Tuesday, May 3, 2011

SILK Automation framework used in Cymfony- By Vijay Murugan

Cymfony Automation Frame Work:-

Automation Framework is a concept, similar to OOPs. Automation Framework is an advanced thought from Record Playback or writing some functions and executing them.

Automation Framework is a discipline and should have proper design/architecture. Automation Framework should have some of following components.

Components of a Framework:-

1. AUT Specific libraries
2. Tool wrapper function libraries.
3. Execution Engine (Script Execution should be derived
based on given test data) Data Driven
4. Results reporting mechanisms (PASS & FAIL for each test cases/procedures and
compiled results for all. Itwould be better,if it captured AUT's snapshots)
5. Planning for long term automation.
6. Keeping GUI objects info/declarations dynamicallyor static.
7. Planned approach of unattended execution.

Also framework design differs by tool, scripting languages and type of AUT etc,

Cymfony is using automation framework called “oops automation framework”

Oops framework is a combination of two or more frame works.
Oops framework Architecture as follows:-


1.WebDeclares.inc : will have Connection to client database &input excel
2.Product_Declares .inc & Global Var.inc : Will have Reusable functions.
3.Testcases.t : will have All Test case Scripts
4.Main.pln : Will have list of executable test cases
5.Main.res : Will have Results

Advantage of Framework:-

1.Reusability of utility Script.
2.Using package of Object Identify.
3.Dynamic object identification
4.Easy to Debugs

Disadvantage of Framework:-

1.If any changes happen in the page design we need to change the pervious scripts for the new design.

Understanding of Php Coding – By Awadhesh


PHP stands for Hypertext Preprocessor. It is a server-side scripting language, like ASP. These scripts are executed on the server. PHP supports many databases (MySQL, Informix, Oracle, Sybase, Solid, PostgreSQL, Generic ODBC, etc.). PHP is an open source software
PHP files can contain text, HTML tags and scripts. PHP files have a file extension of ".php", ".php3", or ".phtml"
PHP runs on different platforms (Windows, Linux, Unix, etc).

Basic PHP Syntax
A PHP scripting block always starts with . A PHP scripting block can be placed anywhere in the document.
On servers with shorthand support enabled you can start a scripting block with .
For maximum compatibility, we recommend that you use the standard form (Below, we have an example of a simple PHP script which sends the text "Hello World" to the browser:

Each code line in PHP must end with a semicolon.

Why do use $ in Php
$ sign is Exclusively use in Php. It instructs to Php Engine That the code inserted with $ sign is Variable.

Variables in PHP
Variables are used for storing values, like text strings, numbers or arrays.
When a variable is declared, it can be used over and over again in your script.
All variables in PHP start with a $ sign symbol.
The correct way of declaring a variable in PHP:
$var_name = value;
Let's try creating a variable containing a string, and a variable containing a number

Naming Rules for Variables
• A variable name must start with a letter or an underscore "_"
• A variable name can only contain alpha-numeric characters and underscores (a-z, A-Z, 0-9, and _ )
• A variable name should not contain spaces. If a variable name is more than one word, it should be separated with an underscore ($my_string), or with capitalization ($myString)

String Variables in PHP
String variables are used for values that contain characters.
Below, the PHP script assigns the text "Hello World" to a string variable called $txt:

The Concatenation Operator
The concatenation operator (.) is used to put two string values together.
To concatenate two string variables together, use the concatenation operator

If we look at the code above you see that we used the concatenation operator two times. This is because we had to insert a third string (a space character), to separate the two strings.
The strlen() function
The strlen() function is used to return the length of a string.

The strpos() function
The strpos() function is used to search for a character/text within a string.
If a match is found, this function will return the character position of the first match. If no match is found, it will return FALSE.

The position of the string "world" in the example above is 6. The reason that it is 6 (and not 7), is that the first character position in the string is 0, and not 1.

To be Continued

Testing Techniques - By Amar

Maestro performance testing approach. – By Siddu

Maestro Performance Testing Approach

Performance testing is one of the key areas of any application, in maestro the performance degradation is mainly observed while loading the widget. Hence we have considered this as a first area to explore and test for performance.

The first challenge for us is, there are millions of combinations of widgets, which one should we consider for testing?

To solve this we are adopting the following approach:

1.Write a query to extract user created widget data. Following widget creating options/combinations will be considered:

a.Widget Type
b.Entity Type
c.Chart Type
d.What to Plot
e.Date range used

2.Run the query and collect the data from all the production clients DB.

3.Identify widely created widgets and its combinations

4.List out all the performance related defects logged in JIRA and Bugzilla. Defects can be logged on production as well as QA sites.

5.Analyze and extract the defects related to widget loading and plotting.

6.Study the database to identify the large tables getting combined while creating the widget.

7.Study the database for complex queries formed during presenting in the UI.

Following data is taken from production Nintendo client.

By observing the data most of the users are creating with

Widget Types: “entity” and “entity sentiment”
Entity Types: “Company” and “Product”
Chart Types: “Line” and “Pie”
What to Plot: “Volume Assets”

-- Will be updating upon further findings

Monday, May 2, 2011

Testing process and few tips on Effective Software Testing - By Shwetha

Testing process

An important part of software quality is the process of testing and validating the software.

Test management is the practice of organizing and controlling the process and artifacts required for the testing effort.
Aspects of test management

Test management can be broken into different phases:

4.Execution and

Test artifact and resource organization: is a clearly necessary part of test management. This requires organizing and maintaining an inventory of items to test, along with the various things used to perform the testing. This addresses how teams track dependencies and relationships among test assets. The most common types of test assets that need to be managed are:

•Test scripts
•Test data
•Test software
•Test hardware

Test planning: is the overall set of tasks that address the questions of why, what, where, and when to test. The reason why a given test is created is called a test motivator (for example, a specific requirement must be validated). What should be tested is broken down into many test cases for a project. Where to test is answered by determining and documenting the needed software and hardware configurations. When to test is resolved by tracking iterations (or cycles, or time period) to the testing.

Test authoring: is a process of capturing the specific steps required to complete a given test. This addresses the question of how something will be tested. This is where somewhat abstract test cases are developed into more detailed test steps, which in turn will become test scripts (either manual or automated).

Test execution: entails running the tests by assembling sequences of test scripts into a suite of tests. This is a continuation of answering the question of how something will be tested (more specifically, how the testing will be conducted).

Test reporting: is how the various results of the testing effort are analyzed and communicated. This is used to determine the current status of project testing, as well as the overall level of quality of the application or system.

The testing effort will produce a great deal of information. From this information, metrics can be extracted that define, measure, and track quality goals for the project. These quality metrics then need to be passed to whatever communication mechanism is used for the rest of the project metrics.

A very common type of data produced by testing, one which is often a source for quality metrics, is defects. Defects are not static, but change over time. In addition, multiple defects are often related to one another. Effective defect tracking is crucial to both testing and development teams.

Test management challenges
•Not enough time to test
•Not enough resources to test
•Testing teams are not always in one place
•Difficulties with requirements

Test management recommendations

The following are general recommendations that can improve software test management.
•Start test management activities early
•Test iteratively
•Reuse test artifacts
•Utilize requirements-based testing
•Leverage remote testing resources
•Defining and enforcing a flexible testing process
•Coordinate and integrate with the rest of development
•Communicate status
•Focus on goals and results
•Automate to save time

Few Questions should be constantly posed by the tester prior to testing which will make the objectives of testing very clear.

One way to sum up the objectives of test management is answering the following questions:
•Why should I test?
•What should I test?
•Where do I test?
•When do I test?
•How do I conduct the tests?

A few tips on Best Testing Practices.
Learn to analyze your test results thoroughly:
Do not ignore the test result. The final test result may be ‘pass’ or ‘fail’ but trouble shooting the root cause of ‘fail’ will lead you to the solution of the problem. Testers will be respected if they not only log the bugs but also provide solutions.

Learn to maximize the test coverage every time you test any application.
Though 100 percent test coverage might not be possible still you can always try to reach near it.

To ensure maximum test coverage break your application under test
(AUT) into smaller functional modules. Write test cases on such individual unit modules. Also if possible break these modules into smaller parts.

While writing test cases, write test cases for intended functionality first
First test cases should be written for valid conditions according to requirements. Then write test cases for invalid conditions. This will cover expected as well unexpected behavior of application under test.

Think positive. Start testing the application by intend of finding bugs/errors.
Don’t think beforehand that there will not be any bugs in the application. If you test the application by intention of finding bugs you will definitely succeed to find those subtle bugs also.

Write your test cases in requirement analysis and design phase itself.
This way you can ensure all the requirements are testable.

If possible identify and group your test cases for regression testing.
This will ensure quick and effective manual regression testing ‘accepting user information’ is one of the modules. You can break this ‘User information’ screen into smaller parts for writing test cases: Parts like UI testing, security testing, functional testing of the ‘User information’ form etc. Apply all form field type and size tests, negative and validation tests on input fields and write all such test cases for maximum coverage.

Applications requiring critical response time should be thoroughly tested for performance.
Performance testing is the critical part of many applications. In manual testing this is mostly ignored part by testers due to lack of required performance testing large data volume. Find out ways to test your application for performance. If not possible to create test data manually then write some basic scripts to create test data for performance test or ask developers to write one for you.

Go beyond requirement testing.
Test application for what it is not supposed to do.

While doing regression testing use previous bug graph (Bug graph - number of bugs found against time for different modules).
This module-wise bug graph can be useful to predict the most probable bug part of the application.

Note down the new terms, concepts you learn while testing.
Keep a text file open while testing an application. Note down the testing progress,observations in it. Use these notepad observations while preparing final test release report. This good habit will help you to provide the complete unambiguous test report and release details.

Many times testers or developers make changes in code base for application under test.
This is required step in development or testing environment to avoid execution of live transaction processing like in banking projects. Note down all such code changes done for testing purpose and at the time of final release make sure you have removed all these changes from final client side deployment file resources.

Keep developers away from test environment.
This is required step to detect any configuration changes missing in release or deployment document. Some times developers do some system or application configuration changes but forget to mention those in deployment steps. If developers don’t have access to testing environment they will not do any such changes accidentally on test environment and these missing things can be captured at the right place.

It’s a good practice to involve tester’s right from software requirement and design phase.
These way testers can get knowledge of application dependability resulting in detailed test coverage. If you are not being asked to be part of this development cycle then make request to your lead or manager to involve your testing team in all decision making processes or meetings.

Testing teams should share best testing practices, experience with other teams in their organization.

Increase your conversation with developers to know more about the product.
Whenever possible make face-to-face communication for resolving disputes quickly and to avoid any misunderstandings. But also when you understand the requirement or resolve any dispute - make sure to communicate the same over written communication ways like emails. Do not keep any thing verbal.

Don’t run out of time to do high priority testing tasks.
Prioritize your testing work from high to low priority and plan your work accordingly. Analyze all associated risks to prioritize your work.

Write clear, descriptive, unambiguous bug report.
Do not only provide the bug symptoms but also provide the effect of the bug and all possible solutions.

SILK test cross training- By Archana M


Definition: Automated testing is running test cases where manual intervention is not required to run each one.

Benefits of Automated Testing:

Reliable: Tests perform precisely the same operations each time they are run, thereby eliminating human error

Repeatable: You can test how the software reacts under repeated execution of the same operations.

Programmable: You can program sophisticated tests that bring out hidden information from the application.

Reusable: You can reuse tests on different versions of an application, even if the user interface changes.

Better Quality Software: Because you can run more tests in less time with fewer resources

Fast: Automated Tools run tests significantly faster than human users.

Cost Reduction: As the number of resources for regression test are reduced.



Silk Test is a tool specifically designed for doing REGRESSION AND FUNCTIONALITY testing. It is developed by Segue Software Inc. Silk Test is the industry’s leading functional testing product for e-business applications, whether Window based, Web, Java, or traditional client/server-based. Silk Test also offers test planning, management, direct database access and validation, the flexible and robust 4Test scripting language, a built in recovery system for unattended testing, and the ability to test across multiple platforms, browsers and technologies.

You have two ways to create automated tests using silk-test:

1) Use the Record test case command to record actions

The record test case command helps us to record various actions which we perform on AUT(Application under test) actions are captured in the 4TEST language (which is the inbuilt language in SILK test tool).

These recorded actions are then saved as *.t file.

The *.t file saved in the SILK test environment, can be played back by clicking on the RUN command or by pressing F9 functional key.

In this way we can record actions on AUT and then play them back for verifying the results of the actions recorded.

2) Write the testcase manually using the 4Test scripting language.

One can write testcases manually by using scripting language i.e. 4test language by using various methods and functions available.

How SilkTest works?

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. SilkTest interprets these objects and recognizes them based on the class, properties and methods that uniquely identify them. During testing, SilkTest 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, SilkTest, is said to be driving the application.

SilkTest consists of two distinct components that execute in separate

1)The SilkTest Host software

2)The SilkTest 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.