threadingtest.java

手机邮箱撒的方式方式方式的

            messageAB.setThreadingMessageID( "AB" );
            messageAB.setParentIDs( firstLevelParentIDs );

            MessageHeader messageB = new MessageHeader(null);
            messageB.setSubject( "subject" );
            messageB.setThreadingMessageID( "B" );

            messages.addElement( messageA );
            messages.addElement( messageAA );
            messages.addElement( messageAAA );
            messages.addElement( messageAB );
            messages.addElement( messageB );
        }

        protected void prepareDataForCheck() {
        	threadedMessageIDs = new String[] {
        		"A",
        		"AA",
        		"AAA",
        		"AB",
        		"B"
        	};
        	isRoot = new boolean[] {
        		true,
        		false,
        		false,
        		false,
        		true
        	};
        }
    }

    /**
     * Class contains data for test and result should be:
     * <pre>
     * --1
     *   \--10
     *      \--100
     *         |--A
     *         \--B
     * </pre>
     * (or something similar - siblings could be switched)
     * When converted to 2 levels:
     * <pre>
     * --100
     *   |--A
     *   \--B
     * </pre>
     * 
     * @author Betlista
     */
    class EmptyContainerData extends AData {

        public EmptyContainerData( final String testName ) {
        	super(testName);
            Vector parentIDs = new Vector();
            parentIDs.addElement( "1" );
            parentIDs.addElement( "10" );
            parentIDs.addElement( "100" );

              // create A message
            MessageHeader messageA = new MessageHeader(null);
            messageA.setSubject( "A" );
            messageA.setThreadingMessageID( "A" );
            messageA.setParentID( "100" );
            messageA.setParentIDs( parentIDs );
            messages.addElement( messageA );

              // create message B
            MessageHeader messageB = new MessageHeader(null);
            messageB.setSubject( "B" );
            messageB.setThreadingMessageID( "B" );
            messageB.setParentID( "100" );
            messageB.setParentIDs( parentIDs );
            messages.addElement( messageB );
        }

        protected void prepareDataForCheck() {
        	threadedMessageIDs = new String[] {
        		"100",
        		"A",
        		"B"
        	};
        	isRoot = new boolean[] {
        		true,
        		false,
        		false
        	};
        }
    }

    /**
     * Class contains data for test and result should be:
     * <pre>
     * --1
     *   \--10
     *      |--100
     *      |  |--A
     *      |  \--B
     *      \--C
     * </pre>
     * (or something similar - siblings could be switched)
     * When converted to 2 levels:
     * <pre>
     *   --10
     *     |--A
     *     |--B
     *     \--C
     * </pre>
     * 
     * @author Betlista
     */
    class EmptyContainerDataWithC extends AData {
        public EmptyContainerDataWithC( final String testName ) {
        	super(testName);
            Vector longParentList = new Vector();
            longParentList.addElement( "1" );
            longParentList.addElement( "10" );
            longParentList.addElement( "100" );

            Vector shortParentList = new Vector();
            shortParentList.addElement( "1" );
            shortParentList.addElement( "10" );

              // create A message
            MessageHeader messageA = new MessageHeader(null);
            messageA.setSubject( "A" );
            messageA.setThreadingMessageID( "A" );
            messageA.setParentID( "100" );
            messageA.setParentIDs( longParentList );
            messages.addElement( messageA );

              // create message B
            MessageHeader messageB = new MessageHeader(null);
            messageB.setSubject( "B" );
            messageB.setThreadingMessageID( "B" );
            messageB.setParentID( "100" );
            messageB.setParentIDs( longParentList );
            messages.addElement( messageB );

              // create message C
            MessageHeader messageC = new MessageHeader(null);
            messageC.setSubject( "C" );
            messageC.setThreadingMessageID( "C" );
            messageC.setParentID( "10" );
            messageC.setParentIDs( shortParentList );
            messages.addElement( messageC );
        }
        protected void prepareDataForCheck() {
        	threadedMessageIDs = new String[] {
    			"10",
        		"A",
        		"B",
        		"C"
        	};
        	isRoot = new boolean[] {
        		true,
        		false,
        		false,
        		false
        	};
        }
    }

    /**
     * Class contains data for test and result should be:
     * <pre>
     * --1
     *   |--10
     *   |  \--A
     *   \--11
     *      \--B
     * </pre>
     * (or something similar - siblings could be switched)
     * When converted to 2 levels:
     * <pre>
     * --1
     *   |--A
     *   \--B
     * </pre>
     * 
     * @author Betlista
     */
    class EmptyContainerDataDifferent extends AData {
        public EmptyContainerDataDifferent( final String testName ) {
        	super(testName);
            Vector parentIDsForA = new Vector();
            parentIDsForA.addElement( "1" );
            parentIDsForA.addElement( "10" );

            Vector parentIDsForB = new Vector();
            parentIDsForB.addElement( "1" );
            parentIDsForB.addElement( "11" );

              // create A message
            MessageHeader messageA = new MessageHeader(null);
            messageA.setSubject( "A" );
            messageA.setThreadingMessageID( "A" );
            messageA.setParentID( "10" );
            messageA.setParentIDs( parentIDsForA );
            messages.addElement( messageA );

              // create message B
            MessageHeader messageB = new MessageHeader(null);
            messageB.setSubject( "B" );
            messageB.setThreadingMessageID( "B" );
            messageB.setParentID( "11" );
            messageB.setParentIDs( parentIDsForB );
            messages.addElement( messageB );
        }
        protected void prepareDataForCheck() {
        	threadedMessageIDs = new String[] {
    			"1",
        		"A",
        		"B"
        	};
        	isRoot = new boolean[] {
        		true,
        		false,
        		false
        	};
        }
    }

    /**
     * Class contains data for test and result should be:
     * <pre>
     * --1
     *   \--10
     *      \--100
     *         \--1000
     *            \--10000
     *               |--A
     *               \--B
     * </pre>
     * (or something similar - siblings could be switched)
     * When converted to 2 levels:
     * <pre>
     * --10000
     *   |--A
     *   \--B
     * </pre>
     * 
     * @author Betlista
     */
    class IncompletePathData extends AData {
        public IncompletePathData( final String testName ) {
        	super(testName);
            Vector completePath = new Vector();
            completePath.addElement("1");
            completePath.addElement("10");
            completePath.addElement("100");
            completePath.addElement("1000");
            completePath.addElement("10000");

            Vector incompletePath = new Vector();
            incompletePath.addElement("10");
            incompletePath.addElement("10000");

            MessageHeader messageA = new MessageHeader(null);
            messageA.setSubject( "A" );
            messageA.setThreadingMessageID( "A" );
            messageA.setParentID( "10000" );
            messageA.setParentIDs( completePath );
            MessageHeader messageB = new MessageHeader(null);
            messageB.setSubject( "B" );
            messageB.setThreadingMessageID( "B" );
            messageB.setParentID( "10000" );
            messageB.setParentIDs( incompletePath );

            messages.addElement( messageA );
            messages.addElement( messageB );
        }
        protected void prepareDataForCheck() {
        	threadedMessageIDs = new String[] {
    			"10000",
        		"A",
        		"B"
        	};
        	isRoot = new boolean[] {
        		true,
        		false,
        		false
        	};
        }
    }

    /**
     * Class contains data for test and result should be:
     * <pre>
     * --1
     *   \--10
     *      \--100
     *         \--1000
     *            \--10000
     *               |--A
     *               \--B
     * </pre>
     * When converted to 2 levels:
     * <pre>
     * --10000
     *   |--A
     *   \--B
     * </pre>
     * 
     * @author Betlista
     */
    class IncompletePathDataSwitched extends AData {
        public IncompletePathDataSwitched( final String testName ) {
        	super(testName);
            Vector completePath = new Vector();
            completePath.addElement("1");
            completePath.addElement("10");
            completePath.addElement("100");
            completePath.addElement("1000");
            completePath.addElement("10000");

            Vector incompletePath = new Vector();
            incompletePath.addElement("10");
            incompletePath.addElement("10000");

            MessageHeader messageA = new MessageHeader(null);
            messageA.setSubject( "A" );
            messageA.setThreadingMessageID( "A" );
            messageA.setParentID( "10000" );
            messageA.setParentIDs( incompletePath );
            MessageHeader messageB = new MessageHeader(null);
            messageB.setSubject( "B" );
            messageB.setThreadingMessageID( "B" );
            messageB.setParentID( "10000" );