<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>HTTPSamplerBase (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: HTTPSamplerBase">
<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 HTTPSamplerBase" class="title">Class HTTPSamplerBase</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.http.sampler.HTTPSamplerBase</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/Sampler.html" title="interface in org.apache.jmeter.samplers">Sampler</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>
<dl class="notes">
<dt>Direct Known Subclasses:</dt>
<dd><code><a href="AjpSampler.html" title="class in org.apache.jmeter.protocol.http.sampler">AjpSampler</a></code>, <code><a href="HTTPSampler.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampler</a></code>, <code><a href="HTTPSamplerProxy.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerProxy</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public abstract class </span><span class="element-name type-name-label">HTTPSamplerBase</span>
<span class="extends-implements">extends <a href="../../../samplers/AbstractSampler.html" title="class in org.apache.jmeter.samplers">AbstractSampler</a>
implements <a href="../../../testelement/TestStateListener.html" title="interface in org.apache.jmeter.testelement">TestStateListener</a>, <a href="../../../testelement/TestIterationListener.html" title="interface in org.apache.jmeter.testelement">TestIterationListener</a>, <a href="../../../testelement/ThreadListener.html" title="interface in org.apache.jmeter.testelement">ThreadListener</a>, <a href="../util/HTTPConstantsInterface.html" title="interface in org.apache.jmeter.protocol.http.util">HTTPConstantsInterface</a>, <a href="../../../gui/Replaceable.html" title="interface in org.apache.jmeter.gui">Replaceable</a></span></div>
<div class="block">Common constants and methods for HTTP samplers</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.HTTPSamplerBase">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="caption"><span>Nested Classes</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">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static enum&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="HTTPSamplerBase.SourceType.html" class="type-name-link" title="enum in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase.SourceType</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
</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="#ARGUMENTS" class="member-name-link">ARGUMENTS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#AUTH_MANAGER" class="member-name-link">AUTH_MANAGER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#AUTO_REDIRECTS" class="member-name-link">AUTO_REDIRECTS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#BROWSER_COMPATIBLE_MULTIPART" class="member-name-link">BROWSER_COMPATIBLE_MULTIPART</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final boolean</code></div>
<div class="col-second even-row-color"><code><a href="#BROWSER_COMPATIBLE_MULTIPART_MODE_DEFAULT" class="member-name-link">BROWSER_COMPATIBLE_MULTIPART_MODE_DEFAULT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#CACHE_MANAGER" class="member-name-link">CACHE_MANAGER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#CONCURRENT_DWN" class="member-name-link">CONCURRENT_DWN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#CONCURRENT_POOL" class="member-name-link">CONCURRENT_POOL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final int</code></div>
<div class="col-second even-row-color"><code><a href="#CONCURRENT_POOL_SIZE" class="member-name-link">CONCURRENT_POOL_SIZE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#CONNECT_TIMEOUT" class="member-name-link">CONNECT_TIMEOUT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#CONTENT_ENCODING" class="member-name-link">CONTENT_ENCODING</a></code></div>
<div class="col-last even-row-color">
<div class="block">This is the encoding used for the content, i.e.</div>
</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#CONTENT_TYPE" class="member-name-link">CONTENT_TYPE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#COOKIE_MANAGER" class="member-name-link">COOKIE_MANAGER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#DEFAULT_METHOD" class="member-name-link">DEFAULT_METHOD</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#DNS_CACHE_MANAGER" class="member-name-link">DNS_CACHE_MANAGER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#DO_MULTIPART_POST" class="member-name-link">DO_MULTIPART_POST</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#DOMAIN" class="member-name-link">DOMAIN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#EMBEDDED_URL_EXCLUDE_RE" class="member-name-link">EMBEDDED_URL_EXCLUDE_RE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#EMBEDDED_URL_RE" class="member-name-link">EMBEDDED_URL_RE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#FOLLOW_REDIRECTS" class="member-name-link">FOLLOW_REDIRECTS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#HEADER_MANAGER" class="member-name-link">HEADER_MANAGER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#IMAGE_PARSER" class="member-name-link">IMAGE_PARSER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#IMPLEMENTATION" class="member-name-link">IMPLEMENTATION</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#IP_SOURCE" class="member-name-link">IP_SOURCE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">IP source to use - does not apply to Java HTTP implementation currently</div>
</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="#IP_SOURCE_TYPE" class="member-name-link">IP_SOURCE_TYPE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#KEYSTORE_CONFIG" class="member-name-link">KEYSTORE_CONFIG</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected static final int</code></div>
<div class="col-second even-row-color"><code><a href="#MAX_FRAME_DEPTH" class="member-name-link">MAX_FRAME_DEPTH</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected static final int</code></div>
<div class="col-second odd-row-color"><code><a href="#MAX_REDIRECTS" class="member-name-link">MAX_REDIRECTS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#MD5" class="member-name-link">MD5</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#METHOD" class="member-name-link">METHOD</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#MONITOR" class="member-name-link">MONITOR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected 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 odd-row-color"><code><a href="#NON_HTTP_RESPONSE_CODE" class="member-name-link">NON_HTTP_RESPONSE_CODE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected 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="#NON_HTTP_RESPONSE_MESSAGE" class="member-name-link">NON_HTTP_RESPONSE_MESSAGE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#PATH" class="member-name-link">PATH</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#PORT" class="member-name-link">PORT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#POST_BODY_RAW" class="member-name-link">POST_BODY_RAW</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final boolean</code></div>
<div class="col-second even-row-color"><code><a href="#POST_BODY_RAW_DEFAULT" class="member-name-link">POST_BODY_RAW_DEFAULT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#PROTOCOL" class="member-name-link">PROTOCOL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#PROXYHOST" class="member-name-link">PROXYHOST</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#PROXYPASS" class="member-name-link">PROXYPASS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#PROXYPORT" class="member-name-link">PROXYPORT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#PROXYSCHEME" class="member-name-link">PROXYSCHEME</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#PROXYUSER" class="member-name-link">PROXYUSER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#RESPONSE_TIMEOUT" class="member-name-link">RESPONSE_TIMEOUT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#SAMPLE_TIMEOUT" class="member-name-link">SAMPLE_TIMEOUT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final int</code></div>
<div class="col-second odd-row-color"><code><a href="#SOURCE_TYPE_DEFAULT" class="member-name-link">SOURCE_TYPE_DEFAULT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final int</code></div>
<div class="col-second even-row-color"><code><a href="#UNSPECIFIED_PORT" class="member-name-link">UNSPECIFIED_PORT</a></code></div>
<div class="col-last even-row-color">
<div class="block">A number to indicate that the port has not been set.</div>
</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#UNSPECIFIED_PORT_AS_STRING" class="member-name-link">UNSPECIFIED_PORT_AS_STRING</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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="#URL" class="member-name-link">URL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final int</code></div>
<div class="col-second odd-row-color"><code><a href="#URL_UNSPECIFIED_PORT" class="member-name-link">URL_UNSPECIFIED_PORT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">If the port is not present in a URL, getPort() returns -1</div>
</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="#URL_UNSPECIFIED_PORT_AS_STRING" class="member-name-link">URL_UNSPECIFIED_PORT_AS_STRING</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#USE_KEEPALIVE" class="member-name-link">USE_KEEPALIVE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
</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 three-column-summary">
<div class="table-header col-first">Modifier</div>
<div class="table-header col-second">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>protected </code></div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">HTTPSamplerBase</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-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static 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-tab3" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab3', 3)" class="table-tab">Abstract 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><button id="method-summary-table-tab6" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab6', 3)" class="table-tab">Deprecated 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>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addArgument(java.lang.String,java.lang.String)" class="member-name-link">addArgument</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;name,
 <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">&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="#addArgument(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">addArgument</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;name,
 <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,
 <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;metadata)</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="#addEncodedArgument(java.lang.String,java.lang.String)" class="member-name-link">addEncodedArgument</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;name,
 <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">Add an argument which has already been encoded</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="#addEncodedArgument(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">addEncodedArgument</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;name,
 <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,
 <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;metaData)</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="#addEncodedArgument(java.lang.String,java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">addEncodedArgument</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;name,
 <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,
 <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;metaData,
 <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;contentEncoding)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates an HTTPArgument and adds it to the current set <a href="#getArguments()"><code>getArguments()</code></a> of arguments.</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="#addNonEncodedArgument(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">addNonEncodedArgument</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;name,
 <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,
 <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;metadata)</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="#addNonEncodedArgument(java.lang.String,java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">addNonEncodedArgument</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;name,
 <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,
 <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;metadata,
 <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;contentType)</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="#addTestElement(org.apache.jmeter.testelement.TestElement)" class="member-name-link">addTestElement</a><wbr>(org.apache.jmeter.testelement.TestElement&nbsp;el)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"></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="#applies(org.apache.jmeter.config.ConfigTestElement)" class="member-name-link">applies</a><wbr>(<a href="../../../config/ConfigTestElement.html" title="class in org.apache.jmeter.config">ConfigTestElement</a>&nbsp;configElement)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Does configElement apply to Sampler</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="#clearTestElementChildren()" class="member-name-link">clearTestElementChildren</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"></div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#downloadPageResources(org.apache.jmeter.protocol.http.sampler.HTTPSampleResult,org.apache.jmeter.protocol.http.sampler.HTTPSampleResult,int)" class="member-name-link">downloadPageResources</a><wbr>(<a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a>&nbsp;pRes,
 <a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a>&nbsp;container,
 int&nbsp;frameDepth)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Download the resources of an HTML page.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>protected static <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-tab1 method-summary-table-tab4"><code><a href="#encodeBackSlashes(java.lang.String)" class="member-name-link">encodeBackSlashes</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 odd-row-color method-summary-table method-summary-table-tab1 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>protected <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="#encodeSpaces(java.lang.String)" class="member-name-link">encodeSpaces</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 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>protected <a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#errorResult(java.lang.Throwable,org.apache.jmeter.protocol.http.sampler.HTTPSampleResult)" class="member-name-link">errorResult</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;e,
 <a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a>&nbsp;res)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Populates the provided HTTPSampleResult with details from the Exception.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#followRedirects(org.apache.jmeter.protocol.http.sampler.HTTPSampleResult,int)" class="member-name-link">followRedirects</a><wbr>(<a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a>&nbsp;res,
 int&nbsp;frameDepth)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Iteratively download the redirect targets of a redirect response.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../../config/Arguments.html" title="class in org.apache.jmeter.config">Arguments</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getArguments()" class="member-name-link">getArguments</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="../control/AuthManager.html" title="class in org.apache.jmeter.protocol.http.control">AuthManager</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getAuthManager()" class="member-name-link">getAuthManager</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="#getAutoRedirects()" class="member-name-link">getAutoRedirects</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="../control/CacheManager.html" title="class in org.apache.jmeter.protocol.http.control">CacheManager</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCacheManager()" class="member-name-link">getCacheManager</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="#getConcurrentPool()" class="member-name-link">getConcurrentPool</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 pool size for concurrent thread pool to get embedded resources.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getConnectTimeout()" class="member-name-link">getConnectTimeout</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="#getContentEncoding()" class="member-name-link">getContentEncoding</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="../control/CookieManager.html" title="class in org.apache.jmeter.protocol.http.control">CookieManager</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCookieManager()" class="member-name-link">getCookieManager</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-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getDefaultPort(java.lang.String,int)" class="member-name-link">getDefaultPort</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;protocol,
 int&nbsp;port)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get the port number for a URL, applying defaults if necessary.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../control/DNSCacheManager.html" title="class in org.apache.jmeter.protocol.http.control">DNSCacheManager</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getDNSResolver()" class="member-name-link">getDNSResolver</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="#getDoBrowserCompatibleMultipart()" class="member-name-link">getDoBrowserCompatibleMultipart</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="#getDomain()" class="member-name-link">getDomain</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="#getDoMultipart()" class="member-name-link">getDoMultipart</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 method-summary-table-tab6"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#getDoMultipartPost()" class="member-name-link">getDoMultipartPost</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">use <a href="#getDoMultipart()"><code>getDoMultipart()</code></a></div>
</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="#getEmbeddedUrlRE()" class="member-name-link">getEmbeddedUrlRE</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 regular expression URLs must match.</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="#getEmbededUrlExcludeRE()" class="member-name-link">getEmbededUrlExcludeRE</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="#getFollowRedirects()" class="member-name-link">getFollowRedirects</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="../control/HeaderManager.html" title="class in org.apache.jmeter.protocol.http.control">HeaderManager</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getHeaderManager()" class="member-name-link">getHeaderManager</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>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getHTTPFileCount()" class="member-name-link">getHTTPFileCount</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="../util/HTTPFileArg.html" title="class in org.apache.jmeter.protocol.http.util">HTTPFileArg</a>[]</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getHTTPFiles()" class="member-name-link">getHTTPFiles</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 collection of files as a list.</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="#getImplementation()" class="member-name-link">getImplementation</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="#getIpSource()" class="member-name-link">getIpSource</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 IP source to use - does not apply to Java HTTP implementation currently</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getIpSourceType()" class="member-name-link">getIpSourceType</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 IP/address source type to use</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../../config/KeystoreConfig.html" title="class in org.apache.jmeter.config">KeystoreConfig</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getKeystoreConfig()" class="member-name-link">getKeystoreConfig</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="#getMethod()" class="member-name-link">getMethod</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 method-summary-table-tab6"><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 method-summary-table-tab6"><code><a href="#getMonitor()" class="member-name-link">getMonitor</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">since 3.2 always returns false</div>
</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="#getPath()" class="member-name-link">getPath</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>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getPort()" class="member-name-link">getPort</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 port; apply the default for the protocol if necessary.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getPortIfSpecified()" class="member-name-link">getPortIfSpecified</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 port number from the port string, allowing for trailing blanks.</div>
</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="#getPostBodyRaw()" class="member-name-link">getPostBodyRaw</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>org.apache.jmeter.testelement.schema.PropertiesAccessor&lt;? extends <a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a>,<wbr>? extends org.apache.jmeter.protocol.http.sampler.HTTPSamplerBaseSchema&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getProps()" class="member-name-link">getProps</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><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="#getProxyHost()" class="member-name-link">getProxyHost</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="#getProxyPass()" class="member-name-link">getProxyPass</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>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getProxyPortInt()" class="member-name-link">getProxyPortInt</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="#getProxyScheme()" class="member-name-link">getProxyScheme</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="#getProxyUser()" class="member-name-link">getProxyUser</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="#getQueryString()" class="member-name-link">getQueryString</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 QueryString attribute of the UrlConfig object, using
 UTF-8 to encode the URL</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="#getQueryString(java.lang.String)" class="member-name-link">getQueryString</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;contentEncoding)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the QueryString attribute of the UrlConfig object, using the
 specified encoding to encode the parameter values put into the URL</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getResponseTimeout()" class="member-name-link">getResponseTimeout</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>org.apache.jmeter.protocol.http.sampler.HTTPSamplerBaseSchema</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getSchema()" class="member-name-link">getSchema</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="#getSendFileAsPostBody()" class="member-name-link">getSendFileAsPostBody</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Determine if the file should be sent as the entire Content body,
 i.e.</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="#getSendParameterValuesAsPostBody()" class="member-name-link">getSendParameterValuesAsPostBody</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Determine if none of the parameters have a name, and if that is the case,
 it means that the parameter values should be sent as the entity body</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <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-tab1 method-summary-table-tab4"><code><a href="#getSourceTypeList()" class="member-name-link">getSourceTypeList</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 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/net/URL.html" title="class or interface in java.net" class="external-link">URL</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getUrl()" class="member-name-link">getUrl</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 URL, built from its component parts.</div>
</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="#getUseKeepAlive()" class="member-name-link">getUseKeepAlive</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="#getUseMultipart()" class="member-name-link">getUseMultipart</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Determine if we should use multipart/form-data or
 application/x-www-form-urlencoded for the post</div>
</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="#getUseMultipartForPost()" class="member-name-link">getUseMultipartForPost</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Determine if we should use multipart/form-data or
 application/x-www-form-urlencoded for the post</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <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-tab1 method-summary-table-tab4"><code><a href="#getValidMethodsAsArray()" class="member-name-link">getValidMethodsAsArray</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 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="#hasArguments()" class="member-name-link">hasArguments</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="#isConcurrentDwn()" class="member-name-link">isConcurrentDwn</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Return if used a concurrent thread pool to get embedded resources.</div>
</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="#isImageParser()" class="member-name-link">isImageParser</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 method-summary-table-tab6"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#isMonitor()" class="member-name-link">isMonitor</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">since 3.2 always returns false</div>
</div>
</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="#isProtocolDefaultPort()" class="member-name-link">isProtocolDefaultPort</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Tell whether the default port for the specified protocol is used</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isSecure(java.lang.String)" class="member-name-link">isSecure</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;protocol)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isSecure(java.net.URL)" class="member-name-link">isSecure</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/URL.html" title="class or interface in java.net" class="external-link">URL</a>&nbsp;url)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 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>protected boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isSuccessCode(int)" class="member-name-link">isSuccessCode</a><wbr>(int&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">Determine if the HTTP status code is successful or not
 i.e.</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="#parseArguments(java.lang.String)" class="member-name-link">parseArguments</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;queryString)</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="#parseArguments(java.lang.String,java.lang.String)" class="member-name-link">parseArguments</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;queryString,
 <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;contentEncoding)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">This method allows a proxy server to send over the raw text from a
 browser's output stream to be parsed and stored correctly into the
 UrlConfig object.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>byte[]</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readResponse(org.apache.jmeter.samplers.SampleResult,java.io.InputStream,long)" class="member-name-link">readResponse</a><wbr>(<a href="../../../samplers/SampleResult.html" title="class in org.apache.jmeter.samplers">SampleResult</a>&nbsp;sampleResult,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;in,
 long&nbsp;length)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Read response from the input stream, converting to MD5 digest if the useMD5 property is set.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#replace(java.lang.String,java.lang.String,boolean)" class="member-name-link">replace</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;regex,
 <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;replaceBy,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Replace by replaceBy in path and body (arguments) properties</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#resultProcessing(boolean,int,org.apache.jmeter.protocol.http.sampler.HTTPSampleResult)" class="member-name-link">resultProcessing</a><wbr>(boolean&nbsp;pAreFollowingRedirect,
 int&nbsp;frameDepth,
 <a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a>&nbsp;pRes)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Follow redirects and download page resources if appropriate.</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="#sample()" class="member-name-link">sample</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Perform a sample, and return the results</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract <a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#sample(java.net.URL,java.lang.String,boolean,int)" class="member-name-link">sample</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/URL.html" title="class or interface in java.net" class="external-link">URL</a>&nbsp;u,
 <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;method,
 boolean&nbsp;areFollowingRedirect,
 int&nbsp;depth)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Samples the URL passed in and stores the result in
 <code>HTTPSampleResult</code>, following redirects and downloading
 page resources as appropriate.</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="#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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Do a sampling and return its results.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>final void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setArguments(org.apache.jmeter.config.Arguments)" class="member-name-link">setArguments</a><wbr>(<a href="../../../config/Arguments.html" title="class in org.apache.jmeter.config">Arguments</a>&nbsp;value)</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="#setAuthManager(org.apache.jmeter.protocol.http.control.AuthManager)" class="member-name-link">setAuthManager</a><wbr>(<a href="../control/AuthManager.html" title="class in org.apache.jmeter.protocol.http.control">AuthManager</a>&nbsp;value)</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="#setAutoRedirects(boolean)" class="member-name-link">setAutoRedirects</a><wbr>(boolean&nbsp;value)</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="#setCacheManager(org.apache.jmeter.protocol.http.control.CacheManager)" class="member-name-link">setCacheManager</a><wbr>(<a href="../control/CacheManager.html" title="class in org.apache.jmeter.protocol.http.control">CacheManager</a>&nbsp;value)</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="#setConcurrentDwn(boolean)" class="member-name-link">setConcurrentDwn</a><wbr>(boolean&nbsp;concurrentDwn)</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="#setConcurrentPool(java.lang.String)" class="member-name-link">setConcurrentPool</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;poolSize)</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="#setConnectTimeout(java.lang.String)" class="member-name-link">setConnectTimeout</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">&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="#setContentEncoding(java.lang.String)" class="member-name-link">setContentEncoding</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;charsetName)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the value of the encoding to be used for the content.</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="#setCookieManager(org.apache.jmeter.protocol.http.control.CookieManager)" class="member-name-link">setCookieManager</a><wbr>(<a href="../control/CookieManager.html" title="class in org.apache.jmeter.protocol.http.control">CookieManager</a>&nbsp;value)</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="#setDNSResolver(org.apache.jmeter.protocol.http.control.DNSCacheManager)" class="member-name-link">setDNSResolver</a><wbr>(<a href="../control/DNSCacheManager.html" title="class in org.apache.jmeter.protocol.http.control">DNSCacheManager</a>&nbsp;cacheManager)</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="#setDoBrowserCompatibleMultipart(boolean)" class="member-name-link">setDoBrowserCompatibleMultipart</a><wbr>(boolean&nbsp;value)</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="#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;value)</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="#setDoMultipart(boolean)" class="member-name-link">setDoMultipart</a><wbr>(boolean&nbsp;value)</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 method-summary-table-tab6"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#setDoMultipartPost(boolean)" class="member-name-link">setDoMultipartPost</a><wbr>(boolean&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">use <a href="#setDoMultipartPost(boolean)"><code>setDoMultipartPost(boolean)</code></a></div>
</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="#setEmbeddedUrlExcludeRE(java.lang.String)" class="member-name-link">setEmbeddedUrlExcludeRE</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;regex)</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="#setEmbeddedUrlRE(java.lang.String)" class="member-name-link">setEmbeddedUrlRE</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;regex)</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="#setFollowRedirects(boolean)" class="member-name-link">setFollowRedirects</a><wbr>(boolean&nbsp;value)</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="#setHeaderManager(org.apache.jmeter.protocol.http.control.HeaderManager)" class="member-name-link">setHeaderManager</a><wbr>(<a href="../control/HeaderManager.html" title="class in org.apache.jmeter.protocol.http.control">HeaderManager</a>&nbsp;value)</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="#setHTTPFiles(org.apache.jmeter.protocol.http.util.HTTPFileArg%5B%5D)" class="member-name-link">setHTTPFiles</a><wbr>(<a href="../util/HTTPFileArg.html" title="class in org.apache.jmeter.protocol.http.util">HTTPFileArg</a>[]&nbsp;files)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Saves the list of files.</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="#setImageParser(boolean)" class="member-name-link">setImageParser</a><wbr>(boolean&nbsp;parseImages)</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="#setImplementation(java.lang.String)" class="member-name-link">setImplementation</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">&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="#setIpSource(java.lang.String)" class="member-name-link">setIpSource</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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">set IP source to use - does not apply to Java HTTP implementation currently</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="#setIpSourceType(int)" class="member-name-link">setIpSourceType</a><wbr>(int&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">set IP/address source type to use</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="#setKeystoreConfig(org.apache.jmeter.config.KeystoreConfig)" class="member-name-link">setKeystoreConfig</a><wbr>(<a href="../../../config/KeystoreConfig.html" title="class in org.apache.jmeter.config">KeystoreConfig</a>&nbsp;value)</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="#setMD5(boolean)" class="member-name-link">setMD5</a><wbr>(boolean&nbsp;value)</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="#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;value)</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="#setMonitor(boolean)" class="member-name-link">setMonitor</a><wbr>(boolean&nbsp;truth)</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="#setMonitor(java.lang.String)" class="member-name-link">setMonitor</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 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="#setPath(java.lang.String)" class="member-name-link">setPath</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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the Path attribute of the UrlConfig object Also calls parseArguments
 to extract and store any query arguments</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="#setPath(java.lang.String,java.lang.String)" class="member-name-link">setPath</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,
 <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;contentEncoding)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the PATH property; if the request is a GET or DELETE (and the path
 does not start with http[s]://) it also calls <a href="#parseArguments(java.lang.String,java.lang.String)"><code>parseArguments(String, String)</code></a>
 to extract and store any query arguments.</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="#setPort(int)" class="member-name-link">setPort</a><wbr>(int&nbsp;value)</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="#setPostBodyRaw(boolean)" class="member-name-link">setPostBodyRaw</a><wbr>(boolean&nbsp;value)</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">&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="#setProxyHost(java.lang.String)" class="member-name-link">setProxyHost</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;host)</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="#setProxyPass(java.lang.String)" class="member-name-link">setProxyPass</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;pass)</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="#setProxyPortInt(java.lang.String)" class="member-name-link">setProxyPortInt</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="#setProxyScheme(java.lang.String)" class="member-name-link">setProxyScheme</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;schema)</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="#setProxyUser(java.lang.String)" class="member-name-link">setProxyUser</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;user)</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="#setResponseTimeout(java.lang.String)" class="member-name-link">setResponseTimeout</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">&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="#setUseKeepAlive(boolean)" class="member-name-link">setUseKeepAlive</a><wbr>(boolean&nbsp;value)</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="#testEnded()" class="member-name-link">testEnded</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 once for all threads after the end of a test.</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(java.lang.String)" class="member-name-link">testEnded</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;host)</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="#testIterationStart(org.apache.jmeter.engine.event.LoopIterationEvent)" class="member-name-link">testIterationStart</a><wbr>(<a href="../../../engine/event/LoopIterationEvent.html" title="class in org.apache.jmeter.engine.event">LoopIterationEvent</a>&nbsp;event)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Each time through a Thread Group's test script, an iteration event is
 fired for each 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="#testStarted()" class="member-name-link">testStarted</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 just before the start of the test from the main engine thread.</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(java.lang.String)" class="member-name-link">testStarted</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;host)</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 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">Called for each thread before starting sampling.</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="#toString()" class="member-name-link">toString</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="#useMD5()" class="member-name-link">useMD5</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
</div>
</div>
</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#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#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, 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, 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">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="ARGUMENTS">
<h3>ARGUMENTS</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">ARGUMENTS</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.HTTPSamplerBase.ARGUMENTS">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="AUTH_MANAGER">
<h3>AUTH_MANAGER</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">AUTH_MANAGER</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.HTTPSamplerBase.AUTH_MANAGER">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="COOKIE_MANAGER">
<h3>COOKIE_MANAGER</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">COOKIE_MANAGER</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.HTTPSamplerBase.COOKIE_MANAGER">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="KEYSTORE_CONFIG">
<h3>KEYSTORE_CONFIG</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">KEYSTORE_CONFIG</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.HTTPSamplerBase.KEYSTORE_CONFIG">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="SAMPLE_TIMEOUT">
<h3>SAMPLE_TIMEOUT</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">SAMPLE_TIMEOUT</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.HTTPSamplerBase.SAMPLE_TIMEOUT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="CACHE_MANAGER">
<h3>CACHE_MANAGER</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">CACHE_MANAGER</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.HTTPSamplerBase.CACHE_MANAGER">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="HEADER_MANAGER">
<h3>HEADER_MANAGER</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">HEADER_MANAGER</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.HTTPSamplerBase.HEADER_MANAGER">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DNS_CACHE_MANAGER">
<h3>DNS_CACHE_MANAGER</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">DNS_CACHE_MANAGER</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.HTTPSamplerBase.DNS_CACHE_MANAGER">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DOMAIN">
<h3>DOMAIN</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">DOMAIN</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.HTTPSamplerBase.DOMAIN">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="PORT">
<h3>PORT</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">PORT</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.HTTPSamplerBase.PORT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="PROXYSCHEME">
<h3>PROXYSCHEME</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">PROXYSCHEME</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.HTTPSamplerBase.PROXYSCHEME">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="PROXYHOST">
<h3>PROXYHOST</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">PROXYHOST</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.HTTPSamplerBase.PROXYHOST">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="PROXYPORT">
<h3>PROXYPORT</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">PROXYPORT</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.HTTPSamplerBase.PROXYPORT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="PROXYUSER">
<h3>PROXYUSER</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">PROXYUSER</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.HTTPSamplerBase.PROXYUSER">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="PROXYPASS">
<h3>PROXYPASS</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">PROXYPASS</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.HTTPSamplerBase.PROXYPASS">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="CONNECT_TIMEOUT">
<h3>CONNECT_TIMEOUT</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">CONNECT_TIMEOUT</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.HTTPSamplerBase.CONNECT_TIMEOUT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="RESPONSE_TIMEOUT">
<h3>RESPONSE_TIMEOUT</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">RESPONSE_TIMEOUT</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.HTTPSamplerBase.RESPONSE_TIMEOUT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="METHOD">
<h3>METHOD</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">METHOD</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.HTTPSamplerBase.METHOD">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="CONTENT_ENCODING">
<h3>CONTENT_ENCODING</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">CONTENT_ENCODING</span></div>
<div class="block">This is the encoding used for the content, i.e. the charset name, not the header "Content-Encoding"</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.HTTPSamplerBase.CONTENT_ENCODING">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="IMPLEMENTATION">
<h3>IMPLEMENTATION</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">IMPLEMENTATION</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.HTTPSamplerBase.IMPLEMENTATION">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="PATH">
<h3>PATH</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">PATH</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.HTTPSamplerBase.PATH">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="FOLLOW_REDIRECTS">
<h3>FOLLOW_REDIRECTS</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">FOLLOW_REDIRECTS</span></div>
</section>
</li>
<li>
<section class="detail" id="AUTO_REDIRECTS">
<h3>AUTO_REDIRECTS</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">AUTO_REDIRECTS</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.HTTPSamplerBase.AUTO_REDIRECTS">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="PROTOCOL">
<h3>PROTOCOL</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">PROTOCOL</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.HTTPSamplerBase.PROTOCOL">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="URL">
<h3>URL</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">URL</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.HTTPSamplerBase.URL">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="IP_SOURCE">
<h3>IP_SOURCE</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">IP_SOURCE</span></div>
<div class="block">IP source to use - does not apply to Java HTTP implementation currently</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.HTTPSamplerBase.IP_SOURCE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="IP_SOURCE_TYPE">
<h3>IP_SOURCE_TYPE</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">IP_SOURCE_TYPE</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.HTTPSamplerBase.IP_SOURCE_TYPE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="USE_KEEPALIVE">
<h3>USE_KEEPALIVE</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">USE_KEEPALIVE</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.HTTPSamplerBase.USE_KEEPALIVE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DO_MULTIPART_POST">
<h3>DO_MULTIPART_POST</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">DO_MULTIPART_POST</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.HTTPSamplerBase.DO_MULTIPART_POST">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="BROWSER_COMPATIBLE_MULTIPART">
<h3>BROWSER_COMPATIBLE_MULTIPART</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">BROWSER_COMPATIBLE_MULTIPART</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.HTTPSamplerBase.BROWSER_COMPATIBLE_MULTIPART">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="CONCURRENT_DWN">
<h3>CONCURRENT_DWN</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">CONCURRENT_DWN</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.HTTPSamplerBase.CONCURRENT_DWN">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="CONCURRENT_POOL">
<h3>CONCURRENT_POOL</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">CONCURRENT_POOL</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.HTTPSamplerBase.CONCURRENT_POOL">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="CONCURRENT_POOL_SIZE">
<h3>CONCURRENT_POOL_SIZE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">CONCURRENT_POOL_SIZE</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.HTTPSamplerBase.CONCURRENT_POOL_SIZE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="BROWSER_COMPATIBLE_MULTIPART_MODE_DEFAULT">
<h3>BROWSER_COMPATIBLE_MULTIPART_MODE_DEFAULT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">BROWSER_COMPATIBLE_MULTIPART_MODE_DEFAULT</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.HTTPSamplerBase.BROWSER_COMPATIBLE_MULTIPART_MODE_DEFAULT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="SOURCE_TYPE_DEFAULT">
<h3>SOURCE_TYPE_DEFAULT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">SOURCE_TYPE_DEFAULT</span></div>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_METHOD">
<h3>DEFAULT_METHOD</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_METHOD</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.HTTPSamplerBase.DEFAULT_METHOD">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="CONTENT_TYPE">
<h3>CONTENT_TYPE</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">CONTENT_TYPE</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.HTTPSamplerBase.CONTENT_TYPE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="IMAGE_PARSER">
<h3>IMAGE_PARSER</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">IMAGE_PARSER</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.HTTPSamplerBase.IMAGE_PARSER">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="EMBEDDED_URL_RE">
<h3>EMBEDDED_URL_RE</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">EMBEDDED_URL_RE</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.HTTPSamplerBase.EMBEDDED_URL_RE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="EMBEDDED_URL_EXCLUDE_RE">
<h3>EMBEDDED_URL_EXCLUDE_RE</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">EMBEDDED_URL_EXCLUDE_RE</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.HTTPSamplerBase.EMBEDDED_URL_EXCLUDE_RE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="MONITOR">
<h3>MONITOR</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">MONITOR</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.HTTPSamplerBase.MONITOR">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="MD5">
<h3>MD5</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">MD5</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.HTTPSamplerBase.MD5">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="UNSPECIFIED_PORT">
<h3>UNSPECIFIED_PORT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">UNSPECIFIED_PORT</span></div>
<div class="block">A number to indicate that the port has not been set.</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.HTTPSamplerBase.UNSPECIFIED_PORT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="UNSPECIFIED_PORT_AS_STRING">
<h3>UNSPECIFIED_PORT_AS_STRING</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">UNSPECIFIED_PORT_AS_STRING</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.HTTPSamplerBase.UNSPECIFIED_PORT_AS_STRING">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="URL_UNSPECIFIED_PORT">
<h3>URL_UNSPECIFIED_PORT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">URL_UNSPECIFIED_PORT</span></div>
<div class="block">If the port is not present in a URL, getPort() returns -1</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.HTTPSamplerBase.URL_UNSPECIFIED_PORT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="URL_UNSPECIFIED_PORT_AS_STRING">
<h3>URL_UNSPECIFIED_PORT_AS_STRING</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">URL_UNSPECIFIED_PORT_AS_STRING</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.HTTPSamplerBase.URL_UNSPECIFIED_PORT_AS_STRING">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="NON_HTTP_RESPONSE_CODE">
<h3>NON_HTTP_RESPONSE_CODE</h3>
<div class="member-signature"><span class="modifiers">protected 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">NON_HTTP_RESPONSE_CODE</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.HTTPSamplerBase.NON_HTTP_RESPONSE_CODE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="NON_HTTP_RESPONSE_MESSAGE">
<h3>NON_HTTP_RESPONSE_MESSAGE</h3>
<div class="member-signature"><span class="modifiers">protected 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">NON_HTTP_RESPONSE_MESSAGE</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.HTTPSamplerBase.NON_HTTP_RESPONSE_MESSAGE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="POST_BODY_RAW">
<h3>POST_BODY_RAW</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">POST_BODY_RAW</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.HTTPSamplerBase.POST_BODY_RAW">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="POST_BODY_RAW_DEFAULT">
<h3>POST_BODY_RAW_DEFAULT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">POST_BODY_RAW_DEFAULT</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.HTTPSamplerBase.POST_BODY_RAW_DEFAULT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="MAX_REDIRECTS">
<h3>MAX_REDIRECTS</h3>
<div class="member-signature"><span class="modifiers">protected static final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">MAX_REDIRECTS</span></div>
</section>
</li>
<li>
<section class="detail" id="MAX_FRAME_DEPTH">
<h3>MAX_FRAME_DEPTH</h3>
<div class="member-signature"><span class="modifiers">protected static final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">MAX_FRAME_DEPTH</span></div>
</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>HTTPSamplerBase</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="element-name">HTTPSamplerBase</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="getSchema()">
<h3>getSchema</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jmeter.protocol.http.sampler.HTTPSamplerBaseSchema</span>&nbsp;<span class="element-name">getSchema</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getSchema</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProps()">
<h3>getProps</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jmeter.testelement.schema.PropertiesAccessor&lt;? extends <a href="HTTPSamplerBase.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSamplerBase</a>,<wbr>? extends org.apache.jmeter.protocol.http.sampler.HTTPSamplerBaseSchema&gt;</span>&nbsp;<span class="element-name">getProps</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getProps</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSourceTypeList()">
<h3>getSourceTypeList</h3>
<div class="member-signature"><span class="modifiers">public static</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">getSourceTypeList</span>()</div>
</section>
</li>
<li>
<section class="detail" id="getSendFileAsPostBody()">
<h3>getSendFileAsPostBody</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getSendFileAsPostBody</span>()</div>
<div class="block">Determine if the file should be sent as the entire Content body,
 i.e. without any additional wrapping.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if specified file is to be sent as the body,
 i.e. there is a single file entry which has a non-empty path and
 an empty Parameter name.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSendParameterValuesAsPostBody()">
<h3>getSendParameterValuesAsPostBody</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getSendParameterValuesAsPostBody</span>()</div>
<div class="block">Determine if none of the parameters have a name, and if that is the case,
 it means that the parameter values should be sent as the entity body</div>
<dl class="notes">
<dt>Returns:</dt>
<dd><code>true</code> if there are parameters and none of these have a
         name specified, or <a href="#getPostBodyRaw()"><code>getPostBodyRaw()</code></a> returns
         <code>true</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getUseMultipartForPost()">
<h3>getUseMultipartForPost</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getUseMultipartForPost</span>()</div>
<div class="block">Determine if we should use multipart/form-data or
 application/x-www-form-urlencoded for the post</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if multipart/form-data should be used and method is POST</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getUseMultipart()">
<h3>getUseMultipart</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getUseMultipart</span>()</div>
<div class="block">Determine if we should use multipart/form-data or
 application/x-www-form-urlencoded for the post</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if multipart/form-data should be used and method is POST</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>
</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>Returns:</dt>
<dd>the protocol</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setPath(java.lang.String)">
<h3>setPath</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setPath</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">Sets the Path attribute of the UrlConfig object Also calls parseArguments
 to extract and store any query arguments</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>path</code> - The new Path value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setPath(java.lang.String,java.lang.String)">
<h3>setPath</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setPath</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,
 <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;contentEncoding)</span></div>
<div class="block">Sets the PATH property; if the request is a GET or DELETE (and the path
 does not start with http[s]://) it also calls <a href="#parseArguments(java.lang.String,java.lang.String)"><code>parseArguments(String, String)</code></a>
 to extract and store any query arguments.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>path</code> - The new Path value</dd>
<dd><code>contentEncoding</code> - The encoding used for the querystring parameter values</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPath()">
<h3>getPath</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">getPath</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setFollowRedirects(boolean)">
<h3>setFollowRedirects</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setFollowRedirects</span><wbr><span class="parameters">(boolean&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="getFollowRedirects()">
<h3>getFollowRedirects</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getFollowRedirects</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setAutoRedirects(boolean)">
<h3>setAutoRedirects</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setAutoRedirects</span><wbr><span class="parameters">(boolean&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="getAutoRedirects()">
<h3>getAutoRedirects</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getAutoRedirects</span>()</div>
</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;value)</span></div>
</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>
</section>
</li>
<li>
<section class="detail" id="setContentEncoding(java.lang.String)">
<h3>setContentEncoding</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setContentEncoding</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;charsetName)</span></div>
<div class="block">Sets the value of the encoding to be used for the content.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>charsetName</code> - the name of the encoding to be used</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getContentEncoding()">
<h3>getContentEncoding</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">getContentEncoding</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the encoding of the content, i.e. its charset name</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setUseKeepAlive(boolean)">
<h3>setUseKeepAlive</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setUseKeepAlive</span><wbr><span class="parameters">(boolean&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="getUseKeepAlive()">
<h3>getUseKeepAlive</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getUseKeepAlive</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setDoMultipartPost(boolean)">
<h3>setDoMultipartPost</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setDoMultipartPost</span><wbr><span class="parameters">(boolean&nbsp;value)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">use <a href="#setDoMultipartPost(boolean)"><code>setDoMultipartPost(boolean)</code></a></div>
</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>value</code> - flag whether multiparts should be used</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getDoMultipartPost()">
<h3>getDoMultipartPost</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getDoMultipartPost</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">use <a href="#getDoMultipart()"><code>getDoMultipart()</code></a></div>
</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>flag whether multiparts should be used</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setDoMultipart(boolean)">
<h3>setDoMultipart</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setDoMultipart</span><wbr><span class="parameters">(boolean&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="getDoMultipart()">
<h3>getDoMultipart</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getDoMultipart</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setDoBrowserCompatibleMultipart(boolean)">
<h3>setDoBrowserCompatibleMultipart</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setDoBrowserCompatibleMultipart</span><wbr><span class="parameters">(boolean&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="getDoBrowserCompatibleMultipart()">
<h3>getDoBrowserCompatibleMultipart</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getDoBrowserCompatibleMultipart</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setMonitor(java.lang.String)">
<h3>setMonitor</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setMonitor</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>
</section>
</li>
<li>
<section class="detail" id="setMonitor(boolean)">
<h3>setMonitor</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setMonitor</span><wbr><span class="parameters">(boolean&nbsp;truth)</span></div>
</section>
</li>
<li>
<section class="detail" id="getMonitor()">
<h3>getMonitor</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><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">getMonitor</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">since 3.2 always returns false</div>
</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>boolean</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isMonitor()">
<h3>isMonitor</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isMonitor</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">since 3.2 always returns false</div>
</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>boolean</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setImplementation(java.lang.String)">
<h3>setImplementation</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setImplementation</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>
</section>
</li>
<li>
<section class="detail" id="getImplementation()">
<h3>getImplementation</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">getImplementation</span>()</div>
</section>
</li>
<li>
<section class="detail" id="useMD5()">
<h3>useMD5</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">useMD5</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setMD5(boolean)">
<h3>setMD5</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setMD5</span><wbr><span class="parameters">(boolean&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="addEncodedArgument(java.lang.String,java.lang.String)">
<h3>addEncodedArgument</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addEncodedArgument</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;name,
 <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">Add an argument which has already been encoded</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>name</code> - name of the argument</dd>
<dd><code>value</code> - value of the argument</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addEncodedArgument(java.lang.String,java.lang.String,java.lang.String,java.lang.String)">
<h3>addEncodedArgument</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addEncodedArgument</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;name,
 <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,
 <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;metaData,
 <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;contentEncoding)</span></div>
<div class="block">Creates an HTTPArgument and adds it to the current set <a href="#getArguments()"><code>getArguments()</code></a> of arguments.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>name</code> - - the parameter name</dd>
<dd><code>value</code> - - the parameter value</dd>
<dd><code>metaData</code> - - normally just '='</dd>
<dd><code>contentEncoding</code> - - the encoding, may be null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addEncodedArgument(java.lang.String,java.lang.String,java.lang.String)">
<h3>addEncodedArgument</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addEncodedArgument</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;name,
 <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,
 <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;metaData)</span></div>
</section>
</li>
<li>
<section class="detail" id="addNonEncodedArgument(java.lang.String,java.lang.String,java.lang.String)">
<h3>addNonEncodedArgument</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addNonEncodedArgument</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;name,
 <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,
 <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;metadata)</span></div>
</section>
</li>
<li>
<section class="detail" id="addNonEncodedArgument(java.lang.String,java.lang.String,java.lang.String,java.lang.String)">
<h3>addNonEncodedArgument</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addNonEncodedArgument</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;name,
 <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,
 <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;metadata,
 <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;contentType)</span></div>
</section>
</li>
<li>
<section class="detail" id="addArgument(java.lang.String,java.lang.String)">
<h3>addArgument</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addArgument</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;name,
 <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>
</section>
</li>
<li>
<section class="detail" id="addArgument(java.lang.String,java.lang.String,java.lang.String)">
<h3>addArgument</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addArgument</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;name,
 <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,
 <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;metadata)</span></div>
</section>
</li>
<li>
<section class="detail" id="hasArguments()">
<h3>hasArguments</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">hasArguments</span>()</div>
</section>
</li>
<li>
<section class="detail" id="addTestElement(org.apache.jmeter.testelement.TestElement)">
<h3>addTestElement</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addTestElement</span><wbr><span class="parameters">(org.apache.jmeter.testelement.TestElement&nbsp;el)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from class:&nbsp;<code><a href="../../../testelement/AbstractTestElement.html#addTestElement(org.apache.jmeter.testelement.TestElement)">AbstractTestElement</a></code></span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>addTestElement</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Overrides:</dt>
<dd><code><a href="../../../testelement/AbstractTestElement.html#addTestElement(org.apache.jmeter.testelement.TestElement)">addTestElement</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="clearTestElementChildren()">
<h3>clearTestElementChildren</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">clearTestElementChildren</span>()</div>
<div class="block">
 <p>
 Default implementation - does nothing
 <p>
 Clears the Header Manager property so subsequent loops don't keep merging more elements</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>clearTestElementChildren</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Overrides:</dt>
<dd><code><a href="../../../testelement/AbstractTestElement.html#clearTestElementChildren()">clearTestElementChildren</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="setPort(int)">
<h3>setPort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setPort</span><wbr><span class="parameters">(int&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="getDefaultPort(java.lang.String,int)">
<h3>getDefaultPort</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getDefaultPort</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;protocol,
 int&nbsp;port)</span></div>
<div class="block">Get the port number for a URL, applying defaults if necessary.
 (Called by CookieManager.)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>protocol</code> - from <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/URL.html#getProtocol()" title="class or interface in java.net" class="external-link"><code>URL.getProtocol()</code></a></dd>
<dd><code>port</code> - number from <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/URL.html#getPort()" title="class or interface in java.net" class="external-link"><code>URL.getPort()</code></a></dd>
<dt>Returns:</dt>
<dd>the default port for the protocol</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPortIfSpecified()">
<h3>getPortIfSpecified</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getPortIfSpecified</span>()</div>
<div class="block">Get the port number from the port string, allowing for trailing blanks.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>port number or UNSPECIFIED_PORT (== 0)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isProtocolDefaultPort()">
<h3>isProtocolDefaultPort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isProtocolDefaultPort</span>()</div>
<div class="block">Tell whether the default port for the specified protocol is used</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if the default port number for the protocol is used, false otherwise</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPort()">
<h3>getPort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getPort</span>()</div>
<div class="block">Get the port; apply the default for the protocol if necessary.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the port number, with default applied if required.</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;value)</span></div>
</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>
</section>
</li>
<li>
<section class="detail" id="setConnectTimeout(java.lang.String)">
<h3>setConnectTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setConnectTimeout</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>
</section>
</li>
<li>
<section class="detail" id="getConnectTimeout()">
<h3>getConnectTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getConnectTimeout</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setResponseTimeout(java.lang.String)">
<h3>setResponseTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setResponseTimeout</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>
</section>
</li>
<li>
<section class="detail" id="getResponseTimeout()">
<h3>getResponseTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getResponseTimeout</span>()</div>
</section>
</li>
<li>
<section class="detail" id="getProxyScheme()">
<h3>getProxyScheme</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">getProxyScheme</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setProxyScheme(java.lang.String)">
<h3>setProxyScheme</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProxyScheme</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;schema)</span></div>
</section>
</li>
<li>
<section class="detail" id="getProxyHost()">
<h3>getProxyHost</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">getProxyHost</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setProxyHost(java.lang.String)">
<h3>setProxyHost</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProxyHost</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;host)</span></div>
</section>
</li>
<li>
<section class="detail" id="getProxyPortInt()">
<h3>getProxyPortInt</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getProxyPortInt</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setProxyPortInt(java.lang.String)">
<h3>setProxyPortInt</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProxyPortInt</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>
</section>
</li>
<li>
<section class="detail" id="getProxyUser()">
<h3>getProxyUser</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">getProxyUser</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setProxyUser(java.lang.String)">
<h3>setProxyUser</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProxyUser</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;user)</span></div>
</section>
</li>
<li>
<section class="detail" id="getProxyPass()">
<h3>getProxyPass</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">getProxyPass</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setProxyPass(java.lang.String)">
<h3>setProxyPass</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProxyPass</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;pass)</span></div>
</section>
</li>
<li>
<section class="detail" id="setArguments(org.apache.jmeter.config.Arguments)">
<h3>setArguments</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setArguments</span><wbr><span class="parameters">(<a href="../../../config/Arguments.html" title="class in org.apache.jmeter.config">Arguments</a>&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="getArguments()">
<h3>getArguments</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../../config/Arguments.html" title="class in org.apache.jmeter.config">Arguments</a></span>&nbsp;<span class="element-name">getArguments</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setPostBodyRaw(boolean)">
<h3>setPostBodyRaw</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setPostBodyRaw</span><wbr><span class="parameters">(boolean&nbsp;value)</span></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>value</code> - Boolean that indicates body will be sent as is</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPostBodyRaw()">
<h3>getPostBodyRaw</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getPostBodyRaw</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>boolean that indicates body will be sent as is</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setAuthManager(org.apache.jmeter.protocol.http.control.AuthManager)">
<h3>setAuthManager</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setAuthManager</span><wbr><span class="parameters">(<a href="../control/AuthManager.html" title="class in org.apache.jmeter.protocol.http.control">AuthManager</a>&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="getAuthManager()">
<h3>getAuthManager</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../control/AuthManager.html" title="class in org.apache.jmeter.protocol.http.control">AuthManager</a></span>&nbsp;<span class="element-name">getAuthManager</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setHeaderManager(org.apache.jmeter.protocol.http.control.HeaderManager)">
<h3>setHeaderManager</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setHeaderManager</span><wbr><span class="parameters">(<a href="../control/HeaderManager.html" title="class in org.apache.jmeter.protocol.http.control">HeaderManager</a>&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="getHeaderManager()">
<h3>getHeaderManager</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../control/HeaderManager.html" title="class in org.apache.jmeter.protocol.http.control">HeaderManager</a></span>&nbsp;<span class="element-name">getHeaderManager</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setCookieManager(org.apache.jmeter.protocol.http.control.CookieManager)">
<h3>setCookieManager</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setCookieManager</span><wbr><span class="parameters">(<a href="../control/CookieManager.html" title="class in org.apache.jmeter.protocol.http.control">CookieManager</a>&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="getCookieManager()">
<h3>getCookieManager</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../control/CookieManager.html" title="class in org.apache.jmeter.protocol.http.control">CookieManager</a></span>&nbsp;<span class="element-name">getCookieManager</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setKeystoreConfig(org.apache.jmeter.config.KeystoreConfig)">
<h3>setKeystoreConfig</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setKeystoreConfig</span><wbr><span class="parameters">(<a href="../../../config/KeystoreConfig.html" title="class in org.apache.jmeter.config">KeystoreConfig</a>&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="getKeystoreConfig()">
<h3>getKeystoreConfig</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../../config/KeystoreConfig.html" title="class in org.apache.jmeter.config">KeystoreConfig</a></span>&nbsp;<span class="element-name">getKeystoreConfig</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setCacheManager(org.apache.jmeter.protocol.http.control.CacheManager)">
<h3>setCacheManager</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setCacheManager</span><wbr><span class="parameters">(<a href="../control/CacheManager.html" title="class in org.apache.jmeter.protocol.http.control">CacheManager</a>&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="getCacheManager()">
<h3>getCacheManager</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../control/CacheManager.html" title="class in org.apache.jmeter.protocol.http.control">CacheManager</a></span>&nbsp;<span class="element-name">getCacheManager</span>()</div>
</section>
</li>
<li>
<section class="detail" id="getDNSResolver()">
<h3>getDNSResolver</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../control/DNSCacheManager.html" title="class in org.apache.jmeter.protocol.http.control">DNSCacheManager</a></span>&nbsp;<span class="element-name">getDNSResolver</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setDNSResolver(org.apache.jmeter.protocol.http.control.DNSCacheManager)">
<h3>setDNSResolver</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setDNSResolver</span><wbr><span class="parameters">(<a href="../control/DNSCacheManager.html" title="class in org.apache.jmeter.protocol.http.control">DNSCacheManager</a>&nbsp;cacheManager)</span></div>
</section>
</li>
<li>
<section class="detail" id="isImageParser()">
<h3>isImageParser</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isImageParser</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setImageParser(boolean)">
<h3>setImageParser</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setImageParser</span><wbr><span class="parameters">(boolean&nbsp;parseImages)</span></div>
</section>
</li>
<li>
<section class="detail" id="getEmbeddedUrlRE()">
<h3>getEmbeddedUrlRE</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">getEmbeddedUrlRE</span>()</div>
<div class="block">Get the regular expression URLs must match.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>regular expression (or empty) string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setEmbeddedUrlRE(java.lang.String)">
<h3>setEmbeddedUrlRE</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setEmbeddedUrlRE</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;regex)</span></div>
</section>
</li>
<li>
<section class="detail" id="getEmbededUrlExcludeRE()">
<h3>getEmbededUrlExcludeRE</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">getEmbededUrlExcludeRE</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the regular (as String) expression that embedded URLs must not match</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setEmbeddedUrlExcludeRE(java.lang.String)">
<h3>setEmbeddedUrlExcludeRE</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setEmbeddedUrlExcludeRE</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;regex)</span></div>
</section>
</li>
<li>
<section class="detail" id="errorResult(java.lang.Throwable,org.apache.jmeter.protocol.http.sampler.HTTPSampleResult)">
<h3>errorResult</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a></span>&nbsp;<span class="element-name">errorResult</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;e,
 <a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a>&nbsp;res)</span></div>
<div class="block">Populates the provided HTTPSampleResult with details from the Exception.
 Does not create a new instance, so should not be used directly to add a subsample.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>e</code> - Exception representing the error.</dd>
<dd><code>res</code> - SampleResult to be modified</dd>
<dt>Returns:</dt>
<dd>the modified sampling result containing details of the Exception.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getUrl()">
<h3>getUrl</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/net/URL.html" title="class or interface in java.net" class="external-link">URL</a></span>&nbsp;<span class="element-name">getUrl</span>()
           throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/MalformedURLException.html" title="class or interface in java.net" class="external-link">MalformedURLException</a></span></div>
<div class="block">Get the URL, built from its component parts.

 <p>
 As a special case, if the path starts with "http[s]://",
 then the path is assumed to be the entire URL.
 </p></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>The URL to be requested by this sampler.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/MalformedURLException.html" title="class or interface in java.net" class="external-link">MalformedURLException</a></code> - if url is malformed</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getQueryString()">
<h3>getQueryString</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">getQueryString</span>()</div>
<div class="block">Gets the QueryString attribute of the UrlConfig object, using
 UTF-8 to encode the URL</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the QueryString value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getQueryString(java.lang.String)">
<h3>getQueryString</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">getQueryString</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;contentEncoding)</span></div>
<div class="block">Gets the QueryString attribute of the UrlConfig object, using the
 specified encoding to encode the parameter values put into the URL</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>contentEncoding</code> - the encoding to use for encoding parameter values</dd>
<dt>Returns:</dt>
<dd>the QueryString value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="parseArguments(java.lang.String,java.lang.String)">
<h3>parseArguments</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">parseArguments</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;queryString,
 <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;contentEncoding)</span></div>
<div class="block">This method allows a proxy server to send over the raw text from a
 browser's output stream to be parsed and stored correctly into the
 UrlConfig object.

 For each name found, addArgument() is called</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>queryString</code> - -
            the query string, might be the post body of a http post request.</dd>
<dd><code>contentEncoding</code> - -
            the content encoding of the query string;
            if non-null then it is used to decode the</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="parseArguments(java.lang.String)">
<h3>parseArguments</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">parseArguments</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;queryString)</span></div>
</section>
</li>
<li>
<section class="detail" id="toString()">
<h3>toString</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">toString</span>()</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><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></code>&nbsp;in class&nbsp;<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></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">Do a sampling and return its results.</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>e</code> - <code>Entry</code> to be sampled</dd>
<dt>Returns:</dt>
<dd>results of the sampling</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sample()">
<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>()</div>
<div class="block">Perform a sample, and return the results</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>results of the sampling</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sample(java.net.URL,java.lang.String,boolean,int)">
<h3>sample</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type"><a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a></span>&nbsp;<span class="element-name">sample</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/URL.html" title="class or interface in java.net" class="external-link">URL</a>&nbsp;u,
 <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;method,
 boolean&nbsp;areFollowingRedirect,
 int&nbsp;depth)</span></div>
<div class="block">Samples the URL passed in and stores the result in
 <code>HTTPSampleResult</code>, following redirects and downloading
 page resources as appropriate.
 <p>
 When getting a redirect target, redirects are not followed and resources
 are not downloaded. The caller will take care of this.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>u</code> - URL to sample</dd>
<dd><code>method</code> - HTTP method: GET, POST,...</dd>
<dd><code>areFollowingRedirect</code> - whether we're getting a redirect target</dd>
<dd><code>depth</code> - Depth of this target in the frame structure. Used only to
            prevent infinite recursion.</dd>
<dt>Returns:</dt>
<dd>results of the sampling, can be null if u is in CacheManager</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="downloadPageResources(org.apache.jmeter.protocol.http.sampler.HTTPSampleResult,org.apache.jmeter.protocol.http.sampler.HTTPSampleResult,int)">
<h3>downloadPageResources</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a></span>&nbsp;<span class="element-name">downloadPageResources</span><wbr><span class="parameters">(<a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a>&nbsp;pRes,
 <a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a>&nbsp;container,
 int&nbsp;frameDepth)</span></div>
<div class="block">Download the resources of an HTML page.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>pRes</code> - result of the initial request - must contain an HTML response</dd>
<dd><code>container</code> - for storing the results, if any</dd>
<dd><code>frameDepth</code> - Depth of this target in the frame structure. Used only to
            prevent infinite recursion.</dd>
<dt>Returns:</dt>
<dd>res if no resources exist, otherwise the "Container" result with one subsample per request issued</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="encodeSpaces(java.lang.String)">
<h3>encodeSpaces</h3>
<div class="member-signature"><span class="modifiers">protected</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">encodeSpaces</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>
</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>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="testEnded(java.lang.String)">
<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><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;host)</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(java.lang.String)">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>Parameters:</dt>
<dd><code>host</code> - name of host</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>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="testStarted(java.lang.String)">
<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><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;host)</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(java.lang.String)">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>Parameters:</dt>
<dd><code>host</code> - name of host</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="followRedirects(org.apache.jmeter.protocol.http.sampler.HTTPSampleResult,int)">
<h3>followRedirects</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a></span>&nbsp;<span class="element-name">followRedirects</span><wbr><span class="parameters">(<a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a>&nbsp;res,
 int&nbsp;frameDepth)</span></div>
<div class="block">Iteratively download the redirect targets of a redirect response.
 <p>
 The returned result will contain one subsample for each request issued,
 including the original one that was passed in. It will be an
 HTTPSampleResult that should mostly look as if the final destination of
 the redirect chain had been obtained in a single shot.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>res</code> - result of the initial request - must be a redirect response</dd>
<dd><code>frameDepth</code> - Depth of this target in the frame structure. Used only to
            prevent infinite recursion.</dd>
<dt>Returns:</dt>
<dd>"Container" result with one subsample per request issued</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="resultProcessing(boolean,int,org.apache.jmeter.protocol.http.sampler.HTTPSampleResult)">
<h3>resultProcessing</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a></span>&nbsp;<span class="element-name">resultProcessing</span><wbr><span class="parameters">(boolean&nbsp;pAreFollowingRedirect,
 int&nbsp;frameDepth,
 <a href="HTTPSampleResult.html" title="class in org.apache.jmeter.protocol.http.sampler">HTTPSampleResult</a>&nbsp;pRes)</span></div>
<div class="block">Follow redirects and download page resources if appropriate. this works,
 but the container stuff here is what's doing it. followRedirects() is
 actually doing the work to make sure we have only one container to make
 this work more naturally, I think this method - sample() - needs to take
 an HTTPSamplerResult container parameter instead of a
 boolean:areFollowingRedirect.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>pAreFollowingRedirect</code> - flag whether we are getting a redirect target</dd>
<dd><code>frameDepth</code> - Depth of this target in the frame structure. Used only to prevent infinite recursion.</dd>
<dd><code>pRes</code> - sample result to process</dd>
<dt>Returns:</dt>
<dd>the sample result</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isSuccessCode(int)">
<h3>isSuccessCode</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isSuccessCode</span><wbr><span class="parameters">(int&nbsp;code)</span></div>
<div class="block">Determine if the HTTP status code is successful or not
 i.e. in range 200 to 399 inclusive</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>code</code> - status code to check</dd>
<dt>Returns:</dt>
<dd>whether in range 200-399 or not</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="encodeBackSlashes(java.lang.String)">
<h3>encodeBackSlashes</h3>
<div class="member-signature"><span class="modifiers">protected static</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">encodeBackSlashes</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>
</section>
</li>
<li>
<section class="detail" id="getHTTPFiles()">
<h3>getHTTPFiles</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../util/HTTPFileArg.html" title="class in org.apache.jmeter.protocol.http.util">HTTPFileArg</a>[]</span>&nbsp;<span class="element-name">getHTTPFiles</span>()</div>
<div class="block">Get the collection of files as a list.
 The list is built up from the filename/filefield/mimetype properties,
 plus any additional entries saved in the FILE_ARGS property.

 If there are no valid file entries, then an empty list is returned.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>an array of file arguments (never null)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getHTTPFileCount()">
<h3>getHTTPFileCount</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getHTTPFileCount</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setHTTPFiles(org.apache.jmeter.protocol.http.util.HTTPFileArg[])">
<h3>setHTTPFiles</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setHTTPFiles</span><wbr><span class="parameters">(<a href="../util/HTTPFileArg.html" title="class in org.apache.jmeter.protocol.http.util">HTTPFileArg</a>[]&nbsp;files)</span></div>
<div class="block">Saves the list of files.
 The first file is saved in the Filename/field/mimetype properties.
 Any additional files are saved in the FILE_ARGS array.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>files</code> - list of files to save</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getValidMethodsAsArray()">
<h3>getValidMethodsAsArray</h3>
<div class="member-signature"><span class="modifiers">public static</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">getValidMethodsAsArray</span>()</div>
</section>
</li>
<li>
<section class="detail" id="isSecure(java.lang.String)">
<h3>isSecure</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isSecure</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;protocol)</span></div>
</section>
</li>
<li>
<section class="detail" id="isSecure(java.net.URL)">
<h3>isSecure</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isSecure</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/URL.html" title="class or interface in java.net" class="external-link">URL</a>&nbsp;url)</span></div>
</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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../../../testelement/ThreadListener.html#threadStarted()">ThreadListener</a></code></span></div>
<div class="block">Called for each thread before starting sampling.
 WARNING: this is called before any Config test elements are processed,
 so any properties they define will not have been merged in yet.

 See org.apache.jmeter.threads.JMeterThread#threadStarted()</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="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="testIterationStart(org.apache.jmeter.engine.event.LoopIterationEvent)">
<h3>testIterationStart</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">testIterationStart</span><wbr><span class="parameters">(<a href="../../../engine/event/LoopIterationEvent.html" title="class in org.apache.jmeter.engine.event">LoopIterationEvent</a>&nbsp;event)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../../../testelement/TestIterationListener.html#testIterationStart(org.apache.jmeter.engine.event.LoopIterationEvent)">TestIterationListener</a></code></span></div>
<div class="block">Each time through a Thread Group's test script, an iteration event is
 fired for each thread.

 This will be after the test elements have been cloned, so in general
 the instance will not be the same as the ones the start/end methods call.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../../testelement/TestIterationListener.html#testIterationStart(org.apache.jmeter.engine.event.LoopIterationEvent)">testIterationStart</a></code>&nbsp;in interface&nbsp;<code><a href="../../../testelement/TestIterationListener.html" title="interface in org.apache.jmeter.testelement">TestIterationListener</a></code></dd>
<dt>Parameters:</dt>
<dd><code>event</code> - the iteration event</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readResponse(org.apache.jmeter.samplers.SampleResult,java.io.InputStream,long)">
<h3>readResponse</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">byte[]</span>&nbsp;<span class="element-name">readResponse</span><wbr><span class="parameters">(<a href="../../../samplers/SampleResult.html" title="class in org.apache.jmeter.samplers">SampleResult</a>&nbsp;sampleResult,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;in,
 long&nbsp;length)</span>
                    throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a></span></div>
<div class="block">Read response from the input stream, converting to MD5 digest if the useMD5 property is set.
 <p>
 For the MD5 case, the result byte count is set to the size of the original response.
 <p>
 Closes the inputStream</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sampleResult</code> - sample to store information about the response into</dd>
<dd><code>in</code> - input stream from which to read the response</dd>
<dd><code>length</code> - expected input length or zero</dd>
<dt>Returns:</dt>
<dd>the response or the MD5 of the response</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a></code> - if reading the result fails</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setIpSource(java.lang.String)">
<h3>setIpSource</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setIpSource</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">set IP source to use - does not apply to Java HTTP implementation currently</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>value</code> - IP source to use</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getIpSource()">
<h3>getIpSource</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">getIpSource</span>()</div>
<div class="block">get IP source to use - does not apply to Java HTTP implementation currently</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>IP source to use</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setIpSourceType(int)">
<h3>setIpSourceType</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setIpSourceType</span><wbr><span class="parameters">(int&nbsp;value)</span></div>
<div class="block">set IP/address source type to use</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>value</code> - type of the IP/address source</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getIpSourceType()">
<h3>getIpSourceType</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getIpSourceType</span>()</div>
<div class="block">get IP/address source type to use</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>address source type</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isConcurrentDwn()">
<h3>isConcurrentDwn</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isConcurrentDwn</span>()</div>
<div class="block">Return if used a concurrent thread pool to get embedded resources.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if used</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setConcurrentDwn(boolean)">
<h3>setConcurrentDwn</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setConcurrentDwn</span><wbr><span class="parameters">(boolean&nbsp;concurrentDwn)</span></div>
</section>
</li>
<li>
<section class="detail" id="getConcurrentPool()">
<h3>getConcurrentPool</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">getConcurrentPool</span>()</div>
<div class="block">Get the pool size for concurrent thread pool to get embedded resources.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the pool size</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setConcurrentPool(java.lang.String)">
<h3>setConcurrentPool</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setConcurrentPool</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;poolSize)</span></div>
</section>
</li>
<li>
<section class="detail" id="applies(org.apache.jmeter.config.ConfigTestElement)">
<h3>applies</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">applies</span><wbr><span class="parameters">(<a href="../../../config/ConfigTestElement.html" title="class in org.apache.jmeter.config">ConfigTestElement</a>&nbsp;configElement)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from class:&nbsp;<code><a href="../../../samplers/AbstractSampler.html#applies(org.apache.jmeter.config.ConfigTestElement)">AbstractSampler</a></code></span></div>
<div class="block">Does configElement apply to Sampler</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../../engine/util/ConfigMergabilityIndicator.html#applies(org.apache.jmeter.config.ConfigTestElement)">applies</a></code>&nbsp;in interface&nbsp;<code><a href="../../../engine/util/ConfigMergabilityIndicator.html" title="interface in org.apache.jmeter.engine.util">ConfigMergabilityIndicator</a></code></dd>
<dt>Overrides:</dt>
<dd><code><a href="../../../samplers/AbstractSampler.html#applies(org.apache.jmeter.config.ConfigTestElement)">applies</a></code>&nbsp;in class&nbsp;<code><a href="../../../samplers/AbstractSampler.html" title="class in org.apache.jmeter.samplers">AbstractSampler</a></code></dd>
<dt>Parameters:</dt>
<dd><code>configElement</code> - <a href="../../../config/ConfigTestElement.html" title="class in org.apache.jmeter.config"><code>ConfigTestElement</code></a></dd>
<dt>Returns:</dt>
<dd>boolean</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="../../../samplers/AbstractSampler.html#applies(org.apache.jmeter.config.ConfigTestElement)"><code>AbstractSampler.applies(org.apache.jmeter.config.ConfigTestElement)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="replace(java.lang.String,java.lang.String,boolean)">
<h3>replace</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">replace</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;regex,
 <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;replaceBy,
 boolean&nbsp;caseSensitive)</span>
            throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a></span></div>
<div class="block">Replace by replaceBy in path and body (arguments) properties</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../../gui/Replaceable.html#replace(java.lang.String,java.lang.String,boolean)">replace</a></code>&nbsp;in interface&nbsp;<code><a href="../../../gui/Replaceable.html" title="interface in org.apache.jmeter.gui">Replaceable</a></code></dd>
<dt>Parameters:</dt>
<dd><code>regex</code> - Regular expression to search for</dd>
<dd><code>replaceBy</code> - Text used as replacement</dd>
<dd><code>caseSensitive</code> - flag, whether search should be done case sensitive</dd>
<dt>Returns:</dt>
<dd>number of replacements</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a></code> - when something fails while replacing</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>
