CSE2410 Fall 2014 Bounce

static bool CheckParse(const char* input) {

  V8::Initialize(NULL);

  RegExpCompileData result;

  return v8::internal::RegExpParser::ParseRegExp(

      &reader, false, &result, &zone);

static SmartArrayPointer<const char> Parse(const char* input) {

  V8::Initialize(NULL);

  RegExpCompileData result;

  CHECK(v8::internal::RegExpParser::ParseRegExp(

      &reader, false, &result, &zone));

static bool CheckSimple(const char* input) {

  V8::Initialize(NULL);

  RegExpCompileData result;

  CHECK(v8::internal::RegExpParser::ParseRegExp(

      &reader, false, &result, &zone));

static MinMaxPair CheckMinMaxMatch(const char* input) {

  V8::Initialize(NULL);

  RegExpCompileData result;

  CHECK(v8::internal::RegExpParser::ParseRegExp(

      &reader, false, &result, &zone));

static void ExpectError(const char* input,

                        const char* expected) {

  V8::Initialize(NULL);

  RegExpCompileData result;

  CHECK(!v8::internal::RegExpParser::ParseRegExp(

      &reader, false, &result, &zone));

TEST(Errors) {

  const char* kEndBackslash = "\\ at end of pattern";

  ExpectError("\\", kEndBackslash);

  const char* kUnterminatedGroup = "Unterminated group";

static void TestCharacterClassEscapes(uc16 c, bool (pred)(uc16 c)) {

  ZoneList<CharacterRange>* ranges =

      new(&zone) ZoneList<CharacterRange>(2, &zone);

  CharacterRange::AddClassEscape(c, ranges, &zone);

                           bool is_ascii,

                           Zone* zone) {

  V8::Initialize(NULL);

  FlatStringReader reader(isolate, CStrVector(input));

  RegExpCompileData compile_data;

  if (!v8::internal::RegExpParser::ParseRegExp(&reader, multiline,

                    bool multiline,

                    bool is_ascii,

                    bool dot_output = false) {

  RegExpNode* node = Compile(input, multiline, is_ascii, &zone);

  USE(node);

#ifdef DEBUG

TEST(SplayTreeSimple) {

  v8::internal::V8::Initialize(NULL);

  static const unsigned kLimit = 1000;

  ZoneSplayTree<TestConfig> tree(&zone);

  bool seen[kLimit];

  for (unsigned i = 0; i < kLimit; i++) seen[i] = false;

    }

  }

  // Enter test data into dispatch table.

  DispatchTable table(&zone);

  for (int i = 0; i < kRangeCount; i++) {

    uc16* range = ranges[i];

class ContextInitializer {

 public:

  ContextInitializer()

    env_->Enter();

  }

  ~ContextInitializer() {

      input_end,

      captures,

      0,

}

TEST(MacroAssemblerNativeSuccess) {

  v8::V8::Initialize();

  ContextInitializer initializer;

  Factory* factory = isolate->factory();

  Zone zone(isolate);

TEST(MacroAssemblerNativeSimple) {

  v8::V8::Initialize();

  ContextInitializer initializer;

  Factory* factory = isolate->factory();

  Zone zone(isolate);

TEST(MacroAssemblerNativeSimpleUC16) {

  v8::V8::Initialize();

  ContextInitializer initializer;

  Factory* factory = isolate->factory();

  Zone zone(isolate);

TEST(MacroAssemblerNativeBacktrack) {

  v8::V8::Initialize();

  ContextInitializer initializer;

  Factory* factory = isolate->factory();

  Zone zone(isolate);

TEST(MacroAssemblerNativeBackReferenceASCII) {

  v8::V8::Initialize();

  ContextInitializer initializer;

  Factory* factory = isolate->factory();

  Zone zone(isolate);

TEST(MacroAssemblerNativeBackReferenceUC16) {

  v8::V8::Initialize();

  ContextInitializer initializer;

  Factory* factory = isolate->factory();

  Zone zone(isolate);

TEST(MacroAssemblernativeAtStart) {

  v8::V8::Initialize();

  ContextInitializer initializer;

  Factory* factory = isolate->factory();

  Zone zone(isolate);

TEST(MacroAssemblerNativeBackRefNoCase) {

  v8::V8::Initialize();

  ContextInitializer initializer;

  Factory* factory = isolate->factory();

  Zone zone(isolate);

TEST(MacroAssemblerNativeRegisters) {

  v8::V8::Initialize();

  ContextInitializer initializer;

  Factory* factory = isolate->factory();

  Zone zone(isolate);

TEST(MacroAssemblerStackOverflow) {

  v8::V8::Initialize();

  ContextInitializer initializer;

  Factory* factory = isolate->factory();

  Zone zone(isolate);

TEST(MacroAssemblerNativeLotsOfRegisters) {

  v8::V8::Initialize();

  ContextInitializer initializer;

  Factory* factory = isolate->factory();

  Zone zone(isolate);

TEST(MacroAssembler) {

  V8::Initialize(NULL);

  byte codes[1024];

  RegExpMacroAssemblerIrregexp m(Vector<byte>(codes, 1024), &zone);

  // ^f(o)o.

  Label start, fail, backtrack;

  m.PopRegister(0);

  m.Fail();

  Factory* factory = isolate->factory();

  HandleScope scope(isolate);

  static const int kLimit = 1000;

  static const int kRangeCount = 16;

  for (int t = 0; t < 10; t++) {

    ZoneList<CharacterRange>* ranges =

        new(&zone) ZoneList<CharacterRange>(kRangeCount, &zone);

    for (int i = 0; i < kRangeCount; i++) {

      CHECK_EQ(is_on, set->Get(0) == false);

    }

  }

  ZoneList<CharacterRange>* ranges =

      new(&zone) ZoneList<CharacterRange>(1, &zone);

  ranges->Add(CharacterRange(0xFFF0, 0xFFFE), &zone);

static void TestRangeCaseIndependence(CharacterRange input,

                                      Vector<CharacterRange> expected) {

  int count = expected.length();

  ZoneList<CharacterRange>* list =

      new(&zone) ZoneList<CharacterRange>(count, &zone);

TEST(CharClassDifference) {

  v8::internal::V8::Initialize(NULL);

  ZoneList<CharacterRange>* base =

      new(&zone) ZoneList<CharacterRange>(1, &zone);

  base->Add(CharacterRange::Everything(), &zone);

TEST(CanonicalizeCharacterSets) {

  v8::internal::V8::Initialize(NULL);

  ZoneList<CharacterRange>* list =

      new(&zone) ZoneList<CharacterRange>(4, &zone);

  CharacterSet set(list);

TEST(CharacterRangeMerge) {

  v8::internal::V8::Initialize(NULL);

  ZoneList<CharacterRange> l1(4, &zone);

  ZoneList<CharacterRange> l2(4, &zone);

  // Create all combinations of intersections of ranges, both singletons and