* Copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos

*

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

*  * Redistributions of source code must retain the above copyright notice,

*    this list of conditions and the following disclaimer.

*

*  * Redistributions in binary form must reproduce the above copyright notice,

*    this list of conditions and the following disclaimer in the documentation

*    and/or other materials provided with the distribution.

*

*  * Neither the name of JSR-310 nor the names of its contributors

*    may be used to endorse or promote products derived from this software

*    without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

* Test LocalDateTime.

*/

    private static final ZoneOffset OFFSET_PONE = ZoneOffset.ofHours(1);

    private static final ZoneOffset OFFSET_PTWO = ZoneOffset.ofHours(2);

    private static final ZoneOffset OFFSET_MTWO = ZoneOffset.ofHours(-2);

    private static final ZoneId ZONE_PARIS = ZoneId.of("Europe/Paris");

    private static final ZoneId ZONE_GAZA = ZoneId.of("Asia/Gaza");

    private LocalDateTime TEST_2007_07_15_12_30_40_987654321 = LocalDateTime.of(2007, 7, 15, 12, 30, 40, 987654321);

    private LocalDateTime MAX_DATE_TIME;

    private LocalDateTime MIN_DATE_TIME;

    private Instant MAX_INSTANT;

    private Instant MIN_INSTANT;

    @BeforeMethod

    public void setUp() {

        MAX_DATE_TIME = LocalDateTime.MAX;

        MIN_DATE_TIME = LocalDateTime.MIN;

        MAX_INSTANT = MAX_DATE_TIME.atZone(ZoneOffset.UTC).toInstant();

        MIN_INSTANT = MIN_DATE_TIME.atZone(ZoneOffset.UTC).toInstant();

    }

    //-----------------------------------------------------------------------

    @Override

    protected List<TemporalAccessor> samples() {

        TemporalAccessor[] array = {TEST_2007_07_15_12_30_40_987654321, LocalDateTime.MAX, LocalDateTime.MIN, };

        return Arrays.asList(array);

    }

    @Override

    protected List<TemporalField> validFields() {

        TemporalField[] array = {

            NANO_OF_SECOND,

            NANO_OF_DAY,

            MICRO_OF_SECOND,

            MICRO_OF_DAY,

            MILLI_OF_SECOND,

            MILLI_OF_DAY,

            SECOND_OF_MINUTE,

            SECOND_OF_DAY,

            MINUTE_OF_HOUR,

            MINUTE_OF_DAY,

            CLOCK_HOUR_OF_AMPM,

            HOUR_OF_AMPM,

            CLOCK_HOUR_OF_DAY,

            HOUR_OF_DAY,

            AMPM_OF_DAY,

            DAY_OF_WEEK,

            ALIGNED_DAY_OF_WEEK_IN_MONTH,

            ALIGNED_DAY_OF_WEEK_IN_YEAR,

            DAY_OF_MONTH,

            DAY_OF_YEAR,

            EPOCH_DAY,

            ALIGNED_WEEK_OF_MONTH,

            ALIGNED_WEEK_OF_YEAR,

            MONTH_OF_YEAR,

            PROLEPTIC_MONTH,

            YEAR_OF_ERA,

            YEAR,

            ERA,

            JulianFields.JULIAN_DAY,

            JulianFields.MODIFIED_JULIAN_DAY,

            JulianFields.RATA_DIE,

        };

        return Arrays.asList(array);

    }

    @Override

    protected List<TemporalField> invalidFields() {

        List<TemporalField> list = new ArrayList<TemporalField>(Arrays.<TemporalField>asList(ChronoField.values()));

        list.removeAll(validFields());

        return list;

    }

    //-----------------------------------------------------------------------

    private void check(LocalDateTime dateTime, int y, int m, int d, int h, int mi, int s, int n) {

        assertEquals(dateTime.getYear(), y);

        assertEquals(dateTime.getMonth().getValue(), m);

        assertEquals(dateTime.getDayOfMonth(), d);

        assertEquals(dateTime.getHour(), h);

        assertEquals(dateTime.getMinute(), mi);

        assertEquals(dateTime.getSecond(), s);

        assertEquals(dateTime.getNano(), n);

    }

    private LocalDateTime createDateMidnight(int year, int month, int day) {

        return LocalDateTime.of(year, month, day, 0, 0);

    }

    @Test

    public void test_serialization() throws IOException, ClassNotFoundException {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        ObjectOutputStream oos = new ObjectOutputStream(baos);

        oos.writeObject(TEST_2007_07_15_12_30_40_987654321);

        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(

                baos.toByteArray()));

        assertEquals(ois.readObject(), TEST_2007_07_15_12_30_40_987654321);

    }

    @Test

    public void test_immutable() {

        Class<LocalDateTime> cls = LocalDateTime.class;

        assertTrue(Modifier.isPublic(cls.getModifiers()));

        assertTrue(Modifier.isFinal(cls.getModifiers()));

        Field[] fields = cls.getDeclaredFields();

        for (Field field : fields) {

            if (field.getName().contains("$") == false) {

                if (Modifier.isStatic(field.getModifiers())) {

                    assertTrue(Modifier.isFinal(field.getModifiers()), "Field:" + field.getName());

                } else {

                    assertTrue(Modifier.isPrivate(field.getModifiers()), "Field:" + field.getName());

                    assertTrue(Modifier.isFinal(field.getModifiers()), "Field:" + field.getName());

                }

            }

        }

    }

    //-----------------------------------------------------------------------

    // now()

    //-----------------------------------------------------------------------

    @Test(timeOut=30000)  // TODO: remove when time zone loading is faster

    public void now() {

        LocalDateTime expected = LocalDateTime.now(Clock.systemDefaultZone());

        LocalDateTime test = LocalDateTime.now();

        long diff = Math.abs(test.toLocalTime().toNanoOfDay() - expected.toLocalTime().toNanoOfDay());

        if (diff >= 100000000) {

            // may be date change

            expected = LocalDateTime.now(Clock.systemDefaultZone());

            test = LocalDateTime.now();

            diff = Math.abs(test.toLocalTime().toNanoOfDay() - expected.toLocalTime().toNanoOfDay());

        }

        assertTrue(diff < 100000000);  // less than 0.1 secs

    }

    //-----------------------------------------------------------------------

    // now(ZoneId)

    //-----------------------------------------------------------------------

    @Test(expectedExceptions=NullPointerException.class)

    public void now_ZoneId_nullZoneId() {

        LocalDateTime.now((ZoneId) null);

    }

    @Test

    public void now_ZoneId() {

        ZoneId zone = ZoneId.of("UTC+01:02:03");

        LocalDateTime expected = LocalDateTime.now(Clock.system(zone));

        LocalDateTime test = LocalDateTime.now(zone);

        for (int i = 0; i < 100; i++) {

            if (expected.equals(test)) {

                return;

            }

            expected = LocalDateTime.now(Clock.system(zone));

            test = LocalDateTime.now(zone);

        }

        assertEquals(test, expected);

    }

    //-----------------------------------------------------------------------

    // now(Clock)

    //-----------------------------------------------------------------------

    @Test(expectedExceptions=NullPointerException.class)

    public void now_Clock_nullClock() {

        LocalDateTime.now((Clock) null);

    }

    @Test

    public void now_Clock_allSecsInDay_utc() {

        for (int i = 0; i < (2 * 24 * 60 * 60); i++) {

            Instant instant = Instant.ofEpochSecond(i).plusNanos(123456789L);

            Clock clock = Clock.fixed(instant, ZoneOffset.UTC);

            LocalDateTime test = LocalDateTime.now(clock);

            assertEquals(test.getYear(), 1970);

            assertEquals(test.getMonth(), Month.JANUARY);

            assertEquals(test.getDayOfMonth(), (i < 24 * 60 * 60 ? 1 : 2));

            assertEquals(test.getHour(), (i / (60 * 60)) % 24);

            assertEquals(test.getMinute(), (i / 60) % 60);

            assertEquals(test.getSecond(), i % 60);

            assertEquals(test.getNano(), 123456789);

        }

    }

    @Test

    public void now_Clock_allSecsInDay_offset() {

        for (int i = 0; i < (2 * 24 * 60 * 60); i++) {

            Instant instant = Instant.ofEpochSecond(i).plusNanos(123456789L);

            Clock clock = Clock.fixed(instant.minusSeconds(OFFSET_PONE.getTotalSeconds()), OFFSET_PONE);

            LocalDateTime test = LocalDateTime.now(clock);

            assertEquals(test.getYear(), 1970);

            assertEquals(test.getMonth(), Month.JANUARY);

            assertEquals(test.getDayOfMonth(), (i < 24 * 60 * 60) ? 1 : 2);

            assertEquals(test.getHour(), (i / (60 * 60)) % 24);

            assertEquals(test.getMinute(), (i / 60) % 60);

            assertEquals(test.getSecond(), i % 60);

            assertEquals(test.getNano(), 123456789);

        }

    }

    @Test

    public void now_Clock_allSecsInDay_beforeEpoch() {

        LocalTime expected = LocalTime.MIDNIGHT.plusNanos(123456789L);

        for (int i =-1; i >= -(24 * 60 * 60); i--) {

            Instant instant = Instant.ofEpochSecond(i).plusNanos(123456789L);

            Clock clock = Clock.fixed(instant, ZoneOffset.UTC);

            LocalDateTime test = LocalDateTime.now(clock);

            assertEquals(test.getYear(), 1969);

            assertEquals(test.getMonth(), Month.DECEMBER);

            assertEquals(test.getDayOfMonth(), 31);

            expected = expected.minusSeconds(1);

            assertEquals(test.toLocalTime(), expected);

        }

    }

    //-----------------------------------------------------------------------

    @Test

    public void now_Clock_maxYear() {

        Clock clock = Clock.fixed(MAX_INSTANT, ZoneOffset.UTC);

        LocalDateTime test = LocalDateTime.now(clock);

        assertEquals(test, MAX_DATE_TIME);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void now_Clock_tooBig() {

        Clock clock = Clock.fixed(MAX_INSTANT.plusSeconds(24 * 60 * 60), ZoneOffset.UTC);

        LocalDateTime.now(clock);

    }

    @Test

    public void now_Clock_minYear() {

        Clock clock = Clock.fixed(MIN_INSTANT, ZoneOffset.UTC);

        LocalDateTime test = LocalDateTime.now(clock);

        assertEquals(test, MIN_DATE_TIME);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void now_Clock_tooLow() {

        Clock clock = Clock.fixed(MIN_INSTANT.minusNanos(1), ZoneOffset.UTC);

        LocalDateTime.now(clock);

    }

    //-----------------------------------------------------------------------

    // of() factories

    //-----------------------------------------------------------------------

    //-----------------------------------------------------------------------

    @Test

    public void factory_of_4intsMonth() {

        LocalDateTime dateTime = LocalDateTime.of(2007, Month.JULY, 15, 12, 30);

        check(dateTime, 2007, 7, 15, 12, 30, 0, 0);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_4intsMonth_yearTooLow() {

        LocalDateTime.of(Integer.MIN_VALUE, Month.JULY, 15, 12, 30);

    }

    @Test(expectedExceptions=NullPointerException.class)

    public void factory_of_4intsMonth_nullMonth() {

        LocalDateTime.of(2007, null, 15, 12, 30);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_4intsMonth_dayTooLow() {

        LocalDateTime.of(2007, Month.JULY, -1, 12, 30);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_4intsMonth_dayTooHigh() {

        LocalDateTime.of(2007, Month.JULY, 32, 12, 30);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_4intsMonth_hourTooLow() {

        LocalDateTime.of(2007, Month.JULY, 15, -1, 30);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_4intsMonth_hourTooHigh() {

        LocalDateTime.of(2007, Month.JULY, 15, 24, 30);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_4intsMonth_minuteTooLow() {

        LocalDateTime.of(2007, Month.JULY, 15, 12, -1);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_4intsMonth_minuteTooHigh() {

        LocalDateTime.of(2007, Month.JULY, 15, 12, 60);

    }

    //-----------------------------------------------------------------------

    @Test

    public void factory_of_5intsMonth() {

        LocalDateTime dateTime = LocalDateTime.of(2007, Month.JULY, 15, 12, 30, 40);

        check(dateTime, 2007, 7, 15, 12, 30, 40, 0);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_5intsMonth_yearTooLow() {

        LocalDateTime.of(Integer.MIN_VALUE, Month.JULY, 15, 12, 30, 40);

    }

    @Test(expectedExceptions=NullPointerException.class)

    public void factory_of_5intsMonth_nullMonth() {

        LocalDateTime.of(2007, null, 15, 12, 30, 40);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_5intsMonth_dayTooLow() {

        LocalDateTime.of(2007, Month.JULY, -1, 12, 30, 40);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_5intsMonth_dayTooHigh() {

        LocalDateTime.of(2007, Month.JULY, 32, 12, 30, 40);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_5intsMonth_hourTooLow() {

        LocalDateTime.of(2007, Month.JULY, 15, -1, 30, 40);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_5intsMonth_hourTooHigh() {

        LocalDateTime.of(2007, Month.JULY, 15, 24, 30, 40);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_5intsMonth_minuteTooLow() {

        LocalDateTime.of(2007, Month.JULY, 15, 12, -1, 40);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_5intsMonth_minuteTooHigh() {

        LocalDateTime.of(2007, Month.JULY, 15, 12, 60, 40);

    }

    @Test(expectedExceptions=DateTimeException.class)

    public void factory_of_5intsMonth_secondTooLow() {

        LocalDateTime.of(2007, Month.JULY, 15, 12, 30, -1);