From 2df13c73103d4bd95a5f4fec741e0ed2f17852f1 Mon Sep 17 00:00:00 2001 From: Ryan Dahl Date: Wed, 23 Sep 2009 14:49:51 +0200 Subject: Upgrade v8 to 1.3.13 --- deps/v8/AUTHORS | 1 + deps/v8/ChangeLog | 24 + deps/v8/LICENSE | 13 +- deps/v8/include/v8.h | 17 +- deps/v8/src/SConscript | 17 +- deps/v8/src/api.cc | 9 +- deps/v8/src/arm/builtins-arm.cc | 16 + deps/v8/src/arm/codegen-arm.cc | 2 +- deps/v8/src/arm/constants-arm.h | 24 +- deps/v8/src/arm/macro-assembler-arm.cc | 16 +- deps/v8/src/bootstrapper.cc | 4 +- deps/v8/src/builtins.cc | 6 +- deps/v8/src/builtins.h | 11 +- deps/v8/src/handles.cc | 85 +- deps/v8/src/handles.h | 6 +- deps/v8/src/heap-profiler.cc | 548 ++ deps/v8/src/heap-profiler.h | 266 + deps/v8/src/heap.cc | 178 +- deps/v8/src/heap.h | 14 - deps/v8/src/ia32/builtins-ia32.cc | 460 ++ deps/v8/src/log-utils.cc | 14 + deps/v8/src/log-utils.h | 9 +- deps/v8/src/log.cc | 43 +- deps/v8/src/log.h | 2 + deps/v8/src/mark-compact.cc | 49 +- deps/v8/src/messages.js | 3 +- deps/v8/src/objects-debug.cc | 1 - deps/v8/src/objects-inl.h | 10 - deps/v8/src/objects.cc | 98 +- deps/v8/src/objects.h | 30 +- deps/v8/src/runtime.cc | 107 +- deps/v8/src/runtime.h | 3 + deps/v8/src/serialize.cc | 38 +- deps/v8/src/serialize.h | 3 +- deps/v8/src/spaces.cc | 14 +- deps/v8/src/string-stream.cc | 2 +- deps/v8/src/string-stream.h | 2 +- deps/v8/src/v8-counters.h | 2 + deps/v8/src/v8natives.js | 18 +- deps/v8/src/version.cc | 4 +- deps/v8/src/x64/builtins-x64.cc | 16 + deps/v8/src/zone-inl.h | 19 +- deps/v8/src/zone.h | 8 +- deps/v8/test/cctest/SConscript | 1 + deps/v8/test/cctest/test-heap-profiler.cc | 330 + deps/v8/test/es5conform/README | 14 + deps/v8/test/es5conform/es5conform.status | 68 + deps/v8/test/es5conform/harness-adapt.js | 74 + deps/v8/test/es5conform/testcfg.py | 108 + deps/v8/test/mjsunit/arguments-enum.js | 14 +- deps/v8/test/mjsunit/array-constructor.js | 119 + deps/v8/test/mjsunit/array-splice-webkit.js | 60 - deps/v8/test/mjsunit/mjsunit.status | 1 + deps/v8/test/mjsunit/regexp-pcre.js | 6603 -------------------- deps/v8/test/mjsunit/testcfg.py | 3 +- .../mjsunit/third_party/array-splice-webkit.js | 62 + deps/v8/test/mjsunit/third_party/object-keys.js | 66 + deps/v8/test/mjsunit/third_party/regexp-pcre.js | 6603 ++++++++++++++++++++ deps/v8/test/mozilla/mozilla.status | 7 +- deps/v8/tools/gyp/v8.gyp | 2 + deps/v8/tools/run-valgrind.py | 2 +- deps/v8/tools/v8.xcodeproj/project.pbxproj | 10 +- deps/v8/tools/visual_studio/v8_base.vcproj | 8 + deps/v8/tools/visual_studio/v8_base_arm.vcproj | 8 + deps/v8/tools/visual_studio/v8_base_x64.vcproj | 8 + deps/v8/tools/visual_studio/v8_cctest.vcproj | 4 + deps/v8/tools/visual_studio/v8_cctest_arm.vcproj | 4 + deps/v8/tools/visual_studio/v8_cctest_x64.vcproj | 4 + 68 files changed, 9195 insertions(+), 7200 deletions(-) create mode 100644 deps/v8/src/heap-profiler.cc create mode 100644 deps/v8/src/heap-profiler.h create mode 100644 deps/v8/test/cctest/test-heap-profiler.cc create mode 100644 deps/v8/test/es5conform/README create mode 100644 deps/v8/test/es5conform/es5conform.status create mode 100644 deps/v8/test/es5conform/harness-adapt.js create mode 100644 deps/v8/test/es5conform/testcfg.py create mode 100644 deps/v8/test/mjsunit/array-constructor.js delete mode 100644 deps/v8/test/mjsunit/array-splice-webkit.js delete mode 100644 deps/v8/test/mjsunit/regexp-pcre.js create mode 100644 deps/v8/test/mjsunit/third_party/array-splice-webkit.js create mode 100644 deps/v8/test/mjsunit/third_party/object-keys.js create mode 100644 deps/v8/test/mjsunit/third_party/regexp-pcre.js diff --git a/deps/v8/AUTHORS b/deps/v8/AUTHORS index 5c5ae4e1b8..de8cabb0b1 100644 --- a/deps/v8/AUTHORS +++ b/deps/v8/AUTHORS @@ -10,6 +10,7 @@ Alexandre Vassalotti Craig Schlenter Daniel Andersson Daniel James +Jan de Mooij Jay Freeman Joel Stanley Matt Hanselman diff --git a/deps/v8/ChangeLog b/deps/v8/ChangeLog index 009296cb44..8c7459168d 100644 --- a/deps/v8/ChangeLog +++ b/deps/v8/ChangeLog @@ -1,3 +1,27 @@ +2009-09-23: Version 1.3.13 + + Fixed uninitialized memory problem. + + Improved heap profiler support. + + +2009-09-22: Version 1.3.12 + + Changed behavior of |function|.toString() on built-in functions to + be compatible with other implementations. Patch by Jan de Mooij. + + Added Object::IsDirty in the API. + + Optimized array construction; it is now handled purely in native + code. + + [ES5] Made properties of the arguments array enumerable. + + [ES5] Added test suite adapter for the es5conform test suite. + + [ES5] Added Object.keys function. + + 2009-09-15: Version 1.3.11 Fixed crash in error reporting during bootstrapping. diff --git a/deps/v8/LICENSE b/deps/v8/LICENSE index 553cf4755f..d2862b4ee8 100644 --- a/deps/v8/LICENSE +++ b/deps/v8/LICENSE @@ -2,10 +2,15 @@ This license applies to all parts of V8 that are not externally maintained libraries. The externally maintained libraries used by V8 are: - - PCRE test suite, located in test/mjsunit/regexp-pcre.js. This is - based on the test suite from PCRE-7.3, which is copyrighted by the - University of Cambridge and Google, Inc. The copyright notice and - license are embedded in regexp-pcre.js. + - PCRE test suite, located in + test/mjsunit/third_party/regexp-pcre.js. This is based on the + test suite from PCRE-7.3, which is copyrighted by the University + of Cambridge and Google, Inc. The copyright notice and license + are embedded in regexp-pcre.js. + + - Layout tests, located in test/mjsunit/third_party. These are + based on layout tests from webkit.org which are copyrighted by + Apple Computer, Inc. and released under a 3-clause BSD license. - Dtoa, located under third_party/dtoa. This code is copyrighted by David M. Gay and released under an MIT license. diff --git a/deps/v8/include/v8.h b/deps/v8/include/v8.h index 24dc6d13f7..1a3177bb0d 100644 --- a/deps/v8/include/v8.h +++ b/deps/v8/include/v8.h @@ -1238,6 +1238,15 @@ class V8EXPORT Object : public Value { bool SetHiddenValue(Handle key, Handle value); Local GetHiddenValue(Handle key); bool DeleteHiddenValue(Handle key); + + /** + * Returns true if this is an instance of an api function (one + * created from a function created from a function template) and has + * been modified since it was created. Note that this method is + * conservative and may return true for objects that haven't actually + * been modified. + */ + bool IsDirty(); /** * Clone this object with a fast but shallow copy. Values will point @@ -1537,9 +1546,9 @@ enum AccessType { /** * Returns true if cross-context access should be allowed to the named - * property with the given key on the global object. + * property with the given key on the host object. */ -typedef bool (*NamedSecurityCallback)(Local global, +typedef bool (*NamedSecurityCallback)(Local host, Local key, AccessType type, Local data); @@ -1547,9 +1556,9 @@ typedef bool (*NamedSecurityCallback)(Local global, /** * Returns true if cross-context access should be allowed to the indexed - * property with the given index on the global object. + * property with the given index on the host object. */ -typedef bool (*IndexedSecurityCallback)(Local global, +typedef bool (*IndexedSecurityCallback)(Local host, uint32_t index, AccessType type, Local data); diff --git a/deps/v8/src/SConscript b/deps/v8/src/SConscript index a1cbf1ba29..423064782a 100755 --- a/deps/v8/src/SConscript +++ b/deps/v8/src/SConscript @@ -42,14 +42,15 @@ SOURCES = { 'debug.cc', 'debug-agent.cc', 'disassembler.cc', 'execution.cc', 'factory.cc', 'flags.cc', 'frame-element.cc', 'frames.cc', 'func-name-inferrer.cc', 'global-handles.cc', 'handles.cc', - 'hashmap.cc', 'heap.cc', 'ic.cc', 'interpreter-irregexp.cc', - 'jsregexp.cc', 'jump-target.cc', 'log.cc', 'log-utils.cc', - 'mark-compact.cc', 'messages.cc', 'objects.cc', 'oprofile-agent.cc', - 'parser.cc', 'property.cc', 'regexp-macro-assembler.cc', - 'regexp-macro-assembler-irregexp.cc', 'regexp-stack.cc', - 'register-allocator.cc', 'rewriter.cc', 'runtime.cc', 'scanner.cc', - 'scopeinfo.cc', 'scopes.cc', 'serialize.cc', 'snapshot-common.cc', - 'spaces.cc', 'string-stream.cc', 'stub-cache.cc', 'token.cc', 'top.cc', + 'hashmap.cc', 'heap.cc', 'heap-profiler.cc', 'ic.cc', + 'interpreter-irregexp.cc', 'jsregexp.cc', 'jump-target.cc', + 'log.cc', 'log-utils.cc', 'mark-compact.cc', 'messages.cc', + 'objects.cc', 'oprofile-agent.cc', 'parser.cc', 'property.cc', + 'regexp-macro-assembler.cc', 'regexp-macro-assembler-irregexp.cc', + 'regexp-stack.cc', 'register-allocator.cc', 'rewriter.cc', + 'runtime.cc', 'scanner.cc', 'scopeinfo.cc', 'scopes.cc', + 'serialize.cc', 'snapshot-common.cc', 'spaces.cc', + 'string-stream.cc', 'stub-cache.cc', 'token.cc', 'top.cc', 'unicode.cc', 'usage-analyzer.cc', 'utils.cc', 'v8-counters.cc', 'v8.cc', 'v8threads.cc', 'variables.cc', 'version.cc', 'virtual-frame.cc', 'zone.cc' diff --git a/deps/v8/src/api.cc b/deps/v8/src/api.cc index 052e875169..eaa4f5a45e 100644 --- a/deps/v8/src/api.cc +++ b/deps/v8/src/api.cc @@ -1191,6 +1191,7 @@ v8::TryCatch::TryCatch() exception_(i::Heap::the_hole_value()), message_(i::Smi::FromInt(0)), is_verbose_(false), + can_continue_(true), capture_message_(true), js_handler_(NULL) { i::Top::RegisterTryCatchHandler(this); @@ -1988,7 +1989,8 @@ Local v8::Object::GetPropertyNames() { ENTER_V8; v8::HandleScope scope; i::Handle self = Utils::OpenHandle(this); - i::Handle value = i::GetKeysInFixedArrayFor(self); + i::Handle value = + i::GetKeysInFixedArrayFor(self, i::INCLUDE_PROTOS); // Because we use caching to speed up enumeration it is important // to never change the result of the basic enumeration function so // we clone the result. @@ -2155,6 +2157,11 @@ void v8::Object::TurnOnAccessCheck() { } +bool v8::Object::IsDirty() { + return Utils::OpenHandle(this)->IsDirty(); +} + + Local v8::Object::Clone() { ON_BAILOUT("v8::Object::Clone()", return Local()); ENTER_V8; diff --git a/deps/v8/src/arm/builtins-arm.cc b/deps/v8/src/arm/builtins-arm.cc index 920110f92e..cdea1cbf6d 100644 --- a/deps/v8/src/arm/builtins-arm.cc +++ b/deps/v8/src/arm/builtins-arm.cc @@ -51,6 +51,22 @@ void Builtins::Generate_Adaptor(MacroAssembler* masm, CFunctionId id) { } +void Builtins::Generate_ArrayCode(MacroAssembler* masm) { + // Just jump to the generic array code. + Code* code = Builtins::builtin(Builtins::ArrayCodeGeneric); + Handle array_code(code); + __ Jump(array_code, RelocInfo::CODE_TARGET); +} + + +void Builtins::Generate_ArrayConstructCode(MacroAssembler* masm) { + // Just jump to the generic construct code. + Code* code = Builtins::builtin(Builtins::JSConstructStubGeneric); + Handle generic_construct_stub(code); + __ Jump(generic_construct_stub, RelocInfo::CODE_TARGET); +} + + void Builtins::Generate_JSConstructCall(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- r0 : number of arguments diff --git a/deps/v8/src/arm/codegen-arm.cc b/deps/v8/src/arm/codegen-arm.cc index 9ef879a5f5..477ea0519b 100644 --- a/deps/v8/src/arm/codegen-arm.cc +++ b/deps/v8/src/arm/codegen-arm.cc @@ -4335,7 +4335,7 @@ static void CountLeadingZeros( Register source, Register scratch, Register zeros) { -#ifdef __ARM_ARCH_5__ +#ifdef CAN_USE_ARMV5_INSTRUCTIONS __ clz(zeros, source); // This instruction is only supported after ARM5. #else __ mov(zeros, Operand(0)); diff --git a/deps/v8/src/arm/constants-arm.h b/deps/v8/src/arm/constants-arm.h index 2f2b709508..6bd0d00804 100644 --- a/deps/v8/src/arm/constants-arm.h +++ b/deps/v8/src/arm/constants-arm.h @@ -43,10 +43,30 @@ # define USE_THUMB_INTERWORK 1 #endif +#if defined(__ARM_ARCH_5T__) || \ + defined(__ARM_ARCH_5TE__) || \ + defined(__ARM_ARCH_6__) || \ + defined(__ARM_ARCH_7A__) || \ + defined(__ARM_ARCH_7__) +# define CAN_USE_ARMV5_INSTRUCTIONS 1 +# define CAN_USE_THUMB_INSTRUCTIONS 1 +#endif + +#if defined(__ARM_ARCH_6__) || \ + defined(__ARM_ARCH_7A__) || \ + defined(__ARM_ARCH_7__) +# define CAN_USE_ARMV6_INSTRUCTIONS 1 +#endif + +#if defined(__ARM_ARCH_7A__) || \ + defined(__ARM_ARCH_7__) +# define CAN_USE_ARMV7_INSTRUCTIONS 1 +#endif + // Simulator should support ARM5 instructions. #if !defined(__arm__) -# define __ARM_ARCH_5__ 1 -# define __ARM_ARCH_5T__ 1 +# define CAN_USE_ARMV5_INSTRUCTIONS 1 +# define CAN_USE_THUMB_INSTRUCTIONS 1 #endif namespace assembler { diff --git a/deps/v8/src/arm/macro-assembler-arm.cc b/deps/v8/src/arm/macro-assembler-arm.cc index 8e1eda9c99..6dd9b8faab 100644 --- a/deps/v8/src/arm/macro-assembler-arm.cc +++ b/deps/v8/src/arm/macro-assembler-arm.cc @@ -52,21 +52,15 @@ MacroAssembler::MacroAssembler(void* buffer, int size) // We do not support thumb inter-working with an arm architecture not supporting -// the blx instruction (below v5t) -#if defined(USE_THUMB_INTERWORK) -#if !defined(__ARM_ARCH_5T__) && \ - !defined(__ARM_ARCH_5TE__) && \ - !defined(__ARM_ARCH_6__) && \ - !defined(__ARM_ARCH_7A__) && \ - !defined(__ARM_ARCH_7__) -// add tests for other versions above v5t as required -#error "for thumb inter-working we require architecture v5t or above" -#endif +// the blx instruction (below v5t). If you know what CPU you are compiling for +// you can use -march=armv7 or similar. +#if defined(USE_THUMB_INTERWORK) && !defined(CAN_USE_THUMB_INSTRUCTIONS) +# error "For thumb inter-working we require an architecture which supports blx" #endif // Using blx may yield better code, so use it when required or when available -#if defined(USE_THUMB_INTERWORK) || defined(__ARM_ARCH_5__) +#if defined(USE_THUMB_INTERWORK) || defined(CAN_USE_ARMV5_INSTRUCTIONS) #define USE_BLX 1 #endif diff --git a/deps/v8/src/bootstrapper.cc b/deps/v8/src/bootstrapper.cc index c1daa57b1f..5f38485ed7 100644 --- a/deps/v8/src/bootstrapper.cc +++ b/deps/v8/src/bootstrapper.cc @@ -654,6 +654,8 @@ void Genesis::CreateRoots(v8::Handle global_template, InstallFunction(global, "Array", JS_ARRAY_TYPE, JSArray::kSize, Top::initial_object_prototype(), Builtins::ArrayCode, true); + array_function->shared()->set_construct_stub( + Builtins::builtin(Builtins::ArrayConstructCode)); array_function->shared()->DontAdaptArguments(); // This seems a bit hackish, but we need to make sure Array.length @@ -1471,7 +1473,7 @@ void Genesis::MakeFunctionInstancePrototypeWritable() { HandleScope scope; Handle function_map_descriptors = - ComputeFunctionInstanceDescriptor(false, true); + ComputeFunctionInstanceDescriptor(false); Handle fm = Factory::CopyMapDropDescriptors(Top::function_map()); fm->set_instance_descriptors(*function_map_descriptors); Top::context()->global_context()->set_function_map(*fm); diff --git a/deps/v8/src/builtins.cc b/deps/v8/src/builtins.cc index 195fe54bef..5fe4ba9a02 100644 --- a/deps/v8/src/builtins.cc +++ b/deps/v8/src/builtins.cc @@ -135,7 +135,9 @@ BUILTIN(EmptyFunction) { BUILTIN_END -BUILTIN(ArrayCode) { +BUILTIN(ArrayCodeGeneric) { + Counters::array_function_runtime.Increment(); + JSArray* array; if (CalledAsConstructor()) { array = JSArray::cast(*receiver); @@ -166,7 +168,7 @@ BUILTIN(ArrayCode) { // Take the argument as the length. obj = array->Initialize(0); if (obj->IsFailure()) return obj; - if (args.length() == 2) return array->SetElementsLength(args[1]); + return array->SetElementsLength(args[1]); } // Optimize the case where there are no parameters passed. diff --git a/deps/v8/src/builtins.h b/deps/v8/src/builtins.h index 8df767a925..141d5b7a58 100644 --- a/deps/v8/src/builtins.h +++ b/deps/v8/src/builtins.h @@ -37,7 +37,7 @@ namespace internal { \ V(EmptyFunction) \ \ - V(ArrayCode) \ + V(ArrayCodeGeneric) \ \ V(ArrayPush) \ V(ArrayPop) \ @@ -83,8 +83,10 @@ namespace internal { \ /* Uses KeyedLoadIC_Initialize; must be after in list. */ \ V(FunctionCall, BUILTIN, UNINITIALIZED) \ - V(FunctionApply, BUILTIN, UNINITIALIZED) - + V(FunctionApply, BUILTIN, UNINITIALIZED) \ + \ + V(ArrayCode, BUILTIN, UNINITIALIZED) \ + V(ArrayConstructCode, BUILTIN, UNINITIALIZED) #ifdef ENABLE_DEBUGGER_SUPPORT // Define list of builtins used by the debugger implemented in assembly. @@ -217,6 +219,9 @@ class Builtins : public AllStatic { static void Generate_FunctionCall(MacroAssembler* masm); static void Generate_FunctionApply(MacroAssembler* masm); + + static void Generate_ArrayCode(MacroAssembler* masm); + static void Generate_ArrayConstructCode(MacroAssembler* masm); }; } } // namespace v8::internal diff --git a/deps/v8/src/handles.cc b/deps/v8/src/handles.cc index fae006a4d0..931e3b9bf0 100644 --- a/deps/v8/src/handles.cc +++ b/deps/v8/src/handles.cc @@ -527,55 +527,53 @@ v8::Handle GetKeysForIndexedInterceptor(Handle receiver, } -Handle GetKeysInFixedArrayFor(Handle object) { +Handle GetKeysInFixedArrayFor(Handle object, + KeyCollectionType type) { Handle content = Factory::empty_fixed_array(); - JSObject* arguments_boilerplate = - Top::context()->global_context()->arguments_boilerplate(); - JSFunction* arguments_function = - JSFunction::cast(arguments_boilerplate->map()->constructor()); - bool allow_enumeration = (object->map()->constructor() != arguments_function); - // Only collect keys if access is permitted. - if (allow_enumeration) { - for (Handle p = object; - *p != Heap::null_value(); - p = Handle(p->GetPrototype())) { - Handle current(JSObject::cast(*p)); - - // Check access rights if required. - if (current->IsAccessCheckNeeded() && - !Top::MayNamedAccess(*current, Heap::undefined_value(), - v8::ACCESS_KEYS)) { - Top::ReportFailedAccessCheck(*current, v8::ACCESS_KEYS); - break; - } + for (Handle p = object; + *p != Heap::null_value(); + p = Handle(p->GetPrototype())) { + Handle current(JSObject::cast(*p)); + + // Check access rights if required. + if (current->IsAccessCheckNeeded() && + !Top::MayNamedAccess(*current, Heap::undefined_value(), + v8::ACCESS_KEYS)) { + Top::ReportFailedAccessCheck(*current, v8::ACCESS_KEYS); + break; + } - // Compute the element keys. - Handle element_keys = - Factory::NewFixedArray(current->NumberOfEnumElements()); - current->GetEnumElementKeys(*element_keys); - content = UnionOfKeys(content, element_keys); - - // Add the element keys from the interceptor. - if (current->HasIndexedInterceptor()) { - v8::Handle result = - GetKeysForIndexedInterceptor(object, current); - if (!result.IsEmpty()) - content = AddKeysFromJSArray(content, v8::Utils::OpenHandle(*result)); - } + // Compute the element keys. + Handle element_keys = + Factory::NewFixedArray(current->NumberOfEnumElements()); + current->GetEnumElementKeys(*element_keys); + content = UnionOfKeys(content, element_keys); + + // Add the element keys from the interceptor. + if (current->HasIndexedInterceptor()) { + v8::Handle result = + GetKeysForIndexedInterceptor(object, current); + if (!result.IsEmpty()) + content = AddKeysFromJSArray(content, v8::Utils::OpenHandle(*result)); + } - // Compute the property keys. - content = UnionOfKeys(content, GetEnumPropertyKeys(current)); + // Compute the property keys. + content = UnionOfKeys(content, GetEnumPropertyKeys(current)); - // Add the property keys from the interceptor. - if (current->HasNamedInterceptor()) { - v8::Handle result = - GetKeysForNamedInterceptor(object, current); - if (!result.IsEmpty()) - content = AddKeysFromJSArray(content, v8::Utils::OpenHandle(*result)); - } + // Add the property keys from the interceptor. + if (current->HasNamedInterceptor()) { + v8::Handle result = + GetKeysForNamedInterceptor(object, current); + if (!result.IsEmpty()) + content = AddKeysFromJSArray(content, v8::Utils::OpenHandle(*result)); } + + // If we only want local properties we bail out after the first + // iteration. + if (type == LOCAL_ONLY) + break; } return content; } @@ -583,7 +581,8 @@ Handle GetKeysInFixedArrayFor(Handle object) { Handle GetKeysFor(Handle object) { Counters::for_in.Increment(); - Handle elements = GetKeysInFixedArrayFor(object); + Handle elements = GetKeysInFixedArrayFor(object, + INCLUDE_PROTOS); return Factory::NewJSArrayWithElements(elements); } diff --git a/deps/v8/src/handles.h b/deps/v8/src/handles.h index 847aebb3b2..5d574657c5 100644 --- a/deps/v8/src/handles.h +++ b/deps/v8/src/handles.h @@ -265,9 +265,13 @@ v8::Handle GetKeysForNamedInterceptor(Handle receiver, Handle object); v8::Handle GetKeysForIndexedInterceptor(Handle receiver, Handle object); + +enum KeyCollectionType { LOCAL_ONLY, INCLUDE_PROTOS }; + // Computes the enumerable keys for a JSObject. Used for implementing // "for (n in object) { }". -Handle GetKeysInFixedArrayFor(Handle object); +Handle GetKeysInFixedArrayFor(Handle object, + KeyCollectionType type); Handle GetKeysFor(Handle object); Handle GetEnumPropertyKeys(Handle object); diff --git a/deps/v8/src/heap-profiler.cc b/deps/v8/src/heap-profiler.cc new file mode 100644 index 0000000000..c1122c4b79 --- /dev/null +++ b/deps/v8/src/heap-profiler.cc @@ -0,0 +1,548 @@ +// Copyright 2009 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "v8.h" + +#include "heap-profiler.h" +#include "string-stream.h" + +namespace v8 { +namespace internal { + + +#ifdef ENABLE_LOGGING_AND_PROFILING +namespace { + +// Clusterizer is a set of helper functions for converting +// object references into clusters. +class Clusterizer : public AllStatic { + public: + static JSObjectsCluster Clusterize(HeapObject* obj) { + return Clusterize(obj, true); + } + static void InsertIntoTree(JSObjectsClusterTree* tree, + HeapObject* obj, bool fine_grain); + static void InsertReferenceIntoTree(JSObjectsClusterTree* tree, + const JSObjectsCluster& cluster) { + InsertIntoTree(tree, cluster, 0); + } + + private: + static JSObjectsCluster Clusterize(HeapObject* obj, bool fine_grain); + static int CalculateNetworkSize(JSObject* obj); + static int GetObjectSize(HeapObject* obj) { + return obj->IsJSObject() ? + CalculateNetworkSize(JSObject::cast(obj)) : obj->Size(); + } + static void InsertIntoTree(JSObjectsClusterTree* tree, + const JSObjectsCluster& cluster, int size); +}; + + +JSObjectsCluster Clusterizer::Clusterize(HeapObject* obj, bool fine_grain) { + if (obj->IsJSObject()) { + JSObject* js_obj = JSObject::cast(obj); + String* constructor = JSObject::cast(js_obj)->constructor_name(); + // Differentiate Array, Function, and Object instances. + if (fine_grain && (constructor == Heap::Object_symbol() || + constructor == Heap::Array_symbol() || + constructor == Heap::function_class_symbol())) { + return JSObjectsCluster(constructor, obj); + } else { + return JSObjectsCluster(constructor); + } + } else if (obj->IsString()) { + return JSObjectsCluster(Heap::String_symbol()); + } + return JSObjectsCluster(); +} + + +void Clusterizer::InsertIntoTree(JSObjectsClusterTree* tree, + HeapObject* obj, bool fine_grain) { + JSObjectsCluster cluster = Clusterize(obj, fine_grain); + if (cluster.is_null()) return; + InsertIntoTree(tree, cluster, GetObjectSize(obj)); +} + + +void Clusterizer::InsertIntoTree(JSObjectsClusterTree* tree, + const JSObjectsCluster& cluster, int size) { + JSObjectsClusterTree::Locator loc; + tree->Insert(cluster, &loc); + NumberAndSizeInfo number_and_size = loc.value(); + number_and_size.increment_number(1); + number_and_size.increment_bytes(size); + loc.set_value(number_and_size); +} + + +int Clusterizer::CalculateNetworkSize(JSObject* obj) { + int size = obj->Size(); + // If 'properties' and 'elements' are non-empty (thus, non-shared), + // take their size into account. + if (FixedArray::cast(obj->properties())->length() != 0) { + size += obj->properties()->Size(); + } + if (FixedArray::cast(obj->elements())->length() != 0) { + size += obj->elements()->Size(); + } + return size; +} + + +// A helper class for recording back references. +class ReferencesExtractor : public ObjectVisitor { + public: + ReferencesExtractor(const JSObjectsCluster& cluster, + RetainerHeapProfile* profile) + : cluster_(cluster), + profile_(profile), + inside_array_(false) { + } + + void VisitPointer(Object** o) { + if ((*o)->IsJSObject() || (*o)->IsString()) { + profile_->StoreReference(cluster_, HeapObject::cast(*o)); + } else if ((*o)->IsFixedArray() && !inside_array_) { + // Traverse one level deep for data members that are fixed arrays. + // This covers the case of 'elements' and 'properties' of JSObject, + // and function contexts. + inside_array_ = true; + FixedArray::cast(*o)->Iterate(this); + inside_array_ = false; + } + } + + void VisitPointers(Object** start, Object** end) { + for (Object** p = start; p < end; p++) VisitPointer(p); + } + + private: + const JSObjectsCluster& cluster_; + RetainerHeapProfile* profile_; + bool inside_array_; +}; + + +// A printer interface implementation for the Retainers profile. +class RetainersPrinter : public RetainerHeapProfile::Printer { + public: + void PrintRetainers(const JSObjectsCluster& cluster, + const StringStream& retainers) { + HeapStringAllocator allocator; + StringStream stream(&allocator); + cluster.Print(&stream); + LOG(HeapSampleJSRetainersEvent( + *(stream.ToCString()), *(retainers.ToCString()))); + } +}; + + +class RetainerTreePrinter BASE_EMBEDDED { + public: + explicit RetainerTreePrinter(StringStream* stream) : stream_(stream) {} + void Call(const JSObjectsCluster& cluster, + const NumberAndSizeInfo& number_and_size) { + Print(stream_, cluster, number_and_size); + } + static void Print(StringStream* stream, + const JSObjectsCluster& cluster, + const NumberAndSizeInfo& numNNber_and_size); + + private: + StringStream* stream_; +}; + + +void RetainerTreePrinter::Print(StringStream* stream, + const JSObjectsCluster& cluster, + const NumberAndSizeInfo& number_and_size) { + stream->Put(','); + cluster.Print(stream); + stream->Add(";%d", number_and_size.number()); +} + + +} // namespace + + +const JSObjectsClusterTreeConfig::Key JSObjectsClusterTreeConfig::kNoKey; +const JSObjectsClusterTreeConfig::Value JSObjectsClusterTreeConfig::kNoValue; + + +ConstructorHeapProfile::ConstructorHeapProfile() + : zscope_(DELETE_ON_EXIT) { +} + + +void ConstructorHeapProfile::Call(const JSObjectsCluster& cluster, + const NumberAndSizeInfo& number_and_size) { + HeapStringAllocator allocator; + StringStream stream(&allocator); + cluster.Print(&stream); + LOG(HeapSampleJSConstructorEvent(*(stream.ToCString()), + number_and_size.number(), + number_and_size.bytes())); +} + + +void ConstructorHeapProfile::CollectStats(HeapObject* obj) { + Clusterizer::InsertIntoTree(&js_objects_info_tree_, obj, false); +} + + +void ConstructorHeapProfile::PrintStats() { + js_objects_info_tree_.ForEach(this); +} + + +void JSObjectsCluster::Print(StringStream* accumulator) const { + ASSERT(!is_null()); + if (constructor_ == FromSpecialCase(ROOTS)) { + accumulator->Add("(roots)"); + } else if (constructor_ == FromSpecialCase(GLOBAL_PROPERTY)) { + accumulator->Add("(global property)"); + } else { + SmartPointer s_name( + constructor_->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL)); + accumulator->Add("%s", (*s_name)[0] != '\0' ? *s_name : "(anonymous)"); + if (instance_ != NULL) { + accumulator->Add(":%p", static_cast(instance_)); + } + } +} + + +void JSObjectsCluster::DebugPrint(StringStream* accumulator) const { + if (!is_null()) { + Print(accumulator); + } else { + accumulator->Add("(null cluster)"); + } +} + + +inline ClustersCoarser::ClusterBackRefs::ClusterBackRefs( + const JSObjectsCluster& cluster_) + : cluster(cluster_), refs(kInitialBackrefsListCapacity) { +} + + +inline ClustersCoarser::ClusterBackRefs::ClusterBackRefs( + const ClustersCoarser::ClusterBackRefs& src) + : cluster(src.cluster), refs(src.refs.capacity()) { + refs.AddAll(src.refs); +} + + +inline ClustersCoarser::ClusterBackRefs& + ClustersCoarser::ClusterBackRefs::operator=( + const ClustersCoarser::ClusterBackRefs& src) { + if (this == &src) return *this; + cluster = src.cluster; + refs.Clear(); + refs.AddAll(src.refs); + return *this; +} + + +inline int ClustersCoarser::ClusterBackRefs::Compare( + const ClustersCoarser::ClusterBackRefs& a, + const ClustersCoarser::ClusterBackRefs& b) { + int cmp = JSObjectsCluster::CompareConstructors(a.cluster, b.cluster); + if (cmp != 0) return cmp; + if (a.refs.length() < b.refs.length()) return -1; + if (a.refs.length() > b.refs.length()) return 1; + for (int i = 0; i < a.refs.length(); ++i) { + int cmp = JSObjectsCluster::Compare(a.refs[i], b.refs[i]); + if (cmp != 0) return cmp; + } + return 0; +} + + +ClustersCoarser::ClustersCoarser() + : zscope_(DELETE_ON_EXIT), + sim_list_(ClustersCoarser::kInitialSimilarityListCapacity), + current_pair_(NULL) { +} + + +void ClustersCoarser::Call(const JSObjectsCluster& cluster, + JSObjectsClusterTree* tree) { + if (!cluster.can_be_coarsed()) return; + ClusterBackRefs pair(cluster); + ASSERT(current_pair_ == NULL); + current_pair_ = &pair; + current_set_ = new JSObjectsRetainerTree(); + tree->ForEach(this); + sim_list_.Add(pair); + current_pair_ = NULL; + current_set_ = NULL; +} + + +void ClustersCoarser::Call(const JSObjectsCluster& cluster, + const NumberAndSizeInfo& number_and_size) { + ASSERT(current_pair_ != NULL); + ASSERT(current_set_ != NULL); + JSObjectsCluster eq = GetCoarseEquivalent(cluster); + JSObjectsRetainerTree::Locator loc; + if (!eq.is_null()) { + if (current_set_->Find(eq, &loc)) return; + current_pair_->refs.Add(eq); + current_set_->Insert(eq, &loc); + } else { + current_pair_->refs.Add(cluster); + } +} + + +void ClustersCoarser::Process(JSObjectsRetainerTree* tree) { + int last_eq_clusters = -1; + for (int i = 0; i < kMaxPassesCount; ++i) { + sim_list_.Clear(); + const int curr_eq_clusters = DoProcess(tree); + // If no new cluster equivalents discovered, abort processing. + if (last_eq_clusters == curr_eq_clusters) break; + last_eq_clusters = curr_eq_clusters; + } +} + + +int ClustersCoarser::DoProcess(JSObjectsRetainerTree* tree) { + tree->ForEach(this); + // To sort similarity list properly, references list of a cluster is + // required to be sorted, thus 'O1 <- A, B' and 'O2 <- B, A' would + // be considered equivalent. But we don't sort them explicitly + // because we know that they come from a splay tree traversal, so + // they are already sorted. + sim_list_.Sort(ClusterBackRefsCmp); + return FillEqualityTree(); +} + + +JSObjectsCluster ClustersCoarser::GetCoarseEquivalent( + const JSObjectsCluster& cluster) { + if (!cluster.can_be_coarsed()) return JSObjectsCluster(); + EqualityTree::Locator loc; + return eq_tree_.Find(cluster, &loc) ? loc.value() : JSObjectsCluster(); +} + + +bool ClustersCoarser::HasAnEquivalent(const JSObjectsCluster& cluster) { + // Return true for coarsible clusters that have a non-identical equivalent. + return cluster.can_be_coarsed() && + JSObjectsCluster::Compare(cluster, GetCoarseEquivalent(cluster)) != 0; +} + + +int ClustersCoarser::FillEqualityTree() { + int eq_clusters_count = 0; + int eq_to = 0; + bool first_added = false; + for (int i = 1; i < sim_list_.length(); ++i) { + if (ClusterBackRefs::Compare(sim_list_[i], sim_list_[eq_to]) == 0) { + EqualityTree::Locator loc; + if (!first_added) { + // Add self-equivalence, if we have more than one item in this + // equivalence class. + eq_tree_.Insert(sim_list_[eq_to].cluster, &loc); + loc.set_value(sim_list_[eq_to].cluster); + first_added = true; + } + eq_tree_.Insert(sim_list_[i].cluster, &loc); + loc.set_value(sim_list_[eq_to].cluster); + ++eq_clusters_count; + } else { + eq_to = i; + first_added = false; + } + } + return eq_clusters_count; +} + + +const JSObjectsCluster ClustersCoarser::ClusterEqualityConfig::kNoKey; +const JSObjectsCluster ClustersCoarser::ClusterEqualityConfig::kNoValue; +const JSObjectsRetainerTreeConfig::Key JSObjectsRetainerTreeConfig::kNoKey; +const JSObjectsRetainerTreeConfig::Value JSObjectsRetainerTreeConfig::kNoValue = + NULL; + + +RetainerHeapProfile::RetainerHeapProfile() + : zscope_(DELETE_ON_EXIT), + coarse_cluster_tree_(NULL), + current_printer_(NULL), + current_stream_(NULL) { + JSObjectsCluster roots(JSObjectsCluster::ROOTS); + ReferencesExtractor extractor(roots, this); + Heap::IterateRoots(&extractor); +} + + +void RetainerHeapProfile::StoreReference(const JSObjectsCluster& cluster, + HeapObject* ref) { + JSObjectsCluster ref_cluster = Clusterizer::Clusterize(ref); + JSObjectsRetainerTree::Locator ref_loc; + if (retainers_tree_.Insert(ref_cluster, &ref_loc)) { + ref_loc.set_value(new JSObjectsClusterTree()); + } + JSObjectsClusterTree* referenced_by = ref_loc.value(); + Clusterizer::InsertReferenceIntoTree(referenced_by, cluster); +} + + +void RetainerHeapProfile::CollectStats(HeapObject* obj) { + if (obj->IsJSObject()) { + const JSObjectsCluster cluster = Clusterizer::Clusterize(obj); + ReferencesExtractor extractor(cluster, this); + obj->Iterate(&extractor); + } else if (obj->IsJSGlobalPropertyCell()) { + JSObjectsCluster global_prop(JSObjectsCluster::GLOBAL_PROPERTY); + ReferencesExtractor extractor(global_prop, this); + obj->Iterate(&extractor); + } +} + + +void RetainerHeapProfile::DebugPrintStats( + RetainerHeapProfile::Printer* printer) { + coarser_.Process(&retainers_tree_); + ASSERT(current_printer_ == NULL); + current_printer_ = printer; + retainers_tree_.ForEach(this); + current_printer_ = NULL; +} + + +void RetainerHeapProfile::PrintStats() { + RetainersPrinter printer; + DebugPrintStats(&printer); +} + + +void RetainerHeapProfile::Call(const JSObjectsCluster& cluster, + JSObjectsClusterTree* tree) { + // First level of retainer graph. + if (coarser_.HasAnEquivalent(cluster)) return; + ASSERT(current_stream_ == NULL); + HeapStringAllocator allocator; + StringStream stream(&allocator); + current_stream_ = &stream; + ASSERT(coarse_cluster_tree_ == NULL); + coarse_cluster_tree_ = new JSObjectsClusterTree(); + tree->ForEach(this); + // Print aggregated counts and sizes. + RetainerTreePrinter printer(current_stream_); + coarse_cluster_tree_->ForEach(&printer); + coarse_cluster_tree_ = NULL; + current_printer_->PrintRetainers(cluster, stream); + current_stream_ = NULL; +} + + +void RetainerHeapProfile::Call(const JSObjectsCluster& cluster, + const NumberAndSizeInfo& number_and_size) { + ASSERT(coarse_cluster_tree_ != NULL); + ASSERT(current_stream_ != NULL); + JSObjectsCluster eq = coarser_.GetCoarseEquivalent(cluster); + if (eq.is_null()) { + RetainerTreePrinter::Print(current_stream_, cluster, number_and_size); + } else { + // Aggregate counts and sizes for equivalent clusters. + JSObjectsClusterTree::Locator loc; + coarse_cluster_tree_->Insert(eq, &loc); + NumberAndSizeInfo eq_number_and_size = loc.value(); + eq_number_and_size.increment_number(number_and_size.number()); + loc.set_value(eq_number_and_size); + } +} + + +// +// HeapProfiler class implementation. +// +void HeapProfiler::CollectStats(HeapObject* obj, HistogramInfo* info) { + InstanceType type = obj->map()->instance_type(); + ASSERT(0 <= type && type <= LAST_TYPE); + info[type].increment_number(1); + info[type].increment_bytes(obj->Size()); +} + + +void HeapProfiler::WriteSample() { + LOG(HeapSampleBeginEvent("Heap", "allocated")); + LOG(HeapSampleStats( + "Heap", "allocated", Heap::Capacity(), Heap::SizeOfObjects())); + + HistogramInfo info[LAST_TYPE+1]; +#define DEF_TYPE_NAME(name) info[name].set_name(#name); + INSTANCE_TYPE_LIST(DEF_TYPE_NAME) +#undef DEF_TYPE_NAME + + ConstructorHeapProfile js_cons_profile; + RetainerHeapProfile js_retainer_profile; + HeapIterator iterator; + while (iterator.has_next()) { + HeapObject* obj = iterator.next(); + CollectStats(obj, info); + js_cons_profile.CollectStats(obj); + js_retainer_profile.CollectStats(obj); + } + + // Lump all the string types together. + int string_number = 0; + int string_bytes = 0; +#define INCREMENT_SIZE(type, size, name, camel_name) \ + string_number += info[type].number(); \ + string_bytes += info[type].bytes(); + STRING_TYPE_LIST(INCREMENT_SIZE) +#undef INCREMENT_SIZE + if (string_bytes > 0) { + LOG(HeapSampleItemEvent("STRING_TYPE", string_number, string_bytes)); + } + + for (int i = FIRST_NONSTRING_TYPE; i <= LAST_TYPE; ++i) { + if (info[i].bytes() > 0) { + LOG(HeapSampleItemEvent(info[i].name(), info[i].number(), + info[i].bytes())); + } + } + + js_cons_profile.PrintStats(); + js_retainer_profile.PrintStats(); + + LOG(HeapSampleEndEvent("Heap", "allocated")); +} + + +#endif // ENABLE_LOGGING_AND_PROFILING + + +} } // namespace v8::internal diff --git a/deps/v8/src/heap-profiler.h b/deps/v8/src/heap-profiler.h new file mode 100644 index 0000000000..adc3da2b86 --- /dev/null +++ b/deps/v8/src/heap-profiler.h @@ -0,0 +1,266 @@ +// Copyright 2009 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef V8_HEAP_PROFILER_H_ +#define V8_HEAP_PROFILER_H_ + +namespace v8 { +namespace internal { + +#ifdef ENABLE_LOGGING_AND_PROFILING + +// The HeapProfiler writes data to the log files, which can be postprocessed +// to generate .hp files for use by the GHC/Valgrind tool hp2ps. +class HeapProfiler { + public: + // Write a single heap sample to the log file. + static void WriteSample(); + + private: + // Update the array info with stats from obj. + static void CollectStats(HeapObject* obj, HistogramInfo* info); +}; + + +// JSObjectsCluster describes a group of JS objects that are +// considered equivalent in terms of a particular profile. +class JSObjectsCluster BASE_EMBEDDED { + public: + // These special cases are used in retainer profile. + enum SpecialCase { + ROOTS = 1, + GLOBAL_PROPERTY = 2 + }; + + JSObjectsCluster() : constructor_(NULL), instance_(NULL) {} + explicit JSObjectsCluster(String* constructor) + : constructor_(constructor), instance_(NULL) {} + explicit JSObjectsCluster(SpecialCase special) + : constructor_(FromSpecialCase(special)), instance_(NULL) {} + JSObjectsCluster(String* constructor, Object* instance) + : constructor_(constructor), instance_(instance) {} + + static int CompareConstructors(const JSObjectsCluster& a, + const JSObjectsCluster& b) { + // Strings are unique, so it is sufficient to compare their pointers. + return a.constructor_ == b.constructor_ ? 0 + : (a.constructor_ < b.constructor_ ? -1 : 1); + } + static int Compare(const JSObjectsCluster& a, const JSObjectsCluster& b) { + // Strings are unique, so it is sufficient to compare their pointers. + const int cons_cmp = CompareConstructors(a, b); + return cons_cmp == 0 ? + (a.instance_ == b.instance_ ? 0 : (a.instance_ < b.instance_ ? -1 : 1)) + : cons_cmp; + } + + bool is_null() const { return constructor_ == NULL; } + bool can_be_coarsed() const { return instance_ != NULL; } + String* constructor() const { return constructor_; } + + void Print(StringStream* accumulator) const; + // Allows null clusters to be printed. + void DebugPrint(StringStream* accumulator) const; + + private: + static String* FromSpecialCase(SpecialCase special) { + // We use symbols that are illegal JS identifiers to identify special cases. + // Their actual value is irrelevant for us. + switch (special) { + case ROOTS: return Heap::result_symbol(); + case GLOBAL_PROPERTY: return Heap::code_symbol(); + default: + UNREACHABLE(); + return NULL; + } + } + + String* constructor_; + Object* instance_; +}; + + +struct JSObjectsClusterTreeConfig { + typedef JSObjectsCluster Key; + typedef NumberAndSizeInfo Value; + static const Key kNoKey; + static const Value kNoValue; + static int Compare(const Key& a, const Key& b) { + return Key::Compare(a, b); + } +}; +typedef ZoneSplayTree JSObjectsClusterTree; + + +// ConstructorHeapProfile is responsible for gathering and logging +// "constructor profile" of JS objects allocated on heap. +// It is run during garbage collection cycle, thus it doesn't need +// to use handles. +class ConstructorHeapProfile BASE_EMBEDDED { + public: + ConstructorHeapProfile(); + virtual ~ConstructorHeapProfile() {} + void CollectStats(HeapObject* obj); + void PrintStats(); + // Used by ZoneSplayTree::ForEach. Made virtual to allow overriding in tests. + virtual void Call(const JSObjectsCluster& cluster, + const NumberAndSizeInfo& number_and_size); + + private: + ZoneScope zscope_; + JSObjectsClusterTree js_objects_info_tree_; +}; + + +// JSObjectsRetainerTree is used to represent retainer graphs using +// adjacency list form: +// +// Cluster -> (Cluster -> NumberAndSizeInfo) +// +// Subordinate splay trees are stored by pointer. They are zone-allocated, +// so it isn't needed to manage their lifetime. +// +struct JSObjectsRetainerTreeConfig { + typedef JSObjectsCluster Key; + typedef JSObjectsClusterTree* Value; + static const Key kNoKey; + static const Value kNoValue; + static int Compare(const Key& a, const Key& b) { + return Key::Compare(a, b); + } +}; +typedef ZoneSplayTree JSObjectsRetainerTree; + + +class ClustersCoarser BASE_EMBEDDED { + public: + ClustersCoarser(); + + // Processes a given retainer graph. + void Process(JSObjectsRetainerTree* tree); + + // Returns an equivalent cluster (can be the cluster itself). + // If the given cluster doesn't have an equivalent, returns null cluster. + JSObjectsCluster GetCoarseEquivalent(const JSObjectsCluster& cluster); + // Returns whether a cluster can be substitued with an equivalent and thus, + // skipped in some cases. + bool HasAnEquivalent(const JSObjectsCluster& cluster); + + // Used by JSObjectsRetainerTree::ForEach. + void Call(const JSObjectsCluster& cluster, JSObjectsClusterTree* tree); + void Call(const JSObjectsCluster& cluster, + const NumberAndSizeInfo& number_and_size); + + private: + // Stores a list of back references for a cluster. + struct ClusterBackRefs { + explicit ClusterBackRefs(const JSObjectsCluster& cluster_); + ClusterBackRefs(const ClusterBackRefs& src); + ClusterBackRefs& operator=(const ClusterBackRefs& src); + + static int Compare(const ClusterBackRefs& a, const ClusterBackRefs& b); + + JSObjectsCluster cluster; + ZoneList refs; + }; + typedef ZoneList SimilarityList; + + // A tree for storing a list of equivalents for a cluster. + struct ClusterEqualityConfig { + typedef JSObjectsCluster Key; + typedef JSObjectsCluster Value; + static const Key kNoKey; + static const Value kNoValue; + static int Compare(const Key& a, const Key& b) { + return Key::Compare(a, b); + } + }; + typedef ZoneSplayTree EqualityTree; + + static int ClusterBackRefsCmp(const ClusterBackRefs* a, + const ClusterBackRefs* b) { + return ClusterBackRefs::Compare(*a, *b); + } + int DoProcess(JSObjectsRetainerTree* tree); + int FillEqualityTree(); + + static const int kInitialBackrefsListCapacity = 2; + static const int kInitialSimilarityListCapacity = 2000; + // Number of passes for finding equivalents. Limits the length of paths + // that can be considered equivalent. + static const int kMaxPassesCount = 10; + + ZoneScope zscope_; + SimilarityList sim_list_; + EqualityTree eq_tree_; + ClusterBackRefs* current_pair_; + JSObjectsRetainerTree* current_set_; +}; + + +// RetainerHeapProfile is responsible for gathering and logging +// "retainer profile" of JS objects allocated on heap. +// It is run during garbage collection cycle, thus it doesn't need +// to use handles. +class RetainerHeapProfile BASE_EMBEDDED { + public: + class Printer { + public: + virtual ~Printer() {} + virtual void PrintRetainers(const JSObjectsCluster& cluster, + const StringStream& retainers) = 0; + }; + + RetainerHeapProfile(); + void CollectStats(HeapObject* obj); + void PrintStats(); + void DebugPrintStats(Printer* printer); + void StoreReference(const JSObjectsCluster& cluster, HeapObject* ref); + + private: + // Limit on the number of retainers to be printed per cluster. + static const int kMaxRetainersToPrint = 50; + ZoneScope zscope_; + JSObjectsRetainerTree retainers_tree_; + ClustersCoarser coarser_; + // TODO(mnaganov): Use some helper class to hold these state variables. + JSObjectsClusterTree* coarse_cluster_tree_; + Printer* current_printer_; + StringStream* current_stream_; + public: + // Used by JSObjectsRetainerTree::ForEach. + void Call(const JSObjectsCluster& cluster, JSObjectsClusterTree* tree); + void Call(const JSObjectsCluster& cluster, + const NumberAndSizeInfo& number_and_size); +}; + + +#endif // ENABLE_LOGGING_AND_PROFILING + +} } // namespace v8::internal + +#endif // V8_HEAP_PROFILER_H_ diff --git a/deps/v8/src/heap.cc b/deps/v8/src/heap.cc index 949dd80c3b..1a80d64784 100644 --- a/deps/v8/src/heap.cc +++ b/deps/v8/src/heap.cc @@ -33,6 +33,7 @@ #include "codegen-inl.h" #include "compilation-cache.h" #include "debug.h" +#include "heap-profiler.h" #include "global-handles.h" #include "mark-compact.h" #include "natives.h" @@ -636,15 +637,7 @@ static void VerifyNonPointerSpacePointers() { HeapObjectIterator code_it(Heap::code_space()); while (code_it.has_next()) { HeapObject* object = code_it.next(); - if (object->IsCode()) { - Code::cast(object)->ConvertICTargetsFromAddressToObject(); - object->Iterate(&v); - Code::cast(object)->ConvertICTargetsFromObjectToAddress(); - } else { - // If we find non-code objects in code space (e.g., free list - // nodes) we want to verify them as well. - object->Iterate(&v); - } + object->Iterate(&v); } HeapObjectIterator data_it(Heap::old_data_space()); @@ -1934,7 +1927,6 @@ Object* Heap::CreateCode(const CodeDesc& desc, code->set_relocation_size(desc.reloc_size); code->set_sinfo_size(sinfo_size); code->set_flags(flags); - code->set_ic_flag(Code::IC_TARGET_IS_ADDRESS); // Allow self references to created code object by patching the handle to // point to the newly allocated Code object. if (!self_reference.is_null()) { @@ -3544,164 +3536,6 @@ void HeapIterator::reset() { } -#ifdef ENABLE_LOGGING_AND_PROFILING -namespace { - -// JSConstructorProfile is responsible for gathering and logging -// "constructor profile" of JS object allocated on heap. -// It is run during garbage collection cycle, thus it doesn't need -// to use handles. -class JSConstructorProfile BASE_EMBEDDED { - public: - JSConstructorProfile() : zscope_(DELETE_ON_EXIT) {} - void CollectStats(HeapObject* obj); - void PrintStats(); - // Used by ZoneSplayTree::ForEach. - void Call(String* name, const NumberAndSizeInfo& number_and_size); - private: - struct TreeConfig { - typedef String* Key; - typedef NumberAndSizeInfo Value; - static const Key kNoKey; - static const Value kNoValue; - // Strings are unique, so it is sufficient to compare their pointers. - static int Compare(const Key& a, const Key& b) { - return a == b ? 0 : (a < b ? -1 : 1); - } - }; - - typedef ZoneSplayTree JSObjectsInfoTree; - static int CalculateJSObjectNetworkSize(JSObject* obj); - - ZoneScope zscope_; - JSObjectsInfoTree js_objects_info_tree_; -}; - -const JSConstructorProfile::TreeConfig::Key - JSConstructorProfile::TreeConfig::kNoKey = NULL; -const JSConstructorProfile::TreeConfig::Value - JSConstructorProfile::TreeConfig::kNoValue; - - -int JSConstructorProfile::CalculateJSObjectNetworkSize(JSObject* obj) { - int size = obj->Size(); - // If 'properties' and 'elements' are non-empty (thus, non-shared), - // take their size into account. - if (FixedArray::cast(obj->properties())->length() != 0) { - size += obj->properties()->Size(); - } - if (FixedArray::cast(obj->elements())->length() != 0) { - size += obj->elements()->Size(); - } - return size; -} - - -void JSConstructorProfile::Call(String* name, - const NumberAndSizeInfo& number_and_size) { - ASSERT(name != NULL); - SmartPointer s_name( - name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL)); - LOG(HeapSampleJSConstructorEvent(*s_name, - number_and_size.number(), - number_and_size.bytes())); -} - - -void JSConstructorProfile::CollectStats(HeapObject* obj) { - String* constructor = NULL; - int size; - if (obj->IsString()) { - constructor = Heap::String_symbol(); - size = obj->Size(); - } else if (obj->IsJSObject()) { - JSObject* js_obj = JSObject::cast(obj); - constructor = js_obj->constructor_name(); - size = CalculateJSObjectNetworkSize(js_obj); - } else { - return; - } - - JSObjectsInfoTree::Locator loc; - if (!js_objects_info_tree_.Find(constructor, &loc)) { - js_objects_info_tree_.Insert(constructor, &loc); - } - NumberAndSizeInfo number_and_size = loc.value(); - number_and_size.increment_number(1); - number_and_size.increment_bytes(size); - loc.set_value(number_and_size); -} - - -void JSConstructorProfile::PrintStats() { - js_objects_info_tree_.ForEach(this); -} - -} // namespace -#endif - - -// -// HeapProfiler class implementation. -// -#ifdef ENABLE_LOGGING_AND_PROFILING -void HeapProfiler::CollectStats(HeapObject* obj, HistogramInfo* info) { - InstanceType type = obj->map()->instance_type(); - ASSERT(0 <= type && type <= LAST_TYPE); - info[type].increment_number(1); - info[type].increment_bytes(obj->Size()); -} -#endif - - -#ifdef ENABLE_LOGGING_AND_PROFILING -void HeapProfiler::WriteSample() { - LOG(HeapSampleBeginEvent("Heap", "allocated")); - LOG(HeapSampleStats( - "Heap", "allocated", Heap::Capacity(), Heap::SizeOfObjects())); - - HistogramInfo info[LAST_TYPE+1]; -#define DEF_TYPE_NAME(name) info[name].set_name(#name); - INSTANCE_TYPE_LIST(DEF_TYPE_NAME) -#undef DEF_TYPE_NAME - - JSConstructorProfile js_cons_profile; - HeapIterator iterator; - while (iterator.has_next()) { - HeapObject* obj = iterator.next(); - CollectStats(obj, info); - js_cons_profile.CollectStats(obj); - } - - // Lump all the string types together. - int string_number = 0; - int string_bytes = 0; -#define INCREMENT_SIZE(type, size, name, camel_name) \ - string_number += info[type].number(); \ - string_bytes += info[type].bytes(); - STRING_TYPE_LIST(INCREMENT_SIZE) -#undef INCREMENT_SIZE - if (string_bytes > 0) { - LOG(HeapSampleItemEvent("STRING_TYPE", string_number, string_bytes)); - } - - for (int i = FIRST_NONSTRING_TYPE; i <= LAST_TYPE; ++i) { - if (info[i].bytes() > 0) { - LOG(HeapSampleItemEvent(info[i].name(), info[i].number(), - info[i].bytes())); - } - } - - js_cons_profile.PrintStats(); - - LOG(HeapSampleEndEvent("Heap", "allocated")); -} - - -#endif - - - #ifdef DEBUG static bool search_for_any_global; @@ -3744,10 +3578,6 @@ static void MarkObjectRecursively(Object** p) { return; } - if (obj->IsCode()) { - Code::cast(obj)->ConvertICTargetsFromAddressToObject(); - } - // not visited yet Map* map_p = reinterpret_cast(HeapObject::cast(map)); @@ -3803,10 +3633,6 @@ static void UnmarkObjectRecursively(Object** p) { obj->IterateBody(Map::cast(map_p)->instance_type(), obj->SizeFromMap(Map::cast(map_p)), &unmark_visitor); - - if (obj->IsCode()) { - Code::cast(obj)->ConvertICTargetsFromObjectToAddress(); - } } diff --git a/deps/v8/src/heap.h b/deps/v8/src/heap.h index 028dd11181..92602c8506 100644 --- a/deps/v8/src/heap.h +++ b/deps/v8/src/heap.h @@ -1443,20 +1443,6 @@ class DisableAssertNoAllocation { #endif -#ifdef ENABLE_LOGGING_AND_PROFILING -// The HeapProfiler writes data to the log files, which can be postprocessed -// to generate .hp files for use by the GHC/Valgrind tool hp2ps. -class HeapProfiler { - public: - // Write a single heap sample to the log file. - static void WriteSample(); - - private: - // Update the array info with stats from obj. - static void CollectStats(HeapObject* obj, HistogramInfo* info); -}; -#endif - // GCTracer collects and prints ONE line after each garbage collector // invocation IFF --trace_gc is used. diff --git a/deps/v8/src/ia32/builtins-ia32.cc b/deps/v8/src/ia32/builtins-ia32.cc index 7793e49265..e7712df30c 100644 --- a/deps/v8/src/ia32/builtins-ia32.cc +++ b/deps/v8/src/ia32/builtins-ia32.cc @@ -658,6 +658,466 @@ void Builtins::Generate_FunctionApply(MacroAssembler* masm) { } +// Load the built-in Array function from the current context. +static void GenerateLoadArrayFunction(MacroAssembler* masm, Register result) { + // Load the global context. + __ mov(result, Operand(esi, Context::SlotOffset(Context::GLOBAL_INDEX))); + __ mov(result, FieldOperand(result, GlobalObject::kGlobalContextOffset)); + // Load the Array function from the global context. + __ mov(result, + Operand(result, Context::SlotOffset(Context::ARRAY_FUNCTION_INDEX))); +} + + +// Number of empty elements to allocate for an empty array. +static const int kPreallocatedArrayElements = 4; + + +// Allocate an empty JSArray. The allocated array is put into the result +// register. If the parameter holes is larger than zero an elements backing +// store is allocated with this size and filled with the hole values. Otherwise +// the elements backing store is set to the empty FixedArray. +static void AllocateEmptyJSArray(MacroAssembler* masm, + Register array_function, + Register result, + Register scratch1, + Register scratch2, + Register scratch3, + int holes, + Label* gc_required) { + ASSERT(holes >= 0); + + // Load the initial map from the array function. + __ mov(scratch1, FieldOperand(array_function, + JSFunction::kPrototypeOrInitialMapOffset)); + + // Allocate the JSArray object together with space for a fixed array with the + // requested elements. + int size = JSArray::kSize; + if (holes > 0) { + size += FixedArray::SizeFor(holes); + } + __ AllocateObjectInNewSpace(size, + result, + scratch2, + scratch3, + gc_required, + TAG_OBJECT); + + // Allocated the JSArray. Now initialize the fields except for the elements + // array. + // result: JSObject + // scratch1: initial map + // scratch2: start of next object + __ mov(FieldOperand(result, JSObject::kMapOffset), scratch1); + __ mov(FieldOperand(result, JSArray::kPropertiesOffset), + Factory::empty_fixed_array()); + // Field JSArray::kElementsOffset is initialized later. + __ mov(FieldOperand(result, JSArray::kLengthOffset), Immediate(0)); + + // If no storage is requested for the elements array just set the empty + // fixed array. + if (holes == 0) { + __ mov(FieldOperand(result, JSArray::kElementsOffset), + Factory::empty_fixed_array()); + return; + } + + // Calculate the location of the elements array and set elements array member + // of the JSArray. + // result: JSObject + // scratch2: start of next object + __ lea(scratch1, Operand(result, JSArray::kSize)); + __ mov(FieldOperand(result, JSArray::kElementsOffset), scratch1); + + // Initialize the FixedArray and fill it with holes. FixedArray length is not + // stored as a smi. + // result: JSObject + // scratch1: elements array + // scratch2: start of next object + __ mov(FieldOperand(scratch1, JSObject::kMapOffset), + Factory::fixed_array_map()); + __ mov(FieldOperand(scratch1, Array::kLengthOffset), Immediate(holes)); + + // Fill the FixedArray with the hole value. Inline the code if short. + // Reconsider loop unfolding if kPreallocatedArrayElements gets changed. + static const int kLoopUnfoldLimit = 4; + ASSERT(kPreallocatedArrayElements <= kLoopUnfoldLimit); + if (holes <= kLoopUnfoldLimit) { + // Use a scratch register here to have only one reloc info when unfolding + // the loop. + __ mov(scratch3, Factory::the_hole_value()); + for (int i = 0; i < holes; i++) { + __ mov(FieldOperand(scratch1, + FixedArray::kHeaderSize + i * kPointerSize), + scratch3); + } + } else { + Label loop, entry; + __ jmp(&entry); + __ bind(&loop); + __ mov(Operand(scratch1, 0), Factory::the_hole_value()); + __ add(Operand(scratch1), Immediate(kPointerSize)); + __ bind(&entry); + __ cmp(scratch1, Operand(scratch2)); + __ j(below, &loop); + } +} + + +// Allocate a JSArray with the number of elements stored in a register. The +// register array_function holds the built-in Array function and the register +// array_size holds the size of the array as a smi. The allocated array is put +// into the result register and beginning and end of the FixedArray elements +// storage is put into registers elements_array and elements_array_end (see +// below for when that is not the case). If the parameter fill_with_holes is +// true the allocated elements backing store is filled with the hole values +// otherwise it is left uninitialized. When the backing store is filled the +// register elements_array is scratched. +static void AllocateJSArray(MacroAssembler* masm, + Register array_function, // Array function. + Register array_size, // As a smi. + Register result, + Register elements_array, + Register elements_array_end, + Register scratch, + bool fill_with_hole, + Label* gc_required) { + Label not_empty, allocated; + + // Load the initial map from the array function. + __ mov(elements_array, + FieldOperand(array_function, + JSFunction::kPrototypeOrInitialMapOffset)); + + // Check whether an empty sized array is requested. + __ test(array_size, Operand(array_size)); + __ j(not_zero, ¬_empty); + + // If an empty array is requested allocate a small elements array anyway. This + // keeps the code below free of special casing for the empty array. + int size = JSArray::kSize + FixedArray::SizeFor(kPreallocatedArrayElements); + __ AllocateObjectInNewSpace(size, + result, + elements_array_end, + scratch, + gc_required, + TAG_OBJECT); + __ jmp(&allocated); + + // Allocate the JSArray object together with space for a FixedArray with the + // requested elements. + __ bind(¬_empty); + ASSERT(kSmiTagSize == 1 && kSmiTag == 0); + __ AllocateObjectInNewSpace(JSArray::kSize + FixedArray::kHeaderSize, + times_half_pointer_size, // array_size is a smi. + array_size, + result, + elements_array_end, + scratch, + gc_required, + TAG_OBJECT); + + // Allocated the JSArray. Now initialize the fields except for the elements + // array. + // result: JSObject + // elements_array: initial map + // elements_array_end: start of next object + // array_size: size of array (smi) + __ bind(&allocated); + __ mov(FieldOperand(result, JSObject::kMapOffset), elements_array); + __ mov(elements_array, Factory::empty_fixed_array()); + __ mov(FieldOperand(result, JSArray::kPropertiesOffset), elements_array); + // Field JSArray::kElementsOffset is initialized later. + __ mov(FieldOperand(result, JSArray::kLengthOffset), array_size); + + // Calculate the location of the elements array and set elements array member + // of the JSArray. + // result: JSObject + // elements_array_end: start of next object + // array_size: size of array (smi) + __ lea(elements_array, Operand(result, JSArray::kSize)); + __ mov(FieldOperand(result, JSArray::kElementsOffset), elements_array); + + // Initialize the fixed array. FixedArray length is not stored as a smi. + // result: JSObject + // elements_array: elements array + // elements_array_end: start of next object + // array_size: size of array (smi) + ASSERT(kSmiTag == 0); + __ shr(array_size, kSmiTagSize); // Convert from smi to value. + __ mov(FieldOperand(elements_array, JSObject::kMapOffset), + Factory::fixed_array_map()); + Label not_empty_2, fill_array; + __ test(array_size, Operand(array_size)); + __ j(not_zero, ¬_empty_2); + // Length of the FixedArray is the number of pre-allocated elements even + // though the actual JSArray has length 0. + __ mov(FieldOperand(elements_array, Array::kLengthOffset), + Immediate(kPreallocatedArrayElements)); + __ jmp(&fill_array); + __ bind(¬_empty_2); + // For non-empty JSArrays the length of the FixedArray and the JSArray is the + // same. + __ mov(FieldOperand(elements_array, Array::kLengthOffset), array_size); + + // Fill the allocated FixedArray with the hole value if requested. + // result: JSObject + // elements_array: elements array + // elements_array_end: start of next object + __ bind(&fill_array); + if (fill_with_hole) { + Label loop, entry; + __ mov(scratch, Factory::the_hole_value()); + __ lea(elements_array, Operand(elements_array, + FixedArray::kHeaderSize - kHeapObjectTag)); + __ jmp(&entry); + __ bind(&loop); + __ mov(Operand(elements_array, 0), scratch); + __ add(Operand(elements_array), Immediate(kPointerSize)); + __ bind(&entry); + __ cmp(elements_array, Operand(elements_array_end)); + __ j(below, &loop); + } +} + + +// Create a new array for the built-in Array function. This function allocates +// the JSArray object and the FixedArray elements array and initializes these. +// If the Array cannot be constructed in native code the runtime is called. This +// function assumes the following state: +// edi: constructor (built-in Array function) +// eax: argc +// esp[0]: return address +// esp[4]: last argument +// This function is used for both construct and normal calls of Array. Whether +// it is a construct call or not is indicated by the construct_call parameter. +// The only difference between handling a construct call and a normal call is +// that for a construct call the constructor function in edi needs to be +// preserved for entering the generic code. In both cases argc in eax needs to +// be preserved. +static void ArrayNativeCode(MacroAssembler* masm, + bool construct_call, + Label *call_generic_code) { + Label argc_one_or_more, argc_two_or_more, prepare_generic_code_call; + + // Push the constructor and argc. No need to tag argc as a smi, as there will + // be no garbage collection with this on the stack. + int push_count = 0; + if (construct_call) { + push_count++; + __ push(edi); + } + push_count++; + __ push(eax); + + // Check for array construction with zero arguments. + __ test(eax, Operand(eax)); + __ j(not_zero, &argc_one_or_more); + + // Handle construction of an empty array. + AllocateEmptyJSArray(masm, + edi, + eax, + ebx, + ecx, + edi, + kPreallocatedArrayElements, + &prepare_generic_code_call); + __ IncrementCounter(&Counters::array_function_native, 1); + __ pop(ebx); + if (construct_call) { + __ pop(edi); + } + __ ret(kPointerSize); + + // Check for one argument. Bail out if argument is not smi or if it is + // negative. + __ bind(&argc_one_or_more); + __ cmp(eax, 1); + __ j(not_equal, &argc_two_or_more); + ASSERT(kSmiTag == 0); + __ test(Operand(esp, (push_count + 1) * kPointerSize), + Immediate(kIntptrSignBit | kSmiTagMask)); + __ j(not_zero, &prepare_generic_code_call); + + // Handle construction of an empty array of a certain size. Get the size from + // the stack and bail out if size is to large to actually allocate an elements + // array. + __ mov(edx, Operand(esp, (push_count + 1) * kPointerSize)); + ASSERT(kSmiTag == 0); + __ cmp(edx, JSObject::kInitialMaxFastElementArray << kSmiTagSize); + __ j(greater_equal, &prepare_generic_code_call); + + // edx: array_size (smi) + // edi: constructor + // esp[0]: argc + // esp[4]: constructor (only if construct_call) + // esp[8]: return address + // esp[C]: argument + AllocateJSArray(masm, + edi, + edx, + eax, + ebx, + ecx, + edi, + true, + &prepare_generic_code_call); + __ IncrementCounter(&Counters::array_function_native, 1); + __ pop(ebx); + if (construct_call) { + __ pop(edi); + } + __ ret(2 * kPointerSize); + + // Handle construction of an array from a list of arguments. + __ bind(&argc_two_or_more); + ASSERT(kSmiTag == 0); + __ shl(eax, kSmiTagSize); // Convet argc to a smi. + // eax: array_size (smi) + // edi: constructor + // esp[0] : argc + // esp[4]: constructor (only if construct_call) + // esp[8] : return address + // esp[C] : last argument + AllocateJSArray(masm, + edi, + eax, + ebx, + ecx, + edx, + edi, + false, + &prepare_generic_code_call); + __ IncrementCounter(&Counters::array_function_native, 1); + __ mov(eax, ebx); + __ pop(ebx); + if (construct_call) { + __ pop(edi); + } + __ push(eax); + // eax: JSArray + // ebx: argc + // edx: elements_array_end (untagged) + // esp[0]: JSArray + // esp[4]: return address + // esp[8]: last argument + + // Location of the last argument + __ lea(edi, Operand(esp, 2 * kPointerSize)); + + // Location of the first array element (Parameter fill_with_holes to + // AllocateJSArrayis false, so the FixedArray is returned in ecx). + __ lea(edx, Operand(ecx, FixedArray::kHeaderSize - kHeapObjectTag)); + + // ebx: argc + // edx: location of the first array element + // edi: location of the last argument + // esp[0]: JSArray + // esp[4]: return address + // esp[8]: last argument + Label loop, entry; + __ mov(ecx, ebx); + __ jmp(&entry); + __ bind(&loop); + __ mov(eax, Operand(edi, ecx, times_pointer_size, 0)); + __ mov(Operand(edx, 0), eax); + __ add(Operand(edx), Immediate(kPointerSize)); + __ bind(&entry); + __ dec(ecx); + __ j(greater_equal, &loop); + + // Remove caller arguments from the stack and return. + // ebx: argc + // esp[0]: JSArray + // esp[4]: return address + // esp[8]: last argument + __ pop(eax); + __ pop(ecx); + __ lea(esp, Operand(esp, ebx, times_pointer_size, 1 * kPointerSize)); + __ push(ecx); + __ ret(0); + + // Restore argc and constructor before running the generic code. + __ bind(&prepare_generic_code_call); + __ pop(eax); + if (construct_call) { + __ pop(edi); + } + __ jmp(call_generic_code); +} + + +void Builtins::Generate_ArrayCode(MacroAssembler* masm) { + // ----------- S t a t e ------------- + // -- eax : argc + // -- esp[0] : return address + // -- esp[4] : last argument + // ----------------------------------- + Label generic_array_code, one_or_more_arguments, two_or_more_arguments; + + // Get the Array function. + GenerateLoadArrayFunction(masm, edi); + + if (FLAG_debug_code) { + // Initial map for the builtin Array function shoud be a map. + __ mov(ebx, FieldOperand(edi, JSFunction::kPrototypeOrInitialMapOffset)); + // Will both indicate a NULL and a Smi. + __ test(ebx, Immediate(kSmiTagMask)); + __ Assert(not_zero, "Unexpected initial map for Array function"); + __ CmpObjectType(ebx, MAP_TYPE, ecx); + __ Assert(equal, "Unexpected initial map for Array function"); + } + + // Run the native code for the Array function called as a normal function. + ArrayNativeCode(masm, false, &generic_array_code); + + // Jump to the generic array code in case the specialized code cannot handle + // the construction. + __ bind(&generic_array_code); + Code* code = Builtins::builtin(Builtins::ArrayCodeGeneric); + Handle array_code(code); + __ jmp(array_code, RelocInfo::CODE_TARGET); +} + + +void Builtins::Generate_ArrayConstructCode(MacroAssembler* masm) { + // ----------- S t a t e ------------- + // -- eax : argc + // -- edi : constructor + // -- esp[0] : return address + // -- esp[4] : last argument + // ----------------------------------- + Label generic_constructor; + + if (FLAG_debug_code) { + // The array construct code is only set for the builtin Array function which + // does always have a map. + GenerateLoadArrayFunction(masm, ebx); + __ cmp(edi, Operand(ebx)); + __ Assert(equal, "Unexpected Array function"); + // Initial map for the builtin Array function should be a map. + __ mov(ebx, FieldOperand(edi, JSFunction::kPrototypeOrInitialMapOffset)); + // Will both indicate a NULL and a Smi. + __ test(ebx, Immediate(kSmiTagMask)); + __ Assert(not_zero, "Unexpected initial map for Array function"); + __ CmpObjectType(ebx, MAP_TYPE, ecx); + __ Assert(equal, "Unexpected initial map for Array function"); + } + + // Run the native code for the Array function called as constructor. + ArrayNativeCode(masm, true, &generic_constructor); + + // Jump to the generic construct code in case the specialized code cannot + // handle the construction. + __ bind(&generic_constructor); + Code* code = Builtins::builtin(Builtins::JSConstructStubGeneric); + Handle generic_construct_stub(code); + __ jmp(generic_construct_stub, RelocInfo::CODE_TARGET); +} + + static void EnterArgumentsAdaptorFrame(MacroAssembler* masm) { __ push(ebp); __ mov(ebp, Operand(esp)); diff --git a/deps/v8/src/log-utils.cc b/deps/v8/src/log-utils.cc index b31864be46..dcb4b499e6 100644 --- a/deps/v8/src/log-utils.cc +++ b/deps/v8/src/log-utils.cc @@ -310,6 +310,20 @@ void LogMessageBuilder::AppendDetailed(String* str, bool show_impl_info) { } +void LogMessageBuilder::AppendStringPart(const char* str, int len) { + if (pos_ + len > Log::kMessageBufferSize) { + len = Log::kMessageBufferSize - pos_; + ASSERT(len >= 0); + if (len == 0) return; + } + Vector buf(Log::message_buffer_ + pos_, + Log::kMessageBufferSize - pos_); + OS::StrNCpy(buf, str, len); + pos_ += len; + ASSERT(pos_ <= Log::kMessageBufferSize); +} + + bool LogMessageBuilder::StoreInCompressor(LogRecordCompressor* compressor) { return compressor->Store(Vector(Log::message_buffer_, pos_)); } diff --git a/deps/v8/src/log-utils.h b/deps/v8/src/log-utils.h index ad669d53d7..117f098cc8 100644 --- a/deps/v8/src/log-utils.h +++ b/deps/v8/src/log-utils.h @@ -114,6 +114,9 @@ class Log : public AllStatic { return !is_stopped_ && (output_handle_ != NULL || output_buffer_ != NULL); } + // Size of buffer used for formatting log messages. + static const int kMessageBufferSize = 2048; + private: typedef int (*WritePtr)(const char* msg, int length); @@ -162,9 +165,6 @@ class Log : public AllStatic { // access to the formatting buffer and the log file or log memory buffer. static Mutex* mutex_; - // Size of buffer used for formatting log messages. - static const int kMessageBufferSize = 2048; - // Buffer used for formatting log messages. This is a singleton buffer and // mutex_ should be acquired before using it. static char* message_buffer_; @@ -247,6 +247,9 @@ class LogMessageBuilder BASE_EMBEDDED { void AppendDetailed(String* str, bool show_impl_info); + // Append a portion of a string. + void AppendStringPart(const char* str, int len); + // Stores log message into compressor, returns true if the message // was stored (i.e. doesn't repeat the previous one). bool StoreInCompressor(LogRecordCompressor* compressor); diff --git a/deps/v8/src/log.cc b/deps/v8/src/log.cc index 6bbefbceb1..d225c3b495 100644 --- a/deps/v8/src/log.cc +++ b/deps/v8/src/log.cc @@ -889,14 +889,51 @@ void Logger::HeapSampleJSConstructorEvent(const char* constructor, #ifdef ENABLE_LOGGING_AND_PROFILING if (!Log::IsEnabled() || !FLAG_log_gc) return; LogMessageBuilder msg; - msg.Append("heap-js-cons-item,%s,%d,%d\n", - constructor[0] != '\0' ? constructor : "(anonymous)", - number, bytes); + msg.Append("heap-js-cons-item,%s,%d,%d\n", constructor, number, bytes); msg.WriteToLogFile(); #endif } +void Logger::HeapSampleJSRetainersEvent( + const char* constructor, const char* event) { +#ifdef ENABLE_LOGGING_AND_PROFILING + if (!Log::IsEnabled() || !FLAG_log_gc) return; + // Event starts with comma, so we don't have it in the format string. + static const char* event_text = "heap-js-ret-item,%s"; + // We take placeholder strings into account, but it's OK to be conservative. + static const int event_text_len = strlen(event_text); + const int cons_len = strlen(constructor), event_len = strlen(event); + int pos = 0; + // Retainer lists can be long. We may need to split them into multiple events. + do { + LogMessageBuilder msg; + msg.Append(event_text, constructor); + int to_write = event_len - pos; + if (to_write > Log::kMessageBufferSize - (cons_len + event_text_len)) { + int cut_pos = pos + Log::kMessageBufferSize - (cons_len + event_text_len); + ASSERT(cut_pos < event_len); + while (cut_pos > pos && event[cut_pos] != ',') --cut_pos; + if (event[cut_pos] != ',') { + // Crash in debug mode, skip in release mode. + ASSERT(false); + return; + } + // Append a piece of event that fits, without trailing comma. + msg.AppendStringPart(event + pos, cut_pos - pos); + // Start next piece with comma. + pos = cut_pos; + } else { + msg.Append("%s", event + pos); + pos += event_len; + } + msg.Append('\n'); + msg.WriteToLogFile(); + } while (pos < event_len); +#endif +} + + void Logger::DebugTag(const char* call_site_tag) { #ifdef ENABLE_LOGGING_AND_PROFILING if (!Log::IsEnabled() || !FLAG_log) return; diff --git a/deps/v8/src/log.h b/deps/v8/src/log.h index 89f6cdb391..07a0429ace 100644 --- a/deps/v8/src/log.h +++ b/deps/v8/src/log.h @@ -221,6 +221,8 @@ class Logger { static void HeapSampleItemEvent(const char* type, int number, int bytes); static void HeapSampleJSConstructorEvent(const char* constructor, int number, int bytes); + static void HeapSampleJSRetainersEvent(const char* constructor, + const char* event); static void HeapSampleStats(const char* space, const char* kind, int capacity, int used); diff --git a/deps/v8/src/mark-compact.cc b/deps/v8/src/mark-compact.cc index 8a51541752..cbd47a8763 100644 --- a/deps/v8/src/mark-compact.cc +++ b/deps/v8/src/mark-compact.cc @@ -265,18 +265,6 @@ class MarkingVisitor : public ObjectVisitor { for (Object** p = start; p < end; p++) MarkObjectByPointer(p); } - void BeginCodeIteration(Code* code) { - // When iterating over a code object during marking - // ic targets are derived pointers. - ASSERT(code->ic_flag() == Code::IC_TARGET_IS_ADDRESS); - } - - void EndCodeIteration(Code* code) { - // If this is a compacting collection, set ic targets - // are pointing to object headers. - if (IsCompacting()) code->set_ic_flag(Code::IC_TARGET_IS_OBJECT); - } - void VisitCodeTarget(RelocInfo* rinfo) { ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode())); Code* code = Code::GetCodeFromTargetAddress(rinfo->target_address()); @@ -287,11 +275,6 @@ class MarkingVisitor : public ObjectVisitor { } else { MarkCompactCollector::MarkObject(code); } - if (IsCompacting()) { - // When compacting we convert the target to a real object pointer. - code = Code::GetCodeFromTargetAddress(rinfo->target_address()); - rinfo->set_target_object(code); - } } void VisitDebugTarget(RelocInfo* rinfo) { @@ -1187,12 +1170,6 @@ static void SweepSpace(PagedSpace* space, DeallocateFunction dealloc) { if (object->IsMarked()) { object->ClearMark(); MarkCompactCollector::tracer()->decrement_marked_count(); - if (MarkCompactCollector::IsCompacting() && object->IsCode()) { - // If this is compacting collection marked code objects have had - // their IC targets converted to objects. - // They need to be converted back to addresses. - Code::cast(object)->ConvertICTargetsFromObjectToAddress(); - } if (!is_previous_alive) { // Transition from free to live. dealloc(free_start, current - free_start); is_previous_alive = true; @@ -1398,6 +1375,14 @@ class UpdatingVisitor: public ObjectVisitor { for (Object** p = start; p < end; p++) UpdatePointer(p); } + void VisitCodeTarget(RelocInfo* rinfo) { + ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode())); + Object* target = Code::GetCodeFromTargetAddress(rinfo->target_address()); + VisitPointer(&target); + rinfo->set_target_address( + reinterpret_cast(target)->instruction_start()); + } + private: void UpdatePointer(Object** p) { if (!(*p)->IsHeapObject()) return; @@ -1631,11 +1616,6 @@ void MarkCompactCollector::RelocateObjects() { ASSERT(live_cells == live_cell_objects_); ASSERT(live_news == live_young_objects_); - // Notify code object in LO to convert IC target to address - // This must happen after lo_space_->Compact - LargeObjectIterator it(Heap::lo_space()); - while (it.has_next()) { ConvertCodeICTargetToAddress(it.next()); } - // Flip from and to spaces Heap::new_space()->Flip(); @@ -1654,14 +1634,6 @@ void MarkCompactCollector::RelocateObjects() { } -int MarkCompactCollector::ConvertCodeICTargetToAddress(HeapObject* obj) { - if (obj->IsCode()) { - Code::cast(obj)->ConvertICTargetsFromObjectToAddress(); - } - return obj->Size(); -} - - int MarkCompactCollector::RelocateMapObject(HeapObject* obj) { // Recover map pointer. MapWord encoding = obj->map_word(); @@ -1770,11 +1742,6 @@ int MarkCompactCollector::RelocateCodeObject(HeapObject* obj) { // Reset the map pointer. int obj_size = RestoreMap(obj, Heap::code_space(), new_addr, map_addr); - // Convert inline cache target to address using old address. - if (obj->IsCode()) { - Code::cast(obj)->ConvertICTargetsFromObjectToAddress(); - } - Address old_addr = obj->address(); if (new_addr != old_addr) { diff --git a/deps/v8/src/messages.js b/deps/v8/src/messages.js index 255e544099..6513067135 100644 --- a/deps/v8/src/messages.js +++ b/deps/v8/src/messages.js @@ -167,7 +167,8 @@ function FormatMessage(message) { no_input_to_regexp: "No input to %0", result_not_primitive: "Result of %0 must be a primitive, was %1", invalid_json: "String '%0' is not valid JSON", - circular_structure: "Converting circular structure to JSON" + circular_structure: "Converting circular structure to JSON", + object_keys_non_object: "Object.keys called on non-object" }; } var format = kMessages[message.type]; diff --git a/deps/v8/src/objects-debug.cc b/deps/v8/src/objects-debug.cc index 9fc9b1d4ef..288cc21ecb 100644 --- a/deps/v8/src/objects-debug.cc +++ b/deps/v8/src/objects-debug.cc @@ -733,7 +733,6 @@ void Code::CodePrint() { void Code::CodeVerify() { - CHECK(ic_flag() == IC_TARGET_IS_ADDRESS); CHECK(IsAligned(reinterpret_cast(instruction_start()), static_cast(kCodeAlignment))); Address last_gc_pc = NULL; diff --git a/deps/v8/src/objects-inl.h b/deps/v8/src/objects-inl.h index cabc8a2187..29b886d87b 100644 --- a/deps/v8/src/objects-inl.h +++ b/deps/v8/src/objects-inl.h @@ -2538,16 +2538,6 @@ INT_ACCESSORS(Code, relocation_size, kRelocationSizeOffset) INT_ACCESSORS(Code, sinfo_size, kSInfoSizeOffset) -Code::ICTargetState Code::ic_flag() { - return static_cast(READ_BYTE_FIELD(this, kICFlagOffset)); -} - - -void Code::set_ic_flag(ICTargetState value) { - WRITE_BYTE_FIELD(this, kICFlagOffset, value); -} - - byte* Code::instruction_start() { return FIELD_ADDR(this, kHeaderSize); } diff --git a/deps/v8/src/objects.cc b/deps/v8/src/objects.cc index 2b6f83fdac..ea2c202c9e 100644 --- a/deps/v8/src/objects.cc +++ b/deps/v8/src/objects.cc @@ -476,6 +476,21 @@ Object* JSObject::DeleteNormalizedProperty(String* name, DeleteMode mode) { } +bool JSObject::IsDirty() { + Object* cons_obj = map()->constructor(); + if (!cons_obj->IsJSFunction()) + return true; + JSFunction* fun = JSFunction::cast(cons_obj); + if (!fun->shared()->function_data()->IsFunctionTemplateInfo()) + return true; + // If the object is fully fast case and has the same map it was + // created with then no changes can have been made to it. + return map() != fun->initial_map() + || !HasFastElements() + || !HasFastProperties(); +} + + Object* Object::GetProperty(Object* receiver, LookupResult* result, String* name, @@ -4940,60 +4955,25 @@ void SharedFunctionInfo::SharedFunctionInfoIterateBody(ObjectVisitor* v) { } -void ObjectVisitor::BeginCodeIteration(Code* code) { - ASSERT(code->ic_flag() == Code::IC_TARGET_IS_OBJECT); -} - - void ObjectVisitor::VisitCodeTarget(RelocInfo* rinfo) { ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode())); - VisitPointer(rinfo->target_object_address()); + Object* target = Code::GetCodeFromTargetAddress(rinfo->target_address()); + Object* old_target = target; + VisitPointer(&target); + CHECK_EQ(target, old_target); // VisitPointer doesn't change Code* *target. } void ObjectVisitor::VisitDebugTarget(RelocInfo* rinfo) { ASSERT(RelocInfo::IsJSReturn(rinfo->rmode()) && rinfo->IsCallInstruction()); - VisitPointer(rinfo->call_object_address()); -} - - -// Convert relocatable targets from address to code object address. This is -// mainly IC call targets but for debugging straight-line code can be replaced -// with a call instruction which also has to be relocated. -void Code::ConvertICTargetsFromAddressToObject() { - ASSERT(ic_flag() == IC_TARGET_IS_ADDRESS); - - for (RelocIterator it(this, RelocInfo::kCodeTargetMask); - !it.done(); it.next()) { - Address ic_addr = it.rinfo()->target_address(); - ASSERT(ic_addr != NULL); - HeapObject* code = Code::GetCodeFromTargetAddress(ic_addr); - ASSERT(code->IsHeapObject()); - it.rinfo()->set_target_object(code); - } - -#ifdef ENABLE_DEBUGGER_SUPPORT - if (Debug::has_break_points()) { - for (RelocIterator it(this, RelocInfo::ModeMask(RelocInfo::JS_RETURN)); - !it.done(); - it.next()) { - if (it.rinfo()->IsCallInstruction()) { - Address addr = it.rinfo()->call_address(); - ASSERT(addr != NULL); - HeapObject* code = Code::GetCodeFromTargetAddress(addr); - ASSERT(code->IsHeapObject()); - it.rinfo()->set_call_object(code); - } - } - } -#endif - set_ic_flag(IC_TARGET_IS_OBJECT); + Object* target = Code::GetCodeFromTargetAddress(rinfo->call_address()); + Object* old_target = target; + VisitPointer(&target); + CHECK_EQ(target, old_target); // VisitPointer doesn't change Code* *target. } void Code::CodeIterateBody(ObjectVisitor* v) { - v->BeginCodeIteration(this); - int mode_mask = RelocInfo::kCodeTargetMask | RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) | RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) | @@ -5020,38 +5000,6 @@ void Code::CodeIterateBody(ObjectVisitor* v) { } ScopeInfo<>::IterateScopeInfo(this, v); - - v->EndCodeIteration(this); -} - - -void Code::ConvertICTargetsFromObjectToAddress() { - ASSERT(ic_flag() == IC_TARGET_IS_OBJECT); - - for (RelocIterator it(this, RelocInfo::kCodeTargetMask); - !it.done(); it.next()) { - // We cannot use the safe cast (Code::cast) here, because we may be in - // the middle of relocating old objects during GC and the map pointer in - // the code object may be mangled - Code* code = reinterpret_cast(it.rinfo()->target_object()); - ASSERT((code != NULL) && code->IsHeapObject()); - it.rinfo()->set_target_address(code->instruction_start()); - } - -#ifdef ENABLE_DEBUGGER_SUPPORT - if (Debug::has_break_points()) { - for (RelocIterator it(this, RelocInfo::ModeMask(RelocInfo::JS_RETURN)); - !it.done(); - it.next()) { - if (it.rinfo()->IsCallInstruction()) { - Code* code = reinterpret_cast(it.rinfo()->call_object()); - ASSERT((code != NULL) && code->IsHeapObject()); - it.rinfo()->set_call_address(code->instruction_start()); - } - } - } -#endif - set_ic_flag(IC_TARGET_IS_ADDRESS); } diff --git a/deps/v8/src/objects.h b/deps/v8/src/objects.h index feeddcb675..5de9afabea 100644 --- a/deps/v8/src/objects.h +++ b/deps/v8/src/objects.h @@ -1428,6 +1428,10 @@ class JSObject: public HeapObject { // Tells whether this object needs to be loaded. inline bool IsLoaded(); + // Returns true if this is an instance of an api function and has + // been modified since it was created. May give false positives. + bool IsDirty(); + bool HasProperty(String* name) { return GetPropertyAttribute(name) != ABSENT; } @@ -2516,13 +2520,6 @@ class Code: public HeapObject { NUMBER_OF_KINDS = KEYED_STORE_IC + 1 }; - // A state indicates that inline cache in this Code object contains - // objects or relative instruction addresses. - enum ICTargetState { - IC_TARGET_IS_ADDRESS, - IC_TARGET_IS_OBJECT - }; - #ifdef ENABLE_DISASSEMBLER // Printing static const char* Kind2String(Kind kind); @@ -2562,12 +2559,6 @@ class Code: public HeapObject { inline bool is_keyed_store_stub() { return kind() == KEYED_STORE_IC; } inline bool is_call_stub() { return kind() == CALL_IC; } - // [ic_flag]: State of inline cache targets. The flag is set to the - // object variant in ConvertICTargetsFromAddressToObject, and set to - // the address variant in ConvertICTargetsFromObjectToAddress. - inline ICTargetState ic_flag(); - inline void set_ic_flag(ICTargetState value); - // [major_key]: For kind STUB, the major key. inline CodeStub::Major major_key(); inline void set_major_key(CodeStub::Major major); @@ -2613,12 +2604,6 @@ class Code: public HeapObject { // Returns the address of the scope information. inline byte* sinfo_start(); - // Convert inline cache target from address to code object before GC. - void ConvertICTargetsFromAddressToObject(); - - // Convert inline cache target from code object to address after GC - void ConvertICTargetsFromObjectToAddress(); - // Relocate the code by delta bytes. Called to signal that this code // object has been moved by delta bytes. void Relocate(int delta); @@ -2674,7 +2659,6 @@ class Code: public HeapObject { ~kCodeAlignmentMask; // Byte offsets within kKindSpecificFlagsOffset. - static const int kICFlagOffset = kKindSpecificFlagsOffset + 0; static const int kStubMajorKeyOffset = kKindSpecificFlagsOffset + 1; // Flags layout. @@ -4806,9 +4790,6 @@ class ObjectVisitor BASE_EMBEDDED { // To allow lazy clearing of inline caches the visitor has // a rich interface for iterating over Code objects.. - // Called prior to visiting the body of a Code object. - virtual void BeginCodeIteration(Code* code); - // Visits a code target in the instruction stream. virtual void VisitCodeTarget(RelocInfo* rinfo); @@ -4818,9 +4799,6 @@ class ObjectVisitor BASE_EMBEDDED { // Visits a debug call target in the instruction stream. virtual void VisitDebugTarget(RelocInfo* rinfo); - // Called after completing visiting the body of a Code object. - virtual void EndCodeIteration(Code* code) {} - // Handy shorthand for visiting a single pointer. virtual void VisitPointer(Object** p) { VisitPointers(p, p + 1); } diff --git a/deps/v8/src/runtime.cc b/deps/v8/src/runtime.cc index 6272827b45..06b61e7bcb 100644 --- a/deps/v8/src/runtime.cc +++ b/deps/v8/src/runtime.cc @@ -1208,6 +1208,14 @@ static Object* Runtime_FunctionIsAPIFunction(Arguments args) { : Heap::false_value(); } +static Object* Runtime_FunctionIsBuiltin(Arguments args) { + NoHandleAllocation ha; + ASSERT(args.length() == 1); + + CONVERT_CHECKED(JSFunction, f, args[0]); + return f->IsBuiltin() ? Heap::true_value() : Heap::false_value(); +} + static Object* Runtime_SetCode(Arguments args) { HandleScope scope; @@ -2992,7 +3000,8 @@ static Object* Runtime_GetPropertyNamesFast(Arguments args) { HandleScope scope; Handle object(raw_object); - Handle content = GetKeysInFixedArrayFor(object); + Handle content = GetKeysInFixedArrayFor(object, + INCLUDE_PROTOS); // Test again, since cache may have been built by preceding call. if (object->IsSimpleEnum()) return object->map(); @@ -3001,6 +3010,22 @@ static Object* Runtime_GetPropertyNamesFast(Arguments args) { } +static Object* Runtime_LocalKeys(Arguments args) { + ASSERT_EQ(args.length(), 1); + CONVERT_CHECKED(JSObject, raw_object, args[0]); + HandleScope scope; + Handle object(raw_object); + Handle contents = GetKeysInFixedArrayFor(object, + LOCAL_ONLY); + // Some fast paths through GetKeysInFixedArrayFor reuse a cached + // property array and since the result is mutable we have to create + // a fresh clone on each invocation. + Handle copy = Factory::NewFixedArray(contents->length()); + contents->CopyTo(0, *copy, 0, contents->length()); + return *Factory::NewJSArrayWithElements(copy); +} + + static Object* Runtime_GetArgumentsProperty(Arguments args) { NoHandleAllocation ha; ASSERT(args.length() == 1); @@ -5516,7 +5541,7 @@ static Object* Runtime_GetArrayKeys(Arguments args) { if (array->elements()->IsDictionary()) { // Create an array and get all the keys into it, then remove all the // keys that are not integers in the range 0 to length-1. - Handle keys = GetKeysInFixedArrayFor(array); + Handle keys = GetKeysInFixedArrayFor(array, INCLUDE_PROTOS); int keys_length = keys->length(); for (int i = 0; i < keys_length; i++) { Object* key = keys->get(i); @@ -5738,55 +5763,51 @@ static Object* Runtime_DebugGetPropertyDetails(Arguments args) { int length = LocalPrototypeChainLength(*obj); // Try local lookup on each of the objects. - LookupResult result; Handle jsproto = obj; for (int i = 0; i < length; i++) { + LookupResult result; jsproto->LocalLookup(*name, &result); if (result.IsProperty()) { - break; + // LookupResult is not GC safe as it holds raw object pointers. + // GC can happen later in this code so put the required fields into + // local variables using handles when required for later use. + PropertyType result_type = result.type(); + Handle result_callback_obj; + if (result_type == CALLBACKS) { + result_callback_obj = Handle(result.GetCallbackObject()); + } + Smi* property_details = result.GetPropertyDetails().AsSmi(); + // DebugLookupResultValue can cause GC so details from LookupResult needs + // to be copied to handles before this. + bool caught_exception = false; + Object* raw_value = DebugLookupResultValue(*obj, *name, &result, + &caught_exception); + if (raw_value->IsFailure()) return raw_value; + Handle value(raw_value); + + // If the callback object is a fixed array then it contains JavaScript + // getter and/or setter. + bool hasJavaScriptAccessors = result_type == CALLBACKS && + result_callback_obj->IsFixedArray(); + Handle details = + Factory::NewFixedArray(hasJavaScriptAccessors ? 5 : 2); + details->set(0, *value); + details->set(1, property_details); + if (hasJavaScriptAccessors) { + details->set(2, + caught_exception ? Heap::true_value() + : Heap::false_value()); + details->set(3, FixedArray::cast(*result_callback_obj)->get(0)); + details->set(4, FixedArray::cast(*result_callback_obj)->get(1)); + } + + return *Factory::NewJSArrayWithElements(details); } if (i < length - 1) { jsproto = Handle(JSObject::cast(jsproto->GetPrototype())); } } - if (result.IsProperty()) { - // LookupResult is not GC safe as all its members are raw object pointers. - // When calling DebugLookupResultValue GC can happen as this might invoke - // callbacks. After the call to DebugLookupResultValue the callback object - // in the LookupResult might still be needed. Put it into a handle for later - // use. - PropertyType result_type = result.type(); - Handle result_callback_obj; - if (result_type == CALLBACKS) { - result_callback_obj = Handle(result.GetCallbackObject()); - } - - // Find the actual value. Don't use result after this call as it's content - // can be invalid. - bool caught_exception = false; - Object* value = DebugLookupResultValue(*obj, *name, &result, - &caught_exception); - if (value->IsFailure()) return value; - Handle value_handle(value); - - // If the callback object is a fixed array then it contains JavaScript - // getter and/or setter. - bool hasJavaScriptAccessors = result_type == CALLBACKS && - result_callback_obj->IsFixedArray(); - Handle details = - Factory::NewFixedArray(hasJavaScriptAccessors ? 5 : 2); - details->set(0, *value_handle); - details->set(1, result.GetPropertyDetails().AsSmi()); - if (hasJavaScriptAccessors) { - details->set(2, - caught_exception ? Heap::true_value() : Heap::false_value()); - details->set(3, FixedArray::cast(result.GetCallbackObject())->get(0)); - details->set(4, FixedArray::cast(result.GetCallbackObject())->get(1)); - } - - return *Factory::NewJSArrayWithElements(details); - } return Heap::undefined_value(); } @@ -6271,7 +6292,7 @@ static Handle MaterializeLocalScope(JavaScriptFrame* frame) { if (function_context->has_extension() && !function_context->IsGlobalContext()) { Handle ext(JSObject::cast(function_context->extension())); - Handle keys = GetKeysInFixedArrayFor(ext); + Handle keys = GetKeysInFixedArrayFor(ext, INCLUDE_PROTOS); for (int i = 0; i < keys->length(); i++) { // Names of variables introduced by eval are strings. ASSERT(keys->get(i)->IsString()); @@ -6320,7 +6341,7 @@ static Handle MaterializeClosure(Handle context) { // be variables introduced by eval. if (context->has_extension()) { Handle ext(JSObject::cast(context->extension())); - Handle keys = GetKeysInFixedArrayFor(ext); + Handle keys = GetKeysInFixedArrayFor(ext, INCLUDE_PROTOS); for (int i = 0; i < keys->length(); i++) { // Names of variables introduced by eval are strings. ASSERT(keys->get(i)->IsString()); diff --git a/deps/v8/src/runtime.h b/deps/v8/src/runtime.h index ca38baf8ee..afa278b135 100644 --- a/deps/v8/src/runtime.h +++ b/deps/v8/src/runtime.h @@ -171,6 +171,7 @@ namespace internal { F(FunctionGetScriptSourcePosition, 1, 1) \ F(FunctionGetPositionForOffset, 2, 1) \ F(FunctionIsAPIFunction, 1, 1) \ + F(FunctionIsBuiltin, 1, 1) \ F(GetScript, 1, 1) \ F(CollectStackTrace, 2, 1) \ \ @@ -258,6 +259,8 @@ namespace internal { F(Abort, 2, 1) \ /* Logging */ \ F(Log, 2, 1) \ + /* ES5 */ \ + F(LocalKeys, 1, 1) \ \ /* Pseudo functions - handled as macros by parser */ \ F(IS_VAR, 1, 1) diff --git a/deps/v8/src/serialize.cc b/deps/v8/src/serialize.cc index c89476241a..b6a9d9434a 100644 --- a/deps/v8/src/serialize.cc +++ b/deps/v8/src/serialize.cc @@ -935,6 +935,15 @@ class ReferenceUpdater: public ObjectVisitor { } } + virtual void VisitCodeTarget(RelocInfo* rinfo) { + ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode())); + Code* target = Code::GetCodeFromTargetAddress(rinfo->target_address()); + Address encoded_target = serializer_->GetSavedAddress(target); + offsets_.Add(rinfo->target_address_address() - obj_address_); + addresses_.Add(encoded_target); + } + + virtual void VisitExternalReferences(Address* start, Address* end) { for (Address* p = start; p < end; ++p) { uint32_t code = reference_encoder_->Encode(*p); @@ -1093,6 +1102,14 @@ void Serializer::VisitPointers(Object** start, Object** end) { } +void Serializer::VisitCodeTarget(RelocInfo* rinfo) { + ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode())); + Code* target = Code::GetCodeFromTargetAddress(rinfo->target_address()); + bool serialized; + Encode(target, &serialized); +} + + class GlobalHandlesRetriever: public ObjectVisitor { public: explicit GlobalHandlesRetriever(List* handles) @@ -1255,10 +1272,7 @@ Address Serializer::PutObject(HeapObject* obj) { SaveAddress(obj, addr); if (type == CODE_TYPE) { - Code* code = Code::cast(obj); - // Ensure Code objects contain Object pointers, not Addresses. - code->ConvertICTargetsFromAddressToObject(); - LOG(CodeMoveEvent(code->address(), addr)); + LOG(CodeMoveEvent(obj->address(), addr)); } // Write out the object prologue: type, size, and simulated address of obj. @@ -1290,12 +1304,6 @@ Address Serializer::PutObject(HeapObject* obj) { } #endif - if (type == CODE_TYPE) { - Code* code = Code::cast(obj); - // Convert relocations from Object* to Address in Code objects - code->ConvertICTargetsFromObjectToAddress(); - } - objects_++; return addr; } @@ -1422,6 +1430,14 @@ void Deserializer::VisitPointers(Object** start, Object** end) { } +void Deserializer::VisitCodeTarget(RelocInfo* rinfo) { + ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode())); + Address encoded_address = reinterpret_cast
(rinfo->target_object()); + Code* target_object = reinterpret_cast(Resolve(encoded_address)); + rinfo->set_target_address(target_object->instruction_start()); +} + + void Deserializer::VisitExternalReferences(Address* start, Address* end) { for (Address* p = start; p < end; ++p) { uint32_t code = static_cast(reinterpret_cast(*p)); @@ -1617,8 +1633,6 @@ Object* Deserializer::GetObject() { if (type == CODE_TYPE) { Code* code = Code::cast(obj); - // Convert relocations from Object* to Address in Code objects - code->ConvertICTargetsFromObjectToAddress(); LOG(CodeMoveEvent(a, code->address())); } objects_++; diff --git a/deps/v8/src/serialize.h b/deps/v8/src/serialize.h index f5780ae35b..c901480fe5 100644 --- a/deps/v8/src/serialize.h +++ b/deps/v8/src/serialize.h @@ -155,7 +155,7 @@ class Serializer: public ObjectVisitor { friend class ReferenceUpdater; virtual void VisitPointers(Object** start, Object** end); - + virtual void VisitCodeTarget(RelocInfo* rinfo); bool IsVisited(HeapObject* obj); Address GetSavedAddress(HeapObject* obj); @@ -289,6 +289,7 @@ class Deserializer: public ObjectVisitor { private: virtual void VisitPointers(Object** start, Object** end); + virtual void VisitCodeTarget(RelocInfo* rinfo); virtual void VisitExternalReferences(Address* start, Address* end); virtual void VisitRuntimeEntry(RelocInfo* rinfo); diff --git a/deps/v8/src/spaces.cc b/deps/v8/src/spaces.cc index de9b233637..998debb30b 100644 --- a/deps/v8/src/spaces.cc +++ b/deps/v8/src/spaces.cc @@ -827,13 +827,7 @@ void PagedSpace::Verify(ObjectVisitor* visitor) { // have their remembered set bits set if required as determined // by the visitor. int size = object->Size(); - if (object->IsCode()) { - Code::cast(object)->ConvertICTargetsFromAddressToObject(); - object->IterateBody(map->instance_type(), size, visitor); - Code::cast(object)->ConvertICTargetsFromObjectToAddress(); - } else { - object->IterateBody(map->instance_type(), size, visitor); - } + object->IterateBody(map->instance_type(), size, visitor); current += size; } @@ -1906,7 +1900,7 @@ void OldSpace::ReportStatistics() { int rset = Memory::int_at(rset_addr); if (rset != 0) { // Bits were set - int intoff = rset_addr - p->address(); + int intoff = rset_addr - p->address() - Page::kRSetOffset; int bitoff = 0; for (; bitoff < kBitsPerInt; ++bitoff) { if ((rset & (1 << bitoff)) != 0) { @@ -2171,7 +2165,7 @@ void FixedSpace::ReportStatistics() { int rset = Memory::int_at(rset_addr); if (rset != 0) { // Bits were set - int intoff = rset_addr - p->address(); + int intoff = rset_addr - p->address() - Page::kRSetOffset; int bitoff = 0; for (; bitoff < kBitsPerInt; ++bitoff) { if ((rset & (1 << bitoff)) != 0) { @@ -2574,11 +2568,9 @@ void LargeObjectSpace::Verify() { // Byte arrays and strings don't have interior pointers. if (object->IsCode()) { VerifyPointersVisitor code_visitor; - Code::cast(object)->ConvertICTargetsFromAddressToObject(); object->IterateBody(map->instance_type(), object->Size(), &code_visitor); - Code::cast(object)->ConvertICTargetsFromObjectToAddress(); } else if (object->IsFixedArray()) { // We loop over fixed arrays ourselves, rather then using the visitor, // because the visitor doesn't support the start/offset iteration diff --git a/deps/v8/src/string-stream.cc b/deps/v8/src/string-stream.cc index cec4167a98..8c62a45f92 100644 --- a/deps/v8/src/string-stream.cc +++ b/deps/v8/src/string-stream.cc @@ -251,7 +251,7 @@ void StringStream::Add(const char* format, FmtElm arg0, FmtElm arg1, } -SmartPointer StringStream::ToCString() { +SmartPointer StringStream::ToCString() const { char* str = NewArray(length_ + 1); memcpy(str, buffer_, length_); str[length_] = '\0'; diff --git a/deps/v8/src/string-stream.h b/deps/v8/src/string-stream.h index 6649f18313..323a6d6633 100644 --- a/deps/v8/src/string-stream.h +++ b/deps/v8/src/string-stream.h @@ -141,7 +141,7 @@ class StringStream { void OutputToStdOut(); void Log(); Handle ToString(); - SmartPointer ToCString(); + SmartPointer ToCString() const; // Object printing support. void PrintName(Object* o); diff --git a/deps/v8/src/v8-counters.h b/deps/v8/src/v8-counters.h index 0b941f672b..e360b55768 100644 --- a/deps/v8/src/v8-counters.h +++ b/deps/v8/src/v8-counters.h @@ -142,6 +142,8 @@ namespace internal { SC(constructed_objects, V8.ConstructedObjects) \ SC(constructed_objects_runtime, V8.ConstructedObjectsRuntime) \ SC(constructed_objects_stub, V8.ConstructedObjectsStub) \ + SC(array_function_runtime, V8.ArrayFunctionRuntime) \ + SC(array_function_native, V8.ArrayFunctionNative) \ SC(for_in, V8.ForIn) \ SC(enum_cache_hits, V8.EnumCacheHits) \ SC(enum_cache_misses, V8.EnumCacheMisses) \ diff --git a/deps/v8/src/v8natives.js b/deps/v8/src/v8natives.js index be92347768..2fecee80c0 100644 --- a/deps/v8/src/v8natives.js +++ b/deps/v8/src/v8natives.js @@ -276,6 +276,13 @@ function ObjectLookupSetter(name) { } +function ObjectKeys(obj) { + if ((!IS_OBJECT(obj) || IS_NULL_OR_UNDEFINED(obj)) && !IS_FUNCTION(obj)) + throw MakeTypeError('object_keys_non_object', [obj]); + return %LocalKeys(obj); +} + + %SetCode($Object, function(x) { if (%_IsConstructCall()) { if (x == null) return this; @@ -304,6 +311,9 @@ function SetupObject() { "__defineSetter__", ObjectDefineSetter, "__lookupSetter__", ObjectLookupSetter )); + InstallFunctions($Object, DONT_ENUM, $Array( + "keys", ObjectKeys + )); } SetupObject(); @@ -514,7 +524,7 @@ function FunctionSourceString(func) { } var source = %FunctionGetSourceCode(func); - if (!IS_STRING(source)) { + if (!IS_STRING(source) || %FunctionIsBuiltin(func)) { var name = %FunctionGetName(func); if (name) { // Mimic what KJS does. @@ -524,12 +534,6 @@ function FunctionSourceString(func) { } } - // Censor occurrences of internal calls. We do that for all - // functions and don't cache under the assumption that people rarly - // convert functions to strings. Note that we (apparently) can't - // use regular expression literals in natives files. - var regexp = ORIGINAL_REGEXP("%(\\w+\\()", "gm"); - if (source.match(regexp)) source = source.replace(regexp, "$1"); var name = %FunctionGetName(func); return 'function ' + name + source; } diff --git a/deps/v8/src/version.cc b/deps/v8/src/version.cc index 3d4939b481..8b612de5a9 100644 --- a/deps/v8/src/version.cc +++ b/deps/v8/src/version.cc @@ -34,8 +34,8 @@ // cannot be changed without changing the SCons build script. #define MAJOR_VERSION 1 #define MINOR_VERSION 3 -#define BUILD_NUMBER 11 -#define PATCH_LEVEL 1 +#define BUILD_NUMBER 13 +#define PATCH_LEVEL 0 #define CANDIDATE_VERSION false // Define SONAME to have the SCons build the put a specific SONAME into the diff --git a/deps/v8/src/x64/builtins-x64.cc b/deps/v8/src/x64/builtins-x64.cc index 170a15b833..d399a88005 100644 --- a/deps/v8/src/x64/builtins-x64.cc +++ b/deps/v8/src/x64/builtins-x64.cc @@ -452,6 +452,22 @@ void Builtins::Generate_FunctionApply(MacroAssembler* masm) { } +void Builtins::Generate_ArrayCode(MacroAssembler* masm) { + // Just jump to the generic array code. + Code* code = Builtins::builtin(Builtins::ArrayCodeGeneric); + Handle array_code(code); + __ Jump(array_code, RelocInfo::CODE_TARGET); +} + + +void Builtins::Generate_ArrayConstructCode(MacroAssembler* masm) { + // Just jump to the generic construct code. + Code* code = Builtins::builtin(Builtins::JSConstructStubGeneric); + Handle generic_construct_stub(code); + __ Jump(generic_construct_stub, RelocInfo::CODE_TARGET); +} + + void Builtins::Generate_JSConstructCall(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- rax: number of arguments diff --git a/deps/v8/src/zone-inl.h b/deps/v8/src/zone-inl.h index b3141a4810..121ba19b12 100644 --- a/deps/v8/src/zone-inl.h +++ b/deps/v8/src/zone-inl.h @@ -276,12 +276,19 @@ void ZoneSplayTree::Splay(const Key& key) { } -template -static void DoForEach(Node* node, Callback* callback) { - if (node == NULL) return; - DoForEach(node->left(), callback); - callback->Call(node->key(), node->value()); - DoForEach(node->right(), callback); +template template +void ZoneSplayTree::ForEach(Callback* callback) { + // Pre-allocate some space for tiny trees. + ZoneList nodes_to_visit(10); + nodes_to_visit.Add(root_); + int pos = 0; + while (pos < nodes_to_visit.length()) { + Node* node = nodes_to_visit[pos++]; + if (node == NULL) continue; + callback->Call(node->key(), node->value()); + nodes_to_visit.Add(node->left()); + nodes_to_visit.Add(node->right()); + } } diff --git a/deps/v8/src/zone.h b/deps/v8/src/zone.h index cdbab32821..4e4f1d7224 100644 --- a/deps/v8/src/zone.h +++ b/deps/v8/src/zone.h @@ -204,10 +204,6 @@ class ZoneScope BASE_EMBEDDED { }; -template -static void DoForEach(Node* node, Callback* callback); - - // A zone splay tree. The config type parameter encapsulates the // different configurations of a concrete splay tree: // @@ -297,9 +293,7 @@ class ZoneSplayTree : public ZoneObject { }; template - void ForEach(Callback* c) { - DoForEach::Node, Callback>(root_, c); - } + void ForEach(Callback* callback); private: Node* root_; diff --git a/deps/v8/test/cctest/SConscript b/deps/v8/test/cctest/SConscript index fc4e01a425..91034034a1 100644 --- a/deps/v8/test/cctest/SConscript +++ b/deps/v8/test/cctest/SConscript @@ -45,6 +45,7 @@ SOURCES = { 'test-func-name-inference.cc', 'test-hashmap.cc', 'test-heap.cc', + 'test-heap-profiler.cc', 'test-list.cc', 'test-lock.cc', 'test-log.cc', diff --git a/deps/v8/test/cctest/test-heap-profiler.cc b/deps/v8/test/cctest/test-heap-profiler.cc new file mode 100644 index 0000000000..f8e5a6b755 --- /dev/null +++ b/deps/v8/test/cctest/test-heap-profiler.cc @@ -0,0 +1,330 @@ +// Copyright 2009 the V8 project authors. All rights reserved. +// +// Tests for heap profiler + +#ifdef ENABLE_LOGGING_AND_PROFILING + +#include "v8.h" +#include "heap-profiler.h" +#include "string-stream.h" +#include "cctest.h" + +namespace i = v8::internal; +using i::ClustersCoarser; +using i::JSObjectsCluster; +using i::JSObjectsRetainerTree; +using i::JSObjectsClusterTree; +using i::RetainerHeapProfile; + + +static void CompileAndRunScript(const char *src) { + v8::Script::Compile(v8::String::New(src))->Run(); +} + + +namespace { + +class ConstructorHeapProfileTestHelper : public i::ConstructorHeapProfile { + public: + ConstructorHeapProfileTestHelper() + : i::ConstructorHeapProfile(), + f_name_(i::Factory::NewStringFromAscii(i::CStrVector("F"))), + f_count_(0) { + } + + void Call(const JSObjectsCluster& cluster, + const i::NumberAndSizeInfo& number_and_size) { + if (f_name_->Equals(cluster.constructor())) { + CHECK_EQ(f_count_, 0); + f_count_ = number_and_size.number(); + CHECK_GT(f_count_, 0); + } + } + + int f_count() { return f_count_; } + + private: + i::Handle f_name_; + int f_count_; +}; + +} // namespace + + +TEST(ConstructorProfile) { + v8::HandleScope scope; + v8::Handle env = v8::Context::New(); + env->Enter(); + + CompileAndRunScript( + "function F() {} // A constructor\n" + "var f1 = new F();\n" + "var f2 = new F();\n"); + + ConstructorHeapProfileTestHelper cons_profile; + i::AssertNoAllocation no_alloc; + i::HeapIterator iterator; + while (iterator.has_next()) { + i::HeapObject* obj = iterator.next(); + cons_profile.CollectStats(obj); + } + CHECK_EQ(0, cons_profile.f_count()); + cons_profile.PrintStats(); + CHECK_EQ(2, cons_profile.f_count()); +} + + +static JSObjectsCluster AddHeapObjectToTree( + JSObjectsRetainerTree* tree, + i::String* constructor, + int instance, + JSObjectsCluster* ref1 = NULL, + JSObjectsCluster* ref2 = NULL, + JSObjectsCluster* ref3 = NULL) { + JSObjectsCluster o(constructor, reinterpret_cast(instance)); + JSObjectsClusterTree* o_tree = new JSObjectsClusterTree(); + JSObjectsClusterTree::Locator o_loc; + if (ref1 != NULL) o_tree->Insert(*ref1, &o_loc); + if (ref2 != NULL) o_tree->Insert(*ref2, &o_loc); + if (ref3 != NULL) o_tree->Insert(*ref3, &o_loc); + JSObjectsRetainerTree::Locator loc; + tree->Insert(o, &loc); + loc.set_value(o_tree); + return o; +} + + +static inline void CheckEqualsHelper(const char* file, int line, + const char* expected_source, + const JSObjectsCluster& expected, + const char* value_source, + const JSObjectsCluster& value) { + if (JSObjectsCluster::Compare(expected, value) != 0) { + i::HeapStringAllocator allocator; + i::StringStream stream(&allocator); + stream.Add("# Expected: "); + expected.DebugPrint(&stream); + stream.Add("\n# Found: "); + value.DebugPrint(&stream); + V8_Fatal(file, line, "CHECK_EQ(%s, %s) failed\n%s", + expected_source, value_source, + *stream.ToCString()); + } +} + + +static inline void CheckNonEqualsHelper(const char* file, int line, + const char* expected_source, + const JSObjectsCluster& expected, + const char* value_source, + const JSObjectsCluster& value) { + if (JSObjectsCluster::Compare(expected, value) == 0) { + i::HeapStringAllocator allocator; + i::StringStream stream(&allocator); + stream.Add("# Expected: "); + expected.DebugPrint(&stream); + stream.Add("\n# Found: "); + value.DebugPrint(&stream); + V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n%s", + expected_source, value_source, + *stream.ToCString()); + } +} + + +TEST(ClustersCoarserSimple) { + v8::HandleScope scope; + v8::Handle env = v8::Context::New(); + env->Enter(); + + i::ZoneScope zn_scope(i::DELETE_ON_EXIT); + + JSObjectsRetainerTree tree; + JSObjectsCluster function(i::Heap::function_class_symbol()); + JSObjectsCluster a(*i::Factory::NewStringFromAscii(i::CStrVector("A"))); + JSObjectsCluster b(*i::Factory::NewStringFromAscii(i::CStrVector("B"))); + + // o1 <- Function + JSObjectsCluster o1 = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x100, &function); + // o2 <- Function + JSObjectsCluster o2 = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x200, &function); + // o3 <- A, B + JSObjectsCluster o3 = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x300, &a, &b); + // o4 <- B, A + JSObjectsCluster o4 = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x400, &b, &a); + // o5 <- A, B, Function + JSObjectsCluster o5 = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x500, + &a, &b, &function); + + ClustersCoarser coarser; + coarser.Process(&tree); + + CHECK_EQ(coarser.GetCoarseEquivalent(o1), coarser.GetCoarseEquivalent(o2)); + CHECK_EQ(coarser.GetCoarseEquivalent(o3), coarser.GetCoarseEquivalent(o4)); + CHECK_NE(coarser.GetCoarseEquivalent(o1), coarser.GetCoarseEquivalent(o3)); + CHECK_EQ(JSObjectsCluster(), coarser.GetCoarseEquivalent(o5)); +} + + +TEST(ClustersCoarserMultipleConstructors) { + v8::HandleScope scope; + v8::Handle env = v8::Context::New(); + env->Enter(); + + i::ZoneScope zn_scope(i::DELETE_ON_EXIT); + + JSObjectsRetainerTree tree; + JSObjectsCluster function(i::Heap::function_class_symbol()); + + // o1 <- Function + JSObjectsCluster o1 = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x100, &function); + // a1 <- Function + JSObjectsCluster a1 = + AddHeapObjectToTree(&tree, i::Heap::Array_symbol(), 0x1000, &function); + // o2 <- Function + JSObjectsCluster o2 = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x200, &function); + // a2 <- Function + JSObjectsCluster a2 = + AddHeapObjectToTree(&tree, i::Heap::Array_symbol(), 0x2000, &function); + + ClustersCoarser coarser; + coarser.Process(&tree); + + CHECK_EQ(coarser.GetCoarseEquivalent(o1), coarser.GetCoarseEquivalent(o2)); + CHECK_EQ(coarser.GetCoarseEquivalent(a1), coarser.GetCoarseEquivalent(a2)); +} + + +TEST(ClustersCoarserPathsTraversal) { + v8::HandleScope scope; + v8::Handle env = v8::Context::New(); + env->Enter(); + + i::ZoneScope zn_scope(i::DELETE_ON_EXIT); + + JSObjectsRetainerTree tree; + + // On the following graph: + // + // p + // <- o21 <- o11 <- + // q o + // <- o22 <- o12 <- + // r + // + // we expect that coarser will deduce equivalences: p ~ q ~ r, + // o21 ~ o22, and o11 ~ o12. + + JSObjectsCluster o = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x100); + JSObjectsCluster o11 = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x110, &o); + JSObjectsCluster o12 = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x120, &o); + JSObjectsCluster o21 = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x210, &o11); + JSObjectsCluster o22 = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x220, &o12); + JSObjectsCluster p = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x300, &o21); + JSObjectsCluster q = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x310, &o21, &o22); + JSObjectsCluster r = + AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x320, &o22); + + ClustersCoarser coarser; + coarser.Process(&tree); + + CHECK_EQ(JSObjectsCluster(), coarser.GetCoarseEquivalent(o)); + CHECK_EQ(coarser.GetCoarseEquivalent(o11), coarser.GetCoarseEquivalent(o12)); + CHECK_EQ(coarser.GetCoarseEquivalent(o21), coarser.GetCoarseEquivalent(o22)); + CHECK_NE(coarser.GetCoarseEquivalent(o11), coarser.GetCoarseEquivalent(o21)); + CHECK_EQ(coarser.GetCoarseEquivalent(p), coarser.GetCoarseEquivalent(q)); + CHECK_EQ(coarser.GetCoarseEquivalent(q), coarser.GetCoarseEquivalent(r)); + CHECK_NE(coarser.GetCoarseEquivalent(o11), coarser.GetCoarseEquivalent(p)); + CHECK_NE(coarser.GetCoarseEquivalent(o21), coarser.GetCoarseEquivalent(p)); +} + + +namespace { + +class RetainerProfilePrinter : public RetainerHeapProfile::Printer { + public: + RetainerProfilePrinter() : stream_(&allocator_), lines_(100) {} + + void PrintRetainers(const JSObjectsCluster& cluster, + const i::StringStream& retainers) { + cluster.Print(&stream_); + stream_.Add("%s", *(retainers.ToCString())); + stream_.Put('\0'); + } + + const char* GetRetainers(const char* constructor) { + FillLines(); + const size_t cons_len = strlen(constructor); + for (int i = 0; i < lines_.length(); ++i) { + if (strncmp(constructor, lines_[i], cons_len) == 0 && + lines_[i][cons_len] == ',') { + return lines_[i] + cons_len + 1; + } + } + return NULL; + } + + private: + void FillLines() { + if (lines_.length() > 0) return; + stream_.Put('\0'); + stream_str_ = stream_.ToCString(); + const char* pos = *stream_str_; + while (pos != NULL && *pos != '\0') { + lines_.Add(pos); + pos = strchr(pos, '\0'); + if (pos != NULL) ++pos; + } + } + + i::HeapStringAllocator allocator_; + i::StringStream stream_; + i::SmartPointer stream_str_; + i::List lines_; +}; + +} // namespace + + +TEST(RetainerProfile) { + v8::HandleScope scope; + v8::Handle env = v8::Context::New(); + env->Enter(); + + CompileAndRunScript( + "function A() {}\n" + "function B(x) { this.x = x; }\n" + "function C(x) { this.x1 = x; this.x2 = x; }\n" + "var a = new A();\n" + "var b1 = new B(a), b2 = new B(a);\n" + "var c = new C(a);"); + + RetainerHeapProfile ret_profile; + i::AssertNoAllocation no_alloc; + i::HeapIterator iterator; + while (iterator.has_next()) { + i::HeapObject* obj = iterator.next(); + ret_profile.CollectStats(obj); + } + RetainerProfilePrinter printer; + ret_profile.DebugPrintStats(&printer); + CHECK_EQ("(global property);1,B;2,C;2", printer.GetRetainers("A")); + CHECK_EQ("(global property);2", printer.GetRetainers("B")); + CHECK_EQ("(global property);1", printer.GetRetainers("C")); +} + +#endif // ENABLE_LOGGING_AND_PROFILING diff --git a/deps/v8/test/es5conform/README b/deps/v8/test/es5conform/README new file mode 100644 index 0000000000..a88f4a368f --- /dev/null +++ b/deps/v8/test/es5conform/README @@ -0,0 +1,14 @@ +This directory contains code for binding the es5conform test suite +into the v8 test harness. To use the tests check out the es5conform +tests from + + https://es5conform.svn.codeplex.com/svn + +in revision 59101 as 'data' in this directory. Using later version +may be possible but the tests are only known to pass (and indeed run) +with that revision. + +If you do update to a newer revision you may have to change the test +harness adapter code since it uses internal functionality from the +harness that comes bundled with the tests. You will most likely also +have to update the test expectation file. diff --git a/deps/v8/test/es5conform/es5conform.status b/deps/v8/test/es5conform/es5conform.status new file mode 100644 index 0000000000..49cffb2801 --- /dev/null +++ b/deps/v8/test/es5conform/es5conform.status @@ -0,0 +1,68 @@ +# Copyright 2009 the V8 project authors. All rights reserved. +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +prefix es5conform +def UNIMPLEMENTED = PASS || FAIL +def FAIL_OK = FAIL, OKAY + +chapter07: UNIMPLEMENTED +chapter08: UNIMPLEMENTED +chapter10: UNIMPLEMENTED +chapter11: UNIMPLEMENTED +chapter12: UNIMPLEMENTED +chapter13: UNIMPLEMENTED +chapter14: UNIMPLEMENTED +chapter15/15.1: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.1: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.2: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.3: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.4: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.5: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.6: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.7: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.8: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.9: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.10: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.11: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.12: UNIMPLEMENTED +chapter15/15.2/15.2.3/15.2.3.13: UNIMPLEMENTED + +# Object.keys +chapter15/15.2/15.2.3/15.2.3.14: PASS + +# We fail this because Object.keys returns numbers for element indices +# rather than strings. +chapter15/15.2/15.2.3/15.2.3.14/15.2.3.14-3-3: FAIL_OK + +chapter15/15.3: UNIMPLEMENTED +chapter15/15.4: UNIMPLEMENTED +chapter15/15.5: UNIMPLEMENTED +chapter15/15.6: UNIMPLEMENTED +chapter15/15.7: UNIMPLEMENTED +chapter15/15.9: UNIMPLEMENTED +chapter15/15.10: UNIMPLEMENTED +chapter15/15.12: UNIMPLEMENTED diff --git a/deps/v8/test/es5conform/harness-adapt.js b/deps/v8/test/es5conform/harness-adapt.js new file mode 100644 index 0000000000..396d4ed978 --- /dev/null +++ b/deps/v8/test/es5conform/harness-adapt.js @@ -0,0 +1,74 @@ +// Copyright 2009 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +var global = this; + +function ES5Error(ut) { + this.ut = ut; +} + +ES5Error.prototype.toString = function () { + return this.ut.res; +}; + +// The harness uses the IE specific .description property of exceptions but +// that's nothing we can't hack our way around. +Error.prototype.__defineGetter__('description', function () { + return this.message; +}); + +function TestHarness() { + sth.call(this, global); + this._testResults = [] +} + +// Borrow sth's registerTest method. +TestHarness.prototype.registerTest = sth.prototype.registerTest; + +// Drop the before/after stuff, just run the test. +TestHarness.prototype.startTesting = function () { + sth.prototype.run.call(this); + this.report(); +}; + +TestHarness.prototype.report = function () { + for (var i = 0; i < this._testResults.length; i++) { + var ut = this._testResults[i]; + // We don't fail on preconditions. Yet. + if (ut.res == "Precondition failed") + continue; + if (ut.res != 'pass') + throw new ES5Error(ut); + } +}; + +TestHarness.prototype.startingTest = function (ut) { + this.currentTest = ut; + this._testResults.push(ut); +}; + +var ES5Harness = new TestHarness(); diff --git a/deps/v8/test/es5conform/testcfg.py b/deps/v8/test/es5conform/testcfg.py new file mode 100644 index 0000000000..d1f23aa312 --- /dev/null +++ b/deps/v8/test/es5conform/testcfg.py @@ -0,0 +1,108 @@ +# Copyright 2008 the V8 project authors. All rights reserved. +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +import test +import os +from os.path import join, exists + + +HARNESS_FILES = ['sth.js'] + + +class ES5ConformTestCase(test.TestCase): + + def __init__(self, filename, path, context, root, mode, framework): + super(ES5ConformTestCase, self).__init__(context, path) + self.filename = filename + self.mode = mode + self.framework = framework + self.root = root + + def IsNegative(self): + return self.filename.endswith('-n.js') + + def GetLabel(self): + return "%s es5conform %s" % (self.mode, self.GetName()) + + def IsFailureOutput(self, output): + if output.exit_code != 0: + return True + return 'FAILED!' in output.stdout + + def GetCommand(self): + result = [self.context.GetVm(self.mode)] + result += ['-e', 'var window = this'] + result += self.framework + result.append(self.filename) + result += ['-e', 'ES5Harness.startTesting()'] + return result + + def GetName(self): + return self.path[-1] + + def GetSource(self): + return open(self.filename).read() + + +class ES5ConformTestConfiguration(test.TestConfiguration): + + def __init__(self, context, root): + super(ES5ConformTestConfiguration, self).__init__(context, root) + + def ListTests(self, current_path, path, mode): + tests = [] + current_root = join(self.root, 'data', 'TestCases') + harness = [] + harness += [join(self.root, 'data', 'SimpleTestHarness', f) for f in HARNESS_FILES] + harness += [join(self.root, 'harness-adapt.js')] + for root, dirs, files in os.walk(current_root): + for dotted in [x for x in dirs if x.startswith('.')]: + dirs.remove(dotted) + root_path = root[len(self.root):].split(os.path.sep) + root_path = current_path + [x for x in root_path if x] + for file in files: + if file.endswith('.js'): + full_path = root_path + [file[:-3]] + full_path = [x for x in full_path if not (x in ['data', 'TestCases'])] + if self.Contains(path, full_path): + test = ES5ConformTestCase(join(root, file), full_path, self.context, + self.root, mode, harness) + tests.append(test) + return tests + + def GetBuildRequirements(self): + return ['sample', 'sample=shell'] + + def GetTestStatus(self, sections, defs): + status_file = join(self.root, 'es5conform.status') + if exists(status_file): + test.ReadConfigurationInto(status_file, sections, defs) + + +def GetConfiguration(context, root): + return ES5ConformTestConfiguration(context, root) diff --git a/deps/v8/test/mjsunit/arguments-enum.js b/deps/v8/test/mjsunit/arguments-enum.js index f76240ff1b..3aee918af1 100644 --- a/deps/v8/test/mjsunit/arguments-enum.js +++ b/deps/v8/test/mjsunit/arguments-enum.js @@ -42,11 +42,11 @@ function setArgumentCount() { } assertEquals(0, countArguments()); -assertEquals(0, countArguments(1)); -assertEquals(0, countArguments(1, 2)); -assertEquals(0, countArguments(1, 2, 3, 4, 5)); +assertEquals(1, countArguments(1)); +assertEquals(2, countArguments(1, 2)); +assertEquals(5, countArguments(1, 2, 3, 4, 5)); -assertEquals(0, setArgumentCount()); -assertEquals(0, setArgumentCount(1)); -assertEquals(0, setArgumentCount(1, 2)); -assertEquals(0, setArgumentCount(1, 2, 3, 4, 5)); +assertEquals(2, setArgumentCount()); +assertEquals(3, setArgumentCount(1)); +assertEquals(4, setArgumentCount(1, 2)); +assertEquals(7, setArgumentCount(1, 2, 3, 4, 5)); diff --git a/deps/v8/test/mjsunit/array-constructor.js b/deps/v8/test/mjsunit/array-constructor.js new file mode 100644 index 0000000000..063ccde583 --- /dev/null +++ b/deps/v8/test/mjsunit/array-constructor.js @@ -0,0 +1,119 @@ +// Copyright 2008 the V8 project authors. All rights reserved. +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +var loop_count = 5 + + +for (var i = 0; i < loop_count; i++) { + var a = new Array(); + var b = Array(); + assertEquals(0, a.length); + assertEquals(0, b.length); + for (var k = 0; k < 10; k++) { + assertEquals('undefined', typeof a[k]); + assertEquals('undefined', typeof b[k]); + } +} + + +for (var i = 0; i < loop_count; i++) { + for (var j = 0; j < 100; j++) { + var a = new Array(j); + var b = Array(j); + assertEquals(j, a.length); + assertEquals(j, b.length); + for (var k = 0; k < j; k++) { + assertEquals('undefined', typeof a[k]); + assertEquals('undefined', typeof b[k]); + } + } +} + + +for (var i = 0; i < loop_count; i++) { + a = new Array(0, 1); + assertArrayEquals([0, 1], a); + a = new Array(0, 1, 2); + assertArrayEquals([0, 1, 2], a); + a = new Array(0, 1, 2, 3); + assertArrayEquals([0, 1, 2, 3], a); + a = new Array(0, 1, 2, 3, 4); + assertArrayEquals([0, 1, 2, 3, 4], a); + a = new Array(0, 1, 2, 3, 4, 5); + assertArrayEquals([0, 1, 2, 3, 4, 5], a); + a = new Array(0, 1, 2, 3, 4, 5, 6); + assertArrayEquals([0, 1, 2, 3, 4, 5, 6], a); + a = new Array(0, 1, 2, 3, 4, 5, 6, 7); + assertArrayEquals([0, 1, 2, 3, 4, 5, 6, 7], a); + a = new Array(0, 1, 2, 3, 4, 5, 6, 7, 8); + assertArrayEquals([0, 1, 2, 3, 4, 5, 6, 7, 8], a); + a = new Array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); + assertArrayEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], a); +} + + +function innerArrayLiteral(n) { + var a = new Array(n); + for (var i = 0; i < n; i++) { + a[i] = i * 2 + 7; + } + return a.join(); +} + + +function testConstructOfSizeSize(n) { + var str = innerArrayLiteral(n); + var a = eval('[' + str + ']'); + var b = eval('new Array(' + str + ')') + var c = eval('Array(' + str + ')') + assertEquals(n, a.length); + assertArrayEquals(a, b); + assertArrayEquals(a, c); +} + + +for (var i = 0; i < loop_count; i++) { + // JSObject::kInitialMaxFastElementArray is 10000. + for (var j = 1000; j < 12000; j += 1000) { + testConstructOfSizeSize(j); + } +} + + +for (var i = 0; i < loop_count; i++) { + assertArrayEquals(['xxx'], new Array('xxx')); + assertArrayEquals(['xxx'], Array('xxx')); + assertArrayEquals([true], new Array(true)); + assertArrayEquals([false], Array(false)); + assertArrayEquals([{a:1}], new Array({a:1})); + assertArrayEquals([{b:2}], Array({b:2})); +} + + +assertThrows('new Array(3.14)'); +assertThrows('Array(2.72)'); diff --git a/deps/v8/test/mjsunit/array-splice-webkit.js b/deps/v8/test/mjsunit/array-splice-webkit.js deleted file mode 100644 index 113a56a6ed..0000000000 --- a/deps/v8/test/mjsunit/array-splice-webkit.js +++ /dev/null @@ -1,60 +0,0 @@ -// Copyright 2008 the V8 project authors. All rights reserved. -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Simple splice tests based on webkit layout tests. -var arr = ['a','b','c','d']; -assertArrayEquals(['a','b','c','d'], arr); -assertArrayEquals(['c','d'], arr.splice(2)); -assertArrayEquals(['a','b'], arr); -assertArrayEquals(['a','b'], arr.splice(0)); -assertArrayEquals([], arr) - -arr = ['a','b','c','d']; -assertEquals(undefined, arr.splice()) -assertArrayEquals(['a','b','c','d'], arr); -assertArrayEquals(['a','b','c','d'], arr.splice(undefined)) -assertArrayEquals([], arr); - -arr = ['a','b','c','d']; -assertArrayEquals(['a','b','c','d'], arr.splice(null)) -assertArrayEquals([], arr); - -arr = ['a','b','c','d']; -assertArrayEquals([], arr.splice(100)) -assertArrayEquals(['a','b','c','d'], arr); -assertArrayEquals(['d'], arr.splice(-1)) -assertArrayEquals(['a','b','c'], arr); - -assertArrayEquals([], arr.splice(2, undefined)) -assertArrayEquals([], arr.splice(2, null)) -assertArrayEquals([], arr.splice(2, -1)) -assertArrayEquals([], arr.splice(2, 0)) -assertArrayEquals(['a','b','c'], arr); -assertArrayEquals(['c'], arr.splice(2, 100)) -assertArrayEquals(['a','b'], arr); - - diff --git a/deps/v8/test/mjsunit/mjsunit.status b/deps/v8/test/mjsunit/mjsunit.status index 13e69ae351..0b069ccbe9 100644 --- a/deps/v8/test/mjsunit/mjsunit.status +++ b/deps/v8/test/mjsunit/mjsunit.status @@ -41,6 +41,7 @@ big-object-literal: PASS, SKIP if ($arch == arm) # Slow tests which times out in debug mode. try: PASS, SKIP if $mode == debug debug-scripts-request: PASS, SKIP if $mode == debug +array-constructor: PASS, SKIP if $mode == debug # Flaky test that can hit compilation-time stack overflow in debug mode. unicode-test: PASS, (PASS || FAIL) if $mode == debug diff --git a/deps/v8/test/mjsunit/regexp-pcre.js b/deps/v8/test/mjsunit/regexp-pcre.js deleted file mode 100644 index dcb1b320fd..0000000000 --- a/deps/v8/test/mjsunit/regexp-pcre.js +++ /dev/null @@ -1,6603 +0,0 @@ -// Autogenerated from the PCRE test suite Mon Feb 2 15:14:04 CET 2009 - -// Note that some regexps in the PCRE test suite use features not present -// in JavaScript. These don't work in JS, but they fail to work in a -// predictable way, and the expected results reflect this. - -// PCRE comes with the following license - -// PCRE LICENCE -// ------------ -// -// PCRE is a library of functions to support regular expressions whose syntax -// and semantics are as close as possible to those of the Perl 5 language. -// -// Release 7 of PCRE is distributed under the terms of the "BSD" licence, as -// specified below. The documentation for PCRE, supplied in the "doc" -// directory, is distributed under the same terms as the software itself. -// -// The basic library functions are written in C and are freestanding. Also -// included in the distribution is a set of C++ wrapper functions. -// -// -// THE BASIC LIBRARY FUNCTIONS -// --------------------------- -// -// Written by: Philip Hazel -// Email local part: ph10 -// Email domain: cam.ac.uk -// -// University of Cambridge Computing Service, -// Cambridge, England. -// -// Copyright (c) 1997-2007 University of Cambridge -// All rights reserved. -// -// -// THE C++ WRAPPER FUNCTIONS -// ------------------------- -// -// Contributed by: Google Inc. -// -// Copyright (c) 2007, Google Inc. -// All rights reserved. -// -// -// THE "BSD" LICENCE -// ----------------- -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// * Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// -// * Redistributions in binary form must reproduce the above copyright -// notice, this list of conditions and the following disclaimer in the -// documentation and/or other materials provided with the distribution. -// -// * Neither the name of the University of Cambridge nor the name of Google -// Inc. nor the names of their contributors may be used to endorse or -// promote products derived from this software without specific prior -// written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE -// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -// POSSIBILITY OF SUCH DAMAGE. -// -// End - -var res = new Array(); -res[0] = /(a)b|/i; -res[1] = /abc/i; -res[2] = /^abc/i; -res[3] = /a+bc/i; -res[4] = /a*bc/i; -res[5] = /a{3}bc/i; -res[6] = /(abc|a+z)/i; -res[7] = /^abc$/i; -res[8] = /ab\idef/; -res[9] = /.*b/i; -res[10] = /.*?b/i; -res[11] = /cat|dog|elephant/i; -res[12] = /cat|dog|elephant/i; -res[13] = /cat|dog|elephant/i; -res[14] = /a|[bcd]/i; -res[15] = /(a|[^\dZ])/i; -res[16] = /(a|b)*[\s]/i; -res[17] = /(ab\2)/; -res[18] = /(a)(b)(c)\2/i; -res[19] = /(a)bc|(a)(b)\2/i; -res[20] = /abc$/i; -res[21] = /(a)(b)(c)(d)(e)\6/; -res[22] = /the quick brown fox/i; -res[23] = /^abc|def/i; -res[24] = /.*((abc)$|(def))/i; -res[25] = /abc/i; -res[26] = /^abc|def/i; -res[27] = /.*((abc)$|(def))/i; -res[28] = /the quick brown fox/i; -res[29] = /the quick brown fox/i; -res[30] = /abc.def/i; -res[31] = /abc$/i; -res[32] = /(abc)\2/i; -res[33] = /(abc\1)/i; -res[34] = /a[]b/; -res[35] = /[^aeiou ]{3,}/i; -res[36] = /<.*>/i; -res[37] = /<.*?>/i; -res[38] = /[abcd]/i; -res[39] = /(^a|^b)/im; -res[40] = /a$/i; -res[41] = /a$/im; -res[42] = /\Aabc/im; -res[43] = /^abc/im; -res[44] = /(?!alphabet)[ab]/i; -res[45] = /The next three are in testinput2 because they have variable length branches/; -res[46] = /This one is here because Perl 5.005_02 doesn't fail it/i; -res[47] = /This one is here because I think Perl 5.005_02 gets the setting of $1 wrong/i; -res[48] = /^(a\1?){4}$/i; -res[49] = /These are syntax tests from Perl 5.005/i; -res[50] = /a[]b/; -res[51] = /\1/; -res[52] = /\2/; -res[53] = /(a)|\2/; -res[54] = /a[]b/i; -res[55] = /abc/; -res[56] = /abc/; -res[57] = /abc/i; -res[58] = /(a)bc(d)/i; -res[59] = /(.{20})/i; -res[60] = /(.{15})/i; -res[61] = /(.{16})/i; -res[62] = /^(a|(bc))de(f)/i; -res[63] = /^abc\00def/i; -res[64] = /word ((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+\n)((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+\n)?)?)?)?)?)?)?)?)?otherword/i; -res[65] = /.*X/i; -res[66] = /.*X/i; -res[67] = /(.*X|^B)/i; -res[68] = /(.*X|^B)/i; -res[69] = /\Biss\B/i; -res[70] = /\Biss\B/i; -res[71] = /iss/ig; -res[72] = /\Biss\B/ig; -res[73] = /\Biss\B/ig; -res[74] = /^iss/ig; -res[75] = /.*iss/ig; -res[76] = /.i./ig; -res[77] = /^.is/ig; -res[78] = /^ab\n/ig; -res[79] = /^ab\n/img; -res[80] = /abc/i; -res[81] = /abc|bac/i; -res[82] = /(abc|bac)/i; -res[83] = /(abc|(c|dc))/i; -res[84] = /(abc|(d|de)c)/i; -res[85] = /a*/i; -res[86] = /a+/i; -res[87] = /(baa|a+)/i; -res[88] = /a{0,3}/i; -res[89] = /baa{3,}/i; -res[90] = /"([^\\"]+|\\.)*"/i; -res[91] = /(abc|ab[cd])/i; -res[92] = /(a|.)/i; -res[93] = /a|ba|\w/i; -res[94] = /abc(?=pqr)/i; -res[95] = /abc(?!pqr)/i; -res[96] = /ab./i; -res[97] = /ab[xyz]/i; -res[98] = /abc*/i; -res[99] = /ab.c*/i; -res[100] = /a.c*/i; -res[101] = /.c*/i; -res[102] = /ac*/i; -res[103] = /(a.c*|b.c*)/i; -res[104] = /a.c*|aba/i; -res[105] = /.+a/i; -res[106] = /(?=abcda)a.*/i; -res[107] = /(?=a)a.*/i; -res[108] = /a(b)*/i; -res[109] = /a\d*/i; -res[110] = /ab\d*/i; -res[111] = /a(\d)*/i; -res[112] = /abcde{0,0}/i; -res[113] = /ab\d+/i; -res[114] = /ab\d{0}e/i; -res[115] = /a?b?/i; -res[116] = /|-/i; -res[117] = /a*(b+)(z)(z)/i; -res[118] = /^.?abcd/i; -res[119] = /^[[:alnum:]]/; -res[120] = /^[[:^alnum:]]/; -res[121] = /^[[:alpha:]]/; -res[122] = /^[[:^alpha:]]/; -res[123] = /[_[:alpha:]]/i; -res[124] = /^[[:ascii:]]/; -res[125] = /^[[:^ascii:]]/; -res[126] = /^[[:blank:]]/; -res[127] = /^[[:^blank:]]/; -res[128] = /[\n\x0b\x0c\x0d[:blank:]]/i; -res[129] = /^[[:cntrl:]]/; -res[130] = /^[[:digit:]]/; -res[131] = /^[[:graph:]]/; -res[132] = /^[[:lower:]]/; -res[133] = /^[[:print:]]/; -res[134] = /^[[:punct:]]/; -res[135] = /^[[:space:]]/; -res[136] = /^[[:upper:]]/; -res[137] = /^[[:xdigit:]]/; -res[138] = /^[[:word:]]/; -res[139] = /^[[:^cntrl:]]/; -res[140] = /^[12[:^digit:]]/; -res[141] = /^[[:^blank:]]/; -res[142] = /[01[:alpha:]%]/; -res[143] = /[[.ch.]]/i; -res[144] = /[[=ch=]]/i; -res[145] = /[[:rhubarb:]]/i; -res[146] = /[[:upper:]]/i; -res[147] = /[[:lower:]]/i; -res[148] = /This one's here because of the large output vector needed/i; -res[149] = /(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\w+)\s+(\270)/i; -res[150] = /This one's here because Perl does this differently and PCRE can't at present/i; -res[151] = /(main(O)?)+/i; -res[152] = /These are all cases where Perl does it differently (nested captures)/i; -res[153] = /^(a(b)?)+$/i; -res[154] = /^(aa(bb)?)+$/i; -res[155] = /^(aa|aa(bb))+$/i; -res[156] = /^(aa(bb)??)+$/i; -res[157] = /^(?:aa(bb)?)+$/i; -res[158] = /^(aa(b(b))?)+$/i; -res[159] = /^(?:aa(b(b))?)+$/i; -res[160] = /^(?:aa(b(?:b))?)+$/i; -res[161] = /^(?:aa(bb(?:b))?)+$/i; -res[162] = /^(?:aa(b(?:bb))?)+$/i; -res[163] = /^(?:aa(?:b(b))?)+$/i; -res[164] = /^(?:aa(?:b(bb))?)+$/i; -res[165] = /^(aa(b(bb))?)+$/i; -res[166] = /^(aa(bb(bb))?)+$/i; -res[167] = /a/i; -res[168] = /[\s]/; -res[169] = /[\S]/; -res[170] = /123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890/; -res[171] = /\Q123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890/; -res[172] = /\Q\E/; -res[173] = /\Q\Ex/; -res[174] = / \Q\E/; -res[175] = /a\Q\E/; -res[176] = /a\Q\Eb/; -res[177] = /\Q\Eabc/; -res[178] = /[.x.]/i; -res[179] = /[=x=]/i; -res[180] = /[:x:]/i; -res[181] = /\l/i; -res[182] = /\L/i; -res[183] = /\N{name}/i; -res[184] = /\u/i; -res[185] = /\U/i; -res[186] = /[[:space:]/i; -res[187] = /[\s]/i; -res[188] = /[[:space:]]/i; -res[189] = /[[:space:]abcde]/i; -res[190] = /(.*)\d+\1/i; -res[191] = /(.*)\d+/i; -res[192] = /(.*)\d+\1/i; -res[193] = /(.*)\d+/i; -res[194] = /(.*(xyz))\d+\2/i; -res[195] = /((.*))\d+\1/i; -res[196] = /a[b]/i; -res[197] = /(?=a).*/i; -res[198] = /(?=abc).xyz/i; -res[199] = /(?=a)(?=b)/i; -res[200] = /(?=.)a/i; -res[201] = /((?=abcda)a)/i; -res[202] = /((?=abcda)ab)/i; -res[203] = /()a/i; -res[204] = /(a)+/i; -res[205] = /(a){2,3}/i; -res[206] = /(a)*/i; -res[207] = /[a]/i; -res[208] = /[ab]/i; -res[209] = /[ab]/i; -res[210] = /[^a]/i; -res[211] = /\d456/i; -res[212] = /\d456/i; -res[213] = /a^b/i; -res[214] = /^a/im; -res[215] = /c|abc/i; -res[216] = /(.*)a/i; -res[217] = /(.*)a\1/i; -res[218] = /(.*)a(b)\2/i; -res[219] = /((.*)a|(.*)b)z/i; -res[220] = /((.*)a|(.*)b)z\1/i; -res[221] = /((.*)a|(.*)b)z\2/i; -res[222] = /((.*)a|(.*)b)z\3/i; -res[223] = /((.*)a|^(.*)b)z\3/i; -res[224] = /(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)a/i; -res[225] = /(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)a\31/i; -res[226] = /(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)a\32/i; -res[227] = /(a)(bc)/i; -res[228] = /(a+)*zz/i; -res[229] = /((w\/|-|with)*(free|immediate)*.*?shipping\s*[!.-]*)/i; -res[230] = /((w\/|-|with)*(free|immediate)*.*?shipping\s*[!.-]*)/i; -res[231] = /a*.*b/i; -res[232] = /(a|b)*.?c/i; -res[233] = /abcde/i; -res[234] = /a*b/i; -res[235] = /a+b/i; -res[236] = /(abc|def)x/i; -res[237] = /(ab|cd){3,4}/i; -res[238] = /([ab]{,4}c|xy)/i; -res[239] = /([ab]{1,4}c|xy){4,5}?123/i; -res[240] = /\b.*/i; -res[241] = /\b.*/i; -res[242] = /(?!.bcd).*/i; -res[243] = /abcde/i; -res[244] = /0{0,2}ABC/i; -res[245] = /\d{3,}ABC/i; -res[246] = /\d*ABC/i; -res[247] = /[abc]+DE/i; -res[248] = /[abc]?123/i; -res[249] = /^(?:\d){3,5}X/i; -res[250] = /^a/i; -res[251] = /line\nbreak/i; -res[252] = /line\nbreak/i; -res[253] = /line\nbreak/im; -res[254] = /ab.cd/i; -res[255] = /ab.cd/i; -res[256] = /a(b)c/i; -res[257] = /Inthisnexttest,Jisnotsetattheouterlevel;consequentlyitisn'tsetinthepattern'soptions;consequentlypcre_get_named_substring()producesarandomvalue./i; -res[258] = /\777/i; -res[259] = /\s*,\s*/i; -res[260] = /^abc/im; -res[261] = /abc$/im; -res[262] = /^abc/im; -res[263] = /^abc/im; -res[264] = /^abc/im; -res[265] = /^abc/im; -res[266] = /abc/i; -res[267] = /.*/i; -res[268] = /\w+(.)(.)?def/i; -res[269] = /()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(.(.))/i; -res[270] = /()[ab]xyz/i; -res[271] = /(|)[ab]xyz/i; -res[272] = /(|c)[ab]xyz/i; -res[273] = /(|c?)[ab]xyz/i; -res[274] = /(d?|c?)[ab]xyz/i; -res[275] = /(d?|c)[ab]xyz/i; -res[276] = /^a*b\d/; -res[277] = /^a*?b\d/; -res[278] = /^a+A\d/; -res[279] = /^a*A\d/i; -res[280] = /(a*|b*)[cd]/i; -res[281] = /(a+|b*)[cd]/i; -res[282] = /(a*|b+)[cd]/i; -res[283] = /(a+|b+)[cd]/i; -res[284] = /(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((a)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))/i; -res[285] = /a*\d/; -res[286] = /a*\D/; -res[287] = /0*\d/; -res[288] = /0*\D/; -res[289] = /a*\s/; -res[290] = /a*\S/; -res[291] = / *\s/; -res[292] = / *\S/; -res[293] = /a*\w/; -res[294] = /a*\W/; -res[295] = /=*\w/; -res[296] = /=*\W/; -res[297] = /\d*a/; -res[298] = /\d*2/; -res[299] = /\d*\d/; -res[300] = /\d*\D/; -res[301] = /\d*\s/; -res[302] = /\d*\S/; -res[303] = /\d*\w/; -res[304] = /\d*\W/; -res[305] = /\D*a/; -res[306] = /\D*2/; -res[307] = /\D*\d/; -res[308] = /\D*\D/; -res[309] = /\D*\s/; -res[310] = /\D*\S/; -res[311] = /\D*\w/; -res[312] = /\D*\W/; -res[313] = /\s*a/; -res[314] = /\s*2/; -res[315] = /\s*\d/; -res[316] = /\s*\D/; -res[317] = /\s*\s/; -res[318] = /\s*\S/; -res[319] = /\s*\w/; -res[320] = /\s*\W/; -res[321] = /\S*a/; -res[322] = /\S*2/; -res[323] = /\S*\d/; -res[324] = /\S*\D/; -res[325] = /\S*\s/; -res[326] = /\S*\S/; -res[327] = /\S*\w/; -res[328] = /\S*\W/; -res[329] = /\w*a/; -res[330] = /\w*2/; -res[331] = /\w*\d/; -res[332] = /\w*\D/; -res[333] = /\w*\s/; -res[334] = /\w*\S/; -res[335] = /\w*\w/; -res[336] = /\w*\W/; -res[337] = /\W*a/; -res[338] = /\W*2/; -res[339] = /\W*\d/; -res[340] = /\W*\D/; -res[341] = /\W*\s/; -res[342] = /\W*\S/; -res[343] = /\W*\w/; -res[344] = /\W*\W/; -res[345] = /[^a]+a/; -res[346] = /[^a]+a/i; -res[347] = /[^a]+A/i; -res[348] = /[^a]+b/; -res[349] = /[^a]+\d/; -res[350] = /a*[^a]/; -res[351] = /^(?:(?:\1|X)(a|b))+/; -res[352] = /^[\E\Qa\E-\Qz\E]+/; -res[353] = /^[a\Q]bc\E]/; -res[354] = /(?=(\w+))\1:/i; -res[355] = /(a|)*\d/; -res[356] = /^a.b/; -res[357] = /^abc./mg; -res[358] = /abc.$/mg; -res[359] = /a/; -res[360] = /a/; -res[361] = /^a\Rb/i; -res[362] = /^a\R*b/i; -res[363] = /^a\R+b/i; -res[364] = /^a\R{1,3}b/i; -res[365] = /^a[\R]b/i; -res[366] = /^(a(b))\1\g1\g{1}\g-1\g{-1}\g{-02}Z/; -res[367] = /^(a)\g-2/; -res[368] = /^(a)\g/; -res[369] = /^(a)\g{0}/; -res[370] = /^(a)\g{3/; -res[371] = /^(a)\g{4a}/; -res[372] = /^a.b/; -res[373] = /.+foo/; -res[374] = /.+foo/; -res[375] = /.+foo/; -res[376] = /.+foo/; -res[377] = /^$/mg; -res[378] = /abc.$/mg; -res[379] = /^X/m; -res[380] = /(foo)\Kbar/; -res[381] = /(foo)(\Kbar|baz)/; -res[382] = /(foo\Kbar)baz/; -res[383] = /\g{A/; -res[384] = /\H\h\V\v/; -res[385] = /\H*\h+\V?\v{3,4}/; -res[386] = /\H{3,4}/; -res[387] = /.\h{3,4}./; -res[388] = /\h*X\h?\H+Y\H?Z/; -res[389] = /\v*X\v?Y\v+Z\V*\x0a\V+\x0b\V{2,3}\x0c/; -res[390] = /[\h]/; -res[391] = /[\h]+/; -res[392] = /[\v]/; -res[393] = /[\H]/; -res[394] = /[^\h]/; -res[395] = /[\V]/; -res[396] = /[\x0a\V]/; -res[397] = /\H+\hY/; -res[398] = /\H+ Y/; -res[399] = /\h+A/; -res[400] = /\v*B/; -res[401] = /\V+\x0a/; -res[402] = /A+\h/; -res[403] = / *\H/; -res[404] = /A*\v/; -res[405] = /\x0b*\V/; -res[406] = /\d+\h/; -res[407] = /\d*\v/; -res[408] = /S+\h\S+\v/; -res[409] = /\w{3,}\h\w+\v/; -res[410] = /\h+\d\h+\w\h+\S\h+\H/; -res[411] = /\v+\d\v+\w\v+\S\v+\V/; -res[412] = /\H+\h\H+\d/; -res[413] = /\V+\v\V+\w/; -res[414] = /[\E]AAA/; -res[415] = /[\Q\E]AAA/; -res[416] = /[^\E]AAA/; -res[417] = /[^\Q\E]AAA/; -res[418] = /[\E^]AAA/; -res[419] = /[\Q\E^]AAA/; -res[420] = /\g6666666666/; -res[421] = /[\g6666666666]/; -res[422] = /.+A/; -res[423] = /\nA/; -res[424] = /[\r\n]A/; -res[425] = /(\r|\n)A/; -res[426] = /a\Rb/i; -res[427] = /a\Rb/i; -res[428] = /a\R?b/i; -res[429] = /a\R?b/i; -res[430] = /a\R{2,4}b/i; -res[431] = /a\R{2,4}b/i; -res[432] = /\k''/; -res[433] = /\k<>/; -res[434] = /\k{}/; -res[435] = /[[:foo:]]/; -res[436] = /[[:1234:]]/; -res[437] = /[[:f\oo:]]/; -res[438] = /[[: :]]/; -res[439] = /[[:...:]]/; -res[440] = /[[:l\ower:]]/; -res[441] = /[[:abc\:]]/; -res[442] = /[abc[:x\]pqr:]]/; -res[443] = /[[:a\dz:]]/; -res[444] = /^(a|b\g<1>c)/; -res[445] = /^(a|b\g'1'c)/; -res[446] = /^(a|b\g'-1'c)/; -res[447] = /(^(a|b\g<-1>c))/; -res[448] = /(^(a|b\g<-1'c))/; -res[449] = /(^(a|b\g{-1}))/; -res[450] = /(\3)(\1)(a)/; -res[451] = /(\3)(\1)(a)/; -res[452] = /TA]/; -res[453] = /TA]/; -res[454] = /a[]b/; -res[455] = /a[^]b/; -res[456] = /a[]b/; -res[457] = /a[]+b/; -res[458] = /a[^]b/; -res[459] = /a[^]+b/; -res[460] = /a(?!)+b/; -res[461] = /(abc|pqr|123){0}[xyz]/i; -res[462] = / End of testinput2 /; -res[463] = /a.b/; -res[464] = /a(.{3})b/; -res[465] = /a(.*?)(.)/; -res[466] = /a(.*?)(.)/; -res[467] = /a(.*)(.)/; -res[468] = /a(.*)(.)/; -res[469] = /a(.)(.)/; -res[470] = /a(.)(.)/; -res[471] = /a(.?)(.)/; -res[472] = /a(.?)(.)/; -res[473] = /a(.??)(.)/; -res[474] = /a(.??)(.)/; -res[475] = /a(.{3})b/; -res[476] = /a(.{3,})b/; -res[477] = /a(.{3,}?)b/; -res[478] = /a(.{3,5})b/; -res[479] = /a(.{3,5}?)b/; -res[480] = /X(\C{3})/; -res[481] = /X(\C{4})/; -res[482] = /X\C*/; -res[483] = /X\C*?/; -res[484] = /X\C{3,5}/; -res[485] = /X\C{3,5}?/; -res[486] = /[^a]+/g; -res[487] = /^[^a]{2}/; -res[488] = /^[^a]{2,}/; -res[489] = /^[^a]{2,}?/; -res[490] = /[^a]+/ig; -res[491] = /^[^a]{2}/i; -res[492] = /^[^a]{2,}/i; -res[493] = /^[^a]{2,}?/i; -res[494] = /\D*/; -res[495] = /\D*/; -res[496] = /\D/; -res[497] = />\S/; -res[498] = /\d/; -res[499] = /\s/; -res[500] = /\D+/; -res[501] = /\D{2,3}/; -res[502] = /\D{2,3}?/; -res[503] = /\d+/; -res[504] = /\d{2,3}/; -res[505] = /\d{2,3}?/; -res[506] = /\S+/; -res[507] = /\S{2,3}/; -res[508] = /\S{2,3}?/; -res[509] = />\s+\s{2,3}\s{2,3}?@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"(?:[^\\\x80-\xff\n\015"]|\\[^\x80-\xff])*")(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*\.(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"(?:[^\\\x80-\xff\n\015"]|\\[^\x80-\xff])*"))*(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*@(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*\.(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\]))*|(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"(?:[^\\\x80-\xff\n\015"]|\\[^\x80-\xff])*")(?:[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\)|"(?:[^\\\x80-\xff\n\015"]|\\[^\x80-\xff])*")*<(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:@(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*\.(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\]))*(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*,(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*@(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*\.(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\]))*)*:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*)?(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"(?:[^\\\x80-\xff\n\015"]|\\[^\x80-\xff])*")(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*\.(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"(?:[^\\\x80-\xff\n\015"]|\\[^\x80-\xff])*"))*(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*@(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*\.(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\]))*(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*>)(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*/; -res[861] = /[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*@[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*|(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037]*(?:(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037]*)*<[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:@[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*(?:,[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*@[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*)*:[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)?(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*@[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*>)/; -res[862] = /abc\x0def\x00pqr\x000xyz\x0000AB/; -res[863] = /^[\000-\037]/; -res[864] = /\0*/; -res[865] = /A\x0{2,3}Z/; -res[866] = /^\s/; -res[867] = /^abc/; -res[868] = /ab{1,3}bc/; -res[869] = /([^.]*)\.([^:]*):[T ]+(.*)/; -res[870] = /([^.]*)\.([^:]*):[T ]+(.*)/i; -res[871] = /([^.]*)\.([^:]*):[t ]+(.*)/i; -res[872] = /^[W-c]+$/; -res[873] = /^[W-c]+$/i; -res[874] = /^[\x3f-\x5F]+$/i; -res[875] = /^abc$/m; -res[876] = /^abc$/; -res[877] = /\Aabc\Z/m; -res[878] = /\A(.)*\Z/; -res[879] = /\A(.)*\Z/m; -res[880] = /(?:b)|(?::+)/; -res[881] = /[-az]+/; -res[882] = /[az-]+/; -res[883] = /[a\-z]+/; -res[884] = /[a-z]+/; -res[885] = /[\d-]+/; -res[886] = /[\d-z]+/; -res[887] = /\x5c/; -res[888] = /\x20Z/; -res[889] = /ab{3cd/; -res[890] = /ab{3,cd/; -res[891] = /ab{3,4a}cd/; -res[892] = /{4,5a}bc/; -res[893] = /^a.b/; -res[894] = /abc$/; -res[895] = /(abc)\123/; -res[896] = /(abc)\223/; -res[897] = /(abc)\323/; -res[898] = /(abc)\100/; -res[899] = /abc\81/; -res[900] = /abc\91/; -res[901] = /(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\12\123/; -res[902] = /ab\idef/; -res[903] = /a{0}bc/; -res[904] = /(a|(bc)){0,0}?xyz/; -res[905] = /abc[\10]de/; -res[906] = /abc[\1]de/; -res[907] = /(abc)[\1]de/; -res[908] = /^([^a])([^\b])([^c]*)([^d]{3,4})/; -res[909] = /[^a]/; -res[910] = /[^a]/i; -res[911] = /[^a]+/; -res[912] = /[^a]+/i; -res[913] = /[^a]+/; -res[914] = /[^k]$/; -res[915] = /[^k]{2,3}$/; -res[916] = /^\d{8,}\@.+[^k]$/; -res[917] = /[^a]/; -res[918] = /[^a]/i; -res[919] = /[^az]/; -res[920] = /[^az]/i; -res[921] = /\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377/; -res[922] = /P[^*]TAIRE[^*]{1,6}?LL/; -res[923] = /P[^*]TAIRE[^*]{1,}?LL/; -res[924] = /(\.\d\d[1-9]?)\d+/; -res[925] = /(\.\d\d((?=0)|\d(?=\d)))/; -res[926] = /\b(foo)\s+(\w+)/i; -res[927] = /foo(.*)bar/; -res[928] = /foo(.*?)bar/; -res[929] = /(.*)(\d*)/; -res[930] = /(.*)(\d+)/; -res[931] = /(.*?)(\d*)/; -res[932] = /(.*?)(\d+)/; -res[933] = /(.*)(\d+)$/; -res[934] = /(.*?)(\d+)$/; -res[935] = /(.*)\b(\d+)$/; -res[936] = /(.*\D)(\d+)$/; -res[937] = /^\D*(?!123)/; -res[938] = /^(\D*)(?=\d)(?!123)/; -res[939] = /^[W-]46]/; -res[940] = /^[W-\]46]/; -res[941] = /\d\d\/\d\d\/\d\d\d\d/; -res[942] = /word (?:[a-zA-Z0-9]+ ){0,10}otherword/; -res[943] = /word (?:[a-zA-Z0-9]+ ){0,300}otherword/; -res[944] = /^(a){0,0}/; -res[945] = /^(a){0,1}/; -res[946] = /^(a){0,2}/; -res[947] = /^(a){0,3}/; -res[948] = /^(a){0,}/; -res[949] = /^(a){1,1}/; -res[950] = /^(a){1,2}/; -res[951] = /^(a){1,3}/; -res[952] = /^(a){1,}/; -res[953] = /.*\.gif/; -res[954] = /.{0,}\.gif/; -res[955] = /.*\.gif/m; -res[956] = /.*\.gif/; -res[957] = /.*\.gif/m; -res[958] = /.*$/; -res[959] = /.*$/m; -res[960] = /.*$/; -res[961] = /.*$/m; -res[962] = /.*$/; -res[963] = /.*$/m; -res[964] = /.*$/; -res[965] = /.*$/m; -res[966] = /(.*X|^B)/; -res[967] = /(.*X|^B)/m; -res[968] = /(.*X|^B)/; -res[969] = /(.*X|^B)/m; -res[970] = /^.*B/; -res[971] = /^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]/; -res[972] = /^\d\d\d\d\d\d\d\d\d\d\d\d/; -res[973] = /^[\d][\d][\d][\d][\d][\d][\d][\d][\d][\d][\d][\d]/; -res[974] = /^[abc]{12}/; -res[975] = /^[a-c]{12}/; -res[976] = /^(a|b|c){12}/; -res[977] = /^[abcdefghijklmnopqrstuvwxy0123456789]/; -res[978] = /abcde{0,0}/; -res[979] = /ab[cd]{0,0}e/; -res[980] = /ab(c){0,0}d/; -res[981] = /a(b*)/; -res[982] = /ab\d{0}e/; -res[983] = /"([^\\"]+|\\.)*"/; -res[984] = /.*?/g; -res[985] = /\b/g; -res[986] = /\b/g; -res[987] = /]{0,})>]{0,})>([\d]{0,}\.)(.*)((
([\w\W\s\d][^<>]{0,})|[\s]{0,}))<\/a><\/TD>]{0,})>([\w\W\s\d][^<>]{0,})<\/TD>]{0,})>([\w\W\s\d][^<>]{0,})<\/TD><\/TR>/i; -res[988] = /a[^a]b/; -res[989] = /a.b/; -res[990] = /a[^a]b/; -res[991] = /a.b/; -res[992] = /^(b+?|a){1,2}?c/; -res[993] = /^(b+|a){1,2}?c/; -res[994] = /(?!\A)x/m; -res[995] = /\x0{ab}/; -res[996] = /(A|B)*?CD/; -res[997] = /(A|B)*CD/; -res[998] = /\Aabc\z/m; -res[999] = /(\d+)(\w)/; -res[1000] = /(a+|b+|c+)*c/; -res[1001] = /(abc|)+/; -res[1002] = /([a]*)*/; -res[1003] = /([ab]*)*/; -res[1004] = /([^a]*)*/; -res[1005] = /([^ab]*)*/; -res[1006] = /([a]*?)*/; -res[1007] = /([ab]*?)*/; -res[1008] = /([^a]*?)*/; -res[1009] = /([^ab]*?)*/; -res[1010] = /The following tests are taken from the Perl 5.005 test suite; some of them/; -res[1011] = /are compatible with 5.004, but I'd rather not have to sort them out./; -res[1012] = /abc/; -res[1013] = /ab*c/; -res[1014] = /ab*bc/; -res[1015] = /.{1}/; -res[1016] = /.{3,4}/; -res[1017] = /ab{0,}bc/; -res[1018] = /ab+bc/; -res[1019] = /ab{1,}bc/; -res[1020] = /ab+bc/; -res[1021] = /ab{1,}bc/; -res[1022] = /ab{1,3}bc/; -res[1023] = /ab{3,4}bc/; -res[1024] = /ab{4,5}bc/; -res[1025] = /ab?bc/; -res[1026] = /ab{0,1}bc/; -res[1027] = /ab?bc/; -res[1028] = /ab?c/; -res[1029] = /ab{0,1}c/; -res[1030] = /^abc$/; -res[1031] = /^abc/; -res[1032] = /^abc$/; -res[1033] = /abc$/; -res[1034] = /^/; -res[1035] = /$/; -res[1036] = /a.c/; -res[1037] = /a.*c/; -res[1038] = /a[bc]d/; -res[1039] = /a[b-d]e/; -res[1040] = /a[b-d]/; -res[1041] = /a[-b]/; -res[1042] = /a[b-]/; -res[1043] = /a]/; -res[1044] = /a[]]b/; -res[1045] = /a[^bc]d/; -res[1046] = /a[^-b]c/; -res[1047] = /a[^]b]c/; -res[1048] = /\ba\b/; -res[1049] = /\by\b/; -res[1050] = /\Ba\B/; -res[1051] = /\By\b/; -res[1052] = /\by\B/; -res[1053] = /\By\B/; -res[1054] = /\w/; -res[1055] = /\W/; -res[1056] = /a\sb/; -res[1057] = /a\Sb/; -res[1058] = /\d/; -res[1059] = /\D/; -res[1060] = /[\w]/; -res[1061] = /[\W]/; -res[1062] = /a[\s]b/; -res[1063] = /a[\S]b/; -res[1064] = /[\d]/; -res[1065] = /[\D]/; -res[1066] = /ab|cd/; -res[1067] = /()ef/; -res[1068] = /$b/; -res[1069] = /a\(b/; -res[1070] = /a\\b/; -res[1071] = /((a))/; -res[1072] = /(a)b(c)/; -res[1073] = /a+b+c/; -res[1074] = /a{1,}b{1,}c/; -res[1075] = /a.+?c/; -res[1076] = /(a+|b)*/; -res[1077] = /(a+|b){0,}/; -res[1078] = /(a+|b)+/; -res[1079] = /(a+|b){1,}/; -res[1080] = /(a+|b)?/; -res[1081] = /(a+|b){0,1}/; -res[1082] = /[^ab]*/; -res[1083] = /abc/; -res[1084] = /a*/; -res[1085] = /([abc])*d/; -res[1086] = /([abc])*bcd/; -res[1087] = /a|b|c|d|e/; -res[1088] = /(a|b|c|d|e)f/; -res[1089] = /abcd*efg/; -res[1090] = /ab*/; -res[1091] = /(ab|cd)e/; -res[1092] = /[abhgefdc]ij/; -res[1093] = /^(ab|cd)e/; -res[1094] = /(abc|)ef/; -res[1095] = /(a|b)c*d/; -res[1096] = /(ab|ab*)bc/; -res[1097] = /a([bc]*)c*/; -res[1098] = /a([bc]*)(c*d)/; -res[1099] = /a([bc]+)(c*d)/; -res[1100] = /a([bc]*)(c+d)/; -res[1101] = /a[bcd]*dcdcde/; -res[1102] = /a[bcd]+dcdcde/; -res[1103] = /(ab|a)b*c/; -res[1104] = /((a)(b)c)(d)/; -res[1105] = /[a-zA-Z_][a-zA-Z0-9_]*/; -res[1106] = /^a(bc+|b[eh])g|.h$/; -res[1107] = /(bc+d$|ef*g.|h?i(j|k))/; -res[1108] = /((((((((((a))))))))))/; -res[1109] = /(((((((((a)))))))))/; -res[1110] = /multiple words of text/; -res[1111] = /multiple words/; -res[1112] = /(.*)c(.*)/; -res[1113] = /\((.*), (.*)\)/; -res[1114] = /[k]/; -res[1115] = /abcd/; -res[1116] = /a(bc)d/; -res[1117] = /a[-]?c/; -res[1118] = /abc/i; -res[1119] = /ab*c/i; -res[1120] = /ab*bc/i; -res[1121] = /ab*?bc/i; -res[1122] = /ab{0,}?bc/i; -res[1123] = /ab+?bc/i; -res[1124] = /ab+bc/i; -res[1125] = /ab{1,}bc/i; -res[1126] = /ab+bc/i; -res[1127] = /ab{1,}?bc/i; -res[1128] = /ab{1,3}?bc/i; -res[1129] = /ab{3,4}?bc/i; -res[1130] = /ab{4,5}?bc/i; -res[1131] = /ab??bc/i; -res[1132] = /ab{0,1}?bc/i; -res[1133] = /ab??bc/i; -res[1134] = /ab??c/i; -res[1135] = /ab{0,1}?c/i; -res[1136] = /^abc$/i; -res[1137] = /^abc/i; -res[1138] = /^abc$/i; -res[1139] = /abc$/i; -res[1140] = /^/i; -res[1141] = /$/i; -res[1142] = /a.c/i; -res[1143] = /a.*?c/i; -res[1144] = /a.*c/i; -res[1145] = /a[bc]d/i; -res[1146] = /a[b-d]e/i; -res[1147] = /a[b-d]/i; -res[1148] = /a[-b]/i; -res[1149] = /a[b-]/i; -res[1150] = /a]/i; -res[1151] = /a[]]b/i; -res[1152] = /a[^bc]d/i; -res[1153] = /a[^-b]c/i; -res[1154] = /a[^]b]c/i; -res[1155] = /ab|cd/i; -res[1156] = /()ef/i; -res[1157] = /$b/i; -res[1158] = /a\(b/i; -res[1159] = /a\\b/i; -res[1160] = /((a))/i; -res[1161] = /(a)b(c)/i; -res[1162] = /a+b+c/i; -res[1163] = /a{1,}b{1,}c/i; -res[1164] = /a.+?c/i; -res[1165] = /a.*?c/i; -res[1166] = /a.{0,5}?c/i; -res[1167] = /(a+|b)*/i; -res[1168] = /(a+|b){0,}/i; -res[1169] = /(a+|b)+/i; -res[1170] = /(a+|b){1,}/i; -res[1171] = /(a+|b)?/i; -res[1172] = /(a+|b){0,1}/i; -res[1173] = /(a+|b){0,1}?/i; -res[1174] = /[^ab]*/i; -res[1175] = /abc/i; -res[1176] = /a*/i; -res[1177] = /([abc])*d/i; -res[1178] = /([abc])*bcd/i; -res[1179] = /a|b|c|d|e/i; -res[1180] = /(a|b|c|d|e)f/i; -res[1181] = /abcd*efg/i; -res[1182] = /ab*/i; -res[1183] = /(ab|cd)e/i; -res[1184] = /[abhgefdc]ij/i; -res[1185] = /^(ab|cd)e/i; -res[1186] = /(abc|)ef/i; -res[1187] = /(a|b)c*d/i; -res[1188] = /(ab|ab*)bc/i; -res[1189] = /a([bc]*)c*/i; -res[1190] = /a([bc]*)(c*d)/i; -res[1191] = /a([bc]+)(c*d)/i; -res[1192] = /a([bc]*)(c+d)/i; -res[1193] = /a[bcd]*dcdcde/i; -res[1194] = /a[bcd]+dcdcde/i; -res[1195] = /(ab|a)b*c/i; -res[1196] = /((a)(b)c)(d)/i; -res[1197] = /[a-zA-Z_][a-zA-Z0-9_]*/i; -res[1198] = /^a(bc+|b[eh])g|.h$/i; -res[1199] = /(bc+d$|ef*g.|h?i(j|k))/i; -res[1200] = /((((((((((a))))))))))/i; -res[1201] = /(((((((((a)))))))))/i; -res[1202] = /(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))/i; -res[1203] = /(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))/i; -res[1204] = /multiple words of text/i; -res[1205] = /multiple words/i; -res[1206] = /(.*)c(.*)/i; -res[1207] = /\((.*), (.*)\)/i; -res[1208] = /[k]/i; -res[1209] = /abcd/i; -res[1210] = /a(bc)d/i; -res[1211] = /a[-]?c/i; -res[1212] = /a(?!b)./; -res[1213] = /a(?=d)./; -res[1214] = /a(?=c|d)./; -res[1215] = /a(?:b|c|d)(.)/; -res[1216] = /a(?:b|c|d)*(.)/; -res[1217] = /a(?:b|c|d)+?(.)/; -res[1218] = /a(?:b|c|d)+(.)/; -res[1219] = /a(?:b|c|d){2}(.)/; -res[1220] = /a(?:b|c|d){4,5}(.)/; -res[1221] = /a(?:b|c|d){4,5}?(.)/; -res[1222] = /((foo)|(bar))*/; -res[1223] = /a(?:b|c|d){6,7}(.)/; -res[1224] = /a(?:b|c|d){6,7}?(.)/; -res[1225] = /a(?:b|c|d){5,6}(.)/; -res[1226] = /a(?:b|c|d){5,6}?(.)/; -res[1227] = /a(?:b|c|d){5,7}(.)/; -res[1228] = /a(?:b|c|d){5,7}?(.)/; -res[1229] = /a(?:b|(c|e){1,2}?|d)+?(.)/; -res[1230] = /^(.+)?B/; -res[1231] = /^([^a-z])|(\^)$/; -res[1232] = /^[<>]&/; -res[1233] = /(?:(f)(o)(o)|(b)(a)(r))*/; -res[1234] = /(?:..)*a/; -res[1235] = /(?:..)*?a/; -res[1236] = /^(){3,5}/; -res[1237] = /^(a+)*ax/; -res[1238] = /^((a|b)+)*ax/; -res[1239] = /^((a|bc)+)*ax/; -res[1240] = /(a|x)*ab/; -res[1241] = /(a)*ab/; -res[1242] = /(?:c|d)(?:)(?:a(?:)(?:b)(?:b(?:))(?:b(?:)(?:b)))/; -res[1243] = /(?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))/; -res[1244] = /foo\w*\d{4}baz/; -res[1245] = /x(~~)*(?:(?:F)?)?/; -res[1246] = /^a{3}c/; -res[1247] = /^a{3}c/; -res[1248] = /^(?:a?b?)*$/; -res[1249] = /^b/; -res[1250] = /()^b/; -res[1251] = /(\w+:)+/; -res[1252] = /([\w:]+::)?(\w+)$/; -res[1253] = /^[^bcd]*(c+)/; -res[1254] = /(a*)b+/; -res[1255] = /([\w:]+::)?(\w+)$/; -res[1256] = /^[^bcd]*(c+)/; -res[1257] = /(>a+)ab/; -res[1258] = /([[:]+)/; -res[1259] = /([[=]+)/; -res[1260] = /([[.]+)/; -res[1261] = /a\Z/; -res[1262] = /b\Z/; -res[1263] = /b\z/; -res[1264] = /b\Z/; -res[1265] = /b\z/; -res[1266] = /((Z)+|A)*/; -res[1267] = /(Z()|A)*/; -res[1268] = /(Z(())|A)*/; -res[1269] = /a*/g; -res[1270] = /^[\d-a]/; -res[1271] = /[[:space:]]+/; -res[1272] = /[[:blank:]]+/; -res[1273] = /[\s]+/; -res[1274] = /\s+/; -res[1275] = /a b/; -res[1276] = /(?!\A)x/m; -res[1277] = /(?!^)x/m; -res[1278] = /abc\Qabc\Eabc/; -res[1279] = /abc\Qabc\Eabc/; -res[1280] = /abc\Qliteral\E/; -res[1281] = /abc\Qliteral/; -res[1282] = /abc\Qliteral\E/; -res[1283] = /abc\Qliteral\E/; -res[1284] = /\Qabc\$xyz\E/; -res[1285] = /\Qabc\E\$\Qxyz\E/; -res[1286] = /\Gabc/; -res[1287] = /\Gabc./g; -res[1288] = /abc./g; -res[1289] = /[z\Qa-d]\E]/; -res[1290] = /[\z\C]/; -res[1291] = /\M/; -res[1292] = /(a+)*b/; -res[1293] = /line\nbreak/; -res[1294] = /line\nbreak/; -res[1295] = /line\nbreak/m; -res[1296] = /1234/; -res[1297] = /1234/; -res[1298] = /^/mg; -res[1299] = /Content-Type\x3A[^\r\n]{6,}/; -res[1300] = /Content-Type\x3A[^\r\n]{6,}z/; -res[1301] = /Content-Type\x3A[^a]{6,}/; -res[1302] = /Content-Type\x3A[^a]{6,}z/; -res[1303] = /^abc/m; -res[1304] = /abc$/m; -res[1305] = /^abc/m; -res[1306] = /^abc/m; -res[1307] = /^abc/m; -res[1308] = /.*/; -res[1309] = /\w+(.)(.)?def/; -res[1310] = /^\w+=.*(\\\n.*)*/; -res[1311] = /^(a()*)*/; -res[1312] = /^(?:a(?:(?:))*)*/; -res[1313] = /^(a()+)+/; -res[1314] = /^(?:a(?:(?:))+)+/; -res[1315] = /(a|)*\d/; -res[1316] = /(?:a|)*\d/; -res[1317] = /^a.b/; -res[1318] = /^abc./mg; -res[1319] = /abc.$/mg; -res[1320] = /^a\Rb/i; -res[1321] = /^a\R*b/i; -res[1322] = /^a\R+b/i; -res[1323] = /^a\R{1,3}b/i; -res[1324] = /^a[\R]b/i; -res[1325] = /.+foo/; -res[1326] = /.+foo/; -res[1327] = /.+foo/; -res[1328] = /.+foo/; -res[1329] = /^$/mg; -res[1330] = /^X/m; -res[1331] = /\H\h\V\v/; -res[1332] = /\H*\h+\V?\v{3,4}/; -res[1333] = /\H{3,4}/; -res[1334] = /.\h{3,4}./; -res[1335] = /\h*X\h?\H+Y\H?Z/; -res[1336] = /\v*X\v?Y\v+Z\V*\x0a\V+\x0b\V{2,3}\x0c/; -res[1337] = /.+A/; -res[1338] = /\nA/; -res[1339] = /[\r\n]A/; -res[1340] = /(\r|\n)A/; -res[1341] = /a\Rb/i; -res[1342] = /a\Rb/i; -res[1343] = /a\R?b/i; -res[1344] = /a\R?b/i; -res[1345] = /a\R{2,4}b/i; -res[1346] = /a\R{2,4}b/i; -res[1347] = /a(?!)|\wbc/; -res[1348] = /a[]b/; -res[1349] = /a[]+b/; -res[1350] = /a[^]b/; -res[1351] = /a[^]+b/; -res[1352] = / End of testinput7 /; -res[1353] = /\bX/; -res[1354] = /\BX/; -res[1355] = /X\b/; -res[1356] = /X\B/; -res[1357] = /[^a]/; -res[1358] = /abc/; -res[1359] = /a.b/; -res[1360] = /a(.{3})b/; -res[1361] = /a(.*?)(.)/; -res[1362] = /a(.*?)(.)/; -res[1363] = /a(.*)(.)/; -res[1364] = /a(.*)(.)/; -res[1365] = /a(.)(.)/; -res[1366] = /a(.)(.)/; -res[1367] = /a(.?)(.)/; -res[1368] = /a(.?)(.)/; -res[1369] = /a(.??)(.)/; -res[1370] = /a(.??)(.)/; -res[1371] = /a(.{3})b/; -res[1372] = /a(.{3,})b/; -res[1373] = /a(.{3,}?)b/; -res[1374] = /a(.{3,5})b/; -res[1375] = /a(.{3,5}?)b/; -res[1376] = /[^a]+/g; -res[1377] = /^[^a]{2}/; -res[1378] = /^[^a]{2,}/; -res[1379] = /^[^a]{2,}?/; -res[1380] = /[^a]+/ig; -res[1381] = /^[^a]{2}/i; -res[1382] = /^[^a]{2,}/i; -res[1383] = /^[^a]{2,}?/i; -res[1384] = /\D*/; -res[1385] = /\D*/; -res[1386] = /\D/; -res[1387] = />\S/; -res[1388] = /\d/; -res[1389] = /\s/; -res[1390] = /\D+/; -res[1391] = /\D{2,3}/; -res[1392] = /\D{2,3}?/; -res[1393] = /\d+/; -res[1394] = /\d{2,3}/; -res[1395] = /\d{2,3}?/; -res[1396] = /\S+/; -res[1397] = /\S{2,3}/; -res[1398] = /\S{2,3}?/; -res[1399] = />\s+\s{2,3}\s{2,3}?ghi", res[36].exec("abcghinop"), 71); -assertEquals("", res[37].exec("abcghinop"), 72); -assertEquals("", res[37].exec("abcghinop"), 73); -assertEquals(null, res[37].exec("abc========def", 74)); -assertEquals(null, res[37].exec("foo", 75)); -assertEquals(null, res[37].exec("catfoo", 76)); -assertEquals(null, res[37].exec("*** Failers", 77)); -assertEquals(null, res[37].exec("the barfoo", 78)); -assertEquals(null, res[37].exec("and cattlefoo", 79)); -assertEquals("a", res[40].exec("a"), 80); -assertEquals(null, res[40].exec("a\n", 81)); -assertEquals(null, res[40].exec("*** Failers", 82)); -assertEquals("a", res[40].exec("Za"), 83); -assertEquals(null, res[40].exec("Za\n", 84)); -assertEquals("a", res[41].exec("a"), 85); -assertEquals("a", res[41].exec("a\n"), 86); -assertEquals("a", res[41].exec("Za\n"), 87); -assertEquals(null, res[41].exec("*** Failers", 88)); -assertEquals("a", res[41].exec("Za"), 89); -assertEquals("b", res[44].exec("foo\nbarbar"), 90); -assertEquals("a", res[44].exec("***Failers"), 91); -assertEquals("b", res[44].exec("rhubarb"), 92); -assertEquals("b", res[44].exec("barbell"), 93); -assertEquals("a", res[44].exec("abc\nbarton"), 94); -assertEquals("b", res[44].exec("foo\nbarbar"), 95); -assertEquals("a", res[44].exec("***Failers"), 96); -assertEquals("b", res[44].exec("rhubarb"), 97); -assertEquals("b", res[44].exec("barbell"), 98); -assertEquals("a", res[44].exec("abc\nbarton"), 99); -assertEquals("a", res[44].exec("abc"), 100); -assertEquals("a", res[44].exec("def\nabc"), 101); -assertEquals("a", res[44].exec("*** Failers"), 102); -assertEquals("a", res[44].exec("defabc"), 103); -assertEquals(null, res[45].exec("the bullock-cart", 104)); -assertEquals(null, res[45].exec("a donkey-cart race", 105)); -assertEquals(null, res[45].exec("*** Failers", 106)); -assertEquals(null, res[45].exec("cart", 107)); -assertEquals(null, res[45].exec("horse-and-cart", 108)); -assertEquals(null, res[45].exec("alphabetabcd", 109)); -assertEquals(null, res[45].exec("endingxyz", 110)); -assertEquals(null, res[45].exec("abxyZZ", 111)); -assertEquals(null, res[45].exec("abXyZZ", 112)); -assertEquals(null, res[45].exec("ZZZ", 113)); -assertEquals(null, res[45].exec("zZZ", 114)); -assertEquals(null, res[45].exec("bZZ", 115)); -assertEquals(null, res[45].exec("BZZ", 116)); -assertEquals(null, res[45].exec("*** Failers", 117)); -assertEquals(null, res[45].exec("ZZ", 118)); -assertEquals(null, res[45].exec("abXYZZ", 119)); -assertEquals(null, res[45].exec("zzz", 120)); -assertEquals(null, res[45].exec("bzz", 121)); -assertEquals(null, res[45].exec("bar", 122)); -assertEquals(null, res[45].exec("foobbar", 123)); -assertEquals(null, res[45].exec("*** Failers", 124)); -assertEquals(null, res[45].exec("fooabar", 125)); -assertEquals(null, res[46].exec("*** Failers", 126)); -assertEquals(null, res[46].exec("a", 127)); -assertEquals(null, res[48].exec("aaaaaa", 128)); -assertThrows("var re = /a[b-a]/;", 129); -assertThrows("var re = /a[/;", 130); -assertThrows("var re = /*a/;", 131); -assertThrows("var re = /abc)/;", 132); -assertThrows("var re = /(abc/;", 133); -assertThrows("var re = /a**/;", 134); -assertThrows("var re = /)(/;", 135); -assertThrows("var re = /a[b-a]/;", 136); -assertThrows("var re = /a[/;", 137); -assertThrows("var re = /*a/;", 138); -assertThrows("var re = /abc)/;", 139); -assertThrows("var re = /(abc/;", 140); -assertThrows("var re = /a**/;", 141); -assertThrows("var re = /)(/;", 142); -assertThrows("var re = /:(?:/;", 143); -assertThrows("var re = /a(?{)b/;", 144); -assertThrows("var re = /a(?{{})b/;", 145); -assertThrows("var re = /a(?{}})b/;", 146); -assertThrows("var re = /a(?{\"{\"})b/;", 147); -assertThrows("var re = /a(?{\"{\"}})b/;", 148); -assertThrows("var re = /[a[:xyz:/;", 149); -assertThrows("var re = /a{37,17}/;", 150); -assertEquals("abcd,a,d", res[58].exec("abcd"), 151); -assertEquals("abcd,a,d", res[58].exec("abcdC2"), 152); -assertEquals("abcd,a,d", res[58].exec("abcdC5"), 153); -assertEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyz"), 154); -assertEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyzC1"), 155); -assertEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyzG1"), 156); -assertEquals("abcdefghijklmno,abcdefghijklmno", res[60].exec("abcdefghijklmnopqrstuvwxyz"), 157); -assertEquals("abcdefghijklmno,abcdefghijklmno", res[60].exec("abcdefghijklmnopqrstuvwxyzC1G1"), 158); -assertEquals("abcdefghijklmnop,abcdefghijklmnop", res[61].exec("abcdefghijklmnopqrstuvwxyz"), 159); -assertEquals("abcdefghijklmnop,abcdefghijklmnop", res[61].exec("abcdefghijklmnopqrstuvwxyzC1G1L"), 160); -assertEquals("adef,a,,f", res[62].exec("adefG1G2G3G4L"), 161); -assertEquals("bcdef,bc,bc,f", res[62].exec("bcdefG1G2G3G4L"), 162); -assertEquals("adef,a,,f", res[62].exec("adefghijkC0"), 163); -assertEquals("abc\x00def", res[63].exec("abc\x00defLC0"), 164); -assertEquals("iss", res[69].exec("Mississippi"), 165); -assertEquals("iss", res[70].exec("Mississippi"), 166); -assertEquals("iss", res[71].exec("Mississippi"), 167); -assertEquals("iss", res[72].exec("Mississippi"), 168); -assertEquals("iss", res[73].exec("Mississippi"), 169); -assertEquals(null, res[73].exec("*** Failers", 170)); -assertEquals("iss", res[73].exec("MississippiA"), 171); -assertEquals("iss", res[73].exec("Mississippi"), 172); -assertEquals(null, res[73].exec("Mississippi", 173)); -assertEquals("iss", res[74].exec("ississippi"), 174); -assertEquals("abciss", res[75].exec("abciss\nxyzisspqr"), 175); -assertEquals("Mis", res[76].exec("Mississippi"), 176); -assertEquals("sis", res[76].exec("MississippiA"), 177); -assertEquals("ri ", res[76].exec("Missouri river"), 178); -assertEquals("riv", res[76].exec("Missouri riverA"), 179); -assertEquals("Mis", res[77].exec("Mississippi"), 180); -assertEquals("ab\n", res[78].exec("ab\nab\ncd"), 181); -assertEquals("ab\n", res[79].exec("ab\nab\ncd"), 182); -assertEquals("a", res[115].exec("a"), 183); -assertEquals("b", res[115].exec("b"), 184); -assertEquals("ab", res[115].exec("ab"), 185); -assertEquals("", res[115].exec("\\"), 186); -assertEquals("", res[115].exec("*** Failers"), 187); -assertEquals("", res[115].exec("N"), 188); -assertEquals("", res[116].exec("abcd"), 189); -assertEquals("", res[116].exec("-abc"), 190); -assertEquals("", res[116].exec("Nab-c"), 191); -assertEquals("", res[116].exec("*** Failers"), 192); -assertEquals("", res[116].exec("Nabc"), 193); -assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzz"), 194); -assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO0"), 195); -assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO1"), 196); -assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO2"), 197); -assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO3"), 198); -assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO4"), 199); -assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO5"), 200); -assertEquals("(abcd", res[118].exec("(abcd)"), 201); -assertEquals("(abcd", res[118].exec("(abcd)xyz"), 202); -assertEquals(null, res[118].exec("xyz(abcd)", 203)); -assertEquals(null, res[118].exec("(ab(xy)cd)pqr", 204)); -assertEquals(null, res[118].exec("(ab(xycd)pqr", 205)); -assertEquals(null, res[118].exec("() abc ()", 206)); -assertEquals(null, res[118].exec("12(abcde(fsh)xyz(foo(bar))lmno)89", 207)); -assertEquals(null, res[118].exec("*** Failers", 208)); -assertEquals("abcd", res[118].exec("abcd"), 209); -assertEquals("abcd", res[118].exec("abcd)"), 210); -assertEquals("(abcd", res[118].exec("(abcd"), 211); -assertEquals(null, res[118].exec("(ab(xy)cd)pqr", 212)); -assertEquals(null, res[118].exec("1(abcd)(x(y)z)pqr", 213)); -assertEquals("(abcd", res[118].exec("(abcd)"), 214); -assertEquals(null, res[118].exec("(ab(xy)cd)", 215)); -assertEquals(null, res[118].exec("(a(b(c)d)e)", 216)); -assertEquals(null, res[118].exec("((ab))", 217)); -assertEquals(null, res[118].exec("*** Failers", 218)); -assertEquals(null, res[118].exec("()", 219)); -assertEquals(null, res[118].exec("()", 220)); -assertEquals(null, res[118].exec("12(abcde(fsh)xyz(foo(bar))lmno)89", 221)); -assertEquals(null, res[118].exec("(ab(xy)cd)", 222)); -assertEquals(null, res[118].exec("(ab(xy)cd)", 223)); -assertEquals(null, res[118].exec("(ab(xy)cd)", 224)); -assertEquals(null, res[118].exec("(123ab(xy)cd)", 225)); -assertEquals(null, res[118].exec("(ab(xy)cd)", 226)); -assertEquals(null, res[118].exec("(123ab(xy)cd)", 227)); -assertEquals(null, res[118].exec("(ab(xy)cd)", 228)); -assertEquals("(abcd", res[118].exec("(abcd(xyz

qrs)123)"), 229); -assertEquals(null, res[118].exec("(ab(cd)ef)", 230)); -assertEquals(null, res[118].exec("(ab(cd(ef)gh)ij)", 231)); -assertEquals(null, res[146].exec("A", 232)); -assertEquals(null, res[146].exec("a", 233)); -assertEquals(null, res[147].exec("A", 234)); -assertEquals(null, res[147].exec("a", 235)); -assertEquals(null, res[147].exec("ab", 236)); -assertEquals(null, res[147].exec("aB", 237)); -assertEquals(null, res[147].exec("*** Failers", 238)); -assertEquals(null, res[147].exec("Ab", 239)); -assertEquals(null, res[147].exec("AB", 240)); -assertThrows("var re = /[\\200-\\110]/;", 241); -assertEquals("1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 ABC ABC,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12 ,13 ,14 ,15 ,16 ,17 ,18 ,19 ,20 ,21 ,22 ,23 ,24 ,25 ,26 ,27 ,28 ,29 ,30 ,31 ,32 ,33 ,34 ,35 ,36 ,37 ,38 ,39 ,40 ,41 ,42 ,43 ,44 ,45 ,46 ,47 ,48 ,49 ,50 ,51 ,52 ,53 ,54 ,55 ,56 ,57 ,58 ,59 ,60 ,61 ,62 ,63 ,64 ,65 ,66 ,67 ,68 ,69 ,70 ,71 ,72 ,73 ,74 ,75 ,76 ,77 ,78 ,79 ,80 ,81 ,82 ,83 ,84 ,85 ,86 ,87 ,88 ,89 ,90 ,91 ,92 ,93 ,94 ,95 ,96 ,97 ,98 ,99 ,100 ,101 ,102 ,103 ,104 ,105 ,106 ,107 ,108 ,109 ,110 ,111 ,112 ,113 ,114 ,115 ,116 ,117 ,118 ,119 ,120 ,121 ,122 ,123 ,124 ,125 ,126 ,127 ,128 ,129 ,130 ,131 ,132 ,133 ,134 ,135 ,136 ,137 ,138 ,139 ,140 ,141 ,142 ,143 ,144 ,145 ,146 ,147 ,148 ,149 ,150 ,151 ,152 ,153 ,154 ,155 ,156 ,157 ,158 ,159 ,160 ,161 ,162 ,163 ,164 ,165 ,166 ,167 ,168 ,169 ,170 ,171 ,172 ,173 ,174 ,175 ,176 ,177 ,178 ,179 ,180 ,181 ,182 ,183 ,184 ,185 ,186 ,187 ,188 ,189 ,190 ,191 ,192 ,193 ,194 ,195 ,196 ,197 ,198 ,199 ,200 ,201 ,202 ,203 ,204 ,205 ,206 ,207 ,208 ,209 ,210 ,211 ,212 ,213 ,214 ,215 ,216 ,217 ,218 ,219 ,220 ,221 ,222 ,223 ,224 ,225 ,226 ,227 ,228 ,229 ,230 ,231 ,232 ,233 ,234 ,235 ,236 ,237 ,238 ,239 ,240 ,241 ,242 ,243 ,244 ,245 ,246 ,247 ,248 ,249 ,250 ,251 ,252 ,253 ,254 ,255 ,256 ,257 ,258 ,259 ,260 ,261 ,262 ,263 ,264 ,265 ,266 ,267 ,268 ,269 ,ABC,ABC", res[149].exec("O900 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 ABC ABC"), 242); -assertEquals("mainmain,main,", res[151].exec("mainmain"), 243); -assertEquals("mainOmain,main,", res[151].exec("mainOmain"), 244); -assertEquals("aba,a,", res[153].exec("aba"), 245); -assertEquals("aabbaa,aa,", res[154].exec("aabbaa"), 246); -assertEquals("aabbaa,aa,", res[155].exec("aabbaa"), 247); -assertEquals("aabbaa,aa,", res[156].exec("aabbaa"), 248); -assertEquals("aabbaa,", res[157].exec("aabbaa"), 249); -assertEquals("aabbaa,aa,,", res[158].exec("aabbaa"), 250); -assertEquals("aabbaa,,", res[159].exec("aabbaa"), 251); -assertEquals("aabbaa,", res[160].exec("aabbaa"), 252); -assertEquals("aabbbaa,", res[161].exec("aabbbaa"), 253); -assertEquals("aabbbaa,", res[162].exec("aabbbaa"), 254); -assertEquals("aabbaa,", res[163].exec("aabbaa"), 255); -assertEquals("aabbbaa,", res[164].exec("aabbbaa"), 256); -assertEquals("aabbbaa,aa,,", res[165].exec("aabbbaa"), 257); -assertEquals("aabbbbaa,aa,,", res[166].exec("aabbbbaa"), 258); -assertThrows("var re = //;", 259); -assertEquals("a", res[169].exec("ab"), 260); -assertEquals("a", res[169].exec("aB"), 261); -assertEquals("*", res[169].exec("*** Failers"), 262); -assertEquals("A", res[169].exec("AB"), 263); -assertEquals("a", res[169].exec("ab"), 264); -assertEquals("a", res[169].exec("aB"), 265); -assertEquals("*", res[169].exec("*** Failers"), 266); -assertEquals("A", res[169].exec("AB"), 267); -assertEquals(null, res[172].exec("\\", 268)); -assertEquals(null, res[177].exec("*** Failers", 269)); -assertEquals(null, res[177].exec("xxxxx", 270)); -assertEquals(null, res[177].exec("now is the time for all good men to come to the aid of the party", 271)); -assertEquals(null, res[177].exec("*** Failers", 272)); -assertEquals(null, res[177].exec("this is not a line with only words and spaces!", 273)); -assertEquals(null, res[177].exec("12345a", 274)); -assertEquals(null, res[177].exec("*** Failers", 275)); -assertEquals(null, res[177].exec("12345+", 276)); -assertEquals(null, res[177].exec("aaab", 277)); -assertEquals(null, res[177].exec("aaab", 278)); -assertEquals(null, res[177].exec("aaab", 279)); -assertEquals(null, res[177].exec("((abc(ade)ufh()()x", 280)); -assertEquals(null, res[177].exec("(abc)", 281)); -assertEquals(null, res[177].exec("(abc(def)xyz)", 282)); -assertEquals(null, res[177].exec("*** Failers", 283)); -assertEquals(null, res[177].exec("((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 284)); -assertEquals(null, res[177].exec("xaaaab", 285)); -assertEquals(null, res[177].exec("xaaaab", 286)); -assertThrows("var re = /[/;", 287); -assertThrows("var re = /[a-/;", 288); -assertEquals(null, res[189].exec("<>", 289)); -assertEquals(null, res[189].exec("", 290)); -assertEquals(null, res[189].exec(" hij>", 291)); -assertEquals(null, res[189].exec(" hij>", 292)); -assertEquals(null, res[189].exec("def>", 293)); -assertEquals(null, res[189].exec("", 294)); -assertEquals(null, res[189].exec("*** Failers", 295)); -assertEquals(null, res[189].exec("", 355)); -assertEquals("abc", res[215].exec(""), 356); -assertEquals("abc", res[215].exec(" hij>"), 357); -assertEquals("abc", res[215].exec(" hij>"), 358); -assertEquals("abc", res[215].exec("def>"), 359); -assertEquals("abc", res[215].exec(""), 360); -assertEquals(null, res[215].exec("*** Failers", 361)); -assertEquals("abc", res[215].exec("\n\n\nPartner der LCO\nde\nPartner der LINEAS Consulting\nGmbH\nLINEAS Consulting GmbH Hamburg\nPartnerfirmen\n30 days\nindex,follow\n\nja\n3\nPartner\n\n\nLCO\nLINEAS Consulting\n15.10.2003\n\n\n\n\nDie Partnerfirmen der LINEAS Consulting\nGmbH\n\n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", 448)); -assertEquals("line\nbreak", res[251].exec("this is a line\nbreak"), 449); -assertEquals("line\nbreak", res[251].exec("line one\nthis is a line\nbreak in the second line"), 450); -assertEquals("line\nbreak", res[252].exec("this is a line\nbreak"), 451); -assertEquals(null, res[252].exec("** Failers", 452)); -assertEquals("line\nbreak", res[252].exec("line one\nthis is a line\nbreak in the second line"), 453); -assertEquals("line\nbreak", res[253].exec("this is a line\nbreak"), 454); -assertEquals(null, res[253].exec("** Failers", 455)); -assertEquals("line\nbreak", res[253].exec("line one\nthis is a line\nbreak in the second line"), 456); -assertEquals("ab-cd", res[254].exec("ab-cd"), 457); -assertEquals("ab=cd", res[254].exec("ab=cd"), 458); -assertEquals(null, res[254].exec("** Failers", 459)); -assertEquals(null, res[254].exec("ab\ncd", 460)); -assertEquals("ab-cd", res[255].exec("ab-cd"), 461); -assertEquals("ab=cd", res[255].exec("ab=cd"), 462); -assertEquals(null, res[255].exec("ab\ncd", 463)); -assertEquals(null, res[255].exec("AbCd", 464)); -assertEquals(null, res[255].exec("** Failers", 465)); -assertEquals(null, res[255].exec("abcd", 466)); -// We are compatible with JSC, and don't throw an exception in this case. -// assertThrows("var re = /(){2,4294967295}/;", 467); -assertEquals(null, res[255].exec("abcdefghijklAkB", 468)); -assertEquals(null, res[255].exec("abcdefghijklAkB", 469)); -assertEquals(null, res[255].exec("abcdefghijklAkB", 470)); -assertEquals(null, res[255].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 471)); -assertEquals(null, res[255].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 472)); -assertEquals(null, res[255].exec("(this(and)that", 473)); -assertEquals(null, res[255].exec("(this(and)that)", 474)); -assertEquals(null, res[255].exec("(this(and)that)stuff", 475)); -assertEquals(null, res[255].exec("(this(and)that", 476)); -assertEquals(null, res[255].exec("(this(and)that)", 477)); -assertEquals(null, res[255].exec("(this(and)that", 478)); -assertEquals(null, res[255].exec("(this(and)that)", 479)); -assertEquals(null, res[255].exec("(this(and)that", 480)); -assertEquals(null, res[255].exec("(this(and)that)", 481)); -assertEquals(null, res[255].exec("((this))", 482)); -assertEquals(null, res[255].exec("(this(and)that", 483)); -assertEquals(null, res[255].exec("(this(and)that)", 484)); -assertEquals(null, res[255].exec("(this)", 485)); -assertEquals(null, res[255].exec("((this))", 486)); -assertEquals("abc,b", res[256].exec("abc"), 487); -assertEquals("abc,b", res[256].exec("abc"), 488); -assertEquals(null, res[256].exec("a1bCA", 489)); -assertEquals(null, res[256].exec("a2bCA", 490)); -assertEquals(null, res[257].exec("a bc dCACBCC", 491)); -assertEquals(null, res[257].exec("aabc", 492)); -assertEquals(null, res[257].exec("bc", 493)); -assertEquals(null, res[257].exec("** Failers", 494)); -assertEquals(null, res[257].exec("abc", 495)); -assertEquals(null, res[257].exec("bXaX", 496)); -assertEquals(null, res[257].exec("bbXaaX", 497)); -assertEquals(null, res[257].exec("(b)\\Xa\\X", 498)); -assertEquals(null, res[257].exec("bXXaYYaY", 499)); -assertEquals(null, res[257].exec("bXYaXXaX", 500)); -assertEquals(null, res[257].exec("bXXaYYaY", 501)); -assertEquals("\x0b,\x0b", res[259].exec("\x0b,\x0b"), 502); -assertEquals("\x0c,\x0d", res[259].exec("\x0c,\x0d"), 503); -assertEquals("abc", res[260].exec("xyz\nabc"), 504); -assertEquals("abc", res[260].exec("xyz\nabc"), 505); -assertEquals("abc", res[260].exec("xyz\x0d\nabc"), 506); -assertEquals("abc", res[260].exec("xyz\x0dabc"), 507); -assertEquals("abc", res[260].exec("xyz\x0d\nabc"), 508); -assertEquals(null, res[260].exec("** Failers", 509)); -assertEquals("abc", res[260].exec("xyz\nabc"), 510); -assertEquals("abc", res[260].exec("xyz\x0d\nabc"), 511); -assertEquals("abc", res[260].exec("xyz\nabc"), 512); -assertEquals("abc", res[260].exec("xyz\x0dabc"), 513); -assertEquals("abc", res[260].exec("xyz\x0dabc"), 514); -assertEquals("abc", res[261].exec("xyzabc"), 515); -assertEquals("abc", res[261].exec("xyzabc\n"), 516); -assertEquals("abc", res[261].exec("xyzabc\npqr"), 517); -assertEquals("abc", res[261].exec("xyzabc\x0d"), 518); -assertEquals("abc", res[261].exec("xyzabc\x0dpqr"), 519); -assertEquals("abc", res[261].exec("xyzabc\x0d\n"), 520); -assertEquals("abc", res[261].exec("xyzabc\x0d\npqr"), 521); -assertEquals(null, res[261].exec("** Failers", 522)); -assertEquals("abc", res[261].exec("xyzabc\x0d"), 523); -assertEquals("abc", res[261].exec("xyzabc\x0dpqr"), 524); -assertEquals("abc", res[261].exec("xyzabc\x0d\n"), 525); -assertEquals("abc", res[261].exec("xyzabc\x0d\npqr"), 526); -assertEquals("abc", res[262].exec("xyz\x0dabcdef"), 527); -assertEquals("abc", res[262].exec("xyz\nabcdef"), 528); -assertEquals(null, res[262].exec("** Failers", 529)); -assertEquals("abc", res[262].exec("xyz\nabcdef"), 530); -assertEquals("abc", res[263].exec("xyz\nabcdef"), 531); -assertEquals("abc", res[263].exec("xyz\x0dabcdef"), 532); -assertEquals(null, res[263].exec("** Failers", 533)); -assertEquals("abc", res[263].exec("xyz\x0dabcdef"), 534); -assertEquals("abc", res[264].exec("xyz\x0d\nabcdef"), 535); -assertEquals("abc", res[264].exec("xyz\x0dabcdef"), 536); -assertEquals(null, res[264].exec("** Failers", 537)); -assertEquals("abc", res[264].exec("xyz\x0dabcdef"), 538); -assertEquals("abc", res[266].exec("xyz\x0dabc"), 539); -assertEquals("abc", res[266].exec("abc"), 540); -assertEquals("abc", res[267].exec("abc\ndef"), 541); -assertEquals("abc", res[267].exec("abc\x0ddef"), 542); -assertEquals("abc", res[267].exec("abc\x0d\ndef"), 543); -assertEquals("abc", res[267].exec("abc\ndef"), 544); -assertEquals("abc", res[267].exec("abc\x0ddef"), 545); -assertEquals("abc", res[267].exec("abc\x0d\ndef"), 546); -assertEquals("abc", res[267].exec("abc\ndef"), 547); -assertEquals("abc", res[267].exec("abc\x0ddef"), 548); -assertEquals("abc", res[267].exec("abc\x0d\ndef"), 549); -assertEquals(null, res[268].exec("abc\ndef", 550)); -assertEquals(null, res[268].exec("abc\x0ddef", 551)); -assertEquals(null, res[268].exec("abc\x0d\ndef", 552)); -assertEquals("XY,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,XY,Y", res[269].exec("XYO400"), 553); -assertEquals("aaaA5", res[278].exec("aaaA5"), 554); -assertEquals(null, res[278].exec("** Failers", 555)); -assertEquals(null, res[278].exec("aaaa5", 556)); -assertEquals("aaaA5", res[279].exec("aaaA5"), 557); -assertEquals("aaaa5", res[279].exec("aaaa5"), 558); -assertEquals("x", res[350].exec("xyCabcCxyz"), 559); -assertEquals("x", res[350].exec("xyCabcCxyz"), 560); -assertEquals("b", res[350].exec("bXaX"), 561); -assertEquals("b", res[350].exec("bXbX"), 562); -assertEquals("*", res[350].exec("** Failers"), 563); -assertEquals("aX", res[350].exec("aXaX"), 564); -assertEquals("aX", res[350].exec("aXbX"), 565); -assertEquals("x", res[350].exec("xx"), 566); -assertEquals("x", res[350].exec("xy"), 567); -assertEquals("y", res[350].exec("yy"), 568); -assertEquals("y", res[350].exec("yx"), 569); -assertEquals("x", res[350].exec("xx"), 570); -assertEquals("x", res[350].exec("xy"), 571); -assertEquals("y", res[350].exec("yy"), 572); -assertEquals("y", res[350].exec("yx"), 573); -assertEquals("b", res[350].exec("bxay"), 574); -assertEquals("b", res[350].exec("bxby"), 575); -assertEquals("*", res[350].exec("** Failers"), 576); -assertEquals("ax", res[350].exec("axby"), 577); -assertEquals("X", res[350].exec("XxXxxx"), 578); -assertEquals("X", res[350].exec("XxXyyx"), 579); -assertEquals("X", res[350].exec("XxXyxx"), 580); -assertEquals("*", res[350].exec("** Failers"), 581); -assertEquals("x", res[350].exec("x"), 582); -assertEquals("ab", res[350].exec("abcabc"), 583); -assertEquals("Xaaa,a", res[351].exec("Xaaa"), 584); -assertEquals("Xaba,a", res[351].exec("Xaba"), 585); -assertThrows("var re = /^[a-\\Q\\E]/;", 586); -assertEquals(null, res[353].exec("(xy)x", 587)); -assertEquals(null, res[353].exec("1221", 588)); -assertEquals(null, res[353].exec("Satan, oscillate my metallic sonatas!", 589)); -assertEquals(null, res[353].exec("A man, a plan, a canal: Panama!", 590)); -assertEquals(null, res[353].exec("Able was I ere I saw Elba.", 591)); -assertEquals(null, res[353].exec("*** Failers", 592)); -assertEquals(null, res[353].exec("The quick brown fox", 593)); -assertEquals("abcd:,abcd", res[354].exec("abcd:"), 594); -assertEquals("abcd:,abcd", res[354].exec("abcd:"), 595); -assertEquals("a:,a", res[354].exec("a:aaxyz"), 596); -assertEquals("ab:,ab", res[354].exec("ab:ababxyz"), 597); -assertEquals(null, res[354].exec("** Failers", 598)); -assertEquals("a:,a", res[354].exec("a:axyz"), 599); -assertEquals("ab:,ab", res[354].exec("ab:abxyz"), 600); -assertEquals(null, res[354].exec("abd", 601)); -assertEquals(null, res[354].exec("ce", 602)); -assertEquals(null, res[354].exec("abcabc1Xabc2XabcXabcabc", 603)); -assertEquals(null, res[354].exec("abcabc1Xabc2XabcXabcabc", 604)); -assertEquals(null, res[354].exec("abcabc1Xabc2XabcXabcabc", 605)); -assertEquals(null, res[354].exec("abcd", 606)); -assertEquals(null, res[354].exec("metcalfe 33", 607)); -assertEquals(null, res[356].exec("a\x0db", 608)); -assertEquals(null, res[356].exec("a\nb", 609)); -assertEquals("a\x85b", res[356].exec("a\x85b "), 610); -assertEquals(null, res[356].exec("** Failers", 611)); -assertEquals(null, res[356].exec("a\nb", 612)); -assertEquals(null, res[356].exec("a\nb", 613)); -assertEquals(null, res[356].exec("a\x0db", 614)); -assertEquals(null, res[356].exec("a\x0db", 615)); -assertEquals("a\x85b", res[356].exec("a\x85b "), 616); -assertEquals(null, res[356].exec("a\x0db", 617)); -assertEquals("abc1", res[357].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 \x85abc7 JUNK"), 618); -assertEquals("abc1", res[358].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc7 abc9"), 619); -assertEquals(null, res[361].exec("a\nb", 620)); -assertEquals(null, res[361].exec("a\x0db", 621)); -assertEquals(null, res[361].exec("a\x0d\nb", 622)); -assertEquals(null, res[361].exec("a\x0bb", 623)); -assertEquals(null, res[361].exec("a\x0cb", 624)); -assertEquals(null, res[361].exec("a\x85b", 625)); -assertEquals(null, res[361].exec("** Failers", 626)); -assertEquals(null, res[361].exec("a\n\x0db", 627)); -assertEquals("ab", res[362].exec("ab"), 628); -assertEquals(null, res[362].exec("a\nb", 629)); -assertEquals(null, res[362].exec("a\x0db", 630)); -assertEquals(null, res[362].exec("a\x0d\nb", 631)); -assertEquals(null, res[362].exec("a\x0bb", 632)); -assertEquals(null, res[362].exec("a\x0cb", 633)); -assertEquals(null, res[362].exec("a\x85b", 634)); -assertEquals(null, res[362].exec("a\n\x0db", 635)); -assertEquals(null, res[362].exec("a\n\x0d\x85\x0cb", 636)); -assertEquals(null, res[363].exec("a\nb", 637)); -assertEquals(null, res[363].exec("a\x0db", 638)); -assertEquals(null, res[363].exec("a\x0d\nb", 639)); -assertEquals(null, res[363].exec("a\x0bb", 640)); -assertEquals(null, res[363].exec("a\x0cb", 641)); -assertEquals(null, res[363].exec("a\x85b", 642)); -assertEquals(null, res[363].exec("a\n\x0db", 643)); -assertEquals(null, res[363].exec("a\n\x0d\x85\x0cb", 644)); -assertEquals(null, res[363].exec("** Failers", 645)); -assertEquals(null, res[363].exec("ab", 646)); -assertEquals(null, res[364].exec("a\nb", 647)); -assertEquals(null, res[364].exec("a\n\x0db", 648)); -assertEquals(null, res[364].exec("a\n\x0d\x85b", 649)); -assertEquals(null, res[364].exec("a\x0d\n\x0d\nb", 650)); -assertEquals(null, res[364].exec("a\x0d\n\x0d\n\x0d\nb", 651)); -assertEquals(null, res[364].exec("a\n\x0d\n\x0db", 652)); -assertEquals(null, res[364].exec("a\n\n\x0d\nb", 653)); -assertEquals(null, res[364].exec("** Failers", 654)); -assertEquals(null, res[364].exec("a\n\n\n\x0db", 655)); -assertEquals(null, res[364].exec("a\x0d", 656)); -assertEquals("aRb", res[365].exec("aRb"), 657); -assertEquals(null, res[365].exec("** Failers", 658)); -assertEquals(null, res[365].exec("a\nb", 659)); -assertEquals(null, res[365].exec("abcPXP123", 660)); -assertEquals(null, res[365].exec("abcPXP123", 661)); -assertEquals(null, res[365].exec("1.2.3.4", 662)); -assertEquals(null, res[365].exec("131.111.10.206", 663)); -assertEquals(null, res[365].exec("10.0.0.0", 664)); -assertEquals(null, res[365].exec("** Failers", 665)); -assertEquals(null, res[365].exec("10.6", 666)); -assertEquals(null, res[365].exec("455.3.4.5", 667)); -assertEquals(null, res[365].exec("1.2.3.4", 668)); -assertEquals(null, res[365].exec("131.111.10.206", 669)); -assertEquals(null, res[365].exec("10.0.0.0", 670)); -assertEquals(null, res[365].exec("** Failers", 671)); -assertEquals(null, res[365].exec("10.6", 672)); -assertEquals(null, res[365].exec("455.3.4.5", 673)); -assertEquals(null, res[365].exec("123axbaxbaxbx456", 674)); -assertEquals(null, res[365].exec("123axbaxbaxb456", 675)); -assertEquals(null, res[365].exec("123axbaxbaxbx456", 676)); -assertEquals(null, res[365].exec("123axbaxbaxbx456", 677)); -assertEquals(null, res[365].exec("123axbaxbaxbx456", 678)); -assertEquals(null, res[366].exec("ababababbbabZXXXX", 679)); -assertEquals(null, res[372].exec("a\x0db", 680)); -assertEquals(null, res[372].exec("*** Failers", 681)); -assertEquals(null, res[372].exec("a\nb", 682)); -assertEquals("afoo", res[373].exec("afoo"), 683); -assertEquals(null, res[373].exec("** Failers", 684)); -assertEquals(null, res[373].exec("\x0d\nfoo", 685)); -assertEquals(null, res[373].exec("\nfoo", 686)); -assertEquals("afoo", res[374].exec("afoo"), 687); -assertEquals(null, res[374].exec("\nfoo", 688)); -assertEquals(null, res[374].exec("** Failers", 689)); -assertEquals(null, res[374].exec("\x0d\nfoo", 690)); -assertEquals("afoo", res[375].exec("afoo"), 691); -assertEquals(null, res[375].exec("** Failers", 692)); -assertEquals(null, res[375].exec("\nfoo", 693)); -assertEquals(null, res[375].exec("\x0d\nfoo", 694)); -assertEquals("afoo", res[376].exec("afoo"), 695); -assertEquals(null, res[376].exec("\x0d\nfoo", 696)); -assertEquals(null, res[376].exec("\nfoo", 697)); -assertEquals("", res[377].exec("abc\x0d\x0dxyz"), 698); -assertEquals("", res[377].exec("abc\n\x0dxyz "), 699); -assertEquals(null, res[377].exec("** Failers ", 700)); -assertEquals("", res[377].exec("abc\x0d\nxyz"), 701); -assertEquals("", res[377].exec("abc\x0d\n\x0d\n"), 702); -assertEquals("", res[377].exec("abc\x0d\n\x0d\n"), 703); -assertEquals("", res[377].exec("abc\x0d\n\x0d\n"), 704); -assertEquals("abc1", res[378].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc9"), 705); -assertEquals("X", res[379].exec("XABC"), 706); -assertEquals(null, res[379].exec("** Failers ", 707)); -assertEquals("X", res[379].exec("XABCB"), 708); -assertThrows("var re = /(ab|c)(?-1)/;", 709); -assertEquals(null, res[379].exec("abc", 710)); -assertEquals(null, res[379].exec("xyabcabc", 711)); -assertEquals(null, res[379].exec("** Failers", 712)); -assertEquals(null, res[379].exec("xyabc ", 713)); -assertThrows("var re = /x(?-0)y/;", 714); -assertThrows("var re = /x(?-1)y/;", 715); -assertEquals(null, res[379].exec("abcX", 716)); -assertEquals(null, res[379].exec("Y", 717)); -assertEquals(null, res[379].exec("** Failers", 718)); -assertEquals(null, res[379].exec("abcY ", 719)); -assertEquals(null, res[379].exec("YabcXabc", 720)); -assertEquals(null, res[379].exec("YabcXabcXabc", 721)); -assertEquals(null, res[379].exec("** Failers", 722)); -assertEquals("X", res[379].exec("XabcXabc "), 723); -assertEquals(null, res[379].exec("Y!", 724)); -assertEquals(null, res[380].exec("foobar", 725)); -assertEquals(null, res[381].exec("foobar", 726)); -assertEquals("foobaz,foo,baz", res[381].exec("foobaz "), 727); -assertEquals(null, res[382].exec("foobarbaz", 728)); -assertEquals(null, res[382].exec("tom-tom", 729)); -assertEquals(null, res[382].exec("bon-bon ", 730)); -assertEquals(null, res[382].exec("** Failers", 731)); -assertEquals(null, res[382].exec("tom-bon ", 732)); -assertEquals(null, res[382].exec("tom-tom", 733)); -assertEquals(null, res[382].exec("bon-bon ", 734)); -assertThrows("var re = /(?|(abc)|(xyz))/;", 735); -assertThrows("var re = /(x)(?|(abc)|(xyz))(x)/;", 736); -assertEquals(null, res[383].exec("xabcx", 737)); -assertEquals(null, res[383].exec("xxyzx ", 738)); -assertThrows("var re = /(x)(?|(abc)(pqr)|(xyz))(x)/;", 739); -assertEquals(null, res[383].exec("xabcpqrx", 740)); -assertEquals(null, res[383].exec("xxyzx ", 741)); -assertThrows("var re = /(?|(abc)|(xyz))\\1/;", 742); -assertEquals(null, res[383].exec("abcabc", 743)); -assertEquals(null, res[383].exec("xyzxyz ", 744)); -assertEquals(null, res[383].exec("** Failers", 745)); -assertEquals(null, res[383].exec("abcxyz", 746)); -assertEquals(null, res[383].exec("xyzabc ", 747)); -assertEquals(null, res[383].exec("abcabc", 748)); -assertEquals(null, res[383].exec("xyzabc ", 749)); -assertEquals(null, res[383].exec("** Failers ", 750)); -assertEquals(null, res[383].exec("xyzxyz ", 751)); -assertEquals(null, res[384].exec("X X\n", 752)); -assertEquals(null, res[384].exec("X\x09X\x0b", 753)); -assertEquals(null, res[384].exec("** Failers", 754)); -assertEquals(null, res[384].exec("\xa0 X\n ", 755)); -assertEquals(null, res[385].exec("\x09 \xa0X\n\x0b\x0c\x0d\n", 756)); -assertEquals(null, res[385].exec("\x09 \xa0\n\x0b\x0c\x0d\n", 757)); -assertEquals(null, res[385].exec("\x09 \xa0\n\x0b\x0c", 758)); -assertEquals(null, res[385].exec("** Failers ", 759)); -assertEquals(null, res[385].exec("\x09 \xa0\n\x0b", 760)); -assertEquals(null, res[385].exec(" ", 761)); -assertEquals(null, res[386].exec("XY ABCDE", 762)); -assertEquals(null, res[386].exec("XY PQR ST ", 763)); -assertEquals(null, res[387].exec("XY AB PQRS", 764)); -assertEquals(null, res[388].exec(">XNNNYZ", 765)); -assertEquals(null, res[388].exec("> X NYQZ", 766)); -assertEquals(null, res[388].exec("** Failers", 767)); -assertEquals(null, res[388].exec(">XYZ ", 768)); -assertEquals(null, res[388].exec("> X NY Z", 769)); -assertEquals(null, res[389].exec(">XY\nZ\nA\x0bNN\x0c", 770)); -assertEquals(null, res[389].exec(">\n\x0dX\nY\n\x0bZZZ\nAAA\x0bNNN\x0c", 771)); -assertEquals(null, res[390].exec(">\x09<", 772)); -assertEquals(null, res[391].exec(">\x09 \xa0<", 773)); -assertEquals(null, res[396].exec("** Failers", 774)); -assertEquals(null, res[396].exec("XXXX", 775)); -assertEquals(null, res[397].exec("XXXX Y ", 776)); -assertEquals(null, res[419].exec("aaaaaa", 777)); -assertEquals(null, res[419].exec("aaabccc", 778)); -assertEquals(null, res[419].exec("aaabccc", 779)); -assertEquals(null, res[419].exec("aaabccc", 780)); -assertEquals(null, res[419].exec("aaabcccaaabccc", 781)); -assertEquals(null, res[419].exec("aaaxxxxxx", 782)); -assertEquals(null, res[419].exec("aaa++++++ ", 783)); -assertEquals(null, res[419].exec("bbbxxxxx", 784)); -assertEquals(null, res[419].exec("bbb+++++ ", 785)); -assertEquals(null, res[419].exec("cccxxxx", 786)); -assertEquals(null, res[419].exec("ccc++++ ", 787)); -assertEquals(null, res[419].exec("dddddddd ", 788)); -assertEquals(null, res[419].exec("aaaxxxxxx", 789)); -assertEquals(null, res[419].exec("aaa++++++ ", 790)); -assertEquals(null, res[419].exec("bbbxxxxx", 791)); -assertEquals(null, res[419].exec("bbb+++++ ", 792)); -assertEquals(null, res[419].exec("cccxxxx", 793)); -assertEquals(null, res[419].exec("ccc++++ ", 794)); -assertEquals(null, res[419].exec("dddddddd ", 795)); -assertEquals(null, res[419].exec("aaabccc", 796)); -assertEquals(null, res[419].exec("ABX", 797)); -assertEquals(null, res[419].exec("AADE", 798)); -assertEquals(null, res[419].exec("ACDE", 799)); -assertEquals(null, res[419].exec("** Failers", 800)); -assertEquals(null, res[419].exec("AD ", 801)); -assertEquals(null, res[419].exec(" ", 802)); -assertEquals(null, res[419].exec("aaaaaa", 803)); -assertEquals(null, res[419].exec("aaabccc", 804)); -assertEquals(null, res[419].exec("aaabccc", 805)); -assertEquals(null, res[419].exec("aaabccc", 806)); -assertEquals(null, res[419].exec("aaabcccaaabccc", 807)); -assertEquals(null, res[419].exec("aaabccc", 808)); -assertEquals(null, res[422].exec("\x0d\nA", 809)); -assertEquals("\nA", res[423].exec("\x0d\nA "), 810); -assertEquals("\nA", res[424].exec("\x0d\nA "), 811); -assertEquals("\nA,\n", res[425].exec("\x0d\nA "), 812); -assertEquals(null, res[425].exec("a\nb", 813)); -assertEquals(null, res[425].exec("** Failers", 814)); -assertEquals(null, res[425].exec("a\x0db ", 815)); -assertEquals(null, res[425].exec("a\nb", 816)); -assertEquals(null, res[425].exec("** Failers", 817)); -assertEquals(null, res[425].exec("a\x0db ", 818)); -assertEquals(null, res[425].exec("a\x0db", 819)); -assertEquals(null, res[425].exec("** Failers", 820)); -assertEquals(null, res[425].exec("a\nb ", 821)); -assertEquals(null, res[425].exec("a\x0db", 822)); -assertEquals(null, res[425].exec("a\nb ", 823)); -assertEquals(null, res[425].exec("** Failers", 824)); -assertEquals(null, res[425].exec("a\x0d\nb ", 825)); -assertEquals(null, res[425].exec("** Failers", 826)); -assertEquals(null, res[425].exec("a\x0db", 827)); -assertEquals(null, res[425].exec("a\nb ", 828)); -assertEquals(null, res[425].exec("a\x0d\nb ", 829)); -assertEquals(null, res[425].exec("** Failers", 830)); -assertEquals(null, res[425].exec("a\x0db", 831)); -assertEquals(null, res[425].exec("a\nb ", 832)); -assertEquals(null, res[425].exec("a\x0d\nb ", 833)); -assertEquals(null, res[425].exec("a\x85b ", 834)); -assertEquals(null, res[426].exec("a\x0db", 835)); -assertEquals(null, res[426].exec("a\nb", 836)); -assertEquals(null, res[426].exec("a\x0d\nb", 837)); -assertEquals(null, res[426].exec("** Failers", 838)); -assertEquals(null, res[426].exec("a\x85b", 839)); -assertEquals(null, res[426].exec("a\x0bb ", 840)); -assertEquals(null, res[427].exec("a\x0db", 841)); -assertEquals(null, res[427].exec("a\nb", 842)); -assertEquals(null, res[427].exec("a\x0d\nb", 843)); -assertEquals(null, res[427].exec("a\x85b", 844)); -assertEquals(null, res[427].exec("a\x0bb ", 845)); -assertEquals(null, res[427].exec("** Failers ", 846)); -assertEquals(null, res[427].exec("a\x85b", 847)); -assertEquals(null, res[427].exec("a\x0bb", 848)); -assertEquals(null, res[428].exec("a\x0db", 849)); -assertEquals(null, res[428].exec("a\nb", 850)); -assertEquals(null, res[428].exec("a\x0d\nb", 851)); -assertEquals(null, res[428].exec("** Failers", 852)); -assertEquals(null, res[428].exec("a\x85b", 853)); -assertEquals(null, res[428].exec("a\x0bb ", 854)); -assertEquals(null, res[429].exec("a\x0db", 855)); -assertEquals(null, res[429].exec("a\nb", 856)); -assertEquals(null, res[429].exec("a\x0d\nb", 857)); -assertEquals(null, res[429].exec("a\x85b", 858)); -assertEquals(null, res[429].exec("a\x0bb ", 859)); -assertEquals(null, res[429].exec("** Failers ", 860)); -assertEquals(null, res[429].exec("a\x85b", 861)); -assertEquals(null, res[429].exec("a\x0bb", 862)); -assertEquals(null, res[430].exec("a\x0d\n\nb", 863)); -assertEquals(null, res[430].exec("a\n\x0d\x0db", 864)); -assertEquals(null, res[430].exec("a\x0d\n\x0d\n\x0d\n\x0d\nb", 865)); -assertEquals(null, res[430].exec("** Failers", 866)); -assertEquals(null, res[430].exec("a\x8585b", 867)); -assertEquals(null, res[430].exec("a\x0b\x00bb ", 868)); -assertEquals(null, res[431].exec("a\x0d\x0db", 869)); -assertEquals(null, res[431].exec("a\n\n\nb", 870)); -assertEquals(null, res[431].exec("a\x0d\n\n\x0d\x0db", 871)); -assertEquals(null, res[431].exec("a\x8585b", 872)); -assertEquals(null, res[431].exec("a\x0b\x00bb ", 873)); -assertEquals(null, res[431].exec("** Failers ", 874)); -assertEquals(null, res[431].exec("a\x0d\x0d\x0d\x0d\x0db ", 875)); -assertEquals(null, res[431].exec("a\x8585b", 876)); -assertEquals(null, res[431].exec("a\x0b\x00bb", 877)); -assertEquals(null, res[431].exec("a\nb", 878)); -assertEquals(null, res[431].exec("a\x0db ", 879)); -assertEquals(null, res[431].exec("a\x85b", 880)); -assertEquals(null, res[431].exec("a\nb", 881)); -assertEquals(null, res[431].exec("a\x0db ", 882)); -assertEquals(null, res[431].exec("a\x85b", 883)); -assertThrows("var re = /(?-+a)/;", 884); -assertEquals(null, res[443].exec("aaaa", 885)); -assertEquals(null, res[443].exec("bacxxx", 886)); -assertEquals(null, res[443].exec("bbaccxxx ", 887)); -assertEquals(null, res[443].exec("bbbacccxx", 888)); -assertEquals(null, res[443].exec("aaaa", 889)); -assertEquals(null, res[443].exec("bacxxx", 890)); -assertEquals(null, res[443].exec("bbaccxxx ", 891)); -assertEquals(null, res[443].exec("bbbacccxx", 892)); -assertEquals("a,a", res[444].exec("aaaa"), 893); -assertEquals(null, res[444].exec("bacxxx", 894)); -assertEquals(null, res[444].exec("bbaccxxx ", 895)); -assertEquals(null, res[444].exec("bbbacccxx", 896)); -assertEquals("a,a", res[445].exec("aaaa"), 897); -assertEquals(null, res[445].exec("bacxxx", 898)); -assertEquals(null, res[445].exec("bbaccxxx ", 899)); -assertEquals(null, res[445].exec("bbbacccxx", 900)); -assertEquals("a,a", res[446].exec("aaaa"), 901); -assertEquals(null, res[446].exec("bacxxx", 902)); -assertEquals(null, res[446].exec("bbaccxxx ", 903)); -assertEquals(null, res[446].exec("bbbacccxx", 904)); -assertEquals("a,a,a", res[447].exec("aaaa"), 905); -assertEquals(null, res[447].exec("bacxxx", 906)); -assertEquals(null, res[447].exec("bbaccxxx ", 907)); -assertEquals(null, res[447].exec("bbbacccxx", 908)); -assertEquals(null, res[449].exec("bacxxx", 909)); -assertEquals(null, res[449].exec("XaaX", 910)); -assertEquals(null, res[449].exec("XAAX ", 911)); -assertEquals(null, res[449].exec("XaaX", 912)); -assertEquals(null, res[449].exec("** Failers ", 913)); -assertEquals(null, res[449].exec("XAAX ", 914)); -assertEquals(null, res[449].exec("XaaX", 915)); -assertEquals(null, res[449].exec("XAAX ", 916)); -assertEquals(null, res[449].exec("xzxx", 917)); -assertEquals(null, res[449].exec("yzyy ", 918)); -assertEquals(null, res[449].exec("** Failers", 919)); -assertEquals(null, res[449].exec("xxz ", 920)); -assertEquals("a,,,a", res[450].exec("cat"), 921); -assertEquals("a,,,a", res[451].exec("cat"), 922); -assertEquals("TA]", res[452].exec("The ACTA] comes "), 923); -assertEquals("TA]", res[453].exec("The ACTA] comes "), 924); -assertEquals(null, res[453].exec("abcbabc", 925)); -assertEquals(null, res[453].exec("abcbabc", 926)); -assertEquals(null, res[453].exec("abcbabc", 927)); -assertEquals(null, res[453].exec("** Failers ", 928)); -assertEquals(null, res[453].exec("abcXabc", 929)); -assertEquals(null, res[453].exec("abcXabc", 930)); -assertEquals(null, res[453].exec("** Failers ", 931)); -assertEquals(null, res[453].exec("abcbabc", 932)); -assertEquals(null, res[453].exec("xyzbabcxyz", 933)); -assertEquals(null, res[456].exec("** Failers", 934)); -assertEquals(null, res[456].exec("ab", 935)); -assertEquals(null, res[457].exec("** Failers", 936)); -assertEquals(null, res[457].exec("ab ", 937)); -assertEquals(null, res[457].exec("** Failers", 938)); -assertEquals(null, res[457].exec("ab ", 939)); -assertEquals("aXb", res[458].exec("aXb"), 940); -assertEquals("a\nb", res[458].exec("a\nb "), 941); -assertEquals(null, res[458].exec("** Failers", 942)); -assertEquals(null, res[458].exec("ab ", 943)); -assertEquals("aXb", res[459].exec("aXb"), 944); -assertEquals("a\nX\nXb", res[459].exec("a\nX\nXb "), 945); -assertEquals(null, res[459].exec("** Failers", 946)); -assertEquals(null, res[459].exec("ab ", 947)); -assertEquals("acb", res[463].exec("acb"), 948); -assertEquals("ab", res[463].exec("ab"), 949); -assertEquals(null, res[463].exec("ax{100}b ", 950)); -assertEquals(null, res[463].exec("*** Failers", 951)); -assertEquals(null, res[463].exec("a\nb ", 952)); -assertEquals(null, res[464].exec("ax{4000}xyb ", 953)); -assertEquals(null, res[464].exec("ax{4000}yb ", 954)); -assertEquals(null, res[464].exec("ax{4000}x{100}yb ", 955)); -assertEquals(null, res[464].exec("*** Failers", 956)); -assertEquals(null, res[464].exec("ax{4000}b ", 957)); -assertEquals(null, res[464].exec("ac\ncb ", 958)); -assertEquals("a\xc0,,\xc0", res[465].exec("a\xc0\x88b"), 959); -assertEquals("ax,,x", res[466].exec("ax{100}b"), 960); -assertEquals("a\xc0\x88b,\xc0\x88,b", res[467].exec("a\xc0\x88b"), 961); -assertEquals("ax{100}b,x{100},b", res[468].exec("ax{100}b"), 962); -assertEquals("a\xc0\x92,\xc0,\x92", res[469].exec("a\xc0\x92bcd"), 963); -assertEquals("ax{,x,{", res[470].exec("ax{240}bcd"), 964); -assertEquals("a\xc0\x92,\xc0,\x92", res[471].exec("a\xc0\x92bcd"), 965); -assertEquals("ax{,x,{", res[472].exec("ax{240}bcd"), 966); -assertEquals("a\xc0,,\xc0", res[473].exec("a\xc0\x92bcd"), 967); -assertEquals("ax,,x", res[474].exec("ax{240}bcd"), 968); -assertEquals(null, res[475].exec("ax{1234}xyb ", 969)); -assertEquals(null, res[475].exec("ax{1234}x{4321}yb ", 970)); -assertEquals(null, res[475].exec("ax{1234}x{4321}x{3412}b ", 971)); -assertEquals(null, res[475].exec("*** Failers", 972)); -assertEquals(null, res[475].exec("ax{1234}b ", 973)); -assertEquals(null, res[475].exec("ac\ncb ", 974)); -assertEquals("ax{1234}xyb,x{1234}xy", res[476].exec("ax{1234}xyb "), 975); -assertEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[476].exec("ax{1234}x{4321}yb "), 976); -assertEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[476].exec("ax{1234}x{4321}x{3412}b "), 977); -assertEquals("axxxxbcdefghijb,xxxxbcdefghij", res[476].exec("axxxxbcdefghijb "), 978); -assertEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[476].exec("ax{1234}x{4321}x{3412}x{3421}b "), 979); -assertEquals(null, res[476].exec("*** Failers", 980)); -assertEquals("ax{1234}b,x{1234}", res[476].exec("ax{1234}b "), 981); -assertEquals("ax{1234}xyb,x{1234}xy", res[477].exec("ax{1234}xyb "), 982); -assertEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[477].exec("ax{1234}x{4321}yb "), 983); -assertEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[477].exec("ax{1234}x{4321}x{3412}b "), 984); -assertEquals("axxxxb,xxxx", res[477].exec("axxxxbcdefghijb "), 985); -assertEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[477].exec("ax{1234}x{4321}x{3412}x{3421}b "), 986); -assertEquals(null, res[477].exec("*** Failers", 987)); -assertEquals("ax{1234}b,x{1234}", res[477].exec("ax{1234}b "), 988); -assertEquals(null, res[478].exec("ax{1234}xyb ", 989)); -assertEquals(null, res[478].exec("ax{1234}x{4321}yb ", 990)); -assertEquals(null, res[478].exec("ax{1234}x{4321}x{3412}b ", 991)); -assertEquals("axxxxb,xxxx", res[478].exec("axxxxbcdefghijb "), 992); -assertEquals(null, res[478].exec("ax{1234}x{4321}x{3412}x{3421}b ", 993)); -assertEquals("axbxxb,xbxx", res[478].exec("axbxxbcdefghijb "), 994); -assertEquals("axxxxxb,xxxxx", res[478].exec("axxxxxbcdefghijb "), 995); -assertEquals(null, res[478].exec("*** Failers", 996)); -assertEquals(null, res[478].exec("ax{1234}b ", 997)); -assertEquals(null, res[478].exec("axxxxxxbcdefghijb ", 998)); -assertEquals(null, res[479].exec("ax{1234}xyb ", 999)); -assertEquals(null, res[479].exec("ax{1234}x{4321}yb ", 1000)); -assertEquals(null, res[479].exec("ax{1234}x{4321}x{3412}b ", 1001)); -assertEquals("axxxxb,xxxx", res[479].exec("axxxxbcdefghijb "), 1002); -assertEquals(null, res[479].exec("ax{1234}x{4321}x{3412}x{3421}b ", 1003)); -assertEquals("axbxxb,xbxx", res[479].exec("axbxxbcdefghijb "), 1004); -assertEquals("axxxxxb,xxxxx", res[479].exec("axxxxxbcdefghijb "), 1005); -assertEquals(null, res[479].exec("*** Failers", 1006)); -assertEquals(null, res[479].exec("ax{1234}b ", 1007)); -assertEquals(null, res[479].exec("axxxxxxbcdefghijb ", 1008)); -assertEquals(null, res[479].exec("*** Failers", 1009)); -assertEquals(null, res[479].exec("x{100}", 1010)); -assertEquals(null, res[479].exec("aXbcd", 1011)); -assertEquals(null, res[479].exec("ax{100}bcd", 1012)); -assertEquals(null, res[479].exec("ax{100000}bcd", 1013)); -assertEquals(null, res[479].exec("x{100}x{100}x{100}b", 1014)); -assertEquals(null, res[479].exec("*** Failers ", 1015)); -assertEquals(null, res[479].exec("x{100}x{100}b", 1016)); -assertEquals(null, res[479].exec("x{ab} ", 1017)); -assertEquals(null, res[479].exec("\xc2\xab", 1018)); -assertEquals(null, res[479].exec("*** Failers ", 1019)); -assertEquals(null, res[479].exec("\x00{ab}", 1020)); -assertEquals(null, res[479].exec("WXYZ", 1021)); -assertEquals(null, res[479].exec("x{256}XYZ ", 1022)); -assertEquals(null, res[479].exec("*** Failers", 1023)); -assertEquals(null, res[479].exec("XYZ ", 1024)); -assertEquals(null, res[480].exec("Xx{1234}", 1025)); -assertEquals(null, res[481].exec("Xx{1234}YZ", 1026)); -assertEquals("X", res[482].exec("XYZabcdce"), 1027); -assertEquals("X", res[483].exec("XYZabcde"), 1028); -assertEquals(null, res[484].exec("Xabcdefg ", 1029)); -assertEquals(null, res[484].exec("Xx{1234} ", 1030)); -assertEquals(null, res[484].exec("Xx{1234}YZ", 1031)); -assertEquals(null, res[484].exec("Xx{1234}x{512} ", 1032)); -assertEquals(null, res[484].exec("Xx{1234}x{512}YZ", 1033)); -assertEquals(null, res[485].exec("Xabcdefg ", 1034)); -assertEquals(null, res[485].exec("Xx{1234} ", 1035)); -assertEquals(null, res[485].exec("Xx{1234}YZ", 1036)); -assertEquals(null, res[485].exec("Xx{1234}x{512} ", 1037)); -assertEquals("bcd", res[486].exec("bcd"), 1038); -assertEquals("00}", res[486].exec("x{100}aYx{256}Z "), 1039); -assertEquals("x{", res[487].exec("x{100}bc"), 1040); -assertEquals("x{100}bcA", res[488].exec("x{100}bcAa"), 1041); -assertEquals("x{", res[489].exec("x{100}bca"), 1042); -assertEquals("bcd", res[490].exec("bcd"), 1043); -assertEquals("00}", res[490].exec("x{100}aYx{256}Z "), 1044); -assertEquals("x{", res[491].exec("x{100}bc"), 1045); -assertEquals("x{100}bc", res[492].exec("x{100}bcAa"), 1046); -assertEquals("x{", res[493].exec("x{100}bca"), 1047); -assertEquals(null, res[493].exec("abcd", 1048)); -assertEquals(null, res[493].exec("abcd", 1049)); -assertEquals("x{", res[493].exec("x{100}x{100} "), 1050); -assertEquals("x{", res[493].exec("x{100}x{100} "), 1051); -assertEquals("x{", res[493].exec("x{100}x{100}x{100}x{100} "), 1052); -assertEquals(null, res[493].exec("abce", 1053)); -assertEquals("x{", res[493].exec("x{100}x{100}x{100}x{100} "), 1054); -assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1055)); -assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1056)); -assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1057)); -assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}XX", 1058)); -assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 1059)); -assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 1060)); -assertEquals("Xy", res[493].exec("Xyyyax{100}x{100}bXzzz"), 1061); -assertEquals("X", res[496].exec("1X2"), 1062); -assertEquals("x", res[496].exec("1x{100}2 "), 1063); -assertEquals(">X", res[497].exec("> >X Y"), 1064); -assertEquals(">x", res[497].exec("> >x{100} Y"), 1065); -assertEquals("1", res[498].exec("x{100}3"), 1066); -assertEquals(" ", res[499].exec("x{100} X"), 1067); -assertEquals("abcd", res[500].exec("12abcd34"), 1068); -assertEquals("*** Failers", res[500].exec("*** Failers"), 1069); -assertEquals(" ", res[500].exec("1234 "), 1070); -assertEquals("abc", res[501].exec("12abcd34"), 1071); -assertEquals("ab", res[501].exec("12ab34"), 1072); -assertEquals("***", res[501].exec("*** Failers "), 1073); -assertEquals(null, res[501].exec("1234", 1074)); -assertEquals(" ", res[501].exec("12a34 "), 1075); -assertEquals("ab", res[502].exec("12abcd34"), 1076); -assertEquals("ab", res[502].exec("12ab34"), 1077); -assertEquals("**", res[502].exec("*** Failers "), 1078); -assertEquals(null, res[502].exec("1234", 1079)); -assertEquals(" ", res[502].exec("12a34 "), 1080); -assertEquals("12", res[503].exec("12abcd34"), 1081); -assertEquals(null, res[503].exec("*** Failers", 1082)); -assertEquals("12", res[504].exec("12abcd34"), 1083); -assertEquals("123", res[504].exec("1234abcd"), 1084); -assertEquals(null, res[504].exec("*** Failers ", 1085)); -assertEquals(null, res[504].exec("1.4 ", 1086)); -assertEquals("12", res[505].exec("12abcd34"), 1087); -assertEquals("12", res[505].exec("1234abcd"), 1088); -assertEquals(null, res[505].exec("*** Failers ", 1089)); -assertEquals(null, res[505].exec("1.4 ", 1090)); -assertEquals("12abcd34", res[506].exec("12abcd34"), 1091); -assertEquals("***", res[506].exec("*** Failers"), 1092); -assertEquals(null, res[506].exec(" ", 1093)); -assertEquals("12a", res[507].exec("12abcd34"), 1094); -assertEquals("123", res[507].exec("1234abcd"), 1095); -assertEquals("***", res[507].exec("*** Failers"), 1096); -assertEquals(null, res[507].exec(" ", 1097)); -assertEquals("12", res[508].exec("12abcd34"), 1098); -assertEquals("12", res[508].exec("1234abcd"), 1099); -assertEquals("**", res[508].exec("*** Failers"), 1100); -assertEquals(null, res[508].exec(" ", 1101)); -assertEquals("> <", res[509].exec("12> <34"), 1102); -assertEquals(null, res[509].exec("*** Failers", 1103)); -assertEquals("> <", res[510].exec("ab> <", res[510].exec("ab> <", res[511].exec("ab> <", res[511].exec("ab> \xff<"), 1186); -assertEquals(null, res[521].exec(">x{ff}<", 1187)); -assertEquals("X", res[522].exec("XYZ"), 1188); -assertEquals("X", res[523].exec("XYZ"), 1189); -assertEquals("x", res[523].exec("x{123} "), 1190); -assertEquals(",", res[528].exec("catac"), 1191); -assertEquals(",", res[528].exec("ax{256}a "), 1192); -assertEquals(",", res[528].exec("x{85}"), 1193); -assertEquals(",", res[528].exec("\u1234 "), 1194); -assertEquals(",", res[528].exec("\u1234 "), 1195); -assertEquals(",", res[528].exec("abcdefg"), 1196); -assertEquals(",", res[528].exec("ab"), 1197); -assertEquals(",", res[528].exec("a "), 1198); -assertEquals("Ax", res[529].exec("Ax{a3}BC"), 1199); -assertEquals("Ax", res[530].exec("Ax{a3}BC"), 1200); -assertEquals("}=", res[531].exec("+x{a3}== "), 1201); -assertEquals("}=", res[532].exec("+x{a3}== "), 1202); -assertEquals("x", res[533].exec("x{442}x{435}x{441}x{442}"), 1203); -assertEquals("x", res[534].exec("x{442}x{435}x{441}x{442}"), 1204); -assertEquals("x", res[535].exec("x{442}x{435}x{441}x{442}"), 1205); -assertEquals("x", res[536].exec("x{442}x{435}x{441}x{442}"), 1206); -assertEquals("{", res[537].exec("x{2442}x{2435}x{2441}x{2442}"), 1207); -assertEquals("{", res[538].exec("x{2442}x{2435}x{2441}x{2442}"), 1208); -assertEquals("abc\n\x0dx{442}x{435}x{441}x{442}xyz ", res[539].exec("abc\n\x0dx{442}x{435}x{441}x{442}xyz "), 1209); -assertEquals("x{442}x{435}x{441}x{442}", res[539].exec("x{442}x{435}x{441}x{442}"), 1210); -assertEquals("c d", res[540].exec("abc defx{442}x{443}xyz\npqr"), 1211); -assertEquals("c d", res[541].exec("abc defx{442}x{443}xyz\npqr"), 1212); -assertEquals(null, res[542].exec("+x{2442}", 1213)); -assertEquals(null, res[543].exec("+x{2442}", 1214)); -assertEquals(null, res[544].exec("Ax{442}", 1215)); -assertEquals(null, res[545].exec("Ax{442}", 1216)); -assertEquals(null, res[546].exec("Ax{442}", 1217)); -assertEquals(null, res[547].exec("Ax{442}", 1218)); -assertEquals(null, res[548].exec("\x19x{e01ff}", 1219)); -assertEquals(null, res[549].exec("Ax{422}", 1220)); -assertEquals(null, res[550].exec("x{19}x{e01ff}", 1221)); -assertEquals(null, res[551].exec("Ax{442}", 1222)); -assertEquals(null, res[552].exec("Ax{442}", 1223)); -assertEquals(null, res[553].exec("ax{442}", 1224)); -assertEquals(null, res[554].exec("+x{2442}", 1225)); -assertEquals(null, res[555].exec("Mx{442}", 1226)); -assertEquals("abc", res[556].exec("abc"), 1227); -assertEquals("abc", res[557].exec("abc"), 1228); -assertEquals("abc", res[558].exec("abc"), 1229); -assertEquals("abc", res[559].exec("abc"), 1230); -assertEquals(null, res[560].exec("x{100}ax{1234}bcd", 1231)); -assertEquals(null, res[562].exec("x{0041}x{2262}x{0391}x{002e}", 1232)); -assertEquals(null, res[562].exec("x{D55c}x{ad6d}x{C5B4} ", 1233)); -assertEquals(null, res[562].exec("x{65e5}x{672c}x{8a9e}", 1234)); -assertEquals("{861}X", res[563].exec("x{212ab}x{212ab}x{212ab}x{861}X"), 1235); -assertEquals("x{2", res[564].exec("x{212ab}x{212ab}x{212ab}x{861}"), 1236); -assertEquals("x{c", res[564].exec("x{c0}b"), 1237); -assertEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1238); -assertEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1239); -assertEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1240); -assertEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1241); -assertEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1242); -assertEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1243); -assertEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1244); -assertEquals("Sho", res[564].exec("Should produce an error diagnostic"), 1245); -assertEquals(null, res[565].exec("Xx{1234}", 1246)); -assertEquals(null, res[565].exec("X\nabc ", 1247)); -assertEquals("b", res[566].exec("bar"), 1248); -assertEquals(null, res[566].exec("*** Failers", 1249)); -assertEquals(null, res[566].exec("c", 1250)); -assertEquals(null, res[566].exec("x{ff}", 1251)); -assertEquals(null, res[566].exec("x{100} ", 1252)); -assertEquals("c", res[567].exec("c"), 1253); -assertEquals("x", res[567].exec("x{ff}"), 1254); -assertEquals("x", res[567].exec("x{100} "), 1255); -assertEquals("*", res[567].exec("*** Failers "), 1256); -assertEquals(null, res[567].exec("aaa", 1257)); -assertEquals("x", res[568].exec("x{f1}"), 1258); -assertEquals("x", res[568].exec("x{bf}"), 1259); -assertEquals("x", res[568].exec("x{100}"), 1260); -assertEquals("x", res[568].exec("x{1000} "), 1261); -assertEquals("*", res[568].exec("*** Failers"), 1262); -assertEquals("x", res[568].exec("x{c0} "), 1263); -assertEquals("x", res[568].exec("x{f0} "), 1264); -assertEquals("1", res[568].exec("1234"), 1265); -assertEquals("\"", res[568].exec("\"1234\" "), 1266); -assertEquals("x", res[568].exec("x{100}1234"), 1267); -assertEquals("\"", res[568].exec("\"x{100}1234\" "), 1268); -assertEquals("x", res[568].exec("x{100}x{100}12ab "), 1269); -assertEquals("x", res[568].exec("x{100}x{100}\"12\" "), 1270); -assertEquals("*", res[568].exec("*** Failers "), 1271); -assertEquals("x", res[568].exec("x{100}x{100}abcd"), 1272); -assertEquals("A", res[568].exec("A"), 1273); -assertEquals("x", res[568].exec("x{100}"), 1274); -assertEquals("Z", res[568].exec("Zx{100}"), 1275); -assertEquals("x", res[568].exec("x{100}Z"), 1276); -assertEquals("*", res[568].exec("*** Failers "), 1277); -assertEquals("Z", res[568].exec("Zx{100}"), 1278); -assertEquals("x", res[568].exec("x{100}"), 1279); -assertEquals("x", res[568].exec("x{100}Z"), 1280); -assertEquals("*", res[568].exec("*** Failers "), 1281); -assertEquals("x", res[568].exec("x{100}"), 1282); -assertEquals("x", res[568].exec("x{104}"), 1283); -assertEquals("*", res[568].exec("*** Failers"), 1284); -assertEquals("x", res[568].exec("x{105}"), 1285); -assertEquals("x", res[568].exec("x{ff} "), 1286); -assertEquals("x", res[568].exec("x{100}"), 1287); -assertEquals("\u0100", res[568].exec("\u0100 "), 1288); -assertEquals("\xff", res[569].exec(">\xff<"), 1289); -assertEquals(null, res[570].exec(">x{ff}<", 1290)); -assertEquals("\xd6", res[572].exec("\xd6 # Matches without Study"), 1291); -assertEquals("x", res[572].exec("x{d6}"), 1292); -assertEquals("\xd6", res[572].exec("\xd6 <-- Same with Study"), 1293); -assertEquals("x", res[572].exec("x{d6}"), 1294); -assertEquals("\xd6", res[572].exec("\xd6 # Matches without Study"), 1295); -assertEquals("x", res[572].exec("x{d6} "), 1296); -assertEquals("\xd6", res[572].exec("\xd6 <-- Same with Study"), 1297); -assertEquals("x", res[572].exec("x{d6} "), 1298); -assertEquals("\ufffd", res[572].exec("\ufffd]"), 1299); -assertEquals("\ufffd", res[572].exec("\ufffd"), 1300); -assertEquals("\ufffd", res[572].exec("\ufffd\ufffd\ufffd"), 1301); -assertEquals("\ufffd", res[572].exec("\ufffd\ufffd\ufffd?"), 1302); -assertEquals(null, res[573].exec("\xc0\x80", 1303)); -assertEquals(null, res[573].exec("\xc1\x8f ", 1304)); -assertEquals(null, res[573].exec("\xe0\x9f\x80", 1305)); -assertEquals(null, res[573].exec("\xf0\x8f\x80\x80 ", 1306)); -assertEquals(null, res[573].exec("\xf8\x87\x80\x80\x80 ", 1307)); -assertEquals(null, res[573].exec("\xfc\x83\x80\x80\x80\x80", 1308)); -assertEquals(null, res[573].exec("\xfe\x80\x80\x80\x80\x80 ", 1309)); -assertEquals(null, res[573].exec("\xff\x80\x80\x80\x80\x80 ", 1310)); -assertEquals(null, res[573].exec("\xc3\x8f", 1311)); -assertEquals(null, res[573].exec("\xe0\xaf\x80", 1312)); -assertEquals(null, res[573].exec("\xe1\x80\x80", 1313)); -assertEquals(null, res[573].exec("\xf0\x9f\x80\x80 ", 1314)); -assertEquals(null, res[573].exec("\xf1\x8f\x80\x80 ", 1315)); -assertEquals(null, res[573].exec("\xf8\x88\x80\x80\x80 ", 1316)); -assertEquals(null, res[573].exec("\xf9\x87\x80\x80\x80 ", 1317)); -assertEquals(null, res[573].exec("\xfc\x84\x80\x80\x80\x80", 1318)); -assertEquals(null, res[573].exec("\xfd\x83\x80\x80\x80\x80", 1319)); -assertEquals(null, res[573].exec("?\xf8\x88\x80\x80\x80 ", 1320)); -assertEquals(null, res[573].exec("?\xf9\x87\x80\x80\x80 ", 1321)); -assertEquals(null, res[573].exec("?\xfc\x84\x80\x80\x80\x80", 1322)); -assertEquals(null, res[573].exec("?\xfd\x83\x80\x80\x80\x80", 1323)); -assertEquals(".", res[574].exec("A.B"), 1324); -assertEquals("{", res[574].exec("Ax{100}B "), 1325); -assertEquals("x", res[575].exec("x{100}X "), 1326); -assertEquals("a", res[575].exec("ax{1234}b"), 1327); -assertEquals(null, res[577].exec("AxxB ", 1328)); -assertEquals("abc1", res[578].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 x{0085}abc7 x{2028}abc8 x{2029}abc9 JUNK"), 1329); -assertEquals("abc1", res[579].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6x{0085} abc7x{2028} abc8x{2029} abc9"), 1330); -assertEquals(null, res[580].exec("a\nb", 1331)); -assertEquals(null, res[580].exec("a\x0db", 1332)); -assertEquals(null, res[580].exec("a\x0d\nb", 1333)); -assertEquals(null, res[580].exec("a\x0bb", 1334)); -assertEquals(null, res[580].exec("a\x0cb", 1335)); -assertEquals(null, res[580].exec("ax{85}b ", 1336)); -assertEquals(null, res[580].exec("ax{2028}b ", 1337)); -assertEquals(null, res[580].exec("ax{2029}b ", 1338)); -assertEquals(null, res[580].exec("** Failers", 1339)); -assertEquals(null, res[580].exec("a\n\x0db ", 1340)); -assertEquals("ab", res[581].exec("ab"), 1341); -assertEquals(null, res[581].exec("a\nb", 1342)); -assertEquals(null, res[581].exec("a\x0db", 1343)); -assertEquals(null, res[581].exec("a\x0d\nb", 1344)); -assertEquals(null, res[581].exec("a\x0bb", 1345)); -assertEquals(null, res[581].exec("a\x0cx{2028}x{2029}b", 1346)); -assertEquals(null, res[581].exec("ax{85}b ", 1347)); -assertEquals(null, res[581].exec("a\n\x0db ", 1348)); -assertEquals(null, res[581].exec("a\n\x0dx{85}\x0cb ", 1349)); -assertEquals(null, res[582].exec("a\nb", 1350)); -assertEquals(null, res[582].exec("a\x0db", 1351)); -assertEquals(null, res[582].exec("a\x0d\nb", 1352)); -assertEquals(null, res[582].exec("a\x0bb", 1353)); -assertEquals(null, res[582].exec("a\x0cx{2028}x{2029}b", 1354)); -assertEquals(null, res[582].exec("ax{85}b ", 1355)); -assertEquals(null, res[582].exec("a\n\x0db ", 1356)); -assertEquals(null, res[582].exec("a\n\x0dx{85}\x0cb ", 1357)); -assertEquals(null, res[582].exec("** Failers", 1358)); -assertEquals(null, res[582].exec("ab ", 1359)); -assertEquals(null, res[583].exec("a\nb", 1360)); -assertEquals(null, res[583].exec("a\n\x0db", 1361)); -assertEquals(null, res[583].exec("a\n\x0dx{85}b", 1362)); -assertEquals(null, res[583].exec("a\x0d\n\x0d\nb ", 1363)); -assertEquals(null, res[583].exec("a\x0d\n\x0d\n\x0d\nb ", 1364)); -assertEquals(null, res[583].exec("a\n\x0d\n\x0db", 1365)); -assertEquals(null, res[583].exec("a\n\n\x0d\nb ", 1366)); -assertEquals(null, res[583].exec("** Failers", 1367)); -assertEquals(null, res[583].exec("a\n\n\n\x0db", 1368)); -assertEquals(null, res[583].exec("a\x0d", 1369)); -assertEquals(null, res[584].exec("X X\n", 1370)); -assertEquals(null, res[584].exec("X\x09X\x0b", 1371)); -assertEquals(null, res[584].exec("** Failers", 1372)); -assertEquals(null, res[584].exec("x{a0} X\n ", 1373)); -assertEquals(null, res[585].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 1374)); -assertEquals(null, res[585].exec("\x09 x{a0}\n\x0b\x0c\x0d\n", 1375)); -assertEquals(null, res[585].exec("\x09 x{a0}\n\x0b\x0c", 1376)); -assertEquals(null, res[585].exec("** Failers ", 1377)); -assertEquals(null, res[585].exec("\x09 x{a0}\n\x0b", 1378)); -assertEquals(null, res[585].exec(" ", 1379)); -assertEquals(null, res[586].exec("x{3001}x{3000}x{2030}x{2028}", 1380)); -assertEquals(null, res[586].exec("Xx{180e}Xx{85}", 1381)); -assertEquals(null, res[586].exec("** Failers", 1382)); -assertEquals(null, res[586].exec("x{2009} X\n ", 1383)); -assertEquals(null, res[587].exec("x{1680}x{180e}x{2007}Xx{2028}x{2029}\x0c\x0d\n", 1384)); -assertEquals(null, res[587].exec("\x09x{205f}x{a0}\nx{2029}\x0cx{2028}\n", 1385)); -assertEquals(null, res[587].exec("\x09 x{202f}\n\x0b\x0c", 1386)); -assertEquals(null, res[587].exec("** Failers ", 1387)); -assertEquals(null, res[587].exec("\x09x{200a}x{a0}x{2028}\x0b", 1388)); -assertEquals(null, res[587].exec(" ", 1389)); -assertEquals(null, res[588].exec(">x{1680}", 1390)); -assertEquals(null, res[589].exec(">x{1680}x{180e}x{2000}x{2003}x{200a}x{202f}x{205f}x{3000}<", 1391)); -assertEquals("x{1ec5} ", res[593].exec("x{1ec5} "), 1392); -assertEquals(null, res[594].exec("x{0}x{d7ff}x{e000}x{10ffff}", 1393)); -assertEquals(null, res[594].exec("x{d800}", 1394)); -assertEquals(null, res[594].exec("x{d800}?", 1395)); -assertEquals(null, res[594].exec("x{da00}", 1396)); -assertEquals(null, res[594].exec("x{da00}?", 1397)); -assertEquals(null, res[594].exec("x{dfff}", 1398)); -assertEquals(null, res[594].exec("x{dfff}?", 1399)); -assertEquals(null, res[594].exec("x{110000} ", 1400)); -assertEquals(null, res[594].exec("x{110000}? ", 1401)); -assertEquals(null, res[594].exec("x{2000000} ", 1402)); -assertEquals(null, res[594].exec("x{2000000}? ", 1403)); -assertEquals(null, res[594].exec("x{7fffffff} ", 1404)); -assertEquals(null, res[594].exec("x{7fffffff}? ", 1405)); -assertEquals(null, res[595].exec("a\x0db", 1406)); -assertEquals(null, res[595].exec("a\nb", 1407)); -assertEquals(null, res[595].exec("a\x0d\nb", 1408)); -assertEquals(null, res[595].exec("** Failers", 1409)); -assertEquals(null, res[595].exec("ax{85}b", 1410)); -assertEquals(null, res[595].exec("a\x0bb ", 1411)); -assertEquals(null, res[596].exec("a\x0db", 1412)); -assertEquals(null, res[596].exec("a\nb", 1413)); -assertEquals(null, res[596].exec("a\x0d\nb", 1414)); -assertEquals(null, res[596].exec("ax{85}b", 1415)); -assertEquals(null, res[596].exec("a\x0bb ", 1416)); -assertEquals(null, res[596].exec("** Failers ", 1417)); -assertEquals(null, res[596].exec("ax{85}b", 1418)); -assertEquals(null, res[596].exec("a\x0bb", 1419)); -assertEquals(null, res[597].exec("a\x0db", 1420)); -assertEquals(null, res[597].exec("a\nb", 1421)); -assertEquals(null, res[597].exec("a\x0d\nb", 1422)); -assertEquals(null, res[597].exec("** Failers", 1423)); -assertEquals(null, res[597].exec("ax{85}b", 1424)); -assertEquals(null, res[597].exec("a\x0bb ", 1425)); -assertEquals(null, res[598].exec("a\x0db", 1426)); -assertEquals(null, res[598].exec("a\nb", 1427)); -assertEquals(null, res[598].exec("a\x0d\nb", 1428)); -assertEquals(null, res[598].exec("ax{85}b", 1429)); -assertEquals(null, res[598].exec("a\x0bb ", 1430)); -assertEquals(null, res[598].exec("** Failers ", 1431)); -assertEquals(null, res[598].exec("ax{85}b", 1432)); -assertEquals(null, res[598].exec("a\x0bb", 1433)); -assertEquals("QQQx{2029}ABCaXYZ=!bPQR", res[599].exec("QQQx{2029}ABCaXYZ=!bPQR"), 1434); -assertEquals(null, res[599].exec("** Failers", 1435)); -assertEquals(null, res[599].exec("ax{2029}b", 1436)); -assertEquals(null, res[599].exec("a\xe2\x80\xa9b ", 1437)); -assertEquals(null, res[600].exec("ax{1234}b", 1438)); -assertEquals("a\nb", res[600].exec("a\nb "), 1439); -assertEquals(null, res[600].exec("** Failers", 1440)); -assertEquals(null, res[600].exec("ab ", 1441)); -assertEquals("aXb", res[601].exec("aXb"), 1442); -assertEquals("a\nX\nXx{1234}b", res[601].exec("a\nX\nXx{1234}b "), 1443); -assertEquals(null, res[601].exec("** Failers", 1444)); -assertEquals(null, res[601].exec("ab ", 1445)); -assertEquals(null, res[601].exec("x{de}x{de}", 1446)); -assertEquals(null, res[601].exec("x{123} ", 1447)); -assertEquals("X", res[602].exec("Ax{1ec5}ABCXYZ"), 1448); -assertEquals(null, res[604].exec("x{c0}x{30f}x{660}x{66c}x{f01}x{1680}<", 1449)); -assertEquals(null, res[604].exec("\npx{300}9!$ < ", 1450)); -assertEquals(null, res[604].exec("** Failers ", 1451)); -assertEquals(null, res[604].exec("apx{300}9!$ < ", 1452)); -assertEquals(null, res[605].exec("X", 1453)); -assertEquals(null, res[605].exec("** Failers ", 1454)); -assertEquals(null, res[605].exec("", 1455)); -assertEquals(null, res[606].exec("9", 1456)); -assertEquals(null, res[606].exec("** Failers ", 1457)); -assertEquals(null, res[606].exec("x{c0}", 1458)); -assertEquals(null, res[607].exec("X", 1459)); -assertEquals(null, res[607].exec("** Failers ", 1460)); -assertEquals(null, res[607].exec("x{30f}", 1461)); -assertEquals(null, res[608].exec("X", 1462)); -assertEquals(null, res[608].exec("** Failers ", 1463)); -assertEquals(null, res[608].exec("x{660}", 1464)); -assertEquals(null, res[609].exec("X", 1465)); -assertEquals(null, res[609].exec("** Failers ", 1466)); -assertEquals(null, res[609].exec("x{66c}", 1467)); -assertEquals(null, res[610].exec("X", 1468)); -assertEquals(null, res[610].exec("** Failers ", 1469)); -assertEquals(null, res[610].exec("x{f01}", 1470)); -assertEquals(null, res[611].exec("X", 1471)); -assertEquals(null, res[611].exec("** Failers ", 1472)); -assertEquals(null, res[611].exec("x{1680}", 1473)); -assertEquals(null, res[612].exec("x{017}", 1474)); -assertEquals(null, res[612].exec("x{09f} ", 1475)); -assertEquals(null, res[612].exec("** Failers", 1476)); -assertEquals(null, res[612].exec("x{0600} ", 1477)); -assertEquals(null, res[613].exec("x{601}", 1478)); -assertEquals(null, res[613].exec("** Failers", 1479)); -assertEquals(null, res[613].exec("x{09f} ", 1480)); -assertEquals(null, res[614].exec("x{e0000}", 1481)); -assertEquals(null, res[614].exec("** Failers", 1482)); -assertEquals(null, res[614].exec("x{09f} ", 1483)); -assertEquals(null, res[615].exec("x{f8ff}", 1484)); -assertEquals(null, res[615].exec("** Failers", 1485)); -assertEquals(null, res[615].exec("x{09f} ", 1486)); -assertEquals(null, res[616].exec("?x{dfff}", 1487)); -assertEquals(null, res[616].exec("** Failers", 1488)); -assertEquals(null, res[616].exec("x{09f} ", 1489)); -assertEquals(null, res[617].exec("a", 1490)); -assertEquals(null, res[617].exec("** Failers ", 1491)); -assertEquals(null, res[617].exec("Z", 1492)); -assertEquals(null, res[617].exec("x{e000} ", 1493)); -assertEquals(null, res[618].exec("x{2b0}", 1494)); -assertEquals(null, res[618].exec("** Failers", 1495)); -assertEquals(null, res[618].exec("a ", 1496)); -assertEquals(null, res[619].exec("x{1bb}", 1497)); -assertEquals(null, res[619].exec("x{3400}", 1498)); -assertEquals(null, res[619].exec("x{3401}", 1499)); -assertEquals(null, res[619].exec("x{4d00}", 1500)); -assertEquals(null, res[619].exec("x{4db4}", 1501)); -assertEquals(null, res[619].exec("x{4db5} ", 1502)); -assertEquals(null, res[619].exec("** Failers", 1503)); -assertEquals(null, res[619].exec("a ", 1504)); -assertEquals(null, res[619].exec("x{2b0}", 1505)); -assertEquals(null, res[619].exec("x{4db6} ", 1506)); -assertEquals(null, res[620].exec("x{1c5}", 1507)); -assertEquals(null, res[620].exec("** Failers", 1508)); -assertEquals(null, res[620].exec("a ", 1509)); -assertEquals(null, res[620].exec("x{2b0}", 1510)); -assertEquals(null, res[621].exec("A", 1511)); -assertEquals(null, res[621].exec("** Failers", 1512)); -assertEquals(null, res[621].exec("x{2b0}", 1513)); -assertEquals(null, res[622].exec("x{903}", 1514)); -assertEquals(null, res[622].exec("** Failers", 1515)); -assertEquals(null, res[622].exec("X", 1516)); -assertEquals(null, res[622].exec("x{300}", 1517)); -assertEquals(null, res[622].exec(" ", 1518)); -assertEquals(null, res[623].exec("x{488}", 1519)); -assertEquals(null, res[623].exec("** Failers", 1520)); -assertEquals(null, res[623].exec("X", 1521)); -assertEquals(null, res[623].exec("x{903}", 1522)); -assertEquals(null, res[623].exec("x{300}", 1523)); -assertEquals(null, res[624].exec("x{300}", 1524)); -assertEquals(null, res[624].exec("** Failers", 1525)); -assertEquals(null, res[624].exec("X", 1526)); -assertEquals(null, res[624].exec("x{903}", 1527)); -assertEquals(null, res[624].exec("0123456789x{660}x{661}x{662}x{663}x{664}x{665}x{666}x{667}x{668}x{669}x{66a}", 1528)); -assertEquals(null, res[624].exec("x{6f0}x{6f1}x{6f2}x{6f3}x{6f4}x{6f5}x{6f6}x{6f7}x{6f8}x{6f9}x{6fa}", 1529)); -assertEquals(null, res[624].exec("x{966}x{967}x{968}x{969}x{96a}x{96b}x{96c}x{96d}x{96e}x{96f}x{970}", 1530)); -assertEquals(null, res[624].exec("** Failers", 1531)); -assertEquals(null, res[624].exec("X", 1532)); -assertEquals(null, res[625].exec("x{16ee}", 1533)); -assertEquals(null, res[625].exec("** Failers", 1534)); -assertEquals(null, res[625].exec("X", 1535)); -assertEquals(null, res[625].exec("x{966}", 1536)); -assertEquals(null, res[626].exec("x{b2}", 1537)); -assertEquals(null, res[626].exec("x{b3}", 1538)); -assertEquals(null, res[626].exec("** Failers", 1539)); -assertEquals(null, res[626].exec("X", 1540)); -assertEquals(null, res[626].exec("x{16ee}", 1541)); -assertEquals(null, res[627].exec("_", 1542)); -assertEquals(null, res[627].exec("x{203f}", 1543)); -assertEquals(null, res[627].exec("** Failers", 1544)); -assertEquals(null, res[627].exec("X", 1545)); -assertEquals(null, res[627].exec("-", 1546)); -assertEquals(null, res[627].exec("x{58a}", 1547)); -assertEquals(null, res[628].exec("-", 1548)); -assertEquals(null, res[628].exec("x{58a}", 1549)); -assertEquals(null, res[628].exec("** Failers", 1550)); -assertEquals(null, res[628].exec("X", 1551)); -assertEquals(null, res[628].exec("x{203f}", 1552)); -assertEquals(null, res[629].exec(")", 1553)); -assertEquals(null, res[629].exec("]", 1554)); -assertEquals(null, res[629].exec("}", 1555)); -assertEquals(null, res[629].exec("x{f3b}", 1556)); -assertEquals(null, res[629].exec("** Failers", 1557)); -assertEquals(null, res[629].exec("X", 1558)); -assertEquals(null, res[629].exec("x{203f}", 1559)); -assertEquals(null, res[629].exec("(", 1560)); -assertEquals(null, res[629].exec("[", 1561)); -assertEquals(null, res[629].exec("{", 1562)); -assertEquals(null, res[629].exec("x{f3c}", 1563)); -assertEquals(null, res[630].exec("x{bb}", 1564)); -assertEquals(null, res[630].exec("x{2019}", 1565)); -assertEquals(null, res[630].exec("** Failers", 1566)); -assertEquals(null, res[630].exec("X", 1567)); -assertEquals(null, res[630].exec("x{203f}", 1568)); -assertEquals(null, res[631].exec("x{ab}", 1569)); -assertEquals(null, res[631].exec("x{2018}", 1570)); -assertEquals(null, res[631].exec("** Failers", 1571)); -assertEquals(null, res[631].exec("X", 1572)); -assertEquals(null, res[631].exec("x{203f}", 1573)); -assertEquals(null, res[632].exec("!", 1574)); -assertEquals(null, res[632].exec("x{37e}", 1575)); -assertEquals(null, res[632].exec("** Failers", 1576)); -assertEquals(null, res[632].exec("X", 1577)); -assertEquals(null, res[632].exec("x{203f}", 1578)); -assertEquals(null, res[633].exec("(", 1579)); -assertEquals(null, res[633].exec("[", 1580)); -assertEquals(null, res[633].exec("{", 1581)); -assertEquals(null, res[633].exec("x{f3c}", 1582)); -assertEquals(null, res[633].exec("** Failers", 1583)); -assertEquals(null, res[633].exec("X", 1584)); -assertEquals(null, res[633].exec(")", 1585)); -assertEquals(null, res[633].exec("]", 1586)); -assertEquals(null, res[633].exec("}", 1587)); -assertEquals(null, res[633].exec("x{f3b}", 1588)); -assertEquals(null, res[633].exec("$x{a2}x{a3}x{a4}x{a5}x{a6}", 1589)); -assertEquals(null, res[633].exec("x{9f2}", 1590)); -assertEquals(null, res[633].exec("** Failers", 1591)); -assertEquals(null, res[633].exec("X", 1592)); -assertEquals(null, res[633].exec("x{2c2}", 1593)); -assertEquals(null, res[634].exec("x{2c2}", 1594)); -assertEquals(null, res[634].exec("** Failers", 1595)); -assertEquals(null, res[634].exec("X", 1596)); -assertEquals(null, res[634].exec("x{9f2}", 1597)); -assertEquals(null, res[634].exec("+<|~x{ac}x{2044}", 1598)); -assertEquals(null, res[634].exec("** Failers", 1599)); -assertEquals(null, res[634].exec("X", 1600)); -assertEquals(null, res[634].exec("x{9f2}", 1601)); -assertEquals(null, res[635].exec("x{a6}", 1602)); -assertEquals(null, res[635].exec("x{482} ", 1603)); -assertEquals(null, res[635].exec("** Failers", 1604)); -assertEquals(null, res[635].exec("X", 1605)); -assertEquals(null, res[635].exec("x{9f2}", 1606)); -assertEquals(null, res[636].exec("x{2028}", 1607)); -assertEquals(null, res[636].exec("** Failers", 1608)); -assertEquals(null, res[636].exec("X", 1609)); -assertEquals(null, res[636].exec("x{2029}", 1610)); -assertEquals(null, res[637].exec("x{2029}", 1611)); -assertEquals(null, res[637].exec("** Failers", 1612)); -assertEquals(null, res[637].exec("X", 1613)); -assertEquals(null, res[637].exec("x{2028}", 1614)); -assertEquals(null, res[638].exec("\\ \\", 1615)); -assertEquals(null, res[638].exec("x{a0}", 1616)); -assertEquals(null, res[638].exec("x{1680}", 1617)); -assertEquals(null, res[638].exec("x{180e}", 1618)); -assertEquals(null, res[638].exec("x{2000}", 1619)); -assertEquals(null, res[638].exec("x{2001} ", 1620)); -assertEquals(null, res[638].exec("** Failers", 1621)); -assertEquals(null, res[638].exec("x{2028}", 1622)); -assertEquals(null, res[638].exec("x{200d} ", 1623)); -assertEquals(null, res[638].exec(" x{660}x{661}x{662}ABC", 1624)); -assertEquals(null, res[638].exec(" x{660}x{661}x{662}ABC", 1625)); -assertEquals(null, res[639].exec(" x{660}x{661}x{662}ABC", 1626)); -assertEquals(null, res[640].exec(" x{660}x{661}x{662}ABC", 1627)); -assertEquals(null, res[641].exec(" x{660}x{661}x{662}ABC", 1628)); -assertEquals(null, res[642].exec(" x{660}x{661}x{662}ABC", 1629)); -assertEquals(null, res[643].exec(" x{660}x{661}x{662}ABC", 1630)); -assertEquals(null, res[644].exec(" x{660}x{661}x{662}ABC", 1631)); -assertEquals(null, res[645].exec(" x{660}x{661}x{662}ABC", 1632)); -assertEquals(null, res[646].exec(" x{660}x{661}x{662}ABC", 1633)); -assertEquals(null, res[647].exec(" x{660}x{661}x{662}ABC", 1634)); -assertEquals(null, res[647].exec(" x{660}x{661}x{662}ABC", 1635)); -assertEquals(null, res[647].exec(" x{660}x{661}x{662}ABC", 1636)); -assertEquals(null, res[647].exec(" ** Failers", 1637)); -assertEquals(null, res[647].exec(" x{660}x{661}x{662}ABC", 1638)); -assertEquals(null, res[648].exec("A", 1639)); -assertEquals(null, res[648].exec("ax{10a0}B ", 1640)); -assertEquals(null, res[648].exec("** Failers ", 1641)); -assertEquals(null, res[648].exec("a", 1642)); -assertEquals(null, res[648].exec("x{1d00} ", 1643)); -assertEquals(null, res[649].exec("1234", 1644)); -assertEquals(null, res[649].exec("** Failers", 1645)); -assertEquals(null, res[649].exec("ABC ", 1646)); -assertEquals(null, res[650].exec("1234", 1647)); -assertEquals(null, res[650].exec("** Failers", 1648)); -assertEquals(null, res[650].exec("ABC ", 1649)); -assertEquals(null, res[650].exec("A2XYZ", 1650)); -assertEquals(null, res[650].exec("123A5XYZPQR", 1651)); -assertEquals(null, res[650].exec("ABAx{660}XYZpqr", 1652)); -assertEquals(null, res[650].exec("** Failers", 1653)); -assertEquals(null, res[650].exec("AXYZ", 1654)); -assertEquals(null, res[650].exec("XYZ ", 1655)); -assertEquals(null, res[650].exec("1XYZ", 1656)); -assertEquals(null, res[650].exec("AB=XYZ.. ", 1657)); -assertEquals(null, res[650].exec("XYZ ", 1658)); -assertEquals(null, res[650].exec("** Failers", 1659)); -assertEquals(null, res[650].exec("WXYZ ", 1660)); -assertEquals(null, res[655].exec("1234", 1661)); -assertEquals(null, res[655].exec("1234", 1662)); -assertEquals(null, res[655].exec("12-34", 1663)); -assertEquals("{", res[655].exec("12+x{661}-34 "), 1664); -assertEquals(null, res[655].exec("** Failers", 1665)); -assertEquals("d", res[655].exec("abcd "), 1666); -assertEquals("d", res[656].exec("abcd"), 1667); -assertEquals(null, res[656].exec("** Failers", 1668)); -assertEquals(null, res[656].exec("1234", 1669)); -assertEquals(null, res[657].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1670)); -assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[657].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1671); -assertEquals(" ", res[657].exec(" "), 1672); -assertEquals(null, res[657].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1673)); -assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[657].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1674); -assertEquals(null, res[658].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1675)); -assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[658].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1676); -assertEquals(null, res[659].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1677)); -assertEquals(null, res[659].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1678)); -assertEquals(null, res[660].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1679)); -assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[660].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1680); -assertEquals(null, res[661].exec("a", 1681)); -assertEquals(null, res[661].exec("A ", 1682)); -assertEquals(null, res[662].exec("a", 1683)); -assertEquals(null, res[662].exec("A ", 1684)); -assertEquals(null, res[663].exec("A", 1685)); -assertEquals(null, res[663].exec("aZ", 1686)); -assertEquals(null, res[663].exec("** Failers", 1687)); -assertEquals(null, res[663].exec("abc ", 1688)); -assertEquals(null, res[664].exec("A", 1689)); -assertEquals(null, res[664].exec("aZ", 1690)); -assertEquals(null, res[664].exec("** Failers", 1691)); -assertEquals(null, res[664].exec("abc ", 1692)); -assertEquals(null, res[665].exec("a", 1693)); -assertEquals(null, res[665].exec("Az", 1694)); -assertEquals(null, res[665].exec("** Failers", 1695)); -assertEquals(null, res[665].exec("ABC ", 1696)); -assertEquals(null, res[666].exec("a", 1697)); -assertEquals(null, res[666].exec("Az", 1698)); -assertEquals(null, res[666].exec("** Failers", 1699)); -assertEquals(null, res[666].exec("ABC ", 1700)); -assertEquals(null, res[666].exec("x{c0}", 1701)); -assertEquals(null, res[666].exec("x{e0} ", 1702)); -assertEquals(null, res[666].exec("x{c0}", 1703)); -assertEquals(null, res[666].exec("x{e0} ", 1704)); -assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 1705)); -assertEquals(null, res[666].exec("** Failers", 1706)); -assertEquals(null, res[666].exec("ax{391}x{10427}x{ff3a}x{1fb0} ", 1707)); -assertEquals(null, res[666].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 1708)); -assertEquals(null, res[666].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 1709)); -assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 1710)); -assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 1711)); -assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 1712)); -assertEquals(null, res[666].exec("ax{391}x{10427}x{ff3a}x{1fb0} ", 1713)); -assertEquals(null, res[666].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 1714)); -assertEquals(null, res[666].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 1715)); -assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 1716)); -assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 1717)); -assertEquals(null, res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}", 1718)); -assertEquals(null, res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 1719)); -assertEquals(null, res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 1720)); -assertEquals(null, res[666].exec("x{391}", 1721)); -assertEquals(null, res[666].exec("x{ff3a}", 1722)); -assertEquals(null, res[666].exec("x{3b1}", 1723)); -assertEquals(null, res[666].exec("x{ff5a} ", 1724)); -assertEquals(null, res[666].exec("x{c0}", 1725)); -assertEquals(null, res[666].exec("x{e0} ", 1726)); -assertEquals(null, res[666].exec("x{104}", 1727)); -assertEquals(null, res[666].exec("x{105}", 1728)); -assertEquals(null, res[666].exec("x{109} ", 1729)); -assertEquals(null, res[666].exec("** Failers", 1730)); -assertEquals(null, res[666].exec("x{100}", 1731)); -assertEquals(null, res[666].exec("x{10a} ", 1732)); -assertEquals(null, res[666].exec("Z", 1733)); -assertEquals(null, res[666].exec("z", 1734)); -assertEquals(null, res[666].exec("x{39c}", 1735)); -assertEquals(null, res[666].exec("x{178}", 1736)); -assertEquals(null, res[666].exec("|", 1737)); -assertEquals(null, res[666].exec("x{80}", 1738)); -assertEquals(null, res[666].exec("x{ff}", 1739)); -assertEquals(null, res[666].exec("x{100}", 1740)); -assertEquals(null, res[666].exec("x{101} ", 1741)); -assertEquals(null, res[666].exec("** Failers", 1742)); -assertEquals(null, res[666].exec("x{102}", 1743)); -assertEquals(null, res[666].exec("Y", 1744)); -assertEquals(null, res[666].exec("y ", 1745)); -assertEquals(null, res[667].exec("A", 1746)); -assertEquals(null, res[667].exec("Ax{300}BC ", 1747)); -assertEquals(null, res[667].exec("Ax{300}x{301}x{302}BC ", 1748)); -assertEquals(null, res[667].exec("*** Failers", 1749)); -assertEquals(null, res[667].exec("x{300} ", 1750)); -assertEquals("X", res[668].exec("X123"), 1751); -assertEquals(null, res[668].exec("*** Failers", 1752)); -assertEquals(null, res[668].exec("AXYZ", 1753)); -assertEquals(null, res[669].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 1754)); -assertEquals(null, res[669].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 1755)); -assertEquals(null, res[670].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 1756)); -assertEquals(null, res[670].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 1757)); -assertEquals("A,,A", res[671].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 1758); -assertEquals("A,,A", res[671].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 1759); -assertEquals("A,,A", res[672].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 1760); -assertEquals("A,,A", res[672].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 1761); -assertEquals(null, res[673].exec("*** Failers", 1762)); -assertEquals(null, res[673].exec("Ax{300}x{301}x{302}", 1763)); -assertEquals(null, res[674].exec("Ax{300}x{301}Bx{300}X", 1764)); -assertEquals(null, res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 1765)); -assertEquals(null, res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 1766)); -assertEquals(null, res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 1767)); -assertEquals(null, res[675].exec("Ax{300}x{301}Bx{300}X", 1768)); -assertEquals(null, res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 1769)); -assertEquals(null, res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 1770)); -assertEquals(null, res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 1771)); -assertEquals(null, res[675].exec("x{2e81}x{3007}x{2f804}x{31a0}", 1772)); -assertEquals(null, res[675].exec("** Failers", 1773)); -assertEquals(null, res[675].exec("x{2e7f} ", 1774)); -assertEquals(null, res[675].exec("x{3105}", 1775)); -assertEquals(null, res[675].exec("** Failers", 1776)); -assertEquals(null, res[675].exec("x{30ff} ", 1777)); -assertEquals(null, res[676].exec("x{06e9}", 1778)); -assertEquals(null, res[676].exec("x{060b}", 1779)); -assertEquals(null, res[676].exec("** Failers", 1780)); -assertEquals(null, res[676].exec("Xx{06e9} ", 1781)); -assertEquals(null, res[677].exec("x{2f800}", 1782)); -assertEquals(null, res[677].exec("** Failers", 1783)); -assertEquals(null, res[677].exec("x{a014}", 1784)); -assertEquals(null, res[677].exec("x{a4c6} ", 1785)); -assertEquals(null, res[678].exec("AXYZ", 1786)); -assertEquals(null, res[678].exec("x{1234}XYZ ", 1787)); -assertEquals(null, res[678].exec("** Failers", 1788)); -assertEquals(null, res[678].exec("X ", 1789)); -assertEquals(null, res[679].exec("** Failers", 1790)); -assertEquals(null, res[679].exec("AX", 1791)); -assertEquals(null, res[680].exec("XYZ", 1792)); -assertEquals(null, res[680].exec("AXYZ", 1793)); -assertEquals(null, res[680].exec("x{1234}XYZ ", 1794)); -assertEquals(null, res[680].exec("** Failers", 1795)); -assertEquals(null, res[680].exec("ABXYZ ", 1796)); -assertEquals(null, res[681].exec("XYZ", 1797)); -assertEquals(null, res[681].exec("** Failers", 1798)); -assertEquals(null, res[681].exec("AXYZ", 1799)); -assertEquals(null, res[681].exec("x{1234}XYZ ", 1800)); -assertEquals(null, res[681].exec("ABXYZ ", 1801)); -assertEquals(null, res[681].exec("AXYZ", 1802)); -assertEquals(null, res[681].exec("x{1234}XYZ", 1803)); -assertEquals(null, res[681].exec("Ax{1234}XYZ", 1804)); -assertEquals(null, res[681].exec("** Failers", 1805)); -assertEquals(null, res[681].exec("XYZ", 1806)); -assertEquals(null, res[681].exec("** Failers", 1807)); -assertEquals(null, res[681].exec("AXYZ", 1808)); -assertEquals(null, res[681].exec("x{1234}XYZ", 1809)); -assertEquals(null, res[681].exec("Ax{1234}XYZ", 1810)); -assertEquals(null, res[681].exec("XYZ", 1811)); -assertEquals(null, res[682].exec("XYZ", 1812)); -assertEquals(null, res[682].exec("AXYZ", 1813)); -assertEquals(null, res[682].exec("x{1234}XYZ", 1814)); -assertEquals(null, res[682].exec("Ax{1234}XYZ", 1815)); -assertEquals(null, res[682].exec("** Failers", 1816)); -assertEquals(null, res[683].exec("XYZ", 1817)); -assertEquals(null, res[683].exec("** Failers", 1818)); -assertEquals(null, res[683].exec("AXYZ", 1819)); -assertEquals(null, res[683].exec("x{1234}XYZ", 1820)); -assertEquals(null, res[683].exec("Ax{1234}XYZ", 1821)); -assertEquals("AX", res[684].exec("AXYZ"), 1822); -assertEquals(null, res[684].exec("x{1234}XYZ ", 1823)); -assertEquals(null, res[684].exec("** Failers", 1824)); -assertEquals(null, res[684].exec("X ", 1825)); -assertEquals(null, res[685].exec("** Failers", 1826)); -assertEquals("AX", res[685].exec("AX"), 1827); -assertEquals("X", res[686].exec("XYZ"), 1828); -assertEquals("AX", res[686].exec("AXYZ"), 1829); -assertEquals(null, res[686].exec("x{1234}XYZ ", 1830)); -assertEquals(null, res[686].exec("** Failers", 1831)); -assertEquals(null, res[686].exec("ABXYZ ", 1832)); -assertEquals("X", res[687].exec("XYZ"), 1833); -assertEquals(null, res[687].exec("** Failers", 1834)); -assertEquals("AX", res[687].exec("AXYZ"), 1835); -assertEquals(null, res[687].exec("x{1234}XYZ ", 1836)); -assertEquals(null, res[687].exec("ABXYZ ", 1837)); -assertEquals("AX", res[688].exec("AXYZ"), 1838); -assertEquals(null, res[688].exec("x{1234}XYZ", 1839)); -assertEquals(null, res[688].exec("Ax{1234}XYZ", 1840)); -assertEquals(null, res[688].exec("** Failers", 1841)); -assertEquals(null, res[688].exec("XYZ", 1842)); -assertEquals(null, res[689].exec("** Failers", 1843)); -assertEquals("AX", res[689].exec("AXYZ"), 1844); -assertEquals(null, res[689].exec("x{1234}XYZ", 1845)); -assertEquals(null, res[689].exec("Ax{1234}XYZ", 1846)); -assertEquals(null, res[689].exec("XYZ", 1847)); -assertEquals("X", res[690].exec("XYZ"), 1848); -assertEquals("AX", res[690].exec("AXYZ"), 1849); -assertEquals(null, res[690].exec("x{1234}XYZ", 1850)); -assertEquals(null, res[690].exec("Ax{1234}XYZ", 1851)); -assertEquals(null, res[690].exec("** Failers", 1852)); -assertEquals("X", res[691].exec("XYZ"), 1853); -assertEquals(null, res[691].exec("** Failers", 1854)); -assertEquals("AX", res[691].exec("AXYZ"), 1855); -assertEquals(null, res[691].exec("x{1234}XYZ", 1856)); -assertEquals(null, res[691].exec("Ax{1234}XYZ", 1857)); -assertEquals(null, res[692].exec("abcdefgh", 1858)); -assertEquals(null, res[692].exec("x{1234}\n\x0dx{3456}xyz ", 1859)); -assertEquals(null, res[693].exec("abcdefgh", 1860)); -assertEquals(null, res[693].exec("x{1234}\n\x0dx{3456}xyz ", 1861)); -assertEquals(null, res[694].exec("** Failers", 1862)); -assertEquals(null, res[694].exec("abcdefgh", 1863)); -assertEquals(null, res[694].exec("x{1234}\n\x0dx{3456}xyz ", 1864)); -assertEquals(null, res[695].exec(" AXY", 1865)); -assertEquals(null, res[695].exec(" aXY", 1866)); -assertEquals(null, res[695].exec(" x{1c5}XY", 1867)); -assertEquals(null, res[695].exec(" ** Failers", 1868)); -assertEquals(null, res[695].exec(" x{1bb}XY", 1869)); -assertEquals(null, res[695].exec(" x{2b0}XY", 1870)); -assertEquals(null, res[695].exec(" !XY ", 1871)); -assertEquals(null, res[696].exec(" AXY", 1872)); -assertEquals(null, res[696].exec(" aXY", 1873)); -assertEquals(null, res[696].exec(" x{1c5}XY", 1874)); -assertEquals(null, res[696].exec(" ** Failers", 1875)); -assertEquals(null, res[696].exec(" x{1bb}XY", 1876)); -assertEquals(null, res[696].exec(" x{2b0}XY", 1877)); -assertEquals(null, res[696].exec(" !XY ", 1878)); -assertEquals(null, res[696].exec(" AXY", 1879)); -assertEquals(null, res[696].exec(" aXY", 1880)); -assertEquals(null, res[696].exec(" AbcdeXyz ", 1881)); -assertEquals(null, res[696].exec(" x{1c5}AbXY", 1882)); -assertEquals(null, res[696].exec(" abcDEXypqreXlmn ", 1883)); -assertEquals(null, res[696].exec(" ** Failers", 1884)); -assertEquals(null, res[696].exec(" x{1bb}XY", 1885)); -assertEquals(null, res[696].exec(" x{2b0}XY", 1886)); -assertEquals(null, res[696].exec(" !XY ", 1887)); -assertEquals(null, res[697].exec(" AXY", 1888)); -assertEquals(null, res[697].exec(" aXY", 1889)); -assertEquals(null, res[697].exec(" AbcdeXyz ", 1890)); -assertEquals(null, res[697].exec(" x{1c5}AbXY", 1891)); -assertEquals(null, res[697].exec(" abcDEXypqreXlmn ", 1892)); -assertEquals(null, res[697].exec(" ** Failers", 1893)); -assertEquals(null, res[697].exec(" x{1bb}XY", 1894)); -assertEquals(null, res[697].exec(" x{2b0}XY", 1895)); -assertEquals(null, res[697].exec(" !XY ", 1896)); -assertEquals(null, res[697].exec(" AXY", 1897)); -assertEquals(null, res[697].exec(" aXY", 1898)); -assertEquals(null, res[697].exec(" AbcdeXyz ", 1899)); -assertEquals(null, res[697].exec(" x{1c5}AbXY", 1900)); -assertEquals(null, res[697].exec(" abcDEXypqreXlmn ", 1901)); -assertEquals(null, res[697].exec(" ** Failers", 1902)); -assertEquals(null, res[697].exec(" x{1bb}XY", 1903)); -assertEquals(null, res[697].exec(" x{2b0}XY", 1904)); -assertEquals(null, res[697].exec(" !XY ", 1905)); -assertEquals(null, res[698].exec(" AXY", 1906)); -assertEquals(null, res[698].exec(" aXY", 1907)); -assertEquals(null, res[698].exec(" AbcdeXyz ", 1908)); -assertEquals(null, res[698].exec(" x{1c5}AbXY", 1909)); -assertEquals(null, res[698].exec(" abcDEXypqreXlmn ", 1910)); -assertEquals(null, res[698].exec(" ** Failers", 1911)); -assertEquals(null, res[698].exec(" x{1bb}XY", 1912)); -assertEquals(null, res[698].exec(" x{2b0}XY", 1913)); -assertEquals(null, res[698].exec(" !XY ", 1914)); -assertEquals(null, res[699].exec(" !XY", 1915)); -assertEquals(null, res[699].exec(" x{1bb}XY", 1916)); -assertEquals(null, res[699].exec(" x{2b0}XY", 1917)); -assertEquals(null, res[699].exec(" ** Failers", 1918)); -assertEquals(null, res[699].exec(" x{1c5}XY", 1919)); -assertEquals(null, res[699].exec(" AXY ", 1920)); -assertEquals(null, res[700].exec(" !XY", 1921)); -assertEquals(null, res[700].exec(" x{1bb}XY", 1922)); -assertEquals(null, res[700].exec(" x{2b0}XY", 1923)); -assertEquals(null, res[700].exec(" ** Failers", 1924)); -assertEquals(null, res[700].exec(" x{1c5}XY", 1925)); -assertEquals(null, res[700].exec(" AXY ", 1926)); -assertEquals(null, res[701].exec("\xa0!", 1927)); -assertEquals(null, res[701].exec("AabcabcYZ ", 1928)); -assertEquals("L=abcX,L=abc,abc", res[702].exec("L=abcX"), 1929); -assertEquals(null, res[702].exec("x{c0}", 1930)); -assertEquals(null, res[702].exec("x{e0} ", 1931)); -assertEquals(null, res[702].exec("x{c0}", 1932)); -assertEquals(null, res[702].exec("x{e0} ", 1933)); -assertEquals(null, res[703].exec("x{1b00}x{12000}x{7c0}x{a840}x{10900}", 1934)); -assertEquals(null, res[706].exec("123abcdefg", 1935)); -assertEquals(null, res[706].exec("123abc\xc4\xc5zz", 1936)); -assertEquals(null, res[710].exec("A\x80", 1937)); -assertEquals(null, res[725].exec("x{60e} ", 1938)); -assertEquals(null, res[725].exec("x{656} ", 1939)); -assertEquals(null, res[725].exec("x{657} ", 1940)); -assertEquals(null, res[725].exec("x{658} ", 1941)); -assertEquals(null, res[725].exec("x{659} ", 1942)); -assertEquals(null, res[725].exec("x{65a} ", 1943)); -assertEquals(null, res[725].exec("x{65b} ", 1944)); -assertEquals(null, res[725].exec("x{65c} ", 1945)); -assertEquals(null, res[725].exec("x{65d} ", 1946)); -assertEquals(null, res[725].exec("x{65e} ", 1947)); -assertEquals(null, res[725].exec("x{66a} ", 1948)); -assertEquals(null, res[725].exec("x{6e9} ", 1949)); -assertEquals(null, res[725].exec("x{6ef}", 1950)); -assertEquals(null, res[725].exec("x{6fa} ", 1951)); -assertEquals(null, res[725].exec("** Failers", 1952)); -assertEquals(null, res[725].exec("x{600}", 1953)); -assertEquals(null, res[725].exec("x{650}", 1954)); -assertEquals(null, res[725].exec("x{651} ", 1955)); -assertEquals(null, res[725].exec("x{652} ", 1956)); -assertEquals(null, res[725].exec("x{653} ", 1957)); -assertEquals(null, res[725].exec("x{654} ", 1958)); -assertEquals(null, res[725].exec("x{655} ", 1959)); -assertEquals(null, res[725].exec("x{65f} ", 1960)); -assertEquals(null, res[726].exec("x{1d2b} ", 1961)); -assertEquals(null, res[727].exec("x{589}", 1962)); -assertEquals(null, res[727].exec("x{60c}", 1963)); -assertEquals(null, res[727].exec("x{61f} ", 1964)); -assertEquals(null, res[727].exec("x{964}", 1965)); -assertEquals(null, res[727].exec("x{965} ", 1966)); -assertEquals(null, res[727].exec("x{970} ", 1967)); -assertEquals(null, res[728].exec("x{64b}", 1968)); -assertEquals(null, res[728].exec("x{654}", 1969)); -assertEquals(null, res[728].exec("x{655}", 1970)); -assertEquals(null, res[728].exec("x{200c} ", 1971)); -assertEquals(null, res[728].exec("** Failers", 1972)); -assertEquals(null, res[728].exec("x{64a}", 1973)); -assertEquals(null, res[728].exec("x{656} ", 1974)); -assertEquals(null, res[729].exec("x{10450}", 1975)); -assertEquals(null, res[729].exec("x{1047f}", 1976)); -assertEquals(null, res[730].exec("x{10400}", 1977)); -assertEquals(null, res[730].exec("x{1044f}", 1978)); -assertEquals(null, res[731].exec("x{10480}", 1979)); -assertEquals(null, res[731].exec("x{1049d}", 1980)); -assertEquals(null, res[731].exec("x{104a0}", 1981)); -assertEquals(null, res[731].exec("x{104a9}", 1982)); -assertEquals(null, res[731].exec("** Failers", 1983)); -assertEquals(null, res[731].exec("x{1049e}", 1984)); -assertEquals(null, res[731].exec("x{1049f}", 1985)); -assertEquals(null, res[731].exec("x{104aa} ", 1986)); -assertEquals(null, res[731].exec("\xe2\x80\xa8\xe2\x80\xa8", 1987)); -assertEquals(null, res[731].exec("x{2028}x{2028}x{2028}", 1988)); -assertEquals(null, res[732].exec("x{c0}x{e0}x{116}x{117}", 1989)); -assertEquals(null, res[732].exec("x{c0}x{e0}x{116}x{117}", 1990)); -assertEquals(null, res[733].exec("x{102A4}x{AA52}x{A91D}x{1C46}x{10283}x{1092E}x{1C6B}x{A93B}x{A8BF}x{1BA0}x{A50A}====", 1991)); -assertEquals(null, res[733].exec("x{a77d}x{1d79}", 1992)); -assertEquals(null, res[733].exec("x{1d79}x{a77d} ", 1993)); -assertEquals(null, res[733].exec("x{a77d}x{1d79}", 1994)); -assertEquals(null, res[733].exec("** Failers ", 1995)); -assertEquals(null, res[733].exec("x{1d79}x{a77d} ", 1996)); -assertEquals("AA,A", res[734].exec("AA"), 1997); -assertEquals("Aa,A", res[734].exec("Aa"), 1998); -assertEquals("aa,a", res[734].exec("aa"), 1999); -assertEquals("aA,a", res[734].exec("aA"), 2000); -assertEquals(null, res[734].exec("x{de}x{de}", 2001)); -assertEquals(null, res[734].exec("x{de}x{fe}", 2002)); -assertEquals(null, res[734].exec("x{fe}x{fe}", 2003)); -assertEquals(null, res[734].exec("x{fe}x{de}", 2004)); -assertEquals(null, res[734].exec("x{10a}x{10a}", 2005)); -assertEquals(null, res[734].exec("x{10a}x{10b}", 2006)); -assertEquals(null, res[734].exec("x{10b}x{10b}", 2007)); -assertEquals(null, res[734].exec("x{10b}x{10a}", 2008)); -assertEquals("abc", res[736].exec("abc"), 2009); -assertEquals("abc", res[737].exec("abc"), 2010); -assertEquals("abbbbc", res[737].exec("abbbbc"), 2011); -assertEquals("ac", res[737].exec("ac"), 2012); -assertEquals("abc", res[738].exec("abc"), 2013); -assertEquals("abbbbbbc", res[738].exec("abbbbbbc"), 2014); -assertEquals(null, res[738].exec("*** Failers ", 2015)); -assertEquals(null, res[738].exec("ac", 2016)); -assertEquals(null, res[738].exec("ab", 2017)); -assertEquals("a", res[739].exec("a"), 2018); -assertEquals("aaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaa"), 2019); -assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "), 2020); -assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaF "), 2021); -assertEquals("a,a", res[740].exec("a"), 2022); -assertEquals("a,a", res[740].exec("abcd"), 2023); -assertEquals("a,a", res[740].exec("african"), 2024); -assertEquals("abc", res[741].exec("abcdef"), 2025); -assertEquals(null, res[741].exec("*** Failers", 2026)); -assertEquals(null, res[741].exec("xyzabc", 2027)); -assertEquals(null, res[741].exec("xyz\nabc ", 2028)); -assertEquals("abc", res[742].exec("abcdef"), 2029); -assertEquals("abc", res[742].exec("xyz\nabc "), 2030); -assertEquals(null, res[742].exec("*** Failers", 2031)); -assertEquals(null, res[742].exec("xyzabc", 2032)); -assertEquals(null, res[743].exec("abcdef", 2033)); -assertEquals(null, res[743].exec("*** Failers", 2034)); -assertEquals(null, res[743].exec("xyzabc", 2035)); -assertEquals(null, res[743].exec("xyz\nabc ", 2036)); -assertEquals(null, res[744].exec("abcdef", 2037)); -assertEquals(null, res[744].exec("*** Failers", 2038)); -assertEquals(null, res[744].exec("xyzabc", 2039)); -assertEquals(null, res[744].exec("xyz\nabc ", 2040)); -assertEquals(null, res[745].exec("abcdef", 2041)); -assertEquals(null, res[745].exec("xyzabc>3", 2042)); -assertEquals(null, res[745].exec("*** Failers", 2043)); -assertEquals(null, res[745].exec("xyzabc ", 2044)); -assertEquals(null, res[745].exec("xyzabc>2 ", 2045)); -assertEquals("x9yzz", res[746].exec("x9yzz"), 2046); -assertEquals("x0y+z", res[746].exec("x0y+z"), 2047); -assertEquals(null, res[746].exec("*** Failers", 2048)); -assertEquals(null, res[746].exec("xyz", 2049)); -assertEquals(null, res[746].exec("xxy0z ", 2050)); -assertEquals("x yzz", res[747].exec("x yzz"), 2051); -assertEquals("x y+z", res[747].exec("x y+z"), 2052); -assertEquals(null, res[747].exec("*** Failers", 2053)); -assertEquals(null, res[747].exec("xyz", 2054)); -assertEquals(null, res[747].exec("xxyyz", 2055)); -assertEquals("xxy+z", res[748].exec("xxy+z"), 2056); -assertEquals(null, res[748].exec("*** Failers", 2057)); -assertEquals(null, res[748].exec("xxy0z", 2058)); -assertEquals(null, res[748].exec("x+y+z ", 2059)); -assertEquals("x+y", res[749].exec("x+y"), 2060); -assertEquals("x-y", res[749].exec("x-y"), 2061); -assertEquals(null, res[749].exec("*** Failers", 2062)); -assertEquals(null, res[749].exec("x\ny", 2063)); -assertEquals("x+y", res[750].exec("x+y"), 2064); -assertEquals("x-y", res[750].exec("x-y"), 2065); -assertEquals(null, res[750].exec("x\ny", 2066)); -assertEquals(null, res[750].exec("a+bc+dp+q", 2067)); -assertEquals(null, res[750].exec("a+bc\ndp+q", 2068)); -assertEquals(null, res[750].exec("x\nyp+q ", 2069)); -assertEquals(null, res[750].exec("*** Failers ", 2070)); -assertEquals(null, res[750].exec("a\nbc\ndp+q", 2071)); -assertEquals(null, res[750].exec("a+bc\ndp\nq", 2072)); -assertEquals(null, res[750].exec("x\nyp\nq ", 2073)); -assertEquals(null, res[751].exec("ba0", 2074)); -assertEquals(null, res[751].exec("*** Failers", 2075)); -assertEquals(null, res[751].exec("ba0\n", 2076)); -assertEquals(null, res[751].exec("ba0\ncd ", 2077)); -assertEquals(null, res[752].exec("ba0", 2078)); -assertEquals(null, res[752].exec("*** Failers", 2079)); -assertEquals(null, res[752].exec("ba0\n", 2080)); -assertEquals(null, res[752].exec("ba0\ncd ", 2081)); -assertEquals(null, res[753].exec("ba0", 2082)); -assertEquals(null, res[753].exec("ba0\n", 2083)); -assertEquals(null, res[753].exec("*** Failers", 2084)); -assertEquals(null, res[753].exec("ba0\ncd ", 2085)); -assertEquals(null, res[754].exec("ba0", 2086)); -assertEquals(null, res[754].exec("ba0\n", 2087)); -assertEquals(null, res[754].exec("*** Failers", 2088)); -assertEquals(null, res[754].exec("ba0\ncd ", 2089)); -assertEquals("a0", res[755].exec("ba0"), 2090); -assertEquals(null, res[755].exec("ba0\n", 2091)); -assertEquals(null, res[755].exec("*** Failers", 2092)); -assertEquals(null, res[755].exec("ba0\ncd ", 2093)); -assertEquals("a0", res[756].exec("ba0"), 2094); -assertEquals("a0", res[756].exec("ba0\n"), 2095); -assertEquals("a0", res[756].exec("ba0\ncd "), 2096); -assertEquals(null, res[756].exec("*** Failers", 2097)); -assertEquals("abc", res[757].exec("abc"), 2098); -assertEquals("aBc", res[757].exec("aBc"), 2099); -assertEquals("ABC", res[757].exec("ABC"), 2100); -assertEquals("b", res[758].exec("abcd"), 2101); -assertEquals("abz", res[759].exec("abz"), 2102); -assertEquals("abb", res[759].exec("abbz"), 2103); -assertEquals("az", res[759].exec("azz "), 2104); -assertEquals("yz", res[760].exec("ayzq"), 2105); -assertEquals("xyz", res[760].exec("axyzq"), 2106); -assertEquals("xxyz", res[760].exec("axxyz"), 2107); -assertEquals("xxxyz", res[760].exec("axxxyzq"), 2108); -assertEquals("xxxyz", res[760].exec("axxxxyzq"), 2109); -assertEquals(null, res[760].exec("*** Failers", 2110)); -assertEquals(null, res[760].exec("ax", 2111)); -assertEquals(null, res[760].exec("axx ", 2112)); -assertEquals(null, res[760].exec(" ", 2113)); -assertEquals("xxxyz", res[761].exec("axxxyzq"), 2114); -assertEquals("xxxyz", res[761].exec("axxxxyzq"), 2115); -assertEquals(null, res[761].exec("*** Failers", 2116)); -assertEquals(null, res[761].exec("ax", 2117)); -assertEquals(null, res[761].exec("axx ", 2118)); -assertEquals(null, res[761].exec("ayzq", 2119)); -assertEquals(null, res[761].exec("axyzq", 2120)); -assertEquals(null, res[761].exec("axxyz", 2121)); -assertEquals(null, res[761].exec(" ", 2122)); -assertEquals("xxyz", res[762].exec("axxyz"), 2123); -assertEquals("xxxyz", res[762].exec("axxxyzq"), 2124); -assertEquals("xxxyz", res[762].exec("axxxxyzq"), 2125); -assertEquals(null, res[762].exec("*** Failers", 2126)); -assertEquals(null, res[762].exec("ax", 2127)); -assertEquals(null, res[762].exec("axx ", 2128)); -assertEquals(null, res[762].exec("ayzq", 2129)); -assertEquals(null, res[762].exec("axyzq", 2130)); -assertEquals(null, res[762].exec(" ", 2131)); -assertEquals("b", res[763].exec("bac"), 2132); -assertEquals("bcdef", res[763].exec("bcdefax"), 2133); -assertEquals("*** F", res[763].exec("*** Failers"), 2134); -assertEquals(" ", res[763].exec("aaaaa "), 2135); -assertEquals("b", res[764].exec("bac"), 2136); -assertEquals("bcdef", res[764].exec("bcdefax"), 2137); -assertEquals("*** F", res[764].exec("*** Failers"), 2138); -assertEquals("", res[764].exec("aaaaa "), 2139); -assertEquals("xyz", res[765].exec("xyz"), 2140); -assertEquals("wxyz", res[765].exec("awxyza"), 2141); -assertEquals("bcdef", res[765].exec("abcdefa"), 2142); -assertEquals("bcdef", res[765].exec("abcdefghijk"), 2143); -assertEquals("*** F", res[765].exec("*** Failers"), 2144); -assertEquals(null, res[765].exec("axya", 2145)); -assertEquals(null, res[765].exec("axa", 2146)); -assertEquals(" ", res[765].exec("aaaaa "), 2147); -assertEquals("1234", res[766].exec("1234b567"), 2148); -assertEquals("", res[766].exec("xyz"), 2149); -assertEquals("a", res[767].exec("a1234b567"), 2150); -assertEquals("xyz", res[767].exec("xyz"), 2151); -assertEquals(" ", res[767].exec(" "), 2152); -assertEquals("1234", res[768].exec("ab1234c56"), 2153); -assertEquals(null, res[768].exec("*** Failers", 2154)); -assertEquals(null, res[768].exec("xyz", 2155)); -assertEquals("ab", res[769].exec("ab123c56"), 2156); -assertEquals("*** Failers", res[769].exec("*** Failers"), 2157); -assertEquals(null, res[769].exec("789", 2158)); -assertEquals("5A", res[770].exec("045ABC"), 2159); -assertEquals("A", res[770].exec("ABC"), 2160); -assertEquals(null, res[770].exec("*** Failers", 2161)); -assertEquals(null, res[770].exec("XYZ", 2162)); -assertEquals("A", res[771].exec("ABC"), 2163); -assertEquals("BA", res[771].exec("BAC"), 2164); -assertEquals("A", res[771].exec("9ABC "), 2165); -assertEquals(null, res[771].exec("*** Failers", 2166)); -assertEquals("aaaa", res[772].exec("aaaa"), 2167); -assertEquals("xyz", res[773].exec("xyz"), 2168); -assertEquals("ggggggggxyz", res[773].exec("ggggggggxyz"), 2169); -assertEquals("abcdxyz", res[774].exec("abcdxyz"), 2170); -assertEquals("axyz", res[774].exec("axyz"), 2171); -assertEquals(null, res[774].exec("*** Failers", 2172)); -assertEquals(null, res[774].exec("xyz", 2173)); -assertEquals("xyz", res[775].exec("xyz"), 2174); -assertEquals("cxyz", res[775].exec("cxyz "), 2175); -assertEquals("12X", res[776].exec("12X"), 2176); -assertEquals("123X", res[776].exec("123X"), 2177); -assertEquals(null, res[776].exec("*** Failers", 2178)); -assertEquals(null, res[776].exec("X", 2179)); -assertEquals(null, res[776].exec("1X", 2180)); -assertEquals(null, res[776].exec("1234X ", 2181)); -assertEquals("a4", res[777].exec("a45"), 2182); -assertEquals("b9", res[777].exec("b93"), 2183); -assertEquals("c9", res[777].exec("c99z"), 2184); -assertEquals("d0", res[777].exec("d04"), 2185); -assertEquals(null, res[777].exec("*** Failers", 2186)); -assertEquals(null, res[777].exec("e45", 2187)); -assertEquals(null, res[777].exec("abcd ", 2188)); -assertEquals(null, res[777].exec("abcd1234", 2189)); -assertEquals(null, res[777].exec("1234 ", 2190)); -assertEquals("a4", res[778].exec("a45"), 2191); -assertEquals("b9", res[778].exec("b93"), 2192); -assertEquals("c9", res[778].exec("c99z"), 2193); -assertEquals("d0", res[778].exec("d04"), 2194); -assertEquals("abcd1", res[778].exec("abcd1234"), 2195); -assertEquals("1", res[778].exec("1234 "), 2196); -assertEquals(null, res[778].exec("*** Failers", 2197)); -assertEquals(null, res[778].exec("e45", 2198)); -assertEquals(null, res[778].exec("abcd ", 2199)); -assertEquals("a4", res[779].exec("a45"), 2200); -assertEquals("b9", res[779].exec("b93"), 2201); -assertEquals("c9", res[779].exec("c99z"), 2202); -assertEquals("d0", res[779].exec("d04"), 2203); -assertEquals("abcd1", res[779].exec("abcd1234"), 2204); -assertEquals(null, res[779].exec("*** Failers", 2205)); -assertEquals(null, res[779].exec("1234 ", 2206)); -assertEquals(null, res[779].exec("e45", 2207)); -assertEquals(null, res[779].exec("abcd ", 2208)); -assertEquals("aX", res[780].exec("aX"), 2209); -assertEquals("aaX", res[780].exec("aaX "), 2210); -assertEquals("a4", res[781].exec("a45"), 2211); -assertEquals("b9", res[781].exec("b93"), 2212); -assertEquals("c9", res[781].exec("c99z"), 2213); -assertEquals("d0", res[781].exec("d04"), 2214); -assertEquals("1", res[781].exec("1234 "), 2215); -assertEquals(null, res[781].exec("*** Failers", 2216)); -assertEquals(null, res[781].exec("abcd1234", 2217)); -assertEquals(null, res[781].exec("e45", 2218)); -assertEquals("ab4", res[782].exec("ab45"), 2219); -assertEquals("bcd9", res[782].exec("bcd93"), 2220); -assertEquals(null, res[782].exec("*** Failers", 2221)); -assertEquals(null, res[782].exec("1234 ", 2222)); -assertEquals(null, res[782].exec("a36 ", 2223)); -assertEquals(null, res[782].exec("abcd1234", 2224)); -assertEquals(null, res[782].exec("ee45", 2225)); -assertEquals("abc4,abc", res[783].exec("abc45"), 2226); -assertEquals("abcabcabc4,abc", res[783].exec("abcabcabc45"), 2227); -assertEquals("4,", res[783].exec("42xyz "), 2228); -assertEquals(null, res[783].exec("*** Failers", 2229)); -assertEquals("abc4,abc", res[784].exec("abc45"), 2230); -assertEquals("abcabcabc4,abc", res[784].exec("abcabcabc45"), 2231); -assertEquals(null, res[784].exec("*** Failers", 2232)); -assertEquals(null, res[784].exec("42xyz ", 2233)); -assertEquals("abc4,abc", res[785].exec("abc45"), 2234); -assertEquals("4,", res[785].exec("42xyz "), 2235); -assertEquals(null, res[785].exec("*** Failers", 2236)); -assertEquals(null, res[785].exec("abcabcabc45", 2237)); -assertEquals("abcabc4,abc", res[786].exec("abcabc45"), 2238); -assertEquals("abcabcabc4,abc", res[786].exec("abcabcabc45"), 2239); -assertEquals(null, res[786].exec("*** Failers", 2240)); -assertEquals(null, res[786].exec("abcabcabcabc45", 2241)); -assertEquals(null, res[786].exec("abc45", 2242)); -assertEquals(null, res[786].exec("42xyz ", 2243)); -assertEquals(null, res[786].exec("1abc2abc3456", 2244)); -assertEquals(null, res[786].exec("1abc2xyz3456 ", 2245)); -assertEquals("ab=ab,ab,ab", res[787].exec("ab=ab"), 2246); -assertEquals("ab=ab,ab,ab", res[787].exec("ab=ab"), 2247); -assertEquals(null, res[787].exec("abc", 2248)); -assertEquals(null, res[787].exec("a(b)c", 2249)); -assertEquals(null, res[787].exec("a(b(c))d ", 2250)); -assertEquals(null, res[787].exec("*** Failers)", 2251)); -assertEquals(null, res[787].exec("a(b(c)d ", 2252)); -assertEquals(null, res[787].exec(">abc>123abc>1(2)3abc>(1(2)3)", 2259)); -assertEquals(null, res[787].exec("", 2260)); -assertEquals(null, res[787].exec(" hij>", 2261)); -assertEquals(null, res[787].exec(" hij>", 2262)); -assertEquals(null, res[787].exec("def> ", 2263)); -assertEquals(null, res[787].exec(" ", 2264)); -assertEquals(null, res[787].exec("*** Failers", 2265)); -assertEquals(null, res[787].exec("3 ", 2323)); -assertEquals(null, res[795].exec("*** Failers ", 2324)); -assertEquals(null, res[795].exec("defabcxyz", 2325)); -assertEquals(null, res[796].exec("abP", 2326)); -assertEquals(null, res[796].exec("abcdeP", 2327)); -assertEquals("abcdef", res[796].exec("abcdefP"), 2328); -assertEquals(null, res[796].exec("*** Failers", 2329)); -assertEquals(null, res[796].exec("abxP ", 2330)); -assertEquals(null, res[797].exec("aP", 2331)); -assertEquals(null, res[797].exec("aaP", 2332)); -assertEquals(null, res[797].exec("aa2P ", 2333)); -assertEquals(null, res[797].exec("aaaP", 2334)); -assertEquals(null, res[797].exec("aaa23P ", 2335)); -assertEquals(null, res[797].exec("aaaa12345P", 2336)); -assertEquals("aa0z", res[797].exec("aa0zP"), 2337); -assertEquals("aaaa4444444444444z", res[797].exec("aaaa4444444444444zP "), 2338); -assertEquals(null, res[797].exec("*** Failers", 2339)); -assertEquals(null, res[797].exec("azP ", 2340)); -assertEquals(null, res[797].exec("aaaaaP ", 2341)); -assertEquals(null, res[797].exec("a56P ", 2342)); -assertEquals(null, res[799].exec("adfadadaklhlkalkajhlkjahdfasdfasdfladsfjkjPZ", 2343)); -assertEquals(null, res[799].exec("lkjhlkjhlkjhlkjhabbbbbbcdaefabbbbbbbefaPBZ", 2344)); -assertEquals(null, res[799].exec("cdabbbbbbbbPRBZ", 2345)); -assertEquals(null, res[799].exec("efabbbbbbbbbbbbbbbbPRBZ", 2346)); -assertEquals(null, res[799].exec("bbbbbbbbbbbbcdXyasdfadfPRBZ ", 2347)); -assertEquals(null, res[799].exec("abc", 2348)); -assertEquals(null, res[799].exec("** Failers", 2349)); -assertEquals(null, res[799].exec("def ", 2350)); -assertEquals("the quick brown fox", res[800].exec("the quick brown fox"), 2351); -assertEquals(null, res[800].exec("The quick brown FOX", 2352)); -assertEquals("the quick brown fox", res[800].exec("What do you know about the quick brown fox?"), 2353); -assertEquals(null, res[800].exec("What do you know about THE QUICK BROWN FOX?", 2354)); -assertEquals("the quick brown fox", res[801].exec("the quick brown fox"), 2355); -assertEquals("The quick brown FOX", res[801].exec("The quick brown FOX"), 2356); -assertEquals("the quick brown fox", res[801].exec("What do you know about the quick brown fox?"), 2357); -assertEquals("THE QUICK BROWN FOX", res[801].exec("What do you know about THE QUICK BROWN FOX?"), 2358); -assertEquals("abcd\x09\n\x0d\x0cae9;$\\?caxyz", res[802].exec("abcd\x09\n\x0d\x0cae9;$\\?caxyz"), 2359); -assertEquals("abxyzpqrrrabbxyyyypqAzz", res[803].exec("abxyzpqrrrabbxyyyypqAzz"), 2360); -assertEquals("abxyzpqrrrabbxyyyypqAzz", res[803].exec("abxyzpqrrrabbxyyyypqAzz"), 2361); -assertEquals("aabxyzpqrrrabbxyyyypqAzz", res[803].exec("aabxyzpqrrrabbxyyyypqAzz"), 2362); -assertEquals("aaabxyzpqrrrabbxyyyypqAzz", res[803].exec("aaabxyzpqrrrabbxyyyypqAzz"), 2363); -assertEquals("aaaabxyzpqrrrabbxyyyypqAzz", res[803].exec("aaaabxyzpqrrrabbxyyyypqAzz"), 2364); -assertEquals("abcxyzpqrrrabbxyyyypqAzz", res[803].exec("abcxyzpqrrrabbxyyyypqAzz"), 2365); -assertEquals("aabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aabcxyzpqrrrabbxyyyypqAzz"), 2366); -assertEquals("aaabcxyzpqrrrabbxyyyypAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypAzz"), 2367); -assertEquals("aaabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqAzz"), 2368); -assertEquals("aaabcxyzpqrrrabbxyyyypqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqAzz"), 2369); -assertEquals("aaabcxyzpqrrrabbxyyyypqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqAzz"), 2370); -assertEquals("aaabcxyzpqrrrabbxyyyypqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqAzz"), 2371); -assertEquals("aaabcxyzpqrrrabbxyyyypqqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqAzz"), 2372); -assertEquals("aaabcxyzpqrrrabbxyyyypqqqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqqAzz"), 2373); -assertEquals("aaaabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aaaabcxyzpqrrrabbxyyyypqAzz"), 2374); -assertEquals("abxyzzpqrrrabbxyyyypqAzz", res[803].exec("abxyzzpqrrrabbxyyyypqAzz"), 2375); -assertEquals("aabxyzzzpqrrrabbxyyyypqAzz", res[803].exec("aabxyzzzpqrrrabbxyyyypqAzz"), 2376); -assertEquals("aaabxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaabxyzzzzpqrrrabbxyyyypqAzz"), 2377); -assertEquals("aaaabxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaaabxyzzzzpqrrrabbxyyyypqAzz"), 2378); -assertEquals("abcxyzzpqrrrabbxyyyypqAzz", res[803].exec("abcxyzzpqrrrabbxyyyypqAzz"), 2379); -assertEquals("aabcxyzzzpqrrrabbxyyyypqAzz", res[803].exec("aabcxyzzzpqrrrabbxyyyypqAzz"), 2380); -assertEquals("aaabcxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaabcxyzzzzpqrrrabbxyyyypqAzz"), 2381); -assertEquals("aaaabcxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbxyyyypqAzz"), 2382); -assertEquals("aaaabcxyzzzzpqrrrabbbxyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyypqAzz"), 2383); -assertEquals("aaaabcxyzzzzpqrrrabbbxyyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyyypqAzz"), 2384); -assertEquals("aaabcxyzpqrrrabbxyyyypABzz", res[803].exec("aaabcxyzpqrrrabbxyyyypABzz"), 2385); -assertEquals("aaabcxyzpqrrrabbxyyyypABBzz", res[803].exec("aaabcxyzpqrrrabbxyyyypABBzz"), 2386); -assertEquals("aaabxyzpqrrrabbxyyyypqAzz", res[803].exec(">>>aaabxyzpqrrrabbxyyyypqAzz"), 2387); -assertEquals("aaaabxyzpqrrrabbxyyyypqAzz", res[803].exec(">aaaabxyzpqrrrabbxyyyypqAzz"), 2388); -assertEquals("abcxyzpqrrrabbxyyyypqAzz", res[803].exec(">>>>abcxyzpqrrrabbxyyyypqAzz"), 2389); -assertEquals(null, res[803].exec("*** Failers", 2390)); -assertEquals(null, res[803].exec("abxyzpqrrabbxyyyypqAzz", 2391)); -assertEquals(null, res[803].exec("abxyzpqrrrrabbxyyyypqAzz", 2392)); -assertEquals(null, res[803].exec("abxyzpqrrrabxyyyypqAzz", 2393)); -assertEquals(null, res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz", 2394)); -assertEquals(null, res[803].exec("aaaabcxyzzzzpqrrrabbbxyyypqAzz", 2395)); -assertEquals(null, res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqqqAzz", 2396)); -assertEquals("abczz,abc", res[804].exec("abczz"), 2397); -assertEquals("abcabczz,abc", res[804].exec("abcabczz"), 2398); -assertEquals(null, res[804].exec("*** Failers", 2399)); -assertEquals(null, res[804].exec("zz", 2400)); -assertEquals(null, res[804].exec("abcabcabczz", 2401)); -assertEquals(null, res[804].exec(">>abczz", 2402)); -assertEquals("bc,b", res[805].exec("bc"), 2403); -assertEquals("bbc,b", res[805].exec("bbc"), 2404); -assertEquals("bbbc,bb", res[805].exec("bbbc"), 2405); -assertEquals("bac,a", res[805].exec("bac"), 2406); -assertEquals("bbac,a", res[805].exec("bbac"), 2407); -assertEquals("aac,a", res[805].exec("aac"), 2408); -assertEquals("abbbbbbbbbbbc,bbbbbbbbbbb", res[805].exec("abbbbbbbbbbbc"), 2409); -assertEquals("bbbbbbbbbbbac,a", res[805].exec("bbbbbbbbbbbac"), 2410); -assertEquals(null, res[805].exec("*** Failers", 2411)); -assertEquals(null, res[805].exec("aaac", 2412)); -assertEquals(null, res[805].exec("abbbbbbbbbbbac", 2413)); -assertEquals("bc,b", res[806].exec("bc"), 2414); -assertEquals("bbc,bb", res[806].exec("bbc"), 2415); -assertEquals("bbbc,bbb", res[806].exec("bbbc"), 2416); -assertEquals("bac,a", res[806].exec("bac"), 2417); -assertEquals("bbac,a", res[806].exec("bbac"), 2418); -assertEquals("aac,a", res[806].exec("aac"), 2419); -assertEquals("abbbbbbbbbbbc,bbbbbbbbbbb", res[806].exec("abbbbbbbbbbbc"), 2420); -assertEquals("bbbbbbbbbbbac,a", res[806].exec("bbbbbbbbbbbac"), 2421); -assertEquals(null, res[806].exec("*** Failers", 2422)); -assertEquals(null, res[806].exec("aaac", 2423)); -assertEquals(null, res[806].exec("abbbbbbbbbbbac", 2424)); -assertEquals("bbc,bb", res[806].exec("bbc"), 2425); -assertEquals("babc,ba", res[807].exec("babc"), 2426); -assertEquals("bbabc,ba", res[807].exec("bbabc"), 2427); -assertEquals("bababc,ba", res[807].exec("bababc"), 2428); -assertEquals(null, res[807].exec("*** Failers", 2429)); -assertEquals(null, res[807].exec("bababbc", 2430)); -assertEquals(null, res[807].exec("babababc", 2431)); -assertEquals("babc,ba", res[808].exec("babc"), 2432); -assertEquals("bbabc,ba", res[808].exec("bbabc"), 2433); -assertEquals("bababc,ba", res[808].exec("bababc"), 2434); -assertEquals(null, res[808].exec("*** Failers", 2435)); -assertEquals(null, res[808].exec("bababbc", 2436)); -assertEquals(null, res[808].exec("babababc", 2437)); -assertThrows("var re = /^\\ca\\cA\\c[\\c{\\c:/;", 2438); -assertEquals(null, res[808].exec("\x01\x01e;z", 2439)); -assertEquals("a", res[809].exec("athing"), 2440); -assertEquals("b", res[809].exec("bthing"), 2441); -assertEquals("]", res[809].exec("]thing"), 2442); -assertEquals("c", res[809].exec("cthing"), 2443); -assertEquals("d", res[809].exec("dthing"), 2444); -assertEquals("e", res[809].exec("ething"), 2445); -assertEquals(null, res[809].exec("*** Failers", 2446)); -assertEquals(null, res[809].exec("fthing", 2447)); -assertEquals(null, res[809].exec("[thing", 2448)); -assertEquals(null, res[809].exec("\\thing", 2449)); -assertEquals(null, res[810].exec("]thing", 2450)); -assertEquals(null, res[810].exec("cthing", 2451)); -assertEquals(null, res[810].exec("dthing", 2452)); -assertEquals(null, res[810].exec("ething", 2453)); -assertEquals(null, res[810].exec("*** Failers", 2454)); -assertEquals(null, res[810].exec("athing", 2455)); -assertEquals(null, res[810].exec("fthing", 2456)); -assertEquals("f", res[811].exec("fthing"), 2457); -assertEquals("[", res[811].exec("[thing"), 2458); -assertEquals("\\", res[811].exec("\\thing"), 2459); -assertEquals("*", res[811].exec("*** Failers"), 2460); -assertEquals(null, res[811].exec("athing", 2461)); -assertEquals(null, res[811].exec("bthing", 2462)); -assertEquals(null, res[811].exec("]thing", 2463)); -assertEquals(null, res[811].exec("cthing", 2464)); -assertEquals(null, res[811].exec("dthing", 2465)); -assertEquals(null, res[811].exec("ething", 2466)); -assertEquals(null, res[812].exec("athing", 2467)); -assertEquals(null, res[812].exec("fthing", 2468)); -assertEquals(null, res[812].exec("*** Failers", 2469)); -assertEquals(null, res[812].exec("]thing", 2470)); -assertEquals(null, res[812].exec("cthing", 2471)); -assertEquals(null, res[812].exec("dthing", 2472)); -assertEquals(null, res[812].exec("ething", 2473)); -assertEquals(null, res[812].exec("\ufffd", 2474)); -assertEquals(null, res[812].exec("\ufffd", 2475)); -assertEquals("0", res[813].exec("0"), 2476); -assertEquals("1", res[813].exec("1"), 2477); -assertEquals("2", res[813].exec("2"), 2478); -assertEquals("3", res[813].exec("3"), 2479); -assertEquals("4", res[813].exec("4"), 2480); -assertEquals("5", res[813].exec("5"), 2481); -assertEquals("6", res[813].exec("6"), 2482); -assertEquals("7", res[813].exec("7"), 2483); -assertEquals("8", res[813].exec("8"), 2484); -assertEquals("9", res[813].exec("9"), 2485); -assertEquals("10", res[813].exec("10"), 2486); -assertEquals("100", res[813].exec("100"), 2487); -assertEquals(null, res[813].exec("*** Failers", 2488)); -assertEquals(null, res[813].exec("abc", 2489)); -assertEquals("enter", res[814].exec("enter"), 2490); -assertEquals("inter", res[814].exec("inter"), 2491); -assertEquals("uponter", res[814].exec("uponter"), 2492); -assertEquals("xxx0", res[815].exec("xxx0"), 2493); -assertEquals("xxx1234", res[815].exec("xxx1234"), 2494); -assertEquals(null, res[815].exec("*** Failers", 2495)); -assertEquals(null, res[815].exec("xxx", 2496)); -assertEquals("x123", res[816].exec("x123"), 2497); -assertEquals("xx123", res[816].exec("xx123"), 2498); -assertEquals("123456", res[816].exec("123456"), 2499); -assertEquals(null, res[816].exec("*** Failers", 2500)); -assertEquals(null, res[816].exec("123", 2501)); -assertEquals("x1234", res[816].exec("x1234"), 2502); -assertEquals("x123", res[817].exec("x123"), 2503); -assertEquals("xx123", res[817].exec("xx123"), 2504); -assertEquals("123456", res[817].exec("123456"), 2505); -assertEquals(null, res[817].exec("*** Failers", 2506)); -assertEquals(null, res[817].exec("123", 2507)); -assertEquals("x1234", res[817].exec("x1234"), 2508); -assertEquals("abc!pqr=apquxz.ixr.zzz.ac.uk,abc,pqr", res[818].exec("abc!pqr=apquxz.ixr.zzz.ac.uk"), 2509); -assertEquals(null, res[818].exec("*** Failers", 2510)); -assertEquals(null, res[818].exec("!pqr=apquxz.ixr.zzz.ac.uk", 2511)); -assertEquals(null, res[818].exec("abc!=apquxz.ixr.zzz.ac.uk", 2512)); -assertEquals(null, res[818].exec("abc!pqr=apquxz:ixr.zzz.ac.uk", 2513)); -assertEquals(null, res[818].exec("abc!pqr=apquxz.ixr.zzz.ac.ukk", 2514)); -assertEquals(":", res[819].exec("Well, we need a colon: somewhere"), 2515); -assertEquals(null, res[819].exec("*** Fail if we don't", 2516)); -assertEquals("0abc,0abc", res[820].exec("0abc"), 2517); -assertEquals("abc,abc", res[820].exec("abc"), 2518); -assertEquals("fed,fed", res[820].exec("fed"), 2519); -assertEquals("E,E", res[820].exec("E"), 2520); -assertEquals("::,::", res[820].exec("::"), 2521); -assertEquals("5f03:12C0::932e,5f03:12C0::932e", res[820].exec("5f03:12C0::932e"), 2522); -assertEquals("def,def", res[820].exec("fed def"), 2523); -assertEquals("ff,ff", res[820].exec("Any old stuff"), 2524); -assertEquals(null, res[820].exec("*** Failers", 2525)); -assertEquals(null, res[820].exec("0zzz", 2526)); -assertEquals(null, res[820].exec("gzzz", 2527)); -assertEquals(null, res[820].exec("fed ", 2528)); -assertEquals(null, res[820].exec("Any old rubbish", 2529)); -assertEquals(".1.2.3,1,2,3", res[821].exec(".1.2.3"), 2530); -assertEquals("A.12.123.0,12,123,0", res[821].exec("A.12.123.0"), 2531); -assertEquals(null, res[821].exec("*** Failers", 2532)); -assertEquals(null, res[821].exec(".1.2.3333", 2533)); -assertEquals(null, res[821].exec("1.2.3", 2534)); -assertEquals(null, res[821].exec("1234.2.3", 2535)); -assertEquals("1 IN SOA non-sp1 non-sp2(,1,non-sp1,non-sp2", res[822].exec("1 IN SOA non-sp1 non-sp2("), 2536); -assertEquals("1 IN SOA non-sp1 non-sp2 (,1,non-sp1,non-sp2", res[822].exec("1 IN SOA non-sp1 non-sp2 ("), 2537); -assertEquals(null, res[822].exec("*** Failers", 2538)); -assertEquals(null, res[822].exec("1IN SOA non-sp1 non-sp2(", 2539)); -assertEquals("a.,", res[823].exec("a."), 2540); -assertEquals("Z.,", res[823].exec("Z."), 2541); -assertEquals("2.,", res[823].exec("2."), 2542); -assertEquals("ab-c.pq-r.,.pq-r", res[823].exec("ab-c.pq-r."), 2543); -assertEquals("sxk.zzz.ac.uk.,.uk", res[823].exec("sxk.zzz.ac.uk."), 2544); -assertEquals("x-.y-.,.y-", res[823].exec("x-.y-."), 2545); -assertEquals(null, res[823].exec("*** Failers", 2546)); -assertEquals(null, res[823].exec("-abc.peq.", 2547)); -assertEquals("*.a,,,", res[824].exec("*.a"), 2548); -assertEquals("*.b0-a,0-a,,", res[824].exec("*.b0-a"), 2549); -assertEquals("*.c3-b.c,3-b,.c,", res[824].exec("*.c3-b.c"), 2550); -assertEquals("*.c-a.b-c,-a,.b-c,-c", res[824].exec("*.c-a.b-c"), 2551); -assertEquals(null, res[824].exec("*** Failers", 2552)); -assertEquals(null, res[824].exec("*.0", 2553)); -assertEquals(null, res[824].exec("*.a-", 2554)); -assertEquals(null, res[824].exec("*.a-b.c-", 2555)); -assertEquals(null, res[824].exec("*.c-a.0-c", 2556)); -assertEquals("abde,de,abd,e", res[825].exec("abde"), 2557); -assertEquals("abdf,,abd,f", res[826].exec("abdf"), 2558); -assertEquals("ab,abcd,cd,ab", res[827].exec("abcd"), 2559); -assertEquals("a.b.c.d,.d", res[828].exec("a.b.c.d"), 2560); -assertEquals("A.B.C.D,.D", res[828].exec("A.B.C.D"), 2561); -assertEquals("a.b.c.1.2.3.C,.C", res[828].exec("a.b.c.1.2.3.C"), 2562); -assertEquals("\"1234\",", res[829].exec("\"1234\""), 2563); -assertEquals("\"abcd\" ;,;", res[829].exec("\"abcd\" ;"), 2564); -assertEquals("\"\" ; rhubarb,; rhubarb", res[829].exec("\"\" ; rhubarb"), 2565); -assertEquals(null, res[829].exec("*** Failers", 2566)); -assertEquals(null, res[829].exec("\"1234\" : things", 2567)); -assertEquals(null, res[830].exec("\\", 2568)); -assertEquals(null, res[830].exec("*** Failers", 2569)); -assertEquals("ab c", res[831].exec("ab c"), 2570); -assertEquals(null, res[831].exec("*** Failers", 2571)); -assertEquals(null, res[831].exec("abc", 2572)); -assertEquals(null, res[831].exec("ab cde", 2573)); -assertEquals("ab c", res[831].exec("ab c"), 2574); -assertEquals(null, res[831].exec("*** Failers", 2575)); -assertEquals(null, res[831].exec("abc", 2576)); -assertEquals(null, res[831].exec("ab cde", 2577)); -assertEquals("a bcd", res[832].exec("a bcd"), 2578); -assertEquals(null, res[832].exec("a b d", 2579)); -assertEquals(null, res[832].exec("*** Failers", 2580)); -assertEquals(null, res[832].exec("abcd", 2581)); -assertEquals(null, res[832].exec("ab d", 2582)); -assertEquals("abcdefhijklm,abc,bc,c,def,ef,f,hij,ij,j,klm,lm,m", res[833].exec("abcdefhijklm"), 2583); -assertEquals("abcdefhijklm,bc,c,ef,f,ij,j,lm,m", res[834].exec("abcdefhijklm"), 2584); -assertEquals(null, res[835].exec("a+ Z0+\x08\n\x1d\x12", 2585)); -assertEquals(null, res[835].exec(".^$(*+)|{?,?}", 2586)); -assertEquals("z", res[836].exec("z"), 2587); -assertEquals("az", res[836].exec("az"), 2588); -assertEquals("aaaz", res[836].exec("aaaz"), 2589); -assertEquals("a", res[836].exec("a"), 2590); -assertEquals("aa", res[836].exec("aa"), 2591); -assertEquals("aaaa", res[836].exec("aaaa"), 2592); -assertEquals("a", res[836].exec("a+"), 2593); -assertEquals("aa", res[836].exec("aa+"), 2594); -assertEquals("z", res[837].exec("z"), 2595); -assertEquals("a", res[837].exec("az"), 2596); -assertEquals("a", res[837].exec("aaaz"), 2597); -assertEquals("a", res[837].exec("a"), 2598); -assertEquals("a", res[837].exec("aa"), 2599); -assertEquals("a", res[837].exec("aaaa"), 2600); -assertEquals("a", res[837].exec("a+"), 2601); -assertEquals("a", res[837].exec("aa+"), 2602); -assertEquals("az", res[838].exec("az"), 2603); -assertEquals("aaaz", res[838].exec("aaaz"), 2604); -assertEquals("aa", res[838].exec("aa"), 2605); -assertEquals("aaaa", res[838].exec("aaaa"), 2606); -assertEquals("aa", res[838].exec("aa+"), 2607); -assertEquals("az", res[839].exec("az"), 2608); -assertEquals("aa", res[839].exec("aaaz"), 2609); -assertEquals("aa", res[839].exec("aa"), 2610); -assertEquals("aa", res[839].exec("aaaa"), 2611); -assertEquals("aa", res[839].exec("aa+"), 2612); -assertEquals("1234567890", res[840].exec("1234567890"), 2613); -assertEquals("12345678ab", res[840].exec("12345678ab"), 2614); -assertEquals("12345678__", res[840].exec("12345678__"), 2615); -assertEquals(null, res[840].exec("*** Failers", 2616)); -assertEquals(null, res[840].exec("1234567", 2617)); -assertEquals("uoie", res[841].exec("uoie"), 2618); -assertEquals("1234", res[841].exec("1234"), 2619); -assertEquals("12345", res[841].exec("12345"), 2620); -assertEquals("aaaaa", res[841].exec("aaaaa"), 2621); -assertEquals(null, res[841].exec("*** Failers", 2622)); -assertEquals(null, res[841].exec("123456", 2623)); -assertEquals("uoie", res[842].exec("uoie"), 2624); -assertEquals("1234", res[842].exec("1234"), 2625); -assertEquals("1234", res[842].exec("12345"), 2626); -assertEquals("aaaa", res[842].exec("aaaaa"), 2627); -assertEquals("1234", res[842].exec("123456"), 2628); -assertEquals("From abcd Mon Sep 01 12:33,abcd", res[843].exec("From abcd Mon Sep 01 12:33:02 1997"), 2629); -assertEquals("From abcd Mon Sep 01 12:33,Sep ", res[844].exec("From abcd Mon Sep 01 12:33:02 1997"), 2630); -assertEquals("From abcd Mon Sep 1 12:33,Sep ", res[844].exec("From abcd Mon Sep 1 12:33:02 1997"), 2631); -assertEquals(null, res[844].exec("*** Failers", 2632)); -assertEquals(null, res[844].exec("From abcd Sep 01 12:33:02 1997", 2633)); -assertEquals(null, res[845].exec("12\n34", 2634)); -assertEquals(null, res[845].exec("12\x0d34", 2635)); -assertEquals("brown", res[846].exec("the quick brown\x09 fox"), 2636); -assertEquals("foolish see?,lish see?", res[847].exec("foobar is foolish see?"), 2637); -assertEquals("rowbar etc, etc", res[848].exec("foobar crowbar etc"), 2638); -assertEquals("barrel,rel", res[848].exec("barrel"), 2639); -assertEquals("2barrel,rel", res[848].exec("2barrel"), 2640); -assertEquals("A barrel,rel", res[848].exec("A barrel"), 2641); -assertEquals("abc,abc", res[849].exec("abc456"), 2642); -assertEquals(null, res[849].exec("*** Failers", 2643)); -assertEquals(null, res[849].exec("abc123", 2644)); -assertEquals("1234", res[850].exec("1234"), 2645); -assertEquals("1234", res[851].exec("1234"), 2646); -assertEquals("abcd", res[852].exec("abcd"), 2647); -assertEquals("abcd", res[853].exec("abcd"), 2648); -assertEquals("abc", res[854].exec("the abc"), 2649); -assertEquals(null, res[854].exec("*** Failers", 2650)); -assertEquals(null, res[854].exec("abc", 2651)); -assertEquals("abc", res[855].exec("abc"), 2652); -assertEquals(null, res[855].exec("*** Failers", 2653)); -assertEquals(null, res[855].exec("the abc", 2654)); -assertEquals("aabb,b", res[856].exec("aabbbbb"), 2655); -assertEquals("aabbbbb,abbbbb", res[857].exec("aabbbbb"), 2656); -assertEquals("aa,a", res[858].exec("aabbbbb"), 2657); -assertEquals("aabb,b", res[859].exec("aabbbbb"), 2658); -assertEquals("Alan Other ", res[860].exec("Alan Other "), 2659); -assertEquals("user@dom.ain", res[860].exec(""), 2660); -assertEquals("user@dom.ain", res[860].exec("user@dom.ain"), 2661); -assertEquals("\"A. Other\" (a comment)", res[860].exec("\"A. Other\" (a comment)"), 2662); -assertEquals(" Other (a comment)", res[860].exec("A. Other (a comment)"), 2663); -assertEquals("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay", res[860].exec("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"), 2664); -assertEquals("user@some.where", res[860].exec("A missing angle ", res[861].exec("Alan Other "), 2668); -assertEquals("user@dom.ain", res[861].exec(""), 2669); -assertEquals("user@dom.ain", res[861].exec("user@dom.ain"), 2670); -assertEquals("\"A. Other\" ", res[861].exec("\"A. Other\" (a comment)"), 2671); -assertEquals(" Other ", res[861].exec("A. Other (a comment)"), 2672); -assertEquals("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay", res[861].exec("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"), 2673); -assertEquals("user@some.where", res[861].exec("A missing angle \x09\n\x0c\x0d\x0b<", 3716)); -assertEquals(null, res[1271].exec(" ", 3717)); -assertEquals(null, res[1272].exec("> \x09\n\x0c\x0d\x0b<", 3718)); -assertEquals(null, res[1272].exec(" ", 3719)); -assertEquals(" \x09\n\x0c\x0d\x0b", res[1273].exec("> \x09\n\x0c\x0d\x0b<"), 3720); -assertEquals(" ", res[1273].exec(" "), 3721); -assertEquals(" \x09\n\x0c\x0d\x0b", res[1274].exec("> \x09\n\x0c\x0d\x0b<"), 3722); -assertEquals(" ", res[1274].exec(" "), 3723); -assertEquals(null, res[1275].exec("ab", 3724)); -assertEquals(null, res[1278].exec("abcabcabc", 3725)); -assertEquals(null, res[1278].exec("abc(*+|abc ", 3726)); -assertEquals(null, res[1279].exec("abc abcabc", 3727)); -assertEquals(null, res[1279].exec("*** Failers", 3728)); -assertEquals(null, res[1279].exec("abcabcabc ", 3729)); -assertEquals(null, res[1280].exec("abc#not comment\n literal ", 3730)); -assertEquals(null, res[1281].exec("abc#not comment\n literal ", 3731)); -assertEquals(null, res[1282].exec("abc#not comment\n literal ", 3732)); -assertEquals(null, res[1283].exec("abc#not comment\n literal ", 3733)); -assertEquals(null, res[1284].exec("abc\\$xyz", 3734)); -assertEquals(null, res[1285].exec("abc$xyz", 3735)); -assertEquals(null, res[1286].exec("abc", 3736)); -assertEquals(null, res[1286].exec("*** Failers", 3737)); -assertEquals(null, res[1286].exec("xyzabc ", 3738)); -assertEquals(null, res[1287].exec("abc1abc2xyzabc3", 3739)); -assertEquals("abc1", res[1288].exec("abc1abc2xyzabc3 "), 3740); -assertEquals(null, res[1288].exec("XabcdY", 3741)); -assertEquals(null, res[1288].exec("*** Failers ", 3742)); -assertEquals(null, res[1288].exec("Xa b c d Y ", 3743)); -assertEquals("abcY", res[1288].exec("XabcY"), 3744); -assertEquals(null, res[1288].exec("AxyzB ", 3745)); -assertEquals(null, res[1288].exec("XabCY", 3746)); -assertEquals(null, res[1288].exec("*** Failers", 3747)); -assertEquals("abcY", res[1288].exec("XabcY "), 3748); -assertEquals(null, res[1288].exec("abCE", 3749)); -assertEquals(null, res[1288].exec("DE", 3750)); -assertEquals(null, res[1288].exec("*** Failers", 3751)); -assertEquals("abcE", res[1288].exec("abcE"), 3752); -assertEquals(null, res[1288].exec("abCe ", 3753)); -assertEquals(null, res[1288].exec("dE", 3754)); -assertEquals(null, res[1288].exec("De ", 3755)); -assertEquals(null, res[1289].exec("z", 3756)); -assertEquals(null, res[1289].exec("a", 3757)); -assertEquals(null, res[1289].exec("-", 3758)); -assertEquals(null, res[1289].exec("d", 3759)); -assertEquals(null, res[1289].exec("] ", 3760)); -assertEquals(null, res[1289].exec("*** Failers", 3761)); -assertEquals(null, res[1289].exec("b ", 3762)); -assertEquals("z", res[1290].exec("z"), 3763); -assertEquals("C", res[1290].exec("C "), 3764); -assertEquals("M", res[1291].exec("M "), 3765); -assertEquals(null, res[1292].exec("", 3766)); -assertEquals(null, res[1292].exec("REGular", 3767)); -assertEquals(null, res[1292].exec("regulaer", 3768)); -assertEquals(null, res[1292].exec("Regex ", 3769)); -assertEquals(null, res[1292].exec("regul\ufffdr ", 3770)); -assertEquals(null, res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3771)); -assertEquals(null, res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3772)); -assertEquals(null, res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3773)); -assertEquals(null, res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3774)); -assertEquals(null, res[1292].exec("\x84XAZXB", 3775)); -assertEquals(null, res[1292].exec("123a", 3776)); -assertEquals(null, res[1292].exec("ac", 3777)); -assertEquals("b,", res[1292].exec("bbbbc"), 3778); -assertEquals("ab,a", res[1292].exec("abc"), 3779); -assertEquals(null, res[1292].exec("*** Failers", 3780)); -assertEquals("b,", res[1292].exec("bca"), 3781); -assertEquals(null, res[1292].exec("", 3782)); -assertEquals("ab,a", res[1292].exec("abc"), 3783); -assertEquals(null, res[1292].exec("*** Failers", 3784)); -assertEquals("b,", res[1292].exec("bca"), 3785); -assertEquals("ab,a", res[1292].exec("abc"), 3786); -assertEquals(null, res[1292].exec("*** Failers", 3787)); -assertEquals(null, res[1292].exec("def ", 3788)); -assertEquals(null, res[1292].exec("", 3789)); -assertEquals("ab,a", res[1292].exec("abc"), 3790); -assertEquals(null, res[1292].exec("*** Failers", 3791)); -assertEquals(null, res[1292].exec("def ", 3792)); -assertEquals(null, res[1292].exec("", 3793)); -assertEquals("line\nbreak", res[1293].exec("this is a line\nbreak"), 3794); -assertEquals("line\nbreak", res[1293].exec("line one\nthis is a line\nbreak in the second line "), 3795); -assertEquals("line\nbreak", res[1294].exec("this is a line\nbreak"), 3796); -assertEquals(null, res[1294].exec("** Failers ", 3797)); -assertEquals("line\nbreak", res[1294].exec("line one\nthis is a line\nbreak in the second line "), 3798); -assertEquals("line\nbreak", res[1295].exec("this is a line\nbreak"), 3799); -assertEquals(null, res[1295].exec("** Failers ", 3800)); -assertEquals("line\nbreak", res[1295].exec("line one\nthis is a line\nbreak in the second line "), 3801); -assertEquals(null, res[1296].exec("123P", 3802)); -assertEquals(null, res[1296].exec("a4PR", 3803)); -assertEquals(null, res[1297].exec("123P", 3804)); -assertEquals(null, res[1297].exec("4PR", 3805)); -assertEquals("", res[1298].exec("a\nb\nc\n"), 3806); -assertEquals("", res[1298].exec(" "), 3807); -assertEquals("", res[1298].exec("A\nC\nC\n "), 3808); -assertEquals("", res[1298].exec("AB"), 3809); -assertEquals("", res[1298].exec("aB "), 3810); -assertEquals("", res[1298].exec("AB"), 3811); -assertEquals("", res[1298].exec("aB "), 3812); -assertEquals("", res[1298].exec("AB"), 3813); -assertEquals("", res[1298].exec("aB "), 3814); -assertEquals("", res[1298].exec("AB"), 3815); -assertEquals("", res[1298].exec("aB "), 3816); -assertEquals("Content-Type:xxxxxyyy ", res[1299].exec("Content-Type:xxxxxyyy "), 3817); -assertEquals("Content-Type:xxxxxyyyz", res[1300].exec("Content-Type:xxxxxyyyz"), 3818); -assertEquals("Content-Type:xxxyyy ", res[1301].exec("Content-Type:xxxyyy "), 3819); -assertEquals("Content-Type:xxxyyyz", res[1302].exec("Content-Type:xxxyyyz"), 3820); -assertEquals("abc", res[1303].exec("xyz\nabc"), 3821); -assertEquals("abc", res[1303].exec("xyz\nabc"), 3822); -assertEquals("abc", res[1303].exec("xyz\x0d\nabc"), 3823); -assertEquals("abc", res[1303].exec("xyz\x0dabc"), 3824); -assertEquals("abc", res[1303].exec("xyz\x0d\nabc"), 3825); -assertEquals(null, res[1303].exec("** Failers ", 3826)); -assertEquals("abc", res[1303].exec("xyz\nabc"), 3827); -assertEquals("abc", res[1303].exec("xyz\x0d\nabc"), 3828); -assertEquals("abc", res[1303].exec("xyz\nabc"), 3829); -assertEquals("abc", res[1303].exec("xyz\x0dabc"), 3830); -assertEquals("abc", res[1303].exec("xyz\x0dabc"), 3831); -assertEquals("abc", res[1304].exec("xyzabc"), 3832); -assertEquals("abc", res[1304].exec("xyzabc\n "), 3833); -assertEquals("abc", res[1304].exec("xyzabc\npqr "), 3834); -assertEquals("abc", res[1304].exec("xyzabc\x0d "), 3835); -assertEquals("abc", res[1304].exec("xyzabc\x0dpqr "), 3836); -assertEquals("abc", res[1304].exec("xyzabc\x0d\n "), 3837); -assertEquals("abc", res[1304].exec("xyzabc\x0d\npqr "), 3838); -assertEquals(null, res[1304].exec("** Failers", 3839)); -assertEquals("abc", res[1304].exec("xyzabc\x0d "), 3840); -assertEquals("abc", res[1304].exec("xyzabc\x0dpqr "), 3841); -assertEquals("abc", res[1304].exec("xyzabc\x0d\n "), 3842); -assertEquals("abc", res[1304].exec("xyzabc\x0d\npqr "), 3843); -assertEquals("abc", res[1305].exec("xyz\x0dabcdef"), 3844); -assertEquals("abc", res[1305].exec("xyz\nabcdef"), 3845); -assertEquals(null, res[1305].exec("** Failers ", 3846)); -assertEquals("abc", res[1305].exec("xyz\nabcdef"), 3847); -assertEquals(null, res[1305].exec(" ", 3848)); -assertEquals("abc", res[1306].exec("xyz\nabcdef"), 3849); -assertEquals("abc", res[1306].exec("xyz\x0dabcdef"), 3850); -assertEquals(null, res[1306].exec("** Failers ", 3851)); -assertEquals("abc", res[1306].exec("xyz\x0dabcdef"), 3852); -assertEquals(null, res[1306].exec(" ", 3853)); -assertEquals("abc", res[1307].exec("xyz\x0d\nabcdef"), 3854); -assertEquals("abc", res[1307].exec("xyz\x0dabcdef"), 3855); -assertEquals(null, res[1307].exec("** Failers ", 3856)); -assertEquals("abc", res[1307].exec("xyz\x0dabcdef"), 3857); -assertEquals("abc", res[1308].exec("abc\ndef"), 3858); -assertEquals("abc", res[1308].exec("abc\x0ddef"), 3859); -assertEquals("abc", res[1308].exec("abc\x0d\ndef"), 3860); -assertEquals("abc", res[1308].exec("abc\ndef"), 3861); -assertEquals("abc", res[1308].exec("abc\x0ddef"), 3862); -assertEquals("abc", res[1308].exec("abc\x0d\ndef"), 3863); -assertEquals("abc", res[1308].exec("abc\ndef"), 3864); -assertEquals("abc", res[1308].exec("abc\x0ddef"), 3865); -assertEquals("abc", res[1308].exec("abc\x0d\ndef"), 3866); -assertEquals(null, res[1309].exec("abc\ndef", 3867)); -assertEquals(null, res[1309].exec("abc\x0ddef", 3868)); -assertEquals(null, res[1309].exec("abc\x0d\ndef", 3869)); -assertEquals("abc=xyz\\,", res[1310].exec("abc=xyz\\\npqr"), 3870); -assertEquals("aaaa,a,", res[1311].exec("aaaa"), 3871); -assertEquals("aaaa", res[1312].exec("aaaa"), 3872); -assertEquals("aaaa,a,", res[1313].exec("aaaa"), 3873); -assertEquals("aaaa", res[1314].exec("aaaa"), 3874); -assertEquals(null, res[1317].exec("a\x0db", 3875)); -assertEquals(null, res[1317].exec("a\nb ", 3876)); -assertEquals(null, res[1317].exec("** Failers", 3877)); -assertEquals(null, res[1317].exec("a\nb", 3878)); -assertEquals(null, res[1317].exec("a\nb", 3879)); -assertEquals(null, res[1317].exec("a\x0db ", 3880)); -assertEquals(null, res[1317].exec("a\x0db ", 3881)); -assertEquals("abc1", res[1318].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 \x85abc7 JUNK"), 3882); -assertEquals("abc1", res[1319].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc9"), 3883); -assertEquals(null, res[1320].exec("a\nb", 3884)); -assertEquals(null, res[1320].exec("a\x0db", 3885)); -assertEquals(null, res[1320].exec("a\x0d\nb", 3886)); -assertEquals(null, res[1320].exec("a\x0bb", 3887)); -assertEquals(null, res[1320].exec("a\x0cb", 3888)); -assertEquals(null, res[1320].exec("a\x85b ", 3889)); -assertEquals(null, res[1320].exec("** Failers", 3890)); -assertEquals(null, res[1320].exec("a\n\x0db ", 3891)); -assertEquals("ab", res[1321].exec("ab"), 3892); -assertEquals(null, res[1321].exec("a\nb", 3893)); -assertEquals(null, res[1321].exec("a\x0db", 3894)); -assertEquals(null, res[1321].exec("a\x0d\nb", 3895)); -assertEquals(null, res[1321].exec("a\x0bb", 3896)); -assertEquals(null, res[1321].exec("a\x0cb", 3897)); -assertEquals(null, res[1321].exec("a\x85b ", 3898)); -assertEquals(null, res[1321].exec("a\n\x0db ", 3899)); -assertEquals(null, res[1321].exec("a\n\x0d\x85\x0cb ", 3900)); -assertEquals(null, res[1322].exec("a\nb", 3901)); -assertEquals(null, res[1322].exec("a\x0db", 3902)); -assertEquals(null, res[1322].exec("a\x0d\nb", 3903)); -assertEquals(null, res[1322].exec("a\x0bb", 3904)); -assertEquals(null, res[1322].exec("a\x0cb", 3905)); -assertEquals(null, res[1322].exec("a\x85b ", 3906)); -assertEquals(null, res[1322].exec("a\n\x0db ", 3907)); -assertEquals(null, res[1322].exec("a\n\x0d\x85\x0cb ", 3908)); -assertEquals(null, res[1322].exec("** Failers", 3909)); -assertEquals(null, res[1322].exec("ab ", 3910)); -assertEquals(null, res[1323].exec("a\nb", 3911)); -assertEquals(null, res[1323].exec("a\n\x0db", 3912)); -assertEquals(null, res[1323].exec("a\n\x0d\x85b", 3913)); -assertEquals(null, res[1323].exec("a\x0d\n\x0d\nb ", 3914)); -assertEquals(null, res[1323].exec("a\x0d\n\x0d\n\x0d\nb ", 3915)); -assertEquals(null, res[1323].exec("a\n\x0d\n\x0db", 3916)); -assertEquals(null, res[1323].exec("a\n\n\x0d\nb ", 3917)); -assertEquals(null, res[1323].exec("** Failers", 3918)); -assertEquals(null, res[1323].exec("a\n\n\n\x0db", 3919)); -assertEquals(null, res[1323].exec("a\x0d", 3920)); -assertEquals("aRb", res[1324].exec("aRb"), 3921); -assertEquals(null, res[1324].exec("** Failers", 3922)); -assertEquals(null, res[1324].exec("a\nb ", 3923)); -assertEquals("afoo", res[1325].exec("afoo"), 3924); -assertEquals(null, res[1325].exec("** Failers ", 3925)); -assertEquals(null, res[1325].exec("\x0d\nfoo ", 3926)); -assertEquals(null, res[1325].exec("\nfoo ", 3927)); -assertEquals("afoo", res[1326].exec("afoo"), 3928); -assertEquals(null, res[1326].exec("\nfoo ", 3929)); -assertEquals(null, res[1326].exec("** Failers ", 3930)); -assertEquals(null, res[1326].exec("\x0d\nfoo ", 3931)); -assertEquals("afoo", res[1327].exec("afoo"), 3932); -assertEquals(null, res[1327].exec("** Failers ", 3933)); -assertEquals(null, res[1327].exec("\nfoo ", 3934)); -assertEquals(null, res[1327].exec("\x0d\nfoo ", 3935)); -assertEquals("afoo", res[1328].exec("afoo"), 3936); -assertEquals(null, res[1328].exec("\x0d\nfoo ", 3937)); -assertEquals(null, res[1328].exec("\nfoo ", 3938)); -assertEquals("", res[1329].exec("abc\x0d\x0dxyz"), 3939); -assertEquals("", res[1329].exec("abc\n\x0dxyz "), 3940); -assertEquals(null, res[1329].exec("** Failers ", 3941)); -assertEquals("", res[1329].exec("abc\x0d\nxyz"), 3942); -assertEquals("X", res[1330].exec("XABC"), 3943); -assertEquals(null, res[1330].exec("** Failers ", 3944)); -assertEquals("X", res[1330].exec("XABCB"), 3945); -assertEquals(null, res[1330].exec("abc\x0d\n\x0d\n", 3946)); -assertEquals(null, res[1330].exec("abc\x0d\n\x0d\n", 3947)); -assertEquals(null, res[1330].exec("abc\x0d\n\x0d\n", 3948)); -assertThrows("var re = /(?|(abc)|(xyz))/;", 3949); -assertThrows("var re = /(x)(?|(abc)|(xyz))(x)/;", 3950); -assertEquals(null, res[1330].exec("xabcx", 3951)); -assertEquals(null, res[1330].exec("xxyzx ", 3952)); -assertThrows("var re = /(x)(?|(abc)(pqr)|(xyz))(x)/;", 3953); -assertEquals(null, res[1330].exec("xabcpqrx", 3954)); -assertEquals(null, res[1330].exec("xxyzx ", 3955)); -assertEquals(null, res[1330].exec("abcabc", 3956)); -assertEquals(null, res[1330].exec("xyzabc ", 3957)); -assertEquals(null, res[1330].exec("** Failers ", 3958)); -assertEquals(null, res[1330].exec("xyzxyz ", 3959)); -assertEquals(null, res[1331].exec("X X\n", 3960)); -assertEquals(null, res[1331].exec("X\x09X\x0b", 3961)); -assertEquals(null, res[1331].exec("** Failers", 3962)); -assertEquals(null, res[1331].exec("\xa0 X\n ", 3963)); -assertEquals(null, res[1332].exec("\x09 \xa0X\n\x0b\x0c\x0d\n", 3964)); -assertEquals(null, res[1332].exec("\x09 \xa0\n\x0b\x0c\x0d\n", 3965)); -assertEquals(null, res[1332].exec("\x09 \xa0\n\x0b\x0c", 3966)); -assertEquals(null, res[1332].exec("** Failers ", 3967)); -assertEquals(null, res[1332].exec("\x09 \xa0\n\x0b", 3968)); -assertEquals(null, res[1332].exec(" ", 3969)); -assertEquals(null, res[1333].exec("XY ABCDE", 3970)); -assertEquals(null, res[1333].exec("XY PQR ST ", 3971)); -assertEquals(null, res[1334].exec("XY AB PQRS", 3972)); -assertEquals(null, res[1335].exec(">XNNNYZ", 3973)); -assertEquals(null, res[1335].exec("> X NYQZ", 3974)); -assertEquals(null, res[1335].exec("** Failers", 3975)); -assertEquals(null, res[1335].exec(">XYZ ", 3976)); -assertEquals(null, res[1335].exec("> X NY Z", 3977)); -assertEquals(null, res[1336].exec(">XY\nZ\nA\x0bNN\x0c", 3978)); -assertEquals(null, res[1336].exec(">\n\x0dX\nY\n\x0bZZZ\nAAA\x0bNNN\x0c", 3979)); -assertEquals(null, res[1337].exec("\x0d\nA", 3980)); -assertEquals("\nA", res[1338].exec("\x0d\nA "), 3981); -assertEquals("\nA", res[1339].exec("\x0d\nA "), 3982); -assertEquals("\nA,\n", res[1340].exec("\x0d\nA "), 3983); -assertEquals(null, res[1341].exec("a\x0db", 3984)); -assertEquals(null, res[1341].exec("a\nb", 3985)); -assertEquals(null, res[1341].exec("a\x0d\nb", 3986)); -assertEquals(null, res[1341].exec("** Failers", 3987)); -assertEquals(null, res[1341].exec("a\x85b", 3988)); -assertEquals(null, res[1341].exec("a\x0bb ", 3989)); -assertEquals(null, res[1342].exec("a\x0db", 3990)); -assertEquals(null, res[1342].exec("a\nb", 3991)); -assertEquals(null, res[1342].exec("a\x0d\nb", 3992)); -assertEquals(null, res[1342].exec("a\x85b", 3993)); -assertEquals(null, res[1342].exec("a\x0bb ", 3994)); -assertEquals(null, res[1342].exec("** Failers ", 3995)); -assertEquals(null, res[1342].exec("a\x85b", 3996)); -assertEquals(null, res[1342].exec("a\x0bb", 3997)); -assertEquals(null, res[1343].exec("a\x0db", 3998)); -assertEquals(null, res[1343].exec("a\nb", 3999)); -assertEquals(null, res[1343].exec("a\x0d\nb", 4000)); -assertEquals(null, res[1343].exec("** Failers", 4001)); -assertEquals(null, res[1343].exec("a\x85b", 4002)); -assertEquals(null, res[1343].exec("a\x0bb ", 4003)); -assertEquals(null, res[1344].exec("a\x0db", 4004)); -assertEquals(null, res[1344].exec("a\nb", 4005)); -assertEquals(null, res[1344].exec("a\x0d\nb", 4006)); -assertEquals(null, res[1344].exec("a\x85b", 4007)); -assertEquals(null, res[1344].exec("a\x0bb ", 4008)); -assertEquals(null, res[1344].exec("** Failers ", 4009)); -assertEquals(null, res[1344].exec("a\x85b", 4010)); -assertEquals(null, res[1344].exec("a\x0bb", 4011)); -assertEquals(null, res[1345].exec("a\x0d\n\nb", 4012)); -assertEquals(null, res[1345].exec("a\n\x0d\x0db", 4013)); -assertEquals(null, res[1345].exec("a\x0d\n\x0d\n\x0d\n\x0d\nb", 4014)); -assertEquals(null, res[1345].exec("** Failers", 4015)); -assertEquals(null, res[1345].exec("a\x8585b", 4016)); -assertEquals(null, res[1345].exec("a\x0b\x00bb ", 4017)); -assertEquals(null, res[1346].exec("a\x0d\x0db", 4018)); -assertEquals(null, res[1346].exec("a\n\n\nb", 4019)); -assertEquals(null, res[1346].exec("a\x0d\n\n\x0d\x0db", 4020)); -assertEquals(null, res[1346].exec("a\x8585b", 4021)); -assertEquals(null, res[1346].exec("a\x0b\x00bb ", 4022)); -assertEquals(null, res[1346].exec("** Failers ", 4023)); -assertEquals(null, res[1346].exec("a\x0d\x0d\x0d\x0d\x0db ", 4024)); -assertEquals(null, res[1346].exec("a\x8585b", 4025)); -assertEquals(null, res[1346].exec("a\x0b\x00bb", 4026)); -assertEquals("abc", res[1347].exec("abc "), 4027); -assertEquals(null, res[1348].exec("** Failers", 4028)); -assertEquals(null, res[1348].exec("ab", 4029)); -assertEquals(null, res[1349].exec("** Failers", 4030)); -assertEquals(null, res[1349].exec("ab ", 4031)); -assertEquals(null, res[1349].exec("** Failers", 4032)); -assertEquals(null, res[1349].exec("ab ", 4033)); -assertEquals("aXb", res[1350].exec("aXb"), 4034); -assertEquals("a\nb", res[1350].exec("a\nb "), 4035); -assertEquals(null, res[1350].exec("** Failers", 4036)); -assertEquals(null, res[1350].exec("ab ", 4037)); -assertEquals("aXb", res[1351].exec("aXb"), 4038); -assertEquals("a\nX\nXb", res[1351].exec("a\nX\nXb "), 4039); -assertEquals(null, res[1351].exec("** Failers", 4040)); -assertEquals(null, res[1351].exec("ab ", 4041)); -assertEquals(null, res[1352].exec("ab", 4042)); -assertEquals(null, res[1352].exec("ax{100}b ", 4043)); -assertEquals(null, res[1352].exec("ax{100}x{100}b ", 4044)); -assertEquals(null, res[1352].exec("ax{100}b ", 4045)); -assertEquals(null, res[1352].exec("ax{100}x{100}b ", 4046)); -assertEquals(null, res[1352].exec("*** Failers ", 4047)); -assertEquals(null, res[1352].exec("ab", 4048)); -assertEquals(null, res[1352].exec(" ", 4049)); -assertEquals("X", res[1353].exec("Xoanon"), 4050); -assertEquals("X", res[1353].exec("+Xoanon"), 4051); -assertEquals("X", res[1353].exec("x{300}Xoanon "), 4052); -assertEquals(null, res[1353].exec("*** Failers ", 4053)); -assertEquals(null, res[1353].exec("YXoanon ", 4054)); -assertEquals("X", res[1354].exec("YXoanon"), 4055); -assertEquals(null, res[1354].exec("*** Failers", 4056)); -assertEquals(null, res[1354].exec("Xoanon", 4057)); -assertEquals(null, res[1354].exec("+Xoanon ", 4058)); -assertEquals(null, res[1354].exec("x{300}Xoanon ", 4059)); -assertEquals("X", res[1355].exec("X+oanon"), 4060); -assertEquals(null, res[1355].exec("ZXx{300}oanon ", 4061)); -assertEquals("X", res[1355].exec("FAX "), 4062); -assertEquals(null, res[1355].exec("*** Failers ", 4063)); -assertEquals(null, res[1355].exec("Xoanon ", 4064)); -assertEquals("X", res[1356].exec("Xoanon "), 4065); -assertEquals(null, res[1356].exec("*** Failers", 4066)); -assertEquals(null, res[1356].exec("X+oanon", 4067)); -assertEquals("X", res[1356].exec("ZXx{300}oanon "), 4068); -assertEquals(null, res[1356].exec("FAX ", 4069)); -assertEquals("b", res[1357].exec("abcd"), 4070); -assertEquals("x", res[1357].exec("ax{100} "), 4071); -assertEquals("b", res[1357].exec("ab99"), 4072); -assertEquals("x", res[1357].exec("x{123}x{123}45"), 4073); -assertEquals("x", res[1357].exec("x{400}x{401}x{402}6 "), 4074); -assertEquals("*", res[1357].exec("*** Failers"), 4075); -assertEquals("d", res[1357].exec("d99"), 4076); -assertEquals("x", res[1357].exec("x{123}x{122}4 "), 4077); -assertEquals("x", res[1357].exec("x{400}x{403}6 "), 4078); -assertEquals("x", res[1357].exec("x{400}x{401}x{402}x{402}6 "), 4079); -assertEquals(null, res[1358].exec("\ufffd]", 4080)); -assertEquals(null, res[1358].exec("\ufffd", 4081)); -assertEquals(null, res[1358].exec("\ufffd\ufffd\ufffd", 4082)); -assertEquals(null, res[1358].exec("\ufffd\ufffd\ufffd?", 4083)); -assertEquals("acb", res[1359].exec("acb"), 4084); -assertEquals("ab", res[1359].exec("ab"), 4085); -assertEquals(null, res[1359].exec("ax{100}b ", 4086)); -assertEquals(null, res[1359].exec("*** Failers", 4087)); -assertEquals(null, res[1359].exec("a\nb ", 4088)); -assertEquals(null, res[1360].exec("ax{4000}xyb ", 4089)); -assertEquals(null, res[1360].exec("ax{4000}yb ", 4090)); -assertEquals(null, res[1360].exec("ax{4000}x{100}yb ", 4091)); -assertEquals(null, res[1360].exec("*** Failers", 4092)); -assertEquals(null, res[1360].exec("ax{4000}b ", 4093)); -assertEquals(null, res[1360].exec("ac\ncb ", 4094)); -assertEquals("a\xc0,,\xc0", res[1361].exec("a\xc0\x88b"), 4095); -assertEquals("ax,,x", res[1362].exec("ax{100}b"), 4096); -assertEquals("a\xc0\x88b,\xc0\x88,b", res[1363].exec("a\xc0\x88b"), 4097); -assertEquals("ax{100}b,x{100},b", res[1364].exec("ax{100}b"), 4098); -assertEquals("a\xc0\x92,\xc0,\x92", res[1365].exec("a\xc0\x92bcd"), 4099); -assertEquals("ax{,x,{", res[1366].exec("ax{240}bcd"), 4100); -assertEquals("a\xc0\x92,\xc0,\x92", res[1367].exec("a\xc0\x92bcd"), 4101); -assertEquals("ax{,x,{", res[1368].exec("ax{240}bcd"), 4102); -assertEquals("a\xc0,,\xc0", res[1369].exec("a\xc0\x92bcd"), 4103); -assertEquals("ax,,x", res[1370].exec("ax{240}bcd"), 4104); -assertEquals(null, res[1371].exec("ax{1234}xyb ", 4105)); -assertEquals(null, res[1371].exec("ax{1234}x{4321}yb ", 4106)); -assertEquals(null, res[1371].exec("ax{1234}x{4321}x{3412}b ", 4107)); -assertEquals(null, res[1371].exec("*** Failers", 4108)); -assertEquals(null, res[1371].exec("ax{1234}b ", 4109)); -assertEquals(null, res[1371].exec("ac\ncb ", 4110)); -assertEquals("ax{1234}xyb,x{1234}xy", res[1372].exec("ax{1234}xyb "), 4111); -assertEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[1372].exec("ax{1234}x{4321}yb "), 4112); -assertEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[1372].exec("ax{1234}x{4321}x{3412}b "), 4113); -assertEquals("axxxxbcdefghijb,xxxxbcdefghij", res[1372].exec("axxxxbcdefghijb "), 4114); -assertEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[1372].exec("ax{1234}x{4321}x{3412}x{3421}b "), 4115); -assertEquals(null, res[1372].exec("*** Failers", 4116)); -assertEquals("ax{1234}b,x{1234}", res[1372].exec("ax{1234}b "), 4117); -assertEquals("ax{1234}xyb,x{1234}xy", res[1373].exec("ax{1234}xyb "), 4118); -assertEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[1373].exec("ax{1234}x{4321}yb "), 4119); -assertEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[1373].exec("ax{1234}x{4321}x{3412}b "), 4120); -assertEquals("axxxxb,xxxx", res[1373].exec("axxxxbcdefghijb "), 4121); -assertEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[1373].exec("ax{1234}x{4321}x{3412}x{3421}b "), 4122); -assertEquals(null, res[1373].exec("*** Failers", 4123)); -assertEquals("ax{1234}b,x{1234}", res[1373].exec("ax{1234}b "), 4124); -assertEquals(null, res[1374].exec("ax{1234}xyb ", 4125)); -assertEquals(null, res[1374].exec("ax{1234}x{4321}yb ", 4126)); -assertEquals(null, res[1374].exec("ax{1234}x{4321}x{3412}b ", 4127)); -assertEquals("axxxxb,xxxx", res[1374].exec("axxxxbcdefghijb "), 4128); -assertEquals(null, res[1374].exec("ax{1234}x{4321}x{3412}x{3421}b ", 4129)); -assertEquals("axbxxb,xbxx", res[1374].exec("axbxxbcdefghijb "), 4130); -assertEquals("axxxxxb,xxxxx", res[1374].exec("axxxxxbcdefghijb "), 4131); -assertEquals(null, res[1374].exec("*** Failers", 4132)); -assertEquals(null, res[1374].exec("ax{1234}b ", 4133)); -assertEquals(null, res[1374].exec("axxxxxxbcdefghijb ", 4134)); -assertEquals(null, res[1375].exec("ax{1234}xyb ", 4135)); -assertEquals(null, res[1375].exec("ax{1234}x{4321}yb ", 4136)); -assertEquals(null, res[1375].exec("ax{1234}x{4321}x{3412}b ", 4137)); -assertEquals("axxxxb,xxxx", res[1375].exec("axxxxbcdefghijb "), 4138); -assertEquals(null, res[1375].exec("ax{1234}x{4321}x{3412}x{3421}b ", 4139)); -assertEquals("axbxxb,xbxx", res[1375].exec("axbxxbcdefghijb "), 4140); -assertEquals("axxxxxb,xxxxx", res[1375].exec("axxxxxbcdefghijb "), 4141); -assertEquals(null, res[1375].exec("*** Failers", 4142)); -assertEquals(null, res[1375].exec("ax{1234}b ", 4143)); -assertEquals(null, res[1375].exec("axxxxxxbcdefghijb ", 4144)); -assertEquals(null, res[1375].exec("*** Failers", 4145)); -assertEquals(null, res[1375].exec("x{100}", 4146)); -assertEquals(null, res[1375].exec("aXbcd", 4147)); -assertEquals(null, res[1375].exec("ax{100}bcd", 4148)); -assertEquals(null, res[1375].exec("ax{100000}bcd", 4149)); -assertEquals(null, res[1375].exec("x{100}x{100}x{100}b", 4150)); -assertEquals(null, res[1375].exec("*** Failers ", 4151)); -assertEquals(null, res[1375].exec("x{100}x{100}b", 4152)); -assertEquals(null, res[1375].exec("x{ab} ", 4153)); -assertEquals(null, res[1375].exec("\xc2\xab", 4154)); -assertEquals(null, res[1375].exec("*** Failers ", 4155)); -assertEquals(null, res[1375].exec("\x00{ab}", 4156)); -assertEquals(null, res[1375].exec("WXYZ", 4157)); -assertEquals(null, res[1375].exec("x{256}XYZ ", 4158)); -assertEquals(null, res[1375].exec("*** Failers", 4159)); -assertEquals(null, res[1375].exec("XYZ ", 4160)); -assertEquals("bcd", res[1376].exec("bcd"), 4161); -assertEquals("00}", res[1376].exec("x{100}aYx{256}Z "), 4162); -assertEquals("x{", res[1377].exec("x{100}bc"), 4163); -assertEquals("x{100}bcA", res[1378].exec("x{100}bcAa"), 4164); -assertEquals("x{", res[1379].exec("x{100}bca"), 4165); -assertEquals("bcd", res[1380].exec("bcd"), 4166); -assertEquals("00}", res[1380].exec("x{100}aYx{256}Z "), 4167); -assertEquals("x{", res[1381].exec("x{100}bc"), 4168); -assertEquals("x{100}bc", res[1382].exec("x{100}bcAa"), 4169); -assertEquals("x{", res[1383].exec("x{100}bca"), 4170); -assertEquals(null, res[1383].exec("abcd", 4171)); -assertEquals(null, res[1383].exec("abcd", 4172)); -assertEquals("x{", res[1383].exec("x{100}x{100} "), 4173); -assertEquals("x{", res[1383].exec("x{100}x{100} "), 4174); -assertEquals("x{", res[1383].exec("x{100}x{100}x{100}x{100} "), 4175); -assertEquals(null, res[1383].exec("abce", 4176)); -assertEquals("x{", res[1383].exec("x{100}x{100}x{100}x{100} "), 4177); -assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100} ", 4178)); -assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100} ", 4179)); -assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100} ", 4180)); -assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}XX", 4181)); -assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 4182)); -assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 4183)); -assertEquals("Xy", res[1383].exec("Xyyyax{100}x{100}bXzzz"), 4184); -assertEquals("X", res[1386].exec("1X2"), 4185); -assertEquals("x", res[1386].exec("1x{100}2 "), 4186); -assertEquals(">X", res[1387].exec("> >X Y"), 4187); -assertEquals(">x", res[1387].exec("> >x{100} Y"), 4188); -assertEquals("1", res[1388].exec("x{100}3"), 4189); -assertEquals(" ", res[1389].exec("x{100} X"), 4190); -assertEquals("abcd", res[1390].exec("12abcd34"), 4191); -assertEquals("*** Failers", res[1390].exec("*** Failers"), 4192); -assertEquals(" ", res[1390].exec("1234 "), 4193); -assertEquals("abc", res[1391].exec("12abcd34"), 4194); -assertEquals("ab", res[1391].exec("12ab34"), 4195); -assertEquals("***", res[1391].exec("*** Failers "), 4196); -assertEquals(null, res[1391].exec("1234", 4197)); -assertEquals(" ", res[1391].exec("12a34 "), 4198); -assertEquals("ab", res[1392].exec("12abcd34"), 4199); -assertEquals("ab", res[1392].exec("12ab34"), 4200); -assertEquals("**", res[1392].exec("*** Failers "), 4201); -assertEquals(null, res[1392].exec("1234", 4202)); -assertEquals(" ", res[1392].exec("12a34 "), 4203); -assertEquals("12", res[1393].exec("12abcd34"), 4204); -assertEquals(null, res[1393].exec("*** Failers", 4205)); -assertEquals("12", res[1394].exec("12abcd34"), 4206); -assertEquals("123", res[1394].exec("1234abcd"), 4207); -assertEquals(null, res[1394].exec("*** Failers ", 4208)); -assertEquals(null, res[1394].exec("1.4 ", 4209)); -assertEquals("12", res[1395].exec("12abcd34"), 4210); -assertEquals("12", res[1395].exec("1234abcd"), 4211); -assertEquals(null, res[1395].exec("*** Failers ", 4212)); -assertEquals(null, res[1395].exec("1.4 ", 4213)); -assertEquals("12abcd34", res[1396].exec("12abcd34"), 4214); -assertEquals("***", res[1396].exec("*** Failers"), 4215); -assertEquals(null, res[1396].exec(" ", 4216)); -assertEquals("12a", res[1397].exec("12abcd34"), 4217); -assertEquals("123", res[1397].exec("1234abcd"), 4218); -assertEquals("***", res[1397].exec("*** Failers"), 4219); -assertEquals(null, res[1397].exec(" ", 4220)); -assertEquals("12", res[1398].exec("12abcd34"), 4221); -assertEquals("12", res[1398].exec("1234abcd"), 4222); -assertEquals("**", res[1398].exec("*** Failers"), 4223); -assertEquals(null, res[1398].exec(" ", 4224)); -assertEquals("> <", res[1399].exec("12> <34"), 4225); -assertEquals(null, res[1399].exec("*** Failers", 4226)); -assertEquals("> <", res[1400].exec("ab> <", res[1400].exec("ab> <", res[1401].exec("ab> <", res[1401].exec("ab> \xff<"), 4303); -assertEquals(null, res[1409].exec(">x{ff}<", 4304)); -assertEquals("X", res[1410].exec("XYZ"), 4305); -assertEquals("X", res[1411].exec("XYZ"), 4306); -assertEquals("x", res[1411].exec("x{123} "), 4307); -assertEquals(",", res[1416].exec("catac"), 4308); -assertEquals(",", res[1416].exec("ax{256}a "), 4309); -assertEquals(",", res[1416].exec("x{85}"), 4310); -assertEquals("abc1", res[1417].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 x{0085}abc7 x{2028}abc8 x{2029}abc9 JUNK"), 4311); -assertEquals("abc1", res[1418].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6x{0085} abc7x{2028} abc8x{2029} abc9"), 4312); -assertEquals(null, res[1419].exec("a\nb", 4313)); -assertEquals(null, res[1419].exec("a\x0db", 4314)); -assertEquals(null, res[1419].exec("a\x0d\nb", 4315)); -assertEquals(null, res[1419].exec("a\x0bb", 4316)); -assertEquals(null, res[1419].exec("a\x0cb", 4317)); -assertEquals(null, res[1419].exec("ax{85}b ", 4318)); -assertEquals(null, res[1419].exec("ax{2028}b ", 4319)); -assertEquals(null, res[1419].exec("ax{2029}b ", 4320)); -assertEquals(null, res[1419].exec("** Failers", 4321)); -assertEquals(null, res[1419].exec("a\n\x0db ", 4322)); -assertEquals("ab", res[1420].exec("ab"), 4323); -assertEquals(null, res[1420].exec("a\nb", 4324)); -assertEquals(null, res[1420].exec("a\x0db", 4325)); -assertEquals(null, res[1420].exec("a\x0d\nb", 4326)); -assertEquals(null, res[1420].exec("a\x0bb", 4327)); -assertEquals(null, res[1420].exec("a\x0cx{2028}x{2029}b", 4328)); -assertEquals(null, res[1420].exec("ax{85}b ", 4329)); -assertEquals(null, res[1420].exec("a\n\x0db ", 4330)); -assertEquals(null, res[1420].exec("a\n\x0dx{85}\x0cb ", 4331)); -assertEquals(null, res[1421].exec("a\nb", 4332)); -assertEquals(null, res[1421].exec("a\x0db", 4333)); -assertEquals(null, res[1421].exec("a\x0d\nb", 4334)); -assertEquals(null, res[1421].exec("a\x0bb", 4335)); -assertEquals(null, res[1421].exec("a\x0cx{2028}x{2029}b", 4336)); -assertEquals(null, res[1421].exec("ax{85}b ", 4337)); -assertEquals(null, res[1421].exec("a\n\x0db ", 4338)); -assertEquals(null, res[1421].exec("a\n\x0dx{85}\x0cb ", 4339)); -assertEquals(null, res[1421].exec("** Failers", 4340)); -assertEquals(null, res[1421].exec("ab ", 4341)); -assertEquals(null, res[1422].exec("a\nb", 4342)); -assertEquals(null, res[1422].exec("a\n\x0db", 4343)); -assertEquals(null, res[1422].exec("a\n\x0dx{85}b", 4344)); -assertEquals(null, res[1422].exec("a\x0d\n\x0d\nb ", 4345)); -assertEquals(null, res[1422].exec("a\x0d\n\x0d\n\x0d\nb ", 4346)); -assertEquals(null, res[1422].exec("a\n\x0d\n\x0db", 4347)); -assertEquals(null, res[1422].exec("a\n\n\x0d\nb ", 4348)); -assertEquals(null, res[1422].exec("** Failers", 4349)); -assertEquals(null, res[1422].exec("a\n\n\n\x0db", 4350)); -assertEquals(null, res[1422].exec("a\x0d", 4351)); -assertEquals(null, res[1423].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 4352)); -assertEquals(null, res[1424].exec(" x{a0}X\n\x0b\x0c\x0d\n", 4353)); -assertEquals(null, res[1425].exec(">\x09 x{a0}X\n\n\n<", 4354)); -assertEquals(null, res[1426].exec(">\x09 x{a0}X\n\n\n<", 4355)); -assertEquals(null, res[1427].exec("X X\n", 4356)); -assertEquals(null, res[1427].exec("X\x09X\x0b", 4357)); -assertEquals(null, res[1427].exec("** Failers", 4358)); -assertEquals(null, res[1427].exec("x{a0} X\n ", 4359)); -assertEquals(null, res[1428].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 4360)); -assertEquals(null, res[1428].exec("\x09 x{a0}\n\x0b\x0c\x0d\n", 4361)); -assertEquals(null, res[1428].exec("\x09 x{a0}\n\x0b\x0c", 4362)); -assertEquals(null, res[1428].exec("** Failers ", 4363)); -assertEquals(null, res[1428].exec("\x09 x{a0}\n\x0b", 4364)); -assertEquals(null, res[1428].exec(" ", 4365)); -assertEquals(null, res[1429].exec("x{3001}x{3000}x{2030}x{2028}", 4366)); -assertEquals(null, res[1429].exec("Xx{180e}Xx{85}", 4367)); -assertEquals(null, res[1429].exec("** Failers", 4368)); -assertEquals(null, res[1429].exec("x{2009} X\n ", 4369)); -assertEquals(null, res[1430].exec("x{1680}x{180e}x{2007}Xx{2028}x{2029}\x0c\x0d\n", 4370)); -assertEquals(null, res[1430].exec("\x09x{205f}x{a0}\nx{2029}\x0cx{2028}\n", 4371)); -assertEquals(null, res[1430].exec("\x09 x{202f}\n\x0b\x0c", 4372)); -assertEquals(null, res[1430].exec("** Failers ", 4373)); -assertEquals(null, res[1430].exec("\x09x{200a}x{a0}x{2028}\x0b", 4374)); -assertEquals(null, res[1430].exec(" ", 4375)); -assertEquals(null, res[1431].exec("a\x0db", 4376)); -assertEquals(null, res[1431].exec("a\nb", 4377)); -assertEquals(null, res[1431].exec("a\x0d\nb", 4378)); -assertEquals(null, res[1431].exec("** Failers", 4379)); -assertEquals(null, res[1431].exec("ax{85}b", 4380)); -assertEquals(null, res[1431].exec("a\x0bb ", 4381)); -assertEquals(null, res[1432].exec("a\x0db", 4382)); -assertEquals(null, res[1432].exec("a\nb", 4383)); -assertEquals(null, res[1432].exec("a\x0d\nb", 4384)); -assertEquals(null, res[1432].exec("ax{85}b", 4385)); -assertEquals(null, res[1432].exec("a\x0bb ", 4386)); -assertEquals(null, res[1432].exec("** Failers ", 4387)); -assertEquals(null, res[1432].exec("ax{85}b", 4388)); -assertEquals(null, res[1432].exec("a\x0bb", 4389)); -assertEquals(null, res[1433].exec("a\x0db", 4390)); -assertEquals(null, res[1433].exec("a\nb", 4391)); -assertEquals(null, res[1433].exec("a\x0d\nb", 4392)); -assertEquals(null, res[1433].exec("** Failers", 4393)); -assertEquals(null, res[1433].exec("ax{85}b", 4394)); -assertEquals(null, res[1433].exec("a\x0bb ", 4395)); -assertEquals(null, res[1434].exec("a\x0db", 4396)); -assertEquals(null, res[1434].exec("a\nb", 4397)); -assertEquals(null, res[1434].exec("a\x0d\nb", 4398)); -assertEquals(null, res[1434].exec("ax{85}b", 4399)); -assertEquals(null, res[1434].exec("a\x0bb ", 4400)); -assertEquals(null, res[1434].exec("** Failers ", 4401)); -assertEquals(null, res[1434].exec("ax{85}b", 4402)); -assertEquals(null, res[1434].exec("a\x0bb", 4403)); -assertEquals("X", res[1435].exec("Ax{1ec5}ABCXYZ"), 4404); -assertEquals(null, res[1437].exec("AB", 4405)); -assertEquals(null, res[1437].exec("*** Failers", 4406)); -assertEquals(null, res[1437].exec("A0", 4407)); -assertEquals(null, res[1437].exec("00 ", 4408)); -assertEquals(null, res[1438].exec("AB", 4409)); -assertEquals(null, res[1438].exec("Ax{300}BC ", 4410)); -assertEquals(null, res[1438].exec("Ax{300}x{301}x{302}BC ", 4411)); -assertEquals(null, res[1438].exec("*** Failers", 4412)); -assertEquals(null, res[1438].exec("x{300} ", 4413)); -assertEquals(null, res[1439].exec("ABC", 4414)); -assertEquals(null, res[1439].exec("Ax{300}Bx{300}x{301}C ", 4415)); -assertEquals(null, res[1439].exec("Ax{300}x{301}x{302}BC ", 4416)); -assertEquals(null, res[1439].exec("*** Failers", 4417)); -assertEquals(null, res[1439].exec("x{300} ", 4418)); -assertEquals(null, res[1440].exec("abcd", 4419)); -assertEquals(null, res[1440].exec("a ", 4420)); -assertEquals(null, res[1440].exec("*** Failers ", 4421)); -assertEquals(null, res[1441].exec("1234", 4422)); -assertEquals(null, res[1441].exec("= ", 4423)); -assertEquals(null, res[1441].exec("*** Failers ", 4424)); -assertEquals(null, res[1441].exec("abcd ", 4425)); -assertEquals(null, res[1442].exec("abcdAx{300}x{301}x{302}", 4426)); -assertEquals(null, res[1442].exec("Ax{300}x{301}x{302}", 4427)); -assertEquals(null, res[1442].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}", 4428)); -assertEquals(null, res[1442].exec("a ", 4429)); -assertEquals(null, res[1442].exec("*** Failers ", 4430)); -assertEquals(null, res[1442].exec("x{300}x{301}x{302}", 4431)); -assertEquals("abc", res[1443].exec("abc"), 4432); -assertEquals("abc", res[1443].exec("Ax{300}abc"), 4433); -assertEquals("abc", res[1443].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz"), 4434); -assertEquals("abc", res[1443].exec("x{300}abc "), 4435); -assertEquals(null, res[1443].exec("*** Failers", 4436)); -assertEquals("abc", res[1444].exec("abc"), 4437); -assertEquals(null, res[1444].exec("Ax{300}abc", 4438)); -assertEquals(null, res[1444].exec("*** Failers", 4439)); -assertEquals(null, res[1444].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz", 4440)); -assertEquals(null, res[1444].exec("x{300}abc ", 4441)); -assertEquals("abc", res[1445].exec("abc"), 4442); -assertEquals("abc", res[1445].exec("Ax{300}abc"), 4443); -assertEquals("abc", res[1445].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz"), 4444); -assertEquals("abc", res[1445].exec("x{300}abc "), 4445); -assertEquals(null, res[1445].exec("*** Failers", 4446)); -assertEquals("abc", res[1446].exec("abc"), 4447); -assertEquals(null, res[1446].exec("Ax{300}abc", 4448)); -assertEquals(null, res[1446].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz", 4449)); -assertEquals(null, res[1446].exec("*** Failers", 4450)); -assertEquals(null, res[1446].exec("x{300}abc ", 4451)); -assertEquals(null, res[1447].exec("A=b", 4452)); -assertEquals(null, res[1447].exec("=c ", 4453)); -assertEquals(null, res[1447].exec("*** Failers", 4454)); -assertEquals(null, res[1447].exec("1=2 ", 4455)); -assertEquals(null, res[1447].exec("AAAA=b ", 4456)); -assertEquals(null, res[1448].exec("AAAA=b", 4457)); -assertEquals(null, res[1448].exec("=c ", 4458)); -assertEquals(null, res[1448].exec("*** Failers", 4459)); -assertEquals(null, res[1448].exec("1=2 ", 4460)); -assertEquals(null, res[1449].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}X", 4461)); -assertEquals(null, res[1449].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}Ax{300}x{301}x{302}X ", 4462)); -assertEquals(null, res[1449].exec("*** Failers", 4463)); -assertEquals(null, res[1449].exec("X", 4464)); -assertEquals(null, res[1449].exec("Ax{300}x{301}x{302}X", 4465)); -assertEquals(null, res[1449].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}Ax{300}x{301}x{302}Ax{300}x{301}x{302}X", 4466)); -assertEquals(null, res[1450].exec("x{c0}x{30f}x{660}x{66c}x{f01}x{1680}<", 4467)); -assertEquals(null, res[1450].exec("\npx{300}9!$ < ", 4468)); -assertEquals(null, res[1450].exec("** Failers ", 4469)); -assertEquals(null, res[1450].exec("apx{300}9!$ < ", 4470)); -assertEquals(null, res[1451].exec("X", 4471)); -assertEquals(null, res[1451].exec("** Failers ", 4472)); -assertEquals(null, res[1451].exec("", 4473)); -assertEquals(null, res[1452].exec("9", 4474)); -assertEquals(null, res[1452].exec("** Failers ", 4475)); -assertEquals(null, res[1452].exec("x{c0}", 4476)); -assertEquals(null, res[1453].exec("X", 4477)); -assertEquals(null, res[1453].exec("** Failers ", 4478)); -assertEquals(null, res[1453].exec("x{30f}", 4479)); -assertEquals(null, res[1454].exec("X", 4480)); -assertEquals(null, res[1454].exec("** Failers ", 4481)); -assertEquals(null, res[1454].exec("x{660}", 4482)); -assertEquals(null, res[1455].exec("X", 4483)); -assertEquals(null, res[1455].exec("** Failers ", 4484)); -assertEquals(null, res[1455].exec("x{66c}", 4485)); -assertEquals(null, res[1456].exec("X", 4486)); -assertEquals(null, res[1456].exec("** Failers ", 4487)); -assertEquals(null, res[1456].exec("x{f01}", 4488)); -assertEquals(null, res[1457].exec("X", 4489)); -assertEquals(null, res[1457].exec("** Failers ", 4490)); -assertEquals(null, res[1457].exec("x{1680}", 4491)); -assertEquals(null, res[1458].exec("x{017}", 4492)); -assertEquals(null, res[1458].exec("x{09f} ", 4493)); -assertEquals(null, res[1458].exec("** Failers", 4494)); -assertEquals(null, res[1458].exec("x{0600} ", 4495)); -assertEquals(null, res[1459].exec("x{601}", 4496)); -assertEquals(null, res[1459].exec("** Failers", 4497)); -assertEquals(null, res[1459].exec("x{09f} ", 4498)); -assertEquals(null, res[1460].exec("** Failers", 4499)); -assertEquals(null, res[1460].exec("x{09f} ", 4500)); -assertEquals(null, res[1461].exec("x{f8ff}", 4501)); -assertEquals(null, res[1461].exec("** Failers", 4502)); -assertEquals(null, res[1461].exec("x{09f} ", 4503)); -assertEquals(null, res[1462].exec("?x{dfff}", 4504)); -assertEquals(null, res[1462].exec("** Failers", 4505)); -assertEquals(null, res[1462].exec("x{09f} ", 4506)); -assertEquals(null, res[1463].exec("a", 4507)); -assertEquals(null, res[1463].exec("** Failers ", 4508)); -assertEquals(null, res[1463].exec("Z", 4509)); -assertEquals(null, res[1463].exec("x{e000} ", 4510)); -assertEquals(null, res[1464].exec("x{2b0}", 4511)); -assertEquals(null, res[1464].exec("** Failers", 4512)); -assertEquals(null, res[1464].exec("a ", 4513)); -assertEquals(null, res[1465].exec("x{1bb}", 4514)); -assertEquals(null, res[1465].exec("** Failers", 4515)); -assertEquals(null, res[1465].exec("a ", 4516)); -assertEquals(null, res[1465].exec("x{2b0}", 4517)); -assertEquals(null, res[1466].exec("x{1c5}", 4518)); -assertEquals(null, res[1466].exec("** Failers", 4519)); -assertEquals(null, res[1466].exec("a ", 4520)); -assertEquals(null, res[1466].exec("x{2b0}", 4521)); -assertEquals(null, res[1467].exec("A", 4522)); -assertEquals(null, res[1467].exec("** Failers", 4523)); -assertEquals(null, res[1467].exec("x{2b0}", 4524)); -assertEquals(null, res[1468].exec("x{903}", 4525)); -assertEquals(null, res[1468].exec("** Failers", 4526)); -assertEquals(null, res[1468].exec("X", 4527)); -assertEquals(null, res[1468].exec("x{300}", 4528)); -assertEquals(null, res[1468].exec(" ", 4529)); -assertEquals(null, res[1469].exec("x{488}", 4530)); -assertEquals(null, res[1469].exec("** Failers", 4531)); -assertEquals(null, res[1469].exec("X", 4532)); -assertEquals(null, res[1469].exec("x{903}", 4533)); -assertEquals(null, res[1469].exec("x{300}", 4534)); -assertEquals(null, res[1470].exec("x{300}", 4535)); -assertEquals(null, res[1470].exec("** Failers", 4536)); -assertEquals(null, res[1470].exec("X", 4537)); -assertEquals(null, res[1470].exec("x{903}", 4538)); -assertEquals(null, res[1470].exec("0123456789x{660}x{661}x{662}x{663}x{664}x{665}x{666}x{667}x{668}x{669}x{66a}", 4539)); -assertEquals(null, res[1470].exec("x{6f0}x{6f1}x{6f2}x{6f3}x{6f4}x{6f5}x{6f6}x{6f7}x{6f8}x{6f9}x{6fa}", 4540)); -assertEquals(null, res[1470].exec("x{966}x{967}x{968}x{969}x{96a}x{96b}x{96c}x{96d}x{96e}x{96f}x{970}", 4541)); -assertEquals(null, res[1470].exec("** Failers", 4542)); -assertEquals(null, res[1470].exec("X", 4543)); -assertEquals(null, res[1471].exec("x{16ee}", 4544)); -assertEquals(null, res[1471].exec("** Failers", 4545)); -assertEquals(null, res[1471].exec("X", 4546)); -assertEquals(null, res[1471].exec("x{966}", 4547)); -assertEquals(null, res[1472].exec("x{b2}", 4548)); -assertEquals(null, res[1472].exec("x{b3}", 4549)); -assertEquals(null, res[1472].exec("** Failers", 4550)); -assertEquals(null, res[1472].exec("X", 4551)); -assertEquals(null, res[1472].exec("x{16ee}", 4552)); -assertEquals(null, res[1473].exec("_", 4553)); -assertEquals(null, res[1473].exec("x{203f}", 4554)); -assertEquals(null, res[1473].exec("** Failers", 4555)); -assertEquals(null, res[1473].exec("X", 4556)); -assertEquals(null, res[1473].exec("-", 4557)); -assertEquals(null, res[1473].exec("x{58a}", 4558)); -assertEquals(null, res[1474].exec("-", 4559)); -assertEquals(null, res[1474].exec("x{58a}", 4560)); -assertEquals(null, res[1474].exec("** Failers", 4561)); -assertEquals(null, res[1474].exec("X", 4562)); -assertEquals(null, res[1474].exec("x{203f}", 4563)); -assertEquals(null, res[1475].exec(")", 4564)); -assertEquals(null, res[1475].exec("]", 4565)); -assertEquals(null, res[1475].exec("}", 4566)); -assertEquals(null, res[1475].exec("x{f3b}", 4567)); -assertEquals(null, res[1475].exec("** Failers", 4568)); -assertEquals(null, res[1475].exec("X", 4569)); -assertEquals(null, res[1475].exec("x{203f}", 4570)); -assertEquals(null, res[1475].exec("(", 4571)); -assertEquals(null, res[1475].exec("[", 4572)); -assertEquals(null, res[1475].exec("{", 4573)); -assertEquals(null, res[1475].exec("x{f3c}", 4574)); -assertEquals(null, res[1476].exec("x{bb}", 4575)); -assertEquals(null, res[1476].exec("x{2019}", 4576)); -assertEquals(null, res[1476].exec("** Failers", 4577)); -assertEquals(null, res[1476].exec("X", 4578)); -assertEquals(null, res[1476].exec("x{203f}", 4579)); -assertEquals(null, res[1477].exec("x{ab}", 4580)); -assertEquals(null, res[1477].exec("x{2018}", 4581)); -assertEquals(null, res[1477].exec("** Failers", 4582)); -assertEquals(null, res[1477].exec("X", 4583)); -assertEquals(null, res[1477].exec("x{203f}", 4584)); -assertEquals(null, res[1478].exec("!", 4585)); -assertEquals(null, res[1478].exec("x{37e}", 4586)); -assertEquals(null, res[1478].exec("** Failers", 4587)); -assertEquals(null, res[1478].exec("X", 4588)); -assertEquals(null, res[1478].exec("x{203f}", 4589)); -assertEquals(null, res[1479].exec("(", 4590)); -assertEquals(null, res[1479].exec("[", 4591)); -assertEquals(null, res[1479].exec("{", 4592)); -assertEquals(null, res[1479].exec("x{f3c}", 4593)); -assertEquals(null, res[1479].exec("** Failers", 4594)); -assertEquals(null, res[1479].exec("X", 4595)); -assertEquals(null, res[1479].exec(")", 4596)); -assertEquals(null, res[1479].exec("]", 4597)); -assertEquals(null, res[1479].exec("}", 4598)); -assertEquals(null, res[1479].exec("x{f3b}", 4599)); -assertEquals(null, res[1479].exec("$x{a2}x{a3}x{a4}x{a5}x{a6}", 4600)); -assertEquals(null, res[1479].exec("x{9f2}", 4601)); -assertEquals(null, res[1479].exec("** Failers", 4602)); -assertEquals(null, res[1479].exec("X", 4603)); -assertEquals(null, res[1479].exec("x{2c2}", 4604)); -assertEquals(null, res[1480].exec("x{2c2}", 4605)); -assertEquals(null, res[1480].exec("** Failers", 4606)); -assertEquals(null, res[1480].exec("X", 4607)); -assertEquals(null, res[1480].exec("x{9f2}", 4608)); -assertEquals(null, res[1480].exec("+<|~x{ac}x{2044}", 4609)); -assertEquals(null, res[1480].exec("** Failers", 4610)); -assertEquals(null, res[1480].exec("X", 4611)); -assertEquals(null, res[1480].exec("x{9f2}", 4612)); -assertEquals(null, res[1481].exec("x{a6}", 4613)); -assertEquals(null, res[1481].exec("x{482} ", 4614)); -assertEquals(null, res[1481].exec("** Failers", 4615)); -assertEquals(null, res[1481].exec("X", 4616)); -assertEquals(null, res[1481].exec("x{9f2}", 4617)); -assertEquals(null, res[1482].exec("x{2028}", 4618)); -assertEquals(null, res[1482].exec("** Failers", 4619)); -assertEquals(null, res[1482].exec("X", 4620)); -assertEquals(null, res[1482].exec("x{2029}", 4621)); -assertEquals(null, res[1483].exec("x{2029}", 4622)); -assertEquals(null, res[1483].exec("** Failers", 4623)); -assertEquals(null, res[1483].exec("X", 4624)); -assertEquals(null, res[1483].exec("x{2028}", 4625)); -assertEquals(null, res[1484].exec("\\ \\", 4626)); -assertEquals(null, res[1484].exec("x{a0}", 4627)); -assertEquals(null, res[1484].exec("x{1680}", 4628)); -assertEquals(null, res[1484].exec("x{180e}", 4629)); -assertEquals(null, res[1484].exec("x{2000}", 4630)); -assertEquals(null, res[1484].exec("x{2001} ", 4631)); -assertEquals(null, res[1484].exec("** Failers", 4632)); -assertEquals(null, res[1484].exec("x{2028}", 4633)); -assertEquals(null, res[1484].exec("x{200d} ", 4634)); -assertEquals(null, res[1484].exec(" x{660}x{661}x{662}ABC", 4635)); -assertEquals(null, res[1484].exec(" x{660}x{661}x{662}ABC", 4636)); -assertEquals(null, res[1485].exec(" x{660}x{661}x{662}ABC", 4637)); -assertEquals(null, res[1486].exec(" x{660}x{661}x{662}ABC", 4638)); -assertEquals(null, res[1487].exec(" x{660}x{661}x{662}ABC", 4639)); -assertEquals(null, res[1488].exec(" x{660}x{661}x{662}ABC", 4640)); -assertEquals(null, res[1489].exec(" x{660}x{661}x{662}ABC", 4641)); -assertEquals(null, res[1490].exec(" x{660}x{661}x{662}ABC", 4642)); -assertEquals(null, res[1491].exec(" x{660}x{661}x{662}ABC", 4643)); -assertEquals(null, res[1492].exec(" x{660}x{661}x{662}ABC", 4644)); -assertEquals(null, res[1493].exec(" x{660}x{661}x{662}ABC", 4645)); -assertEquals(null, res[1493].exec(" x{660}x{661}x{662}ABC", 4646)); -assertEquals(null, res[1493].exec(" x{660}x{661}x{662}ABC", 4647)); -assertEquals(null, res[1493].exec(" ** Failers", 4648)); -assertEquals(null, res[1493].exec(" x{660}x{661}x{662}ABC", 4649)); -assertEquals(null, res[1494].exec("A", 4650)); -assertEquals(null, res[1494].exec("ax{10a0}B ", 4651)); -assertEquals(null, res[1494].exec("** Failers ", 4652)); -assertEquals(null, res[1494].exec("a", 4653)); -assertEquals(null, res[1494].exec("x{1d00} ", 4654)); -assertEquals(null, res[1495].exec("1234", 4655)); -assertEquals(null, res[1495].exec("** Failers", 4656)); -assertEquals(null, res[1495].exec("ABC ", 4657)); -assertEquals(null, res[1496].exec("1234", 4658)); -assertEquals(null, res[1496].exec("** Failers", 4659)); -assertEquals(null, res[1496].exec("ABC ", 4660)); -assertEquals(null, res[1496].exec("A2XYZ", 4661)); -assertEquals(null, res[1496].exec("123A5XYZPQR", 4662)); -assertEquals(null, res[1496].exec("ABAx{660}XYZpqr", 4663)); -assertEquals(null, res[1496].exec("** Failers", 4664)); -assertEquals(null, res[1496].exec("AXYZ", 4665)); -assertEquals(null, res[1496].exec("XYZ ", 4666)); -assertEquals(null, res[1496].exec("1XYZ", 4667)); -assertEquals(null, res[1496].exec("AB=XYZ.. ", 4668)); -assertEquals(null, res[1496].exec("XYZ ", 4669)); -assertEquals(null, res[1496].exec("** Failers", 4670)); -assertEquals(null, res[1496].exec("WXYZ ", 4671)); -assertEquals(null, res[1497].exec("1234", 4672)); -assertEquals(null, res[1497].exec("1234", 4673)); -assertEquals(null, res[1497].exec("12-34", 4674)); -assertEquals("{", res[1497].exec("12+x{661}-34 "), 4675); -assertEquals(null, res[1497].exec("** Failers", 4676)); -assertEquals("d", res[1497].exec("abcd "), 4677); -assertEquals("d", res[1498].exec("abcd"), 4678); -assertEquals(null, res[1498].exec("** Failers", 4679)); -assertEquals(null, res[1498].exec("1234", 4680)); -assertEquals(null, res[1499].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4681)); -assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1499].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4682); -assertEquals(" ", res[1499].exec(" "), 4683); -assertEquals(null, res[1499].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4684)); -assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1499].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4685); -assertEquals(null, res[1500].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4686)); -assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1500].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4687); -assertEquals(null, res[1501].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4688)); -assertEquals(null, res[1501].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 4689)); -assertEquals(null, res[1502].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4690)); -assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1502].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4691); -assertEquals(null, res[1503].exec("a", 4692)); -assertEquals(null, res[1503].exec("A ", 4693)); -assertEquals(null, res[1504].exec("a", 4694)); -assertEquals(null, res[1504].exec("A ", 4695)); -assertEquals(null, res[1505].exec("A", 4696)); -assertEquals(null, res[1505].exec("aZ", 4697)); -assertEquals(null, res[1505].exec("** Failers", 4698)); -assertEquals(null, res[1505].exec("abc ", 4699)); -assertEquals(null, res[1506].exec("A", 4700)); -assertEquals(null, res[1506].exec("aZ", 4701)); -assertEquals(null, res[1506].exec("** Failers", 4702)); -assertEquals(null, res[1506].exec("abc ", 4703)); -assertEquals(null, res[1507].exec("a", 4704)); -assertEquals(null, res[1507].exec("Az", 4705)); -assertEquals(null, res[1507].exec("** Failers", 4706)); -assertEquals(null, res[1507].exec("ABC ", 4707)); -assertEquals(null, res[1508].exec("a", 4708)); -assertEquals(null, res[1508].exec("Az", 4709)); -assertEquals(null, res[1508].exec("** Failers", 4710)); -assertEquals(null, res[1508].exec("ABC ", 4711)); -assertEquals(null, res[1508].exec("x{c0}", 4712)); -assertEquals(null, res[1508].exec("x{e0} ", 4713)); -assertEquals(null, res[1508].exec("x{c0}", 4714)); -assertEquals(null, res[1508].exec("x{e0} ", 4715)); -assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 4716)); -assertEquals(null, res[1508].exec("** Failers", 4717)); -assertEquals(null, res[1508].exec("ax{391}x{10427}x{ff3a}x{1fb0} ", 4718)); -assertEquals(null, res[1508].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 4719)); -assertEquals(null, res[1508].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 4720)); -assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 4721)); -assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 4722)); -assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 4723)); -assertEquals(null, res[1508].exec("ax{391}x{10427}x{ff3a}x{1fb0} ", 4724)); -assertEquals(null, res[1508].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 4725)); -assertEquals(null, res[1508].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 4726)); -assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 4727)); -assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 4728)); -assertEquals(null, res[1508].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}", 4729)); -assertEquals(null, res[1508].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 4730)); -assertEquals(null, res[1508].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 4731)); -assertEquals(null, res[1508].exec("x{391}", 4732)); -assertEquals(null, res[1508].exec("x{ff3a}", 4733)); -assertEquals(null, res[1508].exec("x{3b1}", 4734)); -assertEquals(null, res[1508].exec("x{ff5a} ", 4735)); -assertEquals(null, res[1508].exec("x{c0}", 4736)); -assertEquals(null, res[1508].exec("x{e0} ", 4737)); -assertEquals(null, res[1508].exec("x{104}", 4738)); -assertEquals(null, res[1508].exec("x{105}", 4739)); -assertEquals(null, res[1508].exec("x{109} ", 4740)); -assertEquals(null, res[1508].exec("** Failers", 4741)); -assertEquals(null, res[1508].exec("x{100}", 4742)); -assertEquals(null, res[1508].exec("x{10a} ", 4743)); -assertEquals(null, res[1508].exec("Z", 4744)); -assertEquals(null, res[1508].exec("z", 4745)); -assertEquals(null, res[1508].exec("x{39c}", 4746)); -assertEquals(null, res[1508].exec("x{178}", 4747)); -assertEquals(null, res[1508].exec("|", 4748)); -assertEquals(null, res[1508].exec("x{80}", 4749)); -assertEquals(null, res[1508].exec("x{ff}", 4750)); -assertEquals(null, res[1508].exec("x{100}", 4751)); -assertEquals(null, res[1508].exec("x{101} ", 4752)); -assertEquals(null, res[1508].exec("** Failers", 4753)); -assertEquals(null, res[1508].exec("x{102}", 4754)); -assertEquals(null, res[1508].exec("Y", 4755)); -assertEquals(null, res[1508].exec("y ", 4756)); -assertEquals(null, res[1509].exec("A", 4757)); -assertEquals(null, res[1509].exec("Ax{300}BC ", 4758)); -assertEquals(null, res[1509].exec("Ax{300}x{301}x{302}BC ", 4759)); -assertEquals(null, res[1509].exec("*** Failers", 4760)); -assertEquals(null, res[1509].exec("x{300} ", 4761)); -assertEquals("X", res[1510].exec("X123"), 4762); -assertEquals(null, res[1510].exec("*** Failers", 4763)); -assertEquals(null, res[1510].exec("AXYZ", 4764)); -assertEquals(null, res[1511].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 4765)); -assertEquals(null, res[1511].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 4766)); -assertEquals(null, res[1512].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 4767)); -assertEquals(null, res[1512].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 4768)); -assertEquals("A,,A", res[1513].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 4769); -assertEquals("A,,A", res[1513].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 4770); -assertEquals("A,,A", res[1514].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 4771); -assertEquals("A,,A", res[1514].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 4772); -assertEquals(null, res[1515].exec("*** Failers", 4773)); -assertEquals(null, res[1515].exec("Ax{300}x{301}x{302}", 4774)); -assertEquals(null, res[1516].exec("Ax{300}x{301}Bx{300}X", 4775)); -assertEquals(null, res[1516].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 4776)); -assertEquals(null, res[1516].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 4777)); -assertEquals(null, res[1516].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 4778)); -assertEquals(null, res[1517].exec("Ax{300}x{301}Bx{300}X", 4779)); -assertEquals(null, res[1517].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 4780)); -assertEquals(null, res[1517].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 4781)); -assertEquals(null, res[1517].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 4782)); -assertEquals(null, res[1518].exec("12X", 4783)); -assertEquals(null, res[1518].exec("123X", 4784)); -assertEquals(null, res[1518].exec("*** Failers", 4785)); -assertEquals(null, res[1518].exec("X", 4786)); -assertEquals(null, res[1518].exec("1X", 4787)); -assertEquals(null, res[1518].exec("1234X ", 4788)); -assertEquals(null, res[1518].exec("x{100} ", 4789)); -assertEquals(null, res[1518].exec("x{101} ", 4790)); -assertEquals(null, res[1518].exec("x{2e81}x{3007}x{2f804}x{31a0}", 4791)); -assertEquals(null, res[1518].exec("** Failers", 4792)); -assertEquals(null, res[1518].exec("x{2e7f} ", 4793)); -assertEquals(null, res[1518].exec("x{3105}", 4794)); -assertEquals(null, res[1518].exec("** Failers", 4795)); -assertEquals(null, res[1518].exec("x{30ff} ", 4796)); -assertEquals(null, res[1519].exec("x{06e9}", 4797)); -assertEquals(null, res[1519].exec("x{060b}", 4798)); -assertEquals(null, res[1519].exec("** Failers", 4799)); -assertEquals(null, res[1519].exec("Xx{06e9} ", 4800)); -assertEquals(null, res[1520].exec("x{2f800}", 4801)); -assertEquals(null, res[1520].exec("** Failers", 4802)); -assertEquals(null, res[1520].exec("x{a014}", 4803)); -assertEquals(null, res[1520].exec("x{a4c6} ", 4804)); -assertEquals(null, res[1521].exec("AXYZ", 4805)); -assertEquals(null, res[1521].exec("x{1234}XYZ ", 4806)); -assertEquals(null, res[1521].exec("** Failers", 4807)); -assertEquals(null, res[1521].exec("X ", 4808)); -assertEquals(null, res[1522].exec("** Failers", 4809)); -assertEquals(null, res[1522].exec("AX", 4810)); -assertEquals(null, res[1523].exec("XYZ", 4811)); -assertEquals(null, res[1523].exec("AXYZ", 4812)); -assertEquals(null, res[1523].exec("x{1234}XYZ ", 4813)); -assertEquals(null, res[1523].exec("** Failers", 4814)); -assertEquals(null, res[1523].exec("ABXYZ ", 4815)); -assertEquals(null, res[1524].exec("XYZ", 4816)); -assertEquals(null, res[1524].exec("** Failers", 4817)); -assertEquals(null, res[1524].exec("AXYZ", 4818)); -assertEquals(null, res[1524].exec("x{1234}XYZ ", 4819)); -assertEquals(null, res[1524].exec("ABXYZ ", 4820)); -assertEquals(null, res[1524].exec("AXYZ", 4821)); -assertEquals(null, res[1524].exec("x{1234}XYZ", 4822)); -assertEquals(null, res[1524].exec("Ax{1234}XYZ", 4823)); -assertEquals(null, res[1524].exec("** Failers", 4824)); -assertEquals(null, res[1524].exec("XYZ", 4825)); -assertEquals(null, res[1524].exec("** Failers", 4826)); -assertEquals(null, res[1524].exec("AXYZ", 4827)); -assertEquals(null, res[1524].exec("x{1234}XYZ", 4828)); -assertEquals(null, res[1524].exec("Ax{1234}XYZ", 4829)); -assertEquals(null, res[1524].exec("XYZ", 4830)); -assertEquals(null, res[1525].exec("XYZ", 4831)); -assertEquals(null, res[1525].exec("AXYZ", 4832)); -assertEquals(null, res[1525].exec("x{1234}XYZ", 4833)); -assertEquals(null, res[1525].exec("Ax{1234}XYZ", 4834)); -assertEquals(null, res[1525].exec("** Failers", 4835)); -assertEquals(null, res[1526].exec("XYZ", 4836)); -assertEquals(null, res[1526].exec("** Failers", 4837)); -assertEquals(null, res[1526].exec("AXYZ", 4838)); -assertEquals(null, res[1526].exec("x{1234}XYZ", 4839)); -assertEquals(null, res[1526].exec("Ax{1234}XYZ", 4840)); -assertEquals("AX", res[1527].exec("AXYZ"), 4841); -assertEquals(null, res[1527].exec("x{1234}XYZ ", 4842)); -assertEquals(null, res[1527].exec("** Failers", 4843)); -assertEquals(null, res[1527].exec("X ", 4844)); -assertEquals(null, res[1528].exec("** Failers", 4845)); -assertEquals("AX", res[1528].exec("AX"), 4846); -assertEquals("X", res[1529].exec("XYZ"), 4847); -assertEquals("AX", res[1529].exec("AXYZ"), 4848); -assertEquals(null, res[1529].exec("x{1234}XYZ ", 4849)); -assertEquals(null, res[1529].exec("** Failers", 4850)); -assertEquals(null, res[1529].exec("ABXYZ ", 4851)); -assertEquals("X", res[1530].exec("XYZ"), 4852); -assertEquals(null, res[1530].exec("** Failers", 4853)); -assertEquals("AX", res[1530].exec("AXYZ"), 4854); -assertEquals(null, res[1530].exec("x{1234}XYZ ", 4855)); -assertEquals(null, res[1530].exec("ABXYZ ", 4856)); -assertEquals("AX", res[1531].exec("AXYZ"), 4857); -assertEquals(null, res[1531].exec("x{1234}XYZ", 4858)); -assertEquals(null, res[1531].exec("Ax{1234}XYZ", 4859)); -assertEquals(null, res[1531].exec("** Failers", 4860)); -assertEquals(null, res[1531].exec("XYZ", 4861)); -assertEquals(null, res[1532].exec("** Failers", 4862)); -assertEquals("AX", res[1532].exec("AXYZ"), 4863); -assertEquals(null, res[1532].exec("x{1234}XYZ", 4864)); -assertEquals(null, res[1532].exec("Ax{1234}XYZ", 4865)); -assertEquals(null, res[1532].exec("XYZ", 4866)); -assertEquals("X", res[1533].exec("XYZ"), 4867); -assertEquals("AX", res[1533].exec("AXYZ"), 4868); -assertEquals(null, res[1533].exec("x{1234}XYZ", 4869)); -assertEquals(null, res[1533].exec("Ax{1234}XYZ", 4870)); -assertEquals(null, res[1533].exec("** Failers", 4871)); -assertEquals("X", res[1534].exec("XYZ"), 4872); -assertEquals(null, res[1534].exec("** Failers", 4873)); -assertEquals("AX", res[1534].exec("AXYZ"), 4874); -assertEquals(null, res[1534].exec("x{1234}XYZ", 4875)); -assertEquals(null, res[1534].exec("Ax{1234}XYZ", 4876)); -assertEquals(null, res[1535].exec("abcdefgh", 4877)); -assertEquals(null, res[1535].exec("x{1234}\n\x0dx{3456}xyz ", 4878)); -assertEquals(null, res[1536].exec("abcdefgh", 4879)); -assertEquals(null, res[1536].exec("x{1234}\n\x0dx{3456}xyz ", 4880)); -assertEquals(null, res[1537].exec("** Failers", 4881)); -assertEquals(null, res[1537].exec("abcdefgh", 4882)); -assertEquals(null, res[1537].exec("x{1234}\n\x0dx{3456}xyz ", 4883)); -assertEquals(null, res[1538].exec(" AXY", 4884)); -assertEquals(null, res[1538].exec(" aXY", 4885)); -assertEquals(null, res[1538].exec(" x{1c5}XY", 4886)); -assertEquals(null, res[1538].exec(" ** Failers", 4887)); -assertEquals(null, res[1538].exec(" x{1bb}XY", 4888)); -assertEquals(null, res[1538].exec(" x{2b0}XY", 4889)); -assertEquals(null, res[1538].exec(" !XY ", 4890)); -assertEquals(null, res[1539].exec(" AXY", 4891)); -assertEquals(null, res[1539].exec(" aXY", 4892)); -assertEquals(null, res[1539].exec(" x{1c5}XY", 4893)); -assertEquals(null, res[1539].exec(" ** Failers", 4894)); -assertEquals(null, res[1539].exec(" x{1bb}XY", 4895)); -assertEquals(null, res[1539].exec(" x{2b0}XY", 4896)); -assertEquals(null, res[1539].exec(" !XY ", 4897)); -assertEquals(null, res[1539].exec(" AXY", 4898)); -assertEquals(null, res[1539].exec(" aXY", 4899)); -assertEquals(null, res[1539].exec(" AbcdeXyz ", 4900)); -assertEquals(null, res[1539].exec(" x{1c5}AbXY", 4901)); -assertEquals(null, res[1539].exec(" abcDEXypqreXlmn ", 4902)); -assertEquals(null, res[1539].exec(" ** Failers", 4903)); -assertEquals(null, res[1539].exec(" x{1bb}XY", 4904)); -assertEquals(null, res[1539].exec(" x{2b0}XY", 4905)); -assertEquals(null, res[1539].exec(" !XY ", 4906)); -assertEquals(null, res[1540].exec(" AXY", 4907)); -assertEquals(null, res[1540].exec(" aXY", 4908)); -assertEquals(null, res[1540].exec(" AbcdeXyz ", 4909)); -assertEquals(null, res[1540].exec(" x{1c5}AbXY", 4910)); -assertEquals(null, res[1540].exec(" abcDEXypqreXlmn ", 4911)); -assertEquals(null, res[1540].exec(" ** Failers", 4912)); -assertEquals(null, res[1540].exec(" x{1bb}XY", 4913)); -assertEquals(null, res[1540].exec(" x{2b0}XY", 4914)); -assertEquals(null, res[1540].exec(" !XY ", 4915)); -assertEquals(null, res[1540].exec(" AXY", 4916)); -assertEquals(null, res[1540].exec(" aXY", 4917)); -assertEquals(null, res[1540].exec(" AbcdeXyz ", 4918)); -assertEquals(null, res[1540].exec(" x{1c5}AbXY", 4919)); -assertEquals(null, res[1540].exec(" abcDEXypqreXlmn ", 4920)); -assertEquals(null, res[1540].exec(" ** Failers", 4921)); -assertEquals(null, res[1540].exec(" x{1bb}XY", 4922)); -assertEquals(null, res[1540].exec(" x{2b0}XY", 4923)); -assertEquals(null, res[1540].exec(" !XY ", 4924)); -assertEquals(null, res[1541].exec(" AXY", 4925)); -assertEquals(null, res[1541].exec(" aXY", 4926)); -assertEquals(null, res[1541].exec(" AbcdeXyz ", 4927)); -assertEquals(null, res[1541].exec(" x{1c5}AbXY", 4928)); -assertEquals(null, res[1541].exec(" abcDEXypqreXlmn ", 4929)); -assertEquals(null, res[1541].exec(" ** Failers", 4930)); -assertEquals(null, res[1541].exec(" x{1bb}XY", 4931)); -assertEquals(null, res[1541].exec(" x{2b0}XY", 4932)); -assertEquals(null, res[1541].exec(" !XY ", 4933)); -assertEquals(null, res[1542].exec(" !XY", 4934)); -assertEquals(null, res[1542].exec(" x{1bb}XY", 4935)); -assertEquals(null, res[1542].exec(" x{2b0}XY", 4936)); -assertEquals(null, res[1542].exec(" ** Failers", 4937)); -assertEquals(null, res[1542].exec(" x{1c5}XY", 4938)); -assertEquals(null, res[1542].exec(" AXY ", 4939)); -assertEquals(null, res[1543].exec(" !XY", 4940)); -assertEquals(null, res[1543].exec(" x{1bb}XY", 4941)); -assertEquals(null, res[1543].exec(" x{2b0}XY", 4942)); -assertEquals(null, res[1543].exec(" ** Failers", 4943)); -assertEquals(null, res[1543].exec(" x{1c5}XY", 4944)); -assertEquals(null, res[1543].exec(" AXY ", 4945)); -assertEquals(null, res[1543].exec("x{c0}x{e0}x{116}x{117}", 4946)); -assertEquals(null, res[1543].exec("x{c0}x{e0}x{116}x{117}", 4947)); -assertEquals(null, res[1545].exec("123abcdefg", 4948)); -assertEquals(null, res[1545].exec("123abc\xc4\xc5zz", 4949)); -assertEquals(null, res[1546].exec("x{102A4}x{AA52}x{A91D}x{1C46}x{10283}x{1092E}x{1C6B}x{A93B}x{A8BF}x{1BA0}x{A50A}====", 4950)); -assertEquals(null, res[1546].exec("x{a77d}x{1d79}", 4951)); -assertEquals(null, res[1546].exec("x{1d79}x{a77d} ", 4952)); -assertEquals(null, res[1546].exec("x{a77d}x{1d79}", 4953)); -assertEquals(null, res[1546].exec("** Failers ", 4954)); -assertEquals(null, res[1546].exec("x{1d79}x{a77d} ", 4955)); -assertThrows("var re = //;", 4956); diff --git a/deps/v8/test/mjsunit/testcfg.py b/deps/v8/test/mjsunit/testcfg.py index 97924c8de0..e3f3fcd940 100644 --- a/deps/v8/test/mjsunit/testcfg.py +++ b/deps/v8/test/mjsunit/testcfg.py @@ -112,8 +112,9 @@ class MjsunitTestConfiguration(test.TestConfiguration): mjsunit = [current_path + [t] for t in self.Ls(self.root)] regress = [current_path + ['regress', t] for t in self.Ls(join(self.root, 'regress'))] bugs = [current_path + ['bugs', t] for t in self.Ls(join(self.root, 'bugs'))] + third_party = [current_path + ['third_party', t] for t in self.Ls(join(self.root, 'third_party'))] tools = [current_path + ['tools', t] for t in self.Ls(join(self.root, 'tools'))] - all_tests = mjsunit + regress + bugs + tools + all_tests = mjsunit + regress + bugs + third_party + tools result = [] for test in all_tests: if self.Contains(path, test): diff --git a/deps/v8/test/mjsunit/third_party/array-splice-webkit.js b/deps/v8/test/mjsunit/third_party/array-splice-webkit.js new file mode 100644 index 0000000000..b676a7c165 --- /dev/null +++ b/deps/v8/test/mjsunit/third_party/array-splice-webkit.js @@ -0,0 +1,62 @@ +// Copyright (c) 2006 Apple Computer, Inc. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// +// 3. Neither the name of the copyright holder(s) nor the names of any +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED +// OF THE POSSIBILITY OF SUCH DAMAGE. + +// Simple splice tests based on webkit layout tests. +var arr = ['a','b','c','d']; +assertArrayEquals(['a','b','c','d'], arr); +assertArrayEquals(['c','d'], arr.splice(2)); +assertArrayEquals(['a','b'], arr); +assertArrayEquals(['a','b'], arr.splice(0)); +assertArrayEquals([], arr) + +arr = ['a','b','c','d']; +assertEquals(undefined, arr.splice()) +assertArrayEquals(['a','b','c','d'], arr); +assertArrayEquals(['a','b','c','d'], arr.splice(undefined)) +assertArrayEquals([], arr); + +arr = ['a','b','c','d']; +assertArrayEquals(['a','b','c','d'], arr.splice(null)) +assertArrayEquals([], arr); + +arr = ['a','b','c','d']; +assertArrayEquals([], arr.splice(100)) +assertArrayEquals(['a','b','c','d'], arr); +assertArrayEquals(['d'], arr.splice(-1)) +assertArrayEquals(['a','b','c'], arr); + +assertArrayEquals([], arr.splice(2, undefined)) +assertArrayEquals([], arr.splice(2, null)) +assertArrayEquals([], arr.splice(2, -1)) +assertArrayEquals([], arr.splice(2, 0)) +assertArrayEquals(['a','b','c'], arr); +assertArrayEquals(['c'], arr.splice(2, 100)) +assertArrayEquals(['a','b'], arr); diff --git a/deps/v8/test/mjsunit/third_party/object-keys.js b/deps/v8/test/mjsunit/third_party/object-keys.js new file mode 100644 index 0000000000..7486b8fb8d --- /dev/null +++ b/deps/v8/test/mjsunit/third_party/object-keys.js @@ -0,0 +1,66 @@ +// Copyright (c) 2006 Apple Computer, Inc. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// +// 3. Neither the name of the copyright holder(s) nor the names of any +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED +// OF THE POSSIBILITY OF SUCH DAMAGE. + +// Based on LayoutTests/fast/js/Object-keys.html + +assertThrows(function () { Object.keys(2) }, TypeError); +assertThrows(function () { Object.keys("foo") }, TypeError); +assertThrows(function () { Object.keys(null) }, TypeError); +assertThrows(function () { Object.keys(undefined) }, TypeError); + +assertEquals(Object.keys({}), []); +assertEquals(Object.keys({a:null}), ['a']); +assertEquals(Object.keys({a:null, b:null}), ['a', 'b']); +assertEquals(Object.keys({b:null, a:null}), ['b', 'a']); +assertEquals(Object.keys([]), []); +assertEquals(Object.keys([null]), ['0']); +assertEquals(Object.keys([null,null]), ['0', '1']); +assertEquals(Object.keys([null,null,,,,null]), ['0', '1', '5']); +assertEquals(Object.keys({__proto__:{a:null}}), []); +assertEquals(Object.keys({__proto__:[1,2,3]}), []); +var x = []; +x.__proto__ = [1, 2, 3]; +assertEquals(Object.keys(x), []); +assertEquals(Object.keys(function () {}), []); + +function argsTest(a, b, c) { + assertEquals([0, 1, 2], Object.keys(arguments)); +} + +argsTest(1, 2, 3); + +var literal = {a: 1, b: 2, c: 3}; +var keysBefore = Object.keys(literal); +assertEquals(['a', 'b', 'c'], keysBefore); +keysBefore[0] = 'x'; +var keysAfter = Object.keys(literal); +assertEquals(['a', 'b', 'c'], keysAfter); +assertEquals(['x', 'b', 'c'], keysBefore); diff --git a/deps/v8/test/mjsunit/third_party/regexp-pcre.js b/deps/v8/test/mjsunit/third_party/regexp-pcre.js new file mode 100644 index 0000000000..dcb1b320fd --- /dev/null +++ b/deps/v8/test/mjsunit/third_party/regexp-pcre.js @@ -0,0 +1,6603 @@ +// Autogenerated from the PCRE test suite Mon Feb 2 15:14:04 CET 2009 + +// Note that some regexps in the PCRE test suite use features not present +// in JavaScript. These don't work in JS, but they fail to work in a +// predictable way, and the expected results reflect this. + +// PCRE comes with the following license + +// PCRE LICENCE +// ------------ +// +// PCRE is a library of functions to support regular expressions whose syntax +// and semantics are as close as possible to those of the Perl 5 language. +// +// Release 7 of PCRE is distributed under the terms of the "BSD" licence, as +// specified below. The documentation for PCRE, supplied in the "doc" +// directory, is distributed under the same terms as the software itself. +// +// The basic library functions are written in C and are freestanding. Also +// included in the distribution is a set of C++ wrapper functions. +// +// +// THE BASIC LIBRARY FUNCTIONS +// --------------------------- +// +// Written by: Philip Hazel +// Email local part: ph10 +// Email domain: cam.ac.uk +// +// University of Cambridge Computing Service, +// Cambridge, England. +// +// Copyright (c) 1997-2007 University of Cambridge +// All rights reserved. +// +// +// THE C++ WRAPPER FUNCTIONS +// ------------------------- +// +// Contributed by: Google Inc. +// +// Copyright (c) 2007, Google Inc. +// All rights reserved. +// +// +// THE "BSD" LICENCE +// ----------------- +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// * Neither the name of the University of Cambridge nor the name of Google +// Inc. nor the names of their contributors may be used to endorse or +// promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +// POSSIBILITY OF SUCH DAMAGE. +// +// End + +var res = new Array(); +res[0] = /(a)b|/i; +res[1] = /abc/i; +res[2] = /^abc/i; +res[3] = /a+bc/i; +res[4] = /a*bc/i; +res[5] = /a{3}bc/i; +res[6] = /(abc|a+z)/i; +res[7] = /^abc$/i; +res[8] = /ab\idef/; +res[9] = /.*b/i; +res[10] = /.*?b/i; +res[11] = /cat|dog|elephant/i; +res[12] = /cat|dog|elephant/i; +res[13] = /cat|dog|elephant/i; +res[14] = /a|[bcd]/i; +res[15] = /(a|[^\dZ])/i; +res[16] = /(a|b)*[\s]/i; +res[17] = /(ab\2)/; +res[18] = /(a)(b)(c)\2/i; +res[19] = /(a)bc|(a)(b)\2/i; +res[20] = /abc$/i; +res[21] = /(a)(b)(c)(d)(e)\6/; +res[22] = /the quick brown fox/i; +res[23] = /^abc|def/i; +res[24] = /.*((abc)$|(def))/i; +res[25] = /abc/i; +res[26] = /^abc|def/i; +res[27] = /.*((abc)$|(def))/i; +res[28] = /the quick brown fox/i; +res[29] = /the quick brown fox/i; +res[30] = /abc.def/i; +res[31] = /abc$/i; +res[32] = /(abc)\2/i; +res[33] = /(abc\1)/i; +res[34] = /a[]b/; +res[35] = /[^aeiou ]{3,}/i; +res[36] = /<.*>/i; +res[37] = /<.*?>/i; +res[38] = /[abcd]/i; +res[39] = /(^a|^b)/im; +res[40] = /a$/i; +res[41] = /a$/im; +res[42] = /\Aabc/im; +res[43] = /^abc/im; +res[44] = /(?!alphabet)[ab]/i; +res[45] = /The next three are in testinput2 because they have variable length branches/; +res[46] = /This one is here because Perl 5.005_02 doesn't fail it/i; +res[47] = /This one is here because I think Perl 5.005_02 gets the setting of $1 wrong/i; +res[48] = /^(a\1?){4}$/i; +res[49] = /These are syntax tests from Perl 5.005/i; +res[50] = /a[]b/; +res[51] = /\1/; +res[52] = /\2/; +res[53] = /(a)|\2/; +res[54] = /a[]b/i; +res[55] = /abc/; +res[56] = /abc/; +res[57] = /abc/i; +res[58] = /(a)bc(d)/i; +res[59] = /(.{20})/i; +res[60] = /(.{15})/i; +res[61] = /(.{16})/i; +res[62] = /^(a|(bc))de(f)/i; +res[63] = /^abc\00def/i; +res[64] = /word ((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+\n)((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+\n)?)?)?)?)?)?)?)?)?otherword/i; +res[65] = /.*X/i; +res[66] = /.*X/i; +res[67] = /(.*X|^B)/i; +res[68] = /(.*X|^B)/i; +res[69] = /\Biss\B/i; +res[70] = /\Biss\B/i; +res[71] = /iss/ig; +res[72] = /\Biss\B/ig; +res[73] = /\Biss\B/ig; +res[74] = /^iss/ig; +res[75] = /.*iss/ig; +res[76] = /.i./ig; +res[77] = /^.is/ig; +res[78] = /^ab\n/ig; +res[79] = /^ab\n/img; +res[80] = /abc/i; +res[81] = /abc|bac/i; +res[82] = /(abc|bac)/i; +res[83] = /(abc|(c|dc))/i; +res[84] = /(abc|(d|de)c)/i; +res[85] = /a*/i; +res[86] = /a+/i; +res[87] = /(baa|a+)/i; +res[88] = /a{0,3}/i; +res[89] = /baa{3,}/i; +res[90] = /"([^\\"]+|\\.)*"/i; +res[91] = /(abc|ab[cd])/i; +res[92] = /(a|.)/i; +res[93] = /a|ba|\w/i; +res[94] = /abc(?=pqr)/i; +res[95] = /abc(?!pqr)/i; +res[96] = /ab./i; +res[97] = /ab[xyz]/i; +res[98] = /abc*/i; +res[99] = /ab.c*/i; +res[100] = /a.c*/i; +res[101] = /.c*/i; +res[102] = /ac*/i; +res[103] = /(a.c*|b.c*)/i; +res[104] = /a.c*|aba/i; +res[105] = /.+a/i; +res[106] = /(?=abcda)a.*/i; +res[107] = /(?=a)a.*/i; +res[108] = /a(b)*/i; +res[109] = /a\d*/i; +res[110] = /ab\d*/i; +res[111] = /a(\d)*/i; +res[112] = /abcde{0,0}/i; +res[113] = /ab\d+/i; +res[114] = /ab\d{0}e/i; +res[115] = /a?b?/i; +res[116] = /|-/i; +res[117] = /a*(b+)(z)(z)/i; +res[118] = /^.?abcd/i; +res[119] = /^[[:alnum:]]/; +res[120] = /^[[:^alnum:]]/; +res[121] = /^[[:alpha:]]/; +res[122] = /^[[:^alpha:]]/; +res[123] = /[_[:alpha:]]/i; +res[124] = /^[[:ascii:]]/; +res[125] = /^[[:^ascii:]]/; +res[126] = /^[[:blank:]]/; +res[127] = /^[[:^blank:]]/; +res[128] = /[\n\x0b\x0c\x0d[:blank:]]/i; +res[129] = /^[[:cntrl:]]/; +res[130] = /^[[:digit:]]/; +res[131] = /^[[:graph:]]/; +res[132] = /^[[:lower:]]/; +res[133] = /^[[:print:]]/; +res[134] = /^[[:punct:]]/; +res[135] = /^[[:space:]]/; +res[136] = /^[[:upper:]]/; +res[137] = /^[[:xdigit:]]/; +res[138] = /^[[:word:]]/; +res[139] = /^[[:^cntrl:]]/; +res[140] = /^[12[:^digit:]]/; +res[141] = /^[[:^blank:]]/; +res[142] = /[01[:alpha:]%]/; +res[143] = /[[.ch.]]/i; +res[144] = /[[=ch=]]/i; +res[145] = /[[:rhubarb:]]/i; +res[146] = /[[:upper:]]/i; +res[147] = /[[:lower:]]/i; +res[148] = /This one's here because of the large output vector needed/i; +res[149] = /(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\w+)\s+(\270)/i; +res[150] = /This one's here because Perl does this differently and PCRE can't at present/i; +res[151] = /(main(O)?)+/i; +res[152] = /These are all cases where Perl does it differently (nested captures)/i; +res[153] = /^(a(b)?)+$/i; +res[154] = /^(aa(bb)?)+$/i; +res[155] = /^(aa|aa(bb))+$/i; +res[156] = /^(aa(bb)??)+$/i; +res[157] = /^(?:aa(bb)?)+$/i; +res[158] = /^(aa(b(b))?)+$/i; +res[159] = /^(?:aa(b(b))?)+$/i; +res[160] = /^(?:aa(b(?:b))?)+$/i; +res[161] = /^(?:aa(bb(?:b))?)+$/i; +res[162] = /^(?:aa(b(?:bb))?)+$/i; +res[163] = /^(?:aa(?:b(b))?)+$/i; +res[164] = /^(?:aa(?:b(bb))?)+$/i; +res[165] = /^(aa(b(bb))?)+$/i; +res[166] = /^(aa(bb(bb))?)+$/i; +res[167] = /a/i; +res[168] = /[\s]/; +res[169] = /[\S]/; +res[170] = /123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890/; +res[171] = /\Q123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890/; +res[172] = /\Q\E/; +res[173] = /\Q\Ex/; +res[174] = / \Q\E/; +res[175] = /a\Q\E/; +res[176] = /a\Q\Eb/; +res[177] = /\Q\Eabc/; +res[178] = /[.x.]/i; +res[179] = /[=x=]/i; +res[180] = /[:x:]/i; +res[181] = /\l/i; +res[182] = /\L/i; +res[183] = /\N{name}/i; +res[184] = /\u/i; +res[185] = /\U/i; +res[186] = /[[:space:]/i; +res[187] = /[\s]/i; +res[188] = /[[:space:]]/i; +res[189] = /[[:space:]abcde]/i; +res[190] = /(.*)\d+\1/i; +res[191] = /(.*)\d+/i; +res[192] = /(.*)\d+\1/i; +res[193] = /(.*)\d+/i; +res[194] = /(.*(xyz))\d+\2/i; +res[195] = /((.*))\d+\1/i; +res[196] = /a[b]/i; +res[197] = /(?=a).*/i; +res[198] = /(?=abc).xyz/i; +res[199] = /(?=a)(?=b)/i; +res[200] = /(?=.)a/i; +res[201] = /((?=abcda)a)/i; +res[202] = /((?=abcda)ab)/i; +res[203] = /()a/i; +res[204] = /(a)+/i; +res[205] = /(a){2,3}/i; +res[206] = /(a)*/i; +res[207] = /[a]/i; +res[208] = /[ab]/i; +res[209] = /[ab]/i; +res[210] = /[^a]/i; +res[211] = /\d456/i; +res[212] = /\d456/i; +res[213] = /a^b/i; +res[214] = /^a/im; +res[215] = /c|abc/i; +res[216] = /(.*)a/i; +res[217] = /(.*)a\1/i; +res[218] = /(.*)a(b)\2/i; +res[219] = /((.*)a|(.*)b)z/i; +res[220] = /((.*)a|(.*)b)z\1/i; +res[221] = /((.*)a|(.*)b)z\2/i; +res[222] = /((.*)a|(.*)b)z\3/i; +res[223] = /((.*)a|^(.*)b)z\3/i; +res[224] = /(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)a/i; +res[225] = /(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)a\31/i; +res[226] = /(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)a\32/i; +res[227] = /(a)(bc)/i; +res[228] = /(a+)*zz/i; +res[229] = /((w\/|-|with)*(free|immediate)*.*?shipping\s*[!.-]*)/i; +res[230] = /((w\/|-|with)*(free|immediate)*.*?shipping\s*[!.-]*)/i; +res[231] = /a*.*b/i; +res[232] = /(a|b)*.?c/i; +res[233] = /abcde/i; +res[234] = /a*b/i; +res[235] = /a+b/i; +res[236] = /(abc|def)x/i; +res[237] = /(ab|cd){3,4}/i; +res[238] = /([ab]{,4}c|xy)/i; +res[239] = /([ab]{1,4}c|xy){4,5}?123/i; +res[240] = /\b.*/i; +res[241] = /\b.*/i; +res[242] = /(?!.bcd).*/i; +res[243] = /abcde/i; +res[244] = /0{0,2}ABC/i; +res[245] = /\d{3,}ABC/i; +res[246] = /\d*ABC/i; +res[247] = /[abc]+DE/i; +res[248] = /[abc]?123/i; +res[249] = /^(?:\d){3,5}X/i; +res[250] = /^a/i; +res[251] = /line\nbreak/i; +res[252] = /line\nbreak/i; +res[253] = /line\nbreak/im; +res[254] = /ab.cd/i; +res[255] = /ab.cd/i; +res[256] = /a(b)c/i; +res[257] = /Inthisnexttest,Jisnotsetattheouterlevel;consequentlyitisn'tsetinthepattern'soptions;consequentlypcre_get_named_substring()producesarandomvalue./i; +res[258] = /\777/i; +res[259] = /\s*,\s*/i; +res[260] = /^abc/im; +res[261] = /abc$/im; +res[262] = /^abc/im; +res[263] = /^abc/im; +res[264] = /^abc/im; +res[265] = /^abc/im; +res[266] = /abc/i; +res[267] = /.*/i; +res[268] = /\w+(.)(.)?def/i; +res[269] = /()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(.(.))/i; +res[270] = /()[ab]xyz/i; +res[271] = /(|)[ab]xyz/i; +res[272] = /(|c)[ab]xyz/i; +res[273] = /(|c?)[ab]xyz/i; +res[274] = /(d?|c?)[ab]xyz/i; +res[275] = /(d?|c)[ab]xyz/i; +res[276] = /^a*b\d/; +res[277] = /^a*?b\d/; +res[278] = /^a+A\d/; +res[279] = /^a*A\d/i; +res[280] = /(a*|b*)[cd]/i; +res[281] = /(a+|b*)[cd]/i; +res[282] = /(a*|b+)[cd]/i; +res[283] = /(a+|b+)[cd]/i; +res[284] = /(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((a)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))/i; +res[285] = /a*\d/; +res[286] = /a*\D/; +res[287] = /0*\d/; +res[288] = /0*\D/; +res[289] = /a*\s/; +res[290] = /a*\S/; +res[291] = / *\s/; +res[292] = / *\S/; +res[293] = /a*\w/; +res[294] = /a*\W/; +res[295] = /=*\w/; +res[296] = /=*\W/; +res[297] = /\d*a/; +res[298] = /\d*2/; +res[299] = /\d*\d/; +res[300] = /\d*\D/; +res[301] = /\d*\s/; +res[302] = /\d*\S/; +res[303] = /\d*\w/; +res[304] = /\d*\W/; +res[305] = /\D*a/; +res[306] = /\D*2/; +res[307] = /\D*\d/; +res[308] = /\D*\D/; +res[309] = /\D*\s/; +res[310] = /\D*\S/; +res[311] = /\D*\w/; +res[312] = /\D*\W/; +res[313] = /\s*a/; +res[314] = /\s*2/; +res[315] = /\s*\d/; +res[316] = /\s*\D/; +res[317] = /\s*\s/; +res[318] = /\s*\S/; +res[319] = /\s*\w/; +res[320] = /\s*\W/; +res[321] = /\S*a/; +res[322] = /\S*2/; +res[323] = /\S*\d/; +res[324] = /\S*\D/; +res[325] = /\S*\s/; +res[326] = /\S*\S/; +res[327] = /\S*\w/; +res[328] = /\S*\W/; +res[329] = /\w*a/; +res[330] = /\w*2/; +res[331] = /\w*\d/; +res[332] = /\w*\D/; +res[333] = /\w*\s/; +res[334] = /\w*\S/; +res[335] = /\w*\w/; +res[336] = /\w*\W/; +res[337] = /\W*a/; +res[338] = /\W*2/; +res[339] = /\W*\d/; +res[340] = /\W*\D/; +res[341] = /\W*\s/; +res[342] = /\W*\S/; +res[343] = /\W*\w/; +res[344] = /\W*\W/; +res[345] = /[^a]+a/; +res[346] = /[^a]+a/i; +res[347] = /[^a]+A/i; +res[348] = /[^a]+b/; +res[349] = /[^a]+\d/; +res[350] = /a*[^a]/; +res[351] = /^(?:(?:\1|X)(a|b))+/; +res[352] = /^[\E\Qa\E-\Qz\E]+/; +res[353] = /^[a\Q]bc\E]/; +res[354] = /(?=(\w+))\1:/i; +res[355] = /(a|)*\d/; +res[356] = /^a.b/; +res[357] = /^abc./mg; +res[358] = /abc.$/mg; +res[359] = /a/; +res[360] = /a/; +res[361] = /^a\Rb/i; +res[362] = /^a\R*b/i; +res[363] = /^a\R+b/i; +res[364] = /^a\R{1,3}b/i; +res[365] = /^a[\R]b/i; +res[366] = /^(a(b))\1\g1\g{1}\g-1\g{-1}\g{-02}Z/; +res[367] = /^(a)\g-2/; +res[368] = /^(a)\g/; +res[369] = /^(a)\g{0}/; +res[370] = /^(a)\g{3/; +res[371] = /^(a)\g{4a}/; +res[372] = /^a.b/; +res[373] = /.+foo/; +res[374] = /.+foo/; +res[375] = /.+foo/; +res[376] = /.+foo/; +res[377] = /^$/mg; +res[378] = /abc.$/mg; +res[379] = /^X/m; +res[380] = /(foo)\Kbar/; +res[381] = /(foo)(\Kbar|baz)/; +res[382] = /(foo\Kbar)baz/; +res[383] = /\g{A/; +res[384] = /\H\h\V\v/; +res[385] = /\H*\h+\V?\v{3,4}/; +res[386] = /\H{3,4}/; +res[387] = /.\h{3,4}./; +res[388] = /\h*X\h?\H+Y\H?Z/; +res[389] = /\v*X\v?Y\v+Z\V*\x0a\V+\x0b\V{2,3}\x0c/; +res[390] = /[\h]/; +res[391] = /[\h]+/; +res[392] = /[\v]/; +res[393] = /[\H]/; +res[394] = /[^\h]/; +res[395] = /[\V]/; +res[396] = /[\x0a\V]/; +res[397] = /\H+\hY/; +res[398] = /\H+ Y/; +res[399] = /\h+A/; +res[400] = /\v*B/; +res[401] = /\V+\x0a/; +res[402] = /A+\h/; +res[403] = / *\H/; +res[404] = /A*\v/; +res[405] = /\x0b*\V/; +res[406] = /\d+\h/; +res[407] = /\d*\v/; +res[408] = /S+\h\S+\v/; +res[409] = /\w{3,}\h\w+\v/; +res[410] = /\h+\d\h+\w\h+\S\h+\H/; +res[411] = /\v+\d\v+\w\v+\S\v+\V/; +res[412] = /\H+\h\H+\d/; +res[413] = /\V+\v\V+\w/; +res[414] = /[\E]AAA/; +res[415] = /[\Q\E]AAA/; +res[416] = /[^\E]AAA/; +res[417] = /[^\Q\E]AAA/; +res[418] = /[\E^]AAA/; +res[419] = /[\Q\E^]AAA/; +res[420] = /\g6666666666/; +res[421] = /[\g6666666666]/; +res[422] = /.+A/; +res[423] = /\nA/; +res[424] = /[\r\n]A/; +res[425] = /(\r|\n)A/; +res[426] = /a\Rb/i; +res[427] = /a\Rb/i; +res[428] = /a\R?b/i; +res[429] = /a\R?b/i; +res[430] = /a\R{2,4}b/i; +res[431] = /a\R{2,4}b/i; +res[432] = /\k''/; +res[433] = /\k<>/; +res[434] = /\k{}/; +res[435] = /[[:foo:]]/; +res[436] = /[[:1234:]]/; +res[437] = /[[:f\oo:]]/; +res[438] = /[[: :]]/; +res[439] = /[[:...:]]/; +res[440] = /[[:l\ower:]]/; +res[441] = /[[:abc\:]]/; +res[442] = /[abc[:x\]pqr:]]/; +res[443] = /[[:a\dz:]]/; +res[444] = /^(a|b\g<1>c)/; +res[445] = /^(a|b\g'1'c)/; +res[446] = /^(a|b\g'-1'c)/; +res[447] = /(^(a|b\g<-1>c))/; +res[448] = /(^(a|b\g<-1'c))/; +res[449] = /(^(a|b\g{-1}))/; +res[450] = /(\3)(\1)(a)/; +res[451] = /(\3)(\1)(a)/; +res[452] = /TA]/; +res[453] = /TA]/; +res[454] = /a[]b/; +res[455] = /a[^]b/; +res[456] = /a[]b/; +res[457] = /a[]+b/; +res[458] = /a[^]b/; +res[459] = /a[^]+b/; +res[460] = /a(?!)+b/; +res[461] = /(abc|pqr|123){0}[xyz]/i; +res[462] = / End of testinput2 /; +res[463] = /a.b/; +res[464] = /a(.{3})b/; +res[465] = /a(.*?)(.)/; +res[466] = /a(.*?)(.)/; +res[467] = /a(.*)(.)/; +res[468] = /a(.*)(.)/; +res[469] = /a(.)(.)/; +res[470] = /a(.)(.)/; +res[471] = /a(.?)(.)/; +res[472] = /a(.?)(.)/; +res[473] = /a(.??)(.)/; +res[474] = /a(.??)(.)/; +res[475] = /a(.{3})b/; +res[476] = /a(.{3,})b/; +res[477] = /a(.{3,}?)b/; +res[478] = /a(.{3,5})b/; +res[479] = /a(.{3,5}?)b/; +res[480] = /X(\C{3})/; +res[481] = /X(\C{4})/; +res[482] = /X\C*/; +res[483] = /X\C*?/; +res[484] = /X\C{3,5}/; +res[485] = /X\C{3,5}?/; +res[486] = /[^a]+/g; +res[487] = /^[^a]{2}/; +res[488] = /^[^a]{2,}/; +res[489] = /^[^a]{2,}?/; +res[490] = /[^a]+/ig; +res[491] = /^[^a]{2}/i; +res[492] = /^[^a]{2,}/i; +res[493] = /^[^a]{2,}?/i; +res[494] = /\D*/; +res[495] = /\D*/; +res[496] = /\D/; +res[497] = />\S/; +res[498] = /\d/; +res[499] = /\s/; +res[500] = /\D+/; +res[501] = /\D{2,3}/; +res[502] = /\D{2,3}?/; +res[503] = /\d+/; +res[504] = /\d{2,3}/; +res[505] = /\d{2,3}?/; +res[506] = /\S+/; +res[507] = /\S{2,3}/; +res[508] = /\S{2,3}?/; +res[509] = />\s+\s{2,3}\s{2,3}?@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"(?:[^\\\x80-\xff\n\015"]|\\[^\x80-\xff])*")(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*\.(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"(?:[^\\\x80-\xff\n\015"]|\\[^\x80-\xff])*"))*(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*@(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*\.(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\]))*|(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"(?:[^\\\x80-\xff\n\015"]|\\[^\x80-\xff])*")(?:[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\)|"(?:[^\\\x80-\xff\n\015"]|\\[^\x80-\xff])*")*<(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:@(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*\.(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\]))*(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*,(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*@(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*\.(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\]))*)*:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*)?(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"(?:[^\\\x80-\xff\n\015"]|\\[^\x80-\xff])*")(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*\.(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"(?:[^\\\x80-\xff\n\015"]|\\[^\x80-\xff])*"))*(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*@(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])(?:(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*\.(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\]))*(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*>)(?:[\040\t]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff]|\((?:[^\\\x80-\xff\n\015()]|\\[^\x80-\xff])*\))*\))*/; +res[861] = /[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*@[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*|(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037]*(?:(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[^()<>@,;:".\\\[\]\x80-\xff\000-\010\012-\037]*)*<[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:@[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*(?:,[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*@[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*)*:[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)?(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|"[^\\\x80-\xff\n\015"]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015"]*)*")[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*@[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:\.[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(?:[^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff]+(?![^(\040)<>@,;:".\\\[\]\000-\037\x80-\xff])|\[(?:[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(?:\([^\\\x80-\xff\n\015()]*(?:(?:\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(?:\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*>)/; +res[862] = /abc\x0def\x00pqr\x000xyz\x0000AB/; +res[863] = /^[\000-\037]/; +res[864] = /\0*/; +res[865] = /A\x0{2,3}Z/; +res[866] = /^\s/; +res[867] = /^abc/; +res[868] = /ab{1,3}bc/; +res[869] = /([^.]*)\.([^:]*):[T ]+(.*)/; +res[870] = /([^.]*)\.([^:]*):[T ]+(.*)/i; +res[871] = /([^.]*)\.([^:]*):[t ]+(.*)/i; +res[872] = /^[W-c]+$/; +res[873] = /^[W-c]+$/i; +res[874] = /^[\x3f-\x5F]+$/i; +res[875] = /^abc$/m; +res[876] = /^abc$/; +res[877] = /\Aabc\Z/m; +res[878] = /\A(.)*\Z/; +res[879] = /\A(.)*\Z/m; +res[880] = /(?:b)|(?::+)/; +res[881] = /[-az]+/; +res[882] = /[az-]+/; +res[883] = /[a\-z]+/; +res[884] = /[a-z]+/; +res[885] = /[\d-]+/; +res[886] = /[\d-z]+/; +res[887] = /\x5c/; +res[888] = /\x20Z/; +res[889] = /ab{3cd/; +res[890] = /ab{3,cd/; +res[891] = /ab{3,4a}cd/; +res[892] = /{4,5a}bc/; +res[893] = /^a.b/; +res[894] = /abc$/; +res[895] = /(abc)\123/; +res[896] = /(abc)\223/; +res[897] = /(abc)\323/; +res[898] = /(abc)\100/; +res[899] = /abc\81/; +res[900] = /abc\91/; +res[901] = /(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\12\123/; +res[902] = /ab\idef/; +res[903] = /a{0}bc/; +res[904] = /(a|(bc)){0,0}?xyz/; +res[905] = /abc[\10]de/; +res[906] = /abc[\1]de/; +res[907] = /(abc)[\1]de/; +res[908] = /^([^a])([^\b])([^c]*)([^d]{3,4})/; +res[909] = /[^a]/; +res[910] = /[^a]/i; +res[911] = /[^a]+/; +res[912] = /[^a]+/i; +res[913] = /[^a]+/; +res[914] = /[^k]$/; +res[915] = /[^k]{2,3}$/; +res[916] = /^\d{8,}\@.+[^k]$/; +res[917] = /[^a]/; +res[918] = /[^a]/i; +res[919] = /[^az]/; +res[920] = /[^az]/i; +res[921] = /\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377/; +res[922] = /P[^*]TAIRE[^*]{1,6}?LL/; +res[923] = /P[^*]TAIRE[^*]{1,}?LL/; +res[924] = /(\.\d\d[1-9]?)\d+/; +res[925] = /(\.\d\d((?=0)|\d(?=\d)))/; +res[926] = /\b(foo)\s+(\w+)/i; +res[927] = /foo(.*)bar/; +res[928] = /foo(.*?)bar/; +res[929] = /(.*)(\d*)/; +res[930] = /(.*)(\d+)/; +res[931] = /(.*?)(\d*)/; +res[932] = /(.*?)(\d+)/; +res[933] = /(.*)(\d+)$/; +res[934] = /(.*?)(\d+)$/; +res[935] = /(.*)\b(\d+)$/; +res[936] = /(.*\D)(\d+)$/; +res[937] = /^\D*(?!123)/; +res[938] = /^(\D*)(?=\d)(?!123)/; +res[939] = /^[W-]46]/; +res[940] = /^[W-\]46]/; +res[941] = /\d\d\/\d\d\/\d\d\d\d/; +res[942] = /word (?:[a-zA-Z0-9]+ ){0,10}otherword/; +res[943] = /word (?:[a-zA-Z0-9]+ ){0,300}otherword/; +res[944] = /^(a){0,0}/; +res[945] = /^(a){0,1}/; +res[946] = /^(a){0,2}/; +res[947] = /^(a){0,3}/; +res[948] = /^(a){0,}/; +res[949] = /^(a){1,1}/; +res[950] = /^(a){1,2}/; +res[951] = /^(a){1,3}/; +res[952] = /^(a){1,}/; +res[953] = /.*\.gif/; +res[954] = /.{0,}\.gif/; +res[955] = /.*\.gif/m; +res[956] = /.*\.gif/; +res[957] = /.*\.gif/m; +res[958] = /.*$/; +res[959] = /.*$/m; +res[960] = /.*$/; +res[961] = /.*$/m; +res[962] = /.*$/; +res[963] = /.*$/m; +res[964] = /.*$/; +res[965] = /.*$/m; +res[966] = /(.*X|^B)/; +res[967] = /(.*X|^B)/m; +res[968] = /(.*X|^B)/; +res[969] = /(.*X|^B)/m; +res[970] = /^.*B/; +res[971] = /^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]/; +res[972] = /^\d\d\d\d\d\d\d\d\d\d\d\d/; +res[973] = /^[\d][\d][\d][\d][\d][\d][\d][\d][\d][\d][\d][\d]/; +res[974] = /^[abc]{12}/; +res[975] = /^[a-c]{12}/; +res[976] = /^(a|b|c){12}/; +res[977] = /^[abcdefghijklmnopqrstuvwxy0123456789]/; +res[978] = /abcde{0,0}/; +res[979] = /ab[cd]{0,0}e/; +res[980] = /ab(c){0,0}d/; +res[981] = /a(b*)/; +res[982] = /ab\d{0}e/; +res[983] = /"([^\\"]+|\\.)*"/; +res[984] = /.*?/g; +res[985] = /\b/g; +res[986] = /\b/g; +res[987] = /]{0,})>]{0,})>([\d]{0,}\.)(.*)((
([\w\W\s\d][^<>]{0,})|[\s]{0,}))<\/a><\/TD>]{0,})>([\w\W\s\d][^<>]{0,})<\/TD>]{0,})>([\w\W\s\d][^<>]{0,})<\/TD><\/TR>/i; +res[988] = /a[^a]b/; +res[989] = /a.b/; +res[990] = /a[^a]b/; +res[991] = /a.b/; +res[992] = /^(b+?|a){1,2}?c/; +res[993] = /^(b+|a){1,2}?c/; +res[994] = /(?!\A)x/m; +res[995] = /\x0{ab}/; +res[996] = /(A|B)*?CD/; +res[997] = /(A|B)*CD/; +res[998] = /\Aabc\z/m; +res[999] = /(\d+)(\w)/; +res[1000] = /(a+|b+|c+)*c/; +res[1001] = /(abc|)+/; +res[1002] = /([a]*)*/; +res[1003] = /([ab]*)*/; +res[1004] = /([^a]*)*/; +res[1005] = /([^ab]*)*/; +res[1006] = /([a]*?)*/; +res[1007] = /([ab]*?)*/; +res[1008] = /([^a]*?)*/; +res[1009] = /([^ab]*?)*/; +res[1010] = /The following tests are taken from the Perl 5.005 test suite; some of them/; +res[1011] = /are compatible with 5.004, but I'd rather not have to sort them out./; +res[1012] = /abc/; +res[1013] = /ab*c/; +res[1014] = /ab*bc/; +res[1015] = /.{1}/; +res[1016] = /.{3,4}/; +res[1017] = /ab{0,}bc/; +res[1018] = /ab+bc/; +res[1019] = /ab{1,}bc/; +res[1020] = /ab+bc/; +res[1021] = /ab{1,}bc/; +res[1022] = /ab{1,3}bc/; +res[1023] = /ab{3,4}bc/; +res[1024] = /ab{4,5}bc/; +res[1025] = /ab?bc/; +res[1026] = /ab{0,1}bc/; +res[1027] = /ab?bc/; +res[1028] = /ab?c/; +res[1029] = /ab{0,1}c/; +res[1030] = /^abc$/; +res[1031] = /^abc/; +res[1032] = /^abc$/; +res[1033] = /abc$/; +res[1034] = /^/; +res[1035] = /$/; +res[1036] = /a.c/; +res[1037] = /a.*c/; +res[1038] = /a[bc]d/; +res[1039] = /a[b-d]e/; +res[1040] = /a[b-d]/; +res[1041] = /a[-b]/; +res[1042] = /a[b-]/; +res[1043] = /a]/; +res[1044] = /a[]]b/; +res[1045] = /a[^bc]d/; +res[1046] = /a[^-b]c/; +res[1047] = /a[^]b]c/; +res[1048] = /\ba\b/; +res[1049] = /\by\b/; +res[1050] = /\Ba\B/; +res[1051] = /\By\b/; +res[1052] = /\by\B/; +res[1053] = /\By\B/; +res[1054] = /\w/; +res[1055] = /\W/; +res[1056] = /a\sb/; +res[1057] = /a\Sb/; +res[1058] = /\d/; +res[1059] = /\D/; +res[1060] = /[\w]/; +res[1061] = /[\W]/; +res[1062] = /a[\s]b/; +res[1063] = /a[\S]b/; +res[1064] = /[\d]/; +res[1065] = /[\D]/; +res[1066] = /ab|cd/; +res[1067] = /()ef/; +res[1068] = /$b/; +res[1069] = /a\(b/; +res[1070] = /a\\b/; +res[1071] = /((a))/; +res[1072] = /(a)b(c)/; +res[1073] = /a+b+c/; +res[1074] = /a{1,}b{1,}c/; +res[1075] = /a.+?c/; +res[1076] = /(a+|b)*/; +res[1077] = /(a+|b){0,}/; +res[1078] = /(a+|b)+/; +res[1079] = /(a+|b){1,}/; +res[1080] = /(a+|b)?/; +res[1081] = /(a+|b){0,1}/; +res[1082] = /[^ab]*/; +res[1083] = /abc/; +res[1084] = /a*/; +res[1085] = /([abc])*d/; +res[1086] = /([abc])*bcd/; +res[1087] = /a|b|c|d|e/; +res[1088] = /(a|b|c|d|e)f/; +res[1089] = /abcd*efg/; +res[1090] = /ab*/; +res[1091] = /(ab|cd)e/; +res[1092] = /[abhgefdc]ij/; +res[1093] = /^(ab|cd)e/; +res[1094] = /(abc|)ef/; +res[1095] = /(a|b)c*d/; +res[1096] = /(ab|ab*)bc/; +res[1097] = /a([bc]*)c*/; +res[1098] = /a([bc]*)(c*d)/; +res[1099] = /a([bc]+)(c*d)/; +res[1100] = /a([bc]*)(c+d)/; +res[1101] = /a[bcd]*dcdcde/; +res[1102] = /a[bcd]+dcdcde/; +res[1103] = /(ab|a)b*c/; +res[1104] = /((a)(b)c)(d)/; +res[1105] = /[a-zA-Z_][a-zA-Z0-9_]*/; +res[1106] = /^a(bc+|b[eh])g|.h$/; +res[1107] = /(bc+d$|ef*g.|h?i(j|k))/; +res[1108] = /((((((((((a))))))))))/; +res[1109] = /(((((((((a)))))))))/; +res[1110] = /multiple words of text/; +res[1111] = /multiple words/; +res[1112] = /(.*)c(.*)/; +res[1113] = /\((.*), (.*)\)/; +res[1114] = /[k]/; +res[1115] = /abcd/; +res[1116] = /a(bc)d/; +res[1117] = /a[-]?c/; +res[1118] = /abc/i; +res[1119] = /ab*c/i; +res[1120] = /ab*bc/i; +res[1121] = /ab*?bc/i; +res[1122] = /ab{0,}?bc/i; +res[1123] = /ab+?bc/i; +res[1124] = /ab+bc/i; +res[1125] = /ab{1,}bc/i; +res[1126] = /ab+bc/i; +res[1127] = /ab{1,}?bc/i; +res[1128] = /ab{1,3}?bc/i; +res[1129] = /ab{3,4}?bc/i; +res[1130] = /ab{4,5}?bc/i; +res[1131] = /ab??bc/i; +res[1132] = /ab{0,1}?bc/i; +res[1133] = /ab??bc/i; +res[1134] = /ab??c/i; +res[1135] = /ab{0,1}?c/i; +res[1136] = /^abc$/i; +res[1137] = /^abc/i; +res[1138] = /^abc$/i; +res[1139] = /abc$/i; +res[1140] = /^/i; +res[1141] = /$/i; +res[1142] = /a.c/i; +res[1143] = /a.*?c/i; +res[1144] = /a.*c/i; +res[1145] = /a[bc]d/i; +res[1146] = /a[b-d]e/i; +res[1147] = /a[b-d]/i; +res[1148] = /a[-b]/i; +res[1149] = /a[b-]/i; +res[1150] = /a]/i; +res[1151] = /a[]]b/i; +res[1152] = /a[^bc]d/i; +res[1153] = /a[^-b]c/i; +res[1154] = /a[^]b]c/i; +res[1155] = /ab|cd/i; +res[1156] = /()ef/i; +res[1157] = /$b/i; +res[1158] = /a\(b/i; +res[1159] = /a\\b/i; +res[1160] = /((a))/i; +res[1161] = /(a)b(c)/i; +res[1162] = /a+b+c/i; +res[1163] = /a{1,}b{1,}c/i; +res[1164] = /a.+?c/i; +res[1165] = /a.*?c/i; +res[1166] = /a.{0,5}?c/i; +res[1167] = /(a+|b)*/i; +res[1168] = /(a+|b){0,}/i; +res[1169] = /(a+|b)+/i; +res[1170] = /(a+|b){1,}/i; +res[1171] = /(a+|b)?/i; +res[1172] = /(a+|b){0,1}/i; +res[1173] = /(a+|b){0,1}?/i; +res[1174] = /[^ab]*/i; +res[1175] = /abc/i; +res[1176] = /a*/i; +res[1177] = /([abc])*d/i; +res[1178] = /([abc])*bcd/i; +res[1179] = /a|b|c|d|e/i; +res[1180] = /(a|b|c|d|e)f/i; +res[1181] = /abcd*efg/i; +res[1182] = /ab*/i; +res[1183] = /(ab|cd)e/i; +res[1184] = /[abhgefdc]ij/i; +res[1185] = /^(ab|cd)e/i; +res[1186] = /(abc|)ef/i; +res[1187] = /(a|b)c*d/i; +res[1188] = /(ab|ab*)bc/i; +res[1189] = /a([bc]*)c*/i; +res[1190] = /a([bc]*)(c*d)/i; +res[1191] = /a([bc]+)(c*d)/i; +res[1192] = /a([bc]*)(c+d)/i; +res[1193] = /a[bcd]*dcdcde/i; +res[1194] = /a[bcd]+dcdcde/i; +res[1195] = /(ab|a)b*c/i; +res[1196] = /((a)(b)c)(d)/i; +res[1197] = /[a-zA-Z_][a-zA-Z0-9_]*/i; +res[1198] = /^a(bc+|b[eh])g|.h$/i; +res[1199] = /(bc+d$|ef*g.|h?i(j|k))/i; +res[1200] = /((((((((((a))))))))))/i; +res[1201] = /(((((((((a)))))))))/i; +res[1202] = /(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))/i; +res[1203] = /(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))/i; +res[1204] = /multiple words of text/i; +res[1205] = /multiple words/i; +res[1206] = /(.*)c(.*)/i; +res[1207] = /\((.*), (.*)\)/i; +res[1208] = /[k]/i; +res[1209] = /abcd/i; +res[1210] = /a(bc)d/i; +res[1211] = /a[-]?c/i; +res[1212] = /a(?!b)./; +res[1213] = /a(?=d)./; +res[1214] = /a(?=c|d)./; +res[1215] = /a(?:b|c|d)(.)/; +res[1216] = /a(?:b|c|d)*(.)/; +res[1217] = /a(?:b|c|d)+?(.)/; +res[1218] = /a(?:b|c|d)+(.)/; +res[1219] = /a(?:b|c|d){2}(.)/; +res[1220] = /a(?:b|c|d){4,5}(.)/; +res[1221] = /a(?:b|c|d){4,5}?(.)/; +res[1222] = /((foo)|(bar))*/; +res[1223] = /a(?:b|c|d){6,7}(.)/; +res[1224] = /a(?:b|c|d){6,7}?(.)/; +res[1225] = /a(?:b|c|d){5,6}(.)/; +res[1226] = /a(?:b|c|d){5,6}?(.)/; +res[1227] = /a(?:b|c|d){5,7}(.)/; +res[1228] = /a(?:b|c|d){5,7}?(.)/; +res[1229] = /a(?:b|(c|e){1,2}?|d)+?(.)/; +res[1230] = /^(.+)?B/; +res[1231] = /^([^a-z])|(\^)$/; +res[1232] = /^[<>]&/; +res[1233] = /(?:(f)(o)(o)|(b)(a)(r))*/; +res[1234] = /(?:..)*a/; +res[1235] = /(?:..)*?a/; +res[1236] = /^(){3,5}/; +res[1237] = /^(a+)*ax/; +res[1238] = /^((a|b)+)*ax/; +res[1239] = /^((a|bc)+)*ax/; +res[1240] = /(a|x)*ab/; +res[1241] = /(a)*ab/; +res[1242] = /(?:c|d)(?:)(?:a(?:)(?:b)(?:b(?:))(?:b(?:)(?:b)))/; +res[1243] = /(?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))/; +res[1244] = /foo\w*\d{4}baz/; +res[1245] = /x(~~)*(?:(?:F)?)?/; +res[1246] = /^a{3}c/; +res[1247] = /^a{3}c/; +res[1248] = /^(?:a?b?)*$/; +res[1249] = /^b/; +res[1250] = /()^b/; +res[1251] = /(\w+:)+/; +res[1252] = /([\w:]+::)?(\w+)$/; +res[1253] = /^[^bcd]*(c+)/; +res[1254] = /(a*)b+/; +res[1255] = /([\w:]+::)?(\w+)$/; +res[1256] = /^[^bcd]*(c+)/; +res[1257] = /(>a+)ab/; +res[1258] = /([[:]+)/; +res[1259] = /([[=]+)/; +res[1260] = /([[.]+)/; +res[1261] = /a\Z/; +res[1262] = /b\Z/; +res[1263] = /b\z/; +res[1264] = /b\Z/; +res[1265] = /b\z/; +res[1266] = /((Z)+|A)*/; +res[1267] = /(Z()|A)*/; +res[1268] = /(Z(())|A)*/; +res[1269] = /a*/g; +res[1270] = /^[\d-a]/; +res[1271] = /[[:space:]]+/; +res[1272] = /[[:blank:]]+/; +res[1273] = /[\s]+/; +res[1274] = /\s+/; +res[1275] = /a b/; +res[1276] = /(?!\A)x/m; +res[1277] = /(?!^)x/m; +res[1278] = /abc\Qabc\Eabc/; +res[1279] = /abc\Qabc\Eabc/; +res[1280] = /abc\Qliteral\E/; +res[1281] = /abc\Qliteral/; +res[1282] = /abc\Qliteral\E/; +res[1283] = /abc\Qliteral\E/; +res[1284] = /\Qabc\$xyz\E/; +res[1285] = /\Qabc\E\$\Qxyz\E/; +res[1286] = /\Gabc/; +res[1287] = /\Gabc./g; +res[1288] = /abc./g; +res[1289] = /[z\Qa-d]\E]/; +res[1290] = /[\z\C]/; +res[1291] = /\M/; +res[1292] = /(a+)*b/; +res[1293] = /line\nbreak/; +res[1294] = /line\nbreak/; +res[1295] = /line\nbreak/m; +res[1296] = /1234/; +res[1297] = /1234/; +res[1298] = /^/mg; +res[1299] = /Content-Type\x3A[^\r\n]{6,}/; +res[1300] = /Content-Type\x3A[^\r\n]{6,}z/; +res[1301] = /Content-Type\x3A[^a]{6,}/; +res[1302] = /Content-Type\x3A[^a]{6,}z/; +res[1303] = /^abc/m; +res[1304] = /abc$/m; +res[1305] = /^abc/m; +res[1306] = /^abc/m; +res[1307] = /^abc/m; +res[1308] = /.*/; +res[1309] = /\w+(.)(.)?def/; +res[1310] = /^\w+=.*(\\\n.*)*/; +res[1311] = /^(a()*)*/; +res[1312] = /^(?:a(?:(?:))*)*/; +res[1313] = /^(a()+)+/; +res[1314] = /^(?:a(?:(?:))+)+/; +res[1315] = /(a|)*\d/; +res[1316] = /(?:a|)*\d/; +res[1317] = /^a.b/; +res[1318] = /^abc./mg; +res[1319] = /abc.$/mg; +res[1320] = /^a\Rb/i; +res[1321] = /^a\R*b/i; +res[1322] = /^a\R+b/i; +res[1323] = /^a\R{1,3}b/i; +res[1324] = /^a[\R]b/i; +res[1325] = /.+foo/; +res[1326] = /.+foo/; +res[1327] = /.+foo/; +res[1328] = /.+foo/; +res[1329] = /^$/mg; +res[1330] = /^X/m; +res[1331] = /\H\h\V\v/; +res[1332] = /\H*\h+\V?\v{3,4}/; +res[1333] = /\H{3,4}/; +res[1334] = /.\h{3,4}./; +res[1335] = /\h*X\h?\H+Y\H?Z/; +res[1336] = /\v*X\v?Y\v+Z\V*\x0a\V+\x0b\V{2,3}\x0c/; +res[1337] = /.+A/; +res[1338] = /\nA/; +res[1339] = /[\r\n]A/; +res[1340] = /(\r|\n)A/; +res[1341] = /a\Rb/i; +res[1342] = /a\Rb/i; +res[1343] = /a\R?b/i; +res[1344] = /a\R?b/i; +res[1345] = /a\R{2,4}b/i; +res[1346] = /a\R{2,4}b/i; +res[1347] = /a(?!)|\wbc/; +res[1348] = /a[]b/; +res[1349] = /a[]+b/; +res[1350] = /a[^]b/; +res[1351] = /a[^]+b/; +res[1352] = / End of testinput7 /; +res[1353] = /\bX/; +res[1354] = /\BX/; +res[1355] = /X\b/; +res[1356] = /X\B/; +res[1357] = /[^a]/; +res[1358] = /abc/; +res[1359] = /a.b/; +res[1360] = /a(.{3})b/; +res[1361] = /a(.*?)(.)/; +res[1362] = /a(.*?)(.)/; +res[1363] = /a(.*)(.)/; +res[1364] = /a(.*)(.)/; +res[1365] = /a(.)(.)/; +res[1366] = /a(.)(.)/; +res[1367] = /a(.?)(.)/; +res[1368] = /a(.?)(.)/; +res[1369] = /a(.??)(.)/; +res[1370] = /a(.??)(.)/; +res[1371] = /a(.{3})b/; +res[1372] = /a(.{3,})b/; +res[1373] = /a(.{3,}?)b/; +res[1374] = /a(.{3,5})b/; +res[1375] = /a(.{3,5}?)b/; +res[1376] = /[^a]+/g; +res[1377] = /^[^a]{2}/; +res[1378] = /^[^a]{2,}/; +res[1379] = /^[^a]{2,}?/; +res[1380] = /[^a]+/ig; +res[1381] = /^[^a]{2}/i; +res[1382] = /^[^a]{2,}/i; +res[1383] = /^[^a]{2,}?/i; +res[1384] = /\D*/; +res[1385] = /\D*/; +res[1386] = /\D/; +res[1387] = />\S/; +res[1388] = /\d/; +res[1389] = /\s/; +res[1390] = /\D+/; +res[1391] = /\D{2,3}/; +res[1392] = /\D{2,3}?/; +res[1393] = /\d+/; +res[1394] = /\d{2,3}/; +res[1395] = /\d{2,3}?/; +res[1396] = /\S+/; +res[1397] = /\S{2,3}/; +res[1398] = /\S{2,3}?/; +res[1399] = />\s+\s{2,3}\s{2,3}?ghi", res[36].exec("abcghinop"), 71); +assertEquals("", res[37].exec("abcghinop"), 72); +assertEquals("", res[37].exec("abcghinop"), 73); +assertEquals(null, res[37].exec("abc========def", 74)); +assertEquals(null, res[37].exec("foo", 75)); +assertEquals(null, res[37].exec("catfoo", 76)); +assertEquals(null, res[37].exec("*** Failers", 77)); +assertEquals(null, res[37].exec("the barfoo", 78)); +assertEquals(null, res[37].exec("and cattlefoo", 79)); +assertEquals("a", res[40].exec("a"), 80); +assertEquals(null, res[40].exec("a\n", 81)); +assertEquals(null, res[40].exec("*** Failers", 82)); +assertEquals("a", res[40].exec("Za"), 83); +assertEquals(null, res[40].exec("Za\n", 84)); +assertEquals("a", res[41].exec("a"), 85); +assertEquals("a", res[41].exec("a\n"), 86); +assertEquals("a", res[41].exec("Za\n"), 87); +assertEquals(null, res[41].exec("*** Failers", 88)); +assertEquals("a", res[41].exec("Za"), 89); +assertEquals("b", res[44].exec("foo\nbarbar"), 90); +assertEquals("a", res[44].exec("***Failers"), 91); +assertEquals("b", res[44].exec("rhubarb"), 92); +assertEquals("b", res[44].exec("barbell"), 93); +assertEquals("a", res[44].exec("abc\nbarton"), 94); +assertEquals("b", res[44].exec("foo\nbarbar"), 95); +assertEquals("a", res[44].exec("***Failers"), 96); +assertEquals("b", res[44].exec("rhubarb"), 97); +assertEquals("b", res[44].exec("barbell"), 98); +assertEquals("a", res[44].exec("abc\nbarton"), 99); +assertEquals("a", res[44].exec("abc"), 100); +assertEquals("a", res[44].exec("def\nabc"), 101); +assertEquals("a", res[44].exec("*** Failers"), 102); +assertEquals("a", res[44].exec("defabc"), 103); +assertEquals(null, res[45].exec("the bullock-cart", 104)); +assertEquals(null, res[45].exec("a donkey-cart race", 105)); +assertEquals(null, res[45].exec("*** Failers", 106)); +assertEquals(null, res[45].exec("cart", 107)); +assertEquals(null, res[45].exec("horse-and-cart", 108)); +assertEquals(null, res[45].exec("alphabetabcd", 109)); +assertEquals(null, res[45].exec("endingxyz", 110)); +assertEquals(null, res[45].exec("abxyZZ", 111)); +assertEquals(null, res[45].exec("abXyZZ", 112)); +assertEquals(null, res[45].exec("ZZZ", 113)); +assertEquals(null, res[45].exec("zZZ", 114)); +assertEquals(null, res[45].exec("bZZ", 115)); +assertEquals(null, res[45].exec("BZZ", 116)); +assertEquals(null, res[45].exec("*** Failers", 117)); +assertEquals(null, res[45].exec("ZZ", 118)); +assertEquals(null, res[45].exec("abXYZZ", 119)); +assertEquals(null, res[45].exec("zzz", 120)); +assertEquals(null, res[45].exec("bzz", 121)); +assertEquals(null, res[45].exec("bar", 122)); +assertEquals(null, res[45].exec("foobbar", 123)); +assertEquals(null, res[45].exec("*** Failers", 124)); +assertEquals(null, res[45].exec("fooabar", 125)); +assertEquals(null, res[46].exec("*** Failers", 126)); +assertEquals(null, res[46].exec("a", 127)); +assertEquals(null, res[48].exec("aaaaaa", 128)); +assertThrows("var re = /a[b-a]/;", 129); +assertThrows("var re = /a[/;", 130); +assertThrows("var re = /*a/;", 131); +assertThrows("var re = /abc)/;", 132); +assertThrows("var re = /(abc/;", 133); +assertThrows("var re = /a**/;", 134); +assertThrows("var re = /)(/;", 135); +assertThrows("var re = /a[b-a]/;", 136); +assertThrows("var re = /a[/;", 137); +assertThrows("var re = /*a/;", 138); +assertThrows("var re = /abc)/;", 139); +assertThrows("var re = /(abc/;", 140); +assertThrows("var re = /a**/;", 141); +assertThrows("var re = /)(/;", 142); +assertThrows("var re = /:(?:/;", 143); +assertThrows("var re = /a(?{)b/;", 144); +assertThrows("var re = /a(?{{})b/;", 145); +assertThrows("var re = /a(?{}})b/;", 146); +assertThrows("var re = /a(?{\"{\"})b/;", 147); +assertThrows("var re = /a(?{\"{\"}})b/;", 148); +assertThrows("var re = /[a[:xyz:/;", 149); +assertThrows("var re = /a{37,17}/;", 150); +assertEquals("abcd,a,d", res[58].exec("abcd"), 151); +assertEquals("abcd,a,d", res[58].exec("abcdC2"), 152); +assertEquals("abcd,a,d", res[58].exec("abcdC5"), 153); +assertEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyz"), 154); +assertEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyzC1"), 155); +assertEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyzG1"), 156); +assertEquals("abcdefghijklmno,abcdefghijklmno", res[60].exec("abcdefghijklmnopqrstuvwxyz"), 157); +assertEquals("abcdefghijklmno,abcdefghijklmno", res[60].exec("abcdefghijklmnopqrstuvwxyzC1G1"), 158); +assertEquals("abcdefghijklmnop,abcdefghijklmnop", res[61].exec("abcdefghijklmnopqrstuvwxyz"), 159); +assertEquals("abcdefghijklmnop,abcdefghijklmnop", res[61].exec("abcdefghijklmnopqrstuvwxyzC1G1L"), 160); +assertEquals("adef,a,,f", res[62].exec("adefG1G2G3G4L"), 161); +assertEquals("bcdef,bc,bc,f", res[62].exec("bcdefG1G2G3G4L"), 162); +assertEquals("adef,a,,f", res[62].exec("adefghijkC0"), 163); +assertEquals("abc\x00def", res[63].exec("abc\x00defLC0"), 164); +assertEquals("iss", res[69].exec("Mississippi"), 165); +assertEquals("iss", res[70].exec("Mississippi"), 166); +assertEquals("iss", res[71].exec("Mississippi"), 167); +assertEquals("iss", res[72].exec("Mississippi"), 168); +assertEquals("iss", res[73].exec("Mississippi"), 169); +assertEquals(null, res[73].exec("*** Failers", 170)); +assertEquals("iss", res[73].exec("MississippiA"), 171); +assertEquals("iss", res[73].exec("Mississippi"), 172); +assertEquals(null, res[73].exec("Mississippi", 173)); +assertEquals("iss", res[74].exec("ississippi"), 174); +assertEquals("abciss", res[75].exec("abciss\nxyzisspqr"), 175); +assertEquals("Mis", res[76].exec("Mississippi"), 176); +assertEquals("sis", res[76].exec("MississippiA"), 177); +assertEquals("ri ", res[76].exec("Missouri river"), 178); +assertEquals("riv", res[76].exec("Missouri riverA"), 179); +assertEquals("Mis", res[77].exec("Mississippi"), 180); +assertEquals("ab\n", res[78].exec("ab\nab\ncd"), 181); +assertEquals("ab\n", res[79].exec("ab\nab\ncd"), 182); +assertEquals("a", res[115].exec("a"), 183); +assertEquals("b", res[115].exec("b"), 184); +assertEquals("ab", res[115].exec("ab"), 185); +assertEquals("", res[115].exec("\\"), 186); +assertEquals("", res[115].exec("*** Failers"), 187); +assertEquals("", res[115].exec("N"), 188); +assertEquals("", res[116].exec("abcd"), 189); +assertEquals("", res[116].exec("-abc"), 190); +assertEquals("", res[116].exec("Nab-c"), 191); +assertEquals("", res[116].exec("*** Failers"), 192); +assertEquals("", res[116].exec("Nabc"), 193); +assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzz"), 194); +assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO0"), 195); +assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO1"), 196); +assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO2"), 197); +assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO3"), 198); +assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO4"), 199); +assertEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO5"), 200); +assertEquals("(abcd", res[118].exec("(abcd)"), 201); +assertEquals("(abcd", res[118].exec("(abcd)xyz"), 202); +assertEquals(null, res[118].exec("xyz(abcd)", 203)); +assertEquals(null, res[118].exec("(ab(xy)cd)pqr", 204)); +assertEquals(null, res[118].exec("(ab(xycd)pqr", 205)); +assertEquals(null, res[118].exec("() abc ()", 206)); +assertEquals(null, res[118].exec("12(abcde(fsh)xyz(foo(bar))lmno)89", 207)); +assertEquals(null, res[118].exec("*** Failers", 208)); +assertEquals("abcd", res[118].exec("abcd"), 209); +assertEquals("abcd", res[118].exec("abcd)"), 210); +assertEquals("(abcd", res[118].exec("(abcd"), 211); +assertEquals(null, res[118].exec("(ab(xy)cd)pqr", 212)); +assertEquals(null, res[118].exec("1(abcd)(x(y)z)pqr", 213)); +assertEquals("(abcd", res[118].exec("(abcd)"), 214); +assertEquals(null, res[118].exec("(ab(xy)cd)", 215)); +assertEquals(null, res[118].exec("(a(b(c)d)e)", 216)); +assertEquals(null, res[118].exec("((ab))", 217)); +assertEquals(null, res[118].exec("*** Failers", 218)); +assertEquals(null, res[118].exec("()", 219)); +assertEquals(null, res[118].exec("()", 220)); +assertEquals(null, res[118].exec("12(abcde(fsh)xyz(foo(bar))lmno)89", 221)); +assertEquals(null, res[118].exec("(ab(xy)cd)", 222)); +assertEquals(null, res[118].exec("(ab(xy)cd)", 223)); +assertEquals(null, res[118].exec("(ab(xy)cd)", 224)); +assertEquals(null, res[118].exec("(123ab(xy)cd)", 225)); +assertEquals(null, res[118].exec("(ab(xy)cd)", 226)); +assertEquals(null, res[118].exec("(123ab(xy)cd)", 227)); +assertEquals(null, res[118].exec("(ab(xy)cd)", 228)); +assertEquals("(abcd", res[118].exec("(abcd(xyz

qrs)123)"), 229); +assertEquals(null, res[118].exec("(ab(cd)ef)", 230)); +assertEquals(null, res[118].exec("(ab(cd(ef)gh)ij)", 231)); +assertEquals(null, res[146].exec("A", 232)); +assertEquals(null, res[146].exec("a", 233)); +assertEquals(null, res[147].exec("A", 234)); +assertEquals(null, res[147].exec("a", 235)); +assertEquals(null, res[147].exec("ab", 236)); +assertEquals(null, res[147].exec("aB", 237)); +assertEquals(null, res[147].exec("*** Failers", 238)); +assertEquals(null, res[147].exec("Ab", 239)); +assertEquals(null, res[147].exec("AB", 240)); +assertThrows("var re = /[\\200-\\110]/;", 241); +assertEquals("1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 ABC ABC,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12 ,13 ,14 ,15 ,16 ,17 ,18 ,19 ,20 ,21 ,22 ,23 ,24 ,25 ,26 ,27 ,28 ,29 ,30 ,31 ,32 ,33 ,34 ,35 ,36 ,37 ,38 ,39 ,40 ,41 ,42 ,43 ,44 ,45 ,46 ,47 ,48 ,49 ,50 ,51 ,52 ,53 ,54 ,55 ,56 ,57 ,58 ,59 ,60 ,61 ,62 ,63 ,64 ,65 ,66 ,67 ,68 ,69 ,70 ,71 ,72 ,73 ,74 ,75 ,76 ,77 ,78 ,79 ,80 ,81 ,82 ,83 ,84 ,85 ,86 ,87 ,88 ,89 ,90 ,91 ,92 ,93 ,94 ,95 ,96 ,97 ,98 ,99 ,100 ,101 ,102 ,103 ,104 ,105 ,106 ,107 ,108 ,109 ,110 ,111 ,112 ,113 ,114 ,115 ,116 ,117 ,118 ,119 ,120 ,121 ,122 ,123 ,124 ,125 ,126 ,127 ,128 ,129 ,130 ,131 ,132 ,133 ,134 ,135 ,136 ,137 ,138 ,139 ,140 ,141 ,142 ,143 ,144 ,145 ,146 ,147 ,148 ,149 ,150 ,151 ,152 ,153 ,154 ,155 ,156 ,157 ,158 ,159 ,160 ,161 ,162 ,163 ,164 ,165 ,166 ,167 ,168 ,169 ,170 ,171 ,172 ,173 ,174 ,175 ,176 ,177 ,178 ,179 ,180 ,181 ,182 ,183 ,184 ,185 ,186 ,187 ,188 ,189 ,190 ,191 ,192 ,193 ,194 ,195 ,196 ,197 ,198 ,199 ,200 ,201 ,202 ,203 ,204 ,205 ,206 ,207 ,208 ,209 ,210 ,211 ,212 ,213 ,214 ,215 ,216 ,217 ,218 ,219 ,220 ,221 ,222 ,223 ,224 ,225 ,226 ,227 ,228 ,229 ,230 ,231 ,232 ,233 ,234 ,235 ,236 ,237 ,238 ,239 ,240 ,241 ,242 ,243 ,244 ,245 ,246 ,247 ,248 ,249 ,250 ,251 ,252 ,253 ,254 ,255 ,256 ,257 ,258 ,259 ,260 ,261 ,262 ,263 ,264 ,265 ,266 ,267 ,268 ,269 ,ABC,ABC", res[149].exec("O900 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 ABC ABC"), 242); +assertEquals("mainmain,main,", res[151].exec("mainmain"), 243); +assertEquals("mainOmain,main,", res[151].exec("mainOmain"), 244); +assertEquals("aba,a,", res[153].exec("aba"), 245); +assertEquals("aabbaa,aa,", res[154].exec("aabbaa"), 246); +assertEquals("aabbaa,aa,", res[155].exec("aabbaa"), 247); +assertEquals("aabbaa,aa,", res[156].exec("aabbaa"), 248); +assertEquals("aabbaa,", res[157].exec("aabbaa"), 249); +assertEquals("aabbaa,aa,,", res[158].exec("aabbaa"), 250); +assertEquals("aabbaa,,", res[159].exec("aabbaa"), 251); +assertEquals("aabbaa,", res[160].exec("aabbaa"), 252); +assertEquals("aabbbaa,", res[161].exec("aabbbaa"), 253); +assertEquals("aabbbaa,", res[162].exec("aabbbaa"), 254); +assertEquals("aabbaa,", res[163].exec("aabbaa"), 255); +assertEquals("aabbbaa,", res[164].exec("aabbbaa"), 256); +assertEquals("aabbbaa,aa,,", res[165].exec("aabbbaa"), 257); +assertEquals("aabbbbaa,aa,,", res[166].exec("aabbbbaa"), 258); +assertThrows("var re = //;", 259); +assertEquals("a", res[169].exec("ab"), 260); +assertEquals("a", res[169].exec("aB"), 261); +assertEquals("*", res[169].exec("*** Failers"), 262); +assertEquals("A", res[169].exec("AB"), 263); +assertEquals("a", res[169].exec("ab"), 264); +assertEquals("a", res[169].exec("aB"), 265); +assertEquals("*", res[169].exec("*** Failers"), 266); +assertEquals("A", res[169].exec("AB"), 267); +assertEquals(null, res[172].exec("\\", 268)); +assertEquals(null, res[177].exec("*** Failers", 269)); +assertEquals(null, res[177].exec("xxxxx", 270)); +assertEquals(null, res[177].exec("now is the time for all good men to come to the aid of the party", 271)); +assertEquals(null, res[177].exec("*** Failers", 272)); +assertEquals(null, res[177].exec("this is not a line with only words and spaces!", 273)); +assertEquals(null, res[177].exec("12345a", 274)); +assertEquals(null, res[177].exec("*** Failers", 275)); +assertEquals(null, res[177].exec("12345+", 276)); +assertEquals(null, res[177].exec("aaab", 277)); +assertEquals(null, res[177].exec("aaab", 278)); +assertEquals(null, res[177].exec("aaab", 279)); +assertEquals(null, res[177].exec("((abc(ade)ufh()()x", 280)); +assertEquals(null, res[177].exec("(abc)", 281)); +assertEquals(null, res[177].exec("(abc(def)xyz)", 282)); +assertEquals(null, res[177].exec("*** Failers", 283)); +assertEquals(null, res[177].exec("((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 284)); +assertEquals(null, res[177].exec("xaaaab", 285)); +assertEquals(null, res[177].exec("xaaaab", 286)); +assertThrows("var re = /[/;", 287); +assertThrows("var re = /[a-/;", 288); +assertEquals(null, res[189].exec("<>", 289)); +assertEquals(null, res[189].exec("", 290)); +assertEquals(null, res[189].exec(" hij>", 291)); +assertEquals(null, res[189].exec(" hij>", 292)); +assertEquals(null, res[189].exec("def>", 293)); +assertEquals(null, res[189].exec("", 294)); +assertEquals(null, res[189].exec("*** Failers", 295)); +assertEquals(null, res[189].exec("", 355)); +assertEquals("abc", res[215].exec(""), 356); +assertEquals("abc", res[215].exec(" hij>"), 357); +assertEquals("abc", res[215].exec(" hij>"), 358); +assertEquals("abc", res[215].exec("def>"), 359); +assertEquals("abc", res[215].exec(""), 360); +assertEquals(null, res[215].exec("*** Failers", 361)); +assertEquals("abc", res[215].exec("\n\n\nPartner der LCO\nde\nPartner der LINEAS Consulting\nGmbH\nLINEAS Consulting GmbH Hamburg\nPartnerfirmen\n30 days\nindex,follow\n\nja\n3\nPartner\n\n\nLCO\nLINEAS Consulting\n15.10.2003\n\n\n\n\nDie Partnerfirmen der LINEAS Consulting\nGmbH\n\n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", 448)); +assertEquals("line\nbreak", res[251].exec("this is a line\nbreak"), 449); +assertEquals("line\nbreak", res[251].exec("line one\nthis is a line\nbreak in the second line"), 450); +assertEquals("line\nbreak", res[252].exec("this is a line\nbreak"), 451); +assertEquals(null, res[252].exec("** Failers", 452)); +assertEquals("line\nbreak", res[252].exec("line one\nthis is a line\nbreak in the second line"), 453); +assertEquals("line\nbreak", res[253].exec("this is a line\nbreak"), 454); +assertEquals(null, res[253].exec("** Failers", 455)); +assertEquals("line\nbreak", res[253].exec("line one\nthis is a line\nbreak in the second line"), 456); +assertEquals("ab-cd", res[254].exec("ab-cd"), 457); +assertEquals("ab=cd", res[254].exec("ab=cd"), 458); +assertEquals(null, res[254].exec("** Failers", 459)); +assertEquals(null, res[254].exec("ab\ncd", 460)); +assertEquals("ab-cd", res[255].exec("ab-cd"), 461); +assertEquals("ab=cd", res[255].exec("ab=cd"), 462); +assertEquals(null, res[255].exec("ab\ncd", 463)); +assertEquals(null, res[255].exec("AbCd", 464)); +assertEquals(null, res[255].exec("** Failers", 465)); +assertEquals(null, res[255].exec("abcd", 466)); +// We are compatible with JSC, and don't throw an exception in this case. +// assertThrows("var re = /(){2,4294967295}/;", 467); +assertEquals(null, res[255].exec("abcdefghijklAkB", 468)); +assertEquals(null, res[255].exec("abcdefghijklAkB", 469)); +assertEquals(null, res[255].exec("abcdefghijklAkB", 470)); +assertEquals(null, res[255].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 471)); +assertEquals(null, res[255].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 472)); +assertEquals(null, res[255].exec("(this(and)that", 473)); +assertEquals(null, res[255].exec("(this(and)that)", 474)); +assertEquals(null, res[255].exec("(this(and)that)stuff", 475)); +assertEquals(null, res[255].exec("(this(and)that", 476)); +assertEquals(null, res[255].exec("(this(and)that)", 477)); +assertEquals(null, res[255].exec("(this(and)that", 478)); +assertEquals(null, res[255].exec("(this(and)that)", 479)); +assertEquals(null, res[255].exec("(this(and)that", 480)); +assertEquals(null, res[255].exec("(this(and)that)", 481)); +assertEquals(null, res[255].exec("((this))", 482)); +assertEquals(null, res[255].exec("(this(and)that", 483)); +assertEquals(null, res[255].exec("(this(and)that)", 484)); +assertEquals(null, res[255].exec("(this)", 485)); +assertEquals(null, res[255].exec("((this))", 486)); +assertEquals("abc,b", res[256].exec("abc"), 487); +assertEquals("abc,b", res[256].exec("abc"), 488); +assertEquals(null, res[256].exec("a1bCA", 489)); +assertEquals(null, res[256].exec("a2bCA", 490)); +assertEquals(null, res[257].exec("a bc dCACBCC", 491)); +assertEquals(null, res[257].exec("aabc", 492)); +assertEquals(null, res[257].exec("bc", 493)); +assertEquals(null, res[257].exec("** Failers", 494)); +assertEquals(null, res[257].exec("abc", 495)); +assertEquals(null, res[257].exec("bXaX", 496)); +assertEquals(null, res[257].exec("bbXaaX", 497)); +assertEquals(null, res[257].exec("(b)\\Xa\\X", 498)); +assertEquals(null, res[257].exec("bXXaYYaY", 499)); +assertEquals(null, res[257].exec("bXYaXXaX", 500)); +assertEquals(null, res[257].exec("bXXaYYaY", 501)); +assertEquals("\x0b,\x0b", res[259].exec("\x0b,\x0b"), 502); +assertEquals("\x0c,\x0d", res[259].exec("\x0c,\x0d"), 503); +assertEquals("abc", res[260].exec("xyz\nabc"), 504); +assertEquals("abc", res[260].exec("xyz\nabc"), 505); +assertEquals("abc", res[260].exec("xyz\x0d\nabc"), 506); +assertEquals("abc", res[260].exec("xyz\x0dabc"), 507); +assertEquals("abc", res[260].exec("xyz\x0d\nabc"), 508); +assertEquals(null, res[260].exec("** Failers", 509)); +assertEquals("abc", res[260].exec("xyz\nabc"), 510); +assertEquals("abc", res[260].exec("xyz\x0d\nabc"), 511); +assertEquals("abc", res[260].exec("xyz\nabc"), 512); +assertEquals("abc", res[260].exec("xyz\x0dabc"), 513); +assertEquals("abc", res[260].exec("xyz\x0dabc"), 514); +assertEquals("abc", res[261].exec("xyzabc"), 515); +assertEquals("abc", res[261].exec("xyzabc\n"), 516); +assertEquals("abc", res[261].exec("xyzabc\npqr"), 517); +assertEquals("abc", res[261].exec("xyzabc\x0d"), 518); +assertEquals("abc", res[261].exec("xyzabc\x0dpqr"), 519); +assertEquals("abc", res[261].exec("xyzabc\x0d\n"), 520); +assertEquals("abc", res[261].exec("xyzabc\x0d\npqr"), 521); +assertEquals(null, res[261].exec("** Failers", 522)); +assertEquals("abc", res[261].exec("xyzabc\x0d"), 523); +assertEquals("abc", res[261].exec("xyzabc\x0dpqr"), 524); +assertEquals("abc", res[261].exec("xyzabc\x0d\n"), 525); +assertEquals("abc", res[261].exec("xyzabc\x0d\npqr"), 526); +assertEquals("abc", res[262].exec("xyz\x0dabcdef"), 527); +assertEquals("abc", res[262].exec("xyz\nabcdef"), 528); +assertEquals(null, res[262].exec("** Failers", 529)); +assertEquals("abc", res[262].exec("xyz\nabcdef"), 530); +assertEquals("abc", res[263].exec("xyz\nabcdef"), 531); +assertEquals("abc", res[263].exec("xyz\x0dabcdef"), 532); +assertEquals(null, res[263].exec("** Failers", 533)); +assertEquals("abc", res[263].exec("xyz\x0dabcdef"), 534); +assertEquals("abc", res[264].exec("xyz\x0d\nabcdef"), 535); +assertEquals("abc", res[264].exec("xyz\x0dabcdef"), 536); +assertEquals(null, res[264].exec("** Failers", 537)); +assertEquals("abc", res[264].exec("xyz\x0dabcdef"), 538); +assertEquals("abc", res[266].exec("xyz\x0dabc"), 539); +assertEquals("abc", res[266].exec("abc"), 540); +assertEquals("abc", res[267].exec("abc\ndef"), 541); +assertEquals("abc", res[267].exec("abc\x0ddef"), 542); +assertEquals("abc", res[267].exec("abc\x0d\ndef"), 543); +assertEquals("abc", res[267].exec("abc\ndef"), 544); +assertEquals("abc", res[267].exec("abc\x0ddef"), 545); +assertEquals("abc", res[267].exec("abc\x0d\ndef"), 546); +assertEquals("abc", res[267].exec("abc\ndef"), 547); +assertEquals("abc", res[267].exec("abc\x0ddef"), 548); +assertEquals("abc", res[267].exec("abc\x0d\ndef"), 549); +assertEquals(null, res[268].exec("abc\ndef", 550)); +assertEquals(null, res[268].exec("abc\x0ddef", 551)); +assertEquals(null, res[268].exec("abc\x0d\ndef", 552)); +assertEquals("XY,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,XY,Y", res[269].exec("XYO400"), 553); +assertEquals("aaaA5", res[278].exec("aaaA5"), 554); +assertEquals(null, res[278].exec("** Failers", 555)); +assertEquals(null, res[278].exec("aaaa5", 556)); +assertEquals("aaaA5", res[279].exec("aaaA5"), 557); +assertEquals("aaaa5", res[279].exec("aaaa5"), 558); +assertEquals("x", res[350].exec("xyCabcCxyz"), 559); +assertEquals("x", res[350].exec("xyCabcCxyz"), 560); +assertEquals("b", res[350].exec("bXaX"), 561); +assertEquals("b", res[350].exec("bXbX"), 562); +assertEquals("*", res[350].exec("** Failers"), 563); +assertEquals("aX", res[350].exec("aXaX"), 564); +assertEquals("aX", res[350].exec("aXbX"), 565); +assertEquals("x", res[350].exec("xx"), 566); +assertEquals("x", res[350].exec("xy"), 567); +assertEquals("y", res[350].exec("yy"), 568); +assertEquals("y", res[350].exec("yx"), 569); +assertEquals("x", res[350].exec("xx"), 570); +assertEquals("x", res[350].exec("xy"), 571); +assertEquals("y", res[350].exec("yy"), 572); +assertEquals("y", res[350].exec("yx"), 573); +assertEquals("b", res[350].exec("bxay"), 574); +assertEquals("b", res[350].exec("bxby"), 575); +assertEquals("*", res[350].exec("** Failers"), 576); +assertEquals("ax", res[350].exec("axby"), 577); +assertEquals("X", res[350].exec("XxXxxx"), 578); +assertEquals("X", res[350].exec("XxXyyx"), 579); +assertEquals("X", res[350].exec("XxXyxx"), 580); +assertEquals("*", res[350].exec("** Failers"), 581); +assertEquals("x", res[350].exec("x"), 582); +assertEquals("ab", res[350].exec("abcabc"), 583); +assertEquals("Xaaa,a", res[351].exec("Xaaa"), 584); +assertEquals("Xaba,a", res[351].exec("Xaba"), 585); +assertThrows("var re = /^[a-\\Q\\E]/;", 586); +assertEquals(null, res[353].exec("(xy)x", 587)); +assertEquals(null, res[353].exec("1221", 588)); +assertEquals(null, res[353].exec("Satan, oscillate my metallic sonatas!", 589)); +assertEquals(null, res[353].exec("A man, a plan, a canal: Panama!", 590)); +assertEquals(null, res[353].exec("Able was I ere I saw Elba.", 591)); +assertEquals(null, res[353].exec("*** Failers", 592)); +assertEquals(null, res[353].exec("The quick brown fox", 593)); +assertEquals("abcd:,abcd", res[354].exec("abcd:"), 594); +assertEquals("abcd:,abcd", res[354].exec("abcd:"), 595); +assertEquals("a:,a", res[354].exec("a:aaxyz"), 596); +assertEquals("ab:,ab", res[354].exec("ab:ababxyz"), 597); +assertEquals(null, res[354].exec("** Failers", 598)); +assertEquals("a:,a", res[354].exec("a:axyz"), 599); +assertEquals("ab:,ab", res[354].exec("ab:abxyz"), 600); +assertEquals(null, res[354].exec("abd", 601)); +assertEquals(null, res[354].exec("ce", 602)); +assertEquals(null, res[354].exec("abcabc1Xabc2XabcXabcabc", 603)); +assertEquals(null, res[354].exec("abcabc1Xabc2XabcXabcabc", 604)); +assertEquals(null, res[354].exec("abcabc1Xabc2XabcXabcabc", 605)); +assertEquals(null, res[354].exec("abcd", 606)); +assertEquals(null, res[354].exec("metcalfe 33", 607)); +assertEquals(null, res[356].exec("a\x0db", 608)); +assertEquals(null, res[356].exec("a\nb", 609)); +assertEquals("a\x85b", res[356].exec("a\x85b "), 610); +assertEquals(null, res[356].exec("** Failers", 611)); +assertEquals(null, res[356].exec("a\nb", 612)); +assertEquals(null, res[356].exec("a\nb", 613)); +assertEquals(null, res[356].exec("a\x0db", 614)); +assertEquals(null, res[356].exec("a\x0db", 615)); +assertEquals("a\x85b", res[356].exec("a\x85b "), 616); +assertEquals(null, res[356].exec("a\x0db", 617)); +assertEquals("abc1", res[357].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 \x85abc7 JUNK"), 618); +assertEquals("abc1", res[358].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc7 abc9"), 619); +assertEquals(null, res[361].exec("a\nb", 620)); +assertEquals(null, res[361].exec("a\x0db", 621)); +assertEquals(null, res[361].exec("a\x0d\nb", 622)); +assertEquals(null, res[361].exec("a\x0bb", 623)); +assertEquals(null, res[361].exec("a\x0cb", 624)); +assertEquals(null, res[361].exec("a\x85b", 625)); +assertEquals(null, res[361].exec("** Failers", 626)); +assertEquals(null, res[361].exec("a\n\x0db", 627)); +assertEquals("ab", res[362].exec("ab"), 628); +assertEquals(null, res[362].exec("a\nb", 629)); +assertEquals(null, res[362].exec("a\x0db", 630)); +assertEquals(null, res[362].exec("a\x0d\nb", 631)); +assertEquals(null, res[362].exec("a\x0bb", 632)); +assertEquals(null, res[362].exec("a\x0cb", 633)); +assertEquals(null, res[362].exec("a\x85b", 634)); +assertEquals(null, res[362].exec("a\n\x0db", 635)); +assertEquals(null, res[362].exec("a\n\x0d\x85\x0cb", 636)); +assertEquals(null, res[363].exec("a\nb", 637)); +assertEquals(null, res[363].exec("a\x0db", 638)); +assertEquals(null, res[363].exec("a\x0d\nb", 639)); +assertEquals(null, res[363].exec("a\x0bb", 640)); +assertEquals(null, res[363].exec("a\x0cb", 641)); +assertEquals(null, res[363].exec("a\x85b", 642)); +assertEquals(null, res[363].exec("a\n\x0db", 643)); +assertEquals(null, res[363].exec("a\n\x0d\x85\x0cb", 644)); +assertEquals(null, res[363].exec("** Failers", 645)); +assertEquals(null, res[363].exec("ab", 646)); +assertEquals(null, res[364].exec("a\nb", 647)); +assertEquals(null, res[364].exec("a\n\x0db", 648)); +assertEquals(null, res[364].exec("a\n\x0d\x85b", 649)); +assertEquals(null, res[364].exec("a\x0d\n\x0d\nb", 650)); +assertEquals(null, res[364].exec("a\x0d\n\x0d\n\x0d\nb", 651)); +assertEquals(null, res[364].exec("a\n\x0d\n\x0db", 652)); +assertEquals(null, res[364].exec("a\n\n\x0d\nb", 653)); +assertEquals(null, res[364].exec("** Failers", 654)); +assertEquals(null, res[364].exec("a\n\n\n\x0db", 655)); +assertEquals(null, res[364].exec("a\x0d", 656)); +assertEquals("aRb", res[365].exec("aRb"), 657); +assertEquals(null, res[365].exec("** Failers", 658)); +assertEquals(null, res[365].exec("a\nb", 659)); +assertEquals(null, res[365].exec("abcPXP123", 660)); +assertEquals(null, res[365].exec("abcPXP123", 661)); +assertEquals(null, res[365].exec("1.2.3.4", 662)); +assertEquals(null, res[365].exec("131.111.10.206", 663)); +assertEquals(null, res[365].exec("10.0.0.0", 664)); +assertEquals(null, res[365].exec("** Failers", 665)); +assertEquals(null, res[365].exec("10.6", 666)); +assertEquals(null, res[365].exec("455.3.4.5", 667)); +assertEquals(null, res[365].exec("1.2.3.4", 668)); +assertEquals(null, res[365].exec("131.111.10.206", 669)); +assertEquals(null, res[365].exec("10.0.0.0", 670)); +assertEquals(null, res[365].exec("** Failers", 671)); +assertEquals(null, res[365].exec("10.6", 672)); +assertEquals(null, res[365].exec("455.3.4.5", 673)); +assertEquals(null, res[365].exec("123axbaxbaxbx456", 674)); +assertEquals(null, res[365].exec("123axbaxbaxb456", 675)); +assertEquals(null, res[365].exec("123axbaxbaxbx456", 676)); +assertEquals(null, res[365].exec("123axbaxbaxbx456", 677)); +assertEquals(null, res[365].exec("123axbaxbaxbx456", 678)); +assertEquals(null, res[366].exec("ababababbbabZXXXX", 679)); +assertEquals(null, res[372].exec("a\x0db", 680)); +assertEquals(null, res[372].exec("*** Failers", 681)); +assertEquals(null, res[372].exec("a\nb", 682)); +assertEquals("afoo", res[373].exec("afoo"), 683); +assertEquals(null, res[373].exec("** Failers", 684)); +assertEquals(null, res[373].exec("\x0d\nfoo", 685)); +assertEquals(null, res[373].exec("\nfoo", 686)); +assertEquals("afoo", res[374].exec("afoo"), 687); +assertEquals(null, res[374].exec("\nfoo", 688)); +assertEquals(null, res[374].exec("** Failers", 689)); +assertEquals(null, res[374].exec("\x0d\nfoo", 690)); +assertEquals("afoo", res[375].exec("afoo"), 691); +assertEquals(null, res[375].exec("** Failers", 692)); +assertEquals(null, res[375].exec("\nfoo", 693)); +assertEquals(null, res[375].exec("\x0d\nfoo", 694)); +assertEquals("afoo", res[376].exec("afoo"), 695); +assertEquals(null, res[376].exec("\x0d\nfoo", 696)); +assertEquals(null, res[376].exec("\nfoo", 697)); +assertEquals("", res[377].exec("abc\x0d\x0dxyz"), 698); +assertEquals("", res[377].exec("abc\n\x0dxyz "), 699); +assertEquals(null, res[377].exec("** Failers ", 700)); +assertEquals("", res[377].exec("abc\x0d\nxyz"), 701); +assertEquals("", res[377].exec("abc\x0d\n\x0d\n"), 702); +assertEquals("", res[377].exec("abc\x0d\n\x0d\n"), 703); +assertEquals("", res[377].exec("abc\x0d\n\x0d\n"), 704); +assertEquals("abc1", res[378].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc9"), 705); +assertEquals("X", res[379].exec("XABC"), 706); +assertEquals(null, res[379].exec("** Failers ", 707)); +assertEquals("X", res[379].exec("XABCB"), 708); +assertThrows("var re = /(ab|c)(?-1)/;", 709); +assertEquals(null, res[379].exec("abc", 710)); +assertEquals(null, res[379].exec("xyabcabc", 711)); +assertEquals(null, res[379].exec("** Failers", 712)); +assertEquals(null, res[379].exec("xyabc ", 713)); +assertThrows("var re = /x(?-0)y/;", 714); +assertThrows("var re = /x(?-1)y/;", 715); +assertEquals(null, res[379].exec("abcX", 716)); +assertEquals(null, res[379].exec("Y", 717)); +assertEquals(null, res[379].exec("** Failers", 718)); +assertEquals(null, res[379].exec("abcY ", 719)); +assertEquals(null, res[379].exec("YabcXabc", 720)); +assertEquals(null, res[379].exec("YabcXabcXabc", 721)); +assertEquals(null, res[379].exec("** Failers", 722)); +assertEquals("X", res[379].exec("XabcXabc "), 723); +assertEquals(null, res[379].exec("Y!", 724)); +assertEquals(null, res[380].exec("foobar", 725)); +assertEquals(null, res[381].exec("foobar", 726)); +assertEquals("foobaz,foo,baz", res[381].exec("foobaz "), 727); +assertEquals(null, res[382].exec("foobarbaz", 728)); +assertEquals(null, res[382].exec("tom-tom", 729)); +assertEquals(null, res[382].exec("bon-bon ", 730)); +assertEquals(null, res[382].exec("** Failers", 731)); +assertEquals(null, res[382].exec("tom-bon ", 732)); +assertEquals(null, res[382].exec("tom-tom", 733)); +assertEquals(null, res[382].exec("bon-bon ", 734)); +assertThrows("var re = /(?|(abc)|(xyz))/;", 735); +assertThrows("var re = /(x)(?|(abc)|(xyz))(x)/;", 736); +assertEquals(null, res[383].exec("xabcx", 737)); +assertEquals(null, res[383].exec("xxyzx ", 738)); +assertThrows("var re = /(x)(?|(abc)(pqr)|(xyz))(x)/;", 739); +assertEquals(null, res[383].exec("xabcpqrx", 740)); +assertEquals(null, res[383].exec("xxyzx ", 741)); +assertThrows("var re = /(?|(abc)|(xyz))\\1/;", 742); +assertEquals(null, res[383].exec("abcabc", 743)); +assertEquals(null, res[383].exec("xyzxyz ", 744)); +assertEquals(null, res[383].exec("** Failers", 745)); +assertEquals(null, res[383].exec("abcxyz", 746)); +assertEquals(null, res[383].exec("xyzabc ", 747)); +assertEquals(null, res[383].exec("abcabc", 748)); +assertEquals(null, res[383].exec("xyzabc ", 749)); +assertEquals(null, res[383].exec("** Failers ", 750)); +assertEquals(null, res[383].exec("xyzxyz ", 751)); +assertEquals(null, res[384].exec("X X\n", 752)); +assertEquals(null, res[384].exec("X\x09X\x0b", 753)); +assertEquals(null, res[384].exec("** Failers", 754)); +assertEquals(null, res[384].exec("\xa0 X\n ", 755)); +assertEquals(null, res[385].exec("\x09 \xa0X\n\x0b\x0c\x0d\n", 756)); +assertEquals(null, res[385].exec("\x09 \xa0\n\x0b\x0c\x0d\n", 757)); +assertEquals(null, res[385].exec("\x09 \xa0\n\x0b\x0c", 758)); +assertEquals(null, res[385].exec("** Failers ", 759)); +assertEquals(null, res[385].exec("\x09 \xa0\n\x0b", 760)); +assertEquals(null, res[385].exec(" ", 761)); +assertEquals(null, res[386].exec("XY ABCDE", 762)); +assertEquals(null, res[386].exec("XY PQR ST ", 763)); +assertEquals(null, res[387].exec("XY AB PQRS", 764)); +assertEquals(null, res[388].exec(">XNNNYZ", 765)); +assertEquals(null, res[388].exec("> X NYQZ", 766)); +assertEquals(null, res[388].exec("** Failers", 767)); +assertEquals(null, res[388].exec(">XYZ ", 768)); +assertEquals(null, res[388].exec("> X NY Z", 769)); +assertEquals(null, res[389].exec(">XY\nZ\nA\x0bNN\x0c", 770)); +assertEquals(null, res[389].exec(">\n\x0dX\nY\n\x0bZZZ\nAAA\x0bNNN\x0c", 771)); +assertEquals(null, res[390].exec(">\x09<", 772)); +assertEquals(null, res[391].exec(">\x09 \xa0<", 773)); +assertEquals(null, res[396].exec("** Failers", 774)); +assertEquals(null, res[396].exec("XXXX", 775)); +assertEquals(null, res[397].exec("XXXX Y ", 776)); +assertEquals(null, res[419].exec("aaaaaa", 777)); +assertEquals(null, res[419].exec("aaabccc", 778)); +assertEquals(null, res[419].exec("aaabccc", 779)); +assertEquals(null, res[419].exec("aaabccc", 780)); +assertEquals(null, res[419].exec("aaabcccaaabccc", 781)); +assertEquals(null, res[419].exec("aaaxxxxxx", 782)); +assertEquals(null, res[419].exec("aaa++++++ ", 783)); +assertEquals(null, res[419].exec("bbbxxxxx", 784)); +assertEquals(null, res[419].exec("bbb+++++ ", 785)); +assertEquals(null, res[419].exec("cccxxxx", 786)); +assertEquals(null, res[419].exec("ccc++++ ", 787)); +assertEquals(null, res[419].exec("dddddddd ", 788)); +assertEquals(null, res[419].exec("aaaxxxxxx", 789)); +assertEquals(null, res[419].exec("aaa++++++ ", 790)); +assertEquals(null, res[419].exec("bbbxxxxx", 791)); +assertEquals(null, res[419].exec("bbb+++++ ", 792)); +assertEquals(null, res[419].exec("cccxxxx", 793)); +assertEquals(null, res[419].exec("ccc++++ ", 794)); +assertEquals(null, res[419].exec("dddddddd ", 795)); +assertEquals(null, res[419].exec("aaabccc", 796)); +assertEquals(null, res[419].exec("ABX", 797)); +assertEquals(null, res[419].exec("AADE", 798)); +assertEquals(null, res[419].exec("ACDE", 799)); +assertEquals(null, res[419].exec("** Failers", 800)); +assertEquals(null, res[419].exec("AD ", 801)); +assertEquals(null, res[419].exec(" ", 802)); +assertEquals(null, res[419].exec("aaaaaa", 803)); +assertEquals(null, res[419].exec("aaabccc", 804)); +assertEquals(null, res[419].exec("aaabccc", 805)); +assertEquals(null, res[419].exec("aaabccc", 806)); +assertEquals(null, res[419].exec("aaabcccaaabccc", 807)); +assertEquals(null, res[419].exec("aaabccc", 808)); +assertEquals(null, res[422].exec("\x0d\nA", 809)); +assertEquals("\nA", res[423].exec("\x0d\nA "), 810); +assertEquals("\nA", res[424].exec("\x0d\nA "), 811); +assertEquals("\nA,\n", res[425].exec("\x0d\nA "), 812); +assertEquals(null, res[425].exec("a\nb", 813)); +assertEquals(null, res[425].exec("** Failers", 814)); +assertEquals(null, res[425].exec("a\x0db ", 815)); +assertEquals(null, res[425].exec("a\nb", 816)); +assertEquals(null, res[425].exec("** Failers", 817)); +assertEquals(null, res[425].exec("a\x0db ", 818)); +assertEquals(null, res[425].exec("a\x0db", 819)); +assertEquals(null, res[425].exec("** Failers", 820)); +assertEquals(null, res[425].exec("a\nb ", 821)); +assertEquals(null, res[425].exec("a\x0db", 822)); +assertEquals(null, res[425].exec("a\nb ", 823)); +assertEquals(null, res[425].exec("** Failers", 824)); +assertEquals(null, res[425].exec("a\x0d\nb ", 825)); +assertEquals(null, res[425].exec("** Failers", 826)); +assertEquals(null, res[425].exec("a\x0db", 827)); +assertEquals(null, res[425].exec("a\nb ", 828)); +assertEquals(null, res[425].exec("a\x0d\nb ", 829)); +assertEquals(null, res[425].exec("** Failers", 830)); +assertEquals(null, res[425].exec("a\x0db", 831)); +assertEquals(null, res[425].exec("a\nb ", 832)); +assertEquals(null, res[425].exec("a\x0d\nb ", 833)); +assertEquals(null, res[425].exec("a\x85b ", 834)); +assertEquals(null, res[426].exec("a\x0db", 835)); +assertEquals(null, res[426].exec("a\nb", 836)); +assertEquals(null, res[426].exec("a\x0d\nb", 837)); +assertEquals(null, res[426].exec("** Failers", 838)); +assertEquals(null, res[426].exec("a\x85b", 839)); +assertEquals(null, res[426].exec("a\x0bb ", 840)); +assertEquals(null, res[427].exec("a\x0db", 841)); +assertEquals(null, res[427].exec("a\nb", 842)); +assertEquals(null, res[427].exec("a\x0d\nb", 843)); +assertEquals(null, res[427].exec("a\x85b", 844)); +assertEquals(null, res[427].exec("a\x0bb ", 845)); +assertEquals(null, res[427].exec("** Failers ", 846)); +assertEquals(null, res[427].exec("a\x85b", 847)); +assertEquals(null, res[427].exec("a\x0bb", 848)); +assertEquals(null, res[428].exec("a\x0db", 849)); +assertEquals(null, res[428].exec("a\nb", 850)); +assertEquals(null, res[428].exec("a\x0d\nb", 851)); +assertEquals(null, res[428].exec("** Failers", 852)); +assertEquals(null, res[428].exec("a\x85b", 853)); +assertEquals(null, res[428].exec("a\x0bb ", 854)); +assertEquals(null, res[429].exec("a\x0db", 855)); +assertEquals(null, res[429].exec("a\nb", 856)); +assertEquals(null, res[429].exec("a\x0d\nb", 857)); +assertEquals(null, res[429].exec("a\x85b", 858)); +assertEquals(null, res[429].exec("a\x0bb ", 859)); +assertEquals(null, res[429].exec("** Failers ", 860)); +assertEquals(null, res[429].exec("a\x85b", 861)); +assertEquals(null, res[429].exec("a\x0bb", 862)); +assertEquals(null, res[430].exec("a\x0d\n\nb", 863)); +assertEquals(null, res[430].exec("a\n\x0d\x0db", 864)); +assertEquals(null, res[430].exec("a\x0d\n\x0d\n\x0d\n\x0d\nb", 865)); +assertEquals(null, res[430].exec("** Failers", 866)); +assertEquals(null, res[430].exec("a\x8585b", 867)); +assertEquals(null, res[430].exec("a\x0b\x00bb ", 868)); +assertEquals(null, res[431].exec("a\x0d\x0db", 869)); +assertEquals(null, res[431].exec("a\n\n\nb", 870)); +assertEquals(null, res[431].exec("a\x0d\n\n\x0d\x0db", 871)); +assertEquals(null, res[431].exec("a\x8585b", 872)); +assertEquals(null, res[431].exec("a\x0b\x00bb ", 873)); +assertEquals(null, res[431].exec("** Failers ", 874)); +assertEquals(null, res[431].exec("a\x0d\x0d\x0d\x0d\x0db ", 875)); +assertEquals(null, res[431].exec("a\x8585b", 876)); +assertEquals(null, res[431].exec("a\x0b\x00bb", 877)); +assertEquals(null, res[431].exec("a\nb", 878)); +assertEquals(null, res[431].exec("a\x0db ", 879)); +assertEquals(null, res[431].exec("a\x85b", 880)); +assertEquals(null, res[431].exec("a\nb", 881)); +assertEquals(null, res[431].exec("a\x0db ", 882)); +assertEquals(null, res[431].exec("a\x85b", 883)); +assertThrows("var re = /(?-+a)/;", 884); +assertEquals(null, res[443].exec("aaaa", 885)); +assertEquals(null, res[443].exec("bacxxx", 886)); +assertEquals(null, res[443].exec("bbaccxxx ", 887)); +assertEquals(null, res[443].exec("bbbacccxx", 888)); +assertEquals(null, res[443].exec("aaaa", 889)); +assertEquals(null, res[443].exec("bacxxx", 890)); +assertEquals(null, res[443].exec("bbaccxxx ", 891)); +assertEquals(null, res[443].exec("bbbacccxx", 892)); +assertEquals("a,a", res[444].exec("aaaa"), 893); +assertEquals(null, res[444].exec("bacxxx", 894)); +assertEquals(null, res[444].exec("bbaccxxx ", 895)); +assertEquals(null, res[444].exec("bbbacccxx", 896)); +assertEquals("a,a", res[445].exec("aaaa"), 897); +assertEquals(null, res[445].exec("bacxxx", 898)); +assertEquals(null, res[445].exec("bbaccxxx ", 899)); +assertEquals(null, res[445].exec("bbbacccxx", 900)); +assertEquals("a,a", res[446].exec("aaaa"), 901); +assertEquals(null, res[446].exec("bacxxx", 902)); +assertEquals(null, res[446].exec("bbaccxxx ", 903)); +assertEquals(null, res[446].exec("bbbacccxx", 904)); +assertEquals("a,a,a", res[447].exec("aaaa"), 905); +assertEquals(null, res[447].exec("bacxxx", 906)); +assertEquals(null, res[447].exec("bbaccxxx ", 907)); +assertEquals(null, res[447].exec("bbbacccxx", 908)); +assertEquals(null, res[449].exec("bacxxx", 909)); +assertEquals(null, res[449].exec("XaaX", 910)); +assertEquals(null, res[449].exec("XAAX ", 911)); +assertEquals(null, res[449].exec("XaaX", 912)); +assertEquals(null, res[449].exec("** Failers ", 913)); +assertEquals(null, res[449].exec("XAAX ", 914)); +assertEquals(null, res[449].exec("XaaX", 915)); +assertEquals(null, res[449].exec("XAAX ", 916)); +assertEquals(null, res[449].exec("xzxx", 917)); +assertEquals(null, res[449].exec("yzyy ", 918)); +assertEquals(null, res[449].exec("** Failers", 919)); +assertEquals(null, res[449].exec("xxz ", 920)); +assertEquals("a,,,a", res[450].exec("cat"), 921); +assertEquals("a,,,a", res[451].exec("cat"), 922); +assertEquals("TA]", res[452].exec("The ACTA] comes "), 923); +assertEquals("TA]", res[453].exec("The ACTA] comes "), 924); +assertEquals(null, res[453].exec("abcbabc", 925)); +assertEquals(null, res[453].exec("abcbabc", 926)); +assertEquals(null, res[453].exec("abcbabc", 927)); +assertEquals(null, res[453].exec("** Failers ", 928)); +assertEquals(null, res[453].exec("abcXabc", 929)); +assertEquals(null, res[453].exec("abcXabc", 930)); +assertEquals(null, res[453].exec("** Failers ", 931)); +assertEquals(null, res[453].exec("abcbabc", 932)); +assertEquals(null, res[453].exec("xyzbabcxyz", 933)); +assertEquals(null, res[456].exec("** Failers", 934)); +assertEquals(null, res[456].exec("ab", 935)); +assertEquals(null, res[457].exec("** Failers", 936)); +assertEquals(null, res[457].exec("ab ", 937)); +assertEquals(null, res[457].exec("** Failers", 938)); +assertEquals(null, res[457].exec("ab ", 939)); +assertEquals("aXb", res[458].exec("aXb"), 940); +assertEquals("a\nb", res[458].exec("a\nb "), 941); +assertEquals(null, res[458].exec("** Failers", 942)); +assertEquals(null, res[458].exec("ab ", 943)); +assertEquals("aXb", res[459].exec("aXb"), 944); +assertEquals("a\nX\nXb", res[459].exec("a\nX\nXb "), 945); +assertEquals(null, res[459].exec("** Failers", 946)); +assertEquals(null, res[459].exec("ab ", 947)); +assertEquals("acb", res[463].exec("acb"), 948); +assertEquals("ab", res[463].exec("ab"), 949); +assertEquals(null, res[463].exec("ax{100}b ", 950)); +assertEquals(null, res[463].exec("*** Failers", 951)); +assertEquals(null, res[463].exec("a\nb ", 952)); +assertEquals(null, res[464].exec("ax{4000}xyb ", 953)); +assertEquals(null, res[464].exec("ax{4000}yb ", 954)); +assertEquals(null, res[464].exec("ax{4000}x{100}yb ", 955)); +assertEquals(null, res[464].exec("*** Failers", 956)); +assertEquals(null, res[464].exec("ax{4000}b ", 957)); +assertEquals(null, res[464].exec("ac\ncb ", 958)); +assertEquals("a\xc0,,\xc0", res[465].exec("a\xc0\x88b"), 959); +assertEquals("ax,,x", res[466].exec("ax{100}b"), 960); +assertEquals("a\xc0\x88b,\xc0\x88,b", res[467].exec("a\xc0\x88b"), 961); +assertEquals("ax{100}b,x{100},b", res[468].exec("ax{100}b"), 962); +assertEquals("a\xc0\x92,\xc0,\x92", res[469].exec("a\xc0\x92bcd"), 963); +assertEquals("ax{,x,{", res[470].exec("ax{240}bcd"), 964); +assertEquals("a\xc0\x92,\xc0,\x92", res[471].exec("a\xc0\x92bcd"), 965); +assertEquals("ax{,x,{", res[472].exec("ax{240}bcd"), 966); +assertEquals("a\xc0,,\xc0", res[473].exec("a\xc0\x92bcd"), 967); +assertEquals("ax,,x", res[474].exec("ax{240}bcd"), 968); +assertEquals(null, res[475].exec("ax{1234}xyb ", 969)); +assertEquals(null, res[475].exec("ax{1234}x{4321}yb ", 970)); +assertEquals(null, res[475].exec("ax{1234}x{4321}x{3412}b ", 971)); +assertEquals(null, res[475].exec("*** Failers", 972)); +assertEquals(null, res[475].exec("ax{1234}b ", 973)); +assertEquals(null, res[475].exec("ac\ncb ", 974)); +assertEquals("ax{1234}xyb,x{1234}xy", res[476].exec("ax{1234}xyb "), 975); +assertEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[476].exec("ax{1234}x{4321}yb "), 976); +assertEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[476].exec("ax{1234}x{4321}x{3412}b "), 977); +assertEquals("axxxxbcdefghijb,xxxxbcdefghij", res[476].exec("axxxxbcdefghijb "), 978); +assertEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[476].exec("ax{1234}x{4321}x{3412}x{3421}b "), 979); +assertEquals(null, res[476].exec("*** Failers", 980)); +assertEquals("ax{1234}b,x{1234}", res[476].exec("ax{1234}b "), 981); +assertEquals("ax{1234}xyb,x{1234}xy", res[477].exec("ax{1234}xyb "), 982); +assertEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[477].exec("ax{1234}x{4321}yb "), 983); +assertEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[477].exec("ax{1234}x{4321}x{3412}b "), 984); +assertEquals("axxxxb,xxxx", res[477].exec("axxxxbcdefghijb "), 985); +assertEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[477].exec("ax{1234}x{4321}x{3412}x{3421}b "), 986); +assertEquals(null, res[477].exec("*** Failers", 987)); +assertEquals("ax{1234}b,x{1234}", res[477].exec("ax{1234}b "), 988); +assertEquals(null, res[478].exec("ax{1234}xyb ", 989)); +assertEquals(null, res[478].exec("ax{1234}x{4321}yb ", 990)); +assertEquals(null, res[478].exec("ax{1234}x{4321}x{3412}b ", 991)); +assertEquals("axxxxb,xxxx", res[478].exec("axxxxbcdefghijb "), 992); +assertEquals(null, res[478].exec("ax{1234}x{4321}x{3412}x{3421}b ", 993)); +assertEquals("axbxxb,xbxx", res[478].exec("axbxxbcdefghijb "), 994); +assertEquals("axxxxxb,xxxxx", res[478].exec("axxxxxbcdefghijb "), 995); +assertEquals(null, res[478].exec("*** Failers", 996)); +assertEquals(null, res[478].exec("ax{1234}b ", 997)); +assertEquals(null, res[478].exec("axxxxxxbcdefghijb ", 998)); +assertEquals(null, res[479].exec("ax{1234}xyb ", 999)); +assertEquals(null, res[479].exec("ax{1234}x{4321}yb ", 1000)); +assertEquals(null, res[479].exec("ax{1234}x{4321}x{3412}b ", 1001)); +assertEquals("axxxxb,xxxx", res[479].exec("axxxxbcdefghijb "), 1002); +assertEquals(null, res[479].exec("ax{1234}x{4321}x{3412}x{3421}b ", 1003)); +assertEquals("axbxxb,xbxx", res[479].exec("axbxxbcdefghijb "), 1004); +assertEquals("axxxxxb,xxxxx", res[479].exec("axxxxxbcdefghijb "), 1005); +assertEquals(null, res[479].exec("*** Failers", 1006)); +assertEquals(null, res[479].exec("ax{1234}b ", 1007)); +assertEquals(null, res[479].exec("axxxxxxbcdefghijb ", 1008)); +assertEquals(null, res[479].exec("*** Failers", 1009)); +assertEquals(null, res[479].exec("x{100}", 1010)); +assertEquals(null, res[479].exec("aXbcd", 1011)); +assertEquals(null, res[479].exec("ax{100}bcd", 1012)); +assertEquals(null, res[479].exec("ax{100000}bcd", 1013)); +assertEquals(null, res[479].exec("x{100}x{100}x{100}b", 1014)); +assertEquals(null, res[479].exec("*** Failers ", 1015)); +assertEquals(null, res[479].exec("x{100}x{100}b", 1016)); +assertEquals(null, res[479].exec("x{ab} ", 1017)); +assertEquals(null, res[479].exec("\xc2\xab", 1018)); +assertEquals(null, res[479].exec("*** Failers ", 1019)); +assertEquals(null, res[479].exec("\x00{ab}", 1020)); +assertEquals(null, res[479].exec("WXYZ", 1021)); +assertEquals(null, res[479].exec("x{256}XYZ ", 1022)); +assertEquals(null, res[479].exec("*** Failers", 1023)); +assertEquals(null, res[479].exec("XYZ ", 1024)); +assertEquals(null, res[480].exec("Xx{1234}", 1025)); +assertEquals(null, res[481].exec("Xx{1234}YZ", 1026)); +assertEquals("X", res[482].exec("XYZabcdce"), 1027); +assertEquals("X", res[483].exec("XYZabcde"), 1028); +assertEquals(null, res[484].exec("Xabcdefg ", 1029)); +assertEquals(null, res[484].exec("Xx{1234} ", 1030)); +assertEquals(null, res[484].exec("Xx{1234}YZ", 1031)); +assertEquals(null, res[484].exec("Xx{1234}x{512} ", 1032)); +assertEquals(null, res[484].exec("Xx{1234}x{512}YZ", 1033)); +assertEquals(null, res[485].exec("Xabcdefg ", 1034)); +assertEquals(null, res[485].exec("Xx{1234} ", 1035)); +assertEquals(null, res[485].exec("Xx{1234}YZ", 1036)); +assertEquals(null, res[485].exec("Xx{1234}x{512} ", 1037)); +assertEquals("bcd", res[486].exec("bcd"), 1038); +assertEquals("00}", res[486].exec("x{100}aYx{256}Z "), 1039); +assertEquals("x{", res[487].exec("x{100}bc"), 1040); +assertEquals("x{100}bcA", res[488].exec("x{100}bcAa"), 1041); +assertEquals("x{", res[489].exec("x{100}bca"), 1042); +assertEquals("bcd", res[490].exec("bcd"), 1043); +assertEquals("00}", res[490].exec("x{100}aYx{256}Z "), 1044); +assertEquals("x{", res[491].exec("x{100}bc"), 1045); +assertEquals("x{100}bc", res[492].exec("x{100}bcAa"), 1046); +assertEquals("x{", res[493].exec("x{100}bca"), 1047); +assertEquals(null, res[493].exec("abcd", 1048)); +assertEquals(null, res[493].exec("abcd", 1049)); +assertEquals("x{", res[493].exec("x{100}x{100} "), 1050); +assertEquals("x{", res[493].exec("x{100}x{100} "), 1051); +assertEquals("x{", res[493].exec("x{100}x{100}x{100}x{100} "), 1052); +assertEquals(null, res[493].exec("abce", 1053)); +assertEquals("x{", res[493].exec("x{100}x{100}x{100}x{100} "), 1054); +assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1055)); +assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1056)); +assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1057)); +assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}XX", 1058)); +assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 1059)); +assertEquals(null, res[493].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 1060)); +assertEquals("Xy", res[493].exec("Xyyyax{100}x{100}bXzzz"), 1061); +assertEquals("X", res[496].exec("1X2"), 1062); +assertEquals("x", res[496].exec("1x{100}2 "), 1063); +assertEquals(">X", res[497].exec("> >X Y"), 1064); +assertEquals(">x", res[497].exec("> >x{100} Y"), 1065); +assertEquals("1", res[498].exec("x{100}3"), 1066); +assertEquals(" ", res[499].exec("x{100} X"), 1067); +assertEquals("abcd", res[500].exec("12abcd34"), 1068); +assertEquals("*** Failers", res[500].exec("*** Failers"), 1069); +assertEquals(" ", res[500].exec("1234 "), 1070); +assertEquals("abc", res[501].exec("12abcd34"), 1071); +assertEquals("ab", res[501].exec("12ab34"), 1072); +assertEquals("***", res[501].exec("*** Failers "), 1073); +assertEquals(null, res[501].exec("1234", 1074)); +assertEquals(" ", res[501].exec("12a34 "), 1075); +assertEquals("ab", res[502].exec("12abcd34"), 1076); +assertEquals("ab", res[502].exec("12ab34"), 1077); +assertEquals("**", res[502].exec("*** Failers "), 1078); +assertEquals(null, res[502].exec("1234", 1079)); +assertEquals(" ", res[502].exec("12a34 "), 1080); +assertEquals("12", res[503].exec("12abcd34"), 1081); +assertEquals(null, res[503].exec("*** Failers", 1082)); +assertEquals("12", res[504].exec("12abcd34"), 1083); +assertEquals("123", res[504].exec("1234abcd"), 1084); +assertEquals(null, res[504].exec("*** Failers ", 1085)); +assertEquals(null, res[504].exec("1.4 ", 1086)); +assertEquals("12", res[505].exec("12abcd34"), 1087); +assertEquals("12", res[505].exec("1234abcd"), 1088); +assertEquals(null, res[505].exec("*** Failers ", 1089)); +assertEquals(null, res[505].exec("1.4 ", 1090)); +assertEquals("12abcd34", res[506].exec("12abcd34"), 1091); +assertEquals("***", res[506].exec("*** Failers"), 1092); +assertEquals(null, res[506].exec(" ", 1093)); +assertEquals("12a", res[507].exec("12abcd34"), 1094); +assertEquals("123", res[507].exec("1234abcd"), 1095); +assertEquals("***", res[507].exec("*** Failers"), 1096); +assertEquals(null, res[507].exec(" ", 1097)); +assertEquals("12", res[508].exec("12abcd34"), 1098); +assertEquals("12", res[508].exec("1234abcd"), 1099); +assertEquals("**", res[508].exec("*** Failers"), 1100); +assertEquals(null, res[508].exec(" ", 1101)); +assertEquals("> <", res[509].exec("12> <34"), 1102); +assertEquals(null, res[509].exec("*** Failers", 1103)); +assertEquals("> <", res[510].exec("ab> <", res[510].exec("ab> <", res[511].exec("ab> <", res[511].exec("ab> \xff<"), 1186); +assertEquals(null, res[521].exec(">x{ff}<", 1187)); +assertEquals("X", res[522].exec("XYZ"), 1188); +assertEquals("X", res[523].exec("XYZ"), 1189); +assertEquals("x", res[523].exec("x{123} "), 1190); +assertEquals(",", res[528].exec("catac"), 1191); +assertEquals(",", res[528].exec("ax{256}a "), 1192); +assertEquals(",", res[528].exec("x{85}"), 1193); +assertEquals(",", res[528].exec("\u1234 "), 1194); +assertEquals(",", res[528].exec("\u1234 "), 1195); +assertEquals(",", res[528].exec("abcdefg"), 1196); +assertEquals(",", res[528].exec("ab"), 1197); +assertEquals(",", res[528].exec("a "), 1198); +assertEquals("Ax", res[529].exec("Ax{a3}BC"), 1199); +assertEquals("Ax", res[530].exec("Ax{a3}BC"), 1200); +assertEquals("}=", res[531].exec("+x{a3}== "), 1201); +assertEquals("}=", res[532].exec("+x{a3}== "), 1202); +assertEquals("x", res[533].exec("x{442}x{435}x{441}x{442}"), 1203); +assertEquals("x", res[534].exec("x{442}x{435}x{441}x{442}"), 1204); +assertEquals("x", res[535].exec("x{442}x{435}x{441}x{442}"), 1205); +assertEquals("x", res[536].exec("x{442}x{435}x{441}x{442}"), 1206); +assertEquals("{", res[537].exec("x{2442}x{2435}x{2441}x{2442}"), 1207); +assertEquals("{", res[538].exec("x{2442}x{2435}x{2441}x{2442}"), 1208); +assertEquals("abc\n\x0dx{442}x{435}x{441}x{442}xyz ", res[539].exec("abc\n\x0dx{442}x{435}x{441}x{442}xyz "), 1209); +assertEquals("x{442}x{435}x{441}x{442}", res[539].exec("x{442}x{435}x{441}x{442}"), 1210); +assertEquals("c d", res[540].exec("abc defx{442}x{443}xyz\npqr"), 1211); +assertEquals("c d", res[541].exec("abc defx{442}x{443}xyz\npqr"), 1212); +assertEquals(null, res[542].exec("+x{2442}", 1213)); +assertEquals(null, res[543].exec("+x{2442}", 1214)); +assertEquals(null, res[544].exec("Ax{442}", 1215)); +assertEquals(null, res[545].exec("Ax{442}", 1216)); +assertEquals(null, res[546].exec("Ax{442}", 1217)); +assertEquals(null, res[547].exec("Ax{442}", 1218)); +assertEquals(null, res[548].exec("\x19x{e01ff}", 1219)); +assertEquals(null, res[549].exec("Ax{422}", 1220)); +assertEquals(null, res[550].exec("x{19}x{e01ff}", 1221)); +assertEquals(null, res[551].exec("Ax{442}", 1222)); +assertEquals(null, res[552].exec("Ax{442}", 1223)); +assertEquals(null, res[553].exec("ax{442}", 1224)); +assertEquals(null, res[554].exec("+x{2442}", 1225)); +assertEquals(null, res[555].exec("Mx{442}", 1226)); +assertEquals("abc", res[556].exec("abc"), 1227); +assertEquals("abc", res[557].exec("abc"), 1228); +assertEquals("abc", res[558].exec("abc"), 1229); +assertEquals("abc", res[559].exec("abc"), 1230); +assertEquals(null, res[560].exec("x{100}ax{1234}bcd", 1231)); +assertEquals(null, res[562].exec("x{0041}x{2262}x{0391}x{002e}", 1232)); +assertEquals(null, res[562].exec("x{D55c}x{ad6d}x{C5B4} ", 1233)); +assertEquals(null, res[562].exec("x{65e5}x{672c}x{8a9e}", 1234)); +assertEquals("{861}X", res[563].exec("x{212ab}x{212ab}x{212ab}x{861}X"), 1235); +assertEquals("x{2", res[564].exec("x{212ab}x{212ab}x{212ab}x{861}"), 1236); +assertEquals("x{c", res[564].exec("x{c0}b"), 1237); +assertEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1238); +assertEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1239); +assertEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1240); +assertEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1241); +assertEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1242); +assertEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1243); +assertEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1244); +assertEquals("Sho", res[564].exec("Should produce an error diagnostic"), 1245); +assertEquals(null, res[565].exec("Xx{1234}", 1246)); +assertEquals(null, res[565].exec("X\nabc ", 1247)); +assertEquals("b", res[566].exec("bar"), 1248); +assertEquals(null, res[566].exec("*** Failers", 1249)); +assertEquals(null, res[566].exec("c", 1250)); +assertEquals(null, res[566].exec("x{ff}", 1251)); +assertEquals(null, res[566].exec("x{100} ", 1252)); +assertEquals("c", res[567].exec("c"), 1253); +assertEquals("x", res[567].exec("x{ff}"), 1254); +assertEquals("x", res[567].exec("x{100} "), 1255); +assertEquals("*", res[567].exec("*** Failers "), 1256); +assertEquals(null, res[567].exec("aaa", 1257)); +assertEquals("x", res[568].exec("x{f1}"), 1258); +assertEquals("x", res[568].exec("x{bf}"), 1259); +assertEquals("x", res[568].exec("x{100}"), 1260); +assertEquals("x", res[568].exec("x{1000} "), 1261); +assertEquals("*", res[568].exec("*** Failers"), 1262); +assertEquals("x", res[568].exec("x{c0} "), 1263); +assertEquals("x", res[568].exec("x{f0} "), 1264); +assertEquals("1", res[568].exec("1234"), 1265); +assertEquals("\"", res[568].exec("\"1234\" "), 1266); +assertEquals("x", res[568].exec("x{100}1234"), 1267); +assertEquals("\"", res[568].exec("\"x{100}1234\" "), 1268); +assertEquals("x", res[568].exec("x{100}x{100}12ab "), 1269); +assertEquals("x", res[568].exec("x{100}x{100}\"12\" "), 1270); +assertEquals("*", res[568].exec("*** Failers "), 1271); +assertEquals("x", res[568].exec("x{100}x{100}abcd"), 1272); +assertEquals("A", res[568].exec("A"), 1273); +assertEquals("x", res[568].exec("x{100}"), 1274); +assertEquals("Z", res[568].exec("Zx{100}"), 1275); +assertEquals("x", res[568].exec("x{100}Z"), 1276); +assertEquals("*", res[568].exec("*** Failers "), 1277); +assertEquals("Z", res[568].exec("Zx{100}"), 1278); +assertEquals("x", res[568].exec("x{100}"), 1279); +assertEquals("x", res[568].exec("x{100}Z"), 1280); +assertEquals("*", res[568].exec("*** Failers "), 1281); +assertEquals("x", res[568].exec("x{100}"), 1282); +assertEquals("x", res[568].exec("x{104}"), 1283); +assertEquals("*", res[568].exec("*** Failers"), 1284); +assertEquals("x", res[568].exec("x{105}"), 1285); +assertEquals("x", res[568].exec("x{ff} "), 1286); +assertEquals("x", res[568].exec("x{100}"), 1287); +assertEquals("\u0100", res[568].exec("\u0100 "), 1288); +assertEquals("\xff", res[569].exec(">\xff<"), 1289); +assertEquals(null, res[570].exec(">x{ff}<", 1290)); +assertEquals("\xd6", res[572].exec("\xd6 # Matches without Study"), 1291); +assertEquals("x", res[572].exec("x{d6}"), 1292); +assertEquals("\xd6", res[572].exec("\xd6 <-- Same with Study"), 1293); +assertEquals("x", res[572].exec("x{d6}"), 1294); +assertEquals("\xd6", res[572].exec("\xd6 # Matches without Study"), 1295); +assertEquals("x", res[572].exec("x{d6} "), 1296); +assertEquals("\xd6", res[572].exec("\xd6 <-- Same with Study"), 1297); +assertEquals("x", res[572].exec("x{d6} "), 1298); +assertEquals("\ufffd", res[572].exec("\ufffd]"), 1299); +assertEquals("\ufffd", res[572].exec("\ufffd"), 1300); +assertEquals("\ufffd", res[572].exec("\ufffd\ufffd\ufffd"), 1301); +assertEquals("\ufffd", res[572].exec("\ufffd\ufffd\ufffd?"), 1302); +assertEquals(null, res[573].exec("\xc0\x80", 1303)); +assertEquals(null, res[573].exec("\xc1\x8f ", 1304)); +assertEquals(null, res[573].exec("\xe0\x9f\x80", 1305)); +assertEquals(null, res[573].exec("\xf0\x8f\x80\x80 ", 1306)); +assertEquals(null, res[573].exec("\xf8\x87\x80\x80\x80 ", 1307)); +assertEquals(null, res[573].exec("\xfc\x83\x80\x80\x80\x80", 1308)); +assertEquals(null, res[573].exec("\xfe\x80\x80\x80\x80\x80 ", 1309)); +assertEquals(null, res[573].exec("\xff\x80\x80\x80\x80\x80 ", 1310)); +assertEquals(null, res[573].exec("\xc3\x8f", 1311)); +assertEquals(null, res[573].exec("\xe0\xaf\x80", 1312)); +assertEquals(null, res[573].exec("\xe1\x80\x80", 1313)); +assertEquals(null, res[573].exec("\xf0\x9f\x80\x80 ", 1314)); +assertEquals(null, res[573].exec("\xf1\x8f\x80\x80 ", 1315)); +assertEquals(null, res[573].exec("\xf8\x88\x80\x80\x80 ", 1316)); +assertEquals(null, res[573].exec("\xf9\x87\x80\x80\x80 ", 1317)); +assertEquals(null, res[573].exec("\xfc\x84\x80\x80\x80\x80", 1318)); +assertEquals(null, res[573].exec("\xfd\x83\x80\x80\x80\x80", 1319)); +assertEquals(null, res[573].exec("?\xf8\x88\x80\x80\x80 ", 1320)); +assertEquals(null, res[573].exec("?\xf9\x87\x80\x80\x80 ", 1321)); +assertEquals(null, res[573].exec("?\xfc\x84\x80\x80\x80\x80", 1322)); +assertEquals(null, res[573].exec("?\xfd\x83\x80\x80\x80\x80", 1323)); +assertEquals(".", res[574].exec("A.B"), 1324); +assertEquals("{", res[574].exec("Ax{100}B "), 1325); +assertEquals("x", res[575].exec("x{100}X "), 1326); +assertEquals("a", res[575].exec("ax{1234}b"), 1327); +assertEquals(null, res[577].exec("AxxB ", 1328)); +assertEquals("abc1", res[578].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 x{0085}abc7 x{2028}abc8 x{2029}abc9 JUNK"), 1329); +assertEquals("abc1", res[579].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6x{0085} abc7x{2028} abc8x{2029} abc9"), 1330); +assertEquals(null, res[580].exec("a\nb", 1331)); +assertEquals(null, res[580].exec("a\x0db", 1332)); +assertEquals(null, res[580].exec("a\x0d\nb", 1333)); +assertEquals(null, res[580].exec("a\x0bb", 1334)); +assertEquals(null, res[580].exec("a\x0cb", 1335)); +assertEquals(null, res[580].exec("ax{85}b ", 1336)); +assertEquals(null, res[580].exec("ax{2028}b ", 1337)); +assertEquals(null, res[580].exec("ax{2029}b ", 1338)); +assertEquals(null, res[580].exec("** Failers", 1339)); +assertEquals(null, res[580].exec("a\n\x0db ", 1340)); +assertEquals("ab", res[581].exec("ab"), 1341); +assertEquals(null, res[581].exec("a\nb", 1342)); +assertEquals(null, res[581].exec("a\x0db", 1343)); +assertEquals(null, res[581].exec("a\x0d\nb", 1344)); +assertEquals(null, res[581].exec("a\x0bb", 1345)); +assertEquals(null, res[581].exec("a\x0cx{2028}x{2029}b", 1346)); +assertEquals(null, res[581].exec("ax{85}b ", 1347)); +assertEquals(null, res[581].exec("a\n\x0db ", 1348)); +assertEquals(null, res[581].exec("a\n\x0dx{85}\x0cb ", 1349)); +assertEquals(null, res[582].exec("a\nb", 1350)); +assertEquals(null, res[582].exec("a\x0db", 1351)); +assertEquals(null, res[582].exec("a\x0d\nb", 1352)); +assertEquals(null, res[582].exec("a\x0bb", 1353)); +assertEquals(null, res[582].exec("a\x0cx{2028}x{2029}b", 1354)); +assertEquals(null, res[582].exec("ax{85}b ", 1355)); +assertEquals(null, res[582].exec("a\n\x0db ", 1356)); +assertEquals(null, res[582].exec("a\n\x0dx{85}\x0cb ", 1357)); +assertEquals(null, res[582].exec("** Failers", 1358)); +assertEquals(null, res[582].exec("ab ", 1359)); +assertEquals(null, res[583].exec("a\nb", 1360)); +assertEquals(null, res[583].exec("a\n\x0db", 1361)); +assertEquals(null, res[583].exec("a\n\x0dx{85}b", 1362)); +assertEquals(null, res[583].exec("a\x0d\n\x0d\nb ", 1363)); +assertEquals(null, res[583].exec("a\x0d\n\x0d\n\x0d\nb ", 1364)); +assertEquals(null, res[583].exec("a\n\x0d\n\x0db", 1365)); +assertEquals(null, res[583].exec("a\n\n\x0d\nb ", 1366)); +assertEquals(null, res[583].exec("** Failers", 1367)); +assertEquals(null, res[583].exec("a\n\n\n\x0db", 1368)); +assertEquals(null, res[583].exec("a\x0d", 1369)); +assertEquals(null, res[584].exec("X X\n", 1370)); +assertEquals(null, res[584].exec("X\x09X\x0b", 1371)); +assertEquals(null, res[584].exec("** Failers", 1372)); +assertEquals(null, res[584].exec("x{a0} X\n ", 1373)); +assertEquals(null, res[585].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 1374)); +assertEquals(null, res[585].exec("\x09 x{a0}\n\x0b\x0c\x0d\n", 1375)); +assertEquals(null, res[585].exec("\x09 x{a0}\n\x0b\x0c", 1376)); +assertEquals(null, res[585].exec("** Failers ", 1377)); +assertEquals(null, res[585].exec("\x09 x{a0}\n\x0b", 1378)); +assertEquals(null, res[585].exec(" ", 1379)); +assertEquals(null, res[586].exec("x{3001}x{3000}x{2030}x{2028}", 1380)); +assertEquals(null, res[586].exec("Xx{180e}Xx{85}", 1381)); +assertEquals(null, res[586].exec("** Failers", 1382)); +assertEquals(null, res[586].exec("x{2009} X\n ", 1383)); +assertEquals(null, res[587].exec("x{1680}x{180e}x{2007}Xx{2028}x{2029}\x0c\x0d\n", 1384)); +assertEquals(null, res[587].exec("\x09x{205f}x{a0}\nx{2029}\x0cx{2028}\n", 1385)); +assertEquals(null, res[587].exec("\x09 x{202f}\n\x0b\x0c", 1386)); +assertEquals(null, res[587].exec("** Failers ", 1387)); +assertEquals(null, res[587].exec("\x09x{200a}x{a0}x{2028}\x0b", 1388)); +assertEquals(null, res[587].exec(" ", 1389)); +assertEquals(null, res[588].exec(">x{1680}", 1390)); +assertEquals(null, res[589].exec(">x{1680}x{180e}x{2000}x{2003}x{200a}x{202f}x{205f}x{3000}<", 1391)); +assertEquals("x{1ec5} ", res[593].exec("x{1ec5} "), 1392); +assertEquals(null, res[594].exec("x{0}x{d7ff}x{e000}x{10ffff}", 1393)); +assertEquals(null, res[594].exec("x{d800}", 1394)); +assertEquals(null, res[594].exec("x{d800}?", 1395)); +assertEquals(null, res[594].exec("x{da00}", 1396)); +assertEquals(null, res[594].exec("x{da00}?", 1397)); +assertEquals(null, res[594].exec("x{dfff}", 1398)); +assertEquals(null, res[594].exec("x{dfff}?", 1399)); +assertEquals(null, res[594].exec("x{110000} ", 1400)); +assertEquals(null, res[594].exec("x{110000}? ", 1401)); +assertEquals(null, res[594].exec("x{2000000} ", 1402)); +assertEquals(null, res[594].exec("x{2000000}? ", 1403)); +assertEquals(null, res[594].exec("x{7fffffff} ", 1404)); +assertEquals(null, res[594].exec("x{7fffffff}? ", 1405)); +assertEquals(null, res[595].exec("a\x0db", 1406)); +assertEquals(null, res[595].exec("a\nb", 1407)); +assertEquals(null, res[595].exec("a\x0d\nb", 1408)); +assertEquals(null, res[595].exec("** Failers", 1409)); +assertEquals(null, res[595].exec("ax{85}b", 1410)); +assertEquals(null, res[595].exec("a\x0bb ", 1411)); +assertEquals(null, res[596].exec("a\x0db", 1412)); +assertEquals(null, res[596].exec("a\nb", 1413)); +assertEquals(null, res[596].exec("a\x0d\nb", 1414)); +assertEquals(null, res[596].exec("ax{85}b", 1415)); +assertEquals(null, res[596].exec("a\x0bb ", 1416)); +assertEquals(null, res[596].exec("** Failers ", 1417)); +assertEquals(null, res[596].exec("ax{85}b", 1418)); +assertEquals(null, res[596].exec("a\x0bb", 1419)); +assertEquals(null, res[597].exec("a\x0db", 1420)); +assertEquals(null, res[597].exec("a\nb", 1421)); +assertEquals(null, res[597].exec("a\x0d\nb", 1422)); +assertEquals(null, res[597].exec("** Failers", 1423)); +assertEquals(null, res[597].exec("ax{85}b", 1424)); +assertEquals(null, res[597].exec("a\x0bb ", 1425)); +assertEquals(null, res[598].exec("a\x0db", 1426)); +assertEquals(null, res[598].exec("a\nb", 1427)); +assertEquals(null, res[598].exec("a\x0d\nb", 1428)); +assertEquals(null, res[598].exec("ax{85}b", 1429)); +assertEquals(null, res[598].exec("a\x0bb ", 1430)); +assertEquals(null, res[598].exec("** Failers ", 1431)); +assertEquals(null, res[598].exec("ax{85}b", 1432)); +assertEquals(null, res[598].exec("a\x0bb", 1433)); +assertEquals("QQQx{2029}ABCaXYZ=!bPQR", res[599].exec("QQQx{2029}ABCaXYZ=!bPQR"), 1434); +assertEquals(null, res[599].exec("** Failers", 1435)); +assertEquals(null, res[599].exec("ax{2029}b", 1436)); +assertEquals(null, res[599].exec("a\xe2\x80\xa9b ", 1437)); +assertEquals(null, res[600].exec("ax{1234}b", 1438)); +assertEquals("a\nb", res[600].exec("a\nb "), 1439); +assertEquals(null, res[600].exec("** Failers", 1440)); +assertEquals(null, res[600].exec("ab ", 1441)); +assertEquals("aXb", res[601].exec("aXb"), 1442); +assertEquals("a\nX\nXx{1234}b", res[601].exec("a\nX\nXx{1234}b "), 1443); +assertEquals(null, res[601].exec("** Failers", 1444)); +assertEquals(null, res[601].exec("ab ", 1445)); +assertEquals(null, res[601].exec("x{de}x{de}", 1446)); +assertEquals(null, res[601].exec("x{123} ", 1447)); +assertEquals("X", res[602].exec("Ax{1ec5}ABCXYZ"), 1448); +assertEquals(null, res[604].exec("x{c0}x{30f}x{660}x{66c}x{f01}x{1680}<", 1449)); +assertEquals(null, res[604].exec("\npx{300}9!$ < ", 1450)); +assertEquals(null, res[604].exec("** Failers ", 1451)); +assertEquals(null, res[604].exec("apx{300}9!$ < ", 1452)); +assertEquals(null, res[605].exec("X", 1453)); +assertEquals(null, res[605].exec("** Failers ", 1454)); +assertEquals(null, res[605].exec("", 1455)); +assertEquals(null, res[606].exec("9", 1456)); +assertEquals(null, res[606].exec("** Failers ", 1457)); +assertEquals(null, res[606].exec("x{c0}", 1458)); +assertEquals(null, res[607].exec("X", 1459)); +assertEquals(null, res[607].exec("** Failers ", 1460)); +assertEquals(null, res[607].exec("x{30f}", 1461)); +assertEquals(null, res[608].exec("X", 1462)); +assertEquals(null, res[608].exec("** Failers ", 1463)); +assertEquals(null, res[608].exec("x{660}", 1464)); +assertEquals(null, res[609].exec("X", 1465)); +assertEquals(null, res[609].exec("** Failers ", 1466)); +assertEquals(null, res[609].exec("x{66c}", 1467)); +assertEquals(null, res[610].exec("X", 1468)); +assertEquals(null, res[610].exec("** Failers ", 1469)); +assertEquals(null, res[610].exec("x{f01}", 1470)); +assertEquals(null, res[611].exec("X", 1471)); +assertEquals(null, res[611].exec("** Failers ", 1472)); +assertEquals(null, res[611].exec("x{1680}", 1473)); +assertEquals(null, res[612].exec("x{017}", 1474)); +assertEquals(null, res[612].exec("x{09f} ", 1475)); +assertEquals(null, res[612].exec("** Failers", 1476)); +assertEquals(null, res[612].exec("x{0600} ", 1477)); +assertEquals(null, res[613].exec("x{601}", 1478)); +assertEquals(null, res[613].exec("** Failers", 1479)); +assertEquals(null, res[613].exec("x{09f} ", 1480)); +assertEquals(null, res[614].exec("x{e0000}", 1481)); +assertEquals(null, res[614].exec("** Failers", 1482)); +assertEquals(null, res[614].exec("x{09f} ", 1483)); +assertEquals(null, res[615].exec("x{f8ff}", 1484)); +assertEquals(null, res[615].exec("** Failers", 1485)); +assertEquals(null, res[615].exec("x{09f} ", 1486)); +assertEquals(null, res[616].exec("?x{dfff}", 1487)); +assertEquals(null, res[616].exec("** Failers", 1488)); +assertEquals(null, res[616].exec("x{09f} ", 1489)); +assertEquals(null, res[617].exec("a", 1490)); +assertEquals(null, res[617].exec("** Failers ", 1491)); +assertEquals(null, res[617].exec("Z", 1492)); +assertEquals(null, res[617].exec("x{e000} ", 1493)); +assertEquals(null, res[618].exec("x{2b0}", 1494)); +assertEquals(null, res[618].exec("** Failers", 1495)); +assertEquals(null, res[618].exec("a ", 1496)); +assertEquals(null, res[619].exec("x{1bb}", 1497)); +assertEquals(null, res[619].exec("x{3400}", 1498)); +assertEquals(null, res[619].exec("x{3401}", 1499)); +assertEquals(null, res[619].exec("x{4d00}", 1500)); +assertEquals(null, res[619].exec("x{4db4}", 1501)); +assertEquals(null, res[619].exec("x{4db5} ", 1502)); +assertEquals(null, res[619].exec("** Failers", 1503)); +assertEquals(null, res[619].exec("a ", 1504)); +assertEquals(null, res[619].exec("x{2b0}", 1505)); +assertEquals(null, res[619].exec("x{4db6} ", 1506)); +assertEquals(null, res[620].exec("x{1c5}", 1507)); +assertEquals(null, res[620].exec("** Failers", 1508)); +assertEquals(null, res[620].exec("a ", 1509)); +assertEquals(null, res[620].exec("x{2b0}", 1510)); +assertEquals(null, res[621].exec("A", 1511)); +assertEquals(null, res[621].exec("** Failers", 1512)); +assertEquals(null, res[621].exec("x{2b0}", 1513)); +assertEquals(null, res[622].exec("x{903}", 1514)); +assertEquals(null, res[622].exec("** Failers", 1515)); +assertEquals(null, res[622].exec("X", 1516)); +assertEquals(null, res[622].exec("x{300}", 1517)); +assertEquals(null, res[622].exec(" ", 1518)); +assertEquals(null, res[623].exec("x{488}", 1519)); +assertEquals(null, res[623].exec("** Failers", 1520)); +assertEquals(null, res[623].exec("X", 1521)); +assertEquals(null, res[623].exec("x{903}", 1522)); +assertEquals(null, res[623].exec("x{300}", 1523)); +assertEquals(null, res[624].exec("x{300}", 1524)); +assertEquals(null, res[624].exec("** Failers", 1525)); +assertEquals(null, res[624].exec("X", 1526)); +assertEquals(null, res[624].exec("x{903}", 1527)); +assertEquals(null, res[624].exec("0123456789x{660}x{661}x{662}x{663}x{664}x{665}x{666}x{667}x{668}x{669}x{66a}", 1528)); +assertEquals(null, res[624].exec("x{6f0}x{6f1}x{6f2}x{6f3}x{6f4}x{6f5}x{6f6}x{6f7}x{6f8}x{6f9}x{6fa}", 1529)); +assertEquals(null, res[624].exec("x{966}x{967}x{968}x{969}x{96a}x{96b}x{96c}x{96d}x{96e}x{96f}x{970}", 1530)); +assertEquals(null, res[624].exec("** Failers", 1531)); +assertEquals(null, res[624].exec("X", 1532)); +assertEquals(null, res[625].exec("x{16ee}", 1533)); +assertEquals(null, res[625].exec("** Failers", 1534)); +assertEquals(null, res[625].exec("X", 1535)); +assertEquals(null, res[625].exec("x{966}", 1536)); +assertEquals(null, res[626].exec("x{b2}", 1537)); +assertEquals(null, res[626].exec("x{b3}", 1538)); +assertEquals(null, res[626].exec("** Failers", 1539)); +assertEquals(null, res[626].exec("X", 1540)); +assertEquals(null, res[626].exec("x{16ee}", 1541)); +assertEquals(null, res[627].exec("_", 1542)); +assertEquals(null, res[627].exec("x{203f}", 1543)); +assertEquals(null, res[627].exec("** Failers", 1544)); +assertEquals(null, res[627].exec("X", 1545)); +assertEquals(null, res[627].exec("-", 1546)); +assertEquals(null, res[627].exec("x{58a}", 1547)); +assertEquals(null, res[628].exec("-", 1548)); +assertEquals(null, res[628].exec("x{58a}", 1549)); +assertEquals(null, res[628].exec("** Failers", 1550)); +assertEquals(null, res[628].exec("X", 1551)); +assertEquals(null, res[628].exec("x{203f}", 1552)); +assertEquals(null, res[629].exec(")", 1553)); +assertEquals(null, res[629].exec("]", 1554)); +assertEquals(null, res[629].exec("}", 1555)); +assertEquals(null, res[629].exec("x{f3b}", 1556)); +assertEquals(null, res[629].exec("** Failers", 1557)); +assertEquals(null, res[629].exec("X", 1558)); +assertEquals(null, res[629].exec("x{203f}", 1559)); +assertEquals(null, res[629].exec("(", 1560)); +assertEquals(null, res[629].exec("[", 1561)); +assertEquals(null, res[629].exec("{", 1562)); +assertEquals(null, res[629].exec("x{f3c}", 1563)); +assertEquals(null, res[630].exec("x{bb}", 1564)); +assertEquals(null, res[630].exec("x{2019}", 1565)); +assertEquals(null, res[630].exec("** Failers", 1566)); +assertEquals(null, res[630].exec("X", 1567)); +assertEquals(null, res[630].exec("x{203f}", 1568)); +assertEquals(null, res[631].exec("x{ab}", 1569)); +assertEquals(null, res[631].exec("x{2018}", 1570)); +assertEquals(null, res[631].exec("** Failers", 1571)); +assertEquals(null, res[631].exec("X", 1572)); +assertEquals(null, res[631].exec("x{203f}", 1573)); +assertEquals(null, res[632].exec("!", 1574)); +assertEquals(null, res[632].exec("x{37e}", 1575)); +assertEquals(null, res[632].exec("** Failers", 1576)); +assertEquals(null, res[632].exec("X", 1577)); +assertEquals(null, res[632].exec("x{203f}", 1578)); +assertEquals(null, res[633].exec("(", 1579)); +assertEquals(null, res[633].exec("[", 1580)); +assertEquals(null, res[633].exec("{", 1581)); +assertEquals(null, res[633].exec("x{f3c}", 1582)); +assertEquals(null, res[633].exec("** Failers", 1583)); +assertEquals(null, res[633].exec("X", 1584)); +assertEquals(null, res[633].exec(")", 1585)); +assertEquals(null, res[633].exec("]", 1586)); +assertEquals(null, res[633].exec("}", 1587)); +assertEquals(null, res[633].exec("x{f3b}", 1588)); +assertEquals(null, res[633].exec("$x{a2}x{a3}x{a4}x{a5}x{a6}", 1589)); +assertEquals(null, res[633].exec("x{9f2}", 1590)); +assertEquals(null, res[633].exec("** Failers", 1591)); +assertEquals(null, res[633].exec("X", 1592)); +assertEquals(null, res[633].exec("x{2c2}", 1593)); +assertEquals(null, res[634].exec("x{2c2}", 1594)); +assertEquals(null, res[634].exec("** Failers", 1595)); +assertEquals(null, res[634].exec("X", 1596)); +assertEquals(null, res[634].exec("x{9f2}", 1597)); +assertEquals(null, res[634].exec("+<|~x{ac}x{2044}", 1598)); +assertEquals(null, res[634].exec("** Failers", 1599)); +assertEquals(null, res[634].exec("X", 1600)); +assertEquals(null, res[634].exec("x{9f2}", 1601)); +assertEquals(null, res[635].exec("x{a6}", 1602)); +assertEquals(null, res[635].exec("x{482} ", 1603)); +assertEquals(null, res[635].exec("** Failers", 1604)); +assertEquals(null, res[635].exec("X", 1605)); +assertEquals(null, res[635].exec("x{9f2}", 1606)); +assertEquals(null, res[636].exec("x{2028}", 1607)); +assertEquals(null, res[636].exec("** Failers", 1608)); +assertEquals(null, res[636].exec("X", 1609)); +assertEquals(null, res[636].exec("x{2029}", 1610)); +assertEquals(null, res[637].exec("x{2029}", 1611)); +assertEquals(null, res[637].exec("** Failers", 1612)); +assertEquals(null, res[637].exec("X", 1613)); +assertEquals(null, res[637].exec("x{2028}", 1614)); +assertEquals(null, res[638].exec("\\ \\", 1615)); +assertEquals(null, res[638].exec("x{a0}", 1616)); +assertEquals(null, res[638].exec("x{1680}", 1617)); +assertEquals(null, res[638].exec("x{180e}", 1618)); +assertEquals(null, res[638].exec("x{2000}", 1619)); +assertEquals(null, res[638].exec("x{2001} ", 1620)); +assertEquals(null, res[638].exec("** Failers", 1621)); +assertEquals(null, res[638].exec("x{2028}", 1622)); +assertEquals(null, res[638].exec("x{200d} ", 1623)); +assertEquals(null, res[638].exec(" x{660}x{661}x{662}ABC", 1624)); +assertEquals(null, res[638].exec(" x{660}x{661}x{662}ABC", 1625)); +assertEquals(null, res[639].exec(" x{660}x{661}x{662}ABC", 1626)); +assertEquals(null, res[640].exec(" x{660}x{661}x{662}ABC", 1627)); +assertEquals(null, res[641].exec(" x{660}x{661}x{662}ABC", 1628)); +assertEquals(null, res[642].exec(" x{660}x{661}x{662}ABC", 1629)); +assertEquals(null, res[643].exec(" x{660}x{661}x{662}ABC", 1630)); +assertEquals(null, res[644].exec(" x{660}x{661}x{662}ABC", 1631)); +assertEquals(null, res[645].exec(" x{660}x{661}x{662}ABC", 1632)); +assertEquals(null, res[646].exec(" x{660}x{661}x{662}ABC", 1633)); +assertEquals(null, res[647].exec(" x{660}x{661}x{662}ABC", 1634)); +assertEquals(null, res[647].exec(" x{660}x{661}x{662}ABC", 1635)); +assertEquals(null, res[647].exec(" x{660}x{661}x{662}ABC", 1636)); +assertEquals(null, res[647].exec(" ** Failers", 1637)); +assertEquals(null, res[647].exec(" x{660}x{661}x{662}ABC", 1638)); +assertEquals(null, res[648].exec("A", 1639)); +assertEquals(null, res[648].exec("ax{10a0}B ", 1640)); +assertEquals(null, res[648].exec("** Failers ", 1641)); +assertEquals(null, res[648].exec("a", 1642)); +assertEquals(null, res[648].exec("x{1d00} ", 1643)); +assertEquals(null, res[649].exec("1234", 1644)); +assertEquals(null, res[649].exec("** Failers", 1645)); +assertEquals(null, res[649].exec("ABC ", 1646)); +assertEquals(null, res[650].exec("1234", 1647)); +assertEquals(null, res[650].exec("** Failers", 1648)); +assertEquals(null, res[650].exec("ABC ", 1649)); +assertEquals(null, res[650].exec("A2XYZ", 1650)); +assertEquals(null, res[650].exec("123A5XYZPQR", 1651)); +assertEquals(null, res[650].exec("ABAx{660}XYZpqr", 1652)); +assertEquals(null, res[650].exec("** Failers", 1653)); +assertEquals(null, res[650].exec("AXYZ", 1654)); +assertEquals(null, res[650].exec("XYZ ", 1655)); +assertEquals(null, res[650].exec("1XYZ", 1656)); +assertEquals(null, res[650].exec("AB=XYZ.. ", 1657)); +assertEquals(null, res[650].exec("XYZ ", 1658)); +assertEquals(null, res[650].exec("** Failers", 1659)); +assertEquals(null, res[650].exec("WXYZ ", 1660)); +assertEquals(null, res[655].exec("1234", 1661)); +assertEquals(null, res[655].exec("1234", 1662)); +assertEquals(null, res[655].exec("12-34", 1663)); +assertEquals("{", res[655].exec("12+x{661}-34 "), 1664); +assertEquals(null, res[655].exec("** Failers", 1665)); +assertEquals("d", res[655].exec("abcd "), 1666); +assertEquals("d", res[656].exec("abcd"), 1667); +assertEquals(null, res[656].exec("** Failers", 1668)); +assertEquals(null, res[656].exec("1234", 1669)); +assertEquals(null, res[657].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1670)); +assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[657].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1671); +assertEquals(" ", res[657].exec(" "), 1672); +assertEquals(null, res[657].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1673)); +assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[657].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1674); +assertEquals(null, res[658].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1675)); +assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[658].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1676); +assertEquals(null, res[659].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1677)); +assertEquals(null, res[659].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1678)); +assertEquals(null, res[660].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1679)); +assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[660].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1680); +assertEquals(null, res[661].exec("a", 1681)); +assertEquals(null, res[661].exec("A ", 1682)); +assertEquals(null, res[662].exec("a", 1683)); +assertEquals(null, res[662].exec("A ", 1684)); +assertEquals(null, res[663].exec("A", 1685)); +assertEquals(null, res[663].exec("aZ", 1686)); +assertEquals(null, res[663].exec("** Failers", 1687)); +assertEquals(null, res[663].exec("abc ", 1688)); +assertEquals(null, res[664].exec("A", 1689)); +assertEquals(null, res[664].exec("aZ", 1690)); +assertEquals(null, res[664].exec("** Failers", 1691)); +assertEquals(null, res[664].exec("abc ", 1692)); +assertEquals(null, res[665].exec("a", 1693)); +assertEquals(null, res[665].exec("Az", 1694)); +assertEquals(null, res[665].exec("** Failers", 1695)); +assertEquals(null, res[665].exec("ABC ", 1696)); +assertEquals(null, res[666].exec("a", 1697)); +assertEquals(null, res[666].exec("Az", 1698)); +assertEquals(null, res[666].exec("** Failers", 1699)); +assertEquals(null, res[666].exec("ABC ", 1700)); +assertEquals(null, res[666].exec("x{c0}", 1701)); +assertEquals(null, res[666].exec("x{e0} ", 1702)); +assertEquals(null, res[666].exec("x{c0}", 1703)); +assertEquals(null, res[666].exec("x{e0} ", 1704)); +assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 1705)); +assertEquals(null, res[666].exec("** Failers", 1706)); +assertEquals(null, res[666].exec("ax{391}x{10427}x{ff3a}x{1fb0} ", 1707)); +assertEquals(null, res[666].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 1708)); +assertEquals(null, res[666].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 1709)); +assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 1710)); +assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 1711)); +assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 1712)); +assertEquals(null, res[666].exec("ax{391}x{10427}x{ff3a}x{1fb0} ", 1713)); +assertEquals(null, res[666].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 1714)); +assertEquals(null, res[666].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 1715)); +assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 1716)); +assertEquals(null, res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 1717)); +assertEquals(null, res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}", 1718)); +assertEquals(null, res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 1719)); +assertEquals(null, res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 1720)); +assertEquals(null, res[666].exec("x{391}", 1721)); +assertEquals(null, res[666].exec("x{ff3a}", 1722)); +assertEquals(null, res[666].exec("x{3b1}", 1723)); +assertEquals(null, res[666].exec("x{ff5a} ", 1724)); +assertEquals(null, res[666].exec("x{c0}", 1725)); +assertEquals(null, res[666].exec("x{e0} ", 1726)); +assertEquals(null, res[666].exec("x{104}", 1727)); +assertEquals(null, res[666].exec("x{105}", 1728)); +assertEquals(null, res[666].exec("x{109} ", 1729)); +assertEquals(null, res[666].exec("** Failers", 1730)); +assertEquals(null, res[666].exec("x{100}", 1731)); +assertEquals(null, res[666].exec("x{10a} ", 1732)); +assertEquals(null, res[666].exec("Z", 1733)); +assertEquals(null, res[666].exec("z", 1734)); +assertEquals(null, res[666].exec("x{39c}", 1735)); +assertEquals(null, res[666].exec("x{178}", 1736)); +assertEquals(null, res[666].exec("|", 1737)); +assertEquals(null, res[666].exec("x{80}", 1738)); +assertEquals(null, res[666].exec("x{ff}", 1739)); +assertEquals(null, res[666].exec("x{100}", 1740)); +assertEquals(null, res[666].exec("x{101} ", 1741)); +assertEquals(null, res[666].exec("** Failers", 1742)); +assertEquals(null, res[666].exec("x{102}", 1743)); +assertEquals(null, res[666].exec("Y", 1744)); +assertEquals(null, res[666].exec("y ", 1745)); +assertEquals(null, res[667].exec("A", 1746)); +assertEquals(null, res[667].exec("Ax{300}BC ", 1747)); +assertEquals(null, res[667].exec("Ax{300}x{301}x{302}BC ", 1748)); +assertEquals(null, res[667].exec("*** Failers", 1749)); +assertEquals(null, res[667].exec("x{300} ", 1750)); +assertEquals("X", res[668].exec("X123"), 1751); +assertEquals(null, res[668].exec("*** Failers", 1752)); +assertEquals(null, res[668].exec("AXYZ", 1753)); +assertEquals(null, res[669].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 1754)); +assertEquals(null, res[669].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 1755)); +assertEquals(null, res[670].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 1756)); +assertEquals(null, res[670].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 1757)); +assertEquals("A,,A", res[671].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 1758); +assertEquals("A,,A", res[671].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 1759); +assertEquals("A,,A", res[672].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 1760); +assertEquals("A,,A", res[672].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 1761); +assertEquals(null, res[673].exec("*** Failers", 1762)); +assertEquals(null, res[673].exec("Ax{300}x{301}x{302}", 1763)); +assertEquals(null, res[674].exec("Ax{300}x{301}Bx{300}X", 1764)); +assertEquals(null, res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 1765)); +assertEquals(null, res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 1766)); +assertEquals(null, res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 1767)); +assertEquals(null, res[675].exec("Ax{300}x{301}Bx{300}X", 1768)); +assertEquals(null, res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 1769)); +assertEquals(null, res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 1770)); +assertEquals(null, res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 1771)); +assertEquals(null, res[675].exec("x{2e81}x{3007}x{2f804}x{31a0}", 1772)); +assertEquals(null, res[675].exec("** Failers", 1773)); +assertEquals(null, res[675].exec("x{2e7f} ", 1774)); +assertEquals(null, res[675].exec("x{3105}", 1775)); +assertEquals(null, res[675].exec("** Failers", 1776)); +assertEquals(null, res[675].exec("x{30ff} ", 1777)); +assertEquals(null, res[676].exec("x{06e9}", 1778)); +assertEquals(null, res[676].exec("x{060b}", 1779)); +assertEquals(null, res[676].exec("** Failers", 1780)); +assertEquals(null, res[676].exec("Xx{06e9} ", 1781)); +assertEquals(null, res[677].exec("x{2f800}", 1782)); +assertEquals(null, res[677].exec("** Failers", 1783)); +assertEquals(null, res[677].exec("x{a014}", 1784)); +assertEquals(null, res[677].exec("x{a4c6} ", 1785)); +assertEquals(null, res[678].exec("AXYZ", 1786)); +assertEquals(null, res[678].exec("x{1234}XYZ ", 1787)); +assertEquals(null, res[678].exec("** Failers", 1788)); +assertEquals(null, res[678].exec("X ", 1789)); +assertEquals(null, res[679].exec("** Failers", 1790)); +assertEquals(null, res[679].exec("AX", 1791)); +assertEquals(null, res[680].exec("XYZ", 1792)); +assertEquals(null, res[680].exec("AXYZ", 1793)); +assertEquals(null, res[680].exec("x{1234}XYZ ", 1794)); +assertEquals(null, res[680].exec("** Failers", 1795)); +assertEquals(null, res[680].exec("ABXYZ ", 1796)); +assertEquals(null, res[681].exec("XYZ", 1797)); +assertEquals(null, res[681].exec("** Failers", 1798)); +assertEquals(null, res[681].exec("AXYZ", 1799)); +assertEquals(null, res[681].exec("x{1234}XYZ ", 1800)); +assertEquals(null, res[681].exec("ABXYZ ", 1801)); +assertEquals(null, res[681].exec("AXYZ", 1802)); +assertEquals(null, res[681].exec("x{1234}XYZ", 1803)); +assertEquals(null, res[681].exec("Ax{1234}XYZ", 1804)); +assertEquals(null, res[681].exec("** Failers", 1805)); +assertEquals(null, res[681].exec("XYZ", 1806)); +assertEquals(null, res[681].exec("** Failers", 1807)); +assertEquals(null, res[681].exec("AXYZ", 1808)); +assertEquals(null, res[681].exec("x{1234}XYZ", 1809)); +assertEquals(null, res[681].exec("Ax{1234}XYZ", 1810)); +assertEquals(null, res[681].exec("XYZ", 1811)); +assertEquals(null, res[682].exec("XYZ", 1812)); +assertEquals(null, res[682].exec("AXYZ", 1813)); +assertEquals(null, res[682].exec("x{1234}XYZ", 1814)); +assertEquals(null, res[682].exec("Ax{1234}XYZ", 1815)); +assertEquals(null, res[682].exec("** Failers", 1816)); +assertEquals(null, res[683].exec("XYZ", 1817)); +assertEquals(null, res[683].exec("** Failers", 1818)); +assertEquals(null, res[683].exec("AXYZ", 1819)); +assertEquals(null, res[683].exec("x{1234}XYZ", 1820)); +assertEquals(null, res[683].exec("Ax{1234}XYZ", 1821)); +assertEquals("AX", res[684].exec("AXYZ"), 1822); +assertEquals(null, res[684].exec("x{1234}XYZ ", 1823)); +assertEquals(null, res[684].exec("** Failers", 1824)); +assertEquals(null, res[684].exec("X ", 1825)); +assertEquals(null, res[685].exec("** Failers", 1826)); +assertEquals("AX", res[685].exec("AX"), 1827); +assertEquals("X", res[686].exec("XYZ"), 1828); +assertEquals("AX", res[686].exec("AXYZ"), 1829); +assertEquals(null, res[686].exec("x{1234}XYZ ", 1830)); +assertEquals(null, res[686].exec("** Failers", 1831)); +assertEquals(null, res[686].exec("ABXYZ ", 1832)); +assertEquals("X", res[687].exec("XYZ"), 1833); +assertEquals(null, res[687].exec("** Failers", 1834)); +assertEquals("AX", res[687].exec("AXYZ"), 1835); +assertEquals(null, res[687].exec("x{1234}XYZ ", 1836)); +assertEquals(null, res[687].exec("ABXYZ ", 1837)); +assertEquals("AX", res[688].exec("AXYZ"), 1838); +assertEquals(null, res[688].exec("x{1234}XYZ", 1839)); +assertEquals(null, res[688].exec("Ax{1234}XYZ", 1840)); +assertEquals(null, res[688].exec("** Failers", 1841)); +assertEquals(null, res[688].exec("XYZ", 1842)); +assertEquals(null, res[689].exec("** Failers", 1843)); +assertEquals("AX", res[689].exec("AXYZ"), 1844); +assertEquals(null, res[689].exec("x{1234}XYZ", 1845)); +assertEquals(null, res[689].exec("Ax{1234}XYZ", 1846)); +assertEquals(null, res[689].exec("XYZ", 1847)); +assertEquals("X", res[690].exec("XYZ"), 1848); +assertEquals("AX", res[690].exec("AXYZ"), 1849); +assertEquals(null, res[690].exec("x{1234}XYZ", 1850)); +assertEquals(null, res[690].exec("Ax{1234}XYZ", 1851)); +assertEquals(null, res[690].exec("** Failers", 1852)); +assertEquals("X", res[691].exec("XYZ"), 1853); +assertEquals(null, res[691].exec("** Failers", 1854)); +assertEquals("AX", res[691].exec("AXYZ"), 1855); +assertEquals(null, res[691].exec("x{1234}XYZ", 1856)); +assertEquals(null, res[691].exec("Ax{1234}XYZ", 1857)); +assertEquals(null, res[692].exec("abcdefgh", 1858)); +assertEquals(null, res[692].exec("x{1234}\n\x0dx{3456}xyz ", 1859)); +assertEquals(null, res[693].exec("abcdefgh", 1860)); +assertEquals(null, res[693].exec("x{1234}\n\x0dx{3456}xyz ", 1861)); +assertEquals(null, res[694].exec("** Failers", 1862)); +assertEquals(null, res[694].exec("abcdefgh", 1863)); +assertEquals(null, res[694].exec("x{1234}\n\x0dx{3456}xyz ", 1864)); +assertEquals(null, res[695].exec(" AXY", 1865)); +assertEquals(null, res[695].exec(" aXY", 1866)); +assertEquals(null, res[695].exec(" x{1c5}XY", 1867)); +assertEquals(null, res[695].exec(" ** Failers", 1868)); +assertEquals(null, res[695].exec(" x{1bb}XY", 1869)); +assertEquals(null, res[695].exec(" x{2b0}XY", 1870)); +assertEquals(null, res[695].exec(" !XY ", 1871)); +assertEquals(null, res[696].exec(" AXY", 1872)); +assertEquals(null, res[696].exec(" aXY", 1873)); +assertEquals(null, res[696].exec(" x{1c5}XY", 1874)); +assertEquals(null, res[696].exec(" ** Failers", 1875)); +assertEquals(null, res[696].exec(" x{1bb}XY", 1876)); +assertEquals(null, res[696].exec(" x{2b0}XY", 1877)); +assertEquals(null, res[696].exec(" !XY ", 1878)); +assertEquals(null, res[696].exec(" AXY", 1879)); +assertEquals(null, res[696].exec(" aXY", 1880)); +assertEquals(null, res[696].exec(" AbcdeXyz ", 1881)); +assertEquals(null, res[696].exec(" x{1c5}AbXY", 1882)); +assertEquals(null, res[696].exec(" abcDEXypqreXlmn ", 1883)); +assertEquals(null, res[696].exec(" ** Failers", 1884)); +assertEquals(null, res[696].exec(" x{1bb}XY", 1885)); +assertEquals(null, res[696].exec(" x{2b0}XY", 1886)); +assertEquals(null, res[696].exec(" !XY ", 1887)); +assertEquals(null, res[697].exec(" AXY", 1888)); +assertEquals(null, res[697].exec(" aXY", 1889)); +assertEquals(null, res[697].exec(" AbcdeXyz ", 1890)); +assertEquals(null, res[697].exec(" x{1c5}AbXY", 1891)); +assertEquals(null, res[697].exec(" abcDEXypqreXlmn ", 1892)); +assertEquals(null, res[697].exec(" ** Failers", 1893)); +assertEquals(null, res[697].exec(" x{1bb}XY", 1894)); +assertEquals(null, res[697].exec(" x{2b0}XY", 1895)); +assertEquals(null, res[697].exec(" !XY ", 1896)); +assertEquals(null, res[697].exec(" AXY", 1897)); +assertEquals(null, res[697].exec(" aXY", 1898)); +assertEquals(null, res[697].exec(" AbcdeXyz ", 1899)); +assertEquals(null, res[697].exec(" x{1c5}AbXY", 1900)); +assertEquals(null, res[697].exec(" abcDEXypqreXlmn ", 1901)); +assertEquals(null, res[697].exec(" ** Failers", 1902)); +assertEquals(null, res[697].exec(" x{1bb}XY", 1903)); +assertEquals(null, res[697].exec(" x{2b0}XY", 1904)); +assertEquals(null, res[697].exec(" !XY ", 1905)); +assertEquals(null, res[698].exec(" AXY", 1906)); +assertEquals(null, res[698].exec(" aXY", 1907)); +assertEquals(null, res[698].exec(" AbcdeXyz ", 1908)); +assertEquals(null, res[698].exec(" x{1c5}AbXY", 1909)); +assertEquals(null, res[698].exec(" abcDEXypqreXlmn ", 1910)); +assertEquals(null, res[698].exec(" ** Failers", 1911)); +assertEquals(null, res[698].exec(" x{1bb}XY", 1912)); +assertEquals(null, res[698].exec(" x{2b0}XY", 1913)); +assertEquals(null, res[698].exec(" !XY ", 1914)); +assertEquals(null, res[699].exec(" !XY", 1915)); +assertEquals(null, res[699].exec(" x{1bb}XY", 1916)); +assertEquals(null, res[699].exec(" x{2b0}XY", 1917)); +assertEquals(null, res[699].exec(" ** Failers", 1918)); +assertEquals(null, res[699].exec(" x{1c5}XY", 1919)); +assertEquals(null, res[699].exec(" AXY ", 1920)); +assertEquals(null, res[700].exec(" !XY", 1921)); +assertEquals(null, res[700].exec(" x{1bb}XY", 1922)); +assertEquals(null, res[700].exec(" x{2b0}XY", 1923)); +assertEquals(null, res[700].exec(" ** Failers", 1924)); +assertEquals(null, res[700].exec(" x{1c5}XY", 1925)); +assertEquals(null, res[700].exec(" AXY ", 1926)); +assertEquals(null, res[701].exec("\xa0!", 1927)); +assertEquals(null, res[701].exec("AabcabcYZ ", 1928)); +assertEquals("L=abcX,L=abc,abc", res[702].exec("L=abcX"), 1929); +assertEquals(null, res[702].exec("x{c0}", 1930)); +assertEquals(null, res[702].exec("x{e0} ", 1931)); +assertEquals(null, res[702].exec("x{c0}", 1932)); +assertEquals(null, res[702].exec("x{e0} ", 1933)); +assertEquals(null, res[703].exec("x{1b00}x{12000}x{7c0}x{a840}x{10900}", 1934)); +assertEquals(null, res[706].exec("123abcdefg", 1935)); +assertEquals(null, res[706].exec("123abc\xc4\xc5zz", 1936)); +assertEquals(null, res[710].exec("A\x80", 1937)); +assertEquals(null, res[725].exec("x{60e} ", 1938)); +assertEquals(null, res[725].exec("x{656} ", 1939)); +assertEquals(null, res[725].exec("x{657} ", 1940)); +assertEquals(null, res[725].exec("x{658} ", 1941)); +assertEquals(null, res[725].exec("x{659} ", 1942)); +assertEquals(null, res[725].exec("x{65a} ", 1943)); +assertEquals(null, res[725].exec("x{65b} ", 1944)); +assertEquals(null, res[725].exec("x{65c} ", 1945)); +assertEquals(null, res[725].exec("x{65d} ", 1946)); +assertEquals(null, res[725].exec("x{65e} ", 1947)); +assertEquals(null, res[725].exec("x{66a} ", 1948)); +assertEquals(null, res[725].exec("x{6e9} ", 1949)); +assertEquals(null, res[725].exec("x{6ef}", 1950)); +assertEquals(null, res[725].exec("x{6fa} ", 1951)); +assertEquals(null, res[725].exec("** Failers", 1952)); +assertEquals(null, res[725].exec("x{600}", 1953)); +assertEquals(null, res[725].exec("x{650}", 1954)); +assertEquals(null, res[725].exec("x{651} ", 1955)); +assertEquals(null, res[725].exec("x{652} ", 1956)); +assertEquals(null, res[725].exec("x{653} ", 1957)); +assertEquals(null, res[725].exec("x{654} ", 1958)); +assertEquals(null, res[725].exec("x{655} ", 1959)); +assertEquals(null, res[725].exec("x{65f} ", 1960)); +assertEquals(null, res[726].exec("x{1d2b} ", 1961)); +assertEquals(null, res[727].exec("x{589}", 1962)); +assertEquals(null, res[727].exec("x{60c}", 1963)); +assertEquals(null, res[727].exec("x{61f} ", 1964)); +assertEquals(null, res[727].exec("x{964}", 1965)); +assertEquals(null, res[727].exec("x{965} ", 1966)); +assertEquals(null, res[727].exec("x{970} ", 1967)); +assertEquals(null, res[728].exec("x{64b}", 1968)); +assertEquals(null, res[728].exec("x{654}", 1969)); +assertEquals(null, res[728].exec("x{655}", 1970)); +assertEquals(null, res[728].exec("x{200c} ", 1971)); +assertEquals(null, res[728].exec("** Failers", 1972)); +assertEquals(null, res[728].exec("x{64a}", 1973)); +assertEquals(null, res[728].exec("x{656} ", 1974)); +assertEquals(null, res[729].exec("x{10450}", 1975)); +assertEquals(null, res[729].exec("x{1047f}", 1976)); +assertEquals(null, res[730].exec("x{10400}", 1977)); +assertEquals(null, res[730].exec("x{1044f}", 1978)); +assertEquals(null, res[731].exec("x{10480}", 1979)); +assertEquals(null, res[731].exec("x{1049d}", 1980)); +assertEquals(null, res[731].exec("x{104a0}", 1981)); +assertEquals(null, res[731].exec("x{104a9}", 1982)); +assertEquals(null, res[731].exec("** Failers", 1983)); +assertEquals(null, res[731].exec("x{1049e}", 1984)); +assertEquals(null, res[731].exec("x{1049f}", 1985)); +assertEquals(null, res[731].exec("x{104aa} ", 1986)); +assertEquals(null, res[731].exec("\xe2\x80\xa8\xe2\x80\xa8", 1987)); +assertEquals(null, res[731].exec("x{2028}x{2028}x{2028}", 1988)); +assertEquals(null, res[732].exec("x{c0}x{e0}x{116}x{117}", 1989)); +assertEquals(null, res[732].exec("x{c0}x{e0}x{116}x{117}", 1990)); +assertEquals(null, res[733].exec("x{102A4}x{AA52}x{A91D}x{1C46}x{10283}x{1092E}x{1C6B}x{A93B}x{A8BF}x{1BA0}x{A50A}====", 1991)); +assertEquals(null, res[733].exec("x{a77d}x{1d79}", 1992)); +assertEquals(null, res[733].exec("x{1d79}x{a77d} ", 1993)); +assertEquals(null, res[733].exec("x{a77d}x{1d79}", 1994)); +assertEquals(null, res[733].exec("** Failers ", 1995)); +assertEquals(null, res[733].exec("x{1d79}x{a77d} ", 1996)); +assertEquals("AA,A", res[734].exec("AA"), 1997); +assertEquals("Aa,A", res[734].exec("Aa"), 1998); +assertEquals("aa,a", res[734].exec("aa"), 1999); +assertEquals("aA,a", res[734].exec("aA"), 2000); +assertEquals(null, res[734].exec("x{de}x{de}", 2001)); +assertEquals(null, res[734].exec("x{de}x{fe}", 2002)); +assertEquals(null, res[734].exec("x{fe}x{fe}", 2003)); +assertEquals(null, res[734].exec("x{fe}x{de}", 2004)); +assertEquals(null, res[734].exec("x{10a}x{10a}", 2005)); +assertEquals(null, res[734].exec("x{10a}x{10b}", 2006)); +assertEquals(null, res[734].exec("x{10b}x{10b}", 2007)); +assertEquals(null, res[734].exec("x{10b}x{10a}", 2008)); +assertEquals("abc", res[736].exec("abc"), 2009); +assertEquals("abc", res[737].exec("abc"), 2010); +assertEquals("abbbbc", res[737].exec("abbbbc"), 2011); +assertEquals("ac", res[737].exec("ac"), 2012); +assertEquals("abc", res[738].exec("abc"), 2013); +assertEquals("abbbbbbc", res[738].exec("abbbbbbc"), 2014); +assertEquals(null, res[738].exec("*** Failers ", 2015)); +assertEquals(null, res[738].exec("ac", 2016)); +assertEquals(null, res[738].exec("ab", 2017)); +assertEquals("a", res[739].exec("a"), 2018); +assertEquals("aaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaa"), 2019); +assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "), 2020); +assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaF "), 2021); +assertEquals("a,a", res[740].exec("a"), 2022); +assertEquals("a,a", res[740].exec("abcd"), 2023); +assertEquals("a,a", res[740].exec("african"), 2024); +assertEquals("abc", res[741].exec("abcdef"), 2025); +assertEquals(null, res[741].exec("*** Failers", 2026)); +assertEquals(null, res[741].exec("xyzabc", 2027)); +assertEquals(null, res[741].exec("xyz\nabc ", 2028)); +assertEquals("abc", res[742].exec("abcdef"), 2029); +assertEquals("abc", res[742].exec("xyz\nabc "), 2030); +assertEquals(null, res[742].exec("*** Failers", 2031)); +assertEquals(null, res[742].exec("xyzabc", 2032)); +assertEquals(null, res[743].exec("abcdef", 2033)); +assertEquals(null, res[743].exec("*** Failers", 2034)); +assertEquals(null, res[743].exec("xyzabc", 2035)); +assertEquals(null, res[743].exec("xyz\nabc ", 2036)); +assertEquals(null, res[744].exec("abcdef", 2037)); +assertEquals(null, res[744].exec("*** Failers", 2038)); +assertEquals(null, res[744].exec("xyzabc", 2039)); +assertEquals(null, res[744].exec("xyz\nabc ", 2040)); +assertEquals(null, res[745].exec("abcdef", 2041)); +assertEquals(null, res[745].exec("xyzabc>3", 2042)); +assertEquals(null, res[745].exec("*** Failers", 2043)); +assertEquals(null, res[745].exec("xyzabc ", 2044)); +assertEquals(null, res[745].exec("xyzabc>2 ", 2045)); +assertEquals("x9yzz", res[746].exec("x9yzz"), 2046); +assertEquals("x0y+z", res[746].exec("x0y+z"), 2047); +assertEquals(null, res[746].exec("*** Failers", 2048)); +assertEquals(null, res[746].exec("xyz", 2049)); +assertEquals(null, res[746].exec("xxy0z ", 2050)); +assertEquals("x yzz", res[747].exec("x yzz"), 2051); +assertEquals("x y+z", res[747].exec("x y+z"), 2052); +assertEquals(null, res[747].exec("*** Failers", 2053)); +assertEquals(null, res[747].exec("xyz", 2054)); +assertEquals(null, res[747].exec("xxyyz", 2055)); +assertEquals("xxy+z", res[748].exec("xxy+z"), 2056); +assertEquals(null, res[748].exec("*** Failers", 2057)); +assertEquals(null, res[748].exec("xxy0z", 2058)); +assertEquals(null, res[748].exec("x+y+z ", 2059)); +assertEquals("x+y", res[749].exec("x+y"), 2060); +assertEquals("x-y", res[749].exec("x-y"), 2061); +assertEquals(null, res[749].exec("*** Failers", 2062)); +assertEquals(null, res[749].exec("x\ny", 2063)); +assertEquals("x+y", res[750].exec("x+y"), 2064); +assertEquals("x-y", res[750].exec("x-y"), 2065); +assertEquals(null, res[750].exec("x\ny", 2066)); +assertEquals(null, res[750].exec("a+bc+dp+q", 2067)); +assertEquals(null, res[750].exec("a+bc\ndp+q", 2068)); +assertEquals(null, res[750].exec("x\nyp+q ", 2069)); +assertEquals(null, res[750].exec("*** Failers ", 2070)); +assertEquals(null, res[750].exec("a\nbc\ndp+q", 2071)); +assertEquals(null, res[750].exec("a+bc\ndp\nq", 2072)); +assertEquals(null, res[750].exec("x\nyp\nq ", 2073)); +assertEquals(null, res[751].exec("ba0", 2074)); +assertEquals(null, res[751].exec("*** Failers", 2075)); +assertEquals(null, res[751].exec("ba0\n", 2076)); +assertEquals(null, res[751].exec("ba0\ncd ", 2077)); +assertEquals(null, res[752].exec("ba0", 2078)); +assertEquals(null, res[752].exec("*** Failers", 2079)); +assertEquals(null, res[752].exec("ba0\n", 2080)); +assertEquals(null, res[752].exec("ba0\ncd ", 2081)); +assertEquals(null, res[753].exec("ba0", 2082)); +assertEquals(null, res[753].exec("ba0\n", 2083)); +assertEquals(null, res[753].exec("*** Failers", 2084)); +assertEquals(null, res[753].exec("ba0\ncd ", 2085)); +assertEquals(null, res[754].exec("ba0", 2086)); +assertEquals(null, res[754].exec("ba0\n", 2087)); +assertEquals(null, res[754].exec("*** Failers", 2088)); +assertEquals(null, res[754].exec("ba0\ncd ", 2089)); +assertEquals("a0", res[755].exec("ba0"), 2090); +assertEquals(null, res[755].exec("ba0\n", 2091)); +assertEquals(null, res[755].exec("*** Failers", 2092)); +assertEquals(null, res[755].exec("ba0\ncd ", 2093)); +assertEquals("a0", res[756].exec("ba0"), 2094); +assertEquals("a0", res[756].exec("ba0\n"), 2095); +assertEquals("a0", res[756].exec("ba0\ncd "), 2096); +assertEquals(null, res[756].exec("*** Failers", 2097)); +assertEquals("abc", res[757].exec("abc"), 2098); +assertEquals("aBc", res[757].exec("aBc"), 2099); +assertEquals("ABC", res[757].exec("ABC"), 2100); +assertEquals("b", res[758].exec("abcd"), 2101); +assertEquals("abz", res[759].exec("abz"), 2102); +assertEquals("abb", res[759].exec("abbz"), 2103); +assertEquals("az", res[759].exec("azz "), 2104); +assertEquals("yz", res[760].exec("ayzq"), 2105); +assertEquals("xyz", res[760].exec("axyzq"), 2106); +assertEquals("xxyz", res[760].exec("axxyz"), 2107); +assertEquals("xxxyz", res[760].exec("axxxyzq"), 2108); +assertEquals("xxxyz", res[760].exec("axxxxyzq"), 2109); +assertEquals(null, res[760].exec("*** Failers", 2110)); +assertEquals(null, res[760].exec("ax", 2111)); +assertEquals(null, res[760].exec("axx ", 2112)); +assertEquals(null, res[760].exec(" ", 2113)); +assertEquals("xxxyz", res[761].exec("axxxyzq"), 2114); +assertEquals("xxxyz", res[761].exec("axxxxyzq"), 2115); +assertEquals(null, res[761].exec("*** Failers", 2116)); +assertEquals(null, res[761].exec("ax", 2117)); +assertEquals(null, res[761].exec("axx ", 2118)); +assertEquals(null, res[761].exec("ayzq", 2119)); +assertEquals(null, res[761].exec("axyzq", 2120)); +assertEquals(null, res[761].exec("axxyz", 2121)); +assertEquals(null, res[761].exec(" ", 2122)); +assertEquals("xxyz", res[762].exec("axxyz"), 2123); +assertEquals("xxxyz", res[762].exec("axxxyzq"), 2124); +assertEquals("xxxyz", res[762].exec("axxxxyzq"), 2125); +assertEquals(null, res[762].exec("*** Failers", 2126)); +assertEquals(null, res[762].exec("ax", 2127)); +assertEquals(null, res[762].exec("axx ", 2128)); +assertEquals(null, res[762].exec("ayzq", 2129)); +assertEquals(null, res[762].exec("axyzq", 2130)); +assertEquals(null, res[762].exec(" ", 2131)); +assertEquals("b", res[763].exec("bac"), 2132); +assertEquals("bcdef", res[763].exec("bcdefax"), 2133); +assertEquals("*** F", res[763].exec("*** Failers"), 2134); +assertEquals(" ", res[763].exec("aaaaa "), 2135); +assertEquals("b", res[764].exec("bac"), 2136); +assertEquals("bcdef", res[764].exec("bcdefax"), 2137); +assertEquals("*** F", res[764].exec("*** Failers"), 2138); +assertEquals("", res[764].exec("aaaaa "), 2139); +assertEquals("xyz", res[765].exec("xyz"), 2140); +assertEquals("wxyz", res[765].exec("awxyza"), 2141); +assertEquals("bcdef", res[765].exec("abcdefa"), 2142); +assertEquals("bcdef", res[765].exec("abcdefghijk"), 2143); +assertEquals("*** F", res[765].exec("*** Failers"), 2144); +assertEquals(null, res[765].exec("axya", 2145)); +assertEquals(null, res[765].exec("axa", 2146)); +assertEquals(" ", res[765].exec("aaaaa "), 2147); +assertEquals("1234", res[766].exec("1234b567"), 2148); +assertEquals("", res[766].exec("xyz"), 2149); +assertEquals("a", res[767].exec("a1234b567"), 2150); +assertEquals("xyz", res[767].exec("xyz"), 2151); +assertEquals(" ", res[767].exec(" "), 2152); +assertEquals("1234", res[768].exec("ab1234c56"), 2153); +assertEquals(null, res[768].exec("*** Failers", 2154)); +assertEquals(null, res[768].exec("xyz", 2155)); +assertEquals("ab", res[769].exec("ab123c56"), 2156); +assertEquals("*** Failers", res[769].exec("*** Failers"), 2157); +assertEquals(null, res[769].exec("789", 2158)); +assertEquals("5A", res[770].exec("045ABC"), 2159); +assertEquals("A", res[770].exec("ABC"), 2160); +assertEquals(null, res[770].exec("*** Failers", 2161)); +assertEquals(null, res[770].exec("XYZ", 2162)); +assertEquals("A", res[771].exec("ABC"), 2163); +assertEquals("BA", res[771].exec("BAC"), 2164); +assertEquals("A", res[771].exec("9ABC "), 2165); +assertEquals(null, res[771].exec("*** Failers", 2166)); +assertEquals("aaaa", res[772].exec("aaaa"), 2167); +assertEquals("xyz", res[773].exec("xyz"), 2168); +assertEquals("ggggggggxyz", res[773].exec("ggggggggxyz"), 2169); +assertEquals("abcdxyz", res[774].exec("abcdxyz"), 2170); +assertEquals("axyz", res[774].exec("axyz"), 2171); +assertEquals(null, res[774].exec("*** Failers", 2172)); +assertEquals(null, res[774].exec("xyz", 2173)); +assertEquals("xyz", res[775].exec("xyz"), 2174); +assertEquals("cxyz", res[775].exec("cxyz "), 2175); +assertEquals("12X", res[776].exec("12X"), 2176); +assertEquals("123X", res[776].exec("123X"), 2177); +assertEquals(null, res[776].exec("*** Failers", 2178)); +assertEquals(null, res[776].exec("X", 2179)); +assertEquals(null, res[776].exec("1X", 2180)); +assertEquals(null, res[776].exec("1234X ", 2181)); +assertEquals("a4", res[777].exec("a45"), 2182); +assertEquals("b9", res[777].exec("b93"), 2183); +assertEquals("c9", res[777].exec("c99z"), 2184); +assertEquals("d0", res[777].exec("d04"), 2185); +assertEquals(null, res[777].exec("*** Failers", 2186)); +assertEquals(null, res[777].exec("e45", 2187)); +assertEquals(null, res[777].exec("abcd ", 2188)); +assertEquals(null, res[777].exec("abcd1234", 2189)); +assertEquals(null, res[777].exec("1234 ", 2190)); +assertEquals("a4", res[778].exec("a45"), 2191); +assertEquals("b9", res[778].exec("b93"), 2192); +assertEquals("c9", res[778].exec("c99z"), 2193); +assertEquals("d0", res[778].exec("d04"), 2194); +assertEquals("abcd1", res[778].exec("abcd1234"), 2195); +assertEquals("1", res[778].exec("1234 "), 2196); +assertEquals(null, res[778].exec("*** Failers", 2197)); +assertEquals(null, res[778].exec("e45", 2198)); +assertEquals(null, res[778].exec("abcd ", 2199)); +assertEquals("a4", res[779].exec("a45"), 2200); +assertEquals("b9", res[779].exec("b93"), 2201); +assertEquals("c9", res[779].exec("c99z"), 2202); +assertEquals("d0", res[779].exec("d04"), 2203); +assertEquals("abcd1", res[779].exec("abcd1234"), 2204); +assertEquals(null, res[779].exec("*** Failers", 2205)); +assertEquals(null, res[779].exec("1234 ", 2206)); +assertEquals(null, res[779].exec("e45", 2207)); +assertEquals(null, res[779].exec("abcd ", 2208)); +assertEquals("aX", res[780].exec("aX"), 2209); +assertEquals("aaX", res[780].exec("aaX "), 2210); +assertEquals("a4", res[781].exec("a45"), 2211); +assertEquals("b9", res[781].exec("b93"), 2212); +assertEquals("c9", res[781].exec("c99z"), 2213); +assertEquals("d0", res[781].exec("d04"), 2214); +assertEquals("1", res[781].exec("1234 "), 2215); +assertEquals(null, res[781].exec("*** Failers", 2216)); +assertEquals(null, res[781].exec("abcd1234", 2217)); +assertEquals(null, res[781].exec("e45", 2218)); +assertEquals("ab4", res[782].exec("ab45"), 2219); +assertEquals("bcd9", res[782].exec("bcd93"), 2220); +assertEquals(null, res[782].exec("*** Failers", 2221)); +assertEquals(null, res[782].exec("1234 ", 2222)); +assertEquals(null, res[782].exec("a36 ", 2223)); +assertEquals(null, res[782].exec("abcd1234", 2224)); +assertEquals(null, res[782].exec("ee45", 2225)); +assertEquals("abc4,abc", res[783].exec("abc45"), 2226); +assertEquals("abcabcabc4,abc", res[783].exec("abcabcabc45"), 2227); +assertEquals("4,", res[783].exec("42xyz "), 2228); +assertEquals(null, res[783].exec("*** Failers", 2229)); +assertEquals("abc4,abc", res[784].exec("abc45"), 2230); +assertEquals("abcabcabc4,abc", res[784].exec("abcabcabc45"), 2231); +assertEquals(null, res[784].exec("*** Failers", 2232)); +assertEquals(null, res[784].exec("42xyz ", 2233)); +assertEquals("abc4,abc", res[785].exec("abc45"), 2234); +assertEquals("4,", res[785].exec("42xyz "), 2235); +assertEquals(null, res[785].exec("*** Failers", 2236)); +assertEquals(null, res[785].exec("abcabcabc45", 2237)); +assertEquals("abcabc4,abc", res[786].exec("abcabc45"), 2238); +assertEquals("abcabcabc4,abc", res[786].exec("abcabcabc45"), 2239); +assertEquals(null, res[786].exec("*** Failers", 2240)); +assertEquals(null, res[786].exec("abcabcabcabc45", 2241)); +assertEquals(null, res[786].exec("abc45", 2242)); +assertEquals(null, res[786].exec("42xyz ", 2243)); +assertEquals(null, res[786].exec("1abc2abc3456", 2244)); +assertEquals(null, res[786].exec("1abc2xyz3456 ", 2245)); +assertEquals("ab=ab,ab,ab", res[787].exec("ab=ab"), 2246); +assertEquals("ab=ab,ab,ab", res[787].exec("ab=ab"), 2247); +assertEquals(null, res[787].exec("abc", 2248)); +assertEquals(null, res[787].exec("a(b)c", 2249)); +assertEquals(null, res[787].exec("a(b(c))d ", 2250)); +assertEquals(null, res[787].exec("*** Failers)", 2251)); +assertEquals(null, res[787].exec("a(b(c)d ", 2252)); +assertEquals(null, res[787].exec(">abc>123abc>1(2)3abc>(1(2)3)", 2259)); +assertEquals(null, res[787].exec("", 2260)); +assertEquals(null, res[787].exec(" hij>", 2261)); +assertEquals(null, res[787].exec(" hij>", 2262)); +assertEquals(null, res[787].exec("def> ", 2263)); +assertEquals(null, res[787].exec(" ", 2264)); +assertEquals(null, res[787].exec("*** Failers", 2265)); +assertEquals(null, res[787].exec("3 ", 2323)); +assertEquals(null, res[795].exec("*** Failers ", 2324)); +assertEquals(null, res[795].exec("defabcxyz", 2325)); +assertEquals(null, res[796].exec("abP", 2326)); +assertEquals(null, res[796].exec("abcdeP", 2327)); +assertEquals("abcdef", res[796].exec("abcdefP"), 2328); +assertEquals(null, res[796].exec("*** Failers", 2329)); +assertEquals(null, res[796].exec("abxP ", 2330)); +assertEquals(null, res[797].exec("aP", 2331)); +assertEquals(null, res[797].exec("aaP", 2332)); +assertEquals(null, res[797].exec("aa2P ", 2333)); +assertEquals(null, res[797].exec("aaaP", 2334)); +assertEquals(null, res[797].exec("aaa23P ", 2335)); +assertEquals(null, res[797].exec("aaaa12345P", 2336)); +assertEquals("aa0z", res[797].exec("aa0zP"), 2337); +assertEquals("aaaa4444444444444z", res[797].exec("aaaa4444444444444zP "), 2338); +assertEquals(null, res[797].exec("*** Failers", 2339)); +assertEquals(null, res[797].exec("azP ", 2340)); +assertEquals(null, res[797].exec("aaaaaP ", 2341)); +assertEquals(null, res[797].exec("a56P ", 2342)); +assertEquals(null, res[799].exec("adfadadaklhlkalkajhlkjahdfasdfasdfladsfjkjPZ", 2343)); +assertEquals(null, res[799].exec("lkjhlkjhlkjhlkjhabbbbbbcdaefabbbbbbbefaPBZ", 2344)); +assertEquals(null, res[799].exec("cdabbbbbbbbPRBZ", 2345)); +assertEquals(null, res[799].exec("efabbbbbbbbbbbbbbbbPRBZ", 2346)); +assertEquals(null, res[799].exec("bbbbbbbbbbbbcdXyasdfadfPRBZ ", 2347)); +assertEquals(null, res[799].exec("abc", 2348)); +assertEquals(null, res[799].exec("** Failers", 2349)); +assertEquals(null, res[799].exec("def ", 2350)); +assertEquals("the quick brown fox", res[800].exec("the quick brown fox"), 2351); +assertEquals(null, res[800].exec("The quick brown FOX", 2352)); +assertEquals("the quick brown fox", res[800].exec("What do you know about the quick brown fox?"), 2353); +assertEquals(null, res[800].exec("What do you know about THE QUICK BROWN FOX?", 2354)); +assertEquals("the quick brown fox", res[801].exec("the quick brown fox"), 2355); +assertEquals("The quick brown FOX", res[801].exec("The quick brown FOX"), 2356); +assertEquals("the quick brown fox", res[801].exec("What do you know about the quick brown fox?"), 2357); +assertEquals("THE QUICK BROWN FOX", res[801].exec("What do you know about THE QUICK BROWN FOX?"), 2358); +assertEquals("abcd\x09\n\x0d\x0cae9;$\\?caxyz", res[802].exec("abcd\x09\n\x0d\x0cae9;$\\?caxyz"), 2359); +assertEquals("abxyzpqrrrabbxyyyypqAzz", res[803].exec("abxyzpqrrrabbxyyyypqAzz"), 2360); +assertEquals("abxyzpqrrrabbxyyyypqAzz", res[803].exec("abxyzpqrrrabbxyyyypqAzz"), 2361); +assertEquals("aabxyzpqrrrabbxyyyypqAzz", res[803].exec("aabxyzpqrrrabbxyyyypqAzz"), 2362); +assertEquals("aaabxyzpqrrrabbxyyyypqAzz", res[803].exec("aaabxyzpqrrrabbxyyyypqAzz"), 2363); +assertEquals("aaaabxyzpqrrrabbxyyyypqAzz", res[803].exec("aaaabxyzpqrrrabbxyyyypqAzz"), 2364); +assertEquals("abcxyzpqrrrabbxyyyypqAzz", res[803].exec("abcxyzpqrrrabbxyyyypqAzz"), 2365); +assertEquals("aabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aabcxyzpqrrrabbxyyyypqAzz"), 2366); +assertEquals("aaabcxyzpqrrrabbxyyyypAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypAzz"), 2367); +assertEquals("aaabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqAzz"), 2368); +assertEquals("aaabcxyzpqrrrabbxyyyypqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqAzz"), 2369); +assertEquals("aaabcxyzpqrrrabbxyyyypqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqAzz"), 2370); +assertEquals("aaabcxyzpqrrrabbxyyyypqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqAzz"), 2371); +assertEquals("aaabcxyzpqrrrabbxyyyypqqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqAzz"), 2372); +assertEquals("aaabcxyzpqrrrabbxyyyypqqqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqqAzz"), 2373); +assertEquals("aaaabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aaaabcxyzpqrrrabbxyyyypqAzz"), 2374); +assertEquals("abxyzzpqrrrabbxyyyypqAzz", res[803].exec("abxyzzpqrrrabbxyyyypqAzz"), 2375); +assertEquals("aabxyzzzpqrrrabbxyyyypqAzz", res[803].exec("aabxyzzzpqrrrabbxyyyypqAzz"), 2376); +assertEquals("aaabxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaabxyzzzzpqrrrabbxyyyypqAzz"), 2377); +assertEquals("aaaabxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaaabxyzzzzpqrrrabbxyyyypqAzz"), 2378); +assertEquals("abcxyzzpqrrrabbxyyyypqAzz", res[803].exec("abcxyzzpqrrrabbxyyyypqAzz"), 2379); +assertEquals("aabcxyzzzpqrrrabbxyyyypqAzz", res[803].exec("aabcxyzzzpqrrrabbxyyyypqAzz"), 2380); +assertEquals("aaabcxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaabcxyzzzzpqrrrabbxyyyypqAzz"), 2381); +assertEquals("aaaabcxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbxyyyypqAzz"), 2382); +assertEquals("aaaabcxyzzzzpqrrrabbbxyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyypqAzz"), 2383); +assertEquals("aaaabcxyzzzzpqrrrabbbxyyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyyypqAzz"), 2384); +assertEquals("aaabcxyzpqrrrabbxyyyypABzz", res[803].exec("aaabcxyzpqrrrabbxyyyypABzz"), 2385); +assertEquals("aaabcxyzpqrrrabbxyyyypABBzz", res[803].exec("aaabcxyzpqrrrabbxyyyypABBzz"), 2386); +assertEquals("aaabxyzpqrrrabbxyyyypqAzz", res[803].exec(">>>aaabxyzpqrrrabbxyyyypqAzz"), 2387); +assertEquals("aaaabxyzpqrrrabbxyyyypqAzz", res[803].exec(">aaaabxyzpqrrrabbxyyyypqAzz"), 2388); +assertEquals("abcxyzpqrrrabbxyyyypqAzz", res[803].exec(">>>>abcxyzpqrrrabbxyyyypqAzz"), 2389); +assertEquals(null, res[803].exec("*** Failers", 2390)); +assertEquals(null, res[803].exec("abxyzpqrrabbxyyyypqAzz", 2391)); +assertEquals(null, res[803].exec("abxyzpqrrrrabbxyyyypqAzz", 2392)); +assertEquals(null, res[803].exec("abxyzpqrrrabxyyyypqAzz", 2393)); +assertEquals(null, res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz", 2394)); +assertEquals(null, res[803].exec("aaaabcxyzzzzpqrrrabbbxyyypqAzz", 2395)); +assertEquals(null, res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqqqAzz", 2396)); +assertEquals("abczz,abc", res[804].exec("abczz"), 2397); +assertEquals("abcabczz,abc", res[804].exec("abcabczz"), 2398); +assertEquals(null, res[804].exec("*** Failers", 2399)); +assertEquals(null, res[804].exec("zz", 2400)); +assertEquals(null, res[804].exec("abcabcabczz", 2401)); +assertEquals(null, res[804].exec(">>abczz", 2402)); +assertEquals("bc,b", res[805].exec("bc"), 2403); +assertEquals("bbc,b", res[805].exec("bbc"), 2404); +assertEquals("bbbc,bb", res[805].exec("bbbc"), 2405); +assertEquals("bac,a", res[805].exec("bac"), 2406); +assertEquals("bbac,a", res[805].exec("bbac"), 2407); +assertEquals("aac,a", res[805].exec("aac"), 2408); +assertEquals("abbbbbbbbbbbc,bbbbbbbbbbb", res[805].exec("abbbbbbbbbbbc"), 2409); +assertEquals("bbbbbbbbbbbac,a", res[805].exec("bbbbbbbbbbbac"), 2410); +assertEquals(null, res[805].exec("*** Failers", 2411)); +assertEquals(null, res[805].exec("aaac", 2412)); +assertEquals(null, res[805].exec("abbbbbbbbbbbac", 2413)); +assertEquals("bc,b", res[806].exec("bc"), 2414); +assertEquals("bbc,bb", res[806].exec("bbc"), 2415); +assertEquals("bbbc,bbb", res[806].exec("bbbc"), 2416); +assertEquals("bac,a", res[806].exec("bac"), 2417); +assertEquals("bbac,a", res[806].exec("bbac"), 2418); +assertEquals("aac,a", res[806].exec("aac"), 2419); +assertEquals("abbbbbbbbbbbc,bbbbbbbbbbb", res[806].exec("abbbbbbbbbbbc"), 2420); +assertEquals("bbbbbbbbbbbac,a", res[806].exec("bbbbbbbbbbbac"), 2421); +assertEquals(null, res[806].exec("*** Failers", 2422)); +assertEquals(null, res[806].exec("aaac", 2423)); +assertEquals(null, res[806].exec("abbbbbbbbbbbac", 2424)); +assertEquals("bbc,bb", res[806].exec("bbc"), 2425); +assertEquals("babc,ba", res[807].exec("babc"), 2426); +assertEquals("bbabc,ba", res[807].exec("bbabc"), 2427); +assertEquals("bababc,ba", res[807].exec("bababc"), 2428); +assertEquals(null, res[807].exec("*** Failers", 2429)); +assertEquals(null, res[807].exec("bababbc", 2430)); +assertEquals(null, res[807].exec("babababc", 2431)); +assertEquals("babc,ba", res[808].exec("babc"), 2432); +assertEquals("bbabc,ba", res[808].exec("bbabc"), 2433); +assertEquals("bababc,ba", res[808].exec("bababc"), 2434); +assertEquals(null, res[808].exec("*** Failers", 2435)); +assertEquals(null, res[808].exec("bababbc", 2436)); +assertEquals(null, res[808].exec("babababc", 2437)); +assertThrows("var re = /^\\ca\\cA\\c[\\c{\\c:/;", 2438); +assertEquals(null, res[808].exec("\x01\x01e;z", 2439)); +assertEquals("a", res[809].exec("athing"), 2440); +assertEquals("b", res[809].exec("bthing"), 2441); +assertEquals("]", res[809].exec("]thing"), 2442); +assertEquals("c", res[809].exec("cthing"), 2443); +assertEquals("d", res[809].exec("dthing"), 2444); +assertEquals("e", res[809].exec("ething"), 2445); +assertEquals(null, res[809].exec("*** Failers", 2446)); +assertEquals(null, res[809].exec("fthing", 2447)); +assertEquals(null, res[809].exec("[thing", 2448)); +assertEquals(null, res[809].exec("\\thing", 2449)); +assertEquals(null, res[810].exec("]thing", 2450)); +assertEquals(null, res[810].exec("cthing", 2451)); +assertEquals(null, res[810].exec("dthing", 2452)); +assertEquals(null, res[810].exec("ething", 2453)); +assertEquals(null, res[810].exec("*** Failers", 2454)); +assertEquals(null, res[810].exec("athing", 2455)); +assertEquals(null, res[810].exec("fthing", 2456)); +assertEquals("f", res[811].exec("fthing"), 2457); +assertEquals("[", res[811].exec("[thing"), 2458); +assertEquals("\\", res[811].exec("\\thing"), 2459); +assertEquals("*", res[811].exec("*** Failers"), 2460); +assertEquals(null, res[811].exec("athing", 2461)); +assertEquals(null, res[811].exec("bthing", 2462)); +assertEquals(null, res[811].exec("]thing", 2463)); +assertEquals(null, res[811].exec("cthing", 2464)); +assertEquals(null, res[811].exec("dthing", 2465)); +assertEquals(null, res[811].exec("ething", 2466)); +assertEquals(null, res[812].exec("athing", 2467)); +assertEquals(null, res[812].exec("fthing", 2468)); +assertEquals(null, res[812].exec("*** Failers", 2469)); +assertEquals(null, res[812].exec("]thing", 2470)); +assertEquals(null, res[812].exec("cthing", 2471)); +assertEquals(null, res[812].exec("dthing", 2472)); +assertEquals(null, res[812].exec("ething", 2473)); +assertEquals(null, res[812].exec("\ufffd", 2474)); +assertEquals(null, res[812].exec("\ufffd", 2475)); +assertEquals("0", res[813].exec("0"), 2476); +assertEquals("1", res[813].exec("1"), 2477); +assertEquals("2", res[813].exec("2"), 2478); +assertEquals("3", res[813].exec("3"), 2479); +assertEquals("4", res[813].exec("4"), 2480); +assertEquals("5", res[813].exec("5"), 2481); +assertEquals("6", res[813].exec("6"), 2482); +assertEquals("7", res[813].exec("7"), 2483); +assertEquals("8", res[813].exec("8"), 2484); +assertEquals("9", res[813].exec("9"), 2485); +assertEquals("10", res[813].exec("10"), 2486); +assertEquals("100", res[813].exec("100"), 2487); +assertEquals(null, res[813].exec("*** Failers", 2488)); +assertEquals(null, res[813].exec("abc", 2489)); +assertEquals("enter", res[814].exec("enter"), 2490); +assertEquals("inter", res[814].exec("inter"), 2491); +assertEquals("uponter", res[814].exec("uponter"), 2492); +assertEquals("xxx0", res[815].exec("xxx0"), 2493); +assertEquals("xxx1234", res[815].exec("xxx1234"), 2494); +assertEquals(null, res[815].exec("*** Failers", 2495)); +assertEquals(null, res[815].exec("xxx", 2496)); +assertEquals("x123", res[816].exec("x123"), 2497); +assertEquals("xx123", res[816].exec("xx123"), 2498); +assertEquals("123456", res[816].exec("123456"), 2499); +assertEquals(null, res[816].exec("*** Failers", 2500)); +assertEquals(null, res[816].exec("123", 2501)); +assertEquals("x1234", res[816].exec("x1234"), 2502); +assertEquals("x123", res[817].exec("x123"), 2503); +assertEquals("xx123", res[817].exec("xx123"), 2504); +assertEquals("123456", res[817].exec("123456"), 2505); +assertEquals(null, res[817].exec("*** Failers", 2506)); +assertEquals(null, res[817].exec("123", 2507)); +assertEquals("x1234", res[817].exec("x1234"), 2508); +assertEquals("abc!pqr=apquxz.ixr.zzz.ac.uk,abc,pqr", res[818].exec("abc!pqr=apquxz.ixr.zzz.ac.uk"), 2509); +assertEquals(null, res[818].exec("*** Failers", 2510)); +assertEquals(null, res[818].exec("!pqr=apquxz.ixr.zzz.ac.uk", 2511)); +assertEquals(null, res[818].exec("abc!=apquxz.ixr.zzz.ac.uk", 2512)); +assertEquals(null, res[818].exec("abc!pqr=apquxz:ixr.zzz.ac.uk", 2513)); +assertEquals(null, res[818].exec("abc!pqr=apquxz.ixr.zzz.ac.ukk", 2514)); +assertEquals(":", res[819].exec("Well, we need a colon: somewhere"), 2515); +assertEquals(null, res[819].exec("*** Fail if we don't", 2516)); +assertEquals("0abc,0abc", res[820].exec("0abc"), 2517); +assertEquals("abc,abc", res[820].exec("abc"), 2518); +assertEquals("fed,fed", res[820].exec("fed"), 2519); +assertEquals("E,E", res[820].exec("E"), 2520); +assertEquals("::,::", res[820].exec("::"), 2521); +assertEquals("5f03:12C0::932e,5f03:12C0::932e", res[820].exec("5f03:12C0::932e"), 2522); +assertEquals("def,def", res[820].exec("fed def"), 2523); +assertEquals("ff,ff", res[820].exec("Any old stuff"), 2524); +assertEquals(null, res[820].exec("*** Failers", 2525)); +assertEquals(null, res[820].exec("0zzz", 2526)); +assertEquals(null, res[820].exec("gzzz", 2527)); +assertEquals(null, res[820].exec("fed ", 2528)); +assertEquals(null, res[820].exec("Any old rubbish", 2529)); +assertEquals(".1.2.3,1,2,3", res[821].exec(".1.2.3"), 2530); +assertEquals("A.12.123.0,12,123,0", res[821].exec("A.12.123.0"), 2531); +assertEquals(null, res[821].exec("*** Failers", 2532)); +assertEquals(null, res[821].exec(".1.2.3333", 2533)); +assertEquals(null, res[821].exec("1.2.3", 2534)); +assertEquals(null, res[821].exec("1234.2.3", 2535)); +assertEquals("1 IN SOA non-sp1 non-sp2(,1,non-sp1,non-sp2", res[822].exec("1 IN SOA non-sp1 non-sp2("), 2536); +assertEquals("1 IN SOA non-sp1 non-sp2 (,1,non-sp1,non-sp2", res[822].exec("1 IN SOA non-sp1 non-sp2 ("), 2537); +assertEquals(null, res[822].exec("*** Failers", 2538)); +assertEquals(null, res[822].exec("1IN SOA non-sp1 non-sp2(", 2539)); +assertEquals("a.,", res[823].exec("a."), 2540); +assertEquals("Z.,", res[823].exec("Z."), 2541); +assertEquals("2.,", res[823].exec("2."), 2542); +assertEquals("ab-c.pq-r.,.pq-r", res[823].exec("ab-c.pq-r."), 2543); +assertEquals("sxk.zzz.ac.uk.,.uk", res[823].exec("sxk.zzz.ac.uk."), 2544); +assertEquals("x-.y-.,.y-", res[823].exec("x-.y-."), 2545); +assertEquals(null, res[823].exec("*** Failers", 2546)); +assertEquals(null, res[823].exec("-abc.peq.", 2547)); +assertEquals("*.a,,,", res[824].exec("*.a"), 2548); +assertEquals("*.b0-a,0-a,,", res[824].exec("*.b0-a"), 2549); +assertEquals("*.c3-b.c,3-b,.c,", res[824].exec("*.c3-b.c"), 2550); +assertEquals("*.c-a.b-c,-a,.b-c,-c", res[824].exec("*.c-a.b-c"), 2551); +assertEquals(null, res[824].exec("*** Failers", 2552)); +assertEquals(null, res[824].exec("*.0", 2553)); +assertEquals(null, res[824].exec("*.a-", 2554)); +assertEquals(null, res[824].exec("*.a-b.c-", 2555)); +assertEquals(null, res[824].exec("*.c-a.0-c", 2556)); +assertEquals("abde,de,abd,e", res[825].exec("abde"), 2557); +assertEquals("abdf,,abd,f", res[826].exec("abdf"), 2558); +assertEquals("ab,abcd,cd,ab", res[827].exec("abcd"), 2559); +assertEquals("a.b.c.d,.d", res[828].exec("a.b.c.d"), 2560); +assertEquals("A.B.C.D,.D", res[828].exec("A.B.C.D"), 2561); +assertEquals("a.b.c.1.2.3.C,.C", res[828].exec("a.b.c.1.2.3.C"), 2562); +assertEquals("\"1234\",", res[829].exec("\"1234\""), 2563); +assertEquals("\"abcd\" ;,;", res[829].exec("\"abcd\" ;"), 2564); +assertEquals("\"\" ; rhubarb,; rhubarb", res[829].exec("\"\" ; rhubarb"), 2565); +assertEquals(null, res[829].exec("*** Failers", 2566)); +assertEquals(null, res[829].exec("\"1234\" : things", 2567)); +assertEquals(null, res[830].exec("\\", 2568)); +assertEquals(null, res[830].exec("*** Failers", 2569)); +assertEquals("ab c", res[831].exec("ab c"), 2570); +assertEquals(null, res[831].exec("*** Failers", 2571)); +assertEquals(null, res[831].exec("abc", 2572)); +assertEquals(null, res[831].exec("ab cde", 2573)); +assertEquals("ab c", res[831].exec("ab c"), 2574); +assertEquals(null, res[831].exec("*** Failers", 2575)); +assertEquals(null, res[831].exec("abc", 2576)); +assertEquals(null, res[831].exec("ab cde", 2577)); +assertEquals("a bcd", res[832].exec("a bcd"), 2578); +assertEquals(null, res[832].exec("a b d", 2579)); +assertEquals(null, res[832].exec("*** Failers", 2580)); +assertEquals(null, res[832].exec("abcd", 2581)); +assertEquals(null, res[832].exec("ab d", 2582)); +assertEquals("abcdefhijklm,abc,bc,c,def,ef,f,hij,ij,j,klm,lm,m", res[833].exec("abcdefhijklm"), 2583); +assertEquals("abcdefhijklm,bc,c,ef,f,ij,j,lm,m", res[834].exec("abcdefhijklm"), 2584); +assertEquals(null, res[835].exec("a+ Z0+\x08\n\x1d\x12", 2585)); +assertEquals(null, res[835].exec(".^$(*+)|{?,?}", 2586)); +assertEquals("z", res[836].exec("z"), 2587); +assertEquals("az", res[836].exec("az"), 2588); +assertEquals("aaaz", res[836].exec("aaaz"), 2589); +assertEquals("a", res[836].exec("a"), 2590); +assertEquals("aa", res[836].exec("aa"), 2591); +assertEquals("aaaa", res[836].exec("aaaa"), 2592); +assertEquals("a", res[836].exec("a+"), 2593); +assertEquals("aa", res[836].exec("aa+"), 2594); +assertEquals("z", res[837].exec("z"), 2595); +assertEquals("a", res[837].exec("az"), 2596); +assertEquals("a", res[837].exec("aaaz"), 2597); +assertEquals("a", res[837].exec("a"), 2598); +assertEquals("a", res[837].exec("aa"), 2599); +assertEquals("a", res[837].exec("aaaa"), 2600); +assertEquals("a", res[837].exec("a+"), 2601); +assertEquals("a", res[837].exec("aa+"), 2602); +assertEquals("az", res[838].exec("az"), 2603); +assertEquals("aaaz", res[838].exec("aaaz"), 2604); +assertEquals("aa", res[838].exec("aa"), 2605); +assertEquals("aaaa", res[838].exec("aaaa"), 2606); +assertEquals("aa", res[838].exec("aa+"), 2607); +assertEquals("az", res[839].exec("az"), 2608); +assertEquals("aa", res[839].exec("aaaz"), 2609); +assertEquals("aa", res[839].exec("aa"), 2610); +assertEquals("aa", res[839].exec("aaaa"), 2611); +assertEquals("aa", res[839].exec("aa+"), 2612); +assertEquals("1234567890", res[840].exec("1234567890"), 2613); +assertEquals("12345678ab", res[840].exec("12345678ab"), 2614); +assertEquals("12345678__", res[840].exec("12345678__"), 2615); +assertEquals(null, res[840].exec("*** Failers", 2616)); +assertEquals(null, res[840].exec("1234567", 2617)); +assertEquals("uoie", res[841].exec("uoie"), 2618); +assertEquals("1234", res[841].exec("1234"), 2619); +assertEquals("12345", res[841].exec("12345"), 2620); +assertEquals("aaaaa", res[841].exec("aaaaa"), 2621); +assertEquals(null, res[841].exec("*** Failers", 2622)); +assertEquals(null, res[841].exec("123456", 2623)); +assertEquals("uoie", res[842].exec("uoie"), 2624); +assertEquals("1234", res[842].exec("1234"), 2625); +assertEquals("1234", res[842].exec("12345"), 2626); +assertEquals("aaaa", res[842].exec("aaaaa"), 2627); +assertEquals("1234", res[842].exec("123456"), 2628); +assertEquals("From abcd Mon Sep 01 12:33,abcd", res[843].exec("From abcd Mon Sep 01 12:33:02 1997"), 2629); +assertEquals("From abcd Mon Sep 01 12:33,Sep ", res[844].exec("From abcd Mon Sep 01 12:33:02 1997"), 2630); +assertEquals("From abcd Mon Sep 1 12:33,Sep ", res[844].exec("From abcd Mon Sep 1 12:33:02 1997"), 2631); +assertEquals(null, res[844].exec("*** Failers", 2632)); +assertEquals(null, res[844].exec("From abcd Sep 01 12:33:02 1997", 2633)); +assertEquals(null, res[845].exec("12\n34", 2634)); +assertEquals(null, res[845].exec("12\x0d34", 2635)); +assertEquals("brown", res[846].exec("the quick brown\x09 fox"), 2636); +assertEquals("foolish see?,lish see?", res[847].exec("foobar is foolish see?"), 2637); +assertEquals("rowbar etc, etc", res[848].exec("foobar crowbar etc"), 2638); +assertEquals("barrel,rel", res[848].exec("barrel"), 2639); +assertEquals("2barrel,rel", res[848].exec("2barrel"), 2640); +assertEquals("A barrel,rel", res[848].exec("A barrel"), 2641); +assertEquals("abc,abc", res[849].exec("abc456"), 2642); +assertEquals(null, res[849].exec("*** Failers", 2643)); +assertEquals(null, res[849].exec("abc123", 2644)); +assertEquals("1234", res[850].exec("1234"), 2645); +assertEquals("1234", res[851].exec("1234"), 2646); +assertEquals("abcd", res[852].exec("abcd"), 2647); +assertEquals("abcd", res[853].exec("abcd"), 2648); +assertEquals("abc", res[854].exec("the abc"), 2649); +assertEquals(null, res[854].exec("*** Failers", 2650)); +assertEquals(null, res[854].exec("abc", 2651)); +assertEquals("abc", res[855].exec("abc"), 2652); +assertEquals(null, res[855].exec("*** Failers", 2653)); +assertEquals(null, res[855].exec("the abc", 2654)); +assertEquals("aabb,b", res[856].exec("aabbbbb"), 2655); +assertEquals("aabbbbb,abbbbb", res[857].exec("aabbbbb"), 2656); +assertEquals("aa,a", res[858].exec("aabbbbb"), 2657); +assertEquals("aabb,b", res[859].exec("aabbbbb"), 2658); +assertEquals("Alan Other ", res[860].exec("Alan Other "), 2659); +assertEquals("user@dom.ain", res[860].exec(""), 2660); +assertEquals("user@dom.ain", res[860].exec("user@dom.ain"), 2661); +assertEquals("\"A. Other\" (a comment)", res[860].exec("\"A. Other\" (a comment)"), 2662); +assertEquals(" Other (a comment)", res[860].exec("A. Other (a comment)"), 2663); +assertEquals("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay", res[860].exec("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"), 2664); +assertEquals("user@some.where", res[860].exec("A missing angle ", res[861].exec("Alan Other "), 2668); +assertEquals("user@dom.ain", res[861].exec(""), 2669); +assertEquals("user@dom.ain", res[861].exec("user@dom.ain"), 2670); +assertEquals("\"A. Other\" ", res[861].exec("\"A. Other\" (a comment)"), 2671); +assertEquals(" Other ", res[861].exec("A. Other (a comment)"), 2672); +assertEquals("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay", res[861].exec("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"), 2673); +assertEquals("user@some.where", res[861].exec("A missing angle \x09\n\x0c\x0d\x0b<", 3716)); +assertEquals(null, res[1271].exec(" ", 3717)); +assertEquals(null, res[1272].exec("> \x09\n\x0c\x0d\x0b<", 3718)); +assertEquals(null, res[1272].exec(" ", 3719)); +assertEquals(" \x09\n\x0c\x0d\x0b", res[1273].exec("> \x09\n\x0c\x0d\x0b<"), 3720); +assertEquals(" ", res[1273].exec(" "), 3721); +assertEquals(" \x09\n\x0c\x0d\x0b", res[1274].exec("> \x09\n\x0c\x0d\x0b<"), 3722); +assertEquals(" ", res[1274].exec(" "), 3723); +assertEquals(null, res[1275].exec("ab", 3724)); +assertEquals(null, res[1278].exec("abcabcabc", 3725)); +assertEquals(null, res[1278].exec("abc(*+|abc ", 3726)); +assertEquals(null, res[1279].exec("abc abcabc", 3727)); +assertEquals(null, res[1279].exec("*** Failers", 3728)); +assertEquals(null, res[1279].exec("abcabcabc ", 3729)); +assertEquals(null, res[1280].exec("abc#not comment\n literal ", 3730)); +assertEquals(null, res[1281].exec("abc#not comment\n literal ", 3731)); +assertEquals(null, res[1282].exec("abc#not comment\n literal ", 3732)); +assertEquals(null, res[1283].exec("abc#not comment\n literal ", 3733)); +assertEquals(null, res[1284].exec("abc\\$xyz", 3734)); +assertEquals(null, res[1285].exec("abc$xyz", 3735)); +assertEquals(null, res[1286].exec("abc", 3736)); +assertEquals(null, res[1286].exec("*** Failers", 3737)); +assertEquals(null, res[1286].exec("xyzabc ", 3738)); +assertEquals(null, res[1287].exec("abc1abc2xyzabc3", 3739)); +assertEquals("abc1", res[1288].exec("abc1abc2xyzabc3 "), 3740); +assertEquals(null, res[1288].exec("XabcdY", 3741)); +assertEquals(null, res[1288].exec("*** Failers ", 3742)); +assertEquals(null, res[1288].exec("Xa b c d Y ", 3743)); +assertEquals("abcY", res[1288].exec("XabcY"), 3744); +assertEquals(null, res[1288].exec("AxyzB ", 3745)); +assertEquals(null, res[1288].exec("XabCY", 3746)); +assertEquals(null, res[1288].exec("*** Failers", 3747)); +assertEquals("abcY", res[1288].exec("XabcY "), 3748); +assertEquals(null, res[1288].exec("abCE", 3749)); +assertEquals(null, res[1288].exec("DE", 3750)); +assertEquals(null, res[1288].exec("*** Failers", 3751)); +assertEquals("abcE", res[1288].exec("abcE"), 3752); +assertEquals(null, res[1288].exec("abCe ", 3753)); +assertEquals(null, res[1288].exec("dE", 3754)); +assertEquals(null, res[1288].exec("De ", 3755)); +assertEquals(null, res[1289].exec("z", 3756)); +assertEquals(null, res[1289].exec("a", 3757)); +assertEquals(null, res[1289].exec("-", 3758)); +assertEquals(null, res[1289].exec("d", 3759)); +assertEquals(null, res[1289].exec("] ", 3760)); +assertEquals(null, res[1289].exec("*** Failers", 3761)); +assertEquals(null, res[1289].exec("b ", 3762)); +assertEquals("z", res[1290].exec("z"), 3763); +assertEquals("C", res[1290].exec("C "), 3764); +assertEquals("M", res[1291].exec("M "), 3765); +assertEquals(null, res[1292].exec("", 3766)); +assertEquals(null, res[1292].exec("REGular", 3767)); +assertEquals(null, res[1292].exec("regulaer", 3768)); +assertEquals(null, res[1292].exec("Regex ", 3769)); +assertEquals(null, res[1292].exec("regul\ufffdr ", 3770)); +assertEquals(null, res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3771)); +assertEquals(null, res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3772)); +assertEquals(null, res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3773)); +assertEquals(null, res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3774)); +assertEquals(null, res[1292].exec("\x84XAZXB", 3775)); +assertEquals(null, res[1292].exec("123a", 3776)); +assertEquals(null, res[1292].exec("ac", 3777)); +assertEquals("b,", res[1292].exec("bbbbc"), 3778); +assertEquals("ab,a", res[1292].exec("abc"), 3779); +assertEquals(null, res[1292].exec("*** Failers", 3780)); +assertEquals("b,", res[1292].exec("bca"), 3781); +assertEquals(null, res[1292].exec("", 3782)); +assertEquals("ab,a", res[1292].exec("abc"), 3783); +assertEquals(null, res[1292].exec("*** Failers", 3784)); +assertEquals("b,", res[1292].exec("bca"), 3785); +assertEquals("ab,a", res[1292].exec("abc"), 3786); +assertEquals(null, res[1292].exec("*** Failers", 3787)); +assertEquals(null, res[1292].exec("def ", 3788)); +assertEquals(null, res[1292].exec("", 3789)); +assertEquals("ab,a", res[1292].exec("abc"), 3790); +assertEquals(null, res[1292].exec("*** Failers", 3791)); +assertEquals(null, res[1292].exec("def ", 3792)); +assertEquals(null, res[1292].exec("", 3793)); +assertEquals("line\nbreak", res[1293].exec("this is a line\nbreak"), 3794); +assertEquals("line\nbreak", res[1293].exec("line one\nthis is a line\nbreak in the second line "), 3795); +assertEquals("line\nbreak", res[1294].exec("this is a line\nbreak"), 3796); +assertEquals(null, res[1294].exec("** Failers ", 3797)); +assertEquals("line\nbreak", res[1294].exec("line one\nthis is a line\nbreak in the second line "), 3798); +assertEquals("line\nbreak", res[1295].exec("this is a line\nbreak"), 3799); +assertEquals(null, res[1295].exec("** Failers ", 3800)); +assertEquals("line\nbreak", res[1295].exec("line one\nthis is a line\nbreak in the second line "), 3801); +assertEquals(null, res[1296].exec("123P", 3802)); +assertEquals(null, res[1296].exec("a4PR", 3803)); +assertEquals(null, res[1297].exec("123P", 3804)); +assertEquals(null, res[1297].exec("4PR", 3805)); +assertEquals("", res[1298].exec("a\nb\nc\n"), 3806); +assertEquals("", res[1298].exec(" "), 3807); +assertEquals("", res[1298].exec("A\nC\nC\n "), 3808); +assertEquals("", res[1298].exec("AB"), 3809); +assertEquals("", res[1298].exec("aB "), 3810); +assertEquals("", res[1298].exec("AB"), 3811); +assertEquals("", res[1298].exec("aB "), 3812); +assertEquals("", res[1298].exec("AB"), 3813); +assertEquals("", res[1298].exec("aB "), 3814); +assertEquals("", res[1298].exec("AB"), 3815); +assertEquals("", res[1298].exec("aB "), 3816); +assertEquals("Content-Type:xxxxxyyy ", res[1299].exec("Content-Type:xxxxxyyy "), 3817); +assertEquals("Content-Type:xxxxxyyyz", res[1300].exec("Content-Type:xxxxxyyyz"), 3818); +assertEquals("Content-Type:xxxyyy ", res[1301].exec("Content-Type:xxxyyy "), 3819); +assertEquals("Content-Type:xxxyyyz", res[1302].exec("Content-Type:xxxyyyz"), 3820); +assertEquals("abc", res[1303].exec("xyz\nabc"), 3821); +assertEquals("abc", res[1303].exec("xyz\nabc"), 3822); +assertEquals("abc", res[1303].exec("xyz\x0d\nabc"), 3823); +assertEquals("abc", res[1303].exec("xyz\x0dabc"), 3824); +assertEquals("abc", res[1303].exec("xyz\x0d\nabc"), 3825); +assertEquals(null, res[1303].exec("** Failers ", 3826)); +assertEquals("abc", res[1303].exec("xyz\nabc"), 3827); +assertEquals("abc", res[1303].exec("xyz\x0d\nabc"), 3828); +assertEquals("abc", res[1303].exec("xyz\nabc"), 3829); +assertEquals("abc", res[1303].exec("xyz\x0dabc"), 3830); +assertEquals("abc", res[1303].exec("xyz\x0dabc"), 3831); +assertEquals("abc", res[1304].exec("xyzabc"), 3832); +assertEquals("abc", res[1304].exec("xyzabc\n "), 3833); +assertEquals("abc", res[1304].exec("xyzabc\npqr "), 3834); +assertEquals("abc", res[1304].exec("xyzabc\x0d "), 3835); +assertEquals("abc", res[1304].exec("xyzabc\x0dpqr "), 3836); +assertEquals("abc", res[1304].exec("xyzabc\x0d\n "), 3837); +assertEquals("abc", res[1304].exec("xyzabc\x0d\npqr "), 3838); +assertEquals(null, res[1304].exec("** Failers", 3839)); +assertEquals("abc", res[1304].exec("xyzabc\x0d "), 3840); +assertEquals("abc", res[1304].exec("xyzabc\x0dpqr "), 3841); +assertEquals("abc", res[1304].exec("xyzabc\x0d\n "), 3842); +assertEquals("abc", res[1304].exec("xyzabc\x0d\npqr "), 3843); +assertEquals("abc", res[1305].exec("xyz\x0dabcdef"), 3844); +assertEquals("abc", res[1305].exec("xyz\nabcdef"), 3845); +assertEquals(null, res[1305].exec("** Failers ", 3846)); +assertEquals("abc", res[1305].exec("xyz\nabcdef"), 3847); +assertEquals(null, res[1305].exec(" ", 3848)); +assertEquals("abc", res[1306].exec("xyz\nabcdef"), 3849); +assertEquals("abc", res[1306].exec("xyz\x0dabcdef"), 3850); +assertEquals(null, res[1306].exec("** Failers ", 3851)); +assertEquals("abc", res[1306].exec("xyz\x0dabcdef"), 3852); +assertEquals(null, res[1306].exec(" ", 3853)); +assertEquals("abc", res[1307].exec("xyz\x0d\nabcdef"), 3854); +assertEquals("abc", res[1307].exec("xyz\x0dabcdef"), 3855); +assertEquals(null, res[1307].exec("** Failers ", 3856)); +assertEquals("abc", res[1307].exec("xyz\x0dabcdef"), 3857); +assertEquals("abc", res[1308].exec("abc\ndef"), 3858); +assertEquals("abc", res[1308].exec("abc\x0ddef"), 3859); +assertEquals("abc", res[1308].exec("abc\x0d\ndef"), 3860); +assertEquals("abc", res[1308].exec("abc\ndef"), 3861); +assertEquals("abc", res[1308].exec("abc\x0ddef"), 3862); +assertEquals("abc", res[1308].exec("abc\x0d\ndef"), 3863); +assertEquals("abc", res[1308].exec("abc\ndef"), 3864); +assertEquals("abc", res[1308].exec("abc\x0ddef"), 3865); +assertEquals("abc", res[1308].exec("abc\x0d\ndef"), 3866); +assertEquals(null, res[1309].exec("abc\ndef", 3867)); +assertEquals(null, res[1309].exec("abc\x0ddef", 3868)); +assertEquals(null, res[1309].exec("abc\x0d\ndef", 3869)); +assertEquals("abc=xyz\\,", res[1310].exec("abc=xyz\\\npqr"), 3870); +assertEquals("aaaa,a,", res[1311].exec("aaaa"), 3871); +assertEquals("aaaa", res[1312].exec("aaaa"), 3872); +assertEquals("aaaa,a,", res[1313].exec("aaaa"), 3873); +assertEquals("aaaa", res[1314].exec("aaaa"), 3874); +assertEquals(null, res[1317].exec("a\x0db", 3875)); +assertEquals(null, res[1317].exec("a\nb ", 3876)); +assertEquals(null, res[1317].exec("** Failers", 3877)); +assertEquals(null, res[1317].exec("a\nb", 3878)); +assertEquals(null, res[1317].exec("a\nb", 3879)); +assertEquals(null, res[1317].exec("a\x0db ", 3880)); +assertEquals(null, res[1317].exec("a\x0db ", 3881)); +assertEquals("abc1", res[1318].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 \x85abc7 JUNK"), 3882); +assertEquals("abc1", res[1319].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc9"), 3883); +assertEquals(null, res[1320].exec("a\nb", 3884)); +assertEquals(null, res[1320].exec("a\x0db", 3885)); +assertEquals(null, res[1320].exec("a\x0d\nb", 3886)); +assertEquals(null, res[1320].exec("a\x0bb", 3887)); +assertEquals(null, res[1320].exec("a\x0cb", 3888)); +assertEquals(null, res[1320].exec("a\x85b ", 3889)); +assertEquals(null, res[1320].exec("** Failers", 3890)); +assertEquals(null, res[1320].exec("a\n\x0db ", 3891)); +assertEquals("ab", res[1321].exec("ab"), 3892); +assertEquals(null, res[1321].exec("a\nb", 3893)); +assertEquals(null, res[1321].exec("a\x0db", 3894)); +assertEquals(null, res[1321].exec("a\x0d\nb", 3895)); +assertEquals(null, res[1321].exec("a\x0bb", 3896)); +assertEquals(null, res[1321].exec("a\x0cb", 3897)); +assertEquals(null, res[1321].exec("a\x85b ", 3898)); +assertEquals(null, res[1321].exec("a\n\x0db ", 3899)); +assertEquals(null, res[1321].exec("a\n\x0d\x85\x0cb ", 3900)); +assertEquals(null, res[1322].exec("a\nb", 3901)); +assertEquals(null, res[1322].exec("a\x0db", 3902)); +assertEquals(null, res[1322].exec("a\x0d\nb", 3903)); +assertEquals(null, res[1322].exec("a\x0bb", 3904)); +assertEquals(null, res[1322].exec("a\x0cb", 3905)); +assertEquals(null, res[1322].exec("a\x85b ", 3906)); +assertEquals(null, res[1322].exec("a\n\x0db ", 3907)); +assertEquals(null, res[1322].exec("a\n\x0d\x85\x0cb ", 3908)); +assertEquals(null, res[1322].exec("** Failers", 3909)); +assertEquals(null, res[1322].exec("ab ", 3910)); +assertEquals(null, res[1323].exec("a\nb", 3911)); +assertEquals(null, res[1323].exec("a\n\x0db", 3912)); +assertEquals(null, res[1323].exec("a\n\x0d\x85b", 3913)); +assertEquals(null, res[1323].exec("a\x0d\n\x0d\nb ", 3914)); +assertEquals(null, res[1323].exec("a\x0d\n\x0d\n\x0d\nb ", 3915)); +assertEquals(null, res[1323].exec("a\n\x0d\n\x0db", 3916)); +assertEquals(null, res[1323].exec("a\n\n\x0d\nb ", 3917)); +assertEquals(null, res[1323].exec("** Failers", 3918)); +assertEquals(null, res[1323].exec("a\n\n\n\x0db", 3919)); +assertEquals(null, res[1323].exec("a\x0d", 3920)); +assertEquals("aRb", res[1324].exec("aRb"), 3921); +assertEquals(null, res[1324].exec("** Failers", 3922)); +assertEquals(null, res[1324].exec("a\nb ", 3923)); +assertEquals("afoo", res[1325].exec("afoo"), 3924); +assertEquals(null, res[1325].exec("** Failers ", 3925)); +assertEquals(null, res[1325].exec("\x0d\nfoo ", 3926)); +assertEquals(null, res[1325].exec("\nfoo ", 3927)); +assertEquals("afoo", res[1326].exec("afoo"), 3928); +assertEquals(null, res[1326].exec("\nfoo ", 3929)); +assertEquals(null, res[1326].exec("** Failers ", 3930)); +assertEquals(null, res[1326].exec("\x0d\nfoo ", 3931)); +assertEquals("afoo", res[1327].exec("afoo"), 3932); +assertEquals(null, res[1327].exec("** Failers ", 3933)); +assertEquals(null, res[1327].exec("\nfoo ", 3934)); +assertEquals(null, res[1327].exec("\x0d\nfoo ", 3935)); +assertEquals("afoo", res[1328].exec("afoo"), 3936); +assertEquals(null, res[1328].exec("\x0d\nfoo ", 3937)); +assertEquals(null, res[1328].exec("\nfoo ", 3938)); +assertEquals("", res[1329].exec("abc\x0d\x0dxyz"), 3939); +assertEquals("", res[1329].exec("abc\n\x0dxyz "), 3940); +assertEquals(null, res[1329].exec("** Failers ", 3941)); +assertEquals("", res[1329].exec("abc\x0d\nxyz"), 3942); +assertEquals("X", res[1330].exec("XABC"), 3943); +assertEquals(null, res[1330].exec("** Failers ", 3944)); +assertEquals("X", res[1330].exec("XABCB"), 3945); +assertEquals(null, res[1330].exec("abc\x0d\n\x0d\n", 3946)); +assertEquals(null, res[1330].exec("abc\x0d\n\x0d\n", 3947)); +assertEquals(null, res[1330].exec("abc\x0d\n\x0d\n", 3948)); +assertThrows("var re = /(?|(abc)|(xyz))/;", 3949); +assertThrows("var re = /(x)(?|(abc)|(xyz))(x)/;", 3950); +assertEquals(null, res[1330].exec("xabcx", 3951)); +assertEquals(null, res[1330].exec("xxyzx ", 3952)); +assertThrows("var re = /(x)(?|(abc)(pqr)|(xyz))(x)/;", 3953); +assertEquals(null, res[1330].exec("xabcpqrx", 3954)); +assertEquals(null, res[1330].exec("xxyzx ", 3955)); +assertEquals(null, res[1330].exec("abcabc", 3956)); +assertEquals(null, res[1330].exec("xyzabc ", 3957)); +assertEquals(null, res[1330].exec("** Failers ", 3958)); +assertEquals(null, res[1330].exec("xyzxyz ", 3959)); +assertEquals(null, res[1331].exec("X X\n", 3960)); +assertEquals(null, res[1331].exec("X\x09X\x0b", 3961)); +assertEquals(null, res[1331].exec("** Failers", 3962)); +assertEquals(null, res[1331].exec("\xa0 X\n ", 3963)); +assertEquals(null, res[1332].exec("\x09 \xa0X\n\x0b\x0c\x0d\n", 3964)); +assertEquals(null, res[1332].exec("\x09 \xa0\n\x0b\x0c\x0d\n", 3965)); +assertEquals(null, res[1332].exec("\x09 \xa0\n\x0b\x0c", 3966)); +assertEquals(null, res[1332].exec("** Failers ", 3967)); +assertEquals(null, res[1332].exec("\x09 \xa0\n\x0b", 3968)); +assertEquals(null, res[1332].exec(" ", 3969)); +assertEquals(null, res[1333].exec("XY ABCDE", 3970)); +assertEquals(null, res[1333].exec("XY PQR ST ", 3971)); +assertEquals(null, res[1334].exec("XY AB PQRS", 3972)); +assertEquals(null, res[1335].exec(">XNNNYZ", 3973)); +assertEquals(null, res[1335].exec("> X NYQZ", 3974)); +assertEquals(null, res[1335].exec("** Failers", 3975)); +assertEquals(null, res[1335].exec(">XYZ ", 3976)); +assertEquals(null, res[1335].exec("> X NY Z", 3977)); +assertEquals(null, res[1336].exec(">XY\nZ\nA\x0bNN\x0c", 3978)); +assertEquals(null, res[1336].exec(">\n\x0dX\nY\n\x0bZZZ\nAAA\x0bNNN\x0c", 3979)); +assertEquals(null, res[1337].exec("\x0d\nA", 3980)); +assertEquals("\nA", res[1338].exec("\x0d\nA "), 3981); +assertEquals("\nA", res[1339].exec("\x0d\nA "), 3982); +assertEquals("\nA,\n", res[1340].exec("\x0d\nA "), 3983); +assertEquals(null, res[1341].exec("a\x0db", 3984)); +assertEquals(null, res[1341].exec("a\nb", 3985)); +assertEquals(null, res[1341].exec("a\x0d\nb", 3986)); +assertEquals(null, res[1341].exec("** Failers", 3987)); +assertEquals(null, res[1341].exec("a\x85b", 3988)); +assertEquals(null, res[1341].exec("a\x0bb ", 3989)); +assertEquals(null, res[1342].exec("a\x0db", 3990)); +assertEquals(null, res[1342].exec("a\nb", 3991)); +assertEquals(null, res[1342].exec("a\x0d\nb", 3992)); +assertEquals(null, res[1342].exec("a\x85b", 3993)); +assertEquals(null, res[1342].exec("a\x0bb ", 3994)); +assertEquals(null, res[1342].exec("** Failers ", 3995)); +assertEquals(null, res[1342].exec("a\x85b", 3996)); +assertEquals(null, res[1342].exec("a\x0bb", 3997)); +assertEquals(null, res[1343].exec("a\x0db", 3998)); +assertEquals(null, res[1343].exec("a\nb", 3999)); +assertEquals(null, res[1343].exec("a\x0d\nb", 4000)); +assertEquals(null, res[1343].exec("** Failers", 4001)); +assertEquals(null, res[1343].exec("a\x85b", 4002)); +assertEquals(null, res[1343].exec("a\x0bb ", 4003)); +assertEquals(null, res[1344].exec("a\x0db", 4004)); +assertEquals(null, res[1344].exec("a\nb", 4005)); +assertEquals(null, res[1344].exec("a\x0d\nb", 4006)); +assertEquals(null, res[1344].exec("a\x85b", 4007)); +assertEquals(null, res[1344].exec("a\x0bb ", 4008)); +assertEquals(null, res[1344].exec("** Failers ", 4009)); +assertEquals(null, res[1344].exec("a\x85b", 4010)); +assertEquals(null, res[1344].exec("a\x0bb", 4011)); +assertEquals(null, res[1345].exec("a\x0d\n\nb", 4012)); +assertEquals(null, res[1345].exec("a\n\x0d\x0db", 4013)); +assertEquals(null, res[1345].exec("a\x0d\n\x0d\n\x0d\n\x0d\nb", 4014)); +assertEquals(null, res[1345].exec("** Failers", 4015)); +assertEquals(null, res[1345].exec("a\x8585b", 4016)); +assertEquals(null, res[1345].exec("a\x0b\x00bb ", 4017)); +assertEquals(null, res[1346].exec("a\x0d\x0db", 4018)); +assertEquals(null, res[1346].exec("a\n\n\nb", 4019)); +assertEquals(null, res[1346].exec("a\x0d\n\n\x0d\x0db", 4020)); +assertEquals(null, res[1346].exec("a\x8585b", 4021)); +assertEquals(null, res[1346].exec("a\x0b\x00bb ", 4022)); +assertEquals(null, res[1346].exec("** Failers ", 4023)); +assertEquals(null, res[1346].exec("a\x0d\x0d\x0d\x0d\x0db ", 4024)); +assertEquals(null, res[1346].exec("a\x8585b", 4025)); +assertEquals(null, res[1346].exec("a\x0b\x00bb", 4026)); +assertEquals("abc", res[1347].exec("abc "), 4027); +assertEquals(null, res[1348].exec("** Failers", 4028)); +assertEquals(null, res[1348].exec("ab", 4029)); +assertEquals(null, res[1349].exec("** Failers", 4030)); +assertEquals(null, res[1349].exec("ab ", 4031)); +assertEquals(null, res[1349].exec("** Failers", 4032)); +assertEquals(null, res[1349].exec("ab ", 4033)); +assertEquals("aXb", res[1350].exec("aXb"), 4034); +assertEquals("a\nb", res[1350].exec("a\nb "), 4035); +assertEquals(null, res[1350].exec("** Failers", 4036)); +assertEquals(null, res[1350].exec("ab ", 4037)); +assertEquals("aXb", res[1351].exec("aXb"), 4038); +assertEquals("a\nX\nXb", res[1351].exec("a\nX\nXb "), 4039); +assertEquals(null, res[1351].exec("** Failers", 4040)); +assertEquals(null, res[1351].exec("ab ", 4041)); +assertEquals(null, res[1352].exec("ab", 4042)); +assertEquals(null, res[1352].exec("ax{100}b ", 4043)); +assertEquals(null, res[1352].exec("ax{100}x{100}b ", 4044)); +assertEquals(null, res[1352].exec("ax{100}b ", 4045)); +assertEquals(null, res[1352].exec("ax{100}x{100}b ", 4046)); +assertEquals(null, res[1352].exec("*** Failers ", 4047)); +assertEquals(null, res[1352].exec("ab", 4048)); +assertEquals(null, res[1352].exec(" ", 4049)); +assertEquals("X", res[1353].exec("Xoanon"), 4050); +assertEquals("X", res[1353].exec("+Xoanon"), 4051); +assertEquals("X", res[1353].exec("x{300}Xoanon "), 4052); +assertEquals(null, res[1353].exec("*** Failers ", 4053)); +assertEquals(null, res[1353].exec("YXoanon ", 4054)); +assertEquals("X", res[1354].exec("YXoanon"), 4055); +assertEquals(null, res[1354].exec("*** Failers", 4056)); +assertEquals(null, res[1354].exec("Xoanon", 4057)); +assertEquals(null, res[1354].exec("+Xoanon ", 4058)); +assertEquals(null, res[1354].exec("x{300}Xoanon ", 4059)); +assertEquals("X", res[1355].exec("X+oanon"), 4060); +assertEquals(null, res[1355].exec("ZXx{300}oanon ", 4061)); +assertEquals("X", res[1355].exec("FAX "), 4062); +assertEquals(null, res[1355].exec("*** Failers ", 4063)); +assertEquals(null, res[1355].exec("Xoanon ", 4064)); +assertEquals("X", res[1356].exec("Xoanon "), 4065); +assertEquals(null, res[1356].exec("*** Failers", 4066)); +assertEquals(null, res[1356].exec("X+oanon", 4067)); +assertEquals("X", res[1356].exec("ZXx{300}oanon "), 4068); +assertEquals(null, res[1356].exec("FAX ", 4069)); +assertEquals("b", res[1357].exec("abcd"), 4070); +assertEquals("x", res[1357].exec("ax{100} "), 4071); +assertEquals("b", res[1357].exec("ab99"), 4072); +assertEquals("x", res[1357].exec("x{123}x{123}45"), 4073); +assertEquals("x", res[1357].exec("x{400}x{401}x{402}6 "), 4074); +assertEquals("*", res[1357].exec("*** Failers"), 4075); +assertEquals("d", res[1357].exec("d99"), 4076); +assertEquals("x", res[1357].exec("x{123}x{122}4 "), 4077); +assertEquals("x", res[1357].exec("x{400}x{403}6 "), 4078); +assertEquals("x", res[1357].exec("x{400}x{401}x{402}x{402}6 "), 4079); +assertEquals(null, res[1358].exec("\ufffd]", 4080)); +assertEquals(null, res[1358].exec("\ufffd", 4081)); +assertEquals(null, res[1358].exec("\ufffd\ufffd\ufffd", 4082)); +assertEquals(null, res[1358].exec("\ufffd\ufffd\ufffd?", 4083)); +assertEquals("acb", res[1359].exec("acb"), 4084); +assertEquals("ab", res[1359].exec("ab"), 4085); +assertEquals(null, res[1359].exec("ax{100}b ", 4086)); +assertEquals(null, res[1359].exec("*** Failers", 4087)); +assertEquals(null, res[1359].exec("a\nb ", 4088)); +assertEquals(null, res[1360].exec("ax{4000}xyb ", 4089)); +assertEquals(null, res[1360].exec("ax{4000}yb ", 4090)); +assertEquals(null, res[1360].exec("ax{4000}x{100}yb ", 4091)); +assertEquals(null, res[1360].exec("*** Failers", 4092)); +assertEquals(null, res[1360].exec("ax{4000}b ", 4093)); +assertEquals(null, res[1360].exec("ac\ncb ", 4094)); +assertEquals("a\xc0,,\xc0", res[1361].exec("a\xc0\x88b"), 4095); +assertEquals("ax,,x", res[1362].exec("ax{100}b"), 4096); +assertEquals("a\xc0\x88b,\xc0\x88,b", res[1363].exec("a\xc0\x88b"), 4097); +assertEquals("ax{100}b,x{100},b", res[1364].exec("ax{100}b"), 4098); +assertEquals("a\xc0\x92,\xc0,\x92", res[1365].exec("a\xc0\x92bcd"), 4099); +assertEquals("ax{,x,{", res[1366].exec("ax{240}bcd"), 4100); +assertEquals("a\xc0\x92,\xc0,\x92", res[1367].exec("a\xc0\x92bcd"), 4101); +assertEquals("ax{,x,{", res[1368].exec("ax{240}bcd"), 4102); +assertEquals("a\xc0,,\xc0", res[1369].exec("a\xc0\x92bcd"), 4103); +assertEquals("ax,,x", res[1370].exec("ax{240}bcd"), 4104); +assertEquals(null, res[1371].exec("ax{1234}xyb ", 4105)); +assertEquals(null, res[1371].exec("ax{1234}x{4321}yb ", 4106)); +assertEquals(null, res[1371].exec("ax{1234}x{4321}x{3412}b ", 4107)); +assertEquals(null, res[1371].exec("*** Failers", 4108)); +assertEquals(null, res[1371].exec("ax{1234}b ", 4109)); +assertEquals(null, res[1371].exec("ac\ncb ", 4110)); +assertEquals("ax{1234}xyb,x{1234}xy", res[1372].exec("ax{1234}xyb "), 4111); +assertEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[1372].exec("ax{1234}x{4321}yb "), 4112); +assertEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[1372].exec("ax{1234}x{4321}x{3412}b "), 4113); +assertEquals("axxxxbcdefghijb,xxxxbcdefghij", res[1372].exec("axxxxbcdefghijb "), 4114); +assertEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[1372].exec("ax{1234}x{4321}x{3412}x{3421}b "), 4115); +assertEquals(null, res[1372].exec("*** Failers", 4116)); +assertEquals("ax{1234}b,x{1234}", res[1372].exec("ax{1234}b "), 4117); +assertEquals("ax{1234}xyb,x{1234}xy", res[1373].exec("ax{1234}xyb "), 4118); +assertEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[1373].exec("ax{1234}x{4321}yb "), 4119); +assertEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[1373].exec("ax{1234}x{4321}x{3412}b "), 4120); +assertEquals("axxxxb,xxxx", res[1373].exec("axxxxbcdefghijb "), 4121); +assertEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[1373].exec("ax{1234}x{4321}x{3412}x{3421}b "), 4122); +assertEquals(null, res[1373].exec("*** Failers", 4123)); +assertEquals("ax{1234}b,x{1234}", res[1373].exec("ax{1234}b "), 4124); +assertEquals(null, res[1374].exec("ax{1234}xyb ", 4125)); +assertEquals(null, res[1374].exec("ax{1234}x{4321}yb ", 4126)); +assertEquals(null, res[1374].exec("ax{1234}x{4321}x{3412}b ", 4127)); +assertEquals("axxxxb,xxxx", res[1374].exec("axxxxbcdefghijb "), 4128); +assertEquals(null, res[1374].exec("ax{1234}x{4321}x{3412}x{3421}b ", 4129)); +assertEquals("axbxxb,xbxx", res[1374].exec("axbxxbcdefghijb "), 4130); +assertEquals("axxxxxb,xxxxx", res[1374].exec("axxxxxbcdefghijb "), 4131); +assertEquals(null, res[1374].exec("*** Failers", 4132)); +assertEquals(null, res[1374].exec("ax{1234}b ", 4133)); +assertEquals(null, res[1374].exec("axxxxxxbcdefghijb ", 4134)); +assertEquals(null, res[1375].exec("ax{1234}xyb ", 4135)); +assertEquals(null, res[1375].exec("ax{1234}x{4321}yb ", 4136)); +assertEquals(null, res[1375].exec("ax{1234}x{4321}x{3412}b ", 4137)); +assertEquals("axxxxb,xxxx", res[1375].exec("axxxxbcdefghijb "), 4138); +assertEquals(null, res[1375].exec("ax{1234}x{4321}x{3412}x{3421}b ", 4139)); +assertEquals("axbxxb,xbxx", res[1375].exec("axbxxbcdefghijb "), 4140); +assertEquals("axxxxxb,xxxxx", res[1375].exec("axxxxxbcdefghijb "), 4141); +assertEquals(null, res[1375].exec("*** Failers", 4142)); +assertEquals(null, res[1375].exec("ax{1234}b ", 4143)); +assertEquals(null, res[1375].exec("axxxxxxbcdefghijb ", 4144)); +assertEquals(null, res[1375].exec("*** Failers", 4145)); +assertEquals(null, res[1375].exec("x{100}", 4146)); +assertEquals(null, res[1375].exec("aXbcd", 4147)); +assertEquals(null, res[1375].exec("ax{100}bcd", 4148)); +assertEquals(null, res[1375].exec("ax{100000}bcd", 4149)); +assertEquals(null, res[1375].exec("x{100}x{100}x{100}b", 4150)); +assertEquals(null, res[1375].exec("*** Failers ", 4151)); +assertEquals(null, res[1375].exec("x{100}x{100}b", 4152)); +assertEquals(null, res[1375].exec("x{ab} ", 4153)); +assertEquals(null, res[1375].exec("\xc2\xab", 4154)); +assertEquals(null, res[1375].exec("*** Failers ", 4155)); +assertEquals(null, res[1375].exec("\x00{ab}", 4156)); +assertEquals(null, res[1375].exec("WXYZ", 4157)); +assertEquals(null, res[1375].exec("x{256}XYZ ", 4158)); +assertEquals(null, res[1375].exec("*** Failers", 4159)); +assertEquals(null, res[1375].exec("XYZ ", 4160)); +assertEquals("bcd", res[1376].exec("bcd"), 4161); +assertEquals("00}", res[1376].exec("x{100}aYx{256}Z "), 4162); +assertEquals("x{", res[1377].exec("x{100}bc"), 4163); +assertEquals("x{100}bcA", res[1378].exec("x{100}bcAa"), 4164); +assertEquals("x{", res[1379].exec("x{100}bca"), 4165); +assertEquals("bcd", res[1380].exec("bcd"), 4166); +assertEquals("00}", res[1380].exec("x{100}aYx{256}Z "), 4167); +assertEquals("x{", res[1381].exec("x{100}bc"), 4168); +assertEquals("x{100}bc", res[1382].exec("x{100}bcAa"), 4169); +assertEquals("x{", res[1383].exec("x{100}bca"), 4170); +assertEquals(null, res[1383].exec("abcd", 4171)); +assertEquals(null, res[1383].exec("abcd", 4172)); +assertEquals("x{", res[1383].exec("x{100}x{100} "), 4173); +assertEquals("x{", res[1383].exec("x{100}x{100} "), 4174); +assertEquals("x{", res[1383].exec("x{100}x{100}x{100}x{100} "), 4175); +assertEquals(null, res[1383].exec("abce", 4176)); +assertEquals("x{", res[1383].exec("x{100}x{100}x{100}x{100} "), 4177); +assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100} ", 4178)); +assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100} ", 4179)); +assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100} ", 4180)); +assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}XX", 4181)); +assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 4182)); +assertEquals(null, res[1383].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 4183)); +assertEquals("Xy", res[1383].exec("Xyyyax{100}x{100}bXzzz"), 4184); +assertEquals("X", res[1386].exec("1X2"), 4185); +assertEquals("x", res[1386].exec("1x{100}2 "), 4186); +assertEquals(">X", res[1387].exec("> >X Y"), 4187); +assertEquals(">x", res[1387].exec("> >x{100} Y"), 4188); +assertEquals("1", res[1388].exec("x{100}3"), 4189); +assertEquals(" ", res[1389].exec("x{100} X"), 4190); +assertEquals("abcd", res[1390].exec("12abcd34"), 4191); +assertEquals("*** Failers", res[1390].exec("*** Failers"), 4192); +assertEquals(" ", res[1390].exec("1234 "), 4193); +assertEquals("abc", res[1391].exec("12abcd34"), 4194); +assertEquals("ab", res[1391].exec("12ab34"), 4195); +assertEquals("***", res[1391].exec("*** Failers "), 4196); +assertEquals(null, res[1391].exec("1234", 4197)); +assertEquals(" ", res[1391].exec("12a34 "), 4198); +assertEquals("ab", res[1392].exec("12abcd34"), 4199); +assertEquals("ab", res[1392].exec("12ab34"), 4200); +assertEquals("**", res[1392].exec("*** Failers "), 4201); +assertEquals(null, res[1392].exec("1234", 4202)); +assertEquals(" ", res[1392].exec("12a34 "), 4203); +assertEquals("12", res[1393].exec("12abcd34"), 4204); +assertEquals(null, res[1393].exec("*** Failers", 4205)); +assertEquals("12", res[1394].exec("12abcd34"), 4206); +assertEquals("123", res[1394].exec("1234abcd"), 4207); +assertEquals(null, res[1394].exec("*** Failers ", 4208)); +assertEquals(null, res[1394].exec("1.4 ", 4209)); +assertEquals("12", res[1395].exec("12abcd34"), 4210); +assertEquals("12", res[1395].exec("1234abcd"), 4211); +assertEquals(null, res[1395].exec("*** Failers ", 4212)); +assertEquals(null, res[1395].exec("1.4 ", 4213)); +assertEquals("12abcd34", res[1396].exec("12abcd34"), 4214); +assertEquals("***", res[1396].exec("*** Failers"), 4215); +assertEquals(null, res[1396].exec(" ", 4216)); +assertEquals("12a", res[1397].exec("12abcd34"), 4217); +assertEquals("123", res[1397].exec("1234abcd"), 4218); +assertEquals("***", res[1397].exec("*** Failers"), 4219); +assertEquals(null, res[1397].exec(" ", 4220)); +assertEquals("12", res[1398].exec("12abcd34"), 4221); +assertEquals("12", res[1398].exec("1234abcd"), 4222); +assertEquals("**", res[1398].exec("*** Failers"), 4223); +assertEquals(null, res[1398].exec(" ", 4224)); +assertEquals("> <", res[1399].exec("12> <34"), 4225); +assertEquals(null, res[1399].exec("*** Failers", 4226)); +assertEquals("> <", res[1400].exec("ab> <", res[1400].exec("ab> <", res[1401].exec("ab> <", res[1401].exec("ab> \xff<"), 4303); +assertEquals(null, res[1409].exec(">x{ff}<", 4304)); +assertEquals("X", res[1410].exec("XYZ"), 4305); +assertEquals("X", res[1411].exec("XYZ"), 4306); +assertEquals("x", res[1411].exec("x{123} "), 4307); +assertEquals(",", res[1416].exec("catac"), 4308); +assertEquals(",", res[1416].exec("ax{256}a "), 4309); +assertEquals(",", res[1416].exec("x{85}"), 4310); +assertEquals("abc1", res[1417].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 x{0085}abc7 x{2028}abc8 x{2029}abc9 JUNK"), 4311); +assertEquals("abc1", res[1418].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6x{0085} abc7x{2028} abc8x{2029} abc9"), 4312); +assertEquals(null, res[1419].exec("a\nb", 4313)); +assertEquals(null, res[1419].exec("a\x0db", 4314)); +assertEquals(null, res[1419].exec("a\x0d\nb", 4315)); +assertEquals(null, res[1419].exec("a\x0bb", 4316)); +assertEquals(null, res[1419].exec("a\x0cb", 4317)); +assertEquals(null, res[1419].exec("ax{85}b ", 4318)); +assertEquals(null, res[1419].exec("ax{2028}b ", 4319)); +assertEquals(null, res[1419].exec("ax{2029}b ", 4320)); +assertEquals(null, res[1419].exec("** Failers", 4321)); +assertEquals(null, res[1419].exec("a\n\x0db ", 4322)); +assertEquals("ab", res[1420].exec("ab"), 4323); +assertEquals(null, res[1420].exec("a\nb", 4324)); +assertEquals(null, res[1420].exec("a\x0db", 4325)); +assertEquals(null, res[1420].exec("a\x0d\nb", 4326)); +assertEquals(null, res[1420].exec("a\x0bb", 4327)); +assertEquals(null, res[1420].exec("a\x0cx{2028}x{2029}b", 4328)); +assertEquals(null, res[1420].exec("ax{85}b ", 4329)); +assertEquals(null, res[1420].exec("a\n\x0db ", 4330)); +assertEquals(null, res[1420].exec("a\n\x0dx{85}\x0cb ", 4331)); +assertEquals(null, res[1421].exec("a\nb", 4332)); +assertEquals(null, res[1421].exec("a\x0db", 4333)); +assertEquals(null, res[1421].exec("a\x0d\nb", 4334)); +assertEquals(null, res[1421].exec("a\x0bb", 4335)); +assertEquals(null, res[1421].exec("a\x0cx{2028}x{2029}b", 4336)); +assertEquals(null, res[1421].exec("ax{85}b ", 4337)); +assertEquals(null, res[1421].exec("a\n\x0db ", 4338)); +assertEquals(null, res[1421].exec("a\n\x0dx{85}\x0cb ", 4339)); +assertEquals(null, res[1421].exec("** Failers", 4340)); +assertEquals(null, res[1421].exec("ab ", 4341)); +assertEquals(null, res[1422].exec("a\nb", 4342)); +assertEquals(null, res[1422].exec("a\n\x0db", 4343)); +assertEquals(null, res[1422].exec("a\n\x0dx{85}b", 4344)); +assertEquals(null, res[1422].exec("a\x0d\n\x0d\nb ", 4345)); +assertEquals(null, res[1422].exec("a\x0d\n\x0d\n\x0d\nb ", 4346)); +assertEquals(null, res[1422].exec("a\n\x0d\n\x0db", 4347)); +assertEquals(null, res[1422].exec("a\n\n\x0d\nb ", 4348)); +assertEquals(null, res[1422].exec("** Failers", 4349)); +assertEquals(null, res[1422].exec("a\n\n\n\x0db", 4350)); +assertEquals(null, res[1422].exec("a\x0d", 4351)); +assertEquals(null, res[1423].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 4352)); +assertEquals(null, res[1424].exec(" x{a0}X\n\x0b\x0c\x0d\n", 4353)); +assertEquals(null, res[1425].exec(">\x09 x{a0}X\n\n\n<", 4354)); +assertEquals(null, res[1426].exec(">\x09 x{a0}X\n\n\n<", 4355)); +assertEquals(null, res[1427].exec("X X\n", 4356)); +assertEquals(null, res[1427].exec("X\x09X\x0b", 4357)); +assertEquals(null, res[1427].exec("** Failers", 4358)); +assertEquals(null, res[1427].exec("x{a0} X\n ", 4359)); +assertEquals(null, res[1428].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 4360)); +assertEquals(null, res[1428].exec("\x09 x{a0}\n\x0b\x0c\x0d\n", 4361)); +assertEquals(null, res[1428].exec("\x09 x{a0}\n\x0b\x0c", 4362)); +assertEquals(null, res[1428].exec("** Failers ", 4363)); +assertEquals(null, res[1428].exec("\x09 x{a0}\n\x0b", 4364)); +assertEquals(null, res[1428].exec(" ", 4365)); +assertEquals(null, res[1429].exec("x{3001}x{3000}x{2030}x{2028}", 4366)); +assertEquals(null, res[1429].exec("Xx{180e}Xx{85}", 4367)); +assertEquals(null, res[1429].exec("** Failers", 4368)); +assertEquals(null, res[1429].exec("x{2009} X\n ", 4369)); +assertEquals(null, res[1430].exec("x{1680}x{180e}x{2007}Xx{2028}x{2029}\x0c\x0d\n", 4370)); +assertEquals(null, res[1430].exec("\x09x{205f}x{a0}\nx{2029}\x0cx{2028}\n", 4371)); +assertEquals(null, res[1430].exec("\x09 x{202f}\n\x0b\x0c", 4372)); +assertEquals(null, res[1430].exec("** Failers ", 4373)); +assertEquals(null, res[1430].exec("\x09x{200a}x{a0}x{2028}\x0b", 4374)); +assertEquals(null, res[1430].exec(" ", 4375)); +assertEquals(null, res[1431].exec("a\x0db", 4376)); +assertEquals(null, res[1431].exec("a\nb", 4377)); +assertEquals(null, res[1431].exec("a\x0d\nb", 4378)); +assertEquals(null, res[1431].exec("** Failers", 4379)); +assertEquals(null, res[1431].exec("ax{85}b", 4380)); +assertEquals(null, res[1431].exec("a\x0bb ", 4381)); +assertEquals(null, res[1432].exec("a\x0db", 4382)); +assertEquals(null, res[1432].exec("a\nb", 4383)); +assertEquals(null, res[1432].exec("a\x0d\nb", 4384)); +assertEquals(null, res[1432].exec("ax{85}b", 4385)); +assertEquals(null, res[1432].exec("a\x0bb ", 4386)); +assertEquals(null, res[1432].exec("** Failers ", 4387)); +assertEquals(null, res[1432].exec("ax{85}b", 4388)); +assertEquals(null, res[1432].exec("a\x0bb", 4389)); +assertEquals(null, res[1433].exec("a\x0db", 4390)); +assertEquals(null, res[1433].exec("a\nb", 4391)); +assertEquals(null, res[1433].exec("a\x0d\nb", 4392)); +assertEquals(null, res[1433].exec("** Failers", 4393)); +assertEquals(null, res[1433].exec("ax{85}b", 4394)); +assertEquals(null, res[1433].exec("a\x0bb ", 4395)); +assertEquals(null, res[1434].exec("a\x0db", 4396)); +assertEquals(null, res[1434].exec("a\nb", 4397)); +assertEquals(null, res[1434].exec("a\x0d\nb", 4398)); +assertEquals(null, res[1434].exec("ax{85}b", 4399)); +assertEquals(null, res[1434].exec("a\x0bb ", 4400)); +assertEquals(null, res[1434].exec("** Failers ", 4401)); +assertEquals(null, res[1434].exec("ax{85}b", 4402)); +assertEquals(null, res[1434].exec("a\x0bb", 4403)); +assertEquals("X", res[1435].exec("Ax{1ec5}ABCXYZ"), 4404); +assertEquals(null, res[1437].exec("AB", 4405)); +assertEquals(null, res[1437].exec("*** Failers", 4406)); +assertEquals(null, res[1437].exec("A0", 4407)); +assertEquals(null, res[1437].exec("00 ", 4408)); +assertEquals(null, res[1438].exec("AB", 4409)); +assertEquals(null, res[1438].exec("Ax{300}BC ", 4410)); +assertEquals(null, res[1438].exec("Ax{300}x{301}x{302}BC ", 4411)); +assertEquals(null, res[1438].exec("*** Failers", 4412)); +assertEquals(null, res[1438].exec("x{300} ", 4413)); +assertEquals(null, res[1439].exec("ABC", 4414)); +assertEquals(null, res[1439].exec("Ax{300}Bx{300}x{301}C ", 4415)); +assertEquals(null, res[1439].exec("Ax{300}x{301}x{302}BC ", 4416)); +assertEquals(null, res[1439].exec("*** Failers", 4417)); +assertEquals(null, res[1439].exec("x{300} ", 4418)); +assertEquals(null, res[1440].exec("abcd", 4419)); +assertEquals(null, res[1440].exec("a ", 4420)); +assertEquals(null, res[1440].exec("*** Failers ", 4421)); +assertEquals(null, res[1441].exec("1234", 4422)); +assertEquals(null, res[1441].exec("= ", 4423)); +assertEquals(null, res[1441].exec("*** Failers ", 4424)); +assertEquals(null, res[1441].exec("abcd ", 4425)); +assertEquals(null, res[1442].exec("abcdAx{300}x{301}x{302}", 4426)); +assertEquals(null, res[1442].exec("Ax{300}x{301}x{302}", 4427)); +assertEquals(null, res[1442].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}", 4428)); +assertEquals(null, res[1442].exec("a ", 4429)); +assertEquals(null, res[1442].exec("*** Failers ", 4430)); +assertEquals(null, res[1442].exec("x{300}x{301}x{302}", 4431)); +assertEquals("abc", res[1443].exec("abc"), 4432); +assertEquals("abc", res[1443].exec("Ax{300}abc"), 4433); +assertEquals("abc", res[1443].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz"), 4434); +assertEquals("abc", res[1443].exec("x{300}abc "), 4435); +assertEquals(null, res[1443].exec("*** Failers", 4436)); +assertEquals("abc", res[1444].exec("abc"), 4437); +assertEquals(null, res[1444].exec("Ax{300}abc", 4438)); +assertEquals(null, res[1444].exec("*** Failers", 4439)); +assertEquals(null, res[1444].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz", 4440)); +assertEquals(null, res[1444].exec("x{300}abc ", 4441)); +assertEquals("abc", res[1445].exec("abc"), 4442); +assertEquals("abc", res[1445].exec("Ax{300}abc"), 4443); +assertEquals("abc", res[1445].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz"), 4444); +assertEquals("abc", res[1445].exec("x{300}abc "), 4445); +assertEquals(null, res[1445].exec("*** Failers", 4446)); +assertEquals("abc", res[1446].exec("abc"), 4447); +assertEquals(null, res[1446].exec("Ax{300}abc", 4448)); +assertEquals(null, res[1446].exec("Ax{300}x{301}x{302}Ax{300}Ax{300}Ax{300}abcxyz", 4449)); +assertEquals(null, res[1446].exec("*** Failers", 4450)); +assertEquals(null, res[1446].exec("x{300}abc ", 4451)); +assertEquals(null, res[1447].exec("A=b", 4452)); +assertEquals(null, res[1447].exec("=c ", 4453)); +assertEquals(null, res[1447].exec("*** Failers", 4454)); +assertEquals(null, res[1447].exec("1=2 ", 4455)); +assertEquals(null, res[1447].exec("AAAA=b ", 4456)); +assertEquals(null, res[1448].exec("AAAA=b", 4457)); +assertEquals(null, res[1448].exec("=c ", 4458)); +assertEquals(null, res[1448].exec("*** Failers", 4459)); +assertEquals(null, res[1448].exec("1=2 ", 4460)); +assertEquals(null, res[1449].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}X", 4461)); +assertEquals(null, res[1449].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}Ax{300}x{301}x{302}X ", 4462)); +assertEquals(null, res[1449].exec("*** Failers", 4463)); +assertEquals(null, res[1449].exec("X", 4464)); +assertEquals(null, res[1449].exec("Ax{300}x{301}x{302}X", 4465)); +assertEquals(null, res[1449].exec("Ax{300}x{301}x{302}Ax{300}x{301}x{302}Ax{300}x{301}x{302}Ax{300}x{301}x{302}X", 4466)); +assertEquals(null, res[1450].exec("x{c0}x{30f}x{660}x{66c}x{f01}x{1680}<", 4467)); +assertEquals(null, res[1450].exec("\npx{300}9!$ < ", 4468)); +assertEquals(null, res[1450].exec("** Failers ", 4469)); +assertEquals(null, res[1450].exec("apx{300}9!$ < ", 4470)); +assertEquals(null, res[1451].exec("X", 4471)); +assertEquals(null, res[1451].exec("** Failers ", 4472)); +assertEquals(null, res[1451].exec("", 4473)); +assertEquals(null, res[1452].exec("9", 4474)); +assertEquals(null, res[1452].exec("** Failers ", 4475)); +assertEquals(null, res[1452].exec("x{c0}", 4476)); +assertEquals(null, res[1453].exec("X", 4477)); +assertEquals(null, res[1453].exec("** Failers ", 4478)); +assertEquals(null, res[1453].exec("x{30f}", 4479)); +assertEquals(null, res[1454].exec("X", 4480)); +assertEquals(null, res[1454].exec("** Failers ", 4481)); +assertEquals(null, res[1454].exec("x{660}", 4482)); +assertEquals(null, res[1455].exec("X", 4483)); +assertEquals(null, res[1455].exec("** Failers ", 4484)); +assertEquals(null, res[1455].exec("x{66c}", 4485)); +assertEquals(null, res[1456].exec("X", 4486)); +assertEquals(null, res[1456].exec("** Failers ", 4487)); +assertEquals(null, res[1456].exec("x{f01}", 4488)); +assertEquals(null, res[1457].exec("X", 4489)); +assertEquals(null, res[1457].exec("** Failers ", 4490)); +assertEquals(null, res[1457].exec("x{1680}", 4491)); +assertEquals(null, res[1458].exec("x{017}", 4492)); +assertEquals(null, res[1458].exec("x{09f} ", 4493)); +assertEquals(null, res[1458].exec("** Failers", 4494)); +assertEquals(null, res[1458].exec("x{0600} ", 4495)); +assertEquals(null, res[1459].exec("x{601}", 4496)); +assertEquals(null, res[1459].exec("** Failers", 4497)); +assertEquals(null, res[1459].exec("x{09f} ", 4498)); +assertEquals(null, res[1460].exec("** Failers", 4499)); +assertEquals(null, res[1460].exec("x{09f} ", 4500)); +assertEquals(null, res[1461].exec("x{f8ff}", 4501)); +assertEquals(null, res[1461].exec("** Failers", 4502)); +assertEquals(null, res[1461].exec("x{09f} ", 4503)); +assertEquals(null, res[1462].exec("?x{dfff}", 4504)); +assertEquals(null, res[1462].exec("** Failers", 4505)); +assertEquals(null, res[1462].exec("x{09f} ", 4506)); +assertEquals(null, res[1463].exec("a", 4507)); +assertEquals(null, res[1463].exec("** Failers ", 4508)); +assertEquals(null, res[1463].exec("Z", 4509)); +assertEquals(null, res[1463].exec("x{e000} ", 4510)); +assertEquals(null, res[1464].exec("x{2b0}", 4511)); +assertEquals(null, res[1464].exec("** Failers", 4512)); +assertEquals(null, res[1464].exec("a ", 4513)); +assertEquals(null, res[1465].exec("x{1bb}", 4514)); +assertEquals(null, res[1465].exec("** Failers", 4515)); +assertEquals(null, res[1465].exec("a ", 4516)); +assertEquals(null, res[1465].exec("x{2b0}", 4517)); +assertEquals(null, res[1466].exec("x{1c5}", 4518)); +assertEquals(null, res[1466].exec("** Failers", 4519)); +assertEquals(null, res[1466].exec("a ", 4520)); +assertEquals(null, res[1466].exec("x{2b0}", 4521)); +assertEquals(null, res[1467].exec("A", 4522)); +assertEquals(null, res[1467].exec("** Failers", 4523)); +assertEquals(null, res[1467].exec("x{2b0}", 4524)); +assertEquals(null, res[1468].exec("x{903}", 4525)); +assertEquals(null, res[1468].exec("** Failers", 4526)); +assertEquals(null, res[1468].exec("X", 4527)); +assertEquals(null, res[1468].exec("x{300}", 4528)); +assertEquals(null, res[1468].exec(" ", 4529)); +assertEquals(null, res[1469].exec("x{488}", 4530)); +assertEquals(null, res[1469].exec("** Failers", 4531)); +assertEquals(null, res[1469].exec("X", 4532)); +assertEquals(null, res[1469].exec("x{903}", 4533)); +assertEquals(null, res[1469].exec("x{300}", 4534)); +assertEquals(null, res[1470].exec("x{300}", 4535)); +assertEquals(null, res[1470].exec("** Failers", 4536)); +assertEquals(null, res[1470].exec("X", 4537)); +assertEquals(null, res[1470].exec("x{903}", 4538)); +assertEquals(null, res[1470].exec("0123456789x{660}x{661}x{662}x{663}x{664}x{665}x{666}x{667}x{668}x{669}x{66a}", 4539)); +assertEquals(null, res[1470].exec("x{6f0}x{6f1}x{6f2}x{6f3}x{6f4}x{6f5}x{6f6}x{6f7}x{6f8}x{6f9}x{6fa}", 4540)); +assertEquals(null, res[1470].exec("x{966}x{967}x{968}x{969}x{96a}x{96b}x{96c}x{96d}x{96e}x{96f}x{970}", 4541)); +assertEquals(null, res[1470].exec("** Failers", 4542)); +assertEquals(null, res[1470].exec("X", 4543)); +assertEquals(null, res[1471].exec("x{16ee}", 4544)); +assertEquals(null, res[1471].exec("** Failers", 4545)); +assertEquals(null, res[1471].exec("X", 4546)); +assertEquals(null, res[1471].exec("x{966}", 4547)); +assertEquals(null, res[1472].exec("x{b2}", 4548)); +assertEquals(null, res[1472].exec("x{b3}", 4549)); +assertEquals(null, res[1472].exec("** Failers", 4550)); +assertEquals(null, res[1472].exec("X", 4551)); +assertEquals(null, res[1472].exec("x{16ee}", 4552)); +assertEquals(null, res[1473].exec("_", 4553)); +assertEquals(null, res[1473].exec("x{203f}", 4554)); +assertEquals(null, res[1473].exec("** Failers", 4555)); +assertEquals(null, res[1473].exec("X", 4556)); +assertEquals(null, res[1473].exec("-", 4557)); +assertEquals(null, res[1473].exec("x{58a}", 4558)); +assertEquals(null, res[1474].exec("-", 4559)); +assertEquals(null, res[1474].exec("x{58a}", 4560)); +assertEquals(null, res[1474].exec("** Failers", 4561)); +assertEquals(null, res[1474].exec("X", 4562)); +assertEquals(null, res[1474].exec("x{203f}", 4563)); +assertEquals(null, res[1475].exec(")", 4564)); +assertEquals(null, res[1475].exec("]", 4565)); +assertEquals(null, res[1475].exec("}", 4566)); +assertEquals(null, res[1475].exec("x{f3b}", 4567)); +assertEquals(null, res[1475].exec("** Failers", 4568)); +assertEquals(null, res[1475].exec("X", 4569)); +assertEquals(null, res[1475].exec("x{203f}", 4570)); +assertEquals(null, res[1475].exec("(", 4571)); +assertEquals(null, res[1475].exec("[", 4572)); +assertEquals(null, res[1475].exec("{", 4573)); +assertEquals(null, res[1475].exec("x{f3c}", 4574)); +assertEquals(null, res[1476].exec("x{bb}", 4575)); +assertEquals(null, res[1476].exec("x{2019}", 4576)); +assertEquals(null, res[1476].exec("** Failers", 4577)); +assertEquals(null, res[1476].exec("X", 4578)); +assertEquals(null, res[1476].exec("x{203f}", 4579)); +assertEquals(null, res[1477].exec("x{ab}", 4580)); +assertEquals(null, res[1477].exec("x{2018}", 4581)); +assertEquals(null, res[1477].exec("** Failers", 4582)); +assertEquals(null, res[1477].exec("X", 4583)); +assertEquals(null, res[1477].exec("x{203f}", 4584)); +assertEquals(null, res[1478].exec("!", 4585)); +assertEquals(null, res[1478].exec("x{37e}", 4586)); +assertEquals(null, res[1478].exec("** Failers", 4587)); +assertEquals(null, res[1478].exec("X", 4588)); +assertEquals(null, res[1478].exec("x{203f}", 4589)); +assertEquals(null, res[1479].exec("(", 4590)); +assertEquals(null, res[1479].exec("[", 4591)); +assertEquals(null, res[1479].exec("{", 4592)); +assertEquals(null, res[1479].exec("x{f3c}", 4593)); +assertEquals(null, res[1479].exec("** Failers", 4594)); +assertEquals(null, res[1479].exec("X", 4595)); +assertEquals(null, res[1479].exec(")", 4596)); +assertEquals(null, res[1479].exec("]", 4597)); +assertEquals(null, res[1479].exec("}", 4598)); +assertEquals(null, res[1479].exec("x{f3b}", 4599)); +assertEquals(null, res[1479].exec("$x{a2}x{a3}x{a4}x{a5}x{a6}", 4600)); +assertEquals(null, res[1479].exec("x{9f2}", 4601)); +assertEquals(null, res[1479].exec("** Failers", 4602)); +assertEquals(null, res[1479].exec("X", 4603)); +assertEquals(null, res[1479].exec("x{2c2}", 4604)); +assertEquals(null, res[1480].exec("x{2c2}", 4605)); +assertEquals(null, res[1480].exec("** Failers", 4606)); +assertEquals(null, res[1480].exec("X", 4607)); +assertEquals(null, res[1480].exec("x{9f2}", 4608)); +assertEquals(null, res[1480].exec("+<|~x{ac}x{2044}", 4609)); +assertEquals(null, res[1480].exec("** Failers", 4610)); +assertEquals(null, res[1480].exec("X", 4611)); +assertEquals(null, res[1480].exec("x{9f2}", 4612)); +assertEquals(null, res[1481].exec("x{a6}", 4613)); +assertEquals(null, res[1481].exec("x{482} ", 4614)); +assertEquals(null, res[1481].exec("** Failers", 4615)); +assertEquals(null, res[1481].exec("X", 4616)); +assertEquals(null, res[1481].exec("x{9f2}", 4617)); +assertEquals(null, res[1482].exec("x{2028}", 4618)); +assertEquals(null, res[1482].exec("** Failers", 4619)); +assertEquals(null, res[1482].exec("X", 4620)); +assertEquals(null, res[1482].exec("x{2029}", 4621)); +assertEquals(null, res[1483].exec("x{2029}", 4622)); +assertEquals(null, res[1483].exec("** Failers", 4623)); +assertEquals(null, res[1483].exec("X", 4624)); +assertEquals(null, res[1483].exec("x{2028}", 4625)); +assertEquals(null, res[1484].exec("\\ \\", 4626)); +assertEquals(null, res[1484].exec("x{a0}", 4627)); +assertEquals(null, res[1484].exec("x{1680}", 4628)); +assertEquals(null, res[1484].exec("x{180e}", 4629)); +assertEquals(null, res[1484].exec("x{2000}", 4630)); +assertEquals(null, res[1484].exec("x{2001} ", 4631)); +assertEquals(null, res[1484].exec("** Failers", 4632)); +assertEquals(null, res[1484].exec("x{2028}", 4633)); +assertEquals(null, res[1484].exec("x{200d} ", 4634)); +assertEquals(null, res[1484].exec(" x{660}x{661}x{662}ABC", 4635)); +assertEquals(null, res[1484].exec(" x{660}x{661}x{662}ABC", 4636)); +assertEquals(null, res[1485].exec(" x{660}x{661}x{662}ABC", 4637)); +assertEquals(null, res[1486].exec(" x{660}x{661}x{662}ABC", 4638)); +assertEquals(null, res[1487].exec(" x{660}x{661}x{662}ABC", 4639)); +assertEquals(null, res[1488].exec(" x{660}x{661}x{662}ABC", 4640)); +assertEquals(null, res[1489].exec(" x{660}x{661}x{662}ABC", 4641)); +assertEquals(null, res[1490].exec(" x{660}x{661}x{662}ABC", 4642)); +assertEquals(null, res[1491].exec(" x{660}x{661}x{662}ABC", 4643)); +assertEquals(null, res[1492].exec(" x{660}x{661}x{662}ABC", 4644)); +assertEquals(null, res[1493].exec(" x{660}x{661}x{662}ABC", 4645)); +assertEquals(null, res[1493].exec(" x{660}x{661}x{662}ABC", 4646)); +assertEquals(null, res[1493].exec(" x{660}x{661}x{662}ABC", 4647)); +assertEquals(null, res[1493].exec(" ** Failers", 4648)); +assertEquals(null, res[1493].exec(" x{660}x{661}x{662}ABC", 4649)); +assertEquals(null, res[1494].exec("A", 4650)); +assertEquals(null, res[1494].exec("ax{10a0}B ", 4651)); +assertEquals(null, res[1494].exec("** Failers ", 4652)); +assertEquals(null, res[1494].exec("a", 4653)); +assertEquals(null, res[1494].exec("x{1d00} ", 4654)); +assertEquals(null, res[1495].exec("1234", 4655)); +assertEquals(null, res[1495].exec("** Failers", 4656)); +assertEquals(null, res[1495].exec("ABC ", 4657)); +assertEquals(null, res[1496].exec("1234", 4658)); +assertEquals(null, res[1496].exec("** Failers", 4659)); +assertEquals(null, res[1496].exec("ABC ", 4660)); +assertEquals(null, res[1496].exec("A2XYZ", 4661)); +assertEquals(null, res[1496].exec("123A5XYZPQR", 4662)); +assertEquals(null, res[1496].exec("ABAx{660}XYZpqr", 4663)); +assertEquals(null, res[1496].exec("** Failers", 4664)); +assertEquals(null, res[1496].exec("AXYZ", 4665)); +assertEquals(null, res[1496].exec("XYZ ", 4666)); +assertEquals(null, res[1496].exec("1XYZ", 4667)); +assertEquals(null, res[1496].exec("AB=XYZ.. ", 4668)); +assertEquals(null, res[1496].exec("XYZ ", 4669)); +assertEquals(null, res[1496].exec("** Failers", 4670)); +assertEquals(null, res[1496].exec("WXYZ ", 4671)); +assertEquals(null, res[1497].exec("1234", 4672)); +assertEquals(null, res[1497].exec("1234", 4673)); +assertEquals(null, res[1497].exec("12-34", 4674)); +assertEquals("{", res[1497].exec("12+x{661}-34 "), 4675); +assertEquals(null, res[1497].exec("** Failers", 4676)); +assertEquals("d", res[1497].exec("abcd "), 4677); +assertEquals("d", res[1498].exec("abcd"), 4678); +assertEquals(null, res[1498].exec("** Failers", 4679)); +assertEquals(null, res[1498].exec("1234", 4680)); +assertEquals(null, res[1499].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4681)); +assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1499].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4682); +assertEquals(" ", res[1499].exec(" "), 4683); +assertEquals(null, res[1499].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4684)); +assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1499].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4685); +assertEquals(null, res[1500].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4686)); +assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1500].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4687); +assertEquals(null, res[1501].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4688)); +assertEquals(null, res[1501].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 4689)); +assertEquals(null, res[1502].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 4690)); +assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[1502].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 4691); +assertEquals(null, res[1503].exec("a", 4692)); +assertEquals(null, res[1503].exec("A ", 4693)); +assertEquals(null, res[1504].exec("a", 4694)); +assertEquals(null, res[1504].exec("A ", 4695)); +assertEquals(null, res[1505].exec("A", 4696)); +assertEquals(null, res[1505].exec("aZ", 4697)); +assertEquals(null, res[1505].exec("** Failers", 4698)); +assertEquals(null, res[1505].exec("abc ", 4699)); +assertEquals(null, res[1506].exec("A", 4700)); +assertEquals(null, res[1506].exec("aZ", 4701)); +assertEquals(null, res[1506].exec("** Failers", 4702)); +assertEquals(null, res[1506].exec("abc ", 4703)); +assertEquals(null, res[1507].exec("a", 4704)); +assertEquals(null, res[1507].exec("Az", 4705)); +assertEquals(null, res[1507].exec("** Failers", 4706)); +assertEquals(null, res[1507].exec("ABC ", 4707)); +assertEquals(null, res[1508].exec("a", 4708)); +assertEquals(null, res[1508].exec("Az", 4709)); +assertEquals(null, res[1508].exec("** Failers", 4710)); +assertEquals(null, res[1508].exec("ABC ", 4711)); +assertEquals(null, res[1508].exec("x{c0}", 4712)); +assertEquals(null, res[1508].exec("x{e0} ", 4713)); +assertEquals(null, res[1508].exec("x{c0}", 4714)); +assertEquals(null, res[1508].exec("x{e0} ", 4715)); +assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 4716)); +assertEquals(null, res[1508].exec("** Failers", 4717)); +assertEquals(null, res[1508].exec("ax{391}x{10427}x{ff3a}x{1fb0} ", 4718)); +assertEquals(null, res[1508].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 4719)); +assertEquals(null, res[1508].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 4720)); +assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 4721)); +assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 4722)); +assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 4723)); +assertEquals(null, res[1508].exec("ax{391}x{10427}x{ff3a}x{1fb0} ", 4724)); +assertEquals(null, res[1508].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 4725)); +assertEquals(null, res[1508].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 4726)); +assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 4727)); +assertEquals(null, res[1508].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 4728)); +assertEquals(null, res[1508].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}", 4729)); +assertEquals(null, res[1508].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 4730)); +assertEquals(null, res[1508].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 4731)); +assertEquals(null, res[1508].exec("x{391}", 4732)); +assertEquals(null, res[1508].exec("x{ff3a}", 4733)); +assertEquals(null, res[1508].exec("x{3b1}", 4734)); +assertEquals(null, res[1508].exec("x{ff5a} ", 4735)); +assertEquals(null, res[1508].exec("x{c0}", 4736)); +assertEquals(null, res[1508].exec("x{e0} ", 4737)); +assertEquals(null, res[1508].exec("x{104}", 4738)); +assertEquals(null, res[1508].exec("x{105}", 4739)); +assertEquals(null, res[1508].exec("x{109} ", 4740)); +assertEquals(null, res[1508].exec("** Failers", 4741)); +assertEquals(null, res[1508].exec("x{100}", 4742)); +assertEquals(null, res[1508].exec("x{10a} ", 4743)); +assertEquals(null, res[1508].exec("Z", 4744)); +assertEquals(null, res[1508].exec("z", 4745)); +assertEquals(null, res[1508].exec("x{39c}", 4746)); +assertEquals(null, res[1508].exec("x{178}", 4747)); +assertEquals(null, res[1508].exec("|", 4748)); +assertEquals(null, res[1508].exec("x{80}", 4749)); +assertEquals(null, res[1508].exec("x{ff}", 4750)); +assertEquals(null, res[1508].exec("x{100}", 4751)); +assertEquals(null, res[1508].exec("x{101} ", 4752)); +assertEquals(null, res[1508].exec("** Failers", 4753)); +assertEquals(null, res[1508].exec("x{102}", 4754)); +assertEquals(null, res[1508].exec("Y", 4755)); +assertEquals(null, res[1508].exec("y ", 4756)); +assertEquals(null, res[1509].exec("A", 4757)); +assertEquals(null, res[1509].exec("Ax{300}BC ", 4758)); +assertEquals(null, res[1509].exec("Ax{300}x{301}x{302}BC ", 4759)); +assertEquals(null, res[1509].exec("*** Failers", 4760)); +assertEquals(null, res[1509].exec("x{300} ", 4761)); +assertEquals("X", res[1510].exec("X123"), 4762); +assertEquals(null, res[1510].exec("*** Failers", 4763)); +assertEquals(null, res[1510].exec("AXYZ", 4764)); +assertEquals(null, res[1511].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 4765)); +assertEquals(null, res[1511].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 4766)); +assertEquals(null, res[1512].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 4767)); +assertEquals(null, res[1512].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 4768)); +assertEquals("A,,A", res[1513].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 4769); +assertEquals("A,,A", res[1513].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 4770); +assertEquals("A,,A", res[1514].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 4771); +assertEquals("A,,A", res[1514].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 4772); +assertEquals(null, res[1515].exec("*** Failers", 4773)); +assertEquals(null, res[1515].exec("Ax{300}x{301}x{302}", 4774)); +assertEquals(null, res[1516].exec("Ax{300}x{301}Bx{300}X", 4775)); +assertEquals(null, res[1516].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 4776)); +assertEquals(null, res[1516].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 4777)); +assertEquals(null, res[1516].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 4778)); +assertEquals(null, res[1517].exec("Ax{300}x{301}Bx{300}X", 4779)); +assertEquals(null, res[1517].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 4780)); +assertEquals(null, res[1517].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 4781)); +assertEquals(null, res[1517].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 4782)); +assertEquals(null, res[1518].exec("12X", 4783)); +assertEquals(null, res[1518].exec("123X", 4784)); +assertEquals(null, res[1518].exec("*** Failers", 4785)); +assertEquals(null, res[1518].exec("X", 4786)); +assertEquals(null, res[1518].exec("1X", 4787)); +assertEquals(null, res[1518].exec("1234X ", 4788)); +assertEquals(null, res[1518].exec("x{100} ", 4789)); +assertEquals(null, res[1518].exec("x{101} ", 4790)); +assertEquals(null, res[1518].exec("x{2e81}x{3007}x{2f804}x{31a0}", 4791)); +assertEquals(null, res[1518].exec("** Failers", 4792)); +assertEquals(null, res[1518].exec("x{2e7f} ", 4793)); +assertEquals(null, res[1518].exec("x{3105}", 4794)); +assertEquals(null, res[1518].exec("** Failers", 4795)); +assertEquals(null, res[1518].exec("x{30ff} ", 4796)); +assertEquals(null, res[1519].exec("x{06e9}", 4797)); +assertEquals(null, res[1519].exec("x{060b}", 4798)); +assertEquals(null, res[1519].exec("** Failers", 4799)); +assertEquals(null, res[1519].exec("Xx{06e9} ", 4800)); +assertEquals(null, res[1520].exec("x{2f800}", 4801)); +assertEquals(null, res[1520].exec("** Failers", 4802)); +assertEquals(null, res[1520].exec("x{a014}", 4803)); +assertEquals(null, res[1520].exec("x{a4c6} ", 4804)); +assertEquals(null, res[1521].exec("AXYZ", 4805)); +assertEquals(null, res[1521].exec("x{1234}XYZ ", 4806)); +assertEquals(null, res[1521].exec("** Failers", 4807)); +assertEquals(null, res[1521].exec("X ", 4808)); +assertEquals(null, res[1522].exec("** Failers", 4809)); +assertEquals(null, res[1522].exec("AX", 4810)); +assertEquals(null, res[1523].exec("XYZ", 4811)); +assertEquals(null, res[1523].exec("AXYZ", 4812)); +assertEquals(null, res[1523].exec("x{1234}XYZ ", 4813)); +assertEquals(null, res[1523].exec("** Failers", 4814)); +assertEquals(null, res[1523].exec("ABXYZ ", 4815)); +assertEquals(null, res[1524].exec("XYZ", 4816)); +assertEquals(null, res[1524].exec("** Failers", 4817)); +assertEquals(null, res[1524].exec("AXYZ", 4818)); +assertEquals(null, res[1524].exec("x{1234}XYZ ", 4819)); +assertEquals(null, res[1524].exec("ABXYZ ", 4820)); +assertEquals(null, res[1524].exec("AXYZ", 4821)); +assertEquals(null, res[1524].exec("x{1234}XYZ", 4822)); +assertEquals(null, res[1524].exec("Ax{1234}XYZ", 4823)); +assertEquals(null, res[1524].exec("** Failers", 4824)); +assertEquals(null, res[1524].exec("XYZ", 4825)); +assertEquals(null, res[1524].exec("** Failers", 4826)); +assertEquals(null, res[1524].exec("AXYZ", 4827)); +assertEquals(null, res[1524].exec("x{1234}XYZ", 4828)); +assertEquals(null, res[1524].exec("Ax{1234}XYZ", 4829)); +assertEquals(null, res[1524].exec("XYZ", 4830)); +assertEquals(null, res[1525].exec("XYZ", 4831)); +assertEquals(null, res[1525].exec("AXYZ", 4832)); +assertEquals(null, res[1525].exec("x{1234}XYZ", 4833)); +assertEquals(null, res[1525].exec("Ax{1234}XYZ", 4834)); +assertEquals(null, res[1525].exec("** Failers", 4835)); +assertEquals(null, res[1526].exec("XYZ", 4836)); +assertEquals(null, res[1526].exec("** Failers", 4837)); +assertEquals(null, res[1526].exec("AXYZ", 4838)); +assertEquals(null, res[1526].exec("x{1234}XYZ", 4839)); +assertEquals(null, res[1526].exec("Ax{1234}XYZ", 4840)); +assertEquals("AX", res[1527].exec("AXYZ"), 4841); +assertEquals(null, res[1527].exec("x{1234}XYZ ", 4842)); +assertEquals(null, res[1527].exec("** Failers", 4843)); +assertEquals(null, res[1527].exec("X ", 4844)); +assertEquals(null, res[1528].exec("** Failers", 4845)); +assertEquals("AX", res[1528].exec("AX"), 4846); +assertEquals("X", res[1529].exec("XYZ"), 4847); +assertEquals("AX", res[1529].exec("AXYZ"), 4848); +assertEquals(null, res[1529].exec("x{1234}XYZ ", 4849)); +assertEquals(null, res[1529].exec("** Failers", 4850)); +assertEquals(null, res[1529].exec("ABXYZ ", 4851)); +assertEquals("X", res[1530].exec("XYZ"), 4852); +assertEquals(null, res[1530].exec("** Failers", 4853)); +assertEquals("AX", res[1530].exec("AXYZ"), 4854); +assertEquals(null, res[1530].exec("x{1234}XYZ ", 4855)); +assertEquals(null, res[1530].exec("ABXYZ ", 4856)); +assertEquals("AX", res[1531].exec("AXYZ"), 4857); +assertEquals(null, res[1531].exec("x{1234}XYZ", 4858)); +assertEquals(null, res[1531].exec("Ax{1234}XYZ", 4859)); +assertEquals(null, res[1531].exec("** Failers", 4860)); +assertEquals(null, res[1531].exec("XYZ", 4861)); +assertEquals(null, res[1532].exec("** Failers", 4862)); +assertEquals("AX", res[1532].exec("AXYZ"), 4863); +assertEquals(null, res[1532].exec("x{1234}XYZ", 4864)); +assertEquals(null, res[1532].exec("Ax{1234}XYZ", 4865)); +assertEquals(null, res[1532].exec("XYZ", 4866)); +assertEquals("X", res[1533].exec("XYZ"), 4867); +assertEquals("AX", res[1533].exec("AXYZ"), 4868); +assertEquals(null, res[1533].exec("x{1234}XYZ", 4869)); +assertEquals(null, res[1533].exec("Ax{1234}XYZ", 4870)); +assertEquals(null, res[1533].exec("** Failers", 4871)); +assertEquals("X", res[1534].exec("XYZ"), 4872); +assertEquals(null, res[1534].exec("** Failers", 4873)); +assertEquals("AX", res[1534].exec("AXYZ"), 4874); +assertEquals(null, res[1534].exec("x{1234}XYZ", 4875)); +assertEquals(null, res[1534].exec("Ax{1234}XYZ", 4876)); +assertEquals(null, res[1535].exec("abcdefgh", 4877)); +assertEquals(null, res[1535].exec("x{1234}\n\x0dx{3456}xyz ", 4878)); +assertEquals(null, res[1536].exec("abcdefgh", 4879)); +assertEquals(null, res[1536].exec("x{1234}\n\x0dx{3456}xyz ", 4880)); +assertEquals(null, res[1537].exec("** Failers", 4881)); +assertEquals(null, res[1537].exec("abcdefgh", 4882)); +assertEquals(null, res[1537].exec("x{1234}\n\x0dx{3456}xyz ", 4883)); +assertEquals(null, res[1538].exec(" AXY", 4884)); +assertEquals(null, res[1538].exec(" aXY", 4885)); +assertEquals(null, res[1538].exec(" x{1c5}XY", 4886)); +assertEquals(null, res[1538].exec(" ** Failers", 4887)); +assertEquals(null, res[1538].exec(" x{1bb}XY", 4888)); +assertEquals(null, res[1538].exec(" x{2b0}XY", 4889)); +assertEquals(null, res[1538].exec(" !XY ", 4890)); +assertEquals(null, res[1539].exec(" AXY", 4891)); +assertEquals(null, res[1539].exec(" aXY", 4892)); +assertEquals(null, res[1539].exec(" x{1c5}XY", 4893)); +assertEquals(null, res[1539].exec(" ** Failers", 4894)); +assertEquals(null, res[1539].exec(" x{1bb}XY", 4895)); +assertEquals(null, res[1539].exec(" x{2b0}XY", 4896)); +assertEquals(null, res[1539].exec(" !XY ", 4897)); +assertEquals(null, res[1539].exec(" AXY", 4898)); +assertEquals(null, res[1539].exec(" aXY", 4899)); +assertEquals(null, res[1539].exec(" AbcdeXyz ", 4900)); +assertEquals(null, res[1539].exec(" x{1c5}AbXY", 4901)); +assertEquals(null, res[1539].exec(" abcDEXypqreXlmn ", 4902)); +assertEquals(null, res[1539].exec(" ** Failers", 4903)); +assertEquals(null, res[1539].exec(" x{1bb}XY", 4904)); +assertEquals(null, res[1539].exec(" x{2b0}XY", 4905)); +assertEquals(null, res[1539].exec(" !XY ", 4906)); +assertEquals(null, res[1540].exec(" AXY", 4907)); +assertEquals(null, res[1540].exec(" aXY", 4908)); +assertEquals(null, res[1540].exec(" AbcdeXyz ", 4909)); +assertEquals(null, res[1540].exec(" x{1c5}AbXY", 4910)); +assertEquals(null, res[1540].exec(" abcDEXypqreXlmn ", 4911)); +assertEquals(null, res[1540].exec(" ** Failers", 4912)); +assertEquals(null, res[1540].exec(" x{1bb}XY", 4913)); +assertEquals(null, res[1540].exec(" x{2b0}XY", 4914)); +assertEquals(null, res[1540].exec(" !XY ", 4915)); +assertEquals(null, res[1540].exec(" AXY", 4916)); +assertEquals(null, res[1540].exec(" aXY", 4917)); +assertEquals(null, res[1540].exec(" AbcdeXyz ", 4918)); +assertEquals(null, res[1540].exec(" x{1c5}AbXY", 4919)); +assertEquals(null, res[1540].exec(" abcDEXypqreXlmn ", 4920)); +assertEquals(null, res[1540].exec(" ** Failers", 4921)); +assertEquals(null, res[1540].exec(" x{1bb}XY", 4922)); +assertEquals(null, res[1540].exec(" x{2b0}XY", 4923)); +assertEquals(null, res[1540].exec(" !XY ", 4924)); +assertEquals(null, res[1541].exec(" AXY", 4925)); +assertEquals(null, res[1541].exec(" aXY", 4926)); +assertEquals(null, res[1541].exec(" AbcdeXyz ", 4927)); +assertEquals(null, res[1541].exec(" x{1c5}AbXY", 4928)); +assertEquals(null, res[1541].exec(" abcDEXypqreXlmn ", 4929)); +assertEquals(null, res[1541].exec(" ** Failers", 4930)); +assertEquals(null, res[1541].exec(" x{1bb}XY", 4931)); +assertEquals(null, res[1541].exec(" x{2b0}XY", 4932)); +assertEquals(null, res[1541].exec(" !XY ", 4933)); +assertEquals(null, res[1542].exec(" !XY", 4934)); +assertEquals(null, res[1542].exec(" x{1bb}XY", 4935)); +assertEquals(null, res[1542].exec(" x{2b0}XY", 4936)); +assertEquals(null, res[1542].exec(" ** Failers", 4937)); +assertEquals(null, res[1542].exec(" x{1c5}XY", 4938)); +assertEquals(null, res[1542].exec(" AXY ", 4939)); +assertEquals(null, res[1543].exec(" !XY", 4940)); +assertEquals(null, res[1543].exec(" x{1bb}XY", 4941)); +assertEquals(null, res[1543].exec(" x{2b0}XY", 4942)); +assertEquals(null, res[1543].exec(" ** Failers", 4943)); +assertEquals(null, res[1543].exec(" x{1c5}XY", 4944)); +assertEquals(null, res[1543].exec(" AXY ", 4945)); +assertEquals(null, res[1543].exec("x{c0}x{e0}x{116}x{117}", 4946)); +assertEquals(null, res[1543].exec("x{c0}x{e0}x{116}x{117}", 4947)); +assertEquals(null, res[1545].exec("123abcdefg", 4948)); +assertEquals(null, res[1545].exec("123abc\xc4\xc5zz", 4949)); +assertEquals(null, res[1546].exec("x{102A4}x{AA52}x{A91D}x{1C46}x{10283}x{1092E}x{1C6B}x{A93B}x{A8BF}x{1BA0}x{A50A}====", 4950)); +assertEquals(null, res[1546].exec("x{a77d}x{1d79}", 4951)); +assertEquals(null, res[1546].exec("x{1d79}x{a77d} ", 4952)); +assertEquals(null, res[1546].exec("x{a77d}x{1d79}", 4953)); +assertEquals(null, res[1546].exec("** Failers ", 4954)); +assertEquals(null, res[1546].exec("x{1d79}x{a77d} ", 4955)); +assertThrows("var re = //;", 4956); diff --git a/deps/v8/test/mozilla/mozilla.status b/deps/v8/test/mozilla/mozilla.status index 9793dc8318..c92bfa6bd9 100644 --- a/deps/v8/test/mozilla/mozilla.status +++ b/deps/v8/test/mozilla/mozilla.status @@ -217,6 +217,8 @@ js1_5/Function/regress-338121-01: FAIL_OK js1_5/Function/regress-338121-02: FAIL_OK js1_5/Function/regress-338121-03: FAIL_OK +# Expectes 'prototype' property of functions to be enumerable. +js1_5/Function/10.1.6-01: FAIL_OK # Length of objects whose prototype chain includes a function ecma_3/Function/regress-313570: FAIL_OK @@ -567,11 +569,6 @@ js1_5/Array/regress-350256-02: FAIL ecma_3/Function/regress-137181: FAIL -# Tests that rely on specific details of function decompilation or -# print strings for errors. Non-ECMA behavior. -js1_4/Regress/function-003: FAIL - - # 'export' and 'import' are not keywords in V8. ecma_2/Exceptions/lexical-010: FAIL ecma_2/Exceptions/lexical-022: FAIL diff --git a/deps/v8/tools/gyp/v8.gyp b/deps/v8/tools/gyp/v8.gyp index 22a15e2460..8af8f22bef 100644 --- a/deps/v8/tools/gyp/v8.gyp +++ b/deps/v8/tools/gyp/v8.gyp @@ -279,6 +279,8 @@ '../../src/heap-inl.h', '../../src/heap.cc', '../../src/heap.h', + '../../src/heap-profiler.cc', + '../../src/heap-profiler.h', '../../src/ic-inl.h', '../../src/ic.cc', '../../src/ic.h', diff --git a/deps/v8/tools/run-valgrind.py b/deps/v8/tools/run-valgrind.py index 8a0869cbaa..49c1b70312 100755 --- a/deps/v8/tools/run-valgrind.py +++ b/deps/v8/tools/run-valgrind.py @@ -58,7 +58,7 @@ if code != 0: # have any definitely, indirectly, and possibly lost bytes. LEAK_RE = r"(?:definitely|indirectly|possibly) lost: " LEAK_LINE_MATCHER = re.compile(LEAK_RE) -LEAK_OKAY_MATCHER = re.compile(r"lost: 0 bytes in 0 blocks.") +LEAK_OKAY_MATCHER = re.compile(r"lost: 0 bytes in 0 blocks") leaks = [] for line in errors: if LEAK_LINE_MATCHER.search(line): diff --git a/deps/v8/tools/v8.xcodeproj/project.pbxproj b/deps/v8/tools/v8.xcodeproj/project.pbxproj index 79ece72d7b..2d386811e1 100644 --- a/deps/v8/tools/v8.xcodeproj/project.pbxproj +++ b/deps/v8/tools/v8.xcodeproj/project.pbxproj @@ -207,6 +207,8 @@ 89F23C9F0E78D604006B2466 /* simulator-arm.cc in Sources */ = {isa = PBXBuildFile; fileRef = 897FF17D0E719B8F00D62E90 /* simulator-arm.cc */; }; 89F23CA00E78D609006B2466 /* stub-cache-arm.cc in Sources */ = {isa = PBXBuildFile; fileRef = 897FF18A0E719B8F00D62E90 /* stub-cache-arm.cc */; }; 89FB0E3A0F8E533F00B04B3C /* d8-posix.cc in Sources */ = {isa = PBXBuildFile; fileRef = 89FB0E360F8E531900B04B3C /* d8-posix.cc */; }; + 9F11D9A0105AF0A300EBE5B2 /* heap-profiler.cc in Sources */ = {isa = PBXBuildFile; fileRef = 9F11D99E105AF0A300EBE5B2 /* heap-profiler.cc */; }; + 9F11D9A1105AF0A300EBE5B2 /* heap-profiler.cc in Sources */ = {isa = PBXBuildFile; fileRef = 9F11D99E105AF0A300EBE5B2 /* heap-profiler.cc */; }; 9F4B7B890FCC877A00DC4117 /* log-utils.cc in Sources */ = {isa = PBXBuildFile; fileRef = 9F4B7B870FCC877A00DC4117 /* log-utils.cc */; }; 9F4B7B8A0FCC877A00DC4117 /* log-utils.cc in Sources */ = {isa = PBXBuildFile; fileRef = 9F4B7B870FCC877A00DC4117 /* log-utils.cc */; }; 9F92FAA90F8F28AD0089F02C /* func-name-inferrer.cc in Sources */ = {isa = PBXBuildFile; fileRef = 9F92FAA70F8F28AD0089F02C /* func-name-inferrer.cc */; }; @@ -533,6 +535,8 @@ 89F23C950E78D5B6006B2466 /* v8_shell-arm */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "v8_shell-arm"; sourceTree = BUILT_PRODUCTS_DIR; }; 89FB0E360F8E531900B04B3C /* d8-posix.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = "d8-posix.cc"; path = "../src/d8-posix.cc"; sourceTree = ""; }; 89FB0E370F8E531900B04B3C /* d8-windows.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = "d8-windows.cc"; path = "../src/d8-windows.cc"; sourceTree = ""; }; + 9F11D99E105AF0A300EBE5B2 /* heap-profiler.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "heap-profiler.cc"; sourceTree = ""; }; + 9F11D99F105AF0A300EBE5B2 /* heap-profiler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "heap-profiler.h"; sourceTree = ""; }; 9F4B7B870FCC877A00DC4117 /* log-utils.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "log-utils.cc"; sourceTree = ""; }; 9F4B7B880FCC877A00DC4117 /* log-utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "log-utils.h"; sourceTree = ""; }; 9F92FAA70F8F28AD0089F02C /* func-name-inferrer.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "func-name-inferrer.cc"; sourceTree = ""; }; @@ -626,7 +630,6 @@ 897FF0D70E719AB300D62E90 /* C++ */ = { isa = PBXGroup; children = ( - 22A76C900FF259E600FDC694 /* log-inl.h */, 897FF0F60E719B8F00D62E90 /* accessors.cc */, 897FF0F70E719B8F00D62E90 /* accessors.h */, 897FF0F80E719B8F00D62E90 /* allocation.cc */, @@ -725,6 +728,8 @@ 897FF1460E719B8F00D62E90 /* heap-inl.h */, 897FF1470E719B8F00D62E90 /* heap.cc */, 897FF1480E719B8F00D62E90 /* heap.h */, + 9F11D99E105AF0A300EBE5B2 /* heap-profiler.cc */, + 9F11D99F105AF0A300EBE5B2 /* heap-profiler.h */, 897FF1490E719B8F00D62E90 /* ic-arm.cc */, 897FF14A0E719B8F00D62E90 /* ic-ia32.cc */, 897FF14B0E719B8F00D62E90 /* ic-inl.h */, @@ -742,6 +747,7 @@ 897FF1510E719B8F00D62E90 /* list.h */, 897FF1520E719B8F00D62E90 /* log.cc */, 897FF1530E719B8F00D62E90 /* log.h */, + 22A76C900FF259E600FDC694 /* log-inl.h */, 9F4B7B870FCC877A00DC4117 /* log-utils.cc */, 9F4B7B880FCC877A00DC4117 /* log-utils.h */, 897FF1540E719B8F00D62E90 /* macro-assembler-arm.cc */, @@ -1201,6 +1207,7 @@ 89A88E2E0E71A6D60043BA31 /* zone.cc in Sources */, 9F4B7B890FCC877A00DC4117 /* log-utils.cc in Sources */, 8981F6001010501900D1520E /* frame-element.cc in Sources */, + 9F11D9A0105AF0A300EBE5B2 /* heap-profiler.cc in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -1306,6 +1313,7 @@ 89F23C820E78D5B2006B2466 /* zone.cc in Sources */, 9F4B7B8A0FCC877A00DC4117 /* log-utils.cc in Sources */, 8981F6011010502800D1520E /* frame-element.cc in Sources */, + 9F11D9A1105AF0A300EBE5B2 /* heap-profiler.cc in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; diff --git a/deps/v8/tools/visual_studio/v8_base.vcproj b/deps/v8/tools/visual_studio/v8_base.vcproj index 421cc7ce95..f402e8b6e5 100644 --- a/deps/v8/tools/visual_studio/v8_base.vcproj +++ b/deps/v8/tools/visual_studio/v8_base.vcproj @@ -488,6 +488,14 @@ RelativePath="..\..\src\heap.h" > + + + + diff --git a/deps/v8/tools/visual_studio/v8_base_arm.vcproj b/deps/v8/tools/visual_studio/v8_base_arm.vcproj index ee8e339920..f0ba07a674 100644 --- a/deps/v8/tools/visual_studio/v8_base_arm.vcproj +++ b/deps/v8/tools/visual_studio/v8_base_arm.vcproj @@ -496,6 +496,14 @@ RelativePath="..\..\src\heap.h" > + + + + diff --git a/deps/v8/tools/visual_studio/v8_base_x64.vcproj b/deps/v8/tools/visual_studio/v8_base_x64.vcproj index 1e27824629..d403da0ecd 100644 --- a/deps/v8/tools/visual_studio/v8_base_x64.vcproj +++ b/deps/v8/tools/visual_studio/v8_base_x64.vcproj @@ -488,6 +488,14 @@ RelativePath="..\..\src\heap.h" > + + + + diff --git a/deps/v8/tools/visual_studio/v8_cctest.vcproj b/deps/v8/tools/visual_studio/v8_cctest.vcproj index ec078894ff..d1cf2e84cf 100644 --- a/deps/v8/tools/visual_studio/v8_cctest.vcproj +++ b/deps/v8/tools/visual_studio/v8_cctest.vcproj @@ -197,6 +197,10 @@ RelativePath="..\..\test\cctest\test-heap.cc" > + + diff --git a/deps/v8/tools/visual_studio/v8_cctest_arm.vcproj b/deps/v8/tools/visual_studio/v8_cctest_arm.vcproj index bd49f3b062..968d13472e 100644 --- a/deps/v8/tools/visual_studio/v8_cctest_arm.vcproj +++ b/deps/v8/tools/visual_studio/v8_cctest_arm.vcproj @@ -193,6 +193,10 @@ RelativePath="..\..\test\cctest\test-heap.cc" > + + diff --git a/deps/v8/tools/visual_studio/v8_cctest_x64.vcproj b/deps/v8/tools/visual_studio/v8_cctest_x64.vcproj index d0fbac63ae..78db1a4aa9 100644 --- a/deps/v8/tools/visual_studio/v8_cctest_x64.vcproj +++ b/deps/v8/tools/visual_studio/v8_cctest_x64.vcproj @@ -199,6 +199,10 @@ RelativePath="..\..\test\cctest\test-heap.cc" > + + -- cgit v1.2.3