segmentedtimelinetests.java

用于制作报表的中间件控件,纯java编写,还附带有数据库操作的源代码

    }

    //////////////////////////////////////////////////////////////////////////
    // test construction process
    //////////////////////////////////////////////////////////////////////////

    /**
     * Tests that the new method that created the msTimeline segmented
     * timeline did so correctly.
     */
    public void testMsSegmentedTimeline() {
        // verify attributes set during object construction
        assertEquals(1, this.msTimeline.getSegmentSize());
        assertEquals(0, this.msTimeline.getStartTime());
        assertEquals(5, this.msTimeline.getSegmentsIncluded());
        assertEquals(2, this.msTimeline.getSegmentsExcluded());
    }

    /**
     * Tests that the new method that created the ms2Timeline segmented
     * timeline did so correctly.
     */
    public void testMs2SegmentedTimeline() {
        // verify attributes set during object construction
        assertEquals(1, this.ms2Timeline.getSegmentSize());
        assertEquals(1, this.ms2Timeline.getStartTime());
        assertEquals(2, this.ms2Timeline.getSegmentsIncluded());
        assertEquals(2, this.ms2Timeline.getSegmentsExcluded());
        assertEquals(this.ms2BaseTimeline, this.ms2Timeline.getBaseTimeline());
    }

    /**
     * Tests that the factory method that creates Monday through Friday 
     * segmented timeline does so correctly.
     */
    public void testMondayThroughFridaySegmentedTimeline() {
        // verify attributes set during object construction
        assertEquals(SegmentedTimeline.DAY_SEGMENT_SIZE, 
                this.mondayFridayTimeline.getSegmentSize());
        assertEquals(SegmentedTimeline.FIRST_MONDAY_AFTER_1900, 
                this.mondayFridayTimeline.getStartTime());
        assertEquals(5, this.mondayFridayTimeline.getSegmentsIncluded());
        assertEquals(2, this.mondayFridayTimeline.getSegmentsExcluded());
    }

    /**
     * Tests that the factory method that creates a 15-min 9:00 AM  4:00 PM
     * segmented axis does so correctly.
     */
    public void testFifteenMinSegmentedTimeline() {
        assertEquals(SegmentedTimeline.FIFTEEN_MINUTE_SEGMENT_SIZE,
                this.fifteenMinTimeline.getSegmentSize());
        assertEquals(SegmentedTimeline.FIRST_MONDAY_AFTER_1900 + 36 
                * this.fifteenMinTimeline.getSegmentSize(),
                this.fifteenMinTimeline.getStartTime());
        assertEquals(28, this.fifteenMinTimeline.getSegmentsIncluded());
        assertEquals(68, this.fifteenMinTimeline.getSegmentsExcluded());
    }

    //////////////////////////////////////////////////////////////////////////
    // test one-segment and adjacent segments
    //////////////////////////////////////////////////////////////////////////

    /**
     * Tests one segment of the ms timeline. Internal indices
     * inside one segment as well as adjacent segments are verified.
     */
    public void testMsSegment() {
        verifyOneSegment(this.msTimeline);
    }

    /**
     * Tests one segment of the ms timeline. Internal indices
     * inside one segment as well as adjacent segments are verified.
     */
    public void testMs2Segment() {
        verifyOneSegment(this.ms2Timeline);
    }

    /**
     * Tests one segment of the Monday through Friday timeline. Internal indices
     * inside one segment as well as adjacent segments are verified.
     */
    public void testMondayThroughFridaySegment() {
        verifyOneSegment(this.mondayFridayTimeline);
    }

    /**
     * Tests one segment of the Fifteen timeline. Internal indices
     * inside one segment as well as adjacent segments are verified.
     */
    public void testFifteenMinSegment() {
        verifyOneSegment(this.fifteenMinTimeline);
    }

    /**
     * Tests one segment of the Monday through Friday timeline. Internal indices
     * inside one segment as well as adjacent segments are verified.
     * @param timeline the timeline to use for verifications.
     */
    public void verifyOneSegment(SegmentedTimeline timeline) {
        
        for (long testCycle = TEST_CYCLE_START; testCycle < TEST_CYCLE_END;
             testCycle += TEST_CYCLE_INC) {

            // get two consecutive segments for various tests
            SegmentedTimeline.Segment segment1 = timeline.getSegment(
                    this.monday.getTime().getTime() + testCycle);
            SegmentedTimeline.Segment segment2 = timeline.getSegment(
                    segment1.getSegmentEnd() + 1);

            // verify segments are consecutive and correct
            assertEquals(segment1.getSegmentNumber() + 1, 
                    segment2.getSegmentNumber());
            assertEquals(segment1.getSegmentEnd() + 1, 
                    segment2.getSegmentStart());
            assertEquals(segment1.getSegmentStart() 
                    + timeline.getSegmentSize() - 1, segment1.getSegmentEnd());
            assertEquals(segment1.getSegmentStart() + timeline.getSegmentSize(),
                    segment2.getSegmentStart());
            assertEquals(segment1.getSegmentEnd() + timeline.getSegmentSize(),
                    segment2.getSegmentEnd());

            // verify various indices inside a segment are the same segment
            long delta;
            if (timeline.getSegmentSize() > 1000000) {
                delta = timeline.getSegmentSize() / 10000;
            } 
            else if (timeline.getSegmentSize() > 100000) {
                delta = timeline.getSegmentSize() / 1000;
            } 
            else if (timeline.getSegmentSize() > 10000) {
                delta = timeline.getSegmentSize() / 100;
            }
            else if (timeline.getSegmentSize() > 1000) {
                delta = timeline.getSegmentSize() / 10;
            }
            else if (timeline.getSegmentSize() > 100) {
                delta = timeline.getSegmentSize() / 5;
            }
            else {
                delta = 1;
            }

            long start = segment1.getSegmentStart() + delta;
            long end = segment1.getSegmentStart() 
                       + timeline.getSegmentSize() - 1;
            SegmentedTimeline.Segment lastSeg = timeline.getSegment(
                    segment1.getSegmentStart());
            SegmentedTimeline.Segment seg;
            for (long i = start; i < end; i += delta) {
                seg = timeline.getSegment(i);
                assertEquals(lastSeg.getSegmentNumber(), 
                        seg.getSegmentNumber());
                assertEquals(lastSeg.getSegmentStart(), seg.getSegmentStart());
                assertEquals(lastSeg.getSegmentEnd(), seg.getSegmentEnd());
                assertTrue(lastSeg.getMillisecond() < seg.getMillisecond());
                lastSeg = seg;
            }

            // try next segment
            seg = timeline.getSegment(end + 1);
            assertEquals(segment2.getSegmentNumber(), seg.getSegmentNumber());
            assertEquals(segment2.getSegmentStart(), seg.getSegmentStart());
            assertEquals(segment2.getSegmentEnd(), seg.getSegmentEnd());
        }
    }

    //////////////////////////////////////////////////////////////////////////
    // test inc methods
    //////////////////////////////////////////////////////////////////////////

    /**
     * Tests the inc methods on the msTimeline.
     */
    public void testMsInc() {
        verifyInc(this.msTimeline);
    }

    /**
     * Tests the inc methods on the msTimeline.
     */
    public void testMs2Inc() {
        verifyInc(this.ms2Timeline);
    }

    /**
     * Tests the inc methods on the Monday through Friday timeline.
     */
    public void testMondayThroughFridayInc() {
        verifyInc(this.mondayFridayTimeline);
    }

    /**
     * Tests the inc methods on the Fifteen minute timeline.
     */
    public void testFifteenMinInc() {
        verifyInc(this.fifteenMinTimeline);
    }

    /**
     * Tests the inc methods.
     * @param timeline the timeline to use for verifications.
     */
    public void verifyInc(SegmentedTimeline timeline) {
        for (long testCycle = TEST_CYCLE_START; testCycle < TEST_CYCLE_END;
             testCycle += TEST_CYCLE_INC) {

            long m = timeline.getSegmentSize();
            SegmentedTimeline.Segment segment = timeline.getSegment(testCycle);
            SegmentedTimeline.Segment seg1 = segment.copy();
            for (int i = 0; i < 1000; i++) {

                // test inc() method
                SegmentedTimeline.Segment seg2 = seg1.copy();
                seg2.inc();

                if ((seg1.getSegmentEnd() + 1) != seg2.getSegmentStart()) {
                    // logically consecutive segments non-physically consecutive
                    // (with non-contained time in between)
                    assertTrue(!timeline.containsDomainRange(
                            seg1.getSegmentEnd() + 1, 
                            seg2.getSegmentStart() - 1));
                    assertEquals(0, (seg2.getSegmentStart() 
                            - seg1.getSegmentStart()) % m);
                    assertEquals(0, (seg2.getSegmentEnd() 
                            - seg1.getSegmentEnd()) % m);
                    assertEquals(0, (seg2.getMillisecond() 
                            - seg1.getMillisecond()) % m);
                } 
                else {
                    // physically consecutive
                    assertEquals(seg1.getSegmentStart() + m, 
                            seg2.getSegmentStart());
                    assertEquals(seg1.getSegmentEnd() + m, 
                            seg2.getSegmentEnd());
                    assertEquals(seg1.getMillisecond() + m, 
                            seg2.getMillisecond());
                }

                // test inc(n) method
                SegmentedTimeline.Segment seg3 = seg1.copy();
                SegmentedTimeline.Segment seg4 = seg1.copy();

                for (int j = 0; j < i; j++) {
                    seg3.inc();
                }
                seg4.inc(i);

                assertEquals(seg3.getSegmentStart(), seg4.getSegmentStart());
                assertEquals(seg3.getSegmentEnd(), seg4.getSegmentEnd());
                assertEquals(seg3.getMillisecond(), seg4.getMillisecond());

                // go to another segment to continue test
                seg1.inc();
            }
        }
    }

    //////////////////////////////////////////////////////////////////////////
    // main include and excluded segments
    //////////////////////////////////////////////////////////////////////////

    /**
     * Tests that the msTimeline's included and excluded
     * segments are being calculated correctly.
     */
    public void testMsIncludedAndExcludedSegments() {
        verifyIncludedAndExcludedSegments(this.msTimeline, 0);
    }

    /**
     * Tests that the ms2Timeline's included and excluded
     * segments are being calculated correctly.
     */
    public void testMs2IncludedAndExcludedSegments() {
        verifyIncludedAndExcludedSegments(this.ms2Timeline, 1);
    }

    /**
     * Tests that the Monday through Friday timeline's included and excluded
     * segments are being calculated correctly. The test is performed starting
     * on the first monday after 1/1/2000 and for five years.
     */
    public void testMondayThroughFridayIncludedAndExcludedSegments() {
        verifyIncludedAndExcludedSegments(this.mondayFridayTimeline, 
                this.monday.getTime().getTime());
    }

    /**
     * Tests that the Fifteen-Min timeline's included and excluded