Option to truncate integers to 64 bits, part 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 826 matching lines @@
   EXPECT_VALID(result);
   EXPECT(fits);
 
   Dart_Handle val2 = Dart_NewInteger(kIntegerVal2);
   EXPECT(Dart_IsInteger(val2));
   result = Dart_IntegerFitsIntoInt64(val2, &fits);
   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);
+  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);
+  }
 
   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);
-  EXPECT_VALID(val4);
-  uint64_t out4 = 0;
-  result = Dart_IntegerToUint64(val4, &out4);
-  EXPECT_VALID(result);
-  EXPECT_EQ(kIntegerVal4, out4);
+  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(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");
-  EXPECT(Dart_IsInteger(above_max));
-  fits = true;
-  result = Dart_IntegerFitsIntoInt64(above_max, &fits);
-  EXPECT_VALID(result);
-  EXPECT(!fits);
+  if (FLAG_limit_ints_to_64_bits) {
+    EXPECT(Dart_IsApiError(above_max));
+  } else {
+    EXPECT(Dart_IsInteger(above_max));
+    fits = true;
+    result = Dart_IntegerFitsIntoInt64(above_max, &fits);
+    EXPECT_VALID(result);
+    EXPECT(!fits);
+  }
 
   Dart_Handle min = Dart_NewInteger(kMinInt64);
   EXPECT(Dart_IsInteger(min));
   fits = false;
   result = Dart_IntegerFitsIntoInt64(min, &fits);
   EXPECT_VALID(result);
   EXPECT(fits);
 
   Dart_Handle below_min = Dart_NewIntegerFromHexCString("-0x8000000000000001");
-  EXPECT(Dart_IsInteger(below_min));
-  fits = true;
-  result = Dart_IntegerFitsIntoInt64(below_min, &fits);
-  EXPECT_VALID(result);
-  EXPECT(!fits);
+  if (FLAG_limit_ints_to_64_bits) {
+    EXPECT(Dart_IsApiError(below_min));
+  } else {
+    EXPECT(Dart_IsInteger(below_min));
+    fits = true;
+    result = Dart_IntegerFitsIntoInt64(below_min, &fits);
+    EXPECT_VALID(result);
+    EXPECT(!fits);
+  }
 }
 
 TEST_CASE(IntegerFitsIntoUint64) {
   Dart_Handle max = Dart_NewIntegerFromUint64(kMaxUint64);
-  EXPECT(Dart_IsInteger(max));
+  if (FLAG_limit_ints_to_64_bits) {
+    EXPECT(Dart_IsApiError(max));
+  } else {
+    EXPECT(Dart_IsInteger(max));
+    bool fits = false;
+    Dart_Handle result = Dart_IntegerFitsIntoUint64(max, &fits);
+    EXPECT_VALID(result);
+    EXPECT(fits);
+  }
+
+  Dart_Handle above_max = Dart_NewIntegerFromHexCString("0x10000000000000000");
+  if (FLAG_limit_ints_to_64_bits) {
+    EXPECT(Dart_IsApiError(above_max));
+  } else {
+    EXPECT(Dart_IsInteger(above_max));
+    bool fits = true;
+    Dart_Handle result = Dart_IntegerFitsIntoUint64(above_max, &fits);
+    EXPECT_VALID(result);
+    EXPECT(!fits);
+  }
+
+  Dart_Handle min = Dart_NewInteger(0);
+  EXPECT(Dart_IsInteger(min));
   bool fits = false;
-  Dart_Handle result = Dart_IntegerFitsIntoUint64(max, &fits);
+  Dart_Handle result = Dart_IntegerFitsIntoUint64(min, &fits);
   EXPECT_VALID(result);
   EXPECT(fits);
 
-  Dart_Handle above_max = Dart_NewIntegerFromHexCString("0x10000000000000000");
-  EXPECT(Dart_IsInteger(above_max));
-  fits = true;
-  result = Dart_IntegerFitsIntoUint64(above_max, &fits);
-  EXPECT_VALID(result);
-  EXPECT(!fits);
-
-  Dart_Handle min = Dart_NewInteger(0);
-  EXPECT(Dart_IsInteger(min));
-  fits = false;
-  result = Dart_IntegerFitsIntoUint64(min, &fits);
-  EXPECT_VALID(result);
-  EXPECT(fits);
-
   Dart_Handle below_min = Dart_NewIntegerFromHexCString("-1");
   EXPECT(Dart_IsInteger(below_min));
   fits = true;
   result = Dart_IntegerFitsIntoUint64(below_min, &fits);
   EXPECT_VALID(result);
   EXPECT(!fits);
 }
 
 TEST_CASE(ArrayValues) {
   EXPECT(!Dart_IsList(Dart_Null()));
@@ skipping 6881 matching lines @@
   EXPECT(Dart_IsError(Dart_GetPeer(Dart_False(), &out)));
   EXPECT(out == &out);
   EXPECT(Dart_IsError(Dart_SetPeer(Dart_False(), &out)));
   out = &out;
   Dart_Handle smi = Dart_NewInteger(0);
   EXPECT(Dart_IsError(Dart_GetPeer(smi, &out)));
   EXPECT(out == &out);
   EXPECT(Dart_IsError(Dart_SetPeer(smi, &out)));
   out = &out;
   Dart_Handle big = Dart_NewIntegerFromHexCString("0x10000000000000000");
-  EXPECT(Dart_IsError(Dart_GetPeer(big, &out)));
-  EXPECT(out == &out);
-  EXPECT(Dart_IsError(Dart_SetPeer(big, &out)));
+  if (FLAG_limit_ints_to_64_bits) {
+    EXPECT(Dart_IsApiError(big));
+  } else {
+    EXPECT(Dart_IsError(Dart_GetPeer(big, &out)));
+    EXPECT(out == &out);
+    EXPECT(Dart_IsError(Dart_SetPeer(big, &out)));
+  }
+  out = &out;
   Dart_Handle dbl = Dart_NewDouble(0.0);
   EXPECT(Dart_IsError(Dart_GetPeer(dbl, &out)));
   EXPECT(out == &out);
   EXPECT(Dart_IsError(Dart_SetPeer(dbl, &out)));
 }
 
 // Allocates an object in new space and assigns it a peer.  Removes
 // the peer and checks that the count of peer objects is decremented
 // by one.
 TEST_CASE(OneNewSpacePeer) {
@@ skipping 1742 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