test/src/time/mktime_test.cpp - llvm-project/libc - Git at Google

 //===-- Unittests for mktime ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "src/time/mktime.h"
 #include "src/time/time_utils.h"
 #include "test/ErrnoSetterMatcher.h"
 #include "test/src/time/TmHelper.h"
 #include "test/src/time/TmMatcher.h"
 #include "utils/UnitTest/Test.h"

 #include <errno.h>
 #include <limits.h>
 #include <string.h>

 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 using __llvm_libc::time_utils::TimeConstants;

 static inline time_t call_mktime(struct tm *tm_data, int year, int month,
                                  int mday, int hour, int min, int sec, int wday,
                                  int yday) {
   __llvm_libc::tmhelper::testing::InitializeTmData(tm_data, year, month, mday,
                                                    hour, min, sec, wday, yday);
   return __llvm_libc::mktime(tm_data);
 }

 TEST(LlvmLibcMkTime, FailureSetsErrno) {
   struct tm tm_data;
   __llvm_libc::tmhelper::testing::InitializeTmData(
       &tm_data, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, -1, 0, 0);
   EXPECT_THAT(__llvm_libc::mktime(&tm_data), Fails(EOVERFLOW));
 }

 TEST(LlvmLibcMkTime, InvalidSeconds) {
   struct tm tm_data;
   // -1 second from 1970-01-01 00:00:00 returns 1969-12-31 23:59:59.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           0,    // min
                           -1,   // sec
                           0,    // wday
                           0),   // yday
               Succeeds(-1));
   EXPECT_TM_EQ((tm{59,     // sec
                    59,     // min
                    23,     // hr
                    31,     // day
                    12 - 1, // tm_mon starts with 0 for Jan
                    1969 - TimeConstants::TimeYearBase, // year
                    3,                                  // wday
                    364,                                // yday
                    0}),
                tm_data);
   // 60 seconds from 1970-01-01 00:00:00 returns 1970-01-01 00:01:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           0,    // min
                           60,   // sec
                           0,    // wday
                           0),   // yday
               Succeeds(60));
   EXPECT_TM_EQ((tm{0, // sec
                    1, // min
                    0, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
                    1970 - TimeConstants::TimeYearBase, // year
                    4,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
 }

 TEST(LlvmLibcMkTime, InvalidMinutes) {
   struct tm tm_data;
   // -1 minute from 1970-01-01 00:00:00 returns 1969-12-31 23:59:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           -1,   // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(-TimeConstants::SecondsPerMin));
   EXPECT_TM_EQ((tm{0,  // sec
                    59, // min
                    23, // hr
                    31, // day
                    11, // tm_mon starts with 0 for Jan
                    1969 - TimeConstants::TimeYearBase, // year
                    3,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
   // 60 minutes from 1970-01-01 00:00:00 returns 1970-01-01 01:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           60,   // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(60 * TimeConstants::SecondsPerMin));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    1, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
                    1970 - TimeConstants::TimeYearBase, // year
                    4,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
 }

 TEST(LlvmLibcMkTime, InvalidHours) {
   struct tm tm_data;
   // -1 hour from 1970-01-01 00:00:00 returns 1969-12-31 23:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           -1,   // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(-TimeConstants::SecondsPerHour));
   EXPECT_TM_EQ((tm{0,  // sec
                    0,  // min
                    23, // hr
                    31, // day
                    11, // tm_mon starts with 0 for Jan
                    1969 - TimeConstants::TimeYearBase, // year
                    3,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
   // 24 hours from 1970-01-01 00:00:00 returns 1970-01-02 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           1,    // day
                           24,   // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(24 * TimeConstants::SecondsPerHour));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    2, // day
                    0, // tm_mon starts with 0 for Jan
                    1970 - TimeConstants::TimeYearBase, // year
                    5,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
 }

 TEST(LlvmLibcMkTime, InvalidYear) {
   struct tm tm_data;
   // -1 year from 1970-01-01 00:00:00 returns 1969-01-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1969, // year
                           1,    // month
                           1,    // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(-TimeConstants::DaysPerNonLeapYear *
                        TimeConstants::SecondsPerDay));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
                    1969 - TimeConstants::TimeYearBase, // year
                    3,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
 }

 TEST(LlvmLibcMkTime, InvalidEndOf32BitEpochYear) {
   if (sizeof(size_t) != 4)
     return;
   struct tm tm_data;
   // 2038-01-19 03:14:08 tests overflow of the second in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 19, 3, 14, 8, 0, 0),
               Succeeds(TimeConstants::OutOfRangeReturnValue));
   // 2038-01-19 03:15:07 tests overflow of the minute in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 19, 3, 15, 7, 0, 0),
               Succeeds(TimeConstants::OutOfRangeReturnValue));
   // 2038-01-19 04:14:07 tests overflow of the hour in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 19, 4, 14, 7, 0, 0),
               Succeeds(TimeConstants::OutOfRangeReturnValue));
   // 2038-01-20 03:14:07 tests overflow of the day in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 20, 3, 14, 7, 0, 0),
               Succeeds(TimeConstants::OutOfRangeReturnValue));
   // 2038-02-19 03:14:07 tests overflow of the month in 2038.
   EXPECT_THAT(call_mktime(&tm_data, 2038, 2, 19, 3, 14, 7, 0, 0),
               Succeeds(TimeConstants::OutOfRangeReturnValue));
   // 2039-01-19 03:14:07 tests overflow of the year.
   EXPECT_THAT(call_mktime(&tm_data, 2039, 1, 19, 3, 14, 7, 0, 0),
               Succeeds(TimeConstants::OutOfRangeReturnValue));
 }

 TEST(LlvmLibcMkTime, InvalidMonths) {
   struct tm tm_data;
   // -1 month from 1970-01-01 00:00:00 returns 1969-12-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           0,    // month
                           1,    // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(-31 * TimeConstants::SecondsPerDay));
   EXPECT_TM_EQ((tm{0,      // sec
                    0,      // min
                    0,      // hr
                    1,      // day
                    12 - 1, // tm_mon starts with 0 for Jan
                    1969 - TimeConstants::TimeYearBase, // year
                    1,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
   // 1970-13-01 00:00:00 returns 1971-01-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           13,   // month
                           1,    // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(TimeConstants::DaysPerNonLeapYear *
                        TimeConstants::SecondsPerDay));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
                    1971 - TimeConstants::TimeYearBase, // year
                    5,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
 }

 TEST(LlvmLibcMkTime, InvalidDays) {
   struct tm tm_data;
   // -1 day from 1970-01-01 00:00:00 returns 1969-12-31 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           0,    // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(-1 * TimeConstants::SecondsPerDay));
   EXPECT_TM_EQ((tm{0,  // sec
                    0,  // min
                    0,  // hr
                    31, // day
                    11, // tm_mon starts with 0 for Jan
                    1969 - TimeConstants::TimeYearBase, // year
                    3,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);

   // 1970-01-32 00:00:00 returns 1970-02-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           1,    // month
                           32,   // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(31 * TimeConstants::SecondsPerDay));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    0, // tm_mon starts with 0 for Jan
                    1970 - TimeConstants::TimeYearBase, // year
                    0,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);

   // 1970-02-29 00:00:00 returns 1970-03-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1970, // year
                           2,    // month
                           29,   // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(59 * TimeConstants::SecondsPerDay));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    2, // tm_mon starts with 0 for Jan
                    1970 - TimeConstants::TimeYearBase, // year
                    0,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);

   // 1972-02-30 00:00:00 returns 1972-03-01 00:00:00.
   EXPECT_THAT(call_mktime(&tm_data,
                           1972, // year
                           2,    // month
                           30,   // day
                           0,    // hr
                           0,    // min
                           0,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(((2 * TimeConstants::DaysPerNonLeapYear) + 60) *
                        TimeConstants::SecondsPerDay));
   EXPECT_TM_EQ((tm{0, // sec
                    0, // min
                    0, // hr
                    1, // day
                    2, // tm_mon starts with 0 for Jan
                    1972 - TimeConstants::TimeYearBase, // year
                    3,                                  // wday
                    0,                                  // yday
                    0}),
                tm_data);
 }

 TEST(LlvmLibcMkTime, EndOf32BitEpochYear) {
   struct tm tm_data;
   // Test for maximum value of a signed 32-bit integer.
   // Test implementation can encode time for Tue 19 January 2038 03:14:07 UTC.
   EXPECT_THAT(call_mktime(&tm_data,
                           2038, // year
                           1,    // month
                           19,   // day
                           3,    // hr
                           14,   // min
                           7,    // sec
                           0,    // wday
                           0),   // yday
               Succeeds(0x7FFFFFFF));
   EXPECT_TM_EQ((tm{7,  // sec
                    14, // min
                    3,  // hr
                    19, // day
                    0,  // tm_mon starts with 0 for Jan
                    2038 - TimeConstants::TimeYearBase, // year
                    2,                                  // wday
                    7,                                  // yday
                    0}),
                tm_data);
 }

 TEST(LlvmLibcMkTime, Max64BitYear) {
   if (sizeof(time_t) == 4)
     return;
   // Mon Jan 1 12:50:50 2170 (200 years from 1970),
   struct tm tm_data;
   EXPECT_THAT(call_mktime(&tm_data,
                           2170, // year
                           1,    // month
                           1,    // day
                           12,   // hr
                           50,   // min
                           50,   // sec
                           0,    // wday
                           0),   // yday
               Succeeds(6311479850));
   EXPECT_TM_EQ((tm{50, // sec
                    50, // min
                    12, // hr
                    1,  // day
                    0,  // tm_mon starts with 0 for Jan
                    2170 - TimeConstants::TimeYearBase, // year
                    1,                                  // wday
                    50,                                 // yday
                    0}),
                tm_data);

   // Test for Tue Jan 1 12:50:50 in 2,147,483,647th year.
   EXPECT_THAT(call_mktime(&tm_data, 2147483647, 1, 1, 12, 50, 50, 0, 0),
               Succeeds(67767976202043050));
   EXPECT_TM_EQ((tm{50, // sec
                    50, // min
                    12, // hr
                    1,  // day
                    0,  // tm_mon starts with 0 for Jan
                    2147483647 - TimeConstants::TimeYearBase, // year
                    2,                                        // wday
                    50,                                       // yday
                    0}),
                tm_data);
 }
	//===-- Unittests for mktime ----------------------------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "src/time/mktime.h"
	#include "src/time/time_utils.h"
	#include "test/ErrnoSetterMatcher.h"
	#include "test/src/time/TmHelper.h"
	#include "test/src/time/TmMatcher.h"
	#include "utils/UnitTest/Test.h"

	#include <errno.h>
	#include <limits.h>
	#include <string.h>

	using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
	using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
	using __llvm_libc::time_utils::TimeConstants;

	static inline time_t call_mktime(struct tm *tm_data, int year, int month,
	int mday, int hour, int min, int sec, int wday,
	int yday) {
	__llvm_libc::tmhelper::testing::InitializeTmData(tm_data, year, month, mday,
	hour, min, sec, wday, yday);
	return __llvm_libc::mktime(tm_data);
	}

	TEST(LlvmLibcMkTime, FailureSetsErrno) {
	struct tm tm_data;
	__llvm_libc::tmhelper::testing::InitializeTmData(
	&tm_data, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, -1, 0, 0);
	EXPECT_THAT(__llvm_libc::mktime(&tm_data), Fails(EOVERFLOW));
	}

	TEST(LlvmLibcMkTime, InvalidSeconds) {
	struct tm tm_data;
	// -1 second from 1970-01-01 00:00:00 returns 1969-12-31 23:59:59.
	EXPECT_THAT(call_mktime(&tm_data,
	1970, // year
	1, // month
	1, // day
	0, // hr
	0, // min
	-1, // sec
	0, // wday
	0), // yday
	Succeeds(-1));
	EXPECT_TM_EQ((tm{59, // sec
	59, // min
	23, // hr
	31, // day
	12 - 1, // tm_mon starts with 0 for Jan
	1969 - TimeConstants::TimeYearBase, // year
	3, // wday
	364, // yday
	0}),
	tm_data);
	// 60 seconds from 1970-01-01 00:00:00 returns 1970-01-01 00:01:00.
	EXPECT_THAT(call_mktime(&tm_data,
	1970, // year
	1, // month
	1, // day
	0, // hr
	0, // min
	60, // sec
	0, // wday
	0), // yday
	Succeeds(60));
	EXPECT_TM_EQ((tm{0, // sec
	1, // min
	0, // hr
	1, // day
	0, // tm_mon starts with 0 for Jan
	1970 - TimeConstants::TimeYearBase, // year
	4, // wday
	0, // yday
	0}),
	tm_data);
	}

	TEST(LlvmLibcMkTime, InvalidMinutes) {
	struct tm tm_data;
	// -1 minute from 1970-01-01 00:00:00 returns 1969-12-31 23:59:00.
	EXPECT_THAT(call_mktime(&tm_data,
	1970, // year
	1, // month
	1, // day
	0, // hr
	-1, // min
	0, // sec
	0, // wday
	0), // yday
	Succeeds(-TimeConstants::SecondsPerMin));
	EXPECT_TM_EQ((tm{0, // sec
	59, // min
	23, // hr
	31, // day
	11, // tm_mon starts with 0 for Jan
	1969 - TimeConstants::TimeYearBase, // year
	3, // wday
	0, // yday
	0}),
	tm_data);
	// 60 minutes from 1970-01-01 00:00:00 returns 1970-01-01 01:00:00.
	EXPECT_THAT(call_mktime(&tm_data,
	1970, // year
	1, // month
	1, // day
	0, // hr
	60, // min
	0, // sec
	0, // wday
	0), // yday
	Succeeds(60 * TimeConstants::SecondsPerMin));
	EXPECT_TM_EQ((tm{0, // sec
	0, // min
	1, // hr
	1, // day
	0, // tm_mon starts with 0 for Jan
	1970 - TimeConstants::TimeYearBase, // year
	4, // wday
	0, // yday
	0}),
	tm_data);
	}

	TEST(LlvmLibcMkTime, InvalidHours) {
	struct tm tm_data;
	// -1 hour from 1970-01-01 00:00:00 returns 1969-12-31 23:00:00.
	EXPECT_THAT(call_mktime(&tm_data,
	1970, // year
	1, // month
	1, // day
	-1, // hr
	0, // min
	0, // sec
	0, // wday
	0), // yday
	Succeeds(-TimeConstants::SecondsPerHour));
	EXPECT_TM_EQ((tm{0, // sec
	0, // min
	23, // hr
	31, // day
	11, // tm_mon starts with 0 for Jan
	1969 - TimeConstants::TimeYearBase, // year
	3, // wday
	0, // yday
	0}),
	tm_data);
	// 24 hours from 1970-01-01 00:00:00 returns 1970-01-02 00:00:00.
	EXPECT_THAT(call_mktime(&tm_data,
	1970, // year
	1, // month
	1, // day
	24, // hr
	0, // min
	0, // sec
	0, // wday
	0), // yday
	Succeeds(24 * TimeConstants::SecondsPerHour));
	EXPECT_TM_EQ((tm{0, // sec
	0, // min
	0, // hr
	2, // day
	0, // tm_mon starts with 0 for Jan
	1970 - TimeConstants::TimeYearBase, // year
	5, // wday
	0, // yday
	0}),
	tm_data);
	}

	TEST(LlvmLibcMkTime, InvalidYear) {
	struct tm tm_data;
	// -1 year from 1970-01-01 00:00:00 returns 1969-01-01 00:00:00.
	EXPECT_THAT(call_mktime(&tm_data,
	1969, // year
	1, // month
	1, // day
	0, // hr
	0, // min
	0, // sec
	0, // wday
	0), // yday
	Succeeds(-TimeConstants::DaysPerNonLeapYear *
	TimeConstants::SecondsPerDay));
	EXPECT_TM_EQ((tm{0, // sec
	0, // min
	0, // hr
	1, // day
	0, // tm_mon starts with 0 for Jan
	1969 - TimeConstants::TimeYearBase, // year
	3, // wday
	0, // yday
	0}),
	tm_data);
	}

	TEST(LlvmLibcMkTime, InvalidEndOf32BitEpochYear) {
	if (sizeof(size_t) != 4)
	return;
	struct tm tm_data;
	// 2038-01-19 03:14:08 tests overflow of the second in 2038.
	EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 19, 3, 14, 8, 0, 0),
	Succeeds(TimeConstants::OutOfRangeReturnValue));
	// 2038-01-19 03:15:07 tests overflow of the minute in 2038.
	EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 19, 3, 15, 7, 0, 0),
	Succeeds(TimeConstants::OutOfRangeReturnValue));
	// 2038-01-19 04:14:07 tests overflow of the hour in 2038.
	EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 19, 4, 14, 7, 0, 0),
	Succeeds(TimeConstants::OutOfRangeReturnValue));
	// 2038-01-20 03:14:07 tests overflow of the day in 2038.
	EXPECT_THAT(call_mktime(&tm_data, 2038, 1, 20, 3, 14, 7, 0, 0),
	Succeeds(TimeConstants::OutOfRangeReturnValue));
	// 2038-02-19 03:14:07 tests overflow of the month in 2038.
	EXPECT_THAT(call_mktime(&tm_data, 2038, 2, 19, 3, 14, 7, 0, 0),
	Succeeds(TimeConstants::OutOfRangeReturnValue));
	// 2039-01-19 03:14:07 tests overflow of the year.
	EXPECT_THAT(call_mktime(&tm_data, 2039, 1, 19, 3, 14, 7, 0, 0),
	Succeeds(TimeConstants::OutOfRangeReturnValue));
	}

	TEST(LlvmLibcMkTime, InvalidMonths) {
	struct tm tm_data;
	// -1 month from 1970-01-01 00:00:00 returns 1969-12-01 00:00:00.
	EXPECT_THAT(call_mktime(&tm_data,
	1970, // year
	0, // month
	1, // day
	0, // hr
	0, // min
	0, // sec
	0, // wday
	0), // yday
	Succeeds(-31 * TimeConstants::SecondsPerDay));
	EXPECT_TM_EQ((tm{0, // sec
	0, // min
	0, // hr
	1, // day
	12 - 1, // tm_mon starts with 0 for Jan
	1969 - TimeConstants::TimeYearBase, // year
	1, // wday
	0, // yday
	0}),
	tm_data);
	// 1970-13-01 00:00:00 returns 1971-01-01 00:00:00.
	EXPECT_THAT(call_mktime(&tm_data,
	1970, // year
	13, // month
	1, // day
	0, // hr
	0, // min
	0, // sec
	0, // wday
	0), // yday
	Succeeds(TimeConstants::DaysPerNonLeapYear *
	TimeConstants::SecondsPerDay));
	EXPECT_TM_EQ((tm{0, // sec
	0, // min
	0, // hr
	1, // day
	0, // tm_mon starts with 0 for Jan
	1971 - TimeConstants::TimeYearBase, // year
	5, // wday
	0, // yday
	0}),
	tm_data);
	}

	TEST(LlvmLibcMkTime, InvalidDays) {
	struct tm tm_data;
	// -1 day from 1970-01-01 00:00:00 returns 1969-12-31 00:00:00.
	EXPECT_THAT(call_mktime(&tm_data,
	1970, // year
	1, // month
	0, // day
	0, // hr
	0, // min
	0, // sec
	0, // wday
	0), // yday
	Succeeds(-1 * TimeConstants::SecondsPerDay));
	EXPECT_TM_EQ((tm{0, // sec
	0, // min
	0, // hr
	31, // day
	11, // tm_mon starts with 0 for Jan
	1969 - TimeConstants::TimeYearBase, // year
	3, // wday
	0, // yday
	0}),
	tm_data);

	// 1970-01-32 00:00:00 returns 1970-02-01 00:00:00.
	EXPECT_THAT(call_mktime(&tm_data,
	1970, // year
	1, // month
	32, // day
	0, // hr
	0, // min
	0, // sec
	0, // wday
	0), // yday
	Succeeds(31 * TimeConstants::SecondsPerDay));
	EXPECT_TM_EQ((tm{0, // sec
	0, // min
	0, // hr
	1, // day
	0, // tm_mon starts with 0 for Jan
	1970 - TimeConstants::TimeYearBase, // year
	0, // wday
	0, // yday
	0}),
	tm_data);

	// 1970-02-29 00:00:00 returns 1970-03-01 00:00:00.
	EXPECT_THAT(call_mktime(&tm_data,
	1970, // year
	2, // month
	29, // day
	0, // hr
	0, // min
	0, // sec
	0, // wday
	0), // yday
	Succeeds(59 * TimeConstants::SecondsPerDay));
	EXPECT_TM_EQ((tm{0, // sec
	0, // min
	0, // hr
	1, // day
	2, // tm_mon starts with 0 for Jan
	1970 - TimeConstants::TimeYearBase, // year
	0, // wday
	0, // yday
	0}),
	tm_data);

	// 1972-02-30 00:00:00 returns 1972-03-01 00:00:00.
	EXPECT_THAT(call_mktime(&tm_data,
	1972, // year
	2, // month
	30, // day
	0, // hr
	0, // min
	0, // sec
	0, // wday
	0), // yday
	Succeeds(((2 * TimeConstants::DaysPerNonLeapYear) + 60) *
	TimeConstants::SecondsPerDay));
	EXPECT_TM_EQ((tm{0, // sec
	0, // min
	0, // hr
	1, // day
	2, // tm_mon starts with 0 for Jan
	1972 - TimeConstants::TimeYearBase, // year
	3, // wday
	0, // yday
	0}),
	tm_data);
	}

	TEST(LlvmLibcMkTime, EndOf32BitEpochYear) {
	struct tm tm_data;
	// Test for maximum value of a signed 32-bit integer.
	// Test implementation can encode time for Tue 19 January 2038 03:14:07 UTC.
	EXPECT_THAT(call_mktime(&tm_data,
	2038, // year
	1, // month
	19, // day
	3, // hr
	14, // min
	7, // sec
	0, // wday
	0), // yday
	Succeeds(0x7FFFFFFF));
	EXPECT_TM_EQ((tm{7, // sec
	14, // min
	3, // hr
	19, // day
	0, // tm_mon starts with 0 for Jan
	2038 - TimeConstants::TimeYearBase, // year
	2, // wday
	7, // yday
	0}),
	tm_data);
	}

	TEST(LlvmLibcMkTime, Max64BitYear) {
	if (sizeof(time_t) == 4)
	return;
	// Mon Jan 1 12:50:50 2170 (200 years from 1970),
	struct tm tm_data;
	EXPECT_THAT(call_mktime(&tm_data,
	2170, // year
	1, // month
	1, // day
	12, // hr
	50, // min
	50, // sec
	0, // wday
	0), // yday
	Succeeds(6311479850));
	EXPECT_TM_EQ((tm{50, // sec
	50, // min
	12, // hr
	1, // day
	0, // tm_mon starts with 0 for Jan
	2170 - TimeConstants::TimeYearBase, // year
	1, // wday
	50, // yday
	0}),
	tm_data);

	// Test for Tue Jan 1 12:50:50 in 2,147,483,647th year.
	EXPECT_THAT(call_mktime(&tm_data, 2147483647, 1, 1, 12, 50, 50, 0, 0),
	Succeeds(67767976202043050));
	EXPECT_TM_EQ((tm{50, // sec
	50, // min
	12, // hr
	1, // day
	0, // tm_mon starts with 0 for Jan
	2147483647 - TimeConstants::TimeYearBase, // year
	2, // wday
	50, // yday
	0}),
	tm_data);
	}