/*
 * Copyright 2002-2004 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package test.types;

import junit.framework.TestCase;
import org.apache.axis.types.Duration;
import java.util.Calendar;
import java.util.GregorianCalendar;

/**
 * <p>Title: </p>
 * <p>Description: </p>
 * @author Dominik Kacprzak <dominik@opentoolbox.com>
 * @version $Id: TestDuration.java 259917 2004-11-27 21:08:12Z dims $
 *
 * @todo try to find original author, add more docs
 */
public class TestDuration extends TestCase {


    public TestDuration(String name) {
        super(name);
    }

    public void testValidDurations() throws Exception {
        // invoke the web service as if it was a local java object
        String[] durationStrings = new String[11];
        durationStrings[0] = "P2Y3M8DT8H1M3.3S";
        durationStrings[1] = "P2Y3M8DT8H1M3S";
        durationStrings[2] = "PT8H1M3.3S";
        durationStrings[3] = "P2Y3M8D";
        durationStrings[4] = "P2YT8H";
        durationStrings[5] = "P8DT3.3S";
        durationStrings[6] = "P3MT1M";
        durationStrings[7] = "PT0.3S";
        durationStrings[8] = "P1M";
        durationStrings[9] = "-P1M";
        durationStrings[10] = "-P2Y3M8DT8H1M3.3S";

        for (int i = 0; i < durationStrings.length; i++) {
            String durationString = durationStrings[i];
            Duration duration = new Duration(durationString);

            assertTrue("Duration string \"" + durationString +
                       "\" not equal to returned: " + duration.toString(),
                       durationString.equals(duration.toString()));
        }
    }

    public void testInvalidDurations() throws Exception {
        // make sure that using invalid duration strings results in an
        // exception
        String[] invalidDurationStrings = {"P", "T", "P-2Y3M8D", "P8H1M3S",
                                          "P8Y1MT", "PT8Y1M3D", "PYMDTHMS"};
        // each of the above strings should result in an exception
        for (int i = 0; i < invalidDurationStrings.length; i++) {
            String durationString = invalidDurationStrings[i];
            try {
                Duration duration = new Duration(durationString);
                throw new junit.framework.AssertionFailedError(
                        "org.apache.axis.types.Duration constructor accepted invalid string: " +
                        durationString);
            } catch (IllegalArgumentException e) {
                // this is good
            }
        }

        /* need to test setTime(String) and setDate(String) for handling
         * invalid time and date strings. A handling of properly formatted
         * time and date strings is tested as part of testValidDurations()
         * test case.
         * NOTE: the code below can be removed if/when
         * parseDate(String) and parseTime(String) methods are changed
         * to private ones.
         */
        String[] invalidTimeStrings = {"", "-8H1M3.3S", "8Y1M3D", "HMS"};
        Duration duration = new Duration();
        for (int i = 0; i < invalidTimeStrings.length; i++) {
            String durationString = invalidTimeStrings[i];
            try {
                duration.parseTime(durationString);
                throw new junit.framework.AssertionFailedError(
                        "parseTime(String) method accepted invalid string: " +
                        durationString);
            } catch (IllegalArgumentException e) {
                // this is good
            }
        }

        String[] invalidDateStrings = {"", "-2Y3M8D", "8H1M3S", "-8Y1M"};
        for (int i = 0; i < invalidDateStrings.length; i++) {
            String durationString = invalidDateStrings[i];
            try {
                duration.parseDate(durationString);
                throw new junit.framework.AssertionFailedError(
                        "parseDate(String) method accepted invalid string: " +
                        durationString);
            } catch (IllegalArgumentException e) {
                // this is good
            }
        }

    }

    /**
     * Test if duration object is properly created from a Calendar.
     * @throws Exception
     */
    public void testDurationFromCalendar() throws Exception {
        // negative date
        Calendar calendar = new GregorianCalendar(1, 3, 20);
        Duration duration = new Duration(true, calendar);
        assertTrue("Negative flag does not match", duration.isNegative());
        assertTrue("Years do not match", duration.getYears() == 1);
        assertTrue("Months do not match", duration.getMonths() == 3);
        assertTrue("Days do not match", duration.getDays() == 20);
        assertEquals("String representation does not match", duration.toString(),
                     "-P1Y3M20D");
        // positive date and time
        calendar.clear();
        calendar.set(1, 2, 20, 10, 3, 11);
        duration = new Duration(false, calendar);
        assertTrue("Negative flag does not match", !duration.isNegative());
        assertTrue("Years do not match", duration.getYears() == 1);
        assertTrue("Months do not match", duration.getMonths() == 2);
        assertTrue("Days do not match", duration.getDays() == 20);
        assertTrue("Hours do not match", duration.getHours() == 10);
        assertTrue("Minutes do not match", duration.getMinutes() == 3);
        assertTrue("Seconds do not match", duration.getSeconds() == 11);
        assertEquals("String representation does not match", duration.toString(),
                     "P1Y2M20DT10H3M11S");
    }

    public void testCalendarFromDuration() throws Exception {
        // Check if a calendar object used to create a duration object and
        // a calendar object created from the same duration are equal
        // that's good test for handling of miliseconds
        Calendar calendar = new GregorianCalendar(1, 2, 20, 10, 3, 11);
        calendar.set(Calendar.MILLISECOND, 15);
        Duration duration = new Duration(true, calendar);
        Calendar durationCalendar = duration.getAsCalendar();
        assertTrue("Negative flag does not match", duration.isNegative());
        assertEquals("Years do not match",
                     calendar.get(Calendar.YEAR),
                     durationCalendar.get(Calendar.YEAR));
        assertEquals("Months do not match",
                     calendar.get(Calendar.MONTH),
                     durationCalendar.get(Calendar.MONTH));
        assertEquals("Days do not match",
                     calendar.get(Calendar.DATE),
                     durationCalendar.get(Calendar.DATE));
        assertEquals("Hours do not match",
                     calendar.get(Calendar.HOUR),
                     durationCalendar.get(Calendar.HOUR));
        assertEquals("Minutes do not match",
                     calendar.get(Calendar.MINUTE),
                     durationCalendar.get(Calendar.MINUTE));
        assertEquals("Seconds do not match",
                     calendar.get(Calendar.SECOND),
                     durationCalendar.get(Calendar.SECOND));
        assertEquals("Miliseconds do not match",
                     calendar.get(Calendar.MILLISECOND),
                     durationCalendar.get(Calendar.MILLISECOND));

        // test for overflows - Calendar class does automatic conversion
        // of dates
        duration.setMonths(20);
        durationCalendar = duration.getAsCalendar();
        assertEquals("Years do not match",
                     duration.getYears() + 1,
                     durationCalendar.get(Calendar.YEAR));
        assertEquals("Months do not match",
                     duration.getMonths() - 12,
                     durationCalendar.get(Calendar.MONTH));

        // make sure that Duration enforces milliseconds precision
        duration.setSeconds(10.1234);
        assertTrue("Milliseconds precision is not enforced",
                     duration.getSeconds() == 10.12);
    }

    public void testHash() {
        // test if hash is taking milliseconds in account
        Duration d1 = new Duration(false, 10, 1, 2, 1, 20, 2.51);
        Duration d2 = new Duration(false, 10, 1, 2, 1, 20, 2.51);
        Duration d3 = new Duration(false, 10, 1, 2, 1, 20, 2);
        Duration d4 = new Duration(false, 10, 1, 2, 1, 20, 2.51233);
        assertEquals("Hash code values do not match", d1.hashCode(),
                     d2.hashCode());
        assertFalse("Hash code values match", d1.hashCode() == d3.hashCode());
        // test precistion
        assertEquals("Hash code values do not match", d1.hashCode(),
                     d4.hashCode());
    }

    public void testEquals() {
        // test if equals is taking milliseconds in account
        Duration d1 = new Duration(false, 10, 1, 2, 1, 20, 2.51);
        Duration d2 = new Duration(false, 10, 1, 2, 1, 20, 2.51);
        Duration d3 = new Duration(true, 10, 1, 2, 1, 20, 2.51);
        Duration d4 = new Duration(false, 8, 25, 2, 0, 80, 2.51);
        Duration d5 = new Duration(false, 8, 25, 2, 0, 80, 2.51);
        // the durations are equal: testing precision
        assertTrue("Comparison failed", d1.equals(d2));
        // the durations are equal, except of the sign
        assertFalse("Comparison failed", d1.equals(d3));
        // the durations are equal, but represented differently
        assertTrue("Comparison failed", d1.equals(d4));
        // test precision
        assertTrue("Comparison failed", d1.equals(d5));
    }
}