How Apache JMeter simulates multiple users?

1. Introduction to different elements of a JMeter Test Plan.
2. Difference between real world and JMeter world while doing a web request.
3. Workflow of a typical web server request and response.
4. JMeter's role in a web testing work flow.

Let us take a view at how a request for web page is sent to the Web server from a User's browser, and how a web page is finally displayed.  Understanding this workflow will give us opportunity to imagine how JMeter fits in this workflow and how it can do same thing as a browser does.

Now introducing Apache JMeter into the picture.  The actions taken by the User are no longer required.  The User action trigger some HTTP requests which are recorded in a JMeter HTTP Request Sampler for multiple uses.  

See how JMetr replaces a browser, but how the working is a little different.

So what makes one User transaction in terms of JMeter?  

When we add a HTTP Request Sampler in JMeter Test plan it stores one Web Page calling and receiving sequence.  We can call this as a single user transaction.  As soon as we tell this to JMeter it is capable of doing the same thing any number of times.  It also does this multiple times simultaneously.

As JMeter is not exactly a browser the HTTP Request Sampler makes all the received data available for further analysis.  We use View Tree Listener for actually visualizing the received response.  View Tree Listener is a good way to know what request was sent, what was the response and the result of the transaction.

When JMeter simulates multiple users by making the same call multiple times, in different operating system threads (we can say execution paths) that time more analytical data is available.  The Summary Report Listener can show us the additional calculated data line Minimum time and Maximum time taken to receive the response.  It also calculates the average time taken using all the results together.

So we have seen that for web site testing we need many items like

1. HTTP Request Sampler
2. View Tree Listener
3. Summary Report Listener

To use these items provided by JMeter we will also need items like

1. Test Plan and
2. Thread Group

For some advanced user transactions and logical conditions there are Controllers.  Once we learn how to combine these elements we are ready to write our first Test Plan in JMeter.

Yes initially this may seem like a lot of jargon.  Eventually we will get used to these elements and then testing will be a piece of cake.  Ok, let us re-visit what they all mean in JMeter world.

We will write our first Test Plan step by step in the next article but let us first get introduced formally with the different elements we have seen till now.

Now we know some elements which will be used in creation of a Test Plan in JMeter.  It will be worthwhile checking the difference between real world transactions and the transactions that happen in JMeter world.  Is there one to one mapping between actions performed in real world and while executing a JMeter test plan?

Thats all for this article.  Thanks for reading

PerfTest of Webpage using Jmeter

Performance  Testing of web page with Apache JMeter

Topics covered in this article:

1. Step by step method to test single web page in Apache JMeter
2. Manually creating a test plan in Apache JMeter
3. Simulating 50 users through Apache JMeter test plan

Let us see what we want to achieve first.  We want to create a Test Plan in Apache JMeter so that we can test performance of one web page say page shown by the URL: http://www.google.com/.  We will need many elements in the JMeter Test plan let us see what are they:

So this is what we shall see when we are done with creating the Test Plan.  We have to start with a blank JMeter window

Before adding anything more to this window let us change the name of Test Plan.  We can type a new name for the node in the Name text box.  In this version of JMeter the name does not get reflected immediately when you type it in the text box.  You have to change focus to workbench node and back to Test Plan node to see the name getting reflected.

Let us give new name "First Test" to the Test Plan node.

Now we will add our first element in the window.  We will add one Thread Group, which is placeholder for all other elements like Samplers, Controllers, Listeners.  We need one so we can configure number of users to simulate.  The Thread Group represents one set of actions performed by User.

In JMeter all the node elements are added by using the context menu.  You have to right click the element where you want to add a child element node.  Then choose the appropriate option to add.

We will click the Thread Group option and it will get added under the Test Plan (First test) node.

Like we changed the name of Test Plan let us also change the name of Thread Group.  For us this is the element which represents multiple users.  So let us name it "Users".  For us this element means Users visiting the Google Home Page.

Now we have to add one Sampler in our Thread Group (Users).  As done earlier for adding Thread group, this time we will open the context menu of the Thread Group (Users) node by right clicking and we will add HTTP Request Sampler by choosing Add > Sampler > HTTP request option.

This will add one empty HTTP Request Sampler under the Thread Group (Users) node.

 We will need most configuration in this node element, HTTP Request Sampler.  The settings we have to configure are:

1. Name: we will change the name to reflect the action what we want to achieve
1. This will will name "Visit Google Home Page"
2. Server Name or IP: here we have to type the web server name
1. In out case it is www.google.com
2. Note http:// part is not written this is only the name of the server or its IP
3. Protocol: we will keep this blank
1. That will mean we want HTTP as the protocol
4. Path: we will type path as / (slash)
1. This means we want the root page of the server
2. This also means now the server will decide what page will be sent to us and it is the default page of the web site

After add the HTTP Request Sampler we will need one Listener.  Let us add View Results Tree Listener under the Thread Group (User) node.  This will ensure that the results of the Sampler will be available to view in this Listener node element.

Adding a listener is also same like adding a new node under Thread Group.  Open the context menu and choose Add > Listener > View Results Tree option to add the listener.

With this much of setup we are now ready to run our first test.  Coming back to the configuration of the Thread Group (Users) we have kept it all default values.  This means JMeter will execute the sampler only once.  It will be like a single user and only one time.

This is similar to like a user visiting a web page through browser, only here we are doing that through JMeter sampler.  We will execute the test plan using Run > Start option.

Apache JMeter asks us to save the test plan in a disk file before actually starting the test.  This is important if we want to run the test plan again and again.  If we say not to save by clicking No option it will run without saving.  Let us save it first so we can reuse it again.

We have kept the setting of the thread group as single thread (that means one user only) and loop for 1 time (that means run only one time), hence we will get result of one single transaction in the View Result Tree Listener.

This means JMeter was successful in fetching the web page at the given URL just like a browser.  It has stored all the headers and the response sent by the web server and ready to show us the result in many ways.

Let us take a closer look at the three tabs available in the View Result Tree Listener view.

The first tab is Sampler Results.  It shows JMeter data as well as data returned by the web server.  Usually browsers hide this data from us as it is not related to showing the web page.  This data is utilized internally by the browser, for example when there is a Response Code: 404 then the browser shows a page not found error page, and when the Response Code is 200 the browser shows the received web page HTML.

The second tab is Request, where all the data which was sent to the web server as part of the request is shown.

The last tab is Response data.  In this tab the listener shows the data received from server as it is in text format.  It also have facility to show the data in XML, HTML formats but that will be just the data in other way (no JavaScript will be executed).  This may look different that the page actually seen in the browser.

We can select different ways of viewing this response data like as below:

This was just one request but JMeter's real strength is in sending the same request like many users are sending it.  To test the web servers with multiple users we will have to change the Thread Group (Users) settings.

We will set 50 users and these requests will be sent with some delay of (10/50) seconds as we have set the ramp up time to 10.

To visualize the results, a better aggregating listener will be required so we will add Summary Report Listener in the Thread Group node.  Adding Summary Report Listener is similar to adding a View Results Tree Listener.  Just right click on the Thread group node and choose Add > Listener > Summary Report.

We will run the test plan again after adding the Summary Report Listener ans when the test is done we will see the following results.  Your results may be different than mine due to different environments but mostly similar.

This is how we tried testing one single page with JMeter.  The summary report shows values about the measurement JMeter has done while calling the same page as if many users are calling the page.  Let us look at some of the value headings and what they mean:

• Samples: A sample mean one sampler call.  One request to web page in our case.  So the value of 51 means total 51 web page requests to the page http://www.google.com were made by JMeter 
• Average: This value is the average time taken to receive the web pages.  In our case there were 51  values of receiving time which were added and divided by 51 and this value is arrived by JMeter.  This value is a measure of performance of this web page.  This means on an average 334 milliseconds time is required to receive this web page for our network conditions.
• Min and Max: These are the minimum and maximum value of time required for receiving the web page.
• Std. Dev:  This shows how many exceptional cases were found which were deviating from the average value of the receiving time.   The lesser this value more consistent the time pattern is assumed.
• Error %: This value indicated the percentage of error.  In our case 51 calls were made and all are received successfully this means 0 error.  If there are any calls not received properly they are counted as errors and the percentage of error occurrence against the actual calls made is displayed in this value.

Performance Testing metrics explained

To understand the load test results better, Hope they will help interpret results better:

What is “Response Time”?

Response Time measures the performance of an individual transaction or query and is the amount of time from the moment that a user sends a request until the time that the application indicates that the request has completed.

What is the “90% Line”?

90% Line (90 percentile of the response times)represents one of the most interesting metrics and shows that “90% of the samples finished within 0-x time” or “90% of the samples took no more than this time”

What is the “Average Response Time”?

The “Average Response Time” is a good number to know, however in a business-to-business service application, it doesn’t matter if the average response time is 500ms, if the 90% line is 1.5 seconds. From a software developer perspective, if the 50% and 90% lines are far appart, the application fluctuates a lot.

What is “Latency”?

Latency , a synonym for delay, is the time for a specific block of data to get from one point to another. Latency is measured by sending a packet that is returned to the sender and the round-trip time is considered the latency.
Latency + Processing Time = Response Time

What is “Throughput”?

Throughput indicates the number of transactions per second an application can handle, the amount of transactions produced over time during a test.

Transactions per second

Transactions per second refer to the number of database transactions completed in one second.

Selenium WebDriver Architecture

In this article let’s see the Architecture of Selenium WebDriver.

Selenium WebDriver:

Selenium-WebDriver makes direct calls to the browser using each browser’s native support for automation.
Before starting the automation using any automation tool, it is very important to know how that tool works and how it is architecture. This will helps to take the good advantage of the tool at the same time it will helps to make right automation framework.
In my further posts I will start explain how to use selenium and how to create selenium framework in details but before that let’s get an overview of Selenium webdriver architecture. Selenium can be a little bit confusing. As a beginner you will find how simply you can record and play the selenium scripts but it is not straight forward to how it’s doing that. At first glance it might appear that Selenium is actually driving the browser directly from your code but there’s actually a little bit more going on here and it’s going to help us understand how we can remote execute our test by looking at this basic architecture. So here’s a picture of the architecture for Selenium WebDriver which is the current version of Selenium which I going to explain here.

Selenium webdriver architecture mainly divided into three parts

1. Language level bindings
2. Selenium Webdriver API
3. Drivers

1) Language Level Bindings :
You can see at the Left hand side here we’ve got some bindings and these are language level bindings and with which you can implement the Selenium webdriver code. In simple words these the languages in which are making an framework, will interact with the Selenium Webdriver and work on various browsers and other devices. So we have a common API that we use for Selenium that has a common set of commands and we have various bindings for the different languages. So you can see there’s Java, Java, Python, Ruby, there’s also some other bindings and new bindings can be added very easily.
2) Selenium Webdriver API:
Now these bindings communicate with Selenium Webdriver API and and This API send the commands taken from language level bindings interpret it and sent it to Respective driver. Right now don’t worry about how it works. I will explain them in upcoming posts. In basic term it contains set of common library which allow to send command to respective drivers.
3) Drivers:
Drivers here at the right hand side, you see we have various internet browser specific drivers such as IE driver, a Firefox, Chrome, and other drivers such as HTML unit which is an interesting one. It works in headless mode which make text execution faster. It also contains mobile specific drivers as well. But the basic idea here is that each one of these drivers knows how to drive the browser that it corresponds to. So the Chrome driver knows how to handle the low level details of Chome browser and drive it to do things like clicking button, going into pages, getting data from the browser itself, the same thing for Firefox, IE, and so on.


How all blocks work together?
So what’s happening here is you’re going to write your test in let’s say in Java and you’re going to be using common Selenium API and that Java binding is going to be sending command across this common WebDriver API. Now on the other end is going to be listening a driver, It’s going to interpret those commands and it’s going to execute them on the actual browser and then it’s going to return the result backup using the WebDriver API to your code where you can look at that result.


Let’s take more closure look that how exactly that works
Let say you have written test using java (binding code) against Selenium API and that binding code is going to issue commands across WebDriver wire protocol this is a rest-based web service that is able to interpret those commands. The driver server is just a little executable that runs each one of the drivers has this driver server that basically listens on a port on your local machine when you run your tests and it’s waiting for these commands to come in. And when these commands come in it interprets those commands and then automates the browser and then returns those results back.
I hope this will give some clear idea about how Selenium Webriver being architect.

CSS Selectors for Selenium Automation testers 

Using Selenium WebDriver whenever we want to automate a particular task we have to identify the UI Elements. Selenium WebDriver is providing built-in locators like By ID, Class Name, CSS Selectors, XPATH Selectors … In this article I am going to explain about the CSS Selectors.
First of all what is CSS?
Cascading Style Sheets is a language used to specify the visual appearance of a webpage. The main difference between HTML & CSS is, HTML is a mark-up language structure of a document for web distribution, where as CSS tells the browser how to it should look? (Like font style, back ground colour …). CSS can accomplish this by using CSS pattern matching rules, properties & values.
Syntax:
CSS pattern matching rules {Property: Value ;}
Example:
h1 {color: green;}
In the above example will make all the h1 tags to look in green colour.
In CSS, pattern-matching rules determine which style should be applied to elements in the DOM. These patterns, called CSS Selectors. If all conditions in the pattern are true for a certain element, the selector matches the element and the browser applies the defined style (Style is defined by properties & values) in CSS syntax.
Selenium WebDriver uses same principles of CSS selectors to locate elements in DOM. Selenium WebDriver’s By class provides the cssSelector () method for locating elements using CSS selectors. Let’s explore few of the CSS Selectors.
For examples purpose I am using the following HTML File

Default

<form name="loginForm"> <h1> Login Form</h1> <label title="username"> UserName:</label> <input type="text" id="input1"/> <label title="password">Password:</label> <input type="password" class="password" id="input2" /> <input type="password" class="password" id="input3" /> <input name="login" type="submit" value="Login" id="button1" /> </form>

1 2 3 4 5 6 7 8 9

<form name="loginForm"> <h1>Login Form</h1> <label title="username"> UserName:</label> <input type="text" id="input1"/> <label title="password">Password:</label> <input type="password" class="password" id="input2" /> <input type="password" class="password" id="input3" /> <input name="login" type="submit" value="Login" id="button1" /> </form>

Element Selectors:
In the style sheet, Element selectors are written using by the tag name. Element selectors also referred to as “type” selectors, select by matching elements (HTML tag name). The following line of code will identify the elements whose tag names matches to “input”.
IWebElement Element = Driver.FindElement(By.CssSelector("input"));
Class Selectors
In the style sheet, class selectors are written using the dot (“.”) preceding a custom name. Class selectors are extremely useful selectors that allow to add a class attribute to a given element in the mark-up, with a custom value. Then using that value preceded by a dot, write a corresponding rule using the class name.
The following line of code will identify the elements whose class name matches to “username”.
IWebElement Element = Driver.FindElement(By.CssSelector(".username"));
 ID Selectors:
In the style sheet, ID selectors are written using the hash “#”preceding a custom name. Since ID name can be used exactly one time in a DOM, ID’s are particularly useful in CSS layout when identifying significant portions of the document as they are unique.
The following line of code will identify the elements whose ID matches to “input1”.

IWebElement Element = Driver.FindElement(By.CssSelector("#input1"));
Attribute Selectors:
Apart from the class and id attributes, CSS selectors also enable the location of elements using other attributes of the element. In the following example, the Name attribute is used to locate an element whose tag name is “input” and having an attribute “name” of value “username”.
IWebElement Element = Driver.FindElement(By.CssSelector("[name=username]"));
There are four Attribute selectors available in CSS.

Attribute Selector	Pattern Matching	Example
[name^='ctrl']	Starting with	For example, if the name of an element is ctrl_12, this will locate and return elements with ctrl at the beginning of the name attribute.
[name$='word']	Ends with	For example, if the name of an element is password, this will locate and return elements with word at the end of the name attribute.
[name*='user']	Starting with	For example, if the name of an element is 1_username, this will locate and return elements that are containing user in the name attribute.

We can use ID as a attribute, which will be useful in case of dynamic controls in which ID’s will be generated by appending numbers. For example a particular element is having ID like this username_1_2345. In order to identify these kind of controls we can write selector as [ID^=username_1_].
Chaining of Selectors:
Till now we have seen basic selectors, we can chain those selectors in such a way we can identify the element uniquely in a much simpler way in complex DOM.
Few of chaining examples are listed in the below table.

Syntax	Description
*	Matches any Element
E	Matches all elements with tag name E
E C	Matches all elements with tag name E that are descendents of C
E>C	Matches all elements with tag name C that are direct descendents/children of E
E.C	Matches all elements E, that are having class name of C
E#i	Matches all elements E, that are having ID of i
E[a]	Matches all elements E, that are attribute of a, of any value
E[a=v]	Matches all elements E, that are attribute of a, of value v
E[a^=v]	Matches all elements E, that are attribute of a, whose value starts with v
E[a$=v]	Matches all elements E, that are attribute of a, whose value ends with v
E[a*=v]	Matches all elements E, that are attribute of a, whose value contains v

How to write Css and Xpath for an Element

This page will show you some CSS rules and pseudo-classes that will help you move your XPATH locators to CSS, a native approach on all browsers.

I: Simple

Direct child

A direct child in XPATH is defined by the use of a “/“, while on CSS, it’s defined using “>”
Examples:

//div/a

css=div > a

Child or subchild

If an element could be inside another or one it’s childs, it’s defined in XPATH using “//” and in CSS just by a whitespace.
Examples:

//div//a

css=div a

Id

An element’s id in XPATH is defined using: “[@id='example']” and in CSS using: “#”
Examples:

//div[@id='example']//a

css=div#example a

Class

For class, things are pretty similar in XPATH: “[@class='example']” while in CSS it’s just “.”
Examples:

//div[@class='example']//a

css=div.example a

II: Advanced

Next sibling

This is useful for navigating lists of elements, such as forms or ul items. The next sibling will tell selenium to find the next adjacent element on the page that’s inside the same parent. Let’s show an example using a form to select the field after username.

</input> </input>

Let’s write a css selector that will choose the input field after “username”. This will select the “alias” input, or will select a different element if the form is reordered.

css=form input.username + input

Attribute values

If you don’t care about the ordering of child elements, you can use an attribute selector in selenium to choose elements based on any attribute value. A good example would be choosing the ‘username’ element of the form without adding a class.

</input> </input> </input> </input>

We can easily select the username element without adding a class or an id to the element.

css=form input[name='username']

We can even chain filters to be more specific with our selections.

css=input[name='continue'][type='button']

Here Selenium will act on the input field with name=”continue” and type=”button”

Choosing a specific match

CSS selectors in Selenium allow us to navigate lists with more finess that the above methods. If we have a ul and we want to select its fourth li element without regard to any other elements, we should use nth-child or nth-of-type.

• <p>Heading</p>
• Cat
• Dog
• Car
• Goat

If we want to select the fourth li element (Goat) in this list, we can use the nth-of-type, which will find the fourth li in the list.

css=ul#recordlist li:nth-of-type(4)

On the other hand, if we want to get the fourth element only if it is a li element, we can use a filtered nth-child which will select (Car) in this case.

css=ul#recordlist li:nth-child(4)

Note, if you don’t specify a child type for nth-child it will allow you to select the fourth child without regard to type. This may be useful in testing css layout in selenium.

css=ul#recordlist *:nth-child(4)

Sub-string matches

CSS in Selenium has an interesting feature of allowing partial string matches using ^=, $=, or *=. I’ll define them, then show an example of each:
^= Match a prefix

css=a[id^='id_prefix_']

A link with an “id” that starts with the text “id_prefix_”
$= Match a suffix

css=a[id$='_id_sufix']

A link with an “id” that ends with the text “_id_sufix”
*= Match a substring

css=a[id*='id_pattern']

A link with an “id” that contains the text “id_pattern”

Matching by inner text

And last, one of the more useful pseudo-classes, :contains() will match elements with the desired text block:

css=a:contains('Log Out')

This will find the log out button on your page no matter where it’s located. This is by far my favorite CSS selector and I find it greatly simplifies a lot of my test code.

Sauce Labs - Selenium Testing on the Cloud

Sauce Labs’ cloud-based testing platform allows developers to automatically or interactively test mobile and web applications on more than 300 browsers and platforms including iOS, Android & Mac OS X. With built-in video recording of every test, debugging tools, and secure tunneling for local or firewalled testing, Sauce makes running, debugging and scaling test suites easier than ever. Sauce supports automated functional testing with Selenium and Javascript unit testing in all the popular programming languages, frameworks and CI systems.

Css Selector Vs Xpath

    Replace XPath with Css selector

10 down vote accepted

CSS selectors perform far better than Xpath and it is well documented in Selenium community. Here are some reasons, Xpath engines are different in each browser, hence make them inconsistent IE does not have a native xpath engine, therefore selenium injects its own xpath engine for compatibility of its API. Hence we lose the advantage of using native browser features that WebDriver inherently promotes. Xpath tend to become complex and hence make hard to read in my opinion However there are some situations where, you need to use xpath, for example, searching for a parent element or searching element by its text (I wouldn't recommend the later).

If you know css selectors, those are much more easier (and will work fine with IE without any problem ) than xpath even though they can't replace entire xpath.


Consider below HTML tags

 <div id="firstDiv">This div tag has static id </div>

 <p id="paragraps_dynamic_1234">This p tag has dynamic id</p>

 <a onclick="doThat()" title="doThatOperation">This a tag has multiple attributes</a>

 <h1 name="heading1" value="headName">This is heading</h1>


<div>
<input type="text" id="username" name="username"> 
<input type="password" id="password" name="pwd"> 
</div>

<h2 id="propertyUserData">This tag is for starts-with example</h2>

Tag	XPATH	CSS SELECTOR
div	"//div[@id='firstDiv']"	"div[id='firstDiv']"
p	"//p[contains(@id,'paragraps_dynamic_')]"	"p[id*='paragraps_dynamic_']"
a	"//a[contains(@onclick,'doThat') and @tile='doThatOperation']"	"a[onclick*='doThat'][tile='doThatOperation']"
h1	"//h1[@name='heading1' and @value='headName']"	"h1[name='heading1'][value='headName']"
input	"//div/input[@id='username']"	"div > input[id='username']"
input	"//h2[starts-with(@id,'propertyUser')]"	"h2[id^='propertyUser']"

By seeing above locators we can conclude some points regarding css selectors

• Using css selector we can access particular node or immediate child of any node
• Can combine as many conditions as we want for single node.
• Can achieve starts-with, contains functionality using ^,* symbols respectively. 
• We can't traverse back using css selector.
• We can't go to  the siblings also (preceding as well as following)

What is selenium webdriver?

 What is selenium webdriver

What is selenium webdriver and how it help us in software testing process?

Webdriver in selenium (http://docs.seleniumhq.org/projects/webdriver/) is an Interface and it is designed to overcome some limitations of selenium RC software testing tool. However selenium WebDriver's development is in process so still there are few limitations and known issues available in selenium WebDriver. Selenium WebDriver is also known as Selenium 2 and used for web as well mobile

applications testing. It is freeware software testing tool and mostly used as a regression testing tool for web and mobile applications.

Selenium 2 supports most of all browsers to run your test cases and many programming languages like C#, Java, Python, Ruby, .Net, Perl, PHP, etc.. to create and modify your test scripts. Selenium 2(WebDriver) controls browser directly from operating system level so it is interacting very fast and with more realistic way with browsers. Major people in world using Selenium webdriver with java.

What are difference between Selenium IDE, RC and WebDriver

Selenium IDE	Selenium RC	Selenium WebDriver
It only works in Mozilla browser.	It supports with all browsers like Firefox, IE, Chrome, Safari, Opera etc.	It supports with all browsers like Firefox, IE, Chrome, Safari, Opera etc.
It supports Record and playback	It doesn’t supports Record and playback	It doesn’t supports Record and playback
Doesn’t required to start server before executing the test script.	Required to start server before executing the test script.	Doesn’t required to start server before executing the test script.
It is a GUI Plug-in	It is standalone java program which allow you to run Html test suites.	It actual core API which has binding in a range of languages.
Core engine is Javascript based	Core engine is Javascript based	Interacts natively with browser application
Very simple to use as it is record & playback.	It is easy and small API	As compared to RC, it is bit complex and large API.
It is not object oriented	API’s are less Object oriented	API’s are entirely Object oriented
It doesn’t supports of moving mouse cursors.	It doesn’t supports of moving mouse cursors.	It supports of moving mouse cursors.
Need to append full xpath with ‘xpath=\\’ syntax	Need to append full xpath with ‘xpath=\\’ syntax	No need to append full xpath with ‘xpath=\\’ syntax
It does not supports listeners	It does not supports listeners	It supports the implementation of listeners
It does not support to test iphone/Android applications	It does not support to test iphone/Android applications	It support to test iphone/Android applications

Load Testing: What is it?

In this article we are going to see what is Load testing and how to do it. I will try to discuses about strategy to perform Load testing. In my other Load test tool specific post, I will explain how to implement a load test.

Load testing is the process of putting demand on a system or device and measuring its response. In case of software, the demands will be the functions which are needed to be performed and our system will have to perform those. For example,A load test will define and measure a computer/ peripheral/ server/network /application's maximum level of work of its specifications.

The primary goal of load testing are -

-To define the maximum amount of work a system can handle without significant performance degradation
-For comparing capabilities and accuracies of a system with other systems (under controlled lab conditions).
-To get idea about the system on how it functions in real life.
-To get different type of report for having a overall idea on a new or legacy system.

There are mainly two type of load testing can be performed

A. Longevity testing : This will measure the system's ability on how long the system performs on standard operations(standard load). The main focus will be on how long(the time) the system is stable and consistent.

B.Volume testing : This will measure the system's ability on how the system is stable on heavy operation(heavy load) in standard time. The main focus will be the volume of the operations(load) that system can handle. This load may be performed by multiple users.

Both have pinpoint bottlenecks, bugs and component limitations. EX-A mobile may have a fast processor but a limited amount of RAM (memory). Load testing can provide us with a general idea of
-how many applications or processes can be run simultaneously while maintaining the rated level of performance.
-How long the mobile will be stable with operating standard applications.
-How many users can use the application's certain function (if it is a mobile app using web service)

To perform a load test you may go through following steps
-Define the functions to be perform for the load test .
-Define the time for performing the functions.
-Make a bottom line standard system behavior to define the bugs/issues(like , set a time for perform some operation or set some operations to run for certain period of time)
-Define the measuring parameters(what to monitor)
-Choose suitable reports(grid results, charts, graphs etc) to monitor the results.
-Choose alert/marking type to determine alarm points(defining bugs).
-Choose tools meeting the above requirements.

For different scenarios, load testing measuring parameter can be different. 
For a desktop/mobile application (not using data network)
-Use of processor/memory/time on certain functions.
For a web application/service/data server/applications using internet(desktop/mobile)
-Amount of time on certain functions.
-Number of users concurrently can use certain functions.
-Number of functions can be used in certain time

Some load test tools are :
a. JMeter
b. Load UI
c. Load Runner
d. Visual Studio Load test
e. Eclipse Load test tool 
f. SOASTA

Some Load testing areas are like
-Performing extreme process using functions(like complex logic operation, tree operations)
-Writing and reading data to and from a hard disk continuously
-Downloading a series of large files from the Internet
-Log in to a same system with large number of users.
-Exchanging big number and big size of mail in a mail server. 
-Downloading a series of large files from the Internet.
-Running multiple applications on a computer or server simultaneously.
-Assigning many jobs to a printer in a queue.
- Large amount of permission concurrently occurs as accepted/rejected/filtered.  

.... I will try to increase the more load test areas incrementally....

Thanks.....:) 

How run JMeter in different modes?

How run JMeter in different modes?

In this article we are going to learn how to run JMeter in different mode or ways. This is introductory article for novice users.

After downloading JMeter , in the bin directory if we run

jmeter.bat [Run JMeter with GUI]
jmeter-n.cmd [run a non-GUI test dropping a JMX file]
jmeter-n-r.cmd [run a non-GUI test remotely dropping a JMX file]
jmeter-t.cmd  [drop a JMX file on this to load it with GUI]
jmeter-server.bat [start JMeter in server mode]
mirror-server.cmd [runs the JMeter Mirror Server in non-GUI mode]
shutdown.cmd [Stops a non-GUI instance gracefully]
stoptest.cmd - [Stop a non-GUI instance abruptly]

Note: the special name LAST can be used with jmeter-n.cmd, jmeter-t.cmd and jmeter-n-r.cmd and means the last test plan that was run interactively.

We can override JVM settings using JVM_ARGS in the jmeter.bat script.
For example:

set JVM_ARGS="-Xms1024m -Xmx1024m -Dpropname=propvalue"
jmeter -t test.jmx ... 

To edit the jmeter shell script using JVM_ARGS(if JVM options are not supported by current JVM) For example:

JVM_ARGS="-Xms1024m -Xmx1024m" jmeter -t test.jmx [etc.]

This two i have not used yet, but I am configuring JMeter for my current work, so when ever I have finished, I will add an example with changed environment variable(JVM_ARGS)

There is another way to run jmeter in expert mode . If we edit the following line as true and enable it in jmeter.properties file. It will work.
-To Turn expert mode on/off [It will show expert-mode beans and properties]
jmeter.expertMode=true

Thanks...:)

Localization Testing

What is L10N testing(Localization)? How to do it

In this article we are going to learn about L10N (Localization)testing and how to do that.

What is localization? Localization is a term in software that refers to support any language, any location culture. We can easily understand by the meaning of supporting different language, but what is location culture. This location culture means, the culture format of any geographical location such as Date format, Time format, currency format, number format etc. This is a vital issue when we need to deploy a world-ready software. It is also known as L10N testing

Localization translates UI (may changes some initial settings) to make it suitable for another region. Localization Testing checks the quality of a product for a particular Location/culture. This test is based on the results of globalization testing(verifies the functional support for that particular culture/locale). Localization testing may be done with a localized version of a product. Localizability testing does not focused on testing localization quality.The test focuses on:
- Affected Areas by localization(UI/content)
- Culture/locale-specific, language-specific, and region-specific areas

But, these should be included in localization testing :
-Checking Basic functionality
-Deployment(spatially Setup /upgrade) tests under localized environment. For OS, we should select any language version of Windows/Linux as a platform for the test after installing the target language support or that language specific OS(like Japanese XP).

 Popular Scopes for localization testing :
-Check application resources and attributes
-Check linguistic accuracy (correctness)
-Check linguistic meaning (following culture)
-Check typographical errors.
-Check that documentations, online Help, messages, interface resources, and command-key sequences are consistent/sync with each other. If localized versions of the product exist , check the translation is consistent with previous release.
-Check dependency to system/input/display environment standards.
-Check usability of the UI.
-Check sensitive content(political/religious etc)
-Check your company identity is correct.(market-specific information about your company like contact information or local product-support phone etc).

Some known types of checking for application resources
Checking Content – Static & dynamic content such as product catalogs, search results, etc.
Checking Dates – Is the date January 1 or 1 January or 1st Jan.
Checking Characters/symbols – Different languages have different sets of characters.
Checking Postal codes – In some countries, postal codes contain letters.
Checking Phone numbers – Different formats for different markets.
Checking Direction – Some languages are written left to right, other languages are right to left.

I used to make checklist before doing . My sample localization testing checklist:

- Spelling Rules
- Sorting Rules
- Searching Rules
- Upper and Lower case conversions
- UI Sizes
- Printers
- Size of Papers
- Operating System
- Key boards
- Text Filters
- Hot keys
- Mouse
- Date formats
- Measurements and Rulers
- Currency format, value separator,currency symbol
- Country related codes(phone/postal/country/state name and code)


...I will try to include more testing scopes incrementally..

How to Perform load test using Jmeter

In this article we are going to see very simple steps to perform load test on a site. For basic idea about jmeter, please see my this post.

Step 1 : Download latest JMeter from this link 
Step 2 : Extract and Run jmeter.bat from bin(my case, C:\apache-jmeter-2.8\bin)
Step 3: Add thread group and provide some user , time and loop counter(I use 10 user, 2 second and loop count 3). Here we have to use as for requirement. Suppose, Client want the load 1000 user. So, for that if we have very fast PC, we can use 1000 user in 1 second. But it is better to increase the number of user with little more time which creates less load to the PC. In this case , 1000 users in 10 seconds.

 
Step 4 : Right click on Thread group and add a sampler "HTTP Request"
Step 5 : Provide the link of your site.( I use www.kaz.com.bd for test) as server name
Step 6: Right click on Thread group and add some Listeners (to view report).
 
I have added
View Results Tree
View Results in Table
Graph Results
Monitor Results
Aggregate Report
Comparison Assertion Visualizer
Response Time Graph
Summary Report

Step 7 : Run the test. 
You can see/save the report and get you test done