diff options
Diffstat (limited to 'fluent-bit/lib/onigmo/testpy.py')
| -rwxr-xr-x | fluent-bit/lib/onigmo/testpy.py | 1776 |
1 files changed, 0 insertions, 1776 deletions
diff --git a/fluent-bit/lib/onigmo/testpy.py b/fluent-bit/lib/onigmo/testpy.py deleted file mode 100755 index 7223886f0..000000000 --- a/fluent-bit/lib/onigmo/testpy.py +++ /dev/null @@ -1,1776 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -from __future__ import print_function, unicode_literals -import ctypes -import onigmo -import sys -import io -import locale - -nerror = 0 -nsucc = 0 -nfail = 0 - -# default encoding -onig_encoding = onigmo.ONIG_ENCODING_EUC_JP - -# special syntactic settings -syntax_default = ctypes.byref(onigmo.OnigSyntaxType()) -onigmo.onig_copy_syntax(syntax_default, onigmo.ONIG_SYNTAX_DEFAULT) -onigmo.onig_set_syntax_options(syntax_default, - onigmo.onig_get_syntax_options(syntax_default) - & ~onigmo.ONIG_OPTION_ASCII_RANGE) - - -def get_encoding_name(onigenc): - """Return the name of specified onigmo.OnigEncoding. - - arguments: - enc -- an instance of onigmo.OnigEncoding - """ - name = onigenc[0].name.decode() - encnamemap = {"Windows-31J": "CP932", - "ASCII-8BIT": "ASCII"} - if name in encnamemap: - name = encnamemap[name] - return name - -def is_unicode_encoding(enc): - """Check if the encoding is Unicode encoding. - - arguments: - enc -- encoding name or an instance of onigmo.OnigEncoding - """ - return enc in (onigmo.ONIG_ENCODING_UTF32_LE, - onigmo.ONIG_ENCODING_UTF32_BE, - onigmo.ONIG_ENCODING_UTF16_LE, - onigmo.ONIG_ENCODING_UTF16_BE, - onigmo.ONIG_ENCODING_UTF8, - 'UTF-16LE', 'UTF-16BE', 'UTF-32LE', 'UTF-32BE', 'UTF-8') - -def is_ascii_incompatible_encoding(enc): - """Check if the encoding is ASCII-incompatible encoding. - - arguments: - enc -- encoding name or an instance of onigmo.OnigEncoding - """ - return enc in (onigmo.ONIG_ENCODING_UTF32_LE, - onigmo.ONIG_ENCODING_UTF32_BE, - onigmo.ONIG_ENCODING_UTF16_LE, - onigmo.ONIG_ENCODING_UTF16_BE, - 'UTF-16LE', 'UTF-16BE', 'UTF-32LE', 'UTF-32BE') - - -class strptr: - """a helper class to get a pointer to a string""" - def __init__(self, s): - if not isinstance(s, bytes): - raise TypeError - self._str = s - try: - # CPython 2.x/3.x - self._ptr = ctypes.cast(self._str, ctypes.c_void_p) - except TypeError: - # PyPy 1.x - self._ptr = ctypes.c_void_p(self._str) - - def getptr(self, offset=0): - if offset == -1: # -1 means the end of the string - offset = len(self._str) - elif offset > len(self._str): - raise IndexError - return self._ptr.value + offset - -def cc_to_cb(s, enc, cc): - """convert char count to byte count - - arguments: - s -- unicode string - enc -- encoding name - cc -- char count - """ - if cc == -1: - return -1 - s = s.encode('UTF-32LE') - clen = cc * 4 - if clen > len(s): - raise IndexError - return len(s[:clen].decode('UTF-32LE').encode(enc)) - -def print_result(result, pattern, file=None): - if not file: - file = sys.stdout - print(result + ": ", end='', file=file) - try: - print(pattern, file=file) - except UnicodeEncodeError as e: - print('(' + str(e) + ')') - -def decode_errmsg(msg): - encoding = get_encoding_name(onig_encoding) - if is_ascii_incompatible_encoding(encoding): - encoding = 'ASCII' - return msg.value.decode(encoding, 'replace') - - -class SearchType: - FORWARD = 0 - BACKWARD = 1 - MATCH = 2 - -def xx(pattern, target, s_from, s_to, mem, not_match, - searchtype=SearchType.FORWARD, - gpos=-1, startpos=0, endpos=-1, - syn=syntax_default, opt=onigmo.ONIG_OPTION_DEFAULT, - err=onigmo.ONIG_NORMAL, execerr=onigmo.ONIG_NORMAL): - global nerror - global nsucc - global nfail - - encoding = get_encoding_name(onig_encoding) - - reg = onigmo.OnigRegex() - einfo = onigmo.OnigErrorInfo() - msg = ctypes.create_string_buffer(onigmo.ONIG_MAX_ERROR_MESSAGE_LEN) - - pattern2 = pattern - if not isinstance(pattern, bytes): - pattern2 = pattern.encode(encoding) - patternp = strptr(pattern2) - - target2 = target - if not isinstance(target, bytes): - s_from = cc_to_cb(target, encoding, s_from) - s_to = cc_to_cb(target, encoding, s_to) - gpos = cc_to_cb(target, encoding, gpos) - startpos = cc_to_cb(target, encoding, startpos) - endpos = cc_to_cb(target, encoding, endpos) - target2 = target.encode(encoding) - targetp = strptr(target2) - - # cut very long outputs (used for showing message) - pattern = pattern2.decode(encoding, 'replace') - target = target2.decode(encoding, 'replace') - limit = 100 - if len(pattern) > limit: - pattern = pattern[:limit] + "..." - if len(target) > limit: - target = target[:limit] + "..." - - # Compile - r = onigmo.onig_new(ctypes.byref(reg), - patternp.getptr(), patternp.getptr(-1), - opt, onig_encoding, syn, ctypes.byref(einfo)); - if r != 0: - # Error - onigmo.onig_error_code_to_str(msg, r, ctypes.byref(einfo)) - if r == err: - nsucc += 1 - print_result("OK(E)", "%s (/%s/ '%s')" % \ - (decode_errmsg(msg), pattern, target)) - else: - nerror += 1 - print_result("ERROR", "%s (/%s/ '%s')" % \ - (decode_errmsg(msg), pattern, target), file=sys.stderr) - return - - if err != onigmo.ONIG_NORMAL: - nfail += 1 - print_result("FAIL(E)", "/%s/ '%s'" % (pattern, target)) - onigmo.onig_free(reg) - return - - # Execute - region = onigmo.onig_region_new() - if searchtype == SearchType.FORWARD: - if gpos >= 0: - r = onigmo.onig_search_gpos(reg, - targetp.getptr(), targetp.getptr(-1), - targetp.getptr(gpos), - targetp.getptr(startpos), targetp.getptr(endpos), - region, onigmo.ONIG_OPTION_NONE); - else: - r = onigmo.onig_search(reg, - targetp.getptr(), targetp.getptr(-1), - targetp.getptr(startpos), targetp.getptr(endpos), - region, onigmo.ONIG_OPTION_NONE); - elif searchtype == SearchType.BACKWARD: - if gpos >= 0: - r = onigmo.onig_search_gpos(reg, - targetp.getptr(), targetp.getptr(-1), - targetp.getptr(gpos), - targetp.getptr(endpos), targetp.getptr(startpos), - region, onigmo.ONIG_OPTION_NONE); - else: - r = onigmo.onig_search(reg, - targetp.getptr(), targetp.getptr(-1), - targetp.getptr(endpos), targetp.getptr(startpos), - region, onigmo.ONIG_OPTION_NONE); - elif searchtype == SearchType.MATCH: - r = onigmo.onig_match(reg, targetp.getptr(), targetp.getptr(-1), - targetp.getptr(startpos), - region, onigmo.ONIG_OPTION_NONE); - else: - nerror += 1 - print_result("ERROR", "wrong searchtype", file=sys.stderr) - onigmo.onig_free(reg) - onigmo.onig_region_free(region, 1) - return - - if r < onigmo.ONIG_MISMATCH: - # Error - onigmo.onig_error_code_to_str(msg, r) - if r == execerr: - nsucc += 1 - print_result("OK(E)", "%s (/%s/ '%s')" % \ - (decode_errmsg(msg), pattern, target)) - else: - nerror += 1 - print_result("ERROR", "%s (/%s/ '%s')" % \ - (decode_errmsg(msg), pattern, target), file=sys.stderr) - onigmo.onig_free(reg) - onigmo.onig_region_free(region, 1) - return - - if r == onigmo.ONIG_MISMATCH: - # Not matched - if not_match: - nsucc += 1 - print_result("OK(N)", "/%s/ '%s'" % (pattern, target)) - else: - nfail += 1 - print_result("FAIL", "/%s/ '%s'" % (pattern, target)) - else: - # Matched - if not_match: - nfail += 1 - print_result("FAIL(N)", "/%s/ '%s'" % (pattern, target)) - else: - start = region[0].beg[mem] - end = region[0].end[mem] - if (start == s_from) and (end == s_to): - nsucc += 1 - print_result("OK", "/%s/ '%s'" % (pattern, target)) - else: - nfail += 1 - print_result("FAIL", "/%s/ '%s' %d-%d : %d-%d" % (pattern, target, - s_from, s_to, start, end)) - onigmo.onig_free(reg) - onigmo.onig_region_free(region, 1) - -def x2(pattern, target, s_from, s_to, **kwargs): - xx(pattern, target, s_from, s_to, 0, False, **kwargs) - -def x3(pattern, target, s_from, s_to, mem, **kwargs): - xx(pattern, target, s_from, s_to, mem, False, **kwargs) - -def n(pattern, target, **kwargs): - xx(pattern, target, 0, 0, 0, True, **kwargs) - - -def set_encoding(enc): - """Set the encoding used for testing. - - arguments: - enc -- encoding name or an instance of onigmo.OnigEncoding - """ - global onig_encoding - - if enc == None: - return - if isinstance(enc, onigmo.OnigEncoding): - onig_encoding = enc - else: - encs = {"EUC-JP": onigmo.ONIG_ENCODING_EUC_JP, - "SJIS": onigmo.ONIG_ENCODING_SJIS, - "CP932": onigmo.ONIG_ENCODING_CP932, - "UTF-8": onigmo.ONIG_ENCODING_UTF8, - "UTF-16LE": onigmo.ONIG_ENCODING_UTF16_LE, - "UTF-16BE": onigmo.ONIG_ENCODING_UTF16_BE, - "UTF-32LE": onigmo.ONIG_ENCODING_UTF32_LE, - "UTF-32BE": onigmo.ONIG_ENCODING_UTF32_BE} - onig_encoding = encs[enc.upper()] - -def get_encoding(): - """Get the encoding used for testing.""" - return onig_encoding - -def set_output_encoding(enc=None): - """Set the encoding used for showing the results. - - arguments: - enc -- Encoding name or an instance of onigmo.OnigEncoding. - If omitted, locale.getpreferredencoding() is used. - """ - if enc is None: - enc = locale.getpreferredencoding() - - def get_text_writer(fo, **kwargs): - kw = dict(kwargs) - kw.setdefault('errors', 'backslashreplace') # use \uXXXX style - kw.setdefault('closefd', False) - - if sys.version_info[0] < 3: - # Work around for Python 2.x - # New line conversion isn't needed here. Done in somewhere else. - writer = io.open(fo.fileno(), mode='w', newline='', **kw) - write = writer.write # save the original write() function - enc = locale.getpreferredencoding() - def convwrite(s): - if isinstance(s, bytes): - write(s.decode(enc)) # convert to unistr - else: - write(s) - try: - writer.flush() # needed on Windows - except IOError: - pass - writer.write = convwrite - else: - writer = io.open(fo.fileno(), mode='w', **kw) - return writer - - sys.stdout = get_text_writer(sys.stdout, encoding=enc) - sys.stderr = get_text_writer(sys.stderr, encoding=enc) - - -def set_default_warning_function(): - global _warn_func_ptr - - warning_enc = get_encoding_name(onig_encoding) - if is_ascii_incompatible_encoding(warning_enc): - warning_enc = 'ascii' - def warn_func(str): - print("warning: " + str.decode(warning_enc, 'replace')) - - _warn_func_ptr = onigmo.OnigWarnFunc(warn_func) - onigmo.onig_set_warn_func(_warn_func_ptr) - onigmo.onig_set_verb_warn_func(_warn_func_ptr) - - -def init(enc, outenc=None): - """Setup test target encoding, output encoding and warning function. - - arguments: - enc -- Encoding used for testing. - outenc -- Encoding used for showing messages. - """ - set_encoding(enc) - set_output_encoding(outenc) - set_default_warning_function() - - -def main(): - # encoding of the test target - enc = None - if len(sys.argv) > 1: - enc = sys.argv[1] - - # encoding of stdout/stderr - outenc = None - if len(sys.argv) > 2: - outenc = sys.argv[2] - - # Initialization - try: - init(enc, outenc) - except KeyError: - print("test target encoding error") - print("Usage: python testpy.py [test target encoding] [output encoding]") - sys.exit() - - print(onigmo.onig_copyright()) - - # Copied from onig-5.9.2/testc.c - # '?\?' which is used to avoid trigraph is replaced by '??'. - # Match positions are specified by unit of character instead of byte. - - x2("", "", 0, 0); - x2("^", "", 0, 0); - x2("$", "", 0, 0); - x2("\\G", "", 0, 0); - x2("\\A", "", 0, 0); - x2("\\Z", "", 0, 0); - x2("\\z", "", 0, 0); - x2("^$", "", 0, 0); - x2("\\ca", "\001", 0, 1); - x2("\\C-b", "\002", 0, 1); - x2("\\c\\\\", "\034", 0, 1); - x2("q[\\c\\\\]", "q\034", 0, 2); - x2("", "a", 0, 0); - x2("a", "a", 0, 1); - if onig_encoding == onigmo.ONIG_ENCODING_UTF16_LE: - x2("\\x61\\x00", "a", 0, 1); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF16_BE: - x2("\\x00\\x61", "a", 0, 1); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF32_LE: - x2("\\x61\\x00\\x00\\x00", "a", 0, 1); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF32_BE: - x2("\\x00\\x00\\x00\\x61", "a", 0, 1); - else: - x2("\\x61", "a", 0, 1); - x2("aa", "aa", 0, 2); - x2("aaa", "aaa", 0, 3); - x2("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 0, 35); - x2("ab", "ab", 0, 2); - x2("b", "ab", 1, 2); - x2("bc", "abc", 1, 3); - x2("(?i:#RET#)", "#INS##RET#", 5, 10); - if onig_encoding == onigmo.ONIG_ENCODING_UTF16_LE: - x2("\\17\\00", "\017", 0, 1); - x2("\\x1f\\x00", "\x1f", 0, 1); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF16_BE: - x2("\\00\\17", "\017", 0, 1); - x2("\\x00\\x1f", "\x1f", 0, 1); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF32_LE: - x2("\\17\\00\\00\\00", "\017", 0, 1); - x2("\\x1f\\x00\\x00\\x00", "\x1f", 0, 1); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF32_BE: - x2("\\00\\00\\00\\17", "\017", 0, 1); - x2("\\x00\\x00\\x00\\x1f", "\x1f", 0, 1); - else: - x2("\\17", "\017", 0, 1); - x2("\\x1f", "\x1f", 0, 1); - x2("a(?#....\\\\JJJJ)b", "ab", 0, 2); - x2("(?x) G (o O(?-x)oO) g L", "GoOoOgLe", 0, 7); - x2(".", "a", 0, 1); - n(".", ""); - x2("..", "ab", 0, 2); - x2("\\w", "e", 0, 1); - n("\\W", "e"); - x2("\\s", " ", 0, 1); - x2("\\S", "b", 0, 1); - x2("\\d", "4", 0, 1); - n("\\D", "4"); - x2("\\b", "z ", 0, 0); - x2("\\b", " z", 1, 1); - x2("\\B", "zz ", 1, 1); - x2("\\B", "z ", 2, 2); - x2("\\B", " z", 0, 0); - x2("[ab]", "b", 0, 1); - n("[ab]", "c"); - x2("[a-z]", "t", 0, 1); - n("[^a]", "a"); - x2("[^a]", "\n", 0, 1); - x2("[]]", "]", 0, 1); - n("[^]]", "]"); - x2("[\\^]+", "0^^1", 1, 3); - x2("[b-]", "b", 0, 1); - x2("[b-]", "-", 0, 1); - x2("[\\w]", "z", 0, 1); - n("[\\w]", " "); - x2("[\\W]", "b$", 1, 2); - x2("[\\d]", "5", 0, 1); - n("[\\d]", "e"); - x2("[\\D]", "t", 0, 1); - n("[\\D]", "3"); - x2("[\\s]", " ", 0, 1); - n("[\\s]", "a"); - x2("[\\S]", "b", 0, 1); - n("[\\S]", " "); - x2("[\\w\\d]", "2", 0, 1); - n("[\\w\\d]", " "); - x2("[[:upper:]]", "B", 0, 1); - x2("[*[:xdigit:]+]", "+", 0, 1); - x2("[*[:xdigit:]+]", "GHIKK-9+*", 6, 7); - x2("[*[:xdigit:]+]", "-@^+", 3, 4); - n("[[:upper]]", "A"); - x2("[[:upper]]", ":", 0, 1); - if onig_encoding == onigmo.ONIG_ENCODING_UTF16_LE: - x2("[\\044\\000-\\047\\000]", "\046", 0, 1); - x2("[\\x5a\\x00-\\x5c\\x00]", "\x5b", 0, 1); - x2("[\\x6A\\x00-\\x6D\\x00]", "\x6c", 0, 1); - n("[\\x6A\\x00-\\x6D\\x00]", "\x6E"); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF16_BE: - x2("[\\000\\044-\\000\\047]", "\046", 0, 1); - x2("[\\x00\\x5a-\\x00\\x5c]", "\x5b", 0, 1); - x2("[\\x00\\x6A-\\x00\\x6D]", "\x6c", 0, 1); - n("[\\x00\\x6A-\\x00\\x6D]", "\x6E"); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF32_LE: - x2("[\\044\\000\\000\\000-\\047\\000\\000\\000]", "\046", 0, 1); - x2("[\\x5a\\x00\\x00\\x00-\\x5c\\x00\\x00\\x00]", "\x5b", 0, 1); - x2("[\\x6A\\x00\\x00\\x00-\\x6D\\x00\\x00\\x00]", "\x6c", 0, 1); - n("[\\x6A\\x00\\x00\\x00-\\x6D\\x00\\x00\\x00]", "\x6E"); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF32_BE: - x2("[\\000\\000\\000\\044-\\000\\000\\000\\047]", "\046", 0, 1); - x2("[\\x00\\x00\\x00\\x5a-\\x00\\x00\\x00\\x5c]", "\x5b", 0, 1); - x2("[\\x00\\x00\\x00\\x6A-\\x00\\x00\\x00\\x6D]", "\x6c", 0, 1); - n("[\\x00\\x00\\x00\\x6A-\\x00\\x00\\x00\\x6D]", "\x6E"); - else: - x2("[\\044-\\047]", "\046", 0, 1); - x2("[\\x5a-\\x5c]", "\x5b", 0, 1); - x2("[\\x6A-\\x6D]", "\x6c", 0, 1); - n("[\\x6A-\\x6D]", "\x6E"); - n("^[0-9A-F]+ 0+ UNDEF ", "75F 00000000 SECT14A notype () External | _rb_apply"); - x2("[\\[]", "[", 0, 1); - x2("[\\]]", "]", 0, 1); - x2("[&]", "&", 0, 1); - x2("[[ab]]", "b", 0, 1); - x2("[[ab]c]", "c", 0, 1); - n("[[^a]]", "a"); - n("[^[a]]", "a"); - x2("[[ab]&&bc]", "b", 0, 1); - n("[[ab]&&bc]", "a"); - n("[[ab]&&bc]", "c"); - x2("[a-z&&b-y&&c-x]", "w", 0, 1); - n("[^a-z&&b-y&&c-x]", "w"); - x2("[[^a&&a]&&a-z]", "b", 0, 1); - n("[[^a&&a]&&a-z]", "a"); - x2("[[^a-z&&bcdef]&&[^c-g]]", "h", 0, 1); - n("[[^a-z&&bcdef]&&[^c-g]]", "c"); - x2("[^[^abc]&&[^cde]]", "c", 0, 1); - x2("[^[^abc]&&[^cde]]", "e", 0, 1); - n("[^[^abc]&&[^cde]]", "f"); - x2("[a-&&-a]", "-", 0, 1); - n("[a\\-&&\\-a]", "&"); - n("\\wabc", " abc"); - x2("a\\Wbc", "a bc", 0, 4); - x2("a.b.c", "aabbc", 0, 5); - x2(".\\wb\\W..c", "abb bcc", 0, 7); - x2("\\s\\wzzz", " zzzz", 0, 5); - x2("aa.b", "aabb", 0, 4); - n(".a", "ab"); - x2(".a", "aa", 0, 2); - x2("^a", "a", 0, 1); - x2("^a$", "a", 0, 1); - x2("^\\w$", "a", 0, 1); - n("^\\w$", " "); - x2("^\\wab$", "zab", 0, 3); - x2("^\\wabcdef$", "zabcdef", 0, 7); - x2("^\\w...def$", "zabcdef", 0, 7); - x2("\\w\\w\\s\\Waaa\\d", "aa aaa4", 0, 8); - x2("\\A\\Z", "", 0, 0); - x2("\\Axyz", "xyz", 0, 3); - x2("xyz\\Z", "xyz", 0, 3); - x2("xyz\\z", "xyz", 0, 3); - x2("a\\Z", "a", 0, 1); - x2("\\Gaz", "az", 0, 2); - n("\\Gz", "bza"); - n("az\\G", "az"); - n("az\\A", "az"); - n("a\\Az", "az"); - x2("\\^\\$", "^$", 0, 2); - x2("^x?y", "xy", 0, 2); - x2("^(x?y)", "xy", 0, 2); - x2("\\w", "_", 0, 1); - n("\\W", "_"); - x2("(?=z)z", "z", 0, 1); - n("(?=z).", "a"); - x2("(?!z)a", "a", 0, 1); - n("(?!z)a", "z"); - x2("(?i:a)", "a", 0, 1); - x2("(?i:a)", "A", 0, 1); - x2("(?i:A)", "a", 0, 1); - n("(?i:A)", "b"); - x2("(?i:[A-Z])", "a", 0, 1); - x2("(?i:[f-m])", "H", 0, 1); - x2("(?i:[f-m])", "h", 0, 1); - n("(?i:[f-m])", "e"); - x2("(?i:[A-c])", "D", 0, 1); - n("(?i:[^a-z])", "A"); - n("(?i:[^a-z])", "a"); - x2("(?i:[!-k])", "Z", 0, 1); - x2("(?i:[!-k])", "7", 0, 1); - x2("(?i:[T-}])", "b", 0, 1); - x2("(?i:[T-}])", "{", 0, 1); - x2("(?i:\\?a)", "?A", 0, 2); - x2("(?i:\\*A)", "*a", 0, 2); - n(".", "\n"); - x2("(?m:.)", "\n", 0, 1); - x2("(?m:a.)", "a\n", 0, 2); - x2("(?m:.b)", "a\nb", 1, 3); - x2(".*abc", "dddabdd\nddabc", 8, 13); - x2("(?m:.*abc)", "dddabddabc", 0, 10); - n("(?i)(?-i)a", "A"); - n("(?i)(?-i:a)", "A"); - x2("a?", "", 0, 0); - x2("a?", "b", 0, 0); - x2("a?", "a", 0, 1); - x2("a*", "", 0, 0); - x2("a*", "a", 0, 1); - x2("a*", "aaa", 0, 3); - x2("a*", "baaaa", 0, 0); - n("a+", ""); - x2("a+", "a", 0, 1); - x2("a+", "aaaa", 0, 4); - x2("a+", "aabbb", 0, 2); - x2("a+", "baaaa", 1, 5); - x2(".?", "", 0, 0); - x2(".?", "f", 0, 1); - x2(".?", "\n", 0, 0); - x2(".*", "", 0, 0); - x2(".*", "abcde", 0, 5); - x2(".+", "z", 0, 1); - x2(".+", "zdswer\n", 0, 6); - x2("(.*)a\\1f", "babfbac", 0, 4); - x2("(.*)a\\1f", "bacbabf", 3, 7); - x2("((.*)a\\2f)", "bacbabf", 3, 7); - x2("(.*)a\\1f", "baczzzzzz\nbazz\nzzzzbabf", 19, 23); - x2("a|b", "a", 0, 1); - x2("a|b", "b", 0, 1); - x2("|a", "a", 0, 0); - x2("(|a)", "a", 0, 0); - x2("ab|bc", "ab", 0, 2); - x2("ab|bc", "bc", 0, 2); - x2("z(?:ab|bc)", "zbc", 0, 3); - x2("a(?:ab|bc)c", "aabc", 0, 4); - x2("ab|(?:ac|az)", "az", 0, 2); - x2("a|b|c", "dc", 1, 2); - x2("a|b|cd|efg|h|ijk|lmn|o|pq|rstuvwx|yz", "pqr", 0, 2); - n("a|b|cd|efg|h|ijk|lmn|o|pq|rstuvwx|yz", "mn"); - x2("a|^z", "ba", 1, 2); - x2("a|^z", "za", 0, 1); - x2("a|\\Gz", "bza", 2, 3); - x2("a|\\Gz", "za", 0, 1); - x2("a|\\Az", "bza", 2, 3); - x2("a|\\Az", "za", 0, 1); - x2("a|b\\Z", "ba", 1, 2); - x2("a|b\\Z", "b", 0, 1); - x2("a|b\\z", "ba", 1, 2); - x2("a|b\\z", "b", 0, 1); - x2("\\w|\\s", " ", 0, 1); - n("\\w|\\w", " "); - x2("\\w|%", "%", 0, 1); - x2("\\w|[&$]", "&", 0, 1); - x2("[b-d]|[^e-z]", "a", 0, 1); - x2("(?:a|[c-f])|bz", "dz", 0, 1); - x2("(?:a|[c-f])|bz", "bz", 0, 2); - x2("abc|(?=zz)..f", "zzf", 0, 3); - x2("abc|(?!zz)..f", "abf", 0, 3); - x2("(?=za)..a|(?=zz)..a", "zza", 0, 3); - n("(?>a|abd)c", "abdc"); - x2("(?>abd|a)c", "abdc", 0, 4); - x2("a?|b", "a", 0, 1); - x2("a?|b", "b", 0, 0); - x2("a?|b", "", 0, 0); - x2("a*|b", "aa", 0, 2); - x2("a*|b*", "ba", 0, 0); - x2("a*|b*", "ab", 0, 1); - x2("a+|b*", "", 0, 0); - x2("a+|b*", "bbb", 0, 3); - x2("a+|b*", "abbb", 0, 1); - n("a+|b+", ""); - x2("(a|b)?", "b", 0, 1); - x2("(a|b)*", "ba", 0, 2); - x2("(a|b)+", "bab", 0, 3); - x2("(ab|ca)+", "caabbc", 0, 4); - x2("(ab|ca)+", "aabca", 1, 5); - x2("(ab|ca)+", "abzca", 0, 2); - x2("(a|bab)+", "ababa", 0, 5); - x2("(a|bab)+", "ba", 1, 2); - x2("(a|bab)+", "baaaba", 1, 4); - x2("(?:a|b)(?:a|b)", "ab", 0, 2); - x2("(?:a*|b*)(?:a*|b*)", "aaabbb", 0, 3); - x2("(?:a*|b*)(?:a+|b+)", "aaabbb", 0, 6); - x2("(?:a+|b+){2}", "aaabbb", 0, 6); - x2("h{0,}", "hhhh", 0, 4); - x2("(?:a+|b+){1,2}", "aaabbb", 0, 6); - n("ax{2}*a", "0axxxa1"); - n("a.{0,2}a", "0aXXXa0"); - n("a.{0,2}?a", "0aXXXa0"); - n("a.{0,2}?a", "0aXXXXa0"); - x2("^a{2,}?a$", "aaa", 0, 3); - x2("^[a-z]{2,}?$", "aaa", 0, 3); - x2("(?:a+|\\Ab*)cc", "cc", 0, 2); - n("(?:a+|\\Ab*)cc", "abcc"); - x2("(?:^a+|b+)*c", "aabbbabc", 6, 8); - x2("(?:^a+|b+)*c", "aabbbbc", 0, 7); - x2("a|(?i)c", "C", 0, 1); - x2("(?i)c|a", "C", 0, 1); - x2("(?i)c|a", "A", 0, 1); - x2("(?i:c)|a", "C", 0, 1); - n("(?i:c)|a", "A"); - x2("[abc]?", "abc", 0, 1); - x2("[abc]*", "abc", 0, 3); - x2("[^abc]*", "abc", 0, 0); - n("[^abc]+", "abc"); - x2("a??", "aaa", 0, 0); - x2("ba??b", "bab", 0, 3); - x2("a*?", "aaa", 0, 0); - x2("ba*?", "baa", 0, 1); - x2("ba*?b", "baab", 0, 4); - x2("a+?", "aaa", 0, 1); - x2("ba+?", "baa", 0, 2); - x2("ba+?b", "baab", 0, 4); - x2("(?:a?)??", "a", 0, 0); - x2("(?:a??)?", "a", 0, 0); - x2("(?:a?)+?", "aaa", 0, 1); - x2("(?:a+)??", "aaa", 0, 0); - x2("(?:a+)??b", "aaab", 0, 4); - x2("(?:ab)?{2}", "", 0, 0); - x2("(?:ab)?{2}", "ababa", 0, 4); - x2("(?:ab)*{0}", "ababa", 0, 0); - x2("(?:ab){3,}", "abababab", 0, 8); - n("(?:ab){3,}", "abab"); - x2("(?:ab){2,4}", "ababab", 0, 6); - x2("(?:ab){2,4}", "ababababab", 0, 8); - x2("(?:ab){2,4}?", "ababababab", 0, 4); - x2("(?:ab){,}", "ab{,}", 0, 5); - x2("(?:abc)+?{2}", "abcabcabc", 0, 6); - x2("(?:X*)(?i:xa)", "XXXa", 0, 4); - x2("(d+)([^abc]z)", "dddz", 0, 4); - x2("([^abc]*)([^abc]z)", "dddz", 0, 4); - x2("(\\w+)(\\wz)", "dddz", 0, 4); - x3("(a)", "a", 0, 1, 1); - x3("(ab)", "ab", 0, 2, 1); - x2("((ab))", "ab", 0, 2); - x3("((ab))", "ab", 0, 2, 1); - x3("((ab))", "ab", 0, 2, 2); - x3("((((((((((((((((((((ab))))))))))))))))))))", "ab", 0, 2, 20); - x3("(ab)(cd)", "abcd", 0, 2, 1); - x3("(ab)(cd)", "abcd", 2, 4, 2); - x3("()(a)bc(def)ghijk", "abcdefghijk", 3, 6, 3); - x3("(()(a)bc(def)ghijk)", "abcdefghijk", 3, 6, 4); - x2("(^a)", "a", 0, 1); - x3("(a)|(a)", "ba", 1, 2, 1); - x3("(^a)|(a)", "ba", 1, 2, 2); - x3("(a?)", "aaa", 0, 1, 1); - x3("(a*)", "aaa", 0, 3, 1); - x3("(a*)", "", 0, 0, 1); - x3("(a+)", "aaaaaaa", 0, 7, 1); - x3("(a+|b*)", "bbbaa", 0, 3, 1); - x3("(a+|b?)", "bbbaa", 0, 1, 1); - x3("(abc)?", "abc", 0, 3, 1); - x3("(abc)*", "abc", 0, 3, 1); - x3("(abc)+", "abc", 0, 3, 1); - x3("(xyz|abc)+", "abc", 0, 3, 1); - x3("([xyz][abc]|abc)+", "abc", 0, 3, 1); - x3("((?i:abc))", "AbC", 0, 3, 1); - x2("(abc)(?i:\\1)", "abcABC", 0, 6); - x3("((?m:a.c))", "a\nc", 0, 3, 1); - x3("((?=az)a)", "azb", 0, 1, 1); - x3("abc|(.abd)", "zabd", 0, 4, 1); - x2("(?:abc)|(ABC)", "abc", 0, 3); - x3("(?i:(abc))|(zzz)", "ABC", 0, 3, 1); - x3("a*(.)", "aaaaz", 4, 5, 1); - x3("a*?(.)", "aaaaz", 0, 1, 1); - x3("a*?(c)", "aaaac", 4, 5, 1); - x3("[bcd]a*(.)", "caaaaz", 5, 6, 1); - x3("(\\Abb)cc", "bbcc", 0, 2, 1); - n("(\\Abb)cc", "zbbcc"); - x3("(^bb)cc", "bbcc", 0, 2, 1); - n("(^bb)cc", "zbbcc"); - x3("cc(bb$)", "ccbb", 2, 4, 1); - n("cc(bb$)", "ccbbb"); - n("(\\1)", ""); - n("\\1(a)", "aa"); - n("(a(b)\\1)\\2+", "ababb"); - n("(?:(?:\\1|z)(a))+$", "zaa"); - x2("(?:(?:\\1|z)(a))+$", "zaaa", 0, 4); - x2("(a)(?=\\1)", "aa", 0, 1); - n("(a)$|\\1", "az"); - x2("(a)\\1", "aa", 0, 2); - n("(a)\\1", "ab"); - x2("(a?)\\1", "aa", 0, 2); - x2("(a??)\\1", "aa", 0, 0); - x2("(a*)\\1", "aaaaa", 0, 4); - x3("(a*)\\1", "aaaaa", 0, 2, 1); - x2("a(b*)\\1", "abbbb", 0, 5); - x2("a(b*)\\1", "ab", 0, 1); - x2("(a*)(b*)\\1\\2", "aaabbaaabb", 0, 10); - x2("(a*)(b*)\\2", "aaabbbb", 0, 7); - x2("(((((((a*)b))))))c\\7", "aaabcaaa", 0, 8); - x3("(((((((a*)b))))))c\\7", "aaabcaaa", 0, 3, 7); - x2("(a)(b)(c)\\2\\1\\3", "abcbac", 0, 6); - x2("([a-d])\\1", "cc", 0, 2); - x2("(\\w\\d\\s)\\1", "f5 f5 ", 0, 6); - n("(\\w\\d\\s)\\1", "f5 f5"); - x2("(who|[a-c]{3})\\1", "whowho", 0, 6); - x2("...(who|[a-c]{3})\\1", "abcwhowho", 0, 9); - x2("(who|[a-c]{3})\\1", "cbccbc", 0, 6); - x2("(^a)\\1", "aa", 0, 2); - n("(^a)\\1", "baa"); - n("(a$)\\1", "aa"); - n("(ab\\Z)\\1", "ab"); - x2("(a*\\Z)\\1", "a", 1, 1); - x2(".(a*\\Z)\\1", "ba", 1, 2); - x3("(.(abc)\\2)", "zabcabc", 0, 7, 1); - x3("(.(..\\d.)\\2)", "z12341234", 0, 9, 1); - x2("((?i:az))\\1", "AzAz", 0, 4); - n("((?i:az))\\1", "Azaz"); - x2("(?<=a)b", "ab", 1, 2); - n("(?<=a)b", "bb"); - x2("(?<=a|b)b", "bb", 1, 2); - x2("(?<=a|bc)b", "bcb", 2, 3); - x2("(?<=a|bc)b", "ab", 1, 2); - x2("(?<=a|bc||defghij|klmnopq|r)z", "rz", 1, 2); - x2("(a)\\g<1>", "aa", 0, 2); - x2("(?<!a)b", "cb", 1, 2); - n("(?<!a)b", "ab"); - x2("(?<!a|bc)b", "bbb", 0, 1); - n("(?<!a|bc)z", "bcz"); - x2("(?<name1>a)", "a", 0, 1); - x2("(?<name_2>ab)\\g<name_2>", "abab", 0, 4); - x2("(?<name_3>.zv.)\\k<name_3>", "azvbazvb", 0, 8); - x2("(?<=\\g<ab>)|-\\zEND (?<ab>XyZ)", "XyZ", 3, 3); - x2("(?<n>|a\\g<n>)+", "", 0, 0); - x2("(?<n>|\\(\\g<n>\\))+$", "()(())", 0, 6); - x3("\\g<n>(?<n>.){0}", "X", 0, 1, 1); - x2("\\g<n>(abc|df(?<n>.YZ){2,8}){0}", "XYZ", 0, 3); - x2("\\A(?<n>(a\\g<n>)|)\\z", "aaaa", 0, 4); - x2("(?<n>|\\g<m>\\g<n>)\\z|\\zEND (?<m>a|(b)\\g<m>)", "bbbbabba", 0, 8); - x2("(?<name1240>\\w+\\sx)a+\\k<name1240>", " fg xaaaaaaaafg x", 2, 18); - x3("(z)()()(?<_9>a)\\g<_9>", "zaa", 2, 3, 1); - x2("(.)(((?<_>a)))\\k<_>", "zaa", 0, 3); - x2("((?<name1>\\d)|(?<name2>\\w))(\\k<name1>|\\k<name2>)", "ff", 0, 2); - x2("(?:(?<x>)|(?<x>efg))\\k<x>", "", 0, 0); - x2("(?:(?<x>abc)|(?<x>efg))\\k<x>", "abcefgefg", 3, 9); - n("(?:(?<x>abc)|(?<x>efg))\\k<x>", "abcefg"); - x2("(?:(?<n1>.)|(?<n1>..)|(?<n1>...)|(?<n1>....)|(?<n1>.....)|(?<n1>......)|(?<n1>.......)|(?<n1>........)|(?<n1>.........)|(?<n1>..........)|(?<n1>...........)|(?<n1>............)|(?<n1>.............)|(?<n1>..............))\\k<n1>$", "a-pyumpyum", 2, 10); - x3("(?:(?<n1>.)|(?<n1>..)|(?<n1>...)|(?<n1>....)|(?<n1>.....)|(?<n1>......)|(?<n1>.......)|(?<n1>........)|(?<n1>.........)|(?<n1>..........)|(?<n1>...........)|(?<n1>............)|(?<n1>.............)|(?<n1>..............))\\k<n1>$", "xxxxabcdefghijklmnabcdefghijklmn", 4, 18, 14); - x3("(?<name1>)(?<name2>)(?<name3>)(?<name4>)(?<name5>)(?<name6>)(?<name7>)(?<name8>)(?<name9>)(?<name10>)(?<name11>)(?<name12>)(?<name13>)(?<name14>)(?<name15>)(?<name16>aaa)(?<name17>)$", "aaa", 0, 3, 16); - x2("(?<foo>a|\\(\\g<foo>\\))", "a", 0, 1); - x2("(?<foo>a|\\(\\g<foo>\\))", "((((((a))))))", 0, 13); - x3("(?<foo>a|\\(\\g<foo>\\))", "((((((((a))))))))", 0, 17, 1); - x2("\\g<bar>|\\zEND(?<bar>.*abc$)", "abcxxxabc", 0, 9); - x2("\\g<1>|\\zEND(.a.)", "bac", 0, 3); - x3("\\g<_A>\\g<_A>|\\zEND(.a.)(?<_A>.b.)", "xbxyby", 3, 6, 1); - x2("\\A(?:\\g<pon>|\\g<pan>|\\zEND (?<pan>a|c\\g<pon>c)(?<pon>b|d\\g<pan>d))$", "cdcbcdc", 0, 7); - x2("\\A(?<n>|a\\g<m>)\\z|\\zEND (?<m>\\g<n>)", "aaaa", 0, 4); - x2("(?<n>(a|b\\g<n>c){3,5})", "baaaaca", 1, 5); - x2("(?<n>(a|b\\g<n>c){3,5})", "baaaacaaaaa", 0, 10); - x2("(?<pare>\\(([^\\(\\)]++|\\g<pare>)*+\\))", "((a))", 0, 5); - x2("()*\\1", "", 0, 0); - x2("(?:()|())*\\1\\2", "", 0, 0); - x3("(?:\\1a|())*", "a", 0, 0, 1); - x2("x((.)*)*x", "0x1x2x3", 1, 6); - x2("x((.)*)*x(?i:\\1)\\Z", "0x1x2x1X2", 1, 9); - x2("(?:()|()|()|()|()|())*\\2\\5", "", 0, 0); - x2("(?:()|()|()|(x)|()|())*\\2b\\5", "b", 0, 1); - if onig_encoding == onigmo.ONIG_ENCODING_UTF16_LE: - x2("\\xFA\\x8F", "\u8ffa", 0, 1); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF16_BE: - x2("\\x8F\\xFA", "\u8ffa", 0, 1); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF32_LE: - x2("\\xFA\\x8F\\x00\\x00", "\u8ffa", 0, 1); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF32_BE: - x2("\\x00\\x00\\x8F\\xFA", "\u8ffa", 0, 1); - elif onig_encoding == onigmo.ONIG_ENCODING_UTF8: - x2("\\xE8\\xBF\\xBA", "\u8ffa", 0, 1); - elif onig_encoding == onigmo.ONIG_ENCODING_SJIS or \ - onig_encoding == onigmo.ONIG_ENCODING_CP932: - x2("\\xE7\\x92", "\u8ffa", 0, 1); - elif onig_encoding == onigmo.ONIG_ENCODING_EUC_JP: - x2("\\xED\\xF2", "\u8ffa", 0, 1); # "迺" - x2("", "あ", 0, 0); - x2("あ", "あ", 0, 1); - n("い", "あ"); - x2("うう", "うう", 0, 2); - x2("あいう", "あいう", 0, 3); - x2("こここここここここここここここここここここここここここここここここここ", "こここここここここここここここここここここここここここここここここここ", 0, 35); - x2("あ", "いあ", 1, 2); - x2("いう", "あいう", 1, 3); -# x2(b"\\xca\\xb8", b"\xca\xb8", 0, 2); # "文" - x2(".", "あ", 0, 1); - x2("..", "かき", 0, 2); - x2("\\w", "お", 0, 1); - n("\\W", "あ"); - x2("[\\W]", "う$", 1, 2); - x2("\\S", "そ", 0, 1); - x2("\\S", "漢", 0, 1); - x2("\\b", "気 ", 0, 0); - x2("\\b", " ほ", 1, 1); - x2("\\B", "せそ ", 1, 1); - x2("\\B", "う ", 2, 2); - x2("\\B", " い", 0, 0); - x2("[たち]", "ち", 0, 1); - n("[なに]", "ぬ"); - x2("[う-お]", "え", 0, 1); - n("[^け]", "け"); - x2("[\\w]", "ね", 0, 1); - n("[\\d]", "ふ"); - x2("[\\D]", "は", 0, 1); - n("[\\s]", "く"); - x2("[\\S]", "へ", 0, 1); - x2("[\\w\\d]", "よ", 0, 1); - x2("[\\w\\d]", " よ", 3, 4); - n("\\w鬼車", " 鬼車"); - x2("鬼\\W車", "鬼 車", 0, 3); - x2("あ.い.う", "ああいいう", 0, 5); - x2(".\\wう\\W..ぞ", "えうう うぞぞ", 0, 7); - x2("\\s\\wこここ", " ここここ", 0, 5); - x2("ああ.け", "ああけけ", 0, 4); - n(".い", "いえ"); - x2(".お", "おお", 0, 2); - x2("^あ", "あ", 0, 1); - x2("^む$", "む", 0, 1); - x2("^\\w$", "に", 0, 1); - x2("^\\wかきくけこ$", "zかきくけこ", 0, 6); - x2("^\\w...うえお$", "zあいううえお", 0, 7); - x2("\\w\\w\\s\\Wおおお\\d", "aお おおお4", 0, 8); - x2("\\Aたちつ", "たちつ", 0, 3); - x2("むめも\\Z", "むめも", 0, 3); - x2("かきく\\z", "かきく", 0, 3); - x2("かきく\\Z", "かきく\n", 0, 3); - x2("\\Gぽぴ", "ぽぴ", 0, 2); - n("\\Gえ", "うえお"); - n("とて\\G", "とて"); - n("まみ\\A", "まみ"); - n("ま\\Aみ", "まみ"); - x2("(?=せ)せ", "せ", 0, 1); - n("(?=う).", "い"); - x2("(?!う)か", "か", 0, 1); - n("(?!と)あ", "と"); - x2("(?i:あ)", "あ", 0, 1); - x2("(?i:ぶべ)", "ぶべ", 0, 2); - n("(?i:い)", "う"); - x2("(?m:よ.)", "よ\n", 0, 2); - x2("(?m:.め)", "ま\nめ", 1, 3); - x2("あ?", "", 0, 0); - x2("変?", "化", 0, 0); - x2("変?", "変", 0, 1); - x2("量*", "", 0, 0); - x2("量*", "量", 0, 1); - x2("子*", "子子子", 0, 3); - x2("馬*", "鹿馬馬馬馬", 0, 0); - n("山+", ""); - x2("河+", "河", 0, 1); - x2("時+", "時時時時", 0, 4); - x2("え+", "ええううう", 0, 2); - x2("う+", "おうううう", 1, 5); - x2(".?", "た", 0, 1); - x2(".*", "ぱぴぷぺ", 0, 4); - x2(".+", "ろ", 0, 1); - x2(".+", "いうえか\n", 0, 4); - x2("あ|い", "あ", 0, 1); - x2("あ|い", "い", 0, 1); - x2("あい|いう", "あい", 0, 2); - x2("あい|いう", "いう", 0, 2); - x2("を(?:かき|きく)", "をかき", 0, 3); - x2("を(?:かき|きく)け", "をきくけ", 0, 4); - x2("あい|(?:あう|あを)", "あを", 0, 2); - x2("あ|い|う", "えう", 1, 2); - x2("あ|い|うえ|おかき|く|けこさ|しすせ|そ|たち|つてとなに|ぬね", "しすせ", 0, 3); - n("あ|い|うえ|おかき|く|けこさ|しすせ|そ|たち|つてとなに|ぬね", "すせ"); - x2("あ|^わ", "ぶあ", 1, 2); - x2("あ|^を", "をあ", 0, 1); - x2("鬼|\\G車", "け車鬼", 2, 3); - x2("鬼|\\G車", "車鬼", 0, 1); - x2("鬼|\\A車", "b車鬼", 2, 3); - x2("鬼|\\A車", "車", 0, 1); - x2("鬼|車\\Z", "車鬼", 1, 2); - x2("鬼|車\\Z", "車", 0, 1); - x2("鬼|車\\Z", "車\n", 0, 1); - x2("鬼|車\\z", "車鬼", 1, 2); - x2("鬼|車\\z", "車", 0, 1); - x2("\\w|\\s", "お", 0, 1); - x2("\\w|%", "%お", 0, 1); - x2("\\w|[&$]", "う&", 0, 1); - x2("[い-け]", "う", 0, 1); - x2("[い-け]|[^か-こ]", "あ", 0, 1); - x2("[い-け]|[^か-こ]", "か", 0, 1); - x2("[^あ]", "\n", 0, 1); - x2("(?:あ|[う-き])|いを", "うを", 0, 1); - x2("(?:あ|[う-き])|いを", "いを", 0, 2); - x2("あいう|(?=けけ)..ほ", "けけほ", 0, 3); - x2("あいう|(?!けけ)..ほ", "あいほ", 0, 3); - x2("(?=をあ)..あ|(?=をを)..あ", "ををあ", 0, 3); - x2("(?<=あ|いう)い", "いうい", 2, 3); - n("(?>あ|あいえ)う", "あいえう"); - x2("(?>あいえ|あ)う", "あいえう", 0, 4); - x2("あ?|い", "あ", 0, 1); - x2("あ?|い", "い", 0, 0); - x2("あ?|い", "", 0, 0); - x2("あ*|い", "ああ", 0, 2); - x2("あ*|い*", "いあ", 0, 0); - x2("あ*|い*", "あい", 0, 1); - x2("[aあ]*|い*", "aあいいい", 0, 2); - x2("あ+|い*", "", 0, 0); - x2("あ+|い*", "いいい", 0, 3); - x2("あ+|い*", "あいいい", 0, 1); - x2("あ+|い*", "aあいいい", 0, 0); - n("あ+|い+", ""); - x2("(あ|い)?", "い", 0, 1); - x2("(あ|い)*", "いあ", 0, 2); - x2("(あ|い)+", "いあい", 0, 3); - x2("(あい|うあ)+", "うああいうえ", 0, 4); - x2("(あい|うえ)+", "うああいうえ", 2, 6); - x2("(あい|うあ)+", "ああいうあ", 1, 5); - x2("(あい|うあ)+", "あいをうあ", 0, 2); - x2("(あい|うあ)+", "$$zzzzあいをうあ", 6, 8); - x2("(あ|いあい)+", "あいあいあ", 0, 5); - x2("(あ|いあい)+", "いあ", 1, 2); - x2("(あ|いあい)+", "いあああいあ", 1, 4); - x2("(?:あ|い)(?:あ|い)", "あい", 0, 2); - x2("(?:あ*|い*)(?:あ*|い*)", "あああいいい", 0, 3); - x2("(?:あ*|い*)(?:あ+|い+)", "あああいいい", 0, 6); - x2("(?:あ+|い+){2}", "あああいいい", 0, 6); - x2("(?:あ+|い+){1,2}", "あああいいい", 0, 6); - x2("(?:あ+|\\Aい*)うう", "うう", 0, 2); - n("(?:あ+|\\Aい*)うう", "あいうう"); - x2("(?:^あ+|い+)*う", "ああいいいあいう", 6, 8); - x2("(?:^あ+|い+)*う", "ああいいいいう", 0, 7); - x2("う{0,}", "うううう", 0, 4); - x2("あ|(?i)c", "C", 0, 1); - x2("(?i)c|あ", "C", 0, 1); - x2("(?i:あ)|a", "a", 0, 1); - n("(?i:あ)|a", "A"); - x2("[あいう]?", "あいう", 0, 1); - x2("[あいう]*", "あいう", 0, 3); - x2("[^あいう]*", "あいう", 0, 0); - n("[^あいう]+", "あいう"); - x2("あ??", "あああ", 0, 0); - x2("いあ??い", "いあい", 0, 3); - x2("あ*?", "あああ", 0, 0); - x2("いあ*?", "いああ", 0, 1); - x2("いあ*?い", "いああい", 0, 4); - x2("あ+?", "あああ", 0, 1); - x2("いあ+?", "いああ", 0, 2); - x2("いあ+?い", "いああい", 0, 4); - x2("(?:天?)??", "天", 0, 0); - x2("(?:天??)?", "天", 0, 0); - x2("(?:夢?)+?", "夢夢夢", 0, 1); - x2("(?:風+)??", "風風風", 0, 0); - x2("(?:雪+)??霜", "雪雪雪霜", 0, 4); - x2("(?:あい)?{2}", "", 0, 0); - x2("(?:鬼車)?{2}", "鬼車鬼車鬼", 0, 4); - x2("(?:鬼車)*{0}", "鬼車鬼車鬼", 0, 0); - x2("(?:鬼車){3,}", "鬼車鬼車鬼車鬼車", 0, 8); - n("(?:鬼車){3,}", "鬼車鬼車"); - x2("(?:鬼車){2,4}", "鬼車鬼車鬼車", 0, 6); - x2("(?:鬼車){2,4}", "鬼車鬼車鬼車鬼車鬼車", 0, 8); - x2("(?:鬼車){2,4}?", "鬼車鬼車鬼車鬼車鬼車", 0, 4); - x2("(?:鬼車){,}", "鬼車{,}", 0, 5); - x2("(?:かきく)+?{2}", "かきくかきくかきく", 0, 6); - x3("(火)", "火", 0, 1, 1); - x3("(火水)", "火水", 0, 2, 1); - x2("((時間))", "時間", 0, 2); - x3("((風水))", "風水", 0, 2, 1); - x3("((昨日))", "昨日", 0, 2, 2); - x3("((((((((((((((((((((量子))))))))))))))))))))", "量子", 0, 2, 20); - x3("(あい)(うえ)", "あいうえ", 0, 2, 1); - x3("(あい)(うえ)", "あいうえ", 2, 4, 2); - x3("()(あ)いう(えおか)きくけこ", "あいうえおかきくけこ", 3, 6, 3); - x3("(()(あ)いう(えおか)きくけこ)", "あいうえおかきくけこ", 3, 6, 4); - x3(".*(フォ)ン・マ(ン()シュタ)イン", "フォン・マンシュタイン", 5, 9, 2); - x2("(^あ)", "あ", 0, 1); - x3("(あ)|(あ)", "いあ", 1, 2, 1); - x3("(^あ)|(あ)", "いあ", 1, 2, 2); - x3("(あ?)", "あああ", 0, 1, 1); - x3("(ま*)", "ままま", 0, 3, 1); - x3("(と*)", "", 0, 0, 1); - x3("(る+)", "るるるるるるる", 0, 7, 1); - x3("(ふ+|へ*)", "ふふふへへ", 0, 3, 1); - x3("(あ+|い?)", "いいいああ", 0, 1, 1); - x3("(あいう)?", "あいう", 0, 3, 1); - x3("(あいう)*", "あいう", 0, 3, 1); - x3("(あいう)+", "あいう", 0, 3, 1); - x3("(さしす|あいう)+", "あいう", 0, 3, 1); - x3("([なにぬ][かきく]|かきく)+", "かきく", 0, 3, 1); - x3("((?i:あいう))", "あいう", 0, 3, 1); - x3("((?m:あ.う))", "あ\nう", 0, 3, 1); - x3("((?=あん)あ)", "あんい", 0, 1, 1); - x3("あいう|(.あいえ)", "んあいえ", 0, 4, 1); - x3("あ*(.)", "ああああん", 4, 5, 1); - x3("あ*?(.)", "ああああん", 0, 1, 1); - x3("あ*?(ん)", "ああああん", 4, 5, 1); - x3("[いうえ]あ*(.)", "えああああん", 5, 6, 1); - x3("(\\Aいい)うう", "いいうう", 0, 2, 1); - n("(\\Aいい)うう", "んいいうう"); - x3("(^いい)うう", "いいうう", 0, 2, 1); - n("(^いい)うう", "んいいうう"); - x3("ろろ(るる$)", "ろろるる", 2, 4, 1); - n("ろろ(るる$)", "ろろるるる"); - x2("(無)\\1", "無無", 0, 2); - n("(無)\\1", "無武"); - x2("(空?)\\1", "空空", 0, 2); - x2("(空??)\\1", "空空", 0, 0); - x2("(空*)\\1", "空空空空空", 0, 4); - x3("(空*)\\1", "空空空空空", 0, 2, 1); - x2("あ(い*)\\1", "あいいいい", 0, 5); - x2("あ(い*)\\1", "あい", 0, 1); - x2("(あ*)(い*)\\1\\2", "あああいいあああいい", 0, 10); - x2("(あ*)(い*)\\2", "あああいいいい", 0, 7); - x3("(あ*)(い*)\\2", "あああいいいい", 3, 5, 2); - x2("(((((((ぽ*)ぺ))))))ぴ\\7", "ぽぽぽぺぴぽぽぽ", 0, 8); - x3("(((((((ぽ*)ぺ))))))ぴ\\7", "ぽぽぽぺぴぽぽぽ", 0, 3, 7); - x2("(は)(ひ)(ふ)\\2\\1\\3", "はひふひはふ", 0, 6); - x2("([き-け])\\1", "くく", 0, 2); - x2("(\\w\\d\\s)\\1", "あ5 あ5 ", 0, 6); - n("(\\w\\d\\s)\\1", "あ5 あ5"); - x2("(誰？|[あ-う]{3})\\1", "誰？誰？", 0, 4); - x2("...(誰？|[あ-う]{3})\\1", "あaあ誰？誰？", 0, 7); - x2("(誰？|[あ-う]{3})\\1", "ういうういう", 0, 6); - x2("(^こ)\\1", "ここ", 0, 2); - n("(^む)\\1", "めむむ"); - n("(あ$)\\1", "ああ"); - n("(あい\\Z)\\1", "あい"); - x2("(あ*\\Z)\\1", "あ", 1, 1); - x2(".(あ*\\Z)\\1", "いあ", 1, 2); - x3("(.(やいゆ)\\2)", "zやいゆやいゆ", 0, 7, 1); - x3("(.(..\\d.)\\2)", "あ12341234", 0, 9, 1); - x2("((?i:あvず))\\1", "あvずあvず", 0, 6); - x2("(?<愚か>変|\\(\\g<愚か>\\))", "((((((変))))))", 0, 13); - x2("\\A(?:\\g<阿_1>|\\g<云_2>|\\z終了 (?<阿_1>観|自\\g<云_2>自)(?<云_2>在|菩薩\\g<阿_1>菩薩))$", "菩薩自菩薩自在自菩薩自菩薩", 0, 13); - x2("[[ひふ]]", "ふ", 0, 1); - x2("[[いおう]か]", "か", 0, 1); - n("[[^あ]]", "あ"); - n("[^[あ]]", "あ"); - x2("[^[^あ]]", "あ", 0, 1); - x2("[[かきく]&&きく]", "く", 0, 1); - n("[[かきく]&&きく]", "か"); - n("[[かきく]&&きく]", "け"); - x2("[あ-ん&&い-を&&う-ゑ]", "ゑ", 0, 1); - n("[^あ-ん&&い-を&&う-ゑ]", "ゑ"); - x2("[[^あ&&あ]&&あ-ん]", "い", 0, 1); - n("[[^あ&&あ]&&あ-ん]", "あ"); - x2("[[^あ-ん&&いうえお]&&[^う-か]]", "き", 0, 1); - n("[[^あ-ん&&いうえお]&&[^う-か]]", "い"); - x2("[^[^あいう]&&[^うえお]]", "う", 0, 1); - x2("[^[^あいう]&&[^うえお]]", "え", 0, 1); - n("[^[^あいう]&&[^うえお]]", "か"); - x2("[あ-&&-あ]", "-", 0, 1); - x2("[^[^a-zあいう]&&[^bcdefgうえお]q-w]", "え", 0, 1); - x2("[^[^a-zあいう]&&[^bcdefgうえお]g-w]", "f", 0, 1); - x2("[^[^a-zあいう]&&[^bcdefgうえお]g-w]", "g", 0, 1); - n("[^[^a-zあいう]&&[^bcdefgうえお]g-w]", "2"); - x2("a<b>バージョンのダウンロード<\\/b>", "a<b>バージョンのダウンロード</b>", 0, 20); - x2(".<b>バージョンのダウンロード<\\/b>", "a<b>バージョンのダウンロード</b>", 0, 20); - - - # additional test patterns - if is_unicode_encoding(onig_encoding): - x2("\\x{3042}\\x{3044}", "あい", 0, 2) - elif onig_encoding == onigmo.ONIG_ENCODING_SJIS or \ - onig_encoding == onigmo.ONIG_ENCODING_CP932: - x2("\\x{82a0}\\x{82A2}", "あい", 0, 2) - x2("\\M-\\C-b\x50", "１", 0, 1) # \x8250 - elif onig_encoding == onigmo.ONIG_ENCODING_EUC_JP: - x2("\\x{a4a2}\\x{A4A4}", "あい", 0, 2) - x2("\\p{Hiragana}\\p{Katakana}", "あイ", 0, 2) - x2("(?m)^A.B$", "X\nA\nB\nZ", 2, 5) - n("(?<!(?<=a)b|c)d", "abd") - n("(?<!(?<=a)b|c)d", "cd") - x2("(?<!(?<=a)b|c)d", "bd", 1, 2) - x2("(a){2}z", "aaz", 0, 3) - x2("(?<=a).*b", "aab", 1, 3) - x2("(?!a).*b", "ab", 1, 2) - x2("(?<=(?<!A)B)C", "BBC", 2, 3) - n("(?<=(?<!A)B)C", "ABC") - n("(?i)(?<!aa|b)c", "Aac") - n("(?i)(?<!b|aa)c", "Aac") - x2("(?<=\\babc)d", " abcd", 4, 5) - x2("(?<=\\Babc)d", "aabcd", 4, 5) - n("(?<!a(?:bb|c))", "", err=onigmo.ONIGERR_INVALID_LOOK_BEHIND_PATTERN) - x2("a\\b?a", "aa", 0, 2) - x2("[^x]*x", "aaax", 0, 4) - x2("(?i)[\\x{0}-B]+", "\x00\x01\x02\x1f\x20@AaBbC", 0, 10) - x2("(?i)a{2}", "AA", 0, 2) - if is_unicode_encoding(onig_encoding): - # The longest script name - x2("\\p{Other_Default_Ignorable_Code_Point}+", "\u034F\uFFF8\U000E0FFF", 0, 3) - # The longest block name - x2("\\p{In_Unified_Canadian_Aboriginal_Syllabics_Extended}+", "\u18B0\u18FF", 0, 2) - # Unicode case fold - x2("(?i)\u1ffc", "\u2126\u1fbe", 0, 2) - x2("(?i)\u1ffc", "\u1ff3", 0, 1) - x2("(?i)\u0390", "\u03b9\u0308\u0301", 0, 3) - x2("(?i)\u03b9\u0308\u0301", "\u0390", 0, 1) - x2("(?i)ff", "\ufb00", 0, 1) - x2("(?i)\ufb01", "fi", 0, 2) - x2("(?i)\u0149\u0149", "\u0149\u0149", 0, 2) - x2("(?i)(?<=\u0149)a", "\u02bcna", 2, 3) # with look-behind - # Other Unicode tests - x2("\\x{25771}", "\U00025771", 0, 1) - x2("(?i:ss)", "ss", 0, 2) - x2("(?i:ss)", "Ss", 0, 2) - x2("(?i:ss)", "SS", 0, 2) - if is_unicode_encoding(onig_encoding): - x2("(?i:ss)", "\u017fS", 0, 2) # LATIN SMALL LETTER LONG S - x2("(?i:ss)", "s\u017f", 0, 2) - x2("(?i:ss)", "\u00df", 0, 1) # LATIN SMALL LETTER SHARP S - x2("(?i:ss)", "\u1e9e", 0, 1) # LATIN CAPITAL LETTER SHARP S - x2("(?i:xssy)", "xssy", 0, 4) - x2("(?i:xssy)", "xSsy", 0, 4) - x2("(?i:xssy)", "xSSy", 0, 4) - if is_unicode_encoding(onig_encoding): - x2("(?i:xssy)", "x\u017fSy", 0, 4) - x2("(?i:xssy)", "xs\u017fy", 0, 4) - x2("(?i:xssy)", "x\u00dfy", 0, 3) - x2("(?i:xssy)", "x\u1e9ey", 0, 3) - x2("(?i:\u00df)", "ss", 0, 2) - x2("(?i:\u00df)", "SS", 0, 2) - x2("(?i:[\u00df])", "ss", 0, 2) - x2("(?i:[\u00df])", "SS", 0, 2) - x2("(?i)(?<!ss)z", "qqz", 2, 3) # Issue #92 - x2("(?i)(?<!xss)z", "qqz", 2, 3) - x2("[0-9-a]+", " 0123456789-a ", 1, 13) # same as [0-9\-a] - x2("[0-9-\\s]+", " 0123456789-a ", 0, 12) # same as [0-9\-\s] - n("[0-9-a]", "", syn=onigmo.ONIG_SYNTAX_GREP, err=onigmo.ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS) - n("[a-\\d]", "", err=onigmo.ONIGERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE) - x2("[0-9-あ\\\\/\u0001]+", " 0123456789-あ\\/\u0001 ", 1, 16) - x2("[a-b-]+", "ab-", 0, 3) - x2("[a-b-&&-]+", "ab-", 2, 3) - x2("(?i)[a[b-あ]]+", "abあ", 0, 3) - if is_unicode_encoding(onig_encoding): - x2("(?i)[\\d[:^graph:]]+", "0あ", 0, 1) - x2("(?ia)[\\d[:^print:]]+", "0あ", 0, 2) - x2("(?i:a) B", "a B", 0, 3); - x2("(?i:a )B", "a B", 0, 3); - x2("B (?i:a)", "B a", 0, 3); - x2("B(?i: a)", "B a", 0, 3); - if is_unicode_encoding(onig_encoding): - x2("(?a)[\\p{Space}\\d]", "\u00a0", 0, 1) - x2("(?a)[\\d\\p{Space}]", "\u00a0", 0, 1) - n("(?a)[^\\p{Space}\\d]", "\u00a0") - n("(?a)[^\\d\\p{Space}]", "\u00a0") - x2("(?d)[[:space:]\\d]", "\u00a0", 0, 1) - n("(?d)[^\\d[:space:]]", "\u00a0") - n("x.*?\\Z$", "x\ny") - n("x.*?\\Z$", "x\r\ny") - x2("x.*?\\Z$", "x\n", 0, 1) - x2("x.*?\\Z$", "x\r\n", 0, 2) # \Z will match between \r and \n, if - # ONIG_OPTION_NEWLINE_CRLF isn't specified. - x2("(?<=fo).*", "foo", 2, 3) # Issue #15 - x2("(?m)(?<=fo).*", "foo", 2, 3) # Issue #15 - x2("(?m)(?<=fo).+", "foo", 2, 3) # Issue #15 - x2("\\n?\\z", "hello", 5, 5) - x2("\\z", "hello", 5, 5) - x2("\\n?\\z", "こんにちは", 5, 5) - x2("\\z", "こんにちは", 5, 5) - x2("()" * 32767, "", 0, 0) # Issue #24 - n("()" * 32768, "", err=onigmo.ONIGERR_TOO_MANY_CAPTURE_GROUPS) - x2("\\h+ \\H+", " 0123456789aBcDeF gh", 1, 20) - x2("[\\h]+ [\\H]+", " 0123456789aBcDeF gh", 1, 20) - x2("\\A(|.|(?:(.)\\g<1>\\k<2+0>))\\z", "reer", 0, 4) - x2("\\A(?<a>|.|(?:(?<b>.)\\g<a>\\k<b+0>))\\z", "reer", 0, 4) - x2("(?i)\\A(|.|(?:(.)\\g<1>\\k<2+0>))\\z", "reER", 0, 4) - x2("(?i)\\A(?<a>|.|(?:(?<b>.)\\g<a>\\k<b+0>))\\z", "REer", 0, 4) - x2(''' # Extended pattern - (?<element> \g<stag> \g<content>* \g<etag> ){0} - (?<stag> < \g<name> \s* > ){0} - (?<name> [a-zA-Z_:]+ ){0} - (?<content> [^<&]+ (\g<element> | [^<&]+)* ){0} - (?<etag> </ \k<name+1> >){0} - \g<element>''', - "<foo>f<bar>bbb</bar>f</foo>", 0, 27, opt=onigmo.ONIG_OPTION_EXTEND) - x2("(.)(?<a>a)(?<a>b)\\k<a>", "xaba", 0, 4) - x2("\\p{Print}+", "\n a", 1, 3) - x2("\\p{Graph}+", "\n a", 2, 3) - x2("\\p{^Space}", "x", 0, 1) - x2("\\P{^Space}", " ", 0, 1) - n("\\px", "") # warning: invalid Unicode Property - x2("[\\p{^Space}]", "x", 0, 1) - x2("[\\P{^Space}]", " ", 0, 1) - n("[\\px]", "") # warning: invalid Unicode Property - n("a(?!b)", "ab"); - x2("(?:(.)\\1)*", "a" * 300, 0, 300) - x2("\\cA\\C-B\\a[\\b]\\t\\n\\v\\f\\r\\e\\c?", "\x01\x02\x07\x08\x09\x0a\x0b\x0c\x0d\x1b\x7f", 0, 11) - x2("(?<=(?:[a-z]|\\w){3})x", "ab1x", 3, 4) # repeat inside look-behind - x2("(?<n>(a|b\\g<n>c){3,5}?)", "baaaaca", 1, 4) - x2("\\p{WoRd}", "a", 0, 1) # property name is not case sensitive - n("[[:WoRd:]]", "a", err=onigmo.ONIGERR_INVALID_POSIX_BRACKET_TYPE) # POSIX bracket name is case sensitive - n("(\\2)(\\1)", "") # Issue #65 - n("(0?0|(?(1)||)|(?(1)||))?", "", err=onigmo.ONIGERR_INVALID_CONDITION_PATTERN) # Ruby Bug#12418 - n("[\\40000000000", "", err=onigmo.ONIGERR_TOO_BIG_NUMBER) # Ruby Bug#12420 - n("[\\600000000000\n", "", err=onigmo.ONIGERR_TOO_BIG_NUMBER) # Ruby Bug#12423 - n("[]", "", err=onigmo.ONIGERR_EMPTY_CHAR_CLASS) - n("[c-a]", "", err=onigmo.ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS) - x2("[[:ab:\\x{30}]]+", ":ab0x", 0, 4) - x2("[[:x\\]:]+", "[x:]", 0, 4) - x2("[\n\n]", "\n", 0, 1) - x2("[!--x]+", "!-x", 0, 3) - x2(" ]", " ]", 0, 2) # warning: ']' without escape - n("\\x{FFFFFFFF}", "", err=onigmo.ONIGERR_TOO_BIG_WIDE_CHAR_VALUE); - n("\\x{100000000}", "", err=onigmo.ONIGERR_TOO_LONG_WIDE_CHAR_VALUE); - x2("\\u0026", "\u0026", 0, 1) - x2("[\\u0024-\\u0027]", "\u0026", 0, 1) - n("\\u026x", "", err=onigmo.ONIGERR_TOO_SHORT_DIGITS) - n("()(?\\!(?'a')\\1)", "", err=onigmo.ONIGERR_UNDEFINED_GROUP_OPTION) - x2("\\i", "i", 0, 1) # unknown escape warning - n("\\((", "", err=onigmo.ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS) - n("(|", "", err=onigmo.ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS) - x2("%{(.*?)}", "%{HOSTNAME}", 0, 11) - if not is_ascii_incompatible_encoding(onig_encoding): - n(b"'/g\\\xff\xff\xff\xff&))", "", err=onigmo.ONIGERR_UNMATCHED_CLOSE_PARENTHESIS) - n(b"\\\xff0", "") - if onig_encoding == onigmo.ONIG_ENCODING_UTF8: - n(b"[0-0-\xe2 ", "", err=onigmo.ONIGERR_PREMATURE_END_OF_CHAR_CLASS) - n("\\p{foobarbaz}", "", err=onigmo.ONIGERR_INVALID_CHAR_PROPERTY_NAME) - n("\\p{あ}", "", err=onigmo.ONIGERR_INVALID_CHAR_PROPERTY_NAME) - if is_unicode_encoding(onig_encoding): - n("\\p{\U00025771}", "", err=onigmo.ONIGERR_INVALID_CHAR_PROPERTY_NAME) - if onig_encoding == onigmo.ONIG_ENCODING_UTF8: - x2("[\\xce\\xb1\\xce\\xb2]", "β", 0, 1) - elif onig_encoding == onigmo.ONIG_ENCODING_SJIS or \ - onig_encoding == onigmo.ONIG_ENCODING_CP932: - n("[\\x84A]", "", err=onigmo.ONIGERR_TOO_SHORT_MULTI_BYTE_STRING) - elif onig_encoding == onigmo.ONIG_ENCODING_EUC_JP: - n("[\\xAAA]", "", err=onigmo.ONIGERR_TOO_SHORT_MULTI_BYTE_STRING) - elif is_ascii_incompatible_encoding(onig_encoding): - n("[\\x420]", "", err=onigmo.ONIGERR_TOO_SHORT_MULTI_BYTE_STRING) - x2("(?:a?)*", "aa", 0, 2) # tests for reducing nested quantifiers - x2("(?:a?)*?", "aa", 0, 0) - x2("(?:a*)??", "aa", 0, 0) - x2("(?:a+?)*", "aa", 0, 1) - x2("(?:a*){2,3}", "aaa", 0, 3) - n("(?:a+){2,3}", "a") - x2("a{", "a{", 0, 2) # invalid interval is allowed - n("a{100001}", "", err=onigmo.ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE) - n("a{0,100001}", "", err=onigmo.ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE) - n("a{5,1}", "", err=onigmo.ONIGERR_UPPER_SMALLER_THAN_LOWER_IN_REPEAT_RANGE) - x2("abc{1}", "abcc", 0, 3) - x3("\\(((?:[^(]|\\g<0>)*)\\)", "(abc)(abc)", 1, 4, 1) # Issue #48 - x3("\\(((?:[^(]|\\g<0>)*)\\)", "((abc)(abc))", 1, 11, 1) - x3("\\(((?:[^(]|(\\g<0>))*)\\)", "((abc)(abc))", 6, 11, 2) - n("[\\6000", "a", err=onigmo.ONIGERR_TOO_BIG_NUMBER) # CVE-2017-9226 - n("[\\H- ]", "", err=onigmo.ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS) # CVE-2017-9228 - x2("c.*\\b", "abc", 2, 3) # Issue #96 - x2("abc.*\\b", "abc", 0, 3) # Issue #96 - x2("\\b.*abc.*\\b", "abc", 0, 3) # Issue #96 - x2('(?i) *TOOKY', 'Mozilla/5.0 (Linux; Android 4.0.3; TOOKY', 34, 40) # Issue #120 - n("(?", "", err=onigmo.ONIGERR_END_PATTERN_IN_GROUP) - n("(?#", "", err=onigmo.ONIGERR_END_PATTERN_IN_GROUP) - n("\\", "", err=onigmo.ONIGERR_END_PATTERN_AT_ESCAPE) - n("\\M", "", err=onigmo.ONIGERR_END_PATTERN_AT_META) - n("\\M#", "", err=onigmo.ONIGERR_META_CODE_SYNTAX) - n("\\C", "", err=onigmo.ONIGERR_END_PATTERN_AT_CONTROL) - n("\\C#", "", err=onigmo.ONIGERR_CONTROL_CODE_SYNTAX) - n("(?0d", "", syn=onigmo.ONIG_SYNTAX_PERL, err=onigmo.ONIGERR_INVALID_GROUP_NAME) # Issue #132 - if onig_encoding == onigmo.ONIG_ENCODING_UTF8: - n("\\x{1000000}", "", err=onigmo.ONIGERR_TOO_BIG_WIDE_CHAR_VALUE) - else: - n("\\x{1000000}", "") # TODO: Should be an error? (code_to_mbc()) - if onig_encoding == onigmo.ONIG_ENCODING_SJIS or \ - onig_encoding == onigmo.ONIG_ENCODING_CP932 or \ - onig_encoding == onigmo.ONIG_ENCODING_EUC_JP or \ - onig_encoding == onigmo.ONIG_ENCODING_UTF8: - n("[\\x{1000000}]", "", err=onigmo.ONIGERR_TOO_BIG_WIDE_CHAR_VALUE) - else: - n("[\\x{1000000}]", "") # TODO: Should be an error? (code_to_mbclen()) - - # ONIG_OPTION_FIND_LONGEST option - x2("foo|foobar", "foobar", 0, 3) - x2("foo|foobar", "foobar", 0, 6, opt=onigmo.ONIG_OPTION_FIND_LONGEST) - x2("a*", "aa aaa aaaa aaaaa ", 12, 17, opt=onigmo.ONIG_OPTION_FIND_LONGEST) - - # ONIG_OPTION_FIND_NOT_EMPTY option - x2("\w*", " a", 0, 0) - x2("\w*", " a", 1, 2, opt=onigmo.ONIG_OPTION_FIND_NOT_EMPTY) - - # ONIG_OPTION_DONT_CAPTURE_GROUP option - x2("(ab|cd)*", "cdab", 0, 4, opt=onigmo.ONIG_OPTION_DONT_CAPTURE_GROUP) - n("(ab|cd)*\\1", "", opt=onigmo.ONIG_OPTION_DONT_CAPTURE_GROUP, err=onigmo.ONIGERR_INVALID_BACKREF) - n("", "", opt=(onigmo.ONIG_OPTION_DONT_CAPTURE_GROUP | onigmo.ONIG_OPTION_CAPTURE_GROUP), err=onigmo.ONIGERR_INVALID_COMBINATION_OF_OPTIONS) - - # character classes (tests for character class optimization) - x2("[@][a]", "@a", 0, 2); - x2(".*[a][b][c][d][e]", "abcde", 0, 5); - x2("(?i)[A\\x{41}]", "a", 0, 1); - x2("[abA]", "a", 0, 1); - x2("[[ab]&&[ac]]+", "aaa", 0, 3); - x2("[[ab]&&[^b]]+", "aaa", 0, 3); - x2("[[^b]&&[ab]]+", "aaa", 0, 3); - x2("[[あい]&&[あう]]+", "あああ", 0, 3); - x2("[[あい]&&[^い]]+", "あああ", 0, 3); - x2("[[^い]&&[あい]]+", "あああ", 0, 3); - - # possessive quantifiers - n("a?+a", "a") - n("a*+a", "aaaa") - n("a++a", "aaaa") - x2("a{2,3}+a", "aaa", 0, 3) # Not a possessive quantifier in Ruby, - # same as "(?:a{2,3})+a" - n("a{2,3}+a", "aaa", syn=onigmo.ONIG_SYNTAX_PERL) - - # automatic possessification - x2("\\w+\\W", "abc#", 0, 4) - x2("[a-c]+\\W", "abc#", 0, 4) - x2("[a-c#]+\\W", "abc#", 0, 4) - x2("[^a-c]+\\W", "def#", 0, 4) - x2("(?a)[^a-c]+\\W", "def#", 0, 4) - x2("a+\\w", "aaaa", 0, 4) - x2("#+\\w", "###a", 0, 4) - x2("(?a)a+\\w", "aaaa", 0, 4) - x2("(?a)あ+\\w", "あああa", 0, 4) - x2("[a-c]+[d-f]", "abcd", 0, 4) - x2("[^d-f]+[d-f]", "abcd", 0, 4) - x2("[a-cあ]+[d-f]", "abcd", 0, 4) - - # linebreak - x2("\\R", "\n", 0, 1) - x2("\\R", "\r", 0, 1) - x2("\\R{3}", "\r\r\n\n", 0, 4) - - if (is_unicode_encoding(onig_encoding)): - x2("\\R", "\u0085", 0, 1) - x2("\\R", "\u2028", 0, 1) - x2("\\R", "\u2029", 0, 1) - - # extended grapheme cluster - x2("\\X{5}", "あいab\n", 0, 5) - x2("\\X", "\n", 0, 1) - x2("\\X", "\r", 0, 1) - x2("\\X{3}", "\r\r\n\n", 0, 4) - if is_unicode_encoding(onig_encoding): - x2("\\X", "\u306F\u309A\n", 0, 2) - x2("\\A\\X\\z", "\u0020\u200d", 0, 2) - x2("\\A\\X\\z", "\u0600\u0600", 0, 2) - x2("\\A\\X\\z", "\u0600\u0020", 0, 2) - x2("\\A\\X\\z", "\u261d\U0001F3FB", 0, 2) - x2("\\A\\X\\z", "\U0001f600", 0, 1) - x2("\\A\\X\\z", "\u0020\u0308", 0, 2) - x2("\\A\\X\\X\\z", "\u000a\u0308", 0, 2) - x2("\\A\\X\\X\\z", "\u000d\u0308", 0, 2) - x2("\\A\\X\\z", "\U0001F477\U0001F3FF\u200D\u2640\uFE0F", 0, 5) - x2("\\A\\X\\z", "\U0001F468\u200D\U0001F393", 0, 3) - x2("\\A\\X\\z", "\U0001F46F\u200D\u2642\uFE0F", 0, 4) - x2("\\A\\X\\z", "\U0001F469\u200d\u2764\ufe0f\u200d\U0001F469", 0, 6) - - # keep - x2("ab\\Kcd", "abcd", 2, 4) - x2("ab\\Kc(\\Kd|z)", "abcd", 3, 4) - x2("ab\\Kc(\\Kz|d)", "abcd", 2, 4) - x2("(a\\K)*", "aaab", 3, 3) - x3("(a\\K)*", "aaab", 2, 3, 1) -# x2("a\\K?a", "aa", 0, 2) # error: differ from perl - x2("ab(?=c\Kd)", "abcd", 2, 2) # This behaviour is currently not well defined. (see: perlre) - x2("(?<=a\\Kb|aa)cd", "abcd", 1, 4) # This behaviour is currently not well defined. (see: perlre) - x2("(?<=ab|a\\Ka)cd", "abcd", 2, 4) # This behaviour is currently not well defined. (see: perlre) - - # named group and subroutine call - x2("(?<name_2>ab)(?&name_2)", "abab", 0, 4, syn=onigmo.ONIG_SYNTAX_PERL); - x2("(?<name_2>ab)(?1)", "abab", 0, 4, syn=onigmo.ONIG_SYNTAX_PERL); - x2("(?'n'|\\((?&n)\\))+$", "()(())", 0, 6, syn=onigmo.ONIG_SYNTAX_PERL); - x2("(a|x(?-1)x)", "xax", 0, 3, syn=onigmo.ONIG_SYNTAX_PERL); - x2("(a|(x(?-2)x))", "xax", 0, 3, syn=onigmo.ONIG_SYNTAX_PERL); - x2("a|x(?0)x", "xax", 0, 3, syn=onigmo.ONIG_SYNTAX_PERL); - x2("a|x(?R)x", "xax", 0, 3, syn=onigmo.ONIG_SYNTAX_PERL); - x2("(a|x\g<0>x)", "xax", 0, 3); - x2("(a|x\g'0'x)", "xax", 0, 3); - x2("(?-i:(?+1))(?i:(a)){0}", "A", 0, 1, syn=onigmo.ONIG_SYNTAX_PERL); - x2("(?-i:\g<+1>)(?i:(a)){0}", "A", 0, 1); - x2("(?-i:\g'+1')(?i:(a)){0}", "A", 0, 1); - n("(.(?=\\g<1>))", "", err=onigmo.ONIGERR_NEVER_ENDING_RECURSION) - n("(a)(?<n>b)\\g<1>\\g<n>", "abab", err=onigmo.ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED) - x2("(a)(?<n>b)(?1)(?&n)", "abab", 0, 4, syn=onigmo.ONIG_SYNTAX_PERL) - x2("((?<v>)a)|b\\g<0>b", "bbabb", 0, 5) - x2("((?<v>)a)|b(?0)b", "bbabb", 0, 5, syn=onigmo.ONIG_SYNTAX_PERL) - x2("((?<v>)a|b(?1)b)", "bbabb", 0, 5, syn=onigmo.ONIG_SYNTAX_PERL) - x2("((?<v>a|b(?&v)b))", "bbabb", 0, 5, syn=onigmo.ONIG_SYNTAX_PERL) - n("(?<", "", err=onigmo.ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS) - n("(?'", "", err=onigmo.ONIGERR_EMPTY_GROUP_NAME) - n("(?<>)", "", err=onigmo.ONIGERR_EMPTY_GROUP_NAME) - n("(?<.>)", "", err=onigmo.ONIGERR_INVALID_CHAR_IN_GROUP_NAME) - n("(?<1>)", "", err=onigmo.ONIGERR_INVALID_GROUP_NAME) - n("(?<-1>)", "", err=onigmo.ONIGERR_INVALID_GROUP_NAME) - n("\\g<1->", "", err=onigmo.ONIGERR_INVALID_CHAR_IN_GROUP_NAME) - n("\\g<", "", err=onigmo.ONIGERR_EMPTY_GROUP_NAME) - n("\\g<a", "", err=onigmo.ONIGERR_INVALID_GROUP_NAME) - n("\\g<->", "", err=onigmo.ONIGERR_INVALID_GROUP_NAME) - n("\\g<-0>", "", err=onigmo.ONIGERR_INVALID_GROUP_NAME) - n("\\g<1a>", "", err=onigmo.ONIGERR_INVALID_GROUP_NAME) - n("\\g<a/>", "", err=onigmo.ONIGERR_INVALID_CHAR_IN_GROUP_NAME) - n("\\k.", "") - n("\\k<", "", err=onigmo.ONIGERR_EMPTY_GROUP_NAME) - n("\\k<>", "", err=onigmo.ONIGERR_EMPTY_GROUP_NAME) - n("\\k<1/>", "", err=onigmo.ONIGERR_INVALID_GROUP_NAME) - n("\\k<1-1/>", "", err=onigmo.ONIGERR_INVALID_GROUP_NAME) - n("\\k<1+", "", err=onigmo.ONIGERR_INVALID_CHAR_IN_GROUP_NAME) - n("\\k<.>", "", err=onigmo.ONIGERR_INVALID_CHAR_IN_GROUP_NAME) - n("\\k<a/>", "", err=onigmo.ONIGERR_INVALID_CHAR_IN_GROUP_NAME) - n("\\k<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", "", err=onigmo.ONIGERR_UNDEFINED_NAME_REFERENCE) - n("\\g<1>", "", err=onigmo.ONIGERR_UNDEFINED_GROUP_REFERENCE) - - # character set modifiers - x2("(?u)\\w+", "あa#", 0, 2); - x2("(?a)\\w+", "あa#", 1, 2); - x2("(?u)\\W+", "あa#", 2, 3); - x2("(?a)\\W+", "あa#", 0, 1); - - x2("(?a)\\b", "あa", 1, 1); - x2("(?a)\\w\\b", "aあ", 0, 1); - x2("(?a)\\B", "a ああ ", 2, 2); - - x2("(?u)\\B", "あ ", 2, 2); - x2("(?a)\\B", "あ ", 0, 0); - x2("(?a)\\B", "aあ ", 2, 2); - - x2("(?a)a\\b", " a", 1, 2) - x2("(?u)a\\b", " a", 1, 2) - n("(?a)a\\B", " a") - n("(?a)あ\\b", " あ") - x2("(?u)あ\\b", " あ", 1, 2) - x2("(?a)あ\\B", " あ", 1, 2) - n("(?u)あ\\B", " あ") - - x2("(?a)\\p{Alpha}\\P{Alpha}", "a。", 0, 2); - x2("(?u)\\p{Alpha}\\P{Alpha}", "a。", 0, 2); - x2("(?a)[[:word:]]+", "aあ", 0, 1); - x2("(?a)[[:^word:]]+", "aあ", 1, 2); - x2("(?u)[[:word:]]+", "aあ", 0, 2); - n("(?u)[[:^word:]]+", "aあ"); - - x2("(?iu)\\p{lower}\\p{upper}", "Ab", 0, 2); - x2("(?ia)\\p{lower}\\p{upper}", "Ab", 0, 2); - x2("(?iu)[[:lower:]][[:upper:]]", "Ab", 0, 2); - x2("(?ia)[[:lower:]][[:upper:]]", "Ab", 0, 2); - - if is_unicode_encoding(onig_encoding): - n("(?ia)\\w+", "\u212a\u017f"); # KELVIN SIGN, LATIN SMALL LETTER LONG S - n("(?ia)[\\w]+", "\u212a\u017f"); - n("(?ia)[^\\W]+", "\u212a\u017f"); - x2("(?ia)[^\\W]+", "ks", 0, 2); - n("(?iu)\\p{ASCII}", "\u212a"); - n("(?iu)\\P{ASCII}", "s"); - n("(?iu)[\\p{ASCII}]", "\u212a"); - n("(?iu)[\\P{ASCII}]", "s"); - n("(?ia)\\p{ASCII}", "\u212a"); - n("(?ia)\\P{ASCII}", "s"); - n("(?ia)[\\p{ASCII}]", "\u212a"); - n("(?ia)[\\P{ASCII}]", "s"); - x2("(?iu)[s]+", "Ss\u017f ", 0, 3); - x2("(?ia)[s]+", "Ss\u017f ", 0, 3); - x2("(?iu)[^s]+", "Ss\u017f ", 3, 4); - x2("(?ia)[^s]+", "Ss\u017f ", 3, 4); - x2("(?iu)[[:lower:]]", "\u017f", 0, 1); - n("(?ia)[[:lower:]]", "\u017f"); - x2("(?u)[[:upper:]]", "\u212a", 0, 1); - n("(?a)[[:upper:]]", "\u212a"); - - # Grep syntax - # \+, \?, \|, \{n,m\} - x2("a\\+", "aa", 0, 2, syn=onigmo.ONIG_SYNTAX_GREP) - n("a\\+", "b", syn=onigmo.ONIG_SYNTAX_GREP) - x2("a\\?", "", 0, 0, syn=onigmo.ONIG_SYNTAX_GREP) - x2("a\\?", "a", 0, 1, syn=onigmo.ONIG_SYNTAX_GREP) - x2("ab\\|cd", "cd", 0, 2, syn=onigmo.ONIG_SYNTAX_GREP) - x2("a\\{1,2\\}", "aaa", 0, 2, syn=onigmo.ONIG_SYNTAX_GREP) - x2("a\\{2\\}", "aaa", 0, 2, syn=onigmo.ONIG_SYNTAX_GREP) - n("a\\{|", "", syn=onigmo.ONIG_SYNTAX_GREP, err=onigmo.ONIGERR_END_PATTERN_AT_LEFT_BRACE) - # \< and \> - x2("\\<abc\\>", " abc ", 1, 4, syn=onigmo.ONIG_SYNTAX_GREP) - n("\\<abc\\>", "zabc ", syn=onigmo.ONIG_SYNTAX_GREP) - n("\\<abc\\>", " abcd", syn=onigmo.ONIG_SYNTAX_GREP) - n("\\<abc\\>", "あabcい", syn=onigmo.ONIG_SYNTAX_GREP) - x2("\\<abc\\>", "あabcい", 1, 4, syn=onigmo.ONIG_SYNTAX_GREP, opt=onigmo.ONIG_OPTION_ASCII_RANGE) - n("\\<abc\\>", "zabcい", syn=onigmo.ONIG_SYNTAX_GREP, opt=onigmo.ONIG_OPTION_ASCII_RANGE) - n("\\<abc\\>", "あabcd", syn=onigmo.ONIG_SYNTAX_GREP, opt=onigmo.ONIG_OPTION_ASCII_RANGE) - # others - n("[^a]", "\n", syn=onigmo.ONIG_SYNTAX_GREP) - x2("*", "*", 0, 1, syn=onigmo.ONIG_SYNTAX_GREP) - #x2("\\{1\\}", "{1}", 0, 3, syn.onigmo.ONIG_SYNTAX_GREP) # fails - n("*", "", err=onigmo.ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED) - n("{1}", "", err=onigmo.ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED) - - # \g{} backref - x2("((?<name1>\\d)|(?<name2>\\w))(\\g{name1}|\\g{name2})", "ff", 0, 2, syn=onigmo.ONIG_SYNTAX_PERL); - x2("(?:(?<x>)|(?<x>efg))\\g{x}", "", 0, 0, syn=onigmo.ONIG_SYNTAX_PERL); - x2("(?:(?<x>abc)|(?<x>efg))\\g{x}", "efgabcabc", 3, 9, syn=onigmo.ONIG_SYNTAX_PERL); - n("(?:(?<x>abc)|(?<x>efg))\\g{x}", "abcefg", syn=onigmo.ONIG_SYNTAX_PERL); - x2("((.*)a\\g{2}f)", "bacbabf", 3, 7, syn=onigmo.ONIG_SYNTAX_PERL); - x2("(.*)a\\g{1}f", "baczzzzzz\nbazz\nzzzzbabf", 19, 23, syn=onigmo.ONIG_SYNTAX_PERL); - x2("((.*)a\\g{-1}f)", "bacbabf", 3, 7, syn=onigmo.ONIG_SYNTAX_PERL); - x2("(.*)a\\g{-1}f", "baczzzzzz\nbazz\nzzzzbabf", 19, 23, syn=onigmo.ONIG_SYNTAX_PERL); - x2("(あ*)(い*)\\g{-2}\\g{-1}", "あああいいあああいい", 0, 10, syn=onigmo.ONIG_SYNTAX_PERL); - - # Python/PCRE compatible named group - x2("(?P<name_2>ab)(?P>name_2)", "abab", 0, 4, syn=onigmo.ONIG_SYNTAX_PERL); - x2("(?P<n>|\\((?P>n)\\))+$", "()(())", 0, 6, syn=onigmo.ONIG_SYNTAX_PERL); - x2("((?P<name1>\\d)|(?P<name2>\\w))((?P=name1)|(?P=name2))", "ff", 0, 2, syn=onigmo.ONIG_SYNTAX_PERL); - n("(?P", "", syn=onigmo.ONIG_SYNTAX_PERL, err=onigmo.ONIGERR_UNDEFINED_GROUP_OPTION) - n("(?PX", "", syn=onigmo.ONIG_SYNTAX_PERL, err=onigmo.ONIGERR_UNDEFINED_GROUP_OPTION) - - # Fullwidth Alphabet - n("ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ", "ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ"); - x2("(?i)ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ", "ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ", 0, 26); - x2("(?i)ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ", "ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ", 0, 26); - x2("(?i)ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ", "ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ", 0, 26); - x2("(?i)ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ", "ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ", 0, 26); - - # Greek - n("αβγδεζηθικλμνξοπρστυφχψω", "ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ"); - x2("(?i)αβγδεζηθικλμνξοπρστυφχψω", "αβγδεζηθικλμνξοπρστυφχψω", 0, 24); - x2("(?i)αβγδεζηθικλμνξοπρστυφχψω", "ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ", 0, 24); - x2("(?i)ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ", "αβγδεζηθικλμνξοπρστυφχψω", 0, 24); - x2("(?i)ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ", "ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ", 0, 24); - - # Cyrillic - n("абвгдеёжзийклмнопрстуфхцчшщъыьэюя", "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ"); - x2("(?i)абвгдеёжзийклмнопрстуфхцчшщъыьэюя", "абвгдеёжзийклмнопрстуфхцчшщъыьэюя", 0, 33); - x2("(?i)абвгдеёжзийклмнопрстуфхцчшщъыьэюя", "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ", 0, 33); - x2("(?i)АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ", "абвгдеёжзийклмнопрстуфхцчшщъыьэюя", 0, 33); - x2("(?i)АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ", "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ", 0, 33); - - # multiple name definition - x2("(?<a>a)(?<a>b)\\k<a>", "aba", 0, 3) - x2("(?<a>a)(?<a>b)\\k<a>", "abb", 0, 3) - x2("(?<a>a)(?<a>b)\\g{a}", "aba", 0, 3, syn=onigmo.ONIG_SYNTAX_PERL) - n("(?<a>a)(?<a>b)\\g{a}", "abb", syn=onigmo.ONIG_SYNTAX_PERL) - n("(?<a>a)(?<a>b)\\g<a>", "aba", err=onigmo.ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL) - x2("(?<a>[ac])(?<a>b)(?&a)", "abc", 0, 3, syn=onigmo.ONIG_SYNTAX_PERL) - n("(?<a>[ac])(?<a>b)(?&a)", "abb", syn=onigmo.ONIG_SYNTAX_PERL) - x2("(?:(?<x>abc)|(?<x>efg))(?i:\\k<x>)", "abcefgEFG", 3, 9) - x2("(?<x>a)(?<x>b)(?i:\\k<x>)+", "abAB", 0, 4) - - # branch reset -# x3("(?|(c)|(?:(b)|(a)))", "a", 0, 1, 2) -# x3("(?|(c)|(?|(b)|(a)))", "a", 0, 1, 1) - - # conditional expression - x2("(?:(a)|(b))(?(1)cd)e", "acde", 0, 4) - n("(?:(a)|(b))(?(1)cd)e", "ae") - x2("(?:(a)|(b))(?(2)cd)e", "ae", 0, 2) - n("(?:(a)|(b))(?(2)cd)e", "acde") - x2("(?:(a)|(b))(?(1)c|d)", "ac", 0, 2) - x2("(?:(a)|(b))(?(1)c|d)", "bd", 0, 2) - n("(?:(a)|(b))(?(1)c|d)", "ad") - n("(?:(a)|(b))(?(1)c|d)", "bc") - x2("(?:(a)|(b))(?:(?(1)cd)e|fg)", "acde", 0, 4) - x2("(?:(a)|(b))(?:(?(1)cd|x)e|fg)", "bxe", 0, 3) - n("(?:(a)|(b))(?:(?(2)cd|x)e|fg)", "bxe") - x2("(?:(?<x>a)|(?<y>b))(?:(?(<x>)cd|x)e|fg)", "bxe", 0, 3) - n("(?:(?<x>a)|(?<y>b))(?:(?(<y>)cd|x)e|fg)", "bxe") - x2("((?<=a))?(?(1)b|c)", "abc", 1, 2) - x2("((?<=a))?(?(1)b|c)", "bc", 1, 2) - x2("((?<x>x)|(?<y>y))(?(<x>)y|x)", "xy", 0, 2) - x2("((?<x>x)|(?<y>y))(?(<x>)y|x)", "yx", 0, 2) - n("((?<x>x)|(?<y>y))(?(<x>)y|x)", "xx") - n("((?<x>x)|(?<y>y))(?(<x>)y|x)", "yy") - n("(a)?(?<n>b)?(?(1)a)(?(<n>)b)", "aa", err=onigmo.ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED) - x2("(a)?(?<n>b)?(?(1)a)(?(<n>)b)", "aa", 0, 2, syn=onigmo.ONIG_SYNTAX_PERL) - n("()(?(2))", "", err=onigmo.ONIGERR_INVALID_BACKREF) # Issue #65 - n("(?(700000))", "", err=onigmo.ONIGERR_INVALID_BACKREF) - - # Implicit-anchor optimization - x2("(?m:.*abc)", "dddabdd\nddabc", 0, 13) # optimized /(?m:.*abc)/ ==> /\A(?m:.*abc)/ - x2("(?m:.+abc)", "dddabdd\nddabc", 0, 13) # optimized - x2("(?-m:.*abc)", "dddabdd\nddabc", 8, 13) # optimized /(?-m:.*abc)/ ==> /(?:^|\A)(?m:.*abc)/ - n("(?-m:.*ab[x-z])", "dddabdd\nddabc") # optimized - x2("(?-m:.*(?:abc|\\Gabc))", "dddabdd\nddabc", 8, 13) # optimized - x2("(?-m:.+abc)", "dddabdd\nddabc", 8, 13) # optimized - x2("(?-m:.*abc)", "dddabdd\nabc", 8, 11) # optimized - n("(?-m:.+abc)", "dddabdd\nabc") # optimized - x2("(?m:.*\\Z)", "dddabdd\nddabc", 0, 13) # optimized /(?m:.*\Z)/ ==> /\A(?m:.*\Z)/ - x2("(?-m:.*\\Z)", "dddabdd\nddabc", 8, 13) # optimized /(?-m:.*\Z)/ ==> /(?:^|\A)(?m:.*\Z)/ - x2("(.*)X\\1", "1234X2345", 1, 8) # not optimized - - # Allow options in look-behind - x2("(?<=(?i)ab)cd", "ABcd", 2, 4) - x2("(?<=(?i:ab))cd", "ABcd", 2, 4) - n("(?<=(?i)ab)cd", "ABCD") - n("(?<=(?i:ab))cd", "ABCD") - x2("(?<!(?i)ab)cd", "aacd", 2, 4) - x2("(?<!(?i:ab))cd", "aacd", 2, 4) - n("(?<!(?i)ab)cd", "ABcd") - n("(?<!(?i:ab))cd", "ABcd") - - # Absent operator - x2("<-(?~->)->", "<- ->->", 0, 5) - x2("<-(?~->)->\n", "<-1->2<-3->\n", 6, 12) - x2("<-(?~->)->.*<-(?~->)->", "<-1->2<-3->4<-5->", 0, 17) - x2("<-(?~->)->.*?<-(?~->)->", "<-1->2<-3->4<-5->", 0, 11) - x2("(?~abc)c", "abc", 0, 3) - x2("(?~abc)bc", "abc", 0, 3) - x2("(?~abc)abc", "abc", 0, 3) - n("(?~)", " ") - n("(?~)", "") - n(" (?~)", " ") - n(" (?~)", " ") - x2("(?~(?~))", "abc", 0, 3) - x2("(?~a)", "", 0, 0) - x2("(?~a)a", "a", 0, 1) - x2("(?~a)", "x", 0, 1) - x2("(?~a)a", "xa", 0, 2) - x2("(?~.)", "", 0, 0) - x2("(?~.)a", "a", 0, 1) - x2("(?~.)", "x", 0, 0) - x2("(?~.)a", "xa", 1, 2) - x2("(?~abc)", "abc", 0, 2) - x2("(?~b)", "abc", 0, 1) - x2("(?~abc|b)", "abc", 0, 1) - n("(?~|abc)", "abc") # ??? - x2("(?~abc|)", "abc", 0, 1) # ??? - x2("(?~abc|def)x", "abcx", 1, 4) - x2("(?~abc|def)x", "defx", 1, 4) - x2("^(?~\\S+)TEST", "TEST", 0, 4) - x3('(?~(a)c)', 'aab', -1, -1, 1) # $1 should not match. - - # Perl syntax - x2("\\Q()\\[a]\\E[b]", "()\\[a]b", 0, 7, syn=onigmo.ONIG_SYNTAX_PERL) - x2("\\Q()\\[a]", "()\\[a]", 0, 6, syn=onigmo.ONIG_SYNTAX_PERL) # no \E - x2("(?a)(?d)\\w+", "あ", 0, 1, syn=onigmo.ONIG_SYNTAX_PERL) # For now (?d) == (?u) - x2("(?a)(?l)\\w+", "あ", 0, 1, syn=onigmo.ONIG_SYNTAX_PERL) # For now (?l) == (?u) - x2("(?a)(?^)\\w+", "あ", 0, 1, syn=onigmo.ONIG_SYNTAX_PERL) - n("(?i)(?^)a", "A", syn=onigmo.ONIG_SYNTAX_PERL) - n("(?m)(?^)a$", "a\nb", syn=onigmo.ONIG_SYNTAX_PERL) - x2("(?s)(?^).*", "a\nb", 0, 1, syn=onigmo.ONIG_SYNTAX_PERL) - x2("\\o{046}", "\046", 0, 1, syn=onigmo.ONIG_SYNTAX_PERL); - x2("[\\o{044}-\\o{047}]", "\046", 0, 1, syn=onigmo.ONIG_SYNTAX_PERL); - n("\\o{40000000000}", "", syn=onigmo.ONIG_SYNTAX_PERL, err=onigmo.ONIGERR_TOO_BIG_WIDE_CHAR_VALUE); - n("\\o{100000000000}", "", syn=onigmo.ONIG_SYNTAX_PERL, err=onigmo.ONIGERR_TOO_LONG_WIDE_CHAR_VALUE); - n("[\\o{40000000000}]", "", syn=onigmo.ONIG_SYNTAX_PERL, err=onigmo.ONIGERR_TOO_BIG_WIDE_CHAR_VALUE); - n("[\\o{100000000000}]", "", syn=onigmo.ONIG_SYNTAX_PERL, err=onigmo.ONIGERR_TOO_LONG_WIDE_CHAR_VALUE); - - # Backward search - x2("abc", "abcabc", 3, 6, searchtype=SearchType.BACKWARD) - x2("あいう", "あいうあいう", 3, 6, searchtype=SearchType.BACKWARD) - x2("(?i)abc", "ABCABC", 3, 6, searchtype=SearchType.BACKWARD) - x2("(?i)ａｂｃ", "ＡＢＣＡＢＣ", 3, 6, searchtype=SearchType.BACKWARD) - x2("[a-z]{3}$", "abcabc", 3, 6, searchtype=SearchType.BACKWARD) - x2("[あ-ん]{3}$", "あいうあいう", 3, 6, searchtype=SearchType.BACKWARD) - x2(".*[a-z]bc", "abcabc", 3, 6, searchtype=SearchType.BACKWARD) # Issue #69 - x2(".+[a-z]bc", "abcabc", 2, 6, searchtype=SearchType.BACKWARD) # Issue #69 - x2(".{1,3}[a-z]bc", "abcabc", 2, 6, searchtype=SearchType.BACKWARD) - - # onig_match() - x2("abc", "abcabc", 0, 3, searchtype=SearchType.MATCH) - n("abc", " abcabc", searchtype=SearchType.MATCH) - - # onig_search_gpos() - n("\\Gabc", "123abcdef", gpos=2) - x2("\\Gabc", "123abcdef", 3, 6, gpos=3) - x2("\\Gabc", "123abcdef", 3, 6, startpos=3) - n("\\Gabc", "123abcdef", gpos=0, startpos=3) - x2("abc\\G", "abc", 0, 3, searchtype=SearchType.BACKWARD) - n("abc\\G", "abc ", searchtype=SearchType.BACKWARD) - x2("abc\\G", "abc ", 0, 3, searchtype=SearchType.BACKWARD, endpos=3) - x2("abc\\G", "abc ", 0, 3, searchtype=SearchType.BACKWARD, gpos=3) - - # stack size - stack_size = onigmo.onig_get_match_stack_limit_size() - print("Default stack size:", stack_size) - onigmo.onig_set_match_stack_limit_size(1000) - print("New stack size:", onigmo.onig_get_match_stack_limit_size()) - # These patterns need deep stack. - n("^a*$", "a" * 200 + "b") - n("^a*$", "a" * 2000 + "b", execerr=onigmo.ONIGERR_MATCH_STACK_LIMIT_OVER) - onigmo.onig_set_match_stack_limit_size(0) - - # parse depth - parse_depth = onigmo.onig_get_parse_depth_limit() - print("Default parse depth:", parse_depth) - onigmo.onig_set_parse_depth_limit(1000) - print("New parse depth:", onigmo.onig_get_parse_depth_limit()) - # These patterns need deep parse stack. - x2("(" * 200 + "a" + ")" * 200, "a", 0, 1) - n("(" * 2000 + "a" + ")" * 2000, "a", err=onigmo.ONIGERR_PARSE_DEPTH_LIMIT_OVER) - x2("X" + "+" * 100, "X", 0, 1) - n("X" + "+" * 10000, "X", err=onigmo.ONIGERR_PARSE_DEPTH_LIMIT_OVER) - onigmo.onig_set_parse_depth_limit(0) - - # syntax functions - onigmo.onig_set_syntax_op(syntax_default, - onigmo.onig_get_syntax_op(onigmo.ONIG_SYNTAX_DEFAULT)) - onigmo.onig_set_syntax_op2(syntax_default, - onigmo.onig_get_syntax_op2(onigmo.ONIG_SYNTAX_DEFAULT)) - onigmo.onig_set_syntax_behavior(syntax_default, - onigmo.onig_get_syntax_behavior(onigmo.ONIG_SYNTAX_DEFAULT)) - onigmo.onig_set_default_syntax(None) - - - print("\nEncoding:", get_encoding_name(onig_encoding)) - print("RESULT SUCC: %d, FAIL: %d, ERROR: %d (by Onigmo %s)" % ( - nsucc, nfail, nerror, onigmo.onig_version())) - - onigmo.onig_end() - - if (nfail == 0 and nerror == 0): - exit(0) - else: - exit(-1) - -if __name__ == '__main__': - main() - |