Attachment #31131 for bug #55375

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




import org.apache.jmeter.util.BeanShellServer;
import org.apache.jmeter.util.JMeterUtils;
import org.apache.jorphan.collections.HashTree;
import org.apache.jorphan.collections.HashTreeTraverser;
import org.apache.jorphan.collections.SearchByClass;
import org.apache.jorphan.gui.ComponentUtil;
import org.apache.jorphan.logging.LoggingManager;

                        if (subTree != null) {
                            HashTree replacementTree = rc.getReplacementSubTree();
                            if (replacementTree != null) {
                                checkForInfiniteRecursivity(replacementTree, rc);
                                convertSubTree(replacementTree);
                                tree.replace(item, rc);
                                tree.set(rc, replacementTree);

                        if (subTree != null) {
                            HashTree replacementTree = rc.getReplacementSubTree();
                            if (replacementTree != null) {
                                checkForInfiniteRecursivity(replacementTree, rc);
                                convertSubTree(replacementTree);
                                tree.replace(item, rc);
                                tree.set(rc, replacementTree);

            }
        }
    }
    
    /**
     * @since 2.10.1
     */
    private static final class InfiniteRecursivityDetector implements HashTreeTraverser {
        boolean infiniteRecursivity;
        private ReplaceableController replaceableController;

        /**
         * 
         * @param nodeToFind
         */
        public InfiniteRecursivityDetector(ReplaceableController replaceableController) {
            this.replaceableController = replaceableController;
        }
        
        /**
         * @return boolean
         */
        public boolean getInfiniteRecursivity() {
            return infiniteRecursivity;
        }
        
        @Override
        public void subtractNode() {
            // noop   
        }
        
        @Override
        public void processPath() {
            // noop
        }
        
        @Override
        public void addNode(Object node, HashTree subTree) {
            if(infiniteRecursivity== true) {
                return;
            }
            if(node instanceof JMeterTreeNode) {
                Object uo = ((JMeterTreeNode)node).getUserObject();
                if(uo==replaceableController) {
                    this.infiniteRecursivity = true;
                }
            }
            if(node == replaceableController) {
                this.infiniteRecursivity = true;
            }            
        }
    }

    /**
     * Checks that replacementTree (built after replacement of ReplaceableController) does 
     * not still contain ReplaceableController which would lead to infinite recursivity 
     * see BUG 55375
     * @param replacementTree {@link HashTreeTraverser}
     * @param replaceableController {@link ReplaceableController}
     */
    private static void checkForInfiniteRecursivity(HashTree replacementTree,
            final ReplaceableController replaceableController) {
        InfiniteRecursivityDetector hashTreeTraverser = new InfiniteRecursivityDetector(replaceableController);
        replacementTree.traverse(hashTreeTraverser);
        if(hashTreeTraverser.getInfiniteRecursivity()) {
            throw new IllegalStateException(
                    "Recursivity detected in tree:"+((TestElement)replaceableController).getName());            
        }
    }

    /**
     * Ensures the {@link ReplaceableController} is loaded

Return to bug 55375

Lines 82-87 Link Here

(-)src/core/org/apache/jmeter/JMeter.java (+69 lines)
82	import org.apache.jmeter.util.BeanShellServer;	82	import org.apache.jmeter.util.BeanShellServer;
83	import org.apache.jmeter.util.JMeterUtils;	83	import org.apache.jmeter.util.JMeterUtils;
84	import org.apache.jorphan.collections.HashTree;	84	import org.apache.jorphan.collections.HashTree;
		85	import org.apache.jorphan.collections.HashTreeTraverser;
85	import org.apache.jorphan.collections.SearchByClass;	86	import org.apache.jorphan.collections.SearchByClass;
86	import org.apache.jorphan.gui.ComponentUtil;	87	import org.apache.jorphan.gui.ComponentUtil;
87	import org.apache.jorphan.logging.LoggingManager;	88	import org.apache.jorphan.logging.LoggingManager;
Lines 859-864 Link Here
859	if (subTree != null) {	860	if (subTree != null) {
860	HashTree replacementTree = rc.getReplacementSubTree();	861	HashTree replacementTree = rc.getReplacementSubTree();
861	if (replacementTree != null) {	862	if (replacementTree != null) {
		863	checkForInfiniteRecursivity(replacementTree, rc);
862	convertSubTree(replacementTree);	864	convertSubTree(replacementTree);
863	tree.replace(item, rc);	865	tree.replace(item, rc);
864	tree.set(rc, replacementTree);	866	tree.set(rc, replacementTree);
Lines 884-889 Link Here
884	if (subTree != null) {	886	if (subTree != null) {
885	HashTree replacementTree = rc.getReplacementSubTree();	887	HashTree replacementTree = rc.getReplacementSubTree();
886	if (replacementTree != null) {	888	if (replacementTree != null) {
		889	checkForInfiniteRecursivity(replacementTree, rc);
887	convertSubTree(replacementTree);	890	convertSubTree(replacementTree);
888	tree.replace(item, rc);	891	tree.replace(item, rc);
889	tree.set(rc, replacementTree);	892	tree.set(rc, replacementTree);
Lines 900-905 Link Here
900	}	903	}
901	}	904	}
902	}	905	}
		906
		907	/**
		908	* @since 2.10.1
		909	*/
		910	private static final class InfiniteRecursivityDetector implements HashTreeTraverser {
		911	boolean infiniteRecursivity;
		912	private ReplaceableController replaceableController;
		913
		914	/**
		915	*
		916	* @param nodeToFind
		917	*/
		918	public InfiniteRecursivityDetector(ReplaceableController replaceableController) {
		919	this.replaceableController = replaceableController;
		920	}
		921
		922	/**
		923	* @return boolean
		924	*/
		925	public boolean getInfiniteRecursivity() {
		926	return infiniteRecursivity;
		927	}
		928
		929	@Override
		930	public void subtractNode() {
		931	// noop
		932	}
		933
		934	@Override
		935	public void processPath() {
		936	// noop
		937	}
		938
		939	@Override
		940	public void addNode(Object node, HashTree subTree) {
		941	if(infiniteRecursivity== true) {
		942	return;
		943	}
		944	if(node instanceof JMeterTreeNode) {
		945	Object uo = ((JMeterTreeNode)node).getUserObject();
		946	if(uo==replaceableController) {
		947	this.infiniteRecursivity = true;
		948	}
		949	}
		950	if(node == replaceableController) {
		951	this.infiniteRecursivity = true;
		952	}
		953	}
		954	}
		955
		956	/**
		957	* Checks that replacementTree (built after replacement of ReplaceableController) does
		958	* not still contain ReplaceableController which would lead to infinite recursivity
		959	* see BUG 55375
		960	* @param replacementTree {@link HashTreeTraverser}
		961	* @param replaceableController {@link ReplaceableController}
		962	*/
		963	private static void checkForInfiniteRecursivity(HashTree replacementTree,
		964	final ReplaceableController replaceableController) {
		965	InfiniteRecursivityDetector hashTreeTraverser = new InfiniteRecursivityDetector(replaceableController);
		966	replacementTree.traverse(hashTreeTraverser);
		967	if(hashTreeTraverser.getInfiniteRecursivity()) {
		968	throw new IllegalStateException(
		969	"Recursivity detected in tree:"+((TestElement)replaceableController).getName());
970	}
971	}
903		972
904	/**	973	/**
905	* Ensures the {@link ReplaceableController} is loaded	974	* Ensures the {@link ReplaceableController} is loaded