Setup a peer for read only strings that are not externalized in

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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
@@ skipping 625 matching lines @@
   EXPECT_VALID(utf8_str);
   EXPECT(Dart_IsString(utf8_str));
 
   uint8_t invalid[] = { 0xE4, 0xBA };  // underflow.
   Dart_Handle invalid_str = Dart_NewStringFromUTF8(invalid,
                                                    ARRAY_SIZE(invalid));
   EXPECT(Dart_IsError(invalid_str));
 }
 
 
-TEST_CASE(ExternalStringGetPeer) {
-  Dart_Handle result;
-
-  uint8_t data8[] = { 'o', 'n', 'e', 0xFF };
-  int peer_data = 123;
-  void* peer = NULL;
-
-  // Success.
-  Dart_Handle ext8 = Dart_NewExternalLatin1String(data8, ARRAY_SIZE(data8),
-                                                  &peer_data, NULL);
-  EXPECT_VALID(ext8);
-
-  result = Dart_ExternalStringGetPeer(ext8, &peer);
-  EXPECT_VALID(result);
-  EXPECT_EQ(&peer_data, peer);
-
-  // NULL peer.
-  result = Dart_ExternalStringGetPeer(ext8, NULL);
-  EXPECT(Dart_IsError(result));
-  EXPECT_STREQ("Dart_ExternalStringGetPeer expects argument 'peer' to be "
-               "non-null.", Dart_GetError(result));
-
-  // String is not external.
-  peer = NULL;
-  uint8_t utf8_data8[] = { 'o', 'n', 'e', 0x7F };
-  Dart_Handle str8 = Dart_NewStringFromUTF8(utf8_data8, ARRAY_SIZE(data8));
-  EXPECT_VALID(str8);
-  result = Dart_ExternalStringGetPeer(str8, &peer);
-  EXPECT(Dart_IsError(result));
-  EXPECT_STREQ("Dart_ExternalStringGetPeer expects argument 'object' to be "
-               "an external String.", Dart_GetError(result));
-  EXPECT(peer == NULL);
-
-  // Not a String.
-  peer = NULL;
-  result = Dart_ExternalStringGetPeer(Dart_True(), &peer);
-  EXPECT(Dart_IsError(result));
-  EXPECT_STREQ("Dart_ExternalStringGetPeer expects argument 'object' to be "
-               "of type String.", Dart_GetError(result));
-  EXPECT(peer == NULL);
-}
-
-
 static void ExternalStringCallbackFinalizer(void* peer) {
   *static_cast<int*>(peer) *= 2;
 }
 
 
 TEST_CASE(ExternalStringCallback) {
   int peer8 = 40;
   int peer16 = 41;
 
   {
     Dart_EnterScope();
 
     uint8_t data8[] = { 'h', 'e', 'l', 'l', 'o' };
     Dart_Handle obj8 = Dart_NewExternalLatin1String(
         data8,
         ARRAY_SIZE(data8),
         &peer8,
         ExternalStringCallbackFinalizer);
     EXPECT_VALID(obj8);
-    void* api_peer8 = NULL;
-    EXPECT_VALID(Dart_ExternalStringGetPeer(obj8, &api_peer8));
-    EXPECT_EQ(api_peer8, &peer8);
 
     uint16_t data16[] = { 'h', 'e', 'l', 'l', 'o' };
     Dart_Handle obj16 = Dart_NewExternalUTF16String(
         data16,
         ARRAY_SIZE(data16),
         &peer16,
         ExternalStringCallbackFinalizer);
     EXPECT_VALID(obj16);
-    void* api_peer16 = NULL;
-    EXPECT_VALID(Dart_ExternalStringGetPeer(obj16, &api_peer16));
-    EXPECT_EQ(api_peer16, &peer16);
 
     Dart_ExitScope();
   }
 
   EXPECT_EQ(40, peer8);
   EXPECT_EQ(41, peer16);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT_EQ(40, peer8);
   EXPECT_EQ(41, peer16);
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
@@ skipping 6186 matching lines @@
 
 // Test API call to make strings external.
 static void MakeExternalCback(void* peer) {
   *static_cast<int*>(peer) *= 2;
 }
 
 
 TEST_CASE(MakeExternalString) {
   int peer8 = 40;
   int peer16 = 41;
+  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' };
     const char* err = "string";
     Dart_Handle err_str = NewString(err);
     Dart_Handle ext_err_str = Dart_NewExternalLatin1String(
@@ skipping 41 matching lines @@
                                               NULL);
     EXPECT(Dart_IsString(str));
     EXPECT(Dart_IsString(empty_str));
     EXPECT(Dart_IsStringLatin1(str));
     EXPECT(Dart_IsStringLatin1(empty_str));
     EXPECT(Dart_IsExternalString(str));
     EXPECT(Dart_IsExternalString(empty_str));
     EXPECT_VALID(Dart_StringLength(str, &length));
     EXPECT_EQ(0, length);
 
+    // Test with single character canonical string, it should not become
+    // external string but the peer should be setup for it.
+    Isolate* isolate = Isolate::Current();
+    Dart_Handle canonical_str = Api::NewHandle(isolate, Symbols::New("*"));
+    EXPECT(Dart_IsString(canonical_str));
+    EXPECT(!Dart_IsExternalString(canonical_str));
+    uint8_t ext_canonical_str[kLength];
+    str = Dart_MakeExternalString(canonical_str,
+                                  ext_canonical_str,
+                                  kLength,
+                                  &canonical_str_peer,
+                                  MakeExternalCback);
+    EXPECT(Dart_IsString(str));
+    EXPECT(!Dart_IsExternalString(canonical_str));
+    EXPECT_EQ(canonical_str, str);
+    EXPECT(Dart_IsString(canonical_str));
+    EXPECT(!Dart_IsExternalString(canonical_str));
+
     // Test with a one byte ascii string.
     const char* ascii = "string";
     expected_length = strlen(ascii);
     Dart_Handle ascii_str = NewString(ascii);
     EXPECT_VALID(ascii_str);
     EXPECT(Dart_IsString(ascii_str));
     EXPECT(Dart_IsStringLatin1(ascii_str));
     EXPECT(!Dart_IsExternalString(ascii_str));
     EXPECT_VALID(Dart_StringLength(ascii_str, &length));
     EXPECT_EQ(expected_length, length);
@@ skipping 50 matching lines @@
     EXPECT_EQ(expected_length, length);
     EXPECT(Dart_IdentityEquals(str, utf16_str));
     for (intptr_t i = 0; i < length; i++) {
       EXPECT_EQ(0x4e8c, ext_utf16_str[i]);
     }
 
     Dart_ExitScope();
   }
   EXPECT_EQ(40, peer8);
   EXPECT_EQ(41, peer16);
+  EXPECT_EQ(42, canonical_str_peer);
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   EXPECT_EQ(80, peer8);
   EXPECT_EQ(82, peer16);
+  EXPECT_EQ(42, canonical_str_peer);  // "*" Symbol is not removed on GC.
 }
 
 
 TEST_CASE(ExternalizeConstantStrings) {
   const char* kScriptChars =
       "String testMain() {\n"
       "  return 'constant string';\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
@@ skipping 222 matching lines @@
                                    NewString("main"),
                                    0,
                                    NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(8, value);
 }
 
 }  // namespace dart