<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>AbstractTestElement (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.testelement, class: AbstractTestElement">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../script.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-3.6.1.min.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache JMeter</b></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li><a href="#nested-class-summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.jmeter.testelement</a></div>
<h1 title="Class AbstractTestElement" class="title">Class AbstractTestElement</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">org.apache.jmeter.testelement.AbstractTestElement</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="../gui/Searchable.html" title="interface in org.apache.jmeter.gui">Searchable</a></code>, <code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
<dl class="notes">
<dt>Direct Known Subclasses:</dt>
<dd><code><a href="../protocol/bolt/sampler/AbstractBoltTestElement.html" title="class in org.apache.jmeter.protocol.bolt.sampler">AbstractBoltTestElement</a></code>, <code><a href="../protocol/jdbc/AbstractJDBCTestElement.html" title="class in org.apache.jmeter.protocol.jdbc">AbstractJDBCTestElement</a></code>, <code><a href="../reporters/AbstractListenerElement.html" title="class in org.apache.jmeter.reporters">AbstractListenerElement</a></code>, <code><a href="../samplers/AbstractSampler.html" title="class in org.apache.jmeter.samplers">AbstractSampler</a></code>, <code><a href="AbstractScopedTestElement.html" title="class in org.apache.jmeter.testelement">AbstractScopedTestElement</a></code>, <code><a href="../threads/AbstractThreadGroup.html" title="class in org.apache.jmeter.threads">AbstractThreadGroup</a></code>, <code><a href="../protocol/http/modifier/AnchorModifier.html" title="class in org.apache.jmeter.protocol.http.modifier">AnchorModifier</a></code>, <code><a href="../config/Argument.html" title="class in org.apache.jmeter.config">Argument</a></code>, <code><a href="../protocol/http/control/Authorization.html" title="class in org.apache.jmeter.protocol.http.control">Authorization</a></code>, <code><a href="../visualizers/backend/BackendListener.html" title="class in org.apache.jmeter.visualizers.backend">BackendListener</a></code>, <code><a href="../util/BeanShellTestElement.html" title="class in org.apache.jmeter.util">BeanShellTestElement</a></code>, <code><a href="../protocol/bolt/config/BoltConnectionElement.html" title="class in org.apache.jmeter.protocol.bolt.config">BoltConnectionElement</a></code>, <code><a href="../assertions/CompareAssertion.html" title="class in org.apache.jmeter.assertions">CompareAssertion</a></code>, <code><a href="../config/ConfigTestElement.html" title="class in org.apache.jmeter.config">ConfigTestElement</a></code>, <code><a href="../timers/ConstantThroughputTimer.html" title="class in org.apache.jmeter.timers">ConstantThroughputTimer</a></code>, <code><a href="../timers/ConstantTimer.html" title="class in org.apache.jmeter.timers">ConstantTimer</a></code>, <code><a href="../protocol/http/control/Cookie.html" title="class in org.apache.jmeter.protocol.http.control">Cookie</a></code>, <code><a href="../modifiers/CounterConfig.html" title="class in org.apache.jmeter.modifiers">CounterConfig</a></code>, <code><a href="../protocol/jdbc/config/DataSourceElement.html" title="class in org.apache.jmeter.protocol.jdbc.config">DataSourceElement</a></code>, <code><a href="../extractor/DebugPostProcessor.html" title="class in org.apache.jmeter.extractor">DebugPostProcessor</a></code>, <code><a href="../control/GenericController.html" title="class in org.apache.jmeter.control">GenericController</a></code>, <code><a href="../protocol/http/control/Header.html" title="class in org.apache.jmeter.protocol.http.control">Header</a></code>, <code><a href="../assertions/HTMLAssertion.html" title="class in org.apache.jmeter.assertions">HTMLAssertion</a></code>, <code><a href="../protocol/http/util/HTTPFileArg.html" title="class in org.apache.jmeter.protocol.http.util">HTTPFileArg</a></code>, <code><a href="../protocol/http/control/HttpMirrorControl.html" title="class in org.apache.jmeter.protocol.http.control">HttpMirrorControl</a></code>, <code><a href="../assertions/jmespath/JMESPathAssertion.html" title="class in org.apache.jmeter.assertions.jmespath">JMESPathAssertion</a></code>, <code><a href="../protocol/jms/sampler/JMSProperties.html" title="class in org.apache.jmeter.protocol.jms.sampler">JMSProperties</a></code>, <code><a href="../protocol/jms/sampler/JMSProperty.html" title="class in org.apache.jmeter.protocol.jms.sampler">JMSProperty</a></code>, <code><a href="../assertions/JSONPathAssertion.html" title="class in org.apache.jmeter.assertions">JSONPathAssertion</a></code>, <code><a href="../protocol/ldap/config/gui/LDAPArgument.html" title="class in org.apache.jmeter.protocol.ldap.config.gui">LDAPArgument</a></code>, <code><a href="../reporters/MailerModel.html" title="class in org.apache.jmeter.reporters">MailerModel</a></code>, <code><a href="../assertions/MD5HexAssertion.html" title="class in org.apache.jmeter.assertions">MD5HexAssertion</a></code>, <code><a href="OnErrorTestElement.html" title="class in org.apache.jmeter.testelement">OnErrorTestElement</a></code>, <code><a href="../timers/poissonarrivals/PreciseThroughputTimer.html" title="class in org.apache.jmeter.timers.poissonarrivals">PreciseThroughputTimer</a></code>, <code><a href="../protocol/http/modifier/RegExUserParameters.html" title="class in org.apache.jmeter.protocol.http.modifier">RegExUserParameters</a></code>, <code><a href="../samplers/RemoteListenerWrapper.html" title="class in org.apache.jmeter.samplers">RemoteListenerWrapper</a></code>, <code><a href="../samplers/RemoteSampleListenerWrapper.html" title="class in org.apache.jmeter.samplers">RemoteSampleListenerWrapper</a></code>, <code><a href="../samplers/RemoteTestListenerWrapper.html" title="class in org.apache.jmeter.samplers">RemoteTestListenerWrapper</a></code>, <code><a href="../threads/RemoteThreadsListenerWrapper.html" title="class in org.apache.jmeter.threads">RemoteThreadsListenerWrapper</a></code>, <code><a href="../reporters/ResultSaver.html" title="class in org.apache.jmeter.reporters">ResultSaver</a></code>, <code><a href="../modifiers/SampleTimeout.html" title="class in org.apache.jmeter.modifiers">SampleTimeout</a></code>, <code><a href="../util/ScriptingTestElement.html" title="class in org.apache.jmeter.util">ScriptingTestElement</a></code>, <code><a href="../assertions/SMIMEAssertionTestElement.html" title="class in org.apache.jmeter.assertions">SMIMEAssertionTestElement</a></code>, <code><a href="../protocol/http/control/StaticHost.html" title="class in org.apache.jmeter.protocol.http.control">StaticHost</a></code>, <code><a href="../assertions/SubstitutionElement.html" title="class in org.apache.jmeter.assertions">SubstitutionElement</a></code>, <code><a href="../reporters/Summariser.html" title="class in org.apache.jmeter.reporters">Summariser</a></code>, <code><a href="../timers/SyncTimer.html" title="class in org.apache.jmeter.timers">SyncTimer</a></code>, <code><a href="TestPlan.html" title="class in org.apache.jmeter.testelement">TestPlan</a></code>, <code><a href="../protocol/http/modifier/URLRewritingModifier.html" title="class in org.apache.jmeter.protocol.http.modifier">URLRewritingModifier</a></code>, <code><a href="../modifiers/UserParameters.html" title="class in org.apache.jmeter.modifiers">UserParameters</a></code>, <code><a href="WorkBench.html" title="class in org.apache.jmeter.testelement">WorkBench</a></code>, <code><a href="../assertions/XMLAssertion.html" title="class in org.apache.jmeter.assertions">XMLAssertion</a></code>, <code><a href="../assertions/XMLSchemaAssertion.html" title="class in org.apache.jmeter.assertions">XMLSchemaAssertion</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public abstract class </span><span class="element-name type-name-label">AbstractTestElement</span>
<span class="extends-implements">extends <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>
implements org.apache.jmeter.testelement.TestElement, <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>, <a href="../gui/Searchable.html" title="interface in org.apache.jmeter.gui">Searchable</a></span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../serialized-form.html#org.apache.jmeter.testelement.AbstractTestElement">Serialized Form</a></li>
</ul>
</dd>
</dl>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="inherited-list">
<h2 id="nested-classes-inherited-from-class-org.apache.jmeter.testelement.TestElement">Nested classes/interfaces inherited from interface&nbsp;org.apache.jmeter.testelement.TestElement</h2>
<code>org.apache.jmeter.testelement.TestElement.Companion</code></div>
</section>
</li>
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="inherited-list">
<h3 id="fields-inherited-from-class-org.apache.jmeter.testelement.TestElement">Fields inherited from interface&nbsp;org.apache.jmeter.testelement.TestElement</h3>
<code>COMMENTS, Companion, ENABLED, GUI_CLASS, NAME, TEST_CLASS</code></div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table 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">AbstractTestElement</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected 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="#addPropertiesValues(java.util.List,java.util.Set)" class="member-name-link">addPropertiesValues</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? super <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;result,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;propertyNames)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Add to result the values of propertyNames</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addProperty(org.apache.jmeter.testelement.property.JMeterProperty)" class="member-name-link">addProperty</a><wbr>(<a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;property)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Add property to test element without cloning it</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addProperty(org.apache.jmeter.testelement.property.JMeterProperty,boolean)" class="member-name-link">addProperty</a><wbr>(<a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;property,
 boolean&nbsp;clone)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Add property to test element</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="#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="#canRemove()" class="member-name-link">canRemove</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"></div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clear()" class="member-name-link">clear</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 void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clearTemporary(org.apache.jmeter.testelement.property.JMeterProperty)" class="member-name-link">clearTemporary</a><wbr>(<a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;property)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Remove property from temporaryProperties</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><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clone()" class="member-name-link">clone</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#emptyTemporary()" class="member-name-link">emptyTemporary</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Clears temporaryProperties</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="#equals(java.lang.Object)" class="member-name-link">equals</a><wbr>(<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>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"></div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getComment()" class="member-name-link">getComment</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="#getName()" class="member-name-link">getName</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="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getProperty(java.lang.String)" class="member-name-link">getProperty</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;key)</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 named property.</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="#getPropertyAsBoolean(java.lang.String)" class="member-name-link">getPropertyAsBoolean</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;key)</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="#getPropertyAsBoolean(java.lang.String,boolean)" class="member-name-link">getPropertyAsBoolean</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;key,
 boolean&nbsp;defaultVal)</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>double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getPropertyAsDouble(java.lang.String)" class="member-name-link">getPropertyAsDouble</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;key)</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>float</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getPropertyAsFloat(java.lang.String)" class="member-name-link">getPropertyAsFloat</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;key)</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="#getPropertyAsInt(java.lang.String)" class="member-name-link">getPropertyAsInt</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;key)</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="#getPropertyAsInt(java.lang.String,int)" class="member-name-link">getPropertyAsInt</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;key,
 int&nbsp;defaultValue)</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>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getPropertyAsLong(java.lang.String)" class="member-name-link">getPropertyAsLong</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;key)</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>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getPropertyAsLong(java.lang.String,long)" class="member-name-link">getPropertyAsLong</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;key,
 long&nbsp;defaultValue)</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="#getPropertyAsString(java.lang.String)" class="member-name-link">getPropertyAsString</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;key)</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="#getPropertyAsString(java.lang.String,java.lang.String)" class="member-name-link">getPropertyAsString</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;key,
 <a href="https://docs.oracle.com/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;defaultValue)</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="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getPropertyOrNull(java.lang.String)" class="member-name-link">getPropertyOrNull</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;key)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"></div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getSearchableTokens()" class="member-name-link">getSearchableTokens</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 a list of all tokens that should be visible to searching</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../threads/JMeterContext.html" title="class in org.apache.jmeter.threads">JMeterContext</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getThreadContext()" class="member-name-link">getThreadContext</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="#getThreadName()" class="member-name-link">getThreadName</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="#hashCode()" class="member-name-link">hashCode</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"></div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isEnabled()" class="member-name-link">isEnabled</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="#isRunningVersion()" class="member-name-link">isRunningVersion</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the runningVersion.</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="#isTemporary(org.apache.jmeter.testelement.property.JMeterProperty)" class="member-name-link">isTemporary</a><wbr>(<a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;property)</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 void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#logProperties()" class="member-name-link">logProperties</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Log the properties of the test element</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#mergeIn(org.apache.jmeter.testelement.TestElement)" class="member-name-link">mergeIn</a><wbr>(org.apache.jmeter.testelement.TestElement&nbsp;element)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Add to this the properties of element (by reference)</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="property/PropertyIterator.html" title="interface in org.apache.jmeter.testelement.property">PropertyIterator</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#propertyIterator()" class="member-name-link">propertyIterator</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>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#recoverRunningVersion()" class="member-name-link">recoverRunningVersion</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>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeProperty(java.lang.String)" class="member-name-link">removeProperty</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;key)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"></div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setComment(java.lang.String)" class="member-name-link">setComment</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;comment)</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="#setEnabled(boolean)" class="member-name-link">setEnabled</a><wbr>(boolean&nbsp;enabled)</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="#setName(java.lang.String)" class="member-name-link">setName</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)</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="#setProperty(java.lang.String,boolean)" class="member-name-link">setProperty</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,
 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="#setProperty(java.lang.String,boolean,boolean)" class="member-name-link">setProperty</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,
 boolean&nbsp;value,
 boolean&nbsp;dflt)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Create a boolean property - but only if it is not the default.</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="#setProperty(java.lang.String,int)" class="member-name-link">setProperty</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,
 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="#setProperty(java.lang.String,int,int)" class="member-name-link">setProperty</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,
 int&nbsp;value,
 int&nbsp;dflt)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Create an int property - but only if it is not the default.</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="#setProperty(java.lang.String,long)" class="member-name-link">setProperty</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,
 long&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="#setProperty(java.lang.String,long,long)" class="member-name-link">setProperty</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,
 long&nbsp;value,
 long&nbsp;dflt)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Create a long property - but only if it is not the default.</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="#setProperty(java.lang.String,java.lang.String)" class="member-name-link">setProperty</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="#setProperty(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">setProperty</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;dflt)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Create a String property - but only if it is not the default.</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="#setProperty(org.apache.jmeter.testelement.property.JMeterProperty)" class="member-name-link">setProperty</a><wbr>(<a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;property)</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="#setRunningVersion(boolean)" class="member-name-link">setRunningVersion</a><wbr>(boolean&nbsp;runningVersion)</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 runningVersion.</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="#setTemporary(org.apache.jmeter.testelement.property.JMeterProperty)" class="member-name-link">setTemporary</a><wbr>(<a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;property)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"></div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setThreadContext(org.apache.jmeter.threads.JMeterContext)" class="member-name-link">setThreadContext</a><wbr>(<a href="../threads/JMeterContext.html" title="class in org.apache.jmeter.threads">JMeterContext</a>&nbsp;inthreadContext)</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="#setThreadName(java.lang.String)" class="member-name-link">setThreadName</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;inthreadName)</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="#traverse(org.apache.jmeter.testelement.TestElementTraverser)" class="member-name-link">traverse</a><wbr>(<a href="TestElementTraverser.html" title="interface in org.apache.jmeter.testelement">TestElementTraverser</a>&nbsp;traverser)</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>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#traverseCollection(org.apache.jmeter.testelement.property.CollectionProperty,org.apache.jmeter.testelement.TestElementTraverser)" class="member-name-link">traverseCollection</a><wbr>(<a href="property/CollectionProperty.html" title="class in org.apache.jmeter.testelement.property">CollectionProperty</a>&nbsp;col,
 <a href="TestElementTraverser.html" title="interface in org.apache.jmeter.testelement">TestElementTraverser</a>&nbsp;traverser)</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 void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#traverseMap(org.apache.jmeter.testelement.property.MapProperty,org.apache.jmeter.testelement.TestElementTraverser)" class="member-name-link">traverseMap</a><wbr>(<a href="property/MapProperty.html" title="class in org.apache.jmeter.testelement.property">MapProperty</a>&nbsp;map,
 <a href="TestElementTraverser.html" title="interface in org.apache.jmeter.testelement">TestElementTraverser</a>&nbsp;traverser)</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>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#traverseProperty(org.apache.jmeter.testelement.TestElementTraverser,org.apache.jmeter.testelement.property.JMeterProperty)" class="member-name-link">traverseProperty</a><wbr>(<a href="TestElementTraverser.html" title="interface in org.apache.jmeter.testelement">TestElementTraverser</a>&nbsp;traverser,
 <a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</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>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.jmeter.testelement.TestElement">Methods inherited from interface&nbsp;org.apache.jmeter.testelement.TestElement</h3>
<code>get, get, get, get, get, get, get, get, get, getOrCreate, getOrCreate, getOrNull, getOrNull, getOrNull, getPropertyOrNull, getProps, getSchema, getString, removed, removeProperty, set, set, set, set, set, set, set, set, set</code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;()">
<h3>AbstractTestElement</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="element-name">AbstractTestElement</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="clone()">
<h3>clone</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">clone</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>clone</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Overrides:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</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="clear()">
<h3>clear</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">clear</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>clear</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</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</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>clearTestElementChildren</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeProperty(java.lang.String)">
<h3>removeProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeProperty</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;key)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>removeProperty</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="equals(java.lang.Object)">
<h3>equals</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">equals</span><wbr><span class="parameters">(<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>&nbsp;o)</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#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</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="hashCode()">
<h3>hashCode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">hashCode</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#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</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="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>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>addTestElement</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setName(java.lang.String)">
<h3>setName</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setName</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)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setName</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getName()">
<h3>getName</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">getName</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getName</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setComment(java.lang.String)">
<h3>setComment</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setComment</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;comment)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setComment</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getComment()">
<h3>getComment</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">getComment</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getComment</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProperty(java.lang.String)">
<h3>getProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a></span>&nbsp;<span class="element-name">getProperty</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;key)</span></div>
<div class="block">Get the named property. If it doesn't exist, a new NullProperty object is
 created with the same name and returned.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getProperty</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropertyOrNull(java.lang.String)">
<h3>getPropertyOrNull</h3>
<div class="member-signature"><span class="annotations">@API(status=EXPERIMENTAL,
     since="5.6")
</span><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a></span>&nbsp;<span class="element-name">getPropertyOrNull</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;key)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getPropertyOrNull</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Since:</dt>
<dd>5.6</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="traverse(org.apache.jmeter.testelement.TestElementTraverser)">
<h3>traverse</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">traverse</span><wbr><span class="parameters">(<a href="TestElementTraverser.html" title="interface in org.apache.jmeter.testelement">TestElementTraverser</a>&nbsp;traverser)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>traverse</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="traverseProperty(org.apache.jmeter.testelement.TestElementTraverser,org.apache.jmeter.testelement.property.JMeterProperty)">
<h3>traverseProperty</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">traverseProperty</span><wbr><span class="parameters">(<a href="TestElementTraverser.html" title="interface in org.apache.jmeter.testelement">TestElementTraverser</a>&nbsp;traverser,
 <a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;value)</span></div>
</section>
</li>
<li>
<section class="detail" id="traverseMap(org.apache.jmeter.testelement.property.MapProperty,org.apache.jmeter.testelement.TestElementTraverser)">
<h3>traverseMap</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">traverseMap</span><wbr><span class="parameters">(<a href="property/MapProperty.html" title="class in org.apache.jmeter.testelement.property">MapProperty</a>&nbsp;map,
 <a href="TestElementTraverser.html" title="interface in org.apache.jmeter.testelement">TestElementTraverser</a>&nbsp;traverser)</span></div>
</section>
</li>
<li>
<section class="detail" id="traverseCollection(org.apache.jmeter.testelement.property.CollectionProperty,org.apache.jmeter.testelement.TestElementTraverser)">
<h3>traverseCollection</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">traverseCollection</span><wbr><span class="parameters">(<a href="property/CollectionProperty.html" title="class in org.apache.jmeter.testelement.property">CollectionProperty</a>&nbsp;col,
 <a href="TestElementTraverser.html" title="interface in org.apache.jmeter.testelement">TestElementTraverser</a>&nbsp;traverser)</span></div>
</section>
</li>
<li>
<section class="detail" id="getPropertyAsInt(java.lang.String)">
<h3>getPropertyAsInt</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getPropertyAsInt</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;key)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getPropertyAsInt</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropertyAsInt(java.lang.String,int)">
<h3>getPropertyAsInt</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getPropertyAsInt</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;key,
 int&nbsp;defaultValue)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getPropertyAsInt</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropertyAsBoolean(java.lang.String)">
<h3>getPropertyAsBoolean</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getPropertyAsBoolean</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;key)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getPropertyAsBoolean</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropertyAsBoolean(java.lang.String,boolean)">
<h3>getPropertyAsBoolean</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getPropertyAsBoolean</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;key,
 boolean&nbsp;defaultVal)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getPropertyAsBoolean</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropertyAsFloat(java.lang.String)">
<h3>getPropertyAsFloat</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">float</span>&nbsp;<span class="element-name">getPropertyAsFloat</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;key)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getPropertyAsFloat</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropertyAsLong(java.lang.String)">
<h3>getPropertyAsLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getPropertyAsLong</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;key)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getPropertyAsLong</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropertyAsLong(java.lang.String,long)">
<h3>getPropertyAsLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getPropertyAsLong</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;key,
 long&nbsp;defaultValue)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getPropertyAsLong</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropertyAsDouble(java.lang.String)">
<h3>getPropertyAsDouble</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">getPropertyAsDouble</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;key)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getPropertyAsDouble</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropertyAsString(java.lang.String)">
<h3>getPropertyAsString</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">getPropertyAsString</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;key)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getPropertyAsString</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropertyAsString(java.lang.String,java.lang.String)">
<h3>getPropertyAsString</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">getPropertyAsString</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;key,
 <a href="https://docs.oracle.com/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;defaultValue)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getPropertyAsString</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addProperty(org.apache.jmeter.testelement.property.JMeterProperty,boolean)">
<h3>addProperty</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addProperty</span><wbr><span class="parameters">(<a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;property,
 boolean&nbsp;clone)</span></div>
<div class="block">Add property to test element</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>property</code> - <a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property"><code>JMeterProperty</code></a> to add to current Test Element</dd>
<dd><code>clone</code> - clone property</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addProperty(org.apache.jmeter.testelement.property.JMeterProperty)">
<h3>addProperty</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addProperty</span><wbr><span class="parameters">(<a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;property)</span></div>
<div class="block">Add property to test element without cloning it</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>property</code> - <a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property"><code>JMeterProperty</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="clearTemporary(org.apache.jmeter.testelement.property.JMeterProperty)">
<h3>clearTemporary</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">clearTemporary</span><wbr><span class="parameters">(<a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;property)</span></div>
<div class="block">Remove property from temporaryProperties</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>property</code> - <a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property"><code>JMeterProperty</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="logProperties()">
<h3>logProperties</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">logProperties</span>()</div>
<div class="block">Log the properties of the test element</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><code>TestElement.setProperty(JMeterProperty)</code></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setProperty(org.apache.jmeter.testelement.property.JMeterProperty)">
<h3>setProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProperty</span><wbr><span class="parameters">(<a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;property)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setProperty</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setProperty(java.lang.String,java.lang.String)">
<h3>setProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProperty</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>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setProperty</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setProperty(java.lang.String,java.lang.String,java.lang.String)">
<h3>setProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProperty</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;dflt)</span></div>
<div class="block">Create a String property - but only if it is not the default.
 This is intended for use when adding new properties to JMeter
 so that JMX files are not expanded unnecessarily.

 N.B. - must agree with the default applied when reading the property.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setProperty</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Parameters:</dt>
<dd><code>name</code> - property name</dd>
<dd><code>value</code> - current value</dd>
<dd><code>dflt</code> - default</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setProperty(java.lang.String,boolean)">
<h3>setProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProperty</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,
 boolean&nbsp;value)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setProperty</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setProperty(java.lang.String,boolean,boolean)">
<h3>setProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProperty</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,
 boolean&nbsp;value,
 boolean&nbsp;dflt)</span></div>
<div class="block">Create a boolean property - but only if it is not the default.
 This is intended for use when adding new properties to JMeter
 so that JMX files are not expanded unnecessarily.

 N.B. - must agree with the default applied when reading the property.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setProperty</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Parameters:</dt>
<dd><code>name</code> - property name</dd>
<dd><code>value</code> - current value</dd>
<dd><code>dflt</code> - default</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setProperty(java.lang.String,int)">
<h3>setProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProperty</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,
 int&nbsp;value)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setProperty</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setProperty(java.lang.String,int,int)">
<h3>setProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProperty</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,
 int&nbsp;value,
 int&nbsp;dflt)</span></div>
<div class="block">Create an int property - but only if it is not the default.
 This is intended for use when adding new properties to JMeter
 so that JMX files are not expanded unnecessarily.

 N.B. - must agree with the default applied when reading the property.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setProperty</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Parameters:</dt>
<dd><code>name</code> - property name</dd>
<dd><code>value</code> - current value</dd>
<dd><code>dflt</code> - default</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setProperty(java.lang.String,long)">
<h3>setProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProperty</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,
 long&nbsp;value)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setProperty</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setProperty(java.lang.String,long,long)">
<h3>setProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setProperty</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,
 long&nbsp;value,
 long&nbsp;dflt)</span></div>
<div class="block">Create a long property - but only if it is not the default.
 This is intended for use when adding new properties to JMeter
 so that JMX files are not expanded unnecessarily.

 N.B. - must agree with the default applied when reading the property.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setProperty</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Parameters:</dt>
<dd><code>name</code> - property name</dd>
<dd><code>value</code> - current value</dd>
<dd><code>dflt</code> - default</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="propertyIterator()">
<h3>propertyIterator</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="property/PropertyIterator.html" title="interface in org.apache.jmeter.testelement.property">PropertyIterator</a></span>&nbsp;<span class="element-name">propertyIterator</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>propertyIterator</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="mergeIn(org.apache.jmeter.testelement.TestElement)">
<h3>mergeIn</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">mergeIn</span><wbr><span class="parameters">(org.apache.jmeter.testelement.TestElement&nbsp;element)</span></div>
<div class="block">Add to this the properties of element (by reference)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>element</code> - <code>TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isRunningVersion()">
<h3>isRunningVersion</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isRunningVersion</span>()</div>
<div class="block">Returns the runningVersion.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>isRunningVersion</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setRunningVersion(boolean)">
<h3>setRunningVersion</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setRunningVersion</span><wbr><span class="parameters">(boolean&nbsp;runningVersion)</span></div>
<div class="block">Sets the runningVersion.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setRunningVersion</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Parameters:</dt>
<dd><code>runningVersion</code> - the runningVersion to set</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="recoverRunningVersion()">
<h3>recoverRunningVersion</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">recoverRunningVersion</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>recoverRunningVersion</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="emptyTemporary()">
<h3>emptyTemporary</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">emptyTemporary</span>()</div>
<div class="block">Clears temporaryProperties</div>
</section>
</li>
<li>
<section class="detail" id="isTemporary(org.apache.jmeter.testelement.property.JMeterProperty)">
<h3>isTemporary</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isTemporary</span><wbr><span class="parameters">(<a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;property)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>isTemporary</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setTemporary(org.apache.jmeter.testelement.property.JMeterProperty)">
<h3>setTemporary</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setTemporary</span><wbr><span class="parameters">(<a href="property/JMeterProperty.html" title="interface in org.apache.jmeter.testelement.property">JMeterProperty</a>&nbsp;property)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setTemporary</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getThreadContext()">
<h3>getThreadContext</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../threads/JMeterContext.html" title="class in org.apache.jmeter.threads">JMeterContext</a></span>&nbsp;<span class="element-name">getThreadContext</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getThreadContext</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Returns:</dt>
<dd>Returns the threadContext.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setThreadContext(org.apache.jmeter.threads.JMeterContext)">
<h3>setThreadContext</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setThreadContext</span><wbr><span class="parameters">(<a href="../threads/JMeterContext.html" title="class in org.apache.jmeter.threads">JMeterContext</a>&nbsp;inthreadContext)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setThreadContext</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Parameters:</dt>
<dd><code>inthreadContext</code> - The threadContext to set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getThreadName()">
<h3>getThreadName</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">getThreadName</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>getThreadName</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Returns:</dt>
<dd>Returns the threadName.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setThreadName(java.lang.String)">
<h3>setThreadName</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setThreadName</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;inthreadName)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setThreadName</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
<dt>Parameters:</dt>
<dd><code>inthreadName</code> - The threadName to set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="canRemove()">
<h3>canRemove</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">canRemove</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>canRemove</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isEnabled()">
<h3>isEnabled</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isEnabled</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>isEnabled</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setEnabled(boolean)">
<h3>setEnabled</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setEnabled</span><wbr><span class="parameters">(boolean&nbsp;enabled)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code>setEnabled</code>&nbsp;in interface&nbsp;<code>org.apache.jmeter.testelement.TestElement</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSearchableTokens()">
<h3>getSearchableTokens</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/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">getSearchableTokens</span>()</div>
<div class="block">Get a list of all tokens that should be visible to searching}</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../gui/Searchable.html#getSearchableTokens()">getSearchableTokens</a></code>&nbsp;in interface&nbsp;<code><a href="../gui/Searchable.html" title="interface in org.apache.jmeter.gui">Searchable</a></code></dd>
<dt>Returns:</dt>
<dd>List of searchable tokens</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addPropertiesValues(java.util.List,java.util.Set)">
<h3>addPropertiesValues</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addPropertiesValues</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? super <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;result,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;propertyNames)</span></div>
<div class="block">Add to result the values of propertyNames</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>result</code> - List of values of propertyNames</dd>
<dd><code>propertyNames</code> - Set of names of properties to extract</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-2023 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
