<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>JMeterUtils (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.util, class: JMeterUtils">
<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.5.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>Nested&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.jmeter.util</a></div>
<h1 title="Class JMeterUtils" class="title">Class JMeterUtils</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.jmeter.util.JMeterUtils</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="../../jorphan/test/UnitTestManager.html" title="interface in org.apache.jorphan.test">UnitTestManager</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">JMeterUtils</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>
implements <a href="../../jorphan/test/UnitTestManager.html" title="interface in org.apache.jorphan.test">UnitTestManager</a></span></div>
<div class="block">This class contains the static utility methods used by JMeter.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#RES_KEY_PFX" class="member-name-link">RES_KEY_PFX</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#THREAD_GROUP_DISTRIBUTED_PREFIX_PROPERTY_NAME" class="member-name-link">THREAD_GROUP_DISTRIBUTED_PREFIX_PROPERTY_NAME</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">JMeterUtils</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button><button id="method-summary-table-tab6" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab6', 3)" class="table-tab">Deprecated Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#addLocaleChangeListener(org.apache.jmeter.util.LocaleChangeListener)" class="member-name-link">addLocaleChangeListener</a><wbr>(<a href="LocaleChangeListener.html" title="interface in org.apache.jmeter.util">LocaleChangeListener</a>&nbsp;listener)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#applyHiDPI(javax.swing.JTable)" class="member-name-link">applyHiDPI</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JTable.html" title="class or interface in javax.swing" class="external-link">JTable</a>&nbsp;table)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Apply HiDPI mode management to <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JTable.html" title="class or interface in javax.swing" class="external-link"><code>JTable</code></a></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#applyHiDPIOnFonts()" class="member-name-link">applyHiDPIOnFonts</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Apply HiDPI scale factor on font if HiDPI mode is enabled</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#applyScaleOnFonts(float)" class="member-name-link">applyScaleOnFonts</a><wbr>(float&nbsp;scale)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Apply HiDPI scale factor on fonts</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#clearMatcherMemory(org.apache.oro.text.regex.Perl5Matcher,org.apache.oro.text.regex.Pattern)" class="member-name-link">clearMatcherMemory</a><wbr>(org.apache.oro.text.regex.Perl5Matcher&nbsp;matcher,
 org.apache.oro.text.regex.Pattern&nbsp;pattern)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Hack to make matcher clean the two internal buffers it keeps in memory which size is equivalent to
 the unzipped page size</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html" title="class or interface in java.util.regex" class="external-link">Pattern</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#compilePattern(java.lang.String)" class="member-name-link">compilePattern</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html" title="class or interface in java.util.regex" class="external-link">Pattern</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#compilePattern(java.lang.String,int)" class="member-name-link">compilePattern</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 int&nbsp;flags)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static final com.thoughtworks.xstream.XStream</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createXStream()" class="member-name-link">createXStream</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#findClassesThatExtend(java.lang.Class)" class="member-name-link">findClassesThatExtend</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;superClass)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Convenience method for
 <a href="../../jorphan/reflect/ClassFinder.html#findClassesThatExtend(java.lang.String%5B%5D,java.lang.Class%5B%5D,boolean)"><code>ClassFinder.findClassesThatExtend(String[], Class[], boolean)</code></a>
 with the option to include inner classes in the search set to false
 and the path list is derived from JMeterUtils.getSearchPaths().</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/io/File.html" title="class or interface in java.io" class="external-link">File</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#findFile(java.lang.String)" class="member-name-link">findFile</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;fileName)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Find a file in the current directory or in the JMeter bin directory.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#formatJMeterExportedVariableName(java.lang.String)" class="member-name-link">formatJMeterExportedVariableName</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;elementName)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getArrayPropDefault(java.lang.String,java.lang.String%5B%5D)" class="member-name-link">getArrayPropDefault</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]&nbsp;defaultVal)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get an array of String if present and not empty, defaultValue if not present.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getDelimiter(java.lang.String)" class="member-name-link">getDelimiter</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;delimiterValue)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Return delimiterValue handling the TAB case</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getHiDPIMode()" class="member-name-link">getHiDPIMode</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Provide info, whether we run in HiDPI mode</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getHiDPIScaleFactor()" class="member-name-link">getHiDPIScaleFactor</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Provide info about the HiDPI scale factor</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/ImageIcon.html" title="class or interface in javax.swing" class="external-link">ImageIcon</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getImage(java.lang.String)" class="member-name-link">getImage</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/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-tab1 method-summary-table-tab4">
<div class="block">This looks for the requested image in the classpath under
 org.apache.jmeter.images.&lt;name&gt;</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/ImageIcon.html" title="class or interface in javax.swing" class="external-link">ImageIcon</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getImage(java.lang.String,java.lang.String)" class="member-name-link">getImage</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;description)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">This looks for the requested image in the classpath under
 org.apache.jmeter.images.<em>&lt;name&gt;</em>, and also sets the description
 of the image, which is useful if the icon is going to be placed
 on the clipboard.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getJMeterBinDir()" class="member-name-link">getJMeterBinDir</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get the JMeter bin directory - does not include the trailing separator.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getJMeterCopyright()" class="member-name-link">getJMeterCopyright</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Gets the JMeter copyright.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getJMeterHome()" class="member-name-link">getJMeterHome</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get the JMeter home directory - does not include the trailing separator.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link">Properties</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getJMeterProperties()" class="member-name-link">getJMeterProperties</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">This gets the currently defined appProperties.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getJMeterVersion()" class="member-name-link">getJMeterVersion</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Gets the JMeter Version.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getLocale()" class="member-name-link">getLocale</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Gets the current locale.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getLocaleString(java.lang.String)" class="member-name-link">getLocaleString</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;locale)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get the locale name as a resource.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getLocalHostFullName()" class="member-name-link">getLocalHostFullName</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the cached result from calling
 InetAddress.getLocalHost().getCanonicalHostName()</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getLocalHostIP()" class="member-name-link">getLocalHostIP</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the cached result from calling
 InetAddress.getLocalHost().getHostAddress()</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getLocalHostName()" class="member-name-link">getLocalHostName</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the cached result from calling
 InetAddress.getLocalHost().getHostName()</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.oro.text.regex.Perl5Matcher</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getMatcher()" class="member-name-link">getMatcher</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Gets Perl5Matcher for this thread.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getParsedLabel(java.lang.String)" class="member-name-link">getParsedLabel</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/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-tab1 method-summary-table-tab4">
<div class="block">To get I18N label from properties file</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.oro.text.regex.Pattern</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getPattern(java.lang.String)" class="member-name-link">getPattern</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get a compiled expression from the pattern cache (READ_ONLY).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.oro.text.regex.Pattern</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getPattern(java.lang.String,int)" class="member-name-link">getPattern</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 int&nbsp;options)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get a compiled expression from the pattern cache.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.oro.text.PatternCacheLRU</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getPatternCache()" class="member-name-link">getPatternCache</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getPropDefault(java.lang.String,boolean)" class="member-name-link">getPropDefault</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 boolean&nbsp;defaultVal)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get a boolean value with default if not present.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getPropDefault(java.lang.String,double)" class="member-name-link">getPropDefault</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 double&nbsp;defaultVal)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get a double value with default if not present.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static float</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getPropDefault(java.lang.String,float)" class="member-name-link">getPropDefault</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 float&nbsp;defaultVal)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get a float value with default if not present.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getPropDefault(java.lang.String,int)" class="member-name-link">getPropDefault</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 int&nbsp;defaultVal)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get a int value with default if not present.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getPropDefault(java.lang.String,long)" class="member-name-link">getPropDefault</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 long&nbsp;defaultVal)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get a long value with default if not present.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getPropDefault(java.lang.String,java.lang.String)" class="member-name-link">getPropDefault</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;defaultVal)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get a String value with default if not present.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link">Properties</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getProperties(java.lang.String)" class="member-name-link">getProperties</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;file)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">This method is used by the init method to load the property file that may
 even reside in the user space, or in the classpath under
 org.apache.jmeter.jmeter.properties.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getProperty(java.lang.String)" class="member-name-link">getProperty</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Get the value of a JMeter property.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getRandomInt(int)" class="member-name-link">getRandomInt</a><wbr>(int&nbsp;r)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Provide random numbers</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getResourceFileAsText(java.lang.String)" class="member-name-link">getResourceFileAsText</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/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-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getResString(java.lang.String)" class="member-name-link">getResString</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/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-tab1 method-summary-table-tab4">
<div class="block">Gets the resource string for this key.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#getResString(java.lang.String,java.lang.String)" class="member-name-link">getResString</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/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-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Only intended for use in development; use
             getResString(String) normally</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getResString(java.lang.String,java.util.Locale)" class="member-name-link">getResString</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a>&nbsp;forcedLocale)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Gets the resource string for this key in Locale.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getSearchPaths()" class="member-name-link">getSearchPaths</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Generate a list of paths to search.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#helpGC()" class="member-name-link">helpGC</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Help GC by triggering GC and finalization</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="#initializeProperties(java.lang.String)" class="member-name-link">initializeProperties</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;file)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Your implementation will be handed the filename that was provided to
 AllTests as a configuration file.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#initLocale()" class="member-name-link">initLocale</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Initialise the JMeter Locale</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#initLogging()" class="member-name-link">initLogging</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">does not do anything anymore</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isExpertMode()" class="member-name-link">isExpertMode</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Determine whether we are in 'expert' mode.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isTestRunning()" class="member-name-link">isTestRunning</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JLabel.html" title="class or interface in javax.swing" class="external-link">JLabel</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#labelFor(java.awt.Component,java.lang.String)" class="member-name-link">labelFor</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/awt/Component.html" title="class or interface in java.awt" class="external-link">Component</a>&nbsp;component,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;resourceId)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JLabel.html" title="class or interface in javax.swing" class="external-link"><code>JLabel</code></a> that is associated with a given <a href="https://docs.oracle.com/javase/8/docs/api/java/awt/Component.html" title="class or interface in java.awt" class="external-link"><code>Component</code></a> instance.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JLabel.html" title="class or interface in javax.swing" class="external-link">JLabel</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#labelFor(java.awt.Component,java.lang.String,java.lang.String)" class="member-name-link">labelFor</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/awt/Component.html" title="class or interface in java.awt" class="external-link">Component</a>&nbsp;component,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;labelValue,
 <a href="https://docs.oracle.com/javase/8/docs/api/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-tab1 method-summary-table-tab4">
<div class="block">Creates <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JLabel.html" title="class or interface in javax.swing" class="external-link"><code>JLabel</code></a> that is associated with a given <a href="https://docs.oracle.com/javase/8/docs/api/java/awt/Component.html" title="class or interface in java.awt" class="external-link"><code>Component</code></a> instance.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#loadJMeterProperties(java.lang.String)" class="member-name-link">loadJMeterProperties</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;file)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Load the JMeter properties file; if not found, then
 default to "org/apache/jmeter/jmeter.properties" from the classpath</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link">Properties</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#loadProperties(java.lang.String)" class="member-name-link">loadProperties</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;file)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">This method loads a property file that may reside in the user space, or
 in the classpath</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link">Properties</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#loadProperties(java.lang.String,java.util.Properties)" class="member-name-link">loadProperties</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;file,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link">Properties</a>&nbsp;defaultProps)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">This method loads a property file that may reside in the user space, or
 in the classpath</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/util/LinkedHashMap.html" title="class or interface in java.util" class="external-link">LinkedHashMap</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/javase/8/docs/api/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-tab1 method-summary-table-tab4"><code><a href="#parseHeaders(java.lang.String)" class="member-name-link">parseHeaders</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;headers)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Split line into name/value pairs and remove colon ':'</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#refreshUI()" class="member-name-link">refreshUI</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Refresh UI after LAF change or resizing</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#removeLocaleChangeListener(org.apache.jmeter.util.LocaleChangeListener)" class="member-name-link">removeLocaleChangeListener</a><wbr>(<a href="LocaleChangeListener.html" title="interface in org.apache.jmeter.util">LocaleChangeListener</a>&nbsp;listener)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#reportErrorToUser(java.lang.String)" class="member-name-link">reportErrorToUser</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;errorMsg)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Report an error through a dialog box.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#reportErrorToUser(java.lang.String,java.lang.Exception)" class="member-name-link">reportErrorToUser</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;errorMsg,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a>&nbsp;exception)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Report an error through a dialog box.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#reportErrorToUser(java.lang.String,java.lang.String)" class="member-name-link">reportErrorToUser</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;errorMsg,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;titleMsg)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Report an error through a dialog box in GUI mode
 or in logs and stdout in Non GUI mode</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#reportErrorToUser(java.lang.String,java.lang.String,java.lang.Exception)" class="member-name-link">reportErrorToUser</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;errorMsg,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;titleMsg,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a>&nbsp;exception)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Report an error through a dialog box in GUI mode
 or in logs and stdout in Non GUI mode</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#reportInfoToUser(java.lang.String,java.lang.String)" class="member-name-link">reportInfoToUser</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;msg,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;titleMsg)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Report an information through a dialog box in GUI mode</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#runSafe(boolean,java.lang.Runnable)" class="member-name-link">runSafe</a><wbr>(boolean&nbsp;synchronous,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;runnable)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Run the runnable in AWT Thread if current thread is not AWT thread
 otherwise runs call <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/SwingUtilities.html#invokeAndWait(java.lang.Runnable)" title="class or interface in javax.swing" class="external-link"><code>SwingUtilities.invokeAndWait(Runnable)</code></a></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#runSafe(java.lang.Runnable)" class="member-name-link">runSafe</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;runnable)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Run the runnable in AWT Thread if current thread is not AWT thread
 otherwise runs call <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/SwingUtilities.html#invokeAndWait(java.lang.Runnable)" title="class or interface in javax.swing" class="external-link"><code>SwingUtilities.invokeAndWait(Runnable)</code></a></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#setJMeterHome(java.lang.String)" class="member-name-link">setJMeterHome</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;home)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#setLocale(java.util.Locale)" class="member-name-link">setLocale</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a>&nbsp;loc)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Changes the current locale: re-reads resource strings and notifies
 listeners.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 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/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propValue)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Set a String value</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#setupXStreamSecurityPolicy(com.thoughtworks.xstream.XStream)" class="member-name-link">setupXStreamSecurityPolicy</a><wbr>(com.thoughtworks.xstream.XStream&nbsp;xstream)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Setup default security policy</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#unsplit(java.lang.Object%5B%5D,java.lang.Object)" class="member-name-link">unsplit</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]&nbsp;splittee,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;splitChar)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">use <a href="../../jorphan/util/JOrphanUtils.html#unsplit(java.lang.Object%5B%5D,java.lang.Object)"><code>JOrphanUtils.unsplit(Object[], Object)</code></a></div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unsplit(java.lang.Object%5B%5D,java.lang.Object,java.lang.String)" class="member-name-link">unsplit</a><wbr>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]&nbsp;splittee,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;splitChar,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;def)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Takes an array of strings and a tokenizer character, and returns a string
 of all the strings concatenated with the tokenizer string in between each
 one.</div>
</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/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="THREAD_GROUP_DISTRIBUTED_PREFIX_PROPERTY_NAME">
<h3>THREAD_GROUP_DISTRIBUTED_PREFIX_PROPERTY_NAME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">THREAD_GROUP_DISTRIBUTED_PREFIX_PROPERTY_NAME</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../constant-values.html#org.apache.jmeter.util.JMeterUtils.THREAD_GROUP_DISTRIBUTED_PREFIX_PROPERTY_NAME">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="RES_KEY_PFX">
<h3>RES_KEY_PFX</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">RES_KEY_PFX</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../constant-values.html#org.apache.jmeter.util.JMeterUtils.RES_KEY_PFX">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;()">
<h3>JMeterUtils</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">JMeterUtils</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="getMatcher()">
<h3>getMatcher</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.oro.text.regex.Perl5Matcher</span>&nbsp;<span class="element-name">getMatcher</span>()</div>
<div class="block">Gets Perl5Matcher for this thread.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the <code>Perl5Matcher</code> for this thread</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProperties(java.lang.String)">
<h3>getProperties</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link">Properties</a></span>&nbsp;<span class="element-name">getProperties</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;file)</span></div>
<div class="block">This method is used by the init method to load the property file that may
 even reside in the user space, or in the classpath under
 org.apache.jmeter.jmeter.properties.

 The method also initialises logging and sets up the default Locale

 TODO - perhaps remove?
 [still used</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>file</code> - the file to load</dd>
<dt>Returns:</dt>
<dd>the Properties from the file</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#getJMeterProperties()"><code>getJMeterProperties()</code></a></li>
<li><a href="#loadJMeterProperties(java.lang.String)"><code>loadJMeterProperties(String)</code></a></li>
<li><a href="#initLocale()"><code>initLocale()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="initLogging()">
<h3>initLogging</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">initLogging</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">does not do anything anymore</div>
</div>
<div class="block">Initialise JMeter logging</div>
</section>
</li>
<li>
<section class="detail" id="initLocale()">
<h3>initLocale</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">initLocale</span>()</div>
<div class="block">Initialise the JMeter Locale</div>
</section>
</li>
<li>
<section class="detail" id="loadJMeterProperties(java.lang.String)">
<h3>loadJMeterProperties</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">loadJMeterProperties</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;file)</span></div>
<div class="block">Load the JMeter properties file; if not found, then
 default to "org/apache/jmeter/jmeter.properties" from the classpath

 <p>
 c.f. loadProperties</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>file</code> - Name of the file from which the JMeter properties should be loaded</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="loadProperties(java.lang.String)">
<h3>loadProperties</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link">Properties</a></span>&nbsp;<span class="element-name">loadProperties</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;file)</span></div>
<div class="block">This method loads a property file that may reside in the user space, or
 in the classpath</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>file</code> - the file to load</dd>
<dt>Returns:</dt>
<dd>the Properties from the file, may be null (e.g. file not found)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="loadProperties(java.lang.String,java.util.Properties)">
<h3>loadProperties</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link">Properties</a></span>&nbsp;<span class="element-name">loadProperties</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;file,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link">Properties</a>&nbsp;defaultProps)</span></div>
<div class="block">This method loads a property file that may reside in the user space, or
 in the classpath</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>file</code> - the file to load</dd>
<dd><code>defaultProps</code> - a set of default properties</dd>
<dt>Returns:</dt>
<dd>the Properties from the file; if it could not be processed, the defaultProps are returned.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="compilePattern(java.lang.String)">
<h3>compilePattern</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html" title="class or interface in java.util.regex" class="external-link">Pattern</a></span>&nbsp;<span class="element-name">compilePattern</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression)</span></div>
</section>
</li>
<li>
<section class="detail" id="compilePattern(java.lang.String,int)">
<h3>compilePattern</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html" title="class or interface in java.util.regex" class="external-link">Pattern</a></span>&nbsp;<span class="element-name">compilePattern</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 int&nbsp;flags)</span></div>
</section>
</li>
<li>
<section class="detail" id="getPatternCache()">
<h3>getPatternCache</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.oro.text.PatternCacheLRU</span>&nbsp;<span class="element-name">getPatternCache</span>()</div>
</section>
</li>
<li>
<section class="detail" id="getPattern(java.lang.String)">
<h3>getPattern</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.oro.text.regex.Pattern</span>&nbsp;<span class="element-name">getPattern</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression)</span>
                                                    throws <span class="exceptions">org.apache.oro.text.MalformedCachePatternException</span></div>
<div class="block">Get a compiled expression from the pattern cache (READ_ONLY).</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expression</code> - regular expression to be looked up</dd>
<dt>Returns:</dt>
<dd>compiled pattern</dd>
<dt>Throws:</dt>
<dd><code>org.apache.oro.text.MalformedCachePatternException</code> - (Runtime)
 This should be caught for expressions that may vary (e.g. user input)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPattern(java.lang.String,int)">
<h3>getPattern</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.oro.text.regex.Pattern</span>&nbsp;<span class="element-name">getPattern</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 int&nbsp;options)</span>
                                                    throws <span class="exceptions">org.apache.oro.text.MalformedCachePatternException</span></div>
<div class="block">Get a compiled expression from the pattern cache.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expression</code> - RE</dd>
<dd><code>options</code> - e.g. <code>READ_ONLY_MASK</code></dd>
<dt>Returns:</dt>
<dd>compiled pattern</dd>
<dt>Throws:</dt>
<dd><code>org.apache.oro.text.MalformedCachePatternException</code> - (Runtime)
 This should be caught for expressions that may vary (e.g. user input)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="initializeProperties(java.lang.String)">
<h3>initializeProperties</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">initializeProperties</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;file)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../../jorphan/test/UnitTestManager.html#initializeProperties(java.lang.String)">UnitTestManager</a></code></span></div>
<div class="block">Your implementation will be handed the filename that was provided to
 AllTests as a configuration file. It can hold whatever properties you
 need to configure your system prior to the unit tests running.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../jorphan/test/UnitTestManager.html#initializeProperties(java.lang.String)">initializeProperties</a></code>&nbsp;in interface&nbsp;<code><a href="../../jorphan/test/UnitTestManager.html" title="interface in org.apache.jorphan.test">UnitTestManager</a></code></dd>
<dt>Parameters:</dt>
<dd><code>file</code> - path to the configuration file</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="findClassesThatExtend(java.lang.Class)">
<h3>findClassesThatExtend</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">findClassesThatExtend</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;superClass)</span>
                                          throws <span class="exceptions"><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a></span></div>
<div class="block">Convenience method for
 <a href="../../jorphan/reflect/ClassFinder.html#findClassesThatExtend(java.lang.String%5B%5D,java.lang.Class%5B%5D,boolean)"><code>ClassFinder.findClassesThatExtend(String[], Class[], boolean)</code></a>
 with the option to include inner classes in the search set to false
 and the path list is derived from JMeterUtils.getSearchPaths().</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>superClass</code> - - single class to search for</dd>
<dt>Returns:</dt>
<dd>List of Strings containing discovered class names.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a></code> - when the used <a href="../../jorphan/reflect/ClassFinder.html" title="class in org.apache.jorphan.reflect"><code>ClassFinder</code></a> throws one while searching for the class</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSearchPaths()">
<h3>getSearchPaths</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</span>&nbsp;<span class="element-name">getSearchPaths</span>()</div>
<div class="block">Generate a list of paths to search.
 The output array always starts with
 JMETER_HOME/lib/ext
 and is followed by any paths obtained from the "search_paths" JMeter property.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>array of path strings</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRandomInt(int)">
<h3>getRandomInt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getRandomInt</span><wbr><span class="parameters">(int&nbsp;r)</span></div>
<div class="block">Provide random numbers</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>r</code> - -
            the upper bound (exclusive)</dd>
<dt>Returns:</dt>
<dd>a random <code>int</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLocale(java.util.Locale)">
<h3>setLocale</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLocale</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a>&nbsp;loc)</span></div>
<div class="block">Changes the current locale: re-reads resource strings and notifies
 listeners.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>loc</code> - -
            new locale</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getLocale()">
<h3>getLocale</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a></span>&nbsp;<span class="element-name">getLocale</span>()</div>
<div class="block">Gets the current locale.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>current locale</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addLocaleChangeListener(org.apache.jmeter.util.LocaleChangeListener)">
<h3>addLocaleChangeListener</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addLocaleChangeListener</span><wbr><span class="parameters">(<a href="LocaleChangeListener.html" title="interface in org.apache.jmeter.util">LocaleChangeListener</a>&nbsp;listener)</span></div>
</section>
</li>
<li>
<section class="detail" id="removeLocaleChangeListener(org.apache.jmeter.util.LocaleChangeListener)">
<h3>removeLocaleChangeListener</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeLocaleChangeListener</span><wbr><span class="parameters">(<a href="LocaleChangeListener.html" title="interface in org.apache.jmeter.util">LocaleChangeListener</a>&nbsp;listener)</span></div>
</section>
</li>
<li>
<section class="detail" id="getResString(java.lang.String)">
<h3>getResString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getResString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</span></div>
<div class="block">Gets the resource string for this key.

 If the resource is not found, a warning is logged</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - the key in the resource file</dd>
<dt>Returns:</dt>
<dd>the resource string if the key is found; otherwise, return
         "[res_key="+key+"]"</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getResString(java.lang.String,java.util.Locale)">
<h3>getResString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getResString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a>&nbsp;forcedLocale)</span></div>
<div class="block">Gets the resource string for this key in Locale.

 If the resource is not found, a warning is logged</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - the key in the resource file</dd>
<dd><code>forcedLocale</code> - Force a particular locale</dd>
<dt>Returns:</dt>
<dd>the resource string if the key is found; otherwise, return
         "[res_key="+key+"]"</dd>
<dt>Since:</dt>
<dd>2.7</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getResString(java.lang.String,java.lang.String)">
<h3>getResString</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getResString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;defaultValue)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Only intended for use in development; use
             getResString(String) normally</div>
</div>
<div class="block">Gets the resource string for this key.

 If the resource is not found, a warning is logged</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - the key in the resource file</dd>
<dd><code>defaultValue</code> - -
            the default value</dd>
<dt>Returns:</dt>
<dd>the resource string if the key is found; otherwise, return the
         default</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getParsedLabel(java.lang.String)">
<h3>getParsedLabel</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getParsedLabel</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</span></div>
<div class="block">To get I18N label from properties file</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - in messages.properties</dd>
<dt>Returns:</dt>
<dd>I18N label without (if exists) last colon ':' and spaces</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getLocaleString(java.lang.String)">
<h3>getLocaleString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getLocaleString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;locale)</span></div>
<div class="block">Get the locale name as a resource.
 Does not log an error if the resource does not exist.
 This is needed to support additional locales, as they won't be in existing messages files.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>locale</code> - name</dd>
<dt>Returns:</dt>
<dd>the locale display name as defined in the current Locale or the original string if not present</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getJMeterProperties()">
<h3>getJMeterProperties</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link">Properties</a></span>&nbsp;<span class="element-name">getJMeterProperties</span>()</div>
<div class="block">This gets the currently defined appProperties. It can only be called
 after the <a href="#getProperties(java.lang.String)"><code>getProperties(String)</code></a> or <a href="#loadJMeterProperties(java.lang.String)"><code>loadJMeterProperties(String)</code></a>
 method has been called.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>The JMeterProperties value,
         may be null if <a href="#loadJMeterProperties(java.lang.String)"><code>loadJMeterProperties(String)</code></a> has not been called</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#getProperties(java.lang.String)"><code>getProperties(String)</code></a></li>
<li><a href="#loadJMeterProperties(java.lang.String)"><code>loadJMeterProperties(String)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getImage(java.lang.String)">
<h3>getImage</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/ImageIcon.html" title="class or interface in javax.swing" class="external-link">ImageIcon</a></span>&nbsp;<span class="element-name">getImage</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
<div class="block">This looks for the requested image in the classpath under
 org.apache.jmeter.images.&lt;name&gt;</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>name</code> - Description of Parameter</dd>
<dt>Returns:</dt>
<dd>The Image value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getImage(java.lang.String,java.lang.String)">
<h3>getImage</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/ImageIcon.html" title="class or interface in javax.swing" class="external-link">ImageIcon</a></span>&nbsp;<span class="element-name">getImage</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;description)</span></div>
<div class="block">This looks for the requested image in the classpath under
 org.apache.jmeter.images.<em>&lt;name&gt;</em>, and also sets the description
 of the image, which is useful if the icon is going to be placed
 on the clipboard.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>name</code> - the name of the image</dd>
<dd><code>description</code> - the description of the image</dd>
<dt>Returns:</dt>
<dd>The Image value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getResourceFileAsText(java.lang.String)">
<h3>getResourceFileAsText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getResourceFileAsText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
</section>
</li>
<li>
<section class="detail" id="getPropDefault(java.lang.String,int)">
<h3>getPropDefault</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getPropDefault</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 int&nbsp;defaultVal)</span></div>
<div class="block">Get a int value with default if not present.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>propName</code> - the name of the property.</dd>
<dd><code>defaultVal</code> - the default value.</dd>
<dt>Returns:</dt>
<dd>The PropDefault value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropDefault(java.lang.String,boolean)">
<h3>getPropDefault</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getPropDefault</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 boolean&nbsp;defaultVal)</span></div>
<div class="block">Get a boolean value with default if not present.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>propName</code> - the name of the property.</dd>
<dd><code>defaultVal</code> - the default value.</dd>
<dt>Returns:</dt>
<dd>The PropDefault value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getArrayPropDefault(java.lang.String,java.lang.String[])">
<h3>getArrayPropDefault</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</span>&nbsp;<span class="element-name">getArrayPropDefault</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]&nbsp;defaultVal)</span></div>
<div class="block">Get an array of String if present and not empty, defaultValue if not present.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>propName</code> - the name of the property.</dd>
<dd><code>defaultVal</code> - the default value.</dd>
<dt>Returns:</dt>
<dd>The PropDefault value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropDefault(java.lang.String,long)">
<h3>getPropDefault</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getPropDefault</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 long&nbsp;defaultVal)</span></div>
<div class="block">Get a long value with default if not present.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>propName</code> - the name of the property.</dd>
<dd><code>defaultVal</code> - the default value.</dd>
<dt>Returns:</dt>
<dd>The PropDefault value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropDefault(java.lang.String,float)">
<h3>getPropDefault</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">float</span>&nbsp;<span class="element-name">getPropDefault</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 float&nbsp;defaultVal)</span></div>
<div class="block">Get a float value with default if not present.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>propName</code> - the name of the property.</dd>
<dd><code>defaultVal</code> - the default value.</dd>
<dt>Returns:</dt>
<dd>The PropDefault value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropDefault(java.lang.String,double)">
<h3>getPropDefault</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">getPropDefault</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 double&nbsp;defaultVal)</span></div>
<div class="block">Get a double value with default if not present.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>propName</code> - the name of the property.</dd>
<dd><code>defaultVal</code> - the default value.</dd>
<dt>Returns:</dt>
<dd>The PropDefault value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getPropDefault(java.lang.String,java.lang.String)">
<h3>getPropDefault</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getPropDefault</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;defaultVal)</span></div>
<div class="block">Get a String value with default if not present.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>propName</code> - the name of the property.</dd>
<dd><code>defaultVal</code> - the default value.</dd>
<dt>Returns:</dt>
<dd>The PropDefault value applying a trim on it</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProperty(java.lang.String)">
<h3>getProperty</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getProperty</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName)</span></div>
<div class="block">Get the value of a JMeter property.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>propName</code> - the name of the property.</dd>
<dt>Returns:</dt>
<dd>the value of the JMeter property, or <code>null</code> if not defined</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 static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">setProperty</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propName,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;propValue)</span></div>
<div class="block">Set a String value</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>propName</code> - the name of the property.</dd>
<dd><code>propValue</code> - the value of the property</dd>
<dt>Returns:</dt>
<dd>the previous value of the property</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="reportErrorToUser(java.lang.String)">
<h3>reportErrorToUser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">reportErrorToUser</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;errorMsg)</span></div>
<div class="block">Report an error through a dialog box.
 Title defaults to "error_title" resource string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>errorMsg</code> - - the error message.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="reportErrorToUser(java.lang.String,java.lang.String)">
<h3>reportErrorToUser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">reportErrorToUser</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;errorMsg,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;titleMsg)</span></div>
<div class="block">Report an error through a dialog box in GUI mode
 or in logs and stdout in Non GUI mode</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>errorMsg</code> - - the error message.</dd>
<dd><code>titleMsg</code> - - title string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="reportErrorToUser(java.lang.String,java.lang.Exception)">
<h3>reportErrorToUser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">reportErrorToUser</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;errorMsg,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a>&nbsp;exception)</span></div>
<div class="block">Report an error through a dialog box.
 Title defaults to "error_title" resource string</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>errorMsg</code> - - the error message.</dd>
<dd><code>exception</code> - <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html" title="class or interface in java.lang" class="external-link"><code>Exception</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="reportErrorToUser(java.lang.String,java.lang.String,java.lang.Exception)">
<h3>reportErrorToUser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">reportErrorToUser</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;errorMsg,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;titleMsg,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a>&nbsp;exception)</span></div>
<div class="block">Report an error through a dialog box in GUI mode
 or in logs and stdout in Non GUI mode</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>errorMsg</code> - - the error message.</dd>
<dd><code>titleMsg</code> - - title string</dd>
<dd><code>exception</code> - Exception</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="reportInfoToUser(java.lang.String,java.lang.String)">
<h3>reportInfoToUser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">reportInfoToUser</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;msg,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;titleMsg)</span></div>
<div class="block">Report an information through a dialog box in GUI mode</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>msg</code> - - the information message.</dd>
<dd><code>titleMsg</code> - - title string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="labelFor(java.awt.Component,java.lang.String)">
<h3>labelFor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JLabel.html" title="class or interface in javax.swing" class="external-link">JLabel</a></span>&nbsp;<span class="element-name">labelFor</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/awt/Component.html" title="class or interface in java.awt" class="external-link">Component</a>&nbsp;component,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;resourceId)</span></div>
<div class="block">Creates <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JLabel.html" title="class or interface in javax.swing" class="external-link"><code>JLabel</code></a> that is associated with a given <a href="https://docs.oracle.com/javase/8/docs/api/java/awt/Component.html" title="class or interface in java.awt" class="external-link"><code>Component</code></a> instance.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>component</code> - component for the label</dd>
<dd><code>resourceId</code> - resource ID to be used for retrieving label text</dd>
<dt>Returns:</dt>
<dd>JLabel instance</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="labelFor(java.awt.Component,java.lang.String,java.lang.String)">
<h3>labelFor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JLabel.html" title="class or interface in javax.swing" class="external-link">JLabel</a></span>&nbsp;<span class="element-name">labelFor</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/awt/Component.html" title="class or interface in java.awt" class="external-link">Component</a>&nbsp;component,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;labelValue,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
<div class="block">Creates <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JLabel.html" title="class or interface in javax.swing" class="external-link"><code>JLabel</code></a> that is associated with a given <a href="https://docs.oracle.com/javase/8/docs/api/java/awt/Component.html" title="class or interface in java.awt" class="external-link"><code>Component</code></a> instance.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>component</code> - component for the label</dd>
<dd><code>labelValue</code> - label text</dd>
<dd><code>name</code> - JLabel name</dd>
<dt>Returns:</dt>
<dd>JLabel instance</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="unsplit(java.lang.Object[],java.lang.Object)">
<h3>unsplit</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">unsplit</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]&nbsp;splittee,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;splitChar)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">use <a href="../../jorphan/util/JOrphanUtils.html#unsplit(java.lang.Object%5B%5D,java.lang.Object)"><code>JOrphanUtils.unsplit(Object[], Object)</code></a></div>
</div>
<div class="block">Takes an array of strings and a tokenizer character, and returns a string
 of all the strings concatenated with the tokenizer string in between each
 one.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>splittee</code> - Array of Objects to be concatenated.</dd>
<dd><code>splitChar</code> - Object to unsplit the strings with.</dd>
<dt>Returns:</dt>
<dd>Array of all the tokens.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="unsplit(java.lang.Object[],java.lang.Object,java.lang.String)">
<h3>unsplit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">unsplit</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]&nbsp;splittee,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;splitChar,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;def)</span></div>
<div class="block">Takes an array of strings and a tokenizer character, and returns a string
 of all the strings concatenated with the tokenizer string in between each
 one.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>splittee</code> - Array of Objects to be concatenated.</dd>
<dd><code>splitChar</code> - Object to unsplit the strings with.</dd>
<dd><code>def</code> - Default value to replace null values in array.</dd>
<dt>Returns:</dt>
<dd>Array of all the tokens.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isTestRunning()">
<h3>isTestRunning</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isTestRunning</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if test is running</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getJMeterHome()">
<h3>getJMeterHome</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getJMeterHome</span>()</div>
<div class="block">Get the JMeter home directory - does not include the trailing separator.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the home directory</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getJMeterBinDir()">
<h3>getJMeterBinDir</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getJMeterBinDir</span>()</div>
<div class="block">Get the JMeter bin directory - does not include the trailing separator.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the bin directory</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setJMeterHome(java.lang.String)">
<h3>setJMeterHome</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setJMeterHome</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;home)</span></div>
</section>
</li>
<li>
<section class="detail" id="getJMeterVersion()">
<h3>getJMeterVersion</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getJMeterVersion</span>()</div>
<div class="block">Gets the JMeter Version.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the JMeter version string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getJMeterCopyright()">
<h3>getJMeterCopyright</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getJMeterCopyright</span>()</div>
<div class="block">Gets the JMeter copyright.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the JMeter copyright string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isExpertMode()">
<h3>isExpertMode</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isExpertMode</span>()</div>
<div class="block">Determine whether we are in 'expert' mode. Certain features may be hidden
 from user's view unless in expert mode.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if we're in expert mode</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="findFile(java.lang.String)">
<h3>findFile</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/io/File.html" title="class or interface in java.io" class="external-link">File</a></span>&nbsp;<span class="element-name">findFile</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;fileName)</span></div>
<div class="block">Find a file in the current directory or in the JMeter bin directory.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>fileName</code> - the name of the file to find</dd>
<dt>Returns:</dt>
<dd>File object</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getLocalHostIP()">
<h3>getLocalHostIP</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getLocalHostIP</span>()</div>
<div class="block">Returns the cached result from calling
 InetAddress.getLocalHost().getHostAddress()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>String representation of local IP address</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getLocalHostName()">
<h3>getLocalHostName</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getLocalHostName</span>()</div>
<div class="block">Returns the cached result from calling
 InetAddress.getLocalHost().getHostName()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>local host name</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getLocalHostFullName()">
<h3>getLocalHostFullName</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getLocalHostFullName</span>()</div>
<div class="block">Returns the cached result from calling
 InetAddress.getLocalHost().getCanonicalHostName()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>local host name in canonical form</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="parseHeaders(java.lang.String)">
<h3>parseHeaders</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/util/LinkedHashMap.html" title="class or interface in java.util" class="external-link">LinkedHashMap</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">parseHeaders</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;headers)</span></div>
<div class="block">Split line into name/value pairs and remove colon ':'</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>headers</code> - multi-line string headers</dd>
<dt>Returns:</dt>
<dd>a map name/value for each header</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="runSafe(java.lang.Runnable)">
<h3>runSafe</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">runSafe</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;runnable)</span></div>
<div class="block">Run the runnable in AWT Thread if current thread is not AWT thread
 otherwise runs call <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/SwingUtilities.html#invokeAndWait(java.lang.Runnable)" title="class or interface in javax.swing" class="external-link"><code>SwingUtilities.invokeAndWait(Runnable)</code></a></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>runnable</code> - <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link"><code>Runnable</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="runSafe(boolean,java.lang.Runnable)">
<h3>runSafe</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">runSafe</span><wbr><span class="parameters">(boolean&nbsp;synchronous,
 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link">Runnable</a>&nbsp;runnable)</span></div>
<div class="block">Run the runnable in AWT Thread if current thread is not AWT thread
 otherwise runs call <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/SwingUtilities.html#invokeAndWait(java.lang.Runnable)" title="class or interface in javax.swing" class="external-link"><code>SwingUtilities.invokeAndWait(Runnable)</code></a></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>synchronous</code> - flag, whether we will wait for the AWT Thread to finish its job.</dd>
<dd><code>runnable</code> - <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html" title="class or interface in java.lang" class="external-link"><code>Runnable</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="helpGC()">
<h3>helpGC</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">helpGC</span>()</div>
<div class="block">Help GC by triggering GC and finalization</div>
</section>
</li>
<li>
<section class="detail" id="clearMatcherMemory(org.apache.oro.text.regex.Perl5Matcher,org.apache.oro.text.regex.Pattern)">
<h3>clearMatcherMemory</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">clearMatcherMemory</span><wbr><span class="parameters">(org.apache.oro.text.regex.Perl5Matcher&nbsp;matcher,
 org.apache.oro.text.regex.Pattern&nbsp;pattern)</span></div>
<div class="block">Hack to make matcher clean the two internal buffers it keeps in memory which size is equivalent to
 the unzipped page size</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>matcher</code> - <code>Perl5Matcher</code></dd>
<dd><code>pattern</code> - Pattern</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getHiDPIMode()">
<h3>getHiDPIMode</h3>
<div class="member-signature"><span class="annotations">@API(since="5.3",
     status=DEPRECATED)
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">getHiDPIMode</span>()</div>
<div class="block">Provide info, whether we run in HiDPI mode</div>
<dl class="notes">
<dt>Returns:</dt>
<dd><code>true</code> if we run in HiDPI mode, <code>false</code> otherwise</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getHiDPIScaleFactor()">
<h3>getHiDPIScaleFactor</h3>
<div class="member-signature"><span class="annotations">@API(since="5.3",
     status=DEPRECATED)
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">getHiDPIScaleFactor</span>()</div>
<div class="block">Provide info about the HiDPI scale factor</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the factor by which we should scale elements for HiDPI mode</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="applyHiDPI(javax.swing.JTable)">
<h3>applyHiDPI</h3>
<div class="member-signature"><span class="annotations">@API(since="5.3",
     status=DEPRECATED)
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">applyHiDPI</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JTable.html" title="class or interface in javax.swing" class="external-link">JTable</a>&nbsp;table)</span></div>
<div class="block">Apply HiDPI mode management to <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JTable.html" title="class or interface in javax.swing" class="external-link"><code>JTable</code></a></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>table</code> - the <a href="https://docs.oracle.com/javase/8/docs/api/javax/swing/JTable.html" title="class or interface in javax.swing" class="external-link"><code>JTable</code></a> which should be adapted for HiDPI mode</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getDelimiter(java.lang.String)">
<h3>getDelimiter</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getDelimiter</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;delimiterValue)</span></div>
<div class="block">Return delimiterValue handling the TAB case</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>delimiterValue</code> - Delimited value</dd>
<dt>Returns:</dt>
<dd>String delimited modified to handle correctly tab</dd>
<dt>Throws:</dt>
<dd><code><a href="../../jorphan/util/JMeterError.html" title="class in org.apache.jorphan.util">JMeterError</a></code> - if delimiterValue has a length different from 1</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="applyHiDPIOnFonts()">
<h3>applyHiDPIOnFonts</h3>
<div class="member-signature"><span class="annotations">@API(since="5.3",
     status=DEPRECATED)
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">applyHiDPIOnFonts</span>()</div>
<div class="block">Apply HiDPI scale factor on font if HiDPI mode is enabled</div>
</section>
</li>
<li>
<section class="detail" id="applyScaleOnFonts(float)">
<h3>applyScaleOnFonts</h3>
<div class="member-signature"><span class="annotations">@API(since="5.3",
     status=DEPRECATED)
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">applyScaleOnFonts</span><wbr><span class="parameters">(float&nbsp;scale)</span></div>
<div class="block">Apply HiDPI scale factor on fonts</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>scale</code> - float scale to apply</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="refreshUI()">
<h3>refreshUI</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">refreshUI</span>()</div>
<div class="block">Refresh UI after LAF change or resizing</div>
</section>
</li>
<li>
<section class="detail" id="setupXStreamSecurityPolicy(com.thoughtworks.xstream.XStream)">
<h3>setupXStreamSecurityPolicy</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setupXStreamSecurityPolicy</span><wbr><span class="parameters">(com.thoughtworks.xstream.XStream&nbsp;xstream)</span></div>
<div class="block">Setup default security policy</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>xstream</code> - <code>XStream</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="formatJMeterExportedVariableName(java.lang.String)">
<h3>formatJMeterExportedVariableName</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">formatJMeterExportedVariableName</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;elementName)</span></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>elementName</code> - String elementName</dd>
<dt>Returns:</dt>
<dd>variable name for index following JMeter convention</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createXStream()">
<h3>createXStream</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">com.thoughtworks.xstream.XStream</span>&nbsp;<span class="element-name">createXStream</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd><code>XStream</code> XStream instance following JMeter security policy</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright © 1998-2022 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
