ASI » array

VBScript: Overflow error using CInt function

Shawn — Thu, 25 Aug 2011 17:18:05 +0000

Tips & Tricks Series – Overflow error

Ever get an “Overflow error” when using the CInt function? You might encounter this error when you are doing some programming in your test script and doing some data manipulations or calculations. Let’s review an example of a situation that could cause this to happen – a classic example would be if you were processing a file where a number could be rather large. Here is a code snippet where the batch size of a data extract was retrieved and generated the Overflow error:

First thing is that in VBScript it only has one data type called Variant. This can contain either a numeric or string in it and by default it will be a string if there are any other characters in the original value (which is very common). There are sub-types available to use that you can convert a string or Variant to; they can be one of these:

Subtype	Description
Empty	Variant is uninitialized. Value is 0 for numeric variables or a zero-length string (“”) for string variables.
Null	Variant intentionally contains no valid data.
Boolean	Contains either True or False.
Byte	Contains integer in the range 0 to 255.
Integer	Contains integer in the range -32,768 to 32,767.
Currency	-922,337,203,685,477.5808 to 922,337,203,685,477.5807.
Long	Contains integer in the range -2,147,483,648 to 2,147,483,647.
Single	Contains a single-precision, floating-point number in the range -3.402823E38 to -1.401298E-45 for negative values; 1.401298E-45 to 3.402823E38 for positive values.
Double	Contains a double-precision, floating-point number in the range -1.79769313486232E308 to -4.94065645841247E-324 for negative values; 4.94065645841247E-324 to 1.79769313486232E308 for positive values.
Date (Time)	Contains a number that represents a date between January 1, 100 to December 31, 9999.
String	Contains a variable-length string that can be up to approximately 2 billion characters in length.
Object	Contains an object.
Error	Contains an error number.

Typically what you want to do in order to either add numbers together or compare two numbers in a conditional statement is to convert the variable to a numeric integer. The way to do that is using the CInt() function. However if you notice in the table above, an Integer is in the range of -32,768 to 32,767. The problem is if you are working with an integer that is larger than 32,767. Like in this example, if you look at the bottom in the Debug Viewer you will see that the Batch Size is actually 56,989 (which is not a surprise when dealing with data extracts). So this is what is throwing the error because if you look above the error at the test script, you will see on line 103 that CInt is being used. But if you know that a data element could be large, then use CLng() instead. This will convert it to a Long which then accepts a range of -2,147,483,648 to 2,147,483,647 and works fine for our situation.

Now if you look at this second image, notice how line 103 now uses CLng and how we have paused on the next line, there is no error and the batch size is correct at 56,989 and notice the type is now “Long” to the right of the value.

Redim a multi-dimensional array

Shawn — Mon, 25 Jul 2011 11:59:20 +0000

Did you know that when it comes to redimensionalizing a multi-dimensional array in VBScript, you can only redimensionalize the last element (which is the columns) not the first element (which is the rows)? This is true and can be rather annoying and limiting in scope. Unfortunately you are stuck dealing with it so what this means is that you have to either plan out how large you think the array is, or adjust your structure accordingly. What I find is that this is backwards from what I’m used to in other languages and causes me to have to adjust my vision of the array. I usually think of the arrays as being similar to tables in a database where the rows are the dynamic elements (various data records) and the columns are the common data elements I’m tracking; which is also how the data table in QuickTest Pro is structured. For example if we think of profile data I would envision it being like this:

But this doesn’t work if you are populating an array on the fly with data. In this example the data is the rows and this is what you would want to grow; but you can’t resize the row element. So what you really want to do is reverse your layout to make the rows be the fields you are tracking and make the columns your “individual records of data” like in this image (ignore the first column in the image as this is just a label so you know what I’m talking about; it’s not really part of the actual array):

Now keep in mind that this is only an issue when you have to redim an existing multi-dimensional array. However if you know the size of a multi-dimensional array then I would stick to the normal array layout where the rows are data records and the columns are the field elements.

The code that controls this would look similar to something like this:

Dim arrProfileData()

ReDim Preserve arrProfileData(7,1)

arrProfileData(0,0)="Joe"

arrProfileData(0,1)="Mary"

arrProfileData(1,0)="Tester"

arrProfileData(1,1)="Jones"

ReDim Preserve arrProfileData(7,4)

arrProfileData(0,2)="Billy"

...etc

**Note this doesn’t apply to a single-dimensional array. That you can redim any time since it is dealing with only one element.

QTP: Send Outlook Email

Shawn — Fri, 22 Jan 2010 16:32:19 +0000

QuickTest Pro sample code – sending an email using Outlook

This QuickTest Pro code sample shows how you can create a subroutine that will send an email using Microsoft Outlook. The subroutine is defined and can either be placed at the top of your script (must be executed first before it is called in order for the script to know about the subroutine) or it can be placed in a Function Library and associated with the test script.

The reason to use a subroutine is to isolate the process code that creates and sends the Outlook email to a common subroutine in order to take advantage of reuse. This way every time a test script needs to send an email it just needs to have the bottom three lines of code shown below in the code image (lines 35 – 37). It utilizes the “CreateObject” to create an instance of the Outlook application in order to create the actual email. The data used in the email is passed into the subroutine using an array and then each element is referenced within the subroutine code.

Here is the result of sending the email, the email was received and it looks like this:

This is kind of a neat feature that you may find a need for.

In addition to the images above, here is a snippet of the code for easier readability and the ability to copy the code for your own use:





Sub CreateEmail (emailInfo)

Dim objOutl, objMailMsg, objNameSpace, intRecipientCounter, strEmailAddressConst olMailItem = 0      ’ Constants for new items
Const olAppointmentItem = 1
Const olContactItem = 2
Const olTaskItem = 3
Const olJournalItem = 4
Const olNoteItem = 5
Const olPostItem = 6intRecipientCounter=1      ’Start the email address counter at 1Set objOutl=CreateObject (“Outlook.Application”)   ’Create an Outlook object
Set objMailMsg=objOutl.CreateItem(olMailItem)      ’Create a new Outlook mail object
objMailMsg.Recipients.Add(emailInfo(0))         ’Add the email address to the recipient list of the message
objMailMsg.Subject=emailInfo(1)            ’Set the subject of the message
objMailMsg.Body=emailInfo(2)            ’Set the body of the mail message
objMailMsg.Send               ’Send the mail message‘Free up the memory
Set objOutl=Nothing
Set objMailMsg=NothingEnd Sub‘Script code to actually call the subroutine with data to be used in the email that will be sent
Dim emailInfo
emailInfo = Array(“test@hotmail.com”,”Subject: QTP Test email”,”Desc: This is a test email sent by QTP”)
CreateEmail (emailInfo)

Good Luck.