Apache JMeter Testing
Jump to navigation
Jump to search
Apache JMeter Testing
What is JMeter
Apache JMeter
- Open source project
- Started in the late 1990s
- Part of the Apache Foundation
- Complete portability and 100% Java purity
JMeter is a testing tool
- Full multithreading framework allows concurrent sampling by many threads
- Simultaneous sampling of different functions by separate thread groups.
- Test Plan building and debugging.
- Caching and offline analysis/replaying of test results.
- Apache JMeter features include:
- Ability to load and performance test many different server/protocol types:
- Web - HTTP, HTTPS
- SOAP
- FTP
- Database via JDBC
- LDAP
- Message-oriented middleware (MOM) via JMS
- Mail - SMTP(S), POP3(S) and IMAP(S)
- MongoDB (NoSQL)
- Native commands or shell scripts
- TCP
- Ability to load and performance test many different server/protocol types:
- Highly Extensible core:
- Pluggable Samplers allow unlimited testing capabilities.
- Several load statistics may be choosen with pluggable timers .
- Data analysis and visualization plugins allow great extensibility as well as personalization.
- Functions can be used to provide dynamic input to a test or provide data manipulation.
- Scriptable Samplers (BeanShell, BSF-compatible languages and JSR223-compatible languages)
- Highly Extensible core:
- References:
JMeter requires Java to run
- It is written in Java
- To run it needs a Java Virtual Machine (JVM)
JVM, JRE, JDK - what are these?
JVM - Java Virtual Machine
- Runs Bytecode produced by the Java Compiler
- Allows Java to run on multiple types of hardware (write once, run anywhere)
- Interprets Bytecode into the instruction set of the hardware
- Can use JIT (just in time) compilation
- References:
JRE - Java Runtime Environment
- Contains the Java Virtual Machine, code Libraries, and other components
- Allows applications and applets written in Java to run
- Can be either Standard or Enterprise
- References:
JDK - Java Development Kit
- An implementation of one of the Java SE, Java EE, or Java ME platforms
- For a particular Hardware and Operating System such as Windows, Linux, Solaris, or Mac OS
- Contains JRE (with JVM), and Tools to develop applications
- Important tools it has include, compiler, debugger, JavaDoc generator, JAR archiver
- Most development uses an IDE such as Eclipse or NetBeans that may access the tools in the JDK
Java SE versus EE
- Java EE is built on top of SE components
- The more important components in EE are designed to help build
- Web Applications (Servlets, JSP, JSF, etc.)
- Enterprise Applications (EJB, Database connectivity, Message Services)
- There are numerous packages in EE
Install the Java SE JDK
- Hands on Exercise - Install the Java JDK:
- Using the following document install the Java JDK that corresponds to the type of Operating system that exists on your computer (Windows, Mac OS, Linux x64, etc.). The installation steps will be approximately the same for each operating system.
Understanding the development process
Set up a development web server
- The web server builds and serves web pages to browsers
- Browsers - Firefox, Chrome, Internet Explorer, Safari, etc.
- A Development web server generally is on a developer's computer
- The code base is put onto the server such that the developer can step through web pages that are built by the server.
- These days this is usually done in an Integrated Development Environment (IDE)
- Eclipse
- Netbeans
- Visual Studio
- Intellij
Install Eclipse IDE
- Hands on Exercise - Install an Integrated Development Environment (IDE):
- Using the following instructions install Eclipse on your computer. Eclipse is an Integrated Development Environment commonly used by developers. Installation steps will be approximately the same for all operating systems. There is only one installation zip file for all operating systems.
Install Apache Tomcat
- Hands on Exercise - Install a Web Server
Apache httpd
- The original Apache project
- Handles static HTML pages
- Can sit in front of Tomcat
- Can use a connector to send JSP's to Tomcat
- Apache httpd handles static pages
- Tomcat handles JSP's and Servlets
- Tomcat can handle static HTML pages on its own
Create a small web application for use in testing
HTML Static Pages
Servlets
- Tomcat has a Servlet Container. The Servlet Container:
- Gets HTTP requests from clicks on web pages (usually)
- Keeps state for the user through cookie JSESSIONID, web pages are stateless
- Delegates the request to a servlet.
- Returns a response to the requester.
- A servlet:
- Is a component of a Java Web Application (usually)
- Is a Java class that extends HttpServlet (usually)
- Is configured to handle requests for a specific web page
- Gets requests from the Servlet Container
- Give responses back to the Servlet Container
- Hands on Exercise
- Step 1 - Click and save the Web Project WAR file that is zipped below
- Step 2 - Extract the WAR file from the zip
- Step 3 - Start Eclipse if it is not already running
- Step 4 - Import the WAR file below into Eclipse
- Step 5 - Go over the examples of JSPs and Servlets with the instructor
- Note that "Create a Servlet and WAR file in Eclipse" and "Create an Eclipse Web Project" are discussions on how to create web projects and Servlets. The WAR file to be imported was created by making a web project and then creating servlets and JSPs within that project. Those files were then export as the WAR.
- References
JSPs
JavaServer Pages (JSPs) are another component of a Web Application.
JavaServer Pages:
- Mix HTML with Java Code by using scriplets <% some code %>
- Allow dynamic content such as database content
- Are translated in Java code
- Static code is translated as prints to the output
- Dynamic code is translated as Java code
- The code is compiled into Servlets
- When a reference is made to a JSP the servlet is run
An example of a JavaServer Page is given below.
<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Insert title here</title>
</head>
<body>
This is the testing page.
<% int a, b;
a = 5;
b = a + 6;
%>
<br/>
The integer was <%=b%>
</body>
</html>
JNDI and DataSources
The Java Naming and Directory Interface (JNDI)
- Is an API that provides naming and directory services to Java programs
- Tomcat provides JNDI services for use by the developer
- Context.xml and web.xml are used to configure JNDI resources for use in Tomcat
- Hands on Exercise
Understanding the Testing Environment
Types of Testing
- Performance Testing
- Identify performance bottlenecks
- Determine throughput
- Determine performance for various system and server configurations
- System Testing
- Does system meet original requirement specifications
- Testing is only as good as the test plan
- If requirements are not complete then tests may fail to catch all bugs
- Set up tests to test JIRA reported bugs
- Regression Testing
- rerun sets of standard testing scripts
- determine if system still functions to meet requirements when new versions are to be released
- White Box and Black Box testing
- White Box - find out about the internal structures of the software
- For Example database connections, queries, and inserts should be tested.
- Connections to other systems should be tested.
- Complex algorithms should be tested
- Black box - ignore the internals and just act like a user
- What do users do with the system?
- What types of errors can they make as the use the system?
- Any Ecommerce that can go wrong, multiple clicks on the buy button?
- White Box - find out about the internal structures of the software
- Testers built test plans and scripts
- Close cooperation with developers is needed
- Testers must ask questions
- Are there hidden requirements?
- Show us what is supposed to be happening with the system?
- What happens if bad input is put into the system?
- Can we break the system?
Install JMeter
- Hands on Exercise
Tools for Viewing Web Application Performance
- JConsole
- Google Tools
- VisualVM
- PSI Probe
Build a Test using JMeter
To understand the elements of JMeter test plans it is easiest to build a test plan.
A test plan will consist of
- Thread Groups
- Samplers
- Logic Controllers
- Listeners
- Assertions
- Configuration elements (when needed).
- Hands on Exercise - Step 1:
- Build a test plan using the elements in the JMeter Elements sections below.
- First create a new test plan so that elements can be added
- Build a test plan using the elements in the JMeter Elements sections below.
JMeter Elements
- Reference:
- In General test plans consist of
- Thread Groups
- Logical Controllers - control the flow of the test
- Samplers - send requests and receive responses
- Other elements like Assertions, Timers, Pre Processors, etc.
Test Plan
- The elements of the test plan will be added under this item in the left portion of the window
- Threads - each thread simulates a single user hitting the web server.
- Note that the actual plan is built under a Thread Group
- Thread Groups are under the Threads menu item
- Test Fragment - A special type of controller.
- You can build a test fragment from other elements under this element
- It can be included in the test plan in multiple places
- An Include Controller is used to include it
- Config Element - Various configuration elements are here
- For example the HTTP Request Default element which defines the default host and port etc.
- when placed at the same level as the Thread Group they become global configurations
- Timer - various types of timers that can be used to time the test plan
- Generally JMeter send requests with no pauses between requests
- This does not correspond to the way systems are used by users
- Pre Processors - Executes an action prior to a request (Samplers are discussed below)
- For example setting parameters for a request
- There are scoping rules that apply to Pre Processors
- Post-Processors - Executes an action after a request
- usually it processes the response data
- There are scoping rules that apply to Post-Processors
- Assertions - Used to test the responses
- Was the response correct
- If not fail the response
- Generally added as the child of a Sampler (Discussed below)
- Listeners - provide access to the information JMeter gathers during the test
- Hands on Exercise - Step 2:
- Add a Thread Group to your Test Plan
Thread Group
- Logic Controller - these control the flow of the test plan
- Config Element - the came configuration elements as above
- apply these to Thread Group Elements by placing them as sub-elements in the test plan
- Note that both order of the test plan and where sub-elements are placed are important
- Timer - Same timers as above but these are timers used within the flow of the plan
- Pre Processors - usually attached as children of Samplers
- processed before their parent elements
- Samplers - make requests and get responses from the system
- For example the HTTP Request sampler requests a web page
- the same thing as clicking on a link in a web page
- Post Processors
- Usually attached as children of Samplers
- process the response to a request by the sampler
- Assertions - Used to test the responses
- Was the response correct
- If not fail the response
- Generally added as the child of a Sampler
- Listeners - provide access to the information JMeter gathers during the test
- Hands on Exercise - Step 3:
- Add a View Results Tree Listener to the Thread Group
- This will allow the viewing of the results of the test plan once we add other elements
- Hands on Exercise - Step 3:
Samplers
- FTP Request - send request to retrieve a file or upload a file to an FTP server
- References from search engine - JMeter FTP request tutorial
- HTTP Request - send an HTTP/HTTPS request to a web server
- This is commonly used to test web server pages
- References from search engine - JMeter HTTP Request Tutorial
- Hands on Exercise - Step 4:
- Add a HTTP Request Sampler to your Thread Group.
- Use a URL that hits the Tomcat test server that has been set up in prior steps
- Add a HTTP Request Sampler to your Thread Group.
- Hands on Exercise - Step 4:
- JDBC Request - send a JDBC request to a database
- This sampler would directly exercise a database using JDBC
- Another way to do this is by sampling an HTML page that is built from a database
- Debug Sampler - The Debug Sampler generates a sample containing the values of all JMeter variables and/or properties.
- Can be used to send all of the variables and their values to a View Results Tree
- Beanshell Sampler - very powerful script driven sampler
- Can be programmed to do tasks
- Programming is done in the Bean Shell script
- References
- JSR223 Sampler - very powerful script driven sampler (fast)
- JMeterVariables (vars) and JMeterProperties (props) see the JavaDocs
- References from search engine - JSR223 vs Beanshell
- Java Request - exercise a Java class
- the class would have to implement the correct interface
- Samplers that are not used as often
- SOAP/XML-RPC Request - sample a SOAP service
- LDAP Request - sample an LDAP service
- SMTP Request - send an email through an SMTP server
- Mail Reader Sampler - read an email from a POP or IMAP server
- JMS Publisher, Subscriber, Point to Point
- Most of the other samplers i.e. BSF, TCP, JUnit, OS Process, etc.
- Reference - JMeter Samplers
Logical Controllers
- Control the flow of the test
- Similar to logic within a programming language
- The order of the test plan determines how elements are executed
- Top element is first then on down through the test plan
- Controllers can cause loops and conditional execution of elements
- For example if, foreach, loop, random, etc.
- ForEach Controller - loops over a set of values in a variable
- For Example a Regular Expression Extractor can be used in an HTTP Request to get the values from a page into a variable
- While Controller - allows the setting of a condition that will stop the loop
- Hands on Exercise - Step 6:
- Create a while controller that will stop when an index gets to 20
- Use a Counter to index the loop
- If Controller - conditionally execute steps
- Usually uses a JMeter function or variable in the condition
- JMeter has a set of standard functions (JMeter User Manual)
- variables can be set using
- Regular Expression Extractor as a child of a prior Sampler
- CSS/JQuery Extractor as a child of a prior Sampler
- Hands on Exercise - Step 7:
- Create a If Controller that
- Is a child of the While Controller
- Calls one URL if a counter is below 10
- Calls another URL is counter is over 10
- Create a If Controller that
- Include Controller - include another test plan from a file into this test plan
- Usually the other test plan would not have its own thread group.
- Interleave Controller - The thread group does the looping if any is done
- Child elements are interleaved with each loop by the thread group
- Loop Controller - loop a specific number of times over the children of the controller
- Module Controller - includes a Test Fragment into the test plan
- The Test Fragment is defined within the Test Plan
- It is defined outside the Thread Group
- Once only Controller - executes its children once only during a test.
- If placed under another looping controller it executed only once per test
- Random Controller - similar to interleaving but does it randomly
- Random Order Controller - randomizes the execution of its children
- Recording Controller - Used to record a series of actions taken in a browser (see section Build a Test Using a Recorder)
- Runtime Controller - controls how long the children are allowed to run (i.e. 1 second)
- Simple Controller - used to group children that belong together
- Provides no functionality other than a place holder for grouping
- Switch Controller - acts like a switch statement
- Throughput Controller - controls the number or percentages of times its children are executed.
- Transaction Controller - generates an additional sample telling how long it takes to execute its child elements
Assertions
- Used to perform checks on Samplers
- Test can be failed when assertion fails
- References from search engine - JMeter Assertions
- Bean Shell Assertion - use the Beanshell to create the assertion code
- BSF Assertion - kind of outdated by Beanshell and JSR223 assertions
- Compare Assertion - do two samplers give the same response or response time, for example from two servers
- Duration Assertion - How long did the request and response take
- HTML Assertion - is the response well formed HTML
- JSR223 Assertion - Used when the assertion requires programming
- For example extraction of data from the response
- MD5Hex Assertion - does the response match a MD5 hex hash
- Response Assertion - match patterns in the response
- Hands on Exercise - Step 8:
- Add a Response Assertion to the test and test for specific phrases that are expected in the response from the sampler
- Size Assertion - what is the size of the response
- SMIME Assertion - deals with email responses
- XML Assertion - is the response well formed xml
- XML Schema Assertion - does the response match a specific schema
- XPath Assertion
- References:
Timers
- Timers apply to all Samplers in their scope
- Timers at a level apply to all Samplers (and their Sampler children) at that level
- If a timer is to apply to a specific Sampler it must be a child of that Sampler
- BeanShell Timer - use Beanshell scripting to code a timer
- BSF Timer - use BSF scripting to code a timer
- Constant Throughput Timer - random timing, throughput for all samplers in total kept at a specified value
- Constant Timer - pause for the same amount of time between requests (Samplers)
- Hands on Exercise - Step 9:
- Add one or more Constant timers to the test
- Determine how the placement of the timer effects the test, in other words determine how scope matters.
- Add one or more Constant timers to the test
- Hands on Exercise - Step 9:
- Constant Timer - pause for the same amount of time between requests (Samplers)
- Gaussian Timer - the variation around constant offset has a Gaussian curve distribution
- JSR223 Timer - use a JSR223 scripting language to code a timer
- Poisson Random Timer - pause each thread request for a random amount of time, with most of the time intervals occurring near a particular value
- Synchronizing Timer - bottleneck several threads then release them all at once
- Uniform Random Timer - pauses for a random amount of time
- The maximum time is specified
- An offset is specified
- To get 20 to 100 milliseconds have max of 80, offset of 20
- Values are then generated randomly from 20 to 80
- To get 20 to 100 milliseconds have max of 80, offset of 20
- Uniform Random Timer - pauses for a random amount of time
Listeners
- Most of the listeners perform several roles in addition to "listening" to the test results.
- They also provide means to view, save, and read saved test results.
- Note that Listeners are processed at the end of the scope in which they are found.
- It is easiest to understand the various Listeners by trying them
- Aggregate Graph - Graph showing various time and throughput data
- Aggregate Report - table row for each request giving various time and throughput data
- Assertion Results - shows labels of all assertions executed and results of any failures
- Beanshell Listener - use Beanshell scripting to create a listener
- BSF Listener - use BSF scripting to create a listener
- Comparison Assertion Visualizer - shows results of Compare Assertions
- Distribution Graph - shows graph of response times
- Generate Summary Results - shows results as the test is running to the log and standard output (console)
- Graph Results - graph of sample times
- JSR223 Listener - use JSR223 scripting to create a listener
- Mailer Visualizer - sends email with success and failure data
- Monitor Results - can monitor servers
- Response Time Graph - Graph of response times
- Save Responses to a File - saves responses for samplers in its scope to a file
- Simple Data Writer - records data to a file, faster than the GUI Listeners
- Spline Visualizer - graph of sample times using splines
- Summary Report - similar to an Aggregate Report
- View Results in Table - shows various data in table format such as sample name, size, start time, etc.
- View Results Tree - shows tree (parent child) of results
- Hands on Exercise - Step 9:
- A View Results Tree was added in a prior step. Try some of the other Listeners to see how they work.
- Hands on Exercise - Step 9:
User Defined Variables
- Defined in the User Defined Variable configuration element
- Values are static during test execution (cannot be changed)
Blazemeter on User Defined Variables
Variables and Functions
- JMeter has built in functions that can be used in scripts (for example in JSR223 Samplers)
- JMeter has the ability to save and use variables and properties
- JMeter variables have thread scope
- JMeter properties are shared between all thread
- Functions available in scripts
- See the user manual JMeter User Manual on Functions
- See the function helper in JMeter's icon menu
- Variables available in scripts, for example in the JSR223 Sampler
- Variables passed to scripts by JMeter automatically
- vars - see class JMeterVariables
- ctx - see class JMeterContext
- props - see class JMeterProperty
- SampleResult - see class SampleResult
- sampler - for a pre-processor or post-processor gives access to the sampler that is its parent.
- log - the Logger
- Label - the sampler label
- filename - the file name if any
- Parameters - text from the Parameters field
- args[] - the parameters split into a String array
- OUT - System.out i.e. System.out.println
- Variables that can be built on the fly by the elements (i.e. JSR223 Samplers)
- vars.put("somename", "someString"), vars.get("somename")
- vars.putObject("somename", someObject), (cast to correct type)vars.getObject("somename")
- Properties (class java.util.Properties)
- properties that can be built on the fly by the elements(i.e. JSR223 Samplers)
- props.setProperty("somename", "someString")
- __setProperty("name", "value")
- String value = props.getProperty("somename")
- String value = __property("somename")
- References
Configuration Element
- HTTP Defaults
- HTTP Cookie Manager
- JDBC Connection Configuration
Workbench
- The workbench is a place where elements of the test plan can be temporarily stored while not in use
- certain test elements are only available on it
- HTTP(S) Test Script Recorder
- HTTP Mirror Server
- Property Display
Build a Test using a Recorder
- JMeter Test Script Recorder
- Creates a Proxy in JMeter
- Proxy lets JMeter listen for incoming requests from a Browser
- Browser must be set up to use a proxy localhost:7000 for example
- Once JMeter and Browser are set up correctly
- Actions taken in the browser are recorded by JMeter
- Allows a simple test plan to be recorded
- This can then be made more complex
- Creates a Proxy in JMeter
- Hands on Exercise - Use a Recorder to Build a Test Plan
- Using the following document set up the recorder in JMeter and install a Foxyproxy add-on in Chrome, Firefox, or IE to allow proxy definition. After setting up JMeter and the Browser explore the various options in the Test Script Recorder to see the recording variations. Take the recorded requests and build them into a test plan that uses View Results Tree and Graph results listeners.
- Note: It is important to make sure that your web browser has not cached the pages you are going to visit. If they are cached then the cache copy will be used and there will not be a request going through the JMeter proxy. This will cause the page request to not be recorded by JMeter (the cached copy will be used instead). Go into your browser's options or settings and clear the cache.
Using a Proxy with a Proxy If you already have a company proxy and need to use JMeter as the proxy for recording see this article
Recording How To
- References:
Load Test Mobile Apps
- The basic steps are:
- Record a Mobile Device using JMeter as the proxy as per the discussion in the previous section
- Note that the mobile device and computer running JMeter have to be on the same subnet
- The mobile device should not be on Cellular Data it should be on Wireless so it is on the network
- Change the recording into a test plan
- Set the bandwidth for the test using the article in the references
- Run the test plan, most likely in a master slave distributed environment
- Note the device designation in the Header Managers
- Record a Mobile Device using JMeter as the proxy as per the discussion in the previous section
Build a Test for a Form
- HTML Form parameters can be simulated by JMeter
- Using a HTTP Request Sampler
- Host and port are given by the server location, i.e. localhost and 8080
- Path reference is the HTML Form action parameter
- Using a HTTP Request Sampler
- The results can be checked using an Assertion
- Most likely a Response Assertion
- A JSR223 Assertion could also be used
- JSR223 requires programming of the assertion code
- Assertion failure use AssertionResult.setFailure(true);
- Assertion success use AssertionResult.setFailure(false);
Login in a Test
- To test a login the following must be known
- Is the site using cookies to determine the user and whether they have logged in
- Is it a special cookie or one such as JSESSIONID that is keeping track of the session
- What is Session on a web server?
- References
- What is the URL of the page that will receive the login request
- The HTML form's action URL
- Not the URL of the page that has the input form (that shows the username and password textboxes)
- What are the names of the input textboxes for username and password
- These will go into the parameters of the HTTP Request along with their values
Hands on Exercise - Test a Login Page:
- Part 1
- Find the names of the input textboxes and the form action for a login page on the web
- Use a page that you are aware of such as Amazon.com or a page used by your company or organization
- Part 2
- Look over the Java Server Pages userForm.jsp, actionPage.jsp, and anotherPage.jsp in Eclipse
- They are under WebContent in the web project
- Determine how the login will work.
- Build a test plan that uses the Cookie Manager, and HTTP Request Defaults configurations along with a Thread Group, HTTP Requests, Assertions, and Listeners to test the login
- Export a WAR file to your Tomcat webapps folder
- Start Tomcat using startup.bat
- Test the login page with JMeter and see if you go correctly to the "anotherPage.jsp
- Look at the cookies in the Cookie Manager to see how the login works with Cookies.
Build a ForEach Loop
- This uses a ForEach Controller
- References
- Hands on Exercise:
- Using the first 7 lessons in the Regular Expression Interactive Tutorial (above) determine what strings match expression
- <a href="([^"]+)"
- Hands on Exercise:
- Hands on Exercise
- Add a ForEach Controller to your test plan using a Module Controller and a Test Fragment.
- Use the example at link ForEachTestPlan
- Right click on the link and save it into an examples folder
- Start a second JMeter and use it to open and copy the elements needed
- Create a Test Fragment and paste the copied elements into it
- Create an Module Controller under the Thread Group
- Use the example at link ForEachTestPlan
- Add a ForEach Controller to your test plan using a Module Controller and a Test Fragment.
- Hands on Exercise
Using JSR223 and Java
- JSR223 defines an interface between Java and Scripting Languages
- It is a part of the Java Language
- It allows JMeter which is written in Java to work with Scripting Languages
- JSR223 can be used with Samplers, Pre-Processors, and Post-Processors
- It also allows these to work with Java code
- Hands On Exercise
- Retrieve the zip file at the end of this document and save it
- Extract the contents into the JMeter folder (from the installation of JMeter)
- Open JMeter
- From JMeter open the test plan "Everything and More.jmx"
- Look over and experiment with the JSR223 samplers present in that example
JSR223 Get Sampler Response
- JSR223 Can provide a more complex anaylsis of responses
- To check certain elements such as links
- To check for attributes or tokens on URLs
- To parse for various embedded resources
- To save all or part of the response to a file
- How to get the response using scripting components such as Beanshell or JSR223
- Which ones have this access to the sampler's response (SampleResult)?
- They would need to be children of the sampler
- Look at Post-Processors, Pre-Processors or Assertions
- Assertions have access to SampleResult
- Pre-Processors do not have access they occur before the response happens
- Post-Processors do not have access to SampleResult
- Which ones have this access to the sampler's response (SampleResult)?
- Get the SampleResult using a JSR223 assertion
- The assertion is a child of the sampler
- SampleResult is available as an implicit variable
- It is available to the assertion code that the user writes
An Example where the SampleResult is printed to the console
//print out the Sampler's Response and set the Assertion Result failure to false
String response = SampleResult.getResponseDataAsString();
System.out.println("**********************************************The response data was");
System.out.println(response);
System.out.println("**********************************************The response data end");
AssertionResult.setFailure(false);
- Hands on Exercise
- Start a new test plan
- Put in a Thread Group
- Put in an HTTP Request Sampler
- Put a JSR223 Assertion as the sampler child
- Set it to language Java
- Use import statements to import a FileWriter
- Get the SampleResult
- Print it to a file
Set up Eclipse for JSR223 Scripts
- Writing a script within JMeter is hard
- In a JSR223 Assertion using the text editor
- There are no context drop downs or error checking
- It would be better to write them in Eclipse and copy to JMeter
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx continue this and show how to set up in Eclipse with the JARS etc.
Identify Individual JMeter Threads
- Threadgroup number of threads
- Allows multiple JVM threads to be started
- How to identify each individual thread
- For example so that individual files can be written for each thread
- Perhaps using a JSR223 sampler
- Since the threads are running in the JVM the java Thread class can be used
- For example code in a JSR223 Sampler or Post-Processor might be:
Thread thread = Thread.currentThread();
//Debug using out.println
System.out.println("Runnable Job is being run by " + thread.getName() + " (" + thread.getId() + ")");
Long threadNum = thread.getId();
vars.putObject("threadNum", threadNum);
- Threads are scheduled
- placed on the running queue in the scheduler
- JMeter timers cause interrupts to threads
- placed on the waiting queue
- This can be seen with a test plan that incorporates a Uniform Random Timer
- with an HTTP Request with a JSR223 Post-Processor
- the Post-Processor has the code given above
- The results printed in the console will interleave printlns from the various threads
Build a While Loop
- This uses a While Controller
- While Controller stops on condition being the String "false"
- Something has to set a Variable (one way to control the looping) to the String "false"
- For example JSR223 Samplers could be used
- The code using Strings would be similar to
- Note the System.out.println statements that can be used for debugging
String theIndex = vars.get("index"); //gets value from JMeterVariables see Javadocs
int newCount = Integer.parseInt(theIndex) + 1;
System.out.println("************** newCount is " + newCount); //writes to the console
String count = "" + newCount;
vars.put("index", count); //puts value into JMeterVariables see Javadocs
if (newCount > 3) {
vars.put("continue", "false"); // stops the while loop
}
- The code using Strings and Integers would be similar to
Integer theCounter = (Integer)vars.getObject("counter");
System.out.println("\n****************** theCounter is " + theCounter);
theCounter = theCounter + 1;
System.out.println("****************** new theCounter is " + theCounter + "\n");
vars.putObject("counter", theCounter);
if (theCounter > 3) {
vars.put("continue", "false");
}
Build Test Fragments
- Using the Module Controller
- Test fragments can be put into a Test Plan outside the Thread Group
- placed at locations in the test plan using the module controller
- Using the include controller
- Build a test fragment in a test plan
- Save the test plan
- Include the fragment in another test plan using the include controller
Debugging Test Plans
- Debug Sampler - in user manual under miscellaneous components
- System.out.println to console from JSR223 (Sampler, Pre-Processor, or Post-Processor)
- Assertion Results - Listener
- Will show errors in the Assertions
- Error Messages in View Results Tree
- The element name in the left column turns red when there is an error
- Stacktraces in Console
- Stacktraces in log
- Errors can cause stacktraces which show up in the console
- Enable Debug logging Hints and tips look at Debug Logging
Connecting to a Database
- Testing a Database using JDBC
- Using SQL statements
- Elements needed are
- Thread Group
- JDBC Connection Configuration
- JDBC Request Sampler
- Other elements as needed, i.e. Listeners, assertions
- Questions to ask
- Is it more relevant to test the web pages that are populated by the database than the database itself?
- Is the database behind a firewall that will prevent connection?
- Hands on Exercise
- Create a JDBC test plan
- user the following elements (at a minimum)
- Thread Group
- JDBC request
- Summary Results
- View Results Tree
- Use the MySQL database that has been installed as the database to hit
- Use the usersdb database and test the users table
- Use a select statement - select * from users
The Build Database Test Plan section of the JMeter User's Manual give very good directions. It is listed below in the references
- References
HTTP Cookie Manager
- A configuration element
- Stores any cookies sent by the website
- Sends them back in any request made to the website
- Cookies being managed can be seen in the View Results Tree listener
- References:
- [http://blazemeter.com/blog/using-http-cookie-manager-jmeter-not-cookie-jar Blazemeter on Cookie Manager
Access Log Sampler with Writing of a jmx File (A Hard Example to Work on Together)
- The Access Log Sampler will read a tomcat access log and request all of the URLs in the log
- Gives a more realistic test plan that follows what users do with the website.
- However it cannot write the HTTP Request Samplers that could be included in a test plan
- Hands on Exercise
- Using an Access Log Sampler with a JSR223 Post Processor write a test plan that will read the access log and create a snippet of xml that can be included in another test plan using an Include Controller.
- Step 1 get a test plan running that uses a Access Log Sampler with a View Results tree and a child Simple Data Writer Listener
- Step 2 Determine the format of a jmx file for an HTTP Request so that we can write one of these
- Step 3 Create a JSR223 child of the Access Log Sampler
- Step 4 Figure out the java code that will get the path from the sampler variable, open a file, and write xml similar to the jmx sample for an HTTP Request sampler.
- Note that most groups doing this exercise counted the number of lines in the access log
- Then got to a while loop controlled by the number of lines in the file
- where the Access Log Sampler did its work
Distributed Test using Multiple Clients to hit Server
- JMeter can have a Master the controls multiple slaves
- Useful in stress testing so that the local network or laptop is not overloaded
- A laptop can simulate about 300 to 600 users before becoming overloaded
- better to use the laptop to control multiple other machines
- A stress test may want to simulate 1000s of users hitting the web server at the same time
- There must be a way of determining the server performance during the test
- For example JConsole or VisualVM (jvisualvm.exe on Windows)
- Is there a firewall?
- Both tools create Random RMI ports and therefore have a hard time with internal firewalls
- References
JMeter Plugins
- There are sets of plugins for JMeter.
- give new elements of the various types such as Assertions and Listeners
- Can integrate JMeter with tools such as Selenium/WebDriver
- Those from JMeter-plugins.org are
- Licensed under the Apache 2.0 License
- Free Software License
- References
Functional Testing
- Testing that the systems meets the requirements
- Does the system behave as it should
- Act like a user even making errors
- Black box and white box
- Black box - act as thought system internals are unknown, i.e. HTML Request where response is built from database
- White box - system internals are known, i.e. test a complex algorithm
- References
Regression Testing
- Determine whether the system still meets requirements after changes or bug fixes
- Rerun tests that deal with parts of the system not included in the changes
- References
Wikipedia on Regression Testing Whatis on Regression Testing
Stress Testing
- Putting a server or the software under stress to see whether it behaves with a large number of users
- Does the server get overloaded and response time suffers?
- Does a database get overloaded and fail or response time suffers?
- Does the software fail due to the load?
- Does the web server fail due to the load?
- Tools must be available to gauge the performance of the hardware and software
References
- Discussion of most JMeter Elements - JMeter Complete Element Reference
- Blazemeter Website has many tutorials and articles - Blazemeter Resources
- Apache JMeter Website - Apache JMeter User Manual
- Apache JMeter Website - Apache JMeter Javadocs
- TutorialsPoint has a good JMeter Tutorial - TutorialsPoint JMeter Tutorial
JMeter Example Files
The test plans below contain various types of debugging techniques, test plan elements, looping constructs, regular expressions, and other code that is somewhat hard to figure out when using JMeter test plans. They are examples to be discussed.
Sample code
<?xml version="1.0" encoding="UTF-8"?>
<jmeterTestPlan version="1.2" properties="2.8" jmeter="2.13 r1665067">
<hashTree>
<TestPlan guiclass="TestPlanGui" testclass="TestPlan" testname="Test Plan" enabled="true">
<stringProp name="TestPlan.comments"></stringProp>
<boolProp name="TestPlan.functional_mode">false</boolProp>
<boolProp name="TestPlan.serialize_threadgroups">false</boolProp>
<elementProp name="TestPlan.user_defined_variables" elementType="Arguments" guiclass="ArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
<collectionProp name="Arguments.arguments"/>
</elementProp>
<stringProp name="TestPlan.user_define_classpath"></stringProp>
</TestPlan>
<hashTree>
<ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="Thread Group" enabled="true">
<stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
<elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">
<boolProp name="LoopController.continue_forever">false</boolProp>
<stringProp name="LoopController.loops">1</stringProp>
</elementProp>
<stringProp name="ThreadGroup.num_threads">1</stringProp>
<stringProp name="ThreadGroup.ramp_time">1</stringProp>
<longProp name="ThreadGroup.start_time">1447770674000</longProp>
<longProp name="ThreadGroup.end_time">1447770674000</longProp>
<boolProp name="ThreadGroup.scheduler">false</boolProp>
<stringProp name="ThreadGroup.duration"></stringProp>
<stringProp name="ThreadGroup.delay"></stringProp>
</ThreadGroup>
<hashTree>
<ConfigTestElement guiclass="HttpDefaultsGui" testclass="ConfigTestElement" testname="HTTP Request Defaults" enabled="true">
<elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
<collectionProp name="Arguments.arguments"/>
</elementProp>
<stringProp name="HTTPSampler.domain">localhost</stringProp>
<stringProp name="HTTPSampler.port">8080</stringProp>
<stringProp name="HTTPSampler.connect_timeout"></stringProp>
<stringProp name="HTTPSampler.response_timeout"></stringProp>
<stringProp name="HTTPSampler.protocol"></stringProp>
<stringProp name="HTTPSampler.contentEncoding"></stringProp>
<stringProp name="HTTPSampler.path"></stringProp>
<stringProp name="HTTPSampler.concurrentPool">4</stringProp>
</ConfigTestElement>
<hashTree/>
<CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
<collectionProp name="CookieManager.cookies"/>
<boolProp name="CookieManager.clearEachIteration">false</boolProp>
</CookieManager>
<hashTree/>
<UniformRandomTimer guiclass="UniformRandomTimerGui" testclass="UniformRandomTimer" testname="Uniform Random Timer" enabled="true">
<stringProp name="ConstantTimer.delay">1000</stringProp>
<stringProp name="RandomTimer.range">4000.0</stringProp>
</UniformRandomTimer>
<hashTree/>
<HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="HTTP Request Login" enabled="true">
<elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
<collectionProp name="Arguments.arguments"/>
</elementProp>
<stringProp name="HTTPSampler.domain"></stringProp>
<stringProp name="HTTPSampler.port"></stringProp>
<stringProp name="HTTPSampler.connect_timeout"></stringProp>
<stringProp name="HTTPSampler.response_timeout"></stringProp>
<stringProp name="HTTPSampler.protocol"></stringProp>
<stringProp name="HTTPSampler.contentEncoding"></stringProp>
<stringProp name="HTTPSampler.path">Web_Project_1/userForm.jsp</stringProp>
<stringProp name="HTTPSampler.method">GET</stringProp>
<boolProp name="HTTPSampler.follow_redirects">true</boolProp>
<boolProp name="HTTPSampler.auto_redirects">false</boolProp>
<boolProp name="HTTPSampler.use_keepalive">true</boolProp>
<boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
<boolProp name="HTTPSampler.monitor">false</boolProp>
<stringProp name="HTTPSampler.embedded_url_re"></stringProp>
</HTTPSamplerProxy>
<hashTree/>
<HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="HTTP Request action page" enabled="true">
<elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
<collectionProp name="Arguments.arguments">
<elementProp name="name" elementType="HTTPArgument">
<boolProp name="HTTPArgument.always_encode">false</boolProp>
<stringProp name="Argument.value">${name}</stringProp>
<stringProp name="Argument.metadata">=</stringProp>
<boolProp name="HTTPArgument.use_equals">true</boolProp>
<stringProp name="Argument.name">name</stringProp>
</elementProp>
<elementProp name="password" elementType="HTTPArgument">
<boolProp name="HTTPArgument.always_encode">false</boolProp>
<stringProp name="Argument.value">mypassword</stringProp>
<stringProp name="Argument.metadata">=</stringProp>
<boolProp name="HTTPArgument.use_equals">true</boolProp>
<stringProp name="Argument.name">password</stringProp>
</elementProp>
</collectionProp>
</elementProp>
<stringProp name="HTTPSampler.domain"></stringProp>
<stringProp name="HTTPSampler.port"></stringProp>
<stringProp name="HTTPSampler.connect_timeout"></stringProp>
<stringProp name="HTTPSampler.response_timeout"></stringProp>
<stringProp name="HTTPSampler.protocol"></stringProp>
<stringProp name="HTTPSampler.contentEncoding"></stringProp>
<stringProp name="HTTPSampler.path">Web_Project_1/actionPage.jsp</stringProp>
<stringProp name="HTTPSampler.method">GET</stringProp>
<boolProp name="HTTPSampler.follow_redirects">true</boolProp>
<boolProp name="HTTPSampler.auto_redirects">false</boolProp>
<boolProp name="HTTPSampler.use_keepalive">true</boolProp>
<boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
<boolProp name="HTTPSampler.monitor">false</boolProp>
<stringProp name="HTTPSampler.embedded_url_re"></stringProp>
</HTTPSamplerProxy>
<hashTree/>
<HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="HTTP Request another page" enabled="true">
<elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
<collectionProp name="Arguments.arguments"/>
</elementProp>
<stringProp name="HTTPSampler.domain"></stringProp>
<stringProp name="HTTPSampler.port"></stringProp>
<stringProp name="HTTPSampler.connect_timeout"></stringProp>
<stringProp name="HTTPSampler.response_timeout"></stringProp>
<stringProp name="HTTPSampler.protocol"></stringProp>
<stringProp name="HTTPSampler.contentEncoding"></stringProp>
<stringProp name="HTTPSampler.path">Web_Project_1/anotherPage.jsp</stringProp>
<stringProp name="HTTPSampler.method">GET</stringProp>
<boolProp name="HTTPSampler.follow_redirects">true</boolProp>
<boolProp name="HTTPSampler.auto_redirects">false</boolProp>
<boolProp name="HTTPSampler.use_keepalive">true</boolProp>
<boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
<boolProp name="HTTPSampler.monitor">false</boolProp>
<stringProp name="HTTPSampler.embedded_url_re"></stringProp>
</HTTPSamplerProxy>
<hashTree/>
<ResultCollector guiclass="ViewResultsFullVisualizer" testclass="ResultCollector" testname="View Results Tree" enabled="true">
<boolProp name="ResultCollector.error_logging">false</boolProp>
<objProp>
<name>saveConfig</name>
<value class="SampleSaveConfiguration">
<time>true</time>
<latency>true</latency>
<timestamp>true</timestamp>
<success>true</success>
<label>true</label>
<code>true</code>
<message>true</message>
<threadName>true</threadName>
<dataType>true</dataType>
<encoding>false</encoding>
<assertions>true</assertions>
<subresults>true</subresults>
<responseData>false</responseData>
<samplerData>false</samplerData>
<xml>false</xml>
<fieldNames>false</fieldNames>
<responseHeaders>false</responseHeaders>
<requestHeaders>false</requestHeaders>
<responseDataOnError>false</responseDataOnError>
<saveAssertionResultsFailureMessage>false</saveAssertionResultsFailureMessage>
<assertionsResultsToSave>0</assertionsResultsToSave>
<bytes>true</bytes>
<threadCounts>true</threadCounts>
</value>
</objProp>
<stringProp name="filename"></stringProp>
</ResultCollector>
<hashTree/>
</hashTree>
</hashTree>
</hashTree>
</jmeterTestPlan>
<?xml version="1.0" encoding="UTF-8"?>
<jmeterTestPlan version="1.2" properties="2.7" jmeter="2.12 r1636949">
<hashTree>
<TestPlan guiclass="TestPlanGui" testclass="TestPlan" testname="Test Plan" enabled="true">
<stringProp name="TestPlan.comments"></stringProp>
<boolProp name="TestPlan.functional_mode">false</boolProp>
<boolProp name="TestPlan.serialize_threadgroups">false</boolProp>
<elementProp name="TestPlan.user_defined_variables" elementType="Arguments" guiclass="ArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
<collectionProp name="Arguments.arguments"/>
</elementProp>
<stringProp name="TestPlan.user_define_classpath"></stringProp>
</TestPlan>
<hashTree>
<ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="Thread Group" enabled="true">
<stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
<elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">
<boolProp name="LoopController.continue_forever">false</boolProp>
<stringProp name="LoopController.loops">1</stringProp>
</elementProp>
<stringProp name="ThreadGroup.num_threads">1</stringProp>
<stringProp name="ThreadGroup.ramp_time">1</stringProp>
<longProp name="ThreadGroup.start_time">1437060734000</longProp>
<longProp name="ThreadGroup.end_time">1437060734000</longProp>
<boolProp name="ThreadGroup.scheduler">false</boolProp>
<stringProp name="ThreadGroup.duration"></stringProp>
<stringProp name="ThreadGroup.delay"></stringProp>
</ThreadGroup>
<hashTree>
<HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="HTTP Request" enabled="true">
<elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
<collectionProp name="Arguments.arguments"/>
</elementProp>
<stringProp name="HTTPSampler.domain">localhost</stringProp>
<stringProp name="HTTPSampler.port">8080</stringProp>
<stringProp name="HTTPSampler.connect_timeout"></stringProp>
<stringProp name="HTTPSampler.response_timeout"></stringProp>
<stringProp name="HTTPSampler.protocol"></stringProp>
<stringProp name="HTTPSampler.contentEncoding"></stringProp>
<stringProp name="HTTPSampler.path">/Web_Project_1/userForm.jsp</stringProp>
<stringProp name="HTTPSampler.method">GET</stringProp>
<boolProp name="HTTPSampler.follow_redirects">true</boolProp>
<boolProp name="HTTPSampler.auto_redirects">false</boolProp>
<boolProp name="HTTPSampler.use_keepalive">true</boolProp>
<boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
<boolProp name="HTTPSampler.monitor">false</boolProp>
<stringProp name="HTTPSampler.embedded_url_re"></stringProp>
</HTTPSamplerProxy>
<hashTree/>
<HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="HTTP Request" enabled="true">
<elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
<collectionProp name="Arguments.arguments">
<elementProp name="name" elementType="HTTPArgument">
<boolProp name="HTTPArgument.always_encode">false</boolProp>
<stringProp name="Argument.value">Donald</stringProp>
<stringProp name="Argument.metadata">=</stringProp>
<boolProp name="HTTPArgument.use_equals">true</boolProp>
<stringProp name="Argument.name">name</stringProp>
</elementProp>
<elementProp name="password" elementType="HTTPArgument">
<boolProp name="HTTPArgument.always_encode">false</boolProp>
<stringProp name="Argument.value">mypassword</stringProp>
<stringProp name="Argument.metadata">=</stringProp>
<boolProp name="HTTPArgument.use_equals">true</boolProp>
<stringProp name="Argument.name">password</stringProp>
</elementProp>
</collectionProp>
</elementProp>
<stringProp name="HTTPSampler.domain"></stringProp>
<stringProp name="HTTPSampler.port"></stringProp>
<stringProp name="HTTPSampler.connect_timeout"></stringProp>
<stringProp name="HTTPSampler.response_timeout"></stringProp>
<stringProp name="HTTPSampler.protocol"></stringProp>
<stringProp name="HTTPSampler.contentEncoding"></stringProp>
<stringProp name="HTTPSampler.path">/Web_Project_1/actionPage.jsp</stringProp>
<stringProp name="HTTPSampler.method">GET</stringProp>
<boolProp name="HTTPSampler.follow_redirects">true</boolProp>
<boolProp name="HTTPSampler.auto_redirects">false</boolProp>
<boolProp name="HTTPSampler.use_keepalive">true</boolProp>
<boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
<boolProp name="HTTPSampler.monitor">false</boolProp>
<stringProp name="HTTPSampler.embedded_url_re"></stringProp>
</HTTPSamplerProxy>
<hashTree/>
<HTTPSamplerProxy guiclass="HttpTestSampleGui" testclass="HTTPSamplerProxy" testname="HTTP Request" enabled="true">
<elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
<collectionProp name="Arguments.arguments"/>
</elementProp>
<stringProp name="HTTPSampler.domain"></stringProp>
<stringProp name="HTTPSampler.port"></stringProp>
<stringProp name="HTTPSampler.connect_timeout"></stringProp>
<stringProp name="HTTPSampler.response_timeout"></stringProp>
<stringProp name="HTTPSampler.protocol"></stringProp>
<stringProp name="HTTPSampler.contentEncoding"></stringProp>
<stringProp name="HTTPSampler.path">/Web_Project_1/anotherPage.jsp</stringProp>
<stringProp name="HTTPSampler.method">GET</stringProp>
<boolProp name="HTTPSampler.follow_redirects">true</boolProp>
<boolProp name="HTTPSampler.auto_redirects">false</boolProp>
<boolProp name="HTTPSampler.use_keepalive">true</boolProp>
<boolProp name="HTTPSampler.DO_MULTIPART_POST">false</boolProp>
<boolProp name="HTTPSampler.monitor">false</boolProp>
<stringProp name="HTTPSampler.embedded_url_re"></stringProp>
</HTTPSamplerProxy>
<hashTree/>
<UniformRandomTimer guiclass="UniformRandomTimerGui" testclass="UniformRandomTimer" testname="Uniform Random Timer" enabled="true">
<stringProp name="ConstantTimer.delay">2000</stringProp>
<stringProp name="RandomTimer.range">3000</stringProp>
</UniformRandomTimer>
<hashTree/>
<ResultCollector guiclass="ViewResultsFullVisualizer" testclass="ResultCollector" testname="View Results Tree" enabled="true">
<boolProp name="ResultCollector.error_logging">false</boolProp>
<objProp>
<name>saveConfig</name>
<value class="SampleSaveConfiguration">
<time>true</time>
<latency>true</latency>
<timestamp>true</timestamp>
<success>true</success>
<label>true</label>
<code>true</code>
<message>true</message>
<threadName>true</threadName>
<dataType>true</dataType>
<encoding>false</encoding>
<assertions>true</assertions>
<subresults>true</subresults>
<responseData>false</responseData>
<samplerData>false</samplerData>
<xml>false</xml>
<fieldNames>false</fieldNames>
<responseHeaders>false</responseHeaders>
<requestHeaders>false</requestHeaders>
<responseDataOnError>false</responseDataOnError>
<saveAssertionResultsFailureMessage>false</saveAssertionResultsFailureMessage>
<assertionsResultsToSave>0</assertionsResultsToSave>
<bytes>true</bytes>
<threadCounts>true</threadCounts>
</value>
</objProp>
<stringProp name="filename"></stringProp>
</ResultCollector>
<hashTree/>
<ConfigTestElement guiclass="HttpDefaultsGui" testclass="ConfigTestElement" testname="HTTP Request Defaults" enabled="true">
<elementProp name="HTTPsampler.Arguments" elementType="Arguments" guiclass="HTTPArgumentsPanel" testclass="Arguments" testname="User Defined Variables" enabled="true">
<collectionProp name="Arguments.arguments"/>
</elementProp>
<stringProp name="HTTPSampler.domain">localhost</stringProp>
<stringProp name="HTTPSampler.port">8080</stringProp>
<stringProp name="HTTPSampler.connect_timeout"></stringProp>
<stringProp name="HTTPSampler.response_timeout"></stringProp>
<stringProp name="HTTPSampler.protocol"></stringProp>
<stringProp name="HTTPSampler.contentEncoding"></stringProp>
<stringProp name="HTTPSampler.path"></stringProp>
<stringProp name="HTTPSampler.concurrentPool">4</stringProp>
</ConfigTestElement>
<hashTree/>
<CookieManager guiclass="CookiePanel" testclass="CookieManager" testname="HTTP Cookie Manager" enabled="true">
<collectionProp name="CookieManager.cookies"/>
<boolProp name="CookieManager.clearEachIteration">false</boolProp>
</CookieManager>
<hashTree/>
</hashTree>
</hashTree>
</hashTree>
</jmeterTestPlan>
