Saturday, July 25, 2009

Recording modes in QTP?

'analog
Analog recording mode records exact mouse and keyboard operations. The track of the operations recorded are stored in an external data file.

Desktop.RunAnalog "Track1" 'event for clicking a button
Desktop.RunAnalog "Track2" 'event for setting text in a text box

'low level
Window("Login").WinObject("Help").Click 9,9 'event for clicking a button
Window("Login").WinObject("Agent Name:1").Click 90,5 'event for setting text in a text box
Window("Login").WinObject("Agent Name:1").Type "gopi" 'event for setting text in a text box

X Optional. An Integer value. The x-coordinate of the click. Note that the specified coordinates are relative to the upper left corner of the object. Default = micNoCoordinate (-9999) -- center of the object.

Y Optional. An Integer value. The y-coordinate of the click. Note that the specified coordinates are relative to the upper left corner of the object. Default = micNoCoordinate (-9999) -- center of the object.

alternative for a wait statement in QTP?

Using Exist Method.

Ex:Browser("title:=.*").Page("title:=.*").Link("name:=OK").Exist(2)

It will wait up to specified time(2sec) when object does not exist.

or increase the global synchronization point

or use WaitProperty

or use Sync() method

Some important properties in QTP?

Property Name Description :

abs_x The object's absolute x-coordinate (left) relative to the screen (in pixels).
abs_y The object's absolute y-coordinate (top) relative to the screen (in pixels).
width The object's width (in pixels).
height The object's height (in pixels).
x The object's x-coordinate (left) relative to the parent window (in pixels).
y The object's y-coordinate (top) relative to the parent window (in pixels).

Wednesday, July 22, 2009

Difference Between Execute() statement and Eval() statement in QTP ?

Eval()
Evaluates an expression and returns the result.

syntax:[result = ]Eval(expression)

result :
Optional. Variable to which return value assignment is made. If result is not specified, consider using the Execute statement instead.

expression :
Required. String containing any legal VBScript expression.


In VBScript, x = y can be interpreted two ways. The first is as an assignment statement, where the value of y is assigned to x. The second interpretation is as an expression that tests if x and y have the same value. If they do, result is True; if they are not, result is False. The Eval method always uses the second interpretation, whereas the Execute statement always uses the first.

Sub GuessANumber

Dim Guess, RndNum
RndNum = Int((100) * Rnd(1) + 1)
Guess = CInt(InputBox("Enter your guess:",,0))
Do
If Eval("Guess = RndNum") Then
MsgBox "Congratulations! You guessed it!"
Exit Sub
Else
Guess = CInt(InputBox("Sorry! Try again.",,0))
End If
Loop Until Guess = 0

End Sub

Execute( ) Statement in QTP?

Executes one or more specified statements.

Execute statement
The required statement argument is a string expression containing one or more statements for execution. Include multiple statements in the statement argument, using colons or embedded line breaks to separate them.

*********
In VBScript, x = y can be interpreted two ways. The first is as an assignment statement, where the value of y is assigned to x. The second interpretation is as an expression that tests if x and y have the same value. If they do, result is True; if they are not, result is False. The Execute statement always uses the first interpretation, whereas the Eval method always uses the second.


Note In Microsoft® JScript™, no confusion exists between assignment and comparison, because the assignment operator (=) is different from the comparison operator(==).
The context in which the Execute statement is invoked determines what objects and variables are available to the code being run. In-scope objects and variables are available to code running in an Execute statement. However, it is important to understand that if you execute code that creates a procedure, that procedure does not inherit the scope of the procedure in which it occurred.

Like any procedure, the new procedure's scope is global, and it inherits everything in the global scope. Unlike any other procedure, its context is not global scope, so it can only be executed in the context of the procedure where the Execute statement occurred. However, if the same Execute statement is invoked outside of a procedure (i.e., in global scope), not only does it inherit everything in global scope, but it can also be called from anywhere, since its context is global. The following example illustrates this behavior:

Dim X ' Declare X in global scope.
X = "Global" ' Assign global X a value.
Sub Proc1 ' Declare procedure.
Dim X ' Declare X in local scope.
X = "Local" ' Assign local X a value.
' The Execute statement here creates a
' procedure that, when invoked, prints X.
' It print the global X because Proc2
' inherits everything in global scope.
Execute "Sub Proc2: Print X: End Sub"
Print Eval("X") ' Print local X.
Proc2 ' Invoke Proc2 in Proc1's scope.
End Sub
Proc2 ' This line causes an error since
' Proc2 is unavailable outside Proc1.
Proc1 ' Invoke Proc1.
Execute "Sub Proc2: Print X: End Sub"
Proc2 ' This invocation succeeds because Proc2
' is now available globally.
The following example shows how the Execute statement can be rewritten so you don't have to enclose the entire procedure in the quotation marks:

S = "Sub Proc2" & vbCrLf
S = S & " Print X" & vbCrLf
S = S & "End Sub"
Execute S

------------------example-------------------------------------------

var1="func1"
execute("func1()") 'output is Hi func2
execute(var1) 'output is Hi func2
execute("Call (" & var1 & ")" ) ''output is Hi func2
eval("func1()") 'output is Hi func2.but always prefer execute statement if there is no return value

assume function library will be like mentioned below..
function func1()
msgbox "Hi func1"
end function
function func1()
msgbox "Hi func2"
end function

Tuesday, July 21, 2009

Regular expressions in QTP?

Regular expressions are mathematical expressions used to match the patterns of property values while running the scripts.
(or)
Regular expressions are used to generalize the required property values based on the requirement.
(or)

A regular expression is a pattern of text that consists of ordinary characters (for example, letters a through z) and special characters, known as metacharacters. The pattern describes one or more strings to match when searching a body of text. The regular expression serves as a template for matching a character pattern to the string being searched.

Here are some examples of regular expression you might encounter:

JScript VBScript Matches
/^\[ \t]*$/ "^\[ \t]*$" Match a blank line.
/\d{2}-\d{5}/ "\d{2}-\d{5}" Validate an ID number consisting of 2 digits, a hyphen, and another 5 digits.
/<(.*)>.*<\/\1>/ "<(.*)>.*<\/\1>" Match an HTML tag.

The following table contains the complete list of metacharacters and their behavior in the context of regular expressions:

Character Description
\ Marks the next character as either a special character, a literal, a backreference, or an octal escape. For example, 'n' matches the character "n". '\n' matches a newline character. The sequence '\\' matches "\" and "\(" matches "(".
^ Matches the position at the beginning of the input string. If the RegExp object's Multiline property is set, ^ also matches the position following '\n' or '\r'.
$ Matches the position at the end of the input string. If the RegExp object's Multiline property is set, $ also matches the position preceding '\n' or '\r'.
* Matches the preceding subexpression zero or more times. For example, zo* matches "z" and "zoo". * is equivalent to {0,}.
+ Matches the preceding subexpression one or more times. For example, 'zo+' matches "zo" and "zoo", but not "z". + is equivalent to {1,}.
? Matches the preceding subexpression zero or one time. For example, "do(es)?" matches the "do" in "do" or "does". ? is equivalent to {0,1}
{n} n is a nonnegative integer. Matches exactly n times. For example, 'o{2}' does not match the 'o' in "Bob," but matches the two o's in "food".
{n,} n is a nonnegative integer. Matches at least n times. For example, 'o{2,}' does not match the "o" in "Bob" and matches all the o's in "foooood". 'o{1,}' is equivalent to 'o+'. 'o{0,}' is equivalent to 'o*'.
{n,m} m and n are nonnegative integers, where n <= m. Matches at least n and at most m times. For example, "o{1,3}" matches the first three o's in "fooooood". 'o{0,1}' is equivalent to 'o?'. Note that you cannot put a space between the comma and the numbers.
? When this character immediately follows any of the other quantifiers (*, +, ?, {n}, {n,}, {n,m}), the matching pattern is non-greedy. A non-greedy pattern matches as little of the searched string as possible, whereas the default greedy pattern matches as much of the searched string as possible. For example, in the string "oooo", 'o+?' matches a single "o", while 'o+' matches all 'o's.
. Matches any single character except "\n". To match any character including the '\n', use a pattern such as '[.\n]'.
(pattern) Matches pattern and captures the match. The captured match can be retrieved from the resulting Matches collection, using the SubMatches collection in VBScript or the $0…$9 properties in JScript. To match parentheses characters ( ), use '\(' or '\)'.
(?:pattern) Matches pattern but does not capture the match, that is, it is a non-capturing match that is not stored for possible later use. This is useful for combining parts of a pattern with the "or" character (|). For example, 'industr(?:y|ies) is a more economical expression than 'industry|industries'.
(?=pattern) Positive lookahead matches the search string at any point where a string matching pattern begins. This is a non-capturing match, that is, the match is not captured for possible later use. For example 'Windows (?=95|98|NT|2000)' matches "Windows" in "Windows 2000" but not "Windows" in "Windows 3.1". Lookaheads do not consume characters, that is, after a match occurs, the search for the next match begins immediately following the last match, not after the characters that comprised the lookahead.
(?!pattern) Negative lookahead matches the search string at any point where a string not matching pattern begins. This is a non-capturing match, that is, the match is not captured for possible later use. For example 'Windows (?!95|98|NT|2000)' matches "Windows" in "Windows 3.1" but does not match "Windows" in "Windows 2000". Lookaheads do not consume characters, that is, after a match occurs, the search for the next match begins immediately following the last match, not after the characters that comprised the lookahead.
x|y Matches either x or y. For example, 'z|food' matches "z" or "food". '(z|f)ood' matches "zood" or "food".
[xyz] A character set. Matches any one of the enclosed characters. For example, '[abc]' matches the 'a' in "plain".
[^xyz] A negative character set. Matches any character not enclosed. For example, '[^abc]' matches the 'p' in "plain".
[a-z] A range of characters. Matches any character in the specified range. For example, '[a-z]' matches any lowercase alphabetic character in the range 'a' through 'z'.
[^a-z] A negative range characters. Matches any character not in the specified range. For example, '[^a-z]' matches any character not in the range 'a' through 'z'.
\b Matches a word boundary, that is, the position between a word and a space. For example, 'er\b' matches the 'er' in "never" but not the 'er' in "verb".
\B Matches a nonword boundary. 'er\B' matches the 'er' in "verb" but not the 'er' in "never".
\cx Matches the control character indicated by x. For example, \cM matches a Control-M or carriage return character. The value of x must be in the range of A-Z or a-z. If not, c is assumed to be a literal 'c' character.
\d Matches a digit character. Equivalent to [0-9].
\D Matches a nondigit character. Equivalent to [^0-9].
\f Matches a form-feed character. Equivalent to \x0c and \cL.
\n Matches a newline character. Equivalent to \x0a and \cJ.
\r Matches a carriage return character. Equivalent to \x0d and \cM.
\s Matches any whitespace character including space, tab, form-feed, etc. Equivalent to [ \f\n\r\t\v].
\S Matches any non-white space character. Equivalent to [^ \f\n\r\t\v].
\t Matches a tab character. Equivalent to \x09 and \cI.
\v Matches a vertical tab character. Equivalent to \x0b and \cK.
\w Matches any word character including underscore. Equivalent to '[A-Za-z0-9_]'.
\W Matches any nonword character. Equivalent to '[^A-Za-z0-9_]'.
\xn Matches n, where n is a hexadecimal escape value. Hexadecimal escape values must be exactly two digits long. For example, '\x41' matches "A". '\x041' is equivalent to '\x04' & "1". Allows ASCII codes to be used in regular expressions.
\num Matches num, where num is a positive integer. A reference back to captured matches. For example, '(.)\1' matches two consecutive identical characters.
\n Identifies either an octal escape value or a backreference. If \n is preceded by at least n captured subexpressions, n is a backreference. Otherwise, n is an octal escape value if n is an octal digit (0-7).
\nm Identifies either an octal escape value or a backreference. If \nm is preceded by at least nm captured subexpressions, nm is a backreference. If \nm is preceded by at least n captures, n is a backreference followed by literal m. If neither of the preceding conditions exists, \nm matches octal escape value nm when n and m are octal digits (0-7).
\nml Matches octal escape value nml when n is an octal digit (0-3) and m and l are octal digits (0-7).
\un Matches n, where n is a Unicode character expressed as four hexadecimal digits. For example, \u00A9 matches the copyright symbol (©).

Monday, July 20, 2009

"Group By" clause in OracleDB?

select dno,count(*) from emp group by dno having count(*)>1;






select * from emp;






UNION operator combines two or more SELECT statements.
used to query data from two or more tables, based on a relationship between certain columns in these tables.

Difference between a "where" clause and a "having" clause.?

Having clause is used only with group functions whereas Where is not used with.


Q: What's the difference between a primary key and a unique key?

A: Both primary key and unique enforce uniqueness of the column on which they are defined. But by default primary key creates a clustered index on the column, where are unique creates a nonclustered index by default. Another major difference is that, primary key doesn't allow NULLs, but unique key allows one NULL only.

Unique Key : unique values
Primary Key : Not Null + Unique + nonclustered index

What is the difference among "dropping a table", "truncating a table" and "deleting all records" from a table.

Dropping : (Table structure + Data are deleted), Invalidates the dependent objects ,Drops the indexes

Truncating: (Data alone deleted), Performs an automatic commit, Faster than delete

Delete : (Data alone deleted), Doesn’t perform automatic commit

Retrieve the Top N records from a DataBase Table?

Returning TOP N Records

Returning only the first N records in a SQL query differs quite a bit between database platforms. Here's some samples:

Microsoft SQL Server
SELECT TOP 10 column FROM table

PostgreSQL and MySQL
SELECT column FROM table
LIMIT 10

Oracle
SELECT column FROM table
WHERE ROWNUM <= 10

Sybase
SET rowcount 10
SELECT column FROM table

Firebird
SELECT FIRST 10 column
FROM table

Due to these differences if you want to keep your code database independent you should use the maxrows attribute in the cfquery tag in ColdFusion. The tradeoffs to database independance is performance, I would expect maxrows to be slower than specifying the rows in the SQL.


SELECT column FROM table

PostgreSQL and MySQL have a cool feature that will let you return an arbitrary range of rows (eg return rows 10-20). This is very handy for displaying pages of records:

SELECT column FROM table
LIMIT 10 OFFSET 20
The above query will return rows 20-30




courtesy :http://www.petefreitag.com/item/59.cfm

Sunday, July 19, 2009

VBScript Functions..

follow the link :

http://www.w3schools.com/VBscript/vbscript_ref_functions.asp

Do ...Loop statements in VB Script of QTP??

Do...Loop
If you don't know how many repetitions you want, use a Do...Loop statement.

The Do...Loop statement repeats a block of code while a condition is true, or until a condition becomes true.

Repeat Code While a Condition is True
You use the While keyword to check a condition in a Do...Loop statement.

Do While i>10
some code
Loop

If i equals 9, the code inside the loop above will never be executed.

Do
some code
Loop While i>10

The code inside this loop will be executed at least one time, even if i is less than 10.

Repeat Code Until a Condition Becomes True
You use the Until keyword to check a condition in a Do...Loop statement.

Do Until i=10
some code
Loop

If i equals 10, the code inside the loop will never be executed.

Do
some code
Loop Until i=10

The code inside this loop will be executed at least one time, even if i is equal to 10.

Exit a Do...Loop
You can exit a Do...Loop statement with the Exit Do keyword.

Do Until i=10
i=i-1
If i<10 Then Exit Do
Loop

The code inside this loop will be executed as long as i is different from 10, and as long as i is greater than 10.

VBScript procedures in QTP?

VBScript Procedures
In VBScript, there are two kinds of procedures:

Sub procedure
Function procedure

--------------------------------------------------------------------------------

VBScript Sub Procedures
A Sub procedure:

is a series of statements, enclosed by the Sub and End Sub statements
can perform actions, but does not return a value
can take arguments
without arguments, it must include an empty set of parentheses ()
Sub mysub()
some statements
End Sub

or

Sub mysub(argument1,argument2)
some statements
End Sub


--------------------------------------------------------------------------------

VBScript Function Procedures
A Function procedure:

is a series of statements, enclosed by the Function and End Function statements
can perform actions and can return a value
can take arguments that are passed to it by a calling procedure
without arguments, must include an empty set of parentheses ()
returns a value by assigning a value to its name

Function myfunction()
some statements
myfunction=some value
End Function

or

Function myfunction(argument1,argument2)
some statements
myfunction=some value
End Function


--------------------------------------------------------------------------------

How to Call a Procedure
The line below shows how to call a Function procedure:

carname=findname()

Here you call a Function called "findname", the Function returns a value that will be stored in the variable "carname".

Or, you can do like this:

msgbox "Your car is a " & findname()

Here you also call a Function called "findname", the Function returns a value that will be displayed in the message box.

When you call a Sub procedure you can use the Call statement, like this:

Call MyProc(argument)

Or, you can omit the Call statement, like this:

MyProc argument

Variables in VBScript of QTP?

VBScript Variables
As with algebra, VBScript variables are used to hold values or expressions.

A variable can have a short name, like x, or a more descriptive name, like carname.

Rules for VBScript variable names:

Must begin with a letter
Cannot contain a period (.)
Cannot exceed 255 characters
In VBScript, all variables are of type variant, that can store different types of data.


--------------------------------------------------------------------------------

Declaring (Creating) VBScript Variables
Creating variables in VBScript is most often referred to as "declaring" variables.

You can declare VBScript variables with the Dim, Public or the Private statement. Like this:

dim x;
dim carname;

Now you have created two variables. The name of the variables are "x" and "carname".

You can also declare variables by using its name in a script. Like this:

carname=some value

Now you have also created a variable. The name of the variable is "carname". However, this method is not a good practice, because you can misspell the variable name later in your script, and that can cause strange results when your script is running.

If you misspell for example the "carname" variable to "carnime", the script will automatically create a new variable called "carnime". To prevent your script from doing this, you can use the Option Explicit statement. This statement forces you to declare all your variables with the dim, public or private statement.

Put the Option Explicit statement on the top of your script. Like this:

option explicit
dim carname
carname=some value


--------------------------------------------------------------------------------

Assigning Values to Variables
You assign a value to a variable like this:

carname="Volvo"
x=10

The variable name is on the left side of the expression and the value you want to assign to the variable is on the right. Now the variable "carname" has the value of "Volvo", and the variable "x" has the value of "10".


--------------------------------------------------------------------------------

Lifetime of Variables
How long a variable exists is its lifetime.

When you declare a variable within a procedure, the variable can only be accessed within that procedure. When the procedure exits, the variable is destroyed. These variables are called local variables. You can have local variables with the same name in different procedures, because each is recognized only by the procedure in which it is declared.

If you declare a variable outside a procedure, all the procedures on your page can access it. The lifetime of these variables starts when they are declared, and ends when the page is closed.


--------------------------------------------------------------------------------

VBScript Array Variables
An array variable is used to store multiple values in a single variable.

In the following example, an array containing 3 elements is declared:

dim names(2)

The number shown in the parentheses is 2. We start at zero so this array contains 3 elements. This is a fixed-size array. You assign data to each of the elements of the array like this:

names(0)="Tove"
names(1)="Jani"
names(2)="Stale"


Similarly, the data can be retrieved from any element using the index of the particular array element you want. Like this:

mother=names(0)

You can have up to 60 dimensions in an array. Multiple dimensions are declared by separating the numbers in the parentheses with commas. Here we have a two-dimensional array consisting of 10 rows and 6 columns:

Dim x(9,5),z,y
For z = 0 to 9
For y = 0 to 5
x(z,y) = "Row:" & z & space(1) & "Col:" & y
Next
Next

Select Case Statement in VB Script of QTP?

Executes one of several groups of statements, depending on the value of an expression.

Select Case testexpression
[Case expressionlist-n
[statements-n]] . . .
[Case Else expressionlist-n
[elsestatements-n]]
End Select

Arguments
testexpression
Any numeric or string expression.
expressionlist-n
Required if Case appears. Delimited list of one or more expressions.
statements-n
One or more statements executed if testexpression matches any part of expressionlist-n.
elsestatements-n
One or more statements executed if testexpression doesn't match any of the Case clauses.
Remarks
If testexpression matches any Case expressionlist expression, the statements following that Case clause are executed up to the next Case clause, or for the last clause, up to End Select. Control then passes to the statement following End Select. If testexpression matches an expressionlist expression in more than one Case clause, only the statements following the first match are executed.

The Case Else clause is used to indicate the elsestatements to be executed if no match is found between the testexpression and an expressionlist in any of the other Case selections. Although not required, it is a good idea to have a Case Else statement in your Select Case block to handle unforeseen testexpression values. If no Case expressionlist matches testexpression and there is no Case Else statement, execution continues at the statement following End Select.

Select Case statements can be nested. Each nested Select Case statement must have a matching End Select statement.

The following example illustrates the use of the Select Case statement.

Dim arr(5)
arr(0) = "The"
arr(1) = "World"
arr(2) = "is"
arr(3) = "not"
arr(4) = "good"
arr(5) = "enough"
i=inputbox("enter value for i")

Select Case i
Case 0 :
msgbox arr(0)
Case 1 :
msgbox arr(1)
Case 2 :
msgbox arr(2)
Case 3 :
msgbox arr(3)
Case 4 :
msgbox arr(4)
Case 5 :
msgbox arr(5)
case else :
msgbox "i come if there is no match for your input"

End Select

"on error resume next" or Recovery Scenarios ?

If you can predict that a certain event may happen at a specific point in your test or component, it is recommended to handle that event directly within your test or component by adding steps such as If statements or optional steps or "on error resume next", rather than depending on a recovery scenario. Using Recovery Scenarios may result in unusually slow performance of your tests.They are designed to handle a more generic set of unpredictable events which CANNOT be handled programmatically.

Difference between call by value and call by reference?

ByVal
Indicates that the argument is passed by value.
ByRef
Indicates that the argument is passed by reference.

Call Statement
Transfers control to a Sub or Function procedure.

[Call] name [argumentlist]
Arguments
Call
Optional keyword. If specified, you must enclose argumentlist in

parentheses. For example:
Call MyProc(0)

name
Required. Name of the procedure to call.
argumentlist
Optional. Comma-delimited list of variables, arrays, or expressions to

pass to the procedure.


Remarks
You are not required to use the Call keyword when calling a procedure.

However, if you use the Call keyword to call a procedure that requires

arguments, argumentlist must be enclosed in parentheses. If you omit

the Call keyword, you also must omit the parentheses around

argumentlist. If you use either Call syntax to call any intrinsic or

user-defined function, the function's return value is discarded.




var="Hello World"
Call MyFunction(var)
msgbox var
Function MyFunction(byval text)
text = "gopi"
End Function
'output of the above pgm is "Hello World"


var="Hello World"
Call MyFunction(var)
msgbox var
Function MyFunction(byref text)
text = "World is Changed"
End Function
'output of the above pgm is "World is Changed"


Passing by Value is just that. It passes a value to the function to use. It creates a new space to hold this value.

Passing by Reference passes the pointer to the memory space for the variable. This means that anything you do to the variable in the function changes the actual value of the passed variable. This means that if you changed the variable in the function it will be changed outside the function too.

Friday, July 17, 2009

Working with Associated Function Libraries

In QuickTest, you can create function libraries containing functions, subroutines, modules, and so forth, and then associate the files with your test. This enables you to insert a call to a public function or subroutine in the associated function library from that test. (Public functions stored in function libraries can be called from any associated test, whereas private functions can be called only from within the same function library.)

If a test can no longer access a function that was used in a step (for example, if the function was deleted from the associated function library), the icon is displayed adjacent to the step in the Keyword View. When you run the test, an error will occur when it reaches the step using the nonexistent function.

Note: Any text file written in standard VBScript syntax can be used as a function library.

You can specify the default function libraries for all new tests in the Test Settings dialog box (File > Settings > Resources tab). After a test is created, the list of default function libraries is integrated into the test. Therefore any changes to the default function libraries list in the Test Settings dialog box do not affect existing tests.

You can edit the list of associated function libraries for an existing test in the Test Settings dialog box. For more information, see Defining Resource Settings for Your Test.

Notes:

In addition to the functions available in the associated function libraries, you can also call a function contained in any function library (or VBscript file) directly from any action using the ExecuteFile function. You can also insert ExecuteFile statements within an associated function library. For more information, see Executing Externally-Defined Functions from Your Test.
You cannot debug a file that is called using an ExecuteFile statement, or any of the functions contained in the file. In addition, when debugging a test that contains an ExecuteFile statement, the execution marker may not be correctly displayed



Library files in QTP are used to declare functions that are needed to be used across actions

A Library File included on the Resource tab are placed in the test’s Global namespace at runtime, and are therefore shared and accessible by all Actions included in the test.

Including a library in a test Action, using the ExecuteFile(“libname”) QTP statement. Libraries included in this manner are placed in the including Action’s namespace, and therefore may only be used by the including Action’s code.


It is also possible to use one or more ExecuteFile(“libname”) statements within a library included via the Test Settings Resource tab as well. In this scenario all library files are placed in the test’s Global namespace.

And also a library file can be included from External VBA file directly by using QTA APPLICATION object.

Most frequent http error codes we see while testing

http error code :400
Its Client Error Code..The request was denied due to a syntax error in the request.

http error code :404
The document that has been requested either no longer exists, or has never existed on the server.

http error code :503
Its Server Error Code.The server is overloaded or down for maintenance and due to this was unable to process the client request.

http error code :502
Server Overload.Bad Gateway; a server being used by this Web server has sent an invalid response.

http error code :200
This is the normal response where a page has been successfully fetched