time_unittest.cc 91 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/time/time.h"
  5. #include <stdint.h>
  6. #include <time.h>
  7. #include <limits>
  8. #include <string>
  9. #include "base/build_time.h"
  10. #include "base/check_op.h"
  11. #include "base/compiler_specific.h"
  12. #include "base/environment.h"
  13. #include "base/test/gtest_util.h"
  14. #include "base/threading/platform_thread.h"
  15. #include "base/time/time_override.h"
  16. #include "build/build_config.h"
  17. #include "testing/gmock/include/gmock/gmock.h"
  18. #include "testing/gtest/include/gtest/gtest.h"
  19. #include "third_party/abseil-cpp/absl/types/optional.h"
  20. #include "third_party/icu/source/common/unicode/utypes.h"
  21. #include "third_party/icu/source/i18n/unicode/timezone.h"
  22. #if BUILDFLAG(IS_ANDROID)
  23. #include "base/android/jni_android.h"
  24. #elif BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_CHROMEOS)
  25. #include "base/test/icu_test_util.h"
  26. #elif BUILDFLAG(IS_WIN)
  27. #include <windows.h>
  28. #endif
  29. namespace base {
  30. namespace {
  31. #if BUILDFLAG(IS_FUCHSIA)
  32. // Hawaii does not observe daylight saving time, which is useful for having a
  33. // constant offset when faking the time zone.
  34. const char kHonoluluTimeZoneId[] = "Pacific/Honolulu";
  35. const int kHonoluluOffsetHours = -10;
  36. const int kHonoluluOffsetSeconds = kHonoluluOffsetHours * 60 * 60;
  37. #endif
  38. #if BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_CHROMEOS)
  39. const char kThaiLocale[] = "th-TH";
  40. const char kBangkokTimeZoneId[] = "Asia/Bangkok";
  41. // Returns the total offset (including Daylight Saving Time) of the timezone
  42. // with |timezone_id| at |time|, or absl::nullopt in case of failure.
  43. absl::optional<base::TimeDelta> GetTimeZoneOffsetAtTime(const char* timezone_id,
  44. Time time) {
  45. std::unique_ptr<icu::TimeZone> tz(icu::TimeZone::createTimeZone(timezone_id));
  46. if (*tz == icu::TimeZone::getUnknown()) {
  47. return {};
  48. }
  49. int32_t raw_offset = 0;
  50. int32_t dst_offset = 0;
  51. UErrorCode ec = U_ZERO_ERROR;
  52. tz->getOffset(time.ToDoubleT(), false, raw_offset, dst_offset, ec);
  53. if (!U_SUCCESS(ec)) {
  54. return {};
  55. }
  56. return base::Milliseconds(raw_offset + dst_offset);
  57. }
  58. TimeDelta TimePassedAfterMidnight(const Time::Exploded& time) {
  59. return base::Hours(time.hour) + base::Minutes(time.minute) +
  60. base::Seconds(time.second) + base::Milliseconds(time.millisecond);
  61. }
  62. // Timezone environment variable
  63. class ScopedLibcTZ {
  64. public:
  65. explicit ScopedLibcTZ(const std::string& timezone) {
  66. auto env = base::Environment::Create();
  67. std::string old_timezone_value;
  68. if (env->GetVar(kTZ, &old_timezone_value)) {
  69. old_timezone_ = old_timezone_value;
  70. }
  71. if (!env->SetVar(kTZ, timezone)) {
  72. success_ = false;
  73. }
  74. tzset();
  75. }
  76. ~ScopedLibcTZ() {
  77. auto env = base::Environment::Create();
  78. if (old_timezone_.has_value()) {
  79. CHECK(env->SetVar(kTZ, old_timezone_.value()));
  80. } else {
  81. CHECK(env->UnSetVar(kTZ));
  82. }
  83. }
  84. ScopedLibcTZ(const ScopedLibcTZ& other) = delete;
  85. ScopedLibcTZ& operator=(const ScopedLibcTZ& other) = delete;
  86. bool is_success() const { return success_; }
  87. private:
  88. static constexpr char kTZ[] = "TZ";
  89. bool success_ = true;
  90. absl::optional<std::string> old_timezone_;
  91. };
  92. constexpr char ScopedLibcTZ::kTZ[];
  93. #endif // BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_CHROMEOS)
  94. TEST(TimeTestOutOfBounds, FromExplodedOutOfBoundsTime) {
  95. // FromUTCExploded must set time to Time(0) and failure, if the day is set to
  96. // 31 on a 28-30 day month. Test |exploded| returns Time(0) on 31st of
  97. // February and 31st of April. New implementation handles this.
  98. const struct DateTestData {
  99. Time::Exploded explode;
  100. bool is_valid;
  101. } kDateTestData[] = {
  102. // 31st of February
  103. {{2016, 2, 0, 31, 12, 30, 0, 0}, true},
  104. // 31st of April
  105. {{2016, 4, 0, 31, 8, 43, 0, 0}, true},
  106. // Negative month
  107. {{2016, -5, 0, 2, 4, 10, 0, 0}, false},
  108. // Negative date of month
  109. {{2016, 6, 0, -15, 2, 50, 0, 0}, false},
  110. // Negative hours
  111. {{2016, 7, 0, 10, -11, 29, 0, 0}, false},
  112. // Negative minutes
  113. {{2016, 3, 0, 14, 10, -29, 0, 0}, false},
  114. // Negative seconds
  115. {{2016, 10, 0, 25, 7, 47, -30, 0}, false},
  116. // Negative milliseconds
  117. {{2016, 10, 0, 25, 7, 47, 20, -500}, false},
  118. // Hours are too large
  119. {{2016, 7, 0, 10, 26, 29, 0, 0}, false},
  120. // Minutes are too large
  121. {{2016, 3, 0, 14, 10, 78, 0, 0}, false},
  122. // Seconds are too large
  123. {{2016, 10, 0, 25, 7, 47, 234, 0}, false},
  124. // Milliseconds are too large
  125. {{2016, 10, 0, 25, 6, 31, 23, 1643}, false},
  126. // Test overflow. Time is valid, but overflow case
  127. // results in Time(0).
  128. {{9840633, 1, 0, 1, 1, 1, 0, 0}, true},
  129. // Underflow will fail as well.
  130. {{-9840633, 1, 0, 1, 1, 1, 0, 0}, true},
  131. // Test integer overflow and underflow cases for the values themselves.
  132. {{std::numeric_limits<int>::min(), 1, 0, 1, 1, 1, 0, 0}, true},
  133. {{std::numeric_limits<int>::max(), 1, 0, 1, 1, 1, 0, 0}, true},
  134. {{2016, std::numeric_limits<int>::min(), 0, 1, 1, 1, 0, 0}, false},
  135. {{2016, std::numeric_limits<int>::max(), 0, 1, 1, 1, 0, 0}, false},
  136. };
  137. for (const auto& test : kDateTestData) {
  138. EXPECT_EQ(test.explode.HasValidValues(), test.is_valid);
  139. base::Time result;
  140. EXPECT_FALSE(base::Time::FromUTCExploded(test.explode, &result));
  141. EXPECT_TRUE(result.is_null());
  142. EXPECT_FALSE(base::Time::FromLocalExploded(test.explode, &result));
  143. EXPECT_TRUE(result.is_null());
  144. }
  145. }
  146. // Specialized test fixture allowing time strings without timezones to be
  147. // tested by comparing them to a known time in the local zone.
  148. // See also pr_time_unittests.cc
  149. class TimeTest : public testing::Test {
  150. protected:
  151. #if BUILDFLAG(IS_FUCHSIA)
  152. // POSIX local time functions always use UTC on Fuchsia. As this is not very
  153. // interesting for any "local" tests, set a different default ICU timezone for
  154. // the test. This only affects code that uses ICU, such as Exploded time.
  155. // Chicago is a non-Pacific time zone known to observe daylight saving time.
  156. TimeTest() : chicago_time_("America/Chicago") {}
  157. test::ScopedRestoreDefaultTimezone chicago_time_;
  158. #endif
  159. void SetUp() override {
  160. // Use mktime to get a time_t, and turn it into a PRTime by converting
  161. // seconds to microseconds. Use 15th Oct 2007 12:45:00 local. This
  162. // must be a time guaranteed to be outside of a DST fallback hour in
  163. // any timezone.
  164. struct tm local_comparison_tm = {
  165. 0, // second
  166. 45, // minute
  167. 12, // hour
  168. 15, // day of month
  169. 10 - 1, // month
  170. 2007 - 1900, // year
  171. 0, // day of week (ignored, output only)
  172. 0, // day of year (ignored, output only)
  173. -1 // DST in effect, -1 tells mktime to figure it out
  174. };
  175. time_t converted_time = mktime(&local_comparison_tm);
  176. ASSERT_GT(converted_time, 0);
  177. comparison_time_local_ = Time::FromTimeT(converted_time);
  178. // time_t representation of 15th Oct 2007 12:45:00 PDT
  179. comparison_time_pdt_ = Time::FromTimeT(1192477500);
  180. }
  181. Time comparison_time_local_;
  182. Time comparison_time_pdt_;
  183. };
  184. // Test conversion to/from TimeDeltas elapsed since the Windows epoch.
  185. // Conversions should be idempotent and non-lossy.
  186. TEST_F(TimeTest, DeltaSinceWindowsEpoch) {
  187. constexpr TimeDelta delta = Microseconds(123);
  188. EXPECT_EQ(delta,
  189. Time::FromDeltaSinceWindowsEpoch(delta).ToDeltaSinceWindowsEpoch());
  190. const Time now = Time::Now();
  191. const Time actual =
  192. Time::FromDeltaSinceWindowsEpoch(now.ToDeltaSinceWindowsEpoch());
  193. EXPECT_EQ(now, actual);
  194. // Null times should remain null after a round-trip conversion. This is an
  195. // important invariant for the common use case of serialization +
  196. // deserialization.
  197. const Time should_be_null =
  198. Time::FromDeltaSinceWindowsEpoch(Time().ToDeltaSinceWindowsEpoch());
  199. EXPECT_TRUE(should_be_null.is_null());
  200. {
  201. constexpr Time constexpr_time =
  202. Time::FromDeltaSinceWindowsEpoch(Microseconds(123));
  203. constexpr TimeDelta constexpr_delta =
  204. constexpr_time.ToDeltaSinceWindowsEpoch();
  205. static_assert(constexpr_delta == delta, "");
  206. }
  207. }
  208. // Test conversion to/from time_t.
  209. TEST_F(TimeTest, TimeT) {
  210. EXPECT_EQ(10, Time().FromTimeT(10).ToTimeT());
  211. EXPECT_EQ(10.0, Time().FromTimeT(10).ToDoubleT());
  212. // Conversions of 0 should stay 0.
  213. EXPECT_EQ(0, Time().ToTimeT());
  214. EXPECT_EQ(0, Time::FromTimeT(0).ToInternalValue());
  215. }
  216. // Test conversions to/from time_t and exploding/unexploding (utc time).
  217. TEST_F(TimeTest, UTCTimeT) {
  218. // C library time and exploded time.
  219. time_t now_t_1 = time(nullptr);
  220. struct tm tms;
  221. #if BUILDFLAG(IS_WIN)
  222. gmtime_s(&tms, &now_t_1);
  223. #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
  224. gmtime_r(&now_t_1, &tms);
  225. #endif
  226. // Convert to ours.
  227. Time our_time_1 = Time::FromTimeT(now_t_1);
  228. Time::Exploded exploded;
  229. our_time_1.UTCExplode(&exploded);
  230. // This will test both our exploding and our time_t -> Time conversion.
  231. EXPECT_EQ(tms.tm_year + 1900, exploded.year);
  232. EXPECT_EQ(tms.tm_mon + 1, exploded.month);
  233. EXPECT_EQ(tms.tm_mday, exploded.day_of_month);
  234. EXPECT_EQ(tms.tm_hour, exploded.hour);
  235. EXPECT_EQ(tms.tm_min, exploded.minute);
  236. EXPECT_EQ(tms.tm_sec, exploded.second);
  237. // Convert exploded back to the time struct.
  238. Time our_time_2;
  239. EXPECT_TRUE(Time::FromUTCExploded(exploded, &our_time_2));
  240. EXPECT_TRUE(our_time_1 == our_time_2);
  241. time_t now_t_2 = our_time_2.ToTimeT();
  242. EXPECT_EQ(now_t_1, now_t_2);
  243. }
  244. // Test conversions to/from time_t and exploding/unexploding (local time).
  245. TEST_F(TimeTest, LocalTimeT) {
  246. // C library time and exploded time.
  247. time_t now_t_1 = time(nullptr);
  248. struct tm tms;
  249. #if BUILDFLAG(IS_WIN)
  250. localtime_s(&tms, &now_t_1);
  251. #elif BUILDFLAG(IS_POSIX)
  252. localtime_r(&now_t_1, &tms);
  253. #elif BUILDFLAG(IS_FUCHSIA)
  254. // POSIX local time functions always use UTC on Fuchsia, so set a known time
  255. // zone and manually obtain the local |tms| values by using an adjusted input.
  256. test::ScopedRestoreDefaultTimezone honolulu_time(kHonoluluTimeZoneId);
  257. time_t adjusted_now_t_1 = now_t_1 + kHonoluluOffsetSeconds;
  258. localtime_r(&adjusted_now_t_1, &tms);
  259. #endif
  260. // Convert to ours.
  261. Time our_time_1 = Time::FromTimeT(now_t_1);
  262. Time::Exploded exploded;
  263. our_time_1.LocalExplode(&exploded);
  264. // This will test both our exploding and our time_t -> Time conversion.
  265. EXPECT_EQ(tms.tm_year + 1900, exploded.year);
  266. EXPECT_EQ(tms.tm_mon + 1, exploded.month);
  267. EXPECT_EQ(tms.tm_mday, exploded.day_of_month);
  268. EXPECT_EQ(tms.tm_hour, exploded.hour);
  269. EXPECT_EQ(tms.tm_min, exploded.minute);
  270. EXPECT_EQ(tms.tm_sec, exploded.second);
  271. // Convert exploded back to the time struct.
  272. Time our_time_2;
  273. EXPECT_TRUE(Time::FromLocalExploded(exploded, &our_time_2));
  274. EXPECT_TRUE(our_time_1 == our_time_2);
  275. time_t now_t_2 = our_time_2.ToTimeT();
  276. EXPECT_EQ(now_t_1, now_t_2);
  277. }
  278. // Test conversions to/from javascript time.
  279. TEST_F(TimeTest, JsTime) {
  280. Time epoch = Time::FromJsTime(0.0);
  281. EXPECT_EQ(epoch, Time::UnixEpoch());
  282. Time t = Time::FromJsTime(700000.3);
  283. EXPECT_EQ(700.0003, t.ToDoubleT());
  284. t = Time::FromDoubleT(800.73);
  285. EXPECT_EQ(800730.0, t.ToJsTime());
  286. // 1601-01-01 isn't round-trip with ToJsTime().
  287. const double kWindowsEpoch = -11644473600000.0;
  288. Time time = Time::FromJsTime(kWindowsEpoch);
  289. EXPECT_TRUE(time.is_null());
  290. EXPECT_NE(kWindowsEpoch, time.ToJsTime());
  291. EXPECT_EQ(kWindowsEpoch, time.ToJsTimeIgnoringNull());
  292. }
  293. #if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
  294. TEST_F(TimeTest, FromTimeVal) {
  295. Time now = Time::Now();
  296. Time also_now = Time::FromTimeVal(now.ToTimeVal());
  297. EXPECT_EQ(now, also_now);
  298. }
  299. #endif // BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
  300. TEST_F(TimeTest, FromExplodedWithMilliseconds) {
  301. // Some platform implementations of FromExploded are liable to drop
  302. // milliseconds if we aren't careful.
  303. Time now = Time::NowFromSystemTime();
  304. Time::Exploded exploded1 = {0};
  305. now.UTCExplode(&exploded1);
  306. exploded1.millisecond = 500;
  307. Time time;
  308. EXPECT_TRUE(Time::FromUTCExploded(exploded1, &time));
  309. Time::Exploded exploded2 = {0};
  310. time.UTCExplode(&exploded2);
  311. EXPECT_EQ(exploded1.millisecond, exploded2.millisecond);
  312. }
  313. TEST_F(TimeTest, ZeroIsSymmetric) {
  314. Time zero_time(Time::FromTimeT(0));
  315. EXPECT_EQ(0, zero_time.ToTimeT());
  316. EXPECT_EQ(0.0, zero_time.ToDoubleT());
  317. }
  318. // Note that this test does not check whether the implementation correctly
  319. // accounts for the local time zone.
  320. TEST_F(TimeTest, LocalExplode) {
  321. Time a = Time::Now();
  322. Time::Exploded exploded;
  323. a.LocalExplode(&exploded);
  324. Time b;
  325. EXPECT_TRUE(Time::FromLocalExploded(exploded, &b));
  326. // The exploded structure doesn't have microseconds, and on Mac & Linux, the
  327. // internal OS conversion uses seconds, which will cause truncation. So we
  328. // can only make sure that the delta is within one second.
  329. EXPECT_LT(a - b, Seconds(1));
  330. }
  331. TEST_F(TimeTest, UTCExplode) {
  332. Time a = Time::Now();
  333. Time::Exploded exploded;
  334. a.UTCExplode(&exploded);
  335. Time b;
  336. EXPECT_TRUE(Time::FromUTCExploded(exploded, &b));
  337. // The exploded structure doesn't have microseconds, and on Mac & Linux, the
  338. // internal OS conversion uses seconds, which will cause truncation. So we
  339. // can only make sure that the delta is within one second.
  340. EXPECT_LT(a - b, Seconds(1));
  341. }
  342. TEST_F(TimeTest, UTCMidnight) {
  343. Time::Exploded exploded;
  344. Time::Now().UTCMidnight().UTCExplode(&exploded);
  345. EXPECT_EQ(0, exploded.hour);
  346. EXPECT_EQ(0, exploded.minute);
  347. EXPECT_EQ(0, exploded.second);
  348. EXPECT_EQ(0, exploded.millisecond);
  349. }
  350. // Note that this test does not check whether the implementation correctly
  351. // accounts for the local time zone.
  352. TEST_F(TimeTest, LocalMidnight) {
  353. Time::Exploded exploded;
  354. Time::Now().LocalMidnight().LocalExplode(&exploded);
  355. EXPECT_EQ(0, exploded.hour);
  356. EXPECT_EQ(0, exploded.minute);
  357. EXPECT_EQ(0, exploded.second);
  358. EXPECT_EQ(0, exploded.millisecond);
  359. }
  360. // These tests require the ability to fake the local time zone.
  361. #if BUILDFLAG(IS_FUCHSIA)
  362. TEST_F(TimeTest, LocalExplodeIsLocal) {
  363. // Set the default time zone to a zone with an offset different from UTC.
  364. test::ScopedRestoreDefaultTimezone honolulu_time(kHonoluluTimeZoneId);
  365. // The member contains useful values for this test, which uses it as UTC.
  366. Time comparison_time_utc(comparison_time_local_);
  367. Time::Exploded utc_exploded;
  368. comparison_time_utc.UTCExplode(&utc_exploded);
  369. Time::Exploded local_exploded;
  370. comparison_time_utc.LocalExplode(&local_exploded);
  371. // The year, month, and day are the same because the (negative) offset is
  372. // smaller than the hour in the test time. Similarly, there is no underflow
  373. // for hour.
  374. EXPECT_EQ(utc_exploded.year, local_exploded.year);
  375. EXPECT_EQ(utc_exploded.month, local_exploded.month);
  376. EXPECT_EQ(utc_exploded.day_of_week, local_exploded.day_of_week);
  377. EXPECT_EQ(utc_exploded.day_of_month, local_exploded.day_of_month);
  378. EXPECT_EQ(utc_exploded.hour + kHonoluluOffsetHours, local_exploded.hour);
  379. EXPECT_EQ(utc_exploded.minute, local_exploded.minute);
  380. EXPECT_EQ(utc_exploded.second, local_exploded.second);
  381. EXPECT_EQ(utc_exploded.millisecond, local_exploded.millisecond);
  382. Time time_from_local_exploded;
  383. EXPECT_TRUE(
  384. Time::FromLocalExploded(local_exploded, &time_from_local_exploded));
  385. EXPECT_EQ(comparison_time_utc, time_from_local_exploded);
  386. // Unexplode the local time using the non-local method.
  387. // The resulting time should be offset hours earlier.
  388. Time time_from_utc_exploded;
  389. EXPECT_TRUE(Time::FromUTCExploded(local_exploded, &time_from_utc_exploded));
  390. EXPECT_EQ(comparison_time_utc + Hours(kHonoluluOffsetHours),
  391. time_from_utc_exploded);
  392. }
  393. TEST_F(TimeTest, LocalMidnightIsLocal) {
  394. // Set the default time zone to a zone with an offset different from UTC.
  395. test::ScopedRestoreDefaultTimezone honolulu_time(kHonoluluTimeZoneId);
  396. // The member contains useful values for this test, which uses it as UTC.
  397. Time comparison_time_utc(comparison_time_local_);
  398. Time::Exploded utc_midnight_exploded;
  399. comparison_time_utc.UTCMidnight().UTCExplode(&utc_midnight_exploded);
  400. // Local midnight exploded in UTC will have an offset hour instead of 0.
  401. Time::Exploded local_midnight_utc_exploded;
  402. comparison_time_utc.LocalMidnight().UTCExplode(&local_midnight_utc_exploded);
  403. // The year, month, and day are the same because the (negative) offset is
  404. // smaller than the hour in the test time and thus both midnights round down
  405. // on the same day.
  406. EXPECT_EQ(utc_midnight_exploded.year, local_midnight_utc_exploded.year);
  407. EXPECT_EQ(utc_midnight_exploded.month, local_midnight_utc_exploded.month);
  408. EXPECT_EQ(utc_midnight_exploded.day_of_week,
  409. local_midnight_utc_exploded.day_of_week);
  410. EXPECT_EQ(utc_midnight_exploded.day_of_month,
  411. local_midnight_utc_exploded.day_of_month);
  412. EXPECT_EQ(0, utc_midnight_exploded.hour);
  413. EXPECT_EQ(0 - kHonoluluOffsetHours, local_midnight_utc_exploded.hour);
  414. EXPECT_EQ(0, local_midnight_utc_exploded.minute);
  415. EXPECT_EQ(0, local_midnight_utc_exploded.second);
  416. EXPECT_EQ(0, local_midnight_utc_exploded.millisecond);
  417. // Local midnight exploded in local time will have no offset.
  418. Time::Exploded local_midnight_exploded;
  419. comparison_time_utc.LocalMidnight().LocalExplode(&local_midnight_exploded);
  420. EXPECT_EQ(utc_midnight_exploded.year, local_midnight_exploded.year);
  421. EXPECT_EQ(utc_midnight_exploded.month, local_midnight_exploded.month);
  422. EXPECT_EQ(utc_midnight_exploded.day_of_week,
  423. local_midnight_exploded.day_of_week);
  424. EXPECT_EQ(utc_midnight_exploded.day_of_month,
  425. local_midnight_exploded.day_of_month);
  426. EXPECT_EQ(0, local_midnight_exploded.hour);
  427. EXPECT_EQ(0, local_midnight_exploded.minute);
  428. EXPECT_EQ(0, local_midnight_exploded.second);
  429. EXPECT_EQ(0, local_midnight_exploded.millisecond);
  430. }
  431. #endif // BUILDFLAG(IS_FUCHSIA)
  432. TEST_F(TimeTest, ParseTimeTest1) {
  433. time_t current_time = 0;
  434. time(&current_time);
  435. struct tm local_time = {};
  436. char time_buf[64] = {};
  437. #if BUILDFLAG(IS_WIN)
  438. localtime_s(&local_time, &current_time);
  439. asctime_s(time_buf, std::size(time_buf), &local_time);
  440. #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
  441. localtime_r(&current_time, &local_time);
  442. asctime_r(&local_time, time_buf);
  443. #endif
  444. Time parsed_time;
  445. EXPECT_TRUE(Time::FromString(time_buf, &parsed_time));
  446. EXPECT_EQ(current_time, parsed_time.ToTimeT());
  447. }
  448. TEST_F(TimeTest, DayOfWeekSunday) {
  449. Time time;
  450. EXPECT_TRUE(Time::FromString("Sun, 06 May 2012 12:00:00 GMT", &time));
  451. Time::Exploded exploded;
  452. time.UTCExplode(&exploded);
  453. EXPECT_EQ(0, exploded.day_of_week);
  454. }
  455. TEST_F(TimeTest, DayOfWeekWednesday) {
  456. Time time;
  457. EXPECT_TRUE(Time::FromString("Wed, 09 May 2012 12:00:00 GMT", &time));
  458. Time::Exploded exploded;
  459. time.UTCExplode(&exploded);
  460. EXPECT_EQ(3, exploded.day_of_week);
  461. }
  462. TEST_F(TimeTest, DayOfWeekSaturday) {
  463. Time time;
  464. EXPECT_TRUE(Time::FromString("Sat, 12 May 2012 12:00:00 GMT", &time));
  465. Time::Exploded exploded;
  466. time.UTCExplode(&exploded);
  467. EXPECT_EQ(6, exploded.day_of_week);
  468. }
  469. TEST_F(TimeTest, ParseTimeTest2) {
  470. Time parsed_time;
  471. EXPECT_TRUE(Time::FromString("Mon, 15 Oct 2007 19:45:00 GMT", &parsed_time));
  472. EXPECT_EQ(comparison_time_pdt_, parsed_time);
  473. }
  474. TEST_F(TimeTest, ParseTimeTest3) {
  475. Time parsed_time;
  476. EXPECT_TRUE(Time::FromString("15 Oct 07 12:45:00", &parsed_time));
  477. EXPECT_EQ(comparison_time_local_, parsed_time);
  478. }
  479. TEST_F(TimeTest, ParseTimeTest4) {
  480. Time parsed_time;
  481. EXPECT_TRUE(Time::FromString("15 Oct 07 19:45 GMT", &parsed_time));
  482. EXPECT_EQ(comparison_time_pdt_, parsed_time);
  483. }
  484. TEST_F(TimeTest, ParseTimeTest5) {
  485. Time parsed_time;
  486. EXPECT_TRUE(Time::FromString("Mon Oct 15 12:45 PDT 2007", &parsed_time));
  487. EXPECT_EQ(comparison_time_pdt_, parsed_time);
  488. }
  489. TEST_F(TimeTest, ParseTimeTest6) {
  490. Time parsed_time;
  491. EXPECT_TRUE(Time::FromString("Monday, Oct 15, 2007 12:45 PM", &parsed_time));
  492. EXPECT_EQ(comparison_time_local_, parsed_time);
  493. }
  494. TEST_F(TimeTest, ParseTimeTest7) {
  495. Time parsed_time;
  496. EXPECT_TRUE(Time::FromString("10/15/07 12:45:00 PM", &parsed_time));
  497. EXPECT_EQ(comparison_time_local_, parsed_time);
  498. }
  499. TEST_F(TimeTest, ParseTimeTest8) {
  500. Time parsed_time;
  501. EXPECT_TRUE(Time::FromString("15-OCT-2007 12:45pm", &parsed_time));
  502. EXPECT_EQ(comparison_time_local_, parsed_time);
  503. }
  504. TEST_F(TimeTest, ParseTimeTest9) {
  505. Time parsed_time;
  506. EXPECT_TRUE(Time::FromString("16 Oct 2007 4:45-JST (Tuesday)", &parsed_time));
  507. EXPECT_EQ(comparison_time_pdt_, parsed_time);
  508. }
  509. TEST_F(TimeTest, ParseTimeTest10) {
  510. Time parsed_time;
  511. EXPECT_TRUE(Time::FromString("15/10/07 12:45", &parsed_time));
  512. EXPECT_EQ(parsed_time, comparison_time_local_);
  513. }
  514. // Test some of edge cases around epoch, etc.
  515. TEST_F(TimeTest, ParseTimeTestEpoch0) {
  516. Time parsed_time;
  517. // time_t == epoch == 0
  518. EXPECT_TRUE(Time::FromString("Thu Jan 01 01:00:00 +0100 1970",
  519. &parsed_time));
  520. EXPECT_EQ(0, parsed_time.ToTimeT());
  521. EXPECT_TRUE(Time::FromString("Thu Jan 01 00:00:00 GMT 1970",
  522. &parsed_time));
  523. EXPECT_EQ(0, parsed_time.ToTimeT());
  524. }
  525. TEST_F(TimeTest, ParseTimeTestEpoch1) {
  526. Time parsed_time;
  527. // time_t == 1 second after epoch == 1
  528. EXPECT_TRUE(Time::FromString("Thu Jan 01 01:00:01 +0100 1970",
  529. &parsed_time));
  530. EXPECT_EQ(1, parsed_time.ToTimeT());
  531. EXPECT_TRUE(Time::FromString("Thu Jan 01 00:00:01 GMT 1970",
  532. &parsed_time));
  533. EXPECT_EQ(1, parsed_time.ToTimeT());
  534. }
  535. TEST_F(TimeTest, ParseTimeTestEpoch2) {
  536. Time parsed_time;
  537. // time_t == 2 seconds after epoch == 2
  538. EXPECT_TRUE(Time::FromString("Thu Jan 01 01:00:02 +0100 1970",
  539. &parsed_time));
  540. EXPECT_EQ(2, parsed_time.ToTimeT());
  541. EXPECT_TRUE(Time::FromString("Thu Jan 01 00:00:02 GMT 1970",
  542. &parsed_time));
  543. EXPECT_EQ(2, parsed_time.ToTimeT());
  544. }
  545. TEST_F(TimeTest, ParseTimeTestEpochNeg1) {
  546. Time parsed_time;
  547. // time_t == 1 second before epoch == -1
  548. EXPECT_TRUE(Time::FromString("Thu Jan 01 00:59:59 +0100 1970",
  549. &parsed_time));
  550. EXPECT_EQ(-1, parsed_time.ToTimeT());
  551. EXPECT_TRUE(Time::FromString("Wed Dec 31 23:59:59 GMT 1969",
  552. &parsed_time));
  553. EXPECT_EQ(-1, parsed_time.ToTimeT());
  554. }
  555. // If time_t is 32 bits, a date after year 2038 will overflow time_t and
  556. // cause timegm() to return -1. The parsed time should not be 1 second
  557. // before epoch.
  558. TEST_F(TimeTest, ParseTimeTestEpochNotNeg1) {
  559. Time parsed_time;
  560. EXPECT_TRUE(Time::FromString("Wed Dec 31 23:59:59 GMT 2100",
  561. &parsed_time));
  562. EXPECT_NE(-1, parsed_time.ToTimeT());
  563. }
  564. TEST_F(TimeTest, ParseTimeTestEpochNeg2) {
  565. Time parsed_time;
  566. // time_t == 2 seconds before epoch == -2
  567. EXPECT_TRUE(Time::FromString("Thu Jan 01 00:59:58 +0100 1970",
  568. &parsed_time));
  569. EXPECT_EQ(-2, parsed_time.ToTimeT());
  570. EXPECT_TRUE(Time::FromString("Wed Dec 31 23:59:58 GMT 1969",
  571. &parsed_time));
  572. EXPECT_EQ(-2, parsed_time.ToTimeT());
  573. }
  574. TEST_F(TimeTest, ParseTimeTestEpoch1960) {
  575. Time parsed_time;
  576. // time_t before Epoch, in 1960
  577. EXPECT_TRUE(Time::FromString("Wed Jun 29 19:40:01 +0100 1960",
  578. &parsed_time));
  579. EXPECT_EQ(-299999999, parsed_time.ToTimeT());
  580. EXPECT_TRUE(Time::FromString("Wed Jun 29 18:40:01 GMT 1960",
  581. &parsed_time));
  582. EXPECT_EQ(-299999999, parsed_time.ToTimeT());
  583. EXPECT_TRUE(Time::FromString("Wed Jun 29 17:40:01 GMT 1960",
  584. &parsed_time));
  585. EXPECT_EQ(-300003599, parsed_time.ToTimeT());
  586. }
  587. TEST_F(TimeTest, ParseTimeTestEmpty) {
  588. Time parsed_time;
  589. EXPECT_FALSE(Time::FromString("", &parsed_time));
  590. }
  591. TEST_F(TimeTest, ParseTimeTestInvalidString) {
  592. Time parsed_time;
  593. EXPECT_FALSE(Time::FromString("Monday morning 2000", &parsed_time));
  594. }
  595. TEST_F(TimeTest, ExplodeBeforeUnixEpoch) {
  596. static const int kUnixEpochYear = 1970; // In case this changes (ha!).
  597. Time t;
  598. Time::Exploded exploded;
  599. t = Time::UnixEpoch() - Microseconds(1);
  600. t.UTCExplode(&exploded);
  601. EXPECT_TRUE(exploded.HasValidValues());
  602. // Should be 1969-12-31 23:59:59 999 milliseconds (and 999 microseconds).
  603. EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
  604. EXPECT_EQ(12, exploded.month);
  605. EXPECT_EQ(31, exploded.day_of_month);
  606. EXPECT_EQ(23, exploded.hour);
  607. EXPECT_EQ(59, exploded.minute);
  608. EXPECT_EQ(59, exploded.second);
  609. EXPECT_EQ(999, exploded.millisecond);
  610. t = Time::UnixEpoch() - Microseconds(999);
  611. t.UTCExplode(&exploded);
  612. EXPECT_TRUE(exploded.HasValidValues());
  613. // Should be 1969-12-31 23:59:59 999 milliseconds (and 1 microsecond).
  614. EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
  615. EXPECT_EQ(12, exploded.month);
  616. EXPECT_EQ(31, exploded.day_of_month);
  617. EXPECT_EQ(23, exploded.hour);
  618. EXPECT_EQ(59, exploded.minute);
  619. EXPECT_EQ(59, exploded.second);
  620. EXPECT_EQ(999, exploded.millisecond);
  621. t = Time::UnixEpoch() - Microseconds(1000);
  622. t.UTCExplode(&exploded);
  623. EXPECT_TRUE(exploded.HasValidValues());
  624. // Should be 1969-12-31 23:59:59 999 milliseconds.
  625. EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
  626. EXPECT_EQ(12, exploded.month);
  627. EXPECT_EQ(31, exploded.day_of_month);
  628. EXPECT_EQ(23, exploded.hour);
  629. EXPECT_EQ(59, exploded.minute);
  630. EXPECT_EQ(59, exploded.second);
  631. EXPECT_EQ(999, exploded.millisecond);
  632. t = Time::UnixEpoch() - Microseconds(1001);
  633. t.UTCExplode(&exploded);
  634. EXPECT_TRUE(exploded.HasValidValues());
  635. // Should be 1969-12-31 23:59:59 998 milliseconds (and 999 microseconds).
  636. EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
  637. EXPECT_EQ(12, exploded.month);
  638. EXPECT_EQ(31, exploded.day_of_month);
  639. EXPECT_EQ(23, exploded.hour);
  640. EXPECT_EQ(59, exploded.minute);
  641. EXPECT_EQ(59, exploded.second);
  642. EXPECT_EQ(998, exploded.millisecond);
  643. t = Time::UnixEpoch() - Milliseconds(1000);
  644. t.UTCExplode(&exploded);
  645. EXPECT_TRUE(exploded.HasValidValues());
  646. // Should be 1969-12-31 23:59:59.
  647. EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
  648. EXPECT_EQ(12, exploded.month);
  649. EXPECT_EQ(31, exploded.day_of_month);
  650. EXPECT_EQ(23, exploded.hour);
  651. EXPECT_EQ(59, exploded.minute);
  652. EXPECT_EQ(59, exploded.second);
  653. EXPECT_EQ(0, exploded.millisecond);
  654. t = Time::UnixEpoch() - Milliseconds(1001);
  655. t.UTCExplode(&exploded);
  656. EXPECT_TRUE(exploded.HasValidValues());
  657. // Should be 1969-12-31 23:59:58 999 milliseconds.
  658. EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
  659. EXPECT_EQ(12, exploded.month);
  660. EXPECT_EQ(31, exploded.day_of_month);
  661. EXPECT_EQ(23, exploded.hour);
  662. EXPECT_EQ(59, exploded.minute);
  663. EXPECT_EQ(58, exploded.second);
  664. EXPECT_EQ(999, exploded.millisecond);
  665. // Make sure we still handle at/after Unix epoch correctly.
  666. t = Time::UnixEpoch();
  667. t.UTCExplode(&exploded);
  668. EXPECT_TRUE(exploded.HasValidValues());
  669. // Should be 1970-12-31 00:00:00 0 milliseconds.
  670. EXPECT_EQ(kUnixEpochYear, exploded.year);
  671. EXPECT_EQ(1, exploded.month);
  672. EXPECT_EQ(1, exploded.day_of_month);
  673. EXPECT_EQ(0, exploded.hour);
  674. EXPECT_EQ(0, exploded.minute);
  675. EXPECT_EQ(0, exploded.second);
  676. EXPECT_EQ(0, exploded.millisecond);
  677. t = Time::UnixEpoch() + Microseconds(1);
  678. t.UTCExplode(&exploded);
  679. EXPECT_TRUE(exploded.HasValidValues());
  680. // Should be 1970-01-01 00:00:00 0 milliseconds (and 1 microsecond).
  681. EXPECT_EQ(kUnixEpochYear, exploded.year);
  682. EXPECT_EQ(1, exploded.month);
  683. EXPECT_EQ(1, exploded.day_of_month);
  684. EXPECT_EQ(0, exploded.hour);
  685. EXPECT_EQ(0, exploded.minute);
  686. EXPECT_EQ(0, exploded.second);
  687. EXPECT_EQ(0, exploded.millisecond);
  688. t = Time::UnixEpoch() + Microseconds(999);
  689. t.UTCExplode(&exploded);
  690. EXPECT_TRUE(exploded.HasValidValues());
  691. // Should be 1970-01-01 00:00:00 0 milliseconds (and 999 microseconds).
  692. EXPECT_EQ(kUnixEpochYear, exploded.year);
  693. EXPECT_EQ(1, exploded.month);
  694. EXPECT_EQ(1, exploded.day_of_month);
  695. EXPECT_EQ(0, exploded.hour);
  696. EXPECT_EQ(0, exploded.minute);
  697. EXPECT_EQ(0, exploded.second);
  698. EXPECT_EQ(0, exploded.millisecond);
  699. t = Time::UnixEpoch() + Microseconds(1000);
  700. t.UTCExplode(&exploded);
  701. EXPECT_TRUE(exploded.HasValidValues());
  702. // Should be 1970-01-01 00:00:00 1 millisecond.
  703. EXPECT_EQ(kUnixEpochYear, exploded.year);
  704. EXPECT_EQ(1, exploded.month);
  705. EXPECT_EQ(1, exploded.day_of_month);
  706. EXPECT_EQ(0, exploded.hour);
  707. EXPECT_EQ(0, exploded.minute);
  708. EXPECT_EQ(0, exploded.second);
  709. EXPECT_EQ(1, exploded.millisecond);
  710. t = Time::UnixEpoch() + Milliseconds(1000);
  711. t.UTCExplode(&exploded);
  712. EXPECT_TRUE(exploded.HasValidValues());
  713. // Should be 1970-01-01 00:00:01.
  714. EXPECT_EQ(kUnixEpochYear, exploded.year);
  715. EXPECT_EQ(1, exploded.month);
  716. EXPECT_EQ(1, exploded.day_of_month);
  717. EXPECT_EQ(0, exploded.hour);
  718. EXPECT_EQ(0, exploded.minute);
  719. EXPECT_EQ(1, exploded.second);
  720. EXPECT_EQ(0, exploded.millisecond);
  721. t = Time::UnixEpoch() + Milliseconds(1001);
  722. t.UTCExplode(&exploded);
  723. EXPECT_TRUE(exploded.HasValidValues());
  724. // Should be 1970-01-01 00:00:01 1 millisecond.
  725. EXPECT_EQ(kUnixEpochYear, exploded.year);
  726. EXPECT_EQ(1, exploded.month);
  727. EXPECT_EQ(1, exploded.day_of_month);
  728. EXPECT_EQ(0, exploded.hour);
  729. EXPECT_EQ(0, exploded.minute);
  730. EXPECT_EQ(1, exploded.second);
  731. EXPECT_EQ(1, exploded.millisecond);
  732. }
  733. TEST_F(TimeTest, Max) {
  734. constexpr Time kMax = Time::Max();
  735. static_assert(kMax.is_max(), "");
  736. static_assert(kMax == Time::Max(), "");
  737. EXPECT_GT(kMax, Time::Now());
  738. static_assert(kMax > Time(), "");
  739. }
  740. TEST_F(TimeTest, MaxConversions) {
  741. constexpr Time kMax = Time::Max();
  742. static_assert(std::numeric_limits<int64_t>::max() == kMax.ToInternalValue(),
  743. "");
  744. Time t = Time::FromDoubleT(std::numeric_limits<double>::infinity());
  745. EXPECT_TRUE(t.is_max());
  746. EXPECT_EQ(std::numeric_limits<double>::infinity(), t.ToDoubleT());
  747. t = Time::FromJsTime(std::numeric_limits<double>::infinity());
  748. EXPECT_TRUE(t.is_max());
  749. EXPECT_EQ(std::numeric_limits<double>::infinity(), t.ToJsTime());
  750. t = Time::FromTimeT(std::numeric_limits<time_t>::max());
  751. EXPECT_TRUE(t.is_max());
  752. EXPECT_EQ(std::numeric_limits<time_t>::max(), t.ToTimeT());
  753. #if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
  754. struct timeval tval;
  755. tval.tv_sec = std::numeric_limits<time_t>::max();
  756. tval.tv_usec = static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1;
  757. t = Time::FromTimeVal(tval);
  758. EXPECT_TRUE(t.is_max());
  759. tval = t.ToTimeVal();
  760. EXPECT_EQ(std::numeric_limits<time_t>::max(), tval.tv_sec);
  761. EXPECT_EQ(static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1,
  762. tval.tv_usec);
  763. #endif
  764. #if BUILDFLAG(IS_APPLE)
  765. t = Time::FromCFAbsoluteTime(std::numeric_limits<CFAbsoluteTime>::infinity());
  766. EXPECT_TRUE(t.is_max());
  767. EXPECT_EQ(std::numeric_limits<CFAbsoluteTime>::infinity(),
  768. t.ToCFAbsoluteTime());
  769. #endif
  770. #if BUILDFLAG(IS_WIN)
  771. FILETIME ftime;
  772. ftime.dwHighDateTime = std::numeric_limits<DWORD>::max();
  773. ftime.dwLowDateTime = std::numeric_limits<DWORD>::max();
  774. t = Time::FromFileTime(ftime);
  775. EXPECT_TRUE(t.is_max());
  776. ftime = t.ToFileTime();
  777. EXPECT_EQ(std::numeric_limits<DWORD>::max(), ftime.dwHighDateTime);
  778. EXPECT_EQ(std::numeric_limits<DWORD>::max(), ftime.dwLowDateTime);
  779. #endif
  780. }
  781. #if BUILDFLAG(IS_APPLE)
  782. TEST_F(TimeTest, TimeTOverflow) {
  783. constexpr Time kMaxMinusOne =
  784. Time::FromInternalValue(std::numeric_limits<int64_t>::max() - 1);
  785. static_assert(!kMaxMinusOne.is_max(), "");
  786. EXPECT_EQ(std::numeric_limits<time_t>::max(), kMaxMinusOne.ToTimeT());
  787. }
  788. #endif
  789. #if BUILDFLAG(IS_ANDROID)
  790. TEST_F(TimeTest, FromLocalExplodedCrashOnAndroid) {
  791. // This crashed inside Time:: FromLocalExploded() on Android 4.1.2.
  792. // See http://crbug.com/287821
  793. Time::Exploded midnight = {2013, // year
  794. 10, // month
  795. 0, // day_of_week
  796. 13, // day_of_month
  797. 0, // hour
  798. 0, // minute
  799. 0, // second
  800. };
  801. // The string passed to putenv() must be a char* and the documentation states
  802. // that it 'becomes part of the environment', so use a static buffer.
  803. static char buffer[] = "TZ=America/Santiago";
  804. putenv(buffer);
  805. tzset();
  806. Time t;
  807. EXPECT_TRUE(Time::FromLocalExploded(midnight, &t));
  808. EXPECT_EQ(1381633200, t.ToTimeT());
  809. }
  810. #endif // BUILDFLAG(IS_ANDROID)
  811. // Regression test for https://crbug.com/1104442
  812. TEST_F(TimeTest, Explode_Y10KCompliance) {
  813. constexpr int kDaysPerYear = 365;
  814. constexpr int64_t kHalfYearInMicros = Days(kDaysPerYear / 2).InMicroseconds();
  815. // The Y2038 issue occurs when a 32-bit signed integer overflows.
  816. constexpr int64_t kYear2038MicrosOffset =
  817. Time::kTimeTToMicrosecondsOffset +
  818. (std::numeric_limits<int32_t>::max() * Time::kMicrosecondsPerSecond);
  819. // 1 March 10000 at noon.
  820. constexpr int64_t kYear10000YearsOffset = 10000 - 1970;
  821. constexpr int kExtraLeapDaysOverThoseYears = 1947;
  822. constexpr int kDaysFromJanToMar10000 = 31 + 29;
  823. constexpr int64_t kMarch10000MicrosOffset =
  824. Time::kTimeTToMicrosecondsOffset +
  825. Days(kYear10000YearsOffset * kDaysPerYear + kExtraLeapDaysOverThoseYears +
  826. kDaysFromJanToMar10000)
  827. .InMicroseconds() +
  828. Hours(12).InMicroseconds();
  829. // Windows uses a 64-bit signed integer type that reperesents the number of
  830. // 1/10 microsecond ticks.
  831. constexpr int64_t kWindowsMaxMicrosOffset =
  832. std::numeric_limits<int64_t>::max() / 10;
  833. // ICU's Calendar API uses double values. Thus, the maximum supported value is
  834. // the maximum integer that can be represented by a double.
  835. static_assert(std::numeric_limits<double>::radix == 2, "");
  836. constexpr int64_t kMaxIntegerAsDoubleMillis =
  837. int64_t{1} << std::numeric_limits<double>::digits;
  838. constexpr int64_t kIcuMaxMicrosOffset =
  839. Time::kTimeTToMicrosecondsOffset +
  840. (kMaxIntegerAsDoubleMillis * Time::kMicrosecondsPerMillisecond + 999);
  841. const auto make_time = [](int64_t micros) {
  842. return Time::FromDeltaSinceWindowsEpoch(Microseconds(micros));
  843. };
  844. const struct TestCase {
  845. Time time;
  846. Time::Exploded expected;
  847. } kTestCases[] = {
  848. // A very long time ago.
  849. {Time::Min(), Time::Exploded{-290677, 12, 4, 23, 19, 59, 5, 224}},
  850. // Before/On/After 1 Jan 1601.
  851. {make_time(-kHalfYearInMicros),
  852. Time::Exploded{1600, 7, 1, 3, 0, 0, 0, 0}},
  853. {make_time(0), Time::Exploded{1601, 1, 1, 1, 0, 0, 0, 0}},
  854. {make_time(kHalfYearInMicros), Time::Exploded{1601, 7, 1, 2, 0, 0, 0, 0}},
  855. // Before/On/After 1 Jan 1970.
  856. {make_time(Time::kTimeTToMicrosecondsOffset - kHalfYearInMicros),
  857. Time::Exploded{1969, 7, 4, 3, 0, 0, 0, 0}},
  858. {make_time(Time::kTimeTToMicrosecondsOffset),
  859. Time::Exploded{1970, 1, 4, 1, 0, 0, 0, 0}},
  860. {make_time(Time::kTimeTToMicrosecondsOffset + kHalfYearInMicros),
  861. Time::Exploded{1970, 7, 4, 2, 0, 0, 0, 0}},
  862. // Before/On/After 19 January 2038.
  863. {make_time(kYear2038MicrosOffset - kHalfYearInMicros),
  864. Time::Exploded{2037, 7, 2, 21, 3, 14, 7, 0}},
  865. {make_time(kYear2038MicrosOffset),
  866. Time::Exploded{2038, 1, 2, 19, 3, 14, 7, 0}},
  867. {make_time(kYear2038MicrosOffset + kHalfYearInMicros),
  868. Time::Exploded{2038, 7, 2, 20, 3, 14, 7, 0}},
  869. // Before/On/After 1 March 10000 at noon.
  870. {make_time(kMarch10000MicrosOffset - kHalfYearInMicros),
  871. Time::Exploded{9999, 9, 3, 1, 12, 0, 0, 0}},
  872. {make_time(kMarch10000MicrosOffset),
  873. Time::Exploded{10000, 3, 3, 1, 12, 0, 0, 0}},
  874. {make_time(kMarch10000MicrosOffset + kHalfYearInMicros),
  875. Time::Exploded{10000, 8, 3, 30, 12, 0, 0, 0}},
  876. // Before/On/After Windows Max (14 September 30828).
  877. {make_time(kWindowsMaxMicrosOffset - kHalfYearInMicros),
  878. Time::Exploded{30828, 3, 4, 16, 2, 48, 5, 477}},
  879. {make_time(kWindowsMaxMicrosOffset),
  880. Time::Exploded{30828, 9, 4, 14, 2, 48, 5, 477}},
  881. {make_time(kWindowsMaxMicrosOffset + kHalfYearInMicros),
  882. Time::Exploded{30829, 3, 4, 15, 2, 48, 5, 477}},
  883. // Before/On/After ICU Max.
  884. {make_time(kIcuMaxMicrosOffset - kHalfYearInMicros),
  885. Time::Exploded{287396, 4, 3, 13, 8, 59, 0, 992}},
  886. {make_time(kIcuMaxMicrosOffset),
  887. Time::Exploded{287396, 10, 3, 12, 8, 59, 0, 992}},
  888. {make_time(kIcuMaxMicrosOffset + kHalfYearInMicros),
  889. Time::Exploded{287397, 4, 3, 12, 8, 59, 0, 992}},
  890. // A very long time from now.
  891. {Time::Max(), Time::Exploded{293878, 1, 4, 10, 4, 0, 54, 775}},
  892. };
  893. for (const TestCase& test_case : kTestCases) {
  894. SCOPED_TRACE(testing::Message() << "Time: " << test_case.time);
  895. Time::Exploded exploded = {};
  896. test_case.time.UTCExplode(&exploded);
  897. // Confirm the implementation provides a correct conversion for all inputs
  898. // within the guaranteed range (as discussed in the header comments). If an
  899. // implementation provides a result for inputs outside the guaranteed range,
  900. // the result must still be correct.
  901. if (exploded.HasValidValues()) {
  902. EXPECT_EQ(test_case.expected.year, exploded.year);
  903. EXPECT_EQ(test_case.expected.month, exploded.month);
  904. EXPECT_EQ(test_case.expected.day_of_week, exploded.day_of_week);
  905. EXPECT_EQ(test_case.expected.day_of_month, exploded.day_of_month);
  906. EXPECT_EQ(test_case.expected.hour, exploded.hour);
  907. EXPECT_EQ(test_case.expected.minute, exploded.minute);
  908. EXPECT_EQ(test_case.expected.second, exploded.second);
  909. EXPECT_EQ(test_case.expected.millisecond, exploded.millisecond);
  910. } else {
  911. // The implementation could not provide a conversion. That is only allowed
  912. // for inputs outside the guaranteed range.
  913. const bool is_in_range =
  914. test_case.time >= make_time(0) &&
  915. test_case.time <= make_time(kWindowsMaxMicrosOffset);
  916. EXPECT_FALSE(is_in_range);
  917. }
  918. }
  919. }
  920. #if BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_CHROMEOS)
  921. // Regression tests for https://crbug.com/1198313: base::Time::UTCExplode and
  922. // base::Time::LocalExplode should not be locale-dependent.
  923. TEST_F(TimeTest, UTCExplodedIsLocaleIndependent) {
  924. // Time-to-Exploded could be using libc or ICU functions.
  925. // Set the ICU locale and timezone and the libc timezone.
  926. // We're not setting the libc locale because the libc time functions are
  927. // locale-independent and the th_TH.utf8 locale was not available on all
  928. // trybots at the time this test was added.
  929. // th-TH maps to a non-gregorian calendar.
  930. test::ScopedRestoreICUDefaultLocale scoped_icu_locale(kThaiLocale);
  931. test::ScopedRestoreDefaultTimezone scoped_timezone(kBangkokTimeZoneId);
  932. ScopedLibcTZ scoped_libc_tz(kBangkokTimeZoneId);
  933. ASSERT_TRUE(scoped_libc_tz.is_success());
  934. Time::Exploded utc_exploded_orig;
  935. utc_exploded_orig.year = 2020;
  936. utc_exploded_orig.month = 7;
  937. utc_exploded_orig.day_of_week = 5; // Friday
  938. utc_exploded_orig.day_of_month = 3;
  939. utc_exploded_orig.hour = 12;
  940. utc_exploded_orig.minute = 0;
  941. utc_exploded_orig.second = 0;
  942. utc_exploded_orig.millisecond = 0;
  943. Time time;
  944. ASSERT_TRUE(base::Time::FromUTCExploded(utc_exploded_orig, &time));
  945. // Round trip to UTC Exploded should produce the exact same result.
  946. Time::Exploded utc_exploded;
  947. time.UTCExplode(&utc_exploded);
  948. EXPECT_EQ(utc_exploded_orig.year, utc_exploded.year);
  949. EXPECT_EQ(utc_exploded_orig.month, utc_exploded.month);
  950. EXPECT_EQ(utc_exploded_orig.day_of_week, utc_exploded.day_of_week);
  951. EXPECT_EQ(utc_exploded_orig.day_of_month, utc_exploded.day_of_month);
  952. EXPECT_EQ(utc_exploded_orig.hour, utc_exploded.hour);
  953. EXPECT_EQ(utc_exploded_orig.minute, utc_exploded.minute);
  954. EXPECT_EQ(utc_exploded_orig.second, utc_exploded.second);
  955. EXPECT_EQ(utc_exploded_orig.millisecond, utc_exploded.millisecond);
  956. }
  957. TEST_F(TimeTest, LocalExplodedIsLocaleIndependent) {
  958. // Time-to-Exploded could be using libc or ICU functions.
  959. // Set the ICU locale and timezone and the libc timezone.
  960. // We're not setting the libc locale because the libc time functions are
  961. // locale-independent and the th_TH.utf8 locale was not available on all
  962. // trybots at the time this test was added.
  963. // th-TH maps to a non-gregorian calendar.
  964. test::ScopedRestoreICUDefaultLocale scoped_icu_locale(kThaiLocale);
  965. test::ScopedRestoreDefaultTimezone scoped_timezone(kBangkokTimeZoneId);
  966. ScopedLibcTZ scoped_libc_tz(kBangkokTimeZoneId);
  967. ASSERT_TRUE(scoped_libc_tz.is_success());
  968. Time::Exploded utc_exploded_orig;
  969. utc_exploded_orig.year = 2020;
  970. utc_exploded_orig.month = 7;
  971. utc_exploded_orig.day_of_week = 5; // Friday
  972. utc_exploded_orig.day_of_month = 3;
  973. utc_exploded_orig.hour = 12;
  974. utc_exploded_orig.minute = 0;
  975. utc_exploded_orig.second = 0;
  976. utc_exploded_orig.millisecond = 0;
  977. Time time;
  978. ASSERT_TRUE(base::Time::FromUTCExploded(utc_exploded_orig, &time));
  979. absl::optional<TimeDelta> expected_delta =
  980. GetTimeZoneOffsetAtTime(kBangkokTimeZoneId, time);
  981. ASSERT_TRUE(expected_delta.has_value());
  982. // This is to be sure that the day has not changed
  983. ASSERT_LT(*expected_delta, base::Hours(12));
  984. Time::Exploded local_exploded;
  985. time.LocalExplode(&local_exploded);
  986. TimeDelta actual_delta = TimePassedAfterMidnight(local_exploded) -
  987. TimePassedAfterMidnight(utc_exploded_orig);
  988. EXPECT_EQ(utc_exploded_orig.year, local_exploded.year);
  989. EXPECT_EQ(utc_exploded_orig.month, local_exploded.month);
  990. EXPECT_EQ(utc_exploded_orig.day_of_week, local_exploded.day_of_week);
  991. EXPECT_EQ(utc_exploded_orig.day_of_month, local_exploded.day_of_month);
  992. EXPECT_EQ(actual_delta, *expected_delta);
  993. }
  994. #endif // BUILDFLAG(IS_FUCHSIA) || BUILDFLAG(IS_CHROMEOS)
  995. TEST_F(TimeTest, FromExploded_MinMax) {
  996. Time::Exploded exploded = {0};
  997. exploded.month = 1;
  998. exploded.day_of_month = 1;
  999. Time parsed_time;
  1000. if (Time::kExplodedMinYear != std::numeric_limits<int>::min()) {
  1001. exploded.year = Time::kExplodedMinYear;
  1002. EXPECT_TRUE(Time::FromUTCExploded(exploded, &parsed_time));
  1003. #if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
  1004. // On Windows, January 1, 1601 00:00:00 is actually the null time.
  1005. EXPECT_FALSE(parsed_time.is_null());
  1006. #endif
  1007. #if !BUILDFLAG(IS_ANDROID) && !BUILDFLAG(IS_APPLE)
  1008. // The dates earlier than |kExplodedMinYear| that don't work are OS version
  1009. // dependent on Android and Mac (for example, macOS 10.13 seems to support
  1010. // dates before 1902).
  1011. exploded.year--;
  1012. EXPECT_FALSE(Time::FromUTCExploded(exploded, &parsed_time));
  1013. EXPECT_TRUE(parsed_time.is_null());
  1014. #endif
  1015. }
  1016. if (Time::kExplodedMaxYear != std::numeric_limits<int>::max()) {
  1017. exploded.year = Time::kExplodedMaxYear;
  1018. exploded.month = 12;
  1019. exploded.day_of_month = 31;
  1020. exploded.hour = 23;
  1021. exploded.minute = 59;
  1022. exploded.second = 59;
  1023. exploded.millisecond = 999;
  1024. EXPECT_TRUE(Time::FromUTCExploded(exploded, &parsed_time));
  1025. EXPECT_FALSE(parsed_time.is_null());
  1026. exploded.year++;
  1027. EXPECT_FALSE(Time::FromUTCExploded(exploded, &parsed_time));
  1028. EXPECT_TRUE(parsed_time.is_null());
  1029. }
  1030. }
  1031. class TimeOverride {
  1032. public:
  1033. static Time Now() {
  1034. now_time_ += Seconds(1);
  1035. return now_time_;
  1036. }
  1037. static Time now_time_;
  1038. };
  1039. // static
  1040. Time TimeOverride::now_time_;
  1041. #if BUILDFLAG(IS_FUCHSIA)
  1042. // TODO(https://crbug.com/1060357): Enable when RTC flake is fixed.
  1043. #define MAYBE_NowOverride DISABLED_NowOverride
  1044. #else
  1045. #define MAYBE_NowOverride NowOverride
  1046. #endif
  1047. TEST_F(TimeTest, MAYBE_NowOverride) {
  1048. TimeOverride::now_time_ = Time::UnixEpoch();
  1049. // Choose a reference time that we know to be in the past but close to now.
  1050. Time build_time = GetBuildTime();
  1051. // Override is not active. All Now() methods should return a time greater than
  1052. // the build time.
  1053. EXPECT_LT(build_time, Time::Now());
  1054. EXPECT_GT(Time::Max(), Time::Now());
  1055. EXPECT_LT(build_time, subtle::TimeNowIgnoringOverride());
  1056. EXPECT_GT(Time::Max(), subtle::TimeNowIgnoringOverride());
  1057. EXPECT_LT(build_time, Time::NowFromSystemTime());
  1058. EXPECT_GT(Time::Max(), Time::NowFromSystemTime());
  1059. EXPECT_LT(build_time, subtle::TimeNowFromSystemTimeIgnoringOverride());
  1060. EXPECT_GT(Time::Max(), subtle::TimeNowFromSystemTimeIgnoringOverride());
  1061. {
  1062. // Set override.
  1063. subtle::ScopedTimeClockOverrides overrides(&TimeOverride::Now, nullptr,
  1064. nullptr);
  1065. // Overridden value is returned and incremented when Now() or
  1066. // NowFromSystemTime() is called.
  1067. EXPECT_EQ(Time::UnixEpoch() + Seconds(1), Time::Now());
  1068. EXPECT_EQ(Time::UnixEpoch() + Seconds(2), Time::Now());
  1069. EXPECT_EQ(Time::UnixEpoch() + Seconds(3), Time::NowFromSystemTime());
  1070. EXPECT_EQ(Time::UnixEpoch() + Seconds(4), Time::NowFromSystemTime());
  1071. // IgnoringOverride methods still return real time.
  1072. EXPECT_LT(build_time, subtle::TimeNowIgnoringOverride());
  1073. EXPECT_GT(Time::Max(), subtle::TimeNowIgnoringOverride());
  1074. EXPECT_LT(build_time, subtle::TimeNowFromSystemTimeIgnoringOverride());
  1075. EXPECT_GT(Time::Max(), subtle::TimeNowFromSystemTimeIgnoringOverride());
  1076. // IgnoringOverride methods didn't call NowOverrideClock::Now().
  1077. EXPECT_EQ(Time::UnixEpoch() + Seconds(5), Time::Now());
  1078. EXPECT_EQ(Time::UnixEpoch() + Seconds(6), Time::NowFromSystemTime());
  1079. }
  1080. // All methods return real time again.
  1081. EXPECT_LT(build_time, Time::Now());
  1082. EXPECT_GT(Time::Max(), Time::Now());
  1083. EXPECT_LT(build_time, subtle::TimeNowIgnoringOverride());
  1084. EXPECT_GT(Time::Max(), subtle::TimeNowIgnoringOverride());
  1085. EXPECT_LT(build_time, Time::NowFromSystemTime());
  1086. EXPECT_GT(Time::Max(), Time::NowFromSystemTime());
  1087. EXPECT_LT(build_time, subtle::TimeNowFromSystemTimeIgnoringOverride());
  1088. EXPECT_GT(Time::Max(), subtle::TimeNowFromSystemTimeIgnoringOverride());
  1089. }
  1090. #undef MAYBE_NowOverride
  1091. TEST_F(TimeTest, TimeFormatHTTP) {
  1092. base::Time time;
  1093. ASSERT_TRUE(base::Time::FromString("1994-11-06T08:49:37Z", &time));
  1094. EXPECT_EQ("Sun, 06 Nov 1994 08:49:37 GMT", TimeFormatHTTP(time));
  1095. }
  1096. #if BUILDFLAG(IS_FUCHSIA)
  1097. TEST(ZxTimeTest, ToFromConversions) {
  1098. Time unix_epoch = Time::UnixEpoch();
  1099. EXPECT_EQ(unix_epoch.ToZxTime(), 0);
  1100. EXPECT_EQ(Time::FromZxTime(6000000000), unix_epoch + Seconds(6));
  1101. TimeTicks ticks_now = TimeTicks::Now();
  1102. EXPECT_GE(ticks_now.ToZxTime(), 0);
  1103. TimeTicks ticks_later = ticks_now + Seconds(2);
  1104. EXPECT_EQ((ticks_later.ToZxTime() - ticks_now.ToZxTime()), 2000000000);
  1105. EXPECT_EQ(TimeTicks::FromZxTime(3000000000), TimeTicks() + Seconds(3));
  1106. EXPECT_EQ(TimeDelta().ToZxDuration(), 0);
  1107. EXPECT_EQ(TimeDelta::FromZxDuration(0), TimeDelta());
  1108. EXPECT_EQ(Seconds(2).ToZxDuration(), 2000000000);
  1109. EXPECT_EQ(TimeDelta::FromZxDuration(4000000000), Seconds(4));
  1110. }
  1111. #endif // BUILDFLAG(IS_FUCHSIA)
  1112. TEST(TimeTicks, Deltas) {
  1113. for (int index = 0; index < 50; index++) {
  1114. TimeTicks ticks_start = TimeTicks::Now();
  1115. base::PlatformThread::Sleep(base::Milliseconds(10));
  1116. TimeTicks ticks_stop = TimeTicks::Now();
  1117. TimeDelta delta = ticks_stop - ticks_start;
  1118. // Note: Although we asked for a 10ms sleep, if the
  1119. // time clock has a finer granularity than the Sleep()
  1120. // clock, it is quite possible to wakeup early. Here
  1121. // is how that works:
  1122. // Time(ms timer) Time(us timer)
  1123. // 5 5010
  1124. // 6 6010
  1125. // 7 7010
  1126. // 8 8010
  1127. // 9 9000
  1128. // Elapsed 4ms 3990us
  1129. //
  1130. // Unfortunately, our InMilliseconds() function truncates
  1131. // rather than rounds. We should consider fixing this
  1132. // so that our averages come out better.
  1133. EXPECT_GE(delta.InMilliseconds(), 9);
  1134. EXPECT_GE(delta.InMicroseconds(), 9000);
  1135. EXPECT_EQ(delta.InSeconds(), 0);
  1136. }
  1137. }
  1138. static void HighResClockTest(TimeTicks (*GetTicks)()) {
  1139. // IsHighResolution() is false on some systems. Since the product still works
  1140. // even if it's false, it makes this entire test questionable.
  1141. if (!TimeTicks::IsHighResolution())
  1142. return;
  1143. // Why do we loop here?
  1144. // We're trying to measure that intervals increment in a VERY small amount
  1145. // of time -- less than 15ms. Unfortunately, if we happen to have a
  1146. // context switch in the middle of our test, the context switch could easily
  1147. // exceed our limit. So, we iterate on this several times. As long as we're
  1148. // able to detect the fine-granularity timers at least once, then the test
  1149. // has succeeded.
  1150. const int kTargetGranularityUs = 15000; // 15ms
  1151. bool success = false;
  1152. int retries = 100; // Arbitrary.
  1153. TimeDelta delta;
  1154. while (!success && retries--) {
  1155. TimeTicks ticks_start = GetTicks();
  1156. // Loop until we can detect that the clock has changed. Non-HighRes timers
  1157. // will increment in chunks, e.g. 15ms. By spinning until we see a clock
  1158. // change, we detect the minimum time between measurements.
  1159. do {
  1160. delta = GetTicks() - ticks_start;
  1161. } while (delta.InMilliseconds() == 0);
  1162. if (delta.InMicroseconds() <= kTargetGranularityUs)
  1163. success = true;
  1164. }
  1165. // In high resolution mode, we expect to see the clock increment
  1166. // in intervals less than 15ms.
  1167. EXPECT_TRUE(success);
  1168. }
  1169. TEST(TimeTicks, HighRes) {
  1170. HighResClockTest(&TimeTicks::Now);
  1171. }
  1172. class TimeTicksOverride {
  1173. public:
  1174. static TimeTicks Now() {
  1175. now_ticks_ += Seconds(1);
  1176. return now_ticks_;
  1177. }
  1178. static TimeTicks now_ticks_;
  1179. };
  1180. // static
  1181. TimeTicks TimeTicksOverride::now_ticks_;
  1182. TEST(TimeTicks, NowOverride) {
  1183. TimeTicksOverride::now_ticks_ = TimeTicks::Min();
  1184. // Override is not active. All Now() methods should return a sensible value.
  1185. EXPECT_LT(TimeTicks::Min(), TimeTicks::UnixEpoch());
  1186. EXPECT_LT(TimeTicks::UnixEpoch(), TimeTicks::Now());
  1187. EXPECT_GT(TimeTicks::Max(), TimeTicks::Now());
  1188. EXPECT_LT(TimeTicks::UnixEpoch(), subtle::TimeTicksNowIgnoringOverride());
  1189. EXPECT_GT(TimeTicks::Max(), subtle::TimeTicksNowIgnoringOverride());
  1190. {
  1191. // Set override.
  1192. subtle::ScopedTimeClockOverrides overrides(nullptr, &TimeTicksOverride::Now,
  1193. nullptr);
  1194. // Overridden value is returned and incremented when Now() is called.
  1195. EXPECT_EQ(TimeTicks::Min() + Seconds(1), TimeTicks::Now());
  1196. EXPECT_EQ(TimeTicks::Min() + Seconds(2), TimeTicks::Now());
  1197. // NowIgnoringOverride() still returns real ticks.
  1198. EXPECT_LT(TimeTicks::UnixEpoch(), subtle::TimeTicksNowIgnoringOverride());
  1199. EXPECT_GT(TimeTicks::Max(), subtle::TimeTicksNowIgnoringOverride());
  1200. // IgnoringOverride methods didn't call NowOverrideTickClock::NowTicks().
  1201. EXPECT_EQ(TimeTicks::Min() + Seconds(3), TimeTicks::Now());
  1202. }
  1203. // All methods return real ticks again.
  1204. EXPECT_LT(TimeTicks::UnixEpoch(), TimeTicks::Now());
  1205. EXPECT_GT(TimeTicks::Max(), TimeTicks::Now());
  1206. EXPECT_LT(TimeTicks::UnixEpoch(), subtle::TimeTicksNowIgnoringOverride());
  1207. EXPECT_GT(TimeTicks::Max(), subtle::TimeTicksNowIgnoringOverride());
  1208. }
  1209. class ThreadTicksOverride {
  1210. public:
  1211. static ThreadTicks Now() {
  1212. now_ticks_ += Seconds(1);
  1213. return now_ticks_;
  1214. }
  1215. static ThreadTicks now_ticks_;
  1216. };
  1217. // static
  1218. ThreadTicks ThreadTicksOverride::now_ticks_;
  1219. // IOS doesn't support ThreadTicks::Now().
  1220. #if BUILDFLAG(IS_IOS)
  1221. #define MAYBE_NowOverride DISABLED_NowOverride
  1222. #else
  1223. #define MAYBE_NowOverride NowOverride
  1224. #endif
  1225. TEST(ThreadTicks, MAYBE_NowOverride) {
  1226. ThreadTicksOverride::now_ticks_ = ThreadTicks::Min();
  1227. // Override is not active. All Now() methods should return a sensible value.
  1228. ThreadTicks initial_thread_ticks = ThreadTicks::Now();
  1229. EXPECT_LE(initial_thread_ticks, ThreadTicks::Now());
  1230. EXPECT_GT(ThreadTicks::Max(), ThreadTicks::Now());
  1231. EXPECT_LE(initial_thread_ticks, subtle::ThreadTicksNowIgnoringOverride());
  1232. EXPECT_GT(ThreadTicks::Max(), subtle::ThreadTicksNowIgnoringOverride());
  1233. {
  1234. // Set override.
  1235. subtle::ScopedTimeClockOverrides overrides(nullptr, nullptr,
  1236. &ThreadTicksOverride::Now);
  1237. // Overridden value is returned and incremented when Now() is called.
  1238. EXPECT_EQ(ThreadTicks::Min() + Seconds(1), ThreadTicks::Now());
  1239. EXPECT_EQ(ThreadTicks::Min() + Seconds(2), ThreadTicks::Now());
  1240. // NowIgnoringOverride() still returns real ticks.
  1241. EXPECT_LE(initial_thread_ticks, subtle::ThreadTicksNowIgnoringOverride());
  1242. EXPECT_GT(ThreadTicks::Max(), subtle::ThreadTicksNowIgnoringOverride());
  1243. // IgnoringOverride methods didn't call NowOverrideTickClock::NowTicks().
  1244. EXPECT_EQ(ThreadTicks::Min() + Seconds(3), ThreadTicks::Now());
  1245. }
  1246. // All methods return real ticks again.
  1247. EXPECT_LE(initial_thread_ticks, ThreadTicks::Now());
  1248. EXPECT_GT(ThreadTicks::Max(), ThreadTicks::Now());
  1249. EXPECT_LE(initial_thread_ticks, subtle::ThreadTicksNowIgnoringOverride());
  1250. EXPECT_GT(ThreadTicks::Max(), subtle::ThreadTicksNowIgnoringOverride());
  1251. }
  1252. TEST(ThreadTicks, ThreadNow) {
  1253. if (ThreadTicks::IsSupported()) {
  1254. ThreadTicks::WaitUntilInitialized();
  1255. TimeTicks begin = TimeTicks::Now();
  1256. ThreadTicks begin_thread = ThreadTicks::Now();
  1257. // Make sure that ThreadNow value is non-zero.
  1258. EXPECT_GT(begin_thread, ThreadTicks());
  1259. // Sleep for 10 milliseconds to get the thread de-scheduled.
  1260. base::PlatformThread::Sleep(base::Milliseconds(10));
  1261. ThreadTicks end_thread = ThreadTicks::Now();
  1262. TimeTicks end = TimeTicks::Now();
  1263. TimeDelta delta = end - begin;
  1264. TimeDelta delta_thread = end_thread - begin_thread;
  1265. // Make sure that some thread time have elapsed.
  1266. EXPECT_GE(delta_thread.InMicroseconds(), 0);
  1267. // But the thread time is at least 9ms less than clock time.
  1268. TimeDelta difference = delta - delta_thread;
  1269. EXPECT_GE(difference.InMicroseconds(), 9000);
  1270. }
  1271. }
  1272. TEST(TimeTicks, SnappedToNextTickBasic) {
  1273. base::TimeTicks phase = base::TimeTicks::FromInternalValue(4000);
  1274. base::TimeDelta interval = base::Microseconds(1000);
  1275. base::TimeTicks timestamp;
  1276. // Timestamp in previous interval.
  1277. timestamp = base::TimeTicks::FromInternalValue(3500);
  1278. EXPECT_EQ(4000,
  1279. timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
  1280. // Timestamp in next interval.
  1281. timestamp = base::TimeTicks::FromInternalValue(4500);
  1282. EXPECT_EQ(5000,
  1283. timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
  1284. // Timestamp multiple intervals before.
  1285. timestamp = base::TimeTicks::FromInternalValue(2500);
  1286. EXPECT_EQ(3000,
  1287. timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
  1288. // Timestamp multiple intervals after.
  1289. timestamp = base::TimeTicks::FromInternalValue(6500);
  1290. EXPECT_EQ(7000,
  1291. timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
  1292. // Timestamp on previous interval.
  1293. timestamp = base::TimeTicks::FromInternalValue(3000);
  1294. EXPECT_EQ(3000,
  1295. timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
  1296. // Timestamp on next interval.
  1297. timestamp = base::TimeTicks::FromInternalValue(5000);
  1298. EXPECT_EQ(5000,
  1299. timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
  1300. // Timestamp equal to phase.
  1301. timestamp = base::TimeTicks::FromInternalValue(4000);
  1302. EXPECT_EQ(4000,
  1303. timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
  1304. }
  1305. TEST(TimeTicks, SnappedToNextTickOverflow) {
  1306. // int(big_timestamp / interval) < 0, so this causes a crash if the number of
  1307. // intervals elapsed is attempted to be stored in an int.
  1308. base::TimeTicks phase = base::TimeTicks::FromInternalValue(0);
  1309. base::TimeDelta interval = base::Microseconds(4000);
  1310. base::TimeTicks big_timestamp =
  1311. base::TimeTicks::FromInternalValue(8635916564000);
  1312. EXPECT_EQ(8635916564000,
  1313. big_timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
  1314. EXPECT_EQ(8635916564000,
  1315. big_timestamp.SnappedToNextTick(big_timestamp, interval)
  1316. .ToInternalValue());
  1317. }
  1318. #if BUILDFLAG(IS_ANDROID)
  1319. TEST(TimeTicks, Android_FromUptimeMillis_ClocksMatch) {
  1320. JNIEnv* const env = android::AttachCurrentThread();
  1321. android::ScopedJavaLocalRef<jclass> clazz(
  1322. android::GetClass(env, "android/os/SystemClock"));
  1323. ASSERT_TRUE(clazz.obj());
  1324. const jmethodID method_id =
  1325. android::MethodID::Get<android::MethodID::TYPE_STATIC>(
  1326. env, clazz.obj(), "uptimeMillis", "()J");
  1327. ASSERT_FALSE(!method_id);
  1328. // Subtract 1ms from the expected lower bound to allow millisecond-level
  1329. // truncation performed in uptimeMillis().
  1330. const TimeTicks lower_bound_ticks = TimeTicks::Now() - Milliseconds(1);
  1331. const TimeTicks converted_ticks = TimeTicks::FromUptimeMillis(
  1332. env->CallStaticLongMethod(clazz.obj(), method_id));
  1333. const TimeTicks upper_bound_ticks = TimeTicks::Now();
  1334. EXPECT_LE(lower_bound_ticks, converted_ticks);
  1335. EXPECT_GE(upper_bound_ticks, converted_ticks);
  1336. }
  1337. TEST(TimeTicks, Android_FromJavaNanoTime_ClocksMatch) {
  1338. JNIEnv* const env = android::AttachCurrentThread();
  1339. android::ScopedJavaLocalRef<jclass> clazz(
  1340. android::GetClass(env, "java/lang/System"));
  1341. ASSERT_TRUE(clazz.obj());
  1342. const jmethodID method_id =
  1343. android::MethodID::Get<android::MethodID::TYPE_STATIC>(env, clazz.obj(),
  1344. "nanoTime", "()J");
  1345. ASSERT_FALSE(!method_id);
  1346. const TimeTicks lower_bound_ticks = TimeTicks::Now();
  1347. const TimeTicks converted_ticks = TimeTicks::FromJavaNanoTime(
  1348. env->CallStaticLongMethod(clazz.obj(), method_id));
  1349. // Add 1us to the expected upper bound to allow microsecond-level
  1350. // truncation performed in TimeTicks::Now().
  1351. const TimeTicks upper_bound_ticks = TimeTicks::Now() + Microseconds(1);
  1352. EXPECT_LE(lower_bound_ticks, converted_ticks);
  1353. EXPECT_GE(upper_bound_ticks, converted_ticks);
  1354. }
  1355. #endif // BUILDFLAG(IS_ANDROID)
  1356. TEST(TimeDelta, FromAndIn) {
  1357. // static_assert also checks that the contained expression is a constant
  1358. // expression, meaning all its components are suitable for initializing global
  1359. // variables.
  1360. static_assert(Days(2) == Hours(48), "");
  1361. static_assert(Hours(3) == Minutes(180), "");
  1362. static_assert(Minutes(2) == Seconds(120), "");
  1363. static_assert(Seconds(2) == Milliseconds(2000), "");
  1364. static_assert(Milliseconds(2) == Microseconds(2000), "");
  1365. static_assert(Seconds(2.3) == Milliseconds(2300), "");
  1366. static_assert(Milliseconds(2.5) == Microseconds(2500), "");
  1367. EXPECT_EQ(Days(13).InDays(), 13);
  1368. static_assert(Hours(13).InHours() == 13, "");
  1369. static_assert(Minutes(13).InMinutes() == 13, "");
  1370. static_assert(Seconds(13).InSeconds() == 13, "");
  1371. static_assert(Seconds(13).InSecondsF() == 13.0, "");
  1372. EXPECT_EQ(Milliseconds(13).InMilliseconds(), 13);
  1373. EXPECT_EQ(Milliseconds(13).InMillisecondsF(), 13.0);
  1374. static_assert(Seconds(13.1).InSeconds() == 13, "");
  1375. static_assert(Seconds(13.1).InSecondsF() == 13.1, "");
  1376. EXPECT_EQ(Milliseconds(13.3).InMilliseconds(), 13);
  1377. EXPECT_EQ(Milliseconds(13.3).InMillisecondsF(), 13.3);
  1378. static_assert(Microseconds(13).InMicroseconds() == 13, "");
  1379. static_assert(Microseconds(13.3).InMicroseconds() == 13, "");
  1380. EXPECT_EQ(Milliseconds(3.45678).InMillisecondsF(), 3.456);
  1381. static_assert(Nanoseconds(12345).InNanoseconds() == 12000, "");
  1382. static_assert(Nanoseconds(12345.678).InNanoseconds() == 12000, "");
  1383. }
  1384. TEST(TimeDelta, InRoundsTowardsZero) {
  1385. EXPECT_EQ(Hours(23).InDays(), 0);
  1386. EXPECT_EQ(Hours(-23).InDays(), 0);
  1387. static_assert(Minutes(59).InHours() == 0, "");
  1388. static_assert(Minutes(-59).InHours() == 0, "");
  1389. static_assert(Seconds(59).InMinutes() == 0, "");
  1390. static_assert(Seconds(-59).InMinutes() == 0, "");
  1391. static_assert(Milliseconds(999).InSeconds() == 0, "");
  1392. static_assert(Milliseconds(-999).InSeconds() == 0, "");
  1393. EXPECT_EQ(Microseconds(999).InMilliseconds(), 0);
  1394. EXPECT_EQ(Microseconds(-999).InMilliseconds(), 0);
  1395. }
  1396. TEST(TimeDelta, InDaysFloored) {
  1397. EXPECT_EQ(Hours(-25).InDaysFloored(), -2);
  1398. EXPECT_EQ(Hours(-24).InDaysFloored(), -1);
  1399. EXPECT_EQ(Hours(-23).InDaysFloored(), -1);
  1400. EXPECT_EQ(Hours(-1).InDaysFloored(), -1);
  1401. EXPECT_EQ(Hours(0).InDaysFloored(), 0);
  1402. EXPECT_EQ(Hours(1).InDaysFloored(), 0);
  1403. EXPECT_EQ(Hours(23).InDaysFloored(), 0);
  1404. EXPECT_EQ(Hours(24).InDaysFloored(), 1);
  1405. EXPECT_EQ(Hours(25).InDaysFloored(), 1);
  1406. }
  1407. TEST(TimeDelta, InMillisecondsRoundedUp) {
  1408. EXPECT_EQ(Microseconds(-1001).InMillisecondsRoundedUp(), -1);
  1409. EXPECT_EQ(Microseconds(-1000).InMillisecondsRoundedUp(), -1);
  1410. EXPECT_EQ(Microseconds(-999).InMillisecondsRoundedUp(), 0);
  1411. EXPECT_EQ(Microseconds(-1).InMillisecondsRoundedUp(), 0);
  1412. EXPECT_EQ(Microseconds(0).InMillisecondsRoundedUp(), 0);
  1413. EXPECT_EQ(Microseconds(1).InMillisecondsRoundedUp(), 1);
  1414. EXPECT_EQ(Microseconds(999).InMillisecondsRoundedUp(), 1);
  1415. EXPECT_EQ(Microseconds(1000).InMillisecondsRoundedUp(), 1);
  1416. EXPECT_EQ(Microseconds(1001).InMillisecondsRoundedUp(), 2);
  1417. }
  1418. // Check that near-min/max values saturate rather than overflow when converted
  1419. // lossily with InXXX() functions. Only integral hour, minute, and nanosecond
  1420. // conversions are checked, since those are the only cases where the return type
  1421. // is small enough for saturation or overflow to occur.
  1422. TEST(TimeDelta, InXXXOverflow) {
  1423. constexpr TimeDelta kLargeDelta =
  1424. Microseconds(std::numeric_limits<int64_t>::max() - 1);
  1425. static_assert(!kLargeDelta.is_max(), "");
  1426. static_assert(std::numeric_limits<int>::max() == kLargeDelta.InHours(), "");
  1427. static_assert(std::numeric_limits<int>::max() == kLargeDelta.InMinutes(), "");
  1428. static_assert(
  1429. std::numeric_limits<int64_t>::max() == kLargeDelta.InNanoseconds(), "");
  1430. constexpr TimeDelta kLargeNegative =
  1431. Microseconds(std::numeric_limits<int64_t>::min() + 1);
  1432. static_assert(!kLargeNegative.is_min(), "");
  1433. static_assert(std::numeric_limits<int>::min() == kLargeNegative.InHours(),
  1434. "");
  1435. static_assert(std::numeric_limits<int>::min() == kLargeNegative.InMinutes(),
  1436. "");
  1437. static_assert(
  1438. std::numeric_limits<int64_t>::min() == kLargeNegative.InNanoseconds(),
  1439. "");
  1440. }
  1441. #if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
  1442. TEST(TimeDelta, TimeSpecConversion) {
  1443. TimeDelta delta = Seconds(0);
  1444. struct timespec result = delta.ToTimeSpec();
  1445. EXPECT_EQ(result.tv_sec, 0);
  1446. EXPECT_EQ(result.tv_nsec, 0);
  1447. EXPECT_EQ(delta, TimeDelta::FromTimeSpec(result));
  1448. delta = Seconds(1);
  1449. result = delta.ToTimeSpec();
  1450. EXPECT_EQ(result.tv_sec, 1);
  1451. EXPECT_EQ(result.tv_nsec, 0);
  1452. EXPECT_EQ(delta, TimeDelta::FromTimeSpec(result));
  1453. delta = Microseconds(1);
  1454. result = delta.ToTimeSpec();
  1455. EXPECT_EQ(result.tv_sec, 0);
  1456. EXPECT_EQ(result.tv_nsec, 1000);
  1457. EXPECT_EQ(delta, TimeDelta::FromTimeSpec(result));
  1458. delta = Microseconds(Time::kMicrosecondsPerSecond + 1);
  1459. result = delta.ToTimeSpec();
  1460. EXPECT_EQ(result.tv_sec, 1);
  1461. EXPECT_EQ(result.tv_nsec, 1000);
  1462. EXPECT_EQ(delta, TimeDelta::FromTimeSpec(result));
  1463. }
  1464. #endif // BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
  1465. // Our internal time format is serialized in things like databases, so it's
  1466. // important that it's consistent across all our platforms. We use the 1601
  1467. // Windows epoch as the internal format across all platforms.
  1468. TEST(TimeDelta, WindowsEpoch) {
  1469. Time::Exploded exploded;
  1470. exploded.year = 1970;
  1471. exploded.month = 1;
  1472. exploded.day_of_week = 0; // Should be unusued.
  1473. exploded.day_of_month = 1;
  1474. exploded.hour = 0;
  1475. exploded.minute = 0;
  1476. exploded.second = 0;
  1477. exploded.millisecond = 0;
  1478. Time t;
  1479. EXPECT_TRUE(Time::FromUTCExploded(exploded, &t));
  1480. // Unix 1970 epoch.
  1481. EXPECT_EQ(INT64_C(11644473600000000), t.ToInternalValue());
  1482. // We can't test 1601 epoch, since the system time functions on Linux
  1483. // only compute years starting from 1900.
  1484. }
  1485. TEST(TimeDelta, Hz) {
  1486. static_assert(Hertz(1) == Seconds(1), "");
  1487. EXPECT_EQ(Hertz(0), TimeDelta::Max());
  1488. static_assert(Hertz(-1) == Seconds(-1), "");
  1489. static_assert(Hertz(1000) == Milliseconds(1), "");
  1490. static_assert(Hertz(0.5) == Seconds(2), "");
  1491. static_assert(Hertz(std::numeric_limits<double>::infinity()) == TimeDelta(),
  1492. "");
  1493. static_assert(Seconds(1).ToHz() == 1, "");
  1494. static_assert(TimeDelta::Max().ToHz() == 0, "");
  1495. static_assert(Seconds(-1).ToHz() == -1, "");
  1496. static_assert(Milliseconds(1).ToHz() == 1000, "");
  1497. static_assert(Seconds(2).ToHz() == 0.5, "");
  1498. EXPECT_EQ(TimeDelta().ToHz(), std::numeric_limits<double>::infinity());
  1499. // 60 Hz can't be represented exactly.
  1500. static_assert(Hertz(60) * 60 != Seconds(1), "");
  1501. static_assert(Hertz(60).ToHz() != 60, "");
  1502. EXPECT_EQ(base::ClampRound(Hertz(60).ToHz()), 60);
  1503. }
  1504. // We could define this separately for Time, TimeTicks and TimeDelta but the
  1505. // definitions would be identical anyway.
  1506. template <class Any>
  1507. std::string AnyToString(Any any) {
  1508. std::ostringstream oss;
  1509. oss << any;
  1510. return oss.str();
  1511. }
  1512. TEST(TimeDelta, Magnitude) {
  1513. constexpr int64_t zero = 0;
  1514. static_assert(Microseconds(zero) == Microseconds(zero).magnitude(), "");
  1515. constexpr int64_t one = 1;
  1516. constexpr int64_t negative_one = -1;
  1517. static_assert(Microseconds(one) == Microseconds(one).magnitude(), "");
  1518. static_assert(Microseconds(one) == Microseconds(negative_one).magnitude(),
  1519. "");
  1520. constexpr int64_t max_int64_minus_one =
  1521. std::numeric_limits<int64_t>::max() - 1;
  1522. constexpr int64_t min_int64_plus_two =
  1523. std::numeric_limits<int64_t>::min() + 2;
  1524. static_assert(Microseconds(max_int64_minus_one) ==
  1525. Microseconds(max_int64_minus_one).magnitude(),
  1526. "");
  1527. static_assert(Microseconds(max_int64_minus_one) ==
  1528. Microseconds(min_int64_plus_two).magnitude(),
  1529. "");
  1530. static_assert(TimeDelta::Max() == TimeDelta::Min().magnitude(), "");
  1531. }
  1532. TEST(TimeDelta, ZeroMinMax) {
  1533. constexpr TimeDelta kZero;
  1534. static_assert(kZero.is_zero(), "");
  1535. constexpr TimeDelta kMax = TimeDelta::Max();
  1536. static_assert(kMax.is_max(), "");
  1537. static_assert(kMax == TimeDelta::Max(), "");
  1538. static_assert(kMax > Days(100 * 365), "");
  1539. static_assert(kMax > kZero, "");
  1540. constexpr TimeDelta kMin = TimeDelta::Min();
  1541. static_assert(kMin.is_min(), "");
  1542. static_assert(kMin == TimeDelta::Min(), "");
  1543. static_assert(kMin < Days(-100 * 365), "");
  1544. static_assert(kMin < kZero, "");
  1545. }
  1546. TEST(TimeDelta, MaxConversions) {
  1547. // static_assert also confirms constexpr works as intended.
  1548. constexpr TimeDelta kMax = TimeDelta::Max();
  1549. static_assert(kMax.ToInternalValue() == std::numeric_limits<int64_t>::max(),
  1550. "");
  1551. EXPECT_EQ(kMax.InDays(), std::numeric_limits<int>::max());
  1552. static_assert(kMax.InHours() == std::numeric_limits<int>::max(), "");
  1553. static_assert(kMax.InMinutes() == std::numeric_limits<int>::max(), "");
  1554. static_assert(kMax.InSecondsF() == std::numeric_limits<double>::infinity(),
  1555. "");
  1556. static_assert(kMax.InSeconds() == std::numeric_limits<int64_t>::max(), "");
  1557. EXPECT_EQ(kMax.InMillisecondsF(), std::numeric_limits<double>::infinity());
  1558. EXPECT_EQ(kMax.InMilliseconds(), std::numeric_limits<int64_t>::max());
  1559. EXPECT_EQ(kMax.InMillisecondsRoundedUp(), std::numeric_limits<int64_t>::max());
  1560. static_assert(Days(std::numeric_limits<int64_t>::max()).is_max(), "");
  1561. static_assert(Hours(std::numeric_limits<int64_t>::max()).is_max(), "");
  1562. static_assert(Minutes(std::numeric_limits<int64_t>::max()).is_max(), "");
  1563. constexpr int64_t max_int = std::numeric_limits<int64_t>::max();
  1564. constexpr int64_t min_int = std::numeric_limits<int64_t>::min();
  1565. static_assert(Seconds(max_int / Time::kMicrosecondsPerSecond + 1).is_max(),
  1566. "");
  1567. static_assert(
  1568. Milliseconds(max_int / Time::kMillisecondsPerSecond + 1).is_max(), "");
  1569. static_assert(Microseconds(max_int).is_max(), "");
  1570. static_assert(Seconds(min_int / Time::kMicrosecondsPerSecond - 1).is_min(),
  1571. "");
  1572. static_assert(
  1573. Milliseconds(min_int / Time::kMillisecondsPerSecond - 1).is_min(), "");
  1574. static_assert(Microseconds(min_int).is_min(), "");
  1575. static_assert(Microseconds(std::numeric_limits<int64_t>::min()).is_min(), "");
  1576. static_assert(Seconds(std::numeric_limits<double>::infinity()).is_max(), "");
  1577. // Note that max_int/min_int will be rounded when converted to doubles - they
  1578. // can't be exactly represented.
  1579. constexpr double max_d = static_cast<double>(max_int);
  1580. constexpr double min_d = static_cast<double>(min_int);
  1581. static_assert(Seconds(max_d / Time::kMicrosecondsPerSecond + 1).is_max(), "");
  1582. static_assert(
  1583. Microseconds(max_d).is_max(),
  1584. "Make sure that 2^63 correctly gets clamped to `max` (crbug.com/612601)");
  1585. static_assert(Milliseconds(std::numeric_limits<double>::infinity()).is_max(),
  1586. "");
  1587. static_assert(Milliseconds(max_d / Time::kMillisecondsPerSecond * 2).is_max(),
  1588. "");
  1589. static_assert(Seconds(min_d / Time::kMicrosecondsPerSecond - 1).is_min(), "");
  1590. static_assert(Milliseconds(min_d / Time::kMillisecondsPerSecond * 2).is_min(),
  1591. "");
  1592. }
  1593. TEST(TimeDelta, MinConversions) {
  1594. constexpr TimeDelta kMin = TimeDelta::Min();
  1595. EXPECT_EQ(kMin.InDays(), std::numeric_limits<int>::min());
  1596. static_assert(kMin.InHours() == std::numeric_limits<int>::min(), "");
  1597. static_assert(kMin.InMinutes() == std::numeric_limits<int>::min(), "");
  1598. static_assert(kMin.InSecondsF() == -std::numeric_limits<double>::infinity(),
  1599. "");
  1600. static_assert(kMin.InSeconds() == std::numeric_limits<int64_t>::min(), "");
  1601. EXPECT_EQ(kMin.InMillisecondsF(), -std::numeric_limits<double>::infinity());
  1602. EXPECT_EQ(kMin.InMilliseconds(), std::numeric_limits<int64_t>::min());
  1603. EXPECT_EQ(kMin.InMillisecondsRoundedUp(),
  1604. std::numeric_limits<int64_t>::min());
  1605. }
  1606. TEST(TimeDelta, FiniteMaxMin) {
  1607. constexpr TimeDelta kFiniteMax = TimeDelta::FiniteMax();
  1608. constexpr TimeDelta kUnit = Microseconds(1);
  1609. static_assert(kFiniteMax + kUnit == TimeDelta::Max(), "");
  1610. static_assert(kFiniteMax - kUnit < kFiniteMax, "");
  1611. constexpr TimeDelta kFiniteMin = TimeDelta::FiniteMin();
  1612. static_assert(kFiniteMin - kUnit == TimeDelta::Min(), "");
  1613. static_assert(kFiniteMin + kUnit > kFiniteMin, "");
  1614. }
  1615. TEST(TimeDelta, NumericOperators) {
  1616. constexpr double d = 0.5;
  1617. static_assert(Milliseconds(500) == Milliseconds(1000) * d, "");
  1618. static_assert(Milliseconds(2000) == (Milliseconds(1000) / d), "");
  1619. static_assert(Milliseconds(500) == (Milliseconds(1000) *= d), "");
  1620. static_assert(Milliseconds(2000) == (Milliseconds(1000) /= d), "");
  1621. static_assert(Milliseconds(500) == d * Milliseconds(1000), "");
  1622. constexpr float f = 0.5;
  1623. static_assert(Milliseconds(500) == Milliseconds(1000) * f, "");
  1624. static_assert(Milliseconds(2000) == (Milliseconds(1000) / f), "");
  1625. static_assert(Milliseconds(500) == (Milliseconds(1000) *= f), "");
  1626. static_assert(Milliseconds(2000) == (Milliseconds(1000) /= f), "");
  1627. static_assert(Milliseconds(500) == f * Milliseconds(1000), "");
  1628. constexpr int i = 2;
  1629. static_assert(Milliseconds(2000) == Milliseconds(1000) * i, "");
  1630. static_assert(Milliseconds(500) == (Milliseconds(1000) / i), "");
  1631. static_assert(Milliseconds(2000) == (Milliseconds(1000) *= i), "");
  1632. static_assert(Milliseconds(500) == (Milliseconds(1000) /= i), "");
  1633. static_assert(Milliseconds(2000) == i * Milliseconds(1000), "");
  1634. constexpr int64_t i64 = 2;
  1635. static_assert(Milliseconds(2000) == Milliseconds(1000) * i64, "");
  1636. static_assert(Milliseconds(500) == (Milliseconds(1000) / i64), "");
  1637. static_assert(Milliseconds(2000) == (Milliseconds(1000) *= i64), "");
  1638. static_assert(Milliseconds(500) == (Milliseconds(1000) /= i64), "");
  1639. static_assert(Milliseconds(2000) == i64 * Milliseconds(1000), "");
  1640. static_assert(Milliseconds(500) == Milliseconds(1000) * 0.5, "");
  1641. static_assert(Milliseconds(2000) == (Milliseconds(1000) / 0.5), "");
  1642. static_assert(Milliseconds(500) == (Milliseconds(1000) *= 0.5), "");
  1643. static_assert(Milliseconds(2000) == (Milliseconds(1000) /= 0.5), "");
  1644. static_assert(Milliseconds(500) == 0.5 * Milliseconds(1000), "");
  1645. static_assert(Milliseconds(2000) == Milliseconds(1000) * 2, "");
  1646. static_assert(Milliseconds(500) == (Milliseconds(1000) / 2), "");
  1647. static_assert(Milliseconds(2000) == (Milliseconds(1000) *= 2), "");
  1648. static_assert(Milliseconds(500) == (Milliseconds(1000) /= 2), "");
  1649. static_assert(Milliseconds(2000) == 2 * Milliseconds(1000), "");
  1650. }
  1651. // Basic test of operators between TimeDeltas (without overflow -- next test
  1652. // handles overflow).
  1653. TEST(TimeDelta, TimeDeltaOperators) {
  1654. constexpr TimeDelta kElevenSeconds = Seconds(11);
  1655. constexpr TimeDelta kThreeSeconds = Seconds(3);
  1656. static_assert(Seconds(14) == kElevenSeconds + kThreeSeconds, "");
  1657. static_assert(Seconds(14) == kThreeSeconds + kElevenSeconds, "");
  1658. static_assert(Seconds(8) == kElevenSeconds - kThreeSeconds, "");
  1659. static_assert(Seconds(-8) == kThreeSeconds - kElevenSeconds, "");
  1660. static_assert(11.0 / 3.0 == kElevenSeconds / kThreeSeconds, "");
  1661. static_assert(3.0 / 11.0 == kThreeSeconds / kElevenSeconds, "");
  1662. static_assert(3 == kElevenSeconds.IntDiv(kThreeSeconds), "");
  1663. static_assert(0 == kThreeSeconds.IntDiv(kElevenSeconds), "");
  1664. static_assert(Seconds(2) == kElevenSeconds % kThreeSeconds, "");
  1665. }
  1666. TEST(TimeDelta, Overflows) {
  1667. // Some sanity checks. static_asserts used where possible to verify constexpr
  1668. // evaluation at the same time.
  1669. static_assert(TimeDelta::Max().is_max(), "");
  1670. static_assert(TimeDelta::Max().is_positive(), "");
  1671. static_assert((-TimeDelta::Max()).is_negative(), "");
  1672. static_assert(-TimeDelta::Max() == TimeDelta::Min(), "");
  1673. static_assert(TimeDelta() > -TimeDelta::Max(), "");
  1674. static_assert(TimeDelta::Min().is_min(), "");
  1675. static_assert(TimeDelta::Min().is_negative(), "");
  1676. static_assert((-TimeDelta::Min()).is_positive(), "");
  1677. static_assert(-TimeDelta::Min() == TimeDelta::Max(), "");
  1678. static_assert(TimeDelta() < -TimeDelta::Min(), "");
  1679. constexpr TimeDelta kLargeDelta = TimeDelta::Max() - Milliseconds(1);
  1680. constexpr TimeDelta kLargeNegative = -kLargeDelta;
  1681. static_assert(TimeDelta() > kLargeNegative, "");
  1682. static_assert(!kLargeDelta.is_max(), "");
  1683. static_assert(!(-kLargeNegative).is_min(), "");
  1684. // Test +, -, * and / operators.
  1685. constexpr TimeDelta kOneSecond = Seconds(1);
  1686. static_assert((kLargeDelta + kOneSecond).is_max(), "");
  1687. static_assert((kLargeNegative + (-kOneSecond)).is_min(), "");
  1688. static_assert((kLargeNegative - kOneSecond).is_min(), "");
  1689. static_assert((kLargeDelta - (-kOneSecond)).is_max(), "");
  1690. static_assert((kLargeDelta * 2).is_max(), "");
  1691. static_assert((kLargeDelta * -2).is_min(), "");
  1692. static_assert((kLargeDelta / 0.5).is_max(), "");
  1693. static_assert((kLargeDelta / -0.5).is_min(), "");
  1694. // Test math operators on Max() and Min() values
  1695. // Calculations that would overflow are saturated.
  1696. static_assert(TimeDelta::Max() + kOneSecond == TimeDelta::Max(), "");
  1697. static_assert(TimeDelta::Max() * 7 == TimeDelta::Max(), "");
  1698. static_assert(TimeDelta::FiniteMax() + kOneSecond == TimeDelta::Max(), "");
  1699. static_assert(TimeDelta::Min() - kOneSecond == TimeDelta::Min(), "");
  1700. static_assert(TimeDelta::Min() * 7 == TimeDelta::Min(), "");
  1701. static_assert(TimeDelta::FiniteMin() - kOneSecond == TimeDelta::Min(), "");
  1702. // Division is done by converting to double with Max()/Min() converted to
  1703. // +/- infinities.
  1704. static_assert(
  1705. TimeDelta::Max() / kOneSecond == std::numeric_limits<double>::infinity(),
  1706. "");
  1707. static_assert(TimeDelta::Max() / -kOneSecond ==
  1708. -std::numeric_limits<double>::infinity(),
  1709. "");
  1710. static_assert(
  1711. TimeDelta::Min() / kOneSecond == -std::numeric_limits<double>::infinity(),
  1712. "");
  1713. static_assert(
  1714. TimeDelta::Min() / -kOneSecond == std::numeric_limits<double>::infinity(),
  1715. "");
  1716. static_assert(TimeDelta::Max().IntDiv(kOneSecond) ==
  1717. std::numeric_limits<int64_t>::max(),
  1718. "");
  1719. static_assert(TimeDelta::Max().IntDiv(-kOneSecond) ==
  1720. std::numeric_limits<int64_t>::min(),
  1721. "");
  1722. static_assert(TimeDelta::Min().IntDiv(kOneSecond) ==
  1723. std::numeric_limits<int64_t>::min(),
  1724. "");
  1725. static_assert(TimeDelta::Min().IntDiv(-kOneSecond) ==
  1726. std::numeric_limits<int64_t>::max(),
  1727. "");
  1728. static_assert(TimeDelta::Max() % kOneSecond == TimeDelta::Max(), "");
  1729. static_assert(TimeDelta::Max() % -kOneSecond == TimeDelta::Max(), "");
  1730. static_assert(TimeDelta::Min() % kOneSecond == TimeDelta::Min(), "");
  1731. static_assert(TimeDelta::Min() % -kOneSecond == TimeDelta::Min(), "");
  1732. // Division by zero.
  1733. static_assert((kOneSecond / 0).is_max(), "");
  1734. static_assert((-kOneSecond / 0).is_min(), "");
  1735. static_assert((TimeDelta::Max() / 0).is_max(), "");
  1736. static_assert((TimeDelta::Min() / 0).is_min(), "");
  1737. EXPECT_EQ(std::numeric_limits<double>::infinity(), kOneSecond / TimeDelta());
  1738. EXPECT_EQ(-std::numeric_limits<double>::infinity(),
  1739. -kOneSecond / TimeDelta());
  1740. EXPECT_EQ(std::numeric_limits<double>::infinity(),
  1741. TimeDelta::Max() / TimeDelta());
  1742. EXPECT_EQ(-std::numeric_limits<double>::infinity(),
  1743. TimeDelta::Min() / TimeDelta());
  1744. static_assert(
  1745. kOneSecond.IntDiv(TimeDelta()) == std::numeric_limits<int64_t>::max(),
  1746. "");
  1747. static_assert(
  1748. (-kOneSecond).IntDiv(TimeDelta()) == std::numeric_limits<int64_t>::min(),
  1749. "");
  1750. static_assert(TimeDelta::Max().IntDiv(TimeDelta()) ==
  1751. std::numeric_limits<int64_t>::max(),
  1752. "");
  1753. static_assert(TimeDelta::Min().IntDiv(TimeDelta()) ==
  1754. std::numeric_limits<int64_t>::min(),
  1755. "");
  1756. static_assert(kOneSecond % TimeDelta() == kOneSecond, "");
  1757. static_assert(-kOneSecond % TimeDelta() == -kOneSecond, "");
  1758. static_assert(TimeDelta::Max() % TimeDelta() == TimeDelta::Max(), "");
  1759. static_assert(TimeDelta::Min() % TimeDelta() == TimeDelta::Min(), "");
  1760. // Division by infinity.
  1761. static_assert(kLargeDelta / TimeDelta::Min() == 0, "");
  1762. static_assert(kLargeDelta / TimeDelta::Max() == 0, "");
  1763. static_assert(kLargeNegative / TimeDelta::Min() == 0, "");
  1764. static_assert(kLargeNegative / TimeDelta::Max() == 0, "");
  1765. static_assert(kLargeDelta.IntDiv(TimeDelta::Min()) == 0, "");
  1766. static_assert(kLargeDelta.IntDiv(TimeDelta::Max()) == 0, "");
  1767. static_assert(kLargeNegative.IntDiv(TimeDelta::Min()) == 0, "");
  1768. static_assert(kLargeNegative.IntDiv(TimeDelta::Max()) == 0, "");
  1769. static_assert(kOneSecond % TimeDelta::Min() == kOneSecond, "");
  1770. static_assert(kOneSecond % TimeDelta::Max() == kOneSecond, "");
  1771. // Test that double conversions overflow to infinity.
  1772. static_assert((kLargeDelta + kOneSecond).InSecondsF() ==
  1773. std::numeric_limits<double>::infinity(),
  1774. "");
  1775. EXPECT_EQ((kLargeDelta + kOneSecond).InMillisecondsF(),
  1776. std::numeric_limits<double>::infinity());
  1777. EXPECT_EQ((kLargeDelta + kOneSecond).InMicrosecondsF(),
  1778. std::numeric_limits<double>::infinity());
  1779. // Test op=.
  1780. static_assert((TimeDelta::FiniteMax() += kOneSecond).is_max(), "");
  1781. static_assert((TimeDelta::FiniteMin() += -kOneSecond).is_min(), "");
  1782. static_assert((TimeDelta::FiniteMin() -= kOneSecond).is_min(), "");
  1783. static_assert((TimeDelta::FiniteMax() -= -kOneSecond).is_max(), "");
  1784. static_assert((TimeDelta::FiniteMax() *= 2).is_max(), "");
  1785. static_assert((TimeDelta::FiniteMin() *= 1.5).is_min(), "");
  1786. static_assert((TimeDelta::FiniteMax() /= 0.5).is_max(), "");
  1787. static_assert((TimeDelta::FiniteMin() /= 0.5).is_min(), "");
  1788. static_assert((Seconds(1) %= TimeDelta::Max()) == Seconds(1), "");
  1789. static_assert((Seconds(1) %= TimeDelta()) == Seconds(1), "");
  1790. // Test operations with Time and TimeTicks.
  1791. EXPECT_TRUE((kLargeDelta + Time::Now()).is_max());
  1792. EXPECT_TRUE((kLargeDelta + TimeTicks::Now()).is_max());
  1793. EXPECT_TRUE((Time::Now() + kLargeDelta).is_max());
  1794. EXPECT_TRUE((TimeTicks::Now() + kLargeDelta).is_max());
  1795. Time time_now = Time::Now();
  1796. EXPECT_EQ(kOneSecond, (time_now + kOneSecond) - time_now);
  1797. EXPECT_EQ(-kOneSecond, (time_now - kOneSecond) - time_now);
  1798. TimeTicks ticks_now = TimeTicks::Now();
  1799. EXPECT_EQ(-kOneSecond, (ticks_now - kOneSecond) - ticks_now);
  1800. EXPECT_EQ(kOneSecond, (ticks_now + kOneSecond) - ticks_now);
  1801. }
  1802. TEST(TimeDelta, CeilToMultiple) {
  1803. for (const auto interval : {Seconds(10), Seconds(-10)}) {
  1804. SCOPED_TRACE(interval);
  1805. EXPECT_EQ(TimeDelta().CeilToMultiple(interval), TimeDelta());
  1806. EXPECT_EQ(Seconds(1).CeilToMultiple(interval), Seconds(10));
  1807. EXPECT_EQ(Seconds(9).CeilToMultiple(interval), Seconds(10));
  1808. EXPECT_EQ(Seconds(10).CeilToMultiple(interval), Seconds(10));
  1809. EXPECT_EQ(Seconds(15).CeilToMultiple(interval), Seconds(20));
  1810. EXPECT_EQ(Seconds(20).CeilToMultiple(interval), Seconds(20));
  1811. EXPECT_EQ(TimeDelta::Max().CeilToMultiple(interval), TimeDelta::Max());
  1812. EXPECT_EQ(Seconds(-1).CeilToMultiple(interval), TimeDelta());
  1813. EXPECT_EQ(Seconds(-9).CeilToMultiple(interval), TimeDelta());
  1814. EXPECT_EQ(Seconds(-10).CeilToMultiple(interval), Seconds(-10));
  1815. EXPECT_EQ(Seconds(-15).CeilToMultiple(interval), Seconds(-10));
  1816. EXPECT_EQ(Seconds(-20).CeilToMultiple(interval), Seconds(-20));
  1817. EXPECT_EQ(TimeDelta::Min().CeilToMultiple(interval), TimeDelta::Min());
  1818. }
  1819. for (const auto interval : {TimeDelta::Max(), TimeDelta::Min()}) {
  1820. SCOPED_TRACE(interval);
  1821. EXPECT_EQ(TimeDelta().CeilToMultiple(interval), TimeDelta());
  1822. EXPECT_EQ(Seconds(1).CeilToMultiple(interval), TimeDelta::Max());
  1823. EXPECT_EQ(Seconds(9).CeilToMultiple(interval), TimeDelta::Max());
  1824. EXPECT_EQ(Seconds(10).CeilToMultiple(interval), TimeDelta::Max());
  1825. EXPECT_EQ(Seconds(15).CeilToMultiple(interval), TimeDelta::Max());
  1826. EXPECT_EQ(Seconds(20).CeilToMultiple(interval), TimeDelta::Max());
  1827. EXPECT_EQ(TimeDelta::Max().CeilToMultiple(interval), TimeDelta::Max());
  1828. EXPECT_EQ(Seconds(-1).CeilToMultiple(interval), TimeDelta());
  1829. EXPECT_EQ(Seconds(-9).CeilToMultiple(interval), TimeDelta());
  1830. EXPECT_EQ(Seconds(-10).CeilToMultiple(interval), TimeDelta());
  1831. EXPECT_EQ(Seconds(-15).CeilToMultiple(interval), TimeDelta());
  1832. EXPECT_EQ(Seconds(-20).CeilToMultiple(interval), TimeDelta());
  1833. EXPECT_EQ(TimeDelta::Min().CeilToMultiple(interval), TimeDelta::Min());
  1834. }
  1835. }
  1836. TEST(TimeDelta, FloorToMultiple) {
  1837. for (const auto interval : {Seconds(10), Seconds(-10)}) {
  1838. SCOPED_TRACE(interval);
  1839. EXPECT_EQ(TimeDelta().FloorToMultiple(interval), TimeDelta());
  1840. EXPECT_EQ(Seconds(1).FloorToMultiple(interval), TimeDelta());
  1841. EXPECT_EQ(Seconds(9).FloorToMultiple(interval), TimeDelta());
  1842. EXPECT_EQ(Seconds(10).FloorToMultiple(interval), Seconds(10));
  1843. EXPECT_EQ(Seconds(15).FloorToMultiple(interval), Seconds(10));
  1844. EXPECT_EQ(Seconds(20).FloorToMultiple(interval), Seconds(20));
  1845. EXPECT_EQ(TimeDelta::Max().FloorToMultiple(interval), TimeDelta::Max());
  1846. EXPECT_EQ(Seconds(-1).FloorToMultiple(interval), Seconds(-10));
  1847. EXPECT_EQ(Seconds(-9).FloorToMultiple(interval), Seconds(-10));
  1848. EXPECT_EQ(Seconds(-10).FloorToMultiple(interval), Seconds(-10));
  1849. EXPECT_EQ(Seconds(-15).FloorToMultiple(interval), Seconds(-20));
  1850. EXPECT_EQ(Seconds(-20).FloorToMultiple(interval), Seconds(-20));
  1851. EXPECT_EQ(TimeDelta::Min().FloorToMultiple(interval), TimeDelta::Min());
  1852. }
  1853. for (const auto interval : {TimeDelta::Max(), TimeDelta::Min()}) {
  1854. SCOPED_TRACE(interval);
  1855. EXPECT_EQ(TimeDelta().FloorToMultiple(interval), TimeDelta());
  1856. EXPECT_EQ(Seconds(1).FloorToMultiple(interval), TimeDelta());
  1857. EXPECT_EQ(Seconds(9).FloorToMultiple(interval), TimeDelta());
  1858. EXPECT_EQ(Seconds(10).FloorToMultiple(interval), TimeDelta());
  1859. EXPECT_EQ(Seconds(15).FloorToMultiple(interval), TimeDelta());
  1860. EXPECT_EQ(Seconds(20).FloorToMultiple(interval), TimeDelta());
  1861. EXPECT_EQ(TimeDelta::Max().FloorToMultiple(interval), TimeDelta::Max());
  1862. EXPECT_EQ(Seconds(-1).FloorToMultiple(interval), TimeDelta::Min());
  1863. EXPECT_EQ(Seconds(-9).FloorToMultiple(interval), TimeDelta::Min());
  1864. EXPECT_EQ(Seconds(-10).FloorToMultiple(interval), TimeDelta::Min());
  1865. EXPECT_EQ(Seconds(-15).FloorToMultiple(interval), TimeDelta::Min());
  1866. EXPECT_EQ(Seconds(-20).FloorToMultiple(interval), TimeDelta::Min());
  1867. EXPECT_EQ(TimeDelta::Min().FloorToMultiple(interval), TimeDelta::Min());
  1868. }
  1869. }
  1870. TEST(TimeDelta, RoundToMultiple) {
  1871. for (const auto interval : {Seconds(10), Seconds(-10)}) {
  1872. SCOPED_TRACE(interval);
  1873. EXPECT_EQ(TimeDelta().RoundToMultiple(interval), TimeDelta());
  1874. EXPECT_EQ(Seconds(1).RoundToMultiple(interval), TimeDelta());
  1875. EXPECT_EQ(Seconds(9).RoundToMultiple(interval), Seconds(10));
  1876. EXPECT_EQ(Seconds(10).RoundToMultiple(interval), Seconds(10));
  1877. EXPECT_EQ(Seconds(15).RoundToMultiple(interval), Seconds(20));
  1878. EXPECT_EQ(Seconds(20).RoundToMultiple(interval), Seconds(20));
  1879. EXPECT_EQ(TimeDelta::Max().RoundToMultiple(interval), TimeDelta::Max());
  1880. EXPECT_EQ(Seconds(-1).RoundToMultiple(interval), TimeDelta());
  1881. EXPECT_EQ(Seconds(-9).RoundToMultiple(interval), Seconds(-10));
  1882. EXPECT_EQ(Seconds(-10).RoundToMultiple(interval), Seconds(-10));
  1883. EXPECT_EQ(Seconds(-15).RoundToMultiple(interval), Seconds(-20));
  1884. EXPECT_EQ(Seconds(-20).RoundToMultiple(interval), Seconds(-20));
  1885. EXPECT_EQ(TimeDelta::Min().RoundToMultiple(interval), TimeDelta::Min());
  1886. }
  1887. for (const auto interval : {TimeDelta::Max(), TimeDelta::Min()}) {
  1888. SCOPED_TRACE(interval);
  1889. EXPECT_EQ(TimeDelta().RoundToMultiple(interval), TimeDelta());
  1890. EXPECT_EQ(Seconds(1).RoundToMultiple(interval), TimeDelta());
  1891. EXPECT_EQ(Seconds(9).RoundToMultiple(interval), TimeDelta());
  1892. EXPECT_EQ(Seconds(10).RoundToMultiple(interval), TimeDelta());
  1893. EXPECT_EQ(Seconds(15).RoundToMultiple(interval), TimeDelta());
  1894. EXPECT_EQ(Seconds(20).RoundToMultiple(interval), TimeDelta());
  1895. EXPECT_EQ(TimeDelta::Max().RoundToMultiple(interval), TimeDelta::Max());
  1896. EXPECT_EQ(Seconds(-1).RoundToMultiple(interval), TimeDelta());
  1897. EXPECT_EQ(Seconds(-9).RoundToMultiple(interval), TimeDelta());
  1898. EXPECT_EQ(Seconds(-10).RoundToMultiple(interval), TimeDelta());
  1899. EXPECT_EQ(Seconds(-15).RoundToMultiple(interval), TimeDelta());
  1900. EXPECT_EQ(Seconds(-20).RoundToMultiple(interval), TimeDelta());
  1901. EXPECT_EQ(TimeDelta::Min().RoundToMultiple(interval), TimeDelta::Min());
  1902. }
  1903. }
  1904. TEST(TimeBase, AddSubDeltaSaturates) {
  1905. constexpr TimeTicks kLargeTimeTicks =
  1906. TimeTicks::FromInternalValue(std::numeric_limits<int64_t>::max() - 1);
  1907. constexpr TimeTicks kLargeNegativeTimeTicks =
  1908. TimeTicks::FromInternalValue(std::numeric_limits<int64_t>::min() + 1);
  1909. static_assert((kLargeTimeTicks + TimeDelta::Max()).is_max(), "");
  1910. static_assert((kLargeNegativeTimeTicks + TimeDelta::Max()).is_max(), "");
  1911. static_assert((kLargeTimeTicks - TimeDelta::Max()).is_min(), "");
  1912. static_assert((kLargeNegativeTimeTicks - TimeDelta::Max()).is_min(), "");
  1913. static_assert((TimeTicks() + TimeDelta::Max()).is_max(), "");
  1914. static_assert((TimeTicks() - TimeDelta::Max()).is_min(), "");
  1915. EXPECT_TRUE((TimeTicks::Now() + TimeDelta::Max()).is_max())
  1916. << (TimeTicks::Now() + TimeDelta::Max());
  1917. EXPECT_TRUE((TimeTicks::Now() - TimeDelta::Max()).is_min())
  1918. << (TimeTicks::Now() - TimeDelta::Max());
  1919. static_assert((kLargeTimeTicks + TimeDelta::Min()).is_min(), "");
  1920. static_assert((kLargeNegativeTimeTicks + TimeDelta::Min()).is_min(), "");
  1921. static_assert((kLargeTimeTicks - TimeDelta::Min()).is_max(), "");
  1922. static_assert((kLargeNegativeTimeTicks - TimeDelta::Min()).is_max(), "");
  1923. static_assert((TimeTicks() + TimeDelta::Min()).is_min(), "");
  1924. static_assert((TimeTicks() - TimeDelta::Min()).is_max(), "");
  1925. EXPECT_TRUE((TimeTicks::Now() + TimeDelta::Min()).is_min())
  1926. << (TimeTicks::Now() + TimeDelta::Min());
  1927. EXPECT_TRUE((TimeTicks::Now() - TimeDelta::Min()).is_max())
  1928. << (TimeTicks::Now() - TimeDelta::Min());
  1929. }
  1930. TEST(TimeBase, AddSubInfinities) {
  1931. // CHECK when adding opposite signs or subtracting same sign.
  1932. EXPECT_CHECK_DEATH({ TimeTicks::Min() + TimeDelta::Max(); });
  1933. EXPECT_CHECK_DEATH({ TimeTicks::Max() + TimeDelta::Min(); });
  1934. EXPECT_CHECK_DEATH({ TimeTicks::Min() - TimeDelta::Min(); });
  1935. EXPECT_CHECK_DEATH({ TimeTicks::Max() - TimeDelta::Max(); });
  1936. // Saturates when adding same sign or subtracting opposite signs.
  1937. static_assert((TimeTicks::Max() + TimeDelta::Max()).is_max(), "");
  1938. static_assert((TimeTicks::Min() + TimeDelta::Min()).is_min(), "");
  1939. static_assert((TimeTicks::Max() - TimeDelta::Min()).is_max(), "");
  1940. static_assert((TimeTicks::Min() - TimeDelta::Max()).is_min(), "");
  1941. }
  1942. constexpr TimeTicks TestTimeTicksConstexprCopyAssignment() {
  1943. TimeTicks a = TimeTicks::FromInternalValue(12345);
  1944. TimeTicks b;
  1945. b = a;
  1946. return b;
  1947. }
  1948. TEST(TimeTicks, ConstexprAndTriviallyCopiable) {
  1949. // "Trivially copyable" is necessary for use in std::atomic<TimeTicks>.
  1950. static_assert(std::is_trivially_copyable<TimeTicks>(), "");
  1951. // Copy ctor.
  1952. constexpr TimeTicks a = TimeTicks::FromInternalValue(12345);
  1953. constexpr TimeTicks b{a};
  1954. static_assert(a.ToInternalValue() == b.ToInternalValue(), "");
  1955. // Copy assignment.
  1956. static_assert(a.ToInternalValue() ==
  1957. TestTimeTicksConstexprCopyAssignment().ToInternalValue(),
  1958. "");
  1959. }
  1960. constexpr ThreadTicks TestThreadTicksConstexprCopyAssignment() {
  1961. ThreadTicks a = ThreadTicks::FromInternalValue(12345);
  1962. ThreadTicks b;
  1963. b = a;
  1964. return b;
  1965. }
  1966. TEST(ThreadTicks, ConstexprAndTriviallyCopiable) {
  1967. // "Trivially copyable" is necessary for use in std::atomic<ThreadTicks>.
  1968. static_assert(std::is_trivially_copyable<ThreadTicks>(), "");
  1969. // Copy ctor.
  1970. constexpr ThreadTicks a = ThreadTicks::FromInternalValue(12345);
  1971. constexpr ThreadTicks b{a};
  1972. static_assert(a.ToInternalValue() == b.ToInternalValue(), "");
  1973. // Copy assignment.
  1974. static_assert(a.ToInternalValue() ==
  1975. TestThreadTicksConstexprCopyAssignment().ToInternalValue(),
  1976. "");
  1977. }
  1978. constexpr TimeDelta TestTimeDeltaConstexprCopyAssignment() {
  1979. TimeDelta a = Seconds(1);
  1980. TimeDelta b;
  1981. b = a;
  1982. return b;
  1983. }
  1984. TEST(TimeDelta, ConstexprAndTriviallyCopiable) {
  1985. // "Trivially copyable" is necessary for use in std::atomic<TimeDelta>.
  1986. static_assert(std::is_trivially_copyable<TimeDelta>(), "");
  1987. // Copy ctor.
  1988. constexpr TimeDelta a = Seconds(1);
  1989. constexpr TimeDelta b{a};
  1990. static_assert(a == b, "");
  1991. // Copy assignment.
  1992. static_assert(a == TestTimeDeltaConstexprCopyAssignment(), "");
  1993. }
  1994. TEST(TimeDeltaLogging, DCheckEqCompiles) {
  1995. DCHECK_EQ(TimeDelta(), TimeDelta());
  1996. }
  1997. TEST(TimeDeltaLogging, EmptyIsZero) {
  1998. constexpr TimeDelta kZero;
  1999. EXPECT_EQ("0 s", AnyToString(kZero));
  2000. }
  2001. TEST(TimeDeltaLogging, FiveHundredMs) {
  2002. constexpr TimeDelta kFiveHundredMs = Milliseconds(500);
  2003. EXPECT_EQ("0.5 s", AnyToString(kFiveHundredMs));
  2004. }
  2005. TEST(TimeDeltaLogging, MinusTenSeconds) {
  2006. constexpr TimeDelta kMinusTenSeconds = Seconds(-10);
  2007. EXPECT_EQ("-10 s", AnyToString(kMinusTenSeconds));
  2008. }
  2009. TEST(TimeDeltaLogging, DoesNotMessUpFormattingFlags) {
  2010. std::ostringstream oss;
  2011. std::ios_base::fmtflags flags_before = oss.flags();
  2012. oss << TimeDelta();
  2013. EXPECT_EQ(flags_before, oss.flags());
  2014. }
  2015. TEST(TimeDeltaLogging, DoesNotMakeStreamBad) {
  2016. std::ostringstream oss;
  2017. oss << TimeDelta();
  2018. EXPECT_TRUE(oss.good());
  2019. }
  2020. TEST(TimeLogging, DCheckEqCompiles) {
  2021. DCHECK_EQ(Time(), Time());
  2022. }
  2023. TEST(TimeLogging, ChromeBirthdate) {
  2024. Time birthdate;
  2025. ASSERT_TRUE(Time::FromString("Tue, 02 Sep 2008 09:42:18 GMT", &birthdate));
  2026. EXPECT_EQ("2008-09-02 09:42:18.000 UTC", AnyToString(birthdate));
  2027. }
  2028. TEST(TimeLogging, DoesNotMessUpFormattingFlags) {
  2029. std::ostringstream oss;
  2030. std::ios_base::fmtflags flags_before = oss.flags();
  2031. oss << Time();
  2032. EXPECT_EQ(flags_before, oss.flags());
  2033. }
  2034. TEST(TimeLogging, DoesNotMakeStreamBad) {
  2035. std::ostringstream oss;
  2036. oss << Time();
  2037. EXPECT_TRUE(oss.good());
  2038. }
  2039. TEST(TimeTicksLogging, DCheckEqCompiles) {
  2040. DCHECK_EQ(TimeTicks(), TimeTicks());
  2041. }
  2042. TEST(TimeTicksLogging, ZeroTime) {
  2043. TimeTicks zero;
  2044. EXPECT_EQ("0 bogo-microseconds", AnyToString(zero));
  2045. }
  2046. TEST(TimeTicksLogging, FortyYearsLater) {
  2047. TimeTicks forty_years_later = TimeTicks() + Days(365.25 * 40);
  2048. EXPECT_EQ("1262304000000000 bogo-microseconds",
  2049. AnyToString(forty_years_later));
  2050. }
  2051. TEST(TimeTicksLogging, DoesNotMessUpFormattingFlags) {
  2052. std::ostringstream oss;
  2053. std::ios_base::fmtflags flags_before = oss.flags();
  2054. oss << TimeTicks();
  2055. EXPECT_EQ(flags_before, oss.flags());
  2056. }
  2057. TEST(TimeTicksLogging, DoesNotMakeStreamBad) {
  2058. std::ostringstream oss;
  2059. oss << TimeTicks();
  2060. EXPECT_TRUE(oss.good());
  2061. }
  2062. } // namespace
  2063. } // namespace base