Q. 28: What are the environmental prerequisites prior to playback of RFT scripts?

Ans.

- Make sure that the application under test is in the same state that it was in when you record the script.
- Ensure that applications and windows that were open or displayed or active when we started recording the script must be open or displayed or active when we start playback.
- Ensure to restore relevant network settings, active databases and system memory (if any) to the same state as when the script was recorded.

Q. 29: When we run a RFT script what actions are performed?

Ans. When script runs from Rational Functional Tester, it plays back all recorded actions. Playback Monitor starts and provides information when the script plays back. A log file gets displayed after the script runs completed. When script runs from Test Manager, Test Manager creates a temporary suite, runs the suite and removes the suite after the run is completed. We can run a script either from the Test Manager Test Scripts window or from the Test Manager File menu.

Q. 30: Out of test scripts or test cases which one should be run to generate test case results?

Ans. Test cases should be run to generate test case results instead of the script. If we run a script the Test Manager does not generate test case coverage results.

Q. 31: Describe the process of debugging of scripts in Rational Functional Tester.

Ans. If the scripts are recorded in the Java programming language - debugging scripts is the same process as debugging a Java application. If the scripts are recorded in the VB.NET Scripting - debugging scripts is the same process as debugging a Visual Basic application.

Q. 32: What is the procedure to create data pools in Rational Functional Tester?

Ans. A data pool is a test data set - a collection of related data records which supplies data values to the variables in test script during test script play back. You can create data for a data pool from scratch or we can import existing data into a new data pool from another Functional Tester data pool or from a .csv file.

Note: If you need to import the data, you will need to import the data into the same Rational Functional Tester project as the test scripts that access the data. If you need to import data from Test Manager data pool, you will need to first associate a RFT project with a Rational project to use the Test Manager data pool.

Q. 33: What type of changes we can do in a data pool?

Ans. Once we data drive a test to create a data pool or create an empty data pool, then we can edit the records and variables in the data pool. We can
1) Add – Remove – Move - Edit a record and variable
2) Edit data pool values
4) Cut - Copy or Paste a cell or record or a variable

Q. 34: Can we replace literal values in a script with data pool references?

Ans. Yes. We can replace literal values in existing script with data pool references to add realistic data to the script. We can replace all literal values or just the number or string or Boolean literals with a data pool reference. If we do not use an existing datapool variable, then the same literal values are used each time we run the script.

Q. 35: Which events take place when we run a script?

Ans. Verification point accesses the data in the datapool and creates the expected results from the baseline and the active data pool record. Datapool reference resolves and supplies data to verification point. The expected result is compared to the actual result. The expected and actual results are recorded in the log. Any deviations from the expected results are logged as a failure in the test log.

Q. 36: Name the two types of datapool record selection orders available in RFT?
Ans. Sequential record selection order and Random record selection order.

Q. 37: Explain the purpose of Test Object Inspector?

Ans. It is used to get a display of the test object information in running application. The information can be of parent hierarchy, inheritance hierarchy, test object properties, non-value properties and method information. Test Object Inspector automatically tracks the cursor and performs live updates after the application is opened. Test Object Inspector does not capture the object / objects in the application if it is not active.

Q. 38: What is the wait state feature for the objects?

Ans. In RFT, this feature is used to set wait state for an object during the playback to check its existence. It is useful when waiting for an object after starting the application or after other actions taking a long time.

Q. 39: What happens to the related files when we rename a test asset?

Ans. When we rename a script, Rational Functional Tester renames all its related files like the helper script files, private object map and any verification point files. If you rename a test object map, the associated scripts with the new name gets updated.

Note: After renaming operation, we need to change all callScript commands in scripts which reference the old script name.

Q. 40: How Data driving testing is helpful in RFT?

Ans: During data driven testing, the script uses variables for key application input fields and programs instead of literal values so that we can use external data to drive the application being tested. Data driven testing uses data from an external file called as datapool. We can add data to the data pool after finishing the recording of the test script.

Q. 41: Name two methods to select an object in an application under test in RFT?

Ans. Object Finder Tool method and Test Object Browser method

Q. 42: Name the various types of datapools in Rational Functional Tester.

Ans. There are two types of datapools: Private datapool and Shared datapool

Q. 43: In how many ways test scripts can be saved in RFT?

Ans. Three ways: Save the current test script or file, Save all test scripts & files and Save a script under another name

Q. 44: Sometimes record monitor goes blank when recording against Java or HTML application. What is the reason for that?

Ans. Record Monitor goes blank while recording against Java or HTML application when JREs or browsers are not enabled.

Q. 45: What are the actions performed by the agent computers?

Ans.

- Running the scripts on more than one computer.
- Test different machine configurations.
- Run Functional Tester scripts remotely on Linux or Windows computers.

Q. 46: What is required to run a RFT script from Test Manager?

Ans. Java Scripting / VB.NET Scripting. On a remote computer, you need to install Rational Test Agent software on the Agent computer and start the agent.
However, if we need external library to run scripts, then we need to install the software on the system on which we plan to run the script. To install a .dll, you need to add the library to directory that is in system search paths and to install a .jar file, you will need to add it to the Functional Tester customization directory. Default location for the customization directory is: C:\ Documents and Settings \ All Users \ Application Data\IBM\RFT\customization

Q. 47: What is the purpose of using Script Assure in RFT?

Ans. This feature helps the successful playback of scripts even when the application under test has been updated. We can play back scripts in RFT by using the ScriptAssure feature to control object-matching sensitivity.
For RFT to recognize an object in the application-under-test, the object properties must match the properties recorded in test object map. RFT can find the object if 1 or 2 properties do not match. If 2 properties do not match, RFT gives a weak recognition warning to the log. If more than 3 properties do not match, RFT cannot find the object in the application.

Q. 48: Ways of using ScriptAssure in RFT.

Ans. - Standard way: ScriptAssure Page - Standard controls object-matching sensitivity during playback by using a slider control.
- Advanced way: The ScriptAssure Page - Advanced sets thresholds for recognition scores. You can set a maximum score to consider a test object as a candidate for recognition.

Q. 49: What is the purpose of Hover feature during recording?

Ans. Hover feature is useful to move the mouse towards a particular place during playback in HTML application. It is helpful for clicking on menus or links in HTML testing.

Q. 50: What are the six steps involved in test development using RFT?

Ans

- Restore test environment and set the playback options.
- Play back each script against the same version of the application under test that was used for recording.
- Analyze the results in the Rational Functional Tester log.
- Use Functional Tester Verification Point Comparator for determining the cause of verification point failures.
- If the script fails; then edit it or debug it or re record it so that it runs as required.
- If we associate a Rational Functional Tester project with the current Rational project, we can group various scripts into test suite and play back the suite to verify that the scripts work properly.

Q. 51: What are the two main phases of script playback?

Ans. Test Development Phase and Regression Testing Phase

Q. 52: What are the six steps involved in regression testing phase using Rational Functional Tester?

Ans.

- Restore testing environment and set playback options.
- Play back test script against a new build of the application under test.
- Analyze the test results in the Rational Functional Tester log.
- Use the Rational Functional Tester Verification Point Comparator to determine the cause of verification point failures.
- If required, revise your test scripts to use new features in the application under test and playback the revised test scripts.

Q. 53: What is purpose of Playback Monitor in Rational Functional Tester?

Ans. Using playback monitor, during the playback of script; we can view the script name, number of the line that is executing, status icons and a description of the action in progress.

Q. 54: What are the Local and agent computers / machines in RFT?

Ans. When we associate Rational Functional Tester project with a Rational project, we can use Test Manager to run the RFT scripts on computers that are designated as Agent computers from a single Windows computer called the Local computer.

Also See:

- Rational Functional Tester Interview Questions - 1

Q. 1: What are the main features of Functional Tester?

Ans.
- Complete functional testing of the application
- test the state of objects through verification points.
- Testing any object in the application, including the object's properties and its data.
- Creating and editing simple object-oriented test scripts.
- Generating code through wizards, for example automatically creating a verification point through wizard.

Q. 2: What Process is followed by Rational Functional Tester for test automation?

Ans. Recording of Test Scripts, Enhancing the Test Scripts and then Playing Back the Scripts

Q. 3: For how many development platforms & Languages Functional Tester is available?

Ans.
- Java Scripting uses the Java language and the IBM Rational Software Development Platform.
- VB.NET Scripting uses the VB.NET language and the Microsoft Visual Studio .NET development environment.

Q. 4: What is benefit of test object map in Rational Functional Tester?

Ans. Test object map gets created automatically when recording the script for the application under test. It provides quick way to add objects to a script. It creates a list of test objects available in the application whether they are currently displayed or not. We can create a new test object map either by basing it on an existing map or by adding objects as required. It contains recognition properties for every object; so we can update the recognition information in one central location. Therefore, any scripts using this test object map shall be able to share the updated information. Test object maps created for HTML applications are more hierarchical than those created for Java applications. A browser is the top level of the test object map and the HTML application is inside the browser.

Q. 5: How various objects are identified by Functional Tester?
Ans. In Functional Tester object-oriented technology is used to identify various objects by their internal object properties and not by their screen coordinates. Thus even if the location or text of an object changes, the Functional Tester can still find it on playback.

Q. 6: In how many ways we can test the applications on Linux using RFT?

Ans.
First Way: We can record a script on Windows Environment and export it to Linux & then play it back on Linux.

Second Way: By writing scripts using the Test Object Insert tool. Instead of creating an object map through recording we populate it outside of the recorder by opening the map and selecting objects in the test application.
We can insert verification points without recording, by opening the Verification Point wizard from the Script Explorer.

Q. 7: What are two types of TestManagers in RFT?

Ans.
1) TestManager: It includes the Test Manager Log, running Windows & Linux remote playback agents and test management features like running scripts as part of a test suite. Functional Tester has its own logs and does not depend on the TestManager log integration.

2) ClearQuest Test Manager: It helps us in associating functional test scripts to Test Cases and executes them. Using CQTM we can analyze the received execution results and record those results for reporting and analysis.

Q. 8: What is a Rational and Functional Test project?

Ans. Rational Test project is used for storing test assets like test plans test cases, test logs, reports, builds etc. To associate a Functional Tester project with a Rational project, a Rational project needs to be created to store the test assets. Functional Test project stores all application test assets like scripts, object maps, verification point baseline files and script templates. Functional Test project is created before recording the scripts.

Q. 9: What is the use of associating a project with TestManager in RFT?

Ans. 1) Creating and playingback the scripts from within Rational TestManager.
2) Using the TestManager Agent for playing back scripts on remote computer.
3) You can view the scripts from the Test Scripts window of Rational TestManager.

Q. 10: Benefits of associating a Functional Tester project with Rational Project.

Ans.
1) Management of testing assets from one Rational project.
2) You can record and play back all Functional Tester scripts from Rational TestManager.
3) Playing back Functional Tester script on different computer using Rational Test Agents through TestManager.
4) Management Functional Tester logs using the Test Log window of TestManager.
5) Use of Test Manager reports to get information about the results of running Functional Tester test script and get coverage report for testing project.
6) Use TestManager suite to coordinate the way that scripts run.

Q. 11: Are there any restrictions when we disassociate a project from the current Rational project?

Ans. Yes. We can not play back Functional Tester script or test cases or suites that include Functional Tester scripts in disassociated project from TestManager. Test Manager deletes test script source from the disassociated project. This operation can not be undo. If we associate Functional Test project with Rational project again, TestManager creates new test script source.

Q. 12: Name three buttons available in Functional Tester Projects view banner.

Ans.
- Connect to Functional Test Project: It allows us to connect to an existing Functional Tester project.
- Refresh Projects: It enables us to repaint the display to reflect changes.
- Synchronize with Editor: It scrolls in the tree hierarchy to the name of the script currently displayed in the Java Editor.

Q. 13: Can we export Functional Test project items?

Ans. We can export project items like scripts, test object maps, Java files, Visual Basic files and data pools to another Functional Tester project. When we export a script Functional Tester includes all necessary files like shared test object maps even though it was not selected by us.

Q. 14: What is the utility of a verification points in Rational Functional Tester?

Ans. During the recording verification points can be inserted in the script to confirm the state of an object in the application.
A verification point captures the object information based upon the type of verification point and stores it in a baseline data file. The information in the base file becomes baseline of expected state of object during subsequent builds.

Q. 15: What types of verification points are provided by RFT?

Ans.: Rational Functional Tester has two types of verification points: Object properties verification point and Data verification points. Data verification point has five further points: Menu hierarchy verification point, Table verification point, Text verification point, Tree hierarchy verification point, List verification point.

Q. 16: How RFT playback depends upon the platform and the browser?

Ans.: Test playback in RFT is independent of the platform as well as independent of browser. E.g. we can record script on Windows and play it back on Linux. Also, the script contains no references to the browser during the recording, we can play back the script using any of the supported versions of Firefox, Mozilla, Internet Explorer or Netscape.

Q. 17: What host & test platforms supported by RFT?

Ans. Functional Tester runs on the following Host and Test platforms: Windows XP Professional, Windows 2000 Professional & Server, Windows 2000 Server & Advanced Server, Windows 2003 Enterprise, Standard & Server

Platforms supporting all functions of RFT except the recording: Red Hat Linux Enterprise Workstation 4.0, SuSE Linux Professional version 9.0, SuSE Linux Enterprise Server 10.0, Novel Desktop 10.0

Q. 18: What types of nesting of objects is supported by Functional Tester?

Ans. Parent-child nesting and Owner-owned nesting

Q. 19: Type of file extensions created while exporting Functional Test project items?

Ans. RFT compresses a copy of the files into a data transfer file with the name specified by us. It also appends a .rftjdtr (Functional Tester Java Scripting) or .rftvdtr (Functional Tester VB.NET Scripting) extension to it.

Q. 20: What is the helper superclass in RFT?

Ans. All Functional Tester scripts use default helper superclass. These scripts extend the RationalTestScript class and thereby inherit a number of methods. However, advanced users can create their own helper superclass (if they want to add additional methods or override the methods within RationalTestScript).

Q. 21: Name the Functional Test project items that can be imported?

Ans. Project items like scripts, test object maps, Java files or Visual Basic files, and datapools can be imported into a Functional Tester project. Functional Tester adds all the project items from the data transfer file into the project specified by us. We can use any file compression program which support the .zip to view and work with items in the data transfer file.

Q. 22: RFT provides how many type of delete Cookies methods?

Ans.
- Method of deleting all cookies for the current profile or user
- Method of deletes cookies in a specific page or domain for the current profile or user

Q. 23: How an application starts during recording the tests?

Ans. While recording tests the application can be started by using startApp command. It makes playing back the tests more reliable because startApp uses the application configuration information. RFT will open either Java applications that we specify or HTML pages in our browser, or run applications in executable form.

Q. 24: What is a test project in RFT?

Ans. Location where Functional Tester keeps all of the scripts, along with expected and actual results is called as a test project. The format of test project is governed by the environment being used.

Note: If you are using the Java language, create a Java test project. However you are using Visual Basic.NET, create a .NET test project.

Q. 25: How can we create a new RFT script without recording?

Ans. In new script > RFT includes import statements for files we need to compile the script and comments containing information of archiving. Functional Tester uses the script name as the class name and sets up testMain. Here, you can add the commands to include in the script.

Q. 26: Can we do recording in an existing RFT script?

Ans. Yes. We can do the recording in existing RFT script by bringing our cursor to the desired location & just start the recording. Start the application >> insert verification points >> and add all script support functions.

Q. 27: How can we record script for testing the HTML applications using RFT?

Ans.
- Enabling the Web browser: Enabling of the browser can be done by clicking on Configure > "Enable Environments for Testing". This will enable the environments for testing.

- Configuring the HTML applications for testing: It can be done by clicking on Configure > "Configure Applications for Testing" to specify information about our application and its environment. For testing MS HTML Applications (MSHTA), we need to run mshta.exe to configure application desired to be tested.

Historically, software testing has always been about finding where the software breaks. In fact, when we talk about the qualities of a good software tester we quote anecdotes about how "she was able to break my program in 3 minutes" or that "he found 27 bugs when running on Linux with Apache". In other words, software testing was about finding bugs and software testers would get rewarded for and take satisfaction from finding bugs.

Whereas agile testing is more about keeping the bugs out than finding the ones that are in there. The (automated) software tests that are written in agile testing are more about showing that the software works the way we expect than about finding where it breaks.

This doesn’t mean that agile testers should not attempt to find bugs nor that pre-agile testers never write tests to show what works. It means agile thinking has introduced a change in emphasis from “fault-finding” to “working software”.

In pre-agile days, developers would bang away on the code until they considered it done. Then they would throw the code over the wall to QA to find the bugs. QA's first task would be to find the places where it would break. They'd submit a whole bunch of bugs which developers would fix. This cycle would repeat until they couldn't find any more.

Software Testing now happens closer to the developer in space and in time. Software Testers design tests to show that the software works as expected. The developers and testers work together in a room to expand the set of cases that works. The bugs should never get introduced in the first place.

In the old days the conversation might have gone something like this:

=========================================================
Software Developer: The baby has been delivered.
Software Tester: Your baby is early,
Software Developer: Everything works.
Software Tester: C is broken
Software Developer: fixed C
Software Tester: E doesn't work with X
Developer: fixed E with X
and so on until the tester can't find any more bugs.
=========================================================

In agile environment, it would go more like this:

=========================================================
Software Developer: A is done
Software Tester: A works

Software Developer: B is done
Software Tester: B works
and so on until every case works
=========================================================

Nature of Agile Testing:
The biggest difference between agile projects and most ‘traditional’ software development projects is the concept of test driven development. With agile testing, every chunk of code is covered by unit tests, which must all pass all the time. The absence of unit level and regression bugs means that testers actually get to focus on their job: making sure the code does what the customer wanted. The acceptance tests define the level of quality the customer has specified (and paid for!).

Testers who are new to agile testing should keep in mind the agile values: communication, simplicity, feedback and courage.

Difference between Traditional Software Testing and Agile Testing:

Agile testing was different in many ways from ‘traditional’ software testing. The biggest difference is that on an agile project, the entire development team takes responsibility for quality. This means the whole team is responsible for all software testing tasks, including acceptance test automation. When software testers and programmers work together, the approaches to test automation can be pretty creative. Software Testing is integrated into software development. Having everyone in one room speeds up communication by an astonishing amount. Questions that might otherwise take a couple days to be answered over email are answered within a couple of minutes. There can be numerous occasions when hours of time could be saved by overhearing a conversation in the team room.

On traditional projects, folks with Quality somewhere in their title (Quality Assurance, Quality Engineers, et al) perform Independent Verification and Validation (IV&V) activities to assess the quality of the system. Often these teams also review design artifacts. Sometimes they also have a hand in defining and/or enforcing the process by which the software is made.

Agile project teams generally reject the notion that they need an independent group to assess their work products or enforce their process. They value the information that testing provides and they value testing activities highly. Indeed they value testing so much, they practice Test Driven Development (TDD), writing and executing test code before writing the production code to pass the tests. However, even though agile teams value testing, they don't always value independent testers. And they're particularly allergic to the auditing or policing aspects of heavyweight, formal QA.

So how can testers make themselves useful on a team that does not see much use in traditional, formal QA methodologies? Here's what they can do:

1. Supporting Programmer Testing (Technology facing):

When supplementing programmer testing the testers support the programmers in creating the software. They sit in the synergy with the programmers. If the programmers are practicing agile, it's a given that they have an extensive set of unit tests. The software tester’s role is not to do the programmers' unit testing for them. Instead, most of their work involves manual exploratory testing to discover important information about the software that the unit tests failed to reveal.

In order to do this, they have to:

- Get and build the latest source code.
- Run all the unit tests to verify they are starting from a "known good" place.
- Run the application (usually locally from the IDE).
- Minimize documentation: Test documentation can account for a large percentage of the test effort. An informal poll among 135 testers across 57 organizations revealed that testers spend about one third of their time just documenting test cases
- Occasionally add to the automated unit or acceptance test suites.
- Asking “what if” questions to programmers in the planning game. For example, “What if the migrated data has null values?” Analyzing risks and providing information early.
- Offering information about external dependencies or requirements that the team might not otherwise know about.

Unlike unit tests that use mocks and stubs to isolate the code under test, this exploratory testing is as end-to-end as possible. As a result, they are usually able to find issues and risks that the unit tests don't reveal. And they are finding them sooner than we would if we waited for the customer to try things end-to-end. (Early feedback is good.) In doing so, testers not only help the programmers improve the software, they also help them improve their unit tests.

To support programmer testing, you're going to have to be comfortable mucking about in source code. If you haven't coded in a long time (or ever) that means more than just learning Java or whatever language your organization uses. You'll also have to be comfortable:

- Working in the development environment the developers are using, whether that's Visual Studio, Eclipse, IntelliJ, or something else.
- Fetching and building the latest code from the source control system.
- Using the test frameworks the developers are using such as jUnit or NUnit.
- Configuring your own system and setting up your own data, so you may have to learn more about operating systems, networks, and databases

In short, technology-facing testers become members of the development team. You'll need to grow your technical skills accordingly.

Supporting Customer Testing (Business Facing):

The word "Customer" is used in the sense: The set of people who represent the business-facing stakeholders on a project, and not referring to the customers who pay for the software. When supplementing customer testing, they support them by helping them define and execute acceptance tests. Specifically, they:

- Walk through the existing software with them, using an interview-style conversation to surface assumptions and expectations.
- Use the information from walkthroughs and other sources to design and articulate acceptance tests.
- Use a variety of analysis techniques to discover risks and implications of decisions.
- Help the customers and programmers define what "good enough" means for their context.
- Execute acceptance tests manually where needed.
- Automate acceptance tests (either by automating them themselves or by working with a programmer or existing automation engineer)
- Provide metrics or other high level data as needed to help the Customer satisfy his management's need for numbers

In this second role, software testers spend as much of their time facilitating communication and clarifying expectations.

To help business stakeholders articulate their needs, you're going to end up doing a whole lot of requirements extraction. Business-facing testing is as much about distilling requirements and testing assumptions as it is about testing software. There's an entire body of knowledge on requirements analysis, design analysis, and modeling that can help.

- Consider brushing up on UML.
-Learn how to be an effective interviewer and facilitator.
-Grow both your analysis skills and soft skills.