The Automation Expert's Forum

Scripting Batch File: Split String

2012-04-08T08:49:00.000+05:30

Its been a very long time that I have posted something. I was creating certain batch files and came across the requirement of splitting strings and searching for specific strings. I thought of sharing the same to all, so that one can refer and get help in case one needs.

In order to split a string, one can use the FOR loop. The syntax of the command that one may use to split a string is as follows:

FOR /F "" %% IN ("") DO (statement/s)

Set of arguments to be used for splitting a string can be any combination of the below:

delims=xxx : specifies a delimiter set. The default delimiters are space and tab (if not specified).
tokens=x,y,m-n : specifies which tokens from each line are to be passed to the for body for each iteration. This will cause additional variable names to be allocated. The m-n form is a range, specifying the mth through the nth tokens. If the last character in the tokens= string is an asterisk, then an additional variable is allocated and receives the remaining text on the line after the last token parsed.
usebackq : specifies that the new semantics are in force, where a back quoted string (``) is executed as a command and a single quoted string ('') is a literal string command and allows the use of double quotes ("") to quote file names in file-set.

Lets look into some examples now:

a) FOR /F %a in ("Testing this is a very simple task") do @echo %a

The above command would print Testing as output. That means, if you do not specify any argument, it would split the variable and set the value of variable %a as the first fragment.

b) FOR /F "tokens=1-7" %a in ("Testing this is a very simple task") do @echo %a %f %g

The above command would print "Testing simple task" as the output. When we specify the above command with tokens=1-7, it would split the string for each Space and assign it to a variable starting from %a. In detail, the command would set variables with values as follows:
%a = Testing
%b = this
%c = is
%d = a
%e = very
%f = simple
%g = task

In the above command, one can also set numerals as variables. i.e., FOR /F "tokens=1-7" %1 in ("Testing this is a very simple task") do @echo %1 %6 %7 is also a valid command and would return the same output.

c) Now we can use the "delims=" argument to specify any different delimiters based on which the string should be split. For example, the following command splits the string based on delimiter "," (comma).

FOR /F "tokens=1-7 delims=," %a in ("Testing,this,is,a,very,simple,task") do @echo %a %f %g

Output of the command would be same as that in example b.

d) Now, if you want to get a command executed and then split the output string, then use the command string within single back quotes ( '' ). For example, the command

FOR /F "tokens=1-2 delims=." %a in ('dir /b') do @echo %a would return all the file names without their extension.

or else,

one can force the new semantics and then insert the "usebackq" argument and specify the command within back-quotes (``). Example: FOR /F "usebackq tokens=1-2 delims=." %a in (`dir /b`) do @echo %a

e) If you want to parse through a text file and then split strings with delimiters present in the lines, use the command without any quotes. Example: FOR /F "tokens=1-5 delims=," %a in (a.txt) do @echo %a

or else,

one can force the new semantics and then insert the "usebackq" argument and define the file name within double-quotes (""). Example: FOR /F "usebackq tokens=1-5 delims=," %a in ("a.txt") do @echo %a

f) If one uses the new semantics by inserting the "usebackq" argument, and wants to split a string, then the string should be provided between single quotes (''). Example: FOR /F "usebackq tokens=1-5 delims= " %a in ('dir /b') do @echo %a

Microsoft Excel Chart Exporting

2011-01-14T12:25:00.001+05:30

Someone in my company came across a requirement for exporting charts in Microsoft Excel. It was then that he came across some automation for the same. He got a tool for himself, but it was quite buggy and very small in features. It was then that I thought of creating one for myself and what I could see was that there are tools available in the market, but people have kept the code password protected and licensed. I thought of making an excel add-in and making the keeping the code open for use.

I have used the “Sheets ().ChartObjects(i).Chart.Export” to export the charts in excel. Please download the OpenChartExporter add-in here. It is simple to use. Find the steps to install and use the add-in below.

Steps to Install the Add-In:

Download the attachment.
Open Excel, import the addin (Tools --> Add-Ins --> Browse and add the downloaded vba file).
Check the flag against the Add-In OpenChartExporter.
Click OK button and that’s it!

Note: This is a onetime activity to install the add-in

How to Use:

Open the Excel with charts
Press Keys “Control + e” to invoke the menu
Select the target file type, target folder to save the exported image and worksheet whose charts needed to be exported
Select the chart to be exported, or use the “export all” button to export all the charts available within the sheet

One can view the code by opening the Visual Basic Editor (Macro). Hope it helps you!

Mixing multi-dimensional thoughts into Testing

2010-12-11T16:37:00.000+05:30

I was thinking for a solution to the question what should be the team composition to cover the maximum possible test scenarios that can be thought of, while testing an application/product. It was then that the idea of different people testing the same application in different perspectives came into my mind.

Different people always have different personalities and the same leads them look into things in with a different mentality. Once when I asked a person involved in embedded testing whether he wanted to look for a job into the application testing, the guy furiously refused it. I have had a similar experience from another person involved in application testing, regarding website testing. Another incident, which I have come across many a time, is that people get adhered and addicted to the environment that they had been working for a certain time period. There has been many a time that I listened to people complaining about the new work places due to be using some management application, just because they have been comparing it with the application that they used in their earlier company.

What these made me understand is that people become biased to the type of work that they do. If a person is involved in testing a Visual C# Application for some time, he molds his thoughts to such a direction where all applications behave in the same way that the applications he had been working with. This is a common human mentality, because we always make things to become habits.

Now, when I thought of a method in which we combine the efforts of different people who have different skill levels and domain backgrounds, into testing an application along with some who have been testing the application, it let me make some sense. I thought putting together some people from different domains into one test team, which is testing a totally new product, could prove better than a team of common minds. The thoughts and principles that testers from different backgrounds follow are different and this brings in a lot of variety in testing, once these people come together as a team. If a team which is testing a gaming application includes telecom domain testers, web application testers, network testers etc., then the coverage of testing would be overwhelmingly better than one could imagine. Of course, one thing that is implicit is that, it needs each to be good in their respective fields.

I tried this idea practically into one of those projects that we undertook for an IPTV application. That experience boosted my confidence in this ideology to a great extent. We were only a group of two along with the original testers who were involved from the beginning. Both of us had experiences from the past which are of different backgrounds – one a web tester with experience with different domain accounting systems and the other, experienced in embedded telecom devices, banking applications etc. Together, we were able to test the application and make the product owner change the work-flow a couple of times. The main reason, now I understand, is that we, having expertise working in different domains, were able to create and execute diverse scenarios which were unknown to the other fellow testers. Although the product owner had to change his architecture couple of times, this helped him deliver a product in which his clients, with their own test team, couldn’t find a single bug. This resulted in increased confidence of the client on us, helping us to bag some more projects of the same kind.

There are certain things which need care, while we deal with teams including testers from different domains. It is the fact that the team selection needs to be very even; else it may lead to the testing getting diverted into a single way more and the application development getting affected. A good management should always be able to handle this, because this is common with all teams. I would like to try and implement it in a more projects. Mixing and applying multi-dimensional thoughts for testing an application could prove much more worthy than the usual strategies.

Network Testing Utilities and Functions with AutoIT

2010-04-21T19:42:00.001+05:30

This is interesting to a very high level. I came across the networking utilities of AutoIT. The tool has a very good set of network related functions which could be made use in network testing. There are options for sending and receiving packets through AutoIT. Both TCP and UDP messages could be handled with the tool! Interesting, isn’t it?

One can do socket programming with this testing tool. Believe me, you can open a socket, send and receive TCP/UDP packets, Listen on a specific port, do messaging, etc. with AutoIT. If one has the idea, then creating a server is not so tough with this tool! Below listed are the functions which are available with AutoIT for playing around with the Messages. These are other than what I have mentioned in the earlier post, which talked about FTP programming.

TCPStartup – To Start TCP services
TCPConnect – To create a socket and connect to the specified server
TCPSend – Send TCP data on a connected socket
TCPListen – Creates and starts listening on a socket for incoming connections
TCPAccept – Permits an incoming connection on a listening socket
TCPRecv – Receives data from a connected socket
TCPNameToIP – To convert internet name into the IP address
TCPCloseSocket – Closes a TCP socket
TCPShutdown – Shuts down the TCP services on the machine
UDPStartup – To start the UDP services
UDPOpen – Opens and connects a UDP socket to a server
UDPBind – Creates a socket bound to an incoming connection
UDPSend – Send UDP data on a connected socket
UDPRecv – Receives UDP data on a connected socket
UDPCloseSocket – Closes the UDP socket
UDPShutdown – Shuts down the UDP services on the machine

For explanatory purpose, I have created an example of PC-to-PC Messaging system utilizing these functions. It utilizes the TCP messaging functions. There are two codes which I have created, of which one acts as the server and the second as client. The client establishes connection with the server and gets authenticated with a welcome message. There onwards, messages could be exchanged between these two softwares. This is very much similar to a chat engine, and could in fact be used as such, with some little modifications. Please find the executable here. I have also uploaded the Source code, which could be downloaded here.

I will come up with more examples and more on automated testing of UDP based protocols like TFTP. It is really easy and handy to use AutoIT, because it is a very simple function call which needs to be made for all these.

VBScript Type Conversion

2010-03-05T00:38:00.001+05:30

It's very often for people who are interested in VBScripting to encounter the problem of type conversion from string to number. There is no predefined method that could be found to convert the string variable type to numeric.
We can use the "FormatNumber" for the conversion into Float type. But, this case fails if there is an addition operation. For Example: Consider the code below:

Dim Var01, Var02

Var01 = FormatNumber(InputBox("Enter a Number"))
Var02 = FormatNumber(InputBox("Enter another Number"))

MsgBox "Sum is " & Var01 + Var02

The output of this code that one expects would be the sum, to be returned. But if we input values 2 and 3 here, then the output will be displayed as 2.003.00, instead of 5. This is because the effective action which gets performed is string concatenation, rather than addition of two numbers.

Now, how to perform such an action then? Well, we need to adopt a different method in order to achieve this! Just perform an addition of a zero to the Variable, and all goes fine. Now the code should be:

Dim Var01, Var02

Var01 = FormatNumber(InputBox("Enter a Number"))
Var02 = FormatNumber(InputBox("Enter another Number"))
Var02 = Var02 + 0

MsgBox "Sum is " & Var01 + Var02

Now the code works completely fine. This piece of code returns the sum as "5" for inputs 2 and 3.

So the solution for the addition issue is that you add a 0 to the string variable that has been accepted from an input box. Hereby, we can achieve the task of successful type conversion.

FTP with AutoIT - API Programming

2010-02-25T21:30:00.000+05:30

It is really easy to call Win32 API functions through AutoIT. All that one needs to know is how to use the “DllCall” function in AutoIT and the functions which are available in the particular dll that one intends to utilize. In order to create an FTP client, it is really easy if one uses AutoIT. We can make use of the “Wininet.dll” for the sake of creating FTP client software. The functions that are useful for us will be as follows:

InternetOpen
InternetConnect
FtpGetFile
FtpPutFile
FtpFindFirstFile
InternetFindNextFile
InternetCloseHandle

There are many more functions which are available with wininet.dll, but in order to make the Ftp client software, the above mentioned files are more than enough. Now, let me describe the step by step process which needs to be followed in order to do an Ftp get.

Open an Internet Connection – This is to initialize the wininet API. One can use any connection name for achieving this
$InternetOpen = DllCall("wininet.dll", "long", "InternetOpen", "str", “My FTP Control”, "long", 1, "str", “”, "str", “”, "long", 0);We can keep the proxy name and proxy bypass as blank.
Connect to the server with the username and password – One need to have a username and password for the same, as well as the handle returned from the previous step
$InternetConnect = DllCall("wininet.dll", "long", "InternetConnect", "long", $InternetOpen, "str", $ServerName, "int", 0, "str", $Username, "str", $Password, "long", 1, "long", 0, "long", 0); Servername, Username, Password need to be provided.
Start the file transfer with FtpGetFile function – Filename and handle needs to be provided as the inputs
$FTPget = DllCall("wininet.dll", "int", "FtpGetFile", "long", $InternetConnect, "str", $RemoteFile, "str", $SaveLocalFile, "int", 0, "long", 0, "long", 0, "long", 0);This would save the file in the local computer with the name as provided in place of variable $SaveLocalFile.
Close both the handles
$CloseCC = DllCall("wininet.dll", "int", "InternetCloseHandle", "int", $InternetOpen)
$CloseCC = DllCall("wininet.dll", "int", "InternetCloseHandle", "int", $InternetConnect)

That’s all the one needs. The file would be saved in the local machine with the desired name. For more details on the functions in wininet.dll, one can visit http://msdn.microsoft.com/en-us/library/aa385473%28VS.85%29.aspx.

I have created Ftp client software with the same function, and you can download it freely by clicking here.

If you want to access the code, kindly post a request for it through the comments section. I will share the code with anyone who requires.

The importance of settings – A QTP Experience

2010-01-31T23:16:00.002+05:30

It might sound odd, but it is interesting. The settings that need to be made on the tool before starting the automation session, is really important. It becomes more important when we talk about the automation of applications built with complex objects, for example: ActiveX controls.

ActiveX components are nowadays very common in most of the applications that we come across. The automation scripts that we create on our application are meant to be running across different platforms. But many a times, we forget to keep the settings of the tool same in different environments. The result is awful! We end up disturbing the script multiple times at multiple places, and yielding no result.

I shall share one of the experiences that I have faced myself with QTP. It was at this time when we were trying to automate this product which was declared an unfit candidate for automation, by its makers. Now, after the efforts of a day and half, we were in a position where we had one of the most complex parts of this application automated and displayed to the required. But when it came to running the script in a different work station, we failed. QTP threw an “Object Unidentified” error again and again, till we finally figured out what the real issue was! The issue was that, we forgot to set the “Record and run test on any open Windows-based application” option to be selected. Now see, how annoying it is to have missed out such a simple setting, resulting in wastage of a lot of time! So I would certainly advice you to keep a look at the environment settings on the work station that you are about to run your script. Man, the tool settings though simple, are important enough to make your life complex, at times!

File Upload/Download Tests

2010-01-03T15:21:00.002+05:30

Usually software testers find it difficult to create large sized files which are needed for upload/download tests that we normally do. Even if it is a text file that we normally require, the accuracy of the file size becomes the problem. If we require a file of exact size 5 MB, we usually find it difficult to get the size correct. I have tried to solve this issue by creating a File generator. Please find the executable at the location http://www.4shared.com/file/195192377/31cf44bd/DataGenv11.html. This helps in generating text files that are exactly as the size specified, which could be used in your upload/download tests.

HTTP GET and POST methods in VBScript

2009-12-23T00:29:00.000+05:30

We can get the http response of a website with VBScript using XMLHTTP methods. In this post I am including a sample code using which one can use the GET and POST methods on some sample sites.

Option Explicit

Dim FSO, objTextFile, Path, strWebSite

On Error Resume Next
'The Website URL
strWebSite = "http://automationexpertsforum.blogspot.com/"

'Getting the current directory Path into a variable
Path = Replace(Wscript.ScriptFullName, Wscript.ScriptName, "")

'Calling the HTTP Get and Writing the response into text file
Set FSO = CreateObject("Scripting.FileSystemObject")    'Creating File System Object for writing the code into the text file
Set objTextFile = FSO.OpenTextFile(Path & "HTTPGetResponse.txt", 8, True)    'Open the text file
objTextFile.WriteLine Hget(strWebSite)    'Writing the response into the text file
objTextFile.Close    'Close the Text File

'Calling the HTTP Post and Writing the response into text file
Set objTextFile = FSO.OpenTextFile(Path & "HTTPPostResponse.txt", 8, True)    'Open the text file
objTextFile.WriteLine Hpost("http://www.xchangebooks.net/home?destination=node%2F1", "name="&strUsername&"&pass="&strPassword&"&op=Log+in&form_build_id=form-dedc377ad8922e3fa40dc6a80674002c&form_id=user_login_block")    'Writing the response into the text file
objTextFile.Close    'Close the Text File
Set FSO = Nothing    'Release the File System Object

Function Hget(strURL)
Dim objHTTP
Set objHTTP = CreateObject("Microsoft.XMLHTTP")    'Create XML HTTP object for the Get method
objHTTP.Open "GET", strURL, False    'Opening the HTTP get method
objHTTP.Send()    'Sending the request
If Err.Number = 0 And objHTTP.Status = 200 Then    'objHTTP.Status returns the status code of the HTTP Get Request
    Hget = objHTTP.ResponseText    'ResponseText returns the response HTML code in text format
Else
    Hget = "HTTP Error returned! Error Code = " & objHTTP.Status
End If
Set objHTTP = Nothing
End Function    '==> HTTP GET Method

Function Hpost(strURL, strDatatoSend)
Dim objHTTP
Set objHTTP = CreateObject("Microsoft.XMLHTTP")    'Create XML HTTP object for the Post method
objHTTP.open "POST", strURL, False    'Opening the HTTP post method
objHTTP.setRequestHeader "Content-Type", "application/x-www-form-urlencoded"
objHTTP.send strDatatoSend    'Sending the request
If Err.Number = 0 And objHTTP.Status = 200 Then    'objHTTP.Status returns the status code of the HTTP Post Request
    Hpost = objHTTP.ResponseText    'ResponseText returns the response HTML code in text format
Else
    Hpost = "HTTP Error returned! Error Code = " & objHTTP.Status
End If
Set objHTTP = Nothing
End Function    '==> HTTP POST method

Screen Grabber with AutoIT

2009-12-14T23:48:00.000+05:30

There are quite a lot of tools that are really useful. There are a lot of things that we can do with such common automation tools available. AutoIT is one of such tools which are really interesting to learn. I would suggest that anyone with experience in automation, should go through the tool once.

Here I am presenting a screen Grabbing software that I made with the help of AutoIT. Hope that it helps in some way or the other. Download the Screen Grabbing software Here.

Candidates which are suitable for Automation

2009-12-10T20:41:00.000+05:30

It has been always noticed that people are confused about what to automate and when to automate. The main reason that I feel is the inexperience with automation that puts people into such a dilemma. Proper understanding of automation concepts would help one resolve this question. The answer lies in the same old definition of automation. Why do we require automation? In order to reduce manual errors in repetitive and iterative tasks. It proves to be the answer to the question of what needs to be automated as well. Any task that needs to be executed repetitively and iteratively across releases need to be automated.

The reason behind this is the fact that complex iterative tasks become really a factor that could lead to human errors. But such errors are really not acceptable while you are in production releases. The release dates always become a bound on the tester as a matter of time that he can spend on a module or the complete test. This induces the tendency of creating errors in the process. Let me take the example of testing a desktop application. If the tester is manually executing the test cases that he had prepared before the first round of testing, by around the 15th round of testing, the tester would be confident enough about the test cases and steps. Once he faces frequent releases again and again, he might be in a position where some modules would be skipped from testing due to the information that the feature was working in the previous releases, and the chance of breaking is none. But this assumption should not be correct all the times. Believe in me, I have seen functionality breaking after somewhere after 18-20 releases have been passed. Think of the case if it was an automated script that was testing the application. It would not mind if it was the 10th or 100th release. It will still execute the same steps again and again, whenever it is played. This avoids the chance of any issues being propagated through the release due to human errors.

This does not cover everything. Executing Test cases is only one part. There are more aspects of Automation that could be utilized. Whatever process is very time consuming and tedious due to its complexity, is always a good candidate for automation. Consider the example of a product solution, where there are around 25 servers and applications that need to be installed for installing the product. If it takes 4 hours to install a server and bring it live with all applications, then the total effort required would be 100 man hours which is approximately 13 working man days that gets utilized in the process. This certainly is a candidate for automation, and should be automated with immediate effect. A simple automation framework could be utilized, which could perform installation on different server machines, controlled by a single central machine and with little human intervention. This process could be achieved in the count of some hours only. This could save a lot much of effort, and prove worthy enough for the company as well.

So the automation task is regulated by some factors like

Repetition of Testing tasks
Iterations that need to be executed
Complexity of tasks to be performed
Time consumption by the various tasks involved, and so on

At any time, test automation should be made into use, so that the manual effort could be focussed more into finding bugs that exist in the application which are not revealed through test cases.

Keyword Driven Frameworks

2009-12-07T20:55:00.002+05:30

We come across this phrase of Keyword driven frameworks, every time we think of test automation. There are commercial tools that come inbuilt with the keyword driven approach implemented. So what is this Keyword Driven Framework?

In Keyword Driven Frameworks, we design a framework to accept certain keywords as triggers to start the test. It is the Keyword that a tester provides, which drives the test, and hence the name. The main and the most important feature of a Keyword driven framework is its reusability. The same keyword could be used across different applications and platforms.

Consider an example where the test case is for a login web page. While considering a login page, there would be a text field that accepts username, a text field that accepts password and also a Sign In button. A classic Keyword Driven Framework would suggest us to tackle this situation using three keywords – “Open WebPage”, “Enter Values” and “Click”. One needs to write procedures for these three keywords only. The keywords would look somewhat like:

· Open WebPage(“www.yahoo.com”)
· Enter Value(“username”, “tester01”)
· Enter Value(“passwd”, “password”)
· Click(“.save”)

Now, doesn’t it seem like, if we change the url and object ids, for gmail, it would work? Certainly Yes. It needs to work even for any other site as well, till the page technology does not really differ from the normal. So this means that we achieve reusability of the procedures and hence the framework, in a keyword driven approach.

In order to get a better idea, I have added the code for the same. Please find the code section below for the same below:

Call OpenWebPage("http://www.test.com/")
Call EnterValue("Email", "username")
Call EnterValue("Passwd", "password")
Call ClickButton("signIn")

Function OpenWebPage(strURL)
Set IE = CreateObject("InternetExplorer.Application")
IE.Visible = True
IE. Navigate strURL
Do Until IE.ReadyState = 4
    Wscript.Sleep 1000
Loop
End Function

Function EnterValue(strObjName, strValue)
If strObjName <> "" And strValue <> "" Then
    IE.Document.GetElementByID(strObjName).Value = strValue
Else
    MsgBox "Invalid Inputs"
End If
End Function

Function ClickButton(strButton)
If strButton <> "" Then
    IE.Document.GetElementByID(strButton).Click
Else
    MsgBox "Button name is not valid"
End If
End Function

The above code would work for yahoo as well as gmail or any other site. With some more modifications, which includes creating an excel based input test case to read the inputs, and an HTML report to show the results of test case execution. This would make the the process of a keyword driven framework complete, like the one we can find in any commercial tool.

Data Driven Frameworks

2009-11-14T23:08:00.001+05:30

Data Driven frameworks, as the name suggests, are those where the test input data drives the test. There would be data driven scripts which contain a high level of hardcoded areas, with variable data. Hence the data driven scripts are mostly Application Specific. The same framework cannot be used across different applications to test them. This puts a limitation on people adapting data driven frameworks for testing their applications, but these frameworks could be used to perform an exhaustive testing of your application.

Data Driven Frameworks could be therefore defined as a set of application specific scripts which tests and validates the application against application data. Consider the following architecture of a sample framework.

Fig: A Sample Data Driven Framework

Here, the data pool would contain the data necessary for testing the application. This includes both the input data, as well as the data for result analysis. There will be a large amount of Hardcoded part in the script, apart from the varying data input section.

Let me explain this in an easier way. If we design a data driven framework to test a website namely www.google.com, we cannot test another similar website like www.altavista.com with the same framework. The reason behind this is that the scripts that we use will include sections where the object names of the google web page, which are hardcoded in our framework.

Now, let me just show an example where the test case checks the second page for the search keyword. Find the following VBScript code. The code just tests the google search. You can download the code and input file here (http://www.4shared.com/file/152128664/3d731c19/DDF_Sample.html)

The Code:

Dim IE, strTestInput(100), strTestVal, strActualResult, strTextFile, intCount, i

'Setting the Folder Path
Path = Replace(Wscript.ScriptFullName, Wscript.ScriptName, "")

'Reading the inputs from Text File
Set FSO = CreateObject("Scripting.FileSystemObject")
If FSO.FileExists(Path&"testinput.txt") Then
    Set strTextFile = FSO.OpenTextFile(Path&"testinput.txt", 1, True)
    intCount = 0
    Do Until strTextFile.AtEndofStream
        strTestInput(intCount) = strTextFile.Readline
        intCount = intCount + 1
    Loop

    'Performing the Search on Google
    Set IE = CreateObject("InternetExplorer.Application")
    IE.Visible = True
    i = 0
    Do Until i = intCount
        IE.Navigate "www.google.co.in"
            Do Until IE.ReadyState = 4
                Wscript.Sleep 1000
            Loop
        IE.Document.GetElementByID("q").Value = strTestInput(i)
        IE.Document.GetElementByID("btnG").Click
        Wscript.Sleep 3000
        strActualResult = IE.Document.GetElementByID("q").Value

            If StrComp(strActualResult, strTestInput(i)) = 0 Then
                MsgBox "Pass!!"
            Else
                MsgBox "Fail!!"
            End If
        i = i + 1
    Loop

    IE.Quit()
    Set IE = Nothing
Else
    MsgBox "The file "&Path&"testinput.txt"&" does not exist. Please create the file with test inputs before proceeding"
End If

Note: In order to use the code, one should create a text file named “testinput.txt” with the input values.

The fact is that one cannot test another website with this piece of code. The code is specifically for www.google.com. This could be taken as an example of a data driven test script.

What are Automation Frameworks?

2009-10-31T00:00:00.000+05:30

In Simple terms, one can easily define an automation framework as “a platform for conducting automated test design and execution”. The automation framework can be considered as the ground where a tester designs his test case in the form of scripts, and then runs the script or a set of scripts.

There are a number of types of frameworks that we normally come to hear about. Like the common Data-Driven frameworks, Keyword driven frameworks, Hybrid Frameworks, Test Modularity Frameworks etc. What are these frameworks anyway? Why do we have such a number of types of frameworks anyway? What is the best framework that we can use? These might be some among the questions that come into your mind now. Let’s try to solve the questions.

All the types of frameworks, that we come to hear, are basically the way in which one wants to get his automated tests executed. Let me go into detail with a simple example of the windows calculator application.

If the test case is to check 10 + 10 = 20, this could be automated in different ways.

Create an automated script to press “10 + 10 =” – This could be defined as the data driven way. Here the script directly reads the input value as 10 and does the calculation and checks the outputs.
Create a script to read input values from a file and do the processing – This is also a data driven method of automation. Here, although the data is read from a file, the script is created to perform an addition task.
Create functions to press buttons on calculator and pass the values as object names – This is the Keyword Driven way of automation. Here the final script is not restricted to an addition task. It could be used in other cases as well.

From the example above, we can identify that we can create and use different types of frameworks, according to our outlook of the application and method that needed to be followed.

When comparing different frameworks, the keyword driven framework has an upper hand over the other types of framework, because of its ease of use, reusability, maintainability and other uses. Considering the calculator example shown above itself, if we proceed with the data driven approach, there is a limitation of the script being used only for addition test. For conducting a substraction test, one needs to create another script. But this certainly has an advantage in the fact of repeatability. The script can execute at a faster pace than the one created in the Keyword driven approach, when there is a huge amount of data that needs to be used for testing. Here the data is the one which drives the framework. Thus, the data driven approach makes the framework application dependent. This could not be used across applications. It is meant for a specific application only.

But think about the keyword driven framework, where we create and call function to click certain object. In this case, the same function could be re-used for substraction, division as well as other functionalities. Thus, a keyword driven framework could be reused for various functionalities as well as different applications as well. Thus the application/software dependency is removed from automation, when keyword driven approach is adopted.

I will come up with more light on different frameworks and examples in the coming posts.

How to decide on the automation?

2009-10-25T13:38:00.002+05:30

This is an interesting topic to discuss. Testers always find it difficult to find a solution to this problem. Most of the times they go ahead without proper planning about the procedure to be followed in automation, and then end up being in a mess. Proper idea of automation should be put into use for deciding the process that needs to be followed in test automation. Else, one may face a road-block, where it would be difficult to change the procedure, and also cannot proceed forward with the same procedure.

So what are the pre-requisites that one need to have before deciding on test automation? The answer is quite simple. Complete understanding of the application or software that you are proceeding to test. Let me explain it a bit more deeply. The engineer should have confidence regarding the application that he is going to do automation for. He should have the in-and-out idea about the various functionalities that exist in the application. This plays an important role in deciding the type of automation that needs to be performed.

Idea about the development platform is another important aspect that a person needs to have before deciding on automation. If one has idea about that is the language that the application is built in, then he can choose a tool, that is most suited for automating applications made in that language. For example: There are issues that we normally face with automation when dealing with .NET applications, since they may include many third party controls. This makes many a number of tools which are unable to identify the objects embedded in the application, insufficient for automation. So the complexity of the code should be properly understood prior to select an automation tool or framework.
Another important aspect that needs to be taken care before planning automation is the amount of automation that is expected. Although it might not seem to be affecting automation, it certainly is important because it is a deciding factor in choosing the tool that we can utilize for automation. Why should we choose a tool like QTP, when there are very few test cases which need to be automated? So these factors need to be defined well earlier during the planning process of automation itself.

There are other important factors also which decide test automation like tool support, cost of tool, effort required in automation etc. So the proper way should be beginning with a discussion including the various departments involved in the development process taking into consideration all the above mentioned facts.

Why do we need test automation anyway?

2009-10-24T23:11:00.003+05:30

Whenever a software testing is planned and test cases are prepared, one would always have identified certain number of test cases which need to be executed in order to ensure that the functionality is working fine without many bugs. We generally term these test cases as regression test cases.

Whenever there is a new release in a tester’s hand, with some bugs fixed in the code, there certainly is a large chance of the fix affecting another related functionality of the software. This generally is due to the fact that usually coding is based on utilizing reusable functions to a maximum, so that code complexity as well as the size of code could be reduced. This certainly is a boon to the Software Testing industry, and in particular to the Software Test Engineers. This keeps our department busy in the industry, and thereby keeps its position sustained and important in the life of the Software. So Regression testing could be put across in this way – While a bug gets fixed, there are chances that some related functionalities get affected. In order to test this, while planning the tests, we identify a set of test cases that confirm the functionality of the various features and mark them as regression test cases. Regression Testing is testing the software to make sure that the software functionalities are not affected in a new release”. Regression test cases are usually Positive functionality test cases.

So regression test cases are some set of test cases which need to be executed at every test cycle probably, apart from small releases. This makes it repeating tests. While repeating the execution of test cases again and again, there is a high chance and risk of human errors. There can be missing steps in test execution that can lead to major issues getting exposed to the customers. I have seen a situation when a tester passed a test case just quoting that the functionality was working fine in the previous release, and there was a situation when it turned out to be not working when client tried the same. So a manual test execution has a chance of missing test steps. But considering the test case being automated, there is no chance of any step getting missed.

Not only the human errors are the reason in choosing automation against manual, but the efforts required in Manual Testing is too high when compared to Automation for a long term. The charges of automation is a onetime cost, they would well be redeemed, when the same automated tests are executed over a long period, say a year or so. Thereby, it reduces the cost involved in testing.

There are quite a lot of other uses in choosing automation other than the above mentioned, like Automation makes test execution

Faster
Reliable
Reusable
Cost Effective
More Accurate
Maintainable
And so on.

But even with automation, the manual efforts could not be completely excluded at any point of time. Automation Scripts are just a number of steps performed in sequence, nothing else. So at any time in testing, Manual efforts can never be completely replaced by Automation. But certainly, the efforts of manual intervention in repeatable things could be reduced to a very high level with test automation.

Introduction to Blogging

2009-10-24T22:39:00.000+05:30

Hi All,

I am Kishore Krishnan. I am a software test engineer. I have quite a bit of experience in test automation and have worked on many tools. To quote some would be AutoIT, Perl, TCL, Sahi, QTP, TestComplete, Selenium etc. I have designed frameworks with many of the industry available tools as mentioned above.

The idea behind me starting this blog is to share some thoughts that I have with other needy people around the world. I am planning to Issue some interesting concepts about Software Test Automation, Frameworks, Some methodologies to be used to make automation interesting, and so on. I hope that this blog could help atleast some in understanding basic concepts of automation, and also some of tools.

Regards,
Kishore