Attachment #33036 for bug #57981

View | Details | Raw Unified | Return to bug 57981
Collapse All | Expand All

Lines 67-76 public class JSoupExtractor implements Extractor { Link Here

(-)a/src/components/org/apache/jmeter/extractor/JSoupExtractor.java (-4 / +2 lines)
67	document = Jsoup.parse(inputString);	67	document = Jsoup.parse(inputString);
68	}	68	}
69	Elements elements = document.select(expression);	69	Elements elements = document.select(expression);
70	int size = elements.size();	70	for (Element element : elements) {
71	for (int i = 0; i < size; i++) {	71	if (matchNumber <= 0 \|\| found != matchNumber) {
72	Element element = elements.get(i);
73	if (matchNumber <=0 \|\| found != matchNumber) {
74	result.add(extractValue(attribute, element));	72	result.add(extractValue(attribute, element));
75	found++;	73	found++;
76	} else {	74	} else {

Lines 77-86 public class JoddExtractor implements Extractor { Link Here

(-)a/src/components/org/apache/jmeter/extractor/JoddExtractor.java (-4 / +2 lines)
77	nodeSelector = new NodeSelector(doc);	77	nodeSelector = new NodeSelector(doc);
78	}	78	}
79	List<Node> elements = nodeSelector.select(expression);	79	List<Node> elements = nodeSelector.select(expression);
80	int size = elements.size();	80	for (Node element : elements) {
81	for (int i = 0; i < size; i++) {	81	if (matchNumber <= 0 \|\| found != matchNumber) {
82	Node element = elements.get(i);
83	if (matchNumber <=0 \|\| found != matchNumber) {
84	result.add(extractValue(attribute, element));	82	result.add(extractValue(attribute, element));
85	found++;	83	found++;
86	} else {	84	} else {

Lines 404-412 public class RespTimeGraphChart extends JPanel { Link Here

(-)a/src/components/org/apache/jmeter/visualizers/RespTimeGraphChart.java (-3 / +2 lines)
404	*/	404	*/
405	private double findMax(double datas[][]) {	405	private double findMax(double datas[][]) {
406	double max = 0;	406	double max = 0;
407	for (int i = 0; i < datas.length; i++) {	407	for (double[] dataArray : datas) {
408	for (int j = 0; j < datas[i].length; j++) {	408	for (final double value : dataArray) {
409	final double value = datas[i][j];
410	if ((!Double.isNaN(value)) && (value > max)) {	409	if ((!Double.isNaN(value)) && (value > max)) {
411	max = value;	410	max = value;
412	}	411	}




        // Add any assertion that failed as children of the sample node
        AssertionResult assertionResults[] = res.getAssertionResults();
        int assertionIndex = currNode.getChildCount();
        for (AssertionResult item : assertionResults) {
            AssertionResult item = assertionResults[j];

            if (item.isFailure() || item.isError()) {
                DefaultMutableTreeNode assertionNode = new DefaultMutableTreeNode(item);
                treeModel.insertNodeInto(assertionNode, currNode, assertionIndex++);


        int leafIndex = 0;

        for (SampleResult child : subResults) {
            SampleResult child = subResults[i];

            if (log.isDebugEnabled()) {
                log.debug("updateGui1 : child sample result - " + child);
            }

            // Add any assertion that failed as children of the sample node
            AssertionResult assertionResults[] = child.getAssertionResults();
            int assertionIndex = leafNode.getChildCount();
            for (AssertionResult item : assertionResults) {
                AssertionResult item = assertionResults[j];

                if (item.isFailure() || item.isError()) {
                    DefaultMutableTreeNode assertionNode = new DefaultMutableTreeNode(item);
                    treeModel.insertNodeInto(assertionNode, leafNode, assertionIndex++);

Lines 79-86 public class SamplerMetric { Link Here

(-)a/src/components/org/apache/jmeter/visualizers/backend/SamplerMetric.java (-2 / +2 lines)
79	if (!TransactionController.isFromTransactionController(res)) {	79	if (!TransactionController.isFromTransactionController(res)) {
80	hits += 1;	80	hits += 1;
81	}	81	}
82	for (int i = 0; i < subResults.length; i++) {	82	for (SampleResult subResult : subResults) {
83	addHits(subResults[i]);	83	addHits(subResult);
84	}	84	}
85	}	85	}
86		86




package org.apache.jmeter.visualizers.backend.graphite;

import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;

        koPercentiles = new HashMap<>(percentilesStringArray.length);
        allPercentiles = new HashMap<>(percentilesStringArray.length);
        DecimalFormat format = new DecimalFormat("0.##");
        for (String percentile : percentilesStringArray) {
            if (!StringUtils.isEmpty(percentile.trim())) {
                try {
                    Float percentileValue = Float.parseFloat(percentile.trim());
                    okPercentiles.put(
                            METRIC_OK_PERCENTILE_PREFIX + AbstractGraphiteMetricsSender.sanitizeString(format.format(percentileValue)),
                            percentileValue);
                    koPercentiles.put(
                            METRIC_KO_PERCENTILE_PREFIX + AbstractGraphiteMetricsSender.sanitizeString(format.format(percentileValue)),
                            percentileValue);
                    allPercentiles.put(
                            METRIC_ALL_PERCENTILE_PREFIX + AbstractGraphiteMetricsSender.sanitizeString(format.format(percentileValue)),
                            percentileValue);

                } catch (Exception e) {
                    LOGGER.error("Error parsing percentile:'" + percentile + "'", e);
                }
            }
        }
        Class<?> clazz = Class.forName(graphiteMetricsSenderClass);
        this.graphiteMetricsManager = (GraphiteMetricsSender) clazz.newInstance();
        graphiteMetricsManager.setup(graphiteHost, graphitePort, rootMetricsPrefix);
        samplersToFilter = new HashSet<>(Arrays.asList(samplersList.split(SEPARATOR)));
        samplersToFilter = new HashSet<>();
        for (String samplerName : samplers) {
            samplersToFilter.add(samplerName);
        }
        scheduler = Executors.newScheduledThreadPool(MAX_POOL_SIZE);
        // Don't change this as metrics are per second
        this.timerHandle = scheduler.scheduleAtFixedRate(this, ONE_SECOND, ONE_SECOND, TimeUnit.SECONDS);




        return desc;
    }

    private String generateResult(MatchResult match, String namep, Object[] templates, JMeterVariables vars) {
        saveGroups(match, namep, vars);
        StringBuilder result = new StringBuilder();
        for (Object template : templates) {
            if (template instanceof String) {
                result.append(template);
            } else {
                result.append(match.group((Integer) template));
            }
        }
        if (namep.length() > 0){

Lines 48-58 public final class CLUtil { Link Here

(-)a/src/jorphan/org/apache/commons/cli/avalon/CLUtil.java (-5 / +5 lines)
48	final String lSep = System.getProperty("line.separator");	48	final String lSep = System.getProperty("line.separator");
49	final StringBuilder sb = new StringBuilder();	49	final StringBuilder sb = new StringBuilder();
50		50
51	for (int i = 0; i < options.length; i++) {	51	for (CLOptionDescriptor option : options) {
52	final char ch = (char) options[i].getId();	52	final char ch = (char) option.getId();
53	final String name = options[i].getName();	53	final String name = option.getName();
54	String description = options[i].getDescription();	54	String description = option.getDescription();
55	int flags = options[i].getFlags();	55	int flags = option.getFlags();
56	boolean argumentOptional = ((flags & CLOptionDescriptor.ARGUMENT_OPTIONAL) == CLOptionDescriptor.ARGUMENT_OPTIONAL);	56	boolean argumentOptional = ((flags & CLOptionDescriptor.ARGUMENT_OPTIONAL) == CLOptionDescriptor.ARGUMENT_OPTIONAL);
57	boolean argumentRequired = ((flags & CLOptionDescriptor.ARGUMENT_REQUIRED) == CLOptionDescriptor.ARGUMENT_REQUIRED);	57	boolean argumentRequired = ((flags & CLOptionDescriptor.ARGUMENT_REQUIRED) == CLOptionDescriptor.ARGUMENT_REQUIRED);
58	boolean twoArgumentsRequired = ((flags & CLOptionDescriptor.ARGUMENTS_REQUIRED_2) == CLOptionDescriptor.ARGUMENTS_REQUIRED_2);	58	boolean twoArgumentsRequired = ((flags & CLOptionDescriptor.ARGUMENTS_REQUIRED_2) == CLOptionDescriptor.ARGUMENTS_REQUIRED_2);




        if (headers.length != dHeaders.length) {
            valid = false;
        } else {
            for (String dHeader : dHeaders) {
                if (!header.contains(dHeader)) {
                    valid = false;
                    break;
                }

            currentPos = size;
            d.reset();
            while (d.next()) {
                for (String header : headers) {
                    addColumnValue(header, d.getColumnValue(header));
                }
            }
        }

        String[] contents = getDataAsText();
        StringBuilder sb = new StringBuilder();
        boolean first = true;
        for (String content : contents) {
            if (!first) {
                sb.append("\n");
            } else {
                first = false;
            }
            sb.append(content);
        }
        return sb.toString();
    }




     */
    public HashTree(Object[] keys) {
        data = new HashMap<>();
        for (Object key : keys) {
            data.put(key, new HashTree());
        }
    }


     *            Array of Keys to be added to HashTree.
     */
    public void add(Object[] keys) {
        for (Object key : keys) {
            add(key);
        }
    }


Lines 64-72 public class ListedHashTree extends HashTree implements Serializable, Cloneable Link Here

(-)a/src/jorphan/org/apache/jorphan/collections/ListedHashTree.java (-3 / +3 lines)
64		64
65	public ListedHashTree(Object[] keys) {	65	public ListedHashTree(Object[] keys) {
66	this();	66	this();
67	for (int x = 0; x < keys.length; x++) {	67	for (Object key : keys) {
68	data.put(keys[x], new ListedHashTree());	68	data.put(key, new ListedHashTree());
69	order.add(keys[x]);	69	order.add(key);
70	}	70	}
71	}	71	}
72		72





    public SortedHashTree(Object[] keys) {
        this();
        for (Object key : keys) {
            data.put(key, new SortedHashTree());
        }
    }

    public SortedHashTree(Object[] keys, Comparator<? super Object> comper) {
        this(comper);
        for (Object key : keys) {
            data.put(key, new SortedHashTree(comper));
        }
    }


Lines 229-236 public class MonitorAccumModel implements Clearable, Serializable { Link Here

(-)a/src/monitor/components/org/apache/jmeter/visualizers/MonitorAccumModel.java (-3 / +1 lines)
229	* the {@link MonitorModel} that should be sent to the listeners	229	* the {@link MonitorModel} that should be sent to the listeners
230	*/	230	*/
231	public void notifyListeners(MonitorModel model) {	231	public void notifyListeners(MonitorModel model) {
232	for (int idx = 0; idx < listeners.size(); idx++) {	232	for (MonitorListener ml : listeners) {
233	MonitorListener ml = listeners.get(idx);
234	ml.addSample(model);	233	ml.addSample(model);
235	}	234	}
236	}	235	}
237	-

Return to bug 57981

Lines 150-158 implements ActionListener, TreeSelectionListener, Clearable, ItemListener { Link Here

(-)a/src/components/org/apache/jmeter/visualizers/ViewResultsFullVisualizer.java (-9 / +3 lines)
150	// Add any assertion that failed as children of the sample node	150	// Add any assertion that failed as children of the sample node
151	AssertionResult assertionResults[] = res.getAssertionResults();	151	AssertionResult assertionResults[] = res.getAssertionResults();
152	int assertionIndex = currNode.getChildCount();	152	int assertionIndex = currNode.getChildCount();
153	for (int j = 0; j < assertionResults.length; j++) {	153	for (AssertionResult item : assertionResults) {
154	AssertionResult item = assertionResults[j];
155
156	if (item.isFailure() \|\| item.isError()) {	154	if (item.isFailure() \|\| item.isError()) {
157	DefaultMutableTreeNode assertionNode = new DefaultMutableTreeNode(item);	155	DefaultMutableTreeNode assertionNode = new DefaultMutableTreeNode(item);
158	treeModel.insertNodeInto(assertionNode, currNode, assertionIndex++);	156	treeModel.insertNodeInto(assertionNode, currNode, assertionIndex++);
Lines 173-181 implements ActionListener, TreeSelectionListener, Clearable, ItemListener { Link Here
173		171
174	int leafIndex = 0;	172	int leafIndex = 0;
175		173
176	for (int i = 0; i < subResults.length; i++) {	174	for (SampleResult child : subResults) {
177	SampleResult child = subResults[i];
178
179	if (log.isDebugEnabled()) {	175	if (log.isDebugEnabled()) {
180	log.debug("updateGui1 : child sample result - " + child);	176	log.debug("updateGui1 : child sample result - " + child);
181	}	177	}
Lines 186-194 implements ActionListener, TreeSelectionListener, Clearable, ItemListener { Link Here
186	// Add any assertion that failed as children of the sample node	182	// Add any assertion that failed as children of the sample node
187	AssertionResult assertionResults[] = child.getAssertionResults();	183	AssertionResult assertionResults[] = child.getAssertionResults();
188	int assertionIndex = leafNode.getChildCount();	184	int assertionIndex = leafNode.getChildCount();
189	for (int j = 0; j < assertionResults.length; j++) {	185	for (AssertionResult item : assertionResults) {
190	AssertionResult item = assertionResults[j];
191
192	if (item.isFailure() \|\| item.isError()) {	186	if (item.isFailure() \|\| item.isError()) {
193	DefaultMutableTreeNode assertionNode = new DefaultMutableTreeNode(item);	187	DefaultMutableTreeNode assertionNode = new DefaultMutableTreeNode(item);
194	treeModel.insertNodeInto(assertionNode, leafNode, assertionIndex++);	188	treeModel.insertNodeInto(assertionNode, leafNode, assertionIndex++);

Lines 19-24 Link Here

(-)a/src/components/org/apache/jmeter/visualizers/backend/graphite/GraphiteBackendListenerClient.java (-13 / +10 lines)
19	package org.apache.jmeter.visualizers.backend.graphite;	19	package org.apache.jmeter.visualizers.backend.graphite;
20		20
21	import java.text.DecimalFormat;	21	import java.text.DecimalFormat;
		22	import java.util.Arrays;
22	import java.util.HashMap;	23	import java.util.HashMap;
23	import java.util.HashSet;	24	import java.util.HashSet;
24	import java.util.List;	25	import java.util.List;
Lines 237-269 public class GraphiteBackendListenerClient extends AbstractBackendListenerClient Link Here
237	koPercentiles = new HashMap<>(percentilesStringArray.length);	238	koPercentiles = new HashMap<>(percentilesStringArray.length);
238	allPercentiles = new HashMap<>(percentilesStringArray.length);	239	allPercentiles = new HashMap<>(percentilesStringArray.length);
239	DecimalFormat format = new DecimalFormat("0.##");	240	DecimalFormat format = new DecimalFormat("0.##");
240	for (int i = 0; i < percentilesStringArray.length; i++) {	241	for (String percentile : percentilesStringArray) {
241	if(!StringUtils.isEmpty(percentilesStringArray[i].trim())) {	242	if (!StringUtils.isEmpty(percentile.trim())) {
242	try {	243	try {
243	Float percentileValue = Float.parseFloat(percentilesStringArray[i].trim());	244	Float percentileValue = Float.parseFloat(percentile.trim());
244	okPercentiles.put(	245	okPercentiles.put(
245	METRIC_OK_PERCENTILE_PREFIX+AbstractGraphiteMetricsSender.sanitizeString(format.format(percentileValue)),	246	METRIC_OK_PERCENTILE_PREFIX + AbstractGraphiteMetricsSender.sanitizeString(format.format(percentileValue)),
246	percentileValue);	247	percentileValue);
247	koPercentiles.put(	248	koPercentiles.put(
248	METRIC_KO_PERCENTILE_PREFIX+AbstractGraphiteMetricsSender.sanitizeString(format.format(percentileValue)),	249	METRIC_KO_PERCENTILE_PREFIX + AbstractGraphiteMetricsSender.sanitizeString(format.format(percentileValue)),
249	percentileValue);	250	percentileValue);
250	allPercentiles.put(	251	allPercentiles.put(
251	METRIC_ALL_PERCENTILE_PREFIX+AbstractGraphiteMetricsSender.sanitizeString(format.format(percentileValue)),	252	METRIC_ALL_PERCENTILE_PREFIX + AbstractGraphiteMetricsSender.sanitizeString(format.format(percentileValue)),
252	percentileValue);	253	percentileValue);
253		254
254	} catch(Exception e) {	255	} catch (Exception e) {
255	LOGGER.error("Error parsing percentile:'"+percentilesStringArray[i]+"'", e);	256	LOGGER.error("Error parsing percentile:'" + percentile + "'", e);
256	}	257	}
257	}	258	}
258	}	259	}
259	Class<?> clazz = Class.forName(graphiteMetricsSenderClass);	260	Class<?> clazz = Class.forName(graphiteMetricsSenderClass);
260	this.graphiteMetricsManager = (GraphiteMetricsSender) clazz.newInstance();	261	this.graphiteMetricsManager = (GraphiteMetricsSender) clazz.newInstance();
261	graphiteMetricsManager.setup(graphiteHost, graphitePort, rootMetricsPrefix);	262	graphiteMetricsManager.setup(graphiteHost, graphitePort, rootMetricsPrefix);
262	String[] samplers = samplersList.split(SEPARATOR);	263	samplersToFilter = new HashSet<>(Arrays.asList(samplersList.split(SEPARATOR)));
263	samplersToFilter = new HashSet<>();
264	for (String samplerName : samplers) {
265	samplersToFilter.add(samplerName);
266	}
267	scheduler = Executors.newScheduledThreadPool(MAX_POOL_SIZE);	264	scheduler = Executors.newScheduledThreadPool(MAX_POOL_SIZE);
268	// Don't change this as metrics are per second	265	// Don't change this as metrics are per second
269	this.timerHandle = scheduler.scheduleAtFixedRate(this, ONE_SECOND, ONE_SECOND, TimeUnit.SECONDS);	266	this.timerHandle = scheduler.scheduleAtFixedRate(this, ONE_SECOND, ONE_SECOND, TimeUnit.SECONDS);

Lines 216-229 public class RegexFunction extends AbstractFunction { Link Here

(-)a/src/functions/org/apache/jmeter/functions/RegexFunction.java (-5 / +5 lines)
216	return desc;	216	return desc;
217	}	217	}
218		218
219	private String generateResult(MatchResult match, String namep, Object[] template, JMeterVariables vars) {	219	private String generateResult(MatchResult match, String namep, Object[] templates, JMeterVariables vars) {
220	saveGroups(match, namep, vars);	220	saveGroups(match, namep, vars);
221	StringBuilder result = new StringBuilder();	221	StringBuilder result = new StringBuilder();
222	for (int a = 0; a < template.length; a++) {	222	for (Object template : templates) {
223	if (template[a] instanceof String) {	223	if (template instanceof String) {
224	result.append(template[a]);	224	result.append(template);
225	} else {	225	} else {
226	result.append(match.group(((Integer) template[a]).intValue()));	226	result.append(match.group((Integer) template));
227	}	227	}
228	}	228	}
229	if (namep.length() > 0){	229	if (namep.length() > 0){

Lines 92-99 public class Data implements Serializable { Link Here

(-)a/src/jorphan/org/apache/jorphan/collections/Data.java (-6 / +6 lines)
92	if (headers.length != dHeaders.length) {	92	if (headers.length != dHeaders.length) {
93	valid = false;	93	valid = false;
94	} else {	94	} else {
95	for (int count = 0; count < dHeaders.length; count++) {	95	for (String dHeader : dHeaders) {
96	if (!header.contains(dHeaders[count])) {	96	if (!header.contains(dHeader)) {
97	valid = false;	97	valid = false;
98	break;	98	break;
99	}	99	}
Lines 104-111 public class Data implements Serializable { Link Here
104	currentPos = size;	104	currentPos = size;
105	d.reset();	105	d.reset();
106	while (d.next()) {	106	while (d.next()) {
107	for (int count = 0; count < headers.length; count++) {	107	for (String header : headers) {
108	addColumnValue(headers[count], d.getColumnValue(headers[count]));	108	addColumnValue(header, d.getColumnValue(header));
109	}	109	}
110	}	110	}
111	}	111	}
Lines 685-697 public class Data implements Serializable { Link Here
685	String[] contents = getDataAsText();	685	String[] contents = getDataAsText();
686	StringBuilder sb = new StringBuilder();	686	StringBuilder sb = new StringBuilder();
687	boolean first = true;	687	boolean first = true;
688	for (int x = 0; x < contents.length; x++) {	688	for (String content : contents) {
689	if (!first) {	689	if (!first) {
690	sb.append("\n");	690	sb.append("\n");
691	} else {	691	} else {
692	first = false;	692	first = false;
693	}	693	}
694	sb.append(contents[x]);	694	sb.append(content);
695	}	695	}
696	return sb.toString();	696	return sb.toString();
697	}	697	}

Lines 230-237 public class HashTree implements Serializable, Map<Object, HashTree>, Cloneable Link Here

(-)a/src/jorphan/org/apache/jorphan/collections/HashTree.java (-4 / +4 lines)
230	*/	230	*/
231	public HashTree(Object[] keys) {	231	public HashTree(Object[] keys) {
232	data = new HashMap<>();	232	data = new HashMap<>();
233	for (int x = 0; x < keys.length; x++) {	233	for (Object key : keys) {
234	data.put(keys[x], new HashTree());	234	data.put(key, new HashTree());
235	}	235	}
236	}	236	}
237		237
Lines 432-439 public class HashTree implements Serializable, Map<Object, HashTree>, Cloneable Link Here
432	* Array of Keys to be added to HashTree.	432	* Array of Keys to be added to HashTree.
433	*/	433	*/
434	public void add(Object[] keys) {	434	public void add(Object[] keys) {
435	for (int x = 0; x < keys.length; x++) {	435	for (Object key : keys) {
436	add(keys[x]);	436	add(key);
437	}	437	}
438	}	438	}
439		439

Lines 73-87 public class SortedHashTree extends HashTree implements Serializable { Link Here

(-)a/src/jorphan/org/apache/jorphan/collections/SortedHashTree.java (-4 / +4 lines)
73		73
74	public SortedHashTree(Object[] keys) {	74	public SortedHashTree(Object[] keys) {
75	this();	75	this();
76	for (int x = 0; x < keys.length; x++) {	76	for (Object key : keys) {
77	data.put(keys[x], new SortedHashTree());	77	data.put(key, new SortedHashTree());
78	}	78	}
79	}	79	}
80		80
81	public SortedHashTree(Object[] keys, Comparator<? super Object> comper) {	81	public SortedHashTree(Object[] keys, Comparator<? super Object> comper) {
82	this(comper);	82	this(comper);
83	for (int x = 0; x < keys.length; x++) {	83	for (Object key : keys) {
84	data.put(keys[x], new SortedHashTree(comper));	84	data.put(key, new SortedHashTree(comper));
85	}	85	}
86	}	86	}
87		87