| //===----------------------------------------------------------------------===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| /// | |
| /// \file | |
| /// Basic round-trip tests for POSIX regex functions. | |
| /// | |
| //===----------------------------------------------------------------------===// | |
| #include "src/regex/regcomp.h" | |
| #include "src/regex/regexec.h" | |
| #include "src/regex/regfree.h" | |
| #include "test/UnitTest/Test.h" | |
| #include "hdr/regex_macros.h" | |
| #include "hdr/types/regex_t.h" | |
| #include "src/__support/CPP/scope.h" | |
| using LIBC_NAMESPACE::cpp::scope_exit; | |
| TEST(LlvmLibcRegexTest, BasicLiteralRoundTrip) { | |
| regex_t preg; | |
| ASSERT_EQ(0, | |
| LIBC_NAMESPACE::regcomp(&preg, "hello", REG_EXTENDED | REG_NOSUB)); | |
| scope_exit free_guard([&preg] { LIBC_NAMESPACE::regfree(&preg); }); | |
| EXPECT_EQ(0, | |
| LIBC_NAMESPACE::regexec(&preg, "say hello world", 0, nullptr, 0)); | |
| EXPECT_EQ(REG_NOMATCH, | |
| LIBC_NAMESPACE::regexec(&preg, "goodbye", 0, nullptr, 0)); | |
| } | |
| TEST(LlvmLibcRegexTest, MismatchCases) { | |
| regex_t preg; | |
| // Partial match | |
| ASSERT_EQ(0, | |
| LIBC_NAMESPACE::regcomp(&preg, "hello", REG_EXTENDED | REG_NOSUB)); | |
| EXPECT_EQ(REG_NOMATCH, LIBC_NAMESPACE::regexec(&preg, "hell", 0, nullptr, 0)); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| // Case sensitivity | |
| ASSERT_EQ(0, | |
| LIBC_NAMESPACE::regcomp(&preg, "Hello", REG_EXTENDED | REG_NOSUB)); | |
| EXPECT_EQ(REG_NOMATCH, | |
| LIBC_NAMESPACE::regexec(&preg, "hello", 0, nullptr, 0)); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| // Empty string vs non-empty pattern | |
| ASSERT_EQ(0, LIBC_NAMESPACE::regcomp(&preg, "a", REG_EXTENDED | REG_NOSUB)); | |
| EXPECT_EQ(REG_NOMATCH, LIBC_NAMESPACE::regexec(&preg, "", 0, nullptr, 0)); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| } | |
| TEST(LlvmLibcRegexTest, EmptyString) { | |
| regex_t preg; | |
| ASSERT_EQ(0, LIBC_NAMESPACE::regcomp(&preg, "", REG_EXTENDED | REG_NOSUB)); | |
| scope_exit free_guard([&preg] { LIBC_NAMESPACE::regfree(&preg); }); | |
| EXPECT_EQ(0, LIBC_NAMESPACE::regexec(&preg, "anything", 0, nullptr, 0)); | |
| EXPECT_EQ(0, LIBC_NAMESPACE::regexec(&preg, "", 0, nullptr, 0)); | |
| } | |
| TEST(LlvmLibcRegexTest, ExactMatch) { | |
| regex_t preg; | |
| ASSERT_EQ(0, | |
| LIBC_NAMESPACE::regcomp(&preg, "test", REG_EXTENDED | REG_NOSUB)); | |
| scope_exit free_guard([&preg] { LIBC_NAMESPACE::regfree(&preg); }); | |
| EXPECT_EQ(0, LIBC_NAMESPACE::regexec(&preg, "test", 0, nullptr, 0)); | |
| } | |
| TEST(LlvmLibcRegexTest, NullByteStopsParsing) { | |
| regex_t preg; | |
| ASSERT_EQ(0, | |
| LIBC_NAMESPACE::regcomp(&preg, "match", REG_EXTENDED | REG_NOSUB)); | |
| scope_exit free_guard([&preg] { LIBC_NAMESPACE::regfree(&preg); }); | |
| EXPECT_EQ(REG_NOMATCH, | |
| LIBC_NAMESPACE::regexec(&preg, "doesn't \0 match", 0, nullptr, 0)); | |
| } | |
| TEST(LlvmLibcRegexTest, OverlappingPrefixAndPostFreeSafety) { | |
| regex_t preg; | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "ababac", REG_EXTENDED | REG_NOSUB), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abababac", 0, nullptr, 0), 0); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| // Repeated regfree and post-free regexec must be safe. | |
| LIBC_NAMESPACE::regfree(&preg); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abababac", 0, nullptr, 0), | |
| REG_NOMATCH); | |
| } | |
| TEST(LlvmLibcRegexTest, PoolExhaustionReturnsEspace) { | |
| // 9998 'a' bytes plus EmptySet (1) and EmptyStr (2) fill all 10000 ExprPool | |
| // slots during regcomp; regexec then hits MAX_NODE_LIMIT when interning the | |
| // first derivative Alt state. | |
| char pattern[10000]; | |
| for (size_t i = 0; i < 9998; ++i) | |
| pattern[i] = 'a'; | |
| pattern[9998] = '\0'; | |
| regex_t preg; | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, pattern, REG_EXTENDED | REG_NOSUB), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a", 0, nullptr, 0), REG_ESPACE); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| // One additional byte (9999 'a's) hits MAX_NODE_LIMIT during regcomp; | |
| // calling regfree afterwards must be a safe no-op. | |
| pattern[9998] = 'a'; | |
| pattern[9999] = '\0'; | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, pattern, REG_EXTENDED | REG_NOSUB), | |
| REG_ESPACE); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| } | |
| TEST(LlvmLibcRegexTest, WildcardDot) { | |
| regex_t preg; | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "a.c", REG_EXTENDED | REG_NOSUB), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abc", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "axc", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "ac", 0, nullptr, 0), REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abbc", 0, nullptr, 0), REG_NOMATCH); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| ASSERT_EQ( | |
| LIBC_NAMESPACE::regcomp(&preg, R"(a\.b.c)", REG_EXTENDED | REG_NOSUB), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a.bXc", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "aXbXc", 0, nullptr, 0), | |
| REG_NOMATCH); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| } | |
| TEST(LlvmLibcRegexTest, AnchorsAndFlags) { | |
| regex_t preg; | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "^foo", | |
| REG_EXTENDED | REG_NOSUB | REG_NEWLINE), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "foobar", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xfoo", 0, nullptr, 0), REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "foo", 0, nullptr, REG_NOTBOL), | |
| REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "bar\nfoo", 0, nullptr, REG_NOTBOL), | |
| 0); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "foo$", | |
| REG_EXTENDED | REG_NOSUB | REG_NEWLINE), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "barfoo", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "foox", 0, nullptr, 0), REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "foo", 0, nullptr, REG_NOTEOL), | |
| REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "foo\nbar", 0, nullptr, REG_NOTEOL), | |
| 0); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "^$", | |
| REG_EXTENDED | REG_NOSUB | REG_NEWLINE), | |
| 0); | |
| scope_exit free_guard([&preg] { LIBC_NAMESPACE::regfree(&preg); }); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a\n\nb", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a\nb", 0, nullptr, 0), REG_NOMATCH); | |
| } | |
| TEST(LlvmLibcRegexTest, KleeneStarAndBadRpt) { | |
| regex_t preg; | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "ab*c", REG_EXTENDED | REG_NOSUB), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "ac", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abc", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abbbc", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abbd", 0, nullptr, 0), REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "bbbc", 0, nullptr, 0), REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abXc", 0, nullptr, 0), REG_NOMATCH); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| const char *const bad_rpt[] = {"*", "+", "?", "{1}", "^*", "$*", "a**"}; | |
| for (const char *pat : bad_rpt) { | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED), REG_BADRPT); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| } | |
| } | |
| TEST(LlvmLibcRegexTest, EscapedMetacharacters) { | |
| regex_t preg; | |
| ASSERT_EQ( | |
| LIBC_NAMESPACE::regcomp(&preg, R"(a\.b\*c\\d)", REG_EXTENDED | REG_NOSUB), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, R"(xx a.b*c\d yy)", 0, nullptr, 0), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, R"(aXb*c\d)", 0, nullptr, 0), | |
| REG_NOMATCH); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, R"(trailing\)", REG_EXTENDED), | |
| REG_EESCAPE); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| } | |
| TEST(LlvmLibcRegexTest, BracketExpressionsAndRanges) { | |
| regex_t preg; | |
| // Matching and range checks with near-miss boundary tests. | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "x[c-f]y", REG_EXTENDED | REG_NOSUB), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xcy", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xdy", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xey", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xfy", 0, nullptr, 0), 0); | |
| // Near-misses: adjacent ASCII values 'b' (c - 1) and 'g' (f + 1), empty, | |
| // multi-char, and literal '-'. | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xby", 0, nullptr, 0), REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xgy", 0, nullptr, 0), REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xy", 0, nullptr, 0), REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xccy", 0, nullptr, 0), REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "x-y", 0, nullptr, 0), REG_NOMATCH); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| // Negated brackets and REG_NEWLINE interaction. | |
| ASSERT_EQ( | |
| LIBC_NAMESPACE::regcomp(&preg, "x[^c-f]y", REG_EXTENDED | REG_NOSUB), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xby", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xgy", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xcy", 0, nullptr, 0), REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xfy", 0, nullptr, 0), REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xy", 0, nullptr, 0), REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "xbbby", 0, nullptr, 0), | |
| REG_NOMATCH); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "x[^c-f]y", | |
| REG_EXTENDED | REG_NEWLINE | REG_NOSUB), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "x\ny", 0, nullptr, 0), REG_NOMATCH); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| // First-position ']', leading '-', trailing '-', and collating elements. | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "a[]b]c", REG_EXTENDED | REG_NOSUB), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a]c", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abc", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "ac", 0, nullptr, 0), REG_NOMATCH); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "a[-b]c", REG_EXTENDED | REG_NOSUB), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a-c", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abc", 0, nullptr, 0), 0); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "a[b-]c", REG_EXTENDED | REG_NOSUB), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a-c", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abc", 0, nullptr, 0), 0); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "a[--0]c", REG_EXTENDED | REG_NOSUB), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a-c", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a.c", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a/c", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a0c", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a1c", 0, nullptr, 0), REG_NOMATCH); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "a[!--]c", REG_EXTENDED | REG_NOSUB), | |
| 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a!c", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a+c", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a-c", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a.c", 0, nullptr, 0), REG_NOMATCH); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| ASSERT_EQ( | |
| LIBC_NAMESPACE::regcomp(&preg, "a[[.x.]]b", REG_EXTENDED | REG_NOSUB), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "axb", 0, nullptr, 0), 0); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| ASSERT_EQ( | |
| LIBC_NAMESPACE::regcomp(&preg, "a[[.].]]b", REG_EXTENDED | REG_NOSUB), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a]b", 0, nullptr, 0), 0); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| ASSERT_EQ( | |
| LIBC_NAMESPACE::regcomp(&preg, "^[a-c]*$", REG_EXTENDED | REG_NOSUB), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abcba", 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "abzcba", 0, nullptr, 0), | |
| REG_NOMATCH); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| // Bracket error conditions. | |
| const char *const ebrack_patterns[] = { | |
| "[", "[^", "[abc", "[]", "a[[.x", "a[[.x.", "a[[:digit:", "a[[:digit"}; | |
| for (const char *pat : ebrack_patterns) { | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED), REG_EBRACK); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| } | |
| const char *const erange_patterns[] = {"a[3-1]c", "a[1-3-5]c", "a[1-", | |
| "a[a-[:digit:]]c", "a[[:alpha:]-z]c"}; | |
| for (const char *pat : erange_patterns) { | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED), REG_ERANGE); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| } | |
| const char *const ecollate_patterns[] = {"a[[.notdef.]]b", "a[[.x,.]]", | |
| "a[[=b,=]]"}; | |
| for (const char *pat : ecollate_patterns) { | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED), REG_ECOLLATE); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| } | |
| const char *const ectype_patterns[] = {"a[[:notdef:]]b", "a[[:alph:]]b", | |
| "a[[:]:]]b", "a[[:-:]]b"}; | |
| for (const char *pat : ectype_patterns) { | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED), REG_ECTYPE); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| } | |
| } | |
| TEST(LlvmLibcRegexTest, UnimplementedSyntaxAndFlags) { | |
| regex_t preg; | |
| // Missing REG_EXTENDED (BRE mode) and unsupported cflags return REG_BADPAT. | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, "a", 0), REG_BADPAT); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, "a", REG_EXTENDED | REG_ICASE), | |
| REG_BADPAT); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, "a", ~(REG_NOSUB | REG_NEWLINE)), | |
| REG_BADPAT); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| // Unimplemented ERE backreferences and word-boundary extensions return | |
| // REG_BADPAT. | |
| const char *const bad_patterns[] = {R"(\1)", R"(\b)", "[[:<:]]", "[[:>:]]"}; | |
| for (const char *pat : bad_patterns) { | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED), REG_BADPAT); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| } | |
| // Unsupported eflags in regexec return REG_BADPAT. | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, "a", REG_EXTENDED), 0); | |
| scope_exit free_guard([&preg] { LIBC_NAMESPACE::regfree(&preg); }); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, "a", 0, nullptr, | |
| ~(REG_NOTBOL | REG_NOTEOL)), | |
| REG_BADPAT); | |
| } | |
| TEST(LlvmLibcRegexTest, PosixCharacterClassesAndShorthands) { | |
| auto check = [](const char *pat, const char *str, int expected = 0) { | |
| regex_t preg; | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED | REG_NOSUB), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, str, 0, nullptr, 0), expected); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| }; | |
| // Near-miss ASCII neighbours for [:digit:] and \d. | |
| check("^x[[:digit:]]y$", "x0y"); | |
| check("^x[[:digit:]]y$", "x9y"); | |
| check("^x[[:digit:]]y$", "x/y", REG_NOMATCH); | |
| check("^x[[:digit:]]y$", "x:y", REG_NOMATCH); | |
| check("^x[[:digit:]]y$", "x12y", REG_NOMATCH); | |
| check(R"(^x\dy$)", "x5y"); | |
| check(R"(^x\dy$)", "x/y", REG_NOMATCH); | |
| check(R"(^x\dy$)", "x:y", REG_NOMATCH); | |
| // Near-miss ASCII neighbours for [:xdigit:]. | |
| check("^x[[:xdigit:]]y$", "xfy"); | |
| check("^x[[:xdigit:]]y$", "xFy"); | |
| check("^x[[:xdigit:]]y$", "xgy", REG_NOMATCH); | |
| check("^x[[:xdigit:]]y$", "xGy", REG_NOMATCH); | |
| // [:blank:] matches only space and tab, not newline. | |
| check("^x[[:blank:]]y$", "x y"); | |
| check("^x[[:blank:]]y$", "x\ty"); | |
| check("^x[[:blank:]]y$", "x\ny", REG_NOMATCH); | |
| // \w and \W: underscore matches \w; hyphen does not. | |
| check(R"(^x\wy$)", "x_y"); | |
| check(R"(^x\wy$)", "x-y", REG_NOMATCH); | |
| check(R"(^x\Wy$)", "x-y"); | |
| check(R"(^x\Wy$)", "x_y", REG_NOMATCH); | |
| // Hyphen endpoint combinations with character classes. | |
| check("^[--0[:alpha:]]$", "-"); | |
| check("^[--0[:alpha:]]$", "."); | |
| check("^[--0[:alpha:]]$", "a"); | |
| check("^[--0[:alpha:]]$", "1", REG_NOMATCH); | |
| check("^[[:alpha:]!--]$", "z"); | |
| check("^[[:alpha:]!--]$", "!"); | |
| check("^[[:alpha:]!--]$", "-"); | |
| check("^[[:alpha:]!--]$", ".", REG_NOMATCH); | |
| // Anchored repetitions with negative rejection checks. | |
| check(R"(^\w*$)", ""); | |
| check(R"(^\w*$)", "valid_word1"); | |
| check(R"(^\w*$)", "ab!ba", REG_NOMATCH); | |
| check(R"(^\d*$)", ""); | |
| check(R"(^\d*$)", "12345"); | |
| check(R"(^\d*$)", "12a45", REG_NOMATCH); | |
| // Back-to-back adjacent character classes in a single bracket expression. | |
| check("^[[:alpha:][:blank:]]$", "a"); | |
| check("^[[:alpha:][:blank:]]$", " "); | |
| check("^[[:alpha:][:blank:]]$", "\t"); | |
| check("^[[:alpha:][:blank:]]$", "1", REG_NOMATCH); | |
| check("^[[:alpha:][:blank:]]$", "_", REG_NOMATCH); | |
| check("^[[:alpha:][:blank:]]*$", "Hello World"); | |
| check("^[[:alpha:][:blank:]]*$", "Hello\tWorld"); | |
| check("^[[:alpha:][:blank:]]*$", "Hello1World", REG_NOMATCH); | |
| check("^[[:alpha:][:blank:]]*$", "Hello_World", REG_NOMATCH); | |
| // Multiple classes combined with literals. | |
| check("^[[:digit:][:lower:]_]*$", "3abc_7"); | |
| check("^[[:digit:][:lower:]_]*$", "3ABC_7", REG_NOMATCH); | |
| // Negated multi-class bracket expressions. | |
| check("^[^[:digit:][:space:]]*$", "abcABC_!"); | |
| check("^[^[:digit:][:space:]]*$", "abc 123", REG_NOMATCH); | |
| check("^[^[:digit:][:space:]]*$", "abc1", REG_NOMATCH); | |
| } | |
| TEST(LlvmLibcRegexTest, AlternationAndGrouping) { | |
| auto check = [](const char *pat, const char *str, int expected = 0) { | |
| regex_t preg{}; | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED | REG_NOSUB), 0); | |
| scope_exit free_guard([&preg] { LIBC_NAMESPACE::regfree(&preg); }); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, str, 0, nullptr, 0), expected); | |
| }; | |
| auto check_err = [](const char *pat, int expected_err) { | |
| regex_t preg{}; | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED), expected_err); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| }; | |
| // Basic alternation branches. | |
| check("cat|dog|bird", "cat"); | |
| check("cat|dog|bird", "dog"); | |
| check("cat|dog|bird", "bird"); | |
| check("cat|dog|bird", "fish", REG_NOMATCH); | |
| // Grouping, operator precedence, and POSIX 9.4.9 subexpression anchoring. | |
| check("^ab|cd$", "abXYZ"); | |
| check("^ab|cd$", "XYZcd"); | |
| check("^ab|cd$", "XYZab", REG_NOMATCH); | |
| check("^(ab|cd)$", "ab"); | |
| check("^(ab|cd)$", "cd"); | |
| check("^(ab|cd)$", "abXYZ", REG_NOMATCH); | |
| check("^(ab|cd)$", "XYZcd", REG_NOMATCH); | |
| check("^(ab|cd)$", "abcd", REG_NOMATCH); | |
| check("(^ab)", "abcdef"); | |
| check("(^ab)", "cdefab", REG_NOMATCH); | |
| check("(ef$)", "abcdef"); | |
| check("(ef$)", "cdefab", REG_NOMATCH); | |
| // Near-miss negative checks. | |
| check("^x(cat|dog)y$", "xcaty"); | |
| check("^x(cat|dog)y$", "xdogy"); | |
| check("^x(cat|dog)y$", "xcatdogy", REG_NOMATCH); | |
| check("^x(cat|dog)y$", "xcay", REG_NOMATCH); | |
| check("^x(cat|dog)y$", "xy", REG_NOMATCH); | |
| // Nullable branch anchoring rule. | |
| check("^(a|b*)$", "a"); | |
| check("^(a|b*)$", "bbb"); | |
| check("^(a|b*)$", ""); | |
| check("^(a|b*)$", "ac", REG_NOMATCH); | |
| check("^(a|b*)$", "bc", REG_NOMATCH); | |
| // Nested grouping and repetition under Kleene star. | |
| check("^((a)|(b))*$", "ababba"); | |
| check("^((a)|(b))*$", "ababbc", REG_NOMATCH); | |
| check("(wee|week)(knights|night)", "weeknights"); | |
| // Depth-0 unmatched closing parenthesis treated as a literal character. | |
| check("a)", "a)"); | |
| check(")", ")"); | |
| check("a)b", "a)b"); | |
| check("a)b", "ab", REG_NOMATCH); | |
| check("a|)", "a"); | |
| check("a|)", ")"); | |
| check("a|)", "b", REG_NOMATCH); | |
| // Empty subexpression matches empty string. | |
| check("()", ""); | |
| check("()", "abc"); | |
| check("a()b", "ab"); | |
| // Error condition rejections. | |
| check_err("|", REG_BADPAT); | |
| check_err("|a", REG_BADPAT); | |
| check_err("a|", REG_BADPAT); | |
| check_err("a||b", REG_BADPAT); | |
| check_err("(|a)", REG_BADPAT); | |
| check_err("(a|)", REG_BADPAT); | |
| check_err("a(", REG_EPAREN); | |
| check_err("(a", REG_EPAREN); | |
| check_err("((a)", REG_EPAREN); | |
| // Subexpression count (re_nsub). | |
| auto check_nsub = [](const char *pat, size_t expected_nsub) { | |
| regex_t preg{}; | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED), 0); | |
| scope_exit free_guard([&preg] { LIBC_NAMESPACE::regfree(&preg); }); | |
| EXPECT_EQ(preg.re_nsub, expected_nsub); | |
| }; | |
| check_nsub("abc", 0); | |
| check_nsub("a|b", 0); | |
| check_nsub("a)b", 0); | |
| check_nsub("a(b)c", 1); | |
| check_nsub("()", 1); | |
| check_nsub("(a|b)", 1); | |
| check_nsub("(a)(b)", 2); | |
| check_nsub("((a))", 2); | |
| check_nsub("((a|b)|c)", 2); | |
| check_nsub("(((a|b)|c))", 3); | |
| check_nsub("(wee|week)(knights|night)", 2); | |
| // 128 nested parentheses must succeed within MAX_GROUP_DEPTH. | |
| char deep_128[300]; | |
| for (size_t i = 0; i < 128; ++i) | |
| deep_128[i] = '('; | |
| deep_128[128] = 'x'; | |
| for (size_t i = 129; i < 257; ++i) | |
| deep_128[i] = ')'; | |
| deep_128[257] = '\0'; | |
| check(deep_128, "x"); | |
| // 129 nested parentheses must return REG_ESPACE. | |
| char deep_129[300]; | |
| for (size_t i = 0; i < 129; ++i) | |
| deep_129[i] = '('; | |
| deep_129[129] = 'x'; | |
| for (size_t i = 130; i < 259; ++i) | |
| deep_129[i] = ')'; | |
| deep_129[259] = '\0'; | |
| check_err(deep_129, REG_ESPACE); | |
| // 150 nested unclosed parentheses must return REG_ESPACE without stack | |
| // overflow. | |
| char deep_150[200]; | |
| for (size_t i = 0; i < 150; ++i) | |
| deep_150[i] = '('; | |
| deep_150[150] = '\0'; | |
| check_err(deep_150, REG_ESPACE); | |
| } | |
| TEST(LlvmLibcRegexTest, PlusAndQuestionQuantifiers) { | |
| auto check = [](const char *pat, const char *match1, const char *match2, | |
| const char *nomatch1, const char *nomatch2) { | |
| regex_t preg{}; | |
| ASSERT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED | REG_NOSUB), 0); | |
| scope_exit free_guard([&preg] { LIBC_NAMESPACE::regfree(&preg); }); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, match1, 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, match2, 0, nullptr, 0), 0); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, nomatch1, 0, nullptr, 0), | |
| REG_NOMATCH); | |
| EXPECT_EQ(LIBC_NAMESPACE::regexec(&preg, nomatch2, 0, nullptr, 0), | |
| REG_NOMATCH); | |
| }; | |
| // Framed '+' and '?' near-miss checks (distinguishing '+', '?', and '*'). | |
| check("xa+y", "xay", "xaaay", "xy", "xaby"); | |
| check("xa?y", "xy", "xay", "xaay", "xby"); | |
| // Non-nullable '+' enforcement and anchored nullable '?' rule. | |
| check("a+", "a", "aaa", "", "bbb"); | |
| check("^a?$", "", "a", "aa", "b"); | |
| // Adjacent and mixed quantifiers. | |
| check("^a+b+c+$", "abc", "aaabbbccc", "ab", "ac"); | |
| check("^a?b?c?$", "", "ac", "aabc", "d"); | |
| check("^a+b?c*$", "a", "aaabccc", "bc", "abbc"); | |
| // Grouping, alternation, bracket classes, and escaped '+' / '?'. | |
| check("^(ab)+$", "ab", "ababab", "", "aba"); | |
| check("^(ab)?$", "", "ab", "abab", "a"); | |
| check("^(a|b)+$", "a", "abba", "", "abc"); | |
| check("^a()+b?$", "a", "ab", "", "abb"); | |
| check("^a()?b+$", "ab", "abbb", "a", ""); | |
| check(R"(^\d+-\w?$)", "123-a", "7-", "-a", "7-ab"); | |
| check(R"(a\+b\?c)", "a+b?c", "xx a+b?c yy", "abc", "aabbc"); | |
| // Framed near-miss boundary count checks ({n}, {n,m}, {n,}, {0}), anchored | |
| // nullable bound, adjacent repeats, and literal '{' fallbacks. | |
| check("xa{3}y", "xaaay", "xx xaaay yy", "xaay", "xaaaay"); | |
| check("xa{2,4}y", "xaay", "xaaaay", "xay", "xaaaaay"); | |
| check("xa{2,}y", "xaay", "xaaaaay", "xy", "xay"); | |
| check("xa{0}y", "xy", "xx xy yy", "xay", "xaay"); | |
| check("^a{0,3}$", "", "aaa", "aaaa", "b"); | |
| check("^a{2,3}b{1,2}$", "aab", "aaabb", "ab", "aaaabb"); | |
| check("^(a*$){2}$", "", "aaa", "b", "ab"); | |
| check("^(^|b){2}$", "b", "bb", "bbb", "a"); | |
| check("^(a{1,2}|a{4,5})$", "aa", "aaaa", "aaa", "aaaaaa"); | |
| check("^(a{2})*$", "", "aaaa", "a", "aaa"); | |
| check("((a{1,10}){1,10}){1,10}", "a", "aaaa", "b", ""); | |
| check("^{abc|a{b|a{,2}$", "{abc", "a{,2}", "abc", "aa"); | |
| // Invalid repetition errors (REG_BADRPT). | |
| const char *const bad_rpt[] = {"^+", "$+", "^?", "$?", "a++", "a??", | |
| "a*+", "a+?", "a?*", "(+a)", "(?a)"}; | |
| for (const char *pat : bad_rpt) { | |
| regex_t preg{}; | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED), REG_BADRPT); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| } | |
| auto check_err = [](const char *pat, int expected_err) { | |
| regex_t preg{}; | |
| EXPECT_EQ(LIBC_NAMESPACE::regcomp(&preg, pat, REG_EXTENDED), expected_err); | |
| LIBC_NAMESPACE::regfree(&preg); | |
| }; | |
| check_err("a{2}{2}", REG_BADRPT); | |
| check_err("a{1,2", REG_EBRACE); | |
| check_err("a{5,2}", REG_BADBR); | |
| check_err("a{256}", REG_BADBR); | |
| check_err("(a{255}){255}", REG_ESPACE); | |
| } | |
| #if defined(LIBC_ADD_NULL_CHECKS) | |
| TEST(LlvmLibcRegexTest, NullPointerCrash) { | |
| regex_t preg{}; | |
| ASSERT_DEATH([] { LIBC_NAMESPACE::regcomp(nullptr, "a", 0); }, | |
| WITH_SIGNAL(-1)); | |
| ASSERT_DEATH([&preg] { LIBC_NAMESPACE::regcomp(&preg, nullptr, 0); }, | |
| WITH_SIGNAL(-1)); | |
| ASSERT_DEATH([] { LIBC_NAMESPACE::regexec(nullptr, "a", 0, nullptr, 0); }, | |
| WITH_SIGNAL(-1)); | |
| ASSERT_DEATH( | |
| [&preg] { LIBC_NAMESPACE::regexec(&preg, nullptr, 0, nullptr, 0); }, | |
| WITH_SIGNAL(-1)); | |
| ASSERT_DEATH([] { LIBC_NAMESPACE::regfree(nullptr); }, WITH_SIGNAL(-1)); | |
| } | |
| #endif // defined(LIBC_ADD_NULL_CHECKS) |