Introduction: This document has been prepared in order to resolve the issue that might occur during Invocation of RPT- Agent Controller process on Linux Machine.

Requirement: Our requirement was to generate the load from Linux machine (client) on the application server

For this, we have installed Load Generating tool (Rational Performance Tool version - 7.0.2) on window machine (OS: Window XP 2000 Profession SP-2) and RPT-Agent controller Process (version-7.0.2.1) on Linux machine (OS-Red Hat Enterprise Linux AS release 4-Nahant).

Below are enlisted some of the issues which were encountered during the load distribution through load generating machine (RPT) to Linux machine.

On executing the performance schedule we were getting the following error "Connection failed on host 172.23.244.207".

????????????????????

Security Message

Connection failed on host 172.23.244.207

Reason:
IWAT0284E The agent controller is not available on host 172.23.244.207
Make sure that:
*the agent controller is installed.
*the agent controller is configured to communicate with your machine
*you have the correct host name and port number for the agent controller.

????????????????????'

Possible reason: The above error might have occurred due to Agent Controller is not installed or is not running on Linux machine.
Since, on Linux machine Agent Controller process (RAServer) process is not started automatically. So, we have to start this process manually.

Starting and Stopping Agent Controller on Linux machine:
• To start the Agent Controller process (RAServer) on Linux machine, move to the Installation location's bin directory (for e.g. /opt/IBM/AgentController/bin). Then execute the following command
./RAStart.sh

• To stop the Agent Controller process (RAServer) on Linux machine, move to the Installation location's bin directory ( for e.g. /opt/IBM/AgentController/bin) and then execute the following command
./RAStop.sh

On trying to start the Agent Controller process on Linux machine we may get the following Errors. (Below section describe the Error description, reason and resolution for the same)

Error:
1) Starting Agent Controller
"RAServer: error while loading shared libraries: libstdc++-libc6.2-2.so.3: cannot open shared object file: Error 40 No such file or directory.
RAServer failed to start." Error

Possible Reason: Since the Agent Controller is compiled using libstdc++-libc6.2-2.so.3 shared library. Ensure that this shared library exists under the /usr/lib directory. If it does not exist, then you have to install the RPM package compat-libstdc++ that comes with the operating system installation media.
Note: - To make sure that libstdc++-libc6.2-2.so.3 shared library is available in the /usr/lib directory:
Move to the /usr/lib directory and execute the following command at the Shell prompt.
# ls 'l libstdc*

Resolution:
The solution is to install the standard C++ compatibility libraries in order to satisfy this library dependency. The version of Linux on the client machine will determine what RPM or software package needs to be installed.
In our case, since we are using Red Hat Enterprise Linux As Release 4 (Nahant) Operating System on Linux machine, we need to install compat-libstdc++-296-2.96.132.7.2.i386.rpm package that is located on the Red Hat 4.0 Installation Disc 3.
Note: For more which rpm package required installing, browse the following link
http://seer.entsupport.symantec.com/docs/267077.htm

We can also download required rpm package from the following link
http://rpmfind.net/linux/rpm2html/search.php?query=libstdc%2B%2B-libc6.2-2.so.3&submit=Search
http://rpmfind.net/linux/RPM.

How to Install Required RPM Package:
1) Insert the required disc in CD-ROM and change the directory Red Hat/RPMS from Shell command.
cd media/CDROM/Red Hat/RPMS/
2) Enter the following command and execute
rpm 'ivh compat-libstdc++-296-2.96-132.7.2.i386.rpm
If installation is successful, you see the following message:
Preparing ########################################### [100%]
1:compat-libstdc++-296 ################################## [100%]
RPM prints out the name of the package and then prints a succession of hash marks as the package is installed as a progress meter.
Note: For more information on RPM package browse the following link
http://www.faqs.org/docs/securing/chap3sec20.html

Now we can start the Agent Controller Process (RAServer) on Linux machine. Following message should be displayed on successfully start the Agent Controller Process.

Starting Agent Controller
RAServer Started Successfully
RPM prints out the name of the package and then prints a succession

2) "RAServer failed to Start" Error
Possible Reason: This failure is usually caused when TCP/IP port 1002 is not free. Agent Controller listens on this port by default. Agent controller was just stopped and restarted before the port could be released.
• If Agent Controller failed to start. You can start it as follows:
If port 10002 is being used by another process, you can change the port number by editing the serviceconfig.xml file. Serviceconfig.xml file is located in Installation Location Config's directory /opt/IBM/AgentController/Config/

• If Agent Controller was just stopped, wait a few minutes and try to start it again.

By - http://www.qacampus.com







See Also



http://www.crestech.in



http://www.crestechsoftware.com.au

Borland silk test is a leading tool for functional and regression, cross platform and localization testing. It can test application based on vast set of technologies like Java, .Net , web , active x, adobe Flex ,client server etc. Silk Test's powerful testing framework enables high reusability of test scripts across test projects, building and maintaining regression testing suites and thus helps in expanding test coverage and optimize application quality.

Silk Test Features

A single, automated functional testing tool tests a broad range of enterprise technologies and environments?without costly connectors, adaptors or add-ins
• A wizard-driven toolbar workflow enables novice users to develop useful tests quickly
• Robust, resilient tests are supported by a flexible, object-oriented, fourth-generation scripting language called 4Test is designed expressly for automated testing
• Silk Test also offers functionality of test case management, test planning, data base function, date time functions etc. to make your automation more effective.
• Silk Test offers many features such as basic workflow for recording tests, workflow for linking a single test case to test data values stored in external tables and code completion in the SilkTest IDE .
• Unicode support allows localization testing of global applications on multiple platforms with a single script
• A built-in, customizable error-recovery system returns systems to pre-failure state and resumes testing, unlike other tools that leave systems unstable with unexecuted tests
• TrueLog based visual reports simplify problem diagnosis when you find defects
• Integration with Borland's software test management tool delivers enhanced management capabilities that support a mature and complete functional and regression testing process
• Built-in support for testing Adobe Flex applications using Internet Explorer, Firefox, the Standalone Flex Player, and Adobe AIR
• Animated Run Mode to provide 'slow motion' playback of test scripts

Architecture

Silk Test consists of two distinct components that execute in separate
processes:
• The Silk Test Host software
• The Silk Test Agent software

The SilkTest Host

The host software is the SilkTest component you use to develop, edit, compile, run and debug your test scripts and testplans. The machine that runs this component is often referred to as the host machine.

The SilkTest Agent

The SilkTest Agent is the component of SilkTest that interacts with the GUI of your application. The Agent translates the commands in your 4Test scripts into GUI specific commands, driving and monitoring the application you are testing. The Agent can run locally on the same machine on which the Host is running or, in a networked environment, any number of Agents can run on remote machines. In a networked environment, the machine that runs the Agent is often referred to as the remote machine.

How SilkTest Works and records user actions

Applications are composed of graphical user interface (GUI) objects such as windows, menus and buttons that a user manipulates using a keyboard and a mouse to initiate application operations. Silk Test interprets these objects and recognizes them based on the class, properties and methods that uniquely identify them. During testing, Silk Test interacts with the objects to submit operations to the application automatically, simulating the actions of a user, and then verifies the results of each operation. The simulated user, Silk Test, is said to be driving the application.

Before you begin creating and running test scripts, you create a repository of information about your application to be used by Silk Test. This repository includes descriptions of the GUI objects that comprise your application.Based on the properties and methods Silk Test associates with these objects, Silk Test can recognize the actions performed on them and intelligently record those actions into your test script using the 4Test language.

Test automation is normally developed in SilkTest host using either record/playback or by manual scripting using 4Test. Normally, test cases for SilkTest are developed in IDE (Integrated Development Environment) provided by SilkTest host software. Executing automated test suite is the responsibility of SilkTest agents. SilkTest even supports parallel execution of test cases with the help of these agents. SilkTest host can communicate with these agents residing on multiple machines and execute automated test cases on multiple machines simultaneously. Example , if you need to test your application on Windows 2000, Windows XP and Windows 2000 SP 2, you can have SilkTest agent installed on these machines and run automated test suite in parallel on all these machines at once. Feature like this, saves precious execution time for the testers.

In the next series we will discuss the testing process of silk test and will learn to create simple 4test scripts.

By - http://www.qacampus.com





See Also


http://www.crestech.in


http://www.crestechsoftware.com.au

QTP 10 revolves around 3 pivotal features, alongside several minor features (which turned out to be quite revolutionary):

I. QC integration ' which (mostly) boils down to Resource Management and Source Control:

Resource Management: Although you could keep saving your resources as attachments (for backward compatibility), you can upgrade to a new, fuller mode of work. This includes a whole new Resource module in QC, and allows for some very neat tricks on Function Libraries, Tests, Object Repositories etc.

It should be noted, though, that other types of files (external excel / XML files, for example), remain as unmanaged attachments.

1. Resources have full meta-data, and have a special view pane ' you can view Object-Repositories, data-tables, and function libraries code right from QC.

2. Resources are aware of their dependencies ' Who relies on them, and who do they rely on. This enables a very strong warning system ' when changing / deleting a resource, you'll be alerted to the repercussions ' namely, which tests, if any, might break. Also, the ability to immediately know who uses a share object repository is very useful, nearly revolutionary.

3. A very neat trick is a live, automatically updated path system ' When moving a function library between folders, QC will automatically update all the tests which depend on it, so they will use it at its new location. This makes the once critical problem of hard-path-link a non-issue. Very impressive.

4. A word about the user interface ' when opening a QC resource / test from QTP, the file dialog shows the items with large, crisp icons, very similar to Word's save dialog. Everything is very clear and intuitive, as is the ability to revert back to saving / opening a test from the File-System.

5. And what about your existing projects? Well, when upgrading to QC 10, a wizard will automatically transform all you unmanaged attachments to managed resources (if you'd like it to).

Source Control: This includes a very rich line of features which are very well executed, and effectively allow you to manage a QTP project as any other code project:

1. First, the basics ' QTP and QC 10 introduce a new Check-in/Check-out ability. It works similar to what you'd expect ' a checked out item will be locked to all other users, and you can immediately know an item's status by looking at its icon (green/red locks).

2. An interesting twist regards manner in which a test / resource is locked ' it's at the user level (not the local machine level). This means that if you log into QC from a different machine, you'll have access to all your checked-out items, even if they were originally checked-out on a different local machine. The ability is implemented very well, both from QTP's end, as well as from QC's end.

A major enabler for source control is the new versioning feature of QC. It manifests both with a kind of instant versioning for a single resource, and with a project-wide "base-line version", which allows you to revert your entire test framework to a previous version. Both types of versioning are supported by a surprisingly robust comparison mechanism. You can select two versions of a resource / test, a see a very detailed comparison of their respective changes. For function libraries this amounts to a "simple" text comparison, but this feature truly shines in full test comparisons.

It will present changes in the different actions and their resources (data-table, object repositories, inner code), as well as in the global test-settings, associated function libraries, recovery scenarios, and pretty much anything you could think of. The ability to drill-down into the data is very impressive; and the effective, concise manner in which the data is presented in the top level view is downright unbelievable. A nice touch is a small screen capture of the change, in case you don't remember what "Run all rows '>Changed into-> Run a single iteration only" means (for example).

Now to the versioning mechanism itself: Whenever you check and item in, a new "version" will be created, and you'll be able to revert back to it with ease. The snapshots are visible both from QC and QTP, and you can very easily choose which one to open. This allows you a kind of an instant undo to a single file which worked in the past, but is broken in the present.

The second mechanism presents the ability to select several folders, and create a full blown "base-line version" of them and everything they relate to. Defects, inner-connections, tests, history data, resources ' all these and more will be "frozen" and preserved as a base-line. You can then choose to revert back to an old baseline, and truly regain all the abilities that were present at that time. As all the resources, attachments tests and reports will be restored, you don't have to worry about forgetting anything, or leaving some minor resource at the wrong version. This is versioning with a vengeance ' it allows you to track the AUT's versions with your own automation versions, enabling, among other things, running automation efforts on several AUT versions at once.

For conclusion ' The new abilities inherit in the connection of QTP and QC Atlantis are (or at least seem to be) revolutionary. At last, QTP projects can be natively managed as code projects; and some of the supporting infrastructure is surprisingly robust and useful.

By - http://www.qacampus.com



See Also

http://www.crestech.in

http://www.crestechsoftware.com.au

II. Report improvements

The native QTP report includes several new improvements:

Tracability: Selecting a report-node will automatically focus on the relevant code-line in the script. This may sound like a cool feature at first, but a closer look revels that it only works for actions (not functions); and that in any case, using a custom report function (as most of us do) completely nullifies the feature (since you're always at the same code line when performing the report).

Exporting: The report now has a two-click export feature, which comes with a built-in ability to export to Word and PDF documents, as well as the ability to export through a custom XSL of your chaoosing. You can choose between Short and Long formats (corresponding to PShort.XSL and PDetails.XSL) to get a document relevant to your needs. This blessed feature has one major flaw ' It has no API support. This means that you cannot export the results automatically at the end of a test run, which is quite a miss, to say the least.

Resource Monitor: QTP can now hook onto the Windows Performance Monitor and present it as part of the test results. You can select several counters to monitor (e.g. GDI objects, memory usage etc.), and the monitor output graph will be available in special tab in the result window. You can set up a "checkpoint" for a counter (e.g. Fail the test if there are more than 500 GDI objects), facilitating a kind of a poor-man's version of load-testing.

The fact that clicking the graph focuses on the relevant test step (as well as the other way around), provides an effective way to quickly locate problematic actions and resource usage spikes. This feature is well executed, and HP has even went the extra mile and added several unified counters that simplify monitoring the application. However, the fact that you can only monitor one process per test may leave the more advanced users with their own implementation of a resource monitor.

Native image integration: This is a small, yet long-awaited feature. The ReportEvent command now has a new optional parameter ' you can specify a path to a picture file, and it will be attached to the report node of the current event. When used in conjunction with the CaptureBitmap method, this presents a technical, yet revolutionary upgrade to the native QTP report. Finally, users can attach screenshots to their custom report events without any special functions or frameworks.

III. IDE improvements

Intellisense: IDE improvements, and the new intellisense engine in particular, is what got me excited about QTP Atlantis.

Can create an Excel COM object provided a full intellisense for all its methods and properties, for as many levels as we'd like. Every variable set to this object also presented the same intellisense, and the autocomplete caught every variable we've defined or used (yes, there's autocomplete for variable names!). The autocomplete and intellisense features worked smoothly, and presented no apparent performance issue. It's still left to be seen how it functions in a real script, with hundreds / thousands code lines.

Tasks and Comment Pane: QTP has a new bottom pane which includes a run-of-the-mill implementation of tasks and comments. Double clicking a comment will take you to the relevant code-line, though strangely enough, you cannot do this with a task (i.e., tasks cannot be linked to specific code lines). It was mentioned that enabling the comments feature for function libraries may sometimes cause performance issues.

Dynamic code-zones: When standing inside a code block like If, While, Do, etc, the IDE will mark the relevant block with blue lines, making it much more easy to make your way inside nested blocks of this sort (somewhat like highlighting left-right bracket pairs). While it will surely make our life easier, a more robust mechanism like collapsible code-regions is still needed.

Custom Toolbars: You can add your own buttons and commands to QTP toolbars and menus. While this does not include inner-QTP macros, you can assign a program / File shortcut to your own button / menu item. It's nice, but i think it will only gain power once QTP's inner mechanisms will be bindable to such buttons.

IV. Miscellaneous features

General look and feel: QTP has departed from the old Tab layout, and into the more modern settings-tree layout (similar to Office, EMule, Adobe, and pretty much every other program). It's nice, but nothing as groundbreaking as the transformation in QTP 9.0.

Bitmap Checkpoint improvements: These include presenting the size of the selected area when choosing to check only a part of an Image, as well as the ability to plug your own custom DLL for comparing images. Another great addition is the ability to see the difference between the expected and actual bitmaps in a separate tab.

API changes: QTP Automation API will receive several upgrades, the most noteworthy of which is the ability to read and write that code of the test you've opened. Writing the code will not effect an ongoing run-session (there goes my ambitious try-catch implementation for QTP), but it still opens the door for some creative tweaks and hacks

Saving a test with all linked resources: For those who're working with QC, this is a real blessing. Up until QTP 10, copying a QC saved test to your local system was a hellish procedure of changing each and every resource and action reference to your local file-system. QTP and QC Atlantis offer a one-click solution for copying a test and all its resources to your local file-system, and automatically changing all the references accordingly.

Dynamic Action Call: I've saved the best for last. QTP 10 presents a new native command ' LoadAndRunAction. It allows you to load external actions during the run-session, without having to associate them with your test beforehand. All the run-time debug abilities will be available for these dynamically added actions, so you're not giving anything up by using this feature. I think it's a long awaited feature, and a well executed one.

By - http://www.qacampus.com

See Also
http://www.crestech.in
http://www.crestechsoftware.com.au

I wanted to share my understanding of USE CASES and get valuable inputs from you. I found use case very interesting and an easy way to design test cases. The name sounds a bit awkward. Doesn't it? So then what does it mean?

Use Case is a very effective elicitation technique which can be used throughout SDLC. It describes "who" can do "what" with the system in question. The use case technique is used to capture a system's behavioral requirements by detailing scenario-driven threads through the functional requirements. It is very effective where multiple user classes are involved. As compared to other approach (Requirement Itemisation) of test case designing from SRS, use case has some advantages:

• Easy to write

• Expressed in language of the user

• Can be visually represented

• Can be used for validation (acceptance testing)

• Tools support

• Ideal for OO development

• Where the system is functionally oriented (different types of users, complex behavioral patterns)

We should not use a Use Case when system has few users and is dominated by Non-Functional requirement. Now let us see the various entities involved in a Use Case.

• Actor: An Actor is someone or something that interacts with the system. Example of actors are People (Users), Devices, Other Systems, Organizations. Actors live outside the boundary of the system being defined and they initiate an action. Types of actors are Primary actor and Supporting actor.

A PRIMARY ACTOR is one who calls on the system to deliver a service. i.e. it has a GOAL with respect to the system. A PRIMARY ACTOR is typically who triggers the use case

Examples: A caller initiating a telephone call, a customer withdrawing money from the ATM

(Note: Use cases help identify Primary actors early in the lifecycle)

A SUPPORTING ACTOR is an external actor that provides a service to the system under design.

Examples: A high-speed printer, a web service

(Note: We can use supporting actors to identify external interfaces and the protocols the system will use. An actor can be primary in one use case and supporting in another).

• A GOAL is:

• What an ACTOR wants to get with the help of the system

• An ACTION is

• what the ACTOR must perform to reach the GOAL

• An INTERACTION is

• a sequence of steps that must be  followed to complete the ACTION

Examples of USE CASEs are:

1. "Purchase Goods" Level: User Goal

1. Visitor enters customer information (name, address, etc.).

2. System retrieves customer's profile information, and presents product search and selection mechanisms.

3. Visitor selects products until satisfied. After each selection, system adds the selected product to the customer's shopping cart and presents the ongoing running total of products selected.

4. Visitor selects to purchase the selected items.

5. System presents contents of shopping cart and requests customer's payment information.

6. Visitor enters manner of payment and other payment details.

7. System presents visitor with final sums, charges credit card, and delivers packing list to the shipping department.

2. "Book flight!" referencing "Find a flight-"

"Book flight!" Level: User Goal

1. The customer contacts the travel agency and requests a flight.

2. The customer finds a flight-.

3. The system presents the travel options to the customer.

4. The customer selects a flight.

5. The system builds and reserves flight itinerary for the customer.

7. The customer provides a credit card number.

8. The system charges the flight against it and issues the ticket.

"Find a flight-" Level: Subfunction

1. The customer requests to find a flight.

2. The travel agent captures the customer's trip origin and destination.

3. The travel agent looks up the airport codes for the origin and destination.

4. The travel agent captures the preferred departure times for the customer.

5. The travel agent captures the customer's preferred class of service.

6. The travel agent confirms that the customer's preferences are correct.

7. The system gets from the airline reservation system and presents a list of the available flights that match the customer's preferences.

To summarise, Use Cases are very helpful in deriving test cases from specification. Some of the good practices for writing Use Cases are:

• Make the use cases clear, short and easy to read: Use active voice, present tense, make sure actor and actor's intent are visible in each step.

• Every Use case has two possible endings: Success and Failure / alternate courses. Don't forget to gather both.

• Create a list of primary actors and their goals (actor-goal list).

• Restrict use cases to capture system behavior .use cases are not suitable for other type of requirements.

• Use a common template.

By - http://www.qacampus.com

See Also
http://www.crestech.in
http://www.crestechsoftware.com.au