Relaunch Chrome in metro-mode with the help of a helper process.

base/string_number_conversions_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 <math.h>
 
 #include <limits>
 
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
 template <typename INT>
 struct IntToStringTest {
   INT num;
   const char* sexpected;
   const char* uexpected;
 };
 
 }  // namespace
 
 TEST(StringNumberConversionsTest, IntToString) {
   static const IntToStringTest<int> int_tests[] = {
-      { 0, "0", "0" },
-      { -1, "-1", "4294967295" },
-      { std::numeric_limits<int>::max(), "2147483647", "2147483647" },
-      { std::numeric_limits<int>::min(), "-2147483648", "2147483648" },
+    { 0, "0", "0" },
+    { -1, "-1", "4294967295" },
+    { std::numeric_limits<int>::max(), "2147483647", "2147483647" },
+    { std::numeric_limits<int>::min(), "-2147483648", "2147483648" },
   };
   static const IntToStringTest<int64> int64_tests[] = {
-      { 0, "0", "0" },
-      { -1, "-1", "18446744073709551615" },
-      { std::numeric_limits<int64>::max(),
-        "9223372036854775807",
-        "9223372036854775807", },
-      { std::numeric_limits<int64>::min(),
-        "-9223372036854775808",
-        "9223372036854775808" },
+    { 0, "0", "0" },
+    { -1, "-1", "18446744073709551615" },
+    { std::numeric_limits<int64>::max(),
+      "9223372036854775807",
+      "9223372036854775807", },
+    { std::numeric_limits<int64>::min(),
+      "-9223372036854775808",
+      "9223372036854775808" },
   };
 
   for (size_t i = 0; i < arraysize(int_tests); ++i) {
     const IntToStringTest<int>* test = &int_tests[i];
     EXPECT_EQ(IntToString(test->num), test->sexpected);
     EXPECT_EQ(IntToString16(test->num), UTF8ToUTF16(test->sexpected));
     EXPECT_EQ(UintToString(test->num), test->uexpected);
     EXPECT_EQ(UintToString16(test->num), UTF8ToUTF16(test->uexpected));
   }
   for (size_t i = 0; i < arraysize(int64_tests); ++i) {
@@ skipping 13 matching lines @@
     {0, "0"},
     {42, "42"},
     {INT_MAX, "2147483647"},
     {kuint64max, "18446744073709551615"},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i)
     EXPECT_EQ(cases[i].output, Uint64ToString(cases[i].input));
 }
 
+TEST(StringNumberConversionsTest, PointerToString) {
+  static const struct {
+    void* input;
+    const char* output;
+  } cases[] = {
+    {0, "0"},
+    {reinterpret_cast<void*>(42), "42"},
+    {reinterpret_cast<void*>(UINT_MAX), "4294967295"},
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i)
+    EXPECT_EQ(std::string(cases[i].output), PointerToString(cases[i].input));
+
+  if (sizeof(void*) == sizeof(uint64)) {
+    EXPECT_EQ(std::string("18446744073709551615"),
+              PointerToString(reinterpret_cast<void*>(ULLONG_MAX)));
+  }
+}
+
 TEST(StringNumberConversionsTest, StringToInt) {
   static const struct {
     std::string input;
     int output;
     bool success;
   } cases[] = {
     {"0", 0, true},
     {"42", 42, true},
     {"42\x99", 42, false},
     {"\x99" "42\x99", 0, false},
@@ skipping 108 matching lines @@
   int64 output;
   EXPECT_FALSE(StringToInt64(input_string, &output));
   EXPECT_EQ(6, output);
 
   string16 utf16_input = UTF8ToUTF16(input_string);
   output = 0;
   EXPECT_FALSE(StringToInt64(utf16_input, &output));
   EXPECT_EQ(6, output);
 }
 
+TEST(StringNumberConversionsTest, StringToPointer) {
+  static const struct {
+    const char* input;
+    void* output;
+  } cases[] = {
+    {"0", 0},
+    {"42", reinterpret_cast<void*>(42)},
+    {"4294967295", reinterpret_cast<void*>(UINT_MAX)},
+  };
+
+  void* value;
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    EXPECT_TRUE(StringToPointer(cases[i].input, &value));
+    EXPECT_EQ(cases[i].output, value);
+  }
+
+  if (sizeof(void*) == sizeof(uint64)) {
+    EXPECT_TRUE(StringToPointer(std::string("18446744073709551615"), &value));
+    EXPECT_EQ(reinterpret_cast<void*>(ULLONG_MAX), value);
+  }
+}
+
 TEST(StringNumberConversionsTest, HexStringToInt) {
   static const struct {
     std::string input;
     int output;
     bool success;
   } cases[] = {
     {"0", 0, true},
     {"42", 66, true},
     {"-42", -66, true},
     {"+42", 66, true},
@@ skipping 163 matching lines @@
 
 TEST(StringNumberConversionsTest, HexEncode) {
   std::string hex(HexEncode(NULL, 0));
   EXPECT_EQ(hex.length(), 0U);
   unsigned char bytes[] = {0x01, 0xff, 0x02, 0xfe, 0x03, 0x80, 0x81};
   hex = HexEncode(bytes, sizeof(bytes));
   EXPECT_EQ(hex.compare("01FF02FE038081"), 0);
 }
 
 }  // namespace base