Two years ago we announced that Software Product Compatibility Reports were launched and available to all clients. Today we are proud to say we've updated the look and feel of the reports to better match our support portal experience.
Along with the updated look and feel, we have a slightly updated URL as well:
If you've not previously used the compatibility reports, today is as good a day as any to create reports about a product's compatibility with operating systems, prerequisite software or virtualization environments. Easily generate custom reports about compatible IBM software combinations and use these to tailor-make graphical reports about a set of products' end of service dates.
As always, we are interested in your feedback on this tool. Each of the Reports includes a Feedback Survey to allow you to report problems or question with the use of the tool or the data presented. Please let us know what you think!
IBM Rational Functional Tester (RFT) is all about object recognition. If the graphical user interface (GUI) contains objects that Rational Functional Tester recognizes, you can record a sequence of actions. You can replay this sequence afterward.
This post wants to introduce you to object recognition in Rational Functional Tester.
The heart of object recognition in Rational Functional Tester is the object map. The object map is a graphical representation of the objects in your application under test that Rational Functional Tester encounters.
Through Windows hooks, Rational Functional Tester memorizes what actions you played in the GUI. Here, a hook means a mechanism that works between the keyboard or mouse and the GUI object.
Let’s say, when you click an object, information about that object flows from your video chip to the memory of Rational Functional Tester. During recording, Rational Functional Tester stores the information that the hook gathered.
For more information about hooks, see the following document on Microsoft.com.
When you finished recording, Rational Functional Tester puts the information about the objects into a kind of table. This table shows the objects of your application in a parent-child view. We call this table the object map.
With this object map, you can manipulate the way Rational Functional Tester recognizes the objects in your application under test. In this way, you can fine-tune your script to play back more easily, for example.
Roughly, the object map contains the following information about the objects that you touched during recording: administrative properties, recognition properties.
The object map displays the name that the developer gave to the object.
The name that you in the application’s graphical interface.
If you look at the picture, the domain is the first information that the object map reports about an object. In this example, we’re talking about a Java application. Therefore, the domain is Java. If the application runs in a browser, the object map would say HTML. The domain must match with the type of application under test.
These values are the properties that the recorder collects. These properties make the object unique. Therefore, when you run the script, Rational Functional Tester recognizes the object without ambiguity.
The recorder also assigns a weight. The weight says how important a property is for recognition. If you want, you can change the weight of any recognition property. In this way, you decide yourself what property is important for recognition.
In the sample application Classics Java, you can see the following properties of the Place Order button.
Unique ID: 1.3kaXiXo9H95:AQpC:Pyg70l9:8WW.
You can also see that the most important properties for recognition are the class name, accessible name, and name.
What to do with the object map
In the Rational Functional Tester Script Explorer, you see two kinds of test objects. You see an icon with caption Private Test Object Map. As the name “private” says, these objects belong only to that script that you recorded.
You can also make an object map that you can share with other scripts. With such a shared object map, you can change the object properties in a single place instead of all the private object maps. To create a test object map:
Right-click your project > Add Test Object Map.
When you right-click an object in the object map, you see a set of action that you can apply to the object. The most important are the following items.
Highlight test object
Insert test object
Highlight recognized objects
If Rational Functional Tester recognizes an object properly, you can highlight that object through the object map. Watch the video to see how that looks like.
Insert test object
If your application has an object that you didn’t record, you can still add these objects to the object map. Now, Rational Functional Tester can recognize the object when you run a script where the object does play a role.
Is there a better way? find() method
Sometimes, the object map is not an option. Sometimes manipulations on the object map are too tedious. Sometimes, the object map doesn’t contain an object that you want to play back. Then, the find() method is the way to go.
You can start with the class of RootTestObject. This class gives you access to your application. So to say, RootTestObject opens the objects of your application under test.
Let’s look at the syntax first. I show an example later.
public TestObject find(Subitem properties, boolean mappableOnly
For Subitem, you can use the following items.
A name or value pair that represents a TestObject property.
Contains properties that match with the direct child of the parent TestObject.
Contains properties that match with children or objects under the children of the parent TestObject.
Specifies a sequential properties list that match with atList.
public TestObject find(Subitem properties, boolean mappableOnly)
//Define window and find Place Order button RootTestObject root = RootTestObject.getRootTestObject(); TestObject matchingObj = root.find(atProperty("name", "placeOrder"));
The video shows how you can click the button Place Order in the sample application through the find() method. The find method is a different way to a click from a click through recording. In the video, you can watch the following steps.
Open the application under test.
Create an empty script.
Open the empty object map.
Click Insert Objects … to populate the object map.
Drag the object finder, the hand, to the caption bar of the application. This action casts a red rectangle around the entire screen of the application.
Select Include all available objects on this window. Then, click Finish.
Locate the Place Order button in the object map. Then, click Save.
Insert the following code into the script. This code makes the objects available in the application window.
Rational Functional Tester does not support custom objects.
When something is wrong with the object recognition, you see that the object map either doesn’t list the object and the Test Object Inspector doesn’t see the object. Also, when you see Win.GenericProxy or HTML.Generic.Proxy in the object map, you are dealing with a custom object. When you play back the script, you notice. For example, you get an ObjectNotFoundException.
From my experience, I would first check whether Rational Functional Tester recognizes the objects in the right kind of application. In other words, what domain the object map assigns to the objects. For example, the object map must say HTML for objects in a web browser.
If the domain is the right domain, you can see whether you can highlight the object through the object map. See the video in this post.
What to do with objects not in the object map
With the find method, you can also try to discover an object that Rational Functional Tester recognizes but doesn’t put in the object map. You can see these objects through the Test Object Inspector.
If you set the Test Object Inspector in the Options menu to not hiding objects that are not mapped. If you want to find objects that are absent in the object map, use the mappableOnly parameter. Now, you say that the Boolean value is false.
Object recognition is an important condition for Rational Functional Tester to work. A central role in the object recognition is the object map. You can manipulate the object map or use the find method.
I hope that I explained how the object map works and what you can do to improve object recognition.
If you’d like to share your experiences with object recognition in Rational Functional Tester, leave a comment here or follow me on Twitter.
The performance testing tool that IBM offers is Rational Performance Tester. A new feature in the version 9 that came out March 2016 is the Starter Edition. What's special about the Starter Edition is that you don't need to buy a license. This Starter Edition is the special offer: performance testing without license.
Besides the HTTP protocol, Rational Performance Tester also supports other network protocols. You can do performance testing on network traffic from Citrix, SAP, mainframes (TN3270), for example.
Show me your license
With the starter edition, you can develop your performance tests anytime, anywhere, anybody without buying a license. On top of that fact, much of the documentation about the licensed edition also applies to the Starter Edition when we're talking about the features that are available in both editions.
If we're talking about performance testing, we often mean load tests. However, there are also other kinds of tests in the space of performance testing. One tool is better suitable than another tool for the kind of performance testing that you want to do. Here is an incomplete list of performance testing types.
You do load testing when you want to know what your application does under a specific load. For example, how would your server respond when 200 users send requests to your application at the same time?
If you want to know under what load your application just stops, stress performance testing is the thing for you to do.
Soak or endurance testing
You want to see what happens when your application suffers a certain load for a long time. A great way to see memory leaks.
Suddenly a huge number of users access your application. Then, what happens?
You create tests to see what the influence is of different configurations on your application performance.
From this overview of performance testing types, you can see that you might consider to use the Starter Edition for load test and configuration tests when you want to involve just a few virtual users. If you want to put more load on your application, you can benefit from the cloud capabilities of Rational Performance Tester through the SoftLayer® cloud. The cloud might work for you in terms of timely and easy performance testing.
Starter Edition: try out and find out
The best way to find out whether you can do performance testing with the Starter Edition, is to install the Starter Edition and test. If you are familiar with the installation procedure of IBM products, you might want to skip this chapter. The installation procedure is much the same.
Reports display valuable statistics about how users are using the assets and repository.
Managing software assets goes beyond submitting them to a repository and managing them through consumption. Over time, looking at the changing elements, the models and trends of asset details, consumption use cases, and users information can help companies evaluate the needs of their current business strategies.
Lets understand the different types of reports available and the insights they provide...
Peak usage : This metric represents the maximum number of license requests that were granted by the selected license servers for the selected products. If more than one license type is selected in the report definition (floating and token as license type), the peak usage report shows multiple numbers in the bar graphs. The following example shows a peak distribution report with two counts per bar.
Peak denial : This metric represents the maximum number of license requests that selected license servers denied for the selected products during the specified time.
License usage per user : This metric presents information about product usage by a user from a license server at a specified time. This list includes the user and the host server name for the selected products for the specified duration.
Available Licenses : This metric presents the total number of licenses for a product that are available in the license files that are used to start the license server.
License expiration : This metric presents the expiration date of licenses for each of the selected products. This information is collected from the license file.
Token distribution : This chart presents the number of token licenses that are issued in the specified time for various products in an organization.
Chargeback report : This metric represents a simple chargeback policy for product licenses that are used in an organization. The report for this metric is like an invoice, where the number of licenses that are used by each user during a specified time is listed. The number of license hours is multiplied by the unit costs that are associated with each license hour of that kind of license for that product. This product gives the value in currency to be charged for that user.
Note: For the Collaborative Lifecycle Management (CLM) products, the following metric types are supported:
Homo Sapiens are not the only intelligent ones.. IBM Rational Rhapsody seems to be enhancing its ‘thinking’ capabilities with the introduction of version 8.0.5.
Let us consider you are connecting two ‘actions’ in an Activity diagram with an ObjectFlow. Until the release of 8.0.5, performing the same erroneous step would result in the following error message:
Now in IBM Rational Rhapsody 8.0.5, it automatically understands the error and intention and corrects it by converting the link to a ControlFlow (which happens to be the Intended behaviour). Isn’t that smart?
Similarly, Until the previous release (Rational Rhapsody 8.0.4), you would get the following message when an ‘Action' is connected to an ‘Object Node’ through a ControlFlow:
Here again intelligence of Rational Rhapsody 8.0.5 can be observed, the ControlFlow automatically gets converted to an ObjectFlow when an ‘Action' is connected to an ‘Object Node’: