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) {
+  FLAG_support_externalizable_strings = true;

[srdjan, 2016/04/07 16:47:36]

It seems that we are not that consistent, but many times we restore the old flag
value before existing the test, so that the local flag value does not escape the
test.

[rmacnak, 2016/04/07 20:22:37]

Added a restore for these changes.

+
   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 2902 matching lines @@
 }
 
 
 // Test API call to make strings external.
 static void MakeExternalCback(void* peer) {
   *static_cast<int*>(peer) *= 2;
 }
 
 
 TEST_CASE(MakeExternalString) {
+  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 187 matching lines @@
     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.
 }
 
 
 TEST_CASE(ExternalizeConstantStrings) {
+  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);
@@ skipping 92 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) {
+  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 19 matching lines @@
                                    0,
                                    NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(10640000, value);
 }
 
 
 TEST_CASE(ExternalStringDeoptimize) {
+  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 15 matching lines @@
                                    0,
                                    NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(260, value);
 }
 
 
 TEST_CASE(ExternalStringPolymorphicDeoptimize) {
+  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 16 matching lines @@
                                    NULL);
   EXPECT_VALID(result);
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 }
 
 
 TEST_CASE(ExternalStringGuardFieldDeoptimize) {
+  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 21 matching lines @@
                                    NULL);
   EXPECT_VALID(result);
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 }
 
 
 TEST_CASE(ExternalStringStaticFieldDeoptimize) {
+  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 16 matching lines @@
                                    NULL);
   EXPECT_VALID(result);
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 }
 
 
 TEST_CASE(ExternalStringTrimDoubleParse) {
+  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);
 }
 
 
 TEST_CASE(ExternalStringDoubleParse) {
+  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);
 }
 
 
 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