Installation

Installation

Setting up the path variable for Java 8

1) Install JRE (Version 8+)

https://www.oracle.com/technetwork/java/javas
e/downloads/jre8-downloads-2133155.html

2) Check the bin folder for jre installtion

C:\Program Files\Java\jre1.8.0_211\bin

3) Set the Env variables in system properties as

shown in the picture
C:\Program Files\Java\jre1.8.0_211\bin

4) Notice bin folder should be part of it

Need of Proxy Server
Setting up Proxy Server
Recording Issues
Recording Issues
Recording Issues
Recording Issues
Recording Issues
Recording Issues
Recording Issues
Recording Issues
Recording Issues
 Demo Application

• http://demo.kieker-monitoring.net/jpetstore/actions/Catalog.a
ction

• A quick overview
 Demonstration of Recording

• Record directly in “HTTP(S) Test Script Recorder”.

• In “Recording controller”
• Advantage of doing it Recording controller
• Transfer the samplers to simple controller
• Directly recording in Simple recorder
Understanding the resources associated with a request

Use Developer Tools or HTTP Watch

Understanding the embedded resources associated with a request

http://127.0.0.1:1080/WebTours/index.htm
Index.htm

Header.html

welcome.pl?signOff=true

nav.pl?in=home

home.html
Client

Response for Index.htm Server

Response for Header.html
Response for welcome.pl?signOff=true

Response for nav.pl?in=home

Response for home.html

 Understanding the Log

• Listeners  View Results tree

• By Default, the log will not be saved. As soon as you close the
jmeter, this log disappears
• This log is more like Snapshot view of Loadrunner
• This holds significant value for understanding request and
response for each sampler and also for doing some important
enhancement like correlation.
• For saving it for future use, you can save the log.
 Understanding the Log
• Log can be saved in 3 formats
– .jtl (Jmeter Text Logs)
– .csv
– .xml
• Filename of the log should be given prior to recording.
Otherwise, log will not be saved.
 Understanding the Log
• If you want to capture the log of only successful samplers, then
mark the “successes” checkbox.
 Explore options in “HTTP(S) Test Script Recorder”
• Prefix and Transaction name
 Explore options in “HTTP(S) Test Script Recorder”
• Grouping
 Transaction controller
 Transaction controller merges RT of all the samplers under it
 The Transaction Controller is considered successful only if all
the samplers under it are successful
Importance of “Naming Policy”
How To Properly Handle Embedded Resources in HTML Responses

• https://www.blazemeter.com/blog/web-testing-jmeter-how-pr
operly-handle-embedded-resources-html-responses/
 Recording - Different ways
• Using “HTTP(S) Test Script Recorder”
• Using Bad Boy – No proxy Required
– Bad Boy Download Links (Version 2.2)
– https://badboy1.software.informer.com/download/#downloading
– https://drive.google.com/file/d/1DB0prNuPGfWLbPCytM31CiWHtEiCiUa0/view?usp=sharing

• Using Blazemeter – Chrome Plug-in - No proxy Required

• Using HAR file – Popular one and can be asked in interviews - No
proxy Required

• Using Fiddler - No Proxy is required

 Executing in GUI Mode

•Start: Start a test on the local machine

•Stop: Abruptly stop the test that is running on the local machine

•Shutdown: Stop the test gracefully, allowing the threads / Vusers to wind down
 Executing in GUI Mode

•Importance of Listeners  View results in the tree

•Without listeners, we cannot monitor the execution

•Aggregate report, Summary Report and View results in the table

•All the embedded resources will be downloaded . Demonstrate the

same

•How clear cache works ?- Demonstrate

 Where to look for results?
• Using listeners
Use Recording Template
Use Recording Template
Use Recording Template
 Executing in Non-GUI Mode
GUI mode is not desirable because:
– It consumes a large amount of resources, thus interfering with the test results

To avoid these issues, use the non-GUI mode

.
To see the command line options provided by JMeter, issue the following command
in the CMD prompt.
– jmeter –help

C:\>jmeter -n -t FirstTestPlan.jmx -l test-run.jtl

Note that test-run.jtl is the test execution log file.
 Non-GUI Mode
• Running JMeter in command line mode:
• Running JMeter using command line in non-GUI mode is very
simple.
• Open command prompt
• Go into JMeter’s bin folder
• Enter following command, jmeter -n –t test.jmx -l testresults.jtl
 Non-GUI Mode
Screenshot is taken while the
test is executing
 Non-GUI Mode
• jmeter -n –t test.jmx -l testresults.jtl
• -n: It specifies JMeter is to run in non-gui mode
-t: Name of JMX file that contains the Test Plan
-l: Name of JTL(JMeter text logs) file to log results
-j: Name of JMeter run log file
• Other than these options, JMeter has several other parameters that
can be used for running in the non-GUI mode.
• -R: list of remote servers,
• -H: proxy server hostname or ip address
-P: proxy server port
 Non-GUI Mode
• View test result:
Once your test is complete, you will see the following display
 Non-GUI Mode
• View test result:
After completing the test, a JTL file will be generated at
jmeter2.12/bin folder
• Follow below steps to view test results from the resultant JTL file.
• Open JMeter in GUI mode.
• Add any listener Eg. View Results Tree.
• Click Browse button of the file name field in listener.
• Open testresult.jtl file.
• You should be able to see the result in listener now.
 Non-GUI Mode
To stop the test
Go to the bin folder and run the following program as shown in screenshot
 Simple Controller
• The Simple Controller provides no functionality beyond that of
grouping, primarily to organize samplers and other logic
controllers.
 Transaction controller
 Transaction controller merges RT of all the samplers under it
 The Transaction Controller is considered successful only if all the samplers
under it are successful
 The Transaction Controller can function in Parent Mode.
 In the Parent Mode, the individual samples can still appear in the View
Results Tree, but no longer appear as separate entries in View Results in
Table or in other listeners.
 By default, Transaction Controller does not include the time taken by
timers and pre-processors.
 However, it can be configured to include the timers by enabling a checkbox.
 Transaction controller
 Transaction controller merges RT of all the samplers under it
 The Transaction Controller is considered successful only if all the samplers
under it are successful
 The Transaction Controller can function in Parent Mode.
 In the Parent Mode, the individual samples can still appear in the View
Results Tree, but no longer appear as separate entries in View Results in
Table or in other listeners.
 By default, Transaction Controller does not include the time taken by
timers and pre-processors.
 However, it can be configured to include the timers by enabling a checkbox.
 Loop controller
• The Loop Controller can be configured to loop indefinitely by
enabling the Forever checkbox.
• This gets enabled even if you enter any negative number for
Loop Count.
• If you run the test with the Forever checkbox enabled, you need
to click on the Shutdown button and terminate the test
gracefully.
• Clicking on the Stop button terminates the threads abruptly, and
you may see some errors in the requests.
 Runtime Controller
• The Runtime Controller controls the duration for which its child
elements are run.
• A Runtime Controller executes its child elements in its hierarchy for
the specified duration. At the end of the nested elements, it loops
through again.
• Using the same logic, if the specified time runs out, the Runtime
Controller stops execution even if it has executed only a part of the
nested elements. The currently executing element is allowed to
complete, but the newer elements are not executed once the
specified time is over.
 Throughput Controller
• The Throughput Controller controls the number of executions of its child
elements. This is a misnomer, as it does not control the throughput.

• You can configure this in two modes:

• Number of Executions: The child elements are executed until the specified count
is reached and the subsequent executions are skipped. To configure this, choose
Total Executions and specify a value for Throughput.

• Percentage of Executions: The concept is the same except that the number of
executions of the child elements is restricted by the percentage configured.
 Once Only Controller
• Once Only Controller executes its child elements only once per
thread / VUser.

• This is typically used to perform logins or another use-case that’s

needed only once for a user session.

• The Once Only Controller should be a child element of the thread

group or Loop Controller. Otherwise, the behavior is not defined.
 Interleave Controller
• The Interleave Controller executes only one of its child
elements per loop iteration. Each time it iterates, it picks the
next child element in sequence.

• How the values will be picked for multiple threads?

• What if, there are child controllers

 Interleave Controller
• What if, there are child controllers
Interleave Controller
 Random Controller
• The Random Controller is similar to the Interleave Controller
except that the order of interleaving is random instead of
sequential. The configuration is just like the Interleave
Controller.
 Random Order Controller
• The Random Order Controller executes all its Child Elements
but in random order.
• Random Controller executes only one of the Child Elements
 Switch Controller
• The Switch Controller is analogous to the switch/case
programming construct.

• The Switch Controller executes only one of its child elements

after matching the element’s name with the configured Switch
value.

• If the Switch value is an integer, it executes the child element

based on the sequence number.
 Plug –in Manager
• How to install Plug-in Manager
• Need for installing plug-in manager
• Install Dummy Sampler
 User Defined Variables
• In LR, we have different data types
• In Jmeter we have only one  User Defined Variables
• Variables Defined in “User Defined Variables” are global
• Variables can be used with Jmeter Functions.
• Like url variable
– Why is it used
– Where it is used
• Other places that we use variables like username and password.
 User Defined variables

• Demonstrate _Random Function

• Demonstrate how _Random function can be used for Credit
card and other places
• Random can also be created using Random Sampler.
• Demonstrate Switch controller with _Random Function
• Explore other Jmeter functions like _RandomDate
Switch Controller

C:\Users\sree\
Desktop\Random.jmx
 If Controller
• The If Controller is useful for decision/branching logic. The
configuration is simple, with only two checkboxes.
• The Evaluate for All Children checkbox indicates whether the
condition should be evaluated before processing each of the
child elements. If it’s not checked, the condition is evaluated
only when it is encountered for the first time.
 If Controller
• "${UserVar}" == “true“
• ${Count} == 10
• ${Count} == 10 && "${UserVar}" == “true“
 If Controller
• A better option (default one) is to check Interpret Condition as Variable Expression?
• Then in the condition field you have 2 options:
• Option 1 : Use a function (${__jexl3()} is advised) to evaluate an expression that
must return true or false
• Use ${__jexl3()} function
• ${__jexl3("${UserVar}" == "true")}
• ${__groovy("${UserVar}" == "true")}
 If Controller
• Option 2 : Use a variable that contains true or false
 Think Time
Think time is the time that a user waits between two actions, other words Mark will wait and think
between two transactions.
Lets see the example below

Here Mark entered the user name and password in HP web tours
application’s login screen.

Where to click

After the login and home page is loaded Mark is thinking to where to
click, here Think timer is started.
 Think Time

After some time Mark decided to select “flight” button , he clicked on “Flights”. So the
the moment he clicked on flights option think timer stopped.

This Time which he spends

not doing anything on the
system is called “Think Time”

6 seconds is the think time for between above two transactions.

Note : Thinktime may change from user to user for the same application

10 seconds is the industry standard think time

Difference between ThinkTime and Transaction Response Time

www.facebook.com

2 Secs

Client 2.5 Secs

Web Server App Server DB Server

Now Mark is “Thinking” as to how to login and where should he enter the username and password.
Think Time also includes time taken to enter the username / password and click on “login” button

10 Secs 7 Secs
2 Secs 2.5 Secs
Think Think
Time Login Transaction Time Log off Transaction
Launch Transaction
 Order of Component Execution / Hierarchy

a+b*c
b*c is evaluated first and then the
addition operation
 Constant Timer
• The Constant Timer introduces a specified delay before the samplers in its
scope are executed. The only configuration is the delay that is needed.

• Constant Timer delays all the child elements in scope.

• What if you wanted to delay only a specific sampler by 5 seconds?

• You can achieve this by making the Constant Timer a child element of the
sampler to be delayed.
 How Timers scope works
Rule 1: Timers are executed before each sampler in their scope. Constant Timer delays all the
child elements in scope.
As we can see, Timer1 is:
• Executed three times because of scoping rule
• Executed once before Sampler1
• Executed once before Sampler2
• Executed once before Sampler3

Will be executed in this order

 How Timers scope works
Rule 2: If there is more than one timer in the scope, all the timers will be
processed before the sampler.
As we can see, Timer1 and Timer2 are:
• Grouped because all timers in scope are executed before every sampler
• Executed twice because they are applied to every sampler in scope
• Executed once before Sampler1
• Executed once before Sampler2

Will be executed in this order

Control the execution order of Timers

If we want to have this execution order.

 Control the execution order of Timers
Option 1. We can use Add Think Times to children feature

This feature allows us to have different think times for each element.
 Control the execution order of Timers
Option 2: You can achieve this by making the Constant Timer a child element of
the sampler to be delayed.

Nesting timers as children of samplers is less readable since timers are executed before
Sampler
 Control the execution order of Timers

Option 3: Have a random timer and put it at the same level as Sampler, thanks to
scoping rules, it would run before each Sampler.

But still timers are executed before Sampler

 More clarity on Order of Component Execution

For the given test plan, the execution order will

be:

1. BeanShell Pre-processor
2. Constant Timer
3. Constant Throughput Timer
4.BSF Sampler
5. Transaction Controller
6. CSV Data Set Config
7. HTTP Request
8. BeanShell PostProcessor
9. Aggregate Report

As you can see in the screenshot below, the position of different elements does not
impact the execution order.
 More clarity on Order of Component Execution
For the given test plan, the execution order will
be:

1. Timer1
2. Timer2
3. JR1
4. Outer Postprocessor
5. Inner Postprocessor 1
6. Timer1
7. Timer2
8. JR2
9. Outer Postprocessor
10. Inner Postprocessor 2

The second rule is that outer elements are executed before inner elements of the same
Type.
 Gaussian Random Timer
• The Gaussian Random Timer introduces a delay according to
the Gaussian Distribution
• The delay varies around a central mean, as illustrated in Figure
Gaussian Random Timer
 Gaussian Random Timer
Let’s assume that the mean value is 10 seconds and the variance is 2 seconds.
The delay introduced would vary as follows:
• 68% of the time, the delay would vary between mean - variance and mean
+ variance (between 8 seconds and 12 seconds).
• 95% of the time, the delay would vary between mean - 2 * variance and
mean + 2 *variance (between 6 seconds and 14 seconds).
• 99% of the time, the delay would vary between mean - 3 * variance and
mean + 3 *variance (between 4 seconds and 16 seconds).

• Use Loop controller to demonstrate the Gaussian delays

 Uniform Random Timer
The delay introduced by the Uniform Random Timer has two parts:
 Constant Delay: Fixed and equal to the configured value.
 Random Delay: Varies between zero and the configured value.

• The actual delay will range between the Constant Delay and the Constant Delay plus the
Random Delay.

• As the term “uniform” indicates, the delay varies within its range with equal probability.

• If the Constant Delay was configured to 10 seconds and the Random Delay was configured to 5
seconds, then the actual delay will vary between 10 and 15 seconds.

• Use Loop controller to demonstrate the Gaussian delays

Uniform Random Timer
 Combination of both URT and Gaussian Is used in Real
World

Notice, GRT is not added for 1st sampler, as timer is executed before the sampler
 Constant Throughput Timer
• The Constant Throughput Timer calculates and introduces delays between samplers
so as to keep the throughput at the configured value.
• Target throughput(in samples per min) = 5
• Configure Number of Threads (Users) as 1 and Loop Count as 20.
• In these results, each of the requests to /jmeter/alpha has been delayed by a
varying amount so as to keep the overall throughput at the configured level
• In the Aggregate results, observe that the throughput is approx 5 requests per
minute.
 Synchronizing Timer
• The Synchronizing Timer blocks VUsers and releases them all at
once, thus creating a large load at the same instant. This is very
helpful to test how the application handles simultaneous
requests.
• Number of Threads (Users) as 4, Loop Count as 12
 Assertions
• The primary purpose of assertions is to validate the server response and decide if the test
passed or failed.
• The response to a sampler contains code to indicate success or error. But this is at the
protocol level.
• JMeter assertions provides a mechanism to validate the content of the response.
• The specific JMeter assertions you use depend on the response format.
• The validation check is configurable based on the assertions type.
• JMeter assertions can be a child element of a test plan, thread group, controller, or
sampler.
• Assertions will apply to all the samplers under the scope of its parent. For example, if an
assertion is a child element of a thread group, then it applies to all the samplers under
the thread group.
 Assertions
• Sometimes, it makes more sense to have specific assertions for
each sampler.

• JMeter provides the flexibility to add multiple assertions.

• Assertions are used to validate the test script.

• The Assertion Results listener is a special listener intended

specifically for viewing the results of assertions.
 Assertions
• Duration Assertion – Response time SLA verification
• Size Assertion – Esp Useful for File Download
• HTML Assertion – Can provide threshold for errors and warning
-Only check the format
• XML Assertion – Check the format - SOAP / Restful WS
• JSON Assertion – Esp useful for Restful Services or if any
response is in JSON
 How Assertions scope works
• Copy from Page 89 to 90
Example 3
Example 4:
• Assertion1 will validate Sampler1 and Sampler2 response
© 2015 - 2018 Antonio Gomes Rodrigues, Philippe Mouawad
and Milamber
Important concepts in JMeter 88
Example 4
Rule 2: Failed assertions cause the failure of the entire
Transaction Controller
Example 5:
• All samplers will be validated by assertion Assertion1
• Controller1 will be marked as failed because of Sampler2’s
failure
Example 5
Rule 3: Assertions can validate main sample and/or
sub-samples
For some Assertions, we can select if we want to apply it to
main sample and/or
sub-samples.
© 2015 - 2018 Antonio Gomes Rodrigues, Philippe Mouawad
and Milamber
Important concepts in JMeter 89
For example, in Response Assertion.
Response Assertion apply to
Validating sub-samples can be useful when Retrieve all
JSON Assertion
 JSON Assertion

Script Name is JSON_assertion in Desktop

 Thread Group (need to add at last)
• Every test has one or more thread groups. A thread group is a
child element of a test plan. Each thread group
• represents a use-case. As you will see later in the book, a
thread group can be configured with the number of
• threads, ramp-up time, and other useful properties that allow
you to control its behavior.
Parameterization
Parameterization
Parameterization
Parameterization
Parameterization
Parameterization
 Correlation

•G1 is the first group and G2 is 2nd group.

•$2$ pulls 2nd group values
 Correlation

• To demonstrate “NOTFOUND”, make sure first correlation fails, so that second correlation value is displayed as
“NOTFOUND”
• Infact, anything can be set as default values.
• Even we can use empty value but it has benefits to use “NOTFOUND”
 Correlation

• 0 for random
• 1 for fish
• 2 for dogs
 Correlation
• Capture the complete response

• (?s)(.*)
• ?s represents new lines
 How properties differ from variables
• Properties and variables allow you to make data dynamic in JMeter. So the purpose
• is very similar:
• Important concepts in JMeter
• • Variables are tightly bound to their thread, meaning that every thread has its
• own copy and can manipulate their own version.
• • Properties are shared among all threads, so changing a property during a test
• should be avoided. If you really need to change it, ensure that the value is not
• corrupted by simultaneous access by synchronizing this access.
• In summary, variables and properties differ in that Properties are global and Variables
• are local with respect to threads.
• Based on this, we can define two rules:
• • Properties should be used for environment-related data
• • Variables should be used for user-related data and correlation rules. That’s why
• for example, extractors in JMeter will create variables
 How properties are created
• Properties are created by JMeter reading them from:
• • jmeter.properties
• • user.properties
• • command line using “-J” option: -JpropName=propValue
• • command line using “-G” option: -GpropName=propValue
• • any file referenced through command line option “-p” or ”–propfile”
• • any file referenced through command line option “-q” or ”–addprop”
• • any file passed using command line option
• You can also create them from JMeter using function:
• ${__setProperty(propName, propValue)}
• And finally, using scripting elements like JSR223 Test Elements
• props.put("propName", "propValue");
• or:
• props.setProperty("propName", "propValue");
 How variables are created
• Variables are created by JMeter using different elements:
• • User Defined Variables a config element
• • User Parameters a pre-processor
• • JMeter functions⁴⁶ that accept a variable as last argument
• • JMeter extractors⁴⁷ that create variables from response excerpts
• You can also create using scripting elements like JSR223 Test Elements:
• vars.put("varName", "varValue");
• or:
• vars.putObject("varName", objectToBeUsed);
 How ${} differs from ${_P}
• Since we know the difference between Variables and
Properties, let’s see how to use
• them.
• Variables are accessed using ${varName}
• Properties are accessed using __P function, so to read property
propA, you
• would use ${__P(propA)}
Remote execution – Master / Slave
 Remote execution – Master / Slave
• On both master and slave, jmeter should be available.
• Get IP Address of Master and Slave.
• Both Master Machine and Slave machine should be in the same network.
• Master Machine  From the Jmeter Bin Folder - Execute “Create-rmi-
keystore” windows batch file.
• Enter pertinent information on the cmd prompt like firstname, lastname,
state, company id etc…
• Once the cmd prompt is executed, a file is created with the name “rmi-
keystore.jks”
 Remote execution – Master / Slave
• Copy “rmi-keystore.jks” into the slave machine – bin folder
• Master Machine – User.properties file  Copy below information.

C:\Users\Isha\
Desktop\User_properties_app

• Notice following changes to the file

“remote_hosts=127.0.0.1,192.168.1.3”
In the above
• 127.0.01 is the indication for master file
• 192.168.1.3 is the ip address of slave file
 Remote execution – Master / Slave
• Slave Machine – User.properties file  Copy the same
information as done for master. <No Changes at all>
• Run “jmeter-server” windows batch file – on slave machine
 Remote execution – Master / Slave

Created Remote object in the cmd line indicates that connection is established.

Note: If you wanted to use master also, run “jmeter-server” windows batch file on master also.
 Remote execution – Master / Slave

From the master, test can be executed with the users of the slave as shown in the above picture.
“Starting the test on the host” on the cmd line indicates, slave is used for execution.
• Reports
• Beanshell
 Create a Test Scenario
• Merge multiple scripts using Merge options
 Create a Test Scenario
• Merged 3 scripts below
 Create a Test Scenario
• Apply following settings for
executing for one hour.
• Here Ramp up period id 10 secs.
Which means 1 user for every 2
secs
• Make sure forever options is check
and duration as 3600 secs
• No option of ramp down.
• We need a plug-ion
 Create a Test Scenario
• Make sure Aggregate Listener is added to get the response
times report
 Create a Test Scenario
• Make sure Simple data writer Listener is added to get the final
report
 Test Results
• For creating a report for Load Test, Some changes needs to be
done in user.properties file (GUI and also non-GUIExecution)
• In real world Non-GUI mode execution is preferred as it
consumes less resources.

C:\Users\sree\
Desktop\Jmeter_Scripts\Sdli
 Test Results
• Add simple data writer listener
• Make following changes
• Jmeter –g C:\Users\sree\Desktop\Jmeter_Scripts\
DashboardReport.csv -o C:\Users\sree\Desktop\
Jmeter_Scripts\DashboardReport

• Command to generate the graphs.

• Graphs can be generated via the file created by simple data
writer listener
 Jmeter Latency & Sample Time
• https://performancetestersdiary.wordpress.com/2013/01/30/j
meter-latency-sample-time-and-302s/
 Pre-Processor

Pre-processor

Client Web App Server DB Server

Pre-Processors

Pre-processors take the request and modify it (substitution, enhancement, dereferencing variables, etc.)
before the sampler sends it to the server.
 Post-Processor

Post-processor
Client Web App Server DB Server

Post-Processors

Post-processors process the response from the server. They are used to process the server response and
modify the component settings or to update variables
Order of Component Execution / Hierarchy
a+b*c
b*c is evaluated first and then the addition operation
Order of Component Execution

For the given test plan, the execution order will

be:

1. BeanShell Pre-processor
2. Constant Timer
3. Constant Throughput Timer
4. Transaction Controller
5. CSV Data Set Config
6. HTTP Request
7.BSF Sampler
8. BeanShell PostProcessor
9. Aggregate Report