// -*- coding: utf-8 -*-

//

// Copyright (c) 2005 - 2006, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// Author: Sanjay Ghemawat

//

// TODO: Test extractions for PartialMatch/Consume

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdio.h>

#include <cassert>

#include <vector>

#include "pcrecpp.h"

using pcrecpp::StringPiece;

using pcrecpp::RE;

using pcrecpp::RE_Options;

using pcrecpp::Hex;

using pcrecpp::Octal;

using pcrecpp::CRadix;

static bool VERBOSE_TEST  = false;

// CHECK dies with a fatal error if condition is not true.  It is *not*

// controlled by NDEBUG, so the check will be executed regardless of

// compilation mode.  Therefore, it is safe to do things like:

//    CHECK_EQ(fp->Write(x), 4)

#define CHECK(condition) do {                           \

  if (!(condition)) {                                   \

    fprintf(stderr, "%s:%d: Check failed: %s\n",        \

            __FILE__, __LINE__, #condition);            \

    exit(1);                                            \

  }                                                     \

} while (0)

#define CHECK_EQ(a, b)   CHECK(a == b)

static void Timing1(int num_iters) {

  // Same pattern lots of times

  RE pattern("ruby:\\d+");

  StringPiece p("ruby:1234");

  for (int j = num_iters; j > 0; j--) {

    CHECK(pattern.FullMatch(p));

  }

}

static void Timing2(int num_iters) {

  // Same pattern lots of times

  RE pattern("ruby:(\\d+)");

  int i;

  for (int j = num_iters; j > 0; j--) {

    CHECK(pattern.FullMatch("ruby:1234", &i));

    CHECK_EQ(i, 1234);

  }

}

static void Timing3(int num_iters) {

  string text_string;

  for (int j = num_iters; j > 0; j--) {

    text_string += "this is another line\n";

  }

  RE line_matcher(".*\n");

  string line;

  StringPiece text(text_string);

  int counter = 0;

  while (line_matcher.Consume(&text)) {

    counter++;

  }

  printf("Matched %d lines\n", counter);

}

#if 0  // uncomment this if you have a way of defining VirtualProcessSize()

static void LeakTest() {

  // Check for memory leaks

  unsigned long long initial_size = 0;

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

    if (i == 50000) {

      initial_size = VirtualProcessSize();

      printf("Size after 50000: %llu\n", initial_size);

    }

    char buf[100];  // definitely big enough

    sprintf(buf, "pat%09d", i);

    RE newre(buf);

  }

  uint64 final_size = VirtualProcessSize();

  printf("Size after 100000: %llu\n", final_size);

  const double growth = double(final_size - initial_size) / final_size;

  printf("Growth: %0.2f%%", growth * 100);

  CHECK(growth < 0.02);       // Allow < 2% growth

}

#endif

static void RadixTests() {

  printf("Testing hex\n");

#define CHECK_HEX(type, value) \

  do { \

    type v; \

    CHECK(RE("([0-9a-fA-F]+)[uUlL]*").FullMatch(#value, Hex(&v))); \

    CHECK_EQ(v, 0x ## value); \

    CHECK(RE("([0-9a-fA-FxX]+)[uUlL]*").FullMatch("0x" #value, CRadix(&v))); \

    CHECK_EQ(v, 0x ## value); \

  } while(0)

  CHECK_HEX(short,              2bad);

  CHECK_HEX(unsigned short,     2badU);

  CHECK_HEX(int,                dead);

  CHECK_HEX(unsigned int,       deadU);

  CHECK_HEX(long,               7eadbeefL);

  CHECK_HEX(unsigned long,      deadbeefUL);

#ifdef HAVE_LONG_LONG

  CHECK_HEX(long long,          12345678deadbeefLL);

#endif

#ifdef HAVE_UNSIGNED_LONG_LONG

  CHECK_HEX(unsigned long long, cafebabedeadbeefULL);

#endif

#undef CHECK_HEX

  printf("Testing octal\n");

#define CHECK_OCTAL(type, value) \

  do { \

    type v; \

    CHECK(RE("([0-7]+)[uUlL]*").FullMatch(#value, Octal(&v))); \

    CHECK_EQ(v, 0 ## value); \

    CHECK(RE("([0-9a-fA-FxX]+)[uUlL]*").FullMatch("0" #value, CRadix(&v))); \

    CHECK_EQ(v, 0 ## value); \

  } while(0)

  CHECK_OCTAL(short,              77777);

  CHECK_OCTAL(unsigned short,     177777U);

  CHECK_OCTAL(int,                17777777777);

  CHECK_OCTAL(unsigned int,       37777777777U);

  CHECK_OCTAL(long,               17777777777L);

  CHECK_OCTAL(unsigned long,      37777777777UL);

#ifdef HAVE_LONG_LONG

  CHECK_OCTAL(long long,          777777777777777777777LL);

#endif

#ifdef HAVE_UNSIGNED_LONG_LONG

  CHECK_OCTAL(unsigned long long, 1777777777777777777777ULL);

#endif

#undef CHECK_OCTAL

  printf("Testing decimal\n");

#define CHECK_DECIMAL(type, value) \

  do { \

    type v; \

    CHECK(RE("(-?[0-9]+)[uUlL]*").FullMatch(#value, &v)); \

    CHECK_EQ(v, value); \

    CHECK(RE("(-?[0-9a-fA-FxX]+)[uUlL]*").FullMatch(#value, CRadix(&v))); \

    CHECK_EQ(v, value); \

  } while(0)

  CHECK_DECIMAL(short,              -1);

  CHECK_DECIMAL(unsigned short,     9999);

  CHECK_DECIMAL(int,                -1000);

  CHECK_DECIMAL(unsigned int,       12345U);

  CHECK_DECIMAL(long,               -10000000L);

  CHECK_DECIMAL(unsigned long,      3083324652U);

#ifdef HAVE_LONG_LONG

  CHECK_DECIMAL(long long,          -100000000000000LL);

#endif

#ifdef HAVE_UNSIGNED_LONG_LONG

  CHECK_DECIMAL(unsigned long long, 1234567890987654321ULL);

#endif

#undef CHECK_DECIMAL

}

static void TestReplace() {

  printf("Testing Replace\n");

  struct ReplaceTest {

    const char *regexp;

    const char *rewrite;

    const char *original;

    const char *single;

    const char *global;

    int global_count;         // the expected return value from ReplaceAll

  };

  static const ReplaceTest tests[] = {

    { "(qu|[b-df-hj-np-tv-z]*)([a-z]+)",

      "\\2\\1ay",

      "the quick brown fox jumps over the lazy dogs.",

      "ethay quick brown fox jumps over the lazy dogs.",

      "ethay ickquay ownbray oxfay umpsjay overay ethay azylay ogsday.",

      9 },

    { "\\w+",

      "\\0-NOSPAM",

      "paul.haahr@google.com",

      "paul-NOSPAM.haahr@google.com",

      "paul-NOSPAM.haahr-NOSPAM@google-NOSPAM.com-NOSPAM",

      4 },

    { "^",

      "(START)",

      "foo",

      "(START)foo",

      "(START)foo",

      1 },

    { "^",

      "(START)",

      "",

      "(START)",

      "(START)",

      1 },

    { "$",

      "(END)",

      "",

      "(END)",

      "(END)",

      1 },

    { "b",

      "bb",

      "ababababab",

      "abbabababab",

      "abbabbabbabbabb",

       5 },

    { "b",

      "bb",

      "bbbbbb",

      "bbbbbbb",

      "bbbbbbbbbbbb",

      6 },

    { "b+",

      "bb",

      "bbbbbb",

      "bb",

      "bb",

      1 },

    { "b*",

      "bb",

      "bbbbbb",

      "bb",

      "bb",

      1 },

    { "b*",

      "bb",

      "aaaaa",

      "bbaaaaa",

      "bbabbabbabbabbabb",

      6 },

    { "b*",

      "bb",

      "aa\naa\n",

      "bbaa\naa\n",

      "bbabbabb\nbbabbabb\nbb",

      7 },

    { "b*",

      "bb",

      "aa\raa\r",

      "bbaa\raa\r",

      "bbabbabb\rbbabbabb\rbb",

      7 },

    { "b*",

      "bb",

      "aa\r\naa\r\n",

      "bbaa\r\naa\r\n",

      "bbabbabb\r\nbbabbabb\r\nbb",

      7 },

#ifdef SUPPORT_UTF8

    { "b*",

      "bb",

      "\xE3\x83\x9B\xE3\x83\xBC\xE3\x83\xA0\xE3\x81\xB8",   // utf8

      "bb\xE3\x83\x9B\xE3\x83\xBC\xE3\x83\xA0\xE3\x81\xB8",

      "bb\xE3\x83\x9B""bb""\xE3\x83\xBC""bb""\xE3\x83\xA0""bb""\xE3\x81\xB8""bb",

      5 },

    { "b*",

      "bb",

      "\xE3\x83\x9B\r\n\xE3\x83\xBC\r\xE3\x83\xA0\n\xE3\x81\xB8\r\n",   // utf8

      "bb\xE3\x83\x9B\r\n\xE3\x83\xBC\r\xE3\x83\xA0\n\xE3\x81\xB8\r\n",

      ("bb\xE3\x83\x9B""bb\r\nbb""\xE3\x83\xBC""bb\rbb""\xE3\x83\xA0"

       "bb\nbb""\xE3\x81\xB8""bb\r\nbb"),

      9 },

#endif

    { "", NULL, NULL, NULL, NULL, 0 }

  };

#ifdef SUPPORT_UTF8

  const bool support_utf8 = true;

#else

  const bool support_utf8 = false;

#endif

  for (const ReplaceTest *t = tests; t->original != NULL; ++t) {

    RE re(t->regexp, RE_Options(PCRE_NEWLINE_CRLF).set_utf8(support_utf8));

    assert(re.error().empty());

    string one(t->original);

    CHECK(re.Replace(t->rewrite, &one));

    CHECK_EQ(one, t->single);

    string all(t->original);

    const int replace_count = re.GlobalReplace(t->rewrite, &all);

    CHECK_EQ(all, t->global);

    CHECK_EQ(replace_count, t->global_count);

  }

  // One final test: test \r\n replacement when we're not in CRLF mode

  {

    RE re("b*", RE_Options(PCRE_NEWLINE_CR).set_utf8(support_utf8));

    assert(re.error().empty());

    string all("aa\r\naa\r\n");

    CHECK_EQ(re.GlobalReplace("bb", &all), 9);

    CHECK_EQ(all, string("bbabbabb\rbb\nbbabbabb\rbb\nbb"));

  }

  {

    RE re("b*", RE_Options(PCRE_NEWLINE_LF).set_utf8(support_utf8));

    assert(re.error().empty());

    string all("aa\r\naa\r\n");

    CHECK_EQ(re.GlobalReplace("bb", &all), 9);

    CHECK_EQ(all, string("bbabbabb\rbb\nbbabbabb\rbb\nbb"));

  }

  // TODO: test what happens when no PCRE_NEWLINE_* flag is set.

  //       Alas, the answer depends on how pcre was compiled.

}

static void TestExtract() {

  printf("Testing Extract\n");

  string s;

  CHECK(RE("(.*)@([^.]*)").Extract("\\2!\\1", "boris@kremvax.ru", &s));

  CHECK_EQ(s, "kremvax!boris");

  // check the RE interface as well

  CHECK(RE(".*").Extract("'\\0'", "foo", &s));

  CHECK_EQ(s, "'foo'");

  CHECK(!RE("bar").Extract("'\\0'", "baz", &s));

  CHECK_EQ(s, "'foo'");

}

static void TestConsume() {

  printf("Testing Consume\n");

  string word;

  string s("   aaa b!@#$@#$cccc");

  StringPiece input(s);

  RE r("\\s*(\\w+)");    // matches a word, possibly proceeded by whitespace

  CHECK(r.Consume(&input, &word));

  CHECK_EQ(word, "aaa");

  CHECK(r.Consume(&input, &word));

  CHECK_EQ(word, "b");

  CHECK(! r.Consume(&input, &word));

}

static void TestFindAndConsume() {

  printf("Testing FindAndConsume\n");

  string word;

  string s("   aaa b!@#$@#$cccc");

  StringPiece input(s);

  RE r("(\\w+)");      // matches a word

  CHECK(r.FindAndConsume(&input, &word));

  CHECK_EQ(word, "aaa");

  CHECK(r.FindAndConsume(&input, &word));

  CHECK_EQ(word, "b");

  CHECK(r.FindAndConsume(&input, &word));

  CHECK_EQ(word, "cccc");

  CHECK(! r.FindAndConsume(&input, &word));

}

static void TestMatchNumberPeculiarity() {

  printf("Testing match-number peculiaraity\n");

  string word1;

  string word2;

  string word3;

  RE r("(foo)|(bar)|(baz)");

  CHECK(r.PartialMatch("foo", &word1, &word2, &word3));

  CHECK_EQ(word1, "foo");

  CHECK_EQ(word2, "");

  CHECK_EQ(word3, "");

  CHECK(r.PartialMatch("bar", &word1, &word2, &word3));

  CHECK_EQ(word1, "");

  CHECK_EQ(word2, "bar");

  CHECK_EQ(word3, "");

  CHECK(r.PartialMatch("baz", &word1, &word2, &word3));

  CHECK_EQ(word1, "");

  CHECK_EQ(word2, "");

  CHECK_EQ(word3, "baz");

  CHECK(!r.PartialMatch("f", &word1, &word2, &word3));

  string a;

  CHECK(RE("(foo)|hello").FullMatch("hello", &a));

  CHECK_EQ(a, "");

}

static void TestRecursion() {

  printf("Testing recursion\n");

  // Get one string that passes (sometimes), one that never does.

  string text_good("abcdefghijk");

  string text_bad("acdefghijkl");

  // According to pcretest, matching text_good against (\w+)*b

  // requires match_limit of at least 8192, and match_recursion_limit

  // of at least 37.

  RE_Options options_ml;

  options_ml.set_match_limit(8192);

  RE re("(\\w+)*b", options_ml);

  CHECK(re.PartialMatch(text_good) == true);

  CHECK(re.PartialMatch(text_bad) == false);

  CHECK(re.FullMatch(text_good) == false);

  CHECK(re.FullMatch(text_bad) == false);

  options_ml.set_match_limit(1024);

  RE re2("(\\w+)*b", options_ml);

  CHECK(re2.PartialMatch(text_good) == false);   // because of match_limit

  CHECK(re2.PartialMatch(text_bad) == false);

  CHECK(re2.FullMatch(text_good) == false);

  CHECK(re2.FullMatch(text_bad) == false);

  RE_Options options_mlr;

  options_mlr.set_match_limit_recursion(50);

  RE re3("(\\w+)*b", options_mlr);

  CHECK(re3.PartialMatch(text_good) == true);

  CHECK(re3.PartialMatch(text_bad) == false);

  CHECK(re3.FullMatch(text_good) == false);

  CHECK(re3.FullMatch(text_bad) == false);

  options_mlr.set_match_limit_recursion(10);

  RE re4("(\\w+)*b", options_mlr);

  CHECK(re4.PartialMatch(text_good) == false);

  CHECK(re4.PartialMatch(text_bad) == false);

  CHECK(re4.FullMatch(text_good) == false);

  CHECK(re4.FullMatch(text_bad) == false);

}

// A meta-quoted string, interpreted as a pattern, should always match

// the original unquoted string.

static void TestQuoteMeta(string unquoted, RE_Options options = RE_Options()) {

  string quoted = RE::QuoteMeta(unquoted);

  RE re(quoted, options);

  CHECK(re.FullMatch(unquoted));

}

// A string containing meaningful regexp characters, which is then meta-

// quoted, should not generally match a string the unquoted string does.

static void NegativeTestQuoteMeta(string unquoted, string should_not_match,

                                  RE_Options options = RE_Options()) {

  string quoted = RE::QuoteMeta(unquoted);

  RE re(quoted, options);

  CHECK(!re.FullMatch(should_not_match));

}

// Tests that quoted meta characters match their original strings,

// and that a few things that shouldn't match indeed do not.

static void TestQuotaMetaSimple() {

  TestQuoteMeta("foo");

  TestQuoteMeta("foo.bar");

  TestQuoteMeta("foo\\.bar");

  TestQuoteMeta("[1-9]");

  TestQuoteMeta("1.5-2.0?");

  TestQuoteMeta("\\d");

  TestQuoteMeta("Who doesn't like ice cream?");

  TestQuoteMeta("((a|b)c?d*e+[f-h]i)");

  TestQuoteMeta("((?!)xxx).*yyy");

  TestQuoteMeta("([");

  TestQuoteMeta(string("foo\0bar", 7));

}

static void TestQuoteMetaSimpleNegative() {

  NegativeTestQuoteMeta("foo", "bar");

  NegativeTestQuoteMeta("...", "bar");

  NegativeTestQuoteMeta("\\.", ".");

  NegativeTestQuoteMeta("\\.", "..");

  NegativeTestQuoteMeta("(a)", "a");

  NegativeTestQuoteMeta("(a|b)", "a");

  NegativeTestQuoteMeta("(a|b)", "(a)");

  NegativeTestQuoteMeta("(a|b)", "a|b");

  NegativeTestQuoteMeta("[0-9]", "0");

  NegativeTestQuoteMeta("[0-9]", "0-9");

  NegativeTestQuoteMeta("[0-9]", "[9]");

  NegativeTestQuoteMeta("((?!)xxx)", "xxx");

}

static void TestQuoteMetaLatin1() {

  TestQuoteMeta("3\xb2 = 9");

}

static void TestQuoteMetaUtf8() {

#ifdef SUPPORT_UTF8

  TestQuoteMeta("Pl\xc3\xa1\x63ido Domingo", pcrecpp::UTF8());

  TestQuoteMeta("xyz", pcrecpp::UTF8());            // No fancy utf8

  TestQuoteMeta("\xc2\xb0", pcrecpp::UTF8());       // 2-byte utf8 (degree symbol)

  TestQuoteMeta("27\xc2\xb0 degrees", pcrecpp::UTF8());  // As a middle character

  TestQuoteMeta("\xe2\x80\xb3", pcrecpp::UTF8());   // 3-byte utf8 (double prime)