W3C defines a Web service as “a standard means of interoperating between different software applications, running on a variety of platforms and/or frameworks”. In simple terms, a Web service can be used to integrate web applications. In this exchange of data, XML is used to tag data, SOAP is used to transfer data, WSDL is used to describe how data is exchanged and finally, UDDI lists the services available. For further reading, you can visit XML Web Services Basics.

In this topic, we will be using 3 important objects and provide their overview before diving deep into this topic. They are:

1. XMLUtil
2. XMLDOM
3. XMLHTTPRequest

XMLUtil

XMLUtil object provided with QTP is used to access and return XML objects. In other words, XMLUtil can be used to access or expose the contents of an XML file. XMLUtil supports the following 2 methods to create and return an object of type XMLData:

1. CreateXML Method
2. CreateXMLFromFile

More information regarding XMLUtil can be located at QuickTest Professional Object Model Reference.

XMLDOM

Similar to XMLUtil object used in QTP, XMLDOM also provides methods and properties to access and return XML objects. I am more accustomed to using this object as opposed to XMLUtil, but they can be both used interchangeably. For further reading, you can visit A Beginner’s Guide to the XML DOM. To create an instance of XMLDOM, CreateObject must be used.

Set xmlParser = CreateObject("Microsoft.XMLDOM")

XMLHTTPRequest

Unlike XMLUtil and XMLDOM, which are both XML parsers, the XMLHTTPRequest object is an API used to send HTTP or HTTPS requests directly to a Web Server and receiving the response using its Post, Send and Get methods. For further reading, you can visit XMLHttpRequest object. To create an instance of XMLHTTPRequest, CreateObject must be used.

Set XMLHTTPRequest = CreateObject("Microsoft.XMLHTTP")

Google Maps – The Distance Matrix API

The Google Distance Matrix API is a Web service used to provide travel distance and time for travel start (origins) and end points (destinations). The response from the API consists of rows containing data for each origin and destination pair.

To request information from the Distance Matrix API, the following URL with output type and input parameters must be used:

http://maps.googleapis.com/maps/api/distancematrix/output?parameters

Output

Output may be in either JSON or XML. In this topic, XML will be used.

Parameters

There is a total of 7 parameters that can be used to request information back from the API. 4 of these parameters are optional.

1. Origins (required)
2. Destinations (required)
3. Mode (optional)
4. Language (optional)
5. Avoid (optional)
6. Units (optional)
7. Sensor (required)

For more information, you can refer to the Distance Matrix API documentation.

I feel we’ve covered enough basics and its time to dig into exchanging data with the Distance Matrix API and then, parse it to get values we’re concerned with. Below are the values we will be using to request data:

• output = xml
• origins = Atlanta, GA, USA
• destinations = Dallas, TX, USA
• units = imperial (in miles)
• sensor = False

The final URL string:

http://maps.googleapis.com/maps/api/distancematrix/xml?origins=Atlanta+GA+USA&destinations=Dallas+TX+USA&units=imperial&sensor=false

I also computed the distance using the Google Maps UI (maps.google.com) and got the following result. The result below should match the result obtained from XMLHTTPRequest.

Requesting Information from Distance Matrix API

In the following code, XMLHTTPRequest object is used to send the string above and receive the corresponding response from the Distance Matrix API.

url = "http://maps.googleapis.com/maps/api/distancematrix/xml?" & _
		"origins=Atlanta+GA+USA&" & _
		"destinations=Dallas+TX+USA&" & _
		"units=imperial&" & _
		"sensor=false"
 
Set oReq = CreateObject("Microsoft.XMLHTTP")
 
oReq.open "POST", url, False
oReq.send
 
'Response
responseText = oReq.responseText
 
Print responseText

Output

<?xml version="1.0" encoding="UTF-8"?>
<DistanceMatrixResponse>
 <status>OK</status>
 <origin_address>Atlanta, GA, USA</origin_address>
 <destination_address>Dallas, TX, USA</destination_address>
 <row>
  <element>
   <status>OK</status>
   <duration>
    <value>47410</value>
    <text>13 hours 10 mins</text>
   </duration>
   <distance>
    <value>1254681</value>
    <text>780 mi</text>
   </distance>
  </element>
 </row>
</DistanceMatrixResponse>

Simple, isn’t it? Receiving the response is one thing, parsing it for data important to us is another. In the next part, parsing the above XML will be shown using both XMLUtil and XMLDOM objects.

Parsing Information using XMLUtil, XMLDOM

In the last section, we received some data from Google’s Distance Matrix API by using the .responseText method of XMLHTTPRequest. In this section, we will parse the ResponseText to retrieve the time taken and distance of travel. Below are the 2 nodes from the output above we’re concerned with:

DistanceMatrixResponse\row\element\duration\text
DistanceMatrixResponse\row\element\distance\text

I have used the method GetValueByXPath but you can also use ChildElements and ChildElementsByPath methods.

XMLUtil

sNodeDistance = "row/element/distance/text"
sNodeDuration = "row/element/duration/text"
 
Set oParser = XMLUtil.CreateXML()
 
'Note: responseText comes from XMLHTTPRequest in the previous section
oParser.Load responseText
 
'Using the XPath above to retrieve distance
nodeDistance = oParser.GetRootElement.GetValueByXPath(sNodeDistance)
 
'Using the XPath above to retrieve duration
nodeDuration = oParser.GetRootElement.GetValueByXPath(sNodeDuration)
 
Print nodeDistance
Print nodeDuration

Output

With XMLDOM, I have used the method selectSingleNode but you could also use selectNodes, getElementsByTagName etc. to drill down to the target node.

XMLDOM

sNodeDistance = "row/element/distance/text"
sNodeDuration = "row/element/duration/text"
 
Set oParser = CreateObject("Microsoft.XMLDOM")
 
'Note: responseText comes from XMLHTTPRequest in the previous section
oParser.loadXML(responseText)
 
'Distance node: comes from XPath above
Set nodeDistance = oParser.documentElement.selectSingleNode(sNodeDistance)
 
'Duration node: comes from XPath above
Set nodeDuration = oParser.documentElement.selectSingleNode(sNodeDuration)
 
Print nodeDistance.text
Print nodeDuration.text

Output

Summary

In this topic, we saw how to send a request and receive response using XMLHTTPRequest. Later, to parse the response, we used XMLDOM and XMLUtil to retrieve the results.

Over the past few years, I have read numerous threads and posts talking about working with Excel using VBScript. Not only have there been numerous threads, but also frameworks that use Excel as the input and/or driver engine. I wanted to work on this mini-project for a long time, and I finally have Version 1.0 of ExcelUtil ready for download! It comes with .CHM documentation.

I’m quite sure I have missed some methods that the community uses, which I have not been able to include in the 1st version. I, however, am open to suggestions and would gladly include your ideas for Version 2.0.

Download RelevantCodes.ExcelUtil Class Library (1302)

IMPORTANT: To use any method of ExcelUtil, be sure to use SetFile. This will set the Excel WorkBook and WorkSheet ready for use. To use a different WorkBook or WorkSheet, SetFile will have to be called again.

SetFile Property

Value Type

Read only. A [RelevantCodes.ExcelUtil] object.

Description

Sets the region instances for Excel WorkBook and WorkSheet. These instances for the Excel source are created only once and used by other methods. NOTE: For any method to execute, SetFile must be executed first to set the WorkBook and WorkSheet.

Syntax

ExcelUtil.SetFile WorkBookPath, WorkSheet

Examples

'Example 1
ExcelUtil.SetFile "C:\Student.xls", "Sheet1"
 
'Example 2:  Reading value directly from a file
sCellValue = ExcelUtil.SetFile("C:\Student.xls", "Sheet1").GetCellValue(1, 1)
 
'Example 3:  Reading values from 2 different files - Approach 1
ExcelUtil.SetFile "C:\Student.xls", "Sheet1"
var1 = ExcelUtil.GetCellValue(1, 1)
ExcelUtil.SetFile "C:\Teacher.xls", "Sheet1"
var2 = ExcelUtil.GetCellValue(1, 1)
 
'Example 4:  Reading values from 2 different files - Approach 2
var1 = ExcelUtil.SetFile("C:\Student.xls", "Sheet1").GetCellValue(1, 1)
var2 = ExcelUtil.SetFile("C:\Teacher.xls", "Sheet1").GetCellValue(1, 1)

I found a Bug. What should I do next?

Reporting the bug in the comments section will ensure the next version of this class library is more robust! It may not be possible to release the fixed code immediately, but notifying me and the readers of all potential bugs will be highly appreciated! Thank you.

I have something cool I would like you to add to ExcelUtil.

I would love to hear all ideas and suggestions to improve or enhance this library. Please use the comments section to share them with me and the community. Thank you.

Download RelevantCodes.ExcelUtil Class Library (1302)

While testing a script on IE8, me and my colleague kept getting the error “A script on this page is causing Internet Explorer to run slowly”. Below is a snapshot of the error:

After some research, I came across an article on MSDN which already had the solution: Microsoft KB # 175500. The part we are concerned about is in the section “Let me fix it myself”:

1.Using a Registry Editor such as Regedt32.exe, open this key: HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\Styles
Note: If the Styles key is not present, create a new key that is called Styles.
2. Create a new DWORD value called “MaxScriptStatements” under this key and set the value to the desired number of script statements. If you are unsure of what value you need to set this to, you can set it to a DWORD value of 0xFFFFFFFF to completely avoid the dialog.

For the curious ones, the article states that, to encounter the error, the DWord value of 0xFFFFFFFF must be added. The value equates to -1, which is what has been used in the function below.

Code

Sub IE_ChangeScriptTimeOut()
	Dim Registry, sKeyPath, sValueName, dwValue, sComputer
	CONST HKEY_CURRENT_USER = &H80000001
 
	sKeyPath = "Software\Microsoft\Internet Explorer\Styles"
	sValueName = "MaxScriptStatements"
	dwValue = -1
	sComputer = "."
 
	On Error Resume Next
		Set Registry = GetObject("winmgmts:{impersonationLevel=impersonate}!\\" &_ 
				sComputer & "\root\default:StdRegProv")
 
		Registry.CreateKey HKEY_CURRENT_USER, sKeyPath
		Registry.SetDWORDValue HKEY_CURRENT_USER, sKeyPath, sValueName, CLng(dwValue)
	On Error Goto 0
 
	Set Registry = Nothing
End Sub

Thanks for reading, and thanks for visiting Relevant Codes! :)

VBScript’s error handling techniques have been quite limited to On Error statements, and even though they satisfy our needs to some extent, the lack of incorporating dynamic behavior with them has been a much bigger issue. Lee Harvey here shows how Classes can be extended to create simple Try-Catch-Finally statements with just a bit more work. I like this technique, and have been using it for the past few days with success. We know that this is not the best solution that is possible with a scripting language (JS does a lot better!), but its a start and a terrific workaround (thanks Lee!).

Creating Try-Catch-Finally Statements in VBScript

If you have already read Lee’s article, you can skip this part. Otherwise, a simple implementation is shown below:

1. As soon as the class executes, it enters Class_Initialize – Try statement
2. It encounters an error – Err.Raise 1002
3. As soon as it encounters an error, the Try statement (Class_Initialize) immediately ends execution
4. Because we’re releasing the Class reference using Set NewTryCatchFinally = Nothing right after initializing it, the Class enters Class_Terminate
5. Class_Terminate calls the Catch subroutine
6. When Catch runs in its entirety, Class_Terminate executes

On Error Resume Next
 
Class TryCatchFinally
 
    Private Sub Class_Initialize 'Try
        Print "Entering Try.." & vbNewLine
 
        Err.Raise 1002 'Raise a Syntax Error
        MsgBox "This line will not execute"
    End Sub
 
    Private Sub Catch 'Catch
        If Err.Number = 0 Then Exit Sub
 
        Print "Entering Catch.."
        Print "Error caught: " & Err.Description  & vbNewLine
 
        Err.Clear
    End Sub
 
    Private Sub Class_Terminate : Catch 'Finally
        Print "Exiting.." 
    End Sub
 
End Class
 
'Enters Try (Error occurs)
Set NewTryCatchFinally = New TryCatchFinally 
 
'Enters Catch, then Finally
'Catch will only execute if Error occured
Set NewTryCatchFinally = Nothing

The output of executing the above code should be the following:

Try Catch Finally Implementation in VBScript

We can see from the result that as soon as the Class executes, it enters Class_Initialize. When it encounters an error, it enters into Class_Terminate which contains (and executes) the Catch method. A simple yet such an elegant solution!

Utility Class & Error Handler

In this article, I will try to implement the technique with QTP’s GUI objects. To begin, let’s create a simple Login class with the following methods:

1. CheckPage
2. CheckImage
3. Login

The Login Class outputs the result through the Result property:

A simple Login Class

On Error Resume Next
 
Class Login
 
    Public Property Get Result
        Result = CheckPage And CheckImage And Login
    End Property
 
    Private Function CheckPage
        MsgBox "CheckPage" : CheckPage = True
    End Function
 
    Private Function CheckImage
        CheckImage = False
 
        Browser("title:=Welcome.*").WebElement("text:=Relevant Codes").Click 'Error here!

        MsgBox "Error!" 'This will not execute
    End Function
 
    'This will not execute
    Private Function Login
        MsgBox "Login"
    End Function
 
End Class
 
Dim NewLogin : Set NewLogin = New Login

Above, the Result property of the Login Class is called, which first executes CheckPage, then CheckImage and finally Login. Note that Login will only execute if CheckImage runs without any errors.

Let’s create another class that calls the methods of the original Login class, but with the error handling capabilities of a Try-Catch-Finally statement. This is also the Class that will always execute the original Login class because that’s where the actual error handling using Try-Catch-Finally exists.

Try..Catch..Finally with Class_Initialize & Class_Terminate

Class LoginHandler 'LoginHandler start

    Public bResult
 
    Private Sub Class_Initialize
         Print "Entering Try.." & vbNewLine
         bResult = NewLogin.Result
    End Sub
 
    Private Sub CatchErr
        If Err.Number = 0 Then Exit Sub
 
        Print "Entering Catch.."
        Print "Error: " & Err.Description & vbNewLine
 
        Err.Clear
    End Sub
 
    Private Sub Class_Terminate : CatchErr
        Print "Exiting.."
    End Sub
 
End Class 'LoginHandler end

'NewLoginHnder executes the Login Class in 'try'
Set NewLoginHandler = New LoginHandler
 
'Releasing the instances invokes CatchErr, then Class_Terminate()
Set NewLoginHandler = Nothing
 
'Release NowLogin instance
Set NewLogin = Nothing

The Class_Initialize method of the class calls the Result property of the Login class. Once Result is called, it executes all the methods called by the Result property. If any error occurs, CatchErr is immediately called by Class_Terminate and later, all code inside the Class_Terminate method is executed.

Output of executing Login Class & LoginHandler:

QTP Print Log

Method Containing the Error?

By including the name of each method in the very first line, we can also find out where exactly the error occurred. This, however, I agree is quite time consuming and repetitive work. The only alternative to this has been shown by PowerDebug Beta. However, if you would like to extend the above approach in VBScript, this *may be* the only possible approach. I’ve been wrong before, and would love to see a technique which simplifies the method naming approach used below.

Login Class with Method Names

On Error Resume Next
 
Class Login 'Login start

    Public sMethod
 
    Public Property Get Result
        Result = CheckPage And CheckImage And Login
    End Property
 
    Private Function CheckPage
        Me.sMethod = "CheckPage"
 
        MsgBox "CheckPage" : CheckPage = True
    End Function
 
    Private Function CheckImage
        Me.sMethod = "CheckImage"
 
        CheckImage = False
        Browser("title:=Welcome.*").WebElement("text:=Relevant Codes").Click 'Error here!
        
        MsgBox "Error!" 'This will not execute
    End Function
 
    Private Function Login 'This will not execute
        Me.sMethod = "Login"
 
        Msgbox "Login"
    End Function
 
End Class 'Login end
Dim NewLogin : Set NewLogin = New Login

LoginHandler (Outputs Method Names)

Class LoginHandler 'LoginHandler start

    Public bResult
 
    Private Sub Class_Initialize
         Print "Entering Try.." & vbNewLine
         bResult = NewLogin.Result
    End Sub
 
    Private Sub CatchErr
        If Err.Number = 0 Then Exit Sub
 
        Print "Entering Catch.."
        Print "Error occured in: " & NewLogin.sMethod
        Print "Error: " & Err.Description & vbNewLine
 
        Err.Clear
    End Sub
 
    Private Sub Class_Terminate : CatchErr
        Print "Exiting.."
    End Sub
 
End Class 'LoginHandler end

Set NewLoginHandler = New LoginHandler
Set NewLoginHandler = Nothing
Set NewLogin = Nothing

View code.

Output of executing Login Class & LoginHandler:

QTP Print Log

Notes

After using this technique for several days and manipulating it a bit from the original work, I have found some success. However, implementing Handler classes when the scope of the utility class increases can be quite challenging, and time consuming. I still believe its a start to something that we haven’t witnessed in QTP (yet). To be honest, I still prefer the old way of doing things where I can branch out most of my GUI code in conditional statements – which has enabled me to always create more comprehensive reporting.

My recommendation would be to use this approach with VBScript code instead of using it for QTP’s GUI objects, ofcourse, until absolutely necessary. Most of my usage for the above technique has been with pure VBScript code which has enabled me to create better error handling. In an upcoming article, I will show how this technique will be used to handle Excel errors and recover from them in the CatchErr method using a Select Case block. Including Try-Catch-Finally statements within Try-Catch-Finally statements is quite easily done in .NET, but its very complex to perform the same operation with VBScript. I’m still happy to have a start though.

This topic covers the concepts of the Eval function and Execute statement in depth. The function Eval is used to evaluate a string and return the result of the string expression. The Execute statement on the other hand, executes one or more statements in a string expression and enables creation of dynamic code. Multiple statements can be executed at once by using colons or line breaks to separate them.

If you have had a chance to use RelevantCodes[1]One and went over the function libraries, you would find that all the events are controlled through Execute statement – data is retrieved from the Excel Table and parsed by the function libraries into string statements. Once parsed, these string statements are then executed in the same manner as QTP code.

Eval Syntax

Eval(expression)

Execute Syntax

Execute statement

Difference between Eval & Execute

In the syntax above, both expression and statement arguments are string statements. Both expressions can be derived from VBScript or QTP code; the difference lies in the fact that Eval will always return the result of the string evaluation whereas Execute will execute a string statement for execution and will not retrieve the result (but there are workarounds). The following example demonstrates the main difference between the 2 functions:

x = 9
y = 10
 
bIsEqual = Eval("x = y")
Execute "x = y"
 
MsgBox "bIsEqual: " & bIsEqual
MsgBox "X is no longer 9. It is: " & x

Eval Function

Execute Statement

Note that Eval returned a Boolean value whereas Execute function performed a variable assignment. This article will cover the usage of both techniques in depth through both VBS and QTP code.

You must be wondering why the syntax for Eval and Execute is different. The reason is that, Eval is a function. Execute is not. That means, the following statement for Eval: bIsEqual = Eval("x = y"), when written for Execute will return a Null value for bResult (but assignment will be performed for x):

bResult = Execute("x = y")
MsgBox bResult
MsgBox "x: " & x

Null Output

X = 10

With that said, let me share the workaround that can be used with Execute to return the evaluation just like we did with Eval. Here’s how:

x = 9
y = 10
 
Execute "z = (x = y)"
MsgBox "z: " & z

Return Z (False)

More on this concept will be covered in the section Evaluating Statements.

Creating Variables

Let’s assume a scenario where you need to create the following variables: var_1, … , var_5. One way is to manually create the variables:

var_1 = 1 : var_2 = 2 : var_3 = 3 : var_4 = 4: var_5 = 5

A quicker, and more dynamic way to achieve the same is through Execute statement:

For ix = 1 to 5
    Execute "var_" & ix & " = " & ix
Next

Option Explicit

Using the Execute statement also has a direct impact if the Option Explicit statement is ON. If a variable is not explicitly declared, an error will be occurred:

Option Explicit
 
iNumber = 9

When the same variable is created through Execute, the error will not occur and the variable will be created and value assigned successfully.

Option Explicit
 
Execute "iNumber = 9"

Evaluating Statements

Instead of equating variables and values, we will evaluate statements using Eval. A quick example using IsObject is demonstrated below:

Set dicObject = CreateObject("Scripting.Dictionary")
 
If Eval("IsObject(dicObject)") Then
    MsgBox "Object created."
    Set dicObject = Nothing
End If

Similarly, the above code can be broken into a Select Case block and variables can be evaluated by their type:

Sub RetType(ByVal var)
	Select Case Eval("TypeName(var)")
		Case "Integer" : MsgBox "Integer"
		Case "Dictionary" : MsgBox "Dictionary"
		Case "Nothing" : MsgBox "Nothing"
		Case "String" : MsgBox "String"
	End Select
End Sub
 
Call RetType(Nothing)
Call RetType("Test")
Call RetType(CreateObject("Scripting.Dictionary"))
Call RetType(1)

Upon execution, the following results will be retrieved:

RetType(Nothing)

RetType('Test')

RetType(CreateObject)

RetType(1)

The same function above can be written through Execute. However, with Execute, we cannot directly retrieve the result (it is not a function, unlike Eval). Therefore, we will create a variable and store the result with the variable; the variable will then be used as the Select Case condition.

Sub RetType(ByVal var)
	Dim bResult
 
	Execute "bResult = TypeName(var)"
 
	Select Case bResult
		Case "Integer" : MsgBox "Integer"
		Case "Dictionary" : MsgBox "Dictionary"
		Case "Nothing" : MsgBox "Nothing"
		Case "String" : MsgBox "String"
	End Select
End Sub
 
Call RetType(Nothing)
Call RetType("Test")
Call RetType(CreateObject("Scripting.Dictionary"))
Call RetType(1)

In short then, with Execute, bResult is represented within the string statement:

Execute "bResult = TypeName(var)"

With Eval, bResult is an actual variable that holds the result like below:

bResult = Eval("TypeName(var)")

Creating Functions

I have seen this approach rarely used, but its important to know all the possibilities nonetheless. Yes, we can create Functions (really!) at run-time, as long as everything is a string and new lines are separated by colons or a line feed. This approach is generally fine for small functions, but it can get really confusing and hard to debug as the lines of code increase.

sFunc = "Function ExecuteTest"
sFunc = sFunc & vbLf
sFunc = sFunc & "MsgBox ""ExecuteTest executed."""
sFunc = sFunc & vbLf
sFunc = sFunc & "End Function"
 
Execute sFunc
 
Call ExecuteTest()

We can write the same code above using colons (:) as well:

Execute "Function ExecuteTest : MsgBox ""ExecuteTest executed."" : End Function"
 
Call ExecuteTest()

Executing QTP Statements

This is where the Execute statement absolutely shines. As stated before, RelevantCodes[1]One executes all keywords through Execute statement. It retrieves keywords from the Excel Table as strings at runtime, creates the relevant hierarchies, and executes the hierarchies with chosen events. The concept here and the concepts covered by previous examples will remain the same: we create action strings and execute them. The last example in this topic will show how different strings can be joined together to implement events on supplied test-objects (as strings).

Let’s start with a quick example to check if our target browser exists:

strBrowser = "Browser(""title:=Google"")"
 
Execute "MsgBox " & strBrowser & ".Exist(0)"

The above code can also be written with Eval as well, enabling us to retrieve the value directly instead of using the workaround approach if we were to use Execute:

strBrowser = "Browser(""title:=Google"")"
 
bExist = Eval(strBrowser & ".Exist(0)")

The above statement when executed does the same operation as it would when you would verify the browser existence using an inline DP statement: Msgbox Browser("title:=Google").Exist(0). Let’s consider another example where we create an event on a WebEdit object by creating an object hierarchy through strings at run time.

strBrowser = "Browser(""title:=Google"")"  'Browser("title:=Google")
strPage    = "Page(""title:=Google"")"     'Page("title:=Google")
strText    = "WebEdit(""name:=q"")"        'WebEdit("name:=q")
strEvent   = "Set ""Execute Test"""        'Set "Execute Test"

Execute strBrowser & "." & strPage & "." & strText & "." & strEvent

It does look interesting, doesn’t it? The same approach can be used if you are using Object Repository instead of Descriptive Programming; simply replace the Programmatic Descriptions with the Logical Descriptions in your OR, parse everything in a string and Execute it!

The example below shows how QTP code can be executed into succession through strings. The last 4 statements show how all strings are combined together to 1. Enter the search terms, 2. Click Search Button, 3. Synchronize and 4. Navigate back to the Google search page.

strBrowser = "Browser(""title:=.*Google.*"")"      'Browser("title:=Google")
strPage    = "Page(""title:=.*Google.*"")"         'Page("title:=Google")
strText    = "WebEdit(""name:=q"")"                'WebEdit("name:=q")
strButton  = "WebButton(""value:=Google Search"")" 'WebButton("value:=Google Search")
strEvent   = "Set ""Execute Test"""                'Set "Execute Test"
strClick   = "Click"                               'Click
strSync    = "Sync"                                'Sync
strBack    = "Back"                                'Back

Execute strBrowser & "." & strPage & "." & strText & "." & strEvent
Execute strBrowser & "." & strPage & "." & strButton & "." & strClick
Execute strBrowser & "." & strSync
Execute strBrowser & "." & strBack

The above strings are equivalent to the following QTP code:

Browser("title:=.*Google.*").Page("title:=.*Google.*").WebEdit("name:=q").Set "Execute Test"
Browser("title:=.*Google.*").Page("title:=.*Google.*").WebButton("value:=Google Search").Click
Browser("title:=.*Google.*").Sync
Browser("title:=.*Google.*").Back

Closing Remarks

I hope this article has covered most of the common (and uncommon) uses of Eval and Execute. I’m sure you’ll find areas in your framework where these 2 techniques will make things cleaner and more dynamic. If there is something I have omitted, please feel free to share it with us. I hope you guys find this article useful :)

This post shows a quick and easy way to compare 2 Excel files. I know there are several code snippets on forums that show how to compare do this, so you may ask the following question: how is this technique any different? What makes this technique different is performance. I know there may be faster ways to achieve this, but after much experiment, this was the one that continuously worked at the best speed in comparison to other methods.

The main concept of this technique is performing all validations through a range object, instead of traversing all cells of an Excel sheet (which takes a little longer). Below is the skeleton of how the class is arranged, with documentation. Please use one of the download links above to download this class. There is a usage example shown at the end of this article.

Class clsExcelComparer

Class clsComparer
	'[--- Region Private Variables Start ---]

	Private oExcel		'Excel.Application
	Private arrRangeUno	'Range.Value (array) of the Primary Excel spreadsheet
	Private arrRangeDos	'Range.Value (array) of the Secondary Excecl spreadsheet
	Private oDict		'Scripting.Dictionary containing unmatched cells

	'[--- Region Private Variables End ---]

 
	'[--- Region Public Variables Start ---]

	Public Operation	'0: Only Compare   1: Compare & Highlight Differences

	'[--- Region Public Variables End ---]

 
	'--------------------------------------------------------
	' Name: Function Compare [Public]
	'
	' Remarks: N/A
	'
	' Purpose: Compares differences between 2 Excel Spreadsheets
	'	
	' Arguments:
	'	sWorkBookUno: Primary Excel WorkBook (with complete path)
	'	vSheetUno: Primary Excel Spreadsheet Name
	'	sWorkBookDos: Secondary Excel WorkBook (with complete path)
	'	vSheetDos: Secondary Excel Spreadsheet Name
	'
	' Return: Boolean
	'
	' Author: Anshoo Arora, Relevant Codes
	'
	' Date: 03/17/2010
	'
	' References: N/A
	'--------------------------------------------------------
	Public Function Compare(sWorkBookUno, vSheetUno, sWorkBookDos, vSheetDos)
 
	End Function
 
	'--------------------------------------------------------
	' Name: Function CellsFound [Private]
	'
	' Remarks: N/A
	'
	' Purpose: Finds the dissimilar cells between 2 sheets
	'	
	' Arguments: N/a
	'
	' Return: Integer
	'
	' Author: Anshoo Arora, Relevant Codes
	'
	' Date: 03/17/2010
	'
	' References: N/A
	'--------------------------------------------------------
	Private Function CellsFound()
 
	End Function
 
	'--------------------------------------------------------
	' Name: Sub Class_Terminate [Private]
	'
	' Remarks: N/A
	'
	' Purpose: Disposes the Excel.Application object
	'	
	' Arguments: N/A
	'
	' Author: Anshoo Arora, Relevant Codes
	'
	' Date: 03/17/2010
	'
	' References: N/A
	'--------------------------------------------------------
	Private Sub Class_Terminate()
 
	End Sub
 
End Class
 
'--------------------------------------------------------
' Name: Function CompareExcelSheets
'
' Remarks: N/A
'
' Purpose: Constructor for Class clsComparer
'	
' Arguments:
'	sWorkBookUno: Primary Excel WorkBook (with complete path)
'	vSheetUno: Primary Excel Spreadsheet Name
'	sWorkBookDos: Secondary Excel WorkBook (with complete path)
'	vSheetDos: Secondary Excel Spreadsheet Name
'	Operation: 0: Compare Only   1: Compare & Highlight Differences
'
' Return: Boolean
'
' Author: Anshoo Arora, Relevant Codes
'
' Date: 03/17/2010
'
' References: N/A
'--------------------------------------------------------
Function CompareExcelSheets(sWorkBookUno, vSheetUno, sWorkBookDos, vSheetDos, Operation)
 
End Function

Download clsComparer (771) | View clsComparer (722)

Usage (Example)

Consider the following 2 Excel Sheets, with a few dissimilar cells:

Sheet #1 Original

Sheet #2 Original

There are 2 main operations that can be done through our code. 1. We can simply check if both Excel Sheets are similar and 2. we can check as well as highlight the differences between the two. To only compare the 2 sheets, without highlighting the differences the Operation argument will have a value of 0. On the other hand, to compare as well as highlight the values, the Operation argument will have a value of 1. Let’s first consider a case where the 2 sheets are only to be compared:

Compare Only

'Only Compare:
MsgBox CompareExcelSheets("C:\Test1.xls", "Sheet1", "C:\Test2.xls", "Sheet1", 0)

Because the 2 sheets are not similar, the following will be the output upon execution of the above statement:

Compare Only

Also, the 2 sheets will remain unchanged.

When changing the value of Operation to 1, we will notice that, not only does the code compare the 2 sheets, but also highlights the differences.

Compare and Highlight Differences

'Compare and highlight differences:
MsgBox CompareExcelSheets("C:\Test1.xls", "Sheet1", "C:\Test2.xls", "Sheet1", 1)

Upon execution of the above statement, the following 2 sheets will be highlighed in areas where they differ:

Sheet #1 With Highlighted Differences

Sheet #2 with Highlighted Differences

Limitations

1. This code will work with Excel Sheets with the same number of rows and columns in each (like ranges).

Update: RelevantCodes.Comparer COM DLL

Download RelevantCodes.Comparer

Snapshot of the assembly can be found here.

To register the assembly to your PC, the following code can be used:

RegAsm C:\RelevantCodes.dll /codebase

or

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\RegAsm.exe C:\RelevantCodes.dll /codebase

Once done, the code can be used in QTP like this:

Set oCompare = CreateObject("RelevantCodes.Comparer")

oCompare. should give you the proper intellisense to use all methods. The assembly compares the following items:

1. Arrays
2. Excel Sheets
3. Images
4. Integers
5. Strings
6. TextFiles

I hope you find this useful :)

This article discusses 2 ways of sending e-mail from your Yahoo, Hotmail, Gmail, Live or AOL e-mail accounts using the ‘EmailSender’ class:

1. Calling the Method with the Body Message
2. Retrieve body-messages from text files

This can be quite handy during regression cycles – you can use this code to send yourself an e-mail whenever a step in the test process fails. You can even keep a count of the number of times this procedure executes in your script and even stop your test if too many steps fail.

Calling the Method with the Body Message

The code snippets below shows the syntax to send an HTML and plain text e-mails:

'TEXT
SendMail "myEmailID@AOL.com", "myPassword", "recipient@Gmail.com", _
        "", "Subject", "Hello, this is a test mail."

'HTML
SendMail "myEmailID@AOL.com", "myPassword", "recipient@Gmail.com", "", _
        "Subject", "<h1>Hello</h1><p>Test Mail</p>"

Retrieve body-messages from text files

You can create a text file with the body message, and use the file path in the method to send the e-mail. Below is an example of an HTML body inserted into a text file:

SendMailFromFile "myEmailID@AOL.com", "myPassword", "recipient@Gmail.com", "", _
        "Subject", "C:\MyTestMail.txt"

Sample Text File

Similarly, mails can be sent to multiple recipients using “;” between Recipient’s emails. Example:

SendMail "myEmailID@AOL.com", "myPassword", "recipient1@Gmail.com;recipient2@Yahoo.Com", _
    "CC@YouCC.Com;CC@MeCC.Com", "Test Subject", "Test Message"

You can find the download links to this class towards the end of this post.

Code: Class SendMail

Class EmailSender
 
'#region Public Variables

    Public Body  'Message body
    Public From  'Sender's EmailID

 
'#region Private Variables

    Private CDOMessage  'CDO.Message Object
    Private strFrom     'Sender's Email ID: XX@YY.COM
    
 
'#region Public Methods
    
    ' Purpose: Send Email Using CDO
    ' Args:
    '    sEmailID: Sender's Mail ID String
    '    sPassword: Sender's Password String
    '    sTo: Recipient's Mail ID String (Primary)
    '    sCC: Recipient's Mail ID String (CC)
    '    sSubject: Subject String
    '    sBody: Body Message String
    Public Sub Send(sEMailID, sPassword, sTo, sCC, sSubject, sBody)
        Dim oRegExp     'RegEx Object
        Dim sDetails    'Report Details
        Dim intStatus   'Report Status
        Dim sStepName   'Report Step

        Me.From = sEmailID
        intStatus = micPass
        sStepName = " Sent"
 
        Set oRegExp = New RegExp
        oRegExp.Global = True
        oRegExp.Pattern = "<\w>|<\w\w>|<\w\d>"
        Set oMatches = oRegExp.Execute( Me.Body )
 
        'Build Message
        With CDOMessage
            .Subject = sSubject
            .From = sEmailID
            .To = sTo
            .CC = sCC
            '.BCC = sBCC  'BCC Property can be added as well
            
            'If HTML Tags found, use .HTMLBody
            If oMatches.Count > 0 Then
                .HTMLBody = Me.Body
            Else
                .TextBody = Me.Body
            End If
        End With
 
        Set oMatches = Nothing
        Set oRegExp = Nothing
 
        With CDOMessage.Configuration.Fields
            'Sender's Mail ID
            .Item("http://schemas.microsoft.com/cdo/configuration/" &_
            "sendusername") = sEmailID
            'Sender's Password
            .Item("http://schemas.microsoft.com/cdo/configuration/" &_
            "sendpassword") = sPassword
            'Name/IP of SMTP Server
            .Item("http://schemas.microsoft.com/cdo/configuration/" &_
            "smtpserver") = cdoSMTPServer
            'Server Port
            .Item("http://schemas.microsoft.com/cdo/configuration/" &_
            "smtpserverport") = cdoOutgoingMailSMTP
            'Send Using: (1) Local SMTP Pickup Service (2) Use SMTP Over Network
            .Item("http://schemas.microsoft.com/cdo/configuration/" &_
            "sendusing") = cdoSendUsing
            'Authentication Used: (1) None (2) Basic (3) NTLM
            .Item("http://schemas.microsoft.com/cdo/configuration/" &_
            "smtpauthenticate") = cdoAuthenticationType
            'SMTP Server Requires SSL/STARTTLS: Boolean
            .Item("http://schemas.microsoft.com/cdo/configuration/" &_
            "smtpusessl") = cdoUseSSL
            'Maximum Time in Seconds CDO will try to Establish Connection
            .Item("http://schemas.microsoft.com/cdo/configuration/" &_
            "smtpconnectiontimeout") = cdoTimeout
            'Update Configuration Entries
            .Update
        End With
 
        'Report Details
        sDetails = "SMTP Server: " & cdoSMTPServer & vbLf
        sDetails = sDetails & "Sender: " & sEMailID & vbLf
        sDetails = sDetails & "Recipient: " & sTo & vbLf
        sDetails = sDetails & "Server Port: " & cdoOutgoingMailSMTP & vbLf
        sDetails = sDetails & "SSL Used: " & cdoUseSSL & vbLf
        sDetails = sDetails & "Authentication Type: " & cdoAuthenticationType & vbLf
        sDetails = sDetails & "SMTP Service Type: " & cdoSendUsing & vbLf & vbLf
        sDetails = sDetails & "Subject: " & sSubject & vbLf & vbLf
        sDetails = sDetails & "Body: " & sBody
 
        On Error Resume Next
            CDOMessage.Send  'Send Message
            
            If Err.Number <> 0 Then
                intStatus = micFail
                sStepName = " Not Sent"
                sDetails = sDetails & vbLf & "Error Description: " & Err.Description
            End If
        On Error Goto 0
 
        'If you're not using QTP, please disable the statement below:
        Reporter.ReportEvent intStatus, "EMail" & sStepName, sDetails
    End Sub
 
    ' Purpose: Loads BodyText from a Text File
    ' Args:
    '    sCompleteFilePath: Complete Path to the Text File (Eg: "C:\MyDocs\MyMail.txt")
    Public Property Let LoadBodyMessage( sCompleteFilePath ) 'ReadOnly Property LoadBodyMessage
        CONST ForReading = 1 
        Dim oFSO, oFile
 
        Set oFSO = CreateObject( "Scripting.FileSystemObject" )
        Set oFile = oFSO.OpenTextFile( sCompleteFilePath, ForReading )
        Me.Body = oFile.ReadAll
        oFile.Close: Set oFile = Nothing
 
        Set oFSO = Nothing
    End Property
 
 
'#region Private Gets

    ' Purpose: Readonly property configuration for SMTP Service'
    ' Return: Integer
    Private Property Get CDOSendUsing  'As Integer
        CDOSendUsing = 2    'Use SMTP Over The Network
        'CDOSendUsing = 1    'Use Local SMTP Service Pickup Directory
    End Property
 
    ' Purpose: Maximum time in seconds CDO will try to establish a connection
    ' Return: Integer
    Private Property Get CDOTimeout  'As Integer
        'CDOTimeout = 15    'Seconds
        CDOTimeout = 45    'Seconds
        'CDOTimeout = 75    'Seconds
    End Property
 
    ' Purpose: Type of Authentication to be used
    ' Return: Integer
    Private Property Get CDOAuthenticationType  'As Integer
        'CDOAuthenticationType = 0    'No Authentication
        CDOAuthenticationType = 1    'Basic Authentication
        'CDOAuthenticationType = 2    'NTML Authentication
    End Property
 
    ' Purpose: Server Port
    ' Return: Integer
    Private Property Get CDOOutgoingMailSMTP  'As Integer
        If InStr(1, Lcase(Me.From), "@gmail") <> 0 Then
            CDOOutgoingMailSMTP = 465
        ElseIf InStr(1, LCase(Me.From), "@aol") <> 0 Then
            CDOOutgoingMailSMTP = 587
        Else
            CDOOutgoingMailSMTP = 25
        End If
    End Property
 
    ' Purpose: Name/IP of SMTP Server
    ' Return: Integer
    Private Property Get CDOSMTPServer  'As String
        If InStr(1, LCase(Me.From), "@yahoo") <> 0 Then
            CDOSMTPServer = "smtp.mail.yahoo.com"
        ElseIf InStr(1, LCase(Me.From), "@gmail") <> 0 Then
            CDOSMTPServer = "smtp.gmail.com"
        ElseIf InStr(1, LCase(Me.From), "@hotmail") <> 0 Or _
               InStr(1, LCase(Me.From), "@live") <> 0 Then
            CDOSMTPServer = "smtp.live.com"
        ElseIf InStr(1, LCase(Me.From), "@aol") <> 0 Then
            CDOSMTPServer = "smtp.aol.com"
        End If    
    End Property
 
    ' Purpose: Setting for SMTP Server's use of SSL (Boolean)
    Private Property Get CDOUseSSL  'As Boolean
        CDOUseSSL = True
 
        If InStr(1, LCase(Me.From), "@aol") <> 0 Then
            CDOUseSSL = False
        End If
    End Property
 
 
'#region Initialization and Termination
    
    Private Sub Class_Initialize()
        Set CDOMessage = CreateObject("CDO.Message")
    End Sub
 
    Private Sub Class_Terminate()
        Set CDOMessage = Nothing
    End Sub
 
End Class

Code: Function SendMail

' Purpose: Sends an Email Using CDO to a recipient
' Args:
'    sEmailID: Sender's Mail ID String
'    sPassword: Sender's Password String
'    sTo: Recipient's Mail ID String
'    sSubject: Subject String
'    sBody: Body Message String
Public Sub SendMail(EmailID, Password, Recipient, CC, Subject, Body)
    Dim oEmailSender : Set oEmailSender = New EmailSender
 
    With oEmailSender
        .Send EmailID, Password, Recipient, CC, Subject, Body
    End with 
End Sub

Code: Function SendMailFromFile

' Purpose: Sends an Email Using CDO to a recipient
' Args:
'    sEmailID: Sender's Mail ID String
'    sPassword: Sender's Password String
'    sTo: Recipient's Mail ID String
'    sSubject: Subject String
'    sCompleteFilePath: Text File containing the Body Message
Public Sub SendMailFromFile(EmailID, Password, Recipient, CC, Subject, sCompleteFilePath)
    Dim oEmailSender : Set oEmailSender = New EmailSender
 
    With oEmailSender
        .LoadBodyMessage = sCompleteFilePath
        .Send EmailID, Password, Recipient, CC, Subject, ""
    End with 
End Sub

You can use this code as a .VBS file, but, please remember to remove/comment the Reporter.ReportEvent statement on Line 113.

I recently received the following question in my mailbox yesterday: Is it possible to retrieve the text of a page without physically opening it?

Yes, it’s possible to retrieve the document text without physically opening the page. It can be done though an XMLHTTP Request. XMLHTTP is short for Extensible Markup Language HyperText Transfer Protocol. “The XMLHttpRequest object implements an interface exposed by a scripting engine that allows scripts to perform HTTP client functionality, such as submitting form data or loading data from a server.”¹

In the snippet below, I’ve created a simple mechanism to retrieve server response from this blog. The ‘OPEN’ method is used to assign a method (GET, POST, HEAD) of the pending request. The ‘SEND’ method sends the request (as detailed in the Open method) to the server.

Dim oXMLHTTP
 
Set oXMLHTTP = CreateObject("Microsoft.XMLHttp")
 
With oXMLHTTP
    .open "GET", "http://www.relevantcodes.com", False
    .send
 
    Reporter.ReportEvent micInfo, "Status", .statusText
    Reporter.ReportEvent micInfo, "Response", .responseText
End with
 
Set oXMLHTTP = Nothing

XMLHTTP Request Status

XMLHTTP Request Response

References

1. The XMLHTTPRequest Object
2. The XMLHTTPRequest Object

There are several ways to return multiple values from functions. In this topic, we’re going to look over the 5 most common techniques to pass 2 or more values from functions. The 5 techniques are:

1. Returning variables in Global scope
2. Returning a Collection
3. Returning Arrays
4. Using Concatenated Strings
5. Passing through the use of ByRef

Returning variables in Global scope

This can be achieved by declaring the variables outside the scope of the function. Here, we don’t need to pass the values through the function; but we can simply manipulate them within the function’s scope. Please note that if the same string is declared within the function, it loses its global scope – as it becomes local to the function. These variables can come from a function library or from the test script as long as they are outside the scope of the calling method. Code snippet:

Dim intNumber_1: intNumber_1 = 40
Dim intNumber_2: intNumber_2 = 80
 
Public Sub PassValues
    intNumber_1 = intNumber_1/4
    intNumber_2 = intNumber_2/4
End Sub
 
PassValues
 
MsgBox "intNumber_1 = " & intNumber_1 &_
    vbLf & "intNumber_2 = " & intNumber_2

Demo

Returning a Collection

Another way to pass multiple values from a function is through the using of creating and passing Collections. We can use a collection object to store multiple values as keys/items. Code snippet:

Public Function PassValues(ByVal Num_1, ByVal Num_2)
    Set oDict = CreateObject( "Scripting.Dictionary" )
 
    With oDict
        .Add "Num_1", Num_1/4
        .Add "Num_2", Num_2/2
    End With
 
    Set PassValues = oDict
End Function
 
Set colNumbers = PassValues(40,80)
 
MsgBox "intNumber_1 = " & colNumbers.Item("Num_1") &_
    vbLf & "intNumber_2 = " & colNumbers.Item("Num_2")

Demo

Returning Arrays

This is quite a common technique. Each element in the array stores a variable that is then passed through the function. Code snippet:

Public Function PassValues(ByVal Num_1, ByVal Num_2)
    Dim arrArray: ReDim arrArray(2)
 
    arrArray(0) = Num_1/4
    arrArray(1) = Num_2/2
 
    PassValues = arrArray
End Function
 
arrNew = PassValues(40,80)
 
MsgBox "intNumber_1 = " & arrNew(0) &_
    vbLf & "intNumber_2 = " & arrNew(1)

Demo

Concatenated Strings

I have seen the usage of this technique almost as frequently as the use of arrays. Here, two or more concatenated numbers/strings can be passed through the function with the help of a delimiter. Code snippet:

Public Function PassValues(ByVal Num_1, ByVal Num_2)
    Num_1 = Num_1/4
    Num_2 = Num_2/2
 
    PassValues = Num_1 & "," & Num_2
End Function
 
sNum = PassValues(40,80)
 
MsgBox "intNumber_1 = " & Split(sNum, ",")(0) &_
    vbLf & "intNumber_2 = " & Split(sNum, ",")(1)

Demo

Note above that, concatenated string was passed, it must be broken by using one of the delimiting techniques (split, left, right etc.)

Using ByRef to Pass Multiple Values

Please refer to the article Passing Parameters ByRef and ByVal for a detailed explanation of this technique. It can be used to pass multiple values in the following manner:

Dim intNumber_1: intNumber_1 = 40
Dim intNumber_2: intNumber_2 = 80
 
Public Sub PassValues(ByRef Num_1, ByRef Num_2)
    Num_1 = Num_1/4
    Num_2 = Num_2/2
End Sub
 
PassValues intNumber_1, intNumber_2
 
MsgBox "intNumber_1 = " & intNumber_1 &_
    vbLf & "intNumber_2 = " & intNumber_2

Demo

I hope you found this article helpful. Thanks for visiting Relevant Codes :)

In VBScript, there are two ways values can be passed: ByVal and ByRef. Using ByVal, we can pass arguments as values whereas with the use of ByRef, we can pass arguments are references. This is the obvious bit, but, how do these 2 differ in practice?

Let’s find out!

Passing Parameters By Value

Consider the following code snippet:

Function GetValue( ByVal var )
    var = var + 1
End Function
 
Dim x: x = 5
 
'Pass the variable x to the GetValue function ByVal
GetValue x
 
MsgBox "x = " & x

When you run the block of code above, you will get the following output:

In other words, when we passed the variable ‘x’ (ByVal) to the function ‘GetValue’, we were simply passing a copy of the variable ‘x’. When GetValue executes, ‘var’ stores a copy of the variable ‘x’ and increments itself by 1. Therefore, because what we are passing to GetValue is a copy of ‘x’, it cannot be modified.

Now, let’s look at another way of passing variables: By Reference.

Passing Parameters By Reference

Consider the following code snippet that takes arguments ByReference:

Function GetReference( ByRef var )
    var = var + 1
End Function
 
Dim x: x = 5
 
'Pass the variable x to the GetReference function ByRef
GetReference x
 
MsgBox x

You must already be aware what’s going to happen when the above code is executed. Let’s see the snapshot:

Yes, variable ‘x’ was increment by 1. But why was ‘x’ incremented? Only ‘var’ must have incremented by 1, and not ‘x’? Well, that is the core concept behind passing variables by reference.

When the function ‘getReference’ executes, ‘var’ becomes a reference of ‘x’, and therefore, any changes made to ‘var’ would impact ‘x’. So if var increments itself by 1, so would x. If var becomes 0 (zero), so would x.

Let’s see another example:

Function GetReference( ByRef arrArray )
    ReDim Preserve arrArray(UBound(arrArray)+1)
    arrArray(UBound(arrArray)) = 2
End Function
 
Dim newArray: newArray = Array(0, 1)
GetReference newArray

Will the size of ‘newArray’ increase? Let’s see:

' new size: 2
MsgBox UBound(newArray)
 
' new elements: 0, 1, 2
For x = LBound(newArray) To UBound(newArray)
    MsgBox newArray(x)
Next

Since ‘newArray’ was passed as a reference to the GetReference function, the change made to ‘arrArray’ was reflected upon ‘newArray’ as well. Thus, sizes of both arrays incremented by 1.

Is there a way to pass variables byRef and still avoid this? Yes, there is. The answer lies in passing temporary variables (see footnotes below).

ByRef & Temporary Variables

The advantage of using this approach is that you can pass temporary variables to n number of functions accepting arguments as reference, without having the base (original) variables modified. This is a good (and recommended) approach, since your original variables stay intact and you do not lose track of them when working with extensive function libraries. Please see a simple demonstration of this approach below:

Function GetReference( ByRef var )
 var = var + 1
End Function
 
Dim x: x = 5
Dim y: y = x
 
GetReference y
 
MsgBox x   'Returns 5 (x remains unchanged)
MsgBox y   'Returns 6

Above, you will notice that as y became a temporary variable and was passed to GetReference, only it was modified. The variable x was unchanged. Thus, it’s recommended to use temporary variables when passing variables as reference.

Summary

• (ByVal) Arguments do not change when passed by value.
• (ByRef) If the function parameter is modified, it will have the same impact on the parameter that was passed by reference.
• (ByRef) Because the passed parameters can be changed, we can pass multiple values from functions.
• (ByRef) In a huge function library, it can be hard to tell where the value was changed and what function the variable was supposed to perform.

* Credits go to Christopher J. Schärer for pointing out the error in this statement.