1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <time.h> 18 19 #include <errno.h> 20 #include <gtest/gtest.h> 21 #include <pthread.h> 22 #include <signal.h> 23 #include <sys/syscall.h> 24 #include <sys/types.h> 25 #include <sys/wait.h> 26 #include <unistd.h> 27 #include <atomic> 28 29 #include "ScopedSignalHandler.h" 30 #include "utils.h" 31 32 #include "private/bionic_constants.h" 33 34 TEST(time, gmtime) { 35 time_t t = 0; 36 tm* broken_down = gmtime(&t); 37 ASSERT_TRUE(broken_down != NULL); 38 ASSERT_EQ(0, broken_down->tm_sec); 39 ASSERT_EQ(0, broken_down->tm_min); 40 ASSERT_EQ(0, broken_down->tm_hour); 41 ASSERT_EQ(1, broken_down->tm_mday); 42 ASSERT_EQ(0, broken_down->tm_mon); 43 ASSERT_EQ(1970, broken_down->tm_year + 1900); 44 } 45 46 static void* gmtime_no_stack_overflow_14313703_fn(void*) { 47 const char* original_tz = getenv("TZ"); 48 // Ensure we'll actually have to enter tzload by using a time zone that doesn't exist. 49 setenv("TZ", "gmtime_stack_overflow_14313703", 1); 50 tzset(); 51 if (original_tz != NULL) { 52 setenv("TZ", original_tz, 1); 53 } 54 tzset(); 55 return NULL; 56 } 57 58 TEST(time, gmtime_no_stack_overflow_14313703) { 59 // Is it safe to call tzload on a thread with a small stack? 60 // http://b/14313703 61 // https://code.google.com/p/android/issues/detail?id=61130 62 pthread_attr_t a; 63 ASSERT_EQ(0, pthread_attr_init(&a)); 64 ASSERT_EQ(0, pthread_attr_setstacksize(&a, PTHREAD_STACK_MIN)); 65 66 pthread_t t; 67 ASSERT_EQ(0, pthread_create(&t, &a, gmtime_no_stack_overflow_14313703_fn, NULL)); 68 ASSERT_EQ(0, pthread_join(t, nullptr)); 69 } 70 71 TEST(time, mktime_empty_TZ) { 72 // tzcode used to have a bug where it didn't reinitialize some internal state. 73 74 // Choose a time where DST is set. 75 struct tm t; 76 memset(&t, 0, sizeof(tm)); 77 t.tm_year = 1980 - 1900; 78 t.tm_mon = 6; 79 t.tm_mday = 2; 80 81 setenv("TZ", "America/Los_Angeles", 1); 82 tzset(); 83 ASSERT_EQ(static_cast<time_t>(331372800U), mktime(&t)); 84 85 memset(&t, 0, sizeof(tm)); 86 t.tm_year = 1980 - 1900; 87 t.tm_mon = 6; 88 t.tm_mday = 2; 89 90 setenv("TZ", "", 1); // Implies UTC. 91 tzset(); 92 ASSERT_EQ(static_cast<time_t>(331344000U), mktime(&t)); 93 } 94 95 TEST(time, mktime_10310929) { 96 struct tm t; 97 memset(&t, 0, sizeof(tm)); 98 t.tm_year = 200; 99 t.tm_mon = 2; 100 t.tm_mday = 10; 101 102 #if !defined(__LP64__) 103 // 32-bit bionic stupidly had a signed 32-bit time_t. 104 ASSERT_EQ(-1, mktime(&t)); 105 ASSERT_EQ(EOVERFLOW, errno); 106 #else 107 // Everyone else should be using a signed 64-bit time_t. 108 ASSERT_GE(sizeof(time_t) * 8, 64U); 109 110 setenv("TZ", "America/Los_Angeles", 1); 111 tzset(); 112 errno = 0; 113 ASSERT_EQ(static_cast<time_t>(4108348800U), mktime(&t)); 114 ASSERT_EQ(0, errno); 115 116 setenv("TZ", "UTC", 1); 117 tzset(); 118 errno = 0; 119 ASSERT_EQ(static_cast<time_t>(4108320000U), mktime(&t)); 120 ASSERT_EQ(0, errno); 121 #endif 122 } 123 124 TEST(time, mktime_EOVERFLOW) { 125 struct tm t; 126 memset(&t, 0, sizeof(tm)); 127 128 // LP32 year range is 1901-2038, so this year is guaranteed not to overflow. 129 t.tm_year = 2016 - 1900; 130 131 t.tm_mon = 2; 132 t.tm_mday = 10; 133 134 errno = 0; 135 ASSERT_NE(static_cast<time_t>(-1), mktime(&t)); 136 ASSERT_EQ(0, errno); 137 138 // This will overflow for LP32 or LP64. 139 t.tm_year = INT_MAX; 140 141 errno = 0; 142 ASSERT_EQ(static_cast<time_t>(-1), mktime(&t)); 143 ASSERT_EQ(EOVERFLOW, errno); 144 } 145 146 TEST(time, strftime) { 147 setenv("TZ", "UTC", 1); 148 149 struct tm t; 150 memset(&t, 0, sizeof(tm)); 151 t.tm_year = 200; 152 t.tm_mon = 2; 153 t.tm_mday = 10; 154 155 char buf[64]; 156 157 // Seconds since the epoch. 158 #if defined(__BIONIC__) || defined(__LP64__) // Not 32-bit glibc. 159 EXPECT_EQ(10U, strftime(buf, sizeof(buf), "%s", &t)); 160 EXPECT_STREQ("4108320000", buf); 161 #endif 162 163 // Date and time as text. 164 EXPECT_EQ(24U, strftime(buf, sizeof(buf), "%c", &t)); 165 EXPECT_STREQ("Sun Mar 10 00:00:00 2100", buf); 166 } 167 168 TEST(time, strftime_null_tm_zone) { 169 // Netflix on Nexus Player wouldn't start (http://b/25170306). 170 struct tm t; 171 memset(&t, 0, sizeof(tm)); 172 173 char buf[64]; 174 175 setenv("TZ", "America/Los_Angeles", 1); 176 tzset(); 177 178 t.tm_isdst = 0; // "0 if Daylight Savings Time is not in effect". 179 EXPECT_EQ(5U, strftime(buf, sizeof(buf), "<%Z>", &t)); 180 EXPECT_STREQ("<PST>", buf); 181 182 #if defined(__BIONIC__) // glibc 2.19 only copes with tm_isdst being 0 and 1. 183 t.tm_isdst = 2; // "positive if Daylight Savings Time is in effect" 184 EXPECT_EQ(5U, strftime(buf, sizeof(buf), "<%Z>", &t)); 185 EXPECT_STREQ("<PDT>", buf); 186 187 t.tm_isdst = -123; // "and negative if the information is not available". 188 EXPECT_EQ(2U, strftime(buf, sizeof(buf), "<%Z>", &t)); 189 EXPECT_STREQ("<>", buf); 190 #endif 191 192 setenv("TZ", "UTC", 1); 193 tzset(); 194 195 t.tm_isdst = 0; 196 EXPECT_EQ(5U, strftime(buf, sizeof(buf), "<%Z>", &t)); 197 EXPECT_STREQ("<UTC>", buf); 198 199 #if defined(__BIONIC__) // glibc 2.19 thinks UTC DST is "UTC". 200 t.tm_isdst = 1; // UTC has no DST. 201 EXPECT_EQ(2U, strftime(buf, sizeof(buf), "<%Z>", &t)); 202 EXPECT_STREQ("<>", buf); 203 #endif 204 } 205 206 TEST(time, strftime_l) { 207 locale_t cloc = newlocale(LC_ALL, "C.UTF-8", 0); 208 locale_t old_locale = uselocale(cloc); 209 210 setenv("TZ", "UTC", 1); 211 212 struct tm t; 213 memset(&t, 0, sizeof(tm)); 214 t.tm_year = 200; 215 t.tm_mon = 2; 216 t.tm_mday = 10; 217 218 // Date and time as text. 219 char buf[64]; 220 EXPECT_EQ(24U, strftime_l(buf, sizeof(buf), "%c", &t, cloc)); 221 EXPECT_STREQ("Sun Mar 10 00:00:00 2100", buf); 222 223 uselocale(old_locale); 224 freelocale(cloc); 225 } 226 227 TEST(time, strptime) { 228 setenv("TZ", "UTC", 1); 229 230 struct tm t; 231 char buf[64]; 232 233 memset(&t, 0, sizeof(t)); 234 strptime("11:14", "%R", &t); 235 strftime(buf, sizeof(buf), "%H:%M", &t); 236 EXPECT_STREQ("11:14", buf); 237 238 memset(&t, 0, sizeof(t)); 239 strptime("09:41:53", "%T", &t); 240 strftime(buf, sizeof(buf), "%H:%M:%S", &t); 241 EXPECT_STREQ("09:41:53", buf); 242 } 243 244 void SetTime(timer_t t, time_t value_s, time_t value_ns, time_t interval_s, time_t interval_ns) { 245 itimerspec ts; 246 ts.it_value.tv_sec = value_s; 247 ts.it_value.tv_nsec = value_ns; 248 ts.it_interval.tv_sec = interval_s; 249 ts.it_interval.tv_nsec = interval_ns; 250 ASSERT_EQ(0, timer_settime(t, 0, &ts, NULL)); 251 } 252 253 static void NoOpNotifyFunction(sigval_t) { 254 } 255 256 TEST(time, timer_create) { 257 sigevent_t se; 258 memset(&se, 0, sizeof(se)); 259 se.sigev_notify = SIGEV_THREAD; 260 se.sigev_notify_function = NoOpNotifyFunction; 261 timer_t timer_id; 262 ASSERT_EQ(0, timer_create(CLOCK_MONOTONIC, &se, &timer_id)); 263 264 pid_t pid = fork(); 265 ASSERT_NE(-1, pid) << strerror(errno); 266 267 if (pid == 0) { 268 // Timers are not inherited by the child. 269 ASSERT_EQ(-1, timer_delete(timer_id)); 270 ASSERT_EQ(EINVAL, errno); 271 _exit(0); 272 } 273 274 AssertChildExited(pid, 0); 275 276 ASSERT_EQ(0, timer_delete(timer_id)); 277 } 278 279 static int timer_create_SIGEV_SIGNAL_signal_handler_invocation_count; 280 static void timer_create_SIGEV_SIGNAL_signal_handler(int signal_number) { 281 ++timer_create_SIGEV_SIGNAL_signal_handler_invocation_count; 282 ASSERT_EQ(SIGUSR1, signal_number); 283 } 284 285 TEST(time, timer_create_SIGEV_SIGNAL) { 286 sigevent_t se; 287 memset(&se, 0, sizeof(se)); 288 se.sigev_notify = SIGEV_SIGNAL; 289 se.sigev_signo = SIGUSR1; 290 291 timer_t timer_id; 292 ASSERT_EQ(0, timer_create(CLOCK_MONOTONIC, &se, &timer_id)); 293 294 timer_create_SIGEV_SIGNAL_signal_handler_invocation_count = 0; 295 ScopedSignalHandler ssh(SIGUSR1, timer_create_SIGEV_SIGNAL_signal_handler); 296 297 ASSERT_EQ(0, timer_create_SIGEV_SIGNAL_signal_handler_invocation_count); 298 299 itimerspec ts; 300 ts.it_value.tv_sec = 0; 301 ts.it_value.tv_nsec = 1; 302 ts.it_interval.tv_sec = 0; 303 ts.it_interval.tv_nsec = 0; 304 ASSERT_EQ(0, timer_settime(timer_id, 0, &ts, NULL)); 305 306 usleep(500000); 307 ASSERT_EQ(1, timer_create_SIGEV_SIGNAL_signal_handler_invocation_count); 308 } 309 310 struct Counter { 311 private: 312 std::atomic<int> value; 313 timer_t timer_id; 314 sigevent_t se; 315 bool timer_valid; 316 317 void Create() { 318 ASSERT_FALSE(timer_valid); 319 ASSERT_EQ(0, timer_create(CLOCK_REALTIME, &se, &timer_id)); 320 timer_valid = true; 321 } 322 323 public: 324 explicit Counter(void (*fn)(sigval_t)) : value(0), timer_valid(false) { 325 memset(&se, 0, sizeof(se)); 326 se.sigev_notify = SIGEV_THREAD; 327 se.sigev_notify_function = fn; 328 se.sigev_value.sival_ptr = this; 329 Create(); 330 } 331 void DeleteTimer() { 332 ASSERT_TRUE(timer_valid); 333 ASSERT_EQ(0, timer_delete(timer_id)); 334 timer_valid = false; 335 } 336 337 ~Counter() { 338 if (timer_valid) { 339 DeleteTimer(); 340 } 341 } 342 343 int Value() const { 344 return value; 345 } 346 347 void SetTime(time_t value_s, time_t value_ns, time_t interval_s, time_t interval_ns) { 348 ::SetTime(timer_id, value_s, value_ns, interval_s, interval_ns); 349 } 350 351 bool ValueUpdated() { 352 int current_value = value; 353 time_t start = time(NULL); 354 while (current_value == value && (time(NULL) - start) < 5) { 355 } 356 return current_value != value; 357 } 358 359 static void CountNotifyFunction(sigval_t value) { 360 Counter* cd = reinterpret_cast<Counter*>(value.sival_ptr); 361 ++cd->value; 362 } 363 364 static void CountAndDisarmNotifyFunction(sigval_t value) { 365 Counter* cd = reinterpret_cast<Counter*>(value.sival_ptr); 366 ++cd->value; 367 368 // Setting the initial expiration time to 0 disarms the timer. 369 cd->SetTime(0, 0, 1, 0); 370 } 371 }; 372 373 TEST(time, timer_settime_0) { 374 Counter counter(Counter::CountAndDisarmNotifyFunction); 375 ASSERT_EQ(0, counter.Value()); 376 377 counter.SetTime(0, 500000000, 1, 0); 378 sleep(1); 379 380 // The count should just be 1 because we disarmed the timer the first time it fired. 381 ASSERT_EQ(1, counter.Value()); 382 } 383 384 TEST(time, timer_settime_repeats) { 385 Counter counter(Counter::CountNotifyFunction); 386 ASSERT_EQ(0, counter.Value()); 387 388 counter.SetTime(0, 1, 0, 10); 389 ASSERT_TRUE(counter.ValueUpdated()); 390 ASSERT_TRUE(counter.ValueUpdated()); 391 ASSERT_TRUE(counter.ValueUpdated()); 392 counter.DeleteTimer(); 393 // Add a sleep as other threads may be calling the callback function when the timer is deleted. 394 usleep(500000); 395 } 396 397 static int timer_create_NULL_signal_handler_invocation_count; 398 static void timer_create_NULL_signal_handler(int signal_number) { 399 ++timer_create_NULL_signal_handler_invocation_count; 400 ASSERT_EQ(SIGALRM, signal_number); 401 } 402 403 TEST(time, timer_create_NULL) { 404 // A NULL sigevent* is equivalent to asking for SIGEV_SIGNAL for SIGALRM. 405 timer_t timer_id; 406 ASSERT_EQ(0, timer_create(CLOCK_MONOTONIC, NULL, &timer_id)); 407 408 timer_create_NULL_signal_handler_invocation_count = 0; 409 ScopedSignalHandler ssh(SIGALRM, timer_create_NULL_signal_handler); 410 411 ASSERT_EQ(0, timer_create_NULL_signal_handler_invocation_count); 412 413 SetTime(timer_id, 0, 1, 0, 0); 414 usleep(500000); 415 416 ASSERT_EQ(1, timer_create_NULL_signal_handler_invocation_count); 417 } 418 419 TEST(time, timer_create_EINVAL) { 420 clockid_t invalid_clock = 16; 421 422 // A SIGEV_SIGNAL timer is easy; the kernel does all that. 423 timer_t timer_id; 424 ASSERT_EQ(-1, timer_create(invalid_clock, NULL, &timer_id)); 425 ASSERT_EQ(EINVAL, errno); 426 427 // A SIGEV_THREAD timer is more interesting because we have stuff to clean up. 428 sigevent_t se; 429 memset(&se, 0, sizeof(se)); 430 se.sigev_notify = SIGEV_THREAD; 431 se.sigev_notify_function = NoOpNotifyFunction; 432 ASSERT_EQ(-1, timer_create(invalid_clock, &se, &timer_id)); 433 ASSERT_EQ(EINVAL, errno); 434 } 435 436 TEST(time, timer_delete_multiple) { 437 timer_t timer_id; 438 ASSERT_EQ(0, timer_create(CLOCK_MONOTONIC, NULL, &timer_id)); 439 ASSERT_EQ(0, timer_delete(timer_id)); 440 ASSERT_EQ(-1, timer_delete(timer_id)); 441 ASSERT_EQ(EINVAL, errno); 442 443 sigevent_t se; 444 memset(&se, 0, sizeof(se)); 445 se.sigev_notify = SIGEV_THREAD; 446 se.sigev_notify_function = NoOpNotifyFunction; 447 ASSERT_EQ(0, timer_create(CLOCK_MONOTONIC, &se, &timer_id)); 448 ASSERT_EQ(0, timer_delete(timer_id)); 449 ASSERT_EQ(-1, timer_delete(timer_id)); 450 ASSERT_EQ(EINVAL, errno); 451 } 452 453 TEST(time, timer_create_multiple) { 454 Counter counter1(Counter::CountNotifyFunction); 455 Counter counter2(Counter::CountNotifyFunction); 456 Counter counter3(Counter::CountNotifyFunction); 457 458 ASSERT_EQ(0, counter1.Value()); 459 ASSERT_EQ(0, counter2.Value()); 460 ASSERT_EQ(0, counter3.Value()); 461 462 counter2.SetTime(0, 500000000, 0, 0); 463 sleep(1); 464 465 EXPECT_EQ(0, counter1.Value()); 466 EXPECT_EQ(1, counter2.Value()); 467 EXPECT_EQ(0, counter3.Value()); 468 } 469 470 // Test to verify that disarming a repeatable timer disables the callbacks. 471 TEST(time, timer_disarm_terminates) { 472 Counter counter(Counter::CountNotifyFunction); 473 ASSERT_EQ(0, counter.Value()); 474 475 counter.SetTime(0, 1, 0, 1); 476 ASSERT_TRUE(counter.ValueUpdated()); 477 ASSERT_TRUE(counter.ValueUpdated()); 478 ASSERT_TRUE(counter.ValueUpdated()); 479 480 counter.SetTime(0, 0, 0, 0); 481 // Add a sleep as the kernel may have pending events when the timer is disarmed. 482 usleep(500000); 483 int value = counter.Value(); 484 usleep(500000); 485 486 // Verify the counter has not been incremented. 487 ASSERT_EQ(value, counter.Value()); 488 } 489 490 // Test to verify that deleting a repeatable timer disables the callbacks. 491 TEST(time, timer_delete_terminates) { 492 Counter counter(Counter::CountNotifyFunction); 493 ASSERT_EQ(0, counter.Value()); 494 495 counter.SetTime(0, 1, 0, 1); 496 ASSERT_TRUE(counter.ValueUpdated()); 497 ASSERT_TRUE(counter.ValueUpdated()); 498 ASSERT_TRUE(counter.ValueUpdated()); 499 500 counter.DeleteTimer(); 501 // Add a sleep as other threads may be calling the callback function when the timer is deleted. 502 usleep(500000); 503 int value = counter.Value(); 504 usleep(500000); 505 506 // Verify the counter has not been incremented. 507 ASSERT_EQ(value, counter.Value()); 508 } 509 510 struct TimerDeleteData { 511 timer_t timer_id; 512 pid_t tid; 513 volatile bool complete; 514 }; 515 516 static void TimerDeleteCallback(sigval_t value) { 517 TimerDeleteData* tdd = reinterpret_cast<TimerDeleteData*>(value.sival_ptr); 518 519 tdd->tid = gettid(); 520 timer_delete(tdd->timer_id); 521 tdd->complete = true; 522 } 523 524 TEST(time, timer_delete_from_timer_thread) { 525 TimerDeleteData tdd; 526 sigevent_t se; 527 528 memset(&se, 0, sizeof(se)); 529 se.sigev_notify = SIGEV_THREAD; 530 se.sigev_notify_function = TimerDeleteCallback; 531 se.sigev_value.sival_ptr = &tdd; 532 533 tdd.complete = false; 534 ASSERT_EQ(0, timer_create(CLOCK_REALTIME, &se, &tdd.timer_id)); 535 536 itimerspec ts; 537 ts.it_value.tv_sec = 1; 538 ts.it_value.tv_nsec = 0; 539 ts.it_interval.tv_sec = 0; 540 ts.it_interval.tv_nsec = 0; 541 ASSERT_EQ(0, timer_settime(tdd.timer_id, 0, &ts, NULL)); 542 543 time_t cur_time = time(NULL); 544 while (!tdd.complete && (time(NULL) - cur_time) < 5); 545 ASSERT_TRUE(tdd.complete); 546 547 #if defined(__BIONIC__) 548 // Since bionic timers are implemented by creating a thread to handle the 549 // callback, verify that the thread actually completes. 550 cur_time = time(NULL); 551 while ((kill(tdd.tid, 0) != -1 || errno != ESRCH) && (time(NULL) - cur_time) < 5); 552 ASSERT_EQ(-1, kill(tdd.tid, 0)); 553 ASSERT_EQ(ESRCH, errno); 554 #endif 555 } 556 557 TEST(time, clock_gettime) { 558 // Try to ensure that our vdso clock_gettime is working. 559 timespec ts1; 560 ASSERT_EQ(0, clock_gettime(CLOCK_MONOTONIC, &ts1)); 561 timespec ts2; 562 ASSERT_EQ(0, syscall(__NR_clock_gettime, CLOCK_MONOTONIC, &ts2)); 563 564 // What's the difference between the two? 565 ts2.tv_sec -= ts1.tv_sec; 566 ts2.tv_nsec -= ts1.tv_nsec; 567 if (ts2.tv_nsec < 0) { 568 --ts2.tv_sec; 569 ts2.tv_nsec += NS_PER_S; 570 } 571 572 // Should be less than (a very generous, to try to avoid flakiness) 1000000ns. 573 ASSERT_EQ(0, ts2.tv_sec); 574 ASSERT_LT(ts2.tv_nsec, 1000000); 575 } 576 577 TEST(time, clock) { 578 // clock(3) is hard to test, but a 1s sleep should cost less than 1ms. 579 clock_t t0 = clock(); 580 sleep(1); 581 clock_t t1 = clock(); 582 ASSERT_LT(t1 - t0, CLOCKS_PER_SEC / 1000); 583 } 584 585 pid_t GetInvalidPid() { 586 FILE* fp = fopen("/proc/sys/kernel/pid_max", "r"); 587 long pid_max; 588 fscanf(fp, "%ld", &pid_max); 589 pid_t invalid_pid = static_cast<pid_t>(pid_max + 1); 590 fclose(fp); 591 return invalid_pid; 592 } 593 594 TEST(time, clock_getcpuclockid) { 595 // For current process. 596 clockid_t clockid; 597 ASSERT_EQ(0, clock_getcpuclockid(getpid(), &clockid)); 598 599 timespec ts; 600 ASSERT_EQ(0, clock_gettime(clockid, &ts)); 601 602 // For parent process. 603 ASSERT_EQ(0, clock_getcpuclockid(getppid(), &clockid)); 604 ASSERT_EQ(0, clock_gettime(clockid, &ts)); 605 606 // For invalid process. 607 // We can't use -1 for invalid pid here, because clock_getcpuclockid() can't detect it. 608 errno = 0; 609 ASSERT_EQ(ESRCH, clock_getcpuclockid(GetInvalidPid(), &clockid)); 610 ASSERT_EQ(0, errno); 611 } 612 613 TEST(time, clock_settime) { 614 errno = 0; 615 timespec ts; 616 ASSERT_EQ(-1, clock_settime(-1, &ts)); 617 ASSERT_EQ(EINVAL, errno); 618 } 619 620 TEST(time, clock_nanosleep) { 621 timespec in; 622 timespec out; 623 ASSERT_EQ(EINVAL, clock_nanosleep(-1, 0, &in, &out)); 624 } 625 626 TEST(time, clock_nanosleep_thread_cputime_id) { 627 timespec in; 628 in.tv_sec = 1; 629 in.tv_nsec = 0; 630 ASSERT_EQ(EINVAL, clock_nanosleep(CLOCK_THREAD_CPUTIME_ID, 0, &in, nullptr)); 631 } 632 633 TEST(time, bug_31938693) { 634 // User-visible symptoms in N: 635 // http://b/31938693 636 // https://code.google.com/p/android/issues/detail?id=225132 637 638 // Actual underlying bug (the code change, not the tzdata upgrade that first exposed the bug): 639 // http://b/31848040 640 641 // This isn't a great test, because very few time zones were actually affected, and there's 642 // no real logic to which ones were affected: it was just a coincidence of the data that came 643 // after them in the tzdata file. 644 645 time_t t = 1475619727; 646 struct tm tm; 647 648 setenv("TZ", "America/Los_Angeles", 1); 649 tzset(); 650 ASSERT_TRUE(localtime_r(&t, &tm) != nullptr); 651 EXPECT_EQ(15, tm.tm_hour); 652 653 setenv("TZ", "Europe/London", 1); 654 tzset(); 655 ASSERT_TRUE(localtime_r(&t, &tm) != nullptr); 656 EXPECT_EQ(23, tm.tm_hour); 657 658 setenv("TZ", "America/Atka", 1); 659 tzset(); 660 ASSERT_TRUE(localtime_r(&t, &tm) != nullptr); 661 EXPECT_EQ(13, tm.tm_hour); 662 663 setenv("TZ", "Pacific/Apia", 1); 664 tzset(); 665 ASSERT_TRUE(localtime_r(&t, &tm) != nullptr); 666 EXPECT_EQ(12, tm.tm_hour); 667 668 setenv("TZ", "Pacific/Honolulu", 1); 669 tzset(); 670 ASSERT_TRUE(localtime_r(&t, &tm) != nullptr); 671 EXPECT_EQ(12, tm.tm_hour); 672 673 setenv("TZ", "Asia/Magadan", 1); 674 tzset(); 675 ASSERT_TRUE(localtime_r(&t, &tm) != nullptr); 676 EXPECT_EQ(9, tm.tm_hour); 677 } 678 679 TEST(time, bug_31339449) { 680 // POSIX says localtime acts as if it calls tzset. 681 // tzset does two things: 682 // 1. it sets the time zone ctime/localtime/mktime/strftime will use. 683 // 2. it sets the global `tzname`. 684 // POSIX says localtime_r need not set `tzname` (2). 685 // Q: should localtime_r set the time zone (1)? 686 // Upstream tzcode (and glibc) answer "no", everyone else answers "yes". 687 688 // Pick a time, any time... 689 time_t t = 1475619727; 690 691 // Call tzset with a specific timezone. 692 setenv("TZ", "America/Atka", 1); 693 tzset(); 694 695 // If we change the timezone and call localtime, localtime should use the new timezone. 696 setenv("TZ", "America/Los_Angeles", 1); 697 struct tm* tm_p = localtime(&t); 698 EXPECT_EQ(15, tm_p->tm_hour); 699 700 // Reset the timezone back. 701 setenv("TZ", "America/Atka", 1); 702 tzset(); 703 704 #if defined(__BIONIC__) 705 // If we change the timezone again and call localtime_r, localtime_r should use the new timezone. 706 setenv("TZ", "America/Los_Angeles", 1); 707 struct tm tm = {}; 708 localtime_r(&t, &tm); 709 EXPECT_EQ(15, tm.tm_hour); 710 #else 711 // The BSDs agree with us, but glibc gets this wrong. 712 #endif 713 } 714
