1. Manage Your Test Data

2. Test Your GUI and UI-Less Application Functionality in One Test

3. New Run Results Viewer

4. Help QuickTest Identify Your Objects as a Manual Tester Would – VISUALLY

5.  Collaborate with Developers to Pinpoint Defects Using Log Tracking

6.  Out-of-the-Box Support for Web 2.0 Toolkit Applications

7.  New Web Testing Capabilities

8.  Automatically Parameterize Steps

9.  New Silverlight Add-in

10.Extend WPF and Silverlight Support

11. Use Extensibility Accelerator for Web Add-in Extensibility Development

12. It’s Easier Than Ever to Insert Regular Expressions

13. Load Function Libraries at Run Time

14. Avoid Downtime Due to License Server Failures

15. Improved Documentation Structure Helps You Find the Information You Need

Manage Your Test Data

Quality Center (HP ALM) test configuration functionality enables you to determine at runtime which data sets to use for your tests.

ALM test configurations enable you to:

Unbind your data from your tests

Share common data sources across different tests

Filter your data to fit your testing needs

Increase requirements traceability

You store the data for your tests in the Quality Center Test Resources module in the form of data table resource files.

You can then define multiple test configurations for a test in the Test Plan module. When working with data-driven QuickTest tests in HP ALM, each configuration is a QuickTest test that is set to run with a selected data resource file and optional data filter settings.

One or more specific configurations of the test can be included in a Test Set to cover different parts of a requirement or to cover multiple requirements.

By using Quality Center test configurations, you can create more generic tests and reuse them by associating a different set of data with each. You can also reuse your data by associating the same data table file with multiple tests.

Test Your GUI and UI-Less Application Functionality in One Test

The new QuickTest-Service Test integration enables you to test across the GUI and non-GUI layers of your application.

You can use QuickTest steps to start testing the GUI elements in your application, then call a Service Test test to validate service communications (standard Web Services, non-SOAP Web Services, such as REST, etc.), and then step back into your QuickTest GUI testing, all in a single test run.

The results of the QuickTest and Service Test steps are displayed in a unified report in the new Run Results Viewer.

New Run Results Viewer

The new Run Results Viewer provides an Executive Summary page with summary data, pie charts and statistics for both the current and previous runs, a quick link to the previous run results, and more.

The Run Results Viewer displays the results of your run session in a set of panes that you can show, hide, move, dock, and otherwise customize to your needs.

You can install the Run Results Viewer as a standalone installation. This enables you to share the results of your tests with business analysts and developers who do not work with QuickTest.

Help QuickTest Identify Your Objects as a Manual Tester Would – VISUALLY

You can now use visual relation identifiers to identify application objects based on other objects that are always near them.

This enables you to create a more reliable identification definition for test objects that are otherwise difficult to differentiate, and to ensure that the identification remains reliable even if the user interface design changes.The Visual Relation Identifier Dialog Box provides the interface and tools to help you create and verify your visual relation identifier definitions.

Collaborate with Developers to Pinpoint Defects Using Log Tracking

In today’s more agile development environment, it is more important than ever for QA engineers and developers to work together throughout the development and release process.

QuickTest’s new Log Tracking functionality helps you work with developers to pinpoint the root causes of unexpected behavior in your application.

When you enable log tracking, QuickTest receives the Java or .NET log framework messages from your application and embeds them in the run results.

You can click a log message in the results to jump to the relevant step in the run results tree, or you can click a step in the run results tree and view the log message that was generated at the time that the selected step ran. You can also specify that a log message of a particular level (or higher) will fail your test.

After you view the results, you can print or export the log tracking details to a file to show to a developer, or you can provide the developer with the standalone Run Results Viewer installation so that the developer can view and analyze the results directly on his or her own desktop.

Out-of-the-Box Support for Web 2.0 Toolkit Applications

QuickTest 11.00 provides Web Add-in Extensibility-based add-ins for ASP .NET Ajax, GWT, Yahoo UI, and Dojo Web 2.0 toolkits.

You can use these add-ins just as you would any other add-in. You can also use Web Add-in Extensibility or Extensibility Accelerator to customize the provided support to match your needs.

You install these add-ins by running the Web 2.0 Toolkit Support Setup from the Add-in Extensibility and Web 2.0 Toolkits option in the QuickTest Professional setup window.

The operations supported for each Web 2.0 test object class are a combination of custom operations developed for that test object class and operations directly inherited from the corresponding (base) Web Add-in test object class.

New Web Testing Capabilities

Many new testing capabilities are now available for working with Web-Based objects.

Firefo Testing :You can now record steps on Mozilla Firefox and use the .Object property to access the Firefox DOM.

XPath,CSS,Identifiers: You can add the XPath or CSS identifier properties to instruct QuickTest to identify a Web object in your application based on its XPath location or CSS definition.

Event Identifiers:You can also now use the attribute/* notation in the test object description to identify a Web-based object based on an event associated with that object. For example, you can add attribute/onClick as a property in a WebButton test object description to identify a button that is associated with the onClick event.

Embed or Run JavaScripts in Your Web Pages. You can use the new  EmbedScript/EmbedScriptFromFile and RunScript/RunScriptFromFile functions to embed JavaScripts in all loaded browser pages and frames or to run JavaScripts in specific pages. Use these scripts to perform operations on, or retrieve data from, the browser pages in your application.

Automatically Parameterize Steps

You can instruct QuickTest to automatically parameterize the steps in your test’s actions at the end of a recording session.

This enables you to create actions that can be used for a variety of different purposes or scenarios by referencing different sets of data.

You activate this option by selecting the Automatically parameterize steps option in the General tab of the Options dialog box. You can set the option to use Global Data Table Parameters or Test Parameters.

When you stop a recording session while this option is selected, QuickTest replaces the constant values in the test object operation arguments of your steps with either Data Table parameters or action parameters, based on your selection in the Options dialog box.

QuickTest performs this automatic parameterization for all relevant steps in any action in your test, in which you recorded one or more steps during that recording session.

If you work with HP ALM, and you select the Global Data Table Parameters option, you can map the generated parameters to the column names of a data resource and then use different configurations in your test sets.

If you work with SAP eCATT and you select the Test Parameters option, you can then supply the values for the test parameters from eCATT.

New Silverlight Add-in

You can use the new Silverlight Add-in to test objects in Silverlight 2 and Silverlight 3 applications.

After you install the Silverlight Add-in, it is displayed in the Add-in Manager as a child add-in under the WPF Add-in.

Extend WPF and Silverlight Support

The WPF and Silverlight Add-in Extensibility SDK enables you to develop support for testing third-party and custom WPF and Silverlight controls that are not supported out-of-the-box by the relevant QuickTest add-ins.You install the WPF and Silverlight Add-in Extensibility SDK from the Add-in Extensibility and Web 2.0 Toolkits option in the QuickTest Professional setup window.

Use Extensibility Accelerator for Web Add-in Extensibility Development

The new Extensibility Accelerator for Functional Testing is a Visual Studio-like IDE that facilitates the design, development, and deployment of Web Add-in Extensibility support.

It provides a user interface and special tools that help you define new test object classes, map those test object classes to the controls in your application, and teach QuickTest how to identify the controls, perform operations on the controls and retrieve their properties.You install the Extensibility Accelerator from the Add-in Extensibility and Web 2.0 Toolkits option in the QuickTest Professional setup window.

It’s Easier Than Ever to Insert Regular Expressions

The Smart Regular Expression list provides syntax hints that make it easier than ever to insert regular expressions into your test steps. It also enables you to access the Regular Expression Evaluator, which lets you test regular expressions to make sure they suit your needs.

Load Function Libraries at Run Time

The new LoadFunctionLibrary statement lets you load a function library when a step runs instead of at the beginning of a run session. This means, for example, that you can define conditional steps that use functions from various function libraries, but load only the required function libraries during a run session.

Avoid Downtime Due to License Server Failures

With redundant license servers you create failover, so that if your main license server fails, your remaining servers maintain availability of your licenses without causing any downtime or loss of licenses for users.The redundant license server feature is especially useful for enterprise customers who have a large network installation and want to maintain license server backup.

Improved Documentation Structure Helps You Find the Information You Need

When you open the QuickTest Professional Help, you can now access the entire Documentation Library from one central point, the Home page. It provides links to all available guides in each available format, including PDF files.

The HP QuickTest Professional User Guide and the HP QuickTest Professional for Business Process Testing User Guide are now organized into topic types: Concepts, Tasks, and References. Use each topic type to access specific information about a feature or product area.

For example, you can use the Tasks topic type to learn the overall workflow of a feature to help you accomplish your goals, or you can use the Reference topic type to look up a specific user interface element, such as a window, dialog box, or page.

QTP 10 and QTP 11  are two versions of the Quick Test Professional (QTP), which is a testing tool to judge the proficiency of individuals in functional Graphic User Interface. It helps in testing a lot of topics such as standard windows applications, web objects, Active X controls, .Net, Java, SAP, visual basic applications, Siebel, Oracle, PeopleSoft, and terminal emulators. QTP is Unicode compliant according to the requirements of Unicode standard. This enables testing applications in many languages.

So far there have been many versions of QTP and with the arrival of QTP11, there are many who are confused about the differences between QTP11 and QTP10. Of course there are many updates as well as totally new features in QTP11 that were not there in QTP10.

While QTP10 was able to identify object through only normal object identification, there are different ways to identify an object in QTP11. These different methods are XPath tutorial and CSS tutorial.

In QTP11, results viewer have been improved in the form of pie charts, statics for both current and previous test runs and summary page.

Normal object identification method has been slightly changed in QTP11. There is a visual relation identifier in addition to ordinal identifier. In this, object identification will depend upon relation to neighboring objects and will be helpful to overcome weakness of ordinal identification feature that was there in QTP10.

There is a new LoadFunctionLibrary in QTP11 that is very helpful to load function library at any step instead of starting of run.

In comparison to QTP10, regular expression creation is very easy in QTP11.

It is possible to test GUI and UI-less application functionality which was not possible in QTP10.

There is a totally new Silverlight add on that supports to test objects in silverlight 2 and silverlight 3. Another new feature that has been added in QTP is automatic parameterize steps.

QTP 9.5 vs QTP 10

QTP 9.5 and QTP 10 are software testing tools.  QTP means QuickTest Professional. QTP is an automated testing tool developed by HP/Mercury. This tool integrates with other testing solutions such as LoadRunner, WinRunner and TestDirector/Quality Center. One of the versions of this testing tool is QTP 9.5 and QTP 10. QTP 10 has added features as compared to the previous version.

QTP 9.5

The version 9.5 of QuickTest Professional tool provides following added features over the last versions:

• Process Guidance – The help files are more accessible this time. This is good when a user is learning to record the test for the first time.

• Maintenance Run Mode – Now, users can update object properties and add steps to them on the fly. Users just need to run the maintenance mode if there is some change in the object properties after new build is made.

• Tabbed Browsing – Separate browsers identify the tabs. The same test is compatible with tabbed as well as non-tabbed browsers.

• New environments – This version supports new environments such as Firefox 3.0, Windows Vista, Record on SWT, Netscape 9 and Eclipse 3.2 and 3.3.

All the add-in can be integrated with the core package that is installed on the system. However, these add-ins need to be activated and for this, users need to buy them separately. Another enhancement to this version is that users are now able to view the functions that are related to current tests. Other added functionality provided by QTP 9.5 is bitmap checkpoint and Web add-in extensibility.

QTP 10

This version of QuickTest Professional provides integration capabilities of new quality center 10.00. Some of the capabilities are:

• Support for baselines and asset versioning.

• A new dependencies and resources model for storing as well as managing shared assets.

• It also provides a special tool for Quality center administrators that help in upgrading all the assets of QuickTest to be used with new features. The assets include application areas, components, recovery scenarios, function libraries, tests, and external data tables and shared object repositories.

• There is an Asset comparison tool included in this version that allows the comparison of versions of assets.

The Local system monitoring tool provided in this version helps you in monitoring the computer’s resources that are used by application instance that you are testing during a session.

We can learn the VBScript without QTP also. You need Notepad and command prompt on your system and follow below steps:

1. Create a notepad file.
2. Write a small VBScript in the notepad file.

e.g.

 Option Explicit
 Dim myResponse
 myResponse = MsgBox(“Do you wish to quit?”, 1, “What do you wish to do?”)

1. Save the above Notepad file as Test.vbs.
2. Run above file from the command prompt using CScript.exe.
3. C:\>CScript.exe Test.vbs
4. You will be getting the result of your script.

Descriptive programming in QTP
Whenever QTP records any action on any object of an application, it adds some description on how to recognize that object to a repository of objects called object repository. QTP cannot take action on an object until unless its object description is in the Object Repository. But descriptive programming provides a way to perform action on objects which are not in Object repository

Object Identification:
To identify an object during the play back of the scripts QTP stores some properties which helps QTP to uniquely identify the object on a page. Below screen shots shows an example Object repository:Now to recognize a radio button on a page QTP had added 2 properties the name of the radio button and the html tag for it. The name the left tree view is the logical name given by QTP for the object. This can be changed as per the convenience of the person writing the test case. QTP only allows UNIQUE logical name under same level of hierarchy. As we see in the snapshot the two objects in Browser->Page node are “WebTable” and “testPath”, they cannot have the same logical name. But an object under some other node can have the same name. Now with the current repository that we have, we can only write operation on objects which are in the repository. Some of the example operations are given below

Browser(“Browser”).Page(“Page”).WebRadioGroup (“testPath”).Select “2″
cellData = Browser(“Browser”).Page(“Page”).WebTable (“WebTable”).GetCellData (1,1)
Browser(“Example2″).Page(“Page”).WebEdit(“testPath”).Set “Test text” When and

Why to use Descriptive programming?
 Below are some of the situations when Descriptive Programming can be considered useful:
The objects in the application are dynamic in nature and need special handling to identify the object. The best example would be of clicking a link which changes according to the user of the application, Ex. “Logout <<UserName>>”.
When object repository is getting huge due to the no. of objects being added. If the size of Object repository increases too much then it decreases the performance of QTP while recognizing a object.
When you don’t want to use object repository at all. Well the first question would be why not Object repository? Consider the following scenario which would help understand why not Object repository

Scenario 1: Suppose we have a web application that has not been developed yet. Now QTP for recording the script and adding the objects to repository needs the application to be up, that would mean waiting for the application to be deployed before we can start of with making QTP scripts. But if we know the descriptions of the objects that will be created then we can still start off with the script writing for testing

Scenario 2: Suppose an application has 3 navigation buttons on each and every page. Let the buttons be “Cancel”, “Back” and “Next”. Now recording action on these buttons would add 3 objects per page in the repository. For a 10 page flow this would mean 30 objects which could have been represented just by using 3 objects. So instead of adding these 30 objects to the repository we can just write 3 descriptions for the object and use it on any page.Modification to a test case is needed but the Object repository for the same is Read only or in shared mode i.e. changes may affect other scripts as well.
When you want to take action on similar type of object i.e. suppose we have 20 textboxes on the page and there names are in the form txt_1, txt_2, txt_3 and so on. Now adding all 20 the Object repository would not be a good programming approach.

How to use Descriptive programming?

There are two ways in which descriptive programming can be used
By creating properties collection object for the description.
By giving the description in form of the string arguments.By creating properties collection object for the description.To use this method you need first to create an empty description

Dim obj_Desc ‘Not necessary to declare
Set obj_Desc = Description.Create

Now we have a blank description in “obj_Desc”. Each description has 3 properties “Name”, “Value” and “Regular Expression”.

obj_Desc(“html tag”).value= “INPUT”

When you use a property name for the first time the property is added to the collection and when you use it again the property is modified. By default each property that is defined is a regular expression. Suppose if we have the following description

obj_Desc(“html tag”).value= “INPUT
” obj_Desc(“name”).value= “txt.*”

This would mean an object with html tag as INPUT and name starting with txt. Now actually that “.*” was considered as regular expression. So, if you want the property “name” not to be recognized as a regular expression then you need to set the “regularexpression” property as FALSE

obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt.*”
obj_Desc(“name”).regularexpression= “txt.*”

This is how of we create a description. Now below is the way we can use it

Browser(“Browser”).Page(“Page”).WebEdit(obj_Desc).set “Test”

When we say .WebEdit(obj_Desc) we define one more property for our description that was not earlier defined that is it’s a text box (because QTPs WebEdit boxes map to text boxes in a web page).If we know that we have more than 1 element with same description on the page then we must define “index” property for the that descriptionConsider the HTML code given below

<INPUT type=”textbox” name=”txt_Name”>
<INPUT type=”textbox” name=”txt_Name”>

Now the html code has two objects with same description. So distinguish between these 2 objects we will use the “index” property. Here is the description for both the object

For 1st textbox:
obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt_Name
” obj_Desc(“index”).value= “0”

For 2nd textbox:
obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt_Name”
obj_Desc(“index”).value= “1”

Consider the HTML Code given below:

<INPUT type=”textbox” name=”txt_Name”>
<INPUT type=”radio” name=”txt_Name”> We can use the same description for both the objects and still distinguish between both of themobj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt_Name”

When I want to refer to the textbox then I will use the inside a WebEdit object and to refer to the radio button I will use the description object with the WebRadioGroup object.Browser(“Browser”).Page(“Page”).WebEdit(obj_Desc).set “Test” ‘Refers to the text box
Browser(“Browser”).Page(“Page”).WebRadioGroup(obj_Desc).set “Test” ‘Refers to the radio button

But if we use WebElement object for the description then we must define the “index” property because for a webelement the current description would return two objects.

Hierarchy of test description:
When using programmatic descriptions from a specific point within a test object hierarchy, you must continue to use programmatic descriptions from that point onward within the same statement. If you specify a test object by its object repository name after other objects in the hierarchy have been described using programmatic descriptions, QuickTest cannot identify the object.For example, you can use Browser(Desc1).Page(Desc1).Link(desc3), since it uses programmatic descriptions throughout the entire test object hierarchy. You can also use Browser(“Index”).Page(Desc1).Link(desc3), since it uses programmatic descriptions from a certain point in the description (starting from the Page object description).However, you cannot use Browser(Desc1).Page(Desc1).Link(“Example1″), since it uses programmatic descriptions for the Browser and Page objects but then attempts to use an object repository name for the Link test object (QuickTest tries to locate the Link object based on its name, but cannot locate it in the repository because the parent objects were specified using programmatic descriptions).Getting Child Object:
We can use description object to get all the objects on the page that matches that specific description. Suppose we have to check all the checkboxes present on a web page. So we will first create an object description for a checkboxe and then get all the checkboxes from the pageDim obj_ChkDesc
Set obj_ChkDesc=Description.Create
obj_ChkDesc(“html tag”).value = “INPUT”
obj_ChkDesc(“type”).value = “checkbox”

Dim allCheckboxes, singleCheckBox
Set allCheckboxes = Browse(“Browser”).Page(“Page”).ChildObjects(obj_ChkDesc)
For each singleCheckBox in allCheckboxessingleCheckBox.Set “ON”

Next
The above code will check all the check boxes present on the page. To get all the child objects we need to specify an object description i.e. we can’t use the string arguments that will be discussed later in the 2nd way of using the programming description.Possible Operation on Description Object Consider the below code for all the solutions
Dim obj_ChkDesc Set obj_ChkDesc=Description.Create
obj_ChkDesc(“html tag”).value = “INPUT”
obj_ChkDesc(“type”).value = “checkbox”

Next Step – Variable Declaration

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.CopyFile("d:\ displayText.txt", "d:\myDocs\ displayText.txt")

In this example, a file named myFile.txt is copied from the root folder on the C: drive to a folder named myDocs located on the computer’s D: drive. You can modify this example to copy more than one file using wildcard characters as shown in the next example. Here all files in the root directly with a filename of myFile are copied to the destination folder regardless of their file extension.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.CopyFile("d:\ displayText.*", "d:\Docs")

Moving Files

Moving files is similar to copying them except that instead of leaving the original file in place and placing a duplicate copy in the destination location, the original file is moved leaving only one copy of the file. You can move one or more files using the FileSystemObject object’s MoveFile() method.For example, you can move all files with a .txt file extension found in the root of the C: drive to a myDocs folder on the D: drive using the following VBScript statements.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.MoveFile("c:\*.txt", "c:\Docs")

Deleting Files
You can use the FileSystemObject object’s DeleteFile() method to delete one or more files. For example, you might want to write a script that cleans out a folder at the end of each day or that deletes files after reading and processing them. You can delete one or more files as demonstrated here.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.DeleteFile("d:\*.txt")

Here all files that have a .txt file extension located in the root of the C: drive will be deleted.
Creating a Folder
Working with folders is similar to working with files. You can use the FolderExists() method of the FileSystemObject to determine if a folder exists. If the folder does not exist, you can create it using the FileSystemObject object’s CreateFolder() method as demonstrated here.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
If (fsoObject.FolderExists("d:\Docs") = false) Then
Set myFolder = fsoObject.CreateFolder("d:\Docs")
End If

The first thing that this example does is check to see if a folder named myDocs already exists on the computer’s D: drive. If it does not exist, then the folder is created. Otherwise nothing happens.
Copying Folders
Copying a folder is pretty much the same as copying a file. The folder and all its contents are copied to a new location leaving the original copy still in place. You can copy folders using the FileSystemObject object’s CopyFolder() method.Take a look at the following example. It copies a folder named myDocs located on the computer’s D: drive to its C: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.CopyFolder("c:\Docs", "d:\Docs")

As you can see the CopyFolder() methods requires two arguments, the source and destination folder names, including their complete paths. By changing the name assigned to the destination folder, you can rename the folder as part of the copy operation as demonstrated here.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.CopyFolder("c:\Docs", "d:\NewDocs")

If the destination folder already exists, then the contents of the source folder are copied into it alongside its current contents. The CopyFolder() method supports an additional third parameter that allows you to tell it what to do if the destination folder contains files with duplicate filenames of those found in the source folder. This parameter is set to either a value of true or false. Setting it to true causes any matching files to be overridden. Setting it to false prevents this from happening. Let’s look at a couple examples. The first example prevents files with duplicate filenames from being overridden.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.CopyFolder("c:\Docs", "d:\Docs", "False")

The second example allows files with duplicate names to be overridden in the destination folder.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.CopyFolder("c:\Docs", "d:\Docs", "True")

Moving Folders
Moving a folder works pretty much the same as copying one except that moving the folder leaves you with only the one copy. You can move folders using the FileSystemObject object’s MoveFolder() method. This method moves a folder and all its contents, including subfolders, to a new destination.For example, the following VBScript statements move a folder called myDocs from the computer’s D: drive to its C: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.MoveFolder("c:\Docs", "d:\Docs")

If a folder with the same name already exists at the root of the computer’s D: drive, then the contents of the source folder will be copied into the existing destination along side its current contents.

Deleting Folders

You can delete one or more folders using the FileSystemObject object’s DeleteFolder() method. This method deletes a folder and all its contents, including subfolders. For example, the following VBScript statements can be used to delete a folder named myDocs located on a computer’s D: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.DeleteFolder("d:\Docs")

Managing Files with the File Object

The File Object allows you to work with one file at a time as opposed to the FileSystemObject, which lets you manage multiple files. Using the File object instead of the FileSystemObject requires a little more work. You still have to create an instance of the FileSystemObject to interact with the file system. You also need to use the FileSystemObject object’s GetFile() method to retrieve a File object that represents the file that your script will be managing. Once these two things are set up you can execute any of the File object’s methods.

Copying a File

Using the File object’s Copy() method you can copy a file from one location to another. This method does not support the use of wildcard characters and cannot therefore be used to copy multiple files.The following example demonstrates how to use the File object’s Copy() method to copy a file named myFile.txt from the myDocs folder on the computer’s D: drive to the root of the C: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
Set source_file = fsoObject.GetFile("c:\Docs\ displayText.txt")
source_file.Copy("d:\")

In this example, the FileSystemObject object’s GetFile() method is used to establish a reference to the file that is to be copied. Then the Copy() method is used to set the destination where the file is to be copied.

Moving a File

As you probably expect by now, moving a file using the File object’s Move() method works almost exactly like copying it using the Copy() method. For example, the following VBScript statements demonstrate how to move a file from one location to another.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
Set source_file = fsoObject.GetFile("c:\Docs\ displayText.txt")
source_file.Move("d:\")

Deleting a File

You can delete an individual file using the File Object’s Delete() method. Like the File object’s other methods, the Delete() method does not support wildcard characters limiting it to being able to delete just one file at a time.Take a look at the following example. Here a file named myFile.txt is deleted from a folder named myDocs located on the computer’s D: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
Set source_file = fsoObject.GetFile("c:\Docs\ displayText.txt ")
source_file.Delete()

Managing Folders with the Folder Object
The Folder object is similar to the File object only it works with one folder at a time instead of one file at a time. Like the File object, it requires a little more work to set up than does simply using the FileSystemObject. First, you’ll need to instantiate the FileSystemObject. Then you must use the FileSystemObject object’s GetFolder() method to retrieve a Folder object that represents the folder that your script will be working with. Once these two things are set up you can execute any of the Folder object’s methods.

Copying a Folder

Like the File object, the Folder object supports the Copy() method. Because it doesn’t support wildcard characters it is useful only when you want to work with a single folder at a time. The Copy() method copies the folder and all its contents, including any subfolders, to a new location.For example, the following VBScript statements demonstrate how to use the Copy() method. In this case a folder named myDocs is copied from the root of the computer’s D: drive to the root of the computer’s C: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
Set source_folder = fsoObject.GetFolder("d:\Docs")
source_folder.Copy("c:\")

Moving a Folder
The Folder object’s Move() method lets you move a folder from one location to another. This method recursively copies a folder and all its contents. Because it does not support wildcard characters, this method can only move one folder at a time, as opposed to the FileSystemObject object’s MoveFolder() method, which can move any number of folders in a single operation.The following example demonstrates how to use this method to move a folder. In this case the folder is named myDocs and it is moved from the computer’s D: drive to its C: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
Set source_folder = fsoObject.GetFolder("d:\Docs")
source_folder.Move("c:\")

Deleting a Folder

You can delete a folder using the Folder object’s Delete() method. Wildcard character matching is not supported so it only works with one folder at a time. If you need to delete more than one folder you can use the FileSystemObject object’s DeleteFolder() method, discussed earlier in this chapter.This method deletes the specified folder and all its contents, including subfolders. Its use is demonstrated here.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
Set source_folder = fsoObject.GetFolder("d:\Docs")
source_folder.Delete()

Next Step – QTP Script Examples

To use the FileSystemObject within your VBScripts you must first establish an instance of it. You can do this using the WScript object’s CreateObject() method and by referencing it as Scripting. FileSystemObject. This is demonstrated in the following example.

Set fsoObject = WScript.CreateObject ("Scripting.FileSystemObject")

Here fsoObject is just the name that I assigned to a variable that can now be used by the rest of the script to reference the properties and methods of the FileSystemObject. With this instance of the FileSystemObject now established the script is read to interact with the Windows file system.Let’s put this previous FileSystemObject example to work in a few quick examples to see how it really works.
Displaying Drive Free Space

This first example demonstrates how to use a number of methods and properties of the VBScript runtime objects to access drive information. Specifically the example shown here displays the amount of free space on a computer’s C: and D: drives.

' * Script Name: Script 5.vbs       *  

Option Explicit  

On Error Resume Next  

dim fsoObject, drive1, drive2  

set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

set drive1 = fsoObject.GetDrive(fsoObject.GetDriveName("c:"))  

set drive2 = fsoObject.GetDrive(fsoObject.GetDriveName("d:"))  

   

' ********* Main processing section **********  

' Call a function that displays drive information  

Free_Space()  

   

' *********** Procedures go here *************  

' This function displays the amount of free space on drive 1 and drive 2  

   

Function Free_Space()  

 WScript.Echo( "Free Space on drive 1 is: " _  

  & FormatNumber(drive1.FreeSpace / 1024 , 0) & " KB")  

 WScript.Echo( "Free Space on drive 2 is: " _  

  & FormatNumber(drive2.FreeSpace / 1024 , 0) & " KB")  

End Function

The script begins by defining three variables. The first variable is fsoObject. It will be used to create an instance of the FileSystemObject as discussed earlier. The next two variables will be used to set up references to the computer’s C: and D: drives.The two statements that set up the values of these two variables for the computer’s drives probably look a little complex to you at first. So let’s take a moment and break them down. First, the GetDriveName() method of the FileSystemObject is used by appending it to the variable fsoObject (for example, fsoObject.GetDriveName()). Remember that the fsoObject variable provides the script with a reference to the FileSystemObject and its properties and methods. The GetDriveName() method returns the name of the drive associated with the specified driver letter (that is, C: or D:). Next, the FileSystemObject object’s GetDrive() method is used to retrieve the Drive object associated with the specified drive name. The reason that we need to establish a reference to the Drive object is because we are going to want to use its Freespace property a little later in the script. After executing the statements in the script’s initialization section, the VBScript statement in the main processing section executes. There is only one VBScript statement in this section and it calls a function named Display_Msg(). The function then executes. Its job is to display the amount of free space on each drive. This is accomplished by taking the amount of free space left on a given drive as contained by the Drive object’s FreeSpace property and dividing it by 1024 (1 kilobyte or 1 KB). The results are then formatted using the Drive object’s FormatNumber() method, which in this case formats the number with zero trailing decimal spaces (that is, as whole number).When I ran this script on my computer, I got the following results.

C:\>CScript "Script 5.vbs"  

Microsoft (R) Windows Script Host Version 5.6  

Copyright (C) Microsoft Corporation 1996-2001. All rights reserved.  

Free Space on drive 1 is: 11,116 KB  

Free Space on drive 2 is: 15,784 KB  

C:\>

Examining File System Types
Let’s look at another example of how to work with the methods and properties of the VBScript runtime objects. This time we’ll write a VBScript example that displays the type of file system that the computer’s C: and D: drives have been formatted with.

' * Script Name: Script 6.vbs*  

Option Explicit  

On Error Resume Next  

dim fsoObject, drive1, drive2  

set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

set drive1 = fsoObject.GetDrive("C:")  

set drive2 = fsoObject.GetDrive("D:")  

' ********* Main processing section **********  

' Call a function that displays drive information  

Used_Disk()  

' *********** Procedures go here *************  

' This function displays the file system used to format drive 1 and drive 2  

Function Used_Disk()  

 WScript.Echo("The file system used on drive 1 is: " & drive1.FileSystem)  

 WScript.Echo("The file system used on drive 2 is: " & drive2.FileSystem)  

End Function

As you can see this VBScript is similar to the previous example. The same variables are defined in the initialization section. In addition, the same instance of the FileSystemObject is set up and once again its GetDrive() method is used to retrieve Drive object references to each drive on the computer.Next, a single VBScript statement in the main processing section calls a function that displays a file system type for each drive. This is accomplished by using Drive object’s FileSystem property.When I ran this script on my computer I received the following results.

C:\>CScript "Script 6.vbs"  

Microsoft (R) Windows Script Host Version 5.6  

Copyright (C) Microsoft Corporation 1996-2001. All rights reserved.  

The file system used on drive 1 is: NTFS  

The file system used on drive 2 is: NTFS  

C:\>

Examining File Properties
Let’s look at one final example before we rush off and begin to master the art of reading from and writing to text files. This example starts off like the previous two examples by defining its variables and instantiating an instance of the FileSystemObject. This time the FileSystemObject object’s GetFile() method is used. This method is used to retrieve the File object associated with the specified file, which in this example is c:\winzip.log.Again, a VBScript statement in the main processing section calls on a function named Display_Msg(). The function contains a number of WScript.Echo statements each of which displays a different property associated with the File object.

' ********************************************  

' * Script Name: Script 7.vbs       *  

' * Author: Kuldeep            *  

' * Created: 03/02/08            *  

' ********************************************  

' **** Perform script initialization here ****  

Option Explicit  

On Error Resume Next  

dim fsoObject, targetFile  

set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

set targetFile = fsoObject.GetFile("d:\Test.vbs")  

   

' ********* Main processing section **********  

' Call a function that displays drive information  

Details()  

   

' *********** Procedures go here *************  

' This function displays file properties  

Function Details()  

 WScript.Echo("File properties of d:\Test.vbs")  

 WScript.Echo("-----------------------------------")  

 WScript.Echo("Created on:  " & targetFile.DateCreated)  

 WScript.Echo("Last Modified: " & targetFile.DateLastModified)  

 WScript.Echo("Last Accessed: " & targetFile.DateLastAccessed)  

 WScript.Echo("File Name:   " & targetFile.Name)  

 WScript.Echo("File Path:   " & targetFile.Path)  

 WScript.Echo("File Type:   " & targetFile.Type)  

 WScript.Echo("File Size:   " & targetFile.Size)  

End Function

The following output was displayed when I ran this script.

C:\>CScript "Script 7.vbs"  

Microsoft (R) Windows Script Host Version 5.6  

Copyright (C) Microsoft Corporation 1996-2001. All rights reserved.  

File properties of d:\Test.vbs  

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

Created on:  2/4/2008 11:23:36 PM  

Last Modified: 2/4/2008 10:38:52 AM  

Last Accessed: 2/4/2008  

File Name:   Test.vbs  

File Path:   D:\Test.vbs  

File Type:   VBScript Script File   

File Size:   1081  

C:\>  

Creating Documents, Reports, and LogsBy this point you should have a fairly good understanding of what the VBScript runtime objects are and what they can do. Now let’s look at how you can use them to generate reports, logs, and other types of text documents.To work with files and their contents you must first establish an instance of the FileSystemObject within your VBScript as shown here.

set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")

Next, you should always check to see if the file that you want to work with already exists. If it does, you can open it. If it does not already exist, you can create it and then open it. You can check to see if a file exists using the FileSystemObject object’s FileExists property as shown here.

If (fsoObject.FileExists("C:\displayText.txt" ) ) Then

You must open a file before you can work with it. You can use the FileSystemObject object’s OpenTextFile() method to open files. To use this method you need to supply a few pieces of information including the following. 
·         The name and path of the file to be opened
·         Whether you want the file to be opened for reading, writing, or appending
·         Whether to create the file if it does not existTable defines constants that are used to tell the OpenTextFile() method what you want to do once the file is opened. 

Table defines two options that govern what the OpenTextFile() method should do when the file to be opened does and does not exist. 

Opening and Closing Files

It is very important that you correctly specify the type of operation that you are opening a file for (reading, writing, or appending). If you open a file to write to it and the file exists, then the file will be reinitialized. In other words, any data that is already in the file is lost and the file pointer is placed at the beginning of the new file (in the first row and column of the file).By appending to a file, you are able to preserve its contents and add to it. In other words, the file is opened and the file pointer is placed at the end of the file in the last row and column position.The file pointer is used to identify where the next character of data will be placed with a file. In a newly initialized file, the pointer would automatically be positioned in the upper-left corner (row 0, column 0). If one new character of information were added, the pointer would be moved over one position to column 1 in row 0. If a carriage return were added (indicating an end-of-line marker), then the file pointer would move to column 0 row 1. Knowing the location of the file pointer and how it is moved around is important, especially if you will be writing to or reading from files that have fixed record formats with data fields starting and ending in specified column positions. Okay, enough about the file pointer. Let’s look at an example that ties together everything that we have talked about. In this example, I’ve written a VBScript that opens a file named myFile.txt, which resides in the root directory of my C: drive. If the file already exists, then the script opens it but if it does not already exist it will be created and opened.

' * Script Name: Script 8.vbs       *  

Option Explicit  

On Error Resume Next  

Dim fsoObject, open_File, target_File  

Set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

target_File = "D:\ displayText.txt"  

' ********* Main processing section **********  

' Call a function that displays drive information  

Open_File()  

open_File.WriteLine "This line of data should be written to the text file."  

Close_File()  

' *********** Procedures go here *************  

' This function opens a file  

Function Open_File()  

 If (fsoObject.FileExists(target_File ) ) Then  

  Set open_File = fsoObject.OpenTextFile(target_File, 8 )  

 Else  

  Set open_File = fsoObject.OpenTextFile(target_File, 2, "True" )  

 End If  

End Function  

   

' This function closes a file  

Function Close_File()  

 open_File.Close()  

End Function

The file is opened using the forWriting constant ( with a value of 2 ) if it already exists. If the file does not exist, then the forAppending constant (with a value of 8 ) is specified to open the file and place the file pointer at the end of the file.If you take at look at the script’s main processing section you will see the following statement between a pair of function calls, which open and close the file.

open_File.WriteLine "This line of data should be written to the text file."

This statement writes one line of data to the file and executes a carriage return placing the file pointer in the first column of the following line. I’ll talk more about the use of this and other methods that are used to write data to files in just a bit. The last statement in the main processing section calls a function that executes the following statement.

open_File.Close()

This statement executed the FileSystemObject object’s close() method i to close the opened file. You must remember to close any file that you open before allowing your script to end. Failing to do so may cause an error the next time that you open the file because the end-of-file marker will not have been created.Run this script and open the myFile.txt file and you’ll see the following line of data.
This line of data should be written to the text file.

Writing to Files

As you just learned, you should always check for the existence of a file before creating it. Once opened, you have several different ways in which you can write text data to your files.One option is to write a specific number of characters at a time. This technique is best used when you need to write carefully formatted data to your files such as when you write reports with data that appears in columns. Another option for writing to a file is to write an entire line of data at a time. This technique is best used when your documents are more free-formed and is probably the option that you’ll use most often, especially if you plan to create log files in which you record error messages and other types of event information as your scripts execute.Finally, you might want to add blank lines to your files. Blank lines are especially useful for formatting your documents to improve their presentation and make them easier to read.
Adding Characters to a File
You can write a specific number of characters to a file at a time using the FileSystemObject object’s Write() method. This method does not automatically append a carriage return at the end of each write operation. Therefore, the next time a write operation occurs additional text is inserted immediately following the text written by the previous write operation.The following example demonstrates how you can use the Write() method to append text to an existing file.

Set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

Set open_file = fsoObject.OpenTextFile("d:\ displayText.txt", 8 )  

open_file.Write("Welcome to ")  

open_file.Write("KR Testing Solutions!")  

open_file.Close()

As you can see even though two separate write operations occurred, the text for both write operations was placed on the same line.
Adding a Line to a File

By replacing the Write() method with the FileSystemObject object’s WriteLine() method in the previous example, you can change the previous script to write data to the file a line at a time.

Set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

Set open_file = fsoObject.OpenTextFile("d:\ displayText.txt", 8 )  

open_file.WriteLine("Welcome to KR Testing Solutions!")  

open_file.Close()

The WriteLine() method automatically adds a carriage return to the end of each line returning the file pointer to the first column of the next line.
Adding Blank Lines to a File

If you want to format your text files with blank lines to create better looking reports or make them easier to read you can use the FileSystemObject object’s WriteBlankLines() method. When executed, this method writes a blank line to the file and executes a carriage return.The following example demonstrates how to use the WriteBlankLines() method to format the data in a small report.

Set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

Set myCDrive = fsoObject.GetDrive("d:")  

Set open_file = fsoObject.OpenTextFile("d:\ displayText.txt", 8 )  

   

open_file.WriteLine("------------------------------")  

open_file.WriteBlankLines(1)  

open_file.WriteLine("   My d: Drive Report   ")  

open_file.WriteBlankLines(1)  

open_file.WriteLine("------------------------------")  

   

open_file.WriteBlankLines(2)  

   

open_file.WriteLine("File System - " & myCDrive.FileSystem)  

open_file.WriteLine("Total Size - " & myCDrive.TotalSize)  

open_file.WriteLine("Free Space - " & myCDrive.AvailableSpace)  

   

open_file.Close()Reading from Files

Reading the contents of a file is handled in much the same way as writing to it. First, be sure that the file exists. If it does, then your script may open it. The next thing your script should do is use the TextStream object’s AtEndOfStream property to find out if the file has any data in it. After all, there is no point to trying to read an empty file. In fact, you should check the value of the AtEndOfStream property just before each read operation to be sure that your script has not reached the end of file marker (e.g., the end of the file). The first thing that you need to do to begin reading a text file is create an instance of the FileSystemObject and then use the FileSystemObject object’s OpenTextFile() method as shown here.

Set fsoObject = CreateObject("Scripting.FileSystemObject")  

Set open_file = fsoObject.OpenTextFile("d:\ displayText.txt", 1 )

As you can see the forReading constant has been specified. Next you could set up a loop that runs until the AtEndOfStream property has a value of true (the end of the file is reached). During each iteration of the loop your script should read a line of text using the FileSystemObject object’s ReadLine() method as shown here.

Do while False = open_file.AtEndOfStream  

 WScript.Echo(open_file.ReadLine())     

Loop   

 

The preceding VBScript statements will process every line in the file, terminating when the end of file marker is reached. After your script is done reading the file, it can close it as shown here.
open_file.Close
If you put these lines of code together and ran them as a script using the CScript execution host you’d see output similar to the following.

C:\>CScript test.vbs  

Microsoft (R) Windows Script Host Version 5.6  

Copyright (C) Microsoft Corporation 1996-2001. All rights reserved.  

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

   My d: Drive Report  

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

File System - NTFS  

Total Size - 2146631554  

Free Space - 234554452  

C:\>  

 

In this example we read an entire file by reading it one line at a time. There are a number of other techniques for reading files. These include 
·         Skipping lines when reading a file
·         Reading a specified number of characters from a file
·         Reading an entire file in one operation
Skipping Portions of a File

If a file has headers or other information that you are not interested in reading you can always skip them and read only the portion of the file that interests you. For example, the file that we have been working with contains a five-line header followed by two blank lines after which the data in the report begins.You can use either of the following methods, both of which belong to the FileSystemObject, to skip text in a file. 
·         Skip(). Skip a specific number of characters
·         SkipLine(). Skips a lineThe Skip() method lets you supply a number indicating how many characters should be skipped. For example, the following statement would skip 25 characters in a file referenced as open_file.

open_file.Skip(25)

Unfortunately, the SkipLine() method does not allow you to pass it a number, indicating how many lines to skip. If you want to skip more than one line, you can wrap the method up inside a loop as demonstrated here.

For i = 1 to 7open_file.SkipLine()Next

Here the first seven lines of the file referenced as open_file would be skipped.
Reading Formatted Data

If your file has been formatted to contain fixed length data, then you have the option of reading it by character instead of by line. To do so you will use the FileSystemObject object’s Read() method.The following example demonstrates how to use this method. Here a reference is set up for a file named myfile.txt. Then a For loop is set up to skip the first seven lines of the file using the SkipLine() method. Next the Skip() method is used to skip the first fourteen characters on the eighth line. Finally the next four characters, beginning with the twenty-third character are read and then displayed. Then the file is closed.

Set fsoObject = CreateObject("Scripting.FileSystemObject")  

Set open_file = fsoObject.OpenTextFile("d:\ displayText.txt", 1 )  

For i = 1 to 7  

 open_file.SkipLine()  

Next  

   

open_file.Skip(14)  

WScript.Echo("The file system in use on this drive is: "  

& open_file.Read(4))open_file.Close

Reading Entire Files

Another way in which you can read files is to read the entire file all at once using the FileSystemObject object’s ReadAll() method as demonstrated in the following example.

Set fsoObject = CreateObject("Scripting.FileSystemObject")  

Set open_file = fsoObject.OpenTextFile("d:\ displayText.txt", 1 )  

read_rpt = open_file.ReadAll()open_file.Close()MsgBox(read_rpt)

In this example, the entire file is read using a single statement, which assigns the data read by the ReadAll() method to a variable named read_rpt. The file is then closed and the value of read_rpt displayed using the VBScript MsgBox() function.

Performing File and Folder Administration
z
Managing your files and folders can involve a lot of work. Using VBScript and the WSH you can automate much of this work. For example, typical file and folder tasks involve copying or moving files and folders from one location to another in order to create backups or better organize them. Administration may also include deleting files once they have been processed or after they have reached a certain age.You can use methods belonging to the FileSystemObject to manage one or more files or folders at a time. FileSystemObject methods for handling files include 
· CopyFile(). Copies one or more files.
·         MoveFile(). Moves one or more files to a different location.
·         DeleteFile(). Delete one or more files.
·         FileExists(). Provides verification of whether a file contains data.The FileSystemObject also provides a number of methods that you can use to manage Windows folders, including 
·         CopyFolder(). Copies one or more folders.
·         MoveFolder(). Moves one or more folders to a different location.
·         DeleteFolder(). Deletes one or more folders.
·         FolderExists(). Provides verification of whether a folder exists.
·         CreateFolder(). Creates a new folder.Alternatively, you can also use the File and Folder objects to manage your files and folders instead of the FileSystemObject. These two objects share many of the same methods, including 
·         Copy(). Copies a file or folder to the specified location.
·         Delete(). Removes the specified file or folder.
·         Move(). Moves a file or folder to the specified location.

Next Step – File System Object

VBScript Runtime Properties

Like the objects in the WSH core object model, VBScript runtime objects provide an extensive supply of properties. You can use the properties to view or change numerous file system attributes. These properties are listed here. 
·         AtEndOfLine. Returns a value of either true or false depending on whether the file pointer precedes the TextStream file’s end-of-line marker.
·         AtEndOfStream. Returns a value of either true or false depending on whether the end of a TextStream file has been reached.
·         Attributes. Retrieves or sets file and folder attributes.
·         AvailableSpace. Retrieves the amount of free space available on a drive.
·         Column. Retrieves the current column position within a
TextStream file.
·         CompareMode. Retrieves or sets the comparison mode used to compare a Dictionary object’s string keys.
·         Count. Returns a count of the items in a collection or Dictionary object.
·         DateCreated. Returns a file or folder’s creation date and time.
·         DateLastAccessed. Returns the date and time that a file or folder was last accessed.
·         DateLastModified. Returns the date and time that a file or folder was last modified.
·         Drive. Returns the drive letter representing the drive where a file or folder is stored.
·         DriveLetter. Returns a drive’s drive letter.
·         Drives. Creates a Drives collection representing the computer’s Drive objects.
·         DriveType. Returns a value indicating a drive’s type.
·         Files. Creates a Files collection representing the File objects stored inside a folder.
·         FileSystem. Returns the file system type implemented on a drive.
·         FreeSpace. Returns the amount of free space available to the user on a drive.
·         IsReady. Returns a value of either true or false depending on whether a drive is available.
·         IsRootFolder. Returns a value of either true or false identifying whether a folder is the root folder.
·         Item. Retrieves or sets an item based on the specified Dictionary object key.
·         Key. Sets a Dictionary object key.
·         Line. Returns the current line number in the TextStream file.
·         Name. Retrieves or sets a file or folder’s name.
·         ParentFolder. Retrieves a file or folder’s parent folder object.
·         Path. Retrieves the path associated with a file, folder, or drive.
·         RootFolder. Retrieves the Folder object associated with the root folder on the specified drive.
·         SerialNumber. Retrieves a disk volume’s serial number.
·         ShareName. Retrieves a network drive’s share name.
·         ShortName. Retrieves a file’s or folder’s 8.3 character short name.
·         ShortPath. Retrieves the short path associated with a file’s or folder’s 8.3 character name.
·         Size. Retrieves a file’s or folder’s byte size.
·         SubFolders. Establishes a Folders collection consisting of all the folders located inside a specified folder.
·         TotalSize. Returns the total number of bytes left on a drive.
·         Type. Retrieves information about a file’s or folder’s type.
·         VolumeName. Retrieves or sets a drive’s volume name.

VBScript Runtime Methods

The methods that belong to the VBScript runtime objects are listed here.

VBScript Run-time Methods
·         Add (Dictionary). Adds a key and item pair to a Dictionary object.
·         Add (Folders). Adds a Folder to a collection.
·         BuildPath. Appends a name to the path.
·         Close. Closes an open TextStream file.
·         Copy. Copies a file or folder.
·         CopyFile. Copies one or more files.
·         CopyFolder. Recursively copies a folder.
·         CreateFolder. Creates a new folder.
·         CreateTextFile. Creates a file and a TextStream object that can be used to read and write to the file.
·         Delete. Deletes a file or folder.
·         DeleteFile. Deletes a file.
·         DeleteFolder. Deletes a folder’s contents.
·         DriveExists. Returns either true or false depending on the existence of a drive.
·         Exists. Returns either true or false depending on whether a key exists in a Dictionary object.
·         FileExists. Returns either true or false depending on whether a file can be found.
·         FolderExists. Returns a value of true or false depending on whether a folder can be found.
·         GetAbsolutePathName. Returns a complete path name.
·         GetBaseName. Retrieves a filename less its file extension.
·         GetDrive. Returns the Drive object associated with the drive in the specified path.
·         GetDriveName. Retrieves the name of a drive.
·         GetExtensionName. Retrieves a file’s extension.
·         GetFile. Retrieves a File object.
·         GetFileName. Retrieves the last filename or folder of the specified path.
·         GetFileVersion. Retrieves a file’s version number.
·         GetFolder. Retrieves the Folder object associated with the folder in the specified path.
·         GetParentFolderName. Retrieves the name of the parent folder.
·         GetSpecialFolder. Retrieves a special folder’s name.
·         GetTempName. Retrieves the name of a temporary file or folder.
·         Items. Returns an array containing the items in a Dictionary object.
·         Keys. Returns an array containing the keys in a Dictionary object.
·         Move. Moves a file or folder.
·         MoveFile. Moves one or more files.
·         MoveFolder. Moves one or more folders.
·         OpenAsTextStream. Opens a file and returns a TextStream object that can be used to reference the file.
·         OpenTextFile. Opens a file and returns a TextStream object that can be used to reference the file.
·         Read. Returns a string containing x number of characters from a TextStream file.
·         ReadAll. Reads the whole TextStream file and returns its contents.
·         ReadLine. Reads a line in a TextStream file.
·         Remove. Deletes a Dictionary object’s key, item pair.
·         Skip. Skips x number of character positions when processing a TextStream file.
·         SkipLine. Skips a line when processing a TextStream file.
·         Write. Places a string in the TextStream file.
·         WriteBlankLines. Writes x number of newline characters to the TextStream file.
·         WriteLine. Writes a string in the TextStream file

Next Step – File Scripting

The VBScript MsgBox Function

The MsgBox function provides a way for you to display a pop-up dialog and ask the user to respond by clicking the appropriate button. The syntax of the MsgBox function is shown here.

MsgBox(prompt [, buttons] [, title] [, helpfile, context])

Prompt is the text message displayed by the dialog and can be as many as 1,024 characters long. Button is a numeric expression or value that is the sum of a number of other values that specify.
§                    The types of buttons to display
§                    The type of icon to be displayed in the dialog
§                    The button to be selected by default
§                    The modality of the dialog

Option Explicit 

Dim myResponse 

myResponse = MsgBox("Do you wish to quit?", 1, "What do you wish to do?")

The VBScript InputBox Function

The InputBox() function provides a way for you to display a pop-up dialog that prompts the user to supply text input. The InputBox allows you to ask the user questions and collect text input. The syntax of the InputBox() function is shown here.

InputBox(prompt [, title] [, default] [, xpos] [, ypos] [, helpfile, context])

For example, the following statements prompt the user to type the name of the country in which he or she resides.

Option ExplicitDim myInput 

myInput = InputBox("What country do you reside in?")

Next Step – File and Folder Functions

  Dim arrayname(dimensions)

Dimensions is a comma-separated list specifying the length of each of an array’s dimensions. For example, the following statement defines a single dimension array called myArray that can hold up to four elements.

Dim myArray(2)

An array is an indexed list. The first value stored in the array is automatically assigned an index value 0. The second element stored in an array has an index value of 1, and so on. Because an array’s index always begins with zero the actual length of an array dimension is equal to the number supplied in the declaration statement plus one. So the array defined above can hold up to 4 elements.Once you have defined and array you can populate it as demonstrated here.

myArray(0) = "Welcome"myArray(1) = "To"  

myArray(2) = "KR Testing Solution"

After you have populated an array you can reference its contents. For example, you could use the following statement to display the value stored as the third element in the array.

WScript.Echo myArray(2)

The following examples show how to create an array with more than one dimension. In this case, a two-dimensional array is created using the Dim statement that can store its data in a spreadsheet like format.

Dim myArray (4,4)

You can think of the array created by this example as having five rows by five columns. Remember, the length of any array dimension equals 1 plus the value that specified its length. Similarly, your could define a three-dimensional array by adding additional comma separated values in the Dim statement as shown here.

Dim myArray (4,4,4)

Next Step – Message Dialogs

Functions

VBScript functions are collections of related VBScript statements that are called and executed as a unit. Functions can also return a result to calling statements. The syntax for creating a function is

[Public | Private] Function name [(arglist)]  statements End Function

Private and Public are optional keywords. The Private keyword is used to set up a function that can only be called from within the script where it has been defined. When used, the Public keyword allows the function to be called by other scripts. Name identifies the function’s name. Arglist is used to specify one or more arguments that that can be passed to the function.To return a result to the statement that called the functions you must be sure that the subroutine has a variable of the same name as the subroutine. The value that the subroutine assigned to this variable is what will be returned.The following example shows a WSH VBScript that has two functions.

' * Script Name:   Script 3.vbsOption Explicit

Const Message = “Welcome to KR Testing Solutions”
Dim string1
Dim string2
‘ *********** Main processing section ****************
‘ Collect the First String
string1 = GetFirstString()
‘ Collect the Second String
string2 = GetSecondString()
‘ Display message
WScript.Echo Message & ” ” & string1 & ” ” & string2
‘ ********* Subroutines & Functions go here **********
function GetFirstString()
GetFirstString = InputBox(“What is your 1^st String?”)
End Function

function GetSecondString()
GetSecondString = InputBox(“What is your 2^nd String?”)
End Function

Subroutines

Subroutines work almost exactly like functions except that they are unable to return any results to the calling statement. The syntax for creating a subroutine is shown here.

[Public | Private] Sub name [(arglist)]  statements End Sub

Next Step – Array Decleration