Hello Friends,

In this post we will discuss about the effective ways to clean up the machine after execution of the scripts.

1.     What is Machine Cleanup Framework?

Machine cleanup framework is a separate module which will be implemented as a functional library within QTP/UFT scripts. This module will enable effective usage of the machine and nightly/automated execution of the script. We must implement this framework, if we plan to integrate our scripts with continuous integration frameworks like Jenkins.

2.     Why Machine Cleanup framework is required?

For a new automation team, priority is to increase the automation coverage as quickly as possible to show more benefits. But what will happen once we have tons of automated scripts in bucket? And the answer to that question is most of the team will spend most of their time for execution of the automated scripts instead of developing new ones. It will become a huge problem if we are not thinking about it when we start.

Solution to the above issue will be, the ability to start nightly executions of the scripts, but to have that ability, scripts must be cleaned up, because a lot of automated scripts will have certain amount of manual interventions. Once we do that, the next big question will be how to make sure that the machine or UFT is ready for the execution.

To be able to do that we have to write the code for killing certain applications closing UFT and taking care of the UFT crashes.

Can we take care of UFT crash? Yes, I can, and by the time you will finish reading this post, you can also.

3.     Implementation

Most of us will think about implementing a machine cleanup framework when it’s too late and they already have thousands of scripts already in place, so here we will take the same case and we will try to implement the code where we don’t have to take care about where to make the function calls.

To implement it. we will create a separate class in a functional library.

Class Environment_Cofig
‘Member variables declaration goes here.
‘Member function definition’s goes here.
End Class

Now, the question is why to implement the class and complicate things, we can simple write functions in the function library, and the answer is, remember a class comes with two inbuilt functions “Constructor” and “Destructor”, which will be called automatically. Constructor will be called automatically when we create the object of the class and destructor will be called when the garbage collector is called for the class. This is exactly we want to do, we want to call a function at the start of the UFT execution to check if the machine is clean and we have to call the same set of functions again at the end of UFT execution.

Now, to see the strength of this kind of framework create a empty test in the UFT and copy the below code in a functional library and associate it with the test.

‘####################################################

Public OEnvironment

Public Function IntializeClass
Set OEnvironment = New Environment_Cofig
End Function

Class Environment_Cofig
‘Constructor of the class
Private Sub Class_Initialize
Msgbox “Class Constructor called”
End Sub

‘Destructor for the class
Private Sub Class_Terminate
Msgbox “Destructor called”
End Sub
End Class

Copy the below code into the action of the test

Msgbox “Test Run Started”

‘Initialize Environment Cleanup class here
IntializeClass

Msgbox “Other stuffs here”

Msgbox “Test Run Ended”
‘####################################################

Run the test and see the sequence of the message boxes. You will notice that the constructor of the class is called as soon as the object is created and destructor of the class is called after the execution ends.

It’s time to see an interesting fact. Now place a break point on the line, where we are displaying the message about other stuffs, and run the test. Now, when the test reaches the break point try to stop the test using the “Stop” button. Test will stop but the destructor will be called, because UFT must release the class object and in the process destructor will be called automatically and that’s the most important feature which we will use while writing the cleanup framework.

Complete implementation should look like this

‘####################################################

Public OEnvironment

Public Function IntializeClass
Set OEnvironment = New Environment_Cofig
End Function

Class Environment_Cofig
‘Constructor of the class, this constructor will be used for any initialization required
Private Sub Class_Initialize
‘Function to check the logs, if any applications were left opened by last UFT execution
‘Function to terminate common applications like word, excel, powerpoint, UFT’s Report viewer, Internet Explorer etc. should be placed here..
‘Set QTP Configurations Here
‘Function to Initialialize application under test should be called here 
Msgbox “Class Constructor called”
End Sub

‘Destructor for the class
‘This function will be called to close any external objects created
Private Sub Class_Terminate
‘Functions to terminate the common and AUT should be placed here
‘Function to delete the open application logs should be placed here
‘Functions for any another miscellaneous tasks like moving results folder to the desired placed should be placed here
Msgbox “Destructor called”
End Sub
End Class

‘####################################################

The most important aspect of this implementation is that the whole framework is implemented and will call the functions automatically just by calling one simple function at the start of the test execution and we don’t have to change any of our existing code to implement the code cleanup functionality.

Important Point : Destructor might not be called if the UFT is killed abruptly by another process, to check that, execute the below command when UFT is at the break point we discussed earlier

taskkill /f /im uft.exe

Replace UFT.exe with QTPro.exe for QTP versions.

After executing this command, UFT will be killed instantly and destructor will not be called and hence to make sure that machine is ready, you have to run the clean up code in constructor also so that machine will be ready before execution.

If you have several hundreds of scripts which handles different types of applications then it will be a good idea to implement an initialize app function within the class, which can have switch cases for the initialization of different types of applications. This function can write logs about the opened applications with their process ID’s. These process ID’s can be used for killing the opened applications by the previous execution.

Let me know, if you have any questions, i will try to answer them.

Thanks,
Sumeet Singh Kushwah