How to use MatchTest class

Best Nimble code snippet using MatchTest

MatchTests.swift

Source:MatchTests.swift Github

copy

Full Screen

...123 file: StaticString = #file,124 line: UInt = #line125) {126 for (test, expect) in tests {127 firstMatchTest(128 regex,129 input: test,130 match: expect ? test : nil,131 syntax: syntax,132 enableTracing: enableTracing,133 dumpAST: dumpAST,134 xfail: xfail,135 file: file,136 line: line)137 }138}139// TODO: Adjust below to also check captures140/// Test the first match in a string, via `firstRange(of:)`141func firstMatchTest(142 _ regex: String,143 input: String,144 match: String?,145 syntax: SyntaxOptions = .traditional,146 enableTracing: Bool = false,147 dumpAST: Bool = false,148 xfail: Bool = false,149 file: StaticString = #filePath,150 line: UInt = #line151) {152 do {153 let (found, _) = try _firstMatch(154 regex,155 input: input,156 syntax: syntax,157 enableTracing: enableTracing)158 if xfail {159 XCTAssertNotEqual(found, match, file: file, line: line)160 } else {161 XCTAssertEqual(found, match, file: file, line: line)162 }163 } catch {164 // FIXME: This allows non-matches to succeed even when xfail'd165 // When xfail == true, this should report failure for match == nil166 if !xfail && match != nil {167 XCTFail("\(error)", file: file, line: line)168 }169 return170 }171}172func firstMatchTests(173 _ regex: String,174 _ tests: (input: String, match: String?)...,175 syntax: SyntaxOptions = .traditional,176 enableTracing: Bool = false,177 dumpAST: Bool = false,178 xfail: Bool = false,179 file: StaticString = #filePath,180 line: UInt = #line181) {182 for (input, match) in tests {183 firstMatchTest(184 regex,185 input: input,186 match: match,187 syntax: syntax,188 enableTracing: enableTracing,189 dumpAST: dumpAST,190 xfail: xfail,191 file: file,192 line: line)193 }194}195extension RegexTests {196 func testMatch() {197 firstMatchTest(198 "abc", input: "123abcxyz", match: "abc")199 firstMatchTest(200 #"abc\+d*"#, input: "123abc+xyz", match: "abc+")201 firstMatchTest(202 #"abc\+d*"#, input: "123abc+dddxyz", match: "abc+ddd")203 firstMatchTest(204 "a(b)", input: "123abcxyz", match: "ab")205 firstMatchTest(206 "(.)*(.*)", input: "123abcxyz", match: "123abcxyz")207 firstMatchTest(208 #"abc\d"#, input: "xyzabc123", match: "abc1")209 // MARK: Allowed combining characters210 firstMatchTest("e\u{301}", input: "e\u{301}", match: "e\u{301}")211 firstMatchTest("1\u{358}", input: "1\u{358}", match: "1\u{358}")212 firstMatchTest(#"\ \#u{361}"#, input: " \u{361}", match: " \u{361}")213 // MARK: Alternations214 firstMatchTest(215 "abc(?:de)+fghi*k|j", input: "123abcdefghijxyz", match: "j")216 firstMatchTest(217 "abc(?:de)+fghi*k|j", input: "123abcdedefghkxyz", match: "abcdedefghk")218 firstMatchTest(219 "a(?:b|c)?d", input: "123adxyz", match: "ad")220 firstMatchTest(221 "a(?:b|c)?d", input: "123abdxyz", match: "abd")222 firstMatchTest(223 "a(?:b|c)?d", input: "123acdxyz", match: "acd")224 firstMatchTest(225 "a?b??c+d+?e*f*?", input: "123abcdefxyz", match: "abcde")226 firstMatchTest(227 "a?b??c+d+?e*f*?", input: "123bcddefxyz", match: "bcd")228 firstMatchTest(229 "a|b?c", input: "123axyz", match: "a")230 firstMatchTest(231 "a|b?c", input: "123bcxyz", match: "bc")232 firstMatchTest(233 "(a|b)c", input: "123abcxyz", match: "bc")234 // Alternations with empty branches are permitted.235 firstMatchTest("|", input: "ab", match: "")236 firstMatchTest("(|)", input: "ab", match: "")237 firstMatchTest("a|", input: "ab", match: "a")238 firstMatchTest("a|", input: "ba", match: "")239 firstMatchTest("|b", input: "ab", match: "")240 firstMatchTest("|b", input: "ba", match: "")241 firstMatchTest("|b|", input: "ab", match: "")242 firstMatchTest("|b|", input: "ba", match: "")243 firstMatchTest("a|b|", input: "ab", match: "a")244 firstMatchTest("a|b|", input: "ba", match: "b")245 firstMatchTest("a|b|", input: "ca", match: "")246 firstMatchTest("||c|", input: "ab", match: "")247 firstMatchTest("||c|", input: "cb", match: "")248 firstMatchTest("|||", input: "ab", match: "")249 firstMatchTest("a|||d", input: "bc", match: "")250 firstMatchTest("a|||d", input: "abc", match: "a")251 firstMatchTest("a|||d", input: "d", match: "")252 // MARK: Unicode scalars253 firstMatchTest(254 #"a\u0065b\u{00000065}c\x65d\U00000065"#,255 input: "123aebecedexyz", match: "aebecede")256 firstMatchTest(257 #"\u{00000000000000000000000000A}"#,258 input: "123\nxyz", match: "\n")259 firstMatchTest(260 #"\x{00000000000000000000000000A}"#,261 input: "123\nxyz", match: "\n")262 firstMatchTest(263 #"\o{000000000000000000000000007}"#,264 input: "123\u{7}xyz", match: "\u{7}")265 firstMatchTest(#"\o{70}"#, input: "1238xyz", match: "8")266 firstMatchTest(#"\0"#, input: "123\0xyz", match: "\0")267 firstMatchTest(#"\01"#, input: "123\u{1}xyz", match: "\u{1}")268 firstMatchTest(#"\070"#, input: "1238xyz", match: "8")269 firstMatchTest(#"\07A"#, input: "123\u{7}Axyz", match: "\u{7}A")270 firstMatchTest(#"\08"#, input: "123\08xyz", match: "\08")271 firstMatchTest(#"\0707"#, input: "12387\u{1C7}xyz", match: "\u{1C7}")272 // code point sequence273 firstMatchTest(#"\u{61 62 63}"#, input: "123abcxyz", match: "abc")274 firstMatchTest(#"3\u{ 61 62 63 }"#, input: "123abcxyz", match: "3abc")275 firstMatchTest(#"\u{61 62}\u{63}"#, input: "123abcxyz", match: "abc")276 firstMatchTest(#"\u{61}\u{62 63}"#, input: "123abcxyz", match: "abc")277 firstMatchTest(#"9|\u{61 62 63}"#, input: "123abcxyz", match: "abc")278 firstMatchTest(#"(?:\u{61 62 63})"#, input: "123abcxyz", match: "abc")279 firstMatchTest(#"23\u{61 62 63}xy"#, input: "123abcxyz", match: "23abcxy")280 // o + horn + dot_below281 firstMatchTest(282 #"\u{006f 031b 0323}"#,283 input: "\u{006f}\u{031b}\u{0323}",284 match: "\u{006f}\u{031b}\u{0323}"285 )286 // Escape sequences that represent scalar values.287 firstMatchTest(#"\a[\b]\e\f\n\r\t"#,288 input: "\u{7}\u{8}\u{1B}\u{C}\n\r\t",289 match: "\u{7}\u{8}\u{1B}\u{C}\n\r\t")290 firstMatchTest(#"[\a][\b][\e][\f][\n][\r][\t]"#,291 input: "\u{7}\u{8}\u{1B}\u{C}\n\r\t",292 match: "\u{7}\u{8}\u{1B}\u{C}\n\r\t")293 firstMatchTest(#"\r\n"#, input: "\r\n", match: "\r\n")294 // MARK: Quotes295 firstMatchTest(296 #"a\Q .\Eb"#,297 input: "123a .bxyz", match: "a .b")298 firstMatchTest(299 #"a\Q \Q \\.\Eb"#,300 input: #"123a \Q \\.bxyz"#, match: #"a \Q \\.b"#)301 firstMatchTest(302 #"\d\Q...\E"#,303 input: "Countdown: 3... 2... 1...", match: "3...")304 // MARK: Comments305 firstMatchTest(306 #"a(?#comment)b"#, input: "123abcxyz", match: "ab")307 firstMatchTest(308 #"a(?#. comment)b"#, input: "123abcxyz", match: "ab")309 }310 func testMatchQuantification() {311 // MARK: Quantification312 firstMatchTest(313 #"a{1,2}"#, input: "123aaaxyz", match: "aa")314 firstMatchTest(315 #"a{ 1 , 2 }"#, input: "123aaaxyz", match: "aa")316 firstMatchTest(317 #"a{,2}"#, input: "123aaaxyz", match: "")318 firstMatchTest(319 #"a{ , 2 }"#, input: "123aaaxyz", match: "")320 firstMatchTest(321 #"a{,2}x"#, input: "123aaaxyz", match: "aax")322 firstMatchTest(323 #"a{,2}x"#, input: "123xyz", match: "x")324 firstMatchTest(325 #"a{2,}"#, input: "123aaaxyz", match: "aaa")326 firstMatchTest(327 #"a{1}"#, input: "123aaaxyz", match: "a")328 firstMatchTest(329 #"a{ 1 }"#, input: "123aaaxyz", match: "a")330 firstMatchTest(331 #"a{1,2}?"#, input: "123aaaxyz", match: "a")332 firstMatchTest(333 #"a{1,2}?x"#, input: "123aaaxyz", match: "aax")334 firstMatchTest(335 #"xa{0}y"#, input: "123aaaxyz", match: "xy")336 firstMatchTest(337 #"xa{0,0}y"#, input: "123aaaxyz", match: "xy")338 firstMatchTest(339 #"(a|a){2}a"#, input: "123aaaxyz", match: "aaa")340 firstMatchTest(341 #"(a|a){3}a"#, input: "123aaaxyz", match: nil)342 firstMatchTest("a.*", input: "dcba", match: "a")343 firstMatchTest("a*", input: "", match: "")344 firstMatchTest("a*", input: "a", match: "a")345 firstMatchTest("a*", input: "aaa", match: "aaa")346 firstMatchTest("a*?", input: "", match: "")347 firstMatchTest("a*?", input: "a", match: "")348 firstMatchTest("a*?a", input: "aaa", match: "a")349 firstMatchTest("xa*?x", input: "_xx__", match: "xx")350 firstMatchTest("xa*?x", input: "_xax__", match: "xax")351 firstMatchTest("xa*?x", input: "_xaax__", match: "xaax")352 firstMatchTest("a+", input: "", match: nil)353 firstMatchTest("a+", input: "a", match: "a")354 firstMatchTest("a+", input: "aaa", match: "aaa")355 firstMatchTest("a+?", input: "", match: nil)356 firstMatchTest("a+?", input: "a", match: "a")357 firstMatchTest("a+?a", input: "aaa", match: "aa")358 firstMatchTest("xa+?x", input: "_xx__", match: nil)359 firstMatchTest("xa+?x", input: "_xax__", match: "xax")360 firstMatchTest("xa+?x", input: "_xaax__", match: "xaax")361 firstMatchTest("a??", input: "", match: "")362 firstMatchTest("a??", input: "a", match: "")363 firstMatchTest("a??a", input: "aaa", match: "a")364 firstMatchTest("xa??x", input: "_xx__", match: "xx")365 firstMatchTest("xa??x", input: "_xax__", match: "xax")366 firstMatchTest("xa??x", input: "_xaax__", match: nil)367 // Possessive .* will consume entire input368 firstMatchTests(369 ".*+x",370 ("abc", nil), ("abcx", nil), ("", nil))371 firstMatchTests(372 "a+b",373 ("abc", "ab"),374 ("aaabc", "aaab"),375 ("b", nil))376 firstMatchTests(377 "a++b",378 ("abc", "ab"),379 ("aaabc", "aaab"),380 ("b", nil))381 firstMatchTests(382 "a+?b",383 ("abc", "ab"),384 ("aaabc", "aaab"), // firstRange will match from front385 ("b", nil))386 firstMatchTests(387 "a+a",388 ("babc", nil),389 ("baaabc", "aaa"),390 ("bb", nil))391 firstMatchTests(392 "a++a",393 ("babc", nil),394 ("baaabc", nil),395 ("bb", nil),396 xfail: true)397 firstMatchTests(398 "a+?a",399 ("babc", nil),400 ("baaabc", "aa"),401 ("bb", nil))402 firstMatchTests(403 "a{2,4}a",404 ("babc", nil),405 ("baabc", nil),406 ("baaabc", "aaa"),407 ("baaaaabc", "aaaaa"),408 ("baaaaaaaabc", "aaaaa"),409 ("bb", nil))410 firstMatchTests(411 "a{,4}a",412 ("babc", "a"),413 ("baabc", "aa"),414 ("baaabc", "aaa"),415 ("baaaaabc", "aaaaa"),416 ("baaaaaaaabc", "aaaaa"),417 ("bb", nil))418 firstMatchTests(419 "a{2,}a",420 ("babc", nil),421 ("baabc", nil),422 ("baaabc", "aaa"),423 ("baaaaabc", "aaaaa"),424 ("baaaaaaaabc", "aaaaaaaa"),425 ("bb", nil))426 firstMatchTests(427 "a{2,4}?a",428 ("babc", nil),429 ("baabc", nil),430 ("baaabc", "aaa"),431 ("baaaaabc", "aaa"),432 ("baaaaaaaabc", "aaa"),433 ("bb", nil))434 firstMatchTests(435 "a{,4}?a",436 ("babc", "a"),437 ("baabc", "a"),438 ("baaabc", "a"),439 ("baaaaabc", "a"),440 ("baaaaaaaabc", "a"),441 ("bb", nil))442 firstMatchTests(443 "a{2,}?a",444 ("babc", nil),445 ("baabc", nil),446 ("baaabc", "aaa"),447 ("baaaaabc", "aaa"),448 ("baaaaaaaabc", "aaa"),449 ("bb", nil))450 firstMatchTests(451 "a{2,4}+a",452 ("babc", nil),453 ("baabc", nil),454 ("baaaaabc", "aaaaa"),455 ("baaaaaaaabc", "aaaaa"),456 ("bb", nil))457 firstMatchTests(458 "a{,4}+a",459 ("baaaaabc", "aaaaa"),460 ("baaaaaaaabc", "aaaaa"),461 ("bb", nil))462 firstMatchTests(463 "a{2,}+a",464 ("babc", nil),465 ("baabc", nil),466 ("bb", nil))467 468 // XFAIL'd versions of the above469 firstMatchTests(470 "a{2,4}+a",471 ("baaabc", nil),472 xfail: true)473 firstMatchTests(474 "a{,4}+a",475 ("babc", nil),476 ("baabc", nil),477 ("baaabc", nil),478 xfail: true)479 firstMatchTests(480 "a{2,}+a",481 ("baaabc", nil),482 ("baaaaabc", nil),483 ("baaaaaaaabc", nil),484 xfail: true)485 // XFAIL'd possessive tests486 firstMatchTests(487 "a?+a",488 ("a", nil),489 xfail: true)490 firstMatchTests(491 "(a|a)?+a",492 ("a", nil),493 xfail: true)494 firstMatchTests(495 "(a|a){2,4}+a",496 ("a", nil),497 ("aa", nil))498 firstMatchTests(499 "(a|a){2,4}+a",500 ("aaa", nil),501 ("aaaa", nil),502 xfail: true)503 firstMatchTests(504 "(?:a{2,4}?b)+",505 ("aab", "aab"),506 ("aabaabaab", "aabaabaab"),507 ("aaabaaaabaabab", "aaabaaaabaab")508 // TODO: Nested reluctant reentrant example, xfailed509 )510 // Reluctant by default - '*/+/.' and '*?/+?/.?' are swapped511 firstMatchTest("(?U)a*", input: "aaa", match: "")512 firstMatchTest("(?U)a*a", input: "aaa", match: "a")513 firstMatchTest("(?U)a*?", input: "aaa", match: "aaa")514 firstMatchTest("(?U)a*?a", input: "aaa", match: "aaa")515 firstMatchTest("(?U)a+", input: "aaa", match: "a")516 firstMatchTest("(?U)a+?", input: "aaa", match: "aaa")517 firstMatchTest("(?U)a?", input: "a", match: "")518 firstMatchTest("(?U)a?a", input: "aaa", match: "a")519 firstMatchTest("(?U)a??", input: "a", match: "a")520 firstMatchTest("(?U)a??a", input: "aaa", match: "aa")521 // TODO: After captures, easier to test these522 }523 func testMatchCharacterClasses() {524 // MARK: Character classes525 firstMatchTest(#"abc\d"#, input: "xyzabc123", match: "abc1")526 firstMatchTest(527 "[-|$^:?+*())(*-+-]", input: "123(abc)xyz", match: "(")528 firstMatchTest(529 "[-|$^:?+*())(*-+-]", input: "123-abcxyz", match: "-")530 firstMatchTest(531 "[-|$^:?+*())(*-+-]", input: "123^abcxyz", match: "^")532 firstMatchTest(533 "[a-b-c]", input: "123abcxyz", match: "a")534 firstMatchTest(535 "[a-b-c]", input: "123-abcxyz", match: "-")536 firstMatchTest("[-a-]", input: "123abcxyz", match: "a")537 firstMatchTest("[-a-]", input: "123-abcxyz", match: "-")538 firstMatchTest("[a-z]", input: "123abcxyz", match: "a")539 firstMatchTest("[a-z]", input: "123ABCxyz", match: "x")540 firstMatchTest("[a-z]", input: "123-abcxyz", match: "a")541 firstMatchTest("(?x)[ a - z ]+", input: " 123-abcxyz", match: "abcxyz")542 // Character class subtraction543 firstMatchTest("[a-d--a-c]", input: "123abcdxyz", match: "d")544 firstMatchTest("[-]", input: "123-abcxyz", match: "-")545 // These are metacharacters in certain contexts, but normal characters546 // otherwise.547 firstMatchTest(":-]", input: "123:-]xyz", match: ":-]")548 firstMatchTest(549 "[^abc]", input: "123abcxyz", match: "1")550 firstMatchTest(551 "[a^]", input: "123abcxyz", match: "a")552 firstMatchTest(553 #"\D\S\W"#, input: "123ab-xyz", match: "ab-")554 firstMatchTest(555 #"[\dd]"#, input: "xyzabc123", match: "1")556 firstMatchTest(557 #"[\dd]"#, input: "xyzabcd123", match: "d")558 firstMatchTest(559 #"[^[\D]]"#, input: "xyzabc123", match: "1")560 firstMatchTest(561 "[[ab][bc]]", input: "123abcxyz", match: "a")562 firstMatchTest(563 "[[ab][bc]]", input: "123cbaxyz", match: "c")564 firstMatchTest(565 "[[ab]c[de]]", input: "123abcxyz", match: "a")566 firstMatchTest(567 "[[ab]c[de]]", input: "123cbaxyz", match: "c")568 firstMatchTest(569 #"[ab[:space:]\d[:^upper:]cd]"#,570 input: "123abcxyz", match: "1")571 firstMatchTest(572 #"[ab[:space:]\d[:^upper:]cd]"#,573 input: "xyzabc123", match: "x")574 firstMatchTest(575 #"[ab[:space:]\d[:^upper:]cd]"#,576 input: "XYZabc123", match: "a")577 firstMatchTest(578 #"[ab[:space:]\d[:^upper:]cd]"#,579 input: "XYZ abc123", match: " ")580 firstMatchTest("[[[:space:]]]", input: "123 abc xyz", match: " ")581 firstMatchTest("[[:alnum:]]", input: "[[:alnum:]]", match: "a")582 firstMatchTest("[[:blank:]]", input: "123\tabc xyz", match: "\t")583 firstMatchTest(584 "[[:graph:]]",585 input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: "a")586 firstMatchTest(587 "[[:print:]]",588 input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: " ")589 firstMatchTest(590 "[[:word:]]",591 input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: "a")592 firstMatchTest(593 "[[:xdigit:]]",594 input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: "a")595 firstMatchTest("[[:isALNUM:]]", input: "[[:alnum:]]", match: "a")596 firstMatchTest("[[:AL_NUM:]]", input: "[[:alnum:]]", match: "a")597 firstMatchTest("[[:script=Greek:]]", input: "123αβγxyz", match: "α")598 func scalar(_ u: UnicodeScalar) -> UInt32 { u.value }599 for s in scalar("\u{C}") ... scalar("\u{1B}") {600 let u = UnicodeScalar(s)!601 firstMatchTest(#"[\f-\e]"#, input: "\u{B}\u{1C}\(u)", match: "\(u)")602 }603 for u: UnicodeScalar in ["\u{7}", "\u{8}"] {604 firstMatchTest(#"[\a-\b]"#, input: "\u{6}\u{9}\(u)", match: "\(u)")605 }606 for s in scalar("\u{A}") ... scalar("\u{D}") {607 let u = UnicodeScalar(s)!608 firstMatchTest(#"[\n-\r]"#, input: "\u{9}\u{E}\(u)", match: "\(u)")609 }610 firstMatchTest(#"[\t-\t]"#, input: "\u{8}\u{A}\u{9}", match: "\u{9}")611 // Currently not supported in the matching engine.612 for c: UnicodeScalar in ["a", "b", "c"] {613 firstMatchTest(#"[\c!-\C-#]"#, input: "def\(c)", match: "\(c)",614 xfail: true)615 }616 for c: UnicodeScalar in ["$", "%", "&", "'"] {617 firstMatchTest(#"[\N{DOLLAR SIGN}-\N{APOSTROPHE}]"#,618 input: "#()\(c)", match: "\(c)", xfail: true)619 }620 // MARK: Operators621 firstMatchTest(622 #"[a[bc]de&&[^bc]\d]+"#, input: "123bcdxyz", match: "d")623 // Empty intersection never matches, should this be a compile time error?624 // matchTest("[a&&b]", input: "123abcxyz", match: "")625 firstMatchTest(626 "[abc--def]", input: "123abcxyz", match: "a")627 // We left-associate for chained operators.628 firstMatchTest(629 "[ab&&b~~cd]", input: "123abcxyz", match: "b")630 firstMatchTest(631 "[ab&&b~~cd]", input: "123acdxyz", match: "c") // this doesn't match NSRegularExpression's behavior632 // Operators are only valid in custom character classes.633 firstMatchTest(634 "a&&b", input: "123a&&bcxyz", match: "a&&b")635 firstMatchTest(636 "&?", input: "123a&&bcxyz", match: "")637 firstMatchTest(638 "&&?", input: "123a&&bcxyz", match: "&&")639 firstMatchTest(640 "--+", input: "123---xyz", match: "---")641 firstMatchTest(642 "~~*", input: "123~~~xyz", match: "~~~")643 // Quotes in character classes.644 firstMatchTest(#"[\Qabc\E]"#, input: "QEa", match: "a")645 firstMatchTest(#"[\Qabc\E]"#, input: "cxx", match: "c")646 firstMatchTest(#"[\Qabc\E]+"#, input: "cba", match: "cba")647 firstMatchTest(#"[\Qa-c\E]+"#, input: "a-c", match: "a-c")648 firstMatchTest(#"["a-c"]+"#, input: "abc", match: "a",649 syntax: .experimental)650 firstMatchTest(#"["abc"]+"#, input: "cba", match: "cba",651 syntax: .experimental)652 firstMatchTest(#"["abc"]+"#, input: #""abc""#, match: "abc",653 syntax: .experimental)654 firstMatchTest(#"["abc"]+"#, input: #""abc""#, match: #""abc""#)655 }656 func testCharacterProperties() {657 // MARK: Character names.658 firstMatchTest(#"\N{ASTERISK}"#, input: "123***xyz", match: "*")659 firstMatchTest(#"[\N{ASTERISK}]"#, input: "123***xyz", match: "*")660 firstMatchTest(661 #"\N{ASTERISK}+"#, input: "123***xyz", match: "***")662 firstMatchTest(663 #"\N {2}"#, input: "123 xyz", match: "3 ", xfail: true)664 firstMatchTest(#"\N{U+2C}"#, input: "123,xyz", match: ",")665 firstMatchTest(#"\N{U+1F4BF}"#, input: "123💿xyz", match: "💿")666 firstMatchTest(#"\N{U+00001F4BF}"#, input: "123💿xyz", match: "💿")667 // MARK: Character properties.668 firstMatchTest(#"\p{L}"#, input: "123abcXYZ", match: "a")669 firstMatchTest(#"\p{gc=L}"#, input: "123abcXYZ", match: "a")670 firstMatchTest(#"\p{Lu}"#, input: "123abcXYZ", match: "X")671 // U+0374 GREEK NUMERAL SIGN (Lm)672 // U+00AA FEMININE ORDINAL INDICATOR (Lo)673 firstMatchTest(#"\p{L}"#, input: "\u{0374}\u{00AA}123abcXYZ", match: "\u{0374}")674 firstMatchTest(#"\p{Lc}"#, input: "\u{0374}\u{00AA}123abcXYZ", match: "a")675 firstMatchTest(#"\p{Lc}"#, input: "\u{0374}\u{00AA}123XYZ", match: "X")676 firstMatchTest(#"\p{L&}"#, input: "\u{0374}\u{00AA}123abcXYZ", match: "a")677 firstMatchTest(#"\p{L&}"#, input: "\u{0374}\u{00AA}123XYZ", match: "X")678 firstMatchTest(679 #"\P{Cc}"#, input: "\n\n\nXYZ", match: "X")680 firstMatchTest(681 #"\P{Z}"#, input: " XYZ", match: "X")682 firstMatchTest(#"[\p{C}]"#, input: "123\n\n\nXYZ", match: "\n")683 firstMatchTest(#"\p{C}+"#, input: "123\n\n\nXYZ", match: "\n\n\n")684 // UAX44-LM3 means all of the below are equivalent.685 firstMatchTest(#"\p{ll}"#, input: "123abcXYZ", match: "a")686 firstMatchTest(#"\p{gc=ll}"#, input: "123abcXYZ", match: "a")687 firstMatchTest(688 #"\p{General_Category=Ll}"#, input: "123abcXYZ", match: "a")689 firstMatchTest(690 #"\p{General-Category=isLl}"#,691 input: "123abcXYZ", match: "a")692 firstMatchTest(#"\p{ __l_ l _ }"#, input: "123abcXYZ", match: "a")693 firstMatchTest(694 #"\p{ g_ c =- __l_ l _ }"#, input: "123abcXYZ", match: "a")695 firstMatchTest(696 #"\p{ general ca-tegory = __l_ l _ }"#,697 input: "123abcXYZ", match: "a")698 firstMatchTest(699 #"\p{- general category = is__l_ l _ }"#,700 input: "123abcXYZ", match: "a")701 firstMatchTest(702 #"\p{ general category -= IS__l_ l _ }"#,703 input: "123abcXYZ", match: "a")704 firstMatchTest(#"\p{Any}"#, input: "123abcXYZ", match: "1")705 firstMatchTest(#"\p{Assigned}"#, input: "123abcXYZ", match: "1")706 firstMatchTest(#"\p{ascii}"#, input: "123abcXYZ", match: "1")707 firstMatchTest(#"\p{isAny}"#, input: "123abcXYZ", match: "1")708 firstMatchTest(#"\p{sc=grek}"#, input: "123αβγxyz", match: "α")709 firstMatchTest(#"\p{sc=isGreek}"#, input: "123αβγxyz", match: "α")710 firstMatchTest(#"\p{Greek}"#, input: "123αβγxyz", match: "α")711 firstMatchTest(#"\p{isGreek}"#, input: "123αβγxyz", match: "α")712 firstMatchTest(#"\P{Script=Latn}"#, input: "abcαβγxyz", match: "α")713 firstMatchTest(#"\p{script=Greek}"#, input: "123αβγxyz", match: "α")714 firstMatchTest(#"\p{ISscript=isGreek}"#, input: "123αβγxyz", match: "α")715 firstMatchTest(#"\p{scx=bamum}"#, input: "123ꚠꚡꚢxyz", match: "ꚠ")716 firstMatchTest(#"\p{ISBAMUM}"#, input: "123ꚠꚡꚢxyz", match: "ꚠ")717 firstMatchTest(#"\p{Script=Unknown}"#, input: "\u{10FFFF}", match: "\u{10FFFF}")718 firstMatchTest(#"\p{scx=Gujr}"#, input: "\u{a839}", match: "\u{a839}")719 firstMatchTest(#"\p{Gujr}"#, input: "\u{a839}", match: "\u{a839}")720 firstMatchTest(#"\p{alpha}"#, input: "123abcXYZ", match: "a")721 firstMatchTest(#"\P{alpha}"#, input: "123abcXYZ", match: "1")722 firstMatchTest(723 #"\p{alphabetic=True}"#, input: "123abcXYZ", match: "a")724 // This is actually available-ed...725 firstMatchTest(726 #"\p{emoji=t}"#, input: "123💿xyz", match: "a",727 xfail: true)728 firstMatchTest(#"\p{Alpha=no}"#, input: "123abcXYZ", match: "1")729 firstMatchTest(#"\P{Alpha=no}"#, input: "123abcXYZ", match: "a")730 firstMatchTest(#"\p{isAlphabetic}"#, input: "123abcXYZ", match: "a")731 firstMatchTest(732 #"\p{isAlpha=isFalse}"#, input: "123abcXYZ", match: "1")733 // Oniguruma special support not in stdlib734 firstMatchTest(735 #"\p{In_Runic}"#, input: "123ᚠᚡᚢXYZ", match: "ᚠ",736 xfail: true)737 // TODO: PCRE special738 firstMatchTest(739 #"\p{Xan}"#, input: "[[:alnum:]]", match: "a",740 xfail: true)741 firstMatchTest(742 #"\p{Xps}"#, input: "123 abc xyz", match: " ",743 xfail: true)744 firstMatchTest(745 #"\p{Xsp}"#, input: "123 abc xyz", match: " ",746 xfail: true)747 firstMatchTest(748 #"\p{Xuc}"#, input: "$var", match: "$",749 xfail: true)750 firstMatchTest(751 #"\p{Xwd}"#, input: "[[:alnum:]]", match: "a",752 xfail: true)753 firstMatchTest(#"\p{alnum}"#, input: "[[:alnum:]]", match: "a")754 firstMatchTest(#"\p{is_alnum}"#, input: "[[:alnum:]]", match: "a")755 firstMatchTest(#"\p{blank}"#, input: "123\tabc xyz", match: "\t")756 firstMatchTest(757 #"\p{graph}"#,758 input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: "a")759 firstMatchTest(760 #"\p{print}"#,761 input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: " ")762 firstMatchTest(763 #"\p{word}"#,764 input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: "a")765 firstMatchTest(766 #"\p{xdigit}"#,767 input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: "a")768 firstMatchTest("[[:alnum:]]", input: "[[:alnum:]]", match: "a")769 firstMatchTest("[[:blank:]]", input: "123\tabc xyz", match: "\t")770 firstMatchTest("[[:graph:]]",771 input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: "a")772 firstMatchTest("[[:print:]]",773 input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: " ")774 firstMatchTest("[[:word:]]",775 input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: "a")776 firstMatchTest("[[:xdigit:]]",777 input: "\u{7}\u{1b}\u{a}\n\r\t abc", match: "a")778 }779 func testAssertions() {780 // MARK: Assertions781 firstMatchTest(782 #"\d+(?= dollars)"#,783 input: "Price: 100 dollars", match: "100")784 firstMatchTest(785 #"\d+(?= pesos)"#,786 input: "Price: 100 dollars", match: nil)787 firstMatchTest(788 #"(?=\d+ dollars)\d+"#,789 input: "Price: 100 dollars", match: "100",790 xfail: true) // TODO791 firstMatchTest(792 #"\d+(*pla: dollars)"#,793 input: "Price: 100 dollars", match: "100")794 firstMatchTest(795 #"\d+(*positive_lookahead: dollars)"#,796 input: "Price: 100 dollars", match: "100")797 firstMatchTest(798 #"\d+(?! dollars)"#,799 input: "Price: 100 pesos", match: "100")800 firstMatchTest(801 #"\d+(?! dollars)"#,802 input: "Price: 100 dollars", match: "10")803 firstMatchTest(804 #"(?!\d+ dollars)\d+"#,805 input: "Price: 100 pesos", match: "100")806 firstMatchTest(807 #"\d+(*nla: dollars)"#,808 input: "Price: 100 pesos", match: "100")809 firstMatchTest(810 #"\d+(*negative_lookahead: dollars)"#,811 input: "Price: 100 pesos", match: "100")812 firstMatchTest(813 #"(?<=USD)\d+"#, input: "Price: USD100", match: "100", xfail: true)814 firstMatchTest(815 #"(*plb:USD)\d+"#, input: "Price: USD100", match: "100", xfail: true)816 firstMatchTest(817 #"(*positive_lookbehind:USD)\d+"#,818 input: "Price: USD100", match: "100", xfail: true)819 // engines generally enforce that lookbehinds are fixed width820 firstMatchTest(821 #"\d{3}(?<=USD\d{3})"#, input: "Price: USD100", match: "100", xfail: true)822 firstMatchTest(823 #"(?<!USD)\d+"#, input: "Price: JYP100", match: "100", xfail: true)824 firstMatchTest(825 #"(*nlb:USD)\d+"#, input: "Price: JYP100", match: "100", xfail: true)826 firstMatchTest(827 #"(*negative_lookbehind:USD)\d+"#,828 input: "Price: JYP100", match: "100", xfail: true)829 // engines generally enforce that lookbehinds are fixed width830 firstMatchTest(831 #"\d{3}(?<!USD\d{3})"#, input: "Price: JYP100", match: "100", xfail: true)832 }833 func testMatchAnchors() {834 // MARK: Anchors835 firstMatchTests(836 #"^\d+"#,837 ("123", "123"),838 (" 123", nil),839 ("123 456", "123"),840 (" 123 \n456", nil),841 (" \n123 \n456", nil))842 firstMatchTests(843 #"\d+$"#,844 ("123", "123"),845 (" 123", "123"),846 (" 123 \n456", "456"),847 (" 123\n456", "456"),848 ("123 456", "456"))849 firstMatchTests(850 #"\A\d+"#,851 ("123", "123"),852 (" 123", nil),853 (" 123 \n456", nil),854 (" 123\n456", nil),855 ("123 456", "123"))856 firstMatchTests(857 #"\d+\Z"#,858 ("123", "123"),859 (" 123", "123"),860 ("123\n", "123"),861 (" 123\n", "123"),862 (" 123 \n456", "456"),863 (" 123\n456", "456"),864 (" 123\n456\n", "456"),865 ("123 456", "456"))866 firstMatchTests(867 #"\d+\z"#,868 ("123", "123"),869 (" 123", "123"),870 ("123\n", nil),871 (" 123\n", nil),872 (" 123 \n456", "456"),873 (" 123\n456", "456"),874 (" 123\n456\n", nil),875 ("123 456", "456"))876 firstMatchTests(877 #"\d+\b"#,878 ("123", "123"),879 (" 123", "123"),880 ("123 456", "123"),881 ("123A 456", "456"))882 firstMatchTests(883 #"\d+\b\s\b\d+"#,884 ("123", nil),885 (" 123", nil),886 ("123 456", "123 456"))887 firstMatchTests(888 #"\B\d+"#,889 ("123", "23"),890 (" 123", "23"),891 ("123 456", "23"))892 // TODO: \G and \K893 // TODO: Oniguruma \y and \Y894 firstMatchTests(895 #"\u{65}"#, // Scalar 'e' is present in both896 ("Cafe\u{301}", nil), // but scalar mode requires boundary at end of match897 xfail: true)898 firstMatchTests(899 #"\u{65}"#, // Scalar 'e' is present in both900 ("Sol Cafe", "e")) // standalone is okay901 firstMatchTests(902 #"\u{65}\y"#, // Grapheme boundary assertion903 ("Cafe\u{301}", nil),904 ("Sol Cafe", "e"))905 906 // FIXME: Figure out (?X) and (?u) semantics907 firstMatchTests(908 #"(?u)\u{65}\Y"#, // Grapheme non-boundary assertion909 ("Cafe\u{301}", "e"),910 ("Sol Cafe", nil), xfail: true)911 }912 func testMatchGroups() {913 // MARK: Groups914 // Named captures915 firstMatchTest(916 #"a(?<label>b)c"#, input: "123abcxyz", match: "abc")917 firstMatchTest(918 #"a(?'label'b)c"#, input: "123abcxyz", match: "abc")919 firstMatchTest(920 #"a(?P<label>b)c"#, input: "123abcxyz", match: "abc")921 // Other groups922 firstMatchTest(923 #"a(?:b)c"#, input: "123abcxyz", match: "abc")924 firstMatchTest(925 "(?|(a)|(b)|(c))", input: "123abcxyz", match: "a", xfail: true)926 firstMatchTest(927 #"(?:a|.b)c"#, input: "123abcacxyz", match: "abc")928 firstMatchTest(929 #"(?>a|.b)c"#, input: "123abcacxyz", match: "ac", xfail: true)930 firstMatchTest(931 "(*atomic:a|.b)c", input: "123abcacxyz", match: "ac", xfail: true)932 firstMatchTest(933 #"(?:a+)[a-z]c"#, input: "123aacacxyz", match: "aac")934 firstMatchTest(935 #"(?>a+)[a-z]c"#, input: "123aacacxyz", match: "ac", xfail: true)936 // TODO: Test example where non-atomic is significant937 firstMatchTest(938 #"\d+(?* dollars)"#,939 input: "Price: 100 dollars", match: "100", xfail: true)940 firstMatchTest(941 #"(?*\d+ dollars)\d+"#,942 input: "Price: 100 dollars", match: "100", xfail: true)943 firstMatchTest(944 #"\d+(*napla: dollars)"#,945 input: "Price: 100 dollars", match: "100", xfail: true)946 firstMatchTest(947 #"\d+(*non_atomic_positive_lookahead: dollars)"#,948 input: "Price: 100 dollars", match: "100", xfail: true)949 // TODO: Test example where non-atomic is significant950 firstMatchTest(951 #"(?<*USD)\d+"#, input: "Price: USD100", match: "100", xfail: true)952 firstMatchTest(953 #"(*naplb:USD)\d+"#, input: "Price: USD100", match: "100", xfail: true)954 firstMatchTest(955 #"(*non_atomic_positive_lookbehind:USD)\d+"#,956 input: "Price: USD100", match: "100", xfail: true)957 // engines generally enforce that lookbehinds are fixed width958 firstMatchTest(959 #"\d{3}(?<*USD\d{3})"#, input: "Price: USD100", match: "100", xfail: true)960 // https://www.effectiveperlprogramming.com/2019/03/match-only-the-same-unicode-script/961 firstMatchTest(962 #"abc(*sr:\d+)xyz"#, input: "abc۵۲۸528੫੨੮xyz", match: "۵۲۸", xfail: true)963 firstMatchTest(964 #"abc(*script_run:\d+)xyz"#,965 input: "abc۵۲۸528੫੨੮xyz", match: "۵۲۸", xfail: true)966 // TODO: Test example where atomic is significant967 firstMatchTest(968 #"abc(*asr:\d+)xyz"#, input: "abc۵۲۸528੫੨੮xyz", match: "۵۲۸", xfail: true)969 firstMatchTest(970 #"abc(*atomic_script_run:\d+)xyz"#,971 input: "abc۵۲۸528੫੨੮xyz", match: "۵۲۸", xfail: true)972 }973 func testMatchCaptureBehavior() {974 flatCaptureTest(975 #"a(b)c|abe"#,976 ("abc", ["b"]),977 ("abe", [nil]),978 ("axbe", nil))979 flatCaptureTest(980 #"a(bc)d|abce"#,981 ("abcd", ["bc"]),982 ("abce", [nil]),983 ("abxce", nil))984 flatCaptureTest(985 #"a(bc)+d|abce"#,986 ("abcbcbcd", ["bc"]),987 ("abcbce", nil),988 ("abce", [nil]),989 ("abcbbd", nil))990 flatCaptureTest(991 #"a(bc)+d|(a)bce"#,992 ("abcbcbcd", ["bc", nil]),993 ("abce", [nil, "a"]),994 ("abcbbd", nil))995 flatCaptureTest(996 #"a(b|c)+d|(a)bce"#,997 ("abcbcbcd", ["c", nil]),998 ("abce", [nil, "a"]),999 ("abcbbd", ["b", nil]))1000 flatCaptureTest(1001 #"a(b+|c+)d|(a)bce"#,1002 ("abbbd", ["bbb", nil]),1003 ("acccd", ["ccc", nil]),1004 ("abce", [nil, "a"]),1005 ("abbbe", nil),1006 ("accce", nil),1007 ("abcbbd", nil))1008 flatCaptureTest(1009 #"(?:\w\1|:(\w):)+"#,1010 (":a:bacada", ["a"]),1011 (":a:baca:o:boco", ["o"]),1012 ("bacada", nil),1013 (":a:boco", ["a"]) // this matches only the ':a:' prefix1014 )1015 }1016 func testMatchReferences() {1017 firstMatchTest(1018 #"(.)\1"#,1019 input: "112", match: "11")1020 firstMatchTest(1021 #"(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)\10"#,1022 input: "aaaaaaaaabbc", match: "aaaaaaaaabb")1023 firstMatchTest(1024 #"(.)(.)(.)(.)(.)(.)(.)(.)(.)(?<a1>.)(?P=a1)"#,1025 input: "aaaaaaaaabbc", match: "aaaaaaaaabb")1026 firstMatchTest(1027 #"(.)\g001"#,1028 input: "112", match: "11")1029 firstMatchTest(#"(?<a>.)(.)\k<a>"#, input: "abac", match: "aba")1030 firstMatchTest(#"(?<a>.)(?<b>.)(?<c>.)\k<c>\k<a>\k<b>"#,1031 input: "xyzzxy", match: "xyzzxy")1032 firstMatchTest(#"\1(.)"#, input: "112", match: nil)1033 firstMatchTest(#"\k<a>(?<a>.)"#, input: "112", match: nil)1034 // TODO: Implement subpattern matching.1035 firstMatchTest(#"(.)(.)\g-02"#, input: "abac", match: "aba", xfail: true)1036 firstMatchTest(#"\g'+2'(.)(.)"#, input: "abac", match: "aba", xfail: true)1037 }1038 1039 func testMatchExamples() {1040 // Backreferences1041 matchTest(1042 #"(sens|respons)e and \1ibility"#,1043 ("sense and sensibility", true),1044 ("response and responsibility", true),1045 ("response and sensibility", false),1046 ("sense and responsibility", false))1047 matchTest(1048 #"a(?'name'b(c))d\1\2|abce"#,1049 ("abcdbcc", true),1050 ("abcdbc", false),1051 ("abce", true)1052 )1053 // Subpatterns1054 matchTest(1055 #"(sens|respons)e and (?1)ibility"#,1056 ("sense and sensibility", true),1057 ("response and responsibility", true),1058 ("response and sensibility", true),1059 ("sense and responsibility", true),1060 xfail: true)1061 // Palindromes1062 matchTest(1063 #"(\w)(?:(?R)|\w?)\1"#,1064 ("abccba", true),1065 ("abcba", true),1066 ("abba", true),1067 ("stackcats", true),1068 ("racecar", true),1069 ("a anna c", true), // OK: Partial match1070 ("abc", false),1071 ("cat", false),1072 xfail: true1073 )1074 matchTest(1075 #"^((\w)(?:(?1)|\w?)\2)$"#,1076 ("abccba", true),1077 ("abcba", true),1078 ("abba", true),1079 ("stackcats", true),1080 ("racecar", true),1081 ("a anna c", false), // FAIL: Not whole line1082 ("abc", false),1083 ("cat", false),1084 xfail: true1085 )1086 // HTML tags1087 matchTest(1088 #"<([a-zA-Z][a-zA-Z0-9]*)\b[^>]*>.*?</\1>"#,1089 ("<html> a b c </html>", true),1090 (#"<table style="float:right"> a b c </table>"#, true),1091 ("<html> a b c </htm>", false),1092 ("<htm> a b c </html>", false),1093 (#"<table style="float:right"> a b c </tab>"#, false)1094 )1095 // Doubled words1096 flatCaptureTest(1097 #"\b(\w+)\s+\1\b"#,1098 ("this does have one one in it", ["one"]),1099 ("pass me the the kettle", ["the"]),1100 ("this doesn't have any", nil)1101 )1102 // Floats1103 flatCaptureTest(1104 #"^([-+])?([0-9]*)(?:\.([0-9]+))?(?:[eE]([-+]?[0-9]+))?$"#,1105 ("123.45", [nil, "123", "45", nil]),1106 ("-123e12", ["-", "123", nil, "12"]),1107 ("+123.456E-12", ["+", "123", "456", "-12"]),1108 ("-123e1.2", nil)1109 )1110 }1111 1112 func testSingleLineMode() {1113 firstMatchTest(#".+"#, input: "a\nb", match: "a")1114 firstMatchTest(#"(?s:.+)"#, input: "a\nb", match: "a\nb")1115 }1116 1117 func testCaseSensitivity() {1118 matchTest(1119 #"c..e"#,1120 ("cafe", true),1121 ("Cafe", false))1122 matchTest(1123 #"(?i)c.f."#,1124 ("cafe", true),1125 ("Cafe", true),1126 ("caFe", true))1127 matchTest(1128 #"(?i)cafe"#,1129 ("cafe", true),1130 ("Cafe", true),1131 ("caFe", true))1132 matchTest(1133 #"(?i)café"#,1134 ("café", true),1135 ("CafÉ", true))1136 matchTest(1137 #"(?i)\u{63}af\u{e9}"#,1138 ("café", true),1139 ("CafÉ", true))1140 1141 matchTest(1142 #"[caFE]{4}"#,1143 ("cafe", false),1144 ("CAFE", false),1145 ("caFE", true),1146 ("EFac", true))1147 matchTest(1148 #"(?i)[caFE]{4}"#,1149 ("cafe", true),1150 ("CaFe", true),1151 ("EfAc", true))1152 matchTest(1153 #"(?i)[a-f]{4}"#,1154 ("cafe", true),1155 ("CaFe", true),1156 ("EfAc", true))1157 }1158 func testNonSemanticWhitespace() {1159 firstMatchTest(#" \t "#, input: " \t ", match: " \t ")1160 firstMatchTest(#"(?xx) \t "#, input: " \t ", match: "\t")1161 firstMatchTest(#"[ \t]+"#, input: " \t ", match: " \t ")1162 firstMatchTest(#"(?xx)[ \t]+"#, input: " \t ", match: "\t")1163 firstMatchTest(#"(?xx)[ \t]+"#, input: " \t\t ", match: "\t\t")1164 firstMatchTest(#"(?xx)[ \t]+"#, input: " \t \t", match: "\t")1165 firstMatchTest("(?xx)[ a && ab ]+", input: " aaba ", match: "aa")1166 1167 // Preserve whitespace in quoted section inside extended syntax region1168 firstMatchTest(1169 #"(?x) a b \Q c d \E e f"#, input: "ab c d ef", match: "ab c d ef")1170 firstMatchTest(1171 #"(?x)[a b]+ _ [a\Q b\E]+"#, input: "aba_ a b a", match: "aba_ a b a")1172 firstMatchTest(1173 #"(?x)[a b]+ _ [a\Q b\E]+"#, input: "aba _ a b a", match: nil)1174 }1175 1176 func testASCIIClasses() {1177 // 'D' ASCII-only digits1178 matchTest(1179 #"\d+"#,1180 ("123", true),1181 ("¹೨¾", true))1182 matchTest(1183 #"(?D)\d+"#,1184 ("123", true),1185 ("¹೨¾", false))1186 matchTest(1187 #"(?P)\d+"#,1188 ("123", true),1189 ("¹೨¾", false))1190 // 'W' ASCII-only word characters (and word boundaries)1191 matchTest(1192 #"\w+"#,1193 ("aeiou", true),1194 ("åe\u{301}ïôú", true))1195 matchTest(1196 #"(?W)\w+"#,1197 ("aeiou", true),1198 ("åe\u{301}ïôú", false))1199 matchTest(1200 #"(?P)\w+"#,1201 ("aeiou", true),1202 ("åe\u{301}ïôú", false))1203 matchTest(1204 #"abcd\b.+"#,1205 ("abcd ef", true),1206 ("abcdef", false),1207 ("abcdéf", false))1208 matchTest(1209 #"(?W)abcd\b.+"#,1210 ("abcd ef", true),1211 ("abcdef", false),1212 ("abcdéf", true)) // "dé" matches /d\b./ because "é" isn't ASCII1213 matchTest(1214 #"(?P)abcd\b.+"#,1215 ("abcd ef", true),1216 ("abcdef", false),1217 ("abcdéf", true)) // "dé" matches /d\b./ because "é" isn't ASCII1218 // 'S' ASCII-only spaces1219 matchTest(1220 #"a\sb"#,1221 ("a\tb", true),1222 ("a\u{202f}b", true)) // NARROW NO-BREAK SPACE1223 matchTest(1224 #"(?S)a\sb"#,1225 ("a\tb", true),1226 ("a\u{202f}b", false))1227 matchTest(1228 #"(?P)a\sb"#,1229 ("a\tb", true),1230 ("a\u{202f}b", false))1231 }1232 1233 func testAnchorMatching() throws {1234 let string = """1235 01: Alabama1236 02: Alaska1237 03: Arizona1238 04: Arkansas1239 05: California1240 """1241 XCTAssertTrue(string.contains(try Regex(#"^\d+"#)))1242 XCTAssertEqual(string.ranges(of: try Regex(#"^\d+"#)).count, 1)1243 XCTAssertEqual(string.ranges(of: try Regex(#"(?m)^\d+"#)).count, 5)1244 let regex = try Regex(#"^\d+: [\w ]+$"#)1245 XCTAssertFalse(string.contains(regex))1246 let allRanges = string.ranges(of: regex.anchorsMatchLineEndings())1247 XCTAssertEqual(allRanges.count, 5)1248 }1249 1250 func testMatchingOptionsScope() {1251 // `.` only matches newlines when the 's' option (single-line mode)1252 // is turned on. Standalone option-setting groups (e.g. `(?s)`) are1253 // scoped only to the current group.1254 1255 firstMatchTest(#"(?s)a.b"#, input: "a\nb", match: "a\nb")1256 firstMatchTest(#"((?s)a.)b"#, input: "a\nb", match: "a\nb")1257 firstMatchTest(#"(?-s)((?s)a.)b"#, input: "a\nb", match: "a\nb")1258 firstMatchTest(#"(?-s)(?s:a.)b"#, input: "a\nb", match: "a\nb")1259 firstMatchTest(#"((?s)a).b"#, input: "a\nb", match: nil)1260 firstMatchTest(#"((?s))a.b"#, input: "a\nb", match: nil)1261 firstMatchTest(#"(?:(?s))a.b"#, input: "a\nb", match: nil)1262 firstMatchTest(#"((?s)a(?s)).b"#, input: "a\nb", match: nil)1263 firstMatchTest(#"(?s)a(?-s).b"#, input: "a\nb", match: nil)1264 firstMatchTest(#"(?s)a(?-s:.b)"#, input: "a\nb", match: nil)1265 firstMatchTest(#"(?:(?s)a).b"#, input: "a\nb", match: nil)1266 firstMatchTest(#"(((?s)a)).b"#, input: "a\nb", match: nil)1267 firstMatchTest(#"(?s)(((?-s)a)).b"#, input: "a\nb", match: "a\nb")1268 firstMatchTest(#"(?s)((?-s)((?i)a)).b"#, input: "a\nb", match: "a\nb")1269 // Matching option changing persists across alternations.1270 firstMatchTest(#"a(?s)b|c|.d"#, input: "abc", match: "ab")1271 firstMatchTest(#"a(?s)b|c|.d"#, input: "c", match: "c")1272 firstMatchTest(#"a(?s)b|c|.d"#, input: "a\nd", match: "\nd")1273 firstMatchTest(#"a(?s)(?^)b|c|.d"#, input: "a\nd", match: nil)1274 firstMatchTest(#"a(?s)b|.c(?-s)|.d"#, input: "a\nd", match: nil)1275 firstMatchTest(#"a(?s)b|.c(?-s)|.d"#, input: "a\nc", match: "\nc")1276 firstMatchTest(#"a(?s)b|c(?-s)|(?^s).d"#, input: "a\nd", match: "\nd")1277 firstMatchTest(#"a(?:(?s).b)|.c|.d"#, input: "a\nb", match: "a\nb")1278 firstMatchTest(#"a(?:(?s).b)|.c"#, input: "a\nc", match: nil)1279 }1280 1281 func testOptionMethods() throws {1282 let regex = try Regex("c.f.")1283 XCTAssertTrue ("cafe".contains(regex))1284 XCTAssertFalse("CaFe".contains(regex))1285 1286 let caseInsensitiveRegex = regex.ignoresCase()1287 XCTAssertTrue("cafe".contains(caseInsensitiveRegex))1288 XCTAssertTrue("CaFe".contains(caseInsensitiveRegex))1289 }1290 1291 // MARK: Character Semantics1292 1293 var eComposed: String { "é" }1294 var eDecomposed: String { "e\u{301}" }1295 1296 func testIndividualScalars() {1297 // Expectation: A standalone Unicode scalar value in a regex literal1298 // can match either that specific scalar value or participate in matching1299 // as a character.1300 firstMatchTest(#"\u{65}\u{301}$"#, input: eDecomposed, match: eDecomposed)1301 firstMatchTest(#"\u{65}\u{301}$"#, input: eComposed, match: eComposed)1302 firstMatchTest(#"\u{65 301}$"#, input: eDecomposed, match: eDecomposed)1303 firstMatchTest(#"\u{65 301}$"#, input: eComposed, match: eComposed)1304 // FIXME: Implicit \y at end of match1305 firstMatchTest(#"\u{65}"#, input: eDecomposed, match: nil,1306 xfail: true)1307 firstMatchTest(#"\u{65}$"#, input: eDecomposed, match: nil)1308 // FIXME: \y is unsupported1309 firstMatchTest(#"\u{65}\y"#, input: eDecomposed, match: nil,1310 xfail: true)1311 // FIXME: Unicode scalars are only matched at the start of a grapheme cluster1312 firstMatchTest(#"\u{301}"#, input: eDecomposed, match: "\u{301}",1313 xfail: true)1314 // FIXME: \y is unsupported1315 firstMatchTest(#"\y\u{301}"#, input: eDecomposed, match: nil,1316 xfail: true)1317 }1318 func testCanonicalEquivalence() throws {1319 // Expectation: Matching should use canonical equivalence whenever comparing1320 // characters, so a user can write characters using any equivalent spelling1321 // in either a regex literal or the string targeted for matching.1322 1323 matchTest(1324 #"é$"#,1325 (eComposed, true),1326 (eDecomposed, true))1327 matchTest(1328 #"e\u{301}$"#,1329 (eComposed, true),1330 (eDecomposed, true))1331 matchTest(1332 #"e$"#,1333 (eComposed, false),1334 (eDecomposed, false))1335 }1336 func testCanonicalEquivalenceCharacterClass() throws {1337 // Expectation: Character classes should match equivalent characters to the1338 // same degree, regardless of how they are spelled. Unicode "property1339 // classes" should match characters when all the code points that comprise1340 // the character are members of the property class.1341 1342 // \w1343 matchTest(1344 #"^\w$"#,1345 (eComposed, true),1346 (eDecomposed, true))1347 // \p{Letter}1348 firstMatchTest(#"\p{Letter}$"#, input: eComposed, match: eComposed)1349 firstMatchTest(#"\p{Letter}$"#, input: eDecomposed, match: eDecomposed)1350 1351 // \d1352 firstMatchTest(#"\d"#, input: "5", match: "5")1353 // FIXME: \d shouldn't match a digit composed with a non-digit character1354 firstMatchTest(#"\d"#, input: "5\u{305}", match: nil,1355 xfail: true)1356 // \p{Number}1357 firstMatchTest(#"\p{Number}"#, input: "5", match: "5")1358 // FIXME: \p{Number} shouldn't match a number composed with a non-number character1359 firstMatchTest(#"\p{Number}"#, input: "5\u{305}", match: nil,1360 xfail: true)1361 1362 // Should this match the '5' but not the ZWJ, or should it treat '5'+ZWJ1363 // as one entity and fail to match altogether?1364 firstMatchTest(#"^\d"#, input: "5\u{200d}0", match: "5",1365 xfail: true)1366 1367 // \s1368 firstMatchTest(#"\s"#, input: " ", match: " ")1369 // FIXME: \s shouldn't match a number composed with a non-number character1370 firstMatchTest(#"\s\u{305}"#, input: " ", match: nil,1371 xfail: true)1372 // \p{Whitespace}1373 firstMatchTest(#"\s"#, input: " ", match: " ")1374 // FIXME: \p{Whitespace} shouldn't match whitespace composed with a non-whitespace character1375 firstMatchTest(#"\s\u{305}"#, input: " ", match: nil,1376 xfail: true)1377 }1378 1379 func testCanonicalEquivalenceCustomCharacterClass() throws {1380 // Expectation: Concatenations with custom character classes should be able1381 // to match within a grapheme cluster. That is, a regex should be able to1382 // match the scalar values that comprise a grapheme cluster in separate,1383 // or repeated, custom character classes.1384 1385 matchTest(1386 #"[áéíóú]$"#,1387 (eComposed, true),1388 (eDecomposed, true))1389 // FIXME: Custom char classes don't use canonical equivalence with composed characters1390 firstMatchTest(#"e[\u{301}]$"#, input: eComposed, match: eComposed,1391 xfail: true)1392 firstMatchTest(#"e[\u{300}-\u{320}]$"#, input: eComposed, match: eComposed,1393 xfail: true)1394 firstMatchTest(#"[a-z][\u{300}-\u{320}]$"#, input: eComposed, match: eComposed,1395 xfail: true)1396 // FIXME: Custom char classes don't match decomposed characters1397 firstMatchTest(#"e[\u{301}]$"#, input: eDecomposed, match: eDecomposed,1398 xfail: true)1399 firstMatchTest(#"e[\u{300}-\u{320}]$"#, input: eDecomposed, match: eDecomposed,1400 xfail: true)1401 firstMatchTest(#"[a-z][\u{300}-\u{320}]$"#, input: eDecomposed, match: eDecomposed,1402 xfail: true)1403 let flag = "🇰🇷"1404 firstMatchTest(#"🇰🇷"#, input: flag, match: flag)1405 firstMatchTest(#"[🇰🇷]"#, input: flag, match: flag)1406 firstMatchTest(#"\u{1F1F0}\u{1F1F7}"#, input: flag, match: flag)1407 firstMatchTest(#"\u{1F1F0 1F1F7}"#, input: flag, match: flag)1408 // First Unicode scalar followed by CCC of regional indicators1409 firstMatchTest(#"\u{1F1F0}[\u{1F1E6}-\u{1F1FF}]"#, input: flag, match: flag,1410 xfail: true)1411 // FIXME: CCC of Regional Indicator doesn't match with both parts of a flag character1412 // A CCC of regional indicators x 21413 firstMatchTest(#"[\u{1F1E6}-\u{1F1FF}]{2}"#, input: flag, match: flag,1414 xfail: true)1415 // FIXME: A single CCC of regional indicators matches the whole flag character1416 // A CCC of regional indicators followed by the second Unicode scalar1417 firstMatchTest(#"[\u{1F1E6}-\u{1F1FF}]\u{1F1F7}"#, input: flag, match: flag,1418 xfail: true)1419 // A single CCC of regional indicators1420 firstMatchTest(#"[\u{1F1E6}-\u{1F1FF}]"#, input: flag, match: nil,1421 xfail: true)1422 1423 // A single CCC of actual flag emojis / combined regional indicators1424 firstMatchTest(#"[🇦🇫-🇿🇼]"#, input: flag, match: flag)1425 // This succeeds (correctly) because \u{1F1F0} is lexicographically1426 // within the CCC range1427 firstMatchTest(#"[🇦🇫-🇿🇼]"#, input: "\u{1F1F0}abc", match: "\u{1F1F0}")1428 }1429 1430 func testAnyChar() throws {1431 // Expectation: \X and, in grapheme cluster mode, `.` should consume an1432 // entire character, regardless of how it's spelled. \O should consume only1433 // a single Unicode scalar value, leaving any other grapheme scalar1434 // components to be matched.1435 1436 // FIXME: Figure out (?X) and (?u) semantics1437 firstMatchTest(#"(?u:.)"#, input: eDecomposed, match: "e", xfail: true)1438 matchTest(1439 #".\u{301}"#,1440 (eComposed, false),1441 (eDecomposed, false))1442 matchTest(1443 #"\X\u{301}"#,1444 (eComposed, false),1445 (eDecomposed, false))1446 1447 // FIXME: Figure out (?X) and (?u) semantics1448 // FIXME: \O is unsupported1449 firstMatchTest(1450 #"(?u)\O\u{301}"#,1451 input: eDecomposed,1452 match: eDecomposed,1453 xfail: true1454 )1455 firstMatchTest(1456 #"(?u)e\O"#,1457 input: eDecomposed,1458 match: eDecomposed,1459 xfail: true1460 )1461 firstMatchTest(#"\O"#, input: eComposed, match: eComposed)1462 firstMatchTest(#"\O"#, input: eDecomposed, match: nil,1463 xfail: true)1464 // FIXME: Figure out (?X) and (?u) semantics1465 matchTest(1466 #"(?u).\u{301}"#,1467 (eComposed, false),1468 (eDecomposed, true), xfail: true)1469 firstMatchTest(#"(?u).$"#, input: eComposed, match: eComposed, xfail: true)1470 1471 // Option permutations for 'u' and 's'1472 matchTest(1473 #"...."#,1474 ("e\u{301}ab", false),1475 ("e\u{301}abc", true),1476 ("e\u{301}\nab", false))1477 matchTest(1478 #"(?s)...."#,1479 ("e\u{301}ab", false),1480 ("e\u{301}abc", true),1481 ("e\u{301}\nab", true))1482 1483 // FIXME: Figure out (?X) and (?u) semantics...

Full Screen

Full Screen

GameViewModelTest.swift

Source:GameViewModelTest.swift Github

copy

Full Screen

1//2// RPSLSTests.swift3// RPSLSTests4//5// Created by Mark Christian Buot on 12/08/2019.6// Copyright © 2019 Mark Christian Buot. All rights reserved.7//8import XCTest9@testable import RPSLS10enum MoveEnum: Int {11 case Rock = 012 case Paper13 case Scissors14 case Lizard15 case Spock16}17enum TestCase {18 19 case ResultDriven20 case ScoreDriven21}22class GameViewModelTest: XCTestCase {23 var gameManager: MockGameManager?24 var gameMode: GameMode?25 var viewModel: GameViewModel?26 var testCase: TestCase?27 var expectedResult: GameManager.GameResult?28 29 override func setUp() {30 // Put setup code here. This method is called before the invocation of each test method in the class.31 }32 override func tearDown() {33 // Put teardown code here. This method is called after the invocation of each test method in the class.34 }35 func createDependency(game: GameMode.Game) {36 gameMode = GameMode(playType: .PVC)37 gameMode?.game = game38 gameManager = MockGameManager(gameMode: gameMode)39 viewModel = ViewModelFactory.createGameViewModel(gameManager: gameManager,40 gameMode: gameMode,41 delegate: self)42 }43 44 func matchTest(computer: Move?,45 index: Int,46 expectedResult: GameManager.GameResult) {47 self.testCase = .ResultDriven48 self.expectedResult = expectedResult49 gameManager?.mockMove = computer50 51 viewModel?.setMoveAt(IndexPath(row: index,52 section: 0))53 54 viewModel?.match()55 }56 57 func testRPSRock() {58 createDependency(game: .RPS)59 60 matchTest(computer: gameManager?.createScissors(),61 index: MoveEnum.Rock.rawValue,62 expectedResult: .Win)63 }64 65 func testRPSPaper() {66 createDependency(game: .RPS)67 68 matchTest(computer: gameManager?.createRock(),69 index: MoveEnum.Paper.rawValue,70 expectedResult: .Win)71 }72 73 func testRPSScissors() {74 createDependency(game: .RPS)75 76 matchTest(computer: gameManager?.createPaper(),77 index: MoveEnum.Scissors.rawValue,78 expectedResult: .Win)79 }80 81 func testRPSLSLizard() {82 createDependency(game: .RPSLS)83 84 matchTest(computer: gameManager?.createSpock(),85 index: MoveEnum.Lizard.rawValue,86 expectedResult: .Win)87 }88 89 func testRPSLSSpock() {90 createDependency(game: .RPSLS)91 92 matchTest(computer: gameManager?.createScissors(),93 index: MoveEnum.Spock.rawValue,94 expectedResult: .Win)95 }96 97 func testRPSRockDraw() {98 createDependency(game: .RPS)99 100 matchTest(computer: gameManager?.createRock(),101 index: MoveEnum.Rock.rawValue,102 expectedResult: .Draw)103 }104 105 func testRPSPaperDraw() {106 createDependency(game: .RPS)107 108 matchTest(computer: gameManager?.createPaper(),109 index: MoveEnum.Paper.rawValue,110 expectedResult: .Draw)111 }112 113 func testRPSScissorsDraw() {114 createDependency(game: .RPS)115 116 matchTest(computer: gameManager?.createScissors(),117 index: MoveEnum.Scissors.rawValue,118 expectedResult: .Draw)119 }120 121 func testRPSLSLizardDraw() {122 createDependency(game: .RPSLS)123 124 matchTest(computer: gameManager?.createLizard(),125 index: MoveEnum.Lizard.rawValue,126 expectedResult: .Draw)127 }128 129 func testRPSLSSpockDraw() {130 createDependency(game: .RPSLS)131 132 matchTest(computer: gameManager?.createSpock(),133 index: MoveEnum.Spock.rawValue,134 expectedResult: .Draw)135 }136 137 func testRPSRockLose() {138 createDependency(game: .RPS)139 140 matchTest(computer: gameManager?.createPaper(),141 index: MoveEnum.Rock.rawValue,142 expectedResult: .Lose)143 }144 145 func testRPSPaperLose() {146 createDependency(game: .RPS)147 148 matchTest(computer: gameManager?.createScissors(),149 index: MoveEnum.Paper.rawValue,150 expectedResult: .Lose)151 }152 153 func testRPSScissorsLose() {154 createDependency(game: .RPS)155 156 matchTest(computer: gameManager?.createRock(),157 index: MoveEnum.Scissors.rawValue,158 expectedResult: .Lose)159 }160 161 func testRPSLSLizardLose() {162 createDependency(game: .RPSLS)163 164 matchTest(computer: gameManager?.createRock(),165 index: MoveEnum.Lizard.rawValue,166 expectedResult: .Lose)167 }168 169 func testRPSLSSpockLose() {170 createDependency(game: .RPSLS)171 172 matchTest(computer: gameManager?.createLizard(),173 index: MoveEnum.Spock.rawValue,174 expectedResult: .Lose)175 }176 177 func testRPSLSPaperVsLizard() {178 createDependency(game: .RPSLS)179 180 matchTest(computer: gameManager?.createLizard(),181 index: MoveEnum.Paper.rawValue,182 expectedResult: .Lose)183 }184 185 func testRPSLSScissorsVsSpock() {186 createDependency(game: .RPSLS)187 188 matchTest(computer: gameManager?.createSpock(),189 index: MoveEnum.Scissors.rawValue,190 expectedResult: .Lose)191 }192 193 func testScoreComputer() {194 createDependency(game: .RPS)195 196 testCase = .ScoreDriven197 gameManager?.mockMove = gameManager?.createPaper()198 199 viewModel?.setMoveAt(IndexPath(row: MoveEnum.Rock.rawValue,200 section: 0))201 202 viewModel?.match()203 }204}205extension GameViewModelTest: BaseViewModelDelegate {206 func didUpdateViewmodel(_ viewModel: BaseViewModel) {207 let result = self.viewModel?.getResult()208 if testCase == .ResultDriven {209 XCTAssert(result == expectedResult, "Should win")210 } else {211 if result == .Lose {212 XCTAssert(gameManager?.score.computer == 1,213 "Computer should score 1 after winning")214 } else {215 XCTFail("Should be lose")216 }217 }218 }219}...

Full Screen

Full Screen

EncodableRule.swift

Source:EncodableRule.swift Github

copy

Full Screen

...8import Foundation9fileprivate enum EncoderKeys: String {10 case BrowserIdentifier = "browserIdentifier"11 case MatchType = "match.type"12 case MatchTest = "match.test"13}14@objc(RedirectionDataEncodableRule)15public class EncodableRule : NSObject, NSCoding {16 public let rule: Rule17 public init(_ rule: Rule) {18 self.rule = rule19 }20 required public init?(coder aDecoder: NSCoder) {21 guard22 let browserIdentifier = aDecoder.decodeObject(of: NSString.self, forKey: EncoderKeys.BrowserIdentifier.rawValue) as String?,23 let matchTypeValue = aDecoder.decodeObject(of: NSNumber.self, forKey: EncoderKeys.MatchType.rawValue) as? Int,24 let matchType = MatchType(rawValue: matchTypeValue),25 let matchTest = aDecoder.decodeObject(of: NSString.self, forKey: EncoderKeys.MatchTest.rawValue) as String?26 else { return nil }27 self.rule = Rule(browserIdentifier: BundleIdentifier(value: browserIdentifier), match: Match(type: matchType, test: matchTest))28 }29 public func encode(with aCoder: NSCoder) {30 aCoder.encode(rule.browserIdentifier.value as NSString, forKey: EncoderKeys.BrowserIdentifier.rawValue)31 aCoder.encode(rule.match.type.rawValue, forKey: EncoderKeys.MatchType.rawValue)32 aCoder.encode(rule.match.test as NSString, forKey: EncoderKeys.MatchTest.rawValue)33 }34}35extension EncodableRule : NSSecureCoding {36 public static var supportsSecureCoding: Bool { return true }37}

Full Screen

Full Screen

MatchTest

Using AI Code Generation

copy

Full Screen

1import Nimble2import Quick3class MatchTestSpec: QuickSpec {4 override func spec() {5 describe("MatchTest") {6 it("should return true") {7 let matchTest = MatchTest()8 expect(matchTest.isMatch("abc", "abc")).to(beTrue())9 }10 }11 }12}13import Nimble14import Quick15class MatchTestSpec: QuickSpec {16 override func spec() {17 describe("MatchTest") {18 it("should return false") {19 let matchTest = MatchTest()20 expect(matchTest.isMatch("abc", "ab")).to(beFalse())21 }22 }23 }24}25import Nimble26import Quick27class MatchTestSpec: QuickSpec {28 override func spec() {29 describe("MatchTest") {30 it("should return true") {31 let matchTest = MatchTest()32 expect(matchTest.isMatch("abc", "a.c")).to(beTrue())33 }34 }35 }36}37import Nimble38import Quick39class MatchTestSpec: QuickSpec {40 override func spec() {41 describe("MatchTest") {42 it("should return true") {43 let matchTest = MatchTest()44 expect(matchTest.isMatch("abc", "ab*")).to(beTrue())45 }46 }47 }48}49import Nimble50import Quick51class MatchTestSpec: QuickSpec {52 override func spec() {53 describe("MatchTest") {54 it("should return true") {55 let matchTest = MatchTest()56 expect(matchTest.isMatch("abc", ".*")).to(beTrue())57 }58 }59 }60}61import Nimble62import Quick63class MatchTestSpec: QuickSpec {64 override func spec() {65 describe("MatchTest") {66 it("should return true") {67 let matchTest = MatchTest()68 expect(matchTest.isMatch("abc", ".*c")).to(beTrue())69 }70 }71 }72}

Full Screen

Full Screen

MatchTest

Using AI Code Generation

copy

Full Screen

1import Nimble2import Quick3class MatchTest: QuickSpec {4 override func spec() {5 describe("MatchTest") {6 it("matches") {7 expect(1).to(match(1))8 }9 }10 }11}12import Quick13import Nimble14class MatchTest: QuickSpec {15 override func spec() {16 describe("MatchTest") {17 it("matches") {18 expect(1).to(match(1))19 }20 }21 }22}23import Quick24import Nimble25class MatchTest: QuickSpec {26 override func spec() {27 describe("MatchTest") {28 it("matches") {29 expect(1).to(match(1))30 }31 }32 }33}34import Quick35import Nimble36class MatchTest: QuickSpec {37 override func spec() {38 describe("MatchTest") {39 it("matches") {40 expect(1).to(match(1))41 }42 }43 }44}45import Quick46import Nimble47class MatchTest: QuickSpec {48 override func spec() {49 describe("MatchTest") {50 it("matches") {51 expect(1).to(match(1))52 }53 }54 }55}56import Quick57import Nimble58class MatchTest: QuickSpec {59 override func spec() {60 describe("MatchTest") {61 it("matches") {62 expect(1).to(match(1))63 }64 }65 }66}67import Quick68import Nimble69class MatchTest: QuickSpec {70 override func spec() {71 describe("MatchTest") {72 it("matches") {73 expect(1).to(match(1))74 }75 }76 }77}78import Quick79import Nimble80class MatchTest: QuickSpec {81 override func spec() {82 describe("MatchTest") {

Full Screen

Full Screen

MatchTest

Using AI Code Generation

copy

Full Screen

1import Nimble2import Quick3class MatchTest: QuickSpec {4 override func spec() {5 describe("MatchTest") {6 it("should match") {7 expect(1).to(match(1))8 }9 }10 }11}12import Nimble13import Quick14class MatchTest: QuickSpec {15 override func spec() {16 describe("MatchTest") {17 it("should match") {18 expect(1).to(match(1))19 }20 }21 }22}23import Nimble24import Quick25class MatchTest: QuickSpec {26 override func spec() {27 describe("MatchTest") {28 it("should match") {29 expect(1).to(match(1))30 }31 }32 }33}34import Nimble35import Quick36class MatchTest: QuickSpec {37 override func spec() {38 describe("MatchTest") {39 it("should match") {40 expect(1).to(match(1))41 }42 }43 }44}45import Nimble46import Quick47class MatchTest: QuickSpec {48 override func spec() {49 describe("MatchTest") {50 it("should match") {51 expect(1).to(match(1))52 }53 }54 }55}56import Nimble57import Quick58class MatchTest: QuickSpec {59 override func spec() {60 describe("MatchTest") {61 it("should match") {62 expect(1).to(match(1))63 }64 }65 }66}67import Nimble68import Quick69class MatchTest: QuickSpec {70 override func spec() {71 describe("MatchTest") {72 it("should match") {73 expect(1).to(match(1))74 }75 }76 }77}78import Nimble79import Quick

Full Screen

Full Screen

MatchTest

Using AI Code Generation

copy

Full Screen

1import Nimble2import Quick3class MatchTest: QuickSpec {4 override func spec() {5 describe("match") {6 it("matches") {7 expect("abc").to(match("abc"))8 }9 }10 }11}12import Quick13import Nimble14class MatchTest: QuickSpec {15 override func spec() {16 describe("match") {17 it("matches") {18 expect("abc").to(match("abc"))19 }20 }21 }22}23I have the same problem, but it doesn't work for me. I have tried to change the order of the imports, but it didn't work. Then, I have

Full Screen

Full Screen

MatchTest

Using AI Code Generation

copy

Full Screen

1import Nimble2import Quick3import XCTest4class TestClass: QuickSpec {5 override func spec() {6 describe("matchTest") {7 it("test") {8 expect(1).to(matchTest())9 }10 }11 }12}13class MatchTest: MatcherFunc<Int> {14 override func matches(_ actualExpression: Expression<Int>, failureMessage: FailureMessage) -> Bool {15 }16}17import Nimble18import Quick19import XCTest20class TestClass: QuickSpec {21 override func spec() {22 describe("matchTest") {23 it("test") {24 expect(1).to(matchTest())25 }26 }27 }28}29class MatchTest: MatcherFunc<Int> {30 override func matches(_ actualExpression: Expression<Int>, failureMessage: FailureMessage) -> Bool {31 }32}33import Nimble34import Quick35import XCTest36class TestClass: QuickSpec {37 override func spec() {38 describe("matchTest") {39 it("test") {40 expect(1).to(matchTest())41 }42 }43 }44}45class MatchTest: MatcherFunc<Int> {46 override func matches(_ actualExpression: Expression<Int>, failureMessage: FailureMessage) -> Bool {47 }48}49import Nimble50import Quick51import XCTest52class TestClass: QuickSpec {53 override func spec() {54 describe("matchTest") {55 it("test") {56 expect(1).to(matchTest())57 }58 }59 }60}61class MatchTest: MatcherFunc<Int> {62 override func matches(_ actualExpression: Expression<Int>, failureMessage: FailureMessage) -> Bool {63 }64}65import Nimble66import Quick67import XCTest68class TestClass: QuickSpec {69 override func spec() {70 describe("matchTest") {71 it("test") {72 expect(1).to(matchTest())73 }74 }75 }76}77class MatchTest: MatcherFunc<Int> {78 override func matches(_ actualExpression: Expression<Int>, failure

Full Screen

Full Screen

MatchTest

Using AI Code Generation

copy

Full Screen

1import Nimble2import Quick3class MatchTest: QuickSpec {4 override func spec() {5 describe("Match Test") {6 it("should check if the string matches the regex") {7 expect("Hello World").to(match("Hello World"))8 }9 }10 }11}12import Nimble13import Quick14class MatchTest: QuickSpec {15 override func spec() {16 describe("Match Test") {17 it("should check if the string matches the regex") {18 expect("Hello World").to(match("Hello World"))19 }20 }21 }22}23import Nimble24import Quick25class MatchTest: QuickSpec {26 override func spec() {27 describe("Match Test") {28 it("should check if the string matches the regex") {29 expect("Hello World").to(match("Hello World"))30 }31 }32 }33}34import Nimble35import Quick36class MatchTest: QuickSpec {37 override func spec() {38 describe("Match Test") {39 it("should check if the string matches the regex") {40 expect("Hello World").to(match("Hello World"))41 }42 }43 }44}45import Nimble46import Quick47class MatchTest: QuickSpec {48 override func spec() {49 describe("Match Test") {50 it("should check if the string matches the regex") {51 expect("Hello World").to(match("Hello World"))52 }53 }54 }55}56import Nimble57import Quick58class MatchTest: QuickSpec {59 override func spec() {60 describe("Match Test") {61 it("should check if the string matches the regex") {62 expect("Hello World").to(match("Hello World"))63 }64 }65 }66}67import Nimble68import Quick69class MatchTest: QuickSpec {70 override func spec() {71 describe("Match Test") {72 it("should check if the string matches

Full Screen

Full Screen

MatchTest

Using AI Code Generation

copy

Full Screen

1import Nimble2import Quick3class MatchTest: QuickSpec {4 override func spec() {5 describe("Match Test") {6 it("should be able to use match test") {7 expect(str1).to(match(str2))8 }9 }10 }11}12import Nimble13import Quick14class MatchTest: QuickSpec {15 override func spec() {16 describe("Match Test") {17 it("should be able to use match test") {18 expect(str1).to(match(str2))19 }20 }21 }22}23import Nimble24import Quick25class NimbleMatchTest: QuickSpec {26 override func spec() {27 describe("Match Test") {28 it("should be able to use match test") {29 expect(str1).to(match(str2))30 }31 }32 }33}34import Nimble35import Quick36class QuickMatchTest: QuickSpec {37 override func spec() {38 describe("Match Test") {39 it("should be able to use match test") {40 expect(str1).to(match(str2))41 }42 }43 }44}

Full Screen

Full Screen

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run Nimble automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

... View sample repo... View DocumentationSign up Free
›
_

Most used methods in MatchTest

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

...
Sign up with GoogleSign up with Email
Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful