All Classes and Interfaces
Class
Description
About Command.
This is the base class for JMeter GUI components which manage assertions.
An abstract implementation of the BackendListenerClient interface.
This is the base class for JMeter GUI components which provide configuration
for some other component.
This is the base class for JMeter GUI components which manage controllers.
Provides common methods for all functions
An abstract implementation of the JavaSamplerClient interface.
As pre- and post-processors essentially do the same this class provides the implementation.
A base class for all JDBC test elements handling the basics of a SQL request.
This abstract class takes care of the most basic functions necessary to
create a viable JMeter GUI component.
Base class for Listeners
Basic Listener/Visualiser Gui class to correspond with AbstractPreProcessorGui etc.
This is the base class for JMeter GUI components which manage PostProcessors.
Abstract Random timer GUI.
Base class for SamplerCreator
This is the base class for JMeter GUI components which manage samplers.
Base class for SampleSender implementations
Super-class for all Assertions that can be applied to main sample, sub-samples or both.
Super-class for TestElements that can be applied to main sample, sub-samples or both.
Basic implementation of TCPClient interface.
This is the BeanInfo object for the AbstractTestElement class.
ThreadGroup holds the settings for a JMeter thread group.
This is the base class for JMeter GUI components which manage timers.
This is the base class for JMeter GUI components which can display test
results in some way.
Description:
AccessLogSampler is responsible for a couple of things: creating instances of Generator creating instances of Parser triggering popup windows calling Generator.generateRequest() checking to make sure the classes are valid making sure a class can be instantiated The intent of this sampler is it uses the generator and parser to create a HTTPSampler when it is needed.
AccessLogSampler is responsible for a couple of things: creating instances of Generator creating instances of Parser triggering popup windows calling Generator.generateRequest() checking to make sure the classes are valid making sure a class can be instantiated The intent of this sampler is it uses the generator and parser to create a HTTPSampler when it is needed.
Implements the Add Parent menu command
Selector for the AJP/1.3 protocol
(i.e. what Tomcat uses with mod_jk)
It allows you to test Tomcat in AJP mode without
actually having Apache installed and configured
Class representing an argument.
Decodes an Argument by replacing '\x' with 'x'
Encode an Argument
A set of Argument objects.
A GUI panel allowing the user to enter name-value argument pairs.
An Assertion checks a SampleResult to determine whether or not it is
successful.
GUI interface for a
ResponseAssertion.Implements Response Assertion checking.
Sends samples in a separate Thread and in Batch mode
This class provides a way to provide Authorization in jmeter requests.
This class is an Authorization encapsulator.
Handles input for determining if authentication services are required for a
Sampler.
Axis graph is used by StatGraphVisualizer, which generates bar graphs
from the statistical data.
Async Listener that delegates SampleResult handling to implementations of
BackendListenerClientThis interface defines the interactions between the BackendListener and external
Java programs which can be executed by JMeter.
BackendListenerContext is used to provide context information to a
BackendListenerClient implementation.
The
BackendListenerGui class provides the user interface for the
BackendListener object.This class provides an implementation of Base64 encoding without relying on
the the sun.* packages.
BaseJMSSampler is an abstract class which provides implementation for common
properties.
Implements batch reporting for remote testing.
Support class for test bean beanInfo objects.
A function which understands BeanShell
An Assertion which understands BeanShell
Parent class to handle common GUI design
Implements a client that can talk to the JMeter BeanShell server.
BeanShell setup function - encapsulates all the access to the BeanShell
Interpreter in a single class.
A sampler which understands BeanShell
Implements a BeanShell server to allow access to JMeter variables and
methods.
TCPClient implementation.
Property Editor which handles Boolean properties.
Parent class to handle common GUI design for BSF test elements
This is the interface to Netscape's Rhino (JavaScript) from the
Bean Scripting Framework.
A sampler which understands BSF
BSF Sampler Bean Info
Handles HTTP Caching
The GUI for the HTTP Cache Manager
Provides storage of samples in addition to calculations
Class to calculate various items that don't require all previous results to be saved:
mean = average
standard deviation
minimum
maximum
Implements the Add Parent menu command
Function to generate chars from a list of decimal or hex values
Check if the TestPlan has been changed since it was last saved
This class finds classes that extend one of a set of parent classes
Utility methods for handling dynamic access to classes.
Handles the following actions:
- Clear (Data)
- Clear All (Data)
- Reset (Clear GUI)
Identifies an object which supports the clearing of run-time data
using the clearData() method.
Class to run remote tests from the client JMeter and collect remote samples
ClientPool holds the client instances in an ArrayList.
This command clears the existing test plan, allowing the creation of a New
test plan.
Processes the Collapse All and Expand All options.
This class contains the static utility methods to manipulate colors.
Generic comment panel for Test Elements
This class is a Util for awt Component and could be used to place them in
center of an other.
CompoundFunction.
Interface that gives a hint about the merge policy to apply between Samplers and Config elements
Constants for the custom DocumentHandler.
This class implements a constant throughput timer.
This enum defines the calculation modes used by the ConstantThroughputTimer.
BeanInfo for the ConstantThroughputTimer.
This class implements a constant timer with its own panel and fields for
value update and user interaction.
The GUI for ConstantTimer.
This interface is used by JMeterThread in the following manner:
Utility conversion routines for use with XStream
General purpose conversion utilities related to HTTP/HTML
Converter utilities for TestBeans
Converts the Remoteable Test and Sample Listeners in the test tree by wrapping
them with RemoteSampleListeners so that the samples are returned to the client.
This class is a Cookie encapsulator.
Interface to be implemented by CookieHandler
This class provides an interface to the netscape cookies file to pass cookies
along with a request.
This is the GUI for Cookie Manager
Allows the user to specify if she needs cookie services, and give parameters
for this service.
Implements the Copy menu command
Provides a counter per-thread(user) or per-thread group.
Utility-class to calculate message size.
Generate appropriate pauses for a given CPS (characters per second)
This is a Critical Section Controller; it will execute the set of statements
(samplers/controllers, etc) under named lock.
The user interface for a controller which specifies that its subcomponents
should be executed while a condition holds.
Read lines from a file and split int variables.
The function represented by this class allows data to be read from CSV files.
This class provides a means for saving/reading test results as CSV files.
Custom TrustManager ignores all certificate errors
TODO: implement conditional checking and logging
(Derived from AuthSSLX509TrustManager in HttpClient contrib directory)
Implements the Cut menu item command
Web daemon thread.
Use this class to store database-like data.
The standard remote sample reporting should be more friendly to the main purpose of
remote testing - which is scalability.
Debugging Post-Processor: creates a subSample containing the variables defined in the previous sampler.
The Debug Sampler can be used to "sample" JMeter variables, JMeter properties and System Properties.
Default implementation that handles classical HTTP textual + Multipart requests
Version of HoldSampleSender that stores the samples on disk as a serialised stream.
This class serves all responsibility of starting and stopping distributed tests.
New graph for drawing distribution graph of the results.
This class implements the visualizer for displaying the distribution graph.
This config element provides ability to have flexible control over DNS
caching function.
This gui part of @see
DNSCacheManager.The purpose of this class is to cache the DOM Documents in memory and by-pass
parsing.
Implements the Duplicate menu command
Checks if an Sample is sampled within a specified time-frame.
GUI for
DurationAssertionThis is a basic URL classloader for loading new resources
dynamically.
Implements the Edit menu item.
Implements the Enable menu item.
Function which escapes the characters in a
String using HTML entities.Escape ORO meta characters
Function to evaluate a string which may contain variable or function references.
Function to evaluate a string which may contain variable or function references.
This TestBean is just an example about how to write testbeans.
This TestBean is just an example about how to write testbeans.
This TestBean is just an example of the use of different TestBean types.
Example Sampler (non-Bean version)
JMeter creates an instance of a sampler class for every occurrence of the
element in every thread.
Example Sampler (non-Bean version)
This class is responsible for ensuring that the Sampler data is kept in step
with the GUI.
CSS/JQuery based extractor for HTML pages
Class implementing a file open dialogue
A property editor for File properties.
This class loads data from a saved file and displays statistics about it.
File data container for CSV (and similar delimited) files Data is accessible
via row and column number
The point of this class is to provide thread-safe access to files, and to
provide some simplifying assumptions about where to find files and how to
name them.
FileToString Function to read a complete file into a String.
This class wraps the FileRowColContainer for use across multiple threads.
Description:
Filter interface is designed to make it easier to use Access Logs for JMeter test plans.
Filter interface is designed to make it easier to use Access Logs for JMeter test plans.
HashTreeTraverser implementation that stores in a Stack all
the Test Elements on the path to a particular node.
Request/reply executor with a fixed reply queue.
ForeachController that iterates over a list of variables named XXXX_NN stored in
JMeterVariables
where NN is a number starting from 1 to number of occurences.The user interface for a foreach controller which specifies that its
subcomponents should be executed some number of times in a loop.
A parser for html, to find the form tags, and their accept-charset value
A sampler which understands FTP file requests.
Methods that a function must implement
Class that implements the Function property
Implements function call-backs.
This class implements those methods needed by RandomTimer to be instantiable
and implements a random delay with an average value and a gaussian
distributed variation.
Implementation of a gaussian random timer.
Description:
Generator is a base interface that defines the minimum methods needed to implement a concrete generator.
Generator is a base interface that defines the minimum methods needed to implement a concrete generator.
This class is the basis for all the controllers.
The GenericTestBeanCustomizer is designed to provide developers with a
mechanism to quickly implement GUIs for new components.
Implements a simple graph for displaying performance results.
Graphite based Listener using Pickle Protocol
This class implements a statistical analyser that calculates both the average
and the standard deviation of the sampling process and outputs them as
autoscaling plots.
Provides a way to register and retrieve GUI classes and icons.
GuiPackage is a static class that provides convenient access to information
about the current state of JMeter's GUI.
This class is used to create a tree structure of objects.
By implementing this interface, a class can easily traverse a HashTree
object, and be notified via callbacks of certain events.
HTTPClient 3.1 implementation
Apache HttpClient protocol factory to generate SSL sockets
This class is an HTTP Header encapsulator.
Renders items in a JTable by converting from resource names.
This class provides an interface to headers file to pass HTTP headers along
with a request.
Allows the user to specify if she needs HTTP header services, and give
parameters for this service.
Class allowing access to Sun's heapDump method (Java 1.6+).
Implements the Help menu item.
Lars-Erik Helander provided the idea (and original implementation) for the
caching functionality (sampleStore).
Assertion to validate the response of a Sample with Tidy.
GUI for HTMLAssertion
CSS/JQuery Expression Extractor Post-Processor GUI
Implements an HTML Pane with local hyperlinking enabled.
Error class for use with HTMLParser classes.
Exception class for use with HTMLParser classes.
HtmlParsers can parse HTML content to obtain URLs.
Base class for HTTP implementations used by the HTTPSamplerProxy sampler.
A GUI panel allowing the user to enter HTTP Parameters.
Constants used in HTTP, mainly header names.
Constants used in HTTP, mainly header names.
Class representing a file parameter for http upload.
A set of HTTPFileArg objects.
A GUI panel allowing the user to enter file information for http upload.
HTTP Sampler which can read from file: URLs
HTTP sampler using Apache (Jakarta) Commons HttpClient 3.1.
HTTP Sampler using Apache HttpClient 4.x.
Common parent class for HttpClient implementations.
A sampler which understands all the parts necessary to read statistics about
HTTP requests, including cookies and authentication.
Test element that implements the Workbench HTTP Mirror function
Server daemon thread.
Thread to handle one client request.
Utility class to generate HTTP responses of various types.
The headers of the client HTTP request.
Class for XStream conversion of HTTPResult
A sampler which understands all the parts necessary to read statistics about
HTTP requests, including cookies and authentication.
A sampler which understands all the parts necessary to read statistics about
HTTP requests, including cookies and authentication.
Common constants and methods for HTTP samplers
This is the BeanInfo class for the TestBean HTTPSamplerBase.
Class for XStream conversion of HTTPResult
This is a specialisation of the SampleResult class for the HTTP protocol.
Factory to return the appropriate HTTPSampler for use with classes that need
an HTTPSampler; also creates the implementations for use with HTTPSamplerProxy.
Proxy class that dispatches to the appropriate HTTP sampler.
Derived from EasySSLProtocolFactory
Used by JsseSSLManager to set up the Commons HttpClient and Java https socket handling
HTTP Sampler GUI
WebDav request
This is a Conditional Controller; it will execute the set of statements
(samplers/controllers, etc) while the 'condition' is true.
The user interface for a controller which specifies that its subcomponents
should be executed while a condition holds.
TODO - interface is used but getImage() does not appear to be used
InitialContextFactory is responsible for getting an instance of the initial context.
Property Editor which handles Integer properties.
Alternate among each of the children controllers or samplers for each loop iteration
Samplers which are able to interrupt a potentially long-running operation should
implement this interface.
Provides an intSum function that adds two or more integer values.
Counter that can be referenced anywhere in the Thread Group.
The
JavaConfig class contains the configuration data necessary
for the Java protocol.The
JavaConfigGui class provides the user interface for the
JavaConfig object.A sampler for executing custom Java code in each sample.
This interface defines the interactions between the JavaSampler and external
Java programs which can be executed by JMeter.
JavaSamplerContext is used to provide context information to a
JavaSamplerClient implementation.
javaScript function implementation that executes a piece of JavaScript (not Java!)
The
JavaTest class is a simple sampler which is intended for
use when developing test plans.The
JavaTestSamplerGui class provides the user interface for
the JavaSampler.This is Date mask control.
Post processor handling JDBC Requests
Preprocessor handling JDBC Requests
A sampler which understands JDBC database requests.
A function which understands Commons JEXL2
A function which understands Commons JEXL
JLabeledRadioI18N creates a set of Radio buttons with a label.
A Helper component that wraps a JTextField with a label into a JPanel (this).
A Helper component that wraps a JTextField with a label into a JPanel (this).
Main JMeter class; processes options and starts the GUI, non-GUI or server as appropriate.
Class to render the test tree - sets the enabled/disabled versions of the icons
Holds context for a thread.
Provides context service for JMeter threads.
This interface is implemented by classes that can run JMeter tests.
Exception class for use by
JMeterEngine.runTest() and RemoteJMeterEngine.rrunTest()The rationale for this class was originally to support chained Errors in JDK 1.3
However, the class is now used in its own right.
The rationale for this class was originally to support chained Exceptions in JDK 1.3
However, the class is now used in its own right.
A file filter which allows files to be filtered based on a list of allowed
extensions.
Implementing this interface indicates that the class is a JMeter GUI
Component.
Use this Keystore for JMeter specific KeyStores.
This Exception is for use by functions etc to signal a Stop Test condition
where there is no access to the normal stop method
This Exception is for use by functions etc to signal a Stop Test Now condition
where there is no access to the normal stop method
This Exception is for use by functions etc to signal a Stop Thread condition
where there is no access to the normal stop method
The JMeter interface to the sampling process, allowing JMeter to see the
timing, add listeners for sampling events and to stop the sampling process.
The JMeter main toolbar class
Simple implementation of a transferable for
JMeterTreeNode arrays based on serialization.This class contains the static utility methods used by JMeter.
Class which defines JMeter variables.
Utility class to define the JMeter Version string
A set of JMSProperty objects.
Handles input for Jms Properties
JMS Property with type
This is the GUI for JMS Publisher
This class implements the JMS Point-to-Point sampler
Configuration screen for Java Messaging Point-to-Point requests.
This is the GUI for JMS Subscriber
This class contains frequently-used static utility methods.
Parser based on JSOUP
JSoup based CSS/JQuery extractor
see http://jsoup.org/cookbook/extracting-data/selector-syntax
Parent class to handle common GUI design for JSR223 test elements
The SSLManager handles the KeyStore information for JMeter.
Utility class to handle RSyntaxTextArea code
Utility class to handle RSyntaxTextArea code
This is a basic implementation that runs a single test method of
a JUnit test case.
The
JUnitTestSamplerGui class provides the user interface
for the JUnitSampler.Takes in charge Kerberos auth mechanism
Configure Keystore
Keystore Configuration BeanInfo
Utilities for working with Java keytool
Class representing an argument.
A set of LDAPArgument objects. author Dolf Smits(Dolf.Smits@Siemens.com)
created Aug 09 2003 11:00 AM company Siemens Netherlands N.V..
A GUI panel allowing the user to enter name-value argument pairs.
Ldap Client class is main class to create, modify, search and delete all the
LDAP functionality available.
This class LdapConfigGui is user interface gui for getting all the
configuration values from the user.
Ldap Client class is main class to create ,modify, search and delete all the
LDAP functionality available
This class LdapConfigGui is user interface gui for getting all the
configuration value from the user
Ldap Sampler class is main class for the LDAP test.
author Dolf Smits(Dolf.Smits@Siemens.com) created Aug 09 2003 11:00 AM
company Siemens Netherlands N.V..
Ldap Sampler class is main class for the LDAP test.
Implements binary length-prefixed binary data.
Axis graph is used by StatGraphVisualizer, which generates bar graphs
from the statistical data.
ListedHashTree is a different implementation of the
HashTree
collection class.Processes sample events.
ListenerResultWrapper is for calculated results generated by listeners like
aggregate listener and monitor listener.
Handles the Open (load a new file) and Merge commands.
Handles the loading of a file from a Drag and Drop action.
Handles the loading of recent files, and also the content and
visibility of menu items for loading the recent files
This class implements an SSLSocketFactory which supports a local truststore.
Description:
LogFilter is a basic implementation of Filter interface.
LogFilter is a basic implementation of Filter interface.
Function to log a message.
Function to log a message.
Panel that shows log events
Hide / unhide LoggerPanel.
Manages JMeter logging
A generic controller component.
A GUI component allowing the user to enter a username and password for a
login.
Description:
LogParser is the base interface for classes implementing concrete parse logic.
LogParser is the base interface for classes implementing concrete parse logic.
Property Editor which handles Long properties.
Provides a longSum function that adds two or more long values.
Implements the Look and Feel menu item.
Commons HttpClient protocol factory to generate Loopback HTTP sockets
Class that implements the Loop Controller, ie iterate infinitely or a configured number of times
The user interface for a controller which specifies that its subcomponents
should be executed some number of times in a loop.
An iteration event provides information about the iteration number and the
source of the event.
Allows a class to receive loop iteration start events.
Return Machine IP
Return Machine Host
The model for a MailerVisualizer.
This class implements a visualizer that mails a message when an error occurs.
Sampler that can read from POP3 and IMAP mail servers
The main JMeter frame, containing the menu bar, test tree, and an area for
JMeter component GUIs.
Adapter for
that wraps all connection requests into time-measured implementation a private
MeasuringConnectionRequest
invalid reference
PoolingClientConnectionManagerClass to hold additional information needed when building the GUI lists
A class that provides scrolling capabilities to a long menu dropdown or popup
menu.
Administration of messages.
The goal of ModuleController is to add modularity to JMeter.
ModuleControllerGui provides UI for configuring ModuleController element.
Public API to access MongoDB
object created by
invalid reference
DBMongoSourceElementMonitorGraph will draw the performance history of a given server.
The health panel is responsible for showing the health of the servers.
For performance reasons, I am using tabs for the visualizers.
Configuration element which handles HTTP Parameters and files to be uploaded
For JMeterProperties that hold multiple properties within, provides a simple
interface for retrieving a property iterator for the sub values.
Deprecated.
Main class for JMeter - sets up initial classpath and the loader.
Used by the Generic and Interleave controllers to signal the end of their samples
Implement this method-less interface to indicate that this ConfigElement should not be merged.
Implement this method-less interface to indicate your test element should not
be cloned for each thread in a test run.
A null property.
Renders numbers in a JTable with a specified format
Description:
ObjectFactory is a simple factory class which creates new instances of
objects.
The ObjectTableModel is a TableModel whose rows are objects;
columns are defined as Functors on the object.
Default config gui for Configuration Element.
This class restores the original Avalon XML format (not used by default).
Controller to run its children once per cycle.
This object defines with what a parameter has its value replaced, and the
policies for how that value changes.
This modifier will replace any single http sampler's url parameter value with
a value from a given range - thereby "masking" the value set in the http
sampler.
A swing panel to allow UI with the ParamModifier class.
This class implements a property editor for non-null String properties that
supports custom editing (i.e.: provides a GUI component) based on a text
field.
Places a copied JMeterTreeNode under the selected node.
This class implements those methods needed by RandomTimer to be instantiable
and implements a random delay with an average value and a Poisson
distributed variation.
Implementation of a Poisson random timer.
The PostProcessor is activated after a sample result has been generated.
PostThreadGroup is a special type of ThreadGroup that can be used for
performing actions at the end of a test for cleanup and such.
Class for setting the necessary headers for a POST request, and sending the
body of the POST.
Class to replace function and variable references in the test tree.
PreProcessors are executed just prior to a sample being run.
Printable is used by components that can be saved to an external file.
invalid reference
PrefixResolverFunction to get a JMeter property, and optionally store it
Parameters:
- property name
- variable name (optional)
- default value (optional)
Returns:
- the property value, but if not found:
- the default value, but if not defined:
- the property name itself
Function to get a JMeter property, or a default.
Thread to handle one client request.
Provides JMeter the ability to use proxy servers that require username and
password.
Class handles storing of generated samples, etc
This class implements the JMS Publisher sampler.
Class for setting the necessary headers for a PUT request, and sending the
body of the PUT.
Executor for (pseudo) synchronous communication.
Provides a Random function which returns a random long integer between a min
(first argument) and a max (second argument).
Controller that rans randomly one of it's children on each iteration
A controller that runs its children each at most once, but in a random order.
GUI for RandomOrderController.
Provides a RandomString function which returns a random String of length (first argument)
using characters (second argument)
This class implements a random timer with its own panel and fields for value
update and user interaction.
Renders a rate in a JTable.
Searcher implementation that searches text as is
Exception that contains partial response (Text read until exception occured)
Receiver of pseudo-synchronous reply messages.
Generic MessageConsumer class, which has two possible strategies.
Regular Expression Extractor Post-Processor GUI
Implements regular expression parsing of sample results and variables
Regexp search implementation
This component allows you to specify reference name of a regular expression that extracts names and values of HTTP request parameters.
GUI for
RegExUserParametersMarker interface used by ConvertListeners to determine which test elements to wrap
so that the results are processed by the client rather than the server
This is the interface for the RMI server engine, i.e.
This is the JMeter server main code.
Lars-Erik Helander provided the idea (and original implementation) for the
caching functionality (sampleStore).
Allows notification on events occurring during the sampling process.
Implementation of remote sampler listener, also supports TestStateListener
Interface notified when number of active threads changes
RMI Interface that allows notification of remote start/end of threads
RMI Implementation, client side code (ie executed on Controller)
Empty implementation only used to be able to do replacement by
ConvertListenersserver side wrapper, used to notify RMI client
Implements the Remove menu item.
Implement ResultsRender for CSS/JQuery tester
Implement ResultsRender for Regexp tester
Implement ResultsRender for XPath tester
Utility class for Renderers
This interface represents a controller that gets replaced during the
compilation phase of test execution in an arbitrary way.
Transforms strings into variable references (in spite of the name, which
suggests the opposite!)
Replaces a String containing functions with their Function properties equivalent, example:
${__time()}_${__threadNum()}_${__machineName()} will become a FunctionProperty of
a CompoundVariable containing 3 functions
Manipulate all classes which implements request view panel interface
and return a super panel with a bottom tab list of this classes
Interface for request panel in View Results Tree
All classes which implements this interface is display
on bottom tab in request panel
Specializer panel to view a HTTP request parsed
(historical) Panel to view request data
Reset Search
Test element to handle Response Assertions, @see AssertionGui
Bean to hold timing information about samples
Bean to represent information about a graph line
ResultAction - take action based on the status of the last Result
Create a Result Action Test Element
This class handles all saving of samples.
Helper class to allow TestResultWrapperConverter to send samples
directly to the visualiser if required.
Interface to results render
Save Result responseData to a set of files
This is mainly intended for validation tests
Create a ResultSaver test element, which saves the sample information in set
of files
Handles the Revert Project command.
Renders items in a JTable right-aligned
Show detail of a Row
Running sample data container.
Runtime Controller that runs its children until configured Runtime(s) is exceeded
The user interface for a controller which specifies that its subcomponents
should be executed some number of seconds in a loop.
Packages information regarding the target of a sample event, such as the
result from that event and the thread group it ran in.
XStream Converter for the SampleResult class
Allows notification on events occurring during the sampling process.
Packages methods related to sample handling.
A SamplePackage contains all elements associated to a Sampler: SampleListener(s) Timer(s) Assertion(s) PreProcessor(s) PostProcessor(s) ConfigTestElement(s) Controller(s)
A SamplePackage contains all elements associated to a Sampler: SampleListener(s) Timer(s) Assertion(s) PreProcessor(s) PostProcessor(s) ConfigTestElement(s) Controller(s)
Classes which are able to generate information about an entry should
implement this interface.
Factory of sampler
SamplerCreator factoryThis is a nice packaging for the various information returned from taking a
sample of an entry.
XStream Converter for the SampleResult class
Sampler metric
Function to return the name of the current sampler.
Right side in View Results Tree
For model table
Holds details of which sample attributes to save.
This interface is used to define the methods that need to be intercepted
by the SampleSender wrapper classes processed by the RemoteListenerWrapper.
Aggregate sample data container.
Save the current test plan; implements:
Save
Save TestPlan As
Save (Selection) As
SaveGraphics action is meant to be a generic reusable Action.
Class is responsible for taking a component and saving it as a JPEG, PNG or
TIFF.
Generates Configure pop-up dialogue for Listeners from all methods in SampleSaveConfiguration
with the signature "boolean saveXXX()".
Handles setting up XStream serialisation.
Scope panel so users can choose whether
to apply the test element to the parent sample, the child samples or both.
Parent class to define common GUI parameters for BSF and JSR223 test elements
Common parent class for the
BSFTestElement and JSR223TestElement scripting test elements.Handles XStream conversion of Test Scripts
Interface for nodes that are searchable.
Useful for finding all nodes in the tree that represent objects of a
particular type.
Search algorithm
Search nodes for a text
TODO Enhance search dialog to select kind of nodes ....
FIXME Why is searchTF not getting focus correctly after having been setVisible(false) once
Dialog used for Templates selection
This class performs all tasks necessary to send a message (build message,
prepare connection, send message).
Common server panel implementation for use with HTTP, TCP etc samplers
The purpose of ServerPanel is to display an unique server and its current
status.
Provides Session Filtering for the AccessLog Sampler.
Function to set a JMeter property
Parameters: - property name - value
Usage:
Set the property value in the appropriate GUI by using the string:
${__setProperty(propname,propvalue[,returnvalue?])}
SetupThreadGroup.java is a special type of ThreadGroup that can be used for
setting up of a test before the bulk of the test executes later.
Tagging interface to mark a customizer class as shareable among elements of
the same type.
Simple utility to send a shutdown message to a non-GUI instance of JMeter
Default config gui for Configuration Element.
This listener can record results to a file but not to the UI.
Checks if the results of a Sample matches a particular size.
GUI for
SizeAssertionThe
SleepTest class is a simple example class for a JMeter
Java protocol client.Apache HttpClient protocol factory to generate "slow" sockets for emulating dial-up modems
Apache HttpClient protocol factory to generate "slow" SSL sockets for emulating dial-up modems
Commons HttpClient protocol factory to generate "slow" sockets for emulating dial-up modems
InputStream wrapper to emulate a slow device, e.g. modem
OutputStream filter to emulate a slow device, e.g. modem
"Slow" (non-SSL) socket implementation to emulate dial-up modems etc
"Slow" SSLsocket implementation to emulate dial-up modems etc
WARNING: the class relies on overriding all superclass methods in order to apply them to the input socket.
Class to build gui-components for SMTP-sampler.
Sampler-Class for JMeter - builds, starts and interprets the results of the
sampler.
Class to build superstructure-gui for SMTP-panel, sets/gets value for a JMeter's testElement-object (i.e. also for save/load-purposes).
Commons HTTPClient based soap sampler
Bean to embed host/port to Graphite
Convenience class for writing bytes to a Socket.
Pool Factory of
SocketOutputStreamSortedHashTree is a different implementation of the
HashTree
collection class.This class implements the representation of an interpolated Spline curve.
This class implements a statistical analyser that takes samples to process a
Spline interpolated curve.
Function to split a string into variables
The SSLManager handles the KeyStore information for JMeter.
SSL Manager Command.
Description:
StandardGenerator will be the default generator used to pre-process logs.
StandardGenerator will be the default generator used to pre-process logs.
Runs JMeter tests, either directly for local GUI and non-GUI invocations,
or started by
RemoteJMeterEngineImpl when running in server mode.Default behaviour for remote testing.
This class serves as a way to calculate the median, max, min etc. of a list of values.
StatCalculator for Integer values
StatCalculator for Long values
Aggregrate Table-Based Reporting Visualizer for JMeter.
Aggregates sample results for use by the Statistical remote batch mode.
Implements batch reporting for remote testing.
Description:
Aggregrate Table-Based Reporting Visualizer for JMeter.
Interface that identifies processes to stop on close or load of new project files
Stops stopables (Proxy, Mirror)
StringFromFile Function to read a String from a text file.
This class implements the JMS Subscriber sampler.
Generate a summary of the test run so far to the log file and/or standard
output.
Create a summariser test element GUI.
Simpler (lower memory) version of Aggregate Report (StatVisualizer).
Implements a controller which selects at most one of its children
based on the condition value, which may be a number or a string.
This class implements a listener for SMTP events and a monitor for all
threads sending mail.
The purpose of the SyncTimer is to block threads until X number of threads
have been blocked, and then they are all released at once.
Utility class for invoking native system applications
A sampler for executing a System function.
GUI for
SystemSamplerTable editor for TestBean GUI properties.
Class to hold data for the TableVisualiser.
This class implements a statistical analyser that calculates both the average
and the standard deviation of the sampling process.
Description:
Currently the parser only handles GET/POST requests.
Currently the parser only handles GET/POST requests.
Interface required by TCPSampler for TCPClient implementations.
Sample TCPClient implementation.
A sampler which understands Tcp requests.
Template Bean
Manages Test Plan templates
Open Templates
Request/reply executor with a temporary reply queue.
Dummy Sampler used to pause or stop a thread or the test;
intended for use in Conditional Controllers.
Marker interface to tell JMeter to make a Test Bean Gui for the class.
This is the BeanInfo object for the TestBean class.
JMeter GUI element editing for TestBean elements.
This is an experimental class.
HashTreeTraverser implementation that traverses the Test Tree to build:
A map with key Sampler and as value the associated SamplePackage
A map with key TransactionController and as value the associated SamplePackage
Bug 53796 - TestCompiler uses static Set which can grow huge
This interface is a means to allow the pair data to be saved with the parent
instance, thus allowing it to be garbage collected when the thread completes.
For traversing Test Elements, which contain property that can be other test
elements, strings, collections, maps, objects
This defines a simple Test Fragment GUI that can be used instead of a Thread Group
to allow for a non-execution part of the Test Plan that can be saved and referenced
by a Module or Include Controller.
Deprecated.
since 2.8, please use
TestStateListener and/or TestIterationListenerJMeter GUI component representing the test plan which will be executed when
the test is run.
Returns Test Plan name
XStream Class to convert TestResultWrapper
Dialog text box to display some text in a box
Class to display a dialog box and cell's content
when double click on a table's cell
Class to edit in a dialog box the cell's content
when double (pressed) click on a table's cell which is editable
Utility class to handle text files as a single lump of text.
ThreadGroup holds the settings for a JMeter thread group.
Allow threads to perform startup and closedown if necessary
A random number generator isolated to the current thread.
Function to return the current thread number.
This class represents a controller that can control the number of times that
it is executed, either by the total number of times the user wants the
controller executed (BYNUMBER) or by the percentage of time it is called
(BYPERCENT)
The current implementation executes the first N samples (BYNUMBER)
or the last N% of samples (BYPERCENT).
Class for reporting errors when running Tidy.
__time() function - returns the current time in milliseconds
This interface defines those methods that must be implemented by timer
plugins.
Hide / unhide toolbar.
Transaction Controller to measure transaction times
There are two different modes for the controller:
- generate additional total sample after nested samples (as in JMeter 2.2)
- generate parent sampler containing the nested samples
A Transaction controller component.
Transaction Sampler class to measure transaction times
(not exposed a a GUI class, as it is only used internally by TransactionController in Generate Parent sample mode)
Clones the test tree, skipping test elements that implement
NoThreadClone by default.Clones the test tree, skipping test elements that implement
Timer by default.Tree cell renderer used by ComparisonVisualizer.
Used in JComboBoxes to reference JMeterTreeNodes
This is a basic interface for TreeTableModel that extends TableModel.
This class can be used as a SocketFactory with SSL-connections.
Invokes
setRunningVersion(true) for all matched nodesAllow direct specification of property editors.
Menu command to serve Undo/Redo
This class serves storing Test Tree state and navigating through it
to give the undo/redo ability for test plan changes
Interface to be implemented by components interested in UndoHistory
Undo history item
Replaces ${key} by value extracted from
JMeterVariables if anyFunction to unescape any Java literals found in the String.
Function to unescape a string containing entity escapes
to a string containing the actual Unicode characters corresponding to the escapes.
This class implements those methods needed by RandomTimer to be instantiable
and implements a random delay with an average value and a uniformly
distributed variation.
Implementation of a uniform random timer.
Implement this interface to work with the AllTests class.
Marker interface indicating that an instance of a component cannot be shared.
Collection class designed for handling URLs
Basic URL / HTTP Request configuration:
host and port
connect and response timeouts
path, method, encoding, parameters
redirects and keepalive
Function to decode a application/x-www-form-urlencoded string.
Function to encode a string to a application/x-www-form-urlencoded string.
Helper class to allow URLs to be stored in Collections without incurring the
cost of the hostname lookup performed by the URL methods equals() and
hashCode() URL is a final class, so cannot be extended ...
User metric
The handler used to read in XML parameter data.
XML Parseing errors for XML parameters file are handled here.
Deprecated.
This test element is deprecated.
This module controls the Sequence in which user details are returned.
Utility methods for JMS protocol.
Function to create a UUID
Parameters:
- None
Returns:
- A pseudo random UUID 4
Perfom replacement of ${variable} references.
Function to get a JMeter Variable
Parameters:
- variable name
Returns:
- the variable value, but if not found
- the variable name itself
A vertical layout manager similar to java.awt.FlowLayout.
Base for ViewResults
Implement this method to be a Visualizer for JMeter.
Sampler to handle Web Service requests.
This is the GUI for the webservice samplers.
Debug class to show details of the currently selected object
Currently shows TestElement and GUI class names
Also enables/disables debug for the test element.
JMeter GUI component representing a work bench where users can make
preparations for the test plan.
Created on: Jun 3, 2003
For now I use DOM for WSDLHelper, but it would be more efficient to use JAXB
to generate an object model for WSDL and use it to perform serialization and
deserialization.
Checks if the result is a well-formed XML content using jdom
Provides XML string building methods.
A extended class of DefaultMutableTreeNode except that it also attached XML
node and convert XML document into DefaultMutableTreeNode.
XMLSchemaAssertion.java Validate response against an XML Schema author
Dave Maung
XMLSchemaAssertionGUI.java author Dave Maung
The function represented by this class allows data to be read from XML files.
Checks if the result is a well-formed XML content and whether it matches an
XPath
Extracts text from (X)HTML response using XPath query language
Example XPath queries:
/html/head/title
extracts Title from HTML response
//form[@name='countryForm']//select[@name='country']/option[text()='Czech Republic'])/@value
extracts value attribute of option element that match text 'Czech Republic'
inside of select element with name attribute 'country' inside of
form with name attribute 'countryForm'
//head
extracts the XML fragment for head node.
//head/text()
extracts the text content for head node.
GUI for XPathExtractor class.
File data container for XML files Data is accessible via XPath
Gui component for representing a xpath expression
This class provides a few utility methods for dealing with XML/XPath.
SystemCommandinstead