<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>AccessLogSampler (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.http.sampler, class: AccessLogSampler">
<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><a href="#field-detail">Field</a>&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.http.sampler</a></div>
<h1 title="Class AccessLogSampler" class="title">Class AccessLogSampler</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"><a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">org.apache.jmeter.protocol.http.sampler.HTTPSamplerBase</a>
<div class="inheritance"><a href="HTTPSampler.html" title="class in org.apache.jmeter.protocol.http.sampler">org.apache.jmeter.protocol.http.sampler.HTTPSampler</a>
<div class="inheritance">org.apache.jmeter.protocol.http.sampler.AccessLogSampler</div>
</div>
</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/Replaceable.html" title="interface in org.apache.jmeter.gui">Replaceable</a></code>, <code><a href="../../../gui/Searchable.html" title="interface in org.apache.jmeter.gui">Searchable</a></code>, <code><a href="../util/HTTPConstantsInterface.html" title="interface in org.apache.jmeter.protocol.http.util">HTTPConstantsInterface</a></code>, <code><a href="../../../samplers/Interruptible.html" title="interface in org.apache.jmeter.samplers">Interruptible</a></code>, <code><a href="../../../samplers/Sampler.html" title="interface in org.apache.jmeter.samplers">Sampler</a></code>, <code><a href="../../../testbeans/TestBean.html" title="interface in org.apache.jmeter.testbeans">TestBean</a></code>, <code>org.apache.jmeter.testelement.TestElement</code>, <code><a href="../../../testelement/TestIterationListener.html" title="interface in org.apache.jmeter.testelement">TestIterationListener</a></code>, <code><a href="../../../testelement/TestStateListener.html" title="interface in org.apache.jmeter.testelement">TestStateListener</a></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">AccessLogSampler</span>
<span class="extends-implements">extends <a href="HTTPSampler.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampler</a>
implements <a href="../../../testbeans/TestBean.html" title="interface in org.apache.jmeter.testbeans">TestBean</a>, <a href="../../../testelement/ThreadListener.html" title="interface in org.apache.jmeter.testelement">ThreadListener</a></span></div>
<div class="block">Description: <br>
 <br>
 AccessLogSampler is responsible for a couple of things:
 <ul>
 <li>creating instances of Generator
 <li>creating instances of Parser
 <li>triggering popup windows
 <li>calling Generator.generateRequest()
 <li>checking to make sure the classes are valid
 <li>making sure a class can be instantiated
 </ul>
 The intent of this sampler is it uses the generator and parser to create a
 HTTPSampler when it is needed. It does not contain logic about how to parse
 the logs. It also doesn't care how Generator is implemented, as long as it
 implements the interface. This means a person could simply implement a dummy
 parser to generate random parameters and the generator consumes the results.
 This wasn't the original intent of the sampler. I originally wanted to write
 this sampler, so that I can take production logs to simulate production
 traffic in a test environment. Doing so is desirable to study odd or unusual
 behavior. It's also good to compare a new system against an existing system
 to get near apples-to-apples comparison. I've been asked if benchmarks are
 really fair comparisons just about every single time, so this helps me
 accomplish that task.
 <p>
 Some bugs only appear under production traffic, so it is useful to generate
 traffic using production logs. This way, JMeter can record when problems
 occur and provide a way to match the server logs.
 </p></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../../serialized-form.html#org.apache.jmeter.protocol.http.sampler.AccessLogSampler">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.protocol.http.sampler.HTTPSamplerBase">Nested classes/interfaces inherited from class&nbsp;org.apache.jmeter.protocol.http.sampler.<a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a></h2>
<code><a href="HTTPSamplerBase.SourceType.html" title="enum in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase.SourceType</a></code></div>
<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="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <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"><code><a href="#DEFAULT_CLASS" class="member-name-link">DEFAULT_CLASS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
<div class="inherited-list">
<h3 id="fields-inherited-from-class-org.apache.jmeter.protocol.http.sampler.HTTPSamplerBase">Fields inherited from class&nbsp;org.apache.jmeter.protocol.http.sampler.<a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a></h3>
<code><a href="HTTPSamplerBase.html#ARGUMENTS">ARGUMENTS</a>, <a href="HTTPSamplerBase.html#AUTH_MANAGER">AUTH_MANAGER</a>, <a href="HTTPSamplerBase.html#AUTO_REDIRECTS">AUTO_REDIRECTS</a>, <a href="HTTPSamplerBase.html#BROWSER_COMPATIBLE_MULTIPART">BROWSER_COMPATIBLE_MULTIPART</a>, <a href="HTTPSamplerBase.html#BROWSER_COMPATIBLE_MULTIPART_MODE_DEFAULT">BROWSER_COMPATIBLE_MULTIPART_MODE_DEFAULT</a>, <a href="HTTPSamplerBase.html#CACHE_MANAGER">CACHE_MANAGER</a>, <a href="HTTPSamplerBase.html#CONCURRENT_DWN">CONCURRENT_DWN</a>, <a href="HTTPSamplerBase.html#CONCURRENT_POOL">CONCURRENT_POOL</a>, <a href="HTTPSamplerBase.html#CONCURRENT_POOL_SIZE">CONCURRENT_POOL_SIZE</a>, <a href="HTTPSamplerBase.html#CONNECT_TIMEOUT">CONNECT_TIMEOUT</a>, <a href="HTTPSamplerBase.html#CONTENT_ENCODING">CONTENT_ENCODING</a>, <a href="HTTPSamplerBase.html#CONTENT_TYPE">CONTENT_TYPE</a>, <a href="HTTPSamplerBase.html#COOKIE_MANAGER">COOKIE_MANAGER</a>, <a href="HTTPSamplerBase.html#DEFAULT_METHOD">DEFAULT_METHOD</a>, <a href="HTTPSamplerBase.html#DNS_CACHE_MANAGER">DNS_CACHE_MANAGER</a>, <a href="HTTPSamplerBase.html#DO_MULTIPART_POST">DO_MULTIPART_POST</a>, <a href="HTTPSamplerBase.html#DOMAIN">DOMAIN</a>, <a href="HTTPSamplerBase.html#EMBEDDED_URL_EXCLUDE_RE">EMBEDDED_URL_EXCLUDE_RE</a>, <a href="HTTPSamplerBase.html#EMBEDDED_URL_RE">EMBEDDED_URL_RE</a>, <a href="HTTPSamplerBase.html#FOLLOW_REDIRECTS">FOLLOW_REDIRECTS</a>, <a href="HTTPSamplerBase.html#HEADER_MANAGER">HEADER_MANAGER</a>, <a href="HTTPSamplerBase.html#IMAGE_PARSER">IMAGE_PARSER</a>, <a href="HTTPSamplerBase.html#IMPLEMENTATION">IMPLEMENTATION</a>, <a href="HTTPSamplerBase.html#IP_SOURCE">IP_SOURCE</a>, <a href="HTTPSamplerBase.html#IP_SOURCE_TYPE">IP_SOURCE_TYPE</a>, <a href="HTTPSamplerBase.html#KEYSTORE_CONFIG">KEYSTORE_CONFIG</a>, <a href="HTTPSamplerBase.html#MAX_FRAME_DEPTH">MAX_FRAME_DEPTH</a>, <a href="HTTPSamplerBase.html#MAX_REDIRECTS">MAX_REDIRECTS</a>, <a href="HTTPSamplerBase.html#MD5">MD5</a>, <a href="HTTPSamplerBase.html#METHOD">METHOD</a>, <a href="HTTPSamplerBase.html#MONITOR">MONITOR</a>, <a href="HTTPSamplerBase.html#NON_HTTP_RESPONSE_CODE">NON_HTTP_RESPONSE_CODE</a>, <a href="HTTPSamplerBase.html#NON_HTTP_RESPONSE_MESSAGE">NON_HTTP_RESPONSE_MESSAGE</a>, <a href="HTTPSamplerBase.html#PATH">PATH</a>, <a href="HTTPSamplerBase.html#PORT">PORT</a>, <a href="HTTPSamplerBase.html#POST_BODY_RAW">POST_BODY_RAW</a>, <a href="HTTPSamplerBase.html#POST_BODY_RAW_DEFAULT">POST_BODY_RAW_DEFAULT</a>, <a href="HTTPSamplerBase.html#PROTOCOL">PROTOCOL</a>, <a href="HTTPSamplerBase.html#PROXYHOST">PROXYHOST</a>, <a href="HTTPSamplerBase.html#PROXYPASS">PROXYPASS</a>, <a href="HTTPSamplerBase.html#PROXYPORT">PROXYPORT</a>, <a href="HTTPSamplerBase.html#PROXYSCHEME">PROXYSCHEME</a>, <a href="HTTPSamplerBase.html#PROXYUSER">PROXYUSER</a>, <a href="HTTPSamplerBase.html#RESPONSE_TIMEOUT">RESPONSE_TIMEOUT</a>, <a href="HTTPSamplerBase.html#SAMPLE_TIMEOUT">SAMPLE_TIMEOUT</a>, <a href="HTTPSamplerBase.html#SOURCE_TYPE_DEFAULT">SOURCE_TYPE_DEFAULT</a>, <a href="HTTPSamplerBase.html#UNSPECIFIED_PORT">UNSPECIFIED_PORT</a>, <a href="HTTPSamplerBase.html#UNSPECIFIED_PORT_AS_STRING">UNSPECIFIED_PORT_AS_STRING</a>, <a href="HTTPSamplerBase.html#URL">URL</a>, <a href="HTTPSamplerBase.html#URL_UNSPECIFIED_PORT">URL_UNSPECIFIED_PORT</a>, <a href="HTTPSamplerBase.html#URL_UNSPECIFIED_PORT_AS_STRING">URL_UNSPECIFIED_PORT_AS_STRING</a>, <a href="HTTPSamplerBase.html#USE_KEEPALIVE">USE_KEEPALIVE</a></code></div>
<div class="inherited-list">
<h3 id="fields-inherited-from-class-org.apache.jmeter.protocol.http.util.HTTPConstantsInterface">Fields inherited from interface&nbsp;org.apache.jmeter.protocol.http.util.<a href="../util/HTTPConstantsInterface.html" title="interface in org.apache.jmeter.protocol.http.util">HTTPConstantsInterface</a></h3>
<code><a href="../util/HTTPConstantsInterface.html#APPLICATION_X_WWW_FORM_URLENCODED">APPLICATION_X_WWW_FORM_URLENCODED</a>, <a href="../util/HTTPConstantsInterface.html#CACHE_CONTROL">CACHE_CONTROL</a>, <a href="../util/HTTPConstantsInterface.html#CONNECT">CONNECT</a>, <a href="../util/HTTPConstantsInterface.html#CONNECTION_CLOSE">CONNECTION_CLOSE</a>, <a href="../util/HTTPConstantsInterface.html#COPY">COPY</a>, <a href="../util/HTTPConstantsInterface.html#DATE">DATE</a>, <a href="../util/HTTPConstantsInterface.html#DEFAULT_HTTP_PORT">DEFAULT_HTTP_PORT</a>, <a href="../util/HTTPConstantsInterface.html#DEFAULT_HTTP_PORT_STRING">DEFAULT_HTTP_PORT_STRING</a>, <a href="../util/HTTPConstantsInterface.html#DEFAULT_HTTPS_PORT">DEFAULT_HTTPS_PORT</a>, <a href="../util/HTTPConstantsInterface.html#DEFAULT_HTTPS_PORT_STRING">DEFAULT_HTTPS_PORT_STRING</a>, <a href="../util/HTTPConstantsInterface.html#DELETE">DELETE</a>, <a href="../util/HTTPConstantsInterface.html#ENCODING_BROTLI">ENCODING_BROTLI</a>, <a href="../util/HTTPConstantsInterface.html#ENCODING_DEFLATE">ENCODING_DEFLATE</a>, <a href="../util/HTTPConstantsInterface.html#ENCODING_GZIP">ENCODING_GZIP</a>, <a href="../util/HTTPConstantsInterface.html#ETAG">ETAG</a>, <a href="../util/HTTPConstantsInterface.html#EXPIRES">EXPIRES</a>, <a href="../util/HTTPConstantsInterface.html#GET">GET</a>, <a href="../util/HTTPConstantsInterface.html#HEAD">HEAD</a>, <a href="../util/HTTPConstantsInterface.html#HEADER_AUTHORIZATION">HEADER_AUTHORIZATION</a>, <a href="../util/HTTPConstantsInterface.html#HEADER_CONNECTION">HEADER_CONNECTION</a>, <a href="../util/HTTPConstantsInterface.html#HEADER_CONTENT_DISPOSITION">HEADER_CONTENT_DISPOSITION</a>, <a href="../util/HTTPConstantsInterface.html#HEADER_CONTENT_ENCODING">HEADER_CONTENT_ENCODING</a>, <a href="../util/HTTPConstantsInterface.html#HEADER_CONTENT_LENGTH">HEADER_CONTENT_LENGTH</a>, <a href="../util/HTTPConstantsInterface.html#HEADER_CONTENT_TYPE">HEADER_CONTENT_TYPE</a>, <a href="../util/HTTPConstantsInterface.html#HEADER_COOKIE">HEADER_COOKIE</a>, <a href="../util/HTTPConstantsInterface.html#HEADER_COOKIE_IN_REQUEST">HEADER_COOKIE_IN_REQUEST</a>, <a href="../util/HTTPConstantsInterface.html#HEADER_HOST">HEADER_HOST</a>, <a href="../util/HTTPConstantsInterface.html#HEADER_LOCAL_ADDRESS">HEADER_LOCAL_ADDRESS</a>, <a href="../util/HTTPConstantsInterface.html#HEADER_LOCATION">HEADER_LOCATION</a>, <a href="../util/HTTPConstantsInterface.html#HEADER_SET_COOKIE">HEADER_SET_COOKIE</a>, <a href="../util/HTTPConstantsInterface.html#HTTP_1_1">HTTP_1_1</a>, <a href="../util/HTTPConstantsInterface.html#IF_MODIFIED_SINCE">IF_MODIFIED_SINCE</a>, <a href="../util/HTTPConstantsInterface.html#IF_NONE_MATCH">IF_NONE_MATCH</a>, <a href="../util/HTTPConstantsInterface.html#KEEP_ALIVE">KEEP_ALIVE</a>, <a href="../util/HTTPConstantsInterface.html#LAST_MODIFIED">LAST_MODIFIED</a>, <a href="../util/HTTPConstantsInterface.html#LOCK">LOCK</a>, <a href="../util/HTTPConstantsInterface.html#MKCALENDAR">MKCALENDAR</a>, <a href="../util/HTTPConstantsInterface.html#MKCOL">MKCOL</a>, <a href="../util/HTTPConstantsInterface.html#MOVE">MOVE</a>, <a href="../util/HTTPConstantsInterface.html#MULTIPART_FORM_DATA">MULTIPART_FORM_DATA</a>, <a href="../util/HTTPConstantsInterface.html#OPTIONS">OPTIONS</a>, <a href="../util/HTTPConstantsInterface.html#PATCH">PATCH</a>, <a href="../util/HTTPConstantsInterface.html#POST">POST</a>, <a href="../util/HTTPConstantsInterface.html#PROPFIND">PROPFIND</a>, <a href="../util/HTTPConstantsInterface.html#PROPPATCH">PROPPATCH</a>, <a href="../util/HTTPConstantsInterface.html#PROTOCOL_HTTP">PROTOCOL_HTTP</a>, <a href="../util/HTTPConstantsInterface.html#PROTOCOL_HTTPS">PROTOCOL_HTTPS</a>, <a href="../util/HTTPConstantsInterface.html#PUT">PUT</a>, <a href="../util/HTTPConstantsInterface.html#REPORT">REPORT</a>, <a href="../util/HTTPConstantsInterface.html#SC_MOVED_PERMANENTLY">SC_MOVED_PERMANENTLY</a>, <a href="../util/HTTPConstantsInterface.html#SC_MOVED_TEMPORARILY">SC_MOVED_TEMPORARILY</a>, <a href="../util/HTTPConstantsInterface.html#SC_PERMANENT_REDIRECT">SC_PERMANENT_REDIRECT</a>, <a href="../util/HTTPConstantsInterface.html#SC_SEE_OTHER">SC_SEE_OTHER</a>, <a href="../util/HTTPConstantsInterface.html#SC_TEMPORARY_REDIRECT">SC_TEMPORARY_REDIRECT</a>, <a href="../util/HTTPConstantsInterface.html#SEARCH">SEARCH</a>, <a href="../util/HTTPConstantsInterface.html#TRACE">TRACE</a>, <a href="../util/HTTPConstantsInterface.html#TRANSFER_ENCODING">TRANSFER_ENCODING</a>, <a href="../util/HTTPConstantsInterface.html#UNLOCK">UNLOCK</a>, <a href="../util/HTTPConstantsInterface.html#VARY">VARY</a></code></div>
<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">AccessLogSampler</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><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></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clone()" class="member-name-link">clone</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"></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="#getDomain()" class="member-name-link">getDomain</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="#getFilterClassName()" class="member-name-link">getFilterClassName</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="#getLogFile()" class="member-name-link">getLogFile</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the path where XML messages are stored.</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="#getParserClassName()" class="member-name-link">getParserClassName</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the file location of the xml file.</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="#getPortString()" class="member-name-link">getPortString</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="#getProtocol()" class="member-name-link">getProtocol</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 protocol, with default.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#initFilter()" class="member-name-link">initFilter</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>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#instantiateParser()" class="member-name-link">instantiateParser</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Method will instantiate the log parser based on the class in the text
 field.</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="#isImageParsing()" class="member-name-link">isImageParsing</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="../../../samplers/SampleResult.html" title="class in org.apache.jmeter.samplers">SampleResult</a></code></div>
<div class="col-second even-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;e)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">sample(Entry e) simply calls sample().</div>
</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="#sampleWithParser()" class="member-name-link">sampleWithParser</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">sample gets a new HTTPSampler from the generator and calls it's sample()
 method.</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="#setDomain(java.lang.String)" class="member-name-link">setDomain</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;domain)</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="#setFilterClassName(java.lang.String)" class="member-name-link">setFilterClassName</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;filterClassName)</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>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setImageParsing(boolean)" class="member-name-link">setImageParsing</a><wbr>(boolean&nbsp;imageParsing)</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="#setLogFile(java.lang.String)" class="member-name-link">setLogFile</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;path)</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 path where XML messages are stored for random selection.</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="#setParserClassName(java.lang.String)" class="member-name-link">setParserClassName</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">it's kinda obvious, but we state it anyways.</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="#setPortString(java.lang.String)" class="member-name-link">setPortString</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;port)</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>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setProtocol(java.lang.String)" class="member-name-link">setProtocol</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;value)</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 scheme, with default</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="#testEnded()" class="member-name-link">testEnded</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 once for all threads after the end of a 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="#testStarted()" class="member-name-link">testStarted</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">
 Called just before the start of the test from the main engine thread.</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>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.jmeter.protocol.http.sampler.HTTPSampler">Methods inherited from class&nbsp;org.apache.jmeter.protocol.http.sampler.<a href="HTTPSampler.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampler</a></h3>
<code><a href="HTTPSampler.html#interrupt()">interrupt</a>, <a href="HTTPSampler.html#sample(java.net.URL,java.lang.String,boolean,int)">sample</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.jmeter.protocol.http.sampler.HTTPSamplerBase">Methods inherited from class&nbsp;org.apache.jmeter.protocol.http.sampler.<a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a></h3>
<code><a href="HTTPSamplerBase.html#addArgument(java.lang.String,java.lang.String)">addArgument</a>, <a href="HTTPSamplerBase.html#addArgument(java.lang.String,java.lang.String,java.lang.String)">addArgument</a>, <a href="HTTPSamplerBase.html#addEncodedArgument(java.lang.String,java.lang.String)">addEncodedArgument</a>, <a href="HTTPSamplerBase.html#addEncodedArgument(java.lang.String,java.lang.String,java.lang.String)">addEncodedArgument</a>, <a href="HTTPSamplerBase.html#addEncodedArgument(java.lang.String,java.lang.String,java.lang.String,java.lang.String)">addEncodedArgument</a>, <a href="HTTPSamplerBase.html#addNonEncodedArgument(java.lang.String,java.lang.String,java.lang.String)">addNonEncodedArgument</a>, <a href="HTTPSamplerBase.html#addNonEncodedArgument(java.lang.String,java.lang.String,java.lang.String,java.lang.String)">addNonEncodedArgument</a>, <a href="HTTPSamplerBase.html#addTestElement(org.apache.jmeter.testelement.TestElement)">addTestElement</a>, <a href="HTTPSamplerBase.html#applies(org.apache.jmeter.config.ConfigTestElement)">applies</a>, <a href="HTTPSamplerBase.html#clearTestElementChildren()">clearTestElementChildren</a>, <a href="HTTPSamplerBase.html#downloadPageResources(org.apache.jmeter.protocol.http.sampler.HTTPSampleResult,org.apache.jmeter.protocol.http.sampler.HTTPSampleResult,int)">downloadPageResources</a>, <a href="HTTPSamplerBase.html#encodeBackSlashes(java.lang.String)">encodeBackSlashes</a>, <a href="HTTPSamplerBase.html#encodeSpaces(java.lang.String)">encodeSpaces</a>, <a href="HTTPSamplerBase.html#errorResult(java.lang.Throwable,org.apache.jmeter.protocol.http.sampler.HTTPSampleResult)">errorResult</a>, <a href="HTTPSamplerBase.html#followRedirects(org.apache.jmeter.protocol.http.sampler.HTTPSampleResult,int)">followRedirects</a>, <a href="HTTPSamplerBase.html#getArguments()">getArguments</a>, <a href="HTTPSamplerBase.html#getAuthManager()">getAuthManager</a>, <a href="HTTPSamplerBase.html#getAutoRedirects()">getAutoRedirects</a>, <a href="HTTPSamplerBase.html#getCacheManager()">getCacheManager</a>, <a href="HTTPSamplerBase.html#getConcurrentPool()">getConcurrentPool</a>, <a href="HTTPSamplerBase.html#getConnectTimeout()">getConnectTimeout</a>, <a href="HTTPSamplerBase.html#getContentEncoding()">getContentEncoding</a>, <a href="HTTPSamplerBase.html#getCookieManager()">getCookieManager</a>, <a href="HTTPSamplerBase.html#getDefaultPort(java.lang.String,int)">getDefaultPort</a>, <a href="HTTPSamplerBase.html#getDNSResolver()">getDNSResolver</a>, <a href="HTTPSamplerBase.html#getDoBrowserCompatibleMultipart()">getDoBrowserCompatibleMultipart</a>, <a href="HTTPSamplerBase.html#getDoMultipart()">getDoMultipart</a>, <a href="HTTPSamplerBase.html#getDoMultipartPost()">getDoMultipartPost</a>, <a href="HTTPSamplerBase.html#getEmbeddedUrlRE()">getEmbeddedUrlRE</a>, <a href="HTTPSamplerBase.html#getEmbededUrlExcludeRE()">getEmbededUrlExcludeRE</a>, <a href="HTTPSamplerBase.html#getFollowRedirects()">getFollowRedirects</a>, <a href="HTTPSamplerBase.html#getHeaderManager()">getHeaderManager</a>, <a href="HTTPSamplerBase.html#getHTTPFileCount()">getHTTPFileCount</a>, <a href="HTTPSamplerBase.html#getHTTPFiles()">getHTTPFiles</a>, <a href="HTTPSamplerBase.html#getImplementation()">getImplementation</a>, <a href="HTTPSamplerBase.html#getIpSource()">getIpSource</a>, <a href="HTTPSamplerBase.html#getIpSourceType()">getIpSourceType</a>, <a href="HTTPSamplerBase.html#getKeystoreConfig()">getKeystoreConfig</a>, <a href="HTTPSamplerBase.html#getMethod()">getMethod</a>, <a href="HTTPSamplerBase.html#getMonitor()">getMonitor</a>, <a href="HTTPSamplerBase.html#getPath()">getPath</a>, <a href="HTTPSamplerBase.html#getPort()">getPort</a>, <a href="HTTPSamplerBase.html#getPortIfSpecified()">getPortIfSpecified</a>, <a href="HTTPSamplerBase.html#getPostBodyRaw()">getPostBodyRaw</a>, <a href="HTTPSamplerBase.html#getProps()">getProps</a>, <a href="HTTPSamplerBase.html#getProxyHost()">getProxyHost</a>, <a href="HTTPSamplerBase.html#getProxyPass()">getProxyPass</a>, <a href="HTTPSamplerBase.html#getProxyPortInt()">getProxyPortInt</a>, <a href="HTTPSamplerBase.html#getProxyScheme()">getProxyScheme</a>, <a href="HTTPSamplerBase.html#getProxyUser()">getProxyUser</a>, <a href="HTTPSamplerBase.html#getQueryString()">getQueryString</a>, <a href="HTTPSamplerBase.html#getQueryString(java.lang.String)">getQueryString</a>, <a href="HTTPSamplerBase.html#getResponseTimeout()">getResponseTimeout</a>, <a href="HTTPSamplerBase.html#getSchema()">getSchema</a>, <a href="HTTPSamplerBase.html#getSendFileAsPostBody()">getSendFileAsPostBody</a>, <a href="HTTPSamplerBase.html#getSendParameterValuesAsPostBody()">getSendParameterValuesAsPostBody</a>, <a href="HTTPSamplerBase.html#getSourceTypeList()">getSourceTypeList</a>, <a href="HTTPSamplerBase.html#getUrl()">getUrl</a>, <a href="HTTPSamplerBase.html#getUseKeepAlive()">getUseKeepAlive</a>, <a href="HTTPSamplerBase.html#getUseMultipart()">getUseMultipart</a>, <a href="HTTPSamplerBase.html#getUseMultipartForPost()">getUseMultipartForPost</a>, <a href="HTTPSamplerBase.html#getValidMethodsAsArray()">getValidMethodsAsArray</a>, <a href="HTTPSamplerBase.html#hasArguments()">hasArguments</a>, <a href="HTTPSamplerBase.html#isConcurrentDwn()">isConcurrentDwn</a>, <a href="HTTPSamplerBase.html#isImageParser()">isImageParser</a>, <a href="HTTPSamplerBase.html#isMonitor()">isMonitor</a>, <a href="HTTPSamplerBase.html#isProtocolDefaultPort()">isProtocolDefaultPort</a>, <a href="HTTPSamplerBase.html#isSecure(java.lang.String)">isSecure</a>, <a href="HTTPSamplerBase.html#isSecure(java.net.URL)">isSecure</a>, <a href="HTTPSamplerBase.html#isSuccessCode(int)">isSuccessCode</a>, <a href="HTTPSamplerBase.html#parseArguments(java.lang.String)">parseArguments</a>, <a href="HTTPSamplerBase.html#parseArguments(java.lang.String,java.lang.String)">parseArguments</a>, <a href="HTTPSamplerBase.html#readResponse(org.apache.jmeter.samplers.SampleResult,java.io.InputStream,long)">readResponse</a>, <a href="HTTPSamplerBase.html#replace(java.lang.String,java.lang.String,boolean)">replace</a>, <a href="HTTPSamplerBase.html#resultProcessing(boolean,int,org.apache.jmeter.protocol.http.sampler.HTTPSampleResult)">resultProcessing</a>, <a href="HTTPSamplerBase.html#sample()">sample</a>, <a href="HTTPSamplerBase.html#setArguments(org.apache.jmeter.config.Arguments)">setArguments</a>, <a href="HTTPSamplerBase.html#setAuthManager(org.apache.jmeter.protocol.http.control.AuthManager)">setAuthManager</a>, <a href="HTTPSamplerBase.html#setAutoRedirects(boolean)">setAutoRedirects</a>, <a href="HTTPSamplerBase.html#setCacheManager(org.apache.jmeter.protocol.http.control.CacheManager)">setCacheManager</a>, <a href="HTTPSamplerBase.html#setConcurrentDwn(boolean)">setConcurrentDwn</a>, <a href="HTTPSamplerBase.html#setConcurrentPool(java.lang.String)">setConcurrentPool</a>, <a href="HTTPSamplerBase.html#setConnectTimeout(java.lang.String)">setConnectTimeout</a>, <a href="HTTPSamplerBase.html#setContentEncoding(java.lang.String)">setContentEncoding</a>, <a href="HTTPSamplerBase.html#setCookieManager(org.apache.jmeter.protocol.http.control.CookieManager)">setCookieManager</a>, <a href="HTTPSamplerBase.html#setDNSResolver(org.apache.jmeter.protocol.http.control.DNSCacheManager)">setDNSResolver</a>, <a href="HTTPSamplerBase.html#setDoBrowserCompatibleMultipart(boolean)">setDoBrowserCompatibleMultipart</a>, <a href="HTTPSamplerBase.html#setDoMultipart(boolean)">setDoMultipart</a>, <a href="HTTPSamplerBase.html#setDoMultipartPost(boolean)">setDoMultipartPost</a>, <a href="HTTPSamplerBase.html#setEmbeddedUrlExcludeRE(java.lang.String)">setEmbeddedUrlExcludeRE</a>, <a href="HTTPSamplerBase.html#setEmbeddedUrlRE(java.lang.String)">setEmbeddedUrlRE</a>, <a href="HTTPSamplerBase.html#setFollowRedirects(boolean)">setFollowRedirects</a>, <a href="HTTPSamplerBase.html#setHeaderManager(org.apache.jmeter.protocol.http.control.HeaderManager)">setHeaderManager</a>, <a href="HTTPSamplerBase.html#setHTTPFiles(org.apache.jmeter.protocol.http.util.HTTPFileArg%5B%5D)">setHTTPFiles</a>, <a href="HTTPSamplerBase.html#setImageParser(boolean)">setImageParser</a>, <a href="HTTPSamplerBase.html#setImplementation(java.lang.String)">setImplementation</a>, <a href="HTTPSamplerBase.html#setIpSource(java.lang.String)">setIpSource</a>, <a href="HTTPSamplerBase.html#setIpSourceType(int)">setIpSourceType</a>, <a href="HTTPSamplerBase.html#setKeystoreConfig(org.apache.jmeter.config.KeystoreConfig)">setKeystoreConfig</a>, <a href="HTTPSamplerBase.html#setMD5(boolean)">setMD5</a>, <a href="HTTPSamplerBase.html#setMethod(java.lang.String)">setMethod</a>, <a href="HTTPSamplerBase.html#setMonitor(boolean)">setMonitor</a>, <a href="HTTPSamplerBase.html#setMonitor(java.lang.String)">setMonitor</a>, <a href="HTTPSamplerBase.html#setPath(java.lang.String)">setPath</a>, <a href="HTTPSamplerBase.html#setPath(java.lang.String,java.lang.String)">setPath</a>, <a href="HTTPSamplerBase.html#setPort(int)">setPort</a>, <a href="HTTPSamplerBase.html#setPostBodyRaw(boolean)">setPostBodyRaw</a>, <a href="HTTPSamplerBase.html#setProxyHost(java.lang.String)">setProxyHost</a>, <a href="HTTPSamplerBase.html#setProxyPass(java.lang.String)">setProxyPass</a>, <a href="HTTPSamplerBase.html#setProxyPortInt(java.lang.String)">setProxyPortInt</a>, <a href="HTTPSamplerBase.html#setProxyScheme(java.lang.String)">setProxyScheme</a>, <a href="HTTPSamplerBase.html#setProxyUser(java.lang.String)">setProxyUser</a>, <a href="HTTPSamplerBase.html#setResponseTimeout(java.lang.String)">setResponseTimeout</a>, <a href="HTTPSamplerBase.html#setUseKeepAlive(boolean)">setUseKeepAlive</a>, <a href="HTTPSamplerBase.html#testEnded(java.lang.String)">testEnded</a>, <a href="HTTPSamplerBase.html#testIterationStart(org.apache.jmeter.engine.event.LoopIterationEvent)">testIterationStart</a>, <a href="HTTPSamplerBase.html#testStarted(java.lang.String)">testStarted</a>, <a href="HTTPSamplerBase.html#threadStarted()">threadStarted</a>, <a href="HTTPSamplerBase.html#toString()">toString</a>, <a href="HTTPSamplerBase.html#useMD5()">useMD5</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#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#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#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>canRemove, clear, 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, 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>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.jmeter.testelement.ThreadListener">Methods inherited from interface&nbsp;org.apache.jmeter.testelement.<a href="../../../testelement/ThreadListener.html" title="interface in org.apache.jmeter.testelement">ThreadListener</a></h3>
<code><a href="../../../testelement/ThreadListener.html#threadStarted()">threadStarted</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="DEFAULT_CLASS">
<h3>DEFAULT_CLASS</h3>
<div class="member-signature"><span class="modifiers">public static final</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">DEFAULT_CLASS</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../../constant-values.html#org.apache.jmeter.protocol.http.sampler.AccessLogSampler.DEFAULT_CLASS">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
<!-- ========= 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>AccessLogSampler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">AccessLogSampler</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="setLogFile(java.lang.String)">
<h3>setLogFile</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLogFile</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;path)</span></div>
<div class="block">Set the path where XML messages are stored for random selection.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>path</code> - path where to store XML messages</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getLogFile()">
<h3>getLogFile</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">getLogFile</span>()</div>
<div class="block">Get the path where XML messages are stored. this is the directory where
 JMeter will randomly select a file.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>path where XML messages are stored</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setParserClassName(java.lang.String)">
<h3>setParserClassName</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setParserClassName</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">it's kinda obvious, but we state it anyways. Set the xml file with a
 string path.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>classname</code> - -
            parser class name</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getParserClassName()">
<h3>getParserClassName</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">getParserClassName</span>()</div>
<div class="block">Get the file location of the xml file.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>String file path.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sampleWithParser()">
<h3>sampleWithParser</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">sampleWithParser</span>()</div>
<div class="block">sample gets a new HTTPSampler from the generator and calls it's sample()
 method.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>newly generated and called sample</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;e)</span></div>
<div class="block">sample(Entry e) simply calls sample().</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>Overrides:</dt>
<dd><code><a href="HTTPSamplerBase.html#sample(org.apache.jmeter.samplers.Entry)">sample</a></code>&nbsp;in class&nbsp;<code><a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a></code></dd>
<dt>Parameters:</dt>
<dd><code>e</code> - -
            ignored</dd>
<dt>Returns:</dt>
<dd>the new sample</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="instantiateParser()">
<h3>instantiateParser</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">instantiateParser</span>()</div>
<div class="block">Method will instantiate the log parser based on the class in the text
 field. This was done to make it easier for people to plugin their own log
 parser and use different log parser.</div>
</section>
</li>
<li>
<section class="detail" id="getFilterClassName()">
<h3>getFilterClassName</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">getFilterClassName</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Returns the filterClassName.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setFilterClassName(java.lang.String)">
<h3>setFilterClassName</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setFilterClassName</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;filterClassName)</span></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>filterClassName</code> - The filterClassName to set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getDomain()">
<h3>getDomain</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">getDomain</span>()</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="HTTPSamplerBase.html#getDomain()">getDomain</a></code>&nbsp;in class&nbsp;<code><a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a></code></dd>
<dt>Returns:</dt>
<dd>Returns the domain.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setDomain(java.lang.String)">
<h3>setDomain</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setDomain</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;domain)</span></div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="HTTPSamplerBase.html#setDomain(java.lang.String)">setDomain</a></code>&nbsp;in class&nbsp;<code><a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a></code></dd>
<dt>Parameters:</dt>
<dd><code>domain</code> - The domain to set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isImageParsing()">
<h3>isImageParsing</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isImageParsing</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Returns the imageParsing.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setImageParsing(boolean)">
<h3>setImageParsing</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setImageParsing</span><wbr><span class="parameters">(boolean&nbsp;imageParsing)</span></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>imageParsing</code> - The imageParsing to set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPortString()">
<h3>getPortString</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">getPortString</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Returns the port.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setPortString(java.lang.String)">
<h3>setPortString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setPortString</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;port)</span></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>port</code> - The port to set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setProtocol(java.lang.String)">
<h3>setProtocol</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProtocol</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;value)</span></div>
<div class="block">Sets the scheme, with default</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="HTTPSamplerBase.html#setProtocol(java.lang.String)">setProtocol</a></code>&nbsp;in class&nbsp;<code><a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a></code></dd>
<dt>Parameters:</dt>
<dd><code>value</code> - the protocol</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProtocol()">
<h3>getProtocol</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">getProtocol</span>()</div>
<div class="block">Gets the protocol, with default.</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="HTTPSamplerBase.html#getProtocol()">getProtocol</a></code>&nbsp;in class&nbsp;<code><a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a></code></dd>
<dt>Returns:</dt>
<dd>the protocol</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="initFilter()">
<h3>initFilter</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">initFilter</span>()</div>
</section>
</li>
<li>
<section class="detail" id="clone()">
<h3>clone</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/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">clone</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>clone</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Overrides:</dt>
<dd><code><a href="../../../testelement/AbstractTestElement.html#clone()">clone</a></code>&nbsp;in class&nbsp;<code><a href="../../../testelement/AbstractTestElement.html" title="class in org.apache.jmeter.testelement">AbstractTestElement</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="testEnded()">
<h3>testEnded</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">testEnded</span>()</div>
<div class="block"><p>
 Called once for all threads after the end of a test.

 This will use the same element instances as at the start of the test.
 </p>

 <p>
 <b>
 N.B. testStarted() and testEnded() are called from different threads.
 </b>
 </p></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../../testelement/TestStateListener.html#testEnded()">testEnded</a></code>&nbsp;in interface&nbsp;<code><a href="../../../testelement/TestStateListener.html" title="interface in org.apache.jmeter.testelement">TestStateListener</a></code></dd>
<dt>Overrides:</dt>
<dd><code><a href="HTTPSamplerBase.html#testEnded()">testEnded</a></code>&nbsp;in class&nbsp;<code><a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a></code></dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="../../../engine/StandardJMeterEngine.html#stopTest()"><code>StandardJMeterEngine.stopTest()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="testStarted()">
<h3>testStarted</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">testStarted</span>()</div>
<div class="block"><p>
 Called just before the start of the test from the main engine thread.

 This is before the test elements are cloned.

 Note that not all the test
 variables will have been set up at this point.
 </p>

 <p>
 <b>
 N.B. testStarted() and testEnded() are called from different threads.
 </b>
 </p></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../../testelement/TestStateListener.html#testStarted()">testStarted</a></code>&nbsp;in interface&nbsp;<code><a href="../../../testelement/TestStateListener.html" title="interface in org.apache.jmeter.testelement">TestStateListener</a></code></dd>
<dt>Overrides:</dt>
<dd><code><a href="HTTPSamplerBase.html#testStarted()">testStarted</a></code>&nbsp;in class&nbsp;<code><a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a></code></dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../engine/StandardJMeterEngine.html#run()"><code>StandardJMeterEngine.run()</code></a></li>
</ul>
</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">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>
<dt>Overrides:</dt>
<dd><code><a href="HTTPSamplerBase.html#threadFinished()">threadFinished</a></code>&nbsp;in class&nbsp;<code><a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a></code></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>
