All about Software Testing

HP QTP Tutorial Chapter 5

2011-07-18T18:06:00.001-07:00

1 Insert

The Insert Menu will help you in inserting various verification points, New Steps, Function, and Call to Action etc. While describing the various commands which are available in Insert Menu, I will also be mentioning the hot keys to access some of the commands. See the below screen shot what command is available in the INSERT Menu:

1.1 Checkpoint

Let me first describe what a checkpoint is all about. The Checkpoints feature is provided in Automation Tool for simplifying the test case automation where you need to validate the state of the application. For e.g. You might want to test that when you open a web page or form, you will be able to see 5 Input Boxes and 2 Buttons. Out of the 5 Input Boxes, 3 should be editable, 2 should be ready only. Likewise 2 Buttons – 1 will be disabled by default and 1 will be enabled by default. In such a case you can use Tool Checkpoint feature. I hope this now clarify what is a checkpoint and its usage. If you read the QTP documentation it will talk of various checkpoint like Text, Text area, Table, Standard etc. In this tutorial I will talk about the checkpoint but not in a detail manner as I am writing another chapter dedicated to Checkpoints.

You can access Checkpoint: INSERT->CHECKPOINT (See the below screen shot)

The commands which are in disabled mode will be enabled when you start your script recording. There are only two commands namely Database checkpoint and XML checkpoint which are available in enabled mode by default. There is reason behind it, if you see these checkpoints they do not have dependency on AUT as they are interacting with database and XML which can be loaded from server or local directory.

1.2 Output Value

The Output Value is mainly used wherein you want to capture the value from AUT. For e.g. I am creating an Account in my application which provide me with an Account number after successful creation of an account. I want to use this account number for validating some scenario which can be done only through search module of the application. In such a scenario I can use Output feature in QTP so that the value can be used as an input in another part of AUT. You can access Output Value: INSERT->OUTPUT VALUE (See the below screen shot)

I will talk more about Checkpoint and Output value in the next chapter. Keep checking my blog.

1.3 Step Generator

As you start with your scripting, you need to use inbuilt functions, customized functions to design a robust testing framework. The Step Generator aids your scripting by providing help on 3 categories: Test Objects, Utility Objects, Functions. As you select any of these categories QTP allows you to add respective steps in your script. This tool is very handy for beginner as it really makes their life easy while scripting. You can access the Step Generator by pressing shortcut key of F7 or navigating to INSERT->STEP GENERATOR ( See the below screen shot of Step Generator):

I will talk about the details in next the chapter of this tutorial series.

1.4 Function Definition Generator

This utility or command in QTP aids you in defining the Function Skelton. You can define Function or Sub Procedure using Function Definition Generator. You can define even register your function with a Test Object so that you can achieve the desired result on the Test Object action. I will not delve into much detail at this point of time as it is more advance topic. So as of now if you are beginner and new to scripting, this is the utility for you. You can access the utility by navigating to INSERT-> Function Definition Generator. See the below screen shot:

1.5 Synchronization Point

This is one of very useful command in QTP. This will be used very frequently in your scripting. There might be a situation wherein you have to wait till the time page get loaded or input field get enabled, progress bar reach 100% etc. Any scenario where next action depends on the completion of previous action, you have to use Synchronization Point in your script. This command will get enabled when you are in recoding mode. Just try your hand on this utility and see the generated script. Seeing the name you will understand that you have to wait till some property get satisfied. You can access this command from INSERT-> Synchronization Point (See below screen shot)

1.6 New Step & New Step after Block

Suppose you have done 50% or 20% of your scripting and then you realize that you have to add some more steps which are in between of some existing steps, then you can use New Step command. This command is available to you in Keyword view only. First you need to place select the step in Keyword view, then navigate to INSERT->NEW STEP or press F8, as soon as you do this you will see a drop down from where you can select any test object , function to insert in your script. See the below screen shot:

Similarly if you want to add anything after a conditional block (IF ELSE) or loop (FOR, WHILE etc), then you can make use of INSERT-> New Step after Block or press SHIFT+ F8

See the above screen shot wherein you can see the block of If statement in blue.

1.7 Comment

If you want to insert the comment in your scripting, use this command to provide the line comments, comments before a line of code etc. Navigate to INSERT->COMMENT. You can also provide Line comments by filling the comment column of your keyword view. Please see the below screen shot:

1.8 Report

This command is used to report the Pass, Fail, Warning, Done status to execution result. To add Report statement, select the step in keyword view after which Report statement need to be added, navigate to INSERT->REPORT. See the below screen shot. You have to select the status, enter the name and description and then you are done:

1.9 Conditional Statement

As the name suggests, if you want to define some logic, then you have to use the Conditional statement. This is very useful command to build a robust script. The usage of conditional statement and result reporting goes hand in hand. One has to ensure that wherever they are using Report statement, it should always be inside conditional statement. For e.g If I have to validate that button exists or not, then I will use conditional statement to report my result. See below pseudo code:

IF BUTTON EXIST

REPORT PASS

ELSE

REPORT FAIL

END IF

You can access the Conditional statement command from INSERT=>Conditional Statement. See below screen shot which is self explanatory.

1.10 Loop Statement

Like Conditional Statement you can also use Loop Statement where you have to use different set of data for your script. Without Loop statement, you can make your data driven framework (wait till advance version of tutorial get released). To insert Loop statement, select the step after which you want to have Loop statement, and then navigate to INSERT->Loop Statement. See below screen shot:

1.11 Call to New Action

As in my previous chapter I mentioned about action. Call to New Action is the command which can be accessed from INSERT-> Call to New Action. The call to new action command is calling a new action which does not have any script written. The new action is blank without any commands. You have to define the New Action after which it will perform the desired action and make your requirement fulfilled. See the below screen shots:

After you define the New Action, you can make it reusable if you wish to use it in other Actions.

1.12 Call to Copy of Action

This is calling an existing action but with a copy of it so that you can customized as per your need. When saved a copy of previous action will be saved. This is the same thing wherein you are making use of existing code with some modification to speed up the scripting process. To access Call to Copy of Action, navigate to INSERT->Call to Copy of Action (See below screen shot)

1.13 Call to Existing Action

This is very frequently used while doing scripting. Your test script is a combination of multiple actions like Login, Logout, Navigation, Specific Function etc. As a best practice what we normally do is we identify actions which get used most of the time. We make such action reusable and ask other scripter to call this Action without making any changes. The same is called Call to Existing Action. You cannot make any changes in Original Action. To add existing action, navigate to INSERT->Call to Existing Action (See below screen shot)

1.14 Call to Winrunner

As the name suggest that you can call Winrunner Test or Function as well. This utility is given by HP so that any organization which has major enterprise automation library developed in Winrunner 8.2, they can make most use out of it without rewriting the library from scratch. This command will normally not used when doing fresh automation in QTP. Another pre-requisite to access this command is that you must have WinRunner 8.2 or higher version installed in your machine.

1.15 Start Transaction and End Transaction

Suppose I want to measure the time taken in inserting 1 record in the database. This information will tell me the transaction time. This is useful only when I want to make this information available to LoadRunner or Business Availability Center for measuring the performance of the application. You can insert Transaction time by putting the start time and end time between 2 points. To access the above command navigate to INSERT->Start Transaction and End Transaction. This measures the time taken to complete the required piece of transaction. For e.g. how much time system is taking to return the search result. Here I will start transaction wherein I am inserting search text and clicking the search button, I will end my transaction when I got the required search result. When I run this script, I will have my search timings.

I hope you must have got it what I intend to say.

2 References

Quick Test Professional Tool.

3 additional information

You can email me on Sachin.vasudha@gmail.com with any query.

HP QTP Tutorial Chapter 4

2011-03-16T16:56:00.001-07:00

1 View Menu

The View Menu will provide you the options for setting the view of your Test. You can choose to view or hide the various options available under View Menu. The below section will outline the important information on the options of View Menu. See the below screen shot for the options available under View Menu:

1.1 Active Screen

The Active Screen is a screen which shows the Screen Shot capture while doing the recording. You will be able to see the Screen Shot, if your QTP Settings allow capturing Active Screen.

If you are not able to see the Active Screen after recording is completed, just goto View->Active Screen (Check for a tick mark against this option in View Menu). See the bottom panel where you will see an Active Screen Tab. (See screen shot below)

As a best practice, you can enable this option but while saving the Test, do not save Active Screen with your test; it will unnecessarily increase the resources on your drive.

1.2 Available Keywords

This is a new feature of QTP 10.0 which helps you in doing your scripting in a much easier way. You can simply drag and drop the keywords in expert view and a corresponding code will get inserted automatically. For e.g. If I have a button on my home page, then when I will drag and drop that button in the expert view, a complete statement consisting Browser, Page, Web Button, Click will get added. This feature will come very handy while doing scripting, as you can directly insert the Function Call, OR events etc. See the below screen shot:

If you are not able to see the Available Keywords pane, then goto menu View->Available Keywords.

1.3 Data Table

To view the Data Table Pane, click View->Data Table. The Data Table pane allows you to see the data that will get loaded when the test will run. You can also set the Global Data and Local Data from the Data Table Pane. See the below screen shot:

The Global sheet will have the data that will be used globally while the Action Sheet data will be used locally. This pane will get used very frequently when you are doing the scripting.

1.4 Debug Viewer

When you want to debug your script, then Debug Viewer Pane will be very useful. You can enable the Debug Viewer pane from View->Debug Viewer. To make use of Debug Viewer, you need to add watch so that the variable added in Watch will be visible in the Debug Viewer Pane.

In Debug Viewer, you have three tabs, Watch, Variable, and Command. You can make use of these 3 tabs to debug your script. The command tab will help you in modifying the value of the code and debugging the problems. These tabs were very useful for scripter.

1.5 Information

This tab will give you information on VB Syntax Error, when you move from Keyword View to Expert View or vice versa. You can check the syntax by pressing Ctrl+F7 or goto Tools->Check Syntax.

1.6 Missing Resources

The Missing Resource Pane will provide information if QTP was not able to load any external files references in your Test. The External file can include Library File for Functions, Reusable Actions, External Actions.

1.7 Process Guidance

This is new to QTP 10.0. This will guide you how you can start your workflow. You will see a descriptive guideline for each of the activities. This is not a wizard but just a guide so that new user can get acquainted with QTP much faster. The screen shot is shown below:

1.8 Resources

The Resources Pane is new in QTP 10.0 (not aware about 9.5) and helps one in managing the Test Scripts. You can associate Functional Library, Recovery Scenario, Object Repository. You can also Delete the Action and view the OR. If you are not able to view this pane, then click View->Resources. See screen shot below:

1.9 Test Flow

The Test Flow is also a new feature in QTP 10.0. This will again make your life easier wherein you can easily understand the flow of your Test Cases. You can move the Actions and do a lot with this pane. If you are not able to see (although this pane get loaded as default), click View->Test Flow. See the below screen shot:

1.10 To Do

This is new in QTP 10.0. You can add your to do items in the To Do Pane. To access, goto View->To Do. See the screen shot:

You can see Tasks and Comments tab in the To Do Pane. You can add To do using the upper tool bar which is visible in above screen shot. The comments tab help you in viewing the comments provided in External Actions and Functions provided the comments exist with keyword //To Do, todo, to-do, or TODO (not case-sensitive). You can also export the To Do List in XML or XLS.

1.11 Expand & Collapse All

You can expand the entire Item present in the Keyword View from View-Expand All. Similarly to callable the test tree, click View->Collapse All. Alternatively you can use + to expand and – to collapse all.

1.12 Keyword & Expert View

The switching between views can also be done through View Menu. Select Keyword or Expert View from View Menu to switch between the 2 modes. The Keyword View is the tree based structure of your Test Script. Both these views can be used while doing the scripting. Advance QTP user prefers to work mostly in Expert View rather than Keyword View.

1.13 Toolbars

The Toolbars section under View->Toolbars help you show & hide the below mentioned toolbars. These toolbars are very handy when you are doing your scripting. As a best practice always enable the below mentioned Toolbars:

# Standard

# Automation

# Tools

# Standard

# View

1.13.1 Standard

The Standard Tool bar is shown below. You can enable or disable it by clicking View->Toolbars->Standard (Do check the Tick Mark after you enable)

You can use Standard Toolbar to Open an Existing Test, Create a New Test, Save the Test, Save the Test with All Resource (not recommended), Settings, Enable Editing, QC Connection. You can further customize the above tool bar by clicking the down arrow in above screen shot. This screen is very self explanatory.

1.13.2 Automation

The Automation Toolbar is shown below. View->Toolbars->Automation (Do check the Tick Mark after you enable)

You can use above toolbar to record, run, stop, change recording mode (analog and lowlevel), view Test Result, Open Object Repository Window. The Customization of command can also be done by clicking the down arrow which will provide option for customization.

1.13.3 Debug

The Debug toolbar is shown below. View->Toolbars->Debug (Do check the Tick Mark after you enable)

As the name suggest the Debug toolbar is helpful while doing the Test Script debugging. You can Pause the Test, Step Into (Keyboard shortcut is F11), Step Over (very frequently used. Keyboard shortcut is F10), Step Out (Shift+F11), Insert Breakpoint (F9), Clear all Breakpoint, Enable/Disable All Breakpoint.

1.13.4 Edit

The Edit toolbar is shown below. View->Toolbars->Edit (Do check the Tick Mark after you enable)

All the Edit commands such as Undo, Redo, Comment Code (Ctrl+M), Uncomment Code (Ctrl+Shift+M), Search and Replace are available in this toolbar.

1.13.5 Insert

The Insert toolbar is shown below. View->Toolbars->Insert (Do check the Tick Mark after you enable)

The commands available in this Toolbar are Insert Checkpoint or Output Value, Call to an Action, Split Action (will be enabled after test script has been selected), Step Generator, Transaction Start Time and Transaction End Time. The Start Time and End Time transaction is very useful in knowing the time taken by application to complete a flow.

1.13.6 Tools

The Tools toolbar is shown below. View->Toolbars->Tools (Do check the Tick Mark after you enable)

The commands available in this Toolbar are Options, Check Syntax (Ctrl +F7), Object Spy.

1.13.7 View

The View toolbar is shown below. View->Toolbars->View (Do check the Tick Mark after you enable)

Using this tool bar you can show and hide the pane such as Test Flow Pane, Available Keywords Pane, Resource Pane, Datatable, Active Screen, Process Guidance, To Do Panes.

1.13.8 Action

The Action is shown below. View->Toolbars->Action (Do check the Tick Mark after you enable)

The Action toolbar provides an easy way to navigate across Actions. You can easily go to various reusable actions that is getting used in your test script. This is very useful toolbar.

2 References

Quick Test Professional Tool.

3 additional information

You can email me on Sachin.vasudha@gmail.com with any query.

HP Quick Test Professional Tutorial Chapter 3

2011-01-14T19:57:00.001-08:00

1 Edit Menu

In Edit Menu, the first 7 commands are very self explanatory, which you can find in any GUI based application. You will find Undo, Redo, Cut, Copy, Paste, Delete, Copy Documentation to Clipboard (used for copying the documentation column value into notepad, ms word etc.).The below command are also very self explanatory and will get active when you are in Expert View mode. The commands are Find, Replace, Goto, Bookmarks.

In this paper, we will cover Action (Split Action, Rename Action, Delete Action, Action Properties, Action Call Properties), Step Properties (Object Properties, Checkpoint Properties, Output Value Properties), Advanced (Comment, Uncomment, Indent, Outdent, Goto Function Definition, Complete Word, Argument Info, Apply “with” to script, Remove “with” statements) & Optional Step.

1.1 Action

As the name suggests, ACTION command can be used for doing manipulation on the QTP Actions. If you do not know what an ACTION is, then let me define for you. ACTION is building block concept in QTP. Whatever you are scripting is identified with an Action Name. ACTION provides a unique name to your Test Script. There is a reason behind introducing this concept in QTP. The ACTION enable to design a framework which can be made to re-used in your enterprise application. It provides a logical grouping of your Test Cases so that you can easily manage your Test Script. Test can consist either 1 action or multiple ACTION (reusable actions). We will cover these concepts in next series for Intermediate user level. Let now see the commands available under ACTION option.

1.1.1 Split Action

Select the block of Test Steps in QTP which you want to SPLIT into 2 Action and then either right click or choose EDIT->ACTION>SPLIT. This will open a window where in you can specify whether you want the Actions as an Independent of each other or Nested. Specify the name of each action on the same window and then click OK. You have successfully SPLIT your Action. Now let me tell you its real time usage, you normally split action for doing a fast scripting. You recorded all the Step in 1 go and then SPLIT into ACTIONS so that you have the logical grouping of your test cases. The SPLIT option might not be enabled if:

Reusable Action is selected which is external in your Test (External Action)
The very first step of your Test Script
The Test open is Read-Only (anyway you cannot do anything except execution)
Recording a test
Running a test

As a best practice, 1 Test Case should ideally consists of 1 independent Action and if required reusable actions. I will not recommend to use SPLIT action if you are using it for having 2 independent action with in the same Test Cases.

1.1.2 Rename Action

This will be 1 of the very frequent command on your list. You need to rename your Action as per defined standard for your project and organization. To rename your action, press SHIFT+F2 or click EDIT->SPLIT->RENAME ACTION. You can also rename your action from the Action Properties Window. The default name given by QTP for Action is Action 1 and so on.

1.1.3 Delete Action

You are also going to make use of this command whenever you want to delete other action (normally re-usable) in your Test Script. If you have included wrong re-usable action in your script and want to Delete it, then open the Reusable Action from Action navigation drop-down, click EDIT->SPLIT->DELETE ACTION. Please click Yes or No on the confirmation window to perform Deletion of your Action. I still wonder why this option never appears in right click menu. If you know the shortcut key for Delete Action, please share with us as well. I am having hard luck finding the short key for Deleting an Action.

1.1.4 Action Properties

If you want to perform below activities on your Action, then use Action Properties window:

1. Rename of an action

2. Making your Action a Reusable action

3. Specifying Input and Output Parameters specific to your Action

4. You want to associate or view the Object Repository for your Action.

5. You want to view the information that which all other Test are making use of your reusable action.

Let me give you some more insight into point number 3. In real time scenario, we normally use point 3 whenever we are creating reusable action. Parameter are normally not required for Independent Action. Usage of parameter will be covered in next level of my series.

1.1.5 Action Call Properties

You will find this option available only when your Test is using reusable action or nested actions. Using this command you can:

1. Control the run of the called action

2. Provide the parameter value for the called action

Select the Reusable Action in Keyword View mode (remember you won’t see this option in the Expert View mode) and either Right Click and select Action Call Properties or Edit->Split->Action Call Properties.

1.2 Step Properties

1.2.1 Object Properties

If you know what an object in QTP, then its good but in case of you do not know, then let me define it for you. An object is a control (edit box, radio, check box, button etc), window, browser, page etc which has unique name, properties given by the developer and QTP identifies the object using those unique name or properties. As a scripter you should be able to read and understand the object properties. QTP provide Object Properties option to see the property of an object. Ready only information is displayed in this window but you can find that object in Object Repository from this window as well.

First highlight the Object and then either press Ctrl+Enter or Alt+Enter or Edit->Step->Object Properties or Right Click and then select Object Properties.

1.2.2 Checkpoint Properties

Let first understand what a checkpoint is actually means in QTP. Checkpoints in QTP enable or pacify the process of test case validation. For e.g. if my test case is saying, validate that the QTP image is appearing on the web page, validate that Age Text Box is disabled by default. If you have to script above test cases, then you might require the Checkpoint in QTP. There are various checkpoints which are available in QTP but the most frequent one is Standard Checkpoint. We will cover QTP checkpoints in detail in next series.

If your test consists one or more such checkpoint, then you can view the Checkpoint property by either selecting the “Check” keyword in Expert view and then Right Click and choose Checkpoint Property. You can also click the tick sign in Keyword View mode on the Test Step which correspond to “Checkpoint”. Using Checkpoint properties window, you can put validation for other properties as well. You can set the value to be Constant or make it Dynamic by parameterize the specific property.

1.2.3 Output Value Properties

This is similar to Checkpoint properties except that you are outputting the value from your AUT to make use of it for doing validation at some other steps in your test. We will separately cover this in next series. But you can view the Output properties in the same way as you viewed the Checkpoint properties. Select the Step which consists “Output Check”, select Edit->Step->Output Value Properties or Right Click->Output Value Properties.

You can edit other properties as well so that it can be outputted to a spreadsheet. You can navigate to Object Repository from this window. Click the icon on right side of Name Text Box.

1.3 Advanced

1.3.1 Comment Block

To commend the block of code, select the block of code in Expert View and press Ctrl+M or Edit->Advance->Comment Block. This will comment the selected code. Used very frequently while doing scripting.

1.3.2 Uncomment Block

To uncomment the block simply select the block and press Ctrl+Shift+M or Edit->Advance->Uncomment Block.

1.3.3 Indent / Outdent

This is very self explanatory. You can indent and outdent your Test Script to increase readability. This make your Test Script look cleaner and make your script easily readable to other scripter. Always follow the defined Organization standard for Indenting and Outdenting.

1.3.4 Goto Function Definition

This is very important command and you need to know this as this will come very handy when you are analyzing the existing script which is making use of function. This command will simply take you’re the function definition. Remember from 2^nd series we have included library files in our test. Those library files is a collection of various functions which my Test will make use of. If my test is making use of function whether internally or externally, I can always see the definition. Select the Function Name, Right Click->Goto Function Definition, or Edit->Advance->Goto Function Definition or press Alt+G.

1.3.5 Complete Word

This is again very simple. If you writing a code say Dialog, the instead of typing complete word, you can type initial and then either press Ctrl+Space or select Edit->Advance->Complete Word. The former is more frequently used and I do not know why HP has still given this option in the Edit Menu.

1.3.6 Argument Info

To see the Argument of a function whether in-built or external , type the function name and then press Ctrl+Shift+Space or Edit->Advance->Argument Info.

1.3.7 Apply “With” to Script

You can make your script look more readable with “With” statements. To apply the script with “With” statement, simply press Ctrl+W. This will convert the script into “With” statement. See the below screen shot for clarification.

1.3.8 Remove “With” Statements

If you want to remove the With Statement and revert to its original format, press Ctrl+Shift+W and your script will be removed with all the “With” statements.

1.4 Optional Steps

The decision to make a step optional entirely depends on your application design. There may be instances where you application perform some action based on saved value in session. For e.g. Remember Login feature. You can make the Test Step for Login as an Optional Step. To make a Step optional, go to Keyword View and then select and right click on step and select Optional Step. You can also go Edit->Optional Step. This step will show icon to demarcate it as an Optional Step. In Expert view the corresponding line will be “OptionalStep”.

An optional step is not necessarily required to successfully complete a run session. If object of optional step does not exist in AUT, then QTP ignores it and continue with the test.

By default, QTP considers steps that open the following dialog boxes or message boxes as optional steps: AutoComplete, File Download, Internet Explorer, Netscape, Enter Network Password, Error, Security Alert, Security Information, Security Warning, Username and Password Required.

2 References

Quick Test Professional Tool.

3 additional information

You can email me on Sachin.vasudha@gmail.com with any query.

HP Quick Test Professional Tutorial Chapter 2

2010-11-26T21:17:00.001-08:00

1 FILE Menu

In the first series of this article you have seen the usage of various commands available in File Menu option. This paper is in continuation of my previous series and in this series we will mainly the File->Settings option. I have not included Setting explanation in the first series because understanding Setting is very important for real time usage. You will visit this option very frequently and you must understand its usage in a better way.

1.1 Setting

To open the Settings Dialog, Click File->Settings (as shown below).

We will see each useful option available in the above dialog which helps you a lot while you are developing your test script. I am going to explain about each option such as Properties, Run, Resources, Parameters, Environment, Web, Recovery, Local System Monitor (new in 10.0).

1.1.1 Properties

In the Properties, many of the static things are self explanatory. You can use Properties for:

· Adding or removing the associated add-ins for current test. If you are working on a web based application, it’s always a good practice to de-associate other add-ins to save on memory performance and avoid conflict while opening the Test. Associating or de-associating will require QTP to be started and then you can see your changes.

· You can use Properties Window to Generate the Script of your settings and save as .VBS file. The advantage of having this script is that it can be distributed to all the team members so that settings for all the Test Script remain same. A sample script is shown below:

When above script will run on the Team Members QTP installed machine, this will ensure same configuration of QTP for developing or running the script. This is a real life example of Generate Script usage which I have shown above. There may be other settings as well depending on organization or project needs.

1.1.2 Run

Run option can be used for:

Control your iteration if you are driving your test through excel – Use Data Table Iterations section to control your test execution:
1. Run one iteration only will run the script only one time. This normally picks the data from Global Sheet.
2. Run on all rows- Your test run as many times as there are number of rows in the Global Sheet. In real time I hardly use this as this will be an overhead and make your maintenance really costly.
3. Run from row - here you can customize your test run by providing the From Row number and To Row number. If you want to run from say row 2 to row 20, then provide your value as 2 and 20. I hardly use this option.
Set the action that will be taken when script is running and encounter any error. The QTP will respond to that error in the defined way. So, if you want to suppress all the error, then you can choose “proceed to next step”. This way your script will not stop executing. But there are other impacts as well if you set this as an option. So, depending on your requirement you choose this option with care. This is a global setting option. As a best practice “pop up message box” is the best action for any script error or object error.
Object Synchronization Timeout – This is very self explanatory. What time QTP waits for any object before it display you any error. You can define the timeout based on your requirement. Again this is a global setting.
Disable Smart Identification during the run session – I am not diving in much depth (may be in next set of series I will deep dive) what Smart Identification means but as a best practice tick “Disable Smart Identification during the run session”. This will make your script robust when it runs.
Save image of desktop when error occurs (if test is run by the HP Business Process Monitor) – New Option available in QTP 10.0 – I have not used this option. You can check the QTP help to know more about this option. But as per my experience we hardly make use of this since usage of this again is an overhead on the resources that will be saved with the test.

1.1.3 Resources

This is one of the important options in Settings Window. This will be very frequently used as you need to associate the relevant library and architecture file using this window. Once associated you can make full use of those library files while developing your script. This is something like include statement which you normally write in your C++ programming.

I have never used the Datatable option available in this window since my architecture load the required data file on the fly and so I never use this option. But if you want to set the other location for your Data file, then you can select Other Location option to do that. This Excel will be used during your Script development and execution.

How you will associate the Library file in your Test – Click the sign and you will see a line item in the grid, navigate to the location and select the library files that you want to associate with your test.

In real time, you should always associate pre-defined library files with your test. This option will be very frequently used by scripter in real time.

1.1.4 Parameters

The parameter tab will also get used when you want to call your test with parameters. This is same as function arguments. The usage of the Input and Output parameter depend totally on your application requirement and framework development around your application. I can give you an example where I have used the Input Parameter in one of my complex project. I want to develop a mechanism wherein the Execution Team should have the flexibility to control the execution of test iteration. For e.g. If s/he want to run the test say from Row 20 to Row 30, then they can easily do it. They just have to provide the row number in QC from where they are running the Test.

These parameter are for Test and Not for Action. Remember there is substantial difference between the Test Parameter and Action Parameter usage. Output Parameter is again on global level wherin you can store the output in Quality Center. The usage entirely depends on the complexity and requirement of my solution.

To define these parameter, cick the sign and enter the parameter name, datatype, default value if any and description. After you define these parameter, you can see the parameter in QC Test Run Tab wherein you can provide value to Input Parameter and check the value of the output parameter.

The real time usage of these parameter is very complex and if you do not have good command, I suggest then do not experiment on real project in QC and instead practice first on demo qc.

1.1.5 Environment

There are 2 types of Environment variable:

· Built In – see the available environment variable. These built in variable are very handy while doing scripting, so please go through each of these built in variables. You can use these variable by writing Environment. Value ("ActionName"). You can change the Value parameter to either user defined variable or built in variable. The statement will return you the value available in the variable. This is very handy while designing the architecture around automation.

· User Defined – Any variable that is defined by user. As a best practice, define only global type variable for environment. You can export the variable as an XML file and then re-load with your test for usage. If you are not familiar with XML, then you can use this Tab to create all the user defined variable at one go. After creating all the variable, export to XML and then start making use of it across your Team.

I am not going to cover how to create user defined variable in this paper and will cover in next set of series for intermediate or advance.

1.1.6 Web

I have not used this option in my real time. But for your information, you can make use of Web Tab for doing settings regarding timeout and storing user name and password for the web pages which require authentication on each run.

1.1.7 Recovery

From this window, you can associate the relevant recovery file which will be called in case of any error. Select your recovery file and associate and you are done. If you have generic recovery file and you want to make use of that generic file for all your test, then do the association like this.

1.1.8 Local System Monitor (New in 10.0)

I have not used this option much, but if you want to monitor the application or program which your test will run or is running, you can do so by this Tab. The Tab gives you an option to monitor the performance of the local system. You can monitor Memory Usage, GDI Objects, Handle Count, Thread Count, %Processor Time, %User Time etc.

This completes the File Menu usage series. In next series, we will see the usage of Edit Menu. Keep checking my blog.

2 References

Quick Test Professional Tool

3 additional information

You can email me on Sachin.vasudha@gmail.com with any query.

HP Quick Test Professional Tutorial Chapter 1

2010-11-12T19:15:00.001-08:00

In this article I will explain how you can make use of File Menu option available in HP QTP. This is a very basic usage and I thought to start the Basic Series so that newbie's can learn QTP by following the complete series on this Blog. I will publish the Series subsequently. Next Series I will explain only about the File->Settings option which is very useful in real time usage.

1 FILE Menu

1.1 New Menu

If you want to either create a new test, business component, or function library you have access the File->New-><<Sub Option>>>. Figure is shown below:

1.1.1 New Test

New Test option is used to create a New Test Script. You can create a New Test by pressing Ctr+N, or click File->New->New Test. Once you do above operation, you will see a blank Test Script Page where you can record or write your VB Script code.

1.1.2 Business Component

Business component is mainly used when you are planning to use Business Component Testing model and you have a Quality Center connection with valid BPT License. This is a separate topic for discussion. Keep checking my blog for updates on BPT as well.

You can create a business component by pressing Ctr+Shift+N, or click File->New->Business Component.

1.1.3 Function Library

Functional Library as it name suggest is the placeholder wherein you can define all your reusable functions which will be used in your Automation Framework. It will consist of all the Function or Sub for your Application, Loading of required OR, loading of required folder path and architecture.

To create a Function Library, press Shift+Alt+N, or click File->New->Function Library.

1.2 Open Menu

To perform your daily operation on the Test Script, Functional Library, Business Component you need to access the option available under this Menu.

Note: We will not cover Application Area.

1.2.1 Test

To make any modification in your script at later point of time, you need to open the test script. You can open your QTP Test by pressing Ctr+O, or click File->Open->Test.

Navigate to the location where you have saved your QTP Test and select the Test to open in Edit Mode. In case you want to Open the Test in Read Only Mode, you need to select the “Open in read-only mode” checkbox on Open Dialog box.

Note: If you are connected to Quality Center, you need to navigate to respective QC Test Plan Folder to Open your Test. If any other user has already opened that Test, then you cannot open the Test in Edit Mode and Test will be loaded as Ready Only mode.

1.2.2 Business Component

This option is available when you are connected to Quality Center having a valid BPT License. You can open and edit your Business Component Asset by pressing Ctr+Shift+O, or click File->Open->Business/Scripted Component.

1.2.3 Function Library

To make any modification in your Function Library at later point of time, you need to open the Function Library. You can open your Function Library by pressing Shift+Alt+O, or click File->Open->Function Library.

Navigate to the location where you have saved your Function Library and select the library file to open in Edit Mode. In case you want to Open the Library in Read Only Mode, you need to select the “Open in read-only mode” checkbox on Open Dialog box.

Note: If you are connected to Quality Center and you have saved your Library in QC, you need to navigate to respective QC Test Plan Folder to open your Library File. If any other user has already opened that Library file, then you cannot open the Library File in Edit Mode and it will be loaded as Ready Only mode.

1.3 Close all Function Libraries

In case you have opened multiple Function Library, then you can close all the Function Libraries file by clicking File->Close All Function Libraries.

1.4 Quality Center Connection

In real time scenario, we save all our test cases in QC (in case Organization has valid QC Licenses). To Save or Open any Test from Quality Center, you first need to connect to Quality Center. Click File->Quality Center Connection. Enter the QC Server URL and post that enter your login credentials to get connected to QC. Sometime you might need to select the Domain & Project Domain as well.

One can choose Reconnect to server on startup to automatically get connected with QC, whenever QTP is opened.

Choose Authenticate on startup in case you do not want to enter your login credentials every time.

You can choose Login to project on startup option when you always want to login to same domain and project to carry out with your work.

These Domain and Project are normally defined in QC Administration and User Group.

1.5 Save & Save As

To Save the current test you can either press Ctr+S, or you can click File->Save. This work in a same fashion as any word processor tool, Save feature works.

If you are working with Test, then pressing Ctr+S, will save the Test with latest changes made.

It’s not a good practice to save the Test with Active Screen files. In case you want to Save the same Test with different name, then use Save As option.

The above is true in case of Function Library as well, the only difference is that you can save the Function Library as VBS, TXT and QFL.

See the below structure to understand how a Test is saved on the drive.

Do not make any changes in the file available beneath your Test Folder.

1.6 Export Test to Zip File

You can Export your Test to Zip file to save disk space and for making usage across the network. Your Test should be open, before you start your export to Zip file. You have to individually export each Test File.

In real time scenario we rarely use this feature as all the Test Script are maintained in QC but where the Test Script get maintained in Shared Drive, there you may use this option to save the Shared Drive Disk Space and it also act as a backup of your Test Script.

To initiate, click File-> Export Test to Zip File. Please ensure that Test is open while using this feature.

1.7 Import Test from Zip File

To import the file, click File->Import Test from Zip File.

Select the Zip File location and destination where you want to unzip the file.

2 References

Quick Test Professional Tool

3 Download

Click here to download a PDF copy of this article.

QTP-Stroring Environment Variable In XML File

2010-05-09T05:13:00.000-07:00

Objective:Login Action Parameterization
By the Use of External Environment Variables the issue of Login Actions parameterization could be solved.Using this approach we can concurrently run scripts on different environments.
How it Works:
1. Create AutomaticConfiguration.xml file with two variables namely AdminLogin,UserLogin in Local QTP Installation folder.
2. The Admin and User Login Actions Loads the AutomaticConfiguration.xml file from the above mentioned path.
3. The Login Actions use the Environment variables to Launch the Application.
Steps To Create an XML File:
1. Open Notepad.
2. Type ENVIRONMENT on the first line (in opening and closing angular brackets)
3. Type each variable name-value pair within variable elements in the following format:
For example, your environment variables file may look like this:

4. Save the file as AutomaticConfiguration.xml in quicktest install folder(\program Files\MercuryInteractive\QuickTestProfessional) in your Local Machine.
You are done buddy. If you have any question or comments, please feel free to write at raghavendra.hosur@gmail.com or sachin.vasudha@gmail.com

QTP Functions

2010-05-09T04:46:00.001-07:00

QTP Functions
**********************************************************************************
Function TimeStamp()
iArr1=Replace(Now,"/","")
iArr2=Replace(iArr1,":","")
iArr3=Replace( iArr2,"AM","")
iArr3=Replace( iArr2,"PM","")
iArr4=Replace(iArr3," ","")
iArr5=Cdbl(iArr4)
iTimeStamp=iArr5-1000000000
TimeStamp=iTimeStamp
End Function
**********************************************************************************
Function TimeStamp(theDate)
TimeStamp=DateDiff("s","01/01/1970 00:00:00",theDate)
End function
**********************************************************************************
How to use the below function in your Test Script
**********************************************************************************
Set oObj=Browser("oBrowser").Page("oPage").Frame("oFrame").WebTable("oWebTable")
Call app_CLA__ClickLink_ChildObject(oObj,1)
**********************************************************************************
Function ClickLink_ChildObject(oObj,iLinkIndex)
Set oDesc1=Description.Create()
oDesc1("innertext").value=oFrame
Set oDesc2=Description.Create()
oDesc2("micclass").value=oWebTable
Set oDesc3=Description.Create()
oDesc3("micclass").value="Link"
oDesc3("index").value=iLinkIndex
Set iLink=oObj.ChildObjects(oDesc1)
iLink(iLinkIndex).click
End Function
**********************************************************************************

ABC Of Estimation

2010-03-30T20:07:00.000-07:00

1 WHAT IS ESTIMATION
What we mean by term Estimation? How do we measure software? Well, we measure software in terms of its SIZE which can be LOC, FP etc.
Sizing is the prediction of product deliverables needed to fulfill the project requirements.
Estimation is nothing but the prediction of effort (resource) needed to produce the deliverables.
Estimation is not 100% accurate at the early stages of the SDLC and as we move ahead our estimation become more accurate. We will see this more into coming sections.
Below is a BIG picture of Software Estimation:
Scope Defined -> WBS Created (All dependencies and task identified and created) ->Estimate the Software Size->Estimate the Effort (Cost) and Duration-> Assign Resources->Schedule the Work.
1.1 ESTIMATION MODELS
In below section we will see some widely used Estimation Techniques. In this article we will not go into much detail of each Estimation technique but will give you a high level detail of each technique. My next set of article will follow more detail on each technique, so keep checking on my site.
1.1.1 LOC – Line of Code
Line of Code – LOC is a measure of the SIZE of the Software. Once we calculate the Software Size in LOC unit, we can determine the Effort, Cost and Schedule. We can estimate the LOC using:
• Expert Opinions and Bottom Up Summations
• By Analogy
We will see the detail of above in next article.
In brief consider an example where in we want to estimate the size of software which will be developed in Java technology. The organization has developed similar software in the past. Now based on their past data, they can easily determined the size of the software in terms of LOC. They might use PERT model to get the Pessimistic, Optimistic, and Most Probable estimate (LOC) by experts and then produce the Final Estimate.
Let consider Pessimistic Estimate as 400 LOC, Optimistic as 200 LOC and Most Probable as 250 LOC, then using PERT we can derive final estimate as
PERT = (P+ 4M + O)/6 = (400+4*250+200)/6 = 266 LOC
If you have your productivity figure for Java in terms of LOC like 1 Staff can write 1000 LOC in a month, then you can estimate the Duration. Still productivity in terms of LOC is debatable and may not be the right method for determining productivity.
Note: The number of thousands of source lines of code (KSLOC) delivered is a common metric, carried through the estimation of productivity, which are usually expressed as KSLOC/SM or KLOC/SM (where SM= Staff Month).
LOC is a universal metric because all software products are essentially made of them.
Many organization measure Quality as: No. of Defects / No. of lines of code which is again not the correct way of determining the quality. Quality of the code is important and not the volume.
1.1.2 Function Point (FP)
The Function point method is based on the idea that software size is better measured in terms of the number and complexity of the function that it performs than on the number of lines of code that represent it.
FP measures categories of end-user business functions. It is more methodological way than are LOC counts. A really straightforward analogy is that of a physical house to software. The no. of square feet is to the house as LOC is to software; the number of bedrooms and bathrooms is to the house as function points are to software. The former looks at the size; the latter looks at size and function.
Here is a quick overview of Function Point process:
1. Count the functions in each category ( The categories are: Outputs, Inputs, Inquiries, Data Structures and Interfaces)
2. Establish the complexity of each category as Simple, Medium and Complex.
3. Establish weights for each complexity.
4. Multiply each function by its weight and then sum up to get total function points.
5. Convert FP to LOC using the formula:
LOC = Points X ADJ X Conversion Factor,
where ADJ is an adjustment for the general characteristics of the application.
The Conversion Factor, based on historical data for the application and programming language, represents the average number of lines of code to implement a simple function.
There is more to Function point which will follow soon on my next article dedicated to Function Point only.
1.1.3 Three Point Estimate or PERT Model
Three Point Estimate is considering 3 Estimate, OPTIMISTIC, MOST PROBABLE, PESSIMISTIC. We normally ask relevant developer or Analysts to provide the estimate as 3 Point Estimate. Once they provide these estimates we calculate the Final Estimate using PERT. A formula for the same is:

PERT = (P+ 4M + O)/6, SD = P-O/6

Let say we are estimating the Size of Software in terms of LOC and asking expert for their opinion. We got below value:

O = 200
P = 400
M = 250

PERT = (P+ 4M + O)/6 = (200+ (4 X 250) + 400)/6 = 266 LOC
SD = (P – O) / 6 = (400 – 200) / 6 = 33

The Final Size Estimate would be (266±33) LOC = between 233 to 299 LOC with 68% (1σ)Confidence.
With 2 σ (90%), 266±66 = between 200 to 332 LOC
With 3 σ (99%), 266±99 = between 167 to 365 LOC
1.1.4 Feature Points
Feature Points are an extension of the function point method designed to deal with different kinds of application, such as embedded and / or real time systems. Feature points are basically function points that are sensitive to high algorithmic complexity, where an algorithm is a bounded set of rules (executable statements) required to solve a computational problem.
In Feature Point technique apart from counting Outputs, Inputs, Inquiries, Data Structures and Interfaces we also count the number of Algorithms and provide a weightage as per the Algorithm complexity.
1.1.5 Wideband Delphi
This is a disciplined method of using the experience of several people to reach an estimate that incorporates all of their knowledge.
The “pure” approach (Pure Delphi) is to collect the expert opinion in isolation, feed back anonymous summary results, and iterate until consensus is reached. (without Group discussion). As Delphi approach can take a very long time, the concept of Wideband Delphi was introduced to speed up the process. This improved approach uses group discussion.
The steps in conducting Wideband Delphi are:
1. Distribute problem statement and a response form to all the experts.
2. Conduct a Group discussion.
3. Collect expert opinion anonymously.
4. Feed back a summary of results to each expert.
5. Conduct another group discussion.
6. Iterate as necessary until consensus is reached.
Group discussions are the primary difference between pure Delphi and Wideband Delphi.
This process may utilize the PERT calculation for arriving at Final Estimate. It mainly depends on organization how they are setting up the process for Wideband Delphi.
1.2 ESTIMATION RISK
1.2.1 Risk Associated with Estimation
1. Customer Dissatisfaction with Inaccurate Estimate.
2. Loss of Money in a Fixed Price Contract, due to too optimistic estimate.
Some of the Problems with Estimating:
1. Missing Facts while doing estimation.
2. No or Little Historical data upon which to base future estimates.
3. No Standard Estimating Process within an Organization.
4. Stakeholder misconception about estimating.
5. The requirement is not clear or there is insufficient visibility into other parts of the system
Inaccurate estimates will require adjustments to the schedule, to squeeze the optimal one into a shorter time frame, which almost always results in the introduction of defects.
1.2.2 How to Mitigate Estimation Risk
1. Decompose the WBS to the lowest level possible; smaller components are easier to estimate.
2. Review assumptions with all the stakeholders, including operations, maintenance and support departments.
3. If historical data is not available, collect Anecdotal evidence.
4. Update estimates at frequent intervals. Estimation accuracy does improve over the time(Life Cycle)
5. Educate developer in estimation methods
6. Use multiple size estimating methods to increase confidence.
2 REFERENCES
• Quality Software Project Management by Robert, Donald & Linda.
• Wikipedia
3 Download
Click here to download a pdf copy of this article.

Database Knowledge for a Tester Part V

2010-02-23T19:46:00.000-08:00

Hi Readers, this is the last series of DataBase Knowledge for a Tester. I hope you people must enjoyed the reading and gained database knowledge. Soon I will come with some more stuffs on Technology Knowledge for Tester.

1. GROUPING DATA FROM TABLES IN SQL
Apart from SELECT, WHERE, DISTINCT, ORDER BY etc, there are 2 more clauses which facilitate selective retrieval of row. These are the GROUP BY and HAVING clauses. These are same as ORDER BY and WHERE clauses, except that they act on recordsets, and not on individual records.
1.1 CONCEPT OF GROUPING
1.1.1 Group By clause
The GROUP BY clause creates a data set, containing several sets of records grouped together based on a condition.
Syntax:
SELECT (colname1),(colname2),(colnameN), AGGREGATE_FUNCTION(expression) from TABLE NAME where (condition) GROUP BY (colname1),(colname2),(colnameN);
For e.g.
Consider we want to find out how many employees are there in each department.
Select DEPT_NAME, COUNT(EMP_NO)”No. of Employees” From DEPT_MASTER GROUP BY DEPT_NAME;
Consider another example. In case if we have to find out how many employees are there in each Branch of a Bank.
Select BRANCH_NO, COUNT(EMP_NO)”No. of Employees” From EMP_MASTER GROUP BY BRANCH_NO;
1.1.2 HAVING Clause
HAVING imposes a condition on the GROUP BY clause, which further filters the groups created by the GROUP BY clause.
Each column specification specified in the HAVING clause must occur within a statistical function or must occur in the list of columns named in the GROUP BY clause.
For e.g.
Consider we want to find out all the customers which have more than one account in the Bank.
SELECT CUST_NO, COUNT(ACC_NO) “No. of Accounts” from ACC_DETAIL where ACC_NO like ‘CA%’ or ACC_NO like ‘SA%’ GROUP BY CUST_NO HAVING COUNT(ACC_NO)>1;

Consider another example, if we want to find the list of those customers having only 1 account.

SELECT CUST_NO, COUNT(ACC_NO) “No. of Accounts” from ACC_DETAIL GROUP BY CUST_NO HAVING COUNT(ACC_NO)=1;

1.1.3 Rules For GROUP BY and Having Clause
• Columns listed in the Select Statement have to be listed in the GROUP BY Clause
• Columns listed in the GROUP BY Clause need not be listed in the SELECT Statement.
• Only GROUP functions can be used in the HAVING clause
• The Group functions listed in the HAVING clause need not be listed in the SELECT statement.

1.2 SUBQUERIES
1.2.1 Subqueries
Subqueries are also called Nested query. A subquery is a form of an SQL statement that appears inside another SQL statement. The statement containing a subquery is called a parent statement.
The Parent statement uses the rows (i.e. the result set) returned by the subquery.
It can be used for:
• Inserting records in a target table.
• Creating tables and inserting records in the table created.
• Updating records in a target table.
• Creating Views.
• Providing values for conditions in WHERE, HAVING, IN etc and used with SELECT, UPDATE and DELETE statements.
For e.g.
Get the address of the Customer names Sachin Kumar.
SELECT CODE_NO “Cust No”, ADD1 ‘ ‘ ADD 2 ‘ ‘ ‘ ‘ CITY ‘ , ‘ STATE ‘ , ‘ PINCODE “address” FROM ADD_DETAIL WHERE CODE_NO IN
(SELECT CUST_NO FROM CUST_MASTER WHERE FNAME=’SACHIN’ AND LNAME=’KUMAR’);
1.2.2 Using Subquery in the FROM clause
The concept of using a subquery in the FROM clause is called an inline view. A subquery in the FROM clause of the SELECT statement defines a data source from that particular Select statement.
For e.g.
List accounts alongwith the current balance, the branch, and the avg balance of that branch, having a balance more than the avg. balance of the branch, to which the account belongs.
SELECT A.ACC_NO, A.CURBAL, A.BRANCH_NO, A.AVGBAL FROM ACCT_MSTR A, (SELECT BRANCH_NO, AVG(CURBAL) AVGBAL FROM ACCT_MSTR GROUP BY BRANCH_NO) B
WHERE A.BRANCH_NO=B.BRANCH_NO and A.CURBAL>B.AVGBAL;
1.2.3 Using Correlated Sub-Queries
A sub-query becomes correlated when the subquery references a column from a table in the parent query. A correlated subquery is evaluated once for each row processed by the parent statement, which can be any of SELECT, UPDATE or DELETE.
It is used whenever a subquery must return a different result for each candidate row considered by the parent query.
For e.g.
List accounts alongwith the current balance, the branch, having a balance more than the avg. balance of the branch, to which the account belongs
SELECT ACC_NO, CURBAL, BRANC_NO FROM ACCT_MSTR A WHERE CURBAL>(SELECT AVG(CURBAL) FROM ACCT_MSTR WHERE BRANCH_NO=A.BRANCH_NO);
1.2.4 Using Multi Column Sub-Query
Each row of the outer query is compared to the values from the inner query (Multi Row and Multi Column).
For e.g.
Find out all the customers having the same name as the employees.
SELECT FNAME, LNAME FROM CUST_MSTR WHERE (FNAME, LNAME) IN (SELECT FNAME, LNAME FROM EMP_MSTR);
1.2.5 Using EXISTS/ NOT EXISTS Operator
The EXISTS operator is usually used with correlated subqueries. This operator enables to test whether a value retrieved by the outer query exists in the result set of the values retrieved by the inner query. If a match is found TRUE is returned else FALSE.
The EXISTS ensures that the search in the inner query terminates when at least one match is found.
Similarly, the NOT EXISTS enables to test whether a value retrieved by the outer query is not a part of the result set of the values retrieved by the inner query.
For e.g.
List employees who have verified at least one account.
SELECT EMP_NO, FNAME, LNAME FROM EMP_MSTR E WHERE EXISTS(SELECT ‘SCT’ FROM ACCT_MSTR WHERE VERI_EMP_NO = E.EMP_NO);

List those branches, which don’t have employees yet.
SELECT BRANC_NO, NAME FROM BRANCH_MSTR B WHERE NOT EXISTS(SELECT ‘SCT’ FROM EMP_MSTR WHERE BRANCH_NO=B.BRANCH_NO);

1.3 JOINS
Joins are used to manipulate data from multiple tables using a single SQL sentence. Tables are joined on columns having the same data type, and data width in the tables.
SYNTAX:
ANSI STYLE
SELECT COL1, COL2, COLN From Table1 INNER JOIN Table 2 on Table1.COL1=Table2.COL2 WHERE (CONDITION) ORDER BY COL1, COL2, COLN
THETA-STYLE
SELECT COL1, COL2, COLN From Table1, Table 2 WHERE Table1.COL1=Table2.COL2 AND (CONDITION) ORDER BY COL1, COL2, COLN
In the above syntax:
1. COL1 in Table1 is its Primary Key
2. COL2 in Table2 is its Foreign Key
3. COL1 and COL2 must have the same data type and for certain data types, the same size.
1.3.6 Inner or Equi Join
INNER JOIN returns all rows from both tables where there is a match.
For e.g.
List the employee details alongwith Branch Names to which they belong.
Select E.EMP_NAME, D.BRANCH_NAME FROM EMP_MSTR E, DEPT_MSTR D WHERE D.DEPT_NO = E.DEPT_NO;
1.3.7 Outer Join
This type of Join can be used in situations where it is desired, to select all rows from the table on the left (or right or both) regardless of whether the other table has values in common and (usually) enter NULL where data is missing.
LEFT OUTER JOIN
For e.g.
List the employee details alongwith the contact details (if any) Using Left Outer Join
ANSI STYLE
SELECT A.NAME, A.DEPT, B.CONTACT from EMP_MSTR A LEFT JOIN CNTC_DTLS B ON A.EMP_NO=B.CODE_NO;
THETA STYLE
SELECT A.NAME, A.DEPT, B.CONTACT from EMP_MSTR A, CNTC_DTLS B WHERE A.EMP_NO=B.CODE_NO (+);

USING RIGHT OUTER JOIN- The same query.
ANSI STYLE
SELECT A.NAME, A.DEPT, B.CONTACT from CNTC_DTLS B RIGHT JOIN EMP_MSTR A ON B.CODE_NO=A.EMP_NO;
THETA STYLE
SELECT A.NAME, A.DEPT, B.CONTACT from CNTC_DTLS B , EMP_MSTR A WHERE B.CODE_NO (+)=A.EMP_NO;
In both the query, all the employee details need to be listed alongwith their contact details if any. 1.3.8 Cross Join
A Cross Join returns what’s known as a Cartesian product. The Join combines every row from the left table with every row in the right table.
1.3.9 Self Join
Joining a table to itself is referred to as self-join. In a self join, two rows from the same table combine to form a result row.
For e.g.
Retrieve the name of the employees and the names of their respective managers from the employee table.
SELECT EMP.FNAME “Employee”, MNGR.FNAME “Manager” FROM EMP_MSTR EMP, EMP_MSTR MNGR WHERE EMP.MNGR_NO = MNGR.EMP_NO;
1.4 Guidelines for Creating Joins
• Precede the column name with the table name when writing a select statement that joins tables.(For Clarity)
• If the same column name appears in more than one table, the column name must be prefixed with the table name.
• The WEHERE clause is the most critical clause in a join select statement. Always make sure to include the WHERE clause.
1.5 Miscellaneous Clause- UNION, INTERSECT AND MINUS
1.5.1 Union Clause
The output of multiple queries can be combined using UNION clause.

Output of the UNION Clause
For e.g.
Retrieve the names of all the employee working in India and US
SELECT EMP_NAME FROM EMPLOYEE WHERE LOCATION=’INDIA’
UNION
SELECT EMP_NAME FROM EMPLOYEE WHERE LOCATION=’US’

The UNION clause picks up the common records as well as the individual records in both queries.

Guideline for using Union Clause
• The number of columns and data types of the columns being selected must be identical in all the SELECT statement used in the query. The Column name need not be identical.
• UNION operates over all of the columns being selected.
• NULL values are not ignored during duplicate checking
• The IN operator has a higher precedence than the UNION operator
• By default the output is sorted in ascending order of the first column of the select statement.
• UNION cannot be used in Subqueries
• UNION cannot be used with Aggregate functions.
1.5.2 Intersect Clause
The INTERSECT clause outputs only rows produced by both the queries intersected i.e. the output in an Intersect clause will include only those rows that are retrieved common to both the queries.

Output of the INTERSECT Clause
For e.g.
Retrieve the customer holding accounts as well as fixed deposits in a bank.
SELECT DISTINCT CUST_NO FROM ACC_FD_TBL WHERE ACC_FD_NO LIKE ‘CA%’ OR ACC_FD_NO LIKE ‘SB%’
INTERSECT
SELECT DISTINCT CUST_NO FROM ACC_FD_TBL WHERE ACC_FD_NO LIKE ‘FS%’

The INTERSECT clause picks up the record that are common in both the queries.
Guideline for using Union Clause
• The number of columns and data types of the columns being selected must be identical in all the SELECT statement used in the query. The Column name need not be identical.
• INTERSECT does not ignore NULL values.
• Reversing the order of the intersected tables does not alter the result.
1.5.3 Minus Clause
Multiple queries can be put together and their output combined using the minus clause. The MINUS clause outputs the rows produced by the first query, after filtering the rows retrieved by the second query.

For e.g.
Retrieve the customer holding accounts but not holding any fixed deposits in a bank.
SELECT DISTINCT CUST_NO FROM ACC_FD_TBL WHERE ACC_FD_NO LIKE ‘CA%’ OR ACC_FD_NO LIKE ‘SB%’
MINUS
SELECT DISTINCT CUST_NO FROM ACC_FD_TBL WHERE ACC_FD_NO LIKE ‘FS%’

The MINUS clause picks records in the first query after filtering the records retrieved by the second query.
Guideline for using Union Clause
• The number of columns and data types of the columns being selected must be identical in all the SELECT statement used in the query. The Column name need not be identical.
• All the columns in the where clause must be in the SELECT clause for the MINUS operator to work.
2 REFERENCES
• SQL, PL/SQL Third Edition by Ivan Bayross.
3. Download
Click here to download a pdf copy of this article.

Database Knowledge for a Tester Part IV

2009-08-06T04:54:00.000-07:00

1 COMPUTATIONS ON TABLE DATA

Computations on table data may include displaying an employee’s name and the employee salary from the EMPLOYEE Master table alongwith the annual salary of the employee (i.e. Salary * 12). This can be achieved by using Arithmetic operator. We will see all these explained in below mentioned sections.

1.1 Operators Usage

1.1.1 Arithmetic Operator

Oracle allows arithmetic operators to be used while viewing records from the table or while performing Data Manipulation operations such as Insert, Update and Delete.

For e.g.

Consider we want to increment the salary of all employees by Rs 500.

UPDATE EMPLOYEE SET SALARY = (SALARY + 500)

Similarly you can use the above arithmetic operator for manipulating other data based on the requirement.

1.1.2 Logical Operator

The AND operator
The AND operator requires that each condition must be met for the record to be included in the result set. It can be used in any valid SQL statement such as Select, Insert, Update or Delete.

For e.g.

Consider we want to view the employee whose salary lies between 1000 to 5000.

SELECT EMPLOYEE_NAME FROM EMPLOYEE WHERE SALARY>=1000 AND SALARY<=5000.

The OR operator
The OR operator requires that any of the conditions must be met for the record to be included in the result set. It can be used in any valid SQL statement such as Select, Insert, Update or Delete.

For e.g.

Consider we want to view the employee which belongs to either ADMIN or IT department.

SELECT EMPLOYEE_NAME FROM EMPLOYEE WHERE DEPTT=’ADMIN’ OR DEPTT=’IT’

Combining the AND and OR operator
It can be used in any valid SQL statement such as Select, Insert, Update or Delete. When combining these conditions it is important to use brackets so that the database knows what order to evaluate each condition.

For e.g.

Consider we want to view the employee and which belongs to either ADMIN or IT department and their salary is greater than 3000.

SELECT EMPLOYEE_NAME, SALARY FROM EMPLOYEE WHERE (DEPTT=’ADMIN’ OR DEPTT=’IT’) AND SALARY>3000.

The NOT operator

The NOT operator display only those records that do not satisfy the conditions specified.

For e.g.

Consider we want to view the employees which are not married.

SELECT EMPLOYEE_NAME FROM EMPLOYEE WHERE NOT (MARITAL STATUS=’M’).

1.1.3 Range Searching – BETWEEN operator

The BETWEEN operator allows the selection of rows that contain values within a specified lower and upper limit. The range coded after the word BETWEEN is inclusive.

For e.g.

We can write the “Consider we want to view the employee whose salary lies between 1000 to 5000” also as:

SELECT EMPLOYEE_NAME FROM EMPLOYEE WHERE SALARY BETWEEN1000 AND 5000

1.1.4 Pattern Matching – LIKE predicate

The LIKE predicate allows comparison of one string value with another string value, which is not identical. This is achieved by using wildcard characters. Two wildcard characters that are available are:

• % allows to match any string of any length (including zero length)
• _ allows to match on a single character.

For e.g.

Suppose we want to view the Employee Name which starts with Letter “S”.

SELECT EMPLOYEE_NAME FROM EMPLOYEE WHERE EMPLOYEE_NAME LIKE ‘S%’

Similarly if we want to view only those employee name which start with letter S and is of 4 characters only.

SELECT EMPLOYEE_NAME FROM EMPLOYEE WHERE EMPLOYEE_NAME LIKE ‘S____’

1.1.5 IN and NOT IN Predicates
If a value needs to be compared to a list of values then the IN predicate is used. This predicate helps reduce the need to use multiple OR conditions.

For e.g.

Consider we want the list of all employees which belong to either ADMIN, HR, QUALITY, IT or PROJECT department.

SELECT EMPLOYEE_NAME FROM EMPLOYEE WHERE EMPLOYEE_NAME IN (‘ADMIN’,’HR’, ‘QUALITY’,’ IT’, ‘PROJECT’)

Note: NOT IN is just the opposite of IN and select all the rows where values do not match the values in the list.

1.2 Oracle Functions
1.2.1 Oracle Table “DUAL”
DUAL is a table owned by SYS. When an arithmetic calculation is to be performed such as 2*2 or 4/2 and so on, there is no table being referenced; only numeric literals are being used. To facilitate such calculation via a SELECT statement, Oracle provides a dummy table called DUAL.

For e.g.

SELECT 2*2 from DUAL will return 4.

SELECT SYSDATE from DUAL will return system date.

1.2.2 GROUP or AGGREGATE Functions
Functions that act on a set of values are called Group or Aggregate functions. For e.g. SUM is a function which calculated the total set of numbers. A Group function returns a single result row for a group of queried rows.

Some of the GROUP or AGGREGATE Function is described below:

1.2.3 Single Row or Scalar Functions
Functions that act on only one value at a time are called Scalar Functions. Single row function can be classified corresponding to different data types as:

String Functions - For String data type.
Numeric Functions – For Number data type
Conversion Functions – For Conversion data type
Date Functions - For Date data type

Some of the available scalar functions are described below:

1.3 Date Functions

1.4 Miscellaneous Functions

UID – This function returns an integer value corresponding to the userid of the user currently logged in.

Syntax:

UID(INTO [variable])

For e.g.

SELECT UID FROM DUAL;

USER – This function returns the user name of the user who has logged in. The value returned is in varchar 2 datatype.

Syntax:

USER

For e.g.
SELECT USER FROM DUAL;

2 REFERENCES

SQL, PL/SQL Third Edition by Ivan Bayross.

3 Download

Click hereto download a pdf copy of this article.

Database Knowledge for a Tester Part III

2009-07-29T06:06:00.000-07:00

1. CONSTRAINT CONCEPTS

1.1. Data Constraints

Business Rules, which are enforced on data being stored in a table, are called Constraints. It super control the data being entered into a table for permanent storage.

If constrains fails during insertion or updation of records, then entire record will be rejected and Insert or Update operation failed.

There are 2 types of data constraints which can be further classified as described in below sections.

Input/Output Constraints

The Primary Key Constraint

The Foreign Key Constraint

The Unique Key Constraint

Business Rule Constraints

CHECK Constraints

1.2. Input/Output Data Constraints

1.2.1. Primary Key Constraint

Primary Key Constraint defined at Column Level

Normally used, to define a single primary key in a table.

SYNTAX:

[COLUMN NAME] [DATATYPE] ([SIZE]) PRIMARY KEY

E.g.

CREATE TABLE employee (employee_no varchar2 (10) PRIMARY KEY, employee_name varchar2 (25));

Primary Key Constraint defined at Table Level

Normally used, to define a composite primary key in a table.

SYNTAX:

PRIMARY KEY ([COLUMNNAME], [COLUMNNAME])

E.g.

CREATE TABLE employee (employee_no varchar2 (10), employee_ssn varchar2(20), employee_name varchar2 (25), PRIMARY KEY (employee_no, employee_ssn));

Features of a Primary Key

Uniquely identifies a Row

Does not allow duplicate values and null values

Helps in establishing relationship among tables

Cannot be LONG or LONG RAW data type

Only 1 Primary Key is allowed per table

Unique Index created automatically

1.2.2. Foreign Key Constraint

This constraint establishes a relationship between records across a Master Table and Details table.

Foreign Key Constraint defined at Column Level

SYNTAX:

[COLUMNNAME] [DATATYPE]([SIZE]) REFERENCES [TABLENAME] [([COLUMNNAME]) ]
[ON DELETE CASCADE]

Note: ON DELETE CASCADE delete all the related records from the Master Table & Details table.

ON DELETE SET NULL option instead of deleting the record set the column value to NULL in the entire related table.

For e.g.

CREATE TABLE employee (employee_no varchar2 (10), employee_ssn varchar2(20), employee_name varchar2 (25), deptt_code varchar2(10) REFERENCES DEPTT_MASTER);

Here REFERENCES point to the DEPTT_MASTER table and create deptt_code as foreign key in employee table.

deptt_code is a primary key of DEPTT_MASTER table.

Foreign Key Constraint defined at Table Level

SYNTAX:

FOREIGN KET ([COLUMNNAME], .. [COLUMNNAME]) REFERENCES [TABLENAME] ([COLUMNNAME],…. [COLUMNNAME])

For e.g.

CREATE TABLE employee (employee_no varchar2 (10), employee_ssn varchar2 (20), employee_name varchar2 (25), deptt_code varchar2 (10), FOREIGN KEY (deptt_code) REFERENCES DEPTT_MASTER (deptt_code));

Features of Foreign Keys

Is a column(s) referencing a column(s) of a table (may be same table)

Parent references should be unique or primary key

Child may have duplicates or null but unless it is specified.

Foreign Key Constraint can be specified on child but not on parent.

Parent Record can be deleted provided no child record exists.

Records cannot be inserted into a detail table if corresponding records in master table do not exist.

Records cannot be deleted from the Master Table if corresponding records in the detail table actually exist.

1.2.3. Unique Key Constraint

Unique Key Constraint defined at Column Level

Normally used, to define a single unique key in a table.

SYNTAX:

[COLUMNNAME] [DATATYPE]([SIZE]) UNIQUE

For e.g.

CREATE TABLE employee (employee_no varchar2 (10) UNIQUE, employee_ssn varchar2 (20), employee_name varchar2 (25));

Unique Key Constraint defined at Table Level

Normally used, to define a composite unique key in a table.

SYNTAX:

UNIQUE ([COLUMNNAME],…. [COLUMNNAME])

For e.g.

CREATE TABLE employee (employee_no varchar2 (10), employee_ssn varchar2 (20), employee_name varchar2 (25), UNIQUE(employee_no));

Note: Unique Key Column allow NULL values while Primary Key Column does not allow NULL values

Features of Unique Key Constraint

Does not allow duplicate values

Unique Index created automatically

A Table can have more than 1 unique key which is not possible in Primary Key

Cannot be LONG or LONG RAW data type

1.3. Business Rule data constraint

Business Rule validations can be applied to a table column using CHECK constraint. CHECK constraints must be specified as a logical expression that evaluates either to TRUE or FALSE.

1.3.1. Check Constraint

Check Key Constraint defined at Column Level

SYNTAX:

[COLUMN NAME] [DATATYPE] ([SIZE]) CHECK ([LOGICAL EXPRESSION])

E.g.

CREATE TABLE employee (employee_no varchar2 (10) CHECK (employee_no like ‘E%’), employee_name varchar2 (25) CHECK (employee_name=UPPER(employee_name));

Unique Key Constraint defined at Table Level

SYNTAX:

CHECK ([LOGICAL EXPRESSION])

E.g.

CREATE TABLE employee (employee_no varchar2 (10), employee_name varchar2 (25), CHECK (employee_no like ‘E%’), CHECK (employee_name=UPPER(employee_name));

Restriction on Check Constraints

The condition must be a Boolean expression

Check constrains require a condition to be true or unknown for the row to be processed

The condition cannot contain subqueries or sequences

The condition cannot include SYSDATE, UID, USER or USERENV SQL functions.

Note: CHECK constraint takes substantially longer to execute as compared to NOT NULL, PRIMARY KEY, FOREIGN KEY or UNIQUE.

1.4. NULL Value Concepts

Principles of NULL values

Setting NULL value is appropriate when actual value is unknown.

A NULL is not same as 0 if data type is number and not same as spaces if the data type is character.

A NULL value will evaluate to NULL in any expression.

NULL value can be inserted into columns of any data type

Usual operands such as =,<,> and so on cannot be used on a NULL value. Instead, the IS NULL and IS NOT NULL conditions have to be used.

1.4.1. NOT NULL Constraint

SYNTAX:

[COLUMNNAME] [DATATYPE]([SIZE]) NOT NULL

E.g.

CREATE TABLE employee (employee_no varchar2 (10) PRIMARY, employee_name varchar2 (25) NOT NULL);

Note: The NOT NULL constraint can only be applied at column level.

1.5. Default Value Concepts

The DEFAULT clause can be used to specify a default value for a column.

SYNTAX:

[COLUMNNAME] [DATATYPE]([SIZE]) DEFAULT [VALUE];

E.g.

CREATE TABLE employee (employee_no varchar2 (10) PRIMARY, employee_name varchar2 (25) NOT NULL, sex varchar2 (2) default ‘M’);

Rules for Default Value

The data type of the default value should match the data type of the column

Character and date values will be specified in single quotes

If a column level constraint is defined on the column with a default value, the default value clause must precede the constraint definition

In such a case, the Syntax would be:

[COLUMNNAME] [DATATYPE]([SIZE]) DEFAULT [VALUE] [CONSTRAINT DEFINITION]

2. REFERENCES

SQL, PL/SQL Third Edition by Ivan Bayross.

3. Download

Click here to download a PDF copy of this Article.

Database Knowledge for a Tester Part II

2009-06-23T03:53:00.000-07:00

1 SQL Concepts
1.1 Basic Data Types

1.2 Basic SQL Commands
1.1.1 Create Table
SYNTAX:
CREATE TABLE [Table Name] ([ColumnName1] [Datatype] ([size]), [ColumnName..n] [Datatype] ([size]));
Rule for creating table:
· Name can have maximum upto 30 chars.
· Name should begin with an Alphabet (A-Z, a-z) and optionally followed by numbers (0-9)
· Special character “_” underscore is allowed and also recommended.
· SQL reserved words like create, select etc are not allowed.
E.g.
CREATE TABLE employee (employee_no varchar2 (10), employee_name varchar2 (25));
1.1.2 Insert Data into Tables
SYNTAX:
INSERT INTO [TABLE NAME] ([COLUMNNAME1], [COLUMNNAME...N]) VALUES ([EXPRESSION1], [EXPRESSION2]);
For e.g.
INSERT INTO employee (employee_no, employee_name) VALUES (‘E001’, ‘Sachin Kumar’);
Note: Character & Date expressions placed with in the INSERT INTO statement must be enclosed in single quotes.
In INSERT INTO if the number of values is same as the number of column then there is no need to provide the column name in the INSERT INTO command provided the expression are provided in the same sequence and data type as defined during CREATE TABLE.
However if there is less values being inserted into the table, then it is mandatory to include both the Column Name and corresponding value in the INSERT INTO SQL command.
1.1.3 Viewing Table Data
View All Rows and All Columns
SELECT * FROM [TABLE NAME];
Selected Column and All Rows
SELECT [COLUMNNAME1], [COLUMNNAME…N] FROM [TABLE NAME];
Selected Rows and All Columns
SELECT * FROM [TABLE NAME] WHERE [CONDITION];
Here [CONDITION] is always quantified as [ColumnName=Value]
Note: All Standard operators such as logical, arithmetic, predicates etc can be used when specifying where clause.
Selected Column and Selected Rows
SELECT [COLUMNNAME1], [COLUMNNAME…N] FROM [TABLE NAME] WHERE [CONDITION];
Here [CONDITION] is always quantified as [ColumnName=Value]
Note: All Standard operators such as logical, arithmetic, predicates etc can be used when specifying where clause.
Distinct Data or Eliminate Duplicate Records
SELECT DISTINCT [COLUMNNAME1], [COLUMNNAME…N] FROM [TABLE NAME];
Display unique column values.
SELECT DISTINCT * FROM [TABLE NAME];
Display unique rows from all the records.
1.1.4 Sorting Table Data
Syntax:
SELECT * FROM [TABLE NAME] ORDER BY [COLUMNNAME1], [COLUMNNAME…N] [[SORT ORDER]];
Note: The ORDER BY Clause can only be used in Select Statements.
The Default sort order is ASC (ascending). To sort the record in descending order use DESC keyword as Sort Order.
1.1.5 Updating Table
Updating All Rows
UPDATE [TABLENAME] SET [COLUMNAME1] = [EXPRESSION1], [COLUMNAME…N] = [EXPRESSION…N];
Conditional Update of Records
UPDATE [TABLENAME] SET [COLUMNAME1] = [EXPRESSION1], [COLUMNAME…N] = [EXPRESSION…N] WHERE [CONDITION];
1.1.6 Alter Table
ALTER TABLE allows:
· Add/Delete columns
· Create or Destroy indexes
· Change the data type of existing columns
ALTER TABLE cannot be used for:
· Changing the name of the table & column
· Decrease the size of a column if table data exists.

SYNTAX:
Adding New Column
ALTER TABLE [TABLE NAME] ADD ([NEWCOLUMNNAME1] [DATATYPE]([SIZE]), [NEWCOLUMNNAME…N] [DATATYPE]([SIZE]));
Dropping A Column From a Table
ALTER TABLE [TABLE NAME] DROP COLUMN [COLUMNNAME];
Modifying Existing Columns
ALTER TABLE [TABLE NAME] MODIFY ([COLUMNNAME] [NEWDATATYPE] ([NEW SIZE]));
Note: To use Alter Table command, the ALTER, INSERT & CREATE privileges for the table are required.
1.1.7 Delete Table
Removal of All Rows
DELETE FROM [TABLE NAME];
Removal of Specific Rows
DELETE FROM [TABLE NAME] WHERE [CONDITION];
1.1.8 Truncate Table
Truncate Table like Delete Table deletes all rows from the table but there are some practical differences under some circumstances:
· Truncate is much faster than Delete as Truncate first drop the table and then re-create it.
· Truncate operations are not Transaction safe in case of any error while execution.
· The number of deleted rows are not returned.
Syntax
TRUNCATE TABLE [TABLENAME];
1.1.9 Drop Table
Drop table dropped all records from the table and permanently destroy table from the database which cannot be recovered.
Syntax:
DROP TABLE [TABLENAME];
1.2 Examining Objects Created by a User
1.2.1 Finding out the table/s Created by a user
SELECT * FROM TAB;
The tables created under the currently selected tablespace are displayed.
1.2.2 Displaying the table structure
DESCRIBE [TABLENAME];
The command displays the column names, the data types, and the special attributes connected to the table.
2. References
SQL, PL/SQL Third Edition by Ivan Bayross.
3. Download
Click here to download a PDF copy of this Article.

Database Knowledge for a Tester - Part I

2009-06-18T03:29:00.000-07:00

1. Database concepts
1.1 Codd’s Rule for RDBMS – 12 Rule
Rule 1: The Information Rule
All data should be presented in a table form
Rule 2: Guaranteed Access Rule
All data should be accessible without ambiguity.
Rule 3: Systematic Treatment of Null Values
Support for Null values which is distinct from an empty string or a number with a value of zero.
Rule 4: Dynamic Online Catalog based on the Relational model
A relational database must provide access to its structure through the same tools that are used to access the data.
Rule 5: Comprehensive Data Sublanguage Rule
The DB must support at least one clearly defined language that includes functionality for Data Definition, Data Manipulation, Data Integrity, and Database Transaction Control.
Rule 6: View Updating Rule
Each view in the database should support the same full range of data manipulation that has direct access to a table available. In reality, providing update and delete access to logical views is difficult and is not fully supported by any current database.
Rule 7: High-level Insert, Update, and Delete
Insert, Update and Delete operations should be supported for any retrievable set rather than just for a single row in a single table.
Rule 8: Physical Data Independence
The user is isolated from the physical method of storing and retrieving information from the database.
Rule 9: Logical Data Independence
How data is viewed should not be changed when the logical structure of the database changes. This rule is particularly difficult to satisfy.
Rule 10: Integrity Independence
The database language should support constraints on user input that maintain database integrity.
Rule 11: Distribution Independence
A user should be totally unaware of whether or not the database is distributed.
Rule 12: Non Subversion Rule
There should be no way to modify the db structure other than through the multiple row database language.
1.2 DBMS Vs RDBMS
DBMS – Database Management System.
The relationship between 2 tables or files is maintained programmatically.

Does not support Client/Server Architecture
Does not support distributed databases
There is no security of data

RDBMS – Relational Database Management System
The relationship between 2 tables or files can be specified at the time of table creation

Support Client/Server Architecture
Support distributed databases
There are multiple levels of security
Logging in at O/S level
Command level
Object Level

1.3 Normalization
It is a process that helps in designing the table structure for an application.
Normalization is technique that:

Decomposes data into two dimensional tables.
Eliminates any relationship in which table data does fully depend upon the primary key of a record.
Eliminates any relationship that contains transitive dependencies.

1.3.1 First Normal Form
A table is in 1st Normal Form if:

There are no repeating group
All the key attributes are defined.
All attributes are dependent on a primary key

1.3.2 Second Normal Form
A Table is in 2nd Normal form if:

Its in 1st Normal Form
It includes no partial dependencies i.e. an attribute is dependent on only a part of a primary key.

1.3.3 3rd Normal Form
A table is in 3rd Normal form if:

Its in 2nd Normal Form
It contains no transitive dependencies.

Note: A general case of transitive dependencies is as follows:
X, Y, Z are 3 columns in table.
If Z is related to Y
If Y is related to X
Then Z is indirectly related to X
This is when Transitive dependencies exist.
Note: Normalization slow down the database query for fetching records. So sometime to make the query faster denormalization is deliberately done on the table.
1.4 Illustration of Normalization

2 Components of SQL
2.1 DDL, DML & DCL Commands
DDL – Data Definition Language – No Rollback is possible – Commit is issued implicitly.
Examples are:
· CREATE
· ALTER
· DROP
· TRUNCATE – Remove all the records from a table, including all spaces allocated for the records are removed
· GRANT
· REVOKE
DML – Data Manipulation Language
Examples are:
· INSERT
· UPDATE
· DELETE – Deletes all records from a table, the space for the records remain.
· SELECT – more specifically a DQL – data query language.
DCL – Data Control Language
Examples are:
· COMMIT
· ROLLBACK
References
SQL, PL/SQL Third Edition by Ivan Bayross.
Download
Click here to download a PDF copy of this article.

Mantis - Defect Management Tool - User Guide

2009-01-07T06:40:00.000-08:00

Introduction
This white paper contains information related to an open source defect management tool called Mantis which is freely available for managing all your defects.

Where to Download
One can download the latest version of Mantis from http://sourceforge.net/project/showfiles.php?group_id=14963
Download the “mantis-stable” and then “mantis-x.y.z.zip”.1.1

PRE-REQUISITE
Operating System
Windows 2003 Server, MacOS, OS/2, Linux, Solaris
Database
MySQL database 3.23.2 and higher
Software
PHP 4.0.6 and higher
Application Server
Apache 1.3, Apache 2.0.54, IIS 6.0 with Web Services Extension
Browser
IE6 and above, Mozilla Firefox

STEPS FOR INSTALLATION – FOR WINDOWS

MySQL Installation

Install MySQL by downloading it from http://dev.mysql.com/get/Downloads/MySQLGUITools/mysql-gui-tools-5.0-r6-win32.msi/from/http:/www.mirrorservice.org/sites/ftp.mysql.com/ .
Please follow the below mentioned steps while installing MySQL: (Please remember the password for “root” account)
I. Run Setup.exe. Ignore the warning messages if any.
II. Select Typical Setup and click next until you get to the sign up step. Select Skip and complete the installation.
III. In the Configuration Wizard pick Detailed Configuration from the first option screen. Click next.
IV. Pick Server Machine on the next screen. Next.
V. Select the Non-transactional for database usage. Next.
VI. Pick the first option (Decision Support (DSS)/OLAP). Next.
VII. Make sure both options are checked at the next screen. Next.
VIII. Use the standard character set. Next.
IX. Allow MySQL to install as a Windows Service and launch automatically with Windows.
X. Set the root password to ‘#######’. DO NOT ENABLE ROOT ACCESS FROM REMOTE MACHINES AND CERTAINLY DO NOT CREATE AN ANONYMOUS ACCOUNT.
XI. Execute Settings.
Please check the availability of MySQL in the Start-All Program list.

PHP Installation

Install PHP by downloading it from http://uk2.php.net/get/php-5.2.6-Win32.zip/from/a/mirror
Follow the Steps and complete the installation. Please check the availability of PHP in the Start-All Program list.To successfully install Mantis the PHP must be able to communicate with MySQL. In case you encounter any error which is related to PHP and MySQL integration then check the Environment variable path.

Mantis Installation

Download the mantis from http://sourceforge.net/project/showfiles.php?group_id=14963

I. Extract the zip file to your hard drive. C:\Inetpub\wwwroot\mantis
II Access http://[yoursite- normally a localhost]/mantis/admin/install.php. See below

III.The Green color indicates that everything is OK.
IV.Once your installation is complete, then navigate to C:\Inetpub\wwwroot\mantis
V. Open “config_inc.php” file and set the below mentioned parameter for database details:
# set these values to match your setup
$g_hostname = "your server or localhost";
$g_db_username = "your user name";
$g_db_password = "your password";
$g_database_name = "your database name";
$g_db_type = "mysql";
VI. Save and close the above file.
VII. Open mantis as http:///mantis/index.php
VIII.Enter Administrator as user Id and root as pwd if login for the first time.
IX. Immediately go to Manage and create at least one administrator level account. Immediately after that DISABLE or DELETE the administrator account. You can recreate it but you should delete the account to prevent the cookie_string from being used to trick the package. It would be even better to rename the account or delete it permanently. REMEMBER: After setting up the package, REMOVE the default administrator account.

IMPORTANT CONFIGURATION FOR MANTIS

Email Configuration

You can configure the email by providing the below mentioned parameter in “config_inc.php” file:
$g_administrator_email = 'xxx@xyz.com';
$g_webmaster_email = ' xxx@xyz.com ';
# the "From: " field in emails
$g_from_email = ' xxx@xyz.com ';
# the return address for bounced mail
$g_return_path_email = ' xxx@xyz.com ';
For configuring the SMTP server, please make below changes in the “config_defaults_inc.php” file:
$g_phpMailer_method = 2;
$g_smtp_host = your SMTP host name';
$g_smtp_username = 'your SMTP user id';
$g_smtp_password = 'Your SMTP password';

User Creation

The above screen gets displayed. Provide the desired user name and the appropriate access level. The available access levels are:
Viewer, Reporter, Updater, Developer, Manager, Administrator.

Project Creation

The above screen gets displayed. Provide the desired Project name and the required details and then click the Add project button.

Email Notification

To configure the email notification login into Mantis as an administrator and click Manage Tab->Manage Configuration->Email Notifications

Please tick or un-tick appropriate option as per your requirement and then save the changes by clicking Update Configuration button. The change made here will ensure that who all are going to receive email in case of any changes in the reported defects.Once these configurations are completed, then the Mantis is ready for use for managing defects.

Defect Category Creation

After the Project has been created, then create the various categories for defects which are going to be selected at the time of defect reporting. To create Defect Category, login as an Administrator and Click Manage Tab->Manage Projects->Select the Project. On the edit project page scroll down and locate the Add Category button.

Enter Category name and click the Add Category button. Please follow the same step for creating multiple categories.

Version Creation

After the Project has been created, then create the versions to be selected while reporting the defects. To create Version, login as an Administrator and Click Manage Tab->Manage Projects->Select the Project. On the edit project page scroll down and locate the Add Version button.

Enter Version name and click the Add Version button. Please follow the same step for creating multiple Versions.

Global Profile Creation

You can create a global profile to indicate the environment on which you are doing the testing of the application. To create a global profile, login as an administrator and click Manage Tab->Manage Global Profile.

On the above page, enter the details of available field like Platform, Operating System, Version, and any additional description and then click the Add Profile button.The newly created profile is available globally to the entire defect reporter.

DEFECT MANAGEMENT

Defect Life Cycle Mantis

Defect Reporting

The users (Reporter) who have the rights to report the defect can use Mantis to report the defects while doing testing of the application. The steps for reporting defects are as follows:

I. Login using your valid user id and password.
II. Click Report Issue link.
III. The above page gets displayed. In case you are not able to view all the above field shown in the screen shot, then click the Advance Report link available in upper right section of the page.
IV. Select the Defect Category, Reproducibility, Severity, Select Profile, Product Version. (You may select mandatory field only but as a good practice please input as much information as one can)
V. Enter a Summary for the defect – would be one liner.
VI. Enter Defect Description
VII. Enter the Steps to Reproduce the Defects.
VIII. You can also enter any other additional information.
IX. In case you want to upload supporting document for the defects like screen shot, video etc., then Upload the desired file.
X. Set the View Status to either Public or Private. Recommended is Private so that only authorized user can view the detail of defect.
XI. Submit the Report
Once the Defect has been submitted, its Status is Set to New and Resolution is Open. Refer Defect Life Cycle Section

Defect Assignment

The authorized user (Manager) can assign the reported defect to the respective developer. The Steps for assigning defect(s) to developer are as follows:

I. Logged into Mantis
II. Click View Issues link
III.Select the Issue which should be assigned. (as shown above)
IV. Select Assign from the drop down
V.Click OK (see above screen shot)
VI.Select the developer name from the drop-down and click the Assign Issues button.
Once the defect has been assigned, the status is set to Assigned and Resolution remains open. (Refer Defect Life Cycle Section)

Defect Resolution

After the defect has been assigned, the developer got email notification of all the issue(s) assigned to him/her. The developer can change the Status and provide the correct Resolution based on his/her defect analysis. The below mentioned scenarios can happen at the developer end:
A. In case Defect is valid:
a. Change the Status to Resolved and Resolution to Fixed
B. In case Defect is not valid:
a. Change the Status to Resolved and Resolution to either Duplicate or No Change Required or Unable to Reproduce.
C. In case Defect is valid but planned to fix in future releases:
a. Change the Status to Acknowledged and Resolution remain Open.
The steps for performing above mentioned change in the defect status and resolution are as follows: (Refer below mentioned screen shot)
I. Logged into Mantis
II. Click View Issues link
III. Click the Issue
IV. Click the Update Issue button
V. Change the Status and Resolution and save the changes.

Defect Closure

After the defect status has been marked as Resolved, then the reporter verifies the defect for its closure. The below mentioned scenarios can happen at Reporter end:
1. In case defect is found to be fixed during verification:
o Change the Defect Status from Resolved to Closed. Do not make any changes in Resolution.
2. In case defect is found not fixed during verification:
o Do not change the Status but change the Resolution from Fixed to Reopen
In such cases the defect again moves to Assigned and so on.
3. In case defect is dropped by developer and reporter found that the defect still exists:
o Do not change the Status but change the Resolution to Reopen.
The Reporter follows the same steps as developer to change the Defect Status. Please see section Defect Resolution

Your views and comments are welcome on above white paper.

Automation Framework - Beyond Buzzword

2008-08-04T05:10:00.000-07:00

1. What is Automation?
Controlling one application for another application.
2. What is Framework?
A structure which consists of all the building blocks for developing an application.
3. What is Automation Framework?
You are going to use the building block of structure to develop application which is going to control another application.
4. Background – Object Oriented
If you have done development in any OO programming language then you can easily understand the concept of Framework and Automation. Take a simple example of Calculator. Can we call it an automated tool? Yes it is. You know why, because it controls the simple and scientific calculations.
If you are asked to develop a program like calculator in any OO language, then you are going to make use of many pre-existing library, their methods, properties to accomplish your goal. Now these library or readymade utilities can be bundles in a framework and you just make use of that framework to execute your task.
5. Test Automation Framework
Come to the point and talk about automation framework in testing. Today a no. of testing tool is available in the market and I am going to discuss about one of the widely used tools for automation which is HP Mercury QTP. How you are going to develop an automation framework in QTP.
Well you have heard of Keyword driven and Data driven methods which is considered as an Automation Framework. But I am not in agreement with this view as they do not fulfill the requirement of an Automation framework as whole. It’s Ok that using above methods you can accomplish specific task as per your requirement and you can reuse it in a same application but you cannot make much of it in another application having different requirement. Then what is the use of such a framework, which cannot be extended to fulfill any task.
In next para, I am going to talk of a Framework which can be extended to fulfill any automation task in QTP. I would like to call this as XP Framework - the framework which is extendible in real terms.
6. Beyond Paradigm – XP Framework
I would explain the above framework taking a very simple example. In most of the application you will find a presentation layer, business layer & database layer. XP Framework (as I called) talk of extending existing utilities available with QTP to fulfill the above architecture.
6.1. Presentation Layer (PL) Framework
Develop a library which is going to take care of your presentation layer. Now you will say QTP has already taking care of it. I will ask you how many shared repository you are maintaining for 5 different application you are currently working on. You will say 5. Why 5? Why not a single library for maintaining the repository for all your 5 applications? Never ever think of it. No problem.
Develop a list of object in web-based and desktop based application. The list could include text box, label, list box, combo box, radio button, checkbox, command button, image etc.
For e.g. Consider a login page which has 4 controls, 2 Input Box and 2 command buttons.
When you record your script make use of above control in developing a common library which can be fit into any similar login page in different application.
Every control has some properties and it belong to some object class. You goal is to make use of property and develop procedure so that you can set the property of these controls at run time.
When you record an event on a particular control the tool generate script for your actions and then you start working on these generated script by modifying, making it reusable, modular etc. Great Job you are following Data Driven model. What if you are asked to test the same functionality in different applications with same control but different properties, event etc?
You start recording and again start modifying your script. Why not we focus on developing a Presentation framework which should be application independent?
For e.g. “Object (Property, Action/Event)”. Here Property & Action/Event refers to all the Property and Action/Event supported by the underlying object. Give more thought over it as this method is time taking but once developed must give a good ROI.
6.2. Business Layer (BL) Framework
You have developed a presentation layer framework, now how PL and BL is associated. PL is used for user activity or input. The user input via PL carries some functionality which is also a part of requirement and thus testing. How you test this business layer where you have to apply logical thinking?
Here comes the old logical blocks of If, Else. Take an example, if I have to test “Age of a person cannot be less than 13 years while creating an email account”. Think about what are the objects, actions and input linked with above functionality while testing.
We already generated the PL, now using PL, provide the input and verify that a proper error message get displayed when user is trying to provide an age which is less than 13 year old.
Creation of a reusable business layer is time taking and evolving. You always have to make note of most common business function across all applications. Business Functionality are not always the same, so you have to make logical business unit and then put all your observation for the business unit on ongoing basis and soon you will find that you have created a library of Business Unit which can easily be reused in matching applications carrying same business functionality.
If one is going to automate the above functionality in QTP, then s/he is going to record the above functionality alongwith the error message. Good, that is the right way but I am going to put that If…else block to make it more reliable. For e.g. first I am going to give the script name “AgeLessThan13YearsOld”. This way I can easily find out all the business related script and can run it at any regression cycle. 2 more things I am going to incorporate to make it more reusable. First the input of age and verification of message.
Make the script with 2 arguments, one is age which can be used as input in your script and other is the expected message which get verified with the actual message and the result get reported. This design will ensure that if in future business changed from age 13 to age 15, I just need to change my arguments in the script and nothing else.
6.3. Database Layer
The last layer is the database layer which store the information passed via the presentation layer, filtered through business layer. What you are going to verify in your database. If you are spending time in verifying the entered data in the database using QTP, I will say it useless. You can easily verify it by directly opening the database table.
For e.g. if you are testing a search page, then
You can check the total no. of records returned via a query should match with the results returned on PL.
7. QTP – Itself a framework – Shifting Paradigm
QTP is itself an automation framework which help user to fulfill automation task for testing. We are making use of various features of this framework and trying to develop another framework above oneJ.
What we are trying to do? We are trying to fulfill some business tasks of testing. We are developing script, modifying the script, making it reusable and numerous activities. These all are procedure and we are making use of QTP Framework.
The Automation Framework is an industry buzzword and nothing else.
The industry is calling below mentioned as framework and I am not in agreement with it:
 Test Script Modularity
 Test Library Architecture
 Data-Driven Testing
 Keyword-Driven or Table-Driven Testing
 Hybrid Test Automation
Why we call the above model as a Framework. We solve the business problem using above models in QTP or similar automation tool (which I am calling as an Automation Tool Framework.)
What I am talking may sound rubbish but I am talking on basics. Why we do not call MVC, N-tier and other architecture a framework? Why we call dot net as framework because we solve business problem using Dot Net Framework following some architecture which is reliable, maintainable etc.
Even the framework which I mentioned over here is just an extension of QTP Framework.

The above views are mine and you may or may not agree with it. The views and opinions give may or may not be useful for you in real time scenario.
Your views are most welcome.

Website Testing - Tools and Best Practices

2008-07-01T02:07:00.000-07:00

Introduction

This white paper contains information related to tool and fire-fox add-ins that are freely available for usage when doing testing for websites.

Website testing tool:
Pixel Ruler v3.1 – Measure Vertical and Horizontal distance (in pixels) between various section of a website or your desktop.
Firefox add-ins:
TAW-it – Helpful in doing Accessibility testing
Web Developer

Website testing tool and add-ins

Pixel Ruler Functionality
Know the exact size and position of any element with this screen ruler.

Free and easy to use virtual screen ruler.

Float over your screen.

Work with all applications.

Show measurements in Pixels.

Rotate to horizontal or vertical position.

Maximum of 1300 pixels.

Choose between several skins.

How to install the application

Download the Setup from http://www.mioplanet.com/products/pixelruler/index.htm

Run the Setup
Start using Pixel Ruler
The supported Operating systems are Windows 98, ME, NT4, 2000, XP, Vista.

How to use the Pixel Ruler
1. Open Pixel Ruler
2. Open the website for which you want to measure the pixel distance between the sections, images or various other objects of your interest.
3. Set the initial point and move your mouse horizontally or vertically to the destination point.
4. Check the value displayed at the destination position of mouse cursor

TAW - it
TAW-it allows to verify, with just a click, the accessibility of the Web sites that you are visiting, by means of the TAW3 online service (www.tawdis.net) and making use of the W3C Web Content Accessibility Guidelines (WCAG 1.0).
Its goal is to analyze the level of accessibility in the design and development of Web pages to allow access for all, regardless of their specific characteristics
TAW is based on rules developed by the W3C WAI (Web Accessibility Initiative). These rules, known as Web Content Accessibility Guidelines 1.0, include fourteen guidelines that describe the principles of accessible design. Each of these guidelines is divided into one or more checkpoints.
For more information, visit Web Content Accessibility Guidelines 1.0.

How to install the TAW-it Add-Ins
Pre-requisites:
Firefox: 1.0 – 2.0.0
OS – Supported where Firefox works.
Open Firefox browser
Open link http://www.tawdis.net/taw3/descargas/ext/tawclic.0.9.6.xpi

Follow the instructions and restart your browser
Once TAW-it has been successfully installed, its icon will appear in the browser status bar, and you will be able to make an accessibility analysis of the Web page you are visiting simply by clicking on that icon.

How to use TAW-it

1.Open the Website under test in Firefox browser
2. Check the TAW-it icon in the status bar
3. Change the settings based on your requirement of WCAG 1.0 Level AAA, AA, A
4. Click the TAW-it icon in the status bar
5. TAW-it generates an accessibility report
6. Analyze the report and share with your web developer for necessary fixation.
Note: The website that is under test must be hosted on a public domain, then only TAW-it will be able to do the analysis. This cannot be used on local hosted website.
Web Developer
Web developer tool help you in doing a complete analysis of web pages with respect to various parameters that are available with this addins.
The Web Developer extension adds a menu and a toolbar to the browser with various web developer tools. It is designed for Firefox, Flock, Mozilla and Seamonkey, and will run on any platform that these browsers support including Windows, Mac OS X and Linux

How to install the Web Developer Addins
Pre-requisites:
Firefox: 1.0 – 2.0.0
OS – Supported where Firefox works Windows, Mac OS X and Linux
Open Firefox browser
Open link https://addons.mozilla.org/en-US/firefox/addon/60
Follow the instructions and restart your browser
Once Web Developer has been successfully installed, you will find various menu and toolbar with various web developer tools on the browser standard tool bar. A 'Web Developer' menu under the 'Tools' and context menu of the browser, as well as a new toolbar.

How to use Web Developer
This tool is very helpful for doing Website Testing. A tester can use this tool for verifying mentioned below functionalities of web pages: Click here to download the document.

Steps to Use
1. Open the web page to test
2. Suppose there is requirement to test “All images must have ALT TAGS”.
3. Choose Images->Display ALT attributes
4. All the ALT attributes on the page will get highlighted and one can easily verify the ALT tags
5. Similarly you can test other functionality as per your requirement.

The above article is based on my learning (may or may not apply to your case) and in case you want to share your thoughts, then please do it and assist others.

HP Quality Center - Best Practices

2008-06-02T01:56:00.000-07:00

1.Introduction
Quality Center is a test management tool which provides very good features for managing both your manual and automated test cases. This paper highlights the best practices for managing your test cases.
When you open Quality center, depending on your rights it display the below mentioned option in the sidebar:
1. Requirements
2. Test Plan
3. Test Lab
4. Defects
5. Dashboard
2.Requirements
When you have assigned with the responsibility of developing your test cases in the quality center then you must be wondering where to start with. I am going to share my experience to overcome such a situation.
You need to find the solution of some question before you start writing your test cases.
1. Is your requirement developed and available?
2. Is your requirement organized in a logical sequence?
If answer to both of the above question is Yes, then you can start with Requirement option in the side bar. In case your requirement is under development, then you keep your requirement updated in Quality Center alongwith your test cases.
Develop a folder structure based on the logical sequence of the requirement. For e.g. if your requirement document consists broadly below mentioned section, then create the same folder structure in your Quality Center Requirement module.
1. Use Cases
2. User Interface
3. Business Rules
4. Report Specification
The above are your folder name under a root directory which can be the name of your project or product.
You then start creating the requirement under these folders structure and provide logical and relevant name to each of your requirement. For e.g. if my requirement has say use cases for say Login, Landing Page etc. Then the Use Cases and other folder must contain these requirements. An illustration is given below:
1. Use Cases
Login
Landing Page
2. User Interface
Login
Landing Page
and so on…

3.Test Plan
Once you are through with your requirement, then you start writing test cases. The best way to write test cases is to refer the use cases, user interface, business rules and report specification. These sections help one to develop various scenarios for use cases.
Always think of all possible scenarios and then start documenting those scenarios as per your requirement.
So now you focus your attention on Test Plan module of QC. Here you are going to create the folder structure in logical sequence. The best way to define a logical sequence is to understand the use cases. Your use cases are going to assist in developing the logical sequence and your test scenarios. For e.g. referring my previous example of Login I can think of various test scenarios like
1. Valid Login
2. Invalid Login
3. Authentication and Authorization
4. Server down while login
5. Improper shut down in last successful login
In a similar way you can think of valid scenarios depending on your requirement. These Test Scenarios are going to be your test cases in Quality Center.
An illustration of your folder structure in Test Plan module is given below:
1. Your Project or Product Name
Login
Valid Login
Invalid Login
Authentication and Authorization
Server down while login
Improper shut down in last successful login
Now you must be wondering where we are going to provide the test steps for each scenarios or test cases.
You are going to create your test step for each test scenario. Before that you have to provide the details about the Scenarios in terms of objective, pre-requisite, pre-condition, assumptions and anything important and relevant.
The test scenarios should be completed when you have provided below mentioned detail in Quality Center- Test Plan module.
1. Details
2. Design Steps
Apart from above you can also provide other details like attachments. You can also map your test scenarios with previously developed requirement and defects (once you executed the test scenarios). This you can do using the Req Coverage tab & Linked Defects) available in QC after creating the test scenarios.
4. Test Lab
After completing the test scenarios, the next step is the execution of your test scenarios. The execution sequence can be built in Test Lab module of the Quality Center.
In the test lab module you add your test scenarios that is planned to be executed. Here you are creating a Test Set. A Test Set normally covers a full use case. It is not necessary that you are going to execute all the test scenarios in one go. As I mentioned it is going to depend on your project plan and development lifecycle followed. If you are following Iterative cycle, then only test scenarios relevant to that Iteration is going to be added by you in the Test Lab module.
For example, I have 3 iteration for my project and only Login use case is going to deliver in Iteration 1, then I am going to execute only Login Test Scenarios in Iteration 1. It may be possible that not all the test scenarios of Login is fully functional, then you have to take only those Test Scenarios from Login which have been developed and needs to be tested. An illustration of the same is given below:
Suppose Test Scenarios Server down while login, Improper shut down in last successful login are not yet developed, then one is only going to add below mentioned test scenarios in the Test Lab
1. Your Project or Product Name
Login – (Test Set)
Valid Login
Invalid Login
Authentication and Authorization
I have not added the 2 scenarios in my Login test set as these are not yet developed. The decision for adding the Test Scenarios in the Test Set can be taken mutually with your Project Manager or Test Manager.
5. Additional Information
Last but not the least, Defect module consists all your defects either entered manually or created automatically based on failed test cases or scenarios.
Dashboard shows your Test Progress and help in managing your risk.
At any point of time you can find whether all your requirement have been covered, tested or not just by looking the Requirement module. This module shows the status of each use cases in terms of Covered, Not Covered, Passed or Failed.
6. Your Opinion
Any additional input to this paper is most welcome. Please feel free to write me at sachin.vasudha@gmail.com in case of any query
You can also download a copy of this article from http://sachin.vasudha.googlepages.com/HPQualityCenter-BestPractices.pdf

Testing With Agility

2008-05-05T05:50:00.000-07:00

I am expressing my views and learning on Agility for Testing. This article highlights the challenges and solution when one has to do the testing alongwith the development.
What approach for testing should be taken when “Time to market” is an important factor. The solution of course is to utilize testing time alongwith the development. But is it such an easy task for tester or developer or for management? Of course, not.
To successfully overcome such a situation requires commitment and support from the entire project stakeholder but more support, coordination and commitment are required among test team and development team.
The process that should be followed to overcome such a situation is mentioned below:
1. Define your Test Strategy
2. Define your team and assign responsibility
3. Do not wait for a formal process of release
4. Keep doing the testing as soon as build is ready for testing (Do not wait for formal release)
5. Always keep in mind that tester and developer are working as a team and your objective is to deliver a quality product on schedule.
6. Communicate the defects to developer and help him in understanding the defect.
7. Test each unit once developer finished the work
8. Make your seating arrangement near to developer
9. Communicate verbally as much as you can and do not always communicate formally
10. Always remember that you have a limited time for everything and if you start creating problem, then it is going to waste every one time in meeting and discussion.
11. Do the meeting and discussion only when you are trying to find a technical solution for defect or functionality.
12. If possible release the application to your customer for sneak peak. This is just to save the time and defect when you release the build formally. This also helps in raising the confidence of your customer in the product.
13. If there is dependency on 3rd party, then have a solution ready for doing the testing in case 3rd party is not able to provide the services on time. This can be one of your major risk and should be handled in your test strategy.
14. Keep your motivation high as many a times you feel low on energy due to agile nature of execution.
In my opinion, there is nothing new from execution prospective, it more related to coordination, communication and team work among the development team and test team.
In normal situation also you devote your time in writing test cases, then executing those test cases on formally release build. There is an idle time for tester when development is going on.
If you really want to deliver a quality product, then involve a functional tester while your development is going on and do not wait for the last moment when development get over and you are going to start the testing, this is a very traditional approach and may lead to poor quality for the product. This does not mean that you change the defined process, just make reshuffling in your process and utilize it for your organization maximum benefit.
I would like to share my experiences for a process (you must be known to this process) which is really going to help you in your work. Many of you know this basic process. I am here just adding the activities for a tester in each lifecycle` stage.
Requirement Gathering – Tester should be involved in requirement gathering or requirement analysis. Tester should start developing the test scenarios based on their requirement understanding and should share the same with the functional analyst for the feedback.
Design Development – Tester should participate in the design meeting and he/she should share their thought on the application design. Tester is testing various types of application and design team can make benefit of his/her experiences while designing the system. Tester should update their test scenarios after design review meeting if s/he required a need to do so.
Development – The tester should be assigned the role and responsibility for testing modules. Then it is the responsibility of tester to test the module in coordination with the developer while development is going on. This approach saves a lot of time and also many functional defects to get passed onto the next stage. You should make use of your test scenario document while testing the functionality.
Integration testing – This is one of the important aspects of development life cycle. This may include much complex system with which your product is going to interact. I am here not talking of the integration of the module within application boundary. I am talking of the things which are outside application boundary and which is important for interaction with our system. To successfully do integration testing when complex system interaction are involved, you better start early and make a concrete test strategy in terms of communication involved among the system. It is a good idea to make an Integration testing Plan separately and share it among your stakeholders for feedback and information.
If your system does not interact with complex system then you may or may not require an Integration Test Plan. You better decide for your integration approach.
Testing - Now once you moved into testing phase, you should realize that how less you now need to test. You just need to do the regression testing and you must do a re-verification of the defect you reported during development stage. Re-run your test scenarios and report and verify your defects to closure.
UAT - Your application is now ready for UAT. Go and formally make a release to your customer.
Note: If you development life cycle is Iterative or other model, you must follow the above process of testing particularly during development stage. Development is inevitable stage irrespective of methodology.
Please share your view points on the above topic.

Test Driven Development

2008-03-29T16:59:00.000-07:00

From programmers to users, everyone involved in software development agrees:
Testing is good. So why so many systems are so badly tested? There are several problems with the traditional approach to testing:
· If testing is not comprehensive enough, errors can make it into production and cause potentially devastating problems.
· Testing is often done after all the code is written, or at least after the programmer who wrote the code has moved on to other things. When you are no longer living and breathing a particular program, it takes some time and effort to back into the code enough to deal with the problems.
· Often tests are written by programmers other than those who wrote the code. Since they may not understand all of the details of the code, it is possible that they may miss important tests.
· If the test writers base their tests on documentation or other artifacts other than the code, any extent to which those artifacts are out of date will cause problems.
· If tests are not automated, they most likely will not be performed frequently, regularly, or in exactly the same way each time.
· Finally, it is quite possible with traditional approaches to fix a problem in a way that creates problems elsewhere. The existing test infrastructure may or may not find these new problems.

Test-Driven Development solves all of these problems and others.

· The programmer does the testing, working with tests while the code is freshly in mind. In fact, the code is based on the tests, which guarantees testability, helps ensure exhaustive test coverage, and keeps the code and tests in sync. All tests are automated. They are run quite frequently and identically each time.
· Exhaustive test coverage means that if a bug is introduced during debugging, the test scaffolding finds it immediately and pinpoints its location.
· And the test-debug cycle is kept quite short: there are no lengthy delays between the discovery of a bug and its repair.
· Finally, when the system is delivered, the exhaustive test scaffolding is delivered with it, making future changes and extensions to it easier.

So from a pure testing standpoint, before we begin to discuss non-testing benefits, TDD is superior to traditional testing approaches. You get more thoroughly tested code, period. But you do indeed get much more than that. You get simpler designs. You get systems that reveal intent (describe themselves) clearly. The tests themselves help describe the system. You get extremely low-defect systems that start out robust, are robust at the end, and stay robust all the time. At the end of every day, the latest build is robust. These are benefits for all project stakeholders. But perhaps the most immediate and most tangible benefit is exclusively the programmer’s: more fun. TDD gives you, the programmer, small, regular, frequent doses of positive feedback while you work. You have tangible evidence that you are making progress, and that your code works. There is a potential problem with all this, of course. It is more addictive than caffeine. Once you’re hooked, you’ll want to program this way, and only this way, from then on. And I for one certainly hope you do.

This article will give you an overview of Test-Driven Development, including a short example of a programming session.

WHAT IS TEST-DRIVEN DEVELOPMENT?

Test-Driven Development (TDD) is a style of development where:
· You maintain an exhaustive suite of Programmer Tests,
· No code goes into production unless it has associated tests,
· You write the tests first,
· The tests determine what code you need to write.

Let’s look at each of these in turn.

Maintain an exhaustive suite of Programmer Tests
You have Programmer Tests to test that your classes exhibit the proper behavior. Programmer Tests are written by the developer who writes the code being tested. They’re called Programmer Tests because although they are similar to unit tests, they are written for a different reason. Unit tests are written to test that the code you’ve written works. Programmer Tests are written to define what it means for the code to work. Finally, they’re called Programmer Tests to differentiate them from the tests that the Customer writes (called, logically enough, Customer Tests) to test that the system behaves as required form the point of view of a user.
Using Test-Driven Development implies, in theory, that you have an exhaustive test suite. This is because there is no code unless there is a test that requires it in order to pass. You write the test, then (and not until then) write the code that is tested by the test. There should be no code in the system which was not written in response to a test. Hence, the test suite is, by definition, exhaustive.

No code goes into production unless it has associated tests
One of eXtreme Programming’s tenets is that a feature does not exist until there is a suite of tests to go with it. The reason for this is that everything in the system has to be testable as part of the safety net that gives you confidence and courage. Confidence that all the code tests clean gives you the courage (not to mention the simple ability) to refactor and integrate. How can you possibly make changes to the code without some way to confidently tell whether you have broken the previous behavior? How can you integrate if you don’t have a suite of tests that will immediately (or at least in a short time) tell you if you have inadvertently broken some other part of the code?

Write the tests first
Now we’re getting eXtreme. What do I mean by write the tests first? I mean that when you have a task to do (i.e., some bit of functionality to implement) you write code that will test that the functionality works as required before you implement the functionality itself. Furthermore, you write a little bit of test, followed by just enough code to make that test pass, then a bit more test, and a bit more code, test, code, test, code, etc.

Tests determine what code you need to write
By writing only the code required to pass the latest test, you are putting a limit on the code you will write. You write only enough to pass the test, no more. That means that you do the simplest thing that could possibly work. I think an example is in order. Let’s say you are working on a list class. The logical place to start is with the behavior of an empty list (it makes sense to start with the basis, or simplest, case). So you write the test:

public void testEmptyList()
{
MovieList emptyList = new MovieList();
assertEquals("Empty list should have size of 0", 0, emptyList.size());
}

To pass this test we need a MovieList class that has a size() method. When you are working this way, you want to work in small increments some- times increments that seem ridiculously small. When you grasp the significance of this, you will be on your way to mastering TDD. Later we’ll explore the important and sometimes unexpected benefits and side effects of testing and coding in tiny increments.
LET THE COMPUTER TELL YOU
Write your tests (and your code for that matter) without worrying about what classes or methods you will need to add. Don’t even bother keeping a To Do list. Well, at least in terms of what classes, methods, etc., you need to create. You will likely want a To Do list to keep track of tests you want to write and other higher level items. Just write your test and compile. If you need to add a class or method the compiler will tell you. It provides a better To Do list than you could, and faster. In the previous example when I compile after writing the test (with nothing else written) I get the error: MovieList cannot be resolved or is not a type. This immediately tells me that I need to create a new MovieList class, so I do:

public class MovieList
{

}
I compile again and get another error:
The method size() is undefined for the type MovieList
In response to this I add a stub size() method:

public int size()
{
return 0;
}
Now it will compile. Run the test, and it works. Due to Java requiring a return statement when a return type is defined, we need to combine the steps of creating the method and adding the simplest return statement. I have made a Modern Java programming environments will alert me to these missing items even before I compile. Furthermore, they will offer solutions and do the work of creating the stubs for me.

A Quick Example

Habit of always stubbing methods to return the simplest value possible (i.e., 0, false, or null). What!?! Just return 0? That can’t be right. Ah...but it is right. It is the simplest thing that could possibly work to pass the test we just wrote. As we write more tests we will likely need to revisit the size() method, generalizing and refactoring, but for now return 0 is all that is required.

Let’s take a peek into the development of the project from later in the book. We have a Movie class which now needs to accept multiple ratings (e.g., 3 as in “3 stars out of 5”) and give access to the average. As we go through the example, we will be alluding to a metaphor for the TDD flow originated by William Wake: The TDD Traffic Light. We start by writing a test, and we start the test by making an assertion that we want to be true:

public void testRating()
{
assertEquals("Bad average rating.", 4, starWars.getAverageRating());
}
Now we need to set the stage for that assertion to be true. To do that we’ll add some rating to the Movie:
public void testRating()
{
starWars.addRating(3);
starWars.addRating(5);
assertEquals("Bad average rating.", 4, starWars.getAverageRating());
}
Finally, we need to create the Movie instance we are working with:
public void testRating()
{
Movie starWars = new Movie("Star Wars");
starWars.addRating(3);
starWars.addRating(5);
assertEquals("Bad average rating.", 4, starWars.getAverageRating());
}
When we compile this, the compiler complains that addRating(int) and getAverageRating() are undefined. This is our yellow light. Now we make it compile by adding the following code to Movie:

public void addRating(int newRating)
{
}
public int getAverageRating()
{
return 0;
}
Note that since we are using Java, we must provide a return value for getAverageRating() since we’ve said it returns an int. Now it compiles, but the test fails. This is the red light (aka red bar). This term is derived by the JUnit interfaces that present a progress bar that advances as tests are run. As long as all tests pass, the bar is green. As soon as a test fails, the bar turns red and remains red. The message we get is:
Bad average rating. expected:<4> but was:<0>
Now we have to make the test pass. We add code to getAverageRating() to make the test pass:
public int getAverageRating()
{
return 4;
}

Recompile and rerun the test. Green light! Now we refactor to remove the duplication and other smells that we introduced when we made the test pass. You’re probably thinking “Duplication.. what duplication?” It’s not always obvious at first. We’ll start by looking for constants that we used in making the test work. Sure enough, look at getAverageRating(). It returns a constant. Remember that we set the test up to get the desired result. How did we do that? In this case we gave the movie two ratings: 3 and 5. The average result is the 4 that we are returning. So, that 4 is duplicated. We provide the information required to compute it, as well as returning it as a constant. Returning a constant when we can compute its value is a form of duplication. Let’s get rid of it. Our first step is to rewrite that constant into something related to the provided information:

public int getAverageRating()
{
return (3 + 5) / 2;
}

Compile and run the tests. We’re OK. We have the courage to continue. The 3 and 5 are duplicate with the arguments to addRating() so let’s capture them. Since we add the constants we can simply accumulate the arguments. First we add a variable to accumulate them:
private int totalRating = 0;
Then we add some code to addRating():

public void addRating(int newRating)
{
totalRating += newRating;
}

Now we use it in getAverageRating():

public int getAverageRating()
{
return totalRating / 2;
}
Compile, test, it works! We’re not finished yet, though. While we were refactoring we introduced another constant: the 2 in getAverageRating(). The duplication here is a little subtler. The 2 is the number ratings we added, i.e., the number of times addRating() was called. We need to keep track of that in order to get rid of the 2. Like before, start by defining a place for it:

private int numberOfRatings = 0;

Compile, run the tests, green. Now, increment it every time addRating() is called:

public void addRating(int newRating)
{
totalRating += newRating;
numberOfRatings++;
}

Compile, run the tests, green. OK, finally we replace the constant 2 with numberOfRatings:

public int getAverageRating()
{
return totalRating / numberOfRatings;
}

Compile, run the tests, green. OK, we’re done. If we want to reinforce our confidence in what we did, we can add more calls to addRating() and check against the appropriate expected average. For example:
public void testLotsOfRatings()
{
Movie godzilla = new Movie("Godzilla");
godzilla.addRating(1);
godzilla.addRating(5);
godzilla.addRating(1);
godzilla.addRating(2);
assertEquals("Bad average rating.", 2, godzilla.getAverageRating());
}
I need to underline the fact that I recompiled and ran the tests after each little change above. This cannot be stressed enough. Running tests after each small change gives us confidence and reassurance. The result is that we have courage to continue, one little step at a time. If at any point a test failed we know exactly what change caused the failure: the last one. We back it out and rerun the tests.
The tests should pass again. Now we can try again with courage. The above example shows one school of thought when it comes to cleaning up code. In it we worked to get rid of the duplication that was embodied in the constant. Another school of thought would leave the constant 4 in place and write another test that added different ratings, and a different number of them.
This second test would be designed to require a different returned average. This would force us to refactor and generalize in order to get the test to pass. Which approach should you take? It really depends on how comfortable you are with what you are attempting. Remember that you do have the test to safeguard you. As long as the test runs, you know that you haven’t broken anything. In either case you will want to write that second test: either to drive the generalization, or to verify it.

SUMMARY
We’ve explored what Test-Driven Development is:
· An exhaustive suite of Programmer Tests
· No code without tests,
· Tests first,
· Tests determine the code.
We’ve seen how to leverage feedback from the computer to keep track of what we should do next: if we need to create a class, method, variable, etc., the system will let us know. We’ve even seen a quick example of TDD in action, step by step, building some code to maintain the average rating of a movie. However, before we can jump in and start practicing it in earnest, we need to make sure we have a few basic techniques and skills that TDD builds on.

Agile Modeling and TDDA primary benefit of both modeling and TDD is that they promote a think before you act approach to development. Just because they offer the same type of benefit doesn’t mean that they are incompatible with one another. Instead, experience shows that we can and should model on a project taking a TDD approach. Consider XP projects that clearly take a TDD approach. Modeling is definitely an important part of XP. XP practitioners work with user stories, and user stories are clearly agile models. XP practitioners also create CRC cards whenever they need to, also agile models. In eXtreme Programming Explained, Kent Beck even includes sketches of class diagrams. Heresy? No. Just common sense. If creating a model can help our software development efforts then that’s what we do. It’s as simple as that. Creating agile models can help our TDD efforts because they can reveal the need for some tests. As an agile modeler sketches a diagram they will always be thinking, “How can I test this?” in the back of their minds because they will be following the practice consider testability. This will lead to new test cases. Furthermore, we are likely to find that some of our project stakeholders or even other developers simply don’t think in terms of tests; instead, they are visual thinkers. There’s nothing wrong with this as long as we recognize it as an issue and act accordingly—use visual modeling techniques with visual thinkers and test-driven techniques with people that have a testing mindset. TDD can also improve our agile modeling efforts. Following a test-first approach, agile developers quickly discover whether their ideas actually work or not—the tests will either validate their models or not—providing rapid feedback regarding the ideas captured within the models. This fits in perfectly with AM’s practice of Prove it With Code. Agile Modeling (AM) and Test-Driven Development (TDD) go hand in hand. The most effective developers have a wide range of techniques in their intellectual toolboxes, and AM and TDD should be among those techniques.

Testing is finding a solution rather than a problem

2008-03-08T15:46:00.000-08:00

What are the major challenges that you come across in your day to day work because of managerial decision and sometime you really feel frustrated because of them and it effect your productivity?
I hope you came across with such a situation quite often when you are asked to focus on things decided by management.
I am taking a typical example, you are doing a testing of a product and you are very much motivated about your work. Suddenly something happen and you are asked to do some other thing. How do you feel at that point? Stressed, Frustrated, de-motivated…
Well let’s discuss about how you can counter such a situation which may have negative impact on your productivity and thus your quality work.
Some of the key points that should always be on mind of a Quality Person to keep him/her motivated all the time is mentioned below. I have learnt all these from my experience.

Be flexible in your work

Do not create problems and always come up with some solution

If you are asked to do some other activity, put your points why the work you are doing is more important. You are best judge to decide.

Support your peers and seniors in making a smooth delivery. There is always pressure on managers. If you create problem, then project delivery will go nowhere.

Quality person should work with “providing solution” mindset when they are reporting any problem.

“Quality is polishing a dirty mirror and not making it dirtier by reporting problems instead of its solutions.”
There are always challenges and fighting and then overcoming with challenges is what a quality person always did. This is my personal opinion.
I always face many challenges in my work life. These challenges are less related to your core product but rather related to the stakeholders, your internal customer, external customer, and your team. Don’t you agree? Just try to think on these aspects for a second and then analyze what I am saying is correct or incorrect.
How many times your manager calls you for a meeting? How much time actually you spent on your work? How much time daily, weekly, monthly and yearly you spent on just doing meeting? If you are going to analyze these statistics, then you will be really amazed.
I would like to invite other people too to share their opinions and of course the challenges that they are facing in their day-to-day work.

Risk Based Testing

2008-02-23T18:47:00.000-08:00

Introduction
Risk based testing is a concept which define the roadmap for making test strategy and taking decision on release of product. This concept outlines many of the important aspect of testing when time to market and quality has to be met. How many of times you have tested your product in limited time? I hope you have done it many a times? What approach you normally take when your testing schedule has been reduced and you are asked to test the application in limited schedule? Do you follow any defined approach to overcome such a scenario? I hope many of us “not”. We know all these concepts but making use of it is really difficult as we do not know how to approach with this concept.
Purpose
The purpose of this article is to present a practical approach to Risk based testing based on my experience. It may be applicable or may not be applicable for your day to day activity.
References
• CSTE Group
• Project Experience - myself
Input
Testing schedule and effort has been reduced.
Process
Entry Criteria
Test Cases & Scenarios are ready
Identification of Important Test Scenario or Cases
The first step is to identify the important test scenario or cases based on below mentioned parameters:
• Capability
• Reliability
• Usability
• Performance
• Installability
• Compatibility
• Supportability
• Testability
• Maintainability
• Portability
• Localizability
Mechanics for Identification and Prioritization of Test Scenarios
To identify and prioritize the test scenarios, you need to prepare a Test Factor matrix and assign test scenarios, weightage based on the importance of above parameters. To carry out this you need to do brainstorming session with your team members.
It is not necessary that you are going to provide score for all the test cases for all the factors. Some of your test cases do not suffice the above factors. In that case you need not to give scoring. This help in focusing only on important cases.
The Test Factor matrix gives you an analysis based on important quality factors that are required to be fulfilled in the product. It helps in identifying your test scenarios which must be executed before the delivery of the product.
The customer input may be required for prioritizing the test scenario based on your analysis.
From Test Factor matrix , you can analyze that “Performance is not a major concern area”, the major concern area are “Usability”, “Reliability”, “Capability”.
Now start with Usability Test Scenarios – execute the cases based on maximum weightage to minimum weightage. Follow the same rule for other factors.
Output
• Test Factor matrix
• Test Priority List
Note: Your feedback is most welcome. Please leave your comments.

ABC of Unit Testing

2008-01-23T07:31:00.000-08:00

What is Unit Testing?
After writing any code, every programmer will do some kind of testing to make sure the code works as expected. This testing is called 'unit testing'.
Unit testing is done in different ways. Some programmers write simple test applications to test their own code. Some others simply debug the code and change the values during debugging to make sure the code works fine for different cases.
Some facts about unit testing:

Unit testing is done by developers.
Quality department does different tests, they are not unit tests.
Every programmer must do unit testing after finishing development or during development itself.
Unit testing can be done by writing separate test applications to call your classes and methods to make sure the classes work as expected. This is called manual unit testing.
Unit testing can be automated by writing unit test scripts. This is called Automated Unit Testing.
In automated Unit Testing, after writing each class/method, you will write several Test methods to test the actual code. The test method will call your actual class/method with some sample inputs and compare the result with expected result. If the actual result from your code is same as the expected result, the Unit Test will record the result as "Success". Otherwise the test result will be recorded as "Fail". All of the unit test scripts can be executed together and you can get a summary of all results.
Automated Unit test scripts can be saved and easily repeated so that everytime someone make a change in the project, hundreds of automated unit tests can be executed in few seconds to make sure that every piece of code is still working as expected.
NUnit is one of the most popular automated unit testing tool for .NET applications.
Automated unit tests can be done without using any unit testing tool like NUnit. However, unit test frameworks like NUnit make the job very easy.

Manual Unit Testing

Assume you are writing a class to calculate the Factorial of a number. You may write a class called 'Calculator' with a method called 'Factorial()' taking one input parameter and returning the Factorial of the input.

public class Calculator

{

public int Factorial(int a)

{

int factorial = 1;

while ( a > 0 )

{

factorial *= a; --a;

}

return factorial;

}

After you write the above class and method, you are done with your job. But before you deliver your code to your team leader, you must test the code to make sure this code works fine as expected for different cases.

Most of the programmers test the code by writing a small test application. You may create a new windows forms project and add some labels, a textbox and buttons etc to the form. In the above case, you need one textbox to input the number to find the Factorial. Also, you need a 'Calculate' button. When user inputs a value to the textbox and press the button, you will call the method and pass the user input value to the method. Then you will display the result as a messagebox. By seeing the result you will manually verify it to make sure that the code worked as expected.The above process is called 'Manual Unit Testing'.

Limitation of Manual Unit Testing

Some of the issues of manual unit testing are:

You will write test applications and throw away after doing your testing. After few weeks you may make some modifications to your code and at that time you may not find your old test application. So, you will have to write another test application.
Large projects will have hundreds of classes and several class libraries. It is very difficult to write separate test applications for each of the classes in the project and save all of them for repeated testing in future.
Test applications require a human person to test. You may test several possibilities on the first time, but you may not remember all of the test cases when you repeat the test in future.
When you do manual test, you are manually verifying the result. Even if the result is wrong, you may not realize it and think that the test was success.
It is not practical to repeat all tests manually before you make a product release everytime. It will take several hours or days to complete manual unit testing of every piece of code.

Automated unit testing solves all of the above problems

What is Automated Unit Testing?

Automated unit testing is the process of testing software using test scripts. A unit test is a piece of code that executes another piece of code and compare the actual result with expected result. In above example, you saw how to write a small class to calculate the Factorial of a number. Now let us try to write a small test script to test the Factorial() method. A simple test script will look like this:

public void TestFactorialMethod()

{

// Instantiate the calculator class.

Calculator calc = new Calculator();

// Call the Factorial method to calculate the factorial of 5.

int result = calc.Factorial(5);

// We know that the factorial of 5 is 120. The job of the test method is to compare the result from the factorial method with the expected value and make sure it is same as the expected value

if ( result != 120 )

{

MessageBox.Show("Expected value is 120, but actual value is '" + result + "'.");

}

The above method calls the Factorial method and compares the result. If the result is same as the expected result, then you know that the test is success. This indicates your Factorial method is working as expected.In the above case, the test script calls the Factorial method with one input (5). In real development environment, you have to write several test scripts to test each method, with various input values and make sure the result is correct.The above test script is not perfect. It displays a messagebox when the test fails. This requires someone has to manually look for the messageboxes.

Automated Unit Test Frameworks like NUnit solves this problem.

What is Nunit?

NUnit is an automated unit testing framework for .Net applications.
NETNUnit is free to use with your .NET projects.
NUnit is ported from another product called JUnit, which is a unit testing framework for Java applications.
NUnit provides a class library which includes some classes and methods to help you write test scripts.
NUnit provides graphical user interface application to execute all the test scripts and show the result as a success/failure report (instead of message boxes from the test script).
NUnit is the most popular unit testing framework for .net applications.
NUnit does not create any test scripts by itself. You have to write test scripts by yourself, but NUnit allows you to use it's tools and classes to make the unit testing easier.
NUnit is an open source product. You can get this tool along with source code and modify the source code if required for your specific needs. However, 99% of the programmers do not mess with the source code. Instead, you can download only the executable and class library and implement unit test scripts for your application.
Now Microsoft offers a team collaboration system called 'Visual Studio Team System' (VSTS). This tool includes a unit testing framework also. So, eventually most of the developers may switch to VSTS instead of NUnit. However, NUnit will continue to exist because it is free and easy to use.

History - Software Testing

2008-01-22T19:59:00.000-08:00

Do you know who distinguish testing from debugging? The separation of debugging from testing was initially introduced by Glenford J. Myers in 1979. Although his attention was on breakage testing ,it illustrated the desire of the software engineering community to separate fundamental development activities, such as debugging, from that of verification. Dr. Dave Gelperin and Dr. William C. Hetzel classified in 1988 the phases and goals in software testing in the following stages:

Until 1956 - Debugging oriented
1957-1978 - Demonstration oriented
1983-1987 - Destruction oriented
1983-1987 - Evaluation oriented
1988-onward- Prevention oriented

References:

Myers, Glenford J. (1979). The Art of Software Testing. John Wiley and Sons. ISBN 0-471-04328-1.
Gelperin, D.; B. Hetzel (1988). "The Growth of Software Testing". CACM 31 (6). ISSN 0001-0782.
until 1956 it was the debugging oriented period, when testing was often associated to debugging: there was no clear difference between testing and debugging. Gelperin, D.; B. Hetzel (1988). "The Growth of Software Testing". CACM 31 (6). ISSN 0001-0782.
From 1957-1978 there was the demonstration oriented period where debugging and testing was distinguished now - in this period it was shown, that software satisfies the requirements. Gelperin, D.; B. Hetzel (1988). "The Growth of Software Testing". CACM 31 (6). ISSN 0001-0782.
The time between 1979-1982 is announced as the destruction oriented period, where the goal was to find errors. Gelperin, D.; B. Hetzel (1988). "The Growth of Software Testing". CACM 31 (6). ISSN 0001-0782.
1983-1987 is classified as the evaluation oriented period: intention here is that during the software lifecycle a product evaluation is provided and measuring quality. Gelperin, D.; B. Hetzel (1988). "The Growth of Software Testing". CACM 31 (6). ISSN 0001-0782.
From 1988 on it was seen as prevention oriented period where tests were to demonstrate that software satisfies its specification, to detect faults and to prevent faults. Gelperin, D.; B. Hetzel (1988). "The Growth of Software Testing". CACM 31 (6). ISSN 0001-0782.

What is Software Testing?

2008-01-21T20:32:00.000-08:00

Software testing is any activity aimed at evaluating an attribute or capability of a program or system and determining that it meets its required results. [Hetzel88] Although crucial to software quality and widely deployed by programmers and testers, software testing still remains an art, due to limited understanding of the principles of software. The difficulty in software testing stems from the complexity of software: we can not completely test a program with moderate complexity. Testing is more than just debugging. The purpose of testing can be quality assurance, verification and validation, or reliability estimation. Testing can be used as a generic metric as well. Correctness testing and reliability testing are two major areas of testing. Software testing is a trade-off between budget, time and quality.

Software Testing is the process of executing a program or system with the intent of finding errors. [Myers79] Or, it involves any activity aimed at evaluating an attribute or capability of a program or system and determining that it meets its required results. [Hetzel88] Software is not unlike other physical processes where inputs are received and outputs are produced. Where software differs is in the manner in which it fails. Most physical systems fail in a fixed (and reasonably small) set of ways. By contrast, software can fail in many bizarre ways. Detecting all of the different failure modes for software is generally infeasible. [Rstcorp]
Unlike most physical systems, most of the defects in software are design errors, not manufacturing defects. Software does not suffer from corrosion, wear-and-tear -- generally it will not change until upgrades, or until obsolescence. So once the software is shipped, the design defects -- or bugs -- will be buried in and remain latent until activation.
Software bugs will almost always exist in any software module with moderate size: not because programmers are careless or irresponsible, but because the complexity of software is generally intractable -- and humans have only limited ability to manage complexity. It is also true that for any complex systems, design defects can never be completely ruled out.
Discovering the design defects in software, is equally difficult, for the same reason of complexity. Because software and any digital systems are not continuous, testing boundary values are not sufficient to guarantee correctness. All the possible values need to be tested and verified, but complete testing is infeasible. Exhaustively testing a simple program to add only two integer inputs of 32-bits (yielding 2^64 distinct test cases) would take hundreds of years, even if tests were performed at a rate of thousands per second. Obviously, for a realistic software module, the complexity can be far beyond the example mentioned here. If inputs from the real world are involved, the problem will get worse, because timing and unpredictable environmental effects and human interactions are all possible input parameters under consideration.
A further complication has to do with the dynamic nature of programs. If a failure occurs during preliminary testing and the code is changed, the software may now work for a test case that it didn't work for previously. But its behavior on pre-error test cases that it passed before can no longer be guaranteed. To account for this possibility, testing should be restarted. The expense of doing this is often prohibitive. [Rstcorp]
An interesting analogy parallels the difficulty in software testing with the pesticide, known as the Pesticide Paradox [Beizer90]: Every method you use to prevent or find bugs leaves a residue of subtler bugs against which those methods are ineffectual. But this alone will not guarantee to make the software better, because the Complexity Barrier [Beizer90] principle states: Software complexity(and therefore that of bugs) grows to the limits of our ability to manage that complexity. By eliminating the (previous) easy bugs you allowed another escalation of features and complexity, but his time you have subtler bugs to face, just to retain the reliability you had before. Society seems to be unwilling to limit complexity because we all want that extra bell, whistle, and feature interaction. Thus, our users always push us to the complexity barrier and how close we can approach that barrier is largely determined by the strength of the techniques we can wield against ever more complex and subtle bugs. [Beizer90]

Why to do Software Testing?

2008-01-20T08:38:00.000-08:00

Regardless of the limitations, testing is an integral part in software development. It is broadly deployed in every phase in the software development cycle. Typically, more than 50% percent of the development time is spent in testing. Testing is usually performed for the following purposes:

To improve quality.

As computers and software are used in critical applications, the outcome of a bug can be severe. Bugs can cause huge losses. Bugs in critical systems have caused airplane crashes, allowed space shuttle missions to go awry, halted trading on the stock market, and worse. Bugs can kill. Bugs can cause disasters. The so-called year 2000 (Y2K) bug has given birth to a cottage industry of consultants and programming tools dedicated to making sure the modern world doesn't come to a screeching halt on the first day of the next century. [Bugs] In a computerized embedded world, the quality and reliability of software is a matter of life and death.
Quality means the conformance to the specified design requirement. Being correct, the minimum requirement of quality, means performing as required under specified circumstances. Debugging, a narrow view of software testing, is performed heavily to find out design defects by the programmer. The imperfection of human nature makes it almost impossible to make a moderately complex program correct the first time. Finding the problems and get them fixed [Kaner93], is the purpose of debugging in programming phase.

For Verification & Validation (V&V)

Just as topic Verification and Validation indicated, another important purpose of testing is verification and validation (V&V). Testing can serve as metrics. It is heavily used as a tool in the V&V process. Testers can make claims based on interpretations of the testing results, which either the product works under certain situations, or it does not work. We can also compare the quality among different products under the same specification, based on results from the same test.
We can not test quality directly, but we can test related factors to make quality visible. Quality has three sets of factors -- functionality, engineering, and adaptability. These three sets of factors can be thought of as dimensions in the software quality space. Each dimension may be broken down into its component factors and considerations at successively lower levels of detail. Some of the most frequently cited quality considerations are:(Typical Software Quality Factors [Hetzel88] )

Functionality (exterior quality) -

Correctness
Reliability
Usability
Integrity

Engineering (interior quality)

Efficiency
Testability
Documentation
Structure

Adaptability (future quality)

Flexibility
Reusability
Maintainability

Good testing provides measures for all relevant factors. The importance of any particular factor varies from application to application. Any system where human lives are at stake must place extreme emphasis on reliability and integrity. In the typical business system usability and maintainability are the key factors, while for a one-time scientific program neither may be significant. Our testing, to be fully effective, must be geared to measuring each relevant factor and thus forcing quality to become tangible and visible. [Hetzel88]
Tests with the purpose of validating the product works are named clean tests, or positive tests. The drawbacks are that it can only validate that the software works for the specified test cases. A finite number of tests can not validate that the software works for all situations. On the contrary, only one failed test is sufficient enough to show that the software does not work. Dirty tests, or negative tests, refers to the tests aiming at breaking the software, or showing that it does not work. A piece of software must have sufficient exception handling capabilities to survive a significant level of dirty tests.
A testable design is a design that can be easily validated, falsified and maintained. Because testing is a rigorous effort and requires significant time and cost, design for testability is also an important design rule for software development.
For reliability estimation [Kaner93] [Lyu95]
Software reliability has important relations with many aspects of software, including the structure, and the amount of testing it has been subjected to. Based on an operational profile (an estimate of the relative frequency of use of various inputs to the program [Lyu95]), testing can serve as a statistical sampling method to gain failure data for reliability estimation.
Software testing is not mature. It still remains an art, because we still cannot make it a science. We are still using the same testing techniques invented 20-30 years ago, some of which are crafted methods or heuristics rather than good engineering methods. Software testing can be costly, but not testing software is even more expensive, especially in places that human lives are at stake. Solving the software-testing problem is no easier than solving the Turing halting problem. We can never be sure that a piece of software is correct. We can never be sure that the specifications are correct. No verification system can verify every correct program. We can never be certain that a verification system is correct either.