threadingtest.java

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

package test.mujmail.threading;

import j2meunit.framework.Test;
import j2meunit.framework.TestCase;
import j2meunit.framework.TestMethod;
import j2meunit.framework.TestSuite;

import java.util.Enumeration;
import java.util.Vector;

import mujmail.MessageHeader;
import mujmail.Settings;
import mujmail.ordering.ComparatorStrategy;
import mujmail.ordering.Criterion;
import mujmail.ordering.Ordering;
import mujmail.threading.Algorithm;
import mujmail.threading.ThreadedEmails;

public class ThreadingTest extends TestCase {

    private static final boolean DEBUG = false;

    public ThreadingTest() {
        super();
    }

    public ThreadingTest(String name, TestMethod testMethod) {
        super(name, testMethod);
    }



    public void testBasicFunctionality() {
        new BasicFunctionalityData("testBasicFunctionality").test();
    }

    public void testEmptyContainers() {
        new EmptyContainerData("testEmptyContainers").test();
    }

    public void testEmptyContainersWithC() {
        new EmptyContainerDataWithC("testEmptyContainersWithC").test();
    }

    public void testEmptyContainersDifferent() {
        new EmptyContainerDataDifferent("testEmptyContainersDifferent").test();
    }

    public void testIncompleteParentPath() {
        new IncompletePathData("testIncompleteParentPath").test();
    }

    public void testIncompleteParentPathSwitched() {
        new IncompletePathDataSwitched("testIncompleteParentPathSwitched").test();
    }

    public void testTester1mujmailorg() {
        new Tester1mujmailorgData("testTester1mujmailorg").test();
    }

    public void testTester1mujmailorg090308() {
        new Tester1mujmailOrgData090308("testTester1mujmailorg090308").test();
    }

    public void testDataFromDavidsAccount090308() {
    	new DavidsData( "testDataFromDavidsAccount090308" ).test();
    }

    public void testOneMail() {
    	new OneMailWithoutParent( "testOneMail" ).test();
    }

    public void testRemovingEmailProblem() {
    	new RemovingEmailsProblemData( "testRemovingEmailProblem" ).test();
    }

    public void testNewThreadingRealData() {
        new NewThreadingRealData( "testNewThreadingRealData" ).test();
    }


    public Test suite() {
    	Settings.threading = true;

        TestSuite suite = new TestSuite();

        suite.addTest( new ThreadingTest("testBasicFunctionality", new TestMethod() {
            public void run(TestCase testCase) throws Throwable {
                ((ThreadingTest)testCase).testBasicFunctionality();
            }
        }) );

        suite.addTest( new ThreadingTest("testEmptyContainers", new TestMethod() {
            public void run(TestCase testCase) throws Throwable {
                ((ThreadingTest)testCase).testEmptyContainers();
            }
        }) );

        suite.addTest( new ThreadingTest("testEmptyContainersWithC", new TestMethod() {
            public void run(TestCase testCase) throws Throwable {
                ((ThreadingTest)testCase).testEmptyContainersWithC();
            }
        }) );

        suite.addTest( new ThreadingTest("testEmptyContainersDifferent", new TestMethod() {
            public void run(TestCase testCase) throws Throwable {
                ((ThreadingTest)testCase).testEmptyContainersDifferent();
            }
        }) );

        suite.addTest( new ThreadingTest("testIncompleteParentPath", new TestMethod() {
            public void run(TestCase testCase) throws Throwable {
                ((ThreadingTest)testCase).testIncompleteParentPath();
            }
        }) );

        suite.addTest( new ThreadingTest("testIncompleteParentPathSwitched", new TestMethod() {
            public void run(TestCase testCase) throws Throwable {
                ((ThreadingTest)testCase).testIncompleteParentPathSwitched();
            }
        }) );

        suite.addTest( new ThreadingTest("testTester1mujmail.org", new TestMethod() {
            public void run(TestCase testCase) throws Throwable {
                ((ThreadingTest)testCase).testTester1mujmailorg();
            }
        }) );

        suite.addTest( new ThreadingTest("testTester1mujmailorg090308", new TestMethod() {
            public void run(TestCase testCase) throws Throwable {
                ((ThreadingTest)testCase).testTester1mujmailorg090308();
            }
        }) );

        suite.addTest( new ThreadingTest("testDataFromDavidsAccount090308", new TestMethod() {
            public void run(TestCase testCase) throws Throwable {
                ((ThreadingTest)testCase).testDataFromDavidsAccount090308();
            }
        }) );

        suite.addTest( new ThreadingTest("testOneMail", new TestMethod() {
            public void run(TestCase testCase) throws Throwable {
                ((ThreadingTest)testCase).testOneMail();
            }
        }) );

        suite.addTest( new ThreadingTest("testRemovingEmailProblem", new TestMethod() {
            public void run(TestCase testCase) throws Throwable {
                ((ThreadingTest)testCase).testRemovingEmailProblem();
            }
        }) );

        suite.addTest( new ThreadingTest("testNewThreadingRealData", new TestMethod() {
            public void run(TestCase testCase) throws Throwable {
                ((ThreadingTest)testCase).testNewThreadingRealData();
            }
        }) );

        return suite;
    }

    abstract class AData {
    	/**
    	 * Vector of message headers.
    	 */
        protected Vector messages;

        /** Test name. It's printed to console when test starts. */
        private String testName;

        /**
         * Constructor that sets test name.
         * 
         * @see #testName
         */
        public AData( final String testName ) {
            messages = new Vector();
            this.testName = testName;
        }

        /**
         * Getter for vector of messages.
         * 
         * @return vector of messages
         */
        public Vector getMessages() {
            return messages;
        }

        /**
         * Method invokes threading algorithm on prepared data and at the end
         * checks if the result is the expected result.
         */
        public void test() {
            try {
            	System.out.println( "=== " + testName + " ===");
                ThreadedEmails threadedEmails = Algorithm.getAlgorithm().invoke( this.getMessages() );
                threadedEmails.sort( ComparatorStrategy.getStrategy().getComparator( Ordering.NATURAL, Criterion.THREADING_MESSAGE_ID ) );
                  //#ifdef MUJMAIL_DEVELOPMENT
//#                   if (DEBUG) threadedEmails.printToConsole();
                  //#endif
                if ( ! this.checkResult( threadedEmails ) ) {
                	fail();
                }
            } catch (Throwable t) {
                t.printStackTrace();
                assertTrue(false);
            }
        }

        /**
         * Array of expected threaded message IDs.
         */
        protected String[] threadedMessageIDs;
        /**
         * Array of flags whether the expected message have to be root message.
         */
        protected boolean[] isRoot;
        /**
         * Method prepares expected data for test.
         * 
         * @see #threadedMessageIDs
         * @see #isRoot
         */
        abstract protected void prepareDataForCheck();

        /**
         * This method makes two checks for e-mails:
         * <ul>
         * <li>checks e-mail threading message ID against </li>
         * <li>checks whether the e-mail have to be root message or not</li>
         * </ul>
         * @param threadedEmails structure to be checked
         * @return return if the result is correct (<code>true</code>) or not
         * @see #prepareDataForCheck()
         */
        private boolean checkResult( ThreadedEmails threadedEmails ) {
        	  // check if some e-mails are missing
        	if ( messages.size() != threadedEmails.getSize() - threadedEmails.getEmptyRootsNumber() ) {
        		System.err.println( "Number of messages in result is not correct - expected: " + messages.size() + ", but got " + (threadedEmails.getSize() - threadedEmails.getEmptyRootsNumber()) );
        		return false;
        	}
        	prepareDataForCheck();

        	final Enumeration enum1 = threadedEmails.getEnumeration();

        	String threadedMessageID;
        	int i = 0;
        	MessageHeader header;
            while ( enum1.hasMoreElements() ) {
            	header = (MessageHeader)enum1.nextElement();
            	if ( header == null ) {
            		fail( "Header is null" );
            	}
            	if ( i >= threadedMessageIDs.length) {
            		System.err.println( "Too many messages" );
            		return false;
            	}
            	threadedMessageID = threadedMessageIDs[i];
            	if ( ! threadedMessageID.equals( header.getThreadingMessageID() ) ) {
    				System.err.println( "Message i: " + i + " have to have threaded message ID: '" + threadedMessageID + "', is '" + header.getThreadingMessageID() + "'" );
    				return false;
    			}
    			if ( isRoot[i] && ! threadedEmails.isRootMessage( header ) ) {
    				System.err.println( "Message i: " + i + " have to be root message (threaded message ID: '" + threadedMessageID + "')" );
    				return false;
    			}

            	++i;
            }

            Enumeration e = threadedEmails.getEnumeration();
            i = 0;
            while (e.hasMoreElements()) {
                MessageHeader mh = (MessageHeader)e.nextElement();
                System.out.println( i++ + ". ID: " + mh.getThreadingMessageID() );
            }

        	return true;
        }
    }
    /**
     * Class contains data for test and result should be:
     * <pre>
     * --A
     *   |--AA
     *   |  \--AAA
     *   \--AB
     * --B
     * </pre>
     * When converted to 2 levels:
     * <pre>
     * --A
     *   |--AA
     *   |--AAA
     *   \--AB
     * --B
     * </pre>
     * 
     * @author Betlista
     */
    private class BasicFunctionalityData extends AData {

        public BasicFunctionalityData( final String testName ) {
        	super(testName);
            Vector firstLevelParentIDs = new Vector();
            firstLevelParentIDs.addElement( "A" );

            Vector secondLevelParentIDs = new Vector();
            secondLevelParentIDs.addElement( "A" );
            secondLevelParentIDs.addElement( "AA" );

            MessageHeader messageA = new MessageHeader(null);
            messageA.setSubject( "test" );
            messageA.setThreadingMessageID( "A" );

            MessageHeader messageAA = new MessageHeader(null);
            messageAA.setSubject( "Re: test" );
            messageAA.setThreadingMessageID( "AA" );
            messageAA.setParentID("A");
            messageAA.setParentIDs( firstLevelParentIDs );

            MessageHeader messageAAA = new MessageHeader(null);
            messageAAA.setSubject( "RE: Re: test" );
            messageAAA.setThreadingMessageID( "AAA" );
            messageAAA.setParentID("AA");
            messageAAA.setParentIDs( secondLevelParentIDs );

            MessageHeader messageAB = new MessageHeader(null);
            messageAB.setSubject( "RE: test" );