Implement safepointing of threads

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/globals.h"
 
 #include "vm/assembler.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
@@ skipping 17 matching lines @@
 
 static RawClass* CreateDummyClass(const String& class_name,
                                   const Script& script) {
   const Class& cls = Class::Handle(
       Class::New(class_name, script, Scanner::kNoSourcePos));
   cls.set_is_synthesized_class();  // Dummy class for testing.
   return cls.raw();
 }
 
 
-TEST_CASE(Class) {
+VM_TEST_CASE(Class) {
   // Allocate the class first.
   const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
 
   // Class has no fields and no functions yet.
   EXPECT_EQ(Array::Handle(cls.fields()).Length(), 0);
   EXPECT_EQ(Array::Handle(cls.functions()).Length(), 0);
 
   // Setup the interfaces in the class.
@@ skipping 87 matching lines @@
   EXPECT(!function.HasOptionalParameters());
 
   function_name = String::New("bar");
   function = cls.LookupDynamicFunction(function_name);
   EXPECT(!function.IsNull());
   EXPECT_EQ(kNumFixedParameters, function.num_fixed_parameters());
   EXPECT_EQ(kNumOptionalParameters, function.NumOptionalParameters());
 }
 
 
-TEST_CASE(TypeArguments) {
+VM_TEST_CASE(TypeArguments) {
   const Type& type1 = Type::Handle(Type::Double());
   const Type& type2 = Type::Handle(Type::StringType());
   const TypeArguments& type_arguments1 = TypeArguments::Handle(
     TypeArguments::New(2));
   type_arguments1.SetTypeAt(0, type1);
   type_arguments1.SetTypeAt(1, type2);
   const TypeArguments& type_arguments2 = TypeArguments::Handle(
     TypeArguments::New(2));
   type_arguments2.SetTypeAt(0, type1);
   type_arguments2.SetTypeAt(1, type2);
   EXPECT_NE(type_arguments1.raw(), type_arguments2.raw());
   OS::Print("1: %s\n", type_arguments1.ToCString());
   OS::Print("2: %s\n", type_arguments2.ToCString());
   EXPECT(type_arguments1.Equals(type_arguments2));
   TypeArguments& type_arguments3 = TypeArguments::Handle();
   type_arguments1.Canonicalize();
   type_arguments3 ^= type_arguments2.Canonicalize();
   EXPECT_EQ(type_arguments1.raw(), type_arguments3.raw());
 }
 
 
-TEST_CASE(TokenStream) {
+VM_TEST_CASE(TokenStream) {
   String& source = String::Handle(String::New("= ( 9 , ."));
   String& private_key = String::Handle(String::New(""));
   Scanner scanner(source, private_key);
   const Scanner::GrowableTokenStream& ts = scanner.GetStream();
   EXPECT_EQ(6, ts.length());
   EXPECT_EQ(Token::kLPAREN, ts[1].kind);
   const TokenStream& token_stream = TokenStream::Handle(
       TokenStream::New(ts, private_key, false));
   TokenStream::Iterator iterator(token_stream, 0);
   // EXPECT_EQ(6, token_stream.Length());
   iterator.Advance();  // Advance to '(' token.
   EXPECT_EQ(Token::kLPAREN, iterator.CurrentTokenKind());
   iterator.Advance();
   iterator.Advance();
   iterator.Advance();  // Advance to '.' token.
   EXPECT_EQ(Token::kPERIOD, iterator.CurrentTokenKind());
   iterator.Advance();  // Advance to end of stream.
   EXPECT_EQ(Token::kEOS, iterator.CurrentTokenKind());
 }
 
 
-TEST_CASE(GenerateExactSource) {
+VM_TEST_CASE(GenerateExactSource) {
   // Verify the exact formatting of generated sources.
   const char* kScriptChars =
   "\n"
   "class A {\n"
   "  static bar() { return 42; }\n"
   "  static fly() { return 5; }\n"
   "  void catcher(x) {\n"
   "    try {\n"
   "      if (x) {\n"
   "        fly();\n"
@@ skipping 42 matching lines @@
   EXPECT(!cls.IsNull());
   const intptr_t end_token_pos = cls.ComputeEndTokenPos();
   const Script& scr = Script::Handle(cls.script());
   intptr_t line;
   intptr_t col;
   scr.GetTokenLocation(end_token_pos, &line, &col);
   EXPECT(line == 10 && col == 1);
 }
 
 
-TEST_CASE(InstanceClass) {
+VM_TEST_CASE(InstanceClass) {
   // Allocate the class first.
   String& class_name = String::Handle(Symbols::New("EmptyClass"));
   Script& script = Script::Handle();
   const Class& empty_class =
       Class::Handle(CreateDummyClass(class_name, script));
 
   // EmptyClass has no fields and no functions.
   EXPECT_EQ(Array::Handle(empty_class.fields()).Length(), 0);
   EXPECT_EQ(Array::Handle(empty_class.functions()).Length(), 0);
 
@@ skipping 25 matching lines @@
   intptr_t header_size = sizeof(RawObject);
   EXPECT_EQ(Utils::RoundUp((header_size + (1 * kWordSize)), kObjectAlignment),
             one_field_class.instance_size());
   EXPECT_EQ(header_size, field.Offset());
   EXPECT(!one_field_class.is_implemented());
   one_field_class.set_is_implemented();
   EXPECT(one_field_class.is_implemented());
 }
 
 
-TEST_CASE(Smi) {
+VM_TEST_CASE(Smi) {
   const Smi& smi = Smi::Handle(Smi::New(5));
   Object& smi_object = Object::Handle(smi.raw());
   EXPECT(smi.IsSmi());
   EXPECT(smi_object.IsSmi());
   EXPECT_EQ(5, smi.Value());
   const Object& object = Object::Handle();
   EXPECT(!object.IsSmi());
   smi_object = Object::null();
   EXPECT(!smi_object.IsSmi());
 
@@ skipping 41 matching lines @@
       "10000000000000000000"));
   Bigint& big2 = Bigint::Handle(Bigint::NewFromCString(
       "-10000000000000000000"));
   EXPECT_EQ(-1, a.CompareWith(big1));
   EXPECT_EQ(1, a.CompareWith(big2));
   EXPECT_EQ(-1, c.CompareWith(big1));
   EXPECT_EQ(1, c.CompareWith(big2));
 }
 
 
-TEST_CASE(StringCompareTo) {
+VM_TEST_CASE(StringCompareTo) {
   const String& abcd = String::Handle(String::New("abcd"));
   const String& abce = String::Handle(String::New("abce"));
   EXPECT_EQ(0, abcd.CompareTo(abcd));
   EXPECT_EQ(0, abce.CompareTo(abce));
   EXPECT(abcd.CompareTo(abce) < 0);
   EXPECT(abce.CompareTo(abcd) > 0);
 
   const int kMonkeyLen = 4;
   const uint8_t monkey_utf8[kMonkeyLen] = { 0xf0, 0x9f, 0x90, 0xb5 };
   const String& monkey_face =
@@ skipping 23 matching lines @@
   EXPECT(abce.CompareTo(monkey_face) < 0);
   EXPECT(abcd.CompareTo(domino) < 0);
   EXPECT(abce.CompareTo(domino) < 0);
   EXPECT(domino.CompareTo(abcd) > 0);
   EXPECT(domino.CompareTo(abcd) > 0);
   EXPECT(monkey_face.CompareTo(abce) > 0);
   EXPECT(monkey_face.CompareTo(abce) > 0);
 }
 
 
-TEST_CASE(StringEncodeIRI) {
+VM_TEST_CASE(StringEncodeIRI) {
   const char* kInput =
       "file:///usr/local/johnmccutchan/workspace/dart-repo/dart/test.dart";
   const char* kOutput =
       "file%3A%2F%2F%2Fusr%2Flocal%2Fjohnmccutchan%2Fworkspace%2F"
       "dart-repo%2Fdart%2Ftest.dart";
   const String& input = String::Handle(String::New(kInput));
   const String& output = String::Handle(String::New(kOutput));
   const String& encoded = String::Handle(String::EncodeIRI(input));
   EXPECT(output.Equals(encoded));
 }
 
 
-TEST_CASE(StringDecodeIRI) {
+VM_TEST_CASE(StringDecodeIRI) {
   const char* kOutput =
       "file:///usr/local/johnmccutchan/workspace/dart-repo/dart/test.dart";
   const char* kInput =
       "file%3A%2F%2F%2Fusr%2Flocal%2Fjohnmccutchan%2Fworkspace%2F"
       "dart-repo%2Fdart%2Ftest.dart";
   const String& input = String::Handle(String::New(kInput));
   const String& output = String::Handle(String::New(kOutput));
   const String& decoded = String::Handle(String::DecodeIRI(input));
   EXPECT(output.Equals(decoded));
 }
 
 
-TEST_CASE(StringDecodeIRIInvalid) {
+VM_TEST_CASE(StringDecodeIRIInvalid) {
   String& input = String::Handle();
   input = String::New("file%");
   String& decoded = String::Handle();
   decoded = String::DecodeIRI(input);
   EXPECT(decoded.IsNull());
   input = String::New("file%3");
   decoded = String::DecodeIRI(input);
   EXPECT(decoded.IsNull());
   input = String::New("file%3g");
   decoded = String::DecodeIRI(input);
   EXPECT(decoded.IsNull());
 }
 
 
-TEST_CASE(StringIRITwoByte) {
+VM_TEST_CASE(StringIRITwoByte) {
   const intptr_t kInputLen = 3;
   const uint16_t kInput[kInputLen] = { 'x', '/', 256 };
   const String& input = String::Handle(String::FromUTF16(kInput, kInputLen));
   const intptr_t kOutputLen = 10;
   const uint16_t kOutput[kOutputLen] =
       { 'x', '%', '2', 'F', '%', 'C', '4', '%', '8', '0' };
   const String& output = String::Handle(String::FromUTF16(kOutput, kOutputLen));
   const String& encoded = String::Handle(String::EncodeIRI(input));
   EXPECT(output.Equals(encoded));
   const String& decoded = String::Handle(String::DecodeIRI(output));
   EXPECT(input.Equals(decoded));
 }
 
 
-TEST_CASE(Mint) {
+VM_TEST_CASE(Mint) {
 // On 64-bit architectures a Smi is stored in a 64 bit word. A Midint cannot
 // be allocated if it does fit into a Smi.
 #if !defined(ARCH_IS_64_BIT)
   { Mint& med = Mint::Handle();
     EXPECT(med.IsNull());
     int64_t v = DART_2PART_UINT64_C(1, 0);
     med ^= Integer::New(v);
     EXPECT_EQ(v, med.value());
     const String& smi_str = String::Handle(String::New("1"));
     const String& mint1_str = String::Handle(String::New("2147419168"));
@@ skipping 53 matching lines @@
   mint1 ^= Integer::NewCanonical(mint_string);
   Mint& mint2 = Mint::Handle();
   mint2 ^= Integer::NewCanonical(mint_string);
   EXPECT_EQ(mint1.value(), mint_value);
   EXPECT_EQ(mint2.value(), mint_value);
   EXPECT_EQ(mint1.raw(), mint2.raw());
 #endif
 }
 
 
-TEST_CASE(Double) {
+VM_TEST_CASE(Double) {
   {
     const double dbl_const = 5.0;
     const Double& dbl = Double::Handle(Double::New(dbl_const));
     Object& dbl_object = Object::Handle(dbl.raw());
     EXPECT(dbl.IsDouble());
     EXPECT(dbl_object.IsDouble());
     EXPECT_EQ(dbl_const, dbl.value());
   }
 
   {
@@ skipping 63 matching lines @@
     EXPECT_EQ(2.0, dbl1.value());
 
     // Disallow legacy form.
     const String& dbl_str2 = String::Handle(String::New("2.0d"));
     const Double& dbl2 = Double::Handle(Double::New(dbl_str2));
     EXPECT(dbl2.IsNull());
   }
 }
 
 
-TEST_CASE(Bigint) {
+VM_TEST_CASE(Bigint) {
   Bigint& b = Bigint::Handle();
   EXPECT(b.IsNull());
   const char* cstr = "18446744073709551615000";
   const String& test = String::Handle(String::New(cstr));
   b ^= Integer::NewCanonical(test);
   const char* str = b.ToCString();
   EXPECT_STREQ(cstr, str);
 
   int64_t t64 = DART_2PART_UINT64_C(1, 0);
   Bigint& big = Bigint::Handle(Bigint::NewFromInt64(t64));
@@ skipping 18 matching lines @@
   Smi& smi2 = Smi::Handle(Smi::New(-2));
 
   EXPECT_EQ(-1, smi1.CompareWith(big1));
   EXPECT_EQ(-1, smi2.CompareWith(big1));
 
   EXPECT_EQ(1, smi1.CompareWith(big3));
   EXPECT_EQ(1, smi2.CompareWith(big3));
 }
 
 
-TEST_CASE(Integer) {
+VM_TEST_CASE(Integer) {
   Integer& i = Integer::Handle();
   i = Integer::NewCanonical(String::Handle(String::New("12")));
   EXPECT(i.IsSmi());
   i = Integer::NewCanonical(String::Handle(String::New("-120")));
   EXPECT(i.IsSmi());
   i = Integer::NewCanonical(String::Handle(String::New("0")));
   EXPECT(i.IsSmi());
   i = Integer::NewCanonical(
       String::Handle(String::New("12345678901234567890")));
   EXPECT(i.IsBigint());
   i = Integer::NewCanonical(
       String::Handle(String::New("-12345678901234567890111222")));
   EXPECT(i.IsBigint());
 }
 
 
-TEST_CASE(String) {
+VM_TEST_CASE(String) {
   const char* kHello = "Hello World!";
   int32_t hello_len = strlen(kHello);
   const String& str = String::Handle(String::New(kHello));
   EXPECT(str.IsInstance());
   EXPECT(str.IsString());
   EXPECT(str.IsOneByteString());
   EXPECT(!str.IsTwoByteString());
   EXPECT(!str.IsNumber());
   EXPECT_EQ(hello_len, str.Length());
   EXPECT_EQ('H', str.CharAt(0));
@@ skipping 126 matching lines @@
     const String& str16 = String::Handle(String::FromUTF32(char32, 3));
     EXPECT(!str16.IsOneByteString());
     EXPECT(str16.IsTwoByteString());
     EXPECT_EQ(0x0000, str16.CharAt(0));
     EXPECT_EQ(0x7FFF, str16.CharAt(1));
     EXPECT_EQ(0xFFFF, str16.CharAt(2));
   }
 }
 
 
-TEST_CASE(StringFormat) {
+VM_TEST_CASE(StringFormat) {
   const char* hello_str = "Hello World!";
   const String& str =
       String::Handle(String::NewFormatted("Hello %s!", "World"));
   EXPECT(str.IsInstance());
   EXPECT(str.IsString());
   EXPECT(str.IsOneByteString());
   EXPECT(!str.IsTwoByteString());
   EXPECT(!str.IsNumber());
   EXPECT(str.Equals(hello_str));
 }
 
 
-TEST_CASE(StringConcat) {
+VM_TEST_CASE(StringConcat) {
   // Create strings from concatenated 1-byte empty strings.
   {
     const String& empty1 = String::Handle(String::New(""));
     EXPECT(empty1.IsOneByteString());
     EXPECT_EQ(0, empty1.Length());
 
     const String& empty2 = String::Handle(String::New(""));
     EXPECT(empty2.IsOneByteString());
     EXPECT_EQ(0, empty2.Length());
 
@@ skipping 513 matching lines @@
     EXPECT_EQ(twostr.Length()*2 + onestr.Length(), two_one_two_str.Length());
     uint16_t two_one_two[] = { 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
                                'o', 'n', 'e', ' ', 'b', 'y', 't', 'e',
                                0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
     intptr_t two_one_two_len = sizeof(two_one_two) / sizeof(two_one_two[0]);
     EXPECT(two_one_two_str.Equals(two_one_two, two_one_two_len));
   }
 }
 
 
-TEST_CASE(StringHashConcat) {
+VM_TEST_CASE(StringHashConcat) {
   EXPECT_EQ(String::Handle(String::New("onebyte")).Hash(),
             String::HashConcat(String::Handle(String::New("one")),
                                String::Handle(String::New("byte"))));
   uint16_t clef_utf16[] = { 0xD834, 0xDD1E };
   const String& clef = String::Handle(String::FromUTF16(clef_utf16, 2));
   int32_t clef_utf32[] = { 0x1D11E };
   EXPECT(clef.Equals(clef_utf32, 1));
   intptr_t hash32 = String::Hash(clef_utf32, 1);
   EXPECT_EQ(hash32, clef.Hash());
   EXPECT_EQ(hash32, String::HashConcat(
       String::Handle(String::FromUTF16(clef_utf16, 1)),
       String::Handle(String::FromUTF16(clef_utf16 + 1, 1))));
 }
 
 
-TEST_CASE(StringSubStringDifferentWidth) {
+VM_TEST_CASE(StringSubStringDifferentWidth) {
   // Create 1-byte substring from a 1-byte source string.
   const char* onechars =
       "\xC3\xB6\xC3\xB1\xC3\xA9";
 
   const String& onestr = String::Handle(String::New(onechars));
   EXPECT(!onestr.IsNull());
   EXPECT(onestr.IsOneByteString());
   EXPECT(!onestr.IsTwoByteString());
 
   const String& onesub = String::Handle(String::SubString(onestr, 0));
@@ skipping 41 matching lines @@
   EXPECT(foursub2.IsTwoByteString());
   EXPECT_EQ(foursub2.Length(), 3);
 
   const String& foursub4 = String::Handle(String::SubString(fourstr, 6));
   EXPECT_EQ(foursub4.Length(), 8);
   EXPECT(!foursub4.IsNull());
   EXPECT(foursub4.IsTwoByteString());
 }
 
 
-TEST_CASE(StringFromUtf8Literal) {
+VM_TEST_CASE(StringFromUtf8Literal) {
   // Create a 1-byte string from a UTF-8 encoded string literal.
   {
     const char* src =
         "\xC2\xA0\xC2\xA1\xC2\xA2\xC2\xA3"
         "\xC2\xA4\xC2\xA5\xC2\xA6\xC2\xA7"
         "\xC2\xA8\xC2\xA9\xC2\xAA\xC2\xAB"
         "\xC2\xAC\xC2\xAD\xC2\xAE\xC2\xAF"
         "\xC2\xB0\xC2\xB1\xC2\xB2\xC2\xB3"
         "\xC2\xB4\xC2\xB5\xC2\xB6\xC2\xB7"
         "\xC2\xB8\xC2\xB9\xC2\xBA\xC2\xBB"
@@ skipping 147 matching lines @@
     EXPECT(str.IsTwoByteString());
     intptr_t expected_size = sizeof(expected) / sizeof(expected[0]);
     EXPECT_EQ(expected_size, str.Length());
     for (int i = 0; i < str.Length(); ++i) {
       EXPECT_EQ(expected[i], str.CharAt(i));
     }
   }
 }
 
 
-TEST_CASE(StringEqualsUtf8) {
+VM_TEST_CASE(StringEqualsUtf8) {
   const char* onesrc = "abc";
   const String& onestr = String::Handle(String::New(onesrc));
   EXPECT(onestr.IsOneByteString());
   EXPECT(!onestr.Equals(""));
   EXPECT(!onestr.Equals("a"));
   EXPECT(!onestr.Equals("ab"));
   EXPECT(onestr.Equals("abc"));
   EXPECT(!onestr.Equals("abcd"));
 
   const char* twosrc = "\xD7\x90\xD7\x91\xD7\x92";
@@ skipping 10 matching lines @@
   EXPECT(fourstr.IsTwoByteString());
   EXPECT(!fourstr.Equals(""));
   EXPECT(!fourstr.Equals("\xF0\x90\x8E\xA0"));
   EXPECT(!fourstr.Equals("\xF0\x90\x8E\xA0\xF0\x90\x8E\xA1"));
   EXPECT(fourstr.Equals("\xF0\x90\x8E\xA0\xF0\x90\x8E\xA1\xF0\x90\x8E\xA2"));
   EXPECT(!fourstr.Equals("\xF0\x90\x8E\xA0\xF0\x90\x8E\xA1"
                          "\xF0\x90\x8E\xA2\xF0\x90\x8E\xA3"));
 }
 
 
-TEST_CASE(StringEqualsUTF32) {
+VM_TEST_CASE(StringEqualsUTF32) {
   const String& empty = String::Handle(String::New(""));
   const String& t_str = String::Handle(String::New("t"));
   const String& th_str = String::Handle(String::New("th"));
   const int32_t chars[] = {'t', 'h', 'i', 's'};
   EXPECT(!empty.Equals(chars, -1));
   EXPECT(empty.Equals(chars, 0));
   EXPECT(!empty.Equals(chars, 1));
   EXPECT(!t_str.Equals(chars, 0));
   EXPECT(t_str.Equals(chars, 1));
   EXPECT(!t_str.Equals(chars, 2));
   EXPECT(!th_str.Equals(chars, 1));
   EXPECT(th_str.Equals(chars, 2));
   EXPECT(!th_str.Equals(chars, 3));
 }
 
 
-TEST_CASE(ExternalOneByteString) {
+VM_TEST_CASE(ExternalOneByteString) {
   uint8_t characters[] = { 0xF6, 0xF1, 0xE9 };
   intptr_t len = ARRAY_SIZE(characters);
 
   const String& str =
       String::Handle(
           ExternalOneByteString::New(characters, len, NULL, NULL, Heap::kNew));
   EXPECT(!str.IsOneByteString());
   EXPECT(str.IsExternalOneByteString());
   EXPECT_EQ(str.Length(), len);
   EXPECT(str.Equals("\xC3\xB6\xC3\xB1\xC3\xA9"));
@@ skipping 11 matching lines @@
   EXPECT(concat.Equals("\xC3\xB6\xC3\xB1\xC3\xA9\xC3\xB6\xC3\xB1\xC3\xA9"));
 
   const String& substr = String::Handle(String::SubString(str, 1, 1));
   EXPECT(!substr.IsExternalOneByteString());
   EXPECT(substr.IsOneByteString());
   EXPECT_EQ(1, substr.Length());
   EXPECT(substr.Equals("\xC3\xB1"));
 }
 
 
-TEST_CASE(EscapeSpecialCharactersOneByteString) {
+VM_TEST_CASE(EscapeSpecialCharactersOneByteString) {
   uint8_t characters[] =
       { 'a', '\n', '\f', '\b', '\t', '\v', '\r', '\\', '$', 'z' };
   intptr_t len = ARRAY_SIZE(characters);
 
   const String& str =
       String::Handle(
           OneByteString::New(characters, len, Heap::kNew));
   EXPECT(str.IsOneByteString());
   EXPECT_EQ(str.Length(), len);
   EXPECT(str.Equals("a\n\f\b\t\v\r\\$z"));
   const String& escaped_str =
       String::Handle(String::EscapeSpecialCharacters(str));
   EXPECT(escaped_str.Equals("a\\n\\f\\b\\t\\v\\r\\\\\\$z"));
 
   const String& escaped_empty_str =
       String::Handle(String::EscapeSpecialCharacters(Symbols::Empty()));
   EXPECT_EQ(escaped_empty_str.Length(), 0);
 }
 
 
-TEST_CASE(EscapeSpecialCharactersExternalOneByteString) {
+VM_TEST_CASE(EscapeSpecialCharactersExternalOneByteString) {
   uint8_t characters[] =
       { 'a', '\n', '\f', '\b', '\t', '\v', '\r', '\\', '$', 'z' };
   intptr_t len = ARRAY_SIZE(characters);
 
   const String& str =
       String::Handle(
           ExternalOneByteString::New(characters, len, NULL, NULL, Heap::kNew));
   EXPECT(!str.IsOneByteString());
   EXPECT(str.IsExternalOneByteString());
   EXPECT_EQ(str.Length(), len);
   EXPECT(str.Equals("a\n\f\b\t\v\r\\$z"));
   const String& escaped_str =
       String::Handle(String::EscapeSpecialCharacters(str));
   EXPECT(escaped_str.Equals("a\\n\\f\\b\\t\\v\\r\\\\\\$z"));
 
   const String& empty_str =
       String::Handle(
           ExternalOneByteString::New(characters, 0, NULL, NULL, Heap::kNew));
   const String& escaped_empty_str =
       String::Handle(String::EscapeSpecialCharacters(empty_str));
   EXPECT_EQ(empty_str.Length(), 0);
   EXPECT_EQ(escaped_empty_str.Length(), 0);
 }
 
-TEST_CASE(EscapeSpecialCharactersTwoByteString) {
+VM_TEST_CASE(EscapeSpecialCharactersTwoByteString) {
   uint16_t characters[] =
       { 'a', '\n', '\f', '\b', '\t', '\v', '\r', '\\', '$', 'z' };
   intptr_t len = ARRAY_SIZE(characters);
 
   const String& str =
       String::Handle(TwoByteString::New(characters, len, Heap::kNew));
   EXPECT(str.IsTwoByteString());
   EXPECT_EQ(str.Length(), len);
   EXPECT(str.Equals("a\n\f\b\t\v\r\\$z"));
   const String& escaped_str =
       String::Handle(String::EscapeSpecialCharacters(str));
   EXPECT(escaped_str.Equals("a\\n\\f\\b\\t\\v\\r\\\\\\$z"));
 
   const String& empty_str =
       String::Handle(TwoByteString::New(static_cast<intptr_t>(0), Heap::kNew));
   const String& escaped_empty_str =
       String::Handle(String::EscapeSpecialCharacters(empty_str));
   EXPECT_EQ(empty_str.Length(), 0);
   EXPECT_EQ(escaped_empty_str.Length(), 0);
 }
 
 
-TEST_CASE(EscapeSpecialCharactersExternalTwoByteString) {
+VM_TEST_CASE(EscapeSpecialCharactersExternalTwoByteString) {
   uint16_t characters[] =
       { 'a', '\n', '\f', '\b', '\t', '\v', '\r', '\\', '$', 'z' };
   intptr_t len = ARRAY_SIZE(characters);
 
   const String& str =
       String::Handle(
           ExternalTwoByteString::New(characters, len, NULL, NULL, Heap::kNew));
   EXPECT(str.IsExternalTwoByteString());
   EXPECT_EQ(str.Length(), len);
   EXPECT(str.Equals("a\n\f\b\t\v\r\\$z"));
   const String& escaped_str =
       String::Handle(String::EscapeSpecialCharacters(str));
   EXPECT(escaped_str.Equals("a\\n\\f\\b\\t\\v\\r\\\\\\$z"));
 
   const String& empty_str =
       String::Handle(
           ExternalTwoByteString::New(characters, 0, NULL, NULL, Heap::kNew));
   const String& escaped_empty_str =
       String::Handle(String::EscapeSpecialCharacters(empty_str));
   EXPECT_EQ(empty_str.Length(), 0);
   EXPECT_EQ(escaped_empty_str.Length(), 0);
 }
 
 
-TEST_CASE(ExternalTwoByteString) {
+VM_TEST_CASE(ExternalTwoByteString) {
   uint16_t characters[] = { 0x1E6B, 0x1E85, 0x1E53 };
   intptr_t len = ARRAY_SIZE(characters);
 
   const String& str =
       String::Handle(
           ExternalTwoByteString::New(characters, len, NULL, NULL, Heap::kNew));
   EXPECT(!str.IsTwoByteString());
   EXPECT(str.IsExternalTwoByteString());
   EXPECT_EQ(str.Length(), len);
   EXPECT(str.Equals("\xE1\xB9\xAB\xE1\xBA\x85\xE1\xB9\x93"));
@@ skipping 12 matching lines @@
                        "\xE1\xB9\xAB\xE1\xBA\x85\xE1\xB9\x93"));
 
   const String& substr = String::Handle(String::SubString(str, 1, 1));
   EXPECT(!substr.IsExternalTwoByteString());
   EXPECT(substr.IsTwoByteString());
   EXPECT_EQ(1, substr.Length());
   EXPECT(substr.Equals("\xE1\xBA\x85"));
 }
 
 
-TEST_CASE(Symbol) {
+VM_TEST_CASE(Symbol) {
   const String& one = String::Handle(Symbols::New("Eins"));
   EXPECT(one.IsSymbol());
   const String& two = String::Handle(Symbols::New("Zwei"));
   const String& three = String::Handle(Symbols::New("Drei"));
   const String& four = String::Handle(Symbols::New("Vier"));
   const String& five = String::Handle(Symbols::New("Fuenf"));
   const String& six = String::Handle(Symbols::New("Sechs"));
   const String& seven = String::Handle(Symbols::New("Sieben"));
   const String& eight = String::Handle(Symbols::New("Acht"));
   const String& nine = String::Handle(Symbols::New("Neun"));
@@ skipping 41 matching lines @@
   String& elf1 = String::Handle(Symbols::FromUTF16(char16, 3));
   int32_t char32[] = { 'E', 'l', 'f' };
   String& elf2 = String::Handle(Symbols::FromUTF32(char32, 3));
   EXPECT(elf1.IsSymbol());
   EXPECT(elf2.IsSymbol());
   EXPECT_EQ(elf1.raw(), Symbols::New("Elf"));
   EXPECT_EQ(elf2.raw(), Symbols::New("Elf"));
 }
 
 
-TEST_CASE(SymbolUnicode) {
+VM_TEST_CASE(SymbolUnicode) {
   uint16_t monkey_utf16[] = { 0xd83d, 0xdc35 };  // Unicode Monkey Face.
   String& monkey = String::Handle(Symbols::FromUTF16(monkey_utf16, 2));
   EXPECT(monkey.IsSymbol());
   const char monkey_utf8[] = {'\xf0', '\x9f', '\x90', '\xb5', 0};
   EXPECT_EQ(monkey.raw(), Symbols::New(monkey_utf8));
 
   int32_t kMonkeyFace = 0x1f435;
   String& monkey2 = String::Handle(Symbols::FromCharCode(kMonkeyFace));
   EXPECT_EQ(monkey.raw(), monkey2.raw());
 
   // Unicode cat face with tears of joy.
   int32_t kCatFaceWithTearsOfJoy = 0x1f639;
   String& cat = String::Handle(Symbols::FromCharCode(kCatFaceWithTearsOfJoy));
 
   uint16_t cat_utf16[] = { 0xd83d, 0xde39 };
   String& cat2 = String::Handle(Symbols::FromUTF16(cat_utf16, 2));
   EXPECT(cat2.IsSymbol());
   EXPECT_EQ(cat2.raw(), cat.raw());
 }
 
 
-TEST_CASE(Bool) {
+VM_TEST_CASE(Bool) {
   EXPECT(Bool::True().value());
   EXPECT(!Bool::False().value());
 }
 
 
-TEST_CASE(Array) {
+VM_TEST_CASE(Array) {
   const int kArrayLen = 5;
   const Array& array = Array::Handle(Array::New(kArrayLen));
   EXPECT_EQ(kArrayLen, array.Length());
   Object& element = Object::Handle(array.At(0));
   EXPECT(element.IsNull());
   element = array.At(kArrayLen - 1);
   EXPECT(element.IsNull());
   array.SetAt(0, array);
   array.SetAt(2, array);
   element = array.At(0);
@@ skipping 126 matching lines @@
   if (Dart_IsError(result)) {
     EXPECT_ERROR(result, "Out of Memory");
   } else {
     intptr_t actual = 0;
     EXPECT_VALID(Dart_ListLength(result, &actual));
     EXPECT_EQ(max_elements, actual);
   }
 }
 
 
-TEST_CASE(StringCodePointIterator) {
+VM_TEST_CASE(StringCodePointIterator) {
   const String& str0 = String::Handle(String::New(""));
   String::CodePointIterator it0(str0);
   EXPECT(!it0.Next());
 
   const String& str1 = String::Handle(String::New(" \xc3\xa7 "));
   String::CodePointIterator it1(str1);
   EXPECT(it1.Next());
   EXPECT_EQ(' ', it1.Current());
   EXPECT(it1.Next());
   EXPECT_EQ(0xE7, it1.Current());
@@ skipping 34 matching lines @@
   EXPECT(it3.Next());
   EXPECT_EQ(0x1D461, it3.Current());
   EXPECT(it3.Next());
   EXPECT_EQ(0x1D462, it3.Current());
   EXPECT(it3.Next());
   EXPECT_EQ(0x1D463, it3.Current());
   EXPECT(!it3.Next());
 }
 
 
-TEST_CASE(StringCodePointIteratorRange) {
+VM_TEST_CASE(StringCodePointIteratorRange) {
   const String& str = String::Handle(String::New("foo bar baz"));
 
   String::CodePointIterator it0(str, 3, 0);
   EXPECT(!it0.Next());
 
   String::CodePointIterator it1(str, 4, 3);
   EXPECT(it1.Next());
   EXPECT_EQ('b', it1.Current());
   EXPECT(it1.Next());
   EXPECT_EQ('a', it1.Current());
   EXPECT(it1.Next());
   EXPECT_EQ('r', it1.Current());
   EXPECT(!it1.Next());
 }
 
 
-TEST_CASE(GrowableObjectArray) {
+VM_TEST_CASE(GrowableObjectArray) {
   const int kArrayLen = 5;
   Smi& value = Smi::Handle();
   Smi& expected_value = Smi::Handle();
   GrowableObjectArray& array = GrowableObjectArray::Handle();
 
   // Test basic growing functionality.
   array = GrowableObjectArray::New(kArrayLen);
   EXPECT_EQ(kArrayLen, array.Capacity());
   EXPECT_EQ(0, array.Length());
   for (intptr_t i = 0; i < 10; i++) {
@@ skipping 101 matching lines @@
   new_array = Array::MakeArray(array);
   EXPECT_EQ(1, new_array.Length());
   heap->CollectAllGarbage();
   intptr_t capacity_after = heap->CapacityInWords(Heap::kOld);
   // Page should shrink.
   EXPECT_LT(capacity_after, capacity_before);
   EXPECT_EQ(1, new_array.Length());
 }
 
 
-TEST_CASE(InternalTypedData) {
+VM_TEST_CASE(InternalTypedData) {
   uint8_t data[] = { 253, 254, 255, 0, 1, 2, 3, 4 };
   intptr_t data_length = ARRAY_SIZE(data);
 
   const TypedData& int8_array =
       TypedData::Handle(TypedData::New(kTypedDataInt8ArrayCid, data_length));
   EXPECT(!int8_array.IsNull());
   EXPECT_EQ(data_length, int8_array.Length());
   for (intptr_t i = 0; i < data_length; ++i) {
     int8_array.SetInt8(i, data[i]);
   }
@@ skipping 35 matching lines @@
   }
   for (intptr_t i = 0; i < data_length; ++i) {
     int8_array.SetInt8(i, 123 + i);
   }
   for (intptr_t i = 0; i < data_length; ++i) {
     EXPECT(int8_array.GetInt8(i) != int8_array2.GetInt8(i));
   }
 }
 
 
-TEST_CASE(ExternalTypedData) {
+VM_TEST_CASE(ExternalTypedData) {
   uint8_t data[] = { 253, 254, 255, 0, 1, 2, 3, 4 };
   intptr_t data_length = ARRAY_SIZE(data);
 
   const ExternalTypedData& int8_array =
       ExternalTypedData::Handle(
           ExternalTypedData::New(kExternalTypedDataInt8ArrayCid,
                                  data,
                                  data_length));
   EXPECT(!int8_array.IsNull());
   EXPECT_EQ(data_length, int8_array.Length());
@@ skipping 80 matching lines @@
   Dart_Handle h_lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(h_lib);
   Library& lib = Library::Handle();
   lib ^= Api::UnwrapHandle(h_lib);
   EXPECT(!lib.IsNull());
   Dart_Handle result = Dart_Invoke(h_lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 }
 
 
-TEST_CASE(EmbeddedScript) {
+VM_TEST_CASE(EmbeddedScript) {
   const char* url_chars = "builtin:test-case";
   const char* text =
       /* 1 */ "<!DOCTYPE html>\n"
       /* 2 */ "  ... more junk ...\n"
       /* 3 */ "  <script type='application/dart'>main() {\n"
       /* 4 */ "    return 'foo';\n"
       /* 5 */ "  }\n"
       /* 6 */ "</script>\n";
   const char* line1 = text;
   const char* line2 = strstr(line1, "\n") + 1;
@@ skipping 74 matching lines @@
   EXPECT_EQ(3, last_idx);
   script.TokenRangeAtLine(6, &first_idx, &last_idx);
   EXPECT_EQ(-1, first_idx);
   EXPECT_EQ(-1, last_idx);
   script.TokenRangeAtLine(1000, &first_idx, &last_idx);
   EXPECT_EQ(-1, first_idx);
   EXPECT_EQ(-1, last_idx);
 }
 
 
-TEST_CASE(Context) {
+VM_TEST_CASE(Context) {
   const int kNumVariables = 5;
   const Context& parent_context = Context::Handle(Context::New(0));
   const Context& context = Context::Handle(Context::New(kNumVariables));
   context.set_parent(parent_context);
   EXPECT_EQ(kNumVariables, context.num_variables());
   EXPECT(Context::Handle(context.parent()).raw() == parent_context.raw());
   EXPECT_EQ(0, Context::Handle(context.parent()).num_variables());
   EXPECT(Context::Handle(Context::Handle(context.parent()).parent()).IsNull());
   Object& variable = Object::Handle(context.At(0));
   EXPECT(variable.IsNull());
   variable = context.At(kNumVariables - 1);
   EXPECT(variable.IsNull());
   context.SetAt(0, Smi::Handle(Smi::New(2)));
   context.SetAt(2, Smi::Handle(Smi::New(3)));
   Smi& smi = Smi::Handle();
   smi ^= context.At(0);
   EXPECT_EQ(2, smi.Value());
   smi ^= context.At(2);
   EXPECT_EQ(3, smi.Value());
 }
 
 
-TEST_CASE(ContextScope) {
+VM_TEST_CASE(ContextScope) {
   const intptr_t parent_scope_function_level = 0;
   LocalScope* parent_scope =
       new LocalScope(NULL, parent_scope_function_level, 0);
 
   const intptr_t local_scope_function_level = 1;
   LocalScope* local_scope =
       new LocalScope(parent_scope, local_scope_function_level, 0);
 
   const Type& dynamic_type = Type::ZoneHandle(Type::DynamicType());
   const String& a = String::ZoneHandle(Symbols::New("a"));
@@ skipping 66 matching lines @@
   EXPECT(outer_scope->LocalLookupVariable(b) == NULL);
 
   var_c = outer_scope->LocalLookupVariable(c);
   EXPECT(var_c->is_captured());
   EXPECT_EQ(1, var_c->index());
   EXPECT_EQ(parent_scope_context_level - local_scope_context_level,
             var_c->owner()->context_level());  // Adjusted context level.
 }
 
 
-TEST_CASE(Closure) {
+VM_TEST_CASE(Closure) {
   // Allocate the class first.
   const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
   const Array& functions = Array::Handle(Array::New(1));
 
   const Context& context = Context::Handle(Context::New(0));
   Function& parent = Function::Handle();
   const String& parent_name = String::Handle(Symbols::New("foo_papa"));
   parent = Function::New(parent_name, RawFunction::kRegularFunction,
@@ skipping 12 matching lines @@
   EXPECT(closure_class.IsCanonicalSignatureClass());
   EXPECT_EQ(closure_class.raw(), signature_class.raw());
   const Function& signature_function =
     Function::Handle(signature_class.signature_function());
   EXPECT_EQ(signature_function.raw(), function.raw());
   const Context& closure_context = Context::Handle(Closure::context(closure));
   EXPECT_EQ(closure_context.raw(), closure_context.raw());
 }
 
 
-TEST_CASE(ObjectPrinting) {
+VM_TEST_CASE(ObjectPrinting) {
   // Simple Smis.
   EXPECT_STREQ("2", Smi::Handle(Smi::New(2)).ToCString());
   EXPECT_STREQ("-15", Smi::Handle(Smi::New(-15)).ToCString());
 
   // bool class and true/false values.
   ObjectStore* object_store = Isolate::Current()->object_store();
   const Class& bool_class = Class::Handle(object_store->bool_class());
   EXPECT_STREQ("Library:'dart:core' Class: bool",
                bool_class.ToCString());
   EXPECT_STREQ("true", Bool::True().ToCString());
   EXPECT_STREQ("false", Bool::False().ToCString());
 
   // Strings.
   EXPECT_STREQ("Sugarbowl",
                String::Handle(String::New("Sugarbowl")).ToCString());
 }
 
 
-TEST_CASE(CheckedHandle) {
+VM_TEST_CASE(CheckedHandle) {
   // Ensure that null handles have the correct C++ vtable setup.
   const String& str1 = String::Handle();
   EXPECT(str1.IsString());
   EXPECT(str1.IsNull());
   const String& str2 = String::CheckedHandle(Object::null());
   EXPECT(str2.IsString());
   EXPECT(str2.IsNull());
   String& str3 = String::Handle();
   str3 ^= Object::null();
   EXPECT(str3.IsString());
@@ skipping 17 matching lines @@
   const Library& owner_library =
       Library::Handle(CreateDummyLibrary(lib_name));
   owner_class.set_library(owner_library);
   const String& function_name = String::ZoneHandle(Symbols::New(name));
   return Function::New(function_name, RawFunction::kRegularFunction,
                        true, false, false, false, false, owner_class, 0);
 }
 
 
 // Test for Code and Instruction object creation.
-TEST_CASE(Code) {
+VM_TEST_CASE(Code) {
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
   const Function& function = Function::Handle(CreateFunction("Test_Code"));
   Code& code = Code::Handle(Code::FinalizeCode(function, &_assembler_));
   function.AttachCode(code);
   const Instructions& instructions = Instructions::Handle(code.instructions());
   uword entry_point = instructions.EntryPoint();
   EXPECT_EQ(instructions.raw(), Instructions::FromEntryPoint(entry_point));
   const Object& result = Object::Handle(
       DartEntry::InvokeFunction(function, Array::empty_array()));
   EXPECT_EQ(1, Smi::Cast(result).Value());
 }
 
 
 // Test for immutability of generated instructions. The test crashes with a
 // segmentation fault when writing into it.
-TEST_CASE(CodeImmutability) {
+VM_TEST_CASE(CodeImmutability) {
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
   const Function& function = Function::Handle(CreateFunction("Test_Code"));
   Code& code = Code::Handle(Code::FinalizeCode(function, &_assembler_));
   function.AttachCode(code);
   Instructions& instructions = Instructions::Handle(code.instructions());
   uword entry_point = instructions.EntryPoint();
   EXPECT_EQ(instructions.raw(), Instructions::FromEntryPoint(entry_point));
   // Try writing into the generated code, expected to crash.
   *(reinterpret_cast<char*>(entry_point) + 1) = 1;
   if (!FLAG_write_protect_code) {
     // Since this test is expected to crash, crash if write protection of code
     // is switched off.
     // TODO(regis, fschneider): Should this be FATAL() instead?
     OS::DebugBreak();
   }
 }
 
 
 // Test for Embedded String object in the instructions.
-TEST_CASE(EmbedStringInCode) {
+VM_TEST_CASE(EmbedStringInCode) {
   extern void GenerateEmbedStringInCode(Assembler* assembler, const char* str);
   const char* kHello = "Hello World!";
   word expected_length = static_cast<word>(strlen(kHello));
   Assembler _assembler_;
   GenerateEmbedStringInCode(&_assembler_, kHello);
   const Function& function =
       Function::Handle(CreateFunction("Test_EmbedStringInCode"));
   const Code& code = Code::Handle(Code::FinalizeCode(function, &_assembler_));
   function.AttachCode(code);
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(function, Array::empty_array()));
   EXPECT(result.raw()->IsHeapObject());
   String& string_object = String::Handle();
   string_object ^= result.raw();
   EXPECT(string_object.Length() == expected_length);
   for (int i = 0; i < expected_length; i ++) {
     EXPECT(string_object.CharAt(i) == kHello[i]);
   }
 }
 
 
 // Test for Embedded Smi object in the instructions.
-TEST_CASE(EmbedSmiInCode) {
+VM_TEST_CASE(EmbedSmiInCode) {
   extern void GenerateEmbedSmiInCode(Assembler* assembler, intptr_t value);
   const intptr_t kSmiTestValue = 5;
   Assembler _assembler_;
   GenerateEmbedSmiInCode(&_assembler_, kSmiTestValue);
   const Function& function =
       Function::Handle(CreateFunction("Test_EmbedSmiInCode"));
   const Code& code = Code::Handle(Code::FinalizeCode(function, &_assembler_));
   function.AttachCode(code);
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(function, Array::empty_array()));
   EXPECT(Smi::Cast(result).Value() == kSmiTestValue);
 }
 
 
 #if defined(ARCH_IS_64_BIT)
 // Test for Embedded Smi object in the instructions.
-TEST_CASE(EmbedSmiIn64BitCode) {
+VM_TEST_CASE(EmbedSmiIn64BitCode) {
   extern void GenerateEmbedSmiInCode(Assembler* assembler, intptr_t value);
   const intptr_t kSmiTestValue = DART_INT64_C(5) << 32;
   Assembler _assembler_;
   GenerateEmbedSmiInCode(&_assembler_, kSmiTestValue);
   const Function& function =
       Function::Handle(CreateFunction("Test_EmbedSmiIn64BitCode"));
   const Code& code = Code::Handle(Code::FinalizeCode(function, &_assembler_));
   function.AttachCode(code);
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(function, Array::empty_array()));
   EXPECT(Smi::Cast(result).Value() == kSmiTestValue);
 }
 #endif  // ARCH_IS_64_BIT
 
 
-TEST_CASE(ExceptionHandlers) {
+VM_TEST_CASE(ExceptionHandlers) {
   const int kNumEntries = 4;
   // Add an exception handler table to the code.
   ExceptionHandlers& exception_handlers = ExceptionHandlers::Handle();
   exception_handlers ^= ExceptionHandlers::New(kNumEntries);
   const bool kNeedsStacktrace = true;
   const bool kNoStacktrace = false;
   exception_handlers.SetHandlerInfo(0, -1, 20u, kNeedsStacktrace, false);
   exception_handlers.SetHandlerInfo(1, 0, 30u, kNeedsStacktrace, false);
   exception_handlers.SetHandlerInfo(2, -1, 40u, kNoStacktrace, true);
   exception_handlers.SetHandlerInfo(3, 1, 150u, kNoStacktrace, true);
@@ skipping 17 matching lines @@
   EXPECT(handlers.NeedsStacktrace(0));
   EXPECT(!handlers.HasCatchAll(0));
   EXPECT_EQ(20u, info.handler_pc_offset);
   EXPECT_EQ(1, handlers.OuterTryIndex(3));
   EXPECT_EQ(150u, handlers.HandlerPCOffset(3));
   EXPECT(!handlers.NeedsStacktrace(3));
   EXPECT(handlers.HasCatchAll(3));
 }
 
 
-TEST_CASE(PcDescriptors) {
+VM_TEST_CASE(PcDescriptors) {
   DescriptorList* builder = new DescriptorList(0);
 
   // kind, pc_offset, deopt_id, token_pos, try_index
   builder->AddDescriptor(RawPcDescriptors::kOther, 10, 1, 20, 1);
   builder->AddDescriptor(RawPcDescriptors::kDeopt, 20, 2, 30, 0);
   builder->AddDescriptor(RawPcDescriptors::kOther, 30, 3, 40, 1);
   builder->AddDescriptor(RawPcDescriptors::kOther, 10, 4, 40, 2);
   builder->AddDescriptor(RawPcDescriptors::kOther, 10, 5, 80, 3);
   builder->AddDescriptor(RawPcDescriptors::kOther, 80, 6, 150, 3);
 
@@ skipping 36 matching lines @@
 
   EXPECT_EQ(3, iter.TryIndex());
   EXPECT_EQ(static_cast<uword>(80), iter.PcOffset());
   EXPECT_EQ(150, iter.TokenPos());
   EXPECT_EQ(RawPcDescriptors::kOther, iter.Kind());
 
   EXPECT_EQ(false, iter.MoveNext());
 }
 
 
-TEST_CASE(PcDescriptorsLargeDeltas) {
+VM_TEST_CASE(PcDescriptorsLargeDeltas) {
   DescriptorList* builder = new DescriptorList(0);
 
   // kind, pc_offset, deopt_id, token_pos, try_index
   builder->AddDescriptor(RawPcDescriptors::kOther, 100, 1, 200, 1);
   builder->AddDescriptor(RawPcDescriptors::kDeopt, 200, 2, 300, 0);
   builder->AddDescriptor(RawPcDescriptors::kOther, 300, 3, 400, 1);
   builder->AddDescriptor(RawPcDescriptors::kOther, 100, 4, 0, 2);
   builder->AddDescriptor(RawPcDescriptors::kOther, 100, 5, 800, 3);
   builder->AddDescriptor(RawPcDescriptors::kOther, 800, 6, 150, 3);
 
@@ skipping 54 matching lines @@
 static RawField* CreateTestField(const char* name) {
   const Class& cls = Class::Handle(CreateTestClass("global:"));
   const String& field_name = String::Handle(Symbols::New(name));
   const Field& field =
       Field::Handle(Field::New(field_name, true, false, false, true, cls,
           Object::dynamic_type(), 0));
   return field.raw();
 }
 
 
-TEST_CASE(ClassDictionaryIterator) {
+VM_TEST_CASE(ClassDictionaryIterator) {
   Class& ae66 = Class::ZoneHandle(CreateTestClass("Ae6/6"));
   Class& re44 = Class::ZoneHandle(CreateTestClass("Re4/4"));
   Field& ce68 = Field::ZoneHandle(CreateTestField("Ce6/8"));
   Field& tee = Field::ZoneHandle(CreateTestField("TEE"));
   String& url = String::ZoneHandle(String::New("SBB"));
   Library& lib = Library::Handle(Library::New(url));
   lib.AddClass(ae66);
   lib.AddObject(ce68, String::ZoneHandle(ce68.name()));
   lib.AddClass(re44);
   lib.AddObject(tee, String::ZoneHandle(tee.name()));
@@ skipping 23 matching lines @@
                        is_static,
                        is_const,
                        is_abstract,
                        is_external,
                        is_native,
                        cls,
                        0);
 }
 
 
-TEST_CASE(ICData) {
+VM_TEST_CASE(ICData) {
   Function& function = Function::Handle(GetDummyTarget("Bern"));
   const intptr_t id = 12;
   const intptr_t num_args_tested = 1;
   const String& target_name = String::Handle(Symbols::New("Thun"));
   const Array& args_descriptor =
       Array::Handle(ArgumentsDescriptor::New(1, Object::null_array()));
   ICData& o1 = ICData::Handle();
   o1 = ICData::New(function, target_name, args_descriptor, id, num_args_tested);
   EXPECT_EQ(1, o1.NumArgsTested());
   EXPECT_EQ(id, o1.deopt_id());
@@ skipping 51 matching lines @@
 
   // Check ICData for unoptimized static calls.
   const intptr_t kNumArgsChecked = 0;
   const ICData& scall_icdata = ICData::Handle(
       ICData::New(function, target_name, args_descriptor, 57, kNumArgsChecked));
   scall_icdata.AddTarget(target1);
   EXPECT_EQ(target1.raw(), scall_icdata.GetTargetAt(0));
 }
 
 
-TEST_CASE(SubtypeTestCache) {
+VM_TEST_CASE(SubtypeTestCache) {
   String& class_name = String::Handle(Symbols::New("EmptyClass"));
   Script& script = Script::Handle();
   const Class& empty_class =
       Class::Handle(CreateDummyClass(class_name, script));
   SubtypeTestCache& cache = SubtypeTestCache::Handle(SubtypeTestCache::New());
   EXPECT(!cache.IsNull());
   EXPECT_EQ(0, cache.NumberOfChecks());
   const TypeArguments& targ_0 = TypeArguments::Handle(TypeArguments::New(2));
   const TypeArguments& targ_1 = TypeArguments::Handle(TypeArguments::New(3));
   cache.AddCheck(empty_class.id(), targ_0, targ_1, Bool::True());
   EXPECT_EQ(1, cache.NumberOfChecks());
   intptr_t test_class_id = -1;
   TypeArguments& test_targ_0 = TypeArguments::Handle();
   TypeArguments& test_targ_1 = TypeArguments::Handle();
   Bool& test_result = Bool::Handle();
   cache.GetCheck(0, &test_class_id, &test_targ_0, &test_targ_1, &test_result);
   EXPECT_EQ(empty_class.id(), test_class_id);
   EXPECT_EQ(targ_0.raw(), test_targ_0.raw());
   EXPECT_EQ(targ_1.raw(), test_targ_1.raw());
   EXPECT_EQ(Bool::True().raw(), test_result.raw());
 }
 
 
-TEST_CASE(FieldTests) {
+VM_TEST_CASE(FieldTests) {
   const String& f = String::Handle(String::New("oneField"));
   const String& getter_f = String::Handle(Field::GetterName(f));
   const String& setter_f = String::Handle(Field::SetterName(f));
   EXPECT(!Field::IsGetterName(f));
   EXPECT(!Field::IsSetterName(f));
   EXPECT(Field::IsGetterName(getter_f));
   EXPECT(!Field::IsSetterName(getter_f));
   EXPECT(!Field::IsGetterName(setter_f));
   EXPECT(Field::IsSetterName(setter_f));
   EXPECT_STREQ(f.ToCString(),
                String::Handle(Field::NameFromGetter(getter_f)).ToCString());
   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) {
+VM_TEST_CASE(EqualsIgnoringPrivate) {
   String& mangled_name = String::Handle();
   String& bare_name = String::Handle();
 
   // Simple matches.
   mangled_name = OneByteString::New("foo");
   bare_name = OneByteString::New("foo");
   EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
 
   mangled_name = OneByteString::New("foo.");
   bare_name = OneByteString::New("foo.");
@@ skipping 112 matching lines @@
   // str1 - ExternalOneByteString, str2 - OneByteString.
   EXPECT(String::EqualsIgnoringPrivateKey(ext_mangled_name, bare_name));
 
   // str1 - ExternalOneByteString, str2 - ExternalOneByteString.
   EXPECT(String::EqualsIgnoringPrivateKey(ext_mangled_name, ext_bare_name));
   EXPECT(!String::EqualsIgnoringPrivateKey(ext_mangled_name,
                                            ext_bad_bare_name));
 }
 
 
-TEST_CASE(ArrayNew_Overflow_Crash) {
+VM_TEST_CASE(ArrayNew_Overflow_Crash) {
   Array::Handle(Array::New(Array::kMaxElements + 1));
 }
 
 
 TEST_CASE(StackTraceFormat) {
   const char* kScriptChars =
       "void baz() {\n"
       "  throw 'MyException';\n"
       "}\n"
       "\n"
@@ skipping 45 matching lines @@
       "#4      MyClass.field (test-lib:25:5)\n"
       "#5      MyClass.foo.fooHelper (test-lib:30:7)\n"
       "#6      MyClass.foo (test-lib:32:14)\n"
       "#7      MyClass.MyClass.<anonymous closure> (test-lib:21:12)\n"
       "#8      MyClass.MyClass (test-lib:21:18)\n"
       "#9      main.<anonymous closure> (test-lib:37:14)\n"
       "#10     main (test-lib:37:24)");
 }
 
 
-TEST_CASE(WeakProperty_PreserveCrossGen) {
+VM_TEST_CASE(WeakProperty_PreserveCrossGen) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak = WeakProperty::Handle();
   {
     // Weak property and value in new. Key in old.
     HANDLESCOPE(thread);
     String& key = String::Handle();
     key ^= OneByteString::New("key", Heap::kOld);
     String& value = String::Handle();
     value ^= OneByteString::New("value", Heap::kNew);
     weak ^= WeakProperty::New(Heap::kNew);
@@ skipping 91 matching lines @@
     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) {
+VM_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(thread);
     String& key = String::Handle();
     key ^= OneByteString::New("key");
     arr.SetAt(0, key);
     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) {
+VM_TEST_CASE(WeakProperty_PreserveOne_NewSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak = WeakProperty::Handle();
   String& key = String::Handle();
   key ^= OneByteString::New("key");
   {
     HANDLESCOPE(thread);
     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) {
+VM_TEST_CASE(WeakProperty_PreserveTwo_NewSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak1 = WeakProperty::Handle();
   String& key1 = String::Handle();
   key1 ^= OneByteString::New("key1");
   WeakProperty& weak2 = WeakProperty::Handle();
   String& key2 = String::Handle();
   key2 ^= OneByteString::New("key2");
   {
     HANDLESCOPE(thread);
     String& value1 = String::Handle();
     value1 ^= OneByteString::New("value1");
     weak1 ^= WeakProperty::New();
     weak1.set_key(key1);
     weak1.set_value(value1);
     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) {
+VM_TEST_CASE(WeakProperty_PreserveTwoShared_NewSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak1 = WeakProperty::Handle();
   WeakProperty& weak2 = WeakProperty::Handle();
   String& key = String::Handle();
   key ^= OneByteString::New("key");
   {
     HANDLESCOPE(thread);
     String& value1 = String::Handle();
     value1 ^= OneByteString::New("value1");
     weak1 ^= WeakProperty::New();
     weak1.set_key(key);
     weak1.set_value(value1);
     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) {
+VM_TEST_CASE(WeakProperty_PreserveOne_OldSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak = WeakProperty::Handle();
   String& key = String::Handle();
   key ^= OneByteString::New("key", Heap::kOld);
   {
     HANDLESCOPE(thread);
     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) {
+VM_TEST_CASE(WeakProperty_PreserveTwo_OldSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak1 = WeakProperty::Handle();
   String& key1 = String::Handle();
   key1 ^= OneByteString::New("key1", Heap::kOld);
   WeakProperty& weak2 = WeakProperty::Handle();
   String& key2 = String::Handle();
   key2 ^= OneByteString::New("key2", Heap::kOld);
   {
     HANDLESCOPE(thread);
     String& value1 = String::Handle();
     value1 ^= OneByteString::New("value1", Heap::kOld);
     weak1 ^= WeakProperty::New(Heap::kOld);
     weak1.set_key(key1);
     weak1.set_value(value1);
     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) {
+VM_TEST_CASE(WeakProperty_PreserveTwoShared_OldSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak1 = WeakProperty::Handle();
   WeakProperty& weak2 = WeakProperty::Handle();
   String& key = String::Handle();
   key ^= OneByteString::New("key", Heap::kOld);
   {
     HANDLESCOPE(thread);
     String& value1 = String::Handle();
     value1 ^= OneByteString::New("value1", Heap::kOld);
     weak1 ^= WeakProperty::New(Heap::kOld);
     weak1.set_key(key);
     weak1.set_value(value1);
     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) {
+VM_TEST_CASE(WeakProperty_ClearOne_NewSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak = WeakProperty::Handle();
   {
     HANDLESCOPE(thread);
     String& key = String::Handle();
     key ^= OneByteString::New("key");
     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) {
+VM_TEST_CASE(WeakProperty_ClearTwoShared_NewSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak1 = WeakProperty::Handle();
   WeakProperty& weak2 = WeakProperty::Handle();
   {
     HANDLESCOPE(thread);
     String& key = String::Handle();
     key ^= OneByteString::New("key");
     String& value1 = String::Handle();
     value1 ^= OneByteString::New("value1");
     weak1 ^= WeakProperty::New();
     weak1.set_key(key);
     weak1.set_value(value1);
     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) {
+VM_TEST_CASE(WeakProperty_ClearOne_OldSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak = WeakProperty::Handle();
   {
     HANDLESCOPE(thread);
     String& key = String::Handle();
     key ^= OneByteString::New("key", Heap::kOld);
     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) {
+VM_TEST_CASE(WeakProperty_ClearTwoShared_OldSpace) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak1 = WeakProperty::Handle();
   WeakProperty& weak2 = WeakProperty::Handle();
   {
     HANDLESCOPE(thread);
     String& key = String::Handle();
     key ^= OneByteString::New("key", Heap::kOld);
     String& value1 = String::Handle();
     value1 ^= OneByteString::New("value1");
     weak1 ^= WeakProperty::New(Heap::kOld);
     weak1.set_key(key);
     weak1.set_value(value1);
     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(MirrorReference) {
+VM_TEST_CASE(MirrorReference) {
   const MirrorReference& reference =
       MirrorReference::Handle(MirrorReference::New(Object::Handle()));
   Object& initial_referent = Object::Handle(reference.referent());
   EXPECT(initial_referent.IsNull());
 
   Library& library = Library::Handle(Library::CoreLibrary());
   EXPECT(!library.IsNull());
   EXPECT(library.IsLibrary());
   reference.set_referent(library);
   const Object& returned_referent = Object::Handle(reference.referent());
@@ skipping 37 matching lines @@
 
 
 static RawClass* GetClass(const Library& lib, const char* name) {
   const Class& cls = Class::Handle(
       lib.LookupClass(String::Handle(Symbols::New(name))));
   EXPECT(!cls.IsNull());  // No ambiguity error expected.
   return cls.raw();
 }
 
 
-TEST_CASE(FindClosureIndex) {
+VM_TEST_CASE(FindClosureIndex) {
   // Allocate the class first.
   const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
   const Array& functions = Array::Handle(Array::New(1));
   const Isolate* iso = Isolate::Current();
 
   Function& parent = Function::Handle();
   const String& parent_name = String::Handle(Symbols::New("foo_papa"));
   parent = Function::New(parent_name, RawFunction::kRegularFunction,
@@ skipping 15 matching lines @@
   EXPECT_EQ(bad_closure_index, -1);
 
   // Retrieve closure function via index.
   Function& func_from_index = Function::Handle();
   func_from_index ^= iso->ClosureFunctionFromIndex(good_closure_index);
   // Same closure function.
   EXPECT_EQ(func_from_index.raw(), function.raw());
 }
 
 
-TEST_CASE(FindInvocationDispatcherFunctionIndex) {
+VM_TEST_CASE(FindInvocationDispatcherFunctionIndex) {
   const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
   ClassFinalizer::FinalizeTypesInClass(cls);
 
   const Array& functions = Array::Handle(Array::New(1));
   Function& parent = Function::Handle();
   const String& parent_name = String::Handle(Symbols::New("foo_papa"));
   parent = Function::New(parent_name, RawFunction::kRegularFunction,
                          false, false, false, false, false, cls, 0);
@@ skipping 230 matching lines @@
 
   // After setting a breakpoint in a function A.b, it is no longer inlineable.
   Breakpoint* bpt =
       Isolate::Current()->debugger()->SetBreakpointAtLine(name,
                                                           kBreakpointLine);
   ASSERT(bpt != NULL);
   EXPECT(!func_b.CanBeInlined());
 }
 
 
-TEST_CASE(SpecialClassesHaveEmptyArrays) {
+VM_TEST_CASE(SpecialClassesHaveEmptyArrays) {
   ObjectStore* object_store = Isolate::Current()->object_store();
   Class& cls = Class::Handle();
   Object& array = Object::Handle();
 
   cls = object_store->null_class();
   array = cls.fields();
   EXPECT(!array.IsNull());
   EXPECT(array.IsArray());
   array = cls.functions();
   EXPECT(!array.IsNull());
@@ skipping 34 matching lines @@
         handle.IsLiteralToken()) {
       return;
     }
     objects_->Add(&handle);
   }
  private:
   GrowableArray<Object*>* objects_;
 };
 
 
-TEST_CASE(PrintJSON) {
+VM_TEST_CASE(PrintJSON) {
   Heap* heap = Isolate::Current()->heap();
   heap->CollectAllGarbage();
   GrowableArray<Object*> objects;
   ObjectAccumulator acc(&objects);
   heap->IterateObjects(&acc);
   for (intptr_t i = 0; i < objects.length(); ++i) {
     JSONStream js;
     objects[i]->PrintJSON(&js, false);
     EXPECT_SUBSTRING("\"type\":", js.ToCString());
   }
 }
 
 
-TEST_CASE(PrintJSONPrimitives) {
+VM_TEST_CASE(PrintJSONPrimitives) {
   char buffer[1024];
   Isolate* isolate = Isolate::Current();
 
   // Class reference
   {
     JSONStream js;
     Class& cls = Class::Handle(isolate->object_store()->bool_class());
     cls.PrintJSON(&js, true);
     ElideJSONSubstring("classes", js.ToCString(), buffer);
     EXPECT_STREQ(
@@ skipping 444 matching lines @@
   for (int i = 0; i < n; i++) {
     pieces.Add(*data[i]);
     array.SetAt(i, *data[i]);
   }
   const String& res1 = String::Handle(zone, Symbols::FromConcatAll(pieces));
   const String& res2 = String::Handle(zone, String::ConcatAll(array));
   EXPECT(res1.Equals(res2));
 }
 
 
-TEST_CASE(Symbols_FromConcatAll) {
+VM_TEST_CASE(Symbols_FromConcatAll) {
   {
     const String* data[3] = { &Symbols::FallThroughError(),
                               &Symbols::Dot(),
                               &Symbols::isPaused() };
     CheckConcatAll(data, 3);
   }
 
   {
     const intptr_t kWideCharsLen = 7;
     uint16_t wide_chars[kWideCharsLen] = { 'H', 'e', 'l', 'l', 'o', 256, '!' };
@@ skipping 51 matching lines @@
   }
 }
 
 
 struct TestResult {
   const char* in;
   const char* out;
 };
 
 
-TEST_CASE(String_IdentifierPrettyName) {
+VM_TEST_CASE(String_IdentifierPrettyName) {
   TestResult tests[] = {
     {"(dynamic, dynamic) => void", "(dynamic, dynamic) => void"},
     {"_List@915557746", "_List"},
     {"_HashMap@600006304<K, V>(dynamic) => V", "_HashMap<K, V>(dynamic) => V"},
     {"set:foo", "foo="},
     {"get:foo", "foo"},
     {"_ReceivePortImpl@709387912", "_ReceivePortImpl"},
     {"_ReceivePortImpl@709387912._internal@709387912",
         "_ReceivePortImpl._internal"},
     {"_C@6328321&_E@6328321&_F@6328321", "_C&_E&_F"},
     {"List.", "List"},
     {"get:foo@6328321", "foo"},
     {"_MyClass@6328321.", "_MyClass"},
     {"_MyClass@6328321.named", "_MyClass.named"},
   };
   String& test = String::Handle();
   String& result = String::Handle();
   for (size_t i = 0; i < ARRAY_SIZE(tests); i++) {
     test = String::New(tests[i].in);
     result = String::IdentifierPrettyName(test);
     EXPECT_STREQ(tests[i].out, result.ToCString());
   }
 }
 
 }  // namespace dart