private function doTestOffset(ZoneOffset $offset, $hours, $minutes, $seconds) { $this->assertEquals($offset->getTotalSeconds(), $hours * 60 * 60 + $minutes * 60 + $seconds); if ($hours == 0 && $minutes == 0 && $seconds == 0) { $id = "Z"; } else { $str = $hours < 0 || $minutes < 0 || $seconds < 0 ? "-" : "+"; $str .= substr(Math::abs($hours) + 100, 1); $str .= ":"; $str .= substr(Math::abs($minutes) + 100, 1); if ($seconds != 0) { $str .= ":"; $str .= substr(Math::abs($seconds) + 100, 1); } $id = $str; } $this->assertEquals($offset->getId(), $id); $this->assertEquals($offset, ZoneOffset::ofHoursMinutesSeconds($hours, $minutes, $seconds)); if ($seconds == 0) { $this->assertEquals($offset, ZoneOffset::ofHoursMinutes($hours, $minutes)); if ($minutes == 0) { $this->assertEquals($offset, ZoneOffset::ofHours($hours)); } } $this->assertEquals(ZoneOffset::of($id), $offset); $this->assertEquals($offset->__toString(), $id); }
private static function ZDT() { return LocalDateTime::of(2008, 6, 30, 11, 30, 10, 500)->atZone(ZoneOffset::ofHours(2)); }
public function provider_offsets() { return [["+HH", "+00", ZoneOffset::UTC()], ["+HH", "-00", ZoneOffset::UTC()], ["+HH", "+01", ZoneOffset::ofHours(1)], ["+HH", "-01", ZoneOffset::ofHours(-1)], ["+HHMM", "+0000", ZoneOffset::UTC()], ["+HHMM", "-0000", ZoneOffset::UTC()], ["+HHMM", "+0102", ZoneOffset::ofHoursMinutes(1, 2)], ["+HHMM", "-0102", ZoneOffset::ofHoursMinutes(-1, -2)], ["+HH:MM", "+00:00", ZoneOffset::UTC()], ["+HH:MM", "-00:00", ZoneOffset::UTC()], ["+HH:MM", "+01:02", ZoneOffset::ofHoursMinutes(1, 2)], ["+HH:MM", "-01:02", ZoneOffset::ofHoursMinutes(-1, -2)], ["+HHMMss", "+0000", ZoneOffset::UTC()], ["+HHMMss", "-0000", ZoneOffset::UTC()], ["+HHMMss", "+0100", ZoneOffset::ofHoursMinutesSeconds(1, 0, 0)], ["+HHMMss", "+0159", ZoneOffset::ofHoursMinutesSeconds(1, 59, 0)], ["+HHMMss", "+0200", ZoneOffset::ofHoursMinutesSeconds(2, 0, 0)], ["+HHMMss", "+1800", ZoneOffset::ofHoursMinutesSeconds(18, 0, 0)], ["+HHMMss", "+010215", ZoneOffset::ofHoursMinutesSeconds(1, 2, 15)], ["+HHMMss", "-0100", ZoneOffset::ofHoursMinutesSeconds(-1, 0, 0)], ["+HHMMss", "-0200", ZoneOffset::ofHoursMinutesSeconds(-2, 0, 0)], ["+HHMMss", "-1800", ZoneOffset::ofHoursMinutesSeconds(-18, 0, 0)], ["+HHMMss", "+000000", ZoneOffset::UTC()], ["+HHMMss", "-000000", ZoneOffset::UTC()], ["+HHMMss", "+010000", ZoneOffset::ofHoursMinutesSeconds(1, 0, 0)], ["+HHMMss", "+010203", ZoneOffset::ofHoursMinutesSeconds(1, 2, 3)], ["+HHMMss", "+015959", ZoneOffset::ofHoursMinutesSeconds(1, 59, 59)], ["+HHMMss", "+020000", ZoneOffset::ofHoursMinutesSeconds(2, 0, 0)], ["+HHMMss", "+180000", ZoneOffset::ofHoursMinutesSeconds(18, 0, 0)], ["+HHMMss", "-010000", ZoneOffset::ofHoursMinutesSeconds(-1, 0, 0)], ["+HHMMss", "-020000", ZoneOffset::ofHoursMinutesSeconds(-2, 0, 0)], ["+HHMMss", "-180000", ZoneOffset::ofHoursMinutesSeconds(-18, 0, 0)], ["+HH:MM:ss", "+00:00", ZoneOffset::UTC()], ["+HH:MM:ss", "-00:00", ZoneOffset::UTC()], ["+HH:MM:ss", "+01:00", ZoneOffset::ofHoursMinutesSeconds(1, 0, 0)], ["+HH:MM:ss", "+01:02", ZoneOffset::ofHoursMinutesSeconds(1, 2, 0)], ["+HH:MM:ss", "+01:59", ZoneOffset::ofHoursMinutesSeconds(1, 59, 0)], ["+HH:MM:ss", "+02:00", ZoneOffset::ofHoursMinutesSeconds(2, 0, 0)], ["+HH:MM:ss", "+18:00", ZoneOffset::ofHoursMinutesSeconds(18, 0, 0)], ["+HH:MM:ss", "+01:02:15", ZoneOffset::ofHoursMinutesSeconds(1, 2, 15)], ["+HH:MM:ss", "-01:00", ZoneOffset::ofHoursMinutesSeconds(-1, 0, 0)], ["+HH:MM:ss", "-02:00", ZoneOffset::ofHoursMinutesSeconds(-2, 0, 0)], ["+HH:MM:ss", "-18:00", ZoneOffset::ofHoursMinutesSeconds(-18, 0, 0)], ["+HH:MM:ss", "+00:00:00", ZoneOffset::UTC()], ["+HH:MM:ss", "-00:00:00", ZoneOffset::UTC()], ["+HH:MM:ss", "+01:00:00", ZoneOffset::ofHoursMinutesSeconds(1, 0, 0)], ["+HH:MM:ss", "+01:02:03", ZoneOffset::ofHoursMinutesSeconds(1, 2, 3)], ["+HH:MM:ss", "+01:59:59", ZoneOffset::ofHoursMinutesSeconds(1, 59, 59)], ["+HH:MM:ss", "+02:00:00", ZoneOffset::ofHoursMinutesSeconds(2, 0, 0)], ["+HH:MM:ss", "+18:00:00", ZoneOffset::ofHoursMinutesSeconds(18, 0, 0)], ["+HH:MM:ss", "-01:00:00", ZoneOffset::ofHoursMinutesSeconds(-1, 0, 0)], ["+HH:MM:ss", "-02:00:00", ZoneOffset::ofHoursMinutesSeconds(-2, 0, 0)], ["+HH:MM:ss", "-18:00:00", ZoneOffset::ofHoursMinutesSeconds(-18, 0, 0)], ["+HHMMSS", "+000000", ZoneOffset::UTC()], ["+HHMMSS", "-000000", ZoneOffset::UTC()], ["+HHMMSS", "+010203", ZoneOffset::ofHoursMinutesSeconds(1, 2, 3)], ["+HHMMSS", "-010203", ZoneOffset::ofHoursMinutesSeconds(-1, -2, -3)], ["+HH:MM:SS", "+00:00:00", ZoneOffset::UTC()], ["+HH:MM:SS", "-00:00:00", ZoneOffset::UTC()], ["+HH:MM:SS", "+01:02:03", ZoneOffset::ofHoursMinutesSeconds(1, 2, 3)], ["+HH:MM:SS", "-01:02:03", ZoneOffset::ofHoursMinutesSeconds(-1, -2, -3)]]; }
public function test_of() { //used for standard offset $stdOffset1 = ZoneOffset::UTC(); $stdOffset2 = ZoneOffset::ofHours(1); $time_of_stdOffsetTransition1 = LocalDateTime::of(2013, 1, 5, 1, 0); $stdOffsetTransition1 = ZoneOffsetTransition::of($time_of_stdOffsetTransition1, $stdOffset1, $stdOffset2); $stdOffsetTransition_list = []; $stdOffsetTransition_list[] = $stdOffsetTransition1; //used for wall offset $wallOffset1 = ZoneOffset::ofHours(2); $wallOffset2 = ZoneOffset::ofHours(4); $wallOffset3 = ZoneOffset::ofHours(7); $time_of_wallOffsetTransition1 = LocalDateTime::of(2013, 2, 5, 1, 0); $time_of_wallOffsetTransition2 = LocalDateTime::of(2013, 3, 5, 1, 0); $time_of_wallOffsetTransition3 = LocalDateTime::of(2013, 10, 5, 1, 0); $wallOffsetTransition1 = ZoneOffsetTransition::of($time_of_wallOffsetTransition1, $wallOffset1, $wallOffset2); $wallOffsetTransition2 = ZoneOffsetTransition::of($time_of_wallOffsetTransition2, $wallOffset2, $wallOffset3); $wallOffsetTransition3 = ZoneOffsetTransition::of($time_of_wallOffsetTransition3, $wallOffset3, $wallOffset1); $wallOffsetTransition_list = []; $wallOffsetTransition_list[] = $wallOffsetTransition1; $wallOffsetTransition_list[] = $wallOffsetTransition2; $wallOffsetTransition_list[] = $wallOffsetTransition3; //used for ZoneOffsetTransitionRule $ruleOffset = ZoneOffset::ofHours(3); $timeDefinition = TimeDefinition::WALL(); $rule1 = ZoneOffsetTransitionRule::of(Month::FEBRUARY(), 2, DayOfWeek::MONDAY(), LocalTime::of(1, 0), false, $timeDefinition, ZoneOffset::UTC(), ZoneOffset::UTC(), $ruleOffset); $rule_list = []; $rule_list[] = $rule1; //Begin verification $zoneRule = ZoneRules::of($stdOffset1, $wallOffset1, $stdOffsetTransition_list, $wallOffsetTransition_list, $rule_list); $before_time_of_stdOffsetTransition1 = OffsetDateTime::ofDateTime($time_of_stdOffsetTransition1, $stdOffset1)->minusSeconds(1); $after_time_of_stdOffsetTransition1 = OffsetDateTime::ofDateTime($time_of_stdOffsetTransition1, $stdOffset1)->plusSeconds(1); $this->assertEquals($zoneRule->getStandardOffset($before_time_of_stdOffsetTransition1->toInstant()), $stdOffset1); $this->assertEquals($zoneRule->getStandardOffset($after_time_of_stdOffsetTransition1->toInstant()), $stdOffset2); $before_time_of_wallOffsetTransition1 = OffsetDateTime::ofDateTime($time_of_wallOffsetTransition1, $wallOffset1)->minusSeconds(1); $after_time_of_wallOffsetTransition1 = OffsetDateTime::ofDateTime($time_of_wallOffsetTransition1, $wallOffset1)->plusSeconds(1); $this->assertEquals($zoneRule->nextTransition($before_time_of_wallOffsetTransition1->toInstant()), $wallOffsetTransition1); $this->assertEquals($zoneRule->nextTransition($after_time_of_wallOffsetTransition1->toInstant()), $wallOffsetTransition2); $before_time_of_wallOffsetTransition2 = OffsetDateTime::ofDateTime($time_of_wallOffsetTransition2, $wallOffset2)->minusSeconds(1); $after_time_of_wallOffsetTransition2 = OffsetDateTime::ofDateTime($time_of_wallOffsetTransition2, $wallOffset2)->plusSeconds(1); $this->assertEquals($zoneRule->nextTransition($before_time_of_wallOffsetTransition2->toInstant()), $wallOffsetTransition2); $this->assertEquals($zoneRule->nextTransition($after_time_of_wallOffsetTransition2->toInstant()), $wallOffsetTransition3); $before_time_of_wallOffsetTransition3 = OffsetDateTime::ofDateTime($time_of_wallOffsetTransition3, $wallOffset3)->minusSeconds(1); $after_time_of_wallOffsetTransition3 = OffsetDateTime::ofDateTime($time_of_wallOffsetTransition3, $wallOffset3)->plusSeconds(1); $this->assertEquals($zoneRule->nextTransition($before_time_of_wallOffsetTransition3->toInstant()), $wallOffsetTransition3); $this->assertEquals($zoneRule->nextTransition($after_time_of_wallOffsetTransition3->toInstant()), $rule1->createTransition(2014)); }
private static function OFFSET_PONE() { return ZoneOffset::ofHours(1); }
public function test_with_adjuster_LocalDate_retainOffset2() { $newYork = ZoneId::of("America/New_York"); $ldt = LocalDateTime::of(2008, 11, 3, 1, 30); $base = ZonedDateTime::ofDateTime($ldt, $newYork); $this->assertEquals($base->getOffset(), ZoneOffset::ofHours(-5)); $test = $base->adjust(LocalDate::of(2008, 11, 2)); $this->assertEquals($test->getOffset(), ZoneOffset::ofHours(-5)); }
public function test_parseBest_firstOption() { $test = DateTimeFormatter::ofPattern("yyyy-MM-dd HH:mm[XXX]"); $result = $test->parseBest("2011-06-30 12:30+03:00", TemporalQueries::fromCallable([ZonedDateTime::class, "from"]), TemporalQueries::fromCallable([LocalDateTime::class, "from"])); $ldt = LocalDateTime::of(2011, 6, 30, 12, 30); $this->assertEquals($result, ZonedDateTime::ofDateTime($ldt, ZoneOffset::ofHours(3))); }
function data_adjustInto() { return [[OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), OffsetDateTime::of(2012, 3, 4, 1, 1, 1, 100, ZoneOffset::UTC()), OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), null], [OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), OffsetDateTime::MAX(), OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), null], [OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), OffsetDateTime::MIN(), OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), null], [OffsetDateTime::MAX(), OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), OffsetDateTime::ofDateTime(OffsetDateTime::MAX()->toLocalDateTime(), ZoneOffset::ofHours(-18)), null], [OffsetDateTime::MIN(), OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), OffsetDateTime::ofDateTime(OffsetDateTime::MIN()->toLocalDateTime(), ZoneOffset::ofHours(18)), null], [OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), ZonedDateTime::of(2012, 3, 4, 1, 1, 1, 100, self::ZONE_GAZA()), ZonedDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::ZONE_GAZA()), null], [OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), LocalDateTime::of(2012, 3, 4, 1, 1, 1, 100), null, DateTimeException::class], [OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), LocalDate::of(2210, 2, 2), null, DateTimeException::class], [OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), LocalTime::of(22, 3, 0), null, DateTimeException::class], [OffsetDateTime::of(2012, 3, 4, 23, 5, 0, 0, self::OFFSET_PONE()), OffsetTime::of(22, 3, 0, 0, ZoneOffset::UTC()), null, DateTimeException::class]]; }
/** * @group long */ public function test_toEpochSecond_afterEpoch() { for ($i = -5; $i < 5; $i++) { $offset = ZoneOffset::ofHours($i); for ($j = 0; $j < 100000; $j++) { $a = LocalDateTime::of(1970, 1, 1, 0, 0)->plusSeconds($j); $this->assertEquals($a->toEpochSecond($offset), $j - $i * 3600); } } }
private static function OFFSET_0300() { return ZoneOffset::ofHours(3); }
private static function OFFSET_PTWO() { return ZoneOffset::ofHours(2); }
private static function OFFSET_M0100() { return ZoneOffset::ofHours(-1); }
public function test_factory_from_TemporalAccessor_offset() { $offset = ZoneOffset::ofHours(1); $this->assertEquals(ZoneId::from($offset), $offset); }
public function test_NewYork_getOffsetInfo_overlap() { $test = ZoneId::of("America/New_York"); $dateTime = LocalDateTime::of(2008, 11, 2, 1, 0, 0, 0); $trans = $this->checkOffset($test->getRules(), $dateTime, ZoneOffset::ofHours(-4), self::$OVERLAP); $this->assertEquals($trans->getOffsetBefore(), ZoneOffset::ofHours(-4)); $this->assertEquals($trans->getOffsetAfter(), ZoneOffset::ofHours(-5)); $this->assertEquals($trans->getInstant(), $this->createInstant8(2008, 11, 2, 2, 0, 0, 0, ZoneOffset::ofHours(-4))); $this->assertEquals($trans->isValidOffset(ZoneOffset::ofHours(-1)), false); $this->assertEquals($trans->isValidOffset(ZoneOffset::ofHours(-5)), true); $this->assertEquals($trans->isValidOffset(ZoneOffset::ofHours(-4)), true); $this->assertEquals($trans->isValidOffset(ZoneOffset::ofHours(2)), false); $this->assertEquals($trans->__toString(), "Transition[Overlap at 2008-11-02T02:00-04:00 to -05:00]"); $this->assertFalse($trans->equals(null)); $this->assertFalse($trans->equals(ZoneOffset::ofHours(-4))); $this->assertTrue($trans->equals($trans)); $otherTrans = $test->getRules()->getTransition($dateTime); $this->assertTrue($trans->equals($otherTrans)); }
/** * @group long */ public function test_atZone() { for ($i = 0; $i < 24 * 60 * 60; $i++) { $instant = Instant::ofEpochSecond($i); $test = $instant->atZone(ZoneOffset::ofHours(1)); $this->assertEquals($test->getYear(), 1970); $this->assertEquals($test->getMonthValue(), 1); $this->assertEquals($test->getDayOfMonth(), 1 + ($i >= 23 * 60 * 60 ? 1 : 0)); $this->assertEquals($test->getHour(), ($i / (60 * 60) + 1) % 24); $this->assertEquals($test->getMinute(), $i / 60 % 60); $this->assertEquals($test->getSecond(), $i % 60); } }
/** * SPI method to get the rules for the zone ID. * <p> * This loads the rules for the specified zone ID. * The provider implementation must validate that the zone ID is valid and * available, throwing a {@code ZoneRulesException} if it is not. * The result of the method in the valid case depends on the caching flag. * <p> * If the provider implementation is not dynamic, then the result of the * method must be the non-null set of rules selected by the ID. * <p> * If the provider implementation is dynamic, then the flag gives the option * of preventing the returned rules from being cached in {@link ZoneId}. * When the flag is true, the provider is permitted to return null, where * null will prevent the rules from being cached in {@code ZoneId}. * When the flag is false, the provider must return non-null rules. * * @param string $zoneId the zone ID as defined by {@code ZoneId}, not null * @param bool $forCaching whether the rules are being queried for caching, * true if the returned rules will be cached by {@code ZoneId}, * false if they will be returned to the user without being cached in {@code ZoneId} * @return ZoneRules the rules, null if {@code forCaching} is true and this * is a dynamic provider that wants to prevent caching in {@code ZoneId}, * otherwise not null * @throws ZoneRulesException if rules cannot be obtained for the zone ID */ protected function provideRules($zoneId, $forCaching) { return ZoneRules::ofOffset(ZoneOffset::ofHours(1)); }