| /* |
| * 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); |
| } |
| |
| } |
