Add an interface for retrieving the value of unsigned 64-bit integers.

runtime/vm/dart_api_impl_test.cc

 // Copyright (c) 2011, 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 "include/dart_api.h"
 
 #include "vm/assert.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/unit_test.h"
@@ skipping 283 matching lines @@
   EXPECT_VALID(result);
   EXPECT(fits);
 
   Dart_Handle val3 = Dart_NewIntegerFromHexCString(kIntegerVal3);
   EXPECT(Dart_IsInteger(val3));
   result = Dart_IntegerFitsIntoInt64(val3, &fits);
   EXPECT_VALID(result);
   EXPECT(!fits);
 
   int64_t out = 0;
-  result = Dart_IntegerValue(val1, &out);
+  result = Dart_IntegerToInt64(val1, &out);
   EXPECT_VALID(result);
   EXPECT_EQ(kIntegerVal1, out);
 
-  result = Dart_IntegerValue(val2, &out);
+  result = Dart_IntegerToInt64(val2, &out);
   EXPECT_VALID(result);
   EXPECT_EQ(kIntegerVal2, out);
 
   const char* chars = NULL;
-  result = Dart_IntegerValueHexCString(val3, &chars);
+  result = Dart_IntegerToHexCString(val3, &chars);
   EXPECT_VALID(result);
   EXPECT(!strcmp(kIntegerVal3, chars));
 }
 
 
+UNIT_TEST_CASE(IntegerFitsInto) {

[turnidge, 2011/12/08 18:26:25]

Could you make this test check 4 values for each type, one value on either side
of the border?

e.g. for signed: -1, 0, 0xFFFFFFFFFFFFFFFF, 0x10000000000000000

It might be easier for me to read if the int64 and uint64 tests were not
interleaved.

[cshapiro, 2011/12/08 22:50:50]

Done.

+  TestIsolateScope __test_isolate__;
+
+  const int64_t kLongLongMax = DART_INT64_C(0x7FFFFFFFFFFFFFFF);
+  const int64_t kLongLongMin = -kLongLongMax - 1;
+
+  const char* kUnsignedLongLongMax = "0xFFFFFFFFFFFFFFFF";
+  const uint64_t kUnsignedLongLongMin = DART_UINT64_C(0x0);
+
+  Dart_Handle long_long_min = Dart_NewInteger(kLongLongMin);
+  EXPECT(Dart_IsInteger(long_long_min));
+  bool fits = false;
+  Dart_Handle result = Dart_IntegerFitsIntoInt64(long_long_min, &fits);
+  EXPECT_VALID(result);
+  EXPECT(fits);
+  fits = true;
+  result = Dart_IntegerFitsIntoUint64(long_long_min, &fits);
+  EXPECT_VALID(result);
+  EXPECT(!fits);
+
+  Dart_Handle zero = Dart_NewInteger(kUnsignedLongLongMin);
+  EXPECT(Dart_IsInteger(zero));
+  fits = false;
+  result = Dart_IntegerFitsIntoInt64(zero, &fits);
+  EXPECT_VALID(result);
+  EXPECT(fits);
+  fits = false;
+  result = Dart_IntegerFitsIntoUint64(zero, &fits);
+  EXPECT_VALID(result);
+  EXPECT(fits);
+
+  Dart_Handle long_long_max = Dart_NewInteger(kLongLongMax);
+  EXPECT(Dart_IsInteger(long_long_max));
+  fits = false;
+  result = Dart_IntegerFitsIntoInt64(long_long_max, &fits);
+  EXPECT_VALID(result);
+  EXPECT(fits);
+  fits = false;
+  result = Dart_IntegerFitsIntoUint64(long_long_max, &fits);
+  EXPECT_VALID(result);
+  EXPECT(fits);
+
+  Dart_Handle unsigned_long_long_max =
+      Dart_NewIntegerFromHexCString(kUnsignedLongLongMax);
+  EXPECT(Dart_IsInteger(unsigned_long_long_max));
+  fits = false;
+  result = Dart_IntegerFitsIntoInt64(unsigned_long_long_max, &fits);
+  EXPECT_VALID(result);
+  EXPECT(!fits);
+  fits = false;
+  result = Dart_IntegerFitsIntoUint64(unsigned_long_long_max, &fits);
+  EXPECT_VALID(result);
+  EXPECT(fits);
+}
+
+
 UNIT_TEST_CASE(ArrayValues) {
   TestIsolateScope __test_isolate__;
 
   const int kArrayLength = 10;
   Dart_Handle str = Dart_NewString("test");
   EXPECT(!Dart_IsList(str));
   Dart_Handle val = Dart_NewList(kArrayLength);
   EXPECT(Dart_IsList(val));
   intptr_t len = 0;
   Dart_Handle result = Dart_ListLength(val, &len);
@@ skipping 11 matching lines @@
   EXPECT(Dart_IsError(result));
 
   for (int i = 0; i < kArrayLength; i++) {
     result = Dart_ListSetAt(val, i, Dart_NewInteger(i));
     EXPECT_VALID(result);
   }
   for (int i = 0; i < kArrayLength; i++) {
     result = Dart_ListGetAt(val, i);
     EXPECT_VALID(result);
     int64_t value;
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_VALID(result);
     EXPECT_EQ(i, value);
   }
 }
 
 
 UNIT_TEST_CASE(IsString) {
   TestIsolateScope __test_isolate__;
 
   uint8_t data8[] = { 'o', 'n', 'e', 0xFF };
@@ skipping 130 matching lines @@
     intptr_t len = 0;
     result = Dart_ListLength(ListAccessTestObj, &len);
     EXPECT_VALID(result);
     EXPECT_EQ(3, len);
 
     // Access elements in the array.
     int64_t value;
 
     result = Dart_ListGetAt(ListAccessTestObj, 0);
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_VALID(result);
     EXPECT_EQ(10, value);
 
     result = Dart_ListGetAt(ListAccessTestObj, 1);
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_VALID(result);
     EXPECT_EQ(20, value);
 
     result = Dart_ListGetAt(ListAccessTestObj, 2);
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_VALID(result);
     EXPECT_EQ(30, value);
 
     // Set some elements in the array.
     result = Dart_ListSetAt(ListAccessTestObj, 0, Dart_NewInteger(0));
     EXPECT_VALID(result);
     result = Dart_ListSetAt(ListAccessTestObj, 1, Dart_NewInteger(1));
     EXPECT_VALID(result);
     result = Dart_ListSetAt(ListAccessTestObj, 2, Dart_NewInteger(2));
     EXPECT_VALID(result);
 
     // Get length of array object.
     result = Dart_ListLength(ListAccessTestObj, &len);
     EXPECT_VALID(result);
     EXPECT_EQ(3, len);
 
     // Now try and access these elements in the array.
     result = Dart_ListGetAt(ListAccessTestObj, 0);
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_VALID(result);
     EXPECT_EQ(0, value);
 
     result = Dart_ListGetAt(ListAccessTestObj, 1);
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_VALID(result);
     EXPECT_EQ(1, value);
 
     result = Dart_ListGetAt(ListAccessTestObj, 2);
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_VALID(result);
     EXPECT_EQ(2, value);
 
     uint8_t native_array[3];
     result = Dart_ListGetAsBytes(ListAccessTestObj, 0, native_array, 3);
     EXPECT_VALID(result);
     EXPECT_EQ(0, native_array[0]);
     EXPECT_EQ(1, native_array[1]);
     EXPECT_EQ(2, native_array[2]);
 
     native_array[0] = 10;
     native_array[1] = 20;
     native_array[2] = 30;
     result = Dart_ListSetAsBytes(ListAccessTestObj, 0, native_array, 3);
     EXPECT_VALID(result);
     result = Dart_ListGetAsBytes(ListAccessTestObj, 0, native_array, 3);
     EXPECT_VALID(result);
     EXPECT_EQ(10, native_array[0]);
     EXPECT_EQ(20, native_array[1]);
     EXPECT_EQ(30, native_array[2]);
     result = Dart_ListGetAt(ListAccessTestObj, 2);
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_VALID(result);
     EXPECT_EQ(30, value);
 
     // Check if we get an exception when accessing beyond limit.
     result = Dart_ListGetAt(ListAccessTestObj, 4);
     EXPECT(Dart_IsError(result));
   }
 }
 
 #endif  // TARGET_ARCH_IA32.
@@ skipping 314 matching lines @@
     // Now access and set various static fields of Fields class.
     Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("Fields"));
     EXPECT_VALID(cls);
     result = Dart_GetStaticField(cls, Dart_NewString("fld1"));
     EXPECT(Dart_IsError(result));
     result = Dart_GetInstanceField(retobj, Dart_NewString("fld3"));
     EXPECT(Dart_IsError(result));
     result = Dart_GetStaticField(cls, Dart_NewString("fld4"));
     EXPECT_VALID(result);
     int64_t value = 0;
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(10, value);
     result = Dart_SetStaticField(cls,
                                  Dart_NewString("fld4"),
                                  Dart_NewInteger(20));
     EXPECT(Dart_IsError(result));
     result = Dart_GetStaticField(cls, Dart_NewString("fld3"));
     EXPECT_VALID(result);
     result = Dart_SetStaticField(cls,
                                  Dart_NewString("fld3"),
                                  Dart_NewInteger(200));
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(200, value);
 
     // Now access and set various instance fields of the returned object.
     result = Dart_GetInstanceField(retobj, Dart_NewString("fld3"));
     EXPECT(Dart_IsError(result));
     result = Dart_GetInstanceField(retobj, Dart_NewString("fld1"));
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(10, value);
     result = Dart_GetInstanceField(retobj, Dart_NewString("fld2"));
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(20, value);
     result = Dart_SetInstanceField(retobj,
                                    Dart_NewString("fld2"),
                                    Dart_NewInteger(40));
     EXPECT(Dart_IsError(result));
     result = Dart_SetInstanceField(retobj,
                                    Dart_NewString("fld1"),
                                    Dart_NewInteger(40));
     EXPECT_VALID(result);
     result = Dart_GetInstanceField(retobj, Dart_NewString("fld1"));
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(40, value);
   }
 }
 
 
 UNIT_TEST_CASE(HiddenFieldAccess) {
   const char* kScriptChars =
       "class HiddenFields  {\n"
       "  HiddenFields(int i, int j) : _fld1 = i, _fld2 = j {}\n"
       "  int _fld1;\n"
@@ skipping 25 matching lines @@
     // Now access and set various static fields of HiddenFields class.
     Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("HiddenFields"));
     EXPECT_VALID(cls);
     result = Dart_GetStaticField(cls, Dart_NewString("_fld1"));
     EXPECT(Dart_IsError(result));
     result = Dart_GetInstanceField(retobj, Dart_NewString("_fld3"));
     EXPECT(Dart_IsError(result));
     result = Dart_GetStaticField(cls, Dart_NewString("_fld4"));
     EXPECT_VALID(result);
     int64_t value = 0;
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(10, value);
     result = Dart_SetStaticField(cls,
                                  Dart_NewString("_fld4"),
                                  Dart_NewInteger(20));
     EXPECT(Dart_IsError(result));
     result = Dart_GetStaticField(cls, Dart_NewString("_fld3"));
     EXPECT_VALID(result);
     result = Dart_SetStaticField(cls,
                                  Dart_NewString("_fld3"),
                                  Dart_NewInteger(200));
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(200, value);
 
     // Now access and set various instance fields of the returned object.
     result = Dart_GetInstanceField(retobj, Dart_NewString("_fld3"));
     EXPECT(Dart_IsError(result));
     result = Dart_GetInstanceField(retobj, Dart_NewString("_fld1"));
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(10, value);
     result = Dart_GetInstanceField(retobj, Dart_NewString("_fld2"));
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(20, value);
     result = Dart_SetInstanceField(retobj,
                                    Dart_NewString("_fld2"),
                                    Dart_NewInteger(40));
     EXPECT(Dart_IsError(result));
     result = Dart_SetInstanceField(retobj,
                                    Dart_NewString("_fld1"),
                                    Dart_NewInteger(40));
     EXPECT_VALID(result);
     result = Dart_GetInstanceField(retobj, Dart_NewString("_fld1"));
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(40, value);
   }
 }
 
 
 void NativeFieldLookup(Dart_NativeArguments args) {
   UNREACHABLE();
 }
 
 
@@ skipping 186 matching lines @@
 }
 
 
 static void TestNativeFields(Dart_Handle retobj) {
   // Access and set various instance fields of the object.
   Dart_Handle result = Dart_GetInstanceField(retobj, Dart_NewString("fld3"));
   EXPECT(Dart_IsError(result));
   result = Dart_GetInstanceField(retobj, Dart_NewString("fld1"));
   EXPECT_VALID(result);
   int64_t value = 0;
-  result = Dart_IntegerValue(result, &value);
+  result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(10, value);
   result = Dart_GetInstanceField(retobj, Dart_NewString("fld2"));
   EXPECT_VALID(result);
-  result = Dart_IntegerValue(result, &value);
+  result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(20, value);
   result = Dart_SetInstanceField(retobj,
                                  Dart_NewString("fld2"),
                                  Dart_NewInteger(40));
   EXPECT(Dart_IsError(result));
   result = Dart_SetInstanceField(retobj,
                                  Dart_NewString("fld1"),
                                  Dart_NewInteger(40));
   EXPECT_VALID(result);
   result = Dart_GetInstanceField(retobj, Dart_NewString("fld1"));
   EXPECT_VALID(result);
-  result = Dart_IntegerValue(result, &value);
+  result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(40, value);
 
   // Now access and set various native instance fields of the returned object.
   const int kNativeFld0 = 0;
   const int kNativeFld1 = 1;
   const int kNativeFld2 = 2;
   const int kNativeFld3 = 3;
   const int kNativeFld4 = 4;
   intptr_t field_value = 0;
   result = Dart_GetNativeInstanceField(retobj, kNativeFld4, &field_value);
@@ skipping 18 matching lines @@
   result = Dart_SetNativeInstanceField(retobj, kNativeFld3, 4000);
   EXPECT_VALID(result);
   result = Dart_GetNativeInstanceField(retobj, kNativeFld3, &field_value);
   EXPECT_VALID(result);
   EXPECT_EQ(4000, field_value);
 
   // Now re-access various dart instance fields of the returned object
   // to ensure that there was no corruption while setting native fields.
   result = Dart_GetInstanceField(retobj, Dart_NewString("fld1"));
   EXPECT_VALID(result);
-  result = Dart_IntegerValue(result, &value);
+  result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(40, value);
   result = Dart_GetInstanceField(retobj, Dart_NewString("fld2"));
   EXPECT_VALID(result);
-  result = Dart_IntegerValue(result, &value);
+  result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(20, value);
 }
 
 
 UNIT_TEST_CASE(NativeFieldAccess) {
   const char* kScriptChars =
       "class NativeFields extends NativeFieldsWrapper {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld1;\n"
       "  final int fld2;\n"
@@ skipping 180 matching lines @@
                                0,
                                NULL);
 
     Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("TestClass"));
     EXPECT_VALID(cls);
 
     // For uninitialized fields, the getter is returned
     result = Dart_GetStaticField(cls, Dart_NewString("fld1"));
     EXPECT_VALID(result);
     int64_t value = 0;
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(7, value);
 
     result = Dart_GetStaticField(cls, Dart_NewString("fld2"));
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(11, value);
 
     // Overwrite fld2
     result = Dart_SetStaticField(cls,
                                  Dart_NewString("fld2"),
                                  Dart_NewInteger(13));
     EXPECT_VALID(result);
 
     // We now get the new value for fld2, not the initializer
     result = Dart_GetStaticField(cls, Dart_NewString("fld2"));
     EXPECT_VALID(result);
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(13, value);
   }
 }
 
 
 UNIT_TEST_CASE(StaticFieldNotFound) {
   const char* kScriptChars =
       "class TestClass  {\n"
       "  static void testMain() {\n"
       "  }\n"
@@ skipping 67 matching lines @@
     // Now invoke a dynamic method and check the result.
     Dart_Handle dart_arguments[1];
     dart_arguments[0] = Dart_NewInteger(1);
     result = Dart_InvokeDynamic(retobj,
                                 Dart_NewString("method1"),
                                 1,
                                 dart_arguments);
     EXPECT_VALID(result);
     EXPECT(Dart_IsInteger(result));
     int64_t value = 0;
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(41, value);
 
     result = Dart_InvokeDynamic(retobj, Dart_NewString("method2"), 0, NULL);
     EXPECT(Dart_IsError(result));
 
     result = Dart_InvokeDynamic(retobj, Dart_NewString("method1"), 0, NULL);
     EXPECT(Dart_IsError(result));
   }
 }
 
@@ skipping 43 matching lines @@
     EXPECT(Dart_IsClosure(retobj));
     EXPECT(!Dart_IsClosure(Dart_NewInteger(101)));
 
     // Now invoke the closure and check the result.
     Dart_Handle dart_arguments[1];
     dart_arguments[0] = Dart_NewInteger(1);
     result = Dart_InvokeClosure(retobj, 1, dart_arguments);
     EXPECT_VALID(result);
     EXPECT(Dart_IsInteger(result));
     int64_t value = 0;
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(51, value);
 
     // Invoke closure with wrong number of args, should result in exception.
     result = Dart_InvokeClosure(retobj, 0, NULL);
     EXPECT(Dart_IsError(result));
     EXPECT(Dart_ErrorHasException(result));
 
     // Invoke a function which returns a closure.
     retobj = Dart_InvokeStatic(lib,
                                Dart_NewString("InvokeClosureTest"),
@@ skipping 74 matching lines @@
     result = Dart_ThrowException(retobj);
     EXPECT(Dart_IsError(result));
 
     // Now invoke method2 which invokes a natve method where it is
     // ok to throw an exception, check the result which would indicate
     // if an exception was thrown or not.
     result = Dart_InvokeDynamic(retobj, Dart_NewString("method2"), 0, NULL);
     EXPECT_VALID(result);
     EXPECT(Dart_IsInteger(result));
     int64_t value = 0;
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_EQ(5, value);
 
     Dart_ExitScope();  // Exit the Dart API scope.
     EXPECT_EQ(size, state->ZoneSizeInBytes());
   }
 }
 
 
 void NativeArgumentCounter(Dart_NativeArguments args) {
   Dart_EnterScope();
@@ skipping 28 matching lines @@
 
     Dart_Handle result = Dart_InvokeStatic(lib,
                                            Dart_NewString("Test"),
                                            Dart_NewString("testMain"),
                                            0,
                                            NULL);
     EXPECT_VALID(result);
     EXPECT(Dart_IsInteger(result));
 
     int64_t value = 0;
-    result = Dart_IntegerValue(result, &value);
+    result = Dart_IntegerToInt64(result, &value);
     EXPECT_VALID(result);
     EXPECT_EQ(3, value);
   }
 }
 
 
 UNIT_TEST_CASE(GetClass) {
   const char* kScriptChars =
       "class DoesExist {"
       "}";
@@ skipping 178 matching lines @@
   EXPECT_VALID(result);
 
   result = Dart_InvokeStatic(result,
                              Dart_NewString(""),
                              Dart_NewString("main"),
                              0,
                              NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
-  EXPECT_VALID(Dart_IntegerValue(result, &value));
+  EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(12345, value);
 
   // Further calls to LoadScript are errors.
   result = Dart_LoadScript(url, source, library_handler);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_LoadScript: "
                "A script has already been loaded from 'dart:test-lib'.",
                Dart_GetError(result));
 }
 
@@ skipping 381 matching lines @@
 
   // Call a function and make sure native resolution works.
   result = Dart_InvokeStatic(lib,
                              Dart_NewString("Test"),
                              Dart_NewString("foo"),
                              0,
                              NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
-  EXPECT_VALID(Dart_IntegerValue(result, &value));
+  EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(654321, value);
 
   // A second call succeeds.
   result = Dart_SetNativeResolver(lib, &MyNativeResolver2);
   EXPECT_VALID(result);
 
   // 'foo' has already been resolved so gets the old value.
   result = Dart_InvokeStatic(lib,
                              Dart_NewString("Test"),
                              Dart_NewString("foo"),
                              0,
                              NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   value = 0;
-  EXPECT_VALID(Dart_IntegerValue(result, &value));
+  EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(654321, value);
 
   // 'bar' has not yet been resolved so gets the new value.
   result = Dart_InvokeStatic(lib,
                              Dart_NewString("Test"),
                              Dart_NewString("bar"),
                              0,
                              NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   value = 0;
-  EXPECT_VALID(Dart_IntegerValue(result, &value));
+  EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(123456, value);
 
   // A NULL resolver is okay, but resolution will fail.
   result = Dart_SetNativeResolver(lib, NULL);
   EXPECT_VALID(result);
 
   result = Dart_InvokeStatic(lib,
                              Dart_NewString("Test"),
                              Dart_NewString("baz"),
                              0,
@@ skipping 315 matching lines @@
 }
 
 
 UNIT_TEST_CASE(RunLoop_Exception) {
   RunLoopTest(true);
 }
 
 #endif  // TARGET_ARCH_IA32.
 
 }  // namespace dart