android: fix base::Time::FromLocalExploded() crash.

base/time/time_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/time/time.h"
 
 #include <time.h>
 
 #include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/strings/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 // Specialized test fixture allowing time strings without timezones to be
 // tested by comparing them to a known time in the local zone.
@@ skipping 514 matching lines @@
 }
 
 #if defined(OS_MACOSX)
 TEST_F(TimeTest, TimeTOverflow) {
   Time t = Time::FromInternalValue(std::numeric_limits<int64>::max() - 1);
   EXPECT_FALSE(t.is_max());
   EXPECT_EQ(std::numeric_limits<time_t>::max(), t.ToTimeT());
 }
 #endif
 
+#if defined(OS_ANDROID)
+TEST_F(TimeTest, FromLocalExplodedCrashOnAndroid) {

[jar (doing other things), 2013/10/21 18:15:20]

nit: IMO, you should have "similar" tests on all platforms.

You should try to deliberately pick times that don't exist in "common" time
zones, like here in the USA.  Most critically, you should test both "ambiguous"
date/time where there are two possible answers (because the clock was turned
back), and also where there is "no generic answer" because the clock was pushed
forward.

It was interesting that we had problems in Santiago, but currently, Santiago
does not have a time change on October 13th.... so this test seems especially
weak.

Suggestion (that should work cross platform?): Validate that 3 calls result in
integers that are nice and sequential.  The middle call should be the
"troublesome time," while the bracketing calls should be something like one day
earlier, and one day later.

This should be done for both a clock jumping forward, and a clock jumping
backwards chosen as the "troublesome" date.  In addition, you should verify that
the gap between the two bracketing times is either 49 hours (jump forward), or
47 hours (fall back), so that you know you are probably testing the
"troublesome" date.

+  // This crashed inside Time:: FromLocalExploded() on Android 4.1.2.
+  // See http://crbug.com/287821
+  Time::Exploded midnight = {2013,  // year
+                             10,    // month
+                             0,     // day_of_week
+                             13,    // day_of_month
+                             0,     // hour
+                             0,     // minute
+                             0,     // second
+  };
+  // The string passed to putenv() must be a char* and the documentation states
+  // that it 'becomes part of the environment', so use a static buffer.
+  static char buffer[] = "TZ=America/Santiago";
+  putenv(buffer);
+  tzset();
+  Time t = Time::FromLocalExploded(midnight);
+  EXPECT_EQ(1381633200, t.ToTimeT());
+}
+#endif  // OS_ANDROID
+
 TEST(TimeTicks, Deltas) {
   for (int index = 0; index < 50; index++) {
     TimeTicks ticks_start = TimeTicks::Now();
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
     TimeTicks ticks_stop = TimeTicks::Now();
     TimeDelta delta = ticks_stop - ticks_start;
     // Note:  Although we asked for a 10ms sleep, if the
     // time clock has a finer granularity than the Sleep()
     // clock, it is quite possible to wakeup early.  Here
     // is how that works:
@@ skipping 128 matching lines @@
   exploded.minute = 0;
   exploded.second = 0;
   exploded.millisecond = 0;
   Time t = Time::FromUTCExploded(exploded);
   // Unix 1970 epoch.
   EXPECT_EQ(GG_INT64_C(11644473600000000), t.ToInternalValue());
 
   // We can't test 1601 epoch, since the system time functions on Linux
   // only compute years starting from 1900.
 }