-- 906c47420646d510edd2479d5542c56f5fa31b65 by CJ Johnson <johnsoncj@google.com>: Import of CCTZ from GitHub. PiperOrigin-RevId: 216573923 -- 74560d4afd2b605909e677c6fc3076049fb3010a by Eric Fiselier <ericwf@google.com>: Avoid -Wformat-pedantic in benchmark. PiperOrigin-RevId: 216523769 -- 9bcc9da8b03e6d1ea43ee78931256c5541cb9686 by Eric Fiselier <ericwf@google.com>: Delete unused CityHash functions. PiperOrigin-RevId: 216464492 -- a42563b394c89fbb4c55cb5a6a5edbf96d271eea by Abseil Team <absl-team@google.com>: Introduce new Abseil interfaces for converting between civil times and absolute times.s Deprecates absl::ConvertDateTime() and absl::FromDateTime(). PiperOrigin-RevId: 216424948 -- 088e11235124267517d7f137854fa5554679c24f by Eric Fiselier <ericwf@google.com>: Remove unneeded break statements in test. PiperOrigin-RevId: 216403321 GitOrigin-RevId: 906c47420646d510edd2479d5542c56f5fa31b65 Change-Id: Idb44420be623e369c66f5a9c92bdc9ab46d3ec92pull/194/head
Abseil Team
6 years ago
committed by
CJ Johnson
parent
445998d7ac
commit
f340f773ed
24 changed files with 2657 additions and 2574 deletions
@ -1,41 +0,0 @@ |
||||
// Copyright 2018 The Abseil Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
// This file declares the subset of the CityHash functions that require
|
||||
// _mm_crc32_u64(). See the CityHash README for details.
|
||||
//
|
||||
// Functions in the CityHash family are not suitable for cryptography.
|
||||
|
||||
#ifndef ABSL_HASH_INTERNAL_CITY_CRC_H_ |
||||
#define ABSL_HASH_INTERNAL_CITY_CRC_H_ |
||||
|
||||
#include "absl/hash/internal/city.h" |
||||
|
||||
namespace absl { |
||||
namespace hash_internal { |
||||
|
||||
// Hash function for a byte array.
|
||||
uint128 CityHashCrc128(const char *s, size_t len); |
||||
|
||||
// Hash function for a byte array. For convenience, a 128-bit seed is also
|
||||
// hashed into the result.
|
||||
uint128 CityHashCrc128WithSeed(const char *s, size_t len, uint128 seed); |
||||
|
||||
// Hash function for a byte array. Sets result[0] ... result[3].
|
||||
void CityHashCrc256(const char *s, size_t len, uint64_t *result); |
||||
|
||||
} // namespace hash_internal
|
||||
} // namespace absl
|
||||
|
||||
#endif // ABSL_HASH_INTERNAL_CITY_CRC_H_
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,88 @@ |
||||
// Copyright 2018 The Abseil Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "absl/time/civil_time.h" |
||||
|
||||
#include <cstdlib> |
||||
#include <string> |
||||
|
||||
#include "absl/strings/str_cat.h" |
||||
#include "absl/time/time.h" |
||||
|
||||
namespace absl { |
||||
|
||||
namespace { |
||||
|
||||
// Since a civil time has a larger year range than absl::Time (64-bit years vs
|
||||
// 64-bit seconds, respectively) we normalize years to roughly +/- 400 years
|
||||
// around the year 2400, which will produce an equivalent year in a range that
|
||||
// absl::Time can handle.
|
||||
inline civil_year_t NormalizeYear(civil_year_t year) { |
||||
return 2400 + year % 400; |
||||
} |
||||
|
||||
// Formats the given CivilSecond according to the given format.
|
||||
std::string FormatYearAnd(string_view fmt, CivilSecond cs) { |
||||
const CivilSecond ncs(NormalizeYear(cs.year()), cs.month(), cs.day(), |
||||
cs.hour(), cs.minute(), cs.second()); |
||||
const TimeZone utc = UTCTimeZone(); |
||||
// TODO(absl-team): Avoid conversion of fmt std::string.
|
||||
return StrCat(cs.year(), FormatTime(std::string(fmt), FromCivil(ncs, utc), utc)); |
||||
} |
||||
|
||||
} // namespace
|
||||
|
||||
std::string FormatCivilTime(CivilSecond c) { |
||||
return FormatYearAnd("-%m-%dT%H:%M:%S", c); |
||||
} |
||||
std::string FormatCivilTime(CivilMinute c) { |
||||
return FormatYearAnd("-%m-%dT%H:%M", c); |
||||
} |
||||
std::string FormatCivilTime(CivilHour c) { |
||||
return FormatYearAnd("-%m-%dT%H", c); |
||||
} |
||||
std::string FormatCivilTime(CivilDay c) { |
||||
return FormatYearAnd("-%m-%d", c); |
||||
} |
||||
std::string FormatCivilTime(CivilMonth c) { |
||||
return FormatYearAnd("-%m", c); |
||||
} |
||||
std::string FormatCivilTime(CivilYear c) { |
||||
return FormatYearAnd("", c); |
||||
} |
||||
|
||||
namespace time_internal { |
||||
|
||||
std::ostream& operator<<(std::ostream& os, CivilYear y) { |
||||
return os << FormatCivilTime(y); |
||||
} |
||||
std::ostream& operator<<(std::ostream& os, CivilMonth m) { |
||||
return os << FormatCivilTime(m); |
||||
} |
||||
std::ostream& operator<<(std::ostream& os, CivilDay d) { |
||||
return os << FormatCivilTime(d); |
||||
} |
||||
std::ostream& operator<<(std::ostream& os, CivilHour h) { |
||||
return os << FormatCivilTime(h); |
||||
} |
||||
std::ostream& operator<<(std::ostream& os, CivilMinute m) { |
||||
return os << FormatCivilTime(m); |
||||
} |
||||
std::ostream& operator<<(std::ostream& os, CivilSecond s) { |
||||
return os << FormatCivilTime(s); |
||||
} |
||||
|
||||
} // namespace time_internal
|
||||
|
||||
} // namespace absl
|
||||
@ -0,0 +1,487 @@ |
||||
// Copyright 2018 The Abseil Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
// -----------------------------------------------------------------------------
|
||||
// File: civil_time.h
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// This header file defines abstractions for computing with "civil time".
|
||||
// The term "civil time" refers to the legally recognized human-scale time
|
||||
// that is represented by the six fields `YYYY-MM-DD hh:mm:ss`. A "date"
|
||||
// is perhaps the most common example of a civil time (represented here as
|
||||
// an `absl::CivilDay`).
|
||||
//
|
||||
// Modern-day civil time follows the Gregorian Calendar and is a
|
||||
// time-zone-independent concept: a civil time of "2015-06-01 12:00:00", for
|
||||
// example, is not tied to a time zone. Put another way, a civil time does not
|
||||
// map to a unique point in time; a civil time must be mapped to an absolute
|
||||
// time *through* a time zone.
|
||||
//
|
||||
// Because a civil time is what most people think of as "time," it is common to
|
||||
// map absolute times to civil times to present to users.
|
||||
//
|
||||
// Time zones define the relationship between absolute and civil times. Given an
|
||||
// absolute or civil time and a time zone, you can compute the other time:
|
||||
//
|
||||
// Civil Time = F(Absolute Time, Time Zone)
|
||||
// Absolute Time = G(Civil Time, Time Zone)
|
||||
//
|
||||
// The Abseil time library allows you to construct such civil times from
|
||||
// absolute times; consult time.h for such functionality.
|
||||
//
|
||||
// This library provides six classes for constructing civil-time objects, and
|
||||
// provides several helper functions for rounding, iterating, and performing
|
||||
// arithmetic on civil-time objects, while avoiding complications like
|
||||
// daylight-saving time (DST):
|
||||
//
|
||||
// * `absl::CivilSecond`
|
||||
// * `absl::CivilMinute`
|
||||
// * `absl::CivilHour`
|
||||
// * `absl::CivilDay`
|
||||
// * `absl::CivilMonth`
|
||||
// * `absl::CivilYear`
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// // Construct a civil-time object for a specific day
|
||||
// const absl::CivilDay cd(1969, 07, 20);
|
||||
//
|
||||
// // Construct a civil-time object for a specific second
|
||||
// const absl::CivilSecond cd(2018, 8, 1, 12, 0, 1);
|
||||
//
|
||||
// Note: In C++14 and later, this library is usable in a constexpr context.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// // Valid in C++14
|
||||
// constexpr absl::CivilDay cd(1969, 07, 20);
|
||||
//
|
||||
|
||||
#ifndef ABSL_TIME_CIVIL_TIME_H_ |
||||
#define ABSL_TIME_CIVIL_TIME_H_ |
||||
|
||||
#include <string> |
||||
|
||||
#include "absl/base/port.h" // Needed for string vs std::string |
||||
#include "absl/strings/string_view.h" |
||||
#include "absl/time/internal/cctz/include/cctz/civil_time.h" |
||||
|
||||
namespace absl { |
||||
|
||||
namespace time_internal { |
||||
struct second_tag : cctz::detail::second_tag {}; |
||||
struct minute_tag : second_tag, cctz::detail::minute_tag {}; |
||||
struct hour_tag : minute_tag, cctz::detail::hour_tag {}; |
||||
struct day_tag : hour_tag, cctz::detail::day_tag {}; |
||||
struct month_tag : day_tag, cctz::detail::month_tag {}; |
||||
struct year_tag : month_tag, cctz::detail::year_tag {}; |
||||
} // namespace time_internal
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// CivilSecond, CivilMinute, CivilHour, CivilDay, CivilMonth, CivilYear
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// Each of these civil-time types is a simple value type with the same
|
||||
// interface for construction and the same six accessors for each of the civil
|
||||
// time fields (year, month, day, hour, minute, and second, aka YMDHMS). These
|
||||
// classes differ only in their alignment, which is indicated by the type name
|
||||
// and specifies the field on which arithmetic operates.
|
||||
//
|
||||
// CONSTRUCTION
|
||||
//
|
||||
// Each of the civil-time types can be constructed in two ways: by directly
|
||||
// passing to the constructor up to six integers representing the YMDHMS fields,
|
||||
// or by copying the YMDHMS fields from a differently aligned civil-time type.
|
||||
// Omitted fields are assigned their minimum valid value. Hours, minutes, and
|
||||
// seconds will be set to 0, month and day will be set to 1. Since there is no
|
||||
// minimum year, the default is 1970.
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// absl::CivilDay default_value; // 1970-01-01 00:00:00
|
||||
//
|
||||
// absl::CivilDay a(2015, 2, 3); // 2015-02-03 00:00:00
|
||||
// absl::CivilDay b(2015, 2, 3, 4, 5, 6); // 2015-02-03 00:00:00
|
||||
// absl::CivilDay c(2015); // 2015-01-01 00:00:00
|
||||
//
|
||||
// absl::CivilSecond ss(2015, 2, 3, 4, 5, 6); // 2015-02-03 04:05:06
|
||||
// absl::CivilMinute mm(ss); // 2015-02-03 04:05:00
|
||||
// absl::CivilHour hh(mm); // 2015-02-03 04:00:00
|
||||
// absl::CivilDay d(hh); // 2015-02-03 00:00:00
|
||||
// absl::CivilMonth m(d); // 2015-02-01 00:00:00
|
||||
// absl::CivilYear y(m); // 2015-01-01 00:00:00
|
||||
//
|
||||
// m = absl::CivilMonth(y); // 2015-01-01 00:00:00
|
||||
// d = absl::CivilDay(m); // 2015-01-01 00:00:00
|
||||
// hh = absl::CivilHour(d); // 2015-01-01 00:00:00
|
||||
// mm = absl::CivilMinute(hh); // 2015-01-01 00:00:00
|
||||
// ss = absl::CivilSecond(mm); // 2015-01-01 00:00:00
|
||||
//
|
||||
// Each civil-time class is aligned to the civil-time field indicated in the
|
||||
// class's name after normalization. Alignment is performed by setting all the
|
||||
// inferior fields to their minimum valid value (as described above). The
|
||||
// following are examples of how each of the six types would align the fields
|
||||
// representing November 22, 2015 at 12:34:56 in the afternoon. (Note: the
|
||||
// string format used here is not important; it's just a shorthand way of
|
||||
// showing the six YMDHMS fields.)
|
||||
//
|
||||
// absl::CivilSecond : 2015-11-22 12:34:56
|
||||
// absl::CivilMinute : 2015-11-22 12:34:00
|
||||
// absl::CivilHour : 2015-11-22 12:00:00
|
||||
// absl::CivilDay : 2015-11-22 00:00:00
|
||||
// absl::CivilMonth : 2015-11-01 00:00:00
|
||||
// absl::CivilYear : 2015-01-01 00:00:00
|
||||
//
|
||||
// Each civil-time type performs arithmetic on the field to which it is
|
||||
// aligned. This means that adding 1 to an absl::CivilDay increments the day
|
||||
// field (normalizing as necessary), and subtracting 7 from an absl::CivilMonth
|
||||
// operates on the month field (normalizing as necessary). All arithmetic
|
||||
// produces a valid civil time. Difference requires two similarly aligned
|
||||
// civil-time objects and returns the scalar answer in units of the objects'
|
||||
// alignment. For example, the difference between two absl::CivilHour objects
|
||||
// will give an answer in units of civil hours.
|
||||
//
|
||||
// ALIGNMENT CONVERSION
|
||||
//
|
||||
// The alignment of a civil-time object cannot change, but the object may be
|
||||
// used to construct a new object with a different alignment. This is referred
|
||||
// to as "realigning". When realigning to a type with the same or more
|
||||
// precision (e.g., absl::CivilDay -> absl::CivilSecond), the conversion may be
|
||||
// performed implicitly since no information is lost. However, if information
|
||||
// could be discarded (e.g., CivilSecond -> CivilDay), the conversion must
|
||||
// be explicit at the call site.
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// void UseDay(absl::CivilDay day);
|
||||
//
|
||||
// absl::CivilSecond cs;
|
||||
// UseDay(cs); // Won't compile because data may be discarded
|
||||
// UseDay(absl::CivilDay(cs)); // OK: explicit conversion
|
||||
//
|
||||
// absl::CivilDay cd;
|
||||
// UseDay(cd); // OK: no conversion needed
|
||||
//
|
||||
// absl::CivilMonth cm;
|
||||
// UseDay(cm); // OK: implicit conversion to absl::CivilDay
|
||||
//
|
||||
// NORMALIZATION
|
||||
//
|
||||
// Normalization takes invalid values and adjusts them to produce valid values.
|
||||
// Within the civil-time library, integer arguments passed to the Civil*
|
||||
// constructors may be out-of-range, in which case they are normalized by
|
||||
// carrying overflow into a field of courser granularity to produce valid
|
||||
// civil-time objects. This normalization enables natural arithmetic on
|
||||
// constructor arguments without worrying about the field's range.
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// // Out-of-range; normalized to 2016-11-01
|
||||
// absl::CivilDay d(2016, 10, 32);
|
||||
// // Out-of-range, negative: normalized to 2016-10-30T23
|
||||
// absl::CivilHour h1(2016, 10, 31, -1);
|
||||
// // Normalization is cumulative: normalized to 2016-10-30T23
|
||||
// absl::CivilHour h2(2016, 10, 32, -25);
|
||||
//
|
||||
// Note: If normalization is undesired, you can signal an error by comparing
|
||||
// the constructor arguments to the normalized values returned by the YMDHMS
|
||||
// properties.
|
||||
//
|
||||
// COMPARISON
|
||||
//
|
||||
// Comparison between civil-time objects considers all six YMDHMS fields,
|
||||
// regardless of the type's alignment. Comparison between differently aligned
|
||||
// civil-time types is allowed.
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// absl::CivilDay feb_3(2015, 2, 3); // 2015-02-03 00:00:00
|
||||
// absl::CivilDay mar_4(2015, 3, 4); // 2015-03-04 00:00:00
|
||||
// // feb_3 < mar_4
|
||||
// // absl::CivilYear(feb_3) == absl::CivilYear(mar_4)
|
||||
//
|
||||
// absl::CivilSecond feb_3_noon(2015, 2, 3, 12, 0, 0); // 2015-02-03 12:00:00
|
||||
// // feb_3 < feb_3_noon
|
||||
// // feb_3 == absl::CivilDay(feb_3_noon)
|
||||
//
|
||||
// // Iterates all the days of February 2015.
|
||||
// for (absl::CivilDay d(2015, 2, 1); d < absl::CivilMonth(2015, 3); ++d) {
|
||||
// // ...
|
||||
// }
|
||||
//
|
||||
// ARITHMETIC
|
||||
//
|
||||
// Civil-time types support natural arithmetic operators such as addition,
|
||||
// subtraction, and difference. Arithmetic operates on the civil-time field
|
||||
// indicated in the type's name. Difference operators require arguments with
|
||||
// the same alignment and return the answer in units of the alignment.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::CivilDay a(2015, 2, 3);
|
||||
// ++a; // 2015-02-04 00:00:00
|
||||
// --a; // 2015-02-03 00:00:00
|
||||
// absl::CivilDay b = a + 1; // 2015-02-04 00:00:00
|
||||
// absl::CivilDay c = 1 + b; // 2015-02-05 00:00:00
|
||||
// int n = c - a; // n = 2 (civil days)
|
||||
// int m = c - absl::CivilMonth(c); // Won't compile: different types.
|
||||
//
|
||||
// ACCESSORS
|
||||
//
|
||||
// Each civil-time type has accessors for all six of the civil-time fields:
|
||||
// year, month, day, hour, minute, and second.
|
||||
//
|
||||
// civil_year_t year()
|
||||
// int month()
|
||||
// int day()
|
||||
// int hour()
|
||||
// int minute()
|
||||
// int second()
|
||||
//
|
||||
// Recall that fields inferior to the type's aligment will be set to their
|
||||
// minimum valid value.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::CivilDay d(2015, 6, 28);
|
||||
// // d.year() == 2015
|
||||
// // d.month() == 6
|
||||
// // d.day() == 28
|
||||
// // d.hour() == 0
|
||||
// // d.minute() == 0
|
||||
// // d.second() == 0
|
||||
//
|
||||
// CASE STUDY: Adding a month to January 31.
|
||||
//
|
||||
// One of the classic questions that arises when considering a civil time
|
||||
// library (or a date library or a date/time library) is this:
|
||||
// "What is the result of adding a month to January 31?"
|
||||
// This is an interesting question because it is unclear what is meant by a
|
||||
// "month", and several different answers are possible, depending on context:
|
||||
//
|
||||
// 1. March 3 (or 2 if a leap year), if "add a month" means to add a month to
|
||||
// the current month, and adjust the date to overflow the extra days into
|
||||
// March. In this case the result of "February 31" would be normalized as
|
||||
// within the civil-time library.
|
||||
// 2. February 28 (or 29 if a leap year), if "add a month" means to add a
|
||||
// month, and adjust the date while holding the resulting month constant.
|
||||
// In this case, the result of "February 31" would be truncated to the last
|
||||
// day in February.
|
||||
// 3. An error. The caller may get some error, an exception, an invalid date
|
||||
// object, or perhaps return `false`. This may make sense because there is
|
||||
// no single unambiguously correct answer to the question.
|
||||
//
|
||||
// Practically speaking, any answer that is not what the programmer intended
|
||||
// is the wrong answer.
|
||||
//
|
||||
// The Abseil time library avoids this problem by making it impossible to
|
||||
// ask ambiguous questions. All civil-time objects are aligned to a particular
|
||||
// civil-field boundary (such as aligned to a year, month, day, hour, minute,
|
||||
// or second), and arithmetic operates on the field to which the object is
|
||||
// aligned. This means that in order to "add a month" the object must first be
|
||||
// aligned to a month boundary, which is equivalent to the first day of that
|
||||
// month.
|
||||
//
|
||||
// Of course, there are ways to compute an answer the question at hand using
|
||||
// this Abseil time library, but they require the programmer to be explicit
|
||||
// about the answer they expect. To illustrate, let's see how to compute all
|
||||
// three of the above possible answers to the question of "Jan 31 plus 1
|
||||
// month":
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// const absl::CivilDay d(2015, 1, 31);
|
||||
//
|
||||
// // Answer 1:
|
||||
// // Add 1 to the month field in the constructor, and rely on normalization.
|
||||
// const auto normalized = absl::CivilDay(d.year(), d.month() + 1, d.day());
|
||||
// // normalized == 2015-03-03 (aka Feb 31)
|
||||
//
|
||||
// // Answer 2:
|
||||
// // Add 1 to month field, capping to the end of next month.
|
||||
// const auto next_month = absl::CivilMonth(d) + 1;
|
||||
// const auto last_day_of_next_month = absl::CivilDay(next_month + 1) - 1;
|
||||
// const auto capped = std::min(normalized, last_day_of_next_month);
|
||||
// // capped == 2015-02-28
|
||||
//
|
||||
// // Answer 3:
|
||||
// // Signal an error if the normalized answer is not in next month.
|
||||
// if (absl::CivilMonth(normalized) != next_month) {
|
||||
// // error, month overflow
|
||||
// }
|
||||
//
|
||||
using CivilSecond = |
||||
time_internal::cctz::detail::civil_time<time_internal::second_tag>; |
||||
using CivilMinute = |
||||
time_internal::cctz::detail::civil_time<time_internal::minute_tag>; |
||||
using CivilHour = |
||||
time_internal::cctz::detail::civil_time<time_internal::hour_tag>; |
||||
using CivilDay = |
||||
time_internal::cctz::detail::civil_time<time_internal::day_tag>; |
||||
using CivilMonth = |
||||
time_internal::cctz::detail::civil_time<time_internal::month_tag>; |
||||
using CivilYear = |
||||
time_internal::cctz::detail::civil_time<time_internal::year_tag>; |
||||
|
||||
// civil_year_t
|
||||
//
|
||||
// Type alias of a civil-time year value. This type is guaranteed to (at least)
|
||||
// support any year value supported by `time_t`.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::CivilSecond cs = ...;
|
||||
// absl::civil_year_t y = cs.year();
|
||||
// cs = absl::CivilSecond(y, 1, 1, 0, 0 0); // CivilSecond(CivilYear(cs))
|
||||
//
|
||||
using civil_year_t = time_internal::cctz::year_t; |
||||
|
||||
// civil_diff_t
|
||||
//
|
||||
// Type alias of the difference between two civil-time values.
|
||||
// This type is used to indicate arguments that are not
|
||||
// normalized (such as parameters to the civil-time constructors), the results
|
||||
// of civil-time subtraction, or the operand to civil-time addition.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::civil_diff_t n_sec = cs1 - cs2; // cs1 == cs2 + n_sec;
|
||||
//
|
||||
using civil_diff_t = time_internal::cctz::diff_t; |
||||
|
||||
// Weekday::monday, Weekday::tuesday, Weekday::wednesday, Weekday::thursday,
|
||||
// Weekday::friday, Weekday::saturday, Weekday::sunday
|
||||
//
|
||||
// The Weekday enum class represents the civil-time concept of a "weekday" with
|
||||
// members for all days of the week.
|
||||
//
|
||||
// absl::Weekday wd = absl::Weekday::thursday;
|
||||
//
|
||||
using Weekday = time_internal::cctz::weekday; |
||||
|
||||
// GetWeekday()
|
||||
//
|
||||
// Returns the absl::Weekday for the given absl::CivilDay.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::CivilDay a(2015, 8, 13);
|
||||
// absl::Weekday wd = absl::GetWeekday(a); // wd == absl::Weekday::thursday
|
||||
//
|
||||
inline Weekday GetWeekday(CivilDay cd) { |
||||
return time_internal::cctz::get_weekday(cd); |
||||
} |
||||
|
||||
// NextWeekday()
|
||||
// PrevWeekday()
|
||||
//
|
||||
// Returns the absl::CivilDay that strictly follows or precedes a given
|
||||
// absl::CivilDay, and that falls on the given absl::Weekday.
|
||||
//
|
||||
// Example, given the following month:
|
||||
//
|
||||
// August 2015
|
||||
// Su Mo Tu We Th Fr Sa
|
||||
// 1
|
||||
// 2 3 4 5 6 7 8
|
||||
// 9 10 11 12 13 14 15
|
||||
// 16 17 18 19 20 21 22
|
||||
// 23 24 25 26 27 28 29
|
||||
// 30 31
|
||||
//
|
||||
// absl::CivilDay a(2015, 8, 13);
|
||||
// // absl::GetWeekday(a) == absl::Weekday::thursday
|
||||
// absl::CivilDay b = absl::NextWeekday(a, absl::Weekday::thursday);
|
||||
// // b = 2015-08-20
|
||||
// absl::CivilDay c = absl::PrevWeekday(a, absl::Weekday::thursday);
|
||||
// // c = 2015-08-06
|
||||
//
|
||||
// absl::CivilDay d = ...
|
||||
// // Gets the following Thursday if d is not already Thursday
|
||||
// absl::CivilDay thurs1 = absl::PrevWeekday(d, absl::Weekday::thursday) + 7;
|
||||
// // Gets the previous Thursday if d is not already Thursday
|
||||
// absl::CivilDay thurs2 = absl::NextWeekday(d, absl::Weekday::thursday) - 7;
|
||||
//
|
||||
inline CivilDay NextWeekday(CivilDay cd, Weekday wd) { |
||||
return CivilDay(time_internal::cctz::next_weekday(cd, wd)); |
||||
} |
||||
inline CivilDay PrevWeekday(CivilDay cd, Weekday wd) { |
||||
return CivilDay(time_internal::cctz::prev_weekday(cd, wd)); |
||||
} |
||||
|
||||
// GetYearDay()
|
||||
//
|
||||
// Returns the day-of-year for the given absl::CivilDay.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::CivilDay a(2015, 1, 1);
|
||||
// int yd_jan_1 = absl::GetYearDay(a); // yd_jan_1 = 1
|
||||
// absl::CivilDay b(2015, 12, 31);
|
||||
// int yd_dec_31 = absl::GetYearDay(b); // yd_dec_31 = 365
|
||||
//
|
||||
inline int GetYearDay(CivilDay cd) { |
||||
return time_internal::cctz::get_yearday(cd); |
||||
} |
||||
|
||||
// FormatCivilTime()
|
||||
//
|
||||
// Formats the given civil-time value into a string value of the following
|
||||
// format:
|
||||
//
|
||||
// Type | Format
|
||||
// ---------------------------------
|
||||
// CivilSecond | YYYY-MM-DDTHH:MM:SS
|
||||
// CivilMinute | YYYY-MM-DDTHH:MM
|
||||
// CivilHour | YYYY-MM-DDTHH
|
||||
// CivilDay | YYYY-MM-DD
|
||||
// CivilMonth | YYYY-MM
|
||||
// CivilYear | YYYY
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::CivilDay d = absl::CivilDay(1969, 7, 20);
|
||||
// string day_string = absl::FormatCivilTime(d); // "1969-07-20"
|
||||
//
|
||||
std::string FormatCivilTime(CivilSecond c); |
||||
std::string FormatCivilTime(CivilMinute c); |
||||
std::string FormatCivilTime(CivilHour c); |
||||
std::string FormatCivilTime(CivilDay c); |
||||
std::string FormatCivilTime(CivilMonth c); |
||||
std::string FormatCivilTime(CivilYear c); |
||||
|
||||
namespace time_internal { // For functions found via ADL on civil-time tags.
|
||||
|
||||
// Streaming Operators
|
||||
//
|
||||
// Each civil-time type may be sent to an output stream using operator<<().
|
||||
// The result matches the string produced by `FormatCivilTime()`.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::CivilDay d = absl::CivilDay("1969-07-20");
|
||||
// std::cout << "Date is: " << d << "\n";
|
||||
//
|
||||
std::ostream& operator<<(std::ostream& os, CivilYear y); |
||||
std::ostream& operator<<(std::ostream& os, CivilMonth m); |
||||
std::ostream& operator<<(std::ostream& os, CivilDay d); |
||||
std::ostream& operator<<(std::ostream& os, CivilHour h); |
||||
std::ostream& operator<<(std::ostream& os, CivilMinute m); |
||||
std::ostream& operator<<(std::ostream& os, CivilSecond s); |
||||
|
||||
} // namespace time_internal
|
||||
|
||||
} // namespace absl
|
||||
|
||||
#endif // ABSL_TIME_CIVIL_TIME_H_
|
||||
@ -0,0 +1,57 @@ |
||||
// Copyright 2018 The Abseil Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "absl/time/civil_time.h" |
||||
|
||||
#include "benchmark/benchmark.h" |
||||
|
||||
namespace { |
||||
|
||||
// Benchmark Time(ns) CPU(ns) Iterations
|
||||
// -------------------------------------------------------------------------
|
||||
// BM_Difference_Days 20 20 34542508
|
||||
// BM_Step_Days 15 15 48098146
|
||||
// BM_Format 688 687 1019803
|
||||
// BM_Parse 921 920 762788
|
||||
// BM_RoundTripFormatParse 1766 1764 396092
|
||||
|
||||
void BM_Difference_Days(benchmark::State& state) { |
||||
const absl::CivilDay c(2014, 8, 22); |
||||
const absl::CivilDay epoch(1970, 1, 1); |
||||
while (state.KeepRunning()) { |
||||
const absl::civil_diff_t n = c - epoch; |
||||
benchmark::DoNotOptimize(n); |
||||
} |
||||
} |
||||
BENCHMARK(BM_Difference_Days); |
||||
|
||||
void BM_Step_Days(benchmark::State& state) { |
||||
const absl::CivilDay kStart(2014, 8, 22); |
||||
absl::CivilDay c = kStart; |
||||
while (state.KeepRunning()) { |
||||
benchmark::DoNotOptimize(++c); |
||||
} |
||||
} |
||||
BENCHMARK(BM_Step_Days); |
||||
|
||||
void BM_Format(benchmark::State& state) { |
||||
const absl::CivilSecond c(2014, 1, 2, 3, 4, 5); |
||||
while (state.KeepRunning()) { |
||||
const std::string s = absl::FormatCivilTime(c); |
||||
benchmark::DoNotOptimize(s); |
||||
} |
||||
} |
||||
BENCHMARK(BM_Format); |
||||
|
||||
} // namespace
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,306 +0,0 @@ |
||||
// Copyright 2017 The Abseil Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// This file contains tests for FromDateTime() normalization, which is
|
||||
// time-zone independent so we just use UTC throughout.
|
||||
|
||||
#include <cstdint> |
||||
#include <limits> |
||||
|
||||
#include "gmock/gmock.h" |
||||
#include "gtest/gtest.h" |
||||
#include "absl/time/internal/test_util.h" |
||||
#include "absl/time/time.h" |
||||
|
||||
namespace { |
||||
|
||||
TEST(TimeNormCase, SimpleOverflow) { |
||||
const absl::TimeZone utc = absl::UTCTimeZone(); |
||||
|
||||
absl::TimeConversion tc = |
||||
absl::ConvertDateTime(2013, 11, 15, 16, 32, 59 + 1, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
absl::Time::Breakdown bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 16, 33, 0, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11, 15, 16, 59 + 1, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 17, 0, 14, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11, 15, 23 + 1, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 16, 0, 32, 14, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11, 30 + 1, 16, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 12, 1, 16, 32, 14, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 12 + 1, 15, 16, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2014, 1, 15, 16, 32, 14, 0, false); |
||||
} |
||||
|
||||
TEST(TimeNormCase, SimpleUnderflow) { |
||||
const absl::TimeZone utc = absl::UTCTimeZone(); |
||||
|
||||
absl::TimeConversion tc = ConvertDateTime(2013, 11, 15, 16, 32, 0 - 1, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
absl::Time::Breakdown bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 16, 31, 59, 0, false); |
||||
|
||||
tc = ConvertDateTime(2013, 11, 15, 16, 0 - 1, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 15, 59, 14, 0, false); |
||||
|
||||
tc = ConvertDateTime(2013, 11, 15, 0 - 1, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 14, 23, 32, 14, 0, false); |
||||
|
||||
tc = ConvertDateTime(2013, 11, 1 - 1, 16, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 10, 31, 16, 32, 14, 0, false); |
||||
|
||||
tc = ConvertDateTime(2013, 1 - 1, 15, 16, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2012, 12, 15, 16, 32, 14, 0, false); |
||||
} |
||||
|
||||
TEST(TimeNormCase, MultipleOverflow) { |
||||
const absl::TimeZone utc = absl::UTCTimeZone(); |
||||
absl::TimeConversion tc = ConvertDateTime(2013, 12, 31, 23, 59, 59 + 1, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
absl::Time::Breakdown bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2014, 1, 1, 0, 0, 0, 0, false); |
||||
} |
||||
|
||||
TEST(TimeNormCase, MultipleUnderflow) { |
||||
const absl::TimeZone utc = absl::UTCTimeZone(); |
||||
absl::TimeConversion tc = absl::ConvertDateTime(2014, 1, 1, 0, 0, 0 - 1, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
absl::Time::Breakdown bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 12, 31, 23, 59, 59, 0, false); |
||||
} |
||||
|
||||
TEST(TimeNormCase, OverflowLimits) { |
||||
const absl::TimeZone utc = absl::UTCTimeZone(); |
||||
absl::TimeConversion tc; |
||||
absl::Time::Breakdown bd; |
||||
|
||||
const int kintmax = std::numeric_limits<int>::max(); |
||||
tc = absl::ConvertDateTime(0, kintmax, kintmax, kintmax, kintmax, kintmax, |
||||
utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 185085715, 11, 27, 12, 21, 7, 0, false); |
||||
|
||||
const int kintmin = std::numeric_limits<int>::min(); |
||||
tc = absl::ConvertDateTime(0, kintmin, kintmin, kintmin, kintmin, kintmin, |
||||
utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, -185085717, 10, 31, 10, 37, 52, 0, false); |
||||
|
||||
const int64_t max_year = std::numeric_limits<int64_t>::max(); |
||||
tc = absl::ConvertDateTime(max_year, 12, 31, 23, 59, 59, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
EXPECT_EQ(absl::InfiniteFuture(), tc.pre); |
||||
|
||||
const int64_t min_year = std::numeric_limits<int64_t>::min(); |
||||
tc = absl::ConvertDateTime(min_year, 1, 1, 0, 0, 0, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
EXPECT_EQ(absl::InfinitePast(), tc.pre); |
||||
} |
||||
|
||||
TEST(TimeNormCase, ComplexOverflow) { |
||||
const absl::TimeZone utc = absl::UTCTimeZone(); |
||||
|
||||
absl::TimeConversion tc = |
||||
ConvertDateTime(2013, 11, 15, 16, 32, 14 + 123456789, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
absl::Time::Breakdown bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2017, 10, 14, 14, 5, 23, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11, 15, 16, 32 + 1234567, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2016, 3, 22, 0, 39, 14, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11, 15, 16 + 123456, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2027, 12, 16, 16, 32, 14, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11, 15 + 1234, 16, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2017, 4, 2, 16, 32, 14, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11 + 123, 15, 16, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2024, 2, 15, 16, 32, 14, 0, false); |
||||
} |
||||
|
||||
TEST(TimeNormCase, ComplexUnderflow) { |
||||
const absl::TimeZone utc = absl::UTCTimeZone(); |
||||
|
||||
absl::TimeConversion tc = |
||||
absl::ConvertDateTime(1999, 3, 0, 0, 0, 0, utc); // year 400
|
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
absl::Time::Breakdown bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 1999, 2, 28, 0, 0, 0, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11, 15, 16, 32, 14 - 123456789, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2009, 12, 17, 18, 59, 5, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11, 15, 16, 32 - 1234567, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2011, 7, 12, 8, 25, 14, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11, 15, 16 - 123456, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 1999, 10, 16, 16, 32, 14, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11, 15 - 1234, 16, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2010, 6, 30, 16, 32, 14, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11 - 123, 15, 16, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2003, 8, 15, 16, 32, 14, 0, false); |
||||
} |
||||
|
||||
TEST(TimeNormCase, Mishmash) { |
||||
const absl::TimeZone utc = absl::UTCTimeZone(); |
||||
|
||||
absl::TimeConversion tc = |
||||
absl::ConvertDateTime(2013, 11 - 123, 15 + 1234, 16 - 123456, |
||||
32 + 1234567, 14 - 123456789, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
absl::Time::Breakdown bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 1991, 5, 9, 3, 6, 5, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2013, 11 + 123, 15 - 1234, 16 + 123456, |
||||
32 - 1234567, 14 + 123456789, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2036, 5, 24, 5, 58, 23, 0, false); |
||||
|
||||
// Here is a normalization case we got wrong for a while. Because the
|
||||
// day is converted to "1" within a 400-year (146097-day) period, we
|
||||
// didn't need to roll the month and so we didn't mark it as normalized.
|
||||
tc = absl::ConvertDateTime(2013, 11, -146097 + 1, 16, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 1613, 11, 1, 16, 32, 14, 0, false); |
||||
|
||||
// Even though the month overflow compensates for the day underflow,
|
||||
// this should still be marked as normalized.
|
||||
tc = absl::ConvertDateTime(2013, 11 + 400 * 12, -146097 + 1, 16, 32, 14, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 1, 16, 32, 14, 0, false); |
||||
} |
||||
|
||||
TEST(TimeNormCase, LeapYears) { |
||||
const absl::TimeZone utc = absl::UTCTimeZone(); |
||||
|
||||
absl::TimeConversion tc = |
||||
absl::ConvertDateTime(2013, 2, 28 + 1, 0, 0, 0, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
absl::Time::Breakdown bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 3, 1, 0, 0, 0, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2012, 2, 28 + 1, 0, 0, 0, utc); |
||||
EXPECT_FALSE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2012, 2, 29, 0, 0, 0, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(2000, 2, 28 + 1, 0, 0, 0, utc); |
||||
EXPECT_FALSE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 2000, 2, 29, 0, 0, 0, 0, false); |
||||
|
||||
tc = absl::ConvertDateTime(1900, 2, 28 + 1, 0, 0, 0, utc); |
||||
EXPECT_TRUE(tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
bd = tc.pre.In(utc); |
||||
ABSL_INTERNAL_EXPECT_TIME(bd, 1900, 3, 1, 0, 0, 0, 0, false); |
||||
} |
||||
|
||||
// Convert all the days from 1970-1-1 to 1970-1-146097 (aka 2369-12-31)
|
||||
// and check that they normalize to the expected time. 146097 days span
|
||||
// the 400-year Gregorian cycle used during normalization.
|
||||
TEST(TimeNormCase, AllTheDays) { |
||||
const absl::TimeZone utc = absl::UTCTimeZone(); |
||||
absl::Time exp_time = absl::UnixEpoch(); |
||||
|
||||
for (int day = 1; day <= 146097; ++day) { |
||||
absl::TimeConversion tc = absl::ConvertDateTime(1970, 1, day, 0, 0, 0, utc); |
||||
EXPECT_EQ(day > 31, tc.normalized); |
||||
EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind); |
||||
EXPECT_EQ(exp_time, tc.pre); |
||||
exp_time += absl::Hours(24); |
||||
} |
||||
} |
||||
|
||||
} // namespace
|
||||
Loading…
Reference in new issue