public function equals($obj)
{
if ($obj instanceof OffsetClock) {
return $this->baseClock->equals($obj->baseClock) && $this->offset->equals($obj->offset);
}
return false;
}
/**
* Unit that represents the concept of a quarter-year.
* @return IsoUnit
*/
public static function QUARTER_YEARS()
{
if (self::$QUARTER_YEARS === null) {
self::$QUARTER_YEARS = new IsoUnit("QuarterYears", Duration::ofSeconds(31556952 / 4));
}
return self::$QUARTER_YEARS;
}
public function __toString()
{
return "TickClock[" . $this->baseClock . "," . Duration::ofNanos($this->tickNanos) . "]";
}
function data_minus_TemporalAmount()
{
return [[YearMonth::of(1, 1), Period::ofYears(1), YearMonth::of(0, 1), null], [YearMonth::of(1, 1), Period::ofYears(-12), YearMonth::of(13, 1), null], [YearMonth::of(1, 1), Period::ofYears(0), YearMonth::of(1, 1), null], [YearMonth::of(999999999, 12), Period::ofYears(0), YearMonth::of(999999999, 12), null], [YearMonth::of(-999999999, 1), Period::ofYears(0), YearMonth::of(-999999999, 1), null], [YearMonth::of(0, 1), Period::ofYears(999999999), YearMonth::of(-999999999, 1), null], [YearMonth::of(0, 12), Period::ofYears(-999999999), YearMonth::of(999999999, 12), null], [YearMonth::of(1, 1), Period::ofMonths(1), YearMonth::of(0, 12), null], [YearMonth::of(1, 1), Period::ofMonths(-12), YearMonth::of(2, 1), null], [YearMonth::of(1, 1), Period::ofMonths(121), YearMonth::of(-10, 12), null], [YearMonth::of(1, 1), Period::ofMonths(0), YearMonth::of(1, 1), null], [YearMonth::of(999999999, 12), Period::ofMonths(0), YearMonth::of(999999999, 12), null], [YearMonth::of(-999999999, 1), Period::ofMonths(0), YearMonth::of(-999999999, 1), null], [YearMonth::of(-999999999, 2), Period::ofMonths(1), YearMonth::of(-999999999, 1), null], [YearMonth::of(999999999, 11), Period::ofMonths(-1), YearMonth::of(999999999, 12), null], [YearMonth::of(1, 1), Period::ofYears(1)->withMonths(2), YearMonth::of(-1, 11), null], [YearMonth::of(1, 1), Period::ofYears(-12)->withMonths(-1), YearMonth::of(13, 2), null], [YearMonth::of(1, 1), Period::ofMonths(2)->withYears(1), YearMonth::of(-1, 11), null], [YearMonth::of(1, 1), Period::ofMonths(-1)->withYears(-12), YearMonth::of(13, 2), null], [YearMonth::of(1, 1), Period::ofDays(365), null, DateTimeException::class], [YearMonth::of(1, 1), Duration::ofDays(365), null, DateTimeException::class], [YearMonth::of(1, 1), Duration::ofHours(365 * 24), null, DateTimeException::class], [YearMonth::of(1, 1), Duration::ofMinutes(365 * 24 * 60), null, DateTimeException::class], [YearMonth::of(1, 1), Duration::ofSeconds(365 * 24 * 3600), null, DateTimeException::class], [YearMonth::of(1, 1), Duration::ofNanos(365 * 24 * 3600 * 1000000000), null, DateTimeException::class]];
}
/**
* Returns a copy of this duration with the specified duration subtracted.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param duration Duration the duration to subtract, positive or negative, not null
* @return Duration a {@code Duration} based on this duration with the specified duration subtracted, not null
* @throws ArithmeticException if numeric overflow occurs
*/
public function minusAmount(Duration $duration)
{
$secsToSubtract = $duration->getSeconds();
$nanosToSubtract = $duration->getNano();
if ($secsToSubtract == Long::MIN_VALUE) {
return $this->_plus(Long::MAX_VALUE, -$nanosToSubtract)->_plus(1, 0);
}
return $this->_plus(-$secsToSubtract, -$nanosToSubtract);
}
/**
* @expectedException \Celest\DateTimeException
* @dataProvider provider_factory_of_badTemporalUnit
*/
public function test_bad_getUnit($amount, TemporalUnit $unit)
{
$t = Duration::of($amount, $unit);
$t->get($unit);
}
/**
* @expectedException \Celest\DateTimeException
*/
public function test_minus_Duration_overflowTooBig()
{
$i = Instant::ofEpochSecond(self::MAX_SECOND(), 999999999);
$i->minusAmount(Duration::ofSeconds(-1, 999999999));
}
public function test_getRules()
{
$offset = ZoneOffset::ofHoursMinutesSeconds(1, 2, 3);
$this->assertEquals($offset->getRules()->isFixedOffset(), true);
$this->assertEquals($offset->getRules()->getOffset(null), $offset);
$this->assertEquals($offset->getRules()->getDaylightSavings(null), Duration::ZERO());
$this->assertEquals($offset->getRules()->getStandardOffset(null), $offset);
$this->assertEquals($offset->getRules()->nextTransition(null), null);
$this->assertEquals($offset->getRules()->previousTransition(null), null);
$this->assertEquals($offset->getRules()->isValidOffset(null, $offset), true);
$this->assertEquals($offset->getRules()->isValidOffset(null, ZoneOffset::UTC()), false);
$this->assertEquals($offset->getRules()->isValidOffset(null, null), false);
$this->assertEquals($offset->getRules()->getOffset(null), $offset);
$this->assertEquals($offset->getRules()->getValidOffsets(null), [$offset]);
$this->assertEquals($offset->getRules()->getTransition(null), null);
$this->assertEquals(count($offset->getRules()->getTransitions()), 0);
$this->assertEquals(count($offset->getRules()->getTransitionRules()), 0);
}
public function test_data_nullInput()
{
$test = $this->make(self::OFFSET_PONE());
$this->assertEquals($test->getOffset(null), self::OFFSET_PONE());
$this->assertEquals($test->getOffsetDateTime(null), self::OFFSET_PONE());
$this->assertEquals(count($test->getValidOffsets(null)), 1);
$this->assertEquals($test->getValidOffsets(null)[0], self::OFFSET_PONE());
$this->assertEquals($test->getTransition(null), null);
$this->assertEquals($test->getStandardOffset(null), self::OFFSET_PONE());
$this->assertEquals($test->getDaylightSavings(null), Duration::ZERO());
$this->assertEquals($test->isDaylightSavings(null), false);
$this->assertEquals($test->nextTransition(null), null);
$this->assertEquals($test->previousTransition(null), null);
}
/**
* Gets the amount of daylight savings in use for the specified instant in this zone.
* <p>
* This provides access to historic information on how the amount of daylight
* savings has changed over time.
* This is the difference between the standard offset and the actual offset.
* Typically the amount is zero during winter and one hour during summer.
* Time-zones are second-based, so the nanosecond part of the duration will be zero.
* <p>
* This default implementation calculates the duration from the
* {@link #getOffset(java.time.Instant) actual} and
* {@link #getStandardOffset(java.time.Instant) standard} offsets.
*
* @param Instant|null $instant the instant to find the daylight savings for, not null, but null
* may be ignored if the rules have a single offset for all instants
* @return Duration the difference between the standard and actual offset, not null
*/
public function getDaylightSavings($instant)
{
if (empty($this->savingsInstantTransitions)) {
return Duration::ZERO();
}
$standardOffset = $this->getStandardOffset($instant);
$actualOffset = $this->getOffset($instant);
return Duration::ofSeconds($actualOffset->getTotalSeconds() - $standardOffset->getTotalSeconds());
}
/**
* @expectedException \Celest\DateTimeException
*/
public function test_factory_from_TemporalAmount_Duration()
{
Period::from(Duration::ZERO());
}
/**
* Gets the duration of the transition.
* <p>
* In most cases, the transition duration is one hour, however this is not always the case.
* The duration will be positive for a gap and negative for an overlap.
* Time-zones are second-based, so the nanosecond part of the duration will be zero.
*
* @return Duration the duration of the transition, positive for gaps, negative for overlaps
*/
public function getDuration()
{
return Duration::ofSeconds($this->getDurationSeconds());
}
function data_minusInvalidUnit()
{
return [[Period::of(0, 1, 0)], [Period::of(0, 0, 1)], [Period::of(0, 1, 1)], [Period::of(1, 1, 1)], [Duration::ofDays(1)], [Duration::ofHours(1)], [Duration::ofMinutes(1)], [Duration::ofSeconds(1)]];
}
public function test_getters_overlap()
{
$before = LocalDateTime::of(2010, 10, 31, 1, 0);
$after = LocalDateTime::of(2010, 10, 31, 0, 0);
$test = ZoneOffsetTransition::of($before, self::OFFSET_0300(), self::OFFSET_0200());
$this->assertEquals($test->isGap(), false);
$this->assertEquals($test->isOverlap(), true);
$this->assertEquals($test->getDateTimeBefore(), $before);
$this->assertEquals($test->getDateTimeAfter(), $after);
$this->assertEquals($test->getInstant(), $before->toInstant(self::OFFSET_0300()));
$this->assertEquals($test->getOffsetBefore(), self::OFFSET_0300());
$this->assertEquals($test->getOffsetAfter(), self::OFFSET_0200());
$this->assertEquals($test->getDuration(), Duration::of(-1, ChronoUnit::HOURS()));
}
public function test_minus_TemporalAmount_Duration_zero()
{
$z = $this->TEST_DATE_TIME->minusAmount(Duration::ZERO());
$this->assertEquals($z, $this->TEST_DATE_TIME);
}
public function test_Apia_jumpForwardOverInternationalDateLine_P12_to_M12()
{
// transition occurred at 1879-07-04T00:00+12:33:04
$test = $this->pacificApia();
$instantBefore = LocalDate::of(1879, 7, 2)->atStartOfDayWithZone(ZoneOffset::UTC())->toInstant();
$trans = $test->nextTransition($instantBefore);
$this->assertEquals($trans->getDateTimeBefore(), LocalDateTime::of(1879, 7, 5, 0, 0));
$this->assertEquals($trans->getDateTimeAfter(), LocalDateTime::of(1879, 7, 4, 0, 0));
$this->assertEquals($trans->isGap(), false);
$this->assertEquals($trans->isOverlap(), true);
$this->assertEquals($trans->isValidOffset(ZoneOffset::ofHoursMinutesSeconds(+12, 33, 4)), true);
$this->assertEquals($trans->isValidOffset(ZoneOffset::ofHoursMinutesSeconds(-11, -26, -56)), true);
$this->assertEquals($trans->getDuration(), Duration::ofHours(-24));
$this->assertEquals($trans->getInstant(), LocalDateTime::of(1879, 7, 4, 0, 0)->toInstant(ZoneOffset::ofHoursMinutesSeconds(-11, -26, -56)));
$zdt = ZonedDateTime::of(1879, 7, 4, 23, 0, 0, 0, ZoneId::of("Pacific/Apia"));
$this->assertEquals($zdt->plusHours(2)->toLocalDateTime(), LocalDateTime::of(1879, 7, 4, 1, 0, 0));
}
public function getDuration()
{
return Duration::ofMinutes(90);
}
public function test__equals()
{
$a = Clock::tick(Clock::system(self::PARIS()), Duration::ofMillis(500));
$b = Clock::tick(Clock::system(self::PARIS()), Duration::ofMillis(500));
$this->assertEquals($a->equals($a), true);
$this->assertEquals($a->equals($b), true);
$this->assertEquals($b->equals($a), true);
$this->assertEquals($b->equals($b), true);
$c = Clock::tick(Clock::system(self::MOSCOW()), Duration::ofMillis(500));
$this->assertEquals($a->equals($c), false);
$d = Clock::tick(Clock::system(self::PARIS()), Duration::ofMillis(499));
$this->assertEquals($a->equals($d), false);
$this->assertEquals($a->equals(null), false);
$this->assertEquals($a->equals("other type"), false);
$this->assertEquals($a->equals(Clock::systemUTC()), false);
}
public function test_minus_Duration_zero()
{
$t = self::TEST_2008_6_30_11_30_59_000000500()->minusAmount(Duration::ZERO());
$this->assertEquals($t, self::TEST_2008_6_30_11_30_59_000000500());
}
/**
* Obtains a clock that returns instants from the specified clock with the
* specified duration added
* <p>
* This clock wraps another clock, returning instants that are later by the
* specified duration. If the duration is negative, the instants will be
* earlier than the current date and time.
* The main use case for this is to simulate running in the future or in the past.
* <p>
* A duration of zero would have no offsetting effect.
* Passing zero will return the underlying clock.
* <p>
* The returned implementation is immutable, thread-safe and {@code Serializable}
* providing that the base clock is.
*
* @param Clock $baseClock the base clock to add the duration to, not null
* @param Duration $offsetDuration the duration to add, not null
* @return Clock clock based on the base clock with the duration added, not null
*/
public static function offset(Clock $baseClock, Duration $offsetDuration)
{
if ($offsetDuration->equals(Duration::ZERO())) {
return $baseClock;
}
return new OffsetClock($baseClock, $offsetDuration);
}
private function compareTo(ChronoUnit $other)
{
return $this->duration->compareTo($other->duration);
}
