[vm] Revise Dart_IntegerToHexCString to avoid dependency on Bigint, v.2

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 8725 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