Add support for localized time strings with two units, eg. "2 hours 17 minutes"

ui/base/l10n/time_format_unittest.cc

 // Copyright (c) 2011 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.
 
+#define TIME_FORMAT_UNITTEST 1

[bartfab (slow), 2014/02/18 12:04:04]

There is no precedent for such a construct in Chrome.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

 #include "ui/base/l10n/time_format.h"
 
 #include "base/files/file_path.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/l10n/formatter.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using base::ASCIIToUTF16;
 
 namespace ui {
 namespace {
 
 using base::TimeDelta;
 
-class TimeFormatTest : public ::testing::Test {
+// Subclass TimeFormat to get unqualified access to its methods.
+class TimeFormatTest : public ::testing::Test, public TimeFormat {

[bartfab (slow), 2014/02/18 12:04:04]

I do not think that is the right way of doing things. Yes, this gives you
unqalified access to the methods but is having unqualified access important
enough to introduce the TIME_FORMAT_UNITTEST hack and have TimeFormatTest
inherit from TimeFormat, both things without precedent in the Chrome code base?
I think not. Just make the *ForTesting() methods you need public.Presubmit will
warn people who try to use them in production code.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

  public:
-  static void SetUpTestCase() {
+  TimeFormatTest() :
+      delta_0s(TimeDelta::FromSeconds(0)),

[bartfab (slow), 2014/02/18 12:04:04]

Nit: Why are these member variables? Why not just create the various deltas when
you need them?

[Thiemo Nagel, 2014/02/19 17:08:44]

Some are used in multiple places, others are quite complex, generally I think
it's less error prone that way.

+      delta_1ms(TimeDelta::FromMilliseconds(1)),
+      delta_499ms(TimeDelta::FromMilliseconds(499)),
+      delta_500ms(TimeDelta::FromMilliseconds(500)),
+      delta_999ms(TimeDelta::FromMilliseconds(999)),
+      delta_1s(TimeDelta::FromSeconds(1)),
+      delta_1s499ms(delta_1s + delta_499ms),
+      delta_1s500ms(delta_1s + delta_500ms),
+      delta_2s(TimeDelta::FromSeconds(2)),
+      delta_29s(TimeDelta::FromSeconds(29)),
+      delta_30s(TimeDelta::FromSeconds(30)),
+      delta_59s(TimeDelta::FromSeconds(59)),
+      delta_59s499ms(delta_59s + delta_499ms),
+      delta_59s500ms(delta_59s + delta_500ms),
+      delta_1m(TimeDelta::FromMinutes(1)),
+      delta_1m2s(delta_1m + delta_2s),
+      delta_1m29s999ms(delta_1m + delta_29s + delta_999ms),
+      delta_1m30s(delta_1m + delta_30s),
+      delta_2m(TimeDelta::FromMinutes(2)),
+      delta_2m1s(delta_2m + delta_1s),
+      delta_29m(TimeDelta::FromMinutes(29)),
+      delta_30m(TimeDelta::FromMinutes(30)),
+      delta_59m(TimeDelta::FromMinutes(59)),
+      delta_59m29s999ms(delta_59m + delta_29s + delta_999ms),
+      delta_59m30s(delta_59m + delta_30s),
+      delta_59m59s499ms(delta_59m + delta_59s + delta_499ms),
+      delta_59m59s500ms(delta_59m + delta_59s + delta_500ms),
+      delta_1h(TimeDelta::FromHours(1)),
+      delta_1h2m(delta_1h + delta_2m),
+      delta_1h29m59s999ms(delta_1h + delta_29m + delta_59s + delta_999ms),
+      delta_1h30m(delta_1h + delta_30m),
+      delta_2h(TimeDelta::FromHours(2)),
+      delta_2h1m(delta_2h + delta_1m),
+      delta_11h(TimeDelta::FromHours(11)),
+      delta_12h(TimeDelta::FromHours(12)),
+      delta_23h(TimeDelta::FromHours(23)),
+      delta_23h29m59s999ms(delta_23h + delta_29m + delta_59s + delta_999ms),
+      delta_23h30m(delta_23h + delta_30m),
+      delta_23h59m29s999ms(delta_23h + delta_59m + delta_29s + delta_999ms),
+      delta_23h59m30s(delta_23h + delta_59m + delta_30s),
+      delta_1d(TimeDelta::FromDays(1)),
+      delta_1d2h(delta_1d + delta_2h),
+      delta_1d11h59m59s999ms(delta_1d + delta_11h + delta_59m + delta_29s +
+                                 delta_999ms),
+      delta_1d12h(delta_1d + delta_12h),
+      delta_2d(TimeDelta::FromDays(2)),
+      delta_2d1h(delta_2d + delta_1h) {
     LoadLocale(ui::ResourceBundle::GetSharedInstance()

[bartfab (slow), 2014/02/18 12:04:04]

Nit: Setup and cleanup should be happening in SetUpTestCase() and
TearDownTestCase() whenever possible.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

                    .GetLocaleFilePath("en-US", true));
   }
 
-  static void TearDownTestCase() {
+  virtual ~TimeFormatTest() {

[bartfab (slow), 2014/02/18 12:04:04]

Nit: Setup and cleanup should be happening in SetUpTestCase() and
TearDownTestCase() whenever possible.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

     LoadLocale(base::FilePath());
   }
 
+ protected:
+  void TestStrings(const FormatterContainer& container) {

[bartfab (slow), 2014/02/18 12:04:04]

Nit: Helper functions like this one are not a good idea in tests. If e.g. the
first expectation is not met, you will get an error in line 85. You will not
know which invocation of the function this failure occured in. Just copy & paste
the code into place instead of using this function.

[Thiemo Nagel, 2014/02/19 17:08:44]

I try to avoid duplicating code as it is burdensome to maintain, especially if
its as much as 100 lines. I could turn the function into a macro as a way to
alleviate the line number problem, but I'm unsure whether you'd appreciate that.

[bartfab (slow), 2014/02/20 16:31:22]

I agree in general but I have been bitten by this in tests and have had
reviewers request that I copy & paste instead of calling the same method
multiple times from one test.

In this case, there is an elegant way around it: Leave the TestStrings() method
as-is but split the test into two test cases, each of which calls TestStrings()
only once. That way, if there is a failure inside TestStrings(), you will know
what invocation failed.

[Thiemo Nagel, 2014/02/22 21:44:09]

Thanks!  I did it that way.

+    // Test English strings (simple, singular).
+    EXPECT_EQ(ASCIIToUTF16("1 sec"),
+              SimpleForTesting(container, kDuration, kShort, delta_1s));
+    EXPECT_EQ(ASCIIToUTF16("1 min"),
+              SimpleForTesting(container, kDuration, kShort, delta_1m));
+    EXPECT_EQ(ASCIIToUTF16("1 hour"),
+              SimpleForTesting(container, kDuration, kShort, delta_1h));
+    EXPECT_EQ(ASCIIToUTF16("1 day"),
+              SimpleForTesting(container, kDuration, kShort, delta_1d));
+    EXPECT_EQ(ASCIIToUTF16("1 second"),
+              SimpleForTesting(container, kDuration, kLong, delta_1s));
+    EXPECT_EQ(ASCIIToUTF16("1 minute"),
+              SimpleForTesting(container, kDuration, kLong, delta_1m));
+    EXPECT_EQ(ASCIIToUTF16("1 hour"),
+              SimpleForTesting(container, kDuration, kLong, delta_1h));
+    EXPECT_EQ(ASCIIToUTF16("1 day"),
+              SimpleForTesting(container, kDuration, kLong, delta_1d));
+    EXPECT_EQ(ASCIIToUTF16("1 sec left"),
+              SimpleForTesting(container, kRemaining, kShort, delta_1s));
+    EXPECT_EQ(ASCIIToUTF16("1 min left"),
+              SimpleForTesting(container, kRemaining, kShort, delta_1m));
+    EXPECT_EQ(ASCIIToUTF16("1 hour left"),
+              SimpleForTesting(container, kRemaining, kShort, delta_1h));
+    EXPECT_EQ(ASCIIToUTF16("1 day left"),
+              SimpleForTesting(container, kRemaining, kShort, delta_1d));
+    EXPECT_EQ(ASCIIToUTF16("1 second left"),
+              SimpleForTesting(container, kRemaining, kLong, delta_1s));
+    EXPECT_EQ(ASCIIToUTF16("1 minute left"),
+              SimpleForTesting(container, kRemaining, kLong, delta_1m));
+    EXPECT_EQ(ASCIIToUTF16("1 hour left"),
+              SimpleForTesting(container, kRemaining, kLong, delta_1h));
+    EXPECT_EQ(ASCIIToUTF16("1 day left"),
+              SimpleForTesting(container, kRemaining, kLong, delta_1d));
+    EXPECT_EQ(ASCIIToUTF16("1 sec ago"),
+              SimpleForTesting(container, kElapsed, kShort, delta_1s));
+    EXPECT_EQ(ASCIIToUTF16("1 min ago"),
+              SimpleForTesting(container, kElapsed, kShort, delta_1m));
+    EXPECT_EQ(ASCIIToUTF16("1 hour ago"),
+              SimpleForTesting(container, kElapsed, kShort, delta_1h));
+    EXPECT_EQ(ASCIIToUTF16("1 day ago"),
+              SimpleForTesting(container, kElapsed, kShort, delta_1d));
+
+    // Test English strings (simple, plural).
+    EXPECT_EQ(ASCIIToUTF16("2 secs"),
+              SimpleForTesting(container, kDuration, kShort, delta_2s));
+    EXPECT_EQ(ASCIIToUTF16("2 mins"),
+              SimpleForTesting(container, kDuration, kShort, delta_2m));
+    EXPECT_EQ(ASCIIToUTF16("2 hours"),
+              SimpleForTesting(container, kDuration, kShort, delta_2h));
+    EXPECT_EQ(ASCIIToUTF16("2 days"),
+              SimpleForTesting(container, kDuration, kShort, delta_2d));
+    EXPECT_EQ(ASCIIToUTF16("2 seconds"),
+              SimpleForTesting(container, kDuration, kLong, delta_2s));
+    EXPECT_EQ(ASCIIToUTF16("2 minutes"),
+              SimpleForTesting(container, kDuration, kLong, delta_2m));
+    EXPECT_EQ(ASCIIToUTF16("2 hours"),
+              SimpleForTesting(container, kDuration, kLong, delta_2h));
+    EXPECT_EQ(ASCIIToUTF16("2 days"),
+              SimpleForTesting(container, kDuration, kLong, delta_2d));
+    EXPECT_EQ(ASCIIToUTF16("2 secs left"),
+              SimpleForTesting(container, kRemaining, kShort, delta_2s));
+    EXPECT_EQ(ASCIIToUTF16("2 mins left"),
+              SimpleForTesting(container, kRemaining, kShort, delta_2m));
+    EXPECT_EQ(ASCIIToUTF16("2 hours left"),
+              SimpleForTesting(container, kRemaining, kShort, delta_2h));
+    EXPECT_EQ(ASCIIToUTF16("2 days left"),
+              SimpleForTesting(container, kRemaining, kShort, delta_2d));
+    EXPECT_EQ(ASCIIToUTF16("2 seconds left"),
+              SimpleForTesting(container, kRemaining, kLong, delta_2s));
+    EXPECT_EQ(ASCIIToUTF16("2 minutes left"),
+              SimpleForTesting(container, kRemaining, kLong, delta_2m));
+    EXPECT_EQ(ASCIIToUTF16("2 hours left"),
+              SimpleForTesting(container, kRemaining, kLong, delta_2h));
+    EXPECT_EQ(ASCIIToUTF16("2 days left"),
+              SimpleForTesting(container, kRemaining, kLong, delta_2d));
+    EXPECT_EQ(ASCIIToUTF16("2 secs ago"),
+              SimpleForTesting(container, kElapsed, kShort, delta_2s));
+    EXPECT_EQ(ASCIIToUTF16("2 mins ago"),
+              SimpleForTesting(container, kElapsed, kShort, delta_2m));
+    EXPECT_EQ(ASCIIToUTF16("2 hours ago"),
+              SimpleForTesting(container, kElapsed, kShort, delta_2h));
+    EXPECT_EQ(ASCIIToUTF16("2 days ago"),
+              SimpleForTesting(container, kElapsed, kShort, delta_2d));
+
+    // Test English strings (detailed, singular and plural).
+    EXPECT_EQ(ASCIIToUTF16("1 minute 2 seconds"),
+              Detailed(kDuration, kLong, 3, delta_1m2s));
+    EXPECT_EQ(ASCIIToUTF16("2 minutes 1 second"),
+              Detailed(kDuration, kLong, 3, delta_2m1s));
+    EXPECT_EQ(ASCIIToUTF16("1 hour 2 minutes"),
+              Detailed(kDuration, kLong, 3, delta_1h2m));
+    EXPECT_EQ(ASCIIToUTF16("2 hours 1 minute"),
+              Detailed(kDuration, kLong, 3, delta_2h1m));
+    EXPECT_EQ(ASCIIToUTF16("1 day 2 hours"),
+              Detailed(kDuration, kLong, 3, delta_1d2h));
+    EXPECT_EQ(ASCIIToUTF16("2 days 1 hour"),
+              Detailed(kDuration, kLong, 3, delta_2d1h));
+  }
+
+  TimeDelta delta_0s, delta_1ms, delta_499ms, delta_500ms, delta_999ms,

[bartfab (slow), 2014/02/18 12:04:04]

Nit 1: Members should end with trailing underscores.
Nit 2: It is customary to declare one member per line.

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

+    delta_1s, delta_1s499ms, delta_1s500ms, delta_2s, delta_29s, delta_30s,
+    delta_59s, delta_59s499ms, delta_59s500ms, delta_1m, delta_1m2s,
+    delta_1m29s999ms, delta_1m30s, delta_2m, delta_2m1s, delta_29m, delta_30m,
+    delta_59m, delta_59m29s999ms, delta_59m30s, delta_59m59s499ms,
+    delta_59m59s500ms, delta_1h, delta_1h2m, delta_1h29m59s999ms, delta_1h30m,
+    delta_2h, delta_2h1m, delta_11h, delta_12h, delta_23h, delta_23h29m59s999ms,
+    delta_23h30m, delta_23h59m29s999ms, delta_23h59m30s, delta_1d, delta_1d2h,
+    delta_1d11h59m59s999ms, delta_1d12h, delta_2d, delta_2d1h;
+
  private:
   static void LoadLocale(const base::FilePath& file_path) {
     ui::ResourceBundle::GetSharedInstance().OverrideLocalePakForTest(file_path);
     ui::ResourceBundle::GetSharedInstance().ReloadLocaleResources("en-US");
   }
 };
 
-void TestTimeFormats(const TimeDelta& delta, const char* expected_ascii) {
-  base::string16 expected = ASCIIToUTF16(expected_ascii);
-  base::string16 expected_left = expected + ASCIIToUTF16(" left");
-  base::string16 expected_ago = expected + ASCIIToUTF16(" ago");
-  EXPECT_EQ(expected, TimeFormat::TimeDurationShort(delta));
-  EXPECT_EQ(expected_left, TimeFormat::TimeRemaining(delta));
-  EXPECT_EQ(expected_ago, TimeFormat::TimeElapsed(delta));
-}
+TEST_F(TimeFormatTest, SimpleAndDetailed) {
+  // Test rounding behaviour (simple).

[bartfab (slow), 2014/02/18 12:04:04]

Nit: s/behaviour/behavior/

[Thiemo Nagel, 2014/02/19 17:08:44]

Done.

+  EXPECT_EQ(ASCIIToUTF16("0 secs"), Simple(kDuration, kShort, delta_0s));
+  EXPECT_EQ(ASCIIToUTF16("0 secs"), Simple(kDuration, kShort, delta_499ms));
+  EXPECT_EQ(ASCIIToUTF16("1 sec"), Simple(kDuration, kShort, delta_500ms));
+  EXPECT_EQ(ASCIIToUTF16("1 sec"), Simple(kDuration, kShort, delta_1s499ms));
+  EXPECT_EQ(ASCIIToUTF16("2 secs"), Simple(kDuration, kShort, delta_1s500ms));
+  EXPECT_EQ(ASCIIToUTF16("59 secs"), Simple(kDuration, kShort, delta_59s499ms));
+  EXPECT_EQ(ASCIIToUTF16("1 min"), Simple(kDuration, kShort, delta_59s500ms));
+  EXPECT_EQ(ASCIIToUTF16("1 min"), Simple(kDuration, kShort, delta_1m29s999ms));
+  EXPECT_EQ(ASCIIToUTF16("2 mins"), Simple(kDuration, kShort, delta_1m30s));
+  EXPECT_EQ(ASCIIToUTF16("59 mins"),
+            Simple(kDuration, kShort, delta_59m29s999ms));
+  EXPECT_EQ(ASCIIToUTF16("1 hour"), Simple(kDuration, kShort, delta_59m30s));
+  EXPECT_EQ(ASCIIToUTF16("1 hour"),
+            Simple(kDuration, kShort, delta_1h29m59s999ms));
+  EXPECT_EQ(ASCIIToUTF16("2 hours"), Simple(kDuration, kShort, delta_1h30m));
+  EXPECT_EQ(ASCIIToUTF16("23 hours"),
+            Simple(kDuration, kShort, delta_23h29m59s999ms));
+  EXPECT_EQ(ASCIIToUTF16("1 day"), Simple(kDuration, kShort, delta_23h30m));
+  EXPECT_EQ(ASCIIToUTF16("1 day"),
+            Simple(kDuration, kShort, delta_1d11h59m59s999ms));
+  EXPECT_EQ(ASCIIToUTF16("2 days"), Simple(kDuration, kShort, delta_1d12h));
 
-TEST_F(TimeFormatTest, FormatTime) {
-  const TimeDelta one_day = TimeDelta::FromDays(1);
-  const TimeDelta one_hour = TimeDelta::FromHours(1);
-  const TimeDelta one_min = TimeDelta::FromMinutes(1);
-  const TimeDelta one_second = TimeDelta::FromSeconds(1);
-  const TimeDelta one_millisecond = TimeDelta::FromMilliseconds(1);
-  const TimeDelta zero = TimeDelta::FromMilliseconds(0);
+  // Test rounding behaviour (detailed).
+  EXPECT_EQ(ASCIIToUTF16("59 seconds"),
+            Detailed(kDuration, kLong, 100, delta_59s499ms));
+  EXPECT_EQ(ASCIIToUTF16("1 minute 0 seconds"),
+            Detailed(kDuration, kLong, 2, delta_59s500ms));
+  EXPECT_EQ(ASCIIToUTF16("1 minute"),
+            Detailed(kDuration, kLong, 1, delta_59s500ms));
+  EXPECT_EQ(ASCIIToUTF16("59 minutes 59 seconds"),
+            Detailed(kDuration, kLong, 60, delta_59m59s499ms));
+  EXPECT_EQ(ASCIIToUTF16("1 hour 0 minutes"),
+            Detailed(kDuration, kLong, 59, delta_59m59s499ms));
+  EXPECT_EQ(ASCIIToUTF16("1 hour 0 minutes"),
+            Detailed(kDuration, kLong, 2, delta_59m59s499ms));
+  EXPECT_EQ(ASCIIToUTF16("1 hour"),
+            Detailed(kDuration, kLong, 1, delta_59m59s499ms));
+  EXPECT_EQ(ASCIIToUTF16("1 hour"),
+            Detailed(kDuration, kLong, 1, delta_59m59s500ms));
+  EXPECT_EQ(ASCIIToUTF16("1 hour 0 minutes"),
+            Detailed(kDuration, kLong, 2, delta_59m59s500ms));
+  EXPECT_EQ(ASCIIToUTF16("23 hours 59 minutes"),
+            Detailed(kDuration, kLong, 24, delta_23h59m29s999ms));
+  EXPECT_EQ(ASCIIToUTF16("1 day 0 hours"),
+            Detailed(kDuration, kLong, 23, delta_23h59m29s999ms));
+  EXPECT_EQ(ASCIIToUTF16("1 day 0 hours"),
+            Detailed(kDuration, kLong, 2, delta_23h59m29s999ms));
+  EXPECT_EQ(ASCIIToUTF16("1 day"),
+            Detailed(kDuration, kLong, 1, delta_23h59m29s999ms));
+  EXPECT_EQ(ASCIIToUTF16("1 day"),
+            Detailed(kDuration, kLong, 1, delta_23h59m30s));
+  EXPECT_EQ(ASCIIToUTF16("1 day 0 hours"),
+            Detailed(kDuration, kLong, 2, delta_23h59m30s));
 
-  TestTimeFormats(zero, "0 secs");
-  TestTimeFormats(499 * one_millisecond, "0 secs");
-  TestTimeFormats(500 * one_millisecond, "1 sec");
-  TestTimeFormats(1 * one_second + 499 * one_millisecond, "1 sec");
-  TestTimeFormats(1 * one_second + 500 * one_millisecond, "2 secs");
-  TestTimeFormats(59 * one_second + 499 * one_millisecond, "59 secs");
-  TestTimeFormats(59 * one_second + 500 * one_millisecond, "1 min");
-  TestTimeFormats(1 * one_min + 30 * one_second - one_millisecond, "1 min");
-  TestTimeFormats(1 * one_min + 30 * one_second, "2 mins");
-  TestTimeFormats(59 * one_min + 30 * one_second - one_millisecond, "59 mins");
-  TestTimeFormats(59 * one_min + 30 * one_second, "1 hour");
-  TestTimeFormats(1 * one_hour + 30 * one_min - one_millisecond, "1 hour");
-  TestTimeFormats(1 * one_hour + 30 * one_min, "2 hours");
-  TestTimeFormats(23 * one_hour + 30 * one_min - one_millisecond, "23 hours");
-  TestTimeFormats(23 * one_hour + 30 * one_min, "1 day");
-  TestTimeFormats(1 * one_day + 12 * one_hour - one_millisecond, "1 day");
-  TestTimeFormats(1 * one_day + 12 * one_hour, "2 days");
-}
+  // Test fallback path in case of translator error.
+  FormatterContainer::SetFallbackForTesting(true);
+  FormatterContainer test_container;
+  TestStrings(test_container);
 
-void TestRemainingLong(const TimeDelta& delta, const std::string& expected) {
-  EXPECT_EQ(TimeFormat::TimeRemainingLong(delta), ASCIIToUTF16(expected));
-}
+  // Test default code path.
+  FormatterContainer::SetFallbackForTesting(false);
+  FormatterContainer prod_like_container;
+  TestStrings(prod_like_container);
 
-TEST_F(TimeFormatTest, TimeRemainingLong) {
-  const TimeDelta one_day(TimeDelta::FromDays(1));
-  const TimeDelta one_hour(TimeDelta::FromHours(1));
-  const TimeDelta one_min(TimeDelta::FromMinutes(1));
-  const TimeDelta one_second(TimeDelta::FromSeconds(1));
-  const TimeDelta one_millisecond(TimeDelta::FromMilliseconds(1));
-  const TimeDelta zero(TimeDelta::FromMilliseconds(0));
-
-  TestRemainingLong(zero, "0 seconds left");
-  TestRemainingLong(499 * one_millisecond, "0 seconds left");
-  TestRemainingLong(500 * one_millisecond, "1 second left");
-  TestRemainingLong(one_second + 499 * one_millisecond, "1 second left");
-  TestRemainingLong(one_second + 500 * one_millisecond, "2 seconds left");
-  TestRemainingLong(59 * one_second + 499 * one_millisecond, "59 seconds left");
-  TestRemainingLong(59 * one_second + 500 * one_millisecond, "1 minute left");
-  TestRemainingLong(one_min + 30 * one_second - one_millisecond,
-                    "1 minute left");
-  TestRemainingLong(one_min + 30 * one_second, "2 minutes left");
-  TestRemainingLong(59 * one_min + 30 * one_second - one_millisecond,
-                    "59 minutes left");
-  TestRemainingLong(59 * one_min + 30 * one_second, "1 hour left");
-  TestRemainingLong(one_hour + 30 * one_min - one_millisecond, "1 hour left");
-  TestRemainingLong(one_hour + 30 * one_min, "2 hours left");
-  TestRemainingLong(23 * one_hour + 30 * one_min - one_millisecond,
-                    "23 hours left");
-  TestRemainingLong(23 * one_hour + 30 * one_min, "1 day left");
-  TestRemainingLong(one_day + 12 * one_hour - one_millisecond, "1 day left");
-  TestRemainingLong(one_day + 12 * one_hour, "2 days left");
+#if 0

[bartfab (slow), 2014/02/18 12:04:04]

Nit: Do not commit code guarded by an #if 0. If this code is not exercised,
remove it.

[Thiemo Nagel, 2014/02/19 17:08:44]

It is useful for manual tests.

[bartfab (slow), 2014/02/20 16:31:22]

If you want to use this for manual testing, break it out into a separate test
case and prefix the test case name with MANUAL_. That way, it will not run on
the bots but you can always run it by hand if needed.

[Thiemo Nagel, 2014/02/22 21:44:09]

As far as I can see, the MANUAL_ prefix only works in integration tests (and
it's a prefix to the test, not the test case).

+  // Enable this code to get some DCHECK() failures.
+  EXPECT_EQ(ASCIIToUTF16("1 second ago"),
+            Simple(kElapsed, kLong, delta_1s));
+  EXPECT_EQ(ASCIIToUTF16("1 min 2 secs"),
+            Detailed(kDuration, kShort, 100, delta_1m2s));
+#endif
 }
 
 // crbug.com/159388: This test fails when daylight savings time ends.
 TEST_F(TimeFormatTest, RelativeDate) {
   base::Time now = base::Time::Now();
   base::string16 today_str = TimeFormat::RelativeDate(now, NULL);
   EXPECT_EQ(ASCIIToUTF16("Today"), today_str);
 
   base::Time yesterday = now - TimeDelta::FromDays(1);
   base::string16 yesterday_str = TimeFormat::RelativeDate(yesterday, NULL);
   EXPECT_EQ(ASCIIToUTF16("Yesterday"), yesterday_str);
 
   base::Time two_days_ago = now - TimeDelta::FromDays(2);
   base::string16 two_days_ago_str =
       TimeFormat::RelativeDate(two_days_ago, NULL);
   EXPECT_TRUE(two_days_ago_str.empty());
 
   base::Time a_week_ago = now - TimeDelta::FromDays(7);
   base::string16 a_week_ago_str = TimeFormat::RelativeDate(a_week_ago, NULL);
   EXPECT_TRUE(a_week_ago_str.empty());
 }
 
 }  // namespace
 }  // namespace ui