Initial commit of mktime.

[rtenneti]

Summary

This introduces mktime to LLVM libc, based on C99/C2X/Single Unix Spec.

Co-authored-by: Jeff Bailey <[e-mail]>

This change doesn't handle TIMEZONE, tm_isdst and leap seconds. It returns -1 for invalid dates. I have verified the return results for all the possible dates with glibc's mktime.

TODO:
+ Handle leap seconds.
+ Handle out of range time and date values that don't overflow or underflow.
+ Implement the following suggestion Siva - As we start accumulating the seconds, we should be able to check if the next amount of seconds to be added can lead to an overflow. If it does, return the overflow value. If not keep accumulating. The benefit is that, we don't have to validate every input, and also do not need the special cases for sizeof(time_t) == 4.
+ Handle timezone and update of tm_isdst

[MaskRay]

Drive-by: POSIX.1-2017: "Local timezone information shall be set as though mktime() called tzset()." Is "TZ" handled in this patch?

libc/config/linux/api.td

34

Seems that tm_isdst is entirely unhandled.

libc/src/time/mktime.cpp

12

Drive-by: LLVM Coding Standards talk about the use of anonymous namespaces: https://llvm.org/docs/CodingStandards.html#anonymous-namespaces
https://llvm.org/docs/CodingStandards.html#use-namespace-qualifiers-to-implement-previously-declared-functions

16

namespace-scope const/constexpr variables are automatically of internal linkage. You don't need an anonymous namespace (which is also discouraged) in this case.

37

Have two arrays for leap/nonleap wastes space (libc.a space matters a lot). Having one array plus leap adjustment is sufficient.

[rtenneti]

Remove anonymous namespace, fix typos in ILP64 msg.
Removed duplicate arrays for days calculation.

[sivachandra]

Raman, looks like you lost other files when you updated the patch.

[rtenneti]

Fixed the comments from Fangrui.

[sivachandra]

libc/src/time/mktime.cpp

46

The standard says,

"The values in time are not checked for being out of range."

So, is all this checking necessary?

54

Could we perhaps define a OVERFLOW_VALUE instead of doing (time_t)(-1) everywhere? You can define it in the implementation header as a static constexpr which then allows us to use it in the tests as well.

65

Could we do this overflow check in a more general fashion? For example, we can find a maxYears that can fit in TIME_T_MAX (I am making up TIME_T_MAX). After that, assuming valid inputs for other fields, we can progressively check if the result will fit in time_t.

67

Its not clear to me as to what would/should change on a ILP64 platform. Can add a comment explaining this?

libc/test/src/time/mktime_test.cpp

24

Except for this line, it doesn't seem like you need this function initialize_tm_data. A pattern like this does not work?

tm temp{...};
...
temp = {...};

34

You can inline lines 31 to 33 to:

EXPECT_EQ(__llvm_libc::mktime(&temp), OVERFLOW_VALUE);

And use the same pattern at other places where relevant.

[jeffbailey]

libc/src/time/mktime.cpp

46

The Single Unix Spec says this:

The mktime() function shall return the specified time since the Epoch encoded as a value of type time_t. If the time since the Epoch cannot be represented, the function shall return the value (time_t)-1 [CX] [Option Start] and set errno to indicate the error.

So our bug is that we're not setting errno here to EOVERFLOW.

54

This should be OUT_OF_RANGE since it serves underflow as well.

67

We'll add a comment. In brief: because struct tm is ints, a 32-bit int year can be represented in a 64-bit time_t. However, a 64-bit int year cannot. Without a good way to run tests on it, I'd rather just assume a 32-bit int and make sure it catches fire at build time when that's violated.

libc/test/src/time/mktime_test.cpp

24

This is the case where I was hoping we could use a C99/C++20 designated initializer so that it was readable and clean.

[rtenneti]

Fixed comments.

[rtenneti]

Fixed code review comments.

[rtenneti]

Jeff and I have made the changes. Please take another look. Thanks.

libc/config/linux/api.td

34

Added a TODO to handle tm_isdst . Also needs to read timezone file.

libc/src/time/mktime.cpp

46

Hi Siva and Jeff,

Added a TODO to handle out of range date and time (it seems mktime in C converts invalid dates to valid dates.  For example  "October 40th is silently converted to November 9th")

65

Add a TODO to investigate the above idea.

libc/test/src/time/mktime_test.cpp

24

Done.

[jeffbailey]

libc/src/time/mktime.cpp

65

Is the TODO still necessary with the creation of outOfRange() that sets errno and returns -1?

[rtenneti]

Fixed Jeff's comments.

[rtenneti]

Fixed the todo.

[rtenneti]

Removed the TODO. Thanks Jeff.

[sivachandra]

Mostly LGTM. I have left a few nits along with a not-a-nit comment.

From offline discussions, I understand you are preparing follow ups. It should be OK to land WiP pieces as long as you have clear TODOs about what is missing.

libc/src/time/mktime.cpp

43

Nit: Use static_cast instead of C-style casts, similar to how you do in tests. Even better, define another constant like this:

constexpr time_t OutOfRangeReturnValue = -1;

46

Can you add TODOs for the pieces missing in this implementation? Just rephrase what you have in the commit message as a TODO.

65

Along with the above comment about checking for invalid input, what I meant was this: As we start accumulating the seconds, we should be able to check if the next amount of seconds to be added can lead to an overflow. If it does, return the overflow value. If not keep accumulating. The benefit is that, we don't have to validate every input, and also do need the special cases for sizeof(time_t) == 4.

libc/test/src/time/mktime_test.cpp

31

Nit: To avoid confusions, can you rename this function to call_mktime?

45

Nit: Define a global perhaps to avoid repeated listings of static_cast. Something like:

static constexpr time_t OutOfRangeReturnValue = -1;

[rtenneti]

Fixed Siva's comments and added a TODO.

[sivachandra]

libc/src/time/mktime.cpp

54

Ah, a typo in my comment got carried over here.... "... also, do NOT need the special cases ..."

[rtenneti]

Added "not" to the comment.

[rtenneti]

libc/src/time/mktime.cpp

65

Added a TODO. The above is my intetntion when implementing handle of invalid data (of some one passing INT_MAX in either seconds, minutes, hours ...).

[MaskRay]

libc/config/linux/api.td

41

This may not be a good declaration for 32-bit systems (their support may have lower priority, though, I guess). https://sourceware.org/glibc/wiki/Y2038ProofnessDesign

Then you can avoid all the sizeof(time_t) == 4 special cases.

[jeffbailey]

libc/config/linux/api.td

41

The declaration of time_t comes from the following:

The range and precision of times representable in clock_t and time_t are
implementation-defined. (C99 7.23.1(4))

time_t shall be an integer type. (https://pubs.opengroup.org/onlinepubs/9699919799/toc.htm)

IBM has an analysis: https://www.ibm.com/support/knowledgecenter/SSFKSJ_7.5.0/com.ibm.mq.ref.dev.doc/q104610_.htm

In practice, it will be somewhat more nuanced because of backwards compatibility. I expect that *historical* 32-bit systems will need to maintain a 32-bit signed time_t for compat. However, *new* ones (like em32_t) would use a 64-bit time_t. Since this libc doesn't any support for that we've used this. Someone implementing em32_t would have to go over I think many such types, so I'm not worried about this being extra work for them later if/when that happens.

libc/config/linux/api.td

 
 def SSizeT : TypeDecl<"ssize_t"> {
   let Decl = [{
     #define __need_ssize_t
     #include <__posix-types.h>
   }];
 }
 
+def StructTm: TypeDecl<"struct tm"> {
+  let Decl = [{
+    struct tm {
+      int tm_sec; // seconds after the minute
+      int tm_min; // minutes after the hour
+      int tm_hour; // hours since midnight
+      int tm_mday; // day of the month
+      int tm_mon; // months since January
+      int tm_year; // years since 1900
+      int tm_wday; // days since Sunday
+      int tm_yday; // days since January
+      int tm_isdst; // Daylight Saving Time flag
+    };
+  }];
+}
+
+def TimeT: TypeDecl<"time_t"> {
+   let Decl = [{
+   typedef long time_t;
+  }];
+}
+
 def OffT : TypeDecl<"off_t"> {
   let Decl = [{
     #define __need_off_t
     #include <__posix-types.h>
   }];
 }
 
 def FILE : TypeDecl<"FILE"> {
let TypeDeclarations = [
     SizeT,
     FILE,
   ];
 }
 
 def StdlibAPI : PublicAPI<"stdlib.h"> {
 }
 
+def TimeAPI : PublicAPI<"time.h"> {
+  let TypeDeclarations = [
+    StructTm,
+    TimeT,
+  ];
+
+  let Functions = [
+    "mktime",
+  ];
+}
+
 def ErrnoAPI : PublicAPI<"errno.h"> {
   let Macros = [
     ErrnoMacro,
     // We largely depend on linux/errno.h to give us the
     // various error macro definitions. However, some libc
     // implementations have chosen to provide definitions
     // for some of the error macros to account for the ones
     // missing in linux/errno.h. There is no harm in doing

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     # threads.h entrypoints
     libc.src.threads.call_once
     libc.src.threads.mtx_init
     libc.src.threads.mtx_lock
     libc.src.threads.mtx_unlock
     libc.src.threads.thrd_create
     libc.src.threads.thrd_join
 
+    # time.h entrypoints
+    libc.src.time.mktime
+
     # unistd.h entrypoints
     libc.src.unistd.write
 )
 
 set(TARGET_LIBM_ENTRYPOINTS
     # math.h entrypoints
     libc.src.math.copysign
     libc.src.math.copysignf

libc/config/linux/x86_64/headers.txt

 set(TARGET_PUBLIC_HEADERS
     libc.include.assert_h
     libc.include.ctype
     libc.include.errno
     libc.include.math
     libc.include.signal
     libc.include.stdio
     libc.include.stdlib
     libc.include.sys_mman
     libc.include.sys_syscall
     libc.include.threads
+    libc.include.time
     libc.include.unistd
 )

libc/include/CMakeLists.txt

add_gen_header(
   string
   DEF_FILE string.h.def
   GEN_HDR string.h
   DEPENDS
     .llvm_libc_common_h
 )
 
 add_gen_header(
+  time
+  DEF_FILE time.h.def
+  GEN_HDR time.h
+  DEPENDS
+    .llvm_libc_common_h
+)
+
+add_gen_header(
   threads
   DEF_FILE threads.h.def
   GEN_HDR threads.h
   PARAMS
     platform_threads=../config/${LIBC_TARGET_OS}/threads.h.in
   DEPENDS
     .llvm_libc_common_h
   DATA_FILES

libc/include/time.h.def

+//===-- C standard library header time.h ----------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_TIME_H
+#define LLVM_LIBC_TIME_H
+
+#include <__llvm-libc-common.h>
+
+%%public_api()
+
+#endif // LLVM_LIBC_TIME_H

libc/spec/spec.td

 def ThrdTTypePtr : PtrType<ThrdTType>;
 
 def IntPtr : PtrType<IntType>;
 def FloatPtr : PtrType<FloatType>;
 def DoublePtr : PtrType<DoubleType>;
 
 def SigHandlerT : NamedType<"__sighandler_t">;
 
+def TimeTType : NamedType<"time_t">;
+
 //added because __assert_fail needs it.
 def UnsignedType : NamedType<"unsigned">;
 
 
 class Macro<string name> {
   string Name = name;
 }
 

libc/spec/stdc.td

 def StdC : StandardSpec<"stdc"> {
 
   NamedType FILE = NamedType<"FILE">;
   PtrType FILEPtr = PtrType<FILE>;
   RestrictedPtrType FILERestrictedPtr = RestrictedPtrType<FILE>;
+  NamedType StructTmType = NamedType<"struct tm">;
+  PtrType StructTmPtr = PtrType<StructTmType>;
 
   HeaderSpec Assert = HeaderSpec<
       "assert.h",
       [
           Macro<"static_assert">,
           Macro<"assert">,
       ],
       [], // Types
HeaderSpec Threads = HeaderSpec<
               [
                   ArgSpec<ThrdTTypePtr>,
                   ArgSpec<IntPtr>,
               ]
           >
       ]
   >;
 
+  HeaderSpec Time = HeaderSpec<
+      "time.h",
+      [], // Macros
+      [ // Types
+       StructTmType,
+       TimeTType,
+      ],
+      [], // Enumerations
+      [
+          FunctionSpec<
+              "mktime",
+              RetValSpec<TimeTType>,
+              [ArgSpec<StructTmPtr>]
+          >,
+      ]
+  >;
+
   let Headers = [
     Assert,
     CType,
     Errno,
     Math,
     String,
     StdIO,
     StdLib,
     Signal,
     Threads,
+    Time,
   ];
 }

libc/src/CMakeLists.txt

 add_subdirectory(assert)
 add_subdirectory(ctype)
 add_subdirectory(errno)
 add_subdirectory(math)
 add_subdirectory(signal)
 add_subdirectory(stdio)
 add_subdirectory(stdlib)
 add_subdirectory(string)
 # TODO: Add this target conditional to the target OS.
 add_subdirectory(sys)
 add_subdirectory(threads)
+add_subdirectory(time)
 add_subdirectory(unistd)
 
 add_subdirectory(__support)

libc/src/time/CMakeLists.txt

+add_entrypoint_object(
+  mktime
+  SRCS
+    mktime.cpp
+  HDRS
+    mktime.h
+  DEPENDS
+    libc.include.errno
+    libc.include.time
+    libc.src.errno.__errno_location
+)

libc/src/time/mktime.h

+//===-- Implementation header of mktime -------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_TIME_MKTIME_H
+#define LLVM_LIBC_SRC_TIME_MKTIME_H
+
+#include "src/time/mktime.h"
+#include <time.h>
+
+namespace __llvm_libc {
+
+time_t mktime(struct tm *t1);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_TIME_MKTIME_H
+
+#include "include/time.h"

libc/src/time/mktime.cpp

+//===-- Implementation of mktime function ---------------------------------===//
+//
+// 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 "include/errno.h"
+
+#include "src/__support/common.h"
+#include "src/errno/llvmlibc_errno.h"
+#include "src/time/mktime.h"
+
+namespace __llvm_libc {
+
+constexpr int SecondsPerMin = 60;
+constexpr int MinutesPerHour = 60;
+constexpr int HoursPerDay = 24;
+constexpr int DaysPerWeek = 7;
+constexpr int MonthsPerYear = 12;
+constexpr int DaysPerNonLeapYear = 365;
+constexpr int TimeYearBase = 1900;
+constexpr int EpochYear = 1970;
+constexpr int EpochWeekDay = 4;
+// The latest time that can be represented in this form is 03:14:07 UTC on
+// Tuesday, 19 January 2038 (corresponding to 2,147,483,647 seconds since the
+// start of the epoch). This means that systems using a 32-bit time_t type are
+// susceptible to the Year 2038 problem.
+constexpr int EndOf32BitEpochYear = 2038;
+
+constexpr int NonLeapYearDaysInMonth[] = {31 /* Jan */, 28, 31, 30, 31, 30,
+                                          31,           31, 30, 31, 30, 31};
+
+constexpr bool isLeapYear(const time_t year) {
+  return (((year) % 4) == 0 && (((year) % 100) != 0 || ((year) % 400) == 0));
+}
+
+// POSIX.1-2017 requires this.
+static inline time_t outOfRange() {
+  llvmlibc_errno = EOVERFLOW;
+  return static_cast<time_t>(-1);
+}
+
+time_t LLVM_LIBC_ENTRYPOINT(mktime)(struct tm *t1) {
+  // Unlike most C Library functions, mktime doesn't just die on bad input.
+  // TODO(rtenneti); Handle leap seconds. Handle out of range time and date
+  // values that don't overflow or underflow.
+  // TODO (rtenneti): Implement the following suggestion Siva: "As we start
+  // accumulating the seconds, we should be able to check if the next amount of
+  // seconds to be added can lead to an overflow. If it does, return the
+  // overflow value. If not keep accumulating. The benefit is that, we don't
+  // have to validate every input, and also do not need the special cases for
+  // sizeof(time_t) == 4".
+  if (t1->tm_sec < 0 || t1->tm_sec > (SecondsPerMin - 1))
+    return outOfRange();
+  if (t1->tm_min < 0 || t1->tm_min > (MinutesPerHour - 1))
+    return outOfRange();
+  if (t1->tm_hour < 0 || t1->tm_hour > (HoursPerDay - 1))
+    return outOfRange();
+  time_t tmYearFromBase = t1->tm_year + TimeYearBase;
+
+  if (tmYearFromBase < EpochYear)
+    return outOfRange();
+
+  // 32-bit end-of-the-world is 03:14:07 UTC on 19 January 2038.
+  if (sizeof(time_t) == 4 && tmYearFromBase >= EndOf32BitEpochYear) {
+    if (tmYearFromBase > EndOf32BitEpochYear)
+      return outOfRange();
+    if (t1->tm_mon > 0)
+      return outOfRange();
+    if (t1->tm_mday > 19)
+      return outOfRange();
+    if (t1->tm_hour > 3)
+      return outOfRange();
+    if (t1->tm_min > 14)
+      return outOfRange();
+    if (t1->tm_sec > 7)
+      return outOfRange();
+  }
+
+  // Years are ints.  A 32-bit year will fit into a 64-bit time_t.
+  // A 64-bit year will not.
+  static_assert(sizeof(int) == 4,
+                "ILP64 is unimplemented.  This implementation requires "
+                "32-bit integers.");
+
+  if (t1->tm_mon < 0 || t1->tm_mon > (MonthsPerYear - 1))
+    return outOfRange();
+  bool tmYearIsLeap = isLeapYear(tmYearFromBase);
+  time_t daysInMonth = NonLeapYearDaysInMonth[t1->tm_mon];
+  // Add one day if it is a leap year and the month is February.
+  if (tmYearIsLeap && t1->tm_mon == 1)
+    ++daysInMonth;
+  if (t1->tm_mday < 1 || t1->tm_mday > daysInMonth)
+    return outOfRange();
+
+  time_t totalDays = t1->tm_mday - 1;
+  for (int i = 0; i < t1->tm_mon; ++i)
+    totalDays += NonLeapYearDaysInMonth[i];
+  // Add one day if it is a leap year and the month is after February.
+  if (tmYearIsLeap && t1->tm_mon > 1)
+    totalDays++;
+  t1->tm_yday = totalDays;
+  totalDays += (tmYearFromBase - EpochYear) * DaysPerNonLeapYear;
+
+  // Add an extra day for each leap year, starting with 1972
+  for (time_t year = EpochYear + 2; year < tmYearFromBase;) {
+    if (isLeapYear(year)) {
+      totalDays += 1;
+      year += 4;
+    } else {
+      year++;
+    }
+  }
+
+  t1->tm_wday = (EpochWeekDay + totalDays) % DaysPerWeek;
+  if (t1->tm_wday < 0)
+    t1->tm_wday += DaysPerWeek;
+  // TODO(rtenneti): Need to handle timezone and update of tm_isdst.
+  return t1->tm_sec + t1->tm_min * SecondsPerMin +
+         t1->tm_hour * MinutesPerHour * SecondsPerMin +
+         totalDays * HoursPerDay * MinutesPerHour * SecondsPerMin;
+}
+
+} // namespace __llvm_libc

libc/test/src/CMakeLists.txt

 add_subdirectory(assert)
 add_subdirectory(ctype)
 add_subdirectory(errno)
 add_subdirectory(math)
 add_subdirectory(signal)
 add_subdirectory(stdio)
 add_subdirectory(stdlib)
 add_subdirectory(string)
 add_subdirectory(sys)
 add_subdirectory(threads)
+add_subdirectory(time)
 add_subdirectory(unistd)
 
 set(public_test ${CMAKE_CURRENT_BINARY_DIR}/public_integration_test.cpp)
 
 set(entrypoints_name_list "")
 foreach(entry IN LISTS TARGET_LIBC_ENTRYPOINTS TARGET_LIBM_ENTRYPOINTS)
   get_target_property(entry_name ${entry} "ENTRYPOINT_NAME")
   list(APPEND entrypoints_name_list ${entry_name})

libc/test/src/time/CMakeLists.txt

+add_libc_testsuite(libc_time_unittests)
+
+add_libc_unittest(
+  mktime
+  SUITE
+    libc_time_unittests
+  SRCS
+    mktime_test.cpp
+  DEPENDS
+    libc.src.time.mktime
+)

libc/test/src/time/mktime_test.cpp

+//===-- 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 "test/ErrnoSetterMatcher.h"
+#include "utils/UnitTest/Test.h"
+
+#include <errno.h>
+#include <string.h>
+
+using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
+
+static constexpr time_t OutOfRangeReturnValue = -1;
+
+// A helper function to initialize tm data structure.
+static inline void initialize_tm_data(struct tm *tm_data, int year, int month,
+                                      int mday, int hour, int min, int sec) {
+  struct tm temp = {.tm_sec = sec,
+                    .tm_min = min,
+                    .tm_hour = hour,
+                    .tm_mday = mday,
+                    .tm_mon = month,
+                    .tm_year = year - 1900};
+  *tm_data = temp;
+}
+
+static inline time_t call_mktime(struct tm *tm_data, int year, int month,
+                                 int mday, int hour, int min, int sec) {
+  initialize_tm_data(tm_data, year, month, mday, hour, min, sec);
+  return __llvm_libc::mktime(tm_data);
+}
+
+TEST(MkTime, FailureSetsErrno) {
+  struct tm tm_data;
+  initialize_tm_data(&tm_data, 0, 0, 0, 0, 0, -1);
+  EXPECT_THAT(__llvm_libc::mktime(&tm_data), Fails(EOVERFLOW));
+}
+
+TEST(MkTime, MktimeTestsInvalidSeconds) {
+  struct tm tm_data;
+  EXPECT_EQ(call_mktime(&tm_data, 0, 0, 0, 0, 0, -1), OutOfRangeReturnValue);
+  EXPECT_EQ(call_mktime(&tm_data, 0, 0, 0, 0, 0, 60), OutOfRangeReturnValue);
+}
+
+TEST(MkTime, MktimeTestsInvalidMinutes) {
+  struct tm tm_data;
+  EXPECT_EQ(call_mktime(&tm_data, 0, 0, 0, 0, -1, 0), OutOfRangeReturnValue);
+  EXPECT_EQ(call_mktime(&tm_data, 0, 0, 1, 0, 60, 0), OutOfRangeReturnValue);
+}
+
+TEST(MkTime, MktimeTestsInvalidHours) {
+  struct tm tm_data;
+  EXPECT_EQ(call_mktime(&tm_data, 0, 0, 0, -1, 0, 0), OutOfRangeReturnValue);
+  EXPECT_EQ(call_mktime(&tm_data, 0, 0, 0, 24, 0, 0), OutOfRangeReturnValue);
+}
+
+TEST(MkTime, MktimeTestsInvalidYear) {
+  struct tm tm_data;
+  EXPECT_EQ(call_mktime(&tm_data, 1969, 0, 0, 0, 0, 0), OutOfRangeReturnValue);
+}
+
+TEST(MkTime, MktimeTestsInvalidEndOf32BitEpochYear) {
+  if (sizeof(time_t) != 4)
+    return;
+  struct tm tm_data;
+  // 2038-01-19 03:14:08 tests overflow of the second in 2038.
+  EXPECT_EQ(call_mktime(&tm_data, 2038, 0, 19, 3, 14, 8),
+            OutOfRangeReturnValue);
+  // 2038-01-19 03:15:07 tests overflow of the minute in 2038.
+  EXPECT_EQ(call_mktime(&tm_data, 2038, 0, 19, 3, 15, 7),
+            OutOfRangeReturnValue);
+  // 2038-01-19 04:14:07 tests overflow of the hour in 2038.
+  EXPECT_EQ(call_mktime(&tm_data, 2038, 0, 19, 4, 14, 7),
+            OutOfRangeReturnValue);
+  // 2038-01-20 03:14:07 tests overflow of the day in 2038.
+  EXPECT_EQ(call_mktime(&tm_data, 2038, 0, 20, 3, 14, 7),
+            OutOfRangeReturnValue);
+  // 2038-02-19 03:14:07 tests overflow of the month in 2038.
+  EXPECT_EQ(call_mktime(&tm_data, 2038, 1, 19, 3, 14, 7),
+            OutOfRangeReturnValue);
+  // 2039-01-19 03:14:07 tests overflow of the year.
+  EXPECT_EQ(call_mktime(&tm_data, 2039, 0, 19, 3, 14, 7),
+            OutOfRangeReturnValue);
+}
+
+TEST(MkTime, MktimeTestsInvalidMonths) {
+  struct tm tm_data;
+  // Before Jan of 1970
+  EXPECT_EQ(call_mktime(&tm_data, 1970, -1, 15, 0, 0, 0),
+            OutOfRangeReturnValue);
+  // After Dec of 1970
+  EXPECT_EQ(call_mktime(&tm_data, 1970, 12, 15, 0, 0, 0),
+            OutOfRangeReturnValue);
+}
+
+TEST(MkTime, MktimeTestsInvalidDays) {
+  struct tm tm_data;
+  // -1 day of Jan, 1970
+  EXPECT_EQ(call_mktime(&tm_data, 1970, 0, -1, 0, 0, 0), OutOfRangeReturnValue);
+  // 32 day of Jan, 1970
+  EXPECT_EQ(call_mktime(&tm_data, 1970, 0, 32, 0, 0, 0), OutOfRangeReturnValue);
+  // 29 day of Feb, 1970
+  EXPECT_EQ(call_mktime(&tm_data, 1970, 1, 29, 0, 0, 0), OutOfRangeReturnValue);
+  // 30 day of Feb, 1972
+  EXPECT_EQ(call_mktime(&tm_data, 1972, 1, 30, 0, 0, 0), OutOfRangeReturnValue);
+  // 31 day of Apr, 1970
+  EXPECT_EQ(call_mktime(&tm_data, 1970, 3, 31, 0, 0, 0), OutOfRangeReturnValue);
+}
+
+TEST(MkTime, MktimeTestsStartEpochYear) {
+  // Thu Jan 1 00:00:00 1970
+  struct tm tm_data;
+  EXPECT_EQ(call_mktime(&tm_data, 1970, 0, 1, 0, 0, 0), static_cast<time_t>(0));
+  EXPECT_EQ(4, tm_data.tm_wday);
+  EXPECT_EQ(0, tm_data.tm_yday);
+}
+
+TEST(MkTime, MktimeTestsEpochYearRandomTime) {
+  // Thu Jan 1 12:50:50 1970
+  struct tm tm_data;
+  EXPECT_EQ(call_mktime(&tm_data, 1970, 0, 1, 12, 50, 50),
+            static_cast<time_t>(46250));
+  EXPECT_EQ(4, tm_data.tm_wday);
+  EXPECT_EQ(0, tm_data.tm_yday);
+}
+
+TEST(MkTime, MktimeTestsEndOf32BitEpochYear) {
+  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_EQ(call_mktime(&tm_data, 2038, 0, 19, 3, 14, 7),
+            static_cast<time_t>(0x7FFFFFFF));
+  EXPECT_EQ(2, tm_data.tm_wday);
+  EXPECT_EQ(18, tm_data.tm_yday);
+}
+
+TEST(MkTime, MktimeTests64BitYear) {
+  if (sizeof(time_t) == 4)
+    return;
+  // Mon Jan 1 12:50:50 2170
+  struct tm tm_data;
+  EXPECT_EQ(call_mktime(&tm_data, 2170, 0, 1, 12, 50, 50),
+            static_cast<time_t>(6311479850));
+  EXPECT_EQ(1, tm_data.tm_wday);
+  EXPECT_EQ(0, tm_data.tm_yday);
+
+  // Test for Tue Jan 1 12:50:50 in 2,147,483,647th year.
+  EXPECT_EQ(call_mktime(&tm_data, 2147483647, 0, 1, 12, 50, 50),
+            static_cast<time_t>(67767976202043050));
+  EXPECT_EQ(2, tm_data.tm_wday);
+  EXPECT_EQ(0, tm_data.tm_yday);
+}