Add flag to disable string externalization

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 "bin/builtin.h"
 #include "vm/compiler.h"
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "include/dart_tools_api.h"
 #include "platform/assert.h"
 #include "platform/text_buffer.h"
 #include "platform/utils.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/lockers.h"
 #include "vm/timeline.h"
 #include "vm/unit_test.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, verify_acquired_data);
 DECLARE_FLAG(bool, ignore_patch_signature_mismatch);
+DECLARE_FLAG(bool, support_externalizable_strings);
 
 #ifndef PRODUCT
 
 TEST_CASE(ErrorHandleBasics) {
   const char* kScriptChars =
       "void testMain() {\n"
       "  throw new Exception(\"bad news\");\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
@@ skipping 5532 matching lines @@
   if (!strcmp(function_name, "NativeArgument_Create")) {
     return reinterpret_cast<Dart_NativeFunction>(&NativeArgumentCreate);
   } else if (!strcmp(function_name, "NativeArgument_Access")) {
     return reinterpret_cast<Dart_NativeFunction>(&NativeArgumentAccess);
   }
   return NULL;
 }
 
 
 TEST_CASE(GetNativeArguments) {
+  const bool saved_flag = FLAG_support_externalizable_strings;
+  FLAG_support_externalizable_strings = true;
+
   const char* kScriptChars =
       "import 'dart:nativewrappers';"
       "class MyObject extends NativeFieldWrapperClass2 {"
       "  static MyObject createObject() native 'NativeArgument_Create';"
       "  int accessFields(int arg1,"
       "                   int arg2,"
       "                   bool arg3,"
       "                   double arg4,"
       "                   String arg5,"
       "                   String arg6,"
@@ skipping 26 matching lines @@
       ext_ascii_str,
       size,
       reinterpret_cast<void*>(&native_arg_str_peer),
       NULL);
 
   Dart_Handle args[1];
   args[0] = extstr;
   Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 1, args);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
+
+  FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 static void NativeArgumentCounter(Dart_NativeArguments args) {
   Dart_EnterScope();
   int count = Dart_GetNativeArgumentCount(args);
   Dart_SetReturnValue(args, Dart_NewInteger(count));
   Dart_ExitScope();
 }
 
@@ skipping 2856 matching lines @@
 }
 
 
 // Test API call to make strings external.
 static void MakeExternalCback(void* peer) {
   *static_cast<int*>(peer) *= 2;
 }
 
 
 TEST_CASE(MakeExternalString) {
+  const bool saved_flag = FLAG_support_externalizable_strings;
+  FLAG_support_externalizable_strings = true;
+
   static int peer8 = 40;
   static int peer16 = 41;
   static int canonical_str_peer = 42;
   intptr_t length = 0;
   intptr_t expected_length = 0;
   {
     Dart_EnterScope();
 
     // First test some negative conditions.
     uint8_t data8[] = { 'h', 'e', 'l', 'l', 'o' };
@@ skipping 183 matching lines @@
   EXPECT_EQ(40, peer8);
   EXPECT_EQ(41, peer16);
   EXPECT_EQ(42, canonical_str_peer);
   {
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectAllGarbage();
   }
   EXPECT_EQ(80, peer8);
   EXPECT_EQ(82, peer16);
   EXPECT_EQ(42, canonical_str_peer);  // "*" Symbol is not removed on GC.
+
+  FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalizeConstantStrings) {
+  const bool saved_flag = FLAG_support_externalizable_strings;
+  FLAG_support_externalizable_strings = true;
+
   const char* kScriptChars =
       "String testMain() {\n"
       "  return 'constant string';\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle result = Dart_Invoke(lib,
                                    NewString("testMain"),
                                    0,
                                    NULL);
   const char* expected_str = "constant string";
   const intptr_t kExpectedLen = 15;
   uint8_t ext_str[kExpectedLen];
   Dart_Handle str = Dart_MakeExternalString(result,
                                             ext_str,
                                             kExpectedLen,
                                             NULL,
                                             NULL);
 
   EXPECT(Dart_IsExternalString(str));
   for (intptr_t i = 0; i < kExpectedLen; i++) {
     EXPECT_EQ(expected_str[i], ext_str[i]);
   }
+
+  FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(LazyLoadDeoptimizes) {
   const char* kLoadFirst =
       "library L;\n"
       "start(a) {\n"
       "  var obj = (a == 1) ? createB() : new A();\n"
       "  for (int i = 0; i < 4000; i++) {\n"
       "    var res = obj.foo();\n"
@@ skipping 69 matching lines @@
     Dart_Handle name, int argument_count, bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = true;
   return reinterpret_cast<Dart_NativeFunction>(&A_change_str_native);
 }
 
 
 // Do not use guarding mechanism on externalizable classes, since their class
 // can change on the fly,
 TEST_CASE(GuardExternalizedString) {
+  const bool saved_flag = FLAG_support_externalizable_strings;
+  FLAG_support_externalizable_strings = true;
+
   const char* kScriptChars =
       "main() {\n"
       "  var a = new A('hello');\n"
       "  var res = runOne(a);\n"
       "  if (res != 10640000) return -1;\n"
       "  change_str(a.f);\n"
       "  res = runOne(a);\n"
       "  return res;\n"
       "}\n"
       "runOne(a) {\n"
@@ skipping 15 matching lines @@
       TestCase::LoadTestScript(kScriptChars,
                                &ExternalStringDeoptimize_native_lookup);
   Dart_Handle result = Dart_Invoke(lib,
                                    NewString("main"),
                                    0,
                                    NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(10640000, value);
+
+  FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringDeoptimize) {
+  const bool saved_flag = FLAG_support_externalizable_strings;
+  FLAG_support_externalizable_strings = true;
+
   const char* kScriptChars =
       "String str = 'A';\n"
       "class A {\n"
       "  static change_str(String s) native 'A_change_str';\n"
       "}\n"
       "sum_chars(String s, bool b) {\n"
       "  var result = 0;\n"
       "  for (var i = 0; i < s.length; i++) {\n"
       "    if (b && i == 0) A.change_str(str);\n"
       "    result += s.codeUnitAt(i);"
@@ skipping 11 matching lines @@
       TestCase::LoadTestScript(kScriptChars,
                                &ExternalStringDeoptimize_native_lookup);
   Dart_Handle result = Dart_Invoke(lib,
                                    NewString("main"),
                                    0,
                                    NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(260, value);
+
+  FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringPolymorphicDeoptimize) {
+  const bool saved_flag = FLAG_support_externalizable_strings;
+  FLAG_support_externalizable_strings = true;
+
   const char* kScriptChars =
       "const strA = 'AAAA';\n"
       "class A {\n"
       "  static change_str(String s) native 'A_change_str';\n"
       "}\n"
       "compare(a, b, [i = 0]) {\n"
       "  return a.codeUnitAt(i) == b.codeUnitAt(i);\n"
       "}\n"
       "compareA(b, [i = 0]) {\n"
       "  return compare(strA, b, i);\n"
@@ skipping 12 matching lines @@
                                &ExternalStringDeoptimize_native_lookup);
   Dart_Handle result = Dart_Invoke(lib,
                                    NewString("main"),
                                    0,
                                    NULL);
   EXPECT_VALID(result);
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
+
+  FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringGuardFieldDeoptimize) {
+  const bool saved_flag = FLAG_support_externalizable_strings;
+  FLAG_support_externalizable_strings = true;
+
   const char* kScriptChars =
       "const strA = 'AAAA';\n"
       "class A {\n"
       "  static change_str(String s) native 'A_change_str';\n"
       "}\n"
       "class G { var f = 'A'; }\n"
       "final guard = new G();\n"
       "var shouldExternalize = false;\n"
       "ext() { if (shouldExternalize) A.change_str(strA); }\n"
       "compare(a, b, [i = 0]) {\n"
@@ skipping 17 matching lines @@
                                &ExternalStringDeoptimize_native_lookup);
   Dart_Handle result = Dart_Invoke(lib,
                                    NewString("main"),
                                    0,
                                    NULL);
   EXPECT_VALID(result);
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
+
+  FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringStaticFieldDeoptimize) {
+  const bool saved_flag = FLAG_support_externalizable_strings;
+  FLAG_support_externalizable_strings = true;
+
   const char* kScriptChars =
       "const strA = 'AAAA';\n"
       "class A {\n"
       "  static change_str(String s) native 'A_change_str';\n"
       "}\n"
       "class G { static final f = strA; }\n"
       "compare(a, b, [i = 0]) {\n"
       "  return a.codeUnitAt(i) == b.codeUnitAt(i);\n"
       "}\n"
       "compareA(b, [i = 0]) {\n"
@@ skipping 12 matching lines @@
                                &ExternalStringDeoptimize_native_lookup);
   Dart_Handle result = Dart_Invoke(lib,
                                    NewString("main"),
                                    0,
                                    NULL);
   EXPECT_VALID(result);
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
+
+  FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringTrimDoubleParse) {
+  const bool saved_flag = FLAG_support_externalizable_strings;
+  FLAG_support_externalizable_strings = true;
+
   const char* kScriptChars =
       "String str = 'A';\n"
       "class A {\n"
       "  static change_str(String s) native 'A_change_str';\n"
       "}\n"
       "main() {\n"
       "  var externalOneByteString = ' 0.2\\xA0 ';\n;"
       "  A.change_str(externalOneByteString);\n"
       "  var externalTwoByteString = ' \\u{2029}0.6\\u{2029} ';\n"
       "  A.change_str(externalTwoByteString);\n"
       "  var x = double.parse(externalOneByteString);\n"
       "  var y = double.parse(externalTwoByteString);\n"
       "  return ((x + y) * 10).toInt();\n"
       "}\n";
   Dart_Handle lib =
       TestCase::LoadTestScript(kScriptChars,
                                &ExternalStringDeoptimize_native_lookup);
   Dart_Handle result = Dart_Invoke(lib,
                                    NewString("main"),
                                    0,
                                    NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(8, value);
+
+  FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringDoubleParse) {
+  const bool saved_flag = FLAG_support_externalizable_strings;
+  FLAG_support_externalizable_strings = true;
+
   const char* kScriptChars =
       "String str = 'A';\n"
       "class A {\n"
       "  static change_str(String s) native 'A_change_str';\n"
       "}\n"
       "main() {\n"
       "  var externalOneByteString = '0.2';\n;"
       "  A.change_str(externalOneByteString);\n"
       "  var externalTwoByteString = '0.6';\n"
       "  A.change_str(externalTwoByteString);\n"
       "  var x = double.parse(externalOneByteString);\n"
       "  var y = double.parse(externalTwoByteString);\n"
       "  return ((x + y) * 10).toInt();\n"
       "}\n";
   Dart_Handle lib =
       TestCase::LoadTestScript(kScriptChars,
                                &ExternalStringDeoptimize_native_lookup);
   Dart_Handle result = Dart_Invoke(lib,
                                    NewString("main"),
                                    0,
                                    NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(8, value);
+
+  FLAG_support_externalizable_strings = saved_flag;
 }
 
 
 TEST_CASE(ExternalStringIndexOf) {
-    const char* kScriptChars =
+  const char* kScriptChars =
       "main(String pattern) {\n"
       "  var str = 'Hello World';\n"
       "  return str.indexOf(pattern);\n"
       "}\n";
   Dart_Handle lib =
       TestCase::LoadTestScript(kScriptChars, NULL);
 
   uint8_t data8[] = { 'W' };
   Dart_Handle ext8 = Dart_NewExternalLatin1String(data8, ARRAY_SIZE(data8),
                                                   data8, NULL);
@@ skipping 926 matching lines @@
   result = Dart_Invoke(lib,
                        NewString("foozoo"),
                        0,
                        NULL);
   EXPECT(Dart_IsError(result));
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart