Merge libv1.

runtime/vm/object_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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 2470 matching lines @@
   EXPECT_STREQ(f.ToCString(),
                String::Handle(Field::NameFromSetter(setter_f)).ToCString());
 }
 
 
 // Expose helper function from object.cc for testing.
 bool EqualsIgnoringPrivate(const String& name, const String& private_name);
 
 
 TEST_CASE(EqualsIgnoringPrivate) {
-  OneByteString& mangled_name = OneByteString::Handle();
-  OneByteString& bare_name = OneByteString::Handle();
+  String& mangled_name = String::Handle();
+  String& bare_name = String::Handle();
 
   // Simple matches.
   mangled_name = OneByteString::New("foo");
   bare_name = OneByteString::New("foo");
-  EXPECT(mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   mangled_name = OneByteString::New("foo.");
   bare_name = OneByteString::New("foo.");
-  EXPECT(mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   mangled_name = OneByteString::New("foo.named");
   bare_name = OneByteString::New("foo.named");
-  EXPECT(mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Simple mismatches.
   mangled_name = OneByteString::New("bar");
   bare_name = OneByteString::New("foo");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   mangled_name = OneByteString::New("foo.");
   bare_name = OneByteString::New("foo");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   mangled_name = OneByteString::New("foo");
   bare_name = OneByteString::New("foo.");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   mangled_name = OneByteString::New("foo.name");
   bare_name = OneByteString::New("foo.named");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   mangled_name = OneByteString::New("foo.named");
   bare_name = OneByteString::New("foo.name");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Private match.
   mangled_name = OneByteString::New("foo@12345");
   bare_name = OneByteString::New("foo");
-  EXPECT(mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Private mismatch.
   mangled_name = OneByteString::New("food@12345");
   bare_name = OneByteString::New("foo");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Private mismatch 2.
   mangled_name = OneByteString::New("foo@12345");
   bare_name = OneByteString::New("food");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Private constructor match.
   mangled_name = OneByteString::New("foo@12345.");
   bare_name = OneByteString::New("foo.");
-  EXPECT(mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Private constructor mismatch.
   mangled_name = OneByteString::New("foo@12345.");
   bare_name = OneByteString::New("foo");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Private constructor mismatch 2.
   mangled_name = OneByteString::New("foo@12345");
   bare_name = OneByteString::New("foo.");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Named private constructor match.
   mangled_name = OneByteString::New("foo@12345.named");
   bare_name = OneByteString::New("foo.named");
-  EXPECT(mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Named private constructor mismatch.
   mangled_name = OneByteString::New("foo@12345.name");
   bare_name = OneByteString::New("foo.named");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Named private constructor mismatch 2.
   mangled_name = OneByteString::New("foo@12345.named");
   bare_name = OneByteString::New("foo.name");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Named double-private constructor match.  Yes, this happens.
   mangled_name = OneByteString::New("foo@12345.named@12345");
   bare_name = OneByteString::New("foo.named");
-  EXPECT(mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Named double-private constructor mismatch.
   mangled_name = OneByteString::New("foo@12345.name@12345");
   bare_name = OneByteString::New("foo.named");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   // Named double-private constructor mismatch.
   mangled_name = OneByteString::New("foo@12345.named@12345");
   bare_name = OneByteString::New("foo.name");
-  EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
+  EXPECT(!OneByteString::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 }
 
 
 TEST_CASE(ArrayNew_Overflow_Crash) {
   Array::Handle(Array::New(Array::kMaxElements + 1));
 }
 
 
 TEST_CASE(StackTraceFormat) {
   const char* kScriptChars =
@@ skipping 55 matching lines @@
       "#10     main (dart:test-lib:37:24)");
 }
 
 
 TEST_CASE(WeakProperty_PreserveCrossGen) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak = WeakProperty::Handle();
   {
     // Weak property and value in new. Key in old.
     HANDLESCOPE(isolate);
-    OneByteString& key = OneByteString::Handle();
+    String& key = String::Handle();
     key ^= OneByteString::New("key", Heap::kOld);
-    OneByteString& value = OneByteString::Handle();
+    String& value = String::Handle();
     value ^= OneByteString::New("value", Heap::kNew);
     weak ^= WeakProperty::New(Heap::kNew);
     weak.set_key(key);
     weak.set_value(value);
     key ^= OneByteString::null();
     value ^= OneByteString::null();
   }
   isolate->heap()->CollectAllGarbage();
   // Weak property key and value should survive due to cross-generation
   // pointers.
   EXPECT(weak.key() != Object::null());
   EXPECT(weak.value() != Object::null());
   {
     // Weak property and value in old. Key in new.
     HANDLESCOPE(isolate);
-    OneByteString& key = OneByteString::Handle();
+    String& key = String::Handle();
     key ^= OneByteString::New("key", Heap::kNew);
-    OneByteString& value = OneByteString::Handle();
+    String& value = String::Handle();
     value ^= OneByteString::New("value", Heap::kOld);
     weak ^= WeakProperty::New(Heap::kOld);
     weak.set_key(key);
     weak.set_value(value);
     key ^= OneByteString::null();
     value ^= OneByteString::null();
   }
   isolate->heap()->CollectAllGarbage();
   // Weak property key and value should survive due to cross-generation
   // pointers.
   EXPECT(weak.key() != Object::null());
   EXPECT(weak.value() != Object::null());
   {
     // Weak property and value in new. Key is a Smi.
     HANDLESCOPE(isolate);
     Integer& key = Integer::Handle();
     key ^= Integer::New(31);
-    OneByteString& value = OneByteString::Handle();
+    String& value = String::Handle();
     value ^= OneByteString::New("value", Heap::kNew);
     weak ^= WeakProperty::New(Heap::kNew);
     weak.set_key(key);
     weak.set_value(value);
     key ^= Integer::null();
     value ^= OneByteString::null();
   }
   isolate->heap()->CollectAllGarbage();
   // Weak property key and value should survive due implicit liveness of
   // non-heap objects.
   EXPECT(weak.key() != Object::null());
   EXPECT(weak.value() != Object::null());
   {
     // Weak property and value in old. Key is a Smi.
     HANDLESCOPE(isolate);
     Integer& key = Integer::Handle();
     key ^= Integer::New(32);
-    OneByteString& value = OneByteString::Handle();
+    String& value = String::Handle();
     value ^= OneByteString::New("value", Heap::kOld);
     weak ^= WeakProperty::New(Heap::kOld);
     weak.set_key(key);
     weak.set_value(value);
     key ^= OneByteString::null();
     value ^= OneByteString::null();
   }
   isolate->heap()->CollectAllGarbage();
   // Weak property key and value should survive due implicit liveness of
   // non-heap objects.
   EXPECT(weak.key() != Object::null());
   EXPECT(weak.value() != Object::null());
   {
     // Weak property and value in new. Key in VM isolate.
     HANDLESCOPE(isolate);
-    OneByteString& key = OneByteString::Handle();
+    String& key = String::Handle();
     key ^= Symbols::Dot();
-    OneByteString& value = OneByteString::Handle();
+    String& value = String::Handle();
     value ^= OneByteString::New("value", Heap::kNew);
     weak ^= WeakProperty::New(Heap::kNew);
     weak.set_key(key);
     weak.set_value(value);
     key ^= OneByteString::null();
     value ^= OneByteString::null();
   }
   isolate->heap()->CollectAllGarbage();
   // Weak property key and value should survive due to cross-generation
   // pointers.
   EXPECT(weak.key() != Object::null());
   EXPECT(weak.value() != Object::null());
   {
     // Weak property and value in old. Key in VM isolate.
     HANDLESCOPE(isolate);
-    OneByteString& key = OneByteString::Handle();
+    String& key = String::Handle();
     key ^= Symbols::Dot();
-    OneByteString& value = OneByteString::Handle();
+    String& value = String::Handle();
     value ^= OneByteString::New("value", Heap::kOld);
     weak ^= WeakProperty::New(Heap::kOld);
     weak.set_key(key);
     weak.set_value(value);
     key ^= OneByteString::null();
     value ^= OneByteString::null();
   }
   isolate->heap()->CollectAllGarbage();
   // Weak property key and value should survive due to cross-generation
   // pointers.
   EXPECT(weak.key() != Object::null());
   EXPECT(weak.value() != Object::null());
 }
 
 
 TEST_CASE(WeakProperty_PreserveRecurse) {
   // This used to end in an infinite recursion. Caused by scavenging the weak
   // property before scavenging the key.
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak = WeakProperty::Handle();
   Array& arr = Array::Handle(Array::New(1));
   {
     HANDLESCOPE(isolate);
-    OneByteString& key = OneByteString::Handle();
+    String& key = String::Handle();
     key ^= OneByteString::New("key");
     arr.SetAt(0, key);
-    OneByteString& value = OneByteString::Handle();
+    String& value = String::Handle();
     value ^= OneByteString::New("value");
     weak ^= WeakProperty::New();
     weak.set_key(key);
     weak.set_value(value);
   }
   isolate->heap()->CollectAllGarbage();
   EXPECT(weak.key() != Object::null());
   EXPECT(weak.value() != Object::null());
 }
 
 
 TEST_CASE(WeakProperty_PreserveOne_NewSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak = WeakProperty::Handle();
-  OneByteString& key = OneByteString::Handle();
+  String& key = String::Handle();
   key ^= OneByteString::New("key");
   {
     HANDLESCOPE(isolate);
-    OneByteString& value = OneByteString::Handle();
+    String& value = String::Handle();
     value ^= OneByteString::New("value");
     weak ^= WeakProperty::New();
     weak.set_key(key);
     weak.set_value(value);
   }
   isolate->heap()->CollectAllGarbage();
   EXPECT(weak.key() != Object::null());
   EXPECT(weak.value() != Object::null());
 }
 
 
 TEST_CASE(WeakProperty_PreserveTwo_NewSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak1 = WeakProperty::Handle();
-  OneByteString& key1 = OneByteString::Handle();
+  String& key1 = String::Handle();
   key1 ^= OneByteString::New("key1");
   WeakProperty& weak2 = WeakProperty::Handle();
-  OneByteString& key2 = OneByteString::Handle();
+  String& key2 = String::Handle();
   key2 ^= OneByteString::New("key2");
   {
     HANDLESCOPE(isolate);
-    OneByteString& value1 = OneByteString::Handle();
+    String& value1 = String::Handle();
     value1 ^= OneByteString::New("value1");
     weak1 ^= WeakProperty::New();
     weak1.set_key(key1);
     weak1.set_value(value1);
-    OneByteString& value2 = OneByteString::Handle();
+    String& value2 = String::Handle();
     value2 ^= OneByteString::New("value2");
     weak2 ^= WeakProperty::New();
     weak2.set_key(key2);
     weak2.set_value(value2);
   }
   isolate->heap()->CollectAllGarbage();
   EXPECT(weak1.key() != Object::null());
   EXPECT(weak1.value() != Object::null());
   EXPECT(weak2.key() != Object::null());
   EXPECT(weak2.value() != Object::null());
 }
 
 
 TEST_CASE(WeakProperty_PreserveTwoShared_NewSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak1 = WeakProperty::Handle();
   WeakProperty& weak2 = WeakProperty::Handle();
-  OneByteString& key = OneByteString::Handle();
+  String& key = String::Handle();
   key ^= OneByteString::New("key");
   {
     HANDLESCOPE(isolate);
-    OneByteString& value1 = OneByteString::Handle();
+    String& value1 = String::Handle();
     value1 ^= OneByteString::New("value1");
     weak1 ^= WeakProperty::New();
     weak1.set_key(key);
     weak1.set_value(value1);
-    OneByteString& value2 = OneByteString::Handle();
+    String& value2 = String::Handle();
     value2 ^= OneByteString::New("value2");
     weak2 ^= WeakProperty::New();
     weak2.set_key(key);
     weak2.set_value(value2);
   }
   isolate->heap()->CollectAllGarbage();
   EXPECT(weak1.key() != Object::null());
   EXPECT(weak1.value() != Object::null());
   EXPECT(weak2.key() != Object::null());
   EXPECT(weak2.value() != Object::null());
 }
 
 
 TEST_CASE(WeakProperty_PreserveOne_OldSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak = WeakProperty::Handle();
-  OneByteString& key = OneByteString::Handle();
+  String& key = String::Handle();
   key ^= OneByteString::New("key", Heap::kOld);
   {
     HANDLESCOPE(isolate);
-    OneByteString& value = OneByteString::Handle();
+    String& value = String::Handle();
     value ^= OneByteString::New("value", Heap::kOld);
     weak ^= WeakProperty::New(Heap::kOld);
     weak.set_key(key);
     weak.set_value(value);
   }
   isolate->heap()->CollectAllGarbage();
   EXPECT(weak.key() != Object::null());
   EXPECT(weak.value() != Object::null());
 }
 
 
 TEST_CASE(WeakProperty_PreserveTwo_OldSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak1 = WeakProperty::Handle();
-  OneByteString& key1 = OneByteString::Handle();
+  String& key1 = String::Handle();
   key1 ^= OneByteString::New("key1", Heap::kOld);
   WeakProperty& weak2 = WeakProperty::Handle();
-  OneByteString& key2 = OneByteString::Handle();
+  String& key2 = String::Handle();
   key2 ^= OneByteString::New("key2", Heap::kOld);
   {
     HANDLESCOPE(isolate);
-    OneByteString& value1 = OneByteString::Handle();
+    String& value1 = String::Handle();
     value1 ^= OneByteString::New("value1", Heap::kOld);
     weak1 ^= WeakProperty::New(Heap::kOld);
     weak1.set_key(key1);
     weak1.set_value(value1);
-    OneByteString& value2 = OneByteString::Handle();
+    String& value2 = String::Handle();
     value2 ^= OneByteString::New("value2", Heap::kOld);
     weak2 ^= WeakProperty::New(Heap::kOld);
     weak2.set_key(key2);
     weak2.set_value(value2);
   }
   isolate->heap()->CollectAllGarbage();
   EXPECT(weak1.key() != Object::null());
   EXPECT(weak1.value() != Object::null());
   EXPECT(weak2.key() != Object::null());
   EXPECT(weak2.value() != Object::null());
 }
 
 
 TEST_CASE(WeakProperty_PreserveTwoShared_OldSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak1 = WeakProperty::Handle();
   WeakProperty& weak2 = WeakProperty::Handle();
-  OneByteString& key = OneByteString::Handle();
+  String& key = String::Handle();
   key ^= OneByteString::New("key", Heap::kOld);
   {
     HANDLESCOPE(isolate);
-    OneByteString& value1 = OneByteString::Handle();
+    String& value1 = String::Handle();
     value1 ^= OneByteString::New("value1", Heap::kOld);
     weak1 ^= WeakProperty::New(Heap::kOld);
     weak1.set_key(key);
     weak1.set_value(value1);
-    OneByteString& value2 = OneByteString::Handle();
+    String& value2 = String::Handle();
     value2 ^= OneByteString::New("value2", Heap::kOld);
     weak2 ^= WeakProperty::New(Heap::kOld);
     weak2.set_key(key);
     weak2.set_value(value2);
   }
   isolate->heap()->CollectAllGarbage();
   EXPECT(weak1.key() != Object::null());
   EXPECT(weak1.value() != Object::null());
   EXPECT(weak2.key() != Object::null());
   EXPECT(weak2.value() != Object::null());
 }
 
 
 TEST_CASE(WeakProperty_ClearOne_NewSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak = WeakProperty::Handle();
   {
     HANDLESCOPE(isolate);
-    OneByteString& key = OneByteString::Handle();
+    String& key = String::Handle();
     key ^= OneByteString::New("key");
-    OneByteString& value = OneByteString::Handle();
+    String& value = String::Handle();
     value ^= OneByteString::New("value");
     weak ^= WeakProperty::New();
     weak.set_key(key);
     weak.set_value(value);
     key ^= OneByteString::null();
     value ^= OneByteString::null();
   }
   isolate->heap()->CollectAllGarbage();
   EXPECT(weak.key() == Object::null());
   EXPECT(weak.value() == Object::null());
 }
 
 
 TEST_CASE(WeakProperty_ClearTwoShared_NewSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak1 = WeakProperty::Handle();
   WeakProperty& weak2 = WeakProperty::Handle();
   {
     HANDLESCOPE(isolate);
-    OneByteString& key = OneByteString::Handle();
+    String& key = String::Handle();
     key ^= OneByteString::New("key");
-    OneByteString& value1 = OneByteString::Handle();
+    String& value1 = String::Handle();
     value1 ^= OneByteString::New("value1");
     weak1 ^= WeakProperty::New();
     weak1.set_key(key);
     weak1.set_value(value1);
-    OneByteString& value2 = OneByteString::Handle();
+    String& value2 = String::Handle();
     value2 ^= OneByteString::New("value2");
     weak2 ^= WeakProperty::New();
     weak2.set_key(key);
     weak2.set_value(value2);
   }
   isolate->heap()->CollectAllGarbage();
   EXPECT(weak1.key() == Object::null());
   EXPECT(weak1.value() == Object::null());
   EXPECT(weak2.key() == Object::null());
   EXPECT(weak2.value() == Object::null());
 }
 
 
 TEST_CASE(WeakProperty_ClearOne_OldSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak = WeakProperty::Handle();
   {
     HANDLESCOPE(isolate);
-    OneByteString& key = OneByteString::Handle();
+    String& key = String::Handle();
     key ^= OneByteString::New("key", Heap::kOld);
-    OneByteString& value = OneByteString::Handle();
+    String& value = String::Handle();
     value ^= OneByteString::New("value", Heap::kOld);
     weak ^= WeakProperty::New(Heap::kOld);
     weak.set_key(key);
     weak.set_value(value);
     key ^= OneByteString::null();
     value ^= OneByteString::null();
   }
   isolate->heap()->CollectAllGarbage();
   EXPECT(weak.key() == Object::null());
   EXPECT(weak.value() == Object::null());
 }
 
 
 TEST_CASE(WeakProperty_ClearTwoShared_OldSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak1 = WeakProperty::Handle();
   WeakProperty& weak2 = WeakProperty::Handle();
   {
     HANDLESCOPE(isolate);
-    OneByteString& key = OneByteString::Handle();
+    String& key = String::Handle();
     key ^= OneByteString::New("key", Heap::kOld);
-    OneByteString& value1 = OneByteString::Handle();
+    String& value1 = String::Handle();
     value1 ^= OneByteString::New("value1");
     weak1 ^= WeakProperty::New(Heap::kOld);
     weak1.set_key(key);
     weak1.set_value(value1);
-    OneByteString& value2 = OneByteString::Handle();
+    String& value2 = String::Handle();
     value2 ^= OneByteString::New("value2", Heap::kOld);
     weak2 ^= WeakProperty::New(Heap::kOld);
     weak2.set_key(key);
     weak2.set_value(value2);
   }
   isolate->heap()->CollectAllGarbage();
   EXPECT(weak1.key() == Object::null());
   EXPECT(weak1.value() == Object::null());
   EXPECT(weak2.key() == Object::null());
   EXPECT(weak2.value() == Object::null());
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart