Revert "[vm] Revise Dart_IntegerToHexCString to avoid dependency on Bigint"

runtime/vm/dart_api_impl_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/dart_api_impl.h"
 #include "bin/builtin.h"
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 820 matching lines @@
   const uint64_t kIntegerVal4 = 0xffffffffffffffff;
   const int64_t kIntegerVal5 = -0x7fffffffffffffff;
 
   Dart_Handle val1 = Dart_NewInteger(kIntegerVal1);
   EXPECT(Dart_IsInteger(val1));
   bool fits = false;
   Dart_Handle result = Dart_IntegerFitsIntoInt64(val1, &fits);
   EXPECT_VALID(result);
   EXPECT(fits);
 
-  int64_t out = 0;
-  result = Dart_IntegerToInt64(val1, &out);
-  EXPECT_VALID(result);
-  EXPECT_EQ(kIntegerVal1, out);
-
   Dart_Handle val2 = Dart_NewInteger(kIntegerVal2);
   EXPECT(Dart_IsInteger(val2));
   result = Dart_IntegerFitsIntoInt64(val2, &fits);
   EXPECT_VALID(result);
   EXPECT(fits);
 
-  result = Dart_IntegerToInt64(val2, &out);
-  EXPECT_VALID(result);
-  EXPECT_EQ(kIntegerVal2, out);
-
   Dart_Handle val3 = Dart_NewIntegerFromHexCString(kIntegerVal3);
   if (FLAG_limit_ints_to_64_bits) {
     EXPECT(Dart_IsApiError(val3));
   } else {
     EXPECT(Dart_IsInteger(val3));
     result = Dart_IntegerFitsIntoInt64(val3, &fits);
     EXPECT_VALID(result);
     EXPECT(!fits);
+  }
 
-    const char* chars = NULL;
-    result = Dart_IntegerToHexCString(val3, &chars);
-    EXPECT_VALID(result);
-    EXPECT(!strcmp(kIntegerVal3, chars));
-  }
+  int64_t out = 0;
+  result = Dart_IntegerToInt64(val1, &out);
+  EXPECT_VALID(result);
+  EXPECT_EQ(kIntegerVal1, out);
+
+  result = Dart_IntegerToInt64(val2, &out);
+  EXPECT_VALID(result);
+  EXPECT_EQ(kIntegerVal2, out);
+
+  const char* chars = NULL;
+  result = Dart_IntegerToHexCString(val3, &chars);
+  EXPECT_VALID(result);
+  EXPECT(!strcmp(kIntegerVal3, chars));
 
   Dart_Handle val4 = Dart_NewIntegerFromUint64(kIntegerVal4);
   if (FLAG_limit_ints_to_64_bits) {
     EXPECT(Dart_IsApiError(val4));
   } else {
     EXPECT_VALID(val4);
     uint64_t out4 = 0;
     result = Dart_IntegerToUint64(val4, &out4);
     EXPECT_VALID(result);
     EXPECT_EQ(kIntegerVal4, out4);
   }
 
   Dart_Handle val5 = Dart_NewInteger(-1);
   EXPECT_VALID(val5);
   uint64_t out5 = 0;
   result = Dart_IntegerToUint64(val5, &out5);
   EXPECT(Dart_IsError(result));
 
   Dart_Handle val6 = Dart_NewInteger(kIntegerVal5);
   EXPECT_VALID(val6);
   uint64_t out6 = 0;
   result = Dart_IntegerToUint64(val6, &out6);
   EXPECT(Dart_IsError(result));
 }
 
-TEST_CASE(IntegerToHexCString) {
-  const struct {
-    int64_t i;
-    const char* s;
-  } kIntTestCases[] = {
-      {0, "0x0"},
-      {1, "0x1"},
-      {-1, "-0x1"},
-      {0x123, "0x123"},
-      {-0xABCDEF, "-0xABCDEF"},
-      {DART_INT64_C(-0x7FFFFFFFFFFFFFFF), "-0x7FFFFFFFFFFFFFFF"},
-      {kMaxInt64, "0x7FFFFFFFFFFFFFFF"},
-      {kMinInt64, "-0x8000000000000000"},
-  };
-
-  const size_t kNumberOfIntTestCases =
-      sizeof(kIntTestCases) / sizeof(kIntTestCases[0]);
-
-  for (size_t i = 0; i < kNumberOfIntTestCases; ++i) {
-    Dart_Handle val = Dart_NewInteger(kIntTestCases[i].i);
-    EXPECT_VALID(val);
-    const char* chars = NULL;
-    Dart_Handle result = Dart_IntegerToHexCString(val, &chars);
-    EXPECT_VALID(result);
-    EXPECT_STREQ(kIntTestCases[i].s, chars);
-  }
-
-  if (!FLAG_limit_ints_to_64_bits) {
-    const char* kStrTestCases[] = {
-        "0x8000000000000000",
-        "-0x8000000000000000",
-        "0xFFFFFFFFFFFFFFFF",
-        "-0xFFFFFFFFFFFFFFFF",
-        "0xAABBCCDDEEFF00112233445566778899",
-        "-0x1234567890ABCDEF1234567890ABCDEF",
-    };
-
-    const size_t kNumberOfStrTestCases =
-        sizeof(kStrTestCases) / sizeof(kStrTestCases[0]);
-
-    for (size_t i = 0; i < kNumberOfStrTestCases; ++i) {
-      Dart_Handle val = Dart_NewIntegerFromHexCString(kStrTestCases[i]);
-      EXPECT_VALID(val);
-      const char* chars = NULL;
-      Dart_Handle result = Dart_IntegerToHexCString(val, &chars);
-      EXPECT_VALID(result);
-      EXPECT_STREQ(kStrTestCases[i], chars);
-    }
-  }
-}
-
 TEST_CASE(IntegerFitsIntoInt64) {
   Dart_Handle max = Dart_NewInteger(kMaxInt64);
   EXPECT(Dart_IsInteger(max));
   bool fits = false;
   Dart_Handle result = Dart_IntegerFitsIntoInt64(max, &fits);
   EXPECT_VALID(result);
   EXPECT(fits);
 
   Dart_Handle above_max = Dart_NewIntegerFromHexCString("0x8000000000000000");
   if (FLAG_limit_ints_to_64_bits) {
@@ skipping 8717 matching lines @@
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
   result = Dart_Invoke(lib, NewString("foozoo"), 0, NULL);
   EXPECT(Dart_IsError(result));
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart