@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/re2/re2/testing/simplify_test.cc

@@ -1,289 +0,0 @@
-// Copyright 2006 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.
-
-// Test simplify.cc.
-
-#include <string.h>
-
-#include "absl/base/macros.h"
-#include "absl/log/absl_log.h"
-#include "gtest/gtest.h"
-#include "re2/regexp.h"
-
-namespace re2 {
-
-struct Test {
-  const char* regexp;
-  const char* simplified;
-};
-
-static Test tests[] = {
-  // Already-simple constructs
-  { "a", "a" },
-  { "ab", "ab" },
-  { "a|b", "[a-b]" },
-  { "ab|cd", "ab|cd" },
-  { "(ab)*", "(ab)*" },
-  { "(ab)+", "(ab)+" },
-  { "(ab)?", "(ab)?" },
-  { ".", "." },
-  { "^", "^" },
-  { "$", "$" },
-  { "[ac]", "[ac]" },
-  { "[^ac]", "[^ac]" },
-
-  // Posix character classes
-  { "[[:alnum:]]", "[0-9A-Za-z]" },
-  { "[[:alpha:]]", "[A-Za-z]" },
-  { "[[:blank:]]", "[\\t ]" },
-  { "[[:cntrl:]]", "[\\x00-\\x1f\\x7f]" },
-  { "[[:digit:]]", "[0-9]" },
-  { "[[:graph:]]", "[!-~]" },
-  { "[[:lower:]]", "[a-z]" },
-  { "[[:print:]]", "[ -~]" },
-  { "[[:punct:]]", "[!-/:-@\\[-`{-~]" },
-  { "[[:space:]]" , "[\\t-\\r ]" },
-  { "[[:upper:]]", "[A-Z]" },
-  { "[[:xdigit:]]", "[0-9A-Fa-f]" },
-
-  // Perl character classes
-  { "\\d", "[0-9]" },
-  { "\\s", "[\\t-\\n\\f-\\r ]" },
-  { "\\w", "[0-9A-Z_a-z]" },
-  { "\\D", "[^0-9]" },
-  { "\\S", "[^\\t-\\n\\f-\\r ]" },
-  { "\\W", "[^0-9A-Z_a-z]" },
-  { "[\\d]", "[0-9]" },
-  { "[\\s]", "[\\t-\\n\\f-\\r ]" },
-  { "[\\w]", "[0-9A-Z_a-z]" },
-  { "[\\D]", "[^0-9]" },
-  { "[\\S]", "[^\\t-\\n\\f-\\r ]" },
-  { "[\\W]", "[^0-9A-Z_a-z]" },
-
-  // Posix repetitions
-  { "a{1}", "a" },
-  { "a{2}", "aa" },
-  { "a{5}", "aaaaa" },
-  { "a{0,1}", "a?" },
-  // The next three are illegible because Simplify inserts (?:)
-  // parens instead of () parens to avoid creating extra
-  // captured subexpressions.  The comments show a version fewer parens.
-  { "(a){0,2}",                   "(?:(a)(a)?)?"     },  //       (aa?)?
-  { "(a){0,4}",       "(?:(a)(?:(a)(?:(a)(a)?)?)?)?" },  //   (a(a(aa?)?)?)?
-  { "(a){2,6}", "(a)(a)(?:(a)(?:(a)(?:(a)(a)?)?)?)?" },  // aa(a(a(aa?)?)?)?
-  { "a{0,2}",           "(?:aa?)?"     },  //       (aa?)?
-  { "a{0,4}",   "(?:a(?:a(?:aa?)?)?)?" },  //   (a(a(aa?)?)?)?
-  { "a{2,6}", "aa(?:a(?:a(?:aa?)?)?)?" },  // aa(a(a(aa?)?)?)?
-  { "a{0,}", "a*" },
-  { "a{1,}", "a+" },
-  { "a{2,}", "aa+" },
-  { "a{5,}", "aaaaa+" },
-
-  // Test that operators simplify their arguments.
-  // (Simplify used to not simplify arguments to a {} repeat.)
-  { "(?:a{1,}){1,}", "a+" },
-  { "(a{1,}b{1,})", "(a+b+)" },
-  { "a{1,}|b{1,}", "a+|b+" },
-  { "(?:a{1,})*", "(?:a+)*" },
-  { "(?:a{1,})+", "a+" },
-  { "(?:a{1,})?", "(?:a+)?" },
-  { "a{0}", "" },
-
-  // Character class simplification
-  { "[ab]", "[a-b]" },
-  { "[a-za-za-z]", "[a-z]" },
-  { "[A-Za-zA-Za-z]", "[A-Za-z]" },
-  { "[ABCDEFGH]", "[A-H]" },
-  { "[AB-CD-EF-GH]", "[A-H]" },
-  { "[W-ZP-XE-R]", "[E-Z]" },
-  { "[a-ee-gg-m]", "[a-m]" },
-  { "[a-ea-ha-m]", "[a-m]" },
-  { "[a-ma-ha-e]", "[a-m]" },
-  { "[a-zA-Z0-9 -~]", "[ -~]" },
-
-  // Empty character classes
-  { "[^[:cntrl:][:^cntrl:]]", "[^\\x00-\\x{10ffff}]" },
-
-  // Full character classes
-  { "[[:cntrl:][:^cntrl:]]", "." },
-
-  // Unicode case folding.
-  { "(?i)A", "[Aa]" },
-  { "(?i)a", "[Aa]" },
-  { "(?i)K", "[Kk\\x{212a}]" },
-  { "(?i)k", "[Kk\\x{212a}]" },
-  { "(?i)\\x{212a}", "[Kk\\x{212a}]" },
-  { "(?i)[a-z]", "[A-Za-z\\x{17f}\\x{212a}]" },
-  { "(?i)[\\x00-\\x{FFFD}]", "[\\x00-\\x{fffd}]" },
-  { "(?i)[\\x00-\\x{10ffff}]", "." },
-
-  // Empty string as a regular expression.
-  // Empty string must be preserved inside parens in order
-  // to make submatches work right, so these are less
-  // interesting than they used to be.  ToString inserts
-  // explicit (?:) in place of non-parenthesized empty strings,
-  // to make them easier to spot for other parsers.
-  { "(a|b|)", "([a-b]|(?:))" },
-  { "(|)", "((?:)|(?:))" },
-  { "a()", "a()" },
-  { "(()|())", "(()|())" },
-  { "(a|)", "(a|(?:))" },
-  { "ab()cd()", "ab()cd()" },
-  { "()", "()" },
-  { "()*", "()*" },
-  { "()+", "()+" },
-  { "()?" , "()?" },
-  { "(){0}", "" },
-  { "(){1}", "()" },
-  { "(){1,}", "()+" },
-  { "(){0,2}", "(?:()()?)?" },
-
-  // For an empty-width op OR a concatenation or alternation of empty-width
-  // ops, test that the repetition count is capped at 1.
-  { "(?:^){0,}", "^*" },            // x{0,} -> x*
-  { "(?:$){28,}", "$+" },           // x{N,} -> x{1,} -> x+
-  { "(?-m:^){0,30}", "(?-m:^)?" },  // x{0,N} -> x{0,1} -> x?
-  { "(?-m:$){28,30}", "(?-m:$)" },  // x{N,M} -> x{1,1} -> x
-  { "\\b(?:\\b\\B){999}\\B", "\\b\\b\\B\\B" },
-  { "\\b(?:\\b|\\B){999}\\B", "\\b(?:\\b|\\B)\\B" },
-  // NonGreedy should also be handled.
-  { "(?:^){0,}?", "^*?" },
-  { "(?:$){28,}?", "$+?" },
-  { "(?-m:^){0,30}?", "(?-m:^)??" },
-  { "(?-m:$){28,30}?", "(?-m:$)" },
-  { "\\b(?:\\b\\B){999}?\\B", "\\b\\b\\B\\B" },
-  { "\\b(?:\\b|\\B){999}?\\B", "\\b(?:\\b|\\B)\\B" },
-
-  // Test that coalescing occurs and that the resulting repeats are simplified.
-  // Two-op combinations of *, +, ?, {n}, {n,} and {n,m} with a literal:
-  { "a*a*", "a*" },
-  { "a*a+", "a+" },
-  { "a*a?", "a*" },
-  { "a*a{2}", "aa+" },
-  { "a*a{2,}", "aa+" },
-  { "a*a{2,3}", "aa+" },
-  { "a+a*", "a+" },
-  { "a+a+", "aa+" },
-  { "a+a?", "a+" },
-  { "a+a{2}", "aaa+" },
-  { "a+a{2,}", "aaa+" },
-  { "a+a{2,3}", "aaa+" },
-  { "a?a*", "a*" },
-  { "a?a+", "a+" },
-  { "a?a?", "(?:aa?)?" },
-  { "a?a{2}", "aaa?" },
-  { "a?a{2,}", "aa+" },
-  { "a?a{2,3}", "aa(?:aa?)?" },
-  { "a{2}a*", "aa+" },
-  { "a{2}a+", "aaa+" },
-  { "a{2}a?", "aaa?" },
-  { "a{2}a{2}", "aaaa" },
-  { "a{2}a{2,}", "aaaa+" },
-  { "a{2}a{2,3}", "aaaaa?" },
-  { "a{2,}a*", "aa+" },
-  { "a{2,}a+", "aaa+" },
-  { "a{2,}a?", "aa+" },
-  { "a{2,}a{2}", "aaaa+" },
-  { "a{2,}a{2,}", "aaaa+" },
-  { "a{2,}a{2,3}", "aaaa+" },
-  { "a{2,3}a*", "aa+" },
-  { "a{2,3}a+", "aaa+" },
-  { "a{2,3}a?", "aa(?:aa?)?" },
-  { "a{2,3}a{2}", "aaaaa?" },
-  { "a{2,3}a{2,}", "aaaa+" },
-  { "a{2,3}a{2,3}", "aaaa(?:aa?)?" },
-  // With a char class, any char and any byte:
-  { "\\d*\\d*", "[0-9]*" },
-  { ".*.*", ".*" },
-  { "\\C*\\C*", "\\C*" },
-  // FoldCase works, but must be consistent:
-  { "(?i)A*a*", "[Aa]*" },
-  { "(?i)a+A+", "[Aa][Aa]+" },
-  { "(?i)A*(?-i)a*", "[Aa]*a*" },
-  { "(?i)a+(?-i)A+", "[Aa]+A+" },
-  // NonGreedy works, but must be consistent:
-  { "a*?a*?", "a*?" },
-  { "a+?a+?", "aa+?" },
-  { "a*?a*", "a*?a*" },
-  { "a+a+?", "a+a+?" },
-  // The second element is the literal, char class, any char or any byte:
-  { "a*a", "a+" },
-  { "\\d*\\d", "[0-9]+" },
-  { ".*.", ".+" },
-  { "\\C*\\C", "\\C+" },
-  // FoldCase works, but must be consistent:
-  { "(?i)A*a", "[Aa]+" },
-  { "(?i)a+A", "[Aa][Aa]+" },
-  { "(?i)A*(?-i)a", "[Aa]*a" },
-  { "(?i)a+(?-i)A", "[Aa]+A" },
-  // The second element is a literal string that begins with the literal:
-  { "a*aa", "aa+" },
-  { "a*aab", "aa+b" },
-  // FoldCase works, but must be consistent:
-  { "(?i)a*aa", "[Aa][Aa]+" },
-  { "(?i)a*aab", "[Aa][Aa]+[Bb]" },
-  { "(?i)a*(?-i)aa", "[Aa]*aa" },
-  { "(?i)a*(?-i)aab", "[Aa]*aab" },
-  // Negative tests with mismatching ops:
-  { "a*b*", "a*b*" },
-  { "\\d*\\D*", "[0-9]*[^0-9]*" },
-  { "a+b", "a+b" },
-  { "\\d+\\D", "[0-9]+[^0-9]" },
-  { "a?bb", "a?bb" },
-  // Negative tests with capturing groups:
-  { "(a*)a*", "(a*)a*" },
-  { "a+(a)", "a+(a)" },
-  { "(a?)(aa)", "(a?)(aa)" },
-  // Just for fun:
-  { "aa*aa+aa?aa{2}aaa{2,}aaa{2,3}a", "aaaaaaaaaaaaaaaa+" },
-
-  // During coalescing, the child of the repeat changes, so we build a new
-  // repeat. The new repeat must have the min and max of the old repeat.
-  // Failure to copy them results in min=0 and max=0 -> empty match.
-  { "(?:a*aab){2}", "aa+baa+b" },
-
-  // During coalescing, the child of the capture changes, so we build a new
-  // capture. The new capture must have the cap of the old capture.
-  // Failure to copy it results in cap=0 -> ToString() logs a fatal error.
-  { "(a*aab)", "(aa+b)" },
-
-  // Test squashing of **, ++, ?? et cetera.
-  { "(?:(?:a){0,}){0,}", "a*" },
-  { "(?:(?:a){1,}){1,}", "a+" },
-  { "(?:(?:a){0,1}){0,1}", "a?" },
-  { "(?:(?:a){0,}){1,}", "a*" },
-  { "(?:(?:a){0,}){0,1}", "a*" },
-  { "(?:(?:a){1,}){0,}", "a*" },
-  { "(?:(?:a){1,}){0,1}", "a*" },
-  { "(?:(?:a){0,1}){0,}", "a*" },
-  { "(?:(?:a){0,1}){1,}", "a*" },
-};
-
-TEST(TestSimplify, SimpleRegexps) {
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(tests); i++) {
-    RegexpStatus status;
-    ABSL_VLOG(1) << "Testing " << tests[i].regexp;
-    Regexp* re = Regexp::Parse(tests[i].regexp,
-                               Regexp::MatchNL | (Regexp::LikePerl &
-                                                  ~Regexp::OneLine),
-                               &status);
-    ASSERT_TRUE(re != NULL) << " " << tests[i].regexp << " " << status.Text();
-    Regexp* sre = re->Simplify();
-    ASSERT_TRUE(sre != NULL);
-
-    // Check that already-simple regexps don't allocate new ones.
-    if (strcmp(tests[i].regexp, tests[i].simplified) == 0) {
-      ASSERT_TRUE(re == sre) << " " << tests[i].regexp
-        << " " << re->ToString() << " " << sre->ToString();
-    }
-
-    EXPECT_EQ(tests[i].simplified, sre->ToString())
-      << " " << tests[i].regexp << " " << sre->Dump();
-
-    re->Decref();
-    sre->Decref();
-  }
-}
-
-}  // namespace re2

package/deps/re2/re2/testing/string_generator.cc

@@ -1,144 +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.
-
-// String generator: generates all possible strings of up to
-// maxlen letters using the set of letters in alpha.
-// Fetch strings using a Java-like Next()/HasNext() interface.
-
-#include "re2/testing/string_generator.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <random>
-#include <string>
-#include <vector>
-
-#include "absl/log/absl_check.h"
-#include "absl/strings/string_view.h"
-
-namespace re2 {
-
-StringGenerator::StringGenerator(int maxlen,
-                                 const std::vector<std::string>& alphabet)
-    : maxlen_(maxlen), alphabet_(alphabet),
-      generate_null_(false),
-      random_(false), nrandom_(0) {
-
-  // Degenerate case: no letters, no non-empty strings.
-  if (alphabet_.empty())
-    maxlen_ = 0;
-
-  // Next() will return empty string (digits_ is empty).
-  hasnext_ = true;
-}
-
-// Resets the string generator state to the beginning.
-void StringGenerator::Reset() {
-  digits_.clear();
-  hasnext_ = true;
-  random_ = false;
-  nrandom_ = 0;
-  generate_null_ = false;
-}
-
-// Increments the big number in digits_, returning true if successful.
-// Returns false if all the numbers have been used.
-bool StringGenerator::IncrementDigits() {
-  // First try to increment the current number.
-  for (int i = static_cast<int>(digits_.size()) - 1; i >= 0; i--) {
-    if (++digits_[i] < static_cast<int>(alphabet_.size()))
-      return true;
-    digits_[i] = 0;
-  }
-
-  // If that failed, make a longer number.
-  if (static_cast<int>(digits_.size()) < maxlen_) {
-    digits_.push_back(0);
-    return true;
-  }
-
-  return false;
-}
-
-// Generates random digits_, return true if successful.
-// Returns false if the random sequence is over.
-bool StringGenerator::RandomDigits() {
-  if (--nrandom_ <= 0)
-    return false;
-
-  std::uniform_int_distribution<int> random_len(0, maxlen_);
-  std::uniform_int_distribution<int> random_alphabet_index(
-      0, static_cast<int>(alphabet_.size()) - 1);
-
-  // Pick length.
-  int len = random_len(rng_);
-  digits_.resize(len);
-  for (int i = 0; i < len; i++)
-    digits_[i] = random_alphabet_index(rng_);
-  return true;
-}
-
-// Returns the next string in the iteration, which is the one
-// currently described by digits_.  Calls IncrementDigits
-// after computing the string, so that it knows the answer
-// for subsequent HasNext() calls.
-absl::string_view StringGenerator::Next() {
-  ABSL_CHECK(hasnext_);
-  if (generate_null_) {
-    generate_null_ = false;
-    sp_ = absl::string_view();
-    return sp_;
-  }
-  s_.clear();
-  for (size_t i = 0; i < digits_.size(); i++) {
-    s_ += alphabet_[digits_[i]];
-  }
-  hasnext_ = random_ ? RandomDigits() : IncrementDigits();
-  sp_ = s_;
-  return sp_;
-}
-
-// Sets generator up to return n random strings.
-void StringGenerator::Random(int32_t seed, int n) {
-  rng_.seed(seed);
-
-  random_ = true;
-  nrandom_ = n;
-  hasnext_ = nrandom_ > 0;
-}
-
-void StringGenerator::GenerateNULL() {
-  generate_null_ = true;
-  hasnext_ = true;
-}
-
-std::string DeBruijnString(int n) {
-  ABSL_CHECK_GE(n, 1);
-  ABSL_CHECK_LE(n, 29);
-  const size_t size = size_t{1} << static_cast<size_t>(n);
-  const size_t mask = size - 1;
-  std::vector<bool> did(size, false);
-  std::string s;
-  s.reserve(static_cast<size_t>(n) + size);
-  for (size_t i = 0; i < static_cast<size_t>(n - 1); i++)
-    s += '0';
-  size_t bits = 0;
-  for (size_t i = 0; i < size; i++) {
-    bits <<= 1;
-    bits &= mask;
-    if (!did[bits | 1]) {
-      bits |= 1;
-      s += '1';
-    } else {
-      s += '0';
-    }
-    ABSL_CHECK(!did[bits]);
-    did[bits] = true;
-  }
-  ABSL_CHECK_EQ(s.size(), static_cast<size_t>(n - 1) + size);
-  return s;
-}
-
-}  // namespace re2

package/deps/re2/re2/testing/string_generator.h

@@ -1,76 +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.
-
-#ifndef RE2_TESTING_STRING_GENERATOR_H_
-#define RE2_TESTING_STRING_GENERATOR_H_
-
-// String generator: generates all possible strings of up to
-// maxlen letters using the set of letters in alpha.
-// Fetch strings using a Java-like Next()/HasNext() interface.
-
-#include <stdint.h>
-
-#include <random>
-#include <string>
-#include <vector>
-
-#include "absl/strings/string_view.h"
-
-namespace re2 {
-
-class StringGenerator {
- public:
-  StringGenerator(int maxlen, const std::vector<std::string>& alphabet);
-  ~StringGenerator() {}
-
-  absl::string_view Next();
-  bool HasNext() { return hasnext_; }
-
-  // Resets generator to start sequence over.
-  void Reset();
-
-  // Causes generator to emit random strings for next n calls to Next().
-  void Random(int32_t seed, int n);
-
-  // Causes generator to emit a NULL as the next call.
-  void GenerateNULL();
-
- private:
-  bool IncrementDigits();
-  bool RandomDigits();
-
-  // Global state.
-  int maxlen_;                         // Maximum length string to generate.
-  std::vector<std::string> alphabet_;  // Alphabet, one string per letter.
-
-  // Iteration state.
-  absl::string_view sp_;     // Last string_view returned by Next().
-  std::string s_;            // String data in last string_view returned by Next().
-  bool hasnext_;             // Whether Next() can be called again.
-  std::vector<int> digits_;  // Alphabet indices for next string.
-  bool generate_null_;       // Whether to generate a NULL string_view next.
-  bool random_;              // Whether generated strings are random.
-  int nrandom_;              // Number of random strings left to generate.
-  std::minstd_rand0 rng_;    // Random number generator.
-
-  StringGenerator(const StringGenerator&) = delete;
-  StringGenerator& operator=(const StringGenerator&) = delete;
-};
-
-// Generates and returns a string over binary alphabet {0,1} that contains
-// all possible binary sequences of length n as subsequences.  The obvious
-// brute force method would generate a string of length n * 2^n, but this
-// generates a string of length n-1 + 2^n called a De Bruijn cycle.
-// See Knuth, The Art of Computer Programming, Vol 2, Exercise 3.2.2 #17.
-//
-// Such a string is useful for testing a DFA.  If you have a DFA
-// where distinct last n bytes implies distinct states, then running on a
-// DeBruijn string causes the DFA to need to create a new state at every
-// position in the input, never reusing any states until it gets to the
-// end of the string.  This is the worst possible case for DFA execution.
-std::string DeBruijnString(int n);
-
-}  // namespace re2
-
-#endif  // RE2_TESTING_STRING_GENERATOR_H_

package/deps/re2/re2/testing/string_generator_test.cc

@@ -1,114 +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.
-
-// Test StringGenerator.
-
-#include "re2/testing/string_generator.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <string>
-
-#include "absl/strings/string_view.h"
-#include "gtest/gtest.h"
-#include "re2/testing/regexp_generator.h"
-#include "util/utf.h"
-
-namespace re2 {
-
-// Returns i to the e.
-static int64_t IntegerPower(int i, int e) {
-  int64_t p = 1;
-  while (e-- > 0)
-    p *= i;
-  return p;
-}
-
-// Checks that for given settings of the string generator:
-//   * it generates strings that are non-decreasing in length.
-//   * strings of the same length are sorted in alphabet order.
-//   * it doesn't generate the same string twice.
-//   * it generates the right number of strings.
-//
-// If all of these hold, the StringGenerator is behaving.
-// Assumes that the alphabet is sorted, so that the generated
-// strings can just be compared lexicographically.
-static void RunTest(int len, const std::string& alphabet, bool donull) {
-  StringGenerator g(len, Explode(alphabet));
-
-  int n = 0;
-  int last_l = -1;
-  std::string last_s;
-
-  if (donull) {
-    g.GenerateNULL();
-    EXPECT_TRUE(g.HasNext());
-    absl::string_view sp = g.Next();
-    EXPECT_EQ(sp.data(), static_cast<const char*>(NULL));
-    EXPECT_EQ(sp.size(), size_t{0});
-  }
-
-  while (g.HasNext()) {
-    std::string s = std::string(g.Next());
-    n++;
-
-    // Check that all characters in s appear in alphabet.
-    for (const char *p = s.c_str(); *p != '\0'; ) {
-      Rune r;
-      p += chartorune(&r, p);
-      EXPECT_TRUE(utfrune(alphabet.c_str(), r) != NULL);
-    }
-
-    // Check that string is properly ordered w.r.t. previous string.
-    int l = utflen(s.c_str());
-    EXPECT_LE(l, len);
-    if (last_l < l) {
-      last_l = l;
-    } else {
-      EXPECT_EQ(last_l, l);
-      EXPECT_LT(last_s, s);
-    }
-    last_s = s;
-  }
-
-  // Check total string count.
-  int64_t m = 0;
-  int alpha = utflen(alphabet.c_str());
-  if (alpha == 0)  // Degenerate case.
-    len = 0;
-  for (int i = 0; i <= len; i++)
-    m += IntegerPower(alpha, i);
-  EXPECT_EQ(n, m);
-}
-
-TEST(StringGenerator, NoLength) {
-  RunTest(0, "abc", false);
-}
-
-TEST(StringGenerator, NoLengthNoAlphabet) {
-  RunTest(0, "", false);
-}
-
-TEST(StringGenerator, NoAlphabet) {
-  RunTest(5, "", false);
-}
-
-TEST(StringGenerator, Simple) {
-  RunTest(3, "abc", false);
-}
-
-TEST(StringGenerator, UTF8) {
-  RunTest(4, "abc\xE2\x98\xBA", false);
-}
-
-TEST(StringGenerator, GenNULL) {
-  RunTest(0, "abc", true);
-  RunTest(0, "", true);
-  RunTest(5, "", true);
-  RunTest(3, "abc", true);
-  RunTest(4, "abc\xE2\x98\xBA", true);
-}
-
-}  // namespace re2