clang-format runtime/vm

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 44 matching lines @@
 
   // Finalization of types happens before the fields and functions have been
   // parsed.
   ClassFinalizer::FinalizeTypesInClass(cls);
 
   // Create and populate the function arrays.
   const Array& functions = Array::Handle(Array::New(6));
   Function& function = Function::Handle();
   String& function_name = String::Handle();
   function_name = Symbols::New(thread, "foo");
-  function = Function::New(
-      function_name, RawFunction::kRegularFunction,
-      false, false, false, false, false, cls, TokenPosition::kMinSource);
+  function =
+      Function::New(function_name, RawFunction::kRegularFunction, false, false,
+                    false, false, false, cls, TokenPosition::kMinSource);
   functions.SetAt(0, function);
   function_name = Symbols::New(thread, "bar");
-  function = Function::New(
-      function_name, RawFunction::kRegularFunction,
-      false, false, false, false, false, cls, TokenPosition::kMinSource);
+  function =
+      Function::New(function_name, RawFunction::kRegularFunction, false, false,
+                    false, false, false, cls, TokenPosition::kMinSource);
 
   const int kNumFixedParameters = 2;
   const int kNumOptionalParameters = 3;
   const bool kAreOptionalPositional = true;
   function.set_num_fixed_parameters(kNumFixedParameters);
   function.SetNumOptionalParameters(kNumOptionalParameters,
                                     kAreOptionalPositional);
   functions.SetAt(1, function);
 
   function_name = Symbols::New(thread, "baz");
-  function = Function::New(
-      function_name, RawFunction::kRegularFunction,
-      false, false, false, false, false, cls, TokenPosition::kMinSource);
+  function =
+      Function::New(function_name, RawFunction::kRegularFunction, false, false,
+                    false, false, false, cls, TokenPosition::kMinSource);
   functions.SetAt(2, function);
 
   function_name = Symbols::New(thread, "Foo");
-  function = Function::New(
-      function_name, RawFunction::kRegularFunction,
-      true, false, false, false, false, cls, TokenPosition::kMinSource);
+  function =
+      Function::New(function_name, RawFunction::kRegularFunction, true, false,
+                    false, false, false, cls, TokenPosition::kMinSource);
 
   functions.SetAt(3, function);
   function_name = Symbols::New(thread, "Bar");
-  function = Function::New(
-      function_name, RawFunction::kRegularFunction,
-      true, false, false, false, false, cls, TokenPosition::kMinSource);
+  function =
+      Function::New(function_name, RawFunction::kRegularFunction, true, false,
+                    false, false, false, cls, TokenPosition::kMinSource);
   functions.SetAt(4, function);
   function_name = Symbols::New(thread, "BaZ");
-  function = Function::New(
-      function_name, RawFunction::kRegularFunction,
-      true, false, false, false, false, cls, TokenPosition::kMinSource);
+  function =
+      Function::New(function_name, RawFunction::kRegularFunction, true, false,
+                    false, false, false, cls, TokenPosition::kMinSource);
   functions.SetAt(5, function);
 
   // Setup the functions in the class.
   cls.SetFunctions(functions);
 
   // The class can now be finalized.
   cls.Finalize();
 
   function_name = String::New("Foo");
   function = cls.LookupDynamicFunction(function_name);
@@ skipping 22 matching lines @@
   function = cls.LookupDynamicFunction(function_name);
   EXPECT(!function.IsNull());
   EXPECT_EQ(kNumFixedParameters, function.num_fixed_parameters());
   EXPECT_EQ(kNumOptionalParameters, function.NumOptionalParameters());
 }
 
 
 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));
+  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));
+  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());
 }
 
 
 VM_TEST_CASE(TokenStream) {
   Zone* zone = Thread::Current()->zone();
   String& source = String::Handle(zone, String::New("= ( 9 , ."));
   String& private_key = String::Handle(zone, String::New(""));
-  const TokenStream& token_stream = TokenStream::Handle(
-      zone, TokenStream::New(source, private_key, false));
+  const TokenStream& token_stream =
+      TokenStream::Handle(zone, TokenStream::New(source, private_key, false));
   TokenStream::Iterator iterator(zone, token_stream, TokenPosition::kMinSource);
   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());
 }
 
 
 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 is! List) {\n"
-  "        for (int i = 0; i < x; i++) {\n"
-  "          fly();\n"
-  "          ++i;\n"
-  "        }\n"
-  "      } else {\n"
-  "        for (int i = 0; i < x; i--) {\n"
-  "          !fly();\n"
-  "          --i;\n"
-  "        }\n"
-  "      }\n"
-  "    } on Blah catch (a) {\n"
-  "      _print(17);\n"
-  "    } catch (e, s) {\n"
-  "      bar()\n"
-  "    }\n"
-  "  }\n"
-  "}\n";
+      "\n"
+      "class A {\n"
+      "  static bar() { return 42; }\n"
+      "  static fly() { return 5; }\n"
+      "  void catcher(x) {\n"
+      "    try {\n"
+      "      if (x is! List) {\n"
+      "        for (int i = 0; i < x; i++) {\n"
+      "          fly();\n"
+      "          ++i;\n"
+      "        }\n"
+      "      } else {\n"
+      "        for (int i = 0; i < x; i--) {\n"
+      "          !fly();\n"
+      "          --i;\n"
+      "        }\n"
+      "      }\n"
+      "    } on Blah catch (a) {\n"
+      "      _print(17);\n"
+      "    } catch (e, s) {\n"
+      "      bar()\n"
+      "    }\n"
+      "  }\n"
+      "}\n";
 
   String& url = String::Handle(String::New("dart-test:GenerateExactSource"));
   String& source = String::Handle(String::New(kScriptChars));
-  Script& script = Script::Handle(Script::New(url,
-                                              source,
-                                              RawScript::kScriptTag));
+  Script& script =
+      Script::Handle(Script::New(url, source, RawScript::kScriptTag));
   script.Tokenize(String::Handle(String::New("")));
   const TokenStream& tokens = TokenStream::Handle(script.tokens());
   const String& gen_source = String::Handle(tokens.GenerateSource());
   EXPECT_STREQ(source.ToCString(), gen_source.ToCString());
 }
 
 
 TEST_CASE(Class_ComputeEndTokenPos) {
   const char* kScript =
-  "\n"
-  "class A {\n"
-  "  /**\n"
-  "   * Description of foo().\n"
-  "   */\n"
-  "  foo(a) { return '''\"}'''; }\n"
-  "  // }\n"
-  "  var bar = '\\'}';\n"
-  "  var baz = \"${foo('}')}\";\n"
-  "}\n";
+      "\n"
+      "class A {\n"
+      "  /**\n"
+      "   * Description of foo().\n"
+      "   */\n"
+      "  foo(a) { return '''\"}'''; }\n"
+      "  // }\n"
+      "  var bar = '\\'}';\n"
+      "  var baz = \"${foo('}')}\";\n"
+      "}\n";
   Dart_Handle lib_h = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib_h);
   Library& lib = Library::Handle();
   lib ^= Api::UnwrapHandle(lib_h);
   EXPECT(!lib.IsNull());
-  const Class& cls = Class::Handle(
-      lib.LookupClass(String::Handle(String::New("A"))));
+  const Class& cls =
+      Class::Handle(lib.LookupClass(String::Handle(String::New("A"))));
   EXPECT(!cls.IsNull());
   const TokenPosition 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);
 }
 
 
@@ skipping 55 matching lines @@
   EXPECT(!smi_object.IsSmi());
 
   EXPECT(smi.Equals(Smi::Handle(Smi::New(5))));
   EXPECT(!smi.Equals(Smi::Handle(Smi::New(6))));
   EXPECT(smi.Equals(smi));
   EXPECT(!smi.Equals(Smi::Handle()));
 
   EXPECT(Smi::IsValid(0));
   EXPECT(Smi::IsValid(-15));
   EXPECT(Smi::IsValid(0xFFu));
-  // Upper two bits must be either 00 or 11.
+// Upper two bits must be either 00 or 11.
 #if defined(ARCH_IS_64_BIT)
   EXPECT(!Smi::IsValid(kMaxInt64));
   EXPECT(Smi::IsValid(0x3FFFFFFFFFFFFFFF));
   EXPECT(Smi::IsValid(-1));
 #else
   EXPECT(!Smi::IsValid(kMaxInt32));
   EXPECT(Smi::IsValid(0x3FFFFFFF));
   EXPECT(Smi::IsValid(-1));
   EXPECT(!Smi::IsValid(0xFFFFFFFFu));
 #endif
@@ skipping 11 matching lines @@
 
   Mint& mint1 = Mint::Handle();
   mint1 ^= Integer::New(DART_2PART_UINT64_C(0x7FFFFFFF, 100));
   Mint& mint2 = Mint::Handle();
   mint2 ^= Integer::New(-DART_2PART_UINT64_C(0x7FFFFFFF, 100));
   EXPECT_EQ(-1, a.CompareWith(mint1));
   EXPECT_EQ(1, a.CompareWith(mint2));
   EXPECT_EQ(-1, c.CompareWith(mint1));
   EXPECT_EQ(1, c.CompareWith(mint2));
 
-  Bigint& big1 = Bigint::Handle(Bigint::NewFromCString(
-      "10000000000000000000"));
-  Bigint& big2 = Bigint::Handle(Bigint::NewFromCString(
-      "-10000000000000000000"));
+  Bigint& big1 = Bigint::Handle(Bigint::NewFromCString("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));
 }
 
 
 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 uint8_t monkey_utf8[kMonkeyLen] = {0xf0, 0x9f, 0x90, 0xb5};
   const String& monkey_face =
       String::Handle(String::FromUTF8(monkey_utf8, kMonkeyLen));
   const int kDogLen = 4;
   // 0x1f436 DOG FACE.
-  const uint8_t dog_utf8[kDogLen] = { 0xf0, 0x9f, 0x90, 0xb6 };
-  const String& dog_face =
-      String::Handle(String::FromUTF8(dog_utf8, kDogLen));
+  const uint8_t dog_utf8[kDogLen] = {0xf0, 0x9f, 0x90, 0xb6};
+  const String& dog_face = String::Handle(String::FromUTF8(dog_utf8, kDogLen));
   EXPECT_EQ(0, monkey_face.CompareTo(monkey_face));
   EXPECT_EQ(0, dog_face.CompareTo(dog_face));
   EXPECT(monkey_face.CompareTo(dog_face) < 0);
   EXPECT(dog_face.CompareTo(monkey_face) > 0);
 
   const int kDominoLen = 4;
   // 0x1f036 DOMINO TILE HORIZONTAL-00-05.
-  const uint8_t domino_utf8[kDominoLen] = { 0xf0, 0x9f, 0x80, 0xb6 };
+  const uint8_t domino_utf8[kDominoLen] = {0xf0, 0x9f, 0x80, 0xb6};
   const String& domino =
       String::Handle(String::FromUTF8(domino_utf8, kDominoLen));
   EXPECT_EQ(0, domino.CompareTo(domino));
   EXPECT(domino.CompareTo(dog_face) < 0);
   EXPECT(domino.CompareTo(monkey_face) < 0);
   EXPECT(dog_face.CompareTo(domino) > 0);
   EXPECT(monkey_face.CompareTo(domino) > 0);
 
   EXPECT(abcd.CompareTo(monkey_face) < 0);
   EXPECT(abce.CompareTo(monkey_face) < 0);
@@ skipping 41 matching lines @@
   decoded = String::DecodeIRI(input);
   EXPECT(decoded.IsNull());
   input = String::New("file%3g");
   decoded = String::DecodeIRI(input);
   EXPECT(decoded.IsNull());
 }
 
 
 VM_TEST_CASE(StringIRITwoByte) {
   const intptr_t kInputLen = 3;
-  const uint16_t kInput[kInputLen] = { 'x', '/', 256 };
+  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 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::New(String::EncodeIRI(input)));
   EXPECT(output.Equals(encoded));
   const String& decoded = String::Handle(String::DecodeIRI(output));
   EXPECT(input.Equals(decoded));
 }
 
 
 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();
+  {
+    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"));
     const String& mint2_str = String::Handle(String::New("-2147419168"));
     Integer& i = Integer::Handle(Integer::NewCanonical(smi_str));
     EXPECT(i.IsSmi());
     i = Integer::NewCanonical(mint1_str);
@@ skipping 27 matching lines @@
 
   Mint& c = Mint::Handle();
   c ^= Integer::New(-DART_2PART_UINT64_C(3, 0));
   Smi& smi1 = Smi::Handle(Smi::New(4));
   Smi& smi2 = Smi::Handle(Smi::New(-4));
   EXPECT_EQ(1, a.CompareWith(smi1));
   EXPECT_EQ(1, a.CompareWith(smi2));
   EXPECT_EQ(-1, c.CompareWith(smi1));
   EXPECT_EQ(-1, c.CompareWith(smi2));
 
-  Bigint& big1 = Bigint::Handle(Bigint::NewFromCString(
-      "10000000000000000000"));
-  Bigint& big2 = Bigint::Handle(Bigint::NewFromCString(
-      "-10000000000000000000"));
+  Bigint& big1 = Bigint::Handle(Bigint::NewFromCString("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));
 
   int64_t mint_value = DART_2PART_UINT64_C(0x7FFFFFFF, 64);
   const String& mint_string = String::Handle(String::New("0x7FFFFFFF00000064"));
   Mint& mint1 = Mint::Handle();
   mint1 ^= Integer::NewCanonical(mint_string);
   Mint& mint2 = Mint::Handle();
@@ skipping 55 matching lines @@
     EXPECT(dbl1.CanonicalizeEquals(dbl2));
     const Double& dbl3 = Double::Handle(Double::New(3.3));
     EXPECT(!dbl1.OperatorEquals(dbl3));
     EXPECT(!dbl1.OperatorEquals(Smi::Handle(Smi::New(3))));
     EXPECT(!dbl1.OperatorEquals(Double::Handle()));
     const Double& nan0 = Double::Handle(Double::New(NAN));
     EXPECT(isnan(nan0.value()));
     EXPECT(nan0.IsIdenticalTo(nan0));
     EXPECT(nan0.CanonicalizeEquals(nan0));
     EXPECT(!nan0.OperatorEquals(nan0));
-    const Double& nan1 = Double::Handle(
-        Double::New(bit_cast<double>(kMaxUint64 - 0)));
-    const Double& nan2 = Double::Handle(
-        Double::New(bit_cast<double>(kMaxUint64 - 1)));
+    const Double& nan1 =
+        Double::Handle(Double::New(bit_cast<double>(kMaxUint64 - 0)));
+    const Double& nan2 =
+        Double::Handle(Double::New(bit_cast<double>(kMaxUint64 - 1)));
     EXPECT(isnan(nan1.value()));
     EXPECT(isnan(nan2.value()));
     EXPECT(!nan1.IsIdenticalTo(nan2));
     EXPECT(!nan1.CanonicalizeEquals(nan2));
     EXPECT(!nan1.OperatorEquals(nan2));
   }
   {
     const String& dbl_str0 = String::Handle(String::New("bla"));
     const Double& dbl0 = Double::Handle(Double::New(dbl_str0));
     EXPECT(dbl0.IsNull());
@@ skipping 18 matching lines @@
   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));
   EXPECT_EQ(t64, big.AsInt64Value());
   big = Bigint::NewFromCString("10000000000000000000");
   EXPECT_EQ(1e19, big.AsDoubleValue());
 
-  Bigint& big1 = Bigint::Handle(Bigint::NewFromCString(
-      "100000000000000000000"));
-  Bigint& big2 = Bigint::Handle(Bigint::NewFromCString(
-      "100000000000000000010"));
-  Bigint& big3 = Bigint::Handle(Bigint::NewFromCString(
-      "-10000000000000000000"));
+  Bigint& big1 =
+      Bigint::Handle(Bigint::NewFromCString("100000000000000000000"));
+  Bigint& big2 =
+      Bigint::Handle(Bigint::NewFromCString("100000000000000000010"));
+  Bigint& big3 =
+      Bigint::Handle(Bigint::NewFromCString("-10000000000000000000"));
 
   EXPECT_EQ(0, big1.CompareWith(big1));
   EXPECT_EQ(-1, big1.CompareWith(big2));
   EXPECT_EQ(1, big2.CompareWith(big1));
   EXPECT_EQ(1, big1.CompareWith(big3));
   EXPECT_EQ(-1, big3.CompareWith(big1));
 
   Smi& smi1 = Smi::Handle(Smi::New(5));
   Smi& smi2 = Smi::Handle(Smi::New(-2));
 
@@ skipping 40 matching lines @@
   EXPECT_EQ(' ', str.CharAt(5));
   EXPECT_EQ('W', str.CharAt(6));
   EXPECT_EQ('o', str.CharAt(7));
   EXPECT_EQ('r', str.CharAt(8));
   EXPECT_EQ('l', str.CharAt(9));
   EXPECT_EQ('d', str.CharAt(10));
   EXPECT_EQ('!', str.CharAt(11));
 
   const uint8_t* motto =
       reinterpret_cast<const uint8_t*>("Dart's bescht wos je hets gits");
-  const String& str2 = String::Handle(String::FromUTF8(motto+7, 4));
+  const String& str2 = String::Handle(String::FromUTF8(motto + 7, 4));
   EXPECT_EQ(4, str2.Length());
   EXPECT_EQ('b', str2.CharAt(0));
   EXPECT_EQ('e', str2.CharAt(1));
   EXPECT_EQ('s', str2.CharAt(2));
   EXPECT_EQ('c', str2.CharAt(3));
 
   const String& str3 = String::Handle(String::New(kHello));
   EXPECT(str.Equals(str));
   EXPECT_EQ(str.Hash(), str.Hash());
   EXPECT(!str.Equals(str2));
   EXPECT(str.Equals(str3));
   EXPECT_EQ(str.Hash(), str3.Hash());
   EXPECT(str3.Equals(str));
 
   const String& str4 = String::Handle(String::New("foo"));
   const String& str5 = String::Handle(String::New("bar"));
   const String& str6 = String::Handle(String::Concat(str4, str5));
   const String& str7 = String::Handle(String::New("foobar"));
   EXPECT(str6.Equals(str7));
   EXPECT(!str6.Equals(Smi::Handle(Smi::New(4))));
 
   const String& empty1 = String::Handle(String::New(""));
   const String& empty2 = String::Handle(String::New(""));
   EXPECT(empty1.Equals(empty2, 0, 0));
 
   const intptr_t kCharsLen = 8;
-  const uint8_t chars[kCharsLen] = { 1, 2, 127, 64, 92, 0, 55, 55 };
+  const uint8_t chars[kCharsLen] = {1, 2, 127, 64, 92, 0, 55, 55};
   const String& str8 = String::Handle(String::FromUTF8(chars, kCharsLen));
   EXPECT_EQ(kCharsLen, str8.Length());
   EXPECT_EQ(1, str8.CharAt(0));
   EXPECT_EQ(127, str8.CharAt(2));
   EXPECT_EQ(64, str8.CharAt(3));
   EXPECT_EQ(0, str8.CharAt(5));
   EXPECT_EQ(55, str8.CharAt(6));
   EXPECT_EQ(55, str8.CharAt(7));
   const intptr_t kCharsIndex = 3;
   const String& sub1 = String::Handle(String::SubString(str8, kCharsIndex));
   EXPECT_EQ((kCharsLen - kCharsIndex), sub1.Length());
   EXPECT_EQ(64, sub1.CharAt(0));
   EXPECT_EQ(92, sub1.CharAt(1));
   EXPECT_EQ(0, sub1.CharAt(2));
   EXPECT_EQ(55, sub1.CharAt(3));
   EXPECT_EQ(55, sub1.CharAt(4));
 
   const intptr_t kWideCharsLen = 7;
-  uint16_t wide_chars[kWideCharsLen] = { 'H', 'e', 'l', 'l', 'o', 256, '!' };
-  const String& two_str = String::Handle(String::FromUTF16(wide_chars,
-                                                           kWideCharsLen));
+  uint16_t wide_chars[kWideCharsLen] = {'H', 'e', 'l', 'l', 'o', 256, '!'};
+  const String& two_str =
+      String::Handle(String::FromUTF16(wide_chars, kWideCharsLen));
   EXPECT(two_str.IsInstance());
   EXPECT(two_str.IsString());
   EXPECT(two_str.IsTwoByteString());
   EXPECT(!two_str.IsOneByteString());
   EXPECT_EQ(kWideCharsLen, two_str.Length());
   EXPECT_EQ('H', two_str.CharAt(0));
   EXPECT_EQ(256, two_str.CharAt(5));
   const intptr_t kWideCharsIndex = 3;
   const String& sub2 = String::Handle(String::SubString(two_str, kCharsIndex));
   EXPECT_EQ((kWideCharsLen - kWideCharsIndex), sub2.Length());
   EXPECT_EQ('l', sub2.CharAt(0));
   EXPECT_EQ('o', sub2.CharAt(1));
   EXPECT_EQ(256, sub2.CharAt(2));
   EXPECT_EQ('!', sub2.CharAt(3));
 
   {
     const String& str1 = String::Handle(String::New("My.create"));
     const String& str2 = String::Handle(String::New("My"));
     const String& str3 = String::Handle(String::New("create"));
     EXPECT_EQ(true, str1.StartsWith(str2));
     EXPECT_EQ(false, str1.StartsWith(str3));
   }
 
-  const int32_t four_chars[] = { 'C', 0xFF, 'h', 0xFFFF, 'a', 0x10FFFF, 'r' };
+  const int32_t four_chars[] = {'C', 0xFF, 'h', 0xFFFF, 'a', 0x10FFFF, 'r'};
   const String& four_str = String::Handle(String::FromUTF32(four_chars, 7));
   EXPECT_EQ(four_str.Hash(), four_str.Hash());
   EXPECT(four_str.IsTwoByteString());
   EXPECT(!four_str.IsOneByteString());
   EXPECT_EQ(8, four_str.Length());
   EXPECT_EQ('C', four_str.CharAt(0));
   EXPECT_EQ(0xFF, four_str.CharAt(1));
   EXPECT_EQ('h', four_str.CharAt(2));
   EXPECT_EQ(0xFFFF, four_str.CharAt(3));
   EXPECT_EQ('a', four_str.CharAt(4));
   EXPECT_EQ(0xDBFF, four_str.CharAt(5));
   EXPECT_EQ(0xDFFF, four_str.CharAt(6));
   EXPECT_EQ('r', four_str.CharAt(7));
 
   // Create a 1-byte string from an array of 2-byte elements.
   {
-    const uint16_t char16[] = { 0x00, 0x7F, 0xFF };
+    const uint16_t char16[] = {0x00, 0x7F, 0xFF};
     const String& str8 = String::Handle(String::FromUTF16(char16, 3));
     EXPECT(str8.IsOneByteString());
     EXPECT(!str8.IsTwoByteString());
     EXPECT_EQ(0x00, str8.CharAt(0));
     EXPECT_EQ(0x7F, str8.CharAt(1));
     EXPECT_EQ(0xFF, str8.CharAt(2));
   }
 
   // Create a 1-byte string from an array of 4-byte elements.
   {
-    const int32_t char32[] = { 0x00, 0x1F, 0x7F };
+    const int32_t char32[] = {0x00, 0x1F, 0x7F};
     const String& str8 = String::Handle(String::FromUTF32(char32, 3));
     EXPECT(str8.IsOneByteString());
     EXPECT(!str8.IsTwoByteString());
     EXPECT_EQ(0x00, str8.CharAt(0));
     EXPECT_EQ(0x1F, str8.CharAt(1));
     EXPECT_EQ(0x7F, str8.CharAt(2));
   }
 
   // Create a 2-byte string from an array of 4-byte elements.
   {
-    const int32_t char32[] = { 0, 0x7FFF, 0xFFFF };
+    const int32_t char32[] = {0, 0x7FFF, 0xFFFF};
     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));
   }
 }
 
 
@@ skipping 184 matching lines @@
     EXPECT_EQ(three_one_three_len, str8.Length());
     EXPECT(str8.Equals(three_one_three));
   }
 
   // Concatenate empty and non-empty 2-byte strings.
   {
     const String& str1 = String::Handle(String::New(""));
     EXPECT(str1.IsOneByteString());
     EXPECT_EQ(0, str1.Length());
 
-    uint16_t two[] = { 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
+    uint16_t two[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9};
     intptr_t two_len = sizeof(two) / sizeof(two[0]);
     const String& str2 = String::Handle(String::FromUTF16(two, two_len));
     EXPECT(str2.IsTwoByteString());
     EXPECT_EQ(two_len, str2.Length());
 
     // Concat
 
     const String& str3 = String::Handle(String::Concat(str1, str2));
     EXPECT(str3.IsTwoByteString());
     EXPECT_EQ(two_len, str3.Length());
@@ skipping 25 matching lines @@
     EXPECT(str6.Equals(str2));
 
     const Array& array3 = Array::Handle(Array::New(3));
     EXPECT_EQ(3, array3.Length());
     array3.SetAt(0, str2);
     array3.SetAt(1, str1);
     array3.SetAt(2, str2);
     const String& str7 = String::Handle(String::ConcatAll(array3));
     EXPECT(str7.IsTwoByteString());
     EXPECT_EQ(two_len * 2, str7.Length());
-    uint16_t twotwo[] = { 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
-                          0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
+    uint16_t twotwo[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
+                         0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9};
     intptr_t twotwo_len = sizeof(twotwo) / sizeof(twotwo[0]);
     EXPECT(str7.IsTwoByteString());
     EXPECT(str7.Equals(twotwo, twotwo_len));
   }
 
   // Concatenating non-empty 2-byte strings.
   {
-    const uint16_t one[] = { 0x05D0, 0x05D9, 0x05D9, 0x05DF };
+    const uint16_t one[] = {0x05D0, 0x05D9, 0x05D9, 0x05DF};
     intptr_t one_len = sizeof(one) / sizeof(one[0]);
     const String& str1 = String::Handle(String::FromUTF16(one, one_len));
     EXPECT(str1.IsTwoByteString());
     EXPECT_EQ(one_len, str1.Length());
 
-    const uint16_t two[] = { 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
+    const uint16_t two[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9};
     intptr_t two_len = sizeof(two) / sizeof(two[0]);
     const String& str2 = String::Handle(String::FromUTF16(two, two_len));
     EXPECT(str2.IsTwoByteString());
     EXPECT_EQ(two_len, str2.Length());
 
     // Concat
 
     const String& one_two_str = String::Handle(String::Concat(str1, str2));
     EXPECT(one_two_str.IsTwoByteString());
-    const uint16_t one_two[] = { 0x05D0, 0x05D9, 0x05D9, 0x05DF,
-                                 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
+    const uint16_t one_two[] = {0x05D0, 0x05D9, 0x05D9, 0x05DF, 0x05E6,
+                                0x05D5, 0x05D5, 0x05D9, 0x05D9};
     intptr_t one_two_len = sizeof(one_two) / sizeof(one_two[0]);
     EXPECT_EQ(one_two_len, one_two_str.Length());
     EXPECT(one_two_str.Equals(one_two, one_two_len));
 
     const String& two_one_str = String::Handle(String::Concat(str2, str1));
     EXPECT(two_one_str.IsTwoByteString());
-    const uint16_t two_one[] = { 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
-                                 0x05D0, 0x05D9, 0x05D9, 0x05DF };
+    const uint16_t two_one[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
+                                0x05D0, 0x05D9, 0x05D9, 0x05DF};
     intptr_t two_one_len = sizeof(two_one) / sizeof(two_one[0]);
     EXPECT_EQ(two_one_len, two_one_str.Length());
     EXPECT(two_one_str.Equals(two_one, two_one_len));
 
     // ConcatAll
 
     const Array& array1 = Array::Handle(Array::New(2));
     EXPECT_EQ(2, array1.Length());
     array1.SetAt(0, str1);
     array1.SetAt(1, str2);
@@ skipping 11 matching lines @@
     EXPECT_EQ(two_one_len, str4.Length());
     EXPECT(str4.Equals(two_one, two_one_len));
 
     const Array& array3 = Array::Handle(Array::New(3));
     EXPECT_EQ(3, array3.Length());
     array3.SetAt(0, str1);
     array3.SetAt(1, str2);
     array3.SetAt(2, str1);
     const String& str5 = String::Handle(String::ConcatAll(array3));
     EXPECT(str5.IsTwoByteString());
-    const uint16_t one_two_one[] = { 0x05D0, 0x05D9, 0x05D9, 0x05DF,
-                                     0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
-                                     0x05D0, 0x05D9, 0x05D9, 0x05DF };
+    const uint16_t one_two_one[] = {0x05D0, 0x05D9, 0x05D9, 0x05DF, 0x05E6,
+                                    0x05D5, 0x05D5, 0x05D9, 0x05D9, 0x05D0,
+                                    0x05D9, 0x05D9, 0x05DF};
     intptr_t one_two_one_len = sizeof(one_two_one) / sizeof(one_two_one[0]);
     EXPECT_EQ(one_two_one_len, str5.Length());
     EXPECT(str5.Equals(one_two_one, one_two_one_len));
 
     const Array& array4 = Array::Handle(Array::New(3));
     EXPECT_EQ(3, array4.Length());
     array4.SetAt(0, str2);
     array4.SetAt(1, str1);
     array4.SetAt(2, str2);
     const String& str6 = String::Handle(String::ConcatAll(array4));
     EXPECT(str6.IsTwoByteString());
-    const uint16_t two_one_two[] = { 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
-                                     0x05D0, 0x05D9, 0x05D9, 0x05DF,
-                                     0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
+    const uint16_t two_one_two[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
+                                    0x05D0, 0x05D9, 0x05D9, 0x05DF, 0x05E6,
+                                    0x05D5, 0x05D5, 0x05D9, 0x05D9};
     intptr_t two_one_two_len = sizeof(two_one_two) / sizeof(two_one_two[0]);
     EXPECT_EQ(two_one_two_len, str6.Length());
     EXPECT(str6.Equals(two_one_two, two_one_two_len));
   }
 
   // Concatenated emtpy and non-empty strings built from 4-byte elements.
   {
     const String& str1 = String::Handle(String::New(""));
     EXPECT(str1.IsOneByteString());
     EXPECT_EQ(0, str1.Length());
 
-    int32_t four[] = { 0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1 };
+    int32_t four[] = {0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1};
     intptr_t four_len = sizeof(four) / sizeof(four[0]);
     intptr_t expected_len = (four_len * 2);
     const String& str2 = String::Handle(String::FromUTF32(four, four_len));
     EXPECT(str2.IsTwoByteString());
     EXPECT_EQ(expected_len, str2.Length());
 
     // Concat
 
     const String& str3 = String::Handle(String::Concat(str1, str2));
     EXPECT_EQ(expected_len, str3.Length());
@@ skipping 24 matching lines @@
     EXPECT_EQ(expected_len, str6.Length());
     EXPECT(str6.Equals(str2));
 
     const Array& array3 = Array::Handle(Array::New(3));
     EXPECT_EQ(3, array3.Length());
     array3.SetAt(0, str2);
     array3.SetAt(1, str1);
     array3.SetAt(2, str2);
     const String& str7 = String::Handle(String::ConcatAll(array3));
     EXPECT(str7.IsTwoByteString());
-    int32_t fourfour[] = { 0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1,
-                           0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1 };
+    int32_t fourfour[] = {0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1,
+                          0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1};
     intptr_t fourfour_len = sizeof(fourfour) / sizeof(fourfour[0]);
     EXPECT_EQ((fourfour_len * 2), str7.Length());
     const String& fourfour_str =
         String::Handle(String::FromUTF32(fourfour, fourfour_len));
     EXPECT(str7.Equals(fourfour_str));
   }
 
   // Concatenate non-empty strings built from 4-byte elements.
   {
-    const int32_t one[] = { 0x105D0, 0x105D9, 0x105D9, 0x105DF };
+    const int32_t one[] = {0x105D0, 0x105D9, 0x105D9, 0x105DF};
     intptr_t one_len = sizeof(one) / sizeof(one[0]);
     const String& onestr = String::Handle(String::FromUTF32(one, one_len));
     EXPECT(onestr.IsTwoByteString());
-    EXPECT_EQ((one_len *2), onestr.Length());
+    EXPECT_EQ((one_len * 2), onestr.Length());
 
-    const int32_t two[] = { 0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9 };
+    const int32_t two[] = {0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9};
     intptr_t two_len = sizeof(two) / sizeof(two[0]);
     const String& twostr = String::Handle(String::FromUTF32(two, two_len));
     EXPECT(twostr.IsTwoByteString());
     EXPECT_EQ((two_len * 2), twostr.Length());
 
     // Concat
 
     const String& str1 = String::Handle(String::Concat(onestr, twostr));
     EXPECT(str1.IsTwoByteString());
-    const int32_t one_two[] = { 0x105D0, 0x105D9, 0x105D9, 0x105DF,
-                                0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9 };
+    const int32_t one_two[] = {0x105D0, 0x105D9, 0x105D9, 0x105DF, 0x105E6,
+                               0x105D5, 0x105D5, 0x105D9, 0x105D9};
     intptr_t one_two_len = sizeof(one_two) / sizeof(one_two[0]);
     EXPECT_EQ((one_two_len * 2), str1.Length());
     const String& one_two_str =
         String::Handle(String::FromUTF32(one_two, one_two_len));
     EXPECT(str1.Equals(one_two_str));
 
     const String& str2 = String::Handle(String::Concat(twostr, onestr));
     EXPECT(str2.IsTwoByteString());
-    const int32_t two_one[] = { 0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9,
-                                0x105D0, 0x105D9, 0x105D9, 0x105DF };
+    const int32_t two_one[] = {0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9,
+                               0x105D0, 0x105D9, 0x105D9, 0x105DF};
     intptr_t two_one_len = sizeof(two_one) / sizeof(two_one[0]);
     EXPECT_EQ((two_one_len * 2), str2.Length());
     const String& two_one_str =
         String::Handle(String::FromUTF32(two_one, two_one_len));
     EXPECT(str2.Equals(two_one_str));
 
     // ConcatAll
 
     const Array& array1 = Array::Handle(Array::New(2));
     EXPECT_EQ(2, array1.Length());
@@ skipping 13 matching lines @@
     EXPECT_EQ((two_one_len * 2), str4.Length());
     EXPECT(str4.Equals(two_one_str));
 
     const Array& array3 = Array::Handle(Array::New(3));
     EXPECT_EQ(3, array3.Length());
     array3.SetAt(0, onestr);
     array3.SetAt(1, twostr);
     array3.SetAt(2, onestr);
     const String& str5 = String::Handle(String::ConcatAll(array3));
     EXPECT(str5.IsTwoByteString());
-    const int32_t one_two_one[] = { 0x105D0, 0x105D9, 0x105D9, 0x105DF,
-                                    0x105E6, 0x105D5, 0x105D5, 0x105D9,
-                                    0x105D9,
-                                    0x105D0, 0x105D9, 0x105D9, 0x105DF };
+    const int32_t one_two_one[] = {0x105D0, 0x105D9, 0x105D9, 0x105DF, 0x105E6,
+                                   0x105D5, 0x105D5, 0x105D9, 0x105D9, 0x105D0,
+                                   0x105D9, 0x105D9, 0x105DF};
     intptr_t one_two_one_len = sizeof(one_two_one) / sizeof(one_two_one[0]);
     EXPECT_EQ((one_two_one_len * 2), str5.Length());
     const String& one_two_one_str =
         String::Handle(String::FromUTF32(one_two_one, one_two_one_len));
     EXPECT(str5.Equals(one_two_one_str));
 
     const Array& array4 = Array::Handle(Array::New(3));
     EXPECT_EQ(3, array4.Length());
     array4.SetAt(0, twostr);
     array4.SetAt(1, onestr);
     array4.SetAt(2, twostr);
     const String& str6 = String::Handle(String::ConcatAll(array4));
     EXPECT(str6.IsTwoByteString());
-    const int32_t two_one_two[] = { 0x105E6, 0x105D5, 0x105D5, 0x105D9,
-                                    0x105D9,
-                                    0x105D0, 0x105D9, 0x105D9, 0x105DF,
-                                    0x105E6, 0x105D5, 0x105D5, 0x105D9,
-                                    0x105D9 };
+    const int32_t two_one_two[] = {0x105E6, 0x105D5, 0x105D5, 0x105D9, 0x105D9,
+                                   0x105D0, 0x105D9, 0x105D9, 0x105DF, 0x105E6,
+                                   0x105D5, 0x105D5, 0x105D9, 0x105D9};
     intptr_t two_one_two_len = sizeof(two_one_two) / sizeof(two_one_two[0]);
     EXPECT_EQ((two_one_two_len * 2), str6.Length());
     const String& two_one_two_str =
         String::Handle(String::FromUTF32(two_one_two, two_one_two_len));
     EXPECT(str6.Equals(two_one_two_str));
   }
 
   // Concatenate 1-byte strings and 2-byte strings.
   {
-    const uint8_t one[] = { 'o', 'n', 'e', ' ', 'b', 'y', 't', 'e' };
+    const uint8_t one[] = {'o', 'n', 'e', ' ', 'b', 'y', 't', 'e'};
     intptr_t one_len = sizeof(one) / sizeof(one[0]);
     const String& onestr = String::Handle(String::FromLatin1(one, one_len));
     EXPECT(onestr.IsOneByteString());
     EXPECT_EQ(one_len, onestr.Length());
     EXPECT(onestr.EqualsLatin1(one, one_len));
 
-    uint16_t two[] = { 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
+    uint16_t two[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9};
     intptr_t two_len = sizeof(two) / sizeof(two[0]);
     const String& twostr = String::Handle(String::FromUTF16(two, two_len));
     EXPECT(twostr.IsTwoByteString());
     EXPECT_EQ(two_len, twostr.Length());
     EXPECT(twostr.Equals(two, two_len));
 
     // Concat
 
     const String& one_two_str = String::Handle(String::Concat(onestr, twostr));
     EXPECT(one_two_str.IsTwoByteString());
-    uint16_t one_two[] = { 'o', 'n', 'e', ' ', 'b', 'y', 't', 'e',
-                           0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
+    uint16_t one_two[] = {'o', 'n',    'e',    ' ',    'b',    'y',   't',
+                          'e', 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9};
     intptr_t one_two_len = sizeof(one_two) / sizeof(one_two[0]);
     EXPECT_EQ(one_two_len, one_two_str.Length());
     EXPECT(one_two_str.Equals(one_two, one_two_len));
 
     const String& two_one_str = String::Handle(String::Concat(twostr, onestr));
     EXPECT(two_one_str.IsTwoByteString());
-    uint16_t two_one[] = { 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
-                           'o', 'n', 'e', ' ', 'b', 'y', 't', 'e' };
+    uint16_t two_one[] = {0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9, 'o', 'n',
+                          'e',    ' ',    'b',    'y',    't',    'e'};
     intptr_t two_one_len = sizeof(two_one) / sizeof(two_one[0]);
     EXPECT_EQ(two_one_len, two_one_str.Length());
     EXPECT(two_one_str.Equals(two_one, two_one_len));
 
     // ConcatAll
 
     const Array& array1 = Array::Handle(Array::New(3));
     EXPECT_EQ(3, array1.Length());
     array1.SetAt(0, onestr);
     array1.SetAt(1, twostr);
     array1.SetAt(2, onestr);
     const String& one_two_one_str = String::Handle(String::ConcatAll(array1));
     EXPECT(one_two_one_str.IsTwoByteString());
-    EXPECT_EQ(onestr.Length()*2 + twostr.Length(), one_two_one_str.Length());
-    uint16_t one_two_one[] = { 'o', 'n', 'e', ' ', 'b', 'y', 't', 'e',
-                               0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9,
-                               'o', 'n', 'e', ' ', 'b', 'y', 't', 'e' };
+    EXPECT_EQ(onestr.Length() * 2 + twostr.Length(), one_two_one_str.Length());
+    uint16_t one_two_one[] = {'o', 'n',    'e',    ' ',    'b',    'y',    't',
+                              'e', 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9, 'o',
+                              'n', 'e',    ' ',    'b',    'y',    't',    'e'};
     intptr_t one_two_one_len = sizeof(one_two_one) / sizeof(one_two_one[0]);
     EXPECT(one_two_one_str.Equals(one_two_one, one_two_one_len));
 
     const Array& array2 = Array::Handle(Array::New(3));
     EXPECT_EQ(3, array2.Length());
     array2.SetAt(0, twostr);
     array2.SetAt(1, onestr);
     array2.SetAt(2, twostr);
     const String& two_one_two_str = String::Handle(String::ConcatAll(array2));
     EXPECT(two_one_two_str.IsTwoByteString());
-    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 };
+    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));
   }
 }
 
 
 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 };
+  uint16_t clef_utf16[] = {0xD834, 0xDD1E};
   const String& clef = String::Handle(String::FromUTF16(clef_utf16, 2));
-  int32_t clef_utf32[] = { 0x1D11E };
+  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))));
+                        String::Handle(String::FromUTF16(clef_utf16, 1)),
+                        String::Handle(String::FromUTF16(clef_utf16 + 1, 1))));
 }
 
 
 VM_TEST_CASE(StringSubStringDifferentWidth) {
   // Create 1-byte substring from a 1-byte source string.
-  const char* onechars =
-      "\xC3\xB6\xC3\xB1\xC3\xA9";
+  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));
   EXPECT(!onesub.IsNull());
   EXPECT(onestr.IsOneByteString());
   EXPECT(!onestr.IsTwoByteString());
@@ skipping 67 matching lines @@
         "\xC3\x9C\xC3\x9D\xC3\x9E\xC3\x9F"
         "\xC3\xA0\xC3\xA1\xC3\xA2\xC3\xA3"
         "\xC3\xA4\xC3\xA5\xC3\xA6\xC3\xA7"
         "\xC3\xA8\xC3\xA9\xC3\xAA\xC3\xAB"
         "\xC3\xAC\xC3\xAD\xC3\xAE\xC3\xAF"
         "\xC3\xB0\xC3\xB1\xC3\xB2\xC3\xB3"
         "\xC3\xB4\xC3\xB5\xC3\xB6\xC3\xB7"
         "\xC3\xB8\xC3\xB9\xC3\xBA\xC3\xBB"
         "\xC3\xBC\xC3\xBD\xC3\xBE\xC3\xBF";
     const uint8_t expected[] = {
-      0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
-      0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
-      0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
-      0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
-      0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
-      0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
-      0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
-      0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
-      0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
-      0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
-      0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
-      0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
+        0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB,
+        0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
+        0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3,
+        0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
+        0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB,
+        0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
+        0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3,
+        0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
     };
     const String& str = String::Handle(String::New(src));
     EXPECT(str.IsOneByteString());
     intptr_t expected_length = sizeof(expected);
     EXPECT_EQ(expected_length, str.Length());
     for (int i = 0; i < str.Length(); ++i) {
       EXPECT_EQ(expected[i], str.CharAt(i));
     }
   }
 
   // Create a 2-byte string from a UTF-8 encoded string literal.
   {
     const char* src =
         "\xD7\x92\xD7\x9C\xD7\xA2\xD7\x93"
         "\xD7\x91\xD7\xA8\xD7\x9B\xD7\x94";
-    const uint16_t expected[] = {
-      0x5D2, 0x5DC, 0x5E2, 0x5D3,
-      0x5D1, 0x5E8, 0x5DB, 0x5D4
-    };
+    const uint16_t expected[] = {0x5D2, 0x5DC, 0x5E2, 0x5D3,
+                                 0x5D1, 0x5E8, 0x5DB, 0x5D4};
     const String& str = String::Handle(String::New(src));
     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));
     }
   }
 
   // Create a BMP 2-byte string from UTF-8 encoded 1- and 2-byte
   // characters.
   {
     const char* src =
         "\x0A\x0B\x0D\x0C\x0E\x0F\xC2\xA0"
         "\xC2\xB0\xC3\x80\xC3\x90\xC3\xA0"
         "\xC3\xB0\xE0\xA8\x80\xE0\xAC\x80"
         "\xE0\xB0\x80\xE0\xB4\x80\xE0\xB8"
         "\x80\xE0\xBC\x80\xEA\x80\x80\xEB"
         "\x80\x80\xEC\x80\x80\xED\x80\x80"
         "\xEE\x80\x80\xEF\x80\x80";
     const intptr_t expected[] = {
-      0x000A, 0x000B, 0x000D, 0x000C, 0x000E, 0x000F, 0x00A0, 0x00B0,
-      0x00C0, 0x00D0, 0x00E0, 0x00F0, 0x0A00, 0x0B00, 0x0C00, 0x0D00,
-      0x0E00, 0x0F00, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000
-    };
+        0x000A, 0x000B, 0x000D, 0x000C, 0x000E, 0x000F, 0x00A0, 0x00B0,
+        0x00C0, 0x00D0, 0x00E0, 0x00F0, 0x0A00, 0x0B00, 0x0C00, 0x0D00,
+        0x0E00, 0x0F00, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000};
     const String& str = String::Handle(String::New(src));
     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));
     }
   }
 
   // Create a 2-byte string with supplementary characters from a UTF-8
   // string literal.
   {
     const char* src =
         "\xF0\x9D\x91\xA0\xF0\x9D\x91\xA1"
         "\xF0\x9D\x91\xA2\xF0\x9D\x91\xA3";
-    const intptr_t expected[] = { 0xd835, 0xdc60, 0xd835, 0xdc61,
-                                  0xd835, 0xdc62, 0xd835, 0xdc63 };
+    const intptr_t expected[] = {0xd835, 0xdc60, 0xd835, 0xdc61,
+                                 0xd835, 0xdc62, 0xd835, 0xdc63};
     const String& str = String::Handle(String::New(src));
     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));
     }
   }
 
   // Create a 2-byte string from UTF-8 encoded 2- and 4-byte
   // characters.
   {
     const char* src =
         "\xE0\xA8\x80\xE0\xAC\x80\xE0\xB0"
         "\x80\xE0\xB4\x80\xE0\xB8\x80\xE0"
         "\xBC\x80\xEA\x80\x80\xEB\x80\x80"
         "\xEC\x80\x80\xED\x80\x80\xEE\x80"
         "\x80\xEF\x80\x80\xF0\x9A\x80\x80"
         "\xF0\x9B\x80\x80\xF0\x9D\x80\x80"
         "\xF0\x9E\x80\x80\xF0\x9F\x80\x80";
     const intptr_t expected[] = {
-      0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00, 0xA000, 0xB000, 0xC000,
-      0xD000, 0xE000, 0xF000, 0xD828, 0xDC00, 0xD82c, 0xDC00, 0xD834, 0xDC00,
-      0xD838, 0xDC00, 0xD83c, 0xDC00,
+        0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00, 0xA000, 0xB000,
+        0xC000, 0xD000, 0xE000, 0xF000, 0xD828, 0xDC00, 0xD82c, 0xDC00,
+        0xD834, 0xDC00, 0xD838, 0xDC00, 0xD83c, 0xDC00,
     };
     const String& str = String::Handle(String::New(src));
     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));
     }
   }
 
   // Create a 2-byte string from UTF-8 encoded 1-, 2- and 4-byte
   // characters.
   {
     const char* src =
         "\x0A\x0B\x0D\x0C\x0E\x0F\xC2\xA0"
         "\xC2\xB0\xC3\x80\xC3\x90\xC3\xA0"
         "\xC3\xB0\xE0\xA8\x80\xE0\xAC\x80"
         "\xE0\xB0\x80\xE0\xB4\x80\xE0\xB8"
         "\x80\xE0\xBC\x80\xEA\x80\x80\xEB"
         "\x80\x80\xEC\x80\x80\xED\x80\x80"
         "\xEE\x80\x80\xEF\x80\x80\xF0\x9A"
         "\x80\x80\xF0\x9B\x80\x80\xF0\x9D"
         "\x80\x80\xF0\x9E\x80\x80\xF0\x9F"
         "\x80\x80";
     const intptr_t expected[] = {
-      0x000A, 0x000B, 0x000D, 0x000C, 0x000E, 0x000F, 0x00A0, 0x00B0,
-      0x00C0, 0x00D0, 0x00E0, 0x00F0, 0x0A00, 0x0B00, 0x0C00, 0x0D00,
-      0x0E00, 0x0F00, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000,
-      0xD828, 0xDC00, 0xD82c, 0xDC00, 0xD834, 0xDC00, 0xD838, 0xDC00,
-      0xD83c, 0xDC00,
+        0x000A, 0x000B, 0x000D, 0x000C, 0x000E, 0x000F, 0x00A0, 0x00B0, 0x00C0,
+        0x00D0, 0x00E0, 0x00F0, 0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00,
+        0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000, 0xD828, 0xDC00, 0xD82c,
+        0xDC00, 0xD834, 0xDC00, 0xD838, 0xDC00, 0xD83c, 0xDC00,
     };
     const String& str = String::Handle(String::New(src));
     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));
     }
   }
 }
@@ skipping 18 matching lines @@
   EXPECT(twostr.Equals("\xD7\x90\xD7\x91\xD7\x92"));
   EXPECT(!twostr.Equals("\xD7\x90\xD7\x91\xD7\x92\xD7\x93"));
 
   const char* foursrc = "\xF0\x90\x8E\xA0\xF0\x90\x8E\xA1\xF0\x90\x8E\xA2";
   const String& fourstr = String::Handle(String::New(foursrc));
   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"));
+  EXPECT(
+      !fourstr.Equals("\xF0\x90\x8E\xA0\xF0\x90\x8E\xA1"
+                      "\xF0\x90\x8E\xA2\xF0\x90\x8E\xA3"));
 }
 
 
 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));
 }
 
 
 VM_TEST_CASE(ExternalOneByteString) {
-  uint8_t characters[] = { 0xF6, 0xF1, 0xE9 };
+  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));
+  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"));
 
   const String& copy = String::Handle(String::SubString(str, 0, len));
   EXPECT(!copy.IsExternalOneByteString());
   EXPECT(copy.IsOneByteString());
   EXPECT_EQ(len, copy.Length());
   EXPECT(copy.Equals(str));
 
   const String& concat = String::Handle(String::Concat(str, str));
   EXPECT(!concat.IsExternalOneByteString());
   EXPECT(concat.IsOneByteString());
   EXPECT_EQ(len * 2, concat.Length());
   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"));
 }
 
 
 VM_TEST_CASE(EscapeSpecialCharactersOneByteString) {
-  uint8_t characters[] =
-      { 'a', '\n', '\f', '\b', '\t', '\v', '\r', '\\', '$', 'z' };
+  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));
+      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);
 }
 
 
 VM_TEST_CASE(EscapeSpecialCharactersExternalOneByteString) {
-  uint8_t characters[] =
-      { 'a', '\n', '\f', '\b', '\t', '\v', '\r', '\\', '$', 'z' };
+  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));
+  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& 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);
 }
 
 VM_TEST_CASE(EscapeSpecialCharactersTwoByteString) {
-  uint16_t characters[] =
-      { 'a', '\n', '\f', '\b', '\t', '\v', '\r', '\\', '$', 'z' };
+  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);
 }
 
 
 VM_TEST_CASE(EscapeSpecialCharactersExternalTwoByteString) {
-  uint16_t characters[] =
-      { 'a', '\n', '\f', '\b', '\t', '\v', '\r', '\\', '$', 'z' };
+  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));
+  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& 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);
 }
 
 
 VM_TEST_CASE(ExternalTwoByteString) {
-  uint16_t characters[] = { 0x1E6B, 0x1E85, 0x1E53 };
+  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));
+  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"));
 
   const String& copy = String::Handle(String::SubString(str, 0, len));
   EXPECT(!copy.IsExternalTwoByteString());
   EXPECT(copy.IsTwoByteString());
   EXPECT_EQ(len, copy.Length());
   EXPECT(copy.Equals(str));
 
   const String& concat = String::Handle(String::Concat(str, str));
   EXPECT(!concat.IsExternalTwoByteString());
   EXPECT(concat.IsTwoByteString());
   EXPECT_EQ(len * 2, concat.Length());
-  EXPECT(concat.Equals("\xE1\xB9\xAB\xE1\xBA\x85\xE1\xB9\x93"
-                       "\xE1\xB9\xAB\xE1\xBA\x85\xE1\xB9\x93"));
+  EXPECT(
+      concat.Equals("\xE1\xB9\xAB\xE1\xBA\x85\xE1\xB9\x93"
+                    "\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"));
 }
 
 
 VM_TEST_CASE(Symbol) {
@@ skipping 40 matching lines @@
   EXPECT_EQ(nine.raw(), Symbols::New(thread, "Neun"));
   EXPECT_EQ(ten.raw(), Symbols::New(thread, "Zehn"));
 
   // Symbols from Strings.
   eins = String::New("Eins");
   EXPECT(!eins.IsSymbol());
   String& ein_symbol = String::Handle(Symbols::New(thread, eins));
   EXPECT_EQ(one.raw(), ein_symbol.raw());
   EXPECT(one.raw() != eins.raw());
 
-  uint16_t char16[] = { 'E', 'l', 'f' };
+  uint16_t char16[] = {'E', 'l', 'f'};
   String& elf1 = String::Handle(Symbols::FromUTF16(thread, char16, 3));
-  int32_t char32[] = { 'E', 'l', 'f' };
+  int32_t char32[] = {'E', 'l', 'f'};
   String& elf2 = String::Handle(Symbols::FromUTF32(thread, char32, 3));
   EXPECT(elf1.IsSymbol());
   EXPECT(elf2.IsSymbol());
   EXPECT_EQ(elf1.raw(), Symbols::New(thread, "Elf"));
   EXPECT_EQ(elf2.raw(), Symbols::New(thread, "Elf"));
 }
 
 
 VM_TEST_CASE(SymbolUnicode) {
-  uint16_t monkey_utf16[] = { 0xd83d, 0xdc35 };  // Unicode Monkey Face.
+  uint16_t monkey_utf16[] = {0xd83d, 0xdc35};  // Unicode Monkey Face.
   String& monkey = String::Handle(Symbols::FromUTF16(thread, monkey_utf16, 2));
   EXPECT(monkey.IsSymbol());
   const char monkey_utf8[] = {'\xf0', '\x9f', '\x90', '\xb5', 0};
   EXPECT_EQ(monkey.raw(), Symbols::New(thread, monkey_utf8));
 
   int32_t kMonkeyFace = 0x1f435;
   String& monkey2 = String::Handle(Symbols::FromCharCode(thread, kMonkeyFace));
   EXPECT_EQ(monkey.raw(), monkey2.raw());
 
   // Unicode cat face with tears of joy.
   int32_t kCatFaceWithTearsOfJoy = 0x1f639;
-  String& cat = String::Handle(Symbols::FromCharCode(thread,
-                                                     kCatFaceWithTearsOfJoy));
+  String& cat =
+      String::Handle(Symbols::FromCharCode(thread, kCatFaceWithTearsOfJoy));
 
-  uint16_t cat_utf16[] = { 0xd83d, 0xde39 };
+  uint16_t cat_utf16[] = {0xd83d, 0xde39};
   String& cat2 = String::Handle(Symbols::FromUTF16(thread, cat_utf16, 2));
   EXPECT(cat2.IsSymbol());
   EXPECT_EQ(cat2.raw(), cat.raw());
 }
 
 
 VM_TEST_CASE(Bool) {
   EXPECT(Bool::True().value());
   EXPECT(!Bool::False().value());
 }
@@ skipping 39 matching lines @@
 
   array.MakeImmutable();
   Object& obj = Object::Handle(array.raw());
   EXPECT(obj.IsArray());
 }
 
 
 static void TestIllegalArrayLength(intptr_t length) {
   char buffer[1024];
   OS::SNPrint(buffer, sizeof(buffer),
-      "main() {\n"
-      "  new List(%" Pd ");\n"
-      "}\n",
-      length);
+              "main() {\n"
+              "  new List(%" Pd
+              ");\n"
+              "}\n",
+              length);
   Dart_Handle lib = TestCase::LoadTestScript(buffer, NULL);
   EXPECT_VALID(lib);
   Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   OS::SNPrint(buffer, sizeof(buffer),
-      "Unhandled exception:\n"
-      "RangeError (length): Invalid value: "
-      "Not in range 0..%" Pd ", inclusive: %" Pd,
-      Array::kMaxElements, length);
+              "Unhandled exception:\n"
+              "RangeError (length): Invalid value: "
+              "Not in range 0..%" Pd ", inclusive: %" Pd,
+              Array::kMaxElements, length);
   EXPECT_ERROR(result, buffer);
 }
 
 
-TEST_CASE(ArrayLengthNegativeOne) { TestIllegalArrayLength(-1); }
-TEST_CASE(ArrayLengthSmiMin) { TestIllegalArrayLength(kSmiMin); }
+TEST_CASE(ArrayLengthNegativeOne) {
+  TestIllegalArrayLength(-1);
+}
+TEST_CASE(ArrayLengthSmiMin) {
+  TestIllegalArrayLength(kSmiMin);
+}
 TEST_CASE(ArrayLengthOneTooMany) {
   const intptr_t kOneTooMany = Array::kMaxElements + 1;
   ASSERT(kOneTooMany >= 0);
   TestIllegalArrayLength(kOneTooMany);
 }
 
 
 TEST_CASE(ArrayLengthMaxElements) {
   char buffer[1024];
   OS::SNPrint(buffer, sizeof(buffer),
-      "main() {\n"
-      "  return new List(%" Pd ");\n"
-      "}\n",
-      Array::kMaxElements);
+              "main() {\n"
+              "  return new List(%" Pd
+              ");\n"
+              "}\n",
+              Array::kMaxElements);
   Dart_Handle lib = TestCase::LoadTestScript(buffer, NULL);
   EXPECT_VALID(lib);
   Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   if (Dart_IsError(result)) {
     EXPECT_ERROR(result, "Out of Memory");
   } else {
     const intptr_t kExpected = Array::kMaxElements;
     intptr_t actual = 0;
     EXPECT_VALID(Dart_ListLength(result, &actual));
     EXPECT_EQ(kExpected, actual);
   }
 }
 
 
 static void TestIllegalTypedDataLength(const char* class_name,
                                        intptr_t length) {
   char buffer[1024];
   OS::SNPrint(buffer, sizeof(buffer),
-      "import 'dart:typed_data';\n"
-      "main() {\n"
-      "  new %s(%" Pd ");\n"
-      "}\n",
-      class_name, length);
+              "import 'dart:typed_data';\n"
+              "main() {\n"
+              "  new %s(%" Pd
+              ");\n"
+              "}\n",
+              class_name, length);
   Dart_Handle lib = TestCase::LoadTestScript(buffer, NULL);
   EXPECT_VALID(lib);
   Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
-  OS::SNPrint(buffer, sizeof(buffer), "%" Pd,  length);
+  OS::SNPrint(buffer, sizeof(buffer), "%" Pd, length);
   EXPECT_ERROR(result, "Invalid argument(s)");
   EXPECT_ERROR(result, buffer);
 }
 
 
 TEST_CASE(Int8ListLengthNegativeOne) {
   TestIllegalTypedDataLength("Int8List", -1);
 }
 TEST_CASE(Int8ListLengthSmiMin) {
   TestIllegalTypedDataLength("Int8List", kSmiMin);
 }
 TEST_CASE(Int8ListLengthOneTooMany) {
   const intptr_t kOneTooMany =
       TypedData::MaxElements(kTypedDataInt8ArrayCid) + 1;
   ASSERT(kOneTooMany >= 0);
   TestIllegalTypedDataLength("Int8List", kOneTooMany);
 }
 
 
 TEST_CASE(Int8ListLengthMaxElements) {
   const intptr_t max_elements = TypedData::MaxElements(kTypedDataInt8ArrayCid);
   char buffer[1024];
   OS::SNPrint(buffer, sizeof(buffer),
-      "import 'dart:typed_data';\n"
-      "main() {\n"
-      "  return new Int8List(%" Pd ");\n"
-      "}\n",
-      max_elements);
+              "import 'dart:typed_data';\n"
+              "main() {\n"
+              "  return new Int8List(%" Pd
+              ");\n"
+              "}\n",
+              max_elements);
   Dart_Handle lib = TestCase::LoadTestScript(buffer, NULL);
   EXPECT_VALID(lib);
   Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   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);
   }
 }
 
 
 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());
   EXPECT(it1.Next());
   EXPECT_EQ(' ', it1.Current());
   EXPECT(!it1.Next());
 
-  const String& str2 = String::Handle(String::New("\xD7\x92\xD7\x9C"
-                                                  "\xD7\xA2\xD7\x93"
-                                                  "\xD7\x91\xD7\xA8"
-                                                  "\xD7\x9B\xD7\x94"));
+  const String& str2 =
+      String::Handle(String::New("\xD7\x92\xD7\x9C"
+                                 "\xD7\xA2\xD7\x93"
+                                 "\xD7\x91\xD7\xA8"
+                                 "\xD7\x9B\xD7\x94"));
   String::CodePointIterator it2(str2);
   EXPECT(it2.Next());
   EXPECT_EQ(0x5D2, it2.Current());
   EXPECT(it2.Next());
   EXPECT_EQ(0x5DC, it2.Current());
   EXPECT(it2.Next());
   EXPECT_EQ(0x5E2, it2.Current());
   EXPECT(it2.Next());
   EXPECT_EQ(0x5D3, it2.Current());
   EXPECT(it2.Next());
   EXPECT_EQ(0x5D1, it2.Current());
   EXPECT(it2.Next());
   EXPECT_EQ(0x5E8, it2.Current());
   EXPECT(it2.Next());
   EXPECT_EQ(0x5DB, it2.Current());
   EXPECT(it2.Next());
   EXPECT_EQ(0x5D4, it2.Current());
   EXPECT(!it2.Next());
 
-  const String& str3 = String::Handle(String::New("\xF0\x9D\x91\xA0"
-                                                  "\xF0\x9D\x91\xA1"
-                                                  "\xF0\x9D\x91\xA2"
-                                                  "\xF0\x9D\x91\xA3"));
+  const String& str3 =
+      String::Handle(String::New("\xF0\x9D\x91\xA0"
+                                 "\xF0\x9D\x91\xA1"
+                                 "\xF0\x9D\x91\xA2"
+                                 "\xF0\x9D\x91\xA3"));
   String::CodePointIterator it3(str3);
   EXPECT(it3.Next());
   EXPECT_EQ(0x1D460, it3.Current());
   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());
@@ skipping 133 matching lines @@
   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());
 }
 
 
 VM_TEST_CASE(InternalTypedData) {
-  uint8_t data[] = { 253, 254, 255, 0, 1, 2, 3, 4 };
+  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));
   }
 }
 
 
 VM_TEST_CASE(ExternalTypedData) {
-  uint8_t data[] = { 253, 254, 255, 0, 1, 2, 3, 4 };
+  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));
+      ExternalTypedData::Handle(ExternalTypedData::New(
+          kExternalTypedDataInt8ArrayCid, data, data_length));
   EXPECT(!int8_array.IsNull());
   EXPECT_EQ(data_length, int8_array.Length());
 
   const ExternalTypedData& uint8_array =
-      ExternalTypedData::Handle(
-          ExternalTypedData::New(kExternalTypedDataUint8ArrayCid,
-                                  data,
-                                  data_length));
+      ExternalTypedData::Handle(ExternalTypedData::New(
+          kExternalTypedDataUint8ArrayCid, data, data_length));
   EXPECT(!uint8_array.IsNull());
   EXPECT_EQ(data_length, uint8_array.Length());
 
   const ExternalTypedData& uint8_clamped_array =
-      ExternalTypedData::Handle(
-          ExternalTypedData::New(kExternalTypedDataUint8ClampedArrayCid,
-                                 data,
-                                 data_length));
+      ExternalTypedData::Handle(ExternalTypedData::New(
+          kExternalTypedDataUint8ClampedArrayCid, data, data_length));
   EXPECT(!uint8_clamped_array.IsNull());
   EXPECT_EQ(data_length, uint8_clamped_array.Length());
 
   EXPECT_EQ(-3, int8_array.GetInt8(0));
   EXPECT_EQ(253, uint8_array.GetUint8(0));
   EXPECT_EQ(253, uint8_clamped_array.GetUint8(0));
 
   EXPECT_EQ(-2, int8_array.GetInt8(1));
   EXPECT_EQ(254, uint8_array.GetUint8(1));
   EXPECT_EQ(254, uint8_clamped_array.GetUint8(1));
 
   EXPECT_EQ(-1, int8_array.GetInt8(2));
   EXPECT_EQ(255, uint8_array.GetUint8(2));
   EXPECT_EQ(255, uint8_clamped_array.GetUint8(2));
 
   EXPECT_EQ(0, int8_array.GetInt8(3));
   EXPECT_EQ(0, uint8_array.GetUint8(3));
   EXPECT_EQ(0, uint8_clamped_array.GetUint8(3));
 
   EXPECT_EQ(1, int8_array.GetInt8(4));
   EXPECT_EQ(1, uint8_array.GetUint8(4));
   EXPECT_EQ(1, uint8_clamped_array.GetUint8(4));
 
   EXPECT_EQ(2, int8_array.GetInt8(5));
   EXPECT_EQ(2, uint8_array.GetUint8(5));
   EXPECT_EQ(2, uint8_clamped_array.GetUint8(5));
 
-  for (intptr_t i = 0 ; i < int8_array.Length(); ++i) {
+  for (intptr_t i = 0; i < int8_array.Length(); ++i) {
     EXPECT_EQ(int8_array.GetUint8(i), uint8_array.GetUint8(i));
   }
 
   int8_array.SetInt8(2, -123);
   uint8_array.SetUint8(0, 123);
-  for (intptr_t i = 0 ; i < int8_array.Length(); ++i) {
+  for (intptr_t i = 0; i < int8_array.Length(); ++i) {
     EXPECT_EQ(int8_array.GetInt8(i), uint8_array.GetInt8(i));
   }
 
   uint8_clamped_array.SetUint8(0, 123);
-  for (intptr_t i = 0 ; i < int8_array.Length(); ++i) {
+  for (intptr_t i = 0; i < int8_array.Length(); ++i) {
     EXPECT_EQ(int8_array.GetUint8(i), uint8_clamped_array.GetUint8(i));
   }
 }
 
 
 TEST_CASE(Script) {
   const char* url_chars = "builtin:test-case";
   const char* source_chars = "This will not compile.";
   const String& url = String::Handle(String::New(url_chars));
   const String& source = String::Handle(String::New(source_chars));
-  const Script& script = Script::Handle(Script::New(url,
-                                                    source,
-                                                    RawScript::kScriptTag));
+  const Script& script =
+      Script::Handle(Script::New(url, source, RawScript::kScriptTag));
   EXPECT(!script.IsNull());
   EXPECT(script.IsScript());
   String& str = String::Handle(script.url());
   EXPECT_EQ(17, str.Length());
   EXPECT_EQ('b', str.CharAt(0));
   EXPECT_EQ(':', str.CharAt(7));
   EXPECT_EQ('e', str.CharAt(16));
   str = script.Source();
   EXPECT_EQ(22, str.Length());
   EXPECT_EQ('T', str.CharAt(0));
   EXPECT_EQ('n', str.CharAt(10));
   EXPECT_EQ('.', str.CharAt(21));
 
   const char* kScript = "main() {}";
   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);
 }
 
 
 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"
+      /* 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;
   const char* line3 = strstr(line2, "\n") + 1;
   const char* line4 = strstr(line3, "\n") + 1;
   const char* line5 = strstr(line4, "\n") + 1;
 
   const int first_dart_line = 3;
   EXPECT(strstr(line3, "main") != NULL);
   const int last_dart_line = 5;
@@ skipping 10 matching lines @@
   int line_offset = 2;
   // Dart script starts with "main" on line 3.
   intptr_t col_offset = script_begin - line3;
   EXPECT(col_offset > 0);
 
   char* src_chars = strdup(script_begin);
   src_chars[script_length] = '\0';
 
   const String& url = String::Handle(String::New(url_chars));
   const String& source = String::Handle(String::New(src_chars));
-  const Script& script = Script::Handle(
-      Script::New(url, source, RawScript::kScriptTag));
+  const Script& script =
+      Script::Handle(Script::New(url, source, RawScript::kScriptTag));
   script.SetLocationOffset(line_offset, col_offset);
 
   String& str = String::Handle();
   str = script.GetLine(first_dart_line);
   EXPECT_STREQ("main() {", str.ToCString());
   str = script.GetLine(last_dart_line);
   EXPECT_STREQ("  }", str.ToCString());
 
   script.Tokenize(String::Handle(String::New("ABC")));
   // Tokens: 0: kIDENT, 1: kLPAREN, 2: kRPAREN, 3: kLBRACE, 4: kNEWLINE,
@@ skipping 69 matching lines @@
   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(thread, "a"));
-  LocalVariable* var_a =
-      new LocalVariable(TokenPosition::kNoSource,
-                        TokenPosition::kNoSource,
-                        a,
-                        dynamic_type);
+  LocalVariable* var_a = new LocalVariable(
+      TokenPosition::kNoSource, TokenPosition::kNoSource, a, dynamic_type);
   parent_scope->AddVariable(var_a);
 
   const String& b = String::ZoneHandle(Symbols::New(thread, "b"));
-  LocalVariable* var_b =
-      new LocalVariable(TokenPosition::kNoSource,
-                        TokenPosition::kNoSource,
-                        b,
-                        dynamic_type);
+  LocalVariable* var_b = new LocalVariable(
+      TokenPosition::kNoSource, TokenPosition::kNoSource, b, dynamic_type);
   local_scope->AddVariable(var_b);
 
   const String& c = String::ZoneHandle(Symbols::New(thread, "c"));
-  LocalVariable* var_c =
-      new LocalVariable(TokenPosition::kNoSource,
-                        TokenPosition::kNoSource,
-                        c,
-                        dynamic_type);
+  LocalVariable* var_c = new LocalVariable(
+      TokenPosition::kNoSource, TokenPosition::kNoSource, c, dynamic_type);
   parent_scope->AddVariable(var_c);
 
   bool test_only = false;  // Please, insert alias.
   var_a = local_scope->LookupVariable(a, test_only);
   EXPECT(var_a->is_captured());
   EXPECT_EQ(parent_scope_function_level, var_a->owner()->function_level());
   EXPECT(local_scope->LocalLookupVariable(a) == var_a);  // Alias.
 
   var_b = local_scope->LookupVariable(b, test_only);
   EXPECT(!var_b->is_captured());
   EXPECT_EQ(local_scope_function_level, var_b->owner()->function_level());
   EXPECT(local_scope->LocalLookupVariable(b) == var_b);
 
   test_only = true;  // Please, do not insert alias.
   var_c = local_scope->LookupVariable(c, test_only);
   EXPECT(!var_c->is_captured());
   EXPECT_EQ(parent_scope_function_level, var_c->owner()->function_level());
   // c is not in local_scope.
   EXPECT(local_scope->LocalLookupVariable(c) == NULL);
 
   test_only = false;  // Please, insert alias.
   var_c = local_scope->LookupVariable(c, test_only);
   EXPECT(var_c->is_captured());
 
-  EXPECT_EQ(3, local_scope->num_variables());  // a, b, and c alias.
+  EXPECT_EQ(3, local_scope->num_variables());         // a, b, and c alias.
   EXPECT_EQ(2, local_scope->NumCapturedVariables());  // a, c alias.
 
   const int first_parameter_index = 0;
   const int num_parameters = 0;
   const int first_frame_index = -1;
   bool found_captured_vars = false;
-  int next_frame_index = parent_scope->AllocateVariables(first_parameter_index,
-                                                         num_parameters,
-                                                         first_frame_index,
-                                                         NULL,
-                                                         &found_captured_vars);
+  int next_frame_index = parent_scope->AllocateVariables(
+      first_parameter_index, num_parameters, first_frame_index, NULL,
+      &found_captured_vars);
   EXPECT_EQ(first_frame_index, next_frame_index);  // a and c not in frame.
   const intptr_t parent_scope_context_level = 1;
   EXPECT_EQ(parent_scope_context_level, parent_scope->context_level());
   EXPECT(found_captured_vars);
 
   const intptr_t local_scope_context_level = 5;
   const ContextScope& context_scope = ContextScope::Handle(
       local_scope->PreserveOuterScope(local_scope_context_level));
   LocalScope* outer_scope = LocalScope::RestoreOuterScope(context_scope);
   EXPECT_EQ(2, outer_scope->num_variables());
@@ skipping 18 matching lines @@
 VM_TEST_CASE(Closure) {
   // Allocate the class first.
   const String& class_name = String::Handle(Symbols::New(thread, "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(thread, "foo_papa"));
-  parent = Function::New(parent_name, RawFunction::kRegularFunction,
-                         false, false, false, false, false, cls,
-                         TokenPosition::kMinSource);
+  parent =
+      Function::New(parent_name, RawFunction::kRegularFunction, false, false,
+                    false, false, false, cls, TokenPosition::kMinSource);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
 
   Function& function = Function::Handle();
   const String& function_name = String::Handle(Symbols::New(thread, "foo"));
-  function = Function::NewClosureFunction(
-      function_name, parent, TokenPosition::kMinSource);
+  function = Function::NewClosureFunction(function_name, parent,
+                                          TokenPosition::kMinSource);
   const Closure& closure = Closure::Handle(Closure::New(function, context));
   const Class& closure_class = Class::Handle(closure.clazz());
   EXPECT_EQ(closure_class.id(), kClosureCid);
   const Function& closure_function = Function::Handle(closure.function());
   EXPECT_EQ(closure_function.raw(), function.raw());
   const Context& closure_context = Context::Handle(closure.context());
   EXPECT_EQ(closure_context.raw(), context.raw());
 }
 
 
 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("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());
 }
 
 
 VM_TEST_CASE(CheckedHandle) {
@@ skipping 23 matching lines @@
 }
 
 
 static RawFunction* CreateFunction(const char* name) {
   Thread* thread = Thread::Current();
   const String& class_name = String::Handle(Symbols::New(thread, "ownerClass"));
   const String& lib_name = String::Handle(Symbols::New(thread, "ownerLibrary"));
   const Script& script = Script::Handle();
   const Class& owner_class =
       Class::Handle(CreateDummyClass(class_name, script));
-  const Library& owner_library =
-      Library::Handle(CreateDummyLibrary(lib_name));
+  const Library& owner_library = Library::Handle(CreateDummyLibrary(lib_name));
   owner_class.set_library(owner_library);
   const String& function_name = String::ZoneHandle(Symbols::New(thread, name));
-  return Function::New(function_name, RawFunction::kRegularFunction,
-                       true, false, false, false, false, owner_class,
+  return Function::New(function_name, RawFunction::kRegularFunction, true,
+                       false, false, false, false, owner_class,
                        TokenPosition::kMinSource);
 }
 
 
 // Test for Code and Instruction object creation.
 VM_TEST_CASE(Code) {
-  extern void GenerateIncrement(Assembler* assembler);
+  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 payload_start = instructions.PayloadStart();
   EXPECT_EQ(instructions.raw(), Instructions::FromPayloadStart(payload_start));
-  const Object& result = Object::Handle(
-      DartEntry::InvokeFunction(function, Array::empty_array()));
+  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.
 VM_TEST_CASE(CodeImmutability) {
-  extern void GenerateIncrement(Assembler* assembler);
+  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 payload_start = instructions.PayloadStart();
   EXPECT_EQ(instructions.raw(), Instructions::FromPayloadStart(payload_start));
   // Try writing into the generated code, expected to crash.
   *(reinterpret_cast<char*>(payload_start) + 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.
 VM_TEST_CASE(EmbedStringInCode) {
-  extern void GenerateEmbedStringInCode(Assembler* assembler, const char* str);
+  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 ++) {
+  for (int i = 0; i < expected_length; i++) {
     EXPECT(string_object.CharAt(i) == kHello[i]);
   }
 }
 
 
 // Test for Embedded Smi object in the instructions.
 VM_TEST_CASE(EmbedSmiInCode) {
-  extern void GenerateEmbedSmiInCode(Assembler* assembler, intptr_t value);
+  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.
 VM_TEST_CASE(EmbedSmiIn64BitCode) {
-  extern void GenerateEmbedSmiInCode(Assembler* assembler, intptr_t value);
+  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
 
 
 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);
 
-  extern void GenerateIncrement(Assembler* assembler);
+  extern void GenerateIncrement(Assembler * assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
   Code& code = Code::Handle(Code::FinalizeCode(
       Function::Handle(CreateFunction("Test_Code")), &_assembler_));
   code.set_exception_handlers(exception_handlers);
 
   // Verify the exception handler table entries by accessing them.
   const ExceptionHandlers& handlers =
       ExceptionHandlers::Handle(code.exception_handlers());
   EXPECT_EQ(kNumEntries, handlers.num_entries());
   RawExceptionHandlers::HandlerInfo info;
   handlers.GetHandlerInfo(0, &info);
   EXPECT_EQ(-1, handlers.OuterTryIndex(0));
   EXPECT_EQ(-1, info.outer_try_index);
   EXPECT_EQ(20u, handlers.HandlerPCOffset(0));
   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));
 }
 
 
 VM_TEST_CASE(PcDescriptors) {
   DescriptorList* builder = new DescriptorList(0);
 
   // kind, pc_offset, deopt_id, token_pos, try_index
-  builder->AddDescriptor(RawPcDescriptors::kOther,
-                         10, 1, TokenPosition(20), 1);
-  builder->AddDescriptor(RawPcDescriptors::kDeopt,
-                         20, 2, TokenPosition(30), 0);
-  builder->AddDescriptor(RawPcDescriptors::kOther,
-                         30, 3, TokenPosition(40), 1);
-  builder->AddDescriptor(RawPcDescriptors::kOther,
-                         10, 4, TokenPosition(40), 2);
-  builder->AddDescriptor(RawPcDescriptors::kOther,
-                         10, 5, TokenPosition(80), 3);
-  builder->AddDescriptor(RawPcDescriptors::kOther,
-                         80, 6, TokenPosition(150), 3);
+  builder->AddDescriptor(RawPcDescriptors::kOther, 10, 1, TokenPosition(20), 1);
+  builder->AddDescriptor(RawPcDescriptors::kDeopt, 20, 2, TokenPosition(30), 0);
+  builder->AddDescriptor(RawPcDescriptors::kOther, 30, 3, TokenPosition(40), 1);
+  builder->AddDescriptor(RawPcDescriptors::kOther, 10, 4, TokenPosition(40), 2);
+  builder->AddDescriptor(RawPcDescriptors::kOther, 10, 5, TokenPosition(80), 3);
+  builder->AddDescriptor(RawPcDescriptors::kOther, 80, 6, TokenPosition(150),
+                         3);
 
   PcDescriptors& descriptors = PcDescriptors::Handle();
   descriptors ^= builder->FinalizePcDescriptors(0);
 
-  extern void GenerateIncrement(Assembler* assembler);
+  extern void GenerateIncrement(Assembler * assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
   Code& code = Code::Handle(Code::FinalizeCode(
       Function::Handle(CreateFunction("Test_Code")), &_assembler_));
   code.set_pc_descriptors(descriptors);
 
   // Verify the PcDescriptor entries by accessing them.
   const PcDescriptors& pc_descs = PcDescriptors::Handle(code.pc_descriptors());
   PcDescriptors::Iterator iter(pc_descs, RawPcDescriptors::kAnyKind);
 
@@ skipping 26 matching lines @@
   EXPECT_EQ(RawPcDescriptors::kOther, iter.Kind());
 
   EXPECT_EQ(false, iter.MoveNext());
 }
 
 
 VM_TEST_CASE(PcDescriptorsLargeDeltas) {
   DescriptorList* builder = new DescriptorList(0);
 
   // kind, pc_offset, deopt_id, token_pos, try_index
-  builder->AddDescriptor(RawPcDescriptors::kOther,
-                         100, 1, TokenPosition(200), 1);
-  builder->AddDescriptor(RawPcDescriptors::kDeopt,
-                         200, 2, TokenPosition(300), 0);
-  builder->AddDescriptor(RawPcDescriptors::kOther,
-                         300, 3, TokenPosition(400), 1);
-  builder->AddDescriptor(RawPcDescriptors::kOther,
-                         100, 4, TokenPosition(0), 2);
-  builder->AddDescriptor(RawPcDescriptors::kOther,
-                         100, 5, TokenPosition(800), 3);
-  builder->AddDescriptor(RawPcDescriptors::kOther,
-                         800, 6, TokenPosition(150), 3);
+  builder->AddDescriptor(RawPcDescriptors::kOther, 100, 1, TokenPosition(200),
+                         1);
+  builder->AddDescriptor(RawPcDescriptors::kDeopt, 200, 2, TokenPosition(300),
+                         0);
+  builder->AddDescriptor(RawPcDescriptors::kOther, 300, 3, TokenPosition(400),
+                         1);
+  builder->AddDescriptor(RawPcDescriptors::kOther, 100, 4, TokenPosition(0), 2);
+  builder->AddDescriptor(RawPcDescriptors::kOther, 100, 5, TokenPosition(800),
+                         3);
+  builder->AddDescriptor(RawPcDescriptors::kOther, 800, 6, TokenPosition(150),
+                         3);
 
   PcDescriptors& descriptors = PcDescriptors::Handle();
   descriptors ^= builder->FinalizePcDescriptors(0);
 
-  extern void GenerateIncrement(Assembler* assembler);
+  extern void GenerateIncrement(Assembler * assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
   Code& code = Code::Handle(Code::FinalizeCode(
       Function::Handle(CreateFunction("Test_Code")), &_assembler_));
   code.set_pc_descriptors(descriptors);
 
   // Verify the PcDescriptor entries by accessing them.
   const PcDescriptors& pc_descs = PcDescriptors::Handle(code.pc_descriptors());
   PcDescriptors::Iterator iter(pc_descs, RawPcDescriptors::kAnyKind);
 
@@ skipping 23 matching lines @@
   EXPECT_EQ(3, iter.TryIndex());
   EXPECT_EQ(static_cast<uword>(800), iter.PcOffset());
   EXPECT_EQ(150, iter.TokenPos().value());
   EXPECT_EQ(RawPcDescriptors::kOther, iter.Kind());
 
   EXPECT_EQ(false, iter.MoveNext());
 }
 
 
 static RawClass* CreateTestClass(const char* name) {
-  const String& class_name = String::Handle(Symbols::New(Thread::Current(),
-                                                         name));
-  const Class& cls = Class::Handle(
-      CreateDummyClass(class_name, Script::Handle()));
+  const String& class_name =
+      String::Handle(Symbols::New(Thread::Current(), name));
+  const Class& cls =
+      Class::Handle(CreateDummyClass(class_name, Script::Handle()));
   return cls.raw();
 }
 
 
 static RawField* CreateTestField(const char* name) {
   const Class& cls = Class::Handle(CreateTestClass("global:"));
-  const String& field_name = String::Handle(Symbols::New(Thread::Current(),
-                                                         name));
-  const Field& field =
-      Field::Handle(Field::New(field_name, true, false, false, true, cls,
-          Object::dynamic_type(), TokenPosition::kMinSource));
+  const String& field_name =
+      String::Handle(Symbols::New(Thread::Current(), name));
+  const Field& field = Field::Handle(
+      Field::New(field_name, true, false, false, true, cls,
+                 Object::dynamic_type(), TokenPosition::kMinSource));
   return field.raw();
 }
 
 
 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()));
   ClassDictionaryIterator iterator(lib);
   int count = 0;
   Class& cls = Class::Handle();
   while (iterator.HasNext()) {
     cls = iterator.GetNextClass();
     EXPECT((cls.raw() == ae66.raw()) || (cls.raw() == re44.raw()));
     count++;
   }
   EXPECT(count == 2);
 }
 
 
 static RawFunction* GetDummyTarget(const char* name) {
-  const String& function_name = String::Handle(Symbols::New(Thread::Current(),
-                                                            name));
-  const Class& cls = Class::Handle(
-       CreateDummyClass(function_name, Script::Handle()));
+  const String& function_name =
+      String::Handle(Symbols::New(Thread::Current(), name));
+  const Class& cls =
+      Class::Handle(CreateDummyClass(function_name, Script::Handle()));
   const bool is_static = false;
   const bool is_const = false;
   const bool is_abstract = false;
   const bool is_external = false;
   const bool is_native = false;
-  return Function::New(function_name,
-                       RawFunction::kRegularFunction,
-                       is_static,
-                       is_const,
-                       is_abstract,
-                       is_external,
-                       is_native,
-                       cls,
+  return Function::New(function_name, RawFunction::kRegularFunction, is_static,
+                       is_const, is_abstract, is_external, is_native, cls,
                        TokenPosition::kMinSource);
 }
 
 
 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(thread, "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, false);
+  o1 = ICData::New(function, target_name, args_descriptor, id, num_args_tested,
+                   false);
   EXPECT_EQ(1, o1.NumArgsTested());
   EXPECT_EQ(id, o1.deopt_id());
   EXPECT_EQ(function.raw(), o1.Owner());
   EXPECT_EQ(0, o1.NumberOfChecks());
   EXPECT_EQ(target_name.raw(), o1.target_name());
   EXPECT_EQ(args_descriptor.raw(), o1.arguments_descriptor());
 
   const Function& target1 = Function::Handle(GetDummyTarget("Thun"));
   o1.AddReceiverCheck(kSmiCid, target1);
   EXPECT_EQ(1, o1.NumberOfChecks());
@@ skipping 36 matching lines @@
   o2.AddCheck(classes, target1);
   EXPECT_EQ(1, o2.NumberOfChecks());
   o2.GetCheckAt(0, &test_class_ids, &test_target);
   EXPECT_EQ(2, test_class_ids.length());
   EXPECT_EQ(kSmiCid, test_class_ids[0]);
   EXPECT_EQ(kSmiCid, test_class_ids[1]);
   EXPECT_EQ(target1.raw(), test_target.raw());
 
   // 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, false));
+  const ICData& scall_icdata = ICData::Handle(ICData::New(
+      function, target_name, args_descriptor, 57, kNumArgsChecked, false));
   scall_icdata.AddTarget(target1);
   EXPECT_EQ(target1.raw(), scall_icdata.GetTargetAt(0));
 }
 
 
 VM_TEST_CASE(SubtypeTestCache) {
   String& class_name = String::Handle(Symbols::New(thread, "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 Object& class_id_or_fun = Object::Handle(Smi::New(empty_class.id()));
   const TypeArguments& targ_0 = TypeArguments::Handle(TypeArguments::New(2));
   const TypeArguments& targ_1 = TypeArguments::Handle(TypeArguments::New(3));
   cache.AddCheck(class_id_or_fun, targ_0, targ_1, Bool::True());
   EXPECT_EQ(1, cache.NumberOfChecks());
   Object& test_class_id_or_fun = Object::Handle();
   TypeArguments& test_targ_0 = TypeArguments::Handle();
   TypeArguments& test_targ_1 = TypeArguments::Handle();
   Bool& test_result = Bool::Handle();
-  cache.GetCheck(
-      0, &test_class_id_or_fun, &test_targ_0, &test_targ_1, &test_result);
+  cache.GetCheck(0, &test_class_id_or_fun, &test_targ_0, &test_targ_1,
+                 &test_result);
   EXPECT_EQ(class_id_or_fun.raw(), test_class_id_or_fun.raw());
   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());
 }
 
 
 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);
 
 
 VM_TEST_CASE(EqualsIgnoringPrivate) {
   String& mangled_name = String::Handle();
   String& bare_name = String::Handle();
 
   // Simple matches.
   mangled_name = OneByteString::New("foo");
@@ skipping 94 matching lines @@
   const char* ext_bad_bare_str = "foo.named";
   String& ext_mangled_name = String::Handle();
   String& ext_bare_name = String::Handle();
   String& ext_bad_bare_name = String::Handle();
 
   mangled_name = OneByteString::New("foo@12345.name@12345");
   ext_mangled_name = ExternalOneByteString::New(
       reinterpret_cast<const uint8_t*>(ext_mangled_str),
       strlen(ext_mangled_str), NULL, NULL, Heap::kNew);
   EXPECT(ext_mangled_name.IsExternalOneByteString());
-  ext_bare_name = ExternalOneByteString::New(
-      reinterpret_cast<const uint8_t*>(ext_bare_str),
-      strlen(ext_bare_str), NULL, NULL, Heap::kNew);
+  ext_bare_name =
+      ExternalOneByteString::New(reinterpret_cast<const uint8_t*>(ext_bare_str),
+                                 strlen(ext_bare_str), NULL, NULL, Heap::kNew);
   EXPECT(ext_bare_name.IsExternalOneByteString());
   ext_bad_bare_name = ExternalOneByteString::New(
       reinterpret_cast<const uint8_t*>(ext_bad_bare_str),
       strlen(ext_bad_bare_str), NULL, NULL, Heap::kNew);
   EXPECT(ext_bad_bare_name.IsExternalOneByteString());
 
   // str1 - OneByteString, str2 - ExternalOneByteString.
   EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, ext_bare_name));
   EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, ext_bad_bare_name));
 
   // 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));
+  EXPECT(
+      !String::EqualsIgnoringPrivateKey(ext_mangled_name, ext_bad_bare_name));
 }
 
 
 VM_TEST_CASE(ArrayNew_Overflow_Crash) {
   Array::Handle(Array::New(Array::kMaxElements + 1));
 }
 
 
 TEST_CASE(StackTraceFormat) {
   const char* kScriptChars =
@@ skipping 31 matching lines @@
       "    fooHelper();\n"
       "  }\n"
       "}\n"
       "\n"
       "main() {\n"
       "  (() => new MyClass())();\n"
       "}\n";
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
   Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
-  EXPECT_ERROR(
-      result,
-      "Unhandled exception:\n"
-      "MyException\n"
-      "#0      baz (test-lib:2:3)\n"
-      "#1      _OtherClass._OtherClass._named (test-lib:7:5)\n"
-      "#2      globalVar= (test-lib:12:7)\n"
-      "#3      _bar (test-lib:16:3)\n"
-      "#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)");
+  EXPECT_ERROR(result,
+               "Unhandled exception:\n"
+               "MyException\n"
+               "#0      baz (test-lib:2:3)\n"
+               "#1      _OtherClass._OtherClass._named (test-lib:7:5)\n"
+               "#2      globalVar= (test-lib:12:7)\n"
+               "#3      _bar (test-lib:16:3)\n"
+               "#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)");
 }
 
 
 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();
@@ skipping 391 matching lines @@
   other_reference.set_referent(library);
   EXPECT_NE(reference.raw(), other_reference.raw());
   EXPECT_EQ(reference.referent(), other_reference.referent());
 
   Object& obj = Object::Handle(reference.raw());
   EXPECT(obj.IsMirrorReference());
 }
 
 
 static RawFunction* GetFunction(const Class& cls, const char* name) {
-  const Function& result = Function::Handle(cls.LookupDynamicFunction(
-      String::Handle(String::New(name))));
+  const Function& result = Function::Handle(
+      cls.LookupDynamicFunction(String::Handle(String::New(name))));
   EXPECT(!result.IsNull());
   return result.raw();
 }
 
 
 static RawFunction* GetStaticFunction(const Class& cls, const char* name) {
-  const Function& result = Function::Handle(cls.LookupStaticFunction(
-      String::Handle(String::New(name))));
+  const Function& result = Function::Handle(
+      cls.LookupStaticFunction(String::Handle(String::New(name))));
   EXPECT(!result.IsNull());
   return result.raw();
 }
 
 
 static RawField* GetField(const Class& cls, const char* name) {
   const Field& field =
       Field::Handle(cls.LookupField(String::Handle(String::New(name))));
   EXPECT(!field.IsNull());
   return field.raw();
@@ skipping 11 matching lines @@
 VM_TEST_CASE(FindClosureIndex) {
   // Allocate the class first.
   const String& class_name = String::Handle(Symbols::New(thread, "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(thread, "foo_papa"));
-  parent = Function::New(parent_name, RawFunction::kRegularFunction,
-                         false, false, false, false, false, cls,
-                         TokenPosition::kMinSource);
+  parent =
+      Function::New(parent_name, RawFunction::kRegularFunction, false, false,
+                    false, false, false, cls, TokenPosition::kMinSource);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
 
   Function& function = Function::Handle();
   const String& function_name = String::Handle(Symbols::New(thread, "foo"));
   function = Function::NewClosureFunction(function_name, parent,
                                           TokenPosition::kMinSource);
   // Add closure function to class.
   iso->AddClosureFunction(function);
 
@@ skipping 14 matching lines @@
 
 VM_TEST_CASE(FindInvocationDispatcherFunctionIndex) {
   const String& class_name = String::Handle(Symbols::New(thread, "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(thread, "foo_papa"));
-  parent = Function::New(parent_name, RawFunction::kRegularFunction,
-                         false, false, false, false, false, cls,
-                         TokenPosition::kMinSource);
+  parent =
+      Function::New(parent_name, RawFunction::kRegularFunction, false, false,
+                    false, false, false, cls, TokenPosition::kMinSource);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
   cls.Finalize();
 
   // Add invocation dispatcher.
   const String& invocation_dispatcher_name =
       String::Handle(Symbols::New(thread, "myMethod"));
   const Array& args_desc = Array::Handle(ArgumentsDescriptor::New(1));
   Function& invocation_dispatcher = Function::Handle();
-  invocation_dispatcher ^=
-      cls.GetInvocationDispatcher(invocation_dispatcher_name, args_desc,
-                                  RawFunction::kNoSuchMethodDispatcher,
-                                  true /* create_if_absent */);
+  invocation_dispatcher ^= cls.GetInvocationDispatcher(
+      invocation_dispatcher_name, args_desc,
+      RawFunction::kNoSuchMethodDispatcher, true /* create_if_absent */);
   EXPECT(!invocation_dispatcher.IsNull());
   // Get index to function.
   intptr_t invocation_dispatcher_index =
       cls.FindInvocationDispatcherFunctionIndex(invocation_dispatcher);
   // Expect a valid index.
   EXPECT_GE(invocation_dispatcher_index, 0);
   // Retrieve function through index.
   Function& invocation_dispatcher_from_index = Function::Handle();
   invocation_dispatcher_from_index ^=
       cls.InvocationDispatcherFunctionFromIndex(invocation_dispatcher_index);
   // Same function.
   EXPECT_EQ(invocation_dispatcher.raw(),
             invocation_dispatcher_from_index.raw());
   // Test function not found case.
   const Function& bad_function = Function::Handle(Function::null());
   intptr_t bad_invocation_dispatcher_index =
       cls.FindInvocationDispatcherFunctionIndex(bad_function);
   EXPECT_EQ(bad_invocation_dispatcher_index, -1);
 }
 
 
 static void PrintMetadata(const char* name, const Object& data) {
   if (data.IsError()) {
-    OS::Print("Error in metadata evaluation for %s: '%s'\n",
-              name,
+    OS::Print("Error in metadata evaluation for %s: '%s'\n", name,
               Error::Cast(data).ToErrorCString());
   }
   EXPECT(data.IsArray());
   const Array& metadata = Array::Cast(data);
   OS::Print("Metadata for %s has %" Pd " values:\n", name, metadata.Length());
   Object& elem = Object::Handle();
   for (int i = 0; i < metadata.Length(); i++) {
     elem = metadata.At(i);
     OS::Print("  %d: %s\n", i, elem.ToCString());
   }
@@ skipping 54 matching lines @@
 
   Function& func = Function::Handle(GetFunction(class_a, "aFunc"));
   res = lib.GetMetadata(func);
   PrintMetadata("A.aFunc", res);
 
   func = lib.LookupLocalFunction(String::Handle(Symbols::New(thread, "main")));
   EXPECT(!func.IsNull());
   res = lib.GetMetadata(func);
   PrintMetadata("main", res);
 
-  func = lib.LookupLocalFunction(String::Handle(Symbols::New(thread,
-                                                             "get:tlGetter")));
+  func = lib.LookupLocalFunction(
+      String::Handle(Symbols::New(thread, "get:tlGetter")));
   EXPECT(!func.IsNull());
   res = lib.GetMetadata(func);
   PrintMetadata("tlGetter", res);
 
   field = lib.LookupLocalField(String::Handle(Symbols::New(thread, "gVar")));
   EXPECT(!field.IsNull());
   res = lib.GetMetadata(field);
   PrintMetadata("gVar", res);
 }
 
@@ skipping 35 matching lines @@
       "  void test6(int a) {\n"
       "    return a > 1 ? a + 1 : a;\n"
       "  }\n"
       "}";
   TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT(ClassFinalizer::ProcessPendingClasses());
   const String& name = String::Handle(String::New(TestCase::url()));
   const Library& lib = Library::Handle(Library::LookupLibrary(thread, name));
   EXPECT(!lib.IsNull());
 
-  const Class& class_a = Class::Handle(
-      lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
-  const Class& class_b = Class::Handle(
-      lib.LookupClass(String::Handle(Symbols::New(thread, "B"))));
+  const Class& class_a =
+      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
+  const Class& class_b =
+      Class::Handle(lib.LookupClass(String::Handle(Symbols::New(thread, "B"))));
   const Function& a_test1 =
       Function::Handle(GetStaticFunction(class_a, "test1"));
   const Function& b_test1 =
       Function::Handle(GetStaticFunction(class_b, "test1"));
   const Function& a_test2 =
       Function::Handle(GetStaticFunction(class_a, "test2"));
   const Function& a_test3 =
       Function::Handle(GetStaticFunction(class_a, "test3"));
   const Function& a_test4 =
       Function::Handle(GetStaticFunction(class_a, "test4"));
   const Function& a_test5 =
       Function::Handle(GetStaticFunction(class_a, "test5"));
   const Function& b_test5 =
       Function::Handle(GetStaticFunction(class_b, "test5"));
-  const Function& a_test6 =
-      Function::Handle(GetFunction(class_a, "test6"));
-  const Function& b_test6 =
-      Function::Handle(GetFunction(class_b, "test6"));
+  const Function& a_test6 = Function::Handle(GetFunction(class_a, "test6"));
+  const Function& b_test6 = Function::Handle(GetFunction(class_b, "test6"));
 
   EXPECT_EQ(a_test1.SourceFingerprint(), b_test1.SourceFingerprint());
   EXPECT_NE(a_test1.SourceFingerprint(), a_test2.SourceFingerprint());
   EXPECT_NE(a_test2.SourceFingerprint(), a_test3.SourceFingerprint());
   EXPECT_NE(a_test3.SourceFingerprint(), a_test4.SourceFingerprint());
   EXPECT_NE(a_test4.SourceFingerprint(), a_test5.SourceFingerprint());
   EXPECT_EQ(a_test5.SourceFingerprint(), b_test5.SourceFingerprint());
   // Although a_test6's receiver type is different than b_test6's receiver type,
   // the fingerprints are identical. The token stream does not reflect the
   // receiver's type. This is not a problem, since we recognize functions
@@ skipping 24 matching lines @@
   // Run function A.b one time.
   Dart_Handle result = Dart_Invoke(lib, NewString("test"), 0, NULL);
   EXPECT_VALID(result);
 
   // With no breakpoint, function A.b is inlineable.
   const String& name = String::Handle(String::New(TestCase::url()));
   const Library& vmlib = Library::Handle(Library::LookupLibrary(thread, name));
   EXPECT(!vmlib.IsNull());
   const Class& class_a = Class::Handle(
       vmlib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
-  const Function& func_b =
-      Function::Handle(GetFunction(class_a, "b"));
+  const Function& func_b = Function::Handle(GetFunction(class_a, "b"));
   EXPECT(func_b.CanBeInlined());
 
   // After setting a breakpoint in a function A.b, it is no longer inlineable.
   result = Dart_SetBreakpoint(NewString(TestCase::url()), kBreakpointLine);
   EXPECT_VALID(result);
   EXPECT(!func_b.CanBeInlined());
 }
 
 
 VM_TEST_CASE(SpecialClassesHaveEmptyArrays) {
@@ skipping 26 matching lines @@
   EXPECT(array.IsArray());
 }
 
 
 #ifndef PRODUCT
 
 
 class ObjectAccumulator : public ObjectVisitor {
  public:
   explicit ObjectAccumulator(GrowableArray<Object*>* objects)
-      : objects_(objects) { }
-  virtual ~ObjectAccumulator() { }
+      : objects_(objects) {}
+  virtual ~ObjectAccumulator() {}
   virtual void VisitObject(RawObject* obj) {
     if (obj->IsPseudoObject()) {
       return;  // Cannot be wrapped in handles.
     }
     Object& handle = Object::Handle(obj);
     // Skip some common simple objects to run in reasonable time.
-    if (handle.IsString() ||
-        handle.IsArray() ||
-        handle.IsLiteralToken()) {
+    if (handle.IsString() || handle.IsArray() || handle.IsLiteralToken()) {
       return;
     }
     objects_->Add(&handle);
   }
+
  private:
   GrowableArray<Object*>* objects_;
 };
 
 
 VM_TEST_CASE(PrintJSON) {
   Heap* heap = Isolate::Current()->heap();
   heap->CollectAllGarbage();
   GrowableArray<Object*> objects;
   ObjectAccumulator acc(&objects);
@@ skipping 462 matching lines @@
 
 static void CheckConcatAll(const String* data[], intptr_t n) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   GrowableHandlePtrArray<const String> pieces(zone, n);
   const Array& array = Array::Handle(zone, Array::New(n));
   for (int i = 0; i < n; i++) {
     pieces.Add(*data[i]);
     array.SetAt(i, *data[i]);
   }
-  const String& res1 = String::Handle(zone, Symbols::FromConcatAll(thread,
-                                                                   pieces));
+  const String& res1 =
+      String::Handle(zone, Symbols::FromConcatAll(thread, pieces));
   const String& res2 = String::Handle(zone, String::ConcatAll(array));
   EXPECT(res1.Equals(res2));
 }
 
 
 VM_TEST_CASE(Symbols_FromConcatAll) {
   {
-    const String* data[3] = { &Symbols::FallThroughError(),
-                              &Symbols::Dot(),
-                              &Symbols::isPaused() };
+    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, '!' };
-    const String& two_str = String::Handle(String::FromUTF16(wide_chars,
-                                                             kWideCharsLen));
+    uint16_t wide_chars[kWideCharsLen] = {'H', 'e', 'l', 'l', 'o', 256, '!'};
+    const String& two_str =
+        String::Handle(String::FromUTF16(wide_chars, kWideCharsLen));
 
-    const String* data[3] = { &two_str, &Symbols::Dot(), &two_str };
+    const String* data[3] = {&two_str, &Symbols::Dot(), &two_str};
     CheckConcatAll(data, 3);
   }
 
   {
-    uint8_t characters[] = { 0xF6, 0xF1, 0xE9 };
+    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));
-    const String* data[3] = { &str, &Symbols::Dot(), &str };
+    const String* data[3] = {&str, &Symbols::Dot(), &str};
     CheckConcatAll(data, 3);
   }
 
   {
-    uint16_t characters[] =
-        { 'a', '\n', '\f', '\b', '\t', '\v', '\r', '\\', '$', 'z' };
+    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));
-    const String* data[3] = { &str, &Symbols::Dot(), &str };
+    const String* data[3] = {&str, &Symbols::Dot(), &str};
     CheckConcatAll(data, 3);
   }
 
   {
-    uint8_t characters1[] = { 0xF6, 0xF1, 0xE9 };
+    uint8_t characters1[] = {0xF6, 0xF1, 0xE9};
     intptr_t len1 = ARRAY_SIZE(characters1);
 
     const String& str1 = String::Handle(
         ExternalOneByteString::New(characters1, len1, NULL, NULL, Heap::kNew));
 
-    uint16_t characters2[] =
-        { 'a', '\n', '\f', '\b', '\t', '\v', '\r', '\\', '$', 'z' };
+    uint16_t characters2[] = {'a',  '\n', '\f', '\b', '\t',
+                              '\v', '\r', '\\', '$',  'z'};
     intptr_t len2 = ARRAY_SIZE(characters2);
 
     const String& str2 = String::Handle(
         ExternalTwoByteString::New(characters2, len2, NULL, NULL, Heap::kNew));
-    const String* data[3] = { &str1, &Symbols::Dot(), &str2 };
+    const String* data[3] = {&str1, &Symbols::Dot(), &str2};
     CheckConcatAll(data, 3);
   }
 
   {
     const String& empty = String::Handle(String::New(""));
-    const String* data[3] = { &Symbols::FallThroughError(),
-                              &empty,
-                              &Symbols::isPaused() };
+    const String* data[3] = {&Symbols::FallThroughError(), &empty,
+                             &Symbols::isPaused()};
     CheckConcatAll(data, 3);
   }
 }
 
 
 struct TestResult {
   const char* in;
   const char* out;
 };
 
 
 VM_TEST_CASE(String_ScrubName) {
   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"},
+      {"(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::ScrubName(test);
     EXPECT_STREQ(tests[i].out, result.ToCString());
   }
 }
 
 
 VM_TEST_CASE(String_EqualsUTF32) {
   // Regression test for Issue 27433. Checks that comparisons between Strings
   // and utf32 arrays happens after conversion to utf16 instead of utf32, as
   // required for proper canonicalization of string literals with a lossy
   // utf32->utf16 conversion.
-  int32_t char_codes[] = {
-    0, 0x0a, 0x0d, 0x7f, 0xff, 0xffff, 0xd800, 0xdc00, 0xdbff, 0xdfff
-  };
+  int32_t char_codes[] = {0,      0x0a,   0x0d,   0x7f,   0xff,
+                          0xffff, 0xd800, 0xdc00, 0xdbff, 0xdfff};
 
   const String& str =
       String::Handle(String::FromUTF32(char_codes, ARRAY_SIZE(char_codes)));
   EXPECT(str.Equals(char_codes, ARRAY_SIZE(char_codes)));
 }
 
 }  // namespace dart