/*
 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * This file is available under and governed by the GNU General Public
 * License version 2 only, as published by the Free Software Foundation.
 * However, the following notice accompanied the original version of this
 * file:
 *
 * Copyright (c) 2008-2012, 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.
 */
package tck.java.time;

import static java.time.temporal.ChronoUnit.DAYS;
import static java.time.temporal.ChronoUnit.HOURS;
import static java.time.temporal.ChronoUnit.YEARS;
import static org.testng.Assert.assertEquals;

import java.time.DateTimeException;
import java.time.Duration;
import java.time.LocalDate;
import java.time.Period;
import java.time.chrono.ThaiBuddhistChronology;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoUnit;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAmount;
import java.time.temporal.TemporalUnit;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Locale;

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

/**
 * Test Period.
 */
@Test
public class TCKPeriod extends AbstractTCKTest {

    //-----------------------------------------------------------------------
    // ofYears(int)
    //-----------------------------------------------------------------------
    @Test
    public void factory_ofYears_int() {
        assertPeriod(Period.ofYears(0), 0, 0, 0);
        assertPeriod(Period.ofYears(1), 1, 0, 0);
        assertPeriod(Period.ofYears(234), 234, 0, 0);
        assertPeriod(Period.ofYears(-100), -100, 0, 0);
        assertPeriod(Period.ofYears(Integer.MAX_VALUE), Integer.MAX_VALUE, 0, 0);
        assertPeriod(Period.ofYears(Integer.MIN_VALUE), Integer.MIN_VALUE, 0, 0);
    }

    //-----------------------------------------------------------------------
    // ofMonths(int)
    //-----------------------------------------------------------------------
    @Test
    public void factory_ofMonths_int() {
        assertPeriod(Period.ofMonths(0), 0, 0, 0);
        assertPeriod(Period.ofMonths(1), 0, 1, 0);
        assertPeriod(Period.ofMonths(234), 0, 234, 0);
        assertPeriod(Period.ofMonths(-100), 0, -100, 0);
        assertPeriod(Period.ofMonths(Integer.MAX_VALUE), 0, Integer.MAX_VALUE, 0);
        assertPeriod(Period.ofMonths(Integer.MIN_VALUE), 0, Integer.MIN_VALUE, 0);
    }

    //-----------------------------------------------------------------------
    // ofWeeks(int)
    //-----------------------------------------------------------------------
    @Test
    public void factory_ofWeeks_int() {
        assertPeriod(Period.ofWeeks(0), 0, 0, 0);
        assertPeriod(Period.ofWeeks(1), 0, 0, 7);
        assertPeriod(Period.ofWeeks(234), 0, 0, 234 * 7);
        assertPeriod(Period.ofWeeks(-100), 0, 0, -100 * 7);
        assertPeriod(Period.ofWeeks(Integer.MAX_VALUE / 7), 0, 0, (Integer.MAX_VALUE / 7) * 7);
        assertPeriod(Period.ofWeeks(Integer.MIN_VALUE / 7), 0, 0, (Integer.MIN_VALUE / 7) * 7);
    }

    //-----------------------------------------------------------------------
    // ofDays(int)
    //-----------------------------------------------------------------------
    @Test
    public void factory_ofDays_int() {
        assertPeriod(Period.ofDays(0), 0, 0, 0);
        assertPeriod(Period.ofDays(1), 0, 0, 1);
        assertPeriod(Period.ofDays(234), 0, 0, 234);
        assertPeriod(Period.ofDays(-100), 0, 0, -100);
        assertPeriod(Period.ofDays(Integer.MAX_VALUE), 0, 0, Integer.MAX_VALUE);
        assertPeriod(Period.ofDays(Integer.MIN_VALUE), 0, 0, Integer.MIN_VALUE);
    }

    //-----------------------------------------------------------------------
    // of(int3)
    //-----------------------------------------------------------------------
    @Test
    public void factory_of_ints() {
        assertPeriod(Period.of(1, 2, 3), 1, 2, 3);
        assertPeriod(Period.of(0, 2, 3), 0, 2, 3);
        assertPeriod(Period.of(1, 0, 0), 1, 0, 0);
        assertPeriod(Period.of(0, 0, 0), 0, 0, 0);
        assertPeriod(Period.of(-1, -2, -3), -1, -2, -3);
    }

    //-----------------------------------------------------------------------
    // from(TemporalAmount)
    //-----------------------------------------------------------------------
    @Test
    public void factory_from_TemporalAmount_Period() {
        TemporalAmount amount = Period.of(1, 2, 3);
        assertPeriod(Period.from(amount), 1, 2, 3);
    }

    @Test
    public void factory_from_TemporalAmount_YearsDays() {
        TemporalAmount amount = new TemporalAmount() {
            @Override
            public long get(TemporalUnit unit) {
                if (unit == YEARS) {
                    return 23;
                } else {
                    return 45;
                }
            }
            @Override
            public List<TemporalUnit> getUnits() {
                List<TemporalUnit> list = new ArrayList<>();
                list.add(YEARS);
                list.add(DAYS);
                return list;
            }
            @Override
            public Temporal addTo(Temporal temporal) {
                throw new UnsupportedOperationException();
            }
            @Override
            public Temporal subtractFrom(Temporal temporal) {
                throw new UnsupportedOperationException();
            }
        };
        assertPeriod(Period.from(amount), 23, 0, 45);
    }

    @Test(expectedExceptions = ArithmeticException.class)
    public void factory_from_TemporalAmount_Years_tooBig() {
        TemporalAmount amount = new TemporalAmount() {
            @Override
            public long get(TemporalUnit unit) {
                return ((long) (Integer.MAX_VALUE)) + 1;
            }
            @Override
            public List<TemporalUnit> getUnits() {
                return Collections.<TemporalUnit>singletonList(YEARS);
            }
            @Override
            public Temporal addTo(Temporal temporal) {
                throw new UnsupportedOperationException();
            }
            @Override
            public Temporal subtractFrom(Temporal temporal) {
                throw new UnsupportedOperationException();
            }
        };
        Period.from(amount);
    }

    @Test(expectedExceptions = DateTimeException.class)
    public void factory_from_TemporalAmount_DaysHours() {
        TemporalAmount amount = new TemporalAmount() {
            @Override
            public long get(TemporalUnit unit) {
                if (unit == DAYS) {
                    return 1;
                } else {
                    return 2;
                }
            }
            @Override
            public List<TemporalUnit> getUnits() {
                List<TemporalUnit> list = new ArrayList<>();
                list.add(DAYS);
                list.add(HOURS);
                return list;
            }
            @Override
            public Temporal addTo(Temporal temporal) {
                throw new UnsupportedOperationException();
            }
            @Override
            public Temporal subtractFrom(Temporal temporal) {
                throw new UnsupportedOperationException();
            }
        };
        Period.from(amount);
    }

    @Test(expectedExceptions = DateTimeException.class)
    public void factory_from_TemporalAmount_NonISO() {
        Period.from(ThaiBuddhistChronology.INSTANCE.period(1, 1, 1));
    }

    @Test(expectedExceptions = DateTimeException.class)
    public void factory_from_TemporalAmount_Duration() {
        Period.from(Duration.ZERO);
    }

    @Test(expectedExceptions = NullPointerException.class)
    public void factory_from_TemporalAmount_null() {
        Period.from(null);
    }

    //-----------------------------------------------------------------------
    // parse(String)
    //-----------------------------------------------------------------------
    @DataProvider(name="parseSuccess")
    Object[][] data_factory_parseSuccess() {
        return new Object[][] {
                {"P1Y", Period.ofYears(1)},
                {"P12Y", Period.ofYears(12)},
                {"P987654321Y", Period.ofYears(987654321)},
                {"P+1Y", Period.ofYears(1)},
                {"P+12Y", Period.ofYears(12)},
                {"P+987654321Y", Period.ofYears(987654321)},
                {"P+0Y", Period.ofYears(0)},
                {"P0Y", Period.ofYears(0)},
                {"P-0Y", Period.ofYears(0)},
                {"P-25Y", Period.ofYears(-25)},
                {"P-987654321Y", Period.ofYears(-987654321)},
                {"P" + Integer.MAX_VALUE + "Y", Period.ofYears(Integer.MAX_VALUE)},
                {"P" + Integer.MIN_VALUE + "Y", Period.ofYears(Integer.MIN_VALUE)},

                {"P1M", Period.ofMonths(1)},
                {"P12M", Period.ofMonths(12)},
                {"P987654321M", Period.ofMonths(987654321)},
                {"P+1M", Period.ofMonths(1)},
                {"P+12M", Period.ofMonths(12)},
                {"P+987654321M", Period.ofMonths(987654321)},
                {"P+0M", Period.ofMonths(0)},
                {"P0M", Period.ofMonths(0)},
                {"P-0M", Period.ofMonths(0)},
                {"P-25M", Period.ofMonths(-25)},
                {"P-987654321M", Period.ofMonths(-987654321)},
                {"P" + Integer.MAX_VALUE + "M", Period.ofMonths(Integer.MAX_VALUE)},
                {"P" + Integer.MIN_VALUE + "M", Period.ofMonths(Integer.MIN_VALUE)},

                {"P1W", Period.ofDays(1 * 7)},
                {"P12W", Period.ofDays(12 * 7)},
                {"P7654321W", Period.ofDays(7654321 * 7)},
                {"P+1W", Period.ofDays(1 * 7)},
                {"P+12W", Period.ofDays(12 * 7)},
                {"P+7654321W", Period.ofDays(7654321 * 7)},
                {"P+0W", Period.ofDays(0)},
                {"P0W", Period.ofDays(0)},
                {"P-0W", Period.ofDays(0)},
                {"P-25W", Period.ofDays(-25 * 7)},
                {"P-7654321W", Period.ofDays(-7654321 * 7)},

                {"P1D", Period.ofDays(1)},
                {"P12D", Period.ofDays(12)},
                {"P987654321D", Period.ofDays(987654321)},
                {"P+1D", Period.ofDays(1)},
                {"P+12D", Period.ofDays(12)},
                {"P+987654321D", Period.ofDays(987654321)},
                {"P+0D", Period.ofDays(0)},
                {"P0D", Period.ofDays(0)},
                {"P-0D", Period.ofDays(0)},
                {"P-25D", Period.ofDays(-25)},
                {"P-987654321D", Period.ofDays(-987654321)},
                {"P" + Integer.MAX_VALUE + "D", Period.ofDays(Integer.MAX_VALUE)},
                {"P" + Integer.MIN_VALUE + "D", Period.ofDays(Integer.MIN_VALUE)},

                {"P0Y0M0D", Period.of(0, 0, 0)},
                {"P2Y0M0D", Period.of(2, 0, 0)},
                {"P0Y3M0D", Period.of(0, 3, 0)},
                {"P0Y0M4D", Period.of(0, 0, 4)},
                {"P2Y3M25D", Period.of(2, 3, 25)},
                {"P-2Y3M25D", Period.of(-2, 3, 25)},
                {"P2Y-3M25D", Period.of(2, -3, 25)},
                {"P2Y3M-25D", Period.of(2, 3, -25)},
                {"P-2Y-3M-25D", Period.of(-2, -3, -25)},

                {"P0Y0M0W0D", Period.of(0, 0, 0)},
                {"P2Y3M4W25D", Period.of(2, 3, 4 * 7 + 25)},
                {"P-2Y-3M-4W-25D", Period.of(-2, -3, -4 * 7 - 25)},
        };
    }

    @Test(dataProvider="parseSuccess")
    public void factory_parse(String text, Period expected) {
        Period p = Period.parse(text);
        assertEquals(p, expected);
    }

    @Test(dataProvider="parseSuccess")
    public void factory_parse_plus(String text, Period expected) {
        Period p = Period.parse("+" + text);
        assertEquals(p, expected);
    }

    @Test(dataProvider="parseSuccess")
    public void factory_parse_minus(String text, Period expected) {
        Period p = null;
        try {
            p = Period.parse("-" + text);
        } catch (DateTimeParseException ex) {
            assertEquals(expected.getYears() == Integer.MIN_VALUE ||
                    expected.getMonths() == Integer.MIN_VALUE ||
                    expected.getDays() == Integer.MIN_VALUE, true);
            return;
        }
        // not inside try/catch or it breaks test
        assertEquals(p, expected.negated());
    }

    @Test(dataProvider="parseSuccess")
    public void factory_parse_lowerCase(String text, Period expected) {
        Period p = Period.parse(text.toLowerCase(Locale.ENGLISH));
        assertEquals(p, expected);
    }

    @DataProvider(name="parseFailure")
    Object[][] data_parseFailure() {
        return new Object[][] {
                {""},
                {"PTD"},
                {"AT0D"},
                {"PA0D"},
                {"PT0A"},

                {"PT+D"},
                {"PT-D"},
                {"PT.D"},
                {"PTAD"},

                {"PT+0D"},
                {"PT-0D"},
                {"PT+1D"},
                {"PT-.D"},

                {"P1Y1MT1D"},
                {"P1YMD"},
                {"P1Y2Y"},
                {"PT1M+3S"},

                {"P1M2Y"},
                {"P1W2Y"},
                {"P1D2Y"},
                {"P1W2M"},
                {"P1D2M"},
                {"P1D2W"},

                {"PT1S1"},
                {"PT1S."},
                {"PT1SA"},
                {"PT1M1"},
                {"PT1M."},
                {"PT1MA"},

                {"P"+ (((long) Integer.MAX_VALUE) + 1) + "Y"},
                {"P"+ (((long) Integer.MAX_VALUE) + 1) + "M"},
                {"P"+ (((long) Integer.MAX_VALUE) + 1) + "D"},
                {"P"+ (((long) Integer.MIN_VALUE) - 1) + "Y"},
                {"P"+ (((long) Integer.MIN_VALUE) - 1) + "M"},
                {"P"+ (((long) Integer.MIN_VALUE) - 1) + "D"},

                {"Rubbish"},
        };
    }

    @Test(dataProvider="parseFailure", expectedExceptions=DateTimeParseException.class)
    public void factory_parseFailures(String text) {
        try {
            Period.parse(text);
        } catch (DateTimeParseException ex) {
            assertEquals(ex.getParsedString(), text);
            throw ex;
        }
    }

    @Test(expectedExceptions=NullPointerException.class)
    public void factory_parse_null() {
        Period.parse(null);
    }

    //-----------------------------------------------------------------------
    // between(LocalDate,LocalDate)
    //-----------------------------------------------------------------------
    @DataProvider(name="between")
    Object[][] data_between() {
        return new Object[][] {
                {2010, 1, 1, 2010, 1, 1, 0, 0, 0},
                {2010, 1, 1, 2010, 1, 2, 0, 0, 1},
                {2010, 1, 1, 2010, 1, 31, 0, 0, 30},
                {2010, 1, 1, 2010, 2, 1, 0, 1, 0},
                {2010, 1, 1, 2010, 2, 28, 0, 1, 27},
                {2010, 1, 1, 2010, 3, 1, 0, 2, 0},
                {2010, 1, 1, 2010, 12, 31, 0, 11, 30},
                {2010, 1, 1, 2011, 1, 1, 1, 0, 0},
                {2010, 1, 1, 2011, 12, 31, 1, 11, 30},
                {2010, 1, 1, 2012, 1, 1, 2, 0, 0},

                {2010, 1, 10, 2010, 1, 1, 0, 0, -9},
                {2010, 1, 10, 2010, 1, 2, 0, 0, -8},
                {2010, 1, 10, 2010, 1, 9, 0, 0, -1},
                {2010, 1, 10, 2010, 1, 10, 0, 0, 0},
                {2010, 1, 10, 2010, 1, 11, 0, 0, 1},
                {2010, 1, 10, 2010, 1, 31, 0, 0, 21},
                {2010, 1, 10, 2010, 2, 1, 0, 0, 22},
                {2010, 1, 10, 2010, 2, 9, 0, 0, 30},
                {2010, 1, 10, 2010, 2, 10, 0, 1, 0},
                {2010, 1, 10, 2010, 2, 28, 0, 1, 18},
                {2010, 1, 10, 2010, 3, 1, 0, 1, 19},
                {2010, 1, 10, 2010, 3, 9, 0, 1, 27},
                {2010, 1, 10, 2010, 3, 10, 0, 2, 0},
                {2010, 1, 10, 2010, 12, 31, 0, 11, 21},
                {2010, 1, 10, 2011, 1, 1, 0, 11, 22},
                {2010, 1, 10, 2011, 1, 9, 0, 11, 30},
                {2010, 1, 10, 2011, 1, 10, 1, 0, 0},

                {2010, 3, 30, 2011, 5, 1, 1, 1, 1},
                {2010, 4, 30, 2011, 5, 1, 1, 0, 1},

                {2010, 2, 28, 2012, 2, 27, 1, 11, 30},
                {2010, 2, 28, 2012, 2, 28, 2, 0, 0},
                {2010, 2, 28, 2012, 2, 29, 2, 0, 1},

                {2012, 2, 28, 2014, 2, 27, 1, 11, 30},
                {2012, 2, 28, 2014, 2, 28, 2, 0, 0},
                {2012, 2, 28, 2014, 3, 1, 2, 0, 1},

                {2012, 2, 29, 2014, 2, 28, 1, 11, 30},
                {2012, 2, 29, 2014, 3, 1, 2, 0, 1},
                {2012, 2, 29, 2014, 3, 2, 2, 0, 2},

                {2012, 2, 29, 2016, 2, 28, 3, 11, 30},
                {2012, 2, 29, 2016, 2, 29, 4, 0, 0},
                {2012, 2, 29, 2016, 3, 1, 4, 0, 1},

                {2010, 1, 1, 2009, 12, 31, 0, 0, -1},
                {2010, 1, 1, 2009, 12, 30, 0, 0, -2},
                {2010, 1, 1, 2009, 12, 2, 0, 0, -30},
                {2010, 1, 1, 2009, 12, 1, 0, -1, 0},
                {2010, 1, 1, 2009, 11, 30, 0, -1, -1},
                {2010, 1, 1, 2009, 11, 2, 0, -1, -29},
                {2010, 1, 1, 2009, 11, 1, 0, -2, 0},
                {2010, 1, 1, 2009, 1, 2, 0, -11, -30},
                {2010, 1, 1, 2009, 1, 1, -1, 0, 0},

                {2010, 1, 15, 2010, 1, 15, 0, 0, 0},
                {2010, 1, 15, 2010, 1, 14, 0, 0, -1},
                {2010, 1, 15, 2010, 1, 1, 0, 0, -14},
                {2010, 1, 15, 2009, 12, 31, 0, 0, -15},
                {2010, 1, 15, 2009, 12, 16, 0, 0, -30},
                {2010, 1, 15, 2009, 12, 15, 0, -1, 0},
                {2010, 1, 15, 2009, 12, 14, 0, -1, -1},

                {2010, 2, 28, 2009, 3, 1, 0, -11, -27},
                {2010, 2, 28, 2009, 2, 28, -1, 0, 0},
                {2010, 2, 28, 2009, 2, 27, -1, 0, -1},

                {2010, 2, 28, 2008, 2, 29, -1, -11, -28},
                {2010, 2, 28, 2008, 2, 28, -2, 0, 0},
                {2010, 2, 28, 2008, 2, 27, -2, 0, -1},

                {2012, 2, 29, 2009, 3, 1, -2, -11, -28},
                {2012, 2, 29, 2009, 2, 28, -3, 0, -1},
                {2012, 2, 29, 2009, 2, 27, -3, 0, -2},

                {2012, 2, 29, 2008, 3, 1, -3, -11, -28},
                {2012, 2, 29, 2008, 2, 29, -4, 0, 0},
                {2012, 2, 29, 2008, 2, 28, -4, 0, -1},
        };
    }

    @Test(dataProvider="between")
    public void factory_between_LocalDate(int y1, int m1, int d1, int y2, int m2, int d2, int ye, int me, int de) {
        LocalDate start = LocalDate.of(y1, m1, d1);
        LocalDate end = LocalDate.of(y2, m2, d2);
        Period test = Period.between(start, end);
        assertPeriod(test, ye, me, de);
        //assertEquals(start.plus(test), end);
    }

    @Test(expectedExceptions=NullPointerException.class)
    public void factory_between_LocalDate_nullFirst() {
        Period.between((LocalDate) null, LocalDate.of(2010, 1, 1));
    }

    @Test(expectedExceptions=NullPointerException.class)
    public void factory_between_LocalDate_nullSecond() {
        Period.between(LocalDate.of(2010, 1, 1), (LocalDate) null);
    }

    //-----------------------------------------------------------------------
    // isZero()
    //-----------------------------------------------------------------------
    @Test
    public void test_isZero() {
        assertEquals(Period.of(0, 0, 0).isZero(), true);
        assertEquals(Period.of(1, 2, 3).isZero(), false);
        assertEquals(Period.of(1, 0, 0).isZero(), false);
        assertEquals(Period.of(0, 2, 0).isZero(), false);
        assertEquals(Period.of(0, 0, 3).isZero(), false);
    }

    //-----------------------------------------------------------------------
    // isNegative()
    //-----------------------------------------------------------------------
    @Test
    public void test_isPositive() {
        assertEquals(Period.of(0, 0, 0).isNegative(), false);
        assertEquals(Period.of(1, 2, 3).isNegative(), false);
        assertEquals(Period.of(1, 0, 0).isNegative(), false);
        assertEquals(Period.of(0, 2, 0).isNegative(), false);
        assertEquals(Period.of(0, 0, 3).isNegative(), false);

        assertEquals(Period.of(-1, -2, -3).isNegative(), true);
        assertEquals(Period.of(-1, -2, 3).isNegative(), true);
        assertEquals(Period.of(1, -2, -3).isNegative(), true);
        assertEquals(Period.of(-1, 2, -3).isNegative(), true);
        assertEquals(Period.of(-1, 2, 3).isNegative(), true);
        assertEquals(Period.of(1, -2, 3).isNegative(), true);
        assertEquals(Period.of(1, 2, -3).isNegative(), true);
    }

    //-----------------------------------------------------------------------
    // withYears()
    //-----------------------------------------------------------------------
    @Test
    public void test_withYears() {
        assertPeriod(Period.of(1, 2, 3).withYears(1), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).withYears(10), 10, 2, 3);
        assertPeriod(Period.of(1, 2, 3).withYears(-10), -10, 2, 3);
        assertPeriod(Period.of(-1, -2, -3).withYears(10), 10, -2, -3);
        assertPeriod(Period.of(1, 2, 3).withYears(0), 0, 2, 3);
    }

    //-----------------------------------------------------------------------
    // withMonths()
    //-----------------------------------------------------------------------
    @Test
    public void test_withMonths() {
        assertPeriod(Period.of(1, 2, 3).withMonths(2), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).withMonths(10), 1, 10, 3);
        assertPeriod(Period.of(1, 2, 3).withMonths(-10), 1, -10, 3);
        assertPeriod(Period.of(-1, -2, -3).withMonths(10), -1, 10, -3);
        assertPeriod(Period.of(1, 2, 3).withMonths(0), 1, 0, 3);
    }

    //-----------------------------------------------------------------------
    // withDays()
    //-----------------------------------------------------------------------
    @Test
    public void test_withDays() {
        assertPeriod(Period.of(1, 2, 3).withDays(3), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).withDays(10), 1, 2, 10);
        assertPeriod(Period.of(1, 2, 3).withDays(-10), 1, 2, -10);
        assertPeriod(Period.of(-1, -2, -3).withDays(10), -1, -2, 10);
        assertPeriod(Period.of(1, 2, 3).withDays(0), 1, 2, 0);
    }

    //-----------------------------------------------------------------------
    // plus(Period)
    //-----------------------------------------------------------------------
    @DataProvider(name="plus")
    Object[][] data_plus() {
        return new Object[][] {
                {pymd(0, 0, 0), pymd(0, 0, 0), pymd(0, 0, 0)},
                {pymd(0, 0, 0), pymd(5, 0, 0), pymd(5, 0, 0)},
                {pymd(0, 0, 0), pymd(-5, 0, 0), pymd(-5, 0, 0)},
                {pymd(0, 0, 0), pymd(0, 5, 0), pymd(0, 5, 0)},
                {pymd(0, 0, 0), pymd(0, -5, 0), pymd(0, -5, 0)},
                {pymd(0, 0, 0), pymd(0, 0, 5), pymd(0, 0, 5)},
                {pymd(0, 0, 0), pymd(0, 0, -5), pymd(0, 0, -5)},
                {pymd(0, 0, 0), pymd(2, 3, 4), pymd(2, 3, 4)},
                {pymd(0, 0, 0), pymd(-2, -3, -4), pymd(-2, -3, -4)},

                {pymd(4, 5, 6), pymd(2, 3, 4), pymd(6, 8, 10)},
                {pymd(4, 5, 6), pymd(-2, -3, -4), pymd(2, 2, 2)},
        };
    }

    @Test(dataProvider="plus")
    public void test_plus_TemporalAmount(Period base, Period add, Period expected) {
        assertEquals(base.plus(add), expected);
    }

    @Test(expectedExceptions = DateTimeException.class)
    public void test_plus_TemporalAmount_nonISO() {
        pymd(4, 5, 6).plus(ThaiBuddhistChronology.INSTANCE.period(1, 0, 0));
    }

    @Test(expectedExceptions = DateTimeException.class)
    public void test_plus_TemporalAmount_DaysHours() {
        TemporalAmount amount = new TemporalAmount() {
            @Override
            public long get(TemporalUnit unit) {
                if (unit == DAYS) {
                    return 1;
                } else {
                    return 2;
                }
            }
            @Override
            public List<TemporalUnit> getUnits() {
                List<TemporalUnit> list = new ArrayList<>();
                list.add(DAYS);
                list.add(HOURS);
                return list;
            }
            @Override
            public Temporal addTo(Temporal temporal) {
                throw new UnsupportedOperationException();
            }
            @Override
            public Temporal subtractFrom(Temporal temporal) {
                throw new UnsupportedOperationException();
            }
        };
        pymd(4, 5, 6).plus(amount);
    }

    //-----------------------------------------------------------------------
    // plusYears()
    //-----------------------------------------------------------------------
    @Test
    public void test_plusYears() {
        assertPeriod(Period.of(1, 2, 3).plusYears(0), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).plusYears(10), 11, 2, 3);
        assertPeriod(Period.of(1, 2, 3).plusYears(-10), -9, 2, 3);
        assertPeriod(Period.of(1, 2, 3).plusYears(-1), 0, 2, 3);

        assertPeriod(Period.of(1, 2, 3).plus(Period.ofYears(0)), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).plus(Period.ofYears(10)), 11, 2, 3);
        assertPeriod(Period.of(1, 2, 3).plus(Period.ofYears(-10)), -9, 2, 3);
        assertPeriod(Period.of(1, 2, 3).plus(Period.ofYears(-1)), 0, 2, 3);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_plusYears_overflowTooBig() {
        Period test = Period.ofYears(Integer.MAX_VALUE);
        test.plusYears(1);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_plusYears_overflowTooSmall() {
        Period test = Period.ofYears(Integer.MIN_VALUE);
        test.plusYears(-1);
    }

    //-----------------------------------------------------------------------
    // plusMonths()
    //-----------------------------------------------------------------------
    @Test
    public void test_plusMonths() {
        assertPeriod(Period.of(1, 2, 3).plusMonths(0), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).plusMonths(10), 1, 12, 3);
        assertPeriod(Period.of(1, 2, 3).plusMonths(-10), 1, -8, 3);
        assertPeriod(Period.of(1, 2, 3).plusMonths(-2), 1, 0, 3);

        assertPeriod(Period.of(1, 2, 3).plus(Period.ofMonths(0)), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).plus(Period.ofMonths(10)), 1, 12, 3);
        assertPeriod(Period.of(1, 2, 3).plus(Period.ofMonths(-10)), 1, -8, 3);
        assertPeriod(Period.of(1, 2, 3).plus(Period.ofMonths(-2)), 1, 0, 3);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_plusMonths_overflowTooBig() {
        Period test = Period.ofMonths(Integer.MAX_VALUE);
        test.plusMonths(1);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_plusMonths_overflowTooSmall() {
        Period test = Period.ofMonths(Integer.MIN_VALUE);
        test.plusMonths(-1);
    }

    //-----------------------------------------------------------------------
    // plusDays()
    //-----------------------------------------------------------------------
    @Test
    public void test_plusDays() {
        assertPeriod(Period.of(1, 2, 3).plusDays(0), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).plusDays(10), 1, 2, 13);
        assertPeriod(Period.of(1, 2, 3).plusDays(-10), 1, 2, -7);
        assertPeriod(Period.of(1, 2, 3).plusDays(-3), 1, 2, 0);

        assertPeriod(Period.of(1, 2, 3).plus(Period.ofDays(0)), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).plus(Period.ofDays(10)), 1, 2, 13);
        assertPeriod(Period.of(1, 2, 3).plus(Period.ofDays(-10)), 1, 2, -7);
        assertPeriod(Period.of(1, 2, 3).plus(Period.ofDays(-3)), 1, 2, 0);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_plusDays_overflowTooBig() {
        Period test = Period.ofDays(Integer.MAX_VALUE);
        test.plusDays(1);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_plusDays_overflowTooSmall() {
        Period test = Period.ofDays(Integer.MIN_VALUE);
        test.plusDays(-1);
    }

    //-----------------------------------------------------------------------
    // minus(Period)
    //-----------------------------------------------------------------------
    @DataProvider(name="minus")
    Object[][] data_minus() {
        return new Object[][] {
                {pymd(0, 0, 0), pymd(0, 0, 0), pymd(0, 0, 0)},
                {pymd(0, 0, 0), pymd(5, 0, 0), pymd(-5, 0, 0)},
                {pymd(0, 0, 0), pymd(-5, 0, 0), pymd(5, 0, 0)},
                {pymd(0, 0, 0), pymd(0, 5, 0), pymd(0, -5, 0)},
                {pymd(0, 0, 0), pymd(0, -5, 0), pymd(0, 5, 0)},
                {pymd(0, 0, 0), pymd(0, 0, 5), pymd(0, 0, -5)},
                {pymd(0, 0, 0), pymd(0, 0, -5), pymd(0, 0, 5)},
                {pymd(0, 0, 0), pymd(2, 3, 4), pymd(-2, -3, -4)},
                {pymd(0, 0, 0), pymd(-2, -3, -4), pymd(2, 3, 4)},

                {pymd(4, 5, 6), pymd(2, 3, 4), pymd(2, 2, 2)},
                {pymd(4, 5, 6), pymd(-2, -3, -4), pymd(6, 8, 10)},
        };
    }

    @Test(dataProvider="minus")
    public void test_minus_TemporalAmount(Period base, Period subtract, Period expected) {
        assertEquals(base.minus(subtract), expected);
    }

    @Test(expectedExceptions = DateTimeException.class)
    public void test_minus_TemporalAmount_nonISO() {
        pymd(4, 5, 6).minus(ThaiBuddhistChronology.INSTANCE.period(1, 0, 0));
    }

    @Test(expectedExceptions = DateTimeException.class)
    public void test_minus_TemporalAmount_DaysHours() {
        TemporalAmount amount = new TemporalAmount() {
            @Override
            public long get(TemporalUnit unit) {
                if (unit == DAYS) {
                    return 1;
                } else {
                    return 2;
                }
            }
            @Override
            public List<TemporalUnit> getUnits() {
                List<TemporalUnit> list = new ArrayList<>();
                list.add(DAYS);
                list.add(HOURS);
                return list;
            }
            @Override
            public Temporal addTo(Temporal temporal) {
                throw new UnsupportedOperationException();
            }
            @Override
            public Temporal subtractFrom(Temporal temporal) {
                throw new UnsupportedOperationException();
            }
        };
        pymd(4, 5, 6).minus(amount);
    }

    //-----------------------------------------------------------------------
    // minusYears()
    //-----------------------------------------------------------------------
    @Test
    public void test_minusYears() {
        assertPeriod(Period.of(1, 2, 3).minusYears(0), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).minusYears(10), -9, 2, 3);
        assertPeriod(Period.of(1, 2, 3).minusYears(-10), 11, 2, 3);
        assertPeriod(Period.of(1, 2, 3).minusYears(-1), 2, 2, 3);

        assertPeriod(Period.of(1, 2, 3).minus(Period.ofYears(0)), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).minus(Period.ofYears(10)), -9, 2, 3);
        assertPeriod(Period.of(1, 2, 3).minus(Period.ofYears(-10)), 11, 2, 3);
        assertPeriod(Period.of(1, 2, 3).minus(Period.ofYears(-1)), 2, 2, 3);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_minusYears_overflowTooBig() {
        Period test = Period.ofYears(Integer.MAX_VALUE);
        test.minusYears(-1);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_minusYears_overflowTooSmall() {
        Period test = Period.ofYears(Integer.MIN_VALUE);
        test.minusYears(1);
    }

    //-----------------------------------------------------------------------
    // minusMonths()
    //-----------------------------------------------------------------------
    @Test
    public void test_minusMonths() {
        assertPeriod(Period.of(1, 2, 3).minusMonths(0), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).minusMonths(10), 1, -8, 3);
        assertPeriod(Period.of(1, 2, 3).minusMonths(-10), 1, 12, 3);
        assertPeriod(Period.of(1, 2, 3).minusMonths(-2), 1, 4, 3);

        assertPeriod(Period.of(1, 2, 3).minus(Period.ofMonths(0)), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).minus(Period.ofMonths(10)), 1, -8, 3);
        assertPeriod(Period.of(1, 2, 3).minus(Period.ofMonths(-10)), 1, 12, 3);
        assertPeriod(Period.of(1, 2, 3).minus(Period.ofMonths(-2)), 1, 4, 3);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_minusMonths_overflowTooBig() {
        Period test = Period.ofMonths(Integer.MAX_VALUE);
        test.minusMonths(-1);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_minusMonths_overflowTooSmall() {
        Period test = Period.ofMonths(Integer.MIN_VALUE);
        test.minusMonths(1);
    }

    //-----------------------------------------------------------------------
    // minusDays()
    //-----------------------------------------------------------------------
    @Test
    public void test_minusDays() {
        assertPeriod(Period.of(1, 2, 3).minusDays(0), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).minusDays(10), 1, 2, -7);
        assertPeriod(Period.of(1, 2, 3).minusDays(-10), 1, 2, 13);
        assertPeriod(Period.of(1, 2, 3).minusDays(-3), 1, 2, 6);

        assertPeriod(Period.of(1, 2, 3).minus(Period.ofDays(0)), 1, 2, 3);
        assertPeriod(Period.of(1, 2, 3).minus(Period.ofDays(10)), 1, 2, -7);
        assertPeriod(Period.of(1, 2, 3).minus(Period.ofDays(-10)), 1, 2, 13);
        assertPeriod(Period.of(1, 2, 3).minus(Period.ofDays(-3)), 1, 2, 6);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_minusDays_overflowTooBig() {
        Period test = Period.ofDays(Integer.MAX_VALUE);
        test.minusDays(-1);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_minusDays_overflowTooSmall() {
        Period test = Period.ofDays(Integer.MIN_VALUE);
        test.minusDays(1);
    }

    //-----------------------------------------------------------------------
    // multipliedBy()
    //-----------------------------------------------------------------------
    @Test
    public void test_multipliedBy() {
        Period test = Period.of(1, 2, 3);
        assertPeriod(test.multipliedBy(0), 0, 0, 0);
        assertPeriod(test.multipliedBy(1), 1, 2, 3);
        assertPeriod(test.multipliedBy(2), 2, 4, 6);
        assertPeriod(test.multipliedBy(-3), -3, -6, -9);
    }

    @Test
    public void test_multipliedBy_zeroBase() {
        assertPeriod(Period.ZERO.multipliedBy(2), 0, 0, 0);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_multipliedBy_overflowTooBig() {
        Period test = Period.ofYears(Integer.MAX_VALUE / 2 + 1);
        test.multipliedBy(2);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_multipliedBy_overflowTooSmall() {
        Period test = Period.ofYears(Integer.MIN_VALUE / 2 - 1);
        test.multipliedBy(2);
    }

    //-----------------------------------------------------------------------
    // negated()
    //-----------------------------------------------------------------------
    @Test
    public void test_negated() {
        assertPeriod(Period.of(0, 0, 0).negated(), 0 ,0, 0);
        assertPeriod(Period.of(1, 2, 3).negated(), -1, -2, -3);
        assertPeriod(Period.of(-1, -2, -3).negated(), 1, 2, 3);
        assertPeriod(Period.of(-1, 2, -3).negated(), 1, -2, 3);
        assertPeriod(Period.of(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE).negated(),
                -Integer.MAX_VALUE, -Integer.MAX_VALUE, -Integer.MAX_VALUE);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_negated_overflow_years() {
        Period.ofYears(Integer.MIN_VALUE).negated();
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_negated_overflow_months() {
        Period.ofMonths(Integer.MIN_VALUE).negated();
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_negated_overflow_days() {
        Period.ofDays(Integer.MIN_VALUE).negated();
    }

    //-----------------------------------------------------------------------
    // normalized()
    //-----------------------------------------------------------------------
    @DataProvider(name="normalized")
    Object[][] data_normalized() {
        return new Object[][] {
                {0, 0,  0, 0},
                {1, 0,  1, 0},
                {-1, 0,  -1, 0},

                {1, 1,  1, 1},
                {1, 2,  1, 2},
                {1, 11,  1, 11},
                {1, 12,  2, 0},
                {1, 13,  2, 1},
                {1, 23,  2, 11},
                {1, 24,  3, 0},
                {1, 25,  3, 1},

                {1, -1,  0, 11},
                {1, -2,  0, 10},
                {1, -11,  0, 1},
                {1, -12,  0, 0},
                {1, -13,  0, -1},
                {1, -23,  0, -11},
                {1, -24,  -1, 0},
                {1, -25,  -1, -1},
                {1, -35,  -1, -11},
                {1, -36,  -2, 0},
                {1, -37,  -2, -1},

                {-1, 1,  0, -11},
                {-1, 11,  0, -1},
                {-1, 12,  0, 0},
                {-1, 13,  0, 1},
                {-1, 23,  0, 11},
                {-1, 24,  1, 0},
                {-1, 25,  1, 1},

                {-1, -1,  -1, -1},
                {-1, -11,  -1, -11},
                {-1, -12,  -2, 0},
                {-1, -13,  -2, -1},
        };
    }

    @Test(dataProvider="normalized")
    public void test_normalized(int inputYears, int inputMonths, int expectedYears, int expectedMonths) {
        assertPeriod(Period.of(inputYears, inputMonths, 0).normalized(), expectedYears, expectedMonths, 0);
    }

    @Test(dataProvider="normalized")
    public void test_normalized_daysUnaffected(int inputYears, int inputMonths, int expectedYears, int expectedMonths) {
        assertPeriod(Period.of(inputYears, inputMonths, 5).normalized(), expectedYears, expectedMonths, 5);
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_normalized_min() {
        Period base = Period.of(Integer.MIN_VALUE, -12, 0);
        base.normalized();
    }

    @Test(expectedExceptions=ArithmeticException.class)
    public void test_normalized_max() {
        Period base = Period.of(Integer.MAX_VALUE, 12, 0);
        base.normalized();
    }

    //-----------------------------------------------------------------------
    // addTo()
    //-----------------------------------------------------------------------
    @DataProvider(name="addTo")
    Object[][] data_addTo() {
        return new Object[][] {
                {pymd(0, 0, 0),  date(2012, 6, 30), date(2012, 6, 30)},

                {pymd(1, 0, 0),  date(2012, 6, 10), date(2013, 6, 10)},
                {pymd(0, 1, 0),  date(2012, 6, 10), date(2012, 7, 10)},
                {pymd(0, 0, 1),  date(2012, 6, 10), date(2012, 6, 11)},

                {pymd(-1, 0, 0),  date(2012, 6, 10), date(2011, 6, 10)},
                {pymd(0, -1, 0),  date(2012, 6, 10), date(2012, 5, 10)},
                {pymd(0, 0, -1),  date(2012, 6, 10), date(2012, 6, 9)},

                {pymd(1, 2, 3),  date(2012, 6, 27), date(2013, 8, 30)},
                {pymd(1, 2, 3),  date(2012, 6, 28), date(2013, 8, 31)},
                {pymd(1, 2, 3),  date(2012, 6, 29), date(2013, 9, 1)},
                {pymd(1, 2, 3),  date(2012, 6, 30), date(2013, 9, 2)},
                {pymd(1, 2, 3),  date(2012, 7, 1), date(2013, 9, 4)},

                {pymd(1, 0, 0),  date(2011, 2, 28), date(2012, 2, 28)},
                {pymd(4, 0, 0),  date(2011, 2, 28), date(2015, 2, 28)},
                {pymd(1, 0, 0),  date(2012, 2, 29), date(2013, 2, 28)},
                {pymd(4, 0, 0),  date(2012, 2, 29), date(2016, 2, 29)},

                {pymd(1, 1, 0),  date(2011, 1, 29), date(2012, 2, 29)},
                {pymd(1, 2, 0),  date(2012, 2, 29), date(2013, 4, 29)},
        };
    }

    @Test(dataProvider="addTo")
    public void test_addTo(Period period, LocalDate baseDate, LocalDate expected) {
        assertEquals(period.addTo(baseDate), expected);
    }

    @Test(dataProvider="addTo")
    public void test_addTo_usingLocalDatePlus(Period period, LocalDate baseDate, LocalDate expected) {
        assertEquals(baseDate.plus(period), expected);
    }

    @Test(expectedExceptions=NullPointerException.class)
    public void test_addTo_nullZero() {
        Period.ZERO.addTo(null);
    }

    @Test(expectedExceptions=NullPointerException.class)
    public void test_addTo_nullNonZero() {
        Period.ofDays(2).addTo(null);
    }

    //-----------------------------------------------------------------------
    // subtractFrom()
    //-----------------------------------------------------------------------
    @DataProvider(name="subtractFrom")
    Object[][] data_subtractFrom() {
        return new Object[][] {
                {pymd(0, 0, 0), date(2012, 6, 30), date(2012, 6, 30)},

                {pymd(1, 0, 0), date(2012, 6, 10), date(2011, 6, 10)},
                {pymd(0, 1, 0), date(2012, 6, 10), date(2012, 5, 10)},
                {pymd(0, 0, 1), date(2012, 6, 10), date(2012, 6, 9)},

                {pymd(-1, 0, 0), date(2012, 6, 10), date(2013, 6, 10)},
                {pymd(0, -1, 0), date(2012, 6, 10), date(2012, 7, 10)},
                {pymd(0, 0, -1), date(2012, 6, 10), date(2012, 6, 11)},

                {pymd(1, 2, 3), date(2012, 8, 30), date(2011, 6, 27)},
                {pymd(1, 2, 3), date(2012, 8, 31), date(2011, 6, 27)},
                {pymd(1, 2, 3), date(2012, 9, 1), date(2011, 6, 28)},
                {pymd(1, 2, 3), date(2012, 9, 2), date(2011, 6, 29)},
                {pymd(1, 2, 3), date(2012, 9, 3), date(2011, 6, 30)},
                {pymd(1, 2, 3), date(2012, 9, 4), date(2011, 7, 1)},

                {pymd(1, 0, 0), date(2011, 2, 28), date(2010, 2, 28)},
                {pymd(4, 0, 0), date(2011, 2, 28), date(2007, 2, 28)},
                {pymd(1, 0, 0), date(2012, 2, 29), date(2011, 2, 28)},
                {pymd(4, 0, 0), date(2012, 2, 29), date(2008, 2, 29)},

                {pymd(1, 1, 0), date(2013, 3, 29), date(2012, 2, 29)},
                {pymd(1, 2, 0), date(2012, 2, 29), date(2010, 12, 29)},
        };
    }

    @Test(dataProvider="subtractFrom")
    public void test_subtractFrom(Period period, LocalDate baseDate, LocalDate expected) {
        assertEquals(period.subtractFrom(baseDate), expected);
    }

    @Test(dataProvider="subtractFrom")
    public void test_subtractFrom_usingLocalDateMinus(Period period, LocalDate baseDate, LocalDate expected) {
        assertEquals(baseDate.minus(period), expected);
    }

    @Test(expectedExceptions=NullPointerException.class)
    public void test_subtractFrom_nullZero() {
        Period.ZERO.subtractFrom(null);
    }

    @Test(expectedExceptions=NullPointerException.class)
    public void test_subtractFrom_nullNonZero() {
        Period.ofDays(2).subtractFrom(null);
    }

    //-----------------------------------------------------------------------
    // get units
    //-----------------------------------------------------------------------
    @Test
    public void test_Period_getUnits() {
        Period period = Period.of(2012, 1, 1);
        List<TemporalUnit> units = period.getUnits();
        assertEquals(units.size(), 3, "Period.getUnits should return 3 units");
        assertEquals(units.get(0), ChronoUnit.YEARS, "Period.getUnits contains ChronoUnit.YEARS");
        assertEquals(units.get(1), ChronoUnit.MONTHS, "Period.getUnits contains ChronoUnit.MONTHS");
        assertEquals(units.get(2), ChronoUnit.DAYS, "Period.getUnits contains ChronoUnit.DAYS");
    }


    @DataProvider(name="GoodTemporalUnit")
    Object[][] data_goodTemporalUnit() {
        return new Object[][] {
            {2, ChronoUnit.DAYS},
            {2, ChronoUnit.MONTHS},
            {2, ChronoUnit.YEARS},
        };
    }

    @Test(dataProvider="GoodTemporalUnit")
    public void test_good_getUnit(long amount, TemporalUnit unit) {
        Period period = Period.of(2, 2, 2);
        long actual = period.get(unit);
        assertEquals(actual, amount, "Value of unit: " + unit);
    }

    @DataProvider(name="BadTemporalUnit")
    Object[][] data_badTemporalUnit() {
        return new Object[][] {
            {ChronoUnit.MICROS},
            {ChronoUnit.MILLIS},
            {ChronoUnit.HALF_DAYS},
            {ChronoUnit.DECADES},
            {ChronoUnit.CENTURIES},
            {ChronoUnit.MILLENNIA},
        };
    }

    @Test(dataProvider="BadTemporalUnit", expectedExceptions=DateTimeException.class)
    public void test_bad_getUnit(TemporalUnit unit) {
        Period period = Period.of(2, 2, 2);
        period.get(unit);
    }

    //-----------------------------------------------------------------------
    // equals() / hashCode()
    //-----------------------------------------------------------------------
    public void test_equals() {
        assertEquals(Period.of(1, 0, 0).equals(Period.ofYears(1)), true);
        assertEquals(Period.of(0, 1, 0).equals(Period.ofMonths(1)), true);
        assertEquals(Period.of(0, 0, 1).equals(Period.ofDays(1)), true);
        assertEquals(Period.of(1, 2, 3).equals(Period.of(1, 2, 3)), true);

        assertEquals(Period.ofYears(1).equals(Period.ofYears(1)), true);
        assertEquals(Period.ofYears(1).equals(Period.ofYears(2)), false);

        assertEquals(Period.ofMonths(1).equals(Period.ofMonths(1)), true);
        assertEquals(Period.ofMonths(1).equals(Period.ofMonths(2)), false);

        assertEquals(Period.ofDays(1).equals(Period.ofDays(1)), true);
        assertEquals(Period.ofDays(1).equals(Period.ofDays(2)), false);

        assertEquals(Period.of(1, 2, 3).equals(Period.of(0, 2, 3)), false);
        assertEquals(Period.of(1, 2, 3).equals(Period.of(1, 0, 3)), false);
        assertEquals(Period.of(1, 2, 3).equals(Period.of(1, 2, 0)), false);
    }

    public void test_equals_self() {
        Period test = Period.of(1, 2, 3);
        assertEquals(test.equals(test), true);
    }

    public void test_equals_null() {
        Period test = Period.of(1, 2, 3);
        assertEquals(test.equals(null), false);
    }

    public void test_equals_otherClass() {
        Period test = Period.of(1, 2, 3);
        assertEquals(test.equals(""), false);
    }

    //-----------------------------------------------------------------------
    public void test_hashCode() {
        Period test5 = Period.ofDays(5);
        Period test6 = Period.ofDays(6);
        Period test5M = Period.ofMonths(5);
        Period test5Y = Period.ofYears(5);
        assertEquals(test5.hashCode() == test5.hashCode(), true);
        assertEquals(test5.hashCode() == test6.hashCode(), false);
    }

    //-----------------------------------------------------------------------
    // toString()
    //-----------------------------------------------------------------------
    @DataProvider(name="toStringAndParse")
    Object[][] data_toString() {
        return new Object[][] {
                {Period.ZERO, "P0D"},
                {Period.ofDays(0), "P0D"},
                {Period.ofYears(1), "P1Y"},
                {Period.ofMonths(1), "P1M"},
                {Period.ofDays(1), "P1D"},
                {Period.of(1, 2, 0), "P1Y2M"},
                {Period.of(0, 2, 3), "P2M3D"},
                {Period.of(1, 2, 3), "P1Y2M3D"},
        };
    }

    @Test(dataProvider="toStringAndParse")
    public void test_toString(Period input, String expected) {
        assertEquals(input.toString(), expected);
    }

    @Test(dataProvider="toStringAndParse")
    public void test_parse(Period test, String expected) {
        assertEquals(Period.parse(expected), test);
    }

    //-----------------------------------------------------------------------
    private void assertPeriod(Period test, int y, int m, int d) {
        assertEquals(test.getYears(), y, "years");
        assertEquals(test.getMonths(), m, "months");
        assertEquals(test.getDays(), d, "days");
        assertEquals(test.toTotalMonths(), y * 12L + m, "totalMonths");
    }

    private static Period pymd(int y, int m, int d) {
        return Period.of(y, m, d);
    }

    private static LocalDate date(int y, int m, int d) {
        return LocalDate.of(y, m, d);
    }

}