<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>JUnitSampler (Apache JMeter dist API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.jmeter.protocol.java.sampler, class: JUnitSampler">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../../script-dir/jquery-3.6.1.min.js"></script>
<script type="text/javascript" src="../../../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache JMeter</b></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li><a href="#nested-class-summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.jmeter.protocol.java.sampler</a></div>
<h1 title="Class JUnitSampler" class="title">Class JUnitSampler</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance"><a href="../../../testelement/AbstractTestElement.html" title="class in org.apache.jmeter.testelement">org.apache.jmeter.testelement.AbstractTestElement</a>
<div class="inheritance"><a href="../../../samplers/AbstractSampler.html" title="class in org.apache.jmeter.samplers">org.apache.jmeter.samplers.AbstractSampler</a>
<div class="inheritance">org.apache.jmeter.protocol.java.sampler.JUnitSampler</div>
</div>
</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/Serializable.html" title="class or interface in java.io" class="external-link">Serializable</a></code>, <code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Cloneable.html" title="class or interface in java.lang" class="external-link">Cloneable</a></code>, <code><a href="../../../engine/util/ConfigMergabilityIndicator.html" title="interface in org.apache.jmeter.engine.util">ConfigMergabilityIndicator</a></code>, <code><a href="../../../gui/Searchable.html" title="interface in org.apache.jmeter.gui">Searchable</a></code>, <code><a href="../../../samplers/Sampler.html" title="interface in org.apache.jmeter.samplers">Sampler</a></code>, <code>org.apache.jmeter.testelement.TestElement</code>, <code><a href="../../../testelement/ThreadListener.html" title="interface in org.apache.jmeter.testelement">ThreadListener</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">JUnitSampler</span>
<span class="extends-implements">extends <a href="../../../samplers/AbstractSampler.html" title="class in org.apache.jmeter.samplers">AbstractSampler</a>
implements <a href="../../../testelement/ThreadListener.html" title="interface in org.apache.jmeter.testelement">ThreadListener</a></span></div>
<div class="block">This is a basic implementation that runs a single test method of
 a JUnit test case. The current implementation will use the string
 constructor first. If the test class does not declare a string
 constructor, the sampler will try empty constructor.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../../serialized-form.html#org.apache.jmeter.protocol.java.sampler.JUnitSampler">Serialized Form</a></li>
</ul>
</dd>
</dl>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="inherited-list">
<h2 id="nested-classes-inherited-from-class-org.apache.jmeter.testelement.TestElement">Nested classes/interfaces inherited from interface&nbsp;org.apache.jmeter.testelement.TestElement</h2>
<code>org.apache.jmeter.testelement.TestElement.Companion</code></div>
</section>
</li>
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="inherited-list">
<h3 id="fields-inherited-from-class-org.apache.jmeter.testelement.TestElement">Fields inherited from interface&nbsp;org.apache.jmeter.testelement.TestElement</h3>
<code>COMMENTS, Companion, ENABLED, GUI_CLASS, NAME, TEST_CLASS</code></div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">JUnitSampler</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getAppendError()" class="member-name-link">getAppendError</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">If append error is not set, by default it is set to false,
 which means users have to explicitly set the sampler to
 append the assert errors.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getAppendException()" class="member-name-link">getAppendException</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">If append exception is not set, by default it is set to <code>false</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getClassname()" class="member-name-link">getClassname</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the Classname attribute of the JavaConfig object</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getConstructorString()" class="member-name-link">getConstructorString</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCreateOneInstancePerSample()" class="member-name-link">getCreateOneInstancePerSample</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getDoNotSetUpTearDown()" class="member-name-link">getDoNotSetUpTearDown</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">if the sample shouldn't call setup/teardown, the
 method returns true.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getError()" class="member-name-link">getError</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getErrorCode()" class="member-name-link">getErrorCode</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getFailure()" class="member-name-link">getFailure</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getFailureCode()" class="member-name-link">getFailureCode</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getFilterString()" class="member-name-link">getFilterString</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getJunit4()" class="member-name-link">getJunit4</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Check if JUnit4 (annotations) are to be used instead of
 the JUnit3 style (TestClass and specific method names)</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getMethod()" class="member-name-link">getMethod</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getSuccess()" class="member-name-link">getSuccess</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getSuccessCode()" class="member-name-link">getSuccessCode</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../../samplers/SampleResult.html" title="class in org.apache.jmeter.samplers">SampleResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#sample(org.apache.jmeter.samplers.Entry)" class="member-name-link">sample</a><wbr>(<a href="../../../samplers/Entry.html" title="class in org.apache.jmeter.samplers">Entry</a>&nbsp;entry)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Obtains statistics about the given Entry, and packages the information
 into a SampleResult.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setAppendError(boolean)" class="member-name-link">setAppendError</a><wbr>(boolean&nbsp;error)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set whether to append errors or not.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setAppendException(boolean)" class="member-name-link">setAppendException</a><wbr>(boolean&nbsp;exc)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set whether to append exceptions or not.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setClassname(java.lang.String)" class="member-name-link">setClassname</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;className)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the Classname attribute of the JavaConfig object</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setConstructorString(java.lang.String)" class="member-name-link">setConstructorString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;constr)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set the string label used to create an instance of the
 test with the string constructor.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setCreateOneInstancePerSample(boolean)" class="member-name-link">setCreateOneInstancePerSample</a><wbr>(boolean&nbsp;createOneInstancePerSample)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setDoNotSetUpTearDown(boolean)" class="member-name-link">setDoNotSetUpTearDown</a><wbr>(boolean&nbsp;setup)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">set the setup/teardown option</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setError(java.lang.String)" class="member-name-link">setError</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;error)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">provide a descriptive error for the test method.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setErrorCode(java.lang.String)" class="member-name-link">setErrorCode</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;code)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Provide an unique error code for when the test
 does not pass the assert test.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setFailure(java.lang.String)" class="member-name-link">setFailure</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;fail)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">set the failure message</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setFailureCode(java.lang.String)" class="member-name-link">setFailureCode</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;code)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Provide some unique code to denote a type of failure</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setFilterString(java.lang.String)" class="member-name-link">setFilterString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;text)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">set the filter string in comma separated format</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setJunit4(boolean)" class="member-name-link">setJunit4</a><wbr>(boolean&nbsp;junit4)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set whether to use JUnit4 style or not.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setMethod(java.lang.String)" class="member-name-link">setMethod</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;methodName)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Method should add the JUnit <em>testXXX</em> method to the list at
 the end, since the sequence matters.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setSuccess(java.lang.String)" class="member-name-link">setSuccess</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;success)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">set the success message</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setSuccessCode(java.lang.String)" class="member-name-link">setSuccessCode</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;code)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set the success code.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#threadFinished()" class="member-name-link">threadFinished</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Called for each thread after all samples have been processed.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#threadStarted()" class="member-name-link">threadStarted</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set up all variables that don't change between samples.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.jmeter.samplers.AbstractSampler">Methods inherited from class&nbsp;org.apache.jmeter.samplers.<a href="../../../samplers/AbstractSampler.html" title="class in org.apache.jmeter.samplers">AbstractSampler</a></h3>
<code><a href="../../../samplers/AbstractSampler.html#applies(org.apache.jmeter.config.ConfigTestElement)">applies</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.jmeter.testelement.AbstractTestElement">Methods inherited from class&nbsp;org.apache.jmeter.testelement.<a href="../../../testelement/AbstractTestElement.html" title="class in org.apache.jmeter.testelement">AbstractTestElement</a></h3>
<code><a href="../../../testelement/AbstractTestElement.html#addPropertiesValues(java.util.List,java.util.Set)">addPropertiesValues</a>, <a href="../../../testelement/AbstractTestElement.html#addProperty(org.apache.jmeter.testelement.property.JMeterProperty)">addProperty</a>, <a href="../../../testelement/AbstractTestElement.html#addProperty(org.apache.jmeter.testelement.property.JMeterProperty,boolean)">addProperty</a>, <a href="../../../testelement/AbstractTestElement.html#addTestElement(org.apache.jmeter.testelement.TestElement)">addTestElement</a>, <a href="../../../testelement/AbstractTestElement.html#canRemove()">canRemove</a>, <a href="../../../testelement/AbstractTestElement.html#clear()">clear</a>, <a href="../../../testelement/AbstractTestElement.html#clearTemporary(org.apache.jmeter.testelement.property.JMeterProperty)">clearTemporary</a>, <a href="../../../testelement/AbstractTestElement.html#clearTestElementChildren()">clearTestElementChildren</a>, <a href="../../../testelement/AbstractTestElement.html#clone()">clone</a>, <a href="../../../testelement/AbstractTestElement.html#emptyTemporary()">emptyTemporary</a>, <a href="../../../testelement/AbstractTestElement.html#equals(java.lang.Object)">equals</a>, <a href="../../../testelement/AbstractTestElement.html#getComment()">getComment</a>, <a href="../../../testelement/AbstractTestElement.html#getName()">getName</a>, <a href="../../../testelement/AbstractTestElement.html#getProperty(java.lang.String)">getProperty</a>, <a href="../../../testelement/AbstractTestElement.html#getPropertyAsBoolean(java.lang.String)">getPropertyAsBoolean</a>, <a href="../../../testelement/AbstractTestElement.html#getPropertyAsBoolean(java.lang.String,boolean)">getPropertyAsBoolean</a>, <a href="../../../testelement/AbstractTestElement.html#getPropertyAsDouble(java.lang.String)">getPropertyAsDouble</a>, <a href="../../../testelement/AbstractTestElement.html#getPropertyAsFloat(java.lang.String)">getPropertyAsFloat</a>, <a href="../../../testelement/AbstractTestElement.html#getPropertyAsInt(java.lang.String)">getPropertyAsInt</a>, <a href="../../../testelement/AbstractTestElement.html#getPropertyAsInt(java.lang.String,int)">getPropertyAsInt</a>, <a href="../../../testelement/AbstractTestElement.html#getPropertyAsLong(java.lang.String)">getPropertyAsLong</a>, <a href="../../../testelement/AbstractTestElement.html#getPropertyAsLong(java.lang.String,long)">getPropertyAsLong</a>, <a href="../../../testelement/AbstractTestElement.html#getPropertyAsString(java.lang.String)">getPropertyAsString</a>, <a href="../../../testelement/AbstractTestElement.html#getPropertyAsString(java.lang.String,java.lang.String)">getPropertyAsString</a>, <a href="../../../testelement/AbstractTestElement.html#getPropertyOrNull(java.lang.String)">getPropertyOrNull</a>, <a href="../../../testelement/AbstractTestElement.html#getSearchableTokens()">getSearchableTokens</a>, <a href="../../../testelement/AbstractTestElement.html#getThreadContext()">getThreadContext</a>, <a href="../../../testelement/AbstractTestElement.html#getThreadName()">getThreadName</a>, <a href="../../../testelement/AbstractTestElement.html#hashCode()">hashCode</a>, <a href="../../../testelement/AbstractTestElement.html#isEnabled()">isEnabled</a>, <a href="../../../testelement/AbstractTestElement.html#isRunningVersion()">isRunningVersion</a>, <a href="../../../testelement/AbstractTestElement.html#isTemporary(org.apache.jmeter.testelement.property.JMeterProperty)">isTemporary</a>, <a href="../../../testelement/AbstractTestElement.html#logProperties()">logProperties</a>, <a href="../../../testelement/AbstractTestElement.html#mergeIn(org.apache.jmeter.testelement.TestElement)">mergeIn</a>, <a href="../../../testelement/AbstractTestElement.html#propertyIterator()">propertyIterator</a>, <a href="../../../testelement/AbstractTestElement.html#recoverRunningVersion()">recoverRunningVersion</a>, <a href="../../../testelement/AbstractTestElement.html#removeProperty(java.lang.String)">removeProperty</a>, <a href="../../../testelement/AbstractTestElement.html#setComment(java.lang.String)">setComment</a>, <a href="../../../testelement/AbstractTestElement.html#setEnabled(boolean)">setEnabled</a>, <a href="../../../testelement/AbstractTestElement.html#setName(java.lang.String)">setName</a>, <a href="../../../testelement/AbstractTestElement.html#setProperty(java.lang.String,boolean)">setProperty</a>, <a href="../../../testelement/AbstractTestElement.html#setProperty(java.lang.String,boolean,boolean)">setProperty</a>, <a href="../../../testelement/AbstractTestElement.html#setProperty(java.lang.String,int)">setProperty</a>, <a href="../../../testelement/AbstractTestElement.html#setProperty(java.lang.String,int,int)">setProperty</a>, <a href="../../../testelement/AbstractTestElement.html#setProperty(java.lang.String,long)">setProperty</a>, <a href="../../../testelement/AbstractTestElement.html#setProperty(java.lang.String,long,long)">setProperty</a>, <a href="../../../testelement/AbstractTestElement.html#setProperty(java.lang.String,java.lang.String)">setProperty</a>, <a href="../../../testelement/AbstractTestElement.html#setProperty(java.lang.String,java.lang.String,java.lang.String)">setProperty</a>, <a href="../../../testelement/AbstractTestElement.html#setProperty(org.apache.jmeter.testelement.property.JMeterProperty)">setProperty</a>, <a href="../../../testelement/AbstractTestElement.html#setRunningVersion(boolean)">setRunningVersion</a>, <a href="../../../testelement/AbstractTestElement.html#setTemporary(org.apache.jmeter.testelement.property.JMeterProperty)">setTemporary</a>, <a href="../../../testelement/AbstractTestElement.html#setThreadContext(org.apache.jmeter.threads.JMeterContext)">setThreadContext</a>, <a href="../../../testelement/AbstractTestElement.html#setThreadName(java.lang.String)">setThreadName</a>, <a href="../../../testelement/AbstractTestElement.html#traverse(org.apache.jmeter.testelement.TestElementTraverser)">traverse</a>, <a href="../../../testelement/AbstractTestElement.html#traverseCollection(org.apache.jmeter.testelement.property.CollectionProperty,org.apache.jmeter.testelement.TestElementTraverser)">traverseCollection</a>, <a href="../../../testelement/AbstractTestElement.html#traverseMap(org.apache.jmeter.testelement.property.MapProperty,org.apache.jmeter.testelement.TestElementTraverser)">traverseMap</a>, <a href="../../../testelement/AbstractTestElement.html#traverseProperty(org.apache.jmeter.testelement.TestElementTraverser,org.apache.jmeter.testelement.property.JMeterProperty)">traverseProperty</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.jmeter.testelement.TestElement">Methods inherited from interface&nbsp;org.apache.jmeter.testelement.TestElement</h3>
<code>addTestElement, canRemove, clear, clearTestElementChildren, clone, get, get, get, get, get, get, get, get, get, getComment, getName, getOrCreate, getOrCreate, getOrNull, getOrNull, getOrNull, getProperty, getPropertyAsBoolean, getPropertyAsBoolean, getPropertyAsDouble, getPropertyAsFloat, getPropertyAsInt, getPropertyAsInt, getPropertyAsLong, getPropertyAsLong, getPropertyAsString, getPropertyAsString, getPropertyOrNull, getPropertyOrNull, getProps, getSchema, getString, getThreadContext, getThreadName, isEnabled, isRunningVersion, isTemporary, propertyIterator, recoverRunningVersion, removed, removeProperty, removeProperty, set, set, set, set, set, set, set, set, set, setComment, setEnabled, setName, setProperty, setProperty, setProperty, setProperty, setProperty, setProperty, setProperty, setProperty, setProperty, setRunningVersion, setTemporary, setThreadContext, setThreadName, traverse</code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;()">
<h3>JUnitSampler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">JUnitSampler</span>()</div>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="setClassname(java.lang.String)">
<h3>setClassname</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setClassname</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;className)</span></div>
<div class="block">Sets the Classname attribute of the JavaConfig object</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>className</code> - the new Classname value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getClassname()">
<h3>getClassname</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getClassname</span>()</div>
<div class="block">Gets the Classname attribute of the JavaConfig object</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the Classname value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setConstructorString(java.lang.String)">
<h3>setConstructorString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setConstructorString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;constr)</span></div>
<div class="block">Set the string label used to create an instance of the
 test with the string constructor.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>constr</code> - the string passed to the constructor</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getConstructorString()">
<h3>getConstructorString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getConstructorString</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the string passed to the string constructor</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMethod()">
<h3>getMethod</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getMethod</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the name of the method to test</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setMethod(java.lang.String)">
<h3>setMethod</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setMethod</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;methodName)</span></div>
<div class="block">Method should add the JUnit <em>testXXX</em> method to the list at
 the end, since the sequence matters.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>methodName</code> - name of the method to test</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSuccess()">
<h3>getSuccess</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getSuccess</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the success message</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setSuccess(java.lang.String)">
<h3>setSuccess</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setSuccess</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;success)</span></div>
<div class="block">set the success message</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>success</code> - message to be used for success</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSuccessCode()">
<h3>getSuccessCode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getSuccessCode</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the success code defined by the user</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setSuccessCode(java.lang.String)">
<h3>setSuccessCode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setSuccessCode</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;code)</span></div>
<div class="block">Set the success code. The success code should
 be unique.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>code</code> - unique success code</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getFailure()">
<h3>getFailure</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getFailure</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the failure message</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setFailure(java.lang.String)">
<h3>setFailure</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setFailure</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;fail)</span></div>
<div class="block">set the failure message</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>fail</code> - the failure message</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getFailureCode()">
<h3>getFailureCode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getFailureCode</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>The failure code that is used by other components</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setFailureCode(java.lang.String)">
<h3>setFailureCode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setFailureCode</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;code)</span></div>
<div class="block">Provide some unique code to denote a type of failure</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>code</code> - unique code to denote the type of failure</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getError()">
<h3>getError</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getError</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the descriptive error for the test</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setError(java.lang.String)">
<h3>setError</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setError</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;error)</span></div>
<div class="block">provide a descriptive error for the test method. For
 a description of the difference between failure and
 error, please refer to the
 <a href="http://junit.sourceforge.net/doc/faq/faq.htm#tests_9">junit faq</a></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>error</code> - the description of the error</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getErrorCode()">
<h3>getErrorCode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getErrorCode</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the error code for the test method. It should
 be an unique error code.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setErrorCode(java.lang.String)">
<h3>setErrorCode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setErrorCode</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;code)</span></div>
<div class="block">Provide an unique error code for when the test
 does not pass the assert test.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>code</code> - unique error code</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getFilterString()">
<h3>getFilterString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getFilterString</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the comma separated string for the filter</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setFilterString(java.lang.String)">
<h3>setFilterString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setFilterString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;text)</span></div>
<div class="block">set the filter string in comma separated format</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>text</code> - comma separated filter</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getDoNotSetUpTearDown()">
<h3>getDoNotSetUpTearDown</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getDoNotSetUpTearDown</span>()</div>
<div class="block">if the sample shouldn't call setup/teardown, the
 method returns true. It's meant for onetimesetup
 and onetimeteardown.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>flag whether setup/teardown methods should not be called</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setDoNotSetUpTearDown(boolean)">
<h3>setDoNotSetUpTearDown</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setDoNotSetUpTearDown</span><wbr><span class="parameters">(boolean&nbsp;setup)</span></div>
<div class="block">set the setup/teardown option</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>setup</code> - flag whether the setup/teardown methods should not be called</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getAppendError()">
<h3>getAppendError</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getAppendError</span>()</div>
<div class="block">If append error is not set, by default it is set to false,
 which means users have to explicitly set the sampler to
 append the assert errors. Because of how junit works, there
 should only be one error</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>flag whether errors should be appended</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setAppendError(boolean)">
<h3>setAppendError</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setAppendError</span><wbr><span class="parameters">(boolean&nbsp;error)</span></div>
<div class="block">Set whether to append errors or not.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>error</code> - the setting to apply</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getAppendException()">
<h3>getAppendException</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getAppendException</span>()</div>
<div class="block">If append exception is not set, by default it is set to <code>false</code>.
 Users have to explicitly set it to <code>true</code> to see the exceptions
 in the result tree.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>flag whether exceptions should be appended to the result tree</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setAppendException(boolean)">
<h3>setAppendException</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setAppendException</span><wbr><span class="parameters">(boolean&nbsp;exc)</span></div>
<div class="block">Set whether to append exceptions or not.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>exc</code> - the setting to apply.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getJunit4()">
<h3>getJunit4</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getJunit4</span>()</div>
<div class="block">Check if JUnit4 (annotations) are to be used instead of
 the JUnit3 style (TestClass and specific method names)</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if JUnit4 (annotations) are to be used.
 Default is false.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setJunit4(boolean)">
<h3>setJunit4</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setJunit4</span><wbr><span class="parameters">(boolean&nbsp;junit4)</span></div>
<div class="block">Set whether to use JUnit4 style or not.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>junit4</code> - true if JUnit4 style is to be used.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sample(org.apache.jmeter.samplers.Entry)">
<h3>sample</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../../samplers/SampleResult.html" title="class in org.apache.jmeter.samplers">SampleResult</a></span>&nbsp;<span class="element-name">sample</span><wbr><span class="parameters">(<a href="../../../samplers/Entry.html" title="class in org.apache.jmeter.samplers">Entry</a>&nbsp;entry)</span></div>
<div class="block">Obtains statistics about the given Entry, and packages the information
 into a SampleResult.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../../samplers/Sampler.html#sample(org.apache.jmeter.samplers.Entry)">sample</a></code>&nbsp;in interface&nbsp;<code><a href="../../../samplers/Sampler.html" title="interface in org.apache.jmeter.samplers">Sampler</a></code></dd>
<dt>Parameters:</dt>
<dd><code>entry</code> - the Entry (TODO seems to be unused)</dd>
<dt>Returns:</dt>
<dd>information about the sample</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="threadFinished()">
<h3>threadFinished</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">threadFinished</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../../../testelement/ThreadListener.html#threadFinished()">ThreadListener</a></code></span></div>
<div class="block">Called for each thread after all samples have been processed.

 See org.apache.jmeter.threads.JMeterThread#threadFinished(org.apache.jmeter.engine.event.LoopIterationListener)</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../../testelement/ThreadListener.html#threadFinished()">threadFinished</a></code>&nbsp;in interface&nbsp;<code><a href="../../../testelement/ThreadListener.html" title="interface in org.apache.jmeter.testelement">ThreadListener</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="threadStarted()">
<h3>threadStarted</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">threadStarted</span>()</div>
<div class="block">Set up all variables that don't change between samples.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../../testelement/ThreadListener.html#threadStarted()">threadStarted</a></code>&nbsp;in interface&nbsp;<code><a href="../../../testelement/ThreadListener.html" title="interface in org.apache.jmeter.testelement">ThreadListener</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setCreateOneInstancePerSample(boolean)">
<h3>setCreateOneInstancePerSample</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setCreateOneInstancePerSample</span><wbr><span class="parameters">(boolean&nbsp;createOneInstancePerSample)</span></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>createOneInstancePerSample</code> - flag whether a new instance for each call should be created</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getCreateOneInstancePerSample()">
<h3>getCreateOneInstancePerSample</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getCreateOneInstancePerSample</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>boolean create New Instance For Each Call</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 1998-2024 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
