// 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 <limits>
#include <memory>

#include "include/bin/dart_io_api.h"
#include "include/dart_api.h"

#include "bin/builtin.h"
#include "bin/vmservice_impl.h"

#include "platform/globals.h"
#include "platform/leak_sanitizer.h"
#include "platform/memory_sanitizer.h"
#include "platform/thread_sanitizer.h"
#include "platform/undefined_behavior_sanitizer.h"

#include "vm/class_finalizer.h"
#include "vm/closure_functions_cache.h"
#include "vm/code_descriptors.h"
#include "vm/compiler/assembler/assembler.h"
#include "vm/compiler/backend/il_test_helper.h"
#include "vm/compiler/compiler_state.h"
#include "vm/compiler/runtime_api.h"
#include "vm/dart_api_impl.h"
#include "vm/dart_entry.h"
#include "vm/debugger.h"
#include "vm/debugger_api_impl_test.h"
#include "vm/flags.h"
#include "vm/isolate.h"
#include "vm/message_handler.h"
#include "vm/object.h"
#include "vm/object_store.h"
#include "vm/resolver.h"
#include "vm/simulator.h"
#include "vm/symbols.h"
#include "vm/tagged_pointer.h"
#include "vm/unit_test.h"
#include "vm/zone_text_buffer.h"

namespace dart {

#define Z (thread->zone())

DECLARE_FLAG(bool, write_protect_code);

static ClassPtr CreateDummyClass(const String& class_name,
                                 const Script& script) {
  const Class& cls = Class::Handle(Class::New(
      Library::Handle(), class_name, script, TokenPosition::kNoSource));
  cls.set_is_synthesized_class_unsafe();  // Dummy class for testing.
  cls.set_is_declaration_loaded_unsafe();
  return cls.ptr();
}

ISOLATE_UNIT_TEST_CASE(Class) {
  // 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));

  // Class has no fields and no functions yet.
  EXPECT_EQ(Array::Handle(cls.fields()).Length(), 0);
  EXPECT_EQ(Array::Handle(cls.current_functions()).Length(), 0);

  // Setup the interfaces in the class.
  // Normally the class finalizer is resolving super types and interfaces
  // before finalizing the types in a class. A side-effect of this is setting
  // the is_implemented() bit on a class. We do that manually here.
  const Array& interfaces = Array::Handle(Array::New(2));
  Class& interface = Class::Handle();
  String& interface_name = String::Handle();
  interface_name = Symbols::New(thread, "Harley");
  interface = CreateDummyClass(interface_name, script);
  interfaces.SetAt(0, Type::Handle(Type::NewNonParameterizedType(interface)));
  interface.set_is_implemented_unsafe(true);
  interface_name = Symbols::New(thread, "Norton");
  interface = CreateDummyClass(interface_name, script);
  interfaces.SetAt(1, Type::Handle(Type::NewNonParameterizedType(interface)));
  interface.set_is_implemented_unsafe(true);
  cls.set_interfaces(interfaces);

  // 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));
  FunctionType& signature = FunctionType::Handle();
  Function& function = Function::Handle();
  String& function_name = String::Handle();
  function_name = Symbols::New(thread, "foo");
  signature = FunctionType::New();
  function = Function::New(signature, function_name,
                           UntaggedFunction::kRegularFunction, false, false,
                           false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(0, function);
  function_name = Symbols::New(thread, "bar");
  signature = FunctionType::New();
  function = Function::New(signature, function_name,
                           UntaggedFunction::kRegularFunction, false, false,
                           false, false, false, cls, TokenPosition::kMinSource);

  const int kNumFixedParameters = 2;
  const int kNumOptionalParameters = 3;
  const bool kAreOptionalPositional = true;
  signature.set_num_fixed_parameters(kNumFixedParameters);
  signature.SetNumOptionalParameters(kNumOptionalParameters,
                                     kAreOptionalPositional);
  functions.SetAt(1, function);

  function_name = Symbols::New(thread, "baz");
  signature = FunctionType::New();
  function = Function::New(signature, function_name,
                           UntaggedFunction::kRegularFunction, false, false,
                           false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(2, function);

  function_name = Symbols::New(thread, "Foo");
  signature = FunctionType::New();
  function = Function::New(signature, function_name,
                           UntaggedFunction::kRegularFunction, true, false,
                           false, false, false, cls, TokenPosition::kMinSource);

  functions.SetAt(3, function);
  function_name = Symbols::New(thread, "Bar");
  signature = FunctionType::New();
  function = Function::New(signature, function_name,
                           UntaggedFunction::kRegularFunction, true, false,
                           false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(4, function);
  function_name = Symbols::New(thread, "BaZ");
  signature = FunctionType::New();
  function = Function::New(signature, function_name,
                           UntaggedFunction::kRegularFunction, true, false,
                           false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(5, function);

  // Setup the functions in the class.
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    cls.SetFunctions(functions);
    // The class can now be finalized.
    cls.Finalize();
  }

  function_name = String::New("Foo");
  function = Resolver::ResolveDynamicFunction(Z, cls, function_name);
  EXPECT(function.IsNull());
  function = cls.LookupStaticFunction(function_name);
  EXPECT(!function.IsNull());
  EXPECT(function_name.Equals(String::Handle(function.name())));
  EXPECT_EQ(cls.ptr(), function.Owner());
  EXPECT(function.is_static());
  function_name = String::New("baz");
  function = Resolver::ResolveDynamicFunction(Z, cls, function_name);
  EXPECT(!function.IsNull());
  EXPECT(function_name.Equals(String::Handle(function.name())));
  EXPECT_EQ(cls.ptr(), function.Owner());
  EXPECT(!function.is_static());
  function = cls.LookupStaticFunction(function_name);
  EXPECT(function.IsNull());

  function_name = String::New("foo");
  function = Resolver::ResolveDynamicFunction(Z, cls, function_name);
  EXPECT(!function.IsNull());
  EXPECT_EQ(0, function.num_fixed_parameters());
  EXPECT(!function.HasOptionalParameters());

  function_name = String::New("bar");
  function = Resolver::ResolveDynamicFunction(Z, cls, function_name);
  EXPECT(!function.IsNull());
  EXPECT_EQ(kNumFixedParameters, function.num_fixed_parameters());
  EXPECT_EQ(kNumOptionalParameters, function.NumOptionalParameters());
}

ISOLATE_UNIT_TEST_CASE(SixtyThousandDartClasses) {
  auto zone = thread->zone();
  auto isolate_group = thread->isolate_group();
  auto class_table = isolate_group->class_table();

  const intptr_t start_cid = class_table->NumCids();
  const intptr_t num_classes = std::numeric_limits<uint16_t>::max() - start_cid;

  const Script& script = Script::Handle(zone);
  String& name = String::Handle(zone);
  Class& cls = Class::Handle(zone);
  Field& field = Field::Handle(zone);
  Array& fields = Array::Handle(zone);
  Instance& instance = Instance::Handle(zone);
  Instance& instance2 = Instance::Handle(zone);

  const auto& instances =
      GrowableObjectArray::Handle(zone, GrowableObjectArray::New());

  // Create many top-level classes - they should not consume 16-bit range.
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    for (intptr_t i = 0; i < (1 << 16); ++i) {
      cls = CreateDummyClass(Symbols::TopLevel(), script);
      cls.Finalize();
      EXPECT(cls.id() > std::numeric_limits<uint16_t>::max());
    }
  }

  // Create many concrete classes - they should occupy the entire 16-bit space.
  for (intptr_t i = 0; i < num_classes; ++i) {
    name = Symbols::New(thread, OS::SCreate(zone, "MyClass%" Pd "", i));
    cls = CreateDummyClass(name, script);
    EXPECT_EQ(start_cid + i, cls.id());

    const intptr_t num_fields = (i % 10);
    fields = Array::New(num_fields);
    for (intptr_t f = 0; f < num_fields; ++f) {
      name =
          Symbols::New(thread, OS::SCreate(zone, "myField_%" Pd "_%" Pd, i, f));
      field = Field::New(name, false, false, false, true, false, cls,
                         Object::dynamic_type(), TokenPosition::kMinSource,
                         TokenPosition::kMinSource);
      fields.SetAt(f, field);
    }

    cls.set_interfaces(Array::empty_array());
    {
      SafepointWriteRwLocker ml(thread,
                                thread->isolate_group()->program_lock());
      cls.SetFunctions(Array::empty_array());
      cls.SetFields(fields);
      cls.Finalize();
    }

    instance = Instance::New(cls);
    for (intptr_t f = 0; f < num_fields; ++f) {
      field ^= fields.At(f);
      name = Symbols::New(thread,
                          OS::SCreate(zone, "myFieldValue_%" Pd "_%" Pd, i, f));
      instance.SetField(field, name);
    }
    instances.Add(instance);
  }
  EXPECT_EQ((1 << 16) - 1, class_table->NumCids());

  // Ensure GC runs and can recognize all those new instances.
  isolate_group->heap()->CollectAllGarbage();

  // Ensure the instances are what we expect.
  for (intptr_t i = 0; i < num_classes; ++i) {
    instance ^= instances.At(i);
    cls = instance.clazz();
    fields = cls.fields();

    name = cls.Name();
    EXPECT(strstr(name.ToCString(), OS::SCreate(zone, "MyClass%" Pd "", i)) !=
           0);
    EXPECT_EQ((i % 10), fields.Length());

    for (intptr_t f = 0; f < fields.Length(); ++f) {
      field ^= fields.At(f);
      instance2 ^= instance.GetField(field);
      EXPECT(strstr(instance2.ToCString(),
                    OS::SCreate(zone, "myFieldValue_%" Pd "_%" Pd, i, f)) != 0);
    }
  }
}

ISOLATE_UNIT_TEST_CASE(TypeArguments) {
  const Type& type1 = Type::Handle(Type::Double());
  const Type& type2 = Type::Handle(Type::StringType());
  const TypeArguments& type_arguments1 =
      TypeArguments::Handle(TypeArguments::New(2));
  type_arguments1.SetTypeAt(0, type1);
  type_arguments1.SetTypeAt(1, type2);
  const TypeArguments& type_arguments2 =
      TypeArguments::Handle(TypeArguments::New(2));
  type_arguments2.SetTypeAt(0, type1);
  type_arguments2.SetTypeAt(1, type2);
  EXPECT_NE(type_arguments1.ptr(), type_arguments2.ptr());
  OS::PrintErr("1: %s\n", type_arguments1.ToCString());
  OS::PrintErr("2: %s\n", type_arguments2.ToCString());
  EXPECT(type_arguments1.Equals(type_arguments2));
  TypeArguments& type_arguments3 = TypeArguments::Handle();
  type_arguments1.Canonicalize(thread);
  type_arguments3 ^= type_arguments2.Canonicalize(thread);
  EXPECT_EQ(type_arguments1.ptr(), type_arguments3.ptr());
}

TEST_CASE(Class_EndTokenPos) {
  const char* kScript =
      "\n"
      "class A {\n"
      "  /**\n"
      "   * Description of foo().\n"
      "   */\n"
      "  foo(a) { return '''\"}'''; }\n"
      "  // }\n"
      "  var bar = '\\'}';\n"
      "}\n";
  Dart_Handle lib_h = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib_h);
  TransitionNativeToVM transition(thread);
  Library& lib = Library::Handle();
  lib ^= Api::UnwrapHandle(lib_h);
  EXPECT(!lib.IsNull());
  const Class& cls =
      Class::Handle(lib.LookupClass(String::Handle(String::New("A"))));
  EXPECT(!cls.IsNull());
  const Error& error = Error::Handle(cls.EnsureIsFinalized(thread));
  EXPECT(error.IsNull());
  const TokenPosition end_token_pos = cls.end_token_pos();
  const Script& scr = Script::Handle(cls.script());
  intptr_t line;
  intptr_t col;
  EXPECT(scr.GetTokenLocation(end_token_pos, &line, &col));
  EXPECT_EQ(9, line);
  EXPECT_EQ(1, col);
}

ISOLATE_UNIT_TEST_CASE(InstanceClass) {
  // Allocate the class first.
  String& class_name = String::Handle(Symbols::New(thread, "EmptyClass"));
  Script& script = Script::Handle();
  const Class& empty_class =
      Class::Handle(CreateDummyClass(class_name, script));

  // EmptyClass has no fields and no functions.
  EXPECT_EQ(Array::Handle(empty_class.fields()).Length(), 0);
  EXPECT_EQ(Array::Handle(empty_class.current_functions()).Length(), 0);

  ClassFinalizer::FinalizeTypesInClass(empty_class);
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    empty_class.Finalize();
  }

  EXPECT_EQ(kObjectAlignment, empty_class.host_instance_size());
  Instance& instance = Instance::Handle(Instance::New(empty_class));
  EXPECT_EQ(empty_class.ptr(), instance.clazz());

  class_name = Symbols::New(thread, "OneFieldClass");
  const Class& one_field_class =
      Class::Handle(CreateDummyClass(class_name, script));

  // No fields, functions, or super type for the OneFieldClass.
  EXPECT_EQ(Array::Handle(empty_class.fields()).Length(), 0);
  EXPECT_EQ(Array::Handle(empty_class.current_functions()).Length(), 0);
  EXPECT_EQ(empty_class.super_type(), AbstractType::null());
  ClassFinalizer::FinalizeTypesInClass(one_field_class);

  const Array& one_fields = Array::Handle(Array::New(1));
  const String& field_name = String::Handle(Symbols::New(thread, "the_field"));
  const Field& field = Field::Handle(
      Field::New(field_name, false, false, false, true, false, one_field_class,
                 Object::dynamic_type(), TokenPosition::kMinSource,
                 TokenPosition::kMinSource));
  one_fields.SetAt(0, field);
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    one_field_class.SetFields(one_fields);
    one_field_class.Finalize();
  }
  intptr_t header_size = sizeof(UntaggedObject);
  EXPECT_EQ(Utils::RoundUp((header_size + (1 * kWordSize)), kObjectAlignment),
            one_field_class.host_instance_size());
  EXPECT_EQ(header_size, field.HostOffset());
  EXPECT(!one_field_class.is_implemented());
  one_field_class.set_is_implemented_unsafe(true);
  EXPECT(one_field_class.is_implemented());
}

ISOLATE_UNIT_TEST_CASE(Smi) {
  const Smi& smi = Smi::Handle(Smi::New(5));
  Object& smi_object = Object::Handle(smi.ptr());
  EXPECT(smi.IsSmi());
  EXPECT(smi_object.IsSmi());
  EXPECT(smi_object.ptr()->IsSmi());
  EXPECT_EQ(5, smi.Value());
  const Object& object = Object::Handle();
  EXPECT(!object.IsSmi());
  EXPECT(!object.ptr()->IsSmi());
  smi_object = Object::null();
  EXPECT(!smi_object.IsSmi());
  EXPECT(!smi_object.ptr()->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.
#if defined(ARCH_IS_64_BIT) && !defined(DART_COMPRESSED_POINTERS)
  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

  EXPECT_EQ(5, smi.Value());
  EXPECT_EQ(5.0, smi.ToDouble());
  EXPECT_EQ(5, Integer::Value(smi.ptr()));

  Smi& a = Smi::Handle(Smi::New(5));
  Smi& b = Smi::Handle(Smi::New(3));
  EXPECT_EQ(1, a.CompareWith(b));
  EXPECT_EQ(-1, b.CompareWith(a));
  EXPECT_EQ(0, a.CompareWith(a));

  Smi& c = Smi::Handle(Smi::New(-1));

  Mint& mint1 = Mint::Handle();
  mint1 ^= Integer::New(0x7FFFFFFF00000100);
  Mint& mint2 = Mint::Handle();
  mint2 ^= Integer::New(-0x7FFFFFFF00000100);
  EXPECT_EQ(-1, a.CompareWith(mint1));
  EXPECT_EQ(1, a.CompareWith(mint2));
  EXPECT_EQ(-1, c.CompareWith(mint1));
  EXPECT_EQ(1, c.CompareWith(mint2));
}

ISOLATE_UNIT_TEST_CASE(StringCompareTo) {
  const String& abcd = String::Handle(String::New("abcd"));
  const String& abce = String::Handle(String::New("abce"));
  EXPECT_EQ(0, abcd.CompareTo(abcd));
  EXPECT_EQ(0, abce.CompareTo(abce));
  EXPECT(abcd.CompareTo(abce) < 0);
  EXPECT(abce.CompareTo(abcd) > 0);

  const int kMonkeyLen = 4;
  const uint8_t monkey_utf8[kMonkeyLen] = {0xf0, 0x9f, 0x90, 0xb5};
  const String& monkey_face =
      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));
  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 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);
  EXPECT(abcd.CompareTo(domino) < 0);
  EXPECT(abce.CompareTo(domino) < 0);
  EXPECT(domino.CompareTo(abcd) > 0);
  EXPECT(domino.CompareTo(abcd) > 0);
  EXPECT(monkey_face.CompareTo(abce) > 0);
  EXPECT(monkey_face.CompareTo(abce) > 0);
}

ISOLATE_UNIT_TEST_CASE(StringEncodeIRI) {
  const char* kInput =
      "file:///usr/local/johnmccutchan/workspace/dart-repo/dart/test.dart";
  const char* kOutput =
      "file%3A%2F%2F%2Fusr%2Flocal%2Fjohnmccutchan%2Fworkspace%2F"
      "dart-repo%2Fdart%2Ftest.dart";
  const String& input = String::Handle(String::New(kInput));
  const char* encoded = String::EncodeIRI(input);
  EXPECT(strcmp(encoded, kOutput) == 0);
}

ISOLATE_UNIT_TEST_CASE(StringDecodeIRI) {
  const char* kOutput =
      "file:///usr/local/johnmccutchan/workspace/dart-repo/dart/test.dart";
  const char* kInput =
      "file%3A%2F%2F%2Fusr%2Flocal%2Fjohnmccutchan%2Fworkspace%2F"
      "dart-repo%2Fdart%2Ftest.dart";
  const String& input = String::Handle(String::New(kInput));
  const String& output = String::Handle(String::New(kOutput));
  const String& decoded = String::Handle(String::DecodeIRI(input));
  EXPECT(output.Equals(decoded));
}

ISOLATE_UNIT_TEST_CASE(StringDecodeIRIInvalid) {
  String& input = String::Handle();
  input = String::New("file%");
  String& decoded = String::Handle();
  decoded = String::DecodeIRI(input);
  EXPECT(decoded.IsNull());
  input = String::New("file%3");
  decoded = String::DecodeIRI(input);
  EXPECT(decoded.IsNull());
  input = String::New("file%3g");
  decoded = String::DecodeIRI(input);
  EXPECT(decoded.IsNull());
}

ISOLATE_UNIT_TEST_CASE(StringIRITwoByte) {
  const intptr_t kInputLen = 3;
  const uint16_t kInput[kInputLen] = {'x', '/', 256};
  const String& input = String::Handle(String::FromUTF16(kInput, kInputLen));
  const intptr_t kOutputLen = 10;
  const uint16_t kOutput[kOutputLen] = {'x', '%', '2', 'F', '%',
                                        'C', '4', '%', '8', '0'};
  const String& output = String::Handle(String::FromUTF16(kOutput, kOutputLen));
  const String& encoded = String::Handle(String::New(String::EncodeIRI(input)));
  EXPECT(output.Equals(encoded));
  const String& decoded = String::Handle(String::DecodeIRI(output));
  EXPECT(input.Equals(decoded));
}

ISOLATE_UNIT_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) || defined(DART_COMPRESSED_POINTERS)
  {
    Mint& med = Mint::Handle();
    EXPECT(med.IsNull());
    int64_t v = 0x100000000;
    med ^= Integer::New(v);
    EXPECT_EQ(v, med.Value());
    EXPECT_EQ(v, Integer::Value(med.ptr()));
    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());
    EXPECT_EQ(1, i.Value());
    i = Integer::NewCanonical(mint1_str);
    EXPECT(i.IsMint());
    EXPECT_EQ(2147419168, i.Value());
    i = Integer::NewCanonical(mint2_str);
    EXPECT(i.IsMint());
    EXPECT_EQ(-2147419168, i.Value());
  }
  Integer& i = Integer::Handle(Integer::New(0x100000000));
  EXPECT(i.IsMint());
  EXPECT(i.ptr()->IsMint());
  EXPECT(!i.IsSmi());
  EXPECT(!i.ptr()->IsSmi());
  EXPECT(i.Value() != 0);
  Integer& i1 = Integer::Handle(Integer::New(0x101000000000));
  Mint& i2 = Mint::Handle();
  i2 ^= Integer::New(0x101000000000);
  EXPECT(i1.Equals(i2));
  EXPECT(!i.Equals(i1));
  int64_t test = 0x101000000000;
  EXPECT_EQ(test, i2.Value());
  EXPECT_EQ(test, Integer::Value(i2.ptr()));

  Mint& a = Mint::Handle();
  a ^= Integer::New(0x500000000);
  Mint& b = Mint::Handle();
  b ^= Integer::New(0x300000000);
  EXPECT_EQ(1, a.CompareWith(b));
  EXPECT_EQ(-1, b.CompareWith(a));
  EXPECT_EQ(0, a.CompareWith(a));

  Mint& c = Mint::Handle();
  c ^= Integer::New(-0x300000000);
  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));

  int64_t mint_value = 0x7FFFFFFF00000064;
  const String& mint_string = String::Handle(String::New("0x7FFFFFFF00000064"));
  Mint& mint1 = Mint::Handle();
  mint1 ^= Integer::NewCanonical(mint_string);
  Mint& mint2 = Mint::Handle();
  mint2 ^= Integer::NewCanonical(mint_string);
  EXPECT_EQ(mint1.Value(), mint_value);
  EXPECT_EQ(mint2.Value(), mint_value);
  EXPECT_EQ(mint1.ptr(), mint2.ptr());
#endif
}

ISOLATE_UNIT_TEST_CASE(Double) {
  {
    const double dbl_const = 5.0;
    const Double& dbl = Double::Handle(Double::New(dbl_const));
    Object& dbl_object = Object::Handle(dbl.ptr());
    EXPECT(dbl.IsDouble());
    EXPECT(dbl_object.IsDouble());
    EXPECT_EQ(dbl_const, dbl.value());
  }

  {
    const double dbl_const = -5.0;
    const Double& dbl = Double::Handle(Double::New(dbl_const));
    Object& dbl_object = Object::Handle(dbl.ptr());
    EXPECT(dbl.IsDouble());
    EXPECT(dbl_object.IsDouble());
    EXPECT_EQ(dbl_const, dbl.value());
  }

  {
    const double dbl_const = 0.0;
    const Double& dbl = Double::Handle(Double::New(dbl_const));
    Object& dbl_object = Object::Handle(dbl.ptr());
    EXPECT(dbl.IsDouble());
    EXPECT(dbl_object.IsDouble());
    EXPECT_EQ(dbl_const, dbl.value());
  }

  {
    const double dbl_const = 5.0;
    const String& dbl_str = String::Handle(String::New("5.0"));
    const Double& dbl1 = Double::Handle(Double::NewCanonical(dbl_const));
    const Double& dbl2 = Double::Handle(Double::NewCanonical(dbl_const));
    const Double& dbl3 = Double::Handle(Double::NewCanonical(dbl_str));
    EXPECT_EQ(dbl_const, dbl1.value());
    EXPECT_EQ(dbl_const, dbl2.value());
    EXPECT_EQ(dbl_const, dbl3.value());
    EXPECT_EQ(dbl1.ptr(), dbl2.ptr());
    EXPECT_EQ(dbl1.ptr(), dbl3.ptr());
  }

  {
    const double dbl_const = 2.0;
    const Double& dbl1 = Double::Handle(Double::New(dbl_const));
    const Double& dbl2 = Double::Handle(Double::New(dbl_const));
    EXPECT(dbl1.OperatorEquals(dbl2));
    EXPECT(dbl1.IsIdenticalTo(dbl2));
    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)));
    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());

    const String& dbl_str1 = String::Handle(String::New("2.0"));
    const Double& dbl1 = Double::Handle(Double::New(dbl_str1));
    EXPECT_EQ(2.0, dbl1.value());

    // Disallow legacy form.
    const String& dbl_str2 = String::Handle(String::New("2.0d"));
    const Double& dbl2 = Double::Handle(Double::New(dbl_str2));
    EXPECT(dbl2.IsNull());
  }
}

ISOLATE_UNIT_TEST_CASE(Integer) {
  Integer& i = Integer::Handle();
  i = Integer::NewCanonical(String::Handle(String::New("12")));
  EXPECT(i.IsSmi());
  i = Integer::NewCanonical(String::Handle(String::New("-120")));
  EXPECT(i.IsSmi());
  i = Integer::NewCanonical(String::Handle(String::New("0")));
  EXPECT(i.IsSmi());
  i = Integer::NewCanonical(
      String::Handle(String::New("12345678901234567890")));
  EXPECT(i.IsNull());
  i = Integer::NewCanonical(
      String::Handle(String::New("-12345678901234567890111222")));
  EXPECT(i.IsNull());
}

ISOLATE_UNIT_TEST_CASE(String) {
  const char* kHello = "Hello World!";
  int32_t hello_len = strlen(kHello);
  const String& str = String::Handle(String::New(kHello));
  EXPECT(str.IsInstance());
  EXPECT(str.IsString());
  EXPECT(str.IsOneByteString());
  EXPECT(!str.IsTwoByteString());
  EXPECT(!str.IsNumber());
  EXPECT_EQ(hello_len, str.Length());
  EXPECT_EQ('H', str.CharAt(0));
  EXPECT_EQ('e', str.CharAt(1));
  EXPECT_EQ('l', str.CharAt(2));
  EXPECT_EQ('l', str.CharAt(3));
  EXPECT_EQ('o', str.CharAt(4));
  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));
  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 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));
  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 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 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 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 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));
  }

  // Check that String's identity hash and hashCode are the same.
  {
    for (auto str : {"Hello", "Hell\xC3\x98"}) {
      const String& s = String::Handle(String::New(str));
      const String& s2 = String::Handle(String::New(str));
      EXPECT_EQ(s.Hash(),
                static_cast<uword>(
                    Integer::Handle(s2.IdentityHashCode(thread)).Value()));
    }
  }
}

ISOLATE_UNIT_TEST_CASE(StringFormat) {
  const char* hello_str = "Hello World!";
  const String& str =
      String::Handle(String::NewFormatted("Hello %s!", "World"));
  EXPECT(str.IsInstance());
  EXPECT(str.IsString());
  EXPECT(str.IsOneByteString());
  EXPECT(!str.IsTwoByteString());
  EXPECT(!str.IsNumber());
  EXPECT(str.Equals(hello_str));
}

ISOLATE_UNIT_TEST_CASE(StringConcat) {
  // Create strings from concatenated 1-byte empty strings.
  {
    const String& empty1 = String::Handle(String::New(""));
    EXPECT(empty1.IsOneByteString());
    EXPECT_EQ(0, empty1.Length());

    const String& empty2 = String::Handle(String::New(""));
    EXPECT(empty2.IsOneByteString());
    EXPECT_EQ(0, empty2.Length());

    // Concat

    const String& empty3 = String::Handle(String::Concat(empty1, empty2));
    EXPECT(empty3.IsOneByteString());
    EXPECT_EQ(0, empty3.Length());

    // ConcatAll

    const Array& array1 = Array::Handle(Array::New(0));
    EXPECT_EQ(0, array1.Length());
    const String& empty4 = String::Handle(String::ConcatAll(array1));
    EXPECT_EQ(0, empty4.Length());

    const Array& array2 = Array::Handle(Array::New(10));
    EXPECT_EQ(10, array2.Length());
    for (int i = 0; i < array2.Length(); ++i) {
      array2.SetAt(i, String::Handle(String::New("")));
    }
    const String& empty5 = String::Handle(String::ConcatAll(array2));
    EXPECT(empty5.IsOneByteString());
    EXPECT_EQ(0, empty5.Length());

    const Array& array3 = Array::Handle(Array::New(123));
    EXPECT_EQ(123, array3.Length());

    const String& empty6 = String::Handle(String::New(""));
    EXPECT(empty6.IsOneByteString());
    EXPECT_EQ(0, empty6.Length());
    for (int i = 0; i < array3.Length(); ++i) {
      array3.SetAt(i, empty6);
    }
    const String& empty7 = String::Handle(String::ConcatAll(array3));
    EXPECT(empty7.IsOneByteString());
    EXPECT_EQ(0, empty7.Length());
  }

  // Concatenated empty and non-empty 1-byte strings.
  {
    const String& str1 = String::Handle(String::New(""));
    EXPECT_EQ(0, str1.Length());
    EXPECT(str1.IsOneByteString());

    const String& str2 = String::Handle(String::New("one"));
    EXPECT(str2.IsOneByteString());
    EXPECT_EQ(3, str2.Length());

    // Concat

    const String& str3 = String::Handle(String::Concat(str1, str2));
    EXPECT(str3.IsOneByteString());
    EXPECT_EQ(3, str3.Length());
    EXPECT(str3.Equals(str2));

    const String& str4 = String::Handle(String::Concat(str2, str1));
    EXPECT(str4.IsOneByteString());
    EXPECT_EQ(3, str4.Length());
    EXPECT(str4.Equals(str2));

    // ConcatAll

    const Array& array1 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array1.Length());
    array1.SetAt(0, str1);
    array1.SetAt(1, str2);
    const String& str5 = String::Handle(String::ConcatAll(array1));
    EXPECT(str5.IsOneByteString());
    EXPECT_EQ(3, str5.Length());
    EXPECT(str5.Equals(str2));

    const Array& array2 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array2.Length());
    array2.SetAt(0, str1);
    array2.SetAt(1, str2);
    const String& str6 = String::Handle(String::ConcatAll(array2));
    EXPECT(str6.IsOneByteString());
    EXPECT_EQ(3, 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.IsOneByteString());
    EXPECT_EQ(6, str7.Length());
    EXPECT(str7.Equals("oneone"));
    EXPECT(!str7.Equals("oneoneone"));
  }

  // Create a string by concatenating non-empty 1-byte strings.
  {
    const char* one = "one";
    intptr_t one_len = strlen(one);
    const String& onestr = String::Handle(String::New(one));
    EXPECT(onestr.IsOneByteString());
    EXPECT_EQ(one_len, onestr.Length());

    const char* three = "three";
    intptr_t three_len = strlen(three);
    const String& threestr = String::Handle(String::New(three));
    EXPECT(threestr.IsOneByteString());
    EXPECT_EQ(three_len, threestr.Length());

    // Concat

    const String& str3 = String::Handle(String::Concat(onestr, threestr));
    EXPECT(str3.IsOneByteString());
    const char* one_three = "onethree";
    EXPECT(str3.Equals(one_three));

    const String& str4 = String::Handle(String::Concat(threestr, onestr));
    EXPECT(str4.IsOneByteString());
    const char* three_one = "threeone";
    intptr_t three_one_len = strlen(three_one);
    EXPECT_EQ(three_one_len, str4.Length());
    EXPECT(str4.Equals(three_one));

    // ConcatAll

    const Array& array1 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array1.Length());
    array1.SetAt(0, onestr);
    array1.SetAt(1, threestr);
    const String& str5 = String::Handle(String::ConcatAll(array1));
    EXPECT(str5.IsOneByteString());
    intptr_t one_three_len = strlen(one_three);
    EXPECT_EQ(one_three_len, str5.Length());
    EXPECT(str5.Equals(one_three));

    const Array& array2 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array2.Length());
    array2.SetAt(0, threestr);
    array2.SetAt(1, onestr);
    const String& str6 = String::Handle(String::ConcatAll(array2));
    EXPECT(str6.IsOneByteString());
    EXPECT_EQ(three_one_len, str6.Length());
    EXPECT(str6.Equals(three_one));

    const Array& array3 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array3.Length());
    array3.SetAt(0, onestr);
    array3.SetAt(1, threestr);
    array3.SetAt(2, onestr);
    const String& str7 = String::Handle(String::ConcatAll(array3));
    EXPECT(str7.IsOneByteString());
    const char* one_three_one = "onethreeone";
    intptr_t one_three_one_len = strlen(one_three_one);
    EXPECT_EQ(one_three_one_len, str7.Length());
    EXPECT(str7.Equals(one_three_one));

    const Array& array4 = Array::Handle(Array::New(3));
    EXPECT_EQ(3, array4.Length());
    array4.SetAt(0, threestr);
    array4.SetAt(1, onestr);
    array4.SetAt(2, threestr);
    const String& str8 = String::Handle(String::ConcatAll(array4));
    EXPECT(str8.IsOneByteString());
    const char* three_one_three = "threeonethree";
    intptr_t three_one_three_len = strlen(three_one_three);
    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};
    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());
    EXPECT(str3.Equals(str2));

    const String& str4 = String::Handle(String::Concat(str2, str1));
    EXPECT(str4.IsTwoByteString());
    EXPECT_EQ(two_len, str4.Length());
    EXPECT(str4.Equals(str2));

    // ConcatAll

    const Array& array1 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array1.Length());
    array1.SetAt(0, str1);
    array1.SetAt(1, str2);
    const String& str5 = String::Handle(String::ConcatAll(array1));
    EXPECT(str5.IsTwoByteString());
    EXPECT_EQ(two_len, str5.Length());
    EXPECT(str5.Equals(str2));

    const Array& array2 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array2.Length());
    array2.SetAt(0, str1);
    array2.SetAt(1, str2);
    const String& str6 = String::Handle(String::ConcatAll(array2));
    EXPECT(str6.IsTwoByteString());
    EXPECT_EQ(two_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());
    EXPECT_EQ(two_len * 2, str7.Length());
    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};
    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};
    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};
    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};
    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);
    const String& str3 = String::Handle(String::ConcatAll(array1));
    EXPECT(str3.IsTwoByteString());
    EXPECT_EQ(one_two_len, str3.Length());
    EXPECT(str3.Equals(one_two, one_two_len));

    const Array& array2 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array2.Length());
    array2.SetAt(0, str2);
    array2.SetAt(1, str1);
    const String& str4 = String::Handle(String::ConcatAll(array2));
    EXPECT(str4.IsTwoByteString());
    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};
    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};
    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 empty 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};
    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());
    EXPECT(str3.Equals(str2));

    const String& str4 = String::Handle(String::Concat(str2, str1));
    EXPECT(str4.IsTwoByteString());
    EXPECT_EQ(expected_len, str4.Length());
    EXPECT(str4.Equals(str2));

    // ConcatAll

    const Array& array1 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array1.Length());
    array1.SetAt(0, str1);
    array1.SetAt(1, str2);
    const String& str5 = String::Handle(String::ConcatAll(array1));
    EXPECT(str5.IsTwoByteString());
    EXPECT_EQ(expected_len, str5.Length());
    EXPECT(str5.Equals(str2));

    const Array& array2 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array2.Length());
    array2.SetAt(0, str1);
    array2.SetAt(1, str2);
    const String& str6 = String::Handle(String::ConcatAll(array2));
    EXPECT(str6.IsTwoByteString());
    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};
    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};
    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());

    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};
    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};
    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());
    array1.SetAt(0, onestr);
    array1.SetAt(1, twostr);
    const String& str3 = String::Handle(String::ConcatAll(array1));
    EXPECT(str3.IsTwoByteString());
    EXPECT_EQ((one_two_len * 2), str3.Length());
    EXPECT(str3.Equals(one_two_str));

    const Array& array2 = Array::Handle(Array::New(2));
    EXPECT_EQ(2, array2.Length());
    array2.SetAt(0, twostr);
    array2.SetAt(1, onestr);
    const String& str4 = String::Handle(String::ConcatAll(array2));
    EXPECT(str4.IsTwoByteString());
    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};
    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};
    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'};
    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};
    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};
    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'};
    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'};
    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};
    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));
  }
}

ISOLATE_UNIT_TEST_CASE(StringHashConcat) {
  EXPECT_EQ(String::Handle(String::New("onebyte")).Hash(),
            String::HashConcat(String::Handle(String::New("one")),
                               String::Handle(String::New("byte"))));
  uint16_t clef_utf16[] = {0xD834, 0xDD1E};
  const String& clef = String::Handle(String::FromUTF16(clef_utf16, 2));
  int32_t clef_utf32[] = {0x1D11E};
  EXPECT(clef.Equals(clef_utf32, 1));
  uword hash32 = String::Hash(String::FromUTF32(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))));
}

ISOLATE_UNIT_TEST_CASE(StringSubStringDifferentWidth) {
  // Create 1-byte substring from a 1-byte source string.
  const char* onechars = "\xC3\xB6\xC3\xB1\xC3\xA9";

  const String& onestr = String::Handle(String::New(onechars));
  EXPECT(!onestr.IsNull());
  EXPECT(onestr.IsOneByteString());
  EXPECT(!onestr.IsTwoByteString());

  const String& onesub = String::Handle(String::SubString(onestr, 0));
  EXPECT(!onesub.IsNull());
  EXPECT(onestr.IsOneByteString());
  EXPECT(!onestr.IsTwoByteString());
  EXPECT_EQ(onesub.Length(), 3);

  // Create 1- and 2-byte substrings from a 2-byte source string.
  const char* twochars =
      "\x1f\x2f\x3f"
      "\xE1\xB9\xAB\xE1\xBA\x85\xE1\xB9\x93";

  const String& twostr = String::Handle(String::New(twochars));
  EXPECT(!twostr.IsNull());
  EXPECT(twostr.IsTwoByteString());

  const String& twosub1 = String::Handle(String::SubString(twostr, 0, 3));
  EXPECT(!twosub1.IsNull());
  EXPECT(twosub1.IsOneByteString());
  EXPECT_EQ(twosub1.Length(), 3);

  const String& twosub2 = String::Handle(String::SubString(twostr, 3));
  EXPECT(!twosub2.IsNull());
  EXPECT(twosub2.IsTwoByteString());
  EXPECT_EQ(twosub2.Length(), 3);

  // Create substrings from a string built using 1-, 2- and 4-byte elements.
  const char* fourchars =
      "\x1f\x2f\x3f"
      "\xE1\xB9\xAB\xE1\xBA\x85\xE1\xB9\x93"
      "\xF0\x9D\x96\xBF\xF0\x9D\x97\x88\xF0\x9D\x97\x8E\xF0\x9D\x97\x8B";

  const String& fourstr = String::Handle(String::New(fourchars));
  EXPECT(!fourstr.IsNull());
  EXPECT(fourstr.IsTwoByteString());

  const String& foursub1 = String::Handle(String::SubString(fourstr, 0, 3));
  EXPECT(!foursub1.IsNull());
  EXPECT(foursub1.IsOneByteString());
  EXPECT_EQ(foursub1.Length(), 3);

  const String& foursub2 = String::Handle(String::SubString(fourstr, 3, 3));
  EXPECT(!foursub2.IsNull());
  EXPECT(foursub2.IsTwoByteString());
  EXPECT_EQ(foursub2.Length(), 3);

  const String& foursub4 = String::Handle(String::SubString(fourstr, 6));
  EXPECT_EQ(foursub4.Length(), 8);
  EXPECT(!foursub4.IsNull());
  EXPECT(foursub4.IsTwoByteString());
}

ISOLATE_UNIT_TEST_CASE(StringFromUtf8Literal) {
  // Create a 1-byte string from a UTF-8 encoded string literal.
  {
    const char* src =
        "\xC2\xA0\xC2\xA1\xC2\xA2\xC2\xA3"
        "\xC2\xA4\xC2\xA5\xC2\xA6\xC2\xA7"
        "\xC2\xA8\xC2\xA9\xC2\xAA\xC2\xAB"
        "\xC2\xAC\xC2\xAD\xC2\xAE\xC2\xAF"
        "\xC2\xB0\xC2\xB1\xC2\xB2\xC2\xB3"
        "\xC2\xB4\xC2\xB5\xC2\xB6\xC2\xB7"
        "\xC2\xB8\xC2\xB9\xC2\xBA\xC2\xBB"
        "\xC2\xBC\xC2\xBD\xC2\xBE\xC2\xBF"
        "\xC3\x80\xC3\x81\xC3\x82\xC3\x83"
        "\xC3\x84\xC3\x85\xC3\x86\xC3\x87"
        "\xC3\x88\xC3\x89\xC3\x8A\xC3\x8B"
        "\xC3\x8C\xC3\x8D\xC3\x8E\xC3\x8F"
        "\xC3\x90\xC3\x91\xC3\x92\xC3\x93"
        "\xC3\x94\xC3\x95\xC3\x96\xC3\x97"
        "\xC3\x98\xC3\x99\xC3\x9A\xC3\x9B"
        "\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,
    };
    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 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};
    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 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,
    };
    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,
    };
    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));
    }
  }
}

ISOLATE_UNIT_TEST_CASE(StringEqualsUtf8) {
  const char* onesrc = "abc";
  const String& onestr = String::Handle(String::New(onesrc));
  EXPECT(onestr.IsOneByteString());
  EXPECT(!onestr.Equals(""));
  EXPECT(!onestr.Equals("a"));
  EXPECT(!onestr.Equals("ab"));
  EXPECT(onestr.Equals("abc"));
  EXPECT(!onestr.Equals("abcd"));

  const char* twosrc = "\xD7\x90\xD7\x91\xD7\x92";
  const String& twostr = String::Handle(String::New(twosrc));
  EXPECT(twostr.IsTwoByteString());
  EXPECT(!twostr.Equals(""));
  EXPECT(!twostr.Equals("\xD7\x90"));
  EXPECT(!twostr.Equals("\xD7\x90\xD7\x91"));
  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"));
}

ISOLATE_UNIT_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));
}

ISOLATE_UNIT_TEST_CASE(EscapeSpecialCharactersOneByteString) {
  uint8_t characters[] = {'a',  '\n', '\f', '\b', '\t',
                          '\v', '\r', '\\', '$',  'z'};
  intptr_t len = ARRAY_SIZE(characters);

  const String& str =
      String::Handle(OneByteString::New(characters, len, Heap::kNew));
  EXPECT(str.IsOneByteString());
  EXPECT_EQ(str.Length(), len);
  EXPECT(str.Equals("a\n\f\b\t\v\r\\$z"));
  const String& escaped_str =
      String::Handle(String::EscapeSpecialCharacters(str));
  EXPECT(escaped_str.Equals("a\\n\\f\\b\\t\\v\\r\\\\\\$z"));

  const String& escaped_empty_str =
      String::Handle(String::EscapeSpecialCharacters(Symbols::Empty()));
  EXPECT_EQ(escaped_empty_str.Length(), 0);
}

ISOLATE_UNIT_TEST_CASE(EscapeSpecialCharactersTwoByteString) {
  uint16_t characters[] = {'a',  '\n', '\f', '\b', '\t',
                           '\v', '\r', '\\', '$',  'z'};
  intptr_t len = ARRAY_SIZE(characters);

  const String& str =
      String::Handle(TwoByteString::New(characters, len, Heap::kNew));
  EXPECT(str.IsTwoByteString());
  EXPECT_EQ(str.Length(), len);
  EXPECT(str.Equals("a\n\f\b\t\v\r\\$z"));
  const String& escaped_str =
      String::Handle(String::EscapeSpecialCharacters(str));
  EXPECT(escaped_str.Equals("a\\n\\f\\b\\t\\v\\r\\\\\\$z"));

  const String& empty_str =
      String::Handle(TwoByteString::New(static_cast<intptr_t>(0), Heap::kNew));
  const String& escaped_empty_str =
      String::Handle(String::EscapeSpecialCharacters(empty_str));
  EXPECT_EQ(empty_str.Length(), 0);
  EXPECT_EQ(escaped_empty_str.Length(), 0);
}

ISOLATE_UNIT_TEST_CASE(Symbol) {
  const String& one = String::Handle(Symbols::New(thread, "Eins"));
  EXPECT(one.IsSymbol());
  const String& two = String::Handle(Symbols::New(thread, "Zwei"));
  const String& three = String::Handle(Symbols::New(thread, "Drei"));
  const String& four = String::Handle(Symbols::New(thread, "Vier"));
  const String& five = String::Handle(Symbols::New(thread, "Fuenf"));
  const String& six = String::Handle(Symbols::New(thread, "Sechs"));
  const String& seven = String::Handle(Symbols::New(thread, "Sieben"));
  const String& eight = String::Handle(Symbols::New(thread, "Acht"));
  const String& nine = String::Handle(Symbols::New(thread, "Neun"));
  const String& ten = String::Handle(Symbols::New(thread, "Zehn"));
  String& eins = String::Handle(Symbols::New(thread, "Eins"));
  EXPECT_EQ(one.ptr(), eins.ptr());
  EXPECT(one.ptr() != two.ptr());
  EXPECT(two.Equals(String::Handle(String::New("Zwei"))));
  EXPECT_EQ(two.ptr(), Symbols::New(thread, "Zwei"));
  EXPECT_EQ(three.ptr(), Symbols::New(thread, "Drei"));
  EXPECT_EQ(four.ptr(), Symbols::New(thread, "Vier"));
  EXPECT_EQ(five.ptr(), Symbols::New(thread, "Fuenf"));
  EXPECT_EQ(six.ptr(), Symbols::New(thread, "Sechs"));
  EXPECT_EQ(seven.ptr(), Symbols::New(thread, "Sieben"));
  EXPECT_EQ(eight.ptr(), Symbols::New(thread, "Acht"));
  EXPECT_EQ(nine.ptr(), Symbols::New(thread, "Neun"));
  EXPECT_EQ(ten.ptr(), Symbols::New(thread, "Zehn"));

  // Make sure to cause symbol table overflow.
  for (int i = 0; i < 1024; i++) {
    char buf[256];
    Utils::SNPrint(buf, sizeof(buf), "%d", i);
    Symbols::New(thread, buf);
  }
  eins = Symbols::New(thread, "Eins");
  EXPECT_EQ(one.ptr(), eins.ptr());
  EXPECT_EQ(two.ptr(), Symbols::New(thread, "Zwei"));
  EXPECT_EQ(three.ptr(), Symbols::New(thread, "Drei"));
  EXPECT_EQ(four.ptr(), Symbols::New(thread, "Vier"));
  EXPECT_EQ(five.ptr(), Symbols::New(thread, "Fuenf"));
  EXPECT_EQ(six.ptr(), Symbols::New(thread, "Sechs"));
  EXPECT_EQ(seven.ptr(), Symbols::New(thread, "Sieben"));
  EXPECT_EQ(eight.ptr(), Symbols::New(thread, "Acht"));
  EXPECT_EQ(nine.ptr(), Symbols::New(thread, "Neun"));
  EXPECT_EQ(ten.ptr(), 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.ptr(), ein_symbol.ptr());
  EXPECT(one.ptr() != eins.ptr());

  uint16_t char16[] = {'E', 'l', 'f'};
  String& elf1 = String::Handle(Symbols::FromUTF16(thread, char16, 3));
  int32_t char32[] = {'E', 'l', 'f'};
  String& elf2 = String::Handle(
      Symbols::New(thread, String::Handle(String::FromUTF32(char32, 3))));
  EXPECT(elf1.IsSymbol());
  EXPECT(elf2.IsSymbol());
  EXPECT_EQ(elf1.ptr(), Symbols::New(thread, "Elf"));
  EXPECT_EQ(elf2.ptr(), Symbols::New(thread, "Elf"));
}

ISOLATE_UNIT_TEST_CASE(SymbolUnicode) {
  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.ptr(), Symbols::New(thread, monkey_utf8));

  int32_t kMonkeyFace = 0x1f435;
  String& monkey2 = String::Handle(
      Symbols::New(thread, String::Handle(String::FromUTF32(&kMonkeyFace, 1))));
  EXPECT_EQ(monkey.ptr(), monkey2.ptr());

  // Unicode cat face with tears of joy.
  int32_t kCatFaceWithTearsOfJoy = 0x1f639;
  String& cat = String::Handle(Symbols::New(
      thread, String::Handle(String::FromUTF32(&kCatFaceWithTearsOfJoy, 1))));

  uint16_t cat_utf16[] = {0xd83d, 0xde39};
  String& cat2 = String::Handle(Symbols::FromUTF16(thread, cat_utf16, 2));
  EXPECT(cat2.IsSymbol());
  EXPECT_EQ(cat2.ptr(), cat.ptr());
}

ISOLATE_UNIT_TEST_CASE(Bool) {
  EXPECT(Bool::True().value());
  EXPECT(!Bool::False().value());
}

ISOLATE_UNIT_TEST_CASE(Array) {
  const int kArrayLen = 5;
  const Array& array = Array::Handle(Array::New(kArrayLen));
  EXPECT_EQ(kArrayLen, array.Length());
  Object& element = Object::Handle(array.At(0));
  EXPECT(element.IsNull());
  element = array.At(kArrayLen - 1);
  EXPECT(element.IsNull());
  array.SetAt(0, array);
  array.SetAt(2, array);
  element = array.At(0);
  EXPECT_EQ(array.ptr(), element.ptr());
  element = array.At(1);
  EXPECT(element.IsNull());
  element = array.At(2);
  EXPECT_EQ(array.ptr(), element.ptr());

  Array& other_array = Array::Handle(Array::New(kArrayLen));
  other_array.SetAt(0, array);
  other_array.SetAt(2, array);

  EXPECT(array.CanonicalizeEquals(array));
  EXPECT(array.CanonicalizeEquals(other_array));

  other_array.SetAt(1, other_array);
  EXPECT(!array.CanonicalizeEquals(other_array));

  other_array = Array::New(kArrayLen - 1);
  other_array.SetAt(0, array);
  other_array.SetAt(2, array);
  EXPECT(!array.CanonicalizeEquals(other_array));

  EXPECT_EQ(0, Object::empty_array().Length());

  array.MakeImmutable();
  Object& obj = Object::Handle(array.ptr());
  EXPECT(obj.IsArray());
}

ISOLATE_UNIT_TEST_CASE(Array_Grow) {
  const intptr_t kSmallSize = 100;
  EXPECT(!Array::UseCardMarkingForAllocation(kSmallSize));
  const intptr_t kMediumSize = 1000;
  EXPECT(!Array::UseCardMarkingForAllocation(kMediumSize));
  const intptr_t kLargeSize = 100000;
  EXPECT(Array::UseCardMarkingForAllocation(kLargeSize));

  const Array& small = Array::Handle(Array::New(kSmallSize));
  for (intptr_t i = 0; i < kSmallSize; i++) {
    small.SetAt(i, Smi::Handle(Smi::New(i)));
  }

  const Array& medium = Array::Handle(Array::Grow(small, kMediumSize));
  EXPECT_EQ(kMediumSize, medium.Length());
  for (intptr_t i = 0; i < kSmallSize; i++) {
    EXPECT_EQ(Smi::New(i), medium.At(i));
  }
  for (intptr_t i = kSmallSize; i < kMediumSize; i++) {
    EXPECT_EQ(Object::null(), medium.At(i));
  }

  const Array& large = Array::Handle(Array::Grow(small, kLargeSize));
  EXPECT_EQ(kLargeSize, large.Length());
  for (intptr_t i = 0; i < kSmallSize; i++) {
    EXPECT_EQ(large.At(i), Smi::New(i));
  }
  for (intptr_t i = kSmallSize; i < kLargeSize; i++) {
    EXPECT_EQ(large.At(i), Object::null());
  }
}

ISOLATE_UNIT_TEST_CASE(EmptyInstantiationsCacheArray) {
  SafepointMutexLocker ml(
      thread->isolate_group()->type_arguments_canonicalization_mutex());
  const Array& empty_cache = Object::empty_instantiations_cache_array();
  DEBUG_ONLY(EXPECT(TypeArguments::Cache::IsValidStorageLocked(empty_cache));)
  const TypeArguments::Cache cache(thread->zone(), empty_cache);
  EXPECT(cache.IsLinear());
  EXPECT(!cache.IsHash());
  EXPECT_EQ(0, cache.NumOccupied());
  const InstantiationsCacheTable table(empty_cache);
  EXPECT_EQ(1, table.Length());
  for (const auto& tuple : table) {
    EXPECT(tuple.Get<TypeArguments::Cache::kSentinelIndex>() ==
           TypeArguments::Cache::Sentinel());
  }
}

static void TestIllegalArrayLength(intptr_t length) {
  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "main() {\n"
                 "  List.filled(%" Pd
                 ", null);\n"
                 "}\n",
                 length);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  Utils::SNPrint(buffer, sizeof(buffer),
                 "Unhandled exception:\n"
                 "RangeError (length): Invalid value: "
                 "Not in inclusive range 0..%" Pd ": %" Pd,
                 Array::kMaxElements, length);
  EXPECT_ERROR(result, buffer);
}

TEST_CASE(ArrayLengthNegativeOne) {
  TestIllegalArrayLength(-1);
}
TEST_CASE(ArrayLengthSmiMin) {
  TestIllegalArrayLength(kSmiMin);
}

TEST_CASE(ArrayLengthOneTooMany) {
  const intptr_t kOneTooMany = Array::kMaxElements + 1;
  ASSERT(kOneTooMany >= 0);

  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "main() {\n"
                 "  return List.filled(%" Pd
                 ", null);\n"
                 "}\n",
                 kOneTooMany);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_ERROR(result, "Out of Memory");
}

TEST_CASE(ArrayLengthMaxElements) {
  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "main() {\n"
                 "  return List.filled(%" Pd
                 ", null);\n"
                 "}\n",
                 Array::kMaxElements);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  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];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "import 'dart:typed_data';\n"
                 "main() {\n"
                 "  new %s(%" Pd
                 ");\n"
                 "}\n",
                 class_name, length);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  Utils::SNPrint(buffer, sizeof(buffer), "%" Pd, length);
  EXPECT_ERROR(result, "RangeError (length): Invalid value");
  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);

  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "import 'dart:typed_data';\n"
                 "main() {\n"
                 "  return new Int8List(%" Pd
                 ");\n"
                 "}\n",
                 kOneTooMany);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  EXPECT_ERROR(result, "Out of Memory");
}

TEST_CASE(Int8ListLengthMaxElements) {
  const intptr_t max_elements = TypedData::MaxElements(kTypedDataInt8ArrayCid);
  char buffer[1024];
  Utils::SNPrint(buffer, sizeof(buffer),
                 "import 'dart:typed_data';\n"
                 "main() {\n"
                 "  return new Int8List(%" Pd
                 ");\n"
                 "}\n",
                 max_elements);
  Dart_Handle lib = TestCase::LoadTestScript(buffer, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);
  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);
  }
}

ISOLATE_UNIT_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"));
  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"));
  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());
}

ISOLATE_UNIT_TEST_CASE(StringCodePointIteratorRange) {
  const String& str = String::Handle(String::New("foo bar baz"));

  String::CodePointIterator it0(str, 3, 0);
  EXPECT(!it0.Next());

  String::CodePointIterator it1(str, 4, 3);
  EXPECT(it1.Next());
  EXPECT_EQ('b', it1.Current());
  EXPECT(it1.Next());
  EXPECT_EQ('a', it1.Current());
  EXPECT(it1.Next());
  EXPECT_EQ('r', it1.Current());
  EXPECT(!it1.Next());
}

ISOLATE_UNIT_TEST_CASE(GrowableObjectArray) {
  const int kArrayLen = 5;
  Smi& value = Smi::Handle();
  Smi& expected_value = Smi::Handle();
  GrowableObjectArray& array = GrowableObjectArray::Handle();

  // Test basic growing functionality.
  array = GrowableObjectArray::New(kArrayLen);
  EXPECT_EQ(kArrayLen, array.Capacity());
  EXPECT_EQ(0, array.Length());
  for (intptr_t i = 0; i < 10; i++) {
    value = Smi::New(i);
    array.Add(value);
  }
  EXPECT_EQ(10, array.Length());
  for (intptr_t i = 0; i < 10; i++) {
    expected_value = Smi::New(i);
    value ^= array.At(i);
    EXPECT(value.Equals(expected_value));
  }
  for (intptr_t i = 0; i < 10; i++) {
    value = Smi::New(i * 10);
    array.SetAt(i, value);
  }
  EXPECT_EQ(10, array.Length());
  for (intptr_t i = 0; i < 10; i++) {
    expected_value = Smi::New(i * 10);
    value ^= array.At(i);
    EXPECT(value.Equals(expected_value));
  }

  // Test the MakeFixedLength functionality to make sure the resulting array
  // object is properly setup.
  // 1. Should produce an array of length 2 and a filler of minimal size.
  Array& new_array = Array::Handle();
  Object& obj = Object::Handle();
  uword addr = 0;
  intptr_t used_size = 0;

  array = GrowableObjectArray::New(kArrayLen + 1);
  EXPECT_EQ(kArrayLen + 1, array.Capacity());
  EXPECT_EQ(0, array.Length());
  for (intptr_t i = 0; i < 2; i++) {
    value = Smi::New(i);
    array.Add(value);
  }
  used_size = Array::InstanceSize(array.Length());
  new_array = Array::MakeFixedLength(array);
  addr = UntaggedObject::ToAddr(new_array.ptr());
  obj = UntaggedObject::FromAddr(addr);
  EXPECT(obj.IsArray());
  new_array ^= obj.ptr();
  EXPECT_EQ(2, new_array.Length());
  addr += used_size;
  ObjectPtr filler = UntaggedObject::FromAddr(addr);
  EXPECT(filler->IsFreeListElement());
  EXPECT_EQ(filler->untag()->HeapSize(),
            Array::InstanceSize(kArrayLen + 1) - used_size);

  // 2. Should produce an array of length 3 and a filler object.
  array = GrowableObjectArray::New(kArrayLen);
  EXPECT_EQ(kArrayLen, array.Capacity());
  EXPECT_EQ(0, array.Length());
  for (intptr_t i = 0; i < 3; i++) {
    value = Smi::New(i);
    array.Add(value);
  }
  used_size = Array::InstanceSize(array.Length());
  new_array = Array::MakeFixedLength(array);
  addr = UntaggedObject::ToAddr(new_array.ptr());
  obj = UntaggedObject::FromAddr(addr);
  EXPECT(obj.IsArray());
  new_array ^= obj.ptr();
  EXPECT_EQ(3, new_array.Length());
  addr += used_size;
  filler = UntaggedObject::FromAddr(addr);
  EXPECT(filler->IsFreeListElement());
  EXPECT_EQ(filler->untag()->HeapSize(),
            Array::InstanceSize(kArrayLen) - used_size);

  // 3. Should produce an array of length 1 and a filler object.
  array = GrowableObjectArray::New(kArrayLen + 3);
  EXPECT_EQ((kArrayLen + 3), array.Capacity());
  EXPECT_EQ(0, array.Length());
  for (intptr_t i = 0; i < 1; i++) {
    value = Smi::New(i);
    array.Add(value);
  }
  used_size = Array::InstanceSize(array.Length());
  new_array = Array::MakeFixedLength(array);
  addr = UntaggedObject::ToAddr(new_array.ptr());
  obj = UntaggedObject::FromAddr(addr);
  EXPECT(obj.IsArray());
  new_array ^= obj.ptr();
  EXPECT_EQ(1, new_array.Length());
  addr += used_size;
  filler = UntaggedObject::FromAddr(addr);
  EXPECT(filler->IsFreeListElement());
  EXPECT_EQ(filler->untag()->HeapSize(),
            Array::InstanceSize(kArrayLen + 3) - used_size);

  // 4. Verify that GC can handle the filler object for a large array.
  array = GrowableObjectArray::New((1 * MB) >> kWordSizeLog2);
  EXPECT_EQ(0, array.Length());
  for (intptr_t i = 0; i < 1; i++) {
    value = Smi::New(i);
    array.Add(value);
  }
  Heap* heap = IsolateGroup::Current()->heap();
  GCTestHelper::CollectAllGarbage();
  GCTestHelper::WaitForGCTasks();  // Sweeper must finish for accurate capacity.
  intptr_t capacity_before = heap->CapacityInWords(Heap::kOld);
  new_array = Array::MakeFixedLength(array);
  EXPECT_EQ(1, new_array.Length());
  GCTestHelper::CollectAllGarbage();
  GCTestHelper::WaitForGCTasks();  // Sweeper must finish for accurate capacity.
  intptr_t capacity_after = heap->CapacityInWords(Heap::kOld);
  // Page should shrink.
  EXPECT_LT(capacity_after, capacity_before);
  EXPECT_EQ(1, new_array.Length());
}

ISOLATE_UNIT_TEST_CASE(TypedData_Grow) {
  const intptr_t kSmallSize = 42;
  const intptr_t kLargeSize = 1000;

  Random random(42);

  for (classid_t cid = kFirstTypedDataCid; cid <= kLastTypedDataCid;
       cid += kNumTypedDataCidRemainders) {
    ASSERT(IsTypedDataClassId(cid));

    const auto& small = TypedData::Handle(TypedData::New(cid, kSmallSize));
    EXPECT_EQ(small.LengthInBytes(), kSmallSize * small.ElementSizeInBytes());

    for (intptr_t i = 0; i < TypedData::ElementSizeFor(cid) * kSmallSize; i++) {
      small.SetUint8(i, static_cast<uint8_t>(random.NextUInt64() & 0xff));
    }

    const auto& big = TypedData::Handle(TypedData::Grow(small, kLargeSize));
    EXPECT_EQ(small.GetClassId(), big.GetClassId());
    EXPECT_EQ(big.LengthInBytes(), kLargeSize * big.ElementSizeInBytes());

    for (intptr_t i = 0; i < TypedData::ElementSizeFor(cid) * kSmallSize; i++) {
      EXPECT_EQ(small.GetUint8(i), big.GetUint8(i));
    }
    for (intptr_t i = TypedData::ElementSizeFor(cid) * kSmallSize;
         i < TypedData::ElementSizeFor(cid) * kLargeSize; i++) {
      EXPECT_EQ(0, big.GetUint8(i));
    }
  }
}

ISOLATE_UNIT_TEST_CASE(InternalTypedData) {
  uint8_t data[] = {253, 254, 255, 0, 1, 2, 3, 4};
  intptr_t data_length = ARRAY_SIZE(data);

  const TypedData& int8_array =
      TypedData::Handle(TypedData::New(kTypedDataInt8ArrayCid, data_length));
  EXPECT(!int8_array.IsNull());
  EXPECT_EQ(data_length, int8_array.Length());
  for (intptr_t i = 0; i < data_length; ++i) {
    int8_array.SetInt8(i, data[i]);
  }

  EXPECT_EQ(-3, int8_array.GetInt8(0));
  EXPECT_EQ(253, int8_array.GetUint8(0));

  EXPECT_EQ(-2, int8_array.GetInt8(1));
  EXPECT_EQ(254, int8_array.GetUint8(1));

  EXPECT_EQ(-1, int8_array.GetInt8(2));
  EXPECT_EQ(255, int8_array.GetUint8(2));

  EXPECT_EQ(0, int8_array.GetInt8(3));
  EXPECT_EQ(0, int8_array.GetUint8(3));

  EXPECT_EQ(1, int8_array.GetInt8(4));
  EXPECT_EQ(1, int8_array.GetUint8(4));

  EXPECT_EQ(2, int8_array.GetInt8(5));
  EXPECT_EQ(2, int8_array.GetUint8(5));

  EXPECT_EQ(3, int8_array.GetInt8(6));
  EXPECT_EQ(3, int8_array.GetUint8(6));

  EXPECT_EQ(4, int8_array.GetInt8(7));
  EXPECT_EQ(4, int8_array.GetUint8(7));

  const TypedData& int8_array2 =
      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_array2.SetInt8(i, data[i]);
  }

  for (intptr_t i = 0; i < data_length; ++i) {
    EXPECT_EQ(int8_array.GetInt8(i), int8_array2.GetInt8(i));
  }
  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));
  }
}

ISOLATE_UNIT_TEST_CASE(ExternalTypedData) {
  uint8_t data[] = {253, 254, 255, 0, 1, 2, 3, 4};
  intptr_t data_length = ARRAY_SIZE(data);

  const ExternalTypedData& int8_array =
      ExternalTypedData::Handle(ExternalTypedData::New(
          kExternalTypedDataInt8ArrayCid, data, data_length));
  EXPECT(!int8_array.IsNull());
  EXPECT_EQ(data_length, int8_array.Length());

  const ExternalTypedData& uint8_array =
      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));
  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) {
    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) {
    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) {
    EXPECT_EQ(int8_array.GetUint8(i), uint8_clamped_array.GetUint8(i));
  }
}

ISOLATE_UNIT_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));
    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* url_chars = "";
    // Single line, no terminators.
    const char* source_chars = "abc";
    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));
    EXPECT(!script.IsNull());
    EXPECT(script.IsScript());
    auto& str = String::Handle(Z);
    str = script.GetLine(1);
    EXPECT_STREQ("abc", str.ToCString());
    str = script.GetSnippet(1, 1, 1, 2);
    EXPECT_STREQ("a", str.ToCString());
    str = script.GetSnippet(1, 2, 1, 4);
    EXPECT_STREQ("bc", str.ToCString());
    // Lines not in the source should return the empty string.
    str = script.GetLine(-500);
    EXPECT_STREQ("", str.ToCString());
    str = script.GetLine(0);
    EXPECT_STREQ("", str.ToCString());
    str = script.GetLine(2);
    EXPECT_STREQ("", str.ToCString());
    str = script.GetLine(10000);
    EXPECT_STREQ("", str.ToCString());
    // Snippets not contained within the source should be the null string.
    str = script.GetSnippet(-1, 1, 1, 2);
    EXPECT(str.IsNull());
    str = script.GetSnippet(2, 1, 2, 2);
    EXPECT(str.IsNull());
    str = script.GetSnippet(1, 1, 1, 5);
    EXPECT(str.IsNull());
  }

  TransitionVMToNative transition(thread);
  const char* kScript = "main() {}";
  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle result = Dart_Invoke(h_lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
}

ISOLATE_UNIT_TEST_CASE(Context) {
  const int kNumVariables = 5;
  const Context& parent_context = Context::Handle(Context::New(0));
  const Context& context = Context::Handle(Context::New(kNumVariables));
  context.set_parent(parent_context);
  EXPECT_EQ(kNumVariables, context.num_variables());
  EXPECT(Context::Handle(context.parent()).ptr() == parent_context.ptr());
  EXPECT_EQ(0, Context::Handle(context.parent()).num_variables());
  EXPECT(Context::Handle(Context::Handle(context.parent()).parent()).IsNull());
  Object& variable = Object::Handle(context.At(0));
  EXPECT(variable.IsNull());
  variable = context.At(kNumVariables - 1);
  EXPECT(variable.IsNull());
  context.SetAt(0, Smi::Handle(Smi::New(2)));
  context.SetAt(2, Smi::Handle(Smi::New(3)));
  Smi& smi = Smi::Handle();
  smi ^= context.At(0);
  EXPECT_EQ(2, smi.Value());
  smi ^= context.At(2);
  EXPECT_EQ(3, smi.Value());
}

ISOLATE_UNIT_TEST_CASE(ContextScope) {
  // We need an active compiler context to manipulate scopes, since local
  // variables and slots can be canonicalized in the compiler state.
  CompilerState compiler_state(Thread::Current(), /*is_aot=*/false,
                               /*is_optimizing=*/false);

  const intptr_t parent_scope_function_level = 0;
  LocalScope* parent_scope =
      new LocalScope(nullptr, 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& ta = Symbols::FunctionTypeArgumentsVar();
  LocalVariable* var_ta = new LocalVariable(
      TokenPosition::kNoSource, TokenPosition::kNoSource, ta, dynamic_type);
  parent_scope->AddVariable(var_ta);

  const String& a = String::ZoneHandle(Symbols::New(thread, "a"));
  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);
  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);
  parent_scope->AddVariable(var_c);

  bool test_only = false;  // Please, insert alias.
  var_ta = local_scope->LookupVariable(ta, LocalVariable::kNoKernelOffset,
                                       test_only);
  EXPECT(var_ta->is_captured());
  EXPECT_EQ(parent_scope_function_level, var_ta->owner()->function_level());
  EXPECT(local_scope->LocalLookupVariable(ta, LocalVariable::kNoKernelOffset) ==
         var_ta);  // Alias.

  var_a =
      local_scope->LookupVariable(a, LocalVariable::kNoKernelOffset, test_only);
  EXPECT(var_a->is_captured());
  EXPECT_EQ(parent_scope_function_level, var_a->owner()->function_level());
  EXPECT(local_scope->LocalLookupVariable(a, LocalVariable::kNoKernelOffset) ==
         var_a);  // Alias.

  var_b =
      local_scope->LookupVariable(b, LocalVariable::kNoKernelOffset, test_only);
  EXPECT(!var_b->is_captured());
  EXPECT_EQ(local_scope_function_level, var_b->owner()->function_level());
  EXPECT(local_scope->LocalLookupVariable(b, LocalVariable::kNoKernelOffset) ==
         var_b);

  test_only = true;  // Please, do not insert alias.
  var_c =
      local_scope->LookupVariable(c, LocalVariable::kNoKernelOffset, 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, LocalVariable::kNoKernelOffset) ==
         nullptr);

  test_only = false;  // Please, insert alias.
  var_c =
      local_scope->LookupVariable(c, LocalVariable::kNoKernelOffset, test_only);
  EXPECT(var_c->is_captured());

  EXPECT_EQ(4, local_scope->num_variables());         // ta, a, b, c.
  EXPECT_EQ(3, local_scope->NumCapturedVariables());  // ta, a, c.

  const VariableIndex first_parameter_index(0);
  const int num_parameters = 0;
  const VariableIndex first_local_index(-1);
  bool found_captured_vars = false;
  VariableIndex next_index = parent_scope->AllocateVariables(
      Function::null_function(), first_parameter_index, num_parameters,
      first_local_index, nullptr, &found_captured_vars);
  // Variables a, c and var_ta are captured, therefore are not allocated in
  // frame.
  EXPECT_EQ(0, next_index.value() -
                   first_local_index.value());  // Indices in frame < 0.
  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(
          Function::null_function(), local_scope_context_level));
  LocalScope* outer_scope = LocalScope::RestoreOuterScope(context_scope);
  EXPECT_EQ(3, outer_scope->num_variables());

  var_ta = outer_scope->LocalLookupVariable(ta, LocalVariable::kNoKernelOffset);
  EXPECT(var_ta->is_captured());
  EXPECT_EQ(0, var_ta->index().value());  // First index.
  EXPECT_EQ(parent_scope_context_level - local_scope_context_level,
            var_ta->owner()->context_level());  // Adjusted context level.

  var_a = outer_scope->LocalLookupVariable(a, LocalVariable::kNoKernelOffset);
  EXPECT(var_a->is_captured());
  EXPECT_EQ(1, var_a->index().value());  // First index.
  EXPECT_EQ(parent_scope_context_level - local_scope_context_level,
            var_a->owner()->context_level());  // Adjusted context level.

  // var b was not captured.
  EXPECT(outer_scope->LocalLookupVariable(b, LocalVariable::kNoKernelOffset) ==
         nullptr);

  var_c = outer_scope->LocalLookupVariable(c, LocalVariable::kNoKernelOffset);
  EXPECT(var_c->is_captured());
  EXPECT_EQ(2, var_c->index().value());
  EXPECT_EQ(parent_scope_context_level - local_scope_context_level,
            var_c->owner()->context_level());  // Adjusted context level.
}

ISOLATE_UNIT_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"));
  FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  parent = Function::New(signature, parent_name,
                         UntaggedFunction::kRegularFunction, false, false,
                         false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(0, parent);
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    cls.SetFunctions(functions);
    cls.Finalize();
  }

  Function& function = Function::Handle();
  const String& function_name = String::Handle(Symbols::New(thread, "foo"));
  function = Function::NewClosureFunction(function_name, parent,
                                          TokenPosition::kMinSource);
  signature = function.signature();
  signature.set_result_type(Object::dynamic_type());
  signature ^= ClassFinalizer::FinalizeType(signature);
  function.SetSignature(signature);
  const Closure& closure = Closure::Handle(
      Closure::New(Object::null_type_arguments(), Object::null_type_arguments(),
                   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.ptr(), function.ptr());
  const Context& closure_context = Context::Handle(closure.GetContext());
  EXPECT_EQ(closure_context.ptr(), context.ptr());
}

ISOLATE_UNIT_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 = IsolateGroup::Current()->object_store();
  const Class& bool_class = Class::Handle(object_store->bool_class());
  EXPECT_STREQ("Library:'dart:core' Class: bool", bool_class.ToCString());
  EXPECT_STREQ("true", Bool::True().ToCString());
  EXPECT_STREQ("false", Bool::False().ToCString());

  // Strings.
  EXPECT_STREQ("Sugarbowl",
               String::Handle(String::New("Sugarbowl")).ToCString());
}

ISOLATE_UNIT_TEST_CASE(CheckedHandle) {
  // Ensure that null handles have the correct C++ vtable setup.
  Zone* zone = Thread::Current()->zone();
  const String& str1 = String::Handle(zone);
  EXPECT(str1.IsString());
  EXPECT(str1.IsNull());
  const String& str2 = String::CheckedHandle(zone, Object::null());
  EXPECT(str2.IsString());
  EXPECT(str2.IsNull());
  String& str3 = String::Handle(zone);
  str3 ^= Object::null();
  EXPECT(str3.IsString());
  EXPECT(str3.IsNull());
  EXPECT(!str3.IsOneByteString());
  str3 = String::New("Steep and Deep!");
  EXPECT(str3.IsString());
  EXPECT(str3.IsOneByteString());
  str3 = OneByteString::null();
  EXPECT(str3.IsString());
  EXPECT(!str3.IsOneByteString());
}

static LibraryPtr CreateDummyLibrary(const String& library_name) {
  return Library::New(library_name);
}

static FunctionPtr 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));
  owner_class.set_library(owner_library);
  const String& function_name = String::ZoneHandle(Symbols::New(thread, name));
  const FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  return Function::New(signature, function_name,
                       UntaggedFunction::kRegularFunction, true, false, false,
                       false, false, owner_class, TokenPosition::kMinSource);
}

// Test for Code and Instruction object creation.
ISOLATE_UNIT_TEST_CASE(Code) {
  extern void GenerateIncrement(compiler::Assembler * assembler);
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateIncrement(&_assembler_);
  const Function& function = Function::Handle(CreateFunction("Test_Code"));
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
  code.set_owner(function);
  function.AttachCode(code);
  const Instructions& instructions = Instructions::Handle(code.instructions());
  uword payload_start = instructions.PayloadStart();
  EXPECT_EQ(instructions.ptr(), Instructions::FromPayloadStart(payload_start));
  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.
ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION(CodeImmutability, "Crash") {
  extern void GenerateIncrement(compiler::Assembler * assembler);
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateIncrement(&_assembler_);
  const Function& function = Function::Handle(CreateFunction("Test_Code"));
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
  function.AttachCode(code);
  Instructions& instructions = Instructions::Handle(code.instructions());
  uword payload_start = instructions.PayloadStart();
  EXPECT_EQ(instructions.ptr(), 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.
    FATAL("Test requires --write-protect-code; skip by forcing expected crash");
  }
}

ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION(VMIsolateImmutability, "Crash") {
  // Try writing into the null object, expected to crash.
  *reinterpret_cast<uword*>(UntaggedObject::ToAddr(Object::null())) = 0xBAD;
}

class CodeTestHelper {
 public:
  static void SetInstructions(const Code& code,
                              const Instructions& instructions,
                              uword unchecked_offset) {
    code.SetActiveInstructions(instructions, unchecked_offset);
    code.set_instructions(instructions);
  }
};

// Test for Embedded String object in the instructions.
ISOLATE_UNIT_TEST_CASE(EmbedStringInCode) {
  extern void GenerateEmbedStringInCode(compiler::Assembler * assembler,
                                        const char* str);
  const char* kHello = "Hello World!";
  word expected_length = static_cast<word>(strlen(kHello));
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateEmbedStringInCode(&_assembler_, kHello);
  const Function& function =
      Function::Handle(CreateFunction("Test_EmbedStringInCode"));
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
  code.set_owner(function);
  function.AttachCode(code);
  const Object& result =
      Object::Handle(DartEntry::InvokeFunction(function, Array::empty_array()));
  EXPECT(result.ptr()->IsHeapObject());
  String& string_object = String::Handle();
  string_object ^= result.ptr();
  EXPECT(string_object.Length() == expected_length);
  for (int i = 0; i < expected_length; i++) {
    EXPECT(string_object.CharAt(i) == kHello[i]);
  }
}

// Test for Embedded Smi object in the instructions.
ISOLATE_UNIT_TEST_CASE(EmbedSmiInCode) {
  extern void GenerateEmbedSmiInCode(compiler::Assembler * assembler,
                                     intptr_t value);
  const intptr_t kSmiTestValue = 5;
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateEmbedSmiInCode(&_assembler_, kSmiTestValue);
  const Function& function =
      Function::Handle(CreateFunction("Test_EmbedSmiInCode"));
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
  code.set_owner(function);
  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) && !defined(DART_COMPRESSED_POINTERS)
// Test for Embedded Smi object in the instructions.
ISOLATE_UNIT_TEST_CASE(EmbedSmiIn64BitCode) {
  extern void GenerateEmbedSmiInCode(compiler::Assembler * assembler,
                                     intptr_t value);
  const intptr_t kSmiTestValue = static_cast<intptr_t>(5) << 32;
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateEmbedSmiInCode(&_assembler_, kSmiTestValue);
  const Function& function =
      Function::Handle(CreateFunction("Test_EmbedSmiIn64BitCode"));
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
  code.set_owner(function);
  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 && !DART_COMPRESSED_POINTERS

ISOLATE_UNIT_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, true);
  exception_handlers.SetHandlerInfo(1, 0, 30u, kNeedsStackTrace, false, true);
  exception_handlers.SetHandlerInfo(2, -1, 40u, kNoStackTrace, true, true);
  exception_handlers.SetHandlerInfo(3, 1, 150u, kNoStackTrace, true, true);

  extern void GenerateIncrement(compiler::Assembler * assembler);
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateIncrement(&_assembler_);
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      Function::Handle(CreateFunction("Test_Code")), nullptr, &_assembler_,
      Code::PoolAttachment::kAttachPool));
  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());
  ExceptionHandlerInfo 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));
}

ISOLATE_UNIT_TEST_CASE(PcDescriptors) {
  DescriptorList* builder = new DescriptorList(thread->zone());

  // kind, pc_offset, deopt_id, token_pos, try_index, yield_index
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 10, 1,
                         TokenPosition::Deserialize(20), 1, 1);
  builder->AddDescriptor(UntaggedPcDescriptors::kDeopt, 20, 2,
                         TokenPosition::Deserialize(30), 0, -1);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 30, 3,
                         TokenPosition::Deserialize(40), 1, 10);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 10, 4,
                         TokenPosition::Deserialize(40), 2, 20);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 10, 5,
                         TokenPosition::Deserialize(80), 3, 30);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 80, 6,
                         TokenPosition::Deserialize(150), 3, 30);

  PcDescriptors& descriptors = PcDescriptors::Handle();
  descriptors ^= builder->FinalizePcDescriptors(0);

  extern void GenerateIncrement(compiler::Assembler * assembler);
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateIncrement(&_assembler_);
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      Function::Handle(CreateFunction("Test_Code")), nullptr, &_assembler_,
      Code::PoolAttachment::kAttachPool));
  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, UntaggedPcDescriptors::kAnyKind);

  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(1, iter.YieldIndex());
  EXPECT_EQ(20, iter.TokenPos().Pos());
  EXPECT_EQ(1, iter.TryIndex());
  EXPECT_EQ(static_cast<uword>(10), iter.PcOffset());
  EXPECT_EQ(1, iter.DeoptId());
  EXPECT_EQ(UntaggedPcDescriptors::kOther, iter.Kind());

  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(-1, iter.YieldIndex());
  EXPECT_EQ(30, iter.TokenPos().Pos());
  EXPECT_EQ(UntaggedPcDescriptors::kDeopt, iter.Kind());

  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(10, iter.YieldIndex());
  EXPECT_EQ(40, iter.TokenPos().Pos());

  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(20, iter.YieldIndex());
  EXPECT_EQ(40, iter.TokenPos().Pos());

  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(30, iter.YieldIndex());
  EXPECT_EQ(80, iter.TokenPos().Pos());

  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(30, iter.YieldIndex());
  EXPECT_EQ(150, iter.TokenPos().Pos());

  EXPECT_EQ(3, iter.TryIndex());
  EXPECT_EQ(static_cast<uword>(80), iter.PcOffset());
  EXPECT_EQ(150, iter.TokenPos().Pos());
  EXPECT_EQ(UntaggedPcDescriptors::kOther, iter.Kind());

  EXPECT_EQ(false, iter.MoveNext());
}

ISOLATE_UNIT_TEST_CASE(PcDescriptorsLargeDeltas) {
  DescriptorList* builder = new DescriptorList(thread->zone());

  // kind, pc_offset, deopt_id, token_pos, try_index
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 100, 1,
                         TokenPosition::Deserialize(200), 1, 10);
  builder->AddDescriptor(UntaggedPcDescriptors::kDeopt, 200, 2,
                         TokenPosition::Deserialize(300), 0, -1);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 300, 3,
                         TokenPosition::Deserialize(400), 1, 10);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 100, 4,
                         TokenPosition::Deserialize(0), 2, 20);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 100, 5,
                         TokenPosition::Deserialize(800), 3, 30);
  builder->AddDescriptor(UntaggedPcDescriptors::kOther, 800, 6,
                         TokenPosition::Deserialize(150), 3, 30);

  PcDescriptors& descriptors = PcDescriptors::Handle();
  descriptors ^= builder->FinalizePcDescriptors(0);

  extern void GenerateIncrement(compiler::Assembler * assembler);
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler _assembler_(&object_pool_builder);
  GenerateIncrement(&_assembler_);
  SafepointWriteRwLocker locker(thread,
                                thread->isolate_group()->program_lock());
  Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
      Function::Handle(CreateFunction("Test_Code")), nullptr, &_assembler_,
      Code::PoolAttachment::kAttachPool));
  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, UntaggedPcDescriptors::kAnyKind);

  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(10, iter.YieldIndex());
  EXPECT_EQ(200, iter.TokenPos().Pos());
  EXPECT_EQ(1, iter.TryIndex());
  EXPECT_EQ(static_cast<uword>(100), iter.PcOffset());
  EXPECT_EQ(1, iter.DeoptId());
  EXPECT_EQ(UntaggedPcDescriptors::kOther, iter.Kind());

  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(-1, iter.YieldIndex());
  EXPECT_EQ(300, iter.TokenPos().Pos());
  EXPECT_EQ(UntaggedPcDescriptors::kDeopt, iter.Kind());

  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(10, iter.YieldIndex());
  EXPECT_EQ(400, iter.TokenPos().Pos());

  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(20, iter.YieldIndex());
  EXPECT_EQ(0, iter.TokenPos().Pos());

  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(30, iter.YieldIndex());
  EXPECT_EQ(800, iter.TokenPos().Pos());

  EXPECT_EQ(true, iter.MoveNext());
  EXPECT_EQ(30, iter.YieldIndex());
  EXPECT_EQ(150, iter.TokenPos().Pos());

  EXPECT_EQ(3, iter.TryIndex());
  EXPECT_EQ(static_cast<uword>(800), iter.PcOffset());
  EXPECT_EQ(150, iter.TokenPos().Pos());
  EXPECT_EQ(UntaggedPcDescriptors::kOther, iter.Kind());

  EXPECT_EQ(false, iter.MoveNext());
}

static ClassPtr 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()));
  return cls.ptr();
}

static FieldPtr CreateTestField(const char* name) {
  auto thread = Thread::Current();
  const Class& cls = Class::Handle(CreateTestClass("global:"));
  const String& field_name = String::Handle(Symbols::New(thread, name));
  const Field& field = Field::Handle(Field::New(
      field_name, true, false, false, true, false, cls, Object::dynamic_type(),
      TokenPosition::kMinSource, TokenPosition::kMinSource));
  {
    SafepointWriteRwLocker locker(thread,
                                  thread->isolate_group()->program_lock());
    thread->isolate_group()->RegisterStaticField(field, Object::sentinel());
  }
  return field.ptr();
}

ISOLATE_UNIT_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.ptr() == ae66.ptr()) || (cls.ptr() == re44.ptr()));
    count++;
  }
  EXPECT(count == 2);
}

static FunctionPtr 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 bool is_static = false;
  const bool is_const = false;
  const bool is_abstract = false;
  const bool is_external = false;
  const bool is_native = false;
  const FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  return Function::New(signature, function_name,
                       UntaggedFunction::kRegularFunction, is_static, is_const,
                       is_abstract, is_external, is_native, cls,
                       TokenPosition::kMinSource);
}

ISOLATE_UNIT_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 intptr_t kTypeArgsLen = 0;
  const intptr_t kNumArgs = 1;
  const Array& args_descriptor = Array::Handle(ArgumentsDescriptor::NewBoxed(
      kTypeArgsLen, kNumArgs, Object::null_array()));
  ICData& o1 = ICData::Handle();
  o1 = ICData::New(function, target_name, args_descriptor, id, num_args_tested,
                   ICData::kInstance);
  EXPECT_EQ(1, o1.NumArgsTested());
  EXPECT_EQ(id, o1.deopt_id());
  EXPECT_EQ(function.ptr(), o1.Owner());
  EXPECT_EQ(0, o1.NumberOfChecks());
  EXPECT_EQ(target_name.ptr(), o1.target_name());
  EXPECT_EQ(args_descriptor.ptr(), o1.arguments_descriptor());

  const Function& target1 = Function::Handle(GetDummyTarget("Thun"));
  o1.AddReceiverCheck(kSmiCid, target1);
  EXPECT_EQ(1, o1.NumberOfChecks());
  EXPECT_EQ(1, o1.NumberOfUsedChecks());
  intptr_t test_class_id = -1;
  Function& test_target = Function::Handle();
  o1.GetOneClassCheckAt(0, &test_class_id, &test_target);
  EXPECT_EQ(kSmiCid, test_class_id);
  EXPECT_EQ(target1.ptr(), test_target.ptr());
  EXPECT_EQ(kSmiCid, o1.GetCidAt(0));
  GrowableArray<intptr_t> test_class_ids;
  o1.GetCheckAt(0, &test_class_ids, &test_target);
  EXPECT_EQ(1, test_class_ids.length());
  EXPECT_EQ(kSmiCid, test_class_ids[0]);
  EXPECT_EQ(target1.ptr(), test_target.ptr());

  const Function& target2 = Function::Handle(GetDummyTarget("Thun"));
  o1.AddReceiverCheck(kDoubleCid, target2);
  EXPECT_EQ(2, o1.NumberOfChecks());
  EXPECT_EQ(2, o1.NumberOfUsedChecks());
  o1.GetOneClassCheckAt(1, &test_class_id, &test_target);
  EXPECT_EQ(kDoubleCid, test_class_id);
  EXPECT_EQ(target2.ptr(), test_target.ptr());
  EXPECT_EQ(kDoubleCid, o1.GetCidAt(1));

  o1.AddReceiverCheck(kMintCid, target2);
  EXPECT_EQ(3, o1.NumberOfUsedChecks());
  o1.SetCountAt(o1.NumberOfChecks() - 1, 0);
  EXPECT_EQ(2, o1.NumberOfUsedChecks());

  ICData& o2 = ICData::Handle();
  o2 = ICData::New(function, target_name, args_descriptor, 57, 2,
                   ICData::kInstance);
  EXPECT_EQ(2, o2.NumArgsTested());
  EXPECT_EQ(57, o2.deopt_id());
  EXPECT_EQ(function.ptr(), o2.Owner());
  EXPECT_EQ(0, o2.NumberOfChecks());
  GrowableArray<intptr_t> classes;
  classes.Add(kSmiCid);
  classes.Add(kSmiCid);
  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.ptr(), test_target.ptr());

  // Check ICData for unoptimized static calls.
  const intptr_t kNumArgsChecked = 0;
  const ICData& scall_icdata = ICData::Handle(
      ICData::NewForStaticCall(function, target1, args_descriptor, 57,
                               kNumArgsChecked, ICData::kInstance));
  EXPECT_EQ(target1.ptr(), scall_icdata.GetTargetAt(0));
}

ISOLATE_UNIT_TEST_CASE(SubtypeTestCache) {
  SafepointMutexLocker ml(thread->isolate_group()->subtype_test_cache_mutex());

  String& class1_name = String::Handle(Symbols::New(thread, "EmptyClass1"));
  Script& script = Script::Handle();
  const Class& empty_class1 =
      Class::Handle(CreateDummyClass(class1_name, script));
  String& class2_name = String::Handle(Symbols::New(thread, "EmptyClass2"));
  const Class& empty_class2 =
      Class::Handle(CreateDummyClass(class2_name, script));
  SubtypeTestCache& cache = SubtypeTestCache::Handle(
      SubtypeTestCache::New(SubtypeTestCache::kMaxInputs));
  EXPECT(!cache.IsNull());
  EXPECT_EQ(0, cache.NumberOfChecks());
  const Object& class_id_or_fun = Object::Handle(Smi::New(empty_class1.id()));
  const AbstractType& dest_type =
      AbstractType::Handle(Type::NewNonParameterizedType(empty_class2));
  const TypeArguments& targ_0 = TypeArguments::Handle(TypeArguments::New(2));
  const TypeArguments& targ_1 = TypeArguments::Handle(TypeArguments::New(3));
  const TypeArguments& targ_2 = TypeArguments::Handle(TypeArguments::New(4));
  const TypeArguments& targ_3 = TypeArguments::Handle(TypeArguments::New(5));
  const TypeArguments& targ_4 = TypeArguments::Handle(TypeArguments::New(6));
  cache.AddCheck(class_id_or_fun, dest_type, targ_0, targ_1, targ_2, targ_3,
                 targ_4, Bool::True());
  EXPECT_EQ(1, cache.NumberOfChecks());
  Object& test_class_id_or_fun = Object::Handle();
  AbstractType& test_dest_type = AbstractType::Handle();
  TypeArguments& test_targ_0 = TypeArguments::Handle();
  TypeArguments& test_targ_1 = TypeArguments::Handle();
  TypeArguments& test_targ_2 = TypeArguments::Handle();
  TypeArguments& test_targ_3 = TypeArguments::Handle();
  TypeArguments& test_targ_4 = TypeArguments::Handle();
  Bool& test_result = Bool::Handle();
  cache.GetCheck(0, &test_class_id_or_fun, &test_dest_type, &test_targ_0,
                 &test_targ_1, &test_targ_2, &test_targ_3, &test_targ_4,
                 &test_result);
  EXPECT_EQ(class_id_or_fun.ptr(), test_class_id_or_fun.ptr());
  EXPECT_EQ(dest_type.ptr(), test_dest_type.ptr());
  EXPECT_EQ(targ_0.ptr(), test_targ_0.ptr());
  EXPECT_EQ(targ_1.ptr(), test_targ_1.ptr());
  EXPECT_EQ(targ_2.ptr(), test_targ_2.ptr());
  EXPECT_EQ(targ_3.ptr(), test_targ_3.ptr());
  EXPECT_EQ(targ_4.ptr(), test_targ_4.ptr());
  EXPECT_EQ(Bool::True().ptr(), test_result.ptr());
}

ISOLATE_UNIT_TEST_CASE(MegamorphicCache) {
  const auto& name = String::Handle(Symbols::New(thread, "name"));
  const auto& args_descriptor =
      Array::Handle(ArgumentsDescriptor::NewBoxed(1, 1, Object::null_array()));

  const auto& cidA = Smi::Handle(Smi::New(1));
  const auto& cidB = Smi::Handle(Smi::New(2));

  const auto& valueA = Smi::Handle(Smi::New(42));
  const auto& valueB = Smi::Handle(Smi::New(43));

  // Test normal insert/lookup methods.
  {
    const auto& cache =
        MegamorphicCache::Handle(MegamorphicCache::New(name, args_descriptor));

    EXPECT(cache.Lookup(cidA) == Object::null());
    cache.EnsureContains(cidA, valueA);
    EXPECT(cache.Lookup(cidA) == valueA.ptr());

    EXPECT(cache.Lookup(cidB) == Object::null());
    cache.EnsureContains(cidB, valueB);
    EXPECT(cache.Lookup(cidB) == valueB.ptr());
  }

  // Try to insert many keys to hit collisions & growth.
  {
    const auto& cache =
        MegamorphicCache::Handle(MegamorphicCache::New(name, args_descriptor));

    auto& cid = Smi::Handle();
    auto& value = Object::Handle();
    for (intptr_t i = 0; i < 100; ++i) {
      cid = Smi::New(100 * i);
      if (cid.Value() == kIllegalCid) continue;

      value = Smi::New(i);
      cache.EnsureContains(cid, value);
    }
    auto& expected = Object::Handle();
    for (intptr_t i = 0; i < 100; ++i) {
      cid = Smi::New(100 * i);
      if (cid.Value() == kIllegalCid) continue;

      expected = Smi::New(i);
      value = cache.Lookup(cid);
      EXPECT(Smi::Cast(value).Equals(Smi::Cast(expected)));
    }
  }
}

ISOLATE_UNIT_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);

ISOLATE_UNIT_TEST_CASE(EqualsIgnoringPrivate) {
  String& mangled_name = String::Handle();
  String& bare_name = String::Handle();

  // Simple matches.
  mangled_name = OneByteString::New("foo");
  bare_name = OneByteString::New("foo");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  mangled_name = OneByteString::New("foo.");
  bare_name = OneByteString::New("foo.");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  mangled_name = OneByteString::New("foo.named");
  bare_name = OneByteString::New("foo.named");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Simple mismatches.
  mangled_name = OneByteString::New("bar");
  bare_name = OneByteString::New("foo");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  mangled_name = OneByteString::New("foo.");
  bare_name = OneByteString::New("foo");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  mangled_name = OneByteString::New("foo");
  bare_name = OneByteString::New("foo.");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  mangled_name = OneByteString::New("foo.name");
  bare_name = OneByteString::New("foo.named");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  mangled_name = OneByteString::New("foo.named");
  bare_name = OneByteString::New("foo.name");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Private match.
  mangled_name = OneByteString::New("foo@12345");
  bare_name = OneByteString::New("foo");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Private mismatch.
  mangled_name = OneByteString::New("food@12345");
  bare_name = OneByteString::New("foo");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Private mismatch 2.
  mangled_name = OneByteString::New("foo@12345");
  bare_name = OneByteString::New("food");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Private mixin application match.
  mangled_name = OneByteString::New("_M1@12345&_M2@12345&_M3@12345");
  bare_name = OneByteString::New("_M1&_M2&_M3");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Private mixin application mismatch.
  mangled_name = OneByteString::New("_M1@12345&_M2@12345&_M3@12345");
  bare_name = OneByteString::New("_M1&_M2&_M4");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Private constructor match.
  mangled_name = OneByteString::New("foo@12345.");
  bare_name = OneByteString::New("foo.");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Private constructor mismatch.
  mangled_name = OneByteString::New("foo@12345.");
  bare_name = OneByteString::New("foo");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Private constructor mismatch 2.
  mangled_name = OneByteString::New("foo@12345");
  bare_name = OneByteString::New("foo.");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Named private constructor match.
  mangled_name = OneByteString::New("foo@12345.named");
  bare_name = OneByteString::New("foo.named");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Named private constructor mismatch.
  mangled_name = OneByteString::New("foo@12345.name");
  bare_name = OneByteString::New("foo.named");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Named private constructor mismatch 2.
  mangled_name = OneByteString::New("foo@12345.named");
  bare_name = OneByteString::New("foo.name");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Named double-private constructor match.  Yes, this happens.
  mangled_name = OneByteString::New("foo@12345.named@12345");
  bare_name = OneByteString::New("foo.named");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Named double-private constructor match where the caller knows the private
  // key.  Yes, this also happens.
  mangled_name = OneByteString::New("foo@12345.named@12345");
  bare_name = OneByteString::New("foo@12345.named");
  EXPECT(String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Named double-private constructor mismatch.
  mangled_name = OneByteString::New("foo@12345.name@12345");
  bare_name = OneByteString::New("foo.named");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));

  // Named double-private constructor mismatch.
  mangled_name = OneByteString::New("foo@12345.named@12345");
  bare_name = OneByteString::New("foo.name");
  EXPECT(!String::EqualsIgnoringPrivateKey(mangled_name, bare_name));
}

ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION(ArrayNew_Overflow_Crash, "Crash") {
  Array::Handle(Array::New(Array::kMaxElements + 1));
}

TEST_CASE(StackTraceFormat) {
  const char* kScriptChars =
      "void baz() {\n"
      "  throw 'MyException';\n"
      "}\n"
      "\n"
      "class _OtherClass {\n"
      "  _OtherClass._named() {\n"
      "    baz();\n"
      "  }\n"
      "}\n"
      "\n"
      "set globalVar(var value) {\n"
      "  new _OtherClass._named();\n"
      "}\n"
      "\n"
      "void _bar() {\n"
      "  globalVar = null;\n"
      "}\n"
      "\n"
      "class MyClass {\n"
      "  MyClass() {\n"
      "    (() => foo())();\n"
      "  }\n"
      "\n"
      "  static get field {\n"
      "    _bar();\n"
      "  }\n"
      "\n"
      "  static foo() {\n"
      "    fooHelper() {\n"
      "      field;\n"
      "    }\n"
      "    fooHelper();\n"
      "  }\n"
      "}\n"
      "\n"
      "main() {\n"
      "  (() => new MyClass())();\n"
      "}\n";
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, nullptr);

  const char* lib_url = "file:///test-lib";
  const size_t kBufferSize = 1024;
  char expected[kBufferSize];
  snprintf(expected, kBufferSize,
           "Unhandled exception:\n"
           "MyException\n"
           "#0      baz (%1$s:2:3)\n"
           "#1      new _OtherClass._named (%1$s:7:5)\n"
           "#2      globalVar= (%1$s:12:7)\n"
           "#3      _bar (%1$s:16:3)\n"
           "#4      MyClass.field (%1$s:25:5)\n"
           "#5      MyClass.foo.fooHelper (%1$s:30:7)\n"
           "#6      MyClass.foo (%1$s:32:5)\n"
           "#7      new MyClass.<anonymous closure> (%1$s:21:12)\n"
           "#8      new MyClass (%1$s:21:18)\n"
           "#9      main.<anonymous closure> (%1$s:37:14)\n"
           "#10     main (%1$s:37:24)",
           lib_url);

  EXPECT_ERROR(result, expected);
}

ISOLATE_UNIT_TEST_CASE(WeakProperty_PreserveRecurse) {
  // This used to end in an infinite recursion. Caused by scavenging the weak
  // property before scavenging the key.
  WeakProperty& weak = WeakProperty::Handle();
  Array& arr = Array::Handle(Array::New(1));
  {
    HANDLESCOPE(thread);
    String& key = String::Handle();
    key ^= OneByteString::New("key");
    arr.SetAt(0, key);
    String& value = String::Handle();
    value ^= OneByteString::New("value");
    weak ^= WeakProperty::New();
    weak.set_key(key);
    weak.set_value(value);
  }
  GCTestHelper::CollectAllGarbage();
  EXPECT(weak.key() != Object::null());
  EXPECT(weak.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE(WeakProperty_PreserveOne_NewSpace) {
  WeakProperty& weak = WeakProperty::Handle();
  String& key = String::Handle();
  key ^= OneByteString::New("key");
  {
    HANDLESCOPE(thread);
    String& value = String::Handle();
    value ^= OneByteString::New("value");
    weak ^= WeakProperty::New();
    weak.set_key(key);
    weak.set_value(value);
  }
  GCTestHelper::CollectNewSpace();
  EXPECT(weak.key() != Object::null());
  EXPECT(weak.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE(WeakProperty_PreserveTwo_NewSpace) {
  WeakProperty& weak1 = WeakProperty::Handle();
  String& key1 = String::Handle();
  key1 ^= OneByteString::New("key1");
  WeakProperty& weak2 = WeakProperty::Handle();
  String& key2 = String::Handle();
  key2 ^= OneByteString::New("key2");
  {
    HANDLESCOPE(thread);
    String& value1 = String::Handle();
    value1 ^= OneByteString::New("value1");
    weak1 ^= WeakProperty::New();
    weak1.set_key(key1);
    weak1.set_value(value1);
    String& value2 = String::Handle();
    value2 ^= OneByteString::New("value2");
    weak2 ^= WeakProperty::New();
    weak2.set_key(key2);
    weak2.set_value(value2);
  }
  GCTestHelper::CollectNewSpace();
  EXPECT(weak1.key() != Object::null());
  EXPECT(weak1.value() != Object::null());
  EXPECT(weak2.key() != Object::null());
  EXPECT(weak2.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE(WeakProperty_PreserveTwoShared_NewSpace) {
  WeakProperty& weak1 = WeakProperty::Handle();
  WeakProperty& weak2 = WeakProperty::Handle();
  String& key = String::Handle();
  key ^= OneByteString::New("key");
  {
    HANDLESCOPE(thread);
    String& value1 = String::Handle();
    value1 ^= OneByteString::New("value1");
    weak1 ^= WeakProperty::New();
    weak1.set_key(key);
    weak1.set_value(value1);
    String& value2 = String::Handle();
    value2 ^= OneByteString::New("value2");
    weak2 ^= WeakProperty::New();
    weak2.set_key(key);
    weak2.set_value(value2);
  }
  GCTestHelper::CollectNewSpace();
  EXPECT(weak1.key() != Object::null());
  EXPECT(weak1.value() != Object::null());
  EXPECT(weak2.key() != Object::null());
  EXPECT(weak2.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE(WeakProperty_PreserveOne_OldSpace) {
  WeakProperty& weak = WeakProperty::Handle();
  String& key = String::Handle();
  key ^= OneByteString::New("key", Heap::kOld);
  {
    HANDLESCOPE(thread);
    String& value = String::Handle();
    value ^= OneByteString::New("value", Heap::kOld);
    weak ^= WeakProperty::New(Heap::kOld);
    weak.set_key(key);
    weak.set_value(value);
  }
  GCTestHelper::CollectAllGarbage();
  EXPECT(weak.key() != Object::null());
  EXPECT(weak.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE(WeakProperty_PreserveTwo_OldSpace) {
  WeakProperty& weak1 = WeakProperty::Handle();
  String& key1 = String::Handle();
  key1 ^= OneByteString::New("key1", Heap::kOld);
  WeakProperty& weak2 = WeakProperty::Handle();
  String& key2 = String::Handle();
  key2 ^= OneByteString::New("key2", Heap::kOld);
  {
    HANDLESCOPE(thread);
    String& value1 = String::Handle();
    value1 ^= OneByteString::New("value1", Heap::kOld);
    weak1 ^= WeakProperty::New(Heap::kOld);
    weak1.set_key(key1);
    weak1.set_value(value1);
    String& value2 = String::Handle();
    value2 ^= OneByteString::New("value2", Heap::kOld);
    weak2 ^= WeakProperty::New(Heap::kOld);
    weak2.set_key(key2);
    weak2.set_value(value2);
  }
  GCTestHelper::CollectAllGarbage();
  EXPECT(weak1.key() != Object::null());
  EXPECT(weak1.value() != Object::null());
  EXPECT(weak2.key() != Object::null());
  EXPECT(weak2.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE(WeakProperty_PreserveTwoShared_OldSpace) {
  WeakProperty& weak1 = WeakProperty::Handle();
  WeakProperty& weak2 = WeakProperty::Handle();
  String& key = String::Handle();
  key ^= OneByteString::New("key", Heap::kOld);
  {
    HANDLESCOPE(thread);
    String& value1 = String::Handle();
    value1 ^= OneByteString::New("value1", Heap::kOld);
    weak1 ^= WeakProperty::New(Heap::kOld);
    weak1.set_key(key);
    weak1.set_value(value1);
    String& value2 = String::Handle();
    value2 ^= OneByteString::New("value2", Heap::kOld);
    weak2 ^= WeakProperty::New(Heap::kOld);
    weak2.set_key(key);
    weak2.set_value(value2);
  }
  GCTestHelper::CollectAllGarbage();
  EXPECT(weak1.key() != Object::null());
  EXPECT(weak1.value() != Object::null());
  EXPECT(weak2.key() != Object::null());
  EXPECT(weak2.value() != Object::null());
}

ISOLATE_UNIT_TEST_CASE(WeakProperty_ClearOne_NewSpace) {
  WeakProperty& weak = WeakProperty::Handle();
  {
    HANDLESCOPE(thread);
    String& key = String::Handle();
    key ^= OneByteString::New("key");
    String& value = String::Handle();
    value ^= OneByteString::New("value");
    weak ^= WeakProperty::New();
    weak.set_key(key);
    weak.set_value(value);
    key ^= OneByteString::null();
    value ^= OneByteString::null();
  }
  GCTestHelper::CollectNewSpace();
  EXPECT(weak.key() == Object::null());
  EXPECT(weak.value() == Object::null());
}

ISOLATE_UNIT_TEST_CASE(WeakProperty_ClearTwoShared_NewSpace) {
  WeakProperty& weak1 = WeakProperty::Handle();
  WeakProperty& weak2 = WeakProperty::Handle();
  {
    HANDLESCOPE(thread);
    String& key = String::Handle();
    key ^= OneByteString::New("key");
    String& value1 = String::Handle();
    value1 ^= OneByteString::New("value1");
    weak1 ^= WeakProperty::New();
    weak1.set_key(key);
    weak1.set_value(value1);
    String& value2 = String::Handle();
    value2 ^= OneByteString::New("value2");
    weak2 ^= WeakProperty::New();
    weak2.set_key(key);
    weak2.set_value(value2);
  }
  GCTestHelper::CollectNewSpace();
  EXPECT(weak1.key() == Object::null());
  EXPECT(weak1.value() == Object::null());
  EXPECT(weak2.key() == Object::null());
  EXPECT(weak2.value() == Object::null());
}

ISOLATE_UNIT_TEST_CASE(WeakProperty_ClearOne_OldSpace) {
  WeakProperty& weak = WeakProperty::Handle();
  {
    HANDLESCOPE(thread);
    String& key = String::Handle();
    key ^= OneByteString::New("key", Heap::kOld);
    String& value = String::Handle();
    value ^= OneByteString::New("value", Heap::kOld);
    weak ^= WeakProperty::New(Heap::kOld);
    weak.set_key(key);
    weak.set_value(value);
    key ^= OneByteString::null();
    value ^= OneByteString::null();
  }
  GCTestHelper::CollectAllGarbage();
  EXPECT(weak.key() == Object::null());
  EXPECT(weak.value() == Object::null());
}

ISOLATE_UNIT_TEST_CASE(WeakProperty_ClearTwoShared_OldSpace) {
  WeakProperty& weak1 = WeakProperty::Handle();
  WeakProperty& weak2 = WeakProperty::Handle();
  {
    HANDLESCOPE(thread);
    String& key = String::Handle();
    key ^= OneByteString::New("key", Heap::kOld);
    String& value1 = String::Handle();
    value1 ^= OneByteString::New("value1");
    weak1 ^= WeakProperty::New(Heap::kOld);
    weak1.set_key(key);
    weak1.set_value(value1);
    String& value2 = String::Handle();
    value2 ^= OneByteString::New("value2", Heap::kOld);
    weak2 ^= WeakProperty::New(Heap::kOld);
    weak2.set_key(key);
    weak2.set_value(value2);
  }
  GCTestHelper::CollectAllGarbage();
  EXPECT(weak1.key() == Object::null());
  EXPECT(weak1.value() == Object::null());
  EXPECT(weak2.key() == Object::null());
  EXPECT(weak2.value() == Object::null());
}

static void WeakReference_PreserveOne(Thread* thread, Heap::Space space) {
  auto& weak = WeakReference::Handle();
  const auto& target = String::Handle(OneByteString::New("target", space));
  {
    HANDLESCOPE(thread);
    ObjectStore* object_store = thread->isolate_group()->object_store();
    const auto& type_arguments =
        TypeArguments::Handle(object_store->type_argument_double());
    weak ^= WeakReference::New(space);
    weak.set_target(target);
    weak.SetTypeArguments(type_arguments);
  }

  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }

  EXPECT(weak.target() != Object::null());
  EXPECT(weak.GetTypeArguments() != Object::null());
}

ISOLATE_UNIT_TEST_CASE(WeakReference_PreserveOne_NewSpace) {
  WeakReference_PreserveOne(thread, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE(WeakReference_PreserveOne_OldSpace) {
  WeakReference_PreserveOne(thread, Heap::kOld);
}

static void WeakReference_ClearOne(Thread* thread, Heap::Space space) {
  auto& weak = WeakReference::Handle();
  {
    HANDLESCOPE(thread);
    const auto& target = String::Handle(OneByteString::New("target", space));
    ObjectStore* object_store = thread->isolate_group()->object_store();
    const auto& type_arguments =
        TypeArguments::Handle(object_store->type_argument_double());
    weak ^= WeakReference::New(space);
    weak.set_target(target);
    weak.SetTypeArguments(type_arguments);
  }

  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }

  EXPECT(weak.target() == Object::null());
  EXPECT(weak.GetTypeArguments() != Object::null());
}

ISOLATE_UNIT_TEST_CASE(WeakReference_ClearOne_NewSpace) {
  WeakReference_ClearOne(thread, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE(WeakReference_ClearOne_OldSpace) {
  WeakReference_ClearOne(thread, Heap::kOld);
}

static void WeakReference_Clear_ReachableThroughWeakProperty(
    Thread* thread,
    Heap::Space space) {
  auto& weak_property = WeakProperty::Handle();
  const auto& key = String::Handle(OneByteString::New("key", space));
  {
    HANDLESCOPE(thread);
    ObjectStore* object_store = thread->isolate_group()->object_store();
    const auto& type_arguments =
        TypeArguments::Handle(object_store->type_argument_double());
    const auto& weak_reference =
        WeakReference::Handle(WeakReference::New(space));
    const auto& target = String::Handle(OneByteString::New("target", space));
    weak_reference.set_target(target);
    weak_reference.SetTypeArguments(type_arguments);

    weak_property ^= WeakProperty::New(space);
    weak_property.set_key(key);
    weak_property.set_value(weak_reference);
  }

  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }

  const auto& weak_reference =
      WeakReference::CheckedHandle(Z, weak_property.value());
  EXPECT(weak_reference.target() == Object::null());
  EXPECT(weak_reference.GetTypeArguments() != Object::null());
}

ISOLATE_UNIT_TEST_CASE(
    WeakReference_Clear_ReachableThroughWeakProperty_NewSpace) {
  WeakReference_Clear_ReachableThroughWeakProperty(thread, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE(
    WeakReference_Clear_ReachableThroughWeakProperty_OldSpace) {
  WeakReference_Clear_ReachableThroughWeakProperty(thread, Heap::kOld);
}

static void WeakReference_Preserve_ReachableThroughWeakProperty(
    Thread* thread,
    Heap::Space space) {
  auto& weak_property = WeakProperty::Handle();
  const auto& key = String::Handle(OneByteString::New("key", space));
  const auto& target = String::Handle(OneByteString::New("target", space));
  {
    HANDLESCOPE(thread);
    ObjectStore* object_store = thread->isolate_group()->object_store();
    const auto& type_arguments =
        TypeArguments::Handle(object_store->type_argument_double());
    const auto& weak_reference =
        WeakReference::Handle(WeakReference::New(space));
    weak_reference.set_target(target);
    weak_reference.SetTypeArguments(type_arguments);

    weak_property ^= WeakProperty::New(space);
    weak_property.set_key(key);
    weak_property.set_value(weak_reference);
  }

  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }

  const auto& weak_reference =
      WeakReference::CheckedHandle(Z, weak_property.value());
  EXPECT(weak_reference.target() != Object::null());
  EXPECT(weak_reference.GetTypeArguments() != Object::null());
}

ISOLATE_UNIT_TEST_CASE(
    WeakReference_Preserve_ReachableThroughWeakProperty_NewSpace) {
  WeakReference_Preserve_ReachableThroughWeakProperty(thread, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE(
    WeakReference_Preserve_ReachableThroughWeakProperty_OldSpace) {
  WeakReference_Preserve_ReachableThroughWeakProperty(thread, Heap::kOld);
}

ISOLATE_UNIT_TEST_CASE(WeakArray_New) {
  WeakArray& array = WeakArray::Handle(WeakArray::New(2, Heap::kNew));
  Object& target0 = Object::Handle();
  {
    HANDLESCOPE(thread);
    target0 = String::New("0", Heap::kNew);
    Object& target1 = Object::Handle(String::New("1", Heap::kNew));
    array.SetAt(0, target0);
    array.SetAt(1, target1);
  }

  EXPECT(array.Length() == 2);
  EXPECT(array.At(0) != Object::null());
  EXPECT(array.At(1) != Object::null());

  GCTestHelper::CollectNewSpace();

  EXPECT(array.Length() == 2);
  EXPECT(array.At(0) != Object::null());  // Survives
  EXPECT(array.At(1) == Object::null());  // Cleared
}

ISOLATE_UNIT_TEST_CASE(WeakArray_Old) {
  WeakArray& array = WeakArray::Handle(WeakArray::New(2, Heap::kOld));
  Object& target0 = Object::Handle();
  {
    HANDLESCOPE(thread);
    target0 = String::New("0", Heap::kOld);
    Object& target1 = Object::Handle(String::New("1", Heap::kOld));
    array.SetAt(0, target0);
    array.SetAt(1, target1);
  }

  EXPECT(array.Length() == 2);
  EXPECT(array.At(0) != Object::null());
  EXPECT(array.At(1) != Object::null());

  GCTestHelper::CollectAllGarbage();

  EXPECT(array.Length() == 2);
  EXPECT(array.At(0) != Object::null());  // Survives
  EXPECT(array.At(1) == Object::null());  // Cleared
}

static int NumEntries(const FinalizerEntry& entry, intptr_t acc = 0) {
  if (entry.IsNull()) {
    return acc;
  }
  return NumEntries(FinalizerEntry::Handle(entry.next()), acc + 1);
}

static void Finalizer_PreserveOne(Thread* thread,
                                  Heap::Space space,
                                  bool with_detach) {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif

  MessageHandler* handler = thread->isolate()->message_handler();
  EXPECT_EQ(0, handler->GetMessageCounts().num_messages);

  const auto& finalizer = Finalizer::Handle(Finalizer::New(space));
  finalizer.set_isolate(thread->isolate());
  const auto& entry =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, space));
  const auto& value = String::Handle(OneByteString::New("value", space));
  entry.set_value(value);
  auto& detach = Object::Handle();
  if (with_detach) {
    detach = OneByteString::New("detach", space);
  } else {
    detach = Object::null();
  }
  entry.set_detach(detach);
  const auto& token = String::Handle(OneByteString::New("token", space));
  entry.set_token(token);

  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }

  // Nothing in the entry should have been collected.
  EXPECT_NE(Object::null(), entry.value());
  EXPECT((entry.detach() == Object::null()) ^ with_detach);
  EXPECT_NE(Object::null(), entry.token());

  // The entry should not have moved to the collected list.
  EXPECT_EQ(0,
            NumEntries(FinalizerEntry::Handle(finalizer.entries_collected())));

  // We should have no messages.
  EXPECT(!handler->HasMessages());
}

ISOLATE_UNIT_TEST_CASE(Finalizer_PreserveNoDetachOne_NewSpace) {
  Finalizer_PreserveOne(thread, Heap::kNew, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_PreserveNoDetachOne_OldSpace) {
  Finalizer_PreserveOne(thread, Heap::kOld, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_PreserveWithDetachOne_NewSpace) {
  Finalizer_PreserveOne(thread, Heap::kNew, true);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_PreserveWithDetachOne_OldSpace) {
  Finalizer_PreserveOne(thread, Heap::kOld, true);
}

static void Finalizer_ClearDetachOne(Thread* thread, Heap::Space space) {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif

  MessageHandler* handler = thread->isolate()->message_handler();
  EXPECT(!handler->HasMessages());

  const auto& finalizer = Finalizer::Handle(Finalizer::New(space));
  finalizer.set_isolate(thread->isolate());
  const auto& entry =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, space));
  const auto& value = String::Handle(OneByteString::New("value", space));
  entry.set_value(value);
  const auto& token = String::Handle(OneByteString::New("token", space));
  entry.set_token(token);

  {
    HANDLESCOPE(thread);
    const auto& detach = String::Handle(OneByteString::New("detach", space));
    entry.set_detach(detach);
  }

  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }

  // Detach should have been collected.
  EXPECT_NE(Object::null(), entry.value());
  EXPECT_EQ(Object::null(), entry.detach());
  EXPECT_NE(Object::null(), entry.token());

  // The entry should not have moved to the collected list.
  EXPECT_EQ(0,
            NumEntries(FinalizerEntry::Handle(finalizer.entries_collected())));

  // We should have no messages.
  EXPECT(!handler->HasMessages());
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearDetachOne_NewSpace) {
  Finalizer_ClearDetachOne(thread, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearDetachOne_OldSpace) {
  Finalizer_ClearDetachOne(thread, Heap::kOld);
}

static void Finalizer_ClearValueOne(Thread* thread,
                                    Heap::Space space,
                                    bool null_token) {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif

  MessageHandler* handler = thread->isolate()->message_handler();
  EXPECT(!handler->HasMessages());

  const auto& finalizer = Finalizer::Handle(Finalizer::New(space));
  finalizer.set_isolate(thread->isolate());
  const auto& entry =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, space));
  const auto& detach = String::Handle(OneByteString::New("detach", space));
  auto& token = Object::Handle();
  if (null_token) {
    // Null is a valid token in Dart finalizers.
    token = Object::null();
  } else {
    token = OneByteString::New("token", space);
  }
  entry.set_token(token);
  entry.set_detach(detach);

  {
    HANDLESCOPE(thread);
    const auto& value = String::Handle(OneByteString::New("value", space));
    entry.set_value(value);
  }

  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }

  // Value should have been collected.
  EXPECT_EQ(Object::null(), entry.value());
  EXPECT_NE(Object::null(), entry.detach());

  // The entry should have moved to the collected list.
  EXPECT_EQ(1,
            NumEntries(FinalizerEntry::Handle(finalizer.entries_collected())));

  // We should have 1 message.
  EXPECT_EQ(1, handler->GetMessageCounts().num_messages);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearValueOne_NewSpace) {
  Finalizer_ClearValueOne(thread, Heap::kNew, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearValueOne_OldSpace) {
  Finalizer_ClearValueOne(thread, Heap::kOld, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearValueNullTokenOne_NewSpace) {
  Finalizer_ClearValueOne(thread, Heap::kNew, true);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearValueNullTokenOne_OldSpace) {
  Finalizer_ClearValueOne(thread, Heap::kOld, true);
}

static void Finalizer_DetachOne(Thread* thread,
                                Heap::Space space,
                                bool clear_value) {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif

  MessageHandler* handler = thread->isolate()->message_handler();
  EXPECT(!handler->HasMessages());

  const auto& finalizer = Finalizer::Handle(Finalizer::New(space));
  finalizer.set_isolate(thread->isolate());
  const auto& entry =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, space));
  const auto& detach = String::Handle(OneByteString::New("detach", space));
  entry.set_detach(detach);

  // Simulate calling detach, setting the token of the entry to the entry.
  entry.set_token(entry);

  auto& value = String::Handle();
  {
    HANDLESCOPE(thread);

    const auto& object = String::Handle(OneByteString::New("value", space));
    entry.set_value(object);
    if (!clear_value) {
      value = object.ptr();
    }
  }

  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }

  EXPECT((entry.value() == Object::null()) ^ !clear_value);
  EXPECT_NE(Object::null(), entry.detach());
  EXPECT_EQ(entry.ptr(), entry.token());

  // The entry should have been removed entirely
  EXPECT_EQ(0,
            NumEntries(FinalizerEntry::Handle(finalizer.entries_collected())));

  // We should have no message.
  EXPECT(!handler->HasMessages());
}

ISOLATE_UNIT_TEST_CASE(Finalizer_DetachOne_NewSpace) {
  Finalizer_DetachOne(thread, Heap::kNew, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_DetachOne_OldSpace) {
  Finalizer_DetachOne(thread, Heap::kOld, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_DetachAndClearValueOne_NewSpace) {
  Finalizer_DetachOne(thread, Heap::kNew, true);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_DetachAndClearValueOne_OldSpace) {
  Finalizer_DetachOne(thread, Heap::kOld, true);
}

static void Finalizer_GcFinalizer(Thread* thread, Heap::Space space) {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif

  MessageHandler* handler = thread->isolate()->message_handler();
  EXPECT(!handler->HasMessages());

  const auto& detach = String::Handle(OneByteString::New("detach", space));
  const auto& token = String::Handle(OneByteString::New("token", space));

  {
    HANDLESCOPE(thread);
    const auto& finalizer = Finalizer::Handle(Finalizer::New(space));
    finalizer.set_isolate(thread->isolate());
    const auto& entry =
        FinalizerEntry::Handle(FinalizerEntry::New(finalizer, space));
    entry.set_detach(detach);
    entry.set_token(token);
    const auto& value = String::Handle(OneByteString::New("value", space));
    entry.set_value(value);
  }

  if (space == Heap::kNew) {
    GCTestHelper::CollectNewSpace();
  } else {
    GCTestHelper::CollectAllGarbage();
  }

  // We should have no message, the Finalizer itself has been GCed.
  EXPECT(!handler->HasMessages());
}

ISOLATE_UNIT_TEST_CASE(Finalizer_GcFinalizer_NewSpace) {
  Finalizer_GcFinalizer(thread, Heap::kNew);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_GcFinalizer_OldSpace) {
  Finalizer_GcFinalizer(thread, Heap::kOld);
}

static void Finalizer_TwoEntriesCrossGen(
    Thread* thread,
    Heap::Space* spaces,
    bool collect_old_space,
    bool collect_new_space,
    bool evacuate_new_space_and_collect_old_space,
    bool clear_value_1,
    bool clear_value_2,
    bool clear_detach_1,
    bool clear_detach_2) {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif

  MessageHandler* handler = thread->isolate()->message_handler();
  // We're reusing the isolate in a loop, so there are messages from previous
  // runs of this test.
  const intptr_t queue_length_start = handler->GetMessageCounts().num_messages;

  const auto& finalizer = Finalizer::Handle(Finalizer::New(spaces[0]));
  finalizer.set_isolate(thread->isolate());
  const auto& entry1 =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, spaces[1]));
  const auto& entry2 =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, spaces[2]));

  auto& value1 = String::Handle();
  auto& detach1 = String::Handle();
  const auto& token1 = String::Handle(OneByteString::New("token1", spaces[3]));
  entry1.set_token(token1);

  auto& value2 = String::Handle();
  auto& detach2 = String::Handle();
  const auto& token2 = String::Handle(OneByteString::New("token2", spaces[4]));
  entry2.set_token(token2);
  entry2.set_detach(detach2);

  {
    HANDLESCOPE(thread);
    auto& object = String::Handle();

    object ^= OneByteString::New("value1", spaces[5]);
    entry1.set_value(object);
    if (!clear_value_1) {
      value1 = object.ptr();
    }

    object ^= OneByteString::New("detach", spaces[6]);
    entry1.set_detach(object);
    if (!clear_detach_1) {
      detach1 = object.ptr();
    }

    object ^= OneByteString::New("value2", spaces[7]);
    entry2.set_value(object);
    if (!clear_value_2) {
      value2 = object.ptr();
    }

    object ^= OneByteString::New("detach", spaces[8]);
    entry2.set_detach(object);
    if (!clear_detach_2) {
      detach2 = object.ptr();
    }
  }

  if (collect_old_space) {
    GCTestHelper::CollectOldSpace();
  }
  if (collect_new_space) {
    GCTestHelper::CollectNewSpace();
  }
  if (evacuate_new_space_and_collect_old_space) {
    GCTestHelper::CollectAllGarbage();
  }

  EXPECT((entry1.value() == Object::null()) ^ !clear_value_1);
  EXPECT((entry2.value() == Object::null()) ^ !clear_value_2);
  EXPECT((entry1.detach() == Object::null()) ^ !clear_detach_1);
  EXPECT((entry2.detach() == Object::null()) ^ !clear_detach_2);
  EXPECT_NE(Object::null(), entry1.token());
  EXPECT_NE(Object::null(), entry2.token());

  const intptr_t expect_num_cleared =
      (clear_value_1 ? 1 : 0) + (clear_value_2 ? 1 : 0);
  EXPECT_EQ(expect_num_cleared,
            NumEntries(FinalizerEntry::Handle(finalizer.entries_collected())));

  const intptr_t expect_num_messages = expect_num_cleared == 0 ? 0 : 1;
  EXPECT_EQ(expect_num_messages + queue_length_start,
            handler->GetMessageCounts().num_messages);
}

const intptr_t kFinalizerTwoEntriesNumObjects = 9;

static void Finalizer_TwoEntries(Thread* thread,
                                 Heap::Space space,
                                 bool clear_value_1,
                                 bool clear_value_2,
                                 bool clear_detach_1,
                                 bool clear_detach_2) {
  const bool collect_old_space = true;
  const bool collect_new_space = space == Heap::kNew;
  const bool evacuate_new_space_and_collect_old_space = !collect_new_space;

  Heap::Space spaces[kFinalizerTwoEntriesNumObjects];
  for (intptr_t i = 0; i < kFinalizerTwoEntriesNumObjects; i++) {
    spaces[i] = space;
  }
  Finalizer_TwoEntriesCrossGen(
      thread, spaces, collect_old_space, collect_new_space,
      evacuate_new_space_and_collect_old_space, clear_value_1, clear_value_2,
      clear_detach_1, clear_detach_2);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearValueTwo_NewSpace) {
  Finalizer_TwoEntries(thread, Heap::kNew, true, true, false, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearValueTwo_OldSpace) {
  Finalizer_TwoEntries(thread, Heap::kOld, true, true, false, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearFirstValue_NewSpace) {
  Finalizer_TwoEntries(thread, Heap::kNew, true, false, false, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearFirstValue_OldSpace) {
  Finalizer_TwoEntries(thread, Heap::kOld, true, false, false, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearSecondValue_NewSpace) {
  Finalizer_TwoEntries(thread, Heap::kNew, false, true, false, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearSecondValue_OldSpace) {
  Finalizer_TwoEntries(thread, Heap::kOld, false, true, false, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_PreserveTwo_NewSpace) {
  Finalizer_TwoEntries(thread, Heap::kNew, false, false, false, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_PreserveTwo_OldSpace) {
  Finalizer_TwoEntries(thread, Heap::kOld, false, false, false, false);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearDetachTwo_NewSpace) {
  Finalizer_TwoEntries(thread, Heap::kNew, false, false, true, true);
}

ISOLATE_UNIT_TEST_CASE(Finalizer_ClearDetachTwo_OldSpace) {
  Finalizer_TwoEntries(thread, Heap::kOld, false, false, true, true);
}

static void Finalizer_TwoEntriesCrossGen(Thread* thread, intptr_t test_i) {
  ASSERT(test_i < (1 << kFinalizerTwoEntriesNumObjects));
  Heap::Space spaces[kFinalizerTwoEntriesNumObjects];
  for (intptr_t i = 0; i < kFinalizerTwoEntriesNumObjects; i++) {
    spaces[i] = ((test_i >> i) & 0x1) == 0x1 ? Heap::kOld : Heap::kNew;
  }
  // Either collect or evacuate new space.
  for (const bool collect_new_space : {false, true}) {
    // Always run old space collection first.
    const bool collect_old_space = true;
    // Always run old space collection after new space.
    const bool evacuate_new_space_and_collect_old_space = true;
    for (intptr_t test_j = 0; test_j < 16; test_j++) {
      const bool clear_value_1 = (test_j >> 0 & 0x1) == 0x1;
      const bool clear_value_2 = (test_j >> 1 & 0x1) == 0x1;
      const bool clear_detach_1 = (test_j >> 2 & 0x1) == 0x1;
      const bool clear_detach_2 = (test_j >> 3 & 0x1) == 0x1;
      Finalizer_TwoEntriesCrossGen(
          thread, spaces, collect_old_space, collect_new_space,
          evacuate_new_space_and_collect_old_space, clear_value_1,
          clear_value_2, clear_detach_1, clear_detach_2);
    }
  }
}
#define FINALIZER_CROSS_GEN_TEST_CASE(n)                                       \
  ISOLATE_UNIT_TEST_CASE(Finalizer_CrossGen_##n) {                             \
    Finalizer_TwoEntriesCrossGen(thread, n);                                   \
  }

#define REPEAT_512(V)                                                          \
  V(0)                                                                         \
  V(1)                                                                         \
  V(2)                                                                         \
  V(3)                                                                         \
  V(4)                                                                         \
  V(5)                                                                         \
  V(6)                                                                         \
  V(7)                                                                         \
  V(8)                                                                         \
  V(9)                                                                         \
  V(10)                                                                        \
  V(11)                                                                        \
  V(12)                                                                        \
  V(13)                                                                        \
  V(14)                                                                        \
  V(15)                                                                        \
  V(16)                                                                        \
  V(17)                                                                        \
  V(18)                                                                        \
  V(19)                                                                        \
  V(20)                                                                        \
  V(21)                                                                        \
  V(22)                                                                        \
  V(23)                                                                        \
  V(24)                                                                        \
  V(25)                                                                        \
  V(26)                                                                        \
  V(27)                                                                        \
  V(28)                                                                        \
  V(29)                                                                        \
  V(30)                                                                        \
  V(31)                                                                        \
  V(32)                                                                        \
  V(33)                                                                        \
  V(34)                                                                        \
  V(35)                                                                        \
  V(36)                                                                        \
  V(37)                                                                        \
  V(38)                                                                        \
  V(39)                                                                        \
  V(40)                                                                        \
  V(41)                                                                        \
  V(42)                                                                        \
  V(43)                                                                        \
  V(44)                                                                        \
  V(45)                                                                        \
  V(46)                                                                        \
  V(47)                                                                        \
  V(48)                                                                        \
  V(49)                                                                        \
  V(50)                                                                        \
  V(51)                                                                        \
  V(52)                                                                        \
  V(53)                                                                        \
  V(54)                                                                        \
  V(55)                                                                        \
  V(56)                                                                        \
  V(57)                                                                        \
  V(58)                                                                        \
  V(59)                                                                        \
  V(60)                                                                        \
  V(61)                                                                        \
  V(62)                                                                        \
  V(63)                                                                        \
  V(64)                                                                        \
  V(65)                                                                        \
  V(66)                                                                        \
  V(67)                                                                        \
  V(68)                                                                        \
  V(69)                                                                        \
  V(70)                                                                        \
  V(71)                                                                        \
  V(72)                                                                        \
  V(73)                                                                        \
  V(74)                                                                        \
  V(75)                                                                        \
  V(76)                                                                        \
  V(77)                                                                        \
  V(78)                                                                        \
  V(79)                                                                        \
  V(80)                                                                        \
  V(81)                                                                        \
  V(82)                                                                        \
  V(83)                                                                        \
  V(84)                                                                        \
  V(85)                                                                        \
  V(86)                                                                        \
  V(87)                                                                        \
  V(88)                                                                        \
  V(89)                                                                        \
  V(90)                                                                        \
  V(91)                                                                        \
  V(92)                                                                        \
  V(93)                                                                        \
  V(94)                                                                        \
  V(95)                                                                        \
  V(96)                                                                        \
  V(97)                                                                        \
  V(98)                                                                        \
  V(99)                                                                        \
  V(100)                                                                       \
  V(101)                                                                       \
  V(102)                                                                       \
  V(103)                                                                       \
  V(104)                                                                       \
  V(105)                                                                       \
  V(106)                                                                       \
  V(107)                                                                       \
  V(108)                                                                       \
  V(109)                                                                       \
  V(110)                                                                       \
  V(111)                                                                       \
  V(112)                                                                       \
  V(113)                                                                       \
  V(114)                                                                       \
  V(115)                                                                       \
  V(116)                                                                       \
  V(117)                                                                       \
  V(118)                                                                       \
  V(119)                                                                       \
  V(120)                                                                       \
  V(121)                                                                       \
  V(122)                                                                       \
  V(123)                                                                       \
  V(124)                                                                       \
  V(125)                                                                       \
  V(126)                                                                       \
  V(127)                                                                       \
  V(128)                                                                       \
  V(129)                                                                       \
  V(130)                                                                       \
  V(131)                                                                       \
  V(132)                                                                       \
  V(133)                                                                       \
  V(134)                                                                       \
  V(135)                                                                       \
  V(136)                                                                       \
  V(137)                                                                       \
  V(138)                                                                       \
  V(139)                                                                       \
  V(140)                                                                       \
  V(141)                                                                       \
  V(142)                                                                       \
  V(143)                                                                       \
  V(144)                                                                       \
  V(145)                                                                       \
  V(146)                                                                       \
  V(147)                                                                       \
  V(148)                                                                       \
  V(149)                                                                       \
  V(150)                                                                       \
  V(151)                                                                       \
  V(152)                                                                       \
  V(153)                                                                       \
  V(154)                                                                       \
  V(155)                                                                       \
  V(156)                                                                       \
  V(157)                                                                       \
  V(158)                                                                       \
  V(159)                                                                       \
  V(160)                                                                       \
  V(161)                                                                       \
  V(162)                                                                       \
  V(163)                                                                       \
  V(164)                                                                       \
  V(165)                                                                       \
  V(166)                                                                       \
  V(167)                                                                       \
  V(168)                                                                       \
  V(169)                                                                       \
  V(170)                                                                       \
  V(171)                                                                       \
  V(172)                                                                       \
  V(173)                                                                       \
  V(174)                                                                       \
  V(175)                                                                       \
  V(176)                                                                       \
  V(177)                                                                       \
  V(178)                                                                       \
  V(179)                                                                       \
  V(180)                                                                       \
  V(181)                                                                       \
  V(182)                                                                       \
  V(183)                                                                       \
  V(184)                                                                       \
  V(185)                                                                       \
  V(186)                                                                       \
  V(187)                                                                       \
  V(188)                                                                       \
  V(189)                                                                       \
  V(190)                                                                       \
  V(191)                                                                       \
  V(192)                                                                       \
  V(193)                                                                       \
  V(194)                                                                       \
  V(195)                                                                       \
  V(196)                                                                       \
  V(197)                                                                       \
  V(198)                                                                       \
  V(199)                                                                       \
  V(200)                                                                       \
  V(201)                                                                       \
  V(202)                                                                       \
  V(203)                                                                       \
  V(204)                                                                       \
  V(205)                                                                       \
  V(206)                                                                       \
  V(207)                                                                       \
  V(208)                                                                       \
  V(209)                                                                       \
  V(210)                                                                       \
  V(211)                                                                       \
  V(212)                                                                       \
  V(213)                                                                       \
  V(214)                                                                       \
  V(215)                                                                       \
  V(216)                                                                       \
  V(217)                                                                       \
  V(218)                                                                       \
  V(219)                                                                       \
  V(220)                                                                       \
  V(221)                                                                       \
  V(222)                                                                       \
  V(223)                                                                       \
  V(224)                                                                       \
  V(225)                                                                       \
  V(226)                                                                       \
  V(227)                                                                       \
  V(228)                                                                       \
  V(229)                                                                       \
  V(230)                                                                       \
  V(231)                                                                       \
  V(232)                                                                       \
  V(233)                                                                       \
  V(234)                                                                       \
  V(235)                                                                       \
  V(236)                                                                       \
  V(237)                                                                       \
  V(238)                                                                       \
  V(239)                                                                       \
  V(240)                                                                       \
  V(241)                                                                       \
  V(242)                                                                       \
  V(243)                                                                       \
  V(244)                                                                       \
  V(245)                                                                       \
  V(246)                                                                       \
  V(247)                                                                       \
  V(248)                                                                       \
  V(249)                                                                       \
  V(250)                                                                       \
  V(251)                                                                       \
  V(252)                                                                       \
  V(253)                                                                       \
  V(254)                                                                       \
  V(255)                                                                       \
  V(256)                                                                       \
  V(257)                                                                       \
  V(258)                                                                       \
  V(259)                                                                       \
  V(260)                                                                       \
  V(261)                                                                       \
  V(262)                                                                       \
  V(263)                                                                       \
  V(264)                                                                       \
  V(265)                                                                       \
  V(266)                                                                       \
  V(267)                                                                       \
  V(268)                                                                       \
  V(269)                                                                       \
  V(270)                                                                       \
  V(271)                                                                       \
  V(272)                                                                       \
  V(273)                                                                       \
  V(274)                                                                       \
  V(275)                                                                       \
  V(276)                                                                       \
  V(277)                                                                       \
  V(278)                                                                       \
  V(279)                                                                       \
  V(280)                                                                       \
  V(281)                                                                       \
  V(282)                                                                       \
  V(283)                                                                       \
  V(284)                                                                       \
  V(285)                                                                       \
  V(286)                                                                       \
  V(287)                                                                       \
  V(288)                                                                       \
  V(289)                                                                       \
  V(290)                                                                       \
  V(291)                                                                       \
  V(292)                                                                       \
  V(293)                                                                       \
  V(294)                                                                       \
  V(295)                                                                       \
  V(296)                                                                       \
  V(297)                                                                       \
  V(298)                                                                       \
  V(299)                                                                       \
  V(300)                                                                       \
  V(301)                                                                       \
  V(302)                                                                       \
  V(303)                                                                       \
  V(304)                                                                       \
  V(305)                                                                       \
  V(306)                                                                       \
  V(307)                                                                       \
  V(308)                                                                       \
  V(309)                                                                       \
  V(310)                                                                       \
  V(311)                                                                       \
  V(312)                                                                       \
  V(313)                                                                       \
  V(314)                                                                       \
  V(315)                                                                       \
  V(316)                                                                       \
  V(317)                                                                       \
  V(318)                                                                       \
  V(319)                                                                       \
  V(320)                                                                       \
  V(321)                                                                       \
  V(322)                                                                       \
  V(323)                                                                       \
  V(324)                                                                       \
  V(325)                                                                       \
  V(326)                                                                       \
  V(327)                                                                       \
  V(328)                                                                       \
  V(329)                                                                       \
  V(330)                                                                       \
  V(331)                                                                       \
  V(332)                                                                       \
  V(333)                                                                       \
  V(334)                                                                       \
  V(335)                                                                       \
  V(336)                                                                       \
  V(337)                                                                       \
  V(338)                                                                       \
  V(339)                                                                       \
  V(340)                                                                       \
  V(341)                                                                       \
  V(342)                                                                       \
  V(343)                                                                       \
  V(344)                                                                       \
  V(345)                                                                       \
  V(346)                                                                       \
  V(347)                                                                       \
  V(348)                                                                       \
  V(349)                                                                       \
  V(350)                                                                       \
  V(351)                                                                       \
  V(352)                                                                       \
  V(353)                                                                       \
  V(354)                                                                       \
  V(355)                                                                       \
  V(356)                                                                       \
  V(357)                                                                       \
  V(358)                                                                       \
  V(359)                                                                       \
  V(360)                                                                       \
  V(361)                                                                       \
  V(362)                                                                       \
  V(363)                                                                       \
  V(364)                                                                       \
  V(365)                                                                       \
  V(366)                                                                       \
  V(367)                                                                       \
  V(368)                                                                       \
  V(369)                                                                       \
  V(370)                                                                       \
  V(371)                                                                       \
  V(372)                                                                       \
  V(373)                                                                       \
  V(374)                                                                       \
  V(375)                                                                       \
  V(376)                                                                       \
  V(377)                                                                       \
  V(378)                                                                       \
  V(379)                                                                       \
  V(380)                                                                       \
  V(381)                                                                       \
  V(382)                                                                       \
  V(383)                                                                       \
  V(384)                                                                       \
  V(385)                                                                       \
  V(386)                                                                       \
  V(387)                                                                       \
  V(388)                                                                       \
  V(389)                                                                       \
  V(390)                                                                       \
  V(391)                                                                       \
  V(392)                                                                       \
  V(393)                                                                       \
  V(394)                                                                       \
  V(395)                                                                       \
  V(396)                                                                       \
  V(397)                                                                       \
  V(398)                                                                       \
  V(399)                                                                       \
  V(400)                                                                       \
  V(401)                                                                       \
  V(402)                                                                       \
  V(403)                                                                       \
  V(404)                                                                       \
  V(405)                                                                       \
  V(406)                                                                       \
  V(407)                                                                       \
  V(408)                                                                       \
  V(409)                                                                       \
  V(410)                                                                       \
  V(411)                                                                       \
  V(412)                                                                       \
  V(413)                                                                       \
  V(414)                                                                       \
  V(415)                                                                       \
  V(416)                                                                       \
  V(417)                                                                       \
  V(418)                                                                       \
  V(419)                                                                       \
  V(420)                                                                       \
  V(421)                                                                       \
  V(422)                                                                       \
  V(423)                                                                       \
  V(424)                                                                       \
  V(425)                                                                       \
  V(426)                                                                       \
  V(427)                                                                       \
  V(428)                                                                       \
  V(429)                                                                       \
  V(430)                                                                       \
  V(431)                                                                       \
  V(432)                                                                       \
  V(433)                                                                       \
  V(434)                                                                       \
  V(435)                                                                       \
  V(436)                                                                       \
  V(437)                                                                       \
  V(438)                                                                       \
  V(439)                                                                       \
  V(440)                                                                       \
  V(441)                                                                       \
  V(442)                                                                       \
  V(443)                                                                       \
  V(444)                                                                       \
  V(445)                                                                       \
  V(446)                                                                       \
  V(447)                                                                       \
  V(448)                                                                       \
  V(449)                                                                       \
  V(450)                                                                       \
  V(451)                                                                       \
  V(452)                                                                       \
  V(453)                                                                       \
  V(454)                                                                       \
  V(455)                                                                       \
  V(456)                                                                       \
  V(457)                                                                       \
  V(458)                                                                       \
  V(459)                                                                       \
  V(460)                                                                       \
  V(461)                                                                       \
  V(462)                                                                       \
  V(463)                                                                       \
  V(464)                                                                       \
  V(465)                                                                       \
  V(466)                                                                       \
  V(467)                                                                       \
  V(468)                                                                       \
  V(469)                                                                       \
  V(470)                                                                       \
  V(471)                                                                       \
  V(472)                                                                       \
  V(473)                                                                       \
  V(474)                                                                       \
  V(475)                                                                       \
  V(476)                                                                       \
  V(477)                                                                       \
  V(478)                                                                       \
  V(479)                                                                       \
  V(480)                                                                       \
  V(481)                                                                       \
  V(482)                                                                       \
  V(483)                                                                       \
  V(484)                                                                       \
  V(485)                                                                       \
  V(486)                                                                       \
  V(487)                                                                       \
  V(488)                                                                       \
  V(489)                                                                       \
  V(490)                                                                       \
  V(491)                                                                       \
  V(492)                                                                       \
  V(493)                                                                       \
  V(494)                                                                       \
  V(495)                                                                       \
  V(496)                                                                       \
  V(497)                                                                       \
  V(498)                                                                       \
  V(499)                                                                       \
  V(500)                                                                       \
  V(501)                                                                       \
  V(502)                                                                       \
  V(503)                                                                       \
  V(504)                                                                       \
  V(505)                                                                       \
  V(506)                                                                       \
  V(507)                                                                       \
  V(508)                                                                       \
  V(509)                                                                       \
  V(510)                                                                       \
  V(511)

REPEAT_512(FINALIZER_CROSS_GEN_TEST_CASE)

#undef FINALIZER_CROSS_GEN_TEST_CASE

// Force the marker to add a FinalizerEntry to the store buffer during marking.
//
// This test requires two entries, one in new space, one in old space.
// The scavenger should run first, adding the entry to collected_entries.
// The marker runs right after, swapping the collected_entries with the entry
// in old space, _and_ setting the next field to the entry in new space.
// This forces the entry to be added to the store-buffer _during_ marking.
//
// Then, the compacter needs to be used. Which will move the entry in old
// space.
//
// If the thread's store buffer block is not released after that, the compactor
// will not update it, causing an outdated address to be released to the store
// buffer later.
//
// This causes two types of errors to trigger with --verify-store-buffer:
// 1. We see the address in the store buffer but the object is no entry there.
//    Also can cause segfaults on reading garbage or unallocated memory.
// 2. We see the entry has a marked bit, but can't find it in the store buffer.
ISOLATE_UNIT_TEST_CASE(Finalizer_Regress_48843) {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
  SetFlagScope<bool> sfs2(&FLAG_verify_store_buffer, true);
#endif
  SetFlagScope<bool> sfs3(&FLAG_use_compactor, true);

  const auto& finalizer = Finalizer::Handle(Finalizer::New(Heap::kOld));
  finalizer.set_isolate(thread->isolate());

  const auto& detach1 =
      String::Handle(OneByteString::New("detach1", Heap::kNew));
  const auto& token1 = String::Handle(OneByteString::New("token1", Heap::kNew));
  const auto& detach2 =
      String::Handle(OneByteString::New("detach2", Heap::kOld));
  const auto& token2 = String::Handle(OneByteString::New("token2", Heap::kOld));

  {
    HANDLESCOPE(thread);
    const auto& entry1 =
        FinalizerEntry::Handle(FinalizerEntry::New(finalizer, Heap::kNew));
    entry1.set_detach(detach1);
    entry1.set_token(token1);

    const auto& entry2 =
        FinalizerEntry::Handle(FinalizerEntry::New(finalizer, Heap::kOld));
    entry2.set_detach(detach2);
    entry2.set_token(token2);

    {
      HANDLESCOPE(thread);
      const auto& value1 =
          String::Handle(OneByteString::New("value1", Heap::kNew));
      entry1.set_value(value1);
      const auto& value2 =
          String::Handle(OneByteString::New("value2", Heap::kOld));
      entry2.set_value(value2);
      // Lose both values.
    }

    // First collect new space.
    GCTestHelper::CollectNewSpace();
    // Then old space, this will make the old space entry point to the new
    // space entry.
    // Also, this must be a mark compact, not a mark sweep, to move the entry.
    GCTestHelper::CollectOldSpace();
  }

  // Imagine callbacks running.
  // Entries themselves become unreachable.
  finalizer.set_entries_collected(
      FinalizerEntry::Handle(FinalizerEntry::null()));

  // There should be a single entry in the store buffer.
  // And it should crash when seeing the address in the buffer.
  GCTestHelper::CollectNewSpace();

  // We should no longer be processing the entries.
  GCTestHelper::CollectOldSpace();
  GCTestHelper::CollectNewSpace();
}

void NativeFinalizer_TwoEntriesCrossGen_Finalizer(void* peer) {
  intptr_t* token = reinterpret_cast<intptr_t*>(peer);
  (*token)++;
}

static void NativeFinalizer_TwoEntriesCrossGen(
    Thread* thread,
    Heap::Space* spaces,
    bool collect_new_space,
    bool evacuate_new_space_and_collect_old_space,
    bool clear_value_1,
    bool clear_value_2,
    bool clear_detach_1,
    bool clear_detach_2) {
#ifdef DEBUG
  SetFlagScope<bool> sfs(&FLAG_trace_finalizers, true);
#endif

  intptr_t token1_memory = 0;
  intptr_t token2_memory = 0;

  MessageHandler* handler = thread->isolate()->message_handler();
  // We're reusing the isolate in a loop, so there are messages from previous
  // runs of this test.
  const intptr_t queue_length_start = handler->GetMessageCounts().num_messages;

  const auto& callback = Pointer::Handle(Pointer::New(
      reinterpret_cast<uword>(&NativeFinalizer_TwoEntriesCrossGen_Finalizer),
      spaces[3]));

  const auto& finalizer =
      NativeFinalizer::Handle(NativeFinalizer::New(spaces[0]));
  finalizer.set_callback(callback);
  finalizer.set_isolate(thread->isolate());

  const auto& isolate_finalizers =
      GrowableObjectArray::Handle(GrowableObjectArray::New());
  const auto& weak1 = WeakReference::Handle(WeakReference::New());
  weak1.set_target(finalizer);
  isolate_finalizers.Add(weak1);
  thread->isolate()->set_finalizers(isolate_finalizers);

  const auto& all_entries = Set::Handle(Set::NewDefault());
  finalizer.set_all_entries(all_entries);
  const auto& all_entries_data = Array::Handle(all_entries.data());
  THR_Print("entry1 space: %s\n", spaces[1] == Heap::kNew ? "new" : "old");
  const auto& entry1 =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, spaces[1]));
  all_entries_data.SetAt(0, entry1);
  THR_Print("entry2 space: %s\n", spaces[2] == Heap::kNew ? "new" : "old");
  const auto& entry2 =
      FinalizerEntry::Handle(FinalizerEntry::New(finalizer, spaces[2]));
  all_entries_data.SetAt(1, entry2);
  all_entries.set_used_data(2);  // Don't bother setting the index.

  const intptr_t external_size1 = 1024;
  const intptr_t external_size2 = 2048;
  entry1.set_external_size(external_size1);
  entry2.set_external_size(external_size2);
  IsolateGroup::Current()->heap()->AllocatedExternal(external_size1, spaces[5]);
  IsolateGroup::Current()->heap()->AllocatedExternal(external_size2, spaces[7]);

  auto& value1 = String::Handle();
  auto& detach1 = String::Handle();
  const auto& token1 = Pointer::Handle(
      Pointer::New(reinterpret_cast<uword>(&token1_memory), spaces[3]));
  entry1.set_token(token1);

  auto& value2 = String::Handle();
  auto& detach2 = String::Handle();
  const auto& token2 = Pointer::Handle(
      Pointer::New(reinterpret_cast<uword>(&token2_memory), spaces[4]));
  entry2.set_token(token2);
  entry2.set_detach(detach2);

  {
    HANDLESCOPE(thread);
    auto& object = String::Handle();

    THR_Print("value1 space: %s\n", spaces[5] == Heap::kNew ? "new" : "old");
    object ^= OneByteString::New("value1", spaces[5]);
    entry1.set_value(object);
    if (!clear_value_1) {
      value1 = object.ptr();
    }

    object ^= OneByteString::New("detach", spaces[6]);
    entry1.set_detach(object);
    if (!clear_detach_1) {
      detach1 = object.ptr();
    }

    THR_Print("value2 space: %s\n", spaces[7] == Heap::kNew ? "new" : "old");
    object ^= OneByteString::New("value2", spaces[7]);
    entry2.set_value(object);
    if (!clear_value_2) {
      value2 = object.ptr();
    }

    object ^= OneByteString::New("detach", spaces[8]);
    entry2.set_detach(object);
    if (!clear_detach_2) {
      detach2 = object.ptr();
    }
  }

  THR_Print("CollectOldSpace\n");
  GCTestHelper::CollectOldSpace();
  if (collect_new_space) {
    THR_Print("CollectNewSpace\n");
    GCTestHelper::CollectNewSpace();
  }
  if (evacuate_new_space_and_collect_old_space) {
    THR_Print("CollectAllGarbage\n");
    GCTestHelper::CollectAllGarbage();
  }

  EXPECT((entry1.value() == Object::null()) ^ !clear_value_1);
  EXPECT((entry2.value() == Object::null()) ^ !clear_value_2);
  EXPECT((entry1.detach() == Object::null()) ^ !clear_detach_1);
  EXPECT((entry2.detach() == Object::null()) ^ !clear_detach_2);
  EXPECT_NE(Object::null(), entry1.token());
  EXPECT_NE(Object::null(), entry2.token());

  const intptr_t expect_num_cleared =
      (clear_value_1 ? 1 : 0) + (clear_value_2 ? 1 : 0);
  EXPECT_EQ(expect_num_cleared,
            NumEntries(FinalizerEntry::Handle(finalizer.entries_collected())));

  EXPECT_EQ(clear_value_1 ? 1 : 0, token1_memory);
  EXPECT_EQ(clear_value_2 ? 1 : 0, token2_memory);

  const intptr_t expect_num_messages = expect_num_cleared == 0 ? 0 : 1;
  EXPECT_EQ(expect_num_messages + queue_length_start,
            handler->GetMessageCounts().num_messages);

  // Simulate detachments.
  entry1.set_token(entry1);
  entry2.set_token(entry2);
  all_entries_data.SetAt(0, Object::Handle(Object::null()));
  all_entries_data.SetAt(1, Object::Handle(Object::null()));
  all_entries.set_used_data(0);
}

static void NativeFinalizer_TwoEntriesCrossGen(Thread* thread,
                                               intptr_t test_i) {
  ASSERT(test_i < (1 << kFinalizerTwoEntriesNumObjects));
  Heap::Space spaces[kFinalizerTwoEntriesNumObjects];
  for (intptr_t i = 0; i < kFinalizerTwoEntriesNumObjects; i++) {
    spaces[i] = ((test_i >> i) & 0x1) == 0x1 ? Heap::kOld : Heap::kNew;
  }
  // Either collect or evacuate new space.
  for (const bool collect_new_space : {true, false}) {
    // Always run old space collection after new space.
    const bool evacuate_new_space_and_collect_old_space = true;
    const bool clear_value_1 = true;
    const bool clear_value_2 = true;
    const bool clear_detach_1 = false;
    const bool clear_detach_2 = false;
    THR_Print(
        "collect_new_space: %s evacuate_new_space_and_collect_old_space: %s\n",
        collect_new_space ? "true" : "false",
        evacuate_new_space_and_collect_old_space ? "true" : "false");
    NativeFinalizer_TwoEntriesCrossGen(thread, spaces, collect_new_space,
                                       evacuate_new_space_and_collect_old_space,
                                       clear_value_1, clear_value_2,
                                       clear_detach_1, clear_detach_2);
  }
}

#define FINALIZER_NATIVE_CROSS_GEN_TEST_CASE(n)                                \
  ISOLATE_UNIT_TEST_CASE(NativeFinalizer_CrossGen_##n) {                       \
    NativeFinalizer_TwoEntriesCrossGen(thread, n);                             \
  }

REPEAT_512(FINALIZER_NATIVE_CROSS_GEN_TEST_CASE)

#undef FINALIZER_NATIVE_CROSS_GEN_TEST_CASE

#undef REPEAT_512

TEST_CASE(IsIsolateUnsendable) {
  Zone* const zone = Thread::Current()->zone();

  const char* kScript = R"(
import 'dart:ffi';

class AImpl implements A {}
class ASub extends A {}
// Wonky class order and non-alphabetic naming on purpose.
class C extends Z {}
class E extends D {}
class A implements Finalizable {}
class Z implements A {}
class D implements C {}
class X extends E {}
)";
  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(h_lib);

  TransitionNativeToVM transition(thread);
  const Library& lib = Library::CheckedHandle(zone, Api::UnwrapHandle(h_lib));
  EXPECT(!lib.IsNull());

  const auto& class_x = Class::Handle(zone, GetClass(lib, "X"));
  class_x.EnsureIsFinalized(thread);
  EXPECT(class_x.is_isolate_unsendable());

  const auto& class_a_impl = Class::Handle(zone, GetClass(lib, "AImpl"));
  class_a_impl.EnsureIsFinalized(thread);
  EXPECT(class_a_impl.is_isolate_unsendable());

  const auto& class_a_sub = Class::Handle(zone, GetClass(lib, "ASub"));
  class_a_sub.EnsureIsFinalized(thread);
  EXPECT(class_a_sub.is_isolate_unsendable());
}

TEST_CASE(ImplementorCid) {
  const char* kScriptChars = R"(
abstract class AInterface {}

abstract class BInterface {}
class BImplementation implements BInterface {}

abstract class CInterface {}
class CImplementation1 implements CInterface {}
class CImplementation2 implements CInterface {}

abstract class DInterface {}
abstract class DSubinterface implements DInterface {}

abstract class EInterface {}
abstract class ESubinterface implements EInterface {}
class EImplementation implements ESubinterface {}

abstract class FInterface {}
abstract class FSubinterface implements FInterface {}
class FImplementation1 implements FSubinterface {}
class FImplementation2 implements FSubinterface {}

main() {
  new BImplementation();
  new CImplementation1();
  new CImplementation2();
  new EImplementation();
  new FImplementation1();
  new FImplementation2();
}
)";
  Dart_Handle h_lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle result = Dart_Invoke(h_lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);

  TransitionNativeToVM transition(thread);
  const Library& lib =
      Library::CheckedHandle(thread->zone(), Api::UnwrapHandle(h_lib));
  EXPECT(!lib.IsNull());

  const Class& AInterface = Class::Handle(GetClass(lib, "AInterface"));
  EXPECT_EQ(AInterface.implementor_cid(), kIllegalCid);

  const Class& BInterface = Class::Handle(GetClass(lib, "BInterface"));
  const Class& BImplementation =
      Class::Handle(GetClass(lib, "BImplementation"));
  EXPECT_EQ(BInterface.implementor_cid(), BImplementation.id());
  EXPECT_EQ(BImplementation.implementor_cid(), BImplementation.id());

  const Class& CInterface = Class::Handle(GetClass(lib, "CInterface"));
  const Class& CImplementation1 =
      Class::Handle(GetClass(lib, "CImplementation1"));
  const Class& CImplementation2 =
      Class::Handle(GetClass(lib, "CImplementation2"));
  EXPECT_EQ(CInterface.implementor_cid(), kDynamicCid);
  EXPECT_EQ(CImplementation1.implementor_cid(), CImplementation1.id());
  EXPECT_EQ(CImplementation2.implementor_cid(), CImplementation2.id());

  const Class& DInterface = Class::Handle(GetClass(lib, "DInterface"));
  const Class& DSubinterface = Class::Handle(GetClass(lib, "DSubinterface"));
  EXPECT_EQ(DInterface.implementor_cid(), kIllegalCid);
  EXPECT_EQ(DSubinterface.implementor_cid(), kIllegalCid);

  const Class& EInterface = Class::Handle(GetClass(lib, "EInterface"));
  const Class& ESubinterface = Class::Handle(GetClass(lib, "ESubinterface"));
  const Class& EImplementation =
      Class::Handle(GetClass(lib, "EImplementation"));
  EXPECT_EQ(EInterface.implementor_cid(), EImplementation.id());
  EXPECT_EQ(ESubinterface.implementor_cid(), EImplementation.id());
  EXPECT_EQ(EImplementation.implementor_cid(), EImplementation.id());

  const Class& FInterface = Class::Handle(GetClass(lib, "FInterface"));
  const Class& FSubinterface = Class::Handle(GetClass(lib, "FSubinterface"));
  const Class& FImplementation1 =
      Class::Handle(GetClass(lib, "FImplementation1"));
  const Class& FImplementation2 =
      Class::Handle(GetClass(lib, "FImplementation2"));
  EXPECT_EQ(FInterface.implementor_cid(), kDynamicCid);
  EXPECT_EQ(FSubinterface.implementor_cid(), kDynamicCid);
  EXPECT_EQ(FImplementation1.implementor_cid(), FImplementation1.id());
  EXPECT_EQ(FImplementation2.implementor_cid(), FImplementation2.id());
}

ISOLATE_UNIT_TEST_CASE(MirrorReference) {
  const MirrorReference& reference =
      MirrorReference::Handle(MirrorReference::New(Object::Handle()));
  Object& initial_referent = Object::Handle(reference.referent());
  EXPECT(initial_referent.IsNull());

  Library& library = Library::Handle(Library::CoreLibrary());
  EXPECT(!library.IsNull());
  EXPECT(library.IsLibrary());
  reference.set_referent(library);
  const Object& returned_referent = Object::Handle(reference.referent());
  EXPECT(returned_referent.IsLibrary());
  EXPECT_EQ(returned_referent.ptr(), library.ptr());

  const MirrorReference& other_reference =
      MirrorReference::Handle(MirrorReference::New(Object::Handle()));
  EXPECT_NE(reference.ptr(), other_reference.ptr());
  other_reference.set_referent(library);
  EXPECT_NE(reference.ptr(), other_reference.ptr());
  EXPECT_EQ(reference.referent(), other_reference.referent());

  Object& obj = Object::Handle(reference.ptr());
  EXPECT(obj.IsMirrorReference());
}

static FunctionPtr GetFunction(const Class& cls, const char* name) {
  Thread* thread = Thread::Current();
  const auto& error = cls.EnsureIsFinalized(thread);
  EXPECT(error == Error::null());
  const Function& result = Function::Handle(Resolver::ResolveDynamicFunction(
      Z, cls, String::Handle(String::New(name))));
  EXPECT(!result.IsNull());
  return result.ptr();
}

static FunctionPtr GetStaticFunction(const Class& cls, const char* name) {
  const auto& error = cls.EnsureIsFinalized(Thread::Current());
  EXPECT(error == Error::null());
  const Function& result = Function::Handle(
      cls.LookupStaticFunction(String::Handle(String::New(name))));
  EXPECT(!result.IsNull());
  return result.ptr();
}

static FieldPtr GetField(const Class& cls, const char* name) {
  const Field& field =
      Field::Handle(cls.LookupField(String::Handle(String::New(name))));
  EXPECT(!field.IsNull());
  return field.ptr();
}

ISOLATE_UNIT_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));

  Function& parent = Function::Handle();
  const String& parent_name = String::Handle(Symbols::New(thread, "foo_papa"));
  const FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  parent = Function::New(signature, parent_name,
                         UntaggedFunction::kRegularFunction, false, false,
                         false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(0, parent);
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    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.
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    ClosureFunctionsCache::AddClosureFunctionLocked(function,
                                                    /*local_function_id=*/42);
  }

  // The closure should return a valid index.
  intptr_t good_closure_index =
      ClosureFunctionsCache::FindClosureIndex(function);
  EXPECT_GE(good_closure_index, 0);
  // The parent function should return an invalid index.
  intptr_t bad_closure_index = ClosureFunctionsCache::FindClosureIndex(parent);
  EXPECT_EQ(bad_closure_index, -1);

  // Retrieve closure function via index.
  Function& func_from_index = Function::Handle();
  func_from_index ^=
      ClosureFunctionsCache::ClosureFunctionFromIndex(good_closure_index);
  // Same closure function.
  EXPECT_EQ(func_from_index.ptr(), function.ptr());
}

ISOLATE_UNIT_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"));
  const FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  parent = Function::New(signature, parent_name,
                         UntaggedFunction::kRegularFunction, false, false,
                         false, false, false, cls, TokenPosition::kMinSource);
  functions.SetAt(0, parent);
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    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::NewBoxed(0, 1));
  Function& invocation_dispatcher = Function::Handle();
  invocation_dispatcher ^= cls.GetInvocationDispatcher(
      invocation_dispatcher_name, args_desc,
      UntaggedFunction::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.ptr(),
            invocation_dispatcher_from_index.ptr());
  // 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::PrintErr("Error in metadata evaluation for %s: '%s'\n", name,
                 Error::Cast(data).ToErrorCString());
  }
  EXPECT(data.IsArray());
  const Array& metadata = Array::Cast(data);
  OS::PrintErr("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::PrintErr("  %d: %s\n", i, elem.ToCString());
  }
}

TEST_CASE(Metadata) {
  // clang-format off
  const char* kScriptChars =
        "@metafoo                       \n"
        "class Meta {                   \n"
        "  final m;                     \n"
        "  const Meta(this.m);          \n"
        "}                              \n"
        "                               \n"
        "const metafoo = 'metafoo';     \n"
        "const metabar = 'meta' 'bar';  \n"
        "                               \n"
        "@metafoo                       \n"
        "@Meta(0) String? gVar;         \n"
        "                               \n"
        "@metafoo                       \n"
        "get tlGetter => gVar;          \n"
        "                               \n"
        "@metabar                       \n"
        "class A {                      \n"
        "  @metafoo                     \n"
        "  @metabar                     \n"
        "  @Meta('baz')                 \n"
        "  var aField;                  \n"
        "                               \n"
        "  @metabar @Meta('baa')        \n"
        "  int aFunc(a,b) => a + b;     \n"
        "}                              \n"
        "                               \n"
        "@Meta('main')                  \n"
        "A main() {                     \n"
        "  return A();                  \n"
        "}                              \n";
  // clang-format on

  Dart_Handle h_lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle result = Dart_Invoke(h_lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);
  TransitionNativeToVM transition(thread);
  Library& lib = Library::Handle();
  lib ^= Api::UnwrapHandle(h_lib);
  EXPECT(!lib.IsNull());
  const Class& class_a = Class::Handle(GetClass(lib, "A"));
  Object& res = Object::Handle(lib.GetMetadata(class_a));
  PrintMetadata("A", res);

  const Class& class_meta = Class::Handle(GetClass(lib, "Meta"));
  res = lib.GetMetadata(class_meta);
  PrintMetadata("Meta", res);

  Field& field = Field::Handle(GetField(class_a, "aField"));
  res = lib.GetMetadata(field);
  PrintMetadata("A.aField", res);

  Function& func = Function::Handle(GetFunction(class_a, "aFunc"));
  res = lib.GetMetadata(func);
  PrintMetadata("A.aFunc", res);

  func = lib.LookupFunctionAllowPrivate(
      String::Handle(Symbols::New(thread, "main")));
  EXPECT(!func.IsNull());
  res = lib.GetMetadata(func);
  PrintMetadata("main", res);

  func = lib.LookupFunctionAllowPrivate(
      String::Handle(Symbols::New(thread, "get:tlGetter")));
  EXPECT(!func.IsNull());
  res = lib.GetMetadata(func);
  PrintMetadata("tlGetter", res);

  field =
      lib.LookupFieldAllowPrivate(String::Handle(Symbols::New(thread, "gVar")));
  EXPECT(!field.IsNull());
  res = lib.GetMetadata(field);
  PrintMetadata("gVar", res);
}

TEST_CASE(FunctionSourceFingerprint) {
  const char* kScriptChars =
      "class A {\n"
      "  static test1(int a) {\n"
      "    return a > 1 ? a + 1 : a;\n"
      "  }\n"
      "  static test2(a) {\n"
      "    return a > 1 ? a + 1 : a;\n"
      "  }\n"
      "  static test3(b) {\n"
      "    return b > 1 ? b + 1 : b;\n"
      "  }\n"
      "  static test4(b) {\n"
      "    return b > 1 ? b - 1 : b;\n"
      "  }\n"
      "  static test5(b) {\n"
      "    return b > 1 ? b - 2 : b;\n"
      "  }\n"
      "  test6(int a) {\n"
      "    return a > 1 ? a + 1 : a;\n"
      "  }\n"
      "}\n"
      "class B {\n"
      "  static /* Different declaration style. */\n"
      "  test1(int a) {\n"
      "    /* Returns a + 1 for a > 1, a otherwise. */\n"
      "    return a > 1 ?\n"
      "        a + 1 :\n"
      "        a;\n"
      "  }\n"
      "  static test5(b) {\n"
      "    return b > 1 ?\n"
      "        b - 2 : b;\n"
      "  }\n"
      "  test6(int a) {\n"
      "    return a > 1 ? a + 1 : a;\n"
      "  }\n"
      "}";
  TestCase::LoadTestScript(kScriptChars, nullptr);
  TransitionNativeToVM transition(thread);
  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 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"));

  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
  // of a given class and of a given name.
  EXPECT_EQ(a_test6.SourceFingerprint(), b_test6.SourceFingerprint());
}

#ifndef PRODUCT

TEST_CASE(FunctionWithBreakpointNotInlined) {
  const char* kScriptChars =
      "class A {\n"
      "  a() {\n"
      "  }\n"
      "  b() {\n"
      "    a();\n"  // This is line 5.
      "  }\n"
      "}\n"
      "@pragma('vm:entry-point', 'call')\n"
      "test() {\n"
      "  new A().b();\n"
      "}";
  const int kBreakpointLine = 5;
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);

  // Run function A.b one time.
  Dart_Handle result = Dart_Invoke(lib, NewString("test"), 0, nullptr);
  EXPECT_VALID(result);

  // With no breakpoint, function A.b is inlineable.
  {
    TransitionNativeToVM transition(thread);
    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"))));
    Function& func_b = Function::Handle(GetFunction(class_a, "b"));
    EXPECT(func_b.CanBeInlined());
  }

  result = Dart_SetBreakpoint(NewString(TestCase::url()), kBreakpointLine);
  EXPECT_VALID(result);

  // After setting a breakpoint in a function A.b, it is no longer inlineable.
  {
    TransitionNativeToVM transition(thread);
    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"))));
    Function& func_b = Function::Handle(GetFunction(class_a, "b"));
    EXPECT(!func_b.CanBeInlined());
  }
}

void SetBreakpoint(Dart_NativeArguments args) {
  // Refers to the DeoptimizeFramesWhenSettingBreakpoint function below.
  const int kBreakpointLine = 10;

  // This will force deoptimization of functions on stack.
  // Function on stack has to be optimized, since we want to trigger debuggers
  // on-stack deoptimization flow when we set a breakpoint.
  Dart_Handle result =
      Dart_SetBreakpoint(NewString(TestCase::url()), kBreakpointLine);
  EXPECT_VALID(result);
}

static Dart_NativeFunction SetBreakpointResolver(Dart_Handle name,
                                                 int argument_count,
                                                 bool* auto_setup_scope) {
  ASSERT(auto_setup_scope != nullptr);
  *auto_setup_scope = true;
  const char* cstr = nullptr;
  Dart_Handle result = Dart_StringToCString(name, &cstr);
  EXPECT_VALID(result);
  EXPECT_STREQ(cstr, "setBreakpoint");
  return &SetBreakpoint;
}

TEST_CASE(DeoptimizeFramesWhenSettingBreakpoint) {
  const char* kOriginalScript =
      "@pragma('vm:entry-point', 'call')\n"
      "test() {}";

  Dart_Handle lib = TestCase::LoadTestScript(kOriginalScript, nullptr);
  EXPECT_VALID(lib);
  Dart_SetNativeResolver(lib, &SetBreakpointResolver, nullptr);

  // Get unoptimized code for functions so they can be optimized.
  Dart_Handle result = Dart_Invoke(lib, NewString("test"), 0, nullptr);
  EXPECT_VALID(result);

  // Launch second isolate so that running with stopped mutators during
  // deoptimizattion requests a safepoint.
  Dart_Isolate parent = Dart_CurrentIsolate();
  Dart_ExitIsolate();
  char* error = nullptr;
  Dart_Isolate child =
      Dart_CreateIsolateInGroup(parent, "child",
                                /*shutdown_callback=*/nullptr,
                                /*cleanup_callback=*/nullptr,
                                /*child_isolate_data=*/nullptr, &error);
  EXPECT_NE(nullptr, child);
  EXPECT_EQ(nullptr, error);
  Dart_ExitIsolate();
  Dart_EnterIsolate(parent);

  const char* kReloadScript =
      R"(
      @pragma("vm:external-name", "setBreakpoint")
      external setBreakpoint();
      baz() {}
      @pragma('vm:entry-point', 'call')
      test() {
        if (true) {
          setBreakpoint();
        } else {
          baz();   // this line gets a breakpoint
        }
      }
      )";
  lib = TestCase::ReloadTestScript(kReloadScript);
  EXPECT_VALID(lib);

  {
    TransitionNativeToVM transition(thread);
    const String& name = String::Handle(String::New(TestCase::url()));
    const Library& vmlib =
        Library::Handle(Library::LookupLibrary(thread, name));
    EXPECT(!vmlib.IsNull());
    Function& func_test = Function::Handle(GetFunction(vmlib, "test"));
    Compiler::EnsureUnoptimizedCode(thread, func_test);
    Compiler::CompileOptimizedFunction(thread, func_test);
    func_test.set_unoptimized_code(Code::Handle(Code::null()));
  }

  result = Dart_Invoke(lib, NewString("test"), 0, nullptr);
  EXPECT_VALID(result);

  // Make sure child isolate finishes.
  Dart_ExitIsolate();
  Dart_EnterIsolate(child);
  {
    bool result =
        Dart_RunLoopAsync(/*errors_are_fatal=*/true,
                          /*on_error_port=*/0, /*on_exit_port=*/0, &error);
    EXPECT_EQ(true, result);
  }
  EXPECT_EQ(nullptr, error);
  Dart_EnterIsolate(parent);
}

class ToggleBreakpointTask : public ThreadPool::Task {
 public:
  ToggleBreakpointTask(IsolateGroup* isolate_group,
                       Dart_Isolate isolate,
                       std::atomic<bool>* done)
      : isolate_group_(isolate_group), isolate_(isolate), done_(done) {}
  virtual void Run() {
    Dart_EnterIsolate(isolate_);
    Dart_EnterScope();
    const int kBreakpointLine = 5;  // in the dart script below
    Thread* t = Thread::Current();
    for (intptr_t i = 0; i < 1000; i++) {
      Dart_Handle result =
          Dart_SetBreakpoint(NewString(TestCase::url()), kBreakpointLine);
      EXPECT_VALID(result);
      int64_t breakpoint_id;
      {
        TransitionNativeToVM transition(t);
        Integer& breakpoint_id_handle = Integer::Handle();
        breakpoint_id_handle ^= Api::UnwrapHandle(result);
        breakpoint_id = breakpoint_id_handle.Value();
      }
      result = Dart_RemoveBreakpoint(Dart_NewInteger(breakpoint_id));
      EXPECT_VALID(result);
    }
    Dart_ExitScope();
    Dart_ExitIsolate();
    *done_ = true;
  }

 private:
  IsolateGroup* isolate_group_;
  Dart_Isolate isolate_;
  std::atomic<bool>* done_;
};

TEST_CASE(DartAPI_BreakpointLockRace) {
  const char* kScriptChars =
      "class A {\n"
      "  a() {\n"
      "  }\n"
      "  b() {\n"
      "    a();\n"  // This is line 5.
      "  }\n"
      "}\n"
      "@pragma('vm:entry-point', 'call')\n"
      "test() {\n"
      "  new A().b();\n"
      "}";
  // Create a test library and Load up a test script in it.
  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, nullptr);
  EXPECT_VALID(lib);

  // Run function A.b one time.
  Dart_Handle result = Dart_Invoke(lib, NewString("test"), 0, nullptr);
  EXPECT_VALID(result);

  // Launch second isolate so that running with stopped mutators during
  // deoptimizattion requests a safepoint.
  Dart_Isolate parent = Dart_CurrentIsolate();
  Dart_ExitIsolate();
  char* error = nullptr;
  Dart_Isolate child =
      Dart_CreateIsolateInGroup(parent, "child",
                                /*shutdown_callback=*/nullptr,
                                /*cleanup_callback=*/nullptr,
                                /*child_isolate_data=*/nullptr, &error);
  EXPECT_NE(nullptr, child);
  EXPECT_EQ(nullptr, error);
  Dart_ExitIsolate();
  Dart_EnterIsolate(parent);

  // Run function A.b one time.
  std::atomic<bool> done = false;
  Dart::thread_pool()->Run<ToggleBreakpointTask>(IsolateGroup::Current(), child,
                                                 &done);

  while (!done) {
    {
      TransitionNativeToVM transition(thread);
      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"))));
      Function& func_b = Function::Handle(GetFunction(class_a, "b"));
      func_b.CanBeInlined();
    }
  }

  // Make sure child isolate finishes.
  Dart_ExitIsolate();
  Dart_EnterIsolate(child);
  {
    bool result =
        Dart_RunLoopAsync(/*errors_are_fatal=*/true,
                          /*on_error_port=*/0, /*on_exit_port=*/0, &error);
    EXPECT_EQ(true, result);
  }
  EXPECT_EQ(nullptr, error);
  Dart_EnterIsolate(parent);
}

ISOLATE_UNIT_TEST_CASE(SpecialClassesHaveEmptyArrays) {
  ObjectStore* object_store = IsolateGroup::Current()->object_store();
  Class& cls = Class::Handle();
  Object& array = Object::Handle();

  cls = object_store->null_class();
  array = cls.fields();
  EXPECT(!array.IsNull());
  EXPECT(array.IsArray());
  array = cls.current_functions();
  EXPECT(!array.IsNull());
  EXPECT(array.IsArray());

  cls = Object::void_class();
  array = cls.fields();
  EXPECT(!array.IsNull());
  EXPECT(array.IsArray());
  array = cls.current_functions();
  EXPECT(!array.IsNull());
  EXPECT(array.IsArray());

  cls = Object::dynamic_class();
  array = cls.fields();
  EXPECT(!array.IsNull());
  EXPECT(array.IsArray());
  array = cls.current_functions();
  EXPECT(!array.IsNull());
  EXPECT(array.IsArray());
}

class ObjectAccumulator : public ObjectVisitor {
 public:
  explicit ObjectAccumulator(GrowableArray<Object*>* objects)
      : objects_(objects) {}
  virtual ~ObjectAccumulator() {}
  virtual void VisitObject(ObjectPtr 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()) {
      return;
    }
    objects_->Add(&handle);
  }

 private:
  GrowableArray<Object*>* objects_;
};

ISOLATE_UNIT_TEST_CASE(ToCString) {
  // Set native resolvers in case we need to read native methods.
  {
    TransitionVMToNative transition(thread);
    bin::Builtin::SetNativeResolver(bin::Builtin::kBuiltinLibrary);
    bin::Builtin::SetNativeResolver(bin::Builtin::kCLILibrary);
    bin::SetupDartIoLibrary({});
    bin::VmService::SetNativeResolver();
  }

  GCTestHelper::CollectAllGarbage();
  GrowableArray<Object*> objects;
  {
    HeapIterationScope iteration(Thread::Current());
    ObjectAccumulator acc(&objects);
    iteration.IterateObjects(&acc);
  }
  for (intptr_t i = 0; i < objects.length(); ++i) {
    StackZone zone(thread);
    HANDLESCOPE(thread);

    // All ToCString implementations should not allocate on the Dart heap so
    // they remain useful in all parts of the VM.
    NoSafepointScope no_safepoint;
    objects[i]->ToCString();
  }
}

ISOLATE_UNIT_TEST_CASE(PrintJSON) {
  // Set native resolvers in case we need to read native methods.
  {
    TransitionVMToNative transition(thread);
    bin::Builtin::SetNativeResolver(bin::Builtin::kBuiltinLibrary);
    bin::Builtin::SetNativeResolver(bin::Builtin::kCLILibrary);
    bin::SetupDartIoLibrary({});
    bin::VmService::SetNativeResolver();
  }

  GCTestHelper::CollectAllGarbage();
  GrowableArray<Object*> objects;
  {
    HeapIterationScope iteration(Thread::Current());
    ObjectAccumulator acc(&objects);
    iteration.IterateObjects(&acc);
  }
  for (intptr_t i = 0; i < objects.length(); ++i) {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    objects[i]->PrintJSON(&js, false);
    EXPECT_SUBSTRING("\"type\":", js.ToCString());
  }
}

ISOLATE_UNIT_TEST_CASE(PrintJSONPrimitives) {
  // WARNING: This MUST be big enough for the serialized JSON string.
  const int kBufferSize = 4096;
  char buffer[kBufferSize];
  Isolate* isolate = Isolate::Current();

  // Class reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    Class& cls = Class::Handle(isolate->group()->object_store()->bool_class());
    cls.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    StripTokenPositions(buffer);

    EXPECT_STREQ(
        "{\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"bool\","
        "\"location\":{\"type\":\"SourceLocation\",\"script\":{\"type\":\"@"
        "Script\","
        "\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core\\/bool.dart\","
        "\"_kind\":\"kernel\"}},"
        "\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}}",
        buffer);
  }
  // Function reference
  {
    Thread* thread = Thread::Current();
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    Class& cls = Class::Handle(isolate->group()->object_store()->bool_class());
    const String& func_name = String::Handle(String::New("toString"));
    Function& func =
        Function::Handle(Resolver::ResolveFunction(Z, cls, func_name));
    ASSERT(!func.IsNull());
    func.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Function\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"toString\",\"owner\":{\"type\":\"@Class\","
        "\"fixedId\":true,\"id\":\"\",\"name\":\"bool\","
        "\"location\":{\"type\":\"SourceLocation\","
        "\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core\\/bool.dart\","
        "\"_kind\":\"kernel\"}},"
        "\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"_kind\":\"RegularFunction\",\"static\":false,\"const\":false,"
        "\"implicit\":false,\"abstract\":false,"
        "\"_intrinsic\":false,\"_native\":false,\"isGetter\":false,"
        "\"isSetter\":false,\"location\":{\"type\":\"SourceLocation\","
        "\"script\":{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\","
        "\"uri\":\"dart:core\\/bool.dart\",\"_kind\":\"kernel\"}}}",
        buffer);
  }
  // Library reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    Library& lib =
        Library::Handle(isolate->group()->object_store()->core_library());
    lib.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("libraries", json_str, buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}",
        buffer);
  }
  // Bool reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    Bool::True().PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Instance\",\"_vmType\":\"Bool\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"bool\",\"location\":{"
        "\"type\":\"SourceLocation\",\"script\":{\"type\":\"@Script\","
        "\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core\\/bool.dart\",\"_"
        "kind\":\"kernel\"}},\"library\":"
        "{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\",\"name\":\"dart."
        "core\",\"uri\":\"dart:core\"}},\"identityHashCode\":0,\"kind\":"
        "\"Bool\",\"fixedId\":true,\"id\":\"objects\\/bool-true\","
        "\"valueAsString\":\"true\"}",
        buffer);
  }
  // Smi reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    const Integer& smi = Integer::Handle(Integer::New(7));
    smi.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("_Smi@", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Instance\",\"_vmType\":\"Smi\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_Smi\",\"_vmName\":"
        "\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{\"type\":"
        "\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/integers.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":0,\"kind\":\"Int\",\"fixedId\":true,\"id\":"
        "\"objects\\/int-7\",\"valueAsString\":\"7\"}",
        buffer);
  }
  // Mint reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    const Integer& smi = Integer::Handle(Integer::New(Mint::kMinValue));
    smi.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_Mint@", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Instance\",\"_vmType\":\"Mint\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_Mint\",\"_vmName\":"
        "\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{\"type\":"
        "\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/integers.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":0,\"id\":\"\",\"kind\":\"Int\",\"valueAsString\":"
        "\"-9223372036854775808\"}",
        buffer);
  }
  // Double reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    const Double& dub = Double::Handle(Double::New(0.1234));
    dub.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_Double@", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Instance\",\"_vmType\":\"Double\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_Double\",\"_vmName\":"
        "\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{\"type\":"
        "\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/double.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":0,\"id\":\"\",\"kind\":\"Double\","
        "\"valueAsString\":\"0.1234\"}",
        buffer);
  }
  // String reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    const String& str = String::Handle(String::New("dw"));
    str.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_OneByteString@", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Instance\",\"_vmType\":\"String\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_OneByteString\",\"_"
        "vmName\":\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{"
        "\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/string_patch.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":0,\"id\":\"\",\"kind\":\"String\",\"length\":2,"
        "\"valueAsString\":\"dw\"}",
        buffer);
  }
  // Array reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    const Array& array = Array::Handle(Array::New(0));
    array.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_List@", buffer, buffer);
    ElideJSONSubstring("_TypeParameter@", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_SUBSTRING(
        "{\"type\":\"@Instance\",\"_vmType\":\"Array\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_List\",\"_vmName\":"
        "\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{\"type\":"
        "\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-patch\\/"
        "array.dart\",\"_kind\":\"kernel\"}},"
        "\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"},\"typeParameters\":[{"
        "\"type\":\"@"
        "Instance\",\"_vmType\":\"TypeParameter\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_TypeParameter\",\"_"
        "vmName\":\"\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core-patch\\/"
        "type_patch.dart\",\"_kind\":\"kernel\"}},"
        "\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":",
        buffer);

    EXPECT_SUBSTRING(
        "\"id\":\"\",\"kind\":\"TypeParameter\",\"name\":\"X0\","
        "\"parameterizedClass\":{\"type\":\"@Instance\",\"_vmType\":\"Class\","
        "\"class\":{\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\",\"name\":"
        "\"Null\",\"location\":{\"type\":\"SourceLocation\",\"script\":{"
        "\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:"
        "core\\/"
        "null.dart\",\"_kind\":\"kernel\"}},"
        "\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}},\"kind\":\"Null\","
        "\"fixedId\":true,\"id\":\"\",\"valueAsString\":\"null\"}}]},"
        "\"identityHashCode\":0,\"id\":\"\",\"kind\":\"List\",\"length\":0}",
        buffer);
  }
  OS::PrintErr("\n\n\n");
  // GrowableObjectArray reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    const GrowableObjectArray& array =
        GrowableObjectArray::Handle(GrowableObjectArray::New());
    array.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_GrowableList@", buffer, buffer);
    StripTokenPositions(buffer);
    ElideJSONSubstring("_TypeParameter@", buffer, buffer);
    EXPECT_SUBSTRING(
        "{\"type\":\"@Instance\",\"_vmType\":\"GrowableObjectArray\",\"class\":"
        "{\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_"
        "GrowableList\",\"_vmName\":\"\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core-patch\\/"
        "growable_array.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"},"
        "\"typeParameters\":[{\"type\":\"@Instance\",\"_vmType\":"
        "\"TypeParameter\",\"class\":{\"type\":\"@Class\",\"fixedId\":true,"
        "\"id\":\"\",\"name\":\"_TypeParameter\",\"_vmName\":\""
        "\",\"location\":{\"type\":\"SourceLocation\",\"script\":{"
        "\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/"
        "type_patch.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":",
        buffer);

    EXPECT_SUBSTRING(
        "\"id\":\"\",\"kind\":\"TypeParameter\",\"name\":\"X0\","
        "\"parameterizedClass\":{\"type\":\"@Instance\","
        "\"_vmType\":\"Class\",\"class\":{\"type\":\"@Class\",\"fixedId\":true,"
        "\"id\":\"\",\"name\":\"Null\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core\\/"
        "null.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}},\"kind\":\"Null\","
        "\"fixedId\":true,\"id\":\"\",\"valueAsString\":\"null\"}}]},"
        "\"identityHashCode\":0,\"id\":\"\",\"kind\":\"List\",\"length\":0}",
        buffer);
  }
  // Map reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    const Map& array = Map::Handle(Map::NewDefault());
    array.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_Map@", buffer, buffer);
    StripTokenPositions(buffer);
    ElideJSONSubstring("_TypeParameter@", buffer, buffer);
    EXPECT_SUBSTRING(
        "{\"type\":\"@Instance\",\"_vmType\":\"Map\",\"class\":{"
        "\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\",\"name\":\""
        "_Map\",\"_vmName\":\"\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:_compact_hash\","
        "\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart._compact_hash\","
        "\"uri\":\"dart:_compact_hash\"},"
        "\"typeParameters\":[{\"type\":\"@Instance\",\"_vmType\":"
        "\"TypeParameter\",\"class\":{\"type\":\"@Class\",\"fixedId\":true,"
        "\"id\":\"\",\"name\":\"_TypeParameter\",\"_vmName\":\""
        "\",\"location\":{\"type\":\"SourceLocation\",\"script\":{"
        "\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/"
        "type_patch.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":",
        buffer);

    EXPECT_SUBSTRING(
        "\"id\":\"\",\"kind\":\"TypeParameter\",\"name\":\"X0\","
        "\"parameterizedClass\":{\"type\":\"@Instance\","
        "\"_vmType\":\"Class\",\"class\":{\"type\":\"@Class\",\"fixedId\":true,"
        "\"id\":\"\",\"name\":\"Null\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core\\/"
        "null.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}},\"kind\":\"Null\","
        "\"fixedId\":true,\"id\":\"\",\"valueAsString\":\"null\"}},{\"type\":"
        "\"@Instance\",\"_vmType\":\"TypeParameter\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_TypeParameter\",\"_"
        "vmName\":\"\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core-patch\\/"
        "type_patch.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"identityHashCode\":",
        buffer);

    EXPECT_SUBSTRING(
        "\"id\":\"\",\"kind\":\"TypeParameter\",\"name\":\"X1\","
        "\"parameterizedClass\":{\"type\":\"@Instance\","
        "\"_vmType\":\"Class\",\"class\":{\"type\":\"@Class\",\"fixedId\":true,"
        "\"id\":\"\",\"name\":\"Null\",\"location\":{\"type\":"
        "\"SourceLocation\",\"script\":{\"type\":\"@Script\",\"fixedId\":true,"
        "\"id\":\"\",\"uri\":\"dart:core\\/"
        "null.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"dart.core\",\"uri\":\"dart:core\"}},\"kind\":\"Null\","
        "\"fixedId\":true,\"id\":\"\",\"valueAsString\":\"null\"}}]},"
        "\"identityHashCode\":0,\"id\":\"\",\"kind\":\"Map\",\"length\":0}",
        buffer);
  }
  // UserTag reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    Instance& tag = Instance::Handle(thread->default_tag());
    tag.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_UserTag@", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_SUBSTRING(
        "\"type\":\"@Instance\",\"_vmType\":\"UserTag\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_UserTag\",\"_"
        "vmName\":\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{"
        "\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:"
        "developer-patch\\/"
        "profiler.dart\",\"_kind\":\"kernel\"}},\"library\":{\"type\":\"@"
        "Library\","
        "\"fixedId\":true,\"id\":\"\",\"name\":\"dart.developer\",\"uri\":"
        "\"dart:developer\"}},"
        // Handle non-zero identity hash.
        "\"identityHashCode\":",
        buffer);
    EXPECT_SUBSTRING(
        "\"id\":\"\","
        "\"kind\":\"UserTag\",\"label\":\"Default\"}",
        buffer);
  }
  // Type reference
  // TODO(turnidge): Add in all of the other Type siblings.
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    Instance& type =
        Instance::Handle(isolate->group()->object_store()->bool_type());
    type.PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("objects", buffer, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    ElideJSONSubstring("_Type@", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_SUBSTRING(
        "{\"type\":\"@Instance\",\"_vmType\":\"Type\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"_Type\",\"_vmName\":"
        "\"\",\"location\":{\"type\":\"SourceLocation\",\"script\":{\"type\":"
        "\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core-"
        "patch\\/type_patch.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        // Handle non-zero identity hash.
        "\"identityHashCode\":",
        buffer);
    EXPECT_SUBSTRING(
        "\"kind\":\"Type\","
        "\"fixedId\":true,\"id\":\"\","
        "\"typeClass\":{\"type\":\"@Class\",\"fixedId\":true,\"id\":\"\","
        "\"name\":\"bool\",\"location\":{\"type\":\"SourceLocation\","
        "\"script\":{\"type\":\"@Script\",\"fixedId\":true,\"id\":\"\",\"uri\":"
        "\"dart:core\\/bool.dart\",\"_kind\":\"kernel\"}"
        "},\"library\":{\"type\":\"@Library\",\"fixedId\":"
        "true,\"id\":\"\",\"name\":\"dart.core\",\"uri\":\"dart:core\"}},"
        "\"name\":\"bool\"}",
        buffer);
  }
  // Null reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    Object::null_object().PrintJSON(&js, true);
    const char* json_str = js.ToCString();
    ASSERT(strlen(json_str) < kBufferSize);
    ElideJSONSubstring("classes", json_str, buffer);
    ElideJSONSubstring("libraries", buffer, buffer);
    StripTokenPositions(buffer);
    EXPECT_STREQ(
        "{\"type\":\"@Instance\",\"_vmType\":\"null\",\"class\":{\"type\":\"@"
        "Class\",\"fixedId\":true,\"id\":\"\",\"name\":\"Null\",\"location\":{"
        "\"type\":\"SourceLocation\",\"script\":{\"type\":\"@Script\","
        "\"fixedId\":true,\"id\":\"\",\"uri\":\"dart:core\\/null.dart\",\"_"
        "kind\":\"kernel\"}},\"library\":"
        "{\"type\":\"@Library\",\"fixedId\":true,\"id\":\"\",\"name\":\"dart."
        "core\",\"uri\":\"dart:core\"}},\"kind\":\"Null\",\"fixedId\":true,"
        "\"id\":\"objects\\/null\",\"valueAsString\":\"null\"}",
        buffer);
  }
  // Sentinel reference
  {
    JSONStream js;
    js.set_id_zone(thread->isolate()->EnsureDefaultServiceIdZone());
    Object::sentinel().PrintJSON(&js, true);
    EXPECT_STREQ(
        "{\"type\":\"Sentinel\","
        "\"kind\":\"NotInitialized\","
        "\"valueAsString\":\"<not initialized>\"}",
        js.ToCString());
  }
}

#endif  // !PRODUCT

TEST_CASE(InstanceEquality) {
  // Test that Instance::OperatorEquals can call a user-defined operator==.
  const char* kScript =
      "class A {\n"
      "  bool operator==(covariant A other) { return true; }\n"
      "}\n"
      "main() {\n"
      "  A a = new A();\n"
      "}";

  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle result = Dart_Invoke(h_lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);

  TransitionNativeToVM transition(thread);
  Library& lib = Library::Handle();
  lib ^= Api::UnwrapHandle(h_lib);
  const Class& clazz = Class::Handle(GetClass(lib, "A"));
  EXPECT(!clazz.IsNull());
  const Instance& a0 = Instance::Handle(Instance::New(clazz));
  const Instance& a1 = Instance::Handle(Instance::New(clazz));
  EXPECT(a0.ptr() != a1.ptr());
  EXPECT(a0.OperatorEquals(a0));
  EXPECT(a0.OperatorEquals(a1));
  EXPECT(a0.IsIdenticalTo(a0));
  EXPECT(!a0.IsIdenticalTo(a1));
}

TEST_CASE(HashCode) {
  // Ensure C++ overrides of Instance::HashCode match the Dart implementations.
  const char* kScript =
      "@pragma('vm:entry-point', 'call')\n"
      "foo() {\n"
      "  return \"foo\".hashCode;\n"
      "}";

  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle h_result = Dart_Invoke(h_lib, NewString("foo"), 0, nullptr);
  EXPECT_VALID(h_result);

  TransitionNativeToVM transition(thread);
  Integer& result = Integer::Handle();
  result ^= Api::UnwrapHandle(h_result);
  String& foo = String::Handle(String::New("foo"));
  Integer& expected = Integer::Handle();
  expected ^= foo.HashCode();
  EXPECT(result.IsIdenticalTo(expected));
}

const uint32_t kCalculateCanonicalizeHash = 0;

// Checks that the .hashCode equals the VM CanonicalizeHash() for keys in
// constant maps.
//
// Expects a script with a method named `value`.
//
// If `hashcode_canonicalize_vm` is non-zero, the VM CanonicalizeHash()
// is not executed but the provided value is used.
static bool HashCodeEqualsCanonicalizeHash(
    const char* value_script,
    uint32_t hashcode_canonicalize_vm = kCalculateCanonicalizeHash,
    bool check_identity = true,
    bool check_hashcode = true) {
  CStringUniquePtr kScriptChars(OS::SCreate(nullptr,
                                            R"(
                  %s

                  @pragma('vm:entry-point', 'call')
                  valueHashCode() {
                    return value().hashCode;
                  }

                  @pragma('vm:entry-point', 'call')
                  valueIdentityHashCode() {
                    return identityHashCode(value());
                  }
                  )",
                                            value_script));

  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars.get(), nullptr);
  EXPECT_VALID(lib);
  Dart_Handle value_result = Dart_Invoke(lib, NewString("value"), 0, nullptr);
  EXPECT_VALID(value_result);
  Dart_Handle hashcode_result;
  if (check_hashcode) {
    hashcode_result = Dart_Invoke(lib, NewString("valueHashCode"), 0, nullptr);
    EXPECT_VALID(hashcode_result);
  }
  Dart_Handle identity_hashcode_result =
      Dart_Invoke(lib, NewString("valueIdentityHashCode"), 0, nullptr);
  EXPECT_VALID(identity_hashcode_result);

  TransitionNativeToVM transition(Thread::Current());

  const auto& value_dart = Instance::CheckedHandle(
      Thread::Current()->zone(), Api::UnwrapHandle(value_result));
  int64_t hashcode_dart;
  if (check_hashcode) {
    hashcode_dart =
        Integer::Cast(Object::Handle(Api::UnwrapHandle(hashcode_result)))
            .Value();
  }
  const int64_t identity_hashcode_dart =
      Integer::Cast(Object::Handle(Api::UnwrapHandle(identity_hashcode_result)))
          .Value();
  if (hashcode_canonicalize_vm == 0) {
    hashcode_canonicalize_vm = Instance::Cast(value_dart).CanonicalizeHash();
  }

  bool success = true;

  if (check_hashcode) {
    success &= hashcode_dart == hashcode_canonicalize_vm;
  }
  if (check_identity) {
    success &= identity_hashcode_dart == hashcode_canonicalize_vm;
  }

  if (!success) {
    LogBlock lb;
    THR_Print(
        "Dart hashCode or Dart identityHashCode does not equal VM "
        "CanonicalizeHash for %s\n",
        value_dart.ToCString());
    THR_Print("Dart hashCode %" Px64 " %" Pd64 "\n", hashcode_dart,
              hashcode_dart);
    THR_Print("Dart identityHashCode %" Px64 " %" Pd64 "\n",
              identity_hashcode_dart, identity_hashcode_dart);
    THR_Print("VM CanonicalizeHash %" Px32 " %" Pd32 "\n",
              hashcode_canonicalize_vm, hashcode_canonicalize_vm);
  }

  return success;
}

TEST_CASE(HashCode_Double) {
  const char* kScript =
      R"(
       @pragma('vm:entry-point', 'call')
       value() {
         return 1.0;
       }
      )";
  // Double VM CanonicalizeHash is not equal to hashCode, because doubles
  // cannot be used as keys in constant sets and maps. However, doubles
  // _can_ be used for lookups in which case they are equal to their integer
  // value.
  uint32_t kInt1HashCode = 0;
  {
    TransitionNativeToVM transition(thread);
    kInt1HashCode = Integer::Handle(Integer::New(1)).CanonicalizeHash();
  }
  EXPECT(HashCodeEqualsCanonicalizeHash(kScript, kInt1HashCode));
}

TEST_CASE(HashCode_Mint) {
  const char* kScript =
      R"(
       @pragma('vm:entry-point', 'call')
       value() {
         return 0x8000000;
       }
      )";
  EXPECT(HashCodeEqualsCanonicalizeHash(kScript));
}

TEST_CASE(HashCode_Null) {
  const char* kScript =
      R"(
       @pragma('vm:entry-point', 'call')
       value() {
         return null;
       }
      )";
  EXPECT(HashCodeEqualsCanonicalizeHash(kScript));
}

TEST_CASE(HashCode_Smi) {
  const char* kScript =
      R"(
       @pragma('vm:entry-point', 'call')
       value() {
         return 123;
       }
      )";
  EXPECT(HashCodeEqualsCanonicalizeHash(kScript));
}

TEST_CASE(HashCode_String) {
  const char* kScript = R"(
       @pragma('vm:entry-point', 'call')
       value() {
         return 'asdf';
       }
      )";
  EXPECT(HashCodeEqualsCanonicalizeHash(kScript));
}

TEST_CASE(HashCode_Symbol) {
  const char* kScript =
      R"(
       @pragma('vm:entry-point', 'call')
       value() {
         return #A;
       }
      )";

  EXPECT(HashCodeEqualsCanonicalizeHash(kScript, kCalculateCanonicalizeHash,
                                        /*check_identity=*/false));
}

TEST_CASE(HashCode_True) {
  const char* kScript =
      R"(
       @pragma('vm:entry-point', 'call')
       value() {
         return true;
       }
      )";
  EXPECT(HashCodeEqualsCanonicalizeHash(kScript));
}

TEST_CASE(HashCode_Type_Dynamic) {
  const char* kScript =
      R"(
       const type = dynamic;

       @pragma('vm:entry-point', 'call')
       value() {
         return type;
       }
      )";
  EXPECT(HashCodeEqualsCanonicalizeHash(kScript, kCalculateCanonicalizeHash,
                                        /*check_identity=*/false));
}

TEST_CASE(HashCode_Type_Int) {
  const char* kScript =
      R"(
       const type = int;

       @pragma('vm:entry-point', 'call')
       value() {
         return type;
       }
      )";
  EXPECT(HashCodeEqualsCanonicalizeHash(kScript, kCalculateCanonicalizeHash,
                                        /*check_identity=*/false));
}

TEST_CASE(Map_iteration) {
  const char* kScript =
      R"(
       @pragma('vm:entry-point', 'call')
       makeMap() {
         var map = {'x': 3, 'y': 4, 'z': 5, 'w': 6};
         map.remove('y');
         map.remove('w');
         return map;
       }
      )";
  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle h_result = Dart_Invoke(h_lib, NewString("makeMap"), 0, nullptr);
  EXPECT_VALID(h_result);

  TransitionNativeToVM transition(thread);
  Instance& dart_map = Instance::Handle();
  dart_map ^= Api::UnwrapHandle(h_result);
  ASSERT(dart_map.IsMap());
  const Map& cc_map = Map::Cast(dart_map);

  EXPECT_EQ(2, cc_map.Length());

  Map::Iterator iterator(cc_map);
  Object& object = Object::Handle();

  EXPECT(iterator.MoveNext());
  object = iterator.CurrentKey();
  EXPECT_STREQ("x", object.ToCString());
  object = iterator.CurrentValue();
  EXPECT_STREQ("3", object.ToCString());

  EXPECT(iterator.MoveNext());
  object = iterator.CurrentKey();
  EXPECT_STREQ("z", object.ToCString());
  object = iterator.CurrentValue();
  EXPECT_STREQ("5", object.ToCString());

  EXPECT(!iterator.MoveNext());
}

template <class LinkedHashBase>
static bool LinkedHashBaseEqual(const LinkedHashBase& map1,
                                const LinkedHashBase& map2,
                                bool print_diff,
                                bool check_data = true) {
  if (check_data) {
    // Check data, only for non-nested.
    const auto& data1 = Array::Handle(map1.data());
    const auto& data2 = Array::Handle(map2.data());
    const intptr_t data1_length = Smi::Value(map1.used_data());
    const intptr_t data2_length = Smi::Value(map2.used_data());
    const bool data_length_equal = data1_length == data2_length;
    bool data_equal = data_length_equal;
    if (data_length_equal) {
      auto& object1 = Instance::Handle();
      auto& object2 = Instance::Handle();
      for (intptr_t i = 0; i < data1_length; i++) {
        object1 ^= data1.At(i);
        object2 ^= data2.At(i);
        data_equal &= object1.CanonicalizeEquals(object2);
      }
    }
    if (!data_equal) {
      if (print_diff) {
        THR_Print("LinkedHashBaseEqual Data not equal.\n");
        THR_Print("LinkedHashBaseEqual data1.length %" Pd " data1.length %" Pd
                  " \n",
                  data1_length, data2_length);
        auto& object1 = Instance::Handle();
        for (intptr_t i = 0; i < data1_length; i++) {
          object1 ^= data1.At(i);
          THR_Print("LinkedHashBaseEqual data1[%" Pd "] %s\n", i,
                    object1.ToCString());
        }
        for (intptr_t i = 0; i < data2_length; i++) {
          object1 ^= data2.At(i);
          THR_Print("LinkedHashBaseEqual data2[%" Pd "] %s\n", i,
                    object1.ToCString());
        }
      }
      return false;
    }
  }

  // Check hashing.
  intptr_t hash_mask1 = Smi::Value(map1.hash_mask());
  EXPECT(!Integer::Handle(map2.hash_mask()).IsNull());
  intptr_t hash_mask2 = Smi::Value(map2.hash_mask());
  const bool hash_masks_equal = hash_mask1 == hash_mask2;
  if (!hash_masks_equal) {
    if (print_diff) {
      THR_Print("LinkedHashBaseEqual Hash masks not equal.\n");
      THR_Print("LinkedHashBaseEqual hash_mask1 %" Px " hash_mask2 %" Px " \n",
                hash_mask1, hash_mask2);
    }
  }

  // Check indices.
  const auto& index1 = TypedData::Handle(map1.index());
  const auto& index2 = TypedData::Handle(map2.index());
  EXPECT(!index2.IsNull());
  ASSERT(index1.ElementType() == kUint32ArrayElement);
  ASSERT(index2.ElementType() == kUint32ArrayElement);
  const intptr_t kElementSize = 4;
  ASSERT(kElementSize == index1.ElementSizeInBytes());
  const bool index_length_equal = index1.Length() == index2.Length();
  bool index_equal = index_length_equal;
  if (index_length_equal) {
    for (intptr_t i = 0; i < index1.Length(); i++) {
      const uint32_t index1_val = index1.GetUint32(i * kElementSize);
      const uint32_t index2_val = index2.GetUint32(i * kElementSize);
      index_equal &= index1_val == index2_val;
    }
  }
  if (!index_equal && print_diff) {
    THR_Print("LinkedHashBaseEqual Indices not equal.\n");
    THR_Print("LinkedHashBaseEqual index1.length %" Pd " index2.length %" Pd
              " \n",
              index1.Length(), index2.Length());
    for (intptr_t i = 0; i < index1.Length(); i++) {
      const uint32_t index_val = index1.GetUint32(i * kElementSize);
      THR_Print("LinkedHashBaseEqual index1[%" Pd "] %" Px32 "\n", i,
                index_val);
    }
    for (intptr_t i = 0; i < index2.Length(); i++) {
      const uint32_t index_val = index2.GetUint32(i * kElementSize);
      THR_Print("LinkedHashBaseEqual index2[%" Pd "] %" Px32 "\n", i,
                index_val);
    }
  }
  return index_equal;
}

// Copies elements from data.
static MapPtr ConstructImmutableMap(const Array& input_data,
                                    intptr_t used_data,
                                    const TypeArguments& type_arguments) {
  auto& map = Map::Handle(ConstMap::NewUninitialized());

  const auto& data = Array::Handle(Array::New(used_data));
  for (intptr_t i = 0; i < used_data; i++) {
    data.SetAt(i, Object::Handle(input_data.At(i)));
  }
  map.set_data(data);
  map.set_used_data(used_data);
  map.SetTypeArguments(type_arguments);
  map.set_deleted_keys(0);
  map.ComputeAndSetHashMask();
  map ^= map.Canonicalize(Thread::Current());

  return map.ptr();
}

// Constructs an immutable hashmap from a mutable one in this test.
TEST_CASE(ConstMap_vm) {
  const char* kScript = R"(
enum ExperimentalFlag {
  alternativeInvalidationStrategy,
  constFunctions,
  constantUpdate2018,
  constructorTearoffs,
  controlFlowCollections,
  extensionMethods,
  extensionTypes,
  genericMetadata,
  nonNullable,
  nonfunctionTypeAliases,
  setLiterals,
  spreadCollections,
  testExperiment,
  tripleShift,
  valueClass,
  variance,
}

final Map<ExperimentalFlag?, bool> expiredExperimentalFlagsNonConst = {
  ExperimentalFlag.alternativeInvalidationStrategy: false,
  ExperimentalFlag.constFunctions: false,
  ExperimentalFlag.constantUpdate2018: true,
  ExperimentalFlag.constructorTearoffs: false,
  ExperimentalFlag.controlFlowCollections: true,
  ExperimentalFlag.extensionMethods: false,
  ExperimentalFlag.extensionTypes: false,
  ExperimentalFlag.genericMetadata: false,
  ExperimentalFlag.nonNullable: false,
  ExperimentalFlag.nonfunctionTypeAliases: false,
  ExperimentalFlag.setLiterals: true,
  ExperimentalFlag.spreadCollections: true,
  ExperimentalFlag.testExperiment: false,
  ExperimentalFlag.tripleShift: false,
  ExperimentalFlag.valueClass: false,
  ExperimentalFlag.variance: false,
};

@pragma('vm:entry-point', 'call')
makeNonConstMap() {
  return expiredExperimentalFlagsNonConst;
}

@pragma('vm:entry-point', 'call')
firstKey() {
  return ExperimentalFlag.alternativeInvalidationStrategy;
}

@pragma('vm:entry-point', 'call')
firstKeyHashCode() {
  return firstKey().hashCode;
}

@pragma('vm:entry-point', 'call')
firstKeyIdentityHashCode() {
  return identityHashCode(firstKey());
}

@pragma('vm:entry-point', 'call')
bool lookupSpreadCollections(Map map) =>
    map[ExperimentalFlag.spreadCollections];

@pragma('vm:entry-point', 'call')
bool? lookupNull(Map map) => map[null];
)";
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle non_const_result =
      Dart_Invoke(lib, NewString("makeNonConstMap"), 0, nullptr);
  EXPECT_VALID(non_const_result);
  Dart_Handle first_key_result =
      Dart_Invoke(lib, NewString("firstKey"), 0, nullptr);
  EXPECT_VALID(first_key_result);
  Dart_Handle first_key_hashcode_result =
      Dart_Invoke(lib, NewString("firstKeyHashCode"), 0, nullptr);
  EXPECT_VALID(first_key_hashcode_result);
  Dart_Handle first_key_identity_hashcode_result =
      Dart_Invoke(lib, NewString("firstKeyIdentityHashCode"), 0, nullptr);
  EXPECT_VALID(first_key_identity_hashcode_result);

  Dart_Handle const_argument;

  {
    TransitionNativeToVM transition(thread);
    const auto& non_const_map =
        Map::Cast(Object::Handle(Api::UnwrapHandle(non_const_result)));
    const auto& non_const_type_args =
        TypeArguments::Handle(non_const_map.GetTypeArguments());
    const auto& non_const_data = Array::Handle(non_const_map.data());
    const auto& const_map = Map::Handle(ConstructImmutableMap(
        non_const_data, Smi::Value(non_const_map.used_data()),
        non_const_type_args));
    ASSERT(non_const_map.GetClassId() == kMapCid);
    ASSERT(const_map.GetClassId() == kConstMapCid);
    ASSERT(!non_const_map.IsCanonical());
    ASSERT(const_map.IsCanonical());

    const_argument = Api::NewHandle(thread, const_map.ptr());
  }

  Dart_Handle lookup_result = Dart_Invoke(
      lib, NewString("lookupSpreadCollections"), 1, &const_argument);
  EXPECT_VALID(lookup_result);
  EXPECT_TRUE(lookup_result);

  Dart_Handle lookup_null_result =
      Dart_Invoke(lib, NewString("lookupNull"), 1, &const_argument);
  EXPECT_VALID(lookup_null_result);
  EXPECT_NULL(lookup_null_result);

  {
    TransitionNativeToVM transition(thread);
    const auto& non_const_object =
        Object::Handle(Api::UnwrapHandle(non_const_result));
    const auto& non_const_map = Map::Cast(non_const_object);
    const auto& const_object =
        Object::Handle(Api::UnwrapHandle(const_argument));
    const auto& const_map = Map::Cast(const_object);

    EXPECT(non_const_map.GetClassId() != const_map.GetClassId());

    // Check that the index is identical.
    EXPECT(LinkedHashBaseEqual(non_const_map, const_map,
                               /*print_diff=*/true));
  }
}

static bool IsLinkedHashBase(const Object& object) {
  return object.IsMap() || object.IsSet();
}

// Checks that the non-constant and constant HashMap and HashSets are equal.
//
// Expects a script with a methods named `nonConstValue`, `constValue`, and
// `init`.
template <class LinkedHashBase, int kMutableCid, int kImmutableCid>
static void HashBaseNonConstEqualsConst(const char* script,
                                        bool check_data = true) {
  Dart_Handle lib = TestCase::LoadTestScript(script, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle non_const_result;
  Dart_Handle const_result;
  {
    SetFlagScope<bool> sfs(&FLAG_verify_entry_points, false);
    Dart_Handle init_result = Dart_Invoke(lib, NewString("init"), 0, nullptr);
    EXPECT_VALID(init_result);
    non_const_result = Dart_Invoke(lib, NewString("nonConstValue"), 0, nullptr);
    EXPECT_VALID(non_const_result);
    const_result = Dart_Invoke(lib, NewString("constValue"), 0, nullptr);
    EXPECT_VALID(const_result);
  }
  TransitionNativeToVM transition(Thread::Current());
  const auto& non_const_object =
      Object::Handle(Api::UnwrapHandle(non_const_result));
  const auto& const_object = Object::Handle(Api::UnwrapHandle(const_result));
  non_const_object.IsMap();
  EXPECT(IsLinkedHashBase(non_const_object));
  if (!IsLinkedHashBase(non_const_object)) return;
  const auto& non_const_value = LinkedHashBase::Cast(non_const_object);
  EXPECT(IsLinkedHashBase(const_object));
  if (!IsLinkedHashBase(const_object)) return;
  const auto& const_value = LinkedHashBase::Cast(const_object);
  EXPECT_EQ(non_const_value.GetClassId(), kMutableCid);
  EXPECT_EQ(const_value.GetClassId(), kImmutableCid);
  EXPECT(!non_const_value.IsCanonical());
  EXPECT(const_value.IsCanonical());
  EXPECT(LinkedHashBaseEqual(non_const_value, const_value,
                             /*print_diff=*/true, check_data));
}

static void HashMapNonConstEqualsConst(const char* script,
                                       bool check_data = true) {
  HashBaseNonConstEqualsConst<Map, kMapCid, kConstMapCid>(script, check_data);
}

static void HashSetNonConstEqualsConst(const char* script,
                                       bool check_data = true) {
  HashBaseNonConstEqualsConst<Set, kSetCid, kConstSetCid>(script, check_data);
}

TEST_CASE(ConstMap_small) {
  const char* kScript = R"(
constValue() => const {1: 42, 'foo': 499, 2: 'bar'};

nonConstValue() => {1: 42, 'foo': 499, 2: 'bar'};

void init() {
  constValue()[null];
}
)";
  HashMapNonConstEqualsConst(kScript);
}

TEST_CASE(ConstMap_null) {
  const char* kScript = R"(
constValue() => const {1: 42, 'foo': 499, null: 'bar'};

nonConstValue() => {1: 42, 'foo': 499, null: 'bar'};

void init() {
  constValue()[null];
}
)";
  HashMapNonConstEqualsConst(kScript);
}

TEST_CASE(ConstMap_larger) {
  const char* kScript = R"(
enum ExperimentalFlag {
  alternativeInvalidationStrategy,
  constFunctions,
  constantUpdate2018,
  constructorTearoffs,
  controlFlowCollections,
  extensionMethods,
  extensionTypes,
  genericMetadata,
  nonNullable,
  nonfunctionTypeAliases,
  setLiterals,
  spreadCollections,
  testExperiment,
  tripleShift,
  valueClass,
  variance,
}

const Map<ExperimentalFlag, bool> expiredExperimentalFlags = {
  ExperimentalFlag.alternativeInvalidationStrategy: false,
  ExperimentalFlag.constFunctions: false,
  ExperimentalFlag.constantUpdate2018: true,
  ExperimentalFlag.constructorTearoffs: false,
  ExperimentalFlag.controlFlowCollections: true,
  ExperimentalFlag.extensionMethods: false,
  ExperimentalFlag.extensionTypes: false,
  ExperimentalFlag.genericMetadata: false,
  ExperimentalFlag.nonNullable: false,
  ExperimentalFlag.nonfunctionTypeAliases: false,
  ExperimentalFlag.setLiterals: true,
  ExperimentalFlag.spreadCollections: true,
  ExperimentalFlag.testExperiment: false,
  ExperimentalFlag.tripleShift: false,
  ExperimentalFlag.valueClass: false,
  ExperimentalFlag.variance: false,
};

final Map<ExperimentalFlag, bool> expiredExperimentalFlagsNonConst = {
  ExperimentalFlag.alternativeInvalidationStrategy: false,
  ExperimentalFlag.constFunctions: false,
  ExperimentalFlag.constantUpdate2018: true,
  ExperimentalFlag.constructorTearoffs: false,
  ExperimentalFlag.controlFlowCollections: true,
  ExperimentalFlag.extensionMethods: false,
  ExperimentalFlag.extensionTypes: false,
  ExperimentalFlag.genericMetadata: false,
  ExperimentalFlag.nonNullable: false,
  ExperimentalFlag.nonfunctionTypeAliases: false,
  ExperimentalFlag.setLiterals: true,
  ExperimentalFlag.spreadCollections: true,
  ExperimentalFlag.testExperiment: false,
  ExperimentalFlag.tripleShift: false,
  ExperimentalFlag.valueClass: false,
  ExperimentalFlag.variance: false,
};

constValue() => expiredExperimentalFlags;

nonConstValue() => expiredExperimentalFlagsNonConst;

void init() {
  constValue()[null];
}
)";
  HashMapNonConstEqualsConst(kScript);
}

TEST_CASE(ConstMap_nested) {
  const char* kScript = R"(
enum Abi {
  wordSize64,
  wordSize32Align32,
  wordSize32Align64,
}

enum NativeType {
  kNativeType,
  kNativeInteger,
  kNativeDouble,
  kPointer,
  kNativeFunction,
  kInt8,
  kInt16,
  kInt32,
  kInt64,
  kUint8,
  kUint16,
  kUint32,
  kUint64,
  kIntptr,
  kFloat,
  kDouble,
  kVoid,
  kOpaque,
  kStruct,
  kHandle,
}

const nonSizeAlignment = <Abi, Map<NativeType, int>>{
  Abi.wordSize64: {},
  Abi.wordSize32Align32: {
    NativeType.kDouble: 4,
    NativeType.kInt64: 4,
    NativeType.kUint64: 4
  },
  Abi.wordSize32Align64: {},
};

final nonSizeAlignmentNonConst = <Abi, Map<NativeType, int>>{
  Abi.wordSize64: {},
  Abi.wordSize32Align32: {
    NativeType.kDouble: 4,
    NativeType.kInt64: 4,
    NativeType.kUint64: 4
  },
  Abi.wordSize32Align64: {},
};

constValue() => nonSizeAlignment;

nonConstValue() => nonSizeAlignmentNonConst;

void init() {
  constValue()[null];
}
)";
  HashMapNonConstEqualsConst(kScript, false);
}

TEST_CASE(Set_iteration) {
  const char* kScript = R"(
@pragma('vm:entry-point', 'call')
makeSet() {
  var set = {'x', 'y', 'z', 'w'};
  set.remove('y');
  set.remove('w');
  return set;
}
)";
  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(h_lib);
  Dart_Handle h_result = Dart_Invoke(h_lib, NewString("makeSet"), 0, nullptr);
  EXPECT_VALID(h_result);

  TransitionNativeToVM transition(thread);
  Instance& dart_set = Instance::Handle();
  dart_set ^= Api::UnwrapHandle(h_result);
  ASSERT(dart_set.IsSet());
  const Set& cc_set = Set::Cast(dart_set);

  EXPECT_EQ(2, cc_set.Length());

  Set::Iterator iterator(cc_set);
  Object& object = Object::Handle();

  EXPECT(iterator.MoveNext());
  object = iterator.CurrentKey();
  EXPECT_STREQ("x", object.ToCString());

  EXPECT(iterator.MoveNext());
  object = iterator.CurrentKey();
  EXPECT_STREQ("z", object.ToCString());

  EXPECT(!iterator.MoveNext());
}

// Copies elements from data.
static SetPtr ConstructImmutableSet(const Array& input_data,
                                    intptr_t used_data,
                                    const TypeArguments& type_arguments) {
  auto& set = Set::Handle(ConstSet::NewUninitialized());

  const auto& data = Array::Handle(Array::New(used_data));
  for (intptr_t i = 0; i < used_data; i++) {
    data.SetAt(i, Object::Handle(input_data.At(i)));
  }
  set.set_data(data);
  set.set_used_data(used_data);
  set.SetTypeArguments(type_arguments);
  set.set_deleted_keys(0);
  set.ComputeAndSetHashMask();
  set ^= set.Canonicalize(Thread::Current());

  return set.ptr();
}

TEST_CASE(ConstSet_vm) {
  const char* kScript = R"(
@pragma('vm:entry-point', 'call')
makeNonConstSet() {
  return {1, 2, 3, 5, 8, 13};
}

@pragma('vm:entry-point', 'call')
bool containsFive(Set set) => set.contains(5);
)";
  Dart_Handle lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(lib);
  Dart_Handle non_const_result =
      Dart_Invoke(lib, NewString("makeNonConstSet"), 0, nullptr);
  EXPECT_VALID(non_const_result);

  Dart_Handle const_argument;

  {
    TransitionNativeToVM transition(thread);
    const auto& non_const_object =
        Object::Handle(Api::UnwrapHandle(non_const_result));
    const auto& non_const_set = Set::Cast(non_const_object);
    ASSERT(non_const_set.GetClassId() == kSetCid);
    ASSERT(!non_const_set.IsCanonical());

    const auto& non_const_data = Array::Handle(non_const_set.data());
    const auto& non_const_type_args =
        TypeArguments::Handle(non_const_set.GetTypeArguments());
    const auto& const_set = Set::Handle(ConstructImmutableSet(
        non_const_data, Smi::Value(non_const_set.used_data()),
        non_const_type_args));
    ASSERT(const_set.GetClassId() == kConstSetCid);
    ASSERT(const_set.IsCanonical());

    const_argument = Api::NewHandle(thread, const_set.ptr());
  }

  Dart_Handle contains_5_result =
      Dart_Invoke(lib, NewString("containsFive"), 1, &const_argument);
  EXPECT_VALID(contains_5_result);
  EXPECT_TRUE(contains_5_result);

  {
    TransitionNativeToVM transition(thread);
    const auto& non_const_object =
        Object::Handle(Api::UnwrapHandle(non_const_result));
    const auto& non_const_set = Set::Cast(non_const_object);
    const auto& const_object =
        Object::Handle(Api::UnwrapHandle(const_argument));
    const auto& const_set = Set::Cast(const_object);

    EXPECT(non_const_set.GetClassId() != const_set.GetClassId());

    // Check that the index is identical.
    EXPECT(LinkedHashBaseEqual(non_const_set, const_set,
                               /*print_diff=*/true));
  }
}

TEST_CASE(ConstSet_small) {
  const char* kScript = R"(
constValue() => const {1, 2, 3, 5, 8, 13};

nonConstValue() => {1, 2, 3, 5, 8, 13};

void init() {
  constValue().contains(null);
}
)";
  HashSetNonConstEqualsConst(kScript);
}

TEST_CASE(ConstSet_larger) {
  const char* kScript = R"(
const Set<String> tokensThatMayFollowTypeArg = {
  '(',
  ')',
  ']',
  '}',
  ':',
  ';',
  ',',
  '.',
  '?',
  '==',
  '!=',
  '..',
  '?.',
  '\?\?',
  '?..',
  '&',
  '|',
  '^',
  '+',
  '*',
  '%',
  '/',
  '~/'
};

final Set<String> tokensThatMayFollowTypeArgNonConst = {
  '(',
  ')',
  ']',
  '}',
  ':',
  ';',
  ',',
  '.',
  '?',
  '==',
  '!=',
  '..',
  '?.',
  '\?\?',
  '?..',
  '&',
  '|',
  '^',
  '+',
  '*',
  '%',
  '/',
  '~/'
};

constValue() => tokensThatMayFollowTypeArg;

nonConstValue() => tokensThatMayFollowTypeArgNonConst;

void init() {
  constValue().contains(null);
}
)";
  HashSetNonConstEqualsConst(kScript);
}

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& res2 = String::Handle(zone, String::ConcatAll(array));
  EXPECT(res1.Equals(res2));
}

ISOLATE_UNIT_TEST_CASE(Symbols_FromConcatAll) {
  {
    const String* data[3] = {&Symbols::TypeError(), &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));

    const String* data[3] = {&two_str, &Symbols::Dot(), &two_str};
    CheckConcatAll(data, 3);
  }

  {
    const String& empty = String::Handle(String::New(""));
    const String* data[3] = {&Symbols::TypeError(), &empty,
                             &Symbols::isPaused()};
    CheckConcatAll(data, 3);
  }
}

struct TestResult {
  const char* in;
  const char* out;
};

ISOLATE_UNIT_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"},
  };
  String& test = String::Handle();
  const char* result;
  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);
  }
}

ISOLATE_UNIT_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};

  const String& str =
      String::Handle(String::FromUTF32(char_codes, ARRAY_SIZE(char_codes)));
  EXPECT(str.Equals(char_codes, ARRAY_SIZE(char_codes)));
}

TEST_CASE(TypeParameterTypeRef) {
  // Regression test for issue 82890.
  const char* kScriptChars =
      "void foo<T extends C<T>>(T x) {}\n"
      "void bar<M extends U<M>>(M x) {}\n"
      "abstract class C<T> {}\n"
      "abstract class U<T> extends C<T> {}\n";
  TestCase::LoadTestScript(kScriptChars, nullptr);
  TransitionNativeToVM transition(thread);
  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 Function& foo = Function::Handle(GetFunction(lib, "foo"));
  const Function& bar = Function::Handle(GetFunction(lib, "bar"));
  const TypeParameter& t = TypeParameter::Handle(foo.TypeParameterAt(0));
  const TypeParameter& m = TypeParameter::Handle(bar.TypeParameterAt(0));
  EXPECT(!m.IsSubtypeOf(t, Heap::kNew));
}

static void FinalizeAndCanonicalize(AbstractType* type) {
  *type ^= ClassFinalizer::FinalizeType(*type);
  ASSERT(type->IsCanonical());
}

static void CheckSubtypeRelation(const Expect& expect,
                                 const AbstractType& sub,
                                 const AbstractType& super,
                                 bool is_subtype) {
  if (sub.IsSubtypeOf(super, Heap::kNew) != is_subtype) {
    TextBuffer buffer(128);
    buffer.AddString("Expected ");
    sub.PrintName(Object::kScrubbedName, &buffer);
    buffer.Printf(" to %s a subtype of ", is_subtype ? "be" : "not be");
    super.PrintName(Object::kScrubbedName, &buffer);
    expect.Fail("%s", buffer.buffer());
  }
}

#define EXPECT_SUBTYPE(sub, super)                                             \
  CheckSubtypeRelation(Expect(__FILE__, __LINE__), sub, super, true);
#define EXPECT_NOT_SUBTYPE(sub, super)                                         \
  CheckSubtypeRelation(Expect(__FILE__, __LINE__), sub, super, false);

ISOLATE_UNIT_TEST_CASE(ClosureType_SubtypeOfFunctionType) {
  const auto& closure_class =
      Class::Handle(IsolateGroup::Current()->object_store()->closure_class());
  const auto& closure_type = Type::Handle(closure_class.DeclarationType());
  auto& closure_type_nullable = Type::Handle(
      closure_type.ToNullability(Nullability::kNullable, Heap::kNew));
  FinalizeAndCanonicalize(&closure_type_nullable);
  auto& closure_type_nonnullable = Type::Handle(
      closure_type.ToNullability(Nullability::kNonNullable, Heap::kNew));
  FinalizeAndCanonicalize(&closure_type_nonnullable);

  const auto& function_type =
      Type::Handle(IsolateGroup::Current()->object_store()->function_type());
  auto& function_type_nullable = Type::Handle(
      function_type.ToNullability(Nullability::kNullable, Heap::kNew));
  FinalizeAndCanonicalize(&function_type_nullable);
  auto& function_type_nonnullable = Type::Handle(
      function_type.ToNullability(Nullability::kNonNullable, Heap::kNew));
  FinalizeAndCanonicalize(&function_type_nonnullable);

  EXPECT_SUBTYPE(closure_type_nonnullable, function_type_nullable);
  EXPECT_SUBTYPE(closure_type_nonnullable, function_type_nonnullable);
  EXPECT_SUBTYPE(closure_type_nullable, function_type_nullable);
  EXPECT_NOT_SUBTYPE(closure_type_nullable, function_type_nonnullable);

  const auto& async_lib = Library::Handle(Library::AsyncLibrary());
  const auto& future_or_class =
      Class::Handle(async_lib.LookupClass(Symbols::FutureOr()));
  auto& tav_function_nullable = TypeArguments::Handle(TypeArguments::New(1));
  tav_function_nullable.SetTypeAt(0, function_type_nullable);
  tav_function_nullable = tav_function_nullable.Canonicalize(thread);
  auto& tav_function_nonnullable = TypeArguments::Handle(TypeArguments::New(1));
  tav_function_nonnullable.SetTypeAt(0, function_type_nonnullable);
  tav_function_nonnullable = tav_function_nonnullable.Canonicalize(thread);

  auto& future_or_function_type_nullable =
      Type::Handle(Type::New(future_or_class, tav_function_nullable));
  FinalizeAndCanonicalize(&future_or_function_type_nullable);
  auto& future_or_function_type_nonnullable =
      Type::Handle(Type::New(future_or_class, tav_function_nonnullable));
  FinalizeAndCanonicalize(&future_or_function_type_nonnullable);

  EXPECT_SUBTYPE(closure_type_nonnullable, future_or_function_type_nullable);
  EXPECT_SUBTYPE(closure_type_nonnullable, future_or_function_type_nonnullable);
  EXPECT_SUBTYPE(closure_type_nullable, future_or_function_type_nullable);
  EXPECT_NOT_SUBTYPE(closure_type_nullable,
                     future_or_function_type_nonnullable);
}

ISOLATE_UNIT_TEST_CASE(FunctionType_IsSubtypeOfNonNullableObject) {
  const auto& type_object = Type::Handle(
      IsolateGroup::Current()->object_store()->non_nullable_object_type());

  auto& type_function_int_nullary =
      FunctionType::Handle(FunctionType::New(0, Nullability::kNonNullable));
  type_function_int_nullary.set_result_type(Type::Handle(Type::IntType()));
  FinalizeAndCanonicalize(&type_function_int_nullary);

  auto& type_nullable_function_int_nullary =
      FunctionType::Handle(type_function_int_nullary.ToNullability(
          Nullability::kNullable, Heap::kOld));
  FinalizeAndCanonicalize(&type_nullable_function_int_nullary);

  EXPECT_SUBTYPE(type_function_int_nullary, type_object);
  EXPECT_NOT_SUBTYPE(type_nullable_function_int_nullary, type_object);
}

#undef EXPECT_NOT_SUBTYPE
#undef EXPECT_SUBTYPE

static void ExpectTypesEquivalent(const Expect& expect,
                                  const AbstractType& expected,
                                  const AbstractType& got,
                                  TypeEquality kind) {
  if (got.IsEquivalent(expected, kind)) return;
  TextBuffer buffer(128);
  buffer.AddString("Expected type ");
  expected.PrintName(Object::kScrubbedName, &buffer);
  buffer.AddString(", got ");
  got.PrintName(Object::kScrubbedName, &buffer);
  expect.Fail("%s", buffer.buffer());
}

#define EXPECT_TYPES_EQUAL(expected, got)                                      \
  ExpectTypesEquivalent(Expect(__FILE__, __LINE__), expected, got,             \
                        TypeEquality::kCanonical);

TEST_CASE(Class_GetInstantiationOf) {
  const char* kScript = R"(
    class B<T> {}
    class A1<X, Y> implements B<List<Y>> {}
    class A2<X, Y> extends A1<Y, X> {}
  )";
  Dart_Handle api_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(api_lib);
  TransitionNativeToVM transition(thread);
  Zone* const zone = thread->zone();

  const auto& root_lib =
      Library::CheckedHandle(zone, Api::UnwrapHandle(api_lib));
  EXPECT(!root_lib.IsNull());
  const auto& class_b = Class::Handle(zone, GetClass(root_lib, "B"));
  const auto& class_a1 = Class::Handle(zone, GetClass(root_lib, "A1"));
  const auto& class_a2 = Class::Handle(zone, GetClass(root_lib, "A2"));

  const auto& core_lib = Library::Handle(zone, Library::CoreLibrary());
  const auto& class_list = Class::Handle(zone, GetClass(core_lib, "List"));

  const auto& decl_type_b = Type::Handle(zone, class_b.DeclarationType());
  const auto& decl_type_list = Type::Handle(zone, class_list.DeclarationType());
  const auto& null_tav = Object::null_type_arguments();

  // Test that A1.GetInstantiationOf(B) returns B<List<A1::Y>>.
  {
    const auto& decl_type_a1 = Type::Handle(zone, class_a1.DeclarationType());
    const auto& decl_type_args_a1 =
        TypeArguments::Handle(zone, decl_type_a1.arguments());
    const auto& type_arg_a1_y =
        TypeParameter::CheckedHandle(zone, decl_type_args_a1.TypeAt(1));
    auto& tav_a1_y = TypeArguments::Handle(TypeArguments::New(1));
    tav_a1_y.SetTypeAt(0, type_arg_a1_y);
    tav_a1_y = tav_a1_y.Canonicalize(thread);
    auto& type_list_a1_y = Type::CheckedHandle(
        zone, decl_type_list.InstantiateFrom(tav_a1_y, null_tav, kAllFree,
                                             Heap::kNew));
    type_list_a1_y ^= type_list_a1_y.Canonicalize(thread);
    auto& tav_list_a1_y = TypeArguments::Handle(TypeArguments::New(1));
    tav_list_a1_y.SetTypeAt(0, type_list_a1_y);
    tav_list_a1_y = tav_list_a1_y.Canonicalize(thread);
    auto& type_b_list_a1_y = Type::CheckedHandle(
        zone, decl_type_b.InstantiateFrom(tav_list_a1_y, null_tav, kAllFree,
                                          Heap::kNew));
    type_b_list_a1_y ^= type_b_list_a1_y.Canonicalize(thread);

    const auto& inst_b_a1 =
        Type::Handle(zone, class_a1.GetInstantiationOf(zone, class_b));
    EXPECT(!inst_b_a1.IsNull());
    EXPECT_TYPES_EQUAL(type_b_list_a1_y, inst_b_a1);
  }

  // Test that A2.GetInstantiationOf(B) returns B<List<A2::X>>.
  {
    const auto& decl_type_a2 = Type::Handle(zone, class_a2.DeclarationType());
    const auto& decl_type_args_a2 =
        TypeArguments::Handle(zone, decl_type_a2.arguments());
    const auto& type_arg_a2_x =
        TypeParameter::CheckedHandle(zone, decl_type_args_a2.TypeAt(0));
    auto& tav_a2_x = TypeArguments::Handle(TypeArguments::New(1));
    tav_a2_x.SetTypeAt(0, type_arg_a2_x);
    tav_a2_x = tav_a2_x.Canonicalize(thread);
    auto& type_list_a2_x = Type::CheckedHandle(
        zone, decl_type_list.InstantiateFrom(tav_a2_x, null_tav, kAllFree,
                                             Heap::kNew));
    type_list_a2_x ^= type_list_a2_x.Canonicalize(thread);
    auto& tav_list_a2_x = TypeArguments::Handle(TypeArguments::New(1));
    tav_list_a2_x.SetTypeAt(0, type_list_a2_x);
    tav_list_a2_x = tav_list_a2_x.Canonicalize(thread);
    auto& type_b_list_a2_x = Type::CheckedHandle(
        zone, decl_type_b.InstantiateFrom(tav_list_a2_x, null_tav, kAllFree,
                                          Heap::kNew));
    type_b_list_a2_x ^= type_b_list_a2_x.Canonicalize(thread);

    const auto& inst_b_a2 =
        Type::Handle(zone, class_a2.GetInstantiationOf(zone, class_b));
    EXPECT(!inst_b_a2.IsNull());
    EXPECT_TYPES_EQUAL(type_b_list_a2_x, inst_b_a2);
  }
}

#undef EXPECT_TYPES_EQUAL

#define EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got)                   \
  ExpectTypesEquivalent(Expect(__FILE__, __LINE__), expected, got,             \
                        TypeEquality::kSyntactical);

static TypePtr CreateFutureOrType(const AbstractType& param,
                                  Nullability nullability) {
  const auto& async_lib = Library::Handle(Library::AsyncLibrary());
  const auto& future_or_class =
      Class::Handle(async_lib.LookupClass(Symbols::FutureOr()));
  const auto& tav = TypeArguments::Handle(TypeArguments::New(1));
  tav.SetTypeAt(0, param);
  const auto& type =
      AbstractType::Handle(Type::New(future_or_class, tav, nullability));
  return Type::RawCast(
      ClassFinalizer::FinalizeType(type, ClassFinalizer::kFinalize));
}

static TypePtr CreateFutureType(const AbstractType& param,
                                Nullability nullability) {
  ObjectStore* const object_store = IsolateGroup::Current()->object_store();
  const auto& future_class = Class::Handle(object_store->future_class());
  const auto& tav = TypeArguments::Handle(TypeArguments::New(1));
  tav.SetTypeAt(0, param);
  const auto& type = Type::Handle(Type::New(future_class, tav, nullability));
  return Type::RawCast(
      ClassFinalizer::FinalizeType(type, ClassFinalizer::kFinalize));
}

ISOLATE_UNIT_TEST_CASE(AbstractType_NormalizeFutureOrType) {
  // This should be kept up to date with any changes in
  // https://github.com/dart-lang/language/blob/master/resources/type-system/normalization.md

  ObjectStore* const object_store = IsolateGroup::Current()->object_store();

  auto normalized_future_or = [&](const AbstractType& param,
                                  Nullability nullability) -> AbstractTypePtr {
    const auto& type = Type::Handle(CreateFutureOrType(param, nullability));
    return type.NormalizeFutureOrType(Heap::kNew);
  };

  // NORM(FutureOr<T>) =
  //   let S be NORM(T)
  //   if S is a top type then S
  {
    const auto& type = AbstractType::Handle(normalized_future_or(
        Object::dynamic_type(), Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(Object::dynamic_type(), type);
  }

  {
    const auto& type = AbstractType::Handle(
        normalized_future_or(Object::void_type(), Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(Object::void_type(), type);
  }

  {
    const auto& type_nullable_object =
        Type::Handle(object_store->nullable_object_type());
    const auto& type = AbstractType::Handle(
        normalized_future_or(type_nullable_object, Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_nullable_object, type);
  }

  //   if S is Object then S

  {
    const auto& type_non_nullable_object =
        Type::Handle(object_store->non_nullable_object_type());
    const auto& type = AbstractType::Handle(normalized_future_or(
        type_non_nullable_object, Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_non_nullable_object, type);
  }

  //   if S is Never then Future<Never>

  {
    const auto& type_never = Type::Handle(object_store->never_type());
    const auto& expected =
        Type::Handle(CreateFutureType(type_never, Nullability::kNonNullable));
    const auto& got = AbstractType::Handle(
        normalized_future_or(type_never, Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }

  //   if S is Null then Future<Null>?

  {
    const auto& type_null = Type::Handle(object_store->null_type());
    const auto& expected =
        Type::Handle(CreateFutureType(type_null, Nullability::kNullable));
    const auto& got = AbstractType::Handle(
        normalized_future_or(type_null, Nullability::kNonNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }

  //   else FutureOr<S>

  // NORM(T?) =
  //   let S be NORM(T)
  //   ...
  //   if S is FutureOr<R> and R is nullable then S

  {
    const auto& type_nullable_int =
        Type::Handle(object_store->nullable_int_type());
    const auto& expected = Type::Handle(
        CreateFutureOrType(type_nullable_int, Nullability::kNonNullable));
    const auto& got = AbstractType::Handle(
        normalized_future_or(type_nullable_int, Nullability::kNullable));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }
}

TEST_CASE(AbstractType_InstantiatedFutureOrIsNormalized) {
  const char* kScript = R"(
import 'dart:async';

FutureOr<T>? foo<T>() { return null; }
FutureOr<T?> bar<T>() { return null; }
)";

  Dart_Handle api_lib = TestCase::LoadTestScript(kScript, nullptr);
  EXPECT_VALID(api_lib);
  TransitionNativeToVM transition(thread);
  Zone* const zone = thread->zone();
  ObjectStore* const object_store = IsolateGroup::Current()->object_store();

  const auto& null_tav = Object::null_type_arguments();
  auto instantiate_future_or =
      [&](const AbstractType& generic,
          const AbstractType& param) -> AbstractTypePtr {
    const auto& tav = TypeArguments::Handle(TypeArguments::New(1));
    tav.SetTypeAt(0, param);
    return generic.InstantiateFrom(null_tav, tav, kCurrentAndEnclosingFree,
                                   Heap::kNew);
  };

  const auto& root_lib =
      Library::CheckedHandle(zone, Api::UnwrapHandle(api_lib));
  EXPECT(!root_lib.IsNull());
  const auto& foo = Function::Handle(zone, GetFunction(root_lib, "foo"));
  const auto& bar = Function::Handle(zone, GetFunction(root_lib, "bar"));
  const auto& foo_sig = FunctionType::Handle(zone, foo.signature());
  const auto& bar_sig = FunctionType::Handle(zone, bar.signature());

  const auto& nullable_future_or_T =
      AbstractType::Handle(zone, foo_sig.result_type());
  const auto& future_or_nullable_T =
      AbstractType::Handle(zone, bar_sig.result_type());

  const auto& type_nullable_object =
      Type::Handle(object_store->nullable_object_type());
  const auto& type_non_nullable_object =
      Type::Handle(object_store->non_nullable_object_type());

  // Testing same cases as AbstractType_NormalizeFutureOrType.

  // FutureOr<T>?[top type] = top type

  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, Object::dynamic_type()));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(Object::dynamic_type(), got);
  }

  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, Object::void_type()));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(Object::void_type(), got);
  }

  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_nullable_object));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_nullable_object, got);
  }

  // FutureOr<T?>[top type] = top type

  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, Object::dynamic_type()));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(Object::dynamic_type(), got);
  }

  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, Object::void_type()));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(Object::void_type(), got);
  }

  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_nullable_object));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_nullable_object, got);
  }

  // FutureOr<T?>[Object] = Object?

  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_non_nullable_object));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_nullable_object, got);
  }

  // FutureOr<T>?[Object] = Object?

  {
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_non_nullable_object));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(type_nullable_object, got);
  }

  const auto& type_never = Type::Handle(object_store->never_type());
  const auto& type_null = Type::Handle(object_store->null_type());

  // FutureOr<T?>[Never] = Future<Null>?

  {
    const auto& expected =
        Type::Handle(CreateFutureType(type_null, Nullability::kNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_never));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }

  // FutureOr<T>?[Never] = Future<Never>?

  {
    const auto& expected =
        Type::Handle(CreateFutureType(type_never, Nullability::kNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_never));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }

  // FutureOr<T?>[Null] = Future<Null>?

  {
    const auto& expected =
        Type::Handle(CreateFutureType(type_null, Nullability::kNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_null));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }

  // FutureOr<T>?[Null] = Future<Null>?

  {
    const auto& expected =
        Type::Handle(CreateFutureType(type_null, Nullability::kNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_null));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }

  const auto& type_nullable_int =
      Type::Handle(object_store->nullable_int_type());
  const auto& type_non_nullable_int =
      Type::Handle(object_store->non_nullable_int_type());

  // FutureOr<T?>[int] = FutureOr<int?>

  {
    const auto& expected = Type::Handle(
        CreateFutureOrType(type_nullable_int, Nullability::kNonNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_non_nullable_int));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }

  // FutureOr<T?>[int?] = FutureOr<int?>

  {
    const auto& expected = Type::Handle(
        CreateFutureOrType(type_nullable_int, Nullability::kNonNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(future_or_nullable_T, type_nullable_int));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }

  // FutureOr<T>?[int?] = FutureOr<int?>

  {
    const auto& expected = Type::Handle(
        CreateFutureOrType(type_nullable_int, Nullability::kNonNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_nullable_int));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }

  // FutureOr<T>?[int] = FutureOr<int>?

  {
    const auto& expected = Type::Handle(
        CreateFutureOrType(type_non_nullable_int, Nullability::kNullable));
    const auto& got = AbstractType::Handle(
        instantiate_future_or(nullable_future_or_T, type_non_nullable_int));
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(expected, got);
  }
}

#define __ assembler->

static void GenerateInvokeInstantiateTAVStub(compiler::Assembler* assembler) {
  __ EnterDartFrame(0);
  if (FLAG_target_thread_sanitizer) {
    __ TsanFuncEntry();
  }

  // Load the arguments into the right stub calling convention registers.
  const intptr_t uninstantiated_offset =
      (kCallerSpSlotFromFp + 2) * compiler::target::kWordSize;
  const intptr_t inst_type_args_offset =
      (kCallerSpSlotFromFp + 1) * compiler::target::kWordSize;
  const intptr_t fun_type_args_offset =
      (kCallerSpSlotFromFp + 0) * compiler::target::kWordSize;

  __ LoadMemoryValue(InstantiationABI::kUninstantiatedTypeArgumentsReg, FPREG,
                     uninstantiated_offset);
  __ LoadMemoryValue(InstantiationABI::kInstantiatorTypeArgumentsReg, FPREG,
                     inst_type_args_offset);
  __ LoadMemoryValue(InstantiationABI::kFunctionTypeArgumentsReg, FPREG,
                     fun_type_args_offset);

  __ Call(StubCode::InstantiateTypeArguments());

  // Set the return from the stub.
  __ MoveRegister(CallingConventions::kReturnReg,
                  InstantiationABI::kResultTypeArgumentsReg);
  if (FLAG_target_thread_sanitizer) {
    __ TsanFuncExit();
  }
  __ LeaveDartFrame();
  __ Ret();
}

#undef __

static CodePtr CreateInvokeInstantiateTypeArgumentsStub(Thread* thread) {
  Zone* const zone = thread->zone();
  const auto& klass = Class::Handle(
      zone, thread->isolate_group()->class_table()->At(kInstanceCid));
  const auto& symbol = String::Handle(
      zone, Symbols::New(thread, OS::SCreate(zone, "InstantiateTAVTest")));
  const auto& signature = FunctionType::Handle(zone, FunctionType::New());
  const auto& function = Function::Handle(
      zone, Function::New(signature, symbol, UntaggedFunction::kRegularFunction,
                          false, false, false, false, false, klass,
                          TokenPosition::kNoSource));

  compiler::ObjectPoolBuilder pool_builder;
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
  compiler::Assembler assembler(&pool_builder);
  GenerateInvokeInstantiateTAVStub(&assembler);
  const Code& invoke_instantiate_tav = Code::Handle(
      Code::FinalizeCodeAndNotify("InstantiateTAV", nullptr, &assembler,
                                  Code::PoolAttachment::kNotAttachPool,
                                  /*optimized=*/false));

  const auto& pool =
      ObjectPool::Handle(zone, ObjectPool::NewFromBuilder(pool_builder));
  invoke_instantiate_tav.set_object_pool(pool.ptr());
  invoke_instantiate_tav.set_owner(function);
  invoke_instantiate_tav.set_exception_handlers(
      ExceptionHandlers::Handle(zone, ExceptionHandlers::New(0)));
#if defined(TARGET_ARCH_IA32)
  EXPECT_EQ(0, pool.Length());
#else
  EXPECT_EQ(1, pool.Length());  // The InstantiateTypeArguments stub.
#endif
  return invoke_instantiate_tav.ptr();
}

#if !defined(PRODUCT)
// Defined before TypeArguments::InstantiateAndCanonicalizeFrom in object.cc.
extern bool TESTING_runtime_fail_on_existing_cache_entry;
#endif

static void TypeArgumentsHashCacheTest(Thread* thread, intptr_t num_classes) {
  TextBuffer buffer(MB);
  buffer.AddString("class D<T> {}\n");
  for (intptr_t i = 0; i < num_classes; i++) {
    buffer.Printf("class C%" Pd " { String toString() => 'C%" Pd "'; }\n", i,
                  i);
  }
  buffer.AddString("main() {\n");
  for (intptr_t i = 0; i < num_classes; i++) {
    buffer.Printf("  C%" Pd "().toString();\n", i);
  }
  buffer.AddString("}\n");

  Dart_Handle api_lib = TestCase::LoadTestScript(buffer.buffer(), nullptr);
  EXPECT_VALID(api_lib);
  Dart_Handle result = Dart_Invoke(api_lib, NewString("main"), 0, nullptr);
  EXPECT_VALID(result);

  // D + C0...CN, where N = kNumClasses - 1
  EXPECT(IsolateGroup::Current()->class_table()->NumCids() > num_classes);

  TransitionNativeToVM transition(thread);
  Zone* const zone = thread->zone();

  const auto& root_lib =
      Library::CheckedHandle(zone, Api::UnwrapHandle(api_lib));
  EXPECT(!root_lib.IsNull());

  const auto& class_d = Class::Handle(zone, GetClass(root_lib, "D"));
  ASSERT(!class_d.IsNull());
  const auto& decl_type_d = Type::Handle(zone, class_d.DeclarationType());
  const auto& decl_type_d_type_args =
      TypeArguments::Handle(zone, decl_type_d.arguments());

  EXPECT(!decl_type_d_type_args.HasInstantiations());

  auto& class_c = Class::Handle(zone);
  auto& decl_type_c = Type::Handle(zone);
  auto& instantiator_type_args = TypeArguments::Handle(zone);
  const auto& function_type_args = Object::null_type_arguments();
  auto& result_type_args = TypeArguments::Handle(zone);
  auto& result_type = AbstractType::Handle(zone);
  // Cache the first computed set of instantiator type arguments to check that
  // no entries from the cache have been lost when the cache grows.
  auto& first_instantiator_type_args = TypeArguments::Handle(zone);
  // Used for the cache hit in stub check.
  const auto& invoke_instantiate_tav =
      Code::Handle(zone, CreateInvokeInstantiateTypeArgumentsStub(thread));
  const auto& invoke_instantiate_tav_arguments =
      Array::Handle(zone, Array::New(3));
  const auto& invoke_instantiate_tav_args_descriptor =
      Array::Handle(zone, ArgumentsDescriptor::NewBoxed(0, 3));
  for (intptr_t i = 0; i < num_classes; ++i) {
    const bool updated_cache_is_linear =
        i < TypeArguments::Cache::kMaxLinearCacheEntries;
    auto const name = OS::SCreate(zone, "C%" Pd "", i);
    class_c = GetClass(root_lib, name);
    ASSERT(!class_c.IsNull());
    decl_type_c = class_c.DeclarationType();
    instantiator_type_args = TypeArguments::New(1);
    instantiator_type_args.SetTypeAt(0, decl_type_c);
    instantiator_type_args = instantiator_type_args.Canonicalize(thread);

#if !defined(PRODUCT)
    // The first call to InstantiateAndCanonicalizeFrom shouldn't have a cache
    // hit since the instantiator type arguments should be unique for each
    // iteration, and after that we do a check that the InstantiateTypeArguments
    // stub finds the entry (unless the cache is hash-based on IA32).
    TESTING_runtime_fail_on_existing_cache_entry = true;
#endif

    // Check that the key does not currently exist in the cache.
    intptr_t old_capacity;
    {
      SafepointMutexLocker ml(
          thread->isolate_group()->type_arguments_canonicalization_mutex());
      TypeArguments::Cache cache(zone, decl_type_d_type_args);
      EXPECT_EQ(i, cache.NumOccupied());
      auto loc =
          cache.FindKeyOrUnused(instantiator_type_args, function_type_args);
      EXPECT(!loc.present);
      old_capacity = cache.NumEntries();
    }

    decl_type_d_type_args.InstantiateAndCanonicalizeFrom(instantiator_type_args,
                                                         function_type_args);

    // Check that the key now does exist in the cache.
    TypeArguments::Cache::KeyLocation loc;
    bool storage_changed;
    {
      SafepointMutexLocker ml(
          thread->isolate_group()->type_arguments_canonicalization_mutex());
      TypeArguments::Cache cache(zone, decl_type_d_type_args);
      EXPECT_EQ(i + 1, cache.NumOccupied());
      // Double-check that we got the expected type of cache.
      EXPECT(updated_cache_is_linear ? cache.IsLinear() : cache.IsHash());
      loc = cache.FindKeyOrUnused(instantiator_type_args, function_type_args);
      EXPECT(loc.present);
      storage_changed = cache.NumEntries() != old_capacity;
    }

#if defined(TARGET_ARCH_IA32)
    const bool stub_checks_hash_caches = false;
#else
    const bool stub_checks_hash_caches = true;
#endif
    // Now check that we get the expected result from calling the stub if it
    // checks the cache (e.g., in all cases but hash-based caches on IA32).
    if (updated_cache_is_linear || stub_checks_hash_caches) {
      invoke_instantiate_tav_arguments.SetAt(0, decl_type_d_type_args);
      invoke_instantiate_tav_arguments.SetAt(1, instantiator_type_args);
      invoke_instantiate_tav_arguments.SetAt(2, function_type_args);
      result_type_args ^= DartEntry::InvokeCode(
          invoke_instantiate_tav, invoke_instantiate_tav_args_descriptor,
          invoke_instantiate_tav_arguments, thread);
      EXPECT_EQ(1, result_type_args.Length());
      result_type = result_type_args.TypeAt(0);
      EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(decl_type_c, result_type);
    }

#if !defined(PRODUCT)
    // Setting to false prior to re-calling InstantiateAndCanonicalizeFrom with
    // the same keys, as now we want a runtime check of an existing cache entry.
    TESTING_runtime_fail_on_existing_cache_entry = false;
#endif

    result_type_args = decl_type_d_type_args.InstantiateAndCanonicalizeFrom(
        instantiator_type_args, function_type_args);
    result_type = result_type_args.TypeAt(0);
    EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT(decl_type_c, result_type);

    // Check that no new entries were added to the cache.
    {
      SafepointMutexLocker ml(
          thread->isolate_group()->type_arguments_canonicalization_mutex());
      TypeArguments::Cache cache(zone, decl_type_d_type_args);
      EXPECT_EQ(i + 1, cache.NumOccupied());
      auto const loc2 =
          cache.FindKeyOrUnused(instantiator_type_args, function_type_args);
      EXPECT(loc2.present);
      EXPECT_EQ(loc.entry, loc2.entry);
    }

    if (i == 0) {
      first_instantiator_type_args = instantiator_type_args.ptr();
    } else if (storage_changed) {
      // Check that the first instantiator TAV still exists in the new cache.
      SafepointMutexLocker ml(
          thread->isolate_group()->type_arguments_canonicalization_mutex());
      TypeArguments::Cache cache(zone, decl_type_d_type_args);
      EXPECT_EQ(i + 1, cache.NumOccupied());
      // Double-check that we got the expected type of cache.
      EXPECT(i < TypeArguments::Cache::kMaxLinearCacheEntries ? cache.IsLinear()
                                                              : cache.IsHash());
      auto const loc =
          cache.FindKeyOrUnused(instantiator_type_args, function_type_args);
      EXPECT(loc.present);
    }
  }
}

// A smaller version of the following test case, just to ensure some coverage
// on slower builds.
TEST_CASE(TypeArguments_Cache_SomeInstantiations) {
  TypeArgumentsHashCacheTest(thread,
                             2 * TypeArguments::Cache::kMaxLinearCacheEntries);
}

// Too slow in debug mode. Also avoid the sanitizers and simulators for similar
// reasons. Any core issues will likely be found by SomeInstantiations.
#if !defined(DEBUG) && !defined(USING_MEMORY_SANITIZER) &&                     \
    !defined(USING_THREAD_SANITIZER) && !defined(USING_LEAK_SANITIZER) &&      \
    !defined(USING_UNDEFINED_BEHAVIOR_SANITIZER) &&                            \
    !defined(DART_INCLUDE_SIMULATOR)
TEST_CASE(TypeArguments_Cache_ManyInstantiations) {
  const intptr_t kNumClasses = 100000;
  static_assert(kNumClasses > TypeArguments::Cache::kMaxLinearCacheEntries,
                "too few classes to trigger change to a hash-based cache");
  TypeArgumentsHashCacheTest(thread, kNumClasses);
}
#endif

#undef EXPECT_TYPES_SYNTACTICALLY_EQUIVALENT

static void SubtypeTestCacheCheckContents(Zone* zone,
                                          const SubtypeTestCache& cache) {
  const intptr_t used_inputs = cache.num_inputs();
  if (used_inputs < 1 || used_inputs > SubtypeTestCache::kMaxInputs) {
    FAIL("Invalid number of used inputs: %" Pd "", used_inputs);
    return;
  }
  const auto& array = Array::Handle(zone, cache.cache());
  for (intptr_t i = 0; i < cache.NumEntries(); i++) {
    if (!cache.IsOccupied(i)) continue;
    const intptr_t entry_start = i * SubtypeTestCache::kTestEntryLength;
    {
      const intptr_t cid =
          array.At(entry_start + SubtypeTestCache::kTestResult)->GetClassId();
      EXPECT(cid == kNullCid || cid == kBoolCid);
    }

    // Used to make sure all the cases are in the correct order below.
    int check_ordering = used_inputs;
    // Input: the value of SubtypeTestCache::Entries for this input
    // ExpectedCids is an expression where [cid] is bound to the contents cid.
#define USED_INPUT_CASE(Input, ExpectedCids)                                   \
  case (Input) + 1: {                                                          \
    RELEASE_ASSERT((Input) + 1 == check_ordering);                             \
    const intptr_t cid = array.At(entry_start + (Input))->GetClassId();        \
    if (!(ExpectedCids)) {                                                     \
      FAIL("expected: " #ExpectedCids ", got: cid %" Pd "", cid);              \
    }                                                                          \
    --check_ordering;                                                          \
  }

    switch (used_inputs) {
      USED_INPUT_CASE(SubtypeTestCache::kDestinationType,
                      IsConcreteTypeClassId(cid));
      FALL_THROUGH;
      USED_INPUT_CASE(SubtypeTestCache::kInstanceDelayedFunctionTypeArguments,
                      cid == kNullCid || cid == kTypeArgumentsCid);
      FALL_THROUGH;
      USED_INPUT_CASE(SubtypeTestCache::kInstanceParentFunctionTypeArguments,
                      cid == kNullCid || cid == kTypeArgumentsCid);
      FALL_THROUGH;
      USED_INPUT_CASE(SubtypeTestCache::kFunctionTypeArguments,
                      cid == kNullCid || cid == kTypeArgumentsCid);
      FALL_THROUGH;
      USED_INPUT_CASE(SubtypeTestCache::kInstantiatorTypeArguments,
                      cid == kNullCid || cid == kTypeArgumentsCid);
      FALL_THROUGH;
      USED_INPUT_CASE(SubtypeTestCache::kInstanceTypeArguments,
                      cid == kNullCid || cid == kTypeArgumentsCid);
      FALL_THROUGH;
      USED_INPUT_CASE(SubtypeTestCache::kInstanceCidOrSignature,
                      cid == kSmiCid || cid == kFunctionTypeCid);
      break;
      default:
        UNREACHABLE();
    }

#undef USED_INPUT_CASE
    RELEASE_ASSERT(0 == check_ordering);

    // Check that unused inputs have never been set.
    for (intptr_t i = used_inputs; i < SubtypeTestCache::kMaxInputs; i++) {
      // Since we sometimes use Array::NewUninitialized() for allocations of
      // STCs and never set unused inputs, the only thing we know is that the
      // entry is GC-safe. Since we don't expect valid values for unused inputs,
      // we just check if it's either a Smi or null.
      const intptr_t cid = array.At(entry_start + i)->GetClassId();
      EXPECT(cid == kSmiCid || cid == kNullCid);
    }
  }
}

static void SubtypeTestCacheEntryTest(
    Thread* thread,
    const SubtypeTestCache& cache,
    const Object& instance_class_id_or_signature,
    const AbstractType& destination_type,
    const TypeArguments& instance_type_arguments,
    const TypeArguments& instantiator_type_arguments,
    const TypeArguments& function_type_arguments,
    const TypeArguments& parent_function_type_arguments,
    const TypeArguments& delayed_type_arguments,
    const Bool& expected_result,
    Bool* got_result) {
  const auto& tav_null = TypeArguments::null_type_arguments();
  const intptr_t num_inputs = cache.num_inputs();
  const bool was_hash = cache.IsHash();
  const intptr_t old_count = cache.NumberOfChecks();
  intptr_t expected_index, got_index;

  EXPECT(!cache.HasCheck(
      instance_class_id_or_signature, destination_type, instance_type_arguments,
      instantiator_type_arguments, function_type_arguments,
      parent_function_type_arguments, delayed_type_arguments, /*index=*/nullptr,
      /*result=*/nullptr));
  {
    SafepointMutexLocker ml(
        thread->isolate_group()->subtype_test_cache_mutex());
    expected_index =
        cache.AddCheck(instance_class_id_or_signature, destination_type,
                       instance_type_arguments, instantiator_type_arguments,
                       function_type_arguments, parent_function_type_arguments,
                       delayed_type_arguments, expected_result);
    EXPECT(expected_index >= 0);
  }
  EXPECT_EQ(old_count + 1, cache.NumberOfChecks());
  EXPECT(cache.HasCheck(instance_class_id_or_signature, destination_type,
                        instance_type_arguments, instantiator_type_arguments,
                        function_type_arguments, parent_function_type_arguments,
                        delayed_type_arguments, &got_index, got_result));
  EXPECT_EQ(expected_index, got_index);
  EXPECT(got_result->ptr() == expected_result.ptr());
  if (num_inputs < (SubtypeTestCache::kInstanceTypeArguments + 1)) {
    // Match replacing unused instance type arguments with null.
    EXPECT(cache.HasCheck(instance_class_id_or_signature, destination_type,
                          tav_null, instantiator_type_arguments,
                          function_type_arguments,
                          parent_function_type_arguments,
                          delayed_type_arguments, &got_index, got_result));
    EXPECT_EQ(expected_index, got_index);
    EXPECT(got_result->ptr() == expected_result.ptr());
  } else {
    // No match replacing used instance type arguments with null.
    EXPECT(!cache.HasCheck(
        instance_class_id_or_signature, destination_type, tav_null,
        instantiator_type_arguments, function_type_arguments,
        parent_function_type_arguments, delayed_type_arguments,
        /*index=*/nullptr, /*result=*/nullptr));
  }
  if (num_inputs < (SubtypeTestCache::kInstantiatorTypeArguments + 1)) {
    // Match replacing unused instantiator type arguments with null.
    EXPECT(cache.HasCheck(instance_class_id_or_signature, destination_type,
                          instance_type_arguments, tav_null,
                          function_type_arguments,
                          parent_function_type_arguments,
                          delayed_type_arguments, &got_index, got_result));
    EXPECT_EQ(expected_index, got_index);
    EXPECT(got_result->ptr() == expected_result.ptr());
  } else {
    // No match replacing used instantiator type arguments with null.
    EXPECT(!cache.HasCheck(
        instance_class_id_or_signature, destination_type,
        instance_type_arguments, tav_null, function_type_arguments,
        parent_function_type_arguments, delayed_type_arguments,
        /*index=*/nullptr, /*result=*/nullptr));
  }
  if (num_inputs < (SubtypeTestCache::kFunctionTypeArguments + 1)) {
    // Match replacing unused function type arguments with null.
    EXPECT(cache.HasCheck(instance_class_id_or_signature, destination_type,
                          instance_type_arguments, instantiator_type_arguments,
                          tav_null, parent_function_type_arguments,
                          delayed_type_arguments, &got_index, got_result));
    EXPECT_EQ(expected_index, got_index);
    EXPECT(got_result->ptr() == expected_result.ptr());
  } else {
    // No match replacing used function type arguments with null.
    EXPECT(!cache.HasCheck(instance_class_id_or_signature, destination_type,
                           instance_type_arguments, instantiator_type_arguments,
                           tav_null, parent_function_type_arguments,
                           delayed_type_arguments,
                           /*index=*/nullptr, /*result=*/nullptr));
  }
  if (num_inputs <
      (SubtypeTestCache::kInstanceParentFunctionTypeArguments + 1)) {
    // Match replacing unused parent function type arguments with null.
    EXPECT(cache.HasCheck(instance_class_id_or_signature, destination_type,
                          instance_type_arguments, instantiator_type_arguments,
                          function_type_arguments, tav_null,
                          delayed_type_arguments, &got_index, got_result));
    EXPECT_EQ(expected_index, got_index);
    EXPECT(got_result->ptr() == expected_result.ptr());
  } else {
    // No match replacing used parent function type arguments with null.
    EXPECT(!cache.HasCheck(instance_class_id_or_signature, destination_type,
                           instance_type_arguments, instantiator_type_arguments,
                           function_type_arguments, tav_null,
                           delayed_type_arguments, /*index=*/nullptr,
                           /*result=*/nullptr));
  }
  if (num_inputs <
      (SubtypeTestCache::kInstanceDelayedFunctionTypeArguments + 1)) {
    // Match replacing unused delayed type arguments with null.
    EXPECT(cache.HasCheck(instance_class_id_or_signature, destination_type,
                          instance_type_arguments, instantiator_type_arguments,
                          function_type_arguments,
                          parent_function_type_arguments, tav_null, &got_index,
                          got_result));
    EXPECT_EQ(expected_index, got_index);
    EXPECT(got_result->ptr() == expected_result.ptr());
  } else {
    // No match replacing used delayed type arguments with null.
    EXPECT(!cache.HasCheck(instance_class_id_or_signature, destination_type,
                           instance_type_arguments, instantiator_type_arguments,
                           function_type_arguments,
                           parent_function_type_arguments, tav_null,
                           /*index=*/nullptr, /*result=*/nullptr));
  }
  // Make sure we're not accidentally using the same type as the input below.
  RELEASE_ASSERT(destination_type.ptr() != Type::VoidType());
  if (num_inputs < (SubtypeTestCache::kDestinationType + 1)) {
    // Match replacing unused destination type argument with the null type.
    EXPECT(cache.HasCheck(instance_class_id_or_signature, Object::void_type(),
                          instance_type_arguments, instantiator_type_arguments,
                          function_type_arguments,
                          parent_function_type_arguments,
                          delayed_type_arguments, &got_index, got_result));
    EXPECT_EQ(expected_index, got_index);
    EXPECT(got_result->ptr() == expected_result.ptr());
  } else {
    // No match replacing used destination type argument with the null type.
    EXPECT(!cache.HasCheck(instance_class_id_or_signature, Object::void_type(),
                           instance_type_arguments, instantiator_type_arguments,
                           function_type_arguments,
                           parent_function_type_arguments,
                           delayed_type_arguments,
                           /*index=*/nullptr, /*result=*/nullptr));
  }
  // Once hash-based, should stay a hash-based cache.
  EXPECT(!was_hash || cache.IsHash());
}

static void SubtypeTestCacheTest(Thread* thread,
                                 intptr_t num_classes,
                                 bool expect_hash) {
  TextBuffer buffer(MB);
  buffer.AddString(R"(
    class D {}

    @pragma('vm:entry-point', 'call')
    D createInstanceD() => D();

    @pragma('vm:entry-point', 'call')
    D Function() createClosureD() => () => D();
    )");
  for (intptr_t i = 0; i < num_classes; i++) {
    buffer.Printf(R"(class C%)" Pd R"( extends D {}
)"
                  "@pragma('vm:entry-point', 'call')\n"
                  R"(C%)" Pd R"( createInstanceC%)" Pd R"(() => C%)" Pd
                  R"(();
)"
                  "@pragma('vm:entry-point', 'call')\n"
                  R"(C%)" Pd R"( Function() createClosureC%)" Pd
                  R"(() => () => C%)" Pd
                  R"(();
)",
                  i, i, i, i, i, i, i);
  }

  Dart_Handle api_lib = TestCase::LoadTestScript(buffer.buffer(), nullptr);
  EXPECT_VALID(api_lib);

  // D + C0...CN, where N = kNumClasses - 1
  EXPECT(IsolateGroup::Current()->class_table()->NumCids() > num_classes);

  TransitionNativeToVM transition(thread);
  Zone* const zone = thread->zone();

  const auto& root_lib =
      Library::CheckedHandle(zone, Api::UnwrapHandle(api_lib));
  EXPECT(!root_lib.IsNull());

  const auto& class_d = Class::Handle(zone, GetClass(root_lib, "D"));
  ASSERT(!class_d.IsNull());
  {
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
    ClassFinalizer::FinalizeClass(class_d);
  }
  const auto& instance_d =
      Instance::CheckedHandle(zone, Invoke(root_lib, "createInstanceD"));
  auto& type_instance_d_int =
      Type::CheckedHandle(zone, instance_d.GetType(Heap::kNew));
  const auto& closure_d =
      Instance::CheckedHandle(zone, Invoke(root_lib, "createClosureD"));
  ASSERT(!closure_d.IsNull());
  auto& type_closure_d_int =
      FunctionType::CheckedHandle(zone, closure_d.GetType(Heap::kNew));

  // Test all the possible input values.
  const SubtypeTestCache* stcs[SubtypeTestCache::kMaxInputs];
  for (intptr_t i = 0; i < SubtypeTestCache::kMaxInputs; i++) {
    stcs[i] = &SubtypeTestCache::Handle(zone, SubtypeTestCache::New(i + 1));
  }

  auto& class_c = Class::Handle(zone);
  auto& instance_c = Instance::Handle(zone);
  auto& closure_c = Closure::Handle(zone);
  auto& instance_class_id_or_signature = Object::Handle(zone);
  // Set up unique tavs for each of the TAV inputs.
  auto& instance_type_arguments =
      TypeArguments::Handle(zone, TypeArguments::New(1));
  instance_type_arguments.SetTypeAt(0, Type::Handle(zone, Type::SmiType()));
  instance_type_arguments = instance_type_arguments.Canonicalize(thread);
  auto& instantiator_type_arguments =
      TypeArguments::Handle(zone, TypeArguments::New(1));
  instantiator_type_arguments.SetTypeAt(0, Type::Handle(zone, Type::IntType()));
  instantiator_type_arguments =
      instantiator_type_arguments.Canonicalize(thread);
  auto& function_type_arguments =
      TypeArguments::Handle(zone, TypeArguments::New(1));
  function_type_arguments.SetTypeAt(0, Type::Handle(zone, Type::Double()));
  function_type_arguments = function_type_arguments.Canonicalize(thread);
  auto& parent_function_type_arguments =
      TypeArguments::Handle(zone, TypeArguments::New(1));
  parent_function_type_arguments.SetTypeAt(
      0, Type::Handle(zone, Type::StringType()));
  parent_function_type_arguments =
      parent_function_type_arguments.Canonicalize(thread);
  auto& delayed_type_arguments =
      TypeArguments::Handle(zone, TypeArguments::New(1));
  delayed_type_arguments.SetTypeAt(0, Type::Handle(zone, Type::BoolType()));
  delayed_type_arguments = delayed_type_arguments.Canonicalize(thread);
  auto& got_result = Bool::Handle(zone);
  for (intptr_t i = 0; i < num_classes; ++i) {
    // Just so we're testing both true and false values, as we're not actually
    // using the results to determine subtype/assignability.
    const auto& expected_result = (i % 2 == 0) ? Bool::True() : Bool::False();

    auto const class_name = OS::SCreate(zone, "C%" Pd "", i);
    class_c = GetClass(root_lib, class_name);
    ASSERT(!class_c.IsNull());
    {
      SafepointWriteRwLocker ml(thread,
                                thread->isolate_group()->program_lock());
      ClassFinalizer::FinalizeClass(class_c);
    }
    auto const instance_name = OS::SCreate(zone, "createInstanceC%" Pd "", i);
    instance_c ^= Invoke(root_lib, instance_name);
    EXPECT(!instance_c.IsClosure());
    instance_class_id_or_signature = Smi::New(instance_c.GetClassId());

    for (intptr_t i = 0; i < 5; i++) {
      SubtypeTestCacheEntryTest(
          thread, *stcs[i], instance_class_id_or_signature, type_instance_d_int,
          instance_type_arguments, instantiator_type_arguments,
          function_type_arguments, parent_function_type_arguments,
          delayed_type_arguments, expected_result, &got_result);
    }

    auto const function_name = OS::SCreate(zone, "createClosureC%" Pd "", i);
    closure_c ^= Invoke(root_lib, function_name);

    instance_class_id_or_signature = closure_c.function();
    instance_class_id_or_signature =
        Function::Cast(instance_class_id_or_signature).signature();

    for (intptr_t i = 5; i < SubtypeTestCache::kMaxInputs; i++) {
      SubtypeTestCacheEntryTest(
          thread, *stcs[i], instance_class_id_or_signature, type_closure_d_int,
          instance_type_arguments, instantiator_type_arguments,
          function_type_arguments, parent_function_type_arguments,
          delayed_type_arguments, expected_result, &got_result);
    }
  }
  for (intptr_t i = 0; i < SubtypeTestCache::kMaxInputs; i++) {
    SubtypeTestCacheCheckContents(zone, *stcs[i]);
    EXPECT_EQ(expect_hash, stcs[i]->IsHash());
  }
}

TEST_CASE(STC_LinearLookup) {
  SubtypeTestCacheTest(thread, SubtypeTestCache::kMaxLinearCacheEntries,
                       /*expect_hash=*/false);
}

TEST_CASE(STC_HashLookup) {
  SubtypeTestCacheTest(thread, 2 * SubtypeTestCache::kMaxLinearCacheEntries,
                       /*expect_hash=*/true);
}

}  // namespace dart