@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/re2/re2/testing/exhaustive3_test.cc

@@ -1,100 +0,0 @@
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Exhaustive testing of regular expression matching.
-
-#include <stddef.h>
-
-#include <string>
-#include <vector>
-
-#include "gtest/gtest.h"
-#include "re2/testing/exhaustive_tester.h"
-#include "re2/testing/regexp_generator.h"
-#include "util/utf.h"
-
-namespace re2 {
-
-// Test simple character classes by themselves.
-TEST(CharacterClasses, Exhaustive) {
-  std::vector<std::string> atoms = Split(" ",
-    "[a] [b] [ab] [^bc] [b-d] [^b-d] []a] [-a] [a-] [^-a] [a-b-c] a b .");
-  ExhaustiveTest(2, 1, atoms, RegexpGenerator::EgrepOps(),
-                 5, Explode("ab"), "", "");
-}
-
-// Test simple character classes inside a___b (for example, a[a]b).
-TEST(CharacterClasses, ExhaustiveAB) {
-  std::vector<std::string> atoms = Split(" ",
-    "[a] [b] [ab] [^bc] [b-d] [^b-d] []a] [-a] [a-] [^-a] [a-b-c] a b .");
-  ExhaustiveTest(2, 1, atoms, RegexpGenerator::EgrepOps(),
-                 5, Explode("ab"), "a%sb", "");
-}
-
-// Returns UTF8 for Rune r
-static std::string UTF8(Rune r) {
-  char buf[UTFmax+1];
-  buf[runetochar(buf, &r)] = 0;
-  return std::string(buf);
-}
-
-// Returns a vector of "interesting" UTF8 characters.
-// Unicode is now too big to just return all of them,
-// so UTF8Characters return a set likely to be good test cases.
-static const std::vector<std::string>& InterestingUTF8() {
-  static bool init;
-  static std::vector<std::string> v;
-
-  if (init)
-    return v;
-
-  init = true;
-  // All the Latin1 equivalents are interesting.
-  for (int i = 1; i < 256; i++)
-    v.push_back(UTF8(i));
-
-  // After that, the codes near bit boundaries are
-  // interesting, because they span byte sequence lengths.
-  for (int j = 0; j < 8; j++)
-    v.push_back(UTF8(256 + j));
-  for (int i = 512; i < Runemax; i <<= 1)
-    for (int j = -8; j < 8; j++)
-      v.push_back(UTF8(i + j));
-
-  // The codes near Runemax, including Runemax itself, are interesting.
-  for (int j = -8; j <= 0; j++)
-    v.push_back(UTF8(Runemax + j));
-
-  return v;
-}
-
-// Test interesting UTF-8 characters against character classes.
-TEST(InterestingUTF8, SingleOps) {
-  std::vector<std::string> atoms = Split(" ",
-    ". ^ $ \\a \\f \\n \\r \\t \\v \\d \\D \\s \\S \\w \\W \\b \\B "
-    "[[:alnum:]] [[:alpha:]] [[:blank:]] [[:cntrl:]] [[:digit:]] "
-    "[[:graph:]] [[:lower:]] [[:print:]] [[:punct:]] [[:space:]] "
-    "[[:upper:]] [[:xdigit:]] [\\s\\S] [\\d\\D] [^\\w\\W] [^\\d\\D]");
-  std::vector<std::string> ops;  // no ops
-  ExhaustiveTest(1, 0, atoms, ops,
-                 1, InterestingUTF8(), "", "");
-}
-
-// Test interesting UTF-8 characters against character classes,
-// but wrap everything inside AB.
-TEST(InterestingUTF8, AB) {
-  std::vector<std::string> atoms = Split(" ",
-    ". ^ $ \\a \\f \\n \\r \\t \\v \\d \\D \\s \\S \\w \\W \\b \\B "
-    "[[:alnum:]] [[:alpha:]] [[:blank:]] [[:cntrl:]] [[:digit:]] "
-    "[[:graph:]] [[:lower:]] [[:print:]] [[:punct:]] [[:space:]] "
-    "[[:upper:]] [[:xdigit:]] [\\s\\S] [\\d\\D] [^\\w\\W] [^\\d\\D]");
-  std::vector<std::string> ops;  // no ops
-  std::vector<std::string> alpha = InterestingUTF8();
-  for (size_t i = 0; i < alpha.size(); i++)
-    alpha[i] = "a" + alpha[i] + "b";
-  ExhaustiveTest(1, 0, atoms, ops,
-                 1, alpha, "a%sb", "");
-}
-
-}  // namespace re2

package/deps/re2/re2/testing/exhaustive_test.cc

@@ -1,35 +0,0 @@
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Exhaustive testing of regular expression matching.
-
-#include "gtest/gtest.h"
-#include "re2/testing/exhaustive_tester.h"
-
-namespace re2 {
-
-// Test very simple expressions.
-TEST(EgrepLiterals, Lowercase) {
-  EgrepTest(3, 2, "abc.", 3, "abc", "");
-}
-
-// Test mixed-case expressions.
-TEST(EgrepLiterals, MixedCase) {
-  EgrepTest(3, 2, "AaBb.", 2, "AaBb", "");
-}
-
-// Test mixed-case in case-insensitive mode.
-TEST(EgrepLiterals, FoldCase) {
-  // The punctuation characters surround A-Z and a-z
-  // in the ASCII table.  This looks for bugs in the
-  // bytemap range code in the DFA.
-  EgrepTest(3, 2, "abAB.", 2, "aBc@_~", "(?i:%s)");
-}
-
-// Test very simple expressions.
-TEST(EgrepLiterals, UTF8) {
-  EgrepTest(3, 2, "ab.", 4, "a\xE2\x98\xBA", "");
-}
-
-}  // namespace re2

package/deps/re2/re2/testing/exhaustive_tester.cc

@@ -1,204 +0,0 @@
-// Copyright 2008 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Exhaustive testing of regular expression matching.
-
-// Each test picks an alphabet (e.g., "abc"), a maximum string length,
-// a maximum regular expression length, and a maximum number of letters
-// that can appear in the regular expression.  Given these parameters,
-// it tries every possible regular expression and string, verifying that
-// the NFA, DFA, and a trivial backtracking implementation agree about
-// the location of the match.
-
-#include "re2/testing/exhaustive_tester.h"
-
-#include <stdio.h>
-
-#include <string>
-#include <vector>
-
-#include "absl/base/macros.h"
-#include "absl/flags/flag.h"
-#include "absl/log/absl_check.h"
-#include "absl/log/absl_log.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
-#include "gtest/gtest.h"
-#include "re2/prog.h"
-#include "re2/re2.h"
-#include "re2/testing/regexp_generator.h"
-#include "re2/testing/tester.h"
-
-// For target `log' in the Makefile.
-#ifndef LOGGING
-#define LOGGING 0
-#endif
-
-ABSL_FLAG(bool, show_regexps, false, "show regexps during testing");
-
-ABSL_FLAG(int, max_bad_regexp_inputs, 1,
-          "Stop testing a regular expression after finding this many "
-          "strings that break it.");
-
-namespace re2 {
-
-static char* escape(absl::string_view sp) {
-  static char buf[512];
-  char* p = buf;
-  *p++ = '\"';
-  for (size_t i = 0; i < sp.size(); i++) {
-    if(p+5 >= buf+sizeof buf)
-      ABSL_LOG(FATAL) << "ExhaustiveTester escape: too long";
-    if(sp[i] == '\\' || sp[i] == '\"') {
-      *p++ = '\\';
-      *p++ = sp[i];
-    } else if(sp[i] == '\n') {
-      *p++ = '\\';
-      *p++ = 'n';
-    } else {
-      *p++ = sp[i];
-    }
-  }
-  *p++ = '\"';
-  *p = '\0';
-  return buf;
-}
-
-static void PrintResult(const RE2& re, absl::string_view input,
-                        RE2::Anchor anchor, absl::string_view* m, int n) {
-  if (!re.Match(input, 0, input.size(), anchor, m, n)) {
-    absl::PrintF("-");
-    return;
-  }
-  for (int i = 0; i < n; i++) {
-    if (i > 0)
-      absl::PrintF(" ");
-    if (m[i].data() == NULL)
-      absl::PrintF("-");
-    else
-      absl::PrintF("%d-%d",
-                   BeginPtr(m[i]) - BeginPtr(input),
-                   EndPtr(m[i]) - BeginPtr(input));
-  }
-}
-
-// Processes a single generated regexp.
-// Compiles it using Regexp interface and PCRE, and then
-// checks that NFA, DFA, and PCRE all return the same results.
-void ExhaustiveTester::HandleRegexp(const std::string& const_regexp) {
-  regexps_++;
-  std::string regexp = const_regexp;
-  if (!topwrapper_.empty()) {
-    auto fmt = absl::ParsedFormat<'s'>::New(topwrapper_);
-    ABSL_CHECK(fmt != nullptr);
-    regexp = absl::StrFormat(*fmt, regexp);
-  }
-
-  if (absl::GetFlag(FLAGS_show_regexps)) {
-    absl::PrintF("\r%s", regexp);
-    fflush(stdout);
-  }
-
-  if (LOGGING) {
-    // Write out test cases and answers for use in testing
-    // other implementations, such as Go's regexp package.
-    if (randomstrings_)
-      ABSL_LOG(ERROR) << "Cannot log with random strings.";
-    if (regexps_ == 1) {  // first
-      absl::PrintF("strings\n");
-      strgen_.Reset();
-      while (strgen_.HasNext())
-        absl::PrintF("%s\n", escape(strgen_.Next()));
-      absl::PrintF("regexps\n");
-    }
-    absl::PrintF("%s\n", escape(regexp));
-
-    RE2 re(regexp);
-    RE2::Options longest;
-    longest.set_longest_match(true);
-    RE2 relongest(regexp, longest);
-    int ngroup = re.NumberOfCapturingGroups()+1;
-    absl::string_view* group = new absl::string_view[ngroup];
-
-    strgen_.Reset();
-    while (strgen_.HasNext()) {
-      absl::string_view input = strgen_.Next();
-      PrintResult(re, input, RE2::ANCHOR_BOTH, group, ngroup);
-      absl::PrintF(";");
-      PrintResult(re, input, RE2::UNANCHORED, group, ngroup);
-      absl::PrintF(";");
-      PrintResult(relongest, input, RE2::ANCHOR_BOTH, group, ngroup);
-      absl::PrintF(";");
-      PrintResult(relongest, input, RE2::UNANCHORED, group, ngroup);
-      absl::PrintF("\n");
-    }
-    delete[] group;
-    return;
-  }
-
-  Tester tester(regexp);
-  if (tester.error())
-    return;
-
-  strgen_.Reset();
-  strgen_.GenerateNULL();
-  if (randomstrings_)
-    strgen_.Random(stringseed_, stringcount_);
-  int bad_inputs = 0;
-  while (strgen_.HasNext()) {
-    tests_++;
-    if (!tester.TestInput(strgen_.Next())) {
-      failures_++;
-      if (++bad_inputs >= absl::GetFlag(FLAGS_max_bad_regexp_inputs))
-        break;
-    }
-  }
-}
-
-// Runs an exhaustive test on the given parameters.
-void ExhaustiveTest(int maxatoms, int maxops,
-                    const std::vector<std::string>& alphabet,
-                    const std::vector<std::string>& ops,
-                    int maxstrlen,
-                    const std::vector<std::string>& stralphabet,
-                    const std::string& wrapper,
-                    const std::string& topwrapper) {
-  if (RE2_DEBUG_MODE) {
-    if (maxatoms > 1)
-      maxatoms--;
-    if (maxops > 1)
-      maxops--;
-    if (maxstrlen > 1)
-      maxstrlen--;
-  }
-  ExhaustiveTester t(maxatoms, maxops, alphabet, ops,
-                     maxstrlen, stralphabet, wrapper,
-                     topwrapper);
-  t.Generate();
-  if (!LOGGING) {
-    absl::PrintF("%d regexps, %d tests, %d failures [%d/%d str]\n",
-                 t.regexps(), t.tests(), t.failures(), maxstrlen, stralphabet.size());
-  }
-  EXPECT_EQ(0, t.failures());
-}
-
-// Runs an exhaustive test using the given parameters and
-// the basic egrep operators.
-void EgrepTest(int maxatoms, int maxops, const std::string& alphabet,
-               int maxstrlen, const std::string& stralphabet,
-               const std::string& wrapper) {
-  const char* tops[] = { "", "^(?:%s)", "(?:%s)$", "^(?:%s)$" };
-
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(tops); i++) {
-    ExhaustiveTest(maxatoms, maxops,
-                   Split("", alphabet),
-                   RegexpGenerator::EgrepOps(),
-                   maxstrlen,
-                   Split("", stralphabet),
-                   wrapper,
-                   tops[i]);
-  }
-}
-
-}  // namespace re2

package/deps/re2/re2/testing/exhaustive_tester.h

@@ -1,105 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_TESTING_EXHAUSTIVE_TESTER_H_
-#define RE2_TESTING_EXHAUSTIVE_TESTER_H_
-
-#include <stdint.h>
-
-#include <string>
-#include <vector>
-
-#include "re2/testing/regexp_generator.h"
-#include "re2/testing/string_generator.h"
-
-namespace re2 {
-
-// Doing this simplifies the logic below.
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#if !defined(NDEBUG)
-// We are in a debug build.
-const bool RE2_DEBUG_MODE = true;
-#elif __has_feature(address_sanitizer) || __has_feature(memory_sanitizer) || __has_feature(thread_sanitizer)
-// Not a debug build, but still under sanitizers.
-const bool RE2_DEBUG_MODE = true;
-#else
-const bool RE2_DEBUG_MODE = false;
-#endif
-
-// Exhaustive regular expression test: generate all regexps within parameters,
-// then generate all strings of a given length over a given alphabet,
-// then check that NFA, DFA, and PCRE agree about whether each regexp matches
-// each possible string, and if so, where the match is.
-//
-// Can also be used in a "random" mode that generates a given number
-// of random regexp and strings, allowing testing of larger expressions
-// and inputs.
-class ExhaustiveTester : public RegexpGenerator {
- public:
-  ExhaustiveTester(int maxatoms,
-                   int maxops,
-                   const std::vector<std::string>& alphabet,
-                   const std::vector<std::string>& ops,
-                   int maxstrlen,
-                   const std::vector<std::string>& stralphabet,
-                   const std::string& wrapper,
-                   const std::string& topwrapper)
-    : RegexpGenerator(maxatoms, maxops, alphabet, ops),
-      strgen_(maxstrlen, stralphabet),
-      wrapper_(wrapper),
-      topwrapper_(topwrapper),
-      regexps_(0), tests_(0), failures_(0),
-      randomstrings_(0), stringseed_(0), stringcount_(0)  { }
-
-  int regexps()  { return regexps_; }
-  int tests()    { return tests_; }
-  int failures() { return failures_; }
-
-  // Needed for RegexpGenerator interface.
-  void HandleRegexp(const std::string& regexp);
-
-  // Causes testing to generate random input strings.
-  void RandomStrings(int32_t seed, int32_t count) {
-    randomstrings_ = true;
-    stringseed_ = seed;
-    stringcount_ = count;
-  }
-
- private:
-  StringGenerator strgen_;
-  std::string wrapper_;      // Regexp wrapper - either empty or has one %s.
-  std::string topwrapper_;   // Regexp top-level wrapper.
-  int regexps_;   // Number of HandleRegexp calls
-  int tests_;     // Number of regexp tests.
-  int failures_;  // Number of tests failed.
-
-  bool randomstrings_;  // Whether to use random strings
-  int32_t stringseed_;  // If so, the seed.
-  int stringcount_;     // If so, how many to generate.
-
-  ExhaustiveTester(const ExhaustiveTester&) = delete;
-  ExhaustiveTester& operator=(const ExhaustiveTester&) = delete;
-};
-
-// Runs an exhaustive test on the given parameters.
-void ExhaustiveTest(int maxatoms, int maxops,
-                    const std::vector<std::string>& alphabet,
-                    const std::vector<std::string>& ops,
-                    int maxstrlen,
-                    const std::vector<std::string>& stralphabet,
-                    const std::string& wrapper,
-                    const std::string& topwrapper);
-
-// Runs an exhaustive test using the given parameters and
-// the basic egrep operators.
-void EgrepTest(int maxatoms, int maxops, const std::string& alphabet,
-               int maxstrlen, const std::string& stralphabet,
-               const std::string& wrapper);
-
-}  // namespace re2
-
-#endif  // RE2_TESTING_EXHAUSTIVE_TESTER_H_