From: Karl Williamson Date: Sun, 22 Nov 2009 06:45:28 +0000 (-0700) Subject: mktables revamp X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=99870f4d255a0df2e3a0799d805210bab9040380;p=p5sagit%2Fp5-mst-13.2.git mktables revamp --- diff --git a/MANIFEST b/MANIFEST index b857ae1..5cedb1f 100644 --- a/MANIFEST +++ b/MANIFEST @@ -3975,6 +3975,7 @@ pod/perltrap.pod Perl traps for the unwary pod/perlunicode.pod Perl Unicode support pod/perlunifaq.pod Perl Unicode FAQ pod/perluniintro.pod Perl Unicode introduction +pod/perluniprops.pod Perl Unicode property index pod/perlunitut.pod Perl Unicode tutorial pod/perlutil.pod utilities packaged with the Perl distribution pod/perlvar.pod Perl predefined variables @@ -4544,6 +4545,7 @@ t/re/substr_thr.t See if substr works in another thread t/re/subst.t See if substitution works t/re/substT.t See if substitution works with -T t/re/subst_wamp.t See if substitution works with $& present +t/re/uniprops.t Test unicode \p{} regex constructs t/run/cloexec.t Test close-on-exec. t/run/exit.t Test perl's exit status. t/run/fresh_perl.t Tests that require a fresh perl. diff --git a/lib/unicore/Makefile b/lib/unicore/Makefile index b73d3b8..0dd77b7 100644 --- a/lib/unicore/Makefile +++ b/lib/unicore/Makefile @@ -1,12 +1,6 @@ all: - ../../miniperl -I../../lib ./mktables - -TestProp.pl: mktables UnicodeData.txt Scripts.txt Blocks.txt PropList.txt - ../../miniperl -I../../lib ./mktables -maketest - -test: TestProp.pl - ../../miniperl -I../../lib TestProp.pl + ../../miniperl -I../../lib ./mktables -P ../../pod -T ../../t/re/uniprops.t -makelist clean: - rm -f *.pl */*.pl */*/*.pl - rm -f Properties + rm -fr *.pl To lib + rm -f ../../pod/perluniprops.pod ../../t/re/uniprops.t mktables.lst diff --git a/lib/unicore/README.perl b/lib/unicore/README.perl index 96b2caa..7515825 100644 --- a/lib/unicore/README.perl +++ b/lib/unicore/README.perl @@ -1,11 +1,17 @@ The *.txt files were copied from - http://www.unicode.org/Public/5.1.0/ucd + ftp://www.unicode.org/Public/UNIDATA -and subdirectories 'extracted' and 'auxiliary' as of Unicode 5.1.0 (March 2008). +with subdirectories 'extracted' and 'auxiliary' -The big file, Unihan.txt (28 MB, 5.8 MB zip) was not included due to space -considerations. Also NOT included were any *.html files and *Test.txt files. +The Unihan files were not included due to space considerations. Also NOT +included were any *.html files and *Test.txt files. It is possible to add the +Unihan files, and edit mktables (see instructions near its beginning) to look +at them. + +The file 'version' should exist and be a single line with the Unicode version, +like: +5.2.0 To be 8.3 filesystem friendly, the names of some of the input files have been changed from the values that are in the Unicode DB: @@ -27,42 +33,68 @@ mv extracted/DerivedLineBreak.txt extracted/DLineBreak.txt mv extracted/DerivedNumericType.txt extracted/DNumType.txt mv extracted/DerivedNumericValues.txt extracted/DNumValues.txt -The names of files, such as test files, that are not used by mktables are not -changed, and will not work correctly on 8.3 filesystems. +If you have the Unihan database (5.2 and above), you should also do the +following: -The file 'version' should exist and be a single line with the Unicode version, -like -5.1.0 +mv Unihan_DictionaryIndices.txt UnihanIndicesDictionary.txt +mv Unihan_DictionaryLikeData.txt UnihanDataDictionaryLike.txt +mv Unihan_IRGSources.txt UnihanIRGSources.txt +mv Unihan_NumericValues.txt UnihanNumericValues.txt +mv Unihan_OtherMappings.txt UnihanOtherMappings.txt +mv Unihan_RadicalStrokeCounts.txt UnihanRadicalStrokeCounts.txt +mv Unihan_Readings.txt UnihanReadings.txt +mv Unihan_Variants.txt UnihanVariants.txt + +If you download everything, the names of files, such as test files, that are +not used by mktables are not changed by the above, and will not work correctly +as-is on 8.3 filesystems. + +mktables is used to generate the tables used by the rest of Perl. It will warn +you about any *.txt files in the directory substructure that it doesn't know +about. You should remove any so-identified, or edit mktables to add them to +its lists to process. You can run + + mktables -globlist + +to have it try to process these tables generically. + +If any files are added, deleted, or their names change, you must run -NOTE: If you modify the input file set you should also run - mktables -makelist - -which will recreate the mktables.lst file which is used to speed up -the build process. + +to generate a new list of all the files. FOR PUMPKINS -The files are inter-related. If you take the latest UnicodeData.txt, for example, -but leave the older versions of other files, there can be subtle problems. +The files are inter-related. If you take the latest UnicodeData.txt, for +example, but leave the older versions of other files, there can be subtle +problems. + +When moving to a new version of Unicode, you need to update 'version' by hand + + p4 edit version + ... + +You should look in the Unicode release notes (which are probably towards the +bottom of http://www.unicode.org/reports/tr44/) to see if any properties have +newly been moved to be Obsolete, Deprecated, or Stabilized. The full names for +these should be added to the respective lists near the beginning of mktables, +using an 'if' to add them for just this Unicode version going forward, so that +mktables can continue to be used for earlier Unicode versions. + +When putting out a new Perl release, think about if any of the Deprecated +properties should be moved to Suppressed. The *.pl files are generated from the *.txt files by the mktables script, more recently done during the Perl build process, but if you want to try the old manual way: cd lib/unicore - cp .../UnicodeOriginal/*.txt . - rm NormalizationTest.txt Unihan.txt Derived*.txt - p4 edit Properties *.pl */*.pl - perl ./mktables + p4 edit *.pl */*.pl */*/*.pl + perl ./mktables -P ../../pod -T ../../t/re/uniprops.t -makelist p4 revert -a cd ../.. perl Porting/manicheck - -You need to update version by hand - - p4 edit version - ... If any new (or deleted, unlikely but not impossible) *.pl files are indicated: @@ -78,4 +110,4 @@ And finally: p4 submit -- -jhi@iki.fi; updated by nick@ccl4.org +jhi@iki.fi; updated by nick@ccl4.org, public@khwilliamson.com diff --git a/lib/unicore/mktables b/lib/unicore/mktables index 6ab4e70..abd44f5 100644 --- a/lib/unicore/mktables +++ b/lib/unicore/mktables @@ -1,2232 +1,13697 @@ -## !!!!!!!!!!!!!! IF YOU MODIFY THIS FILE !!!!!!!!!!!!!!!!!!!!!!!!! -## Any files created or read by this program should be listed in 'mktables.lst' - #!/usr/bin/perl -w -require 5.008; # Needs pack "U". Probably safest to run on 5.8.x + +# !!!!!!!!!!!!!! IF YOU MODIFY THIS FILE !!!!!!!!!!!!!!!!!!!!!!!!! +# Any files created or read by this program should be listed in 'mktables.lst' +# Use -makelist to regenerate it. + +require 5.008; # Needs pack "U". Probably safest to run on 5.8.x use strict; +use warnings; use Carp; +use File::Find; +use File::Path; use File::Spec; -use Text::Tabs (); ## using this makes the files about half the size - -## -## mktables -- create the runtime Perl Unicode files (lib/unicore/**/*.pl) -## from the Unicode database files (lib/unicore/*.txt). -## - -## "Fuzzy" means this section in Unicode TR18: -## -## The recommended names for UCD properties and property values are in -## PropertyAliases.txt [Prop] and PropertyValueAliases.txt -## [PropValue]. There are both abbreviated names and longer, more -## descriptive names. It is strongly recommended that both names be -## recognized, and that loose matching of property names be used, -## whereby the case distinctions, whitespace, hyphens, and underbar -## are ignored. - -## Base names already used in lib/gc_sc (for avoiding 8.3 conflicts) -my %BaseNames; - -## -## Process any args. -## -my $Verbose = 0; -my $MakeTestScript = 0; -my $AlwaysWrite = 0; -my $UseDir = ""; -my $FileList = "$0.lst"; -my $MakeList = 0; - -while (@ARGV) -{ +use Text::Tabs; + +sub DEBUG () { 0 } # Set to 0 for production; 1 for development + +########################################################################## +# +# mktables -- create the runtime Perl Unicode files (lib/unicore/.../*.pl), +# from the Unicode database files (lib/unicore/.../*.txt), It also generates +# a pod file and a .t file +# +# The structure of this file is: +# First these introductory comments; then +# code needed for everywhere, such as debugging stuff; then +# code to handle input parameters; then +# data structures likely to be of external interest (some of which depend on +# the input parameters, so follows them; then +# more data structures and subroutine and package (class) definitions; then +# the small actual loop to process the input files and finish up; then +# a __DATA__ section, for the .t tests +# +# This program works on all releases of Unicode through at least 5.2. The +# outputs have been scrutinized most intently for release 5.1. The others +# have been checked for somewhat more than just sanity. It can handle all +# existing Unicode character properties in those releases. +# +# This program needs to be able to run under miniperl. Therefore, it uses a +# minimum of other modules, and hence implements some things itself that could +# be gotten from CPAN +# +# This program uses inputs published by the Unicode Consortium. These can +# change incompatibly between releases without the Perl maintainers realizing +# it. Therefore this program is now designed to try to flag these. It looks +# at the directories where the inputs are, and flags any unrecognized files. +# It keeps track of all the properties in the files it handles, and flags any +# that it doesn't know how to handle. It also flags any input lines that +# don't match the expected syntax, among other checks. +# It is also designed so if a new input file matches one of the known +# templates, one hopefully just needs to add it to a list to have it +# processed. +# +# It tries to keep fatal errors to a minimum, to generate something usable for +# testing purposes. It always looks for files that could be inputs, and will +# warn about any that it doesn't know how to handle (the -q option suppresses +# the warning). +# +# This program is mostly about Unicode character (or code point) properties. +# A property describes some attribute or quality of a code point, like if it +# is lowercase or not, its name, what version of Unicode it was first defined +# in, or what its uppercase equivalent is. Unicode deals with these disparate +# possibilities by making all properties into mappings from each code point +# into some corresponding value. In the case of it being lowercase or not, +# the mapping is either to 'Y' or 'N' (or various synonyms thereof). Each +# property maps each Unicode code point to a single value, called a "property +# value". (Hence each Unicode property is a true mathematical function with +# exactly one value per code point.) +# +# When using a property in a regular expression, what is desired isn't the +# mapping of the code point to its property's value, but the reverse (or the +# mathematical "inverse relation"): starting with the property value, "Does a +# code point map to it?" These are written in a "compound" form: +# \p{property=value}, e.g., \p{category=punctuation}. This program generates +# files containing the lists of code points that map to each such regular +# expression property value, one file per list +# +# There is also a single form shortcut that Perl adds for many of the commonly +# used properties. This happens for all binary properties, plus script, +# general_category, and block properties. +# +# Thus the outputs of this program are files. There are map files, mostly in +# the 'To' directory; and there are list files for use in regular expression +# matching, all in subdirectories of the 'lib' directory, with each +# subdirectory being named for the property that the lists in it are for. +# Bookkeeping, test, and documentation files are also generated. + +my $matches_directory = 'lib'; # Where match (\p{}) files go. +my $map_directory = 'To'; # Where map files go. + +# DATA STRUCTURES +# +# The major data structures of this program are Property, of course, but also +# Table. There are two kinds of tables, very similar to each other. +# "Match_Table" is the data structure giving the list of code points that have +# a particular property value, mentioned above. There is also a "Map_Table" +# data structure which gives the property's mapping from code point to value. +# There are two structures because the match tables need to be combined in +# various ways, such as constructing unions, intersections, complements, etc., +# and the map ones don't. And there would be problems, perhaps subtle, if +# a map table were inadvertently operated on in some of those ways. +# The use of separate classes with operations defined on one but not the other +# prevents accidentally confusing the two. +# +# At the heart of each table's data structure is a "Range_List", which is just +# an ordered list of "Ranges", plus ancillary information, and methods to +# operate on them. A Range is a compact way to store property information. +# Each range has a starting code point, an ending code point, and a value that +# is meant to apply to all the code points between the two end points, +# inclusive. For a map table, this value is the property value for those +# code points. Two such ranges could be written like this: +# 0x41 .. 0x5A, 'Upper', +# 0x61 .. 0x7A, 'Lower' +# +# Each range also has a type used as a convenience to classify the values. +# Most ranges in this program will be Type 0, or normal, but there are some +# ranges that have a non-zero type. These are used only in map tables, and +# are for mappings that don't fit into the normal scheme of things. Mappings +# that require a hash entry to communicate with utf8.c are one example; +# another example is mappings for charnames.pm to use which indicate a name +# that is algorithmically determinable from its code point (and vice-versa). +# These are used to significantly compact these tables, instead of listing +# each one of the tens of thousands individually. +# +# In a match table, the value of a range is irrelevant (and hence the type as +# well, which will always be 0), and arbitrarily set to the null string. +# Using the example above, there would be two match tables for those two +# entries, one named Upper would contain the 0x41..0x5A range, and the other +# named Lower would contain 0x61..0x7A. +# +# Actually, there are two types of range lists, "Range_Map" is the one +# associated with map tables, and "Range_List" with match tables. +# Again, this is so that methods can be defined on one and not the other so as +# to prevent operating on them in incorrect ways. +# +# Eventually, most tables are written out to files to be read by utf8_heavy.pl +# in the perl core. All tables could in theory be written, but some are +# suppressed because there is no current practical use for them. It is easy +# to change which get written by changing various lists that are near the top +# of the actual code in this file. The table data structures contain enough +# ancillary information to allow them to be treated as separate entities for +# writing, such as the path to each one's file. There is a heading in each +# map table that gives the format of its entries, and what the map is for all +# the code points missing from it. (This allows tables to be more compact.) + +# The Property data structure contains one or more tables. All properties +# contain a map table (except the $perl property which is a +# pseudo-property containing only match tables), and any properties that +# are usable in regular expression matches also contain various matching +# tables, one for each value the property can have. A binary property can +# have two values, True and False (or Y and N, which are preferred by Unicode +# terminology). Thus each of these properties will have a map table that +# takes every code point and maps it to Y or N (but having ranges cuts the +# number of entries in that table way down), and two match tables, one +# which has a list of all the code points that map to Y, and one for all the +# code points that map to N. (For each of these, a third table is also +# generated for the pseudo Perl property. It contains the identical code +# points as the Y table, but can be written, not in the compound form, but in +# a "single" form like \p{IsUppercase}.) Many properties are binary, but some +# properties have several possible values, some have many, and properties like +# Name have a different value for every named code point. Those will not, +# unless the controlling lists are changed, have their match tables written +# out. But all the ones which can be used in regular expression \p{} and \P{} +# constructs will. Generally a property will have either its map table or its +# match tables written but not both. Again, what gets written is controlled +# by lists which can easily be changed. + +# For information about the Unicode properties, see Unicode's UAX44 document: + +my $unicode_reference_url = 'http://www.unicode.org/reports/tr44/'; + +# As stated earlier, this program will work on any release of Unicode so far. +# Most obvious problems in earlier data have NOT been corrected except when +# necessary to make Perl or this program work reasonably. For example, no +# folding information was given in early releases, so this program uses the +# substitute of lower case, just so that a regular expression with the /i +# option will do something that actually gives the right results in many +# cases. There are also a couple other corrections for version 1.1.5, +# commented at the point they are made. As an example of corrections that +# weren't made (but could be) is this statement from DerivedAge.txt: "The +# supplementary private use code points and the non-character code points were +# assigned in version 2.0, but not specifically listed in the UCD until +# versions 3.0 and 3.1 respectively." (To be precise it was 3.0.1 not 3.0.0) +# More information on Unicode version glitches is further down in these +# introductory comments. +# +# This program works on all properties as of 5.2, though the files for some +# are suppressed from apparent lack of demand for. You can change which are +# output by changing lists in this program. + +# The old version of mktables emphasized the term "Fuzzy" to mean Unocde's +# loose matchings rules (from Unicode TR18): +# +# The recommended names for UCD properties and property values are in +# PropertyAliases.txt [Prop] and PropertyValueAliases.txt +# [PropValue]. There are both abbreviated names and longer, more +# descriptive names. It is strongly recommended that both names be +# recognized, and that loose matching of property names be used, +# whereby the case distinctions, whitespace, hyphens, and underbar +# are ignored. +# The program still allows Fuzzy to override its determination of if loose +# matching should be used, but it isn't currently used, as it is no longer +# needed; the calculations it makes are good enough. + +# SUMMARY OF HOW IT WORKS: +# +# Process arguments +# +# A list is constructed containing each input file that is to be processed +# +# Each file on the list is processed in a loop, using the associated handler +# code for each: +# The PropertyAliases.txt and PropValueAliases.txt files are processed +# first. These files name the properties and property values. +# Objects are created of all the property and property value names +# that the rest of the input should expect, including all synonyms. +# The other input files give mappings from properties to property +# values. That is, they list code points and say what the mapping +# is under the given property. Some files give the mappings for +# just one property; and some for many. This program goes through +# each file and populates the properties from them. Some properties +# are listed in more than one file, and Unicode has set up a +# precedence as to which has priority if there is a conflict. Thus +# the order of processing matters, and this program handles the +# conflict possibility by processing the overriding input files +# last, so that if necessary they replace earlier values. +# After this is all done, the program creates the property mappings not +# furnished by Unicode, but derivable from what it does give. +# The tables of code points that match each property value in each +# property that is accessible by regular expressions are created. +# The Perl-defined properties are created and populated. Many of these +# require data determined from the earlier steps +# Any Perl-defined synonyms are created, and name clashes between Perl +# and Unicode are reconciled. +# All the properties are written to files +# Any other files are written, and final warnings issued. + +# As mentioned above, some properties are given in more than one file. In +# particular, the files in the extracted directory are supposedly just +# reformattings of the others. But they contain information not easily +# derivable from the other files, including results for Unihan, which this +# program doesn't ordinarily look at, and for unassigned code points. They +# also have historically had errors or been incomplete. In an attempt to +# create the best possible data, this program thus processes them first to +# glean information missing from the other files; then processes those other +# files to override any errors in the extracted ones. + +# For clarity, a number of operators have been overloaded to work on tables: +# ~ means invert (take all characters not in the set). The more +# conventional '!' is not used because of the possibility of confusing +# it with the actual boolean operation. +# + means union +# - means subtraction +# & means intersection +# The precedence of these is the order listed. Parentheses should be +# copiously used. These are not a general scheme. The operations aren't +# defined for a number of things, deliberately, to avoid getting into trouble. +# Operations are done on references and affect the underlying structures, so +# that the copy constructors for them have been overloaded to not return a new +# clone, but the input object itself. + +# The bool operator is deliberately not overloaded to avoid confusion with +# "should it mean if the object merely exists, or also is non-empty?". + +# +# WHY CERTAIN DESIGN DECISIONS WERE MADE + +# XXX These comments need more work. +# +# Why have files written out for binary 'N' matches? +# For binary properties, if you know the mapping for either Y or N; the +# other is trivial to construct, so could be done at Perl run-time instead +# of having a file for it. That is, if someone types in \p{foo: N}, Perl +# could translate that to \P{foo: Y} and not need a file. The problem is +# communicating to Perl that a given property is binary. Perl can't figure +# it out from looking at the N (or No), as some non-binary properties have +# these as property values. +# Why +# There are several types of properties, based on what form their values can +# take on. These are described in more detail below in the DATA STRUCTURES +# section of these comments, but for now, you should know that there are +# string properties, whose values are strings of one or more code points (such +# as the Uppercase_mapping property); every other property maps to some other +# form, like true or false, or a number, or a name, etc. The reason there are +# two directories for map files is because of the way utf8.c works. It +# expects that any files there are string properties, that is that the +# mappings are each to one code point, with mappings in multiple code points +# handled specially in an extra hash data structure. Digit.pl is a table that +# is written there for historical reasons, even though it doesn't fit that +# mold. Thus it can't currently be looked at by the Perl core. +# +# There are no match tables generated for matches of the null string. These +# would like like \p{JSN=}. Perhaps something like them could be added if +# necessary. The JSN does have a real code point U+110B that maps to the null +# string, but it is a contributory property, and therefore not output by +# default. +# +# FUTURE ISSUES +# +# The program would break if Unicode were to change its names so that +# interior white space, underscores, or dashes differences were significant +# within property and property value names. +# +# It might be easier to use the xml versions of the UCD if this program ever +# would need heavy revision, and the ability to handle old versions was not +# required. +# +# There is the potential for name collisions, in that Perl has chosen names +# that Unicode could decide it also likes. There have been such collisions in +# the past, with mostly Perl deciding to adopt the Unicode definition of the +# name. However in the 5.2 Unicode beta testing, there were a number of such +# collisions, which were withdrawn before the final release, because of Perl's +# and other's protests. These all involved new properties which began with +# 'Is'. Based on the protests, Unicode is unlikely to try that again. Also, +# many of the Perl-defined synonyms, like Any, Word, etc, are listed in a +# Unicode document, so they are unlikely to be used by Unicode for another +# purpose. However, they might try something beginning with 'In', or use any +# of the other Perl-defined properties. This program will warn you of name +# collisions, and refuse to generate tables with them, but manual intervention +# will be required in this event. One scheme that could be implemented, if +# necessary, would be to have this program generate another file, or add a +# field to mktables.lst that gives the date of first definition of a property. +# Each new release of Unicode would use that file as a basis for the next +# iteration. And the Perl synonym addition code could sort based on the age +# of the property, so older properties get priority, and newer ones that clash +# would be refused; hence existing code would not be impacted, and some other +# synonym would have to be used for the new property. This is ugly, and +# manual intervention would certainly be easier to do in the short run; lets +# hope it never comes to this. + +# A NOTE ON UNIHAN +# +# This program can generate tables from the Unihan database. But it doesn't +# by default, letting the CPAN module Unicode::Unihan handle them. Prior to +# version 5.2, this database was in a single file, Unihan.txt. In 5.2 the +# database was split into 8 different files, all beginning with the letters +# 'Unihan'. This program will read those file(s) if present, but it needs to +# know which of the many properties in the file(s) should have tables created +# for them. It will create tables for any properties listed in +# PropertyAliases.txt and PropValueAliases.txt, plus any listed in the +# @cjk_properties array and the @cjk_property_values array. Thus, if a +# property you want is not in those files of the release you are building +# against, you must add it to those two arrays. Starting in 4.0, the +# Unicode_Radical_Stroke was listed in those files, so if the Unihan database +# is present in the directory, a table will be generated for that property. +# In 5.2, several more properties were added. For your convenience, the two +# arrays are initialized with all the 5.2 listed properties that are also in +# earlier releases. But these are commented out. You can just uncomment the +# ones you want, or use them as a template for adding entries for other +# properties. +# +# You may need to adjust the entries to suit your purposes. setup_unihan(), +# and filter_unihan_line() are the functions where this is done. This program +# already does some adjusting to make the lines look more like the rest of the +# Unicode DB; You can see what that is in filter_unihan_line() +# +# There is a bug in the 3.2 data file in which some values for the +# kPrimaryNumeric property have commas and an unexpected comment. A filter +# could be added for these; or for a particular installation, the Unihan.txt +# file could be edited to fix them. +# have to be +# +# HOW TO ADD A FILE + +# Unicode Versions Notes + +# alpha's numbers halve in 2.1.9, answer cjk block at 4E00 were removed from PropList; not changed, could add gc Letter, put back in in 3.1.0 +# Some versions of 2.1.x Jamo.txt have the wrong value for 1105, which causes +# real problems for the algorithms for Jamo calculations, so it is changed +# here. +# White space vs Space. in 3.2 perl has +205F=medium math space, fixed in 4.0, and ok in 3.1.1 because not there in unicode. synonym introduced in 4.1 +# ATBL = 202. 202 changed to ATB, and all code points stayed there. So if you were useing ATBL you were out of luck. +# Hrkt Katakana_Or_Hiragana came in 4.01, before was Unknown. +# +# The default for missing code points for BidiClass is complicated. Starting +# in 3.1.1, the derived file DBidiClass.txt handles this, but this program +# tries to do the best it can for earlier releases. It is done in +# process_PropertyAliases() +# +############################################################################## + +my $UNDEF = ':UNDEF:'; # String to print out for undefined values in tracing + # and errors +my $MAX_LINE_WIDTH = 78; + +# Debugging aid to skip most files so as to not be distracted by them when +# concentrating on the ones being debugged. Add +# non_skip => 1, +# to the constructor for those files you want processed when you set this. +# Files with a first version number of 0 are special: they are always +# processed regardless of the state of this flag. +my $debug_skip = 0; + +# Set to 1 to enable tracing. +our $to_trace = 0; + +{ # Closure for trace: debugging aid + my $print_caller = 1; # ? Include calling subroutine name + my $main_with_colon = 'main::'; + my $main_colon_length = length($main_with_colon); + + sub trace { + return unless $to_trace; # Do nothing if global flag not set + + my @input = @_; + + local $DB::trace = 0; + $DB::trace = 0; # Quiet 'used only once' message + + my $line_number; + + # Loop looking up the stack to get the first non-trace caller + my $caller_line; + my $caller_name; + my $i = 0; + do { + $line_number = $caller_line; + (my $pkg, my $file, $caller_line, my $caller) = caller $i++; + $caller = $main_with_colon unless defined $caller; + + $caller_name = $caller; + + # get rid of pkg + $caller_name =~ s/.*:://; + if (substr($caller_name, 0, $main_colon_length) + eq $main_with_colon) + { + $caller_name = substr($caller_name, $main_colon_length); + } + + } until ($caller_name ne 'trace'); + + # If the stack was empty, we were called from the top level + $caller_name = 'main' if ($caller_name eq "" + || $caller_name eq 'trace'); + + my $output = ""; + foreach my $string (@input) { + #print STDERR __LINE__, ": ", join ", ", @input, "\n"; + if (ref $string eq 'ARRAY' || ref $string eq 'HASH') { + $output .= simple_dumper($string); + } + else { + $string = "$string" if ref $string; + $string = $UNDEF unless defined $string; + chomp $string; + $string = '""' if $string eq ""; + $output .= " " if $output ne "" + && $string ne "" + && substr($output, -1, 1) ne " " + && substr($string, 0, 1) ne " "; + $output .= $string; + } + } + + if ($print_caller) { + if (defined $line_number) { + print STDERR sprintf "%4d: ", $line_number; + } + else { + print STDERR " "; + } + $caller_name .= ": "; + print STDERR $caller_name; + } + + print STDERR $output, "\n"; + return; + } +} + +# This is for a rarely used development feature that allows you to compare two +# versions of the Unicode standard without having to deal with changes caused +# by the code points introduced in the later verson. Change the 0 to a SINGLE +# dotted Unicode release number (e.g. 2.1). Only code points introduced in +# that release and earlier will be used; later ones are thrown away. You use +# the version number of the earliest one you want to compare; then run this +# program on directory structures containing each release, and compare the +# outputs. These outputs will therefore include only the code points common +# to both releases, and you can see the changes caused just by the underlying +# release semantic changes. For versions earlier than 3.2, you must copy a +# version of DAge.txt into the directory. +my $string_compare_versions = DEBUG && 0; # e.g., v2.1; +my $compare_versions = DEBUG + && $string_compare_versions + && pack "C*", split /\./, $string_compare_versions; + +sub uniques { + # Returns non-duplicated input values. From "Perl Best Practices: + # Encapsulated Cleverness". p. 455 in first edition. + + my %seen; + return grep { ! $seen{$_}++ } @_; +} + +$0 = File::Spec->canonpath($0); + +my $make_test_script = 0; # ? Should we output a test script +my $write_unchanged_files = 0; # ? Should we update the output files even if + # we don't think they have changed +my $use_directory = ""; # ? Should we chdir somewhere. +my $pod_directory; # input directory to store the pod file. +my $pod_file = 'perluniprops'; +my $t_path; # Path to the .t test file +my $file_list = 'mktables.lst'; # File to store input and output file names. + # This is used to speed up the build, by not + # executing the main body of the program if + # nothing on the list has changed since the + # previous build +my $make_list = 1; # ? Should we write $file_list. Set to always + # make a list so that when the pumpking is + # preparing a release, s/he won't have to do + # special things +my $glob_list = 0; # ? Should we try to include unknown .txt files + # in the input. +my $output_range_counts = 1; # ? Should we include the number of code points + # in ranges in the output +# Verbosity levels; 0 is quiet +my $NORMAL_VERBOSITY = 1; +my $PROGRESS = 2; +my $VERBOSE = 3; + +my $verbosity = $NORMAL_VERBOSITY; + +# Process arguments +while (@ARGV) { my $arg = shift @ARGV; if ($arg eq '-v') { - $Verbose = 1; - } elsif ($arg eq '-q') { - $Verbose = 0; - } elsif ($arg eq '-w') { - $AlwaysWrite = 1; # update the files even if they havent changed - $FileList = ""; - } elsif ($arg eq '-check') { + $verbosity = $VERBOSE; + } + elsif ($arg eq '-p') { + $verbosity = $PROGRESS; + $| = 1; # Flush buffers as we go. + } + elsif ($arg eq '-q') { + $verbosity = 0; + } + elsif ($arg eq '-w') { + $write_unchanged_files = 1; # update the files even if havent changed + } + elsif ($arg eq '-check') { my $this = shift @ARGV; my $ok = shift @ARGV; if ($this ne $ok) { print "Skipping as check params are not the same.\n"; exit(0); } - } elsif ($arg eq '-maketest') { - $MakeTestScript = 1; - } elsif ($arg eq '-makelist') { - $MakeList = 1; - } elsif ($arg eq '-C' && defined ($UseDir = shift)) { - -d $UseDir or die "Unknown directory '$UseDir'"; - } elsif ($arg eq '-L' && defined ($FileList = shift)) { - -e $FileList or die "Filelist '$FileList' doesn't appear to exist!"; - } else { - die "usage: $0 [-v|-q|-w|-C dir|-L filelist] [-maketest] [-makelist]\n", - " -v : Verbose Mode\n", - " -q : Quiet Mode\n", - " -w : Write files regardless\n", - " -maketest : Make test script\n", - " -makelist : Rewrite the file list based on current setup\n", - " -L filelist : Use this file list, (defaults to $0.lst)\n", - " -C dir : Change to this directory before proceeding\n", - " -check A B : Executes only if A and B are the same\n"; - } -} - -if ($FileList) { - print "Reading file list '$FileList'\n" - if $Verbose; - open my $fh,"<",$FileList or die "Failed to read '$FileList':$!"; - my @input; - my @output; - for my $list ( \@input, \@output ) { - while (<$fh>) { - s/^ \s+ | \s+ $//xg; - next if /^ \s* (?: \# .* )? $/x; - last if /^ =+ $/x; - my ( $file ) = split /\t/, $_; - push @$list, $file; - } - my %dupe; - @$list = grep !$dupe{ $_ }++, @$list; - } - close $fh; - die "No input or output files in '$FileList'!" - if !@input or !@output; - if ( $MakeList ) { - foreach my $file (@output) { - unlink $file; - } - } - if ( $Verbose ) { - print "Expecting ".scalar( @input )." input files. ", - "Checking ".scalar( @output )." output files.\n"; - } - # we set maxtime to be the youngest input file, including $0 itself. - my $maxtime = -M $0; # do this before the chdir! - if ($UseDir) { - chdir $UseDir or die "Failed to chdir to '$UseDir':$!"; - } - foreach my $in (@input) { - my $time = -M $in; - die "Missing input file '$in'" unless defined $time; - $maxtime = $time if $maxtime < $time; - } - - # now we check to see if any output files are older than maxtime, if - # they are we need to continue on, otherwise we can presumably bail. - my $ok = 1; - foreach my $out (@output) { - if ( ! -e $out ) { - print "'$out' is missing.\n" - if $Verbose; - $ok = 0; - last; - } - if ( -M $out > $maxtime ) { - print "'$out' is too old.\n" - if $Verbose; - $ok = 0; - last; - } } - if ($ok) { - print "Files seem to be ok, not bothering to rebuild.\n"; - exit(0); + elsif ($arg eq '-P' && defined ($pod_directory = shift)) { + -d $pod_directory or croak "Directory '$pod_directory' doesn't exist"; + } + elsif ($arg eq '-maketest' + || ($arg eq '-T' && defined ($t_path = shift))) { + $make_test_script = 1; + $t_path = 'TestProp.pl' unless defined $t_path; + } + elsif ($arg eq '-makelist') { + $make_list = 1; + } + elsif ($arg eq '-C' && defined ($use_directory = shift)) { + -d $use_directory or croak "Unknown directory '$use_directory'"; + } + elsif ($arg eq '-L') { + + # Existence not tested until have chdir'd + $file_list = shift; + } + elsif ($arg eq '-globlist') { + $glob_list = 1; + } + elsif ($arg eq '-c') { + $output_range_counts = ! $output_range_counts + } + else { + my $with_c = 'with'; + $with_c .= 'out' if $output_range_counts; # Complements the state + croak <file_name_is_absolute($pod_directory)) + { + $pod_directory = File::Spec->rel2abs($pod_directory); + } + if ($t_path + && ! File::Spec->file_name_is_absolute($t_path)) + { + $t_path = File::Spec->rel2abs($t_path); } - print "Must rebuild tables.\n" - if $Verbose; -} else { - if ($Verbose) { - print "Not checking filelist.\n"; + chdir $use_directory or croak "Failed to chdir to '$use_directory':$!"; + if ($pod_directory + && File::Spec->file_name_is_absolute($pod_directory)) + { + $pod_directory = File::Spec->abs2rel($pod_directory); } - if ($UseDir) { - chdir $UseDir or die "Failed to chdir to '$UseDir':$!"; + if ($t_path + && File::Spec->file_name_is_absolute($t_path)) + { + $t_path = File::Spec->abs2rel($t_path); } } -foreach my $lib ('To', 'lib', - map {File::Spec->catdir("lib",$_)} - qw(gc_sc dt bc hst ea jt lb nt ccc)) { - next if -d $lib; - mkdir $lib, 0755 or die "mkdir '$lib': $!"; +# Get Unicode version into regular and v-string. This is done now because +# various tables below get populated based on it. These tables are populated +# here to be near the top of the file, and so easily seeable by those needing +# to modify things. +open my $VERSION, "<", "version" + or croak "$0: can't open required file 'version': $!\n"; +my $string_version = <$VERSION>; +close $VERSION; +chomp $string_version; +my $v_version = pack "C*", split /\./, $string_version; # v string + +# The following are the complete names of properties with property values that +# are known to not match any code points in some versions of Unicode, but that +# may change in the future so they should be matchable, hence an empty file is +# generated for them. +my @tables_that_may_be_empty = ( + 'Joining_Type=Left_Joining', + ); +push @tables_that_may_be_empty, 'Script=Common' if $v_version le v4.0.1; +push @tables_that_may_be_empty, 'Title' if $v_version lt v2.0.0; +push @tables_that_may_be_empty, 'Script=Katakana_Or_Hiragana' + if $v_version ge v4.1.0; + +# The lists below are hashes, so the key is the item in the list, and the +# value is the reason why it is in the list. This makes generation of +# documentation easier. + +my %why_suppressed; # No file generated for these. + +# Files aren't generated for empty extraneous properties. This is arguable. +# Extraneous properties generally come about because a property is no longer +# used in a newer version of Unicode. If we generated a file without code +# points, programs that used to work on that property will still execute +# without errors. It just won't ever match (or will always match, with \P{}). +# This means that the logic is now likely wrong. I (khw) think its better to +# find this out by getting an error message. Just move them to the table +# above to change this behavior +my %why_suppress_if_empty_warn_if_not = ( + + # It is the only property that has ever officially been removed from the + # Standard. The database never contained any code points for it. + 'Special_Case_Condition' => 'Obsolete', + + # Apparently never official, but there were code points in some versions of + # old-style PropList.txt + 'Non_Break' => 'Obsolete', +); + +# These would normally go in the warn table just above, but they were changed +# a long time before this program was written, so warnings about them are +# moot. +if ($v_version gt v3.2.0) { + push @tables_that_may_be_empty, + 'Canonical_Combining_Class=Attached_Below_Left' +} + +# These are listed in the Property aliases file in 5.2, but Unihan is ignored +# unless explicitly added. +if ($v_version ge v5.2.0) { + my $unihan = 'Unihan; remove from list if using Unihan'; + foreach my $table qw ( + kAccountingNumeric + kOtherNumeric + kPrimaryNumeric + kCompatibilityVariant + kIICore + kIRG_GSource + kIRG_HSource + kIRG_JSource + kIRG_KPSource + kIRG_MSource + kIRG_KSource + kIRG_TSource + kIRG_USource + kIRG_VSource + kRSUnicode + ) + { + $why_suppress_if_empty_warn_if_not{$table} = $unihan; + } } -my $LastUnicodeCodepoint = 0x10FFFF; # As of Unicode 5.1. +# Properties that this program ignores. +my @unimplemented_properties = ( +'Unicode_Radical_Stroke' # Remove if changing to handle this one. +); -my $HEADER=<<"EOF"; -# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! -# This file is built by $0 from e.g. UnicodeData.txt. -# Any changes made here will be lost! +# There are several types of obsolete properties defined by Unicode. These +# must be hand-edited for every new Unicode release. +my %why_deprecated; # Generates a deprecated warning message if used. +my %why_stabilized; # Documentation only +my %why_obsolete; # Documentation only + +{ # Closure + my $simple = 'Perl uses the more complete version of this property'; + my $unihan = 'Unihan properties are by default not enabled in the Perl core. Instead use CPAN: Unicode::Unihan'; + + my $other_properties = 'other properties'; + my $contributory = "Used by Unicode internally for generating $other_properties and not intended to be used stand-alone"; + my $why_no_expand = "Easily computed, and yet doesn't cover the common encoding forms (UTF-16/8)", + + %why_deprecated = ( + 'Grapheme_Link' => 'Deprecated by Unicode. Use ccc=vr (Canonical_Combining_Class=Virama) instead', + 'Jamo_Short_Name' => $contributory, + 'Line_Break=Surrogate' => 'Deprecated by Unicode because surrogates should never appear in well-formed text, and therefore shouldn\'t be the basis for line breaking', + 'Other_Alphabetic' => $contributory, + 'Other_Default_Ignorable_Code_Point' => $contributory, + 'Other_Grapheme_Extend' => $contributory, + 'Other_ID_Continue' => $contributory, + 'Other_ID_Start' => $contributory, + 'Other_Lowercase' => $contributory, + 'Other_Math' => $contributory, + 'Other_Uppercase' => $contributory, + ); + + %why_suppressed = ( + # There is a lib/unicore/Decomposition.pl (used by normalize.pm) which + # contains the same information, but without the algorithmically + # determinable Hangul syllables'. This file is not published, so it's + # existence is not noted in the comment. + 'Decomposition_Mapping' => 'Accessible via Unicode::Normalize', + + 'ISO_Comment' => 'Apparently no demand for it, but can access it through Unicode::UCD::charinfo. Obsoleted, and code points for it removed in Unicode 5.2', + 'Unicode_1_Name' => "$simple, and no apparent demand for it, but can access it through Unicode::UCD::charinfo. If there is no later name for a code point, then this one is used instead in charnames", + + 'Simple_Case_Folding' => "$simple. Can access this through Unicode::UCD::casefold", + 'Simple_Lowercase_Mapping' => "$simple. Can access this through Unicode::UCD::charinfo", + 'Simple_Titlecase_Mapping' => "$simple. Can access this through Unicode::UCD::charinfo", + 'Simple_Uppercase_Mapping' => "$simple. Can access this through Unicode::UCD::charinfo", + + 'Name' => "Accessible via 'use charnames;'", + 'Name_Alias' => "Accessible via 'use charnames;'", + + # These are sort of jumping the gun; deprecation is proposed for + # Unicode version 6.0, but they have never been exposed by Perl, and + # likely are soon to be deprecated, so best not to expose them. + FC_NFKC_Closure => 'Use NFKC_Casefold instead', + Expands_On_NFC => $why_no_expand, + Expands_On_NFD => $why_no_expand, + Expands_On_NFKC => $why_no_expand, + Expands_On_NFKD => $why_no_expand, + ); + + # The following are suppressed because they were made contributory or + # deprecated by Unicode before Perl ever thought about supporting them. + foreach my $property ('Jamo_Short_Name', 'Grapheme_Link') { + $why_suppressed{$property} = $why_deprecated{$property}; + } + # Customize the message for all the 'Other_' properties + foreach my $property (keys %why_deprecated) { + next if (my $main_property = $property) !~ s/^Other_//; + $why_deprecated{$property} =~ s/$other_properties/the $main_property property (which should be used instead)/; + } +} + +if ($v_version ge 4.0.0) { + $why_stabilized{'Hyphen'} = 'Use the Line_Break property instead; see www.unicode.org/reports/tr14'; +} +if ($v_version ge 5.2.0) { + $why_obsolete{'ISO_Comment'} = 'Code points for it have been removed'; +} + +# Probably obsolete forever +if ($v_version ge v4.1.0) { + $why_suppressed{'Script=Katakana_Or_Hiragana'} = 'Obsolete. All code points previously matched by this have been moved to "Script=Common"'; +} + +# This program can create files for enumerated-like properties, such as +# 'Numeric_Type'. This file would be the same format as for a string +# property, with a mapping from code point to its value, so you could look up, +# for example, the script a code point is in. But no one so far wants this +# mapping, or they have found another way to get it since this is a new +# feature. So no file is generated except if it is in this list. +my @output_mapped_properties = split "\n", < +## @missing: 0000..10FFFF; cjkIICore; +## @missing: 0000..10FFFF; cjkIRG_GSource; +## @missing: 0000..10FFFF; cjkIRG_HSource; +## @missing: 0000..10FFFF; cjkIRG_JSource; +## @missing: 0000..10FFFF; cjkIRG_KPSource; +## @missing: 0000..10FFFF; cjkIRG_KSource; +## @missing: 0000..10FFFF; cjkIRG_TSource; +## @missing: 0000..10FFFF; cjkIRG_USource; +## @missing: 0000..10FFFF; cjkIRG_VSource; +## @missing: 0000..10FFFF; cjkOtherNumeric; NaN +## @missing: 0000..10FFFF; cjkPrimaryNumeric; NaN +## @missing: 0000..10FFFF; cjkRSUnicode; +END + +# The input files don't list every code point. Those not listed are to be +# defaulted to some value. Below are hard-coded what those values are for +# non-binary properties as of 5.1. Starting in 5.0, there are +# machine-parsable comment lines in the files the give the defaults; so this +# list shouldn't have to be extended. The claim is that all missing entries +# for binary properties will default to 'N'. Unicode tried to change that in +# 5.2, but the beta period produced enough protest that they backed off. +# +# The defaults for the fields that appear in UnicodeData.txt in this hash must +# be in the form that it expects. The others may be synonyms. +my $CODE_POINT = ''; +my %default_mapping = ( + Age => "Unassigned", + # Bidi_Class => Complicated; set in code + Bidi_Mirroring_Glyph => "", + Block => 'No_Block', + Canonical_Combining_Class => 0, + Case_Folding => $CODE_POINT, + Decomposition_Mapping => $CODE_POINT, + Decomposition_Type => 'None', + East_Asian_Width => "Neutral", + FC_NFKC_Closure => $CODE_POINT, + General_Category => 'Cn', + Grapheme_Cluster_Break => 'Other', + Hangul_Syllable_Type => 'NA', + ISO_Comment => "", + Jamo_Short_Name => "", + Joining_Group => "No_Joining_Group", + # Joining_Type => Complicated; set in code + kIICore => 'N', # Is converted to binary + #Line_Break => Complicated; set in code + Lowercase_Mapping => $CODE_POINT, + Name => "", + Name_Alias => "", + NFC_QC => 'Yes', + NFD_QC => 'Yes', + NFKC_QC => 'Yes', + NFKD_QC => 'Yes', + Numeric_Type => 'None', + Numeric_Value => 'NaN', + Script => ($v_version le 4.1.0) ? 'Common' : 'Unknown', + Sentence_Break => 'Other', + Simple_Case_Folding => $CODE_POINT, + Simple_Lowercase_Mapping => $CODE_POINT, + Simple_Titlecase_Mapping => $CODE_POINT, + Simple_Uppercase_Mapping => $CODE_POINT, + Titlecase_Mapping => $CODE_POINT, + Unicode_1_Name => "", + Unicode_Radical_Stroke => "", + Uppercase_Mapping => $CODE_POINT, + Word_Break => 'Other', +); + +# Below are files that Unicode furnishes, but this program ignores, and why +my %ignored_files = ( + 'CJKRadicals.txt' => 'Unihan data', + 'Index.txt' => 'An index, not actual data', + 'NamedSqProv.txt' => 'Not officially part of the Unicode standard; Append it to NamedSequences.txt if you want to process the contents.', + 'NamesList.txt' => 'Just adds commentary', + 'NormalizationCorrections.txt' => 'Data is already in other files.', + 'Props.txt' => 'Adds nothing to PropList.txt; only in very early releases', + 'ReadMe.txt' => 'Just comments', + 'README.TXT' => 'Just comments', + 'StandardizedVariants.txt' => 'Only for glyph changes, not a Unicode character property. Does not fit into current scheme where one code point is mapped', +); + +################ End of externally interesting definitions ############### + +my $HEADER=<<"EOF"; +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is machine-generated by $0 from the Unicode database, +# Version $string_version. Any changes made here will be lost! EOF my $INTERNAL_ONLY=<<"EOF"; + +# !!!!!!! INTERNAL PERL USE ONLY !!!!!!! # This file is for internal use by the Perl program only. The format and even -# name or existence of this file are subject to change without notice. Don't -# use it directly. +# the name or existence of this file are subject to change without notice. +# Don't use it directly. +EOF + +my $DEVELOPMENT_ONLY=<<"EOF"; +# !!!!!!! DEVELOPMENT USE ONLY !!!!!!! +# This file contains information artificially constrained to code points +# present in Unicode release $string_compare_versions. +# IT CANNOT BE RELIED ON. It is for use during development only and should +# not be used for production. EOF -sub force_unlink { - my $filename = shift; - return unless -e $filename; - return if CORE::unlink($filename); - # We might need write permission - chmod 0777, $filename; - CORE::unlink($filename) or die "Couldn't unlink $filename: $!\n"; +my $LAST_UNICODE_CODEPOINT_STRING = "10FFFF"; +my $LAST_UNICODE_CODEPOINT = hex $LAST_UNICODE_CODEPOINT_STRING; +my $MAX_UNICODE_CODEPOINTS = $LAST_UNICODE_CODEPOINT + 1; + +# Matches legal code point. 4-6 hex numbers, If there are 6, the first +# two must be 10; if there are 5, the first must not be a 0. Written this way +# to decrease backtracking +my $code_point_re = + qr/ \b (?: 10[0-9A-F]{4} | [1-9A-F][0-9A-F]{4} | [0-9A-F]{4} ) \b/x; + +# This matches the beginning of the line in the Unicode db files that give the +# defaults for code points not listed (i.e., missing) in the file. The code +# depends on this ending with a semi-colon, so it can assume it is a valid +# field when the line is split() by semi-colons +my $missing_defaults_prefix = + qr/^#\s+\@missing:\s+0000\.\.$LAST_UNICODE_CODEPOINT_STRING\s*;/; + +# Property types. Unicode has more types, but these are sufficient for our +# purposes. +my $UNKNOWN = -1; # initialized to illegal value +my $NON_STRING = 1; # Either binary or enum +my $BINARY = 2; +my $ENUM = 3; # Include catalog +my $STRING = 4; # Anything else: string or misc + +# Some input files have lines that give default values for code points not +# contained in the file. Sometimes these should be ignored. +my $NO_DEFAULTS = 0; # Must evaluate to false +my $NOT_IGNORED = 1; +my $IGNORED = 2; + +# Range types. Each range has a type. Most ranges are type 0, for normal, +# and will appear in the main body of the tables in the output files, but +# there are other types of ranges as well, listed below, that are specially +# handled. There are pseudo-types as well that will never be stored as a +# type, but will affect the calculation of the type. + +# 0 is for normal, non-specials +my $MULTI_CP = 1; # Sequence of more than code point +my $HANGUL_SYLLABLE = 2; +my $CP_IN_NAME = 3; # The NAME contains the code point appended to it. +my $NULL = 4; # The map is to the null string; utf8.c can't + # handle these, nor is there an accepted syntax + # for them in \p{} constructs +my $COMPUTE_NO_MULTI_CP = 5; # Pseudo-type; meanst that ranges that would + # otherwise be $MULTI_CP type are instead type 0 + +# process_generic_property_file() can accept certain overrides in its input. +# Each of these must begin AND end with $CMD_DELIM. +my $CMD_DELIM = "\a"; +my $REPLACE_CMD = 'replace'; # Override the Replace +my $MAP_TYPE_CMD = 'map_type'; # Override the Type + +my $NO = 0; +my $YES = 1; + +# Values for the Replace argument to add_range. +# $NO # Don't replace; add only the code points not + # already present. +my $IF_NOT_EQUIVALENT = 1; # Replace only under certain conditions; details in + # the comments at the subroutine definition. +my $UNCONDITIONALLY = 2; # Replace without conditions. +my $MULTIPLE = 4; # Don't replace, but add a duplicate record if + # already there + +# Flags to give property statuses. The phrases are to remind maintainers that +# if the flag is changed, the indefinite article referring to it in the +# documentation may need to be as well. +my $NORMAL = ""; +my $SUPPRESSED = 'z'; # The character should never actually be seen, since + # it is suppressed +my $DEPRECATED = 'D'; +my $a_bold_deprecated = "a 'B<$DEPRECATED>'"; +my $A_bold_deprecated = "A 'B<$DEPRECATED>'"; +my $DISCOURAGED = 'X'; +my $a_bold_discouraged = "an 'B<$DISCOURAGED>'"; +my $A_bold_discouraged = "An 'B<$DISCOURAGED>'"; +my $STRICTER = 'T'; +my $a_bold_stricter = "a 'B<$STRICTER>'"; +my $A_bold_stricter = "A 'B<$STRICTER>'"; +my $STABILIZED = 'S'; +my $a_bold_stabilized = "an 'B<$STABILIZED>'"; +my $A_bold_stabilized = "An 'B<$STABILIZED>'"; +my $OBSOLETE = 'O'; +my $a_bold_obsolete = "an 'B<$OBSOLETE>'"; +my $A_bold_obsolete = "An 'B<$OBSOLETE>'"; + +my %status_past_participles = ( + $DISCOURAGED => 'discouraged', + $SUPPRESSED => 'should never be generated', + $STABILIZED => 'stabilized', + $OBSOLETE => 'obsolete', + $DEPRECATED => 'deprecated' +); + +# The format of the values of the map tables: +my $BINARY_FORMAT = 'b'; +my $DECIMAL_FORMAT = 'd'; +my $FLOAT_FORMAT = 'f'; +my $INTEGER_FORMAT = 'i'; +my $HEX_FORMAT = 'x'; +my $RATIONAL_FORMAT = 'r'; +my $STRING_FORMAT = 's'; + +my %map_table_formats = ( + $BINARY_FORMAT => 'binary', + $DECIMAL_FORMAT => 'single decimal digit', + $FLOAT_FORMAT => 'floating point number', + $INTEGER_FORMAT => 'integer', + $HEX_FORMAT => 'positive hex whole number; a code point', + $RATIONAL_FORMAT => 'rational: an integer or a fraction', + $STRING_FORMAT => 'arbitrary string', +); + +# Unicode didn't put such derived files in a separate directory at first. +my $EXTRACTED_DIR = (-d 'extracted') ? 'extracted' : ""; +my $EXTRACTED = ($EXTRACTED_DIR) ? "$EXTRACTED_DIR/" : ""; +my $AUXILIARY = 'auxiliary'; + +# Hashes that will eventually go into Heavy.pl for the use of utf8_heavy.pl +my %loose_to_file_of; # loosely maps table names to their respective + # files +my %stricter_to_file_of; # same; but for stricter mapping. +my %nv_floating_to_rational; # maps numeric values floating point numbers to + # their rational equivalent +my %loose_property_name_of; # Loosely maps property names to standard form + +# These constants names and values were taken from the Unicode standard, +# version 5.1, section 3.12. They are used in conjunction with Hangul +# syllables +my $SBase = 0xAC00; +my $LBase = 0x1100; +my $VBase = 0x1161; +my $TBase = 0x11A7; +my $SCount = 11172; +my $LCount = 19; +my $VCount = 21; +my $TCount = 28; +my $NCount = $VCount * $TCount; + +# For Hangul syllables; These store the numbers from Jamo.txt in conjunction +# with the above published constants. +my %Jamo; +my %Jamo_L; # Leading consonants +my %Jamo_V; # Vowels +my %Jamo_T; # Trailing consonants + +my @unhandled_properties; # Will contain a list of properties found in + # the input that we didn't process. +my @match_properties; # properties that have match tables, to be + # listed in the pod +my @map_properties; # Properties that get map files written +my @named_sequences; # NamedSequences.txt contents. +my %potential_files; # Generated list of all .txt files in the directory + # structure so we can warn if something is being + # ignored. +my @files_actually_output; # List of files we generated. +my @more_Names; # Some code point names are compound; this is used + # to store the extra components of them. +my $MIN_FRACTION_LENGTH = 3; # How many digits of a floating point number at + # the minimum before we consider it equivalent to a + # candidate rational +my $MAX_FLOATING_SLOP = 10 ** - $MIN_FRACTION_LENGTH; # And in floating terms + +# These store references to certain commonly used property objects +my $gc; +my $perl; +my $block; + +# Are there conflicting names because of beginning with 'In_', or 'Is_' +my $has_In_conflicts = 0; +my $has_Is_conflicts = 0; + +sub internal_file_to_platform ($) { + # Convert our file paths which have '/' separators to those of the + # platform. + + my $file = shift; + return undef unless defined $file; + + return File::Spec->join(split '/', $file); } -## -## Given a filename and a reference to an array of lines, -## write the lines to the file only if the contents have not changed. -## Filename can be given as an arrayref of directory names -## -sub WriteIfChanged($\@) -{ - my $file = shift; - my $lines = shift; +sub file_exists ($) { # platform independent '-e'. This program internally + # uses slash as a path separator. + my $file = shift; + return 0 if ! defined $file; + return -e internal_file_to_platform($file); +} - $file = File::Spec->catfile(@$file) if ref $file; +# This 'require' doesn't necessarily work in miniperl, and even if it does, +# the native perl version of it (which is what would operate under miniperl) +# is extremely slow, as it does a string eval every call. +my $has_fast_scalar_util = $ !~ /miniperl/ + && defined eval "require Scalar::Util"; - my $TextToWrite = join '', @$lines; - if (open IN, $file) { - local($/) = undef; - my $PreviousText = ; - close IN; - if ($PreviousText eq $TextToWrite) { - print "$file unchanged.\n" if $Verbose; - return unless $AlwaysWrite; - } +sub objaddr($) { + # Returns the address of the blessed input object. Uses the XS version if + # available. It doesn't check for blessedness because that would do a + # string eval every call, and the program is structured so that this is + # never called for a non-blessed object. + + return Scalar::Util::refaddr($_[0]) if $has_fast_scalar_util; + + # Check at least that is a ref. + my $pkg = ref($_[0]) or return undef; + + # Change to a fake package to defeat any overloaded stringify + bless $_[0], 'main::Fake'; + + # Numifying a ref gives its address. + my $addr = 0 + $_[0]; + + # Return to original class + bless $_[0], $pkg; + return $addr; +} + +sub max ($$) { + my $a = shift; + my $b = shift; + return $a if $a >= $b; + return $b; +} + +sub min ($$) { + my $a = shift; + my $b = shift; + return $a if $a <= $b; + return $b; +} + +sub clarify_number ($) { + # This returns the input number with underscores inserted every 3 digits + # in large (5 digits or more) numbers. Input must be entirely digits, not + # checked. + + my $number = shift; + my $pos = length($number) - 3; + return $number if $pos <= 1; + while ($pos > 0) { + substr($number, $pos, 0) = '_'; + $pos -= 3; } - force_unlink ($file); - if (not open OUT, ">$file") { - die "$0: can't open $file for output: $!\n"; - } - print "$file written.\n" if $Verbose; - - print OUT $TextToWrite; - close OUT; -} - -## -## The main datastructure (a "Table") represents a set of code points that -## are part of a particular quality (that are part of \pL, \p{InGreek}, -## etc.). They are kept as ranges of code points (starting and ending of -## each range). -## -## For example, a range ASCII LETTERS would be represented as: -## [ [ 0x41 => 0x5A, 'UPPER' ], -## [ 0x61 => 0x7A, 'LOWER, ] ] -## -sub RANGE_START() { 0 } ## index into range element -sub RANGE_END() { 1 } ## index into range element -sub RANGE_NAME() { 2 } ## index into range element - -## Conceptually, these should really be folded into the 'Table' objects -my %TableInfo; -my %TableDesc; -my %FuzzyNames; -my %AliasInfo; -my %CanonicalToOrig; - -## -## Turn something like -## OLD-ITALIC -## into -## OldItalic -## -sub CanonicalName($) -{ - my $orig = shift; - my $name = lc $orig; - $name =~ s/(?) { - s/#.*//; - s/\s+$//; - next if /^$/; +our $Verbose = 1 if main::DEBUG; # Useful info when debugging - my ($abbrev, $name) = split /\s*;\s*/; - next if $abbrev eq "n/a"; - $PropertyAlias{$abbrev} = $name; - $PA_reverse{$name} = $abbrev; +sub my_carp { + my $message = shift || ""; + my $nofold = shift || 0; - # The %utf8::... versions use japhy's code originally from utf8_pva.pl - # However, it's moved here so that we build the tables at runtime. - tr/ _-//d for $abbrev, $name; - $utf8::PropertyAlias{lc $abbrev} = $name; - $utf8::PA_reverse{lc $name} = $abbrev; - } - close PA; + if ($message) { + $message = main::join_lines($message); + $message =~ s/^$0: *//; # Remove initial program name + $message =~ s/[.;,]+$//; # Remove certain ending punctuation + $message = "\n$0: $message;"; - open PVA, "< PropValueAliases.txt" - or confess "Can't open PropValueAliases.txt: $!"; - while () { - s/#.*//; - s/\s+$//; - next if /^$/; + # Fold the message with program name, semi-colon end punctuation + # (which looks good with the message that carp appends to it), and a + # hanging indent for continuation lines. + $message = main::simple_fold($message, "", 4) unless $nofold; + $message =~ s/\n$//; # Remove the trailing nl so what carp + # appends is to the same line + } - my ($prop, @data) = split /\s*;\s*/; + return $message if defined wantarray; # If a caller just wants the msg - if ($prop eq 'ccc') { - $PropValueAlias{$prop}{$data[1]} = [ @data[0,2] ]; - $PVA_reverse{$prop}{$data[2]} = [ @data[0,1] ]; - } - else { - next if $data[0] eq "n/a"; - $PropValueAlias{$prop}{$data[0]} = $data[1]; - $PVA_reverse{$prop}{$data[1]} = $data[0]; - } + carp $message; + return; +} - shift @data if $prop eq 'ccc'; - next if $data[0] eq "n/a"; +sub my_carp_bug { + # This is called when it is clear that the problem is caused by a bug in + # this program. - $data[1] =~ tr/ _-//d; - $utf8::PropValueAlias{$prop}{lc $data[0]} = $data[1]; - $utf8::PVA_reverse{$prop}{lc $data[1]} = $data[0]; + my $message = shift; + $message =~ s/^$0: *//; + $message = my_carp("Bug in $0. Please report it by running perlbug or if that is unavailable, by sending email to perbug\@perl.org:\n$message"); + carp $message; + return; +} - my $abbr_class = ($prop eq 'gc' or $prop eq 'sc') ? 'gc_sc' : $prop; - $utf8::PVA_abbr_map{$abbr_class}{lc $data[0]} = $data[0]; +sub carp_too_few_args { + if (@_ != 2) { + my_carp_bug("Wrong number of arguments: to 'carp_too_few_arguments'. No action taken."); + return; } - close PVA; - # backwards compatibility for L& -> LC - $utf8::PropValueAlias{gc}{'l&'} = $utf8::PropValueAlias{gc}{lc}; - $utf8::PVA_abbr_map{gc_sc}{'l&'} = $utf8::PVA_abbr_map{gc_sc}{lc}; + my $args_ref = shift; + my $count = shift; + my_carp_bug("Need at least $count arguments to " + . (caller 1)[3] + . ". Instead got: '" + . join ', ', @$args_ref + . "'. No action taken."); + return; } +sub carp_extra_args { + my $args_ref = shift; + my_carp_bug("Too many arguments to 'carp_extra_args': (" . join(', ', @_) . "); Extras ignored.") if @_; -## -## Associates a property ("Greek", "Lu", "Assigned",...) with a Table. -## -## Called like: -## New_Prop(In => 'Greek', $Table, Desc => 'Greek Block', Fuzzy => 1); -## -## Normally, these parameters are set when the Table is created (when the -## Table->New constructor is called), but there are times when it needs to -## be done after-the-fact...) -## -sub New_Prop($$$@) -{ - my $Type = shift; ## "Is" or "In"; - my $Name = shift; - my $Table = shift; + unless (ref $args_ref) { + my_carp_bug("Argument to 'carp_extra_args' ($args_ref) must be a ref. Not checking arguments."); + return; + } + my ($package, $file, $line) = caller; + my $subroutine = (caller 1)[3]; - ## remaining args are optional key/val - my %Args = @_; - - my $Fuzzy = delete $Args{Fuzzy}; - my $Desc = delete $Args{Desc}; # description - - $Name = CanonicalName($Name) if $Fuzzy; - - ## sanity check a few args - if (%Args or ($Type ne 'Is' and $Type ne 'In') or not ref $Table) { - confess "$0: bad args to New_Prop" - } - - if (not $TableInfo{$Type}->{$Name}) - { - $TableInfo{$Type}->{$Name} = $Table; - $TableDesc{$Type}->{$Name} = $Desc; - if ($Fuzzy) { - $FuzzyNames{$Type}->{$Name} = $Name; + my $list; + if (ref $args_ref eq 'HASH') { + foreach my $key (keys %$args_ref) { + $args_ref->{$key} = $UNDEF unless defined $args_ref->{$key}; } + $list = join ', ', each %{$args_ref}; } + elsif (ref $args_ref eq 'ARRAY') { + foreach my $arg (@$args_ref) { + $arg = $UNDEF unless defined $arg; + } + $list = join ', ', @$args_ref; + } + else { + my_carp_bug("Can't cope with ref " + . ref($args_ref) + . " . argument to 'carp_extra_args'. Not checking arguments."); + return; + } + + my_carp_bug("Unrecognized parameters in options: '$list' to $subroutine. Skipped."); + return; } +package main; + +{ # Closure + + # This program uses the inside-out method for objects, as recommended in + # "Perl Best Practices". This closure aids in generating those. There + # are two routines. setup_package() is called once per package to set + # things up, and then set_access() is called for each hash representing a + # field in the object. These routines arrange for the object to be + # properly destroyed when no longer used, and for standard accessor + # functions to be generated. If you need more complex accessors, just + # write your own and leave those accesses out of the call to set_access(). + # More details below. + + my %constructor_fields; # fields that are to be used in constructors; see + # below + + # The values of this hash will be the package names as keys to other + # hashes containing the name of each field in the package as keys, and + # references to their respective hashes as values. + my %package_fields; + + sub setup_package { + # Sets up the package, creating standard DESTROY and dump methods + # (unless already defined). The dump method is used in debugging by + # simple_dumper(). + # The optional parameters are: + # a) a reference to a hash, that gets populated by later + # set_access() calls with one of the accesses being + # 'constructor'. The caller can then refer to this, but it is + # not otherwise used by these two routines. + # b) a reference to a callback routine to call during destruction + # of the object, before any fields are actually destroyed + + my %args = @_; + my $constructor_ref = delete $args{'Constructor_Fields'}; + my $destroy_callback = delete $args{'Destroy_Callback'}; + Carp::carp_extra_args(\@_) if main::DEBUG && %args; + + my %fields; + my $package = (caller)[0]; + + $package_fields{$package} = \%fields; + $constructor_fields{$package} = $constructor_ref; + + unless ($package->can('DESTROY')) { + my $destroy_name = "${package}::DESTROY"; + no strict "refs"; + + # Use typeglob to give the anonymous subroutine the name we want + *$destroy_name = sub { + my $self = shift; + my $addr = main::objaddr($self); + + $self->$destroy_callback if $destroy_callback; + foreach my $field (keys %{$package_fields{$package}}) { + #print STDERR __LINE__, ": Destroying ", ref $self, " ", sprintf("%04X", $addr), ": ", $field, "\n"; + delete $package_fields{$package}{$field}{$addr}; + } + return; + } + } + + unless ($package->can('dump')) { + my $dump_name = "${package}::dump"; + no strict "refs"; + *$dump_name = sub { + my $self = shift; + return dump_inside_out($self, $package_fields{$package}, @_); + } + } + return; + } + + sub set_access { + # Arrange for the input field to be garbage collected when no longer + # needed. Also, creates standard accessor functions for the field + # based on the optional parameters-- none if none of these parameters: + # 'addable' creates an 'add_NAME()' accessor function. + # 'readable' or 'readable_array' creates a 'NAME()' accessor + # function. + # 'settable' creates a 'set_NAME()' accessor function. + # 'constructor' doesn't create an accessor function, but adds the + # field to the hash that was previously passed to + # setup_package(); + # Any of the accesses can be abbreviated down, so that 'a', 'ad', + # 'add' etc. all mean 'addable'. + # The read accessor function will work on both array and scalar + # values. If another accessor in the parameter list is 'a', the read + # access assumes an array. You can also force it to be array access + # by specifying 'readable_array' instead of 'readable' + # + # A sort-of 'protected' access can be set-up by preceding the addable, + # readable or settable with some initial portion of 'protected_' (but, + # the underscore is required), like 'p_a', 'pro_set', etc. The + # "protection" is only by convention. All that happens is that the + # accessor functions' names begin with an underscore. So instead of + # calling set_foo, the call is _set_foo. (Real protection could be + # accomplished by having a new subroutine, end_package called at the + # end of each package, and then storing the __LINE__ ranges and + # checking them on every accessor. But that is way overkill.) + + # We create anonymous subroutines as the accessors and then use + # typeglobs to assign them to the proper package and name + + my $name = shift; # Name of the field + my $field = shift; # Reference to the inside-out hash containing the + # field + + my $package = (caller)[0]; + + if (! exists $package_fields{$package}) { + croak "$0: Must call 'setup_package' before 'set_access'"; + } -## -## Creates a new Table object. -## -## Args are key/value pairs: -## In => Name -- Name of "In" property to be associated with -## Is => Name -- Name of "Is" property to be associated with -## Fuzzy => Boolean -- True if name can be accessed "fuzzily" -## Desc => String -- Description of the property -## -## No args are required. -## -sub Table::New -{ - my $class = shift; - my %Args = @_; + # Stash the field so DESTROY can get it. + $package_fields{$package}{$name} = $field; - my $Table = bless [], $class; + # Remaining arguments are the accessors. For each... + foreach my $access (@_) { + my $access = lc $access; - my $Fuzzy = delete $Args{Fuzzy}; - my $Desc = delete $Args{Desc}; + my $protected = ""; - for my $Type ('Is', 'In') - { - if (my $Name = delete $Args{$Type}) { - New_Prop($Type => $Name, $Table, Desc => $Desc, Fuzzy => $Fuzzy); + # Match the input as far as it goes. + if ($access =~ /^(p[^_]*)_/) { + $protected = $1; + if (substr('protected_', 0, length $protected) + eq $protected) + { + + # Add 1 for the underscore not included in $protected + $access = substr($access, length($protected) + 1); + $protected = '_'; + } + else { + $protected = ""; + } + } + + if (substr('addable', 0, length $access) eq $access) { + my $subname = "${package}::${protected}add_$name"; + no strict "refs"; + + # add_ accessor. Don't add if already there, which we + # determine using 'eq' for scalars and '==' otherwise. + *$subname = sub { + use strict "refs"; + return Carp::carp_too_few_args(\@_, 2) if main::DEBUG && @_ < 2; + my $self = shift; + my $value = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + if (ref $value) { + return if grep { $value == $_ } + @{$field->{main::objaddr $self}}; + } + else { + return if grep { $value eq $_ } + @{$field->{main::objaddr $self}}; + } + push @{$field->{main::objaddr $self}}, $value; + return; + } + } + elsif (substr('constructor', 0, length $access) eq $access) { + if ($protected) { + Carp::my_carp_bug("Can't set-up 'protected' constructors") + } + else { + $constructor_fields{$package}{$name} = $field; + } + } + elsif (substr('readable_array', 0, length $access) eq $access) { + + # Here has read access. If one of the other parameters for + # access is array, or this one specifies array (by being more + # than just 'readable_'), then create a subroutine that + # assumes the data is an array. Otherwise just a scalar + my $subname = "${package}::${protected}$name"; + if (grep { /^a/i } @_ + or length($access) > length('readable_')) + { + no strict "refs"; + *$subname = sub { + use strict "refs"; + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + my $addr = main::objaddr $self; + if (ref $field->{$addr} ne 'ARRAY') { + my $type = ref $field->{$addr}; + $type = 'scalar' unless $type; + Carp::my_carp_bug("Trying to read $name as an array when it is a $type. Big problems."); + return; + } + return scalar @{$field->{$addr}} unless wantarray; + + # Make a copy; had problems with caller modifying the + # original otherwise + my @return = @{$field->{$addr}}; + return @return; + } + } + else { + + # Here not an array value, a simpler function. + no strict "refs"; + *$subname = sub { + use strict "refs"; + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + return $field->{main::objaddr $self}; + } + } + } + elsif (substr('settable', 0, length $access) eq $access) { + my $subname = "${package}::${protected}set_$name"; + no strict "refs"; + *$subname = sub { + use strict "refs"; + return Carp::carp_too_few_args(\@_, 2) if main::DEBUG && @_ < 2; + my $self = shift; + my $value = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + $field->{main::objaddr $self} = $value; + return; + } + } + else { + Carp::my_carp_bug("Unknown accessor type $access. No accessor set."); + } } + return; } - - ## shouldn't have any left over - if (%Args) { - confess "$0: bad args to Table->New" - } - - return $Table; -} - - -## -## Returns the maximum code point currently in the table. -## -sub Table::Max -{ - my $last = $_[0]->[-1]; ## last code point - confess "oops" unless $last; ## must have code points to have a max - return $last->[RANGE_END]; -} - -## -## Replaces the codepoints in the Table with those in the Table given -## as an arg. (NOTE: this is not a "deep copy"). -## -sub Table::Replace($$) -{ - my $Table = shift; #self - my $New = shift; - - @$Table = @$New; -} - -## -## Given a new code point, make the last range of the Table extend to -## include the new (and all intervening) code points. -## -## Takes the time to make sure that the extension is valid. -## -sub Table::Extend -{ - my $Table = shift; #self - my $codepoint = shift; - - my $PrevMax = $Table->Max; - - confess "oops ($codepoint <= $PrevMax)" if $codepoint <= $PrevMax; - - $Table->ExtendNoCheck($codepoint); -} - - -## -## Given a new code point, make the last range of the Table extend to -## include the new (and all intervening) code points. -## -## Does NOT check that the extension is valid. Assumes that the caller -## has already made this check. -## -sub Table::ExtendNoCheck -{ - ## Optmized adding: Assumes $Table and $codepoint as parms - $_[0]->[-1]->[RANGE_END] = $_[1]; -} - -## -## Given a code point range start and end (and optional name), blindly -## append them to the list of ranges for the Table. -## -## NOTE: Code points must be added in strictly ascending numeric order. -## -sub Table::RawAppendRange -{ - my $Table = shift; #self - my $start = shift; - my $end = shift; - my $name = shift; - $name = "" if not defined $name; ## warning: $name can be "0" - - push @$Table, [ $start, # RANGE_START - $end, # RANGE_END - $name ]; # RANGE_NAME -} - -## -## Given a code point (and optional name), add it to the Table. -## -## NOTE: Code points must be added in strictly ascending numeric order. -## -sub Table::Append -{ - my $Table = shift; #self - my $codepoint = shift; - my $name = shift; - $name = "" if not defined $name; ## warning: $name can be "0" - - ## - ## If we've already got a range working, and this code point is the next - ## one in line, and if the name is the same, just extend the current range. - ## - my $last = $Table->[-1]; - if ($last - and - $last->[RANGE_END] == $codepoint - 1 - and - $last->[RANGE_NAME] eq $name) - { - $Table->ExtendNoCheck($codepoint); - } - else - { - $Table->RawAppendRange($codepoint, $codepoint, $name); - } -} - -## -## Given a code point range starting value and ending value (and name), -## Add the range to the Table. -## -## NOTE: Code points must be added in strictly ascending numeric order. -## -sub Table::AppendRange -{ - my $Table = shift; #self - my $start = shift; - my $end = shift; - my $name = shift; - $name = "" if not defined $name; ## warning: $name can be "0" - - $Table->Append($start, $name); - $Table->Extend($end) if $end > $start; -} - -## -## Return a new Table that represents all code points not in the Table. -## -sub Table::Invert -{ - my $Table = shift; #self - - my $New = Table->New(); - my $max = -1; - for my $range (@$Table) - { - my $start = $range->[RANGE_START]; - my $end = $range->[RANGE_END]; - if ($start-1 >= $max+1) { - $New->AppendRange($max+1, $start-1, ""); - } - $max = $end; - } - if ($max+1 < $LastUnicodeCodepoint) { - $New->AppendRange($max+1, $LastUnicodeCodepoint); - } - return $New; -} - -## -## Merges any number of other tables with $self, returning the new table. -## (existing tables are not modified) -## -## -## Args may be Tables, or individual code points (as integers). -## -## Can be called as either a constructor or a method. -## -sub Table::Merge -{ - shift(@_) if not ref $_[0]; ## if called as a constructor, lose the class - my @Tables = @_; - - ## Accumulate all records from all tables - my @Records; - for my $Arg (@Tables) - { - if (ref $Arg) { - ## arg is a table -- get its ranges - push @Records, @$Arg; - } else { - ## arg is a codepoint, make a range - push @Records, [ $Arg, $Arg ] +} + +package Input_file; + +# All input files use this object, which stores various attributes about them, +# and provides for convenient, uniform handling. The run method wraps the +# processing. It handles all the bookkeeping of opening, reading, and closing +# the file, returning only significant input lines. +# +# Each object gets a handler which processes the body of the file, and is +# called by run(). Most should use the generic, default handler, which has +# code scrubbed to handle things you might not expect. A handler should +# basically be a while(next_line()) {...} loop. +# +# You can also set up handlers to +# 1) call before the first line is read for pre processing +# 2) call to adjust each line of the input before the main handler gets them +# 3) call upon EOF before the main handler exits its loop +# 4) call at the end for post processing +# +# $_ is used to store the input line, and is to be filtered by the +# each_line_handler()s. So, if the format of the line is not in the desired +# format for the main handler, these are used to do that adjusting. They can +# be stacked (by enclosing them in an [ anonymous array ] in the constructor, +# so the $_ output of one is used as the input to the next. None of the other +# handlers are stackable, but could easily be changed to be so. +# +# Most of the handlers can call insert_lines() or insert_adjusted_lines() +# which insert the parameters as lines to be processed before the next input +# file line is read. This allows the EOF handler to flush buffers, for +# example. The difference between the two routines is that the lines inserted +# by insert_lines() are subjected to the each_line_handler()s. (So if you +# called it from such a handler, you would get infinite recursion.) Lines +# inserted by insert_adjusted_lines() go directly to the main handler without +# any adjustments. If the post-processing handler calls any of these, there +# will be no effect. Some error checking for these conditions could be added, +# but it hasn't been done. +# +# carp_bad_line() should be called to warn of bad input lines, which clears $_ +# to prevent further processing of the line. This routine will output the +# message as a warning once, and then keep a count of the lines that have the +# same message, and output that count at the end of the file's processing. +# This keeps the number of messages down to a manageable amount. +# +# get_missings() should be called to retrieve any @missing input lines. +# Messages will be raised if this isn't done if the options aren't to ignore +# missings. + +sub trace { return main::trace(@_); } + + +{ # Closure + # Keep track of fields that are to be put into the constructor. + my %constructor_fields; + + main::setup_package(Constructor_Fields => \%constructor_fields); + + my %file; # Input file name, required + main::set_access('file', \%file, qw{ c r }); + + my %first_released; # Unicode version file was first released in, required + main::set_access('first_released', \%first_released, qw{ c r }); + + my %handler; # Subroutine to process the input file, defaults to + # 'process_generic_property_file' + main::set_access('handler', \%handler, qw{ c }); + + my %property; + # name of property this file is for. defaults to none, meaning not + # applicable, or is otherwise determinable, for example, from each line. + main::set_access('property', \%property, qw{ c }); + + my %optional; + # If this is true, the file is optional. If not present, no warning is + # output. If it is present, the string given by this parameter is + # evaluated, and if false the file is not processed. + main::set_access('optional', \%optional, 'c', 'r'); + + my %non_skip; + # This is used for debugging, to skip processing of all but a few input + # files. Add 'non_skip => 1' to the constructor for those files you want + # processed when you set the $debug_skip global. + main::set_access('non_skip', \%non_skip, 'c'); + + my %each_line_handler; + # list of subroutines to look at and filter each non-comment line in the + # file. defaults to none. The subroutines are called in order, each is + # to adjust $_ for the next one, and the final one adjusts it for + # 'handler' + main::set_access('each_line_handler', \%each_line_handler, 'c'); + + my %has_missings_defaults; + # ? Are there lines in the file giving default values for code points + # missing from it?. Defaults to NO_DEFAULTS. Otherwise NOT_IGNORED is + # the norm, but IGNORED means it has such lines, but the handler doesn't + # use them. Having these three states allows us to catch changes to the + # UCD that this program should track + main::set_access('has_missings_defaults', + \%has_missings_defaults, qw{ c r }); + + my %pre_handler; + # Subroutine to call before doing anything else in the file. If undef, no + # such handler is called. + main::set_access('pre_handler', \%pre_handler, qw{ c }); + + my %eof_handler; + # Subroutine to call upon getting an EOF on the input file, but before + # that is returned to the main handler. This is to allow buffers to be + # flushed. The handler is expected to call insert_lines() or + # insert_adjusted() with the buffered material + main::set_access('eof_handler', \%eof_handler, qw{ c r }); + + my %post_handler; + # Subroutine to call after all the lines of the file are read in and + # processed. If undef, no such handler is called. + main::set_access('post_handler', \%post_handler, qw{ c }); + + my %progress_message; + # Message to print to display progress in lieu of the standard one + main::set_access('progress_message', \%progress_message, qw{ c }); + + my %handle; + # cache open file handle, internal. Is undef if file hasn't been + # processed at all, empty if has; + main::set_access('handle', \%handle); + + my %added_lines; + # cache of lines added virtually to the file, internal + main::set_access('added_lines', \%added_lines); + + my %errors; + # cache of errors found, internal + main::set_access('errors', \%errors); + + my %missings; + # storage of '@missing' defaults lines + main::set_access('missings', \%missings); + + sub new { + my $class = shift; + + my $self = bless \do{ my $anonymous_scalar }, $class; + my $addr = main::objaddr($self); + + # Set defaults + $handler{$addr} = \&main::process_generic_property_file; + $non_skip{$addr} = 0; + $has_missings_defaults{$addr} = $NO_DEFAULTS; + $handle{$addr} = undef; + $added_lines{$addr} = [ ]; + $each_line_handler{$addr} = [ ]; + $errors{$addr} = { }; + $missings{$addr} = [ ]; + + # Two positional parameters. + $file{$addr} = main::internal_file_to_platform(shift); + $first_released{$addr} = shift; + + # The rest of the arguments are key => value pairs + # %constructor_fields has been set up earlier to list all possible + # ones. Either set or push, depending on how the default has been set + # up just above. + my %args = @_; + foreach my $key (keys %args) { + my $argument = $args{$key}; + + # Note that the fields are the lower case of the constructor keys + my $hash = $constructor_fields{lc $key}; + if (! defined $hash) { + Carp::my_carp_bug("Unrecognized parameters '$key => $argument' to new() for $self. Skipped"); + next; + } + if (ref $hash->{$addr} eq 'ARRAY') { + if (ref $argument eq 'ARRAY') { + foreach my $argument (@{$argument}) { + next if ! defined $argument; + push @{$hash->{$addr}}, $argument; + } + } + else { + push @{$hash->{$addr}}, $argument if defined $argument; + } + } + else { + $hash->{$addr} = $argument; + } + delete $args{$key}; + }; + + # If the file has a property for it, it means that the property is not + # listed in the file's entries. So add a handler to the list of line + # handlers to insert the property name into the lines, to provide a + # uniform interface to the final processing subroutine. + # the final code doesn't have to worry about that. + if ($property{$addr}) { + push @{$each_line_handler{$addr}}, \&_insert_property_into_line; + } + + if ($non_skip{$addr} && ! $debug_skip && $verbosity) { + print "Warning: " . __PACKAGE__ . " constructor for $file{$addr} has useless 'non_skip' in it\n"; } + + return $self; } - ## sort by range start, with longer ranges coming first. - my ($first, @Rest) = sort { - ($a->[RANGE_START] <=> $b->[RANGE_START]) - or - ($b->[RANGE_END] <=> $b->[RANGE_END]) - } @Records; - my $New = Table->New(); + use overload + fallback => 0, + qw("") => "_operator_stringify", + "." => \&main::_operator_dot, + ; - ## Ensuring the first range is there makes the subsequent loop easier - $New->AppendRange($first->[RANGE_START], - $first->[RANGE_END]); + sub _operator_stringify { + my $self = shift; - ## Fold in records so long as they add new information. - for my $set (@Rest) - { - my $start = $set->[RANGE_START]; - my $end = $set->[RANGE_END]; - if ($start > $New->Max) { - $New->AppendRange($start, $end); - } elsif ($end > $New->Max) { - $New->ExtendNoCheck($end); - } + return __PACKAGE__ . " object for " . $self->file; } - return $New; -} + # flag to make sure extracted files are processed early + my $seen_non_extracted_non_age = 0; -## -## Given a filename, write a representation of the Table to a file. -## May have an optional comment as a 2nd arg. -## Filename may actually be an arrayref of directories -## -sub Table::Write -{ - my $Table = shift; #self - my $filename = shift; - my $comment = shift; + sub run { + # Process the input object $self. This opens and closes the file and + # calls all the handlers for it. Currently, this can only be called + # once per file, as it destroy's the EOF handler - my @OUT = $HEADER; + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; - # files in subdirectories are internal-use-only - push @OUT, $INTERNAL_ONLY if ref $filename; + my $addr = main::objaddr $self; - if (defined $comment) { - $comment =~ s/\s+\Z//; - $comment =~ s/^/# /gm; - push @OUT, "#\n$comment\n#\n"; - } - push @OUT, "return <<'END';\n"; + my $file = $file{$addr}; - for my $set (@$Table) - { - my $start = $set->[RANGE_START]; - my $end = $set->[RANGE_END]; - my $name = $set->[RANGE_NAME]; + # Don't process if not expecting this file (because released later + # than this Unicode version), and isn't there. This means if someone + # copies it into an earlier version's directory, we will go ahead and + # process it. + return if $first_released{$addr} gt $v_version && ! -e $file; + + # If in debugging mode and this file doesn't have the non-skip + # flag set, and isn't one of the critical files, skip it. + if ($debug_skip + && $first_released{$addr} ne v0 + && ! $non_skip{$addr}) + { + print "Skipping $file in debugging\n" if $verbosity; + return; + } + + # File could be optional + if ($optional{$addr}){ + return unless -e $file; + my $result = eval $optional{$addr}; + if (! defined $result) { + Carp::my_carp_bug("Got '$@' when tried to eval $optional{$addr}. $file Skipped."); + return; + } + if (! $result) { + if ($verbosity) { + print STDERR "Skipping processing input file '$file' because '$optional{$addr}' is not true\n"; + } + return; + } + } + + if (! defined $file || ! -e $file) { + + # If the file doesn't exist, see if have internal data for it + # (based on first_released being 0). + if ($first_released{$addr} eq v0) { + $handle{$addr} = 'pretend_is_open'; + } + else { + if (! $optional{$addr} # File could be optional + && $v_version ge $first_released{$addr}) + { + print STDERR "Skipping processing input file '$file' because not found\n" if $v_version ge $first_released{$addr}; + } + return; + } + } + else { + + # Here, the file exists + if ($seen_non_extracted_non_age) { + if ($file =~ /$EXTRACTED/) { + Carp::my_carp_bug(join_lines(<rel2abs($file)} + && ! defined $handle{$addr}; + + # Open the file, converting the slashes used in this program + # into the proper form for the OS + my $file_handle; + if (not open $file_handle, "<", $file) { + Carp::my_carp("Can't open $file. Skipping: $!"); + return 0; + } + $handle{$addr} = $file_handle; # Cache the open file handle + } + + if ($verbosity >= $PROGRESS) { + if ($progress_message{$addr}) { + print "$progress_message{$addr}\n"; + } + else { + # If using a virtual file, say so. + print "Processing ", (-e $file) + ? $file + : "substitute $file", + "\n"; + } + } + + + # Call any special handler for before the file. + &{$pre_handler{$addr}}($self) if $pre_handler{$addr}; + + # Then the main handler + &{$handler{$addr}}($self); + + # Then any special post-file handler. + &{$post_handler{$addr}}($self) if $post_handler{$addr}; + + # If any errors have been accumulated, output the counts (as the first + # error message in each class was output when it was encountered). + if ($errors{$addr}) { + my $total = 0; + my $types = 0; + foreach my $error (keys %{$errors{$addr}}) { + $total += $errors{$addr}->{$error}; + delete $errors{$addr}->{$error}; + $types++; + } + if ($total > 1) { + my $message + = "A total of $total lines had errors in $file. "; + + $message .= ($types == 1) + ? '(Only the first one was displayed.)' + : '(Only the first of each type was displayed.)'; + Carp::my_carp($message); + } + } + + if (@{$missings{$addr}}) { + Carp::my_carp_bug("Handler for $file didn't look at all the \@missing lines. Generated tables likely are wrong"); + } + + # If a real file handle, close it. + close $handle{$addr} or Carp::my_carp("Can't close $file: $!") if + ref $handle{$addr}; + $handle{$addr} = ""; # Uses empty to indicate that has already seen + # the file, as opposed to undef + return; + } + + sub next_line { + # Sets $_ to be the next logical input line, if any. Returns non-zero + # if such a line exists. 'logical' means that any lines that have + # been added via insert_lines() will be returned in $_ before the file + # is read again. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + # Here the file is open (or if the handle is not a ref, is an open + # 'virtual' file). Get the next line; any inserted lines get priority + # over the file itself. + my $adjusted; + + LINE: + while (1) { # Loop until find non-comment, non-empty line + #local $to_trace = 1 if main::DEBUG; + my $inserted_ref = shift @{$added_lines{$addr}}; + if (defined $inserted_ref) { + ($adjusted, $_) = @{$inserted_ref}; + trace $adjusted, $_ if main::DEBUG && $to_trace; + return 1 if $adjusted; + } + else { + last if ! ref $handle{$addr}; # Don't read unless is real file + last if ! defined ($_ = readline $handle{$addr}); + } + chomp; + trace $_ if main::DEBUG && $to_trace; + + # See if this line is the comment line that defines what property + # value that code points that are not listed in the file should + # have. The format or existence of these lines is not guaranteed + # by Unicode since they are comments, but the documentation says + # that this was added for machine-readability, so probably won't + # change. This works starting in Unicode Version 5.0. They look + # like: + # + # @missing: 0000..10FFFF; Not_Reordered + # @missing: 0000..10FFFF; Decomposition_Mapping; + # @missing: 0000..10FFFF; ; NaN + # + # Save the line for a later get_missings() call. + if (/$missing_defaults_prefix/) { + if ($has_missings_defaults{$addr} == $NO_DEFAULTS) { + $self->carp_bad_line("Unexpected \@missing line. Assuming no missing entries"); + } + elsif ($has_missings_defaults{$addr} == $NOT_IGNORED) { + my @defaults = split /\s* ; \s*/x, $_; + + # The first field is the @missing, which ends in a + # semi-colon, so can safely shift. + shift @defaults; + + # Some of these lines may have empty field placeholders + # which get in the way. An example is: + # @missing: 0000..10FFFF; ; NaN + # Remove them. Process starting from the top so the + # splice doesn't affect things still to be looked at. + for (my $i = @defaults - 1; $i >= 0; $i--) { + next if $defaults[$i] ne ""; + splice @defaults, $i, 1; + } + + # What's left should be just the property (maybe) and the + # default. Having only one element means it doesn't have + # the property. + my $default; + my $property; + if (@defaults >= 1) { + if (@defaults == 1) { + $default = $defaults[0]; + } + else { + $property = $defaults[0]; + $default = $defaults[1]; + } + } + + if (@defaults < 1 + || @defaults > 2 + || ($default =~ /^$/i + && $default !~ /^$/i)) + { + $self->carp_bad_line("Unrecognized \@missing line: $_. Assuming no missing entries"); + } + else { + + # If the property is missing from the line, it should + # be the one for the whole file + $property = $property{$addr} if ! defined $property; + + # Change to the null string, which is what it + # really means. If the default is the code point + # itself, set it to , which is what + # Unicode uses (but sometimes they've forgotten the + # space) + if ($default =~ /^$/i) { + $default = ""; + } + elsif ($default =~ /^$/i) { + $default = $CODE_POINT; + } + + # Store them as a sub-arrays with both components. + push @{$missings{$addr}}, [ $default, $property ]; + } + } + + # There is nothing for the caller to process on this comment + # line. + next; + } + + # Remove comments and trailing space, and skip this line if the + # result is empty + s/#.*//; + s/\s+$//; + next if /^$/; + + # Call any handlers for this line, and skip further processing of + # the line if the handler sets the line to null. + foreach my $sub_ref (@{$each_line_handler{$addr}}) { + &{$sub_ref}($self); + next LINE if /^$/; + } + + # Here the line is ok. return success. + return 1; + } # End of looping through lines. + + # If there is an EOF handler, call it (only once) and if it generates + # more lines to process go back in the loop to handle them. + if ($eof_handler{$addr}) { + &{$eof_handler{$addr}}($self); + $eof_handler{$addr} = ""; # Currently only get one shot at it. + goto LINE if $added_lines{$addr}; + } + + # Return failure -- no more lines. + return 0; + + } + +# Not currently used, not fully tested. +# sub peek { +# # Non-destructive look-ahead one non-adjusted, non-comment, non-blank +# # record. Not callable from an each_line_handler(), nor does it call +# # an each_line_handler() on the line. +# +# my $self = shift; +# my $addr = main::objaddr $self; +# +# foreach my $inserted_ref (@{$added_lines{$addr}}) { +# my ($adjusted, $line) = @{$inserted_ref}; +# next if $adjusted; +# +# # Remove comments and trailing space, and return a non-empty +# # resulting line +# $line =~ s/#.*//; +# $line =~ s/\s+$//; +# return $line if $line ne ""; +# } +# +# return if ! ref $handle{$addr}; # Don't read unless is real file +# while (1) { # Loop until find non-comment, non-empty line +# local $to_trace = 1 if main::DEBUG; +# trace $_ if main::DEBUG && $to_trace; +# return if ! defined (my $line = readline $handle{$addr}); +# chomp $line; +# push @{$added_lines{$addr}}, [ 0, $line ]; +# +# $line =~ s/#.*//; +# $line =~ s/\s+$//; +# return $line if $line ne ""; +# } +# +# return; +# } + + + sub insert_lines { + # Lines can be inserted so that it looks like they were in the input + # file at the place it was when this routine is called. See also + # insert_adjusted_lines(). Lines inserted via this routine go through + # any each_line_handler() + + my $self = shift; + + # Each inserted line is an array, with the first element being 0 to + # indicate that this line hasn't been adjusted, and needs to be + # processed. + push @{$added_lines{main::objaddr $self}}, map { [ 0, $_ ] } @_; + return; + } + + sub insert_adjusted_lines { + # Lines can be inserted so that it looks like they were in the input + # file at the place it was when this routine is called. See also + # insert_lines(). Lines inserted via this routine are already fully + # adjusted, ready to be processed; each_line_handler()s handlers will + # not be called. This means this is not a completely general + # facility, as only the last each_line_handler on the stack should + # call this. It could be made more general, by passing to each of the + # line_handlers their position on the stack, which they would pass on + # to this routine, and that would replace the boolean first element in + # the anonymous array pushed here, so that the next_line routine could + # use that to call only those handlers whose index is after it on the + # stack. But this is overkill for what is needed now. + + my $self = shift; + trace $_[0] if main::DEBUG && $to_trace; + + # Each inserted line is an array, with the first element being 1 to + # indicate that this line has been adjusted + push @{$added_lines{main::objaddr $self}}, map { [ 1, $_ ] } @_; + return; + } + + sub get_missings { + # Returns the stored up @missings lines' values, and clears the list. + # The values are in an array, consisting of the default in the first + # element, and the property in the 2nd. However, since these lines + # can be stacked up, the return is an array of all these arrays. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + # If not accepting a list return, just return the first one. + return shift @{$missings{$addr}} unless wantarray; + + my @return = @{$missings{$addr}}; + undef @{$missings{$addr}}; + return @return; + } + + sub _insert_property_into_line { + # Add a property field to $_, if this file requires it. + + my $property = $property{main::objaddr shift}; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + $_ =~ s/(;|$)/; $property$1/; + return; + } + + sub carp_bad_line { + # Output consistent error messages, using either a generic one, or the + # one given by the optional parameter. To avoid gazillions of the + # same message in case the syntax of a file is way off, this routine + # only outputs the first instance of each message, incrementing a + # count so the totals can be output at the end of the file. + + my $self = shift; + my $message = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + $message = 'Unexpected line' unless $message; + + # No trailing punctuation so as to fit with our addenda. + $message =~ s/[.:;,]$//; + + # If haven't seen this exact message before, output it now. Otherwise + # increment the count of how many times it has occurred + unless ($errors{$addr}->{$message}) { + Carp::my_carp("$message in '$_' in " + . $file{main::objaddr $self} + . " at line $.. Skipping this line;"); + $errors{$addr}->{$message} = 1; + } + else { + $errors{$addr}->{$message}++; + } + + # Clear the line to prevent any further (meaningful) processing of it. + $_ = ""; + + return; + } +} # End closure + +package Multi_Default; + +# Certain properties in early versions of Unicode had more than one possible +# default for code points missing from the files. In these cases, one +# default applies to everything left over after all the others are applied, +# and for each of the others, there is a description of which class of code +# points applies to it. This object helps implement this by storing the +# defaults, and for all but that final default, an eval string that generates +# the class that it applies to. + + +{ # Closure + + main::setup_package(); + + my %class_defaults; + # The defaults structure for the classes + main::set_access('class_defaults', \%class_defaults); + + my %other_default; + # The default that applies to everything left over. + main::set_access('other_default', \%other_default, 'r'); + + + sub new { + # The constructor is called with default => eval pairs, terminated by + # the left-over default. e.g. + # Multi_Default->new( + # 'T' => '$gc->table("Mn") + $gc->table("Cf") - 0x200C + # - 0x200D', + # 'R' => 'some other expression that evaluates to code points', + # . + # . + # . + # 'U')); + + my $class = shift; + + my $self = bless \do{my $anonymous_scalar}, $class; + my $addr = main::objaddr($self); + + while (@_ > 1) { + my $default = shift; + my $eval = shift; + $class_defaults{$addr}->{$default} = $eval; + } + + $other_default{$addr} = shift; + + return $self; + } + + sub get_next_defaults { + # Iterates and returns the next class of defaults. + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + return each %{$class_defaults{$addr}}; + } +} + +package Alias; + +# An alias is one of the names that a table goes by. This class defines them +# including some attributes. Everything is currently setup in the +# constructor. + + +{ # Closure + + main::setup_package(); + + my %name; + main::set_access('name', \%name, 'r'); + + my %loose_match; + # Determined by the constructor code if this name should match loosely or + # not. The constructor parameters can override this, but it isn't fully + # implemented, as should have ability to override Unicode one's via + # something like a set_loose_match() + main::set_access('loose_match', \%loose_match, 'r'); + + my %make_pod_entry; + # Some aliases should not get their own entries because they are covered + # by a wild-card, and some we want to discourage use of. Binary + main::set_access('make_pod_entry', \%make_pod_entry, 'r'); + + my %status; + # Aliases have a status, like deprecated, or even suppressed (which means + # they don't appear in documentation). Enum + main::set_access('status', \%status, 'r'); + + my %externally_ok; + # Similarly, some aliases should not be considered as usable ones for + # external use, such as file names, or we don't want documentation to + # recommend them. Boolean + main::set_access('externally_ok', \%externally_ok, 'r'); + + sub new { + my $class = shift; + + my $self = bless \do { my $anonymous_scalar }, $class; + my $addr = main::objaddr($self); + + $name{$addr} = shift; + $loose_match{$addr} = shift; + $make_pod_entry{$addr} = shift; + $externally_ok{$addr} = shift; + $status{$addr} = shift; + + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # Null names are never ok externally + $externally_ok{$addr} = 0 if $name{$addr} eq ""; + + return $self; + } +} + +package Range; + +# A range is the basic unit for storing code points, and is described in the +# comments at the beginning of the program. Each range has a starting code +# point; an ending code point (not less than the starting one); a value +# that applies to every code point in between the two end-points, inclusive; +# and an enum type that applies to the value. The type is for the user's +# convenience, and has no meaning here, except that a non-zero type is +# considered to not obey the normal Unicode rules for having standard forms. +# +# The same structure is used for both map and match tables, even though in the +# latter, the value (and hence type) is irrelevant and could be used as a +# comment. In map tables, the value is what all the code points in the range +# map to. Type 0 values have the standardized version of the value stored as +# well, so as to not have to recalculate it a lot. + +sub trace { return main::trace(@_); } + +{ # Closure + + main::setup_package(); + + my %start; + main::set_access('start', \%start, 'r', 's'); + + my %end; + main::set_access('end', \%end, 'r', 's'); + + my %value; + main::set_access('value', \%value, 'r'); + + my %type; + main::set_access('type', \%type, 'r'); + + my %standard_form; + # The value in internal standard form. Defined only if the type is 0. + main::set_access('standard_form', \%standard_form); + + # Note that if these fields change, the dump() method should as well + + sub new { + return Carp::carp_too_few_args(\@_, 3) if main::DEBUG && @_ < 3; + my $class = shift; + + my $self = bless \do { my $anonymous_scalar }, $class; + my $addr = main::objaddr($self); + + $start{$addr} = shift; + $end{$addr} = shift; + + my %args = @_; + + my $value = delete $args{'Value'}; # Can be 0 + $value = "" unless defined $value; + $value{$addr} = $value; + + $type{$addr} = delete $args{'Type'} || 0; + + Carp::carp_extra_args(\%args) if main::DEBUG && %args; + + if (! $type{$addr}) { + $standard_form{$addr} = main::standardize($value); + } + + return $self; + } + + use overload + fallback => 0, + qw("") => "_operator_stringify", + "." => \&main::_operator_dot, + ; + + sub _operator_stringify { + my $self = shift; + my $addr = main::objaddr $self; + + # Output it like '0041..0065 (value)' + my $return = sprintf("%04X", $start{$addr}) + . '..' + . sprintf("%04X", $end{$addr}); + my $value = $value{$addr}; + my $type = $type{$addr}; + $return .= ' ('; + $return .= "$value"; + $return .= ", Type=$type" if $type != 0; + $return .= ')'; + + return $return; + } + + sub standard_form { + # The standard form is the value itself if the standard form is + # undefined (that is if the value is special) + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + return $standard_form{$addr} if defined $standard_form{$addr}; + return $value{$addr}; + } + + sub dump { + # Human, not machine readable. For machine readable, comment out this + # entire routine and let the standard one take effect. + my $self = shift; + my $indent = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + my $return = $indent + . sprintf("%04X", $start{$addr}) + . '..' + . sprintf("%04X", $end{$addr}) + . " '$value{$addr}';"; + if (! defined $standard_form{$addr}) { + $return .= "(type=$type{$addr})"; + } + elsif ($standard_form{$addr} ne $value{$addr}) { + $return .= "(standard '$standard_form{$addr}')"; + } + return $return; + } +} # End closure + +package _Range_List_Base; + +# Base class for range lists. A range list is simply an ordered list of +# ranges, so that the ranges with the lowest starting numbers are first in it. +# +# When a new range is added that is adjacent to an existing range that has the +# same value and type, it merges with it to form a larger range. +# +# Ranges generally do not overlap, except that there can be multiple entries +# of single code point ranges. This is because of NameAliases.txt. +# +# In this program, there is a standard value such that if two different +# values, have the same standard value, they are considered equivalent. This +# value was chosen so that it gives correct results on Unicode data + +# There are a number of methods to manipulate range lists, and some operators +# are overloaded to handle them. + +# Because of the slowness of pure Perl objaddr() on miniperl, and measurements +# showing this package was using a lot of real time calculating that, the code +# was changed to only calculate it once per call stack. This is done by +# consistently using the package variable $addr in routines, and only calling +# objaddr() if it isn't defined, and setting that to be local, so that callees +# will have it already. It would be a good thing to change this. XXX + +sub trace { return main::trace(@_); } + +{ # Closure + + our $addr; + + main::setup_package(); + + my %ranges; + # The list of ranges + main::set_access('ranges', \%ranges, 'readable_array'); + + my %max; + # The highest code point in the list. This was originally a method, but + # actual measurements said it was used a lot. + main::set_access('max', \%max, 'r'); + + my %each_range_iterator; + # Iterator position for each_range() + main::set_access('each_range_iterator', \%each_range_iterator); + + my %owner_name_of; + # Name of parent this is attached to, if any. Solely for better error + # messages. + main::set_access('owner_name_of', \%owner_name_of, 'p_r'); + + my %_search_ranges_cache; + # A cache of the previous result from _search_ranges(), for better + # performance + main::set_access('_search_ranges_cache', \%_search_ranges_cache); + + sub new { + my $class = shift; + my %args = @_; + + # Optional initialization data for the range list. + my $initialize = delete $args{'Initialize'}; + + my $self; + + # Use _union() to initialize. _union() returns an object of this + # class, which means that it will call this constructor recursively. + # But it won't have this $initialize parameter so that it won't + # infinitely loop on this. + return _union($class, $initialize, %args) if defined $initialize; + + $self = bless \do { my $anonymous_scalar }, $class; + local $addr = main::objaddr($self); + + # Optional parent object, only for debug info. + $owner_name_of{$addr} = delete $args{'Owner'}; + $owner_name_of{$addr} = "" if ! defined $owner_name_of{$addr}; + + # Stringify, in case it is an object. + $owner_name_of{$addr} = "$owner_name_of{$addr}"; + + # This is used only for error messages, and so a colon is added + $owner_name_of{$addr} .= ": " if $owner_name_of{$addr} ne ""; + + Carp::carp_extra_args(\%args) if main::DEBUG && %args; + + # Max is initialized to a negative value that isn't adjacent to 0, + # for simpler tests + $max{$addr} = -2; + + $_search_ranges_cache{$addr} = 0; + $ranges{$addr} = []; + + return $self; + } + + use overload + fallback => 0, + qw("") => "_operator_stringify", + "." => \&main::_operator_dot, + ; + + sub _operator_stringify { + my $self = shift; + local $addr = main::objaddr($self) if !defined $addr; + + return "Range_List attached to '$owner_name_of{$addr}'" + if $owner_name_of{$addr}; + return "anonymous Range_List " . \$self; + } + + sub _union { + # Returns the union of the input code points. It can be called as + # either a constructor or a method. If called as a method, the result + # will be a new() instance of the calling object, containing the union + # of that object with the other parameter's code points; if called as + # a constructor, the first parameter gives the class the new object + # should be, and the second parameter gives the code points to go into + # it. + # In either case, there are two parameters looked at by this routine; + # any additional parameters are passed to the new() constructor. + # + # The code points can come in the form of some object that contains + # ranges, and has a conventionally named method to access them; or + # they can be an array of individual code points (as integers); or + # just a single code point. + # + # If they are ranges, this routine doesn't make any effort to preserve + # the range values of one input over the other. Therefore this base + # class should not allow _union to be called from other than + # initialization code, so as to prevent two tables from being added + # together where the range values matter. The general form of this + # routine therefore belongs in a derived class, but it was moved here + # to avoid duplication of code. The failure to overload this in this + # class keeps it safe. + # + + my $self; + my @args; # Arguments to pass to the constructor + + my $class = shift; + + # If a method call, will start the union with the object itself, and + # the class of the new object will be the same as self. + if (ref $class) { + $self = $class; + $class = ref $self; + push @args, $self; + } + + # Add the other required parameter. + push @args, shift; + # Rest of parameters are passed on to the constructor + + # Accumulate all records from both lists. + my @records; + for my $arg (@args) { + #local $to_trace = 0 if main::DEBUG; + trace "argument = $arg" if main::DEBUG && $to_trace; + if (! defined $arg) { + my $message = ""; + if (defined $self) { + $message .= $owner_name_of{main::objaddr $self}; + } + Carp::my_carp_bug($message .= "Undefined argument to _union. No union done."); + return; + } + $arg = [ $arg ] if ! ref $arg; + my $type = ref $arg; + if ($type eq 'ARRAY') { + foreach my $element (@$arg) { + push @records, Range->new($element, $element); + } + } + elsif ($arg->isa('Range')) { + push @records, $arg; + } + elsif ($arg->can('ranges')) { + push @records, $arg->ranges; + } + else { + my $message = ""; + if (defined $self) { + $message .= $owner_name_of{main::objaddr $self}; + } + Carp::my_carp_bug($message . "Cannot take the union of a $type. No union done."); + return; + } + } + + # Sort with the range containing the lowest ordinal first, but if + # two ranges start at the same code point, sort with the bigger range + # of the two first, because it takes fewer cycles. + @records = sort { ($a->start <=> $b->start) + or + # if b is shorter than a, b->end will be + # less than a->end, and we want to select + # a, so want to return -1 + ($b->end <=> $a->end) + } @records; + + my $new = $class->new(@_); + + # Fold in records so long as they add new information. + for my $set (@records) { + my $start = $set->start; + my $end = $set->end; + my $value = $set->value; + if ($start > $new->max) { + $new->_add_delete('+', $start, $end, $value); + } + elsif ($end > $new->max) { + $new->_add_delete('+', $new->max +1, $end, $value); + } + } + + return $new; + } + + sub range_count { # Return the number of ranges in the range list + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + local $addr = main::objaddr($self) if ! defined $addr; + + return scalar @{$ranges{$addr}}; + } + + sub min { + # Returns the minimum code point currently in the range list, or if + # the range list is empty, 2 beyond the max possible. This is a + # method because used so rarely, that not worth saving between calls, + # and having to worry about changing it as ranges are added and + # deleted. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + local $addr = main::objaddr($self) if ! defined $addr; + + # If the range list is empty, return a large value that isn't adjacent + # to any that could be in the range list, for simpler tests + return $LAST_UNICODE_CODEPOINT + 2 unless scalar @{$ranges{$addr}}; + return $ranges{$addr}->[0]->start; + } + + sub contains { + # Boolean: Is argument in the range list? If so returns $i such that: + # range[$i]->end < $codepoint <= range[$i+1]->end + # which is one beyond what you want; this is so that the 0th range + # doesn't return false + my $self = shift; + my $codepoint = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + local $addr = main::objaddr $self if ! defined $addr; + + my $i = $self->_search_ranges($codepoint); + return 0 unless defined $i; + + # The search returns $i, such that + # range[$i-1]->end < $codepoint <= range[$i]->end + # So is in the table if and only iff it is at least the start position + # of range $i. + return 0 if $ranges{$addr}->[$i]->start > $codepoint; + return $i + 1; + } + + sub value_of { + # Returns the value associated with the code point, undef if none + + my $self = shift; + my $codepoint = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + local $addr = main::objaddr $self if ! defined $addr; + + my $i = $self->contains($codepoint); + return unless $i; + + # contains() returns 1 beyond where we should look + return $ranges{$addr}->[$i-1]->value; + } + + sub _search_ranges { + # Find the range in the list which contains a code point, or where it + # should go if were to add it. That is, it returns $i, such that: + # range[$i-1]->end < $codepoint <= range[$i]->end + # Returns undef if no such $i is possible (e.g. at end of table), or + # if there is an error. + + my $self = shift; + my $code_point = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + local $addr = main::objaddr $self if ! defined $addr; + + return if $code_point > $max{$addr}; + my $r = $ranges{$addr}; # The current list of ranges + my $range_list_size = scalar @$r; + my $i; + + use integer; # want integer division + + # Use the cached result as the starting guess for this one, because, + # an experiment on 5.1 showed that 90% of the time the cache was the + # same as the result on the next call (and 7% it was one less). + $i = $_search_ranges_cache{$addr}; + $i = 0 if $i >= $range_list_size; # Reset if no longer valid (prob. + # from an intervening deletion + #local $to_trace = 1 if main::DEBUG; + trace "previous \$i is still valid: $i" if main::DEBUG && $to_trace && $code_point <= $r->[$i]->end && ($i == 0 || $r->[$i-1]->end < $code_point); + return $i if $code_point <= $r->[$i]->end + && ($i == 0 || $r->[$i-1]->end < $code_point); + + # Here the cache doesn't yield the correct $i. Try adding 1. + if ($i < $range_list_size - 1 + && $r->[$i]->end < $code_point && + $code_point <= $r->[$i+1]->end) + { + $i++; + trace "next \$i is correct: $i" if main::DEBUG && $to_trace; + $_search_ranges_cache{$addr} = $i; + return $i; + } + + # Here, adding 1 also didn't work. We do a binary search to + # find the correct position, starting with current $i + my $lower = 0; + my $upper = $range_list_size - 1; + while (1) { + trace "top of loop i=$i:", sprintf("%04X", $r->[$lower]->start), "[$lower] .. ", sprintf("%04X", $r->[$i]->start), "[$i] .. ", sprintf("%04X", $r->[$upper]->start), "[$upper]" if main::DEBUG && $to_trace; + + if ($code_point <= $r->[$i]->end) { + + # Here we have met the upper constraint. We can quit if we + # also meet the lower one. + last if $i == 0 || $r->[$i-1]->end < $code_point; + + $upper = $i; # Still too high. + + } + else { + + # Here, $r[$i]->end < $code_point, so look higher up. + $lower = $i; + } + + # Split search domain in half to try again. + my $temp = ($upper + $lower) / 2; + + # No point in continuing unless $i changes for next time + # in the loop. + if ($temp == $i) { + + # We can't reach the highest element because of the averaging. + # So if one below the upper edge, force it there and try one + # more time. + if ($i == $range_list_size - 2) { + + trace "Forcing to upper edge" if main::DEBUG && $to_trace; + $i = $range_list_size - 1; + + # Change $lower as well so if fails next time through, + # taking the average will yield the same $i, and we will + # quit with the error message just below. + $lower = $i; + next; + } + Carp::my_carp_bug("$owner_name_of{$addr}Can't find where the range ought to go. No action taken."); + return; + } + $i = $temp; + } # End of while loop + + if (main::DEBUG && $to_trace) { + trace 'i-1=[', $i-1, ']', $r->[$i-1] if $i; + trace "i= [ $i ]", $r->[$i]; + trace 'i+1=[', $i+1, ']', $r->[$i+1] if $i < $range_list_size - 1; + } + + # Here we have found the offset. Cache it as a starting point for the + # next call. + $_search_ranges_cache{$addr} = $i; + return $i; + } + + sub _add_delete { + # Add, replace or delete ranges to or from a list. The $type + # parameter gives which: + # '+' => insert or replace a range, returning a list of any changed + # ranges. + # '-' => delete a range, returning a list of any deleted ranges. + # + # The next three parameters give respectively the start, end, and + # value associated with the range. 'value' should be null unless the + # operation is '+'; + # + # The range list is kept sorted so that the range with the lowest + # starting position is first in the list, and generally, adjacent + # ranges with the same values are merged into single larger one (see + # exceptions below). + # + # There are more parameters, all are key => value pairs: + # Type gives the type of the value. It is only valid for '+'. + # All ranges have types; if this parameter is omitted, 0 is + # assumed. Ranges with type 0 are assumed to obey the + # Unicode rules for casing, etc; ranges with other types are + # not. Otherwise, the type is arbitrary, for the caller's + # convenience, and looked at only by this routine to keep + # adjacent ranges of different types from being merged into + # a single larger range, and when Replace => + # $IF_NOT_EQUIVALENT is specified (see just below). + # Replace determines what to do if the range list already contains + # ranges which coincide with all or portions of the input + # range. It is only valid for '+': + # => $NO means that the new value is not to replace + # any existing ones, but any empty gaps of the + # range list coinciding with the input range + # will be filled in with the new value. + # => $UNCONDITIONALLY means to replace the existing values with + # this one unconditionally. However, if the + # new and old values are identical, the + # replacement is skipped to save cycles + # => $IF_NOT_EQUIVALENT means to replace the existing values + # with this one if they are not equivalent. + # Ranges are equivalent if their types are the + # same, and they are the same string, or if + # both are type 0 ranges, if their Unicode + # standard forms are identical. In this last + # case, the routine chooses the more "modern" + # one to use. This is because some of the + # older files are formatted with values that + # are, for example, ALL CAPs, whereas the + # derived files have a more modern style, + # which looks better. By looking for this + # style when the pre-existing and replacement + # standard forms are the same, we can move to + # the modern style + # => $MULTIPLE means that if this range duplicates an + # existing one, but has a different value, + # don't replace the existing one, but insert + # this, one so that the same range can occur + # multiple times. + # => anything else is the same as => $IF_NOT_EQUIVALENT + # + # "same value" means identical for type-0 ranges, and it means having + # the same standard forms for non-type-0 ranges. + + return Carp::carp_too_few_args(\@_, 5) if main::DEBUG && @_ < 5; + + my $self = shift; + my $operation = shift; # '+' for add/replace; '-' for delete; + my $start = shift; + my $end = shift; + my $value = shift; + + my %args = @_; + + $value = "" if not defined $value; # warning: $value can be "0" + + my $replace = delete $args{'Replace'}; + $replace = $IF_NOT_EQUIVALENT unless defined $replace; + + my $type = delete $args{'Type'}; + $type = 0 unless defined $type; + + Carp::carp_extra_args(\%args) if main::DEBUG && %args; + + local $addr = main::objaddr($self) if ! defined $addr; + + if ($operation ne '+' && $operation ne '-') { + Carp::my_carp_bug("$owner_name_of{$addr}First parameter to _add_delete must be '+' or '-'. No action taken."); + return; + } + unless (defined $start && defined $end) { + Carp::my_carp_bug("$owner_name_of{$addr}Undefined start and/or end to _add_delete. No action taken."); + return; + } + unless ($end >= $start) { + Carp::my_carp_bug("$owner_name_of{$addr}End of range (" . sprintf("%04X", $end) . ") must not be before start (" . sprintf("%04X", $start) . "). No action taken."); + return; + } + #local $to_trace = 1 if main::DEBUG; + + if ($operation eq '-') { + if ($replace != $IF_NOT_EQUIVALENT) { + Carp::my_carp_bug("$owner_name_of{$addr}Replace => \$IF_NOT_EQUIVALENT is required when deleting a range from a range list. Assuming Replace => \$IF_NOT_EQUIVALENT."); + $replace = $IF_NOT_EQUIVALENT; + } + if ($type) { + Carp::my_carp_bug("$owner_name_of{$addr}Type => 0 is required when deleting a range from a range list. Assuming Type => 0."); + $type = 0; + } + if ($value ne "") { + Carp::my_carp_bug("$owner_name_of{$addr}Value => \"\" is required when deleting a range from a range list. Assuming Value => \"\"."); + $value = ""; + } + } + + my $r = $ranges{$addr}; # The current list of ranges + my $range_list_size = scalar @$r; # And its size + my $max = $max{$addr}; # The current high code point in + # the list of ranges + + # Do a special case requiring fewer machine cycles when the new range + # starts after the current highest point. The Unicode input data is + # structured so this is common. + if ($start > $max) { + + trace "$owner_name_of{$addr} $operation", sprintf("%04X", $start) . '..' . sprintf("%04X", $end) . " ($value) type=$type" if main::DEBUG && $to_trace; + return if $operation eq '-'; # Deleting a non-existing range is a + # no-op + + # If the new range doesn't logically extend the current final one + # in the range list, create a new range at the end of the range + # list. (max cleverly is initialized to a negative number not + # adjacent to 0 if the range list is empty, so even adding a range + # to an empty range list starting at 0 will have this 'if' + # succeed.) + if ($start > $max + 1 # non-adjacent means can't extend. + || @{$r}[-1]->value ne $value # values differ, can't extend. + || @{$r}[-1]->type != $type # types differ, can't extend. + ) { + push @$r, Range->new($start, $end, + Value => $value, + Type => $type); + } + else { + + # Here, the new range starts just after the current highest in + # the range list, and they have the same type and value. + # Extend the current range to incorporate the new one. + @{$r}[-1]->set_end($end); + } + + # This becomes the new maximum. + $max{$addr} = $end; + + return; + } + #local $to_trace = 0 if main::DEBUG; + + trace "$owner_name_of{$addr} $operation", sprintf("%04X", $start) . '..' . sprintf("%04X", $end) . " ($value) replace=$replace" if main::DEBUG && $to_trace; + + # Here, the input range isn't after the whole rest of the range list. + # Most likely 'splice' will be needed. The rest of the routine finds + # the needed splice parameters, and if necessary, does the splice. + # First, find the offset parameter needed by the splice function for + # the input range. Note that the input range may span multiple + # existing ones, but we'll worry about that later. For now, just find + # the beginning. If the input range is to be inserted starting in a + # position not currently in the range list, it must (obviously) come + # just after the range below it, and just before the range above it. + # Slightly less obviously, it will occupy the position currently + # occupied by the range that is to come after it. More formally, we + # are looking for the position, $i, in the array of ranges, such that: + # + # r[$i-1]->start <= r[$i-1]->end < $start < r[$i]->start <= r[$i]->end + # + # (The ordered relationships within existing ranges are also shown in + # the equation above). However, if the start of the input range is + # within an existing range, the splice offset should point to that + # existing range's position in the list; that is $i satisfies a + # somewhat different equation, namely: + # + #r[$i-1]->start <= r[$i-1]->end < r[$i]->start <= $start <= r[$i]->end + # + # More briefly, $start can come before or after r[$i]->start, and at + # this point, we don't know which it will be. However, these + # two equations share these constraints: + # + # r[$i-1]->end < $start <= r[$i]->end + # + # And that is good enough to find $i. + + my $i = $self->_search_ranges($start); + if (! defined $i) { + Carp::my_carp_bug("Searching $self for range beginning with $start unexpectedly returned undefined. Operation '$operation' not performed"); + return; + } + + # The search function returns $i such that: + # + # r[$i-1]->end < $start <= r[$i]->end + # + # That means that $i points to the first range in the range list + # that could possibly be affected by this operation. We still don't + # know if the start of the input range is within r[$i], or if it + # points to empty space between r[$i-1] and r[$i]. + trace "[$i] is the beginning splice point. Existing range there is ", $r->[$i] if main::DEBUG && $to_trace; + + # Special case the insertion of data that is not to replace any + # existing data. + if ($replace == $NO) { # If $NO, has to be operation '+' + #local $to_trace = 1 if main::DEBUG; + trace "Doesn't replace" if main::DEBUG && $to_trace; + + # Here, the new range is to take effect only on those code points + # that aren't already in an existing range. This can be done by + # looking through the existing range list and finding the gaps in + # the ranges that this new range affects, and then calling this + # function recursively on each of those gaps, leaving untouched + # anything already in the list. Gather up a list of the changed + # gaps first so that changes to the internal state as new ranges + # are added won't be a problem. + my @gap_list; + + # First, if the starting point of the input range is outside an + # existing one, there is a gap from there to the beginning of the + # existing range -- add a span to fill the part that this new + # range occupies + if ($start < $r->[$i]->start) { + push @gap_list, Range->new($start, + main::min($end, + $r->[$i]->start - 1), + Type => $type); + trace "gap before $r->[$i] [$i], will add", $gap_list[-1] if main::DEBUG && $to_trace; + } + + # Then look through the range list for other gaps until we reach + # the highest range affected by the input one. + my $j; + for ($j = $i+1; $j < $range_list_size; $j++) { + trace "j=[$j]", $r->[$j] if main::DEBUG && $to_trace; + last if $end < $r->[$j]->start; + + # If there is a gap between when this range starts and the + # previous one ends, add a span to fill it. Note that just + # because there are two ranges doesn't mean there is a + # non-zero gap between them. It could be that they have + # different values or types + if ($r->[$j-1]->end + 1 != $r->[$j]->start) { + push @gap_list, + Range->new($r->[$j-1]->end + 1, + $r->[$j]->start - 1, + Type => $type); + trace "gap between $r->[$j-1] and $r->[$j] [$j], will add: $gap_list[-1]" if main::DEBUG && $to_trace; + } + } + + # Here, we have either found an existing range in the range list, + # beyond the area affected by the input one, or we fell off the + # end of the loop because the input range affects the whole rest + # of the range list. In either case, $j is 1 higher than the + # highest affected range. If $j == $i, it means that there are no + # affected ranges, that the entire insertion is in the gap between + # r[$i-1], and r[$i], which we already have taken care of before + # the loop. + # On the other hand, if there are affected ranges, it might be + # that there is a gap that needs filling after the final such + # range to the end of the input range + if ($r->[$j-1]->end < $end) { + push @gap_list, Range->new(main::max($start, + $r->[$j-1]->end + 1), + $end, + Type => $type); + trace "gap after $r->[$j-1], will add $gap_list[-1]" if main::DEBUG && $to_trace; + } + + # Call recursively to fill in all the gaps. + foreach my $gap (@gap_list) { + $self->_add_delete($operation, + $gap->start, + $gap->end, + $value, + Type => $type); + } + + return; + } + + # Here, we have taken care of the case where $replace is $NO, which + # means that whatever action we now take is done unconditionally. It + # still could be that this call will result in a no-op, if duplicates + # aren't allowed, and we are inserting a range that merely duplicates + # data already in the range list; or also if deleting a non-existent + # range. + # $i still points to the first potential affected range. Now find the + # highest range affected, which will determine the length parameter to + # splice. (The input range can span multiple existing ones.) While + # we are looking through the range list, see also if this is an + # insertion that will change the values of at least one of the + # affected ranges. We don't need to do this check unless this is an + # insertion of non-multiples, and also since this is a boolean, we + # don't need to do it if have already determined that it will make a + # change; just unconditionally change them. $cdm is created to be 1 + # if either of these is true. (The 'c' in the name comes from below) + my $cdm = ($operation eq '-' || $replace == $MULTIPLE); + my $j; # This will point to the highest affected range + + # For non-zero types, the standard form is the value itself; + my $standard_form = ($type) ? $value : main::standardize($value); + + for ($j = $i; $j < $range_list_size; $j++) { + trace "Looking for highest affected range; the one at $j is ", $r->[$j] if main::DEBUG && $to_trace; + + # If find a range that it doesn't overlap into, we can stop + # searching + last if $end < $r->[$j]->start; + + # Here, overlaps the range at $j. If the value's don't match, + # and this is supposedly an insertion, it becomes a change + # instead. This is what the 'c' stands for in $cdm. + if (! $cdm) { + if ($r->[$j]->standard_form ne $standard_form) { + $cdm = 1; + } + else { + + # Here, the two values are essentially the same. If the + # two are actually identical, replacing wouldn't change + # anything so skip it. + my $pre_existing = $r->[$j]->value; + if ($pre_existing ne $value) { + + # Here the new and old standardized values are the + # same, but the non-standardized values aren't. If + # replacing unconditionally, then replace + if( $replace == $UNCONDITIONALLY) { + $cdm = 1; + } + else { + + # Here, are replacing conditionally. Decide to + # replace or not based on which appears to look + # the "nicest". If one is mixed case and the + # other isn't, choose the mixed case one. + my $new_mixed = $value =~ /[A-Z]/ + && $value =~ /[a-z]/; + my $old_mixed = $pre_existing =~ /[A-Z]/ + && $pre_existing =~ /[a-z]/; + + if ($old_mixed != $new_mixed) { + $cdm = 1 if $new_mixed; + if (main::DEBUG && $to_trace) { + if ($cdm) { + trace "Replacing $pre_existing with $value"; + } + else { + trace "Retaining $pre_existing over $value"; + } + } + } + else { + + # Here casing wasn't different between the two. + # If one has hyphens or underscores and the + # other doesn't, choose the one with the + # punctuation. + my $new_punct = $value =~ /[-_]/; + my $old_punct = $pre_existing =~ /[-_]/; + + if ($old_punct != $new_punct) { + $cdm = 1 if $new_punct; + if (main::DEBUG && $to_trace) { + if ($cdm) { + trace "Replacing $pre_existing with $value"; + } + else { + trace "Retaining $pre_existing over $value"; + } + } + } # else existing one is just as "good"; + # retain it to save cycles. + } + } + } + } + } + } # End of loop looking for highest affected range. + + # Here, $j points to one beyond the highest range that this insertion + # affects (hence to beyond the range list if that range is the final + # one in the range list). + + # The splice length is all the affected ranges. Get it before + # subtracting, for efficiency, so we don't have to later add 1. + my $length = $j - $i; + + $j--; # $j now points to the highest affected range. + trace "Final affected range is $j: $r->[$j]" if main::DEBUG && $to_trace; + + # If inserting a multiple record, this is where it goes, after all the + # existing ones for this range. This implies an insertion, and no + # change to any existing ranges. Note that $j can be -1 if this new + # range doesn't actually duplicate any existing, and comes at the + # beginning of the list, in which case we can handle it like any other + # insertion, and is easier to do so. + if ($replace == $MULTIPLE && $j >= 0) { + + # This restriction could be remedied with a little extra work, but + # it won't hopefully ever be necessary + if ($r->[$j]->start != $r->[$j]->end) { + Carp::my_carp_bug("$owner_name_of{$addr}Can't cope with adding a multiple when the other range ($r->[$j]) contains more than one code point. No action taken."); + return; + } + + # Don't add an exact duplicate, as it isn't really a multiple + return if $value eq $r->[$j]->value && $type eq $r->[$j]->type; + + trace "Adding multiple record at $j+1 with $start..$end, $value" if main::DEBUG && $to_trace; + my @return = splice @$r, + $j+1, + 0, + Range->new($start, + $end, + Value => $value, + Type => $type); + if (main::DEBUG && $to_trace) { + trace "After splice:"; + trace 'j-2=[', $j-2, ']', $r->[$j-2] if $j >= 2; + trace 'j-1=[', $j-1, ']', $r->[$j-1] if $j >= 1; + trace "j =[", $j, "]", $r->[$j] if $j >= 0; + trace 'j+1=[', $j+1, ']', $r->[$j+1] if $j < @$r - 1; + trace 'j+2=[', $j+2, ']', $r->[$j+2] if $j < @$r - 2; + trace 'j+3=[', $j+3, ']', $r->[$j+3] if $j < @$r - 3; + } + return @return; + } + + # Here, have taken care of $NO and $MULTIPLE replaces. + # $j points to the highest affected range. But it can be < $i or even + # -1. These happen only if the insertion is entirely in the gap + # between r[$i-1] and r[$i]. Here's why: j < i means that the j loop + # above exited first time through with $end < $r->[$i]->start. (And + # then we subtracted one from j) This implies also that $start < + # $r->[$i]->start, but we know from above that $r->[$i-1]->end < + # $start, so the entire input range is in the gap. + if ($j < $i) { + + # Here the entire input range is in the gap before $i. + + if (main::DEBUG && $to_trace) { + if ($i) { + trace "Entire range is between $r->[$i-1] and $r->[$i]"; + } + else { + trace "Entire range is before $r->[$i]"; + } + } + return if $operation ne '+'; # Deletion of a non-existent range is + # a no-op + } + else { + + # Here the entire input range is not in the gap before $i. There + # is an affected one, and $j points to the highest such one. + + # At this point, here is the situation: + # This is not an insertion of a multiple, nor of tentative ($NO) + # data. + # $i points to the first element in the current range list that + # may be affected by this operation. In fact, we know + # that the range at $i is affected because we are in + # the else branch of this 'if' + # $j points to the highest affected range. + # In other words, + # r[$i-1]->end < $start <= r[$i]->end + # And: + # r[$i-1]->end < $start <= $end <= r[$j]->end + # + # Also: + # $cdm is a boolean which is set true if and only if this is a + # change or deletion (multiple was handled above). In + # other words, it could be renamed to be just $cd. + + # We now have enough information to decide if this call is a no-op + # or not. It is a no-op if it is a deletion of a non-existent + # range, or an insertion of already existing data. + + if (main::DEBUG && $to_trace && ! $cdm + && $i == $j + && $start >= $r->[$i]->start) + { + trace "no-op"; + } + return if ! $cdm # change or delete => not no-op + && $i == $j # more than one affected range => not no-op + + # Here, r[$i-1]->end < $start <= $end <= r[$i]->end + # Further, $start and/or $end is >= r[$i]->start + # The test below hence guarantees that + # r[$i]->start < $start <= $end <= r[$i]->end + # This means the input range is contained entirely in + # the one at $i, so is a no-op + && $start >= $r->[$i]->start; + } + + # Here, we know that some action will have to be taken. We have + # calculated the offset and length (though adjustments may be needed) + # for the splice. Now start constructing the replacement list. + my @replacement; + my $splice_start = $i; + + my $extends_below; + my $extends_above; + + # See if should extend any adjacent ranges. + if ($operation eq '-') { # Don't extend deletions + $extends_below = $extends_above = 0; + } + else { # Here, should extend any adjacent ranges. See if there are + # any. + $extends_below = ($i > 0 + # can't extend unless adjacent + && $r->[$i-1]->end == $start -1 + # can't extend unless are same standard value + && $r->[$i-1]->standard_form eq $standard_form + # can't extend unless share type + && $r->[$i-1]->type == $type); + $extends_above = ($j+1 < $range_list_size + && $r->[$j+1]->start == $end +1 + && $r->[$j+1]->standard_form eq $standard_form + && $r->[$j-1]->type == $type); + } + if ($extends_below && $extends_above) { # Adds to both + $splice_start--; # start replace at element below + $length += 2; # will replace on both sides + trace "Extends both below and above ranges" if main::DEBUG && $to_trace; + + # The result will fill in any gap, replacing both sides, and + # create one large range. + @replacement = Range->new($r->[$i-1]->start, + $r->[$j+1]->end, + Value => $value, + Type => $type); + } + else { + + # Here we know that the result won't just be the conglomeration of + # a new range with both its adjacent neighbors. But it could + # extend one of them. + + if ($extends_below) { + + # Here the new element adds to the one below, but not to the + # one above. If inserting, and only to that one range, can + # just change its ending to include the new one. + if ($length == 0 && ! $cdm) { + $r->[$i-1]->set_end($end); + trace "inserted range extends range to below so it is now $r->[$i-1]" if main::DEBUG && $to_trace; + return; + } + else { + trace "Changing inserted range to start at ", sprintf("%04X", $r->[$i-1]->start), " instead of ", sprintf("%04X", $start) if main::DEBUG && $to_trace; + $splice_start--; # start replace at element below + $length++; # will replace the element below + $start = $r->[$i-1]->start; + } + } + elsif ($extends_above) { + + # Here the new element adds to the one above, but not below. + # Mirror the code above + if ($length == 0 && ! $cdm) { + $r->[$j+1]->set_start($start); + trace "inserted range extends range to above so it is now $r->[$j+1]" if main::DEBUG && $to_trace; + return; + } + else { + trace "Changing inserted range to end at ", sprintf("%04X", $r->[$j+1]->end), " instead of ", sprintf("%04X", $end) if main::DEBUG && $to_trace; + $length++; # will replace the element above + $end = $r->[$j+1]->end; + } + } + + trace "Range at $i is $r->[$i]" if main::DEBUG && $to_trace; + + # Finally, here we know there will have to be a splice. + # If the change or delete affects only the highest portion of the + # first affected range, the range will have to be split. The + # splice will remove the whole range, but will replace it by a new + # range containing just the unaffected part. So, in this case, + # add to the replacement list just this unaffected portion. + if (! $extends_below + && $start > $r->[$i]->start && $start <= $r->[$i]->end) + { + push @replacement, + Range->new($r->[$i]->start, + $start - 1, + Value => $r->[$i]->value, + Type => $r->[$i]->type); + } + + # In the case of an insert or change, but not a delete, we have to + # put in the new stuff; this comes next. + if ($operation eq '+') { + push @replacement, Range->new($start, + $end, + Value => $value, + Type => $type); + } + + trace "Range at $j is $r->[$j]" if main::DEBUG && $to_trace && $j != $i; + #trace "$end >=", $r->[$j]->start, " && $end <", $r->[$j]->end if main::DEBUG && $to_trace; + + # And finally, if we're changing or deleting only a portion of the + # highest affected range, it must be split, as the lowest one was. + if (! $extends_above + && $j >= 0 # Remember that j can be -1 if before first + # current element + && $end >= $r->[$j]->start + && $end < $r->[$j]->end) + { + push @replacement, + Range->new($end + 1, + $r->[$j]->end, + Value => $r->[$j]->value, + Type => $r->[$j]->type); + } + } + + # And do the splice, as calculated above + if (main::DEBUG && $to_trace) { + trace "replacing $length element(s) at $i with "; + foreach my $replacement (@replacement) { + trace " $replacement"; + } + trace "Before splice:"; + trace 'i-2=[', $i-2, ']', $r->[$i-2] if $i >= 2; + trace 'i-1=[', $i-1, ']', $r->[$i-1] if $i >= 1; + trace "i =[", $i, "]", $r->[$i]; + trace 'i+1=[', $i+1, ']', $r->[$i+1] if $i < @$r - 1; + trace 'i+2=[', $i+2, ']', $r->[$i+2] if $i < @$r - 2; + } + + my @return = splice @$r, $splice_start, $length, @replacement; + + if (main::DEBUG && $to_trace) { + trace "After splice:"; + trace 'i-2=[', $i-2, ']', $r->[$i-2] if $i >= 2; + trace 'i-1=[', $i-1, ']', $r->[$i-1] if $i >= 1; + trace "i =[", $i, "]", $r->[$i]; + trace 'i+1=[', $i+1, ']', $r->[$i+1] if $i < @$r - 1; + trace 'i+2=[', $i+2, ']', $r->[$i+2] if $i < @$r - 2; + trace "removed @return"; + } + + # An actual deletion could have changed the maximum in the list. + # There was no deletion if the splice didn't return something, but + # otherwise recalculate it. This is done too rarely to worry about + # performance. + if ($operation eq '-' && @return) { + $max{$addr} = $r->[-1]->end; + } + return @return; + } + + sub reset_each_range { # reset the iterator for each_range(); + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + local $addr = main::objaddr $self if ! defined $addr; + + undef $each_range_iterator{$addr}; + return; + } + + sub each_range { + # Iterate over each range in a range list. Results are undefined if + # the range list is changed during the iteration. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + local $addr = main::objaddr($self) if ! defined $addr; + + return if $self->is_empty; + + $each_range_iterator{$addr} = -1 + if ! defined $each_range_iterator{$addr}; + $each_range_iterator{$addr}++; + return $ranges{$addr}->[$each_range_iterator{$addr}] + if $each_range_iterator{$addr} < @{$ranges{$addr}}; + undef $each_range_iterator{$addr}; + return; + } + + sub count { # Returns count of code points in range list + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + local $addr = main::objaddr($self) if ! defined $addr; + + my $count = 0; + foreach my $range (@{$ranges{$addr}}) { + $count += $range->end - $range->start + 1; + } + return $count; + } + + sub delete_range { # Delete a range + my $self = shift; + my $start = shift; + my $end = shift; + + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + return $self->_add_delete('-', $start, $end, ""); + } + + sub is_empty { # Returns boolean as to if a range list is empty + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + local $addr = main::objaddr($self) if ! defined $addr; + return scalar @{$ranges{$addr}} == 0; + } + + sub hash { + # Quickly returns a scalar suitable for separating tables into + # buckets, i.e. it is a hash function of the contents of a table, so + # there are relatively few conflicts. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + local $addr = main::objaddr($self) if ! defined $addr; + + # These are quickly computable. Return looks like 'min..max;count' + return $self->min . "..$max{$addr};" . scalar @{$ranges{$addr}}; + } +} # End closure for _Range_List_Base + +package Range_List; +use base '_Range_List_Base'; + +# A Range_List is a range list for match tables; i.e. the range values are +# not significant. Thus a number of operations can be safely added to it, +# such as inversion, intersection. Note that union is also an unsafe +# operation when range values are cared about, and that method is in the base +# class, not here. But things are set up so that that method is callable only +# during initialization. Only in this derived class, is there an operation +# that combines two tables. A Range_Map can thus be used to initialize a +# Range_List, and its mappings will be in the list, but are not significant to +# this class. + +sub trace { return main::trace(@_); } + +{ # Closure + + use overload + fallback => 0, + '+' => sub { my $self = shift; + my $other = shift; + + return $self->_union($other) + }, + '&' => sub { my $self = shift; + my $other = shift; + + return $self->_intersect($other, 0); + }, + '~' => "_invert", + '-' => "_subtract", + ; + + sub _invert { + # Returns a new Range_List that gives all code points not in $self. + + my $self = shift; + + my $new = Range_List->new; + + # Go through each range in the table, finding the gaps between them + my $max = -1; # Set so no gap before range beginning at 0 + for my $range ($self->ranges) { + my $start = $range->start; + my $end = $range->end; + + # If there is a gap before this range, the inverse will contain + # that gap. + if ($start > $max + 1) { + $new->add_range($max + 1, $start - 1); + } + $max = $end; + } + + # And finally, add the gap from the end of the table to the max + # possible code point + if ($max < $LAST_UNICODE_CODEPOINT) { + $new->add_range($max + 1, $LAST_UNICODE_CODEPOINT); + } + return $new; + } + + sub _subtract { + # Returns a new Range_List with the argument deleted from it. The + # argument can be a single code point, a range, or something that has + # a range, with the _range_list() method on it returning them + + my $self = shift; + my $other = shift; + my $reversed = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + if ($reversed) { + Carp::my_carp_bug("Can't cope with a " + . __PACKAGE__ + . " being the second parameter in a '-'. Subtraction ignored."); + return $self; + } + + my $new = Range_List->new(Initialize => $self); + + if (! ref $other) { # Single code point + $new->delete_range($other, $other); + } + elsif ($other->isa('Range')) { + $new->delete_range($other->start, $other->end); + } + elsif ($other->can('_range_list')) { + foreach my $range ($other->_range_list->ranges) { + $new->delete_range($range->start, $range->end); + } + } + else { + Carp::my_carp_bug("Can't cope with a " + . ref($other) + . " argument to '-'. Subtraction ignored." + ); + return $self; + } + + return $new; + } + + sub _intersect { + # Returns either a boolean giving whether the two inputs' range lists + # intersect (overlap), or a new Range_List containing the intersection + # of the two lists. The optional final parameter being true indicates + # to do the check instead of the intersection. + + my $a_object = shift; + my $b_object = shift; + my $check_if_overlapping = shift; + $check_if_overlapping = 0 unless defined $check_if_overlapping; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + if (! defined $b_object) { + my $message = ""; + $message .= $a_object->_owner_name_of if defined $a_object; + Carp::my_carp_bug($message .= "Called with undefined value. Intersection not done."); + return; + } + + # a & b = !(!a | !b), or in our terminology = ~ ( ~a + -b ) + # Thus the intersection could be much more simply be written: + # return ~(~$a_object + ~$b_object); + # But, this is slower, and when taking the inverse of a large + # range_size_1 table, back when such tables were always stored that + # way, it became prohibitively slow, hence the code was changed to the + # below + + if ($b_object->isa('Range')) { + $b_object = Range_List->new(Initialize => $b_object, + Owner => $a_object->_owner_name_of); + } + $b_object = $b_object->_range_list if $b_object->can('_range_list'); + + my @a_ranges = $a_object->ranges; + my @b_ranges = $b_object->ranges; + + #local $to_trace = 1 if main::DEBUG; + trace "intersecting $a_object with ", scalar @a_ranges, "ranges and $b_object with", scalar @b_ranges, " ranges" if main::DEBUG && $to_trace; + + # Start with the first range in each list + my $a_i = 0; + my $range_a = $a_ranges[$a_i]; + my $b_i = 0; + my $range_b = $b_ranges[$b_i]; + + my $new = __PACKAGE__->new(Owner => $a_object->_owner_name_of) + if ! $check_if_overlapping; + + # If either list is empty, there is no intersection and no overlap + if (! defined $range_a || ! defined $range_b) { + return $check_if_overlapping ? 0 : $new; + } + trace "range_a[$a_i]=$range_a; range_b[$b_i]=$range_b" if main::DEBUG && $to_trace; + + # Otherwise, must calculate the intersection/overlap. Start with the + # very first code point in each list + my $a = $range_a->start; + my $b = $range_b->start; + + # Loop through all the ranges of each list; in each iteration, $a and + # $b are the current code points in their respective lists + while (1) { + + # If $a and $b are the same code point, ... + if ($a == $b) { + + # it means the lists overlap. If just checking for overlap + # know the answer now, + return 1 if $check_if_overlapping; + + # The intersection includes this code point plus anything else + # common to both current ranges. + my $start = $a; + my $end = main::min($range_a->end, $range_b->end); + if (! $check_if_overlapping) { + trace "adding intersection range ", sprintf("%04X", $start) . ".." . sprintf("%04X", $end) if main::DEBUG && $to_trace; + $new->add_range($start, $end); + } + + # Skip ahead to the end of the current intersect + $a = $b = $end; + + # If the current intersect ends at the end of either range (as + # it must for at least one of them), the next possible one + # will be the beginning code point in it's list's next range. + if ($a == $range_a->end) { + $range_a = $a_ranges[++$a_i]; + last unless defined $range_a; + $a = $range_a->start; + } + if ($b == $range_b->end) { + $range_b = $b_ranges[++$b_i]; + last unless defined $range_b; + $b = $range_b->start; + } + + trace "range_a[$a_i]=$range_a; range_b[$b_i]=$range_b" if main::DEBUG && $to_trace; + } + elsif ($a < $b) { + + # Not equal, but if the range containing $a encompasses $b, + # change $a to be the middle of the range where it does equal + # $b, so the next iteration will get the intersection + if ($range_a->end >= $b) { + $a = $b; + } + else { + + # Here, the current range containing $a is entirely below + # $b. Go try to find a range that could contain $b. + $a_i = $a_object->_search_ranges($b); + + # If no range found, quit. + last unless defined $a_i; + + # The search returns $a_i, such that + # range_a[$a_i-1]->end < $b <= range_a[$a_i]->end + # Set $a to the beginning of this new range, and repeat. + $range_a = $a_ranges[$a_i]; + $a = $range_a->start; + } + } + else { # Here, $b < $a. + + # Mirror image code to the leg just above + if ($range_b->end >= $a) { + $b = $a; + } + else { + $b_i = $b_object->_search_ranges($a); + last unless defined $b_i; + $range_b = $b_ranges[$b_i]; + $b = $range_b->start; + } + } + } # End of looping through ranges. + + # Intersection fully computed, or now know that there is no overlap + return $check_if_overlapping ? 0 : $new; + } + + sub overlaps { + # Returns boolean giving whether the two arguments overlap somewhere + + my $self = shift; + my $other = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + return $self->_intersect($other, 1); + } + + sub add_range { + # Add a range to the list. + + my $self = shift; + my $start = shift; + my $end = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + return $self->_add_delete('+', $start, $end, ""); + } + + my $non_ASCII = (ord('A') == 65); # Assumes test on same platform + + sub is_code_point_usable { + # This used only for making the test script. See if the input + # proposed trial code point is one that Perl will handle. If second + # parameter is 0, it won't select some code points for various + # reasons, noted below. + + my $code = shift; + my $try_hard = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + return 0 if $code < 0; # Never use a negative + + # For non-ASCII, we shun the characters that don't have Perl encoding- + # independent symbols for them. 'A' is such a symbol, so is "\n". + # Note, this program hopefully will work on 5.8 Perls, and \v is not + # such a symbol in them. + return $try_hard if $non_ASCII + && $code <= 0xFF + && ($code >= 0x7F + || ($code >= 0x0E && $code <= 0x1F) + || ($code >= 0x01 && $code <= 0x06) + || $code == 0x0B); # \v introduced after 5.8 + + # shun null. I'm (khw) not sure why this was done, but NULL would be + # the character very frequently used. + return $try_hard if $code == 0x0000; + + return 0 if $try_hard; # XXX Temporary until fix utf8.c + + # shun non-character code points. + return $try_hard if $code >= 0xFDD0 && $code <= 0xFDEF; + return $try_hard if ($code & 0xFFFE) == 0xFFFE; # includes FFFF + + return $try_hard if $code > $LAST_UNICODE_CODEPOINT; # keep in range + return $try_hard if $code >= 0xD800 && $code <= 0xDFFF; # no surrogate + + return 1; + } + + sub get_valid_code_point { + # Return a code point that's part of the range list. Returns nothing + # if the table is empty or we can't find a suitable code point. This + # used only for making the test script. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr($self); + + # On first pass, don't choose less desirable code points; if no good + # one is found, repeat, allowing a less desirable one to be selected. + for my $try_hard (0, 1) { + + # Look through all the ranges for a usable code point. + for my $set ($self->ranges) { + + # Try the edge cases first, starting with the end point of the + # range. + my $end = $set->end; + return $end if is_code_point_usable($end, $try_hard); + + # End point didn't, work. Start at the beginning and try + # every one until find one that does work. + for my $trial ($set->start .. $end - 1) { + return $trial if is_code_point_usable($trial, $try_hard); + } + } + } + return (); # If none found, give up. + } + + sub get_invalid_code_point { + # Return a code point that's not part of the table. Returns nothing + # if the table covers all code points or a suitable code point can't + # be found. This used only for making the test script. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # Just find a valid code point of the inverse, if any. + return Range_List->new(Initialize => ~ $self)->get_valid_code_point; + } +} # end closure for Range_List + +package Range_Map; +use base '_Range_List_Base'; + +# A Range_Map is a range list in which the range values (called maps) are +# significant, and hence shouldn't be manipulated by our other code, which +# could be ambiguous or lose things. For example, in taking the union of two +# lists, which share code points, but which have differing values, which one +# has precedence in the union? +# It turns out that these operations aren't really necessary for map tables, +# and so this class was created to make sure they aren't accidentally +# applied to them. + +{ # Closure + + sub add_map { + # Add a range containing a mapping value to the list + + my $self = shift; + # Rest of parameters passed on + + return $self->_add_delete('+', @_); + } + + sub add_duplicate { + # Adds entry to a range list which can duplicate an existing entry + + my $self = shift; + my $code_point = shift; + my $value = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + return $self->add_map($code_point, $code_point, + $value, Replace => $MULTIPLE); + } +} # End of closure for package Range_Map + +package _Base_Table; + +# A table is the basic data structure that gets written out into a file for +# use by the Perl core. This is the abstract base class implementing the +# common elements from the derived ones. A list of the methods to be +# furnished by an implementing class is just after the constructor. + +sub standardize { return main::standardize($_[0]); } +sub trace { return main::trace(@_); } + +{ # Closure + + main::setup_package(); + + my %range_list; + # Object containing the ranges of the table. + main::set_access('range_list', \%range_list, 'p_r', 'p_s'); + + my %full_name; + # The full table name. + main::set_access('full_name', \%full_name, 'r'); + + my %name; + # The table name, almost always shorter + main::set_access('name', \%name, 'r'); + + my %short_name; + # The shortest of all the aliases for this table, with underscores removed + main::set_access('short_name', \%short_name); + + my %nominal_short_name_length; + # The length of short_name before removing underscores + main::set_access('nominal_short_name_length', + \%nominal_short_name_length); + + my %property; + # Parent property this table is attached to. + main::set_access('property', \%property, 'r'); + + my %aliases; + # Ordered list of aliases of the table's name. The first ones in the list + # are output first in comments + main::set_access('aliases', \%aliases, 'readable_array'); + + my %comment; + # A comment associated with the table for human readers of the files + main::set_access('comment', \%comment, 's'); + + my %description; + # A comment giving a short description of the table's meaning for human + # readers of the files. + main::set_access('description', \%description, 'readable_array'); + + my %note; + # A comment giving a short note about the table for human readers of the + # files. + main::set_access('note', \%note, 'readable_array'); + + my %internal_only; + # Boolean; if set means any file that contains this table is marked as for + # internal-only use. + main::set_access('internal_only', \%internal_only); + + my %find_table_from_alias; + # The parent property passes this pointer to a hash which this class adds + # all its aliases to, so that the parent can quickly take an alias and + # find this table. + main::set_access('find_table_from_alias', \%find_table_from_alias, 'p_r'); + + my %locked; + # After this table is made equivalent to another one; we shouldn't go + # changing the contents because that could mean it's no longer equivalent + main::set_access('locked', \%locked, 'r'); + + my %file_path; + # This gives the final path to the file containing the table. Each + # directory in the path is an element in the array + main::set_access('file_path', \%file_path, 'readable_array'); + + my %status; + # What is the table's status, normal, $OBSOLETE, etc. Enum + main::set_access('status', \%status, 'r'); + + my %status_info; + # A comment about its being obsolete, or whatever non normal status it has + main::set_access('status_info', \%status_info, 'r'); + + my %range_size_1; + # Is the table to be output with each range only a single code point? + # This is done to avoid breaking existing code that may have come to rely + # on this behavior in previous versions of this program.) + main::set_access('range_size_1', \%range_size_1, 'r', 's'); + + my %perl_extension; + # A boolean set iff this table is a Perl extension to the Unicode + # standard. + main::set_access('perl_extension', \%perl_extension, 'r'); + + sub new { + # All arguments are key => value pairs, which you can see below, most + # of which match fields documented above. Otherwise: Pod_Entry, + # Externally_Ok, and Fuzzy apply to the names of the table, and are + # documented in the Alias package + + return Carp::carp_too_few_args(\@_, 2) if main::DEBUG && @_ < 2; + + my $class = shift; + + my $self = bless \do { my $anonymous_scalar }, $class; + my $addr = main::objaddr($self); + + my %args = @_; + + $name{$addr} = delete $args{'Name'}; + $find_table_from_alias{$addr} = delete $args{'_Alias_Hash'}; + $full_name{$addr} = delete $args{'Full_Name'}; + $internal_only{$addr} = delete $args{'Internal_Only_Warning'} || 0; + $perl_extension{$addr} = delete $args{'Perl_Extension'} || 0; + $property{$addr} = delete $args{'_Property'}; + $range_list{$addr} = delete $args{'_Range_List'}; + $status{$addr} = delete $args{'Status'} || $NORMAL; + $status_info{$addr} = delete $args{'_Status_Info'} || ""; + $range_size_1{$addr} = delete $args{'Range_Size_1'} || 0; + + my $description = delete $args{'Description'}; + my $externally_ok = delete $args{'Externally_Ok'}; + my $loose_match = delete $args{'Fuzzy'}; + my $note = delete $args{'Note'}; + my $make_pod_entry = delete $args{'Pod_Entry'}; + + # Shouldn't have any left over + Carp::carp_extra_args(\%args) if main::DEBUG && %args; + + # Can't use || above because conceivably the name could be 0, and + # can't use // operator in case this program gets used in Perl 5.8 + $full_name{$addr} = $name{$addr} if ! defined $full_name{$addr}; + + $aliases{$addr} = [ ]; + $comment{$addr} = [ ]; + $description{$addr} = [ ]; + $note{$addr} = [ ]; + $file_path{$addr} = [ ]; + $locked{$addr} = ""; + + push @{$description{$addr}}, $description if $description; + push @{$note{$addr}}, $note if $note; + + # If hasn't set its status already, see if it is on one of the lists + # of properties or tables that have particular statuses; if not, is + # normal. The lists are prioritized so the most serious ones are + # checked first + my $complete_name = $self->complete_name; + if (! $status{$addr}) { + if (exists $why_suppressed{$complete_name}) { + $status{$addr} = $SUPPRESSED; + } + elsif (exists $why_deprecated{$complete_name}) { + $status{$addr} = $DEPRECATED; + } + elsif (exists $why_stabilized{$complete_name}) { + $status{$addr} = $STABILIZED; + } + elsif (exists $why_obsolete{$complete_name}) { + $status{$addr} = $OBSOLETE; + } + + # Existence above doesn't necessarily mean there is a message + # associated with it. Use the most serious message. + if ($status{$addr}) { + if ($why_suppressed{$complete_name}) { + $status_info{$addr} + = $why_suppressed{$complete_name}; + } + elsif ($why_deprecated{$complete_name}) { + $status_info{$addr} + = $why_deprecated{$complete_name}; + } + elsif ($why_stabilized{$complete_name}) { + $status_info{$addr} + = $why_stabilized{$complete_name}; + } + elsif ($why_obsolete{$complete_name}) { + $status_info{$addr} + = $why_obsolete{$complete_name}; + } + } + } + + # By convention what typically gets printed only or first is what's + # first in the list, so put the full name there for good output + # clarity. Other routines rely on the full name being first on the + # list + $self->add_alias($full_name{$addr}, + Externally_Ok => $externally_ok, + Fuzzy => $loose_match, + Pod_Entry => $make_pod_entry, + Status => $status{$addr}, + ); + + # Then comes the other name, if meaningfully different. + if (standardize($full_name{$addr}) ne standardize($name{$addr})) { + $self->add_alias($name{$addr}, + Externally_Ok => $externally_ok, + Fuzzy => $loose_match, + Pod_Entry => $make_pod_entry, + Status => $status{$addr}, + ); + } + + return $self; + } + + # Here are the methods that are required to be defined by any derived + # class + for my $sub qw( + append_to_body + complete_name + pre_body + ) + # append_to_body and pre_body are called in the write() method + # to add stuff after the main body of the table, but before + # its close; and to prepend stuff before the beginning of the + # table. + # complete_name returns the complete name of the property and + # table, like Script=Latin + { + no strict "refs"; + *$sub = sub { + Carp::my_carp_bug( __LINE__ + . ": Must create method '$sub()' for " + . ref shift); + return; + } + } + + use overload + fallback => 0, + "." => \&main::_operator_dot, + '!=' => \&main::_operator_not_equal, + '==' => \&main::_operator_equal, + ; + + sub ranges { + # Returns the array of ranges associated with this table. + + return $range_list{main::objaddr shift}->ranges; + } + + sub add_alias { + # Add a synonym for this table. + + return Carp::carp_too_few_args(\@_, 3) if main::DEBUG && @_ < 3; + + my $self = shift; + my $name = shift; # The name to add. + my $pointer = shift; # What the alias hash should point to. For + # map tables, this is the parent property; + # for match tables, it is the table itself. + + my %args = @_; + my $loose_match = delete $args{'Fuzzy'}; + + my $make_pod_entry = delete $args{'Pod_Entry'}; + $make_pod_entry = $YES unless defined $make_pod_entry; + + my $externally_ok = delete $args{'Externally_Ok'}; + $externally_ok = 1 unless defined $externally_ok; + + my $status = delete $args{'Status'}; + $status = $NORMAL unless defined $status; + + Carp::carp_extra_args(\%args) if main::DEBUG && %args; + + # Capitalize the first letter of the alias unless it is one of the CJK + # ones which specifically begins with a lower 'k'. Do this because + # Unicode has varied whether they capitalize first letters or not, and + # have later changed their minds and capitalized them, but not the + # other way around. So do it always and avoid changes from release to + # release + $name = ucfirst($name) unless $name =~ /^k[A-Z]/; + + my $addr = main::objaddr $self; + + # Figure out if should be loosely matched if not already specified. + if (! defined $loose_match) { + + # Is a loose_match if isn't null, and doesn't begin with an + # underscore and isn't just a number + if ($name ne "" + && substr($name, 0, 1) ne '_' + && $name !~ qr{^[0-9_.+-/]+$}) + { + $loose_match = 1; + } + else { + $loose_match = 0; + } + } + + # If this alias has already been defined, do nothing. + return if defined $find_table_from_alias{$addr}->{$name}; + + # That includes if it is standardly equivalent to an existing alias, + # in which case, add this name to the list, so won't have to search + # for it again. + my $standard_name = main::standardize($name); + if (defined $find_table_from_alias{$addr}->{$standard_name}) { + $find_table_from_alias{$addr}->{$name} + = $find_table_from_alias{$addr}->{$standard_name}; + return; + } + + # Set the index hash for this alias for future quick reference. + $find_table_from_alias{$addr}->{$name} = $pointer; + $find_table_from_alias{$addr}->{$standard_name} = $pointer; + local $to_trace = 0 if main::DEBUG; + trace "adding alias $name to $pointer" if main::DEBUG && $to_trace; + trace "adding alias $standard_name to $pointer" if main::DEBUG && $to_trace; + + + # Put the new alias at the end of the list of aliases unless the final + # element begins with an underscore (meaning it is for internal perl + # use) or is all numeric, in which case, put the new one before that + # one. This floats any all-numeric or underscore-beginning aliases to + # the end. This is done so that they are listed last in output lists, + # to encourage the user to use a better name (either more descriptive + # or not an internal-only one) instead. This ordering is relied on + # implicitly elsewhere in this program, like in short_name() + my $list = $aliases{$addr}; + my $insert_position = (@$list == 0 + || (substr($list->[-1]->name, 0, 1) ne '_' + && $list->[-1]->name =~ /\D/)) + ? @$list + : @$list - 1; + splice @$list, + $insert_position, + 0, + Alias->new($name, $loose_match, $make_pod_entry, + $externally_ok, $status); + + # This name may be shorter than any existing ones, so clear the cache + # of the shortest, so will have to be recalculated. + undef $short_name{main::objaddr $self}; + return; + } + + sub short_name { + # Returns a name suitable for use as the base part of a file name. + # That is, shorter wins. It can return undef if there is no suitable + # name. The name has all non-essential underscores removed. + + # The optional second parameter is a reference to a scalar in which + # this routine will store the length the returned name had before the + # underscores were removed, or undef if the return is undef. + + # The shortest name can change if new aliases are added. So using + # this should be deferred until after all these are added. The code + # that does that should clear this one's cache. + # Any name with alphabetics is preferred over an all numeric one, even + # if longer. + + my $self = shift; + my $nominal_length_ptr = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + # For efficiency, don't recalculate, but this means that adding new + # aliases could change what the shortest is, so the code that does + # that needs to undef this. + if (defined $short_name{$addr}) { + if ($nominal_length_ptr) { + $$nominal_length_ptr = $nominal_short_name_length{$addr}; + } + return $short_name{$addr}; + } + + # Look at each alias + foreach my $alias ($self->aliases()) { + + # Don't use an alias that isn't ok to use for an external name. + next if ! $alias->externally_ok; + + my $name = main::Standardize($alias->name); + trace $self, $name if main::DEBUG && $to_trace; + + # Take the first one, or a shorter one that isn't numeric. This + # relies on numeric aliases always being last in the array + # returned by aliases(). Any alpha one will have precedence. + if (! defined $short_name{$addr} + || ($name =~ /\D/ + && length($name) < length($short_name{$addr}))) + { + # Remove interior underscores. + ($short_name{$addr} = $name) =~ s/ (?<= . ) _ (?= . ) //xg; + + $nominal_short_name_length{$addr} = length $name; + } + } + + # If no suitable external name return undef + if (! defined $short_name{$addr}) { + $$nominal_length_ptr = undef if $nominal_length_ptr; + return; + } + + # Don't allow a null external name. + if ($short_name{$addr} eq "") { + $short_name{$addr} = '_'; + $nominal_short_name_length{$addr} = 1; + } + + trace $self, $short_name{$addr} if main::DEBUG && $to_trace; + + if ($nominal_length_ptr) { + $$nominal_length_ptr = $nominal_short_name_length{$addr}; + } + return $short_name{$addr}; + } + + sub external_name { + # Returns the external name that this table should be known by. This + # is usually the short_name, but not if the short_name is undefined. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $short = $self->short_name; + return $short if defined $short; + + return '_'; + } + + sub add_description { # Adds the parameter as a short description. + + my $self = shift; + my $description = shift; + chomp $description; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + push @{$description{main::objaddr $self}}, $description; + + return; + } + + sub add_note { # Adds the parameter as a short note. + + my $self = shift; + my $note = shift; + chomp $note; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + push @{$note{main::objaddr $self}}, $note; + + return; + } + + sub add_comment { # Adds the parameter as a comment. + + my $self = shift; + my $comment = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + chomp $comment; + push @{$comment{main::objaddr $self}}, $comment; + + return; + } + + sub comment { + # Return the current comment for this table. If called in list + # context, returns the array of comments. In scalar, returns a string + # of each element joined together with a period ending each. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my @list = @{$comment{main::objaddr $self}}; + return @list if wantarray; + my $return = ""; + foreach my $sentence (@list) { + $return .= '. ' if $return; + $return .= $sentence; + $return =~ s/\.$//; + } + $return .= '.' if $return; + return $return; + } + + sub initialize { + # Initialize the table with the argument which is any valid + # initialization for range lists. + + my $self = shift; + my $initialization = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # Replace the current range list with a new one of the same exact + # type. + my $class = ref $range_list{main::objaddr $self}; + $range_list{main::objaddr $self} = $class->new(Owner => $self, + Initialize => $initialization); + return; + + } + + sub header { + # The header that is output for the table in the file it is written + # in. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $return = ""; + $return .= $DEVELOPMENT_ONLY if $compare_versions; + $return .= $HEADER; + $return .= $INTERNAL_ONLY if $internal_only{main::objaddr $self}; + return $return; + } + + sub write { + # Write a representation of the table to its file. + + my $self = shift; + my $tab_stops = shift; # The number of tab stops over to put any + # comment. + my $suppress_value = shift; # Optional, if the value associated with + # a range equals this one, don't write + # the range + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr($self); + + # Start with the header + my @OUT = $self->header; + + # Then the comments + push @OUT, "\n", main::simple_fold($comment{$addr}, '# '), "\n" + if $comment{$addr}; + + # Then any pre-body stuff. + my $pre_body = $self->pre_body; + push @OUT, $pre_body, "\n" if $pre_body; + + # The main body looks like a 'here' document + push @OUT, "return <<'END';\n"; + + if ($range_list{$addr}->is_empty) { + + # This is a kludge for empty tables to silence a warning in + # utf8.c, which can't really deal with empty tables, but it can + # deal with a table that matches nothing, as the inverse of 'Any' + # does. + push @OUT, "!utf8::IsAny\n"; + } + else { + my $range_size_1 = $range_size_1{$addr}; + + # Output each range as part of the here document. + for my $set ($range_list{$addr}->ranges) { + my $start = $set->start; + my $end = $set->end; + my $value = $set->value; + + # Don't output ranges whose value is the one to suppress + next if defined $suppress_value && $value eq $suppress_value; + + # If has or wants a single point range output + if ($start == $end || $range_size_1) { + for my $i ($start .. $end) { + push @OUT, sprintf "%04X\t\t%s\n", $i, $value; + } + } + else { + push @OUT, sprintf "%04X\t%04X\t%s", $start, $end, $value; + + # Add a comment with the size of the range, if requested. + # Expand Tabs to make sure they all start in the same + # column, and then unexpand to use mostly tabs. + if (! $output_range_counts) { + $OUT[-1] .= "\n"; + } + else { + $OUT[-1] = Text::Tabs::expand($OUT[-1]); + my $count = main::clarify_number($end - $start + 1); + use integer; + + my $width = $tab_stops * 8 - 1; + $OUT[-1] = sprintf("%-*s # [%s]\n", + $width, + $OUT[-1], + $count); + $OUT[-1] = Text::Tabs::unexpand($OUT[-1]); + } + } + } # End of loop through all the table's ranges + } + + # Add anything that goes after the main body, but within the here + # document, + my $append_to_body = $self->append_to_body; + push @OUT, $append_to_body if $append_to_body; + + # And finish the here document. + push @OUT, "END\n"; + + # All these files have a .pl suffix + $file_path{$addr}->[-1] .= '.pl'; + + main::write($file_path{$addr}, \@OUT); + return; + } + + sub set_status { # Set the table's status + my $self = shift; + my $status = shift; # The status enum value + my $info = shift; # Any message associated with it. + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr($self); + + $status{$addr} = $status; + $status_info{$addr} = $info; + return; + } + + sub lock { + # Don't allow changes to the table from now on. This stores a stack + # trace of where it was called, so that later attempts to modify it + # can immediately show where it got locked. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + $locked{$addr} = ""; + + my $line = (caller(0))[2]; + my $i = 1; + + # Accumulate the stack trace + while (1) { + my ($pkg, $file, $caller_line, $caller) = caller $i++; + + last unless defined $caller; + + $locked{$addr} .= " called from $caller() at line $line\n"; + $line = $caller_line; + } + $locked{$addr} .= " called from main at line $line\n"; + + return; + } + + sub carp_if_locked { + # Return whether a table is locked or not, and, by the way, complain + # if is locked + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + return 0 if ! $locked{$addr}; + Carp::my_carp_bug("Can't modify a locked table. Stack trace of locking:\n$locked{$addr}\n\n"); + return 1; + } + + sub set_file_path { # Set the final directory path for this table + my $self = shift; + # Rest of parameters passed on + + @{$file_path{main::objaddr $self}} = @_; + return + } + + # Accessors for the range list stored in this table. First for + # unconditional + for my $sub qw( + contains + count + each_range + hash + is_empty + max + min + range_count + reset_each_range + value_of + ) + { + no strict "refs"; + *$sub = sub { + use strict "refs"; + my $self = shift; + return $range_list{main::objaddr $self}->$sub(@_); + } + } + + # Then for ones that should fail if locked + for my $sub qw( + delete_range + ) + { + no strict "refs"; + *$sub = sub { + use strict "refs"; + my $self = shift; + + return if $self->carp_if_locked; + return $range_list{main::objaddr $self}->$sub(@_); + } + } + +} # End closure + +package Map_Table; +use base '_Base_Table'; + +# A Map Table is a table that contains the mappings from code points to +# values. There are two weird cases: +# 1) Anomalous entries are ones that aren't maps of ranges of code points, but +# are written in the table's file at the end of the table nonetheless. It +# requires specially constructed code to handle these; utf8.c can not read +# these in, so they should not go in $map_directory. As of this writing, +# the only case that these happen is for named sequences used in +# charnames.pm. But this code doesn't enforce any syntax on these, so +# something else could come along that uses it. +# 2) Specials are anything that doesn't fit syntactically into the body of the +# table. The ranges for these have a map type of non-zero. The code below +# knows about and handles each possible type. In most cases, these are +# written as part of the header. +# +# A map table deliberately can't be manipulated at will unlike match tables. +# This is because of the ambiguities having to do with what to do with +# overlapping code points. And there just isn't a need for those things; +# what one wants to do is just query, add, replace, or delete mappings, plus +# write the final result. +# However, there is a method to get the list of possible ranges that aren't in +# this table to use for defaulting missing code point mappings. And, +# map_add_or_replace_non_nulls() does allow one to add another table to this +# one, but it is clearly very specialized, and defined that the other's +# non-null values replace this one's if there is any overlap. + +sub trace { return main::trace(@_); } + +{ # Closure + + main::setup_package(); + + my %default_map; + # Many input files omit some entries; this gives what the mapping for the + # missing entries should be + main::set_access('default_map', \%default_map, 'r'); + + my %anomalous_entries; + # Things that go in the body of the table which don't fit the normal + # scheme of things, like having a range. Not much can be done with these + # once there except to output them. This was created to handle named + # sequences. + main::set_access('anomalous_entry', \%anomalous_entries, 'a'); + main::set_access('anomalous_entries', # Append singular, read plural + \%anomalous_entries, + 'readable_array'); + + my %format; + # The format of the entries of the table. This is calculated from the + # data in the table (or passed in the constructor). This is an enum e.g., + # $STRING_FORMAT + main::set_access('format', \%format); + + my %core_access; + # This is a string, solely for documentation, indicating how one can get + # access to this property via the Perl core. + main::set_access('core_access', \%core_access, 'r', 's'); + + my %has_specials; + # Boolean set when non-zero map-type ranges are added to this table, + # which happens in only a few tables. This is purely for performance, to + # avoid having to search through every table upon output, so if all the + # non-zero maps got deleted before output, this would remain set, and the + # only penalty would be performance. Currently, most map tables that get + # output have specials in them, so this doesn't help that much anyway. + main::set_access('has_specials', \%has_specials); + + my %to_output_map; + # Boolean as to whether or not to write out this map table + main::set_access('to_output_map', \%to_output_map, 's'); + + + sub new { + my $class = shift; + my $name = shift; + + my %args = @_; + + # Optional initialization data for the table. + my $initialize = delete $args{'Initialize'}; + + my $core_access = delete $args{'Core_Access'}; + my $default_map = delete $args{'Default_Map'}; + my $format = delete $args{'Format'}; + my $property = delete $args{'_Property'}; + # Rest of parameters passed on + + my $range_list = Range_Map->new(Owner => $property); + + my $self = $class->SUPER::new( + Name => $name, + _Property => $property, + _Range_List => $range_list, + %args); + + my $addr = main::objaddr $self; + + $anomalous_entries{$addr} = []; + $core_access{$addr} = $core_access; + $default_map{$addr} = $default_map; + $format{$addr} = $format; + + $self->initialize($initialize) if defined $initialize; + + return $self; + } + + use overload + fallback => 0, + qw("") => "_operator_stringify", + ; + + sub _operator_stringify { + my $self = shift; + + my $name = $self->property->full_name; + $name = '""' if $name eq ""; + return "Map table for Property '$name'"; + } + + sub complete_name { + # The complete name for a map table is just its full name, as that + # completely identifies the property it represents + + return shift->full_name; + } + + sub add_alias { + # Add a synonym for this table (which means the property itself) + my $self = shift; + my $name = shift; + # Rest of parameters passed on. + + $self->SUPER::add_alias($name, $self->property, @_); + return; + } + + sub add_map { + # Add a range of code points to the list of specially-handled code + # points. $MULTI_CP is assumed if the type of special is not passed + # in. + + my $self = shift; + my $lower = shift; + my $upper = shift; + my $string = shift; + my %args = @_; + + my $type = delete $args{'Type'} || 0; + # Rest of parameters passed on + + # Can't change the table if locked. + return if $self->carp_if_locked; + + my $addr = main::objaddr $self; + + $has_specials{$addr} = 1 if $type; + + $self->_range_list->add_map($lower, $upper, + $string, + @_, + Type => $type); + return; + } + + sub append_to_body { + # Adds to the written HERE document of the table's body any anomalous + # entries in the table.. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + return "" unless @{$anomalous_entries{$addr}}; + return join("\n", @{$anomalous_entries{$addr}}) . "\n"; + } + + sub map_add_or_replace_non_nulls { + # This adds the mappings in the table $other to $self. Non-null + # mappings from $other override those in $self. It essentially merges + # the two tables, with the second having priority except for null + # mappings. + + my $self = shift; + my $other = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + return if $self->carp_if_locked; + + if (! $other->isa(__PACKAGE__)) { + Carp::my_carp_bug("$other should be a " + . __PACKAGE__ + . ". Not a '" + . ref($other) + . "'. Not added;"); + return; + } + + my $addr = main::objaddr $self; + my $other_addr = main::objaddr $other; + + local $to_trace = 0 if main::DEBUG; + + my $self_range_list = $self->_range_list; + my $other_range_list = $other->_range_list; + foreach my $range ($other_range_list->ranges) { + my $value = $range->value; + next if $value eq ""; + $self_range_list->_add_delete('+', + $range->start, + $range->end, + $value, + Type => $range->type, + Replace => $UNCONDITIONALLY); + } + + # Copy the specials information from the other table to $self + if ($has_specials{$other_addr}) { + $has_specials{$addr} = 1; + } + + return; + } + + sub set_default_map { + # Define what code points that are missing from the input files should + # map to + + my $self = shift; + my $map = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + # Convert the input to the standard equivalent, if any (won't have any + # for $STRING properties) + my $standard = $self->_find_table_from_alias->{$map}; + $map = $standard->name if defined $standard; + + # Warn if there already is a non-equivalent default map for this + # property. Note that a default map can be a ref, which means that + # what it actually means is delayed until later in the program, and it + # IS permissible to override it here without a message. + my $default_map = $default_map{$addr}; + if (defined $default_map + && ! ref($default_map) + && $default_map ne $map + && main::Standardize($map) ne $default_map) + { + my $property = $self->property; + my $map_table = $property->table($map); + my $default_table = $property->table($default_map); + if (defined $map_table + && defined $default_table + && $map_table != $default_table) + { + Carp::my_carp("Changing the default mapping for " + . $property + . " from $default_map to $map'"); + } + } + + $default_map{$addr} = $map; + + # Don't also create any missing table for this map at this point, + # because if we did, it could get done before the main table add is + # done for PropValueAliases.txt; instead the caller will have to make + # sure it exists, if desired. + return; + } + + sub to_output_map { + # Returns boolean: should we write this map table? + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + # If overridden, use that + return $to_output_map{$addr} if defined $to_output_map{$addr}; + + my $full_name = $self->full_name; + + # If table says to output, do so; if says to suppress it, do do. + return 1 if grep { $_ eq $full_name } @output_mapped_properties; + return 0 if $self->status eq $SUPPRESSED; + + my $type = $self->property->type; + + # Don't want to output binary map tables even for debugging. + return 0 if $type == $BINARY; + + # But do want to output string ones. + return 1 if $type == $STRING; + + # Otherwise is an $ENUM, don't output it + return 0; + } + + sub inverse_list { + # Returns a Range_List that is gaps of the current table. That is, + # the inversion + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $current = Range_List->new(Initialize => $self->_range_list, + Owner => $self->property); + return ~ $current; + } + + sub set_final_comment { + # Just before output, create the comment that heads the file + # containing this table. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # No sense generating a comment if aren't going to write it out. + return if ! $self->to_output_map; + + my $addr = main::objaddr $self; + + my $property = $self->property; + + # Get all the possible names for this property. Don't use any that + # aren't ok for use in a file name, etc. This is perhaps causing that + # flag to do double duty, and may have to be changed in the future to + # have our own flag for just this purpose; but it works now to exclude + # Perl generated synonyms from the lists for properties, where the + # name is always the proper Unicode one. + my @property_aliases = grep { $_->externally_ok } $self->aliases; + + my $count = $self->count; + my $default_map = $default_map{$addr}; + + # The ranges that map to the default aren't output, so subtract that + # to get those actually output. A property with matching tables + # already has the information calculated. + if ($property->type != $STRING) { + $count -= $property->table($default_map)->count; + } + elsif (defined $default_map) { + + # But for $STRING properties, must calculate now. Subtract the + # count from each range that maps to the default. + foreach my $range ($self->_range_list->ranges) { + local $to_trace = 1 if main::DEBUG; + trace $self, $range; + if ($range->value eq $default_map) { + $count -= $range->end +1 - $range->start; + } + } + + } + + # Get a string version of $count with underscores in large numbers, + # for clarity. + my $string_count = main::clarify_number($count); + + my $code_points = ($count == 1) + ? 'single code point' + : "$string_count code points"; + + my $mapping; + my $these_mappings; + my $are; + if (@property_aliases <= 1) { + $mapping = 'mapping'; + $these_mappings = 'this mapping'; + $are = 'is' + } + else { + $mapping = 'synonymous mappings'; + $these_mappings = 'these mappings'; + $are = 'are' + } + my $cp; + if ($count >= $MAX_UNICODE_CODEPOINTS) { + $cp = "any code point in Unicode Version $string_version"; + } + else { + my $map_to; + if ($default_map eq "") { + $map_to = 'the null string'; + } + elsif ($default_map eq $CODE_POINT) { + $map_to = "itself"; + } + else { + $map_to = "'$default_map'"; + } + if ($count == 1) { + $cp = "the single code point"; + } + else { + $cp = "one of the $code_points"; + } + $cp .= " in Unicode Version $string_version for which the mapping is not to $map_to"; + } + + my $comment = ""; + + my $status = $self->status; + if ($status) { + my $warn = uc $status_past_participles{$status}; + $comment .= <name . '(cp)' + ); + } + $comment .= + "\nwhere 'cp' is $cp. Note that $these_mappings $are "; + + my $access = $core_access{$addr}; + if ($access) { + $comment .= "accessible through the Perl core via $access."; + } + else { + $comment .= "not accessible through the Perl core directly."; + } + + # And append any commentary already set from the actual property. + $comment .= "\n\n" . $self->comment if $self->comment; + if ($self->description) { + $comment .= "\n\n" . join " ", $self->description; + } + if ($self->note) { + $comment .= "\n\n" . join " ", $self->note; + } + $comment .= "\n"; + + if (! $self->perl_extension) { + $comment .= <range_size_1) { + $comment.= <set_comment(main::join_lines($comment)); + return; + } + + my %swash_keys; # Makes sure don't duplicate swash names. + + sub pre_body { + # Returns the string that should be output in the file before the main + # body of this table. This includes some hash entries identifying the + # format of the body, and what the single value should be for all + # ranges missing from it. It also includes any code points which have + # map_types that don't go in the main table. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + my $name = $self->property->swash_name; + + if (defined $swash_keys{$name}) { + Carp::my_carp(join_lines(<_range_list; + foreach my $range ($range_map->ranges) { + next unless $range->type != 0; + my $low = $range->start; + my $high = $range->end; + my $map = $range->value; + my $type = $range->type; + + # No need to output the range if it maps to the default. And + # the write method won't output it either, so no need to + # delete it to keep it from being output, and is faster to + # skip than to delete anyway. + next if $map eq $default_map; + + # Delete the range to keep write() from trying to output it + $range_map->delete_range($low, $high); + + # Switch based on the map type... + if ($type == $HANGUL_SYLLABLE) { + + # These are entirely algorithmically determinable based on + # some constants furnished by Unicode; for now, just set a + # flag to indicate that have them. Below we will output + # the code that does the algorithm. + $has_hangul_syllables = 1; + } + elsif ($type == $CP_IN_NAME) { + + # If the name ends in the code point it represents, are + # also algorithmically determinable, but need information + # about the map to do so. Both the map and its inverse + # are stored in data structures output in the file. + push @{$names_ending_in_code_point{$map}->{'low'}}, $low; + push @{$names_ending_in_code_point{$map}->{'high'}}, $high; + + push @code_points_ending_in_code_point, { low => $low, + high => $high, + name => $map + }; + } + elsif ($range->type == $MULTI_CP || $range->type == $NULL) { + + # Multi-code point maps and null string maps have an entry + # for each code point in the range. They use the same + # output format. + for my $code_point ($low .. $high) { + + # The pack() below can't cope with surrogates. + if ($code_point >= 0xD800 && $code_point <= 0xDFFF) { + Carp::my_carp("Surrogage code point '$code_point' in mapping to '$map' in $self. No map created"); + next; + } + + # Generate the hash entries for these in the form that + # utf8.c understands. + my $tostr = ""; + foreach my $to (split " ", $map) { + if ($to !~ /^$code_point_re$/) { + Carp::my_carp("Illegal code point '$to' in mapping '$map' from $code_point in $self. No map created"); + next; + } + $tostr .= sprintf "\\x{%s}", $to; + } + + # I (khw) have never waded through this line to + # understand it well enough to comment it. + my $utf8 = sprintf(qq["%s" => "$tostr",], + join("", map { sprintf "\\x%02X", $_ } + unpack("U0C*", pack("U", $code_point)))); + + # Add a comment so that a human reader can more easily + # see what's going on. + push @multi_code_point_maps, + sprintf("%-45s # U+%04X => %s", $utf8, + $code_point, + $map); + } + } + else { + Carp::my_carp("Unrecognized map type '$range->type' in '$range' in $self. Using type 0 instead"); + $range_map->add_map($low, $high, $map, Replace => $UNCONDITIONALLY, Type => 0); + } + } # End of loop through all ranges + + # Here have gone through the whole file. If actually generated + # anything for each map type, add its respective header and + # trailer + if (@multi_code_point_maps) { + $pre_body .= <[$i] > $code_point; + next if $names_ending_in_code_point{$base}{'high'}->[$i] < $code_point; + + # Here, the code point is in the range. + return $code_point; + } + + # Here, looked like the name had a code point number in it, but + # did not match one of the valid ones. + return; + } + + sub code_point_to_name_special { + my $code_point = shift; + + # Returns the name of a code point if algorithmically determinable; + # undef if not +END + if ($has_hangul_syllables) { + $pre_body .= << 'END'; + + # If in the Hangul range, calculate the name based on Unicode's + # algorithm + if ($code_point >= $SBase && $code_point <= $SBase + $SCount -1) { + use integer; + my $SIndex = $code_point - $SBase; + my $L = $LBase + $SIndex / $NCount; + my $V = $VBase + ($SIndex % $NCount) / $TCount; + my $T = $TBase + $SIndex % $TCount; + $name = "$HANGUL_SYLLABLE $Jamo{$L}$Jamo{$V}"; + $name .= $Jamo{$T} if $T != $TBase; + return $name; + } +END + } + $pre_body .= << 'END'; + + # Look through list of these code points for one in range. + foreach my $hash (@code_points_ending_in_code_point) { + return if $code_point < $hash->{'low'}; + if ($code_point <= $hash->{'high'}) { + return sprintf("%s-%04X", $hash->{'name'}, $code_point); + } + } + return; # None found + } +} # End closure + +END + } # End of has hangul or code point in name maps. + } # End of has specials + + # Calculate the format of the table if not already done. + my $format = $format{$addr}; + my $property = $self->property; + my $type = $property->type; + if (! defined $format) { + if ($type == $BINARY) { + + # Don't bother checking the values, because we elsewhere + # verify that a binary table has only 2 values. + $format = $BINARY_FORMAT; + } + else { + my @ranges = $self->_range_list->ranges; + + # default an empty table based on its type and default map + if (! @ranges) { + + # But it turns out that the only one we can say is a + # non-string (besides binary, handled above) is when the + # table is a string and the default map is to a code point + if ($type == $STRING && $default_map eq $CODE_POINT) { + $format = $HEX_FORMAT; + } + else { + $format = $STRING_FORMAT; + } + } + else { + + # Start with the most restrictive format, and as we find + # something that doesn't fit with that, change to the next + # most restrictive, and so on. + $format = $DECIMAL_FORMAT; + foreach my $range (@ranges) { + my $map = $range->value; + if ($map ne $default_map) { + last if $format eq $STRING_FORMAT; # already at + # least + # restrictive + $format = $INTEGER_FORMAT + if $format eq $DECIMAL_FORMAT + && $map !~ / ^ [0-9] $ /x; + $format = $FLOAT_FORMAT + if $format eq $INTEGER_FORMAT + && $map !~ / ^ -? [0-9]+ $ /x; + $format = $RATIONAL_FORMAT + if $format eq $FLOAT_FORMAT + && $map !~ / ^ -? [0-9]+ \. [0-9]* $ /x; + $format = $HEX_FORMAT + if $format eq $RATIONAL_FORMAT + && $map !~ / ^ -? [0-9]+ ( \/ [0-9]+ )? $ /x; + $format = $STRING_FORMAT if $format eq $HEX_FORMAT + && $map =~ /[^0-9A-F]/; + } + } + } + } + } # end of calculating format + + my $return = <SUPER::write( + ($self->property == $block) + ? 7 # block file needs more tab stops + : 3, + $default_map{$addr}); # don't write defaulteds + } + + # Accessors for the underlying list that should fail if locked. + for my $sub qw( + add_duplicate + ) + { + no strict "refs"; + *$sub = sub { + use strict "refs"; + my $self = shift; + + return if $self->carp_if_locked; + return $self->_range_list->$sub(@_); + } + } +} # End closure for Map_Table + +package Match_Table; +use base '_Base_Table'; + +# A Match table is one which is a list of all the code points that have +# the same property and property value, for use in \p{property=value} +# constructs in regular expressions. It adds very little data to the base +# structure, but many methods, as these lists can be combined in many ways to +# form new ones. +# There are only a few concepts added: +# 1) Equivalents and Relatedness. +# Two tables can match the identical code points, but have different names. +# This always happens when there is a perl single form extension +# \p{IsProperty} for the Unicode compound form \P{Property=True}. The two +# tables are set to be related, with the Perl extension being a child, and +# the Unicode property being the parent. +# +# It may be that two tables match the identical code points and we don't +# know if they are related or not. This happens most frequently when the +# Block and Script properties have the exact range. But note that a +# revision to Unicode could add new code points to the script, which would +# now have to be in a different block (as the block was filled, or there +# would have been 'Unknown' script code points in it and they wouldn't have +# been identical). So we can't rely on any two properties from Unicode +# always matching the same code points from release to release, and thus +# these tables are considered coincidentally equivalent--not related. When +# two tables are unrelated but equivalent, one is arbitrarily chosen as the +# 'leader', and the others are 'equivalents'. This concept is useful +# to minimize the number of tables written out. Only one file is used for +# any identical set of code points, with entries in Heavy.pl mapping all +# the involved tables to it. +# +# Related tables will always be identical; we set them up to be so. Thus +# if the Unicode one is deprecated, the Perl one will be too. Not so for +# unrelated tables. Relatedness makes generating the documentation easier. +# +# 2) Conflicting. It may be that there will eventually be name clashes, with +# the same name meaning different things. For a while, there actually were +# conflicts, but they have so far been resolved by changing Perl's or +# Unicode's definitions to match the other, but when this code was written, +# it wasn't clear that that was what was going to happen. (Unicode changed +# because of protests during their beta period.) Name clashes are warned +# about during compilation, and the documentation. The generated tables +# are sane, free of name clashes, because the code suppresses the Perl +# version. But manual intervention to decide what the actual behavior +# should be may be required should this happen. The introductory comments +# have more to say about this. + +sub standardize { return main::standardize($_[0]); } +sub trace { return main::trace(@_); } + + +{ # Closure + + main::setup_package(); + + my %leader; + # The leader table of this one; initially $self. + main::set_access('leader', \%leader, 'r'); + + my %equivalents; + # An array of any tables that have this one as their leader + main::set_access('equivalents', \%equivalents, 'readable_array'); + + my %parent; + # The parent table to this one, initially $self. This allows us to + # distinguish between equivalent tables that are related, and those which + # may not be, but share the same output file because they match the exact + # same set of code points in the current Unicode release. + main::set_access('parent', \%parent, 'r'); + + my %children; + # An array of any tables that have this one as their parent + main::set_access('children', \%children, 'readable_array'); + + my %conflicting; + # Array of any tables that would have the same name as this one with + # a different meaning. This is used for the generated documentation. + main::set_access('conflicting', \%conflicting, 'readable_array'); + + my %matches_all; + # Set in the constructor for tables that are expected to match all code + # points. + main::set_access('matches_all', \%matches_all, 'r'); + + sub new { + my $class = shift; + + my %args = @_; + + # The property for which this table is a listing of property values. + my $property = delete $args{'_Property'}; + + # Optional + my $initialize = delete $args{'Initialize'}; + my $matches_all = delete $args{'Matches_All'} || 0; + # Rest of parameters passed on. + + my $range_list = Range_List->new(Initialize => $initialize, + Owner => $property); + + my $self = $class->SUPER::new(%args, + _Property => $property, + _Range_List => $range_list, + ); + my $addr = main::objaddr $self; + + $conflicting{$addr} = [ ]; + $equivalents{$addr} = [ ]; + $children{$addr} = [ ]; + $matches_all{$addr} = $matches_all; + $leader{$addr} = $self; + $parent{$addr} = $self; + + return $self; + } + + # See this program's beginning comment block about overloading these. + use overload + fallback => 0, + qw("") => "_operator_stringify", + '=' => sub { + my $self = shift; + + return if $self->carp_if_locked; + return $self; + }, + + '+' => sub { + my $self = shift; + my $other = shift; + + return $self->_range_list + $other; + }, + '&' => sub { + my $self = shift; + my $other = shift; + + return $self->_range_list & $other; + }, + '+=' => sub { + my $self = shift; + my $other = shift; + + return if $self->carp_if_locked; + + my $addr = main::objaddr $self; + + if (ref $other) { + + # Change the range list of this table to be the + # union of the two. + $self->_set_range_list($self->_range_list + + $other); + } + else { # $other is just a simple value + $self->add_range($other, $other); + } + return $self; + }, + '-' => sub { my $self = shift; + my $other = shift; + my $reversed = shift; + + if ($reversed) { + Carp::my_carp_bug("Can't cope with a " + . __PACKAGE__ + . " being the first parameter in a '-'. Subtraction ignored."); + return; + } + + return $self->_range_list - $other; + }, + '~' => sub { my $self = shift; + return ~ $self->_range_list; + }, + ; + + sub _operator_stringify { + my $self = shift; + + my $name= $self->complete_name; + return "Table '$name'"; + } + + sub add_alias { + # Add a synonym for this table. See the comments in the base class + + my $self = shift; + my $name = shift; + # Rest of parameters passed on. + + $self->SUPER::add_alias($name, $self, @_); + return; + } + + sub add_conflicting { + # Add the name of some other object to the list of ones that name + # clash with this match table. + + my $self = shift; + my $conflicting_name = shift; # The name of the conflicting object + my $p = shift || 'p'; # Optional, is this a \p{} or \P{} ? + my $conflicting_object = shift; # Optional, the conflicting object + # itself. This is used to + # disambiguate the text if the input + # name is identical to any of the + # aliases $self is known by. + # Sometimes the conflicting object is + # merely hypothetical, so this has to + # be an optional parameter. + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + # Check if the conflicting name is exactly the same as any existing + # alias in this table (as long as there is a real object there to + # disambiguate with). + if (defined $conflicting_object) { + foreach my $alias ($self->aliases) { + if ($alias->name eq $conflicting_name) { + + # Here, there is an exact match. This results in + # ambiguous comments, so disambiguate by changing the + # conflicting name to its object's complete equivalent. + $conflicting_name = $conflicting_object->complete_name; + last; + } + } + } + + # Convert to the \p{...} final name + $conflicting_name = "\\$p" . "{$conflicting_name}"; + + # Only add once + return if grep { $conflicting_name eq $_ } @{$conflicting{$addr}}; + + push @{$conflicting{$addr}}, $conflicting_name; + + return; + } + + sub is_equivalent_to { + # Return boolean of whether or not the other object is a table of this + # type and has been marked equivalent to this one. + + my $self = shift; + my $other = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + return 0 if ! defined $other; # Can happen for incomplete early + # releases + unless ($other->isa(__PACKAGE__)) { + my $ref_other = ref $other; + my $ref_self = ref $self; + Carp::my_carp_bug("Argument to 'is_equivalent_to' must be another $ref_self, not a '$ref_other'. $other not set equivalent to $self."); + return 0; + } + + # Two tables are equivalent if they have the same leader. + return $leader{main::objaddr $self} + == $leader{main::objaddr $other}; + return; + } + + sub matches_identically_to { + # Return a boolean as to whether or not two tables match identical + # sets of code points. + + my $self = shift; + my $other = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + unless ($other->isa(__PACKAGE__)) { + my $ref_other = ref $other; + my $ref_self = ref $self; + Carp::my_carp_bug("Argument to 'matches_identically_to' must be another $ref_self, not a '$ref_other'. $other not set equivalent to $self."); + return 0; + } + + # These are ordered in increasing real time to figure out (at least + # until a patch changes that and doesn't change this) + return 0 if $self->max != $other->max; + return 0 if $self->min != $other->min; + return 0 if $self->range_count != $other->range_count; + return 0 if $self->count != $other->count; + + # Here they could be identical because all the tests above passed. + # The loop below is somewhat simpler since we know they have the same + # number of elements. Compare range by range, until reach the end or + # find something that differs. + my @a_ranges = $self->_range_list->ranges; + my @b_ranges = $other->_range_list->ranges; + for my $i (0 .. @a_ranges - 1) { + my $a = $a_ranges[$i]; + my $b = $b_ranges[$i]; + trace "self $a; other $b" if main::DEBUG && $to_trace; + return 0 if $a->start != $b->start || $a->end != $b->end; + } + return 1; + } + + sub set_equivalent_to { + # Set $self equivalent to the parameter table. + # The required Related => 'x' parameter is a boolean indicating + # whether these tables are related or not. If related, $other becomes + # the 'parent' of $self; if unrelated it becomes the 'leader' + # + # Related tables share all characteristics except names; equivalents + # not quite so many. + # If they are related, one must be a perl extension. This is because + # we can't guarantee that Unicode won't change one or the other in a + # later release even if they are idential now. + + my $self = shift; + my $other = shift; + + my %args = @_; + my $related = delete $args{'Related'}; + + Carp::carp_extra_args(\%args) if main::DEBUG && %args; + + return if ! defined $other; # Keep on going; happens in some early + # Unicode releases. + + if (! defined $related) { + Carp::my_carp_bug("set_equivalent_to must have 'Related => [01] parameter. Assuming $self is not related to $other"); + $related = 0; + } + + # If already are equivalent, no need to re-do it; if subroutine + # returns null, it found an error, also do nothing + my $are_equivalent = $self->is_equivalent_to($other); + return if ! defined $are_equivalent || $are_equivalent; + + my $current_leader = ($related) + ? $parent{main::objaddr $self} + : $leader{main::objaddr $self}; + + if ($related && + ! $other->perl_extension + && ! $current_leader->perl_extension) + { + Carp::my_carp_bug("set_equivalent_to should have 'Related => 0 for equivalencing two Unicode properties. Assuming $self is not related to $other"); + $related = 0; + } + + my $leader = main::objaddr $current_leader; + my $other_addr = main::objaddr $other; + + # Any tables that are equivalent to or children of this table must now + # instead be equivalent to or (children) to the new leader (parent), + # still equivalent. The equivalency includes their matches_all info, + # and for related tables, their status + # All related tables are of necessity equivalent, but the converse + # isn't necessarily true + my $status = $other->status; + my $status_info = $other->status_info; + my $matches_all = $matches_all{other_addr}; + foreach my $table ($current_leader, @{$equivalents{$leader}}) { + next if $table == $other; + trace "setting $other to be the leader of $table, status=$status" if main::DEBUG && $to_trace; + + my $table_addr = main::objaddr $table; + $leader{$table_addr} = $other; + $matches_all{$table_addr} = $matches_all; + $self->_set_range_list($other->_range_list); + push @{$equivalents{$other_addr}}, $table; + if ($related) { + $parent{$table_addr} = $other; + push @{$children{$other_addr}}, $table; + $table->set_status($status, $status_info); + } + } + + # Now that we've declared these to be equivalent, any changes to one + # of the tables would invalidate that equivalency. + $self->lock; + $other->lock; + return; + } + + sub add_range { # Add a range to the list for this table. + my $self = shift; + # Rest of parameters passed on + + return if $self->carp_if_locked; + return $self->_range_list->add_range(@_); + } + + sub complete_name { + # The complete name for a match table includes it's property in a + # compound form 'property=table', except if the property is the + # pseudo-property, perl, in which case it is just the single form, + # 'table' + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $name = $self->full_name; + my $property = $self->property; + $name = '""' if $name eq ""; # A null name shouldn't happen, but this + # helps debug if it does + return $name if $property == $perl; + + # (If change the '=' must also change the ':' in set_final_comment(), + # and the references to colon in its text) + return $property->full_name . '=' . $name; + } + + sub pre_body { # Does nothing for match tables. + return + } + + sub append_to_body { # Does nothing for match tables. + return + } + + sub write { + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + return $self->SUPER::write(2); # 2 tab stops + } + + sub set_final_comment { + # This creates a comment for the file that is to hold the match table + # $self. It is somewhat convoluted to make the English read nicely, + # but, heh, it's just a comment. + # This should be called only with the leader match table of all the + # ones that share the same file. It lists all such tables, ordered so + # that related ones are together. + + my $leader = shift; # Should only be called on the leader table of + # an equivalent group + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $leader; + + if ($leader{$addr} != $leader) { + Carp::my_carp_bug(<count; + my $string_count = main::clarify_number($count); + + my $loose_count = 0; # how many aliases loosely matched + my $compound_name = ""; # ? Are any names compound?, and if so, an + # example + my $properties_with_compound_names = 0; # count of these + + + my %flags; # The status flags used in the file + my $total_entries = 0; # number of entries written in the comment + my $matches_comment = ""; # The portion of the comment about the + # \p{}'s + my @global_comments; # List of all the tables' comments that are + # there before this routine was called. + + # Get list of all the parent tables that are equivalent to this one + # (including itself). + my @parents = grep { $parent{main::objaddr $_} == $_ } + main::uniques($leader, @{$equivalents{$addr}}); + my $has_unrelated = (@parents >= 2); # boolean, ? are there unrelated + # tables + + for my $parent (@parents) { + + my $property = $parent->property; + + # Special case 'N' tables in properties with two match tables when + # the other is a 'Y' one. These are likely to be binary tables, + # but not necessarily. In either case, \P{} will match the + # complement of \p{}, and so if something is a synonym of \p, the + # complement of that something will be the synonym of \P. This + # would be true of any property with just two match tables, not + # just those whose values are Y and N; but that would require a + # little extra work, and there are none such so far in Unicode. + my $perl_p = 'p'; # which is it? \p{} or \P{} + my @yes_perl_synonyms; # list of any synonyms for the 'Y' table + + if (scalar $property->tables == 2 + && $parent == $property->table('N') + && defined (my $yes = $property->table('Y'))) + { + my $yes_addr = main::objaddr $yes; + @yes_perl_synonyms + = grep { $_->property == $perl } + main::uniques($yes, + $parent{$yes_addr}, + $parent{$yes_addr}->children); + + # But these synonyms are \P{} ,not \p{} + $perl_p = 'P'; + } + + my @description; # Will hold the table description + my @note; # Will hold the table notes. + my @conflicting; # Will hold the table conflicts. + + # Look at the parent, any yes synonyms, and all the children + for my $table ($parent, + @yes_perl_synonyms, + @{$children{main::objaddr $parent}}) + { + my $table_addr = main::objaddr $table; + my $table_property = $table->property; + + # Tables are separated by a blank line to create a grouping. + $matches_comment .= "\n" if $matches_comment; + + # The table is named based on the property and value + # combination it is for, like script=greek. But there may be + # a number of synonyms for each side, like 'sc' for 'script', + # and 'grek' for 'greek'. Any combination of these is a valid + # name for this table. In this case, there are three more, + # 'sc=grek', 'sc=greek', and 'script='grek'. Rather than + # listing all possible combinations in the comment, we make + # sure that each synonym occurs at least once, and add + # commentary that the other combinations are possible. + my @property_aliases = $table_property->aliases; + my @table_aliases = $table->aliases; + + Carp::my_carp_bug("$table doesn't have any names. Proceeding anyway.") unless @table_aliases; + + # The alias lists above are already ordered in the order we + # want to output them. To ensure that each synonym is listed, + # we must use the max of the two numbers. + my $listed_combos = main::max(scalar @table_aliases, + scalar @property_aliases); + trace "$listed_combos, tables=", scalar @table_aliases, "; names=", scalar @property_aliases if main::DEBUG; + + my $property_had_compound_name = 0; + + for my $i (0 .. $listed_combos - 1) { + $total_entries++; + + # The current alias for the property is the next one on + # the list, or if beyond the end, start over. Similarly + # for the table (\p{prop=table}) + my $property_alias = $property_aliases + [$i % @property_aliases]->name; + my $table_alias_object = $table_aliases + [$i % @table_aliases]; + my $table_alias = $table_alias_object->name; + my $loose_match = $table_alias_object->loose_match; + + if ($table_alias !~ /\D/) { # Clarify large numbers. + $table_alias = main::clarify_number($table_alias) + } + + # Add a comment for this alias combination + my $current_match_comment; + if ($table_property == $perl) { + $current_match_comment = "\\$perl_p" + . "{$table_alias}"; + } + else { + $current_match_comment + = "\\p{$property_alias=$table_alias}"; + $property_had_compound_name = 1; + } + + # Flag any abnormal status for this table. + my $flag = $property->status + || $table->status + || $table_alias_object->status; + $flags{$flag} = $status_past_participles{$flag} if $flag; + + $loose_count++; + + # Pretty up the comment. Note the \b; it says don't make + # this line a continuation. + $matches_comment .= sprintf("\b%-1s%-s%s\n", + $flag, + " " x 7, + $current_match_comment); + } # End of generating the entries for this table. + + # Save these for output after this group of related tables. + push @description, $table->description; + push @note, $table->note; + push @conflicting, $table->conflicting; + + # Compute an alternate compound name using the final property + # synonym and the first table synonym with a colon instead of + # the equal sign used elsewhere. + if ($property_had_compound_name) { + $properties_with_compound_names ++; + if (! $compound_name || @property_aliases > 1) { + $compound_name = $property_aliases[-1]->name + . ': ' + . $table_aliases[0]->name; + } + } + } # End of looping through all children of this table + + # Here have assembled in $matches_comment all the related tables + # to the current parent (preceded by the same info for all the + # previous parents). Put out information that applies to all of + # the current family. + if (@conflicting) { + + # But output the conflicting information now, as it applies to + # just this table. + my $conflicting = join ", ", @conflicting; + if ($conflicting) { + $matches_comment .= < 1; + $matches_comment .= "$conflicting\n"; + } + } + if (@description) { + $matches_comment .= "\n Meaning: " + . join('; ', @description) + . "\n"; + } + if (@note) { + $matches_comment .= "\n Note: " + . join("\n ", @note) + . "\n"; + } + } # End of looping through all tables + + + my $code_points; + my $match; + my $any_of_these; + if ($count == 1) { + $match = 'matches'; + $code_points = 'single code point'; + } + else { + $match = 'match'; + $code_points = "$string_count code points"; + } + + my $synonyms; + my $entries; + if ($total_entries <= 1) { + $synonyms = ""; + $entries = 'entry'; + $any_of_these = 'this' + } + else { + $synonyms = " any of the following regular expression constructs"; + $entries = 'entries'; + $any_of_these = 'any of these' + } + + my $comment = ""; + if ($has_unrelated) { + $comment .= < 1) { + $comment .= <set_comment(main::join_lines($comment)); + return; + } + + # Accessors for the underlying list + for my $sub qw( + get_valid_code_point + get_invalid_code_point + ) + { + no strict "refs"; + *$sub = sub { + use strict "refs"; + my $self = shift; + + return $self->_range_list->$sub(@_); + } + } +} # End closure for Match_Table + +package Property; + +# The Property class represents a Unicode property, or the $perl +# pseudo-property. It contains a map table initialized empty at construction +# time, and for properties accessible through regular expressions, various +# match tables, created through the add_match_table() method, and referenced +# by the table('NAME') or tables() methods, the latter returning a list of all +# of the match tables. Otherwise table operations implicitly are for the map +# table. +# +# Most of the data in the property is actually about its map table, so it +# mostly just uses that table's accessors for most methods. The two could +# have been combined into one object, but for clarity because of their +# differing semantics, they have been kept separate. It could be argued that +# the 'file' and 'directory' fields should be kept with the map table. +# +# Each property has a type. This can be set in the constructor, or in the +# set_type accessor, but mostly it is figured out by the data. Every property +# starts with unknown type, overridden by a parameter to the constructor, or +# as match tables are added, or ranges added to the map table, the data is +# inspected, and the type changed. After the table is mostly or entirely +# filled, compute_type() should be called to finalize they analysis. +# +# There are very few operations defined. One can safely remove a range from +# the map table, and property_add_or_replace_non_nulls() adds the maps from another +# table to this one, replacing any in the intersection of the two. + +sub standardize { return main::standardize($_[0]); } +sub trace { return main::trace(@_) if main::DEBUG && $to_trace } + +{ # Closure + + # This hash will contain as keys, all the aliases of all properties, and + # as values, pointers to their respective property objects. This allows + # quick look-up of a property from any of its names. + my %alias_to_property_of; + + sub dump_alias_to_property_of { + # For debugging + + print "\n", main::simple_dumper (\%alias_to_property_of), "\n"; + return; + } + + sub property_ref { + # This is a package subroutine, not called as a method. + # If the single parameter is a literal '*' it returns a list of all + # defined properties. + # Otherwise, the single parameter is a name, and it returns a pointer + # to the corresponding property object, or undef if none. + # + # Properties can have several different names. The 'standard' form of + # each of them is stored in %alias_to_property_of as they are defined. + # But it's possible that this subroutine will be called with some + # variant, so if the initial lookup fails, it is repeated with the + # standarized form of the input name. If found, besides returning the + # result, the input name is added to the list so future calls won't + # have to do the conversion again. + + my $name = shift; + + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + if (! defined $name) { + Carp::my_carp_bug("Undefined input property. No action taken."); + return; + } + + return main::uniques(values %alias_to_property_of) if $name eq '*'; + + # Return cached result if have it. + my $result = $alias_to_property_of{$name}; + return $result if defined $result; + + # Convert the input to standard form. + my $standard_name = standardize($name); + + $result = $alias_to_property_of{$standard_name}; + return unless defined $result; # Don't cache undefs + + # Cache the result before returning it. + $alias_to_property_of{$name} = $result; + return $result; + } + + + main::setup_package(); + + my %map; + # A pointer to the map table object for this property + main::set_access('map', \%map); + + my %full_name; + # The property's full name. This is a duplicate of the copy kept in the + # map table, but is needed because stringify needs it during + # construction of the map table, and then would have a chicken before egg + # problem. + main::set_access('full_name', \%full_name, 'r'); + + my %table_ref; + # This hash will contain as keys, all the aliases of any match tables + # attached to this property, and as values, the pointers to their + # respective tables. This allows quick look-up of a table from any of its + # names. + main::set_access('table_ref', \%table_ref); + + my %type; + # The type of the property, $ENUM, $BINARY, etc + main::set_access('type', \%type, 'r'); + + my %file; + # The filename where the map table will go (if actually written). + # Normally defaulted, but can be overridden. + main::set_access('file', \%file, 'r', 's'); + + my %directory; + # The directory where the map table will go (if actually written). + # Normally defaulted, but can be overridden. + main::set_access('directory', \%directory, 's'); + + my %pseudo_map_type; + # This is used to affect the calculation of the map types for all the + # ranges in the table. It should be set to one of the values that signify + # to alter the calculation. + main::set_access('pseudo_map_type', \%pseudo_map_type, 'r'); + + my %has_only_code_point_maps; + # A boolean used to help in computing the type of data in the map table. + main::set_access('has_only_code_point_maps', \%has_only_code_point_maps); + + my %unique_maps; + # A list of the first few distinct mappings this property has. This is + # used to disambiguate between binary and enum property types, so don't + # have to keep more than three. + main::set_access('unique_maps', \%unique_maps); + + sub new { + # The only required parameter is the positionally first, name. All + # other parameters are key => value pairs. See the documentation just + # above for the meanings of the ones not passed directly on to the map + # table constructor. + + my $class = shift; + my $name = shift || ""; + + my $self = property_ref($name); + if (defined $self) { + my $options_string = join ", ", @_; + $options_string = ". Ignoring options $options_string" if $options_string; + Carp::my_carp("$self is already in use. Using existing one$options_string;"); + return $self; + } + + my %args = @_; + + $self = bless \do { my $anonymous_scalar }, $class; + my $addr = main::objaddr $self; + + $directory{$addr} = delete $args{'Directory'}; + $file{$addr} = delete $args{'File'}; + $full_name{$addr} = delete $args{'Full_Name'} || $name; + $type{$addr} = delete $args{'Type'} || $UNKNOWN; + $pseudo_map_type{$addr} = delete $args{'Map_Type'}; + # Rest of parameters passed on. + + $has_only_code_point_maps{$addr} = 1; + $table_ref{$addr} = { }; + $unique_maps{$addr} = { }; + + $map{$addr} = Map_Table->new($name, + Full_Name => $full_name{$addr}, + _Alias_Hash => \%alias_to_property_of, + _Property => $self, + %args); + return $self; + } + + # See this program's beginning comment block about overloading the copy + # constructor. Few operations are defined on properties, but a couple are + # useful. It is safe to take the inverse of a property, and to remove a + # single code point from it. + use overload + fallback => 0, + qw("") => "_operator_stringify", + "." => \&main::_operator_dot, + '==' => \&main::_operator_equal, + '!=' => \&main::_operator_not_equal, + '=' => sub { return shift }, + '-=' => "_minus_and_equal", + ; + + sub _operator_stringify { + return "Property '" . shift->full_name . "'"; + } + + sub _minus_and_equal { + # Remove a single code point from the map table of a property. + + my $self = shift; + my $other = shift; + my $reversed = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + if (ref $other) { + Carp::my_carp_bug("Can't cope with a " + . ref($other) + . " argument to '-='. Subtraction ignored."); + return $self; + } + elsif ($reversed) { # Shouldnt happen in a -=, but just in case + Carp::my_carp_bug("Can't cope with a " + . __PACKAGE__ + . " being the first parameter in a '-='. Subtraction ignored."); + return $self; + } + else { + $map{main::objaddr $self}->delete_range($other, $other); + } + return $self; + } + + sub add_match_table { + # Add a new match table for this property, with name given by the + # parameter. It returns a pointer to the table. + + my $self = shift; + my $name = shift; + my %args = @_; + + my $addr = main::objaddr $self; + + my $table = $table_ref{$addr}{$name}; + my $standard_name = main::standardize($name); + if (defined $table + || (defined ($table = $table_ref{$addr}{$standard_name}))) + { + Carp::my_carp("Table '$name' in $self is already in use. Using existing one"); + $table_ref{$addr}{$name} = $table; + return $table; + } + else { + + # See if this is a perl extension, if not passed in. + my $perl_extension = delete $args{'Perl_Extension'}; + $perl_extension + = $self->perl_extension if ! defined $perl_extension; + + $table = Match_Table->new( + Name => $name, + Perl_Extension => $perl_extension, + _Alias_Hash => $table_ref{$addr}, + _Property => $self, + + # gets property's status by default + Status => $self->status, + _Status_Info => $self->status_info, + %args, + Internal_Only_Warning => 1); # Override any + # input param + return unless defined $table; + } + + # Save the names for quick look up + $table_ref{$addr}{$standard_name} = $table; + $table_ref{$addr}{$name} = $table; + + # Perhaps we can figure out the type of this property based on the + # fact of adding this match table. First, string properties don't + # have match tables; second, a binary property can't have 3 match + # tables + if ($type{$addr} == $UNKNOWN) { + $type{$addr} = $NON_STRING; + } + elsif ($type{$addr} == $STRING) { + Carp::my_carp("$self Added a match table '$name' to a string property '$self'. Changed it to a non-string property. Bad News."); + $type{$addr} = $NON_STRING; + } + elsif ($type{$addr} != $ENUM) { + if (scalar main::uniques(values %{$table_ref{$addr}}) > 2 + && $type{$addr} == $BINARY) + { + Carp::my_carp("$self now has more than 2 tables (with the addition of '$name'), and so is no longer binary. Changing its type to 'enum'. Bad News."); + $type{$addr} = $ENUM; + } + } + + return $table; + } + + sub table { + # Return a pointer to the match table (with name given by the + # parameter) associated with this property; undef if none. + + my $self = shift; + my $name = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + return $table_ref{$addr}{$name} if defined $table_ref{$addr}{$name}; + + # If quick look-up failed, try again using the standard form of the + # input name. If that succeeds, cache the result before returning so + # won't have to standardize this input name again. + my $standard_name = main::standardize($name); + return unless defined $table_ref{$addr}{$standard_name}; + + $table_ref{$addr}{$name} = $table_ref{$addr}{$standard_name}; + return $table_ref{$addr}{$name}; + } + + sub tables { + # Return a list of pointers to all the match tables attached to this + # property + + return main::uniques(values %{$table_ref{main::objaddr shift}}); + } + + sub directory { + # Returns the directory the map table for this property should be + # output in. If a specific directory has been specified, that has + # priority; 'undef' is returned if the type isn't defined; + # or $map_directory for everything else. + + my $addr = main::objaddr shift; + + return $directory{$addr} if defined $directory{$addr}; + return undef if $type{$addr} == $UNKNOWN; + return $map_directory; + } + + sub swash_name { + # Return the name that is used to both: + # 1) Name the file that the map table is written to. + # 2) The name of swash related stuff inside that file. + # The reason for this is that the Perl core historically has used + # certain names that aren't the same as the Unicode property names. + # To continue using these, $file is hard-coded in this file for those, + # but otherwise the standard name is used. This is different from the + # external_name, so that the rest of the files, like in lib can use + # the standard name always, without regard to historical precedent. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $self; + + return $file{$addr} if defined $file{$addr}; + return $map{$addr}->external_name; + } + + sub to_create_match_tables { + # Returns a boolean as to whether or not match tables should be + # created for this property. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # The whole point of this pseudo property is match tables. + return 1 if $self == $perl; + + my $addr = main::objaddr $self; + + # Don't generate tables of code points that match the property values + # of a string property. Such a list would most likely have many + # property values, each with just one or very few code points mapping + # to it. + return 0 if $type{$addr} == $STRING; + + # Don't generate anything for unimplemented properties. + return 0 if grep { $self->complete_name eq $_ } + @unimplemented_properties; + # Otherwise, do. + return 1; + } + + sub property_add_or_replace_non_nulls { + # This adds the mappings in the property $other to $self. Non-null + # mappings from $other override those in $self. It essentially merges + # the two properties, with the second having priority except for null + # mappings. + + my $self = shift; + my $other = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + if (! $other->isa(__PACKAGE__)) { + Carp::my_carp_bug("$other should be a " + . __PACKAGE__ + . ". Not a '" + . ref($other) + . "'. Not added;"); + return; + } + + return $map{main::objaddr $self}-> + map_add_or_replace_non_nulls($map{main::objaddr $other}); + } + + sub set_type { + # Set the type of the property. Mostly this is figured out by the + # data in the table. But this is used to set it explicitly. The + # reason it is not a standard accessor is that when setting a binary + # property, we need to make sure that all the true/false aliases are + # present, as they were omitted in early Unicode releases. + + my $self = shift; + my $type = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + if ($type != $ENUM && $type != $BINARY && $type != $STRING) { + Carp::my_carp("Unrecognized type '$type'. Type not set"); + return; + } + + $type{main::objaddr $self} = $type; + return if $type != $BINARY; + + my $yes = $self->table('Y'); + $yes = $self->table('Yes') if ! defined $yes; + $yes = $self->add_match_table('Y') if ! defined $yes; + $yes->add_alias('Yes'); + $yes->add_alias('T'); + $yes->add_alias('True'); + + my $no = $self->table('N'); + $no = $self->table('No') if ! defined $no; + $no = $self->add_match_table('N') if ! defined $no; + $no->add_alias('No'); + $no->add_alias('F'); + $no->add_alias('False'); + return; + } + + sub add_map { + # Add a map to the property's map table. This also keeps + # track of the maps so that the property type can be determined from + # its data. + + my $self = shift; + my $start = shift; # First code point in range + my $end = shift; # Final code point in range + my $map = shift; # What the range maps to. + # Rest of parameters passed on. + + my $addr = main::objaddr $self; + + # If haven't the type of the property, gather information to figure it + # out. + if ($type{$addr} == $UNKNOWN) { + + # If the map contains an interior blank or dash, or most other + # nonword characters, it will be a string property. This + # heuristic may actually miss some string properties. If so, they + # may need to have explicit set_types called for them. This + # happens in the Unihan properties. + if ($map =~ / (?<= . ) [ -] (?= . ) /x + || $map =~ / [^\w.\/\ -] /x) + { + $self->set_type($STRING); + + # $unique_maps is used for disambiguating between ENUM and + # BINARY later; since we know the property is not going to be + # one of those, no point in keeping the data around + undef $unique_maps{$addr}; + } + else { + + # Not necessarily a string. The final decision has to be + # deferred until all the data are in. We keep track of if all + # the values are code points for that eventual decision. + $has_only_code_point_maps{$addr} &= + $map =~ / ^ $code_point_re $/x; + + # For the purposes of disambiguating between binary and other + # enumerations at the end, we keep track of the first three + # distinct property values. Once we get to three, we know + # it's not going to be binary, so no need to track more. + if (scalar keys %{$unique_maps{$addr}} < 3) { + $unique_maps{$addr}{main::standardize($map)} = 1; + } + } + } + + # Add the mapping by calling our map table's method + return $map{$addr}->add_map($start, $end, $map, @_); + } + + sub compute_type { + # Compute the type of the property: $ENUM, $STRING, or $BINARY. This + # should be called after the property is mostly filled with its maps. + # We have been keeping track of what the property values have been, + # and now have the necessary information to figure out the type. + + my $self = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr($self); + + my $type = $type{$addr}; + + # If already have figured these out, no need to do so again, but we do + # a double check on ENUMS to make sure that a string property hasn't + # improperly been classified as an ENUM, so continue on with those. + return if $type == $STRING || $type == $BINARY; + + # If every map is to a code point, is a string property. + if ($type == $UNKNOWN + && ($has_only_code_point_maps{$addr} + || (defined $map{$addr}->default_map + && $map{$addr}->default_map eq ""))) + { + $self->set_type($STRING); + } + else { + + # Otherwise, it is to some sort of enumeration. (The case where + # it is a Unicode miscellaneous property, and treated like a + # string in this program is handled in add_map()). Distinguish + # between binary and some other enumeration type. Of course, if + # there are more than two values, it's not binary. But more + # subtle is the test that the default mapping is defined means it + # isn't binary. This in fact may change in the future if Unicode + # changes the way its data is structured. But so far, no binary + # properties ever have @missing lines for them, so the default map + # isn't defined for them. The few properties that are two-valued + # and aren't considered binary have the default map defined + # starting in Unicode 5.0, when the @missing lines appeared; and + # this program has special code to put in a default map for them + # for earlier than 5.0 releases. + if ($type == $ENUM + || scalar keys %{$unique_maps{$addr}} > 2 + || defined $self->default_map) + { + my $tables = $self->tables; + my $count = $self->count; + if ($verbosity && $count > 500 && $tables/$count > .1) { + Carp::my_carp_bug("It appears that $self should be a \$STRING property, not an \$ENUM because it has too many match tables: $count\n"); + } + $self->set_type($ENUM); + } + else { + $self->set_type($BINARY); + } + } + undef $unique_maps{$addr}; # Garbage collect + return; + } + + # Most of the accessors for a property actually apply to its map table. + # Setup up accessor functions for those, referring to %map + for my $sub qw( + add_alias + add_anomalous_entry + add_comment + add_conflicting + add_description + add_duplicate + add_note + aliases + comment + complete_name + core_access + count + default_map + delete_range + description + each_range + external_name + file_path + format + initialize + inverse_list + is_empty + name + note + perl_extension + property + range_count + ranges + range_size_1 + reset_each_range + set_comment + set_core_access + set_default_map + set_file_path + set_final_comment + set_range_size_1 + set_status + set_to_output_map + short_name + status + status_info + to_output_map + value_of + write + ) + # 'property' above is for symmetry, so that one can take + # the property of a property and get itself, and so don't + # have to distinguish between properties and tables in + # calling code + { + no strict "refs"; + *$sub = sub { + use strict "refs"; + my $self = shift; + return $map{main::objaddr $self}->$sub(@_); + } + } + + +} # End closure + +package main; + +sub join_lines($) { + # Returns lines of the input joined together, so that they can be folded + # properly. + # This causes continuation lines to be joined together into one long line + # for folding. A continuation line is any line that doesn't begin with a + # space or "\b" (the latter is stripped from the output). This is so + # lines can be be in a HERE document so as to fit nicely in the terminal + # width, but be joined together in one long line, and then folded with + # indents, '#' prefixes, etc, properly handled. + # A blank separates the joined lines except if there is a break; an extra + # blank is inserted after a period ending a line. + + # Intialize the return with the first line. + my ($return, @lines) = split "\n", shift; + + # If the first line is null, it was an empty line, add the \n back in + $return = "\n" if $return eq ""; + + # Now join the remainder of the physical lines. + for my $line (@lines) { + + # An empty line means wanted a blank line, so add two \n's to get that + # effect, and go to the next line. + if (length $line == 0) { + $return .= "\n\n"; + next; + } + + # Look at the last character of what we have so far. + my $previous_char = substr($return, -1, 1); + + # And at the next char to be output. + my $next_char = substr($line, 0, 1); + + if ($previous_char ne "\n") { + + # Here didn't end wth a nl. If the next char a blank or \b, it + # means that here there is a break anyway. So add a nl to the + # output. + if ($next_char eq " " || $next_char eq "\b") { + $previous_char = "\n"; + $return .= $previous_char; + } + + # Add an extra space after periods. + $return .= " " if $previous_char eq '.'; + } + + # Here $previous_char is still the latest character to be output. If + # it isn't a nl, it means that the next line is to be a continuation + # line, with a blank inserted between them. + $return .= " " if $previous_char ne "\n"; + + # Get rid of any \b + substr($line, 0, 1) = "" if $next_char eq "\b"; + + # And append this next line. + $return .= $line; + } + + return $return; +} + +sub simple_fold($;$$$) { + # Returns a string of the input (string or an array of strings) folded + # into multiple-lines each of no more than $MAX_LINE_WIDTH characters plus + # a \n + # This is tailored for the kind of text written by this program, + # especially the pod file, which can have very long names with + # underscores in the middle, or words like AbcDefgHij.... We allow + # breaking in the middle of such constructs if the line won't fit + # otherwise. The break in such cases will come either just after an + # underscore, or just before one of the Capital letters. + + local $to_trace = 0 if main::DEBUG; + + my $line = shift; + my $prefix = shift; # Optional string to prepend to each output + # line + $prefix = "" unless defined $prefix; + + my $hanging_indent = shift; # Optional number of spaces to indent + # continuation lines + $hanging_indent = 0 unless $hanging_indent; + + my $right_margin = shift; # Optional number of spaces to narrow the + # total width by. + $right_margin = 0 unless defined $right_margin; + + # Call carp with the 'nofold' option to avoid it from trying to call us + # recursively + Carp::carp_extra_args(\@_, 'nofold') if main::DEBUG && @_; + + # The space available doesn't include what's automatically prepended + # to each line, or what's reserved on the right. + my $max = $MAX_LINE_WIDTH - length($prefix) - $right_margin; + # XXX Instead of using the 'nofold' perhaps better to look up the stack + + if (DEBUG && $hanging_indent >= $max) { + Carp::my_carp("Too large a hanging indent ($hanging_indent); must be < $max. Using 0", 'nofold'); + $hanging_indent = 0; + } + + # First, split into the current physical lines. + my @line; + if (ref $line) { # Better be an array, because not bothering to + # test + foreach my $line (@{$line}) { + push @line, split /\n/, $line; + } + } + else { + @line = split /\n/, $line; + } + + #local $to_trace = 1 if main::DEBUG; + trace "", join(" ", @line), "\n" if main::DEBUG && $to_trace; + + # Look at each current physical line. + for (my $i = 0; $i < @line; $i++) { + Carp::my_carp("Tabs don't work well.", 'nofold') if $line[$i] =~ /\t/; + #local $to_trace = 1 if main::DEBUG; + trace "i=$i: $line[$i]\n" if main::DEBUG && $to_trace; + + # Remove prefix, because will be added back anyway, don't want + # doubled prefix + $line[$i] =~ s/^$prefix//; + + # Remove trailing space + $line[$i] =~ s/\s+\Z//; + + # If the line is too long, fold it. + if (length $line[$i] > $max) { + my $remainder; + + # Here needs to fold. Save the leading space in the line for + # later. + $line[$i] =~ /^ ( \s* )/x; + my $leading_space = $1; + trace "line length", length $line[$i], "; lead length", length($leading_space) if main::DEBUG && $to_trace; + + # If character at final permissible position is white space, + # fold there, which will delete that white space + if (substr($line[$i], $max - 1, 1) =~ /\s/) { + $remainder = substr($line[$i], $max); + $line[$i] = substr($line[$i], 0, $max - 1); + } + else { + + # Otherwise fold at an acceptable break char closest to + # the max length. Look at just the maximal initial + # segment of the line + my $segment = substr($line[$i], 0, $max - 1); + if ($segment =~ + /^ ( .{$hanging_indent} # Don't look before the + # indent. + \ * # Don't look in leading + # blanks past the indent + [^ ] .* # Find the right-most + (?: # acceptable break: + [ \s = ] # space or equal + | - (?! [.0-9] ) # or non-unary minus. + ) # $1 includes the character + )/x) + { + # Split into the initial part that fits, and remaining + # part of the input + $remainder = substr($line[$i], length $1); + $line[$i] = $1; + trace $line[$i] if DEBUG && $to_trace; + trace $remainder if DEBUG && $to_trace; + } + + # If didn't find a good breaking spot, see if there is a + # not-so-good breaking spot. These are just after + # underscores or where the case changes from lower to + # upper. Use \a as a soft hyphen, but give up + # and don't break the line if there is actually a \a + # already in the input. We use an ascii character for the + # soft-hyphen to avoid any attempt by miniperl to try to + # access the files that this program is creating. + elsif ($segment !~ /\a/ + && ($segment =~ s/_/_\a/g + || $segment =~ s/ ( [a-z] ) (?= [A-Z] )/$1\a/xg)) + { + # Here were able to find at least one place to insert + # our substitute soft hyphen. Find the right-most one + # and replace it by a real hyphen. + trace $segment if DEBUG && $to_trace; + substr($segment, + rindex($segment, "\a"), + 1) = '-'; + + # Then remove the soft hyphen substitutes. + $segment =~ s/\a//g; + trace $segment if DEBUG && $to_trace; + + # And split into the initial part that fits, and + # remainder of the line + my $pos = rindex($segment, '-'); + $remainder = substr($line[$i], $pos); + trace $remainder if DEBUG && $to_trace; + $line[$i] = substr($segment, 0, $pos + 1); + } + } + + # Here we know if we can fold or not. If we can, $remainder + # is what remains to be processed in the next iteration. + if (defined $remainder) { + trace "folded='$line[$i]'" if main::DEBUG && $to_trace; + + # Insert the folded remainder of the line as a new element + # of the array. (It may still be too long, but we will + # deal with that next time through the loop.) Omit any + # leading space in the remainder. + $remainder =~ s/^\s+//; + trace "remainder='$remainder'" if main::DEBUG && $to_trace; + + # But then indent by whichever is larger of: + # 1) the leading space on the input line; + # 2) the hanging indent. + # This preserves indentation in the original line. + my $lead = ($leading_space) + ? length $leading_space + : $hanging_indent; + $lead = max($lead, $hanging_indent); + splice @line, $i+1, 0, (" " x $lead) . $remainder; + } + } + + # Ready to output the line. Get rid of any trailing space + # And prefix by the required $prefix passed in. + $line[$i] =~ s/\s+$//; + $line[$i] = "$prefix$line[$i]\n"; + } # End of looping through all the lines. + + return join "", @line; +} + +sub property_ref { # Returns a reference to a property object. + return Property::property_ref(@_); +} + +sub force_unlink ($) { + my $filename = shift; + return unless file_exists($filename); + return if CORE::unlink($filename); + + # We might need write permission + chmod 0777, $filename; + CORE::unlink($filename) or Carp::my_carp("Couldn't unlink $filename. Proceeding anyway: $!"); + return; +} + +sub write ($\@) { + # Given a filename and a reference to an array of lines, write the lines + # to the file + # Filename can be given as an arrayref of directory names + + my $file = shift; + my $lines_ref = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + if (! defined $lines_ref) { + Carp::my_carp("Missing lines to write parameter for $file. Writing skipped;"); + return; + } + + # Get into a single string if an array, and get rid of, in Unix terms, any + # leading '.' + $file= File::Spec->join(@$file) if ref $file eq 'ARRAY'; + $file = File::Spec->canonpath($file); + + # If has directories, make sure that they all exist + (undef, my $directories, undef) = File::Spec->splitpath($file); + File::Path::mkpath($directories) if $directories && ! -d $directories; + + push @files_actually_output, $file; + + my $text; + if (@$lines_ref) { + $text = join "", @$lines_ref; + } + else { + $text = ""; + Carp::my_carp("Output file '$file' is empty; writing it anyway;"); + } + + force_unlink ($file); + + my $OUT; + if (not open $OUT, ">", $file) { + Carp::my_carp("can't open $file for output. Skipping this file: $!"); + return; + } + print "$file written.\n" if $verbosity >= $VERBOSE; + + print $OUT $text; + close $OUT; + return; +} + + +sub Standardize($) { + # This converts the input name string into a standardized equivalent to + # use internally. + + my $name = shift; + unless (defined $name) { + Carp::my_carp_bug("Standardize() called with undef. Returning undef."); + return; + } + + # Remove any leading or trailing white space + $name =~ s/^\s+//g; + $name =~ s/\s+$//g; + + # Convert interior white space and hypens into underscores. + $name =~ s/ (?<= .) [ -]+ (.) /_$1/xg; + + # Capitalize the letter following an underscore, and convert a sequence of + # multiple underscores to a single one + $name =~ s/ (?<= .) _+ (.) /_\u$1/xg; + + # And capitalize the first letter, but not for the special cjk ones. + $name = ucfirst($name) unless $name =~ /^k[A-Z]/; + return $name; +} + +sub standardize ($) { + # Returns a lower-cased standardized name, without underscores. This form + # is chosen so that it can distinguish between any real versus superficial + # Unicode name differences. It relies on the fact that Unicode doesn't + # have interior underscores, white space, nor dashes in any + # stricter-matched name. It should not be used on Unicode code point + # names (the Name property), as they mostly, but not always follow these + # rules. + + my $name = Standardize(shift); + return if !defined $name; + + $name =~ s/ (?<= .) _ (?= . ) //xg; + return lc $name; +} + +{ # Closure + + my $indent_increment = " " x 2; + my %already_output; + + $main::simple_dumper_nesting = 0; + + sub simple_dumper { + # Like Simple Data::Dumper. Good enough for our needs. We can't use + # the real thing as we have to run under miniperl. + + # It is designed so that on input it is at the beginning of a line, + # and the final thing output in any call is a trailing ",\n". + + my $item = shift; + my $indent = shift; + $indent = "" if ! defined $indent; + + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # nesting level is localized, so that as the call stack pops, it goes + # back to the prior value. + local $main::simple_dumper_nesting = $main::simple_dumper_nesting; + undef %already_output if $main::simple_dumper_nesting == 0; + $main::simple_dumper_nesting++; + #print STDERR __LINE__, ": $main::simple_dumper_nesting: $indent$item\n"; + + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # Determine the indent for recursive calls. + my $next_indent = $indent . $indent_increment; + + my $output; + if (! ref $item) { + + # Dump of scalar: just output it in quotes if not a number. To do + # so we must escape certain characters, and therefore need to + # operate on a copy to avoid changing the original + my $copy = $item; + $copy = $UNDEF unless defined $copy; + + # Quote non-numbers (numbers also have optional leading '-' and + # fractions) + if ($copy eq "" || $copy !~ /^ -? \d+ ( \. \d+ )? $/x) { + + # Escape apostrophe and backslash + $copy =~ s/ ( ['\\] ) /\\$1/xg; + $copy = "'$copy'"; + } + $output = "$indent$copy,\n"; + } + else { + + # Keep track of cycles in the input, and refuse to infinitely loop + if (defined $already_output{main::objaddr $item}) { + return "${indent}ALREADY OUTPUT: $item\n"; + } + $already_output{main::objaddr $item} = $item; + + if (ref $item eq 'ARRAY') { + my $using_brackets; + $output = $indent; + if ($main::simple_dumper_nesting > 1) { + $output .= '['; + $using_brackets = 1; + } + else { + $using_brackets = 0; + } + + # If the array is empty, put the closing bracket on the same + # line. Otherwise, recursively add each array element + if (@$item == 0) { + $output .= " "; + } + else { + $output .= "\n"; + for (my $i = 0; $i < @$item; $i++) { + + # Indent array elements one level + $output .= &simple_dumper($item->[$i], $next_indent); + $output =~ s/\n$//; # Remove trailing nl so as to + $output .= " # [$i]\n"; # add a comment giving the + # array index + } + $output .= $indent; # Indent closing ']' to orig level + } + $output .= ']' if $using_brackets; + $output .= ",\n"; + } + elsif (ref $item eq 'HASH') { + my $is_first_line; + my $using_braces; + my $body_indent; + + # No surrounding braces at top level + $output .= $indent; + if ($main::simple_dumper_nesting > 1) { + $output .= "{\n"; + $is_first_line = 0; + $body_indent = $next_indent; + $next_indent .= $indent_increment; + $using_braces = 1; + } + else { + $is_first_line = 1; + $body_indent = $indent; + $using_braces = 0; + } + + # Output hashes sorted alphabetically instead of apparently + # random. Use caseless alphabetic sort + foreach my $key (sort { lc $a cmp lc $b } keys %$item) + { + if ($is_first_line) { + $is_first_line = 0; + } + else { + $output .= "$body_indent"; + } + + # The key must be a scalar, but this recursive call quotes + # it + $output .= &simple_dumper($key); + + # And change the trailing comma and nl to the hash fat + # comma for clarity, and so the value can be on the same + # line + $output =~ s/,\n$/ => /; + + # Recursively call to get the value's dump. + my $next = &simple_dumper($item->{$key}, $next_indent); + + # If the value is all on one line, remove its indent, so + # will follow the => immediately. If it takes more than + # one line, start it on a new line. + if ($next !~ /\n.*\n/) { + $next =~ s/^ *//; + } + else { + $output .= "\n"; + } + $output .= $next; + } + + $output .= "$indent},\n" if $using_braces; + } + elsif (ref $item eq 'CODE' || ref $item eq 'GLOB') { + $output = $indent . ref($item) . "\n"; + # XXX see if blessed + } + elsif ($item->can('dump')) { + + # By convention in this program, objects furnish a 'dump' + # method. Since not doing any output at this level, just pass + # on the input indent + $output = $item->dump($indent); + } + else { + Carp::my_carp("Can't cope with dumping a " . ref($item) . ". Skipping."); + } + } + return $output; + } +} + +sub dump_inside_out { + # Dump inside-out hashes in an object's state by converting them to a + # regular hash and then calling simple_dumper on that. + + my $object = shift; + my $fields_ref = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $addr = main::objaddr $object; + + my %hash; + foreach my $key (keys %$fields_ref) { + $hash{$key} = $fields_ref->{$key}{$addr}; + } + + return simple_dumper(\%hash, @_); +} + +sub _operator_dot { + # Overloaded '.' method that is common to all packages. It uses the + # package's stringify method. + + my $self = shift; + my $other = shift; + my $reversed = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + $other = "" unless defined $other; + + foreach my $which (\$self, \$other) { + next unless ref $$which; + if ($$which->can('_operator_stringify')) { + $$which = $$which->_operator_stringify; + } + else { + my $ref = ref $$which; + my $addr = main::objaddr $$which; + $$which = "$ref ($addr)"; + } + } + return ($reversed) + ? "$other$self" + : "$self$other"; +} + +sub _operator_equal { + # Generic overloaded '==' routine. To be equal, they must be the exact + # same object + + my $self = shift; + my $other = shift; + + return 0 unless defined $other; + return 0 unless ref $other; + return main::objaddr $self == main::objaddr $other; +} + +sub _operator_not_equal { + my $self = shift; + my $other = shift; + + return ! _operator_equal($self, $other); +} + +sub process_PropertyAliases($) { + # This reads in the PropertyAliases.txt file, which contains almost all + # the character properties in Unicode and their equivalent aliases: + # scf ; Simple_Case_Folding ; sfc + # + # Field 0 is the preferred short name for the property. + # Field 1 is the full name. + # Any succeeding ones are other accepted names. + + my $file= shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # This whole file was non-existent in early releases, so use our own + # internal one. + $file->insert_lines(get_old_property_aliases()) + if ! -e 'PropertyAliases.txt'; + + # Add any cjk properties that may have been defined. + $file->insert_lines(@cjk_properties); + + while ($file->next_line) { + + my @data = split /\s*;\s*/; + + my $full = $data[1]; + + my $this = Property->new($data[0], Full_Name => $full); + + # Start looking for more aliases after these two. + for my $i (2 .. @data - 1) { + $this->add_alias($data[$i]); + } + + } + return; +} + +sub finish_property_setup { + # Finishes setting up after PropertyAliases. + + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # This entry was missing from this file in earlier Unicode versions + if (-e 'Jamo.txt') { + my $jsn = property_ref('JSN'); + if (! defined $jsn) { + $jsn = Property->new('JSN', Full_Name => 'Jamo_Short_Name'); + } + } + + # This entry is still missing as of 5.2, perhaps because no short name for + # it. + if (-e 'NameAliases.txt') { + my $aliases = property_ref('Name_Alias'); + if (! defined $aliases) { + $aliases = Property->new('Name_Alias'); + } + } + + # These are used so much, that we set globals for them. + $gc = property_ref('General_Category'); + $block = property_ref('Block'); + + # Perl adds this alias. + $gc->add_alias('Category'); + + # For backwards compatibility, these property files have particular names. + my $upper = property_ref('Uppercase_Mapping'); + $upper->set_core_access('uc()'); + $upper->set_file('Upper'); # This is what utf8.c calls it + + my $lower = property_ref('Lowercase_Mapping'); + $lower->set_core_access('lc()'); + $lower->set_file('Lower'); + + my $title = property_ref('Titlecase_Mapping'); + $title->set_core_access('ucfirst()'); + $title->set_file('Title'); + + my $fold = property_ref('Case_Folding'); + $fold->set_file('Fold') if defined $fold; + + # utf8.c can't currently cope with non range-size-1 for these, and even if + # it were changed to do so, someone else may be using them, expecting the + # old style + foreach my $property (qw { + Case_Folding + Lowercase_Mapping + Titlecase_Mapping + Uppercase_Mapping + }) + { + property_ref($property)->set_range_size_1(1); + } + + # These two properties aren't actually used in the core, but unfortunately + # the names just above that are in the core interfere with these, so + # choose different names. These aren't a problem unless the map tables + # for these files get written out. + my $lowercase = property_ref('Lowercase'); + $lowercase->set_file('IsLower') if defined $lowercase; + my $uppercase = property_ref('Uppercase'); + $uppercase->set_file('IsUpper') if defined $uppercase; + + # Set up the hard-coded default mappings, but only on properties defined + # for this release + foreach my $property (keys %default_mapping) { + my $property_object = property_ref($property); + next if ! defined $property_object; + my $default_map = $default_mapping{$property}; + $property_object->set_default_map($default_map); + + # A map of implies the property is string. + if ($property_object->type == $UNKNOWN + && $default_map eq $CODE_POINT) + { + $property_object->set_type($STRING); + } + } + + # The following use the Multi_Default class to create objects for + # defaults. + + # Bidi class has a complicated default, but the derived file takes care of + # the complications, leaving just 'L'. + if (file_exists("${EXTRACTED}DBidiClass.txt")) { + property_ref('Bidi_Class')->set_default_map('L'); + } + else { + my $default; + + # The derived file was introduced in 3.1.1. The values below are + # taken from table 3-8, TUS 3.0 + my $default_R = + 'my $default = Range_List->new; + $default->add_range(0x0590, 0x05FF); + $default->add_range(0xFB1D, 0xFB4F);' + ; + + # The defaults apply only to unassigned characters + $default_R .= '$gc->table("Cn") & $default;'; + + if ($v_version lt v3.0.0) { + $default = Multi_Default->new(R => $default_R, 'L'); + } + else { + + # AL apparently not introduced until 3.0: TUS 2.x references are + # not on-line to check it out + my $default_AL = + 'my $default = Range_List->new; + $default->add_range(0x0600, 0x07BF); + $default->add_range(0xFB50, 0xFDFF); + $default->add_range(0xFE70, 0xFEFF);' + ; + + # Non-character code points introduced in this release; aren't AL + if ($v_version ge 3.1.0) { + $default_AL .= '$default->delete_range(0xFDD0, 0xFDEF);'; + } + $default_AL .= '$gc->table("Cn") & $default'; + $default = Multi_Default->new(AL => $default_AL, + R => $default_R, + 'L'); + } + property_ref('Bidi_Class')->set_default_map($default); + } + + # Joining type has a complicated default, but the derived file takes care + # of the complications, leaving just 'U' (or Non_Joining), except the file + # is bad in 3.1.0 + if (file_exists("${EXTRACTED}DJoinType.txt") || -e 'ArabicShaping.txt') { + if (file_exists("${EXTRACTED}DJoinType.txt") && $v_version ne 3.1.0) { + property_ref('Joining_Type')->set_default_map('Non_Joining'); + } + else { + + # Otherwise, there are not one, but two possibilities for the + # missing defaults: T and U. + # The missing defaults that evaluate to T are given by: + # T = Mn + Cf - ZWNJ - ZWJ + # where Mn and Cf are the general category values. In other words, + # any non-spacing mark or any format control character, except + # U+200C ZERO WIDTH NON-JOINER (joining type U) and U+200D ZERO + # WIDTH JOINER (joining type C). + my $default = Multi_Default->new( + 'T' => '$gc->table("Mn") + $gc->table("Cf") - 0x200C - 0x200D', + 'Non_Joining'); + property_ref('Joining_Type')->set_default_map($default); + } + } + + # Line break has a complicated default in early releases. It is 'Unknown' + # for non-assigned code points; 'AL' for assigned. + if (file_exists("${EXTRACTED}DLineBreak.txt") || -e 'LineBreak.txt') { + my $lb = property_ref('Line_Break'); + if ($v_version gt 3.2.0) { + $lb->set_default_map('Unknown'); + } + else { + my $default = Multi_Default->new( 'Unknown' => '$gc->table("Cn")', + 'AL'); + $lb->set_default_map($default); + } + + # If has the URS property, make sure that the standard aliases are in + # it, since not in the input tables in some versions. + my $urs = property_ref('Unicode_Radical_Stroke'); + if (defined $urs) { + $urs->add_alias('cjkRSUnicode'); + $urs->add_alias('kRSUnicode'); + } + } + return; +} + +sub get_old_property_aliases() { + # Returns what would be in PropertyAliases.txt if it existed in very old + # versions of Unicode. It was derived from the one in 3.2, and pared + # down based on the data that was actually in the older releases. + # An attempt was made to use the existence of files to mean inclusion or + # not of various aliases, but if this was not sufficient, using version + # numbers was resorted to. + + my @return; + + # These are to be used in all versions (though some are constructed by + # this program if missing) + push @return, split /\n/, <<'END'; +bc ; Bidi_Class +Bidi_M ; Bidi_Mirrored +cf ; Case_Folding +ccc ; Canonical_Combining_Class +dm ; Decomposition_Mapping +dt ; Decomposition_Type +gc ; General_Category +isc ; ISO_Comment +lc ; Lowercase_Mapping +na ; Name +na1 ; Unicode_1_Name +nt ; Numeric_Type +nv ; Numeric_Value +sfc ; Simple_Case_Folding +slc ; Simple_Lowercase_Mapping +stc ; Simple_Titlecase_Mapping +suc ; Simple_Uppercase_Mapping +tc ; Titlecase_Mapping +uc ; Uppercase_Mapping +END + + if (-e 'Blocks.txt') { + push @return, "blk ; Block\n"; + } + if (-e 'ArabicShaping.txt') { + push @return, split /\n/, <<'END'; +jg ; Joining_Group +jt ; Joining_Type +END + } + if (-e 'PropList.txt') { + + # This first set is in the original old-style proplist. + push @return, split /\n/, <<'END'; +Alpha ; Alphabetic +Bidi_C ; Bidi_Control +Dash ; Dash +Dia ; Diacritic +Ext ; Extender +Hex ; Hex_Digit +Hyphen ; Hyphen +IDC ; ID_Continue +Ideo ; Ideographic +Join_C ; Join_Control +Math ; Math +QMark ; Quotation_Mark +Term ; Terminal_Punctuation +WSpace ; White_Space +END + # The next sets were added later + if ($v_version ge v3.0.0) { + push @return, split /\n/, <<'END'; +Upper ; Uppercase +Lower ; Lowercase +END + } + if ($v_version ge v3.0.1) { + push @return, split /\n/, <<'END'; +NChar ; Noncharacter_Code_Point +END + } + # The next sets were added in the new-style + if ($v_version ge v3.1.0) { + push @return, split /\n/, <<'END'; +OAlpha ; Other_Alphabetic +OLower ; Other_Lowercase +OMath ; Other_Math +OUpper ; Other_Uppercase +END + } + if ($v_version ge v3.1.1) { + push @return, "AHex ; ASCII_Hex_Digit\n"; + } + } + if (-e 'EastAsianWidth.txt') { + push @return, "ea ; East_Asian_Width\n"; + } + if (-e 'CompositionExclusions.txt') { + push @return, "CE ; Composition_Exclusion\n"; + } + if (-e 'LineBreak.txt') { + push @return, "lb ; Line_Break\n"; + } + if (-e 'BidiMirroring.txt') { + push @return, "bmg ; Bidi_Mirroring_Glyph\n"; + } + if (-e 'Scripts.txt') { + push @return, "sc ; Script\n"; + } + if (-e 'DNormalizationProps.txt') { + push @return, split /\n/, <<'END'; +Comp_Ex ; Full_Composition_Exclusion +FC_NFKC ; FC_NFKC_Closure +NFC_QC ; NFC_Quick_Check +NFD_QC ; NFD_Quick_Check +NFKC_QC ; NFKC_Quick_Check +NFKD_QC ; NFKD_Quick_Check +XO_NFC ; Expands_On_NFC +XO_NFD ; Expands_On_NFD +XO_NFKC ; Expands_On_NFKC +XO_NFKD ; Expands_On_NFKD +END + } + if (-e 'DCoreProperties.txt') { + push @return, split /\n/, <<'END'; +IDS ; ID_Start +XIDC ; XID_Continue +XIDS ; XID_Start +END + # These can also appear in some versions of PropList.txt + push @return, "Lower ; Lowercase\n" + unless grep { $_ =~ /^Lower\b/} @return; + push @return, "Upper ; Uppercase\n" + unless grep { $_ =~ /^Upper\b/} @return; + } + + # This flag requires the DAge.txt file to be copied into the directory. + if (DEBUG && $compare_versions) { + push @return, 'age ; Age'; + } + + return @return; +} + +sub process_PropValueAliases { + # This file contains values that properties look like: + # bc ; AL ; Arabic_Letter + # blk; n/a ; Greek_And_Coptic ; Greek + # + # Field 0 is the property. + # Field 1 is the short name of a property value or 'n/a' if no + # short name exists; + # Field 2 is the full property value name; + # Any other fields are more synonyms for the property value. + # Purely numeric property values are omitted from the file; as are some + # others, fewer and fewer in later releases + + # Entries for the ccc property have an extra field before the + # abbreviation: + # ccc; 0; NR ; Not_Reordered + # It is the numeric value that the names are synonyms for. + + # There are comment entries for values missing from this file: + # # @missing: 0000..10FFFF; ISO_Comment; + # # @missing: 0000..10FFFF; Lowercase_Mapping; + + my $file= shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # This whole file was non-existent in early releases, so use our own + # internal one if necessary. + if (! -e 'PropValueAliases.txt') { + $file->insert_lines(get_old_property_value_aliases()); + } + + # Add any explicit cjk values + $file->insert_lines(@cjk_property_values); + + # This line is used only for testing the code that checks for name + # conflicts. There is a script Inherited, and when this line is executed + # it causes there to be a name conflict with the 'Inherited' that this + # program generates for this block property value + #$file->insert_lines('blk; n/a; Herited'); + + + # Process each line of the file ... + while ($file->next_line) { + + my ($property, @data) = split /\s*;\s*/; + + # The full name for the ccc property value is in field 2 of the + # remaining ones; field 1 for all other properties. Swap ccc fields 1 + # and 2. (Rightmost splice removes field 2, returning it; left splice + # inserts that into field 1, thus shifting former field 1 to field 2.) + splice (@data, 1, 0, splice(@data, 2, 1)) if $property eq 'ccc'; + + # If there is no short name, use the full one in element 1 + $data[0] = $data[1] if $data[0] eq "n/a"; + + # Earlier releases had the pseudo property 'qc' that should expand to + # the ones that replace it below. + if ($property eq 'qc') { + if (lc $data[0] eq 'y') { + $file->insert_lines('NFC_QC; Y ; Yes', + 'NFD_QC; Y ; Yes', + 'NFKC_QC; Y ; Yes', + 'NFKD_QC; Y ; Yes', + ); + } + elsif (lc $data[0] eq 'n') { + $file->insert_lines('NFC_QC; N ; No', + 'NFD_QC; N ; No', + 'NFKC_QC; N ; No', + 'NFKD_QC; N ; No', + ); + } + elsif (lc $data[0] eq 'm') { + $file->insert_lines('NFC_QC; M ; Maybe', + 'NFKC_QC; M ; Maybe', + ); + } + else { + $file->carp_bad_line("qc followed by unexpected '$data[0]"); + } + next; + } + + # The first field is the short name, 2nd is the full one. + my $property_object = property_ref($property); + my $table = $property_object->add_match_table($data[0], + Full_Name => $data[1]); + + # Start looking for more aliases after these two. + for my $i (2 .. @data - 1) { + $table->add_alias($data[$i]); + } + } # End of looping through the file + + # As noted in the comments early in the program, it generates tables for + # the default values for all releases, even those for which the concept + # didn't exist at the time. Here we add those if missing. + my $age = property_ref('age'); + if (defined $age && ! defined $age->table('Unassigned')) { + $age->add_match_table('Unassigned'); + } + $block->add_match_table('No_Block') if -e 'Blocks.txt' + && ! defined $block->table('No_Block'); + + + # Now set the default mappings of the properties from the file. This is + # done after the loop because a number of properties have only @missings + # entries in the file, and may not show up until the end. + my @defaults = $file->get_missings; + foreach my $default_ref (@defaults) { + my $default = $default_ref->[0]; + my $property = property_ref($default_ref->[1]); + $property->set_default_map($default); + } + return; +} + +sub get_old_property_value_aliases () { + # Returns what would be in PropValueAliases.txt if it existed in very old + # versions of Unicode. It was derived from the one in 3.2, and pared + # down. An attempt was made to use the existence of files to mean + # inclusion or not of various aliases, but if this was not sufficient, + # using version numbers was resorted to. + + my @return = split /\n/, <<'END'; +bc ; AN ; Arabic_Number +bc ; B ; Paragraph_Separator +bc ; CS ; Common_Separator +bc ; EN ; European_Number +bc ; ES ; European_Separator +bc ; ET ; European_Terminator +bc ; L ; Left_To_Right +bc ; ON ; Other_Neutral +bc ; R ; Right_To_Left +bc ; WS ; White_Space + +# The standard combining classes are very much different in v1, so only use +# ones that look right (not checked thoroughly) +ccc; 0; NR ; Not_Reordered +ccc; 1; OV ; Overlay +ccc; 7; NK ; Nukta +ccc; 8; KV ; Kana_Voicing +ccc; 9; VR ; Virama +ccc; 202; ATBL ; Attached_Below_Left +ccc; 216; ATAR ; Attached_Above_Right +ccc; 218; BL ; Below_Left +ccc; 220; B ; Below +ccc; 222; BR ; Below_Right +ccc; 224; L ; Left +ccc; 228; AL ; Above_Left +ccc; 230; A ; Above +ccc; 232; AR ; Above_Right +ccc; 234; DA ; Double_Above + +dt ; can ; canonical +dt ; enc ; circle +dt ; fin ; final +dt ; font ; font +dt ; fra ; fraction +dt ; init ; initial +dt ; iso ; isolated +dt ; med ; medial +dt ; n/a ; none +dt ; nb ; noBreak +dt ; sqr ; square +dt ; sub ; sub +dt ; sup ; super + +gc ; C ; Other # Cc | Cf | Cn | Co | Cs +gc ; Cc ; Control +gc ; Cn ; Unassigned +gc ; Co ; Private_Use +gc ; L ; Letter # Ll | Lm | Lo | Lt | Lu +gc ; LC ; Cased_Letter # Ll | Lt | Lu +gc ; Ll ; Lowercase_Letter +gc ; Lm ; Modifier_Letter +gc ; Lo ; Other_Letter +gc ; Lu ; Uppercase_Letter +gc ; M ; Mark # Mc | Me | Mn +gc ; Mc ; Spacing_Mark +gc ; Mn ; Nonspacing_Mark +gc ; N ; Number # Nd | Nl | No +gc ; Nd ; Decimal_Number +gc ; No ; Other_Number +gc ; P ; Punctuation # Pc | Pd | Pe | Pf | Pi | Po | Ps +gc ; Pd ; Dash_Punctuation +gc ; Pe ; Close_Punctuation +gc ; Po ; Other_Punctuation +gc ; Ps ; Open_Punctuation +gc ; S ; Symbol # Sc | Sk | Sm | So +gc ; Sc ; Currency_Symbol +gc ; Sm ; Math_Symbol +gc ; So ; Other_Symbol +gc ; Z ; Separator # Zl | Zp | Zs +gc ; Zl ; Line_Separator +gc ; Zp ; Paragraph_Separator +gc ; Zs ; Space_Separator + +nt ; de ; Decimal +nt ; di ; Digit +nt ; n/a ; None +nt ; nu ; Numeric +END + + if (-e 'ArabicShaping.txt') { + push @return, split /\n/, <<'END'; +jg ; n/a ; AIN +jg ; n/a ; ALEF +jg ; n/a ; DAL +jg ; n/a ; GAF +jg ; n/a ; LAM +jg ; n/a ; MEEM +jg ; n/a ; NO_JOINING_GROUP +jg ; n/a ; NOON +jg ; n/a ; QAF +jg ; n/a ; SAD +jg ; n/a ; SEEN +jg ; n/a ; TAH +jg ; n/a ; WAW + +jt ; C ; Join_Causing +jt ; D ; Dual_Joining +jt ; L ; Left_Joining +jt ; R ; Right_Joining +jt ; U ; Non_Joining +jt ; T ; Transparent +END + if ($v_version ge v3.0.0) { + push @return, split /\n/, <<'END'; +jg ; n/a ; ALAPH +jg ; n/a ; BEH +jg ; n/a ; BETH +jg ; n/a ; DALATH_RISH +jg ; n/a ; E +jg ; n/a ; FEH +jg ; n/a ; FINAL_SEMKATH +jg ; n/a ; GAMAL +jg ; n/a ; HAH +jg ; n/a ; HAMZA_ON_HEH_GOAL +jg ; n/a ; HE +jg ; n/a ; HEH +jg ; n/a ; HEH_GOAL +jg ; n/a ; HETH +jg ; n/a ; KAF +jg ; n/a ; KAPH +jg ; n/a ; KNOTTED_HEH +jg ; n/a ; LAMADH +jg ; n/a ; MIM +jg ; n/a ; NUN +jg ; n/a ; PE +jg ; n/a ; QAPH +jg ; n/a ; REH +jg ; n/a ; REVERSED_PE +jg ; n/a ; SADHE +jg ; n/a ; SEMKATH +jg ; n/a ; SHIN +jg ; n/a ; SWASH_KAF +jg ; n/a ; TAW +jg ; n/a ; TEH_MARBUTA +jg ; n/a ; TETH +jg ; n/a ; YEH +jg ; n/a ; YEH_BARREE +jg ; n/a ; YEH_WITH_TAIL +jg ; n/a ; YUDH +jg ; n/a ; YUDH_HE +jg ; n/a ; ZAIN +END + } + } + + + if (-e 'EastAsianWidth.txt') { + push @return, split /\n/, <<'END'; +ea ; A ; Ambiguous +ea ; F ; Fullwidth +ea ; H ; Halfwidth +ea ; N ; Neutral +ea ; Na ; Narrow +ea ; W ; Wide +END + } + + if (-e 'LineBreak.txt') { + push @return, split /\n/, <<'END'; +lb ; AI ; Ambiguous +lb ; AL ; Alphabetic +lb ; B2 ; Break_Both +lb ; BA ; Break_After +lb ; BB ; Break_Before +lb ; BK ; Mandatory_Break +lb ; CB ; Contingent_Break +lb ; CL ; Close_Punctuation +lb ; CM ; Combining_Mark +lb ; CR ; Carriage_Return +lb ; EX ; Exclamation +lb ; GL ; Glue +lb ; HY ; Hyphen +lb ; ID ; Ideographic +lb ; IN ; Inseperable +lb ; IS ; Infix_Numeric +lb ; LF ; Line_Feed +lb ; NS ; Nonstarter +lb ; NU ; Numeric +lb ; OP ; Open_Punctuation +lb ; PO ; Postfix_Numeric +lb ; PR ; Prefix_Numeric +lb ; QU ; Quotation +lb ; SA ; Complex_Context +lb ; SG ; Surrogate +lb ; SP ; Space +lb ; SY ; Break_Symbols +lb ; XX ; Unknown +lb ; ZW ; ZWSpace +END + } + + if (-e 'DNormalizationProps.txt') { + push @return, split /\n/, <<'END'; +qc ; M ; Maybe +qc ; N ; No +qc ; Y ; Yes +END + } + + if (-e 'Scripts.txt') { + push @return, split /\n/, <<'END'; +sc ; Arab ; Arabic +sc ; Armn ; Armenian +sc ; Beng ; Bengali +sc ; Bopo ; Bopomofo +sc ; Cans ; Canadian_Aboriginal +sc ; Cher ; Cherokee +sc ; Cyrl ; Cyrillic +sc ; Deva ; Devanagari +sc ; Dsrt ; Deseret +sc ; Ethi ; Ethiopic +sc ; Geor ; Georgian +sc ; Goth ; Gothic +sc ; Grek ; Greek +sc ; Gujr ; Gujarati +sc ; Guru ; Gurmukhi +sc ; Hang ; Hangul +sc ; Hani ; Han +sc ; Hebr ; Hebrew +sc ; Hira ; Hiragana +sc ; Ital ; Old_Italic +sc ; Kana ; Katakana +sc ; Khmr ; Khmer +sc ; Knda ; Kannada +sc ; Laoo ; Lao +sc ; Latn ; Latin +sc ; Mlym ; Malayalam +sc ; Mong ; Mongolian +sc ; Mymr ; Myanmar +sc ; Ogam ; Ogham +sc ; Orya ; Oriya +sc ; Qaai ; Inherited +sc ; Runr ; Runic +sc ; Sinh ; Sinhala +sc ; Syrc ; Syriac +sc ; Taml ; Tamil +sc ; Telu ; Telugu +sc ; Thaa ; Thaana +sc ; Thai ; Thai +sc ; Tibt ; Tibetan +sc ; Yiii ; Yi +sc ; Zyyy ; Common +END + } + + if ($v_version ge v2.0.0) { + push @return, split /\n/, <<'END'; +dt ; com ; compat +dt ; nar ; narrow +dt ; sml ; small +dt ; vert ; vertical +dt ; wide ; wide + +gc ; Cf ; Format +gc ; Cs ; Surrogate +gc ; Lt ; Titlecase_Letter +gc ; Me ; Enclosing_Mark +gc ; Nl ; Letter_Number +gc ; Pc ; Connector_Punctuation +gc ; Sk ; Modifier_Symbol +END + } + if ($v_version ge v2.1.2) { + push @return, "bc ; S ; Segment_Separator\n"; + } + if ($v_version ge v2.1.5) { + push @return, split /\n/, <<'END'; +gc ; Pf ; Final_Punctuation +gc ; Pi ; Initial_Punctuation +END + } + if ($v_version ge v2.1.8) { + push @return, "ccc; 240; IS ; Iota_Subscript\n"; + } + + if ($v_version ge v3.0.0) { + push @return, split /\n/, <<'END'; +bc ; AL ; Arabic_Letter +bc ; BN ; Boundary_Neutral +bc ; LRE ; Left_To_Right_Embedding +bc ; LRO ; Left_To_Right_Override +bc ; NSM ; Nonspacing_Mark +bc ; PDF ; Pop_Directional_Format +bc ; RLE ; Right_To_Left_Embedding +bc ; RLO ; Right_To_Left_Override + +ccc; 233; DB ; Double_Below +END + } + + if ($v_version ge v3.1.0) { + push @return, "ccc; 226; R ; Right\n"; + } + + return @return; +} + +{ # Closure + # This is used to store the range list of all the code points usable when + # the little used $compare_versions feature is enabled. + my $compare_versions_range_list; + + sub process_generic_property_file { + # This processes a file containing property mappings and puts them + # into internal map tables. It should be used to handle any property + # files that have mappings from a code point or range thereof to + # something else. This means almost all the UCD .txt files. + # each_line_handlers() should be set to adjust the lines of these + # files, if necessary, to what this routine understands: + # + # 0374 ; NFD_QC; N + # 003C..003E ; Math + # + # the fields are: "codepoint range ; property; map" + # + # meaning the codepoints in the range all have the value 'map' under + # 'property'. + # Beginning and trailing white space in each field are not signficant. + # Note there is not a trailing semi-colon in the above. A trailing + # semi-colon means the map is a null-string. An omitted map, as + # opposed to a null-string, is assumed to be 'Y', based on Unicode + # table syntax. (This could have been hidden from this routine by + # doing it in the $file object, but that would require parsing of the + # line there, so would have to parse it twice, or change the interface + # to pass this an array. So not done.) + # + # The map field may begin with a sequence of commands that apply to + # this range. Each such command begins and ends with $CMD_DELIM. + # These are used to indicate, for example, that the mapping for a + # range has a non-default type. + # + # This loops through the file, calling it's next_line() method, and + # then taking the map and adding it to the property's table. + # Complications arise because any number of properties can be in the + # file, in any order, interspersed in any way. The first time a + # property is seen, it gets information about that property and + # cache's it for quick retrieval later. It also normalizes the maps + # so that only one of many synonym is stored. The Unicode input files + # do use some multiple synonyms. + + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my %property_info; # To keep track of what properties + # have already had entries in the + # current file, and info about each, + # so don't have to recompute. + my $property_name; # property currently being worked on + my $property_type; # and its type + my $previous_property_name = ""; # name from last time through loop + my $property_object; # pointer to the current property's + # object + my $property_addr; # the address of that object + my $default_map; # the string that code points missing + # from the file map to + my $default_table; # For non-string properties, a + # reference to the match table that + # will contain the list of code + # points that map to $default_map. + + # Get the next real non-comment line + LINE: + while ($file->next_line) { + + # Default replacement type; means that if parts of the range have + # already been stored in our tables, the new map overrides them if + # they differ more than cosmetically + my $replace = $IF_NOT_EQUIVALENT; + my $map_type; # Default type for the map of this range + + #local $to_trace = 1 if main::DEBUG; + trace $_ if main::DEBUG && $to_trace; + + # Split the line into components + my ($range, $property_name, $map, @remainder) + = split /\s*;\s*/, $_, -1; # -1 => retain trailing null fields + + # If more or less on the line than we are expecting, warn and skip + # the line + if (@remainder) { + $file->carp_bad_line('Extra fields'); + next LINE; + } + elsif ( ! defined $property_name) { + $file->carp_bad_line('Missing property'); + next LINE; + } + + # Examine the range. + if ($range !~ /^ ($code_point_re) (?:\.\. ($code_point_re) )? $/x) + { + $file->carp_bad_line("Range '$range' not of the form 'CP1' or 'CP1..CP2' (where CP1,2 are code points in hex)"); + next LINE; + } + my $low = hex $1; + my $high = (defined $2) ? hex $2 : $low; + + # For the very specialized case of comparing two Unicode + # versions... + if (DEBUG && $compare_versions) { + if ($property_name eq 'Age') { + + # Only allow code points at least as old as the version + # specified. + my $age = pack "C*", split(/\./, $map); # v string + next LINE if $age gt $compare_versions; + } + else { + + # Again, we throw out code points younger than those of + # the specified version. By now, the Age property is + # populated. We use the intersection of each input range + # with this property to find what code points in it are + # valid. To do the intersection, we have to convert the + # Age property map to a Range_list. We only have to do + # this once. + if (! defined $compare_versions_range_list) { + my $age = property_ref('Age'); + if (! -e 'DAge.txt') { + croak "Need to have 'DAge.txt' file to do version comparison"; + } + elsif ($age->count == 0) { + croak "The 'Age' table is empty, but its file exists"; + } + $compare_versions_range_list + = Range_List->new(Initialize => $age); + } + + # An undefined map is always 'Y' + $map = 'Y' if ! defined $map; + + # Calculate the intersection of the input range with the + # code points that are known in the specified version + my @ranges = ($compare_versions_range_list + & Range->new($low, $high))->ranges; + + # If the intersection is empty, throw away this range + next LINE unless @ranges; + + # Only examine the first range this time through the loop. + my $this_range = shift @ranges; + + # Put any remaining ranges in the queue to be processed + # later. Note that there is unnecessary work here, as we + # will do the intersection again for each of these ranges + # during some future iteration of the LINE loop, but this + # code is not used in production. The later intersections + # are guaranteed to not splinter, so this will not become + # an infinite loop. + my $line = join ';', $property_name, $map; + foreach my $range (@ranges) { + $file->insert_adjusted_lines(sprintf("%04X..%04X; %s", + $range->start, + $range->end, + $line)); + } + + # And process the first range, like any other. + $low = $this_range->start; + $high = $this_range->end; + } + } # End of $compare_versions + + # If changing to a new property, get the things constant per + # property + if ($previous_property_name ne $property_name) { + + $property_object = property_ref($property_name); + if (! defined $property_object) { + $file->carp_bad_line("Unexpected property '$property_name'. Skipped"); + next LINE; + } + $property_addr = main::objaddr($property_object); + + # Defer changing names until have a line that is acceptable + # (the 'next' statement above means is unacceptable) + $previous_property_name = $property_name; + + # If not the first time for this property, retrieve info about + # it from the cache + if (defined ($property_info{$property_addr}{'type'})) { + $property_type = $property_info{$property_addr}{'type'}; + $default_map = $property_info{$property_addr}{'default'}; + $map_type + = $property_info{$property_addr}{'pseudo_map_type'}; + $default_table + = $property_info{$property_addr}{'default_table'}; + } + else { + + # Here, is the first time for this property. Set up the + # cache. + $property_type = $property_info{$property_addr}{'type'} + = $property_object->type; + $map_type + = $property_info{$property_addr}{'pseudo_map_type'} + = $property_object->pseudo_map_type; + + # The Unicode files are set up so that if the map is not + # defined, it is a binary property + if (! defined $map && $property_type != $BINARY) { + if ($property_type != $UNKNOWN + && $property_type != $NON_STRING) + { + $file->carp_bad_line("No mapping defined on a non-binary property. Using 'Y' for the map"); + } + else { + $property_object->set_type($BINARY); + $property_type + = $property_info{$property_addr}{'type'} + = $BINARY; + } + } + + # Get any @missings default for this property. This + # should precede the first entry for the property in the + # input file, and is located in a comment that has been + # stored by the Input_file class until we access it here. + # It's possible that there is more than one such line + # waiting for us; collect them all, and parse + my @missings_list = $file->get_missings + if $file->has_missings_defaults; + foreach my $default_ref (@missings_list) { + my $default = $default_ref->[0]; + my $addr = objaddr property_ref($default_ref->[1]); + + # For string properties, the default is just what the + # file says, but non-string properties should already + # have set up a table for the default property value; + # use the table for these, so can resolve synonyms + # later to a single standard one. + if ($property_type == $STRING + || $property_type == $UNKNOWN) + { + $property_info{$addr}{'missings'} = $default; + } + else { + $property_info{$addr}{'missings'} + = $property_object->table($default); + } + } + + # Finished storing all the @missings defaults in the input + # file so far. Get the one for the current property. + my $missings = $property_info{$property_addr}{'missings'}; + + # But we likely have separately stored what the default + # should be. (This is to accommodate versions of the + # standard where the @missings lines are absent or + # incomplete.) Hopefully the two will match. But check + # it out. + $default_map = $property_object->default_map; + + # If the map is a ref, it means that the default won't be + # processed until later, so undef it, so next few lines + # will redefine it to something that nothing will match + undef $default_map if ref $default_map; + + # Create a $default_map if don't have one; maybe a dummy + # that won't match anything. + if (! defined $default_map) { + + # Use any @missings line in the file. + if (defined $missings) { + if (ref $missings) { + $default_map = $missings->full_name; + $default_table = $missings; + } + else { + $default_map = $missings; + } + + # And store it with the property for outside use. + $property_object->set_default_map($default_map); + } + else { + + # Neither an @missings nor a default map. Create + # a dummy one, so won't have to test definedness + # in the main loop. + $default_map = '_Perl This will never be in a file + from Unicode'; + } + } + + # Here, we have $default_map defined, possibly in terms of + # $missings, but maybe not, and possibly is a dummy one. + if (defined $missings) { + + # Make sure there is no conflict between the two. + # $missings has priority. + if (ref $missings) { + $default_table + = $property_object->table($default_map); + if (! defined $default_table + || $default_table != $missings) + { + if (! defined $default_table) { + $default_table = $UNDEF; + } + $file->carp_bad_line(<full_name; + } + $property_info{$property_addr}{'default_table'} + = $default_table; + } + elsif ($default_map ne $missings) { + $file->carp_bad_line(<table($default_map); + } + } # End of is first time for this property + } # End of switching properties. + + # Ready to process the line. + # The Unicode files are set up so that if the map is not defined, + # it is a binary property with value 'Y' + if (! defined $map) { + $map = 'Y'; + } + else { + + # If the map begins with a special command to us (enclosed in + # delimiters), extract the command(s). + if (substr($map, 0, 1) eq $CMD_DELIM) { + while ($map =~ s/ ^ $CMD_DELIM (.*?) $CMD_DELIM //x) { + my $command = $1; + if ($command =~ / ^ $REPLACE_CMD= (.*) /x) { + $replace = $1; + } + elsif ($command =~ / ^ $MAP_TYPE_CMD= (.*) /x) { + $map_type = $1; + } + else { + $file->carp_bad_line("Unknown command line: '$1'"); + next LINE; + } + } + } + } + + if ($default_map eq $CODE_POINT && $map =~ / ^ $code_point_re $/x) + { + + # Here, we have a map to a particular code point, and the + # default map is to a code point itself. If the range + # includes the particular code point, change that portion of + # the range to the default. This makes sure that in the final + # table only the non-defaults are listed. + my $decimal_map = hex $map; + if ($low <= $decimal_map && $decimal_map <= $high) { + + # If the range includes stuff before or after the map + # we're changing, split it and process the split-off parts + # later. + if ($low < $decimal_map) { + $file->insert_adjusted_lines( + sprintf("%04X..%04X; %s; %s", + $low, + $decimal_map - 1, + $property_name, + $map)); + } + if ($high > $decimal_map) { + $file->insert_adjusted_lines( + sprintf("%04X..%04X; %s; %s", + $decimal_map + 1, + $high, + $property_name, + $map)); + } + $low = $high = $decimal_map; + $map = $CODE_POINT; + } + } + + # If we can tell that this is a synonym for the default map, use + # the default one instead. + if ($property_type != $STRING + && $property_type != $UNKNOWN) + { + my $table = $property_object->table($map); + if (defined $table && $table == $default_table) { + $map = $default_map; + } + } + + # And figure out the map type if not known. + if (! defined $map_type || $map_type == $COMPUTE_NO_MULTI_CP) { + if ($map eq "") { # Nulls are always $NULL map type + $map_type = $NULL; + } # Otherwise, non-strings, and those that don't allow + # $MULTI_CP, and those that aren't multiple code points are + # 0 + elsif + (($property_type != $STRING && $property_type != $UNKNOWN) + || (defined $map_type && $map_type == $COMPUTE_NO_MULTI_CP) + || $map !~ /^ $code_point_re ( \ $code_point_re )+ $ /x) + { + $map_type = 0; + } + else { + $map_type = $MULTI_CP; + } + } + + $property_object->add_map($low, $high, + $map, + Type => $map_type, + Replace => $replace); + } # End of loop through file's lines + + return; + } +} + +# Unused until revise charnames; +#sub check_and_handle_compound_name { +# This looks at Name properties for parenthesized components and splits +# them off. Thus it finds FF as an equivalent to Form Feed. +# my $code_point = shift; +# my $name = shift; +# if ($name =~ /^ ( .*? ) ( \s* ) \( ( [^)]* ) \) (.*) $/x) { +# #local $to_trace = 1 if main::DEBUG; +# trace $1, $2, $3, $4 if main::DEBUG && $to_trace; +# push @more_Names, "$code_point; $1"; +# push @more_Names, "$code_point; $3"; +# Carp::my_carp_bug("Expecting blank space before left parenthesis in '$_'. Proceeding and assuming it was there;") if $2 ne " "; +# Carp::my_carp_bug("Not expecting anything after the right parenthesis in '$_'. Proceeding and ignoring that;") if $4 ne ""; +# } +# return; +#} + +{ # Closure for UnicodeData.txt handling + + # This file was the first one in the UCD; its design leads to some + # awkwardness in processing. Here is a sample line: + # 0041;LATIN CAPITAL LETTER A;Lu;0;L;;;;;N;;;;0061; + # The fields in order are: + my $i = 0; # The code point is in field 0, and is shifted off. + my $NAME = $i++; # character name (e.g. "LATIN CAPITAL LETTER A") + my $CATEGORY = $i++; # category (e.g. "Lu") + my $CCC = $i++; # Canonical combining class (e.g. "230") + my $BIDI = $i++; # directional class (e.g. "L") + my $PERL_DECOMPOSITION = $i++; # decomposition mapping + my $PERL_DECIMAL_DIGIT = $i++; # decimal digit value + my $NUMERIC_TYPE_OTHER_DIGIT = $i++; # digit value, like a superscript + # Dual-use in this program; see below + my $NUMERIC = $i++; # numeric value + my $MIRRORED = $i++; # ? mirrored + my $UNICODE_1_NAME = $i++; # name in Unicode 1.0 + my $COMMENT = $i++; # iso comment + my $UPPER = $i++; # simple uppercase mapping + my $LOWER = $i++; # simple lowercase mapping + my $TITLE = $i++; # simple titlecase mapping + my $input_field_count = $i; + + # This routine in addition outputs these extra fields: + my $DECOMP_TYPE = $i++; # Decomposition type + my $DECOMP_MAP = $i++; # Must be last; another decomposition mapping + my $last_field = $i - 1; + + # All these are read into an array for each line, with the indices defined + # above. The empty fields in the example line above indicate that the + # value is defaulted. The handler called for each line of the input + # changes these to their defaults. + + # Here are the official names of the properties, in a parallel array: + my @field_names; + $field_names[$BIDI] = 'Bidi_Class'; + $field_names[$CATEGORY] = 'General_Category'; + $field_names[$CCC] = 'Canonical_Combining_Class'; + $field_names[$COMMENT] = 'ISO_Comment'; + $field_names[$DECOMP_MAP] = 'Decomposition_Mapping'; + $field_names[$DECOMP_TYPE] = 'Decomposition_Type'; + $field_names[$LOWER] = 'Simple_Lowercase_Mapping'; + $field_names[$MIRRORED] = 'Bidi_Mirrored'; + $field_names[$NAME] = 'Name'; + $field_names[$NUMERIC] = 'Numeric_Value'; + $field_names[$NUMERIC_TYPE_OTHER_DIGIT] = 'Numeric_Type'; + $field_names[$PERL_DECIMAL_DIGIT] = 'Perl_Decimal_Digit'; + $field_names[$PERL_DECOMPOSITION] = 'Perl_Decomposition_Mapping'; + $field_names[$TITLE] = 'Simple_Titlecase_Mapping'; + $field_names[$UNICODE_1_NAME] = 'Unicode_1_Name'; + $field_names[$UPPER] = 'Simple_Uppercase_Mapping'; + + # Some of these need a little more explanation. The $PERL_DECIMAL_DIGIT + # field does not lead to an official Unicode property, but is used in + # calculating the Numeric_Type. Perl however, creates a file from this + # field, so a Perl property is created from it. Similarly, the Other + # Digit field is used only for calculating the Numeric_Type, and so it can + # be safely re-used as the place to store the value for Numeric_Type; + # hence it is referred to as $NUMERIC_TYPE_OTHER_DIGIT. The input field + # named $PERL_DECOMPOSITION is a combination of both the decomposition + # mapping and its type. Perl creates a file containing exactly this + # field, so it is used for that. The two properties are separated into + # two extra output fields, $DECOMP_MAP and $DECOMP_TYPE. + + # This file is processed like most in this program. Control is passed to + # process_generic_property_file() which calls filter_UnicodeData_line() + # for each input line. This filter converts the input into line(s) that + # process_generic_property_file() understands. There is also a setup + # routine called before any of the file is processed, and a handler for + # EOF processing, all in this closure. + + # A huge speed-up occurred at the cost of some added complexity when these + # routines were altered to buffer the outputs into ranges. Almost all the + # lines of the input file apply to just one code point, and for most + # properties, the map for the next code point up is the same as the + # current one. So instead of creating a line for each property for each + # input line, filter_UnicodeData_line() remembers what the previous map + # of a property was, and doesn't generate a line to pass on until it has + # to, as when the map changes; and that passed-on line encompasses the + # whole contiguous range of code points that have the same map for that + # property. This means a slight amount of extra setup, and having to + # flush these buffers on EOF, testing if the maps have changed, plus + # remembering state information in the closure. But it means a lot less + # real time in not having to change the data base for each property on + # each line. + + # Another complication is that there are already a few ranges designated + # in the input. There are two lines for each, with the same maps except + # the code point and name on each line. This was actually the hardest + # thing to design around. The code points in those ranges may actually + # have real maps not given by these two lines. These maps will either + # be algorthimically determinable, or in the extracted files furnished + # with the UCD. In the event of conflicts between these extracted files, + # and this one, Unicode says that this one prevails. But it shouldn't + # prevail for conflicts that occur in these ranges. The data from the + # extracted files prevails in those cases. So, this program is structured + # so that those files are processed first, storing maps. Then the other + # files are processed, generally overwriting what the extracted files + # stored. But just the range lines in this input file are processed + # without overwriting. This is accomplished by adding a special string to + # the lines output to tell process_generic_property_file() to turn off the + # overwriting for just this one line. + # A similar mechanism is used to tell it that the map is of a non-default + # type. + + sub setup_UnicodeData { # Called before any lines of the input are read + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $Perl_decomp = Property->new('Perl_Decomposition_Mapping', + Directory => '.', + File => 'Decomposition', + Format => $STRING_FORMAT, + Internal_Only_Warning => 1, + Perl_Extension => 1, + Default_Map => $CODE_POINT, + + # This is a specially formatted table + # explicitly for normalize.pm, which + # is expecting a particular format, + # which means that mappings containing + # multiple code points are in the main + # body of the table + Map_Type => $COMPUTE_NO_MULTI_CP, + Type => $STRING, + ); + $Perl_decomp->add_comment(join_lines(<, which denotes the +compatible decomposition type. If the map does not begin with the , the decomposition is canonical. +END + )); + + my $Decimal_Digit = Property->new("Perl_Decimal_Digit", + Default_Map => "", + Perl_Extension => 1, + File => 'Digit', # Trad. location + Directory => $map_directory, + Type => $STRING, + Range_Size_1 => 1, + ); + $Decimal_Digit->add_comment(join_lines(<to_output_map) { + $last_field--; + } + return; + } + + my $first_time = 1; # ? Is this the first line of the file + my $in_range = 0; # ? Are we in one of the file's ranges + my $previous_cp; # hex code point of previous line + my $decimal_previous_cp = -1; # And its decimal equivalent + my @start; # For each field, the current starting + # code point in hex for the range + # being accumulated. + my @fields; # The input fields; + my @previous_fields; # And those from the previous call + + sub filter_UnicodeData_line { + # Handle a single input line from UnicodeData.txt; see comments above + # Conceptually this takes a single line from the file containing N + # properties, and converts it into N lines with one property per line, + # which is what the final handler expects. But there are + # complications due to the quirkiness of the input file, and to save + # time, it accumulates ranges where the property values don't change + # and only emits lines when necessary. This is about an order of + # magnitude fewer lines emitted. + + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # $_ contains the input line. + # -1 in split means retain trailing null fields + (my $cp, @fields) = split /\s*;\s*/, $_, -1; + + #local $to_trace = 1 if main::DEBUG; + trace $cp, @fields , $input_field_count if main::DEBUG && $to_trace; + if (@fields > $input_field_count) { + $file->carp_bad_line('Extra fields'); + $_ = ""; + return; + } + + my $decimal_cp = hex $cp; + + # We have to output all the buffered ranges when the next code point + # is not exactly one after the previous one, which means there is a + # gap in the ranges. + my $force_output = ($decimal_cp != $decimal_previous_cp + 1); + + # The decomposition mapping field requires special handling. It looks + # like either: + # + # 0032 0020 + # 0041 0300 + # + # The decomposition type is enclosed in ; if missing, it + # means the type is canonical. There are two decomposition mapping + # tables: the one for use by Perl's normalize.pm has a special format + # which is this field intact; the other, for general use is of + # standard format. In either case we have to find the decomposition + # type. Empty fields have None as their type, and map to the code + # point itself + if ($fields[$PERL_DECOMPOSITION] eq "") { + $fields[$DECOMP_TYPE] = 'None'; + $fields[$DECOMP_MAP] = $fields[$PERL_DECOMPOSITION] = $CODE_POINT; + } + else { + ($fields[$DECOMP_TYPE], my $map) = $fields[$PERL_DECOMPOSITION] + =~ / < ( .+? ) > \s* ( .+ ) /x; + if (! defined $fields[$DECOMP_TYPE]) { + $fields[$DECOMP_TYPE] = 'Canonical'; + $fields[$DECOMP_MAP] = $fields[$PERL_DECOMPOSITION]; + } + else { + $fields[$DECOMP_MAP] = $map; + } + } + + # The 3 numeric fields also require special handling. The 2 digit + # fields must be either empty or match the number field. This means + # that if it is empty, they must be as well, and the numeric type is + # None, and the numeric value is 'Nan'. + # The decimal digit field must be empty or match the other digit + # field. If the decimal digit field is non-empty, the code point is + # a decimal digit, and the other two fields will have the same value. + # If it is empty, but the other digit field is non-empty, the code + # point is an 'other digit', and the number field will have the same + # value as the other digit field. If the other digit field is empty, + # but the number field is non-empty, the code point is a generic + # numeric type. + if ($fields[$NUMERIC] eq "") { + if ($fields[$PERL_DECIMAL_DIGIT] ne "" + || $fields[$NUMERIC_TYPE_OTHER_DIGIT] ne "" + ) { + $file->carp_bad_line("Numeric values inconsistent. Trying to process anyway"); + } + $fields[$NUMERIC_TYPE_OTHER_DIGIT] = 'None'; + $fields[$NUMERIC] = 'NaN'; + } + else { + $file->carp_bad_line("'$fields[$NUMERIC]' should be a whole or rational number. Processing as if it were") if $fields[$NUMERIC] !~ qr{ ^ -? \d+ ( / \d+ )? $ }x; + if ($fields[$PERL_DECIMAL_DIGIT] ne "") { + $file->carp_bad_line("$fields[$PERL_DECIMAL_DIGIT] should equal $fields[$NUMERIC]. Processing anyway") if $fields[$PERL_DECIMAL_DIGIT] != $fields[$NUMERIC]; + $fields[$NUMERIC_TYPE_OTHER_DIGIT] = 'Decimal'; + } + elsif ($fields[$NUMERIC_TYPE_OTHER_DIGIT] ne "") { + $file->carp_bad_line("$fields[$NUMERIC_TYPE_OTHER_DIGIT] should equal $fields[$NUMERIC]. Processing anyway") if $fields[$NUMERIC_TYPE_OTHER_DIGIT] != $fields[$NUMERIC]; + $fields[$NUMERIC_TYPE_OTHER_DIGIT] = 'Digit'; + } + else { + $fields[$NUMERIC_TYPE_OTHER_DIGIT] = 'Numeric'; + + # Rationals require extra effort. + register_fraction($fields[$NUMERIC]) + if $fields[$NUMERIC] =~ qr{/}; + } + } + + # For the properties that have empty fields in the file, and which + # mean something different from empty, change them to that default. + # Certain fields just haven't been empty so far in any Unicode + # version, so don't look at those, namely $MIRRORED, $BIDI, $CCC, + # $CATEGORY. This leaves just the two fields, and so we hard-code in + # the defaults; which are verly unlikely to ever change. + $fields[$UPPER] = $CODE_POINT if $fields[$UPPER] eq ""; + $fields[$LOWER] = $CODE_POINT if $fields[$LOWER] eq ""; + + # UAX44 says that if title is empty, it is the same as whatever upper + # is, + $fields[$TITLE] = $fields[$UPPER] if $fields[$TITLE] eq ""; + + # There are a few pairs of lines like: + # AC00;;Lo;0;L;;;;;N;;;;; + # D7A3;;Lo;0;L;;;;;N;;;;; + # that define ranges. These should be processed after the fields are + # adjusted above, as they may override some of them; but mostly what + # is left is to possibly adjust the $NAME field. The names of all the + # paired lines start with a '<', but this is also true of ', + # which isn't one of these special ones. + if ($fields[$NAME] eq '') { + + # Some code points in this file have the pseudo-name + # '', but the official name for such ones is the null + # string. + $fields[$NAME] = ""; + + # We had better not be in between range lines. + if ($in_range) { + $file->carp_bad_line("Expecting a closing range line, not a $fields[$NAME]'. Trying anyway"); + $in_range = 0; + } + } + elsif (substr($fields[$NAME], 0, 1) ne '<') { + + # Here is a non-range line. We had better not be in between range + # lines. + if ($in_range) { + $file->carp_bad_line("Expecting a closing range line, not a $fields[$NAME]'. Trying anyway"); + $in_range = 0; + } + # XXX until charnames catches up. +# if ($fields[$NAME] =~ s/- $cp $//x) { +# +# # These are code points whose names end in their code points, +# # which means the names are algorithmically derivable from the +# # code points. To shorten the output Name file, the algorithm +# # for deriving these is placed in the file instead of each +# # code point, so they have map type $CP_IN_NAME +# $fields[$NAME] = $CMD_DELIM +# . $MAP_TYPE_CMD +# . '=' +# . $CP_IN_NAME +# . $CMD_DELIM +# . $fields[$NAME]; +# } + + # Some official names are really two alternate names with one in + # parentheses. What we do here is use the full official one for + # the standard property (stored just above), but for the charnames + # table, we add two more entries, one for each of the alternate + # ones. + # elsif name ne "" + #check_and_handle_compound_name($cp, $fields[$NAME]); + #check_and_handle_compound_name($cp, $unicode_1_name); + # XXX until charnames catches up. + } + elsif ($fields[$NAME] =~ /^<(.+), First>$/) { + $fields[$NAME] = $1; + + # Here we are at the beginning of a range pair. + if ($in_range) { + $file->carp_bad_line("Expecting a closing range line, not a beginning one, $fields[$NAME]'. Trying anyway"); + } + $in_range = 1; + + # Because the properties in the range do not overwrite any already + # in the db, we must flush the buffers of what's already there, so + # they get handled in the normal scheme. + $force_output = 1; + + } + elsif ($fields[$NAME] !~ s/^<(.+), Last>$/$1/) { + $file->carp_bad_line("Unexpected name starting with '<' $fields[$NAME]. Ignoring this line."); + $_ = ""; + return; + } + else { # Here, we are at the last line of a range pair. + + if (! $in_range) { + $file->carp_bad_line("Unexpected end of range $fields[$NAME] when not in one. Ignoring this line."); + $_ = ""; + return; + } + $in_range = 0; + + # Check that the input is valid: that the closing of the range is + # the same as the beginning. + foreach my $i (0 .. $last_field) { + next if $fields[$i] eq $previous_fields[$i]; + $file->carp_bad_line("Expecting '$fields[$i]' to be the same as '$previous_fields[$i]'. Bad News. Trying anyway"); + } + + # The processing differs depending on the type of range, + # determined by its $NAME + if ($fields[$NAME] =~ /^Hangul Syllable/) { + + # Check that the data looks right. + if ($decimal_previous_cp != $SBase) { + $file->carp_bad_line("Unexpected Hangul syllable start = $previous_cp. Bad News. Results will be wrong"); + } + if ($decimal_cp != $SBase + $SCount - 1) { + $file->carp_bad_line("Unexpected Hangul syllable end = $cp. Bad News. Results will be wrong"); + } + + # The Hangul syllable range has a somewhat complicated name + # generation algorithm. Each code point in it has a canonical + # decomposition also computable by an algorithm. The + # perl decomposition map table built from these is used only + # by normalize.pm, which has the algorithm built in it, so the + # decomposition maps are not needed, and are large, so are + # omitted from it. If the full decomposition map table is to + # be output, the decompositions are generated for it, in the + # EOF handling code for this input file. + + $previous_fields[$DECOMP_TYPE] = 'Canonical'; + + # This range is stored in our internal structure with its + # own map type, different from all others. + $previous_fields[$NAME] = $CMD_DELIM + . $MAP_TYPE_CMD + . '=' + . $HANGUL_SYLLABLE + . $CMD_DELIM + . $fields[$NAME]; + } + elsif ($fields[$NAME] =~ /^CJK/) { + + # The name for these contains the code point itself, and all + # are defined to have the same base name, regardless of what + # is in the file. They are stored in our internal structure + # with a map type of $CP_IN_NAME + $previous_fields[$NAME] = $CMD_DELIM + . $MAP_TYPE_CMD + . '=' + . $CP_IN_NAME + . $CMD_DELIM + . 'CJK UNIFIED IDEOGRAPH'; + + } + elsif ($fields[$CATEGORY] eq 'Co' + || $fields[$CATEGORY] eq 'Cs') + { + # The names of all the code points in these ranges are set to + # null, as there are no names for the private use and + # surrogate code points. + + $previous_fields[$NAME] = ""; + } + else { + $file->carp_bad_line("Unexpected code point range $fields[$NAME] because category is $fields[$CATEGORY]. Attempting to process it."); + } + + # The first line of the range caused everything else to be output, + # and then its values were stored as the beginning values for the + # next set of ranges, which this one ends. Now, for each value, + # add a command to tell the handler that these values should not + # replace any existing ones in our database. + foreach my $i (0 .. $last_field) { + $previous_fields[$i] = $CMD_DELIM + . $REPLACE_CMD + . '=' + . $NO + . $CMD_DELIM + . $previous_fields[$i]; + } + + # And change things so it looks like the entire range has been + # gone through with this being the final part of it. Adding the + # command above to each field will cause this range to be flushed + # during the next iteration, as it guaranteed that the stored + # field won't match whatever value the next one has. + $previous_cp = $cp; + $decimal_previous_cp = $decimal_cp; + + # We are now set up for the next iteration; so skip the remaining + # code in this subroutine that does the same thing, but doesn't + # know about these ranges. + $_ = ""; + return; + } + + # On the very first line, we fake it so the code below thinks there is + # nothing to output, and initialize so that when it does get output it + # uses the first line's values for the lowest part of the range. + # (One could avoid this by using peek(), but then one would need to + # know the adjustments done above and do the same ones in the setup + # routine; not worth it) + if ($first_time) { + $first_time = 0; + @previous_fields = @fields; + @start = ($cp) x scalar @fields; + $decimal_previous_cp = $decimal_cp - 1; + } + + # For each field, output the stored up ranges that this code point + # doesn't fit in. Earlier we figured out if all ranges should be + # terminated because of changing the replace or map type styles, or if + # there is a gap between this new code point and the previous one, and + # that is stored in $force_output. But even if those aren't true, we + # need to output the range if this new code point's value for the + # given property doesn't match the stored range's. + #local $to_trace = 1 if main::DEBUG; + foreach my $i (0 .. $last_field) { + my $field = $fields[$i]; + if ($force_output || $field ne $previous_fields[$i]) { + + # Flush the buffer of stored values. + $file->insert_adjusted_lines("$start[$i]..$previous_cp; $field_names[$i]; $previous_fields[$i]"); + + # Start a new range with this code point and its value + $start[$i] = $cp; + $previous_fields[$i] = $field; + } + } + + # Set the values for the next time. + $previous_cp = $cp; + $decimal_previous_cp = $decimal_cp; + + # The input line has generated whatever adjusted lines are needed, and + # should not be looked at further. + $_ = ""; + return; + } + + sub EOF_UnicodeData { + # Called upon EOF to flush the buffers, and create the Hangul + # decomposition mappings if needed. + + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # Flush the buffers. + foreach my $i (1 .. $last_field) { + $file->insert_adjusted_lines("$start[$i]..$previous_cp; $field_names[$i]; $previous_fields[$i]"); + } + + if (-e 'Jamo.txt') { + + # The algorithm is published by Unicode, based on values in + # Jamo.txt, (which should have been processed before this + # subroutine), and the results left in %Jamo + unless (%Jamo) { + Carp::my_carp_bug("Jamo.txt should be processed before Unicode.txt. Hangul syllables not generated."); + return; + } + + # If the full decomposition map table is being output, insert + # into it the Hangul syllable mappings. This is to avoid having + # to publish a subroutine in it to compute them. (which would + # essentially be this code.) This uses the algorithm published by + # Unicode. + if (property_ref('Decomposition_Mapping')->to_output_map) { + for (my $S = $SBase; $S < $SBase + $SCount; $S++) { + use integer; + my $SIndex = $S - $SBase; + my $L = $LBase + $SIndex / $NCount; + my $V = $VBase + ($SIndex % $NCount) / $TCount; + my $T = $TBase + $SIndex % $TCount; + + trace "L=$L, V=$V, T=$T" if main::DEBUG && $to_trace; + my $decomposition = sprintf("%04X %04X", $L, $V); + $decomposition .= sprintf(" %04X", $T) if $T != $TBase; + $file->insert_adjusted_lines( + sprintf("%04X; Decomposition_Mapping; %s", + $S, + $decomposition)); + } + } + } + + return; + } + + sub filter_v1_ucd { + # Fix UCD lines in version 1. This is probably overkill, but this + # fixes some glaring errors in Version 1 UnicodeData.txt. That file: + # 1) had many Hangul (U+3400 - U+4DFF) code points that were later + # removed. This program retains them + # 2) didn't include ranges, which it should have, and which are now + # added in @corrected_lines below. It was hand populated by + # taking the data from Version 2, verified by analyzing + # DAge.txt. + # 3) There is a syntax error in the entry for U+09F8 which could + # cause problems for utf8_heavy, and so is changed. It's + # numeric value was simply a minus sign, without any number. + # (Eventually Unicode changed the code point to non-numeric.) + # 4) The decomposition types often don't match later versions + # exactly, and the whole syntax of that field is different; so + # the syntax is changed as well as the types to their later + # terminology. Otherwise normalize.pm would be very unhappy + # 5) Many ccc classes are different. These are left intact. + # 6) U+FF10 - U+FF19 are missing their numeric values in all three + # fields. These are unchanged because it doesn't really cause + # problems for Perl. + # 7) A number of code points, such as controls, don't have their + # Unicode Version 1 Names in this file. These are unchanged. + + my @corrected_lines = split /\n/, <<'END'; +4E00;;Lo;0;L;;;;;N;;;;; +9FA5;;Lo;0;L;;;;;N;;;;; +E000;;Co;0;L;;;;;N;;;;; +F8FF;;Co;0;L;;;;;N;;;;; +F900;;Lo;0;L;;;;;N;;;;; +FA2D;;Lo;0;L;;;;;N;;;;; +END + + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + #local $to_trace = 1 if main::DEBUG; + trace $_ if main::DEBUG && $to_trace; + + # -1 => retain trailing null fields + my ($code_point, @fields) = split /\s*;\s*/, $_, -1; + + # At the first place that is wrong in the input, insert all the + # corrections, replacing the wrong line. + if ($code_point eq '4E00') { + my @copy = @corrected_lines; + $_ = shift @copy; + ($code_point, @fields) = split /\s*;\s*/, $_, -1; + + $file->insert_lines(@copy); + } + + + if ($fields[$NUMERIC] eq '-') { + $fields[$NUMERIC] = '-1'; # This is what 2.0 made it. + } + + if ($fields[$PERL_DECOMPOSITION] ne "") { + + # Several entries have this change to superscript 2 or 3 in the + # middle. Convert these to the modern version, which is to use + # the actual U+00B2 and U+00B3 (the superscript forms) instead. + # So 'HHHH HHHH <+sup> 0033 <-sup> HHHH' becomes + # 'HHHH HHHH 00B3 HHHH'. + # It turns out that all of these that don't have another + # decomposition defined at the beginning of the line have the + # decomposition in later releases. + if ($code_point ne '00B2' && $code_point ne '00B3') { + if ($fields[$PERL_DECOMPOSITION] + =~ s/<\+sup> 003([23]) <-sup>/00B$1/) + { + if (substr($fields[$PERL_DECOMPOSITION], 0, 1) ne '<') { + $fields[$PERL_DECOMPOSITION] = ' ' + . $fields[$PERL_DECOMPOSITION]; + } + } + } + + # If is like '<+circled> 0052 <-circled>', convert to + # ' 0052' + $fields[$PERL_DECOMPOSITION] =~ + s/ < \+ ( .*? ) > \s* (.*?) \s* <-\1> /<$1> $2/x; + + # Convert ' HHHH HHHH ' to ' HHHH HHHH', etc. + $fields[$PERL_DECOMPOSITION] =~ + s/ \s* (.*?) \s* / $1/x + or $fields[$PERL_DECOMPOSITION] =~ + s/ \s* (.*?) \s* / $1/x + or $fields[$PERL_DECOMPOSITION] =~ + s/ \s* (.*?) \s* / $1/x + or $fields[$PERL_DECOMPOSITION] =~ + s/ \s* (.*?) \s* / $1/x; + + # Convert ' HHHH HHHH ' to ' HHHH', etc. + $fields[$PERL_DECOMPOSITION] =~ + s/ <(break|no-break)> \s* (.*?) \s* <\1> /<$1> $2/x; + + # Change names to modern form. + $fields[$PERL_DECOMPOSITION] =~ s///g; + $fields[$PERL_DECOMPOSITION] =~ s///g; + $fields[$PERL_DECOMPOSITION] =~ s///g; + $fields[$PERL_DECOMPOSITION] =~ s///g; + + # One entry has weird braces + $fields[$PERL_DECOMPOSITION] =~ s/[{}]//g; + } + + $_ = join ';', $code_point, @fields; + trace $_ if main::DEBUG && $to_trace; + return; + } + + sub filter_v2_1_5_ucd { + # A dozen entries in this 2.1.5 file had the mirrored and numeric + # columns swapped; These all had mirrored be 'N'. So if the numeric + # column appears to be N, swap it back. + + my ($code_point, @fields) = split /\s*;\s*/, $_, -1; + if ($fields[$NUMERIC] eq 'N') { + $fields[$NUMERIC] = $fields[$MIRRORED]; + $fields[$MIRRORED] = 'N'; + $_ = join ';', $code_point, @fields; + } + return; + } +} # End closure for UnicodeData + +sub process_NamedSequences { + # NamedSequences.txt entries are just added to an array. Because these + # don't look like the other tables, they have their own handler. + # An example: + # LATIN CAPITAL LETTER A WITH MACRON AND GRAVE;0100 0300 + # + # This just adds the sequence to an array for later handling + + return; # XXX Until charnames catches up + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + while ($file->next_line) { + my ($name, $sequence, @remainder) = split /\s*;\s*/, $_, -1; + if (@remainder) { + $file->carp_bad_line( + "Doesn't look like 'KHMER VOWEL SIGN OM;17BB 17C6'"); + next; + } + push @named_sequences, "$sequence\t\t$name"; + } + return; +} + +{ # Closure + + my $first_range; + + sub filter_early_ea_lb { + # Fixes early EastAsianWidth.txt and LineBreak.txt files. These had a + # third field be the name of the code point, which can be ignored in + # most cases. But it can be meaningful if it marks a range: + # 33FE;W;IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY-ONE + # 3400;W; + # + # We need to see the First in the example above to know it's a range. + # They did not use the later range syntaxes. This routine changes it + # to use the modern syntax. + # $1 is the Input_file object. + + my @fields = split /\s*;\s*/; + if ($fields[2] =~ /^<.*, First>/) { + $first_range = $fields[0]; + $_ = ""; + } + elsif ($fields[2] =~ /^<.*, Last>/) { + $_ = $_ = "$first_range..$fields[0]; $fields[1]"; + } + else { + undef $first_range; + $_ = "$fields[0]; $fields[1]"; + } + + return; + } +} + +sub filter_old_style_arabic_shaping { + # Early versions used a different term for the later one. + + my @fields = split /\s*;\s*/; + $fields[3] =~ s//No_Joining_Group/; + $fields[3] =~ s/\s+/_/g; # Change spaces to underscores + $_ = join ';', @fields; + return; +} + +sub filter_arabic_shaping_line { + # ArabicShaping.txt has entries that look like: + # 062A; TEH; D; BEH + # The field containing 'TEH' is not used. The next field is Joining_Type + # and the last is Joining_Group + # This generates two lines to pass on, one for each property on the input + # line. + + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my @fields = split /\s*;\s*/, $_, -1; # -1 => retain trailing null fields + + if (@fields > 4) { + $file->carp_bad_line('Extra fields'); + $_ = ""; + return; + } + + $file->insert_adjusted_lines("$fields[0]; Joining_Group; $fields[3]"); + $_ = "$fields[0]; Joining_Type; $fields[2]"; + + return; +} + +sub setup_special_casing { + # SpecialCasing.txt contains the non-simple case change mappings. The + # simple ones are in UnicodeData.txt, and should already have been read + # in. + # This routine initializes the full mappings to the simple, then as each + # line is processed, it overrides the simple ones. + + my $file= shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # For each of the case change mappings... + foreach my $case ('lc', 'tc', 'uc') { + + # The simple version's name in each mapping merely has an 's' in front + # of the full one's + my $simple = property_ref('s' . $case); + unless (defined $simple && ! $simple->is_empty) { + Carp::my_carp_bug("Need to process UnicodeData before SpecialCasing. Only special casing will be generated."); + } + + # Initialize the full case mappings with the simple ones. + property_ref($case)->initialize($simple); + } + + return; +} + +sub filter_special_casing_line { + # Change the format of $_ from SpecialCasing.txt into something that the + # generic handler understands. Each input line contains three case + # mappings. This will generate three lines to pass to the generic handler + # for each of those. + + # The input syntax (after stripping comments and trailing white space is + # like one of the following (with the final two being entries that we + # ignore): + # 00DF; 00DF; 0053 0073; 0053 0053; # LATIN SMALL LETTER SHARP S + # 03A3; 03C2; 03A3; 03A3; Final_Sigma; + # 0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE + # Note the trailing semi-colon, unlike many of the input files. That + # means that there will be an extra null field generated by the split + + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my @fields = split /\s*;\s*/, $_, -1; # -1 => retain trailing null fields + + # field #4 is when this mapping is conditional. If any of these get + # implemented, it would be by hard-coding in the casing functions in the + # Perl core, not through tables. But if there is a new condition we don't + # know about, output a warning. We know about all the conditions through + # 5.2 + if ($fields[4] ne "") { + my @conditions = split ' ', $fields[4]; + if ($conditions[0] ne 'tr' # We know that these languages have + # conditions, and some are multiple + && $conditions[0] ne 'az' + && $conditions[0] ne 'lt' + + # And, we know about a single condition Final_Sigma, but + # nothing else. + && ($v_version gt v5.2.0 + && (@conditions > 1 || $conditions[0] ne 'Final_Sigma'))) + { + $file->carp_bad_line("Unknown condition '$fields[4]'. You should inspect it and either add code to handle it, or add to list of those that are to ignore"); + } + elsif ($conditions[0] ne 'Final_Sigma') { + + # Don't print out a message for Final_Sigma, because we have + # hard-coded handling for it. (But the standard could change + # what the rule should be, but it wouldn't show up here + # anyway. + + print "# SKIPPING Special Casing: $_\n" + if $verbosity >= $VERBOSE; + } + $_ = ""; + return; + } + elsif (@fields > 6 || (@fields == 6 && $fields[5] ne "" )) { + $file->carp_bad_line('Extra fields'); + $_ = ""; + return; + } + + $_ = "$fields[0]; lc; $fields[1]"; + $file->insert_adjusted_lines("$fields[0]; tc; $fields[2]"); + $file->insert_adjusted_lines("$fields[0]; uc; $fields[3]"); + + return; +} + +sub filter_old_style_case_folding { + # This transforms $_ containing the case folding style of 3.0.1, to 3.1 + # and later style, then calls the handler for the later style. Different + # letters were used. + + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my @fields = split /\s*;\s*/; + if ($fields[0] =~ /^ 013 [01] $/x) { # The two turkish fields + $fields[1] = 'I'; + } + elsif ($fields[1] eq 'L') { + $fields[1] = 'C'; # L => C always + } + elsif ($fields[1] eq 'E') { + if ($fields[2] =~ / /) { # E => C if one code point; F otherwise + $fields[1] = 'F' + } + else { + $fields[1] = 'C' + } + } + else { + $file->carp_bad_line("Expecting L or E in second field"); + $_ = ""; + return; + } + $_ = join("; ", @fields) . ';'; + return; +} + +{ # Closure for case folding + + # Create the map for simple only if are going to output it, for otherwise + # it takes no part in anything we do. + my $to_output_simple; + + # These are experimental, perhaps will need these to pass to regcomp.c to + # handle the cases where for example the Kelvin sign character folds to k, + # and in regcomp, we need to know which of the characters can have a + # non-latin1 char fold to it, so it doesn't do the optimizations it might + # otherwise. + my @latin1_singly_folded; + my @latin1_folded; + + sub setup_case_folding($) { + # Read in the case foldings in CaseFolding.txt. This handles both + # simple and full case folding. + + $to_output_simple + = property_ref('Simple_Case_Folding')->to_output_map; + + return; + } + + sub filter_case_folding_line { + # Called for each line in CaseFolding.txt + # Input lines look like: + # 0041; C; 0061; # LATIN CAPITAL LETTER A + # 00DF; F; 0073 0073; # LATIN SMALL LETTER SHARP S + # 1E9E; S; 00DF; # LATIN CAPITAL LETTER SHARP S + # + # 'C' means that folding is the same for both simple and full + # 'F' that it is only for full folding + # 'S' that it is only for simple folding + # 'T' is locale-dependent, and ignored + # 'I' is a type of 'F' used in some early releases. + # Note the trailing semi-colon, unlike many of the input files. That + # means that there will be an extra null field generated by the split + # below, which we ignore and hence is not an error. + + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my ($range, $type, $map, @remainder) = split /\s*;\s*/, $_, -1; + if (@remainder > 1 || (@remainder == 1 && $remainder[0] ne "" )) { + $file->carp_bad_line('Extra fields'); + $_ = ""; + return; + } + + if ($type eq 'T') { # Skip Turkic case folding, is locale dependent + $_ = ""; + return; + } + + # C: complete, F: full, or I: dotted uppercase I -> dotless lowercase + # I are all full foldings + if ($type eq 'C' || $type eq 'F' || $type eq 'I') { + $_ = "$range; Case_Folding; $map"; + } + else { + $_ = ""; + if ($type ne 'S') { + $file->carp_bad_line('Expecting C F I S or T in second field'); + return; + } + } + + # C and S are simple foldings, but simple case folding is not needed + # unless we explicitly want its map table output. + if ($to_output_simple && $type eq 'C' || $type eq 'S') { + $file->insert_adjusted_lines("$range; Simple_Case_Folding; $map"); + } + + # Experimental, see comment above + if ($type ne 'S' && hex($range) >= 256) { # assumes range is 1 point + my @folded = split ' ', $map; + if (hex $folded[0] < 256 && @folded == 1) { + push @latin1_singly_folded, hex $folded[0]; + } + foreach my $folded (@folded) { + push @latin1_folded, hex $folded if hex $folded < 256; + } + } + + return; + } + + sub post_fold { + # Experimental, see comment above + return; + + #local $to_trace = 1 if main::DEBUG; + @latin1_singly_folded = uniques(@latin1_singly_folded); + @latin1_folded = uniques(@latin1_folded); + trace "latin1 single folded:", map { chr $_ } sort { $a <=> $b } @latin1_singly_folded if main::DEBUG && $to_trace; + trace "latin1 folded:", map { chr $_ } sort { $a <=> $b } @latin1_folded if main::DEBUG && $to_trace; + return; + } +} # End case fold closure + +sub filter_jamo_line { + # Filter Jamo.txt lines. This routine mainly is used to populate hashes + # from this file that is used in generating the Name property for Jamo + # code points. But, it also is used to convert early versions' syntax + # into the modern form. Here are two examples: + # 1100; G # HANGUL CHOSEONG KIYEOK # Modern syntax + # U+1100; G; HANGUL CHOSEONG KIYEOK # 2.0 syntax + # + # The input is $_, the output is $_ filtered. + + my @fields = split /\s*;\s*/, $_, -1; # -1 => retain trailing null fields + + # Let the caller handle unexpected input. In earlier versions, there was + # a third field which is supposed to be a comment, but did not have a '#' + # before it. + return if @fields > (($v_version gt v3.0.0) ? 2 : 3); + + $fields[0] =~ s/^U\+//; # Also, early versions had this extraneous + # beginning. + + # Some 2.1 versions had this wrong. Causes havoc with the algorithm. + $fields[1] = 'R' if $fields[0] eq '1105'; + + # Add to structure so can generate Names from it. + my $cp = hex $fields[0]; + my $short_name = $fields[1]; + $Jamo{$cp} = $short_name; + if ($cp <= $LBase + $LCount) { + $Jamo_L{$short_name} = $cp - $LBase; + } + elsif ($cp <= $VBase + $VCount) { + $Jamo_V{$short_name} = $cp - $VBase; + } + elsif ($cp <= $TBase + $TCount) { + $Jamo_T{$short_name} = $cp - $TBase; + } + else { + Carp::my_carp_bug("Unexpected Jamo code point in $_"); + } + + + # Reassemble using just the first two fields to look like a typical + # property file line + $_ = "$fields[0]; $fields[1]"; + + return; +} + +sub filter_numeric_value_comment_missing_line { + # Filters out the extra column in DNumValues.txt of this line + + s/^($missing_defaults_prefix)\s*;\s*/$1/; + return; +} + +sub register_fraction($) { + # This registers the input rational number so that it can be passed on to + # utf8_heavy.pl, both in rational and floating forms. + + my $rational = shift; + + my $float = eval $rational; + $nv_floating_to_rational{$float} = $rational; + return; +} + +sub filter_numeric_value_line { + # DNumValues contains lines of a different syntax than the typical + # property file: + # 0F33 ; -0.5 ; ; -1/2 # No TIBETAN DIGIT HALF ZERO + # + # This routine transforms $_ containing the anomalous syntax to the + # typical, by filtering out the extra columns, and convert early version + # decimal numbers to strings that look like rational numbers. + + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # Starting in 5.1, there is a rational field. Just use that, omitting the + # extra columns. Otherwise convert the decimal number in the second field + # to a rational, and omit extraneous columns. + my @fields = split /\s*;\s*/, $_, -1; + my $rational; + + if ($v_version ge v5.1.0) { + if (@fields != 4) { + $file->carp_bad_line('Not 4 semi-colon separated fields'); + $_ = ""; + return; + } + $rational = $fields[3]; + $_ = join '; ', @fields[ 0, 3 ]; + } + else { + + # Here, is an older Unicode file, which has decimal numbers instead of + # rationals in it. Use the fraction to calculate the denominator and + # convert to rational. + + if (@fields != 2 && @fields != 3) { + $file->carp_bad_line('Not 2 or 3 semi-colon separated fields'); + $_ = ""; + return; + } + + my $codepoints = $fields[0]; + my $decimal = $fields[1]; + if ($decimal =~ s/\.0+$//) { + + # Anything ending with a decimal followed by nothing but 0's is an + # integer + $_ = "$codepoints; $decimal"; + $rational = $decimal; + } + else { + + my $denominator; + if ($decimal =~ /\.50*$/) { + $denominator = 2; + } + + # Here have the hardcoded repeating decimals in the fraction, and + # the denominator they imply. There were only a few denominators + # in the older Unicode versions of this file which this code + # handles, so it is easy to convert them. + + # The 4 is because of a round-off error in the Unicode 3.2 files + elsif ($decimal =~ /\.33*[34]$/ || $decimal =~ /\.6+7$/) { + $denominator = 3; + } + elsif ($decimal =~ /\.[27]50*$/) { + $denominator = 4; + } + elsif ($decimal =~ /\.[2468]0*$/) { + $denominator = 5; + } + elsif ($decimal =~ /\.16+7$/ || $decimal =~ /\.83+$/) { + $denominator = 6; + } + elsif ($decimal =~ /\.(12|37|62|87)50*$/) { + $denominator = 8; + } + if ($denominator) { + my $sign = ($decimal < 0) ? "-" : ""; + my $numerator = int((abs($decimal) * $denominator) + .5); + $rational = "$sign$numerator/$denominator"; + $_ = "$codepoints; $rational"; + } + else { + $file->carp_bad_line("Can't cope with number '$decimal'."); + $_ = ""; + return; + } + } + } + + register_fraction($rational) if $rational =~ qr{/}; + return; +} + +{ # Closure + my %unihan_properties; + my $iicore; + + + sub setup_unihan { + # Do any special setup for Unihan properties. + + # This property gives the wrong computed type, so override. + my $usource = property_ref('kIRG_USource'); + $usource->set_type($STRING) if defined $usource; + + # This property is to be considered binary, so change all the values + # to Y. + $iicore = property_ref('kIICore'); + if (defined $iicore) { + $iicore->add_match_table('Y') if ! defined $iicore->table('Y'); + + # We have to change the default map, because the @missing line is + # misleading, given that we are treating it as binary. + $iicore->set_default_map('N'); + $iicore->set_type($BINARY); + } + + return; + } + + sub filter_unihan_line { + # Change unihan db lines to look like the others in the db. Here is + # an input sample: + # U+341C kCangjie IEKN + + # Tabs are used instead of semi-colons to separate fields; therefore + # they may have semi-colons embedded in them. Change these to periods + # so won't screw up the rest of the code. + s/;/./g; + + # Remove lines that don't look like ones we accept. + if ($_ !~ /^ [^\t]* \t ( [^\t]* ) /x) { + $_ = ""; + return; + } + + # Extract the property, and save a reference to its object. + my $property = $1; + if (! exists $unihan_properties{$property}) { + $unihan_properties{$property} = property_ref($property); + } + + # Don't do anything unless the property is one we're handling, which + # we determine by seeing if there is an object defined for it or not + if (! defined $unihan_properties{$property}) { + $_ = ""; + return; + } + + # The iicore property is supposed to be a boolean, so convert to our + # standard boolean form. + if (defined $iicore && $unihan_properties{$property} == $iicore) { + $_ =~ s/$property.*/$property\tY/ + } + + # Convert the tab separators to our standard semi-colons, and convert + # the U+HHHH notation to the rest of the standard's HHHH + s/\t/;/g; + s/\b U \+ (?= $code_point_re )//xg; + + #local $to_trace = 1 if main::DEBUG; + trace $_ if main::DEBUG && $to_trace; + + return; + } +} + +sub filter_blocks_lines { + # In the Blocks.txt file, the names of the blocks don't quite match the + # names given in PropertyValueAliases.txt, so this changes them so they + # do match: Blanks and hyphens are changed into underscores. Also makes + # early release versions look like later ones + # + # $_ is transformed to the correct value. + + my $file = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + if ($v_version lt v3.2.0) { + if (/FEFF.*Specials/) { # Bug in old versions: line wrongly inserted + $_ = ""; + return; + } + + # Old versions used a different syntax to mark the range. + $_ =~ s/;\s+/../ if $v_version lt v3.1.0; + } + + my @fields = split /\s*;\s*/, $_, -1; + if (@fields != 2) { + $file->carp_bad_line("Expecting exactly two fields"); + $_ = ""; + return; + } + + # Change hyphens and blanks in the block name field only + $fields[1] =~ s/[ -]/_/g; + $fields[1] =~ s/_ ( [a-z] ) /_\u$1/g; # Capitalize first letter of word + + $_ = join("; ", @fields); + return; +} + +{ # Closure + my $current_property; + + sub filter_old_style_proplist { + # PropList.txt has been in Unicode since version 2.0. Until 3.1, it + # was in a completely different syntax. Ken Whistler of Unicode says + # that it was something he used as an aid for his own purposes, but + # was never an official part of the standard. However, comments in + # DAge.txt indicate that non-character code points were available in + # the UCD as of 3.1. It is unclear to me (khw) how they could be + # there except through this file (but on the other hand, they first + # appeared there in 3.0.1), so maybe it was part of the UCD, and maybe + # not. But the claim is that it was published as an aid to others who + # might want some more information than was given in the official UCD + # of the time. Many of the properties in it were incorporated into + # the later PropList.txt, but some were not. This program uses this + # early file to generate property tables that are otherwise not + # accessible in the early UCD's, and most were probably not really + # official at that time, so one could argue that it should be ignored, + # and you can easily modify things to skip this. And there are bugs + # in this file in various versions. (For example, the 2.1.9 version + # removes from Alphabetic the CJK range starting at 4E00, and they + # weren't added back in until 3.1.0.) Many of this file's properties + # were later sanctioned, so this code generates tables for those + # properties that aren't otherwise in the UCD of the time but + # eventually did become official, and throws away the rest. Here is a + # list of all the ones that are thrown away: + # Bidi=* duplicates UnicodeData.txt + # Combining never made into official property; + # is \P{ccc=0} + # Composite never made into official property. + # Currency Symbol duplicates UnicodeData.txt: gc=sc + # Decimal Digit duplicates UnicodeData.txt: gc=nd + # Delimiter never made into official property; + # removed in 3.0.1 + # Format Control never made into official property; + # similar to gc=cf + # High Surrogate duplicates Blocks.txt + # Ignorable Control never made into official property; + # similar to di=y + # ISO Control duplicates UnicodeData.txt: gc=cc + # Left of Pair never made into official property; + # Line Separator duplicates UnicodeData.txt: gc=zl + # Low Surrogate duplicates Blocks.txt + # Non-break was actually listed as a property + # in 3.2, but without any code + # points. Unicode denies that this + # was ever an official property + # Non-spacing duplicate UnicodeData.txt: gc=mn + # Numeric duplicates UnicodeData.txt: gc=cc + # Paired Punctuation never made into official property; + # appears to be gc=ps + gc=pe + # Paragraph Separator duplicates UnicodeData.txt: gc=cc + # Private Use duplicates UnicodeData.txt: gc=co + # Private Use High Surrogate duplicates Blocks.txt + # Punctuation duplicates UnicodeData.txt: gc=p + # Space different definition than eventual + # one. + # Titlecase duplicates UnicodeData.txt: gc=lt + # Unassigned Code Value duplicates UnicodeData.txt: gc=cc + # Zero-width never made into offical property; + # subset of gc=cf + # Most of the properties have the same names in this file as in later + # versions, but a couple do not. + # + # This subroutine filters $_, converting it from the old style into + # the new style. Here's a sample of the old-style + # + # ******************************************* + # + # Property dump for: 0x100000A0 (Join Control) + # + # 200C..200D (2 chars) + # + # In the example, the property is "Join Control". It is kept in this + # closure between calls to the subroutine. The numbers beginning with + # 0x were internal to Ken's program that generated this file. + + # If this line contains the property name, extract it. + if (/^Property dump for: [^(]*\((.*)\)/) { + $_ = $1; + + # Convert white space to underscores. + s/ /_/g; + + # Convert the few properties that don't have the same name as + # their modern counterparts + s/Identifier_Part/ID_Continue/ + or s/Not_a_Character/NChar/; + + # If the name matches an existing property, use it. + if (defined property_ref($_)) { + trace "new property=", $_ if main::DEBUG && $to_trace; + $current_property = $_; + } + else { # Otherwise discard it + trace "rejected property=", $_ if main::DEBUG && $to_trace; + undef $current_property; + } + $_ = ""; # The property is saved for the next lines of the + # file, but this defining line is of no further use, + # so clear it so that the caller won't process it + # further. + } + elsif (! defined $current_property || $_ !~ /^$code_point_re/) { + + # Here, the input line isn't a header defining a property for the + # following section, and either we aren't in such a section, or + # the line doesn't look like one that defines the code points in + # such a section. Ignore this line. + $_ = ""; + } + else { + + # Here, we have a line defining the code points for the current + # stashed property. Anything starting with the first blank is + # extraneous. Otherwise, it should look like a normal range to + # the caller. Append the property name so that it looks just like + # a modern PropList entry. + + $_ =~ s/\s.*//; + $_ .= "; $current_property"; + } + trace $_ if main::DEBUG && $to_trace; + return; + } +} # End closure for old style proplist + +sub filter_old_style_normalization_lines { + # For early releases of Unicode, the lines were like: + # 74..2A76 ; NFKD_NO + # For later releases this became: + # 74..2A76 ; NFKD_QC; N + # Filter $_ to look like those in later releases. + # Similarly for MAYBEs + + s/ _NO \b /_QC; N/x || s/ _MAYBE \b /_QC; M/x; + + # Also, the property FC_NFKC was abbreviated to FNC + s/FNC/FC_NFKC/; + return; +} + +sub finish_Unicode() { + # This routine should be called after all the Unicode files have been read + # in. It: + # 1) Adds the mappings for code points missing from the files which have + # defaults specified for them. + # 2) At this this point all mappings are known, so it computes the type of + # each property whose type hasn't been determined yet. + # 3) Calculates all the regular expression match tables based on the + # mappings. + # 3) Calculates and adds the tables which are defined by Unicode, but + # which aren't derived by them + + # For each property, fill in any missing mappings, and calculate the re + # match tables. If a property has more than one missing mapping, the + # default is a reference to a data structure, and requires data from other + # properties to resolve. The sort is used to cause these to be processed + # last, after all the other properties have been calculated. + # (Fortunately, the missing properties so far don't depend on each other.) + foreach my $property + (sort { (defined $a->default_map && ref $a->default_map) ? 1 : -1 } + property_ref('*')) + { + # $perl has been defined, but isn't one of the Unicode properties that + # need to be finished up. + next if $property == $perl; + + # Handle the properties that have more than one possible default + if (ref $property->default_map) { + my $default_map = $property->default_map; + + # These properties have stored in the default_map: + # One or more of: + # 1) A default map which applies to all code points in a + # certain class + # 2) an expression which will evaluate to the list of code + # points in that class + # And + # 3) the default map which applies to every other missing code + # point. + # + # Go through each list. + while (my ($default, $eval) = $default_map->get_next_defaults) { + + # Get the class list, and intersect it with all the so-far + # unspecified code points yielding all the code points + # in the class that haven't been specified. + my $list = eval $eval; + if ($@) { + Carp::my_carp("Can't set some defaults for missing code points for $property because eval '$eval' failed with '$@'"); + last; + } + + # Narrow down the list to just those code points we don't have + # maps for yet. + $list = $list & $property->inverse_list; + + # Add mappings to the property for each code point in the list + foreach my $range ($list->ranges) { + $property->add_map($range->start, $range->end, $default); + } + } + + # All remaining code points have the other mapping. Set that up + # so the normal single-default mapping code will work on them + $property->set_default_map($default_map->other_default); + + # And fall through to do that + } + + # We should have enough data now to compute the type of the property. + $property->compute_type; + my $property_type = $property->type; + + next if ! $property->to_create_match_tables; + + # Here want to create match tables for this property + + # The Unicode db always (so far, and they claim into the future) have + # the default for missing entries in binary properties be 'N' (unless + # there is a '@missing' line that specifies otherwise) + if ($property_type == $BINARY && ! defined $property->default_map) { + $property->set_default_map('N'); + } + + # Add any remaining code points to the mapping, using the default for + # missing code points + if (defined (my $default_map = $property->default_map)) { + foreach my $range ($property->inverse_list->ranges) { + $property->add_map($range->start, $range->end, $default_map); + } + + # Make sure there is a match table for the default + if (! defined $property->table($default_map)) { + $property->add_match_table($default_map); + } + } + + # Have all we need to populate the match tables. + my $property_name = $property->name; + foreach my $range ($property->ranges) { + my $map = $range->value; + my $table = property_ref($property_name)->table($map); + if (! defined $table) { + + # Integral and rational property values are not necessarily + # defined in PropValueAliases, but all other ones should be, + # starting in 5.1 + if ($v_version ge v5.1.0 + && $map !~ /^ -? \d+ ( \/ \d+ )? $/x) + { + Carp::my_carp("Table '$property_name=$map' should have been defined. Defining it now.") + } + $table = property_ref($property_name)->add_match_table($map); + } + + $table->add_range($range->start, $range->end); + } + + # And add the Is_ prefix synonyms for Perl 5.6 compatibility, in which + # all properties have this optional prefix. These do not get a + # separate entry in the pod file, because are covered by a wild-card + # entry + foreach my $alias ($property->aliases) { + my $Is_name = 'Is_' . $alias->name; + if (! defined (my $pre_existing = property_ref($Is_name))) { + $property->add_alias($Is_name, + Pod_Entry => 0, + Status => $alias->status, + Externally_Ok => 0); + } + else { + + # It seemed too much work to add in these warnings when it + # appears that Unicode has made a decision never to begin a + # property name with 'Is_', so this shouldn't happen, but just + # in case, it is a warning. + Carp::my_carp(<tables) { + my $minor_name = $minor_table->name; + next if length $minor_name == 1; + if (length $minor_name != 2) { + Carp::my_carp_bug("Unexpected general category '$minor_name'. Skipped."); + next; + } + + my $major_name = uc(substr($minor_name, 0, 1)); + my $major_table = $gc->table($major_name); + $major_table += $minor_table; + } + + # LC is Ll, Lu, and Lt. (used to be L& or L_, but PropValueAliases.txt + # defines it as LC) + my $LC = $gc->table('LC'); + $LC->add_alias('L_', Status => $DISCOURAGED); # For backwards... + $LC->add_alias('L&', Status => $DISCOURAGED); # compatibility. + + + if ($LC->is_empty) { # Assume if not empty that Unicode has started to + # deliver the correct values in it + $LC->initialize($gc->table('Ll') + $gc->table('Lu')); + + # Lt not in release 1. + $LC += $gc->table('Lt') if defined $gc->table('Lt'); + } + $LC->add_description('[\p{Ll}\p{Lu}\p{Lt}]'); + + my $Cs = $gc->table('Cs'); + if (defined $Cs) { + $Cs->add_note('Mostly not usable in Perl.'); + $Cs->add_comment(join_lines(<is_empty) { + $fold->initialize(property_ref('Simple_Lowercase_Mapping')); + $fold->add_note(join_lines(<is_empty) { + my $simple = property_ref('Simple_' . $map); + $full->initialize($simple); + $full->add_comment($simple->comment) if ($simple->comment); + $full->add_note(join_lines(<add_match_table('Any', + Description => "[\\x{0000}-\\x{$LAST_UNICODE_CODEPOINT_STRING}]", + Matches_All => 1); + + foreach my $major_table ($gc->tables) { + + # Major categories are the ones with single letter names. + next if length($major_table->name) != 1; + + $Any += $major_table; + } + + if ($Any->max != $LAST_UNICODE_CODEPOINT) { + Carp::my_carp_bug("Generated highest code point (" + . sprintf("%X", $Any->max) + . ") doesn't match expected value $LAST_UNICODE_CODEPOINT_STRING.") + } + if ($Any->range_count != 1 || $Any->min != 0) { + Carp::my_carp_bug("Generated table 'Any' doesn't match all code points.") + } + + $Any->add_alias('All'); + + # Assigned is the opposite of gc=unassigned + my $Assigned = $perl->add_match_table('Assigned', + Description => "All assigned code points", + Initialize => ~ $gc->table('Unassigned'), + ); + + # Our internal-only property should be treated as more than just a + # synonym. + $perl->add_match_table('_CombAbove') + ->set_equivalent_to(property_ref('ccc')->table('Above'), + Related => 1); + + my $ASCII = $perl->add_match_table('ASCII', Description => '[[:ASCII:]]'); + if (defined $block) { # This is equivalent to the block if have it. + my $Unicode_ASCII = $block->table('Basic_Latin'); + if (defined $Unicode_ASCII && ! $Unicode_ASCII->is_empty) { + $ASCII->set_equivalent_to($Unicode_ASCII, Related => 1); + } + } + + # Very early releases didn't have blocks, so initialize ASCII ourselves if + # necessary + if ($ASCII->is_empty) { + $ASCII->initialize([ 0..127 ]); + } + + # A number of the Perl synonyms have a restricted-range synonym whose name + # begins with Posix. This hash gets filled in with them, so that they can + # be populated in a small loop. + my %posix_equivalent; + + # Get the best available case definitions. Early Unicode versions didn't + # have Uppercase and Lowercase defined, so use the general category + # instead for them. + my $Lower = $perl->add_match_table('Lower'); + my $Unicode_Lower = property_ref('Lowercase'); + if (defined $Unicode_Lower && ! $Unicode_Lower->is_empty) { + $Lower->set_equivalent_to($Unicode_Lower->table('Y'), Related => 1); + } + else { + $Lower->set_equivalent_to($gc->table('Lowercase_Letter'), + Related => 1); + } + $posix_equivalent{'Lower'} = $Lower; + + my $Upper = $perl->add_match_table('Upper'); + my $Unicode_Upper = property_ref('Uppercase'); + if (defined $Unicode_Upper && ! $Unicode_Upper->is_empty) { + $Upper->set_equivalent_to($Unicode_Upper->table('Y'), Related => 1); + } + else { + $Upper->set_equivalent_to($gc->table('Uppercase_Letter'), + Related => 1); + } + $posix_equivalent{'Upper'} = $Upper; + + # Earliest releases didn't have title case. Initialize it to empty if not + # otherwise present + my $Title = $perl->add_match_table('Title'); + my $lt = $gc->table('Lt'); + if (defined $lt) { + $Title->set_equivalent_to($lt, Related => 1); + } + + # If this Unicode version doesn't have Cased, set up our own. From + # Unicode 5.1: Definition D120: A character C is defined to be cased if + # and only if C has the Lowercase or Uppercase property or has a + # General_Category value of Titlecase_Letter. + unless (defined property_ref('Cased')) { + my $cased = $perl->add_match_table('Cased', + Initialize => $Lower + $Upper + $Title, + Description => 'Uppercase or Lowercase or Titlecase', + ); + } + + # Similarly, set up our own Case_Ignorable property if this Unicode + # version doesn't have it. From Unicode 5.1: Definition D121: A character + # C is defined to be case-ignorable if C has the value MidLetter or the + # value MidNumLet for the Word_Break property or its General_Category is + # one of Nonspacing_Mark (Mn), Enclosing_Mark (Me), Format (Cf), + # Modifier_Letter (Lm), or Modifier_Symbol (Sk). + + # Perl has long had an internal-only alias for this property. + my $perl_case_ignorable = $perl->add_match_table('_Case_Ignorable'); + my $case_ignorable = property_ref('Case_Ignorable'); + if (defined $case_ignorable && ! $case_ignorable->is_empty) { + $perl_case_ignorable->set_equivalent_to($case_ignorable->table('Y'), + Related => 1); + } + else { + + $perl_case_ignorable->initialize($gc->table('Mn') + $gc->table('Lm')); + + # The following three properties are not in early releases + $perl_case_ignorable += $gc->table('Me') if defined $gc->table('Me'); + $perl_case_ignorable += $gc->table('Cf') if defined $gc->table('Cf'); + $perl_case_ignorable += $gc->table('Sk') if defined $gc->table('Sk'); + + # For versions 4.1 - 5.0, there is no MidNumLet property, and + # correspondingly the case-ignorable definition lacks that one. For + # 4.0, it appears that it was meant to be the same definition, but was + # inadvertently omitted from the standard's text, so add it if the + # property actually is there + my $wb = property_ref('Word_Break'); + if (defined $wb) { + my $midlet = $wb->table('MidLetter'); + $perl_case_ignorable += $midlet if defined $midlet; + my $midnumlet = $wb->table('MidNumLet'); + $perl_case_ignorable += $midnumlet if defined $midnumlet; + } + else { + + # In earlier versions of the standard, instead of the above two + # properties , just the following characters were used: + $perl_case_ignorable += 0x0027 # APOSTROPHE + + 0x00AD # SOFT HYPHEN (SHY) + + 0x2019; # RIGHT SINGLE QUOTATION MARK + } + } + + # The remaining perl defined tables are mostly based on Unicode TR 18, + # "Annex C: Compatibility Properties". All of these have two versions, + # one whose name generally begins with Posix that is posix-compliant, and + # one that matches Unicode characters beyond the Posix, ASCII range + + my $Alpha = $perl->add_match_table('Alpha', + Description => '[[:Alpha:]] extended beyond ASCII'); + + # Alphabetic was not present in early releases + my $Alphabetic = property_ref('Alphabetic'); + if (defined $Alphabetic && ! $Alphabetic->is_empty) { + $Alpha->set_equivalent_to($Alphabetic->table('Y'), Related => 1); + } + else { + + # For early releases, we don't get it exactly right. The below + # includes more than it should, which in 5.2 terms is: L + Nl + + # Other_Alphabetic. Other_Alphabetic contains many characters from + # Mn and Mc. It's better to match more than we should, than less than + # we should. + $Alpha->initialize($gc->table('Letter') + + $gc->table('Mn') + + $gc->table('Mc')); + $Alpha += $gc->table('Nl') if defined $gc->table('Nl'); + } + $posix_equivalent{'Alpha'} = $Alpha; + + my $Alnum = $perl->add_match_table('Alnum', + Description => "[[:Alnum:]] extended beyond ASCII", + Initialize => $Alpha + $gc->table('Decimal_Number'), + ); + $posix_equivalent{'Alnum'} = $Alnum; + + my $Word = $perl->add_match_table('Word', + Description => '\w, including beyond ASCII', + Initialize => $Alnum + $gc->table('Mark'), + ); + my $Pc = $gc->table('Connector_Punctuation'); # 'Pc' Not in release 1 + $Word += $Pc if defined $Pc; + + # There is no [[:Word:]], so the name doesn't begin with Posix. + $perl->add_match_table('PerlWord', + Description => '\w, restricted to ASCII = [A-Za-z0-9_]', + Initialize => $Word & $ASCII, + ); + + my $Blank = $perl->add_match_table('Blank', + Description => '\h, Horizontal white space', + + # 200B is Zero Width Space which is for line + # break control, and was listed as + # Space_Separator in early releases + Initialize => $gc->table('Space_Separator') + + 0x0009 # TAB + - 0x200B, # ZWSP + ); + $Blank->add_alias('HorizSpace'); # Another name for it. + $posix_equivalent{'Blank'} = $Blank; + + my $VertSpace = $perl->add_match_table('VertSpace', + Description => '\v', + Initialize => $gc->table('Line_Separator') + + $gc->table('Paragraph_Separator') + + 0x000A # LINE FEED + + 0x000B # VERTICAL TAB + + 0x000C # FORM FEED + + 0x000D # CARRIAGE RETURN + + 0x0085, # NEL + ); + # No Posix equivalent for vertical space + + my $Space = $perl->add_match_table('Space', + Description => '\s including beyond ASCII plus vertical tab = [[:Space:]]', + Initialize => $Blank + $VertSpace, + ); + $posix_equivalent{'Space'} = $Space; + + # Perl's traditional space doesn't include Vertical Tab + my $SpacePerl = $perl->add_match_table('SpacePerl', + Description => '\s, including beyond ASCII', + Initialize => $Space - 0x000B, + ); + $perl->add_match_table('PerlSpace', + Description => '\s, restricted to ASCII', + Initialize => $SpacePerl & $ASCII, + ); + + my $Cntrl = $perl->add_match_table('Cntrl', + Description => "[[:Cntrl:]] extended beyond ASCII"); + $Cntrl->set_equivalent_to($gc->table('Cc'), Related => 1); + $posix_equivalent{'Cntrl'} = $Cntrl; + + # $controls is a temporary used to construct Graph. + my $controls = Range_List->new(Initialize => $gc->table('Unassigned') + + $gc->table('Control')); + # Cs not in release 1 + $controls += $gc->table('Surrogate') if defined $gc->table('Surrogate'); + + # Graph is ~space & ~(Cc|Cs|Cn) = ~(space + $controls) + my $Graph = $perl->add_match_table('Graph', + Description => "[[:Graph:]] extended beyond ASCII", + Initialize => ~ ($Space + $controls), + ); + $posix_equivalent{'Graph'} = $Graph; + + my $Print = $perl->add_match_table('Print', + Description => "[[:Print:]] extended beyond ASCII", + Initialize => $Space + $Graph - $gc->table('Control'), + ); + $posix_equivalent{'Print'} = $Print; + + my $Punct = $perl->add_match_table('Punct'); + $Punct->set_equivalent_to($gc->table('Punctuation'), Related => 1); + + # \p{punct} doesn't include the symbols, which posix does + $perl->add_match_table('PosixPunct', + Description => "[[:Punct:]]", + Initialize => $ASCII & ($gc->table('Punctuation') + + $gc->table('Symbol')), + ); + + my $Digit = $perl->add_match_table('Digit', + Description => '\d, extended beyond just [0-9]'); + $Digit->set_equivalent_to($gc->table('Decimal_Number'), Related => 1); + $posix_equivalent{'Digit'} = $Digit; + + # AHex was not present in early releases + my $Xdigit = $perl->add_match_table('XDigit', + Description => '[0-9A-Fa-f]'); + my $AHex = property_ref('ASCII_Hex_Digit'); + if (defined $AHex && ! $AHex->is_empty) { + $Xdigit->set_equivalent_to($AHex->table('Y'), Related => 1); + } + else { + # (Have to use hex because could be running on an non-ASCII machine, + # and we want the Unicode (ASCII) values) + $Xdigit->initialize([ 0x30..0x39, 0x41..0x46, 0x61..0x66 ]); + } + + # Now, add the ASCII-restricted tables that get uniform treatment + while (my ($name, $table) = each %posix_equivalent) { + $perl->add_match_table("Posix$name", + Description => "[[:$name:]]", + Initialize => $table & $ASCII, + ); + } + $perl->table('PosixDigit')->add_description('\d, restricted to ASCII'); + $perl->table('PosixDigit')->add_description('[0-9]'); + + + my $dt = property_ref('Decomposition_Type'); + $dt->add_match_table('Non_Canon', Full_Name => 'Non_Canonical', + Initialize => ~ ($dt->table('None') + $dt->table('Canonical')), + Perl_Extension => 1, + Note => 'Perl extension consisting of the union of all non-canonical decompositions', + ); + + # _CanonDCIJ is equivalent to Soft_Dotted, but if on a release earlier + # than SD appeared, construct it ourselves, based on the first release SD + # was in. + my $CanonDCIJ = $perl->add_match_table('_CanonDCIJ'); + my $soft_dotted = property_ref('Soft_Dotted'); + if (defined $soft_dotted && ! $soft_dotted->is_empty) { + $CanonDCIJ->set_equivalent_to($soft_dotted->table('Y'), Related => 1); + } + else { + + # This list came from 3.2 Soft_Dotted. + $CanonDCIJ->initialize([ 0x0069, + 0x006A, + 0x012F, + 0x0268, + 0x0456, + 0x0458, + 0x1E2D, + 0x1ECB, + ]); + $CanonDCIJ = $CanonDCIJ & $Assigned; + } + + # This is used in Unicode's definition of \X + my $gcb = property_ref('Grapheme_Cluster_Break'); + if (defined $gcb) { + my $extend = $perl->add_match_table('_GCB_Extend', + Initialize => $gcb->table('Extend')); + $extend += $gcb->table('SpacingMark') + if defined $gcb->table('SpacingMark'); + } + else { # Old definition, used on early releases. + $perl->add_match_table('_X_Extend', Initialize => $gc->table('Mark') + + 0x200C # ZWNJ + + 0x200D # ZWJ + ); + } + + # Create a new property specially located that is a combination of the + # various Name properties: Name, Unicode_1_Name, Named Sequences, and + # Name_Alias properties. (The final duplicates elements of the first.) A + # comment for it is constructed based on the actual properties present and + # used + my $perl_charname = Property->new('Perl_Charnames', + Core_Access => '\N{...} and charnames.pm', + Default_Map => "", + Directory => '.', + File => 'Name', + Internal_Only_Warning => 1, + Perl_Extension => 1, + Range_Size_1 => 1, + Type => $STRING, + Initialize => property_ref('Unicode_1_Name'), + ); + # Name overrides Unicode_1_Name + $perl_charname->property_add_or_replace_non_nulls(property_ref('Name')); + my @composition = ('Name', 'Unicode_1_Name'); + + if (@named_sequences) { + push @composition, 'Named_Sequence'; + foreach my $sequence (@named_sequences) { + $perl_charname->add_anomalous_entry($sequence); + } + } + + my $alias_sentence = ""; + my $alias = property_ref('Name_Alias'); + if (defined $alias) { + push @composition, 'Name_Alias'; + $alias->reset_each_range; + while (my ($range) = $alias->each_range) { + next if $range->value eq ""; + if ($range->start != $range->end) { + Carp::my_carp("Expecting only one code point in the range $range. Just to keep going, using just the first code point;"); + } + $perl_charname->add_duplicate($range->start, $range->value); + } + $alias_sentence = <add_duplicate($code_point, $name); +# } +# #$perl_charname->add_comment("This file is for charnames.pm. It is the union of the $comment properties, plus certain commonly used but unofficial names, such as 'FF' and 'ZWNJ'. Unicode_1_Name entries are used only for otherwise nameless code points.$alias_sentence"); + $perl_charname->add_comment(join_lines( <new('Perl_ccc', + Default_Map => $ccc->default_map, + Full_Name => 'Perl_Canonical_Combining_Class', + Internal_Only_Warning => 1, + Perl_Extension => 1, + Pod_Entry =>0, + Type => $ENUM, + Initialize => $ccc, + File => 'CombiningClass', + Directory => '.', + ); + $perl_ccc->set_to_output_map(1); + $perl_ccc->add_comment(join_lines(<add_match_table($ccc->default_map, + Initialize => $ccc->table($ccc->default_map), + Status => $SUPPRESSED); + + # Construct the Present_In property from the Age property. + if (-e 'DAge.txt' && defined (my $age = property_ref('Age'))) { + my $default_map = $age->default_map; + my $in = Property->new('In', + Default_Map => $default_map, + Full_Name => "Present_In", + Internal_Only_Warning => 1, + Perl_Extension => 1, + Type => $ENUM, + Initialize => $age, + ); + $in->add_comment(join_lines(<name !~ /^[\d.]*$/) + ? 1 + : ($b->name !~ /^[\d.]*$/) + ? -1 + : $a->name <=> $b->name + } $age->tables; + + # The Present_In property is the cumulative age properties. The first + # one hence is identical to the first age one. + my $previous_in = $in->add_match_table($first_age->name); + $previous_in->set_equivalent_to($first_age, Related => 1); + + my $description_start = "Code point's usage introduced in version "; + $first_age->add_description($description_start . $first_age->name); + + # To construct the accumlated values, for each of the age tables + # starting with the 2nd earliest, merge the earliest with it, to get + # all those code points existing in the 2nd earliest. Repeat merging + # the new 2nd earliest with the 3rd earliest to get all those existing + # in the 3rd earliest, and so on. + foreach my $current_age (@rest_ages) { + next if $current_age->name !~ /^[\d.]*$/; # Skip the non-numeric + + my $current_in = $in->add_match_table( + $current_age->name, + Initialize => $current_age + $previous_in, + Description => $description_start + . $current_age->name + . ' or earlier', + ); + $previous_in = $current_in; + + # Add clarifying material for the corresponding age file. This is + # in part because of the confusing and contradictory information + # given in the Standard's documentation itself, as of 5.2. + $current_age->add_description( + "Code point's usage was introduced in version " + . $current_age->name); + $current_age->add_note("See also $in"); + + } + + # And finally the code points whose usages have yet to be decided are + # the same in both properties. Note that permanently unassigned code + # points actually have their usage assigned (as being permanently + # unassigned), so that these tables are not the same as gc=cn. + my $unassigned = $in->add_match_table($default_map); + my $age_default = $age->table($default_map); + $age_default->add_description(<set_equivalent_to($age_default, Related => 1); + } + + + # Finished creating all the perl properties. All non-internal non-string + # ones have a synonym of 'Is_' prefixed. (Internal properties begin with + # an underscore.) These do not get a separate entry in the pod file + foreach my $table ($perl->tables) { + foreach my $alias ($table->aliases) { + next if $alias->name =~ /^_/; + $table->add_alias('Is_' . $alias->name, + Pod_Entry => 0, + Status => $alias->status, + Externally_Ok => 0); + } + } + + return; +} + +sub add_perl_synonyms() { + # A number of Unicode tables have Perl synonyms that are expressed in + # the single-form, \p{name}. These are: + # All the binary property Y tables, so that \p{Name=Y} gets \p{Name} and + # \p{Is_Name} as synonyms + # \p{Script=Value} gets \p{Value}, \p{Is_Value} as synonyms + # \p{General_Category=Value} gets \p{Value}, \p{Is_Value} as synonyms + # \p{Block=Value} gets \p{In_Value} as a synonym, and, if there is no + # conflict, \p{Value} and \p{Is_Value} as well + # + # This routine generates these synonyms, warning of any unexpected + # conflicts. + + # Construct the list of tables to get synonyms for. Start with all the + # binary and the General_Category ones. + my @tables = grep { $_->type == $BINARY } property_ref('*'); + push @tables, $gc->tables; + + # If the version of Unicode includes the Script property, add its tables + if (defined property_ref('Script')) { + push @tables, property_ref('Script')->tables; + } + + # The Block tables are kept separate because they are treated differently. + # And the earliest versions of Unicode didn't include them, so add only if + # there are some. + my @blocks; + push @blocks, $block->tables if defined $block; + + # Here, have the lists of tables constructed. Process blocks last so that + # if there are name collisions with them, blocks have lowest priority. + # Should there ever be other collisions, manual intervention would be + # required. See the comments at the beginning of the program for a + # possible way to handle those semi-automatically. + foreach my $table (@tables, @blocks) { + + # For non-binary properties, the synonym is just the name of the + # table, like Greek, but for binary properties the synonym is the name + # of the property, and means the code points in its 'Y' table. + my $nominal = $table; + my $nominal_property = $nominal->property; + my $actual; + if (! $nominal->isa('Property')) { + $actual = $table; + } + else { + + # Here is a binary property. Use the 'Y' table. Verify that is + # there + my $yes = $nominal->table('Y'); + unless (defined $yes) { # Must be defined, but is permissible to + # be empty. + Carp::my_carp_bug("Undefined $nominal, 'Y'. Skipping."); + next; + } + $actual = $yes; + } + + foreach my $alias ($nominal->aliases) { + + # Attempt to create a table in the perl directory for the + # candidate table, using whatever aliases in it that don't + # conflict. Also add non-conflicting aliases for all these + # prefixed by 'Is_' (and/or 'In_' for Block property tables) + PREFIX: + foreach my $prefix ("", 'Is_', 'In_') { + + # Only Block properties can have added 'In_' aliases. + next if $prefix eq 'In_' and $nominal_property != $block; + + my $proposed_name = $prefix . $alias->name; + + # No Is_Is, In_In, nor combinations thereof + trace "$proposed_name is a no-no" if main::DEBUG && $to_trace && $proposed_name =~ /^ I [ns] _I [ns] _/x; + next if $proposed_name =~ /^ I [ns] _I [ns] _/x; + + trace "Seeing if can add alias or table: 'perl=$proposed_name' based on $nominal" if main::DEBUG && $to_trace; + + # Get a reference to any existing table in the perl + # directory with the desired name. + my $pre_existing = $perl->table($proposed_name); + + if (! defined $pre_existing) { + + # No name collision, so ok to add the perl synonym. + + my $make_pod_entry; + my $externally_ok; + my $status = $actual->status; + if ($nominal_property == $block) { + + # For block properties, the 'In' form is preferred for + # external use; the pod file contains wild cards for + # this and the 'Is' form so no entries for those; and + # we don't want people using the name without the + # 'In', so discourage that. + if ($prefix eq "") { + $make_pod_entry = 1; + $status = $status || $DISCOURAGED; + $externally_ok = 0; + } + elsif ($prefix eq 'In_') { + $make_pod_entry = 0; + $status = $status || $NORMAL; + $externally_ok = 1; + } + else { + $make_pod_entry = 0; + $status = $status || $DISCOURAGED; + $externally_ok = 0; + } + } + elsif ($prefix ne "") { + + # The 'Is' prefix is handled in the pod by a wild + # card, and we won't use it for an external name + $make_pod_entry = 0; + $status = $status || $NORMAL; + $externally_ok = 0; + } + else { + + # Here, is an empty prefix, non block. This gets its + # own pod entry and can be used for an external name. + $make_pod_entry = 1; + $status = $status || $NORMAL; + $externally_ok = 1; + } + + # Here, there isn't a perl pre-existing table with the + # name. Look through the list of equivalents of this + # table to see if one is a perl table. + foreach my $equivalent ($actual->leader->equivalents) { + next if $equivalent->property != $perl; + + # Here, have found a table for $perl. Add this alias + # to it, and are done with this prefix. + $equivalent->add_alias($proposed_name, + Pod_Entry => $make_pod_entry, + Status => $status, + Externally_Ok => $externally_ok); + trace "adding alias perl=$proposed_name to $equivalent" if main::DEBUG && $to_trace; + next PREFIX; + } + + # Here, $perl doesn't already have a table that is a + # synonym for this property, add one. + my $added_table = $perl->add_match_table($proposed_name, + Pod_Entry => $make_pod_entry, + Status => $status, + Externally_Ok => $externally_ok); + # And it will be related to the actual table, since it is + # based on it. + $added_table->set_equivalent_to($actual, Related => 1); + trace "added ", $perl->table($proposed_name) if main::DEBUG && $to_trace; + next; + } # End of no pre-existing. + + # Here, there is a pre-existing table that has the proposed + # name. We could be in trouble, but not if this is just a + # synonym for another table that we have already made a child + # of the pre-existing one. + if ($pre_existing->is_equivalent_to($actual)) { + trace "$pre_existing is already equivalent to $actual; adding alias perl=$proposed_name to it" if main::DEBUG && $to_trace; + $pre_existing->add_alias($proposed_name); + next; + } + + # Here, there is a name collision, but it still could be ok if + # the tables match the identical set of code points, in which + # case, we can combine the names. Compare each table's code + # point list to see if they are identical. + trace "Potential name conflict with $pre_existing having ", $pre_existing->count, " code points" if main::DEBUG && $to_trace; + if ($pre_existing->matches_identically_to($actual)) { + + # Here, they do match identically. Not a real conflict. + # Make the perl version a child of the Unicode one, except + # in the non-obvious case of where the perl name is + # already a synonym of another Unicode property. (This is + # excluded by the test for it being its own parent.) The + # reason for this exclusion is that then the two Unicode + # properties become related; and we don't really know if + # they are or not. We generate documentation based on + # relatedness, and this would be misleading. Code + # later executed in the process will cause the tables to + # be represented by a single file anyway, without making + # it look in the pod like they are necessarily related. + if ($pre_existing->parent == $pre_existing + && ($pre_existing->property == $perl + || $actual->property == $perl)) + { + trace "Setting $pre_existing equivalent to $actual since one is \$perl, and match identical sets" if main::DEBUG && $to_trace; + $pre_existing->set_equivalent_to($actual, Related => 1); + } + elsif (main::DEBUG && $to_trace) { + trace "$pre_existing is equivalent to $actual since match identical sets, but not setting them equivalent, to preserve the separateness of the perl aliases"; + trace $pre_existing->parent; + } + next PREFIX; + } + + # Here they didn't match identically, there is a real conflict + # between our new name and a pre-existing property. + $actual->add_conflicting($proposed_name, 'p', $pre_existing); + $pre_existing->add_conflicting($nominal->full_name, + 'p', + $actual); + + # Don't output a warning for aliases for the block + # properties (unless they start with 'In_') as it is + # expected that there will be conflicts and the block + # form loses. + if ($verbosity >= $NORMAL_VERBOSITY + && ($actual->property != $block || $prefix eq 'In_')) + { + print simple_fold(join_lines(<type != $BINARY } property_ref('*')) { + my $yes = $property->table('Yes'); + if (defined $yes) { + my $y = $property->table('Y'); + if (defined $y && $yes == $y) { + foreach my $alias ($property->aliases) { + $yes->add_conflicting($alias->name); + } + } + } + my $no = $property->table('No'); + if (defined $no) { + my $n = $property->table('N'); + if (defined $n && $no == $n) { + foreach my $alias ($property->aliases) { + $no->add_conflicting($alias->name, 'P'); + } + } + } + } + + return; +} + +sub register_file_for_name($$$) { + # Given info about a table and a datafile that it should be associated + # with, register that assocation + + my $table = shift; + my $directory_ref = shift; # Array of the directory path for the file + my $file = shift; # The file name in the final directory, [-1]. + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + trace "table=$table, file=$file, directory=@$directory_ref" if main::DEBUG && $to_trace; + + if ($table->isa('Property')) { + $table->set_file_path(@$directory_ref, $file); + push @map_properties, $table + if $directory_ref->[0] eq $map_directory; + return; + } + + # Do all of the work for all equivalent tables when called with the leader + # table, so skip if isn't the leader. + return if $table->leader != $table; + + # Join all the file path components together, using slashes. + my $full_filename = join('/', @$directory_ref, $file); + + # All go in the same subdirectory of unicore + if ($directory_ref->[0] ne $matches_directory) { + Carp::my_carp("Unexpected directory in " + . join('/', @{$directory_ref}, $file)); + } + + # For this table and all its equivalents ... + foreach my $table ($table, $table->equivalents) { + + # Associate it with its file internally. Don't include the + # $matches_directory first component + $table->set_file_path(@$directory_ref, $file); + my $sub_filename = join('/', $directory_ref->[1, -1], $file); + + my $property = $table->property; + $property = ($property == $perl) + ? "" # 'perl' is never explicitly stated + : standardize($property->name) . '='; + + my $deprecated = ($table->status eq $DEPRECATED) + ? $table->status_info + : ""; + + # And for each of the table's aliases... This inner loop eventually + # goes through all aliases in the UCD that we generate regex match + # files for + foreach my $alias ($table->aliases) { + my $name = $alias->name; + + # Generate an entry in either the loose or strict hashes, which + # will translate the property and alias names combination into the + # file where the table for them is stored. + my $standard; + if ($alias->loose_match) { + $standard = $property . standardize($alias->name); + if (exists $loose_to_file_of{$standard}) { + Carp::my_carp("Can't change file registered to $loose_to_file_of{$standard} to '$sub_filename'."); + } + else { + $loose_to_file_of{$standard} = $sub_filename; + } + } + else { + $standard = lc ($property . $name); + if (exists $stricter_to_file_of{$standard}) { + Carp::my_carp("Can't change file registered to $stricter_to_file_of{$standard} to '$sub_filename'."); + } + else { + $stricter_to_file_of{$standard} = $sub_filename; + + # Tightly coupled with how utf8_heavy.pl works, for a + # floating point number that is a whole number, get rid of + # the trailing decimal point and 0's, so that utf8_heavy + # will work. Also note that this assumes that such a + # number is matched strictly; so if that were to change, + # this would be wrong. + if ((my $integer_name = $name) + =~ s/^ ( -? \d+ ) \.0+ $ /$1/x) + { + $stricter_to_file_of{$property . $integer_name} + = $sub_filename; + } + } + } + + # Keep a list of the deprecated properties and their filenames + if ($deprecated) { + $utf8::why_deprecated{$sub_filename} = $deprecated; + } + } + } + + return; +} + +{ # Closure + my %base_names; # Names already used for avoiding DOS 8.3 filesystem + # conflicts + my %full_dir_name_of; # Full length names of directories used. + + sub construct_filename($$$) { + # Return a file name for a table, based on the table name, but perhaps + # changed to get rid of non-portable characters in it, and to make + # sure that it is unique on a file system that allows the names before + # any period to be at most 8 characters (DOS). While we're at it + # check and complain if there are any directory conflicts. + + my $name = shift; # The name to start with + my $mutable = shift; # Boolean: can it be changed? If no, but + # yet it must be to work properly, a warning + # is given + my $directories_ref = shift; # A reference to an array containing the + # path to the file, with each element one path + # component. This is used because the same + # name can be used in different directories. + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $warn = ! defined wantarray; # If true, then if the name is + # changed, a warning is issued as well. + + if (! defined $name) { + Carp::my_carp("Undefined name in directory " + . File::Spec->join(@$directories_ref) + . ". '_' used"); + return '_'; + } + + # Make sure that no directory names conflict with each other. Look at + # each directory in the input file's path. If it is already in use, + # assume it is correct, and is merely being re-used, but if we + # truncate it to 8 characters, and find that there are two directories + # that are the same for the first 8 characters, but differ after that, + # then that is a problem. + foreach my $directory (@$directories_ref) { + my $short_dir = substr($directory, 0, 8); + if (defined $full_dir_name_of{$short_dir}) { + next if $full_dir_name_of{$short_dir} eq $directory; + Carp::my_carp("$directory conflicts with $full_dir_name_of{$short_dir}. Bad News. Continuing anyway"); + } + else { + $full_dir_name_of{$short_dir} = $directory; + } + } + + my $path = join '/', @$directories_ref; + $path .= '/' if $path; + + # Remove interior underscores. + (my $filename = $name) =~ s/ (?<=.) _ (?=.) //xg; + + # Change any non-word character into an underscore, and truncate to 8. + $filename =~ s/\W+/_/g; # eg., "L&" -> "L_" + substr($filename, 8) = "" if length($filename) > 8; + + # Make sure the basename doesn't conflict with something we + # might have already written. If we have, say, + # InGreekExtended1 + # InGreekExtended2 + # they become + # InGreekE + # InGreek2 + my $warned = 0; + while (my $num = $base_names{$path}{lc $filename}++) { + $num++; # so basenames with numbers start with '2', which + # just looks more natural. + + # Want to append $num, but if it'll make the basename longer + # than 8 characters, pre-truncate $filename so that the result + # is acceptable. + my $delta = length($filename) + length($num) - 8; + if ($delta > 0) { + substr($filename, -$delta) = $num; + } + else { + $filename .= $num; + } + if ($warn && ! $warned) { + $warned = 1; + Carp::my_carp("'$path$name' conflicts with another name on a filesystem with 8 significant characters (like DOS). Proceeding anyway."); + } + } + + return $filename if $mutable; + + # If not changeable, must return the input name, but warn if needed to + # change it beyond shortening it. + if ($name ne $filename + && substr($name, 0, length($filename)) ne $filename) { + Carp::my_carp("'$path$name' had to be changed into '$filename'. Bad News. Proceeding anyway."); + } + return $name; + } +} + +# The pod file contains a very large table. Many of the lines in that table +# would exceed a typical output window's size, and so need to be wrapped with +# a hanging indent to make them look good. The pod language is really +# insufficient here. There is no general construct to do that in pod, so it +# is done here by beginning each such line with a space to cause the result to +# be output without formatting, and doing all the formatting here. This leads +# to the result that if the eventual display window is too narrow it won't +# look good, and if the window is too wide, no advantage is taken of that +# extra width. A further complication is that the output may be indented by +# the formatter so that there is less space than expected. What I (khw) have +# done is to assume that that indent is a particular number of spaces based on +# what it is in my Linux system; people can always resize their windows if +# necessary, but this is obviously less than desirable, but the best that can +# be expected. +my $automatic_pod_indent = 8; + +# Try to format so that uses fewest lines, but few long left column entries +# slide into the right column. An experiment on 5.1 data yielded the +# following percentages that didn't cut into the other side along with the +# associated first-column widths +# 69% = 24 +# 80% not too bad except for a few blocks +# 90% = 33; # , cuts 353/3053 lines from 37 = 12% +# 95% = 37; +my $indent_info_column = 27; # 75% of lines didn't have overlap + +my $FILLER = 3; # Length of initial boiler-plate columns in a pod line + # The 3 is because of: + # 1 for the leading space to tell the pod formatter to + # output as-is + # 1 for the flag + # 1 for the space between the flag and the main data + +sub format_pod_line ($$$;$$) { + # Take a pod line and return it, formatted properly + + my $first_column_width = shift; + my $entry = shift; # Contents of left column + my $info = shift; # Contents of right column + + my $status = shift || ""; # Any flag + + my $loose_match = shift; # Boolean. + $loose_match = 1 unless defined $loose_match; + + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + my $flags = ""; + $flags .= $STRICTER if ! $loose_match; + + $flags .= $status if $status; + + # There is a blank in the left column to cause the pod formatter to + # output the line as-is. + return sprintf " %-*s%-*s %s\n", + # The first * in the format is replaced by this, the -1 is + # to account for the leading blank. There isn't a + # hard-coded blank after this to separate the flags from + # the rest of the line, so that in the unlikely event that + # multiple flags are shown on the same line, they both + # will get displayed at the expense of that separation, + # but since they are left justified, a blank will be + # inserted in the normal case. + $FILLER - 1, + $flags, + + # The other * in the format is replaced by this number to + # cause the first main column to right fill with blanks. + # The -1 is for the guaranteed blank following it. + $first_column_width - $FILLER - 1, + $entry, + $info; +} + +my @zero_match_tables; # List of tables that have no matches in this release + +sub make_table_pod_entries($) { + # This generates the entries for the pod file for a given table. + # Also done at this time are any children tables. The output looks like: + # \p{Common} \p{Script=Common} (Short: \p{Zyyy}) (5178) + + my $input_table = shift; # Table the entry is for + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # Generate parent and all its children at the same time. + return if $input_table->parent != $input_table; + + my $property = $input_table->property; + my $type = $property->type; + my $full_name = $property->full_name; + + my $count = $input_table->count; + my $string_count = clarify_number($count); + my $status = $input_table->status; + my $status_info = $input_table->status_info; + + my $entry_for_first_table; # The entry for the first table output. + # Almost certainly, it is the parent. + + # For each related table (including itself), we will generate a pod entry + # for each name each table goes by + foreach my $table ($input_table, $input_table->children) { + + # utf8_heavy.pl cannot deal with null string property values, so don't + # output any. + next if $table->name eq ""; + + # First, gather all the info that applies to this table as a whole. + + push @zero_match_tables, $table if $count == 0; + + my $table_property = $table->property; + + # The short name has all the underscores removed, while the full name + # retains them. Later, we decide whether to output a short synonym + # for the full one, we need to compare apples to apples, so we use the + # short name's length including underscores. + my $table_property_short_name_length; + my $table_property_short_name + = $table_property->short_name(\$table_property_short_name_length); + my $table_property_full_name = $table_property->full_name; + + # Get how much savings there is in the short name over the full one + # (delta will always be <= 0) + my $table_property_short_delta = $table_property_short_name_length + - length($table_property_full_name); + my @table_description = $table->description; + my @table_note = $table->note; + + # Generate an entry for each alias in this table. + my $entry_for_first_alias; # saves the first one encountered. + foreach my $alias ($table->aliases) { + + # Skip if not to go in pod. + next unless $alias->make_pod_entry; + + # Start gathering all the components for the entry + my $name = $alias->name; + + my $entry; # Holds the left column, may include extras + my $entry_ref; # To refer to the left column's contents from + # another entry; has no extras + + # First the left column of the pod entry. Tables for the $perl + # property always use the single form. + if ($table_property == $perl) { + $entry = "\\p{$name}"; + $entry_ref = "\\p{$name}"; + } + else { # Compound form. + + # Only generate one entry for all the aliases that mean true + # or false in binary properties. Append a '*' to indicate + # some are missing. (The heading comment notes this.) + my $wild_card_mark; + if ($type == $BINARY) { + next if $name ne 'N' && $name ne 'Y'; + $wild_card_mark = '*'; + } + else { + $wild_card_mark = ""; + } + + # Colon-space is used to give a little more space to be easier + # to read; + $entry = "\\p{" + . $table_property_full_name + . ": $name$wild_card_mark}"; + + # But for the reference to this entry, which will go in the + # right column, where space is at a premium, use equals + # without a space + $entry_ref = "\\p{" . $table_property_full_name . "=$name}"; + } + + # Then the right (info) column. This is stored as components of + # an array for the moment, then joined into a string later. For + # non-internal only properties, begin the info with the entry for + # the first table we encountered (if any), as things are ordered + # so that that one is the most descriptive. This leads to the + # info column of an entry being a more descriptive version of the + # name column + my @info; + if ($name =~ /^_/) { + push @info, + '(For internal use by Perl, not necessarily stable)'; + } + elsif ($entry_for_first_alias) { + push @info, $entry_for_first_alias; + } + + # If this entry is equivalent to another, add that to the info, + # using the first such table we encountered + if ($entry_for_first_table) { + if (@info) { + push @info, "(= $entry_for_first_table)"; + } + else { + push @info, $entry_for_first_table; + } + } + + # If the name is a large integer, add an equivalent with an + # exponent for better readability + if ($name =~ /^[+-]?[\d]+$/ && $name >= 10_000) { + push @info, sprintf "(= %.1e)", $name + } + + my $parenthesized = ""; + if (! $entry_for_first_alias) { + + # This is the first alias for the current table. The alias + # array is ordered so that this is the fullest, most + # descriptive alias, so it gets the fullest info. The other + # aliases are mostly merely pointers to this one, using the + # information already added above. + + # Display any status message, but only on the parent table + if ($status && ! $entry_for_first_table) { + push @info, $status_info; + } + + # Put out any descriptive info + if (@table_description || @table_note) { + push @info, join "; ", @table_description, @table_note; + } + + # Look to see if there is a shorter name we can point people + # at + my $standard_name = standardize($name); + my $short_name; + my $proposed_short = $table->short_name; + if (defined $proposed_short) { + my $standard_short = standardize($proposed_short); + + # If the short name is shorter than the standard one, or + # even it it's not, but the combination of it and its + # short property name (as in \p{prop=short} ($perl doesn't + # have this form)) saves at least two characters, then, + # cause it to be listed as a shorter synonym. + if (length $standard_short < length $standard_name + || ($table_property != $perl + && (length($standard_short) + - length($standard_name) + + $table_property_short_delta) # (<= 0) + < -2)) + { + $short_name = $proposed_short; + if ($table_property != $perl) { + $short_name = $table_property_short_name + . "=$short_name"; + } + $short_name = "\\p{$short_name}"; + } + } + + # And if this is a compound form name, see if there is a + # single form equivalent + my $single_form; + if ($table_property != $perl) { + + # Special case the binary N tables, so that will print + # \P{single}, but use the Y table values to populate + # 'single', as we haven't populated the N table. + my $test_table; + my $p; + if ($type == $BINARY + && $input_table == $property->table('No')) + { + $test_table = $property->table('Yes'); + $p = 'P'; + } + else { + $test_table = $input_table; + $p = 'p'; + } + + # Look for a single form amongst all the children. + foreach my $table ($test_table->children) { + next if $table->property != $perl; + my $proposed_name = $table->short_name; + next if ! defined $proposed_name; + + # Don't mention internal-only properties as a possible + # single form synonym + next if substr($proposed_name, 0, 1) eq '_'; + + $proposed_name = "\\$p\{$proposed_name}"; + if (! defined $single_form + || length($proposed_name) < length $single_form) + { + $single_form = $proposed_name; + + # The goal here is to find a single form; not the + # shortest possible one. We've already found a + # short name. So, stop at the first single form + # found, which is likely to be closer to the + # original. + last; + } + } + } + + # Ouput both short and single in the same parenthesized + # expression, but with only one of 'Single', 'Short' if there + # are both items. + if ($short_name || $single_form || $table->conflicting) { + $parenthesized .= '('; + $parenthesized .= "Short: $short_name" if $short_name; + if ($short_name && $single_form) { + $parenthesized .= ', '; + } + elsif ($single_form) { + $parenthesized .= 'Single: '; + } + $parenthesized .= $single_form if $single_form; + } + } + + + # Warn if this property isn't the same as one that a + # semi-casual user might expect. The other components of this + # parenthesized structure are calculated only for the first entry + # for this table, but the conflicting is deemed important enough + # to go on every entry. + my $conflicting = join " NOR ", $table->conflicting; + if ($conflicting) { + $parenthesized .= '(' if ! $parenthesized; + $parenthesized .= '; ' if $parenthesized ne '('; + $parenthesized .= "NOT $conflicting"; + } + $parenthesized .= ')' if $parenthesized; + + push @info, $parenthesized if $parenthesized; + push @info, "($string_count)" if $output_range_counts; + + # Now, we have both the entry and info so add them to the + # list of all the properties. + push @match_properties, + format_pod_line($indent_info_column, + $entry, + join( " ", @info), + $alias->status, + $alias->loose_match); + + $entry_for_first_alias = $entry_ref unless $entry_for_first_alias; + } # End of looping through the aliases for this table. + + if (! $entry_for_first_table) { + $entry_for_first_table = $entry_for_first_alias; + } + } # End of looping through all the related tables + return; +} + +sub pod_alphanumeric_sort { + # Sort pod entries alphanumerically. + + # The first few character columns are filler; and get rid of all the + # trailing stuff, starting with the trailing '}', so as to sort on just + # '\p{Name=Value' + my $a = lc substr($a, $FILLER); + $a =~ s/}.*//; + my $b = lc substr($b, $FILLER); + $b =~ s/}.*//; + + # Determine if the two operands are numeric property values or not. + # A numeric property will look like \p{xyz: 3}. But the number + # can begin with an optional minus sign, and may have a + # fraction or rational component, like \p{xyz: 3/2}. If either + # isn't numeric, use alphabetic sort. + my ($a_initial, $a_number) = + ($a =~ /^\\p{ ( [^:=]+ [:=] \s* ) (-? \d+ (?: [.\/] \d+)? )/ix); + return $a cmp $b unless defined $a_number; + my ($b_initial, $b_number) = + ($b =~ /^\\p{ ( [^:=]+ [:=] \s* ) (-? \d+ (?: [.\/] \d+)? )/ix); + return $a cmp $b unless defined $b_number; + + # Here they are both numeric, but use alphabetic sort if the + # initial parts don't match + return $a cmp $b if $a_initial ne $b_initial; + + # Convert rationals to floating for the comparison. + $a_number = eval $a_number if $a_number =~ qr{/}; + $b_number = eval $b_number if $b_number =~ qr{/}; + + return $a_number <=> $b_number; +} + +sub make_pod () { + # Create the .pod file. This generates the various subsections and then + # combines them in one big HERE document. + + return unless defined $pod_directory; + print "Making pod file\n" if $verbosity >= $PROGRESS; + + my $exception_message = + '(Any exceptions are individually noted beginning with the word NOT.)'; + my @block_warning; + if (-e 'Blocks.txt') { + + # Add the line: '\p{In_*} \p{Block: *}', with the warning message + # if the global $has_In_conflicts indicates we have them. + push @match_properties, format_pod_line($indent_info_column, + '\p{In_*}', + '\p{Block: *}' + . (($has_In_conflicts) + ? " $exception_message" + : "")); + @block_warning = << "END"; + +Matches in the Block property have shortcuts that begin with 'In_'. For +example, \\p{Block=Latin1} can be written as \\p{In_Latin1}. For backward +compatibility, if there is no conflict with another shortcut, these may also +be written as \\p{Latin1} or \\p{Is_Latin1}. But, N.B., there are numerous +such conflicting shortcuts. Use of these forms for Block is discouraged, and +are flagged as such, not only because of the potential confusion as to what is +meant, but also because a later release of Unicode may preempt the shortcut, +and your program would no longer be correct. Use the 'In_' form instead to +avoid this, or even more clearly, use the compound form, e.g., +\\p{blk:latin1}. See L for more information about this. +END + } + my $text = "If an entry has flag(s) at its beginning, like '$DEPRECATED', the 'Is_' form has the same flag(s)"; + $text = "$exception_message $text" if $has_Is_conflicts; + + # And the 'Is_ line'; + push @match_properties, format_pod_line($indent_info_column, + '\p{Is_*}', + "\\p{*} $text"); + + # Sort the properties array for output. It is sorted alphabetically + # except numerically for numeric properties, and only output unique lines. + @match_properties = sort pod_alphanumeric_sort uniques @match_properties; + + my $formatted_properties = simple_fold(\@match_properties, + "", + # indent succeeding lines by two extra + # which looks better + $indent_info_column + 2, + + # shorten the line length by how much + # the formatter indents, so the folded + # line will fit in the space + # presumably available + $automatic_pod_indent); + # Add column headings, indented to be a little more centered, but not + # exactly + $formatted_properties = format_pod_line($indent_info_column, + ' NAME', + ' INFO') + . "\n" + . $formatted_properties; + + # Generate pod documentation lines for the tables that match nothing + my $zero_matches; + if (@zero_match_tables) { + @zero_match_tables = uniques(@zero_match_tables); + $zero_matches = join "\n\n", + map { $_ = '=item \p{' . $_->complete_name . "}" } + sort { $a->complete_name cmp $b->complete_name } + uniques(@zero_match_tables); + + $zero_matches = <[0] cmp $why_list{$b}->[0] } + keys %why_list) + { + # Add to the output, all the properties that have that reason. Start + # with an empty line. + push @bad_re_properties, "\n\n"; + + my $has_item = 0; # Flag if actually output anything. + foreach my $name (@{$why_list{$why}}) { + + # Split compound names into $property and $table components + my $property = $name; + my $table; + if ($property =~ / (.*) = (.*) /x) { + $property = $1; + $table = $2; + } + + # This release of Unicode may not have a property that is + # suppressed, so don't reference a non-existent one. + $property = property_ref($property); + next if ! defined $property; + + # And since this list is only for match tables, don't list the + # ones that don't have match tables. + next if ! $property->to_create_match_tables; + + # Find any abbreviation, and turn it into a compound name if this + # is a property=value pair. + my $short_name = $property->name; + $short_name .= '=' . $property->table($table)->name if $table; + + # And add the property as an item for the reason. + push @bad_re_properties, "\n=item I<$name> ($short_name)\n"; + $has_item = 1; + } + + # And add the reason under the list of properties, if such a list + # actually got generated. Note that the header got added + # unconditionally before. But pod ignores extra blank lines, so no + # harm. + push @bad_re_properties, "\n$why\n" if $has_item; + + } # End of looping through each reason. + + # Generate a list of the properties whose map table we output, from the + # global @map_properties. + my @map_tables_actually_output; + my $info_indent = 20; # Left column is narrower than \p{} table. + foreach my $property (@map_properties) { + + # Get the path to the file; don't output any not in the standard + # directory. + my @path = $property->file_path; + next if $path[0] ne $map_directory; + shift @path; # Remove the standard name + + my $file = join '/', @path; # In case is in sub directory + my $info = $property->full_name; + my $short_name = $property->name; + if ($info ne $short_name) { + $info .= " ($short_name)"; + } + foreach my $more_info ($property->description, + $property->note, + $property->status_info) + { + next unless $more_info; + $info =~ s/\.\Z//; + $info .= ". $more_info"; + } + push @map_tables_actually_output, format_pod_line($info_indent, + $file, + $info, + $property->status); + } + + # Sort alphabetically, and fold for output + @map_tables_actually_output = sort + pod_alphanumeric_sort @map_tables_actually_output; + @map_tables_actually_output + = simple_fold(\@map_tables_actually_output, + ' ', + $info_indent, + $automatic_pod_indent); + + # Generate a list of the formats that can appear in the map tables. + my @map_table_formats; + foreach my $format (sort keys %map_table_formats) { + push @map_table_formats, " $format $map_table_formats{$format}\n"; + } + + # Everything is ready to assemble. + my @OUT = << "END"; +=begin comment + +$HEADER + +To change this file, edit $0 instead. + +=end comment + +=head1 NAME + +$pod_file - Complete index of Unicode Version $string_version properties in +the Perl core. + +=head1 DESCRIPTION + +There are many properties in Unicode, and Perl provides access to almost all of +them, as well as some additional extensions and short-cut synonyms. + +And just about all of the few that aren't accessible through the Perl +core are accessible through the modules: Unicode::Normalize and +Unicode::UCD, and for Unihan properties, via the CPAN module Unicode::Unihan. + +This document merely lists all available properties and does not attempt to +explain what each property really means. There is a brief description of each +Perl extension. There is some detail about Blocks, Scripts, General_Category, +and Bidi_Class in L, but to find out about the intricacies of the +Unicode properties, refer to the Unicode standard. A good starting place is +L<$unicode_reference_url>. More information on the Perl extensions is in +L. + +Note that you can define your own properties; see +L. + +=head1 Properties accessible through \\p{} and \\P{} + +The Perl regular expression \\p{} and \\P{} constructs give access to most of +the Unicode character properties. The table below shows all these constructs, +both single and compound forms. + +B consist of two components, separated by an equals sign or a +colon. The first component is the property name, and the second component is +the particular value of the property to match against, for example, +'\\p{Script: Greek}' or '\\p{Script=Greek}' both mean to match characters +whose Script property is Greek. + +B, like '\\p{Greek}', are mostly Perl-defined shortcuts for +their equivalent compound forms. The table shows these equivalences. (In our +example, '\\p{Greek}' is a just a shortcut for '\\p{Script=Greek}'.) +There are also a few Perl-defined single forms that are not shortcuts for a +compound form. One such is \\p{Word}. These are also listed in the table. + +In parsing these constructs, Perl always ignores Upper/lower case differences +everywhere within the {braces}. Thus '\\p{Greek}' means the same thing as +'\\p{greek}'. But note that changing the case of the 'p' or 'P' before the +left brace completely changes the meaning of the construct, from "match" (for +'\\p{}') to "doesn't match" (for '\\P{}'). Casing in this document is for +improved legibility. + +Also, white space, hyphens, and underscores are also normally ignored +everywhere between the {braces}, and hence can be freely added or removed +even if the C modifier hasn't been specified on the regular expression. +But $a_bold_stricter at the beginning of an entry in the table below +means that tighter (stricter) rules are used for that entry: + +=over 4 + +=item Single form (\\p{name}) tighter rules: + +White space, hyphens, and underscores ARE significant +except for: + +=over 4 + +=item * white space adjacent to a non-word character + +=item * underscores separating digits in numbers + +=back + +That means, for example, that you can freely add or remove white space +adjacent to (but within) the braces without affecting the meaning. + +=item Compound form (\\p{name=value} or \\p{name:value}) tighter rules: + +The tighter rules given above for the single form apply to everything to the +right of the colon or equals; the looser rules still apply to everything to +the left. + +That means, for example, that you can freely add or remove white space +adjacent to (but within) the braces and the colon or equal sign. + +=back + +Some properties are considered obsolete, but still available. There are +several varieties of obsolesence: + +=over 4 + +=item Obsolete + +Properties marked with $a_bold_obsolete in the table are considered +obsolete. At the time of this writing (Unicode version 5.2) there is no +information in the Unicode standard about the implications of a property being +obsolete. + +=item Stabilized + +Obsolete properties may be stabilized. This means that they are not actively +maintained by Unicode, and will not be extended as new characters are added to +the standard. Such properties are marked with $a_bold_stabilized in the +table. At the time of this writing (Unicode version 5.2) there is no further +information in the Unicode standard about the implications of a property being +stabilized. + +=item Deprecated + +Obsolete properties may be deprecated. This means that their use is strongly +discouraged, so much so that a warning will be issued if used, unless the +regular expression is in the scope of a C> +statement. $A_bold_deprecated flags each such entry in the table, and +the entry there for the longest, most descriptive version of the property will +give the reason it is deprecated, and perhaps advice. Perl may issue such a +warning, even for properties that aren't officially deprecated by Unicode, +when there used to be characters or code points that were matched by them, but +no longer. This is to warn you that your program may not work like it did on +earlier Unicode releases. + +A deprecated property may be made unavailable in a future Perl version, so it +is best to move away from them. + +=back + +Some Perl extensions are present for backwards compatibility and are +discouraged from being used, but not obsolete. $A_bold_discouraged +flags each such entry in the table. + +@block_warning + +The table below has two columns. The left column contains the \\p{} +constructs to look up, possibly preceeded by the flags mentioned above; and +the right column contains information about them, like a description, or +synonyms. It shows both the single and compound forms for each property that +has them. If the left column is a short name for a property, the right column +will give its longer, more descriptive name; and if the left column is the +longest name, the right column will show any equivalent shortest name, in both +single and compound forms if applicable. + +The right column will also caution you if a property means something different +than what might normally be expected. + +Numbers in (parentheses) indicate the total number of code points matched by +the property. For emphasis, those properties that match no code points at all +are listed as well in a separate section following the table. + +There is no description given for most non-Perl defined properties (See +$unicode_reference_url for that). - if ($start == $end) { - push @OUT, sprintf "%04X\t\t%s\n", $start, $name; - } else { - push @OUT, sprintf "%04X\t%04X\t%s\n", $start, $end, $name; - } - } +For compactness, 'B<*>' is used as a wildcard instead of showing all possible +combinations. For example, entries like: - push @OUT, "END\n"; + \\p{Gc: *} \\p{General_Category: *} - WriteIfChanged($filename, @OUT); -} +mean that 'Gc' is a synonym for 'General_Category', and anything that is valid +for the latter is also valid for the former. Similarly, -## This used only for making the test script. -## helper function -sub IsUsable($) -{ - my $code = shift; - return 0 if $code <= 0x0000; ## don't use null - return 0 if $code >= $LastUnicodeCodepoint; ## keep in range - return 0 if ($code >= 0xD800 and $code <= 0xDFFF); ## no surrogates - return 0 if ($code >= 0xFDD0 and $code <= 0xFDEF); ## utf8.c says no good - return 0 if (($code & 0xFFFF) == 0xFFFE); ## utf8.c says no good - return 0 if (($code & 0xFFFF) == 0xFFFF); ## utf8.c says no good - return 1; -} + \\p{Is_*} \\p{*} -## Return a code point that's part of the table. -## Returns nothing if the table is empty (or covers only surrogates). -## This used only for making the test script. -sub Table::ValidCode -{ - my $Table = shift; #self - for my $set (@$Table) { - return $set->[RANGE_END] if IsUsable($set->[RANGE_END]); - } - return (); -} +means that if and only if, for example, \\p{Foo} exists, then \\p{Is_Foo} and +\\p{IsFoo} are also valid and all mean the same thing. And similarly, +\\p{Foo=Bar} means the same as \\p{Is_Foo=Bar} and \\p{IsFoo=Bar}. '*' here +is restricted to something not beginning with an underscore. -## Return a code point that's not part of the table -## Returns nothing if the table covers all code points. -## This used only for making the test script. -sub Table::InvalidCode -{ - my $Table = shift; #self +Also, in binary properties, 'Yes', 'T', and 'True' are all synonyms for 'Y'. +And 'No', 'F', and 'False' are all synonyms for 'N'. The table shows 'Y*' and +'N*' to indicate this, and doesn't have separate entries for the other +possibilities. Note that not all properties which have values 'Yes' and 'No' +are binary, and they have all their values spelled out without using this wild +card, and a C clause in their description that highlights their not being +binary. These also require the compound form to match them, whereas true +binary properties have both single and compound forms available. - return 0x1234 if not @$Table; +Note that all non-essential underscores are removed in the display of the +short names below. - for my $set (@$Table) - { - if (IsUsable($set->[RANGE_END] + 1)) - { - return $set->[RANGE_END] + 1; - } +B - if (IsUsable($set->[RANGE_START] - 1)) - { - return $set->[RANGE_START] - 1; - } - } - return (); -} +=over 4 -########################################################################### -########################################################################### -########################################################################### +=item B<*> is a wild-card +=item B<(\\d+)> in the info column gives the number of code points matched by +this property. -## -## Called like: -## New_Alias(Is => 'All', SameAs => 'Any', Fuzzy => 1); -## -## The args must be in that order, although the Fuzzy pair may be omitted. -## -## This creates 'IsAll' as an alias for 'IsAny' -## -sub New_Alias($$$@) -{ - my $Type = shift; ## "Is" or "In" - my $Alias = shift; - my $SameAs = shift; # expecting "SameAs" -- just ignored - my $Name = shift; +=item B<$DEPRECATED> means this is deprecated. - ## remaining args are optional key/val - my %Args = @_; +=item B<$OBSOLETE> means this is obsolete. - my $Fuzzy = delete $Args{Fuzzy}; +=item B<$STABILIZED> means this is stabilized. - ## sanity check a few args - if (%Args or ($Type ne 'Is' and $Type ne 'In') or $SameAs ne 'SameAs') { - confess "$0: bad args to New_Alias" - } +=item B<$STRICTER> means tighter (stricter) name matching applies. - $Alias = CanonicalName($Alias) if $Fuzzy; +=item B<$DISCOURAGED> means use of this form is discouraged. - if (not $TableInfo{$Type}->{$Name}) - { - my $CName = CanonicalName($Name); - if ($TableInfo{$Type}->{$CName}) { - confess "$0: Use canonical form '$CName' instead of '$Name' for alias."; - } else { - confess "$0: don't have original $Type => $Name to make alias\n"; - } - } - if ($TableInfo{$Alias}) { - confess "$0: already have original $Type => $Alias; can't make alias"; - } - $AliasInfo{$Type}->{$Name} = $Alias; - if ($Fuzzy) { - $FuzzyNames{$Type}->{$Alias} = $Name; - } - -} - - -## All assigned code points -my $Assigned = Table->New(Is => 'Assigned', - Desc => "All assigned code points", - Fuzzy => 0); - -my $Name = Table->New(); ## all characters, individually by name -my $General = Table->New(); ## all characters, grouped by category -my %General; -my %Cat; - -## Simple Data::Dumper like. Good enough for our needs. We can't use the real -## thing as we have to run under miniperl -sub simple_dumper { - my @lines; - my $item; - foreach $item (@_) { - if (ref $item) { - if (ref $item eq 'ARRAY') { - push @lines, "[\n", simple_dumper (@$item), "],\n"; - } elsif (ref $item eq 'HASH') { - push @lines, "{\n", simple_dumper (%$item), "},\n"; - } else { - die "Can't cope with $item"; - } - } else { - if (defined $item) { - my $copy = $item; - $copy =~ s/([\'\\])/\\$1/gs; - push @lines, "'$copy',\n"; - } else { - push @lines, "undef,\n"; - } - } - } - @lines; -} - -## -## Process UnicodeData.txt (Categories, etc.) -## -# These are the character mappings as defined in the POSIX standard -# and in the case of PerlSpace and PerlWord as is defined in the test macros -# for binary strings. IOW, PerlWord is [A-Za-z_] and PerlSpace is [\f\r\n\t ] -# This differs from Word and the existing SpacePerl (note the prefix/suffix difference) -# which is basically the Unicode WhiteSpace without the vertical tab included -# -my %TRUE_POSIX_PERL_CC= ( - PosixAlnum => { map { $_ => 1 } ( 0x0030..0x0039, 0x0041..0x005a, 0x0061..0x007a )}, - PosixAlpha => { map { $_ => 1 } ( 0x0041..0x005a, 0x0061..0x007a )}, - # Not Needed: Ascii => { map { $_ => 1 } ( 0x0000..0x007f )}, - PosixBlank => { map { $_ => 1 } ( 0x0009, 0x0020 )}, - PosixCntrl => { map { $_ => 1 } ( 0x0000..0x001f, 0x007f )}, - PosixGraph => { map { $_ => 1 } ( 0x0021..0x007e )}, - PosixLower => { map { $_ => 1 } ( 0x0061..0x007a )}, - PosixPrint => { map { $_ => 1 } ( 0x0020..0x007e )}, - PosixPunct => { map { $_ => 1 } ( 0x0021..0x002f, 0x003a..0x0040, 0x005b..0x0060, 0x007b..0x007e )}, - PosixSpace => { map { $_ => 1 } ( 0x0009..0x000d, 0x0020 )}, - PosixUpper => { map { $_ => 1 } ( 0x0041..0x005a )}, - # Not needed: PosixXdigit => { map { $_ => 1 } ( 0x0030..0x0039, 0x0041..0x0046, 0x0061..0x0066 )}, - PosixDigit => { map { $_ => 1 } ( 0x0030..0x0039 )}, - - PerlSpace => { map { $_ => 1 } ( 0x0009..0x000a, 0x000c..0x000d, 0x0020 )}, - PerlWord => { map { $_ => 1 } ( 0x0030..0x0039, 0x0041..0x005a, 0x005f, 0x0061..0x007a )}, -); +=back -sub UnicodeData_Txt() -{ - my $Bidi = Table->New(); - my $Deco = Table->New(); - my $Comb = Table->New(); - my $Number = Table->New(); - my $Mirrored = Table->New();#Is => 'Mirrored', - #Desc => "Mirrored in bidirectional text", - #Fuzzy => 0); - - my %DC; - my %Bidi; - my %Number; - $DC{Can} = Table->New(); - $DC{Com} = Table->New(); - - ## Initialize Broken Perl-generated categories - ## (Categories from UnicodeData.txt are auto-initialized in gencat) - $Cat{Alnum} = - Table->New(Is => 'Alnum', Desc => "[[:Alnum:]]", Fuzzy => 0); - $Cat{Alpha} = - Table->New(Is => 'Alpha', Desc => "[[:Alpha:]]", Fuzzy => 0); - $Cat{ASCII} = - Table->New(Is => 'ASCII', Desc => "[[:ASCII:]]", Fuzzy => 0); - $Cat{Blank} = - Table->New(Is => 'Blank', Desc => "[[:Blank:]]", Fuzzy => 0); - $Cat{Cntrl} = - Table->New(Is => 'Cntrl', Desc => "[[:Cntrl:]]", Fuzzy => 0); - $Cat{Digit} = - Table->New(Is => 'Digit', Desc => "[[:Digit:]]", Fuzzy => 0); - $Cat{Graph} = - Table->New(Is => 'Graph', Desc => "[[:Graph:]]", Fuzzy => 0); - $Cat{Lower} = - Table->New(Is => 'Lower', Desc => "[[:Lower:]]", Fuzzy => 0); - $Cat{Print} = - Table->New(Is => 'Print', Desc => "[[:Print:]]", Fuzzy => 0); - $Cat{Punct} = - Table->New(Is => 'Punct', Desc => "[[:Punct:]]", Fuzzy => 0); - $Cat{Space} = - Table->New(Is => 'Space', Desc => "[[:Space:]]", Fuzzy => 0); - $Cat{Title} = - Table->New(Is => 'Title', Desc => "[[:Title:]]", Fuzzy => 0); - $Cat{Upper} = - Table->New(Is => 'Upper', Desc => "[[:Upper:]]", Fuzzy => 0); - $Cat{XDigit} = - Table->New(Is => 'XDigit', Desc => "[[:XDigit:]]", Fuzzy => 0); - $Cat{Word} = - Table->New(Is => 'Word', Desc => "[[:Word:]]", Fuzzy => 0); - $Cat{SpacePerl} = - Table->New(Is => 'SpacePerl', Desc => '\s', Fuzzy => 0); - $Cat{VertSpace} = - Table->New(Is => 'VertSpace', Desc => '\v', Fuzzy => 0); - $Cat{HorizSpace} = - Table->New(Is => 'HorizSpace', Desc => '\h', Fuzzy => 0); - my %To; - $To{Upper} = Table->New(); - $To{Lower} = Table->New(); - $To{Title} = Table->New(); - $To{Digit} = Table->New(); - - foreach my $cat (keys %TRUE_POSIX_PERL_CC) { - $Cat{$cat} = Table->New(Is=>$cat, Fuzzy => 0); - } - - sub gencat($$$$) - { - my ($name, ## Name ("LATIN CAPITAL LETTER A") - $cat, ## Category ("Lu", "Zp", "Nd", etc.) - $code, ## Code point (as an integer) - $op) = @_; - - my $MajorCat = substr($cat, 0, 1); ## L, M, Z, S, etc - - $Assigned->$op($code); - $Name->$op($code, $name); - $General->$op($code, $cat); - - ## add to the sub category (e.g. "Lu", "Nd", "Cf", ..) - $Cat{$cat} ||= Table->New(Is => $cat, - Desc => "General Category '$cat'", - Fuzzy => 0); - $Cat{$cat}->$op($code); - - ## add to the major category (e.g. "L", "N", "C", ...) - $Cat{$MajorCat} ||= Table->New(Is => $MajorCat, - Desc => "Major Category '$MajorCat'", - Fuzzy => 0); - $Cat{$MajorCat}->$op($code); - - ($General{$name} ||= Table->New)->$op($code, $name); - - # 005F: SPACING UNDERSCORE - $Cat{Word}->$op($code) if $cat =~ /^[LMN]|Pc/; - $Cat{Alnum}->$op($code) if $cat =~ /^[LM]|Nd/; - $Cat{Alpha}->$op($code) if $cat =~ /^[LM]/; - - my $isspace = - ($cat =~ /Zs|Zl|Zp/ && - $code != 0x200B) # 200B is ZWSP which is for line break control - # and therefore it is not part of "space" even - # while it is "Zs" in some versions of Unicode. - # In 5.1 it is Cf, so this line is no longer - # necessary. - || $code == 0x0009 # 0009: HORIZONTAL TAB - || $code == 0x000A # 000A: LINE FEED - || $code == 0x000B # 000B: VERTICAL TAB - || $code == 0x000C # 000C: FORM FEED - || $code == 0x000D # 000D: CARRIAGE RETURN - || $code == 0x0085 # 0085: NEL - - ; - - $Cat{Space}->$op($code) if $isspace; - - $Cat{SpacePerl}->$op($code) if $isspace - && $code != 0x000B; # Backward compat. - - $Cat{VertSpace}->$op($code) if grep {$code == $_} - ( 0x0A..0x0D,0x85,0x2028,0x2029 ); - - $Cat{HorizSpace}->$op($code) if grep {$code == $_} ( - 0x09, 0x20, 0xa0, 0x1680, 0x180e, 0x2000, 0x2001, 0x2002, - 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200a, - 0x202f, 0x205f, 0x3000 - ); - - $Cat{Blank}->$op($code) if $isspace - && !($code == 0x000A || - $code == 0x000B || - $code == 0x000C || - $code == 0x000D || - $code == 0x0085 || - $cat =~ /^Z[lp]/); - - $Cat{Digit}->$op($code) if $cat eq "Nd"; - $Cat{Upper}->$op($code) if $cat eq "Lu"; - $Cat{Lower}->$op($code) if $cat eq "Ll"; - $Cat{Title}->$op($code) if $cat eq "Lt"; - $Cat{ASCII}->$op($code) if $code <= 0x007F; - $Cat{Cntrl}->$op($code) if $cat =~ /^C/; - my $isgraph = !$isspace && $cat !~ /Cc|Cs|Cn/; - $Cat{Graph}->$op($code) if $isgraph; - $Cat{Print}->$op($code) if $isgraph || $isspace; - $Cat{Punct}->$op($code) if $cat =~ /^P/; - - $Cat{XDigit}->$op($code) if ($code >= 0x30 && $code <= 0x39) ## 0..9 - || ($code >= 0x41 && $code <= 0x46) ## A..F - || ($code >= 0x61 && $code <= 0x66); ## a..f - if ($code<=0x7F) { - foreach my $cat (keys %TRUE_POSIX_PERL_CC) { - if ($TRUE_POSIX_PERL_CC{$cat}{$code}) { - $Cat{$cat}->$op($code); - } - } - } - } - - ## open and read file..... - if (not open IN, "UnicodeData.txt") { - die "$0: UnicodeData.txt: $!\n"; - } - - ## - ## For building \p{_CombAbove} and \p{_CanonDCIJ} - ## - my %_Above_HexCodes; ## Hexcodes for chars with $comb == 230 ("ABOVE") - - my %CodeToDeco; ## Maps code to decomp. list for chars with first - ## decomp. char an "i" or "j" (for \p{_CanonDCIJ}) - - ## This is filled in as we go.... - my $CombAbove = Table->New(Is => '_CombAbove', - Desc => '(for internal casefolding use)', - Fuzzy => 0); - - while () - { - next unless /^[0-9A-Fa-f]+;/; - s/\s+$//; - - my ($hexcode, ## code point in hex (e.g. "0041") - $name, ## character name (e.g. "LATIN CAPITAL LETTER A") - $cat, ## category (e.g. "Lu") - $comb, ## Canonical combining class (e.g. "230") - $bidi, ## directional category (e.g. "L") - $deco, ## decomposition mapping - $decimal, ## decimal digit value - $digit, ## digit value - $number, ## numeric value - $mirrored, ## mirrored - $unicode10, ## name in Unicode 1.0 - $comment, ## comment field - $upper, ## uppercase mapping - $lower, ## lowercase mapping - $title, ## titlecase mapping - ) = split(/\s*;\s*/); - - # Note that in Unicode 3.2 there will be names like - # LINE FEED (LF), which probably means that \N{} needs - # to cope also with LINE FEED and LF. - $name = $unicode10 if $name eq '' && $unicode10 ne ''; - - my $code = hex($hexcode); - - if ($comb and $comb == 230) { - $CombAbove->Append($code); - $_Above_HexCodes{$hexcode} = 1; - } - - ## Used in building \p{_CanonDCIJ} - if ($deco and $deco =~ m/^006[9A]\b/) { - $CodeToDeco{$code} = $deco; - } - - ## - ## There are a few pairs of lines like: - ## AC00;;Lo;0;L;;;;;N;;;;; - ## D7A3;;Lo;0;L;;;;;N;;;;; - ## that define ranges. - ## - if ($name =~ /^<(.+), (First|Last)>$/) - { - $name = $1; - gencat($name, $cat, $code, $2 eq 'First' ? 'Append' : 'Extend'); - #New_Prop(In => $name, $General{$name}, Fuzzy => 1); - } - else - { - ## normal (single-character) lines - gencat($name, $cat, $code, 'Append'); +$formatted_properties - # No Append() here since since several codes may map into one. - $To{Upper}->RawAppendRange($code, $code, $upper) if $upper; - $To{Lower}->RawAppendRange($code, $code, $lower) if $lower; - $To{Title}->RawAppendRange($code, $code, $title) if $title; - $To{Digit}->Append($code, $decimal) if length $decimal; +$zero_matches - $Bidi->Append($code, $bidi); - $Comb->Append($code, $comb) if $comb; - $Number->Append($code, $number) if length $number; +=head1 Properties not accessible through \\p{} and \\P{} - length($decimal) and ($Number{De} ||= Table->New())->Append($code) - or - length($digit) and ($Number{Di} ||= Table->New())->Append($code) - or - length($number) and ($Number{Nu} ||= Table->New())->Append($code); +A few properties are accessible in Perl via various function calls only. +These are: + Lowercase_Mapping lc() and lcfirst() + Titlecase_Mapping ucfirst() + Uppercase_Mapping uc() - $Mirrored->Append($code) if $mirrored eq "Y"; +Case_Folding is accessible through the /i modifier in regular expressions. - $Bidi{$bidi} ||= Table->New();#Is => "bt/$bidi", - #Desc => "Bi-directional category '$bidi'", - #Fuzzy => 0); - $Bidi{$bidi}->Append($code); +The Name property is accessible through the \\N{} interpolation in +double-quoted strings and regular expressions, but both usages require a C to be specified, which also contains related functions viacode() +and vianame(). - if ($deco) - { - $Deco->Append($code, $deco); - if ($deco =~/^<(\w+)>/) - { - my $dshort = $PVA_reverse{dt}{ucfirst lc $1}; - $DC{Com}->Append($code); - $dshort = $PVA_reverse{dt}{lc $1} unless $dshort ne ""; - die "No reverse for $1'" unless $dshort ne ""; - #$dshort = lc $dshort; # use lower case only - $DC{$dshort} ||= Table->New(); - $DC{$dshort}->Append($code); - } - else - { - $DC{Can}->Append($code); - } - } - } - } - close IN; +=head1 Unicode regular expression properties that are NOT accepted by Perl - ## Read in the NameAliases.txt. It contains other normative names of code - ## points not listed in UnicodeData.txt. This happens when there is an - ## error in the name found after the data base was published, but instead of - ## changing it, to avoid breaking any code that came to rely on the - ## erroneous version, the correct name is added as an alias. - - my $NameAliases = Table->New(); +Perl will generate an error for a few character properties in Unicode when +used in a regular expression. The non-Unihan ones are listed below, with the +reasons they are not accepted, perhaps with work-arounds. The short names for +the properties are listed enclosed in (parentheses). - if (not open IN, "NameAliases.txt") { - die "$0: NameAliases.txt: $!\n"; - } +=over 4 - while () - { - next unless /^[0-9A-Fa-f]+;/; - s/\s+$//; - - my ($hexcode, ## code point in hex (e.g. "0041") - $name, ## character name (e.g. "LATIN CAPITAL LETTER A") - ) = split(/\s*;\s*/); - - my $code = hex($hexcode); - - ## One is supposed to enter elements into tables in strictly increasing - ## order, but this in fact works to append duplicate code points at - ## the end of the table. The table is intended to be indexed by name - ## anyway. - - $Name->RawAppendRange($code, $code, $name); - } - close IN; - - - ## - ## Tidy up a few special cases.... - ## - - $Cat{Cn} = $Assigned->Invert; ## Cn is everything that doesn't exist - New_Prop(Is => 'Cn', - $Cat{Cn}, - Desc => "General Category 'Cn' [not functional in Perl]", - Fuzzy => 0); - - ## Unassigned is the same as 'Cn' - New_Alias(Is => 'Unassigned', SameAs => 'Cn', Fuzzy => 0); - - $Cat{C}->Replace($Cat{C}->Merge($Cat{Cn})); ## Now merge in Cn into C - - - # LC is Ll, Lu, and Lt. - # (used to be L& or L_, but PropValueAliases.txt defines it as LC) - New_Prop(Is => 'LC', - Table->Merge(@Cat{qw[Ll Lu Lt]}), - Desc => '[\p{Ll}\p{Lu}\p{Lt}]', - Fuzzy => 0); - - ## Any and All are all code points. - my $Any = Table->New(Is => 'Any', - Desc => sprintf("[\\x{0000}-\\x{%X}]", - $LastUnicodeCodepoint), - Fuzzy => 0); - $Any->RawAppendRange(0, $LastUnicodeCodepoint); - - New_Alias(Is => 'All', SameAs => 'Any', Fuzzy => 0); - - ## - ## Build special properties for Perl's internal case-folding needs: - ## \p{_CaseIgnorable} - ## \p{_CanonDCIJ} - ## \p{_CombAbove} - ## _CombAbove was built above. Others are built here.... - ## - - ## \p{_CaseIgnorable} is [\p{Mn}\0x00AD\x2010] - New_Prop(Is => '_CaseIgnorable', - Table->Merge($Cat{Mn}, - 0x00AD, #SOFT HYPHEN - 0x2010), #HYPHEN - Desc => '(for internal casefolding use)', - Fuzzy => 0); - - - ## \p{_CanonDCIJ} is fairly complex... - my $CanonCDIJ = Table->New(Is => '_CanonDCIJ', - Desc => '(for internal casefolding use)', - Fuzzy => 0); - ## It contains the ASCII 'i' and 'j'.... - $CanonCDIJ->Append(0x0069); # ASCII ord("i") - $CanonCDIJ->Append(0x006A); # ASCII ord("j") - ## ...and any character with a decomposition that starts with either of - ## those code points, but only if the decomposition does not have any - ## combining character with the "ABOVE" canonical combining class. - for my $code (sort { $a <=> $b} keys %CodeToDeco) - { - ## Need to ensure that all decomposition characters do not have - ## a %HexCodeToComb in %AboveCombClasses. - my $want = 1; - for my $deco_hexcode (split / /, $CodeToDeco{$code}) - { - if (exists $_Above_HexCodes{$deco_hexcode}) { - ## one of the decmposition chars has an ABOVE combination - ## class, so we're not interested in this one - $want = 0; - last; - } - } - if ($want) { - $CanonCDIJ->Append($code); - } - } +@bad_re_properties +=back +An installation can choose to allow any of these to be matched by changing the +controlling lists contained in the program C<\$Config{privlib}>/F +and then re-running F<$0>. (C<\%Config> is available from the Config module). - ## - ## Now dump the files. - ## - $Name->Write("Name.pl"); +=head1 Files in the I directory (for serious hackers only) - { - my @PVA = $HEADER; - foreach my $name (qw (PropertyAlias PA_reverse PropValueAlias - PVA_reverse PVA_abbr_map)) { - # Should I really jump through typeglob hoops just to avoid a - # symbolic reference? (%{"utf8::$name}) - push @PVA, "\n", "\%utf8::$name = (\n", - simple_dumper (%{$utf8::{$name}}), ");\n"; - } - push @PVA, "1;\n"; - WriteIfChanged("PVA.pl", @PVA); - } +All Unicode properties are really mappings (in the mathematical sense) from +code points to their respective values. As part of its build process, +Perl constructs tables containing these mappings for all properties that it +deals with. But only a few of these are written out into files. +Those written out are in the directory C<\$Config{privlib}>/F +(%Config is available from the Config module). - # $Bidi->Write("Bidirectional.pl"); - for (keys %Bidi) { - $Bidi{$_}->Write( - ["lib","bc","$_.pl"], - "BidiClass category '$PropValueAlias{bc}{$_}'" - ); - } +Those ones written are ones needed by Perl internally during execution, or for +which there is some demand, and those for which there is no access through the +Perl core. Generally, properties that can be used in regular expression +matching do not have their map tables written, like Script. Nor are the +simplistic properties that have a better, more complete version, such as +Simple_Uppercase_Mapping (Uppercase_Mapping is written instead). - $Comb->Write("CombiningClass.pl"); - for (keys %{ $PropValueAlias{ccc} }) { - my ($code, $name) = @{ $PropValueAlias{ccc}{$_} }; - (my $c = Table->New())->Append($code); - $c->Write( - ["lib","ccc","$_.pl"], - "CombiningClass category '$name'" - ); - } +None of the properties in the I directory are currently directly +accessible through the Perl core, although some may be accessed indirectly. +For example, the uc() function implements the Uppercase_Mapping property and +uses the F file found in this directory. - $Deco->Write("Decomposition.pl"); - for (keys %DC) { - $DC{$_}->Write( - ["lib","dt","$_.pl"], - "DecompositionType category '$PropValueAlias{dt}{$_}'" - ); - } +The available files with their properties (short names in parentheses), +and any flags or comments about them, are: - # $Number->Write("Number.pl"); - for (keys %Number) { - $Number{$_}->Write( - ["lib","nt","$_.pl"], - "NumericType category '$PropValueAlias{nt}{$_}'" - ); - } +@map_tables_actually_output - # $General->Write("Category.pl"); +An installation can choose to change which files are generated by changing the +controlling lists contained in the program C<\$Config{privlib}>/F +and then re-running F<$0>. - for my $to (sort keys %To) { - $To{$to}->Write(["To","$to.pl"]); - } +Each of these files defines two hash entries to help reading programs decipher +it. One of them looks like this: - for (keys %{ $PropValueAlias{gc} }) { - New_Alias(Is => $PropValueAlias{gc}{$_}, SameAs => $_, Fuzzy => 1); - } -} + \$utf8::SwashInfo{'ToNAME'}{'format'} = 's'; -## -## Process LineBreak.txt -## -sub LineBreak_Txt() -{ - if (not open IN, "LineBreak.txt") { - die "$0: LineBreak.txt: $!\n"; - } +where 'NAME' is a name to indicate the property. For backwards compatibility, +this is not necessarily the property's official Unicode name. (The 'To' is +also for backwards compatibility.) The hash entry gives the format of the +mapping fields of the table, currently one of the following: - my $Lbrk = Table->New(); - my %Lbrk; + @map_table_formats - while () - { - next unless /^([0-9A-Fa-f]+)(?:\.\.([0-9A-Fa-f]+))?\s*;\s*(\w+)/; +This format applies only to the entries in the main body of the table. +Entries defined in hashes or ones that are missing from the list can have a +different format. - my ($first, $last, $lbrk) = (hex($1), hex($2||""), $3); +The value that the missing entries have is given by the other SwashInfo hash +entry line; it looks like this: - $Lbrk->Append($first, $lbrk); + \$utf8::SwashInfo{'ToNAME'}{'missing'} = 'NaN'; - $Lbrk{$lbrk} ||= Table->New(); - $Lbrk{$lbrk}->Append($first); +This example line says that any Unicode code points not explicitly listed in +the file have the value 'NaN' under the property indicated by NAME. If the +value is the special string C<< >>, it means that the value for +any missing code point is the code point itself. This happens, for example, +in the file for Uppercase_Mapping (To/Upper.pl), in which code points like the +character 'A', are missing because the uppercase of 'A' is itself. - if ($last) { - $Lbrk->Extend($last); - $Lbrk{$lbrk}->Extend($last); - } - } - close IN; +=head1 SEE ALSO - # $Lbrk->Write("Lbrk.pl"); +L<$unicode_reference_url> +L - for (keys %Lbrk) { - $Lbrk{$_}->Write( - ["lib","lb","$_.pl"], - "Linebreak category '$PropValueAlias{lb}{$_}'" - ); - } -} +L -## -## Process ArabicShaping.txt. -## -sub ArabicShaping_txt() -{ - if (not open IN, "ArabicShaping.txt") { - die "$0: ArabicShaping.txt: $!\n"; - } +END - my $ArabLink = Table->New(); - my $ArabLinkGroup = Table->New(); + # And write it. + main::write([ $pod_directory, "$pod_file.pod" ], @OUT); + return; +} - my %JoinType; +sub make_Heavy () { + # Create and write Heavy.pl, which passes info about the tables to + # utf8_heavy.pl - while () - { - next unless /^[0-9A-Fa-f]+;/; - s/\s+$//; + my @heavy = <Append($code, $link); - $ArabLinkGroup->Append($code, $linkgroup); +# This file is for the use of utf8_heavy.pl - $JoinType{$link} ||= Table->New(Is => "JoinType$link"); - $JoinType{$link}->Append($code); - } - close IN; +# Maps property names in loose standard form to its standard name +\%utf8::loose_property_name_of = ( +END - # $ArabLink->Write("ArabLink.pl"); - # $ArabLinkGroup->Write("ArabLnkGrp.pl"); + push @heavy, simple_dumper (\%loose_property_name_of, ' ' x 4); + push @heavy, <Write( - ["lib","jt","$_.pl"], - "JoiningType category '$PropValueAlias{jt}{$_}'" - ); - } -} +# Maps property, table to file for those using loose matching +\%utf8::loose_to_file_of = ( +END + push @heavy, simple_dumper (\%loose_to_file_of, ' ' x 4); + push @heavy, <) - { - next unless /^[0-9A-Fa-f]+(\.\.[0-9A-Fa-f]+)?;/; - s/#.*//; - s/\s+$//; +# Deprecated tables to generate a warning for. The key is the file containing +# the table, so as to avoid duplication, as many property names can map to the +# file, but we only need one entry for all of them. +\%utf8::why_deprecated = ( +END - my ($hexcodes, $pv) = split(/\s*;\s*/); - $EAW{$pv} ||= Table->New(Is => "EastAsianWidth$pv"); - my ($start, $end) = split(/\.\./, $hexcodes); - if (defined $end) { - $EAW{$pv}->AppendRange(hex($start), hex($end)); - } else { - $EAW{$pv}->Append(hex($start)); - } - } - close IN; + push @heavy, simple_dumper (\%utf8::why_deprecated, ' ' x 4); + push @heavy, <Write( - ["lib","ea","$_.pl"], - "EastAsianWidth category '$PropValueAlias{ea}{$_}'" - ); - } + main::write("Heavy.pl", @heavy); + return; } -## -## Process HangulSyllableType.txt. -## -sub HangulSyllableType_txt() -{ - if (not open IN, "HangulSyllableType.txt") { - die "$0: HangulSyllableType.txt: $!\n"; - } +sub write_all_tables() { + # Write out all the tables generated by this program to files, as well as + # the supporting data structures, pod file, and .t file. + + my @writables; # List of tables that actually get written + my %match_tables_to_write; # Used to collapse identical match tables + # into one file. Each key is a hash function + # result to partition tables into buckets. + # Each value is an array of the tables that + # fit in the bucket. + + # For each property ... + # (sort so that if there is an immutable file name, it has precedence, so + # some other property can't come in and take over its file name. If b's + # file name is defined, will return 1, meaning to take it first; don't + # care if both defined, as they had better be different anyway) + PROPERTY: + foreach my $property (sort { defined $b->file } property_ref('*')) { + my $type = $property->type; + + # And for each table for that property, starting with the mapping + # table for it ... + TABLE: + foreach my $table($property, + + # and all the match tables for it (if any), sorted so + # the ones with the shortest associated file name come + # first. The length sorting prevents problems of a + # longer file taking a name that might have to be used + # by a shorter one. The alphabetic sorting prevents + # differences between releases + sort { my $ext_a = $a->external_name; + return 1 if ! defined $ext_a; + my $ext_b = $b->external_name; + return -1 if ! defined $ext_b; + my $cmp = length $ext_a <=> length $ext_b; + + # Return result if lengths not equal + return $cmp if $cmp; + + # Alphabetic if lengths equal + return $ext_a cmp $ext_b + } $property->tables + ) + { - my %HST; + # Here we have a table associated with a property. It could be + # the map table (done first for each property), or one of the + # other tables. Determine which type. + my $is_property = $table->isa('Property'); + + my $name = $table->name; + my $complete_name = $table->complete_name; + + # See if should suppress the table if is empty, but warn if it + # contains something. + my $suppress_if_empty_warn_if_not = grep { $complete_name eq $_ } + keys %why_suppress_if_empty_warn_if_not; + + # Calculate if this table should have any code points associated + # with it or not. + my $expected_empty = + + # $perl should be empty, as well as properties that we just + # don't do anything with + ($is_property + && ($table == $perl + || grep { $complete_name eq $_ } + @unimplemented_properties + ) + ) + + # Match tables in properties we skipped populating should be + # empty + || (! $is_property && ! $property->to_create_match_tables) + + # Tables and properties that are expected to have no code + # points should be empty + || $suppress_if_empty_warn_if_not + ; + + # Set a boolean if this table is the complement of an empty binary + # table + my $is_complement_of_empty_binary = + $type == $BINARY && + (($table == $property->table('Y') + && $property->table('N')->is_empty) + || ($table == $property->table('N') + && $property->table('Y')->is_empty)); + + + # Some tables should match everything + my $expected_full = + ($is_property) + ? # All these types of map tables will be full because + # they will have been populated with defaults + ($type == $ENUM || $type == $BINARY) + + : # A match table should match everything if its method + # shows it should + ($table->matches_all + + # The complement of an empty binary table will match + # everything + || $is_complement_of_empty_binary + ) + ; + + if ($table->is_empty) { + + + if ($suppress_if_empty_warn_if_not) { + $table->set_status($SUPPRESSED, + $why_suppress_if_empty_warn_if_not{$complete_name}); + } - while () - { - next unless /^([0-9A-Fa-f]+)(?:\.\.([0-9A-Fa-f]+))?\s*;\s*(\w+)/; - my ($first, $last, $pv) = (hex($1), hex($2||""), $3); + # Suppress expected empty tables. + next TABLE if $expected_empty; + + # And setup to later output a warning for those that aren't + # known to be allowed to be empty. Don't do the warning if + # this table is a child of another one to avoid duplicating + # the warning that should come from the parent one. + if (($table == $property || $table->parent == $table) + && $table->status ne $SUPPRESSED + && ! grep { $complete_name =~ /^$_$/ } + @tables_that_may_be_empty) + { + push @unhandled_properties, "$table"; + } + } + elsif ($expected_empty) { + my $because = ""; + if ($suppress_if_empty_warn_if_not) { + $because = " because $why_suppress_if_empty_warn_if_not{$complete_name}"; + } - $HST{$pv} ||= Table->New(Is => "HangulSyllableType$pv"); - $HST{$pv}->Append($first); + Carp::my_carp("Not expecting property $table$because. Generating file for it anyway."); + } - if ($last) { $HST{$pv}->Extend($last) } - } - close IN; + my $count = $table->count; + if ($expected_full) { + if ($count != $MAX_UNICODE_CODEPOINTS) { + Carp::my_carp("$table matches only " + . clarify_number($count) + . " Unicode code points but should match " + . clarify_number($MAX_UNICODE_CODEPOINTS) + . " (off by " + . clarify_number(abs($MAX_UNICODE_CODEPOINTS - $count)) + . "). Proceeding anyway."); + } - for (keys %HST) { - $HST{$_}->Write( - ["lib","hst","$_.pl"], - "HangulSyllableType category '$PropValueAlias{hst}{$_}'" - ); - } -} + # Here is expected to be full. If it is because it is the + # complement of an (empty) binary table that is to be + # suppressed, then suppress this one as well. + if ($is_complement_of_empty_binary) { + my $opposing_name = ($name eq 'Y') ? 'N' : 'Y'; + my $opposing = $property->table($opposing_name); + my $opposing_status = $opposing->status; + if ($opposing_status) { + $table->set_status($opposing_status, + $opposing->status_info); + } + } + } + elsif ($count == $MAX_UNICODE_CODEPOINTS) { + if ($table == $property || $table->leader == $table) { + Carp::my_carp("$table unexpectedly matches all Unicode code points. Proceeding anyway."); + } + } -## -## Process Jamo.txt. -## -sub Jamo_txt() -{ - if (not open IN, "Jamo.txt") { - die "$0: Jamo.txt: $!\n"; - } - my $Short = Table->New(); + if ($table->status eq $SUPPRESSED) { + if (! $is_property) { + my @children = $table->children; + foreach my $child (@children) { + if ($child->status ne $SUPPRESSED) { + Carp::my_carp_bug("'$table' is suppressed and has a child '$child' which isn't"); + } + } + } + next TABLE; - while () - { - next unless /^([0-9A-Fa-f]+)\s*;\s*(\w*)/; - my ($code, $short) = (hex($1), $2); + } + if (! $is_property) { + + # Several things need to be done just once for each related + # group of match tables. Do them on the parent. + if ($table->parent == $table) { + + # Add an entry in the pod file for the table; it also does + # the children. + make_table_pod_entries($table); + + # See if the the table matches identical code points with + # something that has already been output. In that case, + # no need to have two files with the same code points in + # them. We use the table's hash() method to store these + # in buckets, so that it is quite likely that if two + # tables are in the same bucket they will be identical, so + # don't have to compare tables frequently. The tables + # have to have the same status to share a file, so add + # this to the bucket hash. (The reason for this latter is + # that Heavy.pl associates a status with a file.) + my $hash = $table->hash . ';' . $table->status; + + # Look at each table that is in the same bucket as this + # one would be. + foreach my $comparison (@{$match_tables_to_write{$hash}}) + { + if ($table->matches_identically_to($comparison)) { + $table->set_equivalent_to($comparison, + Related => 0); + next TABLE; + } + } - $Short->Append($code, $short); - } - close IN; - # $Short->Write("JamoShort.pl"); -} + # Here, not equivalent, add this table to the bucket. + push @{$match_tables_to_write{$hash}}, $table; + } + } + else { + + # Here is the property itself. + # Don't write out or make references to the $perl property + next if $table == $perl; + + if ($type != $STRING) { + + # There is a mapping stored of the various synonyms to the + # standardized name of the property for utf8_heavy.pl. + # Also, the pod file contains entries of the form: + # \p{alias: *} \p{full: *} + # rather than show every possible combination of things. + + my @property_aliases = $property->aliases; + + # The full name of this property is stored by convention + # first in the alias array + my $full_property_name = + '\p{' . $property_aliases[0]->name . ': *}'; + my $standard_property_name = standardize($table->name); + + # For each synonym ... + for my $i (0 .. @property_aliases - 1) { + my $alias = $property_aliases[$i]; + my $alias_name = $alias->name; + my $alias_standard = standardize($alias_name); + + # Set the mapping for utf8_heavy of the alias to the + # property + if (exists ($loose_property_name_of{$alias_standard})) + { + Carp::my_carp("There already is a property with the same standard name as $alias_name: $loose_property_name_of{$alias_standard}. Old name is retained"); + } + else { + $loose_property_name_of{$alias_standard} + = $standard_property_name; + } + + # Now for the pod entry for this alias. Skip + # the first one, which is the full name so won't have + # an entry like: '\p{full: *} \p{full: *}', and skip + # if don't want an entry for this one. + next if $i == 0 || ! $alias->make_pod_entry; + + push @match_properties, + format_pod_line($indent_info_column, + '\p{' . $alias->name . ': *}', + $full_property_name, + $alias->status); + } + } # End of non-string-like property code -## -## Process Scripts.txt. -## -sub Scripts_txt() -{ - my @ScriptInfo; - if (not open(IN, "Scripts.txt")) { - die "$0: Scripts.txt: $!\n"; - } - while () { - next unless /^([0-9A-Fa-f]+)(?:\.\.([0-9A-Fa-f]+))?\s*;\s*(.+?)\s*\#/; + # Don't output a mapping file if not desired. + next if ! $property->to_output_map; + } - # Wait until all the scripts have been read since - # they are not listed in numeric order. - push @ScriptInfo, [ hex($1), hex($2||""), $3 ]; - } - close IN; + # Here, we know we want to write out the table, but don't do it + # yet because there may be other tables that come along and will + # want to share the file, and the file's comments will change to + # mention them. So save for later. + push @writables, $table; + + } # End of looping through the property and all its tables. + } # End of looping through all properties. + + # Now have all the tables that will have files written for them. Do it. + foreach my $table (@writables) { + my @directory; + my $filename; + my $property = $table->property; + my $is_property = ($table == $property); + if (! $is_property) { + + # Match tables for the property go in lib/$subdirectory, which is + # the property's name. Don't use the standard file name for this, + # as may get an unfamiliar alias + @directory = ($matches_directory, $property->external_name); + } + else { - # Now append the scripts properties in their code point order. + @directory = $table->directory; + $filename = $table->file; + } - my %Script; - my $Scripts = Table->New(); + # Use specified filename if avaliable, or default to property's + # shortest name. We need an 8.3 safe filename (which means "an 8 + # safe" filename, since after the dot is only 'pl', which is < 3) + # The 2nd parameter is if the filename shouldn't be changed, and + # it shouldn't iff there is a hard-coded name for this table. + $filename = construct_filename( + $filename || $table->external_name, + ! $filename, # mutable if no filename + \@directory); - for my $script (sort { $a->[0] <=> $b->[0] } @ScriptInfo) - { - my ($first, $last, $name) = @$script; - $Scripts->Append($first, $name); + register_file_for_name($table, \@directory, $filename); - $Script{$name} ||= Table->New(Is => $name, - Desc => "Script '$name'", - Fuzzy => 1); - $Script{$name}->Append($first, $name); + # Only need to write one file when shared by more than one + # property + next if ! $is_property && $table->leader != $table; - if ($last) { - $Scripts->Extend($last); - $Script{$name}->Extend($last); - } + # Construct a nice comment to add to the file + $table->set_final_comment; + + $table->write; } - # $Scripts->Write("Scripts.pl"); - ## Common is everything not explicitly assigned to a Script - ## - ## ***shouldn't this be intersected with \p{Assigned}? ****** - ## - New_Prop(Is => 'Common', - $Scripts->Invert, - Desc => 'Pseudo-Script of codepoints not in other Unicode scripts', - Fuzzy => 1); -} + # Write out the pod file + make_pod; + + # And Heavy.pl + make_Heavy; -## -## Given a name like "Close Punctuation", return a regex (that when applied -## with /i) matches any valid form of that name (e.g. "ClosePunctuation", -## "Close-Punctuation", etc.) -## -## Accept any space, dash, or underbar where in the official name there is -## space or a dash (or underbar, but there never is). -## -## -sub NameToRegex($) -{ - my $Name = shift; - $Name =~ s/[- _]/(?:[-_]|\\s+)?/g; - return $Name; + make_property_test_script() if $make_test_script; + return; } -## -## Process Blocks.txt. -## -sub Blocks_txt() -{ - my $Blocks = Table->New(); - my %Blocks; +my @white_space_separators = ( # This used only for making the test script. + "", + ' ', + "\t", + ' ' + ); - if (not open IN, "Blocks.txt") { - die "$0: Blocks.txt: $!\n"; - } +sub generate_separator($) { + # This used only for making the test script. It generates the colon or + # equal separator between the property and property value, with random + # white space surrounding the separator - while () - { - #next if not /Private Use$/; - next if not /^([0-9A-Fa-f]+)\.\.([0-9A-Fa-f]+)\s*;\s*(.+?)\s*$/; + my $lhs = shift; - my ($first, $last, $name) = (hex($1), hex($2), $3); + return "" if $lhs eq ""; # No separator if there's only one (the r) side - $Blocks->Append($first, $name); + # Choose space before and after randomly + my $spaces_before =$white_space_separators[rand(@white_space_separators)]; + my $spaces_after = $white_space_separators[rand(@white_space_separators)]; - $Blocks{$name} ||= Table->New(In => $name, - Desc => "Block '$name'", - Fuzzy => 1); - $Blocks{$name}->Append($first, $name); + # And return the whole complex, half the time using a colon, half the + # equals + return $spaces_before + . (rand() < 0.5) ? '=' : ':' + . $spaces_after; +} - if ($last and $last != $first) { - $Blocks->Extend($last); - $Blocks{$name}->Extend($last); - } +sub generate_tests($$$$$$) { + # This used only for making the test script. It generates test cases that + # are expected to compile successfully in perl. Note that the lhs and + # rhs are assumed to already be as randomized as the caller wants. + + my $file_handle = shift; # Where to output the tests + my $lhs = shift; # The property: what's to the left of the colon + # or equals separator + my $rhs = shift; # The property value; what's to the right + my $valid_code = shift; # A code point that's known to be in the + # table given by lhs=rhs; undef if table is + # empty + my $invalid_code = shift; # A code point known to not be in the table; + # undef if the table is all code points + my $warning = shift; + + # Get the colon or equal + my $separator = generate_separator($lhs); + + # The whole 'property=value' + my $name = "$lhs$separator$rhs"; + + # Create a complete set of tests, with complements. + if (defined $valid_code) { + printf $file_handle + qq/Expect(1, $valid_code, '\\p{$name}', $warning);\n/; + printf $file_handle + qq/Expect(0, $valid_code, '\\p{^$name}', $warning);\n/; + printf $file_handle + qq/Expect(0, $valid_code, '\\P{$name}', $warning);\n/; + printf $file_handle + qq/Expect(1, $valid_code, '\\P{^$name}', $warning);\n/; + } + if (defined $invalid_code) { + printf $file_handle + qq/Expect(0, $invalid_code, '\\p{$name}', $warning);\n/; + printf $file_handle + qq/Expect(1, $invalid_code, '\\p{^$name}', $warning);\n/; + printf $file_handle + qq/Expect(1, $invalid_code, '\\P{$name}', $warning);\n/; + printf $file_handle + qq/Expect(0, $invalid_code, '\\P{^$name}', $warning);\n/; } - close IN; + return; +} - # $Blocks->Write("Blocks.pl"); +sub generate_error($$$$) { + # This used only for making the test script. It generates test cases that + # are expected to not only not match, but to be syntax or similar errors + + my $file_handle = shift; # Where to output to. + my $lhs = shift; # The property: what's to the left of the + # colon or equals separator + my $rhs = shift; # The property value; what's to the right + my $already_in_error = shift; # Boolean; if true it's known that the + # unmodified lhs and rhs will cause an error. + # This routine should not force another one + # Get the colon or equal + my $separator = generate_separator($lhs); + + # Since this is an error only, don't bother to randomly decide whether to + # put the error on the left or right side; and assume that the rhs is + # loosely matched, again for convenience rather than rigor. + $rhs = randomize_loose_name($rhs, 'ERROR') unless $already_in_error; + + my $property = $lhs . $separator . $rhs; + + print $file_handle qq/Error('\\p{$property}');\n/; + print $file_handle qq/Error('\\P{$property}');\n/; + return; } -## -## Read in the PropList.txt. It contains extended properties not -## listed in the UnicodeData.txt, such as 'Other_Alphabetic': -## alphabetic but not of the general category L; many modifiers -## belong to this extended property category: while they are not -## alphabets, they are alphabetic in nature. -## -sub PropList_txt() -{ - my @PropInfo; +# These are used only for making the test script +# XXX Maybe should also have a bad strict seps, which includes underscore. + +my @good_loose_seps = ( + " ", + "-", + "\t", + "", + "_", + ); +my @bad_loose_seps = ( + "/a/", + ':=', + ); + +sub randomize_stricter_name { + # This used only for making the test script. Take the input name and + # return a randomized, but valid version of it under the stricter matching + # rules. + + my $name = shift; + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + # If the name looks like a number (integer, floating, or rational), do + # some extra work + if ($name =~ qr{ ^ ( -? ) (\d+ ( ( [./] ) \d+ )? ) $ }x) { + my $sign = $1; + my $number = $2; + my $separator = $3; + + # If there isn't a sign, part of the time add a plus + # Note: Not testing having any denominator having a minus sign + if (! $sign) { + $sign = '+' if rand() <= .3; + } + + # And add 0 or more leading zeros. + $name = $sign . ('0' x int rand(10)) . $number; + + if (defined $separator) { + my $extra_zeros = '0' x int rand(10); - if (not open IN, "PropList.txt") { - die "$0: PropList.txt: $!\n"; + if ($separator eq '.') { + + # Similarly, add 0 or more trailing zeros after a decimal + # point + $name .= $extra_zeros; + } + else { + + # Or, leading zeros before the denominator + $name =~ s,/,/$extra_zeros,; + } + } } - while () - { - next unless /^([0-9A-Fa-f]+)(?:\.\.([0-9A-Fa-f]+))?\s*;\s*(.+?)\s*\#/; + # For legibility of the test, only change the case of whole sections at a + # time. To do this, first split into sections. The split returns the + # delimiters + my @sections; + for my $section (split / ( [ - + \s _ . ]+ ) /x, $name) { + trace $section if main::DEBUG && $to_trace; + + if (length $section > 1 && $section !~ /\D/) { + + # If the section is a sequence of digits, about half the time + # randomly add underscores between some of them. + if (rand() > .5) { + + # Figure out how many underscores to add. max is 1 less than + # the number of digits. (But add 1 at the end to make sure + # result isn't 0, and compensate earlier by subtracting 2 + # instead of 1) + my $num_underscores = int rand(length($section) - 2) + 1; + + # And add them evenly throughout, for convenience, not rigor + use integer; + my $spacing = (length($section) - 1)/ $num_underscores; + my $temp = $section; + $section = ""; + for my $i (1 .. $num_underscores) { + $section .= substr($temp, 0, $spacing, "") . '_'; + } + $section .= $temp; + } + push @sections, $section; + } + else { - # Wait until all the extended properties have been read since - # they are not listed in numeric order. - push @PropInfo, [ hex($1), hex($2||""), $3 ]; + # Here not a sequence of digits. Change the case of the section + # randomly + my $switch = int rand(4); + if ($switch == 0) { + push @sections, uc $section; + } + elsif ($switch == 1) { + push @sections, lc $section; + } + elsif ($switch == 2) { + push @sections, ucfirst $section; + } + else { + push @sections, $section; + } + } } - close IN; + trace "returning", join "", @sections if main::DEBUG && $to_trace; + return join "", @sections; +} - # Now append the extended properties in their code point order. - my $Props = Table->New(); - my %Prop; +sub randomize_loose_name($;$) { + # This used only for making the test script - for my $prop (sort { $a->[0] <=> $b->[0] } @PropInfo) - { - my ($first, $last, $name) = @$prop; - $Props->Append($first, $name); - - $Prop{$name} ||= Table->New(Is => $name, - Desc => "Extended property '$name'", - Fuzzy => 1); - $Prop{$name}->Append($first, $name); - - if ($last) { - $Props->Extend($last); - $Prop{$name}->Extend($last); - } - } - - for (keys %Prop) { - (my $file = $PA_reverse{$_}) =~ tr/_//d; - # XXX I'm assuming that the names from %Prop don't suffer 8.3 clashes. - $BaseNames{lc $file}++; - $Prop{$_}->Write( - ["lib","gc_sc","$file.pl"], - "Binary property '$_'" - ); - } - - # Alphabetic is L, Nl, and Other_Alphabetic. - New_Prop(Is => 'Alphabetic', - Table->Merge($Cat{L}, $Cat{Nl}, $Prop{Other_Alphabetic}), - Desc => '[\p{L}\p{Nl}\p{OtherAlphabetic}]', # canonical names - Fuzzy => 1); - - # Lowercase is Ll and Other_Lowercase. - New_Prop(Is => 'Lowercase', - Table->Merge($Cat{Ll}, $Prop{Other_Lowercase}), - Desc => '[\p{Ll}\p{OtherLowercase}]', # canonical names - Fuzzy => 1); - - # Uppercase is Lu and Other_Uppercase. - New_Prop(Is => 'Uppercase', - Table->Merge($Cat{Lu}, $Prop{Other_Uppercase}), - Desc => '[\p{Lu}\p{OtherUppercase}]', # canonical names - Fuzzy => 1); - - # Math is Sm and Other_Math. - New_Prop(Is => 'Math', - Table->Merge($Cat{Sm}, $Prop{Other_Math}), - Desc => '[\p{Sm}\p{OtherMath}]', # canonical names - Fuzzy => 1); - - # ID_Start is Ll, Lu, Lt, Lm, Lo, Nl, and Other_ID_Start. - New_Prop(Is => 'ID_Start', - Table->Merge(@Cat{qw[Ll Lu Lt Lm Lo Nl]}, $Prop{Other_ID_Start}), - Desc => '[\p{Ll}\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{Nl}\p{OtherIDStart}]', - Fuzzy => 1); - - # ID_Continue is ID_Start, Mn, Mc, Nd, Pc, and Other_ID_Continue. - New_Prop(Is => 'ID_Continue', - Table->Merge(@Cat{qw[Ll Lu Lt Lm Lo Nl Mn Mc Nd Pc ]}, - @Prop{qw[Other_ID_Start Other_ID_Continue]}), - Desc => '[\p{ID_Start}\p{Mn}\p{Mc}\p{Nd}\p{Pc}\p{OtherIDContinue}]', - Fuzzy => 1); - - # Default_Ignorable_Code_Point = Other_Default_Ignorable_Code_Point - # + Cf + Cc + Cs + Noncharacter + Variation_Selector - # - WhiteSpace - FFF9..FFFB (Annotation Characters) - - my $Annotation = Table->New(); - $Annotation->RawAppendRange(0xFFF9, 0xFFFB); - - New_Prop(Is => 'Default_Ignorable_Code_Point', - Table->Merge(@Cat{qw[Cf Cc Cs]}, - $Prop{Noncharacter_Code_Point}, - $Prop{Variation_Selector}, - $Prop{Other_Default_Ignorable_Code_Point}) - ->Invert - ->Merge($Prop{White_Space}, $Annotation) - ->Invert, - Desc => '(?![\p{WhiteSpace}\x{FFF9}-\x{FFFB}])[\p{Cf}\p{Cc}'. - '\p{Cs}\p{NoncharacterCodePoint}\p{VariationSelector}'. - '\p{OtherDefaultIgnorableCodePoint}]', - Fuzzy => 1); - -} - - -## -## These are used in: -## MakePropTestScript() -## WriteAllMappings() -## for making the test script. -## -my %FuzzyNameToTest; -my %ExactNameToTest; - - -## This used only for making the test script -sub GenTests($$$$) -{ - my $FH = shift; - my $Prop = shift; - my $MatchCode = shift; - my $FailCode = shift; - - if (defined $MatchCode) { - printf $FH qq/Expect(1, "\\x{%04X}", '\\p{$Prop}' );\n/, $MatchCode; - printf $FH qq/Expect(0, "\\x{%04X}", '\\p{^$Prop}');\n/, $MatchCode; - printf $FH qq/Expect(0, "\\x{%04X}", '\\P{$Prop}' );\n/, $MatchCode; - printf $FH qq/Expect(1, "\\x{%04X}", '\\P{^$Prop}');\n/, $MatchCode; - } - if (defined $FailCode) { - printf $FH qq/Expect(0, "\\x{%04X}", '\\p{$Prop}' );\n/, $FailCode; - printf $FH qq/Expect(1, "\\x{%04X}", '\\p{^$Prop}');\n/, $FailCode; - printf $FH qq/Expect(1, "\\x{%04X}", '\\P{$Prop}' );\n/, $FailCode; - printf $FH qq/Expect(0, "\\x{%04X}", '\\P{^$Prop}');\n/, $FailCode; - } -} - -## This used only for making the test script -sub ExpectError($$) -{ - my $FH = shift; - my $prop = shift; - - print $FH qq/Error('\\p{$prop}');\n/; - print $FH qq/Error('\\P{$prop}');\n/; -} - -## This used only for making the test script -my @GoodSeps = ( - " ", - "-", - " \t ", - "", - "", - "_", - ); -my @BadSeps = ( - "--", - "__", - " _", - "/" - ); - -## This used only for making the test script -sub RandomlyFuzzifyName($;$) -{ - my $Name = shift; - my $WantError = shift; ## if true, make an error + my $name = shift; + my $want_error = shift; # if true, make an error + Carp::carp_extra_args(\@_) if main::DEBUG && @_; + + $name = randomize_stricter_name($name); my @parts; - for my $part (split /[-\s_]+/, $Name) - { + push @parts, $good_loose_seps[rand(@good_loose_seps)]; + for my $part (split /[-\s_]+/, $name) { if (@parts) { - if ($WantError and rand() < 0.3) { - push @parts, $BadSeps[rand(@BadSeps)]; - $WantError = 0; - } else { - push @parts, $GoodSeps[rand(@GoodSeps)]; + if ($want_error and rand() < 0.3) { + push @parts, $bad_loose_seps[rand(@bad_loose_seps)]; + $want_error = 0; + } + else { + push @parts, $good_loose_seps[rand(@good_loose_seps)]; } } - my $switch = int rand(4); - if ($switch == 0) { - push @parts, uc $part; - } elsif ($switch == 1) { - push @parts, lc $part; - } elsif ($switch == 2) { - push @parts, ucfirst $part; - } else { - push @parts, $part; - } + push @parts, $part; } - my $new = join('', @parts); + my $new = join("", @parts); + trace "$name => $new" if main::DEBUG && $to_trace; - if ($WantError) { + if ($want_error) { if (rand() >= 0.5) { - $new .= $BadSeps[rand(@BadSeps)]; - } else { - $new = $BadSeps[rand(@BadSeps)] . $new; + $new .= $bad_loose_seps[rand(@bad_loose_seps)]; + } + else { + $new = $bad_loose_seps[rand(@bad_loose_seps)] . $new; } } return $new; } -## This used only for making the test script -sub MakePropTestScript() -{ - ## this written directly -- it's huge. - force_unlink ("TestProp.pl"); - if (not open OUT, ">TestProp.pl") { - die "$0: TestProp.pl: $!\n"; - } - print OUT ; - - while (my ($Name, $Table) = each %ExactNameToTest) - { - GenTests(*OUT, $Name, $Table->ValidCode, $Table->InvalidCode); - ExpectError(*OUT, uc $Name) if uc $Name ne $Name; - ExpectError(*OUT, lc $Name) if lc $Name ne $Name; - } +# Used to make sure don't generate duplicate test cases. +my %test_generated; +sub make_property_test_script() { + # This used only for making the test script + # this written directly -- it's huge. - while (my ($Name, $Table) = each %FuzzyNameToTest) - { - my $Orig = $CanonicalToOrig{$Name}; - my %Names = ( - $Name => 1, - $Orig => 1, - RandomlyFuzzifyName($Orig) => 1 - ); + print "Making test script\n" if $verbosity >= $PROGRESS; - for my $N (keys %Names) { - GenTests(*OUT, $N, $Table->ValidCode, $Table->InvalidCode); - } + # This uses randomness to test different possibilities without testing all + # possibilities. To ensure repeatability, set the seed to 0. But if + # tests are added, it will perturb all later ones in the .t file + srand 0; - ExpectError(*OUT, RandomlyFuzzifyName($Orig, 'ERROR')); + force_unlink ($t_path); + push @files_actually_output, $t_path; + my $OUT; + if (not open $OUT, "> $t_path") { + Carp::my_carp("Can't open $t_path. Skipping: $!"); + return; } - print OUT "Finished();\n"; - close OUT; -} - - -## -## These are used only in: -## RegisterFileForName() -## WriteAllMappings() -## -my %Exact; ## will become %utf8::Exact; -my %Canonical; ## will become %utf8::Canonical; -my %CaComment; ## Comment for %Canonical entry of same key - -## -## Given info about a name and a datafile that it should be associated with, -## register that assocation in %Exact and %Canonical. -sub RegisterFileForName($$$$) -{ - my $Type = shift; - my $Name = shift; - my $IsFuzzy = shift; - my $filename = shift; - - ## - ## Now in details for the mapping. $Type eq 'Is' has the - ## Is removed, as it will be removed in utf8_heavy when this - ## data is being checked. In keeps its "In", but a second - ## sans-In record is written if it doesn't conflict with - ## anything already there. - ## - if (not $IsFuzzy) + # Keep going down an order of magnitude + # until find that adding this quantity to + # 1 remains 1; but put an upper limit on + # this so in case this algorithm doesn't + # work properly on some platform, that we + # won't loop forever. + my $digits = 0; + my $min_floating_slop = 1; + while (1+ $min_floating_slop != 1 + && $digits++ < 50) { - if ($Type eq 'Is') { - die "oops[$Name]" if $Exact{$Name}; - $Exact{$Name} = $filename; - } else { - die "oops[$Type$Name]" if $Exact{"$Type$Name"}; - $Exact{"$Type$Name"} = $filename; - $Exact{$Name} = $filename if not $Exact{$Name}; - } + my $next = $min_floating_slop / 10; + last if $next == 0; # If underflows, + # use previous one + $min_floating_slop = $next; } - else - { - my $CName = lc $Name; - if ($Type eq 'Is') { - die "oops[$CName]" if $Canonical{$CName}; - $Canonical{$CName} = $filename; - $CaComment{$CName} = $Name if $Name =~ tr/A-Z// >= 2; - } else { - die "oops[$Type$CName]" if $Canonical{lc "$Type$CName"}; - $Canonical{lc "$Type$CName"} = $filename; - $CaComment{lc "$Type$CName"} = "$Type$Name"; - if (not $Canonical{$CName}) { - $Canonical{$CName} = $filename; - $CaComment{$CName} = "$Type$Name"; - } - } - } -} - -## -## Writes the info accumulated in -## -## %TableInfo; -## %FuzzyNames; -## %AliasInfo; -## -## -sub WriteAllMappings() -{ - my @MAP; - - ## 'Is' *MUST* come first, so its names have precidence over 'In's - for my $Type ('Is', 'In') - { - my %RawNameToFile; ## a per-$Type cache - - for my $Name (sort {length $a <=> length $b} keys %{$TableInfo{$Type}}) - { - ## Note: $Name is already canonical - my $Table = $TableInfo{$Type}->{$Name}; - my $IsFuzzy = $FuzzyNames{$Type}->{$Name}; - - ## Need an 8.3 safe filename (which means "an 8 safe" $filename) - my $filename; - { - ## 'Is' items lose 'Is' from the basename. - $filename = $Type eq 'Is' ? - ($PVA_reverse{sc}{$Name} || $Name) : - "$Type$Name"; - - $filename =~ s/[^\w_]+/_/g; # "L&" -> "L_" - substr($filename, 8) = '' if length($filename) > 8; - - ## - ## Make sure the basename doesn't conflict with something we - ## might have already written. If we have, say, - ## InGreekExtended1 - ## InGreekExtended2 - ## they become - ## InGreekE - ## InGreek2 - ## - while (my $num = $BaseNames{lc $filename}++) - { - $num++; ## so basenames with numbers start with '2', which - ## just looks more natural. - ## Want to append $num, but if it'll make the basename longer - ## than 8 characters, pre-truncate $filename so that the result - ## is acceptable. - my $delta = length($filename) + length($num) - 8; - if ($delta > 0) { - substr($filename, -$delta) = $num; - } else { - $filename .= $num; + print $OUT $HEADER, ; + + foreach my $property (property_ref('*')) { + foreach my $table ($property->tables) { + + # Find code points that match, and don't match this table. + my $valid = $table->get_valid_code_point; + my $invalid = $table->get_invalid_code_point; + my $warning = ($table->status eq $DEPRECATED) + ? "'deprecated'" + : '""'; + + # Test each possible combination of the property's aliases with + # the table's. If this gets to be too many, could do what is done + # in the set_final_comment() for Tables + my @table_aliases = $table->aliases; + my @property_aliases = $table->property->aliases; + my $max = max(scalar @table_aliases, scalar @property_aliases); + for my $j (0 .. $max - 1) { + + # The current alias for property is the next one on the list, + # or if beyond the end, start over. Similarly for table + my $property_name + = $property_aliases[$j % @property_aliases]->name; + + $property_name = "" if $table->property == $perl; + my $table_alias = $table_aliases[$j % @table_aliases]; + my $table_name = $table_alias->name; + my $loose_match = $table_alias->loose_match; + + # If the table doesn't have a file, any test for it is + # already guaranteed to be in error + my $already_error = ! $table->file_path; + + # Generate error cases for this alias. + generate_error($OUT, + $property_name, + $table_name, + $already_error); + + # If the table is guaranteed to always generate an error, + # quit now without generating success cases. + next if $already_error; + + # Now for the success cases. + my $random; + if ($loose_match) { + + # For loose matching, create an extra test case for the + # standard name. + my $standard = standardize($table_name); + + # $test_name should be a unique combination for each test + # case; used just to avoid duplicate tests + my $test_name = "$property_name=$standard"; + + # Don't output duplicate test cases. + if (! exists $test_generated{$test_name}) { + $test_generated{$test_name} = 1; + generate_tests($OUT, + $property_name, + $standard, + $valid, + $invalid, + $warning, + ); } + $random = randomize_loose_name($table_name) + } + else { # Stricter match + $random = randomize_stricter_name($table_name); } - }; - ## - ## Construct a nice comment to add to the file, and build data - ## for the "./Properties" file along the way. - ## - my $Comment; - { - my $Desc = $TableDesc{$Type}->{$Name} || ""; - ## get list of names this table is reference by - my @Supported = $Name; - while (my ($Orig, $Alias) = each %{ $AliasInfo{$Type} }) - { - if ($Orig eq $Name) { - push @Supported, $Alias; + # Now for the main test case for this alias. + my $test_name = "$property_name=$random"; + if (! exists $test_generated{$test_name}) { + $test_generated{$test_name} = 1; + generate_tests($OUT, + $property_name, + $random, + $valid, + $invalid, + $warning, + ); + + # If the name is a rational number, add tests for the + # floating point equivalent. + if ($table_name =~ qr{/}) { + + # Calculate the float, and find just the fraction. + my $float = eval $table_name; + my ($whole, $fraction) + = $float =~ / (.*) \. (.*) /x; + + # Starting with one digit after the decimal point, + # create a test for each possible precision (number of + # digits past the decimal point) until well beyond the + # native number found on this machine. (If we started + # with 0 digits, it would be an integer, which could + # well match an unrelated table) + PLACE: + for my $i (1 .. $min_floating_slop + 3) { + my $table_name = sprintf("%.*f", $i, $float); + if ($i < $MIN_FRACTION_LENGTH) { + + # If the test case has fewer digits than the + # minimum acceptable precision, it shouldn't + # succeed, so we expect an error for it. + # E.g., 2/3 = .7 at one decimal point, and we + # shouldn't say it matches .7. We should make + # it be .667 at least before agreeing that the + # intent was to match 2/3. But at the + # less-than- acceptable level of precision, it + # might actually match an unrelated number. + # So don't generate a test case if this + # conflating is possible. In our example, we + # don't want 2/3 matching 7/10, if there is + # a 7/10 code point. + for my $existing + (keys %nv_floating_to_rational) + { + next PLACE + if abs($table_name - $existing) + < $MAX_FLOATING_SLOP; + } + generate_error($OUT, + $property_name, + $table_name, + 1 # 1 => already an error + ); + } + else { + + # Here the number of digits exceeds the + # minimum we think is needed. So generate a + # success test case for it. + generate_tests($OUT, + $property_name, + $table_name, + $valid, + $invalid, + $warning, + ); + } + } } } + } + } + } + print $OUT "Finished();\n"; + close $OUT; + return; +} - my $TypeToShow = $Type eq 'Is' ? "" : $Type; - my $OrigProp; +# This is a list of the input files and how to handle them. The files are +# processed in their order in this list. Some reordering is possible if +# desired, but the v0 files should be first, and the extracted before the +# others except DAge.txt (as data in an extracted file can be over-ridden by +# the non-extracted. Some other files depend on data derived from an earlier +# file, like UnicodeData requires data from Jamo, and the case changing and +# folding requires data from Unicode. Mostly, it safest to order by first +# version releases in (except the Jamo). DAge.txt is read before the +# extracted ones because of the rarely used feature $compare_versions. In the +# unlikely event that there were ever an extracted file that contained the Age +# property information, it would have to go in front of DAge. +# +# The version strings allow the program to know whether to expect a file or +# not, but if a file exists in the directory, it will be processed, even if it +# is in a version earlier than expected, so you can copy files from a later +# release into an earlier release's directory. +my @input_file_objects = ( + Input_file->new('PropertyAliases.txt', v0, + Handler => \&process_PropertyAliases, + ), + Input_file->new(undef, v0, # No file associated with this + Progress_Message => 'Finishing Property Setup', + Handler => \&finish_property_setup, + ), + Input_file->new('PropValueAliases.txt', v0, + Handler => \&process_PropValueAliases, + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new('DAge.txt', v3.2.0, + Has_Missings_Defaults => $NOT_IGNORED, + Property => 'Age' + ), + Input_file->new("${EXTRACTED}DGeneralCategory.txt", v3.1.0, + Property => 'General_Category', + ), + Input_file->new("${EXTRACTED}DCombiningClass.txt", v3.1.0, + Property => 'Canonical_Combining_Class', + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new("${EXTRACTED}DNumType.txt", v3.1.0, + Property => 'Numeric_Type', + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new("${EXTRACTED}DEastAsianWidth.txt", v3.1.0, + Property => 'East_Asian_Width', + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new("${EXTRACTED}DLineBreak.txt", v3.1.0, + Property => 'Line_Break', + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new("${EXTRACTED}DBidiClass.txt", v3.1.1, + Property => 'Bidi_Class', + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new("${EXTRACTED}DDecompositionType.txt", v3.1.0, + Property => 'Decomposition_Type', + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new("${EXTRACTED}DBinaryProperties.txt", v3.1.0), + Input_file->new("${EXTRACTED}DNumValues.txt", v3.1.0, + Property => 'Numeric_Value', + Each_Line_Handler => \&filter_numeric_value_line, + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new("${EXTRACTED}DJoinGroup.txt", v3.1.0, + Property => 'Joining_Group', + Has_Missings_Defaults => $NOT_IGNORED, + ), + + Input_file->new("${EXTRACTED}DJoinType.txt", v3.1.0, + Property => 'Joining_Type', + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new('Jamo.txt', v2.0.0, + Property => 'Jamo_Short_Name', + Each_Line_Handler => \&filter_jamo_line, + ), + Input_file->new('UnicodeData.txt', v1.1.5, + Pre_Handler => \&setup_UnicodeData, + + # We clean up this file for some early versions. + Each_Line_Handler => [ (($v_version lt v2.0.0 ) + ? \&filter_v1_ucd + : ($v_version eq v2.1.5) + ? \&filter_v2_1_5_ucd + : undef), + + # And the main filter + \&filter_UnicodeData_line, + ], + EOF_Handler => \&EOF_UnicodeData, + ), + Input_file->new('ArabicShaping.txt', v2.0.0, + Each_Line_Handler => + [ ($v_version lt 4.1.0) + ? \&filter_old_style_arabic_shaping + : undef, + \&filter_arabic_shaping_line, + ], + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new('Blocks.txt', v2.0.0, + Property => 'Block', + Has_Missings_Defaults => $NOT_IGNORED, + Each_Line_Handler => \&filter_blocks_lines + ), + Input_file->new('PropList.txt', v2.0.0, + Each_Line_Handler => (($v_version lt v3.1.0) + ? \&filter_old_style_proplist + : undef), + ), + Input_file->new('Unihan.txt', v2.0.0, + Pre_Handler => \&setup_unihan, + Optional => 1, + Each_Line_Handler => \&filter_unihan_line, + ), + Input_file->new('SpecialCasing.txt', v2.1.8, + Each_Line_Handler => \&filter_special_casing_line, + Pre_Handler => \&setup_special_casing, + ), + Input_file->new( + 'LineBreak.txt', v3.0.0, + Has_Missings_Defaults => $NOT_IGNORED, + Property => 'Line_Break', + # Early versions had problematic syntax + Each_Line_Handler => (($v_version lt v3.1.0) + ? \&filter_early_ea_lb + : undef), + ), + Input_file->new('EastAsianWidth.txt', v3.0.0, + Property => 'East_Asian_Width', + Has_Missings_Defaults => $NOT_IGNORED, + # Early versions had problematic syntax + Each_Line_Handler => (($v_version lt v3.1.0) + ? \&filter_early_ea_lb + : undef), + ), + Input_file->new('CompositionExclusions.txt', v3.0.0, + Property => 'Composition_Exclusion', + ), + Input_file->new('BidiMirroring.txt', v3.0.1, + Property => 'Bidi_Mirroring_Glyph', + ), + Input_file->new('CaseFolding.txt', v3.0.1, + Pre_Handler => \&setup_case_folding, + Each_Line_Handler => + [ ($v_version lt v3.1.0) + ? \&filter_old_style_case_folding + : undef, + \&filter_case_folding_line + ], + Post_Handler => \&post_fold, + ), + Input_file->new('DCoreProperties.txt', v3.1.0, + # 5.2 changed this file + Has_Missings_Defaults => (($v_version ge v5.2.0) + ? $NOT_IGNORED + : $NO_DEFAULTS), + ), + Input_file->new('Scripts.txt', v3.1.0, + Property => 'Script', + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new('DNormalizationProps.txt', v3.1.0, + Has_Missings_Defaults => $NOT_IGNORED, + Each_Line_Handler => (($v_version lt v4.0.1) + ? \&filter_old_style_normalization_lines + : undef), + ), + Input_file->new('HangulSyllableType.txt', v4.0.0, + Has_Missings_Defaults => $NOT_IGNORED, + Property => 'Hangul_Syllable_Type'), + Input_file->new("$AUXILIARY/WordBreakProperty.txt", v4.1.0, + Property => 'Word_Break', + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new("$AUXILIARY/GraphemeBreakProperty.txt", v4.1.0, + Property => 'Grapheme_Cluster_Break', + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new("$AUXILIARY/SentenceBreakProperty.txt", v4.1.0, + Property => 'Sentence_Break', + Has_Missings_Defaults => $NOT_IGNORED, + ), + Input_file->new('NamedSequences.txt', v4.1.0, + Handler => \&process_NamedSequences + ), + Input_file->new('NameAliases.txt', v5.0.0, + Property => 'Name_Alias', + ), + Input_file->new('UnihanIndicesDictionary.txt', v5.2.0, + Optional => 1, + Each_Line_Handler => \&filter_unihan_line, + ), + Input_file->new('UnihanDataDictionaryLike.txt', v5.2.0, + Optional => 1, + Each_Line_Handler => \&filter_unihan_line, + ), + Input_file->new('UnihanIRGSources.txt', v5.2.0, + Optional => 1, + Pre_Handler => \&setup_unihan, + Each_Line_Handler => \&filter_unihan_line, + ), + Input_file->new('UnihanNumericValues.txt', v5.2.0, + Optional => 1, + Each_Line_Handler => \&filter_unihan_line, + ), + Input_file->new('UnihanOtherMappings.txt', v5.2.0, + Optional => 1, + Each_Line_Handler => \&filter_unihan_line, + ), + Input_file->new('UnihanRadicalStrokeCounts.txt', v5.2.0, + Optional => 1, + Each_Line_Handler => \&filter_unihan_line, + ), + Input_file->new('UnihanReadings.txt', v5.2.0, + Optional => 1, + Each_Line_Handler => \&filter_unihan_line, + ), + Input_file->new('UnihanVariants.txt', v5.2.0, + Optional => 1, + Each_Line_Handler => \&filter_unihan_line, + ), +); - $Comment = "This file supports:\n"; - for my $N (@Supported) - { - my $IsFuzzy = $FuzzyNames{$Type}->{$N}; - my $Prop = "\\p{$TypeToShow$Name}"; - $OrigProp = $Prop if not $OrigProp; #cache for aliases - if ($IsFuzzy) { - $Comment .= "\t$Prop (and fuzzy permutations)\n"; - } else { - $Comment .= "\t$Prop\n"; - } - my $MyDesc = ($N eq $Name) ? $Desc : "Alias for $OrigProp ($Desc)"; +# End of all the preliminaries. +# Do it... - push @MAP, sprintf("%s %-42s %s\n", - $IsFuzzy ? '*' : ' ', $Prop, $MyDesc); - } - if ($Desc) { - $Comment .= "\nMeaning: $Desc\n"; - } +if ($compare_versions) { + Carp::my_carp(<Write(["lib","gc_sc","$filename.pl"], $Comment); +# Put into %potential_files a list of all the files in the directory structure +# that could be inputs to this program, excluding those that we should ignore. +# Also don't consider test files. Use absolute file names because it makes it +# easier across machine types. +my @ignored_files_full_names = map { File::Spec->rel2abs( + internal_file_to_platform($_)) + } keys %ignored_files; +File::Find::find({ + wanted=>sub { + return unless /\.txt$/i; + return if /Test\.txt$/i; + my $full = File::Spec->rel2abs($_); + $potential_files{$full} = 1 + if ! grep { $full eq $_ } @ignored_files_full_names; + return; + } +}, File::Spec->curdir()); - ## and register it - $RawNameToFile{$Name} = $filename; - RegisterFileForName($Type => $Name, $IsFuzzy, $filename); +my @mktables_list_output_files; - if ($IsFuzzy) - { - my $CName = CanonicalName($Type . '_'. $Name); - $FuzzyNameToTest{$Name} = $Table if !$FuzzyNameToTest{$Name}; - $FuzzyNameToTest{$CName} = $Table if !$FuzzyNameToTest{$CName}; - } else { - $ExactNameToTest{$Name} = $Table; +if ($write_unchanged_files) { + print "Not checking file list '$file_list'.\n" if $verbosity >= $VERBOSE; +} +else { + print "Reading file list '$file_list'\n" if $verbosity >= $VERBOSE; + my $file_handle; + if (! open $file_handle,"<",$file_list) { + Carp::my_carp("Failed to open '$file_list', turning on -globlist option instead: $!"); + $glob_list = 1; + } + else { + my @input; + + # Read and parse mktables.lst, placing the results from the first part + # into @input, and the second part into @mktables_list_output_files + for my $list ( \@input, \@mktables_list_output_files ) { + while (<$file_handle>) { + s/^ \s+ | \s+ $//xg; + next if /^ \s* (?: \# .* )? $/x; + last if /^ =+ $/x; + my ( $file ) = split /\t/; + push @$list, $file; } - + @$list = uniques(@$list); + next; } - ## Register aliase info - for my $Name (sort {length $a <=> length $b} keys %{$AliasInfo{$Type}}) - { - my $Alias = $AliasInfo{$Type}->{$Name}; - my $IsFuzzy = $FuzzyNames{$Type}->{$Alias}; - my $filename = $RawNameToFile{$Name}; - die "oops [$Alias]->[$Name]" if not $filename; - RegisterFileForName($Type => $Alias, $IsFuzzy, $filename); - - my $Table = $TableInfo{$Type}->{$Name}; - die "oops" if not $Table; - if ($IsFuzzy) - { - my $CName = CanonicalName($Type .'_'. $Alias); - $FuzzyNameToTest{$Alias} = $Table if !$FuzzyNameToTest{$Alias}; - $FuzzyNameToTest{$CName} = $Table if !$FuzzyNameToTest{$CName}; - } else { - $ExactNameToTest{$Alias} = $Table; - } - } - } + # Look through all the input files + foreach my $input (@input) { + next if $input eq 'version'; # Already have checked this. - ## - ## Write out the property list - ## - { - my @OUT = ( - "##\n", - "## This file created by $0\n", - "## List of built-in \\p{...}/\\P{...} properties.\n", - "##\n", - "## '*' means name may be 'fuzzy'\n", - "##\n\n", - sort { substr($a,2) cmp substr($b, 2) } @MAP, - ); - WriteIfChanged('Properties', @OUT); - } - - ## Write Exact.pl - { - my @OUT = ( - $HEADER, - "##\n", - "## Data in this file used by ../utf8_heavy.pl\n", - "##\n\n", - "## Mapping from name to filename in ./lib/gc_sc\n", - "%utf8::Exact = (\n", - ); - - $Exact{InGreek} = 'InGreekA'; # this is evil kludge - for my $Name (sort keys %Exact) - { - my $File = $Exact{$Name}; - $Name = $Name =~ m/\W/ ? qq/'$Name'/ : " $Name "; - my $Text = sprintf("%-15s => %s,\n", $Name, qq/'$File'/); - push @OUT, Text::Tabs::unexpand($Text); - } - push @OUT, ");\n1;\n"; + # Ignore if doesn't exist. The checking about whether we care or + # not is done via the Input_file object. + next if ! file_exists($input); - WriteIfChanged('Exact.pl', @OUT); + # The paths are stored with relative names, and with '/' as the + # delimiter; convert to absolute on this machine + my $full = File::Spec->rel2abs(internal_file_to_platform($input)); + $potential_files{$full} = 1 + if ! grep { $full eq $_ } @ignored_files_full_names; + } } - ## Write Canonical.pl - { - my @OUT = ( - $HEADER, - "##\n", - "## Data in this file used by ../utf8_heavy.pl\n", - "##\n\n", - "## Mapping from lc(canonical name) to filename in ./lib\n", - "%utf8::Canonical = (\n", - ); - my $Trail = ""; ## used just to keep the spacing pretty - for my $Name (sort keys %Canonical) - { - my $File = $Canonical{$Name}; - if ($CaComment{$Name}) { - push @OUT, "\n" if not $Trail; - push @OUT, " # $CaComment{$Name}\n"; - $Trail = "\n"; - } else { - $Trail = ""; + close $file_handle; +} + +if ($glob_list) { + + # Here wants to process all .txt files in the directory structure. + # Convert them to full path names. They are stored in the platform's + # relative style + my @known_files = map { File::Spec->rel2abs($_->file) } + @input_file_objects; + + my @unknown_input_files; + foreach my $file (keys %potential_files) { + next if grep { $file eq $_ } @known_files; + + # Here, the file is unknown to us. Get relative path name + $file = File::Spec->abs2rel($file); + push @unknown_input_files, $file; + + # What will happen is we create a data structure for it, and add it to + # the list of input files to process. First get the subdirectories + # into an array + my (undef, $directories, undef) = File::Spec->splitpath($file); + $directories =~ s;/$;;; # Can have extraneous trailing '/' + my @directories = File::Spec->splitdir($directories); + + # If the file isn't extracted (meaning none of the directories is the + # extracted one), just add it to the end of the list of inputs. + if (! grep { $EXTRACTED_DIR eq $_ } @directories) { + push @input_file_objects, Input_file->new($file); + } + else { + + # Here, the file is extracted. It needs to go ahead of most other + # processing. Search for the first input file that isn't a + # special required property (that is, find one whose first_release + # is non-0), and isn't extracted. Also, the Age property file is + # processed before the extracted ones, just in case + # $compare_versions is set. + for (my $i = 0; $i < @input_file_objects; $i++) { + if ($input_file_objects[$i]->first_released ne v0 + && $input_file_objects[$i]->file ne 'DAge.txt' + && $input_file_objects[$i]->file !~ /$EXTRACTED_DIR/) + { + splice @input_file_objects, $i, 0, Input_file->new($file); + last; + } } - $Name = $Name =~ m/\W/ ? qq/'$Name'/ : " $Name "; - my $Text = sprintf(" %-41s => %s,\n$Trail", $Name, qq/'$File'/); - push @OUT, Text::Tabs::unexpand($Text); + } - push @OUT, ");\n1\n"; - WriteIfChanged('Canonical.pl', @OUT); } + if (@unknown_input_files) { + print STDERR simple_fold(join_line(<file; + next if ! defined $file; # Not all objects have files + next if $object->optional && ! -e $file; + push @input_files, $file; +} -sub SpecialCasing_txt() -{ - # - # Read in the special cases. - # - - my %CaseInfo; +if ( $verbosity >= $VERBOSE ) { + print "Expecting ".scalar( @input_files )." input files. ", + "Checking ".scalar( @mktables_list_output_files )." output files.\n"; +} - if (not open IN, "SpecialCasing.txt") { - die "$0: SpecialCasing.txt: $!\n"; +# We set $youngest to be the most recently changed input file, including this +# program itself (done much earlier in this file) +foreach my $in (@input_files) { + my $age = -M $in; + next unless defined $age; # Keep going even if missing a file + $youngest = $age if $age < $youngest; + + # See that the input files have distinct names, to warn someone if they + # are adding a new one + if ($make_list) { + my ($volume, $directories, $file ) = File::Spec->splitpath($in); + $directories =~ s;/$;;; # Can have extraneous trailing '/' + my @directories = File::Spec->splitdir($directories); + my $base = $file =~ s/\.txt$//; + construct_filename($file, 'mutable', \@directories); } - while () { - next unless /^[0-9A-Fa-f]+;/; - s/\#.*//; - s/\s+$//; +} - my ($code, $lower, $title, $upper, $condition) = split(/\s*;\s*/); +my $ok = ! $write_unchanged_files + && scalar @mktables_list_output_files; # If none known, rebuild - if ($condition) { # not implemented yet - print "# SKIPPING $_\n" if $Verbose; - next; +# Now we check to see if any output files are older than youngest, if +# they are, we need to continue on, otherwise we can presumably bail. +if ($ok) { + foreach my $out (@mktables_list_output_files) { + if ( ! file_exists($out)) { + print "'$out' is missing.\n" if $verbosity >= $VERBOSE; + $ok = 0; + last; + } + #local $to_trace = 1 if main::DEBUG; + trace $youngest, -M $out if main::DEBUG && $to_trace; + if ( -M $out > $youngest ) { + #trace "$out: age: ", -M $out, ", youngest: $youngest\n" if main::DEBUG && $to_trace; + print "'$out' is too old.\n" if $verbosity >= $VERBOSE; + $ok = 0; + last; } - - # Wait until all the special cases have been read since - # they are not listed in numeric order. - my $ix = hex($code); - push @{$CaseInfo{Lower}}, [ $ix, $code, $lower ] - unless $code eq $lower; - push @{$CaseInfo{Title}}, [ $ix, $code, $title ] - unless $code eq $title; - push @{$CaseInfo{Upper}}, [ $ix, $code, $upper ] - unless $code eq $upper; } - close IN; +} +if ($ok) { + print "Files seem to be ok, not bothering to rebuild.\n"; + exit(0); +} +print "Must rebuild tables.\n" if $verbosity >= $VERBOSE; - # Now write out the special cases properties in their code point order. - # Prepend them to the To/{Upper,Lower,Title}.pl. +# Ready to do the major processing. First create the perl pseudo-property. +$perl = Property->new('perl', Type => $NON_STRING, Perl_Extension => 1); - for my $case (qw(Lower Title Upper)) - { - my $NormalCase = do "To/$case.pl" || die "$0: $@\n"; - - my @OUT = - ( - $HEADER, $INTERNAL_ONLY, "\n", - "# The key: UTF-8 _bytes_, the value: UTF-8 (speed hack)\n", - "%utf8::ToSpec$case =\n(\n", - ); - - for my $prop (sort { $a->[0] <=> $b->[0] } @{$CaseInfo{$case}}) { - my ($ix, $code, $to) = @$prop; - my $tostr = - join "", map { sprintf "\\x{%s}", $_ } split ' ', $to; - push @OUT, sprintf qq["%s" => "$tostr",\n], join("", map { sprintf "\\x%02X", $_ } unpack("U0C*", pack("U", $ix))); - # Remove any single-character mappings for - # the same character since we are going for - # the special casing rules. - $NormalCase =~ s/^$code\t\t\w+\n//m; - } - push @OUT, ( - ");\n\n", - "return <<'END';\n", - $NormalCase, - "END\n" - ); - WriteIfChanged(["To","$case.pl"], @OUT); - } +# Process each input file +foreach my $file (@input_file_objects) { + $file->run; } -# -# Read in the case foldings. -# -# We will do full case folding, C + F + I (see CaseFolding.txt). Note that -# there are no I entries starting with Unicode 3.2, but leaving it in allows -# for backward compatibility. -# -sub CaseFolding_txt() -{ - if (not open IN, "CaseFolding.txt") { - die "$0: CaseFolding.txt: $!\n"; - } +# Finish the table generation. - my $Fold = Table->New(); - my %Fold; +print "Finishing processing Unicode properties\n" if $verbosity >= $PROGRESS; +finish_Unicode(); - while () { - # Skip status 'S', simple case folding - next unless /^([0-9A-Fa-f]+)\s*;\s*([CFI])\s*;\s*([0-9A-Fa-f]+(?: [0-9A-Fa-f]+)*)\s*;/; +print "Compiling Perl properties\n" if $verbosity >= $PROGRESS; +compile_perl(); - my ($code, $status, $fold) = (hex($1), $2, $3); +print "Creating Perl synonyms\n" if $verbosity >= $PROGRESS; +add_perl_synonyms(); - if ($status eq 'C') { # Common: one-to-one folding - # No append() since several codes may fold into one. - $Fold->RawAppendRange($code, $code, $fold); - } else { # F: full, or I: dotted uppercase I -> dotless lowercase I - $Fold{$code} = $fold; - } - } - close IN; +print "Writing tables\n" if $verbosity >= $PROGRESS; +write_all_tables(); - $Fold->Write("To/Fold.pl"); +# Write mktables.lst +if ( $file_list and $make_list ) { - # - # Prepend the special foldings to the common foldings. - # - my $CommonFold = do "To/Fold.pl" || die "$0: To/Fold.pl: $!\n"; - - my @OUT = - ( - $HEADER, $INTERNAL_ONLY, "\n", - "# The key: UTF-8 _bytes_, the value: UTF-8 (speed hack)\n", - "%utf8::ToSpecFold =\n(\n", - ); - for my $code (sort { $a <=> $b } keys %Fold) { - my $foldstr = - join "", map { sprintf "\\x{%s}", $_ } split ' ', $Fold{$code}; - push @OUT, sprintf qq["%s" => "$foldstr",\n], join("", map { sprintf "\\x%02X", $_ } unpack("U0C*", pack("U", $code))); - } - push @OUT, ( - ");\n\n", - "return <<'END';\n", - $CommonFold, - "END\n", - ); - - WriteIfChanged(["To","Fold.pl"], @OUT); -} - -## Do it.... - -Build_Aliases(); -UnicodeData_Txt(); -PropList_txt(); - -Scripts_txt(); -Blocks_txt(); - -WriteAllMappings(); - -LineBreak_Txt(); -ArabicShaping_txt(); -EastAsianWidth_txt(); -HangulSyllableType_txt(); -Jamo_txt(); -SpecialCasing_txt(); -CaseFolding_txt(); - -if ( $FileList and $MakeList ) { - - print "Updating '$FileList'\n" - if ($Verbose); - - open my $ofh,">",$FileList - or die "Can't write to '$FileList':$!"; - print $ofh <<"EOFHEADER"; -# -# mktables.lst -- File list for mktables. + print "Updating '$file_list'\n" if $verbosity >= $PROGRESS; + foreach my $file (@input_files, @files_actually_output) { + my (undef, $directories, $file) = File::Spec->splitpath($file); + my @directories = File::Spec->splitdir($directories); + $file = join '/', @directories, $file; + } + + my $ofh; + if (! open $ofh,">",$file_list) { + Carp::my_carp("Can't write to '$file_list'. Skipping: $!"); + return + } + else { + print $ofh <<"END"; +# +# $file_list -- File list for $0. # # Autogenerated on @{[scalar localtime]} # # - First section is input files -# (mktables itself is automatically included) +# ($0 itself is not listed but is automatically considered an input) # - Section seperator is /^=+\$/ # - Second section is a list of output files. # - Lines matching /^\\s*#/ are treated as comments @@ -2235,91 +13700,172 @@ if ( $FileList and $MakeList ) { # Input files: -EOFHEADER - my @input=("version",glob('*.txt')); - print $ofh "$_\n" for - sort(@input), - "\n=================================\n", - "# Output files:\n", - # special files - "Properties"; - - - require File::Find; - my @output_files; - File::Find::find({ - no_chdir=>1, - wanted=>sub { - if (/\.pl$/) { - s!^\./!!; - push @output_files, "$_\n"; - } - }, - },"."); - - print $ofh sort @output_files; - print $ofh "\n# ",scalar(@input)," input files\n", - "# ",scalar(@output_files)+1," output files\n\n", - "# End list\n"; - close $ofh - or warn "Failed to close $ofh: $!"; - - print "Filelist has ",scalar(@input)," input files and ", - scalar(@output_files)+1," output files\n" - if $Verbose; -} -print "All done\n" if $Verbose; +END + print $ofh "$_\n" for sort(@input_files); + print $ofh "\n=================================\n# Output files:\n\n"; + print $ofh "$_\n" for sort @files_actually_output; + print $ofh "\n# ",scalar(@input_files)," input files\n", + "# ",scalar(@files_actually_output)+1," output files\n\n", + "# End list\n"; + close $ofh + or Carp::my_carp("Failed to close $ofh: $!"); + + print "Filelist has ",scalar(@input_files)," input files and ", + scalar(@files_actually_output)+1," output files\n" + if $verbosity >= $VERBOSE; + } +} + +# Output these warnings unless -q explicitly specified. +if ($verbosity >= $NORMAL_VERBOSITY) { + if (@unhandled_properties) { + print "\nProperties and tables that unexpectedly have no code points\n"; + foreach my $property (sort @unhandled_properties) { + print $property, "\n"; + } + } + + if (%potential_files) { + print "\nInput files that are not considered:\n"; + foreach my $file (sort keys %potential_files) { + print File::Spec->abs2rel($file), "\n"; + } + } + print "\nAll done\n" if $verbosity >= $VERBOSE; +} exit(0); -## TRAILING CODE IS USED BY MakePropTestScript() +# TRAILING CODE IS USED BY make_property_test_script() __DATA__ + use strict; use warnings; +# Test the \p{} regular expression constructs. This file is constructed by +# mktables from the tables it generates, so if mktables is buggy, this won't +# necessarily catch those bugs. Tests are generated for all feasible +# properties; a few aren't currently feasible; see is_code_point_usable() +# in mktables for details. + +# Standard test packages are not used because this manipulates SIG_WARN. It +# exits 0 if every non-skipped test succeeded; -1 if any failed. + my $Tests = 0; my $Fails = 0; +my $Skips = 0; + +my $non_ASCII = (ord('A') == 65); + +# The first 127 ASCII characters in ordinal order, with the ones that don't +# have Perl names (as of 5.8) replaced by dots. The 127th is used as the +# string delimiter +my $ascii_to_ebcdic = "\0......\a\b\t\n.\f\r.................. !\"#\$\%&'()*+,-./0123456789:;<=>?\@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"; +#for my $i (0..126) { +# print $i, ": ", substr($ascii_to_ebcdic, $i, 1), "\n"; +#} + +sub Expect($$$$) { + my $expected = shift; + my $ord = shift; + my $regex = shift; + my $warning_type = shift; # Type of warning message, like 'deprecated' + # or empty if none + my $line = (caller)[2]; + + # Convert the code point to hex form + my $string = sprintf "\"\\x{%04X}\"", $ord; + + # Convert the non-ASCII code points expressible as characters in Perl 5.8 + # to their ASCII equivalents, and skip the others. + if ($non_ASCII && $ord < 255) { + + # Dots are used as place holders in the conversion string for the + # non-convertible ones, so check for it first. + if ($ord == 0x2E) { + $ord = ord('.'); + } + elsif ($ord < 0x7F + # Any dots returned are non-convertible. + && ((my $char = substr($ascii_to_ebcdic, $ord, 1)) ne '.')) + { + #print STDERR "$ord, $char, \n"; + $ord = ord($char); + } + else { + $Tests++; + $Skips++; + print "ok $Tests - $string =~ $regex # Skipped: non-ASCII\n"; + return; + } + } -sub Expect($$$) -{ - my $Expect = shift; - my $String = shift; - my $Regex = shift; - my $Line = (caller)[2]; + # The first time through, use all warnings. + my @tests = ""; - $Tests++; - my $RegObj; - my $result = eval { - $RegObj = qr/$Regex/; - $String =~ $RegObj ? 1 : 0 - }; - - if (not defined $result) { - print "couldn't compile /$Regex/ on $0 line $Line: $@\n"; - $Fails++; - } elsif ($result ^ $Expect) { - print "bad result (expected $Expect) on $0 line $Line: $@\n"; - $Fails++; + # If the input should generate a warning, add another time through with + # them turned off + push @tests, "no warnings '$warning_type';" if $warning_type; + + foreach my $no_warnings (@tests) { + + # Store any warning messages instead of outputting them + local $SIG{__WARN__} = $SIG{__WARN__}; + my $warning_message; + $SIG{__WARN__} = sub { $warning_message = $_[0] }; + + $Tests++; + + # A string eval is needed because of the 'no warnings'. + # Assumes no parens in the regular expression + my $result = eval "$no_warnings + my \$RegObj = qr($regex); + $string =~ \$RegObj ? 1 : 0"; + if (not defined $result) { + print "not ok $Tests - couldn't compile /$regex/; line $line: $@\n"; + $Fails++; + } + elsif ($result ^ $expected) { + print "not ok $Tests - expected $expected but got $result for $string =~ qr/$regex/; line $line\n"; + $Fails++; + } + elsif ($warning_message) { + if (! $warning_type || ($warning_type && $no_warnings)) { + print "not ok $Tests - for qr/$regex/ did not expect warning message '$warning_message'; line $line\n"; + $Fails++; + } + else { + print "ok $Tests - expected and got a warning message for qr/$regex/; line $line\n"; + } + } + elsif ($warning_type && ! $no_warnings) { + print "not ok $Tests - for qr/$regex/ expected a $warning_type warning message, but got none; line $line\n"; + $Fails++; + } + else { + print "ok $Tests - got $result for $string =~ qr/$regex/; line $line\n"; + } } + return; } -sub Error($) -{ - my $Regex = shift; +sub Error($) { + my $regex = shift; $Tests++; - if (eval { 'x' =~ qr/$Regex/; 1 }) { + if (eval { 'x' =~ qr/$regex/; 1 }) { $Fails++; - my $Line = (caller)[2]; - print "expected error for /$Regex/ on $0 line $Line: $@\n"; + my $line = (caller)[2]; + print "not ok $Tests - re compiled ok, but expected error for qr/$regex/; line $line: $@\n"; } + else { + my $line = (caller)[2]; + print "ok $Tests - got and expected error for qr/$regex/; line $line\n"; + } + return; } -sub Finished() -{ - if ($Fails == 0) { - print "All $Tests tests passed.\n"; - exit(0); - } else { - print "$Tests tests, $Fails failed!\n"; - exit(-1); - } +sub Finished() { + print "1..$Tests.\n"; + exit($Fails ? -1 : 0); } + +Error('\p{Script=InGreek}'); # Bug #69018 diff --git a/lib/unicore/mktables.lst b/lib/unicore/mktables.lst index f4c55bb..db6b0b7 100644 --- a/lib/unicore/mktables.lst +++ b/lib/unicore/mktables.lst @@ -1,10 +1,10 @@ # -# mktables.lst -- File list for mktables. +# mktables.lst -- File list for lib/unicore/mktables. # -# Autogenerated on Mon Jan 26 17:57:26 2009 +# Autogenerated on Sat Nov 21 22:17:15 2009 # # - First section is input files -# (mktables itself is automatically included) +# (lib/unicore/mktables itself is not listed but is automatically considered an input) # - Section seperator is /^=+$/ # - Second section is a list of output files. # - Lines matching /^\s*#/ are treated as comments @@ -18,546 +18,812 @@ BidiMirroring.txt Blocks.txt CaseFolding.txt CompositionExclusions.txt +DAge.txt +DCoreProperties.txt +DNormalizationProps.txt EastAsianWidth.txt HangulSyllableType.txt -Index.txt Jamo.txt LineBreak.txt NameAliases.txt NamedSequences.txt -NamedSqProv.txt -NamesList.txt -NormalizationCorrections.txt PropList.txt PropValueAliases.txt PropertyAliases.txt -ReadMe.txt Scripts.txt SpecialCasing.txt -StandardizedVariants.txt UnicodeData.txt +auxiliary/GraphemeBreakProperty.txt +auxiliary/SentenceBreakProperty.txt +auxiliary/WordBreakProperty.txt +extracted/DBidiClass.txt +extracted/DBinaryProperties.txt +extracted/DCombiningClass.txt +extracted/DDecompositionType.txt +extracted/DEastAsianWidth.txt +extracted/DGeneralCategory.txt +extracted/DJoinGroup.txt +extracted/DJoinType.txt +extracted/DLineBreak.txt +extracted/DNumType.txt +extracted/DNumValues.txt version ================================= - # Output files: -Properties -Canonical.pl +../../pod/perluniprops.pod +../../t/re/uniprops.t CombiningClass.pl Decomposition.pl -Exact.pl +Heavy.pl Name.pl -PVA.pl +To/Bmg.pl To/Digit.pl To/Fold.pl To/Lower.pl To/Title.pl To/Upper.pl -lib/bc/AL.pl -lib/bc/AN.pl -lib/bc/B.pl -lib/bc/BN.pl -lib/bc/CS.pl -lib/bc/EN.pl -lib/bc/ES.pl -lib/bc/ET.pl -lib/bc/L.pl -lib/bc/LRE.pl -lib/bc/LRO.pl -lib/bc/NSM.pl -lib/bc/ON.pl -lib/bc/PDF.pl -lib/bc/R.pl -lib/bc/RLE.pl -lib/bc/RLO.pl -lib/bc/S.pl -lib/bc/WS.pl -lib/ccc/A.pl -lib/ccc/AL.pl -lib/ccc/AR.pl -lib/ccc/ATAR.pl -lib/ccc/ATB.pl -lib/ccc/ATBL.pl -lib/ccc/B.pl -lib/ccc/BL.pl -lib/ccc/BR.pl -lib/ccc/DA.pl -lib/ccc/DB.pl -lib/ccc/IS.pl -lib/ccc/KV.pl -lib/ccc/L.pl -lib/ccc/NK.pl -lib/ccc/NR.pl -lib/ccc/OV.pl -lib/ccc/R.pl -lib/ccc/VR.pl -lib/dt/Can.pl -lib/dt/Com.pl -lib/dt/Enc.pl -lib/dt/Fin.pl -lib/dt/Font.pl -lib/dt/Fra.pl -lib/dt/Init.pl -lib/dt/Iso.pl -lib/dt/Med.pl -lib/dt/Nar.pl -lib/dt/Nb.pl -lib/dt/Sml.pl -lib/dt/Sqr.pl -lib/dt/Sub.pl -lib/dt/Sup.pl -lib/dt/Vert.pl -lib/dt/Wide.pl -lib/ea/A.pl -lib/ea/F.pl -lib/ea/H.pl -lib/ea/N.pl -lib/ea/Na.pl -lib/ea/W.pl -lib/gc_sc/AHex.pl -lib/gc_sc/ASCII.pl -lib/gc_sc/Alnum.pl -lib/gc_sc/Alpha.pl -lib/gc_sc/Alphabet.pl -lib/gc_sc/Any.pl -lib/gc_sc/Arab.pl -lib/gc_sc/Armn.pl -lib/gc_sc/AsciiHex.pl -lib/gc_sc/Assigned.pl -lib/gc_sc/Bali.pl -lib/gc_sc/Beng.pl -lib/gc_sc/BidiC.pl -lib/gc_sc/BidiCont.pl -lib/gc_sc/Blank.pl -lib/gc_sc/Bopo.pl -lib/gc_sc/Brai.pl -lib/gc_sc/Bugi.pl -lib/gc_sc/Buhd.pl -lib/gc_sc/C.pl -lib/gc_sc/Canadian.pl -lib/gc_sc/Cari.pl -lib/gc_sc/Cc.pl -lib/gc_sc/Cf.pl -lib/gc_sc/Cham.pl -lib/gc_sc/Cher.pl -lib/gc_sc/Cn.pl -lib/gc_sc/Cntrl.pl -lib/gc_sc/Co.pl -lib/gc_sc/Copt.pl -lib/gc_sc/Cprt.pl -lib/gc_sc/Cs.pl -lib/gc_sc/Cyrl.pl -lib/gc_sc/Dash.pl -lib/gc_sc/Dash2.pl -lib/gc_sc/DefaultI.pl -lib/gc_sc/Dep.pl -lib/gc_sc/Deprecat.pl -lib/gc_sc/Deva.pl -lib/gc_sc/Dia.pl -lib/gc_sc/Diacriti.pl -lib/gc_sc/Digit.pl -lib/gc_sc/Dsrt.pl -lib/gc_sc/Ethi.pl -lib/gc_sc/Ext.pl -lib/gc_sc/Extender.pl -lib/gc_sc/Geor.pl -lib/gc_sc/Glag.pl -lib/gc_sc/Goth.pl -lib/gc_sc/Graph.pl -lib/gc_sc/Grek.pl -lib/gc_sc/Gujr.pl -lib/gc_sc/Guru.pl -lib/gc_sc/Hang.pl -lib/gc_sc/Hani.pl -lib/gc_sc/Hano.pl -lib/gc_sc/Hebr.pl -lib/gc_sc/Hex.pl -lib/gc_sc/HexDigit.pl -lib/gc_sc/Hira.pl -lib/gc_sc/HorizSpa.pl -lib/gc_sc/Hyphen.pl -lib/gc_sc/Hyphen2.pl -lib/gc_sc/IDSB.pl -lib/gc_sc/IDST.pl -lib/gc_sc/IdContin.pl -lib/gc_sc/IdStart.pl -lib/gc_sc/Ideo.pl -lib/gc_sc/Ideograp.pl -lib/gc_sc/IdsBinar.pl -lib/gc_sc/IdsTrina.pl -lib/gc_sc/InAegean.pl -lib/gc_sc/InAlphab.pl -lib/gc_sc/InAncie2.pl -lib/gc_sc/InAncie3.pl -lib/gc_sc/InAncien.pl -lib/gc_sc/InArabi2.pl -lib/gc_sc/InArabi3.pl -lib/gc_sc/InArabi4.pl -lib/gc_sc/InArabic.pl -lib/gc_sc/InArmeni.pl -lib/gc_sc/InArrows.pl -lib/gc_sc/InBaline.pl -lib/gc_sc/InBasicL.pl -lib/gc_sc/InBengal.pl -lib/gc_sc/InBlockE.pl -lib/gc_sc/InBopom2.pl -lib/gc_sc/InBopomo.pl -lib/gc_sc/InBoxDra.pl -lib/gc_sc/InBraill.pl -lib/gc_sc/InBugine.pl -lib/gc_sc/InBuhid.pl -lib/gc_sc/InByzant.pl -lib/gc_sc/InCarian.pl -lib/gc_sc/InCham.pl -lib/gc_sc/InCherok.pl -lib/gc_sc/InCjkCo2.pl -lib/gc_sc/InCjkCo3.pl -lib/gc_sc/InCjkCo4.pl -lib/gc_sc/InCjkCom.pl -lib/gc_sc/InCjkRad.pl -lib/gc_sc/InCjkStr.pl -lib/gc_sc/InCjkSym.pl -lib/gc_sc/InCjkUn2.pl -lib/gc_sc/InCjkUn3.pl -lib/gc_sc/InCjkUni.pl -lib/gc_sc/InCombi2.pl -lib/gc_sc/InCombi3.pl -lib/gc_sc/InCombi4.pl -lib/gc_sc/InCombin.pl -lib/gc_sc/InContro.pl -lib/gc_sc/InCoptic.pl -lib/gc_sc/InCounti.pl -lib/gc_sc/InCunei2.pl -lib/gc_sc/InCuneif.pl -lib/gc_sc/InCurren.pl -lib/gc_sc/InCyprio.pl -lib/gc_sc/InCyril2.pl -lib/gc_sc/InCyril3.pl -lib/gc_sc/InCyril4.pl -lib/gc_sc/InCyrill.pl -lib/gc_sc/InDesere.pl -lib/gc_sc/InDevana.pl -lib/gc_sc/InDingba.pl -lib/gc_sc/InDomino.pl -lib/gc_sc/InEnclo2.pl -lib/gc_sc/InEnclos.pl -lib/gc_sc/InEthio2.pl -lib/gc_sc/InEthio3.pl -lib/gc_sc/InEthiop.pl -lib/gc_sc/InGenera.pl -lib/gc_sc/InGeomet.pl -lib/gc_sc/InGeorg2.pl -lib/gc_sc/InGeorgi.pl -lib/gc_sc/InGlagol.pl -lib/gc_sc/InGothic.pl -lib/gc_sc/InGreekA.pl -lib/gc_sc/InGreekE.pl -lib/gc_sc/InGujara.pl -lib/gc_sc/InGurmuk.pl -lib/gc_sc/InHalfwi.pl -lib/gc_sc/InHangu2.pl -lib/gc_sc/InHangu3.pl -lib/gc_sc/InHangul.pl -lib/gc_sc/InHanuno.pl -lib/gc_sc/InHebrew.pl -lib/gc_sc/InHighPr.pl -lib/gc_sc/InHighSu.pl -lib/gc_sc/InHiraga.pl -lib/gc_sc/InIdeogr.pl -lib/gc_sc/InIpaExt.pl -lib/gc_sc/InKanbun.pl -lib/gc_sc/InKangxi.pl -lib/gc_sc/InKannad.pl -lib/gc_sc/InKatak2.pl -lib/gc_sc/InKataka.pl -lib/gc_sc/InKayahL.pl -lib/gc_sc/InKharos.pl -lib/gc_sc/InKhmer.pl -lib/gc_sc/InKhmerS.pl -lib/gc_sc/InLao.pl -lib/gc_sc/InLatin1.pl -lib/gc_sc/InLatin2.pl -lib/gc_sc/InLatin3.pl -lib/gc_sc/InLatin4.pl -lib/gc_sc/InLatin5.pl -lib/gc_sc/InLatinE.pl -lib/gc_sc/InLepcha.pl -lib/gc_sc/InLetter.pl -lib/gc_sc/InLimbu.pl -lib/gc_sc/InLinea2.pl -lib/gc_sc/InLinear.pl -lib/gc_sc/InLowSur.pl -lib/gc_sc/InLycian.pl -lib/gc_sc/InLydian.pl -lib/gc_sc/InMahjon.pl -lib/gc_sc/InMalaya.pl -lib/gc_sc/InMathe2.pl -lib/gc_sc/InMathem.pl -lib/gc_sc/InMisce2.pl -lib/gc_sc/InMisce3.pl -lib/gc_sc/InMisce4.pl -lib/gc_sc/InMisce5.pl -lib/gc_sc/InMiscel.pl -lib/gc_sc/InModifi.pl -lib/gc_sc/InMongol.pl -lib/gc_sc/InMusica.pl -lib/gc_sc/InMyanma.pl -lib/gc_sc/InNewTai.pl -lib/gc_sc/InNko.pl -lib/gc_sc/InNumber.pl -lib/gc_sc/InOgham.pl -lib/gc_sc/InOlChik.pl -lib/gc_sc/InOldIta.pl -lib/gc_sc/InOldPer.pl -lib/gc_sc/InOptica.pl -lib/gc_sc/InOriya.pl -lib/gc_sc/InOsmany.pl -lib/gc_sc/InPhagsP.pl -lib/gc_sc/InPhaist.pl -lib/gc_sc/InPhoeni.pl -lib/gc_sc/InPhone2.pl -lib/gc_sc/InPhonet.pl -lib/gc_sc/InPrivat.pl -lib/gc_sc/InRejang.pl -lib/gc_sc/InRunic.pl -lib/gc_sc/InSauras.pl -lib/gc_sc/InShavia.pl -lib/gc_sc/InSinhal.pl -lib/gc_sc/InSmallF.pl -lib/gc_sc/InSpacin.pl -lib/gc_sc/InSpecia.pl -lib/gc_sc/InSundan.pl -lib/gc_sc/InSupers.pl -lib/gc_sc/InSuppl2.pl -lib/gc_sc/InSuppl3.pl -lib/gc_sc/InSuppl4.pl -lib/gc_sc/InSuppl5.pl -lib/gc_sc/InSuppl6.pl -lib/gc_sc/InSupple.pl -lib/gc_sc/InSyloti.pl -lib/gc_sc/InSyriac.pl -lib/gc_sc/InTagalo.pl -lib/gc_sc/InTagban.pl -lib/gc_sc/InTags.pl -lib/gc_sc/InTaiLe.pl -lib/gc_sc/InTaiXua.pl -lib/gc_sc/InTamil.pl -lib/gc_sc/InTelugu.pl -lib/gc_sc/InThaana.pl -lib/gc_sc/InThai.pl -lib/gc_sc/InTibeta.pl -lib/gc_sc/InTifina.pl -lib/gc_sc/InUgarit.pl -lib/gc_sc/InUnifie.pl -lib/gc_sc/InVai.pl -lib/gc_sc/InVaria2.pl -lib/gc_sc/InVariat.pl -lib/gc_sc/InVertic.pl -lib/gc_sc/InYiRadi.pl -lib/gc_sc/InYiSyll.pl -lib/gc_sc/InYijing.pl -lib/gc_sc/JoinC.pl -lib/gc_sc/JoinCont.pl -lib/gc_sc/Kana.pl -lib/gc_sc/KayahLi.pl -lib/gc_sc/Khar.pl -lib/gc_sc/Khmr.pl -lib/gc_sc/Knda.pl -lib/gc_sc/L.pl -lib/gc_sc/LC.pl -lib/gc_sc/LOE.pl -lib/gc_sc/Laoo.pl -lib/gc_sc/Latn.pl -lib/gc_sc/Lepc.pl -lib/gc_sc/Limb.pl -lib/gc_sc/LinearB.pl -lib/gc_sc/Ll.pl -lib/gc_sc/Lm.pl -lib/gc_sc/Lo.pl -lib/gc_sc/LogicalO.pl -lib/gc_sc/Lower.pl -lib/gc_sc/Lowercas.pl -lib/gc_sc/Lt.pl -lib/gc_sc/Lu.pl -lib/gc_sc/Lyci.pl -lib/gc_sc/Lydi.pl -lib/gc_sc/M.pl -lib/gc_sc/Math.pl -lib/gc_sc/Mc.pl -lib/gc_sc/Me.pl -lib/gc_sc/Mlym.pl -lib/gc_sc/Mn.pl -lib/gc_sc/Mong.pl -lib/gc_sc/Mymr.pl -lib/gc_sc/N.pl -lib/gc_sc/NChar.pl -lib/gc_sc/Nd.pl -lib/gc_sc/NewTaiLu.pl -lib/gc_sc/Nkoo.pl -lib/gc_sc/Nl.pl -lib/gc_sc/No.pl -lib/gc_sc/Nonchara.pl -lib/gc_sc/OAlpha.pl -lib/gc_sc/ODI.pl -lib/gc_sc/OGrExt.pl -lib/gc_sc/OIDC.pl -lib/gc_sc/OIDS.pl -lib/gc_sc/OLower.pl -lib/gc_sc/OMath.pl -lib/gc_sc/OUpper.pl -lib/gc_sc/Ogam.pl -lib/gc_sc/OlChiki.pl -lib/gc_sc/OldItali.pl -lib/gc_sc/OldPersi.pl -lib/gc_sc/Orya.pl -lib/gc_sc/Osma.pl -lib/gc_sc/OtherAlp.pl -lib/gc_sc/OtherDef.pl -lib/gc_sc/OtherGra.pl -lib/gc_sc/OtherIdC.pl -lib/gc_sc/OtherIdS.pl -lib/gc_sc/OtherLow.pl -lib/gc_sc/OtherMat.pl -lib/gc_sc/OtherUpp.pl -lib/gc_sc/P.pl -lib/gc_sc/PatSyn.pl -lib/gc_sc/PatWS.pl -lib/gc_sc/PatternS.pl -lib/gc_sc/PatternW.pl -lib/gc_sc/Pc.pl -lib/gc_sc/Pd.pl -lib/gc_sc/Pe.pl -lib/gc_sc/PerlSpac.pl -lib/gc_sc/PerlWord.pl -lib/gc_sc/Pf.pl -lib/gc_sc/PhagsPa.pl -lib/gc_sc/Phnx.pl -lib/gc_sc/Pi.pl -lib/gc_sc/Po.pl -lib/gc_sc/PosixAln.pl -lib/gc_sc/PosixAlp.pl -lib/gc_sc/PosixBla.pl -lib/gc_sc/PosixCnt.pl -lib/gc_sc/PosixDig.pl -lib/gc_sc/PosixGra.pl -lib/gc_sc/PosixLow.pl -lib/gc_sc/PosixPri.pl -lib/gc_sc/PosixPun.pl -lib/gc_sc/PosixSpa.pl -lib/gc_sc/PosixUpp.pl -lib/gc_sc/Print.pl -lib/gc_sc/Ps.pl -lib/gc_sc/Punct.pl -lib/gc_sc/QMark.pl -lib/gc_sc/Qaai.pl -lib/gc_sc/Quotatio.pl -lib/gc_sc/Radical.pl -lib/gc_sc/Radical2.pl -lib/gc_sc/Rjng.pl -lib/gc_sc/Runr.pl -lib/gc_sc/S.pl -lib/gc_sc/SD.pl -lib/gc_sc/STerm.pl -lib/gc_sc/Saur.pl -lib/gc_sc/Sc.pl -lib/gc_sc/Shaw.pl -lib/gc_sc/Sinh.pl -lib/gc_sc/Sk.pl -lib/gc_sc/Sm.pl -lib/gc_sc/So.pl -lib/gc_sc/SoftDott.pl -lib/gc_sc/Space.pl -lib/gc_sc/SpacePer.pl -lib/gc_sc/Sterm2.pl -lib/gc_sc/Sund.pl -lib/gc_sc/SylotiNa.pl -lib/gc_sc/Syrc.pl -lib/gc_sc/Tagb.pl -lib/gc_sc/TaiLe.pl -lib/gc_sc/Taml.pl -lib/gc_sc/Telu.pl -lib/gc_sc/Term.pl -lib/gc_sc/Terminal.pl -lib/gc_sc/Tfng.pl -lib/gc_sc/Tglg.pl -lib/gc_sc/Thaa.pl -lib/gc_sc/Thai.pl -lib/gc_sc/Tibt.pl -lib/gc_sc/Title.pl -lib/gc_sc/UIdeo.pl -lib/gc_sc/Ugar.pl -lib/gc_sc/UnifiedI.pl -lib/gc_sc/Upper.pl -lib/gc_sc/Uppercas.pl -lib/gc_sc/VS.pl -lib/gc_sc/Vaii.pl -lib/gc_sc/Variatio.pl -lib/gc_sc/VertSpac.pl -lib/gc_sc/WSpace.pl -lib/gc_sc/WhiteSpa.pl -lib/gc_sc/Word.pl -lib/gc_sc/XDigit.pl -lib/gc_sc/Xsux.pl -lib/gc_sc/Yiii.pl -lib/gc_sc/Z.pl -lib/gc_sc/Zl.pl -lib/gc_sc/Zp.pl -lib/gc_sc/Zs.pl -lib/gc_sc/Zyyy.pl -lib/gc_sc/_CanonDC.pl -lib/gc_sc/_CaseIgn.pl -lib/gc_sc/_CombAbo.pl -lib/hst/L.pl -lib/hst/LV.pl -lib/hst/LVT.pl -lib/hst/T.pl -lib/hst/V.pl -lib/jt/C.pl -lib/jt/D.pl -lib/jt/R.pl -lib/jt/U.pl -lib/lb/AI.pl -lib/lb/AL.pl -lib/lb/B2.pl -lib/lb/BA.pl -lib/lb/BB.pl -lib/lb/BK.pl -lib/lb/CB.pl -lib/lb/CL.pl -lib/lb/CM.pl -lib/lb/CR.pl -lib/lb/EX.pl -lib/lb/GL.pl -lib/lb/H2.pl -lib/lb/H3.pl -lib/lb/HY.pl -lib/lb/ID.pl -lib/lb/IN.pl -lib/lb/IS.pl -lib/lb/JL.pl -lib/lb/JT.pl -lib/lb/JV.pl -lib/lb/LF.pl -lib/lb/NL.pl -lib/lb/NS.pl -lib/lb/NU.pl -lib/lb/OP.pl -lib/lb/PO.pl -lib/lb/PR.pl -lib/lb/QU.pl -lib/lb/SA.pl -lib/lb/SG.pl -lib/lb/SP.pl -lib/lb/SY.pl -lib/lb/WJ.pl -lib/lb/XX.pl -lib/lb/ZW.pl -lib/nt/De.pl -lib/nt/Di.pl -lib/nt/Nu.pl +lib/AHex/N.pl +lib/AHex/Y.pl +lib/Age/1_1.pl +lib/Age/2_0.pl +lib/Age/2_1.pl +lib/Age/3_0.pl +lib/Age/3_1.pl +lib/Age/3_2.pl +lib/Age/4_0.pl +lib/Age/4_1.pl +lib/Age/5_0.pl +lib/Age/5_1.pl +lib/Age/Unassign.pl +lib/Alpha/N.pl +lib/Alpha/Y.pl +lib/Bc/AL.pl +lib/Bc/AN.pl +lib/Bc/B.pl +lib/Bc/BN.pl +lib/Bc/CS.pl +lib/Bc/EN.pl +lib/Bc/ES.pl +lib/Bc/ET.pl +lib/Bc/L.pl +lib/Bc/LRE.pl +lib/Bc/LRO.pl +lib/Bc/NSM.pl +lib/Bc/ON.pl +lib/Bc/PDF.pl +lib/Bc/R.pl +lib/Bc/RLE.pl +lib/Bc/RLO.pl +lib/Bc/S.pl +lib/Bc/WS.pl +lib/BidiC/N.pl +lib/BidiC/Y.pl +lib/BidiM/N.pl +lib/BidiM/Y.pl +lib/Blk/ASCII.pl +lib/Blk/AegeanNu.pl +lib/Blk/Alphabet.pl +lib/Blk/Ancient2.pl +lib/Blk/AncientG.pl +lib/Blk/AncientS.pl +lib/Blk/Arabic.pl +lib/Blk/ArabicP2.pl +lib/Blk/ArabicPr.pl +lib/Blk/ArabicSu.pl +lib/Blk/Armenian.pl +lib/Blk/Arrows.pl +lib/Blk/Balinese.pl +lib/Blk/Bengali.pl +lib/Blk/BlockEle.pl +lib/Blk/Bopomof2.pl +lib/Blk/Bopomofo.pl +lib/Blk/BoxDrawi.pl +lib/Blk/BrailleP.pl +lib/Blk/Buginese.pl +lib/Blk/Buhid.pl +lib/Blk/Byzantin.pl +lib/Blk/CJKComp2.pl +lib/Blk/CJKComp3.pl +lib/Blk/CJKComp4.pl +lib/Blk/CJKCompa.pl +lib/Blk/CJKRadic.pl +lib/Blk/CJKStrok.pl +lib/Blk/CJKSymbo.pl +lib/Blk/CJKUnif2.pl +lib/Blk/CJKUnif3.pl +lib/Blk/CJKUnifi.pl +lib/Blk/Canadian.pl +lib/Blk/Carian.pl +lib/Blk/Cham.pl +lib/Blk/Cherokee.pl +lib/Blk/Combini2.pl +lib/Blk/Combini3.pl +lib/Blk/Combini4.pl +lib/Blk/Combinin.pl +lib/Blk/ControlP.pl +lib/Blk/Coptic.pl +lib/Blk/Counting.pl +lib/Blk/Cuneifo2.pl +lib/Blk/Cuneifor.pl +lib/Blk/Currency.pl +lib/Blk/CypriotS.pl +lib/Blk/Cyrilli2.pl +lib/Blk/Cyrilli3.pl +lib/Blk/Cyrilli4.pl +lib/Blk/Cyrillic.pl +lib/Blk/Deseret.pl +lib/Blk/Devanaga.pl +lib/Blk/Dingbats.pl +lib/Blk/DominoTi.pl +lib/Blk/Enclose2.pl +lib/Blk/Enclosed.pl +lib/Blk/Ethiopi2.pl +lib/Blk/Ethiopi3.pl +lib/Blk/Ethiopic.pl +lib/Blk/GeneralP.pl +lib/Blk/Geometri.pl +lib/Blk/Georgia2.pl +lib/Blk/Georgian.pl +lib/Blk/Glagolit.pl +lib/Blk/Gothic.pl +lib/Blk/Greek.pl +lib/Blk/GreekExt.pl +lib/Blk/Gujarati.pl +lib/Blk/Gurmukhi.pl +lib/Blk/Halfwidt.pl +lib/Blk/HangulCo.pl +lib/Blk/HangulJa.pl +lib/Blk/HangulSy.pl +lib/Blk/Hanunoo.pl +lib/Blk/Hebrew.pl +lib/Blk/HighPriv.pl +lib/Blk/HighSurr.pl +lib/Blk/Hiragana.pl +lib/Blk/IPAExten.pl +lib/Blk/Ideograp.pl +lib/Blk/Kanbun.pl +lib/Blk/KangxiRa.pl +lib/Blk/Kannada.pl +lib/Blk/Katakan2.pl +lib/Blk/Katakana.pl +lib/Blk/KayahLi.pl +lib/Blk/Kharosht.pl +lib/Blk/Khmer.pl +lib/Blk/KhmerSym.pl +lib/Blk/Lao.pl +lib/Blk/Latin1.pl +lib/Blk/LatinEx2.pl +lib/Blk/LatinEx3.pl +lib/Blk/LatinEx4.pl +lib/Blk/LatinEx5.pl +lib/Blk/LatinExt.pl +lib/Blk/Lepcha.pl +lib/Blk/Letterli.pl +lib/Blk/Limbu.pl +lib/Blk/LinearBI.pl +lib/Blk/LinearBS.pl +lib/Blk/LowSurro.pl +lib/Blk/Lycian.pl +lib/Blk/Lydian.pl +lib/Blk/MahjongT.pl +lib/Blk/Malayala.pl +lib/Blk/Mathema2.pl +lib/Blk/Mathemat.pl +lib/Blk/Miscell2.pl +lib/Blk/Miscell3.pl +lib/Blk/Miscell4.pl +lib/Blk/Miscell5.pl +lib/Blk/Miscella.pl +lib/Blk/Modifier.pl +lib/Blk/Mongolia.pl +lib/Blk/MusicalS.pl +lib/Blk/Myanmar.pl +lib/Blk/NKo.pl +lib/Blk/NewTaiLu.pl +lib/Blk/NoBlock.pl +lib/Blk/NumberFo.pl +lib/Blk/Ogham.pl +lib/Blk/OlChiki.pl +lib/Blk/OldItali.pl +lib/Blk/OldPersi.pl +lib/Blk/OpticalC.pl +lib/Blk/Oriya.pl +lib/Blk/Osmanya.pl +lib/Blk/PhagsPa.pl +lib/Blk/Phaistos.pl +lib/Blk/Phoenici.pl +lib/Blk/Phoneti2.pl +lib/Blk/Phonetic.pl +lib/Blk/PrivateU.pl +lib/Blk/Rejang.pl +lib/Blk/Runic.pl +lib/Blk/Saurasht.pl +lib/Blk/Shavian.pl +lib/Blk/Sinhala.pl +lib/Blk/SmallFor.pl +lib/Blk/SpacingM.pl +lib/Blk/Specials.pl +lib/Blk/Sundanes.pl +lib/Blk/Superscr.pl +lib/Blk/Supplem2.pl +lib/Blk/Supplem3.pl +lib/Blk/Supplem4.pl +lib/Blk/Supplem5.pl +lib/Blk/Supplem6.pl +lib/Blk/Suppleme.pl +lib/Blk/SylotiNa.pl +lib/Blk/Syriac.pl +lib/Blk/Tagalog.pl +lib/Blk/Tagbanwa.pl +lib/Blk/Tags.pl +lib/Blk/TaiLe.pl +lib/Blk/TaiXuanJ.pl +lib/Blk/Tamil.pl +lib/Blk/Telugu.pl +lib/Blk/Thaana.pl +lib/Blk/Thai.pl +lib/Blk/Tibetan.pl +lib/Blk/Tifinagh.pl +lib/Blk/Ugaritic.pl +lib/Blk/Vai.pl +lib/Blk/Variati2.pl +lib/Blk/Variatio.pl +lib/Blk/Vertical.pl +lib/Blk/YiRadica.pl +lib/Blk/YiSyllab.pl +lib/Blk/YijingHe.pl +lib/CE/N.pl +lib/CE/Y.pl +lib/Ccc/10.pl +lib/Ccc/103.pl +lib/Ccc/107.pl +lib/Ccc/11.pl +lib/Ccc/118.pl +lib/Ccc/12.pl +lib/Ccc/122.pl +lib/Ccc/129.pl +lib/Ccc/13.pl +lib/Ccc/130.pl +lib/Ccc/132.pl +lib/Ccc/14.pl +lib/Ccc/15.pl +lib/Ccc/16.pl +lib/Ccc/17.pl +lib/Ccc/18.pl +lib/Ccc/19.pl +lib/Ccc/20.pl +lib/Ccc/21.pl +lib/Ccc/214.pl +lib/Ccc/22.pl +lib/Ccc/23.pl +lib/Ccc/24.pl +lib/Ccc/25.pl +lib/Ccc/26.pl +lib/Ccc/27.pl +lib/Ccc/28.pl +lib/Ccc/29.pl +lib/Ccc/30.pl +lib/Ccc/31.pl +lib/Ccc/32.pl +lib/Ccc/33.pl +lib/Ccc/34.pl +lib/Ccc/35.pl +lib/Ccc/36.pl +lib/Ccc/84.pl +lib/Ccc/91.pl +lib/Ccc/A.pl +lib/Ccc/AL.pl +lib/Ccc/AR.pl +lib/Ccc/ATAR.pl +lib/Ccc/ATB.pl +lib/Ccc/ATBL.pl +lib/Ccc/B.pl +lib/Ccc/BL.pl +lib/Ccc/BR.pl +lib/Ccc/DA.pl +lib/Ccc/DB.pl +lib/Ccc/IS.pl +lib/Ccc/KV.pl +lib/Ccc/L.pl +lib/Ccc/NK.pl +lib/Ccc/NR.pl +lib/Ccc/OV.pl +lib/Ccc/R.pl +lib/Ccc/VR.pl +lib/CompEx/N.pl +lib/CompEx/Y.pl +lib/DI/N.pl +lib/DI/Y.pl +lib/Dash/N.pl +lib/Dash/Y.pl +lib/Dep/N.pl +lib/Dep/Y.pl +lib/Dia/N.pl +lib/Dia/Y.pl +lib/Dt/Com.pl +lib/Dt/Enc.pl +lib/Dt/Fin.pl +lib/Dt/Font.pl +lib/Dt/Fra.pl +lib/Dt/Init.pl +lib/Dt/Iso.pl +lib/Dt/Med.pl +lib/Dt/Nar.pl +lib/Dt/Nb.pl +lib/Dt/NonCanon.pl +lib/Dt/None.pl +lib/Dt/Sml.pl +lib/Dt/Sqr.pl +lib/Dt/Sub.pl +lib/Dt/Sup.pl +lib/Dt/Vert.pl +lib/Ea/A.pl +lib/Ea/F.pl +lib/Ea/H.pl +lib/Ea/N.pl +lib/Ea/Na.pl +lib/Ea/W.pl +lib/Ext/N.pl +lib/Ext/Y.pl +lib/GCB/CN.pl +lib/GCB/CR.pl +lib/GCB/EX.pl +lib/GCB/L.pl +lib/GCB/LF.pl +lib/GCB/LV.pl +lib/GCB/LVT.pl +lib/GCB/PP.pl +lib/GCB/SM.pl +lib/GCB/T.pl +lib/GCB/V.pl +lib/GCB/XX.pl +lib/Gc/C.pl +lib/Gc/Cc.pl +lib/Gc/Cf.pl +lib/Gc/Cn.pl +lib/Gc/Co.pl +lib/Gc/Cs.pl +lib/Gc/L.pl +lib/Gc/LC.pl +lib/Gc/Ll.pl +lib/Gc/Lm.pl +lib/Gc/Lo.pl +lib/Gc/Lt.pl +lib/Gc/Lu.pl +lib/Gc/M.pl +lib/Gc/Mc.pl +lib/Gc/Me.pl +lib/Gc/Mn.pl +lib/Gc/N.pl +lib/Gc/Nl.pl +lib/Gc/No.pl +lib/Gc/P.pl +lib/Gc/Pd.pl +lib/Gc/Pe.pl +lib/Gc/Pf.pl +lib/Gc/Pi.pl +lib/Gc/Po.pl +lib/Gc/Ps.pl +lib/Gc/S.pl +lib/Gc/Sc.pl +lib/Gc/Sk.pl +lib/Gc/Sm.pl +lib/Gc/So.pl +lib/Gc/Z.pl +lib/Gc/Zl.pl +lib/Gc/Zp.pl +lib/Gc/Zs.pl +lib/GrBase/N.pl +lib/GrBase/Y.pl +lib/GrExt/N.pl +lib/GrExt/Y.pl +lib/Hex/N.pl +lib/Hex/Y.pl +lib/Hst/NA.pl +lib/Hyphen/N.pl +lib/Hyphen/Y.pl +lib/IDC/N.pl +lib/IDC/Y.pl +lib/IDS/N.pl +lib/IDS/Y.pl +lib/IDSB/N.pl +lib/IDSB/Y.pl +lib/IDST/N.pl +lib/IDST/Y.pl +lib/Ideo/N.pl +lib/Ideo/Y.pl +lib/In/2_0.pl +lib/In/2_1.pl +lib/In/3_0.pl +lib/In/3_1.pl +lib/In/3_2.pl +lib/In/4_0.pl +lib/In/4_1.pl +lib/In/5_0.pl +lib/In/5_1.pl +lib/Jg/Ain.pl +lib/Jg/Alaph.pl +lib/Jg/Alef.pl +lib/Jg/Beh.pl +lib/Jg/Beth.pl +lib/Jg/Burushas.pl +lib/Jg/Dal.pl +lib/Jg/DalathRi.pl +lib/Jg/E.pl +lib/Jg/Fe.pl +lib/Jg/Feh.pl +lib/Jg/FinalSem.pl +lib/Jg/Gaf.pl +lib/Jg/Gamal.pl +lib/Jg/Hah.pl +lib/Jg/HamzaOnH.pl +lib/Jg/He.pl +lib/Jg/Heh.pl +lib/Jg/HehGoal.pl +lib/Jg/Heth.pl +lib/Jg/Kaf.pl +lib/Jg/Kaph.pl +lib/Jg/Khaph.pl +lib/Jg/KnottedH.pl +lib/Jg/Lam.pl +lib/Jg/Lamadh.pl +lib/Jg/Meem.pl +lib/Jg/Mim.pl +lib/Jg/NoJoinin.pl +lib/Jg/Noon.pl +lib/Jg/Nun.pl +lib/Jg/Pe.pl +lib/Jg/Qaf.pl +lib/Jg/Qaph.pl +lib/Jg/Reh.pl +lib/Jg/Reversed.pl +lib/Jg/Sad.pl +lib/Jg/Sadhe.pl +lib/Jg/Seen.pl +lib/Jg/Semkath.pl +lib/Jg/Shin.pl +lib/Jg/SwashKaf.pl +lib/Jg/SyriacWa.pl +lib/Jg/Tah.pl +lib/Jg/Taw.pl +lib/Jg/TehMarbu.pl +lib/Jg/Teth.pl +lib/Jg/Waw.pl +lib/Jg/Yeh.pl +lib/Jg/YehBarre.pl +lib/Jg/YehWithT.pl +lib/Jg/Yudh.pl +lib/Jg/YudhHe.pl +lib/Jg/Zain.pl +lib/Jg/Zhain.pl +lib/JoinC/N.pl +lib/JoinC/Y.pl +lib/Jt/C.pl +lib/Jt/D.pl +lib/Jt/R.pl +lib/Jt/T.pl +lib/Jt/U.pl +lib/LOE/N.pl +lib/Lb/AI.pl +lib/Lb/AL.pl +lib/Lb/B2.pl +lib/Lb/BA.pl +lib/Lb/BB.pl +lib/Lb/BK.pl +lib/Lb/CB.pl +lib/Lb/CL.pl +lib/Lb/CM.pl +lib/Lb/EX.pl +lib/Lb/GL.pl +lib/Lb/HY.pl +lib/Lb/ID.pl +lib/Lb/IN.pl +lib/Lb/IS.pl +lib/Lb/NL.pl +lib/Lb/NS.pl +lib/Lb/NU.pl +lib/Lb/OP.pl +lib/Lb/PO.pl +lib/Lb/PR.pl +lib/Lb/QU.pl +lib/Lb/SA.pl +lib/Lb/SG.pl +lib/Lb/SP.pl +lib/Lb/SY.pl +lib/Lb/WJ.pl +lib/Lb/XX.pl +lib/Lb/ZW.pl +lib/Lower/N.pl +lib/Lower/Y.pl +lib/Math/N.pl +lib/Math/Y.pl +lib/NChar/N.pl +lib/NChar/Y.pl +lib/NFCQC/Y.pl +lib/NFDQC/N.pl +lib/NFDQC/Y.pl +lib/NFKCQC/M.pl +lib/NFKCQC/N.pl +lib/NFKCQC/Y.pl +lib/NFKDQC/N.pl +lib/Nt/De.pl +lib/Nt/Di.pl +lib/Nt/Nu.pl +lib/Nv/0.pl +lib/Nv/1.pl +lib/Nv/10.pl +lib/Nv/100.pl +lib/Nv/1000.pl +lib/Nv/10000.pl +lib/Nv/100000.pl +lib/Nv/10000000.pl +lib/Nv/10000002.pl +lib/Nv/11.pl +lib/Nv/11_2.pl +lib/Nv/12.pl +lib/Nv/13.pl +lib/Nv/13_2.pl +lib/Nv/14.pl +lib/Nv/15.pl +lib/Nv/15_2.pl +lib/Nv/16.pl +lib/Nv/17.pl +lib/Nv/17_2.pl +lib/Nv/18.pl +lib/Nv/19.pl +lib/Nv/1_2.pl +lib/Nv/1_3.pl +lib/Nv/1_4.pl +lib/Nv/1_5.pl +lib/Nv/1_6.pl +lib/Nv/1_8.pl +lib/Nv/2.pl +lib/Nv/20.pl +lib/Nv/200.pl +lib/Nv/2000.pl +lib/Nv/20000.pl +lib/Nv/21.pl +lib/Nv/22.pl +lib/Nv/23.pl +lib/Nv/24.pl +lib/Nv/25.pl +lib/Nv/26.pl +lib/Nv/27.pl +lib/Nv/28.pl +lib/Nv/29.pl +lib/Nv/2_3.pl +lib/Nv/2_5.pl +lib/Nv/3.pl +lib/Nv/30.pl +lib/Nv/300.pl +lib/Nv/3000.pl +lib/Nv/30000.pl +lib/Nv/31.pl +lib/Nv/32.pl +lib/Nv/33.pl +lib/Nv/34.pl +lib/Nv/35.pl +lib/Nv/36.pl +lib/Nv/37.pl +lib/Nv/38.pl +lib/Nv/39.pl +lib/Nv/3_2.pl +lib/Nv/3_4.pl +lib/Nv/3_5.pl +lib/Nv/3_8.pl +lib/Nv/4.pl +lib/Nv/40.pl +lib/Nv/400.pl +lib/Nv/4000.pl +lib/Nv/40000.pl +lib/Nv/41.pl +lib/Nv/42.pl +lib/Nv/43.pl +lib/Nv/44.pl +lib/Nv/45.pl +lib/Nv/46.pl +lib/Nv/47.pl +lib/Nv/48.pl +lib/Nv/49.pl +lib/Nv/4_5.pl +lib/Nv/5.pl +lib/Nv/50.pl +lib/Nv/500.pl +lib/Nv/5000.pl +lib/Nv/50000.pl +lib/Nv/5_2.pl +lib/Nv/5_6.pl +lib/Nv/5_8.pl +lib/Nv/6.pl +lib/Nv/60.pl +lib/Nv/600.pl +lib/Nv/6000.pl +lib/Nv/60000.pl +lib/Nv/7.pl +lib/Nv/70.pl +lib/Nv/700.pl +lib/Nv/7000.pl +lib/Nv/70000.pl +lib/Nv/7_2.pl +lib/Nv/7_8.pl +lib/Nv/8.pl +lib/Nv/80.pl +lib/Nv/800.pl +lib/Nv/8000.pl +lib/Nv/80000.pl +lib/Nv/9.pl +lib/Nv/90.pl +lib/Nv/900.pl +lib/Nv/9000.pl +lib/Nv/90000.pl +lib/Nv/9_2.pl +lib/Nv/NaN.pl +lib/Nv/_1_2.pl +lib/OAlpha/N.pl +lib/OAlpha/Y.pl +lib/ODI/N.pl +lib/ODI/Y.pl +lib/OGrExt/N.pl +lib/OGrExt/Y.pl +lib/OIDC/N.pl +lib/OIDC/Y.pl +lib/OIDS/N.pl +lib/OIDS/Y.pl +lib/OLower/N.pl +lib/OLower/Y.pl +lib/OMath/N.pl +lib/OMath/Y.pl +lib/OUpper/N.pl +lib/OUpper/Y.pl +lib/PatSyn/N.pl +lib/PatSyn/Y.pl +lib/PatWS/N.pl +lib/PatWS/Y.pl +lib/Perl/Alnum.pl +lib/Perl/Any.pl +lib/Perl/Assigned.pl +lib/Perl/Blank.pl +lib/Perl/Cased.pl +lib/Perl/Graph.pl +lib/Perl/PerlSpac.pl +lib/Perl/PerlWord.pl +lib/Perl/PosixAln.pl +lib/Perl/PosixAlp.pl +lib/Perl/PosixBla.pl +lib/Perl/PosixCnt.pl +lib/Perl/PosixDig.pl +lib/Perl/PosixGra.pl +lib/Perl/PosixLow.pl +lib/Perl/PosixPri.pl +lib/Perl/PosixPun.pl +lib/Perl/PosixSpa.pl +lib/Perl/PosixUpp.pl +lib/Perl/Print.pl +lib/Perl/SpacePer.pl +lib/Perl/VertSpac.pl +lib/Perl/Word.pl +lib/Perl/_CaseIgn.pl +lib/Perl/_GCBExte.pl +lib/QMark/N.pl +lib/QMark/Y.pl +lib/Radical/N.pl +lib/Radical/Y.pl +lib/SB/AT.pl +lib/SB/CL.pl +lib/SB/EX.pl +lib/SB/FO.pl +lib/SB/LE.pl +lib/SB/LO.pl +lib/SB/SC.pl +lib/SB/SE.pl +lib/SB/ST.pl +lib/SB/Sp.pl +lib/SB/UP.pl +lib/SB/XX.pl +lib/SD/N.pl +lib/SD/Y.pl +lib/STerm/N.pl +lib/STerm/Y.pl +lib/Sc/Arab.pl +lib/Sc/Armn.pl +lib/Sc/Bali.pl +lib/Sc/Beng.pl +lib/Sc/Bopo.pl +lib/Sc/Bugi.pl +lib/Sc/Buhd.pl +lib/Sc/Cans.pl +lib/Sc/Cari.pl +lib/Sc/Cham.pl +lib/Sc/Cher.pl +lib/Sc/Copt.pl +lib/Sc/Cprt.pl +lib/Sc/Cyrl.pl +lib/Sc/Deva.pl +lib/Sc/Ethi.pl +lib/Sc/Geor.pl +lib/Sc/Glag.pl +lib/Sc/Goth.pl +lib/Sc/Grek.pl +lib/Sc/Gujr.pl +lib/Sc/Guru.pl +lib/Sc/Han.pl +lib/Sc/Hang.pl +lib/Sc/Hano.pl +lib/Sc/Hebr.pl +lib/Sc/Hira.pl +lib/Sc/Ital.pl +lib/Sc/Kana.pl +lib/Sc/Khar.pl +lib/Sc/Khmr.pl +lib/Sc/Knda.pl +lib/Sc/Lao.pl +lib/Sc/Latn.pl +lib/Sc/Lepc.pl +lib/Sc/Limb.pl +lib/Sc/Linb.pl +lib/Sc/Lyci.pl +lib/Sc/Lydi.pl +lib/Sc/Mlym.pl +lib/Sc/Mong.pl +lib/Sc/Mymr.pl +lib/Sc/Nko.pl +lib/Sc/Ogam.pl +lib/Sc/Orya.pl +lib/Sc/Osma.pl +lib/Sc/Phag.pl +lib/Sc/Phnx.pl +lib/Sc/Qaai.pl +lib/Sc/Rjng.pl +lib/Sc/Runr.pl +lib/Sc/Saur.pl +lib/Sc/Sinh.pl +lib/Sc/Sund.pl +lib/Sc/Sylo.pl +lib/Sc/Syrc.pl +lib/Sc/Tagb.pl +lib/Sc/Tale.pl +lib/Sc/Talu.pl +lib/Sc/Taml.pl +lib/Sc/Telu.pl +lib/Sc/Tfng.pl +lib/Sc/Tglg.pl +lib/Sc/Thaa.pl +lib/Sc/Thai.pl +lib/Sc/Tibt.pl +lib/Sc/Ugar.pl +lib/Sc/Vai.pl +lib/Sc/Xpeo.pl +lib/Sc/Xsux.pl +lib/Sc/Yi.pl +lib/Sc/Zyyy.pl +lib/Sc/Zzzz.pl +lib/Space/N.pl +lib/Space/Y.pl +lib/Term/N.pl +lib/Term/Y.pl +lib/UIdeo/N.pl +lib/UIdeo/Y.pl +lib/Upper/N.pl +lib/Upper/Y.pl +lib/VS/N.pl +lib/VS/Y.pl +lib/WB/EX.pl +lib/WB/KA.pl +lib/WB/LE.pl +lib/WB/MB.pl +lib/WB/ML.pl +lib/WB/MN.pl +lib/WB/NL.pl +lib/WB/NU.pl +lib/WB/XX.pl +lib/XIDC/N.pl +lib/XIDC/Y.pl +lib/XIDS/N.pl +lib/XIDS/Y.pl -# 24 input files -# 514 output files +# 35 input files +# 771 output files # End list diff --git a/lib/utf8_heavy.pl b/lib/utf8_heavy.pl index 41a0662..250eb69 100644 --- a/lib/utf8_heavy.pl +++ b/lib/utf8_heavy.pl @@ -8,8 +8,6 @@ sub DESTROY {} my %Cache; -our (%PropertyAlias, %PA_reverse, %PropValueAlias, %PVA_reverse, %PVA_abbr_map); - sub croak { require Carp; Carp::croak(@_) } ## @@ -17,272 +15,450 @@ sub croak { require Carp; Carp::croak(@_) } ## It's a data structure that encodes a set of Unicode characters. ## -sub SWASHNEW { - my ($class, $type, $list, $minbits, $none) = @_; - local $^D = 0 if $^D; - - print STDERR "SWASHNEW @_\n" if DEBUG; - - ## - ## Get the list of codepoints for the type. - ## Called from swash_init (see utf8.c) or SWASHNEW itself. - ## - ## Callers of swash_init: - ## op.c:pmtrans -- for tr/// and y/// - ## regexec.c:regclass_swash -- for /[]/, \p, and \P - ## utf8.c:is_utf8_common -- for common Unicode properties - ## utf8.c:to_utf8_case -- for lc, uc, ucfirst, etc. and //i - ## - ## Given a $type, our goal is to fill $list with the set of codepoint - ## ranges. If $type is false, $list passed is used. - ## - ## $minbits: - ## For binary properties, $minbits must be 1. - ## For character mappings (case and transliteration), $minbits must - ## be a number except 1. - ## - ## $list (or that filled according to $type): - ## Refer to perlunicode.pod, "User-Defined Character Properties." - ## - ## For binary properties, only characters with the property value - ## of True should be listed. The 3rd column, if any, will be ignored. - ## - ## To make the parsing of $type clear, this code takes the a rather - ## unorthodox approach of last'ing out of the block once we have the - ## info we need. Were this to be a subroutine, the 'last' would just - ## be a 'return'. - ## - my $file; ## file to load data from, and also part of the %Cache key. - my $ListSorted = 0; - - if ($type) - { - $type =~ s/^\s+//; - $type =~ s/\s+$//; - - print STDERR "type = $type\n" if DEBUG; - - GETFILE: +{ + # If a floating point number is within this distance from the value of a + # fraction, it is considered to be that fraction, even if many more digits + # are specified that don't exactly match. + my $min_floating_slop; + + sub SWASHNEW { + my ($class, $type, $list, $minbits, $none) = @_; + local $^D = 0 if $^D; + + print STDERR __LINE__, ": ", join(", ", @_), "\n" if DEBUG; + + ## + ## Get the list of codepoints for the type. + ## Called from swash_init (see utf8.c) or SWASHNEW itself. + ## + ## Callers of swash_init: + ## op.c:pmtrans -- for tr/// and y/// + ## regexec.c:regclass_swash -- for /[]/, \p, and \P + ## utf8.c:is_utf8_common -- for common Unicode properties + ## utf8.c:to_utf8_case -- for lc, uc, ucfirst, etc. and //i + ## + ## Given a $type, our goal is to fill $list with the set of codepoint + ## ranges. If $type is false, $list passed is used. + ## + ## $minbits: + ## For binary properties, $minbits must be 1. + ## For character mappings (case and transliteration), $minbits must + ## be a number except 1. + ## + ## $list (or that filled according to $type): + ## Refer to perlunicode.pod, "User-Defined Character Properties." + ## + ## For binary properties, only characters with the property value + ## of True should be listed. The 3rd column, if any, will be ignored + ## + ## $none is undocumented, so I'm (khw) trying to do some documentation + ## of it now. It appears to be if there is a mapping in an input file + ## that maps to 'XXXX', then that is replaced by $none+1, expressed in + ## hexadecimal. The only place I found it possibly used was in + ## S_pmtrans in op.c. + ## + ## To make the parsing of $type clear, this code takes the a rather + ## unorthodox approach of last'ing out of the block once we have the + ## info we need. Were this to be a subroutine, the 'last' would just + ## be a 'return'. + ## + my $file; ## file to load data from, and also part of the %Cache key. + my $ListSorted = 0; + + # Change this to get a different set of Unicode tables + my $unicore_dir = 'unicore'; + + if ($type) { - ## - ## It could be a user-defined property. - ## - - my $caller1 = $type =~ s/(.+)::// ? $1 : caller(1); - - if (defined $caller1 && $type =~ /^(?:\w+)$/) { - my $prop = "${caller1}::$type"; - if (exists &{$prop}) { - no strict 'refs'; - - $list = &{$prop}; - last GETFILE; - } - } - - my $wasIs; - - ($wasIs = $type =~ s/^Is(?:\s+|[-_])?//i) - or - $type =~ s/^(?:(?:General(?:\s+|_)?)?Category|gc)\s*[:=]\s*//i - or - $type =~ s/^(?:Script|sc)\s*[:=]\s*//i - or - $type =~ s/^Block\s*[:=]\s*/In/i; - - - ## - ## See if it's in some enumeration. - ## - require "unicore/PVA.pl"; - if ($type =~ /^([\w\s]+)[:=]\s*(.*)/) { - my ($enum, $val) = (lc $1, lc $2); - $enum =~ tr/ _-//d; - $val =~ tr/ _-//d; - - my $pa = $PropertyAlias{$enum} ? $enum : $PA_reverse{$enum}; - my $f = $PropValueAlias{$pa}{$val} ? $val : $PVA_reverse{$pa}{lc $val}; - - if ($pa and $f) { - $pa = "gc_sc" if $pa eq "gc" or $pa eq "sc"; - $file = "unicore/lib/$pa/$PVA_abbr_map{$pa}{lc $f}.pl"; - last GETFILE; - } - } - else { - my $t = lc $type; - $t =~ tr/ _-//d; - - if ($PropValueAlias{gc}{$t} or $PropValueAlias{sc}{$t}) { - $file = "unicore/lib/gc_sc/$PVA_abbr_map{gc_sc}{$t}.pl"; - last GETFILE; - } - } - - ## - ## See if it's in the direct mapping table. - ## - require "unicore/Exact.pl"; - if (my $base = $utf8::Exact{$type}) { - $file = "unicore/lib/gc_sc/$base.pl"; - last GETFILE; + $type =~ s/^\s+//; + $type =~ s/\s+$//; + + print STDERR __LINE__, ": type = $type\n" if DEBUG; + + GETFILE: + { + ## + ## It could be a user-defined property. + ## + + my $caller1 = $type =~ s/(.+)::// ? $1 : caller(1); + + if (defined $caller1 && $type =~ /^(?:\w+)$/) { + my $prop = "${caller1}::$type"; + if (exists &{$prop}) { + no strict 'refs'; + + $list = &{$prop}; + last GETFILE; + } + } + + require "$unicore_dir/Heavy.pl"; + + # Everything is caseless matching + my $property_and_table = lc $type; + print STDERR __LINE__, ": $property_and_table\n" if DEBUG; + + # See if is of the compound form 'property=value', where the + # value indicates the table we should use. + my ($property, $table, @remainder) = + split /\s*[:=]\s*/, $property_and_table, -1; + return $type if @remainder; + + my $prefix; + if (! defined $table) { + + # Here, is the single form. The property becomes empty, and + # the whole value is the table. + $table = $property; + $prefix = $property = ""; + } else { + print STDERR __LINE__, ": $property\n" if DEBUG; + + # Here it is the compound property=table form. The property + # name is always loosely matched, which means remove any of + # these: + $property =~ s/[_\s-]//g; + + # And convert to canonical form. Quit if not valid. + $property = $utf8::loose_property_name_of{$property}; + return $type unless defined $property; + + $prefix = "$property="; + + # If the rhs looks like it is a number... + print STDERR __LINE__, ": table=$table\n" if DEBUG; + if ($table =~ qr{ ^ [ \s 0-9 _ + / . -]+ $ }x) { + print STDERR __LINE__, ": table=$table\n" if DEBUG; + + # Don't allow leading nor trailing slashes + return $type if $table =~ / ^ \/ | \/ $ /x; + + # Split on slash, in case it is a rational, like \p{1/5} + my @parts = split qr{ \s* / \s* }x, $table, -1; + print __LINE__, ": $type\n" if @parts > 2 && DEBUG; + + # Can have maximum of one slash + return $type if @parts > 2; + + foreach my $part (@parts) { + print __LINE__, ": part=$part\n" if DEBUG; + + $part =~ s/^\+\s*//; # Remove leading plus + $part =~ s/^-\s*/-/; # Remove blanks after unary + # minus + + # Remove underscores between digits. + $part =~ s/( ?<= [0-9] ) _ (?= [0-9] ) //xg; + + # No leading zeros (but don't make a single '0' + # into a null string) + $part =~ s/ ^ ( -? ) 0+ /$1/x; + $part .= '0' if $part eq '-' || $part eq ""; + + # No trailing zeros after a decimal point + $part =~ s/ ( \. .*? ) 0+ $ /$1/x; + + # Begin with a 0 if a leading decimal point + $part =~ s/ ^ ( -? ) \. /${1}0./x; + + # Ensure not a trailing decimal point: turn into an + # integer + $part =~ s/ \. $ //x; + + print STDERR __LINE__, ": part=$part\n" if DEBUG; + #return $type if $part eq ""; + + # Result better look like a number. (This test is + # needed because, for example could have a plus in + # the middle.) + return $type if $part + !~ / ^ -? [0-9]+ ( \. [0-9]+)? $ /x; + } + + # If a rational... + if (@parts == 2) { + + # If denominator is negative, get rid of it, and ... + if ($parts[1] =~ s/^-//) { + + # If numerator is also negative, convert the + # whole thing to positive, or move the minus to + # the numerator + if ($parts[0] !~ s/^-//) { + $parts[0] = '-' . $parts[0]; + } + } + $table = join '/', @parts; + } + elsif ($property ne 'nv' || $parts[0] !~ /\./) { + + # Here is not numeric value, or doesn't have a + # decimal point. No further manipulation is + # necessary. (Note the hard-coded property name. + # This could fail if other properties eventually + # had fractions as well; perhaps the cjk ones + # could evolve to do that. This hard-coding could + # be fixed by mktables generating a list of + # properties that could have fractions.) + $table = $parts[0]; + } else { + + # Here is a floating point numeric_value. Try to + # convert to rational. First see if is in the list + # of known ones. + if (exists $utf8::nv_floating_to_rational{$parts[0]}) { + $table = $utf8::nv_floating_to_rational{$parts[0]}; + } else { + + # Here not in the list. See if is close + # enough to something in the list. First + # determine what 'close enough' means. It has + # to be as tight as what mktables says is the + # maximum slop, and as tight as how many + # digits we were passed. That is, if the user + # said .667, .6667, .66667, etc. we match as + # many digits as they passed until get to + # where it doesn't matter any more due to the + # machine's precision. If they said .6666668, + # we fail. + (my $fraction = $parts[0]) =~ s/^.*\.//; + my $epsilon = 10 ** - (length($fraction)); + if ($epsilon > $utf8::max_floating_slop) { + $epsilon = $utf8::max_floating_slop; + } + + # But it can't be tighter than the minimum + # precision for this machine. If haven't + # already calculated that minimum, do so now. + if (! defined $min_floating_slop) { + + # Keep going down an order of magnitude + # until find that adding this quantity to + # 1 remains 1; but put an upper limit on + # this so in case this algorithm doesn't + # work properly on some platform, that we + # won't loop forever. + my $count = 0; + $min_floating_slop = 1; + while (1+ $min_floating_slop != 1 + && $count++ < 50) + { + my $next = $min_floating_slop / 10; + last if $next == 0; # If underflows, + # use previous one + $min_floating_slop = $next; + print STDERR __LINE__, ": min_float_slop=$min_floating_slop\n" if DEBUG; + } + + # Back off a couple orders of magnitude, + # just to be safe. + $min_floating_slop *= 100; + } + + if ($epsilon < $min_floating_slop) { + $epsilon = $min_floating_slop; + } + print STDERR __LINE__, ": fraction=.$fraction; epsilon=$epsilon\n" if DEBUG; + + undef $table; + + # And for each possible rational in the table, + # see if it is within epsilon of the input. + foreach my $official + (keys %utf8::nv_floating_to_rational) + { + print STDERR __LINE__, ": epsilon=$epsilon, official=$official, diff=", abs($parts[0] - $official), "\n" if DEBUG; + if (abs($parts[0] - $official) < $epsilon) { + $table = + $utf8::nv_floating_to_rational{$official}; + last; + } + } + + # Quit if didn't find one. + return $type unless defined $table; + } + } + print STDERR __LINE__, ": $property=$table\n" if DEBUG; + } + } + + # Combine lhs (if any) and rhs to get something that matches + # the syntax of the lookups. + $property_and_table = "$prefix$table"; + print STDERR __LINE__, ": $property_and_table\n" if DEBUG; + + # First try stricter matching. + $file = $utf8::stricter_to_file_of{$property_and_table}; + + # If didn't find it, try again with looser matching by editing + # out the applicable characters on the rhs and looking up + # again. + if (! defined $file) { + $table =~ s/ [_\s-] //xg; + $property_and_table = "$prefix$table"; + print STDERR __LINE__, ": $property_and_table\n" if DEBUG; + $file = $utf8::loose_to_file_of{$property_and_table}; + } + + # Add the constant and go fetch it in. + if (defined $file) { + if ($utf8::why_deprecated{$file}) { + warnings::warnif('deprecated', "Use of '$type' in \\p{} or \\P{} is deprecated because: $utf8::why_deprecated{$file};"); + } + $file= "$unicore_dir/lib/$file.pl"; + last GETFILE; + } + print STDERR __LINE__, ": didn't find $property_and_table\n" if DEBUG; + + ## + ## See if it's a user-level "To". + ## + + my $caller0 = caller(0); + + if (defined $caller0 && $type =~ /^To(?:\w+)$/) { + my $map = $caller0 . "::" . $type; + + if (exists &{$map}) { + no strict 'refs'; + + $list = &{$map}; + last GETFILE; + } + } + + ## + ## Last attempt -- see if it's a standard "To" name + ## (e.g. "ToLower") ToTitle is used by ucfirst(). + ## The user-level way to access ToDigit() and ToFold() + ## is to use Unicode::UCD. + ## + if ($type =~ /^To(Digit|Fold|Lower|Title|Upper)$/) { + $file = "$unicore_dir/To/$1.pl"; + ## would like to test to see if $file actually exists.... + last GETFILE; + } + + ## + ## If we reach this line, it's because we couldn't figure + ## out what to do with $type. Ouch. + ## + + return $type; } - ## - ## If not there exactly, try the canonical form. The canonical - ## form is lowercased, with any separators (\s+|[-_]) removed. - ## - my $canonical = lc $type; - $canonical =~ s/(?<=[a-z\d])(?:\s+|[-_])(?=[a-z\d])//g; - print STDERR "canonical = $canonical\n" if DEBUG; - - require "unicore/Canonical.pl"; - { no warnings "uninitialized"; - if (my $base = ($utf8::Canonical{$canonical} || $utf8::Canonical{ lc $utf8::PropertyAlias{$canonical} })) { - $file = "unicore/lib/gc_sc/$base.pl"; - last GETFILE; - } + if (defined $file) { + print STDERR __LINE__, ": found it (file='$file')\n" if DEBUG; + + ## + ## If we reach here, it was due to a 'last GETFILE' above + ## (exception: user-defined properties and mappings), so we + ## have a filename, so now we load it if we haven't already. + ## If we have, return the cached results. The cache key is the + ## class and file to load. + ## + my $found = $Cache{$class, $file}; + if ($found and ref($found) eq $class) { + print STDERR __LINE__, ": Returning cached '$file' for \\p{$type}\n" if DEBUG; + return $found; + } + + local $@; + local $!; + $list = do $file; die $@ if $@; } - ## - ## See if it's a user-level "To". - ## - - my $caller0 = caller(0); - - if (defined $caller0 && $type =~ /^To(?:\w+)$/) { - my $map = $caller0 . "::" . $type; - - if (exists &{$map}) { - no strict 'refs'; - - $list = &{$map}; - last GETFILE; - } - } - - ## - ## Last attempt -- see if it's a standard "To" name - ## (e.g. "ToLower") ToTitle is used by ucfirst(). - ## The user-level way to access ToDigit() and ToFold() - ## is to use Unicode::UCD. - ## - if ($type =~ /^To(Digit|Fold|Lower|Title|Upper)$/) { - $file = "unicore/To/$1.pl"; - ## would like to test to see if $file actually exists.... - last GETFILE; - } - - ## - ## If we reach this line, it's because we couldn't figure - ## out what to do with $type. Ouch. - ## - - return $type; + $ListSorted = 1; ## we know that these lists are sorted } - if (defined $file) { - print STDERR "found it (file='$file')\n" if DEBUG; - - ## - ## If we reach here, it was due to a 'last GETFILE' above - ## (exception: user-defined properties and mappings), so we - ## have a filename, so now we load it if we haven't already. - ## If we have, return the cached results. The cache key is the - ## class and file to load. - ## - my $found = $Cache{$class, $file}; - if ($found and ref($found) eq $class) { - print STDERR "Returning cached '$file' for \\p{$type}\n" if DEBUG; - return $found; - } - - local $@; - local $!; - $list = do $file; die $@ if $@; - } - - $ListSorted = 1; ## we know that these lists are sorted - } - - my $extras; - my $bits = $minbits; - - my $ORIG = $list; - if ($list) { - my @tmp = split(/^/m, $list); - my %seen; - no warnings; - $extras = join '', grep /^[^0-9a-fA-F]/, @tmp; - $list = join '', - map { $_->[1] } - sort { $a->[0] <=> $b->[0] } - map { /^([0-9a-fA-F]+)/; [ CORE::hex($1), $_ ] } - grep { /^([0-9a-fA-F]+)/ and not $seen{$1}++ } @tmp; # XXX doesn't do ranges right - } + my $extras; + my $bits = $minbits; + + my $ORIG = $list; + if ($list) { + my @tmp = split(/^/m, $list); + my %seen; + no warnings; + $extras = join '', grep /^[^0-9a-fA-F]/, @tmp; + $list = join '', + map { $_->[1] } + sort { $a->[0] <=> $b->[0] } + map { /^([0-9a-fA-F]+)/; [ CORE::hex($1), $_ ] } + grep { /^([0-9a-fA-F]+)/ and not $seen{$1}++ } @tmp; # XXX doesn't do ranges right + } - if ($none) { - my $hextra = sprintf "%04x", $none + 1; - $list =~ s/\tXXXX$/\t$hextra/mg; - } + if ($none) { + my $hextra = sprintf "%04x", $none + 1; + $list =~ s/\tXXXX$/\t$hextra/mg; + } - if ($minbits != 1 && $minbits < 32) { # not binary property - my $top = 0; - while ($list =~ /^([0-9a-fA-F]+)(?:[\t]([0-9a-fA-F]+)?)(?:[ \t]([0-9a-fA-F]+))?/mg) { - my $min = CORE::hex $1; - my $max = defined $2 ? CORE::hex $2 : $min; - my $val = defined $3 ? CORE::hex $3 : 0; - $val += $max - $min if defined $3; - $top = $val if $val > $top; - } - my $topbits = - $top > 0xffff ? 32 : - $top > 0xff ? 16 : 8; - $bits = $topbits if $bits < $topbits; - } + if ($minbits != 1 && $minbits < 32) { # not binary property + my $top = 0; + while ($list =~ /^([0-9a-fA-F]+)(?:[\t]([0-9a-fA-F]+)?)(?:[ \t]([0-9a-fA-F]+))?/mg) { + my $min = CORE::hex $1; + my $max = defined $2 ? CORE::hex $2 : $min; + my $val = defined $3 ? CORE::hex $3 : 0; + $val += $max - $min if defined $3; + $top = $val if $val > $top; + } + my $topbits = + $top > 0xffff ? 32 : + $top > 0xff ? 16 : 8; + $bits = $topbits if $bits < $topbits; + } - my @extras; - for my $x ($extras) { - pos $x = 0; - while ($x =~ /^([^0-9a-fA-F\n])(.*)/mg) { - my $char = $1; - my $name = $2; - print STDERR "$1 => $2\n" if DEBUG; - if ($char =~ /[-+!&]/) { - my ($c,$t) = split(/::/, $name, 2); # bogus use of ::, really - my $subobj; - if ($c eq 'utf8') { - $subobj = utf8->SWASHNEW($t, "", $minbits, 0); - } - elsif (exists &$name) { - $subobj = utf8->SWASHNEW($name, "", $minbits, 0); - } - elsif ($c =~ /^([0-9a-fA-F]+)/) { - $subobj = utf8->SWASHNEW("", $c, $minbits, 0); - } - return $subobj unless ref $subobj; - push @extras, $name => $subobj; - $bits = $subobj->{BITS} if $bits < $subobj->{BITS}; - } - } - } + my @extras; + if ($extras) { + for my $x ($extras) { + pos $x = 0; + while ($x =~ /^([^0-9a-fA-F\n])(.*)/mg) { + my $char = $1; + my $name = $2; + print STDERR __LINE__, ": $1 => $2\n" if DEBUG; + if ($char =~ /[-+!&]/) { + my ($c,$t) = split(/::/, $name, 2); # bogus use of ::, really + my $subobj; + if ($c eq 'utf8') { + $subobj = utf8->SWASHNEW($t, "", $minbits, 0); + } + elsif (exists &$name) { + $subobj = utf8->SWASHNEW($name, "", $minbits, 0); + } + elsif ($c =~ /^([0-9a-fA-F]+)/) { + $subobj = utf8->SWASHNEW("", $c, $minbits, 0); + } + return $subobj unless ref $subobj; + push @extras, $name => $subobj; + $bits = $subobj->{BITS} if $bits < $subobj->{BITS}; + } + } + } + } - print STDERR "CLASS = $class, TYPE => $type, BITS => $bits, NONE => $none\nEXTRAS =>\n$extras\nLIST =>\n$list\n" if DEBUG; + if (DEBUG) { + print STDERR __LINE__, ": CLASS = $class, TYPE => $type, BITS => $bits, NONE => $none"; + print STDERR "\nLIST =>\n$list" if defined $list; + print STDERR "\nEXTRAS =>\n$extras" if defined $extras; + print STDERR "\n"; + } - my $SWASH = bless { - TYPE => $type, - BITS => $bits, - EXTRAS => $extras, - LIST => $list, - NONE => $none, - @extras, - } => $class; + my $SWASH = bless { + TYPE => $type, + BITS => $bits, + EXTRAS => $extras, + LIST => $list, + NONE => $none, + @extras, + } => $class; + + if ($file) { + $Cache{$class, $file} = $SWASH; + } - if ($file) { - $Cache{$class, $file} = $SWASH; + return $SWASH; } - - return $SWASH; } # Now SWASHGET is recasted into a C function S_swash_get (see utf8.c). diff --git a/pod/perluniprops.pod b/pod/perluniprops.pod new file mode 100644 index 0000000..78ab703 --- /dev/null +++ b/pod/perluniprops.pod @@ -0,0 +1,2783 @@ +=begin comment + +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is machine-generated by lib/unicore/mktables from the Unicode database, +# Version 5.1.0. Any changes made here will be lost! + + +To change this file, edit lib/unicore/mktables instead. + +=end comment + +=head1 NAME + +perluniprops - Complete index of Unicode Version 5.1.0 properties in +the Perl core. + +=head1 DESCRIPTION + +There are many properties in Unicode, and Perl provides access to almost all of +them, as well as some additional extensions and short-cut synonyms. + +And just about all of the few that aren't accessible through the Perl +core are accessible through the modules: Unicode::Normalize and +Unicode::UCD, and for Unihan properties, via the CPAN module Unicode::Unihan. + +This document merely lists all available properties and does not attempt to +explain what each property really means. There is a brief description of each +Perl extension. There is some detail about Blocks, Scripts, General_Category, +and Bidi_Class in L, but to find out about the intricacies of the +Unicode properties, refer to the Unicode standard. A good starting place is +L. More information on the Perl extensions is in +L. + +Note that you can define your own properties; see +L. + +=head1 Properties accessible through \p{} and \P{} + +The Perl regular expression \p{} and \P{} constructs give access to most of +the Unicode character properties. The table below shows all these constructs, +both single and compound forms. + +B consist of two components, separated by an equals sign or a +colon. The first component is the property name, and the second component is +the particular value of the property to match against, for example, +'\p{Script: Greek}' or '\p{Script=Greek}' both mean to match characters +whose Script property is Greek. + +B, like '\p{Greek}', are mostly Perl-defined shortcuts for +their equivalent compound forms. The table shows these equivalences. (In our +example, '\p{Greek}' is a just a shortcut for '\p{Script=Greek}'.) +There are also a few Perl-defined single forms that are not shortcuts for a +compound form. One such is \p{Word}. These are also listed in the table. + +In parsing these constructs, Perl always ignores Upper/lower case differences +everywhere within the {braces}. Thus '\p{Greek}' means the same thing as +'\p{greek}'. But note that changing the case of the 'p' or 'P' before the +left brace completely changes the meaning of the construct, from "match" (for +'\p{}') to "doesn't match" (for '\P{}'). Casing in this document is for +improved legibility. + +Also, white space, hyphens, and underscores are also normally ignored +everywhere between the {braces}, and hence can be freely added or removed +even if the C modifier hasn't been specified on the regular expression. +But a 'B' at the beginning of an entry in the table below +means that tighter (stricter) rules are used for that entry: + +=over 4 + +=item Single form (\p{name}) tighter rules: + +White space, hyphens, and underscores ARE significant +except for: + +=over 4 + +=item * white space adjacent to a non-word character + +=item * underscores separating digits in numbers + +=back + +That means, for example, that you can freely add or remove white space +adjacent to (but within) the braces without affecting the meaning. + +=item Compound form (\p{name=value} or \p{name:value}) tighter rules: + +The tighter rules given above for the single form apply to everything to the +right of the colon or equals; the looser rules still apply to everything to +the left. + +That means, for example, that you can freely add or remove white space +adjacent to (but within) the braces and the colon or equal sign. + +=back + +Some properties are considered obsolete, but still available. There are +several varieties of obsolesence: + +=over 4 + +=item Obsolete + +Properties marked with an 'B' in the table are considered +obsolete. At the time of this writing (Unicode version 5.2) there is no +information in the Unicode standard about the implications of a property being +obsolete. + +=item Stabilized + +Obsolete properties may be stabilized. This means that they are not actively +maintained by Unicode, and will not be extended as new characters are added to +the standard. Such properties are marked with an 'B' in the +table. At the time of this writing (Unicode version 5.2) there is no further +information in the Unicode standard about the implications of a property being +stabilized. + +=item Deprecated + +Obsolete properties may be deprecated. This means that their use is strongly +discouraged, so much so that a warning will be issued if used, unless the +regular expression is in the scope of a C> +statement. A 'B' flags each such entry in the table, and +the entry there for the longest, most descriptive version of the property will +give the reason it is deprecated, and perhaps advice. Perl may issue such a +warning, even for properties that aren't officially deprecated by Unicode, +when there used to be characters or code points that were matched by them, but +no longer. This is to warn you that your program may not work like it did on +earlier Unicode releases. + +A deprecated property may be made unavailable in a future Perl version, so it +is best to move away from them. + +=back + +Some Perl extensions are present for backwards compatibility and are +discouraged from being used, but not obsolete. An 'B' +flags each such entry in the table. + + +Matches in the Block property have shortcuts that begin with 'In_'. For +example, \p{Block=Latin1} can be written as \p{In_Latin1}. For backward +compatibility, if there is no conflict with another shortcut, these may also +be written as \p{Latin1} or \p{Is_Latin1}. But, N.B., there are numerous +such conflicting shortcuts. Use of these forms for Block is discouraged, and +are flagged as such, not only because of the potential confusion as to what is +meant, but also because a later release of Unicode may preempt the shortcut, +and your program would no longer be correct. Use the 'In_' form instead to +avoid this, or even more clearly, use the compound form, e.g., +\p{blk:latin1}. See L for more information about this. + + +The table below has two columns. The left column contains the \p{} +constructs to look up, possibly preceeded by the flags mentioned above; and +the right column contains information about them, like a description, or +synonyms. It shows both the single and compound forms for each property that +has them. If the left column is a short name for a property, the right column +will give its longer, more descriptive name; and if the left column is the +longest name, the right column will show any equivalent shortest name, in both +single and compound forms if applicable. + +The right column will also caution you if a property means something different +than what might normally be expected. + +Numbers in (parentheses) indicate the total number of code points matched by +the property. For emphasis, those properties that match no code points at all +are listed as well in a separate section following the table. + +There is no description given for most non-Perl defined properties (See +http://www.unicode.org/reports/tr44/ for that). + +For compactness, 'B<*>' is used as a wildcard instead of showing all possible +combinations. For example, entries like: + + \p{Gc: *} \p{General_Category: *} + +mean that 'Gc' is a synonym for 'General_Category', and anything that is valid +for the latter is also valid for the former. Similarly, + + \p{Is_*} \p{*} + +means that if and only if, for example, \p{Foo} exists, then \p{Is_Foo} and +\p{IsFoo} are also valid and all mean the same thing. And similarly, +\p{Foo=Bar} means the same as \p{Is_Foo=Bar} and \p{IsFoo=Bar}. '*' here +is restricted to something not beginning with an underscore. + +Also, in binary properties, 'Yes', 'T', and 'True' are all synonyms for 'Y'. +And 'No', 'F', and 'False' are all synonyms for 'N'. The table shows 'Y*' and +'N*' to indicate this, and doesn't have separate entries for the other +possibilities. Note that not all properties which have values 'Yes' and 'No' +are binary, and they have all their values spelled out without using this wild +card, and a C clause in their description that highlights their not being +binary. These also require the compound form to match them, whereas true +binary properties have both single and compound forms available. + +Note that all non-essential underscores are removed in the display of the +short names below. + +B + +=over 4 + +=item B<*> is a wild-card + +=item B<(\d+)> in the info column gives the number of code points matched by +this property. + +=item B means this is deprecated. + +=item B means this is obsolete. + +=item B means this is stabilized. + +=item B means tighter (stricter) name matching applies. + +=item B means use of this form is discouraged. + +=back + + NAME INFO + + T \p{_CanonDCIJ} (For internal use by Perl, not necessarily + stable) (= \p{Soft_Dotted=Y}) (46) + T \p{_Case_Ignorable} (For internal use by Perl, not necessarily + stable) (1486) + T \p{_CombAbove} (For internal use by Perl, not necessarily + stable) (= \p{Canonical_Combining_Class= + Above}) (252) + T \p{_GCB_Extend} (For internal use by Perl, not necessarily + stable) (1292) + X \p{Aegean_Numbers} \p{Block=Aegean_Numbers} (64) + T \p{Age: 1.1} Code point's usage introduced in version + 1.1 (33_979) + T \p{Age: 2.0} Code point's usage was introduced in + version 2.0; See also Property + 'Present_In' (144_521) + T \p{Age: 2.1} Code point's usage was introduced in + version 2.1; See also Property + 'Present_In' (2) + T \p{Age: 3.0} Code point's usage was introduced in + version 3.0; See also Property + 'Present_In' (10_307) + T \p{Age: 3.1} Code point's usage was introduced in + version 3.1; See also Property + 'Present_In' (44_978) + T \p{Age: 3.2} Code point's usage was introduced in + version 3.2; See also Property + 'Present_In' (1016) + T \p{Age: 4.0} Code point's usage was introduced in + version 4.0; See also Property + 'Present_In' (1226) + T \p{Age: 4.1} Code point's usage was introduced in + version 4.1; See also Property + 'Present_In' (1273) + T \p{Age: 5.0} Code point's usage was introduced in + version 5.0; See also Property + 'Present_In' (1369) + T \p{Age: 5.1} Code point's usage was introduced in + version 5.1; See also Property + 'Present_In' (1624) + \p{Age: Unassigned} Code point's usage has not been assigned + in any Unicode release thus far. + (873_817) + \p{AHex} \p{XDigit} (= \p{ASCII_Hex_Digit=Y}) (22) + \p{AHex: *} \p{ASCII_Hex_Digit: *} + \p{All} \p{Any} (1_114_112) + \p{Alnum} [[:Alnum:]] extended beyond ASCII (94_702) + \p{Alpha} \p{Alphabetic=Y} [[:Alpha:]] extended + beyond ASCII (94_332) + \p{Alpha: *} \p{Alphabetic: *} + \p{Alphabetic} \p{Alpha} (= \p{Alphabetic=Y}) (94_332) + \p{Alphabetic: N*} (Short: \p{Alpha=N}, \P{Alpha}) (1_019_780) + \p{Alphabetic: Y*} (Short: \p{Alpha=Y}, \p{Alpha}) (94_332) + X \p{Alphabetic_Presentation_Forms} \p{Block= + Alphabetic_Presentation_Forms} (80) + X \p{Ancient_Greek_Musical_Notation} \p{Block= + Ancient_Greek_Musical_Notation} (80) + X \p{Ancient_Greek_Numbers} \p{Block=Ancient_Greek_Numbers} (80) + X \p{Ancient_Symbols} \p{Block=Ancient_Symbols} (64) + \p{Any} [\x{0000}-\x{10FFFF}] (1_114_112) + \p{Arab} \p{Arabic} (= \p{Script=Arabic}) (NOT + \p{Block=Arabic}) (999) + \p{Arabic} \p{Script=Arabic} (Short: \p{Arab}; NOT + \p{Block=Arabic}) (999) + X \p{Arabic_Presentation_Forms_A} \p{Block= + Arabic_Presentation_Forms_A} (688) + X \p{Arabic_Presentation_Forms_B} \p{Block= + Arabic_Presentation_Forms_B} (144) + X \p{Arabic_Supplement} \p{Block=Arabic_Supplement} (48) + \p{Armenian} \p{Script=Armenian} (Short: \p{Armn}; NOT + \p{Block=Armenian}) (90) + \p{Armn} \p{Armenian} (= \p{Script=Armenian}) (NOT + \p{Block=Armenian}) (90) + X \p{Arrows} \p{Block=Arrows} (112) + \p{ASCII} \p{Block=Basic_Latin} [[:ASCII:]] (128) + \p{ASCII_Hex_Digit} \p{XDigit} (= \p{ASCII_Hex_Digit=Y}) (22) + \p{ASCII_Hex_Digit: N*} (Short: \p{AHex=N}, \P{AHex}) (1_114_090) + \p{ASCII_Hex_Digit: Y*} (Short: \p{AHex=Y}, \p{AHex}) (22) + \p{Assigned} All assigned code points (240_229) + \p{Bali} \p{Balinese} (= \p{Script=Balinese}) (NOT + \p{Block=Balinese}) (121) + \p{Balinese} \p{Script=Balinese} (Short: \p{Bali}; NOT + \p{Block=Balinese}) (121) + X \p{Basic_Latin} \p{ASCII} (= \p{Block=Basic_Latin}) (128) + \p{Bc: *} \p{Bidi_Class: *} + \p{Beng} \p{Bengali} (= \p{Script=Bengali}) (NOT + \p{Block=Bengali}) (91) + \p{Bengali} \p{Script=Bengali} (Short: \p{Beng}; NOT + \p{Block=Bengali}) (91) + \p{Bidi_C} \p{Bidi_Control} (= \p{Bidi_Control=Y}) (7) + \p{Bidi_C: *} \p{Bidi_Control: *} + \p{Bidi_Class: AL} \p{Bidi_Class=Arabic_Letter} (1116) + \p{Bidi_Class: AN} \p{Bidi_Class=Arabic_Number} (17) + \p{Bidi_Class: Arabic_Letter} (Short: \p{Bc=AL}) (1116) + \p{Bidi_Class: Arabic_Number} (Short: \p{Bc=AN}) (17) + \p{Bidi_Class: B} \p{Bidi_Class=Paragraph_Separator} (7) + \p{Bidi_Class: BN} \p{Bidi_Class=Boundary_Neutral} (4016) + \p{Bidi_Class: Boundary_Neutral} (Short: \p{Bc=BN}) (4016) + \p{Bidi_Class: Common_Separator} (Short: \p{Bc=CS}) (15) + \p{Bidi_Class: CS} \p{Bidi_Class=Common_Separator} (15) + \p{Bidi_Class: EN} \p{Bidi_Class=European_Number} (120) + \p{Bidi_Class: ES} \p{Bidi_Class=European_Separator} (12) + \p{Bidi_Class: ET} \p{Bidi_Class=European_Terminator} (57) + \p{Bidi_Class: European_Number} (Short: \p{Bc=EN}) (120) + \p{Bidi_Class: European_Separator} (Short: \p{Bc=ES}) (12) + \p{Bidi_Class: European_Terminator} (Short: \p{Bc=ET}) (57) + \p{Bidi_Class: L} \p{Bidi_Class=Left_To_Right} (1_101_792) + \p{Bidi_Class: Left_To_Right} (Short: \p{Bc=L}) (1_101_792) + \p{Bidi_Class: Left_To_Right_Embedding} (Short: \p{Bc=LRE}) (1) + \p{Bidi_Class: Left_To_Right_Override} (Short: \p{Bc=LRO}) (1) + \p{Bidi_Class: LRE} \p{Bidi_Class=Left_To_Right_Embedding} (1) + \p{Bidi_Class: LRO} \p{Bidi_Class=Left_To_Right_Override} (1) + \p{Bidi_Class: Nonspacing_Mark} (Short: \p{Bc=NSM}) (1043) + \p{Bidi_Class: NSM} \p{Bidi_Class=Nonspacing_Mark} (1043) + \p{Bidi_Class: ON} \p{Bidi_Class=Other_Neutral} (3439) + \p{Bidi_Class: Other_Neutral} (Short: \p{Bc=ON}) (3439) + \p{Bidi_Class: Paragraph_Separator} (Short: \p{Bc=B}) (7) + \p{Bidi_Class: PDF} \p{Bidi_Class=Pop_Directional_Format} (1) + \p{Bidi_Class: Pop_Directional_Format} (Short: \p{Bc=PDF}) (1) + \p{Bidi_Class: R} \p{Bidi_Class=Right_To_Left} (2452) + \p{Bidi_Class: Right_To_Left} (Short: \p{Bc=R}) (2452) + \p{Bidi_Class: Right_To_Left_Embedding} (Short: \p{Bc=RLE}) (1) + \p{Bidi_Class: Right_To_Left_Override} (Short: \p{Bc=RLO}) (1) + \p{Bidi_Class: RLE} \p{Bidi_Class=Right_To_Left_Embedding} (1) + \p{Bidi_Class: RLO} \p{Bidi_Class=Right_To_Left_Override} (1) + \p{Bidi_Class: S} \p{Bidi_Class=Segment_Separator} (3) + \p{Bidi_Class: Segment_Separator} (Short: \p{Bc=S}) (3) + \p{Bidi_Class: White_Space} (Short: \p{Bc=WS}) (18) + \p{Bidi_Class: WS} \p{Bidi_Class=White_Space} (18) + \p{Bidi_Control} \p{Bidi_Control=Y} (Short: \p{BidiC}) (7) + \p{Bidi_Control: N*} (Short: \p{BidiC=N}, \P{BidiC}) (1_114_105) + \p{Bidi_Control: Y*} (Short: \p{BidiC=Y}, \p{BidiC}) (7) + \p{Bidi_M} \p{Bidi_Mirrored} (= \p{Bidi_Mirrored=Y}) + (543) + \p{Bidi_M: *} \p{Bidi_Mirrored: *} + \p{Bidi_Mirrored} \p{Bidi_Mirrored=Y} (Short: \p{BidiM}) + (543) + \p{Bidi_Mirrored: N*} (Short: \p{BidiM=N}, \P{BidiM}) (1_113_569) + \p{Bidi_Mirrored: Y*} (Short: \p{BidiM=Y}, \p{BidiM}) (543) + \p{Blank} \h, Horizontal white space (19) + \p{Blk: *} \p{Block: *} + \p{Block: Aegean_Numbers} (Single: \p{InAegeanNumbers}) (64) + \p{Block: Alphabetic_Presentation_Forms} (Single: + \p{InAlphabeticPresentationForms}) (80) + \p{Block: Ancient_Greek_Musical_Notation} (Single: + \p{InAncientGreekMusicalNotation}) (80) + \p{Block: Ancient_Greek_Numbers} (Single: + \p{InAncientGreekNumbers}) (80) + \p{Block: Ancient_Symbols} (Single: \p{InAncientSymbols}) (64) + \p{Block: Arabic} (Single: \p{InArabic}; NOT \p{Arabic} NOR + \p{Is_Arabic}) (256) + \p{Block: Arabic_Presentation_Forms_A} (Single: + \p{InArabicPresentationFormsA}) (688) + \p{Block: Arabic_Presentation_Forms_B} (Single: + \p{InArabicPresentationFormsB}) (144) + \p{Block: Arabic_Supplement} (Single: \p{InArabicSupplement}) (48) + \p{Block: Armenian} (Single: \p{InArmenian}; NOT \p{Armenian} + NOR \p{Is_Armenian}) (96) + \p{Block: Arrows} (Single: \p{InArrows}) (112) + \p{Block: ASCII} \p{Block=Basic_Latin} (128) + \p{Block: Balinese} (Single: \p{InBalinese}; NOT \p{Balinese} + NOR \p{Is_Balinese}) (128) + \p{Block: Basic_Latin} (Short: \p{Blk=ASCII}, \p{ASCII}) (128) + \p{Block: Bengali} (Single: \p{InBengali}; NOT \p{Bengali} + NOR \p{Is_Bengali}) (128) + \p{Block: Block_Elements} (Single: \p{InBlockElements}) (32) + \p{Block: Bopomofo} (Single: \p{InBopomofo}; NOT \p{Bopomofo} + NOR \p{Is_Bopomofo}) (48) + \p{Block: Bopomofo_Extended} (Single: \p{InBopomofoExtended}) (32) + \p{Block: Box_Drawing} (Single: \p{InBoxDrawing}) (128) + \p{Block: Braille_Patterns} (Single: \p{InBraillePatterns}) (256) + \p{Block: Buginese} (Single: \p{InBuginese}; NOT \p{Buginese} + NOR \p{Is_Buginese}) (32) + \p{Block: Buhid} (Single: \p{InBuhid}; NOT \p{Buhid} NOR + \p{Is_Buhid}) (32) + \p{Block: Byzantine_Musical_Symbols} (Single: + \p{InByzantineMusicalSymbols}) (256) + \p{Block: Canadian_Syllabics} \p{Block= + Unified_Canadian_Aboriginal_Syllabics} + (640) + \p{Block: Carian} (Single: \p{InCarian}; NOT \p{Carian} NOR + \p{Is_Carian}) (64) + \p{Block: Cham} (Single: \p{InCham}; NOT \p{Cham} NOR + \p{Is_Cham}) (96) + \p{Block: Cherokee} (Single: \p{InCherokee}; NOT \p{Cherokee} + NOR \p{Is_Cherokee}) (96) + \p{Block: CJK_Compatibility} (Single: \p{InCJKCompatibility}) (256) + \p{Block: CJK_Compatibility_Forms} (Single: + \p{InCJKCompatibilityForms}) (32) + \p{Block: CJK_Compatibility_Ideographs} (Single: + \p{InCJKCompatibilityIdeographs}) (512) + \p{Block: CJK_Compatibility_Ideographs_Supplement} (Single: + \p{InCJKCompatibilityIdeographs- + Supplement}) (544) + \p{Block: CJK_Radicals_Supplement} (Single: + \p{InCJKRadicalsSupplement}) (128) + \p{Block: CJK_Strokes} (Single: \p{InCJKStrokes}) (48) + \p{Block: CJK_Symbols_And_Punctuation} (Single: + \p{InCJKSymbolsAndPunctuation}) (64) + \p{Block: CJK_Unified_Ideographs} (Single: + \p{InCJKUnifiedIdeographs}) (20_992) + \p{Block: CJK_Unified_Ideographs_Extension_A} (Single: + \p{InCJKUnifiedIdeographsExtensionA}) + (6592) + \p{Block: CJK_Unified_Ideographs_Extension_B} (Single: + \p{InCJKUnifiedIdeographsExtensionB}) + (42_720) + \p{Block: Combining_Diacritical_Marks} (Single: + \p{InCombiningDiacriticalMarks}) (112) + \p{Block: Combining_Diacritical_Marks_For_Symbols} (Short: \p{Blk= + CombiningMarksForSymbols}, + \p{InCombiningMarksForSymbols}) (48) + \p{Block: Combining_Diacritical_Marks_Supplement} (Single: + \p{InCombiningDiacriticalMarks- + Supplement}) (64) + \p{Block: Combining_Half_Marks} (Single: \p{InCombiningHalfMarks}) + (16) + \p{Block: Combining_Marks_For_Symbols} \p{Block= + Combining_Diacritical_Marks_For_Symbols} + (48) + \p{Block: Control_Pictures} (Single: \p{InControlPictures}) (64) + \p{Block: Coptic} (Single: \p{InCoptic}; NOT \p{Coptic} NOR + \p{Is_Coptic}) (128) + \p{Block: Counting_Rod_Numerals} (Single: + \p{InCountingRodNumerals}) (32) + \p{Block: Cuneiform} (Single: \p{InCuneiform}; NOT + \p{Cuneiform} NOR \p{Is_Cuneiform}) + (1024) + \p{Block: Cuneiform_Numbers_And_Punctuation} (Single: + \p{InCuneiformNumbersAndPunctuation}) + (128) + \p{Block: Currency_Symbols} (Single: \p{InCurrencySymbols}) (48) + \p{Block: Cypriot_Syllabary} (Single: \p{InCypriotSyllabary}) (64) + \p{Block: Cyrillic} (Single: \p{InCyrillic}; NOT \p{Cyrillic} + NOR \p{Is_Cyrillic}) (256) + \p{Block: Cyrillic_Extended_A} (Single: \p{InCyrillicExtendedA}) + (32) + \p{Block: Cyrillic_Extended_B} (Single: \p{InCyrillicExtendedB}) + (96) + \p{Block: Cyrillic_Supplement} (Single: \p{InCyrillicSupplement}) + (48) + \p{Block: Cyrillic_Supplementary} \p{Block=Cyrillic_Supplement} + (48) + \p{Block: Deseret} (Single: \p{InDeseret}) (80) + \p{Block: Devanagari} (Single: \p{InDevanagari}; NOT + \p{Devanagari} NOR \p{Is_Devanagari}) + (128) + \p{Block: Dingbats} (Single: \p{InDingbats}) (192) + \p{Block: Domino_Tiles} (Single: \p{InDominoTiles}) (112) + \p{Block: Enclosed_Alphanumerics} (Single: + \p{InEnclosedAlphanumerics}) (160) + \p{Block: Enclosed_CJK_Letters_And_Months} (Single: + \p{InEnclosedCJKLettersAndMonths}) (256) + \p{Block: Ethiopic} (Single: \p{InEthiopic}; NOT \p{Ethiopic} + NOR \p{Is_Ethiopic}) (384) + \p{Block: Ethiopic_Extended} (Single: \p{InEthiopicExtended}) (96) + \p{Block: Ethiopic_Supplement} (Single: \p{InEthiopicSupplement}) + (32) + \p{Block: General_Punctuation} (Single: \p{InGeneralPunctuation}) + (112) + \p{Block: Geometric_Shapes} (Single: \p{InGeometricShapes}) (96) + \p{Block: Georgian} (Single: \p{InGeorgian}; NOT \p{Georgian} + NOR \p{Is_Georgian}) (96) + \p{Block: Georgian_Supplement} (Single: \p{InGeorgianSupplement}) + (48) + \p{Block: Glagolitic} (Single: \p{InGlagolitic}; NOT + \p{Glagolitic} NOR \p{Is_Glagolitic}) + (96) + \p{Block: Gothic} (Single: \p{InGothic}; NOT \p{Gothic} NOR + \p{Is_Gothic}) (32) + \p{Block: Greek} \p{Block=Greek_And_Coptic} (NOT \p{Greek} + NOR \p{Is_Greek}) (144) + \p{Block: Greek_And_Coptic} (Short: \p{Blk=Greek}, \p{InGreek}; + NOT \p{Greek} NOR \p{Is_Greek}) (144) + \p{Block: Greek_Extended} (Single: \p{InGreekExtended}) (256) + \p{Block: Gujarati} (Single: \p{InGujarati}; NOT \p{Gujarati} + NOR \p{Is_Gujarati}) (128) + \p{Block: Gurmukhi} (Single: \p{InGurmukhi}; NOT \p{Gurmukhi} + NOR \p{Is_Gurmukhi}) (128) + \p{Block: Halfwidth_And_Fullwidth_Forms} (Single: + \p{InHalfwidthAndFullwidthForms}) (240) + \p{Block: Hangul_Compatibility_Jamo} (Single: + \p{InHangulCompatibilityJamo}) (96) + \p{Block: Hangul_Jamo} (Single: \p{InHangulJamo}) (256) + \p{Block: Hangul_Syllables} (Single: \p{InHangulSyllables}) + (11_184) + \p{Block: Hanunoo} (Single: \p{InHanunoo}; NOT \p{Hanunoo} + NOR \p{Is_Hanunoo}) (32) + \p{Block: Hebrew} (Single: \p{InHebrew}; NOT \p{Hebrew} NOR + \p{Is_Hebrew}) (112) + \p{Block: High_Private_Use_Surrogates} (Single: + \p{InHighPrivateUseSurrogates}) (128) + \p{Block: High_Surrogates} (Single: \p{InHighSurrogates}) (896) + \p{Block: Hiragana} (Single: \p{InHiragana}; NOT \p{Hiragana} + NOR \p{Is_Hiragana}) (96) + \p{Block: Ideographic_Description_Characters} (Single: + \p{InIdeographicDescriptionCharacters}) + (16) + \p{Block: IPA_Extensions} (Single: \p{InIPAExtensions}) (96) + \p{Block: Kanbun} (Single: \p{InKanbun}) (16) + \p{Block: Kangxi_Radicals} (Single: \p{InKangxiRadicals}) (224) + \p{Block: Kannada} (Single: \p{InKannada}; NOT \p{Kannada} + NOR \p{Is_Kannada}) (128) + \p{Block: Katakana} (Single: \p{InKatakana}; NOT \p{Katakana} + NOR \p{Is_Katakana}) (96) + \p{Block: Katakana_Phonetic_Extensions} (Single: + \p{InKatakanaPhoneticExtensions}) (16) + \p{Block: Kayah_Li} (Single: \p{InKayahLi}) (48) + \p{Block: Kharoshthi} (Single: \p{InKharoshthi}; NOT + \p{Kharoshthi} NOR \p{Is_Kharoshthi}) + (96) + \p{Block: Khmer} (Single: \p{InKhmer}; NOT \p{Khmer} NOR + \p{Is_Khmer}) (128) + \p{Block: Khmer_Symbols} (Single: \p{InKhmerSymbols}) (32) + \p{Block: Lao} (Single: \p{InLao}; NOT \p{Lao} NOR + \p{Is_Lao}) (128) + \p{Block: Latin_1} \p{Block=Latin_1_Supplement} (128) + \p{Block: Latin_1_Supplement} (Short: \p{Blk=Latin1}, + \p{InLatin1}) (128) + \p{Block: Latin_Extended_A} (Single: \p{InLatinExtendedA}) (128) + \p{Block: Latin_Extended_Additional} (Single: + \p{InLatinExtendedAdditional}) (256) + \p{Block: Latin_Extended_B} (Single: \p{InLatinExtendedB}) (208) + \p{Block: Latin_Extended_C} (Single: \p{InLatinExtendedC}) (32) + \p{Block: Latin_Extended_D} (Single: \p{InLatinExtendedD}) (224) + \p{Block: Lepcha} (Single: \p{InLepcha}; NOT \p{Lepcha} NOR + \p{Is_Lepcha}) (80) + \p{Block: Letterlike_Symbols} (Single: \p{InLetterlikeSymbols}) + (80) + \p{Block: Limbu} (Single: \p{InLimbu}; NOT \p{Limbu} NOR + \p{Is_Limbu}) (80) + \p{Block: Linear_B_Ideograms} (Single: \p{InLinearBIdeograms}) + (128) + \p{Block: Linear_B_Syllabary} (Single: \p{InLinearBSyllabary}) + (128) + \p{Block: Low_Surrogates} (Single: \p{InLowSurrogates}) (1024) + \p{Block: Lycian} (Single: \p{InLycian}; NOT \p{Lycian} NOR + \p{Is_Lycian}) (32) + \p{Block: Lydian} (Single: \p{InLydian}; NOT \p{Lydian} NOR + \p{Is_Lydian}) (32) + \p{Block: Mahjong_Tiles} (Single: \p{InMahjongTiles}) (48) + \p{Block: Malayalam} (Single: \p{InMalayalam}; NOT + \p{Malayalam} NOR \p{Is_Malayalam}) (128) + \p{Block: Mathematical_Alphanumeric_Symbols} (Single: + \p{InMathematicalAlphanumericSymbols}) + (1024) + \p{Block: Mathematical_Operators} (Single: + \p{InMathematicalOperators}) (256) + \p{Block: Miscellaneous_Mathematical_Symbols_A} (Single: + \p{InMiscellaneousMathematicalSymbolsA}) + (48) + \p{Block: Miscellaneous_Mathematical_Symbols_B} (Single: + \p{InMiscellaneousMathematicalSymbolsB}) + (128) + \p{Block: Miscellaneous_Symbols} (Single: + \p{InMiscellaneousSymbols}) (256) + \p{Block: Miscellaneous_Symbols_And_Arrows} (Single: + \p{InMiscellaneousSymbolsAndArrows}) + (256) + \p{Block: Miscellaneous_Technical} (Single: + \p{InMiscellaneousTechnical}) (256) + \p{Block: Modifier_Tone_Letters} (Single: + \p{InModifierToneLetters}) (32) + \p{Block: Mongolian} (Single: \p{InMongolian}; NOT + \p{Mongolian} NOR \p{Is_Mongolian}) (176) + \p{Block: Musical_Symbols} (Single: \p{InMusicalSymbols}) (256) + \p{Block: Myanmar} (Single: \p{InMyanmar}; NOT \p{Myanmar} + NOR \p{Is_Myanmar}) (160) + \p{Block: New_Tai_Lue} (Single: \p{InNewTaiLue}; NOT + \p{New_Tai_Lue} NOR \p{Is_New_Tai_Lue}) + (96) + \p{Block: NKo} (Single: \p{InNKo}; NOT \p{Nko} NOR + \p{Is_NKo}) (64) + \p{Block: No_Block} (Single: \p{InNoBlock}) (871_248) + \p{Block: Number_Forms} (Single: \p{InNumberForms}) (64) + \p{Block: Ogham} (Single: \p{InOgham}; NOT \p{Ogham} NOR + \p{Is_Ogham}) (32) + \p{Block: Ol_Chiki} (Single: \p{InOlChiki}) (48) + \p{Block: Old_Italic} (Single: \p{InOldItalic}; NOT + \p{Old_Italic} NOR \p{Is_Old_Italic}) + (48) + \p{Block: Old_Persian} (Single: \p{InOldPersian}; NOT + \p{Old_Persian} NOR \p{Is_Old_Persian}) + (64) + \p{Block: Optical_Character_Recognition} (Single: + \p{InOpticalCharacterRecognition}) (32) + \p{Block: Oriya} (Single: \p{InOriya}; NOT \p{Oriya} NOR + \p{Is_Oriya}) (128) + \p{Block: Osmanya} (Single: \p{InOsmanya}; NOT \p{Osmanya} + NOR \p{Is_Osmanya}) (48) + \p{Block: Phags_Pa} (Single: \p{InPhagsPa}; NOT \p{Phags_Pa} + NOR \p{Is_Phags_Pa}) (64) + \p{Block: Phaistos_Disc} (Single: \p{InPhaistosDisc}) (48) + \p{Block: Phoenician} (Single: \p{InPhoenician}; NOT + \p{Phoenician} NOR \p{Is_Phoenician}) + (32) + \p{Block: Phonetic_Extensions} (Single: \p{InPhoneticExtensions}) + (128) + \p{Block: Phonetic_Extensions_Supplement} (Single: + \p{InPhoneticExtensionsSupplement}) (64) + \p{Block: Private_Use} \p{Block=Private_Use_Area} (NOT + \p{Private_Use} NOR \p{Is_Private_Use}) + (6400) + \p{Block: Private_Use_Area} (Short: \p{Blk=PrivateUse}, + \p{InPrivateUse}; NOT \p{Private_Use} + NOR \p{Is_Private_Use}) (6400) + \p{Block: Rejang} (Single: \p{InRejang}; NOT \p{Rejang} NOR + \p{Is_Rejang}) (48) + \p{Block: Runic} (Single: \p{InRunic}; NOT \p{Runic} NOR + \p{Is_Runic}) (96) + \p{Block: Saurashtra} (Single: \p{InSaurashtra}; NOT + \p{Saurashtra} NOR \p{Is_Saurashtra}) + (96) + \p{Block: Shavian} (Single: \p{InShavian}) (48) + \p{Block: Sinhala} (Single: \p{InSinhala}; NOT \p{Sinhala} + NOR \p{Is_Sinhala}) (128) + \p{Block: Small_Form_Variants} (Single: \p{InSmallFormVariants}) + (32) + \p{Block: Spacing_Modifier_Letters} (Single: + \p{InSpacingModifierLetters}) (80) + \p{Block: Specials} (Single: \p{InSpecials}) (16) + \p{Block: Sundanese} (Single: \p{InSundanese}; NOT + \p{Sundanese} NOR \p{Is_Sundanese}) (64) + \p{Block: Superscripts_And_Subscripts} (Single: + \p{InSuperscriptsAndSubscripts}) (48) + \p{Block: Supplemental_Arrows_A} (Single: + \p{InSupplementalArrowsA}) (16) + \p{Block: Supplemental_Arrows_B} (Single: + \p{InSupplementalArrowsB}) (128) + \p{Block: Supplemental_Mathematical_Operators} (Single: + \p{InSupplementalMathematicalOperators}) + (256) + \p{Block: Supplemental_Punctuation} (Single: + \p{InSupplementalPunctuation}) (128) + \p{Block: Supplementary_Private_Use_Area_A} (Single: + \p{InSupplementaryPrivateUseAreaA}) + (65_536) + \p{Block: Supplementary_Private_Use_Area_B} (Single: + \p{InSupplementaryPrivateUseAreaB}) + (65_536) + \p{Block: Syloti_Nagri} (Single: \p{InSylotiNagri}; NOT + \p{Syloti_Nagri} NOR + \p{Is_Syloti_Nagri}) (48) + \p{Block: Syriac} (Single: \p{InSyriac}; NOT \p{Syriac} NOR + \p{Is_Syriac}) (80) + \p{Block: Tagalog} (Single: \p{InTagalog}; NOT \p{Tagalog} + NOR \p{Is_Tagalog}) (32) + \p{Block: Tagbanwa} (Single: \p{InTagbanwa}; NOT \p{Tagbanwa} + NOR \p{Is_Tagbanwa}) (32) + \p{Block: Tags} (Single: \p{InTags}) (128) + \p{Block: Tai_Le} (Single: \p{InTaiLe}; NOT \p{Tai_Le} NOR + \p{Is_Tai_Le}) (48) + \p{Block: Tai_Xuan_Jing_Symbols} (Single: + \p{InTaiXuanJingSymbols}) (96) + \p{Block: Tamil} (Single: \p{InTamil}; NOT \p{Tamil} NOR + \p{Is_Tamil}) (128) + \p{Block: Telugu} (Single: \p{InTelugu}; NOT \p{Telugu} NOR + \p{Is_Telugu}) (128) + \p{Block: Thaana} (Single: \p{InThaana}; NOT \p{Thaana} NOR + \p{Is_Thaana}) (64) + \p{Block: Thai} (Single: \p{InThai}; NOT \p{Thai} NOR + \p{Is_Thai}) (128) + \p{Block: Tibetan} (Single: \p{InTibetan}; NOT \p{Tibetan} + NOR \p{Is_Tibetan}) (256) + \p{Block: Tifinagh} (Single: \p{InTifinagh}; NOT \p{Tifinagh} + NOR \p{Is_Tifinagh}) (80) + \p{Block: Ugaritic} (Single: \p{InUgaritic}; NOT \p{Ugaritic} + NOR \p{Is_Ugaritic}) (32) + \p{Block: Unified_Canadian_Aboriginal_Syllabics} (Short: \p{Blk= + CanadianSyllabics}, + \p{InCanadianSyllabics}) (640) + \p{Block: Vai} (Single: \p{InVai}; NOT \p{Vai} NOR + \p{Is_Vai}) (320) + \p{Block: Variation_Selectors} (Single: \p{InVariationSelectors}) + (16) + \p{Block: Variation_Selectors_Supplement} (Single: + \p{InVariationSelectorsSupplement}) (240) + \p{Block: Vertical_Forms} (Single: \p{InVerticalForms}) (16) + \p{Block: Yi_Radicals} (Single: \p{InYiRadicals}) (64) + \p{Block: Yi_Syllables} (Single: \p{InYiSyllables}) (1168) + \p{Block: Yijing_Hexagram_Symbols} (Single: + \p{InYijingHexagramSymbols}) (64) + X \p{Block_Elements} \p{Block=Block_Elements} (32) + \p{Bopo} \p{Bopomofo} (= \p{Script=Bopomofo}) (NOT + \p{Block=Bopomofo}) (65) + \p{Bopomofo} \p{Script=Bopomofo} (Short: \p{Bopo}; NOT + \p{Block=Bopomofo}) (65) + X \p{Bopomofo_Extended} \p{Block=Bopomofo_Extended} (32) + X \p{Box_Drawing} \p{Block=Box_Drawing} (128) + \p{Brai} \p{Braille} (= \p{Script=Braille}) (256) + \p{Braille} \p{Script=Braille} (Short: \p{Brai}) (256) + X \p{Braille_Patterns} \p{Block=Braille_Patterns} (256) + \p{Bugi} \p{Buginese} (= \p{Script=Buginese}) (NOT + \p{Block=Buginese}) (30) + \p{Buginese} \p{Script=Buginese} (Short: \p{Bugi}; NOT + \p{Block=Buginese}) (30) + \p{Buhd} \p{Buhid} (= \p{Script=Buhid}) (NOT + \p{Block=Buhid}) (20) + \p{Buhid} \p{Script=Buhid} (Short: \p{Buhd}; NOT + \p{Block=Buhid}) (20) + X \p{Byzantine_Musical_Symbols} \p{Block=Byzantine_Musical_Symbols} + (256) + \p{C} \p{Other} (= \p{General_Category=Other}) + (1_013_603) + \p{Canadian_Aboriginal} \p{Script=Canadian_Aboriginal} (Short: + \p{Cans}) (630) + X \p{Canadian_Syllabics} \p{Unified_Canadian_Aboriginal_Syllabics} + (= \p{Block= + Unified_Canadian_Aboriginal_Syllabics}) + (640) + T \p{Canonical_Combining_Class: 0} \p{Canonical_Combining_Class= + Not_Reordered} (1_113_611) + T \p{Canonical_Combining_Class: 1} \p{Canonical_Combining_Class= + Overlay} (18) + T \p{Canonical_Combining_Class: 7} \p{Canonical_Combining_Class= + Nukta} (9) + T \p{Canonical_Combining_Class: 8} \p{Canonical_Combining_Class= + Kana_Voicing} (2) + T \p{Canonical_Combining_Class: 9} \p{Canonical_Combining_Class= + Virama} (23) + T \p{Canonical_Combining_Class: 10} (Short: \p{Ccc=10}) (1) + T \p{Canonical_Combining_Class: 11} (Short: \p{Ccc=11}) (1) + T \p{Canonical_Combining_Class: 12} (Short: \p{Ccc=12}) (1) + T \p{Canonical_Combining_Class: 13} (Short: \p{Ccc=13}) (1) + T \p{Canonical_Combining_Class: 14} (Short: \p{Ccc=14}) (1) + T \p{Canonical_Combining_Class: 15} (Short: \p{Ccc=15}) (1) + T \p{Canonical_Combining_Class: 16} (Short: \p{Ccc=16}) (1) + T \p{Canonical_Combining_Class: 17} (Short: \p{Ccc=17}) (1) + T \p{Canonical_Combining_Class: 18} (Short: \p{Ccc=18}) (2) + T \p{Canonical_Combining_Class: 19} (Short: \p{Ccc=19}) (2) + T \p{Canonical_Combining_Class: 20} (Short: \p{Ccc=20}) (1) + T \p{Canonical_Combining_Class: 21} (Short: \p{Ccc=21}) (1) + T \p{Canonical_Combining_Class: 22} (Short: \p{Ccc=22}) (1) + T \p{Canonical_Combining_Class: 23} (Short: \p{Ccc=23}) (1) + T \p{Canonical_Combining_Class: 24} (Short: \p{Ccc=24}) (1) + T \p{Canonical_Combining_Class: 25} (Short: \p{Ccc=25}) (1) + T \p{Canonical_Combining_Class: 26} (Short: \p{Ccc=26}) (1) + T \p{Canonical_Combining_Class: 27} (Short: \p{Ccc=27}) (1) + T \p{Canonical_Combining_Class: 28} (Short: \p{Ccc=28}) (1) + T \p{Canonical_Combining_Class: 29} (Short: \p{Ccc=29}) (1) + T \p{Canonical_Combining_Class: 30} (Short: \p{Ccc=30}) (2) + T \p{Canonical_Combining_Class: 31} (Short: \p{Ccc=31}) (2) + T \p{Canonical_Combining_Class: 32} (Short: \p{Ccc=32}) (2) + T \p{Canonical_Combining_Class: 33} (Short: \p{Ccc=33}) (1) + T \p{Canonical_Combining_Class: 34} (Short: \p{Ccc=34}) (1) + T \p{Canonical_Combining_Class: 35} (Short: \p{Ccc=35}) (1) + T \p{Canonical_Combining_Class: 36} (Short: \p{Ccc=36}) (1) + T \p{Canonical_Combining_Class: 84} (Short: \p{Ccc=84}) (1) + T \p{Canonical_Combining_Class: 91} (Short: \p{Ccc=91}) (1) + T \p{Canonical_Combining_Class: 103} (Short: \p{Ccc=103}) (2) + T \p{Canonical_Combining_Class: 107} (Short: \p{Ccc=107}) (4) + T \p{Canonical_Combining_Class: 118} (Short: \p{Ccc=118}) (2) + T \p{Canonical_Combining_Class: 122} (Short: \p{Ccc=122}) (4) + T \p{Canonical_Combining_Class: 129} (Short: \p{Ccc=129}) (1) + T \p{Canonical_Combining_Class: 130} (Short: \p{Ccc=130}) (6) + T \p{Canonical_Combining_Class: 132} (Short: \p{Ccc=132}) (1) + T \p{Canonical_Combining_Class: 200} \p{Canonical_Combining_Class= + Attached_Below_Left} (0) + T \p{Canonical_Combining_Class: 202} \p{Canonical_Combining_Class= + Attached_Below} (5) + T \p{Canonical_Combining_Class: 214} (Short: \p{Ccc=214}) (1) + T \p{Canonical_Combining_Class: 216} \p{Canonical_Combining_Class= + Attached_Above_Right} (9) + T \p{Canonical_Combining_Class: 218} \p{Canonical_Combining_Class= + Below_Left} (1) + T \p{Canonical_Combining_Class: 220} \p{Canonical_Combining_Class= + Below} (104) + T \p{Canonical_Combining_Class: 222} \p{Canonical_Combining_Class= + Below_Right} (4) + T \p{Canonical_Combining_Class: 224} \p{Canonical_Combining_Class= + Left} (2) + T \p{Canonical_Combining_Class: 226} \p{Canonical_Combining_Class= + Right} (1) + T \p{Canonical_Combining_Class: 228} \p{Canonical_Combining_Class= + Above_Left} (3) + T \p{Canonical_Combining_Class: 230} \p{Canonical_Combining_Class= + Above} (252) + T \p{Canonical_Combining_Class: 232} \p{Canonical_Combining_Class= + Above_Right} (4) + T \p{Canonical_Combining_Class: 233} \p{Canonical_Combining_Class= + Double_Below} (3) + T \p{Canonical_Combining_Class: 234} \p{Canonical_Combining_Class= + Double_Above} (5) + T \p{Canonical_Combining_Class: 240} \p{Canonical_Combining_Class= + Iota_Subscript} (1) + \p{Canonical_Combining_Class: A} \p{Canonical_Combining_Class= + Above} (252) + \p{Canonical_Combining_Class: Above} (Short: \p{Ccc=A}) (252) + \p{Canonical_Combining_Class: Above_Left} (Short: \p{Ccc=AL}) (3) + \p{Canonical_Combining_Class: Above_Right} (Short: \p{Ccc=AR}) (4) + \p{Canonical_Combining_Class: AL} \p{Canonical_Combining_Class= + Above_Left} (3) + \p{Canonical_Combining_Class: AR} \p{Canonical_Combining_Class= + Above_Right} (4) + \p{Canonical_Combining_Class: ATAR} \p{Canonical_Combining_Class= + Attached_Above_Right} (9) + \p{Canonical_Combining_Class: ATB} \p{Canonical_Combining_Class= + Attached_Below} (5) + \p{Canonical_Combining_Class: ATBL} \p{Canonical_Combining_Class= + Attached_Below_Left} (0) + \p{Canonical_Combining_Class: Attached_Above_Right} (Short: + \p{Ccc=ATAR}) (9) + \p{Canonical_Combining_Class: Attached_Below} (Short: \p{Ccc=ATB}) + (5) + \p{Canonical_Combining_Class: Attached_Below_Left} (Short: \p{Ccc= + ATBL}) (0) + \p{Canonical_Combining_Class: B} \p{Canonical_Combining_Class= + Below} (104) + \p{Canonical_Combining_Class: Below} (Short: \p{Ccc=B}) (104) + \p{Canonical_Combining_Class: Below_Left} (Short: \p{Ccc=BL}) (1) + \p{Canonical_Combining_Class: Below_Right} (Short: \p{Ccc=BR}) (4) + \p{Canonical_Combining_Class: BL} \p{Canonical_Combining_Class= + Below_Left} (1) + \p{Canonical_Combining_Class: BR} \p{Canonical_Combining_Class= + Below_Right} (4) + \p{Canonical_Combining_Class: DA} \p{Canonical_Combining_Class= + Double_Above} (5) + \p{Canonical_Combining_Class: DB} \p{Canonical_Combining_Class= + Double_Below} (3) + \p{Canonical_Combining_Class: Double_Above} (Short: \p{Ccc=DA}) (5) + \p{Canonical_Combining_Class: Double_Below} (Short: \p{Ccc=DB}) (3) + \p{Canonical_Combining_Class: Iota_Subscript} (Short: \p{Ccc=IS}) + (1) + \p{Canonical_Combining_Class: IS} \p{Canonical_Combining_Class= + Iota_Subscript} (1) + \p{Canonical_Combining_Class: Kana_Voicing} (Short: \p{Ccc=KV}) (2) + \p{Canonical_Combining_Class: KV} \p{Canonical_Combining_Class= + Kana_Voicing} (2) + \p{Canonical_Combining_Class: L} \p{Canonical_Combining_Class= + Left} (2) + \p{Canonical_Combining_Class: Left} (Short: \p{Ccc=L}) (2) + \p{Canonical_Combining_Class: NK} \p{Canonical_Combining_Class= + Nukta} (9) + \p{Canonical_Combining_Class: Not_Reordered} (Short: \p{Ccc=NR}) + (1_113_611) + \p{Canonical_Combining_Class: NR} \p{Canonical_Combining_Class= + Not_Reordered} (1_113_611) + \p{Canonical_Combining_Class: Nukta} (Short: \p{Ccc=NK}) (9) + \p{Canonical_Combining_Class: OV} \p{Canonical_Combining_Class= + Overlay} (18) + \p{Canonical_Combining_Class: Overlay} (Short: \p{Ccc=OV}) (18) + \p{Canonical_Combining_Class: R} \p{Canonical_Combining_Class= + Right} (1) + \p{Canonical_Combining_Class: Right} (Short: \p{Ccc=R}) (1) + \p{Canonical_Combining_Class: Virama} (Short: \p{Ccc=VR}) (23) + \p{Canonical_Combining_Class: VR} \p{Canonical_Combining_Class= + Virama} (23) + \p{Cans} \p{Canadian_Aboriginal} (= \p{Script= + Canadian_Aboriginal}) (630) + \p{Cari} \p{Carian} (= \p{Script=Carian}) (NOT + \p{Block=Carian}) (49) + \p{Carian} \p{Script=Carian} (Short: \p{Cari}; NOT + \p{Block=Carian}) (49) + \p{Cased} Uppercase or Lowercase or Titlecase (3401) + \p{Cased_Letter} \p{General_Category=Cased_Letter} (Short: + \p{LC}) (3200) + \p{Category: *} \p{General_Category: *} + \p{Cc} \p{Cntrl} (= \p{General_Category=Control}) + (65) + \p{Ccc: *} \p{Canonical_Combining_Class: *} + \p{CE} \p{Composition_Exclusion} (= + \p{Composition_Exclusion=Y}) (81) + \p{CE: *} \p{Composition_Exclusion: *} + \p{Cf} \p{Format} (= \p{General_Category=Format}) + (139) + \p{Cham} \p{Script=Cham} (NOT \p{Block=Cham}) (83) + \p{Cher} \p{Cherokee} (= \p{Script=Cherokee}) (NOT + \p{Block=Cherokee}) (85) + \p{Cherokee} \p{Script=Cherokee} (Short: \p{Cher}; NOT + \p{Block=Cherokee}) (85) + X \p{CJK_Compatibility} \p{Block=CJK_Compatibility} (256) + X \p{CJK_Compatibility_Forms} \p{Block=CJK_Compatibility_Forms} (32) + X \p{CJK_Compatibility_Ideographs} \p{Block= + CJK_Compatibility_Ideographs} (512) + X \p{CJK_Compatibility_Ideographs_Supplement} \p{Block= + CJK_Compatibility_Ideographs_Supplement} + (544) + X \p{CJK_Radicals_Supplement} \p{Block=CJK_Radicals_Supplement} (128) + X \p{CJK_Strokes} \p{Block=CJK_Strokes} (48) + X \p{CJK_Symbols_And_Punctuation} \p{Block= + CJK_Symbols_And_Punctuation} (64) + X \p{CJK_Unified_Ideographs} \p{Block=CJK_Unified_Ideographs} + (20_992) + X \p{CJK_Unified_Ideographs_Extension_A} \p{Block= + CJK_Unified_Ideographs_Extension_A} + (6592) + X \p{CJK_Unified_Ideographs_Extension_B} \p{Block= + CJK_Unified_Ideographs_Extension_B} + (42_720) + \p{Close_Punctuation} \p{General_Category=Close_Punctuation} + (Short: \p{Pe}) (71) + \p{Cn} \p{Unassigned} (= \p{General_Category= + Unassigned}) (873_883) + \p{Cntrl} \p{General_Category=Control} [[:Cntrl:]] + extended beyond ASCII (Short: \p{Cc}) + (65) + \p{Co} \p{Private_Use} (= \p{General_Category= + Private_Use}) (NOT \p{Private_Use_Area}) + (137_468) + X \p{Combining_Diacritical_Marks} \p{Block= + Combining_Diacritical_Marks} (112) + X \p{Combining_Diacritical_Marks_For_Symbols} \p{Block= + Combining_Diacritical_Marks_For_Symbols} + (Short: \p{InCombiningMarksForSymbols}) + (48) + X \p{Combining_Diacritical_Marks_Supplement} \p{Block= + Combining_Diacritical_Marks_Supplement} + (64) + X \p{Combining_Half_Marks} \p{Block=Combining_Half_Marks} (16) + X \p{Combining_Marks_For_Symbols} + \p{Combining_Diacritical_Marks_For_- + Symbols} (= \p{Block= + Combining_Diacritical_Marks_For_- + Symbols}) (48) + \p{Common} \p{Script=Common} (Short: \p{Zyyy}) (5178) + \p{Comp_Ex} \p{Full_Composition_Exclusion} (= + \p{Full_Composition_Exclusion=Y}) (1115) + \p{Comp_Ex: *} \p{Full_Composition_Exclusion: *} + \p{Composition_Exclusion} \p{Composition_Exclusion=Y} (Short: + \p{CE}) (81) + \p{Composition_Exclusion: N*} (Short: \p{CE=N}, \P{CE}) (1_114_031) + \p{Composition_Exclusion: Y*} (Short: \p{CE=Y}, \p{CE}) (81) + \p{Connector_Punctuation} \p{General_Category= + Connector_Punctuation} (Short: \p{Pc}) + (10) + \p{Control} \p{Cntrl} (= \p{General_Category=Control}) + (65) + X \p{Control_Pictures} \p{Block=Control_Pictures} (64) + \p{Copt} \p{Coptic} (= \p{Script=Coptic}) (NOT + \p{Block=Coptic}) (128) + \p{Coptic} \p{Script=Coptic} (Short: \p{Copt}; NOT + \p{Block=Coptic}) (128) + X \p{Counting_Rod_Numerals} \p{Block=Counting_Rod_Numerals} (32) + \p{Cprt} \p{Cypriot} (= \p{Script=Cypriot}) (55) + \p{Cs} \p{Surrogate} (= \p{General_Category= + Surrogate}) (2048) + \p{Cuneiform} \p{Script=Cuneiform} (Short: \p{Xsux}; NOT + \p{Block=Cuneiform}) (982) + X \p{Cuneiform_Numbers_And_Punctuation} \p{Block= + Cuneiform_Numbers_And_Punctuation} (128) + \p{Currency_Symbol} \p{General_Category=Currency_Symbol} + (Short: \p{Sc}) (41) + X \p{Currency_Symbols} \p{Block=Currency_Symbols} (48) + \p{Cypriot} \p{Script=Cypriot} (Short: \p{Cprt}) (55) + X \p{Cypriot_Syllabary} \p{Block=Cypriot_Syllabary} (64) + \p{Cyrillic} \p{Script=Cyrillic} (Short: \p{Cyrl}; NOT + \p{Block=Cyrillic}) (404) + X \p{Cyrillic_Extended_A} \p{Block=Cyrillic_Extended_A} (32) + X \p{Cyrillic_Extended_B} \p{Block=Cyrillic_Extended_B} (96) + X \p{Cyrillic_Supplement} \p{Block=Cyrillic_Supplement} (48) + X \p{Cyrillic_Supplementary} \p{Cyrillic_Supplement} (= \p{Block= + Cyrillic_Supplement}) (48) + \p{Cyrl} \p{Cyrillic} (= \p{Script=Cyrillic}) (NOT + \p{Block=Cyrillic}) (404) + \p{Dash} \p{Dash=Y} (24) + \p{Dash: N*} (Single: \P{Dash}) (1_114_088) + \p{Dash: Y*} (Single: \p{Dash}) (24) + \p{Dash_Punctuation} \p{General_Category=Dash_Punctuation} + (Short: \p{Pd}) (20) + \p{Decimal_Number} \p{Digit} (= \p{General_Category= + Decimal_Number}) (370) + \p{Decomposition_Type: Can} \p{Decomposition_Type=Canonical} + (13_215) + \p{Decomposition_Type: Canonical} (Short: \p{Dt=Can}) (13_215) + \p{Decomposition_Type: Circle} (Short: \p{Dt=Enc}) (230) + \p{Decomposition_Type: Com} \p{Decomposition_Type=Compat} (673) + \p{Decomposition_Type: Compat} (Short: \p{Dt=Com}) (673) + \p{Decomposition_Type: Enc} \p{Decomposition_Type=Circle} (230) + \p{Decomposition_Type: Fin} \p{Decomposition_Type=Final} (240) + \p{Decomposition_Type: Final} (Short: \p{Dt=Fin}) (240) + \p{Decomposition_Type: Font} (Short: \p{Dt=Font}) (1043) + \p{Decomposition_Type: Fra} \p{Decomposition_Type=Fraction} (16) + \p{Decomposition_Type: Fraction} (Short: \p{Dt=Fra}) (16) + \p{Decomposition_Type: Init} \p{Decomposition_Type=Initial} (171) + \p{Decomposition_Type: Initial} (Short: \p{Dt=Init}) (171) + \p{Decomposition_Type: Iso} \p{Decomposition_Type=Isolated} (238) + \p{Decomposition_Type: Isolated} (Short: \p{Dt=Iso}) (238) + \p{Decomposition_Type: Med} \p{Decomposition_Type=Medial} (82) + \p{Decomposition_Type: Medial} (Short: \p{Dt=Med}) (82) + \p{Decomposition_Type: Nar} \p{Decomposition_Type=Narrow} (122) + \p{Decomposition_Type: Narrow} (Short: \p{Dt=Nar}) (122) + \p{Decomposition_Type: Nb} \p{Decomposition_Type=Nobreak} (5) + \p{Decomposition_Type: Nobreak} (Short: \p{Dt=Nb}) (5) + \p{Decomposition_Type: Non_Canon} \p{Decomposition_Type= + Non_Canonical} (3362) + \p{Decomposition_Type: Non_Canonical} Perl extension consisting of + the union of all non-canonical + decompositions (Short: \p{Dt=NonCanon}) + (3362) + \p{Decomposition_Type: None} (Short: \p{Dt=None}) (1_097_535) + \p{Decomposition_Type: Small} (Short: \p{Dt=Sml}) (26) + \p{Decomposition_Type: Sml} \p{Decomposition_Type=Small} (26) + \p{Decomposition_Type: Sqr} \p{Decomposition_Type=Square} (205) + \p{Decomposition_Type: Square} (Short: \p{Dt=Sqr}) (205) + \p{Decomposition_Type: Sub} (Short: \p{Dt=Sub}) (30) + \p{Decomposition_Type: Sup} \p{Decomposition_Type=Super} (142) + \p{Decomposition_Type: Super} (Short: \p{Dt=Sup}) (142) + \p{Decomposition_Type: Vert} \p{Decomposition_Type=Vertical} (35) + \p{Decomposition_Type: Vertical} (Short: \p{Dt=Vert}) (35) + \p{Decomposition_Type: Wide} (Short: \p{Dt=Wide}) (104) + \p{Default_Ignorable_Code_Point} \p{Default_Ignorable_Code_Point= + Y} (Short: \p{DI}) (4167) + \p{Default_Ignorable_Code_Point: N*} (Short: \p{DI=N}, \P{DI}) + (1_109_945) + \p{Default_Ignorable_Code_Point: Y*} (Short: \p{DI=Y}, \p{DI}) + (4167) + \p{Dep} \p{Deprecated} (= \p{Deprecated=Y}) (107) + \p{Dep: *} \p{Deprecated: *} + \p{Deprecated} \p{Deprecated=Y} (Short: \p{Dep}) (107) + \p{Deprecated: N*} (Short: \p{Dep=N}, \P{Dep}) (1_114_005) + \p{Deprecated: Y*} (Short: \p{Dep=Y}, \p{Dep}) (107) + \p{Deseret} \p{Script=Deseret} (Short: \p{Dsrt}) (80) + \p{Deva} \p{Devanagari} (= \p{Script=Devanagari}) + (NOT \p{Block=Devanagari}) (107) + \p{Devanagari} \p{Script=Devanagari} (Short: \p{Deva}; + NOT \p{Block=Devanagari}) (107) + \p{DI} \p{Default_Ignorable_Code_Point} (= + \p{Default_Ignorable_Code_Point=Y}) + (4167) + \p{DI: *} \p{Default_Ignorable_Code_Point: *} + \p{Dia} \p{Diacritic} (= \p{Diacritic=Y}) (565) + \p{Dia: *} \p{Diacritic: *} + \p{Diacritic} \p{Diacritic=Y} (Short: \p{Dia}) (565) + \p{Diacritic: N*} (Short: \p{Dia=N}, \P{Dia}) (1_113_547) + \p{Diacritic: Y*} (Short: \p{Dia=Y}, \p{Dia}) (565) + \p{Digit} \p{General_Category=Decimal_Number} \d, + extended beyond just [0-9] (Short: + \p{Nd}) (370) + X \p{Dingbats} \p{Block=Dingbats} (192) + X \p{Domino_Tiles} \p{Block=Domino_Tiles} (112) + \p{Dsrt} \p{Deseret} (= \p{Script=Deseret}) (80) + \p{Dt: *} \p{Decomposition_Type: *} + \p{Ea: *} \p{East_Asian_Width: *} + \p{East_Asian_Width: A} \p{East_Asian_Width=Ambiguous} (138_531) + \p{East_Asian_Width: Ambiguous} (Short: \p{Ea=A}) (138_531) + \p{East_Asian_Width: F} \p{East_Asian_Width=Fullwidth} (104) + \p{East_Asian_Width: Fullwidth} (Short: \p{Ea=F}) (104) + \p{East_Asian_Width: H} \p{East_Asian_Width=Halfwidth} (123) + \p{East_Asian_Width: Halfwidth} (Short: \p{Ea=H}) (123) + \p{East_Asian_Width: N} \p{East_Asian_Width=Neutral} (802_324) + \p{East_Asian_Width: Na} \p{East_Asian_Width=Narrow} (111) + \p{East_Asian_Width: Narrow} (Short: \p{Ea=Na}) (111) + \p{East_Asian_Width: Neutral} (Short: \p{Ea=N}) (802_324) + \p{East_Asian_Width: W} \p{East_Asian_Width=Wide} (172_919) + \p{East_Asian_Width: Wide} (Short: \p{Ea=W}) (172_919) + X \p{Enclosed_Alphanumerics} \p{Block=Enclosed_Alphanumerics} (160) + X \p{Enclosed_CJK_Letters_And_Months} \p{Block= + Enclosed_CJK_Letters_And_Months} (256) + \p{Enclosing_Mark} \p{General_Category=Enclosing_Mark} + (Short: \p{Me}) (13) + \p{Ethi} \p{Ethiopic} (= \p{Script=Ethiopic}) (NOT + \p{Block=Ethiopic}) (461) + \p{Ethiopic} \p{Script=Ethiopic} (Short: \p{Ethi}; NOT + \p{Block=Ethiopic}) (461) + X \p{Ethiopic_Extended} \p{Block=Ethiopic_Extended} (96) + X \p{Ethiopic_Supplement} \p{Block=Ethiopic_Supplement} (32) + \p{Ext} \p{Extender} (= \p{Extender=Y}) (24) + \p{Ext: *} \p{Extender: *} + \p{Extender} \p{Extender=Y} (Short: \p{Ext}) (24) + \p{Extender: N*} (Short: \p{Ext=N}, \P{Ext}) (1_114_088) + \p{Extender: Y*} (Short: \p{Ext=Y}, \p{Ext}) (24) + \p{Final_Punctuation} \p{General_Category=Final_Punctuation} + (Short: \p{Pf}) (10) + \p{Format} \p{General_Category=Format} (Short: + \p{Cf}) (139) + \p{Full_Composition_Exclusion} \p{Full_Composition_Exclusion=Y} + (Short: \p{CompEx}) (1115) + \p{Full_Composition_Exclusion: N*} (Short: \p{CompEx=N}, + \P{CompEx}) (1_112_997) + \p{Full_Composition_Exclusion: Y*} (Short: \p{CompEx=Y}, + \p{CompEx}) (1115) + \p{Gc: *} \p{General_Category: *} + \p{GCB: *} \p{Grapheme_Cluster_Break: *} + \p{General_Category: C} \p{General_Category=Other} (1_013_603) + \p{General_Category: Cased_Letter} [\p{Ll}\p{Lu}\p{Lt}] (Short: + \p{Gc=LC}, \p{LC}) (3200) + \p{General_Category: Cc} \p{General_Category=Control} (65) + \p{General_Category: Cf} \p{General_Category=Format} (139) + \p{General_Category: Close_Punctuation} (Short: \p{Gc=Pe}, \p{Pe}) + (71) + \p{General_Category: Cn} \p{General_Category=Unassigned} (873_883) + \p{General_Category: Cntrl} \p{General_Category=Control} (65) + \p{General_Category: Co} \p{General_Category=Private_Use} (137_468) + \p{General_Category: Connector_Punctuation} (Short: \p{Gc=Pc}, + \p{Pc}) (10) + \p{General_Category: Control} (Short: \p{Gc=Cc}, \p{Cc}) (65) + \p{General_Category: Cs} \p{General_Category=Surrogate} (2048) + \p{General_Category: Currency_Symbol} (Short: \p{Gc=Sc}, \p{Sc}) + (41) + \p{General_Category: Dash_Punctuation} (Short: \p{Gc=Pd}, \p{Pd}) + (20) + \p{General_Category: Decimal_Number} (Short: \p{Gc=Nd}, \p{Nd}) + (370) + \p{General_Category: Digit} \p{General_Category=Decimal_Number} + (370) + \p{General_Category: Enclosing_Mark} (Short: \p{Gc=Me}, \p{Me}) + (13) + \p{General_Category: Final_Punctuation} (Short: \p{Gc=Pf}, \p{Pf}) + (10) + \p{General_Category: Format} (Short: \p{Gc=Cf}, \p{Cf}) (139) + \p{General_Category: Initial_Punctuation} (Short: \p{Gc=Pi}, + \p{Pi}) (12) + \p{General_Category: L} \p{General_Category=Letter} (93_455) + X \p{General_Category: L&} \p{General_Category=Cased_Letter} (3200) + X \p{General_Category: L_} \p{General_Category=Cased_Letter} (3200) + \p{General_Category: LC} \p{General_Category=Cased_Letter} (3200) + \p{General_Category: Letter} (Short: \p{Gc=L}, \p{L}) (93_455) + \p{General_Category: Letter_Number} (Short: \p{Gc=Nl}, \p{Nl}) + (214) + \p{General_Category: Line_Separator} (Short: \p{Gc=Zl}, \p{Zl}) (1) + \p{General_Category: Ll} \p{General_Category=Lowercase_Letter} + (1748) + \p{General_Category: Lm} \p{General_Category=Modifier_Letter} (187) + \p{General_Category: Lo} \p{General_Category=Other_Letter} (90_068) + \p{General_Category: Lowercase_Letter} (Short: \p{Gc=Ll}, \p{Ll}) + (1748) + \p{General_Category: Lt} \p{General_Category=Titlecase_Letter} (31) + \p{General_Category: Lu} \p{General_Category=Uppercase_Letter} + (1421) + \p{General_Category: M} \p{General_Category=Mark} (1281) + \p{General_Category: Mark} (Short: \p{Gc=M}, \p{M}) (1281) + \p{General_Category: Math_Symbol} (Short: \p{Gc=Sm}, \p{Sm}) (945) + \p{General_Category: Mc} \p{General_Category=Spacing_Mark} (236) + \p{General_Category: Me} \p{General_Category=Enclosing_Mark} (13) + \p{General_Category: Mn} \p{General_Category=Nonspacing_Mark} + (1032) + \p{General_Category: Modifier_Letter} (Short: \p{Gc=Lm}, \p{Lm}) + (187) + \p{General_Category: Modifier_Symbol} (Short: \p{Gc=Sk}, \p{Sk}) + (99) + \p{General_Category: N} \p{General_Category=Number} (933) + \p{General_Category: Nd} \p{General_Category=Decimal_Number} (370) + \p{General_Category: Nl} \p{General_Category=Letter_Number} (214) + \p{General_Category: No} \p{General_Category=Other_Number} (349) + \p{General_Category: Nonspacing_Mark} (Short: \p{Gc=Mn}, \p{Mn}) + (1032) + \p{General_Category: Number} (Short: \p{Gc=N}, \p{N}) (933) + \p{General_Category: Open_Punctuation} (Short: \p{Gc=Ps}, \p{Ps}) + (72) + \p{General_Category: Other} (Short: \p{Gc=C}, \p{C}) (1_013_603) + \p{General_Category: Other_Letter} (Short: \p{Gc=Lo}, \p{Lo}) + (90_068) + \p{General_Category: Other_Number} (Short: \p{Gc=No}, \p{No}) (349) + \p{General_Category: Other_Punctuation} (Short: \p{Gc=Po}, \p{Po}) + (315) + \p{General_Category: Other_Symbol} (Short: \p{Gc=So}, \p{So}) + (3225) + \p{General_Category: P} \p{General_Category=Punctuation} (510) + \p{General_Category: Paragraph_Separator} (Short: \p{Gc=Zp}, + \p{Zp}) (1) + \p{General_Category: Pc} \p{General_Category= + Connector_Punctuation} (10) + \p{General_Category: Pd} \p{General_Category=Dash_Punctuation} (20) + \p{General_Category: Pe} \p{General_Category=Close_Punctuation} + (71) + \p{General_Category: Pf} \p{General_Category=Final_Punctuation} + (10) + \p{General_Category: Pi} \p{General_Category=Initial_Punctuation} + (12) + \p{General_Category: Po} \p{General_Category=Other_Punctuation} + (315) + \p{General_Category: Private_Use} (Short: \p{Gc=Co}, \p{Co}) + (137_468) + \p{General_Category: Ps} \p{General_Category=Open_Punctuation} (72) + \p{General_Category: Punct} \p{General_Category=Punctuation} (510) + \p{General_Category: Punctuation} (Short: \p{Gc=P}, \p{P}) (510) + \p{General_Category: S} \p{General_Category=Symbol} (4310) + \p{General_Category: Sc} \p{General_Category=Currency_Symbol} (41) + \p{General_Category: Separator} (Short: \p{Gc=Z}, \p{Z}) (20) + \p{General_Category: Sk} \p{General_Category=Modifier_Symbol} (99) + \p{General_Category: Sm} \p{General_Category=Math_Symbol} (945) + \p{General_Category: So} \p{General_Category=Other_Symbol} (3225) + \p{General_Category: Space_Separator} (Short: \p{Gc=Zs}, \p{Zs}) + (18) + \p{General_Category: Spacing_Mark} (Short: \p{Gc=Mc}, \p{Mc}) (236) + \p{General_Category: Surrogate} Mostly not usable in Perl. (Short: + \p{Gc=Cs}, \p{Cs}) (2048) + \p{General_Category: Symbol} (Short: \p{Gc=S}, \p{S}) (4310) + \p{General_Category: Titlecase_Letter} (Short: \p{Gc=Lt}, \p{Lt}) + (31) + \p{General_Category: Unassigned} (Short: \p{Gc=Cn}, \p{Cn}) + (873_883) + \p{General_Category: Uppercase_Letter} (Short: \p{Gc=Lu}, \p{Lu}) + (1421) + \p{General_Category: Z} \p{General_Category=Separator} (20) + \p{General_Category: Zl} \p{General_Category=Line_Separator} (1) + \p{General_Category: Zp} \p{General_Category=Paragraph_Separator} + (1) + \p{General_Category: Zs} \p{General_Category=Space_Separator} (18) + X \p{General_Punctuation} \p{Block=General_Punctuation} (112) + X \p{Geometric_Shapes} \p{Block=Geometric_Shapes} (96) + \p{Geor} \p{Georgian} (= \p{Script=Georgian}) (NOT + \p{Block=Georgian}) (120) + \p{Georgian} \p{Script=Georgian} (Short: \p{Geor}; NOT + \p{Block=Georgian}) (120) + X \p{Georgian_Supplement} \p{Block=Georgian_Supplement} (48) + \p{Glag} \p{Glagolitic} (= \p{Script=Glagolitic}) + (NOT \p{Block=Glagolitic}) (94) + \p{Glagolitic} \p{Script=Glagolitic} (Short: \p{Glag}; + NOT \p{Block=Glagolitic}) (94) + \p{Goth} \p{Gothic} (= \p{Script=Gothic}) (NOT + \p{Block=Gothic}) (27) + \p{Gothic} \p{Script=Gothic} (Short: \p{Goth}; NOT + \p{Block=Gothic}) (27) + \p{Gr_Base} \p{Grapheme_Base} (= \p{Grapheme_Base=Y}) + (99_441) + \p{Gr_Base: *} \p{Grapheme_Base: *} + \p{Gr_Ext} \p{Grapheme_Extend} (= \p{Grapheme_Extend= + Y}) (1068) + \p{Gr_Ext: *} \p{Grapheme_Extend: *} + \p{Graph} [[:Graph:]] extended beyond ASCII (238_096) + \p{Grapheme_Base} \p{Grapheme_Base=Y} (Short: \p{GrBase}) + (99_441) + \p{Grapheme_Base: N*} (Short: \p{GrBase=N}, \P{GrBase}) + (1_014_671) + \p{Grapheme_Base: Y*} (Short: \p{GrBase=Y}, \p{GrBase}) (99_441) + \p{Grapheme_Cluster_Break: CN} \p{Grapheme_Cluster_Break=Control} + (202) + \p{Grapheme_Cluster_Break: Control} (Short: \p{GCB=CN}) (202) + \p{Grapheme_Cluster_Break: CR} (Short: \p{GCB=CR}) (1) + \p{Grapheme_Cluster_Break: EX} \p{Grapheme_Cluster_Break=Extend} + (1075) + \p{Grapheme_Cluster_Break: Extend} (Short: \p{GCB=EX}) (1075) + \p{Grapheme_Cluster_Break: L} (Short: \p{GCB=L}) (91) + \p{Grapheme_Cluster_Break: LF} (Short: \p{GCB=LF}) (1) + \p{Grapheme_Cluster_Break: LV} (Short: \p{GCB=LV}) (399) + \p{Grapheme_Cluster_Break: LVT} (Short: \p{GCB=LVT}) (10_773) + \p{Grapheme_Cluster_Break: Other} (Short: \p{GCB=XX}) (1_101_194) + \p{Grapheme_Cluster_Break: PP} \p{Grapheme_Cluster_Break=Prepend} + (10) + \p{Grapheme_Cluster_Break: Prepend} (Short: \p{GCB=PP}) (10) + \p{Grapheme_Cluster_Break: SM} \p{Grapheme_Cluster_Break= + SpacingMark} (217) + \p{Grapheme_Cluster_Break: SpacingMark} (Short: \p{GCB=SM}) (217) + \p{Grapheme_Cluster_Break: T} (Short: \p{GCB=T}) (82) + \p{Grapheme_Cluster_Break: V} (Short: \p{GCB=V}) (67) + \p{Grapheme_Cluster_Break: XX} \p{Grapheme_Cluster_Break=Other} + (1_101_194) + \p{Grapheme_Extend} \p{Grapheme_Extend=Y} (Short: \p{GrExt}) + (1068) + \p{Grapheme_Extend: N*} (Short: \p{GrExt=N}, \P{GrExt}) (1_113_044) + \p{Grapheme_Extend: Y*} (Short: \p{GrExt=Y}, \p{GrExt}) (1068) + \p{Greek} \p{Script=Greek} (Short: \p{Grek}; NOT + \p{Greek_And_Coptic}) (511) + X \p{Greek_And_Coptic} \p{Block=Greek_And_Coptic} (Short: + \p{InGreek}) (144) + X \p{Greek_Extended} \p{Block=Greek_Extended} (256) + \p{Grek} \p{Greek} (= \p{Script=Greek}) (NOT + \p{Greek_And_Coptic}) (511) + \p{Gujarati} \p{Script=Gujarati} (Short: \p{Gujr}; NOT + \p{Block=Gujarati}) (83) + \p{Gujr} \p{Gujarati} (= \p{Script=Gujarati}) (NOT + \p{Block=Gujarati}) (83) + \p{Gurmukhi} \p{Script=Gurmukhi} (Short: \p{Guru}; NOT + \p{Block=Gurmukhi}) (79) + \p{Guru} \p{Gurmukhi} (= \p{Script=Gurmukhi}) (NOT + \p{Block=Gurmukhi}) (79) + X \p{Halfwidth_And_Fullwidth_Forms} \p{Block= + Halfwidth_And_Fullwidth_Forms} (240) + \p{Han} \p{Script=Han} (71_578) + \p{Hang} \p{Hangul} (= \p{Script=Hangul}) (11_620) + \p{Hangul} \p{Script=Hangul} (Short: \p{Hang}) + (11_620) + X \p{Hangul_Compatibility_Jamo} \p{Block=Hangul_Compatibility_Jamo} + (96) + X \p{Hangul_Jamo} \p{Block=Hangul_Jamo} (256) + \p{Hangul_Syllable_Type: L} \p{Hangul_Syllable_Type=Leading_Jamo} + (91) + \p{Hangul_Syllable_Type: Leading_Jamo} (Short: \p{Hst=L}) (91) + \p{Hangul_Syllable_Type: LV} \p{Hangul_Syllable_Type=LV_Syllable} + (399) + \p{Hangul_Syllable_Type: LV_Syllable} (Short: \p{Hst=LV}) (399) + \p{Hangul_Syllable_Type: LVT} \p{Hangul_Syllable_Type= + LVT_Syllable} (10_773) + \p{Hangul_Syllable_Type: LVT_Syllable} (Short: \p{Hst=LVT}) + (10_773) + \p{Hangul_Syllable_Type: NA} \p{Hangul_Syllable_Type= + Not_Applicable} (1_102_700) + \p{Hangul_Syllable_Type: Not_Applicable} (Short: \p{Hst=NA}) + (1_102_700) + \p{Hangul_Syllable_Type: T} \p{Hangul_Syllable_Type=Trailing_Jamo} + (82) + \p{Hangul_Syllable_Type: Trailing_Jamo} (Short: \p{Hst=T}) (82) + \p{Hangul_Syllable_Type: V} \p{Hangul_Syllable_Type=Vowel_Jamo} + (67) + \p{Hangul_Syllable_Type: Vowel_Jamo} (Short: \p{Hst=V}) (67) + X \p{Hangul_Syllables} \p{Block=Hangul_Syllables} (11_184) + \p{Hani} \p{Han} (= \p{Script=Han}) (71_578) + \p{Hano} \p{Hanunoo} (= \p{Script=Hanunoo}) (NOT + \p{Block=Hanunoo}) (21) + \p{Hanunoo} \p{Script=Hanunoo} (Short: \p{Hano}; NOT + \p{Block=Hanunoo}) (21) + \p{Hebr} \p{Hebrew} (= \p{Script=Hebrew}) (NOT + \p{Block=Hebrew}) (133) + \p{Hebrew} \p{Script=Hebrew} (Short: \p{Hebr}; NOT + \p{Block=Hebrew}) (133) + \p{Hex} \p{Hex_Digit} (= \p{Hex_Digit=Y}) (44) + \p{Hex: *} \p{Hex_Digit: *} + \p{Hex_Digit} \p{Hex_Digit=Y} (Short: \p{Hex}) (44) + \p{Hex_Digit: N*} (Short: \p{Hex=N}, \P{Hex}) (1_114_068) + \p{Hex_Digit: Y*} (Short: \p{Hex=Y}, \p{Hex}) (44) + X \p{High_Private_Use_Surrogates} \p{Block= + High_Private_Use_Surrogates} (128) + X \p{High_Surrogates} \p{Block=High_Surrogates} (896) + \p{Hira} \p{Hiragana} (= \p{Script=Hiragana}) (NOT + \p{Block=Hiragana}) (89) + \p{Hiragana} \p{Script=Hiragana} (Short: \p{Hira}; NOT + \p{Block=Hiragana}) (89) + \p{HorizSpace} \p{Blank} (19) + \p{Hst: *} \p{Hangul_Syllable_Type: *} + S \p{Hyphen} \p{Hyphen=Y} (11) + S \p{Hyphen: N*} Use the Line_Break property instead; see + www.unicode.org/reports/tr14 (Single: + \P{Hyphen}) (1_114_101) + S \p{Hyphen: Y*} Use the Line_Break property instead; see + www.unicode.org/reports/tr14 (Single: + \p{Hyphen}) (11) + \p{ID_Continue} \p{ID_Continue=Y} (Short: \p{IDC}) (95_331) + \p{ID_Continue: N*} (Short: \p{IDC=N}, \P{IDC}) (1_018_781) + \p{ID_Continue: Y*} (Short: \p{IDC=Y}, \p{IDC}) (95_331) + \p{ID_Start} \p{ID_Start=Y} (Short: \p{IDS}) (93_672) + \p{ID_Start: N*} (Short: \p{IDS=N}, \P{IDS}) (1_020_440) + \p{ID_Start: Y*} (Short: \p{IDS=Y}, \p{IDS}) (93_672) + \p{IDC} \p{ID_Continue} (= \p{ID_Continue=Y}) + (95_331) + \p{IDC: *} \p{ID_Continue: *} + \p{Ideo} \p{Ideographic} (= \p{Ideographic=Y}) + (71_248) + \p{Ideo: *} \p{Ideographic: *} + \p{Ideographic} \p{Ideographic=Y} (Short: \p{Ideo}) + (71_248) + \p{Ideographic: N*} (Short: \p{Ideo=N}, \P{Ideo}) (1_042_864) + \p{Ideographic: Y*} (Short: \p{Ideo=Y}, \p{Ideo}) (71_248) + X \p{Ideographic_Description_Characters} \p{Block= + Ideographic_Description_Characters} (16) + \p{IDS} \p{ID_Start} (= \p{ID_Start=Y}) (93_672) + \p{IDS: *} \p{ID_Start: *} + \p{IDS_Binary_Operator} \p{IDS_Binary_Operator=Y} (Short: + \p{IDSB}) (10) + \p{IDS_Binary_Operator: N*} (Short: \p{IDSB=N}, \P{IDSB}) + (1_114_102) + \p{IDS_Binary_Operator: Y*} (Short: \p{IDSB=Y}, \p{IDSB}) (10) + \p{IDS_Trinary_Operator} \p{IDS_Trinary_Operator=Y} (Short: + \p{IDST}) (2) + \p{IDS_Trinary_Operator: N*} (Short: \p{IDST=N}, \P{IDST}) + (1_114_110) + \p{IDS_Trinary_Operator: Y*} (Short: \p{IDST=Y}, \p{IDST}) (2) + \p{IDSB} \p{IDS_Binary_Operator} (= + \p{IDS_Binary_Operator=Y}) (10) + \p{IDSB: *} \p{IDS_Binary_Operator: *} + \p{IDST} \p{IDS_Trinary_Operator} (= + \p{IDS_Trinary_Operator=Y}) (2) + \p{IDST: *} \p{IDS_Trinary_Operator: *} + \p{In: *} \p{Present_In: *} + \p{In_*} \p{Block: *} + \p{Inherited} \p{Script=Inherited} (Short: \p{Qaai}) + (496) + \p{Initial_Punctuation} \p{General_Category=Initial_Punctuation} + (Short: \p{Pi}) (12) + X \p{IPA_Extensions} \p{Block=IPA_Extensions} (96) + \p{Is_*} \p{*} (Any exceptions are individually + noted beginning with the word NOT.) If + an entry has flag(s) at its beginning, + like 'D', the 'Is_' form has the same + flag(s) + \p{Ital} \p{Old_Italic} (= \p{Script=Old_Italic}) + (NOT \p{Block=Old_Italic}) (35) + \p{Jg: *} \p{Joining_Group: *} + \p{Join_C} \p{Join_Control} (= \p{Join_Control=Y}) (2) + \p{Join_C: *} \p{Join_Control: *} + \p{Join_Control} \p{Join_Control=Y} (Short: \p{JoinC}) (2) + \p{Join_Control: N*} (Short: \p{JoinC=N}, \P{JoinC}) (1_114_110) + \p{Join_Control: Y*} (Short: \p{JoinC=Y}, \p{JoinC}) (2) + \p{Joining_Group: Ain} (Short: \p{Jg=Ain}) (7) + \p{Joining_Group: Alaph} (Short: \p{Jg=Alaph}) (1) + \p{Joining_Group: Alef} (Short: \p{Jg=Alef}) (10) + \p{Joining_Group: Beh} (Short: \p{Jg=Beh}) (19) + \p{Joining_Group: Beth} (Short: \p{Jg=Beth}) (2) + \p{Joining_Group: Burushaski_Yeh_Barree} (Short: \p{Jg= + BurushaskiYehBarree}) (2) + \p{Joining_Group: Dal} (Short: \p{Jg=Dal}) (14) + \p{Joining_Group: Dalath_Rish} (Short: \p{Jg=DalathRish}) (4) + \p{Joining_Group: E} (Short: \p{Jg=E}) (1) + \p{Joining_Group: Fe} (Short: \p{Jg=Fe}) (1) + \p{Joining_Group: Feh} (Short: \p{Jg=Feh}) (9) + \p{Joining_Group: Final_Semkath} (Short: \p{Jg=FinalSemkath}) (1) + \p{Joining_Group: Gaf} (Short: \p{Jg=Gaf}) (13) + \p{Joining_Group: Gamal} (Short: \p{Jg=Gamal}) (3) + \p{Joining_Group: Hah} (Short: \p{Jg=Hah}) (17) + \p{Joining_Group: Hamza_On_Heh_Goal} (Short: \p{Jg= + HamzaOnHehGoal}) (1) + \p{Joining_Group: He} (Short: \p{Jg=He}) (1) + \p{Joining_Group: Heh} (Short: \p{Jg=Heh}) (1) + \p{Joining_Group: Heh_Goal} (Short: \p{Jg=HehGoal}) (2) + \p{Joining_Group: Heth} (Short: \p{Jg=Heth}) (1) + \p{Joining_Group: Kaf} (Short: \p{Jg=Kaf}) (5) + \p{Joining_Group: Kaph} (Short: \p{Jg=Kaph}) (1) + \p{Joining_Group: Khaph} (Short: \p{Jg=Khaph}) (1) + \p{Joining_Group: Knotted_Heh} (Short: \p{Jg=KnottedHeh}) (2) + \p{Joining_Group: Lam} (Short: \p{Jg=Lam}) (6) + \p{Joining_Group: Lamadh} (Short: \p{Jg=Lamadh}) (1) + \p{Joining_Group: Meem} (Short: \p{Jg=Meem}) (3) + \p{Joining_Group: Mim} (Short: \p{Jg=Mim}) (1) + \p{Joining_Group: No_Joining_Group} (Short: \p{Jg=NoJoiningGroup}) + (1_113_883) + \p{Joining_Group: Noon} (Short: \p{Jg=Noon}) (9) + \p{Joining_Group: Nun} (Short: \p{Jg=Nun}) (1) + \p{Joining_Group: Pe} (Short: \p{Jg=Pe}) (1) + \p{Joining_Group: Qaf} (Short: \p{Jg=Qaf}) (4) + \p{Joining_Group: Qaph} (Short: \p{Jg=Qaph}) (1) + \p{Joining_Group: Reh} (Short: \p{Jg=Reh}) (16) + \p{Joining_Group: Reversed_Pe} (Short: \p{Jg=ReversedPe}) (1) + \p{Joining_Group: Sad} (Short: \p{Jg=Sad}) (5) + \p{Joining_Group: Sadhe} (Short: \p{Jg=Sadhe}) (1) + \p{Joining_Group: Seen} (Short: \p{Jg=Seen}) (11) + \p{Joining_Group: Semkath} (Short: \p{Jg=Semkath}) (1) + \p{Joining_Group: Shin} (Short: \p{Jg=Shin}) (1) + \p{Joining_Group: Swash_Kaf} (Short: \p{Jg=SwashKaf}) (1) + \p{Joining_Group: Syriac_Waw} (Short: \p{Jg=SyriacWaw}) (1) + \p{Joining_Group: Tah} (Short: \p{Jg=Tah}) (3) + \p{Joining_Group: Taw} (Short: \p{Jg=Taw}) (1) + \p{Joining_Group: Teh_Marbuta} (Short: \p{Jg=TehMarbuta}) (3) + \p{Joining_Group: Teth} (Short: \p{Jg=Teth}) (2) + \p{Joining_Group: Waw} (Short: \p{Jg=Waw}) (15) + \p{Joining_Group: Yeh} (Short: \p{Jg=Yeh}) (14) + \p{Joining_Group: Yeh_Barree} (Short: \p{Jg=YehBarree}) (2) + \p{Joining_Group: Yeh_With_Tail} (Short: \p{Jg=YehWithTail}) (1) + \p{Joining_Group: Yudh} (Short: \p{Jg=Yudh}) (1) + \p{Joining_Group: Yudh_He} (Short: \p{Jg=YudhHe}) (1) + \p{Joining_Group: Zain} (Short: \p{Jg=Zain}) (1) + \p{Joining_Group: Zhain} (Short: \p{Jg=Zhain}) (1) + \p{Joining_Type: C} \p{Joining_Type=Join_Causing} (3) + \p{Joining_Type: D} \p{Joining_Type=Dual_Joining} (188) + \p{Joining_Type: Dual_Joining} (Short: \p{Jt=D}) (188) + \p{Joining_Type: Join_Causing} (Short: \p{Jt=C}) (3) + \p{Joining_Type: L} \p{Joining_Type=Left_Joining} (0) + \p{Joining_Type: Left_Joining} (Short: \p{Jt=L}) (0) + \p{Joining_Type: Non_Joining} (Short: \p{Jt=U}) (1_112_670) + \p{Joining_Type: R} \p{Joining_Type=Right_Joining} (74) + \p{Joining_Type: Right_Joining} (Short: \p{Jt=R}) (74) + \p{Joining_Type: T} \p{Joining_Type=Transparent} (1177) + \p{Joining_Type: Transparent} (Short: \p{Jt=T}) (1177) + \p{Joining_Type: U} \p{Joining_Type=Non_Joining} (1_112_670) + \p{Jt: *} \p{Joining_Type: *} + \p{Kali} \p{Kayah_Li} (= \p{Script=Kayah_Li}) (48) + \p{Kana} \p{Katakana} (= \p{Script=Katakana}) (NOT + \p{Block=Katakana}) (299) + X \p{Kanbun} \p{Block=Kanbun} (16) + X \p{Kangxi_Radicals} \p{Block=Kangxi_Radicals} (224) + \p{Kannada} \p{Script=Kannada} (Short: \p{Knda}; NOT + \p{Block=Kannada}) (84) + \p{Katakana} \p{Script=Katakana} (Short: \p{Kana}; NOT + \p{Block=Katakana}) (299) + X \p{Katakana_Phonetic_Extensions} \p{Block= + Katakana_Phonetic_Extensions} (16) + \p{Kayah_Li} \p{Script=Kayah_Li} (Short: \p{Kali}) (48) + \p{Khar} \p{Kharoshthi} (= \p{Script=Kharoshthi}) + (NOT \p{Block=Kharoshthi}) (65) + \p{Kharoshthi} \p{Script=Kharoshthi} (Short: \p{Khar}; + NOT \p{Block=Kharoshthi}) (65) + \p{Khmer} \p{Script=Khmer} (Short: \p{Khmr}; NOT + \p{Block=Khmer}) (146) + X \p{Khmer_Symbols} \p{Block=Khmer_Symbols} (32) + \p{Khmr} \p{Khmer} (= \p{Script=Khmer}) (NOT + \p{Block=Khmer}) (146) + \p{Knda} \p{Kannada} (= \p{Script=Kannada}) (NOT + \p{Block=Kannada}) (84) + \p{L} \p{Letter} (= \p{General_Category=Letter}) + (93_455) + \p{L&} \p{Cased_Letter} (= \p{General_Category= + Cased_Letter}) (3200) + \p{L_} \p{Cased_Letter} (= \p{General_Category= + Cased_Letter}) (3200) + \p{Lao} \p{Script=Lao} (NOT \p{Block=Lao}) (65) + \p{Laoo} \p{Lao} (= \p{Script=Lao}) (NOT \p{Block= + Lao}) (65) + \p{Latin} \p{Script=Latin} (Short: \p{Latn}) (1241) + X \p{Latin_1} \p{Latin_1_Supplement} (= \p{Block= + Latin_1_Supplement}) (128) + X \p{Latin_1_Supplement} \p{Block=Latin_1_Supplement} (Short: + \p{InLatin1}) (128) + X \p{Latin_Extended_A} \p{Block=Latin_Extended_A} (128) + X \p{Latin_Extended_Additional} \p{Block=Latin_Extended_Additional} + (256) + X \p{Latin_Extended_B} \p{Block=Latin_Extended_B} (208) + X \p{Latin_Extended_C} \p{Block=Latin_Extended_C} (32) + X \p{Latin_Extended_D} \p{Block=Latin_Extended_D} (224) + \p{Latn} \p{Latin} (= \p{Script=Latin}) (1241) + \p{Lb: *} \p{Line_Break: *} + \p{LC} \p{Cased_Letter} (= \p{General_Category= + Cased_Letter}) (3200) + \p{Lepc} \p{Lepcha} (= \p{Script=Lepcha}) (NOT + \p{Block=Lepcha}) (74) + \p{Lepcha} \p{Script=Lepcha} (Short: \p{Lepc}; NOT + \p{Block=Lepcha}) (74) + \p{Letter} \p{General_Category=Letter} (Short: \p{L}) + (93_455) + \p{Letter_Number} \p{General_Category=Letter_Number} (Short: + \p{Nl}) (214) + X \p{Letterlike_Symbols} \p{Block=Letterlike_Symbols} (80) + \p{Limb} \p{Limbu} (= \p{Script=Limbu}) (NOT + \p{Block=Limbu}) (66) + \p{Limbu} \p{Script=Limbu} (Short: \p{Limb}; NOT + \p{Block=Limbu}) (66) + \p{Linb} \p{Linear_B} (= \p{Script=Linear_B}) (211) + \p{Line_Break: AI} \p{Line_Break=Ambiguous} (509) + \p{Line_Break: AL} \p{Line_Break=Alphabetic} (12_318) + \p{Line_Break: Alphabetic} (Short: \p{Lb=AL}) (12_318) + \p{Line_Break: Ambiguous} (Short: \p{Lb=AI}) (509) + \p{Line_Break: B2} \p{Line_Break=Break_Both} (1) + \p{Line_Break: BA} \p{Line_Break=Break_After} (113) + \p{Line_Break: BB} \p{Line_Break=Break_Before} (19) + \p{Line_Break: BK} \p{Line_Break=Mandatory_Break} (4) + \p{Line_Break: Break_After} (Short: \p{Lb=BA}) (113) + \p{Line_Break: Break_Before} (Short: \p{Lb=BB}) (19) + \p{Line_Break: Break_Both} (Short: \p{Lb=B2}) (1) + \p{Line_Break: Break_Symbols} (Short: \p{Lb=SY}) (1) + \p{Line_Break: Carriage_Return} (Short: \p{Lb=CR}) (1) + \p{Line_Break: CB} \p{Line_Break=Contingent_Break} (1) + \p{Line_Break: CL} \p{Line_Break=Close_Punctuation} (81) + \p{Line_Break: Close_Punctuation} (Short: \p{Lb=CL}) (81) + \p{Line_Break: CM} \p{Line_Break=Combining_Mark} (1319) + \p{Line_Break: Combining_Mark} (Short: \p{Lb=CM}) (1319) + \p{Line_Break: Complex_Context} (Short: \p{Lb=SA}) (450) + \p{Line_Break: Contingent_Break} (Short: \p{Lb=CB}) (1) + \p{Line_Break: CR} \p{Line_Break=Carriage_Return} (1) + \p{Line_Break: EX} \p{Line_Break=Exclamation} (34) + \p{Line_Break: Exclamation} (Short: \p{Lb=EX}) (34) + \p{Line_Break: GL} \p{Line_Break=Glue} (16) + \p{Line_Break: Glue} (Short: \p{Lb=GL}) (16) + \p{Line_Break: H2} (Short: \p{Lb=H2}) (399) + \p{Line_Break: H3} (Short: \p{Lb=H3}) (10_773) + \p{Line_Break: HY} \p{Line_Break=Hyphen} (1) + \p{Line_Break: Hyphen} (Short: \p{Lb=HY}) (1) + \p{Line_Break: ID} \p{Line_Break=Ideographic} (73_797) + \p{Line_Break: Ideographic} (Short: \p{Lb=ID}) (73_797) + \p{Line_Break: IN} \p{Line_Break=Inseparable} (4) + \p{Line_Break: Infix_Numeric} (Short: \p{Lb=IS}) (13) + \p{Line_Break: Inseparable} (Short: \p{Lb=IN}) (4) + \p{Line_Break: Inseperable} \p{Line_Break=Inseparable} (4) + \p{Line_Break: IS} \p{Line_Break=Infix_Numeric} (13) + \p{Line_Break: JL} (Short: \p{Lb=JL}) (91) + \p{Line_Break: JT} (Short: \p{Lb=JT}) (82) + \p{Line_Break: JV} (Short: \p{Lb=JV}) (67) + \p{Line_Break: LF} \p{Line_Break=Line_Feed} (1) + \p{Line_Break: Line_Feed} (Short: \p{Lb=LF}) (1) + \p{Line_Break: Mandatory_Break} (Short: \p{Lb=BK}) (4) + \p{Line_Break: Next_Line} (Short: \p{Lb=NL}) (1) + \p{Line_Break: NL} \p{Line_Break=Next_Line} (1) + \p{Line_Break: Nonstarter} (Short: \p{Lb=NS}) (77) + \p{Line_Break: NS} \p{Line_Break=Nonstarter} (77) + \p{Line_Break: NU} \p{Line_Break=Numeric} (362) + \p{Line_Break: Numeric} (Short: \p{Lb=NU}) (362) + \p{Line_Break: OP} \p{Line_Break=Open_Punctuation} (75) + \p{Line_Break: Open_Punctuation} (Short: \p{Lb=OP}) (75) + \p{Line_Break: PO} \p{Line_Break=Postfix_Numeric} (23) + \p{Line_Break: Postfix_Numeric} (Short: \p{Lb=PO}) (23) + \p{Line_Break: PR} \p{Line_Break=Prefix_Numeric} (42) + \p{Line_Break: Prefix_Numeric} (Short: \p{Lb=PR}) (42) + \p{Line_Break: QU} \p{Line_Break=Quotation} (34) + \p{Line_Break: Quotation} (Short: \p{Lb=QU}) (34) + \p{Line_Break: SA} \p{Line_Break=Complex_Context} (450) + D \p{Line_Break: SG} \p{Line_Break=Surrogate} (2048) + \p{Line_Break: SP} \p{Line_Break=Space} (1) + \p{Line_Break: Space} (Short: \p{Lb=SP}) (1) + D \p{Line_Break: Surrogate} Deprecated by Unicode because surrogates + should never appear in well-formed text, + and therefore shouldn't be the basis for + line breaking (Short: \p{Lb=SG}) (2048) + \p{Line_Break: SY} \p{Line_Break=Break_Symbols} (1) + \p{Line_Break: Unknown} (Short: \p{Lb=XX}) (1_011_351) + \p{Line_Break: WJ} \p{Line_Break=Word_Joiner} (2) + \p{Line_Break: Word_Joiner} (Short: \p{Lb=WJ}) (2) + \p{Line_Break: XX} \p{Line_Break=Unknown} (1_011_351) + \p{Line_Break: ZW} \p{Line_Break=ZWSpace} (1) + \p{Line_Break: ZWSpace} (Short: \p{Lb=ZW}) (1) + \p{Line_Separator} \p{General_Category=Line_Separator} + (Short: \p{Zl}) (1) + \p{Linear_B} \p{Script=Linear_B} (Short: \p{Linb}) (211) + X \p{Linear_B_Ideograms} \p{Block=Linear_B_Ideograms} (128) + X \p{Linear_B_Syllabary} \p{Block=Linear_B_Syllabary} (128) + \p{Ll} \p{Lowercase_Letter} (= + \p{General_Category=Lowercase_Letter}) + (1748) + \p{Lm} \p{Modifier_Letter} (= + \p{General_Category=Modifier_Letter}) + (187) + \p{Lo} \p{Other_Letter} (= \p{General_Category= + Other_Letter}) (90_068) + \p{LOE} \p{Logical_Order_Exception} (= + \p{Logical_Order_Exception=Y}) (10) + \p{LOE: *} \p{Logical_Order_Exception: *} + \p{Logical_Order_Exception} \p{Logical_Order_Exception=Y} (Short: + \p{LOE}) (10) + \p{Logical_Order_Exception: N*} (Short: \p{LOE=N}, \P{LOE}) + (1_114_102) + \p{Logical_Order_Exception: Y*} (Short: \p{LOE=Y}, \p{LOE}) (10) + X \p{Low_Surrogates} \p{Block=Low_Surrogates} (1024) + \p{Lower} \p{Lowercase=Y} (1907) + \p{Lower: *} \p{Lowercase: *} + \p{Lowercase} \p{Lower} (= \p{Lowercase=Y}) (1907) + \p{Lowercase: N*} (Short: \p{Lower=N}, \P{Lower}) (1_112_205) + \p{Lowercase: Y*} (Short: \p{Lower=Y}, \p{Lower}) (1907) + \p{Lowercase_Letter} \p{General_Category=Lowercase_Letter} + (Short: \p{Ll}) (1748) + \p{Lt} \p{Title} (= \p{General_Category= + Titlecase_Letter}) (31) + \p{Lu} \p{Uppercase_Letter} (= + \p{General_Category=Uppercase_Letter}) + (1421) + \p{Lyci} \p{Lycian} (= \p{Script=Lycian}) (NOT + \p{Block=Lycian}) (29) + \p{Lycian} \p{Script=Lycian} (Short: \p{Lyci}; NOT + \p{Block=Lycian}) (29) + \p{Lydi} \p{Lydian} (= \p{Script=Lydian}) (NOT + \p{Block=Lydian}) (27) + \p{Lydian} \p{Script=Lydian} (Short: \p{Lydi}; NOT + \p{Block=Lydian}) (27) + \p{M} \p{Mark} (= \p{General_Category=Mark}) + (1281) + X \p{Mahjong_Tiles} \p{Block=Mahjong_Tiles} (48) + \p{Malayalam} \p{Script=Malayalam} (Short: \p{Mlym}; NOT + \p{Block=Malayalam}) (95) + \p{Mark} \p{General_Category=Mark} (Short: \p{M}) + (1281) + \p{Math} \p{Math=Y} (2161) + \p{Math: N*} (Single: \P{Math}) (1_111_951) + \p{Math: Y*} (Single: \p{Math}) (2161) + \p{Math_Symbol} \p{General_Category=Math_Symbol} (Short: + \p{Sm}) (945) + X \p{Mathematical_Alphanumeric_Symbols} \p{Block= + Mathematical_Alphanumeric_Symbols} (1024) + X \p{Mathematical_Operators} \p{Block=Mathematical_Operators} (256) + \p{Mc} \p{Spacing_Mark} (= \p{General_Category= + Spacing_Mark}) (236) + \p{Me} \p{Enclosing_Mark} (= \p{General_Category= + Enclosing_Mark}) (13) + X \p{Miscellaneous_Mathematical_Symbols_A} \p{Block= + Miscellaneous_Mathematical_Symbols_A} + (48) + X \p{Miscellaneous_Mathematical_Symbols_B} \p{Block= + Miscellaneous_Mathematical_Symbols_B} + (128) + X \p{Miscellaneous_Symbols} \p{Block=Miscellaneous_Symbols} (256) + X \p{Miscellaneous_Symbols_And_Arrows} \p{Block= + Miscellaneous_Symbols_And_Arrows} (256) + X \p{Miscellaneous_Technical} \p{Block=Miscellaneous_Technical} (256) + \p{Mlym} \p{Malayalam} (= \p{Script=Malayalam}) + (NOT \p{Block=Malayalam}) (95) + \p{Mn} \p{Nonspacing_Mark} (= + \p{General_Category=Nonspacing_Mark}) + (1032) + \p{Modifier_Letter} \p{General_Category=Modifier_Letter} + (Short: \p{Lm}) (187) + \p{Modifier_Symbol} \p{General_Category=Modifier_Symbol} + (Short: \p{Sk}) (99) + X \p{Modifier_Tone_Letters} \p{Block=Modifier_Tone_Letters} (32) + \p{Mong} \p{Mongolian} (= \p{Script=Mongolian}) + (NOT \p{Block=Mongolian}) (153) + \p{Mongolian} \p{Script=Mongolian} (Short: \p{Mong}; NOT + \p{Block=Mongolian}) (153) + X \p{Musical_Symbols} \p{Block=Musical_Symbols} (256) + \p{Myanmar} \p{Script=Myanmar} (Short: \p{Mymr}; NOT + \p{Block=Myanmar}) (156) + \p{Mymr} \p{Myanmar} (= \p{Script=Myanmar}) (NOT + \p{Block=Myanmar}) (156) + \p{N} \p{Number} (= \p{General_Category=Number}) + (933) + \p{NChar} \p{Noncharacter_Code_Point} (= + \p{Noncharacter_Code_Point=Y}) (66) + \p{NChar: *} \p{Noncharacter_Code_Point: *} + \p{Nd} \p{Digit} (= \p{General_Category= + Decimal_Number}) (370) + \p{New_Tai_Lue} \p{Script=New_Tai_Lue} (Short: \p{Talu}; + NOT \p{Block=New_Tai_Lue}) (80) + \p{NFC_QC: *} \p{NFC_Quick_Check: *} + \p{NFC_Quick_Check: M} \p{NFC_Quick_Check=Maybe} (102) + \p{NFC_Quick_Check: Maybe} (Short: \p{NFCQC=M}) (102) + \p{NFC_Quick_Check: N} \p{NFC_Quick_Check=No} (NOT + \P{NFC_Quick_Check} NOR \P{NFC_QC} NOR + \P{Is_NFC_Quick_Check} NOR + \P{Is_NFC_QC}) (1115) + \p{NFC_Quick_Check: No} (Short: \p{NFCQC=N}; NOT + \P{NFC_Quick_Check} NOR \P{NFC_QC} NOR + \P{Is_NFC_Quick_Check} NOR + \P{Is_NFC_QC}) (1115) + \p{NFC_Quick_Check: Y} \p{NFC_Quick_Check=Yes} (NOT + \p{NFC_Quick_Check} NOR \p{NFC_QC} NOR + \p{Is_NFC_Quick_Check} NOR + \p{Is_NFC_QC}) (1_112_895) + \p{NFC_Quick_Check: Yes} (Short: \p{NFCQC=Y}; NOT + \p{NFC_Quick_Check} NOR \p{NFC_QC} NOR + \p{Is_NFC_Quick_Check} NOR + \p{Is_NFC_QC}) (1_112_895) + \p{NFD_QC: *} \p{NFD_Quick_Check: *} + \p{NFD_Quick_Check: N} \p{NFD_Quick_Check=No} (NOT + \P{NFD_Quick_Check} NOR \P{NFD_QC} NOR + \P{Is_NFD_Quick_Check} NOR + \P{Is_NFD_QC}) (13_215) + \p{NFD_Quick_Check: No} (Short: \p{NFDQC=N}; NOT + \P{NFD_Quick_Check} NOR \P{NFD_QC} NOR + \P{Is_NFD_Quick_Check} NOR + \P{Is_NFD_QC}) (13_215) + \p{NFD_Quick_Check: Y} \p{NFD_Quick_Check=Yes} (NOT + \p{NFD_Quick_Check} NOR \p{NFD_QC} NOR + \p{Is_NFD_Quick_Check} NOR + \p{Is_NFD_QC}) (1_100_897) + \p{NFD_Quick_Check: Yes} (Short: \p{NFDQC=Y}; NOT + \p{NFD_Quick_Check} NOR \p{NFD_QC} NOR + \p{Is_NFD_Quick_Check} NOR + \p{Is_NFD_QC}) (1_100_897) + \p{NFKC_QC: *} \p{NFKC_Quick_Check: *} + \p{NFKC_Quick_Check: M} \p{NFKC_Quick_Check=Maybe} (102) + \p{NFKC_Quick_Check: Maybe} (Short: \p{NFKCQC=M}) (102) + \p{NFKC_Quick_Check: N} \p{NFKC_Quick_Check=No} (NOT + \P{NFKC_Quick_Check} NOR \P{NFKC_QC} NOR + \P{Is_NFKC_Quick_Check} NOR + \P{Is_NFKC_QC}) (4489) + \p{NFKC_Quick_Check: No} (Short: \p{NFKCQC=N}; NOT + \P{NFKC_Quick_Check} NOR \P{NFKC_QC} NOR + \P{Is_NFKC_Quick_Check} NOR + \P{Is_NFKC_QC}) (4489) + \p{NFKC_Quick_Check: Y} \p{NFKC_Quick_Check=Yes} (NOT + \p{NFKC_Quick_Check} NOR \p{NFKC_QC} NOR + \p{Is_NFKC_Quick_Check} NOR + \p{Is_NFKC_QC}) (1_109_521) + \p{NFKC_Quick_Check: Yes} (Short: \p{NFKCQC=Y}; NOT + \p{NFKC_Quick_Check} NOR \p{NFKC_QC} NOR + \p{Is_NFKC_Quick_Check} NOR + \p{Is_NFKC_QC}) (1_109_521) + \p{NFKD_QC: *} \p{NFKD_Quick_Check: *} + \p{NFKD_Quick_Check: N} \p{NFKD_Quick_Check=No} (NOT + \P{NFKD_Quick_Check} NOR \P{NFKD_QC} NOR + \P{Is_NFKD_Quick_Check} NOR + \P{Is_NFKD_QC}) (16_577) + \p{NFKD_Quick_Check: No} (Short: \p{NFKDQC=N}; NOT + \P{NFKD_Quick_Check} NOR \P{NFKD_QC} NOR + \P{Is_NFKD_Quick_Check} NOR + \P{Is_NFKD_QC}) (16_577) + \p{NFKD_Quick_Check: Y} \p{NFKD_Quick_Check=Yes} (NOT + \p{NFKD_Quick_Check} NOR \p{NFKD_QC} NOR + \p{Is_NFKD_Quick_Check} NOR + \p{Is_NFKD_QC}) (1_097_535) + \p{NFKD_Quick_Check: Yes} (Short: \p{NFKDQC=Y}; NOT + \p{NFKD_Quick_Check} NOR \p{NFKD_QC} NOR + \p{Is_NFKD_Quick_Check} NOR + \p{Is_NFKD_QC}) (1_097_535) + \p{Nko} \p{Script=Nko} (NOT \p{NKo}) (59) + \p{Nkoo} \p{Nko} (= \p{Script=Nko}) (NOT \p{NKo}) + (59) + \p{Nl} \p{Letter_Number} (= \p{General_Category= + Letter_Number}) (214) + \p{No} \p{Other_Number} (= \p{General_Category= + Other_Number}) (349) + X \p{No_Block} \p{Block=No_Block} (871_248) + \p{Noncharacter_Code_Point} \p{Noncharacter_Code_Point=Y} (Short: + \p{NChar}) (66) + \p{Noncharacter_Code_Point: N*} (Short: \p{NChar=N}, \P{NChar}) + (1_114_046) + \p{Noncharacter_Code_Point: Y*} (Short: \p{NChar=Y}, \p{NChar}) + (66) + \p{Nonspacing_Mark} \p{General_Category=Nonspacing_Mark} + (Short: \p{Mn}) (1032) + \p{Nt: *} \p{Numeric_Type: *} + \p{Number} \p{General_Category=Number} (Short: \p{N}) + (933) + X \p{Number_Forms} \p{Block=Number_Forms} (64) + \p{Numeric_Type: De} \p{Numeric_Type=Decimal} (370) + \p{Numeric_Type: Decimal} (Short: \p{Nt=De}) (370) + \p{Numeric_Type: Di} \p{Numeric_Type=Digit} (98) + \p{Numeric_Type: Digit} (Short: \p{Nt=Di}) (98) + \p{Numeric_Type: None} (Short: \p{Nt=None}) (1_113_103) + \p{Numeric_Type: Nu} \p{Numeric_Type=Numeric} (541) + \p{Numeric_Type: Numeric} (Short: \p{Nt=Nu}) (541) + T \p{Numeric_Value: -1/2} (Short: \p{Nv=-1/2}) (1) + T \p{Numeric_Value: 0} (Short: \p{Nv=0}) (47) + T \p{Numeric_Value: 1/8} (Short: \p{Nv=1/8}) (2) + T \p{Numeric_Value: 1/6} (Short: \p{Nv=1/6}) (2) + T \p{Numeric_Value: 1/5} (Short: \p{Nv=1/5}) (1) + T \p{Numeric_Value: 1/4} (Short: \p{Nv=1/4}) (5) + T \p{Numeric_Value: 1/3} (Short: \p{Nv=1/3}) (3) + T \p{Numeric_Value: 3/8} (Short: \p{Nv=3/8}) (1) + T \p{Numeric_Value: 2/5} (Short: \p{Nv=2/5}) (1) + T \p{Numeric_Value: 1/2} (Short: \p{Nv=1/2}) (7) + T \p{Numeric_Value: 3/5} (Short: \p{Nv=3/5}) (1) + T \p{Numeric_Value: 5/8} (Short: \p{Nv=5/8}) (1) + T \p{Numeric_Value: 2/3} (Short: \p{Nv=2/3}) (4) + T \p{Numeric_Value: 3/4} (Short: \p{Nv=3/4}) (3) + T \p{Numeric_Value: 4/5} (Short: \p{Nv=4/5}) (1) + T \p{Numeric_Value: 5/6} (Short: \p{Nv=5/6}) (2) + T \p{Numeric_Value: 7/8} (Short: \p{Nv=7/8}) (1) + T \p{Numeric_Value: 1} (Short: \p{Nv=1}) (80) + T \p{Numeric_Value: 3/2} (Short: \p{Nv=3/2}) (1) + T \p{Numeric_Value: 2} (Short: \p{Nv=2}) (84) + T \p{Numeric_Value: 5/2} (Short: \p{Nv=5/2}) (1) + T \p{Numeric_Value: 3} (Short: \p{Nv=3}) (86) + T \p{Numeric_Value: 7/2} (Short: \p{Nv=7/2}) (1) + T \p{Numeric_Value: 4} (Short: \p{Nv=4}) (79) + T \p{Numeric_Value: 9/2} (Short: \p{Nv=9/2}) (1) + T \p{Numeric_Value: 5} (Short: \p{Nv=5}) (77) + T \p{Numeric_Value: 11/2} (Short: \p{Nv=11/2}) (1) + T \p{Numeric_Value: 6} (Short: \p{Nv=6}) (69) + T \p{Numeric_Value: 13/2} (Short: \p{Nv=13/2}) (1) + T \p{Numeric_Value: 7} (Short: \p{Nv=7}) (68) + T \p{Numeric_Value: 15/2} (Short: \p{Nv=15/2}) (1) + T \p{Numeric_Value: 8} (Short: \p{Nv=8}) (64) + T \p{Numeric_Value: 17/2} (Short: \p{Nv=17/2}) (1) + T \p{Numeric_Value: 9} (Short: \p{Nv=9}) (68) + T \p{Numeric_Value: 10} (Short: \p{Nv=10}) (34) + T \p{Numeric_Value: 11} (Short: \p{Nv=11}) (6) + T \p{Numeric_Value: 12} (Short: \p{Nv=12}) (6) + T \p{Numeric_Value: 13} (Short: \p{Nv=13}) (4) + T \p{Numeric_Value: 14} (Short: \p{Nv=14}) (4) + T \p{Numeric_Value: 15} (Short: \p{Nv=15}) (4) + T \p{Numeric_Value: 16} (Short: \p{Nv=16}) (5) + T \p{Numeric_Value: 17} (Short: \p{Nv=17}) (5) + T \p{Numeric_Value: 18} (Short: \p{Nv=18}) (5) + T \p{Numeric_Value: 19} (Short: \p{Nv=19}) (5) + T \p{Numeric_Value: 20} (Short: \p{Nv=20}) (13) + T \p{Numeric_Value: 21} (Short: \p{Nv=21}) (1) + T \p{Numeric_Value: 22} (Short: \p{Nv=22}) (1) + T \p{Numeric_Value: 23} (Short: \p{Nv=23}) (1) + T \p{Numeric_Value: 24} (Short: \p{Nv=24}) (1) + T \p{Numeric_Value: 25} (Short: \p{Nv=25}) (1) + T \p{Numeric_Value: 26} (Short: \p{Nv=26}) (1) + T \p{Numeric_Value: 27} (Short: \p{Nv=27}) (1) + T \p{Numeric_Value: 28} (Short: \p{Nv=28}) (1) + T \p{Numeric_Value: 29} (Short: \p{Nv=29}) (1) + T \p{Numeric_Value: 30} (Short: \p{Nv=30}) (8) + T \p{Numeric_Value: 31} (Short: \p{Nv=31}) (1) + T \p{Numeric_Value: 32} (Short: \p{Nv=32}) (1) + T \p{Numeric_Value: 33} (Short: \p{Nv=33}) (1) + T \p{Numeric_Value: 34} (Short: \p{Nv=34}) (1) + T \p{Numeric_Value: 35} (Short: \p{Nv=35}) (1) + T \p{Numeric_Value: 36} (Short: \p{Nv=36}) (1) + T \p{Numeric_Value: 37} (Short: \p{Nv=37}) (1) + T \p{Numeric_Value: 38} (Short: \p{Nv=38}) (1) + T \p{Numeric_Value: 39} (Short: \p{Nv=39}) (1) + T \p{Numeric_Value: 40} (Short: \p{Nv=40}) (7) + T \p{Numeric_Value: 41} (Short: \p{Nv=41}) (1) + T \p{Numeric_Value: 42} (Short: \p{Nv=42}) (1) + T \p{Numeric_Value: 43} (Short: \p{Nv=43}) (1) + T \p{Numeric_Value: 44} (Short: \p{Nv=44}) (1) + T \p{Numeric_Value: 45} (Short: \p{Nv=45}) (1) + T \p{Numeric_Value: 46} (Short: \p{Nv=46}) (1) + T \p{Numeric_Value: 47} (Short: \p{Nv=47}) (1) + T \p{Numeric_Value: 48} (Short: \p{Nv=48}) (1) + T \p{Numeric_Value: 49} (Short: \p{Nv=49}) (1) + T \p{Numeric_Value: 50} (Short: \p{Nv=50}) (16) + T \p{Numeric_Value: 60} (Short: \p{Nv=60}) (3) + T \p{Numeric_Value: 70} (Short: \p{Nv=70}) (3) + T \p{Numeric_Value: 80} (Short: \p{Nv=80}) (3) + T \p{Numeric_Value: 90} (Short: \p{Nv=90}) (4) + T \p{Numeric_Value: 100} (Short: \p{Nv=100}) (15) + T \p{Numeric_Value: 200} (Short: \p{Nv=200}) (1) + T \p{Numeric_Value: 300} (Short: \p{Nv=300}) (2) + T \p{Numeric_Value: 400} (Short: \p{Nv=400}) (1) + T \p{Numeric_Value: 500} (Short: \p{Nv=500}) (11) + T \p{Numeric_Value: 600} (Short: \p{Nv=600}) (1) + T \p{Numeric_Value: 700} (Short: \p{Nv=700}) (1) + T \p{Numeric_Value: 800} (Short: \p{Nv=800}) (1) + T \p{Numeric_Value: 900} (Short: \p{Nv=900}) (2) + T \p{Numeric_Value: 1000} (Short: \p{Nv=1000}) (13) + T \p{Numeric_Value: 2000} (Short: \p{Nv=2000}) (1) + T \p{Numeric_Value: 3000} (Short: \p{Nv=3000}) (1) + T \p{Numeric_Value: 4000} (Short: \p{Nv=4000}) (1) + T \p{Numeric_Value: 5000} (Short: \p{Nv=5000}) (5) + T \p{Numeric_Value: 6000} (Short: \p{Nv=6000}) (1) + T \p{Numeric_Value: 7000} (Short: \p{Nv=7000}) (1) + T \p{Numeric_Value: 8000} (Short: \p{Nv=8000}) (1) + T \p{Numeric_Value: 9000} (Short: \p{Nv=9000}) (1) + T \p{Numeric_Value: 10000} (= 1.0e+04) (Short: \p{Nv=10000}) (6) + T \p{Numeric_Value: 20000} (= 2.0e+04) (Short: \p{Nv=20000}) (1) + T \p{Numeric_Value: 30000} (= 3.0e+04) (Short: \p{Nv=30000}) (1) + T \p{Numeric_Value: 40000} (= 4.0e+04) (Short: \p{Nv=40000}) (1) + T \p{Numeric_Value: 50000} (= 5.0e+04) (Short: \p{Nv=50000}) (4) + T \p{Numeric_Value: 60000} (= 6.0e+04) (Short: \p{Nv=60000}) (1) + T \p{Numeric_Value: 70000} (= 7.0e+04) (Short: \p{Nv=70000}) (1) + T \p{Numeric_Value: 80000} (= 8.0e+04) (Short: \p{Nv=80000}) (1) + T \p{Numeric_Value: 90000} (= 9.0e+04) (Short: \p{Nv=90000}) (1) + T \p{Numeric_Value: 100000} (= 1.0e+05) (Short: \p{Nv=100000}) (1) + T \p{Numeric_Value: 100000000} (= 1.0e+08) (Short: \p{Nv=100000000}) + (2) + T \p{Numeric_Value: 1000000000000} (= 1.0e+12) (Short: \p{Nv= + 1000000000000}) (1) + \p{Numeric_Value: NaN} (Short: \p{Nv=NaN}) (1_113_103) + \p{Nv: *} \p{Numeric_Value: *} + D \p{OAlpha} \p{Other_Alphabetic} (= + \p{Other_Alphabetic=Y}) (663) + D \p{OAlpha: *} \p{Other_Alphabetic: *} + D \p{ODI} \p{Other_Default_Ignorable_Code_Point} (= + \p{Other_Default_Ignorable_Code_Point= + Y}) (3778) + D \p{ODI: *} \p{Other_Default_Ignorable_Code_Point: *} + \p{Ogam} \p{Ogham} (= \p{Script=Ogham}) (NOT + \p{Block=Ogham}) (29) + \p{Ogham} \p{Script=Ogham} (Short: \p{Ogam}; NOT + \p{Block=Ogham}) (29) + D \p{OGr_Ext} \p{Other_Grapheme_Extend} (= + \p{Other_Grapheme_Extend=Y}) (23) + D \p{OGr_Ext: *} \p{Other_Grapheme_Extend: *} + D \p{OIDC} \p{Other_ID_Continue} (= + \p{Other_ID_Continue=Y}) (11) + D \p{OIDC: *} \p{Other_ID_Continue: *} + D \p{OIDS} \p{Other_ID_Start} (= \p{Other_ID_Start= + Y}) (4) + D \p{OIDS: *} \p{Other_ID_Start: *} + \p{Ol_Chiki} \p{Script=Ol_Chiki} (Short: \p{Olck}) (48) + \p{Olck} \p{Ol_Chiki} (= \p{Script=Ol_Chiki}) (48) + \p{Old_Italic} \p{Script=Old_Italic} (Short: \p{Ital}; + NOT \p{Block=Old_Italic}) (35) + \p{Old_Persian} \p{Script=Old_Persian} (Short: \p{Xpeo}; + NOT \p{Block=Old_Persian}) (50) + D \p{OLower} \p{Other_Lowercase} (= \p{Other_Lowercase= + Y}) (159) + D \p{OLower: *} \p{Other_Lowercase: *} + D \p{OMath} \p{Other_Math} (= \p{Other_Math=Y}) (1216) + D \p{OMath: *} \p{Other_Math: *} + \p{Open_Punctuation} \p{General_Category=Open_Punctuation} + (Short: \p{Ps}) (72) + X \p{Optical_Character_Recognition} \p{Block= + Optical_Character_Recognition} (32) + \p{Oriya} \p{Script=Oriya} (Short: \p{Orya}; NOT + \p{Block=Oriya}) (84) + \p{Orya} \p{Oriya} (= \p{Script=Oriya}) (NOT + \p{Block=Oriya}) (84) + \p{Osma} \p{Osmanya} (= \p{Script=Osmanya}) (NOT + \p{Block=Osmanya}) (40) + \p{Osmanya} \p{Script=Osmanya} (Short: \p{Osma}; NOT + \p{Block=Osmanya}) (40) + \p{Other} \p{General_Category=Other} (Short: \p{C}) + (1_013_603) + D \p{Other_Alphabetic} \p{Other_Alphabetic=Y} (Short: \p{OAlpha}) + (663) + D \p{Other_Alphabetic: N*} Used by Unicode internally for generating + the Alphabetic property (which should be + used instead) and not intended to be + used stand-alone (Short: \p{OAlpha=N}, + \P{OAlpha}) (1_113_449) + D \p{Other_Alphabetic: Y*} Used by Unicode internally for generating + the Alphabetic property (which should be + used instead) and not intended to be + used stand-alone (Short: \p{OAlpha=Y}, + \p{OAlpha}) (663) + D \p{Other_Default_Ignorable_Code_Point} + \p{Other_Default_Ignorable_Code_Point=Y} + (Short: \p{ODI}) (3778) + D \p{Other_Default_Ignorable_Code_Point: N*} Used by Unicode + internally for generating the + Default_Ignorable_Code_Point property + (which should be used instead) and not + intended to be used stand-alone (Short: + \p{ODI=N}, \P{ODI}) (1_110_334) + D \p{Other_Default_Ignorable_Code_Point: Y*} Used by Unicode + internally for generating the + Default_Ignorable_Code_Point property + (which should be used instead) and not + intended to be used stand-alone (Short: + \p{ODI=Y}, \p{ODI}) (3778) + D \p{Other_Grapheme_Extend} \p{Other_Grapheme_Extend=Y} (Short: + \p{OGrExt}) (23) + D \p{Other_Grapheme_Extend: N*} Used by Unicode internally for + generating the Grapheme_Extend property + (which should be used instead) and not + intended to be used stand-alone (Short: + \p{OGrExt=N}, \P{OGrExt}) (1_114_089) + D \p{Other_Grapheme_Extend: Y*} Used by Unicode internally for + generating the Grapheme_Extend property + (which should be used instead) and not + intended to be used stand-alone (Short: + \p{OGrExt=Y}, \p{OGrExt}) (23) + D \p{Other_ID_Continue} \p{Other_ID_Continue=Y} (Short: \p{OIDC}) + (11) + D \p{Other_ID_Continue: N*} Used by Unicode internally for + generating the ID_Continue property + (which should be used instead) and not + intended to be used stand-alone (Short: + \p{OIDC=N}, \P{OIDC}) (1_114_101) + D \p{Other_ID_Continue: Y*} Used by Unicode internally for + generating the ID_Continue property + (which should be used instead) and not + intended to be used stand-alone (Short: + \p{OIDC=Y}, \p{OIDC}) (11) + D \p{Other_ID_Start} \p{Other_ID_Start=Y} (Short: \p{OIDS}) (4) + D \p{Other_ID_Start: N*} Used by Unicode internally for generating + the ID_Start property (which should be + used instead) and not intended to be + used stand-alone (Short: \p{OIDS=N}, + \P{OIDS}) (1_114_108) + D \p{Other_ID_Start: Y*} Used by Unicode internally for generating + the ID_Start property (which should be + used instead) and not intended to be + used stand-alone (Short: \p{OIDS=Y}, + \p{OIDS}) (4) + \p{Other_Letter} \p{General_Category=Other_Letter} (Short: + \p{Lo}) (90_068) + D \p{Other_Lowercase} \p{Other_Lowercase=Y} (Short: \p{OLower}) + (159) + D \p{Other_Lowercase: N*} Used by Unicode internally for generating + the Lowercase property (which should be + used instead) and not intended to be + used stand-alone (Short: \p{OLower=N}, + \P{OLower}) (1_113_953) + D \p{Other_Lowercase: Y*} Used by Unicode internally for generating + the Lowercase property (which should be + used instead) and not intended to be + used stand-alone (Short: \p{OLower=Y}, + \p{OLower}) (159) + D \p{Other_Math} \p{Other_Math=Y} (Short: \p{OMath}) (1216) + D \p{Other_Math: N*} Used by Unicode internally for generating + the Math property (which should be used + instead) and not intended to be used + stand-alone (Short: \p{OMath=N}, + \P{OMath}) (1_112_896) + D \p{Other_Math: Y*} Used by Unicode internally for generating + the Math property (which should be used + instead) and not intended to be used + stand-alone (Short: \p{OMath=Y}, + \p{OMath}) (1216) + \p{Other_Number} \p{General_Category=Other_Number} (Short: + \p{No}) (349) + \p{Other_Punctuation} \p{General_Category=Other_Punctuation} + (Short: \p{Po}) (315) + \p{Other_Symbol} \p{General_Category=Other_Symbol} (Short: + \p{So}) (3225) + D \p{Other_Uppercase} \p{Other_Uppercase=Y} (Short: \p{OUpper}) + (42) + D \p{Other_Uppercase: N*} Used by Unicode internally for generating + the Uppercase property (which should be + used instead) and not intended to be + used stand-alone (Short: \p{OUpper=N}, + \P{OUpper}) (1_114_070) + D \p{Other_Uppercase: Y*} Used by Unicode internally for generating + the Uppercase property (which should be + used instead) and not intended to be + used stand-alone (Short: \p{OUpper=Y}, + \p{OUpper}) (42) + D \p{OUpper} \p{Other_Uppercase} (= \p{Other_Uppercase= + Y}) (42) + D \p{OUpper: *} \p{Other_Uppercase: *} + \p{P} \p{Punct} (= \p{General_Category= + Punctuation}) (510) + \p{Paragraph_Separator} \p{General_Category=Paragraph_Separator} + (Short: \p{Zp}) (1) + \p{Pat_Syn} \p{Pattern_Syntax} (= \p{Pattern_Syntax= + Y}) (2760) + \p{Pat_Syn: *} \p{Pattern_Syntax: *} + \p{Pat_WS} \p{Pattern_White_Space} (= + \p{Pattern_White_Space=Y}) (11) + \p{Pat_WS: *} \p{Pattern_White_Space: *} + \p{Pattern_Syntax} \p{Pattern_Syntax=Y} (Short: \p{PatSyn}) + (2760) + \p{Pattern_Syntax: N*} (Short: \p{PatSyn=N}, \P{PatSyn}) + (1_111_352) + \p{Pattern_Syntax: Y*} (Short: \p{PatSyn=Y}, \p{PatSyn}) (2760) + \p{Pattern_White_Space} \p{Pattern_White_Space=Y} (Short: + \p{PatWS}) (11) + \p{Pattern_White_Space: N*} (Short: \p{PatWS=N}, \P{PatWS}) + (1_114_101) + \p{Pattern_White_Space: Y*} (Short: \p{PatWS=Y}, \p{PatWS}) (11) + \p{Pc} \p{Connector_Punctuation} (= + \p{General_Category= + Connector_Punctuation}) (10) + \p{Pd} \p{Dash_Punctuation} (= + \p{General_Category=Dash_Punctuation}) + (20) + \p{Pe} \p{Close_Punctuation} (= + \p{General_Category=Close_Punctuation}) + (71) + \p{PerlSpace} \s, restricted to ASCII (5) + \p{PerlWord} \w, restricted to ASCII = [A-Za-z0-9_] (63) + \p{Pf} \p{Final_Punctuation} (= + \p{General_Category=Final_Punctuation}) + (10) + \p{Phag} \p{Phags_Pa} (= \p{Script=Phags_Pa}) (NOT + \p{Block=Phags_Pa}) (56) + \p{Phags_Pa} \p{Script=Phags_Pa} (Short: \p{Phag}; NOT + \p{Block=Phags_Pa}) (56) + X \p{Phaistos_Disc} \p{Block=Phaistos_Disc} (48) + \p{Phnx} \p{Phoenician} (= \p{Script=Phoenician}) + (NOT \p{Block=Phoenician}) (27) + \p{Phoenician} \p{Script=Phoenician} (Short: \p{Phnx}; + NOT \p{Block=Phoenician}) (27) + X \p{Phonetic_Extensions} \p{Block=Phonetic_Extensions} (128) + X \p{Phonetic_Extensions_Supplement} \p{Block= + Phonetic_Extensions_Supplement} (64) + \p{Pi} \p{Initial_Punctuation} (= + \p{General_Category= + Initial_Punctuation}) (12) + \p{Po} \p{Other_Punctuation} (= + \p{General_Category=Other_Punctuation}) + (315) + \p{PosixAlnum} [[:Alnum:]] (62) + \p{PosixAlpha} [[:Alpha:]] (52) + \p{PosixBlank} [[:Blank:]] (2) + \p{PosixCntrl} [[:Cntrl:]] (33) + \p{PosixDigit} [[:Digit:]]; \d, restricted to ASCII; + [0-9] (10) + \p{PosixGraph} [[:Graph:]] (94) + \p{PosixLower} [[:Lower:]] (26) + \p{PosixPrint} [[:Print:]] (95) + \p{PosixPunct} [[:Punct:]] (32) + \p{PosixSpace} [[:Space:]] (6) + \p{PosixUpper} [[:Upper:]] (26) + T \p{Present_In: 1.1} \p{Age=1.1} (Short: \p{In=1.1}) (33_979) + T \p{Present_In: 2.0} Code point's usage introduced in version + 2.0 or earlier (Short: \p{In=2.0}) + (178_500) + T \p{Present_In: 2.1} Code point's usage introduced in version + 2.1 or earlier (Short: \p{In=2.1}) + (178_502) + T \p{Present_In: 3.0} Code point's usage introduced in version + 3.0 or earlier (Short: \p{In=3.0}) + (188_809) + T \p{Present_In: 3.1} Code point's usage introduced in version + 3.1 or earlier (Short: \p{In=3.1}) + (233_787) + T \p{Present_In: 3.2} Code point's usage introduced in version + 3.2 or earlier (Short: \p{In=3.2}) + (234_803) + T \p{Present_In: 4.0} Code point's usage introduced in version + 4.0 or earlier (Short: \p{In=4.0}) + (236_029) + T \p{Present_In: 4.1} Code point's usage introduced in version + 4.1 or earlier (Short: \p{In=4.1}) + (237_302) + T \p{Present_In: 5.0} Code point's usage introduced in version + 5.0 or earlier (Short: \p{In=5.0}) + (238_671) + T \p{Present_In: 5.1} Code point's usage introduced in version + 5.1 or earlier (Short: \p{In=5.1}) + (240_295) + \p{Present_In: Unassigned} \p{Age=Unassigned} (Short: \p{In= + Unassigned}) (873_817) + \p{Print} [[:Print:]] extended beyond ASCII (238_116) + \p{Private_Use} \p{General_Category=Private_Use} (Short: + \p{Co}; NOT \p{Private_Use_Area}) + (137_468) + X \p{Private_Use_Area} \p{Block=Private_Use_Area} (Short: + \p{InPrivateUse}) (6400) + \p{Ps} \p{Open_Punctuation} (= + \p{General_Category=Open_Punctuation}) + (72) + \p{Punct} \p{General_Category=Punctuation} (Short: + \p{P}) (510) + \p{Punctuation} \p{Punct} (= \p{General_Category= + Punctuation}) (510) + \p{Qaac} \p{Coptic} (= \p{Script=Coptic}) (NOT + \p{Block=Coptic}) (128) + \p{Qaai} \p{Inherited} (= \p{Script=Inherited}) + (496) + \p{QMark} \p{Quotation_Mark} (= \p{Quotation_Mark= + Y}) (29) + \p{QMark: *} \p{Quotation_Mark: *} + \p{Quotation_Mark} \p{Quotation_Mark=Y} (Short: \p{QMark}) + (29) + \p{Quotation_Mark: N*} (Short: \p{QMark=N}, \P{QMark}) (1_114_083) + \p{Quotation_Mark: Y*} (Short: \p{QMark=Y}, \p{QMark}) (29) + \p{Radical} \p{Radical=Y} (329) + \p{Radical: N*} (Single: \P{Radical}) (1_113_783) + \p{Radical: Y*} (Single: \p{Radical}) (329) + \p{Rejang} \p{Script=Rejang} (Short: \p{Rjng}; NOT + \p{Block=Rejang}) (37) + \p{Rjng} \p{Rejang} (= \p{Script=Rejang}) (NOT + \p{Block=Rejang}) (37) + \p{Runic} \p{Script=Runic} (Short: \p{Runr}; NOT + \p{Block=Runic}) (78) + \p{Runr} \p{Runic} (= \p{Script=Runic}) (NOT + \p{Block=Runic}) (78) + \p{S} \p{Symbol} (= \p{General_Category=Symbol}) + (4310) + \p{Saur} \p{Saurashtra} (= \p{Script=Saurashtra}) + (NOT \p{Block=Saurashtra}) (81) + \p{Saurashtra} \p{Script=Saurashtra} (Short: \p{Saur}; + NOT \p{Block=Saurashtra}) (81) + \p{SB: *} \p{Sentence_Break: *} + \p{Sc} \p{Currency_Symbol} (= + \p{General_Category=Currency_Symbol}) + (41) + \p{Sc: *} \p{Script: *} + \p{Script: Arab} \p{Script=Arabic} (999) + \p{Script: Arabic} (Short: \p{Sc=Arab}, \p{Arab}) (999) + \p{Script: Armenian} (Short: \p{Sc=Armn}, \p{Armn}) (90) + \p{Script: Armn} \p{Script=Armenian} (90) + \p{Script: Bali} \p{Script=Balinese} (121) + \p{Script: Balinese} (Short: \p{Sc=Bali}, \p{Bali}) (121) + \p{Script: Beng} \p{Script=Bengali} (91) + \p{Script: Bengali} (Short: \p{Sc=Beng}, \p{Beng}) (91) + \p{Script: Bopo} \p{Script=Bopomofo} (65) + \p{Script: Bopomofo} (Short: \p{Sc=Bopo}, \p{Bopo}) (65) + \p{Script: Brai} \p{Script=Braille} (256) + \p{Script: Braille} (Short: \p{Sc=Brai}, \p{Brai}) (256) + \p{Script: Bugi} \p{Script=Buginese} (30) + \p{Script: Buginese} (Short: \p{Sc=Bugi}, \p{Bugi}) (30) + \p{Script: Buhd} \p{Script=Buhid} (20) + \p{Script: Buhid} (Short: \p{Sc=Buhd}, \p{Buhd}) (20) + \p{Script: Canadian_Aboriginal} (Short: \p{Sc=Cans}, \p{Cans}) + (630) + \p{Script: Cans} \p{Script=Canadian_Aboriginal} (630) + \p{Script: Cari} \p{Script=Carian} (49) + \p{Script: Carian} (Short: \p{Sc=Cari}, \p{Cari}) (49) + \p{Script: Cham} (Short: \p{Sc=Cham}, \p{Cham}) (83) + \p{Script: Cher} \p{Script=Cherokee} (85) + \p{Script: Cherokee} (Short: \p{Sc=Cher}, \p{Cher}) (85) + \p{Script: Common} (Short: \p{Sc=Zyyy}, \p{Zyyy}) (5178) + \p{Script: Copt} \p{Script=Coptic} (128) + \p{Script: Coptic} (Short: \p{Sc=Copt}, \p{Copt}) (128) + \p{Script: Cprt} \p{Script=Cypriot} (55) + \p{Script: Cuneiform} (Short: \p{Sc=Xsux}, \p{Xsux}) (982) + \p{Script: Cypriot} (Short: \p{Sc=Cprt}, \p{Cprt}) (55) + \p{Script: Cyrillic} (Short: \p{Sc=Cyrl}, \p{Cyrl}) (404) + \p{Script: Cyrl} \p{Script=Cyrillic} (404) + \p{Script: Deseret} (Short: \p{Sc=Dsrt}, \p{Dsrt}) (80) + \p{Script: Deva} \p{Script=Devanagari} (107) + \p{Script: Devanagari} (Short: \p{Sc=Deva}, \p{Deva}) (107) + \p{Script: Dsrt} \p{Script=Deseret} (80) + \p{Script: Ethi} \p{Script=Ethiopic} (461) + \p{Script: Ethiopic} (Short: \p{Sc=Ethi}, \p{Ethi}) (461) + \p{Script: Geor} \p{Script=Georgian} (120) + \p{Script: Georgian} (Short: \p{Sc=Geor}, \p{Geor}) (120) + \p{Script: Glag} \p{Script=Glagolitic} (94) + \p{Script: Glagolitic} (Short: \p{Sc=Glag}, \p{Glag}) (94) + \p{Script: Goth} \p{Script=Gothic} (27) + \p{Script: Gothic} (Short: \p{Sc=Goth}, \p{Goth}) (27) + \p{Script: Greek} (Short: \p{Sc=Grek}, \p{Grek}) (511) + \p{Script: Grek} \p{Script=Greek} (511) + \p{Script: Gujarati} (Short: \p{Sc=Gujr}, \p{Gujr}) (83) + \p{Script: Gujr} \p{Script=Gujarati} (83) + \p{Script: Gurmukhi} (Short: \p{Sc=Guru}, \p{Guru}) (79) + \p{Script: Guru} \p{Script=Gurmukhi} (79) + \p{Script: Han} (Short: \p{Sc=Han}, \p{Han}) (71_578) + \p{Script: Hang} \p{Script=Hangul} (11_620) + \p{Script: Hangul} (Short: \p{Sc=Hang}, \p{Hang}) (11_620) + \p{Script: Hani} \p{Script=Han} (71_578) + \p{Script: Hano} \p{Script=Hanunoo} (21) + \p{Script: Hanunoo} (Short: \p{Sc=Hano}, \p{Hano}) (21) + \p{Script: Hebr} \p{Script=Hebrew} (133) + \p{Script: Hebrew} (Short: \p{Sc=Hebr}, \p{Hebr}) (133) + \p{Script: Hira} \p{Script=Hiragana} (89) + \p{Script: Hiragana} (Short: \p{Sc=Hira}, \p{Hira}) (89) + \p{Script: Inherited} (Short: \p{Sc=Qaai}, \p{Qaai}) (496) + \p{Script: Ital} \p{Script=Old_Italic} (35) + \p{Script: Kali} \p{Script=Kayah_Li} (48) + \p{Script: Kana} \p{Script=Katakana} (299) + \p{Script: Kannada} (Short: \p{Sc=Knda}, \p{Knda}) (84) + \p{Script: Katakana} (Short: \p{Sc=Kana}, \p{Kana}) (299) + \p{Script: Kayah_Li} (Short: \p{Sc=Kali}, \p{Kali}) (48) + \p{Script: Khar} \p{Script=Kharoshthi} (65) + \p{Script: Kharoshthi} (Short: \p{Sc=Khar}, \p{Khar}) (65) + \p{Script: Khmer} (Short: \p{Sc=Khmr}, \p{Khmr}) (146) + \p{Script: Khmr} \p{Script=Khmer} (146) + \p{Script: Knda} \p{Script=Kannada} (84) + \p{Script: Lao} (Short: \p{Sc=Lao}, \p{Lao}) (65) + \p{Script: Laoo} \p{Script=Lao} (65) + \p{Script: Latin} (Short: \p{Sc=Latn}, \p{Latn}) (1241) + \p{Script: Latn} \p{Script=Latin} (1241) + \p{Script: Lepc} \p{Script=Lepcha} (74) + \p{Script: Lepcha} (Short: \p{Sc=Lepc}, \p{Lepc}) (74) + \p{Script: Limb} \p{Script=Limbu} (66) + \p{Script: Limbu} (Short: \p{Sc=Limb}, \p{Limb}) (66) + \p{Script: Linb} \p{Script=Linear_B} (211) + \p{Script: Linear_B} (Short: \p{Sc=Linb}, \p{Linb}) (211) + \p{Script: Lyci} \p{Script=Lycian} (29) + \p{Script: Lycian} (Short: \p{Sc=Lyci}, \p{Lyci}) (29) + \p{Script: Lydi} \p{Script=Lydian} (27) + \p{Script: Lydian} (Short: \p{Sc=Lydi}, \p{Lydi}) (27) + \p{Script: Malayalam} (Short: \p{Sc=Mlym}, \p{Mlym}) (95) + \p{Script: Mlym} \p{Script=Malayalam} (95) + \p{Script: Mong} \p{Script=Mongolian} (153) + \p{Script: Mongolian} (Short: \p{Sc=Mong}, \p{Mong}) (153) + \p{Script: Myanmar} (Short: \p{Sc=Mymr}, \p{Mymr}) (156) + \p{Script: Mymr} \p{Script=Myanmar} (156) + \p{Script: New_Tai_Lue} (Short: \p{Sc=Talu}, \p{Talu}) (80) + \p{Script: Nko} (Short: \p{Sc=Nko}, \p{Nko}) (59) + \p{Script: Nkoo} \p{Script=Nko} (59) + \p{Script: Ogam} \p{Script=Ogham} (29) + \p{Script: Ogham} (Short: \p{Sc=Ogam}, \p{Ogam}) (29) + \p{Script: Ol_Chiki} (Short: \p{Sc=Olck}, \p{Olck}) (48) + \p{Script: Olck} \p{Script=Ol_Chiki} (48) + \p{Script: Old_Italic} (Short: \p{Sc=Ital}, \p{Ital}) (35) + \p{Script: Old_Persian} (Short: \p{Sc=Xpeo}, \p{Xpeo}) (50) + \p{Script: Oriya} (Short: \p{Sc=Orya}, \p{Orya}) (84) + \p{Script: Orya} \p{Script=Oriya} (84) + \p{Script: Osma} \p{Script=Osmanya} (40) + \p{Script: Osmanya} (Short: \p{Sc=Osma}, \p{Osma}) (40) + \p{Script: Phag} \p{Script=Phags_Pa} (56) + \p{Script: Phags_Pa} (Short: \p{Sc=Phag}, \p{Phag}) (56) + \p{Script: Phnx} \p{Script=Phoenician} (27) + \p{Script: Phoenician} (Short: \p{Sc=Phnx}, \p{Phnx}) (27) + \p{Script: Qaac} \p{Script=Coptic} (128) + \p{Script: Qaai} \p{Script=Inherited} (496) + \p{Script: Rejang} (Short: \p{Sc=Rjng}, \p{Rjng}) (37) + \p{Script: Rjng} \p{Script=Rejang} (37) + \p{Script: Runic} (Short: \p{Sc=Runr}, \p{Runr}) (78) + \p{Script: Runr} \p{Script=Runic} (78) + \p{Script: Saur} \p{Script=Saurashtra} (81) + \p{Script: Saurashtra} (Short: \p{Sc=Saur}, \p{Saur}) (81) + \p{Script: Shavian} (Short: \p{Sc=Shaw}, \p{Shaw}) (48) + \p{Script: Shaw} \p{Script=Shavian} (48) + \p{Script: Sinh} \p{Script=Sinhala} (80) + \p{Script: Sinhala} (Short: \p{Sc=Sinh}, \p{Sinh}) (80) + \p{Script: Sund} \p{Script=Sundanese} (55) + \p{Script: Sundanese} (Short: \p{Sc=Sund}, \p{Sund}) (55) + \p{Script: Sylo} \p{Script=Syloti_Nagri} (44) + \p{Script: Syloti_Nagri} (Short: \p{Sc=Sylo}, \p{Sylo}) (44) + \p{Script: Syrc} \p{Script=Syriac} (77) + \p{Script: Syriac} (Short: \p{Sc=Syrc}, \p{Syrc}) (77) + \p{Script: Tagalog} (Short: \p{Sc=Tglg}, \p{Tglg}) (20) + \p{Script: Tagb} \p{Script=Tagbanwa} (18) + \p{Script: Tagbanwa} (Short: \p{Sc=Tagb}, \p{Tagb}) (18) + \p{Script: Tai_Le} (Short: \p{Sc=Tale}, \p{Tale}) (35) + \p{Script: Tale} \p{Script=Tai_Le} (35) + \p{Script: Talu} \p{Script=New_Tai_Lue} (80) + \p{Script: Tamil} (Short: \p{Sc=Taml}, \p{Taml}) (72) + \p{Script: Taml} \p{Script=Tamil} (72) + \p{Script: Telu} \p{Script=Telugu} (93) + \p{Script: Telugu} (Short: \p{Sc=Telu}, \p{Telu}) (93) + \p{Script: Tfng} \p{Script=Tifinagh} (55) + \p{Script: Tglg} \p{Script=Tagalog} (20) + \p{Script: Thaa} \p{Script=Thaana} (50) + \p{Script: Thaana} (Short: \p{Sc=Thaa}, \p{Thaa}) (50) + \p{Script: Thai} (Short: \p{Sc=Thai}, \p{Thai}) (86) + \p{Script: Tibetan} (Short: \p{Sc=Tibt}, \p{Tibt}) (201) + \p{Script: Tibt} \p{Script=Tibetan} (201) + \p{Script: Tifinagh} (Short: \p{Sc=Tfng}, \p{Tfng}) (55) + \p{Script: Ugar} \p{Script=Ugaritic} (31) + \p{Script: Ugaritic} (Short: \p{Sc=Ugar}, \p{Ugar}) (31) + \p{Script: Unknown} (Short: \p{Sc=Zzzz}, \p{Zzzz}) (1_013_399) + \p{Script: Vai} (Short: \p{Sc=Vai}, \p{Vai}) (300) + \p{Script: Vaii} \p{Script=Vai} (300) + \p{Script: Xpeo} \p{Script=Old_Persian} (50) + \p{Script: Xsux} \p{Script=Cuneiform} (982) + \p{Script: Yi} (Short: \p{Sc=Yi}, \p{Yi}) (1220) + \p{Script: Yiii} \p{Script=Yi} (1220) + \p{Script: Zyyy} \p{Script=Common} (5178) + \p{Script: Zzzz} \p{Script=Unknown} (1_013_399) + \p{SD} \p{Soft_Dotted} (= \p{Soft_Dotted=Y}) (46) + \p{SD: *} \p{Soft_Dotted: *} + \p{Sentence_Break: AT} \p{Sentence_Break=ATerm} (4) + \p{Sentence_Break: ATerm} (Short: \p{SB=AT}) (4) + \p{Sentence_Break: CL} \p{Sentence_Break=Close} (177) + \p{Sentence_Break: Close} (Short: \p{SB=CL}) (177) + \p{Sentence_Break: CR} (Short: \p{SB=CR}) (1) + \p{Sentence_Break: EX} \p{Sentence_Break=Extend} (1285) + \p{Sentence_Break: Extend} (Short: \p{SB=EX}) (1285) + \p{Sentence_Break: FO} \p{Sentence_Break=Format} (137) + \p{Sentence_Break: Format} (Short: \p{SB=FO}) (137) + \p{Sentence_Break: LE} \p{Sentence_Break=OLetter} (90_320) + \p{Sentence_Break: LF} (Short: \p{SB=LF}) (1) + \p{Sentence_Break: LO} \p{Sentence_Break=Lower} (1906) + \p{Sentence_Break: Lower} (Short: \p{SB=LO}) (1906) + \p{Sentence_Break: NU} \p{Sentence_Break=Numeric} (362) + \p{Sentence_Break: Numeric} (Short: \p{SB=NU}) (362) + \p{Sentence_Break: OLetter} (Short: \p{SB=LE}) (90_320) + \p{Sentence_Break: Other} (Short: \p{SB=XX}) (1_018_322) + \p{Sentence_Break: SC} \p{Sentence_Break=SContinue} (26) + \p{Sentence_Break: SContinue} (Short: \p{SB=SC}) (26) + \p{Sentence_Break: SE} \p{Sentence_Break=Sep} (3) + \p{Sentence_Break: Sep} (Short: \p{SB=SE}) (3) + \p{Sentence_Break: Sp} (Short: \p{SB=Sp}) (21) + \p{Sentence_Break: ST} \p{Sentence_Break=STerm} (53) + \p{Sentence_Break: STerm} (Short: \p{SB=ST}) (53) + \p{Sentence_Break: UP} \p{Sentence_Break=Upper} (1494) + \p{Sentence_Break: Upper} (Short: \p{SB=UP}) (1494) + \p{Sentence_Break: XX} \p{Sentence_Break=Other} (1_018_322) + \p{Separator} \p{General_Category=Separator} (Short: + \p{Z}) (20) + \p{Shavian} \p{Script=Shavian} (Short: \p{Shaw}) (48) + \p{Shaw} \p{Shavian} (= \p{Script=Shavian}) (48) + \p{Sinh} \p{Sinhala} (= \p{Script=Sinhala}) (NOT + \p{Block=Sinhala}) (80) + \p{Sinhala} \p{Script=Sinhala} (Short: \p{Sinh}; NOT + \p{Block=Sinhala}) (80) + \p{Sk} \p{Modifier_Symbol} (= + \p{General_Category=Modifier_Symbol}) + (99) + \p{Sm} \p{Math_Symbol} (= \p{General_Category= + Math_Symbol}) (945) + X \p{Small_Form_Variants} \p{Block=Small_Form_Variants} (32) + \p{So} \p{Other_Symbol} (= \p{General_Category= + Other_Symbol}) (3225) + \p{Soft_Dotted} \p{Soft_Dotted=Y} (Short: \p{SD}) (46) + \p{Soft_Dotted: N*} (Short: \p{SD=N}, \P{SD}) (1_114_066) + \p{Soft_Dotted: Y*} (Short: \p{SD=Y}, \p{SD}) (46) + \p{Space} \p{White_Space=Y} \s including beyond + ASCII plus vertical tab = [[:Space:]] + (26) + \p{Space: *} \p{White_Space: *} + \p{Space_Separator} \p{General_Category=Space_Separator} + (Short: \p{Zs}) (18) + \p{SpacePerl} \s, including beyond ASCII (25) + \p{Spacing_Mark} \p{General_Category=Spacing_Mark} (Short: + \p{Mc}) (236) + X \p{Spacing_Modifier_Letters} \p{Block=Spacing_Modifier_Letters} + (80) + X \p{Specials} \p{Block=Specials} (16) + \p{STerm} \p{STerm=Y} (56) + \p{STerm: N*} (Single: \P{STerm}) (1_114_056) + \p{STerm: Y*} (Single: \p{STerm}) (56) + \p{Sund} \p{Sundanese} (= \p{Script=Sundanese}) + (NOT \p{Block=Sundanese}) (55) + \p{Sundanese} \p{Script=Sundanese} (Short: \p{Sund}; NOT + \p{Block=Sundanese}) (55) + X \p{Superscripts_And_Subscripts} \p{Block= + Superscripts_And_Subscripts} (48) + X \p{Supplemental_Arrows_A} \p{Block=Supplemental_Arrows_A} (16) + X \p{Supplemental_Arrows_B} \p{Block=Supplemental_Arrows_B} (128) + X \p{Supplemental_Mathematical_Operators} \p{Block= + Supplemental_Mathematical_Operators} + (256) + X \p{Supplemental_Punctuation} \p{Block=Supplemental_Punctuation} + (128) + X \p{Supplementary_Private_Use_Area_A} \p{Block= + Supplementary_Private_Use_Area_A} + (65_536) + X \p{Supplementary_Private_Use_Area_B} \p{Block= + Supplementary_Private_Use_Area_B} + (65_536) + \p{Surrogate} \p{General_Category=Surrogate} (Short: + \p{Cs}) (2048) + \p{Sylo} \p{Syloti_Nagri} (= \p{Script= + Syloti_Nagri}) (NOT \p{Block= + Syloti_Nagri}) (44) + \p{Syloti_Nagri} \p{Script=Syloti_Nagri} (Short: \p{Sylo}; + NOT \p{Block=Syloti_Nagri}) (44) + \p{Symbol} \p{General_Category=Symbol} (Short: \p{S}) + (4310) + \p{Syrc} \p{Syriac} (= \p{Script=Syriac}) (NOT + \p{Block=Syriac}) (77) + \p{Syriac} \p{Script=Syriac} (Short: \p{Syrc}; NOT + \p{Block=Syriac}) (77) + \p{Tagalog} \p{Script=Tagalog} (Short: \p{Tglg}; NOT + \p{Block=Tagalog}) (20) + \p{Tagb} \p{Tagbanwa} (= \p{Script=Tagbanwa}) (NOT + \p{Block=Tagbanwa}) (18) + \p{Tagbanwa} \p{Script=Tagbanwa} (Short: \p{Tagb}; NOT + \p{Block=Tagbanwa}) (18) + X \p{Tags} \p{Block=Tags} (128) + \p{Tai_Le} \p{Script=Tai_Le} (Short: \p{Tale}; NOT + \p{Block=Tai_Le}) (35) + X \p{Tai_Xuan_Jing_Symbols} \p{Block=Tai_Xuan_Jing_Symbols} (96) + \p{Tale} \p{Tai_Le} (= \p{Script=Tai_Le}) (NOT + \p{Block=Tai_Le}) (35) + \p{Talu} \p{New_Tai_Lue} (= \p{Script=New_Tai_Lue}) + (NOT \p{Block=New_Tai_Lue}) (80) + \p{Tamil} \p{Script=Tamil} (Short: \p{Taml}; NOT + \p{Block=Tamil}) (72) + \p{Taml} \p{Tamil} (= \p{Script=Tamil}) (NOT + \p{Block=Tamil}) (72) + \p{Telu} \p{Telugu} (= \p{Script=Telugu}) (NOT + \p{Block=Telugu}) (93) + \p{Telugu} \p{Script=Telugu} (Short: \p{Telu}; NOT + \p{Block=Telugu}) (93) + \p{Term} \p{Terminal_Punctuation} (= + \p{Terminal_Punctuation=Y}) (119) + \p{Term: *} \p{Terminal_Punctuation: *} + \p{Terminal_Punctuation} \p{Terminal_Punctuation=Y} (Short: + \p{Term}) (119) + \p{Terminal_Punctuation: N*} (Short: \p{Term=N}, \P{Term}) + (1_113_993) + \p{Terminal_Punctuation: Y*} (Short: \p{Term=Y}, \p{Term}) (119) + \p{Tfng} \p{Tifinagh} (= \p{Script=Tifinagh}) (NOT + \p{Block=Tifinagh}) (55) + \p{Tglg} \p{Tagalog} (= \p{Script=Tagalog}) (NOT + \p{Block=Tagalog}) (20) + \p{Thaa} \p{Thaana} (= \p{Script=Thaana}) (NOT + \p{Block=Thaana}) (50) + \p{Thaana} \p{Script=Thaana} (Short: \p{Thaa}; NOT + \p{Block=Thaana}) (50) + \p{Thai} \p{Script=Thai} (NOT \p{Block=Thai}) (86) + \p{Tibetan} \p{Script=Tibetan} (Short: \p{Tibt}; NOT + \p{Block=Tibetan}) (201) + \p{Tibt} \p{Tibetan} (= \p{Script=Tibetan}) (NOT + \p{Block=Tibetan}) (201) + \p{Tifinagh} \p{Script=Tifinagh} (Short: \p{Tfng}; NOT + \p{Block=Tifinagh}) (55) + \p{Title} \p{General_Category=Titlecase_Letter} + (Short: \p{Lt}) (31) + \p{Titlecase_Letter} \p{Title} (= \p{General_Category= + Titlecase_Letter}) (31) + \p{Ugar} \p{Ugaritic} (= \p{Script=Ugaritic}) (NOT + \p{Block=Ugaritic}) (31) + \p{Ugaritic} \p{Script=Ugaritic} (Short: \p{Ugar}; NOT + \p{Block=Ugaritic}) (31) + \p{UIdeo} \p{Unified_Ideograph} (= + \p{Unified_Ideograph=Y}) (70_237) + \p{UIdeo: *} \p{Unified_Ideograph: *} + \p{Unassigned} \p{General_Category=Unassigned} (Short: + \p{Cn}) (873_883) + X \p{Unified_Canadian_Aboriginal_Syllabics} \p{Block= + Unified_Canadian_Aboriginal_Syllabics} + (Short: \p{InCanadianSyllabics}) (640) + \p{Unified_Ideograph} \p{Unified_Ideograph=Y} (Short: \p{UIdeo}) + (70_237) + \p{Unified_Ideograph: N*} (Short: \p{UIdeo=N}, \P{UIdeo}) + (1_043_875) + \p{Unified_Ideograph: Y*} (Short: \p{UIdeo=Y}, \p{UIdeo}) (70_237) + \p{Unknown} \p{Script=Unknown} (Short: \p{Zzzz}) + (1_013_399) + \p{Upper} \p{Uppercase=Y} (1463) + \p{Upper: *} \p{Uppercase: *} + \p{Uppercase} \p{Upper} (= \p{Uppercase=Y}) (1463) + \p{Uppercase: N*} (Short: \p{Upper=N}, \P{Upper}) (1_112_649) + \p{Uppercase: Y*} (Short: \p{Upper=Y}, \p{Upper}) (1463) + \p{Uppercase_Letter} \p{General_Category=Uppercase_Letter} + (Short: \p{Lu}) (1421) + \p{Vai} \p{Script=Vai} (NOT \p{Block=Vai}) (300) + \p{Vaii} \p{Vai} (= \p{Script=Vai}) (NOT \p{Block= + Vai}) (300) + \p{Variation_Selector} \p{Variation_Selector=Y} (Short: \p{VS}) + (259) + \p{Variation_Selector: N*} (Short: \p{VS=N}, \P{VS}) (1_113_853) + \p{Variation_Selector: Y*} (Short: \p{VS=Y}, \p{VS}) (259) + X \p{Variation_Selectors} \p{Block=Variation_Selectors} (16) + X \p{Variation_Selectors_Supplement} \p{Block= + Variation_Selectors_Supplement} (240) + X \p{Vertical_Forms} \p{Block=Vertical_Forms} (16) + \p{VertSpace} \v (7) + \p{VS} \p{Variation_Selector} (= + \p{Variation_Selector=Y}) (259) + \p{VS: *} \p{Variation_Selector: *} + \p{WB: *} \p{Word_Break: *} + \p{White_Space} \p{White_Space=Y} (Short: \p{WSpace}) (26) + \p{White_Space: N*} (Short: \p{Space=N}, \P{WSpace}) + (1_114_086) + \p{White_Space: Y*} (Short: \p{Space=Y}, \p{WSpace}) (26) + \p{Word} \w, including beyond ASCII (95_382) + \p{Word_Break: ALetter} (Short: \p{WB=LE}) (21_903) + \p{Word_Break: CR} (Short: \p{WB=CR}) (1) + \p{Word_Break: EX} \p{Word_Break=ExtendNumLet} (10) + \p{Word_Break: Extend} (Short: \p{WB=Extend}) (1285) + \p{Word_Break: ExtendNumLet} (Short: \p{WB=EX}) (10) + \p{Word_Break: FO} \p{Word_Break=Format} (137) + \p{Word_Break: Format} (Short: \p{WB=FO}) (137) + \p{Word_Break: KA} \p{Word_Break=Katakana} (309) + \p{Word_Break: Katakana} (Short: \p{WB=KA}) (309) + \p{Word_Break: LE} \p{Word_Break=ALetter} (21_903) + \p{Word_Break: LF} (Short: \p{WB=LF}) (1) + \p{Word_Break: MB} \p{Word_Break=MidNumLet} (8) + \p{Word_Break: MidLetter} (Short: \p{WB=ML}) (8) + \p{Word_Break: MidNum} (Short: \p{WB=MN}) (15) + \p{Word_Break: MidNumLet} (Short: \p{WB=MB}) (8) + \p{Word_Break: ML} \p{Word_Break=MidLetter} (8) + \p{Word_Break: MN} \p{Word_Break=MidNum} (15) + \p{Word_Break: Newline} (Short: \p{WB=NL}) (5) + \p{Word_Break: NL} \p{Word_Break=Newline} (5) + \p{Word_Break: NU} \p{Word_Break=Numeric} (361) + \p{Word_Break: Numeric} (Short: \p{WB=NU}) (361) + \p{Word_Break: Other} (Short: \p{WB=XX}) (1_090_069) + \p{Word_Break: XX} \p{Word_Break=Other} (1_090_069) + \p{WSpace} \p{White_Space} (= \p{White_Space=Y}) (26) + \p{WSpace: *} \p{White_Space: *} + \p{XDigit} \p{ASCII_Hex_Digit=Y} [0-9A-Fa-f] (Short: + \p{AHex}) (22) + \p{XID_Continue} \p{XID_Continue=Y} (Short: \p{XIDC}) + (95_312) + \p{XID_Continue: N*} (Short: \p{XIDC=N}, \P{XIDC}) (1_018_800) + \p{XID_Continue: Y*} (Short: \p{XIDC=Y}, \p{XIDC}) (95_312) + \p{XID_Start} \p{XID_Start=Y} (Short: \p{XIDS}) (93_649) + \p{XID_Start: N*} (Short: \p{XIDS=N}, \P{XIDS}) (1_020_463) + \p{XID_Start: Y*} (Short: \p{XIDS=Y}, \p{XIDS}) (93_649) + \p{XIDC} \p{XID_Continue} (= \p{XID_Continue=Y}) + (95_312) + \p{XIDC: *} \p{XID_Continue: *} + \p{XIDS} \p{XID_Start} (= \p{XID_Start=Y}) (93_649) + \p{XIDS: *} \p{XID_Start: *} + \p{Xpeo} \p{Old_Persian} (= \p{Script=Old_Persian}) + (NOT \p{Block=Old_Persian}) (50) + \p{Xsux} \p{Cuneiform} (= \p{Script=Cuneiform}) + (NOT \p{Block=Cuneiform}) (982) + \p{Yi} \p{Script=Yi} (1220) + X \p{Yi_Radicals} \p{Block=Yi_Radicals} (64) + X \p{Yi_Syllables} \p{Block=Yi_Syllables} (1168) + \p{Yiii} \p{Yi} (= \p{Script=Yi}) (1220) + X \p{Yijing_Hexagram_Symbols} \p{Block=Yijing_Hexagram_Symbols} (64) + \p{Z} \p{Separator} (= \p{General_Category= + Separator}) (20) + \p{Zl} \p{Line_Separator} (= \p{General_Category= + Line_Separator}) (1) + \p{Zp} \p{Paragraph_Separator} (= + \p{General_Category= + Paragraph_Separator}) (1) + \p{Zs} \p{Space_Separator} (= + \p{General_Category=Space_Separator}) + (18) + \p{Zyyy} \p{Common} (= \p{Script=Common}) (5178) + \p{Zzzz} \p{Unknown} (= \p{Script=Unknown}) + (1_013_399) + + + +=head2 Legal \p{} and \P{} constructs that match no characters + +Unicode has some property-value pairs that currently don't match anything. +This happens generally either because they are obsolete, or for symmetry with +other forms, but no language has yet been encoded that uses them. In this +version of Unicode, the following match zero code points: + +=over 4 + +=item \p{Canonical_Combining_Class=Attached_Below_Left} + +=item \p{Joining_Type=Left_Joining} + +=back + + + +=head1 Properties not accessible through \p{} and \P{} + +A few properties are accessible in Perl via various function calls only. +These are: + Lowercase_Mapping lc() and lcfirst() + Titlecase_Mapping ucfirst() + Uppercase_Mapping uc() + +Case_Folding is accessible through the /i modifier in regular expressions. + +The Name property is accessible through the \N{} interpolation in +double-quoted strings and regular expressions, but both usages require a C to be specified, which also contains related functions viacode() +and vianame(). + +=head1 Unicode regular expression properties that are NOT accepted by Perl + +Perl will generate an error for a few character properties in Unicode when +used in a regular expression. The non-Unihan ones are listed below, with the +reasons they are not accepted, perhaps with work-arounds. The short names for +the properties are listed enclosed in (parentheses). + +=over 4 + + + + + + +=item I (XO_NFC) + +=item I (XO_NFD) + +=item I (XO_NFKC) + +=item I (XO_NFKD) + +Easily computed, and yet doesn't cover the common encoding forms (UTF-16/8) + + + + + +=item I (Gr_Link) + +Deprecated by Unicode. Use ccc=vr (Canonical_Combining_Class=Virama) instead + + + + + +=item I (JSN) + +Used by Unicode internally for generating other properties and not intended to be used stand-alone + + + + + +=item I (sc=Hrkt) + +Obsolete. All code points previously matched by this have been moved to "Script=Common" + + + + + + + + +=back + +An installation can choose to allow any of these to be matched by changing the +controlling lists contained in the program C<$Config{privlib}>/F +and then re-running F. (C<%Config> is available from the Config module). + +=head1 Files in the I directory (for serious hackers only) + +All Unicode properties are really mappings (in the mathematical sense) from +code points to their respective values. As part of its build process, +Perl constructs tables containing these mappings for all properties that it +deals with. But only a few of these are written out into files. +Those written out are in the directory C<$Config{privlib}>/F +(%Config is available from the Config module). + +Those ones written are ones needed by Perl internally during execution, or for +which there is some demand, and those for which there is no access through the +Perl core. Generally, properties that can be used in regular expression +matching do not have their map tables written, like Script. Nor are the +simplistic properties that have a better, more complete version, such as +Simple_Uppercase_Mapping (Uppercase_Mapping is written instead). + +None of the properties in the I directory are currently directly +accessible through the Perl core, although some may be accessed indirectly. +For example, the uc() function implements the Uppercase_Mapping property and +uses the F file found in this directory. + +The available files with their properties (short names in parentheses), +and any flags or comments about them, are: + + Bmg.pl Bidi_Mirroring_Glyph (bmg) + Digit.pl Perl_Decimal_Digit + Fold.pl Case_Folding (cf) + Lower.pl Lowercase_Mapping (lc) + Title.pl Titlecase_Mapping (tc) + Upper.pl Uppercase_Mapping (uc) + + +An installation can choose to change which files are generated by changing the +controlling lists contained in the program C<$Config{privlib}>/F +and then re-running F. + +Each of these files defines two hash entries to help reading programs decipher +it. One of them looks like this: + + $utf8::SwashInfo{'ToNAME'}{'format'} = 's'; + +where 'NAME' is a name to indicate the property. For backwards compatibility, +this is not necessarily the property's official Unicode name. (The 'To' is +also for backwards compatibility.) The hash entry gives the format of the +mapping fields of the table, currently one of the following: + + b binary + d single decimal digit + f floating point number + i integer + r rational: an integer or a fraction + s arbitrary string + x positive hex whole number; a code point + + +This format applies only to the entries in the main body of the table. +Entries defined in hashes or ones that are missing from the list can have a +different format. + +The value that the missing entries have is given by the other SwashInfo hash +entry line; it looks like this: + + $utf8::SwashInfo{'ToNAME'}{'missing'} = 'NaN'; + +This example line says that any Unicode code points not explicitly listed in +the file have the value 'NaN' under the property indicated by NAME. If the +value is the special string C<< >>, it means that the value for +any missing code point is the code point itself. This happens, for example, +in the file for Uppercase_Mapping (To/Upper.pl), in which code points like the +character 'A', are missing because the uppercase of 'A' is itself. + +=head1 SEE ALSO + +L + +L + +L + diff --git a/t/re/pat_advanced.t b/t/re/pat_advanced.t index 9775421..a0eec58 100644 --- a/t/re/pat_advanced.t +++ b/t/re/pat_advanced.t @@ -21,7 +21,7 @@ BEGIN { } -plan tests => 1146; # Update this when adding/deleting tests. +plan tests => 1142; # Update this when adding/deleting tests. run_tests() unless caller; @@ -1120,7 +1120,6 @@ sub run_tests { '_'.pack('U', 0x00F1), # _ + n-tilde 'c'.pack('U', 0x0327), # c + cedilla pack('U*', 0x00F1, 0x0327), # n-tilde + cedilla - 'a'.pack('U', 0x00B2), # a + superscript two pack('U', 0x0391), # ALPHA pack('U', 0x0391).'2', # ALPHA + 2 pack('U', 0x0391).'_', # ALPHA + _ @@ -1729,8 +1728,8 @@ sub run_tests { my @isPrint = grep {not /[[:print:]]/ and /\p{IsPrint}/} map {chr} 0 .. 0x1f, 0x7f .. 0x9f; - iseq join ('', @isPrint), "\x09\x0a\x0b\x0c\x0d\x85", - 'IsPrint disagrees with [:print:] on control characters'; + iseq join ('', @isPrint), "", + 'IsPrint agrees with [:print:] on control characters'; my @isPunct = grep {/[[:punct:]]/ != /\p{IsPunct}/} map {chr} 0x80 .. 0xff; diff --git a/t/re/regexp_unicode_prop.t b/t/re/regexp_unicode_prop.t index 8cc09f1..ba55b96 100644 --- a/t/re/regexp_unicode_prop.t +++ b/t/re/regexp_unicode_prop.t @@ -106,7 +106,8 @@ my %SHORT_PROPERTIES = ( 'Ll' => ['m', '\N{CYRILLIC SMALL LETTER A}'], 'Lu' => ['M', '\N{GREEK CAPITAL LETTER ALPHA}'], 'Lo' => ['\N{HIRAGANA LETTER SMALL A}'], - 'Mn' => ['\N{COMBINING GRAVE ACCENT}'], + # is also in other alphabetic + 'Mn' => ['\N{HEBREW POINT RAFE}'], 'Nd' => ["0", '\N{ARABIC-INDIC DIGIT ZERO}'], 'Pc' => ["_"], 'Po' => ["!"], diff --git a/t/re/uniprops.t b/t/re/uniprops.t new file mode 100644 index 0000000..74548c2 --- /dev/null +++ b/t/re/uniprops.t @@ -0,0 +1,71662 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is machine-generated by lib/unicore/mktables from the Unicode database, +# Version 5.1.0. Any changes made here will be lost! + +use strict; +use warnings; + +# Test the \p{} regular expression constructs. This file is constructed by +# mktables from the tables it generates, so if mktables is buggy, this won't +# necessarily catch those bugs. Tests are generated for all feasible +# properties; a few aren't currently XXX feasible; see is_code_point_usable() +# in mktables for details. + +# Standard test packages are not used because this manipulates SIG_WARN. It +# exits 0 if every non-skipped test succeeded; -1 if any failed. + +my $Tests = 0; +my $Fails = 0; +my $Skips = 0; + +my $non_ASCII = (ord('A') == 65); + +# The first 127 ASCII characters in ordinal order, with the ones that don't +# have Perl names (as of 5.8) replaced by dots. The 127th is used as the +# string delimiter +my $ascii_to_ebcdic = "\0......\a\b\t\n.\f\r.................. !\"#\$\%&'()*+,-./0123456789:;<=>?\@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"; +#for my $i (0..126) { +# print $i, ": ", substr($ascii_to_ebcdic, $i, 1), "\n"; +#} + +sub Expect($$$$) { + my $expected = shift; + my $ord = shift; + my $regex = shift; + my $warning_type = shift; # Type of warning message, like 'deprecated' + # or empty if none + my $line = (caller)[2]; + + # Convert the code point to hex form + my $string = sprintf "\"\\x{%04X}\"", $ord; + + # Convert the non-ASCII code points expressible as characters in Perl 5.8 + # to their ASCII equivalents, and skip the others. + if ($non_ASCII && $ord < 255) { + + # Dots are used as place holders in the conversion string for the + # non-convertible ones, so check for it first. + if ($ord == 0x2E) { + $ord = ord('.'); + } + elsif ($ord < 0x7F + # Any dots returned are non-convertible. + && ((my $char = substr($ascii_to_ebcdic, $ord, 1)) ne '.')) + { + #print STDERR "$ord, $char, \n"; + $ord = ord($char); + } + else { + $Tests++; + $Skips++; + print "ok $Tests - $string =~ $regex # Skipped: non-ASCII\n"; + return; + } + } + + # The first time through, use all warnings. + my @tests = ""; + + # If the input should generate a warning, add another time through with + # them turned off + push @tests, "no warnings '$warning_type';" if $warning_type; + + foreach my $no_warnings (@tests) { + + # Store any warning messages instead of outputting them + local $SIG{__WARN__} = $SIG{__WARN__}; + my $warning_message; + $SIG{__WARN__} = sub { $warning_message = $_[0] }; + + $Tests++; + + # A string eval is needed because of the 'no warnings'. + # Assumes no parens in the regular expression + my $result = eval "$no_warnings + my \$RegObj = qr($regex); + $string =~ \$RegObj ? 1 : 0"; + if (not defined $result) { + print "not ok $Tests - couldn't compile /$regex/; line $line: $@\n"; + $Fails++; + } + elsif ($result ^ $expected) { + print "not ok $Tests - expected $expected but got $result for $string =~ qr/$regex/; line $line\n"; + $Fails++; + } + elsif ($warning_message) { + if (! $warning_type || ($warning_type && $no_warnings)) { + print "not ok $Tests - for qr/$regex/ did not expect warning message '$warning_message'; line $line\n"; + $Fails++; + } + else { + print "ok $Tests - expected and got a warning message for qr/$regex/; line $line\n"; + } + } + elsif ($warning_type && ! $no_warnings) { + print "not ok $Tests - for qr/$regex/ expected a $warning_type warning message, but got none; line $line\n"; + $Fails++; + } + else { + print "ok $Tests - got $result for $string =~ qr/$regex/; line $line\n"; + } + } + return; +} + +sub Error($) { + my $regex = shift; + $Tests++; + if (eval { 'x' =~ qr/$regex/; 1 }) { + $Fails++; + my $line = (caller)[2]; + print "not ok $Tests - re compiled ok, but expected error for qr/$regex/; line $line: $@\n"; + } + else { + my $line = (caller)[2]; + print "ok $Tests - got and expected error for qr/$regex/; line $line\n"; + } + return; +} + +sub Finished() { + print "1..$Tests.\n"; + exit($Fails ? -1 : 0); +} + +Error('\p{Script=InGreek}'); # Bug #69018 +Error('\p{Other_Lowercase=:= Yes}'); +Error('\P{Other_Lowercase=:= Yes}'); +Expect(1, 696, '\p{Other_Lowercase=yes}', 'deprecated'); +Expect(0, 696, '\p{^Other_Lowercase=yes}', 'deprecated'); +Expect(0, 696, '\P{Other_Lowercase=yes}', 'deprecated'); +Expect(1, 696, '\P{^Other_Lowercase=yes}', 'deprecated'); +Expect(0, 687, '\p{Other_Lowercase=yes}', 'deprecated'); +Expect(1, 687, '\p{^Other_Lowercase=yes}', 'deprecated'); +Expect(1, 687, '\P{Other_Lowercase=yes}', 'deprecated'); +Expect(0, 687, '\P{^Other_Lowercase=yes}', 'deprecated'); +Expect(1, 696, '\p{Other_Lowercase=--Yes}', 'deprecated'); +Expect(0, 696, '\p{^Other_Lowercase=--Yes}', 'deprecated'); +Expect(0, 696, '\P{Other_Lowercase=--Yes}', 'deprecated'); +Expect(1, 696, '\P{^Other_Lowercase=--Yes}', 'deprecated'); +Expect(0, 687, '\p{Other_Lowercase=--Yes}', 'deprecated'); +Expect(1, 687, '\p{^Other_Lowercase=--Yes}', 'deprecated'); +Expect(1, 687, '\P{Other_Lowercase=--Yes}', 'deprecated'); +Expect(0, 687, '\P{^Other_Lowercase=--Yes}', 'deprecated'); +Error('\p{OLower= Y:=}'); +Error('\P{OLower= Y:=}'); +Expect(1, 696, '\p{OLower=y}', 'deprecated'); +Expect(0, 696, '\p{^OLower=y}', 'deprecated'); +Expect(0, 696, '\P{OLower=y}', 'deprecated'); +Expect(1, 696, '\P{^OLower=y}', 'deprecated'); +Expect(0, 687, '\p{OLower=y}', 'deprecated'); +Expect(1, 687, '\p{^OLower=y}', 'deprecated'); +Expect(1, 687, '\P{OLower=y}', 'deprecated'); +Expect(0, 687, '\P{^OLower=y}', 'deprecated'); +Expect(1, 696, '\p{OLower: Y}', 'deprecated'); +Expect(0, 696, '\p{^OLower: Y}', 'deprecated'); +Expect(0, 696, '\P{OLower: Y}', 'deprecated'); +Expect(1, 696, '\P{^OLower: Y}', 'deprecated'); +Expect(0, 687, '\p{OLower: Y}', 'deprecated'); +Expect(1, 687, '\p{^OLower: Y}', 'deprecated'); +Expect(1, 687, '\P{OLower: Y}', 'deprecated'); +Expect(0, 687, '\P{^OLower: Y}', 'deprecated'); +Error('\p{Is_Other_Lowercase=/a/ T}'); +Error('\P{Is_Other_Lowercase=/a/ T}'); +Expect(1, 696, '\p{Is_Other_Lowercase=t}', 'deprecated'); +Expect(0, 696, '\p{^Is_Other_Lowercase=t}', 'deprecated'); +Expect(0, 696, '\P{Is_Other_Lowercase=t}', 'deprecated'); +Expect(1, 696, '\P{^Is_Other_Lowercase=t}', 'deprecated'); +Expect(0, 687, '\p{Is_Other_Lowercase=t}', 'deprecated'); +Expect(1, 687, '\p{^Is_Other_Lowercase=t}', 'deprecated'); +Expect(1, 687, '\P{Is_Other_Lowercase=t}', 'deprecated'); +Expect(0, 687, '\P{^Is_Other_Lowercase=t}', 'deprecated'); +Expect(1, 696, '\p{Is_Other_Lowercase=-T}', 'deprecated'); +Expect(0, 696, '\p{^Is_Other_Lowercase=-T}', 'deprecated'); +Expect(0, 696, '\P{Is_Other_Lowercase=-T}', 'deprecated'); +Expect(1, 696, '\P{^Is_Other_Lowercase=-T}', 'deprecated'); +Expect(0, 687, '\p{Is_Other_Lowercase=-T}', 'deprecated'); +Expect(1, 687, '\p{^Is_Other_Lowercase=-T}', 'deprecated'); +Expect(1, 687, '\P{Is_Other_Lowercase=-T}', 'deprecated'); +Expect(0, 687, '\P{^Is_Other_Lowercase=-T}', 'deprecated'); +Error('\p{Is_OLower= True/a/}'); +Error('\P{Is_OLower= True/a/}'); +Expect(1, 696, '\p{Is_OLower=true}', 'deprecated'); +Expect(0, 696, '\p{^Is_OLower=true}', 'deprecated'); +Expect(0, 696, '\P{Is_OLower=true}', 'deprecated'); +Expect(1, 696, '\P{^Is_OLower=true}', 'deprecated'); +Expect(0, 687, '\p{Is_OLower=true}', 'deprecated'); +Expect(1, 687, '\p{^Is_OLower=true}', 'deprecated'); +Expect(1, 687, '\P{Is_OLower=true}', 'deprecated'); +Expect(0, 687, '\P{^Is_OLower=true}', 'deprecated'); +Expect(1, 696, '\p{Is_OLower=_-true}', 'deprecated'); +Expect(0, 696, '\p{^Is_OLower=_-true}', 'deprecated'); +Expect(0, 696, '\P{Is_OLower=_-true}', 'deprecated'); +Expect(1, 696, '\P{^Is_OLower=_-true}', 'deprecated'); +Expect(0, 687, '\p{Is_OLower=_-true}', 'deprecated'); +Expect(1, 687, '\p{^Is_OLower=_-true}', 'deprecated'); +Expect(1, 687, '\P{Is_OLower=_-true}', 'deprecated'); +Expect(0, 687, '\P{^Is_OLower=_-true}', 'deprecated'); +Error('\p{Other_Lowercase=_ NO:=}'); +Error('\P{Other_Lowercase=_ NO:=}'); +Expect(1, 687, '\p{Other_Lowercase=no}', 'deprecated'); +Expect(0, 687, '\p{^Other_Lowercase=no}', 'deprecated'); +Expect(0, 687, '\P{Other_Lowercase=no}', 'deprecated'); +Expect(1, 687, '\P{^Other_Lowercase=no}', 'deprecated'); +Expect(0, 696, '\p{Other_Lowercase=no}', 'deprecated'); +Expect(1, 696, '\p{^Other_Lowercase=no}', 'deprecated'); +Expect(1, 696, '\P{Other_Lowercase=no}', 'deprecated'); +Expect(0, 696, '\P{^Other_Lowercase=no}', 'deprecated'); +Expect(1, 687, '\p{Other_Lowercase=_ no}', 'deprecated'); +Expect(0, 687, '\p{^Other_Lowercase=_ no}', 'deprecated'); +Expect(0, 687, '\P{Other_Lowercase=_ no}', 'deprecated'); +Expect(1, 687, '\P{^Other_Lowercase=_ no}', 'deprecated'); +Expect(0, 696, '\p{Other_Lowercase=_ no}', 'deprecated'); +Expect(1, 696, '\p{^Other_Lowercase=_ no}', 'deprecated'); +Expect(1, 696, '\P{Other_Lowercase=_ no}', 'deprecated'); +Expect(0, 696, '\P{^Other_Lowercase=_ no}', 'deprecated'); +Error('\p{OLower: /a/ N}'); +Error('\P{OLower: /a/ N}'); +Expect(1, 687, '\p{OLower=n}', 'deprecated'); +Expect(0, 687, '\p{^OLower=n}', 'deprecated'); +Expect(0, 687, '\P{OLower=n}', 'deprecated'); +Expect(1, 687, '\P{^OLower=n}', 'deprecated'); +Expect(0, 696, '\p{OLower=n}', 'deprecated'); +Expect(1, 696, '\p{^OLower=n}', 'deprecated'); +Expect(1, 696, '\P{OLower=n}', 'deprecated'); +Expect(0, 696, '\P{^OLower=n}', 'deprecated'); +Expect(1, 687, '\p{OLower= n}', 'deprecated'); +Expect(0, 687, '\p{^OLower= n}', 'deprecated'); +Expect(0, 687, '\P{OLower= n}', 'deprecated'); +Expect(1, 687, '\P{^OLower= n}', 'deprecated'); +Expect(0, 696, '\p{OLower= n}', 'deprecated'); +Expect(1, 696, '\p{^OLower= n}', 'deprecated'); +Expect(1, 696, '\P{OLower= n}', 'deprecated'); +Expect(0, 696, '\P{^OLower= n}', 'deprecated'); +Error('\p{Is_Other_Lowercase::=- F}'); +Error('\P{Is_Other_Lowercase::=- F}'); +Expect(1, 687, '\p{Is_Other_Lowercase=f}', 'deprecated'); +Expect(0, 687, '\p{^Is_Other_Lowercase=f}', 'deprecated'); +Expect(0, 687, '\P{Is_Other_Lowercase=f}', 'deprecated'); +Expect(1, 687, '\P{^Is_Other_Lowercase=f}', 'deprecated'); +Expect(0, 696, '\p{Is_Other_Lowercase=f}', 'deprecated'); +Expect(1, 696, '\p{^Is_Other_Lowercase=f}', 'deprecated'); +Expect(1, 696, '\P{Is_Other_Lowercase=f}', 'deprecated'); +Expect(0, 696, '\P{^Is_Other_Lowercase=f}', 'deprecated'); +Expect(1, 687, '\p{Is_Other_Lowercase: F}', 'deprecated'); +Expect(0, 687, '\p{^Is_Other_Lowercase: F}', 'deprecated'); +Expect(0, 687, '\P{Is_Other_Lowercase: F}', 'deprecated'); +Expect(1, 687, '\P{^Is_Other_Lowercase: F}', 'deprecated'); +Expect(0, 696, '\p{Is_Other_Lowercase: F}', 'deprecated'); +Expect(1, 696, '\p{^Is_Other_Lowercase: F}', 'deprecated'); +Expect(1, 696, '\P{Is_Other_Lowercase: F}', 'deprecated'); +Expect(0, 696, '\P{^Is_Other_Lowercase: F}', 'deprecated'); +Error('\p{Is_OLower= :=False}'); +Error('\P{Is_OLower= :=False}'); +Expect(1, 687, '\p{Is_OLower=false}', 'deprecated'); +Expect(0, 687, '\p{^Is_OLower=false}', 'deprecated'); +Expect(0, 687, '\P{Is_OLower=false}', 'deprecated'); +Expect(1, 687, '\P{^Is_OLower=false}', 'deprecated'); +Expect(0, 696, '\p{Is_OLower=false}', 'deprecated'); +Expect(1, 696, '\p{^Is_OLower=false}', 'deprecated'); +Expect(1, 696, '\P{Is_OLower=false}', 'deprecated'); +Expect(0, 696, '\P{^Is_OLower=false}', 'deprecated'); +Expect(1, 687, '\p{Is_OLower=_ False}', 'deprecated'); +Expect(0, 687, '\p{^Is_OLower=_ False}', 'deprecated'); +Expect(0, 687, '\P{Is_OLower=_ False}', 'deprecated'); +Expect(1, 687, '\P{^Is_OLower=_ False}', 'deprecated'); +Expect(0, 696, '\p{Is_OLower=_ False}', 'deprecated'); +Expect(1, 696, '\p{^Is_OLower=_ False}', 'deprecated'); +Expect(1, 696, '\P{Is_OLower=_ False}', 'deprecated'); +Expect(0, 696, '\P{^Is_OLower=_ False}', 'deprecated'); +Error('\p{Variation_Selector= Yes:=}'); +Error('\P{Variation_Selector= Yes:=}'); +Expect(1, 6157, '\p{Variation_Selector=yes}', ""); +Expect(0, 6157, '\p{^Variation_Selector=yes}', ""); +Expect(0, 6157, '\P{Variation_Selector=yes}', ""); +Expect(1, 6157, '\P{^Variation_Selector=yes}', ""); +Expect(0, 6154, '\p{Variation_Selector=yes}', ""); +Expect(1, 6154, '\p{^Variation_Selector=yes}', ""); +Expect(1, 6154, '\P{Variation_Selector=yes}', ""); +Expect(0, 6154, '\P{^Variation_Selector=yes}', ""); +Expect(1, 6157, '\p{Variation_Selector: -_Yes}', ""); +Expect(0, 6157, '\p{^Variation_Selector: -_Yes}', ""); +Expect(0, 6157, '\P{Variation_Selector: -_Yes}', ""); +Expect(1, 6157, '\P{^Variation_Selector: -_Yes}', ""); +Expect(0, 6154, '\p{Variation_Selector: -_Yes}', ""); +Expect(1, 6154, '\p{^Variation_Selector: -_Yes}', ""); +Expect(1, 6154, '\P{Variation_Selector: -_Yes}', ""); +Expect(0, 6154, '\P{^Variation_Selector: -_Yes}', ""); +Error('\p{VS=-_y/a/}'); +Error('\P{VS=-_y/a/}'); +Expect(1, 6157, '\p{VS=y}', ""); +Expect(0, 6157, '\p{^VS=y}', ""); +Expect(0, 6157, '\P{VS=y}', ""); +Expect(1, 6157, '\P{^VS=y}', ""); +Expect(0, 6154, '\p{VS=y}', ""); +Expect(1, 6154, '\p{^VS=y}', ""); +Expect(1, 6154, '\P{VS=y}', ""); +Expect(0, 6154, '\P{^VS=y}', ""); +Expect(1, 6157, '\p{VS= Y}', ""); +Expect(0, 6157, '\p{^VS= Y}', ""); +Expect(0, 6157, '\P{VS= Y}', ""); +Expect(1, 6157, '\P{^VS= Y}', ""); +Expect(0, 6154, '\p{VS= Y}', ""); +Expect(1, 6154, '\p{^VS= Y}', ""); +Expect(1, 6154, '\P{VS= Y}', ""); +Expect(0, 6154, '\P{^VS= Y}', ""); +Error('\p{Is_Variation_Selector: :=_T}'); +Error('\P{Is_Variation_Selector: :=_T}'); +Expect(1, 6157, '\p{Is_Variation_Selector=t}', ""); +Expect(0, 6157, '\p{^Is_Variation_Selector=t}', ""); +Expect(0, 6157, '\P{Is_Variation_Selector=t}', ""); +Expect(1, 6157, '\P{^Is_Variation_Selector=t}', ""); +Expect(0, 6154, '\p{Is_Variation_Selector=t}', ""); +Expect(1, 6154, '\p{^Is_Variation_Selector=t}', ""); +Expect(1, 6154, '\P{Is_Variation_Selector=t}', ""); +Expect(0, 6154, '\P{^Is_Variation_Selector=t}', ""); +Expect(1, 6157, '\p{Is_Variation_Selector= T}', ""); +Expect(0, 6157, '\p{^Is_Variation_Selector= T}', ""); +Expect(0, 6157, '\P{Is_Variation_Selector= T}', ""); +Expect(1, 6157, '\P{^Is_Variation_Selector= T}', ""); +Expect(0, 6154, '\p{Is_Variation_Selector= T}', ""); +Expect(1, 6154, '\p{^Is_Variation_Selector= T}', ""); +Expect(1, 6154, '\P{Is_Variation_Selector= T}', ""); +Expect(0, 6154, '\P{^Is_Variation_Selector= T}', ""); +Error('\p{Is_VS=/a/--true}'); +Error('\P{Is_VS=/a/--true}'); +Expect(1, 6157, '\p{Is_VS=true}', ""); +Expect(0, 6157, '\p{^Is_VS=true}', ""); +Expect(0, 6157, '\P{Is_VS=true}', ""); +Expect(1, 6157, '\P{^Is_VS=true}', ""); +Expect(0, 6154, '\p{Is_VS=true}', ""); +Expect(1, 6154, '\p{^Is_VS=true}', ""); +Expect(1, 6154, '\P{Is_VS=true}', ""); +Expect(0, 6154, '\P{^Is_VS=true}', ""); +Expect(1, 6157, '\p{Is_VS: true}', ""); +Expect(0, 6157, '\p{^Is_VS: true}', ""); +Expect(0, 6157, '\P{Is_VS: true}', ""); +Expect(1, 6157, '\P{^Is_VS: true}', ""); +Expect(0, 6154, '\p{Is_VS: true}', ""); +Expect(1, 6154, '\p{^Is_VS: true}', ""); +Expect(1, 6154, '\P{Is_VS: true}', ""); +Expect(0, 6154, '\P{^Is_VS: true}', ""); +Error('\p{Variation_Selector= No/a/}'); +Error('\P{Variation_Selector= No/a/}'); +Expect(1, 6154, '\p{Variation_Selector=no}', ""); +Expect(0, 6154, '\p{^Variation_Selector=no}', ""); +Expect(0, 6154, '\P{Variation_Selector=no}', ""); +Expect(1, 6154, '\P{^Variation_Selector=no}', ""); +Expect(0, 6157, '\p{Variation_Selector=no}', ""); +Expect(1, 6157, '\p{^Variation_Selector=no}', ""); +Expect(1, 6157, '\P{Variation_Selector=no}', ""); +Expect(0, 6157, '\P{^Variation_Selector=no}', ""); +Expect(1, 6154, '\p{Variation_Selector=- no}', ""); +Expect(0, 6154, '\p{^Variation_Selector=- no}', ""); +Expect(0, 6154, '\P{Variation_Selector=- no}', ""); +Expect(1, 6154, '\P{^Variation_Selector=- no}', ""); +Expect(0, 6157, '\p{Variation_Selector=- no}', ""); +Expect(1, 6157, '\p{^Variation_Selector=- no}', ""); +Expect(1, 6157, '\P{Variation_Selector=- no}', ""); +Expect(0, 6157, '\P{^Variation_Selector=- no}', ""); +Error('\p{VS=:=N}'); +Error('\P{VS=:=N}'); +Expect(1, 6154, '\p{VS=n}', ""); +Expect(0, 6154, '\p{^VS=n}', ""); +Expect(0, 6154, '\P{VS=n}', ""); +Expect(1, 6154, '\P{^VS=n}', ""); +Expect(0, 6157, '\p{VS=n}', ""); +Expect(1, 6157, '\p{^VS=n}', ""); +Expect(1, 6157, '\P{VS=n}', ""); +Expect(0, 6157, '\P{^VS=n}', ""); +Expect(1, 6154, '\p{VS=__N}', ""); +Expect(0, 6154, '\p{^VS=__N}', ""); +Expect(0, 6154, '\P{VS=__N}', ""); +Expect(1, 6154, '\P{^VS=__N}', ""); +Expect(0, 6157, '\p{VS=__N}', ""); +Expect(1, 6157, '\p{^VS=__N}', ""); +Expect(1, 6157, '\P{VS=__N}', ""); +Expect(0, 6157, '\P{^VS=__N}', ""); +Error('\p{Is_Variation_Selector= F/a/}'); +Error('\P{Is_Variation_Selector= F/a/}'); +Expect(1, 6154, '\p{Is_Variation_Selector:f}', ""); +Expect(0, 6154, '\p{^Is_Variation_Selector:f}', ""); +Expect(0, 6154, '\P{Is_Variation_Selector:f}', ""); +Expect(1, 6154, '\P{^Is_Variation_Selector:f}', ""); +Expect(0, 6157, '\p{Is_Variation_Selector:f}', ""); +Expect(1, 6157, '\p{^Is_Variation_Selector:f}', ""); +Expect(1, 6157, '\P{Is_Variation_Selector:f}', ""); +Expect(0, 6157, '\P{^Is_Variation_Selector:f}', ""); +Expect(1, 6154, '\p{Is_Variation_Selector=_-F}', ""); +Expect(0, 6154, '\p{^Is_Variation_Selector=_-F}', ""); +Expect(0, 6154, '\P{Is_Variation_Selector=_-F}', ""); +Expect(1, 6154, '\P{^Is_Variation_Selector=_-F}', ""); +Expect(0, 6157, '\p{Is_Variation_Selector=_-F}', ""); +Expect(1, 6157, '\p{^Is_Variation_Selector=_-F}', ""); +Expect(1, 6157, '\P{Is_Variation_Selector=_-F}', ""); +Expect(0, 6157, '\P{^Is_Variation_Selector=_-F}', ""); +Error('\p{Is_VS=/a/ False}'); +Error('\P{Is_VS=/a/ False}'); +Expect(1, 6154, '\p{Is_VS=false}', ""); +Expect(0, 6154, '\p{^Is_VS=false}', ""); +Expect(0, 6154, '\P{Is_VS=false}', ""); +Expect(1, 6154, '\P{^Is_VS=false}', ""); +Expect(0, 6157, '\p{Is_VS=false}', ""); +Expect(1, 6157, '\p{^Is_VS=false}', ""); +Expect(1, 6157, '\P{Is_VS=false}', ""); +Expect(0, 6157, '\P{^Is_VS=false}', ""); +Expect(1, 6154, '\p{Is_VS= -FALSE}', ""); +Expect(0, 6154, '\p{^Is_VS= -FALSE}', ""); +Expect(0, 6154, '\P{Is_VS= -FALSE}', ""); +Expect(1, 6154, '\P{^Is_VS= -FALSE}', ""); +Expect(0, 6157, '\p{Is_VS= -FALSE}', ""); +Expect(1, 6157, '\p{^Is_VS= -FALSE}', ""); +Expect(1, 6157, '\P{Is_VS= -FALSE}', ""); +Expect(0, 6157, '\P{^Is_VS= -FALSE}', ""); +Error('\p{Full_Composition_Exclusion=-yes:=}'); +Error('\P{Full_Composition_Exclusion=-yes:=}'); +Expect(1, 833, '\p{Full_Composition_Exclusion=yes}', ""); +Expect(0, 833, '\p{^Full_Composition_Exclusion=yes}', ""); +Expect(0, 833, '\P{Full_Composition_Exclusion=yes}', ""); +Expect(1, 833, '\P{^Full_Composition_Exclusion=yes}', ""); +Expect(0, 831, '\p{Full_Composition_Exclusion=yes}', ""); +Expect(1, 831, '\p{^Full_Composition_Exclusion=yes}', ""); +Expect(1, 831, '\P{Full_Composition_Exclusion=yes}', ""); +Expect(0, 831, '\P{^Full_Composition_Exclusion=yes}', ""); +Expect(1, 833, '\p{Full_Composition_Exclusion= YES}', ""); +Expect(0, 833, '\p{^Full_Composition_Exclusion= YES}', ""); +Expect(0, 833, '\P{Full_Composition_Exclusion= YES}', ""); +Expect(1, 833, '\P{^Full_Composition_Exclusion= YES}', ""); +Expect(0, 831, '\p{Full_Composition_Exclusion= YES}', ""); +Expect(1, 831, '\p{^Full_Composition_Exclusion= YES}', ""); +Expect(1, 831, '\P{Full_Composition_Exclusion= YES}', ""); +Expect(0, 831, '\P{^Full_Composition_Exclusion= YES}', ""); +Error('\p{Comp_Ex=/a/ -Y}'); +Error('\P{Comp_Ex=/a/ -Y}'); +Expect(1, 833, '\p{Comp_Ex=y}', ""); +Expect(0, 833, '\p{^Comp_Ex=y}', ""); +Expect(0, 833, '\P{Comp_Ex=y}', ""); +Expect(1, 833, '\P{^Comp_Ex=y}', ""); +Expect(0, 831, '\p{Comp_Ex=y}', ""); +Expect(1, 831, '\p{^Comp_Ex=y}', ""); +Expect(1, 831, '\P{Comp_Ex=y}', ""); +Expect(0, 831, '\P{^Comp_Ex=y}', ""); +Expect(1, 833, '\p{Comp_Ex=-y}', ""); +Expect(0, 833, '\p{^Comp_Ex=-y}', ""); +Expect(0, 833, '\P{Comp_Ex=-y}', ""); +Expect(1, 833, '\P{^Comp_Ex=-y}', ""); +Expect(0, 831, '\p{Comp_Ex=-y}', ""); +Expect(1, 831, '\p{^Comp_Ex=-y}', ""); +Expect(1, 831, '\P{Comp_Ex=-y}', ""); +Expect(0, 831, '\P{^Comp_Ex=-y}', ""); +Error('\p{Is_Full_Composition_Exclusion= T:=}'); +Error('\P{Is_Full_Composition_Exclusion= T:=}'); +Expect(1, 833, '\p{Is_Full_Composition_Exclusion=t}', ""); +Expect(0, 833, '\p{^Is_Full_Composition_Exclusion=t}', ""); +Expect(0, 833, '\P{Is_Full_Composition_Exclusion=t}', ""); +Expect(1, 833, '\P{^Is_Full_Composition_Exclusion=t}', ""); +Expect(0, 831, '\p{Is_Full_Composition_Exclusion=t}', ""); +Expect(1, 831, '\p{^Is_Full_Composition_Exclusion=t}', ""); +Expect(1, 831, '\P{Is_Full_Composition_Exclusion=t}', ""); +Expect(0, 831, '\P{^Is_Full_Composition_Exclusion=t}', ""); +Expect(1, 833, '\p{Is_Full_Composition_Exclusion= T}', ""); +Expect(0, 833, '\p{^Is_Full_Composition_Exclusion= T}', ""); +Expect(0, 833, '\P{Is_Full_Composition_Exclusion= T}', ""); +Expect(1, 833, '\P{^Is_Full_Composition_Exclusion= T}', ""); +Expect(0, 831, '\p{Is_Full_Composition_Exclusion= T}', ""); +Expect(1, 831, '\p{^Is_Full_Composition_Exclusion= T}', ""); +Expect(1, 831, '\P{Is_Full_Composition_Exclusion= T}', ""); +Expect(0, 831, '\P{^Is_Full_Composition_Exclusion= T}', ""); +Error('\p{Is_Comp_Ex=-True/a/}'); +Error('\P{Is_Comp_Ex=-True/a/}'); +Expect(1, 833, '\p{Is_Comp_Ex=true}', ""); +Expect(0, 833, '\p{^Is_Comp_Ex=true}', ""); +Expect(0, 833, '\P{Is_Comp_Ex=true}', ""); +Expect(1, 833, '\P{^Is_Comp_Ex=true}', ""); +Expect(0, 831, '\p{Is_Comp_Ex=true}', ""); +Expect(1, 831, '\p{^Is_Comp_Ex=true}', ""); +Expect(1, 831, '\P{Is_Comp_Ex=true}', ""); +Expect(0, 831, '\P{^Is_Comp_Ex=true}', ""); +Expect(1, 833, '\p{Is_Comp_Ex=TRUE}', ""); +Expect(0, 833, '\p{^Is_Comp_Ex=TRUE}', ""); +Expect(0, 833, '\P{Is_Comp_Ex=TRUE}', ""); +Expect(1, 833, '\P{^Is_Comp_Ex=TRUE}', ""); +Expect(0, 831, '\p{Is_Comp_Ex=TRUE}', ""); +Expect(1, 831, '\p{^Is_Comp_Ex=TRUE}', ""); +Expect(1, 831, '\P{Is_Comp_Ex=TRUE}', ""); +Expect(0, 831, '\P{^Is_Comp_Ex=TRUE}', ""); +Error('\p{Full_Composition_Exclusion=--No/a/}'); +Error('\P{Full_Composition_Exclusion=--No/a/}'); +Expect(1, 831, '\p{Full_Composition_Exclusion=no}', ""); +Expect(0, 831, '\p{^Full_Composition_Exclusion=no}', ""); +Expect(0, 831, '\P{Full_Composition_Exclusion=no}', ""); +Expect(1, 831, '\P{^Full_Composition_Exclusion=no}', ""); +Expect(0, 833, '\p{Full_Composition_Exclusion=no}', ""); +Expect(1, 833, '\p{^Full_Composition_Exclusion=no}', ""); +Expect(1, 833, '\P{Full_Composition_Exclusion=no}', ""); +Expect(0, 833, '\P{^Full_Composition_Exclusion=no}', ""); +Expect(1, 831, '\p{Full_Composition_Exclusion= _No}', ""); +Expect(0, 831, '\p{^Full_Composition_Exclusion= _No}', ""); +Expect(0, 831, '\P{Full_Composition_Exclusion= _No}', ""); +Expect(1, 831, '\P{^Full_Composition_Exclusion= _No}', ""); +Expect(0, 833, '\p{Full_Composition_Exclusion= _No}', ""); +Expect(1, 833, '\p{^Full_Composition_Exclusion= _No}', ""); +Expect(1, 833, '\P{Full_Composition_Exclusion= _No}', ""); +Expect(0, 833, '\P{^Full_Composition_Exclusion= _No}', ""); +Error('\p{Comp_Ex=:= _N}'); +Error('\P{Comp_Ex=:= _N}'); +Expect(1, 831, '\p{Comp_Ex=n}', ""); +Expect(0, 831, '\p{^Comp_Ex=n}', ""); +Expect(0, 831, '\P{Comp_Ex=n}', ""); +Expect(1, 831, '\P{^Comp_Ex=n}', ""); +Expect(0, 833, '\p{Comp_Ex=n}', ""); +Expect(1, 833, '\p{^Comp_Ex=n}', ""); +Expect(1, 833, '\P{Comp_Ex=n}', ""); +Expect(0, 833, '\P{^Comp_Ex=n}', ""); +Expect(1, 831, '\p{Comp_Ex=_N}', ""); +Expect(0, 831, '\p{^Comp_Ex=_N}', ""); +Expect(0, 831, '\P{Comp_Ex=_N}', ""); +Expect(1, 831, '\P{^Comp_Ex=_N}', ""); +Expect(0, 833, '\p{Comp_Ex=_N}', ""); +Expect(1, 833, '\p{^Comp_Ex=_N}', ""); +Expect(1, 833, '\P{Comp_Ex=_N}', ""); +Expect(0, 833, '\P{^Comp_Ex=_N}', ""); +Error('\p{Is_Full_Composition_Exclusion= -F/a/}'); +Error('\P{Is_Full_Composition_Exclusion= -F/a/}'); +Expect(1, 831, '\p{Is_Full_Composition_Exclusion=f}', ""); +Expect(0, 831, '\p{^Is_Full_Composition_Exclusion=f}', ""); +Expect(0, 831, '\P{Is_Full_Composition_Exclusion=f}', ""); +Expect(1, 831, '\P{^Is_Full_Composition_Exclusion=f}', ""); +Expect(0, 833, '\p{Is_Full_Composition_Exclusion=f}', ""); +Expect(1, 833, '\p{^Is_Full_Composition_Exclusion=f}', ""); +Expect(1, 833, '\P{Is_Full_Composition_Exclusion=f}', ""); +Expect(0, 833, '\P{^Is_Full_Composition_Exclusion=f}', ""); +Expect(1, 831, '\p{Is_Full_Composition_Exclusion= -F}', ""); +Expect(0, 831, '\p{^Is_Full_Composition_Exclusion= -F}', ""); +Expect(0, 831, '\P{Is_Full_Composition_Exclusion= -F}', ""); +Expect(1, 831, '\P{^Is_Full_Composition_Exclusion= -F}', ""); +Expect(0, 833, '\p{Is_Full_Composition_Exclusion= -F}', ""); +Expect(1, 833, '\p{^Is_Full_Composition_Exclusion= -F}', ""); +Expect(1, 833, '\P{Is_Full_Composition_Exclusion= -F}', ""); +Expect(0, 833, '\P{^Is_Full_Composition_Exclusion= -F}', ""); +Error('\p{Is_Comp_Ex= FALSE/a/}'); +Error('\P{Is_Comp_Ex= FALSE/a/}'); +Expect(1, 831, '\p{Is_Comp_Ex=false}', ""); +Expect(0, 831, '\p{^Is_Comp_Ex=false}', ""); +Expect(0, 831, '\P{Is_Comp_Ex=false}', ""); +Expect(1, 831, '\P{^Is_Comp_Ex=false}', ""); +Expect(0, 833, '\p{Is_Comp_Ex=false}', ""); +Expect(1, 833, '\p{^Is_Comp_Ex=false}', ""); +Expect(1, 833, '\P{Is_Comp_Ex=false}', ""); +Expect(0, 833, '\P{^Is_Comp_Ex=false}', ""); +Expect(1, 831, '\p{Is_Comp_Ex= false}', ""); +Expect(0, 831, '\p{^Is_Comp_Ex= false}', ""); +Expect(0, 831, '\P{Is_Comp_Ex= false}', ""); +Expect(1, 831, '\P{^Is_Comp_Ex= false}', ""); +Expect(0, 833, '\p{Is_Comp_Ex= false}', ""); +Expect(1, 833, '\p{^Is_Comp_Ex= false}', ""); +Expect(1, 833, '\P{Is_Comp_Ex= false}', ""); +Expect(0, 833, '\P{^Is_Comp_Ex= false}', ""); +Error('\p{NFKC_Quick_Check= Yes:=}'); +Error('\P{NFKC_Quick_Check= Yes:=}'); +Expect(1, 7, '\p{NFKC_Quick_Check=yes}', ""); +Expect(0, 7, '\p{^NFKC_Quick_Check=yes}', ""); +Expect(0, 7, '\P{NFKC_Quick_Check=yes}', ""); +Expect(1, 7, '\P{^NFKC_Quick_Check=yes}', ""); +Expect(0, 307, '\p{NFKC_Quick_Check=yes}', ""); +Expect(1, 307, '\p{^NFKC_Quick_Check=yes}', ""); +Expect(1, 307, '\P{NFKC_Quick_Check=yes}', ""); +Expect(0, 307, '\P{^NFKC_Quick_Check=yes}', ""); +Expect(1, 7, '\p{NFKC_Quick_Check=Yes}', ""); +Expect(0, 7, '\p{^NFKC_Quick_Check=Yes}', ""); +Expect(0, 7, '\P{NFKC_Quick_Check=Yes}', ""); +Expect(1, 7, '\P{^NFKC_Quick_Check=Yes}', ""); +Expect(0, 307, '\p{NFKC_Quick_Check=Yes}', ""); +Expect(1, 307, '\p{^NFKC_Quick_Check=Yes}', ""); +Expect(1, 307, '\P{NFKC_Quick_Check=Yes}', ""); +Expect(0, 307, '\P{^NFKC_Quick_Check=Yes}', ""); +Error('\p{NFKC_QC= :=Y}'); +Error('\P{NFKC_QC= :=Y}'); +Expect(1, 7, '\p{NFKC_QC=y}', ""); +Expect(0, 7, '\p{^NFKC_QC=y}', ""); +Expect(0, 7, '\P{NFKC_QC=y}', ""); +Expect(1, 7, '\P{^NFKC_QC=y}', ""); +Expect(0, 307, '\p{NFKC_QC=y}', ""); +Expect(1, 307, '\p{^NFKC_QC=y}', ""); +Expect(1, 307, '\P{NFKC_QC=y}', ""); +Expect(0, 307, '\P{^NFKC_QC=y}', ""); +Expect(1, 7, '\p{NFKC_QC= Y}', ""); +Expect(0, 7, '\p{^NFKC_QC= Y}', ""); +Expect(0, 7, '\P{NFKC_QC= Y}', ""); +Expect(1, 7, '\P{^NFKC_QC= Y}', ""); +Expect(0, 307, '\p{NFKC_QC= Y}', ""); +Expect(1, 307, '\p{^NFKC_QC= Y}', ""); +Expect(1, 307, '\P{NFKC_QC= Y}', ""); +Expect(0, 307, '\P{^NFKC_QC= Y}', ""); +Error('\p{Is_NFKC_Quick_Check=/a/-Yes}'); +Error('\P{Is_NFKC_Quick_Check=/a/-Yes}'); +Expect(1, 7, '\p{Is_NFKC_Quick_Check=yes}', ""); +Expect(0, 7, '\p{^Is_NFKC_Quick_Check=yes}', ""); +Expect(0, 7, '\P{Is_NFKC_Quick_Check=yes}', ""); +Expect(1, 7, '\P{^Is_NFKC_Quick_Check=yes}', ""); +Expect(0, 307, '\p{Is_NFKC_Quick_Check=yes}', ""); +Expect(1, 307, '\p{^Is_NFKC_Quick_Check=yes}', ""); +Expect(1, 307, '\P{Is_NFKC_Quick_Check=yes}', ""); +Expect(0, 307, '\P{^Is_NFKC_Quick_Check=yes}', ""); +Expect(1, 7, '\p{Is_NFKC_Quick_Check= YES}', ""); +Expect(0, 7, '\p{^Is_NFKC_Quick_Check= YES}', ""); +Expect(0, 7, '\P{Is_NFKC_Quick_Check= YES}', ""); +Expect(1, 7, '\P{^Is_NFKC_Quick_Check= YES}', ""); +Expect(0, 307, '\p{Is_NFKC_Quick_Check= YES}', ""); +Expect(1, 307, '\p{^Is_NFKC_Quick_Check= YES}', ""); +Expect(1, 307, '\P{Is_NFKC_Quick_Check= YES}', ""); +Expect(0, 307, '\P{^Is_NFKC_Quick_Check= YES}', ""); +Error('\p{Is_NFKC_QC: _-y/a/}'); +Error('\P{Is_NFKC_QC: _-y/a/}'); +Expect(1, 7, '\p{Is_NFKC_QC=y}', ""); +Expect(0, 7, '\p{^Is_NFKC_QC=y}', ""); +Expect(0, 7, '\P{Is_NFKC_QC=y}', ""); +Expect(1, 7, '\P{^Is_NFKC_QC=y}', ""); +Expect(0, 307, '\p{Is_NFKC_QC=y}', ""); +Expect(1, 307, '\p{^Is_NFKC_QC=y}', ""); +Expect(1, 307, '\P{Is_NFKC_QC=y}', ""); +Expect(0, 307, '\P{^Is_NFKC_QC=y}', ""); +Expect(1, 7, '\p{Is_NFKC_QC= Y}', ""); +Expect(0, 7, '\p{^Is_NFKC_QC= Y}', ""); +Expect(0, 7, '\P{Is_NFKC_QC= Y}', ""); +Expect(1, 7, '\P{^Is_NFKC_QC= Y}', ""); +Expect(0, 307, '\p{Is_NFKC_QC= Y}', ""); +Expect(1, 307, '\p{^Is_NFKC_QC= Y}', ""); +Expect(1, 307, '\P{Is_NFKC_QC= Y}', ""); +Expect(0, 307, '\P{^Is_NFKC_QC= Y}', ""); +Error('\p{NFKC_Quick_Check: /a/ -NO}'); +Error('\P{NFKC_Quick_Check: /a/ -NO}'); +Expect(1, 307, '\p{NFKC_Quick_Check=no}', ""); +Expect(0, 307, '\p{^NFKC_Quick_Check=no}', ""); +Expect(0, 307, '\P{NFKC_Quick_Check=no}', ""); +Expect(1, 307, '\P{^NFKC_Quick_Check=no}', ""); +Expect(0, 7, '\p{NFKC_Quick_Check=no}', ""); +Expect(1, 7, '\p{^NFKC_Quick_Check=no}', ""); +Expect(1, 7, '\P{NFKC_Quick_Check=no}', ""); +Expect(0, 7, '\P{^NFKC_Quick_Check=no}', ""); +Expect(1, 307, '\p{NFKC_Quick_Check= No}', ""); +Expect(0, 307, '\p{^NFKC_Quick_Check= No}', ""); +Expect(0, 307, '\P{NFKC_Quick_Check= No}', ""); +Expect(1, 307, '\P{^NFKC_Quick_Check= No}', ""); +Expect(0, 7, '\p{NFKC_Quick_Check= No}', ""); +Expect(1, 7, '\p{^NFKC_Quick_Check= No}', ""); +Expect(1, 7, '\P{NFKC_Quick_Check= No}', ""); +Expect(0, 7, '\P{^NFKC_Quick_Check= No}', ""); +Error('\p{NFKC_QC=- n:=}'); +Error('\P{NFKC_QC=- n:=}'); +Expect(1, 307, '\p{NFKC_QC=n}', ""); +Expect(0, 307, '\p{^NFKC_QC=n}', ""); +Expect(0, 307, '\P{NFKC_QC=n}', ""); +Expect(1, 307, '\P{^NFKC_QC=n}', ""); +Expect(0, 7, '\p{NFKC_QC=n}', ""); +Expect(1, 7, '\p{^NFKC_QC=n}', ""); +Expect(1, 7, '\P{NFKC_QC=n}', ""); +Expect(0, 7, '\P{^NFKC_QC=n}', ""); +Expect(1, 307, '\p{NFKC_QC= _n}', ""); +Expect(0, 307, '\p{^NFKC_QC= _n}', ""); +Expect(0, 307, '\P{NFKC_QC= _n}', ""); +Expect(1, 307, '\P{^NFKC_QC= _n}', ""); +Expect(0, 7, '\p{NFKC_QC= _n}', ""); +Expect(1, 7, '\p{^NFKC_QC= _n}', ""); +Expect(1, 7, '\P{NFKC_QC= _n}', ""); +Expect(0, 7, '\P{^NFKC_QC= _n}', ""); +Error('\p{Is_NFKC_Quick_Check=_ No/a/}'); +Error('\P{Is_NFKC_Quick_Check=_ No/a/}'); +Expect(1, 307, '\p{Is_NFKC_Quick_Check=no}', ""); +Expect(0, 307, '\p{^Is_NFKC_Quick_Check=no}', ""); +Expect(0, 307, '\P{Is_NFKC_Quick_Check=no}', ""); +Expect(1, 307, '\P{^Is_NFKC_Quick_Check=no}', ""); +Expect(0, 7, '\p{Is_NFKC_Quick_Check=no}', ""); +Expect(1, 7, '\p{^Is_NFKC_Quick_Check=no}', ""); +Expect(1, 7, '\P{Is_NFKC_Quick_Check=no}', ""); +Expect(0, 7, '\P{^Is_NFKC_Quick_Check=no}', ""); +Expect(1, 307, '\p{Is_NFKC_Quick_Check=-no}', ""); +Expect(0, 307, '\p{^Is_NFKC_Quick_Check=-no}', ""); +Expect(0, 307, '\P{Is_NFKC_Quick_Check=-no}', ""); +Expect(1, 307, '\P{^Is_NFKC_Quick_Check=-no}', ""); +Expect(0, 7, '\p{Is_NFKC_Quick_Check=-no}', ""); +Expect(1, 7, '\p{^Is_NFKC_Quick_Check=-no}', ""); +Expect(1, 7, '\P{Is_NFKC_Quick_Check=-no}', ""); +Expect(0, 7, '\P{^Is_NFKC_Quick_Check=-no}', ""); +Error('\p{Is_NFKC_QC= /a/N}'); +Error('\P{Is_NFKC_QC= /a/N}'); +Expect(1, 307, '\p{Is_NFKC_QC=n}', ""); +Expect(0, 307, '\p{^Is_NFKC_QC=n}', ""); +Expect(0, 307, '\P{Is_NFKC_QC=n}', ""); +Expect(1, 307, '\P{^Is_NFKC_QC=n}', ""); +Expect(0, 7, '\p{Is_NFKC_QC=n}', ""); +Expect(1, 7, '\p{^Is_NFKC_QC=n}', ""); +Expect(1, 7, '\P{Is_NFKC_QC=n}', ""); +Expect(0, 7, '\P{^Is_NFKC_QC=n}', ""); +Expect(1, 307, '\p{Is_NFKC_QC: -_N}', ""); +Expect(0, 307, '\p{^Is_NFKC_QC: -_N}', ""); +Expect(0, 307, '\P{Is_NFKC_QC: -_N}', ""); +Expect(1, 307, '\P{^Is_NFKC_QC: -_N}', ""); +Expect(0, 7, '\p{Is_NFKC_QC: -_N}', ""); +Expect(1, 7, '\p{^Is_NFKC_QC: -_N}', ""); +Expect(1, 7, '\P{Is_NFKC_QC: -_N}', ""); +Expect(0, 7, '\P{^Is_NFKC_QC: -_N}', ""); +Error('\p{NFKC_Quick_Check=:=-_MAYBE}'); +Error('\P{NFKC_Quick_Check=:=-_MAYBE}'); +Expect(1, 772, '\p{NFKC_Quick_Check:maybe}', ""); +Expect(0, 772, '\p{^NFKC_Quick_Check:maybe}', ""); +Expect(0, 772, '\P{NFKC_Quick_Check:maybe}', ""); +Expect(1, 772, '\P{^NFKC_Quick_Check:maybe}', ""); +Expect(0, 767, '\p{NFKC_Quick_Check:maybe}', ""); +Expect(1, 767, '\p{^NFKC_Quick_Check:maybe}', ""); +Expect(1, 767, '\P{NFKC_Quick_Check:maybe}', ""); +Expect(0, 767, '\P{^NFKC_Quick_Check:maybe}', ""); +Expect(1, 772, '\p{NFKC_Quick_Check=_ MAYBE}', ""); +Expect(0, 772, '\p{^NFKC_Quick_Check=_ MAYBE}', ""); +Expect(0, 772, '\P{NFKC_Quick_Check=_ MAYBE}', ""); +Expect(1, 772, '\P{^NFKC_Quick_Check=_ MAYBE}', ""); +Expect(0, 767, '\p{NFKC_Quick_Check=_ MAYBE}', ""); +Expect(1, 767, '\p{^NFKC_Quick_Check=_ MAYBE}', ""); +Expect(1, 767, '\P{NFKC_Quick_Check=_ MAYBE}', ""); +Expect(0, 767, '\P{^NFKC_Quick_Check=_ MAYBE}', ""); +Error('\p{NFKC_QC=_/a/M}'); +Error('\P{NFKC_QC=_/a/M}'); +Expect(1, 772, '\p{NFKC_QC=m}', ""); +Expect(0, 772, '\p{^NFKC_QC=m}', ""); +Expect(0, 772, '\P{NFKC_QC=m}', ""); +Expect(1, 772, '\P{^NFKC_QC=m}', ""); +Expect(0, 767, '\p{NFKC_QC=m}', ""); +Expect(1, 767, '\p{^NFKC_QC=m}', ""); +Expect(1, 767, '\P{NFKC_QC=m}', ""); +Expect(0, 767, '\P{^NFKC_QC=m}', ""); +Expect(1, 772, '\p{NFKC_QC=M}', ""); +Expect(0, 772, '\p{^NFKC_QC=M}', ""); +Expect(0, 772, '\P{NFKC_QC=M}', ""); +Expect(1, 772, '\P{^NFKC_QC=M}', ""); +Expect(0, 767, '\p{NFKC_QC=M}', ""); +Expect(1, 767, '\p{^NFKC_QC=M}', ""); +Expect(1, 767, '\P{NFKC_QC=M}', ""); +Expect(0, 767, '\P{^NFKC_QC=M}', ""); +Error('\p{Is_NFKC_Quick_Check=__MAYBE:=}'); +Error('\P{Is_NFKC_Quick_Check=__MAYBE:=}'); +Expect(1, 772, '\p{Is_NFKC_Quick_Check=maybe}', ""); +Expect(0, 772, '\p{^Is_NFKC_Quick_Check=maybe}', ""); +Expect(0, 772, '\P{Is_NFKC_Quick_Check=maybe}', ""); +Expect(1, 772, '\P{^Is_NFKC_Quick_Check=maybe}', ""); +Expect(0, 767, '\p{Is_NFKC_Quick_Check=maybe}', ""); +Expect(1, 767, '\p{^Is_NFKC_Quick_Check=maybe}', ""); +Expect(1, 767, '\P{Is_NFKC_Quick_Check=maybe}', ""); +Expect(0, 767, '\P{^Is_NFKC_Quick_Check=maybe}', ""); +Expect(1, 772, '\p{Is_NFKC_Quick_Check=_-Maybe}', ""); +Expect(0, 772, '\p{^Is_NFKC_Quick_Check=_-Maybe}', ""); +Expect(0, 772, '\P{Is_NFKC_Quick_Check=_-Maybe}', ""); +Expect(1, 772, '\P{^Is_NFKC_Quick_Check=_-Maybe}', ""); +Expect(0, 767, '\p{Is_NFKC_Quick_Check=_-Maybe}', ""); +Expect(1, 767, '\p{^Is_NFKC_Quick_Check=_-Maybe}', ""); +Expect(1, 767, '\P{Is_NFKC_Quick_Check=_-Maybe}', ""); +Expect(0, 767, '\P{^Is_NFKC_Quick_Check=_-Maybe}', ""); +Error('\p{Is_NFKC_QC=--m/a/}'); +Error('\P{Is_NFKC_QC=--m/a/}'); +Expect(1, 772, '\p{Is_NFKC_QC=m}', ""); +Expect(0, 772, '\p{^Is_NFKC_QC=m}', ""); +Expect(0, 772, '\P{Is_NFKC_QC=m}', ""); +Expect(1, 772, '\P{^Is_NFKC_QC=m}', ""); +Expect(0, 767, '\p{Is_NFKC_QC=m}', ""); +Expect(1, 767, '\p{^Is_NFKC_QC=m}', ""); +Expect(1, 767, '\P{Is_NFKC_QC=m}', ""); +Expect(0, 767, '\P{^Is_NFKC_QC=m}', ""); +Expect(1, 772, '\p{Is_NFKC_QC: m}', ""); +Expect(0, 772, '\p{^Is_NFKC_QC: m}', ""); +Expect(0, 772, '\P{Is_NFKC_QC: m}', ""); +Expect(1, 772, '\P{^Is_NFKC_QC: m}', ""); +Expect(0, 767, '\p{Is_NFKC_QC: m}', ""); +Expect(1, 767, '\p{^Is_NFKC_QC: m}', ""); +Expect(1, 767, '\P{Is_NFKC_QC: m}', ""); +Expect(0, 767, '\P{^Is_NFKC_QC: m}', ""); +Error('\p{Jamo_Short_Name=}'); +Error('\P{Jamo_Short_Name=}'); +Error('\p{JSN=}'); +Error('\P{JSN=}'); +Error('\p{Is_Jamo_Short_Name=}'); +Error('\P{Is_Jamo_Short_Name=}'); +Error('\p{Is_JSN:}'); +Error('\P{Is_JSN:}'); +Error('\p{Jamo_Short_Name=S}'); +Error('\P{Jamo_Short_Name=S}'); +Error('\p{JSN=S}'); +Error('\P{JSN=S}'); +Error('\p{Is_Jamo_Short_Name=S}'); +Error('\P{Is_Jamo_Short_Name=S}'); +Error('\p{Is_JSN=S}'); +Error('\P{Is_JSN=S}'); +Error('\p{Jamo_Short_Name=GG}'); +Error('\P{Jamo_Short_Name=GG}'); +Error('\p{JSN=GG}'); +Error('\P{JSN=GG}'); +Error('\p{Is_Jamo_Short_Name=GG}'); +Error('\P{Is_Jamo_Short_Name=GG}'); +Error('\p{Is_JSN=GG}'); +Error('\P{Is_JSN=GG}'); +Error('\p{Jamo_Short_Name=YU}'); +Error('\P{Jamo_Short_Name=YU}'); +Error('\p{JSN=YU}'); +Error('\P{JSN=YU}'); +Error('\p{Is_Jamo_Short_Name=YU}'); +Error('\P{Is_Jamo_Short_Name=YU}'); +Error('\p{Is_JSN=YU}'); +Error('\P{Is_JSN=YU}'); +Error('\p{Jamo_Short_Name=WE}'); +Error('\P{Jamo_Short_Name=WE}'); +Error('\p{JSN=WE}'); +Error('\P{JSN=WE}'); +Error('\p{Is_Jamo_Short_Name=WE}'); +Error('\P{Is_Jamo_Short_Name=WE}'); +Error('\p{Is_JSN=WE}'); +Error('\P{Is_JSN=WE}'); +Error('\p{Jamo_Short_Name=LM}'); +Error('\P{Jamo_Short_Name=LM}'); +Error('\p{JSN: LM}'); +Error('\P{JSN: LM}'); +Error('\p{Is_Jamo_Short_Name=LM}'); +Error('\P{Is_Jamo_Short_Name=LM}'); +Error('\p{Is_JSN=LM}'); +Error('\P{Is_JSN=LM}'); +Error('\p{Jamo_Short_Name=K}'); +Error('\P{Jamo_Short_Name=K}'); +Error('\p{JSN: K}'); +Error('\P{JSN: K}'); +Error('\p{Is_Jamo_Short_Name=K}'); +Error('\P{Is_Jamo_Short_Name=K}'); +Error('\p{Is_JSN=K}'); +Error('\P{Is_JSN=K}'); +Error('\p{Jamo_Short_Name=BB}'); +Error('\P{Jamo_Short_Name=BB}'); +Error('\p{JSN=BB}'); +Error('\P{JSN=BB}'); +Error('\p{Is_Jamo_Short_Name=BB}'); +Error('\P{Is_Jamo_Short_Name=BB}'); +Error('\p{Is_JSN=BB}'); +Error('\P{Is_JSN=BB}'); +Error('\p{Jamo_Short_Name=D}'); +Error('\P{Jamo_Short_Name=D}'); +Error('\p{JSN=D}'); +Error('\P{JSN=D}'); +Error('\p{Is_Jamo_Short_Name=D}'); +Error('\P{Is_Jamo_Short_Name=D}'); +Error('\p{Is_JSN=D}'); +Error('\P{Is_JSN=D}'); +Error('\p{Jamo_Short_Name=E}'); +Error('\P{Jamo_Short_Name=E}'); +Error('\p{JSN=E}'); +Error('\P{JSN=E}'); +Error('\p{Is_Jamo_Short_Name=E}'); +Error('\P{Is_Jamo_Short_Name=E}'); +Error('\p{Is_JSN=E}'); +Error('\P{Is_JSN=E}'); +Error('\p{Jamo_Short_Name=JJ}'); +Error('\P{Jamo_Short_Name=JJ}'); +Error('\p{JSN=JJ}'); +Error('\P{JSN=JJ}'); +Error('\p{Is_Jamo_Short_Name=JJ}'); +Error('\P{Is_Jamo_Short_Name=JJ}'); +Error('\p{Is_JSN=JJ}'); +Error('\P{Is_JSN=JJ}'); +Error('\p{Jamo_Short_Name=G}'); +Error('\P{Jamo_Short_Name=G}'); +Error('\p{JSN=G}'); +Error('\P{JSN=G}'); +Error('\p{Is_Jamo_Short_Name=G}'); +Error('\P{Is_Jamo_Short_Name=G}'); +Error('\p{Is_JSN=G}'); +Error('\P{Is_JSN=G}'); +Error('\p{Jamo_Short_Name=YA}'); +Error('\P{Jamo_Short_Name=YA}'); +Error('\p{JSN:YA}'); +Error('\P{JSN:YA}'); +Error('\p{Is_Jamo_Short_Name=YA}'); +Error('\P{Is_Jamo_Short_Name=YA}'); +Error('\p{Is_JSN: YA}'); +Error('\P{Is_JSN: YA}'); +Error('\p{Jamo_Short_Name: SS}'); +Error('\P{Jamo_Short_Name: SS}'); +Error('\p{JSN=SS}'); +Error('\P{JSN=SS}'); +Error('\p{Is_Jamo_Short_Name=SS}'); +Error('\P{Is_Jamo_Short_Name=SS}'); +Error('\p{Is_JSN=SS}'); +Error('\P{Is_JSN=SS}'); +Error('\p{Jamo_Short_Name=LB}'); +Error('\P{Jamo_Short_Name=LB}'); +Error('\p{JSN=LB}'); +Error('\P{JSN=LB}'); +Error('\p{Is_Jamo_Short_Name=LB}'); +Error('\P{Is_Jamo_Short_Name=LB}'); +Error('\p{Is_JSN=LB}'); +Error('\P{Is_JSN=LB}'); +Error('\p{Jamo_Short_Name=J}'); +Error('\P{Jamo_Short_Name=J}'); +Error('\p{JSN=J}'); +Error('\P{JSN=J}'); +Error('\p{Is_Jamo_Short_Name=J}'); +Error('\P{Is_Jamo_Short_Name=J}'); +Error('\p{Is_JSN=J}'); +Error('\P{Is_JSN=J}'); +Error('\p{Jamo_Short_Name=NH}'); +Error('\P{Jamo_Short_Name=NH}'); +Error('\p{JSN=NH}'); +Error('\P{JSN=NH}'); +Error('\p{Is_Jamo_Short_Name=NH}'); +Error('\P{Is_Jamo_Short_Name=NH}'); +Error('\p{Is_JSN=NH}'); +Error('\P{Is_JSN=NH}'); +Error('\p{Jamo_Short_Name=YEO}'); +Error('\P{Jamo_Short_Name=YEO}'); +Error('\p{JSN=YEO}'); +Error('\P{JSN=YEO}'); +Error('\p{Is_Jamo_Short_Name=YEO}'); +Error('\P{Is_Jamo_Short_Name=YEO}'); +Error('\p{Is_JSN=YEO}'); +Error('\P{Is_JSN=YEO}'); +Error('\p{Jamo_Short_Name=LP}'); +Error('\P{Jamo_Short_Name=LP}'); +Error('\p{JSN=LP}'); +Error('\P{JSN=LP}'); +Error('\p{Is_Jamo_Short_Name: LP}'); +Error('\P{Is_Jamo_Short_Name: LP}'); +Error('\p{Is_JSN=LP}'); +Error('\P{Is_JSN=LP}'); +Error('\p{Jamo_Short_Name=NJ}'); +Error('\P{Jamo_Short_Name=NJ}'); +Error('\p{JSN=NJ}'); +Error('\P{JSN=NJ}'); +Error('\p{Is_Jamo_Short_Name=NJ}'); +Error('\P{Is_Jamo_Short_Name=NJ}'); +Error('\p{Is_JSN: NJ}'); +Error('\P{Is_JSN: NJ}'); +Error('\p{Jamo_Short_Name=B}'); +Error('\P{Jamo_Short_Name=B}'); +Error('\p{JSN=B}'); +Error('\P{JSN=B}'); +Error('\p{Is_Jamo_Short_Name: B}'); +Error('\P{Is_Jamo_Short_Name: B}'); +Error('\p{Is_JSN=B}'); +Error('\P{Is_JSN=B}'); +Error('\p{Jamo_Short_Name=WA}'); +Error('\P{Jamo_Short_Name=WA}'); +Error('\p{JSN=WA}'); +Error('\P{JSN=WA}'); +Error('\p{Is_Jamo_Short_Name=WA}'); +Error('\P{Is_Jamo_Short_Name=WA}'); +Error('\p{Is_JSN=WA}'); +Error('\P{Is_JSN=WA}'); +Error('\p{Jamo_Short_Name=LH}'); +Error('\P{Jamo_Short_Name=LH}'); +Error('\p{JSN=LH}'); +Error('\P{JSN=LH}'); +Error('\p{Is_Jamo_Short_Name=LH}'); +Error('\P{Is_Jamo_Short_Name=LH}'); +Error('\p{Is_JSN: LH}'); +Error('\P{Is_JSN: LH}'); +Error('\p{Jamo_Short_Name=YI}'); +Error('\P{Jamo_Short_Name=YI}'); +Error('\p{JSN=YI}'); +Error('\P{JSN=YI}'); +Error('\p{Is_Jamo_Short_Name=YI}'); +Error('\P{Is_Jamo_Short_Name=YI}'); +Error('\p{Is_JSN=YI}'); +Error('\P{Is_JSN=YI}'); +Error('\p{Jamo_Short_Name=WEO}'); +Error('\P{Jamo_Short_Name=WEO}'); +Error('\p{JSN=WEO}'); +Error('\P{JSN=WEO}'); +Error('\p{Is_Jamo_Short_Name=WEO}'); +Error('\P{Is_Jamo_Short_Name=WEO}'); +Error('\p{Is_JSN=WEO}'); +Error('\P{Is_JSN=WEO}'); +Error('\p{Jamo_Short_Name=LS}'); +Error('\P{Jamo_Short_Name=LS}'); +Error('\p{JSN=LS}'); +Error('\P{JSN=LS}'); +Error('\p{Is_Jamo_Short_Name=LS}'); +Error('\P{Is_Jamo_Short_Name=LS}'); +Error('\p{Is_JSN=LS}'); +Error('\P{Is_JSN=LS}'); +Error('\p{Jamo_Short_Name:BS}'); +Error('\P{Jamo_Short_Name:BS}'); +Error('\p{JSN: BS}'); +Error('\P{JSN: BS}'); +Error('\p{Is_Jamo_Short_Name=BS}'); +Error('\P{Is_Jamo_Short_Name=BS}'); +Error('\p{Is_JSN=BS}'); +Error('\P{Is_JSN=BS}'); +Error('\p{Jamo_Short_Name=YO}'); +Error('\P{Jamo_Short_Name=YO}'); +Error('\p{JSN: YO}'); +Error('\P{JSN: YO}'); +Error('\p{Is_Jamo_Short_Name=YO}'); +Error('\P{Is_Jamo_Short_Name=YO}'); +Error('\p{Is_JSN=YO}'); +Error('\P{Is_JSN=YO}'); +Error('\p{Jamo_Short_Name=OE}'); +Error('\P{Jamo_Short_Name=OE}'); +Error('\p{JSN=OE}'); +Error('\P{JSN=OE}'); +Error('\p{Is_Jamo_Short_Name=OE}'); +Error('\P{Is_Jamo_Short_Name=OE}'); +Error('\p{Is_JSN=OE}'); +Error('\P{Is_JSN=OE}'); +Error('\p{Jamo_Short_Name=M}'); +Error('\P{Jamo_Short_Name=M}'); +Error('\p{JSN=M}'); +Error('\P{JSN=M}'); +Error('\p{Is_Jamo_Short_Name=M}'); +Error('\P{Is_Jamo_Short_Name=M}'); +Error('\p{Is_JSN=M}'); +Error('\P{Is_JSN=M}'); +Error('\p{Jamo_Short_Name=EO}'); +Error('\P{Jamo_Short_Name=EO}'); +Error('\p{JSN=EO}'); +Error('\P{JSN=EO}'); +Error('\p{Is_Jamo_Short_Name: EO}'); +Error('\P{Is_Jamo_Short_Name: EO}'); +Error('\p{Is_JSN: EO}'); +Error('\P{Is_JSN: EO}'); +Error('\p{Jamo_Short_Name=C}'); +Error('\P{Jamo_Short_Name=C}'); +Error('\p{JSN=C}'); +Error('\P{JSN=C}'); +Error('\p{Is_Jamo_Short_Name=C}'); +Error('\P{Is_Jamo_Short_Name=C}'); +Error('\p{Is_JSN=C}'); +Error('\P{Is_JSN=C}'); +Error('\p{Jamo_Short_Name:WI}'); +Error('\P{Jamo_Short_Name:WI}'); +Error('\p{JSN=WI}'); +Error('\P{JSN=WI}'); +Error('\p{Is_Jamo_Short_Name=WI}'); +Error('\P{Is_Jamo_Short_Name=WI}'); +Error('\p{Is_JSN: WI}'); +Error('\P{Is_JSN: WI}'); +Error('\p{Jamo_Short_Name=EU}'); +Error('\P{Jamo_Short_Name=EU}'); +Error('\p{JSN=EU}'); +Error('\P{JSN=EU}'); +Error('\p{Is_Jamo_Short_Name=EU}'); +Error('\P{Is_Jamo_Short_Name=EU}'); +Error('\p{Is_JSN=EU}'); +Error('\P{Is_JSN=EU}'); +Error('\p{Jamo_Short_Name=LG}'); +Error('\P{Jamo_Short_Name=LG}'); +Error('\p{JSN=LG}'); +Error('\P{JSN=LG}'); +Error('\p{Is_Jamo_Short_Name=LG}'); +Error('\P{Is_Jamo_Short_Name=LG}'); +Error('\p{Is_JSN=LG}'); +Error('\P{Is_JSN=LG}'); +Error('\p{Jamo_Short_Name=L}'); +Error('\P{Jamo_Short_Name=L}'); +Error('\p{JSN=L}'); +Error('\P{JSN=L}'); +Error('\p{Is_Jamo_Short_Name=L}'); +Error('\P{Is_Jamo_Short_Name=L}'); +Error('\p{Is_JSN=L}'); +Error('\P{Is_JSN=L}'); +Error('\p{Jamo_Short_Name=P}'); +Error('\P{Jamo_Short_Name=P}'); +Error('\p{JSN=P}'); +Error('\P{JSN=P}'); +Error('\p{Is_Jamo_Short_Name=P}'); +Error('\P{Is_Jamo_Short_Name=P}'); +Error('\p{Is_JSN=P}'); +Error('\P{Is_JSN=P}'); +Error('\p{Jamo_Short_Name=DD}'); +Error('\P{Jamo_Short_Name=DD}'); +Error('\p{JSN=DD}'); +Error('\P{JSN=DD}'); +Error('\p{Is_Jamo_Short_Name: DD}'); +Error('\P{Is_Jamo_Short_Name: DD}'); +Error('\p{Is_JSN=DD}'); +Error('\P{Is_JSN=DD}'); +Error('\p{Jamo_Short_Name=NG}'); +Error('\P{Jamo_Short_Name=NG}'); +Error('\p{JSN=NG}'); +Error('\P{JSN=NG}'); +Error('\p{Is_Jamo_Short_Name=NG}'); +Error('\P{Is_Jamo_Short_Name=NG}'); +Error('\p{Is_JSN=NG}'); +Error('\P{Is_JSN=NG}'); +Error('\p{Jamo_Short_Name=AE}'); +Error('\P{Jamo_Short_Name=AE}'); +Error('\p{JSN=AE}'); +Error('\P{JSN=AE}'); +Error('\p{Is_Jamo_Short_Name: AE}'); +Error('\P{Is_Jamo_Short_Name: AE}'); +Error('\p{Is_JSN=AE}'); +Error('\P{Is_JSN=AE}'); +Error('\p{Jamo_Short_Name=T}'); +Error('\P{Jamo_Short_Name=T}'); +Error('\p{JSN=T}'); +Error('\P{JSN=T}'); +Error('\p{Is_Jamo_Short_Name=T}'); +Error('\P{Is_Jamo_Short_Name=T}'); +Error('\p{Is_JSN=T}'); +Error('\P{Is_JSN=T}'); +Error('\p{Jamo_Short_Name=A}'); +Error('\P{Jamo_Short_Name=A}'); +Error('\p{JSN=A}'); +Error('\P{JSN=A}'); +Error('\p{Is_Jamo_Short_Name=A}'); +Error('\P{Is_Jamo_Short_Name=A}'); +Error('\p{Is_JSN:A}'); +Error('\P{Is_JSN:A}'); +Error('\p{Jamo_Short_Name=N}'); +Error('\P{Jamo_Short_Name=N}'); +Error('\p{JSN=N}'); +Error('\P{JSN=N}'); +Error('\p{Is_Jamo_Short_Name=N}'); +Error('\P{Is_Jamo_Short_Name=N}'); +Error('\p{Is_JSN=N}'); +Error('\P{Is_JSN=N}'); +Error('\p{Jamo_Short_Name=YAE}'); +Error('\P{Jamo_Short_Name=YAE}'); +Error('\p{JSN=YAE}'); +Error('\P{JSN=YAE}'); +Error('\p{Is_Jamo_Short_Name=YAE}'); +Error('\P{Is_Jamo_Short_Name=YAE}'); +Error('\p{Is_JSN=YAE}'); +Error('\P{Is_JSN=YAE}'); +Error('\p{Jamo_Short_Name=U}'); +Error('\P{Jamo_Short_Name=U}'); +Error('\p{JSN=U}'); +Error('\P{JSN=U}'); +Error('\p{Is_Jamo_Short_Name=U}'); +Error('\P{Is_Jamo_Short_Name=U}'); +Error('\p{Is_JSN=U}'); +Error('\P{Is_JSN=U}'); +Error('\p{Jamo_Short_Name=WAE}'); +Error('\P{Jamo_Short_Name=WAE}'); +Error('\p{JSN=WAE}'); +Error('\P{JSN=WAE}'); +Error('\p{Is_Jamo_Short_Name=WAE}'); +Error('\P{Is_Jamo_Short_Name=WAE}'); +Error('\p{Is_JSN=WAE}'); +Error('\P{Is_JSN=WAE}'); +Error('\p{Jamo_Short_Name=GS}'); +Error('\P{Jamo_Short_Name=GS}'); +Error('\p{JSN=GS}'); +Error('\P{JSN=GS}'); +Error('\p{Is_Jamo_Short_Name=GS}'); +Error('\P{Is_Jamo_Short_Name=GS}'); +Error('\p{Is_JSN=GS}'); +Error('\P{Is_JSN=GS}'); +Error('\p{Jamo_Short_Name=H}'); +Error('\P{Jamo_Short_Name=H}'); +Error('\p{JSN: H}'); +Error('\P{JSN: H}'); +Error('\p{Is_Jamo_Short_Name=H}'); +Error('\P{Is_Jamo_Short_Name=H}'); +Error('\p{Is_JSN=H}'); +Error('\P{Is_JSN=H}'); +Error('\p{Jamo_Short_Name: LT}'); +Error('\P{Jamo_Short_Name: LT}'); +Error('\p{JSN=LT}'); +Error('\P{JSN=LT}'); +Error('\p{Is_Jamo_Short_Name=LT}'); +Error('\P{Is_Jamo_Short_Name=LT}'); +Error('\p{Is_JSN=LT}'); +Error('\P{Is_JSN=LT}'); +Error('\p{Jamo_Short_Name: YE}'); +Error('\P{Jamo_Short_Name: YE}'); +Error('\p{JSN=YE}'); +Error('\P{JSN=YE}'); +Error('\p{Is_Jamo_Short_Name: YE}'); +Error('\P{Is_Jamo_Short_Name: YE}'); +Error('\p{Is_JSN=YE}'); +Error('\P{Is_JSN=YE}'); +Error('\p{Jamo_Short_Name=I}'); +Error('\P{Jamo_Short_Name=I}'); +Error('\p{JSN=I}'); +Error('\P{JSN=I}'); +Error('\p{Is_Jamo_Short_Name=I}'); +Error('\P{Is_Jamo_Short_Name=I}'); +Error('\p{Is_JSN=I}'); +Error('\P{Is_JSN=I}'); +Error('\p{Jamo_Short_Name=R}'); +Error('\P{Jamo_Short_Name=R}'); +Error('\p{JSN=R}'); +Error('\P{JSN=R}'); +Error('\p{Is_Jamo_Short_Name=R}'); +Error('\P{Is_Jamo_Short_Name=R}'); +Error('\p{Is_JSN=R}'); +Error('\P{Is_JSN=R}'); +Error('\p{Jamo_Short_Name=O}'); +Error('\P{Jamo_Short_Name=O}'); +Error('\p{JSN=O}'); +Error('\P{JSN=O}'); +Error('\p{Is_Jamo_Short_Name=O}'); +Error('\P{Is_Jamo_Short_Name=O}'); +Error('\p{Is_JSN=O}'); +Error('\P{Is_JSN=O}'); +Error('\p{Age= :=000003.2}'); +Error('\P{Age= :=000003.2}'); +Expect(1, 544, '\p{Age=0000003.2}', ""); +Expect(0, 544, '\p{^Age=0000003.2}', ""); +Expect(0, 544, '\P{Age=0000003.2}', ""); +Expect(1, 544, '\P{^Age=0000003.2}', ""); +Expect(0, 543, '\p{Age=0000003.2}', ""); +Expect(1, 543, '\p{^Age=0000003.2}', ""); +Expect(1, 543, '\P{Age=0000003.2}', ""); +Expect(0, 543, '\P{^Age=0000003.2}', ""); +Error('\p{Is_Age= 00_3.2:=}'); +Error('\P{Is_Age= 00_3.2:=}'); +Expect(1, 544, '\p{Is_Age=0_0_0_03.2}', ""); +Expect(0, 544, '\p{^Is_Age=0_0_0_03.2}', ""); +Expect(0, 544, '\P{Is_Age=0_0_0_03.2}', ""); +Expect(1, 544, '\P{^Is_Age=0_0_0_03.2}', ""); +Expect(0, 543, '\p{Is_Age=0_0_0_03.2}', ""); +Expect(1, 543, '\p{^Is_Age=0_0_0_03.2}', ""); +Expect(1, 543, '\P{Is_Age=0_0_0_03.2}', ""); +Expect(0, 543, '\P{^Is_Age=0_0_0_03.2}', ""); +Error('\p{Age=/a/_ +0_0 0 002.0}'); +Error('\P{Age=/a/_ +0_0 0 002.0}'); +Expect(1, 1441, '\p{Age=+0_0_0_0_0_0_02.0}', ""); +Expect(0, 1441, '\p{^Age=+0_0_0_0_0_0_02.0}', ""); +Expect(0, 1441, '\P{Age=+0_0_0_0_0_0_02.0}', ""); +Expect(1, 1441, '\P{^Age=+0_0_0_0_0_0_02.0}', ""); +Expect(0, 1424, '\p{Age=+0_0_0_0_0_0_02.0}', ""); +Expect(1, 1424, '\p{^Age=+0_0_0_0_0_0_02.0}', ""); +Expect(1, 1424, '\P{Age=+0_0_0_0_0_0_02.0}', ""); +Expect(0, 1424, '\P{^Age=+0_0_0_0_0_0_02.0}', ""); +Error('\p{Is_Age=-:=+000 2.0}'); +Error('\P{Is_Age=-:=+000 2.0}'); +Expect(1, 1441, '\p{Is_Age=2.0}', ""); +Expect(0, 1441, '\p{^Is_Age=2.0}', ""); +Expect(0, 1441, '\P{Is_Age=2.0}', ""); +Expect(1, 1441, '\P{^Is_Age=2.0}', ""); +Expect(0, 1424, '\p{Is_Age=2.0}', ""); +Expect(1, 1424, '\p{^Is_Age=2.0}', ""); +Expect(1, 1424, '\P{Is_Age=2.0}', ""); +Expect(0, 1424, '\P{^Is_Age=2.0}', ""); +Error('\p{Age=/a/- 00000001.1}'); +Error('\P{Age=/a/- 00000001.1}'); +Expect(1, 501, '\p{Age=+001.1}', ""); +Expect(0, 501, '\p{^Age=+001.1}', ""); +Expect(0, 501, '\P{Age=+001.1}', ""); +Expect(1, 501, '\P{^Age=+001.1}', ""); +Expect(0, 505, '\p{Age=+001.1}', ""); +Expect(1, 505, '\p{^Age=+001.1}', ""); +Expect(1, 505, '\P{Age=+001.1}', ""); +Expect(0, 505, '\P{^Age=+001.1}', ""); +Error('\p{Is_Age=/a/ 001.1}'); +Error('\P{Is_Age=/a/ 001.1}'); +Expect(1, 501, '\p{Is_Age:001.1}', ""); +Expect(0, 501, '\p{^Is_Age:001.1}', ""); +Expect(0, 501, '\P{Is_Age:001.1}', ""); +Expect(1, 501, '\P{^Is_Age:001.1}', ""); +Expect(0, 505, '\p{Is_Age:001.1}', ""); +Expect(1, 505, '\p{^Is_Age:001.1}', ""); +Expect(1, 505, '\P{Is_Age:001.1}', ""); +Expect(0, 505, '\P{^Is_Age:001.1}', ""); +Error('\p{Age= +5.0:=}'); +Error('\P{Age= +5.0:=}'); +Expect(1, 591, '\p{Age=00_5.0}', ""); +Expect(0, 591, '\p{^Age=00_5.0}', ""); +Expect(0, 591, '\P{Age=00_5.0}', ""); +Expect(1, 591, '\P{^Age=00_5.0}', ""); +Expect(0, 577, '\p{Age=00_5.0}', ""); +Expect(1, 577, '\p{^Age=00_5.0}', ""); +Expect(1, 577, '\P{Age=00_5.0}', ""); +Expect(0, 577, '\P{^Age=00_5.0}', ""); +Error('\p{Is_Age: := +00005.0}'); +Error('\P{Is_Age: := +00005.0}'); +Expect(1, 591, '\p{Is_Age=0_0_05.0}', ""); +Expect(0, 591, '\p{^Is_Age=0_0_05.0}', ""); +Expect(0, 591, '\P{Is_Age=0_0_05.0}', ""); +Expect(1, 591, '\P{^Is_Age=0_0_05.0}', ""); +Expect(0, 577, '\p{Is_Age=0_0_05.0}', ""); +Expect(1, 577, '\p{^Is_Age=0_0_05.0}', ""); +Expect(1, 577, '\P{Is_Age=0_0_05.0}', ""); +Expect(0, 577, '\P{^Is_Age=0_0_05.0}', ""); +Error('\p{Age=:=_ +00000 3.0}'); +Error('\P{Age=:=_ +00000 3.0}'); +Expect(1, 505, '\p{Age=+0000_3.0}', ""); +Expect(0, 505, '\p{^Age=+0000_3.0}', ""); +Expect(0, 505, '\P{Age=+0000_3.0}', ""); +Expect(1, 505, '\P{^Age=+0000_3.0}', ""); +Expect(0, 501, '\p{Age=+0000_3.0}', ""); +Expect(1, 501, '\p{^Age=+0000_3.0}', ""); +Expect(1, 501, '\P{Age=+0000_3.0}', ""); +Expect(0, 501, '\P{^Age=+0000_3.0}', ""); +Error('\p{Is_Age= /a/+0_0_0 0_0003.0}'); +Error('\P{Is_Age= /a/+0_0_0 0_0003.0}'); +Expect(1, 505, '\p{Is_Age=0_0_0_0_0003.0}', ""); +Expect(0, 505, '\p{^Is_Age=0_0_0_0_0003.0}', ""); +Expect(0, 505, '\P{Is_Age=0_0_0_0_0003.0}', ""); +Expect(1, 505, '\P{^Is_Age=0_0_0_0_0003.0}', ""); +Expect(0, 501, '\p{Is_Age=0_0_0_0_0003.0}', ""); +Expect(1, 501, '\p{^Is_Age=0_0_0_0_0003.0}', ""); +Expect(1, 501, '\P{Is_Age=0_0_0_0_0003.0}', ""); +Expect(0, 501, '\P{^Is_Age=0_0_0_0_0003.0}', ""); +Error('\p{Age= -UNASSIGNED:=}'); +Error('\P{Age= -UNASSIGNED:=}'); +Expect(1, 889, '\p{Age=unassigned}', ""); +Expect(0, 889, '\p{^Age=unassigned}', ""); +Expect(0, 889, '\P{Age=unassigned}', ""); +Expect(1, 889, '\P{^Age=unassigned}', ""); +Expect(0, 887, '\p{Age=unassigned}', ""); +Expect(1, 887, '\p{^Age=unassigned}', ""); +Expect(1, 887, '\P{Age=unassigned}', ""); +Expect(0, 887, '\P{^Age=unassigned}', ""); +Expect(1, 889, '\p{Age= unassigned}', ""); +Expect(0, 889, '\p{^Age= unassigned}', ""); +Expect(0, 889, '\P{Age= unassigned}', ""); +Expect(1, 889, '\P{^Age= unassigned}', ""); +Expect(0, 887, '\p{Age= unassigned}', ""); +Expect(1, 887, '\p{^Age= unassigned}', ""); +Expect(1, 887, '\P{Age= unassigned}', ""); +Expect(0, 887, '\P{^Age= unassigned}', ""); +Error('\p{Is_Age=:= _UNASSIGNED}'); +Error('\P{Is_Age=:= _UNASSIGNED}'); +Expect(1, 889, '\p{Is_Age=unassigned}', ""); +Expect(0, 889, '\p{^Is_Age=unassigned}', ""); +Expect(0, 889, '\P{Is_Age=unassigned}', ""); +Expect(1, 889, '\P{^Is_Age=unassigned}', ""); +Expect(0, 887, '\p{Is_Age=unassigned}', ""); +Expect(1, 887, '\p{^Is_Age=unassigned}', ""); +Expect(1, 887, '\P{Is_Age=unassigned}', ""); +Expect(0, 887, '\P{^Is_Age=unassigned}', ""); +Expect(1, 889, '\p{Is_Age: _Unassigned}', ""); +Expect(0, 889, '\p{^Is_Age: _Unassigned}', ""); +Expect(0, 889, '\P{Is_Age: _Unassigned}', ""); +Expect(1, 889, '\P{^Is_Age: _Unassigned}', ""); +Expect(0, 887, '\p{Is_Age: _Unassigned}', ""); +Expect(1, 887, '\p{^Is_Age: _Unassigned}', ""); +Expect(1, 887, '\P{Is_Age: _Unassigned}', ""); +Expect(0, 887, '\P{^Is_Age: _Unassigned}', ""); +Error('\p{Age= :=00000005.1}'); +Error('\P{Age= :=00000005.1}'); +Expect(1, 883, '\p{Age=0000005.1}', ""); +Expect(0, 883, '\p{^Age=0000005.1}', ""); +Expect(0, 883, '\P{Age=0000005.1}', ""); +Expect(1, 883, '\P{^Age=0000005.1}', ""); +Expect(0, 879, '\p{Age=0000005.1}', ""); +Expect(1, 879, '\p{^Age=0000005.1}', ""); +Expect(1, 879, '\P{Age=0000005.1}', ""); +Expect(0, 879, '\P{^Age=0000005.1}', ""); +Error('\p{Is_Age=_+00:=5.1}'); +Error('\P{Is_Age=_+00:=5.1}'); +Expect(1, 883, '\p{Is_Age=+0_0_0_05.1}', ""); +Expect(0, 883, '\p{^Is_Age=+0_0_0_05.1}', ""); +Expect(0, 883, '\P{Is_Age=+0_0_0_05.1}', ""); +Expect(1, 883, '\P{^Is_Age=+0_0_0_05.1}', ""); +Expect(0, 879, '\p{Is_Age=+0_0_0_05.1}', ""); +Expect(1, 879, '\p{^Is_Age=+0_0_0_05.1}', ""); +Expect(1, 879, '\P{Is_Age=+0_0_0_05.1}', ""); +Expect(0, 879, '\P{^Is_Age=+0_0_0_05.1}', ""); +Error('\p{Age:/a/ 4.0}'); +Error('\P{Age:/a/ 4.0}'); +Expect(1, 545, '\p{Age=+4.0}', ""); +Expect(0, 545, '\p{^Age=+4.0}', ""); +Expect(0, 545, '\P{Age=+4.0}', ""); +Expect(1, 545, '\P{^Age=+4.0}', ""); +Expect(0, 544, '\p{Age=+4.0}', ""); +Expect(1, 544, '\p{^Age=+4.0}', ""); +Expect(1, 544, '\P{Age=+4.0}', ""); +Expect(0, 544, '\P{^Age=+4.0}', ""); +Error('\p{Is_Age= :=0 0 0_0 0004.0}'); +Error('\P{Is_Age= :=0 0 0_0 0004.0}'); +Expect(1, 545, '\p{Is_Age=000000004.0}', ""); +Expect(0, 545, '\p{^Is_Age=000000004.0}', ""); +Expect(0, 545, '\P{Is_Age=000000004.0}', ""); +Expect(1, 545, '\P{^Is_Age=000000004.0}', ""); +Expect(0, 544, '\p{Is_Age=000000004.0}', ""); +Expect(1, 544, '\p{^Is_Age=000000004.0}', ""); +Expect(1, 544, '\P{Is_Age=000000004.0}', ""); +Expect(0, 544, '\P{^Is_Age=000000004.0}', ""); +Error('\p{Age=/a/000000003.1}'); +Error('\P{Age=/a/000000003.1}'); +Expect(1, 1013, '\p{Age=00_00_03.1}', ""); +Expect(0, 1013, '\p{^Age=00_00_03.1}', ""); +Expect(0, 1013, '\P{Age=00_00_03.1}', ""); +Expect(1, 1013, '\P{^Age=00_00_03.1}', ""); +Expect(0, 1011, '\p{Age=00_00_03.1}', ""); +Expect(1, 1011, '\p{^Age=00_00_03.1}', ""); +Expect(1, 1011, '\P{Age=00_00_03.1}', ""); +Expect(0, 1011, '\P{^Age=00_00_03.1}', ""); +Error('\p{Is_Age= 003.1:=}'); +Error('\P{Is_Age= 003.1:=}'); +Expect(1, 1013, '\p{Is_Age=+00_3.1}', ""); +Expect(0, 1013, '\p{^Is_Age=+00_3.1}', ""); +Expect(0, 1013, '\P{Is_Age=+00_3.1}', ""); +Expect(1, 1013, '\P{^Is_Age=+00_3.1}', ""); +Expect(0, 1011, '\p{Is_Age=+00_3.1}', ""); +Expect(1, 1011, '\p{^Is_Age=+00_3.1}', ""); +Expect(1, 1011, '\P{Is_Age=+00_3.1}', ""); +Expect(0, 1011, '\P{^Is_Age=+00_3.1}', ""); +Error('\p{Age: - 0:=2.1}'); +Error('\P{Age: - 0:=2.1}'); +Expect(1, 8364, '\p{Age=+0_0_02.1}', ""); +Expect(0, 8364, '\p{^Age=+0_0_02.1}', ""); +Expect(0, 8364, '\P{Age=+0_0_02.1}', ""); +Expect(1, 8364, '\P{^Age=+0_0_02.1}', ""); +Expect(0, 8363, '\p{Age=+0_0_02.1}', ""); +Expect(1, 8363, '\p{^Age=+0_0_02.1}', ""); +Expect(1, 8363, '\P{Age=+0_0_02.1}', ""); +Expect(0, 8363, '\P{^Age=+0_0_02.1}', ""); +Error('\p{Is_Age=/a/ _00000002.1}'); +Error('\P{Is_Age=/a/ _00000002.1}'); +Expect(1, 8364, '\p{Is_Age=+2.1}', ""); +Expect(0, 8364, '\p{^Is_Age=+2.1}', ""); +Expect(0, 8364, '\P{Is_Age=+2.1}', ""); +Expect(1, 8364, '\P{^Is_Age=+2.1}', ""); +Expect(0, 8363, '\p{Is_Age=+2.1}', ""); +Expect(1, 8363, '\p{^Is_Age=+2.1}', ""); +Expect(1, 8363, '\P{Is_Age=+2.1}', ""); +Expect(0, 8363, '\P{^Is_Age=+2.1}', ""); +Error('\p{Age= :=000000004.1}'); +Error('\P{Age= :=000000004.1}'); +Expect(1, 577, '\p{Age=+0_0_0_0_0_0_0_0_04.1}', ""); +Expect(0, 577, '\p{^Age=+0_0_0_0_0_0_0_0_04.1}', ""); +Expect(0, 577, '\P{Age=+0_0_0_0_0_0_0_0_04.1}', ""); +Expect(1, 577, '\P{^Age=+0_0_0_0_0_0_0_0_04.1}', ""); +Expect(0, 566, '\p{Age=+0_0_0_0_0_0_0_0_04.1}', ""); +Expect(1, 566, '\p{^Age=+0_0_0_0_0_0_0_0_04.1}', ""); +Expect(1, 566, '\P{Age=+0_0_0_0_0_0_0_0_04.1}', ""); +Expect(0, 566, '\P{^Age=+0_0_0_0_0_0_0_0_04.1}', ""); +Error('\p{Is_Age=_:=000-4.1}'); +Error('\P{Is_Age=_:=000-4.1}'); +Expect(1, 577, '\p{Is_Age=+004.1}', ""); +Expect(0, 577, '\p{^Is_Age=+004.1}', ""); +Expect(0, 577, '\P{Is_Age=+004.1}', ""); +Expect(1, 577, '\P{^Is_Age=+004.1}', ""); +Expect(0, 566, '\p{Is_Age=+004.1}', ""); +Expect(1, 566, '\p{^Is_Age=+004.1}', ""); +Expect(1, 566, '\P{Is_Age=+004.1}', ""); +Expect(0, 566, '\P{^Is_Age=+004.1}', ""); +Error('\p{Expands_On_NFKD=Yes}'); +Error('\P{Expands_On_NFKD=Yes}'); +Error('\p{XO_NFKD=Y}'); +Error('\P{XO_NFKD=Y}'); +Error('\p{Is_Expands_On_NFKD=T}'); +Error('\P{Is_Expands_On_NFKD=T}'); +Error('\p{Is_XO_NFKD=True}'); +Error('\P{Is_XO_NFKD=True}'); +Error('\p{Expands_On_NFKD=No}'); +Error('\P{Expands_On_NFKD=No}'); +Error('\p{XO_NFKD=N}'); +Error('\P{XO_NFKD=N}'); +Error('\p{Is_Expands_On_NFKD:F}'); +Error('\P{Is_Expands_On_NFKD:F}'); +Error('\p{Is_XO_NFKD=False}'); +Error('\P{Is_XO_NFKD=False}'); +Error('\p{Grapheme_Cluster_Break=_:=spacingmark}'); +Error('\P{Grapheme_Cluster_Break=_:=spacingmark}'); +Expect(1, 2307, '\p{Grapheme_Cluster_Break:spacingmark}', ""); +Expect(0, 2307, '\p{^Grapheme_Cluster_Break:spacingmark}', ""); +Expect(0, 2307, '\P{Grapheme_Cluster_Break:spacingmark}', ""); +Expect(1, 2307, '\P{^Grapheme_Cluster_Break:spacingmark}', ""); +Expect(0, 2306, '\p{Grapheme_Cluster_Break:spacingmark}', ""); +Expect(1, 2306, '\p{^Grapheme_Cluster_Break:spacingmark}', ""); +Expect(1, 2306, '\P{Grapheme_Cluster_Break:spacingmark}', ""); +Expect(0, 2306, '\P{^Grapheme_Cluster_Break:spacingmark}', ""); +Expect(1, 2307, '\p{Grapheme_Cluster_Break=- SPACINGMARK}', ""); +Expect(0, 2307, '\p{^Grapheme_Cluster_Break=- SPACINGMARK}', ""); +Expect(0, 2307, '\P{Grapheme_Cluster_Break=- SPACINGMARK}', ""); +Expect(1, 2307, '\P{^Grapheme_Cluster_Break=- SPACINGMARK}', ""); +Expect(0, 2306, '\p{Grapheme_Cluster_Break=- SPACINGMARK}', ""); +Expect(1, 2306, '\p{^Grapheme_Cluster_Break=- SPACINGMARK}', ""); +Expect(1, 2306, '\P{Grapheme_Cluster_Break=- SPACINGMARK}', ""); +Expect(0, 2306, '\P{^Grapheme_Cluster_Break=- SPACINGMARK}', ""); +Error('\p{GCB= :=SM}'); +Error('\P{GCB= :=SM}'); +Expect(1, 2307, '\p{GCB=sm}', ""); +Expect(0, 2307, '\p{^GCB=sm}', ""); +Expect(0, 2307, '\P{GCB=sm}', ""); +Expect(1, 2307, '\P{^GCB=sm}', ""); +Expect(0, 2306, '\p{GCB=sm}', ""); +Expect(1, 2306, '\p{^GCB=sm}', ""); +Expect(1, 2306, '\P{GCB=sm}', ""); +Expect(0, 2306, '\P{^GCB=sm}', ""); +Expect(1, 2307, '\p{GCB=-SM}', ""); +Expect(0, 2307, '\p{^GCB=-SM}', ""); +Expect(0, 2307, '\P{GCB=-SM}', ""); +Expect(1, 2307, '\P{^GCB=-SM}', ""); +Expect(0, 2306, '\p{GCB=-SM}', ""); +Expect(1, 2306, '\p{^GCB=-SM}', ""); +Expect(1, 2306, '\P{GCB=-SM}', ""); +Expect(0, 2306, '\P{^GCB=-SM}', ""); +Error('\p{Is_Grapheme_Cluster_Break=:= spacingmark}'); +Error('\P{Is_Grapheme_Cluster_Break=:= spacingmark}'); +Expect(1, 2307, '\p{Is_Grapheme_Cluster_Break=spacingmark}', ""); +Expect(0, 2307, '\p{^Is_Grapheme_Cluster_Break=spacingmark}', ""); +Expect(0, 2307, '\P{Is_Grapheme_Cluster_Break=spacingmark}', ""); +Expect(1, 2307, '\P{^Is_Grapheme_Cluster_Break=spacingmark}', ""); +Expect(0, 2306, '\p{Is_Grapheme_Cluster_Break=spacingmark}', ""); +Expect(1, 2306, '\p{^Is_Grapheme_Cluster_Break=spacingmark}', ""); +Expect(1, 2306, '\P{Is_Grapheme_Cluster_Break=spacingmark}', ""); +Expect(0, 2306, '\P{^Is_Grapheme_Cluster_Break=spacingmark}', ""); +Expect(1, 2307, '\p{Is_Grapheme_Cluster_Break: -SPACINGMARK}', ""); +Expect(0, 2307, '\p{^Is_Grapheme_Cluster_Break: -SPACINGMARK}', ""); +Expect(0, 2307, '\P{Is_Grapheme_Cluster_Break: -SPACINGMARK}', ""); +Expect(1, 2307, '\P{^Is_Grapheme_Cluster_Break: -SPACINGMARK}', ""); +Expect(0, 2306, '\p{Is_Grapheme_Cluster_Break: -SPACINGMARK}', ""); +Expect(1, 2306, '\p{^Is_Grapheme_Cluster_Break: -SPACINGMARK}', ""); +Expect(1, 2306, '\P{Is_Grapheme_Cluster_Break: -SPACINGMARK}', ""); +Expect(0, 2306, '\P{^Is_Grapheme_Cluster_Break: -SPACINGMARK}', ""); +Error('\p{Is_GCB= SM/a/}'); +Error('\P{Is_GCB= SM/a/}'); +Expect(1, 2307, '\p{Is_GCB=sm}', ""); +Expect(0, 2307, '\p{^Is_GCB=sm}', ""); +Expect(0, 2307, '\P{Is_GCB=sm}', ""); +Expect(1, 2307, '\P{^Is_GCB=sm}', ""); +Expect(0, 2306, '\p{Is_GCB=sm}', ""); +Expect(1, 2306, '\p{^Is_GCB=sm}', ""); +Expect(1, 2306, '\P{Is_GCB=sm}', ""); +Expect(0, 2306, '\P{^Is_GCB=sm}', ""); +Expect(1, 2307, '\p{Is_GCB= SM}', ""); +Expect(0, 2307, '\p{^Is_GCB= SM}', ""); +Expect(0, 2307, '\P{Is_GCB= SM}', ""); +Expect(1, 2307, '\P{^Is_GCB= SM}', ""); +Expect(0, 2306, '\p{Is_GCB= SM}', ""); +Expect(1, 2306, '\p{^Is_GCB= SM}', ""); +Expect(1, 2306, '\P{Is_GCB= SM}', ""); +Expect(0, 2306, '\P{^Is_GCB= SM}', ""); +Error('\p{Grapheme_Cluster_Break=- T/a/}'); +Error('\P{Grapheme_Cluster_Break=- T/a/}'); +Expect(1, 4601, '\p{Grapheme_Cluster_Break=t}', ""); +Expect(0, 4601, '\p{^Grapheme_Cluster_Break=t}', ""); +Expect(0, 4601, '\P{Grapheme_Cluster_Break=t}', ""); +Expect(1, 4601, '\P{^Grapheme_Cluster_Break=t}', ""); +Expect(0, 4519, '\p{Grapheme_Cluster_Break=t}', ""); +Expect(1, 4519, '\p{^Grapheme_Cluster_Break=t}', ""); +Expect(1, 4519, '\P{Grapheme_Cluster_Break=t}', ""); +Expect(0, 4519, '\P{^Grapheme_Cluster_Break=t}', ""); +Expect(1, 4601, '\p{Grapheme_Cluster_Break= T}', ""); +Expect(0, 4601, '\p{^Grapheme_Cluster_Break= T}', ""); +Expect(0, 4601, '\P{Grapheme_Cluster_Break= T}', ""); +Expect(1, 4601, '\P{^Grapheme_Cluster_Break= T}', ""); +Expect(0, 4519, '\p{Grapheme_Cluster_Break= T}', ""); +Expect(1, 4519, '\p{^Grapheme_Cluster_Break= T}', ""); +Expect(1, 4519, '\P{Grapheme_Cluster_Break= T}', ""); +Expect(0, 4519, '\P{^Grapheme_Cluster_Break= T}', ""); +Error('\p{GCB=/a/_t}'); +Error('\P{GCB=/a/_t}'); +Expect(1, 4601, '\p{GCB: t}', ""); +Expect(0, 4601, '\p{^GCB: t}', ""); +Expect(0, 4601, '\P{GCB: t}', ""); +Expect(1, 4601, '\P{^GCB: t}', ""); +Expect(0, 4519, '\p{GCB: t}', ""); +Expect(1, 4519, '\p{^GCB: t}', ""); +Expect(1, 4519, '\P{GCB: t}', ""); +Expect(0, 4519, '\P{^GCB: t}', ""); +Expect(1, 4601, '\p{GCB= -T}', ""); +Expect(0, 4601, '\p{^GCB= -T}', ""); +Expect(0, 4601, '\P{GCB= -T}', ""); +Expect(1, 4601, '\P{^GCB= -T}', ""); +Expect(0, 4519, '\p{GCB= -T}', ""); +Expect(1, 4519, '\p{^GCB= -T}', ""); +Expect(1, 4519, '\P{GCB= -T}', ""); +Expect(0, 4519, '\P{^GCB= -T}', ""); +Error('\p{Is_Grapheme_Cluster_Break= t/a/}'); +Error('\P{Is_Grapheme_Cluster_Break= t/a/}'); +Expect(1, 4601, '\p{Is_Grapheme_Cluster_Break=t}', ""); +Expect(0, 4601, '\p{^Is_Grapheme_Cluster_Break=t}', ""); +Expect(0, 4601, '\P{Is_Grapheme_Cluster_Break=t}', ""); +Expect(1, 4601, '\P{^Is_Grapheme_Cluster_Break=t}', ""); +Expect(0, 4519, '\p{Is_Grapheme_Cluster_Break=t}', ""); +Expect(1, 4519, '\p{^Is_Grapheme_Cluster_Break=t}', ""); +Expect(1, 4519, '\P{Is_Grapheme_Cluster_Break=t}', ""); +Expect(0, 4519, '\P{^Is_Grapheme_Cluster_Break=t}', ""); +Expect(1, 4601, '\p{Is_Grapheme_Cluster_Break= T}', ""); +Expect(0, 4601, '\p{^Is_Grapheme_Cluster_Break= T}', ""); +Expect(0, 4601, '\P{Is_Grapheme_Cluster_Break= T}', ""); +Expect(1, 4601, '\P{^Is_Grapheme_Cluster_Break= T}', ""); +Expect(0, 4519, '\p{Is_Grapheme_Cluster_Break= T}', ""); +Expect(1, 4519, '\p{^Is_Grapheme_Cluster_Break= T}', ""); +Expect(1, 4519, '\P{Is_Grapheme_Cluster_Break= T}', ""); +Expect(0, 4519, '\P{^Is_Grapheme_Cluster_Break= T}', ""); +Error('\p{Is_GCB=:=_-T}'); +Error('\P{Is_GCB=:=_-T}'); +Expect(1, 4601, '\p{Is_GCB=t}', ""); +Expect(0, 4601, '\p{^Is_GCB=t}', ""); +Expect(0, 4601, '\P{Is_GCB=t}', ""); +Expect(1, 4601, '\P{^Is_GCB=t}', ""); +Expect(0, 4519, '\p{Is_GCB=t}', ""); +Expect(1, 4519, '\p{^Is_GCB=t}', ""); +Expect(1, 4519, '\P{Is_GCB=t}', ""); +Expect(0, 4519, '\P{^Is_GCB=t}', ""); +Expect(1, 4601, '\p{Is_GCB: -t}', ""); +Expect(0, 4601, '\p{^Is_GCB: -t}', ""); +Expect(0, 4601, '\P{Is_GCB: -t}', ""); +Expect(1, 4601, '\P{^Is_GCB: -t}', ""); +Expect(0, 4519, '\p{Is_GCB: -t}', ""); +Expect(1, 4519, '\p{^Is_GCB: -t}', ""); +Expect(1, 4519, '\P{Is_GCB: -t}', ""); +Expect(0, 4519, '\P{^Is_GCB: -t}', ""); +Error('\p{Grapheme_Cluster_Break=:= _LVT}'); +Error('\P{Grapheme_Cluster_Break=:= _LVT}'); +Expect(1, 44059, '\p{Grapheme_Cluster_Break=lvt}', ""); +Expect(0, 44059, '\p{^Grapheme_Cluster_Break=lvt}', ""); +Expect(0, 44059, '\P{Grapheme_Cluster_Break=lvt}', ""); +Expect(1, 44059, '\P{^Grapheme_Cluster_Break=lvt}', ""); +Expect(0, 44032, '\p{Grapheme_Cluster_Break=lvt}', ""); +Expect(1, 44032, '\p{^Grapheme_Cluster_Break=lvt}', ""); +Expect(1, 44032, '\P{Grapheme_Cluster_Break=lvt}', ""); +Expect(0, 44032, '\P{^Grapheme_Cluster_Break=lvt}', ""); +Expect(1, 44059, '\p{Grapheme_Cluster_Break= LVT}', ""); +Expect(0, 44059, '\p{^Grapheme_Cluster_Break= LVT}', ""); +Expect(0, 44059, '\P{Grapheme_Cluster_Break= LVT}', ""); +Expect(1, 44059, '\P{^Grapheme_Cluster_Break= LVT}', ""); +Expect(0, 44032, '\p{Grapheme_Cluster_Break= LVT}', ""); +Expect(1, 44032, '\p{^Grapheme_Cluster_Break= LVT}', ""); +Expect(1, 44032, '\P{Grapheme_Cluster_Break= LVT}', ""); +Expect(0, 44032, '\P{^Grapheme_Cluster_Break= LVT}', ""); +Error('\p{GCB=_:=LVT}'); +Error('\P{GCB=_:=LVT}'); +Expect(1, 44059, '\p{GCB=lvt}', ""); +Expect(0, 44059, '\p{^GCB=lvt}', ""); +Expect(0, 44059, '\P{GCB=lvt}', ""); +Expect(1, 44059, '\P{^GCB=lvt}', ""); +Expect(0, 44032, '\p{GCB=lvt}', ""); +Expect(1, 44032, '\p{^GCB=lvt}', ""); +Expect(1, 44032, '\P{GCB=lvt}', ""); +Expect(0, 44032, '\P{^GCB=lvt}', ""); +Expect(1, 44059, '\p{GCB= -LVT}', ""); +Expect(0, 44059, '\p{^GCB= -LVT}', ""); +Expect(0, 44059, '\P{GCB= -LVT}', ""); +Expect(1, 44059, '\P{^GCB= -LVT}', ""); +Expect(0, 44032, '\p{GCB= -LVT}', ""); +Expect(1, 44032, '\p{^GCB= -LVT}', ""); +Expect(1, 44032, '\P{GCB= -LVT}', ""); +Expect(0, 44032, '\P{^GCB= -LVT}', ""); +Error('\p{Is_Grapheme_Cluster_Break=/a/_lvt}'); +Error('\P{Is_Grapheme_Cluster_Break=/a/_lvt}'); +Expect(1, 44059, '\p{Is_Grapheme_Cluster_Break=lvt}', ""); +Expect(0, 44059, '\p{^Is_Grapheme_Cluster_Break=lvt}', ""); +Expect(0, 44059, '\P{Is_Grapheme_Cluster_Break=lvt}', ""); +Expect(1, 44059, '\P{^Is_Grapheme_Cluster_Break=lvt}', ""); +Expect(0, 44032, '\p{Is_Grapheme_Cluster_Break=lvt}', ""); +Expect(1, 44032, '\p{^Is_Grapheme_Cluster_Break=lvt}', ""); +Expect(1, 44032, '\P{Is_Grapheme_Cluster_Break=lvt}', ""); +Expect(0, 44032, '\P{^Is_Grapheme_Cluster_Break=lvt}', ""); +Expect(1, 44059, '\p{Is_Grapheme_Cluster_Break: -LVT}', ""); +Expect(0, 44059, '\p{^Is_Grapheme_Cluster_Break: -LVT}', ""); +Expect(0, 44059, '\P{Is_Grapheme_Cluster_Break: -LVT}', ""); +Expect(1, 44059, '\P{^Is_Grapheme_Cluster_Break: -LVT}', ""); +Expect(0, 44032, '\p{Is_Grapheme_Cluster_Break: -LVT}', ""); +Expect(1, 44032, '\p{^Is_Grapheme_Cluster_Break: -LVT}', ""); +Expect(1, 44032, '\P{Is_Grapheme_Cluster_Break: -LVT}', ""); +Expect(0, 44032, '\P{^Is_Grapheme_Cluster_Break: -LVT}', ""); +Error('\p{Is_GCB= -LVT:=}'); +Error('\P{Is_GCB= -LVT:=}'); +Expect(1, 44059, '\p{Is_GCB=lvt}', ""); +Expect(0, 44059, '\p{^Is_GCB=lvt}', ""); +Expect(0, 44059, '\P{Is_GCB=lvt}', ""); +Expect(1, 44059, '\P{^Is_GCB=lvt}', ""); +Expect(0, 44032, '\p{Is_GCB=lvt}', ""); +Expect(1, 44032, '\p{^Is_GCB=lvt}', ""); +Expect(1, 44032, '\P{Is_GCB=lvt}', ""); +Expect(0, 44032, '\P{^Is_GCB=lvt}', ""); +Expect(1, 44059, '\p{Is_GCB=-_LVT}', ""); +Expect(0, 44059, '\p{^Is_GCB=-_LVT}', ""); +Expect(0, 44059, '\P{Is_GCB=-_LVT}', ""); +Expect(1, 44059, '\P{^Is_GCB=-_LVT}', ""); +Expect(0, 44032, '\p{Is_GCB=-_LVT}', ""); +Expect(1, 44032, '\p{^Is_GCB=-_LVT}', ""); +Expect(1, 44032, '\P{Is_GCB=-_LVT}', ""); +Expect(0, 44032, '\P{^Is_GCB=-_LVT}', ""); +Error('\p{Grapheme_Cluster_Break=_ CONTROL/a/}'); +Error('\P{Grapheme_Cluster_Break=_ CONTROL/a/}'); +Expect(1, 9, '\p{Grapheme_Cluster_Break=control}', ""); +Expect(0, 9, '\p{^Grapheme_Cluster_Break=control}', ""); +Expect(0, 9, '\P{Grapheme_Cluster_Break=control}', ""); +Expect(1, 9, '\P{^Grapheme_Cluster_Break=control}', ""); +Expect(0, 10, '\p{Grapheme_Cluster_Break=control}', ""); +Expect(1, 10, '\p{^Grapheme_Cluster_Break=control}', ""); +Expect(1, 10, '\P{Grapheme_Cluster_Break=control}', ""); +Expect(0, 10, '\P{^Grapheme_Cluster_Break=control}', ""); +Expect(1, 9, '\p{Grapheme_Cluster_Break=_-control}', ""); +Expect(0, 9, '\p{^Grapheme_Cluster_Break=_-control}', ""); +Expect(0, 9, '\P{Grapheme_Cluster_Break=_-control}', ""); +Expect(1, 9, '\P{^Grapheme_Cluster_Break=_-control}', ""); +Expect(0, 10, '\p{Grapheme_Cluster_Break=_-control}', ""); +Expect(1, 10, '\p{^Grapheme_Cluster_Break=_-control}', ""); +Expect(1, 10, '\P{Grapheme_Cluster_Break=_-control}', ""); +Expect(0, 10, '\P{^Grapheme_Cluster_Break=_-control}', ""); +Error('\p{GCB=_:=CN}'); +Error('\P{GCB=_:=CN}'); +Expect(1, 9, '\p{GCB=cn}', ""); +Expect(0, 9, '\p{^GCB=cn}', ""); +Expect(0, 9, '\P{GCB=cn}', ""); +Expect(1, 9, '\P{^GCB=cn}', ""); +Expect(0, 10, '\p{GCB=cn}', ""); +Expect(1, 10, '\p{^GCB=cn}', ""); +Expect(1, 10, '\P{GCB=cn}', ""); +Expect(0, 10, '\P{^GCB=cn}', ""); +Expect(1, 9, '\p{GCB: -CN}', ""); +Expect(0, 9, '\p{^GCB: -CN}', ""); +Expect(0, 9, '\P{GCB: -CN}', ""); +Expect(1, 9, '\P{^GCB: -CN}', ""); +Expect(0, 10, '\p{GCB: -CN}', ""); +Expect(1, 10, '\p{^GCB: -CN}', ""); +Expect(1, 10, '\P{GCB: -CN}', ""); +Expect(0, 10, '\P{^GCB: -CN}', ""); +Error('\p{Is_Grapheme_Cluster_Break= :=CONTROL}'); +Error('\P{Is_Grapheme_Cluster_Break= :=CONTROL}'); +Expect(1, 9, '\p{Is_Grapheme_Cluster_Break:control}', ""); +Expect(0, 9, '\p{^Is_Grapheme_Cluster_Break:control}', ""); +Expect(0, 9, '\P{Is_Grapheme_Cluster_Break:control}', ""); +Expect(1, 9, '\P{^Is_Grapheme_Cluster_Break:control}', ""); +Expect(0, 10, '\p{Is_Grapheme_Cluster_Break:control}', ""); +Expect(1, 10, '\p{^Is_Grapheme_Cluster_Break:control}', ""); +Expect(1, 10, '\P{Is_Grapheme_Cluster_Break:control}', ""); +Expect(0, 10, '\P{^Is_Grapheme_Cluster_Break:control}', ""); +Expect(1, 9, '\p{Is_Grapheme_Cluster_Break=_ control}', ""); +Expect(0, 9, '\p{^Is_Grapheme_Cluster_Break=_ control}', ""); +Expect(0, 9, '\P{Is_Grapheme_Cluster_Break=_ control}', ""); +Expect(1, 9, '\P{^Is_Grapheme_Cluster_Break=_ control}', ""); +Expect(0, 10, '\p{Is_Grapheme_Cluster_Break=_ control}', ""); +Expect(1, 10, '\p{^Is_Grapheme_Cluster_Break=_ control}', ""); +Expect(1, 10, '\P{Is_Grapheme_Cluster_Break=_ control}', ""); +Expect(0, 10, '\P{^Is_Grapheme_Cluster_Break=_ control}', ""); +Error('\p{Is_GCB=- CN/a/}'); +Error('\P{Is_GCB=- CN/a/}'); +Expect(1, 9, '\p{Is_GCB=cn}', ""); +Expect(0, 9, '\p{^Is_GCB=cn}', ""); +Expect(0, 9, '\P{Is_GCB=cn}', ""); +Expect(1, 9, '\P{^Is_GCB=cn}', ""); +Expect(0, 10, '\p{Is_GCB=cn}', ""); +Expect(1, 10, '\p{^Is_GCB=cn}', ""); +Expect(1, 10, '\P{Is_GCB=cn}', ""); +Expect(0, 10, '\P{^Is_GCB=cn}', ""); +Expect(1, 9, '\p{Is_GCB= -cn}', ""); +Expect(0, 9, '\p{^Is_GCB= -cn}', ""); +Expect(0, 9, '\P{Is_GCB= -cn}', ""); +Expect(1, 9, '\P{^Is_GCB= -cn}', ""); +Expect(0, 10, '\p{Is_GCB= -cn}', ""); +Expect(1, 10, '\p{^Is_GCB= -cn}', ""); +Expect(1, 10, '\P{Is_GCB= -cn}', ""); +Expect(0, 10, '\P{^Is_GCB= -cn}', ""); +Error('\p{Grapheme_Cluster_Break: :=PREPEND}'); +Error('\P{Grapheme_Cluster_Break: :=PREPEND}'); +Expect(1, 3652, '\p{Grapheme_Cluster_Break=prepend}', ""); +Expect(0, 3652, '\p{^Grapheme_Cluster_Break=prepend}', ""); +Expect(0, 3652, '\P{Grapheme_Cluster_Break=prepend}', ""); +Expect(1, 3652, '\P{^Grapheme_Cluster_Break=prepend}', ""); +Expect(0, 3647, '\p{Grapheme_Cluster_Break=prepend}', ""); +Expect(1, 3647, '\p{^Grapheme_Cluster_Break=prepend}', ""); +Expect(1, 3647, '\P{Grapheme_Cluster_Break=prepend}', ""); +Expect(0, 3647, '\P{^Grapheme_Cluster_Break=prepend}', ""); +Expect(1, 3652, '\p{Grapheme_Cluster_Break=-PREPEND}', ""); +Expect(0, 3652, '\p{^Grapheme_Cluster_Break=-PREPEND}', ""); +Expect(0, 3652, '\P{Grapheme_Cluster_Break=-PREPEND}', ""); +Expect(1, 3652, '\P{^Grapheme_Cluster_Break=-PREPEND}', ""); +Expect(0, 3647, '\p{Grapheme_Cluster_Break=-PREPEND}', ""); +Expect(1, 3647, '\p{^Grapheme_Cluster_Break=-PREPEND}', ""); +Expect(1, 3647, '\P{Grapheme_Cluster_Break=-PREPEND}', ""); +Expect(0, 3647, '\P{^Grapheme_Cluster_Break=-PREPEND}', ""); +Error('\p{GCB= :=PP}'); +Error('\P{GCB= :=PP}'); +Expect(1, 3652, '\p{GCB=pp}', ""); +Expect(0, 3652, '\p{^GCB=pp}', ""); +Expect(0, 3652, '\P{GCB=pp}', ""); +Expect(1, 3652, '\P{^GCB=pp}', ""); +Expect(0, 3647, '\p{GCB=pp}', ""); +Expect(1, 3647, '\p{^GCB=pp}', ""); +Expect(1, 3647, '\P{GCB=pp}', ""); +Expect(0, 3647, '\P{^GCB=pp}', ""); +Expect(1, 3652, '\p{GCB: _ PP}', ""); +Expect(0, 3652, '\p{^GCB: _ PP}', ""); +Expect(0, 3652, '\P{GCB: _ PP}', ""); +Expect(1, 3652, '\P{^GCB: _ PP}', ""); +Expect(0, 3647, '\p{GCB: _ PP}', ""); +Expect(1, 3647, '\p{^GCB: _ PP}', ""); +Expect(1, 3647, '\P{GCB: _ PP}', ""); +Expect(0, 3647, '\P{^GCB: _ PP}', ""); +Error('\p{Is_Grapheme_Cluster_Break= /a/Prepend}'); +Error('\P{Is_Grapheme_Cluster_Break= /a/Prepend}'); +Expect(1, 3652, '\p{Is_Grapheme_Cluster_Break=prepend}', ""); +Expect(0, 3652, '\p{^Is_Grapheme_Cluster_Break=prepend}', ""); +Expect(0, 3652, '\P{Is_Grapheme_Cluster_Break=prepend}', ""); +Expect(1, 3652, '\P{^Is_Grapheme_Cluster_Break=prepend}', ""); +Expect(0, 3647, '\p{Is_Grapheme_Cluster_Break=prepend}', ""); +Expect(1, 3647, '\p{^Is_Grapheme_Cluster_Break=prepend}', ""); +Expect(1, 3647, '\P{Is_Grapheme_Cluster_Break=prepend}', ""); +Expect(0, 3647, '\P{^Is_Grapheme_Cluster_Break=prepend}', ""); +Expect(1, 3652, '\p{Is_Grapheme_Cluster_Break= Prepend}', ""); +Expect(0, 3652, '\p{^Is_Grapheme_Cluster_Break= Prepend}', ""); +Expect(0, 3652, '\P{Is_Grapheme_Cluster_Break= Prepend}', ""); +Expect(1, 3652, '\P{^Is_Grapheme_Cluster_Break= Prepend}', ""); +Expect(0, 3647, '\p{Is_Grapheme_Cluster_Break= Prepend}', ""); +Expect(1, 3647, '\p{^Is_Grapheme_Cluster_Break= Prepend}', ""); +Expect(1, 3647, '\P{Is_Grapheme_Cluster_Break= Prepend}', ""); +Expect(0, 3647, '\P{^Is_Grapheme_Cluster_Break= Prepend}', ""); +Error('\p{Is_GCB=:= -pp}'); +Error('\P{Is_GCB=:= -pp}'); +Expect(1, 3652, '\p{Is_GCB=pp}', ""); +Expect(0, 3652, '\p{^Is_GCB=pp}', ""); +Expect(0, 3652, '\P{Is_GCB=pp}', ""); +Expect(1, 3652, '\P{^Is_GCB=pp}', ""); +Expect(0, 3647, '\p{Is_GCB=pp}', ""); +Expect(1, 3647, '\p{^Is_GCB=pp}', ""); +Expect(1, 3647, '\P{Is_GCB=pp}', ""); +Expect(0, 3647, '\P{^Is_GCB=pp}', ""); +Expect(1, 3652, '\p{Is_GCB= pp}', ""); +Expect(0, 3652, '\p{^Is_GCB= pp}', ""); +Expect(0, 3652, '\P{Is_GCB= pp}', ""); +Expect(1, 3652, '\P{^Is_GCB= pp}', ""); +Expect(0, 3647, '\p{Is_GCB= pp}', ""); +Expect(1, 3647, '\p{^Is_GCB= pp}', ""); +Expect(1, 3647, '\P{Is_GCB= pp}', ""); +Expect(0, 3647, '\P{^Is_GCB= pp}', ""); +Error('\p{Grapheme_Cluster_Break=- lv:=}'); +Error('\P{Grapheme_Cluster_Break=- lv:=}'); +Expect(1, 44032, '\p{Grapheme_Cluster_Break=lv}', ""); +Expect(0, 44032, '\p{^Grapheme_Cluster_Break=lv}', ""); +Expect(0, 44032, '\P{Grapheme_Cluster_Break=lv}', ""); +Expect(1, 44032, '\P{^Grapheme_Cluster_Break=lv}', ""); +Expect(0, 44031, '\p{Grapheme_Cluster_Break=lv}', ""); +Expect(1, 44031, '\p{^Grapheme_Cluster_Break=lv}', ""); +Expect(1, 44031, '\P{Grapheme_Cluster_Break=lv}', ""); +Expect(0, 44031, '\P{^Grapheme_Cluster_Break=lv}', ""); +Expect(1, 44032, '\p{Grapheme_Cluster_Break=-LV}', ""); +Expect(0, 44032, '\p{^Grapheme_Cluster_Break=-LV}', ""); +Expect(0, 44032, '\P{Grapheme_Cluster_Break=-LV}', ""); +Expect(1, 44032, '\P{^Grapheme_Cluster_Break=-LV}', ""); +Expect(0, 44031, '\p{Grapheme_Cluster_Break=-LV}', ""); +Expect(1, 44031, '\p{^Grapheme_Cluster_Break=-LV}', ""); +Expect(1, 44031, '\P{Grapheme_Cluster_Break=-LV}', ""); +Expect(0, 44031, '\P{^Grapheme_Cluster_Break=-LV}', ""); +Error('\p{GCB: LV/a/}'); +Error('\P{GCB: LV/a/}'); +Expect(1, 44032, '\p{GCB=lv}', ""); +Expect(0, 44032, '\p{^GCB=lv}', ""); +Expect(0, 44032, '\P{GCB=lv}', ""); +Expect(1, 44032, '\P{^GCB=lv}', ""); +Expect(0, 44031, '\p{GCB=lv}', ""); +Expect(1, 44031, '\p{^GCB=lv}', ""); +Expect(1, 44031, '\P{GCB=lv}', ""); +Expect(0, 44031, '\P{^GCB=lv}', ""); +Expect(1, 44032, '\p{GCB= LV}', ""); +Expect(0, 44032, '\p{^GCB= LV}', ""); +Expect(0, 44032, '\P{GCB= LV}', ""); +Expect(1, 44032, '\P{^GCB= LV}', ""); +Expect(0, 44031, '\p{GCB= LV}', ""); +Expect(1, 44031, '\p{^GCB= LV}', ""); +Expect(1, 44031, '\P{GCB= LV}', ""); +Expect(0, 44031, '\P{^GCB= LV}', ""); +Error('\p{Is_Grapheme_Cluster_Break=-/a/LV}'); +Error('\P{Is_Grapheme_Cluster_Break=-/a/LV}'); +Expect(1, 44032, '\p{Is_Grapheme_Cluster_Break=lv}', ""); +Expect(0, 44032, '\p{^Is_Grapheme_Cluster_Break=lv}', ""); +Expect(0, 44032, '\P{Is_Grapheme_Cluster_Break=lv}', ""); +Expect(1, 44032, '\P{^Is_Grapheme_Cluster_Break=lv}', ""); +Expect(0, 44031, '\p{Is_Grapheme_Cluster_Break=lv}', ""); +Expect(1, 44031, '\p{^Is_Grapheme_Cluster_Break=lv}', ""); +Expect(1, 44031, '\P{Is_Grapheme_Cluster_Break=lv}', ""); +Expect(0, 44031, '\P{^Is_Grapheme_Cluster_Break=lv}', ""); +Expect(1, 44032, '\p{Is_Grapheme_Cluster_Break=-LV}', ""); +Expect(0, 44032, '\p{^Is_Grapheme_Cluster_Break=-LV}', ""); +Expect(0, 44032, '\P{Is_Grapheme_Cluster_Break=-LV}', ""); +Expect(1, 44032, '\P{^Is_Grapheme_Cluster_Break=-LV}', ""); +Expect(0, 44031, '\p{Is_Grapheme_Cluster_Break=-LV}', ""); +Expect(1, 44031, '\p{^Is_Grapheme_Cluster_Break=-LV}', ""); +Expect(1, 44031, '\P{Is_Grapheme_Cluster_Break=-LV}', ""); +Expect(0, 44031, '\P{^Is_Grapheme_Cluster_Break=-LV}', ""); +Error('\p{Is_GCB=/a/ -LV}'); +Error('\P{Is_GCB=/a/ -LV}'); +Expect(1, 44032, '\p{Is_GCB=lv}', ""); +Expect(0, 44032, '\p{^Is_GCB=lv}', ""); +Expect(0, 44032, '\P{Is_GCB=lv}', ""); +Expect(1, 44032, '\P{^Is_GCB=lv}', ""); +Expect(0, 44031, '\p{Is_GCB=lv}', ""); +Expect(1, 44031, '\p{^Is_GCB=lv}', ""); +Expect(1, 44031, '\P{Is_GCB=lv}', ""); +Expect(0, 44031, '\P{^Is_GCB=lv}', ""); +Expect(1, 44032, '\p{Is_GCB= LV}', ""); +Expect(0, 44032, '\p{^Is_GCB= LV}', ""); +Expect(0, 44032, '\P{Is_GCB= LV}', ""); +Expect(1, 44032, '\P{^Is_GCB= LV}', ""); +Expect(0, 44031, '\p{Is_GCB= LV}', ""); +Expect(1, 44031, '\p{^Is_GCB= LV}', ""); +Expect(1, 44031, '\P{Is_GCB= LV}', ""); +Expect(0, 44031, '\P{^Is_GCB= LV}', ""); +Error('\p{Grapheme_Cluster_Break=:= CR}'); +Error('\P{Grapheme_Cluster_Break=:= CR}'); +Expect(1, 13, '\p{Grapheme_Cluster_Break=cr}', ""); +Expect(0, 13, '\p{^Grapheme_Cluster_Break=cr}', ""); +Expect(0, 13, '\P{Grapheme_Cluster_Break=cr}', ""); +Expect(1, 13, '\P{^Grapheme_Cluster_Break=cr}', ""); +Expect(0, 12, '\p{Grapheme_Cluster_Break=cr}', ""); +Expect(1, 12, '\p{^Grapheme_Cluster_Break=cr}', ""); +Expect(1, 12, '\P{Grapheme_Cluster_Break=cr}', ""); +Expect(0, 12, '\P{^Grapheme_Cluster_Break=cr}', ""); +Expect(1, 13, '\p{Grapheme_Cluster_Break=_ CR}', ""); +Expect(0, 13, '\p{^Grapheme_Cluster_Break=_ CR}', ""); +Expect(0, 13, '\P{Grapheme_Cluster_Break=_ CR}', ""); +Expect(1, 13, '\P{^Grapheme_Cluster_Break=_ CR}', ""); +Expect(0, 12, '\p{Grapheme_Cluster_Break=_ CR}', ""); +Expect(1, 12, '\p{^Grapheme_Cluster_Break=_ CR}', ""); +Expect(1, 12, '\P{Grapheme_Cluster_Break=_ CR}', ""); +Expect(0, 12, '\P{^Grapheme_Cluster_Break=_ CR}', ""); +Error('\p{GCB=/a/ CR}'); +Error('\P{GCB=/a/ CR}'); +Expect(1, 13, '\p{GCB=cr}', ""); +Expect(0, 13, '\p{^GCB=cr}', ""); +Expect(0, 13, '\P{GCB=cr}', ""); +Expect(1, 13, '\P{^GCB=cr}', ""); +Expect(0, 12, '\p{GCB=cr}', ""); +Expect(1, 12, '\p{^GCB=cr}', ""); +Expect(1, 12, '\P{GCB=cr}', ""); +Expect(0, 12, '\P{^GCB=cr}', ""); +Expect(1, 13, '\p{GCB: CR}', ""); +Expect(0, 13, '\p{^GCB: CR}', ""); +Expect(0, 13, '\P{GCB: CR}', ""); +Expect(1, 13, '\P{^GCB: CR}', ""); +Expect(0, 12, '\p{GCB: CR}', ""); +Expect(1, 12, '\p{^GCB: CR}', ""); +Expect(1, 12, '\P{GCB: CR}', ""); +Expect(0, 12, '\P{^GCB: CR}', ""); +Error('\p{Is_Grapheme_Cluster_Break=_cr:=}'); +Error('\P{Is_Grapheme_Cluster_Break=_cr:=}'); +Expect(1, 13, '\p{Is_Grapheme_Cluster_Break=cr}', ""); +Expect(0, 13, '\p{^Is_Grapheme_Cluster_Break=cr}', ""); +Expect(0, 13, '\P{Is_Grapheme_Cluster_Break=cr}', ""); +Expect(1, 13, '\P{^Is_Grapheme_Cluster_Break=cr}', ""); +Expect(0, 12, '\p{Is_Grapheme_Cluster_Break=cr}', ""); +Expect(1, 12, '\p{^Is_Grapheme_Cluster_Break=cr}', ""); +Expect(1, 12, '\P{Is_Grapheme_Cluster_Break=cr}', ""); +Expect(0, 12, '\P{^Is_Grapheme_Cluster_Break=cr}', ""); +Expect(1, 13, '\p{Is_Grapheme_Cluster_Break=_CR}', ""); +Expect(0, 13, '\p{^Is_Grapheme_Cluster_Break=_CR}', ""); +Expect(0, 13, '\P{Is_Grapheme_Cluster_Break=_CR}', ""); +Expect(1, 13, '\P{^Is_Grapheme_Cluster_Break=_CR}', ""); +Expect(0, 12, '\p{Is_Grapheme_Cluster_Break=_CR}', ""); +Expect(1, 12, '\p{^Is_Grapheme_Cluster_Break=_CR}', ""); +Expect(1, 12, '\P{Is_Grapheme_Cluster_Break=_CR}', ""); +Expect(0, 12, '\P{^Is_Grapheme_Cluster_Break=_CR}', ""); +Error('\p{Is_GCB=_ CR/a/}'); +Error('\P{Is_GCB=_ CR/a/}'); +Expect(1, 13, '\p{Is_GCB=cr}', ""); +Expect(0, 13, '\p{^Is_GCB=cr}', ""); +Expect(0, 13, '\P{Is_GCB=cr}', ""); +Expect(1, 13, '\P{^Is_GCB=cr}', ""); +Expect(0, 12, '\p{Is_GCB=cr}', ""); +Expect(1, 12, '\p{^Is_GCB=cr}', ""); +Expect(1, 12, '\P{Is_GCB=cr}', ""); +Expect(0, 12, '\P{^Is_GCB=cr}', ""); +Expect(1, 13, '\p{Is_GCB=_-cr}', ""); +Expect(0, 13, '\p{^Is_GCB=_-cr}', ""); +Expect(0, 13, '\P{Is_GCB=_-cr}', ""); +Expect(1, 13, '\P{^Is_GCB=_-cr}', ""); +Expect(0, 12, '\p{Is_GCB=_-cr}', ""); +Expect(1, 12, '\p{^Is_GCB=_-cr}', ""); +Expect(1, 12, '\P{Is_GCB=_-cr}', ""); +Expect(0, 12, '\P{^Is_GCB=_-cr}', ""); +Error('\p{Grapheme_Cluster_Break=other:=}'); +Error('\P{Grapheme_Cluster_Break=other:=}'); +Expect(1, 126, '\p{Grapheme_Cluster_Break=other}', ""); +Expect(0, 126, '\p{^Grapheme_Cluster_Break=other}', ""); +Expect(0, 126, '\P{Grapheme_Cluster_Break=other}', ""); +Expect(1, 126, '\P{^Grapheme_Cluster_Break=other}', ""); +Expect(0, 7, '\p{Grapheme_Cluster_Break=other}', ""); +Expect(1, 7, '\p{^Grapheme_Cluster_Break=other}', ""); +Expect(1, 7, '\P{Grapheme_Cluster_Break=other}', ""); +Expect(0, 7, '\P{^Grapheme_Cluster_Break=other}', ""); +Expect(1, 126, '\p{Grapheme_Cluster_Break=_-OTHER}', ""); +Expect(0, 126, '\p{^Grapheme_Cluster_Break=_-OTHER}', ""); +Expect(0, 126, '\P{Grapheme_Cluster_Break=_-OTHER}', ""); +Expect(1, 126, '\P{^Grapheme_Cluster_Break=_-OTHER}', ""); +Expect(0, 7, '\p{Grapheme_Cluster_Break=_-OTHER}', ""); +Expect(1, 7, '\p{^Grapheme_Cluster_Break=_-OTHER}', ""); +Expect(1, 7, '\P{Grapheme_Cluster_Break=_-OTHER}', ""); +Expect(0, 7, '\P{^Grapheme_Cluster_Break=_-OTHER}', ""); +Error('\p{GCB=:= -XX}'); +Error('\P{GCB=:= -XX}'); +Expect(1, 126, '\p{GCB=xx}', ""); +Expect(0, 126, '\p{^GCB=xx}', ""); +Expect(0, 126, '\P{GCB=xx}', ""); +Expect(1, 126, '\P{^GCB=xx}', ""); +Expect(0, 7, '\p{GCB=xx}', ""); +Expect(1, 7, '\p{^GCB=xx}', ""); +Expect(1, 7, '\P{GCB=xx}', ""); +Expect(0, 7, '\P{^GCB=xx}', ""); +Expect(1, 126, '\p{GCB= _xx}', ""); +Expect(0, 126, '\p{^GCB= _xx}', ""); +Expect(0, 126, '\P{GCB= _xx}', ""); +Expect(1, 126, '\P{^GCB= _xx}', ""); +Expect(0, 7, '\p{GCB= _xx}', ""); +Expect(1, 7, '\p{^GCB= _xx}', ""); +Expect(1, 7, '\P{GCB= _xx}', ""); +Expect(0, 7, '\P{^GCB= _xx}', ""); +Error('\p{Is_Grapheme_Cluster_Break=_/a/OTHER}'); +Error('\P{Is_Grapheme_Cluster_Break=_/a/OTHER}'); +Expect(1, 126, '\p{Is_Grapheme_Cluster_Break=other}', ""); +Expect(0, 126, '\p{^Is_Grapheme_Cluster_Break=other}', ""); +Expect(0, 126, '\P{Is_Grapheme_Cluster_Break=other}', ""); +Expect(1, 126, '\P{^Is_Grapheme_Cluster_Break=other}', ""); +Expect(0, 7, '\p{Is_Grapheme_Cluster_Break=other}', ""); +Expect(1, 7, '\p{^Is_Grapheme_Cluster_Break=other}', ""); +Expect(1, 7, '\P{Is_Grapheme_Cluster_Break=other}', ""); +Expect(0, 7, '\P{^Is_Grapheme_Cluster_Break=other}', ""); +Expect(1, 126, '\p{Is_Grapheme_Cluster_Break= -other}', ""); +Expect(0, 126, '\p{^Is_Grapheme_Cluster_Break= -other}', ""); +Expect(0, 126, '\P{Is_Grapheme_Cluster_Break= -other}', ""); +Expect(1, 126, '\P{^Is_Grapheme_Cluster_Break= -other}', ""); +Expect(0, 7, '\p{Is_Grapheme_Cluster_Break= -other}', ""); +Expect(1, 7, '\p{^Is_Grapheme_Cluster_Break= -other}', ""); +Expect(1, 7, '\P{Is_Grapheme_Cluster_Break= -other}', ""); +Expect(0, 7, '\P{^Is_Grapheme_Cluster_Break= -other}', ""); +Error('\p{Is_GCB=__XX:=}'); +Error('\P{Is_GCB=__XX:=}'); +Expect(1, 126, '\p{Is_GCB=xx}', ""); +Expect(0, 126, '\p{^Is_GCB=xx}', ""); +Expect(0, 126, '\P{Is_GCB=xx}', ""); +Expect(1, 126, '\P{^Is_GCB=xx}', ""); +Expect(0, 7, '\p{Is_GCB=xx}', ""); +Expect(1, 7, '\p{^Is_GCB=xx}', ""); +Expect(1, 7, '\P{Is_GCB=xx}', ""); +Expect(0, 7, '\P{^Is_GCB=xx}', ""); +Expect(1, 126, '\p{Is_GCB= XX}', ""); +Expect(0, 126, '\p{^Is_GCB= XX}', ""); +Expect(0, 126, '\P{Is_GCB= XX}', ""); +Expect(1, 126, '\P{^Is_GCB= XX}', ""); +Expect(0, 7, '\p{Is_GCB= XX}', ""); +Expect(1, 7, '\p{^Is_GCB= XX}', ""); +Expect(1, 7, '\P{Is_GCB= XX}', ""); +Expect(0, 7, '\P{^Is_GCB= XX}', ""); +Error('\p{Grapheme_Cluster_Break= :=Extend}'); +Error('\P{Grapheme_Cluster_Break= :=Extend}'); +Expect(1, 879, '\p{Grapheme_Cluster_Break=extend}', ""); +Expect(0, 879, '\p{^Grapheme_Cluster_Break=extend}', ""); +Expect(0, 879, '\P{Grapheme_Cluster_Break=extend}', ""); +Expect(1, 879, '\P{^Grapheme_Cluster_Break=extend}', ""); +Expect(0, 767, '\p{Grapheme_Cluster_Break=extend}', ""); +Expect(1, 767, '\p{^Grapheme_Cluster_Break=extend}', ""); +Expect(1, 767, '\P{Grapheme_Cluster_Break=extend}', ""); +Expect(0, 767, '\P{^Grapheme_Cluster_Break=extend}', ""); +Expect(1, 879, '\p{Grapheme_Cluster_Break= extend}', ""); +Expect(0, 879, '\p{^Grapheme_Cluster_Break= extend}', ""); +Expect(0, 879, '\P{Grapheme_Cluster_Break= extend}', ""); +Expect(1, 879, '\P{^Grapheme_Cluster_Break= extend}', ""); +Expect(0, 767, '\p{Grapheme_Cluster_Break= extend}', ""); +Expect(1, 767, '\p{^Grapheme_Cluster_Break= extend}', ""); +Expect(1, 767, '\P{Grapheme_Cluster_Break= extend}', ""); +Expect(0, 767, '\P{^Grapheme_Cluster_Break= extend}', ""); +Error('\p{GCB=/a/__EX}'); +Error('\P{GCB=/a/__EX}'); +Expect(1, 879, '\p{GCB=ex}', ""); +Expect(0, 879, '\p{^GCB=ex}', ""); +Expect(0, 879, '\P{GCB=ex}', ""); +Expect(1, 879, '\P{^GCB=ex}', ""); +Expect(0, 767, '\p{GCB=ex}', ""); +Expect(1, 767, '\p{^GCB=ex}', ""); +Expect(1, 767, '\P{GCB=ex}', ""); +Expect(0, 767, '\P{^GCB=ex}', ""); +Expect(1, 879, '\p{GCB=- EX}', ""); +Expect(0, 879, '\p{^GCB=- EX}', ""); +Expect(0, 879, '\P{GCB=- EX}', ""); +Expect(1, 879, '\P{^GCB=- EX}', ""); +Expect(0, 767, '\p{GCB=- EX}', ""); +Expect(1, 767, '\p{^GCB=- EX}', ""); +Expect(1, 767, '\P{GCB=- EX}', ""); +Expect(0, 767, '\P{^GCB=- EX}', ""); +Error('\p{Is_Grapheme_Cluster_Break=_ Extend/a/}'); +Error('\P{Is_Grapheme_Cluster_Break=_ Extend/a/}'); +Expect(1, 879, '\p{Is_Grapheme_Cluster_Break=extend}', ""); +Expect(0, 879, '\p{^Is_Grapheme_Cluster_Break=extend}', ""); +Expect(0, 879, '\P{Is_Grapheme_Cluster_Break=extend}', ""); +Expect(1, 879, '\P{^Is_Grapheme_Cluster_Break=extend}', ""); +Expect(0, 767, '\p{Is_Grapheme_Cluster_Break=extend}', ""); +Expect(1, 767, '\p{^Is_Grapheme_Cluster_Break=extend}', ""); +Expect(1, 767, '\P{Is_Grapheme_Cluster_Break=extend}', ""); +Expect(0, 767, '\P{^Is_Grapheme_Cluster_Break=extend}', ""); +Expect(1, 879, '\p{Is_Grapheme_Cluster_Break= extend}', ""); +Expect(0, 879, '\p{^Is_Grapheme_Cluster_Break= extend}', ""); +Expect(0, 879, '\P{Is_Grapheme_Cluster_Break= extend}', ""); +Expect(1, 879, '\P{^Is_Grapheme_Cluster_Break= extend}', ""); +Expect(0, 767, '\p{Is_Grapheme_Cluster_Break= extend}', ""); +Expect(1, 767, '\p{^Is_Grapheme_Cluster_Break= extend}', ""); +Expect(1, 767, '\P{Is_Grapheme_Cluster_Break= extend}', ""); +Expect(0, 767, '\P{^Is_Grapheme_Cluster_Break= extend}', ""); +Error('\p{Is_GCB=:=_ EX}'); +Error('\P{Is_GCB=:=_ EX}'); +Expect(1, 879, '\p{Is_GCB=ex}', ""); +Expect(0, 879, '\p{^Is_GCB=ex}', ""); +Expect(0, 879, '\P{Is_GCB=ex}', ""); +Expect(1, 879, '\P{^Is_GCB=ex}', ""); +Expect(0, 767, '\p{Is_GCB=ex}', ""); +Expect(1, 767, '\p{^Is_GCB=ex}', ""); +Expect(1, 767, '\P{Is_GCB=ex}', ""); +Expect(0, 767, '\P{^Is_GCB=ex}', ""); +Expect(1, 879, '\p{Is_GCB= _EX}', ""); +Expect(0, 879, '\p{^Is_GCB= _EX}', ""); +Expect(0, 879, '\P{Is_GCB= _EX}', ""); +Expect(1, 879, '\P{^Is_GCB= _EX}', ""); +Expect(0, 767, '\p{Is_GCB= _EX}', ""); +Expect(1, 767, '\p{^Is_GCB= _EX}', ""); +Expect(1, 767, '\P{Is_GCB= _EX}', ""); +Expect(0, 767, '\P{^Is_GCB= _EX}', ""); +Error('\p{Grapheme_Cluster_Break=--V/a/}'); +Error('\P{Grapheme_Cluster_Break=--V/a/}'); +Expect(1, 4514, '\p{Grapheme_Cluster_Break=v}', ""); +Expect(0, 4514, '\p{^Grapheme_Cluster_Break=v}', ""); +Expect(0, 4514, '\P{Grapheme_Cluster_Break=v}', ""); +Expect(1, 4514, '\P{^Grapheme_Cluster_Break=v}', ""); +Expect(0, 4447, '\p{Grapheme_Cluster_Break=v}', ""); +Expect(1, 4447, '\p{^Grapheme_Cluster_Break=v}', ""); +Expect(1, 4447, '\P{Grapheme_Cluster_Break=v}', ""); +Expect(0, 4447, '\P{^Grapheme_Cluster_Break=v}', ""); +Expect(1, 4514, '\p{Grapheme_Cluster_Break=- v}', ""); +Expect(0, 4514, '\p{^Grapheme_Cluster_Break=- v}', ""); +Expect(0, 4514, '\P{Grapheme_Cluster_Break=- v}', ""); +Expect(1, 4514, '\P{^Grapheme_Cluster_Break=- v}', ""); +Expect(0, 4447, '\p{Grapheme_Cluster_Break=- v}', ""); +Expect(1, 4447, '\p{^Grapheme_Cluster_Break=- v}', ""); +Expect(1, 4447, '\P{Grapheme_Cluster_Break=- v}', ""); +Expect(0, 4447, '\P{^Grapheme_Cluster_Break=- v}', ""); +Error('\p{GCB=_ V:=}'); +Error('\P{GCB=_ V:=}'); +Expect(1, 4514, '\p{GCB=v}', ""); +Expect(0, 4514, '\p{^GCB=v}', ""); +Expect(0, 4514, '\P{GCB=v}', ""); +Expect(1, 4514, '\P{^GCB=v}', ""); +Expect(0, 4447, '\p{GCB=v}', ""); +Expect(1, 4447, '\p{^GCB=v}', ""); +Expect(1, 4447, '\P{GCB=v}', ""); +Expect(0, 4447, '\P{^GCB=v}', ""); +Expect(1, 4514, '\p{GCB=V}', ""); +Expect(0, 4514, '\p{^GCB=V}', ""); +Expect(0, 4514, '\P{GCB=V}', ""); +Expect(1, 4514, '\P{^GCB=V}', ""); +Expect(0, 4447, '\p{GCB=V}', ""); +Expect(1, 4447, '\p{^GCB=V}', ""); +Expect(1, 4447, '\P{GCB=V}', ""); +Expect(0, 4447, '\P{^GCB=V}', ""); +Error('\p{Is_Grapheme_Cluster_Break=/a/ _V}'); +Error('\P{Is_Grapheme_Cluster_Break=/a/ _V}'); +Expect(1, 4514, '\p{Is_Grapheme_Cluster_Break=v}', ""); +Expect(0, 4514, '\p{^Is_Grapheme_Cluster_Break=v}', ""); +Expect(0, 4514, '\P{Is_Grapheme_Cluster_Break=v}', ""); +Expect(1, 4514, '\P{^Is_Grapheme_Cluster_Break=v}', ""); +Expect(0, 4447, '\p{Is_Grapheme_Cluster_Break=v}', ""); +Expect(1, 4447, '\p{^Is_Grapheme_Cluster_Break=v}', ""); +Expect(1, 4447, '\P{Is_Grapheme_Cluster_Break=v}', ""); +Expect(0, 4447, '\P{^Is_Grapheme_Cluster_Break=v}', ""); +Expect(1, 4514, '\p{Is_Grapheme_Cluster_Break= v}', ""); +Expect(0, 4514, '\p{^Is_Grapheme_Cluster_Break= v}', ""); +Expect(0, 4514, '\P{Is_Grapheme_Cluster_Break= v}', ""); +Expect(1, 4514, '\P{^Is_Grapheme_Cluster_Break= v}', ""); +Expect(0, 4447, '\p{Is_Grapheme_Cluster_Break= v}', ""); +Expect(1, 4447, '\p{^Is_Grapheme_Cluster_Break= v}', ""); +Expect(1, 4447, '\P{Is_Grapheme_Cluster_Break= v}', ""); +Expect(0, 4447, '\P{^Is_Grapheme_Cluster_Break= v}', ""); +Error('\p{Is_GCB=:=- V}'); +Error('\P{Is_GCB=:=- V}'); +Expect(1, 4514, '\p{Is_GCB=v}', ""); +Expect(0, 4514, '\p{^Is_GCB=v}', ""); +Expect(0, 4514, '\P{Is_GCB=v}', ""); +Expect(1, 4514, '\P{^Is_GCB=v}', ""); +Expect(0, 4447, '\p{Is_GCB=v}', ""); +Expect(1, 4447, '\p{^Is_GCB=v}', ""); +Expect(1, 4447, '\P{Is_GCB=v}', ""); +Expect(0, 4447, '\P{^Is_GCB=v}', ""); +Expect(1, 4514, '\p{Is_GCB= v}', ""); +Expect(0, 4514, '\p{^Is_GCB= v}', ""); +Expect(0, 4514, '\P{Is_GCB= v}', ""); +Expect(1, 4514, '\P{^Is_GCB= v}', ""); +Expect(0, 4447, '\p{Is_GCB= v}', ""); +Expect(1, 4447, '\p{^Is_GCB= v}', ""); +Expect(1, 4447, '\P{Is_GCB= v}', ""); +Expect(0, 4447, '\P{^Is_GCB= v}', ""); +Error('\p{Grapheme_Cluster_Break=/a/- lf}'); +Error('\P{Grapheme_Cluster_Break=/a/- lf}'); +Expect(1, 10, '\p{Grapheme_Cluster_Break=lf}', ""); +Expect(0, 10, '\p{^Grapheme_Cluster_Break=lf}', ""); +Expect(0, 10, '\P{Grapheme_Cluster_Break=lf}', ""); +Expect(1, 10, '\P{^Grapheme_Cluster_Break=lf}', ""); +Expect(0, 9, '\p{Grapheme_Cluster_Break=lf}', ""); +Expect(1, 9, '\p{^Grapheme_Cluster_Break=lf}', ""); +Expect(1, 9, '\P{Grapheme_Cluster_Break=lf}', ""); +Expect(0, 9, '\P{^Grapheme_Cluster_Break=lf}', ""); +Expect(1, 10, '\p{Grapheme_Cluster_Break=-LF}', ""); +Expect(0, 10, '\p{^Grapheme_Cluster_Break=-LF}', ""); +Expect(0, 10, '\P{Grapheme_Cluster_Break=-LF}', ""); +Expect(1, 10, '\P{^Grapheme_Cluster_Break=-LF}', ""); +Expect(0, 9, '\p{Grapheme_Cluster_Break=-LF}', ""); +Expect(1, 9, '\p{^Grapheme_Cluster_Break=-LF}', ""); +Expect(1, 9, '\P{Grapheme_Cluster_Break=-LF}', ""); +Expect(0, 9, '\P{^Grapheme_Cluster_Break=-LF}', ""); +Error('\p{GCB=_LF:=}'); +Error('\P{GCB=_LF:=}'); +Expect(1, 10, '\p{GCB=lf}', ""); +Expect(0, 10, '\p{^GCB=lf}', ""); +Expect(0, 10, '\P{GCB=lf}', ""); +Expect(1, 10, '\P{^GCB=lf}', ""); +Expect(0, 9, '\p{GCB=lf}', ""); +Expect(1, 9, '\p{^GCB=lf}', ""); +Expect(1, 9, '\P{GCB=lf}', ""); +Expect(0, 9, '\P{^GCB=lf}', ""); +Expect(1, 10, '\p{GCB= LF}', ""); +Expect(0, 10, '\p{^GCB= LF}', ""); +Expect(0, 10, '\P{GCB= LF}', ""); +Expect(1, 10, '\P{^GCB= LF}', ""); +Expect(0, 9, '\p{GCB= LF}', ""); +Expect(1, 9, '\p{^GCB= LF}', ""); +Expect(1, 9, '\P{GCB= LF}', ""); +Expect(0, 9, '\P{^GCB= LF}', ""); +Error('\p{Is_Grapheme_Cluster_Break:_ LF:=}'); +Error('\P{Is_Grapheme_Cluster_Break:_ LF:=}'); +Expect(1, 10, '\p{Is_Grapheme_Cluster_Break=lf}', ""); +Expect(0, 10, '\p{^Is_Grapheme_Cluster_Break=lf}', ""); +Expect(0, 10, '\P{Is_Grapheme_Cluster_Break=lf}', ""); +Expect(1, 10, '\P{^Is_Grapheme_Cluster_Break=lf}', ""); +Expect(0, 9, '\p{Is_Grapheme_Cluster_Break=lf}', ""); +Expect(1, 9, '\p{^Is_Grapheme_Cluster_Break=lf}', ""); +Expect(1, 9, '\P{Is_Grapheme_Cluster_Break=lf}', ""); +Expect(0, 9, '\P{^Is_Grapheme_Cluster_Break=lf}', ""); +Expect(1, 10, '\p{Is_Grapheme_Cluster_Break=LF}', ""); +Expect(0, 10, '\p{^Is_Grapheme_Cluster_Break=LF}', ""); +Expect(0, 10, '\P{Is_Grapheme_Cluster_Break=LF}', ""); +Expect(1, 10, '\P{^Is_Grapheme_Cluster_Break=LF}', ""); +Expect(0, 9, '\p{Is_Grapheme_Cluster_Break=LF}', ""); +Expect(1, 9, '\p{^Is_Grapheme_Cluster_Break=LF}', ""); +Expect(1, 9, '\P{Is_Grapheme_Cluster_Break=LF}', ""); +Expect(0, 9, '\P{^Is_Grapheme_Cluster_Break=LF}', ""); +Error('\p{Is_GCB= LF:=}'); +Error('\P{Is_GCB= LF:=}'); +Expect(1, 10, '\p{Is_GCB=lf}', ""); +Expect(0, 10, '\p{^Is_GCB=lf}', ""); +Expect(0, 10, '\P{Is_GCB=lf}', ""); +Expect(1, 10, '\P{^Is_GCB=lf}', ""); +Expect(0, 9, '\p{Is_GCB=lf}', ""); +Expect(1, 9, '\p{^Is_GCB=lf}', ""); +Expect(1, 9, '\P{Is_GCB=lf}', ""); +Expect(0, 9, '\P{^Is_GCB=lf}', ""); +Expect(1, 10, '\p{Is_GCB=-_LF}', ""); +Expect(0, 10, '\p{^Is_GCB=-_LF}', ""); +Expect(0, 10, '\P{Is_GCB=-_LF}', ""); +Expect(1, 10, '\P{^Is_GCB=-_LF}', ""); +Expect(0, 9, '\p{Is_GCB=-_LF}', ""); +Expect(1, 9, '\p{^Is_GCB=-_LF}', ""); +Expect(1, 9, '\P{Is_GCB=-_LF}', ""); +Expect(0, 9, '\P{^Is_GCB=-_LF}', ""); +Error('\p{Grapheme_Cluster_Break=/a/ l}'); +Error('\P{Grapheme_Cluster_Break=/a/ l}'); +Expect(1, 4441, '\p{Grapheme_Cluster_Break=l}', ""); +Expect(0, 4441, '\p{^Grapheme_Cluster_Break=l}', ""); +Expect(0, 4441, '\P{Grapheme_Cluster_Break=l}', ""); +Expect(1, 4441, '\P{^Grapheme_Cluster_Break=l}', ""); +Expect(0, 4351, '\p{Grapheme_Cluster_Break=l}', ""); +Expect(1, 4351, '\p{^Grapheme_Cluster_Break=l}', ""); +Expect(1, 4351, '\P{Grapheme_Cluster_Break=l}', ""); +Expect(0, 4351, '\P{^Grapheme_Cluster_Break=l}', ""); +Expect(1, 4441, '\p{Grapheme_Cluster_Break=-L}', ""); +Expect(0, 4441, '\p{^Grapheme_Cluster_Break=-L}', ""); +Expect(0, 4441, '\P{Grapheme_Cluster_Break=-L}', ""); +Expect(1, 4441, '\P{^Grapheme_Cluster_Break=-L}', ""); +Expect(0, 4351, '\p{Grapheme_Cluster_Break=-L}', ""); +Expect(1, 4351, '\p{^Grapheme_Cluster_Break=-L}', ""); +Expect(1, 4351, '\P{Grapheme_Cluster_Break=-L}', ""); +Expect(0, 4351, '\P{^Grapheme_Cluster_Break=-L}', ""); +Error('\p{GCB=:=-l}'); +Error('\P{GCB=:=-l}'); +Expect(1, 4441, '\p{GCB=l}', ""); +Expect(0, 4441, '\p{^GCB=l}', ""); +Expect(0, 4441, '\P{GCB=l}', ""); +Expect(1, 4441, '\P{^GCB=l}', ""); +Expect(0, 4351, '\p{GCB=l}', ""); +Expect(1, 4351, '\p{^GCB=l}', ""); +Expect(1, 4351, '\P{GCB=l}', ""); +Expect(0, 4351, '\P{^GCB=l}', ""); +Expect(1, 4441, '\p{GCB: -l}', ""); +Expect(0, 4441, '\p{^GCB: -l}', ""); +Expect(0, 4441, '\P{GCB: -l}', ""); +Expect(1, 4441, '\P{^GCB: -l}', ""); +Expect(0, 4351, '\p{GCB: -l}', ""); +Expect(1, 4351, '\p{^GCB: -l}', ""); +Expect(1, 4351, '\P{GCB: -l}', ""); +Expect(0, 4351, '\P{^GCB: -l}', ""); +Error('\p{Is_Grapheme_Cluster_Break=/a/_ L}'); +Error('\P{Is_Grapheme_Cluster_Break=/a/_ L}'); +Expect(1, 4441, '\p{Is_Grapheme_Cluster_Break=l}', ""); +Expect(0, 4441, '\p{^Is_Grapheme_Cluster_Break=l}', ""); +Expect(0, 4441, '\P{Is_Grapheme_Cluster_Break=l}', ""); +Expect(1, 4441, '\P{^Is_Grapheme_Cluster_Break=l}', ""); +Expect(0, 4351, '\p{Is_Grapheme_Cluster_Break=l}', ""); +Expect(1, 4351, '\p{^Is_Grapheme_Cluster_Break=l}', ""); +Expect(1, 4351, '\P{Is_Grapheme_Cluster_Break=l}', ""); +Expect(0, 4351, '\P{^Is_Grapheme_Cluster_Break=l}', ""); +Expect(1, 4441, '\p{Is_Grapheme_Cluster_Break=-L}', ""); +Expect(0, 4441, '\p{^Is_Grapheme_Cluster_Break=-L}', ""); +Expect(0, 4441, '\P{Is_Grapheme_Cluster_Break=-L}', ""); +Expect(1, 4441, '\P{^Is_Grapheme_Cluster_Break=-L}', ""); +Expect(0, 4351, '\p{Is_Grapheme_Cluster_Break=-L}', ""); +Expect(1, 4351, '\p{^Is_Grapheme_Cluster_Break=-L}', ""); +Expect(1, 4351, '\P{Is_Grapheme_Cluster_Break=-L}', ""); +Expect(0, 4351, '\P{^Is_Grapheme_Cluster_Break=-L}', ""); +Error('\p{Is_GCB=:= _l}'); +Error('\P{Is_GCB=:= _l}'); +Expect(1, 4441, '\p{Is_GCB: l}', ""); +Expect(0, 4441, '\p{^Is_GCB: l}', ""); +Expect(0, 4441, '\P{Is_GCB: l}', ""); +Expect(1, 4441, '\P{^Is_GCB: l}', ""); +Expect(0, 4351, '\p{Is_GCB: l}', ""); +Expect(1, 4351, '\p{^Is_GCB: l}', ""); +Expect(1, 4351, '\P{Is_GCB: l}', ""); +Expect(0, 4351, '\P{^Is_GCB: l}', ""); +Expect(1, 4441, '\p{Is_GCB=--L}', ""); +Expect(0, 4441, '\p{^Is_GCB=--L}', ""); +Expect(0, 4441, '\P{Is_GCB=--L}', ""); +Expect(1, 4441, '\P{^Is_GCB=--L}', ""); +Expect(0, 4351, '\p{Is_GCB=--L}', ""); +Expect(1, 4351, '\p{^Is_GCB=--L}', ""); +Expect(1, 4351, '\P{Is_GCB=--L}', ""); +Expect(0, 4351, '\P{^Is_GCB=--L}', ""); +Error('\p{Logical_Order_Exception=/a/ yes}'); +Error('\P{Logical_Order_Exception=/a/ yes}'); +Expect(1, 3652, '\p{Logical_Order_Exception=yes}', ""); +Expect(0, 3652, '\p{^Logical_Order_Exception=yes}', ""); +Expect(0, 3652, '\P{Logical_Order_Exception=yes}', ""); +Expect(1, 3652, '\P{^Logical_Order_Exception=yes}', ""); +Expect(0, 3647, '\p{Logical_Order_Exception=yes}', ""); +Expect(1, 3647, '\p{^Logical_Order_Exception=yes}', ""); +Expect(1, 3647, '\P{Logical_Order_Exception=yes}', ""); +Expect(0, 3647, '\P{^Logical_Order_Exception=yes}', ""); +Expect(1, 3652, '\p{Logical_Order_Exception= _YES}', ""); +Expect(0, 3652, '\p{^Logical_Order_Exception= _YES}', ""); +Expect(0, 3652, '\P{Logical_Order_Exception= _YES}', ""); +Expect(1, 3652, '\P{^Logical_Order_Exception= _YES}', ""); +Expect(0, 3647, '\p{Logical_Order_Exception= _YES}', ""); +Expect(1, 3647, '\p{^Logical_Order_Exception= _YES}', ""); +Expect(1, 3647, '\P{Logical_Order_Exception= _YES}', ""); +Expect(0, 3647, '\P{^Logical_Order_Exception= _YES}', ""); +Error('\p{LOE=/a/Y}'); +Error('\P{LOE=/a/Y}'); +Expect(1, 3652, '\p{LOE=y}', ""); +Expect(0, 3652, '\p{^LOE=y}', ""); +Expect(0, 3652, '\P{LOE=y}', ""); +Expect(1, 3652, '\P{^LOE=y}', ""); +Expect(0, 3647, '\p{LOE=y}', ""); +Expect(1, 3647, '\p{^LOE=y}', ""); +Expect(1, 3647, '\P{LOE=y}', ""); +Expect(0, 3647, '\P{^LOE=y}', ""); +Expect(1, 3652, '\p{LOE= Y}', ""); +Expect(0, 3652, '\p{^LOE= Y}', ""); +Expect(0, 3652, '\P{LOE= Y}', ""); +Expect(1, 3652, '\P{^LOE= Y}', ""); +Expect(0, 3647, '\p{LOE= Y}', ""); +Expect(1, 3647, '\p{^LOE= Y}', ""); +Expect(1, 3647, '\P{LOE= Y}', ""); +Expect(0, 3647, '\P{^LOE= Y}', ""); +Error('\p{Is_Logical_Order_Exception: T:=}'); +Error('\P{Is_Logical_Order_Exception: T:=}'); +Expect(1, 3652, '\p{Is_Logical_Order_Exception=t}', ""); +Expect(0, 3652, '\p{^Is_Logical_Order_Exception=t}', ""); +Expect(0, 3652, '\P{Is_Logical_Order_Exception=t}', ""); +Expect(1, 3652, '\P{^Is_Logical_Order_Exception=t}', ""); +Expect(0, 3647, '\p{Is_Logical_Order_Exception=t}', ""); +Expect(1, 3647, '\p{^Is_Logical_Order_Exception=t}', ""); +Expect(1, 3647, '\P{Is_Logical_Order_Exception=t}', ""); +Expect(0, 3647, '\P{^Is_Logical_Order_Exception=t}', ""); +Expect(1, 3652, '\p{Is_Logical_Order_Exception= T}', ""); +Expect(0, 3652, '\p{^Is_Logical_Order_Exception= T}', ""); +Expect(0, 3652, '\P{Is_Logical_Order_Exception= T}', ""); +Expect(1, 3652, '\P{^Is_Logical_Order_Exception= T}', ""); +Expect(0, 3647, '\p{Is_Logical_Order_Exception= T}', ""); +Expect(1, 3647, '\p{^Is_Logical_Order_Exception= T}', ""); +Expect(1, 3647, '\P{Is_Logical_Order_Exception= T}', ""); +Expect(0, 3647, '\P{^Is_Logical_Order_Exception= T}', ""); +Error('\p{Is_LOE=-True:=}'); +Error('\P{Is_LOE=-True:=}'); +Expect(1, 3652, '\p{Is_LOE=true}', ""); +Expect(0, 3652, '\p{^Is_LOE=true}', ""); +Expect(0, 3652, '\P{Is_LOE=true}', ""); +Expect(1, 3652, '\P{^Is_LOE=true}', ""); +Expect(0, 3647, '\p{Is_LOE=true}', ""); +Expect(1, 3647, '\p{^Is_LOE=true}', ""); +Expect(1, 3647, '\P{Is_LOE=true}', ""); +Expect(0, 3647, '\P{^Is_LOE=true}', ""); +Expect(1, 3652, '\p{Is_LOE=-TRUE}', ""); +Expect(0, 3652, '\p{^Is_LOE=-TRUE}', ""); +Expect(0, 3652, '\P{Is_LOE=-TRUE}', ""); +Expect(1, 3652, '\P{^Is_LOE=-TRUE}', ""); +Expect(0, 3647, '\p{Is_LOE=-TRUE}', ""); +Expect(1, 3647, '\p{^Is_LOE=-TRUE}', ""); +Expect(1, 3647, '\P{Is_LOE=-TRUE}', ""); +Expect(0, 3647, '\P{^Is_LOE=-TRUE}', ""); +Error('\p{Logical_Order_Exception=/a/_ No}'); +Error('\P{Logical_Order_Exception=/a/_ No}'); +Expect(1, 3647, '\p{Logical_Order_Exception=no}', ""); +Expect(0, 3647, '\p{^Logical_Order_Exception=no}', ""); +Expect(0, 3647, '\P{Logical_Order_Exception=no}', ""); +Expect(1, 3647, '\P{^Logical_Order_Exception=no}', ""); +Expect(0, 3652, '\p{Logical_Order_Exception=no}', ""); +Expect(1, 3652, '\p{^Logical_Order_Exception=no}', ""); +Expect(1, 3652, '\P{Logical_Order_Exception=no}', ""); +Expect(0, 3652, '\P{^Logical_Order_Exception=no}', ""); +Expect(1, 3647, '\p{Logical_Order_Exception= no}', ""); +Expect(0, 3647, '\p{^Logical_Order_Exception= no}', ""); +Expect(0, 3647, '\P{Logical_Order_Exception= no}', ""); +Expect(1, 3647, '\P{^Logical_Order_Exception= no}', ""); +Expect(0, 3652, '\p{Logical_Order_Exception= no}', ""); +Expect(1, 3652, '\p{^Logical_Order_Exception= no}', ""); +Expect(1, 3652, '\P{Logical_Order_Exception= no}', ""); +Expect(0, 3652, '\P{^Logical_Order_Exception= no}', ""); +Error('\p{LOE= /a/N}'); +Error('\P{LOE= /a/N}'); +Expect(1, 3647, '\p{LOE=n}', ""); +Expect(0, 3647, '\p{^LOE=n}', ""); +Expect(0, 3647, '\P{LOE=n}', ""); +Expect(1, 3647, '\P{^LOE=n}', ""); +Expect(0, 3652, '\p{LOE=n}', ""); +Expect(1, 3652, '\p{^LOE=n}', ""); +Expect(1, 3652, '\P{LOE=n}', ""); +Expect(0, 3652, '\P{^LOE=n}', ""); +Expect(1, 3647, '\p{LOE= -N}', ""); +Expect(0, 3647, '\p{^LOE= -N}', ""); +Expect(0, 3647, '\P{LOE= -N}', ""); +Expect(1, 3647, '\P{^LOE= -N}', ""); +Expect(0, 3652, '\p{LOE= -N}', ""); +Expect(1, 3652, '\p{^LOE= -N}', ""); +Expect(1, 3652, '\P{LOE= -N}', ""); +Expect(0, 3652, '\P{^LOE= -N}', ""); +Error('\p{Is_Logical_Order_Exception=_-F/a/}'); +Error('\P{Is_Logical_Order_Exception=_-F/a/}'); +Expect(1, 3647, '\p{Is_Logical_Order_Exception=f}', ""); +Expect(0, 3647, '\p{^Is_Logical_Order_Exception=f}', ""); +Expect(0, 3647, '\P{Is_Logical_Order_Exception=f}', ""); +Expect(1, 3647, '\P{^Is_Logical_Order_Exception=f}', ""); +Expect(0, 3652, '\p{Is_Logical_Order_Exception=f}', ""); +Expect(1, 3652, '\p{^Is_Logical_Order_Exception=f}', ""); +Expect(1, 3652, '\P{Is_Logical_Order_Exception=f}', ""); +Expect(0, 3652, '\P{^Is_Logical_Order_Exception=f}', ""); +Expect(1, 3647, '\p{Is_Logical_Order_Exception=_-F}', ""); +Expect(0, 3647, '\p{^Is_Logical_Order_Exception=_-F}', ""); +Expect(0, 3647, '\P{Is_Logical_Order_Exception=_-F}', ""); +Expect(1, 3647, '\P{^Is_Logical_Order_Exception=_-F}', ""); +Expect(0, 3652, '\p{Is_Logical_Order_Exception=_-F}', ""); +Expect(1, 3652, '\p{^Is_Logical_Order_Exception=_-F}', ""); +Expect(1, 3652, '\P{Is_Logical_Order_Exception=_-F}', ""); +Expect(0, 3652, '\P{^Is_Logical_Order_Exception=_-F}', ""); +Error('\p{Is_LOE=/a/ False}'); +Error('\P{Is_LOE=/a/ False}'); +Expect(1, 3647, '\p{Is_LOE:false}', ""); +Expect(0, 3647, '\p{^Is_LOE:false}', ""); +Expect(0, 3647, '\P{Is_LOE:false}', ""); +Expect(1, 3647, '\P{^Is_LOE:false}', ""); +Expect(0, 3652, '\p{Is_LOE:false}', ""); +Expect(1, 3652, '\p{^Is_LOE:false}', ""); +Expect(1, 3652, '\P{Is_LOE:false}', ""); +Expect(0, 3652, '\P{^Is_LOE:false}', ""); +Expect(1, 3647, '\p{Is_LOE= FALSE}', ""); +Expect(0, 3647, '\p{^Is_LOE= FALSE}', ""); +Expect(0, 3647, '\P{Is_LOE= FALSE}', ""); +Expect(1, 3647, '\P{^Is_LOE= FALSE}', ""); +Expect(0, 3652, '\p{Is_LOE= FALSE}', ""); +Expect(1, 3652, '\p{^Is_LOE= FALSE}', ""); +Expect(1, 3652, '\P{Is_LOE= FALSE}', ""); +Expect(0, 3652, '\P{^Is_LOE= FALSE}', ""); +Error('\p{Bidi_Mirrored=_ Yes/a/}'); +Error('\P{Bidi_Mirrored=_ Yes/a/}'); +Expect(1, 41, '\p{Bidi_Mirrored=yes}', ""); +Expect(0, 41, '\p{^Bidi_Mirrored=yes}', ""); +Expect(0, 41, '\P{Bidi_Mirrored=yes}', ""); +Expect(1, 41, '\P{^Bidi_Mirrored=yes}', ""); +Expect(0, 39, '\p{Bidi_Mirrored=yes}', ""); +Expect(1, 39, '\p{^Bidi_Mirrored=yes}', ""); +Expect(1, 39, '\P{Bidi_Mirrored=yes}', ""); +Expect(0, 39, '\P{^Bidi_Mirrored=yes}', ""); +Expect(1, 41, '\p{Bidi_Mirrored: Yes}', ""); +Expect(0, 41, '\p{^Bidi_Mirrored: Yes}', ""); +Expect(0, 41, '\P{Bidi_Mirrored: Yes}', ""); +Expect(1, 41, '\P{^Bidi_Mirrored: Yes}', ""); +Expect(0, 39, '\p{Bidi_Mirrored: Yes}', ""); +Expect(1, 39, '\p{^Bidi_Mirrored: Yes}', ""); +Expect(1, 39, '\P{Bidi_Mirrored: Yes}', ""); +Expect(0, 39, '\P{^Bidi_Mirrored: Yes}', ""); +Error('\p{Bidi_M= /a/y}'); +Error('\P{Bidi_M= /a/y}'); +Expect(1, 41, '\p{Bidi_M=y}', ""); +Expect(0, 41, '\p{^Bidi_M=y}', ""); +Expect(0, 41, '\P{Bidi_M=y}', ""); +Expect(1, 41, '\P{^Bidi_M=y}', ""); +Expect(0, 39, '\p{Bidi_M=y}', ""); +Expect(1, 39, '\p{^Bidi_M=y}', ""); +Expect(1, 39, '\P{Bidi_M=y}', ""); +Expect(0, 39, '\P{^Bidi_M=y}', ""); +Expect(1, 41, '\p{Bidi_M= -Y}', ""); +Expect(0, 41, '\p{^Bidi_M= -Y}', ""); +Expect(0, 41, '\P{Bidi_M= -Y}', ""); +Expect(1, 41, '\P{^Bidi_M= -Y}', ""); +Expect(0, 39, '\p{Bidi_M= -Y}', ""); +Expect(1, 39, '\p{^Bidi_M= -Y}', ""); +Expect(1, 39, '\P{Bidi_M= -Y}', ""); +Expect(0, 39, '\P{^Bidi_M= -Y}', ""); +Error('\p{Is_Bidi_Mirrored= -T/a/}'); +Error('\P{Is_Bidi_Mirrored= -T/a/}'); +Expect(1, 41, '\p{Is_Bidi_Mirrored=t}', ""); +Expect(0, 41, '\p{^Is_Bidi_Mirrored=t}', ""); +Expect(0, 41, '\P{Is_Bidi_Mirrored=t}', ""); +Expect(1, 41, '\P{^Is_Bidi_Mirrored=t}', ""); +Expect(0, 39, '\p{Is_Bidi_Mirrored=t}', ""); +Expect(1, 39, '\p{^Is_Bidi_Mirrored=t}', ""); +Expect(1, 39, '\P{Is_Bidi_Mirrored=t}', ""); +Expect(0, 39, '\P{^Is_Bidi_Mirrored=t}', ""); +Expect(1, 41, '\p{Is_Bidi_Mirrored: -t}', ""); +Expect(0, 41, '\p{^Is_Bidi_Mirrored: -t}', ""); +Expect(0, 41, '\P{Is_Bidi_Mirrored: -t}', ""); +Expect(1, 41, '\P{^Is_Bidi_Mirrored: -t}', ""); +Expect(0, 39, '\p{Is_Bidi_Mirrored: -t}', ""); +Expect(1, 39, '\p{^Is_Bidi_Mirrored: -t}', ""); +Expect(1, 39, '\P{Is_Bidi_Mirrored: -t}', ""); +Expect(0, 39, '\P{^Is_Bidi_Mirrored: -t}', ""); +Error('\p{Is_Bidi_M=/a/-TRUE}'); +Error('\P{Is_Bidi_M=/a/-TRUE}'); +Expect(1, 41, '\p{Is_Bidi_M=true}', ""); +Expect(0, 41, '\p{^Is_Bidi_M=true}', ""); +Expect(0, 41, '\P{Is_Bidi_M=true}', ""); +Expect(1, 41, '\P{^Is_Bidi_M=true}', ""); +Expect(0, 39, '\p{Is_Bidi_M=true}', ""); +Expect(1, 39, '\p{^Is_Bidi_M=true}', ""); +Expect(1, 39, '\P{Is_Bidi_M=true}', ""); +Expect(0, 39, '\P{^Is_Bidi_M=true}', ""); +Expect(1, 41, '\p{Is_Bidi_M=_-True}', ""); +Expect(0, 41, '\p{^Is_Bidi_M=_-True}', ""); +Expect(0, 41, '\P{Is_Bidi_M=_-True}', ""); +Expect(1, 41, '\P{^Is_Bidi_M=_-True}', ""); +Expect(0, 39, '\p{Is_Bidi_M=_-True}', ""); +Expect(1, 39, '\p{^Is_Bidi_M=_-True}', ""); +Expect(1, 39, '\P{Is_Bidi_M=_-True}', ""); +Expect(0, 39, '\P{^Is_Bidi_M=_-True}', ""); +Error('\p{Bidi_Mirrored=/a/_ No}'); +Error('\P{Bidi_Mirrored=/a/_ No}'); +Expect(1, 39, '\p{Bidi_Mirrored=no}', ""); +Expect(0, 39, '\p{^Bidi_Mirrored=no}', ""); +Expect(0, 39, '\P{Bidi_Mirrored=no}', ""); +Expect(1, 39, '\P{^Bidi_Mirrored=no}', ""); +Expect(0, 41, '\p{Bidi_Mirrored=no}', ""); +Expect(1, 41, '\p{^Bidi_Mirrored=no}', ""); +Expect(1, 41, '\P{Bidi_Mirrored=no}', ""); +Expect(0, 41, '\P{^Bidi_Mirrored=no}', ""); +Expect(1, 39, '\p{Bidi_Mirrored: --NO}', ""); +Expect(0, 39, '\p{^Bidi_Mirrored: --NO}', ""); +Expect(0, 39, '\P{Bidi_Mirrored: --NO}', ""); +Expect(1, 39, '\P{^Bidi_Mirrored: --NO}', ""); +Expect(0, 41, '\p{Bidi_Mirrored: --NO}', ""); +Expect(1, 41, '\p{^Bidi_Mirrored: --NO}', ""); +Expect(1, 41, '\P{Bidi_Mirrored: --NO}', ""); +Expect(0, 41, '\P{^Bidi_Mirrored: --NO}', ""); +Error('\p{Bidi_M=:=_N}'); +Error('\P{Bidi_M=:=_N}'); +Expect(1, 39, '\p{Bidi_M=n}', ""); +Expect(0, 39, '\p{^Bidi_M=n}', ""); +Expect(0, 39, '\P{Bidi_M=n}', ""); +Expect(1, 39, '\P{^Bidi_M=n}', ""); +Expect(0, 41, '\p{Bidi_M=n}', ""); +Expect(1, 41, '\p{^Bidi_M=n}', ""); +Expect(1, 41, '\P{Bidi_M=n}', ""); +Expect(0, 41, '\P{^Bidi_M=n}', ""); +Expect(1, 39, '\p{Bidi_M=_N}', ""); +Expect(0, 39, '\p{^Bidi_M=_N}', ""); +Expect(0, 39, '\P{Bidi_M=_N}', ""); +Expect(1, 39, '\P{^Bidi_M=_N}', ""); +Expect(0, 41, '\p{Bidi_M=_N}', ""); +Expect(1, 41, '\p{^Bidi_M=_N}', ""); +Expect(1, 41, '\P{Bidi_M=_N}', ""); +Expect(0, 41, '\P{^Bidi_M=_N}', ""); +Error('\p{Is_Bidi_Mirrored=- F/a/}'); +Error('\P{Is_Bidi_Mirrored=- F/a/}'); +Expect(1, 39, '\p{Is_Bidi_Mirrored=f}', ""); +Expect(0, 39, '\p{^Is_Bidi_Mirrored=f}', ""); +Expect(0, 39, '\P{Is_Bidi_Mirrored=f}', ""); +Expect(1, 39, '\P{^Is_Bidi_Mirrored=f}', ""); +Expect(0, 41, '\p{Is_Bidi_Mirrored=f}', ""); +Expect(1, 41, '\p{^Is_Bidi_Mirrored=f}', ""); +Expect(1, 41, '\P{Is_Bidi_Mirrored=f}', ""); +Expect(0, 41, '\P{^Is_Bidi_Mirrored=f}', ""); +Expect(1, 39, '\p{Is_Bidi_Mirrored=- F}', ""); +Expect(0, 39, '\p{^Is_Bidi_Mirrored=- F}', ""); +Expect(0, 39, '\P{Is_Bidi_Mirrored=- F}', ""); +Expect(1, 39, '\P{^Is_Bidi_Mirrored=- F}', ""); +Expect(0, 41, '\p{Is_Bidi_Mirrored=- F}', ""); +Expect(1, 41, '\p{^Is_Bidi_Mirrored=- F}', ""); +Expect(1, 41, '\P{Is_Bidi_Mirrored=- F}', ""); +Expect(0, 41, '\P{^Is_Bidi_Mirrored=- F}', ""); +Error('\p{Is_Bidi_M=_ false:=}'); +Error('\P{Is_Bidi_M=_ false:=}'); +Expect(1, 39, '\p{Is_Bidi_M=false}', ""); +Expect(0, 39, '\p{^Is_Bidi_M=false}', ""); +Expect(0, 39, '\P{Is_Bidi_M=false}', ""); +Expect(1, 39, '\P{^Is_Bidi_M=false}', ""); +Expect(0, 41, '\p{Is_Bidi_M=false}', ""); +Expect(1, 41, '\p{^Is_Bidi_M=false}', ""); +Expect(1, 41, '\P{Is_Bidi_M=false}', ""); +Expect(0, 41, '\P{^Is_Bidi_M=false}', ""); +Expect(1, 39, '\p{Is_Bidi_M=- False}', ""); +Expect(0, 39, '\p{^Is_Bidi_M=- False}', ""); +Expect(0, 39, '\P{Is_Bidi_M=- False}', ""); +Expect(1, 39, '\P{^Is_Bidi_M=- False}', ""); +Expect(0, 41, '\p{Is_Bidi_M=- False}', ""); +Expect(1, 41, '\p{^Is_Bidi_M=- False}', ""); +Expect(1, 41, '\P{Is_Bidi_M=- False}', ""); +Expect(0, 41, '\P{^Is_Bidi_M=- False}', ""); +Error('\p{Lowercase= _Yes:=}'); +Error('\P{Lowercase= _Yes:=}'); +Expect(1, 122, '\p{Lowercase=yes}', ""); +Expect(0, 122, '\p{^Lowercase=yes}', ""); +Expect(0, 122, '\P{Lowercase=yes}', ""); +Expect(1, 122, '\P{^Lowercase=yes}', ""); +Expect(0, 96, '\p{Lowercase=yes}', ""); +Expect(1, 96, '\p{^Lowercase=yes}', ""); +Expect(1, 96, '\P{Lowercase=yes}', ""); +Expect(0, 96, '\P{^Lowercase=yes}', ""); +Expect(1, 122, '\p{Lowercase= Yes}', ""); +Expect(0, 122, '\p{^Lowercase= Yes}', ""); +Expect(0, 122, '\P{Lowercase= Yes}', ""); +Expect(1, 122, '\P{^Lowercase= Yes}', ""); +Expect(0, 96, '\p{Lowercase= Yes}', ""); +Expect(1, 96, '\p{^Lowercase= Yes}', ""); +Expect(1, 96, '\P{Lowercase= Yes}', ""); +Expect(0, 96, '\P{^Lowercase= Yes}', ""); +Error('\p{Lower=_/a/Y}'); +Error('\P{Lower=_/a/Y}'); +Expect(1, 122, '\p{Lower=y}', ""); +Expect(0, 122, '\p{^Lower=y}', ""); +Expect(0, 122, '\P{Lower=y}', ""); +Expect(1, 122, '\P{^Lower=y}', ""); +Expect(0, 96, '\p{Lower=y}', ""); +Expect(1, 96, '\p{^Lower=y}', ""); +Expect(1, 96, '\P{Lower=y}', ""); +Expect(0, 96, '\P{^Lower=y}', ""); +Expect(1, 122, '\p{Lower=_Y}', ""); +Expect(0, 122, '\p{^Lower=_Y}', ""); +Expect(0, 122, '\P{Lower=_Y}', ""); +Expect(1, 122, '\P{^Lower=_Y}', ""); +Expect(0, 96, '\p{Lower=_Y}', ""); +Expect(1, 96, '\p{^Lower=_Y}', ""); +Expect(1, 96, '\P{Lower=_Y}', ""); +Expect(0, 96, '\P{^Lower=_Y}', ""); +Error('\p{Is_Lowercase=:=_ T}'); +Error('\P{Is_Lowercase=:=_ T}'); +Expect(1, 122, '\p{Is_Lowercase=t}', ""); +Expect(0, 122, '\p{^Is_Lowercase=t}', ""); +Expect(0, 122, '\P{Is_Lowercase=t}', ""); +Expect(1, 122, '\P{^Is_Lowercase=t}', ""); +Expect(0, 96, '\p{Is_Lowercase=t}', ""); +Expect(1, 96, '\p{^Is_Lowercase=t}', ""); +Expect(1, 96, '\P{Is_Lowercase=t}', ""); +Expect(0, 96, '\P{^Is_Lowercase=t}', ""); +Expect(1, 122, '\p{Is_Lowercase=--T}', ""); +Expect(0, 122, '\p{^Is_Lowercase=--T}', ""); +Expect(0, 122, '\P{Is_Lowercase=--T}', ""); +Expect(1, 122, '\P{^Is_Lowercase=--T}', ""); +Expect(0, 96, '\p{Is_Lowercase=--T}', ""); +Expect(1, 96, '\p{^Is_Lowercase=--T}', ""); +Expect(1, 96, '\P{Is_Lowercase=--T}', ""); +Expect(0, 96, '\P{^Is_Lowercase=--T}', ""); +Error('\p{Is_Lower=/a/ -TRUE}'); +Error('\P{Is_Lower=/a/ -TRUE}'); +Expect(1, 122, '\p{Is_Lower=true}', ""); +Expect(0, 122, '\p{^Is_Lower=true}', ""); +Expect(0, 122, '\P{Is_Lower=true}', ""); +Expect(1, 122, '\P{^Is_Lower=true}', ""); +Expect(0, 96, '\p{Is_Lower=true}', ""); +Expect(1, 96, '\p{^Is_Lower=true}', ""); +Expect(1, 96, '\P{Is_Lower=true}', ""); +Expect(0, 96, '\P{^Is_Lower=true}', ""); +Expect(1, 122, '\p{Is_Lower= _True}', ""); +Expect(0, 122, '\p{^Is_Lower= _True}', ""); +Expect(0, 122, '\P{Is_Lower= _True}', ""); +Expect(1, 122, '\P{^Is_Lower= _True}', ""); +Expect(0, 96, '\p{Is_Lower= _True}', ""); +Expect(1, 96, '\p{^Is_Lower= _True}', ""); +Expect(1, 96, '\P{Is_Lower= _True}', ""); +Expect(0, 96, '\P{^Is_Lower= _True}', ""); +Error('\p{Lowercase=:=-No}'); +Error('\P{Lowercase=:=-No}'); +Expect(1, 96, '\p{Lowercase=no}', ""); +Expect(0, 96, '\p{^Lowercase=no}', ""); +Expect(0, 96, '\P{Lowercase=no}', ""); +Expect(1, 96, '\P{^Lowercase=no}', ""); +Expect(0, 122, '\p{Lowercase=no}', ""); +Expect(1, 122, '\p{^Lowercase=no}', ""); +Expect(1, 122, '\P{Lowercase=no}', ""); +Expect(0, 122, '\P{^Lowercase=no}', ""); +Expect(1, 96, '\p{Lowercase=_no}', ""); +Expect(0, 96, '\p{^Lowercase=_no}', ""); +Expect(0, 96, '\P{Lowercase=_no}', ""); +Expect(1, 96, '\P{^Lowercase=_no}', ""); +Expect(0, 122, '\p{Lowercase=_no}', ""); +Expect(1, 122, '\p{^Lowercase=_no}', ""); +Expect(1, 122, '\P{Lowercase=_no}', ""); +Expect(0, 122, '\P{^Lowercase=_no}', ""); +Error('\p{Lower= :=N}'); +Error('\P{Lower= :=N}'); +Expect(1, 96, '\p{Lower=n}', ""); +Expect(0, 96, '\p{^Lower=n}', ""); +Expect(0, 96, '\P{Lower=n}', ""); +Expect(1, 96, '\P{^Lower=n}', ""); +Expect(0, 122, '\p{Lower=n}', ""); +Expect(1, 122, '\p{^Lower=n}', ""); +Expect(1, 122, '\P{Lower=n}', ""); +Expect(0, 122, '\P{^Lower=n}', ""); +Expect(1, 96, '\p{Lower= N}', ""); +Expect(0, 96, '\p{^Lower= N}', ""); +Expect(0, 96, '\P{Lower= N}', ""); +Expect(1, 96, '\P{^Lower= N}', ""); +Expect(0, 122, '\p{Lower= N}', ""); +Expect(1, 122, '\p{^Lower= N}', ""); +Expect(1, 122, '\P{Lower= N}', ""); +Expect(0, 122, '\P{^Lower= N}', ""); +Error('\p{Is_Lowercase=/a/ F}'); +Error('\P{Is_Lowercase=/a/ F}'); +Expect(1, 96, '\p{Is_Lowercase=f}', ""); +Expect(0, 96, '\p{^Is_Lowercase=f}', ""); +Expect(0, 96, '\P{Is_Lowercase=f}', ""); +Expect(1, 96, '\P{^Is_Lowercase=f}', ""); +Expect(0, 122, '\p{Is_Lowercase=f}', ""); +Expect(1, 122, '\p{^Is_Lowercase=f}', ""); +Expect(1, 122, '\P{Is_Lowercase=f}', ""); +Expect(0, 122, '\P{^Is_Lowercase=f}', ""); +Expect(1, 96, '\p{Is_Lowercase= F}', ""); +Expect(0, 96, '\p{^Is_Lowercase= F}', ""); +Expect(0, 96, '\P{Is_Lowercase= F}', ""); +Expect(1, 96, '\P{^Is_Lowercase= F}', ""); +Expect(0, 122, '\p{Is_Lowercase= F}', ""); +Expect(1, 122, '\p{^Is_Lowercase= F}', ""); +Expect(1, 122, '\P{Is_Lowercase= F}', ""); +Expect(0, 122, '\P{^Is_Lowercase= F}', ""); +Error('\p{Is_Lower=/a/false}'); +Error('\P{Is_Lower=/a/false}'); +Expect(1, 96, '\p{Is_Lower=false}', ""); +Expect(0, 96, '\p{^Is_Lower=false}', ""); +Expect(0, 96, '\P{Is_Lower=false}', ""); +Expect(1, 96, '\P{^Is_Lower=false}', ""); +Expect(0, 122, '\p{Is_Lower=false}', ""); +Expect(1, 122, '\p{^Is_Lower=false}', ""); +Expect(1, 122, '\P{Is_Lower=false}', ""); +Expect(0, 122, '\P{^Is_Lower=false}', ""); +Expect(1, 96, '\p{Is_Lower= false}', ""); +Expect(0, 96, '\p{^Is_Lower= false}', ""); +Expect(0, 96, '\P{Is_Lower= false}', ""); +Expect(1, 96, '\P{^Is_Lower= false}', ""); +Expect(0, 122, '\p{Is_Lower= false}', ""); +Expect(1, 122, '\p{^Is_Lower= false}', ""); +Expect(1, 122, '\P{Is_Lower= false}', ""); +Expect(0, 122, '\P{^Is_Lower= false}', ""); +Error('\p{Uppercase= -YES/a/}'); +Error('\P{Uppercase= -YES/a/}'); +Expect(1, 90, '\p{Uppercase=yes}', ""); +Expect(0, 90, '\p{^Uppercase=yes}', ""); +Expect(0, 90, '\P{Uppercase=yes}', ""); +Expect(1, 90, '\P{^Uppercase=yes}', ""); +Expect(0, 64, '\p{Uppercase=yes}', ""); +Expect(1, 64, '\p{^Uppercase=yes}', ""); +Expect(1, 64, '\P{Uppercase=yes}', ""); +Expect(0, 64, '\P{^Uppercase=yes}', ""); +Expect(1, 90, '\p{Uppercase= yes}', ""); +Expect(0, 90, '\p{^Uppercase= yes}', ""); +Expect(0, 90, '\P{Uppercase= yes}', ""); +Expect(1, 90, '\P{^Uppercase= yes}', ""); +Expect(0, 64, '\p{Uppercase= yes}', ""); +Expect(1, 64, '\p{^Uppercase= yes}', ""); +Expect(1, 64, '\P{Uppercase= yes}', ""); +Expect(0, 64, '\P{^Uppercase= yes}', ""); +Error('\p{Upper=/a/ Y}'); +Error('\P{Upper=/a/ Y}'); +Expect(1, 90, '\p{Upper=y}', ""); +Expect(0, 90, '\p{^Upper=y}', ""); +Expect(0, 90, '\P{Upper=y}', ""); +Expect(1, 90, '\P{^Upper=y}', ""); +Expect(0, 64, '\p{Upper=y}', ""); +Expect(1, 64, '\p{^Upper=y}', ""); +Expect(1, 64, '\P{Upper=y}', ""); +Expect(0, 64, '\P{^Upper=y}', ""); +Expect(1, 90, '\p{Upper:-y}', ""); +Expect(0, 90, '\p{^Upper:-y}', ""); +Expect(0, 90, '\P{Upper:-y}', ""); +Expect(1, 90, '\P{^Upper:-y}', ""); +Expect(0, 64, '\p{Upper:-y}', ""); +Expect(1, 64, '\p{^Upper:-y}', ""); +Expect(1, 64, '\P{Upper:-y}', ""); +Expect(0, 64, '\P{^Upper:-y}', ""); +Error('\p{Is_Uppercase=_:=T}'); +Error('\P{Is_Uppercase=_:=T}'); +Expect(1, 90, '\p{Is_Uppercase:t}', ""); +Expect(0, 90, '\p{^Is_Uppercase:t}', ""); +Expect(0, 90, '\P{Is_Uppercase:t}', ""); +Expect(1, 90, '\P{^Is_Uppercase:t}', ""); +Expect(0, 64, '\p{Is_Uppercase:t}', ""); +Expect(1, 64, '\p{^Is_Uppercase:t}', ""); +Expect(1, 64, '\P{Is_Uppercase:t}', ""); +Expect(0, 64, '\P{^Is_Uppercase:t}', ""); +Expect(1, 90, '\p{Is_Uppercase=__T}', ""); +Expect(0, 90, '\p{^Is_Uppercase=__T}', ""); +Expect(0, 90, '\P{Is_Uppercase=__T}', ""); +Expect(1, 90, '\P{^Is_Uppercase=__T}', ""); +Expect(0, 64, '\p{Is_Uppercase=__T}', ""); +Expect(1, 64, '\p{^Is_Uppercase=__T}', ""); +Expect(1, 64, '\P{Is_Uppercase=__T}', ""); +Expect(0, 64, '\P{^Is_Uppercase=__T}', ""); +Error('\p{Is_Upper= true:=}'); +Error('\P{Is_Upper= true:=}'); +Expect(1, 90, '\p{Is_Upper: true}', ""); +Expect(0, 90, '\p{^Is_Upper: true}', ""); +Expect(0, 90, '\P{Is_Upper: true}', ""); +Expect(1, 90, '\P{^Is_Upper: true}', ""); +Expect(0, 64, '\p{Is_Upper: true}', ""); +Expect(1, 64, '\p{^Is_Upper: true}', ""); +Expect(1, 64, '\P{Is_Upper: true}', ""); +Expect(0, 64, '\P{^Is_Upper: true}', ""); +Expect(1, 90, '\p{Is_Upper:_true}', ""); +Expect(0, 90, '\p{^Is_Upper:_true}', ""); +Expect(0, 90, '\P{Is_Upper:_true}', ""); +Expect(1, 90, '\P{^Is_Upper:_true}', ""); +Expect(0, 64, '\p{Is_Upper:_true}', ""); +Expect(1, 64, '\p{^Is_Upper:_true}', ""); +Expect(1, 64, '\P{Is_Upper:_true}', ""); +Expect(0, 64, '\P{^Is_Upper:_true}', ""); +Error('\p{Uppercase=:= No}'); +Error('\P{Uppercase=:= No}'); +Expect(1, 64, '\p{Uppercase:no}', ""); +Expect(0, 64, '\p{^Uppercase:no}', ""); +Expect(0, 64, '\P{Uppercase:no}', ""); +Expect(1, 64, '\P{^Uppercase:no}', ""); +Expect(0, 90, '\p{Uppercase:no}', ""); +Expect(1, 90, '\p{^Uppercase:no}', ""); +Expect(1, 90, '\P{Uppercase:no}', ""); +Expect(0, 90, '\P{^Uppercase:no}', ""); +Expect(1, 64, '\p{Uppercase= No}', ""); +Expect(0, 64, '\p{^Uppercase= No}', ""); +Expect(0, 64, '\P{Uppercase= No}', ""); +Expect(1, 64, '\P{^Uppercase= No}', ""); +Expect(0, 90, '\p{Uppercase= No}', ""); +Expect(1, 90, '\p{^Uppercase= No}', ""); +Expect(1, 90, '\P{Uppercase= No}', ""); +Expect(0, 90, '\P{^Uppercase= No}', ""); +Error('\p{Upper=/a/- N}'); +Error('\P{Upper=/a/- N}'); +Expect(1, 64, '\p{Upper=n}', ""); +Expect(0, 64, '\p{^Upper=n}', ""); +Expect(0, 64, '\P{Upper=n}', ""); +Expect(1, 64, '\P{^Upper=n}', ""); +Expect(0, 90, '\p{Upper=n}', ""); +Expect(1, 90, '\p{^Upper=n}', ""); +Expect(1, 90, '\P{Upper=n}', ""); +Expect(0, 90, '\P{^Upper=n}', ""); +Expect(1, 64, '\p{Upper=-n}', ""); +Expect(0, 64, '\p{^Upper=-n}', ""); +Expect(0, 64, '\P{Upper=-n}', ""); +Expect(1, 64, '\P{^Upper=-n}', ""); +Expect(0, 90, '\p{Upper=-n}', ""); +Expect(1, 90, '\p{^Upper=-n}', ""); +Expect(1, 90, '\P{Upper=-n}', ""); +Expect(0, 90, '\P{^Upper=-n}', ""); +Error('\p{Is_Uppercase=_ F:=}'); +Error('\P{Is_Uppercase=_ F:=}'); +Expect(1, 64, '\p{Is_Uppercase=f}', ""); +Expect(0, 64, '\p{^Is_Uppercase=f}', ""); +Expect(0, 64, '\P{Is_Uppercase=f}', ""); +Expect(1, 64, '\P{^Is_Uppercase=f}', ""); +Expect(0, 90, '\p{Is_Uppercase=f}', ""); +Expect(1, 90, '\p{^Is_Uppercase=f}', ""); +Expect(1, 90, '\P{Is_Uppercase=f}', ""); +Expect(0, 90, '\P{^Is_Uppercase=f}', ""); +Expect(1, 64, '\p{Is_Uppercase= F}', ""); +Expect(0, 64, '\p{^Is_Uppercase= F}', ""); +Expect(0, 64, '\P{Is_Uppercase= F}', ""); +Expect(1, 64, '\P{^Is_Uppercase= F}', ""); +Expect(0, 90, '\p{Is_Uppercase= F}', ""); +Expect(1, 90, '\p{^Is_Uppercase= F}', ""); +Expect(1, 90, '\P{Is_Uppercase= F}', ""); +Expect(0, 90, '\P{^Is_Uppercase= F}', ""); +Error('\p{Is_Upper: /a/ False}'); +Error('\P{Is_Upper: /a/ False}'); +Expect(1, 64, '\p{Is_Upper=false}', ""); +Expect(0, 64, '\p{^Is_Upper=false}', ""); +Expect(0, 64, '\P{Is_Upper=false}', ""); +Expect(1, 64, '\P{^Is_Upper=false}', ""); +Expect(0, 90, '\p{Is_Upper=false}', ""); +Expect(1, 90, '\p{^Is_Upper=false}', ""); +Expect(1, 90, '\P{Is_Upper=false}', ""); +Expect(0, 90, '\P{^Is_Upper=false}', ""); +Expect(1, 64, '\p{Is_Upper= False}', ""); +Expect(0, 64, '\p{^Is_Upper= False}', ""); +Expect(0, 64, '\P{Is_Upper= False}', ""); +Expect(1, 64, '\P{^Is_Upper= False}', ""); +Expect(0, 90, '\p{Is_Upper= False}', ""); +Expect(1, 90, '\p{^Is_Upper= False}', ""); +Expect(1, 90, '\P{Is_Upper= False}', ""); +Expect(0, 90, '\P{^Is_Upper= False}', ""); +Error('\p{Expands_On_NFKC: Yes}'); +Error('\P{Expands_On_NFKC: Yes}'); +Error('\p{XO_NFKC=Y}'); +Error('\P{XO_NFKC=Y}'); +Error('\p{Is_Expands_On_NFKC=T}'); +Error('\P{Is_Expands_On_NFKC=T}'); +Error('\p{Is_XO_NFKC=True}'); +Error('\P{Is_XO_NFKC=True}'); +Error('\p{Expands_On_NFKC: No}'); +Error('\P{Expands_On_NFKC: No}'); +Error('\p{XO_NFKC=N}'); +Error('\P{XO_NFKC=N}'); +Error('\p{Is_Expands_On_NFKC=F}'); +Error('\P{Is_Expands_On_NFKC=F}'); +Error('\p{Is_XO_NFKC=False}'); +Error('\P{Is_XO_NFKC=False}'); +Error('\p{NFD_Quick_Check=--yes:=}'); +Error('\P{NFD_Quick_Check=--yes:=}'); +Expect(1, 7, '\p{NFD_Quick_Check=yes}', ""); +Expect(0, 7, '\p{^NFD_Quick_Check=yes}', ""); +Expect(0, 7, '\P{NFD_Quick_Check=yes}', ""); +Expect(1, 7, '\P{^NFD_Quick_Check=yes}', ""); +Expect(0, 271, '\p{NFD_Quick_Check=yes}', ""); +Expect(1, 271, '\p{^NFD_Quick_Check=yes}', ""); +Expect(1, 271, '\P{NFD_Quick_Check=yes}', ""); +Expect(0, 271, '\P{^NFD_Quick_Check=yes}', ""); +Expect(1, 7, '\p{NFD_Quick_Check=YES}', ""); +Expect(0, 7, '\p{^NFD_Quick_Check=YES}', ""); +Expect(0, 7, '\P{NFD_Quick_Check=YES}', ""); +Expect(1, 7, '\P{^NFD_Quick_Check=YES}', ""); +Expect(0, 271, '\p{NFD_Quick_Check=YES}', ""); +Expect(1, 271, '\p{^NFD_Quick_Check=YES}', ""); +Expect(1, 271, '\P{NFD_Quick_Check=YES}', ""); +Expect(0, 271, '\P{^NFD_Quick_Check=YES}', ""); +Error('\p{NFD_QC=-Y/a/}'); +Error('\P{NFD_QC=-Y/a/}'); +Expect(1, 7, '\p{NFD_QC=y}', ""); +Expect(0, 7, '\p{^NFD_QC=y}', ""); +Expect(0, 7, '\P{NFD_QC=y}', ""); +Expect(1, 7, '\P{^NFD_QC=y}', ""); +Expect(0, 271, '\p{NFD_QC=y}', ""); +Expect(1, 271, '\p{^NFD_QC=y}', ""); +Expect(1, 271, '\P{NFD_QC=y}', ""); +Expect(0, 271, '\P{^NFD_QC=y}', ""); +Expect(1, 7, '\p{NFD_QC=_-Y}', ""); +Expect(0, 7, '\p{^NFD_QC=_-Y}', ""); +Expect(0, 7, '\P{NFD_QC=_-Y}', ""); +Expect(1, 7, '\P{^NFD_QC=_-Y}', ""); +Expect(0, 271, '\p{NFD_QC=_-Y}', ""); +Expect(1, 271, '\p{^NFD_QC=_-Y}', ""); +Expect(1, 271, '\P{NFD_QC=_-Y}', ""); +Expect(0, 271, '\P{^NFD_QC=_-Y}', ""); +Error('\p{Is_NFD_Quick_Check=/a/YES}'); +Error('\P{Is_NFD_Quick_Check=/a/YES}'); +Expect(1, 7, '\p{Is_NFD_Quick_Check=yes}', ""); +Expect(0, 7, '\p{^Is_NFD_Quick_Check=yes}', ""); +Expect(0, 7, '\P{Is_NFD_Quick_Check=yes}', ""); +Expect(1, 7, '\P{^Is_NFD_Quick_Check=yes}', ""); +Expect(0, 271, '\p{Is_NFD_Quick_Check=yes}', ""); +Expect(1, 271, '\p{^Is_NFD_Quick_Check=yes}', ""); +Expect(1, 271, '\P{Is_NFD_Quick_Check=yes}', ""); +Expect(0, 271, '\P{^Is_NFD_Quick_Check=yes}', ""); +Expect(1, 7, '\p{Is_NFD_Quick_Check=__Yes}', ""); +Expect(0, 7, '\p{^Is_NFD_Quick_Check=__Yes}', ""); +Expect(0, 7, '\P{Is_NFD_Quick_Check=__Yes}', ""); +Expect(1, 7, '\P{^Is_NFD_Quick_Check=__Yes}', ""); +Expect(0, 271, '\p{Is_NFD_Quick_Check=__Yes}', ""); +Expect(1, 271, '\p{^Is_NFD_Quick_Check=__Yes}', ""); +Expect(1, 271, '\P{Is_NFD_Quick_Check=__Yes}', ""); +Expect(0, 271, '\P{^Is_NFD_Quick_Check=__Yes}', ""); +Error('\p{Is_NFD_QC=:=Y}'); +Error('\P{Is_NFD_QC=:=Y}'); +Expect(1, 7, '\p{Is_NFD_QC=y}', ""); +Expect(0, 7, '\p{^Is_NFD_QC=y}', ""); +Expect(0, 7, '\P{Is_NFD_QC=y}', ""); +Expect(1, 7, '\P{^Is_NFD_QC=y}', ""); +Expect(0, 271, '\p{Is_NFD_QC=y}', ""); +Expect(1, 271, '\p{^Is_NFD_QC=y}', ""); +Expect(1, 271, '\P{Is_NFD_QC=y}', ""); +Expect(0, 271, '\P{^Is_NFD_QC=y}', ""); +Expect(1, 7, '\p{Is_NFD_QC=_ Y}', ""); +Expect(0, 7, '\p{^Is_NFD_QC=_ Y}', ""); +Expect(0, 7, '\P{Is_NFD_QC=_ Y}', ""); +Expect(1, 7, '\P{^Is_NFD_QC=_ Y}', ""); +Expect(0, 271, '\p{Is_NFD_QC=_ Y}', ""); +Expect(1, 271, '\p{^Is_NFD_QC=_ Y}', ""); +Expect(1, 271, '\P{Is_NFD_QC=_ Y}', ""); +Expect(0, 271, '\P{^Is_NFD_QC=_ Y}', ""); +Error('\p{NFD_Quick_Check: /a/-_NO}'); +Error('\P{NFD_Quick_Check: /a/-_NO}'); +Expect(1, 271, '\p{NFD_Quick_Check: no}', ""); +Expect(0, 271, '\p{^NFD_Quick_Check: no}', ""); +Expect(0, 271, '\P{NFD_Quick_Check: no}', ""); +Expect(1, 271, '\P{^NFD_Quick_Check: no}', ""); +Expect(0, 7, '\p{NFD_Quick_Check: no}', ""); +Expect(1, 7, '\p{^NFD_Quick_Check: no}', ""); +Expect(1, 7, '\P{NFD_Quick_Check: no}', ""); +Expect(0, 7, '\P{^NFD_Quick_Check: no}', ""); +Expect(1, 271, '\p{NFD_Quick_Check=_ no}', ""); +Expect(0, 271, '\p{^NFD_Quick_Check=_ no}', ""); +Expect(0, 271, '\P{NFD_Quick_Check=_ no}', ""); +Expect(1, 271, '\P{^NFD_Quick_Check=_ no}', ""); +Expect(0, 7, '\p{NFD_Quick_Check=_ no}', ""); +Expect(1, 7, '\p{^NFD_Quick_Check=_ no}', ""); +Expect(1, 7, '\P{NFD_Quick_Check=_ no}', ""); +Expect(0, 7, '\P{^NFD_Quick_Check=_ no}', ""); +Error('\p{NFD_QC=_N/a/}'); +Error('\P{NFD_QC=_N/a/}'); +Expect(1, 271, '\p{NFD_QC=n}', ""); +Expect(0, 271, '\p{^NFD_QC=n}', ""); +Expect(0, 271, '\P{NFD_QC=n}', ""); +Expect(1, 271, '\P{^NFD_QC=n}', ""); +Expect(0, 7, '\p{NFD_QC=n}', ""); +Expect(1, 7, '\p{^NFD_QC=n}', ""); +Expect(1, 7, '\P{NFD_QC=n}', ""); +Expect(0, 7, '\P{^NFD_QC=n}', ""); +Expect(1, 271, '\p{NFD_QC=-_N}', ""); +Expect(0, 271, '\p{^NFD_QC=-_N}', ""); +Expect(0, 271, '\P{NFD_QC=-_N}', ""); +Expect(1, 271, '\P{^NFD_QC=-_N}', ""); +Expect(0, 7, '\p{NFD_QC=-_N}', ""); +Expect(1, 7, '\p{^NFD_QC=-_N}', ""); +Expect(1, 7, '\P{NFD_QC=-_N}', ""); +Expect(0, 7, '\P{^NFD_QC=-_N}', ""); +Error('\p{Is_NFD_Quick_Check=:= no}'); +Error('\P{Is_NFD_Quick_Check=:= no}'); +Expect(1, 271, '\p{Is_NFD_Quick_Check=no}', ""); +Expect(0, 271, '\p{^Is_NFD_Quick_Check=no}', ""); +Expect(0, 271, '\P{Is_NFD_Quick_Check=no}', ""); +Expect(1, 271, '\P{^Is_NFD_Quick_Check=no}', ""); +Expect(0, 7, '\p{Is_NFD_Quick_Check=no}', ""); +Expect(1, 7, '\p{^Is_NFD_Quick_Check=no}', ""); +Expect(1, 7, '\P{Is_NFD_Quick_Check=no}', ""); +Expect(0, 7, '\P{^Is_NFD_Quick_Check=no}', ""); +Expect(1, 271, '\p{Is_NFD_Quick_Check=_ No}', ""); +Expect(0, 271, '\p{^Is_NFD_Quick_Check=_ No}', ""); +Expect(0, 271, '\P{Is_NFD_Quick_Check=_ No}', ""); +Expect(1, 271, '\P{^Is_NFD_Quick_Check=_ No}', ""); +Expect(0, 7, '\p{Is_NFD_Quick_Check=_ No}', ""); +Expect(1, 7, '\p{^Is_NFD_Quick_Check=_ No}', ""); +Expect(1, 7, '\P{Is_NFD_Quick_Check=_ No}', ""); +Expect(0, 7, '\P{^Is_NFD_Quick_Check=_ No}', ""); +Error('\p{Is_NFD_QC=/a/- N}'); +Error('\P{Is_NFD_QC=/a/- N}'); +Expect(1, 271, '\p{Is_NFD_QC=n}', ""); +Expect(0, 271, '\p{^Is_NFD_QC=n}', ""); +Expect(0, 271, '\P{Is_NFD_QC=n}', ""); +Expect(1, 271, '\P{^Is_NFD_QC=n}', ""); +Expect(0, 7, '\p{Is_NFD_QC=n}', ""); +Expect(1, 7, '\p{^Is_NFD_QC=n}', ""); +Expect(1, 7, '\P{Is_NFD_QC=n}', ""); +Expect(0, 7, '\P{^Is_NFD_QC=n}', ""); +Expect(1, 271, '\p{Is_NFD_QC=N}', ""); +Expect(0, 271, '\p{^Is_NFD_QC=N}', ""); +Expect(0, 271, '\P{Is_NFD_QC=N}', ""); +Expect(1, 271, '\P{^Is_NFD_QC=N}', ""); +Expect(0, 7, '\p{Is_NFD_QC=N}', ""); +Expect(1, 7, '\p{^Is_NFD_QC=N}', ""); +Expect(1, 7, '\P{Is_NFD_QC=N}', ""); +Expect(0, 7, '\P{^Is_NFD_QC=N}', ""); +Error('\p{Line_Break=:=space}'); +Error('\P{Line_Break=:=space}'); +Expect(1, 32, '\p{Line_Break=space}', ""); +Expect(0, 32, '\p{^Line_Break=space}', ""); +Expect(0, 32, '\P{Line_Break=space}', ""); +Expect(1, 32, '\P{^Line_Break=space}', ""); +Expect(0, 7, '\p{Line_Break=space}', ""); +Expect(1, 7, '\p{^Line_Break=space}', ""); +Expect(1, 7, '\P{Line_Break=space}', ""); +Expect(0, 7, '\P{^Line_Break=space}', ""); +Expect(1, 32, '\p{Line_Break: _Space}', ""); +Expect(0, 32, '\p{^Line_Break: _Space}', ""); +Expect(0, 32, '\P{Line_Break: _Space}', ""); +Expect(1, 32, '\P{^Line_Break: _Space}', ""); +Expect(0, 7, '\p{Line_Break: _Space}', ""); +Expect(1, 7, '\p{^Line_Break: _Space}', ""); +Expect(1, 7, '\P{Line_Break: _Space}', ""); +Expect(0, 7, '\P{^Line_Break: _Space}', ""); +Error('\p{Lb=:=SP}'); +Error('\P{Lb=:=SP}'); +Expect(1, 32, '\p{Lb=sp}', ""); +Expect(0, 32, '\p{^Lb=sp}', ""); +Expect(0, 32, '\P{Lb=sp}', ""); +Expect(1, 32, '\P{^Lb=sp}', ""); +Expect(0, 7, '\p{Lb=sp}', ""); +Expect(1, 7, '\p{^Lb=sp}', ""); +Expect(1, 7, '\P{Lb=sp}', ""); +Expect(0, 7, '\P{^Lb=sp}', ""); +Expect(1, 32, '\p{Lb= SP}', ""); +Expect(0, 32, '\p{^Lb= SP}', ""); +Expect(0, 32, '\P{Lb= SP}', ""); +Expect(1, 32, '\P{^Lb= SP}', ""); +Expect(0, 7, '\p{Lb= SP}', ""); +Expect(1, 7, '\p{^Lb= SP}', ""); +Expect(1, 7, '\P{Lb= SP}', ""); +Expect(0, 7, '\P{^Lb= SP}', ""); +Error('\p{Is_Line_Break=Space/a/}'); +Error('\P{Is_Line_Break=Space/a/}'); +Expect(1, 32, '\p{Is_Line_Break=space}', ""); +Expect(0, 32, '\p{^Is_Line_Break=space}', ""); +Expect(0, 32, '\P{Is_Line_Break=space}', ""); +Expect(1, 32, '\P{^Is_Line_Break=space}', ""); +Expect(0, 7, '\p{Is_Line_Break=space}', ""); +Expect(1, 7, '\p{^Is_Line_Break=space}', ""); +Expect(1, 7, '\P{Is_Line_Break=space}', ""); +Expect(0, 7, '\P{^Is_Line_Break=space}', ""); +Expect(1, 32, '\p{Is_Line_Break=__SPACE}', ""); +Expect(0, 32, '\p{^Is_Line_Break=__SPACE}', ""); +Expect(0, 32, '\P{Is_Line_Break=__SPACE}', ""); +Expect(1, 32, '\P{^Is_Line_Break=__SPACE}', ""); +Expect(0, 7, '\p{Is_Line_Break=__SPACE}', ""); +Expect(1, 7, '\p{^Is_Line_Break=__SPACE}', ""); +Expect(1, 7, '\P{Is_Line_Break=__SPACE}', ""); +Expect(0, 7, '\P{^Is_Line_Break=__SPACE}', ""); +Error('\p{Is_Lb=/a/_sp}'); +Error('\P{Is_Lb=/a/_sp}'); +Expect(1, 32, '\p{Is_Lb=sp}', ""); +Expect(0, 32, '\p{^Is_Lb=sp}', ""); +Expect(0, 32, '\P{Is_Lb=sp}', ""); +Expect(1, 32, '\P{^Is_Lb=sp}', ""); +Expect(0, 7, '\p{Is_Lb=sp}', ""); +Expect(1, 7, '\p{^Is_Lb=sp}', ""); +Expect(1, 7, '\P{Is_Lb=sp}', ""); +Expect(0, 7, '\P{^Is_Lb=sp}', ""); +Expect(1, 32, '\p{Is_Lb=-_SP}', ""); +Expect(0, 32, '\p{^Is_Lb=-_SP}', ""); +Expect(0, 32, '\P{Is_Lb=-_SP}', ""); +Expect(1, 32, '\P{^Is_Lb=-_SP}', ""); +Expect(0, 7, '\p{Is_Lb=-_SP}', ""); +Expect(1, 7, '\p{^Is_Lb=-_SP}', ""); +Expect(1, 7, '\P{Is_Lb=-_SP}', ""); +Expect(0, 7, '\P{^Is_Lb=-_SP}', ""); +Error('\p{Line_Break=:=GLUE}'); +Error('\P{Line_Break=:=GLUE}'); +Expect(1, 847, '\p{Line_Break=glue}', ""); +Expect(0, 847, '\p{^Line_Break=glue}', ""); +Expect(0, 847, '\P{Line_Break=glue}', ""); +Expect(1, 847, '\P{^Line_Break=glue}', ""); +Expect(0, 7, '\p{Line_Break=glue}', ""); +Expect(1, 7, '\p{^Line_Break=glue}', ""); +Expect(1, 7, '\P{Line_Break=glue}', ""); +Expect(0, 7, '\P{^Line_Break=glue}', ""); +Expect(1, 847, '\p{Line_Break=-_Glue}', ""); +Expect(0, 847, '\p{^Line_Break=-_Glue}', ""); +Expect(0, 847, '\P{Line_Break=-_Glue}', ""); +Expect(1, 847, '\P{^Line_Break=-_Glue}', ""); +Expect(0, 7, '\p{Line_Break=-_Glue}', ""); +Expect(1, 7, '\p{^Line_Break=-_Glue}', ""); +Expect(1, 7, '\P{Line_Break=-_Glue}', ""); +Expect(0, 7, '\P{^Line_Break=-_Glue}', ""); +Error('\p{Lb=/a/ GL}'); +Error('\P{Lb=/a/ GL}'); +Expect(1, 847, '\p{Lb: gl}', ""); +Expect(0, 847, '\p{^Lb: gl}', ""); +Expect(0, 847, '\P{Lb: gl}', ""); +Expect(1, 847, '\P{^Lb: gl}', ""); +Expect(0, 7, '\p{Lb: gl}', ""); +Expect(1, 7, '\p{^Lb: gl}', ""); +Expect(1, 7, '\P{Lb: gl}', ""); +Expect(0, 7, '\P{^Lb: gl}', ""); +Expect(1, 847, '\p{Lb= gl}', ""); +Expect(0, 847, '\p{^Lb= gl}', ""); +Expect(0, 847, '\P{Lb= gl}', ""); +Expect(1, 847, '\P{^Lb= gl}', ""); +Expect(0, 7, '\p{Lb= gl}', ""); +Expect(1, 7, '\p{^Lb= gl}', ""); +Expect(1, 7, '\P{Lb= gl}', ""); +Expect(0, 7, '\P{^Lb= gl}', ""); +Error('\p{Is_Line_Break=_Glue:=}'); +Error('\P{Is_Line_Break=_Glue:=}'); +Expect(1, 847, '\p{Is_Line_Break=glue}', ""); +Expect(0, 847, '\p{^Is_Line_Break=glue}', ""); +Expect(0, 847, '\P{Is_Line_Break=glue}', ""); +Expect(1, 847, '\P{^Is_Line_Break=glue}', ""); +Expect(0, 7, '\p{Is_Line_Break=glue}', ""); +Expect(1, 7, '\p{^Is_Line_Break=glue}', ""); +Expect(1, 7, '\P{Is_Line_Break=glue}', ""); +Expect(0, 7, '\P{^Is_Line_Break=glue}', ""); +Expect(1, 847, '\p{Is_Line_Break=_Glue}', ""); +Expect(0, 847, '\p{^Is_Line_Break=_Glue}', ""); +Expect(0, 847, '\P{Is_Line_Break=_Glue}', ""); +Expect(1, 847, '\P{^Is_Line_Break=_Glue}', ""); +Expect(0, 7, '\p{Is_Line_Break=_Glue}', ""); +Expect(1, 7, '\p{^Is_Line_Break=_Glue}', ""); +Expect(1, 7, '\P{Is_Line_Break=_Glue}', ""); +Expect(0, 7, '\P{^Is_Line_Break=_Glue}', ""); +Error('\p{Is_Lb=/a/ GL}'); +Error('\P{Is_Lb=/a/ GL}'); +Expect(1, 847, '\p{Is_Lb=gl}', ""); +Expect(0, 847, '\p{^Is_Lb=gl}', ""); +Expect(0, 847, '\P{Is_Lb=gl}', ""); +Expect(1, 847, '\P{^Is_Lb=gl}', ""); +Expect(0, 7, '\p{Is_Lb=gl}', ""); +Expect(1, 7, '\p{^Is_Lb=gl}', ""); +Expect(1, 7, '\P{Is_Lb=gl}', ""); +Expect(0, 7, '\P{^Is_Lb=gl}', ""); +Expect(1, 847, '\p{Is_Lb=_GL}', ""); +Expect(0, 847, '\p{^Is_Lb=_GL}', ""); +Expect(0, 847, '\P{Is_Lb=_GL}', ""); +Expect(1, 847, '\P{^Is_Lb=_GL}', ""); +Expect(0, 7, '\p{Is_Lb=_GL}', ""); +Expect(1, 7, '\p{^Is_Lb=_GL}', ""); +Expect(1, 7, '\P{Is_Lb=_GL}', ""); +Expect(0, 7, '\P{^Is_Lb=_GL}', ""); +Error('\p{Line_Break=- Surrogate/a/}'); +Error('\P{Line_Break=- Surrogate/a/}'); +Expect(0, 55295, '\p{Line_Break=surrogate}', 'deprecated'); +Expect(1, 55295, '\p{^Line_Break=surrogate}', 'deprecated'); +Expect(1, 55295, '\P{Line_Break=surrogate}', 'deprecated'); +Expect(0, 55295, '\P{^Line_Break=surrogate}', 'deprecated'); +Expect(0, 55295, '\p{Line_Break=_Surrogate}', 'deprecated'); +Expect(1, 55295, '\p{^Line_Break=_Surrogate}', 'deprecated'); +Expect(1, 55295, '\P{Line_Break=_Surrogate}', 'deprecated'); +Expect(0, 55295, '\P{^Line_Break=_Surrogate}', 'deprecated'); +Error('\p{Lb: /a/--SG}'); +Error('\P{Lb: /a/--SG}'); +Expect(0, 55295, '\p{Lb=sg}', 'deprecated'); +Expect(1, 55295, '\p{^Lb=sg}', 'deprecated'); +Expect(1, 55295, '\P{Lb=sg}', 'deprecated'); +Expect(0, 55295, '\P{^Lb=sg}', 'deprecated'); +Expect(0, 55295, '\p{Lb= SG}', 'deprecated'); +Expect(1, 55295, '\p{^Lb= SG}', 'deprecated'); +Expect(1, 55295, '\P{Lb= SG}', 'deprecated'); +Expect(0, 55295, '\P{^Lb= SG}', 'deprecated'); +Error('\p{Is_Line_Break= :=Surrogate}'); +Error('\P{Is_Line_Break= :=Surrogate}'); +Expect(0, 55295, '\p{Is_Line_Break=surrogate}', 'deprecated'); +Expect(1, 55295, '\p{^Is_Line_Break=surrogate}', 'deprecated'); +Expect(1, 55295, '\P{Is_Line_Break=surrogate}', 'deprecated'); +Expect(0, 55295, '\P{^Is_Line_Break=surrogate}', 'deprecated'); +Expect(0, 55295, '\p{Is_Line_Break=-Surrogate}', 'deprecated'); +Expect(1, 55295, '\p{^Is_Line_Break=-Surrogate}', 'deprecated'); +Expect(1, 55295, '\P{Is_Line_Break=-Surrogate}', 'deprecated'); +Expect(0, 55295, '\P{^Is_Line_Break=-Surrogate}', 'deprecated'); +Error('\p{Is_Lb=:=-_SG}'); +Error('\P{Is_Lb=:=-_SG}'); +Expect(0, 55295, '\p{Is_Lb=sg}', 'deprecated'); +Expect(1, 55295, '\p{^Is_Lb=sg}', 'deprecated'); +Expect(1, 55295, '\P{Is_Lb=sg}', 'deprecated'); +Expect(0, 55295, '\P{^Is_Lb=sg}', 'deprecated'); +Expect(0, 55295, '\p{Is_Lb= -SG}', 'deprecated'); +Expect(1, 55295, '\p{^Is_Lb= -SG}', 'deprecated'); +Expect(1, 55295, '\P{Is_Lb= -SG}', 'deprecated'); +Expect(0, 55295, '\P{^Is_Lb= -SG}', 'deprecated'); +Error('\p{Line_Break=_/a/Unknown}'); +Error('\P{Line_Break=_/a/Unknown}'); +Expect(1, 889, '\p{Line_Break=unknown}', ""); +Expect(0, 889, '\p{^Line_Break=unknown}', ""); +Expect(0, 889, '\P{Line_Break=unknown}', ""); +Expect(1, 889, '\P{^Line_Break=unknown}', ""); +Expect(0, 887, '\p{Line_Break=unknown}', ""); +Expect(1, 887, '\p{^Line_Break=unknown}', ""); +Expect(1, 887, '\P{Line_Break=unknown}', ""); +Expect(0, 887, '\P{^Line_Break=unknown}', ""); +Expect(1, 889, '\p{Line_Break: --Unknown}', ""); +Expect(0, 889, '\p{^Line_Break: --Unknown}', ""); +Expect(0, 889, '\P{Line_Break: --Unknown}', ""); +Expect(1, 889, '\P{^Line_Break: --Unknown}', ""); +Expect(0, 887, '\p{Line_Break: --Unknown}', ""); +Expect(1, 887, '\p{^Line_Break: --Unknown}', ""); +Expect(1, 887, '\P{Line_Break: --Unknown}', ""); +Expect(0, 887, '\P{^Line_Break: --Unknown}', ""); +Error('\p{Lb=/a/ -XX}'); +Error('\P{Lb=/a/ -XX}'); +Expect(1, 889, '\p{Lb=xx}', ""); +Expect(0, 889, '\p{^Lb=xx}', ""); +Expect(0, 889, '\P{Lb=xx}', ""); +Expect(1, 889, '\P{^Lb=xx}', ""); +Expect(0, 887, '\p{Lb=xx}', ""); +Expect(1, 887, '\p{^Lb=xx}', ""); +Expect(1, 887, '\P{Lb=xx}', ""); +Expect(0, 887, '\P{^Lb=xx}', ""); +Expect(1, 889, '\p{Lb=_ xx}', ""); +Expect(0, 889, '\p{^Lb=_ xx}', ""); +Expect(0, 889, '\P{Lb=_ xx}', ""); +Expect(1, 889, '\P{^Lb=_ xx}', ""); +Expect(0, 887, '\p{Lb=_ xx}', ""); +Expect(1, 887, '\p{^Lb=_ xx}', ""); +Expect(1, 887, '\P{Lb=_ xx}', ""); +Expect(0, 887, '\P{^Lb=_ xx}', ""); +Error('\p{Is_Line_Break=/a/Unknown}'); +Error('\P{Is_Line_Break=/a/Unknown}'); +Expect(1, 889, '\p{Is_Line_Break=unknown}', ""); +Expect(0, 889, '\p{^Is_Line_Break=unknown}', ""); +Expect(0, 889, '\P{Is_Line_Break=unknown}', ""); +Expect(1, 889, '\P{^Is_Line_Break=unknown}', ""); +Expect(0, 887, '\p{Is_Line_Break=unknown}', ""); +Expect(1, 887, '\p{^Is_Line_Break=unknown}', ""); +Expect(1, 887, '\P{Is_Line_Break=unknown}', ""); +Expect(0, 887, '\P{^Is_Line_Break=unknown}', ""); +Expect(1, 889, '\p{Is_Line_Break: -Unknown}', ""); +Expect(0, 889, '\p{^Is_Line_Break: -Unknown}', ""); +Expect(0, 889, '\P{Is_Line_Break: -Unknown}', ""); +Expect(1, 889, '\P{^Is_Line_Break: -Unknown}', ""); +Expect(0, 887, '\p{Is_Line_Break: -Unknown}', ""); +Expect(1, 887, '\p{^Is_Line_Break: -Unknown}', ""); +Expect(1, 887, '\P{Is_Line_Break: -Unknown}', ""); +Expect(0, 887, '\P{^Is_Line_Break: -Unknown}', ""); +Error('\p{Is_Lb: /a/-xx}'); +Error('\P{Is_Lb: /a/-xx}'); +Expect(1, 889, '\p{Is_Lb=xx}', ""); +Expect(0, 889, '\p{^Is_Lb=xx}', ""); +Expect(0, 889, '\P{Is_Lb=xx}', ""); +Expect(1, 889, '\P{^Is_Lb=xx}', ""); +Expect(0, 887, '\p{Is_Lb=xx}', ""); +Expect(1, 887, '\p{^Is_Lb=xx}', ""); +Expect(1, 887, '\P{Is_Lb=xx}', ""); +Expect(0, 887, '\P{^Is_Lb=xx}', ""); +Expect(1, 889, '\p{Is_Lb= XX}', ""); +Expect(0, 889, '\p{^Is_Lb= XX}', ""); +Expect(0, 889, '\P{Is_Lb= XX}', ""); +Expect(1, 889, '\P{^Is_Lb= XX}', ""); +Expect(0, 887, '\p{Is_Lb= XX}', ""); +Expect(1, 887, '\p{^Is_Lb= XX}', ""); +Expect(1, 887, '\P{Is_Lb= XX}', ""); +Expect(0, 887, '\P{^Is_Lb= XX}', ""); +Error('\p{Line_Break=NUMERIC:=}'); +Error('\P{Line_Break=NUMERIC:=}'); +Expect(1, 57, '\p{Line_Break: numeric}', ""); +Expect(0, 57, '\p{^Line_Break: numeric}', ""); +Expect(0, 57, '\P{Line_Break: numeric}', ""); +Expect(1, 57, '\P{^Line_Break: numeric}', ""); +Expect(0, 47, '\p{Line_Break: numeric}', ""); +Expect(1, 47, '\p{^Line_Break: numeric}', ""); +Expect(1, 47, '\P{Line_Break: numeric}', ""); +Expect(0, 47, '\P{^Line_Break: numeric}', ""); +Expect(1, 57, '\p{Line_Break= Numeric}', ""); +Expect(0, 57, '\p{^Line_Break= Numeric}', ""); +Expect(0, 57, '\P{Line_Break= Numeric}', ""); +Expect(1, 57, '\P{^Line_Break= Numeric}', ""); +Expect(0, 47, '\p{Line_Break= Numeric}', ""); +Expect(1, 47, '\p{^Line_Break= Numeric}', ""); +Expect(1, 47, '\P{Line_Break= Numeric}', ""); +Expect(0, 47, '\P{^Line_Break= Numeric}', ""); +Error('\p{Lb=/a/ NU}'); +Error('\P{Lb=/a/ NU}'); +Expect(1, 57, '\p{Lb=nu}', ""); +Expect(0, 57, '\p{^Lb=nu}', ""); +Expect(0, 57, '\P{Lb=nu}', ""); +Expect(1, 57, '\P{^Lb=nu}', ""); +Expect(0, 47, '\p{Lb=nu}', ""); +Expect(1, 47, '\p{^Lb=nu}', ""); +Expect(1, 47, '\P{Lb=nu}', ""); +Expect(0, 47, '\P{^Lb=nu}', ""); +Expect(1, 57, '\p{Lb=--NU}', ""); +Expect(0, 57, '\p{^Lb=--NU}', ""); +Expect(0, 57, '\P{Lb=--NU}', ""); +Expect(1, 57, '\P{^Lb=--NU}', ""); +Expect(0, 47, '\p{Lb=--NU}', ""); +Expect(1, 47, '\p{^Lb=--NU}', ""); +Expect(1, 47, '\P{Lb=--NU}', ""); +Expect(0, 47, '\P{^Lb=--NU}', ""); +Error('\p{Is_Line_Break=- NUMERIC/a/}'); +Error('\P{Is_Line_Break=- NUMERIC/a/}'); +Expect(1, 57, '\p{Is_Line_Break=numeric}', ""); +Expect(0, 57, '\p{^Is_Line_Break=numeric}', ""); +Expect(0, 57, '\P{Is_Line_Break=numeric}', ""); +Expect(1, 57, '\P{^Is_Line_Break=numeric}', ""); +Expect(0, 47, '\p{Is_Line_Break=numeric}', ""); +Expect(1, 47, '\p{^Is_Line_Break=numeric}', ""); +Expect(1, 47, '\P{Is_Line_Break=numeric}', ""); +Expect(0, 47, '\P{^Is_Line_Break=numeric}', ""); +Expect(1, 57, '\p{Is_Line_Break= Numeric}', ""); +Expect(0, 57, '\p{^Is_Line_Break= Numeric}', ""); +Expect(0, 57, '\P{Is_Line_Break= Numeric}', ""); +Expect(1, 57, '\P{^Is_Line_Break= Numeric}', ""); +Expect(0, 47, '\p{Is_Line_Break= Numeric}', ""); +Expect(1, 47, '\p{^Is_Line_Break= Numeric}', ""); +Expect(1, 47, '\P{Is_Line_Break= Numeric}', ""); +Expect(0, 47, '\P{^Is_Line_Break= Numeric}', ""); +Error('\p{Is_Lb=_ NU/a/}'); +Error('\P{Is_Lb=_ NU/a/}'); +Expect(1, 57, '\p{Is_Lb=nu}', ""); +Expect(0, 57, '\p{^Is_Lb=nu}', ""); +Expect(0, 57, '\P{Is_Lb=nu}', ""); +Expect(1, 57, '\P{^Is_Lb=nu}', ""); +Expect(0, 47, '\p{Is_Lb=nu}', ""); +Expect(1, 47, '\p{^Is_Lb=nu}', ""); +Expect(1, 47, '\P{Is_Lb=nu}', ""); +Expect(0, 47, '\P{^Is_Lb=nu}', ""); +Expect(1, 57, '\p{Is_Lb= -nu}', ""); +Expect(0, 57, '\p{^Is_Lb= -nu}', ""); +Expect(0, 57, '\P{Is_Lb= -nu}', ""); +Expect(1, 57, '\P{^Is_Lb= -nu}', ""); +Expect(0, 47, '\p{Is_Lb= -nu}', ""); +Expect(1, 47, '\p{^Is_Lb= -nu}', ""); +Expect(1, 47, '\P{Is_Lb= -nu}', ""); +Expect(0, 47, '\P{^Is_Lb= -nu}', ""); +Error('\p{Line_Break=:= -BREAK-before}'); +Error('\P{Line_Break=:= -BREAK-before}'); +Expect(1, 712, '\p{Line_Break=breakbefore}', ""); +Expect(0, 712, '\p{^Line_Break=breakbefore}', ""); +Expect(0, 712, '\P{Line_Break=breakbefore}', ""); +Expect(1, 712, '\P{^Line_Break=breakbefore}', ""); +Expect(0, 7, '\p{Line_Break=breakbefore}', ""); +Expect(1, 7, '\p{^Line_Break=breakbefore}', ""); +Expect(1, 7, '\P{Line_Break=breakbefore}', ""); +Expect(0, 7, '\P{^Line_Break=breakbefore}', ""); +Expect(1, 712, '\p{Line_Break= Breakbefore}', ""); +Expect(0, 712, '\p{^Line_Break= Breakbefore}', ""); +Expect(0, 712, '\P{Line_Break= Breakbefore}', ""); +Expect(1, 712, '\P{^Line_Break= Breakbefore}', ""); +Expect(0, 7, '\p{Line_Break= Breakbefore}', ""); +Expect(1, 7, '\p{^Line_Break= Breakbefore}', ""); +Expect(1, 7, '\P{Line_Break= Breakbefore}', ""); +Expect(0, 7, '\P{^Line_Break= Breakbefore}', ""); +Error('\p{Lb=/a/BB}'); +Error('\P{Lb=/a/BB}'); +Expect(1, 712, '\p{Lb=bb}', ""); +Expect(0, 712, '\p{^Lb=bb}', ""); +Expect(0, 712, '\P{Lb=bb}', ""); +Expect(1, 712, '\P{^Lb=bb}', ""); +Expect(0, 7, '\p{Lb=bb}', ""); +Expect(1, 7, '\p{^Lb=bb}', ""); +Expect(1, 7, '\P{Lb=bb}', ""); +Expect(0, 7, '\P{^Lb=bb}', ""); +Expect(1, 712, '\p{Lb=_ bb}', ""); +Expect(0, 712, '\p{^Lb=_ bb}', ""); +Expect(0, 712, '\P{Lb=_ bb}', ""); +Expect(1, 712, '\P{^Lb=_ bb}', ""); +Expect(0, 7, '\p{Lb=_ bb}', ""); +Expect(1, 7, '\p{^Lb=_ bb}', ""); +Expect(1, 7, '\P{Lb=_ bb}', ""); +Expect(0, 7, '\P{^Lb=_ bb}', ""); +Error('\p{Is_Line_Break=_:=break Before}'); +Error('\P{Is_Line_Break=_:=break Before}'); +Expect(1, 712, '\p{Is_Line_Break=breakbefore}', ""); +Expect(0, 712, '\p{^Is_Line_Break=breakbefore}', ""); +Expect(0, 712, '\P{Is_Line_Break=breakbefore}', ""); +Expect(1, 712, '\P{^Is_Line_Break=breakbefore}', ""); +Expect(0, 7, '\p{Is_Line_Break=breakbefore}', ""); +Expect(1, 7, '\p{^Is_Line_Break=breakbefore}', ""); +Expect(1, 7, '\P{Is_Line_Break=breakbefore}', ""); +Expect(0, 7, '\P{^Is_Line_Break=breakbefore}', ""); +Expect(1, 712, '\p{Is_Line_Break=-_break BEFORE}', ""); +Expect(0, 712, '\p{^Is_Line_Break=-_break BEFORE}', ""); +Expect(0, 712, '\P{Is_Line_Break=-_break BEFORE}', ""); +Expect(1, 712, '\P{^Is_Line_Break=-_break BEFORE}', ""); +Expect(0, 7, '\p{Is_Line_Break=-_break BEFORE}', ""); +Expect(1, 7, '\p{^Is_Line_Break=-_break BEFORE}', ""); +Expect(1, 7, '\P{Is_Line_Break=-_break BEFORE}', ""); +Expect(0, 7, '\P{^Is_Line_Break=-_break BEFORE}', ""); +Error('\p{Is_Lb=-/a/bb}'); +Error('\P{Is_Lb=-/a/bb}'); +Expect(1, 712, '\p{Is_Lb=bb}', ""); +Expect(0, 712, '\p{^Is_Lb=bb}', ""); +Expect(0, 712, '\P{Is_Lb=bb}', ""); +Expect(1, 712, '\P{^Is_Lb=bb}', ""); +Expect(0, 7, '\p{Is_Lb=bb}', ""); +Expect(1, 7, '\p{^Is_Lb=bb}', ""); +Expect(1, 7, '\P{Is_Lb=bb}', ""); +Expect(0, 7, '\P{^Is_Lb=bb}', ""); +Expect(1, 712, '\p{Is_Lb= bb}', ""); +Expect(0, 712, '\p{^Is_Lb= bb}', ""); +Expect(0, 712, '\P{Is_Lb= bb}', ""); +Expect(1, 712, '\P{^Is_Lb= bb}', ""); +Expect(0, 7, '\p{Is_Lb= bb}', ""); +Expect(1, 7, '\p{^Is_Lb= bb}', ""); +Expect(1, 7, '\P{Is_Lb= bb}', ""); +Expect(0, 7, '\P{^Is_Lb= bb}', ""); +Error('\p{Line_Break: /a/ZWSPACE}'); +Error('\P{Line_Break: /a/ZWSPACE}'); +Expect(1, 8203, '\p{Line_Break:zwspace}', ""); +Expect(0, 8203, '\p{^Line_Break:zwspace}', ""); +Expect(0, 8203, '\P{Line_Break:zwspace}', ""); +Expect(1, 8203, '\P{^Line_Break:zwspace}', ""); +Expect(0, 8202, '\p{Line_Break:zwspace}', ""); +Expect(1, 8202, '\p{^Line_Break:zwspace}', ""); +Expect(1, 8202, '\P{Line_Break:zwspace}', ""); +Expect(0, 8202, '\P{^Line_Break:zwspace}', ""); +Expect(1, 8203, '\p{Line_Break= zwspace}', ""); +Expect(0, 8203, '\p{^Line_Break= zwspace}', ""); +Expect(0, 8203, '\P{Line_Break= zwspace}', ""); +Expect(1, 8203, '\P{^Line_Break= zwspace}', ""); +Expect(0, 8202, '\p{Line_Break= zwspace}', ""); +Expect(1, 8202, '\p{^Line_Break= zwspace}', ""); +Expect(1, 8202, '\P{Line_Break= zwspace}', ""); +Expect(0, 8202, '\P{^Line_Break= zwspace}', ""); +Error('\p{Lb: := zw}'); +Error('\P{Lb: := zw}'); +Expect(1, 8203, '\p{Lb=zw}', ""); +Expect(0, 8203, '\p{^Lb=zw}', ""); +Expect(0, 8203, '\P{Lb=zw}', ""); +Expect(1, 8203, '\P{^Lb=zw}', ""); +Expect(0, 8202, '\p{Lb=zw}', ""); +Expect(1, 8202, '\p{^Lb=zw}', ""); +Expect(1, 8202, '\P{Lb=zw}', ""); +Expect(0, 8202, '\P{^Lb=zw}', ""); +Expect(1, 8203, '\p{Lb= _ZW}', ""); +Expect(0, 8203, '\p{^Lb= _ZW}', ""); +Expect(0, 8203, '\P{Lb= _ZW}', ""); +Expect(1, 8203, '\P{^Lb= _ZW}', ""); +Expect(0, 8202, '\p{Lb= _ZW}', ""); +Expect(1, 8202, '\p{^Lb= _ZW}', ""); +Expect(1, 8202, '\P{Lb= _ZW}', ""); +Expect(0, 8202, '\P{^Lb= _ZW}', ""); +Error('\p{Is_Line_Break= :=ZWSpace}'); +Error('\P{Is_Line_Break= :=ZWSpace}'); +Expect(1, 8203, '\p{Is_Line_Break=zwspace}', ""); +Expect(0, 8203, '\p{^Is_Line_Break=zwspace}', ""); +Expect(0, 8203, '\P{Is_Line_Break=zwspace}', ""); +Expect(1, 8203, '\P{^Is_Line_Break=zwspace}', ""); +Expect(0, 8202, '\p{Is_Line_Break=zwspace}', ""); +Expect(1, 8202, '\p{^Is_Line_Break=zwspace}', ""); +Expect(1, 8202, '\P{Is_Line_Break=zwspace}', ""); +Expect(0, 8202, '\P{^Is_Line_Break=zwspace}', ""); +Expect(1, 8203, '\p{Is_Line_Break= _zwspace}', ""); +Expect(0, 8203, '\p{^Is_Line_Break= _zwspace}', ""); +Expect(0, 8203, '\P{Is_Line_Break= _zwspace}', ""); +Expect(1, 8203, '\P{^Is_Line_Break= _zwspace}', ""); +Expect(0, 8202, '\p{Is_Line_Break= _zwspace}', ""); +Expect(1, 8202, '\p{^Is_Line_Break= _zwspace}', ""); +Expect(1, 8202, '\P{Is_Line_Break= _zwspace}', ""); +Expect(0, 8202, '\P{^Is_Line_Break= _zwspace}', ""); +Error('\p{Is_Lb=-_ZW/a/}'); +Error('\P{Is_Lb=-_ZW/a/}'); +Expect(1, 8203, '\p{Is_Lb=zw}', ""); +Expect(0, 8203, '\p{^Is_Lb=zw}', ""); +Expect(0, 8203, '\P{Is_Lb=zw}', ""); +Expect(1, 8203, '\P{^Is_Lb=zw}', ""); +Expect(0, 8202, '\p{Is_Lb=zw}', ""); +Expect(1, 8202, '\p{^Is_Lb=zw}', ""); +Expect(1, 8202, '\P{Is_Lb=zw}', ""); +Expect(0, 8202, '\P{^Is_Lb=zw}', ""); +Expect(1, 8203, '\p{Is_Lb= ZW}', ""); +Expect(0, 8203, '\p{^Is_Lb= ZW}', ""); +Expect(0, 8203, '\P{Is_Lb= ZW}', ""); +Expect(1, 8203, '\P{^Is_Lb= ZW}', ""); +Expect(0, 8202, '\p{Is_Lb= ZW}', ""); +Expect(1, 8202, '\p{^Is_Lb= ZW}', ""); +Expect(1, 8202, '\P{Is_Lb= ZW}', ""); +Expect(0, 8202, '\P{^Is_Lb= ZW}', ""); +Error('\p{Line_Break= JL/a/}'); +Error('\P{Line_Break= JL/a/}'); +Expect(1, 4441, '\p{Line_Break=jl}', ""); +Expect(0, 4441, '\p{^Line_Break=jl}', ""); +Expect(0, 4441, '\P{Line_Break=jl}', ""); +Expect(1, 4441, '\P{^Line_Break=jl}', ""); +Expect(0, 4351, '\p{Line_Break=jl}', ""); +Expect(1, 4351, '\p{^Line_Break=jl}', ""); +Expect(1, 4351, '\P{Line_Break=jl}', ""); +Expect(0, 4351, '\P{^Line_Break=jl}', ""); +Expect(1, 4441, '\p{Line_Break:_ jl}', ""); +Expect(0, 4441, '\p{^Line_Break:_ jl}', ""); +Expect(0, 4441, '\P{Line_Break:_ jl}', ""); +Expect(1, 4441, '\P{^Line_Break:_ jl}', ""); +Expect(0, 4351, '\p{Line_Break:_ jl}', ""); +Expect(1, 4351, '\p{^Line_Break:_ jl}', ""); +Expect(1, 4351, '\P{Line_Break:_ jl}', ""); +Expect(0, 4351, '\P{^Line_Break:_ jl}', ""); +Error('\p{Lb=:=JL}'); +Error('\P{Lb=:=JL}'); +Expect(1, 4441, '\p{Lb=jl}', ""); +Expect(0, 4441, '\p{^Lb=jl}', ""); +Expect(0, 4441, '\P{Lb=jl}', ""); +Expect(1, 4441, '\P{^Lb=jl}', ""); +Expect(0, 4351, '\p{Lb=jl}', ""); +Expect(1, 4351, '\p{^Lb=jl}', ""); +Expect(1, 4351, '\P{Lb=jl}', ""); +Expect(0, 4351, '\P{^Lb=jl}', ""); +Expect(1, 4441, '\p{Lb= JL}', ""); +Expect(0, 4441, '\p{^Lb= JL}', ""); +Expect(0, 4441, '\P{Lb= JL}', ""); +Expect(1, 4441, '\P{^Lb= JL}', ""); +Expect(0, 4351, '\p{Lb= JL}', ""); +Expect(1, 4351, '\p{^Lb= JL}', ""); +Expect(1, 4351, '\P{Lb= JL}', ""); +Expect(0, 4351, '\P{^Lb= JL}', ""); +Error('\p{Is_Line_Break= JL/a/}'); +Error('\P{Is_Line_Break= JL/a/}'); +Expect(1, 4441, '\p{Is_Line_Break=jl}', ""); +Expect(0, 4441, '\p{^Is_Line_Break=jl}', ""); +Expect(0, 4441, '\P{Is_Line_Break=jl}', ""); +Expect(1, 4441, '\P{^Is_Line_Break=jl}', ""); +Expect(0, 4351, '\p{Is_Line_Break=jl}', ""); +Expect(1, 4351, '\p{^Is_Line_Break=jl}', ""); +Expect(1, 4351, '\P{Is_Line_Break=jl}', ""); +Expect(0, 4351, '\P{^Is_Line_Break=jl}', ""); +Expect(1, 4441, '\p{Is_Line_Break: JL}', ""); +Expect(0, 4441, '\p{^Is_Line_Break: JL}', ""); +Expect(0, 4441, '\P{Is_Line_Break: JL}', ""); +Expect(1, 4441, '\P{^Is_Line_Break: JL}', ""); +Expect(0, 4351, '\p{Is_Line_Break: JL}', ""); +Expect(1, 4351, '\p{^Is_Line_Break: JL}', ""); +Expect(1, 4351, '\P{Is_Line_Break: JL}', ""); +Expect(0, 4351, '\P{^Is_Line_Break: JL}', ""); +Error('\p{Is_Lb=-/a/JL}'); +Error('\P{Is_Lb=-/a/JL}'); +Expect(1, 4441, '\p{Is_Lb=jl}', ""); +Expect(0, 4441, '\p{^Is_Lb=jl}', ""); +Expect(0, 4441, '\P{Is_Lb=jl}', ""); +Expect(1, 4441, '\P{^Is_Lb=jl}', ""); +Expect(0, 4351, '\p{Is_Lb=jl}', ""); +Expect(1, 4351, '\p{^Is_Lb=jl}', ""); +Expect(1, 4351, '\P{Is_Lb=jl}', ""); +Expect(0, 4351, '\P{^Is_Lb=jl}', ""); +Expect(1, 4441, '\p{Is_Lb= _JL}', ""); +Expect(0, 4441, '\p{^Is_Lb= _JL}', ""); +Expect(0, 4441, '\P{Is_Lb= _JL}', ""); +Expect(1, 4441, '\P{^Is_Lb= _JL}', ""); +Expect(0, 4351, '\p{Is_Lb= _JL}', ""); +Expect(1, 4351, '\p{^Is_Lb= _JL}', ""); +Expect(1, 4351, '\P{Is_Lb= _JL}', ""); +Expect(0, 4351, '\P{^Is_Lb= _JL}', ""); +Error('\p{Line_Break::= Break Symbols}'); +Error('\P{Line_Break::= Break Symbols}'); +Expect(1, 47, '\p{Line_Break=breaksymbols}', ""); +Expect(0, 47, '\p{^Line_Break=breaksymbols}', ""); +Expect(0, 47, '\P{Line_Break=breaksymbols}', ""); +Expect(1, 47, '\P{^Line_Break=breaksymbols}', ""); +Expect(0, 46, '\p{Line_Break=breaksymbols}', ""); +Expect(1, 46, '\p{^Line_Break=breaksymbols}', ""); +Expect(1, 46, '\P{Line_Break=breaksymbols}', ""); +Expect(0, 46, '\P{^Line_Break=breaksymbols}', ""); +Expect(1, 47, '\p{Line_Break=_BREAK SYMBOLS}', ""); +Expect(0, 47, '\p{^Line_Break=_BREAK SYMBOLS}', ""); +Expect(0, 47, '\P{Line_Break=_BREAK SYMBOLS}', ""); +Expect(1, 47, '\P{^Line_Break=_BREAK SYMBOLS}', ""); +Expect(0, 46, '\p{Line_Break=_BREAK SYMBOLS}', ""); +Expect(1, 46, '\p{^Line_Break=_BREAK SYMBOLS}', ""); +Expect(1, 46, '\P{Line_Break=_BREAK SYMBOLS}', ""); +Expect(0, 46, '\P{^Line_Break=_BREAK SYMBOLS}', ""); +Error('\p{Lb= SY/a/}'); +Error('\P{Lb= SY/a/}'); +Expect(1, 47, '\p{Lb=sy}', ""); +Expect(0, 47, '\p{^Lb=sy}', ""); +Expect(0, 47, '\P{Lb=sy}', ""); +Expect(1, 47, '\P{^Lb=sy}', ""); +Expect(0, 46, '\p{Lb=sy}', ""); +Expect(1, 46, '\p{^Lb=sy}', ""); +Expect(1, 46, '\P{Lb=sy}', ""); +Expect(0, 46, '\P{^Lb=sy}', ""); +Expect(1, 47, '\p{Lb=_ SY}', ""); +Expect(0, 47, '\p{^Lb=_ SY}', ""); +Expect(0, 47, '\P{Lb=_ SY}', ""); +Expect(1, 47, '\P{^Lb=_ SY}', ""); +Expect(0, 46, '\p{Lb=_ SY}', ""); +Expect(1, 46, '\p{^Lb=_ SY}', ""); +Expect(1, 46, '\P{Lb=_ SY}', ""); +Expect(0, 46, '\P{^Lb=_ SY}', ""); +Error('\p{Is_Line_Break=:=_BREAK_SYMBOLS}'); +Error('\P{Is_Line_Break=:=_BREAK_SYMBOLS}'); +Expect(1, 47, '\p{Is_Line_Break=breaksymbols}', ""); +Expect(0, 47, '\p{^Is_Line_Break=breaksymbols}', ""); +Expect(0, 47, '\P{Is_Line_Break=breaksymbols}', ""); +Expect(1, 47, '\P{^Is_Line_Break=breaksymbols}', ""); +Expect(0, 46, '\p{Is_Line_Break=breaksymbols}', ""); +Expect(1, 46, '\p{^Is_Line_Break=breaksymbols}', ""); +Expect(1, 46, '\P{Is_Line_Break=breaksymbols}', ""); +Expect(0, 46, '\P{^Is_Line_Break=breaksymbols}', ""); +Expect(1, 47, '\p{Is_Line_Break=_ Break Symbols}', ""); +Expect(0, 47, '\p{^Is_Line_Break=_ Break Symbols}', ""); +Expect(0, 47, '\P{Is_Line_Break=_ Break Symbols}', ""); +Expect(1, 47, '\P{^Is_Line_Break=_ Break Symbols}', ""); +Expect(0, 46, '\p{Is_Line_Break=_ Break Symbols}', ""); +Expect(1, 46, '\p{^Is_Line_Break=_ Break Symbols}', ""); +Expect(1, 46, '\P{Is_Line_Break=_ Break Symbols}', ""); +Expect(0, 46, '\P{^Is_Line_Break=_ Break Symbols}', ""); +Error('\p{Is_Lb=- SY/a/}'); +Error('\P{Is_Lb=- SY/a/}'); +Expect(1, 47, '\p{Is_Lb=sy}', ""); +Expect(0, 47, '\p{^Is_Lb=sy}', ""); +Expect(0, 47, '\P{Is_Lb=sy}', ""); +Expect(1, 47, '\P{^Is_Lb=sy}', ""); +Expect(0, 46, '\p{Is_Lb=sy}', ""); +Expect(1, 46, '\p{^Is_Lb=sy}', ""); +Expect(1, 46, '\P{Is_Lb=sy}', ""); +Expect(0, 46, '\P{^Is_Lb=sy}', ""); +Expect(1, 47, '\p{Is_Lb=--SY}', ""); +Expect(0, 47, '\p{^Is_Lb=--SY}', ""); +Expect(0, 47, '\P{Is_Lb=--SY}', ""); +Expect(1, 47, '\P{^Is_Lb=--SY}', ""); +Expect(0, 46, '\p{Is_Lb=--SY}', ""); +Expect(1, 46, '\p{^Is_Lb=--SY}', ""); +Expect(1, 46, '\P{Is_Lb=--SY}', ""); +Expect(0, 46, '\P{^Is_Lb=--SY}', ""); +Error('\p{Line_Break: /a/--PREFIX NUMERIC}'); +Error('\P{Line_Break: /a/--PREFIX NUMERIC}'); +Expect(1, 36, '\p{Line_Break=prefixnumeric}', ""); +Expect(0, 36, '\p{^Line_Break=prefixnumeric}', ""); +Expect(0, 36, '\P{Line_Break=prefixnumeric}', ""); +Expect(1, 36, '\P{^Line_Break=prefixnumeric}', ""); +Expect(0, 35, '\p{Line_Break=prefixnumeric}', ""); +Expect(1, 35, '\p{^Line_Break=prefixnumeric}', ""); +Expect(1, 35, '\P{Line_Break=prefixnumeric}', ""); +Expect(0, 35, '\P{^Line_Break=prefixnumeric}', ""); +Expect(1, 36, '\p{Line_Break=- Prefix_Numeric}', ""); +Expect(0, 36, '\p{^Line_Break=- Prefix_Numeric}', ""); +Expect(0, 36, '\P{Line_Break=- Prefix_Numeric}', ""); +Expect(1, 36, '\P{^Line_Break=- Prefix_Numeric}', ""); +Expect(0, 35, '\p{Line_Break=- Prefix_Numeric}', ""); +Expect(1, 35, '\p{^Line_Break=- Prefix_Numeric}', ""); +Expect(1, 35, '\P{Line_Break=- Prefix_Numeric}', ""); +Expect(0, 35, '\P{^Line_Break=- Prefix_Numeric}', ""); +Error('\p{Lb=/a/pr}'); +Error('\P{Lb=/a/pr}'); +Expect(1, 36, '\p{Lb=pr}', ""); +Expect(0, 36, '\p{^Lb=pr}', ""); +Expect(0, 36, '\P{Lb=pr}', ""); +Expect(1, 36, '\P{^Lb=pr}', ""); +Expect(0, 35, '\p{Lb=pr}', ""); +Expect(1, 35, '\p{^Lb=pr}', ""); +Expect(1, 35, '\P{Lb=pr}', ""); +Expect(0, 35, '\P{^Lb=pr}', ""); +Expect(1, 36, '\p{Lb= _pr}', ""); +Expect(0, 36, '\p{^Lb= _pr}', ""); +Expect(0, 36, '\P{Lb= _pr}', ""); +Expect(1, 36, '\P{^Lb= _pr}', ""); +Expect(0, 35, '\p{Lb= _pr}', ""); +Expect(1, 35, '\p{^Lb= _pr}', ""); +Expect(1, 35, '\P{Lb= _pr}', ""); +Expect(0, 35, '\P{^Lb= _pr}', ""); +Error('\p{Is_Line_Break=_ PREFIX:=numeric}'); +Error('\P{Is_Line_Break=_ PREFIX:=numeric}'); +Expect(1, 36, '\p{Is_Line_Break=prefixnumeric}', ""); +Expect(0, 36, '\p{^Is_Line_Break=prefixnumeric}', ""); +Expect(0, 36, '\P{Is_Line_Break=prefixnumeric}', ""); +Expect(1, 36, '\P{^Is_Line_Break=prefixnumeric}', ""); +Expect(0, 35, '\p{Is_Line_Break=prefixnumeric}', ""); +Expect(1, 35, '\p{^Is_Line_Break=prefixnumeric}', ""); +Expect(1, 35, '\P{Is_Line_Break=prefixnumeric}', ""); +Expect(0, 35, '\P{^Is_Line_Break=prefixnumeric}', ""); +Expect(1, 36, '\p{Is_Line_Break=-_prefix NUMERIC}', ""); +Expect(0, 36, '\p{^Is_Line_Break=-_prefix NUMERIC}', ""); +Expect(0, 36, '\P{Is_Line_Break=-_prefix NUMERIC}', ""); +Expect(1, 36, '\P{^Is_Line_Break=-_prefix NUMERIC}', ""); +Expect(0, 35, '\p{Is_Line_Break=-_prefix NUMERIC}', ""); +Expect(1, 35, '\p{^Is_Line_Break=-_prefix NUMERIC}', ""); +Expect(1, 35, '\P{Is_Line_Break=-_prefix NUMERIC}', ""); +Expect(0, 35, '\P{^Is_Line_Break=-_prefix NUMERIC}', ""); +Error('\p{Is_Lb=/a/-PR}'); +Error('\P{Is_Lb=/a/-PR}'); +Expect(1, 36, '\p{Is_Lb: pr}', ""); +Expect(0, 36, '\p{^Is_Lb: pr}', ""); +Expect(0, 36, '\P{Is_Lb: pr}', ""); +Expect(1, 36, '\P{^Is_Lb: pr}', ""); +Expect(0, 35, '\p{Is_Lb: pr}', ""); +Expect(1, 35, '\p{^Is_Lb: pr}', ""); +Expect(1, 35, '\P{Is_Lb: pr}', ""); +Expect(0, 35, '\P{^Is_Lb: pr}', ""); +Expect(1, 36, '\p{Is_Lb= _PR}', ""); +Expect(0, 36, '\p{^Is_Lb= _PR}', ""); +Expect(0, 36, '\P{Is_Lb= _PR}', ""); +Expect(1, 36, '\P{^Is_Lb= _PR}', ""); +Expect(0, 35, '\p{Is_Lb= _PR}', ""); +Expect(1, 35, '\p{^Is_Lb= _PR}', ""); +Expect(1, 35, '\P{Is_Lb= _PR}', ""); +Expect(0, 35, '\P{^Is_Lb= _PR}', ""); +Error('\p{Line_Break= h3:=}'); +Error('\P{Line_Break= h3:=}'); +Expect(1, 44059, '\p{Line_Break=h3}', ""); +Expect(0, 44059, '\p{^Line_Break=h3}', ""); +Expect(0, 44059, '\P{Line_Break=h3}', ""); +Expect(1, 44059, '\P{^Line_Break=h3}', ""); +Expect(0, 44032, '\p{Line_Break=h3}', ""); +Expect(1, 44032, '\p{^Line_Break=h3}', ""); +Expect(1, 44032, '\P{Line_Break=h3}', ""); +Expect(0, 44032, '\P{^Line_Break=h3}', ""); +Expect(1, 44059, '\p{Line_Break=_-H3}', ""); +Expect(0, 44059, '\p{^Line_Break=_-H3}', ""); +Expect(0, 44059, '\P{Line_Break=_-H3}', ""); +Expect(1, 44059, '\P{^Line_Break=_-H3}', ""); +Expect(0, 44032, '\p{Line_Break=_-H3}', ""); +Expect(1, 44032, '\p{^Line_Break=_-H3}', ""); +Expect(1, 44032, '\P{Line_Break=_-H3}', ""); +Expect(0, 44032, '\P{^Line_Break=_-H3}', ""); +Error('\p{Lb=_ h3:=}'); +Error('\P{Lb=_ h3:=}'); +Expect(1, 44059, '\p{Lb=h3}', ""); +Expect(0, 44059, '\p{^Lb=h3}', ""); +Expect(0, 44059, '\P{Lb=h3}', ""); +Expect(1, 44059, '\P{^Lb=h3}', ""); +Expect(0, 44032, '\p{Lb=h3}', ""); +Expect(1, 44032, '\p{^Lb=h3}', ""); +Expect(1, 44032, '\P{Lb=h3}', ""); +Expect(0, 44032, '\P{^Lb=h3}', ""); +Expect(1, 44059, '\p{Lb=-H3}', ""); +Expect(0, 44059, '\p{^Lb=-H3}', ""); +Expect(0, 44059, '\P{Lb=-H3}', ""); +Expect(1, 44059, '\P{^Lb=-H3}', ""); +Expect(0, 44032, '\p{Lb=-H3}', ""); +Expect(1, 44032, '\p{^Lb=-H3}', ""); +Expect(1, 44032, '\P{Lb=-H3}', ""); +Expect(0, 44032, '\P{^Lb=-H3}', ""); +Error('\p{Is_Line_Break=:=-_H3}'); +Error('\P{Is_Line_Break=:=-_H3}'); +Expect(1, 44059, '\p{Is_Line_Break=h3}', ""); +Expect(0, 44059, '\p{^Is_Line_Break=h3}', ""); +Expect(0, 44059, '\P{Is_Line_Break=h3}', ""); +Expect(1, 44059, '\P{^Is_Line_Break=h3}', ""); +Expect(0, 44032, '\p{Is_Line_Break=h3}', ""); +Expect(1, 44032, '\p{^Is_Line_Break=h3}', ""); +Expect(1, 44032, '\P{Is_Line_Break=h3}', ""); +Expect(0, 44032, '\P{^Is_Line_Break=h3}', ""); +Expect(1, 44059, '\p{Is_Line_Break= _H3}', ""); +Expect(0, 44059, '\p{^Is_Line_Break= _H3}', ""); +Expect(0, 44059, '\P{Is_Line_Break= _H3}', ""); +Expect(1, 44059, '\P{^Is_Line_Break= _H3}', ""); +Expect(0, 44032, '\p{Is_Line_Break= _H3}', ""); +Expect(1, 44032, '\p{^Is_Line_Break= _H3}', ""); +Expect(1, 44032, '\P{Is_Line_Break= _H3}', ""); +Expect(0, 44032, '\P{^Is_Line_Break= _H3}', ""); +Error('\p{Is_Lb=:= H3}'); +Error('\P{Is_Lb=:= H3}'); +Expect(1, 44059, '\p{Is_Lb=h3}', ""); +Expect(0, 44059, '\p{^Is_Lb=h3}', ""); +Expect(0, 44059, '\P{Is_Lb=h3}', ""); +Expect(1, 44059, '\P{^Is_Lb=h3}', ""); +Expect(0, 44032, '\p{Is_Lb=h3}', ""); +Expect(1, 44032, '\p{^Is_Lb=h3}', ""); +Expect(1, 44032, '\P{Is_Lb=h3}', ""); +Expect(0, 44032, '\P{^Is_Lb=h3}', ""); +Expect(1, 44059, '\p{Is_Lb=__h3}', ""); +Expect(0, 44059, '\p{^Is_Lb=__h3}', ""); +Expect(0, 44059, '\P{Is_Lb=__h3}', ""); +Expect(1, 44059, '\P{^Is_Lb=__h3}', ""); +Expect(0, 44032, '\p{Is_Lb=__h3}', ""); +Expect(1, 44032, '\p{^Is_Lb=__h3}', ""); +Expect(1, 44032, '\P{Is_Lb=__h3}', ""); +Expect(0, 44032, '\P{^Is_Lb=__h3}', ""); +Error('\p{Line_Break=_/a/Carriage RETURN}'); +Error('\P{Line_Break=_/a/Carriage RETURN}'); +Expect(1, 13, '\p{Line_Break: carriagereturn}', ""); +Expect(0, 13, '\p{^Line_Break: carriagereturn}', ""); +Expect(0, 13, '\P{Line_Break: carriagereturn}', ""); +Expect(1, 13, '\P{^Line_Break: carriagereturn}', ""); +Expect(0, 12, '\p{Line_Break: carriagereturn}', ""); +Expect(1, 12, '\p{^Line_Break: carriagereturn}', ""); +Expect(1, 12, '\P{Line_Break: carriagereturn}', ""); +Expect(0, 12, '\P{^Line_Break: carriagereturn}', ""); +Expect(1, 13, '\p{Line_Break=_ CARRIAGE RETURN}', ""); +Expect(0, 13, '\p{^Line_Break=_ CARRIAGE RETURN}', ""); +Expect(0, 13, '\P{Line_Break=_ CARRIAGE RETURN}', ""); +Expect(1, 13, '\P{^Line_Break=_ CARRIAGE RETURN}', ""); +Expect(0, 12, '\p{Line_Break=_ CARRIAGE RETURN}', ""); +Expect(1, 12, '\p{^Line_Break=_ CARRIAGE RETURN}', ""); +Expect(1, 12, '\P{Line_Break=_ CARRIAGE RETURN}', ""); +Expect(0, 12, '\P{^Line_Break=_ CARRIAGE RETURN}', ""); +Error('\p{Lb= CR:=}'); +Error('\P{Lb= CR:=}'); +Expect(1, 13, '\p{Lb:cr}', ""); +Expect(0, 13, '\p{^Lb:cr}', ""); +Expect(0, 13, '\P{Lb:cr}', ""); +Expect(1, 13, '\P{^Lb:cr}', ""); +Expect(0, 12, '\p{Lb:cr}', ""); +Expect(1, 12, '\p{^Lb:cr}', ""); +Expect(1, 12, '\P{Lb:cr}', ""); +Expect(0, 12, '\P{^Lb:cr}', ""); +Expect(1, 13, '\p{Lb= CR}', ""); +Expect(0, 13, '\p{^Lb= CR}', ""); +Expect(0, 13, '\P{Lb= CR}', ""); +Expect(1, 13, '\P{^Lb= CR}', ""); +Expect(0, 12, '\p{Lb= CR}', ""); +Expect(1, 12, '\p{^Lb= CR}', ""); +Expect(1, 12, '\P{Lb= CR}', ""); +Expect(0, 12, '\P{^Lb= CR}', ""); +Error('\p{Is_Line_Break=_Carriage_Return:=}'); +Error('\P{Is_Line_Break=_Carriage_Return:=}'); +Expect(1, 13, '\p{Is_Line_Break=carriagereturn}', ""); +Expect(0, 13, '\p{^Is_Line_Break=carriagereturn}', ""); +Expect(0, 13, '\P{Is_Line_Break=carriagereturn}', ""); +Expect(1, 13, '\P{^Is_Line_Break=carriagereturn}', ""); +Expect(0, 12, '\p{Is_Line_Break=carriagereturn}', ""); +Expect(1, 12, '\p{^Is_Line_Break=carriagereturn}', ""); +Expect(1, 12, '\P{Is_Line_Break=carriagereturn}', ""); +Expect(0, 12, '\P{^Is_Line_Break=carriagereturn}', ""); +Expect(1, 13, '\p{Is_Line_Break=_CARRIAGE-RETURN}', ""); +Expect(0, 13, '\p{^Is_Line_Break=_CARRIAGE-RETURN}', ""); +Expect(0, 13, '\P{Is_Line_Break=_CARRIAGE-RETURN}', ""); +Expect(1, 13, '\P{^Is_Line_Break=_CARRIAGE-RETURN}', ""); +Expect(0, 12, '\p{Is_Line_Break=_CARRIAGE-RETURN}', ""); +Expect(1, 12, '\p{^Is_Line_Break=_CARRIAGE-RETURN}', ""); +Expect(1, 12, '\P{Is_Line_Break=_CARRIAGE-RETURN}', ""); +Expect(0, 12, '\P{^Is_Line_Break=_CARRIAGE-RETURN}', ""); +Error('\p{Is_Lb=:=CR}'); +Error('\P{Is_Lb=:=CR}'); +Expect(1, 13, '\p{Is_Lb=cr}', ""); +Expect(0, 13, '\p{^Is_Lb=cr}', ""); +Expect(0, 13, '\P{Is_Lb=cr}', ""); +Expect(1, 13, '\P{^Is_Lb=cr}', ""); +Expect(0, 12, '\p{Is_Lb=cr}', ""); +Expect(1, 12, '\p{^Is_Lb=cr}', ""); +Expect(1, 12, '\P{Is_Lb=cr}', ""); +Expect(0, 12, '\P{^Is_Lb=cr}', ""); +Expect(1, 13, '\p{Is_Lb= -CR}', ""); +Expect(0, 13, '\p{^Is_Lb= -CR}', ""); +Expect(0, 13, '\P{Is_Lb= -CR}', ""); +Expect(1, 13, '\P{^Is_Lb= -CR}', ""); +Expect(0, 12, '\p{Is_Lb= -CR}', ""); +Expect(1, 12, '\p{^Is_Lb= -CR}', ""); +Expect(1, 12, '\P{Is_Lb= -CR}', ""); +Expect(0, 12, '\P{^Is_Lb= -CR}', ""); +Error('\p{Line_Break=:=Close_Punctuation}'); +Error('\P{Line_Break=:=Close_Punctuation}'); +Expect(1, 41, '\p{Line_Break=closepunctuation}', ""); +Expect(0, 41, '\p{^Line_Break=closepunctuation}', ""); +Expect(0, 41, '\P{Line_Break=closepunctuation}', ""); +Expect(1, 41, '\P{^Line_Break=closepunctuation}', ""); +Expect(0, 40, '\p{Line_Break=closepunctuation}', ""); +Expect(1, 40, '\p{^Line_Break=closepunctuation}', ""); +Expect(1, 40, '\P{Line_Break=closepunctuation}', ""); +Expect(0, 40, '\P{^Line_Break=closepunctuation}', ""); +Expect(1, 41, '\p{Line_Break=- Close PUNCTUATION}', ""); +Expect(0, 41, '\p{^Line_Break=- Close PUNCTUATION}', ""); +Expect(0, 41, '\P{Line_Break=- Close PUNCTUATION}', ""); +Expect(1, 41, '\P{^Line_Break=- Close PUNCTUATION}', ""); +Expect(0, 40, '\p{Line_Break=- Close PUNCTUATION}', ""); +Expect(1, 40, '\p{^Line_Break=- Close PUNCTUATION}', ""); +Expect(1, 40, '\P{Line_Break=- Close PUNCTUATION}', ""); +Expect(0, 40, '\P{^Line_Break=- Close PUNCTUATION}', ""); +Error('\p{Lb=_CL/a/}'); +Error('\P{Lb=_CL/a/}'); +Expect(1, 41, '\p{Lb=cl}', ""); +Expect(0, 41, '\p{^Lb=cl}', ""); +Expect(0, 41, '\P{Lb=cl}', ""); +Expect(1, 41, '\P{^Lb=cl}', ""); +Expect(0, 40, '\p{Lb=cl}', ""); +Expect(1, 40, '\p{^Lb=cl}', ""); +Expect(1, 40, '\P{Lb=cl}', ""); +Expect(0, 40, '\P{^Lb=cl}', ""); +Expect(1, 41, '\p{Lb=_CL}', ""); +Expect(0, 41, '\p{^Lb=_CL}', ""); +Expect(0, 41, '\P{Lb=_CL}', ""); +Expect(1, 41, '\P{^Lb=_CL}', ""); +Expect(0, 40, '\p{Lb=_CL}', ""); +Expect(1, 40, '\p{^Lb=_CL}', ""); +Expect(1, 40, '\P{Lb=_CL}', ""); +Expect(0, 40, '\P{^Lb=_CL}', ""); +Error('\p{Is_Line_Break=/a/-Closepunctuation}'); +Error('\P{Is_Line_Break=/a/-Closepunctuation}'); +Expect(1, 41, '\p{Is_Line_Break=closepunctuation}', ""); +Expect(0, 41, '\p{^Is_Line_Break=closepunctuation}', ""); +Expect(0, 41, '\P{Is_Line_Break=closepunctuation}', ""); +Expect(1, 41, '\P{^Is_Line_Break=closepunctuation}', ""); +Expect(0, 40, '\p{Is_Line_Break=closepunctuation}', ""); +Expect(1, 40, '\p{^Is_Line_Break=closepunctuation}', ""); +Expect(1, 40, '\P{Is_Line_Break=closepunctuation}', ""); +Expect(0, 40, '\P{^Is_Line_Break=closepunctuation}', ""); +Expect(1, 41, '\p{Is_Line_Break=_ CLOSE-Punctuation}', ""); +Expect(0, 41, '\p{^Is_Line_Break=_ CLOSE-Punctuation}', ""); +Expect(0, 41, '\P{Is_Line_Break=_ CLOSE-Punctuation}', ""); +Expect(1, 41, '\P{^Is_Line_Break=_ CLOSE-Punctuation}', ""); +Expect(0, 40, '\p{Is_Line_Break=_ CLOSE-Punctuation}', ""); +Expect(1, 40, '\p{^Is_Line_Break=_ CLOSE-Punctuation}', ""); +Expect(1, 40, '\P{Is_Line_Break=_ CLOSE-Punctuation}', ""); +Expect(0, 40, '\P{^Is_Line_Break=_ CLOSE-Punctuation}', ""); +Error('\p{Is_Lb=/a/ -CL}'); +Error('\P{Is_Lb=/a/ -CL}'); +Expect(1, 41, '\p{Is_Lb=cl}', ""); +Expect(0, 41, '\p{^Is_Lb=cl}', ""); +Expect(0, 41, '\P{Is_Lb=cl}', ""); +Expect(1, 41, '\P{^Is_Lb=cl}', ""); +Expect(0, 40, '\p{Is_Lb=cl}', ""); +Expect(1, 40, '\p{^Is_Lb=cl}', ""); +Expect(1, 40, '\P{Is_Lb=cl}', ""); +Expect(0, 40, '\P{^Is_Lb=cl}', ""); +Expect(1, 41, '\p{Is_Lb= CL}', ""); +Expect(0, 41, '\p{^Is_Lb= CL}', ""); +Expect(0, 41, '\P{Is_Lb= CL}', ""); +Expect(1, 41, '\P{^Is_Lb= CL}', ""); +Expect(0, 40, '\p{Is_Lb= CL}', ""); +Expect(1, 40, '\p{^Is_Lb= CL}', ""); +Expect(1, 40, '\P{Is_Lb= CL}', ""); +Expect(0, 40, '\P{^Is_Lb= CL}', ""); +Error('\p{Line_Break= /a/Combining Mark}'); +Error('\P{Line_Break= /a/Combining Mark}'); +Expect(1, 8, '\p{Line_Break=combiningmark}', ""); +Expect(0, 8, '\p{^Line_Break=combiningmark}', ""); +Expect(0, 8, '\P{Line_Break=combiningmark}', ""); +Expect(1, 8, '\P{^Line_Break=combiningmark}', ""); +Expect(0, 13, '\p{Line_Break=combiningmark}', ""); +Expect(1, 13, '\p{^Line_Break=combiningmark}', ""); +Expect(1, 13, '\P{Line_Break=combiningmark}', ""); +Expect(0, 13, '\P{^Line_Break=combiningmark}', ""); +Expect(1, 8, '\p{Line_Break=- CombiningMark}', ""); +Expect(0, 8, '\p{^Line_Break=- CombiningMark}', ""); +Expect(0, 8, '\P{Line_Break=- CombiningMark}', ""); +Expect(1, 8, '\P{^Line_Break=- CombiningMark}', ""); +Expect(0, 13, '\p{Line_Break=- CombiningMark}', ""); +Expect(1, 13, '\p{^Line_Break=- CombiningMark}', ""); +Expect(1, 13, '\P{Line_Break=- CombiningMark}', ""); +Expect(0, 13, '\P{^Line_Break=- CombiningMark}', ""); +Error('\p{Lb=:=-_CM}'); +Error('\P{Lb=:=-_CM}'); +Expect(1, 8, '\p{Lb=cm}', ""); +Expect(0, 8, '\p{^Lb=cm}', ""); +Expect(0, 8, '\P{Lb=cm}', ""); +Expect(1, 8, '\P{^Lb=cm}', ""); +Expect(0, 13, '\p{Lb=cm}', ""); +Expect(1, 13, '\p{^Lb=cm}', ""); +Expect(1, 13, '\P{Lb=cm}', ""); +Expect(0, 13, '\P{^Lb=cm}', ""); +Expect(1, 8, '\p{Lb=_cm}', ""); +Expect(0, 8, '\p{^Lb=_cm}', ""); +Expect(0, 8, '\P{Lb=_cm}', ""); +Expect(1, 8, '\P{^Lb=_cm}', ""); +Expect(0, 13, '\p{Lb=_cm}', ""); +Expect(1, 13, '\p{^Lb=_cm}', ""); +Expect(1, 13, '\P{Lb=_cm}', ""); +Expect(0, 13, '\P{^Lb=_cm}', ""); +Error('\p{Is_Line_Break= -combining-Mark/a/}'); +Error('\P{Is_Line_Break= -combining-Mark/a/}'); +Expect(1, 8, '\p{Is_Line_Break:combiningmark}', ""); +Expect(0, 8, '\p{^Is_Line_Break:combiningmark}', ""); +Expect(0, 8, '\P{Is_Line_Break:combiningmark}', ""); +Expect(1, 8, '\P{^Is_Line_Break:combiningmark}', ""); +Expect(0, 13, '\p{Is_Line_Break:combiningmark}', ""); +Expect(1, 13, '\p{^Is_Line_Break:combiningmark}', ""); +Expect(1, 13, '\P{Is_Line_Break:combiningmark}', ""); +Expect(0, 13, '\P{^Is_Line_Break:combiningmark}', ""); +Expect(1, 8, '\p{Is_Line_Break= combining_MARK}', ""); +Expect(0, 8, '\p{^Is_Line_Break= combining_MARK}', ""); +Expect(0, 8, '\P{Is_Line_Break= combining_MARK}', ""); +Expect(1, 8, '\P{^Is_Line_Break= combining_MARK}', ""); +Expect(0, 13, '\p{Is_Line_Break= combining_MARK}', ""); +Expect(1, 13, '\p{^Is_Line_Break= combining_MARK}', ""); +Expect(1, 13, '\P{Is_Line_Break= combining_MARK}', ""); +Expect(0, 13, '\P{^Is_Line_Break= combining_MARK}', ""); +Error('\p{Is_Lb:_:=CM}'); +Error('\P{Is_Lb:_:=CM}'); +Expect(1, 8, '\p{Is_Lb=cm}', ""); +Expect(0, 8, '\p{^Is_Lb=cm}', ""); +Expect(0, 8, '\P{Is_Lb=cm}', ""); +Expect(1, 8, '\P{^Is_Lb=cm}', ""); +Expect(0, 13, '\p{Is_Lb=cm}', ""); +Expect(1, 13, '\p{^Is_Lb=cm}', ""); +Expect(1, 13, '\P{Is_Lb=cm}', ""); +Expect(0, 13, '\P{^Is_Lb=cm}', ""); +Expect(1, 8, '\p{Is_Lb= -CM}', ""); +Expect(0, 8, '\p{^Is_Lb= -CM}', ""); +Expect(0, 8, '\P{Is_Lb= -CM}', ""); +Expect(1, 8, '\P{^Is_Lb= -CM}', ""); +Expect(0, 13, '\p{Is_Lb= -CM}', ""); +Expect(1, 13, '\p{^Is_Lb= -CM}', ""); +Expect(1, 13, '\P{Is_Lb= -CM}', ""); +Expect(0, 13, '\P{^Is_Lb= -CM}', ""); +Error('\p{Line_Break= -Mandatory:=BREAK}'); +Error('\P{Line_Break= -Mandatory:=BREAK}'); +Expect(1, 12, '\p{Line_Break=mandatorybreak}', ""); +Expect(0, 12, '\p{^Line_Break=mandatorybreak}', ""); +Expect(0, 12, '\P{Line_Break=mandatorybreak}', ""); +Expect(1, 12, '\P{^Line_Break=mandatorybreak}', ""); +Expect(0, 10, '\p{Line_Break=mandatorybreak}', ""); +Expect(1, 10, '\p{^Line_Break=mandatorybreak}', ""); +Expect(1, 10, '\P{Line_Break=mandatorybreak}', ""); +Expect(0, 10, '\P{^Line_Break=mandatorybreak}', ""); +Expect(1, 12, '\p{Line_Break=_MANDATORY BREAK}', ""); +Expect(0, 12, '\p{^Line_Break=_MANDATORY BREAK}', ""); +Expect(0, 12, '\P{Line_Break=_MANDATORY BREAK}', ""); +Expect(1, 12, '\P{^Line_Break=_MANDATORY BREAK}', ""); +Expect(0, 10, '\p{Line_Break=_MANDATORY BREAK}', ""); +Expect(1, 10, '\p{^Line_Break=_MANDATORY BREAK}', ""); +Expect(1, 10, '\P{Line_Break=_MANDATORY BREAK}', ""); +Expect(0, 10, '\P{^Line_Break=_MANDATORY BREAK}', ""); +Error('\p{Lb=/a/bk}'); +Error('\P{Lb=/a/bk}'); +Expect(1, 12, '\p{Lb=bk}', ""); +Expect(0, 12, '\p{^Lb=bk}', ""); +Expect(0, 12, '\P{Lb=bk}', ""); +Expect(1, 12, '\P{^Lb=bk}', ""); +Expect(0, 10, '\p{Lb=bk}', ""); +Expect(1, 10, '\p{^Lb=bk}', ""); +Expect(1, 10, '\P{Lb=bk}', ""); +Expect(0, 10, '\P{^Lb=bk}', ""); +Expect(1, 12, '\p{Lb=-BK}', ""); +Expect(0, 12, '\p{^Lb=-BK}', ""); +Expect(0, 12, '\P{Lb=-BK}', ""); +Expect(1, 12, '\P{^Lb=-BK}', ""); +Expect(0, 10, '\p{Lb=-BK}', ""); +Expect(1, 10, '\p{^Lb=-BK}', ""); +Expect(1, 10, '\P{Lb=-BK}', ""); +Expect(0, 10, '\P{^Lb=-BK}', ""); +Error('\p{Is_Line_Break=:=__mandatory Break}'); +Error('\P{Is_Line_Break=:=__mandatory Break}'); +Expect(1, 12, '\p{Is_Line_Break=mandatorybreak}', ""); +Expect(0, 12, '\p{^Is_Line_Break=mandatorybreak}', ""); +Expect(0, 12, '\P{Is_Line_Break=mandatorybreak}', ""); +Expect(1, 12, '\P{^Is_Line_Break=mandatorybreak}', ""); +Expect(0, 10, '\p{Is_Line_Break=mandatorybreak}', ""); +Expect(1, 10, '\p{^Is_Line_Break=mandatorybreak}', ""); +Expect(1, 10, '\P{Is_Line_Break=mandatorybreak}', ""); +Expect(0, 10, '\P{^Is_Line_Break=mandatorybreak}', ""); +Expect(1, 12, '\p{Is_Line_Break=_Mandatory_Break}', ""); +Expect(0, 12, '\p{^Is_Line_Break=_Mandatory_Break}', ""); +Expect(0, 12, '\P{Is_Line_Break=_Mandatory_Break}', ""); +Expect(1, 12, '\P{^Is_Line_Break=_Mandatory_Break}', ""); +Expect(0, 10, '\p{Is_Line_Break=_Mandatory_Break}', ""); +Expect(1, 10, '\p{^Is_Line_Break=_Mandatory_Break}', ""); +Expect(1, 10, '\P{Is_Line_Break=_Mandatory_Break}', ""); +Expect(0, 10, '\P{^Is_Line_Break=_Mandatory_Break}', ""); +Error('\p{Is_Lb=-:=BK}'); +Error('\P{Is_Lb=-:=BK}'); +Expect(1, 12, '\p{Is_Lb=bk}', ""); +Expect(0, 12, '\p{^Is_Lb=bk}', ""); +Expect(0, 12, '\P{Is_Lb=bk}', ""); +Expect(1, 12, '\P{^Is_Lb=bk}', ""); +Expect(0, 10, '\p{Is_Lb=bk}', ""); +Expect(1, 10, '\p{^Is_Lb=bk}', ""); +Expect(1, 10, '\P{Is_Lb=bk}', ""); +Expect(0, 10, '\P{^Is_Lb=bk}', ""); +Expect(1, 12, '\p{Is_Lb=_BK}', ""); +Expect(0, 12, '\p{^Is_Lb=_BK}', ""); +Expect(0, 12, '\P{Is_Lb=_BK}', ""); +Expect(1, 12, '\P{^Is_Lb=_BK}', ""); +Expect(0, 10, '\p{Is_Lb=_BK}', ""); +Expect(1, 10, '\p{^Is_Lb=_BK}', ""); +Expect(1, 10, '\P{Is_Lb=_BK}', ""); +Expect(0, 10, '\P{^Is_Lb=_BK}', ""); +Error('\p{Line_Break:-_Nonstarter/a/}'); +Error('\P{Line_Break:-_Nonstarter/a/}'); +Expect(1, 6102, '\p{Line_Break=nonstarter}', ""); +Expect(0, 6102, '\p{^Line_Break=nonstarter}', ""); +Expect(0, 6102, '\P{Line_Break=nonstarter}', ""); +Expect(1, 6102, '\P{^Line_Break=nonstarter}', ""); +Expect(0, 6101, '\p{Line_Break=nonstarter}', ""); +Expect(1, 6101, '\p{^Line_Break=nonstarter}', ""); +Expect(1, 6101, '\P{Line_Break=nonstarter}', ""); +Expect(0, 6101, '\P{^Line_Break=nonstarter}', ""); +Error('\p{Lb=:= NS}'); +Error('\P{Lb=:= NS}'); +Expect(1, 6102, '\p{Lb=ns}', ""); +Expect(0, 6102, '\p{^Lb=ns}', ""); +Expect(0, 6102, '\P{Lb=ns}', ""); +Expect(1, 6102, '\P{^Lb=ns}', ""); +Expect(0, 6101, '\p{Lb=ns}', ""); +Expect(1, 6101, '\p{^Lb=ns}', ""); +Expect(1, 6101, '\P{Lb=ns}', ""); +Expect(0, 6101, '\P{^Lb=ns}', ""); +Expect(1, 6102, '\p{Lb=- NS}', ""); +Expect(0, 6102, '\p{^Lb=- NS}', ""); +Expect(0, 6102, '\P{Lb=- NS}', ""); +Expect(1, 6102, '\P{^Lb=- NS}', ""); +Expect(0, 6101, '\p{Lb=- NS}', ""); +Expect(1, 6101, '\p{^Lb=- NS}', ""); +Expect(1, 6101, '\P{Lb=- NS}', ""); +Expect(0, 6101, '\P{^Lb=- NS}', ""); +Error('\p{Is_Line_Break=-NONSTARTER/a/}'); +Error('\P{Is_Line_Break=-NONSTARTER/a/}'); +Expect(1, 6102, '\p{Is_Line_Break: nonstarter}', ""); +Expect(0, 6102, '\p{^Is_Line_Break: nonstarter}', ""); +Expect(0, 6102, '\P{Is_Line_Break: nonstarter}', ""); +Expect(1, 6102, '\P{^Is_Line_Break: nonstarter}', ""); +Expect(0, 6101, '\p{Is_Line_Break: nonstarter}', ""); +Expect(1, 6101, '\p{^Is_Line_Break: nonstarter}', ""); +Expect(1, 6101, '\P{Is_Line_Break: nonstarter}', ""); +Expect(0, 6101, '\P{^Is_Line_Break: nonstarter}', ""); +Expect(1, 6102, '\p{Is_Line_Break= Nonstarter}', ""); +Expect(0, 6102, '\p{^Is_Line_Break= Nonstarter}', ""); +Expect(0, 6102, '\P{Is_Line_Break= Nonstarter}', ""); +Expect(1, 6102, '\P{^Is_Line_Break= Nonstarter}', ""); +Expect(0, 6101, '\p{Is_Line_Break= Nonstarter}', ""); +Expect(1, 6101, '\p{^Is_Line_Break= Nonstarter}', ""); +Expect(1, 6101, '\P{Is_Line_Break= Nonstarter}', ""); +Expect(0, 6101, '\P{^Is_Line_Break= Nonstarter}', ""); +Error('\p{Is_Lb=/a/_-ns}'); +Error('\P{Is_Lb=/a/_-ns}'); +Expect(1, 6102, '\p{Is_Lb=ns}', ""); +Expect(0, 6102, '\p{^Is_Lb=ns}', ""); +Expect(0, 6102, '\P{Is_Lb=ns}', ""); +Expect(1, 6102, '\P{^Is_Lb=ns}', ""); +Expect(0, 6101, '\p{Is_Lb=ns}', ""); +Expect(1, 6101, '\p{^Is_Lb=ns}', ""); +Expect(1, 6101, '\P{Is_Lb=ns}', ""); +Expect(0, 6101, '\P{^Is_Lb=ns}', ""); +Expect(1, 6102, '\p{Is_Lb=- NS}', ""); +Expect(0, 6102, '\p{^Is_Lb=- NS}', ""); +Expect(0, 6102, '\P{Is_Lb=- NS}', ""); +Expect(1, 6102, '\P{^Is_Lb=- NS}', ""); +Expect(0, 6101, '\p{Is_Lb=- NS}', ""); +Expect(1, 6101, '\p{^Is_Lb=- NS}', ""); +Expect(1, 6101, '\P{Is_Lb=- NS}', ""); +Expect(0, 6101, '\P{^Is_Lb=- NS}', ""); +Error('\p{Line_Break= jv/a/}'); +Error('\P{Line_Break= jv/a/}'); +Expect(1, 4514, '\p{Line_Break=jv}', ""); +Expect(0, 4514, '\p{^Line_Break=jv}', ""); +Expect(0, 4514, '\P{Line_Break=jv}', ""); +Expect(1, 4514, '\P{^Line_Break=jv}', ""); +Expect(0, 4447, '\p{Line_Break=jv}', ""); +Expect(1, 4447, '\p{^Line_Break=jv}', ""); +Expect(1, 4447, '\P{Line_Break=jv}', ""); +Expect(0, 4447, '\P{^Line_Break=jv}', ""); +Expect(1, 4514, '\p{Line_Break=JV}', ""); +Expect(0, 4514, '\p{^Line_Break=JV}', ""); +Expect(0, 4514, '\P{Line_Break=JV}', ""); +Expect(1, 4514, '\P{^Line_Break=JV}', ""); +Expect(0, 4447, '\p{Line_Break=JV}', ""); +Expect(1, 4447, '\p{^Line_Break=JV}', ""); +Expect(1, 4447, '\P{Line_Break=JV}', ""); +Expect(0, 4447, '\P{^Line_Break=JV}', ""); +Error('\p{Lb=/a/ JV}'); +Error('\P{Lb=/a/ JV}'); +Expect(1, 4514, '\p{Lb=jv}', ""); +Expect(0, 4514, '\p{^Lb=jv}', ""); +Expect(0, 4514, '\P{Lb=jv}', ""); +Expect(1, 4514, '\P{^Lb=jv}', ""); +Expect(0, 4447, '\p{Lb=jv}', ""); +Expect(1, 4447, '\p{^Lb=jv}', ""); +Expect(1, 4447, '\P{Lb=jv}', ""); +Expect(0, 4447, '\P{^Lb=jv}', ""); +Expect(1, 4514, '\p{Lb=-_JV}', ""); +Expect(0, 4514, '\p{^Lb=-_JV}', ""); +Expect(0, 4514, '\P{Lb=-_JV}', ""); +Expect(1, 4514, '\P{^Lb=-_JV}', ""); +Expect(0, 4447, '\p{Lb=-_JV}', ""); +Expect(1, 4447, '\p{^Lb=-_JV}', ""); +Expect(1, 4447, '\P{Lb=-_JV}', ""); +Expect(0, 4447, '\P{^Lb=-_JV}', ""); +Error('\p{Is_Line_Break: /a/JV}'); +Error('\P{Is_Line_Break: /a/JV}'); +Expect(1, 4514, '\p{Is_Line_Break=jv}', ""); +Expect(0, 4514, '\p{^Is_Line_Break=jv}', ""); +Expect(0, 4514, '\P{Is_Line_Break=jv}', ""); +Expect(1, 4514, '\P{^Is_Line_Break=jv}', ""); +Expect(0, 4447, '\p{Is_Line_Break=jv}', ""); +Expect(1, 4447, '\p{^Is_Line_Break=jv}', ""); +Expect(1, 4447, '\P{Is_Line_Break=jv}', ""); +Expect(0, 4447, '\P{^Is_Line_Break=jv}', ""); +Expect(1, 4514, '\p{Is_Line_Break=- JV}', ""); +Expect(0, 4514, '\p{^Is_Line_Break=- JV}', ""); +Expect(0, 4514, '\P{Is_Line_Break=- JV}', ""); +Expect(1, 4514, '\P{^Is_Line_Break=- JV}', ""); +Expect(0, 4447, '\p{Is_Line_Break=- JV}', ""); +Expect(1, 4447, '\p{^Is_Line_Break=- JV}', ""); +Expect(1, 4447, '\P{Is_Line_Break=- JV}', ""); +Expect(0, 4447, '\P{^Is_Line_Break=- JV}', ""); +Error('\p{Is_Lb=:=-jv}'); +Error('\P{Is_Lb=:=-jv}'); +Expect(1, 4514, '\p{Is_Lb=jv}', ""); +Expect(0, 4514, '\p{^Is_Lb=jv}', ""); +Expect(0, 4514, '\P{Is_Lb=jv}', ""); +Expect(1, 4514, '\P{^Is_Lb=jv}', ""); +Expect(0, 4447, '\p{Is_Lb=jv}', ""); +Expect(1, 4447, '\p{^Is_Lb=jv}', ""); +Expect(1, 4447, '\P{Is_Lb=jv}', ""); +Expect(0, 4447, '\P{^Is_Lb=jv}', ""); +Expect(1, 4514, '\p{Is_Lb= -jv}', ""); +Expect(0, 4514, '\p{^Is_Lb= -jv}', ""); +Expect(0, 4514, '\P{Is_Lb= -jv}', ""); +Expect(1, 4514, '\P{^Is_Lb= -jv}', ""); +Expect(0, 4447, '\p{Is_Lb= -jv}', ""); +Expect(1, 4447, '\p{^Is_Lb= -jv}', ""); +Expect(1, 4447, '\P{Is_Lb= -jv}', ""); +Expect(0, 4447, '\P{^Is_Lb= -jv}', ""); +Error('\p{Line_Break= _Quotation/a/}'); +Error('\P{Line_Break= _Quotation/a/}'); +Expect(1, 34, '\p{Line_Break=quotation}', ""); +Expect(0, 34, '\p{^Line_Break=quotation}', ""); +Expect(0, 34, '\P{Line_Break=quotation}', ""); +Expect(1, 34, '\P{^Line_Break=quotation}', ""); +Expect(0, 33, '\p{Line_Break=quotation}', ""); +Expect(1, 33, '\p{^Line_Break=quotation}', ""); +Expect(1, 33, '\P{Line_Break=quotation}', ""); +Expect(0, 33, '\P{^Line_Break=quotation}', ""); +Expect(1, 34, '\p{Line_Break=-_quotation}', ""); +Expect(0, 34, '\p{^Line_Break=-_quotation}', ""); +Expect(0, 34, '\P{Line_Break=-_quotation}', ""); +Expect(1, 34, '\P{^Line_Break=-_quotation}', ""); +Expect(0, 33, '\p{Line_Break=-_quotation}', ""); +Expect(1, 33, '\p{^Line_Break=-_quotation}', ""); +Expect(1, 33, '\P{Line_Break=-_quotation}', ""); +Expect(0, 33, '\P{^Line_Break=-_quotation}', ""); +Error('\p{Lb= QU/a/}'); +Error('\P{Lb= QU/a/}'); +Expect(1, 34, '\p{Lb=qu}', ""); +Expect(0, 34, '\p{^Lb=qu}', ""); +Expect(0, 34, '\P{Lb=qu}', ""); +Expect(1, 34, '\P{^Lb=qu}', ""); +Expect(0, 33, '\p{Lb=qu}', ""); +Expect(1, 33, '\p{^Lb=qu}', ""); +Expect(1, 33, '\P{Lb=qu}', ""); +Expect(0, 33, '\P{^Lb=qu}', ""); +Expect(1, 34, '\p{Lb= QU}', ""); +Expect(0, 34, '\p{^Lb= QU}', ""); +Expect(0, 34, '\P{Lb= QU}', ""); +Expect(1, 34, '\P{^Lb= QU}', ""); +Expect(0, 33, '\p{Lb= QU}', ""); +Expect(1, 33, '\p{^Lb= QU}', ""); +Expect(1, 33, '\P{Lb= QU}', ""); +Expect(0, 33, '\P{^Lb= QU}', ""); +Error('\p{Is_Line_Break=/a/quotation}'); +Error('\P{Is_Line_Break=/a/quotation}'); +Expect(1, 34, '\p{Is_Line_Break=quotation}', ""); +Expect(0, 34, '\p{^Is_Line_Break=quotation}', ""); +Expect(0, 34, '\P{Is_Line_Break=quotation}', ""); +Expect(1, 34, '\P{^Is_Line_Break=quotation}', ""); +Expect(0, 33, '\p{Is_Line_Break=quotation}', ""); +Expect(1, 33, '\p{^Is_Line_Break=quotation}', ""); +Expect(1, 33, '\P{Is_Line_Break=quotation}', ""); +Expect(0, 33, '\P{^Is_Line_Break=quotation}', ""); +Expect(1, 34, '\p{Is_Line_Break=- Quotation}', ""); +Expect(0, 34, '\p{^Is_Line_Break=- Quotation}', ""); +Expect(0, 34, '\P{Is_Line_Break=- Quotation}', ""); +Expect(1, 34, '\P{^Is_Line_Break=- Quotation}', ""); +Expect(0, 33, '\p{Is_Line_Break=- Quotation}', ""); +Expect(1, 33, '\p{^Is_Line_Break=- Quotation}', ""); +Expect(1, 33, '\P{Is_Line_Break=- Quotation}', ""); +Expect(0, 33, '\P{^Is_Line_Break=- Quotation}', ""); +Error('\p{Is_Lb=__QU/a/}'); +Error('\P{Is_Lb=__QU/a/}'); +Expect(1, 34, '\p{Is_Lb=qu}', ""); +Expect(0, 34, '\p{^Is_Lb=qu}', ""); +Expect(0, 34, '\P{Is_Lb=qu}', ""); +Expect(1, 34, '\P{^Is_Lb=qu}', ""); +Expect(0, 33, '\p{Is_Lb=qu}', ""); +Expect(1, 33, '\p{^Is_Lb=qu}', ""); +Expect(1, 33, '\P{Is_Lb=qu}', ""); +Expect(0, 33, '\P{^Is_Lb=qu}', ""); +Expect(1, 34, '\p{Is_Lb=_ QU}', ""); +Expect(0, 34, '\p{^Is_Lb=_ QU}', ""); +Expect(0, 34, '\P{Is_Lb=_ QU}', ""); +Expect(1, 34, '\P{^Is_Lb=_ QU}', ""); +Expect(0, 33, '\p{Is_Lb=_ QU}', ""); +Expect(1, 33, '\p{^Is_Lb=_ QU}', ""); +Expect(1, 33, '\P{Is_Lb=_ QU}', ""); +Expect(0, 33, '\P{^Is_Lb=_ QU}', ""); +Error('\p{Line_Break=-/a/INFIX-Numeric}'); +Error('\P{Line_Break=-/a/INFIX-Numeric}'); +Expect(1, 44, '\p{Line_Break=infixnumeric}', ""); +Expect(0, 44, '\p{^Line_Break=infixnumeric}', ""); +Expect(0, 44, '\P{Line_Break=infixnumeric}', ""); +Expect(1, 44, '\P{^Line_Break=infixnumeric}', ""); +Expect(0, 43, '\p{Line_Break=infixnumeric}', ""); +Expect(1, 43, '\p{^Line_Break=infixnumeric}', ""); +Expect(1, 43, '\P{Line_Break=infixnumeric}', ""); +Expect(0, 43, '\P{^Line_Break=infixnumeric}', ""); +Expect(1, 44, '\p{Line_Break: infix_Numeric}', ""); +Expect(0, 44, '\p{^Line_Break: infix_Numeric}', ""); +Expect(0, 44, '\P{Line_Break: infix_Numeric}', ""); +Expect(1, 44, '\P{^Line_Break: infix_Numeric}', ""); +Expect(0, 43, '\p{Line_Break: infix_Numeric}', ""); +Expect(1, 43, '\p{^Line_Break: infix_Numeric}', ""); +Expect(1, 43, '\P{Line_Break: infix_Numeric}', ""); +Expect(0, 43, '\P{^Line_Break: infix_Numeric}', ""); +Error('\p{Lb= :=IS}'); +Error('\P{Lb= :=IS}'); +Expect(1, 44, '\p{Lb=is}', ""); +Expect(0, 44, '\p{^Lb=is}', ""); +Expect(0, 44, '\P{Lb=is}', ""); +Expect(1, 44, '\P{^Lb=is}', ""); +Expect(0, 43, '\p{Lb=is}', ""); +Expect(1, 43, '\p{^Lb=is}', ""); +Expect(1, 43, '\P{Lb=is}', ""); +Expect(0, 43, '\P{^Lb=is}', ""); +Expect(1, 44, '\p{Lb=-IS}', ""); +Expect(0, 44, '\p{^Lb=-IS}', ""); +Expect(0, 44, '\P{Lb=-IS}', ""); +Expect(1, 44, '\P{^Lb=-IS}', ""); +Expect(0, 43, '\p{Lb=-IS}', ""); +Expect(1, 43, '\p{^Lb=-IS}', ""); +Expect(1, 43, '\P{Lb=-IS}', ""); +Expect(0, 43, '\P{^Lb=-IS}', ""); +Error('\p{Is_Line_Break:_-infix numeric/a/}'); +Error('\P{Is_Line_Break:_-infix numeric/a/}'); +Expect(1, 44, '\p{Is_Line_Break=infixnumeric}', ""); +Expect(0, 44, '\p{^Is_Line_Break=infixnumeric}', ""); +Expect(0, 44, '\P{Is_Line_Break=infixnumeric}', ""); +Expect(1, 44, '\P{^Is_Line_Break=infixnumeric}', ""); +Expect(0, 43, '\p{Is_Line_Break=infixnumeric}', ""); +Expect(1, 43, '\p{^Is_Line_Break=infixnumeric}', ""); +Expect(1, 43, '\P{Is_Line_Break=infixnumeric}', ""); +Expect(0, 43, '\P{^Is_Line_Break=infixnumeric}', ""); +Expect(1, 44, '\p{Is_Line_Break=- infix Numeric}', ""); +Expect(0, 44, '\p{^Is_Line_Break=- infix Numeric}', ""); +Expect(0, 44, '\P{Is_Line_Break=- infix Numeric}', ""); +Expect(1, 44, '\P{^Is_Line_Break=- infix Numeric}', ""); +Expect(0, 43, '\p{Is_Line_Break=- infix Numeric}', ""); +Expect(1, 43, '\p{^Is_Line_Break=- infix Numeric}', ""); +Expect(1, 43, '\P{Is_Line_Break=- infix Numeric}', ""); +Expect(0, 43, '\P{^Is_Line_Break=- infix Numeric}', ""); +Error('\p{Is_Lb= _IS/a/}'); +Error('\P{Is_Lb= _IS/a/}'); +Expect(1, 44, '\p{Is_Lb=is}', ""); +Expect(0, 44, '\p{^Is_Lb=is}', ""); +Expect(0, 44, '\P{Is_Lb=is}', ""); +Expect(1, 44, '\P{^Is_Lb=is}', ""); +Expect(0, 43, '\p{Is_Lb=is}', ""); +Expect(1, 43, '\p{^Is_Lb=is}', ""); +Expect(1, 43, '\P{Is_Lb=is}', ""); +Expect(0, 43, '\P{^Is_Lb=is}', ""); +Expect(1, 44, '\p{Is_Lb= _is}', ""); +Expect(0, 44, '\p{^Is_Lb= _is}', ""); +Expect(0, 44, '\P{Is_Lb= _is}', ""); +Expect(1, 44, '\P{^Is_Lb= _is}', ""); +Expect(0, 43, '\p{Is_Lb= _is}', ""); +Expect(1, 43, '\p{^Is_Lb= _is}', ""); +Expect(1, 43, '\P{Is_Lb= _is}', ""); +Expect(0, 43, '\P{^Is_Lb= _is}', ""); +Error('\p{Line_Break=- INSEPARABLE:=}'); +Error('\P{Line_Break=- INSEPARABLE:=}'); +Expect(1, 8230, '\p{Line_Break=inseparable}', ""); +Expect(0, 8230, '\p{^Line_Break=inseparable}', ""); +Expect(0, 8230, '\P{Line_Break=inseparable}', ""); +Expect(1, 8230, '\P{^Line_Break=inseparable}', ""); +Expect(0, 8227, '\p{Line_Break=inseparable}', ""); +Expect(1, 8227, '\p{^Line_Break=inseparable}', ""); +Expect(1, 8227, '\P{Line_Break=inseparable}', ""); +Expect(0, 8227, '\P{^Line_Break=inseparable}', ""); +Expect(1, 8230, '\p{Line_Break=--INSEPARABLE}', ""); +Expect(0, 8230, '\p{^Line_Break=--INSEPARABLE}', ""); +Expect(0, 8230, '\P{Line_Break=--INSEPARABLE}', ""); +Expect(1, 8230, '\P{^Line_Break=--INSEPARABLE}', ""); +Expect(0, 8227, '\p{Line_Break=--INSEPARABLE}', ""); +Expect(1, 8227, '\p{^Line_Break=--INSEPARABLE}', ""); +Expect(1, 8227, '\P{Line_Break=--INSEPARABLE}', ""); +Expect(0, 8227, '\P{^Line_Break=--INSEPARABLE}', ""); +Error('\p{Lb=:=_ IN}'); +Error('\P{Lb=:=_ IN}'); +Expect(1, 8230, '\p{Lb=in}', ""); +Expect(0, 8230, '\p{^Lb=in}', ""); +Expect(0, 8230, '\P{Lb=in}', ""); +Expect(1, 8230, '\P{^Lb=in}', ""); +Expect(0, 8227, '\p{Lb=in}', ""); +Expect(1, 8227, '\p{^Lb=in}', ""); +Expect(1, 8227, '\P{Lb=in}', ""); +Expect(0, 8227, '\P{^Lb=in}', ""); +Expect(1, 8230, '\p{Lb=__IN}', ""); +Expect(0, 8230, '\p{^Lb=__IN}', ""); +Expect(0, 8230, '\P{Lb=__IN}', ""); +Expect(1, 8230, '\P{^Lb=__IN}', ""); +Expect(0, 8227, '\p{Lb=__IN}', ""); +Expect(1, 8227, '\p{^Lb=__IN}', ""); +Expect(1, 8227, '\P{Lb=__IN}', ""); +Expect(0, 8227, '\P{^Lb=__IN}', ""); +Error('\p{Is_Line_Break=-:=INSEPERABLE}'); +Error('\P{Is_Line_Break=-:=INSEPERABLE}'); +Expect(1, 8230, '\p{Is_Line_Break=inseperable}', ""); +Expect(0, 8230, '\p{^Is_Line_Break=inseperable}', ""); +Expect(0, 8230, '\P{Is_Line_Break=inseperable}', ""); +Expect(1, 8230, '\P{^Is_Line_Break=inseperable}', ""); +Expect(0, 8227, '\p{Is_Line_Break=inseperable}', ""); +Expect(1, 8227, '\p{^Is_Line_Break=inseperable}', ""); +Expect(1, 8227, '\P{Is_Line_Break=inseperable}', ""); +Expect(0, 8227, '\P{^Is_Line_Break=inseperable}', ""); +Expect(1, 8230, '\p{Is_Line_Break= -INSEPERABLE}', ""); +Expect(0, 8230, '\p{^Is_Line_Break= -INSEPERABLE}', ""); +Expect(0, 8230, '\P{Is_Line_Break= -INSEPERABLE}', ""); +Expect(1, 8230, '\P{^Is_Line_Break= -INSEPERABLE}', ""); +Expect(0, 8227, '\p{Is_Line_Break= -INSEPERABLE}', ""); +Expect(1, 8227, '\p{^Is_Line_Break= -INSEPERABLE}', ""); +Expect(1, 8227, '\P{Is_Line_Break= -INSEPERABLE}', ""); +Expect(0, 8227, '\P{^Is_Line_Break= -INSEPERABLE}', ""); +Error('\p{Is_Lb::= inseparable}'); +Error('\P{Is_Lb::= inseparable}'); +Expect(1, 8230, '\p{Is_Lb=inseparable}', ""); +Expect(0, 8230, '\p{^Is_Lb=inseparable}', ""); +Expect(0, 8230, '\P{Is_Lb=inseparable}', ""); +Expect(1, 8230, '\P{^Is_Lb=inseparable}', ""); +Expect(0, 8227, '\p{Is_Lb=inseparable}', ""); +Expect(1, 8227, '\p{^Is_Lb=inseparable}', ""); +Expect(1, 8227, '\P{Is_Lb=inseparable}', ""); +Expect(0, 8227, '\P{^Is_Lb=inseparable}', ""); +Expect(1, 8230, '\p{Is_Lb: _ Inseparable}', ""); +Expect(0, 8230, '\p{^Is_Lb: _ Inseparable}', ""); +Expect(0, 8230, '\P{Is_Lb: _ Inseparable}', ""); +Expect(1, 8230, '\P{^Is_Lb: _ Inseparable}', ""); +Expect(0, 8227, '\p{Is_Lb: _ Inseparable}', ""); +Expect(1, 8227, '\p{^Is_Lb: _ Inseparable}', ""); +Expect(1, 8227, '\P{Is_Lb: _ Inseparable}', ""); +Expect(0, 8227, '\P{^Is_Lb: _ Inseparable}', ""); +Error('\p{Line_Break=-/a/Complex context}'); +Error('\P{Line_Break=-/a/Complex context}'); +Expect(1, 3642, '\p{Line_Break=complexcontext}', ""); +Expect(0, 3642, '\p{^Line_Break=complexcontext}', ""); +Expect(0, 3642, '\P{Line_Break=complexcontext}', ""); +Expect(1, 3642, '\P{^Line_Break=complexcontext}', ""); +Expect(0, 3584, '\p{Line_Break=complexcontext}', ""); +Expect(1, 3584, '\p{^Line_Break=complexcontext}', ""); +Expect(1, 3584, '\P{Line_Break=complexcontext}', ""); +Expect(0, 3584, '\P{^Line_Break=complexcontext}', ""); +Expect(1, 3642, '\p{Line_Break= -Complex Context}', ""); +Expect(0, 3642, '\p{^Line_Break= -Complex Context}', ""); +Expect(0, 3642, '\P{Line_Break= -Complex Context}', ""); +Expect(1, 3642, '\P{^Line_Break= -Complex Context}', ""); +Expect(0, 3584, '\p{Line_Break= -Complex Context}', ""); +Expect(1, 3584, '\p{^Line_Break= -Complex Context}', ""); +Expect(1, 3584, '\P{Line_Break= -Complex Context}', ""); +Expect(0, 3584, '\P{^Line_Break= -Complex Context}', ""); +Error('\p{Lb= :=sa}'); +Error('\P{Lb= :=sa}'); +Expect(1, 3642, '\p{Lb=sa}', ""); +Expect(0, 3642, '\p{^Lb=sa}', ""); +Expect(0, 3642, '\P{Lb=sa}', ""); +Expect(1, 3642, '\P{^Lb=sa}', ""); +Expect(0, 3584, '\p{Lb=sa}', ""); +Expect(1, 3584, '\p{^Lb=sa}', ""); +Expect(1, 3584, '\P{Lb=sa}', ""); +Expect(0, 3584, '\P{^Lb=sa}', ""); +Expect(1, 3642, '\p{Lb=SA}', ""); +Expect(0, 3642, '\p{^Lb=SA}', ""); +Expect(0, 3642, '\P{Lb=SA}', ""); +Expect(1, 3642, '\P{^Lb=SA}', ""); +Expect(0, 3584, '\p{Lb=SA}', ""); +Expect(1, 3584, '\p{^Lb=SA}', ""); +Expect(1, 3584, '\P{Lb=SA}', ""); +Expect(0, 3584, '\P{^Lb=SA}', ""); +Error('\p{Is_Line_Break=/a/ -COMPLEX CONTEXT}'); +Error('\P{Is_Line_Break=/a/ -COMPLEX CONTEXT}'); +Expect(1, 3642, '\p{Is_Line_Break=complexcontext}', ""); +Expect(0, 3642, '\p{^Is_Line_Break=complexcontext}', ""); +Expect(0, 3642, '\P{Is_Line_Break=complexcontext}', ""); +Expect(1, 3642, '\P{^Is_Line_Break=complexcontext}', ""); +Expect(0, 3584, '\p{Is_Line_Break=complexcontext}', ""); +Expect(1, 3584, '\p{^Is_Line_Break=complexcontext}', ""); +Expect(1, 3584, '\P{Is_Line_Break=complexcontext}', ""); +Expect(0, 3584, '\P{^Is_Line_Break=complexcontext}', ""); +Expect(1, 3642, '\p{Is_Line_Break= COMPLEX-Context}', ""); +Expect(0, 3642, '\p{^Is_Line_Break= COMPLEX-Context}', ""); +Expect(0, 3642, '\P{Is_Line_Break= COMPLEX-Context}', ""); +Expect(1, 3642, '\P{^Is_Line_Break= COMPLEX-Context}', ""); +Expect(0, 3584, '\p{Is_Line_Break= COMPLEX-Context}', ""); +Expect(1, 3584, '\p{^Is_Line_Break= COMPLEX-Context}', ""); +Expect(1, 3584, '\P{Is_Line_Break= COMPLEX-Context}', ""); +Expect(0, 3584, '\P{^Is_Line_Break= COMPLEX-Context}', ""); +Error('\p{Is_Lb=- SA:=}'); +Error('\P{Is_Lb=- SA:=}'); +Expect(1, 3642, '\p{Is_Lb=sa}', ""); +Expect(0, 3642, '\p{^Is_Lb=sa}', ""); +Expect(0, 3642, '\P{Is_Lb=sa}', ""); +Expect(1, 3642, '\P{^Is_Lb=sa}', ""); +Expect(0, 3584, '\p{Is_Lb=sa}', ""); +Expect(1, 3584, '\p{^Is_Lb=sa}', ""); +Expect(1, 3584, '\P{Is_Lb=sa}', ""); +Expect(0, 3584, '\P{^Is_Lb=sa}', ""); +Expect(1, 3642, '\p{Is_Lb=_ SA}', ""); +Expect(0, 3642, '\p{^Is_Lb=_ SA}', ""); +Expect(0, 3642, '\P{Is_Lb=_ SA}', ""); +Expect(1, 3642, '\P{^Is_Lb=_ SA}', ""); +Expect(0, 3584, '\p{Is_Lb=_ SA}', ""); +Expect(1, 3584, '\p{^Is_Lb=_ SA}', ""); +Expect(1, 3584, '\P{Is_Lb=_ SA}', ""); +Expect(0, 3584, '\P{^Is_Lb=_ SA}', ""); +Error('\p{Line_Break=/a/ hyphen}'); +Error('\P{Line_Break=/a/ hyphen}'); +Expect(1, 45, '\p{Line_Break=hyphen}', ""); +Expect(0, 45, '\p{^Line_Break=hyphen}', ""); +Expect(0, 45, '\P{Line_Break=hyphen}', ""); +Expect(1, 45, '\P{^Line_Break=hyphen}', ""); +Expect(0, 44, '\p{Line_Break=hyphen}', ""); +Expect(1, 44, '\p{^Line_Break=hyphen}', ""); +Expect(1, 44, '\P{Line_Break=hyphen}', ""); +Expect(0, 44, '\P{^Line_Break=hyphen}', ""); +Expect(1, 45, '\p{Line_Break= -hyphen}', ""); +Expect(0, 45, '\p{^Line_Break= -hyphen}', ""); +Expect(0, 45, '\P{Line_Break= -hyphen}', ""); +Expect(1, 45, '\P{^Line_Break= -hyphen}', ""); +Expect(0, 44, '\p{Line_Break= -hyphen}', ""); +Expect(1, 44, '\p{^Line_Break= -hyphen}', ""); +Expect(1, 44, '\P{Line_Break= -hyphen}', ""); +Expect(0, 44, '\P{^Line_Break= -hyphen}', ""); +Error('\p{Lb= /a/hy}'); +Error('\P{Lb= /a/hy}'); +Expect(1, 45, '\p{Lb=hy}', ""); +Expect(0, 45, '\p{^Lb=hy}', ""); +Expect(0, 45, '\P{Lb=hy}', ""); +Expect(1, 45, '\P{^Lb=hy}', ""); +Expect(0, 44, '\p{Lb=hy}', ""); +Expect(1, 44, '\p{^Lb=hy}', ""); +Expect(1, 44, '\P{Lb=hy}', ""); +Expect(0, 44, '\P{^Lb=hy}', ""); +Expect(1, 45, '\p{Lb: _hy}', ""); +Expect(0, 45, '\p{^Lb: _hy}', ""); +Expect(0, 45, '\P{Lb: _hy}', ""); +Expect(1, 45, '\P{^Lb: _hy}', ""); +Expect(0, 44, '\p{Lb: _hy}', ""); +Expect(1, 44, '\p{^Lb: _hy}', ""); +Expect(1, 44, '\P{Lb: _hy}', ""); +Expect(0, 44, '\P{^Lb: _hy}', ""); +Error('\p{Is_Line_Break= Hyphen/a/}'); +Error('\P{Is_Line_Break= Hyphen/a/}'); +Expect(1, 45, '\p{Is_Line_Break=hyphen}', ""); +Expect(0, 45, '\p{^Is_Line_Break=hyphen}', ""); +Expect(0, 45, '\P{Is_Line_Break=hyphen}', ""); +Expect(1, 45, '\P{^Is_Line_Break=hyphen}', ""); +Expect(0, 44, '\p{Is_Line_Break=hyphen}', ""); +Expect(1, 44, '\p{^Is_Line_Break=hyphen}', ""); +Expect(1, 44, '\P{Is_Line_Break=hyphen}', ""); +Expect(0, 44, '\P{^Is_Line_Break=hyphen}', ""); +Expect(1, 45, '\p{Is_Line_Break=--HYPHEN}', ""); +Expect(0, 45, '\p{^Is_Line_Break=--HYPHEN}', ""); +Expect(0, 45, '\P{Is_Line_Break=--HYPHEN}', ""); +Expect(1, 45, '\P{^Is_Line_Break=--HYPHEN}', ""); +Expect(0, 44, '\p{Is_Line_Break=--HYPHEN}', ""); +Expect(1, 44, '\p{^Is_Line_Break=--HYPHEN}', ""); +Expect(1, 44, '\P{Is_Line_Break=--HYPHEN}', ""); +Expect(0, 44, '\P{^Is_Line_Break=--HYPHEN}', ""); +Error('\p{Is_Lb= /a/HY}'); +Error('\P{Is_Lb= /a/HY}'); +Expect(1, 45, '\p{Is_Lb=hy}', ""); +Expect(0, 45, '\p{^Is_Lb=hy}', ""); +Expect(0, 45, '\P{Is_Lb=hy}', ""); +Expect(1, 45, '\P{^Is_Lb=hy}', ""); +Expect(0, 44, '\p{Is_Lb=hy}', ""); +Expect(1, 44, '\p{^Is_Lb=hy}', ""); +Expect(1, 44, '\P{Is_Lb=hy}', ""); +Expect(0, 44, '\P{^Is_Lb=hy}', ""); +Error('\p{Line_Break=:=break After}'); +Error('\P{Line_Break=:=break After}'); +Expect(1, 9, '\p{Line_Break=breakafter}', ""); +Expect(0, 9, '\p{^Line_Break=breakafter}', ""); +Expect(0, 9, '\P{Line_Break=breakafter}', ""); +Expect(1, 9, '\P{^Line_Break=breakafter}', ""); +Expect(0, 8, '\p{Line_Break=breakafter}', ""); +Expect(1, 8, '\p{^Line_Break=breakafter}', ""); +Expect(1, 8, '\P{Line_Break=breakafter}', ""); +Expect(0, 8, '\P{^Line_Break=breakafter}', ""); +Expect(1, 9, '\p{Line_Break=- BreakAfter}', ""); +Expect(0, 9, '\p{^Line_Break=- BreakAfter}', ""); +Expect(0, 9, '\P{Line_Break=- BreakAfter}', ""); +Expect(1, 9, '\P{^Line_Break=- BreakAfter}', ""); +Expect(0, 8, '\p{Line_Break=- BreakAfter}', ""); +Expect(1, 8, '\p{^Line_Break=- BreakAfter}', ""); +Expect(1, 8, '\P{Line_Break=- BreakAfter}', ""); +Expect(0, 8, '\P{^Line_Break=- BreakAfter}', ""); +Error('\p{Lb=/a/ BA}'); +Error('\P{Lb=/a/ BA}'); +Expect(1, 9, '\p{Lb=ba}', ""); +Expect(0, 9, '\p{^Lb=ba}', ""); +Expect(0, 9, '\P{Lb=ba}', ""); +Expect(1, 9, '\P{^Lb=ba}', ""); +Expect(0, 8, '\p{Lb=ba}', ""); +Expect(1, 8, '\p{^Lb=ba}', ""); +Expect(1, 8, '\P{Lb=ba}', ""); +Expect(0, 8, '\P{^Lb=ba}', ""); +Expect(1, 9, '\p{Lb=-BA}', ""); +Expect(0, 9, '\p{^Lb=-BA}', ""); +Expect(0, 9, '\P{Lb=-BA}', ""); +Expect(1, 9, '\P{^Lb=-BA}', ""); +Expect(0, 8, '\p{Lb=-BA}', ""); +Expect(1, 8, '\p{^Lb=-BA}', ""); +Expect(1, 8, '\P{Lb=-BA}', ""); +Expect(0, 8, '\P{^Lb=-BA}', ""); +Error('\p{Is_Line_Break=/a/ -BreakAfter}'); +Error('\P{Is_Line_Break=/a/ -BreakAfter}'); +Expect(1, 9, '\p{Is_Line_Break=breakafter}', ""); +Expect(0, 9, '\p{^Is_Line_Break=breakafter}', ""); +Expect(0, 9, '\P{Is_Line_Break=breakafter}', ""); +Expect(1, 9, '\P{^Is_Line_Break=breakafter}', ""); +Expect(0, 8, '\p{Is_Line_Break=breakafter}', ""); +Expect(1, 8, '\p{^Is_Line_Break=breakafter}', ""); +Expect(1, 8, '\P{Is_Line_Break=breakafter}', ""); +Expect(0, 8, '\P{^Is_Line_Break=breakafter}', ""); +Expect(1, 9, '\p{Is_Line_Break: - BreakAFTER}', ""); +Expect(0, 9, '\p{^Is_Line_Break: - BreakAFTER}', ""); +Expect(0, 9, '\P{Is_Line_Break: - BreakAFTER}', ""); +Expect(1, 9, '\P{^Is_Line_Break: - BreakAFTER}', ""); +Expect(0, 8, '\p{Is_Line_Break: - BreakAFTER}', ""); +Expect(1, 8, '\p{^Is_Line_Break: - BreakAFTER}', ""); +Expect(1, 8, '\P{Is_Line_Break: - BreakAFTER}', ""); +Expect(0, 8, '\P{^Is_Line_Break: - BreakAFTER}', ""); +Error('\p{Is_Lb=/a/--BA}'); +Error('\P{Is_Lb=/a/--BA}'); +Expect(1, 9, '\p{Is_Lb=ba}', ""); +Expect(0, 9, '\p{^Is_Lb=ba}', ""); +Expect(0, 9, '\P{Is_Lb=ba}', ""); +Expect(1, 9, '\P{^Is_Lb=ba}', ""); +Expect(0, 8, '\p{Is_Lb=ba}', ""); +Expect(1, 8, '\p{^Is_Lb=ba}', ""); +Expect(1, 8, '\P{Is_Lb=ba}', ""); +Expect(0, 8, '\P{^Is_Lb=ba}', ""); +Expect(1, 9, '\p{Is_Lb: --BA}', ""); +Expect(0, 9, '\p{^Is_Lb: --BA}', ""); +Expect(0, 9, '\P{Is_Lb: --BA}', ""); +Expect(1, 9, '\P{^Is_Lb: --BA}', ""); +Expect(0, 8, '\p{Is_Lb: --BA}', ""); +Expect(1, 8, '\p{^Is_Lb: --BA}', ""); +Expect(1, 8, '\P{Is_Lb: --BA}', ""); +Expect(0, 8, '\P{^Is_Lb: --BA}', ""); +Error('\p{Line_Break: -Line-Feed/a/}'); +Error('\P{Line_Break: -Line-Feed/a/}'); +Expect(1, 10, '\p{Line_Break=linefeed}', ""); +Expect(0, 10, '\p{^Line_Break=linefeed}', ""); +Expect(0, 10, '\P{Line_Break=linefeed}', ""); +Expect(1, 10, '\P{^Line_Break=linefeed}', ""); +Expect(0, 9, '\p{Line_Break=linefeed}', ""); +Expect(1, 9, '\p{^Line_Break=linefeed}', ""); +Expect(1, 9, '\P{Line_Break=linefeed}', ""); +Expect(0, 9, '\P{^Line_Break=linefeed}', ""); +Expect(1, 10, '\p{Line_Break=-_Line FEED}', ""); +Expect(0, 10, '\p{^Line_Break=-_Line FEED}', ""); +Expect(0, 10, '\P{Line_Break=-_Line FEED}', ""); +Expect(1, 10, '\P{^Line_Break=-_Line FEED}', ""); +Expect(0, 9, '\p{Line_Break=-_Line FEED}', ""); +Expect(1, 9, '\p{^Line_Break=-_Line FEED}', ""); +Expect(1, 9, '\P{Line_Break=-_Line FEED}', ""); +Expect(0, 9, '\P{^Line_Break=-_Line FEED}', ""); +Error('\p{Lb: lf:=}'); +Error('\P{Lb: lf:=}'); +Expect(1, 10, '\p{Lb=lf}', ""); +Expect(0, 10, '\p{^Lb=lf}', ""); +Expect(0, 10, '\P{Lb=lf}', ""); +Expect(1, 10, '\P{^Lb=lf}', ""); +Expect(0, 9, '\p{Lb=lf}', ""); +Expect(1, 9, '\p{^Lb=lf}', ""); +Expect(1, 9, '\P{Lb=lf}', ""); +Expect(0, 9, '\P{^Lb=lf}', ""); +Expect(1, 10, '\p{Lb:_-LF}', ""); +Expect(0, 10, '\p{^Lb:_-LF}', ""); +Expect(0, 10, '\P{Lb:_-LF}', ""); +Expect(1, 10, '\P{^Lb:_-LF}', ""); +Expect(0, 9, '\p{Lb:_-LF}', ""); +Expect(1, 9, '\p{^Lb:_-LF}', ""); +Expect(1, 9, '\P{Lb:_-LF}', ""); +Expect(0, 9, '\P{^Lb:_-LF}', ""); +Error('\p{Is_Line_Break: LineFeed/a/}'); +Error('\P{Is_Line_Break: LineFeed/a/}'); +Expect(1, 10, '\p{Is_Line_Break=linefeed}', ""); +Expect(0, 10, '\p{^Is_Line_Break=linefeed}', ""); +Expect(0, 10, '\P{Is_Line_Break=linefeed}', ""); +Expect(1, 10, '\P{^Is_Line_Break=linefeed}', ""); +Expect(0, 9, '\p{Is_Line_Break=linefeed}', ""); +Expect(1, 9, '\p{^Is_Line_Break=linefeed}', ""); +Expect(1, 9, '\P{Is_Line_Break=linefeed}', ""); +Expect(0, 9, '\P{^Is_Line_Break=linefeed}', ""); +Expect(1, 10, '\p{Is_Line_Break=_Line Feed}', ""); +Expect(0, 10, '\p{^Is_Line_Break=_Line Feed}', ""); +Expect(0, 10, '\P{Is_Line_Break=_Line Feed}', ""); +Expect(1, 10, '\P{^Is_Line_Break=_Line Feed}', ""); +Expect(0, 9, '\p{Is_Line_Break=_Line Feed}', ""); +Expect(1, 9, '\p{^Is_Line_Break=_Line Feed}', ""); +Expect(1, 9, '\P{Is_Line_Break=_Line Feed}', ""); +Expect(0, 9, '\P{^Is_Line_Break=_Line Feed}', ""); +Error('\p{Is_Lb=_ LF/a/}'); +Error('\P{Is_Lb=_ LF/a/}'); +Expect(1, 10, '\p{Is_Lb: lf}', ""); +Expect(0, 10, '\p{^Is_Lb: lf}', ""); +Expect(0, 10, '\P{Is_Lb: lf}', ""); +Expect(1, 10, '\P{^Is_Lb: lf}', ""); +Expect(0, 9, '\p{Is_Lb: lf}', ""); +Expect(1, 9, '\p{^Is_Lb: lf}', ""); +Expect(1, 9, '\P{Is_Lb: lf}', ""); +Expect(0, 9, '\P{^Is_Lb: lf}', ""); +Expect(1, 10, '\p{Is_Lb: lf}', ""); +Expect(0, 10, '\p{^Is_Lb: lf}', ""); +Expect(0, 10, '\P{Is_Lb: lf}', ""); +Expect(1, 10, '\P{^Is_Lb: lf}', ""); +Expect(0, 9, '\p{Is_Lb: lf}', ""); +Expect(1, 9, '\p{^Is_Lb: lf}', ""); +Expect(1, 9, '\P{Is_Lb: lf}', ""); +Expect(0, 9, '\P{^Is_Lb: lf}', ""); +Error('\p{Line_Break=/a/ _ambiguous}'); +Error('\P{Line_Break=/a/ _ambiguous}'); +Expect(1, 711, '\p{Line_Break: ambiguous}', ""); +Expect(0, 711, '\p{^Line_Break: ambiguous}', ""); +Expect(0, 711, '\P{Line_Break: ambiguous}', ""); +Expect(1, 711, '\P{^Line_Break: ambiguous}', ""); +Expect(0, 7, '\p{Line_Break: ambiguous}', ""); +Expect(1, 7, '\p{^Line_Break: ambiguous}', ""); +Expect(1, 7, '\P{Line_Break: ambiguous}', ""); +Expect(0, 7, '\P{^Line_Break: ambiguous}', ""); +Expect(1, 711, '\p{Line_Break: _Ambiguous}', ""); +Expect(0, 711, '\p{^Line_Break: _Ambiguous}', ""); +Expect(0, 711, '\P{Line_Break: _Ambiguous}', ""); +Expect(1, 711, '\P{^Line_Break: _Ambiguous}', ""); +Expect(0, 7, '\p{Line_Break: _Ambiguous}', ""); +Expect(1, 7, '\p{^Line_Break: _Ambiguous}', ""); +Expect(1, 7, '\P{Line_Break: _Ambiguous}', ""); +Expect(0, 7, '\P{^Line_Break: _Ambiguous}', ""); +Error('\p{Lb=_:=AI}'); +Error('\P{Lb=_:=AI}'); +Expect(1, 711, '\p{Lb: ai}', ""); +Expect(0, 711, '\p{^Lb: ai}', ""); +Expect(0, 711, '\P{Lb: ai}', ""); +Expect(1, 711, '\P{^Lb: ai}', ""); +Expect(0, 7, '\p{Lb: ai}', ""); +Expect(1, 7, '\p{^Lb: ai}', ""); +Expect(1, 7, '\P{Lb: ai}', ""); +Expect(0, 7, '\P{^Lb: ai}', ""); +Expect(1, 711, '\p{Lb=- AI}', ""); +Expect(0, 711, '\p{^Lb=- AI}', ""); +Expect(0, 711, '\P{Lb=- AI}', ""); +Expect(1, 711, '\P{^Lb=- AI}', ""); +Expect(0, 7, '\p{Lb=- AI}', ""); +Expect(1, 7, '\p{^Lb=- AI}', ""); +Expect(1, 7, '\P{Lb=- AI}', ""); +Expect(0, 7, '\P{^Lb=- AI}', ""); +Error('\p{Is_Line_Break=_ Ambiguous/a/}'); +Error('\P{Is_Line_Break=_ Ambiguous/a/}'); +Expect(1, 711, '\p{Is_Line_Break: ambiguous}', ""); +Expect(0, 711, '\p{^Is_Line_Break: ambiguous}', ""); +Expect(0, 711, '\P{Is_Line_Break: ambiguous}', ""); +Expect(1, 711, '\P{^Is_Line_Break: ambiguous}', ""); +Expect(0, 7, '\p{Is_Line_Break: ambiguous}', ""); +Expect(1, 7, '\p{^Is_Line_Break: ambiguous}', ""); +Expect(1, 7, '\P{Is_Line_Break: ambiguous}', ""); +Expect(0, 7, '\P{^Is_Line_Break: ambiguous}', ""); +Expect(1, 711, '\p{Is_Line_Break= AMBIGUOUS}', ""); +Expect(0, 711, '\p{^Is_Line_Break= AMBIGUOUS}', ""); +Expect(0, 711, '\P{Is_Line_Break= AMBIGUOUS}', ""); +Expect(1, 711, '\P{^Is_Line_Break= AMBIGUOUS}', ""); +Expect(0, 7, '\p{Is_Line_Break= AMBIGUOUS}', ""); +Expect(1, 7, '\p{^Is_Line_Break= AMBIGUOUS}', ""); +Expect(1, 7, '\P{Is_Line_Break= AMBIGUOUS}', ""); +Expect(0, 7, '\P{^Is_Line_Break= AMBIGUOUS}', ""); +Error('\p{Is_Lb: _AI/a/}'); +Error('\P{Is_Lb: _AI/a/}'); +Expect(1, 711, '\p{Is_Lb=ai}', ""); +Expect(0, 711, '\p{^Is_Lb=ai}', ""); +Expect(0, 711, '\P{Is_Lb=ai}', ""); +Expect(1, 711, '\P{^Is_Lb=ai}', ""); +Expect(0, 7, '\p{Is_Lb=ai}', ""); +Expect(1, 7, '\p{^Is_Lb=ai}', ""); +Expect(1, 7, '\P{Is_Lb=ai}', ""); +Expect(0, 7, '\P{^Is_Lb=ai}', ""); +Expect(1, 711, '\p{Is_Lb=_ai}', ""); +Expect(0, 711, '\p{^Is_Lb=_ai}', ""); +Expect(0, 711, '\P{Is_Lb=_ai}', ""); +Expect(1, 711, '\P{^Is_Lb=_ai}', ""); +Expect(0, 7, '\p{Is_Lb=_ai}', ""); +Expect(1, 7, '\p{^Is_Lb=_ai}', ""); +Expect(1, 7, '\P{Is_Lb=_ai}', ""); +Expect(0, 7, '\P{^Is_Lb=_ai}', ""); +Error('\p{Line_Break= Contingent/a/break}'); +Error('\P{Line_Break= Contingent/a/break}'); +Expect(1, 65532, '\p{Line_Break=contingentbreak}', ""); +Expect(0, 65532, '\p{^Line_Break=contingentbreak}', ""); +Expect(0, 65532, '\P{Line_Break=contingentbreak}', ""); +Expect(1, 65532, '\P{^Line_Break=contingentbreak}', ""); +Expect(0, 65531, '\p{Line_Break=contingentbreak}', ""); +Expect(1, 65531, '\p{^Line_Break=contingentbreak}', ""); +Expect(1, 65531, '\P{Line_Break=contingentbreak}', ""); +Expect(0, 65531, '\P{^Line_Break=contingentbreak}', ""); +Expect(1, 65532, '\p{Line_Break= Contingent_BREAK}', ""); +Expect(0, 65532, '\p{^Line_Break= Contingent_BREAK}', ""); +Expect(0, 65532, '\P{Line_Break= Contingent_BREAK}', ""); +Expect(1, 65532, '\P{^Line_Break= Contingent_BREAK}', ""); +Expect(0, 65531, '\p{Line_Break= Contingent_BREAK}', ""); +Expect(1, 65531, '\p{^Line_Break= Contingent_BREAK}', ""); +Expect(1, 65531, '\P{Line_Break= Contingent_BREAK}', ""); +Expect(0, 65531, '\P{^Line_Break= Contingent_BREAK}', ""); +Error('\p{Lb=/a/- CB}'); +Error('\P{Lb=/a/- CB}'); +Expect(1, 65532, '\p{Lb=cb}', ""); +Expect(0, 65532, '\p{^Lb=cb}', ""); +Expect(0, 65532, '\P{Lb=cb}', ""); +Expect(1, 65532, '\P{^Lb=cb}', ""); +Expect(0, 65531, '\p{Lb=cb}', ""); +Expect(1, 65531, '\p{^Lb=cb}', ""); +Expect(1, 65531, '\P{Lb=cb}', ""); +Expect(0, 65531, '\P{^Lb=cb}', ""); +Expect(1, 65532, '\p{Lb= cb}', ""); +Expect(0, 65532, '\p{^Lb= cb}', ""); +Expect(0, 65532, '\P{Lb= cb}', ""); +Expect(1, 65532, '\P{^Lb= cb}', ""); +Expect(0, 65531, '\p{Lb= cb}', ""); +Expect(1, 65531, '\p{^Lb= cb}', ""); +Expect(1, 65531, '\P{Lb= cb}', ""); +Expect(0, 65531, '\P{^Lb= cb}', ""); +Error('\p{Is_Line_Break: --CONTINGENT Break:=}'); +Error('\P{Is_Line_Break: --CONTINGENT Break:=}'); +Expect(1, 65532, '\p{Is_Line_Break=contingentbreak}', ""); +Expect(0, 65532, '\p{^Is_Line_Break=contingentbreak}', ""); +Expect(0, 65532, '\P{Is_Line_Break=contingentbreak}', ""); +Expect(1, 65532, '\P{^Is_Line_Break=contingentbreak}', ""); +Expect(0, 65531, '\p{Is_Line_Break=contingentbreak}', ""); +Expect(1, 65531, '\p{^Is_Line_Break=contingentbreak}', ""); +Expect(1, 65531, '\P{Is_Line_Break=contingentbreak}', ""); +Expect(0, 65531, '\P{^Is_Line_Break=contingentbreak}', ""); +Expect(1, 65532, '\p{Is_Line_Break=_ Contingent_BREAK}', ""); +Expect(0, 65532, '\p{^Is_Line_Break=_ Contingent_BREAK}', ""); +Expect(0, 65532, '\P{Is_Line_Break=_ Contingent_BREAK}', ""); +Expect(1, 65532, '\P{^Is_Line_Break=_ Contingent_BREAK}', ""); +Expect(0, 65531, '\p{Is_Line_Break=_ Contingent_BREAK}', ""); +Expect(1, 65531, '\p{^Is_Line_Break=_ Contingent_BREAK}', ""); +Expect(1, 65531, '\P{Is_Line_Break=_ Contingent_BREAK}', ""); +Expect(0, 65531, '\P{^Is_Line_Break=_ Contingent_BREAK}', ""); +Error('\p{Is_Lb=:=_-CB}'); +Error('\P{Is_Lb=:=_-CB}'); +Expect(1, 65532, '\p{Is_Lb=cb}', ""); +Expect(0, 65532, '\p{^Is_Lb=cb}', ""); +Expect(0, 65532, '\P{Is_Lb=cb}', ""); +Expect(1, 65532, '\P{^Is_Lb=cb}', ""); +Expect(0, 65531, '\p{Is_Lb=cb}', ""); +Expect(1, 65531, '\p{^Is_Lb=cb}', ""); +Expect(1, 65531, '\P{Is_Lb=cb}', ""); +Expect(0, 65531, '\P{^Is_Lb=cb}', ""); +Expect(1, 65532, '\p{Is_Lb=-CB}', ""); +Expect(0, 65532, '\p{^Is_Lb=-CB}', ""); +Expect(0, 65532, '\P{Is_Lb=-CB}', ""); +Expect(1, 65532, '\P{^Is_Lb=-CB}', ""); +Expect(0, 65531, '\p{Is_Lb=-CB}', ""); +Expect(1, 65531, '\p{^Is_Lb=-CB}', ""); +Expect(1, 65531, '\P{Is_Lb=-CB}', ""); +Expect(0, 65531, '\P{^Is_Lb=-CB}', ""); +Error('\p{Line_Break: _:=Exclamation}'); +Error('\P{Line_Break: _:=Exclamation}'); +Expect(1, 33, '\p{Line_Break=exclamation}', ""); +Expect(0, 33, '\p{^Line_Break=exclamation}', ""); +Expect(0, 33, '\P{Line_Break=exclamation}', ""); +Expect(1, 33, '\P{^Line_Break=exclamation}', ""); +Expect(0, 32, '\p{Line_Break=exclamation}', ""); +Expect(1, 32, '\p{^Line_Break=exclamation}', ""); +Expect(1, 32, '\P{Line_Break=exclamation}', ""); +Expect(0, 32, '\P{^Line_Break=exclamation}', ""); +Expect(1, 33, '\p{Line_Break= -exclamation}', ""); +Expect(0, 33, '\p{^Line_Break= -exclamation}', ""); +Expect(0, 33, '\P{Line_Break= -exclamation}', ""); +Expect(1, 33, '\P{^Line_Break= -exclamation}', ""); +Expect(0, 32, '\p{Line_Break= -exclamation}', ""); +Expect(1, 32, '\p{^Line_Break= -exclamation}', ""); +Expect(1, 32, '\P{Line_Break= -exclamation}', ""); +Expect(0, 32, '\P{^Line_Break= -exclamation}', ""); +Error('\p{Lb=:= EX}'); +Error('\P{Lb=:= EX}'); +Expect(1, 33, '\p{Lb=ex}', ""); +Expect(0, 33, '\p{^Lb=ex}', ""); +Expect(0, 33, '\P{Lb=ex}', ""); +Expect(1, 33, '\P{^Lb=ex}', ""); +Expect(0, 32, '\p{Lb=ex}', ""); +Expect(1, 32, '\p{^Lb=ex}', ""); +Expect(1, 32, '\P{Lb=ex}', ""); +Expect(0, 32, '\P{^Lb=ex}', ""); +Expect(1, 33, '\p{Lb=-EX}', ""); +Expect(0, 33, '\p{^Lb=-EX}', ""); +Expect(0, 33, '\P{Lb=-EX}', ""); +Expect(1, 33, '\P{^Lb=-EX}', ""); +Expect(0, 32, '\p{Lb=-EX}', ""); +Expect(1, 32, '\p{^Lb=-EX}', ""); +Expect(1, 32, '\P{Lb=-EX}', ""); +Expect(0, 32, '\P{^Lb=-EX}', ""); +Error('\p{Is_Line_Break= EXCLAMATION/a/}'); +Error('\P{Is_Line_Break= EXCLAMATION/a/}'); +Expect(1, 33, '\p{Is_Line_Break=exclamation}', ""); +Expect(0, 33, '\p{^Is_Line_Break=exclamation}', ""); +Expect(0, 33, '\P{Is_Line_Break=exclamation}', ""); +Expect(1, 33, '\P{^Is_Line_Break=exclamation}', ""); +Expect(0, 32, '\p{Is_Line_Break=exclamation}', ""); +Expect(1, 32, '\p{^Is_Line_Break=exclamation}', ""); +Expect(1, 32, '\P{Is_Line_Break=exclamation}', ""); +Expect(0, 32, '\P{^Is_Line_Break=exclamation}', ""); +Expect(1, 33, '\p{Is_Line_Break=- Exclamation}', ""); +Expect(0, 33, '\p{^Is_Line_Break=- Exclamation}', ""); +Expect(0, 33, '\P{Is_Line_Break=- Exclamation}', ""); +Expect(1, 33, '\P{^Is_Line_Break=- Exclamation}', ""); +Expect(0, 32, '\p{Is_Line_Break=- Exclamation}', ""); +Expect(1, 32, '\p{^Is_Line_Break=- Exclamation}', ""); +Expect(1, 32, '\P{Is_Line_Break=- Exclamation}', ""); +Expect(0, 32, '\P{^Is_Line_Break=- Exclamation}', ""); +Error('\p{Is_Lb: EX/a/}'); +Error('\P{Is_Lb: EX/a/}'); +Expect(1, 33, '\p{Is_Lb:ex}', ""); +Expect(0, 33, '\p{^Is_Lb:ex}', ""); +Expect(0, 33, '\P{Is_Lb:ex}', ""); +Expect(1, 33, '\P{^Is_Lb:ex}', ""); +Expect(0, 32, '\p{Is_Lb:ex}', ""); +Expect(1, 32, '\p{^Is_Lb:ex}', ""); +Expect(1, 32, '\P{Is_Lb:ex}', ""); +Expect(0, 32, '\P{^Is_Lb:ex}', ""); +Expect(1, 33, '\p{Is_Lb=__EX}', ""); +Expect(0, 33, '\p{^Is_Lb=__EX}', ""); +Expect(0, 33, '\P{Is_Lb=__EX}', ""); +Expect(1, 33, '\P{^Is_Lb=__EX}', ""); +Expect(0, 32, '\p{Is_Lb=__EX}', ""); +Expect(1, 32, '\p{^Is_Lb=__EX}', ""); +Expect(1, 32, '\P{Is_Lb=__EX}', ""); +Expect(0, 32, '\P{^Is_Lb=__EX}', ""); +Error('\p{Line_Break: _ Ideographic/a/}'); +Error('\P{Line_Break: _ Ideographic/a/}'); +Expect(1, 11929, '\p{Line_Break: ideographic}', ""); +Expect(0, 11929, '\p{^Line_Break: ideographic}', ""); +Expect(0, 11929, '\P{Line_Break: ideographic}', ""); +Expect(1, 11929, '\P{^Line_Break: ideographic}', ""); +Expect(0, 11903, '\p{Line_Break: ideographic}', ""); +Expect(1, 11903, '\p{^Line_Break: ideographic}', ""); +Expect(1, 11903, '\P{Line_Break: ideographic}', ""); +Expect(0, 11903, '\P{^Line_Break: ideographic}', ""); +Expect(1, 11929, '\p{Line_Break=- Ideographic}', ""); +Expect(0, 11929, '\p{^Line_Break=- Ideographic}', ""); +Expect(0, 11929, '\P{Line_Break=- Ideographic}', ""); +Expect(1, 11929, '\P{^Line_Break=- Ideographic}', ""); +Expect(0, 11903, '\p{Line_Break=- Ideographic}', ""); +Expect(1, 11903, '\p{^Line_Break=- Ideographic}', ""); +Expect(1, 11903, '\P{Line_Break=- Ideographic}', ""); +Expect(0, 11903, '\P{^Line_Break=- Ideographic}', ""); +Error('\p{Lb= :=ID}'); +Error('\P{Lb= :=ID}'); +Expect(1, 11929, '\p{Lb=id}', ""); +Expect(0, 11929, '\p{^Lb=id}', ""); +Expect(0, 11929, '\P{Lb=id}', ""); +Expect(1, 11929, '\P{^Lb=id}', ""); +Expect(0, 11903, '\p{Lb=id}', ""); +Expect(1, 11903, '\p{^Lb=id}', ""); +Expect(1, 11903, '\P{Lb=id}', ""); +Expect(0, 11903, '\P{^Lb=id}', ""); +Expect(1, 11929, '\p{Lb=_ID}', ""); +Expect(0, 11929, '\p{^Lb=_ID}', ""); +Expect(0, 11929, '\P{Lb=_ID}', ""); +Expect(1, 11929, '\P{^Lb=_ID}', ""); +Expect(0, 11903, '\p{Lb=_ID}', ""); +Expect(1, 11903, '\p{^Lb=_ID}', ""); +Expect(1, 11903, '\P{Lb=_ID}', ""); +Expect(0, 11903, '\P{^Lb=_ID}', ""); +Error('\p{Is_Line_Break= -Ideographic/a/}'); +Error('\P{Is_Line_Break= -Ideographic/a/}'); +Expect(1, 11929, '\p{Is_Line_Break=ideographic}', ""); +Expect(0, 11929, '\p{^Is_Line_Break=ideographic}', ""); +Expect(0, 11929, '\P{Is_Line_Break=ideographic}', ""); +Expect(1, 11929, '\P{^Is_Line_Break=ideographic}', ""); +Expect(0, 11903, '\p{Is_Line_Break=ideographic}', ""); +Expect(1, 11903, '\p{^Is_Line_Break=ideographic}', ""); +Expect(1, 11903, '\P{Is_Line_Break=ideographic}', ""); +Expect(0, 11903, '\P{^Is_Line_Break=ideographic}', ""); +Expect(1, 11929, '\p{Is_Line_Break= IDEOGRAPHIC}', ""); +Expect(0, 11929, '\p{^Is_Line_Break= IDEOGRAPHIC}', ""); +Expect(0, 11929, '\P{Is_Line_Break= IDEOGRAPHIC}', ""); +Expect(1, 11929, '\P{^Is_Line_Break= IDEOGRAPHIC}', ""); +Expect(0, 11903, '\p{Is_Line_Break= IDEOGRAPHIC}', ""); +Expect(1, 11903, '\p{^Is_Line_Break= IDEOGRAPHIC}', ""); +Expect(1, 11903, '\P{Is_Line_Break= IDEOGRAPHIC}', ""); +Expect(0, 11903, '\P{^Is_Line_Break= IDEOGRAPHIC}', ""); +Error('\p{Is_Lb=/a/ID}'); +Error('\P{Is_Lb=/a/ID}'); +Expect(1, 11929, '\p{Is_Lb=id}', ""); +Expect(0, 11929, '\p{^Is_Lb=id}', ""); +Expect(0, 11929, '\P{Is_Lb=id}', ""); +Expect(1, 11929, '\P{^Is_Lb=id}', ""); +Expect(0, 11903, '\p{Is_Lb=id}', ""); +Expect(1, 11903, '\p{^Is_Lb=id}', ""); +Expect(1, 11903, '\P{Is_Lb=id}', ""); +Expect(0, 11903, '\P{^Is_Lb=id}', ""); +Expect(1, 11929, '\p{Is_Lb=-id}', ""); +Expect(0, 11929, '\p{^Is_Lb=-id}', ""); +Expect(0, 11929, '\P{Is_Lb=-id}', ""); +Expect(1, 11929, '\P{^Is_Lb=-id}', ""); +Expect(0, 11903, '\p{Is_Lb=-id}', ""); +Expect(1, 11903, '\p{^Is_Lb=-id}', ""); +Expect(1, 11903, '\P{Is_Lb=-id}', ""); +Expect(0, 11903, '\P{^Is_Lb=-id}', ""); +Error('\p{Line_Break=/a/- WORD joiner}'); +Error('\P{Line_Break=/a/- WORD joiner}'); +Expect(1, 8288, '\p{Line_Break=wordjoiner}', ""); +Expect(0, 8288, '\p{^Line_Break=wordjoiner}', ""); +Expect(0, 8288, '\P{Line_Break=wordjoiner}', ""); +Expect(1, 8288, '\P{^Line_Break=wordjoiner}', ""); +Expect(0, 8287, '\p{Line_Break=wordjoiner}', ""); +Expect(1, 8287, '\p{^Line_Break=wordjoiner}', ""); +Expect(1, 8287, '\P{Line_Break=wordjoiner}', ""); +Expect(0, 8287, '\P{^Line_Break=wordjoiner}', ""); +Expect(1, 8288, '\p{Line_Break=_ Word JOINER}', ""); +Expect(0, 8288, '\p{^Line_Break=_ Word JOINER}', ""); +Expect(0, 8288, '\P{Line_Break=_ Word JOINER}', ""); +Expect(1, 8288, '\P{^Line_Break=_ Word JOINER}', ""); +Expect(0, 8287, '\p{Line_Break=_ Word JOINER}', ""); +Expect(1, 8287, '\p{^Line_Break=_ Word JOINER}', ""); +Expect(1, 8287, '\P{Line_Break=_ Word JOINER}', ""); +Expect(0, 8287, '\P{^Line_Break=_ Word JOINER}', ""); +Error('\p{Lb: - WJ:=}'); +Error('\P{Lb: - WJ:=}'); +Expect(1, 8288, '\p{Lb=wj}', ""); +Expect(0, 8288, '\p{^Lb=wj}', ""); +Expect(0, 8288, '\P{Lb=wj}', ""); +Expect(1, 8288, '\P{^Lb=wj}', ""); +Expect(0, 8287, '\p{Lb=wj}', ""); +Expect(1, 8287, '\p{^Lb=wj}', ""); +Expect(1, 8287, '\P{Lb=wj}', ""); +Expect(0, 8287, '\P{^Lb=wj}', ""); +Expect(1, 8288, '\p{Lb= WJ}', ""); +Expect(0, 8288, '\p{^Lb= WJ}', ""); +Expect(0, 8288, '\P{Lb= WJ}', ""); +Expect(1, 8288, '\P{^Lb= WJ}', ""); +Expect(0, 8287, '\p{Lb= WJ}', ""); +Expect(1, 8287, '\p{^Lb= WJ}', ""); +Expect(1, 8287, '\P{Lb= WJ}', ""); +Expect(0, 8287, '\P{^Lb= WJ}', ""); +Error('\p{Is_Line_Break=-/a/Word Joiner}'); +Error('\P{Is_Line_Break=-/a/Word Joiner}'); +Expect(1, 8288, '\p{Is_Line_Break: wordjoiner}', ""); +Expect(0, 8288, '\p{^Is_Line_Break: wordjoiner}', ""); +Expect(0, 8288, '\P{Is_Line_Break: wordjoiner}', ""); +Expect(1, 8288, '\P{^Is_Line_Break: wordjoiner}', ""); +Expect(0, 8287, '\p{Is_Line_Break: wordjoiner}', ""); +Expect(1, 8287, '\p{^Is_Line_Break: wordjoiner}', ""); +Expect(1, 8287, '\P{Is_Line_Break: wordjoiner}', ""); +Expect(0, 8287, '\P{^Is_Line_Break: wordjoiner}', ""); +Expect(1, 8288, '\p{Is_Line_Break= Word-Joiner}', ""); +Expect(0, 8288, '\p{^Is_Line_Break= Word-Joiner}', ""); +Expect(0, 8288, '\P{Is_Line_Break= Word-Joiner}', ""); +Expect(1, 8288, '\P{^Is_Line_Break= Word-Joiner}', ""); +Expect(0, 8287, '\p{Is_Line_Break= Word-Joiner}', ""); +Expect(1, 8287, '\p{^Is_Line_Break= Word-Joiner}', ""); +Expect(1, 8287, '\P{Is_Line_Break= Word-Joiner}', ""); +Expect(0, 8287, '\P{^Is_Line_Break= Word-Joiner}', ""); +Error('\p{Is_Lb=/a/-wj}'); +Error('\P{Is_Lb=/a/-wj}'); +Expect(1, 8288, '\p{Is_Lb=wj}', ""); +Expect(0, 8288, '\p{^Is_Lb=wj}', ""); +Expect(0, 8288, '\P{Is_Lb=wj}', ""); +Expect(1, 8288, '\P{^Is_Lb=wj}', ""); +Expect(0, 8287, '\p{Is_Lb=wj}', ""); +Expect(1, 8287, '\p{^Is_Lb=wj}', ""); +Expect(1, 8287, '\P{Is_Lb=wj}', ""); +Expect(0, 8287, '\P{^Is_Lb=wj}', ""); +Expect(1, 8288, '\p{Is_Lb= WJ}', ""); +Expect(0, 8288, '\p{^Is_Lb= WJ}', ""); +Expect(0, 8288, '\P{Is_Lb= WJ}', ""); +Expect(1, 8288, '\P{^Is_Lb= WJ}', ""); +Expect(0, 8287, '\p{Is_Lb= WJ}', ""); +Expect(1, 8287, '\p{^Is_Lb= WJ}', ""); +Expect(1, 8287, '\P{Is_Lb= WJ}', ""); +Expect(0, 8287, '\P{^Is_Lb= WJ}', ""); +Error('\p{Line_Break=-/a/H2}'); +Error('\P{Line_Break=-/a/H2}'); +Expect(1, 44032, '\p{Line_Break=h2}', ""); +Expect(0, 44032, '\p{^Line_Break=h2}', ""); +Expect(0, 44032, '\P{Line_Break=h2}', ""); +Expect(1, 44032, '\P{^Line_Break=h2}', ""); +Expect(0, 44031, '\p{Line_Break=h2}', ""); +Expect(1, 44031, '\p{^Line_Break=h2}', ""); +Expect(1, 44031, '\P{Line_Break=h2}', ""); +Expect(0, 44031, '\P{^Line_Break=h2}', ""); +Expect(1, 44032, '\p{Line_Break= h2}', ""); +Expect(0, 44032, '\p{^Line_Break= h2}', ""); +Expect(0, 44032, '\P{Line_Break= h2}', ""); +Expect(1, 44032, '\P{^Line_Break= h2}', ""); +Expect(0, 44031, '\p{Line_Break= h2}', ""); +Expect(1, 44031, '\p{^Line_Break= h2}', ""); +Expect(1, 44031, '\P{Line_Break= h2}', ""); +Expect(0, 44031, '\P{^Line_Break= h2}', ""); +Error('\p{Lb=--H2:=}'); +Error('\P{Lb=--H2:=}'); +Expect(1, 44032, '\p{Lb=h2}', ""); +Expect(0, 44032, '\p{^Lb=h2}', ""); +Expect(0, 44032, '\P{Lb=h2}', ""); +Expect(1, 44032, '\P{^Lb=h2}', ""); +Expect(0, 44031, '\p{Lb=h2}', ""); +Expect(1, 44031, '\p{^Lb=h2}', ""); +Expect(1, 44031, '\P{Lb=h2}', ""); +Expect(0, 44031, '\P{^Lb=h2}', ""); +Expect(1, 44032, '\p{Lb: H2}', ""); +Expect(0, 44032, '\p{^Lb: H2}', ""); +Expect(0, 44032, '\P{Lb: H2}', ""); +Expect(1, 44032, '\P{^Lb: H2}', ""); +Expect(0, 44031, '\p{Lb: H2}', ""); +Expect(1, 44031, '\p{^Lb: H2}', ""); +Expect(1, 44031, '\P{Lb: H2}', ""); +Expect(0, 44031, '\P{^Lb: H2}', ""); +Error('\p{Is_Line_Break=/a/_-h2}'); +Error('\P{Is_Line_Break=/a/_-h2}'); +Expect(1, 44032, '\p{Is_Line_Break=h2}', ""); +Expect(0, 44032, '\p{^Is_Line_Break=h2}', ""); +Expect(0, 44032, '\P{Is_Line_Break=h2}', ""); +Expect(1, 44032, '\P{^Is_Line_Break=h2}', ""); +Expect(0, 44031, '\p{Is_Line_Break=h2}', ""); +Expect(1, 44031, '\p{^Is_Line_Break=h2}', ""); +Expect(1, 44031, '\P{Is_Line_Break=h2}', ""); +Expect(0, 44031, '\P{^Is_Line_Break=h2}', ""); +Expect(1, 44032, '\p{Is_Line_Break=- h2}', ""); +Expect(0, 44032, '\p{^Is_Line_Break=- h2}', ""); +Expect(0, 44032, '\P{Is_Line_Break=- h2}', ""); +Expect(1, 44032, '\P{^Is_Line_Break=- h2}', ""); +Expect(0, 44031, '\p{Is_Line_Break=- h2}', ""); +Expect(1, 44031, '\p{^Is_Line_Break=- h2}', ""); +Expect(1, 44031, '\P{Is_Line_Break=- h2}', ""); +Expect(0, 44031, '\P{^Is_Line_Break=- h2}', ""); +Error('\p{Is_Lb=/a/ H2}'); +Error('\P{Is_Lb=/a/ H2}'); +Expect(1, 44032, '\p{Is_Lb=h2}', ""); +Expect(0, 44032, '\p{^Is_Lb=h2}', ""); +Expect(0, 44032, '\P{Is_Lb=h2}', ""); +Expect(1, 44032, '\P{^Is_Lb=h2}', ""); +Expect(0, 44031, '\p{Is_Lb=h2}', ""); +Expect(1, 44031, '\p{^Is_Lb=h2}', ""); +Expect(1, 44031, '\P{Is_Lb=h2}', ""); +Expect(0, 44031, '\P{^Is_Lb=h2}', ""); +Expect(1, 44032, '\p{Is_Lb=__h2}', ""); +Expect(0, 44032, '\p{^Is_Lb=__h2}', ""); +Expect(0, 44032, '\P{Is_Lb=__h2}', ""); +Expect(1, 44032, '\P{^Is_Lb=__h2}', ""); +Expect(0, 44031, '\p{Is_Lb=__h2}', ""); +Expect(1, 44031, '\p{^Is_Lb=__h2}', ""); +Expect(1, 44031, '\P{Is_Lb=__h2}', ""); +Expect(0, 44031, '\P{^Is_Lb=__h2}', ""); +Error('\p{Line_Break=-Break both:=}'); +Error('\P{Line_Break=-Break both:=}'); +Expect(1, 8212, '\p{Line_Break=breakboth}', ""); +Expect(0, 8212, '\p{^Line_Break=breakboth}', ""); +Expect(0, 8212, '\P{Line_Break=breakboth}', ""); +Expect(1, 8212, '\P{^Line_Break=breakboth}', ""); +Expect(0, 8211, '\p{Line_Break=breakboth}', ""); +Expect(1, 8211, '\p{^Line_Break=breakboth}', ""); +Expect(1, 8211, '\P{Line_Break=breakboth}', ""); +Expect(0, 8211, '\P{^Line_Break=breakboth}', ""); +Expect(1, 8212, '\p{Line_Break=- Break_both}', ""); +Expect(0, 8212, '\p{^Line_Break=- Break_both}', ""); +Expect(0, 8212, '\P{Line_Break=- Break_both}', ""); +Expect(1, 8212, '\P{^Line_Break=- Break_both}', ""); +Expect(0, 8211, '\p{Line_Break=- Break_both}', ""); +Expect(1, 8211, '\p{^Line_Break=- Break_both}', ""); +Expect(1, 8211, '\P{Line_Break=- Break_both}', ""); +Expect(0, 8211, '\P{^Line_Break=- Break_both}', ""); +Error('\p{Lb=- B2/a/}'); +Error('\P{Lb=- B2/a/}'); +Expect(1, 8212, '\p{Lb: b2}', ""); +Expect(0, 8212, '\p{^Lb: b2}', ""); +Expect(0, 8212, '\P{Lb: b2}', ""); +Expect(1, 8212, '\P{^Lb: b2}', ""); +Expect(0, 8211, '\p{Lb: b2}', ""); +Expect(1, 8211, '\p{^Lb: b2}', ""); +Expect(1, 8211, '\P{Lb: b2}', ""); +Expect(0, 8211, '\P{^Lb: b2}', ""); +Expect(1, 8212, '\p{Lb=- B2}', ""); +Expect(0, 8212, '\p{^Lb=- B2}', ""); +Expect(0, 8212, '\P{Lb=- B2}', ""); +Expect(1, 8212, '\P{^Lb=- B2}', ""); +Expect(0, 8211, '\p{Lb=- B2}', ""); +Expect(1, 8211, '\p{^Lb=- B2}', ""); +Expect(1, 8211, '\P{Lb=- B2}', ""); +Expect(0, 8211, '\P{^Lb=- B2}', ""); +Error('\p{Is_Line_Break= break:=BOTH}'); +Error('\P{Is_Line_Break= break:=BOTH}'); +Expect(1, 8212, '\p{Is_Line_Break=breakboth}', ""); +Expect(0, 8212, '\p{^Is_Line_Break=breakboth}', ""); +Expect(0, 8212, '\P{Is_Line_Break=breakboth}', ""); +Expect(1, 8212, '\P{^Is_Line_Break=breakboth}', ""); +Expect(0, 8211, '\p{Is_Line_Break=breakboth}', ""); +Expect(1, 8211, '\p{^Is_Line_Break=breakboth}', ""); +Expect(1, 8211, '\P{Is_Line_Break=breakboth}', ""); +Expect(0, 8211, '\P{^Is_Line_Break=breakboth}', ""); +Expect(1, 8212, '\p{Is_Line_Break=_BREAK_Both}', ""); +Expect(0, 8212, '\p{^Is_Line_Break=_BREAK_Both}', ""); +Expect(0, 8212, '\P{Is_Line_Break=_BREAK_Both}', ""); +Expect(1, 8212, '\P{^Is_Line_Break=_BREAK_Both}', ""); +Expect(0, 8211, '\p{Is_Line_Break=_BREAK_Both}', ""); +Expect(1, 8211, '\p{^Is_Line_Break=_BREAK_Both}', ""); +Expect(1, 8211, '\P{Is_Line_Break=_BREAK_Both}', ""); +Expect(0, 8211, '\P{^Is_Line_Break=_BREAK_Both}', ""); +Error('\p{Is_Lb=/a/ B2}'); +Error('\P{Is_Lb=/a/ B2}'); +Expect(1, 8212, '\p{Is_Lb:b2}', ""); +Expect(0, 8212, '\p{^Is_Lb:b2}', ""); +Expect(0, 8212, '\P{Is_Lb:b2}', ""); +Expect(1, 8212, '\P{^Is_Lb:b2}', ""); +Expect(0, 8211, '\p{Is_Lb:b2}', ""); +Expect(1, 8211, '\p{^Is_Lb:b2}', ""); +Expect(1, 8211, '\P{Is_Lb:b2}', ""); +Expect(0, 8211, '\P{^Is_Lb:b2}', ""); +Expect(1, 8212, '\p{Is_Lb=-B2}', ""); +Expect(0, 8212, '\p{^Is_Lb=-B2}', ""); +Expect(0, 8212, '\P{Is_Lb=-B2}', ""); +Expect(1, 8212, '\P{^Is_Lb=-B2}', ""); +Expect(0, 8211, '\p{Is_Lb=-B2}', ""); +Expect(1, 8211, '\p{^Is_Lb=-B2}', ""); +Expect(1, 8211, '\P{Is_Lb=-B2}', ""); +Expect(0, 8211, '\P{^Is_Lb=-B2}', ""); +Error('\p{Line_Break= alphabetic/a/}'); +Error('\P{Line_Break= alphabetic/a/}'); +Expect(1, 35, '\p{Line_Break=alphabetic}', ""); +Expect(0, 35, '\p{^Line_Break=alphabetic}', ""); +Expect(0, 35, '\P{Line_Break=alphabetic}', ""); +Expect(1, 35, '\P{^Line_Break=alphabetic}', ""); +Expect(0, 34, '\p{Line_Break=alphabetic}', ""); +Expect(1, 34, '\p{^Line_Break=alphabetic}', ""); +Expect(1, 34, '\P{Line_Break=alphabetic}', ""); +Expect(0, 34, '\P{^Line_Break=alphabetic}', ""); +Expect(1, 35, '\p{Line_Break=_Alphabetic}', ""); +Expect(0, 35, '\p{^Line_Break=_Alphabetic}', ""); +Expect(0, 35, '\P{Line_Break=_Alphabetic}', ""); +Expect(1, 35, '\P{^Line_Break=_Alphabetic}', ""); +Expect(0, 34, '\p{Line_Break=_Alphabetic}', ""); +Expect(1, 34, '\p{^Line_Break=_Alphabetic}', ""); +Expect(1, 34, '\P{Line_Break=_Alphabetic}', ""); +Expect(0, 34, '\P{^Line_Break=_Alphabetic}', ""); +Error('\p{Lb=/a/--AL}'); +Error('\P{Lb=/a/--AL}'); +Expect(1, 35, '\p{Lb=al}', ""); +Expect(0, 35, '\p{^Lb=al}', ""); +Expect(0, 35, '\P{Lb=al}', ""); +Expect(1, 35, '\P{^Lb=al}', ""); +Expect(0, 34, '\p{Lb=al}', ""); +Expect(1, 34, '\p{^Lb=al}', ""); +Expect(1, 34, '\P{Lb=al}', ""); +Expect(0, 34, '\P{^Lb=al}', ""); +Expect(1, 35, '\p{Lb= AL}', ""); +Expect(0, 35, '\p{^Lb= AL}', ""); +Expect(0, 35, '\P{Lb= AL}', ""); +Expect(1, 35, '\P{^Lb= AL}', ""); +Expect(0, 34, '\p{Lb= AL}', ""); +Expect(1, 34, '\p{^Lb= AL}', ""); +Expect(1, 34, '\P{Lb= AL}', ""); +Expect(0, 34, '\P{^Lb= AL}', ""); +Error('\p{Is_Line_Break= _alphabetic/a/}'); +Error('\P{Is_Line_Break= _alphabetic/a/}'); +Expect(1, 35, '\p{Is_Line_Break: alphabetic}', ""); +Expect(0, 35, '\p{^Is_Line_Break: alphabetic}', ""); +Expect(0, 35, '\P{Is_Line_Break: alphabetic}', ""); +Expect(1, 35, '\P{^Is_Line_Break: alphabetic}', ""); +Expect(0, 34, '\p{Is_Line_Break: alphabetic}', ""); +Expect(1, 34, '\p{^Is_Line_Break: alphabetic}', ""); +Expect(1, 34, '\P{Is_Line_Break: alphabetic}', ""); +Expect(0, 34, '\P{^Is_Line_Break: alphabetic}', ""); +Expect(1, 35, '\p{Is_Line_Break= Alphabetic}', ""); +Expect(0, 35, '\p{^Is_Line_Break= Alphabetic}', ""); +Expect(0, 35, '\P{Is_Line_Break= Alphabetic}', ""); +Expect(1, 35, '\P{^Is_Line_Break= Alphabetic}', ""); +Expect(0, 34, '\p{Is_Line_Break= Alphabetic}', ""); +Expect(1, 34, '\p{^Is_Line_Break= Alphabetic}', ""); +Expect(1, 34, '\P{Is_Line_Break= Alphabetic}', ""); +Expect(0, 34, '\P{^Is_Line_Break= Alphabetic}', ""); +Error('\p{Is_Lb=-AL:=}'); +Error('\P{Is_Lb=-AL:=}'); +Expect(1, 35, '\p{Is_Lb=al}', ""); +Expect(0, 35, '\p{^Is_Lb=al}', ""); +Expect(0, 35, '\P{Is_Lb=al}', ""); +Expect(1, 35, '\P{^Is_Lb=al}', ""); +Expect(0, 34, '\p{Is_Lb=al}', ""); +Expect(1, 34, '\p{^Is_Lb=al}', ""); +Expect(1, 34, '\P{Is_Lb=al}', ""); +Expect(0, 34, '\P{^Is_Lb=al}', ""); +Expect(1, 35, '\p{Is_Lb=_AL}', ""); +Expect(0, 35, '\p{^Is_Lb=_AL}', ""); +Expect(0, 35, '\P{Is_Lb=_AL}', ""); +Expect(1, 35, '\P{^Is_Lb=_AL}', ""); +Expect(0, 34, '\p{Is_Lb=_AL}', ""); +Expect(1, 34, '\p{^Is_Lb=_AL}', ""); +Expect(1, 34, '\P{Is_Lb=_AL}', ""); +Expect(0, 34, '\P{^Is_Lb=_AL}', ""); +Error('\p{Line_Break=_Postfix NUMERIC/a/}'); +Error('\P{Line_Break=_Postfix NUMERIC/a/}'); +Expect(1, 37, '\p{Line_Break=postfixnumeric}', ""); +Expect(0, 37, '\p{^Line_Break=postfixnumeric}', ""); +Expect(0, 37, '\P{Line_Break=postfixnumeric}', ""); +Expect(1, 37, '\P{^Line_Break=postfixnumeric}', ""); +Expect(0, 36, '\p{Line_Break=postfixnumeric}', ""); +Expect(1, 36, '\p{^Line_Break=postfixnumeric}', ""); +Expect(1, 36, '\P{Line_Break=postfixnumeric}', ""); +Expect(0, 36, '\P{^Line_Break=postfixnumeric}', ""); +Expect(1, 37, '\p{Line_Break= -Postfix_Numeric}', ""); +Expect(0, 37, '\p{^Line_Break= -Postfix_Numeric}', ""); +Expect(0, 37, '\P{Line_Break= -Postfix_Numeric}', ""); +Expect(1, 37, '\P{^Line_Break= -Postfix_Numeric}', ""); +Expect(0, 36, '\p{Line_Break= -Postfix_Numeric}', ""); +Expect(1, 36, '\p{^Line_Break= -Postfix_Numeric}', ""); +Expect(1, 36, '\P{Line_Break= -Postfix_Numeric}', ""); +Expect(0, 36, '\P{^Line_Break= -Postfix_Numeric}', ""); +Error('\p{Lb=PO/a/}'); +Error('\P{Lb=PO/a/}'); +Expect(1, 37, '\p{Lb=po}', ""); +Expect(0, 37, '\p{^Lb=po}', ""); +Expect(0, 37, '\P{Lb=po}', ""); +Expect(1, 37, '\P{^Lb=po}', ""); +Expect(0, 36, '\p{Lb=po}', ""); +Expect(1, 36, '\p{^Lb=po}', ""); +Expect(1, 36, '\P{Lb=po}', ""); +Expect(0, 36, '\P{^Lb=po}', ""); +Expect(1, 37, '\p{Lb= -PO}', ""); +Expect(0, 37, '\p{^Lb= -PO}', ""); +Expect(0, 37, '\P{Lb= -PO}', ""); +Expect(1, 37, '\P{^Lb= -PO}', ""); +Expect(0, 36, '\p{Lb= -PO}', ""); +Expect(1, 36, '\p{^Lb= -PO}', ""); +Expect(1, 36, '\P{Lb= -PO}', ""); +Expect(0, 36, '\P{^Lb= -PO}', ""); +Error('\p{Is_Line_Break=-/a/Postfix-Numeric}'); +Error('\P{Is_Line_Break=-/a/Postfix-Numeric}'); +Expect(1, 37, '\p{Is_Line_Break=postfixnumeric}', ""); +Expect(0, 37, '\p{^Is_Line_Break=postfixnumeric}', ""); +Expect(0, 37, '\P{Is_Line_Break=postfixnumeric}', ""); +Expect(1, 37, '\P{^Is_Line_Break=postfixnumeric}', ""); +Expect(0, 36, '\p{Is_Line_Break=postfixnumeric}', ""); +Expect(1, 36, '\p{^Is_Line_Break=postfixnumeric}', ""); +Expect(1, 36, '\P{Is_Line_Break=postfixnumeric}', ""); +Expect(0, 36, '\P{^Is_Line_Break=postfixnumeric}', ""); +Expect(1, 37, '\p{Is_Line_Break=-POSTFIX numeric}', ""); +Expect(0, 37, '\p{^Is_Line_Break=-POSTFIX numeric}', ""); +Expect(0, 37, '\P{Is_Line_Break=-POSTFIX numeric}', ""); +Expect(1, 37, '\P{^Is_Line_Break=-POSTFIX numeric}', ""); +Expect(0, 36, '\p{Is_Line_Break=-POSTFIX numeric}', ""); +Expect(1, 36, '\p{^Is_Line_Break=-POSTFIX numeric}', ""); +Expect(1, 36, '\P{Is_Line_Break=-POSTFIX numeric}', ""); +Expect(0, 36, '\P{^Is_Line_Break=-POSTFIX numeric}', ""); +Error('\p{Is_Lb: po/a/}'); +Error('\P{Is_Lb: po/a/}'); +Expect(1, 37, '\p{Is_Lb=po}', ""); +Expect(0, 37, '\p{^Is_Lb=po}', ""); +Expect(0, 37, '\P{Is_Lb=po}', ""); +Expect(1, 37, '\P{^Is_Lb=po}', ""); +Expect(0, 36, '\p{Is_Lb=po}', ""); +Expect(1, 36, '\p{^Is_Lb=po}', ""); +Expect(1, 36, '\P{Is_Lb=po}', ""); +Expect(0, 36, '\P{^Is_Lb=po}', ""); +Expect(1, 37, '\p{Is_Lb= -PO}', ""); +Expect(0, 37, '\p{^Is_Lb= -PO}', ""); +Expect(0, 37, '\P{Is_Lb= -PO}', ""); +Expect(1, 37, '\P{^Is_Lb= -PO}', ""); +Expect(0, 36, '\p{Is_Lb= -PO}', ""); +Expect(1, 36, '\p{^Is_Lb= -PO}', ""); +Expect(1, 36, '\P{Is_Lb= -PO}', ""); +Expect(0, 36, '\P{^Is_Lb= -PO}', ""); +Error('\p{Line_Break=- OPEN:=Punctuation}'); +Error('\P{Line_Break=- OPEN:=Punctuation}'); +Expect(1, 40, '\p{Line_Break: openpunctuation}', ""); +Expect(0, 40, '\p{^Line_Break: openpunctuation}', ""); +Expect(0, 40, '\P{Line_Break: openpunctuation}', ""); +Expect(1, 40, '\P{^Line_Break: openpunctuation}', ""); +Expect(0, 39, '\p{Line_Break: openpunctuation}', ""); +Expect(1, 39, '\p{^Line_Break: openpunctuation}', ""); +Expect(1, 39, '\P{Line_Break: openpunctuation}', ""); +Expect(0, 39, '\P{^Line_Break: openpunctuation}', ""); +Expect(1, 40, '\p{Line_Break=-Open_Punctuation}', ""); +Expect(0, 40, '\p{^Line_Break=-Open_Punctuation}', ""); +Expect(0, 40, '\P{Line_Break=-Open_Punctuation}', ""); +Expect(1, 40, '\P{^Line_Break=-Open_Punctuation}', ""); +Expect(0, 39, '\p{Line_Break=-Open_Punctuation}', ""); +Expect(1, 39, '\p{^Line_Break=-Open_Punctuation}', ""); +Expect(1, 39, '\P{Line_Break=-Open_Punctuation}', ""); +Expect(0, 39, '\P{^Line_Break=-Open_Punctuation}', ""); +Error('\p{Lb: :=OP}'); +Error('\P{Lb: :=OP}'); +Expect(1, 40, '\p{Lb=op}', ""); +Expect(0, 40, '\p{^Lb=op}', ""); +Expect(0, 40, '\P{Lb=op}', ""); +Expect(1, 40, '\P{^Lb=op}', ""); +Expect(0, 39, '\p{Lb=op}', ""); +Expect(1, 39, '\p{^Lb=op}', ""); +Expect(1, 39, '\P{Lb=op}', ""); +Expect(0, 39, '\P{^Lb=op}', ""); +Expect(1, 40, '\p{Lb= OP}', ""); +Expect(0, 40, '\p{^Lb= OP}', ""); +Expect(0, 40, '\P{Lb= OP}', ""); +Expect(1, 40, '\P{^Lb= OP}', ""); +Expect(0, 39, '\p{Lb= OP}', ""); +Expect(1, 39, '\p{^Lb= OP}', ""); +Expect(1, 39, '\P{Lb= OP}', ""); +Expect(0, 39, '\P{^Lb= OP}', ""); +Error('\p{Is_Line_Break= _Open/a/Punctuation}'); +Error('\P{Is_Line_Break= _Open/a/Punctuation}'); +Expect(1, 40, '\p{Is_Line_Break=openpunctuation}', ""); +Expect(0, 40, '\p{^Is_Line_Break=openpunctuation}', ""); +Expect(0, 40, '\P{Is_Line_Break=openpunctuation}', ""); +Expect(1, 40, '\P{^Is_Line_Break=openpunctuation}', ""); +Expect(0, 39, '\p{Is_Line_Break=openpunctuation}', ""); +Expect(1, 39, '\p{^Is_Line_Break=openpunctuation}', ""); +Expect(1, 39, '\P{Is_Line_Break=openpunctuation}', ""); +Expect(0, 39, '\P{^Is_Line_Break=openpunctuation}', ""); +Expect(1, 40, '\p{Is_Line_Break= open-punctuation}', ""); +Expect(0, 40, '\p{^Is_Line_Break= open-punctuation}', ""); +Expect(0, 40, '\P{Is_Line_Break= open-punctuation}', ""); +Expect(1, 40, '\P{^Is_Line_Break= open-punctuation}', ""); +Expect(0, 39, '\p{Is_Line_Break= open-punctuation}', ""); +Expect(1, 39, '\p{^Is_Line_Break= open-punctuation}', ""); +Expect(1, 39, '\P{Is_Line_Break= open-punctuation}', ""); +Expect(0, 39, '\P{^Is_Line_Break= open-punctuation}', ""); +Error('\p{Is_Lb= OP:=}'); +Error('\P{Is_Lb= OP:=}'); +Expect(1, 40, '\p{Is_Lb=op}', ""); +Expect(0, 40, '\p{^Is_Lb=op}', ""); +Expect(0, 40, '\P{Is_Lb=op}', ""); +Expect(1, 40, '\P{^Is_Lb=op}', ""); +Expect(0, 39, '\p{Is_Lb=op}', ""); +Expect(1, 39, '\p{^Is_Lb=op}', ""); +Expect(1, 39, '\P{Is_Lb=op}', ""); +Expect(0, 39, '\P{^Is_Lb=op}', ""); +Expect(1, 40, '\p{Is_Lb= OP}', ""); +Expect(0, 40, '\p{^Is_Lb= OP}', ""); +Expect(0, 40, '\P{Is_Lb= OP}', ""); +Expect(1, 40, '\P{^Is_Lb= OP}', ""); +Expect(0, 39, '\p{Is_Lb= OP}', ""); +Expect(1, 39, '\p{^Is_Lb= OP}', ""); +Expect(1, 39, '\P{Is_Lb= OP}', ""); +Expect(0, 39, '\P{^Is_Lb= OP}', ""); +Error('\p{Line_Break=--next/a/line}'); +Error('\P{Line_Break=--next/a/line}'); +Expect(1, 133, '\p{Line_Break: nextline}', ""); +Expect(0, 133, '\p{^Line_Break: nextline}', ""); +Expect(0, 133, '\P{Line_Break: nextline}', ""); +Expect(1, 133, '\P{^Line_Break: nextline}', ""); +Expect(0, 7, '\p{Line_Break: nextline}', ""); +Expect(1, 7, '\p{^Line_Break: nextline}', ""); +Expect(1, 7, '\P{Line_Break: nextline}', ""); +Expect(0, 7, '\P{^Line_Break: nextline}', ""); +Expect(1, 133, '\p{Line_Break= Next Line}', ""); +Expect(0, 133, '\p{^Line_Break= Next Line}', ""); +Expect(0, 133, '\P{Line_Break= Next Line}', ""); +Expect(1, 133, '\P{^Line_Break= Next Line}', ""); +Expect(0, 7, '\p{Line_Break= Next Line}', ""); +Expect(1, 7, '\p{^Line_Break= Next Line}', ""); +Expect(1, 7, '\P{Line_Break= Next Line}', ""); +Expect(0, 7, '\P{^Line_Break= Next Line}', ""); +Error('\p{Lb=/a/nl}'); +Error('\P{Lb=/a/nl}'); +Expect(1, 133, '\p{Lb=nl}', ""); +Expect(0, 133, '\p{^Lb=nl}', ""); +Expect(0, 133, '\P{Lb=nl}', ""); +Expect(1, 133, '\P{^Lb=nl}', ""); +Expect(0, 7, '\p{Lb=nl}', ""); +Expect(1, 7, '\p{^Lb=nl}', ""); +Expect(1, 7, '\P{Lb=nl}', ""); +Expect(0, 7, '\P{^Lb=nl}', ""); +Expect(1, 133, '\p{Lb=_-NL}', ""); +Expect(0, 133, '\p{^Lb=_-NL}', ""); +Expect(0, 133, '\P{Lb=_-NL}', ""); +Expect(1, 133, '\P{^Lb=_-NL}', ""); +Expect(0, 7, '\p{Lb=_-NL}', ""); +Expect(1, 7, '\p{^Lb=_-NL}', ""); +Expect(1, 7, '\P{Lb=_-NL}', ""); +Expect(0, 7, '\P{^Lb=_-NL}', ""); +Error('\p{Is_Line_Break=:=- Next-Line}'); +Error('\P{Is_Line_Break=:=- Next-Line}'); +Expect(1, 133, '\p{Is_Line_Break=nextline}', ""); +Expect(0, 133, '\p{^Is_Line_Break=nextline}', ""); +Expect(0, 133, '\P{Is_Line_Break=nextline}', ""); +Expect(1, 133, '\P{^Is_Line_Break=nextline}', ""); +Expect(0, 7, '\p{Is_Line_Break=nextline}', ""); +Expect(1, 7, '\p{^Is_Line_Break=nextline}', ""); +Expect(1, 7, '\P{Is_Line_Break=nextline}', ""); +Expect(0, 7, '\P{^Is_Line_Break=nextline}', ""); +Expect(1, 133, '\p{Is_Line_Break= NEXT Line}', ""); +Expect(0, 133, '\p{^Is_Line_Break= NEXT Line}', ""); +Expect(0, 133, '\P{Is_Line_Break= NEXT Line}', ""); +Expect(1, 133, '\P{^Is_Line_Break= NEXT Line}', ""); +Expect(0, 7, '\p{Is_Line_Break= NEXT Line}', ""); +Expect(1, 7, '\p{^Is_Line_Break= NEXT Line}', ""); +Expect(1, 7, '\P{Is_Line_Break= NEXT Line}', ""); +Expect(0, 7, '\P{^Is_Line_Break= NEXT Line}', ""); +Error('\p{Is_Lb= NL/a/}'); +Error('\P{Is_Lb= NL/a/}'); +Expect(1, 133, '\p{Is_Lb=nl}', ""); +Expect(0, 133, '\p{^Is_Lb=nl}', ""); +Expect(0, 133, '\P{Is_Lb=nl}', ""); +Expect(1, 133, '\P{^Is_Lb=nl}', ""); +Expect(0, 7, '\p{Is_Lb=nl}', ""); +Expect(1, 7, '\p{^Is_Lb=nl}', ""); +Expect(1, 7, '\P{Is_Lb=nl}', ""); +Expect(0, 7, '\P{^Is_Lb=nl}', ""); +Expect(1, 133, '\p{Is_Lb= NL}', ""); +Expect(0, 133, '\p{^Is_Lb= NL}', ""); +Expect(0, 133, '\P{Is_Lb= NL}', ""); +Expect(1, 133, '\P{^Is_Lb= NL}', ""); +Expect(0, 7, '\p{Is_Lb= NL}', ""); +Expect(1, 7, '\p{^Is_Lb= NL}', ""); +Expect(1, 7, '\P{Is_Lb= NL}', ""); +Expect(0, 7, '\P{^Is_Lb= NL}', ""); +Error('\p{Line_Break=/a/ jt}'); +Error('\P{Line_Break=/a/ jt}'); +Expect(1, 4601, '\p{Line_Break=jt}', ""); +Expect(0, 4601, '\p{^Line_Break=jt}', ""); +Expect(0, 4601, '\P{Line_Break=jt}', ""); +Expect(1, 4601, '\P{^Line_Break=jt}', ""); +Expect(0, 4519, '\p{Line_Break=jt}', ""); +Expect(1, 4519, '\p{^Line_Break=jt}', ""); +Expect(1, 4519, '\P{Line_Break=jt}', ""); +Expect(0, 4519, '\P{^Line_Break=jt}', ""); +Expect(1, 4601, '\p{Line_Break= JT}', ""); +Expect(0, 4601, '\p{^Line_Break= JT}', ""); +Expect(0, 4601, '\P{Line_Break= JT}', ""); +Expect(1, 4601, '\P{^Line_Break= JT}', ""); +Expect(0, 4519, '\p{Line_Break= JT}', ""); +Expect(1, 4519, '\p{^Line_Break= JT}', ""); +Expect(1, 4519, '\P{Line_Break= JT}', ""); +Expect(0, 4519, '\P{^Line_Break= JT}', ""); +Error('\p{Lb: JT/a/}'); +Error('\P{Lb: JT/a/}'); +Expect(1, 4601, '\p{Lb=jt}', ""); +Expect(0, 4601, '\p{^Lb=jt}', ""); +Expect(0, 4601, '\P{Lb=jt}', ""); +Expect(1, 4601, '\P{^Lb=jt}', ""); +Expect(0, 4519, '\p{Lb=jt}', ""); +Expect(1, 4519, '\p{^Lb=jt}', ""); +Expect(1, 4519, '\P{Lb=jt}', ""); +Expect(0, 4519, '\P{^Lb=jt}', ""); +Expect(1, 4601, '\p{Lb= JT}', ""); +Expect(0, 4601, '\p{^Lb= JT}', ""); +Expect(0, 4601, '\P{Lb= JT}', ""); +Expect(1, 4601, '\P{^Lb= JT}', ""); +Expect(0, 4519, '\p{Lb= JT}', ""); +Expect(1, 4519, '\p{^Lb= JT}', ""); +Expect(1, 4519, '\P{Lb= JT}', ""); +Expect(0, 4519, '\P{^Lb= JT}', ""); +Error('\p{Is_Line_Break=/a/JT}'); +Error('\P{Is_Line_Break=/a/JT}'); +Expect(1, 4601, '\p{Is_Line_Break=jt}', ""); +Expect(0, 4601, '\p{^Is_Line_Break=jt}', ""); +Expect(0, 4601, '\P{Is_Line_Break=jt}', ""); +Expect(1, 4601, '\P{^Is_Line_Break=jt}', ""); +Expect(0, 4519, '\p{Is_Line_Break=jt}', ""); +Expect(1, 4519, '\p{^Is_Line_Break=jt}', ""); +Expect(1, 4519, '\P{Is_Line_Break=jt}', ""); +Expect(0, 4519, '\P{^Is_Line_Break=jt}', ""); +Expect(1, 4601, '\p{Is_Line_Break: _-JT}', ""); +Expect(0, 4601, '\p{^Is_Line_Break: _-JT}', ""); +Expect(0, 4601, '\P{Is_Line_Break: _-JT}', ""); +Expect(1, 4601, '\P{^Is_Line_Break: _-JT}', ""); +Expect(0, 4519, '\p{Is_Line_Break: _-JT}', ""); +Expect(1, 4519, '\p{^Is_Line_Break: _-JT}', ""); +Expect(1, 4519, '\P{Is_Line_Break: _-JT}', ""); +Expect(0, 4519, '\P{^Is_Line_Break: _-JT}', ""); +Error('\p{Is_Lb=:= JT}'); +Error('\P{Is_Lb=:= JT}'); +Expect(1, 4601, '\p{Is_Lb=jt}', ""); +Expect(0, 4601, '\p{^Is_Lb=jt}', ""); +Expect(0, 4601, '\P{Is_Lb=jt}', ""); +Expect(1, 4601, '\P{^Is_Lb=jt}', ""); +Expect(0, 4519, '\p{Is_Lb=jt}', ""); +Expect(1, 4519, '\p{^Is_Lb=jt}', ""); +Expect(1, 4519, '\P{Is_Lb=jt}', ""); +Expect(0, 4519, '\P{^Is_Lb=jt}', ""); +Expect(1, 4601, '\p{Is_Lb= -JT}', ""); +Expect(0, 4601, '\p{^Is_Lb= -JT}', ""); +Expect(0, 4601, '\P{Is_Lb= -JT}', ""); +Expect(1, 4601, '\P{^Is_Lb= -JT}', ""); +Expect(0, 4519, '\p{Is_Lb= -JT}', ""); +Expect(1, 4519, '\p{^Is_Lb= -JT}', ""); +Expect(1, 4519, '\P{Is_Lb= -JT}', ""); +Expect(0, 4519, '\P{^Is_Lb= -JT}', ""); +Error('\p{Block=_:=NEW tai_lue}'); +Error('\P{Block=_:=NEW tai_lue}'); +Expect(1, 6623, '\p{Block=newtailue}', ""); +Expect(0, 6623, '\p{^Block=newtailue}', ""); +Expect(0, 6623, '\P{Block=newtailue}', ""); +Expect(1, 6623, '\P{^Block=newtailue}', ""); +Expect(0, 6527, '\p{Block=newtailue}', ""); +Expect(1, 6527, '\p{^Block=newtailue}', ""); +Expect(1, 6527, '\P{Block=newtailue}', ""); +Expect(0, 6527, '\P{^Block=newtailue}', ""); +Expect(1, 6623, '\p{Block=_ New_TaiLUE}', ""); +Expect(0, 6623, '\p{^Block=_ New_TaiLUE}', ""); +Expect(0, 6623, '\P{Block=_ New_TaiLUE}', ""); +Expect(1, 6623, '\P{^Block=_ New_TaiLUE}', ""); +Expect(0, 6527, '\p{Block=_ New_TaiLUE}', ""); +Expect(1, 6527, '\p{^Block=_ New_TaiLUE}', ""); +Expect(1, 6527, '\P{Block=_ New_TaiLUE}', ""); +Expect(0, 6527, '\P{^Block=_ New_TaiLUE}', ""); +Error('\p{Blk= _NEW/a/Tai_lue}'); +Error('\P{Blk= _NEW/a/Tai_lue}'); +Expect(1, 6623, '\p{Blk=newtailue}', ""); +Expect(0, 6623, '\p{^Blk=newtailue}', ""); +Expect(0, 6623, '\P{Blk=newtailue}', ""); +Expect(1, 6623, '\P{^Blk=newtailue}', ""); +Expect(0, 6527, '\p{Blk=newtailue}', ""); +Expect(1, 6527, '\p{^Blk=newtailue}', ""); +Expect(1, 6527, '\P{Blk=newtailue}', ""); +Expect(0, 6527, '\P{^Blk=newtailue}', ""); +Expect(1, 6623, '\p{Blk=-new TaiLue}', ""); +Expect(0, 6623, '\p{^Blk=-new TaiLue}', ""); +Expect(0, 6623, '\P{Blk=-new TaiLue}', ""); +Expect(1, 6623, '\P{^Blk=-new TaiLue}', ""); +Expect(0, 6527, '\p{Blk=-new TaiLue}', ""); +Expect(1, 6527, '\p{^Blk=-new TaiLue}', ""); +Expect(1, 6527, '\P{Blk=-new TaiLue}', ""); +Expect(0, 6527, '\P{^Blk=-new TaiLue}', ""); +Error('\p{Is_Block=_/a/New_TAIlue}'); +Error('\P{Is_Block=_/a/New_TAIlue}'); +Expect(1, 6623, '\p{Is_Block=newtailue}', ""); +Expect(0, 6623, '\p{^Is_Block=newtailue}', ""); +Expect(0, 6623, '\P{Is_Block=newtailue}', ""); +Expect(1, 6623, '\P{^Is_Block=newtailue}', ""); +Expect(0, 6527, '\p{Is_Block=newtailue}', ""); +Expect(1, 6527, '\p{^Is_Block=newtailue}', ""); +Expect(1, 6527, '\P{Is_Block=newtailue}', ""); +Expect(0, 6527, '\P{^Is_Block=newtailue}', ""); +Expect(1, 6623, '\p{Is_Block: -_Newtai-LUE}', ""); +Expect(0, 6623, '\p{^Is_Block: -_Newtai-LUE}', ""); +Expect(0, 6623, '\P{Is_Block: -_Newtai-LUE}', ""); +Expect(1, 6623, '\P{^Is_Block: -_Newtai-LUE}', ""); +Expect(0, 6527, '\p{Is_Block: -_Newtai-LUE}', ""); +Expect(1, 6527, '\p{^Is_Block: -_Newtai-LUE}', ""); +Expect(1, 6527, '\P{Is_Block: -_Newtai-LUE}', ""); +Expect(0, 6527, '\P{^Is_Block: -_Newtai-LUE}', ""); +Error('\p{Is_Blk: := -Newtai Lue}'); +Error('\P{Is_Blk: := -Newtai Lue}'); +Expect(1, 6623, '\p{Is_Blk=newtailue}', ""); +Expect(0, 6623, '\p{^Is_Blk=newtailue}', ""); +Expect(0, 6623, '\P{Is_Blk=newtailue}', ""); +Expect(1, 6623, '\P{^Is_Blk=newtailue}', ""); +Expect(0, 6527, '\p{Is_Blk=newtailue}', ""); +Expect(1, 6527, '\p{^Is_Blk=newtailue}', ""); +Expect(1, 6527, '\P{Is_Blk=newtailue}', ""); +Expect(0, 6527, '\P{^Is_Blk=newtailue}', ""); +Expect(1, 6623, '\p{Is_Blk= _New-Tailue}', ""); +Expect(0, 6623, '\p{^Is_Blk= _New-Tailue}', ""); +Expect(0, 6623, '\P{Is_Blk= _New-Tailue}', ""); +Expect(1, 6623, '\P{^Is_Blk= _New-Tailue}', ""); +Expect(0, 6527, '\p{Is_Blk= _New-Tailue}', ""); +Expect(1, 6527, '\p{^Is_Blk= _New-Tailue}', ""); +Expect(1, 6527, '\P{Is_Blk= _New-Tailue}', ""); +Expect(0, 6527, '\P{^Is_Blk= _New-Tailue}', ""); +Error('\p{Block=_cjk/a/UnifiedIdeographs-Extension_A}'); +Error('\P{Block=_cjk/a/UnifiedIdeographs-Extension_A}'); +Expect(1, 19903, '\p{Block=cjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\p{^Block=cjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\P{Block=cjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\P{^Block=cjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\p{Block=cjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\p{^Block=cjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\P{Block=cjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\P{^Block=cjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\p{Block: CJK-unifiedIdeographs Extension-A}', ""); +Expect(0, 19903, '\p{^Block: CJK-unifiedIdeographs Extension-A}', ""); +Expect(0, 19903, '\P{Block: CJK-unifiedIdeographs Extension-A}', ""); +Expect(1, 19903, '\P{^Block: CJK-unifiedIdeographs Extension-A}', ""); +Expect(0, 13311, '\p{Block: CJK-unifiedIdeographs Extension-A}', ""); +Expect(1, 13311, '\p{^Block: CJK-unifiedIdeographs Extension-A}', ""); +Expect(1, 13311, '\P{Block: CJK-unifiedIdeographs Extension-A}', ""); +Expect(0, 13311, '\P{^Block: CJK-unifiedIdeographs Extension-A}', ""); +Error('\p{Blk=-CJK unified:=Ideographs Extension A}'); +Error('\P{Blk=-CJK unified:=Ideographs Extension A}'); +Expect(1, 19903, '\p{Blk: cjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\p{^Blk: cjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\P{Blk: cjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\P{^Blk: cjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\p{Blk: cjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\p{^Blk: cjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\P{Blk: cjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\P{^Blk: cjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\p{Blk=_ CJKUnifiedIdeographs extension_a}', ""); +Expect(0, 19903, '\p{^Blk=_ CJKUnifiedIdeographs extension_a}', ""); +Expect(0, 19903, '\P{Blk=_ CJKUnifiedIdeographs extension_a}', ""); +Expect(1, 19903, '\P{^Blk=_ CJKUnifiedIdeographs extension_a}', ""); +Expect(0, 13311, '\p{Blk=_ CJKUnifiedIdeographs extension_a}', ""); +Expect(1, 13311, '\p{^Blk=_ CJKUnifiedIdeographs extension_a}', ""); +Expect(1, 13311, '\P{Blk=_ CJKUnifiedIdeographs extension_a}', ""); +Expect(0, 13311, '\P{^Blk=_ CJKUnifiedIdeographs extension_a}', ""); +Error('\p{Is_Block=/a/CJK Unified_ideographs ExtensionA}'); +Error('\P{Is_Block=/a/CJK Unified_ideographs ExtensionA}'); +Expect(1, 19903, '\p{Is_Block=cjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\p{^Is_Block=cjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\P{Is_Block=cjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\P{^Is_Block=cjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\p{Is_Block=cjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\p{^Is_Block=cjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\P{Is_Block=cjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\P{^Is_Block=cjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\p{Is_Block=CJK UnifiedIdeographs-ExtensionA}', ""); +Expect(0, 19903, '\p{^Is_Block=CJK UnifiedIdeographs-ExtensionA}', ""); +Expect(0, 19903, '\P{Is_Block=CJK UnifiedIdeographs-ExtensionA}', ""); +Expect(1, 19903, '\P{^Is_Block=CJK UnifiedIdeographs-ExtensionA}', ""); +Expect(0, 13311, '\p{Is_Block=CJK UnifiedIdeographs-ExtensionA}', ""); +Expect(1, 13311, '\p{^Is_Block=CJK UnifiedIdeographs-ExtensionA}', ""); +Expect(1, 13311, '\P{Is_Block=CJK UnifiedIdeographs-ExtensionA}', ""); +Expect(0, 13311, '\P{^Is_Block=CJK UnifiedIdeographs-ExtensionA}', ""); +Error('\p{Is_Blk= -cjk unified:=ideographs extensionA}'); +Error('\P{Is_Blk= -cjk unified:=ideographs extensionA}'); +Expect(1, 19903, '\p{Is_Blk=cjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\p{^Is_Blk=cjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\P{Is_Blk=cjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\P{^Is_Blk=cjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\p{Is_Blk=cjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\p{^Is_Blk=cjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\P{Is_Blk=cjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\P{^Is_Blk=cjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\p{Is_Blk=_ cjk unified Ideographs EXTENSION-A}', ""); +Expect(0, 19903, '\p{^Is_Blk=_ cjk unified Ideographs EXTENSION-A}', ""); +Expect(0, 19903, '\P{Is_Blk=_ cjk unified Ideographs EXTENSION-A}', ""); +Expect(1, 19903, '\P{^Is_Blk=_ cjk unified Ideographs EXTENSION-A}', ""); +Expect(0, 13311, '\p{Is_Blk=_ cjk unified Ideographs EXTENSION-A}', ""); +Expect(1, 13311, '\p{^Is_Blk=_ cjk unified Ideographs EXTENSION-A}', ""); +Expect(1, 13311, '\P{Is_Blk=_ cjk unified Ideographs EXTENSION-A}', ""); +Expect(0, 13311, '\P{^Is_Blk=_ cjk unified Ideographs EXTENSION-A}', ""); +Error('\p{Block= Hangul_Jamo:=}'); +Error('\P{Block= Hangul_Jamo:=}'); +Expect(1, 4607, '\p{Block=hanguljamo}', ""); +Expect(0, 4607, '\p{^Block=hanguljamo}', ""); +Expect(0, 4607, '\P{Block=hanguljamo}', ""); +Expect(1, 4607, '\P{^Block=hanguljamo}', ""); +Expect(0, 4351, '\p{Block=hanguljamo}', ""); +Expect(1, 4351, '\p{^Block=hanguljamo}', ""); +Expect(1, 4351, '\P{Block=hanguljamo}', ""); +Expect(0, 4351, '\P{^Block=hanguljamo}', ""); +Expect(1, 4607, '\p{Block=- Hangul-Jamo}', ""); +Expect(0, 4607, '\p{^Block=- Hangul-Jamo}', ""); +Expect(0, 4607, '\P{Block=- Hangul-Jamo}', ""); +Expect(1, 4607, '\P{^Block=- Hangul-Jamo}', ""); +Expect(0, 4351, '\p{Block=- Hangul-Jamo}', ""); +Expect(1, 4351, '\p{^Block=- Hangul-Jamo}', ""); +Expect(1, 4351, '\P{Block=- Hangul-Jamo}', ""); +Expect(0, 4351, '\P{^Block=- Hangul-Jamo}', ""); +Error('\p{Blk=:= -hangul jamo}'); +Error('\P{Blk=:= -hangul jamo}'); +Expect(1, 4607, '\p{Blk=hanguljamo}', ""); +Expect(0, 4607, '\p{^Blk=hanguljamo}', ""); +Expect(0, 4607, '\P{Blk=hanguljamo}', ""); +Expect(1, 4607, '\P{^Blk=hanguljamo}', ""); +Expect(0, 4351, '\p{Blk=hanguljamo}', ""); +Expect(1, 4351, '\p{^Blk=hanguljamo}', ""); +Expect(1, 4351, '\P{Blk=hanguljamo}', ""); +Expect(0, 4351, '\P{^Blk=hanguljamo}', ""); +Expect(1, 4607, '\p{Blk= HangulJamo}', ""); +Expect(0, 4607, '\p{^Blk= HangulJamo}', ""); +Expect(0, 4607, '\P{Blk= HangulJamo}', ""); +Expect(1, 4607, '\P{^Blk= HangulJamo}', ""); +Expect(0, 4351, '\p{Blk= HangulJamo}', ""); +Expect(1, 4351, '\p{^Blk= HangulJamo}', ""); +Expect(1, 4351, '\P{Blk= HangulJamo}', ""); +Expect(0, 4351, '\P{^Blk= HangulJamo}', ""); +Error('\p{Is_Block: /a/hangul-JAMO}'); +Error('\P{Is_Block: /a/hangul-JAMO}'); +Expect(1, 4607, '\p{Is_Block=hanguljamo}', ""); +Expect(0, 4607, '\p{^Is_Block=hanguljamo}', ""); +Expect(0, 4607, '\P{Is_Block=hanguljamo}', ""); +Expect(1, 4607, '\P{^Is_Block=hanguljamo}', ""); +Expect(0, 4351, '\p{Is_Block=hanguljamo}', ""); +Expect(1, 4351, '\p{^Is_Block=hanguljamo}', ""); +Expect(1, 4351, '\P{Is_Block=hanguljamo}', ""); +Expect(0, 4351, '\P{^Is_Block=hanguljamo}', ""); +Expect(1, 4607, '\p{Is_Block:- HANGUL_Jamo}', ""); +Expect(0, 4607, '\p{^Is_Block:- HANGUL_Jamo}', ""); +Expect(0, 4607, '\P{Is_Block:- HANGUL_Jamo}', ""); +Expect(1, 4607, '\P{^Is_Block:- HANGUL_Jamo}', ""); +Expect(0, 4351, '\p{Is_Block:- HANGUL_Jamo}', ""); +Expect(1, 4351, '\p{^Is_Block:- HANGUL_Jamo}', ""); +Expect(1, 4351, '\P{Is_Block:- HANGUL_Jamo}', ""); +Expect(0, 4351, '\P{^Is_Block:- HANGUL_Jamo}', ""); +Error('\p{Is_Blk=_HANGUL:=Jamo}'); +Error('\P{Is_Blk=_HANGUL:=Jamo}'); +Expect(1, 4607, '\p{Is_Blk:hanguljamo}', ""); +Expect(0, 4607, '\p{^Is_Blk:hanguljamo}', ""); +Expect(0, 4607, '\P{Is_Blk:hanguljamo}', ""); +Expect(1, 4607, '\P{^Is_Blk:hanguljamo}', ""); +Expect(0, 4351, '\p{Is_Blk:hanguljamo}', ""); +Expect(1, 4351, '\p{^Is_Blk:hanguljamo}', ""); +Expect(1, 4351, '\P{Is_Blk:hanguljamo}', ""); +Expect(0, 4351, '\P{^Is_Blk:hanguljamo}', ""); +Expect(1, 4607, '\p{Is_Blk=__hangul jamo}', ""); +Expect(0, 4607, '\p{^Is_Blk=__hangul jamo}', ""); +Expect(0, 4607, '\P{Is_Blk=__hangul jamo}', ""); +Expect(1, 4607, '\P{^Is_Blk=__hangul jamo}', ""); +Expect(0, 4351, '\p{Is_Blk=__hangul jamo}', ""); +Expect(1, 4351, '\p{^Is_Blk=__hangul jamo}', ""); +Expect(1, 4351, '\P{Is_Blk=__hangul jamo}', ""); +Expect(0, 4351, '\P{^Is_Blk=__hangul jamo}', ""); +Error('\p{Block: /a/DINGBATS}'); +Error('\P{Block: /a/DINGBATS}'); +Expect(1, 10175, '\p{Block=dingbats}', ""); +Expect(0, 10175, '\p{^Block=dingbats}', ""); +Expect(0, 10175, '\P{Block=dingbats}', ""); +Expect(1, 10175, '\P{^Block=dingbats}', ""); +Expect(0, 9983, '\p{Block=dingbats}', ""); +Expect(1, 9983, '\p{^Block=dingbats}', ""); +Expect(1, 9983, '\P{Block=dingbats}', ""); +Expect(0, 9983, '\P{^Block=dingbats}', ""); +Expect(1, 10175, '\p{Block= DINGBATS}', ""); +Expect(0, 10175, '\p{^Block= DINGBATS}', ""); +Expect(0, 10175, '\P{Block= DINGBATS}', ""); +Expect(1, 10175, '\P{^Block= DINGBATS}', ""); +Expect(0, 9983, '\p{Block= DINGBATS}', ""); +Expect(1, 9983, '\p{^Block= DINGBATS}', ""); +Expect(1, 9983, '\P{Block= DINGBATS}', ""); +Expect(0, 9983, '\P{^Block= DINGBATS}', ""); +Error('\p{Blk= Dingbats:=}'); +Error('\P{Blk= Dingbats:=}'); +Expect(1, 10175, '\p{Blk=dingbats}', ""); +Expect(0, 10175, '\p{^Blk=dingbats}', ""); +Expect(0, 10175, '\P{Blk=dingbats}', ""); +Expect(1, 10175, '\P{^Blk=dingbats}', ""); +Expect(0, 9983, '\p{Blk=dingbats}', ""); +Expect(1, 9983, '\p{^Blk=dingbats}', ""); +Expect(1, 9983, '\P{Blk=dingbats}', ""); +Expect(0, 9983, '\P{^Blk=dingbats}', ""); +Expect(1, 10175, '\p{Blk= Dingbats}', ""); +Expect(0, 10175, '\p{^Blk= Dingbats}', ""); +Expect(0, 10175, '\P{Blk= Dingbats}', ""); +Expect(1, 10175, '\P{^Blk= Dingbats}', ""); +Expect(0, 9983, '\p{Blk= Dingbats}', ""); +Expect(1, 9983, '\p{^Blk= Dingbats}', ""); +Expect(1, 9983, '\P{Blk= Dingbats}', ""); +Expect(0, 9983, '\P{^Blk= Dingbats}', ""); +Error('\p{Is_Block=-:=dingbats}'); +Error('\P{Is_Block=-:=dingbats}'); +Expect(1, 10175, '\p{Is_Block:dingbats}', ""); +Expect(0, 10175, '\p{^Is_Block:dingbats}', ""); +Expect(0, 10175, '\P{Is_Block:dingbats}', ""); +Expect(1, 10175, '\P{^Is_Block:dingbats}', ""); +Expect(0, 9983, '\p{Is_Block:dingbats}', ""); +Expect(1, 9983, '\p{^Is_Block:dingbats}', ""); +Expect(1, 9983, '\P{Is_Block:dingbats}', ""); +Expect(0, 9983, '\P{^Is_Block:dingbats}', ""); +Expect(1, 10175, '\p{Is_Block=-DINGBATS}', ""); +Expect(0, 10175, '\p{^Is_Block=-DINGBATS}', ""); +Expect(0, 10175, '\P{Is_Block=-DINGBATS}', ""); +Expect(1, 10175, '\P{^Is_Block=-DINGBATS}', ""); +Expect(0, 9983, '\p{Is_Block=-DINGBATS}', ""); +Expect(1, 9983, '\p{^Is_Block=-DINGBATS}', ""); +Expect(1, 9983, '\P{Is_Block=-DINGBATS}', ""); +Expect(0, 9983, '\P{^Is_Block=-DINGBATS}', ""); +Error('\p{Is_Blk=:=DINGBATS}'); +Error('\P{Is_Blk=:=DINGBATS}'); +Expect(1, 10175, '\p{Is_Blk=dingbats}', ""); +Expect(0, 10175, '\p{^Is_Blk=dingbats}', ""); +Expect(0, 10175, '\P{Is_Blk=dingbats}', ""); +Expect(1, 10175, '\P{^Is_Blk=dingbats}', ""); +Expect(0, 9983, '\p{Is_Blk=dingbats}', ""); +Expect(1, 9983, '\p{^Is_Blk=dingbats}', ""); +Expect(1, 9983, '\P{Is_Blk=dingbats}', ""); +Expect(0, 9983, '\P{^Is_Blk=dingbats}', ""); +Expect(1, 10175, '\p{Is_Blk= -Dingbats}', ""); +Expect(0, 10175, '\p{^Is_Blk= -Dingbats}', ""); +Expect(0, 10175, '\P{Is_Blk= -Dingbats}', ""); +Expect(1, 10175, '\P{^Is_Blk= -Dingbats}', ""); +Expect(0, 9983, '\p{Is_Blk= -Dingbats}', ""); +Expect(1, 9983, '\p{^Is_Blk= -Dingbats}', ""); +Expect(1, 9983, '\P{Is_Blk= -Dingbats}', ""); +Expect(0, 9983, '\P{^Is_Blk= -Dingbats}', ""); +Error('\p{Block=/a/unified-canadianABORIGINAL Syllabics}'); +Error('\P{Block=/a/unified-canadianABORIGINAL Syllabics}'); +Expect(1, 5759, '\p{Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5759, '\p{^Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5759, '\P{Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5759, '\P{^Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5119, '\p{Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5119, '\p{^Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5119, '\P{Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5119, '\P{^Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5759, '\p{Block: -_Unified-Canadian ABORIGINALsyllabics}', ""); +Expect(0, 5759, '\p{^Block: -_Unified-Canadian ABORIGINALsyllabics}', ""); +Expect(0, 5759, '\P{Block: -_Unified-Canadian ABORIGINALsyllabics}', ""); +Expect(1, 5759, '\P{^Block: -_Unified-Canadian ABORIGINALsyllabics}', ""); +Expect(0, 5119, '\p{Block: -_Unified-Canadian ABORIGINALsyllabics}', ""); +Expect(1, 5119, '\p{^Block: -_Unified-Canadian ABORIGINALsyllabics}', ""); +Expect(1, 5119, '\P{Block: -_Unified-Canadian ABORIGINALsyllabics}', ""); +Expect(0, 5119, '\P{^Block: -_Unified-Canadian ABORIGINALsyllabics}', ""); +Error('\p{Blk= Canadian/a/syllabics}'); +Error('\P{Blk= Canadian/a/syllabics}'); +Expect(1, 5759, '\p{Blk: canadiansyllabics}', ""); +Expect(0, 5759, '\p{^Blk: canadiansyllabics}', ""); +Expect(0, 5759, '\P{Blk: canadiansyllabics}', ""); +Expect(1, 5759, '\P{^Blk: canadiansyllabics}', ""); +Expect(0, 5119, '\p{Blk: canadiansyllabics}', ""); +Expect(1, 5119, '\p{^Blk: canadiansyllabics}', ""); +Expect(1, 5119, '\P{Blk: canadiansyllabics}', ""); +Expect(0, 5119, '\P{^Blk: canadiansyllabics}', ""); +Expect(1, 5759, '\p{Blk=__CanadianSyllabics}', ""); +Expect(0, 5759, '\p{^Blk=__CanadianSyllabics}', ""); +Expect(0, 5759, '\P{Blk=__CanadianSyllabics}', ""); +Expect(1, 5759, '\P{^Blk=__CanadianSyllabics}', ""); +Expect(0, 5119, '\p{Blk=__CanadianSyllabics}', ""); +Expect(1, 5119, '\p{^Blk=__CanadianSyllabics}', ""); +Expect(1, 5119, '\P{Blk=__CanadianSyllabics}', ""); +Expect(0, 5119, '\P{^Blk=__CanadianSyllabics}', ""); +Error('\p{Is_Block=--UNIFIED-canadian:=ABORIGINAL SYLLABICS}'); +Error('\P{Is_Block=--UNIFIED-canadian:=ABORIGINAL SYLLABICS}'); +Expect(1, 5759, '\p{Is_Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5759, '\p{^Is_Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5759, '\P{Is_Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5759, '\P{^Is_Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5119, '\p{Is_Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5119, '\p{^Is_Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5119, '\P{Is_Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5119, '\P{^Is_Block=unifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5759, '\p{Is_Block= UnifiedCanadian aboriginalsyllabics}', ""); +Expect(0, 5759, '\p{^Is_Block= UnifiedCanadian aboriginalsyllabics}', ""); +Expect(0, 5759, '\P{Is_Block= UnifiedCanadian aboriginalsyllabics}', ""); +Expect(1, 5759, '\P{^Is_Block= UnifiedCanadian aboriginalsyllabics}', ""); +Expect(0, 5119, '\p{Is_Block= UnifiedCanadian aboriginalsyllabics}', ""); +Expect(1, 5119, '\p{^Is_Block= UnifiedCanadian aboriginalsyllabics}', ""); +Expect(1, 5119, '\P{Is_Block= UnifiedCanadian aboriginalsyllabics}', ""); +Expect(0, 5119, '\P{^Is_Block= UnifiedCanadian aboriginalsyllabics}', ""); +Error('\p{Is_Blk=-:=CanadianSYLLABICS}'); +Error('\P{Is_Blk=-:=CanadianSYLLABICS}'); +Expect(1, 5759, '\p{Is_Blk=canadiansyllabics}', ""); +Expect(0, 5759, '\p{^Is_Blk=canadiansyllabics}', ""); +Expect(0, 5759, '\P{Is_Blk=canadiansyllabics}', ""); +Expect(1, 5759, '\P{^Is_Blk=canadiansyllabics}', ""); +Expect(0, 5119, '\p{Is_Blk=canadiansyllabics}', ""); +Expect(1, 5119, '\p{^Is_Blk=canadiansyllabics}', ""); +Expect(1, 5119, '\P{Is_Blk=canadiansyllabics}', ""); +Expect(0, 5119, '\P{^Is_Blk=canadiansyllabics}', ""); +Expect(1, 5759, '\p{Is_Blk: Canadian-Syllabics}', ""); +Expect(0, 5759, '\p{^Is_Blk: Canadian-Syllabics}', ""); +Expect(0, 5759, '\P{Is_Blk: Canadian-Syllabics}', ""); +Expect(1, 5759, '\P{^Is_Blk: Canadian-Syllabics}', ""); +Expect(0, 5119, '\p{Is_Blk: Canadian-Syllabics}', ""); +Expect(1, 5119, '\p{^Is_Blk: Canadian-Syllabics}', ""); +Expect(1, 5119, '\P{Is_Blk: Canadian-Syllabics}', ""); +Expect(0, 5119, '\P{^Is_Blk: Canadian-Syllabics}', ""); +Error('\p{Block=:= VARIATION Selectors}'); +Error('\P{Block=:= VARIATION Selectors}'); +Expect(1, 65039, '\p{Block=variationselectors}', ""); +Expect(0, 65039, '\p{^Block=variationselectors}', ""); +Expect(0, 65039, '\P{Block=variationselectors}', ""); +Expect(1, 65039, '\P{^Block=variationselectors}', ""); +Expect(0, 65023, '\p{Block=variationselectors}', ""); +Expect(1, 65023, '\p{^Block=variationselectors}', ""); +Expect(1, 65023, '\P{Block=variationselectors}', ""); +Expect(0, 65023, '\P{^Block=variationselectors}', ""); +Expect(1, 65039, '\p{Block=-variation-SELECTORS}', ""); +Expect(0, 65039, '\p{^Block=-variation-SELECTORS}', ""); +Expect(0, 65039, '\P{Block=-variation-SELECTORS}', ""); +Expect(1, 65039, '\P{^Block=-variation-SELECTORS}', ""); +Expect(0, 65023, '\p{Block=-variation-SELECTORS}', ""); +Expect(1, 65023, '\p{^Block=-variation-SELECTORS}', ""); +Expect(1, 65023, '\P{Block=-variation-SELECTORS}', ""); +Expect(0, 65023, '\P{^Block=-variation-SELECTORS}', ""); +Error('\p{Blk=_ Variation-Selectors/a/}'); +Error('\P{Blk=_ Variation-Selectors/a/}'); +Expect(1, 65039, '\p{Blk=variationselectors}', ""); +Expect(0, 65039, '\p{^Blk=variationselectors}', ""); +Expect(0, 65039, '\P{Blk=variationselectors}', ""); +Expect(1, 65039, '\P{^Blk=variationselectors}', ""); +Expect(0, 65023, '\p{Blk=variationselectors}', ""); +Expect(1, 65023, '\p{^Blk=variationselectors}', ""); +Expect(1, 65023, '\P{Blk=variationselectors}', ""); +Expect(0, 65023, '\P{^Blk=variationselectors}', ""); +Expect(1, 65039, '\p{Blk= variationselectors}', ""); +Expect(0, 65039, '\p{^Blk= variationselectors}', ""); +Expect(0, 65039, '\P{Blk= variationselectors}', ""); +Expect(1, 65039, '\P{^Blk= variationselectors}', ""); +Expect(0, 65023, '\p{Blk= variationselectors}', ""); +Expect(1, 65023, '\p{^Blk= variationselectors}', ""); +Expect(1, 65023, '\P{Blk= variationselectors}', ""); +Expect(0, 65023, '\P{^Blk= variationselectors}', ""); +Error('\p{Is_Block=- Variation/a/SELECTORS}'); +Error('\P{Is_Block=- Variation/a/SELECTORS}'); +Expect(1, 65039, '\p{Is_Block=variationselectors}', ""); +Expect(0, 65039, '\p{^Is_Block=variationselectors}', ""); +Expect(0, 65039, '\P{Is_Block=variationselectors}', ""); +Expect(1, 65039, '\P{^Is_Block=variationselectors}', ""); +Expect(0, 65023, '\p{Is_Block=variationselectors}', ""); +Expect(1, 65023, '\p{^Is_Block=variationselectors}', ""); +Expect(1, 65023, '\P{Is_Block=variationselectors}', ""); +Expect(0, 65023, '\P{^Is_Block=variationselectors}', ""); +Expect(1, 65039, '\p{Is_Block=Variation_Selectors}', ""); +Expect(0, 65039, '\p{^Is_Block=Variation_Selectors}', ""); +Expect(0, 65039, '\P{Is_Block=Variation_Selectors}', ""); +Expect(1, 65039, '\P{^Is_Block=Variation_Selectors}', ""); +Expect(0, 65023, '\p{Is_Block=Variation_Selectors}', ""); +Expect(1, 65023, '\p{^Is_Block=Variation_Selectors}', ""); +Expect(1, 65023, '\P{Is_Block=Variation_Selectors}', ""); +Expect(0, 65023, '\P{^Is_Block=Variation_Selectors}', ""); +Error('\p{Is_Blk=:=--variation Selectors}'); +Error('\P{Is_Blk=:=--variation Selectors}'); +Expect(1, 65039, '\p{Is_Blk: variationselectors}', ""); +Expect(0, 65039, '\p{^Is_Blk: variationselectors}', ""); +Expect(0, 65039, '\P{Is_Blk: variationselectors}', ""); +Expect(1, 65039, '\P{^Is_Blk: variationselectors}', ""); +Expect(0, 65023, '\p{Is_Blk: variationselectors}', ""); +Expect(1, 65023, '\p{^Is_Blk: variationselectors}', ""); +Expect(1, 65023, '\P{Is_Blk: variationselectors}', ""); +Expect(0, 65023, '\P{^Is_Blk: variationselectors}', ""); +Expect(1, 65039, '\p{Is_Blk= _Variation_SELECTORS}', ""); +Expect(0, 65039, '\p{^Is_Blk= _Variation_SELECTORS}', ""); +Expect(0, 65039, '\P{Is_Blk= _Variation_SELECTORS}', ""); +Expect(1, 65039, '\P{^Is_Blk= _Variation_SELECTORS}', ""); +Expect(0, 65023, '\p{Is_Blk= _Variation_SELECTORS}', ""); +Expect(1, 65023, '\p{^Is_Blk= _Variation_SELECTORS}', ""); +Expect(1, 65023, '\P{Is_Blk= _Variation_SELECTORS}', ""); +Expect(0, 65023, '\P{^Is_Blk= _Variation_SELECTORS}', ""); +Error('\p{Block= /a/number Forms}'); +Error('\P{Block= /a/number Forms}'); +Expect(1, 8591, '\p{Block=numberforms}', ""); +Expect(0, 8591, '\p{^Block=numberforms}', ""); +Expect(0, 8591, '\P{Block=numberforms}', ""); +Expect(1, 8591, '\P{^Block=numberforms}', ""); +Expect(0, 8527, '\p{Block=numberforms}', ""); +Expect(1, 8527, '\p{^Block=numberforms}', ""); +Expect(1, 8527, '\P{Block=numberforms}', ""); +Expect(0, 8527, '\P{^Block=numberforms}', ""); +Expect(1, 8591, '\p{Block=-_Number Forms}', ""); +Expect(0, 8591, '\p{^Block=-_Number Forms}', ""); +Expect(0, 8591, '\P{Block=-_Number Forms}', ""); +Expect(1, 8591, '\P{^Block=-_Number Forms}', ""); +Expect(0, 8527, '\p{Block=-_Number Forms}', ""); +Expect(1, 8527, '\p{^Block=-_Number Forms}', ""); +Expect(1, 8527, '\P{Block=-_Number Forms}', ""); +Expect(0, 8527, '\P{^Block=-_Number Forms}', ""); +Error('\p{Blk=-NUMBER:=forms}'); +Error('\P{Blk=-NUMBER:=forms}'); +Expect(1, 8591, '\p{Blk=numberforms}', ""); +Expect(0, 8591, '\p{^Blk=numberforms}', ""); +Expect(0, 8591, '\P{Blk=numberforms}', ""); +Expect(1, 8591, '\P{^Blk=numberforms}', ""); +Expect(0, 8527, '\p{Blk=numberforms}', ""); +Expect(1, 8527, '\p{^Blk=numberforms}', ""); +Expect(1, 8527, '\P{Blk=numberforms}', ""); +Expect(0, 8527, '\P{^Blk=numberforms}', ""); +Expect(1, 8591, '\p{Blk= -NUMBER forms}', ""); +Expect(0, 8591, '\p{^Blk= -NUMBER forms}', ""); +Expect(0, 8591, '\P{Blk= -NUMBER forms}', ""); +Expect(1, 8591, '\P{^Blk= -NUMBER forms}', ""); +Expect(0, 8527, '\p{Blk= -NUMBER forms}', ""); +Expect(1, 8527, '\p{^Blk= -NUMBER forms}', ""); +Expect(1, 8527, '\P{Blk= -NUMBER forms}', ""); +Expect(0, 8527, '\P{^Blk= -NUMBER forms}', ""); +Error('\p{Is_Block=Number/a/forms}'); +Error('\P{Is_Block=Number/a/forms}'); +Expect(1, 8591, '\p{Is_Block=numberforms}', ""); +Expect(0, 8591, '\p{^Is_Block=numberforms}', ""); +Expect(0, 8591, '\P{Is_Block=numberforms}', ""); +Expect(1, 8591, '\P{^Is_Block=numberforms}', ""); +Expect(0, 8527, '\p{Is_Block=numberforms}', ""); +Expect(1, 8527, '\p{^Is_Block=numberforms}', ""); +Expect(1, 8527, '\P{Is_Block=numberforms}', ""); +Expect(0, 8527, '\P{^Is_Block=numberforms}', ""); +Expect(1, 8591, '\p{Is_Block=_ numberFORMS}', ""); +Expect(0, 8591, '\p{^Is_Block=_ numberFORMS}', ""); +Expect(0, 8591, '\P{Is_Block=_ numberFORMS}', ""); +Expect(1, 8591, '\P{^Is_Block=_ numberFORMS}', ""); +Expect(0, 8527, '\p{Is_Block=_ numberFORMS}', ""); +Expect(1, 8527, '\p{^Is_Block=_ numberFORMS}', ""); +Expect(1, 8527, '\P{Is_Block=_ numberFORMS}', ""); +Expect(0, 8527, '\P{^Is_Block=_ numberFORMS}', ""); +Error('\p{Is_Blk=_-Number FORMS:=}'); +Error('\P{Is_Blk=_-Number FORMS:=}'); +Expect(1, 8591, '\p{Is_Blk=numberforms}', ""); +Expect(0, 8591, '\p{^Is_Blk=numberforms}', ""); +Expect(0, 8591, '\P{Is_Blk=numberforms}', ""); +Expect(1, 8591, '\P{^Is_Blk=numberforms}', ""); +Expect(0, 8527, '\p{Is_Blk=numberforms}', ""); +Expect(1, 8527, '\p{^Is_Blk=numberforms}', ""); +Expect(1, 8527, '\P{Is_Blk=numberforms}', ""); +Expect(0, 8527, '\P{^Is_Blk=numberforms}', ""); +Expect(1, 8591, '\p{Is_Blk= NUMBER-Forms}', ""); +Expect(0, 8591, '\p{^Is_Blk= NUMBER-Forms}', ""); +Expect(0, 8591, '\P{Is_Blk= NUMBER-Forms}', ""); +Expect(1, 8591, '\P{^Is_Blk= NUMBER-Forms}', ""); +Expect(0, 8527, '\p{Is_Blk= NUMBER-Forms}', ""); +Expect(1, 8527, '\p{^Is_Blk= NUMBER-Forms}', ""); +Expect(1, 8527, '\P{Is_Blk= NUMBER-Forms}', ""); +Expect(0, 8527, '\P{^Is_Blk= NUMBER-Forms}', ""); +Error('\p{Block=-:=CONTROL-pictures}'); +Error('\P{Block=-:=CONTROL-pictures}'); +Expect(1, 9279, '\p{Block=controlpictures}', ""); +Expect(0, 9279, '\p{^Block=controlpictures}', ""); +Expect(0, 9279, '\P{Block=controlpictures}', ""); +Expect(1, 9279, '\P{^Block=controlpictures}', ""); +Expect(0, 9215, '\p{Block=controlpictures}', ""); +Expect(1, 9215, '\p{^Block=controlpictures}', ""); +Expect(1, 9215, '\P{Block=controlpictures}', ""); +Expect(0, 9215, '\P{^Block=controlpictures}', ""); +Expect(1, 9279, '\p{Block=_ Control_PICTURES}', ""); +Expect(0, 9279, '\p{^Block=_ Control_PICTURES}', ""); +Expect(0, 9279, '\P{Block=_ Control_PICTURES}', ""); +Expect(1, 9279, '\P{^Block=_ Control_PICTURES}', ""); +Expect(0, 9215, '\p{Block=_ Control_PICTURES}', ""); +Expect(1, 9215, '\p{^Block=_ Control_PICTURES}', ""); +Expect(1, 9215, '\P{Block=_ Control_PICTURES}', ""); +Expect(0, 9215, '\P{^Block=_ Control_PICTURES}', ""); +Error('\p{Blk=-:=Control_Pictures}'); +Error('\P{Blk=-:=Control_Pictures}'); +Expect(1, 9279, '\p{Blk=controlpictures}', ""); +Expect(0, 9279, '\p{^Blk=controlpictures}', ""); +Expect(0, 9279, '\P{Blk=controlpictures}', ""); +Expect(1, 9279, '\P{^Blk=controlpictures}', ""); +Expect(0, 9215, '\p{Blk=controlpictures}', ""); +Expect(1, 9215, '\p{^Blk=controlpictures}', ""); +Expect(1, 9215, '\P{Blk=controlpictures}', ""); +Expect(0, 9215, '\P{^Blk=controlpictures}', ""); +Expect(1, 9279, '\p{Blk=_ Control Pictures}', ""); +Expect(0, 9279, '\p{^Blk=_ Control Pictures}', ""); +Expect(0, 9279, '\P{Blk=_ Control Pictures}', ""); +Expect(1, 9279, '\P{^Blk=_ Control Pictures}', ""); +Expect(0, 9215, '\p{Blk=_ Control Pictures}', ""); +Expect(1, 9215, '\p{^Blk=_ Control Pictures}', ""); +Expect(1, 9215, '\P{Blk=_ Control Pictures}', ""); +Expect(0, 9215, '\P{^Blk=_ Control Pictures}', ""); +Error('\p{Is_Block=_ controlPICTURES/a/}'); +Error('\P{Is_Block=_ controlPICTURES/a/}'); +Expect(1, 9279, '\p{Is_Block: controlpictures}', ""); +Expect(0, 9279, '\p{^Is_Block: controlpictures}', ""); +Expect(0, 9279, '\P{Is_Block: controlpictures}', ""); +Expect(1, 9279, '\P{^Is_Block: controlpictures}', ""); +Expect(0, 9215, '\p{Is_Block: controlpictures}', ""); +Expect(1, 9215, '\p{^Is_Block: controlpictures}', ""); +Expect(1, 9215, '\P{Is_Block: controlpictures}', ""); +Expect(0, 9215, '\P{^Is_Block: controlpictures}', ""); +Expect(1, 9279, '\p{Is_Block=-Control Pictures}', ""); +Expect(0, 9279, '\p{^Is_Block=-Control Pictures}', ""); +Expect(0, 9279, '\P{Is_Block=-Control Pictures}', ""); +Expect(1, 9279, '\P{^Is_Block=-Control Pictures}', ""); +Expect(0, 9215, '\p{Is_Block=-Control Pictures}', ""); +Expect(1, 9215, '\p{^Is_Block=-Control Pictures}', ""); +Expect(1, 9215, '\P{Is_Block=-Control Pictures}', ""); +Expect(0, 9215, '\P{^Is_Block=-Control Pictures}', ""); +Error('\p{Is_Blk= control:=Pictures}'); +Error('\P{Is_Blk= control:=Pictures}'); +Expect(1, 9279, '\p{Is_Blk=controlpictures}', ""); +Expect(0, 9279, '\p{^Is_Blk=controlpictures}', ""); +Expect(0, 9279, '\P{Is_Blk=controlpictures}', ""); +Expect(1, 9279, '\P{^Is_Blk=controlpictures}', ""); +Expect(0, 9215, '\p{Is_Blk=controlpictures}', ""); +Expect(1, 9215, '\p{^Is_Blk=controlpictures}', ""); +Expect(1, 9215, '\P{Is_Blk=controlpictures}', ""); +Expect(0, 9215, '\P{^Is_Blk=controlpictures}', ""); +Expect(1, 9279, '\p{Is_Blk= _CONTROL-Pictures}', ""); +Expect(0, 9279, '\p{^Is_Blk= _CONTROL-Pictures}', ""); +Expect(0, 9279, '\P{Is_Blk= _CONTROL-Pictures}', ""); +Expect(1, 9279, '\P{^Is_Blk= _CONTROL-Pictures}', ""); +Expect(0, 9215, '\p{Is_Blk= _CONTROL-Pictures}', ""); +Expect(1, 9215, '\p{^Is_Blk= _CONTROL-Pictures}', ""); +Expect(1, 9215, '\P{Is_Blk= _CONTROL-Pictures}', ""); +Expect(0, 9215, '\P{^Is_Blk= _CONTROL-Pictures}', ""); +Error('\p{Block=/a/ High Private_USE_Surrogates}'); +Error('\P{Block=/a/ High Private_USE_Surrogates}'); +Expect(0, 7, '\p{Block: highprivateusesurrogates}', ""); +Expect(1, 7, '\p{^Block: highprivateusesurrogates}', ""); +Expect(1, 7, '\P{Block: highprivateusesurrogates}', ""); +Expect(0, 7, '\P{^Block: highprivateusesurrogates}', ""); +Expect(0, 7, '\p{Block=-_High-Private usesurrogates}', ""); +Expect(1, 7, '\p{^Block=-_High-Private usesurrogates}', ""); +Expect(1, 7, '\P{Block=-_High-Private usesurrogates}', ""); +Expect(0, 7, '\P{^Block=-_High-Private usesurrogates}', ""); +Error('\p{Blk= /a/high_Private_USESurrogates}'); +Error('\P{Blk= /a/high_Private_USESurrogates}'); +Expect(0, 7, '\p{Blk=highprivateusesurrogates}', ""); +Expect(1, 7, '\p{^Blk=highprivateusesurrogates}', ""); +Expect(1, 7, '\P{Blk=highprivateusesurrogates}', ""); +Expect(0, 7, '\P{^Blk=highprivateusesurrogates}', ""); +Expect(0, 7, '\p{Blk= High Private-USE Surrogates}', ""); +Expect(1, 7, '\p{^Blk= High Private-USE Surrogates}', ""); +Expect(1, 7, '\P{Blk= High Private-USE Surrogates}', ""); +Expect(0, 7, '\P{^Blk= High Private-USE Surrogates}', ""); +Error('\p{Is_Block=:=HighprivateUse surrogates}'); +Error('\P{Is_Block=:=HighprivateUse surrogates}'); +Expect(0, 7, '\p{Is_Block=highprivateusesurrogates}', ""); +Expect(1, 7, '\p{^Is_Block=highprivateusesurrogates}', ""); +Expect(1, 7, '\P{Is_Block=highprivateusesurrogates}', ""); +Expect(0, 7, '\P{^Is_Block=highprivateusesurrogates}', ""); +Expect(0, 7, '\p{Is_Block= High PRIVATEUse surrogates}', ""); +Expect(1, 7, '\p{^Is_Block= High PRIVATEUse surrogates}', ""); +Expect(1, 7, '\P{Is_Block= High PRIVATEUse surrogates}', ""); +Expect(0, 7, '\P{^Is_Block= High PRIVATEUse surrogates}', ""); +Error('\p{Is_Blk= :=high Private-USE_SURROGATES}'); +Error('\P{Is_Blk= :=high Private-USE_SURROGATES}'); +Expect(0, 7, '\p{Is_Blk:highprivateusesurrogates}', ""); +Expect(1, 7, '\p{^Is_Blk:highprivateusesurrogates}', ""); +Expect(1, 7, '\P{Is_Blk:highprivateusesurrogates}', ""); +Expect(0, 7, '\P{^Is_Blk:highprivateusesurrogates}', ""); +Expect(0, 7, '\p{Is_Blk=--high_Private-use-Surrogates}', ""); +Expect(1, 7, '\p{^Is_Blk=--high_Private-use-Surrogates}', ""); +Expect(1, 7, '\P{Is_Blk=--high_Private-use-Surrogates}', ""); +Expect(0, 7, '\P{^Is_Blk=--high_Private-use-Surrogates}', ""); +Error('\p{Block= :=Ugaritic}'); +Error('\P{Block= :=Ugaritic}'); +Expect(1, 66463, '\p{Block=ugaritic}', ""); +Expect(0, 66463, '\p{^Block=ugaritic}', ""); +Expect(0, 66463, '\P{Block=ugaritic}', ""); +Expect(1, 66463, '\P{^Block=ugaritic}', ""); +Expect(0, 66431, '\p{Block=ugaritic}', ""); +Expect(1, 66431, '\p{^Block=ugaritic}', ""); +Expect(1, 66431, '\P{Block=ugaritic}', ""); +Expect(0, 66431, '\P{^Block=ugaritic}', ""); +Expect(1, 66463, '\p{Block= _UGARITIC}', ""); +Expect(0, 66463, '\p{^Block= _UGARITIC}', ""); +Expect(0, 66463, '\P{Block= _UGARITIC}', ""); +Expect(1, 66463, '\P{^Block= _UGARITIC}', ""); +Expect(0, 66431, '\p{Block= _UGARITIC}', ""); +Expect(1, 66431, '\p{^Block= _UGARITIC}', ""); +Expect(1, 66431, '\P{Block= _UGARITIC}', ""); +Expect(0, 66431, '\P{^Block= _UGARITIC}', ""); +Error('\p{Blk=_ ugaritic/a/}'); +Error('\P{Blk=_ ugaritic/a/}'); +Expect(1, 66463, '\p{Blk=ugaritic}', ""); +Expect(0, 66463, '\p{^Blk=ugaritic}', ""); +Expect(0, 66463, '\P{Blk=ugaritic}', ""); +Expect(1, 66463, '\P{^Blk=ugaritic}', ""); +Expect(0, 66431, '\p{Blk=ugaritic}', ""); +Expect(1, 66431, '\p{^Blk=ugaritic}', ""); +Expect(1, 66431, '\P{Blk=ugaritic}', ""); +Expect(0, 66431, '\P{^Blk=ugaritic}', ""); +Expect(1, 66463, '\p{Blk=_ UGARITIC}', ""); +Expect(0, 66463, '\p{^Blk=_ UGARITIC}', ""); +Expect(0, 66463, '\P{Blk=_ UGARITIC}', ""); +Expect(1, 66463, '\P{^Blk=_ UGARITIC}', ""); +Expect(0, 66431, '\p{Blk=_ UGARITIC}', ""); +Expect(1, 66431, '\p{^Blk=_ UGARITIC}', ""); +Expect(1, 66431, '\P{Blk=_ UGARITIC}', ""); +Expect(0, 66431, '\P{^Blk=_ UGARITIC}', ""); +Error('\p{Is_Block=-:=Ugaritic}'); +Error('\P{Is_Block=-:=Ugaritic}'); +Expect(1, 66463, '\p{Is_Block=ugaritic}', ""); +Expect(0, 66463, '\p{^Is_Block=ugaritic}', ""); +Expect(0, 66463, '\P{Is_Block=ugaritic}', ""); +Expect(1, 66463, '\P{^Is_Block=ugaritic}', ""); +Expect(0, 66431, '\p{Is_Block=ugaritic}', ""); +Expect(1, 66431, '\p{^Is_Block=ugaritic}', ""); +Expect(1, 66431, '\P{Is_Block=ugaritic}', ""); +Expect(0, 66431, '\P{^Is_Block=ugaritic}', ""); +Expect(1, 66463, '\p{Is_Block= Ugaritic}', ""); +Expect(0, 66463, '\p{^Is_Block= Ugaritic}', ""); +Expect(0, 66463, '\P{Is_Block= Ugaritic}', ""); +Expect(1, 66463, '\P{^Is_Block= Ugaritic}', ""); +Expect(0, 66431, '\p{Is_Block= Ugaritic}', ""); +Expect(1, 66431, '\p{^Is_Block= Ugaritic}', ""); +Expect(1, 66431, '\P{Is_Block= Ugaritic}', ""); +Expect(0, 66431, '\P{^Is_Block= Ugaritic}', ""); +Error('\p{Is_Blk= UGARITIC/a/}'); +Error('\P{Is_Blk= UGARITIC/a/}'); +Expect(1, 66463, '\p{Is_Blk=ugaritic}', ""); +Expect(0, 66463, '\p{^Is_Blk=ugaritic}', ""); +Expect(0, 66463, '\P{Is_Blk=ugaritic}', ""); +Expect(1, 66463, '\P{^Is_Blk=ugaritic}', ""); +Expect(0, 66431, '\p{Is_Blk=ugaritic}', ""); +Expect(1, 66431, '\p{^Is_Blk=ugaritic}', ""); +Expect(1, 66431, '\P{Is_Blk=ugaritic}', ""); +Expect(0, 66431, '\P{^Is_Blk=ugaritic}', ""); +Expect(1, 66463, '\p{Is_Blk=_ Ugaritic}', ""); +Expect(0, 66463, '\p{^Is_Blk=_ Ugaritic}', ""); +Expect(0, 66463, '\P{Is_Blk=_ Ugaritic}', ""); +Expect(1, 66463, '\P{^Is_Blk=_ Ugaritic}', ""); +Expect(0, 66431, '\p{Is_Blk=_ Ugaritic}', ""); +Expect(1, 66431, '\p{^Is_Blk=_ Ugaritic}', ""); +Expect(1, 66431, '\P{Is_Blk=_ Ugaritic}', ""); +Expect(0, 66431, '\P{^Is_Blk=_ Ugaritic}', ""); +Error('\p{Block=:= -Armenian}'); +Error('\P{Block=:= -Armenian}'); +Expect(1, 1423, '\p{Block=armenian}', ""); +Expect(0, 1423, '\p{^Block=armenian}', ""); +Expect(0, 1423, '\P{Block=armenian}', ""); +Expect(1, 1423, '\P{^Block=armenian}', ""); +Expect(0, 1327, '\p{Block=armenian}', ""); +Expect(1, 1327, '\p{^Block=armenian}', ""); +Expect(1, 1327, '\P{Block=armenian}', ""); +Expect(0, 1327, '\P{^Block=armenian}', ""); +Expect(1, 1423, '\p{Block=_ ARMENIAN}', ""); +Expect(0, 1423, '\p{^Block=_ ARMENIAN}', ""); +Expect(0, 1423, '\P{Block=_ ARMENIAN}', ""); +Expect(1, 1423, '\P{^Block=_ ARMENIAN}', ""); +Expect(0, 1327, '\p{Block=_ ARMENIAN}', ""); +Expect(1, 1327, '\p{^Block=_ ARMENIAN}', ""); +Expect(1, 1327, '\P{Block=_ ARMENIAN}', ""); +Expect(0, 1327, '\P{^Block=_ ARMENIAN}', ""); +Error('\p{Blk=-/a/Armenian}'); +Error('\P{Blk=-/a/Armenian}'); +Expect(1, 1423, '\p{Blk=armenian}', ""); +Expect(0, 1423, '\p{^Blk=armenian}', ""); +Expect(0, 1423, '\P{Blk=armenian}', ""); +Expect(1, 1423, '\P{^Blk=armenian}', ""); +Expect(0, 1327, '\p{Blk=armenian}', ""); +Expect(1, 1327, '\p{^Blk=armenian}', ""); +Expect(1, 1327, '\P{Blk=armenian}', ""); +Expect(0, 1327, '\P{^Blk=armenian}', ""); +Expect(1, 1423, '\p{Blk= armenian}', ""); +Expect(0, 1423, '\p{^Blk= armenian}', ""); +Expect(0, 1423, '\P{Blk= armenian}', ""); +Expect(1, 1423, '\P{^Blk= armenian}', ""); +Expect(0, 1327, '\p{Blk= armenian}', ""); +Expect(1, 1327, '\p{^Blk= armenian}', ""); +Expect(1, 1327, '\P{Blk= armenian}', ""); +Expect(0, 1327, '\P{^Blk= armenian}', ""); +Error('\p{Is_Block= Armenian/a/}'); +Error('\P{Is_Block= Armenian/a/}'); +Expect(1, 1423, '\p{Is_Block=armenian}', ""); +Expect(0, 1423, '\p{^Is_Block=armenian}', ""); +Expect(0, 1423, '\P{Is_Block=armenian}', ""); +Expect(1, 1423, '\P{^Is_Block=armenian}', ""); +Expect(0, 1327, '\p{Is_Block=armenian}', ""); +Expect(1, 1327, '\p{^Is_Block=armenian}', ""); +Expect(1, 1327, '\P{Is_Block=armenian}', ""); +Expect(0, 1327, '\P{^Is_Block=armenian}', ""); +Expect(1, 1423, '\p{Is_Block=_ Armenian}', ""); +Expect(0, 1423, '\p{^Is_Block=_ Armenian}', ""); +Expect(0, 1423, '\P{Is_Block=_ Armenian}', ""); +Expect(1, 1423, '\P{^Is_Block=_ Armenian}', ""); +Expect(0, 1327, '\p{Is_Block=_ Armenian}', ""); +Expect(1, 1327, '\p{^Is_Block=_ Armenian}', ""); +Expect(1, 1327, '\P{Is_Block=_ Armenian}', ""); +Expect(0, 1327, '\P{^Is_Block=_ Armenian}', ""); +Error('\p{Is_Blk=_:=Armenian}'); +Error('\P{Is_Blk=_:=Armenian}'); +Expect(1, 1423, '\p{Is_Blk=armenian}', ""); +Expect(0, 1423, '\p{^Is_Blk=armenian}', ""); +Expect(0, 1423, '\P{Is_Blk=armenian}', ""); +Expect(1, 1423, '\P{^Is_Blk=armenian}', ""); +Expect(0, 1327, '\p{Is_Blk=armenian}', ""); +Expect(1, 1327, '\p{^Is_Blk=armenian}', ""); +Expect(1, 1327, '\P{Is_Blk=armenian}', ""); +Expect(0, 1327, '\P{^Is_Blk=armenian}', ""); +Expect(1, 1423, '\p{Is_Blk=--Armenian}', ""); +Expect(0, 1423, '\p{^Is_Blk=--Armenian}', ""); +Expect(0, 1423, '\P{Is_Blk=--Armenian}', ""); +Expect(1, 1423, '\P{^Is_Blk=--Armenian}', ""); +Expect(0, 1327, '\p{Is_Blk=--Armenian}', ""); +Expect(1, 1327, '\p{^Is_Blk=--Armenian}', ""); +Expect(1, 1327, '\P{Is_Blk=--Armenian}', ""); +Expect(0, 1327, '\P{^Is_Blk=--Armenian}', ""); +Error('\p{Block: /a/PRIVATE_Use_Area}'); +Error('\P{Block: /a/PRIVATE_Use_Area}'); +Expect(1, 63743, '\p{Block=privateusearea}', ""); +Expect(0, 63743, '\p{^Block=privateusearea}', ""); +Expect(0, 63743, '\P{Block=privateusearea}', ""); +Expect(1, 63743, '\P{^Block=privateusearea}', ""); +Expect(0, 7, '\p{Block=privateusearea}', ""); +Expect(1, 7, '\p{^Block=privateusearea}', ""); +Expect(1, 7, '\P{Block=privateusearea}', ""); +Expect(0, 7, '\P{^Block=privateusearea}', ""); +Expect(1, 63743, '\p{Block= _Private Use Area}', ""); +Expect(0, 63743, '\p{^Block= _Private Use Area}', ""); +Expect(0, 63743, '\P{Block= _Private Use Area}', ""); +Expect(1, 63743, '\P{^Block= _Private Use Area}', ""); +Expect(0, 7, '\p{Block= _Private Use Area}', ""); +Expect(1, 7, '\p{^Block= _Private Use Area}', ""); +Expect(1, 7, '\P{Block= _Private Use Area}', ""); +Expect(0, 7, '\P{^Block= _Private Use Area}', ""); +Error('\p{Blk=_:=PRIVATE-Use}'); +Error('\P{Blk=_:=PRIVATE-Use}'); +Expect(1, 63743, '\p{Blk=privateuse}', ""); +Expect(0, 63743, '\p{^Blk=privateuse}', ""); +Expect(0, 63743, '\P{Blk=privateuse}', ""); +Expect(1, 63743, '\P{^Blk=privateuse}', ""); +Expect(0, 7, '\p{Blk=privateuse}', ""); +Expect(1, 7, '\p{^Blk=privateuse}', ""); +Expect(1, 7, '\P{Blk=privateuse}', ""); +Expect(0, 7, '\P{^Blk=privateuse}', ""); +Expect(1, 63743, '\p{Blk= PRIVATE use}', ""); +Expect(0, 63743, '\p{^Blk= PRIVATE use}', ""); +Expect(0, 63743, '\P{Blk= PRIVATE use}', ""); +Expect(1, 63743, '\P{^Blk= PRIVATE use}', ""); +Expect(0, 7, '\p{Blk= PRIVATE use}', ""); +Expect(1, 7, '\p{^Blk= PRIVATE use}', ""); +Expect(1, 7, '\P{Blk= PRIVATE use}', ""); +Expect(0, 7, '\P{^Blk= PRIVATE use}', ""); +Error('\p{Is_Block= :=Private use AREA}'); +Error('\P{Is_Block= :=Private use AREA}'); +Expect(1, 63743, '\p{Is_Block=privateusearea}', ""); +Expect(0, 63743, '\p{^Is_Block=privateusearea}', ""); +Expect(0, 63743, '\P{Is_Block=privateusearea}', ""); +Expect(1, 63743, '\P{^Is_Block=privateusearea}', ""); +Expect(0, 7, '\p{Is_Block=privateusearea}', ""); +Expect(1, 7, '\p{^Is_Block=privateusearea}', ""); +Expect(1, 7, '\P{Is_Block=privateusearea}', ""); +Expect(0, 7, '\P{^Is_Block=privateusearea}', ""); +Expect(1, 63743, '\p{Is_Block= private_Use AREA}', ""); +Expect(0, 63743, '\p{^Is_Block= private_Use AREA}', ""); +Expect(0, 63743, '\P{Is_Block= private_Use AREA}', ""); +Expect(1, 63743, '\P{^Is_Block= private_Use AREA}', ""); +Expect(0, 7, '\p{Is_Block= private_Use AREA}', ""); +Expect(1, 7, '\p{^Is_Block= private_Use AREA}', ""); +Expect(1, 7, '\P{Is_Block= private_Use AREA}', ""); +Expect(0, 7, '\P{^Is_Block= private_Use AREA}', ""); +Error('\p{Is_Blk=-/a/PRIVATE_USE}'); +Error('\P{Is_Blk=-/a/PRIVATE_USE}'); +Expect(1, 63743, '\p{Is_Blk=privateuse}', ""); +Expect(0, 63743, '\p{^Is_Blk=privateuse}', ""); +Expect(0, 63743, '\P{Is_Blk=privateuse}', ""); +Expect(1, 63743, '\P{^Is_Blk=privateuse}', ""); +Expect(0, 7, '\p{Is_Blk=privateuse}', ""); +Expect(1, 7, '\p{^Is_Blk=privateuse}', ""); +Expect(1, 7, '\P{Is_Blk=privateuse}', ""); +Expect(0, 7, '\P{^Is_Blk=privateuse}', ""); +Expect(1, 63743, '\p{Is_Blk= Private-USE}', ""); +Expect(0, 63743, '\p{^Is_Blk= Private-USE}', ""); +Expect(0, 63743, '\P{Is_Blk= Private-USE}', ""); +Expect(1, 63743, '\P{^Is_Blk= Private-USE}', ""); +Expect(0, 7, '\p{Is_Blk= Private-USE}', ""); +Expect(1, 7, '\p{^Is_Blk= Private-USE}', ""); +Expect(1, 7, '\P{Is_Blk= Private-USE}', ""); +Expect(0, 7, '\P{^Is_Blk= Private-USE}', ""); +Error('\p{Block=/a/_-syriac}'); +Error('\P{Block=/a/_-syriac}'); +Expect(1, 1871, '\p{Block=syriac}', ""); +Expect(0, 1871, '\p{^Block=syriac}', ""); +Expect(0, 1871, '\P{Block=syriac}', ""); +Expect(1, 1871, '\P{^Block=syriac}', ""); +Expect(0, 1791, '\p{Block=syriac}', ""); +Expect(1, 1791, '\p{^Block=syriac}', ""); +Expect(1, 1791, '\P{Block=syriac}', ""); +Expect(0, 1791, '\P{^Block=syriac}', ""); +Expect(1, 1871, '\p{Block= Syriac}', ""); +Expect(0, 1871, '\p{^Block= Syriac}', ""); +Expect(0, 1871, '\P{Block= Syriac}', ""); +Expect(1, 1871, '\P{^Block= Syriac}', ""); +Expect(0, 1791, '\p{Block= Syriac}', ""); +Expect(1, 1791, '\p{^Block= Syriac}', ""); +Expect(1, 1791, '\P{Block= Syriac}', ""); +Expect(0, 1791, '\P{^Block= Syriac}', ""); +Error('\p{Blk=_SYRIAC:=}'); +Error('\P{Blk=_SYRIAC:=}'); +Expect(1, 1871, '\p{Blk=syriac}', ""); +Expect(0, 1871, '\p{^Blk=syriac}', ""); +Expect(0, 1871, '\P{Blk=syriac}', ""); +Expect(1, 1871, '\P{^Blk=syriac}', ""); +Expect(0, 1791, '\p{Blk=syriac}', ""); +Expect(1, 1791, '\p{^Blk=syriac}', ""); +Expect(1, 1791, '\P{Blk=syriac}', ""); +Expect(0, 1791, '\P{^Blk=syriac}', ""); +Expect(1, 1871, '\p{Blk=_ Syriac}', ""); +Expect(0, 1871, '\p{^Blk=_ Syriac}', ""); +Expect(0, 1871, '\P{Blk=_ Syriac}', ""); +Expect(1, 1871, '\P{^Blk=_ Syriac}', ""); +Expect(0, 1791, '\p{Blk=_ Syriac}', ""); +Expect(1, 1791, '\p{^Blk=_ Syriac}', ""); +Expect(1, 1791, '\P{Blk=_ Syriac}', ""); +Expect(0, 1791, '\P{^Blk=_ Syriac}', ""); +Error('\p{Is_Block=_:=Syriac}'); +Error('\P{Is_Block=_:=Syriac}'); +Expect(1, 1871, '\p{Is_Block=syriac}', ""); +Expect(0, 1871, '\p{^Is_Block=syriac}', ""); +Expect(0, 1871, '\P{Is_Block=syriac}', ""); +Expect(1, 1871, '\P{^Is_Block=syriac}', ""); +Expect(0, 1791, '\p{Is_Block=syriac}', ""); +Expect(1, 1791, '\p{^Is_Block=syriac}', ""); +Expect(1, 1791, '\P{Is_Block=syriac}', ""); +Expect(0, 1791, '\P{^Is_Block=syriac}', ""); +Expect(1, 1871, '\p{Is_Block= syriac}', ""); +Expect(0, 1871, '\p{^Is_Block= syriac}', ""); +Expect(0, 1871, '\P{Is_Block= syriac}', ""); +Expect(1, 1871, '\P{^Is_Block= syriac}', ""); +Expect(0, 1791, '\p{Is_Block= syriac}', ""); +Expect(1, 1791, '\p{^Is_Block= syriac}', ""); +Expect(1, 1791, '\P{Is_Block= syriac}', ""); +Expect(0, 1791, '\P{^Is_Block= syriac}', ""); +Error('\p{Is_Blk= -Syriac/a/}'); +Error('\P{Is_Blk= -Syriac/a/}'); +Expect(1, 1871, '\p{Is_Blk:syriac}', ""); +Expect(0, 1871, '\p{^Is_Blk:syriac}', ""); +Expect(0, 1871, '\P{Is_Blk:syriac}', ""); +Expect(1, 1871, '\P{^Is_Blk:syriac}', ""); +Expect(0, 1791, '\p{Is_Blk:syriac}', ""); +Expect(1, 1791, '\p{^Is_Blk:syriac}', ""); +Expect(1, 1791, '\P{Is_Blk:syriac}', ""); +Expect(0, 1791, '\P{^Is_Blk:syriac}', ""); +Expect(1, 1871, '\p{Is_Blk=_Syriac}', ""); +Expect(0, 1871, '\p{^Is_Blk=_Syriac}', ""); +Expect(0, 1871, '\P{Is_Blk=_Syriac}', ""); +Expect(1, 1871, '\P{^Is_Blk=_Syriac}', ""); +Expect(0, 1791, '\p{Is_Blk=_Syriac}', ""); +Expect(1, 1791, '\p{^Is_Blk=_Syriac}', ""); +Expect(1, 1791, '\P{Is_Blk=_Syriac}', ""); +Expect(0, 1791, '\P{^Is_Blk=_Syriac}', ""); +Error('\p{Block= ancient:=Greek Musical-NOTATION}'); +Error('\P{Block= ancient:=Greek Musical-NOTATION}'); +Expect(1, 119375, '\p{Block=ancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\p{^Block=ancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\P{Block=ancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\P{^Block=ancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\p{Block=ancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\p{^Block=ancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\P{Block=ancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\P{^Block=ancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\p{Block=_ Ancient-GREEK Musical Notation}', ""); +Expect(0, 119375, '\p{^Block=_ Ancient-GREEK Musical Notation}', ""); +Expect(0, 119375, '\P{Block=_ Ancient-GREEK Musical Notation}', ""); +Expect(1, 119375, '\P{^Block=_ Ancient-GREEK Musical Notation}', ""); +Expect(0, 119295, '\p{Block=_ Ancient-GREEK Musical Notation}', ""); +Expect(1, 119295, '\p{^Block=_ Ancient-GREEK Musical Notation}', ""); +Expect(1, 119295, '\P{Block=_ Ancient-GREEK Musical Notation}', ""); +Expect(0, 119295, '\P{^Block=_ Ancient-GREEK Musical Notation}', ""); +Error('\p{Blk=_ANCIENT_GreekMUSICAL Notation:=}'); +Error('\P{Blk=_ANCIENT_GreekMUSICAL Notation:=}'); +Expect(1, 119375, '\p{Blk=ancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\p{^Blk=ancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\P{Blk=ancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\P{^Blk=ancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\p{Blk=ancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\p{^Blk=ancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\P{Blk=ancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\P{^Blk=ancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\p{Blk= _AncientgreekMusical Notation}', ""); +Expect(0, 119375, '\p{^Blk= _AncientgreekMusical Notation}', ""); +Expect(0, 119375, '\P{Blk= _AncientgreekMusical Notation}', ""); +Expect(1, 119375, '\P{^Blk= _AncientgreekMusical Notation}', ""); +Expect(0, 119295, '\p{Blk= _AncientgreekMusical Notation}', ""); +Expect(1, 119295, '\p{^Blk= _AncientgreekMusical Notation}', ""); +Expect(1, 119295, '\P{Blk= _AncientgreekMusical Notation}', ""); +Expect(0, 119295, '\P{^Blk= _AncientgreekMusical Notation}', ""); +Error('\p{Is_Block=__ancient/a/Greek Musical Notation}'); +Error('\P{Is_Block=__ancient/a/Greek Musical Notation}'); +Expect(1, 119375, '\p{Is_Block=ancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\p{^Is_Block=ancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\P{Is_Block=ancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\P{^Is_Block=ancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\p{Is_Block=ancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\p{^Is_Block=ancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\P{Is_Block=ancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\P{^Is_Block=ancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\p{Is_Block=--ANCIENTGreek_musical_notation}', ""); +Expect(0, 119375, '\p{^Is_Block=--ANCIENTGreek_musical_notation}', ""); +Expect(0, 119375, '\P{Is_Block=--ANCIENTGreek_musical_notation}', ""); +Expect(1, 119375, '\P{^Is_Block=--ANCIENTGreek_musical_notation}', ""); +Expect(0, 119295, '\p{Is_Block=--ANCIENTGreek_musical_notation}', ""); +Expect(1, 119295, '\p{^Is_Block=--ANCIENTGreek_musical_notation}', ""); +Expect(1, 119295, '\P{Is_Block=--ANCIENTGreek_musical_notation}', ""); +Expect(0, 119295, '\P{^Is_Block=--ANCIENTGreek_musical_notation}', ""); +Error('\p{Is_Blk=-:=Ancient greek Musical notation}'); +Error('\P{Is_Blk=-:=Ancient greek Musical notation}'); +Expect(1, 119375, '\p{Is_Blk: ancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\p{^Is_Blk: ancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\P{Is_Blk: ancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\P{^Is_Blk: ancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\p{Is_Blk: ancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\p{^Is_Blk: ancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\P{Is_Blk: ancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\P{^Is_Blk: ancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\p{Is_Blk= ANCIENT greek MUSICAL-notation}', ""); +Expect(0, 119375, '\p{^Is_Blk= ANCIENT greek MUSICAL-notation}', ""); +Expect(0, 119375, '\P{Is_Blk= ANCIENT greek MUSICAL-notation}', ""); +Expect(1, 119375, '\P{^Is_Blk= ANCIENT greek MUSICAL-notation}', ""); +Expect(0, 119295, '\p{Is_Blk= ANCIENT greek MUSICAL-notation}', ""); +Expect(1, 119295, '\p{^Is_Blk= ANCIENT greek MUSICAL-notation}', ""); +Expect(1, 119295, '\P{Is_Blk= ANCIENT greek MUSICAL-notation}', ""); +Expect(0, 119295, '\P{^Is_Blk= ANCIENT greek MUSICAL-notation}', ""); +Error('\p{Block=/a/-_Phags pa}'); +Error('\P{Block=/a/-_Phags pa}'); +Expect(1, 43135, '\p{Block=phagspa}', ""); +Expect(0, 43135, '\p{^Block=phagspa}', ""); +Expect(0, 43135, '\P{Block=phagspa}', ""); +Expect(1, 43135, '\P{^Block=phagspa}', ""); +Expect(0, 43071, '\p{Block=phagspa}', ""); +Expect(1, 43071, '\p{^Block=phagspa}', ""); +Expect(1, 43071, '\P{Block=phagspa}', ""); +Expect(0, 43071, '\P{^Block=phagspa}', ""); +Expect(1, 43135, '\p{Block=--Phags-Pa}', ""); +Expect(0, 43135, '\p{^Block=--Phags-Pa}', ""); +Expect(0, 43135, '\P{Block=--Phags-Pa}', ""); +Expect(1, 43135, '\P{^Block=--Phags-Pa}', ""); +Expect(0, 43071, '\p{Block=--Phags-Pa}', ""); +Expect(1, 43071, '\p{^Block=--Phags-Pa}', ""); +Expect(1, 43071, '\P{Block=--Phags-Pa}', ""); +Expect(0, 43071, '\P{^Block=--Phags-Pa}', ""); +Error('\p{Blk=/a/_phagsPA}'); +Error('\P{Blk=/a/_phagsPA}'); +Expect(1, 43135, '\p{Blk:phagspa}', ""); +Expect(0, 43135, '\p{^Blk:phagspa}', ""); +Expect(0, 43135, '\P{Blk:phagspa}', ""); +Expect(1, 43135, '\P{^Blk:phagspa}', ""); +Expect(0, 43071, '\p{Blk:phagspa}', ""); +Expect(1, 43071, '\p{^Blk:phagspa}', ""); +Expect(1, 43071, '\P{Blk:phagspa}', ""); +Expect(0, 43071, '\P{^Blk:phagspa}', ""); +Expect(1, 43135, '\p{Blk=_phags-PA}', ""); +Expect(0, 43135, '\p{^Blk=_phags-PA}', ""); +Expect(0, 43135, '\P{Blk=_phags-PA}', ""); +Expect(1, 43135, '\P{^Blk=_phags-PA}', ""); +Expect(0, 43071, '\p{Blk=_phags-PA}', ""); +Expect(1, 43071, '\p{^Blk=_phags-PA}', ""); +Expect(1, 43071, '\P{Blk=_phags-PA}', ""); +Expect(0, 43071, '\P{^Blk=_phags-PA}', ""); +Error('\p{Is_Block=/a/PHAGS Pa}'); +Error('\P{Is_Block=/a/PHAGS Pa}'); +Expect(1, 43135, '\p{Is_Block=phagspa}', ""); +Expect(0, 43135, '\p{^Is_Block=phagspa}', ""); +Expect(0, 43135, '\P{Is_Block=phagspa}', ""); +Expect(1, 43135, '\P{^Is_Block=phagspa}', ""); +Expect(0, 43071, '\p{Is_Block=phagspa}', ""); +Expect(1, 43071, '\p{^Is_Block=phagspa}', ""); +Expect(1, 43071, '\P{Is_Block=phagspa}', ""); +Expect(0, 43071, '\P{^Is_Block=phagspa}', ""); +Expect(1, 43135, '\p{Is_Block=-PHAGS_PA}', ""); +Expect(0, 43135, '\p{^Is_Block=-PHAGS_PA}', ""); +Expect(0, 43135, '\P{Is_Block=-PHAGS_PA}', ""); +Expect(1, 43135, '\P{^Is_Block=-PHAGS_PA}', ""); +Expect(0, 43071, '\p{Is_Block=-PHAGS_PA}', ""); +Expect(1, 43071, '\p{^Is_Block=-PHAGS_PA}', ""); +Expect(1, 43071, '\P{Is_Block=-PHAGS_PA}', ""); +Expect(0, 43071, '\P{^Is_Block=-PHAGS_PA}', ""); +Error('\p{Is_Blk=-/a/PHAGS Pa}'); +Error('\P{Is_Blk=-/a/PHAGS Pa}'); +Expect(1, 43135, '\p{Is_Blk=phagspa}', ""); +Expect(0, 43135, '\p{^Is_Blk=phagspa}', ""); +Expect(0, 43135, '\P{Is_Blk=phagspa}', ""); +Expect(1, 43135, '\P{^Is_Blk=phagspa}', ""); +Expect(0, 43071, '\p{Is_Blk=phagspa}', ""); +Expect(1, 43071, '\p{^Is_Blk=phagspa}', ""); +Expect(1, 43071, '\P{Is_Blk=phagspa}', ""); +Expect(0, 43071, '\P{^Is_Blk=phagspa}', ""); +Expect(1, 43135, '\p{Is_Blk=_-Phags PA}', ""); +Expect(0, 43135, '\p{^Is_Blk=_-Phags PA}', ""); +Expect(0, 43135, '\P{Is_Blk=_-Phags PA}', ""); +Expect(1, 43135, '\P{^Is_Blk=_-Phags PA}', ""); +Expect(0, 43071, '\p{Is_Blk=_-Phags PA}', ""); +Expect(1, 43071, '\p{^Is_Blk=_-Phags PA}', ""); +Expect(1, 43071, '\P{Is_Blk=_-Phags PA}', ""); +Expect(0, 43071, '\P{^Is_Blk=_-Phags PA}', ""); +Error('\p{Block=_ cjk_Compatibility:=ideographs}'); +Error('\P{Block=_ cjk_Compatibility:=ideographs}'); +Expect(1, 64255, '\p{Block=cjkcompatibilityideographs}', ""); +Expect(0, 64255, '\p{^Block=cjkcompatibilityideographs}', ""); +Expect(0, 64255, '\P{Block=cjkcompatibilityideographs}', ""); +Expect(1, 64255, '\P{^Block=cjkcompatibilityideographs}', ""); +Expect(0, 63743, '\p{Block=cjkcompatibilityideographs}', ""); +Expect(1, 63743, '\p{^Block=cjkcompatibilityideographs}', ""); +Expect(1, 63743, '\P{Block=cjkcompatibilityideographs}', ""); +Expect(0, 63743, '\P{^Block=cjkcompatibilityideographs}', ""); +Expect(1, 64255, '\p{Block: -CJK_COMPATIBILITY Ideographs}', ""); +Expect(0, 64255, '\p{^Block: -CJK_COMPATIBILITY Ideographs}', ""); +Expect(0, 64255, '\P{Block: -CJK_COMPATIBILITY Ideographs}', ""); +Expect(1, 64255, '\P{^Block: -CJK_COMPATIBILITY Ideographs}', ""); +Expect(0, 63743, '\p{Block: -CJK_COMPATIBILITY Ideographs}', ""); +Expect(1, 63743, '\p{^Block: -CJK_COMPATIBILITY Ideographs}', ""); +Expect(1, 63743, '\P{Block: -CJK_COMPATIBILITY Ideographs}', ""); +Expect(0, 63743, '\P{^Block: -CJK_COMPATIBILITY Ideographs}', ""); +Error('\p{Blk:-CJK-Compatibility:=IDEOGRAPHS}'); +Error('\P{Blk:-CJK-Compatibility:=IDEOGRAPHS}'); +Expect(1, 64255, '\p{Blk=cjkcompatibilityideographs}', ""); +Expect(0, 64255, '\p{^Blk=cjkcompatibilityideographs}', ""); +Expect(0, 64255, '\P{Blk=cjkcompatibilityideographs}', ""); +Expect(1, 64255, '\P{^Blk=cjkcompatibilityideographs}', ""); +Expect(0, 63743, '\p{Blk=cjkcompatibilityideographs}', ""); +Expect(1, 63743, '\p{^Blk=cjkcompatibilityideographs}', ""); +Expect(1, 63743, '\P{Blk=cjkcompatibilityideographs}', ""); +Expect(0, 63743, '\P{^Blk=cjkcompatibilityideographs}', ""); +Expect(1, 64255, '\p{Blk: - CJK COMPATIBILITY Ideographs}', ""); +Expect(0, 64255, '\p{^Blk: - CJK COMPATIBILITY Ideographs}', ""); +Expect(0, 64255, '\P{Blk: - CJK COMPATIBILITY Ideographs}', ""); +Expect(1, 64255, '\P{^Blk: - CJK COMPATIBILITY Ideographs}', ""); +Expect(0, 63743, '\p{Blk: - CJK COMPATIBILITY Ideographs}', ""); +Expect(1, 63743, '\p{^Blk: - CJK COMPATIBILITY Ideographs}', ""); +Expect(1, 63743, '\P{Blk: - CJK COMPATIBILITY Ideographs}', ""); +Expect(0, 63743, '\P{^Blk: - CJK COMPATIBILITY Ideographs}', ""); +Error('\p{Is_Block: CJK/a/Compatibility IDEOGRAPHS}'); +Error('\P{Is_Block: CJK/a/Compatibility IDEOGRAPHS}'); +Expect(1, 64255, '\p{Is_Block=cjkcompatibilityideographs}', ""); +Expect(0, 64255, '\p{^Is_Block=cjkcompatibilityideographs}', ""); +Expect(0, 64255, '\P{Is_Block=cjkcompatibilityideographs}', ""); +Expect(1, 64255, '\P{^Is_Block=cjkcompatibilityideographs}', ""); +Expect(0, 63743, '\p{Is_Block=cjkcompatibilityideographs}', ""); +Expect(1, 63743, '\p{^Is_Block=cjkcompatibilityideographs}', ""); +Expect(1, 63743, '\P{Is_Block=cjkcompatibilityideographs}', ""); +Expect(0, 63743, '\P{^Is_Block=cjkcompatibilityideographs}', ""); +Expect(1, 64255, '\p{Is_Block= CJK-compatibilityideographs}', ""); +Expect(0, 64255, '\p{^Is_Block= CJK-compatibilityideographs}', ""); +Expect(0, 64255, '\P{Is_Block= CJK-compatibilityideographs}', ""); +Expect(1, 64255, '\P{^Is_Block= CJK-compatibilityideographs}', ""); +Expect(0, 63743, '\p{Is_Block= CJK-compatibilityideographs}', ""); +Expect(1, 63743, '\p{^Is_Block= CJK-compatibilityideographs}', ""); +Expect(1, 63743, '\P{Is_Block= CJK-compatibilityideographs}', ""); +Expect(0, 63743, '\P{^Is_Block= CJK-compatibilityideographs}', ""); +Error('\p{Is_Blk= cjk compatibility Ideographs/a/}'); +Error('\P{Is_Blk= cjk compatibility Ideographs/a/}'); +Expect(1, 64255, '\p{Is_Blk=cjkcompatibilityideographs}', ""); +Expect(0, 64255, '\p{^Is_Blk=cjkcompatibilityideographs}', ""); +Expect(0, 64255, '\P{Is_Blk=cjkcompatibilityideographs}', ""); +Expect(1, 64255, '\P{^Is_Blk=cjkcompatibilityideographs}', ""); +Expect(0, 63743, '\p{Is_Blk=cjkcompatibilityideographs}', ""); +Expect(1, 63743, '\p{^Is_Blk=cjkcompatibilityideographs}', ""); +Expect(1, 63743, '\P{Is_Blk=cjkcompatibilityideographs}', ""); +Expect(0, 63743, '\P{^Is_Blk=cjkcompatibilityideographs}', ""); +Expect(1, 64255, '\p{Is_Blk: -CJK Compatibility-IDEOGRAPHS}', ""); +Expect(0, 64255, '\p{^Is_Blk: -CJK Compatibility-IDEOGRAPHS}', ""); +Expect(0, 64255, '\P{Is_Blk: -CJK Compatibility-IDEOGRAPHS}', ""); +Expect(1, 64255, '\P{^Is_Blk: -CJK Compatibility-IDEOGRAPHS}', ""); +Expect(0, 63743, '\p{Is_Blk: -CJK Compatibility-IDEOGRAPHS}', ""); +Expect(1, 63743, '\p{^Is_Blk: -CJK Compatibility-IDEOGRAPHS}', ""); +Expect(1, 63743, '\P{Is_Blk: -CJK Compatibility-IDEOGRAPHS}', ""); +Expect(0, 63743, '\P{^Is_Blk: -CJK Compatibility-IDEOGRAPHS}', ""); +Error('\p{Block= thaana:=}'); +Error('\P{Block= thaana:=}'); +Expect(1, 1983, '\p{Block: thaana}', ""); +Expect(0, 1983, '\p{^Block: thaana}', ""); +Expect(0, 1983, '\P{Block: thaana}', ""); +Expect(1, 1983, '\P{^Block: thaana}', ""); +Expect(0, 1919, '\p{Block: thaana}', ""); +Expect(1, 1919, '\p{^Block: thaana}', ""); +Expect(1, 1919, '\P{Block: thaana}', ""); +Expect(0, 1919, '\P{^Block: thaana}', ""); +Expect(1, 1983, '\p{Block=_Thaana}', ""); +Expect(0, 1983, '\p{^Block=_Thaana}', ""); +Expect(0, 1983, '\P{Block=_Thaana}', ""); +Expect(1, 1983, '\P{^Block=_Thaana}', ""); +Expect(0, 1919, '\p{Block=_Thaana}', ""); +Expect(1, 1919, '\p{^Block=_Thaana}', ""); +Expect(1, 1919, '\P{Block=_Thaana}', ""); +Expect(0, 1919, '\P{^Block=_Thaana}', ""); +Error('\p{Blk=- THAANA/a/}'); +Error('\P{Blk=- THAANA/a/}'); +Expect(1, 1983, '\p{Blk=thaana}', ""); +Expect(0, 1983, '\p{^Blk=thaana}', ""); +Expect(0, 1983, '\P{Blk=thaana}', ""); +Expect(1, 1983, '\P{^Blk=thaana}', ""); +Expect(0, 1919, '\p{Blk=thaana}', ""); +Expect(1, 1919, '\p{^Blk=thaana}', ""); +Expect(1, 1919, '\P{Blk=thaana}', ""); +Expect(0, 1919, '\P{^Blk=thaana}', ""); +Expect(1, 1983, '\p{Blk=_-thaana}', ""); +Expect(0, 1983, '\p{^Blk=_-thaana}', ""); +Expect(0, 1983, '\P{Blk=_-thaana}', ""); +Expect(1, 1983, '\P{^Blk=_-thaana}', ""); +Expect(0, 1919, '\p{Blk=_-thaana}', ""); +Expect(1, 1919, '\p{^Blk=_-thaana}', ""); +Expect(1, 1919, '\P{Blk=_-thaana}', ""); +Expect(0, 1919, '\P{^Blk=_-thaana}', ""); +Error('\p{Is_Block=thaana/a/}'); +Error('\P{Is_Block=thaana/a/}'); +Expect(1, 1983, '\p{Is_Block: thaana}', ""); +Expect(0, 1983, '\p{^Is_Block: thaana}', ""); +Expect(0, 1983, '\P{Is_Block: thaana}', ""); +Expect(1, 1983, '\P{^Is_Block: thaana}', ""); +Expect(0, 1919, '\p{Is_Block: thaana}', ""); +Expect(1, 1919, '\p{^Is_Block: thaana}', ""); +Expect(1, 1919, '\P{Is_Block: thaana}', ""); +Expect(0, 1919, '\P{^Is_Block: thaana}', ""); +Expect(1, 1983, '\p{Is_Block= thaana}', ""); +Expect(0, 1983, '\p{^Is_Block= thaana}', ""); +Expect(0, 1983, '\P{Is_Block= thaana}', ""); +Expect(1, 1983, '\P{^Is_Block= thaana}', ""); +Expect(0, 1919, '\p{Is_Block= thaana}', ""); +Expect(1, 1919, '\p{^Is_Block= thaana}', ""); +Expect(1, 1919, '\P{Is_Block= thaana}', ""); +Expect(0, 1919, '\P{^Is_Block= thaana}', ""); +Error('\p{Is_Blk=_/a/THAANA}'); +Error('\P{Is_Blk=_/a/THAANA}'); +Expect(1, 1983, '\p{Is_Blk=thaana}', ""); +Expect(0, 1983, '\p{^Is_Blk=thaana}', ""); +Expect(0, 1983, '\P{Is_Blk=thaana}', ""); +Expect(1, 1983, '\P{^Is_Blk=thaana}', ""); +Expect(0, 1919, '\p{Is_Blk=thaana}', ""); +Expect(1, 1919, '\p{^Is_Blk=thaana}', ""); +Expect(1, 1919, '\P{Is_Blk=thaana}', ""); +Expect(0, 1919, '\P{^Is_Blk=thaana}', ""); +Expect(1, 1983, '\p{Is_Blk= thaana}', ""); +Expect(0, 1983, '\p{^Is_Blk= thaana}', ""); +Expect(0, 1983, '\P{Is_Blk= thaana}', ""); +Expect(1, 1983, '\P{^Is_Blk= thaana}', ""); +Expect(0, 1919, '\p{Is_Blk= thaana}', ""); +Expect(1, 1919, '\p{^Is_Blk= thaana}', ""); +Expect(1, 1919, '\P{Is_Blk= thaana}', ""); +Expect(0, 1919, '\P{^Is_Blk= thaana}', ""); +Error('\p{Block= Ethiopic_extended/a/}'); +Error('\P{Block= Ethiopic_extended/a/}'); +Expect(1, 11743, '\p{Block=ethiopicextended}', ""); +Expect(0, 11743, '\p{^Block=ethiopicextended}', ""); +Expect(0, 11743, '\P{Block=ethiopicextended}', ""); +Expect(1, 11743, '\P{^Block=ethiopicextended}', ""); +Expect(0, 11647, '\p{Block=ethiopicextended}', ""); +Expect(1, 11647, '\p{^Block=ethiopicextended}', ""); +Expect(1, 11647, '\P{Block=ethiopicextended}', ""); +Expect(0, 11647, '\P{^Block=ethiopicextended}', ""); +Expect(1, 11743, '\p{Block= Ethiopic Extended}', ""); +Expect(0, 11743, '\p{^Block= Ethiopic Extended}', ""); +Expect(0, 11743, '\P{Block= Ethiopic Extended}', ""); +Expect(1, 11743, '\P{^Block= Ethiopic Extended}', ""); +Expect(0, 11647, '\p{Block= Ethiopic Extended}', ""); +Expect(1, 11647, '\p{^Block= Ethiopic Extended}', ""); +Expect(1, 11647, '\P{Block= Ethiopic Extended}', ""); +Expect(0, 11647, '\P{^Block= Ethiopic Extended}', ""); +Error('\p{Blk=- EthiopicEXTENDED:=}'); +Error('\P{Blk=- EthiopicEXTENDED:=}'); +Expect(1, 11743, '\p{Blk=ethiopicextended}', ""); +Expect(0, 11743, '\p{^Blk=ethiopicextended}', ""); +Expect(0, 11743, '\P{Blk=ethiopicextended}', ""); +Expect(1, 11743, '\P{^Blk=ethiopicextended}', ""); +Expect(0, 11647, '\p{Blk=ethiopicextended}', ""); +Expect(1, 11647, '\p{^Blk=ethiopicextended}', ""); +Expect(1, 11647, '\P{Blk=ethiopicextended}', ""); +Expect(0, 11647, '\P{^Blk=ethiopicextended}', ""); +Expect(1, 11743, '\p{Blk=__Ethiopic EXTENDED}', ""); +Expect(0, 11743, '\p{^Blk=__Ethiopic EXTENDED}', ""); +Expect(0, 11743, '\P{Blk=__Ethiopic EXTENDED}', ""); +Expect(1, 11743, '\P{^Blk=__Ethiopic EXTENDED}', ""); +Expect(0, 11647, '\p{Blk=__Ethiopic EXTENDED}', ""); +Expect(1, 11647, '\p{^Blk=__Ethiopic EXTENDED}', ""); +Expect(1, 11647, '\P{Blk=__Ethiopic EXTENDED}', ""); +Expect(0, 11647, '\P{^Blk=__Ethiopic EXTENDED}', ""); +Error('\p{Is_Block=:= -ethiopic-Extended}'); +Error('\P{Is_Block=:= -ethiopic-Extended}'); +Expect(1, 11743, '\p{Is_Block=ethiopicextended}', ""); +Expect(0, 11743, '\p{^Is_Block=ethiopicextended}', ""); +Expect(0, 11743, '\P{Is_Block=ethiopicextended}', ""); +Expect(1, 11743, '\P{^Is_Block=ethiopicextended}', ""); +Expect(0, 11647, '\p{Is_Block=ethiopicextended}', ""); +Expect(1, 11647, '\p{^Is_Block=ethiopicextended}', ""); +Expect(1, 11647, '\P{Is_Block=ethiopicextended}', ""); +Expect(0, 11647, '\P{^Is_Block=ethiopicextended}', ""); +Expect(1, 11743, '\p{Is_Block: Ethiopic Extended}', ""); +Expect(0, 11743, '\p{^Is_Block: Ethiopic Extended}', ""); +Expect(0, 11743, '\P{Is_Block: Ethiopic Extended}', ""); +Expect(1, 11743, '\P{^Is_Block: Ethiopic Extended}', ""); +Expect(0, 11647, '\p{Is_Block: Ethiopic Extended}', ""); +Expect(1, 11647, '\p{^Is_Block: Ethiopic Extended}', ""); +Expect(1, 11647, '\P{Is_Block: Ethiopic Extended}', ""); +Expect(0, 11647, '\P{^Is_Block: Ethiopic Extended}', ""); +Error('\p{Is_Blk= EthiopicExtended/a/}'); +Error('\P{Is_Blk= EthiopicExtended/a/}'); +Expect(1, 11743, '\p{Is_Blk=ethiopicextended}', ""); +Expect(0, 11743, '\p{^Is_Blk=ethiopicextended}', ""); +Expect(0, 11743, '\P{Is_Blk=ethiopicextended}', ""); +Expect(1, 11743, '\P{^Is_Blk=ethiopicextended}', ""); +Expect(0, 11647, '\p{Is_Blk=ethiopicextended}', ""); +Expect(1, 11647, '\p{^Is_Blk=ethiopicextended}', ""); +Expect(1, 11647, '\P{Is_Blk=ethiopicextended}', ""); +Expect(0, 11647, '\P{^Is_Blk=ethiopicextended}', ""); +Expect(1, 11743, '\p{Is_Blk=_ Ethiopic_extended}', ""); +Expect(0, 11743, '\p{^Is_Blk=_ Ethiopic_extended}', ""); +Expect(0, 11743, '\P{Is_Blk=_ Ethiopic_extended}', ""); +Expect(1, 11743, '\P{^Is_Blk=_ Ethiopic_extended}', ""); +Expect(0, 11647, '\p{Is_Blk=_ Ethiopic_extended}', ""); +Expect(1, 11647, '\p{^Is_Blk=_ Ethiopic_extended}', ""); +Expect(1, 11647, '\P{Is_Blk=_ Ethiopic_extended}', ""); +Expect(0, 11647, '\P{^Is_Blk=_ Ethiopic_extended}', ""); +Error('\p{Block= /a/PHOENICIAN}'); +Error('\P{Block= /a/PHOENICIAN}'); +Expect(1, 67871, '\p{Block=phoenician}', ""); +Expect(0, 67871, '\p{^Block=phoenician}', ""); +Expect(0, 67871, '\P{Block=phoenician}', ""); +Expect(1, 67871, '\P{^Block=phoenician}', ""); +Expect(0, 67839, '\p{Block=phoenician}', ""); +Expect(1, 67839, '\p{^Block=phoenician}', ""); +Expect(1, 67839, '\P{Block=phoenician}', ""); +Expect(0, 67839, '\P{^Block=phoenician}', ""); +Expect(1, 67871, '\p{Block= _Phoenician}', ""); +Expect(0, 67871, '\p{^Block= _Phoenician}', ""); +Expect(0, 67871, '\P{Block= _Phoenician}', ""); +Expect(1, 67871, '\P{^Block= _Phoenician}', ""); +Expect(0, 67839, '\p{Block= _Phoenician}', ""); +Expect(1, 67839, '\p{^Block= _Phoenician}', ""); +Expect(1, 67839, '\P{Block= _Phoenician}', ""); +Expect(0, 67839, '\P{^Block= _Phoenician}', ""); +Error('\p{Blk= :=phoenician}'); +Error('\P{Blk= :=phoenician}'); +Expect(1, 67871, '\p{Blk: phoenician}', ""); +Expect(0, 67871, '\p{^Blk: phoenician}', ""); +Expect(0, 67871, '\P{Blk: phoenician}', ""); +Expect(1, 67871, '\P{^Blk: phoenician}', ""); +Expect(0, 67839, '\p{Blk: phoenician}', ""); +Expect(1, 67839, '\p{^Blk: phoenician}', ""); +Expect(1, 67839, '\P{Blk: phoenician}', ""); +Expect(0, 67839, '\P{^Blk: phoenician}', ""); +Expect(1, 67871, '\p{Blk= _Phoenician}', ""); +Expect(0, 67871, '\p{^Blk= _Phoenician}', ""); +Expect(0, 67871, '\P{Blk= _Phoenician}', ""); +Expect(1, 67871, '\P{^Blk= _Phoenician}', ""); +Expect(0, 67839, '\p{Blk= _Phoenician}', ""); +Expect(1, 67839, '\p{^Blk= _Phoenician}', ""); +Expect(1, 67839, '\P{Blk= _Phoenician}', ""); +Expect(0, 67839, '\P{^Blk= _Phoenician}', ""); +Error('\p{Is_Block= :=PHOENICIAN}'); +Error('\P{Is_Block= :=PHOENICIAN}'); +Expect(1, 67871, '\p{Is_Block=phoenician}', ""); +Expect(0, 67871, '\p{^Is_Block=phoenician}', ""); +Expect(0, 67871, '\P{Is_Block=phoenician}', ""); +Expect(1, 67871, '\P{^Is_Block=phoenician}', ""); +Expect(0, 67839, '\p{Is_Block=phoenician}', ""); +Expect(1, 67839, '\p{^Is_Block=phoenician}', ""); +Expect(1, 67839, '\P{Is_Block=phoenician}', ""); +Expect(0, 67839, '\P{^Is_Block=phoenician}', ""); +Expect(1, 67871, '\p{Is_Block=_-PHOENICIAN}', ""); +Expect(0, 67871, '\p{^Is_Block=_-PHOENICIAN}', ""); +Expect(0, 67871, '\P{Is_Block=_-PHOENICIAN}', ""); +Expect(1, 67871, '\P{^Is_Block=_-PHOENICIAN}', ""); +Expect(0, 67839, '\p{Is_Block=_-PHOENICIAN}', ""); +Expect(1, 67839, '\p{^Is_Block=_-PHOENICIAN}', ""); +Expect(1, 67839, '\P{Is_Block=_-PHOENICIAN}', ""); +Expect(0, 67839, '\P{^Is_Block=_-PHOENICIAN}', ""); +Error('\p{Is_Blk=:= Phoenician}'); +Error('\P{Is_Blk=:= Phoenician}'); +Expect(1, 67871, '\p{Is_Blk: phoenician}', ""); +Expect(0, 67871, '\p{^Is_Blk: phoenician}', ""); +Expect(0, 67871, '\P{Is_Blk: phoenician}', ""); +Expect(1, 67871, '\P{^Is_Blk: phoenician}', ""); +Expect(0, 67839, '\p{Is_Blk: phoenician}', ""); +Expect(1, 67839, '\p{^Is_Blk: phoenician}', ""); +Expect(1, 67839, '\P{Is_Blk: phoenician}', ""); +Expect(0, 67839, '\P{^Is_Blk: phoenician}', ""); +Expect(1, 67871, '\p{Is_Blk: __Phoenician}', ""); +Expect(0, 67871, '\p{^Is_Blk: __Phoenician}', ""); +Expect(0, 67871, '\P{Is_Blk: __Phoenician}', ""); +Expect(1, 67871, '\P{^Is_Blk: __Phoenician}', ""); +Expect(0, 67839, '\p{Is_Blk: __Phoenician}', ""); +Expect(1, 67839, '\p{^Is_Blk: __Phoenician}', ""); +Expect(1, 67839, '\P{Is_Blk: __Phoenician}', ""); +Expect(0, 67839, '\P{^Is_Blk: __Phoenician}', ""); +Error('\p{Block=_:=Latin 1 Supplement}'); +Error('\P{Block=_:=Latin 1 Supplement}'); +Expect(1, 255, '\p{Block=latin1supplement}', ""); +Expect(0, 255, '\p{^Block=latin1supplement}', ""); +Expect(0, 255, '\P{Block=latin1supplement}', ""); +Expect(1, 255, '\P{^Block=latin1supplement}', ""); +Expect(0, 7, '\p{Block=latin1supplement}', ""); +Expect(1, 7, '\p{^Block=latin1supplement}', ""); +Expect(1, 7, '\P{Block=latin1supplement}', ""); +Expect(0, 7, '\P{^Block=latin1supplement}', ""); +Expect(1, 255, '\p{Block: -_latin1Supplement}', ""); +Expect(0, 255, '\p{^Block: -_latin1Supplement}', ""); +Expect(0, 255, '\P{Block: -_latin1Supplement}', ""); +Expect(1, 255, '\P{^Block: -_latin1Supplement}', ""); +Expect(0, 7, '\p{Block: -_latin1Supplement}', ""); +Expect(1, 7, '\p{^Block: -_latin1Supplement}', ""); +Expect(1, 7, '\P{Block: -_latin1Supplement}', ""); +Expect(0, 7, '\P{^Block: -_latin1Supplement}', ""); +Error('\p{Blk=:=LATIN_1}'); +Error('\P{Blk=:=LATIN_1}'); +Expect(1, 255, '\p{Blk=latin1}', ""); +Expect(0, 255, '\p{^Blk=latin1}', ""); +Expect(0, 255, '\P{Blk=latin1}', ""); +Expect(1, 255, '\P{^Blk=latin1}', ""); +Expect(0, 7, '\p{Blk=latin1}', ""); +Expect(1, 7, '\p{^Blk=latin1}', ""); +Expect(1, 7, '\P{Blk=latin1}', ""); +Expect(0, 7, '\P{^Blk=latin1}', ""); +Expect(1, 255, '\p{Blk=_ LATIN1}', ""); +Expect(0, 255, '\p{^Blk=_ LATIN1}', ""); +Expect(0, 255, '\P{Blk=_ LATIN1}', ""); +Expect(1, 255, '\P{^Blk=_ LATIN1}', ""); +Expect(0, 7, '\p{Blk=_ LATIN1}', ""); +Expect(1, 7, '\p{^Blk=_ LATIN1}', ""); +Expect(1, 7, '\P{Blk=_ LATIN1}', ""); +Expect(0, 7, '\P{^Blk=_ LATIN1}', ""); +Error('\p{Is_Block= _LATIN-1-Supplement/a/}'); +Error('\P{Is_Block= _LATIN-1-Supplement/a/}'); +Expect(1, 255, '\p{Is_Block=latin1supplement}', ""); +Expect(0, 255, '\p{^Is_Block=latin1supplement}', ""); +Expect(0, 255, '\P{Is_Block=latin1supplement}', ""); +Expect(1, 255, '\P{^Is_Block=latin1supplement}', ""); +Expect(0, 7, '\p{Is_Block=latin1supplement}', ""); +Expect(1, 7, '\p{^Is_Block=latin1supplement}', ""); +Expect(1, 7, '\P{Is_Block=latin1supplement}', ""); +Expect(0, 7, '\P{^Is_Block=latin1supplement}', ""); +Expect(1, 255, '\p{Is_Block= -Latin-1 SUPPLEMENT}', ""); +Expect(0, 255, '\p{^Is_Block= -Latin-1 SUPPLEMENT}', ""); +Expect(0, 255, '\P{Is_Block= -Latin-1 SUPPLEMENT}', ""); +Expect(1, 255, '\P{^Is_Block= -Latin-1 SUPPLEMENT}', ""); +Expect(0, 7, '\p{Is_Block= -Latin-1 SUPPLEMENT}', ""); +Expect(1, 7, '\p{^Is_Block= -Latin-1 SUPPLEMENT}', ""); +Expect(1, 7, '\P{Is_Block= -Latin-1 SUPPLEMENT}', ""); +Expect(0, 7, '\P{^Is_Block= -Latin-1 SUPPLEMENT}', ""); +Error('\p{Is_Blk=-/a/Latin 1}'); +Error('\P{Is_Blk=-/a/Latin 1}'); +Expect(1, 255, '\p{Is_Blk=latin1}', ""); +Expect(0, 255, '\p{^Is_Blk=latin1}', ""); +Expect(0, 255, '\P{Is_Blk=latin1}', ""); +Expect(1, 255, '\P{^Is_Blk=latin1}', ""); +Expect(0, 7, '\p{Is_Blk=latin1}', ""); +Expect(1, 7, '\p{^Is_Blk=latin1}', ""); +Expect(1, 7, '\P{Is_Blk=latin1}', ""); +Expect(0, 7, '\P{^Is_Blk=latin1}', ""); +Expect(1, 255, '\p{Is_Blk= -Latin-1}', ""); +Expect(0, 255, '\p{^Is_Blk= -Latin-1}', ""); +Expect(0, 255, '\P{Is_Blk= -Latin-1}', ""); +Expect(1, 255, '\P{^Is_Blk= -Latin-1}', ""); +Expect(0, 7, '\p{Is_Blk= -Latin-1}', ""); +Expect(1, 7, '\p{^Is_Blk= -Latin-1}', ""); +Expect(1, 7, '\P{Is_Blk= -Latin-1}', ""); +Expect(0, 7, '\P{^Is_Blk= -Latin-1}', ""); +Error('\p{Block=_ devanagari:=}'); +Error('\P{Block=_ devanagari:=}'); +Expect(1, 2431, '\p{Block=devanagari}', ""); +Expect(0, 2431, '\p{^Block=devanagari}', ""); +Expect(0, 2431, '\P{Block=devanagari}', ""); +Expect(1, 2431, '\P{^Block=devanagari}', ""); +Expect(0, 2303, '\p{Block=devanagari}', ""); +Expect(1, 2303, '\p{^Block=devanagari}', ""); +Expect(1, 2303, '\P{Block=devanagari}', ""); +Expect(0, 2303, '\P{^Block=devanagari}', ""); +Expect(1, 2431, '\p{Block: Devanagari}', ""); +Expect(0, 2431, '\p{^Block: Devanagari}', ""); +Expect(0, 2431, '\P{Block: Devanagari}', ""); +Expect(1, 2431, '\P{^Block: Devanagari}', ""); +Expect(0, 2303, '\p{Block: Devanagari}', ""); +Expect(1, 2303, '\p{^Block: Devanagari}', ""); +Expect(1, 2303, '\P{Block: Devanagari}', ""); +Expect(0, 2303, '\P{^Block: Devanagari}', ""); +Error('\p{Blk= DEVANAGARI:=}'); +Error('\P{Blk= DEVANAGARI:=}'); +Expect(1, 2431, '\p{Blk: devanagari}', ""); +Expect(0, 2431, '\p{^Blk: devanagari}', ""); +Expect(0, 2431, '\P{Blk: devanagari}', ""); +Expect(1, 2431, '\P{^Blk: devanagari}', ""); +Expect(0, 2303, '\p{Blk: devanagari}', ""); +Expect(1, 2303, '\p{^Blk: devanagari}', ""); +Expect(1, 2303, '\P{Blk: devanagari}', ""); +Expect(0, 2303, '\P{^Blk: devanagari}', ""); +Expect(1, 2431, '\p{Blk: _DEVANAGARI}', ""); +Expect(0, 2431, '\p{^Blk: _DEVANAGARI}', ""); +Expect(0, 2431, '\P{Blk: _DEVANAGARI}', ""); +Expect(1, 2431, '\P{^Blk: _DEVANAGARI}', ""); +Expect(0, 2303, '\p{Blk: _DEVANAGARI}', ""); +Expect(1, 2303, '\p{^Blk: _DEVANAGARI}', ""); +Expect(1, 2303, '\P{Blk: _DEVANAGARI}', ""); +Expect(0, 2303, '\P{^Blk: _DEVANAGARI}', ""); +Error('\p{Is_Block= _Devanagari:=}'); +Error('\P{Is_Block= _Devanagari:=}'); +Expect(1, 2431, '\p{Is_Block: devanagari}', ""); +Expect(0, 2431, '\p{^Is_Block: devanagari}', ""); +Expect(0, 2431, '\P{Is_Block: devanagari}', ""); +Expect(1, 2431, '\P{^Is_Block: devanagari}', ""); +Expect(0, 2303, '\p{Is_Block: devanagari}', ""); +Expect(1, 2303, '\p{^Is_Block: devanagari}', ""); +Expect(1, 2303, '\P{Is_Block: devanagari}', ""); +Expect(0, 2303, '\P{^Is_Block: devanagari}', ""); +Expect(1, 2431, '\p{Is_Block= devanagari}', ""); +Expect(0, 2431, '\p{^Is_Block= devanagari}', ""); +Expect(0, 2431, '\P{Is_Block= devanagari}', ""); +Expect(1, 2431, '\P{^Is_Block= devanagari}', ""); +Expect(0, 2303, '\p{Is_Block= devanagari}', ""); +Expect(1, 2303, '\p{^Is_Block= devanagari}', ""); +Expect(1, 2303, '\P{Is_Block= devanagari}', ""); +Expect(0, 2303, '\P{^Is_Block= devanagari}', ""); +Error('\p{Is_Blk=-DEVANAGARI/a/}'); +Error('\P{Is_Blk=-DEVANAGARI/a/}'); +Expect(1, 2431, '\p{Is_Blk=devanagari}', ""); +Expect(0, 2431, '\p{^Is_Blk=devanagari}', ""); +Expect(0, 2431, '\P{Is_Blk=devanagari}', ""); +Expect(1, 2431, '\P{^Is_Blk=devanagari}', ""); +Expect(0, 2303, '\p{Is_Blk=devanagari}', ""); +Expect(1, 2303, '\p{^Is_Blk=devanagari}', ""); +Expect(1, 2303, '\P{Is_Blk=devanagari}', ""); +Expect(0, 2303, '\P{^Is_Blk=devanagari}', ""); +Expect(1, 2431, '\p{Is_Blk=- DEVANAGARI}', ""); +Expect(0, 2431, '\p{^Is_Blk=- DEVANAGARI}', ""); +Expect(0, 2431, '\P{Is_Blk=- DEVANAGARI}', ""); +Expect(1, 2431, '\P{^Is_Blk=- DEVANAGARI}', ""); +Expect(0, 2303, '\p{Is_Blk=- DEVANAGARI}', ""); +Expect(1, 2303, '\p{^Is_Blk=- DEVANAGARI}', ""); +Expect(1, 2303, '\P{Is_Blk=- DEVANAGARI}', ""); +Expect(0, 2303, '\P{^Is_Blk=- DEVANAGARI}', ""); +Error('\p{Block=:= Carian}'); +Error('\P{Block=:= Carian}'); +Expect(1, 66271, '\p{Block=carian}', ""); +Expect(0, 66271, '\p{^Block=carian}', ""); +Expect(0, 66271, '\P{Block=carian}', ""); +Expect(1, 66271, '\P{^Block=carian}', ""); +Expect(0, 66207, '\p{Block=carian}', ""); +Expect(1, 66207, '\p{^Block=carian}', ""); +Expect(1, 66207, '\P{Block=carian}', ""); +Expect(0, 66207, '\P{^Block=carian}', ""); +Expect(1, 66271, '\p{Block=-_Carian}', ""); +Expect(0, 66271, '\p{^Block=-_Carian}', ""); +Expect(0, 66271, '\P{Block=-_Carian}', ""); +Expect(1, 66271, '\P{^Block=-_Carian}', ""); +Expect(0, 66207, '\p{Block=-_Carian}', ""); +Expect(1, 66207, '\p{^Block=-_Carian}', ""); +Expect(1, 66207, '\P{Block=-_Carian}', ""); +Expect(0, 66207, '\P{^Block=-_Carian}', ""); +Error('\p{Blk: /a/_Carian}'); +Error('\P{Blk: /a/_Carian}'); +Expect(1, 66271, '\p{Blk=carian}', ""); +Expect(0, 66271, '\p{^Blk=carian}', ""); +Expect(0, 66271, '\P{Blk=carian}', ""); +Expect(1, 66271, '\P{^Blk=carian}', ""); +Expect(0, 66207, '\p{Blk=carian}', ""); +Expect(1, 66207, '\p{^Blk=carian}', ""); +Expect(1, 66207, '\P{Blk=carian}', ""); +Expect(0, 66207, '\P{^Blk=carian}', ""); +Expect(1, 66271, '\p{Blk: CARIAN}', ""); +Expect(0, 66271, '\p{^Blk: CARIAN}', ""); +Expect(0, 66271, '\P{Blk: CARIAN}', ""); +Expect(1, 66271, '\P{^Blk: CARIAN}', ""); +Expect(0, 66207, '\p{Blk: CARIAN}', ""); +Expect(1, 66207, '\p{^Blk: CARIAN}', ""); +Expect(1, 66207, '\P{Blk: CARIAN}', ""); +Expect(0, 66207, '\P{^Blk: CARIAN}', ""); +Error('\p{Is_Block=:=-carian}'); +Error('\P{Is_Block=:=-carian}'); +Expect(1, 66271, '\p{Is_Block=carian}', ""); +Expect(0, 66271, '\p{^Is_Block=carian}', ""); +Expect(0, 66271, '\P{Is_Block=carian}', ""); +Expect(1, 66271, '\P{^Is_Block=carian}', ""); +Expect(0, 66207, '\p{Is_Block=carian}', ""); +Expect(1, 66207, '\p{^Is_Block=carian}', ""); +Expect(1, 66207, '\P{Is_Block=carian}', ""); +Expect(0, 66207, '\P{^Is_Block=carian}', ""); +Expect(1, 66271, '\p{Is_Block= Carian}', ""); +Expect(0, 66271, '\p{^Is_Block= Carian}', ""); +Expect(0, 66271, '\P{Is_Block= Carian}', ""); +Expect(1, 66271, '\P{^Is_Block= Carian}', ""); +Expect(0, 66207, '\p{Is_Block= Carian}', ""); +Expect(1, 66207, '\p{^Is_Block= Carian}', ""); +Expect(1, 66207, '\P{Is_Block= Carian}', ""); +Expect(0, 66207, '\P{^Is_Block= Carian}', ""); +Error('\p{Is_Blk= -Carian:=}'); +Error('\P{Is_Blk= -Carian:=}'); +Expect(1, 66271, '\p{Is_Blk=carian}', ""); +Expect(0, 66271, '\p{^Is_Blk=carian}', ""); +Expect(0, 66271, '\P{Is_Blk=carian}', ""); +Expect(1, 66271, '\P{^Is_Blk=carian}', ""); +Expect(0, 66207, '\p{Is_Blk=carian}', ""); +Expect(1, 66207, '\p{^Is_Blk=carian}', ""); +Expect(1, 66207, '\P{Is_Blk=carian}', ""); +Expect(0, 66207, '\P{^Is_Blk=carian}', ""); +Expect(1, 66271, '\p{Is_Blk=Carian}', ""); +Expect(0, 66271, '\p{^Is_Blk=Carian}', ""); +Expect(0, 66271, '\P{Is_Blk=Carian}', ""); +Expect(1, 66271, '\P{^Is_Blk=Carian}', ""); +Expect(0, 66207, '\p{Is_Blk=Carian}', ""); +Expect(1, 66207, '\p{^Is_Blk=Carian}', ""); +Expect(1, 66207, '\P{Is_Blk=Carian}', ""); +Expect(0, 66207, '\P{^Is_Blk=Carian}', ""); +Error('\p{Block=/a/ -Buhid}'); +Error('\P{Block=/a/ -Buhid}'); +Expect(1, 5983, '\p{Block=buhid}', ""); +Expect(0, 5983, '\p{^Block=buhid}', ""); +Expect(0, 5983, '\P{Block=buhid}', ""); +Expect(1, 5983, '\P{^Block=buhid}', ""); +Expect(0, 5951, '\p{Block=buhid}', ""); +Expect(1, 5951, '\p{^Block=buhid}', ""); +Expect(1, 5951, '\P{Block=buhid}', ""); +Expect(0, 5951, '\P{^Block=buhid}', ""); +Expect(1, 5983, '\p{Block=- BUHID}', ""); +Expect(0, 5983, '\p{^Block=- BUHID}', ""); +Expect(0, 5983, '\P{Block=- BUHID}', ""); +Expect(1, 5983, '\P{^Block=- BUHID}', ""); +Expect(0, 5951, '\p{Block=- BUHID}', ""); +Expect(1, 5951, '\p{^Block=- BUHID}', ""); +Expect(1, 5951, '\P{Block=- BUHID}', ""); +Expect(0, 5951, '\P{^Block=- BUHID}', ""); +Error('\p{Blk= :=buhid}'); +Error('\P{Blk= :=buhid}'); +Expect(1, 5983, '\p{Blk=buhid}', ""); +Expect(0, 5983, '\p{^Blk=buhid}', ""); +Expect(0, 5983, '\P{Blk=buhid}', ""); +Expect(1, 5983, '\P{^Blk=buhid}', ""); +Expect(0, 5951, '\p{Blk=buhid}', ""); +Expect(1, 5951, '\p{^Blk=buhid}', ""); +Expect(1, 5951, '\P{Blk=buhid}', ""); +Expect(0, 5951, '\P{^Blk=buhid}', ""); +Expect(1, 5983, '\p{Blk: BUHID}', ""); +Expect(0, 5983, '\p{^Blk: BUHID}', ""); +Expect(0, 5983, '\P{Blk: BUHID}', ""); +Expect(1, 5983, '\P{^Blk: BUHID}', ""); +Expect(0, 5951, '\p{Blk: BUHID}', ""); +Expect(1, 5951, '\p{^Blk: BUHID}', ""); +Expect(1, 5951, '\P{Blk: BUHID}', ""); +Expect(0, 5951, '\P{^Blk: BUHID}', ""); +Error('\p{Is_Block= :=Buhid}'); +Error('\P{Is_Block= :=Buhid}'); +Expect(1, 5983, '\p{Is_Block=buhid}', ""); +Expect(0, 5983, '\p{^Is_Block=buhid}', ""); +Expect(0, 5983, '\P{Is_Block=buhid}', ""); +Expect(1, 5983, '\P{^Is_Block=buhid}', ""); +Expect(0, 5951, '\p{Is_Block=buhid}', ""); +Expect(1, 5951, '\p{^Is_Block=buhid}', ""); +Expect(1, 5951, '\P{Is_Block=buhid}', ""); +Expect(0, 5951, '\P{^Is_Block=buhid}', ""); +Expect(1, 5983, '\p{Is_Block= -Buhid}', ""); +Expect(0, 5983, '\p{^Is_Block= -Buhid}', ""); +Expect(0, 5983, '\P{Is_Block= -Buhid}', ""); +Expect(1, 5983, '\P{^Is_Block= -Buhid}', ""); +Expect(0, 5951, '\p{Is_Block= -Buhid}', ""); +Expect(1, 5951, '\p{^Is_Block= -Buhid}', ""); +Expect(1, 5951, '\P{Is_Block= -Buhid}', ""); +Expect(0, 5951, '\P{^Is_Block= -Buhid}', ""); +Error('\p{Is_Blk=- BUHID:=}'); +Error('\P{Is_Blk=- BUHID:=}'); +Expect(1, 5983, '\p{Is_Blk=buhid}', ""); +Expect(0, 5983, '\p{^Is_Blk=buhid}', ""); +Expect(0, 5983, '\P{Is_Blk=buhid}', ""); +Expect(1, 5983, '\P{^Is_Blk=buhid}', ""); +Expect(0, 5951, '\p{Is_Blk=buhid}', ""); +Expect(1, 5951, '\p{^Is_Blk=buhid}', ""); +Expect(1, 5951, '\P{Is_Blk=buhid}', ""); +Expect(0, 5951, '\P{^Is_Blk=buhid}', ""); +Expect(1, 5983, '\p{Is_Blk=- buhid}', ""); +Expect(0, 5983, '\p{^Is_Blk=- buhid}', ""); +Expect(0, 5983, '\P{Is_Blk=- buhid}', ""); +Expect(1, 5983, '\P{^Is_Blk=- buhid}', ""); +Expect(0, 5951, '\p{Is_Blk=- buhid}', ""); +Expect(1, 5951, '\p{^Is_Blk=- buhid}', ""); +Expect(1, 5951, '\P{Is_Blk=- buhid}', ""); +Expect(0, 5951, '\P{^Is_Blk=- buhid}', ""); +Error('\p{Block: _:=ideographic_description CHARACTERS}'); +Error('\P{Block: _:=ideographic_description CHARACTERS}'); +Expect(1, 12287, '\p{Block=ideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\p{^Block=ideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\P{Block=ideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\P{^Block=ideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\p{Block=ideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\p{^Block=ideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\P{Block=ideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\P{^Block=ideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\p{Block=-_IdeographicDescription CHARACTERS}', ""); +Expect(0, 12287, '\p{^Block=-_IdeographicDescription CHARACTERS}', ""); +Expect(0, 12287, '\P{Block=-_IdeographicDescription CHARACTERS}', ""); +Expect(1, 12287, '\P{^Block=-_IdeographicDescription CHARACTERS}', ""); +Expect(0, 12271, '\p{Block=-_IdeographicDescription CHARACTERS}', ""); +Expect(1, 12271, '\p{^Block=-_IdeographicDescription CHARACTERS}', ""); +Expect(1, 12271, '\P{Block=-_IdeographicDescription CHARACTERS}', ""); +Expect(0, 12271, '\P{^Block=-_IdeographicDescription CHARACTERS}', ""); +Error('\p{Blk= Ideographic_Description_characters:=}'); +Error('\P{Blk= Ideographic_Description_characters:=}'); +Expect(1, 12287, '\p{Blk=ideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\p{^Blk=ideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\P{Blk=ideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\P{^Blk=ideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\p{Blk=ideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\p{^Blk=ideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\P{Blk=ideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\P{^Blk=ideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\p{Blk=-IDEOGRAPHIC Description-CHARACTERS}', ""); +Expect(0, 12287, '\p{^Blk=-IDEOGRAPHIC Description-CHARACTERS}', ""); +Expect(0, 12287, '\P{Blk=-IDEOGRAPHIC Description-CHARACTERS}', ""); +Expect(1, 12287, '\P{^Blk=-IDEOGRAPHIC Description-CHARACTERS}', ""); +Expect(0, 12271, '\p{Blk=-IDEOGRAPHIC Description-CHARACTERS}', ""); +Expect(1, 12271, '\p{^Blk=-IDEOGRAPHIC Description-CHARACTERS}', ""); +Expect(1, 12271, '\P{Blk=-IDEOGRAPHIC Description-CHARACTERS}', ""); +Expect(0, 12271, '\P{^Blk=-IDEOGRAPHIC Description-CHARACTERS}', ""); +Error('\p{Is_Block= /a/ideographic_Description Characters}'); +Error('\P{Is_Block= /a/ideographic_Description Characters}'); +Expect(1, 12287, '\p{Is_Block=ideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\p{^Is_Block=ideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\P{Is_Block=ideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\P{^Is_Block=ideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\p{Is_Block=ideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\p{^Is_Block=ideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\P{Is_Block=ideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\P{^Is_Block=ideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\p{Is_Block= Ideographic DESCRIPTION characters}', ""); +Expect(0, 12287, '\p{^Is_Block= Ideographic DESCRIPTION characters}', ""); +Expect(0, 12287, '\P{Is_Block= Ideographic DESCRIPTION characters}', ""); +Expect(1, 12287, '\P{^Is_Block= Ideographic DESCRIPTION characters}', ""); +Expect(0, 12271, '\p{Is_Block= Ideographic DESCRIPTION characters}', ""); +Expect(1, 12271, '\p{^Is_Block= Ideographic DESCRIPTION characters}', ""); +Expect(1, 12271, '\P{Is_Block= Ideographic DESCRIPTION characters}', ""); +Expect(0, 12271, '\P{^Is_Block= Ideographic DESCRIPTION characters}', ""); +Error('\p{Is_Blk= /a/ideographic description Characters}'); +Error('\P{Is_Blk= /a/ideographic description Characters}'); +Expect(1, 12287, '\p{Is_Blk=ideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\p{^Is_Blk=ideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\P{Is_Blk=ideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\P{^Is_Blk=ideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\p{Is_Blk=ideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\p{^Is_Blk=ideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\P{Is_Blk=ideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\P{^Is_Blk=ideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\p{Is_Blk=--Ideographic-description_characters}', ""); +Expect(0, 12287, '\p{^Is_Blk=--Ideographic-description_characters}', ""); +Expect(0, 12287, '\P{Is_Blk=--Ideographic-description_characters}', ""); +Expect(1, 12287, '\P{^Is_Blk=--Ideographic-description_characters}', ""); +Expect(0, 12271, '\p{Is_Blk=--Ideographic-description_characters}', ""); +Expect(1, 12271, '\p{^Is_Blk=--Ideographic-description_characters}', ""); +Expect(1, 12271, '\P{Is_Blk=--Ideographic-description_characters}', ""); +Expect(0, 12271, '\P{^Is_Blk=--Ideographic-description_characters}', ""); +Error('\p{Block: --cjkUnifiedIdeographs-Extension:=B}'); +Error('\P{Block: --cjkUnifiedIdeographs-Extension:=B}'); +Expect(1, 173791, '\p{Block=cjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\p{^Block=cjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\P{Block=cjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\P{^Block=cjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\p{Block=cjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\p{^Block=cjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\P{Block=cjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\P{^Block=cjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\p{Block= _CJK-UnifiedIDEOGRAPHS extension B}', ""); +Expect(0, 173791, '\p{^Block= _CJK-UnifiedIDEOGRAPHS extension B}', ""); +Expect(0, 173791, '\P{Block= _CJK-UnifiedIDEOGRAPHS extension B}', ""); +Expect(1, 173791, '\P{^Block= _CJK-UnifiedIDEOGRAPHS extension B}', ""); +Expect(0, 7, '\p{Block= _CJK-UnifiedIDEOGRAPHS extension B}', ""); +Expect(1, 7, '\p{^Block= _CJK-UnifiedIDEOGRAPHS extension B}', ""); +Expect(1, 7, '\P{Block= _CJK-UnifiedIDEOGRAPHS extension B}', ""); +Expect(0, 7, '\P{^Block= _CJK-UnifiedIDEOGRAPHS extension B}', ""); +Error('\p{Blk=-/a/CJK Unified-Ideographs Extension_b}'); +Error('\P{Blk=-/a/CJK Unified-Ideographs Extension_b}'); +Expect(1, 173791, '\p{Blk: cjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\p{^Blk: cjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\P{Blk: cjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\P{^Blk: cjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\p{Blk: cjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\p{^Blk: cjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\P{Blk: cjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\P{^Blk: cjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\p{Blk=- cjkUnifiedIDEOGRAPHS Extension_B}', ""); +Expect(0, 173791, '\p{^Blk=- cjkUnifiedIDEOGRAPHS Extension_B}', ""); +Expect(0, 173791, '\P{Blk=- cjkUnifiedIDEOGRAPHS Extension_B}', ""); +Expect(1, 173791, '\P{^Blk=- cjkUnifiedIDEOGRAPHS Extension_B}', ""); +Expect(0, 7, '\p{Blk=- cjkUnifiedIDEOGRAPHS Extension_B}', ""); +Expect(1, 7, '\p{^Blk=- cjkUnifiedIDEOGRAPHS Extension_B}', ""); +Expect(1, 7, '\P{Blk=- cjkUnifiedIDEOGRAPHS Extension_B}', ""); +Expect(0, 7, '\P{^Blk=- cjkUnifiedIDEOGRAPHS Extension_B}', ""); +Error('\p{Is_Block=_CJK-Unified-ideographs_extensionB/a/}'); +Error('\P{Is_Block=_CJK-Unified-ideographs_extensionB/a/}'); +Expect(1, 173791, '\p{Is_Block=cjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\p{^Is_Block=cjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\P{Is_Block=cjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\P{^Is_Block=cjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\p{Is_Block=cjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\p{^Is_Block=cjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\P{Is_Block=cjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\P{^Is_Block=cjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\p{Is_Block=_CJK Unified ideographs Extension_B}', ""); +Expect(0, 173791, '\p{^Is_Block=_CJK Unified ideographs Extension_B}', ""); +Expect(0, 173791, '\P{Is_Block=_CJK Unified ideographs Extension_B}', ""); +Expect(1, 173791, '\P{^Is_Block=_CJK Unified ideographs Extension_B}', ""); +Expect(0, 7, '\p{Is_Block=_CJK Unified ideographs Extension_B}', ""); +Expect(1, 7, '\p{^Is_Block=_CJK Unified ideographs Extension_B}', ""); +Expect(1, 7, '\P{Is_Block=_CJK Unified ideographs Extension_B}', ""); +Expect(0, 7, '\P{^Is_Block=_CJK Unified ideographs Extension_B}', ""); +Error('\p{Is_Blk=CJK Unified/a/Ideographs EXTENSION_B}'); +Error('\P{Is_Blk=CJK Unified/a/Ideographs EXTENSION_B}'); +Expect(1, 173791, '\p{Is_Blk=cjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\p{^Is_Blk=cjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\P{Is_Blk=cjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\P{^Is_Blk=cjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\p{Is_Blk=cjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\p{^Is_Blk=cjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\P{Is_Blk=cjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\P{^Is_Blk=cjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\p{Is_Blk=--CJK Unified ideographs ExtensionB}', ""); +Expect(0, 173791, '\p{^Is_Blk=--CJK Unified ideographs ExtensionB}', ""); +Expect(0, 173791, '\P{Is_Blk=--CJK Unified ideographs ExtensionB}', ""); +Expect(1, 173791, '\P{^Is_Blk=--CJK Unified ideographs ExtensionB}', ""); +Expect(0, 7, '\p{Is_Blk=--CJK Unified ideographs ExtensionB}', ""); +Expect(1, 7, '\p{^Is_Blk=--CJK Unified ideographs ExtensionB}', ""); +Expect(1, 7, '\P{Is_Blk=--CJK Unified ideographs ExtensionB}', ""); +Expect(0, 7, '\P{^Is_Blk=--CJK Unified ideographs ExtensionB}', ""); +Error('\p{Block=-:=Old Italic}'); +Error('\P{Block=-:=Old Italic}'); +Expect(1, 66351, '\p{Block=olditalic}', ""); +Expect(0, 66351, '\p{^Block=olditalic}', ""); +Expect(0, 66351, '\P{Block=olditalic}', ""); +Expect(1, 66351, '\P{^Block=olditalic}', ""); +Expect(0, 66303, '\p{Block=olditalic}', ""); +Expect(1, 66303, '\p{^Block=olditalic}', ""); +Expect(1, 66303, '\P{Block=olditalic}', ""); +Expect(0, 66303, '\P{^Block=olditalic}', ""); +Expect(1, 66351, '\p{Block= Old ITALIC}', ""); +Expect(0, 66351, '\p{^Block= Old ITALIC}', ""); +Expect(0, 66351, '\P{Block= Old ITALIC}', ""); +Expect(1, 66351, '\P{^Block= Old ITALIC}', ""); +Expect(0, 66303, '\p{Block= Old ITALIC}', ""); +Expect(1, 66303, '\p{^Block= Old ITALIC}', ""); +Expect(1, 66303, '\P{Block= Old ITALIC}', ""); +Expect(0, 66303, '\P{^Block= Old ITALIC}', ""); +Error('\p{Blk=__Old-ITALIC:=}'); +Error('\P{Blk=__Old-ITALIC:=}'); +Expect(1, 66351, '\p{Blk=olditalic}', ""); +Expect(0, 66351, '\p{^Blk=olditalic}', ""); +Expect(0, 66351, '\P{Blk=olditalic}', ""); +Expect(1, 66351, '\P{^Blk=olditalic}', ""); +Expect(0, 66303, '\p{Blk=olditalic}', ""); +Expect(1, 66303, '\p{^Blk=olditalic}', ""); +Expect(1, 66303, '\P{Blk=olditalic}', ""); +Expect(0, 66303, '\P{^Blk=olditalic}', ""); +Expect(1, 66351, '\p{Blk= Old-Italic}', ""); +Expect(0, 66351, '\p{^Blk= Old-Italic}', ""); +Expect(0, 66351, '\P{Blk= Old-Italic}', ""); +Expect(1, 66351, '\P{^Blk= Old-Italic}', ""); +Expect(0, 66303, '\p{Blk= Old-Italic}', ""); +Expect(1, 66303, '\p{^Blk= Old-Italic}', ""); +Expect(1, 66303, '\P{Blk= Old-Italic}', ""); +Expect(0, 66303, '\P{^Blk= Old-Italic}', ""); +Error('\p{Is_Block: old/a/italic}'); +Error('\P{Is_Block: old/a/italic}'); +Expect(1, 66351, '\p{Is_Block=olditalic}', ""); +Expect(0, 66351, '\p{^Is_Block=olditalic}', ""); +Expect(0, 66351, '\P{Is_Block=olditalic}', ""); +Expect(1, 66351, '\P{^Is_Block=olditalic}', ""); +Expect(0, 66303, '\p{Is_Block=olditalic}', ""); +Expect(1, 66303, '\p{^Is_Block=olditalic}', ""); +Expect(1, 66303, '\P{Is_Block=olditalic}', ""); +Expect(0, 66303, '\P{^Is_Block=olditalic}', ""); +Expect(1, 66351, '\p{Is_Block= -Old Italic}', ""); +Expect(0, 66351, '\p{^Is_Block= -Old Italic}', ""); +Expect(0, 66351, '\P{Is_Block= -Old Italic}', ""); +Expect(1, 66351, '\P{^Is_Block= -Old Italic}', ""); +Expect(0, 66303, '\p{Is_Block= -Old Italic}', ""); +Expect(1, 66303, '\p{^Is_Block= -Old Italic}', ""); +Expect(1, 66303, '\P{Is_Block= -Old Italic}', ""); +Expect(0, 66303, '\P{^Is_Block= -Old Italic}', ""); +Error('\p{Is_Blk=-/a/old Italic}'); +Error('\P{Is_Blk=-/a/old Italic}'); +Expect(1, 66351, '\p{Is_Blk=olditalic}', ""); +Expect(0, 66351, '\p{^Is_Blk=olditalic}', ""); +Expect(0, 66351, '\P{Is_Blk=olditalic}', ""); +Expect(1, 66351, '\P{^Is_Blk=olditalic}', ""); +Expect(0, 66303, '\p{Is_Blk=olditalic}', ""); +Expect(1, 66303, '\p{^Is_Blk=olditalic}', ""); +Expect(1, 66303, '\P{Is_Blk=olditalic}', ""); +Expect(0, 66303, '\P{^Is_Blk=olditalic}', ""); +Expect(1, 66351, '\p{Is_Blk= old Italic}', ""); +Expect(0, 66351, '\p{^Is_Blk= old Italic}', ""); +Expect(0, 66351, '\P{Is_Blk= old Italic}', ""); +Expect(1, 66351, '\P{^Is_Blk= old Italic}', ""); +Expect(0, 66303, '\p{Is_Blk= old Italic}', ""); +Expect(1, 66303, '\p{^Is_Blk= old Italic}', ""); +Expect(1, 66303, '\P{Is_Blk= old Italic}', ""); +Expect(0, 66303, '\P{^Is_Blk= old Italic}', ""); +Error('\p{Block=-:=Hangul Syllables}'); +Error('\P{Block=-:=Hangul Syllables}'); +Expect(1, 55215, '\p{Block=hangulsyllables}', ""); +Expect(0, 55215, '\p{^Block=hangulsyllables}', ""); +Expect(0, 55215, '\P{Block=hangulsyllables}', ""); +Expect(1, 55215, '\P{^Block=hangulsyllables}', ""); +Expect(0, 44031, '\p{Block=hangulsyllables}', ""); +Expect(1, 44031, '\p{^Block=hangulsyllables}', ""); +Expect(1, 44031, '\P{Block=hangulsyllables}', ""); +Expect(0, 44031, '\P{^Block=hangulsyllables}', ""); +Expect(1, 55215, '\p{Block:- Hangul Syllables}', ""); +Expect(0, 55215, '\p{^Block:- Hangul Syllables}', ""); +Expect(0, 55215, '\P{Block:- Hangul Syllables}', ""); +Expect(1, 55215, '\P{^Block:- Hangul Syllables}', ""); +Expect(0, 44031, '\p{Block:- Hangul Syllables}', ""); +Expect(1, 44031, '\p{^Block:- Hangul Syllables}', ""); +Expect(1, 44031, '\P{Block:- Hangul Syllables}', ""); +Expect(0, 44031, '\P{^Block:- Hangul Syllables}', ""); +Error('\p{Blk=_:=Hangul Syllables}'); +Error('\P{Blk=_:=Hangul Syllables}'); +Expect(1, 55215, '\p{Blk=hangulsyllables}', ""); +Expect(0, 55215, '\p{^Blk=hangulsyllables}', ""); +Expect(0, 55215, '\P{Blk=hangulsyllables}', ""); +Expect(1, 55215, '\P{^Blk=hangulsyllables}', ""); +Expect(0, 44031, '\p{Blk=hangulsyllables}', ""); +Expect(1, 44031, '\p{^Blk=hangulsyllables}', ""); +Expect(1, 44031, '\P{Blk=hangulsyllables}', ""); +Expect(0, 44031, '\P{^Blk=hangulsyllables}', ""); +Expect(1, 55215, '\p{Blk=_ Hangul-Syllables}', ""); +Expect(0, 55215, '\p{^Blk=_ Hangul-Syllables}', ""); +Expect(0, 55215, '\P{Blk=_ Hangul-Syllables}', ""); +Expect(1, 55215, '\P{^Blk=_ Hangul-Syllables}', ""); +Expect(0, 44031, '\p{Blk=_ Hangul-Syllables}', ""); +Expect(1, 44031, '\p{^Blk=_ Hangul-Syllables}', ""); +Expect(1, 44031, '\P{Blk=_ Hangul-Syllables}', ""); +Expect(0, 44031, '\P{^Blk=_ Hangul-Syllables}', ""); +Error('\p{Is_Block=-:=Hangul_Syllables}'); +Error('\P{Is_Block=-:=Hangul_Syllables}'); +Expect(1, 55215, '\p{Is_Block=hangulsyllables}', ""); +Expect(0, 55215, '\p{^Is_Block=hangulsyllables}', ""); +Expect(0, 55215, '\P{Is_Block=hangulsyllables}', ""); +Expect(1, 55215, '\P{^Is_Block=hangulsyllables}', ""); +Expect(0, 44031, '\p{Is_Block=hangulsyllables}', ""); +Expect(1, 44031, '\p{^Is_Block=hangulsyllables}', ""); +Expect(1, 44031, '\P{Is_Block=hangulsyllables}', ""); +Expect(0, 44031, '\P{^Is_Block=hangulsyllables}', ""); +Expect(1, 55215, '\p{Is_Block=_-HANGUL Syllables}', ""); +Expect(0, 55215, '\p{^Is_Block=_-HANGUL Syllables}', ""); +Expect(0, 55215, '\P{Is_Block=_-HANGUL Syllables}', ""); +Expect(1, 55215, '\P{^Is_Block=_-HANGUL Syllables}', ""); +Expect(0, 44031, '\p{Is_Block=_-HANGUL Syllables}', ""); +Expect(1, 44031, '\p{^Is_Block=_-HANGUL Syllables}', ""); +Expect(1, 44031, '\P{Is_Block=_-HANGUL Syllables}', ""); +Expect(0, 44031, '\P{^Is_Block=_-HANGUL Syllables}', ""); +Error('\p{Is_Blk=:=- Hangul_Syllables}'); +Error('\P{Is_Blk=:=- Hangul_Syllables}'); +Expect(1, 55215, '\p{Is_Blk=hangulsyllables}', ""); +Expect(0, 55215, '\p{^Is_Blk=hangulsyllables}', ""); +Expect(0, 55215, '\P{Is_Blk=hangulsyllables}', ""); +Expect(1, 55215, '\P{^Is_Blk=hangulsyllables}', ""); +Expect(0, 44031, '\p{Is_Blk=hangulsyllables}', ""); +Expect(1, 44031, '\p{^Is_Blk=hangulsyllables}', ""); +Expect(1, 44031, '\P{Is_Blk=hangulsyllables}', ""); +Expect(0, 44031, '\P{^Is_Blk=hangulsyllables}', ""); +Expect(1, 55215, '\p{Is_Blk=_hangul_Syllables}', ""); +Expect(0, 55215, '\p{^Is_Blk=_hangul_Syllables}', ""); +Expect(0, 55215, '\P{Is_Blk=_hangul_Syllables}', ""); +Expect(1, 55215, '\P{^Is_Blk=_hangul_Syllables}', ""); +Expect(0, 44031, '\p{Is_Blk=_hangul_Syllables}', ""); +Expect(1, 44031, '\p{^Is_Blk=_hangul_Syllables}', ""); +Expect(1, 44031, '\P{Is_Blk=_hangul_Syllables}', ""); +Expect(0, 44031, '\P{^Is_Blk=_hangul_Syllables}', ""); +Error('\p{Block=_:=Yijing Hexagram SYMBOLS}'); +Error('\P{Block=_:=Yijing Hexagram SYMBOLS}'); +Expect(1, 19967, '\p{Block=yijinghexagramsymbols}', ""); +Expect(0, 19967, '\p{^Block=yijinghexagramsymbols}', ""); +Expect(0, 19967, '\P{Block=yijinghexagramsymbols}', ""); +Expect(1, 19967, '\P{^Block=yijinghexagramsymbols}', ""); +Expect(0, 19903, '\p{Block=yijinghexagramsymbols}', ""); +Expect(1, 19903, '\p{^Block=yijinghexagramsymbols}', ""); +Expect(1, 19903, '\P{Block=yijinghexagramsymbols}', ""); +Expect(0, 19903, '\P{^Block=yijinghexagramsymbols}', ""); +Expect(1, 19967, '\p{Block= YijingHexagram Symbols}', ""); +Expect(0, 19967, '\p{^Block= YijingHexagram Symbols}', ""); +Expect(0, 19967, '\P{Block= YijingHexagram Symbols}', ""); +Expect(1, 19967, '\P{^Block= YijingHexagram Symbols}', ""); +Expect(0, 19903, '\p{Block= YijingHexagram Symbols}', ""); +Expect(1, 19903, '\p{^Block= YijingHexagram Symbols}', ""); +Expect(1, 19903, '\P{Block= YijingHexagram Symbols}', ""); +Expect(0, 19903, '\P{^Block= YijingHexagram Symbols}', ""); +Error('\p{Blk=:= _yijing-hexagramSymbols}'); +Error('\P{Blk=:= _yijing-hexagramSymbols}'); +Expect(1, 19967, '\p{Blk=yijinghexagramsymbols}', ""); +Expect(0, 19967, '\p{^Blk=yijinghexagramsymbols}', ""); +Expect(0, 19967, '\P{Blk=yijinghexagramsymbols}', ""); +Expect(1, 19967, '\P{^Blk=yijinghexagramsymbols}', ""); +Expect(0, 19903, '\p{Blk=yijinghexagramsymbols}', ""); +Expect(1, 19903, '\p{^Blk=yijinghexagramsymbols}', ""); +Expect(1, 19903, '\P{Blk=yijinghexagramsymbols}', ""); +Expect(0, 19903, '\P{^Blk=yijinghexagramsymbols}', ""); +Expect(1, 19967, '\p{Blk=_yijing_Hexagram_Symbols}', ""); +Expect(0, 19967, '\p{^Blk=_yijing_Hexagram_Symbols}', ""); +Expect(0, 19967, '\P{Blk=_yijing_Hexagram_Symbols}', ""); +Expect(1, 19967, '\P{^Blk=_yijing_Hexagram_Symbols}', ""); +Expect(0, 19903, '\p{Blk=_yijing_Hexagram_Symbols}', ""); +Expect(1, 19903, '\p{^Blk=_yijing_Hexagram_Symbols}', ""); +Expect(1, 19903, '\P{Blk=_yijing_Hexagram_Symbols}', ""); +Expect(0, 19903, '\P{^Blk=_yijing_Hexagram_Symbols}', ""); +Error('\p{Is_Block= _YIJINGHexagram:=symbols}'); +Error('\P{Is_Block= _YIJINGHexagram:=symbols}'); +Expect(1, 19967, '\p{Is_Block: yijinghexagramsymbols}', ""); +Expect(0, 19967, '\p{^Is_Block: yijinghexagramsymbols}', ""); +Expect(0, 19967, '\P{Is_Block: yijinghexagramsymbols}', ""); +Expect(1, 19967, '\P{^Is_Block: yijinghexagramsymbols}', ""); +Expect(0, 19903, '\p{Is_Block: yijinghexagramsymbols}', ""); +Expect(1, 19903, '\p{^Is_Block: yijinghexagramsymbols}', ""); +Expect(1, 19903, '\P{Is_Block: yijinghexagramsymbols}', ""); +Expect(0, 19903, '\P{^Is_Block: yijinghexagramsymbols}', ""); +Expect(1, 19967, '\p{Is_Block= Yijing hexagram-Symbols}', ""); +Expect(0, 19967, '\p{^Is_Block= Yijing hexagram-Symbols}', ""); +Expect(0, 19967, '\P{Is_Block= Yijing hexagram-Symbols}', ""); +Expect(1, 19967, '\P{^Is_Block= Yijing hexagram-Symbols}', ""); +Expect(0, 19903, '\p{Is_Block= Yijing hexagram-Symbols}', ""); +Expect(1, 19903, '\p{^Is_Block= Yijing hexagram-Symbols}', ""); +Expect(1, 19903, '\P{Is_Block= Yijing hexagram-Symbols}', ""); +Expect(0, 19903, '\P{^Is_Block= Yijing hexagram-Symbols}', ""); +Error('\p{Is_Blk=:=Yijing_HEXAGRAMSymbols}'); +Error('\P{Is_Blk=:=Yijing_HEXAGRAMSymbols}'); +Expect(1, 19967, '\p{Is_Blk: yijinghexagramsymbols}', ""); +Expect(0, 19967, '\p{^Is_Blk: yijinghexagramsymbols}', ""); +Expect(0, 19967, '\P{Is_Blk: yijinghexagramsymbols}', ""); +Expect(1, 19967, '\P{^Is_Blk: yijinghexagramsymbols}', ""); +Expect(0, 19903, '\p{Is_Blk: yijinghexagramsymbols}', ""); +Expect(1, 19903, '\p{^Is_Blk: yijinghexagramsymbols}', ""); +Expect(1, 19903, '\P{Is_Blk: yijinghexagramsymbols}', ""); +Expect(0, 19903, '\P{^Is_Blk: yijinghexagramsymbols}', ""); +Expect(1, 19967, '\p{Is_Blk= _Yijing_Hexagram Symbols}', ""); +Expect(0, 19967, '\p{^Is_Blk= _Yijing_Hexagram Symbols}', ""); +Expect(0, 19967, '\P{Is_Blk= _Yijing_Hexagram Symbols}', ""); +Expect(1, 19967, '\P{^Is_Blk= _Yijing_Hexagram Symbols}', ""); +Expect(0, 19903, '\p{Is_Blk= _Yijing_Hexagram Symbols}', ""); +Expect(1, 19903, '\p{^Is_Blk= _Yijing_Hexagram Symbols}', ""); +Expect(1, 19903, '\P{Is_Blk= _Yijing_Hexagram Symbols}', ""); +Expect(0, 19903, '\P{^Is_Blk= _Yijing_Hexagram Symbols}', ""); +Error('\p{Block=/a/ -PHAISTOS-Disc}'); +Error('\P{Block=/a/ -PHAISTOS-Disc}'); +Expect(1, 66047, '\p{Block=phaistosdisc}', ""); +Expect(0, 66047, '\p{^Block=phaistosdisc}', ""); +Expect(0, 66047, '\P{Block=phaistosdisc}', ""); +Expect(1, 66047, '\P{^Block=phaistosdisc}', ""); +Expect(0, 65999, '\p{Block=phaistosdisc}', ""); +Expect(1, 65999, '\p{^Block=phaistosdisc}', ""); +Expect(1, 65999, '\P{Block=phaistosdisc}', ""); +Expect(0, 65999, '\P{^Block=phaistosdisc}', ""); +Expect(1, 66047, '\p{Block=-phaistos_DISC}', ""); +Expect(0, 66047, '\p{^Block=-phaistos_DISC}', ""); +Expect(0, 66047, '\P{Block=-phaistos_DISC}', ""); +Expect(1, 66047, '\P{^Block=-phaistos_DISC}', ""); +Expect(0, 65999, '\p{Block=-phaistos_DISC}', ""); +Expect(1, 65999, '\p{^Block=-phaistos_DISC}', ""); +Expect(1, 65999, '\P{Block=-phaistos_DISC}', ""); +Expect(0, 65999, '\P{^Block=-phaistos_DISC}', ""); +Error('\p{Blk=-:=Phaistos_Disc}'); +Error('\P{Blk=-:=Phaistos_Disc}'); +Expect(1, 66047, '\p{Blk=phaistosdisc}', ""); +Expect(0, 66047, '\p{^Blk=phaistosdisc}', ""); +Expect(0, 66047, '\P{Blk=phaistosdisc}', ""); +Expect(1, 66047, '\P{^Blk=phaistosdisc}', ""); +Expect(0, 65999, '\p{Blk=phaistosdisc}', ""); +Expect(1, 65999, '\p{^Blk=phaistosdisc}', ""); +Expect(1, 65999, '\P{Blk=phaistosdisc}', ""); +Expect(0, 65999, '\P{^Blk=phaistosdisc}', ""); +Expect(1, 66047, '\p{Blk=--PHAISTOS Disc}', ""); +Expect(0, 66047, '\p{^Blk=--PHAISTOS Disc}', ""); +Expect(0, 66047, '\P{Blk=--PHAISTOS Disc}', ""); +Expect(1, 66047, '\P{^Blk=--PHAISTOS Disc}', ""); +Expect(0, 65999, '\p{Blk=--PHAISTOS Disc}', ""); +Expect(1, 65999, '\p{^Blk=--PHAISTOS Disc}', ""); +Expect(1, 65999, '\P{Blk=--PHAISTOS Disc}', ""); +Expect(0, 65999, '\P{^Blk=--PHAISTOS Disc}', ""); +Error('\p{Is_Block= /a/PHAISTOS disc}'); +Error('\P{Is_Block= /a/PHAISTOS disc}'); +Expect(1, 66047, '\p{Is_Block=phaistosdisc}', ""); +Expect(0, 66047, '\p{^Is_Block=phaistosdisc}', ""); +Expect(0, 66047, '\P{Is_Block=phaistosdisc}', ""); +Expect(1, 66047, '\P{^Is_Block=phaistosdisc}', ""); +Expect(0, 65999, '\p{Is_Block=phaistosdisc}', ""); +Expect(1, 65999, '\p{^Is_Block=phaistosdisc}', ""); +Expect(1, 65999, '\P{Is_Block=phaistosdisc}', ""); +Expect(0, 65999, '\P{^Is_Block=phaistosdisc}', ""); +Expect(1, 66047, '\p{Is_Block=-phaistos-disc}', ""); +Expect(0, 66047, '\p{^Is_Block=-phaistos-disc}', ""); +Expect(0, 66047, '\P{Is_Block=-phaistos-disc}', ""); +Expect(1, 66047, '\P{^Is_Block=-phaistos-disc}', ""); +Expect(0, 65999, '\p{Is_Block=-phaistos-disc}', ""); +Expect(1, 65999, '\p{^Is_Block=-phaistos-disc}', ""); +Expect(1, 65999, '\P{Is_Block=-phaistos-disc}', ""); +Expect(0, 65999, '\P{^Is_Block=-phaistos-disc}', ""); +Error('\p{Is_Blk= _PHAISTOS disc:=}'); +Error('\P{Is_Blk= _PHAISTOS disc:=}'); +Expect(1, 66047, '\p{Is_Blk=phaistosdisc}', ""); +Expect(0, 66047, '\p{^Is_Blk=phaistosdisc}', ""); +Expect(0, 66047, '\P{Is_Blk=phaistosdisc}', ""); +Expect(1, 66047, '\P{^Is_Blk=phaistosdisc}', ""); +Expect(0, 65999, '\p{Is_Blk=phaistosdisc}', ""); +Expect(1, 65999, '\p{^Is_Blk=phaistosdisc}', ""); +Expect(1, 65999, '\P{Is_Blk=phaistosdisc}', ""); +Expect(0, 65999, '\P{^Is_Blk=phaistosdisc}', ""); +Expect(1, 66047, '\p{Is_Blk= PhaistosDISC}', ""); +Expect(0, 66047, '\p{^Is_Blk= PhaistosDISC}', ""); +Expect(0, 66047, '\P{Is_Blk= PhaistosDISC}', ""); +Expect(1, 66047, '\P{^Is_Blk= PhaistosDISC}', ""); +Expect(0, 65999, '\p{Is_Blk= PhaistosDISC}', ""); +Expect(1, 65999, '\p{^Is_Blk= PhaistosDISC}', ""); +Expect(1, 65999, '\P{Is_Blk= PhaistosDISC}', ""); +Expect(0, 65999, '\P{^Is_Blk= PhaistosDISC}', ""); +Error('\p{Block=/a/ SMALL formvariants}'); +Error('\P{Block=/a/ SMALL formvariants}'); +Expect(1, 65135, '\p{Block=smallformvariants}', ""); +Expect(0, 65135, '\p{^Block=smallformvariants}', ""); +Expect(0, 65135, '\P{Block=smallformvariants}', ""); +Expect(1, 65135, '\P{^Block=smallformvariants}', ""); +Expect(0, 65103, '\p{Block=smallformvariants}', ""); +Expect(1, 65103, '\p{^Block=smallformvariants}', ""); +Expect(1, 65103, '\P{Block=smallformvariants}', ""); +Expect(0, 65103, '\P{^Block=smallformvariants}', ""); +Expect(1, 65135, '\p{Block= Small FormVariants}', ""); +Expect(0, 65135, '\p{^Block= Small FormVariants}', ""); +Expect(0, 65135, '\P{Block= Small FormVariants}', ""); +Expect(1, 65135, '\P{^Block= Small FormVariants}', ""); +Expect(0, 65103, '\p{Block= Small FormVariants}', ""); +Expect(1, 65103, '\p{^Block= Small FormVariants}', ""); +Expect(1, 65103, '\P{Block= Small FormVariants}', ""); +Expect(0, 65103, '\P{^Block= Small FormVariants}', ""); +Error('\p{Blk=- SMALLForm/a/variants}'); +Error('\P{Blk=- SMALLForm/a/variants}'); +Expect(1, 65135, '\p{Blk=smallformvariants}', ""); +Expect(0, 65135, '\p{^Blk=smallformvariants}', ""); +Expect(0, 65135, '\P{Blk=smallformvariants}', ""); +Expect(1, 65135, '\P{^Blk=smallformvariants}', ""); +Expect(0, 65103, '\p{Blk=smallformvariants}', ""); +Expect(1, 65103, '\p{^Blk=smallformvariants}', ""); +Expect(1, 65103, '\P{Blk=smallformvariants}', ""); +Expect(0, 65103, '\P{^Blk=smallformvariants}', ""); +Expect(1, 65135, '\p{Blk= -Small Form Variants}', ""); +Expect(0, 65135, '\p{^Blk= -Small Form Variants}', ""); +Expect(0, 65135, '\P{Blk= -Small Form Variants}', ""); +Expect(1, 65135, '\P{^Blk= -Small Form Variants}', ""); +Expect(0, 65103, '\p{Blk= -Small Form Variants}', ""); +Expect(1, 65103, '\p{^Blk= -Small Form Variants}', ""); +Expect(1, 65103, '\P{Blk= -Small Form Variants}', ""); +Expect(0, 65103, '\P{^Blk= -Small Form Variants}', ""); +Error('\p{Is_Block= Small_form/a/variants}'); +Error('\P{Is_Block= Small_form/a/variants}'); +Expect(1, 65135, '\p{Is_Block=smallformvariants}', ""); +Expect(0, 65135, '\p{^Is_Block=smallformvariants}', ""); +Expect(0, 65135, '\P{Is_Block=smallformvariants}', ""); +Expect(1, 65135, '\P{^Is_Block=smallformvariants}', ""); +Expect(0, 65103, '\p{Is_Block=smallformvariants}', ""); +Expect(1, 65103, '\p{^Is_Block=smallformvariants}', ""); +Expect(1, 65103, '\P{Is_Block=smallformvariants}', ""); +Expect(0, 65103, '\P{^Is_Block=smallformvariants}', ""); +Expect(1, 65135, '\p{Is_Block= small-form_Variants}', ""); +Expect(0, 65135, '\p{^Is_Block= small-form_Variants}', ""); +Expect(0, 65135, '\P{Is_Block= small-form_Variants}', ""); +Expect(1, 65135, '\P{^Is_Block= small-form_Variants}', ""); +Expect(0, 65103, '\p{Is_Block= small-form_Variants}', ""); +Expect(1, 65103, '\p{^Is_Block= small-form_Variants}', ""); +Expect(1, 65103, '\P{Is_Block= small-form_Variants}', ""); +Expect(0, 65103, '\P{^Is_Block= small-form_Variants}', ""); +Error('\p{Is_Blk= Small/a/Form Variants}'); +Error('\P{Is_Blk= Small/a/Form Variants}'); +Expect(1, 65135, '\p{Is_Blk=smallformvariants}', ""); +Expect(0, 65135, '\p{^Is_Blk=smallformvariants}', ""); +Expect(0, 65135, '\P{Is_Blk=smallformvariants}', ""); +Expect(1, 65135, '\P{^Is_Blk=smallformvariants}', ""); +Expect(0, 65103, '\p{Is_Blk=smallformvariants}', ""); +Expect(1, 65103, '\p{^Is_Blk=smallformvariants}', ""); +Expect(1, 65103, '\P{Is_Blk=smallformvariants}', ""); +Expect(0, 65103, '\P{^Is_Blk=smallformvariants}', ""); +Expect(1, 65135, '\p{Is_Blk= small Formvariants}', ""); +Expect(0, 65135, '\p{^Is_Blk= small Formvariants}', ""); +Expect(0, 65135, '\P{Is_Blk= small Formvariants}', ""); +Expect(1, 65135, '\P{^Is_Blk= small Formvariants}', ""); +Expect(0, 65103, '\p{Is_Blk= small Formvariants}', ""); +Expect(1, 65103, '\p{^Is_Blk= small Formvariants}', ""); +Expect(1, 65103, '\P{Is_Blk= small Formvariants}', ""); +Expect(0, 65103, '\P{^Is_Blk= small Formvariants}', ""); +Error('\p{Block= /a/Latin extended d}'); +Error('\P{Block= /a/Latin extended d}'); +Expect(1, 43007, '\p{Block=latinextendedd}', ""); +Expect(0, 43007, '\p{^Block=latinextendedd}', ""); +Expect(0, 43007, '\P{Block=latinextendedd}', ""); +Expect(1, 43007, '\P{^Block=latinextendedd}', ""); +Expect(0, 42783, '\p{Block=latinextendedd}', ""); +Expect(1, 42783, '\p{^Block=latinextendedd}', ""); +Expect(1, 42783, '\P{Block=latinextendedd}', ""); +Expect(0, 42783, '\P{^Block=latinextendedd}', ""); +Expect(1, 43007, '\p{Block= _latinExtended-D}', ""); +Expect(0, 43007, '\p{^Block= _latinExtended-D}', ""); +Expect(0, 43007, '\P{Block= _latinExtended-D}', ""); +Expect(1, 43007, '\P{^Block= _latinExtended-D}', ""); +Expect(0, 42783, '\p{Block= _latinExtended-D}', ""); +Expect(1, 42783, '\p{^Block= _latinExtended-D}', ""); +Expect(1, 42783, '\P{Block= _latinExtended-D}', ""); +Expect(0, 42783, '\P{^Block= _latinExtended-D}', ""); +Error('\p{Blk: /a/latin-Extended D}'); +Error('\P{Blk: /a/latin-Extended D}'); +Expect(1, 43007, '\p{Blk=latinextendedd}', ""); +Expect(0, 43007, '\p{^Blk=latinextendedd}', ""); +Expect(0, 43007, '\P{Blk=latinextendedd}', ""); +Expect(1, 43007, '\P{^Blk=latinextendedd}', ""); +Expect(0, 42783, '\p{Blk=latinextendedd}', ""); +Expect(1, 42783, '\p{^Blk=latinextendedd}', ""); +Expect(1, 42783, '\P{Blk=latinextendedd}', ""); +Expect(0, 42783, '\P{^Blk=latinextendedd}', ""); +Expect(1, 43007, '\p{Blk= Latin_EXTENDEDD}', ""); +Expect(0, 43007, '\p{^Blk= Latin_EXTENDEDD}', ""); +Expect(0, 43007, '\P{Blk= Latin_EXTENDEDD}', ""); +Expect(1, 43007, '\P{^Blk= Latin_EXTENDEDD}', ""); +Expect(0, 42783, '\p{Blk= Latin_EXTENDEDD}', ""); +Expect(1, 42783, '\p{^Blk= Latin_EXTENDEDD}', ""); +Expect(1, 42783, '\P{Blk= Latin_EXTENDEDD}', ""); +Expect(0, 42783, '\P{^Blk= Latin_EXTENDEDD}', ""); +Error('\p{Is_Block= Latin-Extended:=D}'); +Error('\P{Is_Block= Latin-Extended:=D}'); +Expect(1, 43007, '\p{Is_Block=latinextendedd}', ""); +Expect(0, 43007, '\p{^Is_Block=latinextendedd}', ""); +Expect(0, 43007, '\P{Is_Block=latinextendedd}', ""); +Expect(1, 43007, '\P{^Is_Block=latinextendedd}', ""); +Expect(0, 42783, '\p{Is_Block=latinextendedd}', ""); +Expect(1, 42783, '\p{^Is_Block=latinextendedd}', ""); +Expect(1, 42783, '\P{Is_Block=latinextendedd}', ""); +Expect(0, 42783, '\P{^Is_Block=latinextendedd}', ""); +Expect(1, 43007, '\p{Is_Block= Latin extended_D}', ""); +Expect(0, 43007, '\p{^Is_Block= Latin extended_D}', ""); +Expect(0, 43007, '\P{Is_Block= Latin extended_D}', ""); +Expect(1, 43007, '\P{^Is_Block= Latin extended_D}', ""); +Expect(0, 42783, '\p{Is_Block= Latin extended_D}', ""); +Expect(1, 42783, '\p{^Is_Block= Latin extended_D}', ""); +Expect(1, 42783, '\P{Is_Block= Latin extended_D}', ""); +Expect(0, 42783, '\P{^Is_Block= Latin extended_D}', ""); +Error('\p{Is_Blk= -latin:=extended-D}'); +Error('\P{Is_Blk= -latin:=extended-D}'); +Expect(1, 43007, '\p{Is_Blk=latinextendedd}', ""); +Expect(0, 43007, '\p{^Is_Blk=latinextendedd}', ""); +Expect(0, 43007, '\P{Is_Blk=latinextendedd}', ""); +Expect(1, 43007, '\P{^Is_Blk=latinextendedd}', ""); +Expect(0, 42783, '\p{Is_Blk=latinextendedd}', ""); +Expect(1, 42783, '\p{^Is_Blk=latinextendedd}', ""); +Expect(1, 42783, '\P{Is_Blk=latinextendedd}', ""); +Expect(0, 42783, '\P{^Is_Blk=latinextendedd}', ""); +Expect(1, 43007, '\p{Is_Blk: _LATIN-extended-D}', ""); +Expect(0, 43007, '\p{^Is_Blk: _LATIN-extended-D}', ""); +Expect(0, 43007, '\P{Is_Blk: _LATIN-extended-D}', ""); +Expect(1, 43007, '\P{^Is_Blk: _LATIN-extended-D}', ""); +Expect(0, 42783, '\p{Is_Blk: _LATIN-extended-D}', ""); +Expect(1, 42783, '\p{^Is_Blk: _LATIN-extended-D}', ""); +Expect(1, 42783, '\P{Is_Blk: _LATIN-extended-D}', ""); +Expect(0, 42783, '\P{^Is_Blk: _LATIN-extended-D}', ""); +Error('\p{Block=__Alphabetic:=Presentation-forms}'); +Error('\P{Block=__Alphabetic:=Presentation-forms}'); +Expect(1, 64335, '\p{Block=alphabeticpresentationforms}', ""); +Expect(0, 64335, '\p{^Block=alphabeticpresentationforms}', ""); +Expect(0, 64335, '\P{Block=alphabeticpresentationforms}', ""); +Expect(1, 64335, '\P{^Block=alphabeticpresentationforms}', ""); +Expect(0, 64255, '\p{Block=alphabeticpresentationforms}', ""); +Expect(1, 64255, '\p{^Block=alphabeticpresentationforms}', ""); +Expect(1, 64255, '\P{Block=alphabeticpresentationforms}', ""); +Expect(0, 64255, '\P{^Block=alphabeticpresentationforms}', ""); +Expect(1, 64335, '\p{Block=--ALPHABETIC_PRESENTATION-forms}', ""); +Expect(0, 64335, '\p{^Block=--ALPHABETIC_PRESENTATION-forms}', ""); +Expect(0, 64335, '\P{Block=--ALPHABETIC_PRESENTATION-forms}', ""); +Expect(1, 64335, '\P{^Block=--ALPHABETIC_PRESENTATION-forms}', ""); +Expect(0, 64255, '\p{Block=--ALPHABETIC_PRESENTATION-forms}', ""); +Expect(1, 64255, '\p{^Block=--ALPHABETIC_PRESENTATION-forms}', ""); +Expect(1, 64255, '\P{Block=--ALPHABETIC_PRESENTATION-forms}', ""); +Expect(0, 64255, '\P{^Block=--ALPHABETIC_PRESENTATION-forms}', ""); +Error('\p{Blk= alphabetic_PRESENTATION forms/a/}'); +Error('\P{Blk= alphabetic_PRESENTATION forms/a/}'); +Expect(1, 64335, '\p{Blk=alphabeticpresentationforms}', ""); +Expect(0, 64335, '\p{^Blk=alphabeticpresentationforms}', ""); +Expect(0, 64335, '\P{Blk=alphabeticpresentationforms}', ""); +Expect(1, 64335, '\P{^Blk=alphabeticpresentationforms}', ""); +Expect(0, 64255, '\p{Blk=alphabeticpresentationforms}', ""); +Expect(1, 64255, '\p{^Blk=alphabeticpresentationforms}', ""); +Expect(1, 64255, '\P{Blk=alphabeticpresentationforms}', ""); +Expect(0, 64255, '\P{^Blk=alphabeticpresentationforms}', ""); +Expect(1, 64335, '\p{Blk= -ALPHABETIC Presentation-Forms}', ""); +Expect(0, 64335, '\p{^Blk= -ALPHABETIC Presentation-Forms}', ""); +Expect(0, 64335, '\P{Blk= -ALPHABETIC Presentation-Forms}', ""); +Expect(1, 64335, '\P{^Blk= -ALPHABETIC Presentation-Forms}', ""); +Expect(0, 64255, '\p{Blk= -ALPHABETIC Presentation-Forms}', ""); +Expect(1, 64255, '\p{^Blk= -ALPHABETIC Presentation-Forms}', ""); +Expect(1, 64255, '\P{Blk= -ALPHABETIC Presentation-Forms}', ""); +Expect(0, 64255, '\P{^Blk= -ALPHABETIC Presentation-Forms}', ""); +Error('\p{Is_Block= /a/ALPHABETIC Presentation Forms}'); +Error('\P{Is_Block= /a/ALPHABETIC Presentation Forms}'); +Expect(1, 64335, '\p{Is_Block=alphabeticpresentationforms}', ""); +Expect(0, 64335, '\p{^Is_Block=alphabeticpresentationforms}', ""); +Expect(0, 64335, '\P{Is_Block=alphabeticpresentationforms}', ""); +Expect(1, 64335, '\P{^Is_Block=alphabeticpresentationforms}', ""); +Expect(0, 64255, '\p{Is_Block=alphabeticpresentationforms}', ""); +Expect(1, 64255, '\p{^Is_Block=alphabeticpresentationforms}', ""); +Expect(1, 64255, '\P{Is_Block=alphabeticpresentationforms}', ""); +Expect(0, 64255, '\P{^Is_Block=alphabeticpresentationforms}', ""); +Expect(1, 64335, '\p{Is_Block=_ Alphabetic-Presentationforms}', ""); +Expect(0, 64335, '\p{^Is_Block=_ Alphabetic-Presentationforms}', ""); +Expect(0, 64335, '\P{Is_Block=_ Alphabetic-Presentationforms}', ""); +Expect(1, 64335, '\P{^Is_Block=_ Alphabetic-Presentationforms}', ""); +Expect(0, 64255, '\p{Is_Block=_ Alphabetic-Presentationforms}', ""); +Expect(1, 64255, '\p{^Is_Block=_ Alphabetic-Presentationforms}', ""); +Expect(1, 64255, '\P{Is_Block=_ Alphabetic-Presentationforms}', ""); +Expect(0, 64255, '\P{^Is_Block=_ Alphabetic-Presentationforms}', ""); +Error('\p{Is_Blk= Alphabetic:=PRESENTATION Forms}'); +Error('\P{Is_Blk= Alphabetic:=PRESENTATION Forms}'); +Expect(1, 64335, '\p{Is_Blk=alphabeticpresentationforms}', ""); +Expect(0, 64335, '\p{^Is_Blk=alphabeticpresentationforms}', ""); +Expect(0, 64335, '\P{Is_Blk=alphabeticpresentationforms}', ""); +Expect(1, 64335, '\P{^Is_Blk=alphabeticpresentationforms}', ""); +Expect(0, 64255, '\p{Is_Blk=alphabeticpresentationforms}', ""); +Expect(1, 64255, '\p{^Is_Blk=alphabeticpresentationforms}', ""); +Expect(1, 64255, '\P{Is_Blk=alphabeticpresentationforms}', ""); +Expect(0, 64255, '\P{^Is_Blk=alphabeticpresentationforms}', ""); +Expect(1, 64335, '\p{Is_Blk=--Alphabetic-Presentation forms}', ""); +Expect(0, 64335, '\p{^Is_Blk=--Alphabetic-Presentation forms}', ""); +Expect(0, 64335, '\P{Is_Blk=--Alphabetic-Presentation forms}', ""); +Expect(1, 64335, '\P{^Is_Blk=--Alphabetic-Presentation forms}', ""); +Expect(0, 64255, '\p{Is_Blk=--Alphabetic-Presentation forms}', ""); +Expect(1, 64255, '\p{^Is_Blk=--Alphabetic-Presentation forms}', ""); +Expect(1, 64255, '\P{Is_Blk=--Alphabetic-Presentation forms}', ""); +Expect(0, 64255, '\P{^Is_Blk=--Alphabetic-Presentation forms}', ""); +Error('\p{Block=-/a/OpticalCharacter_Recognition}'); +Error('\P{Block=-/a/OpticalCharacter_Recognition}'); +Expect(1, 9311, '\p{Block=opticalcharacterrecognition}', ""); +Expect(0, 9311, '\p{^Block=opticalcharacterrecognition}', ""); +Expect(0, 9311, '\P{Block=opticalcharacterrecognition}', ""); +Expect(1, 9311, '\P{^Block=opticalcharacterrecognition}', ""); +Expect(0, 9279, '\p{Block=opticalcharacterrecognition}', ""); +Expect(1, 9279, '\p{^Block=opticalcharacterrecognition}', ""); +Expect(1, 9279, '\P{Block=opticalcharacterrecognition}', ""); +Expect(0, 9279, '\P{^Block=opticalcharacterrecognition}', ""); +Expect(1, 9311, '\p{Block=- optical CHARACTERRecognition}', ""); +Expect(0, 9311, '\p{^Block=- optical CHARACTERRecognition}', ""); +Expect(0, 9311, '\P{Block=- optical CHARACTERRecognition}', ""); +Expect(1, 9311, '\P{^Block=- optical CHARACTERRecognition}', ""); +Expect(0, 9279, '\p{Block=- optical CHARACTERRecognition}', ""); +Expect(1, 9279, '\p{^Block=- optical CHARACTERRecognition}', ""); +Expect(1, 9279, '\P{Block=- optical CHARACTERRecognition}', ""); +Expect(0, 9279, '\P{^Block=- optical CHARACTERRecognition}', ""); +Error('\p{Blk= /a/optical_character Recognition}'); +Error('\P{Blk= /a/optical_character Recognition}'); +Expect(1, 9311, '\p{Blk=opticalcharacterrecognition}', ""); +Expect(0, 9311, '\p{^Blk=opticalcharacterrecognition}', ""); +Expect(0, 9311, '\P{Blk=opticalcharacterrecognition}', ""); +Expect(1, 9311, '\P{^Blk=opticalcharacterrecognition}', ""); +Expect(0, 9279, '\p{Blk=opticalcharacterrecognition}', ""); +Expect(1, 9279, '\p{^Blk=opticalcharacterrecognition}', ""); +Expect(1, 9279, '\P{Blk=opticalcharacterrecognition}', ""); +Expect(0, 9279, '\P{^Blk=opticalcharacterrecognition}', ""); +Expect(1, 9311, '\p{Blk: Optical-CHARACTER_recognition}', ""); +Expect(0, 9311, '\p{^Blk: Optical-CHARACTER_recognition}', ""); +Expect(0, 9311, '\P{Blk: Optical-CHARACTER_recognition}', ""); +Expect(1, 9311, '\P{^Blk: Optical-CHARACTER_recognition}', ""); +Expect(0, 9279, '\p{Blk: Optical-CHARACTER_recognition}', ""); +Expect(1, 9279, '\p{^Blk: Optical-CHARACTER_recognition}', ""); +Expect(1, 9279, '\P{Blk: Optical-CHARACTER_recognition}', ""); +Expect(0, 9279, '\P{^Blk: Optical-CHARACTER_recognition}', ""); +Error('\p{Is_Block= :=Optical CharacterRecognition}'); +Error('\P{Is_Block= :=Optical CharacterRecognition}'); +Expect(1, 9311, '\p{Is_Block=opticalcharacterrecognition}', ""); +Expect(0, 9311, '\p{^Is_Block=opticalcharacterrecognition}', ""); +Expect(0, 9311, '\P{Is_Block=opticalcharacterrecognition}', ""); +Expect(1, 9311, '\P{^Is_Block=opticalcharacterrecognition}', ""); +Expect(0, 9279, '\p{Is_Block=opticalcharacterrecognition}', ""); +Expect(1, 9279, '\p{^Is_Block=opticalcharacterrecognition}', ""); +Expect(1, 9279, '\P{Is_Block=opticalcharacterrecognition}', ""); +Expect(0, 9279, '\P{^Is_Block=opticalcharacterrecognition}', ""); +Expect(1, 9311, '\p{Is_Block=- OpticalCharacter_Recognition}', ""); +Expect(0, 9311, '\p{^Is_Block=- OpticalCharacter_Recognition}', ""); +Expect(0, 9311, '\P{Is_Block=- OpticalCharacter_Recognition}', ""); +Expect(1, 9311, '\P{^Is_Block=- OpticalCharacter_Recognition}', ""); +Expect(0, 9279, '\p{Is_Block=- OpticalCharacter_Recognition}', ""); +Expect(1, 9279, '\p{^Is_Block=- OpticalCharacter_Recognition}', ""); +Expect(1, 9279, '\P{Is_Block=- OpticalCharacter_Recognition}', ""); +Expect(0, 9279, '\P{^Is_Block=- OpticalCharacter_Recognition}', ""); +Error('\p{Is_Blk= :=Opticalcharacter recognition}'); +Error('\P{Is_Blk= :=Opticalcharacter recognition}'); +Expect(1, 9311, '\p{Is_Blk=opticalcharacterrecognition}', ""); +Expect(0, 9311, '\p{^Is_Blk=opticalcharacterrecognition}', ""); +Expect(0, 9311, '\P{Is_Blk=opticalcharacterrecognition}', ""); +Expect(1, 9311, '\P{^Is_Blk=opticalcharacterrecognition}', ""); +Expect(0, 9279, '\p{Is_Blk=opticalcharacterrecognition}', ""); +Expect(1, 9279, '\p{^Is_Blk=opticalcharacterrecognition}', ""); +Expect(1, 9279, '\P{Is_Blk=opticalcharacterrecognition}', ""); +Expect(0, 9279, '\P{^Is_Blk=opticalcharacterrecognition}', ""); +Expect(1, 9311, '\p{Is_Blk=_-Optical_Character recognition}', ""); +Expect(0, 9311, '\p{^Is_Blk=_-Optical_Character recognition}', ""); +Expect(0, 9311, '\P{Is_Blk=_-Optical_Character recognition}', ""); +Expect(1, 9311, '\P{^Is_Blk=_-Optical_Character recognition}', ""); +Expect(0, 9279, '\p{Is_Blk=_-Optical_Character recognition}', ""); +Expect(1, 9279, '\p{^Is_Blk=_-Optical_Character recognition}', ""); +Expect(1, 9279, '\P{Is_Blk=_-Optical_Character recognition}', ""); +Expect(0, 9279, '\P{^Is_Blk=_-Optical_Character recognition}', ""); +Error('\p{Block=- cjk/a/UNIFIEDideographs}'); +Error('\P{Block=- cjk/a/UNIFIEDideographs}'); +Expect(1, 40959, '\p{Block=cjkunifiedideographs}', ""); +Expect(0, 40959, '\p{^Block=cjkunifiedideographs}', ""); +Expect(0, 40959, '\P{Block=cjkunifiedideographs}', ""); +Expect(1, 40959, '\P{^Block=cjkunifiedideographs}', ""); +Expect(0, 19967, '\p{Block=cjkunifiedideographs}', ""); +Expect(1, 19967, '\p{^Block=cjkunifiedideographs}', ""); +Expect(1, 19967, '\P{Block=cjkunifiedideographs}', ""); +Expect(0, 19967, '\P{^Block=cjkunifiedideographs}', ""); +Expect(1, 40959, '\p{Block: -cjkUnifiedIDEOGRAPHS}', ""); +Expect(0, 40959, '\p{^Block: -cjkUnifiedIDEOGRAPHS}', ""); +Expect(0, 40959, '\P{Block: -cjkUnifiedIDEOGRAPHS}', ""); +Expect(1, 40959, '\P{^Block: -cjkUnifiedIDEOGRAPHS}', ""); +Expect(0, 19967, '\p{Block: -cjkUnifiedIDEOGRAPHS}', ""); +Expect(1, 19967, '\p{^Block: -cjkUnifiedIDEOGRAPHS}', ""); +Expect(1, 19967, '\P{Block: -cjkUnifiedIDEOGRAPHS}', ""); +Expect(0, 19967, '\P{^Block: -cjkUnifiedIDEOGRAPHS}', ""); +Error('\p{Blk= CJKUnified/a/ideographs}'); +Error('\P{Blk= CJKUnified/a/ideographs}'); +Expect(1, 40959, '\p{Blk: cjkunifiedideographs}', ""); +Expect(0, 40959, '\p{^Blk: cjkunifiedideographs}', ""); +Expect(0, 40959, '\P{Blk: cjkunifiedideographs}', ""); +Expect(1, 40959, '\P{^Blk: cjkunifiedideographs}', ""); +Expect(0, 19967, '\p{Blk: cjkunifiedideographs}', ""); +Expect(1, 19967, '\p{^Blk: cjkunifiedideographs}', ""); +Expect(1, 19967, '\P{Blk: cjkunifiedideographs}', ""); +Expect(0, 19967, '\P{^Blk: cjkunifiedideographs}', ""); +Expect(1, 40959, '\p{Blk=_-CJKunified_ideographs}', ""); +Expect(0, 40959, '\p{^Blk=_-CJKunified_ideographs}', ""); +Expect(0, 40959, '\P{Blk=_-CJKunified_ideographs}', ""); +Expect(1, 40959, '\P{^Blk=_-CJKunified_ideographs}', ""); +Expect(0, 19967, '\p{Blk=_-CJKunified_ideographs}', ""); +Expect(1, 19967, '\p{^Blk=_-CJKunified_ideographs}', ""); +Expect(1, 19967, '\P{Blk=_-CJKunified_ideographs}', ""); +Expect(0, 19967, '\P{^Blk=_-CJKunified_ideographs}', ""); +Error('\p{Is_Block= -CJK:=unified-Ideographs}'); +Error('\P{Is_Block= -CJK:=unified-Ideographs}'); +Expect(1, 40959, '\p{Is_Block: cjkunifiedideographs}', ""); +Expect(0, 40959, '\p{^Is_Block: cjkunifiedideographs}', ""); +Expect(0, 40959, '\P{Is_Block: cjkunifiedideographs}', ""); +Expect(1, 40959, '\P{^Is_Block: cjkunifiedideographs}', ""); +Expect(0, 19967, '\p{Is_Block: cjkunifiedideographs}', ""); +Expect(1, 19967, '\p{^Is_Block: cjkunifiedideographs}', ""); +Expect(1, 19967, '\P{Is_Block: cjkunifiedideographs}', ""); +Expect(0, 19967, '\P{^Is_Block: cjkunifiedideographs}', ""); +Expect(1, 40959, '\p{Is_Block=--CJKUnified Ideographs}', ""); +Expect(0, 40959, '\p{^Is_Block=--CJKUnified Ideographs}', ""); +Expect(0, 40959, '\P{Is_Block=--CJKUnified Ideographs}', ""); +Expect(1, 40959, '\P{^Is_Block=--CJKUnified Ideographs}', ""); +Expect(0, 19967, '\p{Is_Block=--CJKUnified Ideographs}', ""); +Expect(1, 19967, '\p{^Is_Block=--CJKUnified Ideographs}', ""); +Expect(1, 19967, '\P{Is_Block=--CJKUnified Ideographs}', ""); +Expect(0, 19967, '\P{^Is_Block=--CJKUnified Ideographs}', ""); +Error('\p{Is_Blk: CJK/a/Unified-Ideographs}'); +Error('\P{Is_Blk: CJK/a/Unified-Ideographs}'); +Expect(1, 40959, '\p{Is_Blk=cjkunifiedideographs}', ""); +Expect(0, 40959, '\p{^Is_Blk=cjkunifiedideographs}', ""); +Expect(0, 40959, '\P{Is_Blk=cjkunifiedideographs}', ""); +Expect(1, 40959, '\P{^Is_Blk=cjkunifiedideographs}', ""); +Expect(0, 19967, '\p{Is_Blk=cjkunifiedideographs}', ""); +Expect(1, 19967, '\p{^Is_Blk=cjkunifiedideographs}', ""); +Expect(1, 19967, '\P{Is_Blk=cjkunifiedideographs}', ""); +Expect(0, 19967, '\P{^Is_Blk=cjkunifiedideographs}', ""); +Expect(1, 40959, '\p{Is_Blk: CJKUNIFIEDIdeographs}', ""); +Expect(0, 40959, '\p{^Is_Blk: CJKUNIFIEDIdeographs}', ""); +Expect(0, 40959, '\P{Is_Blk: CJKUNIFIEDIdeographs}', ""); +Expect(1, 40959, '\P{^Is_Blk: CJKUNIFIEDIdeographs}', ""); +Expect(0, 19967, '\p{Is_Blk: CJKUNIFIEDIdeographs}', ""); +Expect(1, 19967, '\p{^Is_Blk: CJKUNIFIEDIdeographs}', ""); +Expect(1, 19967, '\P{Is_Blk: CJKUNIFIEDIdeographs}', ""); +Expect(0, 19967, '\P{^Is_Blk: CJKUNIFIEDIdeographs}', ""); +Error('\p{Block=_:=AncientSymbols}'); +Error('\P{Block=_:=AncientSymbols}'); +Expect(1, 65999, '\p{Block=ancientsymbols}', ""); +Expect(0, 65999, '\p{^Block=ancientsymbols}', ""); +Expect(0, 65999, '\P{Block=ancientsymbols}', ""); +Expect(1, 65999, '\P{^Block=ancientsymbols}', ""); +Expect(0, 65935, '\p{Block=ancientsymbols}', ""); +Expect(1, 65935, '\p{^Block=ancientsymbols}', ""); +Expect(1, 65935, '\P{Block=ancientsymbols}', ""); +Expect(0, 65935, '\P{^Block=ancientsymbols}', ""); +Expect(1, 65999, '\p{Block=- Ancient_Symbols}', ""); +Expect(0, 65999, '\p{^Block=- Ancient_Symbols}', ""); +Expect(0, 65999, '\P{Block=- Ancient_Symbols}', ""); +Expect(1, 65999, '\P{^Block=- Ancient_Symbols}', ""); +Expect(0, 65935, '\p{Block=- Ancient_Symbols}', ""); +Expect(1, 65935, '\p{^Block=- Ancient_Symbols}', ""); +Expect(1, 65935, '\P{Block=- Ancient_Symbols}', ""); +Expect(0, 65935, '\P{^Block=- Ancient_Symbols}', ""); +Error('\p{Blk= ancient symbols/a/}'); +Error('\P{Blk= ancient symbols/a/}'); +Expect(1, 65999, '\p{Blk=ancientsymbols}', ""); +Expect(0, 65999, '\p{^Blk=ancientsymbols}', ""); +Expect(0, 65999, '\P{Blk=ancientsymbols}', ""); +Expect(1, 65999, '\P{^Blk=ancientsymbols}', ""); +Expect(0, 65935, '\p{Blk=ancientsymbols}', ""); +Expect(1, 65935, '\p{^Blk=ancientsymbols}', ""); +Expect(1, 65935, '\P{Blk=ancientsymbols}', ""); +Expect(0, 65935, '\P{^Blk=ancientsymbols}', ""); +Expect(1, 65999, '\p{Blk= Ancient-Symbols}', ""); +Expect(0, 65999, '\p{^Blk= Ancient-Symbols}', ""); +Expect(0, 65999, '\P{Blk= Ancient-Symbols}', ""); +Expect(1, 65999, '\P{^Blk= Ancient-Symbols}', ""); +Expect(0, 65935, '\p{Blk= Ancient-Symbols}', ""); +Expect(1, 65935, '\p{^Blk= Ancient-Symbols}', ""); +Expect(1, 65935, '\P{Blk= Ancient-Symbols}', ""); +Expect(0, 65935, '\P{^Blk= Ancient-Symbols}', ""); +Error('\p{Is_Block= -Ancient Symbols/a/}'); +Error('\P{Is_Block= -Ancient Symbols/a/}'); +Expect(1, 65999, '\p{Is_Block=ancientsymbols}', ""); +Expect(0, 65999, '\p{^Is_Block=ancientsymbols}', ""); +Expect(0, 65999, '\P{Is_Block=ancientsymbols}', ""); +Expect(1, 65999, '\P{^Is_Block=ancientsymbols}', ""); +Expect(0, 65935, '\p{Is_Block=ancientsymbols}', ""); +Expect(1, 65935, '\p{^Is_Block=ancientsymbols}', ""); +Expect(1, 65935, '\P{Is_Block=ancientsymbols}', ""); +Expect(0, 65935, '\P{^Is_Block=ancientsymbols}', ""); +Expect(1, 65999, '\p{Is_Block=-Ancientsymbols}', ""); +Expect(0, 65999, '\p{^Is_Block=-Ancientsymbols}', ""); +Expect(0, 65999, '\P{Is_Block=-Ancientsymbols}', ""); +Expect(1, 65999, '\P{^Is_Block=-Ancientsymbols}', ""); +Expect(0, 65935, '\p{Is_Block=-Ancientsymbols}', ""); +Expect(1, 65935, '\p{^Is_Block=-Ancientsymbols}', ""); +Expect(1, 65935, '\P{Is_Block=-Ancientsymbols}', ""); +Expect(0, 65935, '\P{^Is_Block=-Ancientsymbols}', ""); +Error('\p{Is_Blk=:=-Ancient-Symbols}'); +Error('\P{Is_Blk=:=-Ancient-Symbols}'); +Expect(1, 65999, '\p{Is_Blk=ancientsymbols}', ""); +Expect(0, 65999, '\p{^Is_Blk=ancientsymbols}', ""); +Expect(0, 65999, '\P{Is_Blk=ancientsymbols}', ""); +Expect(1, 65999, '\P{^Is_Blk=ancientsymbols}', ""); +Expect(0, 65935, '\p{Is_Blk=ancientsymbols}', ""); +Expect(1, 65935, '\p{^Is_Blk=ancientsymbols}', ""); +Expect(1, 65935, '\P{Is_Blk=ancientsymbols}', ""); +Expect(0, 65935, '\P{^Is_Blk=ancientsymbols}', ""); +Expect(1, 65999, '\p{Is_Blk: _ ancient Symbols}', ""); +Expect(0, 65999, '\p{^Is_Blk: _ ancient Symbols}', ""); +Expect(0, 65999, '\P{Is_Blk: _ ancient Symbols}', ""); +Expect(1, 65999, '\P{^Is_Blk: _ ancient Symbols}', ""); +Expect(0, 65935, '\p{Is_Blk: _ ancient Symbols}', ""); +Expect(1, 65935, '\p{^Is_Blk: _ ancient Symbols}', ""); +Expect(1, 65935, '\P{Is_Blk: _ ancient Symbols}', ""); +Expect(0, 65935, '\P{^Is_Blk: _ ancient Symbols}', ""); +Error('\p{Block=:=-_gothic}'); +Error('\P{Block=:=-_gothic}'); +Expect(1, 66383, '\p{Block=gothic}', ""); +Expect(0, 66383, '\p{^Block=gothic}', ""); +Expect(0, 66383, '\P{Block=gothic}', ""); +Expect(1, 66383, '\P{^Block=gothic}', ""); +Expect(0, 66351, '\p{Block=gothic}', ""); +Expect(1, 66351, '\p{^Block=gothic}', ""); +Expect(1, 66351, '\P{Block=gothic}', ""); +Expect(0, 66351, '\P{^Block=gothic}', ""); +Expect(1, 66383, '\p{Block=-GOTHIC}', ""); +Expect(0, 66383, '\p{^Block=-GOTHIC}', ""); +Expect(0, 66383, '\P{Block=-GOTHIC}', ""); +Expect(1, 66383, '\P{^Block=-GOTHIC}', ""); +Expect(0, 66351, '\p{Block=-GOTHIC}', ""); +Expect(1, 66351, '\p{^Block=-GOTHIC}', ""); +Expect(1, 66351, '\P{Block=-GOTHIC}', ""); +Expect(0, 66351, '\P{^Block=-GOTHIC}', ""); +Error('\p{Blk=:=-Gothic}'); +Error('\P{Blk=:=-Gothic}'); +Expect(1, 66383, '\p{Blk=gothic}', ""); +Expect(0, 66383, '\p{^Blk=gothic}', ""); +Expect(0, 66383, '\P{Blk=gothic}', ""); +Expect(1, 66383, '\P{^Blk=gothic}', ""); +Expect(0, 66351, '\p{Blk=gothic}', ""); +Expect(1, 66351, '\p{^Blk=gothic}', ""); +Expect(1, 66351, '\P{Blk=gothic}', ""); +Expect(0, 66351, '\P{^Blk=gothic}', ""); +Expect(1, 66383, '\p{Blk=- GOTHIC}', ""); +Expect(0, 66383, '\p{^Blk=- GOTHIC}', ""); +Expect(0, 66383, '\P{Blk=- GOTHIC}', ""); +Expect(1, 66383, '\P{^Blk=- GOTHIC}', ""); +Expect(0, 66351, '\p{Blk=- GOTHIC}', ""); +Expect(1, 66351, '\p{^Blk=- GOTHIC}', ""); +Expect(1, 66351, '\P{Blk=- GOTHIC}', ""); +Expect(0, 66351, '\P{^Blk=- GOTHIC}', ""); +Error('\p{Is_Block= Gothic:=}'); +Error('\P{Is_Block= Gothic:=}'); +Expect(1, 66383, '\p{Is_Block=gothic}', ""); +Expect(0, 66383, '\p{^Is_Block=gothic}', ""); +Expect(0, 66383, '\P{Is_Block=gothic}', ""); +Expect(1, 66383, '\P{^Is_Block=gothic}', ""); +Expect(0, 66351, '\p{Is_Block=gothic}', ""); +Expect(1, 66351, '\p{^Is_Block=gothic}', ""); +Expect(1, 66351, '\P{Is_Block=gothic}', ""); +Expect(0, 66351, '\P{^Is_Block=gothic}', ""); +Expect(1, 66383, '\p{Is_Block= -GOTHIC}', ""); +Expect(0, 66383, '\p{^Is_Block= -GOTHIC}', ""); +Expect(0, 66383, '\P{Is_Block= -GOTHIC}', ""); +Expect(1, 66383, '\P{^Is_Block= -GOTHIC}', ""); +Expect(0, 66351, '\p{Is_Block= -GOTHIC}', ""); +Expect(1, 66351, '\p{^Is_Block= -GOTHIC}', ""); +Expect(1, 66351, '\P{Is_Block= -GOTHIC}', ""); +Expect(0, 66351, '\P{^Is_Block= -GOTHIC}', ""); +Error('\p{Is_Blk=-/a/gothic}'); +Error('\P{Is_Blk=-/a/gothic}'); +Expect(1, 66383, '\p{Is_Blk=gothic}', ""); +Expect(0, 66383, '\p{^Is_Blk=gothic}', ""); +Expect(0, 66383, '\P{Is_Blk=gothic}', ""); +Expect(1, 66383, '\P{^Is_Blk=gothic}', ""); +Expect(0, 66351, '\p{Is_Blk=gothic}', ""); +Expect(1, 66351, '\p{^Is_Blk=gothic}', ""); +Expect(1, 66351, '\P{Is_Blk=gothic}', ""); +Expect(0, 66351, '\P{^Is_Blk=gothic}', ""); +Expect(1, 66383, '\p{Is_Blk= GOTHIC}', ""); +Expect(0, 66383, '\p{^Is_Blk= GOTHIC}', ""); +Expect(0, 66383, '\P{Is_Blk= GOTHIC}', ""); +Expect(1, 66383, '\P{^Is_Blk= GOTHIC}', ""); +Expect(0, 66351, '\p{Is_Blk= GOTHIC}', ""); +Expect(1, 66351, '\p{^Is_Blk= GOTHIC}', ""); +Expect(1, 66351, '\P{Is_Blk= GOTHIC}', ""); +Expect(0, 66351, '\P{^Is_Blk= GOTHIC}', ""); +Error('\p{Block=-:=Ethiopic}'); +Error('\P{Block=-:=Ethiopic}'); +Expect(1, 4991, '\p{Block=ethiopic}', ""); +Expect(0, 4991, '\p{^Block=ethiopic}', ""); +Expect(0, 4991, '\P{Block=ethiopic}', ""); +Expect(1, 4991, '\P{^Block=ethiopic}', ""); +Expect(0, 4607, '\p{Block=ethiopic}', ""); +Expect(1, 4607, '\p{^Block=ethiopic}', ""); +Expect(1, 4607, '\P{Block=ethiopic}', ""); +Expect(0, 4607, '\P{^Block=ethiopic}', ""); +Expect(1, 4991, '\p{Block= Ethiopic}', ""); +Expect(0, 4991, '\p{^Block= Ethiopic}', ""); +Expect(0, 4991, '\P{Block= Ethiopic}', ""); +Expect(1, 4991, '\P{^Block= Ethiopic}', ""); +Expect(0, 4607, '\p{Block= Ethiopic}', ""); +Expect(1, 4607, '\p{^Block= Ethiopic}', ""); +Expect(1, 4607, '\P{Block= Ethiopic}', ""); +Expect(0, 4607, '\P{^Block= Ethiopic}', ""); +Error('\p{Blk:/a/-_ETHIOPIC}'); +Error('\P{Blk:/a/-_ETHIOPIC}'); +Expect(1, 4991, '\p{Blk=ethiopic}', ""); +Expect(0, 4991, '\p{^Blk=ethiopic}', ""); +Expect(0, 4991, '\P{Blk=ethiopic}', ""); +Expect(1, 4991, '\P{^Blk=ethiopic}', ""); +Expect(0, 4607, '\p{Blk=ethiopic}', ""); +Expect(1, 4607, '\p{^Blk=ethiopic}', ""); +Expect(1, 4607, '\P{Blk=ethiopic}', ""); +Expect(0, 4607, '\P{^Blk=ethiopic}', ""); +Expect(1, 4991, '\p{Blk: _-ETHIOPIC}', ""); +Expect(0, 4991, '\p{^Blk: _-ETHIOPIC}', ""); +Expect(0, 4991, '\P{Blk: _-ETHIOPIC}', ""); +Expect(1, 4991, '\P{^Blk: _-ETHIOPIC}', ""); +Expect(0, 4607, '\p{Blk: _-ETHIOPIC}', ""); +Expect(1, 4607, '\p{^Blk: _-ETHIOPIC}', ""); +Expect(1, 4607, '\P{Blk: _-ETHIOPIC}', ""); +Expect(0, 4607, '\P{^Blk: _-ETHIOPIC}', ""); +Error('\p{Is_Block=_ETHIOPIC/a/}'); +Error('\P{Is_Block=_ETHIOPIC/a/}'); +Expect(1, 4991, '\p{Is_Block=ethiopic}', ""); +Expect(0, 4991, '\p{^Is_Block=ethiopic}', ""); +Expect(0, 4991, '\P{Is_Block=ethiopic}', ""); +Expect(1, 4991, '\P{^Is_Block=ethiopic}', ""); +Expect(0, 4607, '\p{Is_Block=ethiopic}', ""); +Expect(1, 4607, '\p{^Is_Block=ethiopic}', ""); +Expect(1, 4607, '\P{Is_Block=ethiopic}', ""); +Expect(0, 4607, '\P{^Is_Block=ethiopic}', ""); +Expect(1, 4991, '\p{Is_Block=_ ETHIOPIC}', ""); +Expect(0, 4991, '\p{^Is_Block=_ ETHIOPIC}', ""); +Expect(0, 4991, '\P{Is_Block=_ ETHIOPIC}', ""); +Expect(1, 4991, '\P{^Is_Block=_ ETHIOPIC}', ""); +Expect(0, 4607, '\p{Is_Block=_ ETHIOPIC}', ""); +Expect(1, 4607, '\p{^Is_Block=_ ETHIOPIC}', ""); +Expect(1, 4607, '\P{Is_Block=_ ETHIOPIC}', ""); +Expect(0, 4607, '\P{^Is_Block=_ ETHIOPIC}', ""); +Error('\p{Is_Blk= -ETHIOPIC/a/}'); +Error('\P{Is_Blk= -ETHIOPIC/a/}'); +Expect(1, 4991, '\p{Is_Blk=ethiopic}', ""); +Expect(0, 4991, '\p{^Is_Blk=ethiopic}', ""); +Expect(0, 4991, '\P{Is_Blk=ethiopic}', ""); +Expect(1, 4991, '\P{^Is_Blk=ethiopic}', ""); +Expect(0, 4607, '\p{Is_Blk=ethiopic}', ""); +Expect(1, 4607, '\p{^Is_Blk=ethiopic}', ""); +Expect(1, 4607, '\P{Is_Blk=ethiopic}', ""); +Expect(0, 4607, '\P{^Is_Blk=ethiopic}', ""); +Expect(1, 4991, '\p{Is_Blk= ETHIOPIC}', ""); +Expect(0, 4991, '\p{^Is_Blk= ETHIOPIC}', ""); +Expect(0, 4991, '\P{Is_Blk= ETHIOPIC}', ""); +Expect(1, 4991, '\P{^Is_Blk= ETHIOPIC}', ""); +Expect(0, 4607, '\p{Is_Blk= ETHIOPIC}', ""); +Expect(1, 4607, '\p{^Is_Blk= ETHIOPIC}', ""); +Expect(1, 4607, '\P{Is_Blk= ETHIOPIC}', ""); +Expect(0, 4607, '\P{^Is_Blk= ETHIOPIC}', ""); +Error('\p{Block: /a/buginese}'); +Error('\P{Block: /a/buginese}'); +Expect(1, 6687, '\p{Block=buginese}', ""); +Expect(0, 6687, '\p{^Block=buginese}', ""); +Expect(0, 6687, '\P{Block=buginese}', ""); +Expect(1, 6687, '\P{^Block=buginese}', ""); +Expect(0, 6655, '\p{Block=buginese}', ""); +Expect(1, 6655, '\p{^Block=buginese}', ""); +Expect(1, 6655, '\P{Block=buginese}', ""); +Expect(0, 6655, '\P{^Block=buginese}', ""); +Expect(1, 6687, '\p{Block= _Buginese}', ""); +Expect(0, 6687, '\p{^Block= _Buginese}', ""); +Expect(0, 6687, '\P{Block= _Buginese}', ""); +Expect(1, 6687, '\P{^Block= _Buginese}', ""); +Expect(0, 6655, '\p{Block= _Buginese}', ""); +Expect(1, 6655, '\p{^Block= _Buginese}', ""); +Expect(1, 6655, '\P{Block= _Buginese}', ""); +Expect(0, 6655, '\P{^Block= _Buginese}', ""); +Error('\p{Blk= buginese/a/}'); +Error('\P{Blk= buginese/a/}'); +Expect(1, 6687, '\p{Blk:buginese}', ""); +Expect(0, 6687, '\p{^Blk:buginese}', ""); +Expect(0, 6687, '\P{Blk:buginese}', ""); +Expect(1, 6687, '\P{^Blk:buginese}', ""); +Expect(0, 6655, '\p{Blk:buginese}', ""); +Expect(1, 6655, '\p{^Blk:buginese}', ""); +Expect(1, 6655, '\P{Blk:buginese}', ""); +Expect(0, 6655, '\P{^Blk:buginese}', ""); +Expect(1, 6687, '\p{Blk=- Buginese}', ""); +Expect(0, 6687, '\p{^Blk=- Buginese}', ""); +Expect(0, 6687, '\P{Blk=- Buginese}', ""); +Expect(1, 6687, '\P{^Blk=- Buginese}', ""); +Expect(0, 6655, '\p{Blk=- Buginese}', ""); +Expect(1, 6655, '\p{^Blk=- Buginese}', ""); +Expect(1, 6655, '\P{Blk=- Buginese}', ""); +Expect(0, 6655, '\P{^Blk=- Buginese}', ""); +Error('\p{Is_Block= /a/buginese}'); +Error('\P{Is_Block= /a/buginese}'); +Expect(1, 6687, '\p{Is_Block=buginese}', ""); +Expect(0, 6687, '\p{^Is_Block=buginese}', ""); +Expect(0, 6687, '\P{Is_Block=buginese}', ""); +Expect(1, 6687, '\P{^Is_Block=buginese}', ""); +Expect(0, 6655, '\p{Is_Block=buginese}', ""); +Expect(1, 6655, '\p{^Is_Block=buginese}', ""); +Expect(1, 6655, '\P{Is_Block=buginese}', ""); +Expect(0, 6655, '\P{^Is_Block=buginese}', ""); +Expect(1, 6687, '\p{Is_Block= Buginese}', ""); +Expect(0, 6687, '\p{^Is_Block= Buginese}', ""); +Expect(0, 6687, '\P{Is_Block= Buginese}', ""); +Expect(1, 6687, '\P{^Is_Block= Buginese}', ""); +Expect(0, 6655, '\p{Is_Block= Buginese}', ""); +Expect(1, 6655, '\p{^Is_Block= Buginese}', ""); +Expect(1, 6655, '\P{Is_Block= Buginese}', ""); +Expect(0, 6655, '\P{^Is_Block= Buginese}', ""); +Error('\p{Is_Blk=/a/ buginese}'); +Error('\P{Is_Blk=/a/ buginese}'); +Expect(1, 6687, '\p{Is_Blk=buginese}', ""); +Expect(0, 6687, '\p{^Is_Blk=buginese}', ""); +Expect(0, 6687, '\P{Is_Blk=buginese}', ""); +Expect(1, 6687, '\P{^Is_Blk=buginese}', ""); +Expect(0, 6655, '\p{Is_Blk=buginese}', ""); +Expect(1, 6655, '\p{^Is_Blk=buginese}', ""); +Expect(1, 6655, '\P{Is_Blk=buginese}', ""); +Expect(0, 6655, '\P{^Is_Blk=buginese}', ""); +Expect(1, 6687, '\p{Is_Blk=-Buginese}', ""); +Expect(0, 6687, '\p{^Is_Blk=-Buginese}', ""); +Expect(0, 6687, '\P{Is_Blk=-Buginese}', ""); +Expect(1, 6687, '\P{^Is_Blk=-Buginese}', ""); +Expect(0, 6655, '\p{Is_Blk=-Buginese}', ""); +Expect(1, 6655, '\p{^Is_Blk=-Buginese}', ""); +Expect(1, 6655, '\P{Is_Blk=-Buginese}', ""); +Expect(0, 6655, '\P{^Is_Blk=-Buginese}', ""); +Error('\p{Block=_-Mathematical alphanumeric_Symbols/a/}'); +Error('\P{Block=_-Mathematical alphanumeric_Symbols/a/}'); +Expect(1, 120831, '\p{Block=mathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\p{^Block=mathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\P{Block=mathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\P{^Block=mathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\p{Block=mathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\p{^Block=mathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\P{Block=mathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\P{^Block=mathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\p{Block= MATHEMATICAL Alphanumeric-Symbols}', ""); +Expect(0, 120831, '\p{^Block= MATHEMATICAL Alphanumeric-Symbols}', ""); +Expect(0, 120831, '\P{Block= MATHEMATICAL Alphanumeric-Symbols}', ""); +Expect(1, 120831, '\P{^Block= MATHEMATICAL Alphanumeric-Symbols}', ""); +Expect(0, 119807, '\p{Block= MATHEMATICAL Alphanumeric-Symbols}', ""); +Expect(1, 119807, '\p{^Block= MATHEMATICAL Alphanumeric-Symbols}', ""); +Expect(1, 119807, '\P{Block= MATHEMATICAL Alphanumeric-Symbols}', ""); +Expect(0, 119807, '\P{^Block= MATHEMATICAL Alphanumeric-Symbols}', ""); +Error('\p{Blk= :=Mathematical Alphanumeric_Symbols}'); +Error('\P{Blk= :=Mathematical Alphanumeric_Symbols}'); +Expect(1, 120831, '\p{Blk: mathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\p{^Blk: mathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\P{Blk: mathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\P{^Blk: mathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\p{Blk: mathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\p{^Blk: mathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\P{Blk: mathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\P{^Blk: mathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\p{Blk= -mathematicalAlphanumeric_Symbols}', ""); +Expect(0, 120831, '\p{^Blk= -mathematicalAlphanumeric_Symbols}', ""); +Expect(0, 120831, '\P{Blk= -mathematicalAlphanumeric_Symbols}', ""); +Expect(1, 120831, '\P{^Blk= -mathematicalAlphanumeric_Symbols}', ""); +Expect(0, 119807, '\p{Blk= -mathematicalAlphanumeric_Symbols}', ""); +Expect(1, 119807, '\p{^Blk= -mathematicalAlphanumeric_Symbols}', ""); +Expect(1, 119807, '\P{Blk= -mathematicalAlphanumeric_Symbols}', ""); +Expect(0, 119807, '\P{^Blk= -mathematicalAlphanumeric_Symbols}', ""); +Error('\p{Is_Block: -:=Mathematical Alphanumeric_SYMBOLS}'); +Error('\P{Is_Block: -:=Mathematical Alphanumeric_SYMBOLS}'); +Expect(1, 120831, '\p{Is_Block=mathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\p{^Is_Block=mathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\P{Is_Block=mathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\P{^Is_Block=mathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\p{Is_Block=mathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\p{^Is_Block=mathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\P{Is_Block=mathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\P{^Is_Block=mathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\p{Is_Block=mathematical Alphanumeric SYMBOLS}', ""); +Expect(0, 120831, '\p{^Is_Block=mathematical Alphanumeric SYMBOLS}', ""); +Expect(0, 120831, '\P{Is_Block=mathematical Alphanumeric SYMBOLS}', ""); +Expect(1, 120831, '\P{^Is_Block=mathematical Alphanumeric SYMBOLS}', ""); +Expect(0, 119807, '\p{Is_Block=mathematical Alphanumeric SYMBOLS}', ""); +Expect(1, 119807, '\p{^Is_Block=mathematical Alphanumeric SYMBOLS}', ""); +Expect(1, 119807, '\P{Is_Block=mathematical Alphanumeric SYMBOLS}', ""); +Expect(0, 119807, '\P{^Is_Block=mathematical Alphanumeric SYMBOLS}', ""); +Error('\p{Is_Blk=- mathematical_Alphanumeric SYMBOLS:=}'); +Error('\P{Is_Blk=- mathematical_Alphanumeric SYMBOLS:=}'); +Expect(1, 120831, '\p{Is_Blk=mathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\p{^Is_Blk=mathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\P{Is_Blk=mathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\P{^Is_Blk=mathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\p{Is_Blk=mathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\p{^Is_Blk=mathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\P{Is_Blk=mathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\P{^Is_Blk=mathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\p{Is_Blk=_Mathematical_AlphanumericSYMBOLS}', ""); +Expect(0, 120831, '\p{^Is_Blk=_Mathematical_AlphanumericSYMBOLS}', ""); +Expect(0, 120831, '\P{Is_Blk=_Mathematical_AlphanumericSYMBOLS}', ""); +Expect(1, 120831, '\P{^Is_Blk=_Mathematical_AlphanumericSYMBOLS}', ""); +Expect(0, 119807, '\p{Is_Blk=_Mathematical_AlphanumericSYMBOLS}', ""); +Expect(1, 119807, '\p{^Is_Blk=_Mathematical_AlphanumericSYMBOLS}', ""); +Expect(1, 119807, '\P{Is_Blk=_Mathematical_AlphanumericSYMBOLS}', ""); +Expect(0, 119807, '\P{^Is_Blk=_Mathematical_AlphanumericSYMBOLS}', ""); +Error('\p{Block= Kangxi/a/RADICALS}'); +Error('\P{Block= Kangxi/a/RADICALS}'); +Expect(1, 12255, '\p{Block=kangxiradicals}', ""); +Expect(0, 12255, '\p{^Block=kangxiradicals}', ""); +Expect(0, 12255, '\P{Block=kangxiradicals}', ""); +Expect(1, 12255, '\P{^Block=kangxiradicals}', ""); +Expect(0, 12031, '\p{Block=kangxiradicals}', ""); +Expect(1, 12031, '\p{^Block=kangxiradicals}', ""); +Expect(1, 12031, '\P{Block=kangxiradicals}', ""); +Expect(0, 12031, '\P{^Block=kangxiradicals}', ""); +Expect(1, 12255, '\p{Block=_ kangxi Radicals}', ""); +Expect(0, 12255, '\p{^Block=_ kangxi Radicals}', ""); +Expect(0, 12255, '\P{Block=_ kangxi Radicals}', ""); +Expect(1, 12255, '\P{^Block=_ kangxi Radicals}', ""); +Expect(0, 12031, '\p{Block=_ kangxi Radicals}', ""); +Expect(1, 12031, '\p{^Block=_ kangxi Radicals}', ""); +Expect(1, 12031, '\P{Block=_ kangxi Radicals}', ""); +Expect(0, 12031, '\P{^Block=_ kangxi Radicals}', ""); +Error('\p{Blk=_ KANGXI/a/radicals}'); +Error('\P{Blk=_ KANGXI/a/radicals}'); +Expect(1, 12255, '\p{Blk=kangxiradicals}', ""); +Expect(0, 12255, '\p{^Blk=kangxiradicals}', ""); +Expect(0, 12255, '\P{Blk=kangxiradicals}', ""); +Expect(1, 12255, '\P{^Blk=kangxiradicals}', ""); +Expect(0, 12031, '\p{Blk=kangxiradicals}', ""); +Expect(1, 12031, '\p{^Blk=kangxiradicals}', ""); +Expect(1, 12031, '\P{Blk=kangxiradicals}', ""); +Expect(0, 12031, '\P{^Blk=kangxiradicals}', ""); +Expect(1, 12255, '\p{Blk=_-Kangxi radicals}', ""); +Expect(0, 12255, '\p{^Blk=_-Kangxi radicals}', ""); +Expect(0, 12255, '\P{Blk=_-Kangxi radicals}', ""); +Expect(1, 12255, '\P{^Blk=_-Kangxi radicals}', ""); +Expect(0, 12031, '\p{Blk=_-Kangxi radicals}', ""); +Expect(1, 12031, '\p{^Blk=_-Kangxi radicals}', ""); +Expect(1, 12031, '\P{Blk=_-Kangxi radicals}', ""); +Expect(0, 12031, '\P{^Blk=_-Kangxi radicals}', ""); +Error('\p{Is_Block=-:=Kangxi Radicals}'); +Error('\P{Is_Block=-:=Kangxi Radicals}'); +Expect(1, 12255, '\p{Is_Block: kangxiradicals}', ""); +Expect(0, 12255, '\p{^Is_Block: kangxiradicals}', ""); +Expect(0, 12255, '\P{Is_Block: kangxiradicals}', ""); +Expect(1, 12255, '\P{^Is_Block: kangxiradicals}', ""); +Expect(0, 12031, '\p{Is_Block: kangxiradicals}', ""); +Expect(1, 12031, '\p{^Is_Block: kangxiradicals}', ""); +Expect(1, 12031, '\P{Is_Block: kangxiradicals}', ""); +Expect(0, 12031, '\P{^Is_Block: kangxiradicals}', ""); +Expect(1, 12255, '\p{Is_Block: - kangxiradicals}', ""); +Expect(0, 12255, '\p{^Is_Block: - kangxiradicals}', ""); +Expect(0, 12255, '\P{Is_Block: - kangxiradicals}', ""); +Expect(1, 12255, '\P{^Is_Block: - kangxiradicals}', ""); +Expect(0, 12031, '\p{Is_Block: - kangxiradicals}', ""); +Expect(1, 12031, '\p{^Is_Block: - kangxiradicals}', ""); +Expect(1, 12031, '\P{Is_Block: - kangxiradicals}', ""); +Expect(0, 12031, '\P{^Is_Block: - kangxiradicals}', ""); +Error('\p{Is_Blk=:=_kangxi-radicals}'); +Error('\P{Is_Blk=:=_kangxi-radicals}'); +Expect(1, 12255, '\p{Is_Blk=kangxiradicals}', ""); +Expect(0, 12255, '\p{^Is_Blk=kangxiradicals}', ""); +Expect(0, 12255, '\P{Is_Blk=kangxiradicals}', ""); +Expect(1, 12255, '\P{^Is_Blk=kangxiradicals}', ""); +Expect(0, 12031, '\p{Is_Blk=kangxiradicals}', ""); +Expect(1, 12031, '\p{^Is_Blk=kangxiradicals}', ""); +Expect(1, 12031, '\P{Is_Blk=kangxiradicals}', ""); +Expect(0, 12031, '\P{^Is_Blk=kangxiradicals}', ""); +Expect(1, 12255, '\p{Is_Blk= KangxiRadicals}', ""); +Expect(0, 12255, '\p{^Is_Blk= KangxiRadicals}', ""); +Expect(0, 12255, '\P{Is_Blk= KangxiRadicals}', ""); +Expect(1, 12255, '\P{^Is_Blk= KangxiRadicals}', ""); +Expect(0, 12031, '\p{Is_Blk= KangxiRadicals}', ""); +Expect(1, 12031, '\p{^Is_Blk= KangxiRadicals}', ""); +Expect(1, 12031, '\P{Is_Blk= KangxiRadicals}', ""); +Expect(0, 12031, '\P{^Is_Blk= KangxiRadicals}', ""); +Error('\p{Block=_:=Arabic-presentationForms B}'); +Error('\P{Block=_:=Arabic-presentationForms B}'); +Expect(1, 65279, '\p{Block=arabicpresentationformsb}', ""); +Expect(0, 65279, '\p{^Block=arabicpresentationformsb}', ""); +Expect(0, 65279, '\P{Block=arabicpresentationformsb}', ""); +Expect(1, 65279, '\P{^Block=arabicpresentationformsb}', ""); +Expect(0, 65135, '\p{Block=arabicpresentationformsb}', ""); +Expect(1, 65135, '\p{^Block=arabicpresentationformsb}', ""); +Expect(1, 65135, '\P{Block=arabicpresentationformsb}', ""); +Expect(0, 65135, '\P{^Block=arabicpresentationformsb}', ""); +Expect(1, 65279, '\p{Block= _arabicPresentation FORMS_b}', ""); +Expect(0, 65279, '\p{^Block= _arabicPresentation FORMS_b}', ""); +Expect(0, 65279, '\P{Block= _arabicPresentation FORMS_b}', ""); +Expect(1, 65279, '\P{^Block= _arabicPresentation FORMS_b}', ""); +Expect(0, 65135, '\p{Block= _arabicPresentation FORMS_b}', ""); +Expect(1, 65135, '\p{^Block= _arabicPresentation FORMS_b}', ""); +Expect(1, 65135, '\P{Block= _arabicPresentation FORMS_b}', ""); +Expect(0, 65135, '\P{^Block= _arabicPresentation FORMS_b}', ""); +Error('\p{Blk: -:=arabic presentation Forms B}'); +Error('\P{Blk: -:=arabic presentation Forms B}'); +Expect(1, 65279, '\p{Blk=arabicpresentationformsb}', ""); +Expect(0, 65279, '\p{^Blk=arabicpresentationformsb}', ""); +Expect(0, 65279, '\P{Blk=arabicpresentationformsb}', ""); +Expect(1, 65279, '\P{^Blk=arabicpresentationformsb}', ""); +Expect(0, 65135, '\p{Blk=arabicpresentationformsb}', ""); +Expect(1, 65135, '\p{^Blk=arabicpresentationformsb}', ""); +Expect(1, 65135, '\P{Blk=arabicpresentationformsb}', ""); +Expect(0, 65135, '\P{^Blk=arabicpresentationformsb}', ""); +Expect(1, 65279, '\p{Blk=_ARABIC_Presentation_FormsB}', ""); +Expect(0, 65279, '\p{^Blk=_ARABIC_Presentation_FormsB}', ""); +Expect(0, 65279, '\P{Blk=_ARABIC_Presentation_FormsB}', ""); +Expect(1, 65279, '\P{^Blk=_ARABIC_Presentation_FormsB}', ""); +Expect(0, 65135, '\p{Blk=_ARABIC_Presentation_FormsB}', ""); +Expect(1, 65135, '\p{^Blk=_ARABIC_Presentation_FormsB}', ""); +Expect(1, 65135, '\P{Blk=_ARABIC_Presentation_FormsB}', ""); +Expect(0, 65135, '\P{^Blk=_ARABIC_Presentation_FormsB}', ""); +Error('\p{Is_Block= :=ArabicPRESENTATIONFORMSB}'); +Error('\P{Is_Block= :=ArabicPRESENTATIONFORMSB}'); +Expect(1, 65279, '\p{Is_Block=arabicpresentationformsb}', ""); +Expect(0, 65279, '\p{^Is_Block=arabicpresentationformsb}', ""); +Expect(0, 65279, '\P{Is_Block=arabicpresentationformsb}', ""); +Expect(1, 65279, '\P{^Is_Block=arabicpresentationformsb}', ""); +Expect(0, 65135, '\p{Is_Block=arabicpresentationformsb}', ""); +Expect(1, 65135, '\p{^Is_Block=arabicpresentationformsb}', ""); +Expect(1, 65135, '\P{Is_Block=arabicpresentationformsb}', ""); +Expect(0, 65135, '\P{^Is_Block=arabicpresentationformsb}', ""); +Expect(1, 65279, '\p{Is_Block= -ARABIC PRESENTATION Forms-B}', ""); +Expect(0, 65279, '\p{^Is_Block= -ARABIC PRESENTATION Forms-B}', ""); +Expect(0, 65279, '\P{Is_Block= -ARABIC PRESENTATION Forms-B}', ""); +Expect(1, 65279, '\P{^Is_Block= -ARABIC PRESENTATION Forms-B}', ""); +Expect(0, 65135, '\p{Is_Block= -ARABIC PRESENTATION Forms-B}', ""); +Expect(1, 65135, '\p{^Is_Block= -ARABIC PRESENTATION Forms-B}', ""); +Expect(1, 65135, '\P{Is_Block= -ARABIC PRESENTATION Forms-B}', ""); +Expect(0, 65135, '\P{^Is_Block= -ARABIC PRESENTATION Forms-B}', ""); +Error('\p{Is_Blk= ARABIC/a/Presentation-forms B}'); +Error('\P{Is_Blk= ARABIC/a/Presentation-forms B}'); +Expect(1, 65279, '\p{Is_Blk=arabicpresentationformsb}', ""); +Expect(0, 65279, '\p{^Is_Blk=arabicpresentationformsb}', ""); +Expect(0, 65279, '\P{Is_Blk=arabicpresentationformsb}', ""); +Expect(1, 65279, '\P{^Is_Blk=arabicpresentationformsb}', ""); +Expect(0, 65135, '\p{Is_Blk=arabicpresentationformsb}', ""); +Expect(1, 65135, '\p{^Is_Blk=arabicpresentationformsb}', ""); +Expect(1, 65135, '\P{Is_Blk=arabicpresentationformsb}', ""); +Expect(0, 65135, '\P{^Is_Blk=arabicpresentationformsb}', ""); +Expect(1, 65279, '\p{Is_Blk:- arabic-presentation FORMS-B}', ""); +Expect(0, 65279, '\p{^Is_Blk:- arabic-presentation FORMS-B}', ""); +Expect(0, 65279, '\P{Is_Blk:- arabic-presentation FORMS-B}', ""); +Expect(1, 65279, '\P{^Is_Blk:- arabic-presentation FORMS-B}', ""); +Expect(0, 65135, '\p{Is_Blk:- arabic-presentation FORMS-B}', ""); +Expect(1, 65135, '\p{^Is_Blk:- arabic-presentation FORMS-B}', ""); +Expect(1, 65135, '\P{Is_Blk:- arabic-presentation FORMS-B}', ""); +Expect(0, 65135, '\P{^Is_Blk:- arabic-presentation FORMS-B}', ""); +Error('\p{Block=-:=Gurmukhi}'); +Error('\P{Block=-:=Gurmukhi}'); +Expect(1, 2687, '\p{Block: gurmukhi}', ""); +Expect(0, 2687, '\p{^Block: gurmukhi}', ""); +Expect(0, 2687, '\P{Block: gurmukhi}', ""); +Expect(1, 2687, '\P{^Block: gurmukhi}', ""); +Expect(0, 2559, '\p{Block: gurmukhi}', ""); +Expect(1, 2559, '\p{^Block: gurmukhi}', ""); +Expect(1, 2559, '\P{Block: gurmukhi}', ""); +Expect(0, 2559, '\P{^Block: gurmukhi}', ""); +Expect(1, 2687, '\p{Block= GURMUKHI}', ""); +Expect(0, 2687, '\p{^Block= GURMUKHI}', ""); +Expect(0, 2687, '\P{Block= GURMUKHI}', ""); +Expect(1, 2687, '\P{^Block= GURMUKHI}', ""); +Expect(0, 2559, '\p{Block= GURMUKHI}', ""); +Expect(1, 2559, '\p{^Block= GURMUKHI}', ""); +Expect(1, 2559, '\P{Block= GURMUKHI}', ""); +Expect(0, 2559, '\P{^Block= GURMUKHI}', ""); +Error('\p{Blk= :=gurmukhi}'); +Error('\P{Blk= :=gurmukhi}'); +Expect(1, 2687, '\p{Blk=gurmukhi}', ""); +Expect(0, 2687, '\p{^Blk=gurmukhi}', ""); +Expect(0, 2687, '\P{Blk=gurmukhi}', ""); +Expect(1, 2687, '\P{^Blk=gurmukhi}', ""); +Expect(0, 2559, '\p{Blk=gurmukhi}', ""); +Expect(1, 2559, '\p{^Blk=gurmukhi}', ""); +Expect(1, 2559, '\P{Blk=gurmukhi}', ""); +Expect(0, 2559, '\P{^Blk=gurmukhi}', ""); +Expect(1, 2687, '\p{Blk=-Gurmukhi}', ""); +Expect(0, 2687, '\p{^Blk=-Gurmukhi}', ""); +Expect(0, 2687, '\P{Blk=-Gurmukhi}', ""); +Expect(1, 2687, '\P{^Blk=-Gurmukhi}', ""); +Expect(0, 2559, '\p{Blk=-Gurmukhi}', ""); +Expect(1, 2559, '\p{^Blk=-Gurmukhi}', ""); +Expect(1, 2559, '\P{Blk=-Gurmukhi}', ""); +Expect(0, 2559, '\P{^Blk=-Gurmukhi}', ""); +Error('\p{Is_Block= -GURMUKHI:=}'); +Error('\P{Is_Block= -GURMUKHI:=}'); +Expect(1, 2687, '\p{Is_Block=gurmukhi}', ""); +Expect(0, 2687, '\p{^Is_Block=gurmukhi}', ""); +Expect(0, 2687, '\P{Is_Block=gurmukhi}', ""); +Expect(1, 2687, '\P{^Is_Block=gurmukhi}', ""); +Expect(0, 2559, '\p{Is_Block=gurmukhi}', ""); +Expect(1, 2559, '\p{^Is_Block=gurmukhi}', ""); +Expect(1, 2559, '\P{Is_Block=gurmukhi}', ""); +Expect(0, 2559, '\P{^Is_Block=gurmukhi}', ""); +Expect(1, 2687, '\p{Is_Block: gurmukhi}', ""); +Expect(0, 2687, '\p{^Is_Block: gurmukhi}', ""); +Expect(0, 2687, '\P{Is_Block: gurmukhi}', ""); +Expect(1, 2687, '\P{^Is_Block: gurmukhi}', ""); +Expect(0, 2559, '\p{Is_Block: gurmukhi}', ""); +Expect(1, 2559, '\p{^Is_Block: gurmukhi}', ""); +Expect(1, 2559, '\P{Is_Block: gurmukhi}', ""); +Expect(0, 2559, '\P{^Is_Block: gurmukhi}', ""); +Error('\p{Is_Blk=/a/ Gurmukhi}'); +Error('\P{Is_Blk=/a/ Gurmukhi}'); +Expect(1, 2687, '\p{Is_Blk=gurmukhi}', ""); +Expect(0, 2687, '\p{^Is_Blk=gurmukhi}', ""); +Expect(0, 2687, '\P{Is_Blk=gurmukhi}', ""); +Expect(1, 2687, '\P{^Is_Blk=gurmukhi}', ""); +Expect(0, 2559, '\p{Is_Blk=gurmukhi}', ""); +Expect(1, 2559, '\p{^Is_Blk=gurmukhi}', ""); +Expect(1, 2559, '\P{Is_Blk=gurmukhi}', ""); +Expect(0, 2559, '\P{^Is_Blk=gurmukhi}', ""); +Expect(1, 2687, '\p{Is_Blk: __Gurmukhi}', ""); +Expect(0, 2687, '\p{^Is_Blk: __Gurmukhi}', ""); +Expect(0, 2687, '\P{Is_Blk: __Gurmukhi}', ""); +Expect(1, 2687, '\P{^Is_Blk: __Gurmukhi}', ""); +Expect(0, 2559, '\p{Is_Blk: __Gurmukhi}', ""); +Expect(1, 2559, '\p{^Is_Blk: __Gurmukhi}', ""); +Expect(1, 2559, '\P{Is_Blk: __Gurmukhi}', ""); +Expect(0, 2559, '\P{^Is_Blk: __Gurmukhi}', ""); +Error('\p{Block= /a/PHONETIC Extensions Supplement}'); +Error('\P{Block= /a/PHONETIC Extensions Supplement}'); +Expect(1, 7615, '\p{Block=phoneticextensionssupplement}', ""); +Expect(0, 7615, '\p{^Block=phoneticextensionssupplement}', ""); +Expect(0, 7615, '\P{Block=phoneticextensionssupplement}', ""); +Expect(1, 7615, '\P{^Block=phoneticextensionssupplement}', ""); +Expect(0, 7551, '\p{Block=phoneticextensionssupplement}', ""); +Expect(1, 7551, '\p{^Block=phoneticextensionssupplement}', ""); +Expect(1, 7551, '\P{Block=phoneticextensionssupplement}', ""); +Expect(0, 7551, '\P{^Block=phoneticextensionssupplement}', ""); +Expect(1, 7615, '\p{Block: PHONETIC extensions SUPPLEMENT}', ""); +Expect(0, 7615, '\p{^Block: PHONETIC extensions SUPPLEMENT}', ""); +Expect(0, 7615, '\P{Block: PHONETIC extensions SUPPLEMENT}', ""); +Expect(1, 7615, '\P{^Block: PHONETIC extensions SUPPLEMENT}', ""); +Expect(0, 7551, '\p{Block: PHONETIC extensions SUPPLEMENT}', ""); +Expect(1, 7551, '\p{^Block: PHONETIC extensions SUPPLEMENT}', ""); +Expect(1, 7551, '\P{Block: PHONETIC extensions SUPPLEMENT}', ""); +Expect(0, 7551, '\P{^Block: PHONETIC extensions SUPPLEMENT}', ""); +Error('\p{Blk= -Phonetic:=Extensions_Supplement}'); +Error('\P{Blk= -Phonetic:=Extensions_Supplement}'); +Expect(1, 7615, '\p{Blk=phoneticextensionssupplement}', ""); +Expect(0, 7615, '\p{^Blk=phoneticextensionssupplement}', ""); +Expect(0, 7615, '\P{Blk=phoneticextensionssupplement}', ""); +Expect(1, 7615, '\P{^Blk=phoneticextensionssupplement}', ""); +Expect(0, 7551, '\p{Blk=phoneticextensionssupplement}', ""); +Expect(1, 7551, '\p{^Blk=phoneticextensionssupplement}', ""); +Expect(1, 7551, '\P{Blk=phoneticextensionssupplement}', ""); +Expect(0, 7551, '\P{^Blk=phoneticextensionssupplement}', ""); +Expect(1, 7615, '\p{Blk:_Phonetic_Extensionssupplement}', ""); +Expect(0, 7615, '\p{^Blk:_Phonetic_Extensionssupplement}', ""); +Expect(0, 7615, '\P{Blk:_Phonetic_Extensionssupplement}', ""); +Expect(1, 7615, '\P{^Blk:_Phonetic_Extensionssupplement}', ""); +Expect(0, 7551, '\p{Blk:_Phonetic_Extensionssupplement}', ""); +Expect(1, 7551, '\p{^Blk:_Phonetic_Extensionssupplement}', ""); +Expect(1, 7551, '\P{Blk:_Phonetic_Extensionssupplement}', ""); +Expect(0, 7551, '\P{^Blk:_Phonetic_Extensionssupplement}', ""); +Error('\p{Is_Block=-/a/Phonetic_Extensions SUPPLEMENT}'); +Error('\P{Is_Block=-/a/Phonetic_Extensions SUPPLEMENT}'); +Expect(1, 7615, '\p{Is_Block=phoneticextensionssupplement}', ""); +Expect(0, 7615, '\p{^Is_Block=phoneticextensionssupplement}', ""); +Expect(0, 7615, '\P{Is_Block=phoneticextensionssupplement}', ""); +Expect(1, 7615, '\P{^Is_Block=phoneticextensionssupplement}', ""); +Expect(0, 7551, '\p{Is_Block=phoneticextensionssupplement}', ""); +Expect(1, 7551, '\p{^Is_Block=phoneticextensionssupplement}', ""); +Expect(1, 7551, '\P{Is_Block=phoneticextensionssupplement}', ""); +Expect(0, 7551, '\P{^Is_Block=phoneticextensionssupplement}', ""); +Expect(1, 7615, '\p{Is_Block=-_Phonetic EXTENSIONS Supplement}', ""); +Expect(0, 7615, '\p{^Is_Block=-_Phonetic EXTENSIONS Supplement}', ""); +Expect(0, 7615, '\P{Is_Block=-_Phonetic EXTENSIONS Supplement}', ""); +Expect(1, 7615, '\P{^Is_Block=-_Phonetic EXTENSIONS Supplement}', ""); +Expect(0, 7551, '\p{Is_Block=-_Phonetic EXTENSIONS Supplement}', ""); +Expect(1, 7551, '\p{^Is_Block=-_Phonetic EXTENSIONS Supplement}', ""); +Expect(1, 7551, '\P{Is_Block=-_Phonetic EXTENSIONS Supplement}', ""); +Expect(0, 7551, '\P{^Is_Block=-_Phonetic EXTENSIONS Supplement}', ""); +Error('\p{Is_Blk= _PHONETIC-Extensions Supplement:=}'); +Error('\P{Is_Blk= _PHONETIC-Extensions Supplement:=}'); +Expect(1, 7615, '\p{Is_Blk=phoneticextensionssupplement}', ""); +Expect(0, 7615, '\p{^Is_Blk=phoneticextensionssupplement}', ""); +Expect(0, 7615, '\P{Is_Blk=phoneticextensionssupplement}', ""); +Expect(1, 7615, '\P{^Is_Blk=phoneticextensionssupplement}', ""); +Expect(0, 7551, '\p{Is_Blk=phoneticextensionssupplement}', ""); +Expect(1, 7551, '\p{^Is_Blk=phoneticextensionssupplement}', ""); +Expect(1, 7551, '\P{Is_Blk=phoneticextensionssupplement}', ""); +Expect(0, 7551, '\P{^Is_Blk=phoneticextensionssupplement}', ""); +Expect(1, 7615, '\p{Is_Blk= Phonetic EXTENSIONS supplement}', ""); +Expect(0, 7615, '\p{^Is_Blk= Phonetic EXTENSIONS supplement}', ""); +Expect(0, 7615, '\P{Is_Blk= Phonetic EXTENSIONS supplement}', ""); +Expect(1, 7615, '\P{^Is_Blk= Phonetic EXTENSIONS supplement}', ""); +Expect(0, 7551, '\p{Is_Blk= Phonetic EXTENSIONS supplement}', ""); +Expect(1, 7551, '\p{^Is_Blk= Phonetic EXTENSIONS supplement}', ""); +Expect(1, 7551, '\P{Is_Blk= Phonetic EXTENSIONS supplement}', ""); +Expect(0, 7551, '\P{^Is_Blk= Phonetic EXTENSIONS supplement}', ""); +Error('\p{Block=/a/greek Extended}'); +Error('\P{Block=/a/greek Extended}'); +Expect(1, 8191, '\p{Block=greekextended}', ""); +Expect(0, 8191, '\p{^Block=greekextended}', ""); +Expect(0, 8191, '\P{Block=greekextended}', ""); +Expect(1, 8191, '\P{^Block=greekextended}', ""); +Expect(0, 7935, '\p{Block=greekextended}', ""); +Expect(1, 7935, '\p{^Block=greekextended}', ""); +Expect(1, 7935, '\P{Block=greekextended}', ""); +Expect(0, 7935, '\P{^Block=greekextended}', ""); +Expect(1, 8191, '\p{Block= Greek EXTENDED}', ""); +Expect(0, 8191, '\p{^Block= Greek EXTENDED}', ""); +Expect(0, 8191, '\P{Block= Greek EXTENDED}', ""); +Expect(1, 8191, '\P{^Block= Greek EXTENDED}', ""); +Expect(0, 7935, '\p{Block= Greek EXTENDED}', ""); +Expect(1, 7935, '\p{^Block= Greek EXTENDED}', ""); +Expect(1, 7935, '\P{Block= Greek EXTENDED}', ""); +Expect(0, 7935, '\P{^Block= Greek EXTENDED}', ""); +Error('\p{Blk=/a/__greek Extended}'); +Error('\P{Blk=/a/__greek Extended}'); +Expect(1, 8191, '\p{Blk=greekextended}', ""); +Expect(0, 8191, '\p{^Blk=greekextended}', ""); +Expect(0, 8191, '\P{Blk=greekextended}', ""); +Expect(1, 8191, '\P{^Blk=greekextended}', ""); +Expect(0, 7935, '\p{Blk=greekextended}', ""); +Expect(1, 7935, '\p{^Blk=greekextended}', ""); +Expect(1, 7935, '\P{Blk=greekextended}', ""); +Expect(0, 7935, '\P{^Blk=greekextended}', ""); +Expect(1, 8191, '\p{Blk= greek-extended}', ""); +Expect(0, 8191, '\p{^Blk= greek-extended}', ""); +Expect(0, 8191, '\P{Blk= greek-extended}', ""); +Expect(1, 8191, '\P{^Blk= greek-extended}', ""); +Expect(0, 7935, '\p{Blk= greek-extended}', ""); +Expect(1, 7935, '\p{^Blk= greek-extended}', ""); +Expect(1, 7935, '\P{Blk= greek-extended}', ""); +Expect(0, 7935, '\P{^Blk= greek-extended}', ""); +Error('\p{Is_Block=-_greekExtended/a/}'); +Error('\P{Is_Block=-_greekExtended/a/}'); +Expect(1, 8191, '\p{Is_Block=greekextended}', ""); +Expect(0, 8191, '\p{^Is_Block=greekextended}', ""); +Expect(0, 8191, '\P{Is_Block=greekextended}', ""); +Expect(1, 8191, '\P{^Is_Block=greekextended}', ""); +Expect(0, 7935, '\p{Is_Block=greekextended}', ""); +Expect(1, 7935, '\p{^Is_Block=greekextended}', ""); +Expect(1, 7935, '\P{Is_Block=greekextended}', ""); +Expect(0, 7935, '\P{^Is_Block=greekextended}', ""); +Expect(1, 8191, '\p{Is_Block= greekExtended}', ""); +Expect(0, 8191, '\p{^Is_Block= greekExtended}', ""); +Expect(0, 8191, '\P{Is_Block= greekExtended}', ""); +Expect(1, 8191, '\P{^Is_Block= greekExtended}', ""); +Expect(0, 7935, '\p{Is_Block= greekExtended}', ""); +Expect(1, 7935, '\p{^Is_Block= greekExtended}', ""); +Expect(1, 7935, '\P{Is_Block= greekExtended}', ""); +Expect(0, 7935, '\P{^Is_Block= greekExtended}', ""); +Error('\p{Is_Blk: Greek EXTENDED/a/}'); +Error('\P{Is_Blk: Greek EXTENDED/a/}'); +Expect(1, 8191, '\p{Is_Blk=greekextended}', ""); +Expect(0, 8191, '\p{^Is_Blk=greekextended}', ""); +Expect(0, 8191, '\P{Is_Blk=greekextended}', ""); +Expect(1, 8191, '\P{^Is_Blk=greekextended}', ""); +Expect(0, 7935, '\p{Is_Blk=greekextended}', ""); +Expect(1, 7935, '\p{^Is_Blk=greekextended}', ""); +Expect(1, 7935, '\P{Is_Blk=greekextended}', ""); +Expect(0, 7935, '\P{^Is_Blk=greekextended}', ""); +Expect(1, 8191, '\p{Is_Blk=- Greek Extended}', ""); +Expect(0, 8191, '\p{^Is_Blk=- Greek Extended}', ""); +Expect(0, 8191, '\P{Is_Blk=- Greek Extended}', ""); +Expect(1, 8191, '\P{^Is_Blk=- Greek Extended}', ""); +Expect(0, 7935, '\p{Is_Blk=- Greek Extended}', ""); +Expect(1, 7935, '\p{^Is_Blk=- Greek Extended}', ""); +Expect(1, 7935, '\P{Is_Blk=- Greek Extended}', ""); +Expect(0, 7935, '\P{^Is_Blk=- Greek Extended}', ""); +Error('\p{Block=- Deseret:=}'); +Error('\P{Block=- Deseret:=}'); +Expect(1, 66639, '\p{Block=deseret}', ""); +Expect(0, 66639, '\p{^Block=deseret}', ""); +Expect(0, 66639, '\P{Block=deseret}', ""); +Expect(1, 66639, '\P{^Block=deseret}', ""); +Expect(0, 66559, '\p{Block=deseret}', ""); +Expect(1, 66559, '\p{^Block=deseret}', ""); +Expect(1, 66559, '\P{Block=deseret}', ""); +Expect(0, 66559, '\P{^Block=deseret}', ""); +Expect(1, 66639, '\p{Block: _Deseret}', ""); +Expect(0, 66639, '\p{^Block: _Deseret}', ""); +Expect(0, 66639, '\P{Block: _Deseret}', ""); +Expect(1, 66639, '\P{^Block: _Deseret}', ""); +Expect(0, 66559, '\p{Block: _Deseret}', ""); +Expect(1, 66559, '\p{^Block: _Deseret}', ""); +Expect(1, 66559, '\P{Block: _Deseret}', ""); +Expect(0, 66559, '\P{^Block: _Deseret}', ""); +Error('\p{Blk:/a/ Deseret}'); +Error('\P{Blk:/a/ Deseret}'); +Expect(1, 66639, '\p{Blk=deseret}', ""); +Expect(0, 66639, '\p{^Blk=deseret}', ""); +Expect(0, 66639, '\P{Blk=deseret}', ""); +Expect(1, 66639, '\P{^Blk=deseret}', ""); +Expect(0, 66559, '\p{Blk=deseret}', ""); +Expect(1, 66559, '\p{^Blk=deseret}', ""); +Expect(1, 66559, '\P{Blk=deseret}', ""); +Expect(0, 66559, '\P{^Blk=deseret}', ""); +Expect(1, 66639, '\p{Blk=_-Deseret}', ""); +Expect(0, 66639, '\p{^Blk=_-Deseret}', ""); +Expect(0, 66639, '\P{Blk=_-Deseret}', ""); +Expect(1, 66639, '\P{^Blk=_-Deseret}', ""); +Expect(0, 66559, '\p{Blk=_-Deseret}', ""); +Expect(1, 66559, '\p{^Blk=_-Deseret}', ""); +Expect(1, 66559, '\P{Blk=_-Deseret}', ""); +Expect(0, 66559, '\P{^Blk=_-Deseret}', ""); +Error('\p{Is_Block=:= _Deseret}'); +Error('\P{Is_Block=:= _Deseret}'); +Expect(1, 66639, '\p{Is_Block=deseret}', ""); +Expect(0, 66639, '\p{^Is_Block=deseret}', ""); +Expect(0, 66639, '\P{Is_Block=deseret}', ""); +Expect(1, 66639, '\P{^Is_Block=deseret}', ""); +Expect(0, 66559, '\p{Is_Block=deseret}', ""); +Expect(1, 66559, '\p{^Is_Block=deseret}', ""); +Expect(1, 66559, '\P{Is_Block=deseret}', ""); +Expect(0, 66559, '\P{^Is_Block=deseret}', ""); +Expect(1, 66639, '\p{Is_Block=- Deseret}', ""); +Expect(0, 66639, '\p{^Is_Block=- Deseret}', ""); +Expect(0, 66639, '\P{Is_Block=- Deseret}', ""); +Expect(1, 66639, '\P{^Is_Block=- Deseret}', ""); +Expect(0, 66559, '\p{Is_Block=- Deseret}', ""); +Expect(1, 66559, '\p{^Is_Block=- Deseret}', ""); +Expect(1, 66559, '\P{Is_Block=- Deseret}', ""); +Expect(0, 66559, '\P{^Is_Block=- Deseret}', ""); +Error('\p{Is_Blk= DESERET:=}'); +Error('\P{Is_Blk= DESERET:=}'); +Expect(1, 66639, '\p{Is_Blk=deseret}', ""); +Expect(0, 66639, '\p{^Is_Blk=deseret}', ""); +Expect(0, 66639, '\P{Is_Blk=deseret}', ""); +Expect(1, 66639, '\P{^Is_Blk=deseret}', ""); +Expect(0, 66559, '\p{Is_Blk=deseret}', ""); +Expect(1, 66559, '\p{^Is_Blk=deseret}', ""); +Expect(1, 66559, '\P{Is_Blk=deseret}', ""); +Expect(0, 66559, '\P{^Is_Blk=deseret}', ""); +Expect(1, 66639, '\p{Is_Blk= Deseret}', ""); +Expect(0, 66639, '\p{^Is_Blk= Deseret}', ""); +Expect(0, 66639, '\P{Is_Blk= Deseret}', ""); +Expect(1, 66639, '\P{^Is_Blk= Deseret}', ""); +Expect(0, 66559, '\p{Is_Blk= Deseret}', ""); +Expect(1, 66559, '\p{^Is_Blk= Deseret}', ""); +Expect(1, 66559, '\P{Is_Blk= Deseret}', ""); +Expect(0, 66559, '\P{^Is_Blk= Deseret}', ""); +Error('\p{Block: /a/tagbanwa}'); +Error('\P{Block: /a/tagbanwa}'); +Expect(1, 6015, '\p{Block=tagbanwa}', ""); +Expect(0, 6015, '\p{^Block=tagbanwa}', ""); +Expect(0, 6015, '\P{Block=tagbanwa}', ""); +Expect(1, 6015, '\P{^Block=tagbanwa}', ""); +Expect(0, 5983, '\p{Block=tagbanwa}', ""); +Expect(1, 5983, '\p{^Block=tagbanwa}', ""); +Expect(1, 5983, '\P{Block=tagbanwa}', ""); +Expect(0, 5983, '\P{^Block=tagbanwa}', ""); +Expect(1, 6015, '\p{Block=_ tagbanwa}', ""); +Expect(0, 6015, '\p{^Block=_ tagbanwa}', ""); +Expect(0, 6015, '\P{Block=_ tagbanwa}', ""); +Expect(1, 6015, '\P{^Block=_ tagbanwa}', ""); +Expect(0, 5983, '\p{Block=_ tagbanwa}', ""); +Expect(1, 5983, '\p{^Block=_ tagbanwa}', ""); +Expect(1, 5983, '\P{Block=_ tagbanwa}', ""); +Expect(0, 5983, '\P{^Block=_ tagbanwa}', ""); +Error('\p{Blk: /a/ -Tagbanwa}'); +Error('\P{Blk: /a/ -Tagbanwa}'); +Expect(1, 6015, '\p{Blk=tagbanwa}', ""); +Expect(0, 6015, '\p{^Blk=tagbanwa}', ""); +Expect(0, 6015, '\P{Blk=tagbanwa}', ""); +Expect(1, 6015, '\P{^Blk=tagbanwa}', ""); +Expect(0, 5983, '\p{Blk=tagbanwa}', ""); +Expect(1, 5983, '\p{^Blk=tagbanwa}', ""); +Expect(1, 5983, '\P{Blk=tagbanwa}', ""); +Expect(0, 5983, '\P{^Blk=tagbanwa}', ""); +Expect(1, 6015, '\p{Blk= Tagbanwa}', ""); +Expect(0, 6015, '\p{^Blk= Tagbanwa}', ""); +Expect(0, 6015, '\P{Blk= Tagbanwa}', ""); +Expect(1, 6015, '\P{^Blk= Tagbanwa}', ""); +Expect(0, 5983, '\p{Blk= Tagbanwa}', ""); +Expect(1, 5983, '\p{^Blk= Tagbanwa}', ""); +Expect(1, 5983, '\P{Blk= Tagbanwa}', ""); +Expect(0, 5983, '\P{^Blk= Tagbanwa}', ""); +Error('\p{Is_Block=-/a/tagbanwa}'); +Error('\P{Is_Block=-/a/tagbanwa}'); +Expect(1, 6015, '\p{Is_Block=tagbanwa}', ""); +Expect(0, 6015, '\p{^Is_Block=tagbanwa}', ""); +Expect(0, 6015, '\P{Is_Block=tagbanwa}', ""); +Expect(1, 6015, '\P{^Is_Block=tagbanwa}', ""); +Expect(0, 5983, '\p{Is_Block=tagbanwa}', ""); +Expect(1, 5983, '\p{^Is_Block=tagbanwa}', ""); +Expect(1, 5983, '\P{Is_Block=tagbanwa}', ""); +Expect(0, 5983, '\P{^Is_Block=tagbanwa}', ""); +Expect(1, 6015, '\p{Is_Block=_ Tagbanwa}', ""); +Expect(0, 6015, '\p{^Is_Block=_ Tagbanwa}', ""); +Expect(0, 6015, '\P{Is_Block=_ Tagbanwa}', ""); +Expect(1, 6015, '\P{^Is_Block=_ Tagbanwa}', ""); +Expect(0, 5983, '\p{Is_Block=_ Tagbanwa}', ""); +Expect(1, 5983, '\p{^Is_Block=_ Tagbanwa}', ""); +Expect(1, 5983, '\P{Is_Block=_ Tagbanwa}', ""); +Expect(0, 5983, '\P{^Is_Block=_ Tagbanwa}', ""); +Error('\p{Is_Blk=/a/_ TAGBANWA}'); +Error('\P{Is_Blk=/a/_ TAGBANWA}'); +Expect(1, 6015, '\p{Is_Blk: tagbanwa}', ""); +Expect(0, 6015, '\p{^Is_Blk: tagbanwa}', ""); +Expect(0, 6015, '\P{Is_Blk: tagbanwa}', ""); +Expect(1, 6015, '\P{^Is_Blk: tagbanwa}', ""); +Expect(0, 5983, '\p{Is_Blk: tagbanwa}', ""); +Expect(1, 5983, '\p{^Is_Blk: tagbanwa}', ""); +Expect(1, 5983, '\P{Is_Blk: tagbanwa}', ""); +Expect(0, 5983, '\P{^Is_Blk: tagbanwa}', ""); +Expect(1, 6015, '\p{Is_Blk=- tagbanwa}', ""); +Expect(0, 6015, '\p{^Is_Blk=- tagbanwa}', ""); +Expect(0, 6015, '\P{Is_Blk=- tagbanwa}', ""); +Expect(1, 6015, '\P{^Is_Blk=- tagbanwa}', ""); +Expect(0, 5983, '\p{Is_Blk=- tagbanwa}', ""); +Expect(1, 5983, '\p{^Is_Blk=- tagbanwa}', ""); +Expect(1, 5983, '\P{Is_Blk=- tagbanwa}', ""); +Expect(0, 5983, '\P{^Is_Blk=- tagbanwa}', ""); +Error('\p{Block=:= ARABIC}'); +Error('\P{Block=:= ARABIC}'); +Expect(1, 1791, '\p{Block=arabic}', ""); +Expect(0, 1791, '\p{^Block=arabic}', ""); +Expect(0, 1791, '\P{Block=arabic}', ""); +Expect(1, 1791, '\P{^Block=arabic}', ""); +Expect(0, 1535, '\p{Block=arabic}', ""); +Expect(1, 1535, '\p{^Block=arabic}', ""); +Expect(1, 1535, '\P{Block=arabic}', ""); +Expect(0, 1535, '\P{^Block=arabic}', ""); +Expect(1, 1791, '\p{Block=-Arabic}', ""); +Expect(0, 1791, '\p{^Block=-Arabic}', ""); +Expect(0, 1791, '\P{Block=-Arabic}', ""); +Expect(1, 1791, '\P{^Block=-Arabic}', ""); +Expect(0, 1535, '\p{Block=-Arabic}', ""); +Expect(1, 1535, '\p{^Block=-Arabic}', ""); +Expect(1, 1535, '\P{Block=-Arabic}', ""); +Expect(0, 1535, '\P{^Block=-Arabic}', ""); +Error('\p{Blk:-/a/Arabic}'); +Error('\P{Blk:-/a/Arabic}'); +Expect(1, 1791, '\p{Blk=arabic}', ""); +Expect(0, 1791, '\p{^Blk=arabic}', ""); +Expect(0, 1791, '\P{Blk=arabic}', ""); +Expect(1, 1791, '\P{^Blk=arabic}', ""); +Expect(0, 1535, '\p{Blk=arabic}', ""); +Expect(1, 1535, '\p{^Blk=arabic}', ""); +Expect(1, 1535, '\P{Blk=arabic}', ""); +Expect(0, 1535, '\P{^Blk=arabic}', ""); +Expect(1, 1791, '\p{Blk: arabic}', ""); +Expect(0, 1791, '\p{^Blk: arabic}', ""); +Expect(0, 1791, '\P{Blk: arabic}', ""); +Expect(1, 1791, '\P{^Blk: arabic}', ""); +Expect(0, 1535, '\p{Blk: arabic}', ""); +Expect(1, 1535, '\p{^Blk: arabic}', ""); +Expect(1, 1535, '\P{Blk: arabic}', ""); +Expect(0, 1535, '\P{^Blk: arabic}', ""); +Error('\p{Is_Block= _Arabic:=}'); +Error('\P{Is_Block= _Arabic:=}'); +Expect(1, 1791, '\p{Is_Block=arabic}', ""); +Expect(0, 1791, '\p{^Is_Block=arabic}', ""); +Expect(0, 1791, '\P{Is_Block=arabic}', ""); +Expect(1, 1791, '\P{^Is_Block=arabic}', ""); +Expect(0, 1535, '\p{Is_Block=arabic}', ""); +Expect(1, 1535, '\p{^Is_Block=arabic}', ""); +Expect(1, 1535, '\P{Is_Block=arabic}', ""); +Expect(0, 1535, '\P{^Is_Block=arabic}', ""); +Expect(1, 1791, '\p{Is_Block=-ARABIC}', ""); +Expect(0, 1791, '\p{^Is_Block=-ARABIC}', ""); +Expect(0, 1791, '\P{Is_Block=-ARABIC}', ""); +Expect(1, 1791, '\P{^Is_Block=-ARABIC}', ""); +Expect(0, 1535, '\p{Is_Block=-ARABIC}', ""); +Expect(1, 1535, '\p{^Is_Block=-ARABIC}', ""); +Expect(1, 1535, '\P{Is_Block=-ARABIC}', ""); +Expect(0, 1535, '\P{^Is_Block=-ARABIC}', ""); +Error('\p{Is_Blk::=_ Arabic}'); +Error('\P{Is_Blk::=_ Arabic}'); +Expect(1, 1791, '\p{Is_Blk=arabic}', ""); +Expect(0, 1791, '\p{^Is_Blk=arabic}', ""); +Expect(0, 1791, '\P{Is_Blk=arabic}', ""); +Expect(1, 1791, '\P{^Is_Blk=arabic}', ""); +Expect(0, 1535, '\p{Is_Blk=arabic}', ""); +Expect(1, 1535, '\p{^Is_Blk=arabic}', ""); +Expect(1, 1535, '\P{Is_Blk=arabic}', ""); +Expect(0, 1535, '\P{^Is_Blk=arabic}', ""); +Expect(1, 1791, '\p{Is_Blk=-Arabic}', ""); +Expect(0, 1791, '\p{^Is_Blk=-Arabic}', ""); +Expect(0, 1791, '\P{Is_Blk=-Arabic}', ""); +Expect(1, 1791, '\P{^Is_Blk=-Arabic}', ""); +Expect(0, 1535, '\p{Is_Blk=-Arabic}', ""); +Expect(1, 1535, '\p{^Is_Blk=-Arabic}', ""); +Expect(1, 1535, '\P{Is_Blk=-Arabic}', ""); +Expect(0, 1535, '\P{^Is_Blk=-Arabic}', ""); +Error('\p{Block= Katakana_Phonetic Extensions/a/}'); +Error('\P{Block= Katakana_Phonetic Extensions/a/}'); +Expect(1, 12799, '\p{Block: katakanaphoneticextensions}', ""); +Expect(0, 12799, '\p{^Block: katakanaphoneticextensions}', ""); +Expect(0, 12799, '\P{Block: katakanaphoneticextensions}', ""); +Expect(1, 12799, '\P{^Block: katakanaphoneticextensions}', ""); +Expect(0, 12783, '\p{Block: katakanaphoneticextensions}', ""); +Expect(1, 12783, '\p{^Block: katakanaphoneticextensions}', ""); +Expect(1, 12783, '\P{Block: katakanaphoneticextensions}', ""); +Expect(0, 12783, '\P{^Block: katakanaphoneticextensions}', ""); +Expect(1, 12799, '\p{Block= -Katakana phonetic_EXTENSIONS}', ""); +Expect(0, 12799, '\p{^Block= -Katakana phonetic_EXTENSIONS}', ""); +Expect(0, 12799, '\P{Block= -Katakana phonetic_EXTENSIONS}', ""); +Expect(1, 12799, '\P{^Block= -Katakana phonetic_EXTENSIONS}', ""); +Expect(0, 12783, '\p{Block= -Katakana phonetic_EXTENSIONS}', ""); +Expect(1, 12783, '\p{^Block= -Katakana phonetic_EXTENSIONS}', ""); +Expect(1, 12783, '\P{Block= -Katakana phonetic_EXTENSIONS}', ""); +Expect(0, 12783, '\P{^Block= -Katakana phonetic_EXTENSIONS}', ""); +Error('\p{Blk: -_KatakanaPHONETIC Extensions:=}'); +Error('\P{Blk: -_KatakanaPHONETIC Extensions:=}'); +Expect(1, 12799, '\p{Blk=katakanaphoneticextensions}', ""); +Expect(0, 12799, '\p{^Blk=katakanaphoneticextensions}', ""); +Expect(0, 12799, '\P{Blk=katakanaphoneticextensions}', ""); +Expect(1, 12799, '\P{^Blk=katakanaphoneticextensions}', ""); +Expect(0, 12783, '\p{Blk=katakanaphoneticextensions}', ""); +Expect(1, 12783, '\p{^Blk=katakanaphoneticextensions}', ""); +Expect(1, 12783, '\P{Blk=katakanaphoneticextensions}', ""); +Expect(0, 12783, '\P{^Blk=katakanaphoneticextensions}', ""); +Expect(1, 12799, '\p{Blk= _Katakana-phonetic_EXTENSIONS}', ""); +Expect(0, 12799, '\p{^Blk= _Katakana-phonetic_EXTENSIONS}', ""); +Expect(0, 12799, '\P{Blk= _Katakana-phonetic_EXTENSIONS}', ""); +Expect(1, 12799, '\P{^Blk= _Katakana-phonetic_EXTENSIONS}', ""); +Expect(0, 12783, '\p{Blk= _Katakana-phonetic_EXTENSIONS}', ""); +Expect(1, 12783, '\p{^Blk= _Katakana-phonetic_EXTENSIONS}', ""); +Expect(1, 12783, '\P{Blk= _Katakana-phonetic_EXTENSIONS}', ""); +Expect(0, 12783, '\P{^Blk= _Katakana-phonetic_EXTENSIONS}', ""); +Error('\p{Is_Block: -Katakana:=phonetic-EXTENSIONS}'); +Error('\P{Is_Block: -Katakana:=phonetic-EXTENSIONS}'); +Expect(1, 12799, '\p{Is_Block=katakanaphoneticextensions}', ""); +Expect(0, 12799, '\p{^Is_Block=katakanaphoneticextensions}', ""); +Expect(0, 12799, '\P{Is_Block=katakanaphoneticextensions}', ""); +Expect(1, 12799, '\P{^Is_Block=katakanaphoneticextensions}', ""); +Expect(0, 12783, '\p{Is_Block=katakanaphoneticextensions}', ""); +Expect(1, 12783, '\p{^Is_Block=katakanaphoneticextensions}', ""); +Expect(1, 12783, '\P{Is_Block=katakanaphoneticextensions}', ""); +Expect(0, 12783, '\P{^Is_Block=katakanaphoneticextensions}', ""); +Expect(1, 12799, '\p{Is_Block=_-Katakana Phonetic EXTENSIONS}', ""); +Expect(0, 12799, '\p{^Is_Block=_-Katakana Phonetic EXTENSIONS}', ""); +Expect(0, 12799, '\P{Is_Block=_-Katakana Phonetic EXTENSIONS}', ""); +Expect(1, 12799, '\P{^Is_Block=_-Katakana Phonetic EXTENSIONS}', ""); +Expect(0, 12783, '\p{Is_Block=_-Katakana Phonetic EXTENSIONS}', ""); +Expect(1, 12783, '\p{^Is_Block=_-Katakana Phonetic EXTENSIONS}', ""); +Expect(1, 12783, '\P{Is_Block=_-Katakana Phonetic EXTENSIONS}', ""); +Expect(0, 12783, '\P{^Is_Block=_-Katakana Phonetic EXTENSIONS}', ""); +Error('\p{Is_Blk=_-KATAKANA/a/Phonetic_EXTENSIONS}'); +Error('\P{Is_Blk=_-KATAKANA/a/Phonetic_EXTENSIONS}'); +Expect(1, 12799, '\p{Is_Blk=katakanaphoneticextensions}', ""); +Expect(0, 12799, '\p{^Is_Blk=katakanaphoneticextensions}', ""); +Expect(0, 12799, '\P{Is_Blk=katakanaphoneticextensions}', ""); +Expect(1, 12799, '\P{^Is_Blk=katakanaphoneticextensions}', ""); +Expect(0, 12783, '\p{Is_Blk=katakanaphoneticextensions}', ""); +Expect(1, 12783, '\p{^Is_Blk=katakanaphoneticextensions}', ""); +Expect(1, 12783, '\P{Is_Blk=katakanaphoneticextensions}', ""); +Expect(0, 12783, '\P{^Is_Blk=katakanaphoneticextensions}', ""); +Expect(1, 12799, '\p{Is_Blk= -katakana Phonetic EXTENSIONS}', ""); +Expect(0, 12799, '\p{^Is_Blk= -katakana Phonetic EXTENSIONS}', ""); +Expect(0, 12799, '\P{Is_Blk= -katakana Phonetic EXTENSIONS}', ""); +Expect(1, 12799, '\P{^Is_Blk= -katakana Phonetic EXTENSIONS}', ""); +Expect(0, 12783, '\p{Is_Blk= -katakana Phonetic EXTENSIONS}', ""); +Expect(1, 12783, '\p{^Is_Blk= -katakana Phonetic EXTENSIONS}', ""); +Expect(1, 12783, '\P{Is_Blk= -katakana Phonetic EXTENSIONS}', ""); +Expect(0, 12783, '\P{^Is_Blk= -katakana Phonetic EXTENSIONS}', ""); +Error('\p{Block=--Letterlike:=Symbols}'); +Error('\P{Block=--Letterlike:=Symbols}'); +Expect(1, 8527, '\p{Block=letterlikesymbols}', ""); +Expect(0, 8527, '\p{^Block=letterlikesymbols}', ""); +Expect(0, 8527, '\P{Block=letterlikesymbols}', ""); +Expect(1, 8527, '\P{^Block=letterlikesymbols}', ""); +Expect(0, 8447, '\p{Block=letterlikesymbols}', ""); +Expect(1, 8447, '\p{^Block=letterlikesymbols}', ""); +Expect(1, 8447, '\P{Block=letterlikesymbols}', ""); +Expect(0, 8447, '\P{^Block=letterlikesymbols}', ""); +Expect(1, 8527, '\p{Block=- LETTERLIKE Symbols}', ""); +Expect(0, 8527, '\p{^Block=- LETTERLIKE Symbols}', ""); +Expect(0, 8527, '\P{Block=- LETTERLIKE Symbols}', ""); +Expect(1, 8527, '\P{^Block=- LETTERLIKE Symbols}', ""); +Expect(0, 8447, '\p{Block=- LETTERLIKE Symbols}', ""); +Expect(1, 8447, '\p{^Block=- LETTERLIKE Symbols}', ""); +Expect(1, 8447, '\P{Block=- LETTERLIKE Symbols}', ""); +Expect(0, 8447, '\P{^Block=- LETTERLIKE Symbols}', ""); +Error('\p{Blk: -letterlike/a/Symbols}'); +Error('\P{Blk: -letterlike/a/Symbols}'); +Expect(1, 8527, '\p{Blk=letterlikesymbols}', ""); +Expect(0, 8527, '\p{^Blk=letterlikesymbols}', ""); +Expect(0, 8527, '\P{Blk=letterlikesymbols}', ""); +Expect(1, 8527, '\P{^Blk=letterlikesymbols}', ""); +Expect(0, 8447, '\p{Blk=letterlikesymbols}', ""); +Expect(1, 8447, '\p{^Blk=letterlikesymbols}', ""); +Expect(1, 8447, '\P{Blk=letterlikesymbols}', ""); +Expect(0, 8447, '\P{^Blk=letterlikesymbols}', ""); +Expect(1, 8527, '\p{Blk=-_letterlike-Symbols}', ""); +Expect(0, 8527, '\p{^Blk=-_letterlike-Symbols}', ""); +Expect(0, 8527, '\P{Blk=-_letterlike-Symbols}', ""); +Expect(1, 8527, '\P{^Blk=-_letterlike-Symbols}', ""); +Expect(0, 8447, '\p{Blk=-_letterlike-Symbols}', ""); +Expect(1, 8447, '\p{^Blk=-_letterlike-Symbols}', ""); +Expect(1, 8447, '\P{Blk=-_letterlike-Symbols}', ""); +Expect(0, 8447, '\P{^Blk=-_letterlike-Symbols}', ""); +Error('\p{Is_Block=:=Letterlike SYMBOLS}'); +Error('\P{Is_Block=:=Letterlike SYMBOLS}'); +Expect(1, 8527, '\p{Is_Block: letterlikesymbols}', ""); +Expect(0, 8527, '\p{^Is_Block: letterlikesymbols}', ""); +Expect(0, 8527, '\P{Is_Block: letterlikesymbols}', ""); +Expect(1, 8527, '\P{^Is_Block: letterlikesymbols}', ""); +Expect(0, 8447, '\p{Is_Block: letterlikesymbols}', ""); +Expect(1, 8447, '\p{^Is_Block: letterlikesymbols}', ""); +Expect(1, 8447, '\P{Is_Block: letterlikesymbols}', ""); +Expect(0, 8447, '\P{^Is_Block: letterlikesymbols}', ""); +Expect(1, 8527, '\p{Is_Block=- Letterlike_Symbols}', ""); +Expect(0, 8527, '\p{^Is_Block=- Letterlike_Symbols}', ""); +Expect(0, 8527, '\P{Is_Block=- Letterlike_Symbols}', ""); +Expect(1, 8527, '\P{^Is_Block=- Letterlike_Symbols}', ""); +Expect(0, 8447, '\p{Is_Block=- Letterlike_Symbols}', ""); +Expect(1, 8447, '\p{^Is_Block=- Letterlike_Symbols}', ""); +Expect(1, 8447, '\P{Is_Block=- Letterlike_Symbols}', ""); +Expect(0, 8447, '\P{^Is_Block=- Letterlike_Symbols}', ""); +Error('\p{Is_Blk=_-letterlike-symbols:=}'); +Error('\P{Is_Blk=_-letterlike-symbols:=}'); +Expect(1, 8527, '\p{Is_Blk=letterlikesymbols}', ""); +Expect(0, 8527, '\p{^Is_Blk=letterlikesymbols}', ""); +Expect(0, 8527, '\P{Is_Blk=letterlikesymbols}', ""); +Expect(1, 8527, '\P{^Is_Blk=letterlikesymbols}', ""); +Expect(0, 8447, '\p{Is_Blk=letterlikesymbols}', ""); +Expect(1, 8447, '\p{^Is_Blk=letterlikesymbols}', ""); +Expect(1, 8447, '\P{Is_Blk=letterlikesymbols}', ""); +Expect(0, 8447, '\P{^Is_Blk=letterlikesymbols}', ""); +Expect(1, 8527, '\p{Is_Blk= LETTERLIKE_symbols}', ""); +Expect(0, 8527, '\p{^Is_Blk= LETTERLIKE_symbols}', ""); +Expect(0, 8527, '\P{Is_Blk= LETTERLIKE_symbols}', ""); +Expect(1, 8527, '\P{^Is_Blk= LETTERLIKE_symbols}', ""); +Expect(0, 8447, '\p{Is_Blk= LETTERLIKE_symbols}', ""); +Expect(1, 8447, '\p{^Is_Blk= LETTERLIKE_symbols}', ""); +Expect(1, 8447, '\P{Is_Blk= LETTERLIKE_symbols}', ""); +Expect(0, 8447, '\P{^Is_Blk= LETTERLIKE_symbols}', ""); +Error('\p{Block: /a/Latin-Extended_C}'); +Error('\P{Block: /a/Latin-Extended_C}'); +Expect(1, 11391, '\p{Block=latinextendedc}', ""); +Expect(0, 11391, '\p{^Block=latinextendedc}', ""); +Expect(0, 11391, '\P{Block=latinextendedc}', ""); +Expect(1, 11391, '\P{^Block=latinextendedc}', ""); +Expect(0, 11359, '\p{Block=latinextendedc}', ""); +Expect(1, 11359, '\p{^Block=latinextendedc}', ""); +Expect(1, 11359, '\P{Block=latinextendedc}', ""); +Expect(0, 11359, '\P{^Block=latinextendedc}', ""); +Expect(1, 11391, '\p{Block: Latin_Extended_C}', ""); +Expect(0, 11391, '\p{^Block: Latin_Extended_C}', ""); +Expect(0, 11391, '\P{Block: Latin_Extended_C}', ""); +Expect(1, 11391, '\P{^Block: Latin_Extended_C}', ""); +Expect(0, 11359, '\p{Block: Latin_Extended_C}', ""); +Expect(1, 11359, '\p{^Block: Latin_Extended_C}', ""); +Expect(1, 11359, '\P{Block: Latin_Extended_C}', ""); +Expect(0, 11359, '\P{^Block: Latin_Extended_C}', ""); +Error('\p{Blk= -latin_Extended_C:=}'); +Error('\P{Blk= -latin_Extended_C:=}'); +Expect(1, 11391, '\p{Blk=latinextendedc}', ""); +Expect(0, 11391, '\p{^Blk=latinextendedc}', ""); +Expect(0, 11391, '\P{Blk=latinextendedc}', ""); +Expect(1, 11391, '\P{^Blk=latinextendedc}', ""); +Expect(0, 11359, '\p{Blk=latinextendedc}', ""); +Expect(1, 11359, '\p{^Blk=latinextendedc}', ""); +Expect(1, 11359, '\P{Blk=latinextendedc}', ""); +Expect(0, 11359, '\P{^Blk=latinextendedc}', ""); +Expect(1, 11391, '\p{Blk= Latin EXTENDED-C}', ""); +Expect(0, 11391, '\p{^Blk= Latin EXTENDED-C}', ""); +Expect(0, 11391, '\P{Blk= Latin EXTENDED-C}', ""); +Expect(1, 11391, '\P{^Blk= Latin EXTENDED-C}', ""); +Expect(0, 11359, '\p{Blk= Latin EXTENDED-C}', ""); +Expect(1, 11359, '\p{^Blk= Latin EXTENDED-C}', ""); +Expect(1, 11359, '\P{Blk= Latin EXTENDED-C}', ""); +Expect(0, 11359, '\P{^Blk= Latin EXTENDED-C}', ""); +Error('\p{Is_Block=-Latin/a/extended C}'); +Error('\P{Is_Block=-Latin/a/extended C}'); +Expect(1, 11391, '\p{Is_Block=latinextendedc}', ""); +Expect(0, 11391, '\p{^Is_Block=latinextendedc}', ""); +Expect(0, 11391, '\P{Is_Block=latinextendedc}', ""); +Expect(1, 11391, '\P{^Is_Block=latinextendedc}', ""); +Expect(0, 11359, '\p{Is_Block=latinextendedc}', ""); +Expect(1, 11359, '\p{^Is_Block=latinextendedc}', ""); +Expect(1, 11359, '\P{Is_Block=latinextendedc}', ""); +Expect(0, 11359, '\P{^Is_Block=latinextendedc}', ""); +Expect(1, 11391, '\p{Is_Block=--Latin extended C}', ""); +Expect(0, 11391, '\p{^Is_Block=--Latin extended C}', ""); +Expect(0, 11391, '\P{Is_Block=--Latin extended C}', ""); +Expect(1, 11391, '\P{^Is_Block=--Latin extended C}', ""); +Expect(0, 11359, '\p{Is_Block=--Latin extended C}', ""); +Expect(1, 11359, '\p{^Is_Block=--Latin extended C}', ""); +Expect(1, 11359, '\P{Is_Block=--Latin extended C}', ""); +Expect(0, 11359, '\P{^Is_Block=--Latin extended C}', ""); +Error('\p{Is_Blk=-_LATIN_ExtendedC/a/}'); +Error('\P{Is_Blk=-_LATIN_ExtendedC/a/}'); +Expect(1, 11391, '\p{Is_Blk=latinextendedc}', ""); +Expect(0, 11391, '\p{^Is_Blk=latinextendedc}', ""); +Expect(0, 11391, '\P{Is_Blk=latinextendedc}', ""); +Expect(1, 11391, '\P{^Is_Blk=latinextendedc}', ""); +Expect(0, 11359, '\p{Is_Blk=latinextendedc}', ""); +Expect(1, 11359, '\p{^Is_Blk=latinextendedc}', ""); +Expect(1, 11359, '\P{Is_Blk=latinextendedc}', ""); +Expect(0, 11359, '\P{^Is_Blk=latinextendedc}', ""); +Expect(1, 11391, '\p{Is_Blk=_LatinEXTENDED-C}', ""); +Expect(0, 11391, '\p{^Is_Blk=_LatinEXTENDED-C}', ""); +Expect(0, 11391, '\P{Is_Blk=_LatinEXTENDED-C}', ""); +Expect(1, 11391, '\P{^Is_Blk=_LatinEXTENDED-C}', ""); +Expect(0, 11359, '\p{Is_Blk=_LatinEXTENDED-C}', ""); +Expect(1, 11359, '\p{^Is_Blk=_LatinEXTENDED-C}', ""); +Expect(1, 11359, '\P{Is_Blk=_LatinEXTENDED-C}', ""); +Expect(0, 11359, '\P{^Is_Blk=_LatinEXTENDED-C}', ""); +Error('\p{Block= /a/supplemental_Mathematical_Operators}'); +Error('\P{Block= /a/supplemental_Mathematical_Operators}'); +Expect(1, 11007, '\p{Block=supplementalmathematicaloperators}', ""); +Expect(0, 11007, '\p{^Block=supplementalmathematicaloperators}', ""); +Expect(0, 11007, '\P{Block=supplementalmathematicaloperators}', ""); +Expect(1, 11007, '\P{^Block=supplementalmathematicaloperators}', ""); +Expect(0, 10751, '\p{Block=supplementalmathematicaloperators}', ""); +Expect(1, 10751, '\p{^Block=supplementalmathematicaloperators}', ""); +Expect(1, 10751, '\P{Block=supplementalmathematicaloperators}', ""); +Expect(0, 10751, '\P{^Block=supplementalmathematicaloperators}', ""); +Expect(1, 11007, '\p{Block: SUPPLEMENTAL-Mathematical_operators}', ""); +Expect(0, 11007, '\p{^Block: SUPPLEMENTAL-Mathematical_operators}', ""); +Expect(0, 11007, '\P{Block: SUPPLEMENTAL-Mathematical_operators}', ""); +Expect(1, 11007, '\P{^Block: SUPPLEMENTAL-Mathematical_operators}', ""); +Expect(0, 10751, '\p{Block: SUPPLEMENTAL-Mathematical_operators}', ""); +Expect(1, 10751, '\p{^Block: SUPPLEMENTAL-Mathematical_operators}', ""); +Expect(1, 10751, '\P{Block: SUPPLEMENTAL-Mathematical_operators}', ""); +Expect(0, 10751, '\P{^Block: SUPPLEMENTAL-Mathematical_operators}', ""); +Error('\p{Blk= SUPPLEMENTAL-Mathematical:=OPERATORS}'); +Error('\P{Blk= SUPPLEMENTAL-Mathematical:=OPERATORS}'); +Expect(1, 11007, '\p{Blk=supplementalmathematicaloperators}', ""); +Expect(0, 11007, '\p{^Blk=supplementalmathematicaloperators}', ""); +Expect(0, 11007, '\P{Blk=supplementalmathematicaloperators}', ""); +Expect(1, 11007, '\P{^Blk=supplementalmathematicaloperators}', ""); +Expect(0, 10751, '\p{Blk=supplementalmathematicaloperators}', ""); +Expect(1, 10751, '\p{^Blk=supplementalmathematicaloperators}', ""); +Expect(1, 10751, '\P{Blk=supplementalmathematicaloperators}', ""); +Expect(0, 10751, '\P{^Blk=supplementalmathematicaloperators}', ""); +Expect(1, 11007, '\p{Blk= supplementalMathematicalOperators}', ""); +Expect(0, 11007, '\p{^Blk= supplementalMathematicalOperators}', ""); +Expect(0, 11007, '\P{Blk= supplementalMathematicalOperators}', ""); +Expect(1, 11007, '\P{^Blk= supplementalMathematicalOperators}', ""); +Expect(0, 10751, '\p{Blk= supplementalMathematicalOperators}', ""); +Expect(1, 10751, '\p{^Blk= supplementalMathematicalOperators}', ""); +Expect(1, 10751, '\P{Blk= supplementalMathematicalOperators}', ""); +Expect(0, 10751, '\P{^Blk= supplementalMathematicalOperators}', ""); +Error('\p{Is_Block=-SUPPLEMENTAL-mathematical/a/operators}'); +Error('\P{Is_Block=-SUPPLEMENTAL-mathematical/a/operators}'); +Expect(1, 11007, '\p{Is_Block=supplementalmathematicaloperators}', ""); +Expect(0, 11007, '\p{^Is_Block=supplementalmathematicaloperators}', ""); +Expect(0, 11007, '\P{Is_Block=supplementalmathematicaloperators}', ""); +Expect(1, 11007, '\P{^Is_Block=supplementalmathematicaloperators}', ""); +Expect(0, 10751, '\p{Is_Block=supplementalmathematicaloperators}', ""); +Expect(1, 10751, '\p{^Is_Block=supplementalmathematicaloperators}', ""); +Expect(1, 10751, '\P{Is_Block=supplementalmathematicaloperators}', ""); +Expect(0, 10751, '\P{^Is_Block=supplementalmathematicaloperators}', ""); +Expect(1, 11007, '\p{Is_Block: --Supplemental-mathematicalOperators}', ""); +Expect(0, 11007, '\p{^Is_Block: --Supplemental-mathematicalOperators}', ""); +Expect(0, 11007, '\P{Is_Block: --Supplemental-mathematicalOperators}', ""); +Expect(1, 11007, '\P{^Is_Block: --Supplemental-mathematicalOperators}', ""); +Expect(0, 10751, '\p{Is_Block: --Supplemental-mathematicalOperators}', ""); +Expect(1, 10751, '\p{^Is_Block: --Supplemental-mathematicalOperators}', ""); +Expect(1, 10751, '\P{Is_Block: --Supplemental-mathematicalOperators}', ""); +Expect(0, 10751, '\P{^Is_Block: --Supplemental-mathematicalOperators}', ""); +Error('\p{Is_Blk=-:=Supplemental MATHEMATICAL_Operators}'); +Error('\P{Is_Blk=-:=Supplemental MATHEMATICAL_Operators}'); +Expect(1, 11007, '\p{Is_Blk=supplementalmathematicaloperators}', ""); +Expect(0, 11007, '\p{^Is_Blk=supplementalmathematicaloperators}', ""); +Expect(0, 11007, '\P{Is_Blk=supplementalmathematicaloperators}', ""); +Expect(1, 11007, '\P{^Is_Blk=supplementalmathematicaloperators}', ""); +Expect(0, 10751, '\p{Is_Blk=supplementalmathematicaloperators}', ""); +Expect(1, 10751, '\p{^Is_Blk=supplementalmathematicaloperators}', ""); +Expect(1, 10751, '\P{Is_Blk=supplementalmathematicaloperators}', ""); +Expect(0, 10751, '\P{^Is_Blk=supplementalmathematicaloperators}', ""); +Expect(1, 11007, '\p{Is_Blk=SUPPLEMENTAL MATHEMATICALOperators}', ""); +Expect(0, 11007, '\p{^Is_Blk=SUPPLEMENTAL MATHEMATICALOperators}', ""); +Expect(0, 11007, '\P{Is_Blk=SUPPLEMENTAL MATHEMATICALOperators}', ""); +Expect(1, 11007, '\P{^Is_Blk=SUPPLEMENTAL MATHEMATICALOperators}', ""); +Expect(0, 10751, '\p{Is_Blk=SUPPLEMENTAL MATHEMATICALOperators}', ""); +Expect(1, 10751, '\p{^Is_Blk=SUPPLEMENTAL MATHEMATICALOperators}', ""); +Expect(1, 10751, '\P{Is_Blk=SUPPLEMENTAL MATHEMATICALOperators}', ""); +Expect(0, 10751, '\P{^Is_Blk=SUPPLEMENTAL MATHEMATICALOperators}', ""); +Error('\p{Block=/a/shavian}'); +Error('\P{Block=/a/shavian}'); +Expect(1, 66687, '\p{Block=shavian}', ""); +Expect(0, 66687, '\p{^Block=shavian}', ""); +Expect(0, 66687, '\P{Block=shavian}', ""); +Expect(1, 66687, '\P{^Block=shavian}', ""); +Expect(0, 66639, '\p{Block=shavian}', ""); +Expect(1, 66639, '\p{^Block=shavian}', ""); +Expect(1, 66639, '\P{Block=shavian}', ""); +Expect(0, 66639, '\P{^Block=shavian}', ""); +Expect(1, 66687, '\p{Block: -SHAVIAN}', ""); +Expect(0, 66687, '\p{^Block: -SHAVIAN}', ""); +Expect(0, 66687, '\P{Block: -SHAVIAN}', ""); +Expect(1, 66687, '\P{^Block: -SHAVIAN}', ""); +Expect(0, 66639, '\p{Block: -SHAVIAN}', ""); +Expect(1, 66639, '\p{^Block: -SHAVIAN}', ""); +Expect(1, 66639, '\P{Block: -SHAVIAN}', ""); +Expect(0, 66639, '\P{^Block: -SHAVIAN}', ""); +Error('\p{Blk=--Shavian:=}'); +Error('\P{Blk=--Shavian:=}'); +Expect(1, 66687, '\p{Blk=shavian}', ""); +Expect(0, 66687, '\p{^Blk=shavian}', ""); +Expect(0, 66687, '\P{Blk=shavian}', ""); +Expect(1, 66687, '\P{^Blk=shavian}', ""); +Expect(0, 66639, '\p{Blk=shavian}', ""); +Expect(1, 66639, '\p{^Blk=shavian}', ""); +Expect(1, 66639, '\P{Blk=shavian}', ""); +Expect(0, 66639, '\P{^Blk=shavian}', ""); +Expect(1, 66687, '\p{Blk=_ shavian}', ""); +Expect(0, 66687, '\p{^Blk=_ shavian}', ""); +Expect(0, 66687, '\P{Blk=_ shavian}', ""); +Expect(1, 66687, '\P{^Blk=_ shavian}', ""); +Expect(0, 66639, '\p{Blk=_ shavian}', ""); +Expect(1, 66639, '\p{^Blk=_ shavian}', ""); +Expect(1, 66639, '\P{Blk=_ shavian}', ""); +Expect(0, 66639, '\P{^Blk=_ shavian}', ""); +Error('\p{Is_Block= SHAVIAN:=}'); +Error('\P{Is_Block= SHAVIAN:=}'); +Expect(1, 66687, '\p{Is_Block=shavian}', ""); +Expect(0, 66687, '\p{^Is_Block=shavian}', ""); +Expect(0, 66687, '\P{Is_Block=shavian}', ""); +Expect(1, 66687, '\P{^Is_Block=shavian}', ""); +Expect(0, 66639, '\p{Is_Block=shavian}', ""); +Expect(1, 66639, '\p{^Is_Block=shavian}', ""); +Expect(1, 66639, '\P{Is_Block=shavian}', ""); +Expect(0, 66639, '\P{^Is_Block=shavian}', ""); +Expect(1, 66687, '\p{Is_Block: - Shavian}', ""); +Expect(0, 66687, '\p{^Is_Block: - Shavian}', ""); +Expect(0, 66687, '\P{Is_Block: - Shavian}', ""); +Expect(1, 66687, '\P{^Is_Block: - Shavian}', ""); +Expect(0, 66639, '\p{Is_Block: - Shavian}', ""); +Expect(1, 66639, '\p{^Is_Block: - Shavian}', ""); +Expect(1, 66639, '\P{Is_Block: - Shavian}', ""); +Expect(0, 66639, '\P{^Is_Block: - Shavian}', ""); +Error('\p{Is_Blk= :=Shavian}'); +Error('\P{Is_Blk= :=Shavian}'); +Expect(1, 66687, '\p{Is_Blk=shavian}', ""); +Expect(0, 66687, '\p{^Is_Blk=shavian}', ""); +Expect(0, 66687, '\P{Is_Blk=shavian}', ""); +Expect(1, 66687, '\P{^Is_Blk=shavian}', ""); +Expect(0, 66639, '\p{Is_Blk=shavian}', ""); +Expect(1, 66639, '\p{^Is_Blk=shavian}', ""); +Expect(1, 66639, '\P{Is_Blk=shavian}', ""); +Expect(0, 66639, '\P{^Is_Blk=shavian}', ""); +Expect(1, 66687, '\p{Is_Blk=--shavian}', ""); +Expect(0, 66687, '\p{^Is_Blk=--shavian}', ""); +Expect(0, 66687, '\P{Is_Blk=--shavian}', ""); +Expect(1, 66687, '\P{^Is_Blk=--shavian}', ""); +Expect(0, 66639, '\p{Is_Blk=--shavian}', ""); +Expect(1, 66639, '\p{^Is_Blk=--shavian}', ""); +Expect(1, 66639, '\P{Is_Blk=--shavian}', ""); +Expect(0, 66639, '\P{^Is_Blk=--shavian}', ""); +Error('\p{Block=:=--LYDIAN}'); +Error('\P{Block=:=--LYDIAN}'); +Expect(1, 67903, '\p{Block=lydian}', ""); +Expect(0, 67903, '\p{^Block=lydian}', ""); +Expect(0, 67903, '\P{Block=lydian}', ""); +Expect(1, 67903, '\P{^Block=lydian}', ""); +Expect(0, 67871, '\p{Block=lydian}', ""); +Expect(1, 67871, '\p{^Block=lydian}', ""); +Expect(1, 67871, '\P{Block=lydian}', ""); +Expect(0, 67871, '\P{^Block=lydian}', ""); +Expect(1, 67903, '\p{Block=-LYDIAN}', ""); +Expect(0, 67903, '\p{^Block=-LYDIAN}', ""); +Expect(0, 67903, '\P{Block=-LYDIAN}', ""); +Expect(1, 67903, '\P{^Block=-LYDIAN}', ""); +Expect(0, 67871, '\p{Block=-LYDIAN}', ""); +Expect(1, 67871, '\p{^Block=-LYDIAN}', ""); +Expect(1, 67871, '\P{Block=-LYDIAN}', ""); +Expect(0, 67871, '\P{^Block=-LYDIAN}', ""); +Error('\p{Blk=/a/lydian}'); +Error('\P{Blk=/a/lydian}'); +Expect(1, 67903, '\p{Blk=lydian}', ""); +Expect(0, 67903, '\p{^Blk=lydian}', ""); +Expect(0, 67903, '\P{Blk=lydian}', ""); +Expect(1, 67903, '\P{^Blk=lydian}', ""); +Expect(0, 67871, '\p{Blk=lydian}', ""); +Expect(1, 67871, '\p{^Blk=lydian}', ""); +Expect(1, 67871, '\P{Blk=lydian}', ""); +Expect(0, 67871, '\P{^Blk=lydian}', ""); +Expect(1, 67903, '\p{Blk: -lydian}', ""); +Expect(0, 67903, '\p{^Blk: -lydian}', ""); +Expect(0, 67903, '\P{Blk: -lydian}', ""); +Expect(1, 67903, '\P{^Blk: -lydian}', ""); +Expect(0, 67871, '\p{Blk: -lydian}', ""); +Expect(1, 67871, '\p{^Blk: -lydian}', ""); +Expect(1, 67871, '\P{Blk: -lydian}', ""); +Expect(0, 67871, '\P{^Blk: -lydian}', ""); +Error('\p{Is_Block=_ Lydian/a/}'); +Error('\P{Is_Block=_ Lydian/a/}'); +Expect(1, 67903, '\p{Is_Block=lydian}', ""); +Expect(0, 67903, '\p{^Is_Block=lydian}', ""); +Expect(0, 67903, '\P{Is_Block=lydian}', ""); +Expect(1, 67903, '\P{^Is_Block=lydian}', ""); +Expect(0, 67871, '\p{Is_Block=lydian}', ""); +Expect(1, 67871, '\p{^Is_Block=lydian}', ""); +Expect(1, 67871, '\P{Is_Block=lydian}', ""); +Expect(0, 67871, '\P{^Is_Block=lydian}', ""); +Expect(1, 67903, '\p{Is_Block=_lydian}', ""); +Expect(0, 67903, '\p{^Is_Block=_lydian}', ""); +Expect(0, 67903, '\P{Is_Block=_lydian}', ""); +Expect(1, 67903, '\P{^Is_Block=_lydian}', ""); +Expect(0, 67871, '\p{Is_Block=_lydian}', ""); +Expect(1, 67871, '\p{^Is_Block=_lydian}', ""); +Expect(1, 67871, '\P{Is_Block=_lydian}', ""); +Expect(0, 67871, '\P{^Is_Block=_lydian}', ""); +Error('\p{Is_Blk=/a/_LYDIAN}'); +Error('\P{Is_Blk=/a/_LYDIAN}'); +Expect(1, 67903, '\p{Is_Blk=lydian}', ""); +Expect(0, 67903, '\p{^Is_Blk=lydian}', ""); +Expect(0, 67903, '\P{Is_Blk=lydian}', ""); +Expect(1, 67903, '\P{^Is_Blk=lydian}', ""); +Expect(0, 67871, '\p{Is_Blk=lydian}', ""); +Expect(1, 67871, '\p{^Is_Blk=lydian}', ""); +Expect(1, 67871, '\P{Is_Blk=lydian}', ""); +Expect(0, 67871, '\P{^Is_Blk=lydian}', ""); +Expect(1, 67903, '\p{Is_Blk=_-LYDIAN}', ""); +Expect(0, 67903, '\p{^Is_Blk=_-LYDIAN}', ""); +Expect(0, 67903, '\P{Is_Blk=_-LYDIAN}', ""); +Expect(1, 67903, '\P{^Is_Blk=_-LYDIAN}', ""); +Expect(0, 67871, '\p{Is_Blk=_-LYDIAN}', ""); +Expect(1, 67871, '\p{^Is_Blk=_-LYDIAN}', ""); +Expect(1, 67871, '\P{Is_Blk=_-LYDIAN}', ""); +Expect(0, 67871, '\P{^Is_Blk=_-LYDIAN}', ""); +Error('\p{Block=_ Mongolian/a/}'); +Error('\P{Block=_ Mongolian/a/}'); +Expect(1, 6319, '\p{Block=mongolian}', ""); +Expect(0, 6319, '\p{^Block=mongolian}', ""); +Expect(0, 6319, '\P{Block=mongolian}', ""); +Expect(1, 6319, '\P{^Block=mongolian}', ""); +Expect(0, 6143, '\p{Block=mongolian}', ""); +Expect(1, 6143, '\p{^Block=mongolian}', ""); +Expect(1, 6143, '\P{Block=mongolian}', ""); +Expect(0, 6143, '\P{^Block=mongolian}', ""); +Expect(1, 6319, '\p{Block=_Mongolian}', ""); +Expect(0, 6319, '\p{^Block=_Mongolian}', ""); +Expect(0, 6319, '\P{Block=_Mongolian}', ""); +Expect(1, 6319, '\P{^Block=_Mongolian}', ""); +Expect(0, 6143, '\p{Block=_Mongolian}', ""); +Expect(1, 6143, '\p{^Block=_Mongolian}', ""); +Expect(1, 6143, '\P{Block=_Mongolian}', ""); +Expect(0, 6143, '\P{^Block=_Mongolian}', ""); +Error('\p{Blk=_-mongolian:=}'); +Error('\P{Blk=_-mongolian:=}'); +Expect(1, 6319, '\p{Blk=mongolian}', ""); +Expect(0, 6319, '\p{^Blk=mongolian}', ""); +Expect(0, 6319, '\P{Blk=mongolian}', ""); +Expect(1, 6319, '\P{^Blk=mongolian}', ""); +Expect(0, 6143, '\p{Blk=mongolian}', ""); +Expect(1, 6143, '\p{^Blk=mongolian}', ""); +Expect(1, 6143, '\P{Blk=mongolian}', ""); +Expect(0, 6143, '\P{^Blk=mongolian}', ""); +Expect(1, 6319, '\p{Blk= Mongolian}', ""); +Expect(0, 6319, '\p{^Blk= Mongolian}', ""); +Expect(0, 6319, '\P{Blk= Mongolian}', ""); +Expect(1, 6319, '\P{^Blk= Mongolian}', ""); +Expect(0, 6143, '\p{Blk= Mongolian}', ""); +Expect(1, 6143, '\p{^Blk= Mongolian}', ""); +Expect(1, 6143, '\P{Blk= Mongolian}', ""); +Expect(0, 6143, '\P{^Blk= Mongolian}', ""); +Error('\p{Is_Block= /a/Mongolian}'); +Error('\P{Is_Block= /a/Mongolian}'); +Expect(1, 6319, '\p{Is_Block: mongolian}', ""); +Expect(0, 6319, '\p{^Is_Block: mongolian}', ""); +Expect(0, 6319, '\P{Is_Block: mongolian}', ""); +Expect(1, 6319, '\P{^Is_Block: mongolian}', ""); +Expect(0, 6143, '\p{Is_Block: mongolian}', ""); +Expect(1, 6143, '\p{^Is_Block: mongolian}', ""); +Expect(1, 6143, '\P{Is_Block: mongolian}', ""); +Expect(0, 6143, '\P{^Is_Block: mongolian}', ""); +Expect(1, 6319, '\p{Is_Block= Mongolian}', ""); +Expect(0, 6319, '\p{^Is_Block= Mongolian}', ""); +Expect(0, 6319, '\P{Is_Block= Mongolian}', ""); +Expect(1, 6319, '\P{^Is_Block= Mongolian}', ""); +Expect(0, 6143, '\p{Is_Block= Mongolian}', ""); +Expect(1, 6143, '\p{^Is_Block= Mongolian}', ""); +Expect(1, 6143, '\P{Is_Block= Mongolian}', ""); +Expect(0, 6143, '\P{^Is_Block= Mongolian}', ""); +Error('\p{Is_Blk= :=Mongolian}'); +Error('\P{Is_Blk= :=Mongolian}'); +Expect(1, 6319, '\p{Is_Blk=mongolian}', ""); +Expect(0, 6319, '\p{^Is_Blk=mongolian}', ""); +Expect(0, 6319, '\P{Is_Blk=mongolian}', ""); +Expect(1, 6319, '\P{^Is_Blk=mongolian}', ""); +Expect(0, 6143, '\p{Is_Blk=mongolian}', ""); +Expect(1, 6143, '\p{^Is_Blk=mongolian}', ""); +Expect(1, 6143, '\P{Is_Blk=mongolian}', ""); +Expect(0, 6143, '\P{^Is_Blk=mongolian}', ""); +Expect(1, 6319, '\p{Is_Blk: _MONGOLIAN}', ""); +Expect(0, 6319, '\p{^Is_Blk: _MONGOLIAN}', ""); +Expect(0, 6319, '\P{Is_Blk: _MONGOLIAN}', ""); +Expect(1, 6319, '\P{^Is_Blk: _MONGOLIAN}', ""); +Expect(0, 6143, '\p{Is_Blk: _MONGOLIAN}', ""); +Expect(1, 6143, '\p{^Is_Blk: _MONGOLIAN}', ""); +Expect(1, 6143, '\P{Is_Blk: _MONGOLIAN}', ""); +Expect(0, 6143, '\P{^Is_Blk: _MONGOLIAN}', ""); +Error('\p{Block: lao:=}'); +Error('\P{Block: lao:=}'); +Expect(1, 3839, '\p{Block=lao}', ""); +Expect(0, 3839, '\p{^Block=lao}', ""); +Expect(0, 3839, '\P{Block=lao}', ""); +Expect(1, 3839, '\P{^Block=lao}', ""); +Expect(0, 3711, '\p{Block=lao}', ""); +Expect(1, 3711, '\p{^Block=lao}', ""); +Expect(1, 3711, '\P{Block=lao}', ""); +Expect(0, 3711, '\P{^Block=lao}', ""); +Expect(1, 3839, '\p{Block=-Lao}', ""); +Expect(0, 3839, '\p{^Block=-Lao}', ""); +Expect(0, 3839, '\P{Block=-Lao}', ""); +Expect(1, 3839, '\P{^Block=-Lao}', ""); +Expect(0, 3711, '\p{Block=-Lao}', ""); +Expect(1, 3711, '\p{^Block=-Lao}', ""); +Expect(1, 3711, '\P{Block=-Lao}', ""); +Expect(0, 3711, '\P{^Block=-Lao}', ""); +Error('\p{Blk: -/a/Lao}'); +Error('\P{Blk: -/a/Lao}'); +Expect(1, 3839, '\p{Blk=lao}', ""); +Expect(0, 3839, '\p{^Blk=lao}', ""); +Expect(0, 3839, '\P{Blk=lao}', ""); +Expect(1, 3839, '\P{^Blk=lao}', ""); +Expect(0, 3711, '\p{Blk=lao}', ""); +Expect(1, 3711, '\p{^Blk=lao}', ""); +Expect(1, 3711, '\P{Blk=lao}', ""); +Expect(0, 3711, '\P{^Blk=lao}', ""); +Expect(1, 3839, '\p{Blk= LAO}', ""); +Expect(0, 3839, '\p{^Blk= LAO}', ""); +Expect(0, 3839, '\P{Blk= LAO}', ""); +Expect(1, 3839, '\P{^Blk= LAO}', ""); +Expect(0, 3711, '\p{Blk= LAO}', ""); +Expect(1, 3711, '\p{^Blk= LAO}', ""); +Expect(1, 3711, '\P{Blk= LAO}', ""); +Expect(0, 3711, '\P{^Blk= LAO}', ""); +Error('\p{Is_Block=:=-_Lao}'); +Error('\P{Is_Block=:=-_Lao}'); +Expect(1, 3839, '\p{Is_Block=lao}', ""); +Expect(0, 3839, '\p{^Is_Block=lao}', ""); +Expect(0, 3839, '\P{Is_Block=lao}', ""); +Expect(1, 3839, '\P{^Is_Block=lao}', ""); +Expect(0, 3711, '\p{Is_Block=lao}', ""); +Expect(1, 3711, '\p{^Is_Block=lao}', ""); +Expect(1, 3711, '\P{Is_Block=lao}', ""); +Expect(0, 3711, '\P{^Is_Block=lao}', ""); +Expect(1, 3839, '\p{Is_Block= Lao}', ""); +Expect(0, 3839, '\p{^Is_Block= Lao}', ""); +Expect(0, 3839, '\P{Is_Block= Lao}', ""); +Expect(1, 3839, '\P{^Is_Block= Lao}', ""); +Expect(0, 3711, '\p{Is_Block= Lao}', ""); +Expect(1, 3711, '\p{^Is_Block= Lao}', ""); +Expect(1, 3711, '\P{Is_Block= Lao}', ""); +Expect(0, 3711, '\P{^Is_Block= Lao}', ""); +Error('\p{Is_Blk: -/a/Lao}'); +Error('\P{Is_Blk: -/a/Lao}'); +Expect(1, 3839, '\p{Is_Blk=lao}', ""); +Expect(0, 3839, '\p{^Is_Blk=lao}', ""); +Expect(0, 3839, '\P{Is_Blk=lao}', ""); +Expect(1, 3839, '\P{^Is_Blk=lao}', ""); +Expect(0, 3711, '\p{Is_Blk=lao}', ""); +Expect(1, 3711, '\p{^Is_Blk=lao}', ""); +Expect(1, 3711, '\P{Is_Blk=lao}', ""); +Expect(0, 3711, '\P{^Is_Blk=lao}', ""); +Expect(1, 3839, '\p{Is_Blk: - lao}', ""); +Expect(0, 3839, '\p{^Is_Blk: - lao}', ""); +Expect(0, 3839, '\P{Is_Blk: - lao}', ""); +Expect(1, 3839, '\P{^Is_Blk: - lao}', ""); +Expect(0, 3711, '\p{Is_Blk: - lao}', ""); +Expect(1, 3711, '\p{^Is_Blk: - lao}', ""); +Expect(1, 3711, '\P{Is_Blk: - lao}', ""); +Expect(0, 3711, '\P{^Is_Blk: - lao}', ""); +Error('\p{Block=:= Hiragana}'); +Error('\P{Block=:= Hiragana}'); +Expect(1, 12447, '\p{Block:hiragana}', ""); +Expect(0, 12447, '\p{^Block:hiragana}', ""); +Expect(0, 12447, '\P{Block:hiragana}', ""); +Expect(1, 12447, '\P{^Block:hiragana}', ""); +Expect(0, 12351, '\p{Block:hiragana}', ""); +Expect(1, 12351, '\p{^Block:hiragana}', ""); +Expect(1, 12351, '\P{Block:hiragana}', ""); +Expect(0, 12351, '\P{^Block:hiragana}', ""); +Expect(1, 12447, '\p{Block= -Hiragana}', ""); +Expect(0, 12447, '\p{^Block= -Hiragana}', ""); +Expect(0, 12447, '\P{Block= -Hiragana}', ""); +Expect(1, 12447, '\P{^Block= -Hiragana}', ""); +Expect(0, 12351, '\p{Block= -Hiragana}', ""); +Expect(1, 12351, '\p{^Block= -Hiragana}', ""); +Expect(1, 12351, '\P{Block= -Hiragana}', ""); +Expect(0, 12351, '\P{^Block= -Hiragana}', ""); +Error('\p{Blk=HIRAGANA/a/}'); +Error('\P{Blk=HIRAGANA/a/}'); +Expect(1, 12447, '\p{Blk=hiragana}', ""); +Expect(0, 12447, '\p{^Blk=hiragana}', ""); +Expect(0, 12447, '\P{Blk=hiragana}', ""); +Expect(1, 12447, '\P{^Blk=hiragana}', ""); +Expect(0, 12351, '\p{Blk=hiragana}', ""); +Expect(1, 12351, '\p{^Blk=hiragana}', ""); +Expect(1, 12351, '\P{Blk=hiragana}', ""); +Expect(0, 12351, '\P{^Blk=hiragana}', ""); +Expect(1, 12447, '\p{Blk: Hiragana}', ""); +Expect(0, 12447, '\p{^Blk: Hiragana}', ""); +Expect(0, 12447, '\P{Blk: Hiragana}', ""); +Expect(1, 12447, '\P{^Blk: Hiragana}', ""); +Expect(0, 12351, '\p{Blk: Hiragana}', ""); +Expect(1, 12351, '\p{^Blk: Hiragana}', ""); +Expect(1, 12351, '\P{Blk: Hiragana}', ""); +Expect(0, 12351, '\P{^Blk: Hiragana}', ""); +Error('\p{Is_Block=-:=Hiragana}'); +Error('\P{Is_Block=-:=Hiragana}'); +Expect(1, 12447, '\p{Is_Block=hiragana}', ""); +Expect(0, 12447, '\p{^Is_Block=hiragana}', ""); +Expect(0, 12447, '\P{Is_Block=hiragana}', ""); +Expect(1, 12447, '\P{^Is_Block=hiragana}', ""); +Expect(0, 12351, '\p{Is_Block=hiragana}', ""); +Expect(1, 12351, '\p{^Is_Block=hiragana}', ""); +Expect(1, 12351, '\P{Is_Block=hiragana}', ""); +Expect(0, 12351, '\P{^Is_Block=hiragana}', ""); +Expect(1, 12447, '\p{Is_Block=_Hiragana}', ""); +Expect(0, 12447, '\p{^Is_Block=_Hiragana}', ""); +Expect(0, 12447, '\P{Is_Block=_Hiragana}', ""); +Expect(1, 12447, '\P{^Is_Block=_Hiragana}', ""); +Expect(0, 12351, '\p{Is_Block=_Hiragana}', ""); +Expect(1, 12351, '\p{^Is_Block=_Hiragana}', ""); +Expect(1, 12351, '\P{Is_Block=_Hiragana}', ""); +Expect(0, 12351, '\P{^Is_Block=_Hiragana}', ""); +Error('\p{Is_Blk: :=hiragana}'); +Error('\P{Is_Blk: :=hiragana}'); +Expect(1, 12447, '\p{Is_Blk: hiragana}', ""); +Expect(0, 12447, '\p{^Is_Blk: hiragana}', ""); +Expect(0, 12447, '\P{Is_Blk: hiragana}', ""); +Expect(1, 12447, '\P{^Is_Blk: hiragana}', ""); +Expect(0, 12351, '\p{Is_Blk: hiragana}', ""); +Expect(1, 12351, '\p{^Is_Blk: hiragana}', ""); +Expect(1, 12351, '\P{Is_Blk: hiragana}', ""); +Expect(0, 12351, '\P{^Is_Blk: hiragana}', ""); +Expect(1, 12447, '\p{Is_Blk=_Hiragana}', ""); +Expect(0, 12447, '\p{^Is_Blk=_Hiragana}', ""); +Expect(0, 12447, '\P{Is_Blk=_Hiragana}', ""); +Expect(1, 12447, '\P{^Is_Blk=_Hiragana}', ""); +Expect(0, 12351, '\p{Is_Blk=_Hiragana}', ""); +Expect(1, 12351, '\p{^Is_Blk=_Hiragana}', ""); +Expect(1, 12351, '\P{Is_Blk=_Hiragana}', ""); +Expect(0, 12351, '\P{^Is_Blk=_Hiragana}', ""); +Error('\p{Block= :=Lepcha}'); +Error('\P{Block= :=Lepcha}'); +Expect(1, 7247, '\p{Block=lepcha}', ""); +Expect(0, 7247, '\p{^Block=lepcha}', ""); +Expect(0, 7247, '\P{Block=lepcha}', ""); +Expect(1, 7247, '\P{^Block=lepcha}', ""); +Expect(0, 7167, '\p{Block=lepcha}', ""); +Expect(1, 7167, '\p{^Block=lepcha}', ""); +Expect(1, 7167, '\P{Block=lepcha}', ""); +Expect(0, 7167, '\P{^Block=lepcha}', ""); +Expect(1, 7247, '\p{Block: _-lepcha}', ""); +Expect(0, 7247, '\p{^Block: _-lepcha}', ""); +Expect(0, 7247, '\P{Block: _-lepcha}', ""); +Expect(1, 7247, '\P{^Block: _-lepcha}', ""); +Expect(0, 7167, '\p{Block: _-lepcha}', ""); +Expect(1, 7167, '\p{^Block: _-lepcha}', ""); +Expect(1, 7167, '\P{Block: _-lepcha}', ""); +Expect(0, 7167, '\P{^Block: _-lepcha}', ""); +Error('\p{Blk=_:=Lepcha}'); +Error('\P{Blk=_:=Lepcha}'); +Expect(1, 7247, '\p{Blk=lepcha}', ""); +Expect(0, 7247, '\p{^Blk=lepcha}', ""); +Expect(0, 7247, '\P{Blk=lepcha}', ""); +Expect(1, 7247, '\P{^Blk=lepcha}', ""); +Expect(0, 7167, '\p{Blk=lepcha}', ""); +Expect(1, 7167, '\p{^Blk=lepcha}', ""); +Expect(1, 7167, '\P{Blk=lepcha}', ""); +Expect(0, 7167, '\P{^Blk=lepcha}', ""); +Expect(1, 7247, '\p{Blk= Lepcha}', ""); +Expect(0, 7247, '\p{^Blk= Lepcha}', ""); +Expect(0, 7247, '\P{Blk= Lepcha}', ""); +Expect(1, 7247, '\P{^Blk= Lepcha}', ""); +Expect(0, 7167, '\p{Blk= Lepcha}', ""); +Expect(1, 7167, '\p{^Blk= Lepcha}', ""); +Expect(1, 7167, '\P{Blk= Lepcha}', ""); +Expect(0, 7167, '\P{^Blk= Lepcha}', ""); +Error('\p{Is_Block=:=Lepcha}'); +Error('\P{Is_Block=:=Lepcha}'); +Expect(1, 7247, '\p{Is_Block=lepcha}', ""); +Expect(0, 7247, '\p{^Is_Block=lepcha}', ""); +Expect(0, 7247, '\P{Is_Block=lepcha}', ""); +Expect(1, 7247, '\P{^Is_Block=lepcha}', ""); +Expect(0, 7167, '\p{Is_Block=lepcha}', ""); +Expect(1, 7167, '\p{^Is_Block=lepcha}', ""); +Expect(1, 7167, '\P{Is_Block=lepcha}', ""); +Expect(0, 7167, '\P{^Is_Block=lepcha}', ""); +Expect(1, 7247, '\p{Is_Block= lepcha}', ""); +Expect(0, 7247, '\p{^Is_Block= lepcha}', ""); +Expect(0, 7247, '\P{Is_Block= lepcha}', ""); +Expect(1, 7247, '\P{^Is_Block= lepcha}', ""); +Expect(0, 7167, '\p{Is_Block= lepcha}', ""); +Expect(1, 7167, '\p{^Is_Block= lepcha}', ""); +Expect(1, 7167, '\P{Is_Block= lepcha}', ""); +Expect(0, 7167, '\P{^Is_Block= lepcha}', ""); +Error('\p{Is_Blk=_:=Lepcha}'); +Error('\P{Is_Blk=_:=Lepcha}'); +Expect(1, 7247, '\p{Is_Blk=lepcha}', ""); +Expect(0, 7247, '\p{^Is_Blk=lepcha}', ""); +Expect(0, 7247, '\P{Is_Blk=lepcha}', ""); +Expect(1, 7247, '\P{^Is_Blk=lepcha}', ""); +Expect(0, 7167, '\p{Is_Blk=lepcha}', ""); +Expect(1, 7167, '\p{^Is_Blk=lepcha}', ""); +Expect(1, 7167, '\P{Is_Blk=lepcha}', ""); +Expect(0, 7167, '\P{^Is_Blk=lepcha}', ""); +Expect(1, 7247, '\p{Is_Blk=_Lepcha}', ""); +Expect(0, 7247, '\p{^Is_Blk=_Lepcha}', ""); +Expect(0, 7247, '\P{Is_Blk=_Lepcha}', ""); +Expect(1, 7247, '\P{^Is_Blk=_Lepcha}', ""); +Expect(0, 7167, '\p{Is_Blk=_Lepcha}', ""); +Expect(1, 7167, '\p{^Is_Blk=_Lepcha}', ""); +Expect(1, 7167, '\P{Is_Blk=_Lepcha}', ""); +Expect(0, 7167, '\P{^Is_Blk=_Lepcha}', ""); +Error('\p{Block= /a/Syloti-nagri}'); +Error('\P{Block= /a/Syloti-nagri}'); +Expect(1, 43055, '\p{Block=sylotinagri}', ""); +Expect(0, 43055, '\p{^Block=sylotinagri}', ""); +Expect(0, 43055, '\P{Block=sylotinagri}', ""); +Expect(1, 43055, '\P{^Block=sylotinagri}', ""); +Expect(0, 43007, '\p{Block=sylotinagri}', ""); +Expect(1, 43007, '\p{^Block=sylotinagri}', ""); +Expect(1, 43007, '\P{Block=sylotinagri}', ""); +Expect(0, 43007, '\P{^Block=sylotinagri}', ""); +Expect(1, 43055, '\p{Block=_ Syloti Nagri}', ""); +Expect(0, 43055, '\p{^Block=_ Syloti Nagri}', ""); +Expect(0, 43055, '\P{Block=_ Syloti Nagri}', ""); +Expect(1, 43055, '\P{^Block=_ Syloti Nagri}', ""); +Expect(0, 43007, '\p{Block=_ Syloti Nagri}', ""); +Expect(1, 43007, '\p{^Block=_ Syloti Nagri}', ""); +Expect(1, 43007, '\P{Block=_ Syloti Nagri}', ""); +Expect(0, 43007, '\P{^Block=_ Syloti Nagri}', ""); +Error('\p{Blk= sylotiNAGRI:=}'); +Error('\P{Blk= sylotiNAGRI:=}'); +Expect(1, 43055, '\p{Blk=sylotinagri}', ""); +Expect(0, 43055, '\p{^Blk=sylotinagri}', ""); +Expect(0, 43055, '\P{Blk=sylotinagri}', ""); +Expect(1, 43055, '\P{^Blk=sylotinagri}', ""); +Expect(0, 43007, '\p{Blk=sylotinagri}', ""); +Expect(1, 43007, '\p{^Blk=sylotinagri}', ""); +Expect(1, 43007, '\P{Blk=sylotinagri}', ""); +Expect(0, 43007, '\P{^Blk=sylotinagri}', ""); +Expect(1, 43055, '\p{Blk= _syloti NAGRI}', ""); +Expect(0, 43055, '\p{^Blk= _syloti NAGRI}', ""); +Expect(0, 43055, '\P{Blk= _syloti NAGRI}', ""); +Expect(1, 43055, '\P{^Blk= _syloti NAGRI}', ""); +Expect(0, 43007, '\p{Blk= _syloti NAGRI}', ""); +Expect(1, 43007, '\p{^Blk= _syloti NAGRI}', ""); +Expect(1, 43007, '\P{Blk= _syloti NAGRI}', ""); +Expect(0, 43007, '\P{^Blk= _syloti NAGRI}', ""); +Error('\p{Is_Block=:= -Syloti NAGRI}'); +Error('\P{Is_Block=:= -Syloti NAGRI}'); +Expect(1, 43055, '\p{Is_Block=sylotinagri}', ""); +Expect(0, 43055, '\p{^Is_Block=sylotinagri}', ""); +Expect(0, 43055, '\P{Is_Block=sylotinagri}', ""); +Expect(1, 43055, '\P{^Is_Block=sylotinagri}', ""); +Expect(0, 43007, '\p{Is_Block=sylotinagri}', ""); +Expect(1, 43007, '\p{^Is_Block=sylotinagri}', ""); +Expect(1, 43007, '\P{Is_Block=sylotinagri}', ""); +Expect(0, 43007, '\P{^Is_Block=sylotinagri}', ""); +Expect(1, 43055, '\p{Is_Block= SYLOTInagri}', ""); +Expect(0, 43055, '\p{^Is_Block= SYLOTInagri}', ""); +Expect(0, 43055, '\P{Is_Block= SYLOTInagri}', ""); +Expect(1, 43055, '\P{^Is_Block= SYLOTInagri}', ""); +Expect(0, 43007, '\p{Is_Block= SYLOTInagri}', ""); +Expect(1, 43007, '\p{^Is_Block= SYLOTInagri}', ""); +Expect(1, 43007, '\P{Is_Block= SYLOTInagri}', ""); +Expect(0, 43007, '\P{^Is_Block= SYLOTInagri}', ""); +Error('\p{Is_Blk= :=Syloti NAGRI}'); +Error('\P{Is_Blk= :=Syloti NAGRI}'); +Expect(1, 43055, '\p{Is_Blk:sylotinagri}', ""); +Expect(0, 43055, '\p{^Is_Blk:sylotinagri}', ""); +Expect(0, 43055, '\P{Is_Blk:sylotinagri}', ""); +Expect(1, 43055, '\P{^Is_Blk:sylotinagri}', ""); +Expect(0, 43007, '\p{Is_Blk:sylotinagri}', ""); +Expect(1, 43007, '\p{^Is_Blk:sylotinagri}', ""); +Expect(1, 43007, '\P{Is_Blk:sylotinagri}', ""); +Expect(0, 43007, '\P{^Is_Blk:sylotinagri}', ""); +Expect(1, 43055, '\p{Is_Blk= SYLOTI-Nagri}', ""); +Expect(0, 43055, '\p{^Is_Blk= SYLOTI-Nagri}', ""); +Expect(0, 43055, '\P{Is_Blk= SYLOTI-Nagri}', ""); +Expect(1, 43055, '\P{^Is_Blk= SYLOTI-Nagri}', ""); +Expect(0, 43007, '\p{Is_Blk= SYLOTI-Nagri}', ""); +Expect(1, 43007, '\p{^Is_Blk= SYLOTI-Nagri}', ""); +Expect(1, 43007, '\P{Is_Blk= SYLOTI-Nagri}', ""); +Expect(0, 43007, '\P{^Is_Blk= SYLOTI-Nagri}', ""); +Error('\p{Block=-/a/combiningDiacritical MARKS-Forsymbols}'); +Error('\P{Block=-/a/combiningDiacritical MARKS-Forsymbols}'); +Expect(1, 8447, '\p{Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8447, '\p{^Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8447, '\P{Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8447, '\P{^Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8399, '\p{Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8399, '\p{^Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8399, '\P{Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8399, '\P{^Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8447, '\p{Block=--CombiningDiacritical Marks for Symbols}', ""); +Expect(0, 8447, '\p{^Block=--CombiningDiacritical Marks for Symbols}', ""); +Expect(0, 8447, '\P{Block=--CombiningDiacritical Marks for Symbols}', ""); +Expect(1, 8447, '\P{^Block=--CombiningDiacritical Marks for Symbols}', ""); +Expect(0, 8399, '\p{Block=--CombiningDiacritical Marks for Symbols}', ""); +Expect(1, 8399, '\p{^Block=--CombiningDiacritical Marks for Symbols}', ""); +Expect(1, 8399, '\P{Block=--CombiningDiacritical Marks for Symbols}', ""); +Expect(0, 8399, '\P{^Block=--CombiningDiacritical Marks for Symbols}', ""); +Error('\p{Blk: _combining_marks:=for Symbols}'); +Error('\P{Blk: _combining_marks:=for Symbols}'); +Expect(1, 8447, '\p{Blk=combiningmarksforsymbols}', ""); +Expect(0, 8447, '\p{^Blk=combiningmarksforsymbols}', ""); +Expect(0, 8447, '\P{Blk=combiningmarksforsymbols}', ""); +Expect(1, 8447, '\P{^Blk=combiningmarksforsymbols}', ""); +Expect(0, 8399, '\p{Blk=combiningmarksforsymbols}', ""); +Expect(1, 8399, '\p{^Blk=combiningmarksforsymbols}', ""); +Expect(1, 8399, '\P{Blk=combiningmarksforsymbols}', ""); +Expect(0, 8399, '\P{^Blk=combiningmarksforsymbols}', ""); +Expect(1, 8447, '\p{Blk= COMBINING marks-forSymbols}', ""); +Expect(0, 8447, '\p{^Blk= COMBINING marks-forSymbols}', ""); +Expect(0, 8447, '\P{Blk= COMBINING marks-forSymbols}', ""); +Expect(1, 8447, '\P{^Blk= COMBINING marks-forSymbols}', ""); +Expect(0, 8399, '\p{Blk= COMBINING marks-forSymbols}', ""); +Expect(1, 8399, '\p{^Blk= COMBINING marks-forSymbols}', ""); +Expect(1, 8399, '\P{Blk= COMBINING marks-forSymbols}', ""); +Expect(0, 8399, '\P{^Blk= COMBINING marks-forSymbols}', ""); +Error('\p{Is_Block: Combining/a/diacritical Marks FOR_SYMBOLS}'); +Error('\P{Is_Block: Combining/a/diacritical Marks FOR_SYMBOLS}'); +Expect(1, 8447, '\p{Is_Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8447, '\p{^Is_Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8447, '\P{Is_Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8447, '\P{^Is_Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8399, '\p{Is_Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8399, '\p{^Is_Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8399, '\P{Is_Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8399, '\P{^Is_Block=combiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8447, '\p{Is_Block=_ combining-diacritical_marks for_Symbols}', ""); +Expect(0, 8447, '\p{^Is_Block=_ combining-diacritical_marks for_Symbols}', ""); +Expect(0, 8447, '\P{Is_Block=_ combining-diacritical_marks for_Symbols}', ""); +Expect(1, 8447, '\P{^Is_Block=_ combining-diacritical_marks for_Symbols}', ""); +Expect(0, 8399, '\p{Is_Block=_ combining-diacritical_marks for_Symbols}', ""); +Expect(1, 8399, '\p{^Is_Block=_ combining-diacritical_marks for_Symbols}', ""); +Expect(1, 8399, '\P{Is_Block=_ combining-diacritical_marks for_Symbols}', ""); +Expect(0, 8399, '\P{^Is_Block=_ combining-diacritical_marks for_Symbols}', ""); +Error('\p{Is_Blk= combining/a/marks-for_Symbols}'); +Error('\P{Is_Blk= combining/a/marks-for_Symbols}'); +Expect(1, 8447, '\p{Is_Blk=combiningmarksforsymbols}', ""); +Expect(0, 8447, '\p{^Is_Blk=combiningmarksforsymbols}', ""); +Expect(0, 8447, '\P{Is_Blk=combiningmarksforsymbols}', ""); +Expect(1, 8447, '\P{^Is_Blk=combiningmarksforsymbols}', ""); +Expect(0, 8399, '\p{Is_Blk=combiningmarksforsymbols}', ""); +Expect(1, 8399, '\p{^Is_Blk=combiningmarksforsymbols}', ""); +Expect(1, 8399, '\P{Is_Blk=combiningmarksforsymbols}', ""); +Expect(0, 8399, '\P{^Is_Blk=combiningmarksforsymbols}', ""); +Expect(1, 8447, '\p{Is_Blk: - Combining-marksfor Symbols}', ""); +Expect(0, 8447, '\p{^Is_Blk: - Combining-marksfor Symbols}', ""); +Expect(0, 8447, '\P{Is_Blk: - Combining-marksfor Symbols}', ""); +Expect(1, 8447, '\P{^Is_Blk: - Combining-marksfor Symbols}', ""); +Expect(0, 8399, '\p{Is_Blk: - Combining-marksfor Symbols}', ""); +Expect(1, 8399, '\p{^Is_Blk: - Combining-marksfor Symbols}', ""); +Expect(1, 8399, '\P{Is_Blk: - Combining-marksfor Symbols}', ""); +Expect(0, 8399, '\P{^Is_Blk: - Combining-marksfor Symbols}', ""); +Error('\p{Block=-:=Basic Latin}'); +Error('\P{Block=-:=Basic Latin}'); +Expect(1, 7, '\p{Block=basiclatin}', ""); +Expect(0, 7, '\p{^Block=basiclatin}', ""); +Expect(0, 7, '\P{Block=basiclatin}', ""); +Expect(1, 7, '\P{^Block=basiclatin}', ""); +Expect(0, 256, '\p{Block=basiclatin}', ""); +Expect(1, 256, '\p{^Block=basiclatin}', ""); +Expect(1, 256, '\P{Block=basiclatin}', ""); +Expect(0, 256, '\P{^Block=basiclatin}', ""); +Expect(1, 7, '\p{Block=-Basic_latin}', ""); +Expect(0, 7, '\p{^Block=-Basic_latin}', ""); +Expect(0, 7, '\P{Block=-Basic_latin}', ""); +Expect(1, 7, '\P{^Block=-Basic_latin}', ""); +Expect(0, 256, '\p{Block=-Basic_latin}', ""); +Expect(1, 256, '\p{^Block=-Basic_latin}', ""); +Expect(1, 256, '\P{Block=-Basic_latin}', ""); +Expect(0, 256, '\P{^Block=-Basic_latin}', ""); +Error('\p{Blk:/a/ ascii}'); +Error('\P{Blk:/a/ ascii}'); +Expect(1, 7, '\p{Blk=ascii}', ""); +Expect(0, 7, '\p{^Blk=ascii}', ""); +Expect(0, 7, '\P{Blk=ascii}', ""); +Expect(1, 7, '\P{^Blk=ascii}', ""); +Expect(0, 256, '\p{Blk=ascii}', ""); +Expect(1, 256, '\p{^Blk=ascii}', ""); +Expect(1, 256, '\P{Blk=ascii}', ""); +Expect(0, 256, '\P{^Blk=ascii}', ""); +Expect(1, 7, '\p{Blk=ASCII}', ""); +Expect(0, 7, '\p{^Blk=ASCII}', ""); +Expect(0, 7, '\P{Blk=ASCII}', ""); +Expect(1, 7, '\P{^Blk=ASCII}', ""); +Expect(0, 256, '\p{Blk=ASCII}', ""); +Expect(1, 256, '\p{^Blk=ASCII}', ""); +Expect(1, 256, '\P{Blk=ASCII}', ""); +Expect(0, 256, '\P{^Blk=ASCII}', ""); +Error('\p{Is_Block=- Basic:=latin}'); +Error('\P{Is_Block=- Basic:=latin}'); +Expect(1, 7, '\p{Is_Block=basiclatin}', ""); +Expect(0, 7, '\p{^Is_Block=basiclatin}', ""); +Expect(0, 7, '\P{Is_Block=basiclatin}', ""); +Expect(1, 7, '\P{^Is_Block=basiclatin}', ""); +Expect(0, 256, '\p{Is_Block=basiclatin}', ""); +Expect(1, 256, '\p{^Is_Block=basiclatin}', ""); +Expect(1, 256, '\P{Is_Block=basiclatin}', ""); +Expect(0, 256, '\P{^Is_Block=basiclatin}', ""); +Expect(1, 7, '\p{Is_Block=-_Basic Latin}', ""); +Expect(0, 7, '\p{^Is_Block=-_Basic Latin}', ""); +Expect(0, 7, '\P{Is_Block=-_Basic Latin}', ""); +Expect(1, 7, '\P{^Is_Block=-_Basic Latin}', ""); +Expect(0, 256, '\p{Is_Block=-_Basic Latin}', ""); +Expect(1, 256, '\p{^Is_Block=-_Basic Latin}', ""); +Expect(1, 256, '\P{Is_Block=-_Basic Latin}', ""); +Expect(0, 256, '\P{^Is_Block=-_Basic Latin}', ""); +Error('\p{Is_Blk=:= _ASCII}'); +Error('\P{Is_Blk=:= _ASCII}'); +Expect(1, 7, '\p{Is_Blk=ascii}', ""); +Expect(0, 7, '\p{^Is_Blk=ascii}', ""); +Expect(0, 7, '\P{Is_Blk=ascii}', ""); +Expect(1, 7, '\P{^Is_Blk=ascii}', ""); +Expect(0, 256, '\p{Is_Blk=ascii}', ""); +Expect(1, 256, '\p{^Is_Blk=ascii}', ""); +Expect(1, 256, '\P{Is_Blk=ascii}', ""); +Expect(0, 256, '\P{^Is_Blk=ascii}', ""); +Expect(1, 7, '\p{Is_Blk=_ASCII}', ""); +Expect(0, 7, '\p{^Is_Blk=_ASCII}', ""); +Expect(0, 7, '\P{Is_Blk=_ASCII}', ""); +Expect(1, 7, '\P{^Is_Blk=_ASCII}', ""); +Expect(0, 256, '\p{Is_Blk=_ASCII}', ""); +Expect(1, 256, '\p{^Is_Blk=_ASCII}', ""); +Expect(1, 256, '\P{Is_Blk=_ASCII}', ""); +Expect(0, 256, '\P{^Is_Blk=_ASCII}', ""); +Error('\p{Block:/a/ Limbu}'); +Error('\P{Block:/a/ Limbu}'); +Expect(1, 6479, '\p{Block=limbu}', ""); +Expect(0, 6479, '\p{^Block=limbu}', ""); +Expect(0, 6479, '\P{Block=limbu}', ""); +Expect(1, 6479, '\P{^Block=limbu}', ""); +Expect(0, 6399, '\p{Block=limbu}', ""); +Expect(1, 6399, '\p{^Block=limbu}', ""); +Expect(1, 6399, '\P{Block=limbu}', ""); +Expect(0, 6399, '\P{^Block=limbu}', ""); +Expect(1, 6479, '\p{Block=-_LIMBU}', ""); +Expect(0, 6479, '\p{^Block=-_LIMBU}', ""); +Expect(0, 6479, '\P{Block=-_LIMBU}', ""); +Expect(1, 6479, '\P{^Block=-_LIMBU}', ""); +Expect(0, 6399, '\p{Block=-_LIMBU}', ""); +Expect(1, 6399, '\p{^Block=-_LIMBU}', ""); +Expect(1, 6399, '\P{Block=-_LIMBU}', ""); +Expect(0, 6399, '\P{^Block=-_LIMBU}', ""); +Error('\p{Blk=_Limbu/a/}'); +Error('\P{Blk=_Limbu/a/}'); +Expect(1, 6479, '\p{Blk=limbu}', ""); +Expect(0, 6479, '\p{^Blk=limbu}', ""); +Expect(0, 6479, '\P{Blk=limbu}', ""); +Expect(1, 6479, '\P{^Blk=limbu}', ""); +Expect(0, 6399, '\p{Blk=limbu}', ""); +Expect(1, 6399, '\p{^Blk=limbu}', ""); +Expect(1, 6399, '\P{Blk=limbu}', ""); +Expect(0, 6399, '\P{^Blk=limbu}', ""); +Expect(1, 6479, '\p{Blk: -_LIMBU}', ""); +Expect(0, 6479, '\p{^Blk: -_LIMBU}', ""); +Expect(0, 6479, '\P{Blk: -_LIMBU}', ""); +Expect(1, 6479, '\P{^Blk: -_LIMBU}', ""); +Expect(0, 6399, '\p{Blk: -_LIMBU}', ""); +Expect(1, 6399, '\p{^Blk: -_LIMBU}', ""); +Expect(1, 6399, '\P{Blk: -_LIMBU}', ""); +Expect(0, 6399, '\P{^Blk: -_LIMBU}', ""); +Error('\p{Is_Block= :=Limbu}'); +Error('\P{Is_Block= :=Limbu}'); +Expect(1, 6479, '\p{Is_Block: limbu}', ""); +Expect(0, 6479, '\p{^Is_Block: limbu}', ""); +Expect(0, 6479, '\P{Is_Block: limbu}', ""); +Expect(1, 6479, '\P{^Is_Block: limbu}', ""); +Expect(0, 6399, '\p{Is_Block: limbu}', ""); +Expect(1, 6399, '\p{^Is_Block: limbu}', ""); +Expect(1, 6399, '\P{Is_Block: limbu}', ""); +Expect(0, 6399, '\P{^Is_Block: limbu}', ""); +Expect(1, 6479, '\p{Is_Block=--Limbu}', ""); +Expect(0, 6479, '\p{^Is_Block=--Limbu}', ""); +Expect(0, 6479, '\P{Is_Block=--Limbu}', ""); +Expect(1, 6479, '\P{^Is_Block=--Limbu}', ""); +Expect(0, 6399, '\p{Is_Block=--Limbu}', ""); +Expect(1, 6399, '\p{^Is_Block=--Limbu}', ""); +Expect(1, 6399, '\P{Is_Block=--Limbu}', ""); +Expect(0, 6399, '\P{^Is_Block=--Limbu}', ""); +Error('\p{Is_Blk=/a/-limbu}'); +Error('\P{Is_Blk=/a/-limbu}'); +Expect(1, 6479, '\p{Is_Blk=limbu}', ""); +Expect(0, 6479, '\p{^Is_Blk=limbu}', ""); +Expect(0, 6479, '\P{Is_Blk=limbu}', ""); +Expect(1, 6479, '\P{^Is_Blk=limbu}', ""); +Expect(0, 6399, '\p{Is_Blk=limbu}', ""); +Expect(1, 6399, '\p{^Is_Blk=limbu}', ""); +Expect(1, 6399, '\P{Is_Blk=limbu}', ""); +Expect(0, 6399, '\P{^Is_Blk=limbu}', ""); +Expect(1, 6479, '\p{Is_Blk:__Limbu}', ""); +Expect(0, 6479, '\p{^Is_Blk:__Limbu}', ""); +Expect(0, 6479, '\P{Is_Blk:__Limbu}', ""); +Expect(1, 6479, '\P{^Is_Blk:__Limbu}', ""); +Expect(0, 6399, '\p{Is_Blk:__Limbu}', ""); +Expect(1, 6399, '\p{^Is_Blk:__Limbu}', ""); +Expect(1, 6399, '\P{Is_Blk:__Limbu}', ""); +Expect(0, 6399, '\P{^Is_Blk:__Limbu}', ""); +Error('\p{Block=-Currency:=symbols}'); +Error('\P{Block=-Currency:=symbols}'); +Expect(1, 8399, '\p{Block: currencysymbols}', ""); +Expect(0, 8399, '\p{^Block: currencysymbols}', ""); +Expect(0, 8399, '\P{Block: currencysymbols}', ""); +Expect(1, 8399, '\P{^Block: currencysymbols}', ""); +Expect(0, 8351, '\p{Block: currencysymbols}', ""); +Expect(1, 8351, '\p{^Block: currencysymbols}', ""); +Expect(1, 8351, '\P{Block: currencysymbols}', ""); +Expect(0, 8351, '\P{^Block: currencysymbols}', ""); +Expect(1, 8399, '\p{Block=_currency symbols}', ""); +Expect(0, 8399, '\p{^Block=_currency symbols}', ""); +Expect(0, 8399, '\P{Block=_currency symbols}', ""); +Expect(1, 8399, '\P{^Block=_currency symbols}', ""); +Expect(0, 8351, '\p{Block=_currency symbols}', ""); +Expect(1, 8351, '\p{^Block=_currency symbols}', ""); +Expect(1, 8351, '\P{Block=_currency symbols}', ""); +Expect(0, 8351, '\P{^Block=_currency symbols}', ""); +Error('\p{Blk= _Currency-symbols/a/}'); +Error('\P{Blk= _Currency-symbols/a/}'); +Expect(1, 8399, '\p{Blk: currencysymbols}', ""); +Expect(0, 8399, '\p{^Blk: currencysymbols}', ""); +Expect(0, 8399, '\P{Blk: currencysymbols}', ""); +Expect(1, 8399, '\P{^Blk: currencysymbols}', ""); +Expect(0, 8351, '\p{Blk: currencysymbols}', ""); +Expect(1, 8351, '\p{^Blk: currencysymbols}', ""); +Expect(1, 8351, '\P{Blk: currencysymbols}', ""); +Expect(0, 8351, '\P{^Blk: currencysymbols}', ""); +Expect(1, 8399, '\p{Blk= currency SYMBOLS}', ""); +Expect(0, 8399, '\p{^Blk= currency SYMBOLS}', ""); +Expect(0, 8399, '\P{Blk= currency SYMBOLS}', ""); +Expect(1, 8399, '\P{^Blk= currency SYMBOLS}', ""); +Expect(0, 8351, '\p{Blk= currency SYMBOLS}', ""); +Expect(1, 8351, '\p{^Blk= currency SYMBOLS}', ""); +Expect(1, 8351, '\P{Blk= currency SYMBOLS}', ""); +Expect(0, 8351, '\P{^Blk= currency SYMBOLS}', ""); +Error('\p{Is_Block=:=Currency Symbols}'); +Error('\P{Is_Block=:=Currency Symbols}'); +Expect(1, 8399, '\p{Is_Block=currencysymbols}', ""); +Expect(0, 8399, '\p{^Is_Block=currencysymbols}', ""); +Expect(0, 8399, '\P{Is_Block=currencysymbols}', ""); +Expect(1, 8399, '\P{^Is_Block=currencysymbols}', ""); +Expect(0, 8351, '\p{Is_Block=currencysymbols}', ""); +Expect(1, 8351, '\p{^Is_Block=currencysymbols}', ""); +Expect(1, 8351, '\P{Is_Block=currencysymbols}', ""); +Expect(0, 8351, '\P{^Is_Block=currencysymbols}', ""); +Expect(1, 8399, '\p{Is_Block=-CURRENCY SYMBOLS}', ""); +Expect(0, 8399, '\p{^Is_Block=-CURRENCY SYMBOLS}', ""); +Expect(0, 8399, '\P{Is_Block=-CURRENCY SYMBOLS}', ""); +Expect(1, 8399, '\P{^Is_Block=-CURRENCY SYMBOLS}', ""); +Expect(0, 8351, '\p{Is_Block=-CURRENCY SYMBOLS}', ""); +Expect(1, 8351, '\p{^Is_Block=-CURRENCY SYMBOLS}', ""); +Expect(1, 8351, '\P{Is_Block=-CURRENCY SYMBOLS}', ""); +Expect(0, 8351, '\P{^Is_Block=-CURRENCY SYMBOLS}', ""); +Error('\p{Is_Blk=/a/_-currency-symbols}'); +Error('\P{Is_Blk=/a/_-currency-symbols}'); +Expect(1, 8399, '\p{Is_Blk=currencysymbols}', ""); +Expect(0, 8399, '\p{^Is_Blk=currencysymbols}', ""); +Expect(0, 8399, '\P{Is_Blk=currencysymbols}', ""); +Expect(1, 8399, '\P{^Is_Blk=currencysymbols}', ""); +Expect(0, 8351, '\p{Is_Blk=currencysymbols}', ""); +Expect(1, 8351, '\p{^Is_Blk=currencysymbols}', ""); +Expect(1, 8351, '\P{Is_Blk=currencysymbols}', ""); +Expect(0, 8351, '\P{^Is_Blk=currencysymbols}', ""); +Expect(1, 8399, '\p{Is_Blk= currencySYMBOLS}', ""); +Expect(0, 8399, '\p{^Is_Blk= currencySYMBOLS}', ""); +Expect(0, 8399, '\P{Is_Blk= currencySYMBOLS}', ""); +Expect(1, 8399, '\P{^Is_Blk= currencySYMBOLS}', ""); +Expect(0, 8351, '\p{Is_Blk= currencySYMBOLS}', ""); +Expect(1, 8351, '\p{^Is_Blk= currencySYMBOLS}', ""); +Expect(1, 8351, '\P{Is_Blk= currencySYMBOLS}', ""); +Expect(0, 8351, '\P{^Is_Blk= currencySYMBOLS}', ""); +Error('\p{Block=_/a/spacing Modifier_Letters}'); +Error('\P{Block=_/a/spacing Modifier_Letters}'); +Expect(1, 767, '\p{Block=spacingmodifierletters}', ""); +Expect(0, 767, '\p{^Block=spacingmodifierletters}', ""); +Expect(0, 767, '\P{Block=spacingmodifierletters}', ""); +Expect(1, 767, '\P{^Block=spacingmodifierletters}', ""); +Expect(0, 687, '\p{Block=spacingmodifierletters}', ""); +Expect(1, 687, '\p{^Block=spacingmodifierletters}', ""); +Expect(1, 687, '\P{Block=spacingmodifierletters}', ""); +Expect(0, 687, '\P{^Block=spacingmodifierletters}', ""); +Expect(1, 767, '\p{Block=-_SPACING_Modifier_LETTERS}', ""); +Expect(0, 767, '\p{^Block=-_SPACING_Modifier_LETTERS}', ""); +Expect(0, 767, '\P{Block=-_SPACING_Modifier_LETTERS}', ""); +Expect(1, 767, '\P{^Block=-_SPACING_Modifier_LETTERS}', ""); +Expect(0, 687, '\p{Block=-_SPACING_Modifier_LETTERS}', ""); +Expect(1, 687, '\p{^Block=-_SPACING_Modifier_LETTERS}', ""); +Expect(1, 687, '\P{Block=-_SPACING_Modifier_LETTERS}', ""); +Expect(0, 687, '\P{^Block=-_SPACING_Modifier_LETTERS}', ""); +Error('\p{Blk=- Spacing-modifier/a/letters}'); +Error('\P{Blk=- Spacing-modifier/a/letters}'); +Expect(1, 767, '\p{Blk=spacingmodifierletters}', ""); +Expect(0, 767, '\p{^Blk=spacingmodifierletters}', ""); +Expect(0, 767, '\P{Blk=spacingmodifierletters}', ""); +Expect(1, 767, '\P{^Blk=spacingmodifierletters}', ""); +Expect(0, 687, '\p{Blk=spacingmodifierletters}', ""); +Expect(1, 687, '\p{^Blk=spacingmodifierletters}', ""); +Expect(1, 687, '\P{Blk=spacingmodifierletters}', ""); +Expect(0, 687, '\P{^Blk=spacingmodifierletters}', ""); +Expect(1, 767, '\p{Blk=-_Spacing-MODIFIER Letters}', ""); +Expect(0, 767, '\p{^Blk=-_Spacing-MODIFIER Letters}', ""); +Expect(0, 767, '\P{Blk=-_Spacing-MODIFIER Letters}', ""); +Expect(1, 767, '\P{^Blk=-_Spacing-MODIFIER Letters}', ""); +Expect(0, 687, '\p{Blk=-_Spacing-MODIFIER Letters}', ""); +Expect(1, 687, '\p{^Blk=-_Spacing-MODIFIER Letters}', ""); +Expect(1, 687, '\P{Blk=-_Spacing-MODIFIER Letters}', ""); +Expect(0, 687, '\P{^Blk=-_Spacing-MODIFIER Letters}', ""); +Error('\p{Is_Block=--Spacing:=modifier LETTERS}'); +Error('\P{Is_Block=--Spacing:=modifier LETTERS}'); +Expect(1, 767, '\p{Is_Block=spacingmodifierletters}', ""); +Expect(0, 767, '\p{^Is_Block=spacingmodifierletters}', ""); +Expect(0, 767, '\P{Is_Block=spacingmodifierletters}', ""); +Expect(1, 767, '\P{^Is_Block=spacingmodifierletters}', ""); +Expect(0, 687, '\p{Is_Block=spacingmodifierletters}', ""); +Expect(1, 687, '\p{^Is_Block=spacingmodifierletters}', ""); +Expect(1, 687, '\P{Is_Block=spacingmodifierletters}', ""); +Expect(0, 687, '\P{^Is_Block=spacingmodifierletters}', ""); +Expect(1, 767, '\p{Is_Block=_spacing-MODIFIER Letters}', ""); +Expect(0, 767, '\p{^Is_Block=_spacing-MODIFIER Letters}', ""); +Expect(0, 767, '\P{Is_Block=_spacing-MODIFIER Letters}', ""); +Expect(1, 767, '\P{^Is_Block=_spacing-MODIFIER Letters}', ""); +Expect(0, 687, '\p{Is_Block=_spacing-MODIFIER Letters}', ""); +Expect(1, 687, '\p{^Is_Block=_spacing-MODIFIER Letters}', ""); +Expect(1, 687, '\P{Is_Block=_spacing-MODIFIER Letters}', ""); +Expect(0, 687, '\P{^Is_Block=_spacing-MODIFIER Letters}', ""); +Error('\p{Is_Blk=:= Spacing-modifier Letters}'); +Error('\P{Is_Blk=:= Spacing-modifier Letters}'); +Expect(1, 767, '\p{Is_Blk=spacingmodifierletters}', ""); +Expect(0, 767, '\p{^Is_Blk=spacingmodifierletters}', ""); +Expect(0, 767, '\P{Is_Blk=spacingmodifierletters}', ""); +Expect(1, 767, '\P{^Is_Blk=spacingmodifierletters}', ""); +Expect(0, 687, '\p{Is_Blk=spacingmodifierletters}', ""); +Expect(1, 687, '\p{^Is_Blk=spacingmodifierletters}', ""); +Expect(1, 687, '\P{Is_Blk=spacingmodifierletters}', ""); +Expect(0, 687, '\P{^Is_Blk=spacingmodifierletters}', ""); +Expect(1, 767, '\p{Is_Blk= Spacing-MODIFIERletters}', ""); +Expect(0, 767, '\p{^Is_Blk= Spacing-MODIFIERletters}', ""); +Expect(0, 767, '\P{Is_Blk= Spacing-MODIFIERletters}', ""); +Expect(1, 767, '\P{^Is_Blk= Spacing-MODIFIERletters}', ""); +Expect(0, 687, '\p{Is_Blk= Spacing-MODIFIERletters}', ""); +Expect(1, 687, '\p{^Is_Blk= Spacing-MODIFIERletters}', ""); +Expect(1, 687, '\P{Is_Blk= Spacing-MODIFIERletters}', ""); +Expect(0, 687, '\P{^Is_Blk= Spacing-MODIFIERletters}', ""); +Error('\p{Block= Box:=drawing}'); +Error('\P{Block= Box:=drawing}'); +Expect(1, 9599, '\p{Block:boxdrawing}', ""); +Expect(0, 9599, '\p{^Block:boxdrawing}', ""); +Expect(0, 9599, '\P{Block:boxdrawing}', ""); +Expect(1, 9599, '\P{^Block:boxdrawing}', ""); +Expect(0, 9471, '\p{Block:boxdrawing}', ""); +Expect(1, 9471, '\p{^Block:boxdrawing}', ""); +Expect(1, 9471, '\P{Block:boxdrawing}', ""); +Expect(0, 9471, '\P{^Block:boxdrawing}', ""); +Expect(1, 9599, '\p{Block:__BOX-DRAWING}', ""); +Expect(0, 9599, '\p{^Block:__BOX-DRAWING}', ""); +Expect(0, 9599, '\P{Block:__BOX-DRAWING}', ""); +Expect(1, 9599, '\P{^Block:__BOX-DRAWING}', ""); +Expect(0, 9471, '\p{Block:__BOX-DRAWING}', ""); +Expect(1, 9471, '\p{^Block:__BOX-DRAWING}', ""); +Expect(1, 9471, '\P{Block:__BOX-DRAWING}', ""); +Expect(0, 9471, '\P{^Block:__BOX-DRAWING}', ""); +Error('\p{Blk: -box_Drawing/a/}'); +Error('\P{Blk: -box_Drawing/a/}'); +Expect(1, 9599, '\p{Blk=boxdrawing}', ""); +Expect(0, 9599, '\p{^Blk=boxdrawing}', ""); +Expect(0, 9599, '\P{Blk=boxdrawing}', ""); +Expect(1, 9599, '\P{^Blk=boxdrawing}', ""); +Expect(0, 9471, '\p{Blk=boxdrawing}', ""); +Expect(1, 9471, '\p{^Blk=boxdrawing}', ""); +Expect(1, 9471, '\P{Blk=boxdrawing}', ""); +Expect(0, 9471, '\P{^Blk=boxdrawing}', ""); +Expect(1, 9599, '\p{Blk=_ Box_Drawing}', ""); +Expect(0, 9599, '\p{^Blk=_ Box_Drawing}', ""); +Expect(0, 9599, '\P{Blk=_ Box_Drawing}', ""); +Expect(1, 9599, '\P{^Blk=_ Box_Drawing}', ""); +Expect(0, 9471, '\p{Blk=_ Box_Drawing}', ""); +Expect(1, 9471, '\p{^Blk=_ Box_Drawing}', ""); +Expect(1, 9471, '\P{Blk=_ Box_Drawing}', ""); +Expect(0, 9471, '\P{^Blk=_ Box_Drawing}', ""); +Error('\p{Is_Block=_ Box:=Drawing}'); +Error('\P{Is_Block=_ Box:=Drawing}'); +Expect(1, 9599, '\p{Is_Block=boxdrawing}', ""); +Expect(0, 9599, '\p{^Is_Block=boxdrawing}', ""); +Expect(0, 9599, '\P{Is_Block=boxdrawing}', ""); +Expect(1, 9599, '\P{^Is_Block=boxdrawing}', ""); +Expect(0, 9471, '\p{Is_Block=boxdrawing}', ""); +Expect(1, 9471, '\p{^Is_Block=boxdrawing}', ""); +Expect(1, 9471, '\P{Is_Block=boxdrawing}', ""); +Expect(0, 9471, '\P{^Is_Block=boxdrawing}', ""); +Expect(1, 9599, '\p{Is_Block=_Box_Drawing}', ""); +Expect(0, 9599, '\p{^Is_Block=_Box_Drawing}', ""); +Expect(0, 9599, '\P{Is_Block=_Box_Drawing}', ""); +Expect(1, 9599, '\P{^Is_Block=_Box_Drawing}', ""); +Expect(0, 9471, '\p{Is_Block=_Box_Drawing}', ""); +Expect(1, 9471, '\p{^Is_Block=_Box_Drawing}', ""); +Expect(1, 9471, '\P{Is_Block=_Box_Drawing}', ""); +Expect(0, 9471, '\P{^Is_Block=_Box_Drawing}', ""); +Error('\p{Is_Blk=_-BOX_Drawing:=}'); +Error('\P{Is_Blk=_-BOX_Drawing:=}'); +Expect(1, 9599, '\p{Is_Blk=boxdrawing}', ""); +Expect(0, 9599, '\p{^Is_Blk=boxdrawing}', ""); +Expect(0, 9599, '\P{Is_Blk=boxdrawing}', ""); +Expect(1, 9599, '\P{^Is_Blk=boxdrawing}', ""); +Expect(0, 9471, '\p{Is_Blk=boxdrawing}', ""); +Expect(1, 9471, '\p{^Is_Blk=boxdrawing}', ""); +Expect(1, 9471, '\P{Is_Blk=boxdrawing}', ""); +Expect(0, 9471, '\P{^Is_Blk=boxdrawing}', ""); +Expect(1, 9599, '\p{Is_Blk= -box drawing}', ""); +Expect(0, 9599, '\p{^Is_Blk= -box drawing}', ""); +Expect(0, 9599, '\P{Is_Blk= -box drawing}', ""); +Expect(1, 9599, '\P{^Is_Blk= -box drawing}', ""); +Expect(0, 9471, '\p{Is_Blk= -box drawing}', ""); +Expect(1, 9471, '\p{^Is_Blk= -box drawing}', ""); +Expect(1, 9471, '\P{Is_Blk= -box drawing}', ""); +Expect(0, 9471, '\P{^Is_Blk= -box drawing}', ""); +Error('\p{Block: SUPERSCRIPTSAnd SUBSCRIPTS:=}'); +Error('\P{Block: SUPERSCRIPTSAnd SUBSCRIPTS:=}'); +Expect(1, 8351, '\p{Block=superscriptsandsubscripts}', ""); +Expect(0, 8351, '\p{^Block=superscriptsandsubscripts}', ""); +Expect(0, 8351, '\P{Block=superscriptsandsubscripts}', ""); +Expect(1, 8351, '\P{^Block=superscriptsandsubscripts}', ""); +Expect(0, 8303, '\p{Block=superscriptsandsubscripts}', ""); +Expect(1, 8303, '\p{^Block=superscriptsandsubscripts}', ""); +Expect(1, 8303, '\P{Block=superscriptsandsubscripts}', ""); +Expect(0, 8303, '\P{^Block=superscriptsandsubscripts}', ""); +Expect(1, 8351, '\p{Block=_superscripts_AndSubscripts}', ""); +Expect(0, 8351, '\p{^Block=_superscripts_AndSubscripts}', ""); +Expect(0, 8351, '\P{Block=_superscripts_AndSubscripts}', ""); +Expect(1, 8351, '\P{^Block=_superscripts_AndSubscripts}', ""); +Expect(0, 8303, '\p{Block=_superscripts_AndSubscripts}', ""); +Expect(1, 8303, '\p{^Block=_superscripts_AndSubscripts}', ""); +Expect(1, 8303, '\P{Block=_superscripts_AndSubscripts}', ""); +Expect(0, 8303, '\P{^Block=_superscripts_AndSubscripts}', ""); +Error('\p{Blk=__superscripts/a/And_Subscripts}'); +Error('\P{Blk=__superscripts/a/And_Subscripts}'); +Expect(1, 8351, '\p{Blk=superscriptsandsubscripts}', ""); +Expect(0, 8351, '\p{^Blk=superscriptsandsubscripts}', ""); +Expect(0, 8351, '\P{Blk=superscriptsandsubscripts}', ""); +Expect(1, 8351, '\P{^Blk=superscriptsandsubscripts}', ""); +Expect(0, 8303, '\p{Blk=superscriptsandsubscripts}', ""); +Expect(1, 8303, '\p{^Blk=superscriptsandsubscripts}', ""); +Expect(1, 8303, '\P{Blk=superscriptsandsubscripts}', ""); +Expect(0, 8303, '\P{^Blk=superscriptsandsubscripts}', ""); +Expect(1, 8351, '\p{Blk= Superscripts_andsubscripts}', ""); +Expect(0, 8351, '\p{^Blk= Superscripts_andsubscripts}', ""); +Expect(0, 8351, '\P{Blk= Superscripts_andsubscripts}', ""); +Expect(1, 8351, '\P{^Blk= Superscripts_andsubscripts}', ""); +Expect(0, 8303, '\p{Blk= Superscripts_andsubscripts}', ""); +Expect(1, 8303, '\p{^Blk= Superscripts_andsubscripts}', ""); +Expect(1, 8303, '\P{Blk= Superscripts_andsubscripts}', ""); +Expect(0, 8303, '\P{^Blk= Superscripts_andsubscripts}', ""); +Error('\p{Is_Block= /a/SUPERSCRIPTSAnd Subscripts}'); +Error('\P{Is_Block= /a/SUPERSCRIPTSAnd Subscripts}'); +Expect(1, 8351, '\p{Is_Block=superscriptsandsubscripts}', ""); +Expect(0, 8351, '\p{^Is_Block=superscriptsandsubscripts}', ""); +Expect(0, 8351, '\P{Is_Block=superscriptsandsubscripts}', ""); +Expect(1, 8351, '\P{^Is_Block=superscriptsandsubscripts}', ""); +Expect(0, 8303, '\p{Is_Block=superscriptsandsubscripts}', ""); +Expect(1, 8303, '\p{^Is_Block=superscriptsandsubscripts}', ""); +Expect(1, 8303, '\P{Is_Block=superscriptsandsubscripts}', ""); +Expect(0, 8303, '\P{^Is_Block=superscriptsandsubscripts}', ""); +Expect(1, 8351, '\p{Is_Block= Superscripts-and Subscripts}', ""); +Expect(0, 8351, '\p{^Is_Block= Superscripts-and Subscripts}', ""); +Expect(0, 8351, '\P{Is_Block= Superscripts-and Subscripts}', ""); +Expect(1, 8351, '\P{^Is_Block= Superscripts-and Subscripts}', ""); +Expect(0, 8303, '\p{Is_Block= Superscripts-and Subscripts}', ""); +Expect(1, 8303, '\p{^Is_Block= Superscripts-and Subscripts}', ""); +Expect(1, 8303, '\P{Is_Block= Superscripts-and Subscripts}', ""); +Expect(0, 8303, '\P{^Is_Block= Superscripts-and Subscripts}', ""); +Error('\p{Is_Blk=-/a/SUPERSCRIPTS-And Subscripts}'); +Error('\P{Is_Blk=-/a/SUPERSCRIPTS-And Subscripts}'); +Expect(1, 8351, '\p{Is_Blk=superscriptsandsubscripts}', ""); +Expect(0, 8351, '\p{^Is_Blk=superscriptsandsubscripts}', ""); +Expect(0, 8351, '\P{Is_Blk=superscriptsandsubscripts}', ""); +Expect(1, 8351, '\P{^Is_Blk=superscriptsandsubscripts}', ""); +Expect(0, 8303, '\p{Is_Blk=superscriptsandsubscripts}', ""); +Expect(1, 8303, '\p{^Is_Blk=superscriptsandsubscripts}', ""); +Expect(1, 8303, '\P{Is_Blk=superscriptsandsubscripts}', ""); +Expect(0, 8303, '\P{^Is_Blk=superscriptsandsubscripts}', ""); +Expect(1, 8351, '\p{Is_Blk= Superscripts-And_SUBSCRIPTS}', ""); +Expect(0, 8351, '\p{^Is_Blk= Superscripts-And_SUBSCRIPTS}', ""); +Expect(0, 8351, '\P{Is_Blk= Superscripts-And_SUBSCRIPTS}', ""); +Expect(1, 8351, '\P{^Is_Blk= Superscripts-And_SUBSCRIPTS}', ""); +Expect(0, 8303, '\p{Is_Blk= Superscripts-And_SUBSCRIPTS}', ""); +Expect(1, 8303, '\p{^Is_Blk= Superscripts-And_SUBSCRIPTS}', ""); +Expect(1, 8303, '\P{Is_Blk= Superscripts-And_SUBSCRIPTS}', ""); +Expect(0, 8303, '\P{^Is_Blk= Superscripts-And_SUBSCRIPTS}', ""); +Error('\p{Block=:=ANCIENT_Greek Numbers}'); +Error('\P{Block=:=ANCIENT_Greek Numbers}'); +Expect(1, 65935, '\p{Block=ancientgreeknumbers}', ""); +Expect(0, 65935, '\p{^Block=ancientgreeknumbers}', ""); +Expect(0, 65935, '\P{Block=ancientgreeknumbers}', ""); +Expect(1, 65935, '\P{^Block=ancientgreeknumbers}', ""); +Expect(0, 65855, '\p{Block=ancientgreeknumbers}', ""); +Expect(1, 65855, '\p{^Block=ancientgreeknumbers}', ""); +Expect(1, 65855, '\P{Block=ancientgreeknumbers}', ""); +Expect(0, 65855, '\P{^Block=ancientgreeknumbers}', ""); +Expect(1, 65935, '\p{Block= -Ancient GREEKNumbers}', ""); +Expect(0, 65935, '\p{^Block= -Ancient GREEKNumbers}', ""); +Expect(0, 65935, '\P{Block= -Ancient GREEKNumbers}', ""); +Expect(1, 65935, '\P{^Block= -Ancient GREEKNumbers}', ""); +Expect(0, 65855, '\p{Block= -Ancient GREEKNumbers}', ""); +Expect(1, 65855, '\p{^Block= -Ancient GREEKNumbers}', ""); +Expect(1, 65855, '\P{Block= -Ancient GREEKNumbers}', ""); +Expect(0, 65855, '\P{^Block= -Ancient GREEKNumbers}', ""); +Error('\p{Blk= /a/ANCIENT-Greek Numbers}'); +Error('\P{Blk= /a/ANCIENT-Greek Numbers}'); +Expect(1, 65935, '\p{Blk=ancientgreeknumbers}', ""); +Expect(0, 65935, '\p{^Blk=ancientgreeknumbers}', ""); +Expect(0, 65935, '\P{Blk=ancientgreeknumbers}', ""); +Expect(1, 65935, '\P{^Blk=ancientgreeknumbers}', ""); +Expect(0, 65855, '\p{Blk=ancientgreeknumbers}', ""); +Expect(1, 65855, '\p{^Blk=ancientgreeknumbers}', ""); +Expect(1, 65855, '\P{Blk=ancientgreeknumbers}', ""); +Expect(0, 65855, '\P{^Blk=ancientgreeknumbers}', ""); +Expect(1, 65935, '\p{Blk=_-ancient-Greek_numbers}', ""); +Expect(0, 65935, '\p{^Blk=_-ancient-Greek_numbers}', ""); +Expect(0, 65935, '\P{Blk=_-ancient-Greek_numbers}', ""); +Expect(1, 65935, '\P{^Blk=_-ancient-Greek_numbers}', ""); +Expect(0, 65855, '\p{Blk=_-ancient-Greek_numbers}', ""); +Expect(1, 65855, '\p{^Blk=_-ancient-Greek_numbers}', ""); +Expect(1, 65855, '\P{Blk=_-ancient-Greek_numbers}', ""); +Expect(0, 65855, '\P{^Blk=_-ancient-Greek_numbers}', ""); +Error('\p{Is_Block=_-Ancient GreekNumbers/a/}'); +Error('\P{Is_Block=_-Ancient GreekNumbers/a/}'); +Expect(1, 65935, '\p{Is_Block=ancientgreeknumbers}', ""); +Expect(0, 65935, '\p{^Is_Block=ancientgreeknumbers}', ""); +Expect(0, 65935, '\P{Is_Block=ancientgreeknumbers}', ""); +Expect(1, 65935, '\P{^Is_Block=ancientgreeknumbers}', ""); +Expect(0, 65855, '\p{Is_Block=ancientgreeknumbers}', ""); +Expect(1, 65855, '\p{^Is_Block=ancientgreeknumbers}', ""); +Expect(1, 65855, '\P{Is_Block=ancientgreeknumbers}', ""); +Expect(0, 65855, '\P{^Is_Block=ancientgreeknumbers}', ""); +Expect(1, 65935, '\p{Is_Block=_AncientGreek Numbers}', ""); +Expect(0, 65935, '\p{^Is_Block=_AncientGreek Numbers}', ""); +Expect(0, 65935, '\P{Is_Block=_AncientGreek Numbers}', ""); +Expect(1, 65935, '\P{^Is_Block=_AncientGreek Numbers}', ""); +Expect(0, 65855, '\p{Is_Block=_AncientGreek Numbers}', ""); +Expect(1, 65855, '\p{^Is_Block=_AncientGreek Numbers}', ""); +Expect(1, 65855, '\P{Is_Block=_AncientGreek Numbers}', ""); +Expect(0, 65855, '\P{^Is_Block=_AncientGreek Numbers}', ""); +Error('\p{Is_Blk=- ancient/a/greek Numbers}'); +Error('\P{Is_Blk=- ancient/a/greek Numbers}'); +Expect(1, 65935, '\p{Is_Blk=ancientgreeknumbers}', ""); +Expect(0, 65935, '\p{^Is_Blk=ancientgreeknumbers}', ""); +Expect(0, 65935, '\P{Is_Blk=ancientgreeknumbers}', ""); +Expect(1, 65935, '\P{^Is_Blk=ancientgreeknumbers}', ""); +Expect(0, 65855, '\p{Is_Blk=ancientgreeknumbers}', ""); +Expect(1, 65855, '\p{^Is_Blk=ancientgreeknumbers}', ""); +Expect(1, 65855, '\P{Is_Blk=ancientgreeknumbers}', ""); +Expect(0, 65855, '\P{^Is_Blk=ancientgreeknumbers}', ""); +Expect(1, 65935, '\p{Is_Blk=_ANCIENTGreeknumbers}', ""); +Expect(0, 65935, '\p{^Is_Blk=_ANCIENTGreeknumbers}', ""); +Expect(0, 65935, '\P{Is_Blk=_ANCIENTGreeknumbers}', ""); +Expect(1, 65935, '\P{^Is_Blk=_ANCIENTGreeknumbers}', ""); +Expect(0, 65855, '\p{Is_Blk=_ANCIENTGreeknumbers}', ""); +Expect(1, 65855, '\p{^Is_Blk=_ANCIENTGreeknumbers}', ""); +Expect(1, 65855, '\P{Is_Blk=_ANCIENTGreeknumbers}', ""); +Expect(0, 65855, '\P{^Is_Blk=_ANCIENTGreeknumbers}', ""); +Error('\p{Block=/a/ NKo}'); +Error('\P{Block=/a/ NKo}'); +Expect(1, 2047, '\p{Block=nko}', ""); +Expect(0, 2047, '\p{^Block=nko}', ""); +Expect(0, 2047, '\P{Block=nko}', ""); +Expect(1, 2047, '\P{^Block=nko}', ""); +Expect(0, 1983, '\p{Block=nko}', ""); +Expect(1, 1983, '\p{^Block=nko}', ""); +Expect(1, 1983, '\P{Block=nko}', ""); +Expect(0, 1983, '\P{^Block=nko}', ""); +Expect(1, 2047, '\p{Block=_ NKo}', ""); +Expect(0, 2047, '\p{^Block=_ NKo}', ""); +Expect(0, 2047, '\P{Block=_ NKo}', ""); +Expect(1, 2047, '\P{^Block=_ NKo}', ""); +Expect(0, 1983, '\p{Block=_ NKo}', ""); +Expect(1, 1983, '\p{^Block=_ NKo}', ""); +Expect(1, 1983, '\P{Block=_ NKo}', ""); +Expect(0, 1983, '\P{^Block=_ NKo}', ""); +Error('\p{Blk: :=NKO}'); +Error('\P{Blk: :=NKO}'); +Expect(1, 2047, '\p{Blk=nko}', ""); +Expect(0, 2047, '\p{^Blk=nko}', ""); +Expect(0, 2047, '\P{Blk=nko}', ""); +Expect(1, 2047, '\P{^Blk=nko}', ""); +Expect(0, 1983, '\p{Blk=nko}', ""); +Expect(1, 1983, '\p{^Blk=nko}', ""); +Expect(1, 1983, '\P{Blk=nko}', ""); +Expect(0, 1983, '\P{^Blk=nko}', ""); +Expect(1, 2047, '\p{Blk=_NKo}', ""); +Expect(0, 2047, '\p{^Blk=_NKo}', ""); +Expect(0, 2047, '\P{Blk=_NKo}', ""); +Expect(1, 2047, '\P{^Blk=_NKo}', ""); +Expect(0, 1983, '\p{Blk=_NKo}', ""); +Expect(1, 1983, '\p{^Blk=_NKo}', ""); +Expect(1, 1983, '\P{Blk=_NKo}', ""); +Expect(0, 1983, '\P{^Blk=_NKo}', ""); +Error('\p{Is_Block= nko/a/}'); +Error('\P{Is_Block= nko/a/}'); +Expect(1, 2047, '\p{Is_Block=nko}', ""); +Expect(0, 2047, '\p{^Is_Block=nko}', ""); +Expect(0, 2047, '\P{Is_Block=nko}', ""); +Expect(1, 2047, '\P{^Is_Block=nko}', ""); +Expect(0, 1983, '\p{Is_Block=nko}', ""); +Expect(1, 1983, '\p{^Is_Block=nko}', ""); +Expect(1, 1983, '\P{Is_Block=nko}', ""); +Expect(0, 1983, '\P{^Is_Block=nko}', ""); +Expect(1, 2047, '\p{Is_Block=--NKO}', ""); +Expect(0, 2047, '\p{^Is_Block=--NKO}', ""); +Expect(0, 2047, '\P{Is_Block=--NKO}', ""); +Expect(1, 2047, '\P{^Is_Block=--NKO}', ""); +Expect(0, 1983, '\p{Is_Block=--NKO}', ""); +Expect(1, 1983, '\p{^Is_Block=--NKO}', ""); +Expect(1, 1983, '\P{Is_Block=--NKO}', ""); +Expect(0, 1983, '\P{^Is_Block=--NKO}', ""); +Error('\p{Is_Blk: := NKO}'); +Error('\P{Is_Blk: := NKO}'); +Expect(1, 2047, '\p{Is_Blk=nko}', ""); +Expect(0, 2047, '\p{^Is_Blk=nko}', ""); +Expect(0, 2047, '\P{Is_Blk=nko}', ""); +Expect(1, 2047, '\P{^Is_Blk=nko}', ""); +Expect(0, 1983, '\p{Is_Blk=nko}', ""); +Expect(1, 1983, '\p{^Is_Blk=nko}', ""); +Expect(1, 1983, '\P{Is_Blk=nko}', ""); +Expect(0, 1983, '\P{^Is_Blk=nko}', ""); +Expect(1, 2047, '\p{Is_Blk= _NKO}', ""); +Expect(0, 2047, '\p{^Is_Blk= _NKO}', ""); +Expect(0, 2047, '\P{Is_Blk= _NKO}', ""); +Expect(1, 2047, '\P{^Is_Blk= _NKO}', ""); +Expect(0, 1983, '\p{Is_Blk= _NKO}', ""); +Expect(1, 1983, '\p{^Is_Blk= _NKO}', ""); +Expect(1, 1983, '\P{Is_Blk= _NKO}', ""); +Expect(0, 1983, '\P{^Is_Blk= _NKO}', ""); +Error('\p{Block=_/a/musical-Symbols}'); +Error('\P{Block=_/a/musical-Symbols}'); +Expect(1, 119295, '\p{Block=musicalsymbols}', ""); +Expect(0, 119295, '\p{^Block=musicalsymbols}', ""); +Expect(0, 119295, '\P{Block=musicalsymbols}', ""); +Expect(1, 119295, '\P{^Block=musicalsymbols}', ""); +Expect(0, 119039, '\p{Block=musicalsymbols}', ""); +Expect(1, 119039, '\p{^Block=musicalsymbols}', ""); +Expect(1, 119039, '\P{Block=musicalsymbols}', ""); +Expect(0, 119039, '\P{^Block=musicalsymbols}', ""); +Expect(1, 119295, '\p{Block=- musical-Symbols}', ""); +Expect(0, 119295, '\p{^Block=- musical-Symbols}', ""); +Expect(0, 119295, '\P{Block=- musical-Symbols}', ""); +Expect(1, 119295, '\P{^Block=- musical-Symbols}', ""); +Expect(0, 119039, '\p{Block=- musical-Symbols}', ""); +Expect(1, 119039, '\p{^Block=- musical-Symbols}', ""); +Expect(1, 119039, '\P{Block=- musical-Symbols}', ""); +Expect(0, 119039, '\P{^Block=- musical-Symbols}', ""); +Error('\p{Blk=-_Musical/a/SYMBOLS}'); +Error('\P{Blk=-_Musical/a/SYMBOLS}'); +Expect(1, 119295, '\p{Blk=musicalsymbols}', ""); +Expect(0, 119295, '\p{^Blk=musicalsymbols}', ""); +Expect(0, 119295, '\P{Blk=musicalsymbols}', ""); +Expect(1, 119295, '\P{^Blk=musicalsymbols}', ""); +Expect(0, 119039, '\p{Blk=musicalsymbols}', ""); +Expect(1, 119039, '\p{^Blk=musicalsymbols}', ""); +Expect(1, 119039, '\P{Blk=musicalsymbols}', ""); +Expect(0, 119039, '\P{^Blk=musicalsymbols}', ""); +Expect(1, 119295, '\p{Blk:_ musical SYMBOLS}', ""); +Expect(0, 119295, '\p{^Blk:_ musical SYMBOLS}', ""); +Expect(0, 119295, '\P{Blk:_ musical SYMBOLS}', ""); +Expect(1, 119295, '\P{^Blk:_ musical SYMBOLS}', ""); +Expect(0, 119039, '\p{Blk:_ musical SYMBOLS}', ""); +Expect(1, 119039, '\p{^Blk:_ musical SYMBOLS}', ""); +Expect(1, 119039, '\P{Blk:_ musical SYMBOLS}', ""); +Expect(0, 119039, '\P{^Blk:_ musical SYMBOLS}', ""); +Error('\p{Is_Block= :=musical SYMBOLS}'); +Error('\P{Is_Block= :=musical SYMBOLS}'); +Expect(1, 119295, '\p{Is_Block=musicalsymbols}', ""); +Expect(0, 119295, '\p{^Is_Block=musicalsymbols}', ""); +Expect(0, 119295, '\P{Is_Block=musicalsymbols}', ""); +Expect(1, 119295, '\P{^Is_Block=musicalsymbols}', ""); +Expect(0, 119039, '\p{Is_Block=musicalsymbols}', ""); +Expect(1, 119039, '\p{^Is_Block=musicalsymbols}', ""); +Expect(1, 119039, '\P{Is_Block=musicalsymbols}', ""); +Expect(0, 119039, '\P{^Is_Block=musicalsymbols}', ""); +Expect(1, 119295, '\p{Is_Block=_ MUSICALSYMBOLS}', ""); +Expect(0, 119295, '\p{^Is_Block=_ MUSICALSYMBOLS}', ""); +Expect(0, 119295, '\P{Is_Block=_ MUSICALSYMBOLS}', ""); +Expect(1, 119295, '\P{^Is_Block=_ MUSICALSYMBOLS}', ""); +Expect(0, 119039, '\p{Is_Block=_ MUSICALSYMBOLS}', ""); +Expect(1, 119039, '\p{^Is_Block=_ MUSICALSYMBOLS}', ""); +Expect(1, 119039, '\P{Is_Block=_ MUSICALSYMBOLS}', ""); +Expect(0, 119039, '\P{^Is_Block=_ MUSICALSYMBOLS}', ""); +Error('\p{Is_Blk=-Musical_symbols:=}'); +Error('\P{Is_Blk=-Musical_symbols:=}'); +Expect(1, 119295, '\p{Is_Blk=musicalsymbols}', ""); +Expect(0, 119295, '\p{^Is_Blk=musicalsymbols}', ""); +Expect(0, 119295, '\P{Is_Blk=musicalsymbols}', ""); +Expect(1, 119295, '\P{^Is_Blk=musicalsymbols}', ""); +Expect(0, 119039, '\p{Is_Blk=musicalsymbols}', ""); +Expect(1, 119039, '\p{^Is_Blk=musicalsymbols}', ""); +Expect(1, 119039, '\P{Is_Blk=musicalsymbols}', ""); +Expect(0, 119039, '\P{^Is_Blk=musicalsymbols}', ""); +Expect(1, 119295, '\p{Is_Blk= musicalsymbols}', ""); +Expect(0, 119295, '\p{^Is_Blk= musicalsymbols}', ""); +Expect(0, 119295, '\P{Is_Blk= musicalsymbols}', ""); +Expect(1, 119295, '\P{^Is_Blk= musicalsymbols}', ""); +Expect(0, 119039, '\p{Is_Blk= musicalsymbols}', ""); +Expect(1, 119039, '\p{^Is_Blk= musicalsymbols}', ""); +Expect(1, 119039, '\P{Is_Blk= musicalsymbols}', ""); +Expect(0, 119039, '\P{^Is_Blk= musicalsymbols}', ""); +Error('\p{Block=_:=Miscellaneous Symbols}'); +Error('\P{Block=_:=Miscellaneous Symbols}'); +Expect(1, 9983, '\p{Block=miscellaneoussymbols}', ""); +Expect(0, 9983, '\p{^Block=miscellaneoussymbols}', ""); +Expect(0, 9983, '\P{Block=miscellaneoussymbols}', ""); +Expect(1, 9983, '\P{^Block=miscellaneoussymbols}', ""); +Expect(0, 9727, '\p{Block=miscellaneoussymbols}', ""); +Expect(1, 9727, '\p{^Block=miscellaneoussymbols}', ""); +Expect(1, 9727, '\P{Block=miscellaneoussymbols}', ""); +Expect(0, 9727, '\P{^Block=miscellaneoussymbols}', ""); +Expect(1, 9983, '\p{Block= -MiscellaneousSYMBOLS}', ""); +Expect(0, 9983, '\p{^Block= -MiscellaneousSYMBOLS}', ""); +Expect(0, 9983, '\P{Block= -MiscellaneousSYMBOLS}', ""); +Expect(1, 9983, '\P{^Block= -MiscellaneousSYMBOLS}', ""); +Expect(0, 9727, '\p{Block= -MiscellaneousSYMBOLS}', ""); +Expect(1, 9727, '\p{^Block= -MiscellaneousSYMBOLS}', ""); +Expect(1, 9727, '\P{Block= -MiscellaneousSYMBOLS}', ""); +Expect(0, 9727, '\P{^Block= -MiscellaneousSYMBOLS}', ""); +Error('\p{Blk=:=__MISCELLANEOUS Symbols}'); +Error('\P{Blk=:=__MISCELLANEOUS Symbols}'); +Expect(1, 9983, '\p{Blk=miscellaneoussymbols}', ""); +Expect(0, 9983, '\p{^Blk=miscellaneoussymbols}', ""); +Expect(0, 9983, '\P{Blk=miscellaneoussymbols}', ""); +Expect(1, 9983, '\P{^Blk=miscellaneoussymbols}', ""); +Expect(0, 9727, '\p{Blk=miscellaneoussymbols}', ""); +Expect(1, 9727, '\p{^Blk=miscellaneoussymbols}', ""); +Expect(1, 9727, '\P{Blk=miscellaneoussymbols}', ""); +Expect(0, 9727, '\P{^Blk=miscellaneoussymbols}', ""); +Expect(1, 9983, '\p{Blk=- MISCELLANEOUS symbols}', ""); +Expect(0, 9983, '\p{^Blk=- MISCELLANEOUS symbols}', ""); +Expect(0, 9983, '\P{Blk=- MISCELLANEOUS symbols}', ""); +Expect(1, 9983, '\P{^Blk=- MISCELLANEOUS symbols}', ""); +Expect(0, 9727, '\p{Blk=- MISCELLANEOUS symbols}', ""); +Expect(1, 9727, '\p{^Blk=- MISCELLANEOUS symbols}', ""); +Expect(1, 9727, '\P{Blk=- MISCELLANEOUS symbols}', ""); +Expect(0, 9727, '\P{^Blk=- MISCELLANEOUS symbols}', ""); +Error('\p{Is_Block=/a/_ MISCELLANEOUS_symbols}'); +Error('\P{Is_Block=/a/_ MISCELLANEOUS_symbols}'); +Expect(1, 9983, '\p{Is_Block=miscellaneoussymbols}', ""); +Expect(0, 9983, '\p{^Is_Block=miscellaneoussymbols}', ""); +Expect(0, 9983, '\P{Is_Block=miscellaneoussymbols}', ""); +Expect(1, 9983, '\P{^Is_Block=miscellaneoussymbols}', ""); +Expect(0, 9727, '\p{Is_Block=miscellaneoussymbols}', ""); +Expect(1, 9727, '\p{^Is_Block=miscellaneoussymbols}', ""); +Expect(1, 9727, '\P{Is_Block=miscellaneoussymbols}', ""); +Expect(0, 9727, '\P{^Is_Block=miscellaneoussymbols}', ""); +Expect(1, 9983, '\p{Is_Block= Miscellaneous symbols}', ""); +Expect(0, 9983, '\p{^Is_Block= Miscellaneous symbols}', ""); +Expect(0, 9983, '\P{Is_Block= Miscellaneous symbols}', ""); +Expect(1, 9983, '\P{^Is_Block= Miscellaneous symbols}', ""); +Expect(0, 9727, '\p{Is_Block= Miscellaneous symbols}', ""); +Expect(1, 9727, '\p{^Is_Block= Miscellaneous symbols}', ""); +Expect(1, 9727, '\P{Is_Block= Miscellaneous symbols}', ""); +Expect(0, 9727, '\P{^Is_Block= Miscellaneous symbols}', ""); +Error('\p{Is_Blk=:=miscellaneous-Symbols}'); +Error('\P{Is_Blk=:=miscellaneous-Symbols}'); +Expect(1, 9983, '\p{Is_Blk: miscellaneoussymbols}', ""); +Expect(0, 9983, '\p{^Is_Blk: miscellaneoussymbols}', ""); +Expect(0, 9983, '\P{Is_Blk: miscellaneoussymbols}', ""); +Expect(1, 9983, '\P{^Is_Blk: miscellaneoussymbols}', ""); +Expect(0, 9727, '\p{Is_Blk: miscellaneoussymbols}', ""); +Expect(1, 9727, '\p{^Is_Blk: miscellaneoussymbols}', ""); +Expect(1, 9727, '\P{Is_Blk: miscellaneoussymbols}', ""); +Expect(0, 9727, '\P{^Is_Blk: miscellaneoussymbols}', ""); +Expect(1, 9983, '\p{Is_Blk=MISCELLANEOUS Symbols}', ""); +Expect(0, 9983, '\p{^Is_Blk=MISCELLANEOUS Symbols}', ""); +Expect(0, 9983, '\P{Is_Blk=MISCELLANEOUS Symbols}', ""); +Expect(1, 9983, '\P{^Is_Blk=MISCELLANEOUS Symbols}', ""); +Expect(0, 9727, '\p{Is_Blk=MISCELLANEOUS Symbols}', ""); +Expect(1, 9727, '\p{^Is_Blk=MISCELLANEOUS Symbols}', ""); +Expect(1, 9727, '\P{Is_Blk=MISCELLANEOUS Symbols}', ""); +Expect(0, 9727, '\P{^Is_Blk=MISCELLANEOUS Symbols}', ""); +Error('\p{Block=/a/Runic}'); +Error('\P{Block=/a/Runic}'); +Expect(1, 5887, '\p{Block=runic}', ""); +Expect(0, 5887, '\p{^Block=runic}', ""); +Expect(0, 5887, '\P{Block=runic}', ""); +Expect(1, 5887, '\P{^Block=runic}', ""); +Expect(0, 5791, '\p{Block=runic}', ""); +Expect(1, 5791, '\p{^Block=runic}', ""); +Expect(1, 5791, '\P{Block=runic}', ""); +Expect(0, 5791, '\P{^Block=runic}', ""); +Expect(1, 5887, '\p{Block=- runic}', ""); +Expect(0, 5887, '\p{^Block=- runic}', ""); +Expect(0, 5887, '\P{Block=- runic}', ""); +Expect(1, 5887, '\P{^Block=- runic}', ""); +Expect(0, 5791, '\p{Block=- runic}', ""); +Expect(1, 5791, '\p{^Block=- runic}', ""); +Expect(1, 5791, '\P{Block=- runic}', ""); +Expect(0, 5791, '\P{^Block=- runic}', ""); +Error('\p{Blk=/a/ _RUNIC}'); +Error('\P{Blk=/a/ _RUNIC}'); +Expect(1, 5887, '\p{Blk=runic}', ""); +Expect(0, 5887, '\p{^Blk=runic}', ""); +Expect(0, 5887, '\P{Blk=runic}', ""); +Expect(1, 5887, '\P{^Blk=runic}', ""); +Expect(0, 5791, '\p{Blk=runic}', ""); +Expect(1, 5791, '\p{^Blk=runic}', ""); +Expect(1, 5791, '\P{Blk=runic}', ""); +Expect(0, 5791, '\P{^Blk=runic}', ""); +Expect(1, 5887, '\p{Blk=--RUNIC}', ""); +Expect(0, 5887, '\p{^Blk=--RUNIC}', ""); +Expect(0, 5887, '\P{Blk=--RUNIC}', ""); +Expect(1, 5887, '\P{^Blk=--RUNIC}', ""); +Expect(0, 5791, '\p{Blk=--RUNIC}', ""); +Expect(1, 5791, '\p{^Blk=--RUNIC}', ""); +Expect(1, 5791, '\P{Blk=--RUNIC}', ""); +Expect(0, 5791, '\P{^Blk=--RUNIC}', ""); +Error('\p{Is_Block=-_runic/a/}'); +Error('\P{Is_Block=-_runic/a/}'); +Expect(1, 5887, '\p{Is_Block=runic}', ""); +Expect(0, 5887, '\p{^Is_Block=runic}', ""); +Expect(0, 5887, '\P{Is_Block=runic}', ""); +Expect(1, 5887, '\P{^Is_Block=runic}', ""); +Expect(0, 5791, '\p{Is_Block=runic}', ""); +Expect(1, 5791, '\p{^Is_Block=runic}', ""); +Expect(1, 5791, '\P{Is_Block=runic}', ""); +Expect(0, 5791, '\P{^Is_Block=runic}', ""); +Expect(1, 5887, '\p{Is_Block=- runic}', ""); +Expect(0, 5887, '\p{^Is_Block=- runic}', ""); +Expect(0, 5887, '\P{Is_Block=- runic}', ""); +Expect(1, 5887, '\P{^Is_Block=- runic}', ""); +Expect(0, 5791, '\p{Is_Block=- runic}', ""); +Expect(1, 5791, '\p{^Is_Block=- runic}', ""); +Expect(1, 5791, '\P{Is_Block=- runic}', ""); +Expect(0, 5791, '\P{^Is_Block=- runic}', ""); +Error('\p{Is_Blk=:=RUNIC}'); +Error('\P{Is_Blk=:=RUNIC}'); +Expect(1, 5887, '\p{Is_Blk=runic}', ""); +Expect(0, 5887, '\p{^Is_Blk=runic}', ""); +Expect(0, 5887, '\P{Is_Blk=runic}', ""); +Expect(1, 5887, '\P{^Is_Blk=runic}', ""); +Expect(0, 5791, '\p{Is_Blk=runic}', ""); +Expect(1, 5791, '\p{^Is_Blk=runic}', ""); +Expect(1, 5791, '\P{Is_Blk=runic}', ""); +Expect(0, 5791, '\P{^Is_Blk=runic}', ""); +Expect(1, 5887, '\p{Is_Blk: -Runic}', ""); +Expect(0, 5887, '\p{^Is_Blk: -Runic}', ""); +Expect(0, 5887, '\P{Is_Blk: -Runic}', ""); +Expect(1, 5887, '\P{^Is_Blk: -Runic}', ""); +Expect(0, 5791, '\p{Is_Blk: -Runic}', ""); +Expect(1, 5791, '\p{^Is_Blk: -Runic}', ""); +Expect(1, 5791, '\P{Is_Blk: -Runic}', ""); +Expect(0, 5791, '\P{^Is_Blk: -Runic}', ""); +Error('\p{Block=-/a/Lycian}'); +Error('\P{Block=-/a/Lycian}'); +Expect(1, 66207, '\p{Block=lycian}', ""); +Expect(0, 66207, '\p{^Block=lycian}', ""); +Expect(0, 66207, '\P{Block=lycian}', ""); +Expect(1, 66207, '\P{^Block=lycian}', ""); +Expect(0, 66175, '\p{Block=lycian}', ""); +Expect(1, 66175, '\p{^Block=lycian}', ""); +Expect(1, 66175, '\P{Block=lycian}', ""); +Expect(0, 66175, '\P{^Block=lycian}', ""); +Expect(1, 66207, '\p{Block=-LYCIAN}', ""); +Expect(0, 66207, '\p{^Block=-LYCIAN}', ""); +Expect(0, 66207, '\P{Block=-LYCIAN}', ""); +Expect(1, 66207, '\P{^Block=-LYCIAN}', ""); +Expect(0, 66175, '\p{Block=-LYCIAN}', ""); +Expect(1, 66175, '\p{^Block=-LYCIAN}', ""); +Expect(1, 66175, '\P{Block=-LYCIAN}', ""); +Expect(0, 66175, '\P{^Block=-LYCIAN}', ""); +Error('\p{Blk=_/a/lycian}'); +Error('\P{Blk=_/a/lycian}'); +Expect(1, 66207, '\p{Blk=lycian}', ""); +Expect(0, 66207, '\p{^Blk=lycian}', ""); +Expect(0, 66207, '\P{Blk=lycian}', ""); +Expect(1, 66207, '\P{^Blk=lycian}', ""); +Expect(0, 66175, '\p{Blk=lycian}', ""); +Expect(1, 66175, '\p{^Blk=lycian}', ""); +Expect(1, 66175, '\P{Blk=lycian}', ""); +Expect(0, 66175, '\P{^Blk=lycian}', ""); +Expect(1, 66207, '\p{Blk: - LYCIAN}', ""); +Expect(0, 66207, '\p{^Blk: - LYCIAN}', ""); +Expect(0, 66207, '\P{Blk: - LYCIAN}', ""); +Expect(1, 66207, '\P{^Blk: - LYCIAN}', ""); +Expect(0, 66175, '\p{Blk: - LYCIAN}', ""); +Expect(1, 66175, '\p{^Blk: - LYCIAN}', ""); +Expect(1, 66175, '\P{Blk: - LYCIAN}', ""); +Expect(0, 66175, '\P{^Blk: - LYCIAN}', ""); +Error('\p{Is_Block=/a/_ lycian}'); +Error('\P{Is_Block=/a/_ lycian}'); +Expect(1, 66207, '\p{Is_Block: lycian}', ""); +Expect(0, 66207, '\p{^Is_Block: lycian}', ""); +Expect(0, 66207, '\P{Is_Block: lycian}', ""); +Expect(1, 66207, '\P{^Is_Block: lycian}', ""); +Expect(0, 66175, '\p{Is_Block: lycian}', ""); +Expect(1, 66175, '\p{^Is_Block: lycian}', ""); +Expect(1, 66175, '\P{Is_Block: lycian}', ""); +Expect(0, 66175, '\P{^Is_Block: lycian}', ""); +Expect(1, 66207, '\p{Is_Block= Lycian}', ""); +Expect(0, 66207, '\p{^Is_Block= Lycian}', ""); +Expect(0, 66207, '\P{Is_Block= Lycian}', ""); +Expect(1, 66207, '\P{^Is_Block= Lycian}', ""); +Expect(0, 66175, '\p{Is_Block= Lycian}', ""); +Expect(1, 66175, '\p{^Is_Block= Lycian}', ""); +Expect(1, 66175, '\P{Is_Block= Lycian}', ""); +Expect(0, 66175, '\P{^Is_Block= Lycian}', ""); +Error('\p{Is_Blk=-:=lycian}'); +Error('\P{Is_Blk=-:=lycian}'); +Expect(1, 66207, '\p{Is_Blk:lycian}', ""); +Expect(0, 66207, '\p{^Is_Blk:lycian}', ""); +Expect(0, 66207, '\P{Is_Blk:lycian}', ""); +Expect(1, 66207, '\P{^Is_Blk:lycian}', ""); +Expect(0, 66175, '\p{Is_Blk:lycian}', ""); +Expect(1, 66175, '\p{^Is_Blk:lycian}', ""); +Expect(1, 66175, '\P{Is_Blk:lycian}', ""); +Expect(0, 66175, '\P{^Is_Blk:lycian}', ""); +Expect(1, 66207, '\p{Is_Blk= _Lycian}', ""); +Expect(0, 66207, '\p{^Is_Blk= _Lycian}', ""); +Expect(0, 66207, '\P{Is_Blk= _Lycian}', ""); +Expect(1, 66207, '\P{^Is_Blk= _Lycian}', ""); +Expect(0, 66175, '\p{Is_Blk= _Lycian}', ""); +Expect(1, 66175, '\p{^Is_Blk= _Lycian}', ""); +Expect(1, 66175, '\P{Is_Blk= _Lycian}', ""); +Expect(0, 66175, '\P{^Is_Blk= _Lycian}', ""); +Error('\p{Block= _geometric-shapes/a/}'); +Error('\P{Block= _geometric-shapes/a/}'); +Expect(1, 9727, '\p{Block=geometricshapes}', ""); +Expect(0, 9727, '\p{^Block=geometricshapes}', ""); +Expect(0, 9727, '\P{Block=geometricshapes}', ""); +Expect(1, 9727, '\P{^Block=geometricshapes}', ""); +Expect(0, 9631, '\p{Block=geometricshapes}', ""); +Expect(1, 9631, '\p{^Block=geometricshapes}', ""); +Expect(1, 9631, '\P{Block=geometricshapes}', ""); +Expect(0, 9631, '\P{^Block=geometricshapes}', ""); +Expect(1, 9727, '\p{Block=geometric shapes}', ""); +Expect(0, 9727, '\p{^Block=geometric shapes}', ""); +Expect(0, 9727, '\P{Block=geometric shapes}', ""); +Expect(1, 9727, '\P{^Block=geometric shapes}', ""); +Expect(0, 9631, '\p{Block=geometric shapes}', ""); +Expect(1, 9631, '\p{^Block=geometric shapes}', ""); +Expect(1, 9631, '\P{Block=geometric shapes}', ""); +Expect(0, 9631, '\P{^Block=geometric shapes}', ""); +Error('\p{Blk= GEOMETRIC/a/SHAPES}'); +Error('\P{Blk= GEOMETRIC/a/SHAPES}'); +Expect(1, 9727, '\p{Blk=geometricshapes}', ""); +Expect(0, 9727, '\p{^Blk=geometricshapes}', ""); +Expect(0, 9727, '\P{Blk=geometricshapes}', ""); +Expect(1, 9727, '\P{^Blk=geometricshapes}', ""); +Expect(0, 9631, '\p{Blk=geometricshapes}', ""); +Expect(1, 9631, '\p{^Blk=geometricshapes}', ""); +Expect(1, 9631, '\P{Blk=geometricshapes}', ""); +Expect(0, 9631, '\P{^Blk=geometricshapes}', ""); +Expect(1, 9727, '\p{Blk=- Geometric-Shapes}', ""); +Expect(0, 9727, '\p{^Blk=- Geometric-Shapes}', ""); +Expect(0, 9727, '\P{Blk=- Geometric-Shapes}', ""); +Expect(1, 9727, '\P{^Blk=- Geometric-Shapes}', ""); +Expect(0, 9631, '\p{Blk=- Geometric-Shapes}', ""); +Expect(1, 9631, '\p{^Blk=- Geometric-Shapes}', ""); +Expect(1, 9631, '\P{Blk=- Geometric-Shapes}', ""); +Expect(0, 9631, '\P{^Blk=- Geometric-Shapes}', ""); +Error('\p{Is_Block=_:=Geometric Shapes}'); +Error('\P{Is_Block=_:=Geometric Shapes}'); +Expect(1, 9727, '\p{Is_Block=geometricshapes}', ""); +Expect(0, 9727, '\p{^Is_Block=geometricshapes}', ""); +Expect(0, 9727, '\P{Is_Block=geometricshapes}', ""); +Expect(1, 9727, '\P{^Is_Block=geometricshapes}', ""); +Expect(0, 9631, '\p{Is_Block=geometricshapes}', ""); +Expect(1, 9631, '\p{^Is_Block=geometricshapes}', ""); +Expect(1, 9631, '\P{Is_Block=geometricshapes}', ""); +Expect(0, 9631, '\P{^Is_Block=geometricshapes}', ""); +Expect(1, 9727, '\p{Is_Block=_geometric_Shapes}', ""); +Expect(0, 9727, '\p{^Is_Block=_geometric_Shapes}', ""); +Expect(0, 9727, '\P{Is_Block=_geometric_Shapes}', ""); +Expect(1, 9727, '\P{^Is_Block=_geometric_Shapes}', ""); +Expect(0, 9631, '\p{Is_Block=_geometric_Shapes}', ""); +Expect(1, 9631, '\p{^Is_Block=_geometric_Shapes}', ""); +Expect(1, 9631, '\P{Is_Block=_geometric_Shapes}', ""); +Expect(0, 9631, '\P{^Is_Block=_geometric_Shapes}', ""); +Error('\p{Is_Blk= _Geometric/a/shapes}'); +Error('\P{Is_Blk= _Geometric/a/shapes}'); +Expect(1, 9727, '\p{Is_Blk=geometricshapes}', ""); +Expect(0, 9727, '\p{^Is_Blk=geometricshapes}', ""); +Expect(0, 9727, '\P{Is_Blk=geometricshapes}', ""); +Expect(1, 9727, '\P{^Is_Blk=geometricshapes}', ""); +Expect(0, 9631, '\p{Is_Blk=geometricshapes}', ""); +Expect(1, 9631, '\p{^Is_Blk=geometricshapes}', ""); +Expect(1, 9631, '\P{Is_Blk=geometricshapes}', ""); +Expect(0, 9631, '\P{^Is_Blk=geometricshapes}', ""); +Expect(1, 9727, '\p{Is_Blk=-Geometric Shapes}', ""); +Expect(0, 9727, '\p{^Is_Blk=-Geometric Shapes}', ""); +Expect(0, 9727, '\P{Is_Blk=-Geometric Shapes}', ""); +Expect(1, 9727, '\P{^Is_Blk=-Geometric Shapes}', ""); +Expect(0, 9631, '\p{Is_Blk=-Geometric Shapes}', ""); +Expect(1, 9631, '\p{^Is_Blk=-Geometric Shapes}', ""); +Expect(1, 9631, '\P{Is_Blk=-Geometric Shapes}', ""); +Expect(0, 9631, '\P{^Is_Blk=-Geometric Shapes}', ""); +Error('\p{Block=/a/- Aegean-Numbers}'); +Error('\P{Block=/a/- Aegean-Numbers}'); +Expect(1, 65855, '\p{Block=aegeannumbers}', ""); +Expect(0, 65855, '\p{^Block=aegeannumbers}', ""); +Expect(0, 65855, '\P{Block=aegeannumbers}', ""); +Expect(1, 65855, '\P{^Block=aegeannumbers}', ""); +Expect(0, 65791, '\p{Block=aegeannumbers}', ""); +Expect(1, 65791, '\p{^Block=aegeannumbers}', ""); +Expect(1, 65791, '\P{Block=aegeannumbers}', ""); +Expect(0, 65791, '\P{^Block=aegeannumbers}', ""); +Expect(1, 65855, '\p{Block=-_AEGEANNumbers}', ""); +Expect(0, 65855, '\p{^Block=-_AEGEANNumbers}', ""); +Expect(0, 65855, '\P{Block=-_AEGEANNumbers}', ""); +Expect(1, 65855, '\P{^Block=-_AEGEANNumbers}', ""); +Expect(0, 65791, '\p{Block=-_AEGEANNumbers}', ""); +Expect(1, 65791, '\p{^Block=-_AEGEANNumbers}', ""); +Expect(1, 65791, '\P{Block=-_AEGEANNumbers}', ""); +Expect(0, 65791, '\P{^Block=-_AEGEANNumbers}', ""); +Error('\p{Blk= aegean numbers/a/}'); +Error('\P{Blk= aegean numbers/a/}'); +Expect(1, 65855, '\p{Blk=aegeannumbers}', ""); +Expect(0, 65855, '\p{^Blk=aegeannumbers}', ""); +Expect(0, 65855, '\P{Blk=aegeannumbers}', ""); +Expect(1, 65855, '\P{^Blk=aegeannumbers}', ""); +Expect(0, 65791, '\p{Blk=aegeannumbers}', ""); +Expect(1, 65791, '\p{^Blk=aegeannumbers}', ""); +Expect(1, 65791, '\P{Blk=aegeannumbers}', ""); +Expect(0, 65791, '\P{^Blk=aegeannumbers}', ""); +Expect(1, 65855, '\p{Blk: --Aegean numbers}', ""); +Expect(0, 65855, '\p{^Blk: --Aegean numbers}', ""); +Expect(0, 65855, '\P{Blk: --Aegean numbers}', ""); +Expect(1, 65855, '\P{^Blk: --Aegean numbers}', ""); +Expect(0, 65791, '\p{Blk: --Aegean numbers}', ""); +Expect(1, 65791, '\p{^Blk: --Aegean numbers}', ""); +Expect(1, 65791, '\P{Blk: --Aegean numbers}', ""); +Expect(0, 65791, '\P{^Blk: --Aegean numbers}', ""); +Error('\p{Is_Block= :=AEGEAN Numbers}'); +Error('\P{Is_Block= :=AEGEAN Numbers}'); +Expect(1, 65855, '\p{Is_Block=aegeannumbers}', ""); +Expect(0, 65855, '\p{^Is_Block=aegeannumbers}', ""); +Expect(0, 65855, '\P{Is_Block=aegeannumbers}', ""); +Expect(1, 65855, '\P{^Is_Block=aegeannumbers}', ""); +Expect(0, 65791, '\p{Is_Block=aegeannumbers}', ""); +Expect(1, 65791, '\p{^Is_Block=aegeannumbers}', ""); +Expect(1, 65791, '\P{Is_Block=aegeannumbers}', ""); +Expect(0, 65791, '\P{^Is_Block=aegeannumbers}', ""); +Expect(1, 65855, '\p{Is_Block=_-aegeanNumbers}', ""); +Expect(0, 65855, '\p{^Is_Block=_-aegeanNumbers}', ""); +Expect(0, 65855, '\P{Is_Block=_-aegeanNumbers}', ""); +Expect(1, 65855, '\P{^Is_Block=_-aegeanNumbers}', ""); +Expect(0, 65791, '\p{Is_Block=_-aegeanNumbers}', ""); +Expect(1, 65791, '\p{^Is_Block=_-aegeanNumbers}', ""); +Expect(1, 65791, '\P{Is_Block=_-aegeanNumbers}', ""); +Expect(0, 65791, '\P{^Is_Block=_-aegeanNumbers}', ""); +Error('\p{Is_Blk=_/a/aegeannumbers}'); +Error('\P{Is_Blk=_/a/aegeannumbers}'); +Expect(1, 65855, '\p{Is_Blk=aegeannumbers}', ""); +Expect(0, 65855, '\p{^Is_Blk=aegeannumbers}', ""); +Expect(0, 65855, '\P{Is_Blk=aegeannumbers}', ""); +Expect(1, 65855, '\P{^Is_Blk=aegeannumbers}', ""); +Expect(0, 65791, '\p{Is_Blk=aegeannumbers}', ""); +Expect(1, 65791, '\p{^Is_Blk=aegeannumbers}', ""); +Expect(1, 65791, '\P{Is_Blk=aegeannumbers}', ""); +Expect(0, 65791, '\P{^Is_Blk=aegeannumbers}', ""); +Expect(1, 65855, '\p{Is_Blk=--aegean Numbers}', ""); +Expect(0, 65855, '\p{^Is_Blk=--aegean Numbers}', ""); +Expect(0, 65855, '\P{Is_Blk=--aegean Numbers}', ""); +Expect(1, 65855, '\P{^Is_Blk=--aegean Numbers}', ""); +Expect(0, 65791, '\p{Is_Blk=--aegean Numbers}', ""); +Expect(1, 65791, '\p{^Is_Blk=--aegean Numbers}', ""); +Expect(1, 65791, '\P{Is_Blk=--aegean Numbers}', ""); +Expect(0, 65791, '\P{^Is_Blk=--aegean Numbers}', ""); +Error('\p{Block= /a/KHMER Symbols}'); +Error('\P{Block= /a/KHMER Symbols}'); +Expect(1, 6655, '\p{Block: khmersymbols}', ""); +Expect(0, 6655, '\p{^Block: khmersymbols}', ""); +Expect(0, 6655, '\P{Block: khmersymbols}', ""); +Expect(1, 6655, '\P{^Block: khmersymbols}', ""); +Expect(0, 6623, '\p{Block: khmersymbols}', ""); +Expect(1, 6623, '\p{^Block: khmersymbols}', ""); +Expect(1, 6623, '\P{Block: khmersymbols}', ""); +Expect(0, 6623, '\P{^Block: khmersymbols}', ""); +Expect(1, 6655, '\p{Block=_Khmer Symbols}', ""); +Expect(0, 6655, '\p{^Block=_Khmer Symbols}', ""); +Expect(0, 6655, '\P{Block=_Khmer Symbols}', ""); +Expect(1, 6655, '\P{^Block=_Khmer Symbols}', ""); +Expect(0, 6623, '\p{Block=_Khmer Symbols}', ""); +Expect(1, 6623, '\p{^Block=_Khmer Symbols}', ""); +Expect(1, 6623, '\P{Block=_Khmer Symbols}', ""); +Expect(0, 6623, '\P{^Block=_Khmer Symbols}', ""); +Error('\p{Blk= :=Khmer-Symbols}'); +Error('\P{Blk= :=Khmer-Symbols}'); +Expect(1, 6655, '\p{Blk=khmersymbols}', ""); +Expect(0, 6655, '\p{^Blk=khmersymbols}', ""); +Expect(0, 6655, '\P{Blk=khmersymbols}', ""); +Expect(1, 6655, '\P{^Blk=khmersymbols}', ""); +Expect(0, 6623, '\p{Blk=khmersymbols}', ""); +Expect(1, 6623, '\p{^Blk=khmersymbols}', ""); +Expect(1, 6623, '\P{Blk=khmersymbols}', ""); +Expect(0, 6623, '\P{^Blk=khmersymbols}', ""); +Expect(1, 6655, '\p{Blk=_KHMER symbols}', ""); +Expect(0, 6655, '\p{^Blk=_KHMER symbols}', ""); +Expect(0, 6655, '\P{Blk=_KHMER symbols}', ""); +Expect(1, 6655, '\P{^Blk=_KHMER symbols}', ""); +Expect(0, 6623, '\p{Blk=_KHMER symbols}', ""); +Expect(1, 6623, '\p{^Blk=_KHMER symbols}', ""); +Expect(1, 6623, '\P{Blk=_KHMER symbols}', ""); +Expect(0, 6623, '\P{^Blk=_KHMER symbols}', ""); +Error('\p{Is_Block=_:=KHMERSYMBOLS}'); +Error('\P{Is_Block=_:=KHMERSYMBOLS}'); +Expect(1, 6655, '\p{Is_Block=khmersymbols}', ""); +Expect(0, 6655, '\p{^Is_Block=khmersymbols}', ""); +Expect(0, 6655, '\P{Is_Block=khmersymbols}', ""); +Expect(1, 6655, '\P{^Is_Block=khmersymbols}', ""); +Expect(0, 6623, '\p{Is_Block=khmersymbols}', ""); +Expect(1, 6623, '\p{^Is_Block=khmersymbols}', ""); +Expect(1, 6623, '\P{Is_Block=khmersymbols}', ""); +Expect(0, 6623, '\P{^Is_Block=khmersymbols}', ""); +Expect(1, 6655, '\p{Is_Block= -KHMER_SYMBOLS}', ""); +Expect(0, 6655, '\p{^Is_Block= -KHMER_SYMBOLS}', ""); +Expect(0, 6655, '\P{Is_Block= -KHMER_SYMBOLS}', ""); +Expect(1, 6655, '\P{^Is_Block= -KHMER_SYMBOLS}', ""); +Expect(0, 6623, '\p{Is_Block= -KHMER_SYMBOLS}', ""); +Expect(1, 6623, '\p{^Is_Block= -KHMER_SYMBOLS}', ""); +Expect(1, 6623, '\P{Is_Block= -KHMER_SYMBOLS}', ""); +Expect(0, 6623, '\P{^Is_Block= -KHMER_SYMBOLS}', ""); +Error('\p{Is_Blk=_-khmer:=symbols}'); +Error('\P{Is_Blk=_-khmer:=symbols}'); +Expect(1, 6655, '\p{Is_Blk=khmersymbols}', ""); +Expect(0, 6655, '\p{^Is_Blk=khmersymbols}', ""); +Expect(0, 6655, '\P{Is_Blk=khmersymbols}', ""); +Expect(1, 6655, '\P{^Is_Blk=khmersymbols}', ""); +Expect(0, 6623, '\p{Is_Blk=khmersymbols}', ""); +Expect(1, 6623, '\p{^Is_Blk=khmersymbols}', ""); +Expect(1, 6623, '\P{Is_Blk=khmersymbols}', ""); +Expect(0, 6623, '\P{^Is_Blk=khmersymbols}', ""); +Expect(1, 6655, '\p{Is_Blk=_Khmer_SYMBOLS}', ""); +Expect(0, 6655, '\p{^Is_Blk=_Khmer_SYMBOLS}', ""); +Expect(0, 6655, '\P{Is_Blk=_Khmer_SYMBOLS}', ""); +Expect(1, 6655, '\P{^Is_Blk=_Khmer_SYMBOLS}', ""); +Expect(0, 6623, '\p{Is_Blk=_Khmer_SYMBOLS}', ""); +Expect(1, 6623, '\p{^Is_Blk=_Khmer_SYMBOLS}', ""); +Expect(1, 6623, '\P{Is_Blk=_Khmer_SYMBOLS}', ""); +Expect(0, 6623, '\P{^Is_Blk=_Khmer_SYMBOLS}', ""); +Error('\p{Block= _CJKRadicals:=Supplement}'); +Error('\P{Block= _CJKRadicals:=Supplement}'); +Expect(1, 12031, '\p{Block=cjkradicalssupplement}', ""); +Expect(0, 12031, '\p{^Block=cjkradicalssupplement}', ""); +Expect(0, 12031, '\P{Block=cjkradicalssupplement}', ""); +Expect(1, 12031, '\P{^Block=cjkradicalssupplement}', ""); +Expect(0, 11903, '\p{Block=cjkradicalssupplement}', ""); +Expect(1, 11903, '\p{^Block=cjkradicalssupplement}', ""); +Expect(1, 11903, '\P{Block=cjkradicalssupplement}', ""); +Expect(0, 11903, '\P{^Block=cjkradicalssupplement}', ""); +Expect(1, 12031, '\p{Block=_-cjk RADICALS_Supplement}', ""); +Expect(0, 12031, '\p{^Block=_-cjk RADICALS_Supplement}', ""); +Expect(0, 12031, '\P{Block=_-cjk RADICALS_Supplement}', ""); +Expect(1, 12031, '\P{^Block=_-cjk RADICALS_Supplement}', ""); +Expect(0, 11903, '\p{Block=_-cjk RADICALS_Supplement}', ""); +Expect(1, 11903, '\p{^Block=_-cjk RADICALS_Supplement}', ""); +Expect(1, 11903, '\P{Block=_-cjk RADICALS_Supplement}', ""); +Expect(0, 11903, '\P{^Block=_-cjk RADICALS_Supplement}', ""); +Error('\p{Blk: CJK-Radicals:=supplement}'); +Error('\P{Blk: CJK-Radicals:=supplement}'); +Expect(1, 12031, '\p{Blk=cjkradicalssupplement}', ""); +Expect(0, 12031, '\p{^Blk=cjkradicalssupplement}', ""); +Expect(0, 12031, '\P{Blk=cjkradicalssupplement}', ""); +Expect(1, 12031, '\P{^Blk=cjkradicalssupplement}', ""); +Expect(0, 11903, '\p{Blk=cjkradicalssupplement}', ""); +Expect(1, 11903, '\p{^Blk=cjkradicalssupplement}', ""); +Expect(1, 11903, '\P{Blk=cjkradicalssupplement}', ""); +Expect(0, 11903, '\P{^Blk=cjkradicalssupplement}', ""); +Expect(1, 12031, '\p{Blk=--cjk_radicals Supplement}', ""); +Expect(0, 12031, '\p{^Blk=--cjk_radicals Supplement}', ""); +Expect(0, 12031, '\P{Blk=--cjk_radicals Supplement}', ""); +Expect(1, 12031, '\P{^Blk=--cjk_radicals Supplement}', ""); +Expect(0, 11903, '\p{Blk=--cjk_radicals Supplement}', ""); +Expect(1, 11903, '\p{^Blk=--cjk_radicals Supplement}', ""); +Expect(1, 11903, '\P{Blk=--cjk_radicals Supplement}', ""); +Expect(0, 11903, '\P{^Blk=--cjk_radicals Supplement}', ""); +Error('\p{Is_Block= cjk/a/radicals-SUPPLEMENT}'); +Error('\P{Is_Block= cjk/a/radicals-SUPPLEMENT}'); +Expect(1, 12031, '\p{Is_Block=cjkradicalssupplement}', ""); +Expect(0, 12031, '\p{^Is_Block=cjkradicalssupplement}', ""); +Expect(0, 12031, '\P{Is_Block=cjkradicalssupplement}', ""); +Expect(1, 12031, '\P{^Is_Block=cjkradicalssupplement}', ""); +Expect(0, 11903, '\p{Is_Block=cjkradicalssupplement}', ""); +Expect(1, 11903, '\p{^Is_Block=cjkradicalssupplement}', ""); +Expect(1, 11903, '\P{Is_Block=cjkradicalssupplement}', ""); +Expect(0, 11903, '\P{^Is_Block=cjkradicalssupplement}', ""); +Expect(1, 12031, '\p{Is_Block=__cjk Radicals Supplement}', ""); +Expect(0, 12031, '\p{^Is_Block=__cjk Radicals Supplement}', ""); +Expect(0, 12031, '\P{Is_Block=__cjk Radicals Supplement}', ""); +Expect(1, 12031, '\P{^Is_Block=__cjk Radicals Supplement}', ""); +Expect(0, 11903, '\p{Is_Block=__cjk Radicals Supplement}', ""); +Expect(1, 11903, '\p{^Is_Block=__cjk Radicals Supplement}', ""); +Expect(1, 11903, '\P{Is_Block=__cjk Radicals Supplement}', ""); +Expect(0, 11903, '\P{^Is_Block=__cjk Radicals Supplement}', ""); +Error('\p{Is_Blk=_:=cjk Radicals-Supplement}'); +Error('\P{Is_Blk=_:=cjk Radicals-Supplement}'); +Expect(1, 12031, '\p{Is_Blk=cjkradicalssupplement}', ""); +Expect(0, 12031, '\p{^Is_Blk=cjkradicalssupplement}', ""); +Expect(0, 12031, '\P{Is_Blk=cjkradicalssupplement}', ""); +Expect(1, 12031, '\P{^Is_Blk=cjkradicalssupplement}', ""); +Expect(0, 11903, '\p{Is_Blk=cjkradicalssupplement}', ""); +Expect(1, 11903, '\p{^Is_Blk=cjkradicalssupplement}', ""); +Expect(1, 11903, '\P{Is_Blk=cjkradicalssupplement}', ""); +Expect(0, 11903, '\P{^Is_Blk=cjkradicalssupplement}', ""); +Expect(1, 12031, '\p{Is_Blk= _CJKRadicals supplement}', ""); +Expect(0, 12031, '\p{^Is_Blk= _CJKRadicals supplement}', ""); +Expect(0, 12031, '\P{Is_Blk= _CJKRadicals supplement}', ""); +Expect(1, 12031, '\P{^Is_Blk= _CJKRadicals supplement}', ""); +Expect(0, 11903, '\p{Is_Blk= _CJKRadicals supplement}', ""); +Expect(1, 11903, '\p{^Is_Blk= _CJKRadicals supplement}', ""); +Expect(1, 11903, '\P{Is_Blk= _CJKRadicals supplement}', ""); +Expect(0, 11903, '\P{^Is_Blk= _CJKRadicals supplement}', ""); +Error('\p{Block=-Mathematical_Operators/a/}'); +Error('\P{Block=-Mathematical_Operators/a/}'); +Expect(1, 8959, '\p{Block=mathematicaloperators}', ""); +Expect(0, 8959, '\p{^Block=mathematicaloperators}', ""); +Expect(0, 8959, '\P{Block=mathematicaloperators}', ""); +Expect(1, 8959, '\P{^Block=mathematicaloperators}', ""); +Expect(0, 8703, '\p{Block=mathematicaloperators}', ""); +Expect(1, 8703, '\p{^Block=mathematicaloperators}', ""); +Expect(1, 8703, '\P{Block=mathematicaloperators}', ""); +Expect(0, 8703, '\P{^Block=mathematicaloperators}', ""); +Expect(1, 8959, '\p{Block= MATHEMATICAL-operators}', ""); +Expect(0, 8959, '\p{^Block= MATHEMATICAL-operators}', ""); +Expect(0, 8959, '\P{Block= MATHEMATICAL-operators}', ""); +Expect(1, 8959, '\P{^Block= MATHEMATICAL-operators}', ""); +Expect(0, 8703, '\p{Block= MATHEMATICAL-operators}', ""); +Expect(1, 8703, '\p{^Block= MATHEMATICAL-operators}', ""); +Expect(1, 8703, '\P{Block= MATHEMATICAL-operators}', ""); +Expect(0, 8703, '\P{^Block= MATHEMATICAL-operators}', ""); +Error('\p{Blk= Mathematical Operators/a/}'); +Error('\P{Blk= Mathematical Operators/a/}'); +Expect(1, 8959, '\p{Blk=mathematicaloperators}', ""); +Expect(0, 8959, '\p{^Blk=mathematicaloperators}', ""); +Expect(0, 8959, '\P{Blk=mathematicaloperators}', ""); +Expect(1, 8959, '\P{^Blk=mathematicaloperators}', ""); +Expect(0, 8703, '\p{Blk=mathematicaloperators}', ""); +Expect(1, 8703, '\p{^Blk=mathematicaloperators}', ""); +Expect(1, 8703, '\P{Blk=mathematicaloperators}', ""); +Expect(0, 8703, '\P{^Blk=mathematicaloperators}', ""); +Expect(1, 8959, '\p{Blk: - MathematicalOperators}', ""); +Expect(0, 8959, '\p{^Blk: - MathematicalOperators}', ""); +Expect(0, 8959, '\P{Blk: - MathematicalOperators}', ""); +Expect(1, 8959, '\P{^Blk: - MathematicalOperators}', ""); +Expect(0, 8703, '\p{Blk: - MathematicalOperators}', ""); +Expect(1, 8703, '\p{^Blk: - MathematicalOperators}', ""); +Expect(1, 8703, '\P{Blk: - MathematicalOperators}', ""); +Expect(0, 8703, '\P{^Blk: - MathematicalOperators}', ""); +Error('\p{Is_Block=_Mathematical:=OPERATORS}'); +Error('\P{Is_Block=_Mathematical:=OPERATORS}'); +Expect(1, 8959, '\p{Is_Block=mathematicaloperators}', ""); +Expect(0, 8959, '\p{^Is_Block=mathematicaloperators}', ""); +Expect(0, 8959, '\P{Is_Block=mathematicaloperators}', ""); +Expect(1, 8959, '\P{^Is_Block=mathematicaloperators}', ""); +Expect(0, 8703, '\p{Is_Block=mathematicaloperators}', ""); +Expect(1, 8703, '\p{^Is_Block=mathematicaloperators}', ""); +Expect(1, 8703, '\P{Is_Block=mathematicaloperators}', ""); +Expect(0, 8703, '\P{^Is_Block=mathematicaloperators}', ""); +Expect(1, 8959, '\p{Is_Block=_MATHEMATICAL Operators}', ""); +Expect(0, 8959, '\p{^Is_Block=_MATHEMATICAL Operators}', ""); +Expect(0, 8959, '\P{Is_Block=_MATHEMATICAL Operators}', ""); +Expect(1, 8959, '\P{^Is_Block=_MATHEMATICAL Operators}', ""); +Expect(0, 8703, '\p{Is_Block=_MATHEMATICAL Operators}', ""); +Expect(1, 8703, '\p{^Is_Block=_MATHEMATICAL Operators}', ""); +Expect(1, 8703, '\P{Is_Block=_MATHEMATICAL Operators}', ""); +Expect(0, 8703, '\P{^Is_Block=_MATHEMATICAL Operators}', ""); +Error('\p{Is_Blk=_ MATHEMATICALOPERATORS/a/}'); +Error('\P{Is_Blk=_ MATHEMATICALOPERATORS/a/}'); +Expect(1, 8959, '\p{Is_Blk=mathematicaloperators}', ""); +Expect(0, 8959, '\p{^Is_Blk=mathematicaloperators}', ""); +Expect(0, 8959, '\P{Is_Blk=mathematicaloperators}', ""); +Expect(1, 8959, '\P{^Is_Blk=mathematicaloperators}', ""); +Expect(0, 8703, '\p{Is_Blk=mathematicaloperators}', ""); +Expect(1, 8703, '\p{^Is_Blk=mathematicaloperators}', ""); +Expect(1, 8703, '\P{Is_Blk=mathematicaloperators}', ""); +Expect(0, 8703, '\P{^Is_Blk=mathematicaloperators}', ""); +Expect(1, 8959, '\p{Is_Blk= MATHEMATICALOperators}', ""); +Expect(0, 8959, '\p{^Is_Blk= MATHEMATICALOperators}', ""); +Expect(0, 8959, '\P{Is_Blk= MATHEMATICALOperators}', ""); +Expect(1, 8959, '\P{^Is_Blk= MATHEMATICALOperators}', ""); +Expect(0, 8703, '\p{Is_Blk= MATHEMATICALOperators}', ""); +Expect(1, 8703, '\p{^Is_Blk= MATHEMATICALOperators}', ""); +Expect(1, 8703, '\P{Is_Blk= MATHEMATICALOperators}', ""); +Expect(0, 8703, '\P{^Is_Blk= MATHEMATICALOperators}', ""); +Error('\p{Block=:=_CJK_COMPATIBILITY-ideographs-supplement}'); +Error('\P{Block=:=_CJK_COMPATIBILITY-ideographs-supplement}'); +Expect(1, 195103, '\p{Block=cjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\p{^Block=cjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\P{Block=cjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\P{^Block=cjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\p{Block=cjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\p{^Block=cjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\P{Block=cjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\P{^Block=cjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\p{Block=-CJKCompatibilityIdeographs Supplement}', ""); +Expect(0, 195103, '\p{^Block=-CJKCompatibilityIdeographs Supplement}', ""); +Expect(0, 195103, '\P{Block=-CJKCompatibilityIdeographs Supplement}', ""); +Expect(1, 195103, '\P{^Block=-CJKCompatibilityIdeographs Supplement}', ""); +Expect(0, 194559, '\p{Block=-CJKCompatibilityIdeographs Supplement}', ""); +Expect(1, 194559, '\p{^Block=-CJKCompatibilityIdeographs Supplement}', ""); +Expect(1, 194559, '\P{Block=-CJKCompatibilityIdeographs Supplement}', ""); +Expect(0, 194559, '\P{^Block=-CJKCompatibilityIdeographs Supplement}', ""); +Error('\p{Blk=- cjk/a/compatibility-ideographsSUPPLEMENT}'); +Error('\P{Blk=- cjk/a/compatibility-ideographsSUPPLEMENT}'); +Expect(1, 195103, '\p{Blk: cjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\p{^Blk: cjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\P{Blk: cjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\P{^Blk: cjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\p{Blk: cjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\p{^Blk: cjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\P{Blk: cjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\P{^Blk: cjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\p{Blk= _CJK-compatibility ideographsSupplement}', ""); +Expect(0, 195103, '\p{^Blk= _CJK-compatibility ideographsSupplement}', ""); +Expect(0, 195103, '\P{Blk= _CJK-compatibility ideographsSupplement}', ""); +Expect(1, 195103, '\P{^Blk= _CJK-compatibility ideographsSupplement}', ""); +Expect(0, 194559, '\p{Blk= _CJK-compatibility ideographsSupplement}', ""); +Expect(1, 194559, '\p{^Blk= _CJK-compatibility ideographsSupplement}', ""); +Expect(1, 194559, '\P{Blk= _CJK-compatibility ideographsSupplement}', ""); +Expect(0, 194559, '\P{^Blk= _CJK-compatibility ideographsSupplement}', ""); +Error('\p{Is_Block=_CJK/a/compatibility IdeographsSupplement}'); +Error('\P{Is_Block=_CJK/a/compatibility IdeographsSupplement}'); +Expect(1, 195103, '\p{Is_Block=cjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\p{^Is_Block=cjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\P{Is_Block=cjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\P{^Is_Block=cjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\p{Is_Block=cjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\p{^Is_Block=cjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\P{Is_Block=cjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\P{^Is_Block=cjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\p{Is_Block=_ CJK COMPATIBILITY_IDEOGRAPHS-Supplement}', ""); +Expect(0, 195103, '\p{^Is_Block=_ CJK COMPATIBILITY_IDEOGRAPHS-Supplement}', ""); +Expect(0, 195103, '\P{Is_Block=_ CJK COMPATIBILITY_IDEOGRAPHS-Supplement}', ""); +Expect(1, 195103, '\P{^Is_Block=_ CJK COMPATIBILITY_IDEOGRAPHS-Supplement}', ""); +Expect(0, 194559, '\p{Is_Block=_ CJK COMPATIBILITY_IDEOGRAPHS-Supplement}', ""); +Expect(1, 194559, '\p{^Is_Block=_ CJK COMPATIBILITY_IDEOGRAPHS-Supplement}', ""); +Expect(1, 194559, '\P{Is_Block=_ CJK COMPATIBILITY_IDEOGRAPHS-Supplement}', ""); +Expect(0, 194559, '\P{^Is_Block=_ CJK COMPATIBILITY_IDEOGRAPHS-Supplement}', ""); +Error('\p{Is_Blk= _CJK/a/COMPATIBILITY-ideographsSUPPLEMENT}'); +Error('\P{Is_Blk= _CJK/a/COMPATIBILITY-ideographsSUPPLEMENT}'); +Expect(1, 195103, '\p{Is_Blk=cjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\p{^Is_Blk=cjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\P{Is_Blk=cjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\P{^Is_Blk=cjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\p{Is_Blk=cjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\p{^Is_Blk=cjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\P{Is_Blk=cjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\P{^Is_Blk=cjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\p{Is_Blk= _CJK_compatibility Ideographs_Supplement}', ""); +Expect(0, 195103, '\p{^Is_Blk= _CJK_compatibility Ideographs_Supplement}', ""); +Expect(0, 195103, '\P{Is_Blk= _CJK_compatibility Ideographs_Supplement}', ""); +Expect(1, 195103, '\P{^Is_Blk= _CJK_compatibility Ideographs_Supplement}', ""); +Expect(0, 194559, '\p{Is_Blk= _CJK_compatibility Ideographs_Supplement}', ""); +Expect(1, 194559, '\p{^Is_Blk= _CJK_compatibility Ideographs_Supplement}', ""); +Expect(1, 194559, '\P{Is_Blk= _CJK_compatibility Ideographs_Supplement}', ""); +Expect(0, 194559, '\P{^Is_Blk= _CJK_compatibility Ideographs_Supplement}', ""); +Error('\p{Block=_ IPA_Extensions/a/}'); +Error('\P{Block=_ IPA_Extensions/a/}'); +Expect(1, 687, '\p{Block=ipaextensions}', ""); +Expect(0, 687, '\p{^Block=ipaextensions}', ""); +Expect(0, 687, '\P{Block=ipaextensions}', ""); +Expect(1, 687, '\P{^Block=ipaextensions}', ""); +Expect(0, 591, '\p{Block=ipaextensions}', ""); +Expect(1, 591, '\p{^Block=ipaextensions}', ""); +Expect(1, 591, '\P{Block=ipaextensions}', ""); +Expect(0, 591, '\P{^Block=ipaextensions}', ""); +Expect(1, 687, '\p{Block: - IPAextensions}', ""); +Expect(0, 687, '\p{^Block: - IPAextensions}', ""); +Expect(0, 687, '\P{Block: - IPAextensions}', ""); +Expect(1, 687, '\P{^Block: - IPAextensions}', ""); +Expect(0, 591, '\p{Block: - IPAextensions}', ""); +Expect(1, 591, '\p{^Block: - IPAextensions}', ""); +Expect(1, 591, '\P{Block: - IPAextensions}', ""); +Expect(0, 591, '\P{^Block: - IPAextensions}', ""); +Error('\p{Blk=:=_ IPA-extensions}'); +Error('\P{Blk=:=_ IPA-extensions}'); +Expect(1, 687, '\p{Blk=ipaextensions}', ""); +Expect(0, 687, '\p{^Blk=ipaextensions}', ""); +Expect(0, 687, '\P{Blk=ipaextensions}', ""); +Expect(1, 687, '\P{^Blk=ipaextensions}', ""); +Expect(0, 591, '\p{Blk=ipaextensions}', ""); +Expect(1, 591, '\p{^Blk=ipaextensions}', ""); +Expect(1, 591, '\P{Blk=ipaextensions}', ""); +Expect(0, 591, '\P{^Blk=ipaextensions}', ""); +Expect(1, 687, '\p{Blk= IPA-Extensions}', ""); +Expect(0, 687, '\p{^Blk= IPA-Extensions}', ""); +Expect(0, 687, '\P{Blk= IPA-Extensions}', ""); +Expect(1, 687, '\P{^Blk= IPA-Extensions}', ""); +Expect(0, 591, '\p{Blk= IPA-Extensions}', ""); +Expect(1, 591, '\p{^Blk= IPA-Extensions}', ""); +Expect(1, 591, '\P{Blk= IPA-Extensions}', ""); +Expect(0, 591, '\P{^Blk= IPA-Extensions}', ""); +Error('\p{Is_Block: :=_-IPA extensions}'); +Error('\P{Is_Block: :=_-IPA extensions}'); +Expect(1, 687, '\p{Is_Block=ipaextensions}', ""); +Expect(0, 687, '\p{^Is_Block=ipaextensions}', ""); +Expect(0, 687, '\P{Is_Block=ipaextensions}', ""); +Expect(1, 687, '\P{^Is_Block=ipaextensions}', ""); +Expect(0, 591, '\p{Is_Block=ipaextensions}', ""); +Expect(1, 591, '\p{^Is_Block=ipaextensions}', ""); +Expect(1, 591, '\P{Is_Block=ipaextensions}', ""); +Expect(0, 591, '\P{^Is_Block=ipaextensions}', ""); +Expect(1, 687, '\p{Is_Block=_-ipa EXTENSIONS}', ""); +Expect(0, 687, '\p{^Is_Block=_-ipa EXTENSIONS}', ""); +Expect(0, 687, '\P{Is_Block=_-ipa EXTENSIONS}', ""); +Expect(1, 687, '\P{^Is_Block=_-ipa EXTENSIONS}', ""); +Expect(0, 591, '\p{Is_Block=_-ipa EXTENSIONS}', ""); +Expect(1, 591, '\p{^Is_Block=_-ipa EXTENSIONS}', ""); +Expect(1, 591, '\P{Is_Block=_-ipa EXTENSIONS}', ""); +Expect(0, 591, '\P{^Is_Block=_-ipa EXTENSIONS}', ""); +Error('\p{Is_Blk=/a/__IPAEXTENSIONS}'); +Error('\P{Is_Blk=/a/__IPAEXTENSIONS}'); +Expect(1, 687, '\p{Is_Blk=ipaextensions}', ""); +Expect(0, 687, '\p{^Is_Blk=ipaextensions}', ""); +Expect(0, 687, '\P{Is_Blk=ipaextensions}', ""); +Expect(1, 687, '\P{^Is_Blk=ipaextensions}', ""); +Expect(0, 591, '\p{Is_Blk=ipaextensions}', ""); +Expect(1, 591, '\p{^Is_Blk=ipaextensions}', ""); +Expect(1, 591, '\P{Is_Blk=ipaextensions}', ""); +Expect(0, 591, '\P{^Is_Blk=ipaextensions}', ""); +Expect(1, 687, '\p{Is_Blk:- ipa Extensions}', ""); +Expect(0, 687, '\p{^Is_Blk:- ipa Extensions}', ""); +Expect(0, 687, '\P{Is_Blk:- ipa Extensions}', ""); +Expect(1, 687, '\P{^Is_Blk:- ipa Extensions}', ""); +Expect(0, 591, '\p{Is_Blk:- ipa Extensions}', ""); +Expect(1, 591, '\p{^Is_Blk:- ipa Extensions}', ""); +Expect(1, 591, '\P{Is_Blk:- ipa Extensions}', ""); +Expect(0, 591, '\P{^Is_Blk:- ipa Extensions}', ""); +Error('\p{Block= /a/kannada}'); +Error('\P{Block= /a/kannada}'); +Expect(1, 3327, '\p{Block=kannada}', ""); +Expect(0, 3327, '\p{^Block=kannada}', ""); +Expect(0, 3327, '\P{Block=kannada}', ""); +Expect(1, 3327, '\P{^Block=kannada}', ""); +Expect(0, 3199, '\p{Block=kannada}', ""); +Expect(1, 3199, '\p{^Block=kannada}', ""); +Expect(1, 3199, '\P{Block=kannada}', ""); +Expect(0, 3199, '\P{^Block=kannada}', ""); +Expect(1, 3327, '\p{Block= Kannada}', ""); +Expect(0, 3327, '\p{^Block= Kannada}', ""); +Expect(0, 3327, '\P{Block= Kannada}', ""); +Expect(1, 3327, '\P{^Block= Kannada}', ""); +Expect(0, 3199, '\p{Block= Kannada}', ""); +Expect(1, 3199, '\p{^Block= Kannada}', ""); +Expect(1, 3199, '\P{Block= Kannada}', ""); +Expect(0, 3199, '\P{^Block= Kannada}', ""); +Error('\p{Blk=__kannada/a/}'); +Error('\P{Blk=__kannada/a/}'); +Expect(1, 3327, '\p{Blk=kannada}', ""); +Expect(0, 3327, '\p{^Blk=kannada}', ""); +Expect(0, 3327, '\P{Blk=kannada}', ""); +Expect(1, 3327, '\P{^Blk=kannada}', ""); +Expect(0, 3199, '\p{Blk=kannada}', ""); +Expect(1, 3199, '\p{^Blk=kannada}', ""); +Expect(1, 3199, '\P{Blk=kannada}', ""); +Expect(0, 3199, '\P{^Blk=kannada}', ""); +Expect(1, 3327, '\p{Blk=--KANNADA}', ""); +Expect(0, 3327, '\p{^Blk=--KANNADA}', ""); +Expect(0, 3327, '\P{Blk=--KANNADA}', ""); +Expect(1, 3327, '\P{^Blk=--KANNADA}', ""); +Expect(0, 3199, '\p{Blk=--KANNADA}', ""); +Expect(1, 3199, '\p{^Blk=--KANNADA}', ""); +Expect(1, 3199, '\P{Blk=--KANNADA}', ""); +Expect(0, 3199, '\P{^Blk=--KANNADA}', ""); +Error('\p{Is_Block= _kannada/a/}'); +Error('\P{Is_Block= _kannada/a/}'); +Expect(1, 3327, '\p{Is_Block=kannada}', ""); +Expect(0, 3327, '\p{^Is_Block=kannada}', ""); +Expect(0, 3327, '\P{Is_Block=kannada}', ""); +Expect(1, 3327, '\P{^Is_Block=kannada}', ""); +Expect(0, 3199, '\p{Is_Block=kannada}', ""); +Expect(1, 3199, '\p{^Is_Block=kannada}', ""); +Expect(1, 3199, '\P{Is_Block=kannada}', ""); +Expect(0, 3199, '\P{^Is_Block=kannada}', ""); +Expect(1, 3327, '\p{Is_Block= _Kannada}', ""); +Expect(0, 3327, '\p{^Is_Block= _Kannada}', ""); +Expect(0, 3327, '\P{Is_Block= _Kannada}', ""); +Expect(1, 3327, '\P{^Is_Block= _Kannada}', ""); +Expect(0, 3199, '\p{Is_Block= _Kannada}', ""); +Expect(1, 3199, '\p{^Is_Block= _Kannada}', ""); +Expect(1, 3199, '\P{Is_Block= _Kannada}', ""); +Expect(0, 3199, '\P{^Is_Block= _Kannada}', ""); +Error('\p{Is_Blk=KANNADA:=}'); +Error('\P{Is_Blk=KANNADA:=}'); +Expect(1, 3327, '\p{Is_Blk=kannada}', ""); +Expect(0, 3327, '\p{^Is_Blk=kannada}', ""); +Expect(0, 3327, '\P{Is_Blk=kannada}', ""); +Expect(1, 3327, '\P{^Is_Blk=kannada}', ""); +Expect(0, 3199, '\p{Is_Blk=kannada}', ""); +Expect(1, 3199, '\p{^Is_Blk=kannada}', ""); +Expect(1, 3199, '\P{Is_Blk=kannada}', ""); +Expect(0, 3199, '\P{^Is_Blk=kannada}', ""); +Expect(1, 3327, '\p{Is_Blk= _kannada}', ""); +Expect(0, 3327, '\p{^Is_Blk= _kannada}', ""); +Expect(0, 3327, '\P{Is_Blk= _kannada}', ""); +Expect(1, 3327, '\P{^Is_Blk= _kannada}', ""); +Expect(0, 3199, '\p{Is_Blk= _kannada}', ""); +Expect(1, 3199, '\p{^Is_Blk= _kannada}', ""); +Expect(1, 3199, '\P{Is_Blk= _kannada}', ""); +Expect(0, 3199, '\P{^Is_Blk= _kannada}', ""); +Error('\p{Block= :=Latin extended_ADDITIONAL}'); +Error('\P{Block= :=Latin extended_ADDITIONAL}'); +Expect(1, 7935, '\p{Block=latinextendedadditional}', ""); +Expect(0, 7935, '\p{^Block=latinextendedadditional}', ""); +Expect(0, 7935, '\P{Block=latinextendedadditional}', ""); +Expect(1, 7935, '\P{^Block=latinextendedadditional}', ""); +Expect(0, 7679, '\p{Block=latinextendedadditional}', ""); +Expect(1, 7679, '\p{^Block=latinextendedadditional}', ""); +Expect(1, 7679, '\P{Block=latinextendedadditional}', ""); +Expect(0, 7679, '\P{^Block=latinextendedadditional}', ""); +Expect(1, 7935, '\p{Block=-_Latin Extended-Additional}', ""); +Expect(0, 7935, '\p{^Block=-_Latin Extended-Additional}', ""); +Expect(0, 7935, '\P{Block=-_Latin Extended-Additional}', ""); +Expect(1, 7935, '\P{^Block=-_Latin Extended-Additional}', ""); +Expect(0, 7679, '\p{Block=-_Latin Extended-Additional}', ""); +Expect(1, 7679, '\p{^Block=-_Latin Extended-Additional}', ""); +Expect(1, 7679, '\P{Block=-_Latin Extended-Additional}', ""); +Expect(0, 7679, '\P{^Block=-_Latin Extended-Additional}', ""); +Error('\p{Blk=:=- LatinExtended_Additional}'); +Error('\P{Blk=:=- LatinExtended_Additional}'); +Expect(1, 7935, '\p{Blk=latinextendedadditional}', ""); +Expect(0, 7935, '\p{^Blk=latinextendedadditional}', ""); +Expect(0, 7935, '\P{Blk=latinextendedadditional}', ""); +Expect(1, 7935, '\P{^Blk=latinextendedadditional}', ""); +Expect(0, 7679, '\p{Blk=latinextendedadditional}', ""); +Expect(1, 7679, '\p{^Blk=latinextendedadditional}', ""); +Expect(1, 7679, '\P{Blk=latinextendedadditional}', ""); +Expect(0, 7679, '\P{^Blk=latinextendedadditional}', ""); +Expect(1, 7935, '\p{Blk=--Latin EXTENDED ADDITIONAL}', ""); +Expect(0, 7935, '\p{^Blk=--Latin EXTENDED ADDITIONAL}', ""); +Expect(0, 7935, '\P{Blk=--Latin EXTENDED ADDITIONAL}', ""); +Expect(1, 7935, '\P{^Blk=--Latin EXTENDED ADDITIONAL}', ""); +Expect(0, 7679, '\p{Blk=--Latin EXTENDED ADDITIONAL}', ""); +Expect(1, 7679, '\p{^Blk=--Latin EXTENDED ADDITIONAL}', ""); +Expect(1, 7679, '\P{Blk=--Latin EXTENDED ADDITIONAL}', ""); +Expect(0, 7679, '\P{^Blk=--Latin EXTENDED ADDITIONAL}', ""); +Error('\p{Is_Block=-LATIN:=EXTENDED-Additional}'); +Error('\P{Is_Block=-LATIN:=EXTENDED-Additional}'); +Expect(1, 7935, '\p{Is_Block=latinextendedadditional}', ""); +Expect(0, 7935, '\p{^Is_Block=latinextendedadditional}', ""); +Expect(0, 7935, '\P{Is_Block=latinextendedadditional}', ""); +Expect(1, 7935, '\P{^Is_Block=latinextendedadditional}', ""); +Expect(0, 7679, '\p{Is_Block=latinextendedadditional}', ""); +Expect(1, 7679, '\p{^Is_Block=latinextendedadditional}', ""); +Expect(1, 7679, '\P{Is_Block=latinextendedadditional}', ""); +Expect(0, 7679, '\P{^Is_Block=latinextendedadditional}', ""); +Expect(1, 7935, '\p{Is_Block= LATINextended_additional}', ""); +Expect(0, 7935, '\p{^Is_Block= LATINextended_additional}', ""); +Expect(0, 7935, '\P{Is_Block= LATINextended_additional}', ""); +Expect(1, 7935, '\P{^Is_Block= LATINextended_additional}', ""); +Expect(0, 7679, '\p{Is_Block= LATINextended_additional}', ""); +Expect(1, 7679, '\p{^Is_Block= LATINextended_additional}', ""); +Expect(1, 7679, '\P{Is_Block= LATINextended_additional}', ""); +Expect(0, 7679, '\P{^Is_Block= LATINextended_additional}', ""); +Error('\p{Is_Blk= _latin extended/a/ADDITIONAL}'); +Error('\P{Is_Blk= _latin extended/a/ADDITIONAL}'); +Expect(1, 7935, '\p{Is_Blk: latinextendedadditional}', ""); +Expect(0, 7935, '\p{^Is_Blk: latinextendedadditional}', ""); +Expect(0, 7935, '\P{Is_Blk: latinextendedadditional}', ""); +Expect(1, 7935, '\P{^Is_Blk: latinextendedadditional}', ""); +Expect(0, 7679, '\p{Is_Blk: latinextendedadditional}', ""); +Expect(1, 7679, '\p{^Is_Blk: latinextendedadditional}', ""); +Expect(1, 7679, '\P{Is_Blk: latinextendedadditional}', ""); +Expect(0, 7679, '\P{^Is_Blk: latinextendedadditional}', ""); +Expect(1, 7935, '\p{Is_Blk: -LatinExtended Additional}', ""); +Expect(0, 7935, '\p{^Is_Blk: -LatinExtended Additional}', ""); +Expect(0, 7935, '\P{Is_Blk: -LatinExtended Additional}', ""); +Expect(1, 7935, '\P{^Is_Blk: -LatinExtended Additional}', ""); +Expect(0, 7679, '\p{Is_Blk: -LatinExtended Additional}', ""); +Expect(1, 7679, '\p{^Is_Blk: -LatinExtended Additional}', ""); +Expect(1, 7679, '\P{Is_Blk: -LatinExtended Additional}', ""); +Expect(0, 7679, '\P{^Is_Blk: -LatinExtended Additional}', ""); +Error('\p{Block= Cham:=}'); +Error('\P{Block= Cham:=}'); +Expect(1, 43615, '\p{Block=cham}', ""); +Expect(0, 43615, '\p{^Block=cham}', ""); +Expect(0, 43615, '\P{Block=cham}', ""); +Expect(1, 43615, '\P{^Block=cham}', ""); +Expect(0, 43519, '\p{Block=cham}', ""); +Expect(1, 43519, '\p{^Block=cham}', ""); +Expect(1, 43519, '\P{Block=cham}', ""); +Expect(0, 43519, '\P{^Block=cham}', ""); +Expect(1, 43615, '\p{Block=_-Cham}', ""); +Expect(0, 43615, '\p{^Block=_-Cham}', ""); +Expect(0, 43615, '\P{Block=_-Cham}', ""); +Expect(1, 43615, '\P{^Block=_-Cham}', ""); +Expect(0, 43519, '\p{Block=_-Cham}', ""); +Expect(1, 43519, '\p{^Block=_-Cham}', ""); +Expect(1, 43519, '\P{Block=_-Cham}', ""); +Expect(0, 43519, '\P{^Block=_-Cham}', ""); +Error('\p{Blk=- Cham/a/}'); +Error('\P{Blk=- Cham/a/}'); +Expect(1, 43615, '\p{Blk=cham}', ""); +Expect(0, 43615, '\p{^Blk=cham}', ""); +Expect(0, 43615, '\P{Blk=cham}', ""); +Expect(1, 43615, '\P{^Blk=cham}', ""); +Expect(0, 43519, '\p{Blk=cham}', ""); +Expect(1, 43519, '\p{^Blk=cham}', ""); +Expect(1, 43519, '\P{Blk=cham}', ""); +Expect(0, 43519, '\P{^Blk=cham}', ""); +Expect(1, 43615, '\p{Blk=_-cham}', ""); +Expect(0, 43615, '\p{^Blk=_-cham}', ""); +Expect(0, 43615, '\P{Blk=_-cham}', ""); +Expect(1, 43615, '\P{^Blk=_-cham}', ""); +Expect(0, 43519, '\p{Blk=_-cham}', ""); +Expect(1, 43519, '\p{^Blk=_-cham}', ""); +Expect(1, 43519, '\P{Blk=_-cham}', ""); +Expect(0, 43519, '\P{^Blk=_-cham}', ""); +Error('\p{Is_Block=:=-_Cham}'); +Error('\P{Is_Block=:=-_Cham}'); +Expect(1, 43615, '\p{Is_Block=cham}', ""); +Expect(0, 43615, '\p{^Is_Block=cham}', ""); +Expect(0, 43615, '\P{Is_Block=cham}', ""); +Expect(1, 43615, '\P{^Is_Block=cham}', ""); +Expect(0, 43519, '\p{Is_Block=cham}', ""); +Expect(1, 43519, '\p{^Is_Block=cham}', ""); +Expect(1, 43519, '\P{Is_Block=cham}', ""); +Expect(0, 43519, '\P{^Is_Block=cham}', ""); +Expect(1, 43615, '\p{Is_Block: Cham}', ""); +Expect(0, 43615, '\p{^Is_Block: Cham}', ""); +Expect(0, 43615, '\P{Is_Block: Cham}', ""); +Expect(1, 43615, '\P{^Is_Block: Cham}', ""); +Expect(0, 43519, '\p{Is_Block: Cham}', ""); +Expect(1, 43519, '\p{^Is_Block: Cham}', ""); +Expect(1, 43519, '\P{Is_Block: Cham}', ""); +Expect(0, 43519, '\P{^Is_Block: Cham}', ""); +Error('\p{Is_Blk=:=-Cham}'); +Error('\P{Is_Blk=:=-Cham}'); +Expect(1, 43615, '\p{Is_Blk=cham}', ""); +Expect(0, 43615, '\p{^Is_Blk=cham}', ""); +Expect(0, 43615, '\P{Is_Blk=cham}', ""); +Expect(1, 43615, '\P{^Is_Blk=cham}', ""); +Expect(0, 43519, '\p{Is_Blk=cham}', ""); +Expect(1, 43519, '\p{^Is_Blk=cham}', ""); +Expect(1, 43519, '\P{Is_Blk=cham}', ""); +Expect(0, 43519, '\P{^Is_Blk=cham}', ""); +Expect(1, 43615, '\p{Is_Blk= CHAM}', ""); +Expect(0, 43615, '\p{^Is_Blk= CHAM}', ""); +Expect(0, 43615, '\P{Is_Blk= CHAM}', ""); +Expect(1, 43615, '\P{^Is_Blk= CHAM}', ""); +Expect(0, 43519, '\p{Is_Blk= CHAM}', ""); +Expect(1, 43519, '\p{^Is_Blk= CHAM}', ""); +Expect(1, 43519, '\P{Is_Blk= CHAM}', ""); +Expect(0, 43519, '\P{^Is_Blk= CHAM}', ""); +Error('\p{Block: _ cyrillic/a/Supplement}'); +Error('\P{Block: _ cyrillic/a/Supplement}'); +Expect(1, 1327, '\p{Block=cyrillicsupplement}', ""); +Expect(0, 1327, '\p{^Block=cyrillicsupplement}', ""); +Expect(0, 1327, '\P{Block=cyrillicsupplement}', ""); +Expect(1, 1327, '\P{^Block=cyrillicsupplement}', ""); +Expect(0, 1279, '\p{Block=cyrillicsupplement}', ""); +Expect(1, 1279, '\p{^Block=cyrillicsupplement}', ""); +Expect(1, 1279, '\P{Block=cyrillicsupplement}', ""); +Expect(0, 1279, '\P{^Block=cyrillicsupplement}', ""); +Expect(1, 1327, '\p{Block: cyrillicsupplement}', ""); +Expect(0, 1327, '\p{^Block: cyrillicsupplement}', ""); +Expect(0, 1327, '\P{Block: cyrillicsupplement}', ""); +Expect(1, 1327, '\P{^Block: cyrillicsupplement}', ""); +Expect(0, 1279, '\p{Block: cyrillicsupplement}', ""); +Expect(1, 1279, '\p{^Block: cyrillicsupplement}', ""); +Expect(1, 1279, '\P{Block: cyrillicsupplement}', ""); +Expect(0, 1279, '\P{^Block: cyrillicsupplement}', ""); +Error('\p{Blk=:=-CYRILLIC_Supplementary}'); +Error('\P{Blk=:=-CYRILLIC_Supplementary}'); +Expect(1, 1327, '\p{Blk=cyrillicsupplementary}', ""); +Expect(0, 1327, '\p{^Blk=cyrillicsupplementary}', ""); +Expect(0, 1327, '\P{Blk=cyrillicsupplementary}', ""); +Expect(1, 1327, '\P{^Blk=cyrillicsupplementary}', ""); +Expect(0, 1279, '\p{Blk=cyrillicsupplementary}', ""); +Expect(1, 1279, '\p{^Blk=cyrillicsupplementary}', ""); +Expect(1, 1279, '\P{Blk=cyrillicsupplementary}', ""); +Expect(0, 1279, '\P{^Blk=cyrillicsupplementary}', ""); +Expect(1, 1327, '\p{Blk=-_cyrillic-supplementary}', ""); +Expect(0, 1327, '\p{^Blk=-_cyrillic-supplementary}', ""); +Expect(0, 1327, '\P{Blk=-_cyrillic-supplementary}', ""); +Expect(1, 1327, '\P{^Blk=-_cyrillic-supplementary}', ""); +Expect(0, 1279, '\p{Blk=-_cyrillic-supplementary}', ""); +Expect(1, 1279, '\p{^Blk=-_cyrillic-supplementary}', ""); +Expect(1, 1279, '\P{Blk=-_cyrillic-supplementary}', ""); +Expect(0, 1279, '\P{^Blk=-_cyrillic-supplementary}', ""); +Error('\p{Is_Block= :=Cyrillic-Supplement}'); +Error('\P{Is_Block= :=Cyrillic-Supplement}'); +Expect(1, 1327, '\p{Is_Block=cyrillicsupplement}', ""); +Expect(0, 1327, '\p{^Is_Block=cyrillicsupplement}', ""); +Expect(0, 1327, '\P{Is_Block=cyrillicsupplement}', ""); +Expect(1, 1327, '\P{^Is_Block=cyrillicsupplement}', ""); +Expect(0, 1279, '\p{Is_Block=cyrillicsupplement}', ""); +Expect(1, 1279, '\p{^Is_Block=cyrillicsupplement}', ""); +Expect(1, 1279, '\P{Is_Block=cyrillicsupplement}', ""); +Expect(0, 1279, '\P{^Is_Block=cyrillicsupplement}', ""); +Expect(1, 1327, '\p{Is_Block=__cyrillic_SUPPLEMENT}', ""); +Expect(0, 1327, '\p{^Is_Block=__cyrillic_SUPPLEMENT}', ""); +Expect(0, 1327, '\P{Is_Block=__cyrillic_SUPPLEMENT}', ""); +Expect(1, 1327, '\P{^Is_Block=__cyrillic_SUPPLEMENT}', ""); +Expect(0, 1279, '\p{Is_Block=__cyrillic_SUPPLEMENT}', ""); +Expect(1, 1279, '\p{^Is_Block=__cyrillic_SUPPLEMENT}', ""); +Expect(1, 1279, '\P{Is_Block=__cyrillic_SUPPLEMENT}', ""); +Expect(0, 1279, '\P{^Is_Block=__cyrillic_SUPPLEMENT}', ""); +Error('\p{Is_Blk= _Cyrillic SUPPLEMENTARY/a/}'); +Error('\P{Is_Blk= _Cyrillic SUPPLEMENTARY/a/}'); +Expect(1, 1327, '\p{Is_Blk=cyrillicsupplementary}', ""); +Expect(0, 1327, '\p{^Is_Blk=cyrillicsupplementary}', ""); +Expect(0, 1327, '\P{Is_Blk=cyrillicsupplementary}', ""); +Expect(1, 1327, '\P{^Is_Blk=cyrillicsupplementary}', ""); +Expect(0, 1279, '\p{Is_Blk=cyrillicsupplementary}', ""); +Expect(1, 1279, '\p{^Is_Blk=cyrillicsupplementary}', ""); +Expect(1, 1279, '\P{Is_Blk=cyrillicsupplementary}', ""); +Expect(0, 1279, '\P{^Is_Blk=cyrillicsupplementary}', ""); +Expect(1, 1327, '\p{Is_Blk=-CyrillicSupplementary}', ""); +Expect(0, 1327, '\p{^Is_Blk=-CyrillicSupplementary}', ""); +Expect(0, 1327, '\P{Is_Blk=-CyrillicSupplementary}', ""); +Expect(1, 1327, '\P{^Is_Blk=-CyrillicSupplementary}', ""); +Expect(0, 1279, '\p{Is_Blk=-CyrillicSupplementary}', ""); +Expect(1, 1279, '\p{^Is_Blk=-CyrillicSupplementary}', ""); +Expect(1, 1279, '\P{Is_Blk=-CyrillicSupplementary}', ""); +Expect(0, 1279, '\P{^Is_Blk=-CyrillicSupplementary}', ""); +Error('\p{Block=- Greek:=AND Coptic}'); +Error('\P{Block=- Greek:=AND Coptic}'); +Expect(1, 1023, '\p{Block=greekandcoptic}', ""); +Expect(0, 1023, '\p{^Block=greekandcoptic}', ""); +Expect(0, 1023, '\P{Block=greekandcoptic}', ""); +Expect(1, 1023, '\P{^Block=greekandcoptic}', ""); +Expect(0, 879, '\p{Block=greekandcoptic}', ""); +Expect(1, 879, '\p{^Block=greekandcoptic}', ""); +Expect(1, 879, '\P{Block=greekandcoptic}', ""); +Expect(0, 879, '\P{^Block=greekandcoptic}', ""); +Expect(1, 1023, '\p{Block= _Greek AND_coptic}', ""); +Expect(0, 1023, '\p{^Block= _Greek AND_coptic}', ""); +Expect(0, 1023, '\P{Block= _Greek AND_coptic}', ""); +Expect(1, 1023, '\P{^Block= _Greek AND_coptic}', ""); +Expect(0, 879, '\p{Block= _Greek AND_coptic}', ""); +Expect(1, 879, '\p{^Block= _Greek AND_coptic}', ""); +Expect(1, 879, '\P{Block= _Greek AND_coptic}', ""); +Expect(0, 879, '\P{^Block= _Greek AND_coptic}', ""); +Error('\p{Blk= -Greek:=}'); +Error('\P{Blk= -Greek:=}'); +Expect(1, 1023, '\p{Blk=greek}', ""); +Expect(0, 1023, '\p{^Blk=greek}', ""); +Expect(0, 1023, '\P{Blk=greek}', ""); +Expect(1, 1023, '\P{^Blk=greek}', ""); +Expect(0, 879, '\p{Blk=greek}', ""); +Expect(1, 879, '\p{^Blk=greek}', ""); +Expect(1, 879, '\P{Blk=greek}', ""); +Expect(0, 879, '\P{^Blk=greek}', ""); +Expect(1, 1023, '\p{Blk: - GREEK}', ""); +Expect(0, 1023, '\p{^Blk: - GREEK}', ""); +Expect(0, 1023, '\P{Blk: - GREEK}', ""); +Expect(1, 1023, '\P{^Blk: - GREEK}', ""); +Expect(0, 879, '\p{Blk: - GREEK}', ""); +Expect(1, 879, '\p{^Blk: - GREEK}', ""); +Expect(1, 879, '\P{Blk: - GREEK}', ""); +Expect(0, 879, '\P{^Blk: - GREEK}', ""); +Error('\p{Is_Block= Greek/a/And_COPTIC}'); +Error('\P{Is_Block= Greek/a/And_COPTIC}'); +Expect(1, 1023, '\p{Is_Block=greekandcoptic}', ""); +Expect(0, 1023, '\p{^Is_Block=greekandcoptic}', ""); +Expect(0, 1023, '\P{Is_Block=greekandcoptic}', ""); +Expect(1, 1023, '\P{^Is_Block=greekandcoptic}', ""); +Expect(0, 879, '\p{Is_Block=greekandcoptic}', ""); +Expect(1, 879, '\p{^Is_Block=greekandcoptic}', ""); +Expect(1, 879, '\P{Is_Block=greekandcoptic}', ""); +Expect(0, 879, '\P{^Is_Block=greekandcoptic}', ""); +Expect(1, 1023, '\p{Is_Block= GREEK-And COPTIC}', ""); +Expect(0, 1023, '\p{^Is_Block= GREEK-And COPTIC}', ""); +Expect(0, 1023, '\P{Is_Block= GREEK-And COPTIC}', ""); +Expect(1, 1023, '\P{^Is_Block= GREEK-And COPTIC}', ""); +Expect(0, 879, '\p{Is_Block= GREEK-And COPTIC}', ""); +Expect(1, 879, '\p{^Is_Block= GREEK-And COPTIC}', ""); +Expect(1, 879, '\P{Is_Block= GREEK-And COPTIC}', ""); +Expect(0, 879, '\P{^Is_Block= GREEK-And COPTIC}', ""); +Error('\p{Is_Blk: /a/ Greek}'); +Error('\P{Is_Blk: /a/ Greek}'); +Expect(1, 1023, '\p{Is_Blk=greek}', ""); +Expect(0, 1023, '\p{^Is_Blk=greek}', ""); +Expect(0, 1023, '\P{Is_Blk=greek}', ""); +Expect(1, 1023, '\P{^Is_Blk=greek}', ""); +Expect(0, 879, '\p{Is_Blk=greek}', ""); +Expect(1, 879, '\p{^Is_Blk=greek}', ""); +Expect(1, 879, '\P{Is_Blk=greek}', ""); +Expect(0, 879, '\P{^Is_Blk=greek}', ""); +Expect(1, 1023, '\p{Is_Blk= greek}', ""); +Expect(0, 1023, '\p{^Is_Blk= greek}', ""); +Expect(0, 1023, '\P{Is_Blk= greek}', ""); +Expect(1, 1023, '\P{^Is_Blk= greek}', ""); +Expect(0, 879, '\p{Is_Blk= greek}', ""); +Expect(1, 879, '\p{^Is_Blk= greek}', ""); +Expect(1, 879, '\P{Is_Blk= greek}', ""); +Expect(0, 879, '\P{^Is_Blk= greek}', ""); +Error('\p{Block= miscellaneous_Mathematical symbols_B/a/}'); +Error('\P{Block= miscellaneous_Mathematical symbols_B/a/}'); +Expect(1, 10751, '\p{Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\p{^Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\P{Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\P{^Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\p{Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\p{^Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\P{Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\P{^Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\p{Block= Miscellaneous-mathematical-SYMBOLS B}', ""); +Expect(0, 10751, '\p{^Block= Miscellaneous-mathematical-SYMBOLS B}', ""); +Expect(0, 10751, '\P{Block= Miscellaneous-mathematical-SYMBOLS B}', ""); +Expect(1, 10751, '\P{^Block= Miscellaneous-mathematical-SYMBOLS B}', ""); +Expect(0, 10623, '\p{Block= Miscellaneous-mathematical-SYMBOLS B}', ""); +Expect(1, 10623, '\p{^Block= Miscellaneous-mathematical-SYMBOLS B}', ""); +Expect(1, 10623, '\P{Block= Miscellaneous-mathematical-SYMBOLS B}', ""); +Expect(0, 10623, '\P{^Block= Miscellaneous-mathematical-SYMBOLS B}', ""); +Error('\p{Blk: - MiscellaneousMathematicalSymbols:=b}'); +Error('\P{Blk: - MiscellaneousMathematicalSymbols:=b}'); +Expect(1, 10751, '\p{Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\p{^Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\P{Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\P{^Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\p{Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\p{^Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\P{Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\P{^Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\p{Blk=_ miscellaneous Mathematical_SYMBOLS-b}', ""); +Expect(0, 10751, '\p{^Blk=_ miscellaneous Mathematical_SYMBOLS-b}', ""); +Expect(0, 10751, '\P{Blk=_ miscellaneous Mathematical_SYMBOLS-b}', ""); +Expect(1, 10751, '\P{^Blk=_ miscellaneous Mathematical_SYMBOLS-b}', ""); +Expect(0, 10623, '\p{Blk=_ miscellaneous Mathematical_SYMBOLS-b}', ""); +Expect(1, 10623, '\p{^Blk=_ miscellaneous Mathematical_SYMBOLS-b}', ""); +Expect(1, 10623, '\P{Blk=_ miscellaneous Mathematical_SYMBOLS-b}', ""); +Expect(0, 10623, '\P{^Blk=_ miscellaneous Mathematical_SYMBOLS-b}', ""); +Error('\p{Is_Block=--miscellaneous Mathematical_Symbols/a/B}'); +Error('\P{Is_Block=--miscellaneous Mathematical_Symbols/a/B}'); +Expect(1, 10751, '\p{Is_Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\p{^Is_Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\P{Is_Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\P{^Is_Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\p{Is_Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\p{^Is_Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\P{Is_Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\P{^Is_Block=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\p{Is_Block= miscellaneousMathematical-SYMBOLS_B}', ""); +Expect(0, 10751, '\p{^Is_Block= miscellaneousMathematical-SYMBOLS_B}', ""); +Expect(0, 10751, '\P{Is_Block= miscellaneousMathematical-SYMBOLS_B}', ""); +Expect(1, 10751, '\P{^Is_Block= miscellaneousMathematical-SYMBOLS_B}', ""); +Expect(0, 10623, '\p{Is_Block= miscellaneousMathematical-SYMBOLS_B}', ""); +Expect(1, 10623, '\p{^Is_Block= miscellaneousMathematical-SYMBOLS_B}', ""); +Expect(1, 10623, '\P{Is_Block= miscellaneousMathematical-SYMBOLS_B}', ""); +Expect(0, 10623, '\P{^Is_Block= miscellaneousMathematical-SYMBOLS_B}', ""); +Error('\p{Is_Blk=_/a/miscellaneous_mathematical-symbols B}'); +Error('\P{Is_Blk=_/a/miscellaneous_mathematical-symbols B}'); +Expect(1, 10751, '\p{Is_Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\p{^Is_Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\P{Is_Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\P{^Is_Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\p{Is_Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\p{^Is_Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\P{Is_Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\P{^Is_Blk=miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\p{Is_Blk= -Miscellaneous Mathematical Symbols B}', ""); +Expect(0, 10751, '\p{^Is_Blk= -Miscellaneous Mathematical Symbols B}', ""); +Expect(0, 10751, '\P{Is_Blk= -Miscellaneous Mathematical Symbols B}', ""); +Expect(1, 10751, '\P{^Is_Blk= -Miscellaneous Mathematical Symbols B}', ""); +Expect(0, 10623, '\p{Is_Blk= -Miscellaneous Mathematical Symbols B}', ""); +Expect(1, 10623, '\p{^Is_Blk= -Miscellaneous Mathematical Symbols B}', ""); +Expect(1, 10623, '\P{Is_Blk= -Miscellaneous Mathematical Symbols B}', ""); +Expect(0, 10623, '\P{^Is_Blk= -Miscellaneous Mathematical Symbols B}', ""); +Error('\p{Block=Bengali/a/}'); +Error('\P{Block=Bengali/a/}'); +Expect(1, 2559, '\p{Block=bengali}', ""); +Expect(0, 2559, '\p{^Block=bengali}', ""); +Expect(0, 2559, '\P{Block=bengali}', ""); +Expect(1, 2559, '\P{^Block=bengali}', ""); +Expect(0, 2431, '\p{Block=bengali}', ""); +Expect(1, 2431, '\p{^Block=bengali}', ""); +Expect(1, 2431, '\P{Block=bengali}', ""); +Expect(0, 2431, '\P{^Block=bengali}', ""); +Expect(1, 2559, '\p{Block= -bengali}', ""); +Expect(0, 2559, '\p{^Block= -bengali}', ""); +Expect(0, 2559, '\P{Block= -bengali}', ""); +Expect(1, 2559, '\P{^Block= -bengali}', ""); +Expect(0, 2431, '\p{Block= -bengali}', ""); +Expect(1, 2431, '\p{^Block= -bengali}', ""); +Expect(1, 2431, '\P{Block= -bengali}', ""); +Expect(0, 2431, '\P{^Block= -bengali}', ""); +Error('\p{Blk=/a/_ Bengali}'); +Error('\P{Blk=/a/_ Bengali}'); +Expect(1, 2559, '\p{Blk=bengali}', ""); +Expect(0, 2559, '\p{^Blk=bengali}', ""); +Expect(0, 2559, '\P{Blk=bengali}', ""); +Expect(1, 2559, '\P{^Blk=bengali}', ""); +Expect(0, 2431, '\p{Blk=bengali}', ""); +Expect(1, 2431, '\p{^Blk=bengali}', ""); +Expect(1, 2431, '\P{Blk=bengali}', ""); +Expect(0, 2431, '\P{^Blk=bengali}', ""); +Expect(1, 2559, '\p{Blk=-Bengali}', ""); +Expect(0, 2559, '\p{^Blk=-Bengali}', ""); +Expect(0, 2559, '\P{Blk=-Bengali}', ""); +Expect(1, 2559, '\P{^Blk=-Bengali}', ""); +Expect(0, 2431, '\p{Blk=-Bengali}', ""); +Expect(1, 2431, '\p{^Blk=-Bengali}', ""); +Expect(1, 2431, '\P{Blk=-Bengali}', ""); +Expect(0, 2431, '\P{^Blk=-Bengali}', ""); +Error('\p{Is_Block=:=-Bengali}'); +Error('\P{Is_Block=:=-Bengali}'); +Expect(1, 2559, '\p{Is_Block=bengali}', ""); +Expect(0, 2559, '\p{^Is_Block=bengali}', ""); +Expect(0, 2559, '\P{Is_Block=bengali}', ""); +Expect(1, 2559, '\P{^Is_Block=bengali}', ""); +Expect(0, 2431, '\p{Is_Block=bengali}', ""); +Expect(1, 2431, '\p{^Is_Block=bengali}', ""); +Expect(1, 2431, '\P{Is_Block=bengali}', ""); +Expect(0, 2431, '\P{^Is_Block=bengali}', ""); +Expect(1, 2559, '\p{Is_Block=-Bengali}', ""); +Expect(0, 2559, '\p{^Is_Block=-Bengali}', ""); +Expect(0, 2559, '\P{Is_Block=-Bengali}', ""); +Expect(1, 2559, '\P{^Is_Block=-Bengali}', ""); +Expect(0, 2431, '\p{Is_Block=-Bengali}', ""); +Expect(1, 2431, '\p{^Is_Block=-Bengali}', ""); +Expect(1, 2431, '\P{Is_Block=-Bengali}', ""); +Expect(0, 2431, '\P{^Is_Block=-Bengali}', ""); +Error('\p{Is_Blk=/a/ bengali}'); +Error('\P{Is_Blk=/a/ bengali}'); +Expect(1, 2559, '\p{Is_Blk=bengali}', ""); +Expect(0, 2559, '\p{^Is_Blk=bengali}', ""); +Expect(0, 2559, '\P{Is_Blk=bengali}', ""); +Expect(1, 2559, '\P{^Is_Blk=bengali}', ""); +Expect(0, 2431, '\p{Is_Blk=bengali}', ""); +Expect(1, 2431, '\p{^Is_Blk=bengali}', ""); +Expect(1, 2431, '\P{Is_Blk=bengali}', ""); +Expect(0, 2431, '\P{^Is_Blk=bengali}', ""); +Expect(1, 2559, '\p{Is_Blk=_-Bengali}', ""); +Expect(0, 2559, '\p{^Is_Blk=_-Bengali}', ""); +Expect(0, 2559, '\P{Is_Blk=_-Bengali}', ""); +Expect(1, 2559, '\P{^Is_Blk=_-Bengali}', ""); +Expect(0, 2431, '\p{Is_Blk=_-Bengali}', ""); +Expect(1, 2431, '\p{^Is_Blk=_-Bengali}', ""); +Expect(1, 2431, '\P{Is_Blk=_-Bengali}', ""); +Expect(0, 2431, '\P{^Is_Blk=_-Bengali}', ""); +Error('\p{Block= _Cypriot/a/Syllabary}'); +Error('\P{Block= _Cypriot/a/Syllabary}'); +Expect(1, 67647, '\p{Block=cypriotsyllabary}', ""); +Expect(0, 67647, '\p{^Block=cypriotsyllabary}', ""); +Expect(0, 67647, '\P{Block=cypriotsyllabary}', ""); +Expect(1, 67647, '\P{^Block=cypriotsyllabary}', ""); +Expect(0, 67583, '\p{Block=cypriotsyllabary}', ""); +Expect(1, 67583, '\p{^Block=cypriotsyllabary}', ""); +Expect(1, 67583, '\P{Block=cypriotsyllabary}', ""); +Expect(0, 67583, '\P{^Block=cypriotsyllabary}', ""); +Expect(1, 67647, '\p{Block=--Cypriotsyllabary}', ""); +Expect(0, 67647, '\p{^Block=--Cypriotsyllabary}', ""); +Expect(0, 67647, '\P{Block=--Cypriotsyllabary}', ""); +Expect(1, 67647, '\P{^Block=--Cypriotsyllabary}', ""); +Expect(0, 67583, '\p{Block=--Cypriotsyllabary}', ""); +Expect(1, 67583, '\p{^Block=--Cypriotsyllabary}', ""); +Expect(1, 67583, '\P{Block=--Cypriotsyllabary}', ""); +Expect(0, 67583, '\P{^Block=--Cypriotsyllabary}', ""); +Error('\p{Blk=/a/ _cypriotSyllabary}'); +Error('\P{Blk=/a/ _cypriotSyllabary}'); +Expect(1, 67647, '\p{Blk=cypriotsyllabary}', ""); +Expect(0, 67647, '\p{^Blk=cypriotsyllabary}', ""); +Expect(0, 67647, '\P{Blk=cypriotsyllabary}', ""); +Expect(1, 67647, '\P{^Blk=cypriotsyllabary}', ""); +Expect(0, 67583, '\p{Blk=cypriotsyllabary}', ""); +Expect(1, 67583, '\p{^Blk=cypriotsyllabary}', ""); +Expect(1, 67583, '\P{Blk=cypriotsyllabary}', ""); +Expect(0, 67583, '\P{^Blk=cypriotsyllabary}', ""); +Expect(1, 67647, '\p{Blk=_CYPRIOTSYLLABARY}', ""); +Expect(0, 67647, '\p{^Blk=_CYPRIOTSYLLABARY}', ""); +Expect(0, 67647, '\P{Blk=_CYPRIOTSYLLABARY}', ""); +Expect(1, 67647, '\P{^Blk=_CYPRIOTSYLLABARY}', ""); +Expect(0, 67583, '\p{Blk=_CYPRIOTSYLLABARY}', ""); +Expect(1, 67583, '\p{^Blk=_CYPRIOTSYLLABARY}', ""); +Expect(1, 67583, '\P{Blk=_CYPRIOTSYLLABARY}', ""); +Expect(0, 67583, '\P{^Blk=_CYPRIOTSYLLABARY}', ""); +Error('\p{Is_Block=:= -Cypriot Syllabary}'); +Error('\P{Is_Block=:= -Cypriot Syllabary}'); +Expect(1, 67647, '\p{Is_Block:cypriotsyllabary}', ""); +Expect(0, 67647, '\p{^Is_Block:cypriotsyllabary}', ""); +Expect(0, 67647, '\P{Is_Block:cypriotsyllabary}', ""); +Expect(1, 67647, '\P{^Is_Block:cypriotsyllabary}', ""); +Expect(0, 67583, '\p{Is_Block:cypriotsyllabary}', ""); +Expect(1, 67583, '\p{^Is_Block:cypriotsyllabary}', ""); +Expect(1, 67583, '\P{Is_Block:cypriotsyllabary}', ""); +Expect(0, 67583, '\P{^Is_Block:cypriotsyllabary}', ""); +Expect(1, 67647, '\p{Is_Block: -Cypriot Syllabary}', ""); +Expect(0, 67647, '\p{^Is_Block: -Cypriot Syllabary}', ""); +Expect(0, 67647, '\P{Is_Block: -Cypriot Syllabary}', ""); +Expect(1, 67647, '\P{^Is_Block: -Cypriot Syllabary}', ""); +Expect(0, 67583, '\p{Is_Block: -Cypriot Syllabary}', ""); +Expect(1, 67583, '\p{^Is_Block: -Cypriot Syllabary}', ""); +Expect(1, 67583, '\P{Is_Block: -Cypriot Syllabary}', ""); +Expect(0, 67583, '\P{^Is_Block: -Cypriot Syllabary}', ""); +Error('\p{Is_Blk= _CYPRIOT syllabary/a/}'); +Error('\P{Is_Blk= _CYPRIOT syllabary/a/}'); +Expect(1, 67647, '\p{Is_Blk=cypriotsyllabary}', ""); +Expect(0, 67647, '\p{^Is_Blk=cypriotsyllabary}', ""); +Expect(0, 67647, '\P{Is_Blk=cypriotsyllabary}', ""); +Expect(1, 67647, '\P{^Is_Blk=cypriotsyllabary}', ""); +Expect(0, 67583, '\p{Is_Blk=cypriotsyllabary}', ""); +Expect(1, 67583, '\p{^Is_Blk=cypriotsyllabary}', ""); +Expect(1, 67583, '\P{Is_Blk=cypriotsyllabary}', ""); +Expect(0, 67583, '\P{^Is_Blk=cypriotsyllabary}', ""); +Expect(1, 67647, '\p{Is_Blk= Cypriot Syllabary}', ""); +Expect(0, 67647, '\p{^Is_Blk= Cypriot Syllabary}', ""); +Expect(0, 67647, '\P{Is_Blk= Cypriot Syllabary}', ""); +Expect(1, 67647, '\P{^Is_Blk= Cypriot Syllabary}', ""); +Expect(0, 67583, '\p{Is_Blk= Cypriot Syllabary}', ""); +Expect(1, 67583, '\p{^Is_Blk= Cypriot Syllabary}', ""); +Expect(1, 67583, '\P{Is_Blk= Cypriot Syllabary}', ""); +Expect(0, 67583, '\P{^Is_Blk= Cypriot Syllabary}', ""); +Error('\p{Block= -supplemental/a/Punctuation}'); +Error('\P{Block= -supplemental/a/Punctuation}'); +Expect(1, 11903, '\p{Block=supplementalpunctuation}', ""); +Expect(0, 11903, '\p{^Block=supplementalpunctuation}', ""); +Expect(0, 11903, '\P{Block=supplementalpunctuation}', ""); +Expect(1, 11903, '\P{^Block=supplementalpunctuation}', ""); +Expect(0, 11775, '\p{Block=supplementalpunctuation}', ""); +Expect(1, 11775, '\p{^Block=supplementalpunctuation}', ""); +Expect(1, 11775, '\P{Block=supplementalpunctuation}', ""); +Expect(0, 11775, '\P{^Block=supplementalpunctuation}', ""); +Expect(1, 11903, '\p{Block= -Supplemental_Punctuation}', ""); +Expect(0, 11903, '\p{^Block= -Supplemental_Punctuation}', ""); +Expect(0, 11903, '\P{Block= -Supplemental_Punctuation}', ""); +Expect(1, 11903, '\P{^Block= -Supplemental_Punctuation}', ""); +Expect(0, 11775, '\p{Block= -Supplemental_Punctuation}', ""); +Expect(1, 11775, '\p{^Block= -Supplemental_Punctuation}', ""); +Expect(1, 11775, '\P{Block= -Supplemental_Punctuation}', ""); +Expect(0, 11775, '\P{^Block= -Supplemental_Punctuation}', ""); +Error('\p{Blk= :=Supplemental Punctuation}'); +Error('\P{Blk= :=Supplemental Punctuation}'); +Expect(1, 11903, '\p{Blk: supplementalpunctuation}', ""); +Expect(0, 11903, '\p{^Blk: supplementalpunctuation}', ""); +Expect(0, 11903, '\P{Blk: supplementalpunctuation}', ""); +Expect(1, 11903, '\P{^Blk: supplementalpunctuation}', ""); +Expect(0, 11775, '\p{Blk: supplementalpunctuation}', ""); +Expect(1, 11775, '\p{^Blk: supplementalpunctuation}', ""); +Expect(1, 11775, '\P{Blk: supplementalpunctuation}', ""); +Expect(0, 11775, '\P{^Blk: supplementalpunctuation}', ""); +Expect(1, 11903, '\p{Blk=_Supplemental_PUNCTUATION}', ""); +Expect(0, 11903, '\p{^Blk=_Supplemental_PUNCTUATION}', ""); +Expect(0, 11903, '\P{Blk=_Supplemental_PUNCTUATION}', ""); +Expect(1, 11903, '\P{^Blk=_Supplemental_PUNCTUATION}', ""); +Expect(0, 11775, '\p{Blk=_Supplemental_PUNCTUATION}', ""); +Expect(1, 11775, '\p{^Blk=_Supplemental_PUNCTUATION}', ""); +Expect(1, 11775, '\P{Blk=_Supplemental_PUNCTUATION}', ""); +Expect(0, 11775, '\P{^Blk=_Supplemental_PUNCTUATION}', ""); +Error('\p{Is_Block= SUPPLEMENTAL/a/punctuation}'); +Error('\P{Is_Block= SUPPLEMENTAL/a/punctuation}'); +Expect(1, 11903, '\p{Is_Block=supplementalpunctuation}', ""); +Expect(0, 11903, '\p{^Is_Block=supplementalpunctuation}', ""); +Expect(0, 11903, '\P{Is_Block=supplementalpunctuation}', ""); +Expect(1, 11903, '\P{^Is_Block=supplementalpunctuation}', ""); +Expect(0, 11775, '\p{Is_Block=supplementalpunctuation}', ""); +Expect(1, 11775, '\p{^Is_Block=supplementalpunctuation}', ""); +Expect(1, 11775, '\P{Is_Block=supplementalpunctuation}', ""); +Expect(0, 11775, '\P{^Is_Block=supplementalpunctuation}', ""); +Expect(1, 11903, '\p{Is_Block=_-Supplemental-PUNCTUATION}', ""); +Expect(0, 11903, '\p{^Is_Block=_-Supplemental-PUNCTUATION}', ""); +Expect(0, 11903, '\P{Is_Block=_-Supplemental-PUNCTUATION}', ""); +Expect(1, 11903, '\P{^Is_Block=_-Supplemental-PUNCTUATION}', ""); +Expect(0, 11775, '\p{Is_Block=_-Supplemental-PUNCTUATION}', ""); +Expect(1, 11775, '\p{^Is_Block=_-Supplemental-PUNCTUATION}', ""); +Expect(1, 11775, '\P{Is_Block=_-Supplemental-PUNCTUATION}', ""); +Expect(0, 11775, '\P{^Is_Block=_-Supplemental-PUNCTUATION}', ""); +Error('\p{Is_Blk= /a/Supplemental Punctuation}'); +Error('\P{Is_Blk= /a/Supplemental Punctuation}'); +Expect(1, 11903, '\p{Is_Blk=supplementalpunctuation}', ""); +Expect(0, 11903, '\p{^Is_Blk=supplementalpunctuation}', ""); +Expect(0, 11903, '\P{Is_Blk=supplementalpunctuation}', ""); +Expect(1, 11903, '\P{^Is_Blk=supplementalpunctuation}', ""); +Expect(0, 11775, '\p{Is_Blk=supplementalpunctuation}', ""); +Expect(1, 11775, '\p{^Is_Blk=supplementalpunctuation}', ""); +Expect(1, 11775, '\P{Is_Blk=supplementalpunctuation}', ""); +Expect(0, 11775, '\P{^Is_Blk=supplementalpunctuation}', ""); +Expect(1, 11903, '\p{Is_Blk: -SupplementalPunctuation}', ""); +Expect(0, 11903, '\p{^Is_Blk: -SupplementalPunctuation}', ""); +Expect(0, 11903, '\P{Is_Blk: -SupplementalPunctuation}', ""); +Expect(1, 11903, '\P{^Is_Blk: -SupplementalPunctuation}', ""); +Expect(0, 11775, '\p{Is_Blk: -SupplementalPunctuation}', ""); +Expect(1, 11775, '\p{^Is_Blk: -SupplementalPunctuation}', ""); +Expect(1, 11775, '\P{Is_Blk: -SupplementalPunctuation}', ""); +Expect(0, 11775, '\P{^Is_Blk: -SupplementalPunctuation}', ""); +Error('\p{Block=/a/_COPTIC}'); +Error('\P{Block=/a/_COPTIC}'); +Expect(1, 11519, '\p{Block=coptic}', ""); +Expect(0, 11519, '\p{^Block=coptic}', ""); +Expect(0, 11519, '\P{Block=coptic}', ""); +Expect(1, 11519, '\P{^Block=coptic}', ""); +Expect(0, 11391, '\p{Block=coptic}', ""); +Expect(1, 11391, '\p{^Block=coptic}', ""); +Expect(1, 11391, '\P{Block=coptic}', ""); +Expect(0, 11391, '\P{^Block=coptic}', ""); +Expect(1, 11519, '\p{Block= _COPTIC}', ""); +Expect(0, 11519, '\p{^Block= _COPTIC}', ""); +Expect(0, 11519, '\P{Block= _COPTIC}', ""); +Expect(1, 11519, '\P{^Block= _COPTIC}', ""); +Expect(0, 11391, '\p{Block= _COPTIC}', ""); +Expect(1, 11391, '\p{^Block= _COPTIC}', ""); +Expect(1, 11391, '\P{Block= _COPTIC}', ""); +Expect(0, 11391, '\P{^Block= _COPTIC}', ""); +Error('\p{Blk: Coptic/a/}'); +Error('\P{Blk: Coptic/a/}'); +Expect(1, 11519, '\p{Blk=coptic}', ""); +Expect(0, 11519, '\p{^Blk=coptic}', ""); +Expect(0, 11519, '\P{Blk=coptic}', ""); +Expect(1, 11519, '\P{^Blk=coptic}', ""); +Expect(0, 11391, '\p{Blk=coptic}', ""); +Expect(1, 11391, '\p{^Blk=coptic}', ""); +Expect(1, 11391, '\P{Blk=coptic}', ""); +Expect(0, 11391, '\P{^Blk=coptic}', ""); +Expect(1, 11519, '\p{Blk: coptic}', ""); +Expect(0, 11519, '\p{^Blk: coptic}', ""); +Expect(0, 11519, '\P{Blk: coptic}', ""); +Expect(1, 11519, '\P{^Blk: coptic}', ""); +Expect(0, 11391, '\p{Blk: coptic}', ""); +Expect(1, 11391, '\p{^Blk: coptic}', ""); +Expect(1, 11391, '\P{Blk: coptic}', ""); +Expect(0, 11391, '\P{^Blk: coptic}', ""); +Error('\p{Is_Block=/a/ _coptic}'); +Error('\P{Is_Block=/a/ _coptic}'); +Expect(1, 11519, '\p{Is_Block=coptic}', ""); +Expect(0, 11519, '\p{^Is_Block=coptic}', ""); +Expect(0, 11519, '\P{Is_Block=coptic}', ""); +Expect(1, 11519, '\P{^Is_Block=coptic}', ""); +Expect(0, 11391, '\p{Is_Block=coptic}', ""); +Expect(1, 11391, '\p{^Is_Block=coptic}', ""); +Expect(1, 11391, '\P{Is_Block=coptic}', ""); +Expect(0, 11391, '\P{^Is_Block=coptic}', ""); +Expect(1, 11519, '\p{Is_Block=_-coptic}', ""); +Expect(0, 11519, '\p{^Is_Block=_-coptic}', ""); +Expect(0, 11519, '\P{Is_Block=_-coptic}', ""); +Expect(1, 11519, '\P{^Is_Block=_-coptic}', ""); +Expect(0, 11391, '\p{Is_Block=_-coptic}', ""); +Expect(1, 11391, '\p{^Is_Block=_-coptic}', ""); +Expect(1, 11391, '\P{Is_Block=_-coptic}', ""); +Expect(0, 11391, '\P{^Is_Block=_-coptic}', ""); +Error('\p{Is_Blk= :=Coptic}'); +Error('\P{Is_Blk= :=Coptic}'); +Expect(1, 11519, '\p{Is_Blk=coptic}', ""); +Expect(0, 11519, '\p{^Is_Blk=coptic}', ""); +Expect(0, 11519, '\P{Is_Blk=coptic}', ""); +Expect(1, 11519, '\P{^Is_Blk=coptic}', ""); +Expect(0, 11391, '\p{Is_Blk=coptic}', ""); +Expect(1, 11391, '\p{^Is_Blk=coptic}', ""); +Expect(1, 11391, '\P{Is_Blk=coptic}', ""); +Expect(0, 11391, '\P{^Is_Blk=coptic}', ""); +Expect(1, 11519, '\p{Is_Blk= -Coptic}', ""); +Expect(0, 11519, '\p{^Is_Blk= -Coptic}', ""); +Expect(0, 11519, '\P{Is_Blk= -Coptic}', ""); +Expect(1, 11519, '\P{^Is_Blk= -Coptic}', ""); +Expect(0, 11391, '\p{Is_Blk= -Coptic}', ""); +Expect(1, 11391, '\p{^Is_Blk= -Coptic}', ""); +Expect(1, 11391, '\P{Is_Blk= -Coptic}', ""); +Expect(0, 11391, '\P{^Is_Blk= -Coptic}', ""); +Error('\p{Block=-:=SUPPLEMENTAL Arrows B}'); +Error('\P{Block=-:=SUPPLEMENTAL Arrows B}'); +Expect(1, 10623, '\p{Block=supplementalarrowsb}', ""); +Expect(0, 10623, '\p{^Block=supplementalarrowsb}', ""); +Expect(0, 10623, '\P{Block=supplementalarrowsb}', ""); +Expect(1, 10623, '\P{^Block=supplementalarrowsb}', ""); +Expect(0, 10495, '\p{Block=supplementalarrowsb}', ""); +Expect(1, 10495, '\p{^Block=supplementalarrowsb}', ""); +Expect(1, 10495, '\P{Block=supplementalarrowsb}', ""); +Expect(0, 10495, '\P{^Block=supplementalarrowsb}', ""); +Expect(1, 10623, '\p{Block= Supplemental Arrows_B}', ""); +Expect(0, 10623, '\p{^Block= Supplemental Arrows_B}', ""); +Expect(0, 10623, '\P{Block= Supplemental Arrows_B}', ""); +Expect(1, 10623, '\P{^Block= Supplemental Arrows_B}', ""); +Expect(0, 10495, '\p{Block= Supplemental Arrows_B}', ""); +Expect(1, 10495, '\p{^Block= Supplemental Arrows_B}', ""); +Expect(1, 10495, '\P{Block= Supplemental Arrows_B}', ""); +Expect(0, 10495, '\P{^Block= Supplemental Arrows_B}', ""); +Error('\p{Blk:_Supplemental ARROWS_B/a/}'); +Error('\P{Blk:_Supplemental ARROWS_B/a/}'); +Expect(1, 10623, '\p{Blk=supplementalarrowsb}', ""); +Expect(0, 10623, '\p{^Blk=supplementalarrowsb}', ""); +Expect(0, 10623, '\P{Blk=supplementalarrowsb}', ""); +Expect(1, 10623, '\P{^Blk=supplementalarrowsb}', ""); +Expect(0, 10495, '\p{Blk=supplementalarrowsb}', ""); +Expect(1, 10495, '\p{^Blk=supplementalarrowsb}', ""); +Expect(1, 10495, '\P{Blk=supplementalarrowsb}', ""); +Expect(0, 10495, '\P{^Blk=supplementalarrowsb}', ""); +Expect(1, 10623, '\p{Blk= SUPPLEMENTAL arrowsB}', ""); +Expect(0, 10623, '\p{^Blk= SUPPLEMENTAL arrowsB}', ""); +Expect(0, 10623, '\P{Blk= SUPPLEMENTAL arrowsB}', ""); +Expect(1, 10623, '\P{^Blk= SUPPLEMENTAL arrowsB}', ""); +Expect(0, 10495, '\p{Blk= SUPPLEMENTAL arrowsB}', ""); +Expect(1, 10495, '\p{^Blk= SUPPLEMENTAL arrowsB}', ""); +Expect(1, 10495, '\P{Blk= SUPPLEMENTAL arrowsB}', ""); +Expect(0, 10495, '\P{^Blk= SUPPLEMENTAL arrowsB}', ""); +Error('\p{Is_Block=-Supplemental-ArrowsB:=}'); +Error('\P{Is_Block=-Supplemental-ArrowsB:=}'); +Expect(1, 10623, '\p{Is_Block=supplementalarrowsb}', ""); +Expect(0, 10623, '\p{^Is_Block=supplementalarrowsb}', ""); +Expect(0, 10623, '\P{Is_Block=supplementalarrowsb}', ""); +Expect(1, 10623, '\P{^Is_Block=supplementalarrowsb}', ""); +Expect(0, 10495, '\p{Is_Block=supplementalarrowsb}', ""); +Expect(1, 10495, '\p{^Is_Block=supplementalarrowsb}', ""); +Expect(1, 10495, '\P{Is_Block=supplementalarrowsb}', ""); +Expect(0, 10495, '\P{^Is_Block=supplementalarrowsb}', ""); +Expect(1, 10623, '\p{Is_Block=_-SUPPLEMENTAL arrows B}', ""); +Expect(0, 10623, '\p{^Is_Block=_-SUPPLEMENTAL arrows B}', ""); +Expect(0, 10623, '\P{Is_Block=_-SUPPLEMENTAL arrows B}', ""); +Expect(1, 10623, '\P{^Is_Block=_-SUPPLEMENTAL arrows B}', ""); +Expect(0, 10495, '\p{Is_Block=_-SUPPLEMENTAL arrows B}', ""); +Expect(1, 10495, '\p{^Is_Block=_-SUPPLEMENTAL arrows B}', ""); +Expect(1, 10495, '\P{Is_Block=_-SUPPLEMENTAL arrows B}', ""); +Expect(0, 10495, '\P{^Is_Block=_-SUPPLEMENTAL arrows B}', ""); +Error('\p{Is_Blk=- Supplemental:=ARROWS b}'); +Error('\P{Is_Blk=- Supplemental:=ARROWS b}'); +Expect(1, 10623, '\p{Is_Blk=supplementalarrowsb}', ""); +Expect(0, 10623, '\p{^Is_Blk=supplementalarrowsb}', ""); +Expect(0, 10623, '\P{Is_Blk=supplementalarrowsb}', ""); +Expect(1, 10623, '\P{^Is_Blk=supplementalarrowsb}', ""); +Expect(0, 10495, '\p{Is_Blk=supplementalarrowsb}', ""); +Expect(1, 10495, '\p{^Is_Blk=supplementalarrowsb}', ""); +Expect(1, 10495, '\P{Is_Blk=supplementalarrowsb}', ""); +Expect(0, 10495, '\P{^Is_Blk=supplementalarrowsb}', ""); +Expect(1, 10623, '\p{Is_Blk=--supplemental-arrows_B}', ""); +Expect(0, 10623, '\p{^Is_Blk=--supplemental-arrows_B}', ""); +Expect(0, 10623, '\P{Is_Blk=--supplemental-arrows_B}', ""); +Expect(1, 10623, '\P{^Is_Blk=--supplemental-arrows_B}', ""); +Expect(0, 10495, '\p{Is_Blk=--supplemental-arrows_B}', ""); +Expect(1, 10495, '\p{^Is_Blk=--supplemental-arrows_B}', ""); +Expect(1, 10495, '\P{Is_Blk=--supplemental-arrows_B}', ""); +Expect(0, 10495, '\P{^Is_Blk=--supplemental-arrows_B}', ""); +Error('\p{Block=/a/_ TIBETAN}'); +Error('\P{Block=/a/_ TIBETAN}'); +Expect(1, 4095, '\p{Block=tibetan}', ""); +Expect(0, 4095, '\p{^Block=tibetan}', ""); +Expect(0, 4095, '\P{Block=tibetan}', ""); +Expect(1, 4095, '\P{^Block=tibetan}', ""); +Expect(0, 3839, '\p{Block=tibetan}', ""); +Expect(1, 3839, '\p{^Block=tibetan}', ""); +Expect(1, 3839, '\P{Block=tibetan}', ""); +Expect(0, 3839, '\P{^Block=tibetan}', ""); +Expect(1, 4095, '\p{Block= tibetan}', ""); +Expect(0, 4095, '\p{^Block= tibetan}', ""); +Expect(0, 4095, '\P{Block= tibetan}', ""); +Expect(1, 4095, '\P{^Block= tibetan}', ""); +Expect(0, 3839, '\p{Block= tibetan}', ""); +Expect(1, 3839, '\p{^Block= tibetan}', ""); +Expect(1, 3839, '\P{Block= tibetan}', ""); +Expect(0, 3839, '\P{^Block= tibetan}', ""); +Error('\p{Blk=-/a/TIBETAN}'); +Error('\P{Blk=-/a/TIBETAN}'); +Expect(1, 4095, '\p{Blk=tibetan}', ""); +Expect(0, 4095, '\p{^Blk=tibetan}', ""); +Expect(0, 4095, '\P{Blk=tibetan}', ""); +Expect(1, 4095, '\P{^Blk=tibetan}', ""); +Expect(0, 3839, '\p{Blk=tibetan}', ""); +Expect(1, 3839, '\p{^Blk=tibetan}', ""); +Expect(1, 3839, '\P{Blk=tibetan}', ""); +Expect(0, 3839, '\P{^Blk=tibetan}', ""); +Expect(1, 4095, '\p{Blk= TIBETAN}', ""); +Expect(0, 4095, '\p{^Blk= TIBETAN}', ""); +Expect(0, 4095, '\P{Blk= TIBETAN}', ""); +Expect(1, 4095, '\P{^Blk= TIBETAN}', ""); +Expect(0, 3839, '\p{Blk= TIBETAN}', ""); +Expect(1, 3839, '\p{^Blk= TIBETAN}', ""); +Expect(1, 3839, '\P{Blk= TIBETAN}', ""); +Expect(0, 3839, '\P{^Blk= TIBETAN}', ""); +Error('\p{Is_Block: tibetan/a/}'); +Error('\P{Is_Block: tibetan/a/}'); +Expect(1, 4095, '\p{Is_Block=tibetan}', ""); +Expect(0, 4095, '\p{^Is_Block=tibetan}', ""); +Expect(0, 4095, '\P{Is_Block=tibetan}', ""); +Expect(1, 4095, '\P{^Is_Block=tibetan}', ""); +Expect(0, 3839, '\p{Is_Block=tibetan}', ""); +Expect(1, 3839, '\p{^Is_Block=tibetan}', ""); +Expect(1, 3839, '\P{Is_Block=tibetan}', ""); +Expect(0, 3839, '\P{^Is_Block=tibetan}', ""); +Expect(1, 4095, '\p{Is_Block= Tibetan}', ""); +Expect(0, 4095, '\p{^Is_Block= Tibetan}', ""); +Expect(0, 4095, '\P{Is_Block= Tibetan}', ""); +Expect(1, 4095, '\P{^Is_Block= Tibetan}', ""); +Expect(0, 3839, '\p{Is_Block= Tibetan}', ""); +Expect(1, 3839, '\p{^Is_Block= Tibetan}', ""); +Expect(1, 3839, '\P{Is_Block= Tibetan}', ""); +Expect(0, 3839, '\P{^Is_Block= Tibetan}', ""); +Error('\p{Is_Blk=/a/-_tibetan}'); +Error('\P{Is_Blk=/a/-_tibetan}'); +Expect(1, 4095, '\p{Is_Blk=tibetan}', ""); +Expect(0, 4095, '\p{^Is_Blk=tibetan}', ""); +Expect(0, 4095, '\P{Is_Blk=tibetan}', ""); +Expect(1, 4095, '\P{^Is_Blk=tibetan}', ""); +Expect(0, 3839, '\p{Is_Blk=tibetan}', ""); +Expect(1, 3839, '\p{^Is_Blk=tibetan}', ""); +Expect(1, 3839, '\P{Is_Blk=tibetan}', ""); +Expect(0, 3839, '\P{^Is_Blk=tibetan}', ""); +Expect(1, 4095, '\p{Is_Blk=- TIBETAN}', ""); +Expect(0, 4095, '\p{^Is_Blk=- TIBETAN}', ""); +Expect(0, 4095, '\P{Is_Blk=- TIBETAN}', ""); +Expect(1, 4095, '\P{^Is_Blk=- TIBETAN}', ""); +Expect(0, 3839, '\p{Is_Blk=- TIBETAN}', ""); +Expect(1, 3839, '\p{^Is_Blk=- TIBETAN}', ""); +Expect(1, 3839, '\P{Is_Blk=- TIBETAN}', ""); +Expect(0, 3839, '\P{^Is_Blk=- TIBETAN}', ""); +Error('\p{Block=__DominoTiles/a/}'); +Error('\P{Block=__DominoTiles/a/}'); +Expect(1, 127135, '\p{Block=dominotiles}', ""); +Expect(0, 127135, '\p{^Block=dominotiles}', ""); +Expect(0, 127135, '\P{Block=dominotiles}', ""); +Expect(1, 127135, '\P{^Block=dominotiles}', ""); +Expect(0, 127023, '\p{Block=dominotiles}', ""); +Expect(1, 127023, '\p{^Block=dominotiles}', ""); +Expect(1, 127023, '\P{Block=dominotiles}', ""); +Expect(0, 127023, '\P{^Block=dominotiles}', ""); +Expect(1, 127135, '\p{Block= domino Tiles}', ""); +Expect(0, 127135, '\p{^Block= domino Tiles}', ""); +Expect(0, 127135, '\P{Block= domino Tiles}', ""); +Expect(1, 127135, '\P{^Block= domino Tiles}', ""); +Expect(0, 127023, '\p{Block= domino Tiles}', ""); +Expect(1, 127023, '\p{^Block= domino Tiles}', ""); +Expect(1, 127023, '\P{Block= domino Tiles}', ""); +Expect(0, 127023, '\P{^Block= domino Tiles}', ""); +Error('\p{Blk=- domino:=Tiles}'); +Error('\P{Blk=- domino:=Tiles}'); +Expect(1, 127135, '\p{Blk=dominotiles}', ""); +Expect(0, 127135, '\p{^Blk=dominotiles}', ""); +Expect(0, 127135, '\P{Blk=dominotiles}', ""); +Expect(1, 127135, '\P{^Blk=dominotiles}', ""); +Expect(0, 127023, '\p{Blk=dominotiles}', ""); +Expect(1, 127023, '\p{^Blk=dominotiles}', ""); +Expect(1, 127023, '\P{Blk=dominotiles}', ""); +Expect(0, 127023, '\P{^Blk=dominotiles}', ""); +Expect(1, 127135, '\p{Blk: -domino-Tiles}', ""); +Expect(0, 127135, '\p{^Blk: -domino-Tiles}', ""); +Expect(0, 127135, '\P{Blk: -domino-Tiles}', ""); +Expect(1, 127135, '\P{^Blk: -domino-Tiles}', ""); +Expect(0, 127023, '\p{Blk: -domino-Tiles}', ""); +Expect(1, 127023, '\p{^Blk: -domino-Tiles}', ""); +Expect(1, 127023, '\P{Blk: -domino-Tiles}', ""); +Expect(0, 127023, '\P{^Blk: -domino-Tiles}', ""); +Error('\p{Is_Block=_Domino/a/tiles}'); +Error('\P{Is_Block=_Domino/a/tiles}'); +Expect(1, 127135, '\p{Is_Block=dominotiles}', ""); +Expect(0, 127135, '\p{^Is_Block=dominotiles}', ""); +Expect(0, 127135, '\P{Is_Block=dominotiles}', ""); +Expect(1, 127135, '\P{^Is_Block=dominotiles}', ""); +Expect(0, 127023, '\p{Is_Block=dominotiles}', ""); +Expect(1, 127023, '\p{^Is_Block=dominotiles}', ""); +Expect(1, 127023, '\P{Is_Block=dominotiles}', ""); +Expect(0, 127023, '\P{^Is_Block=dominotiles}', ""); +Expect(1, 127135, '\p{Is_Block=- Domino Tiles}', ""); +Expect(0, 127135, '\p{^Is_Block=- Domino Tiles}', ""); +Expect(0, 127135, '\P{Is_Block=- Domino Tiles}', ""); +Expect(1, 127135, '\P{^Is_Block=- Domino Tiles}', ""); +Expect(0, 127023, '\p{Is_Block=- Domino Tiles}', ""); +Expect(1, 127023, '\p{^Is_Block=- Domino Tiles}', ""); +Expect(1, 127023, '\P{Is_Block=- Domino Tiles}', ""); +Expect(0, 127023, '\P{^Is_Block=- Domino Tiles}', ""); +Error('\p{Is_Blk=-DOMINO TILES/a/}'); +Error('\P{Is_Blk=-DOMINO TILES/a/}'); +Expect(1, 127135, '\p{Is_Blk=dominotiles}', ""); +Expect(0, 127135, '\p{^Is_Blk=dominotiles}', ""); +Expect(0, 127135, '\P{Is_Blk=dominotiles}', ""); +Expect(1, 127135, '\P{^Is_Blk=dominotiles}', ""); +Expect(0, 127023, '\p{Is_Blk=dominotiles}', ""); +Expect(1, 127023, '\p{^Is_Blk=dominotiles}', ""); +Expect(1, 127023, '\P{Is_Blk=dominotiles}', ""); +Expect(0, 127023, '\P{^Is_Blk=dominotiles}', ""); +Expect(1, 127135, '\p{Is_Blk=-_domino-tiles}', ""); +Expect(0, 127135, '\p{^Is_Blk=-_domino-tiles}', ""); +Expect(0, 127135, '\P{Is_Blk=-_domino-tiles}', ""); +Expect(1, 127135, '\P{^Is_Blk=-_domino-tiles}', ""); +Expect(0, 127023, '\p{Is_Blk=-_domino-tiles}', ""); +Expect(1, 127023, '\p{^Is_Blk=-_domino-tiles}', ""); +Expect(1, 127023, '\P{Is_Blk=-_domino-tiles}', ""); +Expect(0, 127023, '\P{^Is_Blk=-_domino-tiles}', ""); +Error('\p{Block= /a/CJK_SYMBOLS And-PUNCTUATION}'); +Error('\P{Block= /a/CJK_SYMBOLS And-PUNCTUATION}'); +Expect(1, 12351, '\p{Block=cjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\p{^Block=cjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\P{Block=cjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\P{^Block=cjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\p{Block=cjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\p{^Block=cjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\P{Block=cjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\P{^Block=cjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\p{Block=- CJKSymbolsAndPunctuation}', ""); +Expect(0, 12351, '\p{^Block=- CJKSymbolsAndPunctuation}', ""); +Expect(0, 12351, '\P{Block=- CJKSymbolsAndPunctuation}', ""); +Expect(1, 12351, '\P{^Block=- CJKSymbolsAndPunctuation}', ""); +Expect(0, 12287, '\p{Block=- CJKSymbolsAndPunctuation}', ""); +Expect(1, 12287, '\p{^Block=- CJKSymbolsAndPunctuation}', ""); +Expect(1, 12287, '\P{Block=- CJKSymbolsAndPunctuation}', ""); +Expect(0, 12287, '\P{^Block=- CJKSymbolsAndPunctuation}', ""); +Error('\p{Blk=--CJKsymbols:=AND PUNCTUATION}'); +Error('\P{Blk=--CJKsymbols:=AND PUNCTUATION}'); +Expect(1, 12351, '\p{Blk=cjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\p{^Blk=cjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\P{Blk=cjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\P{^Blk=cjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\p{Blk=cjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\p{^Blk=cjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\P{Blk=cjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\P{^Blk=cjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\p{Blk=__CJK Symbols and punctuation}', ""); +Expect(0, 12351, '\p{^Blk=__CJK Symbols and punctuation}', ""); +Expect(0, 12351, '\P{Blk=__CJK Symbols and punctuation}', ""); +Expect(1, 12351, '\P{^Blk=__CJK Symbols and punctuation}', ""); +Expect(0, 12287, '\p{Blk=__CJK Symbols and punctuation}', ""); +Expect(1, 12287, '\p{^Blk=__CJK Symbols and punctuation}', ""); +Expect(1, 12287, '\P{Blk=__CJK Symbols and punctuation}', ""); +Expect(0, 12287, '\P{^Blk=__CJK Symbols and punctuation}', ""); +Error('\p{Is_Block=- CJK/a/SYMBOLSAND punctuation}'); +Error('\P{Is_Block=- CJK/a/SYMBOLSAND punctuation}'); +Expect(1, 12351, '\p{Is_Block=cjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\p{^Is_Block=cjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\P{Is_Block=cjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\P{^Is_Block=cjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\p{Is_Block=cjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\p{^Is_Block=cjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\P{Is_Block=cjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\P{^Is_Block=cjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\p{Is_Block=- CJK-SYMBOLS AND Punctuation}', ""); +Expect(0, 12351, '\p{^Is_Block=- CJK-SYMBOLS AND Punctuation}', ""); +Expect(0, 12351, '\P{Is_Block=- CJK-SYMBOLS AND Punctuation}', ""); +Expect(1, 12351, '\P{^Is_Block=- CJK-SYMBOLS AND Punctuation}', ""); +Expect(0, 12287, '\p{Is_Block=- CJK-SYMBOLS AND Punctuation}', ""); +Expect(1, 12287, '\p{^Is_Block=- CJK-SYMBOLS AND Punctuation}', ""); +Expect(1, 12287, '\P{Is_Block=- CJK-SYMBOLS AND Punctuation}', ""); +Expect(0, 12287, '\P{^Is_Block=- CJK-SYMBOLS AND Punctuation}', ""); +Error('\p{Is_Blk: _:=CJKsymbolsand Punctuation}'); +Error('\P{Is_Blk: _:=CJKsymbolsand Punctuation}'); +Expect(1, 12351, '\p{Is_Blk: cjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\p{^Is_Blk: cjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\P{Is_Blk: cjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\P{^Is_Blk: cjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\p{Is_Blk: cjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\p{^Is_Blk: cjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\P{Is_Blk: cjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\P{^Is_Blk: cjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\p{Is_Blk=_-CJKSYMBOLS And_Punctuation}', ""); +Expect(0, 12351, '\p{^Is_Blk=_-CJKSYMBOLS And_Punctuation}', ""); +Expect(0, 12351, '\P{Is_Blk=_-CJKSYMBOLS And_Punctuation}', ""); +Expect(1, 12351, '\P{^Is_Blk=_-CJKSYMBOLS And_Punctuation}', ""); +Expect(0, 12287, '\p{Is_Blk=_-CJKSYMBOLS And_Punctuation}', ""); +Expect(1, 12287, '\p{^Is_Blk=_-CJKSYMBOLS And_Punctuation}', ""); +Expect(1, 12287, '\P{Is_Blk=_-CJKSYMBOLS And_Punctuation}', ""); +Expect(0, 12287, '\P{^Is_Blk=_-CJKSYMBOLS And_Punctuation}', ""); +Error('\p{Block=-:=hangul Compatibility_JAMO}'); +Error('\P{Block=-:=hangul Compatibility_JAMO}'); +Expect(1, 12687, '\p{Block: hangulcompatibilityjamo}', ""); +Expect(0, 12687, '\p{^Block: hangulcompatibilityjamo}', ""); +Expect(0, 12687, '\P{Block: hangulcompatibilityjamo}', ""); +Expect(1, 12687, '\P{^Block: hangulcompatibilityjamo}', ""); +Expect(0, 12591, '\p{Block: hangulcompatibilityjamo}', ""); +Expect(1, 12591, '\p{^Block: hangulcompatibilityjamo}', ""); +Expect(1, 12591, '\P{Block: hangulcompatibilityjamo}', ""); +Expect(0, 12591, '\P{^Block: hangulcompatibilityjamo}', ""); +Expect(1, 12687, '\p{Block= HANGUL Compatibility_Jamo}', ""); +Expect(0, 12687, '\p{^Block= HANGUL Compatibility_Jamo}', ""); +Expect(0, 12687, '\P{Block= HANGUL Compatibility_Jamo}', ""); +Expect(1, 12687, '\P{^Block= HANGUL Compatibility_Jamo}', ""); +Expect(0, 12591, '\p{Block= HANGUL Compatibility_Jamo}', ""); +Expect(1, 12591, '\p{^Block= HANGUL Compatibility_Jamo}', ""); +Expect(1, 12591, '\P{Block= HANGUL Compatibility_Jamo}', ""); +Expect(0, 12591, '\P{^Block= HANGUL Compatibility_Jamo}', ""); +Error('\p{Blk=- HANGUL/a/compatibility-jamo}'); +Error('\P{Blk=- HANGUL/a/compatibility-jamo}'); +Expect(1, 12687, '\p{Blk=hangulcompatibilityjamo}', ""); +Expect(0, 12687, '\p{^Blk=hangulcompatibilityjamo}', ""); +Expect(0, 12687, '\P{Blk=hangulcompatibilityjamo}', ""); +Expect(1, 12687, '\P{^Blk=hangulcompatibilityjamo}', ""); +Expect(0, 12591, '\p{Blk=hangulcompatibilityjamo}', ""); +Expect(1, 12591, '\p{^Blk=hangulcompatibilityjamo}', ""); +Expect(1, 12591, '\P{Blk=hangulcompatibilityjamo}', ""); +Expect(0, 12591, '\P{^Blk=hangulcompatibilityjamo}', ""); +Expect(1, 12687, '\p{Blk: HANGULCOMPATIBILITY JAMO}', ""); +Expect(0, 12687, '\p{^Blk: HANGULCOMPATIBILITY JAMO}', ""); +Expect(0, 12687, '\P{Blk: HANGULCOMPATIBILITY JAMO}', ""); +Expect(1, 12687, '\P{^Blk: HANGULCOMPATIBILITY JAMO}', ""); +Expect(0, 12591, '\p{Blk: HANGULCOMPATIBILITY JAMO}', ""); +Expect(1, 12591, '\p{^Blk: HANGULCOMPATIBILITY JAMO}', ""); +Expect(1, 12591, '\P{Blk: HANGULCOMPATIBILITY JAMO}', ""); +Expect(0, 12591, '\P{^Blk: HANGULCOMPATIBILITY JAMO}', ""); +Error('\p{Is_Block=/a/ -Hangul Compatibility-JAMO}'); +Error('\P{Is_Block=/a/ -Hangul Compatibility-JAMO}'); +Expect(1, 12687, '\p{Is_Block:hangulcompatibilityjamo}', ""); +Expect(0, 12687, '\p{^Is_Block:hangulcompatibilityjamo}', ""); +Expect(0, 12687, '\P{Is_Block:hangulcompatibilityjamo}', ""); +Expect(1, 12687, '\P{^Is_Block:hangulcompatibilityjamo}', ""); +Expect(0, 12591, '\p{Is_Block:hangulcompatibilityjamo}', ""); +Expect(1, 12591, '\p{^Is_Block:hangulcompatibilityjamo}', ""); +Expect(1, 12591, '\P{Is_Block:hangulcompatibilityjamo}', ""); +Expect(0, 12591, '\P{^Is_Block:hangulcompatibilityjamo}', ""); +Expect(1, 12687, '\p{Is_Block= HANGUL-Compatibility_jamo}', ""); +Expect(0, 12687, '\p{^Is_Block= HANGUL-Compatibility_jamo}', ""); +Expect(0, 12687, '\P{Is_Block= HANGUL-Compatibility_jamo}', ""); +Expect(1, 12687, '\P{^Is_Block= HANGUL-Compatibility_jamo}', ""); +Expect(0, 12591, '\p{Is_Block= HANGUL-Compatibility_jamo}', ""); +Expect(1, 12591, '\p{^Is_Block= HANGUL-Compatibility_jamo}', ""); +Expect(1, 12591, '\P{Is_Block= HANGUL-Compatibility_jamo}', ""); +Expect(0, 12591, '\P{^Is_Block= HANGUL-Compatibility_jamo}', ""); +Error('\p{Is_Blk=-HANGUL Compatibility/a/Jamo}'); +Error('\P{Is_Blk=-HANGUL Compatibility/a/Jamo}'); +Expect(1, 12687, '\p{Is_Blk=hangulcompatibilityjamo}', ""); +Expect(0, 12687, '\p{^Is_Blk=hangulcompatibilityjamo}', ""); +Expect(0, 12687, '\P{Is_Blk=hangulcompatibilityjamo}', ""); +Expect(1, 12687, '\P{^Is_Blk=hangulcompatibilityjamo}', ""); +Expect(0, 12591, '\p{Is_Blk=hangulcompatibilityjamo}', ""); +Expect(1, 12591, '\p{^Is_Blk=hangulcompatibilityjamo}', ""); +Expect(1, 12591, '\P{Is_Blk=hangulcompatibilityjamo}', ""); +Expect(0, 12591, '\P{^Is_Blk=hangulcompatibilityjamo}', ""); +Expect(1, 12687, '\p{Is_Blk=- Hangul_compatibility-jamo}', ""); +Expect(0, 12687, '\p{^Is_Blk=- Hangul_compatibility-jamo}', ""); +Expect(0, 12687, '\P{Is_Blk=- Hangul_compatibility-jamo}', ""); +Expect(1, 12687, '\P{^Is_Blk=- Hangul_compatibility-jamo}', ""); +Expect(0, 12591, '\p{Is_Blk=- Hangul_compatibility-jamo}', ""); +Expect(1, 12591, '\p{^Is_Blk=- Hangul_compatibility-jamo}', ""); +Expect(1, 12591, '\P{Is_Blk=- Hangul_compatibility-jamo}', ""); +Expect(0, 12591, '\P{^Is_Blk=- Hangul_compatibility-jamo}', ""); +Error('\p{Block=-:=OldPersian}'); +Error('\P{Block=-:=OldPersian}'); +Expect(1, 66527, '\p{Block=oldpersian}', ""); +Expect(0, 66527, '\p{^Block=oldpersian}', ""); +Expect(0, 66527, '\P{Block=oldpersian}', ""); +Expect(1, 66527, '\P{^Block=oldpersian}', ""); +Expect(0, 66463, '\p{Block=oldpersian}', ""); +Expect(1, 66463, '\p{^Block=oldpersian}', ""); +Expect(1, 66463, '\P{Block=oldpersian}', ""); +Expect(0, 66463, '\P{^Block=oldpersian}', ""); +Expect(1, 66527, '\p{Block=_ OLDpersian}', ""); +Expect(0, 66527, '\p{^Block=_ OLDpersian}', ""); +Expect(0, 66527, '\P{Block=_ OLDpersian}', ""); +Expect(1, 66527, '\P{^Block=_ OLDpersian}', ""); +Expect(0, 66463, '\p{Block=_ OLDpersian}', ""); +Expect(1, 66463, '\p{^Block=_ OLDpersian}', ""); +Expect(1, 66463, '\P{Block=_ OLDpersian}', ""); +Expect(0, 66463, '\P{^Block=_ OLDpersian}', ""); +Error('\p{Blk=-old:=Persian}'); +Error('\P{Blk=-old:=Persian}'); +Expect(1, 66527, '\p{Blk=oldpersian}', ""); +Expect(0, 66527, '\p{^Blk=oldpersian}', ""); +Expect(0, 66527, '\P{Blk=oldpersian}', ""); +Expect(1, 66527, '\P{^Blk=oldpersian}', ""); +Expect(0, 66463, '\p{Blk=oldpersian}', ""); +Expect(1, 66463, '\p{^Blk=oldpersian}', ""); +Expect(1, 66463, '\P{Blk=oldpersian}', ""); +Expect(0, 66463, '\P{^Blk=oldpersian}', ""); +Expect(1, 66527, '\p{Blk=- OLD Persian}', ""); +Expect(0, 66527, '\p{^Blk=- OLD Persian}', ""); +Expect(0, 66527, '\P{Blk=- OLD Persian}', ""); +Expect(1, 66527, '\P{^Blk=- OLD Persian}', ""); +Expect(0, 66463, '\p{Blk=- OLD Persian}', ""); +Expect(1, 66463, '\p{^Blk=- OLD Persian}', ""); +Expect(1, 66463, '\P{Blk=- OLD Persian}', ""); +Expect(0, 66463, '\P{^Blk=- OLD Persian}', ""); +Error('\p{Is_Block=_:=old Persian}'); +Error('\P{Is_Block=_:=old Persian}'); +Expect(1, 66527, '\p{Is_Block: oldpersian}', ""); +Expect(0, 66527, '\p{^Is_Block: oldpersian}', ""); +Expect(0, 66527, '\P{Is_Block: oldpersian}', ""); +Expect(1, 66527, '\P{^Is_Block: oldpersian}', ""); +Expect(0, 66463, '\p{Is_Block: oldpersian}', ""); +Expect(1, 66463, '\p{^Is_Block: oldpersian}', ""); +Expect(1, 66463, '\P{Is_Block: oldpersian}', ""); +Expect(0, 66463, '\P{^Is_Block: oldpersian}', ""); +Expect(1, 66527, '\p{Is_Block=- Old persian}', ""); +Expect(0, 66527, '\p{^Is_Block=- Old persian}', ""); +Expect(0, 66527, '\P{Is_Block=- Old persian}', ""); +Expect(1, 66527, '\P{^Is_Block=- Old persian}', ""); +Expect(0, 66463, '\p{Is_Block=- Old persian}', ""); +Expect(1, 66463, '\p{^Is_Block=- Old persian}', ""); +Expect(1, 66463, '\P{Is_Block=- Old persian}', ""); +Expect(0, 66463, '\P{^Is_Block=- Old persian}', ""); +Error('\p{Is_Blk=_:=Old persian}'); +Error('\P{Is_Blk=_:=Old persian}'); +Expect(1, 66527, '\p{Is_Blk=oldpersian}', ""); +Expect(0, 66527, '\p{^Is_Blk=oldpersian}', ""); +Expect(0, 66527, '\P{Is_Blk=oldpersian}', ""); +Expect(1, 66527, '\P{^Is_Blk=oldpersian}', ""); +Expect(0, 66463, '\p{Is_Blk=oldpersian}', ""); +Expect(1, 66463, '\p{^Is_Blk=oldpersian}', ""); +Expect(1, 66463, '\P{Is_Blk=oldpersian}', ""); +Expect(0, 66463, '\P{^Is_Blk=oldpersian}', ""); +Expect(1, 66527, '\p{Is_Blk=OldPERSIAN}', ""); +Expect(0, 66527, '\p{^Is_Blk=OldPERSIAN}', ""); +Expect(0, 66527, '\P{Is_Blk=OldPERSIAN}', ""); +Expect(1, 66527, '\P{^Is_Blk=OldPERSIAN}', ""); +Expect(0, 66463, '\p{Is_Blk=OldPERSIAN}', ""); +Expect(1, 66463, '\p{^Is_Blk=OldPERSIAN}', ""); +Expect(1, 66463, '\P{Is_Blk=OldPERSIAN}', ""); +Expect(0, 66463, '\P{^Is_Blk=OldPERSIAN}', ""); +Error('\p{Block= _modifier/a/Tone_Letters}'); +Error('\P{Block= _modifier/a/Tone_Letters}'); +Expect(1, 42783, '\p{Block=modifiertoneletters}', ""); +Expect(0, 42783, '\p{^Block=modifiertoneletters}', ""); +Expect(0, 42783, '\P{Block=modifiertoneletters}', ""); +Expect(1, 42783, '\P{^Block=modifiertoneletters}', ""); +Expect(0, 42751, '\p{Block=modifiertoneletters}', ""); +Expect(1, 42751, '\p{^Block=modifiertoneletters}', ""); +Expect(1, 42751, '\P{Block=modifiertoneletters}', ""); +Expect(0, 42751, '\P{^Block=modifiertoneletters}', ""); +Expect(1, 42783, '\p{Block= -Modifier TONE letters}', ""); +Expect(0, 42783, '\p{^Block= -Modifier TONE letters}', ""); +Expect(0, 42783, '\P{Block= -Modifier TONE letters}', ""); +Expect(1, 42783, '\P{^Block= -Modifier TONE letters}', ""); +Expect(0, 42751, '\p{Block= -Modifier TONE letters}', ""); +Expect(1, 42751, '\p{^Block= -Modifier TONE letters}', ""); +Expect(1, 42751, '\P{Block= -Modifier TONE letters}', ""); +Expect(0, 42751, '\P{^Block= -Modifier TONE letters}', ""); +Error('\p{Blk= Modifier/a/tone Letters}'); +Error('\P{Blk= Modifier/a/tone Letters}'); +Expect(1, 42783, '\p{Blk=modifiertoneletters}', ""); +Expect(0, 42783, '\p{^Blk=modifiertoneletters}', ""); +Expect(0, 42783, '\P{Blk=modifiertoneletters}', ""); +Expect(1, 42783, '\P{^Blk=modifiertoneletters}', ""); +Expect(0, 42751, '\p{Blk=modifiertoneletters}', ""); +Expect(1, 42751, '\p{^Blk=modifiertoneletters}', ""); +Expect(1, 42751, '\P{Blk=modifiertoneletters}', ""); +Expect(0, 42751, '\P{^Blk=modifiertoneletters}', ""); +Expect(1, 42783, '\p{Blk=__Modifier_Tone Letters}', ""); +Expect(0, 42783, '\p{^Blk=__Modifier_Tone Letters}', ""); +Expect(0, 42783, '\P{Blk=__Modifier_Tone Letters}', ""); +Expect(1, 42783, '\P{^Blk=__Modifier_Tone Letters}', ""); +Expect(0, 42751, '\p{Blk=__Modifier_Tone Letters}', ""); +Expect(1, 42751, '\p{^Blk=__Modifier_Tone Letters}', ""); +Expect(1, 42751, '\P{Blk=__Modifier_Tone Letters}', ""); +Expect(0, 42751, '\P{^Blk=__Modifier_Tone Letters}', ""); +Error('\p{Is_Block:_ MODIFIER:=Tone LETTERS}'); +Error('\P{Is_Block:_ MODIFIER:=Tone LETTERS}'); +Expect(1, 42783, '\p{Is_Block: modifiertoneletters}', ""); +Expect(0, 42783, '\p{^Is_Block: modifiertoneletters}', ""); +Expect(0, 42783, '\P{Is_Block: modifiertoneletters}', ""); +Expect(1, 42783, '\P{^Is_Block: modifiertoneletters}', ""); +Expect(0, 42751, '\p{Is_Block: modifiertoneletters}', ""); +Expect(1, 42751, '\p{^Is_Block: modifiertoneletters}', ""); +Expect(1, 42751, '\P{Is_Block: modifiertoneletters}', ""); +Expect(0, 42751, '\P{^Is_Block: modifiertoneletters}', ""); +Expect(1, 42783, '\p{Is_Block=__modifier Tone_LETTERS}', ""); +Expect(0, 42783, '\p{^Is_Block=__modifier Tone_LETTERS}', ""); +Expect(0, 42783, '\P{Is_Block=__modifier Tone_LETTERS}', ""); +Expect(1, 42783, '\P{^Is_Block=__modifier Tone_LETTERS}', ""); +Expect(0, 42751, '\p{Is_Block=__modifier Tone_LETTERS}', ""); +Expect(1, 42751, '\p{^Is_Block=__modifier Tone_LETTERS}', ""); +Expect(1, 42751, '\P{Is_Block=__modifier Tone_LETTERS}', ""); +Expect(0, 42751, '\P{^Is_Block=__modifier Tone_LETTERS}', ""); +Error('\p{Is_Blk= /a/ModifierToneLETTERS}'); +Error('\P{Is_Blk= /a/ModifierToneLETTERS}'); +Expect(1, 42783, '\p{Is_Blk=modifiertoneletters}', ""); +Expect(0, 42783, '\p{^Is_Blk=modifiertoneletters}', ""); +Expect(0, 42783, '\P{Is_Blk=modifiertoneletters}', ""); +Expect(1, 42783, '\P{^Is_Blk=modifiertoneletters}', ""); +Expect(0, 42751, '\p{Is_Blk=modifiertoneletters}', ""); +Expect(1, 42751, '\p{^Is_Blk=modifiertoneletters}', ""); +Expect(1, 42751, '\P{Is_Blk=modifiertoneletters}', ""); +Expect(0, 42751, '\P{^Is_Blk=modifiertoneletters}', ""); +Expect(1, 42783, '\p{Is_Blk= _Modifier ToneLetters}', ""); +Expect(0, 42783, '\p{^Is_Blk= _Modifier ToneLetters}', ""); +Expect(0, 42783, '\P{Is_Blk= _Modifier ToneLetters}', ""); +Expect(1, 42783, '\P{^Is_Blk= _Modifier ToneLetters}', ""); +Expect(0, 42751, '\p{Is_Blk= _Modifier ToneLetters}', ""); +Expect(1, 42751, '\p{^Is_Blk= _Modifier ToneLetters}', ""); +Expect(1, 42751, '\P{Is_Blk= _Modifier ToneLetters}', ""); +Expect(0, 42751, '\P{^Is_Blk= _Modifier ToneLetters}', ""); +Error('\p{Block: := Ethiopic Supplement}'); +Error('\P{Block: := Ethiopic Supplement}'); +Expect(1, 5023, '\p{Block=ethiopicsupplement}', ""); +Expect(0, 5023, '\p{^Block=ethiopicsupplement}', ""); +Expect(0, 5023, '\P{Block=ethiopicsupplement}', ""); +Expect(1, 5023, '\P{^Block=ethiopicsupplement}', ""); +Expect(0, 4991, '\p{Block=ethiopicsupplement}', ""); +Expect(1, 4991, '\p{^Block=ethiopicsupplement}', ""); +Expect(1, 4991, '\P{Block=ethiopicsupplement}', ""); +Expect(0, 4991, '\P{^Block=ethiopicsupplement}', ""); +Expect(1, 5023, '\p{Block=-Ethiopic_SUPPLEMENT}', ""); +Expect(0, 5023, '\p{^Block=-Ethiopic_SUPPLEMENT}', ""); +Expect(0, 5023, '\P{Block=-Ethiopic_SUPPLEMENT}', ""); +Expect(1, 5023, '\P{^Block=-Ethiopic_SUPPLEMENT}', ""); +Expect(0, 4991, '\p{Block=-Ethiopic_SUPPLEMENT}', ""); +Expect(1, 4991, '\p{^Block=-Ethiopic_SUPPLEMENT}', ""); +Expect(1, 4991, '\P{Block=-Ethiopic_SUPPLEMENT}', ""); +Expect(0, 4991, '\P{^Block=-Ethiopic_SUPPLEMENT}', ""); +Error('\p{Blk=:= -ethiopicsupplement}'); +Error('\P{Blk=:= -ethiopicsupplement}'); +Expect(1, 5023, '\p{Blk=ethiopicsupplement}', ""); +Expect(0, 5023, '\p{^Blk=ethiopicsupplement}', ""); +Expect(0, 5023, '\P{Blk=ethiopicsupplement}', ""); +Expect(1, 5023, '\P{^Blk=ethiopicsupplement}', ""); +Expect(0, 4991, '\p{Blk=ethiopicsupplement}', ""); +Expect(1, 4991, '\p{^Blk=ethiopicsupplement}', ""); +Expect(1, 4991, '\P{Blk=ethiopicsupplement}', ""); +Expect(0, 4991, '\P{^Blk=ethiopicsupplement}', ""); +Expect(1, 5023, '\p{Blk=- EthiopicSupplement}', ""); +Expect(0, 5023, '\p{^Blk=- EthiopicSupplement}', ""); +Expect(0, 5023, '\P{Blk=- EthiopicSupplement}', ""); +Expect(1, 5023, '\P{^Blk=- EthiopicSupplement}', ""); +Expect(0, 4991, '\p{Blk=- EthiopicSupplement}', ""); +Expect(1, 4991, '\p{^Blk=- EthiopicSupplement}', ""); +Expect(1, 4991, '\P{Blk=- EthiopicSupplement}', ""); +Expect(0, 4991, '\P{^Blk=- EthiopicSupplement}', ""); +Error('\p{Is_Block= ethiopic:=supplement}'); +Error('\P{Is_Block= ethiopic:=supplement}'); +Expect(1, 5023, '\p{Is_Block=ethiopicsupplement}', ""); +Expect(0, 5023, '\p{^Is_Block=ethiopicsupplement}', ""); +Expect(0, 5023, '\P{Is_Block=ethiopicsupplement}', ""); +Expect(1, 5023, '\P{^Is_Block=ethiopicsupplement}', ""); +Expect(0, 4991, '\p{Is_Block=ethiopicsupplement}', ""); +Expect(1, 4991, '\p{^Is_Block=ethiopicsupplement}', ""); +Expect(1, 4991, '\P{Is_Block=ethiopicsupplement}', ""); +Expect(0, 4991, '\P{^Is_Block=ethiopicsupplement}', ""); +Expect(1, 5023, '\p{Is_Block=-Ethiopic-SUPPLEMENT}', ""); +Expect(0, 5023, '\p{^Is_Block=-Ethiopic-SUPPLEMENT}', ""); +Expect(0, 5023, '\P{Is_Block=-Ethiopic-SUPPLEMENT}', ""); +Expect(1, 5023, '\P{^Is_Block=-Ethiopic-SUPPLEMENT}', ""); +Expect(0, 4991, '\p{Is_Block=-Ethiopic-SUPPLEMENT}', ""); +Expect(1, 4991, '\p{^Is_Block=-Ethiopic-SUPPLEMENT}', ""); +Expect(1, 4991, '\P{Is_Block=-Ethiopic-SUPPLEMENT}', ""); +Expect(0, 4991, '\P{^Is_Block=-Ethiopic-SUPPLEMENT}', ""); +Error('\p{Is_Blk= EthiopicSupplement:=}'); +Error('\P{Is_Blk= EthiopicSupplement:=}'); +Expect(1, 5023, '\p{Is_Blk=ethiopicsupplement}', ""); +Expect(0, 5023, '\p{^Is_Blk=ethiopicsupplement}', ""); +Expect(0, 5023, '\P{Is_Blk=ethiopicsupplement}', ""); +Expect(1, 5023, '\P{^Is_Blk=ethiopicsupplement}', ""); +Expect(0, 4991, '\p{Is_Blk=ethiopicsupplement}', ""); +Expect(1, 4991, '\p{^Is_Blk=ethiopicsupplement}', ""); +Expect(1, 4991, '\P{Is_Blk=ethiopicsupplement}', ""); +Expect(0, 4991, '\P{^Is_Blk=ethiopicsupplement}', ""); +Expect(1, 5023, '\p{Is_Blk=- ethiopic_SUPPLEMENT}', ""); +Expect(0, 5023, '\p{^Is_Blk=- ethiopic_SUPPLEMENT}', ""); +Expect(0, 5023, '\P{Is_Blk=- ethiopic_SUPPLEMENT}', ""); +Expect(1, 5023, '\P{^Is_Blk=- ethiopic_SUPPLEMENT}', ""); +Expect(0, 4991, '\p{Is_Blk=- ethiopic_SUPPLEMENT}', ""); +Expect(1, 4991, '\p{^Is_Blk=- ethiopic_SUPPLEMENT}', ""); +Expect(1, 4991, '\P{Is_Blk=- ethiopic_SUPPLEMENT}', ""); +Expect(0, 4991, '\P{^Is_Blk=- ethiopic_SUPPLEMENT}', ""); +Error('\p{Block=/a/ _Linearb syllabary}'); +Error('\P{Block=/a/ _Linearb syllabary}'); +Expect(1, 65663, '\p{Block=linearbsyllabary}', ""); +Expect(0, 65663, '\p{^Block=linearbsyllabary}', ""); +Expect(0, 65663, '\P{Block=linearbsyllabary}', ""); +Expect(1, 65663, '\P{^Block=linearbsyllabary}', ""); +Expect(0, 7, '\p{Block=linearbsyllabary}', ""); +Expect(1, 7, '\p{^Block=linearbsyllabary}', ""); +Expect(1, 7, '\P{Block=linearbsyllabary}', ""); +Expect(0, 7, '\P{^Block=linearbsyllabary}', ""); +Expect(1, 65663, '\p{Block=LINEAR bsyllabary}', ""); +Expect(0, 65663, '\p{^Block=LINEAR bsyllabary}', ""); +Expect(0, 65663, '\P{Block=LINEAR bsyllabary}', ""); +Expect(1, 65663, '\P{^Block=LINEAR bsyllabary}', ""); +Expect(0, 7, '\p{Block=LINEAR bsyllabary}', ""); +Expect(1, 7, '\p{^Block=LINEAR bsyllabary}', ""); +Expect(1, 7, '\P{Block=LINEAR bsyllabary}', ""); +Expect(0, 7, '\P{^Block=LINEAR bsyllabary}', ""); +Error('\p{Blk: _/a/Linear B syllabary}'); +Error('\P{Blk: _/a/Linear B syllabary}'); +Expect(1, 65663, '\p{Blk=linearbsyllabary}', ""); +Expect(0, 65663, '\p{^Blk=linearbsyllabary}', ""); +Expect(0, 65663, '\P{Blk=linearbsyllabary}', ""); +Expect(1, 65663, '\P{^Blk=linearbsyllabary}', ""); +Expect(0, 7, '\p{Blk=linearbsyllabary}', ""); +Expect(1, 7, '\p{^Blk=linearbsyllabary}', ""); +Expect(1, 7, '\P{Blk=linearbsyllabary}', ""); +Expect(0, 7, '\P{^Blk=linearbsyllabary}', ""); +Expect(1, 65663, '\p{Blk=_Linear B-Syllabary}', ""); +Expect(0, 65663, '\p{^Blk=_Linear B-Syllabary}', ""); +Expect(0, 65663, '\P{Blk=_Linear B-Syllabary}', ""); +Expect(1, 65663, '\P{^Blk=_Linear B-Syllabary}', ""); +Expect(0, 7, '\p{Blk=_Linear B-Syllabary}', ""); +Expect(1, 7, '\p{^Blk=_Linear B-Syllabary}', ""); +Expect(1, 7, '\P{Blk=_Linear B-Syllabary}', ""); +Expect(0, 7, '\P{^Blk=_Linear B-Syllabary}', ""); +Error('\p{Is_Block= LinearB_syllabary:=}'); +Error('\P{Is_Block= LinearB_syllabary:=}'); +Expect(1, 65663, '\p{Is_Block=linearbsyllabary}', ""); +Expect(0, 65663, '\p{^Is_Block=linearbsyllabary}', ""); +Expect(0, 65663, '\P{Is_Block=linearbsyllabary}', ""); +Expect(1, 65663, '\P{^Is_Block=linearbsyllabary}', ""); +Expect(0, 7, '\p{Is_Block=linearbsyllabary}', ""); +Expect(1, 7, '\p{^Is_Block=linearbsyllabary}', ""); +Expect(1, 7, '\P{Is_Block=linearbsyllabary}', ""); +Expect(0, 7, '\P{^Is_Block=linearbsyllabary}', ""); +Expect(1, 65663, '\p{Is_Block: -LINEAR-B-SYLLABARY}', ""); +Expect(0, 65663, '\p{^Is_Block: -LINEAR-B-SYLLABARY}', ""); +Expect(0, 65663, '\P{Is_Block: -LINEAR-B-SYLLABARY}', ""); +Expect(1, 65663, '\P{^Is_Block: -LINEAR-B-SYLLABARY}', ""); +Expect(0, 7, '\p{Is_Block: -LINEAR-B-SYLLABARY}', ""); +Expect(1, 7, '\p{^Is_Block: -LINEAR-B-SYLLABARY}', ""); +Expect(1, 7, '\P{Is_Block: -LINEAR-B-SYLLABARY}', ""); +Expect(0, 7, '\P{^Is_Block: -LINEAR-B-SYLLABARY}', ""); +Error('\p{Is_Blk= linear b Syllabary/a/}'); +Error('\P{Is_Blk= linear b Syllabary/a/}'); +Expect(1, 65663, '\p{Is_Blk=linearbsyllabary}', ""); +Expect(0, 65663, '\p{^Is_Blk=linearbsyllabary}', ""); +Expect(0, 65663, '\P{Is_Blk=linearbsyllabary}', ""); +Expect(1, 65663, '\P{^Is_Blk=linearbsyllabary}', ""); +Expect(0, 7, '\p{Is_Blk=linearbsyllabary}', ""); +Expect(1, 7, '\p{^Is_Blk=linearbsyllabary}', ""); +Expect(1, 7, '\P{Is_Blk=linearbsyllabary}', ""); +Expect(0, 7, '\P{^Is_Blk=linearbsyllabary}', ""); +Expect(1, 65663, '\p{Is_Blk=Linear-b_syllabary}', ""); +Expect(0, 65663, '\p{^Is_Blk=Linear-b_syllabary}', ""); +Expect(0, 65663, '\P{Is_Blk=Linear-b_syllabary}', ""); +Expect(1, 65663, '\P{^Is_Blk=Linear-b_syllabary}', ""); +Expect(0, 7, '\p{Is_Blk=Linear-b_syllabary}', ""); +Expect(1, 7, '\p{^Is_Blk=Linear-b_syllabary}', ""); +Expect(1, 7, '\P{Is_Blk=Linear-b_syllabary}', ""); +Expect(0, 7, '\P{^Is_Blk=Linear-b_syllabary}', ""); +Error('\p{Block=_:=Enclosed-CJK letters And Months}'); +Error('\P{Block=_:=Enclosed-CJK letters And Months}'); +Expect(1, 13055, '\p{Block=enclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\p{^Block=enclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\P{Block=enclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\P{^Block=enclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\p{Block=enclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\p{^Block=enclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\P{Block=enclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\P{^Block=enclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\p{Block=--EnclosedCJK LETTERS And Months}', ""); +Expect(0, 13055, '\p{^Block=--EnclosedCJK LETTERS And Months}', ""); +Expect(0, 13055, '\P{Block=--EnclosedCJK LETTERS And Months}', ""); +Expect(1, 13055, '\P{^Block=--EnclosedCJK LETTERS And Months}', ""); +Expect(0, 12799, '\p{Block=--EnclosedCJK LETTERS And Months}', ""); +Expect(1, 12799, '\p{^Block=--EnclosedCJK LETTERS And Months}', ""); +Expect(1, 12799, '\P{Block=--EnclosedCJK LETTERS And Months}', ""); +Expect(0, 12799, '\P{^Block=--EnclosedCJK LETTERS And Months}', ""); +Error('\p{Blk=/a/Enclosed-CJK_letters-AndMonths}'); +Error('\P{Blk=/a/Enclosed-CJK_letters-AndMonths}'); +Expect(1, 13055, '\p{Blk=enclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\p{^Blk=enclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\P{Blk=enclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\P{^Blk=enclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\p{Blk=enclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\p{^Blk=enclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\P{Blk=enclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\P{^Blk=enclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\p{Blk: _ enclosed-cjk-LettersAnd MONTHS}', ""); +Expect(0, 13055, '\p{^Blk: _ enclosed-cjk-LettersAnd MONTHS}', ""); +Expect(0, 13055, '\P{Blk: _ enclosed-cjk-LettersAnd MONTHS}', ""); +Expect(1, 13055, '\P{^Blk: _ enclosed-cjk-LettersAnd MONTHS}', ""); +Expect(0, 12799, '\p{Blk: _ enclosed-cjk-LettersAnd MONTHS}', ""); +Expect(1, 12799, '\p{^Blk: _ enclosed-cjk-LettersAnd MONTHS}', ""); +Expect(1, 12799, '\P{Blk: _ enclosed-cjk-LettersAnd MONTHS}', ""); +Expect(0, 12799, '\P{^Blk: _ enclosed-cjk-LettersAnd MONTHS}', ""); +Error('\p{Is_Block=/a/ Enclosed CJK_Letters And_Months}'); +Error('\P{Is_Block=/a/ Enclosed CJK_Letters And_Months}'); +Expect(1, 13055, '\p{Is_Block: enclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\p{^Is_Block: enclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\P{Is_Block: enclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\P{^Is_Block: enclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\p{Is_Block: enclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\p{^Is_Block: enclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\P{Is_Block: enclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\P{^Is_Block: enclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\p{Is_Block=-ENCLOSED cjkLetters-And-Months}', ""); +Expect(0, 13055, '\p{^Is_Block=-ENCLOSED cjkLetters-And-Months}', ""); +Expect(0, 13055, '\P{Is_Block=-ENCLOSED cjkLetters-And-Months}', ""); +Expect(1, 13055, '\P{^Is_Block=-ENCLOSED cjkLetters-And-Months}', ""); +Expect(0, 12799, '\p{Is_Block=-ENCLOSED cjkLetters-And-Months}', ""); +Expect(1, 12799, '\p{^Is_Block=-ENCLOSED cjkLetters-And-Months}', ""); +Expect(1, 12799, '\P{Is_Block=-ENCLOSED cjkLetters-And-Months}', ""); +Expect(0, 12799, '\P{^Is_Block=-ENCLOSED cjkLetters-And-Months}', ""); +Error('\p{Is_Blk=_-Enclosed/a/CJKlettersandMONTHS}'); +Error('\P{Is_Blk=_-Enclosed/a/CJKlettersandMONTHS}'); +Expect(1, 13055, '\p{Is_Blk=enclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\p{^Is_Blk=enclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\P{Is_Blk=enclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\P{^Is_Blk=enclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\p{Is_Blk=enclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\p{^Is_Blk=enclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\P{Is_Blk=enclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\P{^Is_Blk=enclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\p{Is_Blk= enclosed_CJK letters_and_MONTHS}', ""); +Expect(0, 13055, '\p{^Is_Blk= enclosed_CJK letters_and_MONTHS}', ""); +Expect(0, 13055, '\P{Is_Blk= enclosed_CJK letters_and_MONTHS}', ""); +Expect(1, 13055, '\P{^Is_Blk= enclosed_CJK letters_and_MONTHS}', ""); +Expect(0, 12799, '\p{Is_Blk= enclosed_CJK letters_and_MONTHS}', ""); +Expect(1, 12799, '\p{^Is_Blk= enclosed_CJK letters_and_MONTHS}', ""); +Expect(1, 12799, '\P{Is_Blk= enclosed_CJK letters_and_MONTHS}', ""); +Expect(0, 12799, '\P{^Is_Blk= enclosed_CJK letters_and_MONTHS}', ""); +Error('\p{Block= :=Combining diacritical-MARKSSUPPLEMENT}'); +Error('\P{Block= :=Combining diacritical-MARKSSUPPLEMENT}'); +Expect(1, 7679, '\p{Block=combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\p{^Block=combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\P{Block=combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\P{^Block=combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\p{Block=combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\p{^Block=combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\P{Block=combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\P{^Block=combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\p{Block=_-COMBINING-Diacritical_marks-supplement}', ""); +Expect(0, 7679, '\p{^Block=_-COMBINING-Diacritical_marks-supplement}', ""); +Expect(0, 7679, '\P{Block=_-COMBINING-Diacritical_marks-supplement}', ""); +Expect(1, 7679, '\P{^Block=_-COMBINING-Diacritical_marks-supplement}', ""); +Expect(0, 7615, '\p{Block=_-COMBINING-Diacritical_marks-supplement}', ""); +Expect(1, 7615, '\p{^Block=_-COMBINING-Diacritical_marks-supplement}', ""); +Expect(1, 7615, '\P{Block=_-COMBINING-Diacritical_marks-supplement}', ""); +Expect(0, 7615, '\P{^Block=_-COMBINING-Diacritical_marks-supplement}', ""); +Error('\p{Blk= COMBINING Diacritical Marks/a/Supplement}'); +Error('\P{Blk= COMBINING Diacritical Marks/a/Supplement}'); +Expect(1, 7679, '\p{Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\p{^Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\P{Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\P{^Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\p{Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\p{^Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\P{Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\P{^Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\p{Blk= combining_Diacriticalmarks-supplement}', ""); +Expect(0, 7679, '\p{^Blk= combining_Diacriticalmarks-supplement}', ""); +Expect(0, 7679, '\P{Blk= combining_Diacriticalmarks-supplement}', ""); +Expect(1, 7679, '\P{^Blk= combining_Diacriticalmarks-supplement}', ""); +Expect(0, 7615, '\p{Blk= combining_Diacriticalmarks-supplement}', ""); +Expect(1, 7615, '\p{^Blk= combining_Diacriticalmarks-supplement}', ""); +Expect(1, 7615, '\P{Blk= combining_Diacriticalmarks-supplement}', ""); +Expect(0, 7615, '\P{^Blk= combining_Diacriticalmarks-supplement}', ""); +Error('\p{Is_Block=/a/--combining Diacritical-MARKS-supplement}'); +Error('\P{Is_Block=/a/--combining Diacritical-MARKS-supplement}'); +Expect(1, 7679, '\p{Is_Block:combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\p{^Is_Block:combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\P{Is_Block:combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\P{^Is_Block:combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\p{Is_Block:combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\p{^Is_Block:combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\P{Is_Block:combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\P{^Is_Block:combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\p{Is_Block= -Combining DIACRITICAL marks-Supplement}', ""); +Expect(0, 7679, '\p{^Is_Block= -Combining DIACRITICAL marks-Supplement}', ""); +Expect(0, 7679, '\P{Is_Block= -Combining DIACRITICAL marks-Supplement}', ""); +Expect(1, 7679, '\P{^Is_Block= -Combining DIACRITICAL marks-Supplement}', ""); +Expect(0, 7615, '\p{Is_Block= -Combining DIACRITICAL marks-Supplement}', ""); +Expect(1, 7615, '\p{^Is_Block= -Combining DIACRITICAL marks-Supplement}', ""); +Expect(1, 7615, '\P{Is_Block= -Combining DIACRITICAL marks-Supplement}', ""); +Expect(0, 7615, '\P{^Is_Block= -Combining DIACRITICAL marks-Supplement}', ""); +Error('\p{Is_Blk=_COMBINING:=Diacritical marks supplement}'); +Error('\P{Is_Blk=_COMBINING:=Diacritical marks supplement}'); +Expect(1, 7679, '\p{Is_Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\p{^Is_Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\P{Is_Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\P{^Is_Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\p{Is_Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\p{^Is_Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\P{Is_Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\P{^Is_Blk=combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\p{Is_Blk=Combining_DIACRITICAL MARKS-Supplement}', ""); +Expect(0, 7679, '\p{^Is_Blk=Combining_DIACRITICAL MARKS-Supplement}', ""); +Expect(0, 7679, '\P{Is_Blk=Combining_DIACRITICAL MARKS-Supplement}', ""); +Expect(1, 7679, '\P{^Is_Blk=Combining_DIACRITICAL MARKS-Supplement}', ""); +Expect(0, 7615, '\p{Is_Blk=Combining_DIACRITICAL MARKS-Supplement}', ""); +Expect(1, 7615, '\p{^Is_Blk=Combining_DIACRITICAL MARKS-Supplement}', ""); +Expect(1, 7615, '\P{Is_Blk=Combining_DIACRITICAL MARKS-Supplement}', ""); +Expect(0, 7615, '\P{^Is_Blk=Combining_DIACRITICAL MARKS-Supplement}', ""); +Error('\p{Block=_Bopomofo/a/}'); +Error('\P{Block=_Bopomofo/a/}'); +Expect(1, 12591, '\p{Block=bopomofo}', ""); +Expect(0, 12591, '\p{^Block=bopomofo}', ""); +Expect(0, 12591, '\P{Block=bopomofo}', ""); +Expect(1, 12591, '\P{^Block=bopomofo}', ""); +Expect(0, 12543, '\p{Block=bopomofo}', ""); +Expect(1, 12543, '\p{^Block=bopomofo}', ""); +Expect(1, 12543, '\P{Block=bopomofo}', ""); +Expect(0, 12543, '\P{^Block=bopomofo}', ""); +Expect(1, 12591, '\p{Block=-BOPOMOFO}', ""); +Expect(0, 12591, '\p{^Block=-BOPOMOFO}', ""); +Expect(0, 12591, '\P{Block=-BOPOMOFO}', ""); +Expect(1, 12591, '\P{^Block=-BOPOMOFO}', ""); +Expect(0, 12543, '\p{Block=-BOPOMOFO}', ""); +Expect(1, 12543, '\p{^Block=-BOPOMOFO}', ""); +Expect(1, 12543, '\P{Block=-BOPOMOFO}', ""); +Expect(0, 12543, '\P{^Block=-BOPOMOFO}', ""); +Error('\p{Blk=BOPOMOFO:=}'); +Error('\P{Blk=BOPOMOFO:=}'); +Expect(1, 12591, '\p{Blk=bopomofo}', ""); +Expect(0, 12591, '\p{^Blk=bopomofo}', ""); +Expect(0, 12591, '\P{Blk=bopomofo}', ""); +Expect(1, 12591, '\P{^Blk=bopomofo}', ""); +Expect(0, 12543, '\p{Blk=bopomofo}', ""); +Expect(1, 12543, '\p{^Blk=bopomofo}', ""); +Expect(1, 12543, '\P{Blk=bopomofo}', ""); +Expect(0, 12543, '\P{^Blk=bopomofo}', ""); +Expect(1, 12591, '\p{Blk= bopomofo}', ""); +Expect(0, 12591, '\p{^Blk= bopomofo}', ""); +Expect(0, 12591, '\P{Blk= bopomofo}', ""); +Expect(1, 12591, '\P{^Blk= bopomofo}', ""); +Expect(0, 12543, '\p{Blk= bopomofo}', ""); +Expect(1, 12543, '\p{^Blk= bopomofo}', ""); +Expect(1, 12543, '\P{Blk= bopomofo}', ""); +Expect(0, 12543, '\P{^Blk= bopomofo}', ""); +Error('\p{Is_Block= Bopomofo:=}'); +Error('\P{Is_Block= Bopomofo:=}'); +Expect(1, 12591, '\p{Is_Block:bopomofo}', ""); +Expect(0, 12591, '\p{^Is_Block:bopomofo}', ""); +Expect(0, 12591, '\P{Is_Block:bopomofo}', ""); +Expect(1, 12591, '\P{^Is_Block:bopomofo}', ""); +Expect(0, 12543, '\p{Is_Block:bopomofo}', ""); +Expect(1, 12543, '\p{^Is_Block:bopomofo}', ""); +Expect(1, 12543, '\P{Is_Block:bopomofo}', ""); +Expect(0, 12543, '\P{^Is_Block:bopomofo}', ""); +Expect(1, 12591, '\p{Is_Block= _BOPOMOFO}', ""); +Expect(0, 12591, '\p{^Is_Block= _BOPOMOFO}', ""); +Expect(0, 12591, '\P{Is_Block= _BOPOMOFO}', ""); +Expect(1, 12591, '\P{^Is_Block= _BOPOMOFO}', ""); +Expect(0, 12543, '\p{Is_Block= _BOPOMOFO}', ""); +Expect(1, 12543, '\p{^Is_Block= _BOPOMOFO}', ""); +Expect(1, 12543, '\P{Is_Block= _BOPOMOFO}', ""); +Expect(0, 12543, '\P{^Is_Block= _BOPOMOFO}', ""); +Error('\p{Is_Blk=_BOPOMOFO/a/}'); +Error('\P{Is_Blk=_BOPOMOFO/a/}'); +Expect(1, 12591, '\p{Is_Blk=bopomofo}', ""); +Expect(0, 12591, '\p{^Is_Blk=bopomofo}', ""); +Expect(0, 12591, '\P{Is_Blk=bopomofo}', ""); +Expect(1, 12591, '\P{^Is_Blk=bopomofo}', ""); +Expect(0, 12543, '\p{Is_Blk=bopomofo}', ""); +Expect(1, 12543, '\p{^Is_Blk=bopomofo}', ""); +Expect(1, 12543, '\P{Is_Blk=bopomofo}', ""); +Expect(0, 12543, '\P{^Is_Blk=bopomofo}', ""); +Expect(1, 12591, '\p{Is_Blk=--bopomofo}', ""); +Expect(0, 12591, '\p{^Is_Blk=--bopomofo}', ""); +Expect(0, 12591, '\P{Is_Blk=--bopomofo}', ""); +Expect(1, 12591, '\P{^Is_Blk=--bopomofo}', ""); +Expect(0, 12543, '\p{Is_Blk=--bopomofo}', ""); +Expect(1, 12543, '\p{^Is_Blk=--bopomofo}', ""); +Expect(1, 12543, '\P{Is_Blk=--bopomofo}', ""); +Expect(0, 12543, '\P{^Is_Blk=--bopomofo}', ""); +Error('\p{Block: Miscellaneous Technical:=}'); +Error('\P{Block: Miscellaneous Technical:=}'); +Expect(1, 9215, '\p{Block=miscellaneoustechnical}', ""); +Expect(0, 9215, '\p{^Block=miscellaneoustechnical}', ""); +Expect(0, 9215, '\P{Block=miscellaneoustechnical}', ""); +Expect(1, 9215, '\P{^Block=miscellaneoustechnical}', ""); +Expect(0, 8959, '\p{Block=miscellaneoustechnical}', ""); +Expect(1, 8959, '\p{^Block=miscellaneoustechnical}', ""); +Expect(1, 8959, '\P{Block=miscellaneoustechnical}', ""); +Expect(0, 8959, '\P{^Block=miscellaneoustechnical}', ""); +Expect(1, 9215, '\p{Block: _-MISCELLANEOUS-Technical}', ""); +Expect(0, 9215, '\p{^Block: _-MISCELLANEOUS-Technical}', ""); +Expect(0, 9215, '\P{Block: _-MISCELLANEOUS-Technical}', ""); +Expect(1, 9215, '\P{^Block: _-MISCELLANEOUS-Technical}', ""); +Expect(0, 8959, '\p{Block: _-MISCELLANEOUS-Technical}', ""); +Expect(1, 8959, '\p{^Block: _-MISCELLANEOUS-Technical}', ""); +Expect(1, 8959, '\P{Block: _-MISCELLANEOUS-Technical}', ""); +Expect(0, 8959, '\P{^Block: _-MISCELLANEOUS-Technical}', ""); +Error('\p{Blk= _miscellaneous/a/Technical}'); +Error('\P{Blk= _miscellaneous/a/Technical}'); +Expect(1, 9215, '\p{Blk=miscellaneoustechnical}', ""); +Expect(0, 9215, '\p{^Blk=miscellaneoustechnical}', ""); +Expect(0, 9215, '\P{Blk=miscellaneoustechnical}', ""); +Expect(1, 9215, '\P{^Blk=miscellaneoustechnical}', ""); +Expect(0, 8959, '\p{Blk=miscellaneoustechnical}', ""); +Expect(1, 8959, '\p{^Blk=miscellaneoustechnical}', ""); +Expect(1, 8959, '\P{Blk=miscellaneoustechnical}', ""); +Expect(0, 8959, '\P{^Blk=miscellaneoustechnical}', ""); +Expect(1, 9215, '\p{Blk=_ MISCELLANEOUS technical}', ""); +Expect(0, 9215, '\p{^Blk=_ MISCELLANEOUS technical}', ""); +Expect(0, 9215, '\P{Blk=_ MISCELLANEOUS technical}', ""); +Expect(1, 9215, '\P{^Blk=_ MISCELLANEOUS technical}', ""); +Expect(0, 8959, '\p{Blk=_ MISCELLANEOUS technical}', ""); +Expect(1, 8959, '\p{^Blk=_ MISCELLANEOUS technical}', ""); +Expect(1, 8959, '\P{Blk=_ MISCELLANEOUS technical}', ""); +Expect(0, 8959, '\P{^Blk=_ MISCELLANEOUS technical}', ""); +Error('\p{Is_Block=:= _Miscellaneous-Technical}'); +Error('\P{Is_Block=:= _Miscellaneous-Technical}'); +Expect(1, 9215, '\p{Is_Block=miscellaneoustechnical}', ""); +Expect(0, 9215, '\p{^Is_Block=miscellaneoustechnical}', ""); +Expect(0, 9215, '\P{Is_Block=miscellaneoustechnical}', ""); +Expect(1, 9215, '\P{^Is_Block=miscellaneoustechnical}', ""); +Expect(0, 8959, '\p{Is_Block=miscellaneoustechnical}', ""); +Expect(1, 8959, '\p{^Is_Block=miscellaneoustechnical}', ""); +Expect(1, 8959, '\P{Is_Block=miscellaneoustechnical}', ""); +Expect(0, 8959, '\P{^Is_Block=miscellaneoustechnical}', ""); +Expect(1, 9215, '\p{Is_Block= miscellaneous TECHNICAL}', ""); +Expect(0, 9215, '\p{^Is_Block= miscellaneous TECHNICAL}', ""); +Expect(0, 9215, '\P{Is_Block= miscellaneous TECHNICAL}', ""); +Expect(1, 9215, '\P{^Is_Block= miscellaneous TECHNICAL}', ""); +Expect(0, 8959, '\p{Is_Block= miscellaneous TECHNICAL}', ""); +Expect(1, 8959, '\p{^Is_Block= miscellaneous TECHNICAL}', ""); +Expect(1, 8959, '\P{Is_Block= miscellaneous TECHNICAL}', ""); +Expect(0, 8959, '\P{^Is_Block= miscellaneous TECHNICAL}', ""); +Error('\p{Is_Blk=/a/miscellaneous_technical}'); +Error('\P{Is_Blk=/a/miscellaneous_technical}'); +Expect(1, 9215, '\p{Is_Blk=miscellaneoustechnical}', ""); +Expect(0, 9215, '\p{^Is_Blk=miscellaneoustechnical}', ""); +Expect(0, 9215, '\P{Is_Blk=miscellaneoustechnical}', ""); +Expect(1, 9215, '\P{^Is_Blk=miscellaneoustechnical}', ""); +Expect(0, 8959, '\p{Is_Blk=miscellaneoustechnical}', ""); +Expect(1, 8959, '\p{^Is_Blk=miscellaneoustechnical}', ""); +Expect(1, 8959, '\P{Is_Blk=miscellaneoustechnical}', ""); +Expect(0, 8959, '\P{^Is_Blk=miscellaneoustechnical}', ""); +Expect(1, 9215, '\p{Is_Blk=- MISCELLANEOUS TECHNICAL}', ""); +Expect(0, 9215, '\p{^Is_Blk=- MISCELLANEOUS TECHNICAL}', ""); +Expect(0, 9215, '\P{Is_Blk=- MISCELLANEOUS TECHNICAL}', ""); +Expect(1, 9215, '\P{^Is_Blk=- MISCELLANEOUS TECHNICAL}', ""); +Expect(0, 8959, '\p{Is_Blk=- MISCELLANEOUS TECHNICAL}', ""); +Expect(1, 8959, '\p{^Is_Blk=- MISCELLANEOUS TECHNICAL}', ""); +Expect(1, 8959, '\P{Is_Blk=- MISCELLANEOUS TECHNICAL}', ""); +Expect(0, 8959, '\P{^Is_Blk=- MISCELLANEOUS TECHNICAL}', ""); +Error('\p{Block=/a/__Osmanya}'); +Error('\P{Block=/a/__Osmanya}'); +Expect(1, 66735, '\p{Block=osmanya}', ""); +Expect(0, 66735, '\p{^Block=osmanya}', ""); +Expect(0, 66735, '\P{Block=osmanya}', ""); +Expect(1, 66735, '\P{^Block=osmanya}', ""); +Expect(0, 66687, '\p{Block=osmanya}', ""); +Expect(1, 66687, '\p{^Block=osmanya}', ""); +Expect(1, 66687, '\P{Block=osmanya}', ""); +Expect(0, 66687, '\P{^Block=osmanya}', ""); +Expect(1, 66735, '\p{Block=_Osmanya}', ""); +Expect(0, 66735, '\p{^Block=_Osmanya}', ""); +Expect(0, 66735, '\P{Block=_Osmanya}', ""); +Expect(1, 66735, '\P{^Block=_Osmanya}', ""); +Expect(0, 66687, '\p{Block=_Osmanya}', ""); +Expect(1, 66687, '\p{^Block=_Osmanya}', ""); +Expect(1, 66687, '\P{Block=_Osmanya}', ""); +Expect(0, 66687, '\P{^Block=_Osmanya}', ""); +Error('\p{Blk: osmanya/a/}'); +Error('\P{Blk: osmanya/a/}'); +Expect(1, 66735, '\p{Blk=osmanya}', ""); +Expect(0, 66735, '\p{^Blk=osmanya}', ""); +Expect(0, 66735, '\P{Blk=osmanya}', ""); +Expect(1, 66735, '\P{^Blk=osmanya}', ""); +Expect(0, 66687, '\p{Blk=osmanya}', ""); +Expect(1, 66687, '\p{^Blk=osmanya}', ""); +Expect(1, 66687, '\P{Blk=osmanya}', ""); +Expect(0, 66687, '\P{^Blk=osmanya}', ""); +Expect(1, 66735, '\p{Blk= _OSMANYA}', ""); +Expect(0, 66735, '\p{^Blk= _OSMANYA}', ""); +Expect(0, 66735, '\P{Blk= _OSMANYA}', ""); +Expect(1, 66735, '\P{^Blk= _OSMANYA}', ""); +Expect(0, 66687, '\p{Blk= _OSMANYA}', ""); +Expect(1, 66687, '\p{^Blk= _OSMANYA}', ""); +Expect(1, 66687, '\P{Blk= _OSMANYA}', ""); +Expect(0, 66687, '\P{^Blk= _OSMANYA}', ""); +Error('\p{Is_Block= -Osmanya:=}'); +Error('\P{Is_Block= -Osmanya:=}'); +Expect(1, 66735, '\p{Is_Block=osmanya}', ""); +Expect(0, 66735, '\p{^Is_Block=osmanya}', ""); +Expect(0, 66735, '\P{Is_Block=osmanya}', ""); +Expect(1, 66735, '\P{^Is_Block=osmanya}', ""); +Expect(0, 66687, '\p{Is_Block=osmanya}', ""); +Expect(1, 66687, '\p{^Is_Block=osmanya}', ""); +Expect(1, 66687, '\P{Is_Block=osmanya}', ""); +Expect(0, 66687, '\P{^Is_Block=osmanya}', ""); +Expect(1, 66735, '\p{Is_Block=_ Osmanya}', ""); +Expect(0, 66735, '\p{^Is_Block=_ Osmanya}', ""); +Expect(0, 66735, '\P{Is_Block=_ Osmanya}', ""); +Expect(1, 66735, '\P{^Is_Block=_ Osmanya}', ""); +Expect(0, 66687, '\p{Is_Block=_ Osmanya}', ""); +Expect(1, 66687, '\p{^Is_Block=_ Osmanya}', ""); +Expect(1, 66687, '\P{Is_Block=_ Osmanya}', ""); +Expect(0, 66687, '\P{^Is_Block=_ Osmanya}', ""); +Error('\p{Is_Blk= :=osmanya}'); +Error('\P{Is_Blk= :=osmanya}'); +Expect(1, 66735, '\p{Is_Blk=osmanya}', ""); +Expect(0, 66735, '\p{^Is_Blk=osmanya}', ""); +Expect(0, 66735, '\P{Is_Blk=osmanya}', ""); +Expect(1, 66735, '\P{^Is_Blk=osmanya}', ""); +Expect(0, 66687, '\p{Is_Blk=osmanya}', ""); +Expect(1, 66687, '\p{^Is_Blk=osmanya}', ""); +Expect(1, 66687, '\P{Is_Blk=osmanya}', ""); +Expect(0, 66687, '\P{^Is_Blk=osmanya}', ""); +Expect(1, 66735, '\p{Is_Blk=__Osmanya}', ""); +Expect(0, 66735, '\p{^Is_Blk=__Osmanya}', ""); +Expect(0, 66735, '\P{Is_Blk=__Osmanya}', ""); +Expect(1, 66735, '\P{^Is_Blk=__Osmanya}', ""); +Expect(0, 66687, '\p{Is_Blk=__Osmanya}', ""); +Expect(1, 66687, '\p{^Is_Blk=__Osmanya}', ""); +Expect(1, 66687, '\P{Is_Blk=__Osmanya}', ""); +Expect(0, 66687, '\P{^Is_Blk=__Osmanya}', ""); +Error('\p{Block= _Mahjong_Tiles/a/}'); +Error('\P{Block= _Mahjong_Tiles/a/}'); +Expect(1, 127023, '\p{Block=mahjongtiles}', ""); +Expect(0, 127023, '\p{^Block=mahjongtiles}', ""); +Expect(0, 127023, '\P{Block=mahjongtiles}', ""); +Expect(1, 127023, '\P{^Block=mahjongtiles}', ""); +Expect(0, 126975, '\p{Block=mahjongtiles}', ""); +Expect(1, 126975, '\p{^Block=mahjongtiles}', ""); +Expect(1, 126975, '\P{Block=mahjongtiles}', ""); +Expect(0, 126975, '\P{^Block=mahjongtiles}', ""); +Expect(1, 127023, '\p{Block= mahjong TILES}', ""); +Expect(0, 127023, '\p{^Block= mahjong TILES}', ""); +Expect(0, 127023, '\P{Block= mahjong TILES}', ""); +Expect(1, 127023, '\P{^Block= mahjong TILES}', ""); +Expect(0, 126975, '\p{Block= mahjong TILES}', ""); +Expect(1, 126975, '\p{^Block= mahjong TILES}', ""); +Expect(1, 126975, '\P{Block= mahjong TILES}', ""); +Expect(0, 126975, '\P{^Block= mahjong TILES}', ""); +Error('\p{Blk= :=MAHJONG Tiles}'); +Error('\P{Blk= :=MAHJONG Tiles}'); +Expect(1, 127023, '\p{Blk=mahjongtiles}', ""); +Expect(0, 127023, '\p{^Blk=mahjongtiles}', ""); +Expect(0, 127023, '\P{Blk=mahjongtiles}', ""); +Expect(1, 127023, '\P{^Blk=mahjongtiles}', ""); +Expect(0, 126975, '\p{Blk=mahjongtiles}', ""); +Expect(1, 126975, '\p{^Blk=mahjongtiles}', ""); +Expect(1, 126975, '\P{Blk=mahjongtiles}', ""); +Expect(0, 126975, '\P{^Blk=mahjongtiles}', ""); +Expect(1, 127023, '\p{Blk=_ MAHJONG-Tiles}', ""); +Expect(0, 127023, '\p{^Blk=_ MAHJONG-Tiles}', ""); +Expect(0, 127023, '\P{Blk=_ MAHJONG-Tiles}', ""); +Expect(1, 127023, '\P{^Blk=_ MAHJONG-Tiles}', ""); +Expect(0, 126975, '\p{Blk=_ MAHJONG-Tiles}', ""); +Expect(1, 126975, '\p{^Blk=_ MAHJONG-Tiles}', ""); +Expect(1, 126975, '\P{Blk=_ MAHJONG-Tiles}', ""); +Expect(0, 126975, '\P{^Blk=_ MAHJONG-Tiles}', ""); +Error('\p{Is_Block= :=Mahjong Tiles}'); +Error('\P{Is_Block= :=Mahjong Tiles}'); +Expect(1, 127023, '\p{Is_Block: mahjongtiles}', ""); +Expect(0, 127023, '\p{^Is_Block: mahjongtiles}', ""); +Expect(0, 127023, '\P{Is_Block: mahjongtiles}', ""); +Expect(1, 127023, '\P{^Is_Block: mahjongtiles}', ""); +Expect(0, 126975, '\p{Is_Block: mahjongtiles}', ""); +Expect(1, 126975, '\p{^Is_Block: mahjongtiles}', ""); +Expect(1, 126975, '\P{Is_Block: mahjongtiles}', ""); +Expect(0, 126975, '\P{^Is_Block: mahjongtiles}', ""); +Expect(1, 127023, '\p{Is_Block: MAHJONGTiles}', ""); +Expect(0, 127023, '\p{^Is_Block: MAHJONGTiles}', ""); +Expect(0, 127023, '\P{Is_Block: MAHJONGTiles}', ""); +Expect(1, 127023, '\P{^Is_Block: MAHJONGTiles}', ""); +Expect(0, 126975, '\p{Is_Block: MAHJONGTiles}', ""); +Expect(1, 126975, '\p{^Is_Block: MAHJONGTiles}', ""); +Expect(1, 126975, '\P{Is_Block: MAHJONGTiles}', ""); +Expect(0, 126975, '\P{^Is_Block: MAHJONGTiles}', ""); +Error('\p{Is_Blk=-Mahjong Tiles/a/}'); +Error('\P{Is_Blk=-Mahjong Tiles/a/}'); +Expect(1, 127023, '\p{Is_Blk: mahjongtiles}', ""); +Expect(0, 127023, '\p{^Is_Blk: mahjongtiles}', ""); +Expect(0, 127023, '\P{Is_Blk: mahjongtiles}', ""); +Expect(1, 127023, '\P{^Is_Blk: mahjongtiles}', ""); +Expect(0, 126975, '\p{Is_Blk: mahjongtiles}', ""); +Expect(1, 126975, '\p{^Is_Blk: mahjongtiles}', ""); +Expect(1, 126975, '\P{Is_Blk: mahjongtiles}', ""); +Expect(0, 126975, '\P{^Is_Blk: mahjongtiles}', ""); +Expect(1, 127023, '\p{Is_Blk= _MAHJONG-Tiles}', ""); +Expect(0, 127023, '\p{^Is_Blk= _MAHJONG-Tiles}', ""); +Expect(0, 127023, '\P{Is_Blk= _MAHJONG-Tiles}', ""); +Expect(1, 127023, '\P{^Is_Blk= _MAHJONG-Tiles}', ""); +Expect(0, 126975, '\p{Is_Blk= _MAHJONG-Tiles}', ""); +Expect(1, 126975, '\p{^Is_Blk= _MAHJONG-Tiles}', ""); +Expect(1, 126975, '\P{Is_Blk= _MAHJONG-Tiles}', ""); +Expect(0, 126975, '\P{^Is_Blk= _MAHJONG-Tiles}', ""); +Error('\p{Block=:=-_Arrows}'); +Error('\P{Block=:=-_Arrows}'); +Expect(1, 8703, '\p{Block=arrows}', ""); +Expect(0, 8703, '\p{^Block=arrows}', ""); +Expect(0, 8703, '\P{Block=arrows}', ""); +Expect(1, 8703, '\P{^Block=arrows}', ""); +Expect(0, 8591, '\p{Block=arrows}', ""); +Expect(1, 8591, '\p{^Block=arrows}', ""); +Expect(1, 8591, '\P{Block=arrows}', ""); +Expect(0, 8591, '\P{^Block=arrows}', ""); +Expect(1, 8703, '\p{Block= ARROWS}', ""); +Expect(0, 8703, '\p{^Block= ARROWS}', ""); +Expect(0, 8703, '\P{Block= ARROWS}', ""); +Expect(1, 8703, '\P{^Block= ARROWS}', ""); +Expect(0, 8591, '\p{Block= ARROWS}', ""); +Expect(1, 8591, '\p{^Block= ARROWS}', ""); +Expect(1, 8591, '\P{Block= ARROWS}', ""); +Expect(0, 8591, '\P{^Block= ARROWS}', ""); +Error('\p{Blk=/a/_Arrows}'); +Error('\P{Blk=/a/_Arrows}'); +Expect(1, 8703, '\p{Blk=arrows}', ""); +Expect(0, 8703, '\p{^Blk=arrows}', ""); +Expect(0, 8703, '\P{Blk=arrows}', ""); +Expect(1, 8703, '\P{^Blk=arrows}', ""); +Expect(0, 8591, '\p{Blk=arrows}', ""); +Expect(1, 8591, '\p{^Blk=arrows}', ""); +Expect(1, 8591, '\P{Blk=arrows}', ""); +Expect(0, 8591, '\P{^Blk=arrows}', ""); +Expect(1, 8703, '\p{Blk=_ Arrows}', ""); +Expect(0, 8703, '\p{^Blk=_ Arrows}', ""); +Expect(0, 8703, '\P{Blk=_ Arrows}', ""); +Expect(1, 8703, '\P{^Blk=_ Arrows}', ""); +Expect(0, 8591, '\p{Blk=_ Arrows}', ""); +Expect(1, 8591, '\p{^Blk=_ Arrows}', ""); +Expect(1, 8591, '\P{Blk=_ Arrows}', ""); +Expect(0, 8591, '\P{^Blk=_ Arrows}', ""); +Error('\p{Is_Block=_ Arrows/a/}'); +Error('\P{Is_Block=_ Arrows/a/}'); +Expect(1, 8703, '\p{Is_Block=arrows}', ""); +Expect(0, 8703, '\p{^Is_Block=arrows}', ""); +Expect(0, 8703, '\P{Is_Block=arrows}', ""); +Expect(1, 8703, '\P{^Is_Block=arrows}', ""); +Expect(0, 8591, '\p{Is_Block=arrows}', ""); +Expect(1, 8591, '\p{^Is_Block=arrows}', ""); +Expect(1, 8591, '\P{Is_Block=arrows}', ""); +Expect(0, 8591, '\P{^Is_Block=arrows}', ""); +Expect(1, 8703, '\p{Is_Block: Arrows}', ""); +Expect(0, 8703, '\p{^Is_Block: Arrows}', ""); +Expect(0, 8703, '\P{Is_Block: Arrows}', ""); +Expect(1, 8703, '\P{^Is_Block: Arrows}', ""); +Expect(0, 8591, '\p{Is_Block: Arrows}', ""); +Expect(1, 8591, '\p{^Is_Block: Arrows}', ""); +Expect(1, 8591, '\P{Is_Block: Arrows}', ""); +Expect(0, 8591, '\P{^Is_Block: Arrows}', ""); +Error('\p{Is_Blk= :=Arrows}'); +Error('\P{Is_Blk= :=Arrows}'); +Expect(1, 8703, '\p{Is_Blk=arrows}', ""); +Expect(0, 8703, '\p{^Is_Blk=arrows}', ""); +Expect(0, 8703, '\P{Is_Blk=arrows}', ""); +Expect(1, 8703, '\P{^Is_Blk=arrows}', ""); +Expect(0, 8591, '\p{Is_Blk=arrows}', ""); +Expect(1, 8591, '\p{^Is_Blk=arrows}', ""); +Expect(1, 8591, '\P{Is_Blk=arrows}', ""); +Expect(0, 8591, '\P{^Is_Blk=arrows}', ""); +Expect(1, 8703, '\p{Is_Blk= -Arrows}', ""); +Expect(0, 8703, '\p{^Is_Blk= -Arrows}', ""); +Expect(0, 8703, '\P{Is_Blk= -Arrows}', ""); +Expect(1, 8703, '\P{^Is_Blk= -Arrows}', ""); +Expect(0, 8591, '\p{Is_Blk= -Arrows}', ""); +Expect(1, 8591, '\p{^Is_Blk= -Arrows}', ""); +Expect(1, 8591, '\P{Is_Blk= -Arrows}', ""); +Expect(0, 8591, '\P{^Is_Blk= -Arrows}', ""); +Error('\p{Block=Block Elements/a/}'); +Error('\P{Block=Block Elements/a/}'); +Expect(1, 9631, '\p{Block=blockelements}', ""); +Expect(0, 9631, '\p{^Block=blockelements}', ""); +Expect(0, 9631, '\P{Block=blockelements}', ""); +Expect(1, 9631, '\P{^Block=blockelements}', ""); +Expect(0, 9599, '\p{Block=blockelements}', ""); +Expect(1, 9599, '\p{^Block=blockelements}', ""); +Expect(1, 9599, '\P{Block=blockelements}', ""); +Expect(0, 9599, '\P{^Block=blockelements}', ""); +Expect(1, 9631, '\p{Block: _-block_Elements}', ""); +Expect(0, 9631, '\p{^Block: _-block_Elements}', ""); +Expect(0, 9631, '\P{Block: _-block_Elements}', ""); +Expect(1, 9631, '\P{^Block: _-block_Elements}', ""); +Expect(0, 9599, '\p{Block: _-block_Elements}', ""); +Expect(1, 9599, '\p{^Block: _-block_Elements}', ""); +Expect(1, 9599, '\P{Block: _-block_Elements}', ""); +Expect(0, 9599, '\P{^Block: _-block_Elements}', ""); +Error('\p{Blk=/a/BLOCK_ELEMENTS}'); +Error('\P{Blk=/a/BLOCK_ELEMENTS}'); +Expect(1, 9631, '\p{Blk=blockelements}', ""); +Expect(0, 9631, '\p{^Blk=blockelements}', ""); +Expect(0, 9631, '\P{Blk=blockelements}', ""); +Expect(1, 9631, '\P{^Blk=blockelements}', ""); +Expect(0, 9599, '\p{Blk=blockelements}', ""); +Expect(1, 9599, '\p{^Blk=blockelements}', ""); +Expect(1, 9599, '\P{Blk=blockelements}', ""); +Expect(0, 9599, '\P{^Blk=blockelements}', ""); +Expect(1, 9631, '\p{Blk= BlockELEMENTS}', ""); +Expect(0, 9631, '\p{^Blk= BlockELEMENTS}', ""); +Expect(0, 9631, '\P{Blk= BlockELEMENTS}', ""); +Expect(1, 9631, '\P{^Blk= BlockELEMENTS}', ""); +Expect(0, 9599, '\p{Blk= BlockELEMENTS}', ""); +Expect(1, 9599, '\p{^Blk= BlockELEMENTS}', ""); +Expect(1, 9599, '\P{Blk= BlockELEMENTS}', ""); +Expect(0, 9599, '\P{^Blk= BlockELEMENTS}', ""); +Error('\p{Is_Block=-block ELEMENTS/a/}'); +Error('\P{Is_Block=-block ELEMENTS/a/}'); +Expect(1, 9631, '\p{Is_Block=blockelements}', ""); +Expect(0, 9631, '\p{^Is_Block=blockelements}', ""); +Expect(0, 9631, '\P{Is_Block=blockelements}', ""); +Expect(1, 9631, '\P{^Is_Block=blockelements}', ""); +Expect(0, 9599, '\p{Is_Block=blockelements}', ""); +Expect(1, 9599, '\p{^Is_Block=blockelements}', ""); +Expect(1, 9599, '\P{Is_Block=blockelements}', ""); +Expect(0, 9599, '\P{^Is_Block=blockelements}', ""); +Expect(1, 9631, '\p{Is_Block=_ Block elements}', ""); +Expect(0, 9631, '\p{^Is_Block=_ Block elements}', ""); +Expect(0, 9631, '\P{Is_Block=_ Block elements}', ""); +Expect(1, 9631, '\P{^Is_Block=_ Block elements}', ""); +Expect(0, 9599, '\p{Is_Block=_ Block elements}', ""); +Expect(1, 9599, '\p{^Is_Block=_ Block elements}', ""); +Expect(1, 9599, '\P{Is_Block=_ Block elements}', ""); +Expect(0, 9599, '\P{^Is_Block=_ Block elements}', ""); +Error('\p{Is_Blk: _Block/a/Elements}'); +Error('\P{Is_Blk: _Block/a/Elements}'); +Expect(1, 9631, '\p{Is_Blk: blockelements}', ""); +Expect(0, 9631, '\p{^Is_Blk: blockelements}', ""); +Expect(0, 9631, '\P{Is_Blk: blockelements}', ""); +Expect(1, 9631, '\P{^Is_Blk: blockelements}', ""); +Expect(0, 9599, '\p{Is_Blk: blockelements}', ""); +Expect(1, 9599, '\p{^Is_Blk: blockelements}', ""); +Expect(1, 9599, '\P{Is_Blk: blockelements}', ""); +Expect(0, 9599, '\P{^Is_Blk: blockelements}', ""); +Expect(1, 9631, '\p{Is_Blk=--Block_ELEMENTS}', ""); +Expect(0, 9631, '\p{^Is_Blk=--Block_ELEMENTS}', ""); +Expect(0, 9631, '\P{Is_Blk=--Block_ELEMENTS}', ""); +Expect(1, 9631, '\P{^Is_Blk=--Block_ELEMENTS}', ""); +Expect(0, 9599, '\p{Is_Blk=--Block_ELEMENTS}', ""); +Expect(1, 9599, '\p{^Is_Blk=--Block_ELEMENTS}', ""); +Expect(1, 9599, '\P{Is_Blk=--Block_ELEMENTS}', ""); +Expect(0, 9599, '\P{^Is_Blk=--Block_ELEMENTS}', ""); +Error('\p{Block=/a/ -cjk-Strokes}'); +Error('\P{Block=/a/ -cjk-Strokes}'); +Expect(1, 12783, '\p{Block=cjkstrokes}', ""); +Expect(0, 12783, '\p{^Block=cjkstrokes}', ""); +Expect(0, 12783, '\P{Block=cjkstrokes}', ""); +Expect(1, 12783, '\P{^Block=cjkstrokes}', ""); +Expect(0, 12735, '\p{Block=cjkstrokes}', ""); +Expect(1, 12735, '\p{^Block=cjkstrokes}', ""); +Expect(1, 12735, '\P{Block=cjkstrokes}', ""); +Expect(0, 12735, '\P{^Block=cjkstrokes}', ""); +Expect(1, 12783, '\p{Block=CJK strokes}', ""); +Expect(0, 12783, '\p{^Block=CJK strokes}', ""); +Expect(0, 12783, '\P{Block=CJK strokes}', ""); +Expect(1, 12783, '\P{^Block=CJK strokes}', ""); +Expect(0, 12735, '\p{Block=CJK strokes}', ""); +Expect(1, 12735, '\p{^Block=CJK strokes}', ""); +Expect(1, 12735, '\P{Block=CJK strokes}', ""); +Expect(0, 12735, '\P{^Block=CJK strokes}', ""); +Error('\p{Blk= :=CJK-STROKES}'); +Error('\P{Blk= :=CJK-STROKES}'); +Expect(1, 12783, '\p{Blk=cjkstrokes}', ""); +Expect(0, 12783, '\p{^Blk=cjkstrokes}', ""); +Expect(0, 12783, '\P{Blk=cjkstrokes}', ""); +Expect(1, 12783, '\P{^Blk=cjkstrokes}', ""); +Expect(0, 12735, '\p{Blk=cjkstrokes}', ""); +Expect(1, 12735, '\p{^Blk=cjkstrokes}', ""); +Expect(1, 12735, '\P{Blk=cjkstrokes}', ""); +Expect(0, 12735, '\P{^Blk=cjkstrokes}', ""); +Expect(1, 12783, '\p{Blk: _CJK strokes}', ""); +Expect(0, 12783, '\p{^Blk: _CJK strokes}', ""); +Expect(0, 12783, '\P{Blk: _CJK strokes}', ""); +Expect(1, 12783, '\P{^Blk: _CJK strokes}', ""); +Expect(0, 12735, '\p{Blk: _CJK strokes}', ""); +Expect(1, 12735, '\p{^Blk: _CJK strokes}', ""); +Expect(1, 12735, '\P{Blk: _CJK strokes}', ""); +Expect(0, 12735, '\P{^Blk: _CJK strokes}', ""); +Error('\p{Is_Block=/a/ -CJK STROKES}'); +Error('\P{Is_Block=/a/ -CJK STROKES}'); +Expect(1, 12783, '\p{Is_Block:cjkstrokes}', ""); +Expect(0, 12783, '\p{^Is_Block:cjkstrokes}', ""); +Expect(0, 12783, '\P{Is_Block:cjkstrokes}', ""); +Expect(1, 12783, '\P{^Is_Block:cjkstrokes}', ""); +Expect(0, 12735, '\p{Is_Block:cjkstrokes}', ""); +Expect(1, 12735, '\p{^Is_Block:cjkstrokes}', ""); +Expect(1, 12735, '\P{Is_Block:cjkstrokes}', ""); +Expect(0, 12735, '\P{^Is_Block:cjkstrokes}', ""); +Expect(1, 12783, '\p{Is_Block:__CJKSTROKES}', ""); +Expect(0, 12783, '\p{^Is_Block:__CJKSTROKES}', ""); +Expect(0, 12783, '\P{Is_Block:__CJKSTROKES}', ""); +Expect(1, 12783, '\P{^Is_Block:__CJKSTROKES}', ""); +Expect(0, 12735, '\p{Is_Block:__CJKSTROKES}', ""); +Expect(1, 12735, '\p{^Is_Block:__CJKSTROKES}', ""); +Expect(1, 12735, '\P{Is_Block:__CJKSTROKES}', ""); +Expect(0, 12735, '\P{^Is_Block:__CJKSTROKES}', ""); +Error('\p{Is_Blk=/a/CJK-strokes}'); +Error('\P{Is_Blk=/a/CJK-strokes}'); +Expect(1, 12783, '\p{Is_Blk=cjkstrokes}', ""); +Expect(0, 12783, '\p{^Is_Blk=cjkstrokes}', ""); +Expect(0, 12783, '\P{Is_Blk=cjkstrokes}', ""); +Expect(1, 12783, '\P{^Is_Blk=cjkstrokes}', ""); +Expect(0, 12735, '\p{Is_Blk=cjkstrokes}', ""); +Expect(1, 12735, '\p{^Is_Blk=cjkstrokes}', ""); +Expect(1, 12735, '\P{Is_Blk=cjkstrokes}', ""); +Expect(0, 12735, '\P{^Is_Blk=cjkstrokes}', ""); +Expect(1, 12783, '\p{Is_Blk=-_CJKSTROKES}', ""); +Expect(0, 12783, '\p{^Is_Blk=-_CJKSTROKES}', ""); +Expect(0, 12783, '\P{Is_Blk=-_CJKSTROKES}', ""); +Expect(1, 12783, '\P{^Is_Blk=-_CJKSTROKES}', ""); +Expect(0, 12735, '\p{Is_Blk=-_CJKSTROKES}', ""); +Expect(1, 12735, '\p{^Is_Blk=-_CJKSTROKES}', ""); +Expect(1, 12735, '\P{Is_Blk=-_CJKSTROKES}', ""); +Expect(0, 12735, '\P{^Is_Blk=-_CJKSTROKES}', ""); +Error('\p{Block=_No block/a/}'); +Error('\P{Block=_No block/a/}'); +Expect(1, 2303, '\p{Block=noblock}', ""); +Expect(0, 2303, '\p{^Block=noblock}', ""); +Expect(0, 2303, '\P{Block=noblock}', ""); +Expect(1, 2303, '\P{^Block=noblock}', ""); +Expect(0, 2047, '\p{Block=noblock}', ""); +Expect(1, 2047, '\p{^Block=noblock}', ""); +Expect(1, 2047, '\P{Block=noblock}', ""); +Expect(0, 2047, '\P{^Block=noblock}', ""); +Expect(1, 2303, '\p{Block= no-block}', ""); +Expect(0, 2303, '\p{^Block= no-block}', ""); +Expect(0, 2303, '\P{Block= no-block}', ""); +Expect(1, 2303, '\P{^Block= no-block}', ""); +Expect(0, 2047, '\p{Block= no-block}', ""); +Expect(1, 2047, '\p{^Block= no-block}', ""); +Expect(1, 2047, '\P{Block= no-block}', ""); +Expect(0, 2047, '\P{^Block= no-block}', ""); +Error('\p{Blk=:=__no BLOCK}'); +Error('\P{Blk=:=__no BLOCK}'); +Expect(1, 2303, '\p{Blk: noblock}', ""); +Expect(0, 2303, '\p{^Blk: noblock}', ""); +Expect(0, 2303, '\P{Blk: noblock}', ""); +Expect(1, 2303, '\P{^Blk: noblock}', ""); +Expect(0, 2047, '\p{Blk: noblock}', ""); +Expect(1, 2047, '\p{^Blk: noblock}', ""); +Expect(1, 2047, '\P{Blk: noblock}', ""); +Expect(0, 2047, '\P{^Blk: noblock}', ""); +Expect(1, 2303, '\p{Blk:_NoBlock}', ""); +Expect(0, 2303, '\p{^Blk:_NoBlock}', ""); +Expect(0, 2303, '\P{Blk:_NoBlock}', ""); +Expect(1, 2303, '\P{^Blk:_NoBlock}', ""); +Expect(0, 2047, '\p{Blk:_NoBlock}', ""); +Expect(1, 2047, '\p{^Blk:_NoBlock}', ""); +Expect(1, 2047, '\P{Blk:_NoBlock}', ""); +Expect(0, 2047, '\P{^Blk:_NoBlock}', ""); +Error('\p{Is_Block: _no/a/Block}'); +Error('\P{Is_Block: _no/a/Block}'); +Expect(1, 2303, '\p{Is_Block=noblock}', ""); +Expect(0, 2303, '\p{^Is_Block=noblock}', ""); +Expect(0, 2303, '\P{Is_Block=noblock}', ""); +Expect(1, 2303, '\P{^Is_Block=noblock}', ""); +Expect(0, 2047, '\p{Is_Block=noblock}', ""); +Expect(1, 2047, '\p{^Is_Block=noblock}', ""); +Expect(1, 2047, '\P{Is_Block=noblock}', ""); +Expect(0, 2047, '\P{^Is_Block=noblock}', ""); +Expect(1, 2303, '\p{Is_Block=-_No_Block}', ""); +Expect(0, 2303, '\p{^Is_Block=-_No_Block}', ""); +Expect(0, 2303, '\P{Is_Block=-_No_Block}', ""); +Expect(1, 2303, '\P{^Is_Block=-_No_Block}', ""); +Expect(0, 2047, '\p{Is_Block=-_No_Block}', ""); +Expect(1, 2047, '\p{^Is_Block=-_No_Block}', ""); +Expect(1, 2047, '\P{Is_Block=-_No_Block}', ""); +Expect(0, 2047, '\P{^Is_Block=-_No_Block}', ""); +Error('\p{Is_Blk=/a/ No Block}'); +Error('\P{Is_Blk=/a/ No Block}'); +Expect(1, 2303, '\p{Is_Blk=noblock}', ""); +Expect(0, 2303, '\p{^Is_Blk=noblock}', ""); +Expect(0, 2303, '\P{Is_Blk=noblock}', ""); +Expect(1, 2303, '\P{^Is_Blk=noblock}', ""); +Expect(0, 2047, '\p{Is_Blk=noblock}', ""); +Expect(1, 2047, '\p{^Is_Blk=noblock}', ""); +Expect(1, 2047, '\P{Is_Blk=noblock}', ""); +Expect(0, 2047, '\P{^Is_Blk=noblock}', ""); +Expect(1, 2303, '\p{Is_Blk= _No BLOCK}', ""); +Expect(0, 2303, '\p{^Is_Blk= _No BLOCK}', ""); +Expect(0, 2303, '\P{Is_Blk= _No BLOCK}', ""); +Expect(1, 2303, '\P{^Is_Blk= _No BLOCK}', ""); +Expect(0, 2047, '\p{Is_Blk= _No BLOCK}', ""); +Expect(1, 2047, '\p{^Is_Blk= _No BLOCK}', ""); +Expect(1, 2047, '\P{Is_Blk= _No BLOCK}', ""); +Expect(0, 2047, '\P{^Is_Blk= _No BLOCK}', ""); +Error('\p{Block= -CJK/a/COMPATIBILITY}'); +Error('\P{Block= -CJK/a/COMPATIBILITY}'); +Expect(1, 13311, '\p{Block=cjkcompatibility}', ""); +Expect(0, 13311, '\p{^Block=cjkcompatibility}', ""); +Expect(0, 13311, '\P{Block=cjkcompatibility}', ""); +Expect(1, 13311, '\P{^Block=cjkcompatibility}', ""); +Expect(0, 13055, '\p{Block=cjkcompatibility}', ""); +Expect(1, 13055, '\p{^Block=cjkcompatibility}', ""); +Expect(1, 13055, '\P{Block=cjkcompatibility}', ""); +Expect(0, 13055, '\P{^Block=cjkcompatibility}', ""); +Expect(1, 13311, '\p{Block: _CJK COMPATIBILITY}', ""); +Expect(0, 13311, '\p{^Block: _CJK COMPATIBILITY}', ""); +Expect(0, 13311, '\P{Block: _CJK COMPATIBILITY}', ""); +Expect(1, 13311, '\P{^Block: _CJK COMPATIBILITY}', ""); +Expect(0, 13055, '\p{Block: _CJK COMPATIBILITY}', ""); +Expect(1, 13055, '\p{^Block: _CJK COMPATIBILITY}', ""); +Expect(1, 13055, '\P{Block: _CJK COMPATIBILITY}', ""); +Expect(0, 13055, '\P{^Block: _CJK COMPATIBILITY}', ""); +Error('\p{Blk=/a/_ CJK-compatibility}'); +Error('\P{Blk=/a/_ CJK-compatibility}'); +Expect(1, 13311, '\p{Blk=cjkcompatibility}', ""); +Expect(0, 13311, '\p{^Blk=cjkcompatibility}', ""); +Expect(0, 13311, '\P{Blk=cjkcompatibility}', ""); +Expect(1, 13311, '\P{^Blk=cjkcompatibility}', ""); +Expect(0, 13055, '\p{Blk=cjkcompatibility}', ""); +Expect(1, 13055, '\p{^Blk=cjkcompatibility}', ""); +Expect(1, 13055, '\P{Blk=cjkcompatibility}', ""); +Expect(0, 13055, '\P{^Blk=cjkcompatibility}', ""); +Expect(1, 13311, '\p{Blk: -cjk_COMPATIBILITY}', ""); +Expect(0, 13311, '\p{^Blk: -cjk_COMPATIBILITY}', ""); +Expect(0, 13311, '\P{Blk: -cjk_COMPATIBILITY}', ""); +Expect(1, 13311, '\P{^Blk: -cjk_COMPATIBILITY}', ""); +Expect(0, 13055, '\p{Blk: -cjk_COMPATIBILITY}', ""); +Expect(1, 13055, '\p{^Blk: -cjk_COMPATIBILITY}', ""); +Expect(1, 13055, '\P{Blk: -cjk_COMPATIBILITY}', ""); +Expect(0, 13055, '\P{^Blk: -cjk_COMPATIBILITY}', ""); +Error('\p{Is_Block=:=-CJK_compatibility}'); +Error('\P{Is_Block=:=-CJK_compatibility}'); +Expect(1, 13311, '\p{Is_Block=cjkcompatibility}', ""); +Expect(0, 13311, '\p{^Is_Block=cjkcompatibility}', ""); +Expect(0, 13311, '\P{Is_Block=cjkcompatibility}', ""); +Expect(1, 13311, '\P{^Is_Block=cjkcompatibility}', ""); +Expect(0, 13055, '\p{Is_Block=cjkcompatibility}', ""); +Expect(1, 13055, '\p{^Is_Block=cjkcompatibility}', ""); +Expect(1, 13055, '\P{Is_Block=cjkcompatibility}', ""); +Expect(0, 13055, '\P{^Is_Block=cjkcompatibility}', ""); +Expect(1, 13311, '\p{Is_Block= CJK compatibility}', ""); +Expect(0, 13311, '\p{^Is_Block= CJK compatibility}', ""); +Expect(0, 13311, '\P{Is_Block= CJK compatibility}', ""); +Expect(1, 13311, '\P{^Is_Block= CJK compatibility}', ""); +Expect(0, 13055, '\p{Is_Block= CJK compatibility}', ""); +Expect(1, 13055, '\p{^Is_Block= CJK compatibility}', ""); +Expect(1, 13055, '\P{Is_Block= CJK compatibility}', ""); +Expect(0, 13055, '\P{^Is_Block= CJK compatibility}', ""); +Error('\p{Is_Blk=CJK:=COMPATIBILITY}'); +Error('\P{Is_Blk=CJK:=COMPATIBILITY}'); +Expect(1, 13311, '\p{Is_Blk:cjkcompatibility}', ""); +Expect(0, 13311, '\p{^Is_Blk:cjkcompatibility}', ""); +Expect(0, 13311, '\P{Is_Blk:cjkcompatibility}', ""); +Expect(1, 13311, '\P{^Is_Blk:cjkcompatibility}', ""); +Expect(0, 13055, '\p{Is_Blk:cjkcompatibility}', ""); +Expect(1, 13055, '\p{^Is_Blk:cjkcompatibility}', ""); +Expect(1, 13055, '\P{Is_Blk:cjkcompatibility}', ""); +Expect(0, 13055, '\P{^Is_Blk:cjkcompatibility}', ""); +Expect(1, 13311, '\p{Is_Blk= CJK-COMPATIBILITY}', ""); +Expect(0, 13311, '\p{^Is_Blk= CJK-COMPATIBILITY}', ""); +Expect(0, 13311, '\P{Is_Blk= CJK-COMPATIBILITY}', ""); +Expect(1, 13311, '\P{^Is_Blk= CJK-COMPATIBILITY}', ""); +Expect(0, 13055, '\p{Is_Blk= CJK-COMPATIBILITY}', ""); +Expect(1, 13055, '\p{^Is_Blk= CJK-COMPATIBILITY}', ""); +Expect(1, 13055, '\P{Is_Blk= CJK-COMPATIBILITY}', ""); +Expect(0, 13055, '\P{^Is_Blk= CJK-COMPATIBILITY}', ""); +Error('\p{Block= _Cyrillic Extended B:=}'); +Error('\P{Block= _Cyrillic Extended B:=}'); +Expect(1, 42655, '\p{Block=cyrillicextendedb}', ""); +Expect(0, 42655, '\p{^Block=cyrillicextendedb}', ""); +Expect(0, 42655, '\P{Block=cyrillicextendedb}', ""); +Expect(1, 42655, '\P{^Block=cyrillicextendedb}', ""); +Expect(0, 42559, '\p{Block=cyrillicextendedb}', ""); +Expect(1, 42559, '\p{^Block=cyrillicextendedb}', ""); +Expect(1, 42559, '\P{Block=cyrillicextendedb}', ""); +Expect(0, 42559, '\P{^Block=cyrillicextendedb}', ""); +Expect(1, 42655, '\p{Block= cyrillic extendedB}', ""); +Expect(0, 42655, '\p{^Block= cyrillic extendedB}', ""); +Expect(0, 42655, '\P{Block= cyrillic extendedB}', ""); +Expect(1, 42655, '\P{^Block= cyrillic extendedB}', ""); +Expect(0, 42559, '\p{Block= cyrillic extendedB}', ""); +Expect(1, 42559, '\p{^Block= cyrillic extendedB}', ""); +Expect(1, 42559, '\P{Block= cyrillic extendedB}', ""); +Expect(0, 42559, '\P{^Block= cyrillic extendedB}', ""); +Error('\p{Blk= _cyrillic EXTENDED:=B}'); +Error('\P{Blk= _cyrillic EXTENDED:=B}'); +Expect(1, 42655, '\p{Blk=cyrillicextendedb}', ""); +Expect(0, 42655, '\p{^Blk=cyrillicextendedb}', ""); +Expect(0, 42655, '\P{Blk=cyrillicextendedb}', ""); +Expect(1, 42655, '\P{^Blk=cyrillicextendedb}', ""); +Expect(0, 42559, '\p{Blk=cyrillicextendedb}', ""); +Expect(1, 42559, '\p{^Blk=cyrillicextendedb}', ""); +Expect(1, 42559, '\P{Blk=cyrillicextendedb}', ""); +Expect(0, 42559, '\P{^Blk=cyrillicextendedb}', ""); +Expect(1, 42655, '\p{Blk= cyrillic_Extended_b}', ""); +Expect(0, 42655, '\p{^Blk= cyrillic_Extended_b}', ""); +Expect(0, 42655, '\P{Blk= cyrillic_Extended_b}', ""); +Expect(1, 42655, '\P{^Blk= cyrillic_Extended_b}', ""); +Expect(0, 42559, '\p{Blk= cyrillic_Extended_b}', ""); +Expect(1, 42559, '\p{^Blk= cyrillic_Extended_b}', ""); +Expect(1, 42559, '\P{Blk= cyrillic_Extended_b}', ""); +Expect(0, 42559, '\P{^Blk= cyrillic_Extended_b}', ""); +Error('\p{Is_Block=:= Cyrillicextended B}'); +Error('\P{Is_Block=:= Cyrillicextended B}'); +Expect(1, 42655, '\p{Is_Block=cyrillicextendedb}', ""); +Expect(0, 42655, '\p{^Is_Block=cyrillicextendedb}', ""); +Expect(0, 42655, '\P{Is_Block=cyrillicextendedb}', ""); +Expect(1, 42655, '\P{^Is_Block=cyrillicextendedb}', ""); +Expect(0, 42559, '\p{Is_Block=cyrillicextendedb}', ""); +Expect(1, 42559, '\p{^Is_Block=cyrillicextendedb}', ""); +Expect(1, 42559, '\P{Is_Block=cyrillicextendedb}', ""); +Expect(0, 42559, '\P{^Is_Block=cyrillicextendedb}', ""); +Expect(1, 42655, '\p{Is_Block=_cyrillic-Extended b}', ""); +Expect(0, 42655, '\p{^Is_Block=_cyrillic-Extended b}', ""); +Expect(0, 42655, '\P{Is_Block=_cyrillic-Extended b}', ""); +Expect(1, 42655, '\P{^Is_Block=_cyrillic-Extended b}', ""); +Expect(0, 42559, '\p{Is_Block=_cyrillic-Extended b}', ""); +Expect(1, 42559, '\p{^Is_Block=_cyrillic-Extended b}', ""); +Expect(1, 42559, '\P{Is_Block=_cyrillic-Extended b}', ""); +Expect(0, 42559, '\P{^Is_Block=_cyrillic-Extended b}', ""); +Error('\p{Is_Blk=_:=CYRILLIC EXTENDED-B}'); +Error('\P{Is_Blk=_:=CYRILLIC EXTENDED-B}'); +Expect(1, 42655, '\p{Is_Blk=cyrillicextendedb}', ""); +Expect(0, 42655, '\p{^Is_Blk=cyrillicextendedb}', ""); +Expect(0, 42655, '\P{Is_Blk=cyrillicextendedb}', ""); +Expect(1, 42655, '\P{^Is_Blk=cyrillicextendedb}', ""); +Expect(0, 42559, '\p{Is_Blk=cyrillicextendedb}', ""); +Expect(1, 42559, '\p{^Is_Blk=cyrillicextendedb}', ""); +Expect(1, 42559, '\P{Is_Blk=cyrillicextendedb}', ""); +Expect(0, 42559, '\P{^Is_Blk=cyrillicextendedb}', ""); +Expect(1, 42655, '\p{Is_Blk=_Cyrillic_extendedB}', ""); +Expect(0, 42655, '\p{^Is_Blk=_Cyrillic_extendedB}', ""); +Expect(0, 42655, '\P{Is_Blk=_Cyrillic_extendedB}', ""); +Expect(1, 42655, '\P{^Is_Blk=_Cyrillic_extendedB}', ""); +Expect(0, 42559, '\p{Is_Blk=_Cyrillic_extendedB}', ""); +Expect(1, 42559, '\p{^Is_Blk=_Cyrillic_extendedB}', ""); +Expect(1, 42559, '\P{Is_Blk=_Cyrillic_extendedB}', ""); +Expect(0, 42559, '\P{^Is_Blk=_Cyrillic_extendedB}', ""); +Error('\p{Block: _Phonetic Extensions/a/}'); +Error('\P{Block: _Phonetic Extensions/a/}'); +Expect(1, 7551, '\p{Block: phoneticextensions}', ""); +Expect(0, 7551, '\p{^Block: phoneticextensions}', ""); +Expect(0, 7551, '\P{Block: phoneticextensions}', ""); +Expect(1, 7551, '\P{^Block: phoneticextensions}', ""); +Expect(0, 7423, '\p{Block: phoneticextensions}', ""); +Expect(1, 7423, '\p{^Block: phoneticextensions}', ""); +Expect(1, 7423, '\P{Block: phoneticextensions}', ""); +Expect(0, 7423, '\P{^Block: phoneticextensions}', ""); +Expect(1, 7551, '\p{Block= phonetic extensions}', ""); +Expect(0, 7551, '\p{^Block= phonetic extensions}', ""); +Expect(0, 7551, '\P{Block= phonetic extensions}', ""); +Expect(1, 7551, '\P{^Block= phonetic extensions}', ""); +Expect(0, 7423, '\p{Block= phonetic extensions}', ""); +Expect(1, 7423, '\p{^Block= phonetic extensions}', ""); +Expect(1, 7423, '\P{Block= phonetic extensions}', ""); +Expect(0, 7423, '\P{^Block= phonetic extensions}', ""); +Error('\p{Blk: := phonetic EXTENSIONS}'); +Error('\P{Blk: := phonetic EXTENSIONS}'); +Expect(1, 7551, '\p{Blk: phoneticextensions}', ""); +Expect(0, 7551, '\p{^Blk: phoneticextensions}', ""); +Expect(0, 7551, '\P{Blk: phoneticextensions}', ""); +Expect(1, 7551, '\P{^Blk: phoneticextensions}', ""); +Expect(0, 7423, '\p{Blk: phoneticextensions}', ""); +Expect(1, 7423, '\p{^Blk: phoneticextensions}', ""); +Expect(1, 7423, '\P{Blk: phoneticextensions}', ""); +Expect(0, 7423, '\P{^Blk: phoneticextensions}', ""); +Expect(1, 7551, '\p{Blk=_-Phonetic Extensions}', ""); +Expect(0, 7551, '\p{^Blk=_-Phonetic Extensions}', ""); +Expect(0, 7551, '\P{Blk=_-Phonetic Extensions}', ""); +Expect(1, 7551, '\P{^Blk=_-Phonetic Extensions}', ""); +Expect(0, 7423, '\p{Blk=_-Phonetic Extensions}', ""); +Expect(1, 7423, '\p{^Blk=_-Phonetic Extensions}', ""); +Expect(1, 7423, '\P{Blk=_-Phonetic Extensions}', ""); +Expect(0, 7423, '\P{^Blk=_-Phonetic Extensions}', ""); +Error('\p{Is_Block=/a/-_PHONETIC Extensions}'); +Error('\P{Is_Block=/a/-_PHONETIC Extensions}'); +Expect(1, 7551, '\p{Is_Block=phoneticextensions}', ""); +Expect(0, 7551, '\p{^Is_Block=phoneticextensions}', ""); +Expect(0, 7551, '\P{Is_Block=phoneticextensions}', ""); +Expect(1, 7551, '\P{^Is_Block=phoneticextensions}', ""); +Expect(0, 7423, '\p{Is_Block=phoneticextensions}', ""); +Expect(1, 7423, '\p{^Is_Block=phoneticextensions}', ""); +Expect(1, 7423, '\P{Is_Block=phoneticextensions}', ""); +Expect(0, 7423, '\P{^Is_Block=phoneticextensions}', ""); +Expect(1, 7551, '\p{Is_Block=- Phonetic-Extensions}', ""); +Expect(0, 7551, '\p{^Is_Block=- Phonetic-Extensions}', ""); +Expect(0, 7551, '\P{Is_Block=- Phonetic-Extensions}', ""); +Expect(1, 7551, '\P{^Is_Block=- Phonetic-Extensions}', ""); +Expect(0, 7423, '\p{Is_Block=- Phonetic-Extensions}', ""); +Expect(1, 7423, '\p{^Is_Block=- Phonetic-Extensions}', ""); +Expect(1, 7423, '\P{Is_Block=- Phonetic-Extensions}', ""); +Expect(0, 7423, '\P{^Is_Block=- Phonetic-Extensions}', ""); +Error('\p{Is_Blk=_Phonetic/a/Extensions}'); +Error('\P{Is_Blk=_Phonetic/a/Extensions}'); +Expect(1, 7551, '\p{Is_Blk=phoneticextensions}', ""); +Expect(0, 7551, '\p{^Is_Blk=phoneticextensions}', ""); +Expect(0, 7551, '\P{Is_Blk=phoneticextensions}', ""); +Expect(1, 7551, '\P{^Is_Blk=phoneticextensions}', ""); +Expect(0, 7423, '\p{Is_Blk=phoneticextensions}', ""); +Expect(1, 7423, '\p{^Is_Blk=phoneticextensions}', ""); +Expect(1, 7423, '\P{Is_Blk=phoneticextensions}', ""); +Expect(0, 7423, '\P{^Is_Blk=phoneticextensions}', ""); +Expect(1, 7551, '\p{Is_Blk=- PhoneticExtensions}', ""); +Expect(0, 7551, '\p{^Is_Blk=- PhoneticExtensions}', ""); +Expect(0, 7551, '\P{Is_Blk=- PhoneticExtensions}', ""); +Expect(1, 7551, '\P{^Is_Blk=- PhoneticExtensions}', ""); +Expect(0, 7423, '\p{Is_Blk=- PhoneticExtensions}', ""); +Expect(1, 7423, '\p{^Is_Blk=- PhoneticExtensions}', ""); +Expect(1, 7423, '\P{Is_Blk=- PhoneticExtensions}', ""); +Expect(0, 7423, '\P{^Is_Blk=- PhoneticExtensions}', ""); +Error('\p{Block: /a/taiXUAN-JING SYMBOLS}'); +Error('\P{Block: /a/taiXUAN-JING SYMBOLS}'); +Expect(1, 119647, '\p{Block=taixuanjingsymbols}', ""); +Expect(0, 119647, '\p{^Block=taixuanjingsymbols}', ""); +Expect(0, 119647, '\P{Block=taixuanjingsymbols}', ""); +Expect(1, 119647, '\P{^Block=taixuanjingsymbols}', ""); +Expect(0, 119551, '\p{Block=taixuanjingsymbols}', ""); +Expect(1, 119551, '\p{^Block=taixuanjingsymbols}', ""); +Expect(1, 119551, '\P{Block=taixuanjingsymbols}', ""); +Expect(0, 119551, '\P{^Block=taixuanjingsymbols}', ""); +Expect(1, 119647, '\p{Block: __taiXuan-jing_Symbols}', ""); +Expect(0, 119647, '\p{^Block: __taiXuan-jing_Symbols}', ""); +Expect(0, 119647, '\P{Block: __taiXuan-jing_Symbols}', ""); +Expect(1, 119647, '\P{^Block: __taiXuan-jing_Symbols}', ""); +Expect(0, 119551, '\p{Block: __taiXuan-jing_Symbols}', ""); +Expect(1, 119551, '\p{^Block: __taiXuan-jing_Symbols}', ""); +Expect(1, 119551, '\P{Block: __taiXuan-jing_Symbols}', ""); +Expect(0, 119551, '\P{^Block: __taiXuan-jing_Symbols}', ""); +Error('\p{Blk= TaiXUAN Jing SYMBOLS:=}'); +Error('\P{Blk= TaiXUAN Jing SYMBOLS:=}'); +Expect(1, 119647, '\p{Blk=taixuanjingsymbols}', ""); +Expect(0, 119647, '\p{^Blk=taixuanjingsymbols}', ""); +Expect(0, 119647, '\P{Blk=taixuanjingsymbols}', ""); +Expect(1, 119647, '\P{^Blk=taixuanjingsymbols}', ""); +Expect(0, 119551, '\p{Blk=taixuanjingsymbols}', ""); +Expect(1, 119551, '\p{^Blk=taixuanjingsymbols}', ""); +Expect(1, 119551, '\P{Blk=taixuanjingsymbols}', ""); +Expect(0, 119551, '\P{^Blk=taixuanjingsymbols}', ""); +Expect(1, 119647, '\p{Blk= _tai xuanjing-Symbols}', ""); +Expect(0, 119647, '\p{^Blk= _tai xuanjing-Symbols}', ""); +Expect(0, 119647, '\P{Blk= _tai xuanjing-Symbols}', ""); +Expect(1, 119647, '\P{^Blk= _tai xuanjing-Symbols}', ""); +Expect(0, 119551, '\p{Blk= _tai xuanjing-Symbols}', ""); +Expect(1, 119551, '\p{^Blk= _tai xuanjing-Symbols}', ""); +Expect(1, 119551, '\P{Blk= _tai xuanjing-Symbols}', ""); +Expect(0, 119551, '\P{^Blk= _tai xuanjing-Symbols}', ""); +Error('\p{Is_Block=/a/-TaiXuan jing Symbols}'); +Error('\P{Is_Block=/a/-TaiXuan jing Symbols}'); +Expect(1, 119647, '\p{Is_Block=taixuanjingsymbols}', ""); +Expect(0, 119647, '\p{^Is_Block=taixuanjingsymbols}', ""); +Expect(0, 119647, '\P{Is_Block=taixuanjingsymbols}', ""); +Expect(1, 119647, '\P{^Is_Block=taixuanjingsymbols}', ""); +Expect(0, 119551, '\p{Is_Block=taixuanjingsymbols}', ""); +Expect(1, 119551, '\p{^Is_Block=taixuanjingsymbols}', ""); +Expect(1, 119551, '\P{Is_Block=taixuanjingsymbols}', ""); +Expect(0, 119551, '\P{^Is_Block=taixuanjingsymbols}', ""); +Expect(1, 119647, '\p{Is_Block= TAIXUAN-Jing_SYMBOLS}', ""); +Expect(0, 119647, '\p{^Is_Block= TAIXUAN-Jing_SYMBOLS}', ""); +Expect(0, 119647, '\P{Is_Block= TAIXUAN-Jing_SYMBOLS}', ""); +Expect(1, 119647, '\P{^Is_Block= TAIXUAN-Jing_SYMBOLS}', ""); +Expect(0, 119551, '\p{Is_Block= TAIXUAN-Jing_SYMBOLS}', ""); +Expect(1, 119551, '\p{^Is_Block= TAIXUAN-Jing_SYMBOLS}', ""); +Expect(1, 119551, '\P{Is_Block= TAIXUAN-Jing_SYMBOLS}', ""); +Expect(0, 119551, '\P{^Is_Block= TAIXUAN-Jing_SYMBOLS}', ""); +Error('\p{Is_Blk=Tai Xuan_jing Symbols/a/}'); +Error('\P{Is_Blk=Tai Xuan_jing Symbols/a/}'); +Expect(1, 119647, '\p{Is_Blk=taixuanjingsymbols}', ""); +Expect(0, 119647, '\p{^Is_Blk=taixuanjingsymbols}', ""); +Expect(0, 119647, '\P{Is_Blk=taixuanjingsymbols}', ""); +Expect(1, 119647, '\P{^Is_Blk=taixuanjingsymbols}', ""); +Expect(0, 119551, '\p{Is_Blk=taixuanjingsymbols}', ""); +Expect(1, 119551, '\p{^Is_Blk=taixuanjingsymbols}', ""); +Expect(1, 119551, '\P{Is_Blk=taixuanjingsymbols}', ""); +Expect(0, 119551, '\P{^Is_Blk=taixuanjingsymbols}', ""); +Expect(1, 119647, '\p{Is_Blk: Tai Xuan JING_SYMBOLS}', ""); +Expect(0, 119647, '\p{^Is_Blk: Tai Xuan JING_SYMBOLS}', ""); +Expect(0, 119647, '\P{Is_Blk: Tai Xuan JING_SYMBOLS}', ""); +Expect(1, 119647, '\P{^Is_Blk: Tai Xuan JING_SYMBOLS}', ""); +Expect(0, 119551, '\p{Is_Blk: Tai Xuan JING_SYMBOLS}', ""); +Expect(1, 119551, '\p{^Is_Blk: Tai Xuan JING_SYMBOLS}', ""); +Expect(1, 119551, '\P{Is_Blk: Tai Xuan JING_SYMBOLS}', ""); +Expect(0, 119551, '\P{^Is_Blk: Tai Xuan JING_SYMBOLS}', ""); +Error('\p{Block=:=malayalam}'); +Error('\P{Block=:=malayalam}'); +Expect(1, 3455, '\p{Block=malayalam}', ""); +Expect(0, 3455, '\p{^Block=malayalam}', ""); +Expect(0, 3455, '\P{Block=malayalam}', ""); +Expect(1, 3455, '\P{^Block=malayalam}', ""); +Expect(0, 3327, '\p{Block=malayalam}', ""); +Expect(1, 3327, '\p{^Block=malayalam}', ""); +Expect(1, 3327, '\P{Block=malayalam}', ""); +Expect(0, 3327, '\P{^Block=malayalam}', ""); +Expect(1, 3455, '\p{Block=__Malayalam}', ""); +Expect(0, 3455, '\p{^Block=__Malayalam}', ""); +Expect(0, 3455, '\P{Block=__Malayalam}', ""); +Expect(1, 3455, '\P{^Block=__Malayalam}', ""); +Expect(0, 3327, '\p{Block=__Malayalam}', ""); +Expect(1, 3327, '\p{^Block=__Malayalam}', ""); +Expect(1, 3327, '\P{Block=__Malayalam}', ""); +Expect(0, 3327, '\P{^Block=__Malayalam}', ""); +Error('\p{Blk=:= malayalam}'); +Error('\P{Blk=:= malayalam}'); +Expect(1, 3455, '\p{Blk=malayalam}', ""); +Expect(0, 3455, '\p{^Blk=malayalam}', ""); +Expect(0, 3455, '\P{Blk=malayalam}', ""); +Expect(1, 3455, '\P{^Blk=malayalam}', ""); +Expect(0, 3327, '\p{Blk=malayalam}', ""); +Expect(1, 3327, '\p{^Blk=malayalam}', ""); +Expect(1, 3327, '\P{Blk=malayalam}', ""); +Expect(0, 3327, '\P{^Blk=malayalam}', ""); +Expect(1, 3455, '\p{Blk= malayalam}', ""); +Expect(0, 3455, '\p{^Blk= malayalam}', ""); +Expect(0, 3455, '\P{Blk= malayalam}', ""); +Expect(1, 3455, '\P{^Blk= malayalam}', ""); +Expect(0, 3327, '\p{Blk= malayalam}', ""); +Expect(1, 3327, '\p{^Blk= malayalam}', ""); +Expect(1, 3327, '\P{Blk= malayalam}', ""); +Expect(0, 3327, '\P{^Blk= malayalam}', ""); +Error('\p{Is_Block=/a/MALAYALAM}'); +Error('\P{Is_Block=/a/MALAYALAM}'); +Expect(1, 3455, '\p{Is_Block:malayalam}', ""); +Expect(0, 3455, '\p{^Is_Block:malayalam}', ""); +Expect(0, 3455, '\P{Is_Block:malayalam}', ""); +Expect(1, 3455, '\P{^Is_Block:malayalam}', ""); +Expect(0, 3327, '\p{Is_Block:malayalam}', ""); +Expect(1, 3327, '\p{^Is_Block:malayalam}', ""); +Expect(1, 3327, '\P{Is_Block:malayalam}', ""); +Expect(0, 3327, '\P{^Is_Block:malayalam}', ""); +Expect(1, 3455, '\p{Is_Block= malayalam}', ""); +Expect(0, 3455, '\p{^Is_Block= malayalam}', ""); +Expect(0, 3455, '\P{Is_Block= malayalam}', ""); +Expect(1, 3455, '\P{^Is_Block= malayalam}', ""); +Expect(0, 3327, '\p{Is_Block= malayalam}', ""); +Expect(1, 3327, '\p{^Is_Block= malayalam}', ""); +Expect(1, 3327, '\P{Is_Block= malayalam}', ""); +Expect(0, 3327, '\P{^Is_Block= malayalam}', ""); +Error('\p{Is_Blk=/a/ _Malayalam}'); +Error('\P{Is_Blk=/a/ _Malayalam}'); +Expect(1, 3455, '\p{Is_Blk=malayalam}', ""); +Expect(0, 3455, '\p{^Is_Blk=malayalam}', ""); +Expect(0, 3455, '\P{Is_Blk=malayalam}', ""); +Expect(1, 3455, '\P{^Is_Blk=malayalam}', ""); +Expect(0, 3327, '\p{Is_Blk=malayalam}', ""); +Expect(1, 3327, '\p{^Is_Blk=malayalam}', ""); +Expect(1, 3327, '\P{Is_Blk=malayalam}', ""); +Expect(0, 3327, '\P{^Is_Blk=malayalam}', ""); +Expect(1, 3455, '\p{Is_Blk=-_MALAYALAM}', ""); +Expect(0, 3455, '\p{^Is_Blk=-_MALAYALAM}', ""); +Expect(0, 3455, '\P{Is_Blk=-_MALAYALAM}', ""); +Expect(1, 3455, '\P{^Is_Blk=-_MALAYALAM}', ""); +Expect(0, 3327, '\p{Is_Blk=-_MALAYALAM}', ""); +Expect(1, 3327, '\p{^Is_Blk=-_MALAYALAM}', ""); +Expect(1, 3327, '\P{Is_Blk=-_MALAYALAM}', ""); +Expect(0, 3327, '\P{^Is_Blk=-_MALAYALAM}', ""); +Error('\p{Block= Arabic Presentation:=FORMS A}'); +Error('\P{Block= Arabic Presentation:=FORMS A}'); +Expect(1, 65023, '\p{Block: arabicpresentationformsa}', ""); +Expect(0, 65023, '\p{^Block: arabicpresentationformsa}', ""); +Expect(0, 65023, '\P{Block: arabicpresentationformsa}', ""); +Expect(1, 65023, '\P{^Block: arabicpresentationformsa}', ""); +Expect(0, 64335, '\p{Block: arabicpresentationformsa}', ""); +Expect(1, 64335, '\p{^Block: arabicpresentationformsa}', ""); +Expect(1, 64335, '\P{Block: arabicpresentationformsa}', ""); +Expect(0, 64335, '\P{^Block: arabicpresentationformsa}', ""); +Expect(1, 65023, '\p{Block= arabic-Presentation_Forms A}', ""); +Expect(0, 65023, '\p{^Block= arabic-Presentation_Forms A}', ""); +Expect(0, 65023, '\P{Block= arabic-Presentation_Forms A}', ""); +Expect(1, 65023, '\P{^Block= arabic-Presentation_Forms A}', ""); +Expect(0, 64335, '\p{Block= arabic-Presentation_Forms A}', ""); +Expect(1, 64335, '\p{^Block= arabic-Presentation_Forms A}', ""); +Expect(1, 64335, '\P{Block= arabic-Presentation_Forms A}', ""); +Expect(0, 64335, '\P{^Block= arabic-Presentation_Forms A}', ""); +Error('\p{Blk=-/a/ARABIC PRESENTATION-FormsA}'); +Error('\P{Blk=-/a/ARABIC PRESENTATION-FormsA}'); +Expect(1, 65023, '\p{Blk=arabicpresentationformsa}', ""); +Expect(0, 65023, '\p{^Blk=arabicpresentationformsa}', ""); +Expect(0, 65023, '\P{Blk=arabicpresentationformsa}', ""); +Expect(1, 65023, '\P{^Blk=arabicpresentationformsa}', ""); +Expect(0, 64335, '\p{Blk=arabicpresentationformsa}', ""); +Expect(1, 64335, '\p{^Blk=arabicpresentationformsa}', ""); +Expect(1, 64335, '\P{Blk=arabicpresentationformsa}', ""); +Expect(0, 64335, '\P{^Blk=arabicpresentationformsa}', ""); +Expect(1, 65023, '\p{Blk: - Arabic presentation-forms_A}', ""); +Expect(0, 65023, '\p{^Blk: - Arabic presentation-forms_A}', ""); +Expect(0, 65023, '\P{Blk: - Arabic presentation-forms_A}', ""); +Expect(1, 65023, '\P{^Blk: - Arabic presentation-forms_A}', ""); +Expect(0, 64335, '\p{Blk: - Arabic presentation-forms_A}', ""); +Expect(1, 64335, '\p{^Blk: - Arabic presentation-forms_A}', ""); +Expect(1, 64335, '\P{Blk: - Arabic presentation-forms_A}', ""); +Expect(0, 64335, '\P{^Blk: - Arabic presentation-forms_A}', ""); +Error('\p{Is_Block=_Arabic/a/PresentationFORMS-A}'); +Error('\P{Is_Block=_Arabic/a/PresentationFORMS-A}'); +Expect(1, 65023, '\p{Is_Block=arabicpresentationformsa}', ""); +Expect(0, 65023, '\p{^Is_Block=arabicpresentationformsa}', ""); +Expect(0, 65023, '\P{Is_Block=arabicpresentationformsa}', ""); +Expect(1, 65023, '\P{^Is_Block=arabicpresentationformsa}', ""); +Expect(0, 64335, '\p{Is_Block=arabicpresentationformsa}', ""); +Expect(1, 64335, '\p{^Is_Block=arabicpresentationformsa}', ""); +Expect(1, 64335, '\P{Is_Block=arabicpresentationformsa}', ""); +Expect(0, 64335, '\P{^Is_Block=arabicpresentationformsa}', ""); +Expect(1, 65023, '\p{Is_Block=_ Arabic_Presentation-FormsA}', ""); +Expect(0, 65023, '\p{^Is_Block=_ Arabic_Presentation-FormsA}', ""); +Expect(0, 65023, '\P{Is_Block=_ Arabic_Presentation-FormsA}', ""); +Expect(1, 65023, '\P{^Is_Block=_ Arabic_Presentation-FormsA}', ""); +Expect(0, 64335, '\p{Is_Block=_ Arabic_Presentation-FormsA}', ""); +Expect(1, 64335, '\p{^Is_Block=_ Arabic_Presentation-FormsA}', ""); +Expect(1, 64335, '\P{Is_Block=_ Arabic_Presentation-FormsA}', ""); +Expect(0, 64335, '\P{^Is_Block=_ Arabic_Presentation-FormsA}', ""); +Error('\p{Is_Blk=-:=Arabic Presentation_FormsA}'); +Error('\P{Is_Blk=-:=Arabic Presentation_FormsA}'); +Expect(1, 65023, '\p{Is_Blk: arabicpresentationformsa}', ""); +Expect(0, 65023, '\p{^Is_Blk: arabicpresentationformsa}', ""); +Expect(0, 65023, '\P{Is_Blk: arabicpresentationformsa}', ""); +Expect(1, 65023, '\P{^Is_Blk: arabicpresentationformsa}', ""); +Expect(0, 64335, '\p{Is_Blk: arabicpresentationformsa}', ""); +Expect(1, 64335, '\p{^Is_Blk: arabicpresentationformsa}', ""); +Expect(1, 64335, '\P{Is_Blk: arabicpresentationformsa}', ""); +Expect(0, 64335, '\P{^Is_Blk: arabicpresentationformsa}', ""); +Expect(1, 65023, '\p{Is_Blk= arabic Presentation_FORMS-A}', ""); +Expect(0, 65023, '\p{^Is_Blk= arabic Presentation_FORMS-A}', ""); +Expect(0, 65023, '\P{Is_Blk= arabic Presentation_FORMS-A}', ""); +Expect(1, 65023, '\P{^Is_Blk= arabic Presentation_FORMS-A}', ""); +Expect(0, 64335, '\p{Is_Blk= arabic Presentation_FORMS-A}', ""); +Expect(1, 64335, '\p{^Is_Blk= arabic Presentation_FORMS-A}', ""); +Expect(1, 64335, '\P{Is_Blk= arabic Presentation_FORMS-A}', ""); +Expect(0, 64335, '\P{^Is_Blk= arabic Presentation_FORMS-A}', ""); +Error('\p{Block=--tai-LE:=}'); +Error('\P{Block=--tai-LE:=}'); +Expect(1, 6527, '\p{Block=taile}', ""); +Expect(0, 6527, '\p{^Block=taile}', ""); +Expect(0, 6527, '\P{Block=taile}', ""); +Expect(1, 6527, '\P{^Block=taile}', ""); +Expect(0, 6479, '\p{Block=taile}', ""); +Expect(1, 6479, '\p{^Block=taile}', ""); +Expect(1, 6479, '\P{Block=taile}', ""); +Expect(0, 6479, '\P{^Block=taile}', ""); +Expect(1, 6527, '\p{Block= TAI-Le}', ""); +Expect(0, 6527, '\p{^Block= TAI-Le}', ""); +Expect(0, 6527, '\P{Block= TAI-Le}', ""); +Expect(1, 6527, '\P{^Block= TAI-Le}', ""); +Expect(0, 6479, '\p{Block= TAI-Le}', ""); +Expect(1, 6479, '\p{^Block= TAI-Le}', ""); +Expect(1, 6479, '\P{Block= TAI-Le}', ""); +Expect(0, 6479, '\P{^Block= TAI-Le}', ""); +Error('\p{Blk= TAI/a/Le}'); +Error('\P{Blk= TAI/a/Le}'); +Expect(1, 6527, '\p{Blk=taile}', ""); +Expect(0, 6527, '\p{^Blk=taile}', ""); +Expect(0, 6527, '\P{Blk=taile}', ""); +Expect(1, 6527, '\P{^Blk=taile}', ""); +Expect(0, 6479, '\p{Blk=taile}', ""); +Expect(1, 6479, '\p{^Blk=taile}', ""); +Expect(1, 6479, '\P{Blk=taile}', ""); +Expect(0, 6479, '\P{^Blk=taile}', ""); +Expect(1, 6527, '\p{Blk=--Tai_le}', ""); +Expect(0, 6527, '\p{^Blk=--Tai_le}', ""); +Expect(0, 6527, '\P{Blk=--Tai_le}', ""); +Expect(1, 6527, '\P{^Blk=--Tai_le}', ""); +Expect(0, 6479, '\p{Blk=--Tai_le}', ""); +Expect(1, 6479, '\p{^Blk=--Tai_le}', ""); +Expect(1, 6479, '\P{Blk=--Tai_le}', ""); +Expect(0, 6479, '\P{^Blk=--Tai_le}', ""); +Error('\p{Is_Block=:=tai LE}'); +Error('\P{Is_Block=:=tai LE}'); +Expect(1, 6527, '\p{Is_Block=taile}', ""); +Expect(0, 6527, '\p{^Is_Block=taile}', ""); +Expect(0, 6527, '\P{Is_Block=taile}', ""); +Expect(1, 6527, '\P{^Is_Block=taile}', ""); +Expect(0, 6479, '\p{Is_Block=taile}', ""); +Expect(1, 6479, '\p{^Is_Block=taile}', ""); +Expect(1, 6479, '\P{Is_Block=taile}', ""); +Expect(0, 6479, '\P{^Is_Block=taile}', ""); +Expect(1, 6527, '\p{Is_Block=_Tai Le}', ""); +Expect(0, 6527, '\p{^Is_Block=_Tai Le}', ""); +Expect(0, 6527, '\P{Is_Block=_Tai Le}', ""); +Expect(1, 6527, '\P{^Is_Block=_Tai Le}', ""); +Expect(0, 6479, '\p{Is_Block=_Tai Le}', ""); +Expect(1, 6479, '\p{^Is_Block=_Tai Le}', ""); +Expect(1, 6479, '\P{Is_Block=_Tai Le}', ""); +Expect(0, 6479, '\P{^Is_Block=_Tai Le}', ""); +Error('\p{Is_Blk=:=--tai Le}'); +Error('\P{Is_Blk=:=--tai Le}'); +Expect(1, 6527, '\p{Is_Blk=taile}', ""); +Expect(0, 6527, '\p{^Is_Blk=taile}', ""); +Expect(0, 6527, '\P{Is_Blk=taile}', ""); +Expect(1, 6527, '\P{^Is_Blk=taile}', ""); +Expect(0, 6479, '\p{Is_Blk=taile}', ""); +Expect(1, 6479, '\p{^Is_Blk=taile}', ""); +Expect(1, 6479, '\P{Is_Blk=taile}', ""); +Expect(0, 6479, '\P{^Is_Blk=taile}', ""); +Expect(1, 6527, '\p{Is_Blk: -Tai LE}', ""); +Expect(0, 6527, '\p{^Is_Blk: -Tai LE}', ""); +Expect(0, 6527, '\P{Is_Blk: -Tai LE}', ""); +Expect(1, 6527, '\P{^Is_Blk: -Tai LE}', ""); +Expect(0, 6479, '\p{Is_Blk: -Tai LE}', ""); +Expect(1, 6479, '\p{^Is_Blk: -Tai LE}', ""); +Expect(1, 6479, '\P{Is_Blk: -Tai LE}', ""); +Expect(0, 6479, '\P{^Is_Blk: -Tai LE}', ""); +Error('\p{Block=:= Combining Diacritical MARKS}'); +Error('\P{Block=:= Combining Diacritical MARKS}'); +Expect(1, 879, '\p{Block=combiningdiacriticalmarks}', ""); +Expect(0, 879, '\p{^Block=combiningdiacriticalmarks}', ""); +Expect(0, 879, '\P{Block=combiningdiacriticalmarks}', ""); +Expect(1, 879, '\P{^Block=combiningdiacriticalmarks}', ""); +Expect(0, 767, '\p{Block=combiningdiacriticalmarks}', ""); +Expect(1, 767, '\p{^Block=combiningdiacriticalmarks}', ""); +Expect(1, 767, '\P{Block=combiningdiacriticalmarks}', ""); +Expect(0, 767, '\P{^Block=combiningdiacriticalmarks}', ""); +Expect(1, 879, '\p{Block: -Combining-Diacritical_MARKS}', ""); +Expect(0, 879, '\p{^Block: -Combining-Diacritical_MARKS}', ""); +Expect(0, 879, '\P{Block: -Combining-Diacritical_MARKS}', ""); +Expect(1, 879, '\P{^Block: -Combining-Diacritical_MARKS}', ""); +Expect(0, 767, '\p{Block: -Combining-Diacritical_MARKS}', ""); +Expect(1, 767, '\p{^Block: -Combining-Diacritical_MARKS}', ""); +Expect(1, 767, '\P{Block: -Combining-Diacritical_MARKS}', ""); +Expect(0, 767, '\P{^Block: -Combining-Diacritical_MARKS}', ""); +Error('\p{Blk=/a/ Combining DiacriticalMARKS}'); +Error('\P{Blk=/a/ Combining DiacriticalMARKS}'); +Expect(1, 879, '\p{Blk=combiningdiacriticalmarks}', ""); +Expect(0, 879, '\p{^Blk=combiningdiacriticalmarks}', ""); +Expect(0, 879, '\P{Blk=combiningdiacriticalmarks}', ""); +Expect(1, 879, '\P{^Blk=combiningdiacriticalmarks}', ""); +Expect(0, 767, '\p{Blk=combiningdiacriticalmarks}', ""); +Expect(1, 767, '\p{^Blk=combiningdiacriticalmarks}', ""); +Expect(1, 767, '\P{Blk=combiningdiacriticalmarks}', ""); +Expect(0, 767, '\P{^Blk=combiningdiacriticalmarks}', ""); +Expect(1, 879, '\p{Blk=_combining-diacritical-Marks}', ""); +Expect(0, 879, '\p{^Blk=_combining-diacritical-Marks}', ""); +Expect(0, 879, '\P{Blk=_combining-diacritical-Marks}', ""); +Expect(1, 879, '\P{^Blk=_combining-diacritical-Marks}', ""); +Expect(0, 767, '\p{Blk=_combining-diacritical-Marks}', ""); +Expect(1, 767, '\p{^Blk=_combining-diacritical-Marks}', ""); +Expect(1, 767, '\P{Blk=_combining-diacritical-Marks}', ""); +Expect(0, 767, '\P{^Blk=_combining-diacritical-Marks}', ""); +Error('\p{Is_Block= Combining diacriticalMarks/a/}'); +Error('\P{Is_Block= Combining diacriticalMarks/a/}'); +Expect(1, 879, '\p{Is_Block=combiningdiacriticalmarks}', ""); +Expect(0, 879, '\p{^Is_Block=combiningdiacriticalmarks}', ""); +Expect(0, 879, '\P{Is_Block=combiningdiacriticalmarks}', ""); +Expect(1, 879, '\P{^Is_Block=combiningdiacriticalmarks}', ""); +Expect(0, 767, '\p{Is_Block=combiningdiacriticalmarks}', ""); +Expect(1, 767, '\p{^Is_Block=combiningdiacriticalmarks}', ""); +Expect(1, 767, '\P{Is_Block=combiningdiacriticalmarks}', ""); +Expect(0, 767, '\P{^Is_Block=combiningdiacriticalmarks}', ""); +Expect(1, 879, '\p{Is_Block=_-Combining DIACRITICALMarks}', ""); +Expect(0, 879, '\p{^Is_Block=_-Combining DIACRITICALMarks}', ""); +Expect(0, 879, '\P{Is_Block=_-Combining DIACRITICALMarks}', ""); +Expect(1, 879, '\P{^Is_Block=_-Combining DIACRITICALMarks}', ""); +Expect(0, 767, '\p{Is_Block=_-Combining DIACRITICALMarks}', ""); +Expect(1, 767, '\p{^Is_Block=_-Combining DIACRITICALMarks}', ""); +Expect(1, 767, '\P{Is_Block=_-Combining DIACRITICALMarks}', ""); +Expect(0, 767, '\P{^Is_Block=_-Combining DIACRITICALMarks}', ""); +Error('\p{Is_Blk= _COMBINING:=DIACRITICAL-Marks}'); +Error('\P{Is_Blk= _COMBINING:=DIACRITICAL-Marks}'); +Expect(1, 879, '\p{Is_Blk=combiningdiacriticalmarks}', ""); +Expect(0, 879, '\p{^Is_Blk=combiningdiacriticalmarks}', ""); +Expect(0, 879, '\P{Is_Blk=combiningdiacriticalmarks}', ""); +Expect(1, 879, '\P{^Is_Blk=combiningdiacriticalmarks}', ""); +Expect(0, 767, '\p{Is_Blk=combiningdiacriticalmarks}', ""); +Expect(1, 767, '\p{^Is_Blk=combiningdiacriticalmarks}', ""); +Expect(1, 767, '\P{Is_Blk=combiningdiacriticalmarks}', ""); +Expect(0, 767, '\P{^Is_Blk=combiningdiacriticalmarks}', ""); +Expect(1, 879, '\p{Is_Blk: -Combining diacritical Marks}', ""); +Expect(0, 879, '\p{^Is_Blk: -Combining diacritical Marks}', ""); +Expect(0, 879, '\P{Is_Blk: -Combining diacritical Marks}', ""); +Expect(1, 879, '\P{^Is_Blk: -Combining diacritical Marks}', ""); +Expect(0, 767, '\p{Is_Blk: -Combining diacritical Marks}', ""); +Expect(1, 767, '\p{^Is_Blk: -Combining diacritical Marks}', ""); +Expect(1, 767, '\P{Is_Blk: -Combining diacritical Marks}', ""); +Expect(0, 767, '\P{^Is_Blk: -Combining diacritical Marks}', ""); +Error('\p{Block=__LatinExtended/a/B}'); +Error('\P{Block=__LatinExtended/a/B}'); +Expect(1, 591, '\p{Block=latinextendedb}', ""); +Expect(0, 591, '\p{^Block=latinextendedb}', ""); +Expect(0, 591, '\P{Block=latinextendedb}', ""); +Expect(1, 591, '\P{^Block=latinextendedb}', ""); +Expect(0, 383, '\p{Block=latinextendedb}', ""); +Expect(1, 383, '\p{^Block=latinextendedb}', ""); +Expect(1, 383, '\P{Block=latinextendedb}', ""); +Expect(0, 383, '\P{^Block=latinextendedb}', ""); +Expect(1, 591, '\p{Block=__Latinextended-b}', ""); +Expect(0, 591, '\p{^Block=__Latinextended-b}', ""); +Expect(0, 591, '\P{Block=__Latinextended-b}', ""); +Expect(1, 591, '\P{^Block=__Latinextended-b}', ""); +Expect(0, 383, '\p{Block=__Latinextended-b}', ""); +Expect(1, 383, '\p{^Block=__Latinextended-b}', ""); +Expect(1, 383, '\P{Block=__Latinextended-b}', ""); +Expect(0, 383, '\P{^Block=__Latinextended-b}', ""); +Error('\p{Blk= Latin:=extended-B}'); +Error('\P{Blk= Latin:=extended-B}'); +Expect(1, 591, '\p{Blk=latinextendedb}', ""); +Expect(0, 591, '\p{^Blk=latinextendedb}', ""); +Expect(0, 591, '\P{Blk=latinextendedb}', ""); +Expect(1, 591, '\P{^Blk=latinextendedb}', ""); +Expect(0, 383, '\p{Blk=latinextendedb}', ""); +Expect(1, 383, '\p{^Blk=latinextendedb}', ""); +Expect(1, 383, '\P{Blk=latinextendedb}', ""); +Expect(0, 383, '\P{^Blk=latinextendedb}', ""); +Expect(1, 591, '\p{Blk= -LATIN_Extended B}', ""); +Expect(0, 591, '\p{^Blk= -LATIN_Extended B}', ""); +Expect(0, 591, '\P{Blk= -LATIN_Extended B}', ""); +Expect(1, 591, '\P{^Blk= -LATIN_Extended B}', ""); +Expect(0, 383, '\p{Blk= -LATIN_Extended B}', ""); +Expect(1, 383, '\p{^Blk= -LATIN_Extended B}', ""); +Expect(1, 383, '\P{Blk= -LATIN_Extended B}', ""); +Expect(0, 383, '\P{^Blk= -LATIN_Extended B}', ""); +Error('\p{Is_Block= -LATIN_ExtendedB:=}'); +Error('\P{Is_Block= -LATIN_ExtendedB:=}'); +Expect(1, 591, '\p{Is_Block=latinextendedb}', ""); +Expect(0, 591, '\p{^Is_Block=latinextendedb}', ""); +Expect(0, 591, '\P{Is_Block=latinextendedb}', ""); +Expect(1, 591, '\P{^Is_Block=latinextendedb}', ""); +Expect(0, 383, '\p{Is_Block=latinextendedb}', ""); +Expect(1, 383, '\p{^Is_Block=latinextendedb}', ""); +Expect(1, 383, '\P{Is_Block=latinextendedb}', ""); +Expect(0, 383, '\P{^Is_Block=latinextendedb}', ""); +Expect(1, 591, '\p{Is_Block=_ LATIN extended-B}', ""); +Expect(0, 591, '\p{^Is_Block=_ LATIN extended-B}', ""); +Expect(0, 591, '\P{Is_Block=_ LATIN extended-B}', ""); +Expect(1, 591, '\P{^Is_Block=_ LATIN extended-B}', ""); +Expect(0, 383, '\p{Is_Block=_ LATIN extended-B}', ""); +Expect(1, 383, '\p{^Is_Block=_ LATIN extended-B}', ""); +Expect(1, 383, '\P{Is_Block=_ LATIN extended-B}', ""); +Expect(0, 383, '\P{^Is_Block=_ LATIN extended-B}', ""); +Error('\p{Is_Blk=_Latin:=Extendedb}'); +Error('\P{Is_Blk=_Latin:=Extendedb}'); +Expect(1, 591, '\p{Is_Blk=latinextendedb}', ""); +Expect(0, 591, '\p{^Is_Blk=latinextendedb}', ""); +Expect(0, 591, '\P{Is_Blk=latinextendedb}', ""); +Expect(1, 591, '\P{^Is_Blk=latinextendedb}', ""); +Expect(0, 383, '\p{Is_Blk=latinextendedb}', ""); +Expect(1, 383, '\p{^Is_Blk=latinextendedb}', ""); +Expect(1, 383, '\P{Is_Blk=latinextendedb}', ""); +Expect(0, 383, '\P{^Is_Blk=latinextendedb}', ""); +Expect(1, 591, '\p{Is_Blk: _latin-Extended_B}', ""); +Expect(0, 591, '\p{^Is_Blk: _latin-Extended_B}', ""); +Expect(0, 591, '\P{Is_Blk: _latin-Extended_B}', ""); +Expect(1, 591, '\P{^Is_Blk: _latin-Extended_B}', ""); +Expect(0, 383, '\p{Is_Blk: _latin-Extended_B}', ""); +Expect(1, 383, '\p{^Is_Blk: _latin-Extended_B}', ""); +Expect(1, 383, '\P{Is_Blk: _latin-Extended_B}', ""); +Expect(0, 383, '\P{^Is_Blk: _latin-Extended_B}', ""); +Error('\p{Block= SUPPLEMENTAL-Arrows A:=}'); +Error('\P{Block= SUPPLEMENTAL-Arrows A:=}'); +Expect(1, 10239, '\p{Block=supplementalarrowsa}', ""); +Expect(0, 10239, '\p{^Block=supplementalarrowsa}', ""); +Expect(0, 10239, '\P{Block=supplementalarrowsa}', ""); +Expect(1, 10239, '\P{^Block=supplementalarrowsa}', ""); +Expect(0, 10223, '\p{Block=supplementalarrowsa}', ""); +Expect(1, 10223, '\p{^Block=supplementalarrowsa}', ""); +Expect(1, 10223, '\P{Block=supplementalarrowsa}', ""); +Expect(0, 10223, '\P{^Block=supplementalarrowsa}', ""); +Expect(1, 10239, '\p{Block=_Supplemental Arrows A}', ""); +Expect(0, 10239, '\p{^Block=_Supplemental Arrows A}', ""); +Expect(0, 10239, '\P{Block=_Supplemental Arrows A}', ""); +Expect(1, 10239, '\P{^Block=_Supplemental Arrows A}', ""); +Expect(0, 10223, '\p{Block=_Supplemental Arrows A}', ""); +Expect(1, 10223, '\p{^Block=_Supplemental Arrows A}', ""); +Expect(1, 10223, '\P{Block=_Supplemental Arrows A}', ""); +Expect(0, 10223, '\P{^Block=_Supplemental Arrows A}', ""); +Error('\p{Blk=_:=supplemental_ARROWS a}'); +Error('\P{Blk=_:=supplemental_ARROWS a}'); +Expect(1, 10239, '\p{Blk:supplementalarrowsa}', ""); +Expect(0, 10239, '\p{^Blk:supplementalarrowsa}', ""); +Expect(0, 10239, '\P{Blk:supplementalarrowsa}', ""); +Expect(1, 10239, '\P{^Blk:supplementalarrowsa}', ""); +Expect(0, 10223, '\p{Blk:supplementalarrowsa}', ""); +Expect(1, 10223, '\p{^Blk:supplementalarrowsa}', ""); +Expect(1, 10223, '\P{Blk:supplementalarrowsa}', ""); +Expect(0, 10223, '\P{^Blk:supplementalarrowsa}', ""); +Expect(1, 10239, '\p{Blk: -_SUPPLEMENTAL-ArrowsA}', ""); +Expect(0, 10239, '\p{^Blk: -_SUPPLEMENTAL-ArrowsA}', ""); +Expect(0, 10239, '\P{Blk: -_SUPPLEMENTAL-ArrowsA}', ""); +Expect(1, 10239, '\P{^Blk: -_SUPPLEMENTAL-ArrowsA}', ""); +Expect(0, 10223, '\p{Blk: -_SUPPLEMENTAL-ArrowsA}', ""); +Expect(1, 10223, '\p{^Blk: -_SUPPLEMENTAL-ArrowsA}', ""); +Expect(1, 10223, '\P{Blk: -_SUPPLEMENTAL-ArrowsA}', ""); +Expect(0, 10223, '\P{^Blk: -_SUPPLEMENTAL-ArrowsA}', ""); +Error('\p{Is_Block=_:=supplemental Arrows A}'); +Error('\P{Is_Block=_:=supplemental Arrows A}'); +Expect(1, 10239, '\p{Is_Block=supplementalarrowsa}', ""); +Expect(0, 10239, '\p{^Is_Block=supplementalarrowsa}', ""); +Expect(0, 10239, '\P{Is_Block=supplementalarrowsa}', ""); +Expect(1, 10239, '\P{^Is_Block=supplementalarrowsa}', ""); +Expect(0, 10223, '\p{Is_Block=supplementalarrowsa}', ""); +Expect(1, 10223, '\p{^Is_Block=supplementalarrowsa}', ""); +Expect(1, 10223, '\P{Is_Block=supplementalarrowsa}', ""); +Expect(0, 10223, '\P{^Is_Block=supplementalarrowsa}', ""); +Expect(1, 10239, '\p{Is_Block= Supplemental_Arrows A}', ""); +Expect(0, 10239, '\p{^Is_Block= Supplemental_Arrows A}', ""); +Expect(0, 10239, '\P{Is_Block= Supplemental_Arrows A}', ""); +Expect(1, 10239, '\P{^Is_Block= Supplemental_Arrows A}', ""); +Expect(0, 10223, '\p{Is_Block= Supplemental_Arrows A}', ""); +Expect(1, 10223, '\p{^Is_Block= Supplemental_Arrows A}', ""); +Expect(1, 10223, '\P{Is_Block= Supplemental_Arrows A}', ""); +Expect(0, 10223, '\P{^Is_Block= Supplemental_Arrows A}', ""); +Error('\p{Is_Blk: :=-_Supplemental_arrowsA}'); +Error('\P{Is_Blk: :=-_Supplemental_arrowsA}'); +Expect(1, 10239, '\p{Is_Blk=supplementalarrowsa}', ""); +Expect(0, 10239, '\p{^Is_Blk=supplementalarrowsa}', ""); +Expect(0, 10239, '\P{Is_Blk=supplementalarrowsa}', ""); +Expect(1, 10239, '\P{^Is_Blk=supplementalarrowsa}', ""); +Expect(0, 10223, '\p{Is_Blk=supplementalarrowsa}', ""); +Expect(1, 10223, '\p{^Is_Blk=supplementalarrowsa}', ""); +Expect(1, 10223, '\P{Is_Blk=supplementalarrowsa}', ""); +Expect(0, 10223, '\P{^Is_Blk=supplementalarrowsa}', ""); +Expect(1, 10239, '\p{Is_Blk=_-supplemental_Arrows A}', ""); +Expect(0, 10239, '\p{^Is_Blk=_-supplemental_Arrows A}', ""); +Expect(0, 10239, '\P{Is_Blk=_-supplemental_Arrows A}', ""); +Expect(1, 10239, '\P{^Is_Blk=_-supplemental_Arrows A}', ""); +Expect(0, 10223, '\p{Is_Blk=_-supplemental_Arrows A}', ""); +Expect(1, 10223, '\p{^Is_Blk=_-supplemental_Arrows A}', ""); +Expect(1, 10223, '\P{Is_Blk=_-supplemental_Arrows A}', ""); +Expect(0, 10223, '\P{^Is_Blk=_-supplemental_Arrows A}', ""); +Error('\p{Block= :=Supplementary PRIVATE Use-Area-A}'); +Error('\P{Block= :=Supplementary PRIVATE Use-Area-A}'); +Expect(1, 983040, '\p{Block=supplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\p{^Block=supplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\P{Block=supplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\P{^Block=supplementaryprivateuseareaa}', ""); +Expect(0, 7, '\p{Block=supplementaryprivateuseareaa}', ""); +Expect(1, 7, '\p{^Block=supplementaryprivateuseareaa}', ""); +Expect(1, 7, '\P{Block=supplementaryprivateuseareaa}', ""); +Expect(0, 7, '\P{^Block=supplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\p{Block: _supplementary_Private USE Area-A}', ""); +Expect(0, 983040, '\p{^Block: _supplementary_Private USE Area-A}', ""); +Expect(0, 983040, '\P{Block: _supplementary_Private USE Area-A}', ""); +Expect(1, 983040, '\P{^Block: _supplementary_Private USE Area-A}', ""); +Expect(0, 7, '\p{Block: _supplementary_Private USE Area-A}', ""); +Expect(1, 7, '\p{^Block: _supplementary_Private USE Area-A}', ""); +Expect(1, 7, '\P{Block: _supplementary_Private USE Area-A}', ""); +Expect(0, 7, '\P{^Block: _supplementary_Private USE Area-A}', ""); +Error('\p{Blk= SUPPLEMENTARY-private USE_Area a:=}'); +Error('\P{Blk= SUPPLEMENTARY-private USE_Area a:=}'); +Expect(1, 983040, '\p{Blk=supplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\p{^Blk=supplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\P{Blk=supplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\P{^Blk=supplementaryprivateuseareaa}', ""); +Expect(0, 7, '\p{Blk=supplementaryprivateuseareaa}', ""); +Expect(1, 7, '\p{^Blk=supplementaryprivateuseareaa}', ""); +Expect(1, 7, '\P{Blk=supplementaryprivateuseareaa}', ""); +Expect(0, 7, '\P{^Blk=supplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\p{Blk=_ SUPPLEMENTARY private use area-A}', ""); +Expect(0, 983040, '\p{^Blk=_ SUPPLEMENTARY private use area-A}', ""); +Expect(0, 983040, '\P{Blk=_ SUPPLEMENTARY private use area-A}', ""); +Expect(1, 983040, '\P{^Blk=_ SUPPLEMENTARY private use area-A}', ""); +Expect(0, 7, '\p{Blk=_ SUPPLEMENTARY private use area-A}', ""); +Expect(1, 7, '\p{^Blk=_ SUPPLEMENTARY private use area-A}', ""); +Expect(1, 7, '\P{Blk=_ SUPPLEMENTARY private use area-A}', ""); +Expect(0, 7, '\P{^Blk=_ SUPPLEMENTARY private use area-A}', ""); +Error('\p{Is_Block=/a/Supplementary Private Use_area A}'); +Error('\P{Is_Block=/a/Supplementary Private Use_area A}'); +Expect(1, 983040, '\p{Is_Block=supplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\p{^Is_Block=supplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\P{Is_Block=supplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\P{^Is_Block=supplementaryprivateuseareaa}', ""); +Expect(0, 7, '\p{Is_Block=supplementaryprivateuseareaa}', ""); +Expect(1, 7, '\p{^Is_Block=supplementaryprivateuseareaa}', ""); +Expect(1, 7, '\P{Is_Block=supplementaryprivateuseareaa}', ""); +Expect(0, 7, '\P{^Is_Block=supplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\p{Is_Block= -supplementary Private_Use area a}', ""); +Expect(0, 983040, '\p{^Is_Block= -supplementary Private_Use area a}', ""); +Expect(0, 983040, '\P{Is_Block= -supplementary Private_Use area a}', ""); +Expect(1, 983040, '\P{^Is_Block= -supplementary Private_Use area a}', ""); +Expect(0, 7, '\p{Is_Block= -supplementary Private_Use area a}', ""); +Expect(1, 7, '\p{^Is_Block= -supplementary Private_Use area a}', ""); +Expect(1, 7, '\P{Is_Block= -supplementary Private_Use area a}', ""); +Expect(0, 7, '\P{^Is_Block= -supplementary Private_Use area a}', ""); +Error('\p{Is_Blk=_/a/Supplementary_PRIVATE use_Area-A}'); +Error('\P{Is_Blk=_/a/Supplementary_PRIVATE use_Area-A}'); +Expect(1, 983040, '\p{Is_Blk=supplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\p{^Is_Blk=supplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\P{Is_Blk=supplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\P{^Is_Blk=supplementaryprivateuseareaa}', ""); +Expect(0, 7, '\p{Is_Blk=supplementaryprivateuseareaa}', ""); +Expect(1, 7, '\p{^Is_Blk=supplementaryprivateuseareaa}', ""); +Expect(1, 7, '\P{Is_Blk=supplementaryprivateuseareaa}', ""); +Expect(0, 7, '\P{^Is_Blk=supplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\p{Is_Blk=Supplementary-PRIVATE_UseAREAA}', ""); +Expect(0, 983040, '\p{^Is_Blk=Supplementary-PRIVATE_UseAREAA}', ""); +Expect(0, 983040, '\P{Is_Blk=Supplementary-PRIVATE_UseAREAA}', ""); +Expect(1, 983040, '\P{^Is_Blk=Supplementary-PRIVATE_UseAREAA}', ""); +Expect(0, 7, '\p{Is_Blk=Supplementary-PRIVATE_UseAREAA}', ""); +Expect(1, 7, '\p{^Is_Blk=Supplementary-PRIVATE_UseAREAA}', ""); +Expect(1, 7, '\P{Is_Blk=Supplementary-PRIVATE_UseAREAA}', ""); +Expect(0, 7, '\P{^Is_Blk=Supplementary-PRIVATE_UseAREAA}', ""); +Error('\p{Block=:=-_Hanunoo}'); +Error('\P{Block=:=-_Hanunoo}'); +Expect(1, 5951, '\p{Block=hanunoo}', ""); +Expect(0, 5951, '\p{^Block=hanunoo}', ""); +Expect(0, 5951, '\P{Block=hanunoo}', ""); +Expect(1, 5951, '\P{^Block=hanunoo}', ""); +Expect(0, 5919, '\p{Block=hanunoo}', ""); +Expect(1, 5919, '\p{^Block=hanunoo}', ""); +Expect(1, 5919, '\P{Block=hanunoo}', ""); +Expect(0, 5919, '\P{^Block=hanunoo}', ""); +Expect(1, 5951, '\p{Block=_ Hanunoo}', ""); +Expect(0, 5951, '\p{^Block=_ Hanunoo}', ""); +Expect(0, 5951, '\P{Block=_ Hanunoo}', ""); +Expect(1, 5951, '\P{^Block=_ Hanunoo}', ""); +Expect(0, 5919, '\p{Block=_ Hanunoo}', ""); +Expect(1, 5919, '\p{^Block=_ Hanunoo}', ""); +Expect(1, 5919, '\P{Block=_ Hanunoo}', ""); +Expect(0, 5919, '\P{^Block=_ Hanunoo}', ""); +Error('\p{Blk=/a/_HANUNOO}'); +Error('\P{Blk=/a/_HANUNOO}'); +Expect(1, 5951, '\p{Blk: hanunoo}', ""); +Expect(0, 5951, '\p{^Blk: hanunoo}', ""); +Expect(0, 5951, '\P{Blk: hanunoo}', ""); +Expect(1, 5951, '\P{^Blk: hanunoo}', ""); +Expect(0, 5919, '\p{Blk: hanunoo}', ""); +Expect(1, 5919, '\p{^Blk: hanunoo}', ""); +Expect(1, 5919, '\P{Blk: hanunoo}', ""); +Expect(0, 5919, '\P{^Blk: hanunoo}', ""); +Expect(1, 5951, '\p{Blk= Hanunoo}', ""); +Expect(0, 5951, '\p{^Blk= Hanunoo}', ""); +Expect(0, 5951, '\P{Blk= Hanunoo}', ""); +Expect(1, 5951, '\P{^Blk= Hanunoo}', ""); +Expect(0, 5919, '\p{Blk= Hanunoo}', ""); +Expect(1, 5919, '\p{^Blk= Hanunoo}', ""); +Expect(1, 5919, '\P{Blk= Hanunoo}', ""); +Expect(0, 5919, '\P{^Blk= Hanunoo}', ""); +Error('\p{Is_Block: _HANUNOO/a/}'); +Error('\P{Is_Block: _HANUNOO/a/}'); +Expect(1, 5951, '\p{Is_Block=hanunoo}', ""); +Expect(0, 5951, '\p{^Is_Block=hanunoo}', ""); +Expect(0, 5951, '\P{Is_Block=hanunoo}', ""); +Expect(1, 5951, '\P{^Is_Block=hanunoo}', ""); +Expect(0, 5919, '\p{Is_Block=hanunoo}', ""); +Expect(1, 5919, '\p{^Is_Block=hanunoo}', ""); +Expect(1, 5919, '\P{Is_Block=hanunoo}', ""); +Expect(0, 5919, '\P{^Is_Block=hanunoo}', ""); +Expect(1, 5951, '\p{Is_Block= hanunoo}', ""); +Expect(0, 5951, '\p{^Is_Block= hanunoo}', ""); +Expect(0, 5951, '\P{Is_Block= hanunoo}', ""); +Expect(1, 5951, '\P{^Is_Block= hanunoo}', ""); +Expect(0, 5919, '\p{Is_Block= hanunoo}', ""); +Expect(1, 5919, '\p{^Is_Block= hanunoo}', ""); +Expect(1, 5919, '\P{Is_Block= hanunoo}', ""); +Expect(0, 5919, '\P{^Is_Block= hanunoo}', ""); +Error('\p{Is_Blk=:=Hanunoo}'); +Error('\P{Is_Blk=:=Hanunoo}'); +Expect(1, 5951, '\p{Is_Blk=hanunoo}', ""); +Expect(0, 5951, '\p{^Is_Blk=hanunoo}', ""); +Expect(0, 5951, '\P{Is_Blk=hanunoo}', ""); +Expect(1, 5951, '\P{^Is_Blk=hanunoo}', ""); +Expect(0, 5919, '\p{Is_Blk=hanunoo}', ""); +Expect(1, 5919, '\p{^Is_Blk=hanunoo}', ""); +Expect(1, 5919, '\P{Is_Blk=hanunoo}', ""); +Expect(0, 5919, '\P{^Is_Blk=hanunoo}', ""); +Expect(1, 5951, '\p{Is_Blk= HANUNOO}', ""); +Expect(0, 5951, '\p{^Is_Blk= HANUNOO}', ""); +Expect(0, 5951, '\P{Is_Blk= HANUNOO}', ""); +Expect(1, 5951, '\P{^Is_Blk= HANUNOO}', ""); +Expect(0, 5919, '\p{Is_Blk= HANUNOO}', ""); +Expect(1, 5919, '\p{^Is_Blk= HANUNOO}', ""); +Expect(1, 5919, '\P{Is_Blk= HANUNOO}', ""); +Expect(0, 5919, '\P{^Is_Blk= HANUNOO}', ""); +Error('\p{Block=:=- LowSurrogates}'); +Error('\P{Block=:=- LowSurrogates}'); +Expect(0, 7, '\p{Block=lowsurrogates}', ""); +Expect(1, 7, '\p{^Block=lowsurrogates}', ""); +Expect(1, 7, '\P{Block=lowsurrogates}', ""); +Expect(0, 7, '\P{^Block=lowsurrogates}', ""); +Expect(0, 7, '\p{Block=-Low surrogates}', ""); +Expect(1, 7, '\p{^Block=-Low surrogates}', ""); +Expect(1, 7, '\P{Block=-Low surrogates}', ""); +Expect(0, 7, '\P{^Block=-Low surrogates}', ""); +Error('\p{Blk=/a/Low_surrogates}'); +Error('\P{Blk=/a/Low_surrogates}'); +Expect(0, 7, '\p{Blk=lowsurrogates}', ""); +Expect(1, 7, '\p{^Blk=lowsurrogates}', ""); +Expect(1, 7, '\P{Blk=lowsurrogates}', ""); +Expect(0, 7, '\P{^Blk=lowsurrogates}', ""); +Expect(0, 7, '\p{Blk=_-LowSurrogates}', ""); +Expect(1, 7, '\p{^Blk=_-LowSurrogates}', ""); +Expect(1, 7, '\P{Blk=_-LowSurrogates}', ""); +Expect(0, 7, '\P{^Blk=_-LowSurrogates}', ""); +Error('\p{Is_Block=__LOW-SURROGATES:=}'); +Error('\P{Is_Block=__LOW-SURROGATES:=}'); +Expect(0, 7, '\p{Is_Block=lowsurrogates}', ""); +Expect(1, 7, '\p{^Is_Block=lowsurrogates}', ""); +Expect(1, 7, '\P{Is_Block=lowsurrogates}', ""); +Expect(0, 7, '\P{^Is_Block=lowsurrogates}', ""); +Expect(0, 7, '\p{Is_Block= -Low_surrogates}', ""); +Expect(1, 7, '\p{^Is_Block= -Low_surrogates}', ""); +Expect(1, 7, '\P{Is_Block= -Low_surrogates}', ""); +Expect(0, 7, '\P{^Is_Block= -Low_surrogates}', ""); +Error('\p{Is_Blk=_:=Low-SURROGATES}'); +Error('\P{Is_Blk=_:=Low-SURROGATES}'); +Expect(0, 7, '\p{Is_Blk=lowsurrogates}', ""); +Expect(1, 7, '\p{^Is_Blk=lowsurrogates}', ""); +Expect(1, 7, '\P{Is_Blk=lowsurrogates}', ""); +Expect(0, 7, '\P{^Is_Blk=lowsurrogates}', ""); +Expect(0, 7, '\p{Is_Blk=-Low_surrogates}', ""); +Expect(1, 7, '\p{^Is_Blk=-Low_surrogates}', ""); +Expect(1, 7, '\P{Is_Blk=-Low_surrogates}', ""); +Expect(0, 7, '\P{^Is_Blk=-Low_surrogates}', ""); +Error('\p{Block= /a/Katakana}'); +Error('\P{Block= /a/Katakana}'); +Expect(1, 12543, '\p{Block=katakana}', ""); +Expect(0, 12543, '\p{^Block=katakana}', ""); +Expect(0, 12543, '\P{Block=katakana}', ""); +Expect(1, 12543, '\P{^Block=katakana}', ""); +Expect(0, 12447, '\p{Block=katakana}', ""); +Expect(1, 12447, '\p{^Block=katakana}', ""); +Expect(1, 12447, '\P{Block=katakana}', ""); +Expect(0, 12447, '\P{^Block=katakana}', ""); +Expect(1, 12543, '\p{Block=_KATAKANA}', ""); +Expect(0, 12543, '\p{^Block=_KATAKANA}', ""); +Expect(0, 12543, '\P{Block=_KATAKANA}', ""); +Expect(1, 12543, '\P{^Block=_KATAKANA}', ""); +Expect(0, 12447, '\p{Block=_KATAKANA}', ""); +Expect(1, 12447, '\p{^Block=_KATAKANA}', ""); +Expect(1, 12447, '\P{Block=_KATAKANA}', ""); +Expect(0, 12447, '\P{^Block=_KATAKANA}', ""); +Error('\p{Blk=/a/ Katakana}'); +Error('\P{Blk=/a/ Katakana}'); +Expect(1, 12543, '\p{Blk=katakana}', ""); +Expect(0, 12543, '\p{^Blk=katakana}', ""); +Expect(0, 12543, '\P{Blk=katakana}', ""); +Expect(1, 12543, '\P{^Blk=katakana}', ""); +Expect(0, 12447, '\p{Blk=katakana}', ""); +Expect(1, 12447, '\p{^Blk=katakana}', ""); +Expect(1, 12447, '\P{Blk=katakana}', ""); +Expect(0, 12447, '\P{^Blk=katakana}', ""); +Expect(1, 12543, '\p{Blk=_Katakana}', ""); +Expect(0, 12543, '\p{^Blk=_Katakana}', ""); +Expect(0, 12543, '\P{Blk=_Katakana}', ""); +Expect(1, 12543, '\P{^Blk=_Katakana}', ""); +Expect(0, 12447, '\p{Blk=_Katakana}', ""); +Expect(1, 12447, '\p{^Blk=_Katakana}', ""); +Expect(1, 12447, '\P{Blk=_Katakana}', ""); +Expect(0, 12447, '\P{^Blk=_Katakana}', ""); +Error('\p{Is_Block=_/a/Katakana}'); +Error('\P{Is_Block=_/a/Katakana}'); +Expect(1, 12543, '\p{Is_Block=katakana}', ""); +Expect(0, 12543, '\p{^Is_Block=katakana}', ""); +Expect(0, 12543, '\P{Is_Block=katakana}', ""); +Expect(1, 12543, '\P{^Is_Block=katakana}', ""); +Expect(0, 12447, '\p{Is_Block=katakana}', ""); +Expect(1, 12447, '\p{^Is_Block=katakana}', ""); +Expect(1, 12447, '\P{Is_Block=katakana}', ""); +Expect(0, 12447, '\P{^Is_Block=katakana}', ""); +Expect(1, 12543, '\p{Is_Block= KATAKANA}', ""); +Expect(0, 12543, '\p{^Is_Block= KATAKANA}', ""); +Expect(0, 12543, '\P{Is_Block= KATAKANA}', ""); +Expect(1, 12543, '\P{^Is_Block= KATAKANA}', ""); +Expect(0, 12447, '\p{Is_Block= KATAKANA}', ""); +Expect(1, 12447, '\p{^Is_Block= KATAKANA}', ""); +Expect(1, 12447, '\P{Is_Block= KATAKANA}', ""); +Expect(0, 12447, '\P{^Is_Block= KATAKANA}', ""); +Error('\p{Is_Blk= :=Katakana}'); +Error('\P{Is_Blk= :=Katakana}'); +Expect(1, 12543, '\p{Is_Blk=katakana}', ""); +Expect(0, 12543, '\p{^Is_Blk=katakana}', ""); +Expect(0, 12543, '\P{Is_Blk=katakana}', ""); +Expect(1, 12543, '\P{^Is_Blk=katakana}', ""); +Expect(0, 12447, '\p{Is_Blk=katakana}', ""); +Expect(1, 12447, '\p{^Is_Blk=katakana}', ""); +Expect(1, 12447, '\P{Is_Blk=katakana}', ""); +Expect(0, 12447, '\P{^Is_Blk=katakana}', ""); +Expect(1, 12543, '\p{Is_Blk= KATAKANA}', ""); +Expect(0, 12543, '\p{^Is_Blk= KATAKANA}', ""); +Expect(0, 12543, '\P{Is_Blk= KATAKANA}', ""); +Expect(1, 12543, '\P{^Is_Blk= KATAKANA}', ""); +Expect(0, 12447, '\p{Is_Blk= KATAKANA}', ""); +Expect(1, 12447, '\p{^Is_Blk= KATAKANA}', ""); +Expect(1, 12447, '\P{Is_Blk= KATAKANA}', ""); +Expect(0, 12447, '\P{^Is_Blk= KATAKANA}', ""); +Error('\p{Block= :=Cuneiform}'); +Error('\P{Block= :=Cuneiform}'); +Expect(1, 74751, '\p{Block=cuneiform}', ""); +Expect(0, 74751, '\p{^Block=cuneiform}', ""); +Expect(0, 74751, '\P{Block=cuneiform}', ""); +Expect(1, 74751, '\P{^Block=cuneiform}', ""); +Expect(0, 73727, '\p{Block=cuneiform}', ""); +Expect(1, 73727, '\p{^Block=cuneiform}', ""); +Expect(1, 73727, '\P{Block=cuneiform}', ""); +Expect(0, 73727, '\P{^Block=cuneiform}', ""); +Expect(1, 74751, '\p{Block=__Cuneiform}', ""); +Expect(0, 74751, '\p{^Block=__Cuneiform}', ""); +Expect(0, 74751, '\P{Block=__Cuneiform}', ""); +Expect(1, 74751, '\P{^Block=__Cuneiform}', ""); +Expect(0, 73727, '\p{Block=__Cuneiform}', ""); +Expect(1, 73727, '\p{^Block=__Cuneiform}', ""); +Expect(1, 73727, '\P{Block=__Cuneiform}', ""); +Expect(0, 73727, '\P{^Block=__Cuneiform}', ""); +Error('\p{Blk=:=- CUNEIFORM}'); +Error('\P{Blk=:=- CUNEIFORM}'); +Expect(1, 74751, '\p{Blk=cuneiform}', ""); +Expect(0, 74751, '\p{^Blk=cuneiform}', ""); +Expect(0, 74751, '\P{Blk=cuneiform}', ""); +Expect(1, 74751, '\P{^Blk=cuneiform}', ""); +Expect(0, 73727, '\p{Blk=cuneiform}', ""); +Expect(1, 73727, '\p{^Blk=cuneiform}', ""); +Expect(1, 73727, '\P{Blk=cuneiform}', ""); +Expect(0, 73727, '\P{^Blk=cuneiform}', ""); +Expect(1, 74751, '\p{Blk:__Cuneiform}', ""); +Expect(0, 74751, '\p{^Blk:__Cuneiform}', ""); +Expect(0, 74751, '\P{Blk:__Cuneiform}', ""); +Expect(1, 74751, '\P{^Blk:__Cuneiform}', ""); +Expect(0, 73727, '\p{Blk:__Cuneiform}', ""); +Expect(1, 73727, '\p{^Blk:__Cuneiform}', ""); +Expect(1, 73727, '\P{Blk:__Cuneiform}', ""); +Expect(0, 73727, '\P{^Blk:__Cuneiform}', ""); +Error('\p{Is_Block=- Cuneiform:=}'); +Error('\P{Is_Block=- Cuneiform:=}'); +Expect(1, 74751, '\p{Is_Block=cuneiform}', ""); +Expect(0, 74751, '\p{^Is_Block=cuneiform}', ""); +Expect(0, 74751, '\P{Is_Block=cuneiform}', ""); +Expect(1, 74751, '\P{^Is_Block=cuneiform}', ""); +Expect(0, 73727, '\p{Is_Block=cuneiform}', ""); +Expect(1, 73727, '\p{^Is_Block=cuneiform}', ""); +Expect(1, 73727, '\P{Is_Block=cuneiform}', ""); +Expect(0, 73727, '\P{^Is_Block=cuneiform}', ""); +Expect(1, 74751, '\p{Is_Block= CUNEIFORM}', ""); +Expect(0, 74751, '\p{^Is_Block= CUNEIFORM}', ""); +Expect(0, 74751, '\P{Is_Block= CUNEIFORM}', ""); +Expect(1, 74751, '\P{^Is_Block= CUNEIFORM}', ""); +Expect(0, 73727, '\p{Is_Block= CUNEIFORM}', ""); +Expect(1, 73727, '\p{^Is_Block= CUNEIFORM}', ""); +Expect(1, 73727, '\P{Is_Block= CUNEIFORM}', ""); +Expect(0, 73727, '\P{^Is_Block= CUNEIFORM}', ""); +Error('\p{Is_Blk= /a/Cuneiform}'); +Error('\P{Is_Blk= /a/Cuneiform}'); +Expect(1, 74751, '\p{Is_Blk=cuneiform}', ""); +Expect(0, 74751, '\p{^Is_Blk=cuneiform}', ""); +Expect(0, 74751, '\P{Is_Blk=cuneiform}', ""); +Expect(1, 74751, '\P{^Is_Blk=cuneiform}', ""); +Expect(0, 73727, '\p{Is_Blk=cuneiform}', ""); +Expect(1, 73727, '\p{^Is_Blk=cuneiform}', ""); +Expect(1, 73727, '\P{Is_Blk=cuneiform}', ""); +Expect(0, 73727, '\P{^Is_Blk=cuneiform}', ""); +Expect(1, 74751, '\p{Is_Blk= cuneiform}', ""); +Expect(0, 74751, '\p{^Is_Blk= cuneiform}', ""); +Expect(0, 74751, '\P{Is_Blk= cuneiform}', ""); +Expect(1, 74751, '\P{^Is_Blk= cuneiform}', ""); +Expect(0, 73727, '\p{Is_Blk= cuneiform}', ""); +Expect(1, 73727, '\p{^Is_Blk= cuneiform}', ""); +Expect(1, 73727, '\P{Is_Blk= cuneiform}', ""); +Expect(0, 73727, '\P{^Is_Blk= cuneiform}', ""); +Error('\p{Block: -High/a/Surrogates}'); +Error('\P{Block: -High/a/Surrogates}'); +Expect(0, 55295, '\p{Block=highsurrogates}', ""); +Expect(1, 55295, '\p{^Block=highsurrogates}', ""); +Expect(1, 55295, '\P{Block=highsurrogates}', ""); +Expect(0, 55295, '\P{^Block=highsurrogates}', ""); +Expect(0, 55295, '\p{Block= high SURROGATES}', ""); +Expect(1, 55295, '\p{^Block= high SURROGATES}', ""); +Expect(1, 55295, '\P{Block= high SURROGATES}', ""); +Expect(0, 55295, '\P{^Block= high SURROGATES}', ""); +Error('\p{Blk: High/a/Surrogates}'); +Error('\P{Blk: High/a/Surrogates}'); +Expect(0, 55295, '\p{Blk=highsurrogates}', ""); +Expect(1, 55295, '\p{^Blk=highsurrogates}', ""); +Expect(1, 55295, '\P{Blk=highsurrogates}', ""); +Expect(0, 55295, '\P{^Blk=highsurrogates}', ""); +Expect(0, 55295, '\p{Blk= HIGH Surrogates}', ""); +Expect(1, 55295, '\p{^Blk= HIGH Surrogates}', ""); +Expect(1, 55295, '\P{Blk= HIGH Surrogates}', ""); +Expect(0, 55295, '\P{^Blk= HIGH Surrogates}', ""); +Error('\p{Is_Block=_HIGHSURROGATES/a/}'); +Error('\P{Is_Block=_HIGHSURROGATES/a/}'); +Expect(0, 55295, '\p{Is_Block=highsurrogates}', ""); +Expect(1, 55295, '\p{^Is_Block=highsurrogates}', ""); +Expect(1, 55295, '\P{Is_Block=highsurrogates}', ""); +Expect(0, 55295, '\P{^Is_Block=highsurrogates}', ""); +Expect(0, 55295, '\p{Is_Block=_HighSurrogates}', ""); +Expect(1, 55295, '\p{^Is_Block=_HighSurrogates}', ""); +Expect(1, 55295, '\P{Is_Block=_HighSurrogates}', ""); +Expect(0, 55295, '\P{^Is_Block=_HighSurrogates}', ""); +Error('\p{Is_Blk=/a/ -High-Surrogates}'); +Error('\P{Is_Blk=/a/ -High-Surrogates}'); +Expect(0, 55295, '\p{Is_Blk=highsurrogates}', ""); +Expect(1, 55295, '\p{^Is_Blk=highsurrogates}', ""); +Expect(1, 55295, '\P{Is_Blk=highsurrogates}', ""); +Expect(0, 55295, '\P{^Is_Blk=highsurrogates}', ""); +Expect(0, 55295, '\p{Is_Blk=-High-Surrogates}', ""); +Expect(1, 55295, '\p{^Is_Blk=-High-Surrogates}', ""); +Expect(1, 55295, '\P{Is_Blk=-High-Surrogates}', ""); +Expect(0, 55295, '\P{^Is_Blk=-High-Surrogates}', ""); +Error('\p{Block= /a/variation Selectors_SUPPLEMENT}'); +Error('\P{Block= /a/variation Selectors_SUPPLEMENT}'); +Expect(1, 917999, '\p{Block=variationselectorssupplement}', ""); +Expect(0, 917999, '\p{^Block=variationselectorssupplement}', ""); +Expect(0, 917999, '\P{Block=variationselectorssupplement}', ""); +Expect(1, 917999, '\P{^Block=variationselectorssupplement}', ""); +Expect(0, 917759, '\p{Block=variationselectorssupplement}', ""); +Expect(1, 917759, '\p{^Block=variationselectorssupplement}', ""); +Expect(1, 917759, '\P{Block=variationselectorssupplement}', ""); +Expect(0, 917759, '\P{^Block=variationselectorssupplement}', ""); +Expect(1, 917999, '\p{Block=-variation_selectorsSUPPLEMENT}', ""); +Expect(0, 917999, '\p{^Block=-variation_selectorsSUPPLEMENT}', ""); +Expect(0, 917999, '\P{Block=-variation_selectorsSUPPLEMENT}', ""); +Expect(1, 917999, '\P{^Block=-variation_selectorsSUPPLEMENT}', ""); +Expect(0, 917759, '\p{Block=-variation_selectorsSUPPLEMENT}', ""); +Expect(1, 917759, '\p{^Block=-variation_selectorsSUPPLEMENT}', ""); +Expect(1, 917759, '\P{Block=-variation_selectorsSUPPLEMENT}', ""); +Expect(0, 917759, '\P{^Block=-variation_selectorsSUPPLEMENT}', ""); +Error('\p{Blk=_VARIATION Selectors/a/supplement}'); +Error('\P{Blk=_VARIATION Selectors/a/supplement}'); +Expect(1, 917999, '\p{Blk: variationselectorssupplement}', ""); +Expect(0, 917999, '\p{^Blk: variationselectorssupplement}', ""); +Expect(0, 917999, '\P{Blk: variationselectorssupplement}', ""); +Expect(1, 917999, '\P{^Blk: variationselectorssupplement}', ""); +Expect(0, 917759, '\p{Blk: variationselectorssupplement}', ""); +Expect(1, 917759, '\p{^Blk: variationselectorssupplement}', ""); +Expect(1, 917759, '\P{Blk: variationselectorssupplement}', ""); +Expect(0, 917759, '\P{^Blk: variationselectorssupplement}', ""); +Expect(1, 917999, '\p{Blk=- VARIATION selectors Supplement}', ""); +Expect(0, 917999, '\p{^Blk=- VARIATION selectors Supplement}', ""); +Expect(0, 917999, '\P{Blk=- VARIATION selectors Supplement}', ""); +Expect(1, 917999, '\P{^Blk=- VARIATION selectors Supplement}', ""); +Expect(0, 917759, '\p{Blk=- VARIATION selectors Supplement}', ""); +Expect(1, 917759, '\p{^Blk=- VARIATION selectors Supplement}', ""); +Expect(1, 917759, '\P{Blk=- VARIATION selectors Supplement}', ""); +Expect(0, 917759, '\P{^Blk=- VARIATION selectors Supplement}', ""); +Error('\p{Is_Block: Variation-selectors/a/supplement}'); +Error('\P{Is_Block: Variation-selectors/a/supplement}'); +Expect(1, 917999, '\p{Is_Block=variationselectorssupplement}', ""); +Expect(0, 917999, '\p{^Is_Block=variationselectorssupplement}', ""); +Expect(0, 917999, '\P{Is_Block=variationselectorssupplement}', ""); +Expect(1, 917999, '\P{^Is_Block=variationselectorssupplement}', ""); +Expect(0, 917759, '\p{Is_Block=variationselectorssupplement}', ""); +Expect(1, 917759, '\p{^Is_Block=variationselectorssupplement}', ""); +Expect(1, 917759, '\P{Is_Block=variationselectorssupplement}', ""); +Expect(0, 917759, '\P{^Is_Block=variationselectorssupplement}', ""); +Expect(1, 917999, '\p{Is_Block:__VARIATIONSELECTORS_SUPPLEMENT}', ""); +Expect(0, 917999, '\p{^Is_Block:__VARIATIONSELECTORS_SUPPLEMENT}', ""); +Expect(0, 917999, '\P{Is_Block:__VARIATIONSELECTORS_SUPPLEMENT}', ""); +Expect(1, 917999, '\P{^Is_Block:__VARIATIONSELECTORS_SUPPLEMENT}', ""); +Expect(0, 917759, '\p{Is_Block:__VARIATIONSELECTORS_SUPPLEMENT}', ""); +Expect(1, 917759, '\p{^Is_Block:__VARIATIONSELECTORS_SUPPLEMENT}', ""); +Expect(1, 917759, '\P{Is_Block:__VARIATIONSELECTORS_SUPPLEMENT}', ""); +Expect(0, 917759, '\P{^Is_Block:__VARIATIONSELECTORS_SUPPLEMENT}', ""); +Error('\p{Is_Blk=/a/ -Variation SELECTORS_SUPPLEMENT}'); +Error('\P{Is_Blk=/a/ -Variation SELECTORS_SUPPLEMENT}'); +Expect(1, 917999, '\p{Is_Blk=variationselectorssupplement}', ""); +Expect(0, 917999, '\p{^Is_Blk=variationselectorssupplement}', ""); +Expect(0, 917999, '\P{Is_Blk=variationselectorssupplement}', ""); +Expect(1, 917999, '\P{^Is_Blk=variationselectorssupplement}', ""); +Expect(0, 917759, '\p{Is_Blk=variationselectorssupplement}', ""); +Expect(1, 917759, '\p{^Is_Blk=variationselectorssupplement}', ""); +Expect(1, 917759, '\P{Is_Blk=variationselectorssupplement}', ""); +Expect(0, 917759, '\P{^Is_Blk=variationselectorssupplement}', ""); +Expect(1, 917999, '\p{Is_Blk=- VARIATION SELECTORS Supplement}', ""); +Expect(0, 917999, '\p{^Is_Blk=- VARIATION SELECTORS Supplement}', ""); +Expect(0, 917999, '\P{Is_Blk=- VARIATION SELECTORS Supplement}', ""); +Expect(1, 917999, '\P{^Is_Blk=- VARIATION SELECTORS Supplement}', ""); +Expect(0, 917759, '\p{Is_Blk=- VARIATION SELECTORS Supplement}', ""); +Expect(1, 917759, '\p{^Is_Blk=- VARIATION SELECTORS Supplement}', ""); +Expect(1, 917759, '\P{Is_Blk=- VARIATION SELECTORS Supplement}', ""); +Expect(0, 917759, '\P{^Is_Blk=- VARIATION SELECTORS Supplement}', ""); +Error('\p{Block=:=_-Georgian-Supplement}'); +Error('\P{Block=:=_-Georgian-Supplement}'); +Expect(1, 11567, '\p{Block=georgiansupplement}', ""); +Expect(0, 11567, '\p{^Block=georgiansupplement}', ""); +Expect(0, 11567, '\P{Block=georgiansupplement}', ""); +Expect(1, 11567, '\P{^Block=georgiansupplement}', ""); +Expect(0, 11519, '\p{Block=georgiansupplement}', ""); +Expect(1, 11519, '\p{^Block=georgiansupplement}', ""); +Expect(1, 11519, '\P{Block=georgiansupplement}', ""); +Expect(0, 11519, '\P{^Block=georgiansupplement}', ""); +Expect(1, 11567, '\p{Block=-GeorgianSupplement}', ""); +Expect(0, 11567, '\p{^Block=-GeorgianSupplement}', ""); +Expect(0, 11567, '\P{Block=-GeorgianSupplement}', ""); +Expect(1, 11567, '\P{^Block=-GeorgianSupplement}', ""); +Expect(0, 11519, '\p{Block=-GeorgianSupplement}', ""); +Expect(1, 11519, '\p{^Block=-GeorgianSupplement}', ""); +Expect(1, 11519, '\P{Block=-GeorgianSupplement}', ""); +Expect(0, 11519, '\P{^Block=-GeorgianSupplement}', ""); +Error('\p{Blk= GEORGIAN:=Supplement}'); +Error('\P{Blk= GEORGIAN:=Supplement}'); +Expect(1, 11567, '\p{Blk=georgiansupplement}', ""); +Expect(0, 11567, '\p{^Blk=georgiansupplement}', ""); +Expect(0, 11567, '\P{Blk=georgiansupplement}', ""); +Expect(1, 11567, '\P{^Blk=georgiansupplement}', ""); +Expect(0, 11519, '\p{Blk=georgiansupplement}', ""); +Expect(1, 11519, '\p{^Blk=georgiansupplement}', ""); +Expect(1, 11519, '\P{Blk=georgiansupplement}', ""); +Expect(0, 11519, '\P{^Blk=georgiansupplement}', ""); +Expect(1, 11567, '\p{Blk=-GEORGIAN Supplement}', ""); +Expect(0, 11567, '\p{^Blk=-GEORGIAN Supplement}', ""); +Expect(0, 11567, '\P{Blk=-GEORGIAN Supplement}', ""); +Expect(1, 11567, '\P{^Blk=-GEORGIAN Supplement}', ""); +Expect(0, 11519, '\p{Blk=-GEORGIAN Supplement}', ""); +Expect(1, 11519, '\p{^Blk=-GEORGIAN Supplement}', ""); +Expect(1, 11519, '\P{Blk=-GEORGIAN Supplement}', ""); +Expect(0, 11519, '\P{^Blk=-GEORGIAN Supplement}', ""); +Error('\p{Is_Block=/a/_-Georgian_Supplement}'); +Error('\P{Is_Block=/a/_-Georgian_Supplement}'); +Expect(1, 11567, '\p{Is_Block=georgiansupplement}', ""); +Expect(0, 11567, '\p{^Is_Block=georgiansupplement}', ""); +Expect(0, 11567, '\P{Is_Block=georgiansupplement}', ""); +Expect(1, 11567, '\P{^Is_Block=georgiansupplement}', ""); +Expect(0, 11519, '\p{Is_Block=georgiansupplement}', ""); +Expect(1, 11519, '\p{^Is_Block=georgiansupplement}', ""); +Expect(1, 11519, '\P{Is_Block=georgiansupplement}', ""); +Expect(0, 11519, '\P{^Is_Block=georgiansupplement}', ""); +Expect(1, 11567, '\p{Is_Block=_ GeorgianSupplement}', ""); +Expect(0, 11567, '\p{^Is_Block=_ GeorgianSupplement}', ""); +Expect(0, 11567, '\P{Is_Block=_ GeorgianSupplement}', ""); +Expect(1, 11567, '\P{^Is_Block=_ GeorgianSupplement}', ""); +Expect(0, 11519, '\p{Is_Block=_ GeorgianSupplement}', ""); +Expect(1, 11519, '\p{^Is_Block=_ GeorgianSupplement}', ""); +Expect(1, 11519, '\P{Is_Block=_ GeorgianSupplement}', ""); +Expect(0, 11519, '\P{^Is_Block=_ GeorgianSupplement}', ""); +Error('\p{Is_Blk=_:=GEORGIAN_SUPPLEMENT}'); +Error('\P{Is_Blk=_:=GEORGIAN_SUPPLEMENT}'); +Expect(1, 11567, '\p{Is_Blk=georgiansupplement}', ""); +Expect(0, 11567, '\p{^Is_Blk=georgiansupplement}', ""); +Expect(0, 11567, '\P{Is_Blk=georgiansupplement}', ""); +Expect(1, 11567, '\P{^Is_Blk=georgiansupplement}', ""); +Expect(0, 11519, '\p{Is_Blk=georgiansupplement}', ""); +Expect(1, 11519, '\p{^Is_Blk=georgiansupplement}', ""); +Expect(1, 11519, '\P{Is_Blk=georgiansupplement}', ""); +Expect(0, 11519, '\P{^Is_Blk=georgiansupplement}', ""); +Expect(1, 11567, '\p{Is_Blk= -Georgian supplement}', ""); +Expect(0, 11567, '\p{^Is_Blk= -Georgian supplement}', ""); +Expect(0, 11567, '\P{Is_Blk= -Georgian supplement}', ""); +Expect(1, 11567, '\P{^Is_Blk= -Georgian supplement}', ""); +Expect(0, 11519, '\p{Is_Blk= -Georgian supplement}', ""); +Expect(1, 11519, '\p{^Is_Blk= -Georgian supplement}', ""); +Expect(1, 11519, '\P{Is_Blk= -Georgian supplement}', ""); +Expect(0, 11519, '\P{^Is_Blk= -Georgian supplement}', ""); +Error('\p{Block=/a/MYANMAR}'); +Error('\P{Block=/a/MYANMAR}'); +Expect(1, 4255, '\p{Block=myanmar}', ""); +Expect(0, 4255, '\p{^Block=myanmar}', ""); +Expect(0, 4255, '\P{Block=myanmar}', ""); +Expect(1, 4255, '\P{^Block=myanmar}', ""); +Expect(0, 4095, '\p{Block=myanmar}', ""); +Expect(1, 4095, '\p{^Block=myanmar}', ""); +Expect(1, 4095, '\P{Block=myanmar}', ""); +Expect(0, 4095, '\P{^Block=myanmar}', ""); +Expect(1, 4255, '\p{Block=_ Myanmar}', ""); +Expect(0, 4255, '\p{^Block=_ Myanmar}', ""); +Expect(0, 4255, '\P{Block=_ Myanmar}', ""); +Expect(1, 4255, '\P{^Block=_ Myanmar}', ""); +Expect(0, 4095, '\p{Block=_ Myanmar}', ""); +Expect(1, 4095, '\p{^Block=_ Myanmar}', ""); +Expect(1, 4095, '\P{Block=_ Myanmar}', ""); +Expect(0, 4095, '\P{^Block=_ Myanmar}', ""); +Error('\p{Blk=-Myanmar/a/}'); +Error('\P{Blk=-Myanmar/a/}'); +Expect(1, 4255, '\p{Blk=myanmar}', ""); +Expect(0, 4255, '\p{^Blk=myanmar}', ""); +Expect(0, 4255, '\P{Blk=myanmar}', ""); +Expect(1, 4255, '\P{^Blk=myanmar}', ""); +Expect(0, 4095, '\p{Blk=myanmar}', ""); +Expect(1, 4095, '\p{^Blk=myanmar}', ""); +Expect(1, 4095, '\P{Blk=myanmar}', ""); +Expect(0, 4095, '\P{^Blk=myanmar}', ""); +Expect(1, 4255, '\p{Blk=-MYANMAR}', ""); +Expect(0, 4255, '\p{^Blk=-MYANMAR}', ""); +Expect(0, 4255, '\P{Blk=-MYANMAR}', ""); +Expect(1, 4255, '\P{^Blk=-MYANMAR}', ""); +Expect(0, 4095, '\p{Blk=-MYANMAR}', ""); +Expect(1, 4095, '\p{^Blk=-MYANMAR}', ""); +Expect(1, 4095, '\P{Blk=-MYANMAR}', ""); +Expect(0, 4095, '\P{^Blk=-MYANMAR}', ""); +Error('\p{Is_Block=-/a/myanmar}'); +Error('\P{Is_Block=-/a/myanmar}'); +Expect(1, 4255, '\p{Is_Block=myanmar}', ""); +Expect(0, 4255, '\p{^Is_Block=myanmar}', ""); +Expect(0, 4255, '\P{Is_Block=myanmar}', ""); +Expect(1, 4255, '\P{^Is_Block=myanmar}', ""); +Expect(0, 4095, '\p{Is_Block=myanmar}', ""); +Expect(1, 4095, '\p{^Is_Block=myanmar}', ""); +Expect(1, 4095, '\P{Is_Block=myanmar}', ""); +Expect(0, 4095, '\P{^Is_Block=myanmar}', ""); +Expect(1, 4255, '\p{Is_Block=_-Myanmar}', ""); +Expect(0, 4255, '\p{^Is_Block=_-Myanmar}', ""); +Expect(0, 4255, '\P{Is_Block=_-Myanmar}', ""); +Expect(1, 4255, '\P{^Is_Block=_-Myanmar}', ""); +Expect(0, 4095, '\p{Is_Block=_-Myanmar}', ""); +Expect(1, 4095, '\p{^Is_Block=_-Myanmar}', ""); +Expect(1, 4095, '\P{Is_Block=_-Myanmar}', ""); +Expect(0, 4095, '\P{^Is_Block=_-Myanmar}', ""); +Error('\p{Is_Blk=_ Myanmar:=}'); +Error('\P{Is_Blk=_ Myanmar:=}'); +Expect(1, 4255, '\p{Is_Blk=myanmar}', ""); +Expect(0, 4255, '\p{^Is_Blk=myanmar}', ""); +Expect(0, 4255, '\P{Is_Blk=myanmar}', ""); +Expect(1, 4255, '\P{^Is_Blk=myanmar}', ""); +Expect(0, 4095, '\p{Is_Blk=myanmar}', ""); +Expect(1, 4095, '\p{^Is_Blk=myanmar}', ""); +Expect(1, 4095, '\P{Is_Blk=myanmar}', ""); +Expect(0, 4095, '\P{^Is_Blk=myanmar}', ""); +Expect(1, 4255, '\p{Is_Blk= Myanmar}', ""); +Expect(0, 4255, '\p{^Is_Blk= Myanmar}', ""); +Expect(0, 4255, '\P{Is_Blk= Myanmar}', ""); +Expect(1, 4255, '\P{^Is_Blk= Myanmar}', ""); +Expect(0, 4095, '\p{Is_Blk= Myanmar}', ""); +Expect(1, 4095, '\p{^Is_Blk= Myanmar}', ""); +Expect(1, 4095, '\P{Is_Blk= Myanmar}', ""); +Expect(0, 4095, '\P{^Is_Blk= Myanmar}', ""); +Error('\p{Block= verticalForms:=}'); +Error('\P{Block= verticalForms:=}'); +Expect(1, 65055, '\p{Block: verticalforms}', ""); +Expect(0, 65055, '\p{^Block: verticalforms}', ""); +Expect(0, 65055, '\P{Block: verticalforms}', ""); +Expect(1, 65055, '\P{^Block: verticalforms}', ""); +Expect(0, 65039, '\p{Block: verticalforms}', ""); +Expect(1, 65039, '\p{^Block: verticalforms}', ""); +Expect(1, 65039, '\P{Block: verticalforms}', ""); +Expect(0, 65039, '\P{^Block: verticalforms}', ""); +Expect(1, 65055, '\p{Block= _Vertical FORMS}', ""); +Expect(0, 65055, '\p{^Block= _Vertical FORMS}', ""); +Expect(0, 65055, '\P{Block= _Vertical FORMS}', ""); +Expect(1, 65055, '\P{^Block= _Vertical FORMS}', ""); +Expect(0, 65039, '\p{Block= _Vertical FORMS}', ""); +Expect(1, 65039, '\p{^Block= _Vertical FORMS}', ""); +Expect(1, 65039, '\P{Block= _Vertical FORMS}', ""); +Expect(0, 65039, '\P{^Block= _Vertical FORMS}', ""); +Error('\p{Blk= Vertical_Forms/a/}'); +Error('\P{Blk= Vertical_Forms/a/}'); +Expect(1, 65055, '\p{Blk: verticalforms}', ""); +Expect(0, 65055, '\p{^Blk: verticalforms}', ""); +Expect(0, 65055, '\P{Blk: verticalforms}', ""); +Expect(1, 65055, '\P{^Blk: verticalforms}', ""); +Expect(0, 65039, '\p{Blk: verticalforms}', ""); +Expect(1, 65039, '\p{^Blk: verticalforms}', ""); +Expect(1, 65039, '\P{Blk: verticalforms}', ""); +Expect(0, 65039, '\P{^Blk: verticalforms}', ""); +Expect(1, 65055, '\p{Blk=-_Vertical forms}', ""); +Expect(0, 65055, '\p{^Blk=-_Vertical forms}', ""); +Expect(0, 65055, '\P{Blk=-_Vertical forms}', ""); +Expect(1, 65055, '\P{^Blk=-_Vertical forms}', ""); +Expect(0, 65039, '\p{Blk=-_Vertical forms}', ""); +Expect(1, 65039, '\p{^Blk=-_Vertical forms}', ""); +Expect(1, 65039, '\P{Blk=-_Vertical forms}', ""); +Expect(0, 65039, '\P{^Blk=-_Vertical forms}', ""); +Error('\p{Is_Block=:=_VerticalFORMS}'); +Error('\P{Is_Block=:=_VerticalFORMS}'); +Expect(1, 65055, '\p{Is_Block: verticalforms}', ""); +Expect(0, 65055, '\p{^Is_Block: verticalforms}', ""); +Expect(0, 65055, '\P{Is_Block: verticalforms}', ""); +Expect(1, 65055, '\P{^Is_Block: verticalforms}', ""); +Expect(0, 65039, '\p{Is_Block: verticalforms}', ""); +Expect(1, 65039, '\p{^Is_Block: verticalforms}', ""); +Expect(1, 65039, '\P{Is_Block: verticalforms}', ""); +Expect(0, 65039, '\P{^Is_Block: verticalforms}', ""); +Expect(1, 65055, '\p{Is_Block=_Vertical FORMS}', ""); +Expect(0, 65055, '\p{^Is_Block=_Vertical FORMS}', ""); +Expect(0, 65055, '\P{Is_Block=_Vertical FORMS}', ""); +Expect(1, 65055, '\P{^Is_Block=_Vertical FORMS}', ""); +Expect(0, 65039, '\p{Is_Block=_Vertical FORMS}', ""); +Expect(1, 65039, '\p{^Is_Block=_Vertical FORMS}', ""); +Expect(1, 65039, '\P{Is_Block=_Vertical FORMS}', ""); +Expect(0, 65039, '\P{^Is_Block=_Vertical FORMS}', ""); +Error('\p{Is_Blk=-/a/Vertical-Forms}'); +Error('\P{Is_Blk=-/a/Vertical-Forms}'); +Expect(1, 65055, '\p{Is_Blk=verticalforms}', ""); +Expect(0, 65055, '\p{^Is_Blk=verticalforms}', ""); +Expect(0, 65055, '\P{Is_Blk=verticalforms}', ""); +Expect(1, 65055, '\P{^Is_Blk=verticalforms}', ""); +Expect(0, 65039, '\p{Is_Blk=verticalforms}', ""); +Expect(1, 65039, '\p{^Is_Blk=verticalforms}', ""); +Expect(1, 65039, '\P{Is_Blk=verticalforms}', ""); +Expect(0, 65039, '\P{^Is_Blk=verticalforms}', ""); +Expect(1, 65055, '\p{Is_Blk=_ Vertical FORMS}', ""); +Expect(0, 65055, '\p{^Is_Blk=_ Vertical FORMS}', ""); +Expect(0, 65055, '\P{Is_Blk=_ Vertical FORMS}', ""); +Expect(1, 65055, '\P{^Is_Blk=_ Vertical FORMS}', ""); +Expect(0, 65039, '\p{Is_Blk=_ Vertical FORMS}', ""); +Expect(1, 65039, '\p{^Is_Blk=_ Vertical FORMS}', ""); +Expect(1, 65039, '\P{Is_Blk=_ Vertical FORMS}', ""); +Expect(0, 65039, '\P{^Is_Blk=_ Vertical FORMS}', ""); +Error('\p{Block=:= _Sinhala}'); +Error('\P{Block=:= _Sinhala}'); +Expect(1, 3583, '\p{Block=sinhala}', ""); +Expect(0, 3583, '\p{^Block=sinhala}', ""); +Expect(0, 3583, '\P{Block=sinhala}', ""); +Expect(1, 3583, '\P{^Block=sinhala}', ""); +Expect(0, 3455, '\p{Block=sinhala}', ""); +Expect(1, 3455, '\p{^Block=sinhala}', ""); +Expect(1, 3455, '\P{Block=sinhala}', ""); +Expect(0, 3455, '\P{^Block=sinhala}', ""); +Expect(1, 3583, '\p{Block=- sinhala}', ""); +Expect(0, 3583, '\p{^Block=- sinhala}', ""); +Expect(0, 3583, '\P{Block=- sinhala}', ""); +Expect(1, 3583, '\P{^Block=- sinhala}', ""); +Expect(0, 3455, '\p{Block=- sinhala}', ""); +Expect(1, 3455, '\p{^Block=- sinhala}', ""); +Expect(1, 3455, '\P{Block=- sinhala}', ""); +Expect(0, 3455, '\P{^Block=- sinhala}', ""); +Error('\p{Blk=sinhala/a/}'); +Error('\P{Blk=sinhala/a/}'); +Expect(1, 3583, '\p{Blk=sinhala}', ""); +Expect(0, 3583, '\p{^Blk=sinhala}', ""); +Expect(0, 3583, '\P{Blk=sinhala}', ""); +Expect(1, 3583, '\P{^Blk=sinhala}', ""); +Expect(0, 3455, '\p{Blk=sinhala}', ""); +Expect(1, 3455, '\p{^Blk=sinhala}', ""); +Expect(1, 3455, '\P{Blk=sinhala}', ""); +Expect(0, 3455, '\P{^Blk=sinhala}', ""); +Expect(1, 3583, '\p{Blk=_SINHALA}', ""); +Expect(0, 3583, '\p{^Blk=_SINHALA}', ""); +Expect(0, 3583, '\P{Blk=_SINHALA}', ""); +Expect(1, 3583, '\P{^Blk=_SINHALA}', ""); +Expect(0, 3455, '\p{Blk=_SINHALA}', ""); +Expect(1, 3455, '\p{^Blk=_SINHALA}', ""); +Expect(1, 3455, '\P{Blk=_SINHALA}', ""); +Expect(0, 3455, '\P{^Blk=_SINHALA}', ""); +Error('\p{Is_Block= Sinhala:=}'); +Error('\P{Is_Block= Sinhala:=}'); +Expect(1, 3583, '\p{Is_Block=sinhala}', ""); +Expect(0, 3583, '\p{^Is_Block=sinhala}', ""); +Expect(0, 3583, '\P{Is_Block=sinhala}', ""); +Expect(1, 3583, '\P{^Is_Block=sinhala}', ""); +Expect(0, 3455, '\p{Is_Block=sinhala}', ""); +Expect(1, 3455, '\p{^Is_Block=sinhala}', ""); +Expect(1, 3455, '\P{Is_Block=sinhala}', ""); +Expect(0, 3455, '\P{^Is_Block=sinhala}', ""); +Expect(1, 3583, '\p{Is_Block=-Sinhala}', ""); +Expect(0, 3583, '\p{^Is_Block=-Sinhala}', ""); +Expect(0, 3583, '\P{Is_Block=-Sinhala}', ""); +Expect(1, 3583, '\P{^Is_Block=-Sinhala}', ""); +Expect(0, 3455, '\p{Is_Block=-Sinhala}', ""); +Expect(1, 3455, '\p{^Is_Block=-Sinhala}', ""); +Expect(1, 3455, '\P{Is_Block=-Sinhala}', ""); +Expect(0, 3455, '\P{^Is_Block=-Sinhala}', ""); +Error('\p{Is_Blk= Sinhala:=}'); +Error('\P{Is_Blk= Sinhala:=}'); +Expect(1, 3583, '\p{Is_Blk=sinhala}', ""); +Expect(0, 3583, '\p{^Is_Blk=sinhala}', ""); +Expect(0, 3583, '\P{Is_Blk=sinhala}', ""); +Expect(1, 3583, '\P{^Is_Blk=sinhala}', ""); +Expect(0, 3455, '\p{Is_Blk=sinhala}', ""); +Expect(1, 3455, '\p{^Is_Blk=sinhala}', ""); +Expect(1, 3455, '\P{Is_Blk=sinhala}', ""); +Expect(0, 3455, '\P{^Is_Blk=sinhala}', ""); +Expect(1, 3583, '\p{Is_Blk=__Sinhala}', ""); +Expect(0, 3583, '\p{^Is_Blk=__Sinhala}', ""); +Expect(0, 3583, '\P{Is_Blk=__Sinhala}', ""); +Expect(1, 3583, '\P{^Is_Blk=__Sinhala}', ""); +Expect(0, 3455, '\p{Is_Blk=__Sinhala}', ""); +Expect(1, 3455, '\p{^Is_Blk=__Sinhala}', ""); +Expect(1, 3455, '\P{Is_Blk=__Sinhala}', ""); +Expect(0, 3455, '\P{^Is_Blk=__Sinhala}', ""); +Error('\p{Block=_/a/GLAGOLITIC}'); +Error('\P{Block=_/a/GLAGOLITIC}'); +Expect(1, 11359, '\p{Block: glagolitic}', ""); +Expect(0, 11359, '\p{^Block: glagolitic}', ""); +Expect(0, 11359, '\P{Block: glagolitic}', ""); +Expect(1, 11359, '\P{^Block: glagolitic}', ""); +Expect(0, 11263, '\p{Block: glagolitic}', ""); +Expect(1, 11263, '\p{^Block: glagolitic}', ""); +Expect(1, 11263, '\P{Block: glagolitic}', ""); +Expect(0, 11263, '\P{^Block: glagolitic}', ""); +Expect(1, 11359, '\p{Block= GLAGOLITIC}', ""); +Expect(0, 11359, '\p{^Block= GLAGOLITIC}', ""); +Expect(0, 11359, '\P{Block= GLAGOLITIC}', ""); +Expect(1, 11359, '\P{^Block= GLAGOLITIC}', ""); +Expect(0, 11263, '\p{Block= GLAGOLITIC}', ""); +Expect(1, 11263, '\p{^Block= GLAGOLITIC}', ""); +Expect(1, 11263, '\P{Block= GLAGOLITIC}', ""); +Expect(0, 11263, '\P{^Block= GLAGOLITIC}', ""); +Error('\p{Blk= :=GLAGOLITIC}'); +Error('\P{Blk= :=GLAGOLITIC}'); +Expect(1, 11359, '\p{Blk: glagolitic}', ""); +Expect(0, 11359, '\p{^Blk: glagolitic}', ""); +Expect(0, 11359, '\P{Blk: glagolitic}', ""); +Expect(1, 11359, '\P{^Blk: glagolitic}', ""); +Expect(0, 11263, '\p{Blk: glagolitic}', ""); +Expect(1, 11263, '\p{^Blk: glagolitic}', ""); +Expect(1, 11263, '\P{Blk: glagolitic}', ""); +Expect(0, 11263, '\P{^Blk: glagolitic}', ""); +Expect(1, 11359, '\p{Blk= Glagolitic}', ""); +Expect(0, 11359, '\p{^Blk= Glagolitic}', ""); +Expect(0, 11359, '\P{Blk= Glagolitic}', ""); +Expect(1, 11359, '\P{^Blk= Glagolitic}', ""); +Expect(0, 11263, '\p{Blk= Glagolitic}', ""); +Expect(1, 11263, '\p{^Blk= Glagolitic}', ""); +Expect(1, 11263, '\P{Blk= Glagolitic}', ""); +Expect(0, 11263, '\P{^Blk= Glagolitic}', ""); +Error('\p{Is_Block= GLAGOLITIC/a/}'); +Error('\P{Is_Block= GLAGOLITIC/a/}'); +Expect(1, 11359, '\p{Is_Block=glagolitic}', ""); +Expect(0, 11359, '\p{^Is_Block=glagolitic}', ""); +Expect(0, 11359, '\P{Is_Block=glagolitic}', ""); +Expect(1, 11359, '\P{^Is_Block=glagolitic}', ""); +Expect(0, 11263, '\p{Is_Block=glagolitic}', ""); +Expect(1, 11263, '\p{^Is_Block=glagolitic}', ""); +Expect(1, 11263, '\P{Is_Block=glagolitic}', ""); +Expect(0, 11263, '\P{^Is_Block=glagolitic}', ""); +Expect(1, 11359, '\p{Is_Block=_ glagolitic}', ""); +Expect(0, 11359, '\p{^Is_Block=_ glagolitic}', ""); +Expect(0, 11359, '\P{Is_Block=_ glagolitic}', ""); +Expect(1, 11359, '\P{^Is_Block=_ glagolitic}', ""); +Expect(0, 11263, '\p{Is_Block=_ glagolitic}', ""); +Expect(1, 11263, '\p{^Is_Block=_ glagolitic}', ""); +Expect(1, 11263, '\P{Is_Block=_ glagolitic}', ""); +Expect(0, 11263, '\P{^Is_Block=_ glagolitic}', ""); +Error('\p{Is_Blk=_-Glagolitic/a/}'); +Error('\P{Is_Blk=_-Glagolitic/a/}'); +Expect(1, 11359, '\p{Is_Blk=glagolitic}', ""); +Expect(0, 11359, '\p{^Is_Blk=glagolitic}', ""); +Expect(0, 11359, '\P{Is_Blk=glagolitic}', ""); +Expect(1, 11359, '\P{^Is_Blk=glagolitic}', ""); +Expect(0, 11263, '\p{Is_Blk=glagolitic}', ""); +Expect(1, 11263, '\p{^Is_Blk=glagolitic}', ""); +Expect(1, 11263, '\P{Is_Blk=glagolitic}', ""); +Expect(0, 11263, '\P{^Is_Blk=glagolitic}', ""); +Expect(1, 11359, '\p{Is_Blk= _Glagolitic}', ""); +Expect(0, 11359, '\p{^Is_Blk= _Glagolitic}', ""); +Expect(0, 11359, '\P{Is_Blk= _Glagolitic}', ""); +Expect(1, 11359, '\P{^Is_Blk= _Glagolitic}', ""); +Expect(0, 11263, '\p{Is_Blk= _Glagolitic}', ""); +Expect(1, 11263, '\p{^Is_Blk= _Glagolitic}', ""); +Expect(1, 11263, '\P{Is_Blk= _Glagolitic}', ""); +Expect(0, 11263, '\P{^Is_Blk= _Glagolitic}', ""); +Error('\p{Block=/a/- tagalog}'); +Error('\P{Block=/a/- tagalog}'); +Expect(1, 5919, '\p{Block=tagalog}', ""); +Expect(0, 5919, '\p{^Block=tagalog}', ""); +Expect(0, 5919, '\P{Block=tagalog}', ""); +Expect(1, 5919, '\P{^Block=tagalog}', ""); +Expect(0, 5887, '\p{Block=tagalog}', ""); +Expect(1, 5887, '\p{^Block=tagalog}', ""); +Expect(1, 5887, '\P{Block=tagalog}', ""); +Expect(0, 5887, '\P{^Block=tagalog}', ""); +Expect(1, 5919, '\p{Block= Tagalog}', ""); +Expect(0, 5919, '\p{^Block= Tagalog}', ""); +Expect(0, 5919, '\P{Block= Tagalog}', ""); +Expect(1, 5919, '\P{^Block= Tagalog}', ""); +Expect(0, 5887, '\p{Block= Tagalog}', ""); +Expect(1, 5887, '\p{^Block= Tagalog}', ""); +Expect(1, 5887, '\P{Block= Tagalog}', ""); +Expect(0, 5887, '\P{^Block= Tagalog}', ""); +Error('\p{Blk=/a/ -Tagalog}'); +Error('\P{Blk=/a/ -Tagalog}'); +Expect(1, 5919, '\p{Blk=tagalog}', ""); +Expect(0, 5919, '\p{^Blk=tagalog}', ""); +Expect(0, 5919, '\P{Blk=tagalog}', ""); +Expect(1, 5919, '\P{^Blk=tagalog}', ""); +Expect(0, 5887, '\p{Blk=tagalog}', ""); +Expect(1, 5887, '\p{^Blk=tagalog}', ""); +Expect(1, 5887, '\P{Blk=tagalog}', ""); +Expect(0, 5887, '\P{^Blk=tagalog}', ""); +Expect(1, 5919, '\p{Blk=-TAGALOG}', ""); +Expect(0, 5919, '\p{^Blk=-TAGALOG}', ""); +Expect(0, 5919, '\P{Blk=-TAGALOG}', ""); +Expect(1, 5919, '\P{^Blk=-TAGALOG}', ""); +Expect(0, 5887, '\p{Blk=-TAGALOG}', ""); +Expect(1, 5887, '\p{^Blk=-TAGALOG}', ""); +Expect(1, 5887, '\P{Blk=-TAGALOG}', ""); +Expect(0, 5887, '\P{^Blk=-TAGALOG}', ""); +Error('\p{Is_Block= -tagalog/a/}'); +Error('\P{Is_Block= -tagalog/a/}'); +Expect(1, 5919, '\p{Is_Block=tagalog}', ""); +Expect(0, 5919, '\p{^Is_Block=tagalog}', ""); +Expect(0, 5919, '\P{Is_Block=tagalog}', ""); +Expect(1, 5919, '\P{^Is_Block=tagalog}', ""); +Expect(0, 5887, '\p{Is_Block=tagalog}', ""); +Expect(1, 5887, '\p{^Is_Block=tagalog}', ""); +Expect(1, 5887, '\P{Is_Block=tagalog}', ""); +Expect(0, 5887, '\P{^Is_Block=tagalog}', ""); +Expect(1, 5919, '\p{Is_Block= Tagalog}', ""); +Expect(0, 5919, '\p{^Is_Block= Tagalog}', ""); +Expect(0, 5919, '\P{Is_Block= Tagalog}', ""); +Expect(1, 5919, '\P{^Is_Block= Tagalog}', ""); +Expect(0, 5887, '\p{Is_Block= Tagalog}', ""); +Expect(1, 5887, '\p{^Is_Block= Tagalog}', ""); +Expect(1, 5887, '\P{Is_Block= Tagalog}', ""); +Expect(0, 5887, '\P{^Is_Block= Tagalog}', ""); +Error('\p{Is_Blk=-:=Tagalog}'); +Error('\P{Is_Blk=-:=Tagalog}'); +Expect(1, 5919, '\p{Is_Blk:tagalog}', ""); +Expect(0, 5919, '\p{^Is_Blk:tagalog}', ""); +Expect(0, 5919, '\P{Is_Blk:tagalog}', ""); +Expect(1, 5919, '\P{^Is_Blk:tagalog}', ""); +Expect(0, 5887, '\p{Is_Blk:tagalog}', ""); +Expect(1, 5887, '\p{^Is_Blk:tagalog}', ""); +Expect(1, 5887, '\P{Is_Blk:tagalog}', ""); +Expect(0, 5887, '\P{^Is_Blk:tagalog}', ""); +Expect(1, 5919, '\p{Is_Blk= Tagalog}', ""); +Expect(0, 5919, '\p{^Is_Blk= Tagalog}', ""); +Expect(0, 5919, '\P{Is_Blk= Tagalog}', ""); +Expect(1, 5919, '\P{^Is_Blk= Tagalog}', ""); +Expect(0, 5887, '\p{Is_Blk= Tagalog}', ""); +Expect(1, 5887, '\p{^Is_Blk= Tagalog}', ""); +Expect(1, 5887, '\P{Is_Blk= Tagalog}', ""); +Expect(0, 5887, '\P{^Is_Blk= Tagalog}', ""); +Error('\p{Block=/a/_Kharoshthi}'); +Error('\P{Block=/a/_Kharoshthi}'); +Expect(1, 68191, '\p{Block=kharoshthi}', ""); +Expect(0, 68191, '\p{^Block=kharoshthi}', ""); +Expect(0, 68191, '\P{Block=kharoshthi}', ""); +Expect(1, 68191, '\P{^Block=kharoshthi}', ""); +Expect(0, 68095, '\p{Block=kharoshthi}', ""); +Expect(1, 68095, '\p{^Block=kharoshthi}', ""); +Expect(1, 68095, '\P{Block=kharoshthi}', ""); +Expect(0, 68095, '\P{^Block=kharoshthi}', ""); +Expect(1, 68191, '\p{Block= kharoshthi}', ""); +Expect(0, 68191, '\p{^Block= kharoshthi}', ""); +Expect(0, 68191, '\P{Block= kharoshthi}', ""); +Expect(1, 68191, '\P{^Block= kharoshthi}', ""); +Expect(0, 68095, '\p{Block= kharoshthi}', ""); +Expect(1, 68095, '\p{^Block= kharoshthi}', ""); +Expect(1, 68095, '\P{Block= kharoshthi}', ""); +Expect(0, 68095, '\P{^Block= kharoshthi}', ""); +Error('\p{Blk=:= KHAROSHTHI}'); +Error('\P{Blk=:= KHAROSHTHI}'); +Expect(1, 68191, '\p{Blk=kharoshthi}', ""); +Expect(0, 68191, '\p{^Blk=kharoshthi}', ""); +Expect(0, 68191, '\P{Blk=kharoshthi}', ""); +Expect(1, 68191, '\P{^Blk=kharoshthi}', ""); +Expect(0, 68095, '\p{Blk=kharoshthi}', ""); +Expect(1, 68095, '\p{^Blk=kharoshthi}', ""); +Expect(1, 68095, '\P{Blk=kharoshthi}', ""); +Expect(0, 68095, '\P{^Blk=kharoshthi}', ""); +Expect(1, 68191, '\p{Blk: -Kharoshthi}', ""); +Expect(0, 68191, '\p{^Blk: -Kharoshthi}', ""); +Expect(0, 68191, '\P{Blk: -Kharoshthi}', ""); +Expect(1, 68191, '\P{^Blk: -Kharoshthi}', ""); +Expect(0, 68095, '\p{Blk: -Kharoshthi}', ""); +Expect(1, 68095, '\p{^Blk: -Kharoshthi}', ""); +Expect(1, 68095, '\P{Blk: -Kharoshthi}', ""); +Expect(0, 68095, '\P{^Blk: -Kharoshthi}', ""); +Error('\p{Is_Block=:= Kharoshthi}'); +Error('\P{Is_Block=:= Kharoshthi}'); +Expect(1, 68191, '\p{Is_Block=kharoshthi}', ""); +Expect(0, 68191, '\p{^Is_Block=kharoshthi}', ""); +Expect(0, 68191, '\P{Is_Block=kharoshthi}', ""); +Expect(1, 68191, '\P{^Is_Block=kharoshthi}', ""); +Expect(0, 68095, '\p{Is_Block=kharoshthi}', ""); +Expect(1, 68095, '\p{^Is_Block=kharoshthi}', ""); +Expect(1, 68095, '\P{Is_Block=kharoshthi}', ""); +Expect(0, 68095, '\P{^Is_Block=kharoshthi}', ""); +Expect(1, 68191, '\p{Is_Block=-Kharoshthi}', ""); +Expect(0, 68191, '\p{^Is_Block=-Kharoshthi}', ""); +Expect(0, 68191, '\P{Is_Block=-Kharoshthi}', ""); +Expect(1, 68191, '\P{^Is_Block=-Kharoshthi}', ""); +Expect(0, 68095, '\p{Is_Block=-Kharoshthi}', ""); +Expect(1, 68095, '\p{^Is_Block=-Kharoshthi}', ""); +Expect(1, 68095, '\P{Is_Block=-Kharoshthi}', ""); +Expect(0, 68095, '\P{^Is_Block=-Kharoshthi}', ""); +Error('\p{Is_Blk= _Kharoshthi/a/}'); +Error('\P{Is_Blk= _Kharoshthi/a/}'); +Expect(1, 68191, '\p{Is_Blk=kharoshthi}', ""); +Expect(0, 68191, '\p{^Is_Blk=kharoshthi}', ""); +Expect(0, 68191, '\P{Is_Blk=kharoshthi}', ""); +Expect(1, 68191, '\P{^Is_Blk=kharoshthi}', ""); +Expect(0, 68095, '\p{Is_Blk=kharoshthi}', ""); +Expect(1, 68095, '\p{^Is_Blk=kharoshthi}', ""); +Expect(1, 68095, '\P{Is_Blk=kharoshthi}', ""); +Expect(0, 68095, '\P{^Is_Blk=kharoshthi}', ""); +Expect(1, 68191, '\p{Is_Blk=__Kharoshthi}', ""); +Expect(0, 68191, '\p{^Is_Blk=__Kharoshthi}', ""); +Expect(0, 68191, '\P{Is_Blk=__Kharoshthi}', ""); +Expect(1, 68191, '\P{^Is_Blk=__Kharoshthi}', ""); +Expect(0, 68095, '\p{Is_Blk=__Kharoshthi}', ""); +Expect(1, 68095, '\p{^Is_Blk=__Kharoshthi}', ""); +Expect(1, 68095, '\P{Is_Blk=__Kharoshthi}', ""); +Expect(0, 68095, '\P{^Is_Blk=__Kharoshthi}', ""); +Error('\p{Block=- Arabic-Supplement/a/}'); +Error('\P{Block=- Arabic-Supplement/a/}'); +Expect(1, 1919, '\p{Block=arabicsupplement}', ""); +Expect(0, 1919, '\p{^Block=arabicsupplement}', ""); +Expect(0, 1919, '\P{Block=arabicsupplement}', ""); +Expect(1, 1919, '\P{^Block=arabicsupplement}', ""); +Expect(0, 1871, '\p{Block=arabicsupplement}', ""); +Expect(1, 1871, '\p{^Block=arabicsupplement}', ""); +Expect(1, 1871, '\P{Block=arabicsupplement}', ""); +Expect(0, 1871, '\P{^Block=arabicsupplement}', ""); +Expect(1, 1919, '\p{Block= _Arabic-supplement}', ""); +Expect(0, 1919, '\p{^Block= _Arabic-supplement}', ""); +Expect(0, 1919, '\P{Block= _Arabic-supplement}', ""); +Expect(1, 1919, '\P{^Block= _Arabic-supplement}', ""); +Expect(0, 1871, '\p{Block= _Arabic-supplement}', ""); +Expect(1, 1871, '\p{^Block= _Arabic-supplement}', ""); +Expect(1, 1871, '\P{Block= _Arabic-supplement}', ""); +Expect(0, 1871, '\P{^Block= _Arabic-supplement}', ""); +Error('\p{Blk=/a/ Arabic-Supplement}'); +Error('\P{Blk=/a/ Arabic-Supplement}'); +Expect(1, 1919, '\p{Blk=arabicsupplement}', ""); +Expect(0, 1919, '\p{^Blk=arabicsupplement}', ""); +Expect(0, 1919, '\P{Blk=arabicsupplement}', ""); +Expect(1, 1919, '\P{^Blk=arabicsupplement}', ""); +Expect(0, 1871, '\p{Blk=arabicsupplement}', ""); +Expect(1, 1871, '\p{^Blk=arabicsupplement}', ""); +Expect(1, 1871, '\P{Blk=arabicsupplement}', ""); +Expect(0, 1871, '\P{^Blk=arabicsupplement}', ""); +Expect(1, 1919, '\p{Blk=_ Arabic_supplement}', ""); +Expect(0, 1919, '\p{^Blk=_ Arabic_supplement}', ""); +Expect(0, 1919, '\P{Blk=_ Arabic_supplement}', ""); +Expect(1, 1919, '\P{^Blk=_ Arabic_supplement}', ""); +Expect(0, 1871, '\p{Blk=_ Arabic_supplement}', ""); +Expect(1, 1871, '\p{^Blk=_ Arabic_supplement}', ""); +Expect(1, 1871, '\P{Blk=_ Arabic_supplement}', ""); +Expect(0, 1871, '\P{^Blk=_ Arabic_supplement}', ""); +Error('\p{Is_Block= Arabic supplement:=}'); +Error('\P{Is_Block= Arabic supplement:=}'); +Expect(1, 1919, '\p{Is_Block=arabicsupplement}', ""); +Expect(0, 1919, '\p{^Is_Block=arabicsupplement}', ""); +Expect(0, 1919, '\P{Is_Block=arabicsupplement}', ""); +Expect(1, 1919, '\P{^Is_Block=arabicsupplement}', ""); +Expect(0, 1871, '\p{Is_Block=arabicsupplement}', ""); +Expect(1, 1871, '\p{^Is_Block=arabicsupplement}', ""); +Expect(1, 1871, '\P{Is_Block=arabicsupplement}', ""); +Expect(0, 1871, '\P{^Is_Block=arabicsupplement}', ""); +Expect(1, 1919, '\p{Is_Block=_-Arabic supplement}', ""); +Expect(0, 1919, '\p{^Is_Block=_-Arabic supplement}', ""); +Expect(0, 1919, '\P{Is_Block=_-Arabic supplement}', ""); +Expect(1, 1919, '\P{^Is_Block=_-Arabic supplement}', ""); +Expect(0, 1871, '\p{Is_Block=_-Arabic supplement}', ""); +Expect(1, 1871, '\p{^Is_Block=_-Arabic supplement}', ""); +Expect(1, 1871, '\P{Is_Block=_-Arabic supplement}', ""); +Expect(0, 1871, '\P{^Is_Block=_-Arabic supplement}', ""); +Error('\p{Is_Blk=_:=arabic SUPPLEMENT}'); +Error('\P{Is_Blk=_:=arabic SUPPLEMENT}'); +Expect(1, 1919, '\p{Is_Blk=arabicsupplement}', ""); +Expect(0, 1919, '\p{^Is_Blk=arabicsupplement}', ""); +Expect(0, 1919, '\P{Is_Blk=arabicsupplement}', ""); +Expect(1, 1919, '\P{^Is_Blk=arabicsupplement}', ""); +Expect(0, 1871, '\p{Is_Blk=arabicsupplement}', ""); +Expect(1, 1871, '\p{^Is_Blk=arabicsupplement}', ""); +Expect(1, 1871, '\P{Is_Blk=arabicsupplement}', ""); +Expect(0, 1871, '\P{^Is_Blk=arabicsupplement}', ""); +Expect(1, 1919, '\p{Is_Blk=_ARABIC-SUPPLEMENT}', ""); +Expect(0, 1919, '\p{^Is_Blk=_ARABIC-SUPPLEMENT}', ""); +Expect(0, 1919, '\P{Is_Blk=_ARABIC-SUPPLEMENT}', ""); +Expect(1, 1919, '\P{^Is_Blk=_ARABIC-SUPPLEMENT}', ""); +Expect(0, 1871, '\p{Is_Blk=_ARABIC-SUPPLEMENT}', ""); +Expect(1, 1871, '\p{^Is_Blk=_ARABIC-SUPPLEMENT}', ""); +Expect(1, 1871, '\P{Is_Blk=_ARABIC-SUPPLEMENT}', ""); +Expect(0, 1871, '\P{^Is_Blk=_ARABIC-SUPPLEMENT}', ""); +Error('\p{Block=-Cuneiform_Numbers/a/and PUNCTUATION}'); +Error('\P{Block=-Cuneiform_Numbers/a/and PUNCTUATION}'); +Expect(1, 74879, '\p{Block=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\p{^Block=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\P{Block=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\P{^Block=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\p{Block=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\p{^Block=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\P{Block=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\P{^Block=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\p{Block= CUNEIFORMNUMBERS_andPunctuation}', ""); +Expect(0, 74879, '\p{^Block= CUNEIFORMNUMBERS_andPunctuation}', ""); +Expect(0, 74879, '\P{Block= CUNEIFORMNUMBERS_andPunctuation}', ""); +Expect(1, 74879, '\P{^Block= CUNEIFORMNUMBERS_andPunctuation}', ""); +Expect(0, 74751, '\p{Block= CUNEIFORMNUMBERS_andPunctuation}', ""); +Expect(1, 74751, '\p{^Block= CUNEIFORMNUMBERS_andPunctuation}', ""); +Expect(1, 74751, '\P{Block= CUNEIFORMNUMBERS_andPunctuation}', ""); +Expect(0, 74751, '\P{^Block= CUNEIFORMNUMBERS_andPunctuation}', ""); +Error('\p{Blk= -CuneiformNumbers_AND Punctuation/a/}'); +Error('\P{Blk= -CuneiformNumbers_AND Punctuation/a/}'); +Expect(1, 74879, '\p{Blk=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\p{^Blk=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\P{Blk=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\P{^Blk=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\p{Blk=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\p{^Blk=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\P{Blk=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\P{^Blk=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\p{Blk=_ CUNEIFORM NUMBERS-and Punctuation}', ""); +Expect(0, 74879, '\p{^Blk=_ CUNEIFORM NUMBERS-and Punctuation}', ""); +Expect(0, 74879, '\P{Blk=_ CUNEIFORM NUMBERS-and Punctuation}', ""); +Expect(1, 74879, '\P{^Blk=_ CUNEIFORM NUMBERS-and Punctuation}', ""); +Expect(0, 74751, '\p{Blk=_ CUNEIFORM NUMBERS-and Punctuation}', ""); +Expect(1, 74751, '\p{^Blk=_ CUNEIFORM NUMBERS-and Punctuation}', ""); +Expect(1, 74751, '\P{Blk=_ CUNEIFORM NUMBERS-and Punctuation}', ""); +Expect(0, 74751, '\P{^Blk=_ CUNEIFORM NUMBERS-and Punctuation}', ""); +Error('\p{Is_Block=_:=Cuneiform Numbers-And_punctuation}'); +Error('\P{Is_Block=_:=Cuneiform Numbers-And_punctuation}'); +Expect(1, 74879, '\p{Is_Block=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\p{^Is_Block=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\P{Is_Block=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\P{^Is_Block=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\p{Is_Block=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\p{^Is_Block=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\P{Is_Block=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\P{^Is_Block=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\p{Is_Block= CuneiformNumbers-AndPunctuation}', ""); +Expect(0, 74879, '\p{^Is_Block= CuneiformNumbers-AndPunctuation}', ""); +Expect(0, 74879, '\P{Is_Block= CuneiformNumbers-AndPunctuation}', ""); +Expect(1, 74879, '\P{^Is_Block= CuneiformNumbers-AndPunctuation}', ""); +Expect(0, 74751, '\p{Is_Block= CuneiformNumbers-AndPunctuation}', ""); +Expect(1, 74751, '\p{^Is_Block= CuneiformNumbers-AndPunctuation}', ""); +Expect(1, 74751, '\P{Is_Block= CuneiformNumbers-AndPunctuation}', ""); +Expect(0, 74751, '\P{^Is_Block= CuneiformNumbers-AndPunctuation}', ""); +Error('\p{Is_Blk: _cuneiform Numbersand-Punctuation:=}'); +Error('\P{Is_Blk: _cuneiform Numbersand-Punctuation:=}'); +Expect(1, 74879, '\p{Is_Blk=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\p{^Is_Blk=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\P{Is_Blk=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\P{^Is_Blk=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\p{Is_Blk=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\p{^Is_Blk=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\P{Is_Blk=cuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\P{^Is_Blk=cuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\p{Is_Blk: Cuneiform Numbers AndPunctuation}', ""); +Expect(0, 74879, '\p{^Is_Blk: Cuneiform Numbers AndPunctuation}', ""); +Expect(0, 74879, '\P{Is_Blk: Cuneiform Numbers AndPunctuation}', ""); +Expect(1, 74879, '\P{^Is_Blk: Cuneiform Numbers AndPunctuation}', ""); +Expect(0, 74751, '\p{Is_Blk: Cuneiform Numbers AndPunctuation}', ""); +Expect(1, 74751, '\p{^Is_Blk: Cuneiform Numbers AndPunctuation}', ""); +Expect(1, 74751, '\P{Is_Blk: Cuneiform Numbers AndPunctuation}', ""); +Expect(0, 74751, '\P{^Is_Blk: Cuneiform Numbers AndPunctuation}', ""); +Error('\p{Block=- YI Syllables/a/}'); +Error('\P{Block=- YI Syllables/a/}'); +Expect(1, 42127, '\p{Block=yisyllables}', ""); +Expect(0, 42127, '\p{^Block=yisyllables}', ""); +Expect(0, 42127, '\P{Block=yisyllables}', ""); +Expect(1, 42127, '\P{^Block=yisyllables}', ""); +Expect(0, 40959, '\p{Block=yisyllables}', ""); +Expect(1, 40959, '\p{^Block=yisyllables}', ""); +Expect(1, 40959, '\P{Block=yisyllables}', ""); +Expect(0, 40959, '\P{^Block=yisyllables}', ""); +Expect(1, 42127, '\p{Block=_ yi Syllables}', ""); +Expect(0, 42127, '\p{^Block=_ yi Syllables}', ""); +Expect(0, 42127, '\P{Block=_ yi Syllables}', ""); +Expect(1, 42127, '\P{^Block=_ yi Syllables}', ""); +Expect(0, 40959, '\p{Block=_ yi Syllables}', ""); +Expect(1, 40959, '\p{^Block=_ yi Syllables}', ""); +Expect(1, 40959, '\P{Block=_ yi Syllables}', ""); +Expect(0, 40959, '\P{^Block=_ yi Syllables}', ""); +Error('\p{Blk=_ yi SYLLABLES:=}'); +Error('\P{Blk=_ yi SYLLABLES:=}'); +Expect(1, 42127, '\p{Blk=yisyllables}', ""); +Expect(0, 42127, '\p{^Blk=yisyllables}', ""); +Expect(0, 42127, '\P{Blk=yisyllables}', ""); +Expect(1, 42127, '\P{^Blk=yisyllables}', ""); +Expect(0, 40959, '\p{Blk=yisyllables}', ""); +Expect(1, 40959, '\p{^Blk=yisyllables}', ""); +Expect(1, 40959, '\P{Blk=yisyllables}', ""); +Expect(0, 40959, '\P{^Blk=yisyllables}', ""); +Expect(1, 42127, '\p{Blk: _ YI-Syllables}', ""); +Expect(0, 42127, '\p{^Blk: _ YI-Syllables}', ""); +Expect(0, 42127, '\P{Blk: _ YI-Syllables}', ""); +Expect(1, 42127, '\P{^Blk: _ YI-Syllables}', ""); +Expect(0, 40959, '\p{Blk: _ YI-Syllables}', ""); +Expect(1, 40959, '\p{^Blk: _ YI-Syllables}', ""); +Expect(1, 40959, '\P{Blk: _ YI-Syllables}', ""); +Expect(0, 40959, '\P{^Blk: _ YI-Syllables}', ""); +Error('\p{Is_Block:_yi_syllables/a/}'); +Error('\P{Is_Block:_yi_syllables/a/}'); +Expect(1, 42127, '\p{Is_Block=yisyllables}', ""); +Expect(0, 42127, '\p{^Is_Block=yisyllables}', ""); +Expect(0, 42127, '\P{Is_Block=yisyllables}', ""); +Expect(1, 42127, '\P{^Is_Block=yisyllables}', ""); +Expect(0, 40959, '\p{Is_Block=yisyllables}', ""); +Expect(1, 40959, '\p{^Is_Block=yisyllables}', ""); +Expect(1, 40959, '\P{Is_Block=yisyllables}', ""); +Expect(0, 40959, '\P{^Is_Block=yisyllables}', ""); +Expect(1, 42127, '\p{Is_Block= YiSyllables}', ""); +Expect(0, 42127, '\p{^Is_Block= YiSyllables}', ""); +Expect(0, 42127, '\P{Is_Block= YiSyllables}', ""); +Expect(1, 42127, '\P{^Is_Block= YiSyllables}', ""); +Expect(0, 40959, '\p{Is_Block= YiSyllables}', ""); +Expect(1, 40959, '\p{^Is_Block= YiSyllables}', ""); +Expect(1, 40959, '\P{Is_Block= YiSyllables}', ""); +Expect(0, 40959, '\P{^Is_Block= YiSyllables}', ""); +Error('\p{Is_Blk=/a/ YI SYLLABLES}'); +Error('\P{Is_Blk=/a/ YI SYLLABLES}'); +Expect(1, 42127, '\p{Is_Blk=yisyllables}', ""); +Expect(0, 42127, '\p{^Is_Blk=yisyllables}', ""); +Expect(0, 42127, '\P{Is_Blk=yisyllables}', ""); +Expect(1, 42127, '\P{^Is_Blk=yisyllables}', ""); +Expect(0, 40959, '\p{Is_Blk=yisyllables}', ""); +Expect(1, 40959, '\p{^Is_Blk=yisyllables}', ""); +Expect(1, 40959, '\P{Is_Blk=yisyllables}', ""); +Expect(0, 40959, '\P{^Is_Blk=yisyllables}', ""); +Expect(1, 42127, '\p{Is_Blk=__YI-Syllables}', ""); +Expect(0, 42127, '\p{^Is_Blk=__YI-Syllables}', ""); +Expect(0, 42127, '\P{Is_Blk=__YI-Syllables}', ""); +Expect(1, 42127, '\P{^Is_Blk=__YI-Syllables}', ""); +Expect(0, 40959, '\p{Is_Blk=__YI-Syllables}', ""); +Expect(1, 40959, '\p{^Is_Blk=__YI-Syllables}', ""); +Expect(1, 40959, '\P{Is_Blk=__YI-Syllables}', ""); +Expect(0, 40959, '\P{^Is_Blk=__YI-Syllables}', ""); +Error('\p{Block: := -combining-half MARKS}'); +Error('\P{Block: := -combining-half MARKS}'); +Expect(1, 65071, '\p{Block=combininghalfmarks}', ""); +Expect(0, 65071, '\p{^Block=combininghalfmarks}', ""); +Expect(0, 65071, '\P{Block=combininghalfmarks}', ""); +Expect(1, 65071, '\P{^Block=combininghalfmarks}', ""); +Expect(0, 65055, '\p{Block=combininghalfmarks}', ""); +Expect(1, 65055, '\p{^Block=combininghalfmarks}', ""); +Expect(1, 65055, '\P{Block=combininghalfmarks}', ""); +Expect(0, 65055, '\P{^Block=combininghalfmarks}', ""); +Expect(1, 65071, '\p{Block= Combining HalfMarks}', ""); +Expect(0, 65071, '\p{^Block= Combining HalfMarks}', ""); +Expect(0, 65071, '\P{Block= Combining HalfMarks}', ""); +Expect(1, 65071, '\P{^Block= Combining HalfMarks}', ""); +Expect(0, 65055, '\p{Block= Combining HalfMarks}', ""); +Expect(1, 65055, '\p{^Block= Combining HalfMarks}', ""); +Expect(1, 65055, '\P{Block= Combining HalfMarks}', ""); +Expect(0, 65055, '\P{^Block= Combining HalfMarks}', ""); +Error('\p{Blk=:=Combining-HALF Marks}'); +Error('\P{Blk=:=Combining-HALF Marks}'); +Expect(1, 65071, '\p{Blk=combininghalfmarks}', ""); +Expect(0, 65071, '\p{^Blk=combininghalfmarks}', ""); +Expect(0, 65071, '\P{Blk=combininghalfmarks}', ""); +Expect(1, 65071, '\P{^Blk=combininghalfmarks}', ""); +Expect(0, 65055, '\p{Blk=combininghalfmarks}', ""); +Expect(1, 65055, '\p{^Blk=combininghalfmarks}', ""); +Expect(1, 65055, '\P{Blk=combininghalfmarks}', ""); +Expect(0, 65055, '\P{^Blk=combininghalfmarks}', ""); +Expect(1, 65071, '\p{Blk= combining halfMarks}', ""); +Expect(0, 65071, '\p{^Blk= combining halfMarks}', ""); +Expect(0, 65071, '\P{Blk= combining halfMarks}', ""); +Expect(1, 65071, '\P{^Blk= combining halfMarks}', ""); +Expect(0, 65055, '\p{Blk= combining halfMarks}', ""); +Expect(1, 65055, '\p{^Blk= combining halfMarks}', ""); +Expect(1, 65055, '\P{Blk= combining halfMarks}', ""); +Expect(0, 65055, '\P{^Blk= combining halfMarks}', ""); +Error('\p{Is_Block= :=COMBINING HALF_marks}'); +Error('\P{Is_Block= :=COMBINING HALF_marks}'); +Expect(1, 65071, '\p{Is_Block=combininghalfmarks}', ""); +Expect(0, 65071, '\p{^Is_Block=combininghalfmarks}', ""); +Expect(0, 65071, '\P{Is_Block=combininghalfmarks}', ""); +Expect(1, 65071, '\P{^Is_Block=combininghalfmarks}', ""); +Expect(0, 65055, '\p{Is_Block=combininghalfmarks}', ""); +Expect(1, 65055, '\p{^Is_Block=combininghalfmarks}', ""); +Expect(1, 65055, '\P{Is_Block=combininghalfmarks}', ""); +Expect(0, 65055, '\P{^Is_Block=combininghalfmarks}', ""); +Expect(1, 65071, '\p{Is_Block= combining-Half-Marks}', ""); +Expect(0, 65071, '\p{^Is_Block= combining-Half-Marks}', ""); +Expect(0, 65071, '\P{Is_Block= combining-Half-Marks}', ""); +Expect(1, 65071, '\P{^Is_Block= combining-Half-Marks}', ""); +Expect(0, 65055, '\p{Is_Block= combining-Half-Marks}', ""); +Expect(1, 65055, '\p{^Is_Block= combining-Half-Marks}', ""); +Expect(1, 65055, '\P{Is_Block= combining-Half-Marks}', ""); +Expect(0, 65055, '\P{^Is_Block= combining-Half-Marks}', ""); +Error('\p{Is_Blk= combining_Half Marks:=}'); +Error('\P{Is_Blk= combining_Half Marks:=}'); +Expect(1, 65071, '\p{Is_Blk=combininghalfmarks}', ""); +Expect(0, 65071, '\p{^Is_Blk=combininghalfmarks}', ""); +Expect(0, 65071, '\P{Is_Blk=combininghalfmarks}', ""); +Expect(1, 65071, '\P{^Is_Blk=combininghalfmarks}', ""); +Expect(0, 65055, '\p{Is_Blk=combininghalfmarks}', ""); +Expect(1, 65055, '\p{^Is_Blk=combininghalfmarks}', ""); +Expect(1, 65055, '\P{Is_Blk=combininghalfmarks}', ""); +Expect(0, 65055, '\P{^Is_Blk=combininghalfmarks}', ""); +Expect(1, 65071, '\p{Is_Blk=- combiningHALFmarks}', ""); +Expect(0, 65071, '\p{^Is_Blk=- combiningHALFmarks}', ""); +Expect(0, 65071, '\P{Is_Blk=- combiningHALFmarks}', ""); +Expect(1, 65071, '\P{^Is_Blk=- combiningHALFmarks}', ""); +Expect(0, 65055, '\p{Is_Blk=- combiningHALFmarks}', ""); +Expect(1, 65055, '\p{^Is_Blk=- combiningHALFmarks}', ""); +Expect(1, 65055, '\P{Is_Blk=- combiningHALFmarks}', ""); +Expect(0, 65055, '\P{^Is_Blk=- combiningHALFmarks}', ""); +Error('\p{Block=/a/ MISCELLANEOUS symbols Andarrows}'); +Error('\P{Block=/a/ MISCELLANEOUS symbols Andarrows}'); +Expect(1, 11263, '\p{Block=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\p{^Block=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\P{Block=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\P{^Block=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\p{Block=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\p{^Block=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\P{Block=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\P{^Block=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\p{Block=- Miscellaneous-Symbols-And Arrows}', ""); +Expect(0, 11263, '\p{^Block=- Miscellaneous-Symbols-And Arrows}', ""); +Expect(0, 11263, '\P{Block=- Miscellaneous-Symbols-And Arrows}', ""); +Expect(1, 11263, '\P{^Block=- Miscellaneous-Symbols-And Arrows}', ""); +Expect(0, 11007, '\p{Block=- Miscellaneous-Symbols-And Arrows}', ""); +Expect(1, 11007, '\p{^Block=- Miscellaneous-Symbols-And Arrows}', ""); +Expect(1, 11007, '\P{Block=- Miscellaneous-Symbols-And Arrows}', ""); +Expect(0, 11007, '\P{^Block=- Miscellaneous-Symbols-And Arrows}', ""); +Error('\p{Blk: :=- MISCELLANEOUS_Symbols_And_arrows}'); +Error('\P{Blk: :=- MISCELLANEOUS_Symbols_And_arrows}'); +Expect(1, 11263, '\p{Blk=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\p{^Blk=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\P{Blk=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\P{^Blk=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\p{Blk=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\p{^Blk=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\P{Blk=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\P{^Blk=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\p{Blk=miscellaneous Symbols_And-ARROWS}', ""); +Expect(0, 11263, '\p{^Blk=miscellaneous Symbols_And-ARROWS}', ""); +Expect(0, 11263, '\P{Blk=miscellaneous Symbols_And-ARROWS}', ""); +Expect(1, 11263, '\P{^Blk=miscellaneous Symbols_And-ARROWS}', ""); +Expect(0, 11007, '\p{Blk=miscellaneous Symbols_And-ARROWS}', ""); +Expect(1, 11007, '\p{^Blk=miscellaneous Symbols_And-ARROWS}', ""); +Expect(1, 11007, '\P{Blk=miscellaneous Symbols_And-ARROWS}', ""); +Expect(0, 11007, '\P{^Blk=miscellaneous Symbols_And-ARROWS}', ""); +Error('\p{Is_Block= miscellaneous Symbols AND/a/Arrows}'); +Error('\P{Is_Block= miscellaneous Symbols AND/a/Arrows}'); +Expect(1, 11263, '\p{Is_Block=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\p{^Is_Block=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\P{Is_Block=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\P{^Is_Block=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\p{Is_Block=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\p{^Is_Block=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\P{Is_Block=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\P{^Is_Block=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\p{Is_Block: miscellaneousSymbols-And arrows}', ""); +Expect(0, 11263, '\p{^Is_Block: miscellaneousSymbols-And arrows}', ""); +Expect(0, 11263, '\P{Is_Block: miscellaneousSymbols-And arrows}', ""); +Expect(1, 11263, '\P{^Is_Block: miscellaneousSymbols-And arrows}', ""); +Expect(0, 11007, '\p{Is_Block: miscellaneousSymbols-And arrows}', ""); +Expect(1, 11007, '\p{^Is_Block: miscellaneousSymbols-And arrows}', ""); +Expect(1, 11007, '\P{Is_Block: miscellaneousSymbols-And arrows}', ""); +Expect(0, 11007, '\P{^Is_Block: miscellaneousSymbols-And arrows}', ""); +Error('\p{Is_Blk=-MISCELLANEOUS/a/symbols_AND-Arrows}'); +Error('\P{Is_Blk=-MISCELLANEOUS/a/symbols_AND-Arrows}'); +Expect(1, 11263, '\p{Is_Blk=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\p{^Is_Blk=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\P{Is_Blk=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\P{^Is_Blk=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\p{Is_Blk=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\p{^Is_Blk=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\P{Is_Blk=miscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\P{^Is_Blk=miscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\p{Is_Blk=_ Miscellaneous SYMBOLSAND_Arrows}', ""); +Expect(0, 11263, '\p{^Is_Blk=_ Miscellaneous SYMBOLSAND_Arrows}', ""); +Expect(0, 11263, '\P{Is_Blk=_ Miscellaneous SYMBOLSAND_Arrows}', ""); +Expect(1, 11263, '\P{^Is_Blk=_ Miscellaneous SYMBOLSAND_Arrows}', ""); +Expect(0, 11007, '\p{Is_Blk=_ Miscellaneous SYMBOLSAND_Arrows}', ""); +Expect(1, 11007, '\p{^Is_Blk=_ Miscellaneous SYMBOLSAND_Arrows}', ""); +Expect(1, 11007, '\P{Is_Blk=_ Miscellaneous SYMBOLSAND_Arrows}', ""); +Expect(0, 11007, '\P{^Is_Blk=_ Miscellaneous SYMBOLSAND_Arrows}', ""); +Error('\p{Block=Halfwidth/a/And Fullwidth forms}'); +Error('\P{Block=Halfwidth/a/And Fullwidth forms}'); +Expect(1, 65519, '\p{Block=halfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\p{^Block=halfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\P{Block=halfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\P{^Block=halfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\p{Block=halfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\p{^Block=halfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\P{Block=halfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\P{^Block=halfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\p{Block= Halfwidth andfullwidth_Forms}', ""); +Expect(0, 65519, '\p{^Block= Halfwidth andfullwidth_Forms}', ""); +Expect(0, 65519, '\P{Block= Halfwidth andfullwidth_Forms}', ""); +Expect(1, 65519, '\P{^Block= Halfwidth andfullwidth_Forms}', ""); +Expect(0, 65279, '\p{Block= Halfwidth andfullwidth_Forms}', ""); +Expect(1, 65279, '\p{^Block= Halfwidth andfullwidth_Forms}', ""); +Expect(1, 65279, '\P{Block= Halfwidth andfullwidth_Forms}', ""); +Expect(0, 65279, '\P{^Block= Halfwidth andfullwidth_Forms}', ""); +Error('\p{Blk= halfwidth_And:=fullwidth FORMS}'); +Error('\P{Blk= halfwidth_And:=fullwidth FORMS}'); +Expect(1, 65519, '\p{Blk=halfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\p{^Blk=halfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\P{Blk=halfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\P{^Blk=halfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\p{Blk=halfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\p{^Blk=halfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\P{Blk=halfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\P{^Blk=halfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\p{Blk=--HALFWIDTH andFULLWIDTH forms}', ""); +Expect(0, 65519, '\p{^Blk=--HALFWIDTH andFULLWIDTH forms}', ""); +Expect(0, 65519, '\P{Blk=--HALFWIDTH andFULLWIDTH forms}', ""); +Expect(1, 65519, '\P{^Blk=--HALFWIDTH andFULLWIDTH forms}', ""); +Expect(0, 65279, '\p{Blk=--HALFWIDTH andFULLWIDTH forms}', ""); +Expect(1, 65279, '\p{^Blk=--HALFWIDTH andFULLWIDTH forms}', ""); +Expect(1, 65279, '\P{Blk=--HALFWIDTH andFULLWIDTH forms}', ""); +Expect(0, 65279, '\P{^Blk=--HALFWIDTH andFULLWIDTH forms}', ""); +Error('\p{Is_Block= HALFWIDTH_And/a/FULLWIDTHForms}'); +Error('\P{Is_Block= HALFWIDTH_And/a/FULLWIDTHForms}'); +Expect(1, 65519, '\p{Is_Block=halfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\p{^Is_Block=halfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\P{Is_Block=halfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\P{^Is_Block=halfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\p{Is_Block=halfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\p{^Is_Block=halfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\P{Is_Block=halfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\P{^Is_Block=halfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\p{Is_Block= Halfwidth_And-fullwidthForms}', ""); +Expect(0, 65519, '\p{^Is_Block= Halfwidth_And-fullwidthForms}', ""); +Expect(0, 65519, '\P{Is_Block= Halfwidth_And-fullwidthForms}', ""); +Expect(1, 65519, '\P{^Is_Block= Halfwidth_And-fullwidthForms}', ""); +Expect(0, 65279, '\p{Is_Block= Halfwidth_And-fullwidthForms}', ""); +Expect(1, 65279, '\p{^Is_Block= Halfwidth_And-fullwidthForms}', ""); +Expect(1, 65279, '\P{Is_Block= Halfwidth_And-fullwidthForms}', ""); +Expect(0, 65279, '\P{^Is_Block= Halfwidth_And-fullwidthForms}', ""); +Error('\p{Is_Blk= Halfwidth AND/a/Fullwidth forms}'); +Error('\P{Is_Blk= Halfwidth AND/a/Fullwidth forms}'); +Expect(1, 65519, '\p{Is_Blk=halfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\p{^Is_Blk=halfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\P{Is_Blk=halfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\P{^Is_Blk=halfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\p{Is_Blk=halfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\p{^Is_Blk=halfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\P{Is_Blk=halfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\P{^Is_Blk=halfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\p{Is_Blk=--halfwidth-AND FULLWIDTHforms}', ""); +Expect(0, 65519, '\p{^Is_Blk=--halfwidth-AND FULLWIDTHforms}', ""); +Expect(0, 65519, '\P{Is_Blk=--halfwidth-AND FULLWIDTHforms}', ""); +Expect(1, 65519, '\P{^Is_Blk=--halfwidth-AND FULLWIDTHforms}', ""); +Expect(0, 65279, '\p{Is_Blk=--halfwidth-AND FULLWIDTHforms}', ""); +Expect(1, 65279, '\p{^Is_Blk=--halfwidth-AND FULLWIDTHforms}', ""); +Expect(1, 65279, '\P{Is_Blk=--halfwidth-AND FULLWIDTHforms}', ""); +Expect(0, 65279, '\P{^Is_Blk=--halfwidth-AND FULLWIDTHforms}', ""); +Error('\p{Block=-supplementary-Private use/a/Area-B}'); +Error('\P{Block=-supplementary-Private use/a/Area-B}'); +Expect(1, 1048576, '\p{Block=supplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\p{^Block=supplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\P{Block=supplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\P{^Block=supplementaryprivateuseareab}', ""); +Expect(0, 7, '\p{Block=supplementaryprivateuseareab}', ""); +Expect(1, 7, '\p{^Block=supplementaryprivateuseareab}', ""); +Expect(1, 7, '\P{Block=supplementaryprivateuseareab}', ""); +Expect(0, 7, '\P{^Block=supplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\p{Block: -_SupplementaryPrivate_Usearea B}', ""); +Expect(0, 1048576, '\p{^Block: -_SupplementaryPrivate_Usearea B}', ""); +Expect(0, 1048576, '\P{Block: -_SupplementaryPrivate_Usearea B}', ""); +Expect(1, 1048576, '\P{^Block: -_SupplementaryPrivate_Usearea B}', ""); +Expect(0, 7, '\p{Block: -_SupplementaryPrivate_Usearea B}', ""); +Expect(1, 7, '\p{^Block: -_SupplementaryPrivate_Usearea B}', ""); +Expect(1, 7, '\P{Block: -_SupplementaryPrivate_Usearea B}', ""); +Expect(0, 7, '\P{^Block: -_SupplementaryPrivate_Usearea B}', ""); +Error('\p{Blk=-SUPPLEMENTARY/a/Private_USE-area-B}'); +Error('\P{Blk=-SUPPLEMENTARY/a/Private_USE-area-B}'); +Expect(1, 1048576, '\p{Blk: supplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\p{^Blk: supplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\P{Blk: supplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\P{^Blk: supplementaryprivateuseareab}', ""); +Expect(0, 7, '\p{Blk: supplementaryprivateuseareab}', ""); +Expect(1, 7, '\p{^Blk: supplementaryprivateuseareab}', ""); +Expect(1, 7, '\P{Blk: supplementaryprivateuseareab}', ""); +Expect(0, 7, '\P{^Blk: supplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\p{Blk: -_Supplementaryprivate-use AREA-B}', ""); +Expect(0, 1048576, '\p{^Blk: -_Supplementaryprivate-use AREA-B}', ""); +Expect(0, 1048576, '\P{Blk: -_Supplementaryprivate-use AREA-B}', ""); +Expect(1, 1048576, '\P{^Blk: -_Supplementaryprivate-use AREA-B}', ""); +Expect(0, 7, '\p{Blk: -_Supplementaryprivate-use AREA-B}', ""); +Expect(1, 7, '\p{^Blk: -_Supplementaryprivate-use AREA-B}', ""); +Expect(1, 7, '\P{Blk: -_Supplementaryprivate-use AREA-B}', ""); +Expect(0, 7, '\P{^Blk: -_Supplementaryprivate-use AREA-B}', ""); +Error('\p{Is_Block=-Supplementary/a/private-usearea B}'); +Error('\P{Is_Block=-Supplementary/a/private-usearea B}'); +Expect(1, 1048576, '\p{Is_Block: supplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\p{^Is_Block: supplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\P{Is_Block: supplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\P{^Is_Block: supplementaryprivateuseareab}', ""); +Expect(0, 7, '\p{Is_Block: supplementaryprivateuseareab}', ""); +Expect(1, 7, '\p{^Is_Block: supplementaryprivateuseareab}', ""); +Expect(1, 7, '\P{Is_Block: supplementaryprivateuseareab}', ""); +Expect(0, 7, '\P{^Is_Block: supplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\p{Is_Block= Supplementary-Private-Use area B}', ""); +Expect(0, 1048576, '\p{^Is_Block= Supplementary-Private-Use area B}', ""); +Expect(0, 1048576, '\P{Is_Block= Supplementary-Private-Use area B}', ""); +Expect(1, 1048576, '\P{^Is_Block= Supplementary-Private-Use area B}', ""); +Expect(0, 7, '\p{Is_Block= Supplementary-Private-Use area B}', ""); +Expect(1, 7, '\p{^Is_Block= Supplementary-Private-Use area B}', ""); +Expect(1, 7, '\P{Is_Block= Supplementary-Private-Use area B}', ""); +Expect(0, 7, '\P{^Is_Block= Supplementary-Private-Use area B}', ""); +Error('\p{Is_Blk=__SUPPLEMENTARY-PRIVATE/a/USE-Areab}'); +Error('\P{Is_Blk=__SUPPLEMENTARY-PRIVATE/a/USE-Areab}'); +Expect(1, 1048576, '\p{Is_Blk=supplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\p{^Is_Blk=supplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\P{Is_Blk=supplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\P{^Is_Blk=supplementaryprivateuseareab}', ""); +Expect(0, 7, '\p{Is_Blk=supplementaryprivateuseareab}', ""); +Expect(1, 7, '\p{^Is_Blk=supplementaryprivateuseareab}', ""); +Expect(1, 7, '\P{Is_Blk=supplementaryprivateuseareab}', ""); +Expect(0, 7, '\P{^Is_Blk=supplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\p{Is_Blk=_Supplementary_Private UseAREA b}', ""); +Expect(0, 1048576, '\p{^Is_Blk=_Supplementary_Private UseAREA b}', ""); +Expect(0, 1048576, '\P{Is_Blk=_Supplementary_Private UseAREA b}', ""); +Expect(1, 1048576, '\P{^Is_Blk=_Supplementary_Private UseAREA b}', ""); +Expect(0, 7, '\p{Is_Blk=_Supplementary_Private UseAREA b}', ""); +Expect(1, 7, '\p{^Is_Blk=_Supplementary_Private UseAREA b}', ""); +Expect(1, 7, '\P{Is_Blk=_Supplementary_Private UseAREA b}', ""); +Expect(0, 7, '\P{^Is_Blk=_Supplementary_Private UseAREA b}', ""); +Error('\p{Block=:= _SUNDANESE}'); +Error('\P{Block=:= _SUNDANESE}'); +Expect(1, 7103, '\p{Block=sundanese}', ""); +Expect(0, 7103, '\p{^Block=sundanese}', ""); +Expect(0, 7103, '\P{Block=sundanese}', ""); +Expect(1, 7103, '\P{^Block=sundanese}', ""); +Expect(0, 7039, '\p{Block=sundanese}', ""); +Expect(1, 7039, '\p{^Block=sundanese}', ""); +Expect(1, 7039, '\P{Block=sundanese}', ""); +Expect(0, 7039, '\P{^Block=sundanese}', ""); +Expect(1, 7103, '\p{Block=_ sundanese}', ""); +Expect(0, 7103, '\p{^Block=_ sundanese}', ""); +Expect(0, 7103, '\P{Block=_ sundanese}', ""); +Expect(1, 7103, '\P{^Block=_ sundanese}', ""); +Expect(0, 7039, '\p{Block=_ sundanese}', ""); +Expect(1, 7039, '\p{^Block=_ sundanese}', ""); +Expect(1, 7039, '\P{Block=_ sundanese}', ""); +Expect(0, 7039, '\P{^Block=_ sundanese}', ""); +Error('\p{Blk=-Sundanese:=}'); +Error('\P{Blk=-Sundanese:=}'); +Expect(1, 7103, '\p{Blk=sundanese}', ""); +Expect(0, 7103, '\p{^Blk=sundanese}', ""); +Expect(0, 7103, '\P{Blk=sundanese}', ""); +Expect(1, 7103, '\P{^Blk=sundanese}', ""); +Expect(0, 7039, '\p{Blk=sundanese}', ""); +Expect(1, 7039, '\p{^Blk=sundanese}', ""); +Expect(1, 7039, '\P{Blk=sundanese}', ""); +Expect(0, 7039, '\P{^Blk=sundanese}', ""); +Expect(1, 7103, '\p{Blk= SUNDANESE}', ""); +Expect(0, 7103, '\p{^Blk= SUNDANESE}', ""); +Expect(0, 7103, '\P{Blk= SUNDANESE}', ""); +Expect(1, 7103, '\P{^Blk= SUNDANESE}', ""); +Expect(0, 7039, '\p{Blk= SUNDANESE}', ""); +Expect(1, 7039, '\p{^Blk= SUNDANESE}', ""); +Expect(1, 7039, '\P{Blk= SUNDANESE}', ""); +Expect(0, 7039, '\P{^Blk= SUNDANESE}', ""); +Error('\p{Is_Block:_SUNDANESE/a/}'); +Error('\P{Is_Block:_SUNDANESE/a/}'); +Expect(1, 7103, '\p{Is_Block=sundanese}', ""); +Expect(0, 7103, '\p{^Is_Block=sundanese}', ""); +Expect(0, 7103, '\P{Is_Block=sundanese}', ""); +Expect(1, 7103, '\P{^Is_Block=sundanese}', ""); +Expect(0, 7039, '\p{Is_Block=sundanese}', ""); +Expect(1, 7039, '\p{^Is_Block=sundanese}', ""); +Expect(1, 7039, '\P{Is_Block=sundanese}', ""); +Expect(0, 7039, '\P{^Is_Block=sundanese}', ""); +Expect(1, 7103, '\p{Is_Block= SUNDANESE}', ""); +Expect(0, 7103, '\p{^Is_Block= SUNDANESE}', ""); +Expect(0, 7103, '\P{Is_Block= SUNDANESE}', ""); +Expect(1, 7103, '\P{^Is_Block= SUNDANESE}', ""); +Expect(0, 7039, '\p{Is_Block= SUNDANESE}', ""); +Expect(1, 7039, '\p{^Is_Block= SUNDANESE}', ""); +Expect(1, 7039, '\P{Is_Block= SUNDANESE}', ""); +Expect(0, 7039, '\P{^Is_Block= SUNDANESE}', ""); +Error('\p{Is_Blk=/a/ Sundanese}'); +Error('\P{Is_Blk=/a/ Sundanese}'); +Expect(1, 7103, '\p{Is_Blk=sundanese}', ""); +Expect(0, 7103, '\p{^Is_Blk=sundanese}', ""); +Expect(0, 7103, '\P{Is_Blk=sundanese}', ""); +Expect(1, 7103, '\P{^Is_Blk=sundanese}', ""); +Expect(0, 7039, '\p{Is_Blk=sundanese}', ""); +Expect(1, 7039, '\p{^Is_Blk=sundanese}', ""); +Expect(1, 7039, '\P{Is_Blk=sundanese}', ""); +Expect(0, 7039, '\P{^Is_Blk=sundanese}', ""); +Expect(1, 7103, '\p{Is_Blk=__sundanese}', ""); +Expect(0, 7103, '\p{^Is_Blk=__sundanese}', ""); +Expect(0, 7103, '\P{Is_Blk=__sundanese}', ""); +Expect(1, 7103, '\P{^Is_Blk=__sundanese}', ""); +Expect(0, 7039, '\p{Is_Blk=__sundanese}', ""); +Expect(1, 7039, '\p{^Is_Blk=__sundanese}', ""); +Expect(1, 7039, '\P{Is_Blk=__sundanese}', ""); +Expect(0, 7039, '\P{^Is_Blk=__sundanese}', ""); +Error('\p{Block=_ENCLOSED Alphanumerics/a/}'); +Error('\P{Block=_ENCLOSED Alphanumerics/a/}'); +Expect(1, 9471, '\p{Block:enclosedalphanumerics}', ""); +Expect(0, 9471, '\p{^Block:enclosedalphanumerics}', ""); +Expect(0, 9471, '\P{Block:enclosedalphanumerics}', ""); +Expect(1, 9471, '\P{^Block:enclosedalphanumerics}', ""); +Expect(0, 9311, '\p{Block:enclosedalphanumerics}', ""); +Expect(1, 9311, '\p{^Block:enclosedalphanumerics}', ""); +Expect(1, 9311, '\P{Block:enclosedalphanumerics}', ""); +Expect(0, 9311, '\P{^Block:enclosedalphanumerics}', ""); +Expect(1, 9471, '\p{Block= enclosed ALPHANUMERICS}', ""); +Expect(0, 9471, '\p{^Block= enclosed ALPHANUMERICS}', ""); +Expect(0, 9471, '\P{Block= enclosed ALPHANUMERICS}', ""); +Expect(1, 9471, '\P{^Block= enclosed ALPHANUMERICS}', ""); +Expect(0, 9311, '\p{Block= enclosed ALPHANUMERICS}', ""); +Expect(1, 9311, '\p{^Block= enclosed ALPHANUMERICS}', ""); +Expect(1, 9311, '\P{Block= enclosed ALPHANUMERICS}', ""); +Expect(0, 9311, '\P{^Block= enclosed ALPHANUMERICS}', ""); +Error('\p{Blk=-Enclosed-alphanumerics:=}'); +Error('\P{Blk=-Enclosed-alphanumerics:=}'); +Expect(1, 9471, '\p{Blk=enclosedalphanumerics}', ""); +Expect(0, 9471, '\p{^Blk=enclosedalphanumerics}', ""); +Expect(0, 9471, '\P{Blk=enclosedalphanumerics}', ""); +Expect(1, 9471, '\P{^Blk=enclosedalphanumerics}', ""); +Expect(0, 9311, '\p{Blk=enclosedalphanumerics}', ""); +Expect(1, 9311, '\p{^Blk=enclosedalphanumerics}', ""); +Expect(1, 9311, '\P{Blk=enclosedalphanumerics}', ""); +Expect(0, 9311, '\P{^Blk=enclosedalphanumerics}', ""); +Expect(1, 9471, '\p{Blk= Enclosed ALPHANUMERICS}', ""); +Expect(0, 9471, '\p{^Blk= Enclosed ALPHANUMERICS}', ""); +Expect(0, 9471, '\P{Blk= Enclosed ALPHANUMERICS}', ""); +Expect(1, 9471, '\P{^Blk= Enclosed ALPHANUMERICS}', ""); +Expect(0, 9311, '\p{Blk= Enclosed ALPHANUMERICS}', ""); +Expect(1, 9311, '\p{^Blk= Enclosed ALPHANUMERICS}', ""); +Expect(1, 9311, '\P{Blk= Enclosed ALPHANUMERICS}', ""); +Expect(0, 9311, '\P{^Blk= Enclosed ALPHANUMERICS}', ""); +Error('\p{Is_Block= Enclosed/a/Alphanumerics}'); +Error('\P{Is_Block= Enclosed/a/Alphanumerics}'); +Expect(1, 9471, '\p{Is_Block=enclosedalphanumerics}', ""); +Expect(0, 9471, '\p{^Is_Block=enclosedalphanumerics}', ""); +Expect(0, 9471, '\P{Is_Block=enclosedalphanumerics}', ""); +Expect(1, 9471, '\P{^Is_Block=enclosedalphanumerics}', ""); +Expect(0, 9311, '\p{Is_Block=enclosedalphanumerics}', ""); +Expect(1, 9311, '\p{^Is_Block=enclosedalphanumerics}', ""); +Expect(1, 9311, '\P{Is_Block=enclosedalphanumerics}', ""); +Expect(0, 9311, '\P{^Is_Block=enclosedalphanumerics}', ""); +Expect(1, 9471, '\p{Is_Block=-_ENCLOSEDAlphanumerics}', ""); +Expect(0, 9471, '\p{^Is_Block=-_ENCLOSEDAlphanumerics}', ""); +Expect(0, 9471, '\P{Is_Block=-_ENCLOSEDAlphanumerics}', ""); +Expect(1, 9471, '\P{^Is_Block=-_ENCLOSEDAlphanumerics}', ""); +Expect(0, 9311, '\p{Is_Block=-_ENCLOSEDAlphanumerics}', ""); +Expect(1, 9311, '\p{^Is_Block=-_ENCLOSEDAlphanumerics}', ""); +Expect(1, 9311, '\P{Is_Block=-_ENCLOSEDAlphanumerics}', ""); +Expect(0, 9311, '\P{^Is_Block=-_ENCLOSEDAlphanumerics}', ""); +Error('\p{Is_Blk=:=_Enclosed Alphanumerics}'); +Error('\P{Is_Blk=:=_Enclosed Alphanumerics}'); +Expect(1, 9471, '\p{Is_Blk=enclosedalphanumerics}', ""); +Expect(0, 9471, '\p{^Is_Blk=enclosedalphanumerics}', ""); +Expect(0, 9471, '\P{Is_Blk=enclosedalphanumerics}', ""); +Expect(1, 9471, '\P{^Is_Blk=enclosedalphanumerics}', ""); +Expect(0, 9311, '\p{Is_Blk=enclosedalphanumerics}', ""); +Expect(1, 9311, '\p{^Is_Blk=enclosedalphanumerics}', ""); +Expect(1, 9311, '\P{Is_Blk=enclosedalphanumerics}', ""); +Expect(0, 9311, '\P{^Is_Blk=enclosedalphanumerics}', ""); +Expect(1, 9471, '\p{Is_Blk=_Enclosed ALPHANUMERICS}', ""); +Expect(0, 9471, '\p{^Is_Blk=_Enclosed ALPHANUMERICS}', ""); +Expect(0, 9471, '\P{Is_Blk=_Enclosed ALPHANUMERICS}', ""); +Expect(1, 9471, '\P{^Is_Blk=_Enclosed ALPHANUMERICS}', ""); +Expect(0, 9311, '\p{Is_Blk=_Enclosed ALPHANUMERICS}', ""); +Expect(1, 9311, '\p{^Is_Blk=_Enclosed ALPHANUMERICS}', ""); +Expect(1, 9311, '\P{Is_Blk=_Enclosed ALPHANUMERICS}', ""); +Expect(0, 9311, '\P{^Is_Blk=_Enclosed ALPHANUMERICS}', ""); +Error('\p{Block= _Tags:=}'); +Error('\P{Block= _Tags:=}'); +Expect(1, 917631, '\p{Block=tags}', ""); +Expect(0, 917631, '\p{^Block=tags}', ""); +Expect(0, 917631, '\P{Block=tags}', ""); +Expect(1, 917631, '\P{^Block=tags}', ""); +Expect(0, 7, '\p{Block=tags}', ""); +Expect(1, 7, '\p{^Block=tags}', ""); +Expect(1, 7, '\P{Block=tags}', ""); +Expect(0, 7, '\P{^Block=tags}', ""); +Expect(1, 917631, '\p{Block=_Tags}', ""); +Expect(0, 917631, '\p{^Block=_Tags}', ""); +Expect(0, 917631, '\P{Block=_Tags}', ""); +Expect(1, 917631, '\P{^Block=_Tags}', ""); +Expect(0, 7, '\p{Block=_Tags}', ""); +Expect(1, 7, '\p{^Block=_Tags}', ""); +Expect(1, 7, '\P{Block=_Tags}', ""); +Expect(0, 7, '\P{^Block=_Tags}', ""); +Error('\p{Blk= :=tags}'); +Error('\P{Blk= :=tags}'); +Expect(1, 917631, '\p{Blk=tags}', ""); +Expect(0, 917631, '\p{^Blk=tags}', ""); +Expect(0, 917631, '\P{Blk=tags}', ""); +Expect(1, 917631, '\P{^Blk=tags}', ""); +Expect(0, 7, '\p{Blk=tags}', ""); +Expect(1, 7, '\p{^Blk=tags}', ""); +Expect(1, 7, '\P{Blk=tags}', ""); +Expect(0, 7, '\P{^Blk=tags}', ""); +Expect(1, 917631, '\p{Blk= TAGS}', ""); +Expect(0, 917631, '\p{^Blk= TAGS}', ""); +Expect(0, 917631, '\P{Blk= TAGS}', ""); +Expect(1, 917631, '\P{^Blk= TAGS}', ""); +Expect(0, 7, '\p{Blk= TAGS}', ""); +Expect(1, 7, '\p{^Blk= TAGS}', ""); +Expect(1, 7, '\P{Blk= TAGS}', ""); +Expect(0, 7, '\P{^Blk= TAGS}', ""); +Error('\p{Is_Block=_ Tags:=}'); +Error('\P{Is_Block=_ Tags:=}'); +Expect(1, 917631, '\p{Is_Block=tags}', ""); +Expect(0, 917631, '\p{^Is_Block=tags}', ""); +Expect(0, 917631, '\P{Is_Block=tags}', ""); +Expect(1, 917631, '\P{^Is_Block=tags}', ""); +Expect(0, 7, '\p{Is_Block=tags}', ""); +Expect(1, 7, '\p{^Is_Block=tags}', ""); +Expect(1, 7, '\P{Is_Block=tags}', ""); +Expect(0, 7, '\P{^Is_Block=tags}', ""); +Expect(1, 917631, '\p{Is_Block=_ tags}', ""); +Expect(0, 917631, '\p{^Is_Block=_ tags}', ""); +Expect(0, 917631, '\P{Is_Block=_ tags}', ""); +Expect(1, 917631, '\P{^Is_Block=_ tags}', ""); +Expect(0, 7, '\p{Is_Block=_ tags}', ""); +Expect(1, 7, '\p{^Is_Block=_ tags}', ""); +Expect(1, 7, '\P{Is_Block=_ tags}', ""); +Expect(0, 7, '\P{^Is_Block=_ tags}', ""); +Error('\p{Is_Blk: -:=tags}'); +Error('\P{Is_Blk: -:=tags}'); +Expect(1, 917631, '\p{Is_Blk=tags}', ""); +Expect(0, 917631, '\p{^Is_Blk=tags}', ""); +Expect(0, 917631, '\P{Is_Blk=tags}', ""); +Expect(1, 917631, '\P{^Is_Blk=tags}', ""); +Expect(0, 7, '\p{Is_Blk=tags}', ""); +Expect(1, 7, '\p{^Is_Blk=tags}', ""); +Expect(1, 7, '\P{Is_Blk=tags}', ""); +Expect(0, 7, '\P{^Is_Blk=tags}', ""); +Expect(1, 917631, '\p{Is_Blk: __tags}', ""); +Expect(0, 917631, '\p{^Is_Blk: __tags}', ""); +Expect(0, 917631, '\P{Is_Blk: __tags}', ""); +Expect(1, 917631, '\P{^Is_Blk: __tags}', ""); +Expect(0, 7, '\p{Is_Blk: __tags}', ""); +Expect(1, 7, '\p{^Is_Blk: __tags}', ""); +Expect(1, 7, '\P{Is_Blk: __tags}', ""); +Expect(0, 7, '\P{^Is_Blk: __tags}', ""); +Error('\p{Block=_:=MISCELLANEOUSMathematical symbols A}'); +Error('\P{Block=_:=MISCELLANEOUSMathematical symbols A}'); +Expect(1, 10223, '\p{Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\p{^Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\P{Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\P{^Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\p{Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\p{^Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\P{Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\P{^Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\p{Block=-Miscellaneous MATHEMATICAL_symbols A}', ""); +Expect(0, 10223, '\p{^Block=-Miscellaneous MATHEMATICAL_symbols A}', ""); +Expect(0, 10223, '\P{Block=-Miscellaneous MATHEMATICAL_symbols A}', ""); +Expect(1, 10223, '\P{^Block=-Miscellaneous MATHEMATICAL_symbols A}', ""); +Expect(0, 10175, '\p{Block=-Miscellaneous MATHEMATICAL_symbols A}', ""); +Expect(1, 10175, '\p{^Block=-Miscellaneous MATHEMATICAL_symbols A}', ""); +Expect(1, 10175, '\P{Block=-Miscellaneous MATHEMATICAL_symbols A}', ""); +Expect(0, 10175, '\P{^Block=-Miscellaneous MATHEMATICAL_symbols A}', ""); +Error('\p{Blk=_ MiscellaneousMathematical-Symbols:=A}'); +Error('\P{Blk=_ MiscellaneousMathematical-Symbols:=A}'); +Expect(1, 10223, '\p{Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\p{^Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\P{Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\P{^Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\p{Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\p{^Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\P{Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\P{^Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\p{Blk: miscellaneous-MathematicalSymbols_a}', ""); +Expect(0, 10223, '\p{^Blk: miscellaneous-MathematicalSymbols_a}', ""); +Expect(0, 10223, '\P{Blk: miscellaneous-MathematicalSymbols_a}', ""); +Expect(1, 10223, '\P{^Blk: miscellaneous-MathematicalSymbols_a}', ""); +Expect(0, 10175, '\p{Blk: miscellaneous-MathematicalSymbols_a}', ""); +Expect(1, 10175, '\p{^Blk: miscellaneous-MathematicalSymbols_a}', ""); +Expect(1, 10175, '\P{Blk: miscellaneous-MathematicalSymbols_a}', ""); +Expect(0, 10175, '\P{^Blk: miscellaneous-MathematicalSymbols_a}', ""); +Error('\p{Is_Block= -MiscellaneousMATHEMATICAL:=symbols A}'); +Error('\P{Is_Block= -MiscellaneousMATHEMATICAL:=symbols A}'); +Expect(1, 10223, '\p{Is_Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\p{^Is_Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\P{Is_Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\P{^Is_Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\p{Is_Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\p{^Is_Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\P{Is_Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\P{^Is_Block=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\p{Is_Block=_MiscellaneousMathematicalSymbolsA}', ""); +Expect(0, 10223, '\p{^Is_Block=_MiscellaneousMathematicalSymbolsA}', ""); +Expect(0, 10223, '\P{Is_Block=_MiscellaneousMathematicalSymbolsA}', ""); +Expect(1, 10223, '\P{^Is_Block=_MiscellaneousMathematicalSymbolsA}', ""); +Expect(0, 10175, '\p{Is_Block=_MiscellaneousMathematicalSymbolsA}', ""); +Expect(1, 10175, '\p{^Is_Block=_MiscellaneousMathematicalSymbolsA}', ""); +Expect(1, 10175, '\P{Is_Block=_MiscellaneousMathematicalSymbolsA}', ""); +Expect(0, 10175, '\P{^Is_Block=_MiscellaneousMathematicalSymbolsA}', ""); +Error('\p{Is_Blk=- Miscellaneous/a/MATHEMATICAL_Symbols-A}'); +Error('\P{Is_Blk=- Miscellaneous/a/MATHEMATICAL_Symbols-A}'); +Expect(1, 10223, '\p{Is_Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\p{^Is_Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\P{Is_Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\P{^Is_Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\p{Is_Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\p{^Is_Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\P{Is_Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\P{^Is_Blk=miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\p{Is_Blk=- MISCELLANEOUS mathematical_Symbols-A}', ""); +Expect(0, 10223, '\p{^Is_Blk=- MISCELLANEOUS mathematical_Symbols-A}', ""); +Expect(0, 10223, '\P{Is_Blk=- MISCELLANEOUS mathematical_Symbols-A}', ""); +Expect(1, 10223, '\P{^Is_Blk=- MISCELLANEOUS mathematical_Symbols-A}', ""); +Expect(0, 10175, '\p{Is_Blk=- MISCELLANEOUS mathematical_Symbols-A}', ""); +Expect(1, 10175, '\p{^Is_Blk=- MISCELLANEOUS mathematical_Symbols-A}', ""); +Expect(1, 10175, '\P{Is_Blk=- MISCELLANEOUS mathematical_Symbols-A}', ""); +Expect(0, 10175, '\P{^Is_Blk=- MISCELLANEOUS mathematical_Symbols-A}', ""); +Error('\p{Block: _ braille/a/PATTERNS}'); +Error('\P{Block: _ braille/a/PATTERNS}'); +Expect(1, 10495, '\p{Block=braillepatterns}', ""); +Expect(0, 10495, '\p{^Block=braillepatterns}', ""); +Expect(0, 10495, '\P{Block=braillepatterns}', ""); +Expect(1, 10495, '\P{^Block=braillepatterns}', ""); +Expect(0, 10239, '\p{Block=braillepatterns}', ""); +Expect(1, 10239, '\p{^Block=braillepatterns}', ""); +Expect(1, 10239, '\P{Block=braillepatterns}', ""); +Expect(0, 10239, '\P{^Block=braillepatterns}', ""); +Expect(1, 10495, '\p{Block=_ Braille PATTERNS}', ""); +Expect(0, 10495, '\p{^Block=_ Braille PATTERNS}', ""); +Expect(0, 10495, '\P{Block=_ Braille PATTERNS}', ""); +Expect(1, 10495, '\P{^Block=_ Braille PATTERNS}', ""); +Expect(0, 10239, '\p{Block=_ Braille PATTERNS}', ""); +Expect(1, 10239, '\p{^Block=_ Braille PATTERNS}', ""); +Expect(1, 10239, '\P{Block=_ Braille PATTERNS}', ""); +Expect(0, 10239, '\P{^Block=_ Braille PATTERNS}', ""); +Error('\p{Blk=_-braille_Patterns:=}'); +Error('\P{Blk=_-braille_Patterns:=}'); +Expect(1, 10495, '\p{Blk=braillepatterns}', ""); +Expect(0, 10495, '\p{^Blk=braillepatterns}', ""); +Expect(0, 10495, '\P{Blk=braillepatterns}', ""); +Expect(1, 10495, '\P{^Blk=braillepatterns}', ""); +Expect(0, 10239, '\p{Blk=braillepatterns}', ""); +Expect(1, 10239, '\p{^Blk=braillepatterns}', ""); +Expect(1, 10239, '\P{Blk=braillepatterns}', ""); +Expect(0, 10239, '\P{^Blk=braillepatterns}', ""); +Expect(1, 10495, '\p{Blk=Braille PATTERNS}', ""); +Expect(0, 10495, '\p{^Blk=Braille PATTERNS}', ""); +Expect(0, 10495, '\P{Blk=Braille PATTERNS}', ""); +Expect(1, 10495, '\P{^Blk=Braille PATTERNS}', ""); +Expect(0, 10239, '\p{Blk=Braille PATTERNS}', ""); +Expect(1, 10239, '\p{^Blk=Braille PATTERNS}', ""); +Expect(1, 10239, '\P{Blk=Braille PATTERNS}', ""); +Expect(0, 10239, '\P{^Blk=Braille PATTERNS}', ""); +Error('\p{Is_Block=:=BRAILLE-Patterns}'); +Error('\P{Is_Block=:=BRAILLE-Patterns}'); +Expect(1, 10495, '\p{Is_Block=braillepatterns}', ""); +Expect(0, 10495, '\p{^Is_Block=braillepatterns}', ""); +Expect(0, 10495, '\P{Is_Block=braillepatterns}', ""); +Expect(1, 10495, '\P{^Is_Block=braillepatterns}', ""); +Expect(0, 10239, '\p{Is_Block=braillepatterns}', ""); +Expect(1, 10239, '\p{^Is_Block=braillepatterns}', ""); +Expect(1, 10239, '\P{Is_Block=braillepatterns}', ""); +Expect(0, 10239, '\P{^Is_Block=braillepatterns}', ""); +Expect(1, 10495, '\p{Is_Block= _BraillePATTERNS}', ""); +Expect(0, 10495, '\p{^Is_Block= _BraillePATTERNS}', ""); +Expect(0, 10495, '\P{Is_Block= _BraillePATTERNS}', ""); +Expect(1, 10495, '\P{^Is_Block= _BraillePATTERNS}', ""); +Expect(0, 10239, '\p{Is_Block= _BraillePATTERNS}', ""); +Expect(1, 10239, '\p{^Is_Block= _BraillePATTERNS}', ""); +Expect(1, 10239, '\P{Is_Block= _BraillePATTERNS}', ""); +Expect(0, 10239, '\P{^Is_Block= _BraillePATTERNS}', ""); +Error('\p{Is_Blk=-braille-patterns/a/}'); +Error('\P{Is_Blk=-braille-patterns/a/}'); +Expect(1, 10495, '\p{Is_Blk=braillepatterns}', ""); +Expect(0, 10495, '\p{^Is_Blk=braillepatterns}', ""); +Expect(0, 10495, '\P{Is_Blk=braillepatterns}', ""); +Expect(1, 10495, '\P{^Is_Blk=braillepatterns}', ""); +Expect(0, 10239, '\p{Is_Blk=braillepatterns}', ""); +Expect(1, 10239, '\p{^Is_Blk=braillepatterns}', ""); +Expect(1, 10239, '\P{Is_Blk=braillepatterns}', ""); +Expect(0, 10239, '\P{^Is_Blk=braillepatterns}', ""); +Expect(1, 10495, '\p{Is_Blk=Braille Patterns}', ""); +Expect(0, 10495, '\p{^Is_Blk=Braille Patterns}', ""); +Expect(0, 10495, '\P{Is_Blk=Braille Patterns}', ""); +Expect(1, 10495, '\P{^Is_Blk=Braille Patterns}', ""); +Expect(0, 10239, '\p{Is_Blk=Braille Patterns}', ""); +Expect(1, 10239, '\p{^Is_Blk=Braille Patterns}', ""); +Expect(1, 10239, '\P{Is_Blk=Braille Patterns}', ""); +Expect(0, 10239, '\P{^Is_Blk=Braille Patterns}', ""); +Error('\p{Block: -Oriya/a/}'); +Error('\P{Block: -Oriya/a/}'); +Expect(1, 2943, '\p{Block=oriya}', ""); +Expect(0, 2943, '\p{^Block=oriya}', ""); +Expect(0, 2943, '\P{Block=oriya}', ""); +Expect(1, 2943, '\P{^Block=oriya}', ""); +Expect(0, 2815, '\p{Block=oriya}', ""); +Expect(1, 2815, '\p{^Block=oriya}', ""); +Expect(1, 2815, '\P{Block=oriya}', ""); +Expect(0, 2815, '\P{^Block=oriya}', ""); +Expect(1, 2943, '\p{Block=--Oriya}', ""); +Expect(0, 2943, '\p{^Block=--Oriya}', ""); +Expect(0, 2943, '\P{Block=--Oriya}', ""); +Expect(1, 2943, '\P{^Block=--Oriya}', ""); +Expect(0, 2815, '\p{Block=--Oriya}', ""); +Expect(1, 2815, '\p{^Block=--Oriya}', ""); +Expect(1, 2815, '\P{Block=--Oriya}', ""); +Expect(0, 2815, '\P{^Block=--Oriya}', ""); +Error('\p{Blk: -Oriya/a/}'); +Error('\P{Blk: -Oriya/a/}'); +Expect(1, 2943, '\p{Blk=oriya}', ""); +Expect(0, 2943, '\p{^Blk=oriya}', ""); +Expect(0, 2943, '\P{Blk=oriya}', ""); +Expect(1, 2943, '\P{^Blk=oriya}', ""); +Expect(0, 2815, '\p{Blk=oriya}', ""); +Expect(1, 2815, '\p{^Blk=oriya}', ""); +Expect(1, 2815, '\P{Blk=oriya}', ""); +Expect(0, 2815, '\P{^Blk=oriya}', ""); +Expect(1, 2943, '\p{Blk=-_oriya}', ""); +Expect(0, 2943, '\p{^Blk=-_oriya}', ""); +Expect(0, 2943, '\P{Blk=-_oriya}', ""); +Expect(1, 2943, '\P{^Blk=-_oriya}', ""); +Expect(0, 2815, '\p{Blk=-_oriya}', ""); +Expect(1, 2815, '\p{^Blk=-_oriya}', ""); +Expect(1, 2815, '\P{Blk=-_oriya}', ""); +Expect(0, 2815, '\P{^Blk=-_oriya}', ""); +Error('\p{Is_Block=_ORIYA:=}'); +Error('\P{Is_Block=_ORIYA:=}'); +Expect(1, 2943, '\p{Is_Block=oriya}', ""); +Expect(0, 2943, '\p{^Is_Block=oriya}', ""); +Expect(0, 2943, '\P{Is_Block=oriya}', ""); +Expect(1, 2943, '\P{^Is_Block=oriya}', ""); +Expect(0, 2815, '\p{Is_Block=oriya}', ""); +Expect(1, 2815, '\p{^Is_Block=oriya}', ""); +Expect(1, 2815, '\P{Is_Block=oriya}', ""); +Expect(0, 2815, '\P{^Is_Block=oriya}', ""); +Expect(1, 2943, '\p{Is_Block= Oriya}', ""); +Expect(0, 2943, '\p{^Is_Block= Oriya}', ""); +Expect(0, 2943, '\P{Is_Block= Oriya}', ""); +Expect(1, 2943, '\P{^Is_Block= Oriya}', ""); +Expect(0, 2815, '\p{Is_Block= Oriya}', ""); +Expect(1, 2815, '\p{^Is_Block= Oriya}', ""); +Expect(1, 2815, '\P{Is_Block= Oriya}', ""); +Expect(0, 2815, '\P{^Is_Block= Oriya}', ""); +Error('\p{Is_Blk=/a/_ Oriya}'); +Error('\P{Is_Blk=/a/_ Oriya}'); +Expect(1, 2943, '\p{Is_Blk: oriya}', ""); +Expect(0, 2943, '\p{^Is_Blk: oriya}', ""); +Expect(0, 2943, '\P{Is_Blk: oriya}', ""); +Expect(1, 2943, '\P{^Is_Blk: oriya}', ""); +Expect(0, 2815, '\p{Is_Blk: oriya}', ""); +Expect(1, 2815, '\p{^Is_Blk: oriya}', ""); +Expect(1, 2815, '\P{Is_Blk: oriya}', ""); +Expect(0, 2815, '\P{^Is_Blk: oriya}', ""); +Expect(1, 2943, '\p{Is_Blk=--Oriya}', ""); +Expect(0, 2943, '\p{^Is_Blk=--Oriya}', ""); +Expect(0, 2943, '\P{Is_Blk=--Oriya}', ""); +Expect(1, 2943, '\P{^Is_Blk=--Oriya}', ""); +Expect(0, 2815, '\p{Is_Blk=--Oriya}', ""); +Expect(1, 2815, '\p{^Is_Blk=--Oriya}', ""); +Expect(1, 2815, '\P{Is_Blk=--Oriya}', ""); +Expect(0, 2815, '\P{^Is_Blk=--Oriya}', ""); +Error('\p{Block: := -Linear B_ideograms}'); +Error('\P{Block: := -Linear B_ideograms}'); +Expect(1, 65791, '\p{Block=linearbideograms}', ""); +Expect(0, 65791, '\p{^Block=linearbideograms}', ""); +Expect(0, 65791, '\P{Block=linearbideograms}', ""); +Expect(1, 65791, '\P{^Block=linearbideograms}', ""); +Expect(0, 65663, '\p{Block=linearbideograms}', ""); +Expect(1, 65663, '\p{^Block=linearbideograms}', ""); +Expect(1, 65663, '\P{Block=linearbideograms}', ""); +Expect(0, 65663, '\P{^Block=linearbideograms}', ""); +Expect(1, 65791, '\p{Block= Linear_B_Ideograms}', ""); +Expect(0, 65791, '\p{^Block= Linear_B_Ideograms}', ""); +Expect(0, 65791, '\P{Block= Linear_B_Ideograms}', ""); +Expect(1, 65791, '\P{^Block= Linear_B_Ideograms}', ""); +Expect(0, 65663, '\p{Block= Linear_B_Ideograms}', ""); +Expect(1, 65663, '\p{^Block= Linear_B_Ideograms}', ""); +Expect(1, 65663, '\P{Block= Linear_B_Ideograms}', ""); +Expect(0, 65663, '\P{^Block= Linear_B_Ideograms}', ""); +Error('\p{Blk= LINEAR_b_IDEOGRAMS/a/}'); +Error('\P{Blk= LINEAR_b_IDEOGRAMS/a/}'); +Expect(1, 65791, '\p{Blk=linearbideograms}', ""); +Expect(0, 65791, '\p{^Blk=linearbideograms}', ""); +Expect(0, 65791, '\P{Blk=linearbideograms}', ""); +Expect(1, 65791, '\P{^Blk=linearbideograms}', ""); +Expect(0, 65663, '\p{Blk=linearbideograms}', ""); +Expect(1, 65663, '\p{^Blk=linearbideograms}', ""); +Expect(1, 65663, '\P{Blk=linearbideograms}', ""); +Expect(0, 65663, '\P{^Blk=linearbideograms}', ""); +Expect(1, 65791, '\p{Blk= -LINEAR-b_Ideograms}', ""); +Expect(0, 65791, '\p{^Blk= -LINEAR-b_Ideograms}', ""); +Expect(0, 65791, '\P{Blk= -LINEAR-b_Ideograms}', ""); +Expect(1, 65791, '\P{^Blk= -LINEAR-b_Ideograms}', ""); +Expect(0, 65663, '\p{Blk= -LINEAR-b_Ideograms}', ""); +Expect(1, 65663, '\p{^Blk= -LINEAR-b_Ideograms}', ""); +Expect(1, 65663, '\P{Blk= -LINEAR-b_Ideograms}', ""); +Expect(0, 65663, '\P{^Blk= -LINEAR-b_Ideograms}', ""); +Error('\p{Is_Block= Linear/a/B IDEOGRAMS}'); +Error('\P{Is_Block= Linear/a/B IDEOGRAMS}'); +Expect(1, 65791, '\p{Is_Block=linearbideograms}', ""); +Expect(0, 65791, '\p{^Is_Block=linearbideograms}', ""); +Expect(0, 65791, '\P{Is_Block=linearbideograms}', ""); +Expect(1, 65791, '\P{^Is_Block=linearbideograms}', ""); +Expect(0, 65663, '\p{Is_Block=linearbideograms}', ""); +Expect(1, 65663, '\p{^Is_Block=linearbideograms}', ""); +Expect(1, 65663, '\P{Is_Block=linearbideograms}', ""); +Expect(0, 65663, '\P{^Is_Block=linearbideograms}', ""); +Expect(1, 65791, '\p{Is_Block=- Linear_b IDEOGRAMS}', ""); +Expect(0, 65791, '\p{^Is_Block=- Linear_b IDEOGRAMS}', ""); +Expect(0, 65791, '\P{Is_Block=- Linear_b IDEOGRAMS}', ""); +Expect(1, 65791, '\P{^Is_Block=- Linear_b IDEOGRAMS}', ""); +Expect(0, 65663, '\p{Is_Block=- Linear_b IDEOGRAMS}', ""); +Expect(1, 65663, '\p{^Is_Block=- Linear_b IDEOGRAMS}', ""); +Expect(1, 65663, '\P{Is_Block=- Linear_b IDEOGRAMS}', ""); +Expect(0, 65663, '\P{^Is_Block=- Linear_b IDEOGRAMS}', ""); +Error('\p{Is_Blk=_/a/linear_B Ideograms}'); +Error('\P{Is_Blk=_/a/linear_B Ideograms}'); +Expect(1, 65791, '\p{Is_Blk=linearbideograms}', ""); +Expect(0, 65791, '\p{^Is_Blk=linearbideograms}', ""); +Expect(0, 65791, '\P{Is_Blk=linearbideograms}', ""); +Expect(1, 65791, '\P{^Is_Blk=linearbideograms}', ""); +Expect(0, 65663, '\p{Is_Blk=linearbideograms}', ""); +Expect(1, 65663, '\p{^Is_Blk=linearbideograms}', ""); +Expect(1, 65663, '\P{Is_Blk=linearbideograms}', ""); +Expect(0, 65663, '\P{^Is_Blk=linearbideograms}', ""); +Expect(1, 65791, '\p{Is_Blk=LinearBIDEOGRAMS}', ""); +Expect(0, 65791, '\p{^Is_Blk=LinearBIDEOGRAMS}', ""); +Expect(0, 65791, '\P{Is_Blk=LinearBIDEOGRAMS}', ""); +Expect(1, 65791, '\P{^Is_Blk=LinearBIDEOGRAMS}', ""); +Expect(0, 65663, '\p{Is_Blk=LinearBIDEOGRAMS}', ""); +Expect(1, 65663, '\p{^Is_Blk=LinearBIDEOGRAMS}', ""); +Expect(1, 65663, '\P{Is_Blk=LinearBIDEOGRAMS}', ""); +Expect(0, 65663, '\P{^Is_Blk=LinearBIDEOGRAMS}', ""); +Error('\p{Block=:=CHEROKEE}'); +Error('\P{Block=:=CHEROKEE}'); +Expect(1, 5119, '\p{Block=cherokee}', ""); +Expect(0, 5119, '\p{^Block=cherokee}', ""); +Expect(0, 5119, '\P{Block=cherokee}', ""); +Expect(1, 5119, '\P{^Block=cherokee}', ""); +Expect(0, 5023, '\p{Block=cherokee}', ""); +Expect(1, 5023, '\p{^Block=cherokee}', ""); +Expect(1, 5023, '\P{Block=cherokee}', ""); +Expect(0, 5023, '\P{^Block=cherokee}', ""); +Expect(1, 5119, '\p{Block= CHEROKEE}', ""); +Expect(0, 5119, '\p{^Block= CHEROKEE}', ""); +Expect(0, 5119, '\P{Block= CHEROKEE}', ""); +Expect(1, 5119, '\P{^Block= CHEROKEE}', ""); +Expect(0, 5023, '\p{Block= CHEROKEE}', ""); +Expect(1, 5023, '\p{^Block= CHEROKEE}', ""); +Expect(1, 5023, '\P{Block= CHEROKEE}', ""); +Expect(0, 5023, '\P{^Block= CHEROKEE}', ""); +Error('\p{Blk=:=cherokee}'); +Error('\P{Blk=:=cherokee}'); +Expect(1, 5119, '\p{Blk=cherokee}', ""); +Expect(0, 5119, '\p{^Blk=cherokee}', ""); +Expect(0, 5119, '\P{Blk=cherokee}', ""); +Expect(1, 5119, '\P{^Blk=cherokee}', ""); +Expect(0, 5023, '\p{Blk=cherokee}', ""); +Expect(1, 5023, '\p{^Blk=cherokee}', ""); +Expect(1, 5023, '\P{Blk=cherokee}', ""); +Expect(0, 5023, '\P{^Blk=cherokee}', ""); +Expect(1, 5119, '\p{Blk= _CHEROKEE}', ""); +Expect(0, 5119, '\p{^Blk= _CHEROKEE}', ""); +Expect(0, 5119, '\P{Blk= _CHEROKEE}', ""); +Expect(1, 5119, '\P{^Blk= _CHEROKEE}', ""); +Expect(0, 5023, '\p{Blk= _CHEROKEE}', ""); +Expect(1, 5023, '\p{^Blk= _CHEROKEE}', ""); +Expect(1, 5023, '\P{Blk= _CHEROKEE}', ""); +Expect(0, 5023, '\P{^Blk= _CHEROKEE}', ""); +Error('\p{Is_Block=/a/_CHEROKEE}'); +Error('\P{Is_Block=/a/_CHEROKEE}'); +Expect(1, 5119, '\p{Is_Block=cherokee}', ""); +Expect(0, 5119, '\p{^Is_Block=cherokee}', ""); +Expect(0, 5119, '\P{Is_Block=cherokee}', ""); +Expect(1, 5119, '\P{^Is_Block=cherokee}', ""); +Expect(0, 5023, '\p{Is_Block=cherokee}', ""); +Expect(1, 5023, '\p{^Is_Block=cherokee}', ""); +Expect(1, 5023, '\P{Is_Block=cherokee}', ""); +Expect(0, 5023, '\P{^Is_Block=cherokee}', ""); +Expect(1, 5119, '\p{Is_Block=_Cherokee}', ""); +Expect(0, 5119, '\p{^Is_Block=_Cherokee}', ""); +Expect(0, 5119, '\P{Is_Block=_Cherokee}', ""); +Expect(1, 5119, '\P{^Is_Block=_Cherokee}', ""); +Expect(0, 5023, '\p{Is_Block=_Cherokee}', ""); +Expect(1, 5023, '\p{^Is_Block=_Cherokee}', ""); +Expect(1, 5023, '\P{Is_Block=_Cherokee}', ""); +Expect(0, 5023, '\P{^Is_Block=_Cherokee}', ""); +Error('\p{Is_Blk=_cherokee/a/}'); +Error('\P{Is_Blk=_cherokee/a/}'); +Expect(1, 5119, '\p{Is_Blk=cherokee}', ""); +Expect(0, 5119, '\p{^Is_Blk=cherokee}', ""); +Expect(0, 5119, '\P{Is_Blk=cherokee}', ""); +Expect(1, 5119, '\P{^Is_Blk=cherokee}', ""); +Expect(0, 5023, '\p{Is_Blk=cherokee}', ""); +Expect(1, 5023, '\p{^Is_Blk=cherokee}', ""); +Expect(1, 5023, '\P{Is_Blk=cherokee}', ""); +Expect(0, 5023, '\P{^Is_Blk=cherokee}', ""); +Expect(1, 5119, '\p{Is_Blk=_ Cherokee}', ""); +Expect(0, 5119, '\p{^Is_Blk=_ Cherokee}', ""); +Expect(0, 5119, '\P{Is_Blk=_ Cherokee}', ""); +Expect(1, 5119, '\P{^Is_Blk=_ Cherokee}', ""); +Expect(0, 5023, '\p{Is_Blk=_ Cherokee}', ""); +Expect(1, 5023, '\p{^Is_Blk=_ Cherokee}', ""); +Expect(1, 5023, '\P{Is_Blk=_ Cherokee}', ""); +Expect(0, 5023, '\P{^Is_Blk=_ Cherokee}', ""); +Error('\p{Block=:= BOPOMOFO_Extended}'); +Error('\P{Block=:= BOPOMOFO_Extended}'); +Expect(1, 12735, '\p{Block=bopomofoextended}', ""); +Expect(0, 12735, '\p{^Block=bopomofoextended}', ""); +Expect(0, 12735, '\P{Block=bopomofoextended}', ""); +Expect(1, 12735, '\P{^Block=bopomofoextended}', ""); +Expect(0, 12703, '\p{Block=bopomofoextended}', ""); +Expect(1, 12703, '\p{^Block=bopomofoextended}', ""); +Expect(1, 12703, '\P{Block=bopomofoextended}', ""); +Expect(0, 12703, '\P{^Block=bopomofoextended}', ""); +Expect(1, 12735, '\p{Block= bopomofo Extended}', ""); +Expect(0, 12735, '\p{^Block= bopomofo Extended}', ""); +Expect(0, 12735, '\P{Block= bopomofo Extended}', ""); +Expect(1, 12735, '\P{^Block= bopomofo Extended}', ""); +Expect(0, 12703, '\p{Block= bopomofo Extended}', ""); +Expect(1, 12703, '\p{^Block= bopomofo Extended}', ""); +Expect(1, 12703, '\P{Block= bopomofo Extended}', ""); +Expect(0, 12703, '\P{^Block= bopomofo Extended}', ""); +Error('\p{Blk=__Bopomofo/a/EXTENDED}'); +Error('\P{Blk=__Bopomofo/a/EXTENDED}'); +Expect(1, 12735, '\p{Blk=bopomofoextended}', ""); +Expect(0, 12735, '\p{^Blk=bopomofoextended}', ""); +Expect(0, 12735, '\P{Blk=bopomofoextended}', ""); +Expect(1, 12735, '\P{^Blk=bopomofoextended}', ""); +Expect(0, 12703, '\p{Blk=bopomofoextended}', ""); +Expect(1, 12703, '\p{^Blk=bopomofoextended}', ""); +Expect(1, 12703, '\P{Blk=bopomofoextended}', ""); +Expect(0, 12703, '\P{^Blk=bopomofoextended}', ""); +Expect(1, 12735, '\p{Blk= Bopomofo extended}', ""); +Expect(0, 12735, '\p{^Blk= Bopomofo extended}', ""); +Expect(0, 12735, '\P{Blk= Bopomofo extended}', ""); +Expect(1, 12735, '\P{^Blk= Bopomofo extended}', ""); +Expect(0, 12703, '\p{Blk= Bopomofo extended}', ""); +Expect(1, 12703, '\p{^Blk= Bopomofo extended}', ""); +Expect(1, 12703, '\P{Blk= Bopomofo extended}', ""); +Expect(0, 12703, '\P{^Blk= Bopomofo extended}', ""); +Error('\p{Is_Block= /a/bopomofo extended}'); +Error('\P{Is_Block= /a/bopomofo extended}'); +Expect(1, 12735, '\p{Is_Block=bopomofoextended}', ""); +Expect(0, 12735, '\p{^Is_Block=bopomofoextended}', ""); +Expect(0, 12735, '\P{Is_Block=bopomofoextended}', ""); +Expect(1, 12735, '\P{^Is_Block=bopomofoextended}', ""); +Expect(0, 12703, '\p{Is_Block=bopomofoextended}', ""); +Expect(1, 12703, '\p{^Is_Block=bopomofoextended}', ""); +Expect(1, 12703, '\P{Is_Block=bopomofoextended}', ""); +Expect(0, 12703, '\P{^Is_Block=bopomofoextended}', ""); +Expect(1, 12735, '\p{Is_Block= BopomofoExtended}', ""); +Expect(0, 12735, '\p{^Is_Block= BopomofoExtended}', ""); +Expect(0, 12735, '\P{Is_Block= BopomofoExtended}', ""); +Expect(1, 12735, '\P{^Is_Block= BopomofoExtended}', ""); +Expect(0, 12703, '\p{Is_Block= BopomofoExtended}', ""); +Expect(1, 12703, '\p{^Is_Block= BopomofoExtended}', ""); +Expect(1, 12703, '\P{Is_Block= BopomofoExtended}', ""); +Expect(0, 12703, '\P{^Is_Block= BopomofoExtended}', ""); +Error('\p{Is_Blk=_ BOPOMOFO:=Extended}'); +Error('\P{Is_Blk=_ BOPOMOFO:=Extended}'); +Expect(1, 12735, '\p{Is_Blk=bopomofoextended}', ""); +Expect(0, 12735, '\p{^Is_Blk=bopomofoextended}', ""); +Expect(0, 12735, '\P{Is_Blk=bopomofoextended}', ""); +Expect(1, 12735, '\P{^Is_Blk=bopomofoextended}', ""); +Expect(0, 12703, '\p{Is_Blk=bopomofoextended}', ""); +Expect(1, 12703, '\p{^Is_Blk=bopomofoextended}', ""); +Expect(1, 12703, '\P{Is_Blk=bopomofoextended}', ""); +Expect(0, 12703, '\P{^Is_Blk=bopomofoextended}', ""); +Expect(1, 12735, '\p{Is_Blk: _ Bopomofo Extended}', ""); +Expect(0, 12735, '\p{^Is_Blk: _ Bopomofo Extended}', ""); +Expect(0, 12735, '\P{Is_Blk: _ Bopomofo Extended}', ""); +Expect(1, 12735, '\P{^Is_Blk: _ Bopomofo Extended}', ""); +Expect(0, 12703, '\p{Is_Blk: _ Bopomofo Extended}', ""); +Expect(1, 12703, '\p{^Is_Blk: _ Bopomofo Extended}', ""); +Expect(1, 12703, '\P{Is_Blk: _ Bopomofo Extended}', ""); +Expect(0, 12703, '\P{^Is_Blk: _ Bopomofo Extended}', ""); +Error('\p{Block=_ogham/a/}'); +Error('\P{Block=_ogham/a/}'); +Expect(1, 5791, '\p{Block=ogham}', ""); +Expect(0, 5791, '\p{^Block=ogham}', ""); +Expect(0, 5791, '\P{Block=ogham}', ""); +Expect(1, 5791, '\P{^Block=ogham}', ""); +Expect(0, 5759, '\p{Block=ogham}', ""); +Expect(1, 5759, '\p{^Block=ogham}', ""); +Expect(1, 5759, '\P{Block=ogham}', ""); +Expect(0, 5759, '\P{^Block=ogham}', ""); +Expect(1, 5791, '\p{Block=_OGHAM}', ""); +Expect(0, 5791, '\p{^Block=_OGHAM}', ""); +Expect(0, 5791, '\P{Block=_OGHAM}', ""); +Expect(1, 5791, '\P{^Block=_OGHAM}', ""); +Expect(0, 5759, '\p{Block=_OGHAM}', ""); +Expect(1, 5759, '\p{^Block=_OGHAM}', ""); +Expect(1, 5759, '\P{Block=_OGHAM}', ""); +Expect(0, 5759, '\P{^Block=_OGHAM}', ""); +Error('\p{Blk= /a/Ogham}'); +Error('\P{Blk= /a/Ogham}'); +Expect(1, 5791, '\p{Blk=ogham}', ""); +Expect(0, 5791, '\p{^Blk=ogham}', ""); +Expect(0, 5791, '\P{Blk=ogham}', ""); +Expect(1, 5791, '\P{^Blk=ogham}', ""); +Expect(0, 5759, '\p{Blk=ogham}', ""); +Expect(1, 5759, '\p{^Blk=ogham}', ""); +Expect(1, 5759, '\P{Blk=ogham}', ""); +Expect(0, 5759, '\P{^Blk=ogham}', ""); +Expect(1, 5791, '\p{Blk= Ogham}', ""); +Expect(0, 5791, '\p{^Blk= Ogham}', ""); +Expect(0, 5791, '\P{Blk= Ogham}', ""); +Expect(1, 5791, '\P{^Blk= Ogham}', ""); +Expect(0, 5759, '\p{Blk= Ogham}', ""); +Expect(1, 5759, '\p{^Blk= Ogham}', ""); +Expect(1, 5759, '\P{Blk= Ogham}', ""); +Expect(0, 5759, '\P{^Blk= Ogham}', ""); +Error('\p{Is_Block: _:=Ogham}'); +Error('\P{Is_Block: _:=Ogham}'); +Expect(1, 5791, '\p{Is_Block=ogham}', ""); +Expect(0, 5791, '\p{^Is_Block=ogham}', ""); +Expect(0, 5791, '\P{Is_Block=ogham}', ""); +Expect(1, 5791, '\P{^Is_Block=ogham}', ""); +Expect(0, 5759, '\p{Is_Block=ogham}', ""); +Expect(1, 5759, '\p{^Is_Block=ogham}', ""); +Expect(1, 5759, '\P{Is_Block=ogham}', ""); +Expect(0, 5759, '\P{^Is_Block=ogham}', ""); +Expect(1, 5791, '\p{Is_Block=_OGHAM}', ""); +Expect(0, 5791, '\p{^Is_Block=_OGHAM}', ""); +Expect(0, 5791, '\P{Is_Block=_OGHAM}', ""); +Expect(1, 5791, '\P{^Is_Block=_OGHAM}', ""); +Expect(0, 5759, '\p{Is_Block=_OGHAM}', ""); +Expect(1, 5759, '\p{^Is_Block=_OGHAM}', ""); +Expect(1, 5759, '\P{Is_Block=_OGHAM}', ""); +Expect(0, 5759, '\P{^Is_Block=_OGHAM}', ""); +Error('\p{Is_Blk= _OGHAM/a/}'); +Error('\P{Is_Blk= _OGHAM/a/}'); +Expect(1, 5791, '\p{Is_Blk=ogham}', ""); +Expect(0, 5791, '\p{^Is_Blk=ogham}', ""); +Expect(0, 5791, '\P{Is_Blk=ogham}', ""); +Expect(1, 5791, '\P{^Is_Blk=ogham}', ""); +Expect(0, 5759, '\p{Is_Blk=ogham}', ""); +Expect(1, 5759, '\p{^Is_Blk=ogham}', ""); +Expect(1, 5759, '\P{Is_Blk=ogham}', ""); +Expect(0, 5759, '\P{^Is_Blk=ogham}', ""); +Expect(1, 5791, '\p{Is_Blk=_ Ogham}', ""); +Expect(0, 5791, '\p{^Is_Blk=_ Ogham}', ""); +Expect(0, 5791, '\P{Is_Blk=_ Ogham}', ""); +Expect(1, 5791, '\P{^Is_Blk=_ Ogham}', ""); +Expect(0, 5759, '\p{Is_Blk=_ Ogham}', ""); +Expect(1, 5759, '\p{^Is_Blk=_ Ogham}', ""); +Expect(1, 5759, '\P{Is_Blk=_ Ogham}', ""); +Expect(0, 5759, '\P{^Is_Blk=_ Ogham}', ""); +Error('\p{Block= Vai:=}'); +Error('\P{Block= Vai:=}'); +Expect(1, 42559, '\p{Block: vai}', ""); +Expect(0, 42559, '\p{^Block: vai}', ""); +Expect(0, 42559, '\P{Block: vai}', ""); +Expect(1, 42559, '\P{^Block: vai}', ""); +Expect(0, 42239, '\p{Block: vai}', ""); +Expect(1, 42239, '\p{^Block: vai}', ""); +Expect(1, 42239, '\P{Block: vai}', ""); +Expect(0, 42239, '\P{^Block: vai}', ""); +Expect(1, 42559, '\p{Block= VAI}', ""); +Expect(0, 42559, '\p{^Block= VAI}', ""); +Expect(0, 42559, '\P{Block= VAI}', ""); +Expect(1, 42559, '\P{^Block= VAI}', ""); +Expect(0, 42239, '\p{Block= VAI}', ""); +Expect(1, 42239, '\p{^Block= VAI}', ""); +Expect(1, 42239, '\P{Block= VAI}', ""); +Expect(0, 42239, '\P{^Block= VAI}', ""); +Error('\p{Blk=_vai/a/}'); +Error('\P{Blk=_vai/a/}'); +Expect(1, 42559, '\p{Blk=vai}', ""); +Expect(0, 42559, '\p{^Blk=vai}', ""); +Expect(0, 42559, '\P{Blk=vai}', ""); +Expect(1, 42559, '\P{^Blk=vai}', ""); +Expect(0, 42239, '\p{Blk=vai}', ""); +Expect(1, 42239, '\p{^Blk=vai}', ""); +Expect(1, 42239, '\P{Blk=vai}', ""); +Expect(0, 42239, '\P{^Blk=vai}', ""); +Expect(1, 42559, '\p{Blk= _vai}', ""); +Expect(0, 42559, '\p{^Blk= _vai}', ""); +Expect(0, 42559, '\P{Blk= _vai}', ""); +Expect(1, 42559, '\P{^Blk= _vai}', ""); +Expect(0, 42239, '\p{Blk= _vai}', ""); +Expect(1, 42239, '\p{^Blk= _vai}', ""); +Expect(1, 42239, '\P{Blk= _vai}', ""); +Expect(0, 42239, '\P{^Blk= _vai}', ""); +Error('\p{Is_Block: __VAI/a/}'); +Error('\P{Is_Block: __VAI/a/}'); +Expect(1, 42559, '\p{Is_Block=vai}', ""); +Expect(0, 42559, '\p{^Is_Block=vai}', ""); +Expect(0, 42559, '\P{Is_Block=vai}', ""); +Expect(1, 42559, '\P{^Is_Block=vai}', ""); +Expect(0, 42239, '\p{Is_Block=vai}', ""); +Expect(1, 42239, '\p{^Is_Block=vai}', ""); +Expect(1, 42239, '\P{Is_Block=vai}', ""); +Expect(0, 42239, '\P{^Is_Block=vai}', ""); +Expect(1, 42559, '\p{Is_Block=_ VAI}', ""); +Expect(0, 42559, '\p{^Is_Block=_ VAI}', ""); +Expect(0, 42559, '\P{Is_Block=_ VAI}', ""); +Expect(1, 42559, '\P{^Is_Block=_ VAI}', ""); +Expect(0, 42239, '\p{Is_Block=_ VAI}', ""); +Expect(1, 42239, '\p{^Is_Block=_ VAI}', ""); +Expect(1, 42239, '\P{Is_Block=_ VAI}', ""); +Expect(0, 42239, '\P{^Is_Block=_ VAI}', ""); +Error('\p{Is_Blk=-:=Vai}'); +Error('\P{Is_Blk=-:=Vai}'); +Expect(1, 42559, '\p{Is_Blk=vai}', ""); +Expect(0, 42559, '\p{^Is_Blk=vai}', ""); +Expect(0, 42559, '\P{Is_Blk=vai}', ""); +Expect(1, 42559, '\P{^Is_Blk=vai}', ""); +Expect(0, 42239, '\p{Is_Blk=vai}', ""); +Expect(1, 42239, '\p{^Is_Blk=vai}', ""); +Expect(1, 42239, '\P{Is_Blk=vai}', ""); +Expect(0, 42239, '\P{^Is_Blk=vai}', ""); +Expect(1, 42559, '\p{Is_Blk= _Vai}', ""); +Expect(0, 42559, '\p{^Is_Blk= _Vai}', ""); +Expect(0, 42559, '\P{Is_Blk= _Vai}', ""); +Expect(1, 42559, '\P{^Is_Blk= _Vai}', ""); +Expect(0, 42239, '\p{Is_Blk= _Vai}', ""); +Expect(1, 42239, '\p{^Is_Blk= _Vai}', ""); +Expect(1, 42239, '\P{Is_Blk= _Vai}', ""); +Expect(0, 42239, '\P{^Is_Blk= _Vai}', ""); +Error('\p{Block=__Generalpunctuation/a/}'); +Error('\P{Block=__Generalpunctuation/a/}'); +Expect(1, 8303, '\p{Block=generalpunctuation}', ""); +Expect(0, 8303, '\p{^Block=generalpunctuation}', ""); +Expect(0, 8303, '\P{Block=generalpunctuation}', ""); +Expect(1, 8303, '\P{^Block=generalpunctuation}', ""); +Expect(0, 8191, '\p{Block=generalpunctuation}', ""); +Expect(1, 8191, '\p{^Block=generalpunctuation}', ""); +Expect(1, 8191, '\P{Block=generalpunctuation}', ""); +Expect(0, 8191, '\P{^Block=generalpunctuation}', ""); +Expect(1, 8303, '\p{Block: -general punctuation}', ""); +Expect(0, 8303, '\p{^Block: -general punctuation}', ""); +Expect(0, 8303, '\P{Block: -general punctuation}', ""); +Expect(1, 8303, '\P{^Block: -general punctuation}', ""); +Expect(0, 8191, '\p{Block: -general punctuation}', ""); +Expect(1, 8191, '\p{^Block: -general punctuation}', ""); +Expect(1, 8191, '\P{Block: -general punctuation}', ""); +Expect(0, 8191, '\P{^Block: -general punctuation}', ""); +Error('\p{Blk=:=GENERAL PUNCTUATION}'); +Error('\P{Blk=:=GENERAL PUNCTUATION}'); +Expect(1, 8303, '\p{Blk=generalpunctuation}', ""); +Expect(0, 8303, '\p{^Blk=generalpunctuation}', ""); +Expect(0, 8303, '\P{Blk=generalpunctuation}', ""); +Expect(1, 8303, '\P{^Blk=generalpunctuation}', ""); +Expect(0, 8191, '\p{Blk=generalpunctuation}', ""); +Expect(1, 8191, '\p{^Blk=generalpunctuation}', ""); +Expect(1, 8191, '\P{Blk=generalpunctuation}', ""); +Expect(0, 8191, '\P{^Blk=generalpunctuation}', ""); +Expect(1, 8303, '\p{Blk: - generalpunctuation}', ""); +Expect(0, 8303, '\p{^Blk: - generalpunctuation}', ""); +Expect(0, 8303, '\P{Blk: - generalpunctuation}', ""); +Expect(1, 8303, '\P{^Blk: - generalpunctuation}', ""); +Expect(0, 8191, '\p{Blk: - generalpunctuation}', ""); +Expect(1, 8191, '\p{^Blk: - generalpunctuation}', ""); +Expect(1, 8191, '\P{Blk: - generalpunctuation}', ""); +Expect(0, 8191, '\P{^Blk: - generalpunctuation}', ""); +Error('\p{Is_Block= :=general punctuation}'); +Error('\P{Is_Block= :=general punctuation}'); +Expect(1, 8303, '\p{Is_Block=generalpunctuation}', ""); +Expect(0, 8303, '\p{^Is_Block=generalpunctuation}', ""); +Expect(0, 8303, '\P{Is_Block=generalpunctuation}', ""); +Expect(1, 8303, '\P{^Is_Block=generalpunctuation}', ""); +Expect(0, 8191, '\p{Is_Block=generalpunctuation}', ""); +Expect(1, 8191, '\p{^Is_Block=generalpunctuation}', ""); +Expect(1, 8191, '\P{Is_Block=generalpunctuation}', ""); +Expect(0, 8191, '\P{^Is_Block=generalpunctuation}', ""); +Expect(1, 8303, '\p{Is_Block=_ GENERALpunctuation}', ""); +Expect(0, 8303, '\p{^Is_Block=_ GENERALpunctuation}', ""); +Expect(0, 8303, '\P{Is_Block=_ GENERALpunctuation}', ""); +Expect(1, 8303, '\P{^Is_Block=_ GENERALpunctuation}', ""); +Expect(0, 8191, '\p{Is_Block=_ GENERALpunctuation}', ""); +Expect(1, 8191, '\p{^Is_Block=_ GENERALpunctuation}', ""); +Expect(1, 8191, '\P{Is_Block=_ GENERALpunctuation}', ""); +Expect(0, 8191, '\P{^Is_Block=_ GENERALpunctuation}', ""); +Error('\p{Is_Blk=/a/- general PUNCTUATION}'); +Error('\P{Is_Blk=/a/- general PUNCTUATION}'); +Expect(1, 8303, '\p{Is_Blk=generalpunctuation}', ""); +Expect(0, 8303, '\p{^Is_Blk=generalpunctuation}', ""); +Expect(0, 8303, '\P{Is_Blk=generalpunctuation}', ""); +Expect(1, 8303, '\P{^Is_Blk=generalpunctuation}', ""); +Expect(0, 8191, '\p{Is_Blk=generalpunctuation}', ""); +Expect(1, 8191, '\p{^Is_Blk=generalpunctuation}', ""); +Expect(1, 8191, '\P{Is_Blk=generalpunctuation}', ""); +Expect(0, 8191, '\P{^Is_Blk=generalpunctuation}', ""); +Expect(1, 8303, '\p{Is_Blk= -generalPunctuation}', ""); +Expect(0, 8303, '\p{^Is_Blk= -generalPunctuation}', ""); +Expect(0, 8303, '\P{Is_Blk= -generalPunctuation}', ""); +Expect(1, 8303, '\P{^Is_Blk= -generalPunctuation}', ""); +Expect(0, 8191, '\p{Is_Blk= -generalPunctuation}', ""); +Expect(1, 8191, '\p{^Is_Blk= -generalPunctuation}', ""); +Expect(1, 8191, '\P{Is_Blk= -generalPunctuation}', ""); +Expect(0, 8191, '\P{^Is_Blk= -generalPunctuation}', ""); +Error('\p{Block= _rejang/a/}'); +Error('\P{Block= _rejang/a/}'); +Expect(1, 43359, '\p{Block: rejang}', ""); +Expect(0, 43359, '\p{^Block: rejang}', ""); +Expect(0, 43359, '\P{Block: rejang}', ""); +Expect(1, 43359, '\P{^Block: rejang}', ""); +Expect(0, 43311, '\p{Block: rejang}', ""); +Expect(1, 43311, '\p{^Block: rejang}', ""); +Expect(1, 43311, '\P{Block: rejang}', ""); +Expect(0, 43311, '\P{^Block: rejang}', ""); +Expect(1, 43359, '\p{Block= Rejang}', ""); +Expect(0, 43359, '\p{^Block= Rejang}', ""); +Expect(0, 43359, '\P{Block= Rejang}', ""); +Expect(1, 43359, '\P{^Block= Rejang}', ""); +Expect(0, 43311, '\p{Block= Rejang}', ""); +Expect(1, 43311, '\p{^Block= Rejang}', ""); +Expect(1, 43311, '\P{Block= Rejang}', ""); +Expect(0, 43311, '\P{^Block= Rejang}', ""); +Error('\p{Blk=-/a/Rejang}'); +Error('\P{Blk=-/a/Rejang}'); +Expect(1, 43359, '\p{Blk=rejang}', ""); +Expect(0, 43359, '\p{^Blk=rejang}', ""); +Expect(0, 43359, '\P{Blk=rejang}', ""); +Expect(1, 43359, '\P{^Blk=rejang}', ""); +Expect(0, 43311, '\p{Blk=rejang}', ""); +Expect(1, 43311, '\p{^Blk=rejang}', ""); +Expect(1, 43311, '\P{Blk=rejang}', ""); +Expect(0, 43311, '\P{^Blk=rejang}', ""); +Expect(1, 43359, '\p{Blk= rejang}', ""); +Expect(0, 43359, '\p{^Blk= rejang}', ""); +Expect(0, 43359, '\P{Blk= rejang}', ""); +Expect(1, 43359, '\P{^Blk= rejang}', ""); +Expect(0, 43311, '\p{Blk= rejang}', ""); +Expect(1, 43311, '\p{^Blk= rejang}', ""); +Expect(1, 43311, '\P{Blk= rejang}', ""); +Expect(0, 43311, '\P{^Blk= rejang}', ""); +Error('\p{Is_Block= :=Rejang}'); +Error('\P{Is_Block= :=Rejang}'); +Expect(1, 43359, '\p{Is_Block=rejang}', ""); +Expect(0, 43359, '\p{^Is_Block=rejang}', ""); +Expect(0, 43359, '\P{Is_Block=rejang}', ""); +Expect(1, 43359, '\P{^Is_Block=rejang}', ""); +Expect(0, 43311, '\p{Is_Block=rejang}', ""); +Expect(1, 43311, '\p{^Is_Block=rejang}', ""); +Expect(1, 43311, '\P{Is_Block=rejang}', ""); +Expect(0, 43311, '\P{^Is_Block=rejang}', ""); +Expect(1, 43359, '\p{Is_Block= _Rejang}', ""); +Expect(0, 43359, '\p{^Is_Block= _Rejang}', ""); +Expect(0, 43359, '\P{Is_Block= _Rejang}', ""); +Expect(1, 43359, '\P{^Is_Block= _Rejang}', ""); +Expect(0, 43311, '\p{Is_Block= _Rejang}', ""); +Expect(1, 43311, '\p{^Is_Block= _Rejang}', ""); +Expect(1, 43311, '\P{Is_Block= _Rejang}', ""); +Expect(0, 43311, '\P{^Is_Block= _Rejang}', ""); +Error('\p{Is_Blk=--Rejang:=}'); +Error('\P{Is_Blk=--Rejang:=}'); +Expect(1, 43359, '\p{Is_Blk=rejang}', ""); +Expect(0, 43359, '\p{^Is_Blk=rejang}', ""); +Expect(0, 43359, '\P{Is_Blk=rejang}', ""); +Expect(1, 43359, '\P{^Is_Blk=rejang}', ""); +Expect(0, 43311, '\p{Is_Blk=rejang}', ""); +Expect(1, 43311, '\p{^Is_Blk=rejang}', ""); +Expect(1, 43311, '\P{Is_Blk=rejang}', ""); +Expect(0, 43311, '\P{^Is_Blk=rejang}', ""); +Expect(1, 43359, '\p{Is_Blk= REJANG}', ""); +Expect(0, 43359, '\p{^Is_Blk= REJANG}', ""); +Expect(0, 43359, '\P{Is_Blk= REJANG}', ""); +Expect(1, 43359, '\P{^Is_Blk= REJANG}', ""); +Expect(0, 43311, '\p{Is_Blk= REJANG}', ""); +Expect(1, 43311, '\p{^Is_Blk= REJANG}', ""); +Expect(1, 43311, '\P{Is_Blk= REJANG}', ""); +Expect(0, 43311, '\P{^Is_Blk= REJANG}', ""); +Error('\p{Block=-_Ol:=Chiki}'); +Error('\P{Block=-_Ol:=Chiki}'); +Expect(1, 7295, '\p{Block=olchiki}', ""); +Expect(0, 7295, '\p{^Block=olchiki}', ""); +Expect(0, 7295, '\P{Block=olchiki}', ""); +Expect(1, 7295, '\P{^Block=olchiki}', ""); +Expect(0, 7247, '\p{Block=olchiki}', ""); +Expect(1, 7247, '\p{^Block=olchiki}', ""); +Expect(1, 7247, '\P{Block=olchiki}', ""); +Expect(0, 7247, '\P{^Block=olchiki}', ""); +Expect(1, 7295, '\p{Block=Ol Chiki}', ""); +Expect(0, 7295, '\p{^Block=Ol Chiki}', ""); +Expect(0, 7295, '\P{Block=Ol Chiki}', ""); +Expect(1, 7295, '\P{^Block=Ol Chiki}', ""); +Expect(0, 7247, '\p{Block=Ol Chiki}', ""); +Expect(1, 7247, '\p{^Block=Ol Chiki}', ""); +Expect(1, 7247, '\P{Block=Ol Chiki}', ""); +Expect(0, 7247, '\P{^Block=Ol Chiki}', ""); +Error('\p{Blk=/a/_-Ol chiki}'); +Error('\P{Blk=/a/_-Ol chiki}'); +Expect(1, 7295, '\p{Blk=olchiki}', ""); +Expect(0, 7295, '\p{^Blk=olchiki}', ""); +Expect(0, 7295, '\P{Blk=olchiki}', ""); +Expect(1, 7295, '\P{^Blk=olchiki}', ""); +Expect(0, 7247, '\p{Blk=olchiki}', ""); +Expect(1, 7247, '\p{^Blk=olchiki}', ""); +Expect(1, 7247, '\P{Blk=olchiki}', ""); +Expect(0, 7247, '\P{^Blk=olchiki}', ""); +Expect(1, 7295, '\p{Blk= Ol chiki}', ""); +Expect(0, 7295, '\p{^Blk= Ol chiki}', ""); +Expect(0, 7295, '\P{Blk= Ol chiki}', ""); +Expect(1, 7295, '\P{^Blk= Ol chiki}', ""); +Expect(0, 7247, '\p{Blk= Ol chiki}', ""); +Expect(1, 7247, '\p{^Blk= Ol chiki}', ""); +Expect(1, 7247, '\P{Blk= Ol chiki}', ""); +Expect(0, 7247, '\P{^Blk= Ol chiki}', ""); +Error('\p{Is_Block= Ol:=CHIKI}'); +Error('\P{Is_Block= Ol:=CHIKI}'); +Expect(1, 7295, '\p{Is_Block=olchiki}', ""); +Expect(0, 7295, '\p{^Is_Block=olchiki}', ""); +Expect(0, 7295, '\P{Is_Block=olchiki}', ""); +Expect(1, 7295, '\P{^Is_Block=olchiki}', ""); +Expect(0, 7247, '\p{Is_Block=olchiki}', ""); +Expect(1, 7247, '\p{^Is_Block=olchiki}', ""); +Expect(1, 7247, '\P{Is_Block=olchiki}', ""); +Expect(0, 7247, '\P{^Is_Block=olchiki}', ""); +Expect(1, 7295, '\p{Is_Block= Ol chiki}', ""); +Expect(0, 7295, '\p{^Is_Block= Ol chiki}', ""); +Expect(0, 7295, '\P{Is_Block= Ol chiki}', ""); +Expect(1, 7295, '\P{^Is_Block= Ol chiki}', ""); +Expect(0, 7247, '\p{Is_Block= Ol chiki}', ""); +Expect(1, 7247, '\p{^Is_Block= Ol chiki}', ""); +Expect(1, 7247, '\P{Is_Block= Ol chiki}', ""); +Expect(0, 7247, '\P{^Is_Block= Ol chiki}', ""); +Error('\p{Is_Blk= _Ol:=Chiki}'); +Error('\P{Is_Blk= _Ol:=Chiki}'); +Expect(1, 7295, '\p{Is_Blk=olchiki}', ""); +Expect(0, 7295, '\p{^Is_Blk=olchiki}', ""); +Expect(0, 7295, '\P{Is_Blk=olchiki}', ""); +Expect(1, 7295, '\P{^Is_Blk=olchiki}', ""); +Expect(0, 7247, '\p{Is_Blk=olchiki}', ""); +Expect(1, 7247, '\p{^Is_Blk=olchiki}', ""); +Expect(1, 7247, '\P{Is_Blk=olchiki}', ""); +Expect(0, 7247, '\P{^Is_Blk=olchiki}', ""); +Expect(1, 7295, '\p{Is_Blk= -olChiki}', ""); +Expect(0, 7295, '\p{^Is_Blk= -olChiki}', ""); +Expect(0, 7295, '\P{Is_Blk= -olChiki}', ""); +Expect(1, 7295, '\P{^Is_Blk= -olChiki}', ""); +Expect(0, 7247, '\p{Is_Blk= -olChiki}', ""); +Expect(1, 7247, '\p{^Is_Blk= -olChiki}', ""); +Expect(1, 7247, '\P{Is_Blk= -olChiki}', ""); +Expect(0, 7247, '\P{^Is_Blk= -olChiki}', ""); +Error('\p{Block: :=KANBUN}'); +Error('\P{Block: :=KANBUN}'); +Expect(1, 12703, '\p{Block=kanbun}', ""); +Expect(0, 12703, '\p{^Block=kanbun}', ""); +Expect(0, 12703, '\P{Block=kanbun}', ""); +Expect(1, 12703, '\P{^Block=kanbun}', ""); +Expect(0, 12687, '\p{Block=kanbun}', ""); +Expect(1, 12687, '\p{^Block=kanbun}', ""); +Expect(1, 12687, '\P{Block=kanbun}', ""); +Expect(0, 12687, '\P{^Block=kanbun}', ""); +Expect(1, 12703, '\p{Block=- KANBUN}', ""); +Expect(0, 12703, '\p{^Block=- KANBUN}', ""); +Expect(0, 12703, '\P{Block=- KANBUN}', ""); +Expect(1, 12703, '\P{^Block=- KANBUN}', ""); +Expect(0, 12687, '\p{Block=- KANBUN}', ""); +Expect(1, 12687, '\p{^Block=- KANBUN}', ""); +Expect(1, 12687, '\P{Block=- KANBUN}', ""); +Expect(0, 12687, '\P{^Block=- KANBUN}', ""); +Error('\p{Blk=/a/_kanbun}'); +Error('\P{Blk=/a/_kanbun}'); +Expect(1, 12703, '\p{Blk=kanbun}', ""); +Expect(0, 12703, '\p{^Blk=kanbun}', ""); +Expect(0, 12703, '\P{Blk=kanbun}', ""); +Expect(1, 12703, '\P{^Blk=kanbun}', ""); +Expect(0, 12687, '\p{Blk=kanbun}', ""); +Expect(1, 12687, '\p{^Blk=kanbun}', ""); +Expect(1, 12687, '\P{Blk=kanbun}', ""); +Expect(0, 12687, '\P{^Blk=kanbun}', ""); +Expect(1, 12703, '\p{Blk=_-Kanbun}', ""); +Expect(0, 12703, '\p{^Blk=_-Kanbun}', ""); +Expect(0, 12703, '\P{Blk=_-Kanbun}', ""); +Expect(1, 12703, '\P{^Blk=_-Kanbun}', ""); +Expect(0, 12687, '\p{Blk=_-Kanbun}', ""); +Expect(1, 12687, '\p{^Blk=_-Kanbun}', ""); +Expect(1, 12687, '\P{Blk=_-Kanbun}', ""); +Expect(0, 12687, '\P{^Blk=_-Kanbun}', ""); +Error('\p{Is_Block:_:=KANBUN}'); +Error('\P{Is_Block:_:=KANBUN}'); +Expect(1, 12703, '\p{Is_Block=kanbun}', ""); +Expect(0, 12703, '\p{^Is_Block=kanbun}', ""); +Expect(0, 12703, '\P{Is_Block=kanbun}', ""); +Expect(1, 12703, '\P{^Is_Block=kanbun}', ""); +Expect(0, 12687, '\p{Is_Block=kanbun}', ""); +Expect(1, 12687, '\p{^Is_Block=kanbun}', ""); +Expect(1, 12687, '\P{Is_Block=kanbun}', ""); +Expect(0, 12687, '\P{^Is_Block=kanbun}', ""); +Expect(1, 12703, '\p{Is_Block=__Kanbun}', ""); +Expect(0, 12703, '\p{^Is_Block=__Kanbun}', ""); +Expect(0, 12703, '\P{Is_Block=__Kanbun}', ""); +Expect(1, 12703, '\P{^Is_Block=__Kanbun}', ""); +Expect(0, 12687, '\p{Is_Block=__Kanbun}', ""); +Expect(1, 12687, '\p{^Is_Block=__Kanbun}', ""); +Expect(1, 12687, '\P{Is_Block=__Kanbun}', ""); +Expect(0, 12687, '\P{^Is_Block=__Kanbun}', ""); +Error('\p{Is_Blk=-kanbun:=}'); +Error('\P{Is_Blk=-kanbun:=}'); +Expect(1, 12703, '\p{Is_Blk=kanbun}', ""); +Expect(0, 12703, '\p{^Is_Blk=kanbun}', ""); +Expect(0, 12703, '\P{Is_Blk=kanbun}', ""); +Expect(1, 12703, '\P{^Is_Blk=kanbun}', ""); +Expect(0, 12687, '\p{Is_Blk=kanbun}', ""); +Expect(1, 12687, '\p{^Is_Blk=kanbun}', ""); +Expect(1, 12687, '\P{Is_Blk=kanbun}', ""); +Expect(0, 12687, '\P{^Is_Blk=kanbun}', ""); +Expect(1, 12703, '\p{Is_Blk= kanbun}', ""); +Expect(0, 12703, '\p{^Is_Blk= kanbun}', ""); +Expect(0, 12703, '\P{Is_Blk= kanbun}', ""); +Expect(1, 12703, '\P{^Is_Blk= kanbun}', ""); +Expect(0, 12687, '\p{Is_Blk= kanbun}', ""); +Expect(1, 12687, '\p{^Is_Blk= kanbun}', ""); +Expect(1, 12687, '\P{Is_Blk= kanbun}', ""); +Expect(0, 12687, '\P{^Is_Blk= kanbun}', ""); +Error('\p{Block=:=Cyrillic_Extended-a}'); +Error('\P{Block=:=Cyrillic_Extended-a}'); +Expect(1, 11775, '\p{Block=cyrillicextendeda}', ""); +Expect(0, 11775, '\p{^Block=cyrillicextendeda}', ""); +Expect(0, 11775, '\P{Block=cyrillicextendeda}', ""); +Expect(1, 11775, '\P{^Block=cyrillicextendeda}', ""); +Expect(0, 11743, '\p{Block=cyrillicextendeda}', ""); +Expect(1, 11743, '\p{^Block=cyrillicextendeda}', ""); +Expect(1, 11743, '\P{Block=cyrillicextendeda}', ""); +Expect(0, 11743, '\P{^Block=cyrillicextendeda}', ""); +Expect(1, 11775, '\p{Block=- cyrillicEXTENDED_A}', ""); +Expect(0, 11775, '\p{^Block=- cyrillicEXTENDED_A}', ""); +Expect(0, 11775, '\P{Block=- cyrillicEXTENDED_A}', ""); +Expect(1, 11775, '\P{^Block=- cyrillicEXTENDED_A}', ""); +Expect(0, 11743, '\p{Block=- cyrillicEXTENDED_A}', ""); +Expect(1, 11743, '\p{^Block=- cyrillicEXTENDED_A}', ""); +Expect(1, 11743, '\P{Block=- cyrillicEXTENDED_A}', ""); +Expect(0, 11743, '\P{^Block=- cyrillicEXTENDED_A}', ""); +Error('\p{Blk:- CYRILLIC/a/ExtendedA}'); +Error('\P{Blk:- CYRILLIC/a/ExtendedA}'); +Expect(1, 11775, '\p{Blk=cyrillicextendeda}', ""); +Expect(0, 11775, '\p{^Blk=cyrillicextendeda}', ""); +Expect(0, 11775, '\P{Blk=cyrillicextendeda}', ""); +Expect(1, 11775, '\P{^Blk=cyrillicextendeda}', ""); +Expect(0, 11743, '\p{Blk=cyrillicextendeda}', ""); +Expect(1, 11743, '\p{^Blk=cyrillicextendeda}', ""); +Expect(1, 11743, '\P{Blk=cyrillicextendeda}', ""); +Expect(0, 11743, '\P{^Blk=cyrillicextendeda}', ""); +Expect(1, 11775, '\p{Blk=_CYRILLIC-EXTENDED_A}', ""); +Expect(0, 11775, '\p{^Blk=_CYRILLIC-EXTENDED_A}', ""); +Expect(0, 11775, '\P{Blk=_CYRILLIC-EXTENDED_A}', ""); +Expect(1, 11775, '\P{^Blk=_CYRILLIC-EXTENDED_A}', ""); +Expect(0, 11743, '\p{Blk=_CYRILLIC-EXTENDED_A}', ""); +Expect(1, 11743, '\p{^Blk=_CYRILLIC-EXTENDED_A}', ""); +Expect(1, 11743, '\P{Blk=_CYRILLIC-EXTENDED_A}', ""); +Expect(0, 11743, '\P{^Blk=_CYRILLIC-EXTENDED_A}', ""); +Error('\p{Is_Block: cyrillic/a/ExtendedA}'); +Error('\P{Is_Block: cyrillic/a/ExtendedA}'); +Expect(1, 11775, '\p{Is_Block=cyrillicextendeda}', ""); +Expect(0, 11775, '\p{^Is_Block=cyrillicextendeda}', ""); +Expect(0, 11775, '\P{Is_Block=cyrillicextendeda}', ""); +Expect(1, 11775, '\P{^Is_Block=cyrillicextendeda}', ""); +Expect(0, 11743, '\p{Is_Block=cyrillicextendeda}', ""); +Expect(1, 11743, '\p{^Is_Block=cyrillicextendeda}', ""); +Expect(1, 11743, '\P{Is_Block=cyrillicextendeda}', ""); +Expect(0, 11743, '\P{^Is_Block=cyrillicextendeda}', ""); +Expect(1, 11775, '\p{Is_Block=- Cyrillic extended-A}', ""); +Expect(0, 11775, '\p{^Is_Block=- Cyrillic extended-A}', ""); +Expect(0, 11775, '\P{Is_Block=- Cyrillic extended-A}', ""); +Expect(1, 11775, '\P{^Is_Block=- Cyrillic extended-A}', ""); +Expect(0, 11743, '\p{Is_Block=- Cyrillic extended-A}', ""); +Expect(1, 11743, '\p{^Is_Block=- Cyrillic extended-A}', ""); +Expect(1, 11743, '\P{Is_Block=- Cyrillic extended-A}', ""); +Expect(0, 11743, '\P{^Is_Block=- Cyrillic extended-A}', ""); +Error('\p{Is_Blk=:=--Cyrillic Extended a}'); +Error('\P{Is_Blk=:=--Cyrillic Extended a}'); +Expect(1, 11775, '\p{Is_Blk=cyrillicextendeda}', ""); +Expect(0, 11775, '\p{^Is_Blk=cyrillicextendeda}', ""); +Expect(0, 11775, '\P{Is_Blk=cyrillicextendeda}', ""); +Expect(1, 11775, '\P{^Is_Blk=cyrillicextendeda}', ""); +Expect(0, 11743, '\p{Is_Blk=cyrillicextendeda}', ""); +Expect(1, 11743, '\p{^Is_Blk=cyrillicextendeda}', ""); +Expect(1, 11743, '\P{Is_Blk=cyrillicextendeda}', ""); +Expect(0, 11743, '\P{^Is_Blk=cyrillicextendeda}', ""); +Expect(1, 11775, '\p{Is_Blk= CYRILLIC-Extended_a}', ""); +Expect(0, 11775, '\p{^Is_Blk= CYRILLIC-Extended_a}', ""); +Expect(0, 11775, '\P{Is_Blk= CYRILLIC-Extended_a}', ""); +Expect(1, 11775, '\P{^Is_Blk= CYRILLIC-Extended_a}', ""); +Expect(0, 11743, '\p{Is_Blk= CYRILLIC-Extended_a}', ""); +Expect(1, 11743, '\p{^Is_Blk= CYRILLIC-Extended_a}', ""); +Expect(1, 11743, '\P{Is_Blk= CYRILLIC-Extended_a}', ""); +Expect(0, 11743, '\P{^Is_Blk= CYRILLIC-Extended_a}', ""); +Error('\p{Block= Hebrew/a/}'); +Error('\P{Block= Hebrew/a/}'); +Expect(1, 1535, '\p{Block=hebrew}', ""); +Expect(0, 1535, '\p{^Block=hebrew}', ""); +Expect(0, 1535, '\P{Block=hebrew}', ""); +Expect(1, 1535, '\P{^Block=hebrew}', ""); +Expect(0, 1423, '\p{Block=hebrew}', ""); +Expect(1, 1423, '\p{^Block=hebrew}', ""); +Expect(1, 1423, '\P{Block=hebrew}', ""); +Expect(0, 1423, '\P{^Block=hebrew}', ""); +Error('\p{Blk=:= -HEBREW}'); +Error('\P{Blk=:= -HEBREW}'); +Expect(1, 1535, '\p{Blk=hebrew}', ""); +Expect(0, 1535, '\p{^Blk=hebrew}', ""); +Expect(0, 1535, '\P{Blk=hebrew}', ""); +Expect(1, 1535, '\P{^Blk=hebrew}', ""); +Expect(0, 1423, '\p{Blk=hebrew}', ""); +Expect(1, 1423, '\p{^Blk=hebrew}', ""); +Expect(1, 1423, '\P{Blk=hebrew}', ""); +Expect(0, 1423, '\P{^Blk=hebrew}', ""); +Expect(1, 1535, '\p{Blk: -_Hebrew}', ""); +Expect(0, 1535, '\p{^Blk: -_Hebrew}', ""); +Expect(0, 1535, '\P{Blk: -_Hebrew}', ""); +Expect(1, 1535, '\P{^Blk: -_Hebrew}', ""); +Expect(0, 1423, '\p{Blk: -_Hebrew}', ""); +Expect(1, 1423, '\p{^Blk: -_Hebrew}', ""); +Expect(1, 1423, '\P{Blk: -_Hebrew}', ""); +Expect(0, 1423, '\P{^Blk: -_Hebrew}', ""); +Error('\p{Is_Block=:= Hebrew}'); +Error('\P{Is_Block=:= Hebrew}'); +Expect(1, 1535, '\p{Is_Block=hebrew}', ""); +Expect(0, 1535, '\p{^Is_Block=hebrew}', ""); +Expect(0, 1535, '\P{Is_Block=hebrew}', ""); +Expect(1, 1535, '\P{^Is_Block=hebrew}', ""); +Expect(0, 1423, '\p{Is_Block=hebrew}', ""); +Expect(1, 1423, '\p{^Is_Block=hebrew}', ""); +Expect(1, 1423, '\P{Is_Block=hebrew}', ""); +Expect(0, 1423, '\P{^Is_Block=hebrew}', ""); +Expect(1, 1535, '\p{Is_Block=-Hebrew}', ""); +Expect(0, 1535, '\p{^Is_Block=-Hebrew}', ""); +Expect(0, 1535, '\P{Is_Block=-Hebrew}', ""); +Expect(1, 1535, '\P{^Is_Block=-Hebrew}', ""); +Expect(0, 1423, '\p{Is_Block=-Hebrew}', ""); +Expect(1, 1423, '\p{^Is_Block=-Hebrew}', ""); +Expect(1, 1423, '\P{Is_Block=-Hebrew}', ""); +Expect(0, 1423, '\P{^Is_Block=-Hebrew}', ""); +Error('\p{Is_Blk: _/a/HEBREW}'); +Error('\P{Is_Blk: _/a/HEBREW}'); +Expect(1, 1535, '\p{Is_Blk=hebrew}', ""); +Expect(0, 1535, '\p{^Is_Blk=hebrew}', ""); +Expect(0, 1535, '\P{Is_Blk=hebrew}', ""); +Expect(1, 1535, '\P{^Is_Blk=hebrew}', ""); +Expect(0, 1423, '\p{Is_Blk=hebrew}', ""); +Expect(1, 1423, '\p{^Is_Blk=hebrew}', ""); +Expect(1, 1423, '\P{Is_Blk=hebrew}', ""); +Expect(0, 1423, '\P{^Is_Blk=hebrew}', ""); +Expect(1, 1535, '\p{Is_Blk= _Hebrew}', ""); +Expect(0, 1535, '\p{^Is_Blk= _Hebrew}', ""); +Expect(0, 1535, '\P{Is_Blk= _Hebrew}', ""); +Expect(1, 1535, '\P{^Is_Blk= _Hebrew}', ""); +Expect(0, 1423, '\p{Is_Blk= _Hebrew}', ""); +Expect(1, 1423, '\p{^Is_Blk= _Hebrew}', ""); +Expect(1, 1423, '\P{Is_Blk= _Hebrew}', ""); +Expect(0, 1423, '\P{^Is_Blk= _Hebrew}', ""); +Error('\p{Block= /a/cyrillic}'); +Error('\P{Block= /a/cyrillic}'); +Expect(1, 1279, '\p{Block=cyrillic}', ""); +Expect(0, 1279, '\p{^Block=cyrillic}', ""); +Expect(0, 1279, '\P{Block=cyrillic}', ""); +Expect(1, 1279, '\P{^Block=cyrillic}', ""); +Expect(0, 1023, '\p{Block=cyrillic}', ""); +Expect(1, 1023, '\p{^Block=cyrillic}', ""); +Expect(1, 1023, '\P{Block=cyrillic}', ""); +Expect(0, 1023, '\P{^Block=cyrillic}', ""); +Expect(1, 1279, '\p{Block=_Cyrillic}', ""); +Expect(0, 1279, '\p{^Block=_Cyrillic}', ""); +Expect(0, 1279, '\P{Block=_Cyrillic}', ""); +Expect(1, 1279, '\P{^Block=_Cyrillic}', ""); +Expect(0, 1023, '\p{Block=_Cyrillic}', ""); +Expect(1, 1023, '\p{^Block=_Cyrillic}', ""); +Expect(1, 1023, '\P{Block=_Cyrillic}', ""); +Expect(0, 1023, '\P{^Block=_Cyrillic}', ""); +Error('\p{Blk=/a/Cyrillic}'); +Error('\P{Blk=/a/Cyrillic}'); +Expect(1, 1279, '\p{Blk=cyrillic}', ""); +Expect(0, 1279, '\p{^Blk=cyrillic}', ""); +Expect(0, 1279, '\P{Blk=cyrillic}', ""); +Expect(1, 1279, '\P{^Blk=cyrillic}', ""); +Expect(0, 1023, '\p{Blk=cyrillic}', ""); +Expect(1, 1023, '\p{^Blk=cyrillic}', ""); +Expect(1, 1023, '\P{Blk=cyrillic}', ""); +Expect(0, 1023, '\P{^Blk=cyrillic}', ""); +Expect(1, 1279, '\p{Blk= CYRILLIC}', ""); +Expect(0, 1279, '\p{^Blk= CYRILLIC}', ""); +Expect(0, 1279, '\P{Blk= CYRILLIC}', ""); +Expect(1, 1279, '\P{^Blk= CYRILLIC}', ""); +Expect(0, 1023, '\p{Blk= CYRILLIC}', ""); +Expect(1, 1023, '\p{^Blk= CYRILLIC}', ""); +Expect(1, 1023, '\P{Blk= CYRILLIC}', ""); +Expect(0, 1023, '\P{^Blk= CYRILLIC}', ""); +Error('\p{Is_Block=:= Cyrillic}'); +Error('\P{Is_Block=:= Cyrillic}'); +Expect(1, 1279, '\p{Is_Block=cyrillic}', ""); +Expect(0, 1279, '\p{^Is_Block=cyrillic}', ""); +Expect(0, 1279, '\P{Is_Block=cyrillic}', ""); +Expect(1, 1279, '\P{^Is_Block=cyrillic}', ""); +Expect(0, 1023, '\p{Is_Block=cyrillic}', ""); +Expect(1, 1023, '\p{^Is_Block=cyrillic}', ""); +Expect(1, 1023, '\P{Is_Block=cyrillic}', ""); +Expect(0, 1023, '\P{^Is_Block=cyrillic}', ""); +Expect(1, 1279, '\p{Is_Block=_ Cyrillic}', ""); +Expect(0, 1279, '\p{^Is_Block=_ Cyrillic}', ""); +Expect(0, 1279, '\P{Is_Block=_ Cyrillic}', ""); +Expect(1, 1279, '\P{^Is_Block=_ Cyrillic}', ""); +Expect(0, 1023, '\p{Is_Block=_ Cyrillic}', ""); +Expect(1, 1023, '\p{^Is_Block=_ Cyrillic}', ""); +Expect(1, 1023, '\P{Is_Block=_ Cyrillic}', ""); +Expect(0, 1023, '\P{^Is_Block=_ Cyrillic}', ""); +Error('\p{Is_Blk=:= -Cyrillic}'); +Error('\P{Is_Blk=:= -Cyrillic}'); +Expect(1, 1279, '\p{Is_Blk=cyrillic}', ""); +Expect(0, 1279, '\p{^Is_Blk=cyrillic}', ""); +Expect(0, 1279, '\P{Is_Blk=cyrillic}', ""); +Expect(1, 1279, '\P{^Is_Blk=cyrillic}', ""); +Expect(0, 1023, '\p{Is_Blk=cyrillic}', ""); +Expect(1, 1023, '\p{^Is_Blk=cyrillic}', ""); +Expect(1, 1023, '\P{Is_Blk=cyrillic}', ""); +Expect(0, 1023, '\P{^Is_Blk=cyrillic}', ""); +Expect(1, 1279, '\p{Is_Blk=-_Cyrillic}', ""); +Expect(0, 1279, '\p{^Is_Blk=-_Cyrillic}', ""); +Expect(0, 1279, '\P{Is_Blk=-_Cyrillic}', ""); +Expect(1, 1279, '\P{^Is_Blk=-_Cyrillic}', ""); +Expect(0, 1023, '\p{Is_Blk=-_Cyrillic}', ""); +Expect(1, 1023, '\p{^Is_Blk=-_Cyrillic}', ""); +Expect(1, 1023, '\P{Is_Blk=-_Cyrillic}', ""); +Expect(0, 1023, '\P{^Is_Blk=-_Cyrillic}', ""); +Error('\p{Block: :=_latin-Extended a}'); +Error('\P{Block: :=_latin-Extended a}'); +Expect(1, 383, '\p{Block=latinextendeda}', ""); +Expect(0, 383, '\p{^Block=latinextendeda}', ""); +Expect(0, 383, '\P{Block=latinextendeda}', ""); +Expect(1, 383, '\P{^Block=latinextendeda}', ""); +Expect(0, 7, '\p{Block=latinextendeda}', ""); +Expect(1, 7, '\p{^Block=latinextendeda}', ""); +Expect(1, 7, '\P{Block=latinextendeda}', ""); +Expect(0, 7, '\P{^Block=latinextendeda}', ""); +Expect(1, 383, '\p{Block= Latin EXTENDED A}', ""); +Expect(0, 383, '\p{^Block= Latin EXTENDED A}', ""); +Expect(0, 383, '\P{Block= Latin EXTENDED A}', ""); +Expect(1, 383, '\P{^Block= Latin EXTENDED A}', ""); +Expect(0, 7, '\p{Block= Latin EXTENDED A}', ""); +Expect(1, 7, '\p{^Block= Latin EXTENDED A}', ""); +Expect(1, 7, '\P{Block= Latin EXTENDED A}', ""); +Expect(0, 7, '\P{^Block= Latin EXTENDED A}', ""); +Error('\p{Blk=_ LATIN/a/Extended-A}'); +Error('\P{Blk=_ LATIN/a/Extended-A}'); +Expect(1, 383, '\p{Blk=latinextendeda}', ""); +Expect(0, 383, '\p{^Blk=latinextendeda}', ""); +Expect(0, 383, '\P{Blk=latinextendeda}', ""); +Expect(1, 383, '\P{^Blk=latinextendeda}', ""); +Expect(0, 7, '\p{Blk=latinextendeda}', ""); +Expect(1, 7, '\p{^Blk=latinextendeda}', ""); +Expect(1, 7, '\P{Blk=latinextendeda}', ""); +Expect(0, 7, '\P{^Blk=latinextendeda}', ""); +Expect(1, 383, '\p{Blk= latin_extended A}', ""); +Expect(0, 383, '\p{^Blk= latin_extended A}', ""); +Expect(0, 383, '\P{Blk= latin_extended A}', ""); +Expect(1, 383, '\P{^Blk= latin_extended A}', ""); +Expect(0, 7, '\p{Blk= latin_extended A}', ""); +Expect(1, 7, '\p{^Blk= latin_extended A}', ""); +Expect(1, 7, '\P{Blk= latin_extended A}', ""); +Expect(0, 7, '\P{^Blk= latin_extended A}', ""); +Error('\p{Is_Block= -LATIN:=EXTENDEDA}'); +Error('\P{Is_Block= -LATIN:=EXTENDEDA}'); +Expect(1, 383, '\p{Is_Block=latinextendeda}', ""); +Expect(0, 383, '\p{^Is_Block=latinextendeda}', ""); +Expect(0, 383, '\P{Is_Block=latinextendeda}', ""); +Expect(1, 383, '\P{^Is_Block=latinextendeda}', ""); +Expect(0, 7, '\p{Is_Block=latinextendeda}', ""); +Expect(1, 7, '\p{^Is_Block=latinextendeda}', ""); +Expect(1, 7, '\P{Is_Block=latinextendeda}', ""); +Expect(0, 7, '\P{^Is_Block=latinextendeda}', ""); +Expect(1, 383, '\p{Is_Block: LATIN EXTENDED-A}', ""); +Expect(0, 383, '\p{^Is_Block: LATIN EXTENDED-A}', ""); +Expect(0, 383, '\P{Is_Block: LATIN EXTENDED-A}', ""); +Expect(1, 383, '\P{^Is_Block: LATIN EXTENDED-A}', ""); +Expect(0, 7, '\p{Is_Block: LATIN EXTENDED-A}', ""); +Expect(1, 7, '\p{^Is_Block: LATIN EXTENDED-A}', ""); +Expect(1, 7, '\P{Is_Block: LATIN EXTENDED-A}', ""); +Expect(0, 7, '\P{^Is_Block: LATIN EXTENDED-A}', ""); +Error('\p{Is_Blk=_ latin-Extended-A:=}'); +Error('\P{Is_Blk=_ latin-Extended-A:=}'); +Expect(1, 383, '\p{Is_Blk=latinextendeda}', ""); +Expect(0, 383, '\p{^Is_Blk=latinextendeda}', ""); +Expect(0, 383, '\P{Is_Blk=latinextendeda}', ""); +Expect(1, 383, '\P{^Is_Blk=latinextendeda}', ""); +Expect(0, 7, '\p{Is_Blk=latinextendeda}', ""); +Expect(1, 7, '\p{^Is_Blk=latinextendeda}', ""); +Expect(1, 7, '\P{Is_Blk=latinextendeda}', ""); +Expect(0, 7, '\P{^Is_Blk=latinextendeda}', ""); +Expect(1, 383, '\p{Is_Blk= Latin_Extended A}', ""); +Expect(0, 383, '\p{^Is_Blk= Latin_Extended A}', ""); +Expect(0, 383, '\P{Is_Blk= Latin_Extended A}', ""); +Expect(1, 383, '\P{^Is_Blk= Latin_Extended A}', ""); +Expect(0, 7, '\p{Is_Blk= Latin_Extended A}', ""); +Expect(1, 7, '\p{^Is_Blk= Latin_Extended A}', ""); +Expect(1, 7, '\P{Is_Blk= Latin_Extended A}', ""); +Expect(0, 7, '\P{^Is_Blk= Latin_Extended A}', ""); +Error('\p{Block= -balinese/a/}'); +Error('\P{Block= -balinese/a/}'); +Expect(1, 7039, '\p{Block=balinese}', ""); +Expect(0, 7039, '\p{^Block=balinese}', ""); +Expect(0, 7039, '\P{Block=balinese}', ""); +Expect(1, 7039, '\P{^Block=balinese}', ""); +Expect(0, 6911, '\p{Block=balinese}', ""); +Expect(1, 6911, '\p{^Block=balinese}', ""); +Expect(1, 6911, '\P{Block=balinese}', ""); +Expect(0, 6911, '\P{^Block=balinese}', ""); +Expect(1, 7039, '\p{Block= _balinese}', ""); +Expect(0, 7039, '\p{^Block= _balinese}', ""); +Expect(0, 7039, '\P{Block= _balinese}', ""); +Expect(1, 7039, '\P{^Block= _balinese}', ""); +Expect(0, 6911, '\p{Block= _balinese}', ""); +Expect(1, 6911, '\p{^Block= _balinese}', ""); +Expect(1, 6911, '\P{Block= _balinese}', ""); +Expect(0, 6911, '\P{^Block= _balinese}', ""); +Error('\p{Blk=--Balinese:=}'); +Error('\P{Blk=--Balinese:=}'); +Expect(1, 7039, '\p{Blk=balinese}', ""); +Expect(0, 7039, '\p{^Blk=balinese}', ""); +Expect(0, 7039, '\P{Blk=balinese}', ""); +Expect(1, 7039, '\P{^Blk=balinese}', ""); +Expect(0, 6911, '\p{Blk=balinese}', ""); +Expect(1, 6911, '\p{^Blk=balinese}', ""); +Expect(1, 6911, '\P{Blk=balinese}', ""); +Expect(0, 6911, '\P{^Blk=balinese}', ""); +Expect(1, 7039, '\p{Blk=_ Balinese}', ""); +Expect(0, 7039, '\p{^Blk=_ Balinese}', ""); +Expect(0, 7039, '\P{Blk=_ Balinese}', ""); +Expect(1, 7039, '\P{^Blk=_ Balinese}', ""); +Expect(0, 6911, '\p{Blk=_ Balinese}', ""); +Expect(1, 6911, '\p{^Blk=_ Balinese}', ""); +Expect(1, 6911, '\P{Blk=_ Balinese}', ""); +Expect(0, 6911, '\P{^Blk=_ Balinese}', ""); +Error('\p{Is_Block=/a/Balinese}'); +Error('\P{Is_Block=/a/Balinese}'); +Expect(1, 7039, '\p{Is_Block: balinese}', ""); +Expect(0, 7039, '\p{^Is_Block: balinese}', ""); +Expect(0, 7039, '\P{Is_Block: balinese}', ""); +Expect(1, 7039, '\P{^Is_Block: balinese}', ""); +Expect(0, 6911, '\p{Is_Block: balinese}', ""); +Expect(1, 6911, '\p{^Is_Block: balinese}', ""); +Expect(1, 6911, '\P{Is_Block: balinese}', ""); +Expect(0, 6911, '\P{^Is_Block: balinese}', ""); +Expect(1, 7039, '\p{Is_Block: _Balinese}', ""); +Expect(0, 7039, '\p{^Is_Block: _Balinese}', ""); +Expect(0, 7039, '\P{Is_Block: _Balinese}', ""); +Expect(1, 7039, '\P{^Is_Block: _Balinese}', ""); +Expect(0, 6911, '\p{Is_Block: _Balinese}', ""); +Expect(1, 6911, '\p{^Is_Block: _Balinese}', ""); +Expect(1, 6911, '\P{Is_Block: _Balinese}', ""); +Expect(0, 6911, '\P{^Is_Block: _Balinese}', ""); +Error('\p{Is_Blk: balinese/a/}'); +Error('\P{Is_Blk: balinese/a/}'); +Expect(1, 7039, '\p{Is_Blk=balinese}', ""); +Expect(0, 7039, '\p{^Is_Blk=balinese}', ""); +Expect(0, 7039, '\P{Is_Blk=balinese}', ""); +Expect(1, 7039, '\P{^Is_Blk=balinese}', ""); +Expect(0, 6911, '\p{Is_Blk=balinese}', ""); +Expect(1, 6911, '\p{^Is_Blk=balinese}', ""); +Expect(1, 6911, '\P{Is_Blk=balinese}', ""); +Expect(0, 6911, '\P{^Is_Blk=balinese}', ""); +Expect(1, 7039, '\p{Is_Blk=_ Balinese}', ""); +Expect(0, 7039, '\p{^Is_Blk=_ Balinese}', ""); +Expect(0, 7039, '\P{Is_Blk=_ Balinese}', ""); +Expect(1, 7039, '\P{^Is_Blk=_ Balinese}', ""); +Expect(0, 6911, '\p{Is_Blk=_ Balinese}', ""); +Expect(1, 6911, '\p{^Is_Blk=_ Balinese}', ""); +Expect(1, 6911, '\P{Is_Blk=_ Balinese}', ""); +Expect(0, 6911, '\P{^Is_Blk=_ Balinese}', ""); +Error('\p{Block= -Counting-Rod-numerals/a/}'); +Error('\P{Block= -Counting-Rod-numerals/a/}'); +Expect(1, 119679, '\p{Block: countingrodnumerals}', ""); +Expect(0, 119679, '\p{^Block: countingrodnumerals}', ""); +Expect(0, 119679, '\P{Block: countingrodnumerals}', ""); +Expect(1, 119679, '\P{^Block: countingrodnumerals}', ""); +Expect(0, 119647, '\p{Block: countingrodnumerals}', ""); +Expect(1, 119647, '\p{^Block: countingrodnumerals}', ""); +Expect(1, 119647, '\P{Block: countingrodnumerals}', ""); +Expect(0, 119647, '\P{^Block: countingrodnumerals}', ""); +Expect(1, 119679, '\p{Block=- Counting-rod_NUMERALS}', ""); +Expect(0, 119679, '\p{^Block=- Counting-rod_NUMERALS}', ""); +Expect(0, 119679, '\P{Block=- Counting-rod_NUMERALS}', ""); +Expect(1, 119679, '\P{^Block=- Counting-rod_NUMERALS}', ""); +Expect(0, 119647, '\p{Block=- Counting-rod_NUMERALS}', ""); +Expect(1, 119647, '\p{^Block=- Counting-rod_NUMERALS}', ""); +Expect(1, 119647, '\P{Block=- Counting-rod_NUMERALS}', ""); +Expect(0, 119647, '\P{^Block=- Counting-rod_NUMERALS}', ""); +Error('\p{Blk=__CountingRodNumerals:=}'); +Error('\P{Blk=__CountingRodNumerals:=}'); +Expect(1, 119679, '\p{Blk=countingrodnumerals}', ""); +Expect(0, 119679, '\p{^Blk=countingrodnumerals}', ""); +Expect(0, 119679, '\P{Blk=countingrodnumerals}', ""); +Expect(1, 119679, '\P{^Blk=countingrodnumerals}', ""); +Expect(0, 119647, '\p{Blk=countingrodnumerals}', ""); +Expect(1, 119647, '\p{^Blk=countingrodnumerals}', ""); +Expect(1, 119647, '\P{Blk=countingrodnumerals}', ""); +Expect(0, 119647, '\P{^Blk=countingrodnumerals}', ""); +Expect(1, 119679, '\p{Blk=__Counting rod NUMERALS}', ""); +Expect(0, 119679, '\p{^Blk=__Counting rod NUMERALS}', ""); +Expect(0, 119679, '\P{Blk=__Counting rod NUMERALS}', ""); +Expect(1, 119679, '\P{^Blk=__Counting rod NUMERALS}', ""); +Expect(0, 119647, '\p{Blk=__Counting rod NUMERALS}', ""); +Expect(1, 119647, '\p{^Blk=__Counting rod NUMERALS}', ""); +Expect(1, 119647, '\P{Blk=__Counting rod NUMERALS}', ""); +Expect(0, 119647, '\P{^Blk=__Counting rod NUMERALS}', ""); +Error('\p{Is_Block=:=CountingRod numerals}'); +Error('\P{Is_Block=:=CountingRod numerals}'); +Expect(1, 119679, '\p{Is_Block=countingrodnumerals}', ""); +Expect(0, 119679, '\p{^Is_Block=countingrodnumerals}', ""); +Expect(0, 119679, '\P{Is_Block=countingrodnumerals}', ""); +Expect(1, 119679, '\P{^Is_Block=countingrodnumerals}', ""); +Expect(0, 119647, '\p{Is_Block=countingrodnumerals}', ""); +Expect(1, 119647, '\p{^Is_Block=countingrodnumerals}', ""); +Expect(1, 119647, '\P{Is_Block=countingrodnumerals}', ""); +Expect(0, 119647, '\P{^Is_Block=countingrodnumerals}', ""); +Expect(1, 119679, '\p{Is_Block= Counting rodNumerals}', ""); +Expect(0, 119679, '\p{^Is_Block= Counting rodNumerals}', ""); +Expect(0, 119679, '\P{Is_Block= Counting rodNumerals}', ""); +Expect(1, 119679, '\P{^Is_Block= Counting rodNumerals}', ""); +Expect(0, 119647, '\p{Is_Block= Counting rodNumerals}', ""); +Expect(1, 119647, '\p{^Is_Block= Counting rodNumerals}', ""); +Expect(1, 119647, '\P{Is_Block= Counting rodNumerals}', ""); +Expect(0, 119647, '\P{^Is_Block= Counting rodNumerals}', ""); +Error('\p{Is_Blk= counting/a/ROD-NUMERALS}'); +Error('\P{Is_Blk= counting/a/ROD-NUMERALS}'); +Expect(1, 119679, '\p{Is_Blk=countingrodnumerals}', ""); +Expect(0, 119679, '\p{^Is_Blk=countingrodnumerals}', ""); +Expect(0, 119679, '\P{Is_Blk=countingrodnumerals}', ""); +Expect(1, 119679, '\P{^Is_Blk=countingrodnumerals}', ""); +Expect(0, 119647, '\p{Is_Blk=countingrodnumerals}', ""); +Expect(1, 119647, '\p{^Is_Blk=countingrodnumerals}', ""); +Expect(1, 119647, '\P{Is_Blk=countingrodnumerals}', ""); +Expect(0, 119647, '\P{^Is_Blk=countingrodnumerals}', ""); +Expect(1, 119679, '\p{Is_Blk=- counting Rod numerals}', ""); +Expect(0, 119679, '\p{^Is_Blk=- counting Rod numerals}', ""); +Expect(0, 119679, '\P{Is_Blk=- counting Rod numerals}', ""); +Expect(1, 119679, '\P{^Is_Blk=- counting Rod numerals}', ""); +Expect(0, 119647, '\p{Is_Blk=- counting Rod numerals}', ""); +Expect(1, 119647, '\p{^Is_Blk=- counting Rod numerals}', ""); +Expect(1, 119647, '\P{Is_Blk=- counting Rod numerals}', ""); +Expect(0, 119647, '\P{^Is_Blk=- counting Rod numerals}', ""); +Error('\p{Block=-/a/BYZANTINEMusical-Symbols}'); +Error('\P{Block=-/a/BYZANTINEMusical-Symbols}'); +Expect(1, 119039, '\p{Block: byzantinemusicalsymbols}', ""); +Expect(0, 119039, '\p{^Block: byzantinemusicalsymbols}', ""); +Expect(0, 119039, '\P{Block: byzantinemusicalsymbols}', ""); +Expect(1, 119039, '\P{^Block: byzantinemusicalsymbols}', ""); +Expect(0, 118783, '\p{Block: byzantinemusicalsymbols}', ""); +Expect(1, 118783, '\p{^Block: byzantinemusicalsymbols}', ""); +Expect(1, 118783, '\P{Block: byzantinemusicalsymbols}', ""); +Expect(0, 118783, '\P{^Block: byzantinemusicalsymbols}', ""); +Expect(1, 119039, '\p{Block= Byzantine_Musical-Symbols}', ""); +Expect(0, 119039, '\p{^Block= Byzantine_Musical-Symbols}', ""); +Expect(0, 119039, '\P{Block= Byzantine_Musical-Symbols}', ""); +Expect(1, 119039, '\P{^Block= Byzantine_Musical-Symbols}', ""); +Expect(0, 118783, '\p{Block= Byzantine_Musical-Symbols}', ""); +Expect(1, 118783, '\p{^Block= Byzantine_Musical-Symbols}', ""); +Expect(1, 118783, '\P{Block= Byzantine_Musical-Symbols}', ""); +Expect(0, 118783, '\P{^Block= Byzantine_Musical-Symbols}', ""); +Error('\p{Blk=-/a/byzantine-MusicalSYMBOLS}'); +Error('\P{Blk=-/a/byzantine-MusicalSYMBOLS}'); +Expect(1, 119039, '\p{Blk=byzantinemusicalsymbols}', ""); +Expect(0, 119039, '\p{^Blk=byzantinemusicalsymbols}', ""); +Expect(0, 119039, '\P{Blk=byzantinemusicalsymbols}', ""); +Expect(1, 119039, '\P{^Blk=byzantinemusicalsymbols}', ""); +Expect(0, 118783, '\p{Blk=byzantinemusicalsymbols}', ""); +Expect(1, 118783, '\p{^Blk=byzantinemusicalsymbols}', ""); +Expect(1, 118783, '\P{Blk=byzantinemusicalsymbols}', ""); +Expect(0, 118783, '\P{^Blk=byzantinemusicalsymbols}', ""); +Expect(1, 119039, '\p{Blk=- byzantine-Musical-Symbols}', ""); +Expect(0, 119039, '\p{^Blk=- byzantine-Musical-Symbols}', ""); +Expect(0, 119039, '\P{Blk=- byzantine-Musical-Symbols}', ""); +Expect(1, 119039, '\P{^Blk=- byzantine-Musical-Symbols}', ""); +Expect(0, 118783, '\p{Blk=- byzantine-Musical-Symbols}', ""); +Expect(1, 118783, '\p{^Blk=- byzantine-Musical-Symbols}', ""); +Expect(1, 118783, '\P{Blk=- byzantine-Musical-Symbols}', ""); +Expect(0, 118783, '\P{^Blk=- byzantine-Musical-Symbols}', ""); +Error('\p{Is_Block=_byzantine MUSICALsymbols:=}'); +Error('\P{Is_Block=_byzantine MUSICALsymbols:=}'); +Expect(1, 119039, '\p{Is_Block=byzantinemusicalsymbols}', ""); +Expect(0, 119039, '\p{^Is_Block=byzantinemusicalsymbols}', ""); +Expect(0, 119039, '\P{Is_Block=byzantinemusicalsymbols}', ""); +Expect(1, 119039, '\P{^Is_Block=byzantinemusicalsymbols}', ""); +Expect(0, 118783, '\p{Is_Block=byzantinemusicalsymbols}', ""); +Expect(1, 118783, '\p{^Is_Block=byzantinemusicalsymbols}', ""); +Expect(1, 118783, '\P{Is_Block=byzantinemusicalsymbols}', ""); +Expect(0, 118783, '\P{^Is_Block=byzantinemusicalsymbols}', ""); +Expect(1, 119039, '\p{Is_Block= Byzantine musical_SYMBOLS}', ""); +Expect(0, 119039, '\p{^Is_Block= Byzantine musical_SYMBOLS}', ""); +Expect(0, 119039, '\P{Is_Block= Byzantine musical_SYMBOLS}', ""); +Expect(1, 119039, '\P{^Is_Block= Byzantine musical_SYMBOLS}', ""); +Expect(0, 118783, '\p{Is_Block= Byzantine musical_SYMBOLS}', ""); +Expect(1, 118783, '\p{^Is_Block= Byzantine musical_SYMBOLS}', ""); +Expect(1, 118783, '\P{Is_Block= Byzantine musical_SYMBOLS}', ""); +Expect(0, 118783, '\P{^Is_Block= Byzantine musical_SYMBOLS}', ""); +Error('\p{Is_Blk= Byzantine_Musical:=Symbols}'); +Error('\P{Is_Blk= Byzantine_Musical:=Symbols}'); +Expect(1, 119039, '\p{Is_Blk=byzantinemusicalsymbols}', ""); +Expect(0, 119039, '\p{^Is_Blk=byzantinemusicalsymbols}', ""); +Expect(0, 119039, '\P{Is_Blk=byzantinemusicalsymbols}', ""); +Expect(1, 119039, '\P{^Is_Blk=byzantinemusicalsymbols}', ""); +Expect(0, 118783, '\p{Is_Blk=byzantinemusicalsymbols}', ""); +Expect(1, 118783, '\p{^Is_Blk=byzantinemusicalsymbols}', ""); +Expect(1, 118783, '\P{Is_Blk=byzantinemusicalsymbols}', ""); +Expect(0, 118783, '\P{^Is_Blk=byzantinemusicalsymbols}', ""); +Expect(1, 119039, '\p{Is_Blk=- byzantineMusical_symbols}', ""); +Expect(0, 119039, '\p{^Is_Blk=- byzantineMusical_symbols}', ""); +Expect(0, 119039, '\P{Is_Blk=- byzantineMusical_symbols}', ""); +Expect(1, 119039, '\P{^Is_Blk=- byzantineMusical_symbols}', ""); +Expect(0, 118783, '\p{Is_Blk=- byzantineMusical_symbols}', ""); +Expect(1, 118783, '\p{^Is_Blk=- byzantineMusical_symbols}', ""); +Expect(1, 118783, '\P{Is_Blk=- byzantineMusical_symbols}', ""); +Expect(0, 118783, '\P{^Is_Blk=- byzantineMusical_symbols}', ""); +Error('\p{Block=/a/ tamil}'); +Error('\P{Block=/a/ tamil}'); +Expect(1, 3071, '\p{Block=tamil}', ""); +Expect(0, 3071, '\p{^Block=tamil}', ""); +Expect(0, 3071, '\P{Block=tamil}', ""); +Expect(1, 3071, '\P{^Block=tamil}', ""); +Expect(0, 2943, '\p{Block=tamil}', ""); +Expect(1, 2943, '\p{^Block=tamil}', ""); +Expect(1, 2943, '\P{Block=tamil}', ""); +Expect(0, 2943, '\P{^Block=tamil}', ""); +Expect(1, 3071, '\p{Block=_ Tamil}', ""); +Expect(0, 3071, '\p{^Block=_ Tamil}', ""); +Expect(0, 3071, '\P{Block=_ Tamil}', ""); +Expect(1, 3071, '\P{^Block=_ Tamil}', ""); +Expect(0, 2943, '\p{Block=_ Tamil}', ""); +Expect(1, 2943, '\p{^Block=_ Tamil}', ""); +Expect(1, 2943, '\P{Block=_ Tamil}', ""); +Expect(0, 2943, '\P{^Block=_ Tamil}', ""); +Error('\p{Blk=/a/ tamil}'); +Error('\P{Blk=/a/ tamil}'); +Expect(1, 3071, '\p{Blk=tamil}', ""); +Expect(0, 3071, '\p{^Blk=tamil}', ""); +Expect(0, 3071, '\P{Blk=tamil}', ""); +Expect(1, 3071, '\P{^Blk=tamil}', ""); +Expect(0, 2943, '\p{Blk=tamil}', ""); +Expect(1, 2943, '\p{^Blk=tamil}', ""); +Expect(1, 2943, '\P{Blk=tamil}', ""); +Expect(0, 2943, '\P{^Blk=tamil}', ""); +Expect(1, 3071, '\p{Blk: -_Tamil}', ""); +Expect(0, 3071, '\p{^Blk: -_Tamil}', ""); +Expect(0, 3071, '\P{Blk: -_Tamil}', ""); +Expect(1, 3071, '\P{^Blk: -_Tamil}', ""); +Expect(0, 2943, '\p{Blk: -_Tamil}', ""); +Expect(1, 2943, '\p{^Blk: -_Tamil}', ""); +Expect(1, 2943, '\P{Blk: -_Tamil}', ""); +Expect(0, 2943, '\P{^Blk: -_Tamil}', ""); +Error('\p{Is_Block= -TAMIL:=}'); +Error('\P{Is_Block= -TAMIL:=}'); +Expect(1, 3071, '\p{Is_Block=tamil}', ""); +Expect(0, 3071, '\p{^Is_Block=tamil}', ""); +Expect(0, 3071, '\P{Is_Block=tamil}', ""); +Expect(1, 3071, '\P{^Is_Block=tamil}', ""); +Expect(0, 2943, '\p{Is_Block=tamil}', ""); +Expect(1, 2943, '\p{^Is_Block=tamil}', ""); +Expect(1, 2943, '\P{Is_Block=tamil}', ""); +Expect(0, 2943, '\P{^Is_Block=tamil}', ""); +Expect(1, 3071, '\p{Is_Block=_ Tamil}', ""); +Expect(0, 3071, '\p{^Is_Block=_ Tamil}', ""); +Expect(0, 3071, '\P{Is_Block=_ Tamil}', ""); +Expect(1, 3071, '\P{^Is_Block=_ Tamil}', ""); +Expect(0, 2943, '\p{Is_Block=_ Tamil}', ""); +Expect(1, 2943, '\p{^Is_Block=_ Tamil}', ""); +Expect(1, 2943, '\P{Is_Block=_ Tamil}', ""); +Expect(0, 2943, '\P{^Is_Block=_ Tamil}', ""); +Error('\p{Is_Blk= _Tamil/a/}'); +Error('\P{Is_Blk= _Tamil/a/}'); +Expect(1, 3071, '\p{Is_Blk=tamil}', ""); +Expect(0, 3071, '\p{^Is_Blk=tamil}', ""); +Expect(0, 3071, '\P{Is_Blk=tamil}', ""); +Expect(1, 3071, '\P{^Is_Blk=tamil}', ""); +Expect(0, 2943, '\p{Is_Blk=tamil}', ""); +Expect(1, 2943, '\p{^Is_Blk=tamil}', ""); +Expect(1, 2943, '\P{Is_Blk=tamil}', ""); +Expect(0, 2943, '\P{^Is_Blk=tamil}', ""); +Expect(1, 3071, '\p{Is_Blk=-Tamil}', ""); +Expect(0, 3071, '\p{^Is_Blk=-Tamil}', ""); +Expect(0, 3071, '\P{Is_Blk=-Tamil}', ""); +Expect(1, 3071, '\P{^Is_Blk=-Tamil}', ""); +Expect(0, 2943, '\p{Is_Blk=-Tamil}', ""); +Expect(1, 2943, '\p{^Is_Blk=-Tamil}', ""); +Expect(1, 2943, '\P{Is_Blk=-Tamil}', ""); +Expect(0, 2943, '\P{^Is_Blk=-Tamil}', ""); +Error('\p{Block=:=SPECIALS}'); +Error('\P{Block=:=SPECIALS}'); +Expect(1, 65520, '\p{Block=specials}', ""); +Expect(0, 65520, '\p{^Block=specials}', ""); +Expect(0, 65520, '\P{Block=specials}', ""); +Expect(1, 65520, '\P{^Block=specials}', ""); +Expect(0, 65519, '\p{Block=specials}', ""); +Expect(1, 65519, '\p{^Block=specials}', ""); +Expect(1, 65519, '\P{Block=specials}', ""); +Expect(0, 65519, '\P{^Block=specials}', ""); +Expect(1, 65520, '\p{Block= SPECIALS}', ""); +Expect(0, 65520, '\p{^Block= SPECIALS}', ""); +Expect(0, 65520, '\P{Block= SPECIALS}', ""); +Expect(1, 65520, '\P{^Block= SPECIALS}', ""); +Expect(0, 65519, '\p{Block= SPECIALS}', ""); +Expect(1, 65519, '\p{^Block= SPECIALS}', ""); +Expect(1, 65519, '\P{Block= SPECIALS}', ""); +Expect(0, 65519, '\P{^Block= SPECIALS}', ""); +Error('\p{Blk=_ SPECIALS:=}'); +Error('\P{Blk=_ SPECIALS:=}'); +Expect(1, 65520, '\p{Blk=specials}', ""); +Expect(0, 65520, '\p{^Blk=specials}', ""); +Expect(0, 65520, '\P{Blk=specials}', ""); +Expect(1, 65520, '\P{^Blk=specials}', ""); +Expect(0, 65519, '\p{Blk=specials}', ""); +Expect(1, 65519, '\p{^Blk=specials}', ""); +Expect(1, 65519, '\P{Blk=specials}', ""); +Expect(0, 65519, '\P{^Blk=specials}', ""); +Expect(1, 65520, '\p{Blk= Specials}', ""); +Expect(0, 65520, '\p{^Blk= Specials}', ""); +Expect(0, 65520, '\P{Blk= Specials}', ""); +Expect(1, 65520, '\P{^Blk= Specials}', ""); +Expect(0, 65519, '\p{Blk= Specials}', ""); +Expect(1, 65519, '\p{^Blk= Specials}', ""); +Expect(1, 65519, '\P{Blk= Specials}', ""); +Expect(0, 65519, '\P{^Blk= Specials}', ""); +Error('\p{Is_Block: Specials:=}'); +Error('\P{Is_Block: Specials:=}'); +Expect(1, 65520, '\p{Is_Block=specials}', ""); +Expect(0, 65520, '\p{^Is_Block=specials}', ""); +Expect(0, 65520, '\P{Is_Block=specials}', ""); +Expect(1, 65520, '\P{^Is_Block=specials}', ""); +Expect(0, 65519, '\p{Is_Block=specials}', ""); +Expect(1, 65519, '\p{^Is_Block=specials}', ""); +Expect(1, 65519, '\P{Is_Block=specials}', ""); +Expect(0, 65519, '\P{^Is_Block=specials}', ""); +Expect(1, 65520, '\p{Is_Block=- Specials}', ""); +Expect(0, 65520, '\p{^Is_Block=- Specials}', ""); +Expect(0, 65520, '\P{Is_Block=- Specials}', ""); +Expect(1, 65520, '\P{^Is_Block=- Specials}', ""); +Expect(0, 65519, '\p{Is_Block=- Specials}', ""); +Expect(1, 65519, '\p{^Is_Block=- Specials}', ""); +Expect(1, 65519, '\P{Is_Block=- Specials}', ""); +Expect(0, 65519, '\P{^Is_Block=- Specials}', ""); +Error('\p{Is_Blk=:=Specials}'); +Error('\P{Is_Blk=:=Specials}'); +Expect(1, 65520, '\p{Is_Blk: specials}', ""); +Expect(0, 65520, '\p{^Is_Blk: specials}', ""); +Expect(0, 65520, '\P{Is_Blk: specials}', ""); +Expect(1, 65520, '\P{^Is_Blk: specials}', ""); +Expect(0, 65519, '\p{Is_Blk: specials}', ""); +Expect(1, 65519, '\p{^Is_Blk: specials}', ""); +Expect(1, 65519, '\P{Is_Blk: specials}', ""); +Expect(0, 65519, '\P{^Is_Blk: specials}', ""); +Expect(1, 65520, '\p{Is_Blk: SPECIALS}', ""); +Expect(0, 65520, '\p{^Is_Blk: SPECIALS}', ""); +Expect(0, 65520, '\P{Is_Blk: SPECIALS}', ""); +Expect(1, 65520, '\P{^Is_Blk: SPECIALS}', ""); +Expect(0, 65519, '\p{Is_Blk: SPECIALS}', ""); +Expect(1, 65519, '\p{^Is_Blk: SPECIALS}', ""); +Expect(1, 65519, '\P{Is_Blk: SPECIALS}', ""); +Expect(0, 65519, '\P{^Is_Blk: SPECIALS}', ""); +Error('\p{Block=-/a/Georgian}'); +Error('\P{Block=-/a/Georgian}'); +Expect(1, 4351, '\p{Block=georgian}', ""); +Expect(0, 4351, '\p{^Block=georgian}', ""); +Expect(0, 4351, '\P{Block=georgian}', ""); +Expect(1, 4351, '\P{^Block=georgian}', ""); +Expect(0, 4255, '\p{Block=georgian}', ""); +Expect(1, 4255, '\p{^Block=georgian}', ""); +Expect(1, 4255, '\P{Block=georgian}', ""); +Expect(0, 4255, '\P{^Block=georgian}', ""); +Expect(1, 4351, '\p{Block=_Georgian}', ""); +Expect(0, 4351, '\p{^Block=_Georgian}', ""); +Expect(0, 4351, '\P{Block=_Georgian}', ""); +Expect(1, 4351, '\P{^Block=_Georgian}', ""); +Expect(0, 4255, '\p{Block=_Georgian}', ""); +Expect(1, 4255, '\p{^Block=_Georgian}', ""); +Expect(1, 4255, '\P{Block=_Georgian}', ""); +Expect(0, 4255, '\P{^Block=_Georgian}', ""); +Error('\p{Blk=_/a/GEORGIAN}'); +Error('\P{Blk=_/a/GEORGIAN}'); +Expect(1, 4351, '\p{Blk=georgian}', ""); +Expect(0, 4351, '\p{^Blk=georgian}', ""); +Expect(0, 4351, '\P{Blk=georgian}', ""); +Expect(1, 4351, '\P{^Blk=georgian}', ""); +Expect(0, 4255, '\p{Blk=georgian}', ""); +Expect(1, 4255, '\p{^Blk=georgian}', ""); +Expect(1, 4255, '\P{Blk=georgian}', ""); +Expect(0, 4255, '\P{^Blk=georgian}', ""); +Expect(1, 4351, '\p{Blk=__Georgian}', ""); +Expect(0, 4351, '\p{^Blk=__Georgian}', ""); +Expect(0, 4351, '\P{Blk=__Georgian}', ""); +Expect(1, 4351, '\P{^Blk=__Georgian}', ""); +Expect(0, 4255, '\p{Blk=__Georgian}', ""); +Expect(1, 4255, '\p{^Blk=__Georgian}', ""); +Expect(1, 4255, '\P{Blk=__Georgian}', ""); +Expect(0, 4255, '\P{^Blk=__Georgian}', ""); +Error('\p{Is_Block=:=georgian}'); +Error('\P{Is_Block=:=georgian}'); +Expect(1, 4351, '\p{Is_Block=georgian}', ""); +Expect(0, 4351, '\p{^Is_Block=georgian}', ""); +Expect(0, 4351, '\P{Is_Block=georgian}', ""); +Expect(1, 4351, '\P{^Is_Block=georgian}', ""); +Expect(0, 4255, '\p{Is_Block=georgian}', ""); +Expect(1, 4255, '\p{^Is_Block=georgian}', ""); +Expect(1, 4255, '\P{Is_Block=georgian}', ""); +Expect(0, 4255, '\P{^Is_Block=georgian}', ""); +Expect(1, 4351, '\p{Is_Block= -georgian}', ""); +Expect(0, 4351, '\p{^Is_Block= -georgian}', ""); +Expect(0, 4351, '\P{Is_Block= -georgian}', ""); +Expect(1, 4351, '\P{^Is_Block= -georgian}', ""); +Expect(0, 4255, '\p{Is_Block= -georgian}', ""); +Expect(1, 4255, '\p{^Is_Block= -georgian}', ""); +Expect(1, 4255, '\P{Is_Block= -georgian}', ""); +Expect(0, 4255, '\P{^Is_Block= -georgian}', ""); +Error('\p{Is_Blk=_/a/Georgian}'); +Error('\P{Is_Blk=_/a/Georgian}'); +Expect(1, 4351, '\p{Is_Blk=georgian}', ""); +Expect(0, 4351, '\p{^Is_Blk=georgian}', ""); +Expect(0, 4351, '\P{Is_Blk=georgian}', ""); +Expect(1, 4351, '\P{^Is_Blk=georgian}', ""); +Expect(0, 4255, '\p{Is_Blk=georgian}', ""); +Expect(1, 4255, '\p{^Is_Blk=georgian}', ""); +Expect(1, 4255, '\P{Is_Blk=georgian}', ""); +Expect(0, 4255, '\P{^Is_Blk=georgian}', ""); +Expect(1, 4351, '\p{Is_Blk=GEORGIAN}', ""); +Expect(0, 4351, '\p{^Is_Blk=GEORGIAN}', ""); +Expect(0, 4351, '\P{Is_Blk=GEORGIAN}', ""); +Expect(1, 4351, '\P{^Is_Blk=GEORGIAN}', ""); +Expect(0, 4255, '\p{Is_Blk=GEORGIAN}', ""); +Expect(1, 4255, '\p{^Is_Blk=GEORGIAN}', ""); +Expect(1, 4255, '\P{Is_Blk=GEORGIAN}', ""); +Expect(0, 4255, '\P{^Is_Blk=GEORGIAN}', ""); +Error('\p{Block=-:=Kayah LI}'); +Error('\P{Block=-:=Kayah LI}'); +Expect(1, 43311, '\p{Block=kayahli}', ""); +Expect(0, 43311, '\p{^Block=kayahli}', ""); +Expect(0, 43311, '\P{Block=kayahli}', ""); +Expect(1, 43311, '\P{^Block=kayahli}', ""); +Expect(0, 43263, '\p{Block=kayahli}', ""); +Expect(1, 43263, '\p{^Block=kayahli}', ""); +Expect(1, 43263, '\P{Block=kayahli}', ""); +Expect(0, 43263, '\P{^Block=kayahli}', ""); +Expect(1, 43311, '\p{Block= Kayah Li}', ""); +Expect(0, 43311, '\p{^Block= Kayah Li}', ""); +Expect(0, 43311, '\P{Block= Kayah Li}', ""); +Expect(1, 43311, '\P{^Block= Kayah Li}', ""); +Expect(0, 43263, '\p{Block= Kayah Li}', ""); +Expect(1, 43263, '\p{^Block= Kayah Li}', ""); +Expect(1, 43263, '\P{Block= Kayah Li}', ""); +Expect(0, 43263, '\P{^Block= Kayah Li}', ""); +Error('\p{Blk= _Kayah-li:=}'); +Error('\P{Blk= _Kayah-li:=}'); +Expect(1, 43311, '\p{Blk=kayahli}', ""); +Expect(0, 43311, '\p{^Blk=kayahli}', ""); +Expect(0, 43311, '\P{Blk=kayahli}', ""); +Expect(1, 43311, '\P{^Blk=kayahli}', ""); +Expect(0, 43263, '\p{Blk=kayahli}', ""); +Expect(1, 43263, '\p{^Blk=kayahli}', ""); +Expect(1, 43263, '\P{Blk=kayahli}', ""); +Expect(0, 43263, '\P{^Blk=kayahli}', ""); +Expect(1, 43311, '\p{Blk= KAYAH-li}', ""); +Expect(0, 43311, '\p{^Blk= KAYAH-li}', ""); +Expect(0, 43311, '\P{Blk= KAYAH-li}', ""); +Expect(1, 43311, '\P{^Blk= KAYAH-li}', ""); +Expect(0, 43263, '\p{Blk= KAYAH-li}', ""); +Expect(1, 43263, '\p{^Blk= KAYAH-li}', ""); +Expect(1, 43263, '\P{Blk= KAYAH-li}', ""); +Expect(0, 43263, '\P{^Blk= KAYAH-li}', ""); +Error('\p{Is_Block: :=KAYAH Li}'); +Error('\P{Is_Block: :=KAYAH Li}'); +Expect(1, 43311, '\p{Is_Block=kayahli}', ""); +Expect(0, 43311, '\p{^Is_Block=kayahli}', ""); +Expect(0, 43311, '\P{Is_Block=kayahli}', ""); +Expect(1, 43311, '\P{^Is_Block=kayahli}', ""); +Expect(0, 43263, '\p{Is_Block=kayahli}', ""); +Expect(1, 43263, '\p{^Is_Block=kayahli}', ""); +Expect(1, 43263, '\P{Is_Block=kayahli}', ""); +Expect(0, 43263, '\P{^Is_Block=kayahli}', ""); +Expect(1, 43311, '\p{Is_Block: Kayah_li}', ""); +Expect(0, 43311, '\p{^Is_Block: Kayah_li}', ""); +Expect(0, 43311, '\P{Is_Block: Kayah_li}', ""); +Expect(1, 43311, '\P{^Is_Block: Kayah_li}', ""); +Expect(0, 43263, '\p{Is_Block: Kayah_li}', ""); +Expect(1, 43263, '\p{^Is_Block: Kayah_li}', ""); +Expect(1, 43263, '\P{Is_Block: Kayah_li}', ""); +Expect(0, 43263, '\P{^Is_Block: Kayah_li}', ""); +Error('\p{Is_Blk=:= KAYAH-Li}'); +Error('\P{Is_Blk=:= KAYAH-Li}'); +Expect(1, 43311, '\p{Is_Blk=kayahli}', ""); +Expect(0, 43311, '\p{^Is_Blk=kayahli}', ""); +Expect(0, 43311, '\P{Is_Blk=kayahli}', ""); +Expect(1, 43311, '\P{^Is_Blk=kayahli}', ""); +Expect(0, 43263, '\p{Is_Blk=kayahli}', ""); +Expect(1, 43263, '\p{^Is_Blk=kayahli}', ""); +Expect(1, 43263, '\P{Is_Blk=kayahli}', ""); +Expect(0, 43263, '\P{^Is_Blk=kayahli}', ""); +Expect(1, 43311, '\p{Is_Blk: -Kayah LI}', ""); +Expect(0, 43311, '\p{^Is_Blk: -Kayah LI}', ""); +Expect(0, 43311, '\P{Is_Blk: -Kayah LI}', ""); +Expect(1, 43311, '\P{^Is_Blk: -Kayah LI}', ""); +Expect(0, 43263, '\p{Is_Blk: -Kayah LI}', ""); +Expect(1, 43263, '\p{^Is_Blk: -Kayah LI}', ""); +Expect(1, 43263, '\P{Is_Blk: -Kayah LI}', ""); +Expect(0, 43263, '\P{^Is_Blk: -Kayah LI}', ""); +Error('\p{Block= CJK:=Compatibility Forms}'); +Error('\P{Block= CJK:=Compatibility Forms}'); +Expect(1, 65103, '\p{Block=cjkcompatibilityforms}', ""); +Expect(0, 65103, '\p{^Block=cjkcompatibilityforms}', ""); +Expect(0, 65103, '\P{Block=cjkcompatibilityforms}', ""); +Expect(1, 65103, '\P{^Block=cjkcompatibilityforms}', ""); +Expect(0, 65071, '\p{Block=cjkcompatibilityforms}', ""); +Expect(1, 65071, '\p{^Block=cjkcompatibilityforms}', ""); +Expect(1, 65071, '\P{Block=cjkcompatibilityforms}', ""); +Expect(0, 65071, '\P{^Block=cjkcompatibilityforms}', ""); +Expect(1, 65103, '\p{Block: CJKCompatibility Forms}', ""); +Expect(0, 65103, '\p{^Block: CJKCompatibility Forms}', ""); +Expect(0, 65103, '\P{Block: CJKCompatibility Forms}', ""); +Expect(1, 65103, '\P{^Block: CJKCompatibility Forms}', ""); +Expect(0, 65071, '\p{Block: CJKCompatibility Forms}', ""); +Expect(1, 65071, '\p{^Block: CJKCompatibility Forms}', ""); +Expect(1, 65071, '\P{Block: CJKCompatibility Forms}', ""); +Expect(0, 65071, '\P{^Block: CJKCompatibility Forms}', ""); +Error('\p{Blk= CJK-compatibility Forms/a/}'); +Error('\P{Blk= CJK-compatibility Forms/a/}'); +Expect(1, 65103, '\p{Blk=cjkcompatibilityforms}', ""); +Expect(0, 65103, '\p{^Blk=cjkcompatibilityforms}', ""); +Expect(0, 65103, '\P{Blk=cjkcompatibilityforms}', ""); +Expect(1, 65103, '\P{^Blk=cjkcompatibilityforms}', ""); +Expect(0, 65071, '\p{Blk=cjkcompatibilityforms}', ""); +Expect(1, 65071, '\p{^Blk=cjkcompatibilityforms}', ""); +Expect(1, 65071, '\P{Blk=cjkcompatibilityforms}', ""); +Expect(0, 65071, '\P{^Blk=cjkcompatibilityforms}', ""); +Expect(1, 65103, '\p{Blk=cjkCompatibility Forms}', ""); +Expect(0, 65103, '\p{^Blk=cjkCompatibility Forms}', ""); +Expect(0, 65103, '\P{Blk=cjkCompatibility Forms}', ""); +Expect(1, 65103, '\P{^Blk=cjkCompatibility Forms}', ""); +Expect(0, 65071, '\p{Blk=cjkCompatibility Forms}', ""); +Expect(1, 65071, '\p{^Blk=cjkCompatibility Forms}', ""); +Expect(1, 65071, '\P{Blk=cjkCompatibility Forms}', ""); +Expect(0, 65071, '\P{^Blk=cjkCompatibility Forms}', ""); +Error('\p{Is_Block::= CJK_compatibility_Forms}'); +Error('\P{Is_Block::= CJK_compatibility_Forms}'); +Expect(1, 65103, '\p{Is_Block=cjkcompatibilityforms}', ""); +Expect(0, 65103, '\p{^Is_Block=cjkcompatibilityforms}', ""); +Expect(0, 65103, '\P{Is_Block=cjkcompatibilityforms}', ""); +Expect(1, 65103, '\P{^Is_Block=cjkcompatibilityforms}', ""); +Expect(0, 65071, '\p{Is_Block=cjkcompatibilityforms}', ""); +Expect(1, 65071, '\p{^Is_Block=cjkcompatibilityforms}', ""); +Expect(1, 65071, '\P{Is_Block=cjkcompatibilityforms}', ""); +Expect(0, 65071, '\P{^Is_Block=cjkcompatibilityforms}', ""); +Expect(1, 65103, '\p{Is_Block=_ CJK-compatibility Forms}', ""); +Expect(0, 65103, '\p{^Is_Block=_ CJK-compatibility Forms}', ""); +Expect(0, 65103, '\P{Is_Block=_ CJK-compatibility Forms}', ""); +Expect(1, 65103, '\P{^Is_Block=_ CJK-compatibility Forms}', ""); +Expect(0, 65071, '\p{Is_Block=_ CJK-compatibility Forms}', ""); +Expect(1, 65071, '\p{^Is_Block=_ CJK-compatibility Forms}', ""); +Expect(1, 65071, '\P{Is_Block=_ CJK-compatibility Forms}', ""); +Expect(0, 65071, '\P{^Is_Block=_ CJK-compatibility Forms}', ""); +Error('\p{Is_Blk:_:=CJK compatibility Forms}'); +Error('\P{Is_Blk:_:=CJK compatibility Forms}'); +Expect(1, 65103, '\p{Is_Blk=cjkcompatibilityforms}', ""); +Expect(0, 65103, '\p{^Is_Blk=cjkcompatibilityforms}', ""); +Expect(0, 65103, '\P{Is_Blk=cjkcompatibilityforms}', ""); +Expect(1, 65103, '\P{^Is_Blk=cjkcompatibilityforms}', ""); +Expect(0, 65071, '\p{Is_Blk=cjkcompatibilityforms}', ""); +Expect(1, 65071, '\p{^Is_Blk=cjkcompatibilityforms}', ""); +Expect(1, 65071, '\P{Is_Blk=cjkcompatibilityforms}', ""); +Expect(0, 65071, '\P{^Is_Blk=cjkcompatibilityforms}', ""); +Expect(1, 65103, '\p{Is_Blk=_-cjk COMPATIBILITY Forms}', ""); +Expect(0, 65103, '\p{^Is_Blk=_-cjk COMPATIBILITY Forms}', ""); +Expect(0, 65103, '\P{Is_Blk=_-cjk COMPATIBILITY Forms}', ""); +Expect(1, 65103, '\P{^Is_Blk=_-cjk COMPATIBILITY Forms}', ""); +Expect(0, 65071, '\p{Is_Blk=_-cjk COMPATIBILITY Forms}', ""); +Expect(1, 65071, '\p{^Is_Blk=_-cjk COMPATIBILITY Forms}', ""); +Expect(1, 65071, '\P{Is_Blk=_-cjk COMPATIBILITY Forms}', ""); +Expect(0, 65071, '\P{^Is_Blk=_-cjk COMPATIBILITY Forms}', ""); +Error('\p{Block=--tifinagh/a/}'); +Error('\P{Block=--tifinagh/a/}'); +Expect(1, 11647, '\p{Block=tifinagh}', ""); +Expect(0, 11647, '\p{^Block=tifinagh}', ""); +Expect(0, 11647, '\P{Block=tifinagh}', ""); +Expect(1, 11647, '\P{^Block=tifinagh}', ""); +Expect(0, 11567, '\p{Block=tifinagh}', ""); +Expect(1, 11567, '\p{^Block=tifinagh}', ""); +Expect(1, 11567, '\P{Block=tifinagh}', ""); +Expect(0, 11567, '\P{^Block=tifinagh}', ""); +Expect(1, 11647, '\p{Block=__TIFINAGH}', ""); +Expect(0, 11647, '\p{^Block=__TIFINAGH}', ""); +Expect(0, 11647, '\P{Block=__TIFINAGH}', ""); +Expect(1, 11647, '\P{^Block=__TIFINAGH}', ""); +Expect(0, 11567, '\p{Block=__TIFINAGH}', ""); +Expect(1, 11567, '\p{^Block=__TIFINAGH}', ""); +Expect(1, 11567, '\P{Block=__TIFINAGH}', ""); +Expect(0, 11567, '\P{^Block=__TIFINAGH}', ""); +Error('\p{Blk=_:=TIFINAGH}'); +Error('\P{Blk=_:=TIFINAGH}'); +Expect(1, 11647, '\p{Blk=tifinagh}', ""); +Expect(0, 11647, '\p{^Blk=tifinagh}', ""); +Expect(0, 11647, '\P{Blk=tifinagh}', ""); +Expect(1, 11647, '\P{^Blk=tifinagh}', ""); +Expect(0, 11567, '\p{Blk=tifinagh}', ""); +Expect(1, 11567, '\p{^Blk=tifinagh}', ""); +Expect(1, 11567, '\P{Blk=tifinagh}', ""); +Expect(0, 11567, '\P{^Blk=tifinagh}', ""); +Expect(1, 11647, '\p{Blk=_tifinagh}', ""); +Expect(0, 11647, '\p{^Blk=_tifinagh}', ""); +Expect(0, 11647, '\P{Blk=_tifinagh}', ""); +Expect(1, 11647, '\P{^Blk=_tifinagh}', ""); +Expect(0, 11567, '\p{Blk=_tifinagh}', ""); +Expect(1, 11567, '\p{^Blk=_tifinagh}', ""); +Expect(1, 11567, '\P{Blk=_tifinagh}', ""); +Expect(0, 11567, '\P{^Blk=_tifinagh}', ""); +Error('\p{Is_Block=:=_Tifinagh}'); +Error('\P{Is_Block=:=_Tifinagh}'); +Expect(1, 11647, '\p{Is_Block=tifinagh}', ""); +Expect(0, 11647, '\p{^Is_Block=tifinagh}', ""); +Expect(0, 11647, '\P{Is_Block=tifinagh}', ""); +Expect(1, 11647, '\P{^Is_Block=tifinagh}', ""); +Expect(0, 11567, '\p{Is_Block=tifinagh}', ""); +Expect(1, 11567, '\p{^Is_Block=tifinagh}', ""); +Expect(1, 11567, '\P{Is_Block=tifinagh}', ""); +Expect(0, 11567, '\P{^Is_Block=tifinagh}', ""); +Expect(1, 11647, '\p{Is_Block= Tifinagh}', ""); +Expect(0, 11647, '\p{^Is_Block= Tifinagh}', ""); +Expect(0, 11647, '\P{Is_Block= Tifinagh}', ""); +Expect(1, 11647, '\P{^Is_Block= Tifinagh}', ""); +Expect(0, 11567, '\p{Is_Block= Tifinagh}', ""); +Expect(1, 11567, '\p{^Is_Block= Tifinagh}', ""); +Expect(1, 11567, '\P{Is_Block= Tifinagh}', ""); +Expect(0, 11567, '\P{^Is_Block= Tifinagh}', ""); +Error('\p{Is_Blk=_:=TIFINAGH}'); +Error('\P{Is_Blk=_:=TIFINAGH}'); +Expect(1, 11647, '\p{Is_Blk=tifinagh}', ""); +Expect(0, 11647, '\p{^Is_Blk=tifinagh}', ""); +Expect(0, 11647, '\P{Is_Blk=tifinagh}', ""); +Expect(1, 11647, '\P{^Is_Blk=tifinagh}', ""); +Expect(0, 11567, '\p{Is_Blk=tifinagh}', ""); +Expect(1, 11567, '\p{^Is_Blk=tifinagh}', ""); +Expect(1, 11567, '\P{Is_Blk=tifinagh}', ""); +Expect(0, 11567, '\P{^Is_Blk=tifinagh}', ""); +Expect(1, 11647, '\p{Is_Blk= Tifinagh}', ""); +Expect(0, 11647, '\p{^Is_Blk= Tifinagh}', ""); +Expect(0, 11647, '\P{Is_Blk= Tifinagh}', ""); +Expect(1, 11647, '\P{^Is_Blk= Tifinagh}', ""); +Expect(0, 11567, '\p{Is_Blk= Tifinagh}', ""); +Expect(1, 11567, '\p{^Is_Blk= Tifinagh}', ""); +Expect(1, 11567, '\P{Is_Blk= Tifinagh}', ""); +Expect(0, 11567, '\P{^Is_Blk= Tifinagh}', ""); +Error('\p{Block=:= -Thai}'); +Error('\P{Block=:= -Thai}'); +Expect(1, 3711, '\p{Block=thai}', ""); +Expect(0, 3711, '\p{^Block=thai}', ""); +Expect(0, 3711, '\P{Block=thai}', ""); +Expect(1, 3711, '\P{^Block=thai}', ""); +Expect(0, 3583, '\p{Block=thai}', ""); +Expect(1, 3583, '\p{^Block=thai}', ""); +Expect(1, 3583, '\P{Block=thai}', ""); +Expect(0, 3583, '\P{^Block=thai}', ""); +Expect(1, 3711, '\p{Block:_THAI}', ""); +Expect(0, 3711, '\p{^Block:_THAI}', ""); +Expect(0, 3711, '\P{Block:_THAI}', ""); +Expect(1, 3711, '\P{^Block:_THAI}', ""); +Expect(0, 3583, '\p{Block:_THAI}', ""); +Expect(1, 3583, '\p{^Block:_THAI}', ""); +Expect(1, 3583, '\P{Block:_THAI}', ""); +Expect(0, 3583, '\P{^Block:_THAI}', ""); +Error('\p{Blk=_:=thai}'); +Error('\P{Blk=_:=thai}'); +Expect(1, 3711, '\p{Blk=thai}', ""); +Expect(0, 3711, '\p{^Blk=thai}', ""); +Expect(0, 3711, '\P{Blk=thai}', ""); +Expect(1, 3711, '\P{^Blk=thai}', ""); +Expect(0, 3583, '\p{Blk=thai}', ""); +Expect(1, 3583, '\p{^Blk=thai}', ""); +Expect(1, 3583, '\P{Blk=thai}', ""); +Expect(0, 3583, '\P{^Blk=thai}', ""); +Expect(1, 3711, '\p{Blk=- THAI}', ""); +Expect(0, 3711, '\p{^Blk=- THAI}', ""); +Expect(0, 3711, '\P{Blk=- THAI}', ""); +Expect(1, 3711, '\P{^Blk=- THAI}', ""); +Expect(0, 3583, '\p{Blk=- THAI}', ""); +Expect(1, 3583, '\p{^Blk=- THAI}', ""); +Expect(1, 3583, '\P{Blk=- THAI}', ""); +Expect(0, 3583, '\P{^Blk=- THAI}', ""); +Error('\p{Is_Block=/a/thai}'); +Error('\P{Is_Block=/a/thai}'); +Expect(1, 3711, '\p{Is_Block=thai}', ""); +Expect(0, 3711, '\p{^Is_Block=thai}', ""); +Expect(0, 3711, '\P{Is_Block=thai}', ""); +Expect(1, 3711, '\P{^Is_Block=thai}', ""); +Expect(0, 3583, '\p{Is_Block=thai}', ""); +Expect(1, 3583, '\p{^Is_Block=thai}', ""); +Expect(1, 3583, '\P{Is_Block=thai}', ""); +Expect(0, 3583, '\P{^Is_Block=thai}', ""); +Expect(1, 3711, '\p{Is_Block: -Thai}', ""); +Expect(0, 3711, '\p{^Is_Block: -Thai}', ""); +Expect(0, 3711, '\P{Is_Block: -Thai}', ""); +Expect(1, 3711, '\P{^Is_Block: -Thai}', ""); +Expect(0, 3583, '\p{Is_Block: -Thai}', ""); +Expect(1, 3583, '\p{^Is_Block: -Thai}', ""); +Expect(1, 3583, '\P{Is_Block: -Thai}', ""); +Expect(0, 3583, '\P{^Is_Block: -Thai}', ""); +Error('\p{Is_Blk=/a/ _Thai}'); +Error('\P{Is_Blk=/a/ _Thai}'); +Expect(1, 3711, '\p{Is_Blk=thai}', ""); +Expect(0, 3711, '\p{^Is_Blk=thai}', ""); +Expect(0, 3711, '\P{Is_Blk=thai}', ""); +Expect(1, 3711, '\P{^Is_Blk=thai}', ""); +Expect(0, 3583, '\p{Is_Blk=thai}', ""); +Expect(1, 3583, '\p{^Is_Blk=thai}', ""); +Expect(1, 3583, '\P{Is_Blk=thai}', ""); +Expect(0, 3583, '\P{^Is_Blk=thai}', ""); +Expect(1, 3711, '\p{Is_Blk= thai}', ""); +Expect(0, 3711, '\p{^Is_Blk= thai}', ""); +Expect(0, 3711, '\P{Is_Blk= thai}', ""); +Expect(1, 3711, '\P{^Is_Blk= thai}', ""); +Expect(0, 3583, '\p{Is_Blk= thai}', ""); +Expect(1, 3583, '\p{^Is_Blk= thai}', ""); +Expect(1, 3583, '\P{Is_Blk= thai}', ""); +Expect(0, 3583, '\P{^Is_Blk= thai}', ""); +Error('\p{Block: _KHMER/a/}'); +Error('\P{Block: _KHMER/a/}'); +Expect(1, 6143, '\p{Block=khmer}', ""); +Expect(0, 6143, '\p{^Block=khmer}', ""); +Expect(0, 6143, '\P{Block=khmer}', ""); +Expect(1, 6143, '\P{^Block=khmer}', ""); +Expect(0, 6015, '\p{Block=khmer}', ""); +Expect(1, 6015, '\p{^Block=khmer}', ""); +Expect(1, 6015, '\P{Block=khmer}', ""); +Expect(0, 6015, '\P{^Block=khmer}', ""); +Expect(1, 6143, '\p{Block= khmer}', ""); +Expect(0, 6143, '\p{^Block= khmer}', ""); +Expect(0, 6143, '\P{Block= khmer}', ""); +Expect(1, 6143, '\P{^Block= khmer}', ""); +Expect(0, 6015, '\p{Block= khmer}', ""); +Expect(1, 6015, '\p{^Block= khmer}', ""); +Expect(1, 6015, '\P{Block= khmer}', ""); +Expect(0, 6015, '\P{^Block= khmer}', ""); +Error('\p{Blk=-/a/Khmer}'); +Error('\P{Blk=-/a/Khmer}'); +Expect(1, 6143, '\p{Blk=khmer}', ""); +Expect(0, 6143, '\p{^Blk=khmer}', ""); +Expect(0, 6143, '\P{Blk=khmer}', ""); +Expect(1, 6143, '\P{^Blk=khmer}', ""); +Expect(0, 6015, '\p{Blk=khmer}', ""); +Expect(1, 6015, '\p{^Blk=khmer}', ""); +Expect(1, 6015, '\P{Blk=khmer}', ""); +Expect(0, 6015, '\P{^Blk=khmer}', ""); +Expect(1, 6143, '\p{Blk=_ Khmer}', ""); +Expect(0, 6143, '\p{^Blk=_ Khmer}', ""); +Expect(0, 6143, '\P{Blk=_ Khmer}', ""); +Expect(1, 6143, '\P{^Blk=_ Khmer}', ""); +Expect(0, 6015, '\p{Blk=_ Khmer}', ""); +Expect(1, 6015, '\p{^Blk=_ Khmer}', ""); +Expect(1, 6015, '\P{Blk=_ Khmer}', ""); +Expect(0, 6015, '\P{^Blk=_ Khmer}', ""); +Error('\p{Is_Block=:= Khmer}'); +Error('\P{Is_Block=:= Khmer}'); +Expect(1, 6143, '\p{Is_Block=khmer}', ""); +Expect(0, 6143, '\p{^Is_Block=khmer}', ""); +Expect(0, 6143, '\P{Is_Block=khmer}', ""); +Expect(1, 6143, '\P{^Is_Block=khmer}', ""); +Expect(0, 6015, '\p{Is_Block=khmer}', ""); +Expect(1, 6015, '\p{^Is_Block=khmer}', ""); +Expect(1, 6015, '\P{Is_Block=khmer}', ""); +Expect(0, 6015, '\P{^Is_Block=khmer}', ""); +Expect(1, 6143, '\p{Is_Block=__Khmer}', ""); +Expect(0, 6143, '\p{^Is_Block=__Khmer}', ""); +Expect(0, 6143, '\P{Is_Block=__Khmer}', ""); +Expect(1, 6143, '\P{^Is_Block=__Khmer}', ""); +Expect(0, 6015, '\p{Is_Block=__Khmer}', ""); +Expect(1, 6015, '\p{^Is_Block=__Khmer}', ""); +Expect(1, 6015, '\P{Is_Block=__Khmer}', ""); +Expect(0, 6015, '\P{^Is_Block=__Khmer}', ""); +Error('\p{Is_Blk=_-Khmer:=}'); +Error('\P{Is_Blk=_-Khmer:=}'); +Expect(1, 6143, '\p{Is_Blk=khmer}', ""); +Expect(0, 6143, '\p{^Is_Blk=khmer}', ""); +Expect(0, 6143, '\P{Is_Blk=khmer}', ""); +Expect(1, 6143, '\P{^Is_Blk=khmer}', ""); +Expect(0, 6015, '\p{Is_Blk=khmer}', ""); +Expect(1, 6015, '\p{^Is_Blk=khmer}', ""); +Expect(1, 6015, '\P{Is_Blk=khmer}', ""); +Expect(0, 6015, '\P{^Is_Blk=khmer}', ""); +Expect(1, 6143, '\p{Is_Blk=- KHMER}', ""); +Expect(0, 6143, '\p{^Is_Blk=- KHMER}', ""); +Expect(0, 6143, '\P{Is_Blk=- KHMER}', ""); +Expect(1, 6143, '\P{^Is_Blk=- KHMER}', ""); +Expect(0, 6015, '\p{Is_Blk=- KHMER}', ""); +Expect(1, 6015, '\p{^Is_Blk=- KHMER}', ""); +Expect(1, 6015, '\P{Is_Blk=- KHMER}', ""); +Expect(0, 6015, '\P{^Is_Blk=- KHMER}', ""); +Error('\p{Block=_Saurashtra:=}'); +Error('\P{Block=_Saurashtra:=}'); +Expect(1, 43231, '\p{Block=saurashtra}', ""); +Expect(0, 43231, '\p{^Block=saurashtra}', ""); +Expect(0, 43231, '\P{Block=saurashtra}', ""); +Expect(1, 43231, '\P{^Block=saurashtra}', ""); +Expect(0, 43135, '\p{Block=saurashtra}', ""); +Expect(1, 43135, '\p{^Block=saurashtra}', ""); +Expect(1, 43135, '\P{Block=saurashtra}', ""); +Expect(0, 43135, '\P{^Block=saurashtra}', ""); +Expect(1, 43231, '\p{Block=--Saurashtra}', ""); +Expect(0, 43231, '\p{^Block=--Saurashtra}', ""); +Expect(0, 43231, '\P{Block=--Saurashtra}', ""); +Expect(1, 43231, '\P{^Block=--Saurashtra}', ""); +Expect(0, 43135, '\p{Block=--Saurashtra}', ""); +Expect(1, 43135, '\p{^Block=--Saurashtra}', ""); +Expect(1, 43135, '\P{Block=--Saurashtra}', ""); +Expect(0, 43135, '\P{^Block=--Saurashtra}', ""); +Error('\p{Blk= _SAURASHTRA:=}'); +Error('\P{Blk= _SAURASHTRA:=}'); +Expect(1, 43231, '\p{Blk=saurashtra}', ""); +Expect(0, 43231, '\p{^Blk=saurashtra}', ""); +Expect(0, 43231, '\P{Blk=saurashtra}', ""); +Expect(1, 43231, '\P{^Blk=saurashtra}', ""); +Expect(0, 43135, '\p{Blk=saurashtra}', ""); +Expect(1, 43135, '\p{^Blk=saurashtra}', ""); +Expect(1, 43135, '\P{Blk=saurashtra}', ""); +Expect(0, 43135, '\P{^Blk=saurashtra}', ""); +Expect(1, 43231, '\p{Blk=-_Saurashtra}', ""); +Expect(0, 43231, '\p{^Blk=-_Saurashtra}', ""); +Expect(0, 43231, '\P{Blk=-_Saurashtra}', ""); +Expect(1, 43231, '\P{^Blk=-_Saurashtra}', ""); +Expect(0, 43135, '\p{Blk=-_Saurashtra}', ""); +Expect(1, 43135, '\p{^Blk=-_Saurashtra}', ""); +Expect(1, 43135, '\P{Blk=-_Saurashtra}', ""); +Expect(0, 43135, '\P{^Blk=-_Saurashtra}', ""); +Error('\p{Is_Block= :=SAURASHTRA}'); +Error('\P{Is_Block= :=SAURASHTRA}'); +Expect(1, 43231, '\p{Is_Block=saurashtra}', ""); +Expect(0, 43231, '\p{^Is_Block=saurashtra}', ""); +Expect(0, 43231, '\P{Is_Block=saurashtra}', ""); +Expect(1, 43231, '\P{^Is_Block=saurashtra}', ""); +Expect(0, 43135, '\p{Is_Block=saurashtra}', ""); +Expect(1, 43135, '\p{^Is_Block=saurashtra}', ""); +Expect(1, 43135, '\P{Is_Block=saurashtra}', ""); +Expect(0, 43135, '\P{^Is_Block=saurashtra}', ""); +Expect(1, 43231, '\p{Is_Block=_Saurashtra}', ""); +Expect(0, 43231, '\p{^Is_Block=_Saurashtra}', ""); +Expect(0, 43231, '\P{Is_Block=_Saurashtra}', ""); +Expect(1, 43231, '\P{^Is_Block=_Saurashtra}', ""); +Expect(0, 43135, '\p{Is_Block=_Saurashtra}', ""); +Expect(1, 43135, '\p{^Is_Block=_Saurashtra}', ""); +Expect(1, 43135, '\P{Is_Block=_Saurashtra}', ""); +Expect(0, 43135, '\P{^Is_Block=_Saurashtra}', ""); +Error('\p{Is_Blk= Saurashtra/a/}'); +Error('\P{Is_Blk= Saurashtra/a/}'); +Expect(1, 43231, '\p{Is_Blk=saurashtra}', ""); +Expect(0, 43231, '\p{^Is_Blk=saurashtra}', ""); +Expect(0, 43231, '\P{Is_Blk=saurashtra}', ""); +Expect(1, 43231, '\P{^Is_Blk=saurashtra}', ""); +Expect(0, 43135, '\p{Is_Blk=saurashtra}', ""); +Expect(1, 43135, '\p{^Is_Blk=saurashtra}', ""); +Expect(1, 43135, '\P{Is_Blk=saurashtra}', ""); +Expect(0, 43135, '\P{^Is_Blk=saurashtra}', ""); +Expect(1, 43231, '\p{Is_Blk=- saurashtra}', ""); +Expect(0, 43231, '\p{^Is_Blk=- saurashtra}', ""); +Expect(0, 43231, '\P{Is_Blk=- saurashtra}', ""); +Expect(1, 43231, '\P{^Is_Blk=- saurashtra}', ""); +Expect(0, 43135, '\p{Is_Blk=- saurashtra}', ""); +Expect(1, 43135, '\p{^Is_Blk=- saurashtra}', ""); +Expect(1, 43135, '\P{Is_Blk=- saurashtra}', ""); +Expect(0, 43135, '\P{^Is_Blk=- saurashtra}', ""); +Error('\p{Block=:=_Gujarati}'); +Error('\P{Block=:=_Gujarati}'); +Expect(1, 2815, '\p{Block=gujarati}', ""); +Expect(0, 2815, '\p{^Block=gujarati}', ""); +Expect(0, 2815, '\P{Block=gujarati}', ""); +Expect(1, 2815, '\P{^Block=gujarati}', ""); +Expect(0, 2687, '\p{Block=gujarati}', ""); +Expect(1, 2687, '\p{^Block=gujarati}', ""); +Expect(1, 2687, '\P{Block=gujarati}', ""); +Expect(0, 2687, '\P{^Block=gujarati}', ""); +Expect(1, 2815, '\p{Block=-Gujarati}', ""); +Expect(0, 2815, '\p{^Block=-Gujarati}', ""); +Expect(0, 2815, '\P{Block=-Gujarati}', ""); +Expect(1, 2815, '\P{^Block=-Gujarati}', ""); +Expect(0, 2687, '\p{Block=-Gujarati}', ""); +Expect(1, 2687, '\p{^Block=-Gujarati}', ""); +Expect(1, 2687, '\P{Block=-Gujarati}', ""); +Expect(0, 2687, '\P{^Block=-Gujarati}', ""); +Error('\p{Blk=:= _GUJARATI}'); +Error('\P{Blk=:= _GUJARATI}'); +Expect(1, 2815, '\p{Blk=gujarati}', ""); +Expect(0, 2815, '\p{^Blk=gujarati}', ""); +Expect(0, 2815, '\P{Blk=gujarati}', ""); +Expect(1, 2815, '\P{^Blk=gujarati}', ""); +Expect(0, 2687, '\p{Blk=gujarati}', ""); +Expect(1, 2687, '\p{^Blk=gujarati}', ""); +Expect(1, 2687, '\P{Blk=gujarati}', ""); +Expect(0, 2687, '\P{^Blk=gujarati}', ""); +Expect(1, 2815, '\p{Blk=_-gujarati}', ""); +Expect(0, 2815, '\p{^Blk=_-gujarati}', ""); +Expect(0, 2815, '\P{Blk=_-gujarati}', ""); +Expect(1, 2815, '\P{^Blk=_-gujarati}', ""); +Expect(0, 2687, '\p{Blk=_-gujarati}', ""); +Expect(1, 2687, '\p{^Blk=_-gujarati}', ""); +Expect(1, 2687, '\P{Blk=_-gujarati}', ""); +Expect(0, 2687, '\P{^Blk=_-gujarati}', ""); +Error('\p{Is_Block=:= gujarati}'); +Error('\P{Is_Block=:= gujarati}'); +Expect(1, 2815, '\p{Is_Block=gujarati}', ""); +Expect(0, 2815, '\p{^Is_Block=gujarati}', ""); +Expect(0, 2815, '\P{Is_Block=gujarati}', ""); +Expect(1, 2815, '\P{^Is_Block=gujarati}', ""); +Expect(0, 2687, '\p{Is_Block=gujarati}', ""); +Expect(1, 2687, '\p{^Is_Block=gujarati}', ""); +Expect(1, 2687, '\P{Is_Block=gujarati}', ""); +Expect(0, 2687, '\P{^Is_Block=gujarati}', ""); +Expect(1, 2815, '\p{Is_Block=-_Gujarati}', ""); +Expect(0, 2815, '\p{^Is_Block=-_Gujarati}', ""); +Expect(0, 2815, '\P{Is_Block=-_Gujarati}', ""); +Expect(1, 2815, '\P{^Is_Block=-_Gujarati}', ""); +Expect(0, 2687, '\p{Is_Block=-_Gujarati}', ""); +Expect(1, 2687, '\p{^Is_Block=-_Gujarati}', ""); +Expect(1, 2687, '\P{Is_Block=-_Gujarati}', ""); +Expect(0, 2687, '\P{^Is_Block=-_Gujarati}', ""); +Error('\p{Is_Blk=/a/ gujarati}'); +Error('\P{Is_Blk=/a/ gujarati}'); +Expect(1, 2815, '\p{Is_Blk=gujarati}', ""); +Expect(0, 2815, '\p{^Is_Blk=gujarati}', ""); +Expect(0, 2815, '\P{Is_Blk=gujarati}', ""); +Expect(1, 2815, '\P{^Is_Blk=gujarati}', ""); +Expect(0, 2687, '\p{Is_Blk=gujarati}', ""); +Expect(1, 2687, '\p{^Is_Blk=gujarati}', ""); +Expect(1, 2687, '\P{Is_Blk=gujarati}', ""); +Expect(0, 2687, '\P{^Is_Blk=gujarati}', ""); +Expect(1, 2815, '\p{Is_Blk= Gujarati}', ""); +Expect(0, 2815, '\p{^Is_Blk= Gujarati}', ""); +Expect(0, 2815, '\P{Is_Blk= Gujarati}', ""); +Expect(1, 2815, '\P{^Is_Blk= Gujarati}', ""); +Expect(0, 2687, '\p{Is_Blk= Gujarati}', ""); +Expect(1, 2687, '\p{^Is_Blk= Gujarati}', ""); +Expect(1, 2687, '\P{Is_Blk= Gujarati}', ""); +Expect(0, 2687, '\P{^Is_Blk= Gujarati}', ""); +Error('\p{Block= /a/TELUGU}'); +Error('\P{Block= /a/TELUGU}'); +Expect(1, 3199, '\p{Block=telugu}', ""); +Expect(0, 3199, '\p{^Block=telugu}', ""); +Expect(0, 3199, '\P{Block=telugu}', ""); +Expect(1, 3199, '\P{^Block=telugu}', ""); +Expect(0, 3071, '\p{Block=telugu}', ""); +Expect(1, 3071, '\p{^Block=telugu}', ""); +Expect(1, 3071, '\P{Block=telugu}', ""); +Expect(0, 3071, '\P{^Block=telugu}', ""); +Expect(1, 3199, '\p{Block= TELUGU}', ""); +Expect(0, 3199, '\p{^Block= TELUGU}', ""); +Expect(0, 3199, '\P{Block= TELUGU}', ""); +Expect(1, 3199, '\P{^Block= TELUGU}', ""); +Expect(0, 3071, '\p{Block= TELUGU}', ""); +Expect(1, 3071, '\p{^Block= TELUGU}', ""); +Expect(1, 3071, '\P{Block= TELUGU}', ""); +Expect(0, 3071, '\P{^Block= TELUGU}', ""); +Error('\p{Blk=_:=telugu}'); +Error('\P{Blk=_:=telugu}'); +Expect(1, 3199, '\p{Blk=telugu}', ""); +Expect(0, 3199, '\p{^Blk=telugu}', ""); +Expect(0, 3199, '\P{Blk=telugu}', ""); +Expect(1, 3199, '\P{^Blk=telugu}', ""); +Expect(0, 3071, '\p{Blk=telugu}', ""); +Expect(1, 3071, '\p{^Blk=telugu}', ""); +Expect(1, 3071, '\P{Blk=telugu}', ""); +Expect(0, 3071, '\P{^Blk=telugu}', ""); +Expect(1, 3199, '\p{Blk= -Telugu}', ""); +Expect(0, 3199, '\p{^Blk= -Telugu}', ""); +Expect(0, 3199, '\P{Blk= -Telugu}', ""); +Expect(1, 3199, '\P{^Blk= -Telugu}', ""); +Expect(0, 3071, '\p{Blk= -Telugu}', ""); +Expect(1, 3071, '\p{^Blk= -Telugu}', ""); +Expect(1, 3071, '\P{Blk= -Telugu}', ""); +Expect(0, 3071, '\P{^Blk= -Telugu}', ""); +Error('\p{Is_Block=_/a/TELUGU}'); +Error('\P{Is_Block=_/a/TELUGU}'); +Expect(1, 3199, '\p{Is_Block=telugu}', ""); +Expect(0, 3199, '\p{^Is_Block=telugu}', ""); +Expect(0, 3199, '\P{Is_Block=telugu}', ""); +Expect(1, 3199, '\P{^Is_Block=telugu}', ""); +Expect(0, 3071, '\p{Is_Block=telugu}', ""); +Expect(1, 3071, '\p{^Is_Block=telugu}', ""); +Expect(1, 3071, '\P{Is_Block=telugu}', ""); +Expect(0, 3071, '\P{^Is_Block=telugu}', ""); +Expect(1, 3199, '\p{Is_Block= TELUGU}', ""); +Expect(0, 3199, '\p{^Is_Block= TELUGU}', ""); +Expect(0, 3199, '\P{Is_Block= TELUGU}', ""); +Expect(1, 3199, '\P{^Is_Block= TELUGU}', ""); +Expect(0, 3071, '\p{Is_Block= TELUGU}', ""); +Expect(1, 3071, '\p{^Is_Block= TELUGU}', ""); +Expect(1, 3071, '\P{Is_Block= TELUGU}', ""); +Expect(0, 3071, '\P{^Is_Block= TELUGU}', ""); +Error('\p{Is_Blk:Telugu:=}'); +Error('\P{Is_Blk:Telugu:=}'); +Expect(1, 3199, '\p{Is_Blk=telugu}', ""); +Expect(0, 3199, '\p{^Is_Blk=telugu}', ""); +Expect(0, 3199, '\P{Is_Blk=telugu}', ""); +Expect(1, 3199, '\P{^Is_Blk=telugu}', ""); +Expect(0, 3071, '\p{Is_Blk=telugu}', ""); +Expect(1, 3071, '\p{^Is_Blk=telugu}', ""); +Expect(1, 3071, '\P{Is_Blk=telugu}', ""); +Expect(0, 3071, '\P{^Is_Blk=telugu}', ""); +Expect(1, 3199, '\p{Is_Blk=- telugu}', ""); +Expect(0, 3199, '\p{^Is_Blk=- telugu}', ""); +Expect(0, 3199, '\P{Is_Blk=- telugu}', ""); +Expect(1, 3199, '\P{^Is_Blk=- telugu}', ""); +Expect(0, 3071, '\p{Is_Blk=- telugu}', ""); +Expect(1, 3071, '\p{^Is_Blk=- telugu}', ""); +Expect(1, 3071, '\P{Is_Blk=- telugu}', ""); +Expect(0, 3071, '\P{^Is_Blk=- telugu}', ""); +Error('\p{Block: -Yi/a/radicals}'); +Error('\P{Block: -Yi/a/radicals}'); +Expect(1, 42191, '\p{Block=yiradicals}', ""); +Expect(0, 42191, '\p{^Block=yiradicals}', ""); +Expect(0, 42191, '\P{Block=yiradicals}', ""); +Expect(1, 42191, '\P{^Block=yiradicals}', ""); +Expect(0, 42127, '\p{Block=yiradicals}', ""); +Expect(1, 42127, '\p{^Block=yiradicals}', ""); +Expect(1, 42127, '\P{Block=yiradicals}', ""); +Expect(0, 42127, '\P{^Block=yiradicals}', ""); +Expect(1, 42191, '\p{Block= _YiRadicals}', ""); +Expect(0, 42191, '\p{^Block= _YiRadicals}', ""); +Expect(0, 42191, '\P{Block= _YiRadicals}', ""); +Expect(1, 42191, '\P{^Block= _YiRadicals}', ""); +Expect(0, 42127, '\p{Block= _YiRadicals}', ""); +Expect(1, 42127, '\p{^Block= _YiRadicals}', ""); +Expect(1, 42127, '\P{Block= _YiRadicals}', ""); +Expect(0, 42127, '\P{^Block= _YiRadicals}', ""); +Error('\p{Blk=__yi radicals/a/}'); +Error('\P{Blk=__yi radicals/a/}'); +Expect(1, 42191, '\p{Blk=yiradicals}', ""); +Expect(0, 42191, '\p{^Blk=yiradicals}', ""); +Expect(0, 42191, '\P{Blk=yiradicals}', ""); +Expect(1, 42191, '\P{^Blk=yiradicals}', ""); +Expect(0, 42127, '\p{Blk=yiradicals}', ""); +Expect(1, 42127, '\p{^Blk=yiradicals}', ""); +Expect(1, 42127, '\P{Blk=yiradicals}', ""); +Expect(0, 42127, '\P{^Blk=yiradicals}', ""); +Expect(1, 42191, '\p{Blk=_ Yi_RADICALS}', ""); +Expect(0, 42191, '\p{^Blk=_ Yi_RADICALS}', ""); +Expect(0, 42191, '\P{Blk=_ Yi_RADICALS}', ""); +Expect(1, 42191, '\P{^Blk=_ Yi_RADICALS}', ""); +Expect(0, 42127, '\p{Blk=_ Yi_RADICALS}', ""); +Expect(1, 42127, '\p{^Blk=_ Yi_RADICALS}', ""); +Expect(1, 42127, '\P{Blk=_ Yi_RADICALS}', ""); +Expect(0, 42127, '\P{^Blk=_ Yi_RADICALS}', ""); +Error('\p{Is_Block= Yi/a/RADICALS}'); +Error('\P{Is_Block= Yi/a/RADICALS}'); +Expect(1, 42191, '\p{Is_Block=yiradicals}', ""); +Expect(0, 42191, '\p{^Is_Block=yiradicals}', ""); +Expect(0, 42191, '\P{Is_Block=yiradicals}', ""); +Expect(1, 42191, '\P{^Is_Block=yiradicals}', ""); +Expect(0, 42127, '\p{Is_Block=yiradicals}', ""); +Expect(1, 42127, '\p{^Is_Block=yiradicals}', ""); +Expect(1, 42127, '\P{Is_Block=yiradicals}', ""); +Expect(0, 42127, '\P{^Is_Block=yiradicals}', ""); +Expect(1, 42191, '\p{Is_Block=_ YI RADICALS}', ""); +Expect(0, 42191, '\p{^Is_Block=_ YI RADICALS}', ""); +Expect(0, 42191, '\P{Is_Block=_ YI RADICALS}', ""); +Expect(1, 42191, '\P{^Is_Block=_ YI RADICALS}', ""); +Expect(0, 42127, '\p{Is_Block=_ YI RADICALS}', ""); +Expect(1, 42127, '\p{^Is_Block=_ YI RADICALS}', ""); +Expect(1, 42127, '\P{Is_Block=_ YI RADICALS}', ""); +Expect(0, 42127, '\P{^Is_Block=_ YI RADICALS}', ""); +Error('\p{Is_Blk=:= YI Radicals}'); +Error('\P{Is_Blk=:= YI Radicals}'); +Expect(1, 42191, '\p{Is_Blk=yiradicals}', ""); +Expect(0, 42191, '\p{^Is_Blk=yiradicals}', ""); +Expect(0, 42191, '\P{Is_Blk=yiradicals}', ""); +Expect(1, 42191, '\P{^Is_Blk=yiradicals}', ""); +Expect(0, 42127, '\p{Is_Blk=yiradicals}', ""); +Expect(1, 42127, '\p{^Is_Blk=yiradicals}', ""); +Expect(1, 42127, '\P{Is_Blk=yiradicals}', ""); +Expect(0, 42127, '\P{^Is_Blk=yiradicals}', ""); +Expect(1, 42191, '\p{Is_Blk: _ yiRadicals}', ""); +Expect(0, 42191, '\p{^Is_Blk: _ yiRadicals}', ""); +Expect(0, 42191, '\P{Is_Blk: _ yiRadicals}', ""); +Expect(1, 42191, '\P{^Is_Blk: _ yiRadicals}', ""); +Expect(0, 42127, '\p{Is_Blk: _ yiRadicals}', ""); +Expect(1, 42127, '\p{^Is_Blk: _ yiRadicals}', ""); +Expect(1, 42127, '\P{Is_Blk: _ yiRadicals}', ""); +Expect(0, 42127, '\P{^Is_Blk: _ yiRadicals}', ""); +Error('\p{East_Asian_Width: :=wide}'); +Error('\P{East_Asian_Width: :=wide}'); +Expect(1, 4441, '\p{East_Asian_Width=wide}', ""); +Expect(0, 4441, '\p{^East_Asian_Width=wide}', ""); +Expect(0, 4441, '\P{East_Asian_Width=wide}', ""); +Expect(1, 4441, '\P{^East_Asian_Width=wide}', ""); +Expect(0, 4351, '\p{East_Asian_Width=wide}', ""); +Expect(1, 4351, '\p{^East_Asian_Width=wide}', ""); +Expect(1, 4351, '\P{East_Asian_Width=wide}', ""); +Expect(0, 4351, '\P{^East_Asian_Width=wide}', ""); +Expect(1, 4441, '\p{East_Asian_Width=- wide}', ""); +Expect(0, 4441, '\p{^East_Asian_Width=- wide}', ""); +Expect(0, 4441, '\P{East_Asian_Width=- wide}', ""); +Expect(1, 4441, '\P{^East_Asian_Width=- wide}', ""); +Expect(0, 4351, '\p{East_Asian_Width=- wide}', ""); +Expect(1, 4351, '\p{^East_Asian_Width=- wide}', ""); +Expect(1, 4351, '\P{East_Asian_Width=- wide}', ""); +Expect(0, 4351, '\P{^East_Asian_Width=- wide}', ""); +Error('\p{Ea=_-W/a/}'); +Error('\P{Ea=_-W/a/}'); +Expect(1, 4441, '\p{Ea=w}', ""); +Expect(0, 4441, '\p{^Ea=w}', ""); +Expect(0, 4441, '\P{Ea=w}', ""); +Expect(1, 4441, '\P{^Ea=w}', ""); +Expect(0, 4351, '\p{Ea=w}', ""); +Expect(1, 4351, '\p{^Ea=w}', ""); +Expect(1, 4351, '\P{Ea=w}', ""); +Expect(0, 4351, '\P{^Ea=w}', ""); +Expect(1, 4441, '\p{Ea= -W}', ""); +Expect(0, 4441, '\p{^Ea= -W}', ""); +Expect(0, 4441, '\P{Ea= -W}', ""); +Expect(1, 4441, '\P{^Ea= -W}', ""); +Expect(0, 4351, '\p{Ea= -W}', ""); +Expect(1, 4351, '\p{^Ea= -W}', ""); +Expect(1, 4351, '\P{Ea= -W}', ""); +Expect(0, 4351, '\P{^Ea= -W}', ""); +Error('\p{Is_East_Asian_Width= wide/a/}'); +Error('\P{Is_East_Asian_Width= wide/a/}'); +Expect(1, 4441, '\p{Is_East_Asian_Width=wide}', ""); +Expect(0, 4441, '\p{^Is_East_Asian_Width=wide}', ""); +Expect(0, 4441, '\P{Is_East_Asian_Width=wide}', ""); +Expect(1, 4441, '\P{^Is_East_Asian_Width=wide}', ""); +Expect(0, 4351, '\p{Is_East_Asian_Width=wide}', ""); +Expect(1, 4351, '\p{^Is_East_Asian_Width=wide}', ""); +Expect(1, 4351, '\P{Is_East_Asian_Width=wide}', ""); +Expect(0, 4351, '\P{^Is_East_Asian_Width=wide}', ""); +Expect(1, 4441, '\p{Is_East_Asian_Width: -Wide}', ""); +Expect(0, 4441, '\p{^Is_East_Asian_Width: -Wide}', ""); +Expect(0, 4441, '\P{Is_East_Asian_Width: -Wide}', ""); +Expect(1, 4441, '\P{^Is_East_Asian_Width: -Wide}', ""); +Expect(0, 4351, '\p{Is_East_Asian_Width: -Wide}', ""); +Expect(1, 4351, '\p{^Is_East_Asian_Width: -Wide}', ""); +Expect(1, 4351, '\P{Is_East_Asian_Width: -Wide}', ""); +Expect(0, 4351, '\P{^Is_East_Asian_Width: -Wide}', ""); +Error('\p{Is_Ea:/a/ W}'); +Error('\P{Is_Ea:/a/ W}'); +Expect(1, 4441, '\p{Is_Ea: w}', ""); +Expect(0, 4441, '\p{^Is_Ea: w}', ""); +Expect(0, 4441, '\P{Is_Ea: w}', ""); +Expect(1, 4441, '\P{^Is_Ea: w}', ""); +Expect(0, 4351, '\p{Is_Ea: w}', ""); +Expect(1, 4351, '\p{^Is_Ea: w}', ""); +Expect(1, 4351, '\P{Is_Ea: w}', ""); +Expect(0, 4351, '\P{^Is_Ea: w}', ""); +Expect(1, 4441, '\p{Is_Ea= _W}', ""); +Expect(0, 4441, '\p{^Is_Ea= _W}', ""); +Expect(0, 4441, '\P{Is_Ea= _W}', ""); +Expect(1, 4441, '\P{^Is_Ea= _W}', ""); +Expect(0, 4351, '\p{Is_Ea= _W}', ""); +Expect(1, 4351, '\p{^Is_Ea= _W}', ""); +Expect(1, 4351, '\P{Is_Ea= _W}', ""); +Expect(0, 4351, '\P{^Is_Ea= _W}', ""); +Error('\p{East_Asian_Width=-/a/Fullwidth}'); +Error('\P{East_Asian_Width=-/a/Fullwidth}'); +Expect(1, 12288, '\p{East_Asian_Width=fullwidth}', ""); +Expect(0, 12288, '\p{^East_Asian_Width=fullwidth}', ""); +Expect(0, 12288, '\P{East_Asian_Width=fullwidth}', ""); +Expect(1, 12288, '\P{^East_Asian_Width=fullwidth}', ""); +Expect(0, 12287, '\p{East_Asian_Width=fullwidth}', ""); +Expect(1, 12287, '\p{^East_Asian_Width=fullwidth}', ""); +Expect(1, 12287, '\P{East_Asian_Width=fullwidth}', ""); +Expect(0, 12287, '\P{^East_Asian_Width=fullwidth}', ""); +Expect(1, 12288, '\p{East_Asian_Width=Fullwidth}', ""); +Expect(0, 12288, '\p{^East_Asian_Width=Fullwidth}', ""); +Expect(0, 12288, '\P{East_Asian_Width=Fullwidth}', ""); +Expect(1, 12288, '\P{^East_Asian_Width=Fullwidth}', ""); +Expect(0, 12287, '\p{East_Asian_Width=Fullwidth}', ""); +Expect(1, 12287, '\p{^East_Asian_Width=Fullwidth}', ""); +Expect(1, 12287, '\P{East_Asian_Width=Fullwidth}', ""); +Expect(0, 12287, '\P{^East_Asian_Width=Fullwidth}', ""); +Error('\p{Ea: /a/-_F}'); +Error('\P{Ea: /a/-_F}'); +Expect(1, 12288, '\p{Ea=f}', ""); +Expect(0, 12288, '\p{^Ea=f}', ""); +Expect(0, 12288, '\P{Ea=f}', ""); +Expect(1, 12288, '\P{^Ea=f}', ""); +Expect(0, 12287, '\p{Ea=f}', ""); +Expect(1, 12287, '\p{^Ea=f}', ""); +Expect(1, 12287, '\P{Ea=f}', ""); +Expect(0, 12287, '\P{^Ea=f}', ""); +Expect(1, 12288, '\p{Ea= F}', ""); +Expect(0, 12288, '\p{^Ea= F}', ""); +Expect(0, 12288, '\P{Ea= F}', ""); +Expect(1, 12288, '\P{^Ea= F}', ""); +Expect(0, 12287, '\p{Ea= F}', ""); +Expect(1, 12287, '\p{^Ea= F}', ""); +Expect(1, 12287, '\P{Ea= F}', ""); +Expect(0, 12287, '\P{^Ea= F}', ""); +Error('\p{Is_East_Asian_Width: :=_Fullwidth}'); +Error('\P{Is_East_Asian_Width: :=_Fullwidth}'); +Expect(1, 12288, '\p{Is_East_Asian_Width=fullwidth}', ""); +Expect(0, 12288, '\p{^Is_East_Asian_Width=fullwidth}', ""); +Expect(0, 12288, '\P{Is_East_Asian_Width=fullwidth}', ""); +Expect(1, 12288, '\P{^Is_East_Asian_Width=fullwidth}', ""); +Expect(0, 12287, '\p{Is_East_Asian_Width=fullwidth}', ""); +Expect(1, 12287, '\p{^Is_East_Asian_Width=fullwidth}', ""); +Expect(1, 12287, '\P{Is_East_Asian_Width=fullwidth}', ""); +Expect(0, 12287, '\P{^Is_East_Asian_Width=fullwidth}', ""); +Expect(1, 12288, '\p{Is_East_Asian_Width= Fullwidth}', ""); +Expect(0, 12288, '\p{^Is_East_Asian_Width= Fullwidth}', ""); +Expect(0, 12288, '\P{Is_East_Asian_Width= Fullwidth}', ""); +Expect(1, 12288, '\P{^Is_East_Asian_Width= Fullwidth}', ""); +Expect(0, 12287, '\p{Is_East_Asian_Width= Fullwidth}', ""); +Expect(1, 12287, '\p{^Is_East_Asian_Width= Fullwidth}', ""); +Expect(1, 12287, '\P{Is_East_Asian_Width= Fullwidth}', ""); +Expect(0, 12287, '\P{^Is_East_Asian_Width= Fullwidth}', ""); +Error('\p{Is_Ea=:= f}'); +Error('\P{Is_Ea=:= f}'); +Expect(1, 12288, '\p{Is_Ea=f}', ""); +Expect(0, 12288, '\p{^Is_Ea=f}', ""); +Expect(0, 12288, '\P{Is_Ea=f}', ""); +Expect(1, 12288, '\P{^Is_Ea=f}', ""); +Expect(0, 12287, '\p{Is_Ea=f}', ""); +Expect(1, 12287, '\p{^Is_Ea=f}', ""); +Expect(1, 12287, '\P{Is_Ea=f}', ""); +Expect(0, 12287, '\P{^Is_Ea=f}', ""); +Expect(1, 12288, '\p{Is_Ea=_ F}', ""); +Expect(0, 12288, '\p{^Is_Ea=_ F}', ""); +Expect(0, 12288, '\P{Is_Ea=_ F}', ""); +Expect(1, 12288, '\P{^Is_Ea=_ F}', ""); +Expect(0, 12287, '\p{Is_Ea=_ F}', ""); +Expect(1, 12287, '\p{^Is_Ea=_ F}', ""); +Expect(1, 12287, '\P{Is_Ea=_ F}', ""); +Expect(0, 12287, '\P{^Is_Ea=_ F}', ""); +Error('\p{East_Asian_Width= /a/Ambiguous}'); +Error('\P{East_Asian_Width= /a/Ambiguous}'); +Expect(1, 257, '\p{East_Asian_Width=ambiguous}', ""); +Expect(0, 257, '\p{^East_Asian_Width=ambiguous}', ""); +Expect(0, 257, '\P{East_Asian_Width=ambiguous}', ""); +Expect(1, 257, '\P{^East_Asian_Width=ambiguous}', ""); +Expect(0, 7, '\p{East_Asian_Width=ambiguous}', ""); +Expect(1, 7, '\p{^East_Asian_Width=ambiguous}', ""); +Expect(1, 7, '\P{East_Asian_Width=ambiguous}', ""); +Expect(0, 7, '\P{^East_Asian_Width=ambiguous}', ""); +Expect(1, 257, '\p{East_Asian_Width=-_Ambiguous}', ""); +Expect(0, 257, '\p{^East_Asian_Width=-_Ambiguous}', ""); +Expect(0, 257, '\P{East_Asian_Width=-_Ambiguous}', ""); +Expect(1, 257, '\P{^East_Asian_Width=-_Ambiguous}', ""); +Expect(0, 7, '\p{East_Asian_Width=-_Ambiguous}', ""); +Expect(1, 7, '\p{^East_Asian_Width=-_Ambiguous}', ""); +Expect(1, 7, '\P{East_Asian_Width=-_Ambiguous}', ""); +Expect(0, 7, '\P{^East_Asian_Width=-_Ambiguous}', ""); +Error('\p{Ea= :=a}'); +Error('\P{Ea= :=a}'); +Expect(1, 257, '\p{Ea=a}', ""); +Expect(0, 257, '\p{^Ea=a}', ""); +Expect(0, 257, '\P{Ea=a}', ""); +Expect(1, 257, '\P{^Ea=a}', ""); +Expect(0, 7, '\p{Ea=a}', ""); +Expect(1, 7, '\p{^Ea=a}', ""); +Expect(1, 7, '\P{Ea=a}', ""); +Expect(0, 7, '\P{^Ea=a}', ""); +Expect(1, 257, '\p{Ea=-_A}', ""); +Expect(0, 257, '\p{^Ea=-_A}', ""); +Expect(0, 257, '\P{Ea=-_A}', ""); +Expect(1, 257, '\P{^Ea=-_A}', ""); +Expect(0, 7, '\p{Ea=-_A}', ""); +Expect(1, 7, '\p{^Ea=-_A}', ""); +Expect(1, 7, '\P{Ea=-_A}', ""); +Expect(0, 7, '\P{^Ea=-_A}', ""); +Error('\p{Is_East_Asian_Width=-:=ambiguous}'); +Error('\P{Is_East_Asian_Width=-:=ambiguous}'); +Expect(1, 257, '\p{Is_East_Asian_Width=ambiguous}', ""); +Expect(0, 257, '\p{^Is_East_Asian_Width=ambiguous}', ""); +Expect(0, 257, '\P{Is_East_Asian_Width=ambiguous}', ""); +Expect(1, 257, '\P{^Is_East_Asian_Width=ambiguous}', ""); +Expect(0, 7, '\p{Is_East_Asian_Width=ambiguous}', ""); +Expect(1, 7, '\p{^Is_East_Asian_Width=ambiguous}', ""); +Expect(1, 7, '\P{Is_East_Asian_Width=ambiguous}', ""); +Expect(0, 7, '\P{^Is_East_Asian_Width=ambiguous}', ""); +Expect(1, 257, '\p{Is_East_Asian_Width= Ambiguous}', ""); +Expect(0, 257, '\p{^Is_East_Asian_Width= Ambiguous}', ""); +Expect(0, 257, '\P{Is_East_Asian_Width= Ambiguous}', ""); +Expect(1, 257, '\P{^Is_East_Asian_Width= Ambiguous}', ""); +Expect(0, 7, '\p{Is_East_Asian_Width= Ambiguous}', ""); +Expect(1, 7, '\p{^Is_East_Asian_Width= Ambiguous}', ""); +Expect(1, 7, '\P{Is_East_Asian_Width= Ambiguous}', ""); +Expect(0, 7, '\P{^Is_East_Asian_Width= Ambiguous}', ""); +Error('\p{Is_Ea=-a:=}'); +Error('\P{Is_Ea=-a:=}'); +Expect(1, 257, '\p{Is_Ea=a}', ""); +Expect(0, 257, '\p{^Is_Ea=a}', ""); +Expect(0, 257, '\P{Is_Ea=a}', ""); +Expect(1, 257, '\P{^Is_Ea=a}', ""); +Expect(0, 7, '\p{Is_Ea=a}', ""); +Expect(1, 7, '\p{^Is_Ea=a}', ""); +Expect(1, 7, '\P{Is_Ea=a}', ""); +Expect(0, 7, '\P{^Is_Ea=a}', ""); +Expect(1, 257, '\p{Is_Ea= A}', ""); +Expect(0, 257, '\p{^Is_Ea= A}', ""); +Expect(0, 257, '\P{Is_Ea= A}', ""); +Expect(1, 257, '\P{^Is_Ea= A}', ""); +Expect(0, 7, '\p{Is_Ea= A}', ""); +Expect(1, 7, '\p{^Is_Ea= A}', ""); +Expect(1, 7, '\P{Is_Ea= A}', ""); +Expect(0, 7, '\P{^Is_Ea= A}', ""); +Error('\p{East_Asian_Width::= narrow}'); +Error('\P{East_Asian_Width::= narrow}'); +Expect(1, 126, '\p{East_Asian_Width=narrow}', ""); +Expect(0, 126, '\p{^East_Asian_Width=narrow}', ""); +Expect(0, 126, '\P{East_Asian_Width=narrow}', ""); +Expect(1, 126, '\P{^East_Asian_Width=narrow}', ""); +Expect(0, 7, '\p{East_Asian_Width=narrow}', ""); +Expect(1, 7, '\p{^East_Asian_Width=narrow}', ""); +Expect(1, 7, '\P{East_Asian_Width=narrow}', ""); +Expect(0, 7, '\P{^East_Asian_Width=narrow}', ""); +Expect(1, 126, '\p{East_Asian_Width=-narrow}', ""); +Expect(0, 126, '\p{^East_Asian_Width=-narrow}', ""); +Expect(0, 126, '\P{East_Asian_Width=-narrow}', ""); +Expect(1, 126, '\P{^East_Asian_Width=-narrow}', ""); +Expect(0, 7, '\p{East_Asian_Width=-narrow}', ""); +Expect(1, 7, '\p{^East_Asian_Width=-narrow}', ""); +Expect(1, 7, '\P{East_Asian_Width=-narrow}', ""); +Expect(0, 7, '\P{^East_Asian_Width=-narrow}', ""); +Error('\p{Ea=:=_Na}'); +Error('\P{Ea=:=_Na}'); +Expect(1, 126, '\p{Ea=na}', ""); +Expect(0, 126, '\p{^Ea=na}', ""); +Expect(0, 126, '\P{Ea=na}', ""); +Expect(1, 126, '\P{^Ea=na}', ""); +Expect(0, 7, '\p{Ea=na}', ""); +Expect(1, 7, '\p{^Ea=na}', ""); +Expect(1, 7, '\P{Ea=na}', ""); +Expect(0, 7, '\P{^Ea=na}', ""); +Expect(1, 126, '\p{Ea=_-Na}', ""); +Expect(0, 126, '\p{^Ea=_-Na}', ""); +Expect(0, 126, '\P{Ea=_-Na}', ""); +Expect(1, 126, '\P{^Ea=_-Na}', ""); +Expect(0, 7, '\p{Ea=_-Na}', ""); +Expect(1, 7, '\p{^Ea=_-Na}', ""); +Expect(1, 7, '\P{Ea=_-Na}', ""); +Expect(0, 7, '\P{^Ea=_-Na}', ""); +Error('\p{Is_East_Asian_Width=_:=NARROW}'); +Error('\P{Is_East_Asian_Width=_:=NARROW}'); +Expect(1, 126, '\p{Is_East_Asian_Width=narrow}', ""); +Expect(0, 126, '\p{^Is_East_Asian_Width=narrow}', ""); +Expect(0, 126, '\P{Is_East_Asian_Width=narrow}', ""); +Expect(1, 126, '\P{^Is_East_Asian_Width=narrow}', ""); +Expect(0, 7, '\p{Is_East_Asian_Width=narrow}', ""); +Expect(1, 7, '\p{^Is_East_Asian_Width=narrow}', ""); +Expect(1, 7, '\P{Is_East_Asian_Width=narrow}', ""); +Expect(0, 7, '\P{^Is_East_Asian_Width=narrow}', ""); +Expect(1, 126, '\p{Is_East_Asian_Width: - NARROW}', ""); +Expect(0, 126, '\p{^Is_East_Asian_Width: - NARROW}', ""); +Expect(0, 126, '\P{Is_East_Asian_Width: - NARROW}', ""); +Expect(1, 126, '\P{^Is_East_Asian_Width: - NARROW}', ""); +Expect(0, 7, '\p{Is_East_Asian_Width: - NARROW}', ""); +Expect(1, 7, '\p{^Is_East_Asian_Width: - NARROW}', ""); +Expect(1, 7, '\P{Is_East_Asian_Width: - NARROW}', ""); +Expect(0, 7, '\P{^Is_East_Asian_Width: - NARROW}', ""); +Error('\p{Is_Ea= /a/na}'); +Error('\P{Is_Ea= /a/na}'); +Expect(1, 126, '\p{Is_Ea=na}', ""); +Expect(0, 126, '\p{^Is_Ea=na}', ""); +Expect(0, 126, '\P{Is_Ea=na}', ""); +Expect(1, 126, '\P{^Is_Ea=na}', ""); +Expect(0, 7, '\p{Is_Ea=na}', ""); +Expect(1, 7, '\p{^Is_Ea=na}', ""); +Expect(1, 7, '\P{Is_Ea=na}', ""); +Expect(0, 7, '\P{^Is_Ea=na}', ""); +Expect(1, 126, '\p{Is_Ea=_ Na}', ""); +Expect(0, 126, '\p{^Is_Ea=_ Na}', ""); +Expect(0, 126, '\P{Is_Ea=_ Na}', ""); +Expect(1, 126, '\P{^Is_Ea=_ Na}', ""); +Expect(0, 7, '\p{Is_Ea=_ Na}', ""); +Expect(1, 7, '\p{^Is_Ea=_ Na}', ""); +Expect(1, 7, '\P{Is_Ea=_ Na}', ""); +Expect(0, 7, '\P{^Is_Ea=_ Na}', ""); +Error('\p{East_Asian_Width= Neutral/a/}'); +Error('\P{East_Asian_Width= Neutral/a/}'); +Expect(1, 7, '\p{East_Asian_Width=neutral}', ""); +Expect(0, 7, '\p{^East_Asian_Width=neutral}', ""); +Expect(0, 7, '\P{East_Asian_Width=neutral}', ""); +Expect(1, 7, '\P{^East_Asian_Width=neutral}', ""); +Expect(0, 126, '\p{East_Asian_Width=neutral}', ""); +Expect(1, 126, '\p{^East_Asian_Width=neutral}', ""); +Expect(1, 126, '\P{East_Asian_Width=neutral}', ""); +Expect(0, 126, '\P{^East_Asian_Width=neutral}', ""); +Expect(1, 7, '\p{East_Asian_Width=_ NEUTRAL}', ""); +Expect(0, 7, '\p{^East_Asian_Width=_ NEUTRAL}', ""); +Expect(0, 7, '\P{East_Asian_Width=_ NEUTRAL}', ""); +Expect(1, 7, '\P{^East_Asian_Width=_ NEUTRAL}', ""); +Expect(0, 126, '\p{East_Asian_Width=_ NEUTRAL}', ""); +Expect(1, 126, '\p{^East_Asian_Width=_ NEUTRAL}', ""); +Expect(1, 126, '\P{East_Asian_Width=_ NEUTRAL}', ""); +Expect(0, 126, '\P{^East_Asian_Width=_ NEUTRAL}', ""); +Error('\p{Ea=/a/-N}'); +Error('\P{Ea=/a/-N}'); +Expect(1, 7, '\p{Ea=n}', ""); +Expect(0, 7, '\p{^Ea=n}', ""); +Expect(0, 7, '\P{Ea=n}', ""); +Expect(1, 7, '\P{^Ea=n}', ""); +Expect(0, 126, '\p{Ea=n}', ""); +Expect(1, 126, '\p{^Ea=n}', ""); +Expect(1, 126, '\P{Ea=n}', ""); +Expect(0, 126, '\P{^Ea=n}', ""); +Expect(1, 7, '\p{Ea= N}', ""); +Expect(0, 7, '\p{^Ea= N}', ""); +Expect(0, 7, '\P{Ea= N}', ""); +Expect(1, 7, '\P{^Ea= N}', ""); +Expect(0, 126, '\p{Ea= N}', ""); +Expect(1, 126, '\p{^Ea= N}', ""); +Expect(1, 126, '\P{Ea= N}', ""); +Expect(0, 126, '\P{^Ea= N}', ""); +Error('\p{Is_East_Asian_Width: := _neutral}'); +Error('\P{Is_East_Asian_Width: := _neutral}'); +Expect(1, 7, '\p{Is_East_Asian_Width=neutral}', ""); +Expect(0, 7, '\p{^Is_East_Asian_Width=neutral}', ""); +Expect(0, 7, '\P{Is_East_Asian_Width=neutral}', ""); +Expect(1, 7, '\P{^Is_East_Asian_Width=neutral}', ""); +Expect(0, 126, '\p{Is_East_Asian_Width=neutral}', ""); +Expect(1, 126, '\p{^Is_East_Asian_Width=neutral}', ""); +Expect(1, 126, '\P{Is_East_Asian_Width=neutral}', ""); +Expect(0, 126, '\P{^Is_East_Asian_Width=neutral}', ""); +Expect(1, 7, '\p{Is_East_Asian_Width= Neutral}', ""); +Expect(0, 7, '\p{^Is_East_Asian_Width= Neutral}', ""); +Expect(0, 7, '\P{Is_East_Asian_Width= Neutral}', ""); +Expect(1, 7, '\P{^Is_East_Asian_Width= Neutral}', ""); +Expect(0, 126, '\p{Is_East_Asian_Width= Neutral}', ""); +Expect(1, 126, '\p{^Is_East_Asian_Width= Neutral}', ""); +Expect(1, 126, '\P{Is_East_Asian_Width= Neutral}', ""); +Expect(0, 126, '\P{^Is_East_Asian_Width= Neutral}', ""); +Error('\p{Is_Ea= /a/n}'); +Error('\P{Is_Ea= /a/n}'); +Expect(1, 7, '\p{Is_Ea=n}', ""); +Expect(0, 7, '\p{^Is_Ea=n}', ""); +Expect(0, 7, '\P{Is_Ea=n}', ""); +Expect(1, 7, '\P{^Is_Ea=n}', ""); +Expect(0, 126, '\p{Is_Ea=n}', ""); +Expect(1, 126, '\p{^Is_Ea=n}', ""); +Expect(1, 126, '\P{Is_Ea=n}', ""); +Expect(0, 126, '\P{^Is_Ea=n}', ""); +Expect(1, 7, '\p{Is_Ea= n}', ""); +Expect(0, 7, '\p{^Is_Ea= n}', ""); +Expect(0, 7, '\P{Is_Ea= n}', ""); +Expect(1, 7, '\P{^Is_Ea= n}', ""); +Expect(0, 126, '\p{Is_Ea= n}', ""); +Expect(1, 126, '\p{^Is_Ea= n}', ""); +Expect(1, 126, '\P{Is_Ea= n}', ""); +Expect(0, 126, '\P{^Is_Ea= n}', ""); +Error('\p{East_Asian_Width= _halfwidth/a/}'); +Error('\P{East_Asian_Width= _halfwidth/a/}'); +Expect(1, 8361, '\p{East_Asian_Width=halfwidth}', ""); +Expect(0, 8361, '\p{^East_Asian_Width=halfwidth}', ""); +Expect(0, 8361, '\P{East_Asian_Width=halfwidth}', ""); +Expect(1, 8361, '\P{^East_Asian_Width=halfwidth}', ""); +Expect(0, 8360, '\p{East_Asian_Width=halfwidth}', ""); +Expect(1, 8360, '\p{^East_Asian_Width=halfwidth}', ""); +Expect(1, 8360, '\P{East_Asian_Width=halfwidth}', ""); +Expect(0, 8360, '\P{^East_Asian_Width=halfwidth}', ""); +Expect(1, 8361, '\p{East_Asian_Width= _halfwidth}', ""); +Expect(0, 8361, '\p{^East_Asian_Width= _halfwidth}', ""); +Expect(0, 8361, '\P{East_Asian_Width= _halfwidth}', ""); +Expect(1, 8361, '\P{^East_Asian_Width= _halfwidth}', ""); +Expect(0, 8360, '\p{East_Asian_Width= _halfwidth}', ""); +Expect(1, 8360, '\p{^East_Asian_Width= _halfwidth}', ""); +Expect(1, 8360, '\P{East_Asian_Width= _halfwidth}', ""); +Expect(0, 8360, '\P{^East_Asian_Width= _halfwidth}', ""); +Error('\p{Ea: _h/a/}'); +Error('\P{Ea: _h/a/}'); +Expect(1, 8361, '\p{Ea=h}', ""); +Expect(0, 8361, '\p{^Ea=h}', ""); +Expect(0, 8361, '\P{Ea=h}', ""); +Expect(1, 8361, '\P{^Ea=h}', ""); +Expect(0, 8360, '\p{Ea=h}', ""); +Expect(1, 8360, '\p{^Ea=h}', ""); +Expect(1, 8360, '\P{Ea=h}', ""); +Expect(0, 8360, '\P{^Ea=h}', ""); +Expect(1, 8361, '\p{Ea=__H}', ""); +Expect(0, 8361, '\p{^Ea=__H}', ""); +Expect(0, 8361, '\P{Ea=__H}', ""); +Expect(1, 8361, '\P{^Ea=__H}', ""); +Expect(0, 8360, '\p{Ea=__H}', ""); +Expect(1, 8360, '\p{^Ea=__H}', ""); +Expect(1, 8360, '\P{Ea=__H}', ""); +Expect(0, 8360, '\P{^Ea=__H}', ""); +Error('\p{Is_East_Asian_Width=/a/halfwidth}'); +Error('\P{Is_East_Asian_Width=/a/halfwidth}'); +Expect(1, 8361, '\p{Is_East_Asian_Width=halfwidth}', ""); +Expect(0, 8361, '\p{^Is_East_Asian_Width=halfwidth}', ""); +Expect(0, 8361, '\P{Is_East_Asian_Width=halfwidth}', ""); +Expect(1, 8361, '\P{^Is_East_Asian_Width=halfwidth}', ""); +Expect(0, 8360, '\p{Is_East_Asian_Width=halfwidth}', ""); +Expect(1, 8360, '\p{^Is_East_Asian_Width=halfwidth}', ""); +Expect(1, 8360, '\P{Is_East_Asian_Width=halfwidth}', ""); +Expect(0, 8360, '\P{^Is_East_Asian_Width=halfwidth}', ""); +Expect(1, 8361, '\p{Is_East_Asian_Width=_ HALFWIDTH}', ""); +Expect(0, 8361, '\p{^Is_East_Asian_Width=_ HALFWIDTH}', ""); +Expect(0, 8361, '\P{Is_East_Asian_Width=_ HALFWIDTH}', ""); +Expect(1, 8361, '\P{^Is_East_Asian_Width=_ HALFWIDTH}', ""); +Expect(0, 8360, '\p{Is_East_Asian_Width=_ HALFWIDTH}', ""); +Expect(1, 8360, '\p{^Is_East_Asian_Width=_ HALFWIDTH}', ""); +Expect(1, 8360, '\P{Is_East_Asian_Width=_ HALFWIDTH}', ""); +Expect(0, 8360, '\P{^Is_East_Asian_Width=_ HALFWIDTH}', ""); +Error('\p{Is_Ea=:= _H}'); +Error('\P{Is_Ea=:= _H}'); +Expect(1, 8361, '\p{Is_Ea=h}', ""); +Expect(0, 8361, '\p{^Is_Ea=h}', ""); +Expect(0, 8361, '\P{Is_Ea=h}', ""); +Expect(1, 8361, '\P{^Is_Ea=h}', ""); +Expect(0, 8360, '\p{Is_Ea=h}', ""); +Expect(1, 8360, '\p{^Is_Ea=h}', ""); +Expect(1, 8360, '\P{Is_Ea=h}', ""); +Expect(0, 8360, '\P{^Is_Ea=h}', ""); +Expect(1, 8361, '\p{Is_Ea=--H}', ""); +Expect(0, 8361, '\p{^Is_Ea=--H}', ""); +Expect(0, 8361, '\P{Is_Ea=--H}', ""); +Expect(1, 8361, '\P{^Is_Ea=--H}', ""); +Expect(0, 8360, '\p{Is_Ea=--H}', ""); +Expect(1, 8360, '\p{^Is_Ea=--H}', ""); +Expect(1, 8360, '\P{Is_Ea=--H}', ""); +Expect(0, 8360, '\P{^Is_Ea=--H}', ""); +Error('\p{ASCII_Hex_Digit: := YES}'); +Error('\P{ASCII_Hex_Digit: := YES}'); +Expect(1, 57, '\p{ASCII_Hex_Digit=yes}', ""); +Expect(0, 57, '\p{^ASCII_Hex_Digit=yes}', ""); +Expect(0, 57, '\P{ASCII_Hex_Digit=yes}', ""); +Expect(1, 57, '\P{^ASCII_Hex_Digit=yes}', ""); +Expect(0, 47, '\p{ASCII_Hex_Digit=yes}', ""); +Expect(1, 47, '\p{^ASCII_Hex_Digit=yes}', ""); +Expect(1, 47, '\P{ASCII_Hex_Digit=yes}', ""); +Expect(0, 47, '\P{^ASCII_Hex_Digit=yes}', ""); +Expect(1, 57, '\p{ASCII_Hex_Digit=_-YES}', ""); +Expect(0, 57, '\p{^ASCII_Hex_Digit=_-YES}', ""); +Expect(0, 57, '\P{ASCII_Hex_Digit=_-YES}', ""); +Expect(1, 57, '\P{^ASCII_Hex_Digit=_-YES}', ""); +Expect(0, 47, '\p{ASCII_Hex_Digit=_-YES}', ""); +Expect(1, 47, '\p{^ASCII_Hex_Digit=_-YES}', ""); +Expect(1, 47, '\P{ASCII_Hex_Digit=_-YES}', ""); +Expect(0, 47, '\P{^ASCII_Hex_Digit=_-YES}', ""); +Error('\p{AHex: _Y:=}'); +Error('\P{AHex: _Y:=}'); +Expect(1, 57, '\p{AHex=y}', ""); +Expect(0, 57, '\p{^AHex=y}', ""); +Expect(0, 57, '\P{AHex=y}', ""); +Expect(1, 57, '\P{^AHex=y}', ""); +Expect(0, 47, '\p{AHex=y}', ""); +Expect(1, 47, '\p{^AHex=y}', ""); +Expect(1, 47, '\P{AHex=y}', ""); +Expect(0, 47, '\P{^AHex=y}', ""); +Expect(1, 57, '\p{AHex= Y}', ""); +Expect(0, 57, '\p{^AHex= Y}', ""); +Expect(0, 57, '\P{AHex= Y}', ""); +Expect(1, 57, '\P{^AHex= Y}', ""); +Expect(0, 47, '\p{AHex= Y}', ""); +Expect(1, 47, '\p{^AHex= Y}', ""); +Expect(1, 47, '\P{AHex= Y}', ""); +Expect(0, 47, '\P{^AHex= Y}', ""); +Error('\p{Is_ASCII_Hex_Digit::=_ t}'); +Error('\P{Is_ASCII_Hex_Digit::=_ t}'); +Expect(1, 57, '\p{Is_ASCII_Hex_Digit=t}', ""); +Expect(0, 57, '\p{^Is_ASCII_Hex_Digit=t}', ""); +Expect(0, 57, '\P{Is_ASCII_Hex_Digit=t}', ""); +Expect(1, 57, '\P{^Is_ASCII_Hex_Digit=t}', ""); +Expect(0, 47, '\p{Is_ASCII_Hex_Digit=t}', ""); +Expect(1, 47, '\p{^Is_ASCII_Hex_Digit=t}', ""); +Expect(1, 47, '\P{Is_ASCII_Hex_Digit=t}', ""); +Expect(0, 47, '\P{^Is_ASCII_Hex_Digit=t}', ""); +Expect(1, 57, '\p{Is_ASCII_Hex_Digit= -T}', ""); +Expect(0, 57, '\p{^Is_ASCII_Hex_Digit= -T}', ""); +Expect(0, 57, '\P{Is_ASCII_Hex_Digit= -T}', ""); +Expect(1, 57, '\P{^Is_ASCII_Hex_Digit= -T}', ""); +Expect(0, 47, '\p{Is_ASCII_Hex_Digit= -T}', ""); +Expect(1, 47, '\p{^Is_ASCII_Hex_Digit= -T}', ""); +Expect(1, 47, '\P{Is_ASCII_Hex_Digit= -T}', ""); +Expect(0, 47, '\P{^Is_ASCII_Hex_Digit= -T}', ""); +Error('\p{Is_AHex=/a/ True}'); +Error('\P{Is_AHex=/a/ True}'); +Expect(1, 57, '\p{Is_AHex=true}', ""); +Expect(0, 57, '\p{^Is_AHex=true}', ""); +Expect(0, 57, '\P{Is_AHex=true}', ""); +Expect(1, 57, '\P{^Is_AHex=true}', ""); +Expect(0, 47, '\p{Is_AHex=true}', ""); +Expect(1, 47, '\p{^Is_AHex=true}', ""); +Expect(1, 47, '\P{Is_AHex=true}', ""); +Expect(0, 47, '\P{^Is_AHex=true}', ""); +Expect(1, 57, '\p{Is_AHex= True}', ""); +Expect(0, 57, '\p{^Is_AHex= True}', ""); +Expect(0, 57, '\P{Is_AHex= True}', ""); +Expect(1, 57, '\P{^Is_AHex= True}', ""); +Expect(0, 47, '\p{Is_AHex= True}', ""); +Expect(1, 47, '\p{^Is_AHex= True}', ""); +Expect(1, 47, '\P{Is_AHex= True}', ""); +Expect(0, 47, '\P{^Is_AHex= True}', ""); +Error('\p{ASCII_Hex_Digit=- no:=}'); +Error('\P{ASCII_Hex_Digit=- no:=}'); +Expect(1, 47, '\p{ASCII_Hex_Digit: no}', ""); +Expect(0, 47, '\p{^ASCII_Hex_Digit: no}', ""); +Expect(0, 47, '\P{ASCII_Hex_Digit: no}', ""); +Expect(1, 47, '\P{^ASCII_Hex_Digit: no}', ""); +Expect(0, 57, '\p{ASCII_Hex_Digit: no}', ""); +Expect(1, 57, '\p{^ASCII_Hex_Digit: no}', ""); +Expect(1, 57, '\P{ASCII_Hex_Digit: no}', ""); +Expect(0, 57, '\P{^ASCII_Hex_Digit: no}', ""); +Expect(1, 47, '\p{ASCII_Hex_Digit=-No}', ""); +Expect(0, 47, '\p{^ASCII_Hex_Digit=-No}', ""); +Expect(0, 47, '\P{ASCII_Hex_Digit=-No}', ""); +Expect(1, 47, '\P{^ASCII_Hex_Digit=-No}', ""); +Expect(0, 57, '\p{ASCII_Hex_Digit=-No}', ""); +Expect(1, 57, '\p{^ASCII_Hex_Digit=-No}', ""); +Expect(1, 57, '\P{ASCII_Hex_Digit=-No}', ""); +Expect(0, 57, '\P{^ASCII_Hex_Digit=-No}', ""); +Error('\p{AHex=_/a/N}'); +Error('\P{AHex=_/a/N}'); +Expect(1, 47, '\p{AHex=n}', ""); +Expect(0, 47, '\p{^AHex=n}', ""); +Expect(0, 47, '\P{AHex=n}', ""); +Expect(1, 47, '\P{^AHex=n}', ""); +Expect(0, 57, '\p{AHex=n}', ""); +Expect(1, 57, '\p{^AHex=n}', ""); +Expect(1, 57, '\P{AHex=n}', ""); +Expect(0, 57, '\P{^AHex=n}', ""); +Expect(1, 47, '\p{AHex=_N}', ""); +Expect(0, 47, '\p{^AHex=_N}', ""); +Expect(0, 47, '\P{AHex=_N}', ""); +Expect(1, 47, '\P{^AHex=_N}', ""); +Expect(0, 57, '\p{AHex=_N}', ""); +Expect(1, 57, '\p{^AHex=_N}', ""); +Expect(1, 57, '\P{AHex=_N}', ""); +Expect(0, 57, '\P{^AHex=_N}', ""); +Error('\p{Is_ASCII_Hex_Digit= /a/F}'); +Error('\P{Is_ASCII_Hex_Digit= /a/F}'); +Expect(1, 47, '\p{Is_ASCII_Hex_Digit=f}', ""); +Expect(0, 47, '\p{^Is_ASCII_Hex_Digit=f}', ""); +Expect(0, 47, '\P{Is_ASCII_Hex_Digit=f}', ""); +Expect(1, 47, '\P{^Is_ASCII_Hex_Digit=f}', ""); +Expect(0, 57, '\p{Is_ASCII_Hex_Digit=f}', ""); +Expect(1, 57, '\p{^Is_ASCII_Hex_Digit=f}', ""); +Expect(1, 57, '\P{Is_ASCII_Hex_Digit=f}', ""); +Expect(0, 57, '\P{^Is_ASCII_Hex_Digit=f}', ""); +Expect(1, 47, '\p{Is_ASCII_Hex_Digit: -F}', ""); +Expect(0, 47, '\p{^Is_ASCII_Hex_Digit: -F}', ""); +Expect(0, 47, '\P{Is_ASCII_Hex_Digit: -F}', ""); +Expect(1, 47, '\P{^Is_ASCII_Hex_Digit: -F}', ""); +Expect(0, 57, '\p{Is_ASCII_Hex_Digit: -F}', ""); +Expect(1, 57, '\p{^Is_ASCII_Hex_Digit: -F}', ""); +Expect(1, 57, '\P{Is_ASCII_Hex_Digit: -F}', ""); +Expect(0, 57, '\P{^Is_ASCII_Hex_Digit: -F}', ""); +Error('\p{Is_AHex: /a/ -False}'); +Error('\P{Is_AHex: /a/ -False}'); +Expect(1, 47, '\p{Is_AHex=false}', ""); +Expect(0, 47, '\p{^Is_AHex=false}', ""); +Expect(0, 47, '\P{Is_AHex=false}', ""); +Expect(1, 47, '\P{^Is_AHex=false}', ""); +Expect(0, 57, '\p{Is_AHex=false}', ""); +Expect(1, 57, '\p{^Is_AHex=false}', ""); +Expect(1, 57, '\P{Is_AHex=false}', ""); +Expect(0, 57, '\P{^Is_AHex=false}', ""); +Expect(1, 47, '\p{Is_AHex=__false}', ""); +Expect(0, 47, '\p{^Is_AHex=__false}', ""); +Expect(0, 47, '\P{Is_AHex=__false}', ""); +Expect(1, 47, '\P{^Is_AHex=__false}', ""); +Expect(0, 57, '\p{Is_AHex=__false}', ""); +Expect(1, 57, '\p{^Is_AHex=__false}', ""); +Expect(1, 57, '\P{Is_AHex=__false}', ""); +Expect(0, 57, '\P{^Is_AHex=__false}', ""); +Error('\p{Present_In= :=+0_3.2}'); +Error('\P{Present_In= :=+0_3.2}'); +Expect(1, 544, '\p{Present_In=+0003.2}', ""); +Expect(0, 544, '\p{^Present_In=+0003.2}', ""); +Expect(0, 544, '\P{Present_In=+0003.2}', ""); +Expect(1, 544, '\P{^Present_In=+0003.2}', ""); +Expect(0, 545, '\p{Present_In=+0003.2}', ""); +Expect(1, 545, '\p{^Present_In=+0003.2}', ""); +Expect(1, 545, '\P{Present_In=+0003.2}', ""); +Expect(0, 545, '\P{^Present_In=+0003.2}', ""); +Error('\p{In=_:=+0000 0000 03.2}'); +Error('\P{In=_:=+0000 0000 03.2}'); +Expect(1, 544, '\p{In=+0_0_0_0_0_0_0_003.2}', ""); +Expect(0, 544, '\p{^In=+0_0_0_0_0_0_0_003.2}', ""); +Expect(0, 544, '\P{In=+0_0_0_0_0_0_0_003.2}', ""); +Expect(1, 544, '\P{^In=+0_0_0_0_0_0_0_003.2}', ""); +Expect(0, 545, '\p{In=+0_0_0_0_0_0_0_003.2}', ""); +Expect(1, 545, '\p{^In=+0_0_0_0_0_0_0_003.2}', ""); +Expect(1, 545, '\P{In=+0_0_0_0_0_0_0_003.2}', ""); +Expect(0, 545, '\P{^In=+0_0_0_0_0_0_0_003.2}', ""); +Error('\p{Present_In= _00 2.0/a/}'); +Error('\P{Present_In= _00 2.0/a/}'); +Expect(1, 501, '\p{Present_In=+0_0_0_0_0_0_0_002.0}', ""); +Expect(0, 501, '\p{^Present_In=+0_0_0_0_0_0_0_002.0}', ""); +Expect(0, 501, '\P{Present_In=+0_0_0_0_0_0_0_002.0}', ""); +Expect(1, 501, '\P{^Present_In=+0_0_0_0_0_0_0_002.0}', ""); +Expect(0, 505, '\p{Present_In=+0_0_0_0_0_0_0_002.0}', ""); +Expect(1, 505, '\p{^Present_In=+0_0_0_0_0_0_0_002.0}', ""); +Expect(1, 505, '\P{Present_In=+0_0_0_0_0_0_0_002.0}', ""); +Expect(0, 505, '\P{^Present_In=+0_0_0_0_0_0_0_002.0}', ""); +Error('\p{In=:= +000000002.0}'); +Error('\P{In=:= +000000002.0}'); +Expect(1, 501, '\p{In:000002.0}', ""); +Expect(0, 501, '\p{^In:000002.0}', ""); +Expect(0, 501, '\P{In:000002.0}', ""); +Expect(1, 501, '\P{^In:000002.0}', ""); +Expect(0, 505, '\p{In:000002.0}', ""); +Expect(1, 505, '\p{^In:000002.0}', ""); +Expect(1, 505, '\P{In:000002.0}', ""); +Expect(0, 505, '\P{^In:000002.0}', ""); +Error('\p{Present_In=:= 0000001.1}'); +Error('\P{Present_In=:= 0000001.1}'); +Expect(1, 501, '\p{Present_In=00_1.1}', ""); +Expect(0, 501, '\p{^Present_In=00_1.1}', ""); +Expect(0, 501, '\P{Present_In=00_1.1}', ""); +Expect(1, 501, '\P{^Present_In=00_1.1}', ""); +Expect(0, 505, '\p{Present_In=00_1.1}', ""); +Expect(1, 505, '\p{^Present_In=00_1.1}', ""); +Expect(1, 505, '\P{Present_In=00_1.1}', ""); +Expect(0, 505, '\P{^Present_In=00_1.1}', ""); +Error('\p{In=_1.1:=}'); +Error('\P{In=_1.1:=}'); +Expect(1, 501, '\p{In=0_0_0_0_0_01.1}', ""); +Expect(0, 501, '\p{^In=0_0_0_0_0_01.1}', ""); +Expect(0, 501, '\P{In=0_0_0_0_0_01.1}', ""); +Expect(1, 501, '\P{^In=0_0_0_0_0_01.1}', ""); +Expect(0, 505, '\p{In=0_0_0_0_0_01.1}', ""); +Expect(1, 505, '\p{^In=0_0_0_0_0_01.1}', ""); +Expect(1, 505, '\P{In=0_0_0_0_0_01.1}', ""); +Expect(0, 505, '\P{^In=0_0_0_0_0_01.1}', ""); +Error('\p{Present_In= _0_0:=0_05.0}'); +Error('\P{Present_In= _0_0:=0_05.0}'); +Expect(1, 879, '\p{Present_In=0_0_0_0_0_05.0}', ""); +Expect(0, 879, '\p{^Present_In=0_0_0_0_0_05.0}', ""); +Expect(0, 879, '\P{Present_In=0_0_0_0_0_05.0}', ""); +Expect(1, 879, '\P{^Present_In=0_0_0_0_0_05.0}', ""); +Expect(0, 883, '\p{Present_In=0_0_0_0_0_05.0}', ""); +Expect(1, 883, '\p{^Present_In=0_0_0_0_0_05.0}', ""); +Expect(1, 883, '\P{Present_In=0_0_0_0_0_05.0}', ""); +Expect(0, 883, '\P{^Present_In=0_0_0_0_0_05.0}', ""); +Error('\p{In=- 00000005.0/a/}'); +Error('\P{In=- 00000005.0/a/}'); +Expect(1, 879, '\p{In=0_0_0_0_0_05.0}', ""); +Expect(0, 879, '\p{^In=0_0_0_0_0_05.0}', ""); +Expect(0, 879, '\P{In=0_0_0_0_0_05.0}', ""); +Expect(1, 879, '\P{^In=0_0_0_0_0_05.0}', ""); +Expect(0, 883, '\p{In=0_0_0_0_0_05.0}', ""); +Expect(1, 883, '\p{^In=0_0_0_0_0_05.0}', ""); +Expect(1, 883, '\P{In=0_0_0_0_0_05.0}', ""); +Expect(0, 883, '\P{^In=0_0_0_0_0_05.0}', ""); +Error('\p{Present_In=-:=0000003.0}'); +Error('\P{Present_In=-:=0000003.0}'); +Expect(1, 543, '\p{Present_In=003.0}', ""); +Expect(0, 543, '\p{^Present_In=003.0}', ""); +Expect(0, 543, '\P{Present_In=003.0}', ""); +Expect(1, 543, '\P{^Present_In=003.0}', ""); +Expect(0, 545, '\p{Present_In=003.0}', ""); +Expect(1, 545, '\p{^Present_In=003.0}', ""); +Expect(1, 545, '\P{Present_In=003.0}', ""); +Expect(0, 545, '\P{^Present_In=003.0}', ""); +Error('\p{In= _+0 00:=0 0003.0}'); +Error('\P{In= _+0 00:=0 0003.0}'); +Expect(1, 543, '\p{In=0003.0}', ""); +Expect(0, 543, '\p{^In=0003.0}', ""); +Expect(0, 543, '\P{In=0003.0}', ""); +Expect(1, 543, '\P{^In=0003.0}', ""); +Expect(0, 545, '\p{In=0003.0}', ""); +Expect(1, 545, '\p{^In=0003.0}', ""); +Expect(1, 545, '\P{In=0003.0}', ""); +Expect(0, 545, '\P{^In=0003.0}', ""); +Error('\p{Present_In=/a/ unassigned}'); +Error('\P{Present_In=/a/ unassigned}'); +Expect(1, 889, '\p{Present_In=unassigned}', ""); +Expect(0, 889, '\p{^Present_In=unassigned}', ""); +Expect(0, 889, '\P{Present_In=unassigned}', ""); +Expect(1, 889, '\P{^Present_In=unassigned}', ""); +Expect(0, 887, '\p{Present_In=unassigned}', ""); +Expect(1, 887, '\p{^Present_In=unassigned}', ""); +Expect(1, 887, '\P{Present_In=unassigned}', ""); +Expect(0, 887, '\P{^Present_In=unassigned}', ""); +Expect(1, 889, '\p{Present_In= Unassigned}', ""); +Expect(0, 889, '\p{^Present_In= Unassigned}', ""); +Expect(0, 889, '\P{Present_In= Unassigned}', ""); +Expect(1, 889, '\P{^Present_In= Unassigned}', ""); +Expect(0, 887, '\p{Present_In= Unassigned}', ""); +Expect(1, 887, '\p{^Present_In= Unassigned}', ""); +Expect(1, 887, '\P{Present_In= Unassigned}', ""); +Expect(0, 887, '\P{^Present_In= Unassigned}', ""); +Error('\p{In=-/a/UNASSIGNED}'); +Error('\P{In=-/a/UNASSIGNED}'); +Expect(1, 889, '\p{In=unassigned}', ""); +Expect(0, 889, '\p{^In=unassigned}', ""); +Expect(0, 889, '\P{In=unassigned}', ""); +Expect(1, 889, '\P{^In=unassigned}', ""); +Expect(0, 887, '\p{In=unassigned}', ""); +Expect(1, 887, '\p{^In=unassigned}', ""); +Expect(1, 887, '\P{In=unassigned}', ""); +Expect(0, 887, '\P{^In=unassigned}', ""); +Expect(1, 889, '\p{In= Unassigned}', ""); +Expect(0, 889, '\p{^In= Unassigned}', ""); +Expect(0, 889, '\P{In= Unassigned}', ""); +Expect(1, 889, '\P{^In= Unassigned}', ""); +Expect(0, 887, '\p{In= Unassigned}', ""); +Expect(1, 887, '\p{^In= Unassigned}', ""); +Expect(1, 887, '\P{In= Unassigned}', ""); +Expect(0, 887, '\P{^In= Unassigned}', ""); +Error('\p{Present_In= 0:=0 0-0-0_0 0 005.1}'); +Error('\P{Present_In= 0:=0 0-0-0_0 0 005.1}'); +Expect(1, 887, '\p{Present_In=+05.1}', ""); +Expect(0, 887, '\p{^Present_In=+05.1}', ""); +Expect(0, 887, '\P{Present_In=+05.1}', ""); +Expect(1, 887, '\P{^Present_In=+05.1}', ""); +Expect(0, 889, '\p{Present_In=+05.1}', ""); +Expect(1, 889, '\p{^Present_In=+05.1}', ""); +Expect(1, 889, '\P{Present_In=+05.1}', ""); +Expect(0, 889, '\P{^Present_In=+05.1}', ""); +Error('\p{In= _+0000000005.1:=}'); +Error('\P{In= _+0000000005.1:=}'); +Expect(1, 887, '\p{In=0_0_0_0_0005.1}', ""); +Expect(0, 887, '\p{^In=0_0_0_0_0005.1}', ""); +Expect(0, 887, '\P{In=0_0_0_0_0005.1}', ""); +Expect(1, 887, '\P{^In=0_0_0_0_0005.1}', ""); +Expect(0, 889, '\p{In=0_0_0_0_0005.1}', ""); +Expect(1, 889, '\p{^In=0_0_0_0_0005.1}', ""); +Expect(1, 889, '\P{In=0_0_0_0_0005.1}', ""); +Expect(0, 889, '\P{^In=0_0_0_0_0005.1}', ""); +Error('\p{Present_In= /a/0 4.0}'); +Error('\P{Present_In= /a/0 4.0}'); +Expect(1, 566, '\p{Present_In=00004.0}', ""); +Expect(0, 566, '\p{^Present_In=00004.0}', ""); +Expect(0, 566, '\P{Present_In=00004.0}', ""); +Expect(1, 566, '\P{^Present_In=00004.0}', ""); +Expect(0, 591, '\p{Present_In=00004.0}', ""); +Expect(1, 591, '\p{^Present_In=00004.0}', ""); +Expect(1, 591, '\P{Present_In=00004.0}', ""); +Expect(0, 591, '\P{^Present_In=00004.0}', ""); +Error('\p{In=/a/__+000000004.0}'); +Error('\P{In=/a/__+000000004.0}'); +Expect(1, 566, '\p{In: 000000004.0}', ""); +Expect(0, 566, '\p{^In: 000000004.0}', ""); +Expect(0, 566, '\P{In: 000000004.0}', ""); +Expect(1, 566, '\P{^In: 000000004.0}', ""); +Expect(0, 591, '\p{In: 000000004.0}', ""); +Expect(1, 591, '\p{^In: 000000004.0}', ""); +Expect(1, 591, '\P{In: 000000004.0}', ""); +Expect(0, 591, '\P{^In: 000000004.0}', ""); +Error('\p{Present_In=- 0 3.1:=}'); +Error('\P{Present_In=- 0 3.1:=}'); +Expect(1, 543, '\p{Present_In=0000000003.1}', ""); +Expect(0, 543, '\p{^Present_In=0000000003.1}', ""); +Expect(0, 543, '\P{Present_In=0000000003.1}', ""); +Expect(1, 543, '\P{^Present_In=0000000003.1}', ""); +Expect(0, 545, '\p{Present_In=0000000003.1}', ""); +Expect(1, 545, '\p{^Present_In=0000000003.1}', ""); +Expect(1, 545, '\P{Present_In=0000000003.1}', ""); +Expect(0, 545, '\P{^Present_In=0000000003.1}', ""); +Error('\p{In=-00/a/00_00_003.1}'); +Error('\P{In=-00/a/00_00_003.1}'); +Expect(1, 543, '\p{In=000000003.1}', ""); +Expect(0, 543, '\p{^In=000000003.1}', ""); +Expect(0, 543, '\P{In=000000003.1}', ""); +Expect(1, 543, '\P{^In=000000003.1}', ""); +Expect(0, 545, '\p{In=000000003.1}', ""); +Expect(1, 545, '\p{^In=000000003.1}', ""); +Expect(1, 545, '\P{In=000000003.1}', ""); +Expect(0, 545, '\P{^In=000000003.1}', ""); +Error('\p{Present_In=_-+0000000002.1:=}'); +Error('\P{Present_In=_-+0000000002.1:=}'); +Expect(1, 501, '\p{Present_In=+0002.1}', ""); +Expect(0, 501, '\p{^Present_In=+0002.1}', ""); +Expect(0, 501, '\P{Present_In=+0002.1}', ""); +Expect(1, 501, '\P{^Present_In=+0002.1}', ""); +Expect(0, 505, '\p{Present_In=+0002.1}', ""); +Expect(1, 505, '\p{^Present_In=+0002.1}', ""); +Expect(1, 505, '\P{Present_In=+0002.1}', ""); +Expect(0, 505, '\P{^Present_In=+0002.1}', ""); +Error('\p{In=-_0_0 0_0:=0002.1}'); +Error('\P{In=-_0_0 0_0:=0002.1}'); +Expect(1, 501, '\p{In=+2.1}', ""); +Expect(0, 501, '\p{^In=+2.1}', ""); +Expect(0, 501, '\P{In=+2.1}', ""); +Expect(1, 501, '\P{^In=+2.1}', ""); +Expect(0, 505, '\p{In=+2.1}', ""); +Expect(1, 505, '\p{^In=+2.1}', ""); +Expect(1, 505, '\P{In=+2.1}', ""); +Expect(0, 505, '\P{^In=+2.1}', ""); +Error('\p{Present_In=:= _00 4.1}'); +Error('\P{Present_In=:= _00 4.1}'); +Expect(1, 577, '\p{Present_In=0_4.1}', ""); +Expect(0, 577, '\p{^Present_In=0_4.1}', ""); +Expect(0, 577, '\P{Present_In=0_4.1}', ""); +Expect(1, 577, '\P{^Present_In=0_4.1}', ""); +Expect(0, 591, '\p{Present_In=0_4.1}', ""); +Expect(1, 591, '\p{^Present_In=0_4.1}', ""); +Expect(1, 591, '\P{Present_In=0_4.1}', ""); +Expect(0, 591, '\P{^Present_In=0_4.1}', ""); +Error('\p{In=_ 000004.1/a/}'); +Error('\P{In=_ 000004.1/a/}'); +Expect(1, 577, '\p{In: 0000000004.1}', ""); +Expect(0, 577, '\p{^In: 0000000004.1}', ""); +Expect(0, 577, '\P{In: 0000000004.1}', ""); +Expect(1, 577, '\P{^In: 0000000004.1}', ""); +Expect(0, 591, '\p{In: 0000000004.1}', ""); +Expect(1, 591, '\p{^In: 0000000004.1}', ""); +Expect(1, 591, '\P{In: 0000000004.1}', ""); +Expect(0, 591, '\P{^In: 0000000004.1}', ""); +Error('\p{Extender=-/a/YES}'); +Error('\P{Extender=-/a/YES}'); +Expect(1, 721, '\p{Extender=yes}', ""); +Expect(0, 721, '\p{^Extender=yes}', ""); +Expect(0, 721, '\P{Extender=yes}', ""); +Expect(1, 721, '\P{^Extender=yes}', ""); +Expect(0, 7, '\p{Extender=yes}', ""); +Expect(1, 7, '\p{^Extender=yes}', ""); +Expect(1, 7, '\P{Extender=yes}', ""); +Expect(0, 7, '\P{^Extender=yes}', ""); +Expect(1, 721, '\p{Extender=-Yes}', ""); +Expect(0, 721, '\p{^Extender=-Yes}', ""); +Expect(0, 721, '\P{Extender=-Yes}', ""); +Expect(1, 721, '\P{^Extender=-Yes}', ""); +Expect(0, 7, '\p{Extender=-Yes}', ""); +Expect(1, 7, '\p{^Extender=-Yes}', ""); +Expect(1, 7, '\P{Extender=-Yes}', ""); +Expect(0, 7, '\P{^Extender=-Yes}', ""); +Error('\p{Ext= Y:=}'); +Error('\P{Ext= Y:=}'); +Expect(1, 721, '\p{Ext=y}', ""); +Expect(0, 721, '\p{^Ext=y}', ""); +Expect(0, 721, '\P{Ext=y}', ""); +Expect(1, 721, '\P{^Ext=y}', ""); +Expect(0, 7, '\p{Ext=y}', ""); +Expect(1, 7, '\p{^Ext=y}', ""); +Expect(1, 7, '\P{Ext=y}', ""); +Expect(0, 7, '\P{^Ext=y}', ""); +Expect(1, 721, '\p{Ext= Y}', ""); +Expect(0, 721, '\p{^Ext= Y}', ""); +Expect(0, 721, '\P{Ext= Y}', ""); +Expect(1, 721, '\P{^Ext= Y}', ""); +Expect(0, 7, '\p{Ext= Y}', ""); +Expect(1, 7, '\p{^Ext= Y}', ""); +Expect(1, 7, '\P{Ext= Y}', ""); +Expect(0, 7, '\P{^Ext= Y}', ""); +Error('\p{Is_Extender=/a/-T}'); +Error('\P{Is_Extender=/a/-T}'); +Expect(1, 721, '\p{Is_Extender=t}', ""); +Expect(0, 721, '\p{^Is_Extender=t}', ""); +Expect(0, 721, '\P{Is_Extender=t}', ""); +Expect(1, 721, '\P{^Is_Extender=t}', ""); +Expect(0, 7, '\p{Is_Extender=t}', ""); +Expect(1, 7, '\p{^Is_Extender=t}', ""); +Expect(1, 7, '\P{Is_Extender=t}', ""); +Expect(0, 7, '\P{^Is_Extender=t}', ""); +Expect(1, 721, '\p{Is_Extender=- T}', ""); +Expect(0, 721, '\p{^Is_Extender=- T}', ""); +Expect(0, 721, '\P{Is_Extender=- T}', ""); +Expect(1, 721, '\P{^Is_Extender=- T}', ""); +Expect(0, 7, '\p{Is_Extender=- T}', ""); +Expect(1, 7, '\p{^Is_Extender=- T}', ""); +Expect(1, 7, '\P{Is_Extender=- T}', ""); +Expect(0, 7, '\P{^Is_Extender=- T}', ""); +Error('\p{Is_Ext= /a/true}'); +Error('\P{Is_Ext= /a/true}'); +Expect(1, 721, '\p{Is_Ext=true}', ""); +Expect(0, 721, '\p{^Is_Ext=true}', ""); +Expect(0, 721, '\P{Is_Ext=true}', ""); +Expect(1, 721, '\P{^Is_Ext=true}', ""); +Expect(0, 7, '\p{Is_Ext=true}', ""); +Expect(1, 7, '\p{^Is_Ext=true}', ""); +Expect(1, 7, '\P{Is_Ext=true}', ""); +Expect(0, 7, '\P{^Is_Ext=true}', ""); +Expect(1, 721, '\p{Is_Ext=-_true}', ""); +Expect(0, 721, '\p{^Is_Ext=-_true}', ""); +Expect(0, 721, '\P{Is_Ext=-_true}', ""); +Expect(1, 721, '\P{^Is_Ext=-_true}', ""); +Expect(0, 7, '\p{Is_Ext=-_true}', ""); +Expect(1, 7, '\p{^Is_Ext=-_true}', ""); +Expect(1, 7, '\P{Is_Ext=-_true}', ""); +Expect(0, 7, '\P{^Is_Ext=-_true}', ""); +Error('\p{Extender:_-NO:=}'); +Error('\P{Extender:_-NO:=}'); +Expect(1, 7, '\p{Extender=no}', ""); +Expect(0, 7, '\p{^Extender=no}', ""); +Expect(0, 7, '\P{Extender=no}', ""); +Expect(1, 7, '\P{^Extender=no}', ""); +Expect(0, 721, '\p{Extender=no}', ""); +Expect(1, 721, '\p{^Extender=no}', ""); +Expect(1, 721, '\P{Extender=no}', ""); +Expect(0, 721, '\P{^Extender=no}', ""); +Expect(1, 7, '\p{Extender= _No}', ""); +Expect(0, 7, '\p{^Extender= _No}', ""); +Expect(0, 7, '\P{Extender= _No}', ""); +Expect(1, 7, '\P{^Extender= _No}', ""); +Expect(0, 721, '\p{Extender= _No}', ""); +Expect(1, 721, '\p{^Extender= _No}', ""); +Expect(1, 721, '\P{Extender= _No}', ""); +Expect(0, 721, '\P{^Extender= _No}', ""); +Error('\p{Ext=/a/_N}'); +Error('\P{Ext=/a/_N}'); +Expect(1, 7, '\p{Ext=n}', ""); +Expect(0, 7, '\p{^Ext=n}', ""); +Expect(0, 7, '\P{Ext=n}', ""); +Expect(1, 7, '\P{^Ext=n}', ""); +Expect(0, 721, '\p{Ext=n}', ""); +Expect(1, 721, '\p{^Ext=n}', ""); +Expect(1, 721, '\P{Ext=n}', ""); +Expect(0, 721, '\P{^Ext=n}', ""); +Expect(1, 7, '\p{Ext=-N}', ""); +Expect(0, 7, '\p{^Ext=-N}', ""); +Expect(0, 7, '\P{Ext=-N}', ""); +Expect(1, 7, '\P{^Ext=-N}', ""); +Expect(0, 721, '\p{Ext=-N}', ""); +Expect(1, 721, '\p{^Ext=-N}', ""); +Expect(1, 721, '\P{Ext=-N}', ""); +Expect(0, 721, '\P{^Ext=-N}', ""); +Error('\p{Is_Extender= F/a/}'); +Error('\P{Is_Extender= F/a/}'); +Expect(1, 7, '\p{Is_Extender=f}', ""); +Expect(0, 7, '\p{^Is_Extender=f}', ""); +Expect(0, 7, '\P{Is_Extender=f}', ""); +Expect(1, 7, '\P{^Is_Extender=f}', ""); +Expect(0, 721, '\p{Is_Extender=f}', ""); +Expect(1, 721, '\p{^Is_Extender=f}', ""); +Expect(1, 721, '\P{Is_Extender=f}', ""); +Expect(0, 721, '\P{^Is_Extender=f}', ""); +Expect(1, 7, '\p{Is_Extender= F}', ""); +Expect(0, 7, '\p{^Is_Extender= F}', ""); +Expect(0, 7, '\P{Is_Extender= F}', ""); +Expect(1, 7, '\P{^Is_Extender= F}', ""); +Expect(0, 721, '\p{Is_Extender= F}', ""); +Expect(1, 721, '\p{^Is_Extender= F}', ""); +Expect(1, 721, '\P{Is_Extender= F}', ""); +Expect(0, 721, '\P{^Is_Extender= F}', ""); +Error('\p{Is_Ext=:= False}'); +Error('\P{Is_Ext=:= False}'); +Expect(1, 7, '\p{Is_Ext=false}', ""); +Expect(0, 7, '\p{^Is_Ext=false}', ""); +Expect(0, 7, '\P{Is_Ext=false}', ""); +Expect(1, 7, '\P{^Is_Ext=false}', ""); +Expect(0, 721, '\p{Is_Ext=false}', ""); +Expect(1, 721, '\p{^Is_Ext=false}', ""); +Expect(1, 721, '\P{Is_Ext=false}', ""); +Expect(0, 721, '\P{^Is_Ext=false}', ""); +Expect(1, 7, '\p{Is_Ext= -false}', ""); +Expect(0, 7, '\p{^Is_Ext= -false}', ""); +Expect(0, 7, '\P{Is_Ext= -false}', ""); +Expect(1, 7, '\P{^Is_Ext= -false}', ""); +Expect(0, 721, '\p{Is_Ext= -false}', ""); +Expect(1, 721, '\p{^Is_Ext= -false}', ""); +Expect(1, 721, '\P{Is_Ext= -false}', ""); +Expect(0, 721, '\P{^Is_Ext= -false}', ""); +Error('\p{IDS_Trinary_Operator: __yes/a/}'); +Error('\P{IDS_Trinary_Operator: __yes/a/}'); +Expect(1, 12275, '\p{IDS_Trinary_Operator=yes}', ""); +Expect(0, 12275, '\p{^IDS_Trinary_Operator=yes}', ""); +Expect(0, 12275, '\P{IDS_Trinary_Operator=yes}', ""); +Expect(1, 12275, '\P{^IDS_Trinary_Operator=yes}', ""); +Expect(0, 12273, '\p{IDS_Trinary_Operator=yes}', ""); +Expect(1, 12273, '\p{^IDS_Trinary_Operator=yes}', ""); +Expect(1, 12273, '\P{IDS_Trinary_Operator=yes}', ""); +Expect(0, 12273, '\P{^IDS_Trinary_Operator=yes}', ""); +Expect(1, 12275, '\p{IDS_Trinary_Operator=_-Yes}', ""); +Expect(0, 12275, '\p{^IDS_Trinary_Operator=_-Yes}', ""); +Expect(0, 12275, '\P{IDS_Trinary_Operator=_-Yes}', ""); +Expect(1, 12275, '\P{^IDS_Trinary_Operator=_-Yes}', ""); +Expect(0, 12273, '\p{IDS_Trinary_Operator=_-Yes}', ""); +Expect(1, 12273, '\p{^IDS_Trinary_Operator=_-Yes}', ""); +Expect(1, 12273, '\P{IDS_Trinary_Operator=_-Yes}', ""); +Expect(0, 12273, '\P{^IDS_Trinary_Operator=_-Yes}', ""); +Error('\p{IDST=:=_ Y}'); +Error('\P{IDST=:=_ Y}'); +Expect(1, 12275, '\p{IDST: y}', ""); +Expect(0, 12275, '\p{^IDST: y}', ""); +Expect(0, 12275, '\P{IDST: y}', ""); +Expect(1, 12275, '\P{^IDST: y}', ""); +Expect(0, 12273, '\p{IDST: y}', ""); +Expect(1, 12273, '\p{^IDST: y}', ""); +Expect(1, 12273, '\P{IDST: y}', ""); +Expect(0, 12273, '\P{^IDST: y}', ""); +Expect(1, 12275, '\p{IDST= y}', ""); +Expect(0, 12275, '\p{^IDST= y}', ""); +Expect(0, 12275, '\P{IDST= y}', ""); +Expect(1, 12275, '\P{^IDST= y}', ""); +Expect(0, 12273, '\p{IDST= y}', ""); +Expect(1, 12273, '\p{^IDST= y}', ""); +Expect(1, 12273, '\P{IDST= y}', ""); +Expect(0, 12273, '\P{^IDST= y}', ""); +Error('\p{Is_IDS_Trinary_Operator: -T:=}'); +Error('\P{Is_IDS_Trinary_Operator: -T:=}'); +Expect(1, 12275, '\p{Is_IDS_Trinary_Operator=t}', ""); +Expect(0, 12275, '\p{^Is_IDS_Trinary_Operator=t}', ""); +Expect(0, 12275, '\P{Is_IDS_Trinary_Operator=t}', ""); +Expect(1, 12275, '\P{^Is_IDS_Trinary_Operator=t}', ""); +Expect(0, 12273, '\p{Is_IDS_Trinary_Operator=t}', ""); +Expect(1, 12273, '\p{^Is_IDS_Trinary_Operator=t}', ""); +Expect(1, 12273, '\P{Is_IDS_Trinary_Operator=t}', ""); +Expect(0, 12273, '\P{^Is_IDS_Trinary_Operator=t}', ""); +Expect(1, 12275, '\p{Is_IDS_Trinary_Operator=_t}', ""); +Expect(0, 12275, '\p{^Is_IDS_Trinary_Operator=_t}', ""); +Expect(0, 12275, '\P{Is_IDS_Trinary_Operator=_t}', ""); +Expect(1, 12275, '\P{^Is_IDS_Trinary_Operator=_t}', ""); +Expect(0, 12273, '\p{Is_IDS_Trinary_Operator=_t}', ""); +Expect(1, 12273, '\p{^Is_IDS_Trinary_Operator=_t}', ""); +Expect(1, 12273, '\P{Is_IDS_Trinary_Operator=_t}', ""); +Expect(0, 12273, '\P{^Is_IDS_Trinary_Operator=_t}', ""); +Error('\p{Is_IDST= true:=}'); +Error('\P{Is_IDST= true:=}'); +Expect(1, 12275, '\p{Is_IDST=true}', ""); +Expect(0, 12275, '\p{^Is_IDST=true}', ""); +Expect(0, 12275, '\P{Is_IDST=true}', ""); +Expect(1, 12275, '\P{^Is_IDST=true}', ""); +Expect(0, 12273, '\p{Is_IDST=true}', ""); +Expect(1, 12273, '\p{^Is_IDST=true}', ""); +Expect(1, 12273, '\P{Is_IDST=true}', ""); +Expect(0, 12273, '\P{^Is_IDST=true}', ""); +Expect(1, 12275, '\p{Is_IDST= True}', ""); +Expect(0, 12275, '\p{^Is_IDST= True}', ""); +Expect(0, 12275, '\P{Is_IDST= True}', ""); +Expect(1, 12275, '\P{^Is_IDST= True}', ""); +Expect(0, 12273, '\p{Is_IDST= True}', ""); +Expect(1, 12273, '\p{^Is_IDST= True}', ""); +Expect(1, 12273, '\P{Is_IDST= True}', ""); +Expect(0, 12273, '\P{^Is_IDST= True}', ""); +Error('\p{IDS_Trinary_Operator=/a/ _NO}'); +Error('\P{IDS_Trinary_Operator=/a/ _NO}'); +Expect(1, 12273, '\p{IDS_Trinary_Operator=no}', ""); +Expect(0, 12273, '\p{^IDS_Trinary_Operator=no}', ""); +Expect(0, 12273, '\P{IDS_Trinary_Operator=no}', ""); +Expect(1, 12273, '\P{^IDS_Trinary_Operator=no}', ""); +Expect(0, 12275, '\p{IDS_Trinary_Operator=no}', ""); +Expect(1, 12275, '\p{^IDS_Trinary_Operator=no}', ""); +Expect(1, 12275, '\P{IDS_Trinary_Operator=no}', ""); +Expect(0, 12275, '\P{^IDS_Trinary_Operator=no}', ""); +Expect(1, 12273, '\p{IDS_Trinary_Operator= No}', ""); +Expect(0, 12273, '\p{^IDS_Trinary_Operator= No}', ""); +Expect(0, 12273, '\P{IDS_Trinary_Operator= No}', ""); +Expect(1, 12273, '\P{^IDS_Trinary_Operator= No}', ""); +Expect(0, 12275, '\p{IDS_Trinary_Operator= No}', ""); +Expect(1, 12275, '\p{^IDS_Trinary_Operator= No}', ""); +Expect(1, 12275, '\P{IDS_Trinary_Operator= No}', ""); +Expect(0, 12275, '\P{^IDS_Trinary_Operator= No}', ""); +Error('\p{IDST=/a/ N}'); +Error('\P{IDST=/a/ N}'); +Expect(1, 12273, '\p{IDST=n}', ""); +Expect(0, 12273, '\p{^IDST=n}', ""); +Expect(0, 12273, '\P{IDST=n}', ""); +Expect(1, 12273, '\P{^IDST=n}', ""); +Expect(0, 12275, '\p{IDST=n}', ""); +Expect(1, 12275, '\p{^IDST=n}', ""); +Expect(1, 12275, '\P{IDST=n}', ""); +Expect(0, 12275, '\P{^IDST=n}', ""); +Expect(1, 12273, '\p{IDST=-_N}', ""); +Expect(0, 12273, '\p{^IDST=-_N}', ""); +Expect(0, 12273, '\P{IDST=-_N}', ""); +Expect(1, 12273, '\P{^IDST=-_N}', ""); +Expect(0, 12275, '\p{IDST=-_N}', ""); +Expect(1, 12275, '\p{^IDST=-_N}', ""); +Expect(1, 12275, '\P{IDST=-_N}', ""); +Expect(0, 12275, '\P{^IDST=-_N}', ""); +Error('\p{Is_IDS_Trinary_Operator=/a/ -F}'); +Error('\P{Is_IDS_Trinary_Operator=/a/ -F}'); +Expect(1, 12273, '\p{Is_IDS_Trinary_Operator=f}', ""); +Expect(0, 12273, '\p{^Is_IDS_Trinary_Operator=f}', ""); +Expect(0, 12273, '\P{Is_IDS_Trinary_Operator=f}', ""); +Expect(1, 12273, '\P{^Is_IDS_Trinary_Operator=f}', ""); +Expect(0, 12275, '\p{Is_IDS_Trinary_Operator=f}', ""); +Expect(1, 12275, '\p{^Is_IDS_Trinary_Operator=f}', ""); +Expect(1, 12275, '\P{Is_IDS_Trinary_Operator=f}', ""); +Expect(0, 12275, '\P{^Is_IDS_Trinary_Operator=f}', ""); +Expect(1, 12273, '\p{Is_IDS_Trinary_Operator=_f}', ""); +Expect(0, 12273, '\p{^Is_IDS_Trinary_Operator=_f}', ""); +Expect(0, 12273, '\P{Is_IDS_Trinary_Operator=_f}', ""); +Expect(1, 12273, '\P{^Is_IDS_Trinary_Operator=_f}', ""); +Expect(0, 12275, '\p{Is_IDS_Trinary_Operator=_f}', ""); +Expect(1, 12275, '\p{^Is_IDS_Trinary_Operator=_f}', ""); +Expect(1, 12275, '\P{Is_IDS_Trinary_Operator=_f}', ""); +Expect(0, 12275, '\P{^Is_IDS_Trinary_Operator=_f}', ""); +Error('\p{Is_IDST=:=false}'); +Error('\P{Is_IDST=:=false}'); +Expect(1, 12273, '\p{Is_IDST=false}', ""); +Expect(0, 12273, '\p{^Is_IDST=false}', ""); +Expect(0, 12273, '\P{Is_IDST=false}', ""); +Expect(1, 12273, '\P{^Is_IDST=false}', ""); +Expect(0, 12275, '\p{Is_IDST=false}', ""); +Expect(1, 12275, '\p{^Is_IDST=false}', ""); +Expect(1, 12275, '\P{Is_IDST=false}', ""); +Expect(0, 12275, '\P{^Is_IDST=false}', ""); +Expect(1, 12273, '\p{Is_IDST: false}', ""); +Expect(0, 12273, '\p{^Is_IDST: false}', ""); +Expect(0, 12273, '\P{Is_IDST: false}', ""); +Expect(1, 12273, '\P{^Is_IDST: false}', ""); +Expect(0, 12275, '\p{Is_IDST: false}', ""); +Expect(1, 12275, '\p{^Is_IDST: false}', ""); +Expect(1, 12275, '\P{Is_IDST: false}', ""); +Expect(0, 12275, '\P{^Is_IDST: false}', ""); +Error('\p{Composition_Exclusion=yes:=}'); +Error('\P{Composition_Exclusion=yes:=}'); +Expect(1, 2399, '\p{Composition_Exclusion=yes}', ""); +Expect(0, 2399, '\p{^Composition_Exclusion=yes}', ""); +Expect(0, 2399, '\P{Composition_Exclusion=yes}', ""); +Expect(1, 2399, '\P{^Composition_Exclusion=yes}', ""); +Expect(0, 2391, '\p{Composition_Exclusion=yes}', ""); +Expect(1, 2391, '\p{^Composition_Exclusion=yes}', ""); +Expect(1, 2391, '\P{Composition_Exclusion=yes}', ""); +Expect(0, 2391, '\P{^Composition_Exclusion=yes}', ""); +Expect(1, 2399, '\p{Composition_Exclusion=_yes}', ""); +Expect(0, 2399, '\p{^Composition_Exclusion=_yes}', ""); +Expect(0, 2399, '\P{Composition_Exclusion=_yes}', ""); +Expect(1, 2399, '\P{^Composition_Exclusion=_yes}', ""); +Expect(0, 2391, '\p{Composition_Exclusion=_yes}', ""); +Expect(1, 2391, '\p{^Composition_Exclusion=_yes}', ""); +Expect(1, 2391, '\P{Composition_Exclusion=_yes}', ""); +Expect(0, 2391, '\P{^Composition_Exclusion=_yes}', ""); +Error('\p{CE= /a/y}'); +Error('\P{CE= /a/y}'); +Expect(1, 2399, '\p{CE=y}', ""); +Expect(0, 2399, '\p{^CE=y}', ""); +Expect(0, 2399, '\P{CE=y}', ""); +Expect(1, 2399, '\P{^CE=y}', ""); +Expect(0, 2391, '\p{CE=y}', ""); +Expect(1, 2391, '\p{^CE=y}', ""); +Expect(1, 2391, '\P{CE=y}', ""); +Expect(0, 2391, '\P{^CE=y}', ""); +Expect(1, 2399, '\p{CE=- y}', ""); +Expect(0, 2399, '\p{^CE=- y}', ""); +Expect(0, 2399, '\P{CE=- y}', ""); +Expect(1, 2399, '\P{^CE=- y}', ""); +Expect(0, 2391, '\p{CE=- y}', ""); +Expect(1, 2391, '\p{^CE=- y}', ""); +Expect(1, 2391, '\P{CE=- y}', ""); +Expect(0, 2391, '\P{^CE=- y}', ""); +Error('\p{Is_Composition_Exclusion=-:=t}'); +Error('\P{Is_Composition_Exclusion=-:=t}'); +Expect(1, 2399, '\p{Is_Composition_Exclusion=t}', ""); +Expect(0, 2399, '\p{^Is_Composition_Exclusion=t}', ""); +Expect(0, 2399, '\P{Is_Composition_Exclusion=t}', ""); +Expect(1, 2399, '\P{^Is_Composition_Exclusion=t}', ""); +Expect(0, 2391, '\p{Is_Composition_Exclusion=t}', ""); +Expect(1, 2391, '\p{^Is_Composition_Exclusion=t}', ""); +Expect(1, 2391, '\P{Is_Composition_Exclusion=t}', ""); +Expect(0, 2391, '\P{^Is_Composition_Exclusion=t}', ""); +Expect(1, 2399, '\p{Is_Composition_Exclusion=_T}', ""); +Expect(0, 2399, '\p{^Is_Composition_Exclusion=_T}', ""); +Expect(0, 2399, '\P{Is_Composition_Exclusion=_T}', ""); +Expect(1, 2399, '\P{^Is_Composition_Exclusion=_T}', ""); +Expect(0, 2391, '\p{Is_Composition_Exclusion=_T}', ""); +Expect(1, 2391, '\p{^Is_Composition_Exclusion=_T}', ""); +Expect(1, 2391, '\P{Is_Composition_Exclusion=_T}', ""); +Expect(0, 2391, '\P{^Is_Composition_Exclusion=_T}', ""); +Error('\p{Is_CE=__TRUE/a/}'); +Error('\P{Is_CE=__TRUE/a/}'); +Expect(1, 2399, '\p{Is_CE=true}', ""); +Expect(0, 2399, '\p{^Is_CE=true}', ""); +Expect(0, 2399, '\P{Is_CE=true}', ""); +Expect(1, 2399, '\P{^Is_CE=true}', ""); +Expect(0, 2391, '\p{Is_CE=true}', ""); +Expect(1, 2391, '\p{^Is_CE=true}', ""); +Expect(1, 2391, '\P{Is_CE=true}', ""); +Expect(0, 2391, '\P{^Is_CE=true}', ""); +Expect(1, 2399, '\p{Is_CE= True}', ""); +Expect(0, 2399, '\p{^Is_CE= True}', ""); +Expect(0, 2399, '\P{Is_CE= True}', ""); +Expect(1, 2399, '\P{^Is_CE= True}', ""); +Expect(0, 2391, '\p{Is_CE= True}', ""); +Expect(1, 2391, '\p{^Is_CE= True}', ""); +Expect(1, 2391, '\P{Is_CE= True}', ""); +Expect(0, 2391, '\P{^Is_CE= True}', ""); +Error('\p{Composition_Exclusion=:=_ No}'); +Error('\P{Composition_Exclusion=:=_ No}'); +Expect(1, 2391, '\p{Composition_Exclusion=no}', ""); +Expect(0, 2391, '\p{^Composition_Exclusion=no}', ""); +Expect(0, 2391, '\P{Composition_Exclusion=no}', ""); +Expect(1, 2391, '\P{^Composition_Exclusion=no}', ""); +Expect(0, 2399, '\p{Composition_Exclusion=no}', ""); +Expect(1, 2399, '\p{^Composition_Exclusion=no}', ""); +Expect(1, 2399, '\P{Composition_Exclusion=no}', ""); +Expect(0, 2399, '\P{^Composition_Exclusion=no}', ""); +Expect(1, 2391, '\p{Composition_Exclusion: NO}', ""); +Expect(0, 2391, '\p{^Composition_Exclusion: NO}', ""); +Expect(0, 2391, '\P{Composition_Exclusion: NO}', ""); +Expect(1, 2391, '\P{^Composition_Exclusion: NO}', ""); +Expect(0, 2399, '\p{Composition_Exclusion: NO}', ""); +Expect(1, 2399, '\p{^Composition_Exclusion: NO}', ""); +Expect(1, 2399, '\P{Composition_Exclusion: NO}', ""); +Expect(0, 2399, '\P{^Composition_Exclusion: NO}', ""); +Error('\p{CE=_:=N}'); +Error('\P{CE=_:=N}'); +Expect(1, 2391, '\p{CE=n}', ""); +Expect(0, 2391, '\p{^CE=n}', ""); +Expect(0, 2391, '\P{CE=n}', ""); +Expect(1, 2391, '\P{^CE=n}', ""); +Expect(0, 2399, '\p{CE=n}', ""); +Expect(1, 2399, '\p{^CE=n}', ""); +Expect(1, 2399, '\P{CE=n}', ""); +Expect(0, 2399, '\P{^CE=n}', ""); +Expect(1, 2391, '\p{CE=- n}', ""); +Expect(0, 2391, '\p{^CE=- n}', ""); +Expect(0, 2391, '\P{CE=- n}', ""); +Expect(1, 2391, '\P{^CE=- n}', ""); +Expect(0, 2399, '\p{CE=- n}', ""); +Expect(1, 2399, '\p{^CE=- n}', ""); +Expect(1, 2399, '\P{CE=- n}', ""); +Expect(0, 2399, '\P{^CE=- n}', ""); +Error('\p{Is_Composition_Exclusion=/a/ -f}'); +Error('\P{Is_Composition_Exclusion=/a/ -f}'); +Expect(1, 2391, '\p{Is_Composition_Exclusion: f}', ""); +Expect(0, 2391, '\p{^Is_Composition_Exclusion: f}', ""); +Expect(0, 2391, '\P{Is_Composition_Exclusion: f}', ""); +Expect(1, 2391, '\P{^Is_Composition_Exclusion: f}', ""); +Expect(0, 2399, '\p{Is_Composition_Exclusion: f}', ""); +Expect(1, 2399, '\p{^Is_Composition_Exclusion: f}', ""); +Expect(1, 2399, '\P{Is_Composition_Exclusion: f}', ""); +Expect(0, 2399, '\P{^Is_Composition_Exclusion: f}', ""); +Expect(1, 2391, '\p{Is_Composition_Exclusion= F}', ""); +Expect(0, 2391, '\p{^Is_Composition_Exclusion= F}', ""); +Expect(0, 2391, '\P{Is_Composition_Exclusion= F}', ""); +Expect(1, 2391, '\P{^Is_Composition_Exclusion= F}', ""); +Expect(0, 2399, '\p{Is_Composition_Exclusion= F}', ""); +Expect(1, 2399, '\p{^Is_Composition_Exclusion= F}', ""); +Expect(1, 2399, '\P{Is_Composition_Exclusion= F}', ""); +Expect(0, 2399, '\P{^Is_Composition_Exclusion= F}', ""); +Error('\p{Is_CE=:= FALSE}'); +Error('\P{Is_CE=:= FALSE}'); +Expect(1, 2391, '\p{Is_CE=false}', ""); +Expect(0, 2391, '\p{^Is_CE=false}', ""); +Expect(0, 2391, '\P{Is_CE=false}', ""); +Expect(1, 2391, '\P{^Is_CE=false}', ""); +Expect(0, 2399, '\p{Is_CE=false}', ""); +Expect(1, 2399, '\p{^Is_CE=false}', ""); +Expect(1, 2399, '\P{Is_CE=false}', ""); +Expect(0, 2399, '\P{^Is_CE=false}', ""); +Expect(1, 2391, '\p{Is_CE= FALSE}', ""); +Expect(0, 2391, '\p{^Is_CE= FALSE}', ""); +Expect(0, 2391, '\P{Is_CE= FALSE}', ""); +Expect(1, 2391, '\P{^Is_CE= FALSE}', ""); +Expect(0, 2399, '\p{Is_CE= FALSE}', ""); +Expect(1, 2399, '\p{^Is_CE= FALSE}', ""); +Expect(1, 2399, '\P{Is_CE= FALSE}', ""); +Expect(0, 2399, '\P{^Is_CE= FALSE}', ""); +Error('\p{STerm= /a/YES}'); +Error('\P{STerm= /a/YES}'); +Expect(1, 33, '\p{STerm=yes}', ""); +Expect(0, 33, '\p{^STerm=yes}', ""); +Expect(0, 33, '\P{STerm=yes}', ""); +Expect(1, 33, '\P{^STerm=yes}', ""); +Expect(0, 32, '\p{STerm=yes}', ""); +Expect(1, 32, '\p{^STerm=yes}', ""); +Expect(1, 32, '\P{STerm=yes}', ""); +Expect(0, 32, '\P{^STerm=yes}', ""); +Expect(1, 33, '\p{STerm= -Yes}', ""); +Expect(0, 33, '\p{^STerm= -Yes}', ""); +Expect(0, 33, '\P{STerm= -Yes}', ""); +Expect(1, 33, '\P{^STerm= -Yes}', ""); +Expect(0, 32, '\p{STerm= -Yes}', ""); +Expect(1, 32, '\p{^STerm= -Yes}', ""); +Expect(1, 32, '\P{STerm= -Yes}', ""); +Expect(0, 32, '\P{^STerm= -Yes}', ""); +Error('\p{Is_STerm= /a/Y}'); +Error('\P{Is_STerm= /a/Y}'); +Expect(1, 33, '\p{Is_STerm=y}', ""); +Expect(0, 33, '\p{^Is_STerm=y}', ""); +Expect(0, 33, '\P{Is_STerm=y}', ""); +Expect(1, 33, '\P{^Is_STerm=y}', ""); +Expect(0, 32, '\p{Is_STerm=y}', ""); +Expect(1, 32, '\p{^Is_STerm=y}', ""); +Expect(1, 32, '\P{Is_STerm=y}', ""); +Expect(0, 32, '\P{^Is_STerm=y}', ""); +Expect(1, 33, '\p{Is_STerm= Y}', ""); +Expect(0, 33, '\p{^Is_STerm= Y}', ""); +Expect(0, 33, '\P{Is_STerm= Y}', ""); +Expect(1, 33, '\P{^Is_STerm= Y}', ""); +Expect(0, 32, '\p{Is_STerm= Y}', ""); +Expect(1, 32, '\p{^Is_STerm= Y}', ""); +Expect(1, 32, '\P{Is_STerm= Y}', ""); +Expect(0, 32, '\P{^Is_STerm= Y}', ""); +Error('\p{STerm=-T:=}'); +Error('\P{STerm=-T:=}'); +Expect(1, 33, '\p{STerm=t}', ""); +Expect(0, 33, '\p{^STerm=t}', ""); +Expect(0, 33, '\P{STerm=t}', ""); +Expect(1, 33, '\P{^STerm=t}', ""); +Expect(0, 32, '\p{STerm=t}', ""); +Expect(1, 32, '\p{^STerm=t}', ""); +Expect(1, 32, '\P{STerm=t}', ""); +Expect(0, 32, '\P{^STerm=t}', ""); +Expect(1, 33, '\p{STerm=_t}', ""); +Expect(0, 33, '\p{^STerm=_t}', ""); +Expect(0, 33, '\P{STerm=_t}', ""); +Expect(1, 33, '\P{^STerm=_t}', ""); +Expect(0, 32, '\p{STerm=_t}', ""); +Expect(1, 32, '\p{^STerm=_t}', ""); +Expect(1, 32, '\P{STerm=_t}', ""); +Expect(0, 32, '\P{^STerm=_t}', ""); +Error('\p{Is_STerm= True/a/}'); +Error('\P{Is_STerm= True/a/}'); +Expect(1, 33, '\p{Is_STerm:true}', ""); +Expect(0, 33, '\p{^Is_STerm:true}', ""); +Expect(0, 33, '\P{Is_STerm:true}', ""); +Expect(1, 33, '\P{^Is_STerm:true}', ""); +Expect(0, 32, '\p{Is_STerm:true}', ""); +Expect(1, 32, '\p{^Is_STerm:true}', ""); +Expect(1, 32, '\P{Is_STerm:true}', ""); +Expect(0, 32, '\P{^Is_STerm:true}', ""); +Expect(1, 33, '\p{Is_STerm= _True}', ""); +Expect(0, 33, '\p{^Is_STerm= _True}', ""); +Expect(0, 33, '\P{Is_STerm= _True}', ""); +Expect(1, 33, '\P{^Is_STerm= _True}', ""); +Expect(0, 32, '\p{Is_STerm= _True}', ""); +Expect(1, 32, '\p{^Is_STerm= _True}', ""); +Expect(1, 32, '\P{Is_STerm= _True}', ""); +Expect(0, 32, '\P{^Is_STerm= _True}', ""); +Error('\p{STerm=:= no}'); +Error('\P{STerm=:= no}'); +Expect(1, 32, '\p{STerm=no}', ""); +Expect(0, 32, '\p{^STerm=no}', ""); +Expect(0, 32, '\P{STerm=no}', ""); +Expect(1, 32, '\P{^STerm=no}', ""); +Expect(0, 33, '\p{STerm=no}', ""); +Expect(1, 33, '\p{^STerm=no}', ""); +Expect(1, 33, '\P{STerm=no}', ""); +Expect(0, 33, '\P{^STerm=no}', ""); +Expect(1, 32, '\p{STerm= No}', ""); +Expect(0, 32, '\p{^STerm= No}', ""); +Expect(0, 32, '\P{STerm= No}', ""); +Expect(1, 32, '\P{^STerm= No}', ""); +Expect(0, 33, '\p{STerm= No}', ""); +Expect(1, 33, '\p{^STerm= No}', ""); +Expect(1, 33, '\P{STerm= No}', ""); +Expect(0, 33, '\P{^STerm= No}', ""); +Error('\p{Is_STerm=_/a/n}'); +Error('\P{Is_STerm=_/a/n}'); +Expect(1, 32, '\p{Is_STerm=n}', ""); +Expect(0, 32, '\p{^Is_STerm=n}', ""); +Expect(0, 32, '\P{Is_STerm=n}', ""); +Expect(1, 32, '\P{^Is_STerm=n}', ""); +Expect(0, 33, '\p{Is_STerm=n}', ""); +Expect(1, 33, '\p{^Is_STerm=n}', ""); +Expect(1, 33, '\P{Is_STerm=n}', ""); +Expect(0, 33, '\P{^Is_STerm=n}', ""); +Expect(1, 32, '\p{Is_STerm=--n}', ""); +Expect(0, 32, '\p{^Is_STerm=--n}', ""); +Expect(0, 32, '\P{Is_STerm=--n}', ""); +Expect(1, 32, '\P{^Is_STerm=--n}', ""); +Expect(0, 33, '\p{Is_STerm=--n}', ""); +Expect(1, 33, '\p{^Is_STerm=--n}', ""); +Expect(1, 33, '\P{Is_STerm=--n}', ""); +Expect(0, 33, '\P{^Is_STerm=--n}', ""); +Error('\p{STerm=/a/ _F}'); +Error('\P{STerm=/a/ _F}'); +Expect(1, 32, '\p{STerm=f}', ""); +Expect(0, 32, '\p{^STerm=f}', ""); +Expect(0, 32, '\P{STerm=f}', ""); +Expect(1, 32, '\P{^STerm=f}', ""); +Expect(0, 33, '\p{STerm=f}', ""); +Expect(1, 33, '\p{^STerm=f}', ""); +Expect(1, 33, '\P{STerm=f}', ""); +Expect(0, 33, '\P{^STerm=f}', ""); +Expect(1, 32, '\p{STerm= f}', ""); +Expect(0, 32, '\p{^STerm= f}', ""); +Expect(0, 32, '\P{STerm= f}', ""); +Expect(1, 32, '\P{^STerm= f}', ""); +Expect(0, 33, '\p{STerm= f}', ""); +Expect(1, 33, '\p{^STerm= f}', ""); +Expect(1, 33, '\P{STerm= f}', ""); +Expect(0, 33, '\P{^STerm= f}', ""); +Error('\p{Is_STerm=-/a/False}'); +Error('\P{Is_STerm=-/a/False}'); +Expect(1, 32, '\p{Is_STerm=false}', ""); +Expect(0, 32, '\p{^Is_STerm=false}', ""); +Expect(0, 32, '\P{Is_STerm=false}', ""); +Expect(1, 32, '\P{^Is_STerm=false}', ""); +Expect(0, 33, '\p{Is_STerm=false}', ""); +Expect(1, 33, '\p{^Is_STerm=false}', ""); +Expect(1, 33, '\P{Is_STerm=false}', ""); +Expect(0, 33, '\P{^Is_STerm=false}', ""); +Expect(1, 32, '\p{Is_STerm=__False}', ""); +Expect(0, 32, '\p{^Is_STerm=__False}', ""); +Expect(0, 32, '\P{Is_STerm=__False}', ""); +Expect(1, 32, '\P{^Is_STerm=__False}', ""); +Expect(0, 33, '\p{Is_STerm=__False}', ""); +Expect(1, 33, '\p{^Is_STerm=__False}', ""); +Expect(1, 33, '\P{Is_STerm=__False}', ""); +Expect(0, 33, '\P{^Is_STerm=__False}', ""); +Error('\p{Decomposition_Type=:=-fraction}'); +Error('\P{Decomposition_Type=:=-fraction}'); +Expect(1, 8543, '\p{Decomposition_Type=fraction}', ""); +Expect(0, 8543, '\p{^Decomposition_Type=fraction}', ""); +Expect(0, 8543, '\P{Decomposition_Type=fraction}', ""); +Expect(1, 8543, '\P{^Decomposition_Type=fraction}', ""); +Expect(0, 7, '\p{Decomposition_Type=fraction}', ""); +Expect(1, 7, '\p{^Decomposition_Type=fraction}', ""); +Expect(1, 7, '\P{Decomposition_Type=fraction}', ""); +Expect(0, 7, '\P{^Decomposition_Type=fraction}', ""); +Expect(1, 8543, '\p{Decomposition_Type= -fraction}', ""); +Expect(0, 8543, '\p{^Decomposition_Type= -fraction}', ""); +Expect(0, 8543, '\P{Decomposition_Type= -fraction}', ""); +Expect(1, 8543, '\P{^Decomposition_Type= -fraction}', ""); +Expect(0, 7, '\p{Decomposition_Type= -fraction}', ""); +Expect(1, 7, '\p{^Decomposition_Type= -fraction}', ""); +Expect(1, 7, '\P{Decomposition_Type= -fraction}', ""); +Expect(0, 7, '\P{^Decomposition_Type= -fraction}', ""); +Error('\p{Dt=_-Fra:=}'); +Error('\P{Dt=_-Fra:=}'); +Expect(1, 8543, '\p{Dt=fra}', ""); +Expect(0, 8543, '\p{^Dt=fra}', ""); +Expect(0, 8543, '\P{Dt=fra}', ""); +Expect(1, 8543, '\P{^Dt=fra}', ""); +Expect(0, 7, '\p{Dt=fra}', ""); +Expect(1, 7, '\p{^Dt=fra}', ""); +Expect(1, 7, '\P{Dt=fra}', ""); +Expect(0, 7, '\P{^Dt=fra}', ""); +Expect(1, 8543, '\p{Dt=__FRA}', ""); +Expect(0, 8543, '\p{^Dt=__FRA}', ""); +Expect(0, 8543, '\P{Dt=__FRA}', ""); +Expect(1, 8543, '\P{^Dt=__FRA}', ""); +Expect(0, 7, '\p{Dt=__FRA}', ""); +Expect(1, 7, '\p{^Dt=__FRA}', ""); +Expect(1, 7, '\P{Dt=__FRA}', ""); +Expect(0, 7, '\P{^Dt=__FRA}', ""); +Error('\p{Is_Decomposition_Type=-/a/fraction}'); +Error('\P{Is_Decomposition_Type=-/a/fraction}'); +Expect(1, 8543, '\p{Is_Decomposition_Type=fraction}', ""); +Expect(0, 8543, '\p{^Is_Decomposition_Type=fraction}', ""); +Expect(0, 8543, '\P{Is_Decomposition_Type=fraction}', ""); +Expect(1, 8543, '\P{^Is_Decomposition_Type=fraction}', ""); +Expect(0, 7, '\p{Is_Decomposition_Type=fraction}', ""); +Expect(1, 7, '\p{^Is_Decomposition_Type=fraction}', ""); +Expect(1, 7, '\P{Is_Decomposition_Type=fraction}', ""); +Expect(0, 7, '\P{^Is_Decomposition_Type=fraction}', ""); +Expect(1, 8543, '\p{Is_Decomposition_Type= _FRACTION}', ""); +Expect(0, 8543, '\p{^Is_Decomposition_Type= _FRACTION}', ""); +Expect(0, 8543, '\P{Is_Decomposition_Type= _FRACTION}', ""); +Expect(1, 8543, '\P{^Is_Decomposition_Type= _FRACTION}', ""); +Expect(0, 7, '\p{Is_Decomposition_Type= _FRACTION}', ""); +Expect(1, 7, '\p{^Is_Decomposition_Type= _FRACTION}', ""); +Expect(1, 7, '\P{Is_Decomposition_Type= _FRACTION}', ""); +Expect(0, 7, '\P{^Is_Decomposition_Type= _FRACTION}', ""); +Error('\p{Is_Dt= FRA:=}'); +Error('\P{Is_Dt= FRA:=}'); +Expect(1, 8543, '\p{Is_Dt=fra}', ""); +Expect(0, 8543, '\p{^Is_Dt=fra}', ""); +Expect(0, 8543, '\P{Is_Dt=fra}', ""); +Expect(1, 8543, '\P{^Is_Dt=fra}', ""); +Expect(0, 7, '\p{Is_Dt=fra}', ""); +Expect(1, 7, '\p{^Is_Dt=fra}', ""); +Expect(1, 7, '\P{Is_Dt=fra}', ""); +Expect(0, 7, '\P{^Is_Dt=fra}', ""); +Expect(1, 8543, '\p{Is_Dt= _Fra}', ""); +Expect(0, 8543, '\p{^Is_Dt= _Fra}', ""); +Expect(0, 8543, '\P{Is_Dt= _Fra}', ""); +Expect(1, 8543, '\P{^Is_Dt= _Fra}', ""); +Expect(0, 7, '\p{Is_Dt= _Fra}', ""); +Expect(1, 7, '\p{^Is_Dt= _Fra}', ""); +Expect(1, 7, '\P{Is_Dt= _Fra}', ""); +Expect(0, 7, '\P{^Is_Dt= _Fra}', ""); +Error('\p{Decomposition_Type=/a/- CIRCLE}'); +Error('\P{Decomposition_Type=/a/- CIRCLE}'); +Expect(1, 9331, '\p{Decomposition_Type=circle}', ""); +Expect(0, 9331, '\p{^Decomposition_Type=circle}', ""); +Expect(0, 9331, '\P{Decomposition_Type=circle}', ""); +Expect(1, 9331, '\P{^Decomposition_Type=circle}', ""); +Expect(0, 9311, '\p{Decomposition_Type=circle}', ""); +Expect(1, 9311, '\p{^Decomposition_Type=circle}', ""); +Expect(1, 9311, '\P{Decomposition_Type=circle}', ""); +Expect(0, 9311, '\P{^Decomposition_Type=circle}', ""); +Expect(1, 9331, '\p{Decomposition_Type=- Circle}', ""); +Expect(0, 9331, '\p{^Decomposition_Type=- Circle}', ""); +Expect(0, 9331, '\P{Decomposition_Type=- Circle}', ""); +Expect(1, 9331, '\P{^Decomposition_Type=- Circle}', ""); +Expect(0, 9311, '\p{Decomposition_Type=- Circle}', ""); +Expect(1, 9311, '\p{^Decomposition_Type=- Circle}', ""); +Expect(1, 9311, '\P{Decomposition_Type=- Circle}', ""); +Expect(0, 9311, '\P{^Decomposition_Type=- Circle}', ""); +Error('\p{Dt: -_enc/a/}'); +Error('\P{Dt: -_enc/a/}'); +Expect(1, 9331, '\p{Dt=enc}', ""); +Expect(0, 9331, '\p{^Dt=enc}', ""); +Expect(0, 9331, '\P{Dt=enc}', ""); +Expect(1, 9331, '\P{^Dt=enc}', ""); +Expect(0, 9311, '\p{Dt=enc}', ""); +Expect(1, 9311, '\p{^Dt=enc}', ""); +Expect(1, 9311, '\P{Dt=enc}', ""); +Expect(0, 9311, '\P{^Dt=enc}', ""); +Expect(1, 9331, '\p{Dt= Enc}', ""); +Expect(0, 9331, '\p{^Dt= Enc}', ""); +Expect(0, 9331, '\P{Dt= Enc}', ""); +Expect(1, 9331, '\P{^Dt= Enc}', ""); +Expect(0, 9311, '\p{Dt= Enc}', ""); +Expect(1, 9311, '\p{^Dt= Enc}', ""); +Expect(1, 9311, '\P{Dt= Enc}', ""); +Expect(0, 9311, '\P{^Dt= Enc}', ""); +Error('\p{Is_Decomposition_Type=- circle:=}'); +Error('\P{Is_Decomposition_Type=- circle:=}'); +Expect(1, 9331, '\p{Is_Decomposition_Type=circle}', ""); +Expect(0, 9331, '\p{^Is_Decomposition_Type=circle}', ""); +Expect(0, 9331, '\P{Is_Decomposition_Type=circle}', ""); +Expect(1, 9331, '\P{^Is_Decomposition_Type=circle}', ""); +Expect(0, 9311, '\p{Is_Decomposition_Type=circle}', ""); +Expect(1, 9311, '\p{^Is_Decomposition_Type=circle}', ""); +Expect(1, 9311, '\P{Is_Decomposition_Type=circle}', ""); +Expect(0, 9311, '\P{^Is_Decomposition_Type=circle}', ""); +Expect(1, 9331, '\p{Is_Decomposition_Type= Circle}', ""); +Expect(0, 9331, '\p{^Is_Decomposition_Type= Circle}', ""); +Expect(0, 9331, '\P{Is_Decomposition_Type= Circle}', ""); +Expect(1, 9331, '\P{^Is_Decomposition_Type= Circle}', ""); +Expect(0, 9311, '\p{Is_Decomposition_Type= Circle}', ""); +Expect(1, 9311, '\p{^Is_Decomposition_Type= Circle}', ""); +Expect(1, 9311, '\P{Is_Decomposition_Type= Circle}', ""); +Expect(0, 9311, '\P{^Is_Decomposition_Type= Circle}', ""); +Error('\p{Is_Dt=:=-ENC}'); +Error('\P{Is_Dt=:=-ENC}'); +Expect(1, 9331, '\p{Is_Dt: enc}', ""); +Expect(0, 9331, '\p{^Is_Dt: enc}', ""); +Expect(0, 9331, '\P{Is_Dt: enc}', ""); +Expect(1, 9331, '\P{^Is_Dt: enc}', ""); +Expect(0, 9311, '\p{Is_Dt: enc}', ""); +Expect(1, 9311, '\p{^Is_Dt: enc}', ""); +Expect(1, 9311, '\P{Is_Dt: enc}', ""); +Expect(0, 9311, '\P{^Is_Dt: enc}', ""); +Expect(1, 9331, '\p{Is_Dt= enc}', ""); +Expect(0, 9331, '\p{^Is_Dt= enc}', ""); +Expect(0, 9331, '\P{Is_Dt= enc}', ""); +Expect(1, 9331, '\P{^Is_Dt= enc}', ""); +Expect(0, 9311, '\p{Is_Dt= enc}', ""); +Expect(1, 9311, '\p{^Is_Dt= enc}', ""); +Expect(1, 9311, '\P{Is_Dt= enc}', ""); +Expect(0, 9311, '\P{^Is_Dt= enc}', ""); +Error('\p{Decomposition_Type= /a/INITIAL}'); +Error('\P{Decomposition_Type= /a/INITIAL}'); +Expect(1, 64340, '\p{Decomposition_Type=initial}', ""); +Expect(0, 64340, '\p{^Decomposition_Type=initial}', ""); +Expect(0, 64340, '\P{Decomposition_Type=initial}', ""); +Expect(1, 64340, '\P{^Decomposition_Type=initial}', ""); +Expect(0, 64339, '\p{Decomposition_Type=initial}', ""); +Expect(1, 64339, '\p{^Decomposition_Type=initial}', ""); +Expect(1, 64339, '\P{Decomposition_Type=initial}', ""); +Expect(0, 64339, '\P{^Decomposition_Type=initial}', ""); +Expect(1, 64340, '\p{Decomposition_Type= Initial}', ""); +Expect(0, 64340, '\p{^Decomposition_Type= Initial}', ""); +Expect(0, 64340, '\P{Decomposition_Type= Initial}', ""); +Expect(1, 64340, '\P{^Decomposition_Type= Initial}', ""); +Expect(0, 64339, '\p{Decomposition_Type= Initial}', ""); +Expect(1, 64339, '\p{^Decomposition_Type= Initial}', ""); +Expect(1, 64339, '\P{Decomposition_Type= Initial}', ""); +Expect(0, 64339, '\P{^Decomposition_Type= Initial}', ""); +Error('\p{Dt=:=-init}'); +Error('\P{Dt=:=-init}'); +Expect(1, 64340, '\p{Dt=init}', ""); +Expect(0, 64340, '\p{^Dt=init}', ""); +Expect(0, 64340, '\P{Dt=init}', ""); +Expect(1, 64340, '\P{^Dt=init}', ""); +Expect(0, 64339, '\p{Dt=init}', ""); +Expect(1, 64339, '\p{^Dt=init}', ""); +Expect(1, 64339, '\P{Dt=init}', ""); +Expect(0, 64339, '\P{^Dt=init}', ""); +Expect(1, 64340, '\p{Dt= -INIT}', ""); +Expect(0, 64340, '\p{^Dt= -INIT}', ""); +Expect(0, 64340, '\P{Dt= -INIT}', ""); +Expect(1, 64340, '\P{^Dt= -INIT}', ""); +Expect(0, 64339, '\p{Dt= -INIT}', ""); +Expect(1, 64339, '\p{^Dt= -INIT}', ""); +Expect(1, 64339, '\P{Dt= -INIT}', ""); +Expect(0, 64339, '\P{^Dt= -INIT}', ""); +Error('\p{Is_Decomposition_Type=/a/Initial}'); +Error('\P{Is_Decomposition_Type=/a/Initial}'); +Expect(1, 64340, '\p{Is_Decomposition_Type=initial}', ""); +Expect(0, 64340, '\p{^Is_Decomposition_Type=initial}', ""); +Expect(0, 64340, '\P{Is_Decomposition_Type=initial}', ""); +Expect(1, 64340, '\P{^Is_Decomposition_Type=initial}', ""); +Expect(0, 64339, '\p{Is_Decomposition_Type=initial}', ""); +Expect(1, 64339, '\p{^Is_Decomposition_Type=initial}', ""); +Expect(1, 64339, '\P{Is_Decomposition_Type=initial}', ""); +Expect(0, 64339, '\P{^Is_Decomposition_Type=initial}', ""); +Expect(1, 64340, '\p{Is_Decomposition_Type= Initial}', ""); +Expect(0, 64340, '\p{^Is_Decomposition_Type= Initial}', ""); +Expect(0, 64340, '\P{Is_Decomposition_Type= Initial}', ""); +Expect(1, 64340, '\P{^Is_Decomposition_Type= Initial}', ""); +Expect(0, 64339, '\p{Is_Decomposition_Type= Initial}', ""); +Expect(1, 64339, '\p{^Is_Decomposition_Type= Initial}', ""); +Expect(1, 64339, '\P{Is_Decomposition_Type= Initial}', ""); +Expect(0, 64339, '\P{^Is_Decomposition_Type= Initial}', ""); +Error('\p{Is_Dt=:=--Init}'); +Error('\P{Is_Dt=:=--Init}'); +Expect(1, 64340, '\p{Is_Dt: init}', ""); +Expect(0, 64340, '\p{^Is_Dt: init}', ""); +Expect(0, 64340, '\P{Is_Dt: init}', ""); +Expect(1, 64340, '\P{^Is_Dt: init}', ""); +Expect(0, 64339, '\p{Is_Dt: init}', ""); +Expect(1, 64339, '\p{^Is_Dt: init}', ""); +Expect(1, 64339, '\P{Is_Dt: init}', ""); +Expect(0, 64339, '\P{^Is_Dt: init}', ""); +Expect(1, 64340, '\p{Is_Dt= Init}', ""); +Expect(0, 64340, '\p{^Is_Dt= Init}', ""); +Expect(0, 64340, '\P{Is_Dt= Init}', ""); +Expect(1, 64340, '\P{^Is_Dt= Init}', ""); +Expect(0, 64339, '\p{Is_Dt= Init}', ""); +Expect(1, 64339, '\p{^Is_Dt= Init}', ""); +Expect(1, 64339, '\P{Is_Dt= Init}', ""); +Expect(0, 64339, '\P{^Is_Dt= Init}', ""); +Error('\p{Decomposition_Type=:= -font}'); +Error('\P{Decomposition_Type=:= -font}'); +Expect(1, 8450, '\p{Decomposition_Type=font}', ""); +Expect(0, 8450, '\p{^Decomposition_Type=font}', ""); +Expect(0, 8450, '\P{Decomposition_Type=font}', ""); +Expect(1, 8450, '\P{^Decomposition_Type=font}', ""); +Expect(0, 8449, '\p{Decomposition_Type=font}', ""); +Expect(1, 8449, '\p{^Decomposition_Type=font}', ""); +Expect(1, 8449, '\P{Decomposition_Type=font}', ""); +Expect(0, 8449, '\P{^Decomposition_Type=font}', ""); +Expect(1, 8450, '\p{Decomposition_Type= font}', ""); +Expect(0, 8450, '\p{^Decomposition_Type= font}', ""); +Expect(0, 8450, '\P{Decomposition_Type= font}', ""); +Expect(1, 8450, '\P{^Decomposition_Type= font}', ""); +Expect(0, 8449, '\p{Decomposition_Type= font}', ""); +Expect(1, 8449, '\p{^Decomposition_Type= font}', ""); +Expect(1, 8449, '\P{Decomposition_Type= font}', ""); +Expect(0, 8449, '\P{^Decomposition_Type= font}', ""); +Error('\p{Dt=:=--font}'); +Error('\P{Dt=:=--font}'); +Expect(1, 8450, '\p{Dt=font}', ""); +Expect(0, 8450, '\p{^Dt=font}', ""); +Expect(0, 8450, '\P{Dt=font}', ""); +Expect(1, 8450, '\P{^Dt=font}', ""); +Expect(0, 8449, '\p{Dt=font}', ""); +Expect(1, 8449, '\p{^Dt=font}', ""); +Expect(1, 8449, '\P{Dt=font}', ""); +Expect(0, 8449, '\P{^Dt=font}', ""); +Expect(1, 8450, '\p{Dt=-Font}', ""); +Expect(0, 8450, '\p{^Dt=-Font}', ""); +Expect(0, 8450, '\P{Dt=-Font}', ""); +Expect(1, 8450, '\P{^Dt=-Font}', ""); +Expect(0, 8449, '\p{Dt=-Font}', ""); +Expect(1, 8449, '\p{^Dt=-Font}', ""); +Expect(1, 8449, '\P{Dt=-Font}', ""); +Expect(0, 8449, '\P{^Dt=-Font}', ""); +Error('\p{Is_Decomposition_Type= FONT:=}'); +Error('\P{Is_Decomposition_Type= FONT:=}'); +Expect(1, 8450, '\p{Is_Decomposition_Type:font}', ""); +Expect(0, 8450, '\p{^Is_Decomposition_Type:font}', ""); +Expect(0, 8450, '\P{Is_Decomposition_Type:font}', ""); +Expect(1, 8450, '\P{^Is_Decomposition_Type:font}', ""); +Expect(0, 8449, '\p{Is_Decomposition_Type:font}', ""); +Expect(1, 8449, '\p{^Is_Decomposition_Type:font}', ""); +Expect(1, 8449, '\P{Is_Decomposition_Type:font}', ""); +Expect(0, 8449, '\P{^Is_Decomposition_Type:font}', ""); +Expect(1, 8450, '\p{Is_Decomposition_Type=- FONT}', ""); +Expect(0, 8450, '\p{^Is_Decomposition_Type=- FONT}', ""); +Expect(0, 8450, '\P{Is_Decomposition_Type=- FONT}', ""); +Expect(1, 8450, '\P{^Is_Decomposition_Type=- FONT}', ""); +Expect(0, 8449, '\p{Is_Decomposition_Type=- FONT}', ""); +Expect(1, 8449, '\p{^Is_Decomposition_Type=- FONT}', ""); +Expect(1, 8449, '\P{Is_Decomposition_Type=- FONT}', ""); +Expect(0, 8449, '\P{^Is_Decomposition_Type=- FONT}', ""); +Error('\p{Is_Dt=_-FONT:=}'); +Error('\P{Is_Dt=_-FONT:=}'); +Expect(1, 8450, '\p{Is_Dt=font}', ""); +Expect(0, 8450, '\p{^Is_Dt=font}', ""); +Expect(0, 8450, '\P{Is_Dt=font}', ""); +Expect(1, 8450, '\P{^Is_Dt=font}', ""); +Expect(0, 8449, '\p{Is_Dt=font}', ""); +Expect(1, 8449, '\p{^Is_Dt=font}', ""); +Expect(1, 8449, '\P{Is_Dt=font}', ""); +Expect(0, 8449, '\P{^Is_Dt=font}', ""); +Expect(1, 8450, '\p{Is_Dt=--FONT}', ""); +Expect(0, 8450, '\p{^Is_Dt=--FONT}', ""); +Expect(0, 8450, '\P{Is_Dt=--FONT}', ""); +Expect(1, 8450, '\P{^Is_Dt=--FONT}', ""); +Expect(0, 8449, '\p{Is_Dt=--FONT}', ""); +Expect(1, 8449, '\p{^Is_Dt=--FONT}', ""); +Expect(1, 8449, '\P{Is_Dt=--FONT}', ""); +Expect(0, 8449, '\P{^Is_Dt=--FONT}', ""); +Error('\p{Decomposition_Type=/a/ -Nobreak}'); +Error('\P{Decomposition_Type=/a/ -Nobreak}'); +Expect(1, 3852, '\p{Decomposition_Type=nobreak}', ""); +Expect(0, 3852, '\p{^Decomposition_Type=nobreak}', ""); +Expect(0, 3852, '\P{Decomposition_Type=nobreak}', ""); +Expect(1, 3852, '\P{^Decomposition_Type=nobreak}', ""); +Expect(0, 7, '\p{Decomposition_Type=nobreak}', ""); +Expect(1, 7, '\p{^Decomposition_Type=nobreak}', ""); +Expect(1, 7, '\P{Decomposition_Type=nobreak}', ""); +Expect(0, 7, '\P{^Decomposition_Type=nobreak}', ""); +Expect(1, 3852, '\p{Decomposition_Type= -Nobreak}', ""); +Expect(0, 3852, '\p{^Decomposition_Type= -Nobreak}', ""); +Expect(0, 3852, '\P{Decomposition_Type= -Nobreak}', ""); +Expect(1, 3852, '\P{^Decomposition_Type= -Nobreak}', ""); +Expect(0, 7, '\p{Decomposition_Type= -Nobreak}', ""); +Expect(1, 7, '\p{^Decomposition_Type= -Nobreak}', ""); +Expect(1, 7, '\P{Decomposition_Type= -Nobreak}', ""); +Expect(0, 7, '\P{^Decomposition_Type= -Nobreak}', ""); +Error('\p{Dt=nb/a/}'); +Error('\P{Dt=nb/a/}'); +Expect(1, 3852, '\p{Dt=nb}', ""); +Expect(0, 3852, '\p{^Dt=nb}', ""); +Expect(0, 3852, '\P{Dt=nb}', ""); +Expect(1, 3852, '\P{^Dt=nb}', ""); +Expect(0, 7, '\p{Dt=nb}', ""); +Expect(1, 7, '\p{^Dt=nb}', ""); +Expect(1, 7, '\P{Dt=nb}', ""); +Expect(0, 7, '\P{^Dt=nb}', ""); +Expect(1, 3852, '\p{Dt= -Nb}', ""); +Expect(0, 3852, '\p{^Dt= -Nb}', ""); +Expect(0, 3852, '\P{Dt= -Nb}', ""); +Expect(1, 3852, '\P{^Dt= -Nb}', ""); +Expect(0, 7, '\p{Dt= -Nb}', ""); +Expect(1, 7, '\p{^Dt= -Nb}', ""); +Expect(1, 7, '\P{Dt= -Nb}', ""); +Expect(0, 7, '\P{^Dt= -Nb}', ""); +Error('\p{Is_Decomposition_Type=/a/Nobreak}'); +Error('\P{Is_Decomposition_Type=/a/Nobreak}'); +Expect(1, 3852, '\p{Is_Decomposition_Type=nobreak}', ""); +Expect(0, 3852, '\p{^Is_Decomposition_Type=nobreak}', ""); +Expect(0, 3852, '\P{Is_Decomposition_Type=nobreak}', ""); +Expect(1, 3852, '\P{^Is_Decomposition_Type=nobreak}', ""); +Expect(0, 7, '\p{Is_Decomposition_Type=nobreak}', ""); +Expect(1, 7, '\p{^Is_Decomposition_Type=nobreak}', ""); +Expect(1, 7, '\P{Is_Decomposition_Type=nobreak}', ""); +Expect(0, 7, '\P{^Is_Decomposition_Type=nobreak}', ""); +Expect(1, 3852, '\p{Is_Decomposition_Type= -nobreak}', ""); +Expect(0, 3852, '\p{^Is_Decomposition_Type= -nobreak}', ""); +Expect(0, 3852, '\P{Is_Decomposition_Type= -nobreak}', ""); +Expect(1, 3852, '\P{^Is_Decomposition_Type= -nobreak}', ""); +Expect(0, 7, '\p{Is_Decomposition_Type= -nobreak}', ""); +Expect(1, 7, '\p{^Is_Decomposition_Type= -nobreak}', ""); +Expect(1, 7, '\P{Is_Decomposition_Type= -nobreak}', ""); +Expect(0, 7, '\P{^Is_Decomposition_Type= -nobreak}', ""); +Error('\p{Is_Dt=:=_nb}'); +Error('\P{Is_Dt=:=_nb}'); +Expect(1, 3852, '\p{Is_Dt=nb}', ""); +Expect(0, 3852, '\p{^Is_Dt=nb}', ""); +Expect(0, 3852, '\P{Is_Dt=nb}', ""); +Expect(1, 3852, '\P{^Is_Dt=nb}', ""); +Expect(0, 7, '\p{Is_Dt=nb}', ""); +Expect(1, 7, '\p{^Is_Dt=nb}', ""); +Expect(1, 7, '\P{Is_Dt=nb}', ""); +Expect(0, 7, '\P{^Is_Dt=nb}', ""); +Expect(1, 3852, '\p{Is_Dt=__Nb}', ""); +Expect(0, 3852, '\p{^Is_Dt=__Nb}', ""); +Expect(0, 3852, '\P{Is_Dt=__Nb}', ""); +Expect(1, 3852, '\P{^Is_Dt=__Nb}', ""); +Expect(0, 7, '\p{Is_Dt=__Nb}', ""); +Expect(1, 7, '\p{^Is_Dt=__Nb}', ""); +Expect(1, 7, '\P{Is_Dt=__Nb}', ""); +Expect(0, 7, '\P{^Is_Dt=__Nb}', ""); +Error('\p{Decomposition_Type= _Non:=Canonical}'); +Error('\P{Decomposition_Type= _Non:=Canonical}'); +Expect(1, 307, '\p{Decomposition_Type=noncanonical}', ""); +Expect(0, 307, '\p{^Decomposition_Type=noncanonical}', ""); +Expect(0, 307, '\P{Decomposition_Type=noncanonical}', ""); +Expect(1, 307, '\P{^Decomposition_Type=noncanonical}', ""); +Expect(0, 7, '\p{Decomposition_Type=noncanonical}', ""); +Expect(1, 7, '\p{^Decomposition_Type=noncanonical}', ""); +Expect(1, 7, '\P{Decomposition_Type=noncanonical}', ""); +Expect(0, 7, '\P{^Decomposition_Type=noncanonical}', ""); +Expect(1, 307, '\p{Decomposition_Type=_non canonical}', ""); +Expect(0, 307, '\p{^Decomposition_Type=_non canonical}', ""); +Expect(0, 307, '\P{Decomposition_Type=_non canonical}', ""); +Expect(1, 307, '\P{^Decomposition_Type=_non canonical}', ""); +Expect(0, 7, '\p{Decomposition_Type=_non canonical}', ""); +Expect(1, 7, '\p{^Decomposition_Type=_non canonical}', ""); +Expect(1, 7, '\P{Decomposition_Type=_non canonical}', ""); +Expect(0, 7, '\P{^Decomposition_Type=_non canonical}', ""); +Error('\p{Dt=__Non-canon:=}'); +Error('\P{Dt=__Non-canon:=}'); +Expect(1, 307, '\p{Dt=noncanon}', ""); +Expect(0, 307, '\p{^Dt=noncanon}', ""); +Expect(0, 307, '\P{Dt=noncanon}', ""); +Expect(1, 307, '\P{^Dt=noncanon}', ""); +Expect(0, 7, '\p{Dt=noncanon}', ""); +Expect(1, 7, '\p{^Dt=noncanon}', ""); +Expect(1, 7, '\P{Dt=noncanon}', ""); +Expect(0, 7, '\P{^Dt=noncanon}', ""); +Expect(1, 307, '\p{Dt=_ NON_canon}', ""); +Expect(0, 307, '\p{^Dt=_ NON_canon}', ""); +Expect(0, 307, '\P{Dt=_ NON_canon}', ""); +Expect(1, 307, '\P{^Dt=_ NON_canon}', ""); +Expect(0, 7, '\p{Dt=_ NON_canon}', ""); +Expect(1, 7, '\p{^Dt=_ NON_canon}', ""); +Expect(1, 7, '\P{Dt=_ NON_canon}', ""); +Expect(0, 7, '\P{^Dt=_ NON_canon}', ""); +Error('\p{Is_Decomposition_Type= /a/Non Canonical}'); +Error('\P{Is_Decomposition_Type= /a/Non Canonical}'); +Expect(1, 307, '\p{Is_Decomposition_Type=noncanonical}', ""); +Expect(0, 307, '\p{^Is_Decomposition_Type=noncanonical}', ""); +Expect(0, 307, '\P{Is_Decomposition_Type=noncanonical}', ""); +Expect(1, 307, '\P{^Is_Decomposition_Type=noncanonical}', ""); +Expect(0, 7, '\p{Is_Decomposition_Type=noncanonical}', ""); +Expect(1, 7, '\p{^Is_Decomposition_Type=noncanonical}', ""); +Expect(1, 7, '\P{Is_Decomposition_Type=noncanonical}', ""); +Expect(0, 7, '\P{^Is_Decomposition_Type=noncanonical}', ""); +Expect(1, 307, '\p{Is_Decomposition_Type= -NON-canonical}', ""); +Expect(0, 307, '\p{^Is_Decomposition_Type= -NON-canonical}', ""); +Expect(0, 307, '\P{Is_Decomposition_Type= -NON-canonical}', ""); +Expect(1, 307, '\P{^Is_Decomposition_Type= -NON-canonical}', ""); +Expect(0, 7, '\p{Is_Decomposition_Type= -NON-canonical}', ""); +Expect(1, 7, '\p{^Is_Decomposition_Type= -NON-canonical}', ""); +Expect(1, 7, '\P{Is_Decomposition_Type= -NON-canonical}', ""); +Expect(0, 7, '\P{^Is_Decomposition_Type= -NON-canonical}', ""); +Error('\p{Is_Dt=:= Non Canon}'); +Error('\P{Is_Dt=:= Non Canon}'); +Expect(1, 307, '\p{Is_Dt=noncanon}', ""); +Expect(0, 307, '\p{^Is_Dt=noncanon}', ""); +Expect(0, 307, '\P{Is_Dt=noncanon}', ""); +Expect(1, 307, '\P{^Is_Dt=noncanon}', ""); +Expect(0, 7, '\p{Is_Dt=noncanon}', ""); +Expect(1, 7, '\p{^Is_Dt=noncanon}', ""); +Expect(1, 7, '\P{Is_Dt=noncanon}', ""); +Expect(0, 7, '\P{^Is_Dt=noncanon}', ""); +Expect(1, 307, '\p{Is_Dt=_noncanon}', ""); +Expect(0, 307, '\p{^Is_Dt=_noncanon}', ""); +Expect(0, 307, '\P{Is_Dt=_noncanon}', ""); +Expect(1, 307, '\P{^Is_Dt=_noncanon}', ""); +Expect(0, 7, '\p{Is_Dt=_noncanon}', ""); +Expect(1, 7, '\p{^Is_Dt=_noncanon}', ""); +Expect(1, 7, '\P{Is_Dt=_noncanon}', ""); +Expect(0, 7, '\P{^Is_Dt=_noncanon}', ""); +Error('\p{Decomposition_Type=:= Final}'); +Error('\P{Decomposition_Type=:= Final}'); +Expect(1, 64337, '\p{Decomposition_Type=final}', ""); +Expect(0, 64337, '\p{^Decomposition_Type=final}', ""); +Expect(0, 64337, '\P{Decomposition_Type=final}', ""); +Expect(1, 64337, '\P{^Decomposition_Type=final}', ""); +Expect(0, 64336, '\p{Decomposition_Type=final}', ""); +Expect(1, 64336, '\p{^Decomposition_Type=final}', ""); +Expect(1, 64336, '\P{Decomposition_Type=final}', ""); +Expect(0, 64336, '\P{^Decomposition_Type=final}', ""); +Expect(1, 64337, '\p{Decomposition_Type: _Final}', ""); +Expect(0, 64337, '\p{^Decomposition_Type: _Final}', ""); +Expect(0, 64337, '\P{Decomposition_Type: _Final}', ""); +Expect(1, 64337, '\P{^Decomposition_Type: _Final}', ""); +Expect(0, 64336, '\p{Decomposition_Type: _Final}', ""); +Expect(1, 64336, '\p{^Decomposition_Type: _Final}', ""); +Expect(1, 64336, '\P{Decomposition_Type: _Final}', ""); +Expect(0, 64336, '\P{^Decomposition_Type: _Final}', ""); +Error('\p{Dt=/a/_ Fin}'); +Error('\P{Dt=/a/_ Fin}'); +Expect(1, 64337, '\p{Dt=fin}', ""); +Expect(0, 64337, '\p{^Dt=fin}', ""); +Expect(0, 64337, '\P{Dt=fin}', ""); +Expect(1, 64337, '\P{^Dt=fin}', ""); +Expect(0, 64336, '\p{Dt=fin}', ""); +Expect(1, 64336, '\p{^Dt=fin}', ""); +Expect(1, 64336, '\P{Dt=fin}', ""); +Expect(0, 64336, '\P{^Dt=fin}', ""); +Expect(1, 64337, '\p{Dt= _Fin}', ""); +Expect(0, 64337, '\p{^Dt= _Fin}', ""); +Expect(0, 64337, '\P{Dt= _Fin}', ""); +Expect(1, 64337, '\P{^Dt= _Fin}', ""); +Expect(0, 64336, '\p{Dt= _Fin}', ""); +Expect(1, 64336, '\p{^Dt= _Fin}', ""); +Expect(1, 64336, '\P{Dt= _Fin}', ""); +Expect(0, 64336, '\P{^Dt= _Fin}', ""); +Error('\p{Is_Decomposition_Type=_Final:=}'); +Error('\P{Is_Decomposition_Type=_Final:=}'); +Expect(1, 64337, '\p{Is_Decomposition_Type=final}', ""); +Expect(0, 64337, '\p{^Is_Decomposition_Type=final}', ""); +Expect(0, 64337, '\P{Is_Decomposition_Type=final}', ""); +Expect(1, 64337, '\P{^Is_Decomposition_Type=final}', ""); +Expect(0, 64336, '\p{Is_Decomposition_Type=final}', ""); +Expect(1, 64336, '\p{^Is_Decomposition_Type=final}', ""); +Expect(1, 64336, '\P{Is_Decomposition_Type=final}', ""); +Expect(0, 64336, '\P{^Is_Decomposition_Type=final}', ""); +Expect(1, 64337, '\p{Is_Decomposition_Type= final}', ""); +Expect(0, 64337, '\p{^Is_Decomposition_Type= final}', ""); +Expect(0, 64337, '\P{Is_Decomposition_Type= final}', ""); +Expect(1, 64337, '\P{^Is_Decomposition_Type= final}', ""); +Expect(0, 64336, '\p{Is_Decomposition_Type= final}', ""); +Expect(1, 64336, '\p{^Is_Decomposition_Type= final}', ""); +Expect(1, 64336, '\P{Is_Decomposition_Type= final}', ""); +Expect(0, 64336, '\P{^Is_Decomposition_Type= final}', ""); +Error('\p{Is_Dt=:=--Fin}'); +Error('\P{Is_Dt=:=--Fin}'); +Expect(1, 64337, '\p{Is_Dt=fin}', ""); +Expect(0, 64337, '\p{^Is_Dt=fin}', ""); +Expect(0, 64337, '\P{Is_Dt=fin}', ""); +Expect(1, 64337, '\P{^Is_Dt=fin}', ""); +Expect(0, 64336, '\p{Is_Dt=fin}', ""); +Expect(1, 64336, '\p{^Is_Dt=fin}', ""); +Expect(1, 64336, '\P{Is_Dt=fin}', ""); +Expect(0, 64336, '\P{^Is_Dt=fin}', ""); +Expect(1, 64337, '\p{Is_Dt= fin}', ""); +Expect(0, 64337, '\p{^Is_Dt= fin}', ""); +Expect(0, 64337, '\P{Is_Dt= fin}', ""); +Expect(1, 64337, '\P{^Is_Dt= fin}', ""); +Expect(0, 64336, '\p{Is_Dt= fin}', ""); +Expect(1, 64336, '\p{^Is_Dt= fin}', ""); +Expect(1, 64336, '\P{Is_Dt= fin}', ""); +Expect(0, 64336, '\P{^Is_Dt= fin}', ""); +Error('\p{Decomposition_Type=:= wide}'); +Error('\P{Decomposition_Type=:= wide}'); +Expect(1, 12288, '\p{Decomposition_Type=wide}', ""); +Expect(0, 12288, '\p{^Decomposition_Type=wide}', ""); +Expect(0, 12288, '\P{Decomposition_Type=wide}', ""); +Expect(1, 12288, '\P{^Decomposition_Type=wide}', ""); +Expect(0, 12287, '\p{Decomposition_Type=wide}', ""); +Expect(1, 12287, '\p{^Decomposition_Type=wide}', ""); +Expect(1, 12287, '\P{Decomposition_Type=wide}', ""); +Expect(0, 12287, '\P{^Decomposition_Type=wide}', ""); +Expect(1, 12288, '\p{Decomposition_Type=- wide}', ""); +Expect(0, 12288, '\p{^Decomposition_Type=- wide}', ""); +Expect(0, 12288, '\P{Decomposition_Type=- wide}', ""); +Expect(1, 12288, '\P{^Decomposition_Type=- wide}', ""); +Expect(0, 12287, '\p{Decomposition_Type=- wide}', ""); +Expect(1, 12287, '\p{^Decomposition_Type=- wide}', ""); +Expect(1, 12287, '\P{Decomposition_Type=- wide}', ""); +Expect(0, 12287, '\P{^Decomposition_Type=- wide}', ""); +Error('\p{Dt=-/a/Wide}'); +Error('\P{Dt=-/a/Wide}'); +Expect(1, 12288, '\p{Dt=wide}', ""); +Expect(0, 12288, '\p{^Dt=wide}', ""); +Expect(0, 12288, '\P{Dt=wide}', ""); +Expect(1, 12288, '\P{^Dt=wide}', ""); +Expect(0, 12287, '\p{Dt=wide}', ""); +Expect(1, 12287, '\p{^Dt=wide}', ""); +Expect(1, 12287, '\P{Dt=wide}', ""); +Expect(0, 12287, '\P{^Dt=wide}', ""); +Expect(1, 12288, '\p{Dt= Wide}', ""); +Expect(0, 12288, '\p{^Dt= Wide}', ""); +Expect(0, 12288, '\P{Dt= Wide}', ""); +Expect(1, 12288, '\P{^Dt= Wide}', ""); +Expect(0, 12287, '\p{Dt= Wide}', ""); +Expect(1, 12287, '\p{^Dt= Wide}', ""); +Expect(1, 12287, '\P{Dt= Wide}', ""); +Expect(0, 12287, '\P{^Dt= Wide}', ""); +Error('\p{Is_Decomposition_Type: /a/ Wide}'); +Error('\P{Is_Decomposition_Type: /a/ Wide}'); +Expect(1, 12288, '\p{Is_Decomposition_Type=wide}', ""); +Expect(0, 12288, '\p{^Is_Decomposition_Type=wide}', ""); +Expect(0, 12288, '\P{Is_Decomposition_Type=wide}', ""); +Expect(1, 12288, '\P{^Is_Decomposition_Type=wide}', ""); +Expect(0, 12287, '\p{Is_Decomposition_Type=wide}', ""); +Expect(1, 12287, '\p{^Is_Decomposition_Type=wide}', ""); +Expect(1, 12287, '\P{Is_Decomposition_Type=wide}', ""); +Expect(0, 12287, '\P{^Is_Decomposition_Type=wide}', ""); +Expect(1, 12288, '\p{Is_Decomposition_Type= WIDE}', ""); +Expect(0, 12288, '\p{^Is_Decomposition_Type= WIDE}', ""); +Expect(0, 12288, '\P{Is_Decomposition_Type= WIDE}', ""); +Expect(1, 12288, '\P{^Is_Decomposition_Type= WIDE}', ""); +Expect(0, 12287, '\p{Is_Decomposition_Type= WIDE}', ""); +Expect(1, 12287, '\p{^Is_Decomposition_Type= WIDE}', ""); +Expect(1, 12287, '\P{Is_Decomposition_Type= WIDE}', ""); +Expect(0, 12287, '\P{^Is_Decomposition_Type= WIDE}', ""); +Error('\p{Is_Dt=/a/ Wide}'); +Error('\P{Is_Dt=/a/ Wide}'); +Expect(1, 12288, '\p{Is_Dt=wide}', ""); +Expect(0, 12288, '\p{^Is_Dt=wide}', ""); +Expect(0, 12288, '\P{Is_Dt=wide}', ""); +Expect(1, 12288, '\P{^Is_Dt=wide}', ""); +Expect(0, 12287, '\p{Is_Dt=wide}', ""); +Expect(1, 12287, '\p{^Is_Dt=wide}', ""); +Expect(1, 12287, '\P{Is_Dt=wide}', ""); +Expect(0, 12287, '\P{^Is_Dt=wide}', ""); +Expect(1, 12288, '\p{Is_Dt= -Wide}', ""); +Expect(0, 12288, '\p{^Is_Dt= -Wide}', ""); +Expect(0, 12288, '\P{Is_Dt= -Wide}', ""); +Expect(1, 12288, '\P{^Is_Dt= -Wide}', ""); +Expect(0, 12287, '\p{Is_Dt= -Wide}', ""); +Expect(1, 12287, '\p{^Is_Dt= -Wide}', ""); +Expect(1, 12287, '\P{Is_Dt= -Wide}', ""); +Expect(0, 12287, '\P{^Is_Dt= -Wide}', ""); +Error('\p{Decomposition_Type=:=CANONICAL}'); +Error('\P{Decomposition_Type=:=CANONICAL}'); +Expect(1, 271, '\p{Decomposition_Type=canonical}', ""); +Expect(0, 271, '\p{^Decomposition_Type=canonical}', ""); +Expect(0, 271, '\P{Decomposition_Type=canonical}', ""); +Expect(1, 271, '\P{^Decomposition_Type=canonical}', ""); +Expect(0, 7, '\p{Decomposition_Type=canonical}', ""); +Expect(1, 7, '\p{^Decomposition_Type=canonical}', ""); +Expect(1, 7, '\P{Decomposition_Type=canonical}', ""); +Expect(0, 7, '\P{^Decomposition_Type=canonical}', ""); +Expect(1, 271, '\p{Decomposition_Type=- Canonical}', ""); +Expect(0, 271, '\p{^Decomposition_Type=- Canonical}', ""); +Expect(0, 271, '\P{Decomposition_Type=- Canonical}', ""); +Expect(1, 271, '\P{^Decomposition_Type=- Canonical}', ""); +Expect(0, 7, '\p{Decomposition_Type=- Canonical}', ""); +Expect(1, 7, '\p{^Decomposition_Type=- Canonical}', ""); +Expect(1, 7, '\P{Decomposition_Type=- Canonical}', ""); +Expect(0, 7, '\P{^Decomposition_Type=- Canonical}', ""); +Error('\p{Dt=_ Can/a/}'); +Error('\P{Dt=_ Can/a/}'); +Expect(1, 271, '\p{Dt=can}', ""); +Expect(0, 271, '\p{^Dt=can}', ""); +Expect(0, 271, '\P{Dt=can}', ""); +Expect(1, 271, '\P{^Dt=can}', ""); +Expect(0, 7, '\p{Dt=can}', ""); +Expect(1, 7, '\p{^Dt=can}', ""); +Expect(1, 7, '\P{Dt=can}', ""); +Expect(0, 7, '\P{^Dt=can}', ""); +Expect(1, 271, '\p{Dt: can}', ""); +Expect(0, 271, '\p{^Dt: can}', ""); +Expect(0, 271, '\P{Dt: can}', ""); +Expect(1, 271, '\P{^Dt: can}', ""); +Expect(0, 7, '\p{Dt: can}', ""); +Expect(1, 7, '\p{^Dt: can}', ""); +Expect(1, 7, '\P{Dt: can}', ""); +Expect(0, 7, '\P{^Dt: can}', ""); +Error('\p{Is_Decomposition_Type: _/a/Canonical}'); +Error('\P{Is_Decomposition_Type: _/a/Canonical}'); +Expect(1, 271, '\p{Is_Decomposition_Type=canonical}', ""); +Expect(0, 271, '\p{^Is_Decomposition_Type=canonical}', ""); +Expect(0, 271, '\P{Is_Decomposition_Type=canonical}', ""); +Expect(1, 271, '\P{^Is_Decomposition_Type=canonical}', ""); +Expect(0, 7, '\p{Is_Decomposition_Type=canonical}', ""); +Expect(1, 7, '\p{^Is_Decomposition_Type=canonical}', ""); +Expect(1, 7, '\P{Is_Decomposition_Type=canonical}', ""); +Expect(0, 7, '\P{^Is_Decomposition_Type=canonical}', ""); +Expect(1, 271, '\p{Is_Decomposition_Type=-CANONICAL}', ""); +Expect(0, 271, '\p{^Is_Decomposition_Type=-CANONICAL}', ""); +Expect(0, 271, '\P{Is_Decomposition_Type=-CANONICAL}', ""); +Expect(1, 271, '\P{^Is_Decomposition_Type=-CANONICAL}', ""); +Expect(0, 7, '\p{Is_Decomposition_Type=-CANONICAL}', ""); +Expect(1, 7, '\p{^Is_Decomposition_Type=-CANONICAL}', ""); +Expect(1, 7, '\P{Is_Decomposition_Type=-CANONICAL}', ""); +Expect(0, 7, '\P{^Is_Decomposition_Type=-CANONICAL}', ""); +Error('\p{Is_Dt= Can/a/}'); +Error('\P{Is_Dt= Can/a/}'); +Expect(1, 271, '\p{Is_Dt=can}', ""); +Expect(0, 271, '\p{^Is_Dt=can}', ""); +Expect(0, 271, '\P{Is_Dt=can}', ""); +Expect(1, 271, '\P{^Is_Dt=can}', ""); +Expect(0, 7, '\p{Is_Dt=can}', ""); +Expect(1, 7, '\p{^Is_Dt=can}', ""); +Expect(1, 7, '\P{Is_Dt=can}', ""); +Expect(0, 7, '\P{^Is_Dt=can}', ""); +Expect(1, 271, '\p{Is_Dt= can}', ""); +Expect(0, 271, '\p{^Is_Dt= can}', ""); +Expect(0, 271, '\P{Is_Dt= can}', ""); +Expect(1, 271, '\P{^Is_Dt= can}', ""); +Expect(0, 7, '\p{Is_Dt= can}', ""); +Expect(1, 7, '\p{^Is_Dt= can}', ""); +Expect(1, 7, '\P{Is_Dt= can}', ""); +Expect(0, 7, '\P{^Is_Dt= can}', ""); +Error('\p{Decomposition_Type= -VERTICAL:=}'); +Error('\P{Decomposition_Type= -VERTICAL:=}'); +Expect(1, 12447, '\p{Decomposition_Type: vertical}', ""); +Expect(0, 12447, '\p{^Decomposition_Type: vertical}', ""); +Expect(0, 12447, '\P{Decomposition_Type: vertical}', ""); +Expect(1, 12447, '\P{^Decomposition_Type: vertical}', ""); +Expect(0, 12446, '\p{Decomposition_Type: vertical}', ""); +Expect(1, 12446, '\p{^Decomposition_Type: vertical}', ""); +Expect(1, 12446, '\P{Decomposition_Type: vertical}', ""); +Expect(0, 12446, '\P{^Decomposition_Type: vertical}', ""); +Expect(1, 12447, '\p{Decomposition_Type= vertical}', ""); +Expect(0, 12447, '\p{^Decomposition_Type= vertical}', ""); +Expect(0, 12447, '\P{Decomposition_Type= vertical}', ""); +Expect(1, 12447, '\P{^Decomposition_Type= vertical}', ""); +Expect(0, 12446, '\p{Decomposition_Type= vertical}', ""); +Expect(1, 12446, '\p{^Decomposition_Type= vertical}', ""); +Expect(1, 12446, '\P{Decomposition_Type= vertical}', ""); +Expect(0, 12446, '\P{^Decomposition_Type= vertical}', ""); +Error('\p{Dt=/a/VERT}'); +Error('\P{Dt=/a/VERT}'); +Expect(1, 12447, '\p{Dt: vert}', ""); +Expect(0, 12447, '\p{^Dt: vert}', ""); +Expect(0, 12447, '\P{Dt: vert}', ""); +Expect(1, 12447, '\P{^Dt: vert}', ""); +Expect(0, 12446, '\p{Dt: vert}', ""); +Expect(1, 12446, '\p{^Dt: vert}', ""); +Expect(1, 12446, '\P{Dt: vert}', ""); +Expect(0, 12446, '\P{^Dt: vert}', ""); +Expect(1, 12447, '\p{Dt=-Vert}', ""); +Expect(0, 12447, '\p{^Dt=-Vert}', ""); +Expect(0, 12447, '\P{Dt=-Vert}', ""); +Expect(1, 12447, '\P{^Dt=-Vert}', ""); +Expect(0, 12446, '\p{Dt=-Vert}', ""); +Expect(1, 12446, '\p{^Dt=-Vert}', ""); +Expect(1, 12446, '\P{Dt=-Vert}', ""); +Expect(0, 12446, '\P{^Dt=-Vert}', ""); +Error('\p{Is_Decomposition_Type= vertical/a/}'); +Error('\P{Is_Decomposition_Type= vertical/a/}'); +Expect(1, 12447, '\p{Is_Decomposition_Type=vertical}', ""); +Expect(0, 12447, '\p{^Is_Decomposition_Type=vertical}', ""); +Expect(0, 12447, '\P{Is_Decomposition_Type=vertical}', ""); +Expect(1, 12447, '\P{^Is_Decomposition_Type=vertical}', ""); +Expect(0, 12446, '\p{Is_Decomposition_Type=vertical}', ""); +Expect(1, 12446, '\p{^Is_Decomposition_Type=vertical}', ""); +Expect(1, 12446, '\P{Is_Decomposition_Type=vertical}', ""); +Expect(0, 12446, '\P{^Is_Decomposition_Type=vertical}', ""); +Expect(1, 12447, '\p{Is_Decomposition_Type=_vertical}', ""); +Expect(0, 12447, '\p{^Is_Decomposition_Type=_vertical}', ""); +Expect(0, 12447, '\P{Is_Decomposition_Type=_vertical}', ""); +Expect(1, 12447, '\P{^Is_Decomposition_Type=_vertical}', ""); +Expect(0, 12446, '\p{Is_Decomposition_Type=_vertical}', ""); +Expect(1, 12446, '\p{^Is_Decomposition_Type=_vertical}', ""); +Expect(1, 12446, '\P{Is_Decomposition_Type=_vertical}', ""); +Expect(0, 12446, '\P{^Is_Decomposition_Type=_vertical}', ""); +Error('\p{Is_Dt=/a/_ Vert}'); +Error('\P{Is_Dt=/a/_ Vert}'); +Expect(1, 12447, '\p{Is_Dt=vert}', ""); +Expect(0, 12447, '\p{^Is_Dt=vert}', ""); +Expect(0, 12447, '\P{Is_Dt=vert}', ""); +Expect(1, 12447, '\P{^Is_Dt=vert}', ""); +Expect(0, 12446, '\p{Is_Dt=vert}', ""); +Expect(1, 12446, '\p{^Is_Dt=vert}', ""); +Expect(1, 12446, '\P{Is_Dt=vert}', ""); +Expect(0, 12446, '\P{^Is_Dt=vert}', ""); +Expect(1, 12447, '\p{Is_Dt: -Vert}', ""); +Expect(0, 12447, '\p{^Is_Dt: -Vert}', ""); +Expect(0, 12447, '\P{Is_Dt: -Vert}', ""); +Expect(1, 12447, '\P{^Is_Dt: -Vert}', ""); +Expect(0, 12446, '\p{Is_Dt: -Vert}', ""); +Expect(1, 12446, '\p{^Is_Dt: -Vert}', ""); +Expect(1, 12446, '\P{Is_Dt: -Vert}', ""); +Expect(0, 12446, '\P{^Is_Dt: -Vert}', ""); +Error('\p{Decomposition_Type=:=--medial}'); +Error('\P{Decomposition_Type=:=--medial}'); +Expect(1, 64341, '\p{Decomposition_Type: medial}', ""); +Expect(0, 64341, '\p{^Decomposition_Type: medial}', ""); +Expect(0, 64341, '\P{Decomposition_Type: medial}', ""); +Expect(1, 64341, '\P{^Decomposition_Type: medial}', ""); +Expect(0, 64340, '\p{Decomposition_Type: medial}', ""); +Expect(1, 64340, '\p{^Decomposition_Type: medial}', ""); +Expect(1, 64340, '\P{Decomposition_Type: medial}', ""); +Expect(0, 64340, '\P{^Decomposition_Type: medial}', ""); +Expect(1, 64341, '\p{Decomposition_Type=--Medial}', ""); +Expect(0, 64341, '\p{^Decomposition_Type=--Medial}', ""); +Expect(0, 64341, '\P{Decomposition_Type=--Medial}', ""); +Expect(1, 64341, '\P{^Decomposition_Type=--Medial}', ""); +Expect(0, 64340, '\p{Decomposition_Type=--Medial}', ""); +Expect(1, 64340, '\p{^Decomposition_Type=--Medial}', ""); +Expect(1, 64340, '\P{Decomposition_Type=--Medial}', ""); +Expect(0, 64340, '\P{^Decomposition_Type=--Medial}', ""); +Error('\p{Dt=:=MED}'); +Error('\P{Dt=:=MED}'); +Expect(1, 64341, '\p{Dt=med}', ""); +Expect(0, 64341, '\p{^Dt=med}', ""); +Expect(0, 64341, '\P{Dt=med}', ""); +Expect(1, 64341, '\P{^Dt=med}', ""); +Expect(0, 64340, '\p{Dt=med}', ""); +Expect(1, 64340, '\p{^Dt=med}', ""); +Expect(1, 64340, '\P{Dt=med}', ""); +Expect(0, 64340, '\P{^Dt=med}', ""); +Expect(1, 64341, '\p{Dt= Med}', ""); +Expect(0, 64341, '\p{^Dt= Med}', ""); +Expect(0, 64341, '\P{Dt= Med}', ""); +Expect(1, 64341, '\P{^Dt= Med}', ""); +Expect(0, 64340, '\p{Dt= Med}', ""); +Expect(1, 64340, '\p{^Dt= Med}', ""); +Expect(1, 64340, '\P{Dt= Med}', ""); +Expect(0, 64340, '\P{^Dt= Med}', ""); +Error('\p{Is_Decomposition_Type=-MEDIAL:=}'); +Error('\P{Is_Decomposition_Type=-MEDIAL:=}'); +Expect(1, 64341, '\p{Is_Decomposition_Type=medial}', ""); +Expect(0, 64341, '\p{^Is_Decomposition_Type=medial}', ""); +Expect(0, 64341, '\P{Is_Decomposition_Type=medial}', ""); +Expect(1, 64341, '\P{^Is_Decomposition_Type=medial}', ""); +Expect(0, 64340, '\p{Is_Decomposition_Type=medial}', ""); +Expect(1, 64340, '\p{^Is_Decomposition_Type=medial}', ""); +Expect(1, 64340, '\P{Is_Decomposition_Type=medial}', ""); +Expect(0, 64340, '\P{^Is_Decomposition_Type=medial}', ""); +Expect(1, 64341, '\p{Is_Decomposition_Type= -MEDIAL}', ""); +Expect(0, 64341, '\p{^Is_Decomposition_Type= -MEDIAL}', ""); +Expect(0, 64341, '\P{Is_Decomposition_Type= -MEDIAL}', ""); +Expect(1, 64341, '\P{^Is_Decomposition_Type= -MEDIAL}', ""); +Expect(0, 64340, '\p{Is_Decomposition_Type= -MEDIAL}', ""); +Expect(1, 64340, '\p{^Is_Decomposition_Type= -MEDIAL}', ""); +Expect(1, 64340, '\P{Is_Decomposition_Type= -MEDIAL}', ""); +Expect(0, 64340, '\P{^Is_Decomposition_Type= -MEDIAL}', ""); +Error('\p{Is_Dt: _Med:=}'); +Error('\P{Is_Dt: _Med:=}'); +Expect(1, 64341, '\p{Is_Dt=med}', ""); +Expect(0, 64341, '\p{^Is_Dt=med}', ""); +Expect(0, 64341, '\P{Is_Dt=med}', ""); +Expect(1, 64341, '\P{^Is_Dt=med}', ""); +Expect(0, 64340, '\p{Is_Dt=med}', ""); +Expect(1, 64340, '\p{^Is_Dt=med}', ""); +Expect(1, 64340, '\P{Is_Dt=med}', ""); +Expect(0, 64340, '\P{^Is_Dt=med}', ""); +Expect(1, 64341, '\p{Is_Dt=- MED}', ""); +Expect(0, 64341, '\p{^Is_Dt=- MED}', ""); +Expect(0, 64341, '\P{Is_Dt=- MED}', ""); +Expect(1, 64341, '\P{^Is_Dt=- MED}', ""); +Expect(0, 64340, '\p{Is_Dt=- MED}', ""); +Expect(1, 64340, '\p{^Is_Dt=- MED}', ""); +Expect(1, 64340, '\P{Is_Dt=- MED}', ""); +Expect(0, 64340, '\P{^Is_Dt=- MED}', ""); +Error('\p{Decomposition_Type=_/a/NARROW}'); +Error('\P{Decomposition_Type=_/a/NARROW}'); +Expect(1, 65470, '\p{Decomposition_Type=narrow}', ""); +Expect(0, 65470, '\p{^Decomposition_Type=narrow}', ""); +Expect(0, 65470, '\P{Decomposition_Type=narrow}', ""); +Expect(1, 65470, '\P{^Decomposition_Type=narrow}', ""); +Expect(0, 65376, '\p{Decomposition_Type=narrow}', ""); +Expect(1, 65376, '\p{^Decomposition_Type=narrow}', ""); +Expect(1, 65376, '\P{Decomposition_Type=narrow}', ""); +Expect(0, 65376, '\P{^Decomposition_Type=narrow}', ""); +Expect(1, 65470, '\p{Decomposition_Type= NARROW}', ""); +Expect(0, 65470, '\p{^Decomposition_Type= NARROW}', ""); +Expect(0, 65470, '\P{Decomposition_Type= NARROW}', ""); +Expect(1, 65470, '\P{^Decomposition_Type= NARROW}', ""); +Expect(0, 65376, '\p{Decomposition_Type= NARROW}', ""); +Expect(1, 65376, '\p{^Decomposition_Type= NARROW}', ""); +Expect(1, 65376, '\P{Decomposition_Type= NARROW}', ""); +Expect(0, 65376, '\P{^Decomposition_Type= NARROW}', ""); +Error('\p{Dt=/a/-nar}'); +Error('\P{Dt=/a/-nar}'); +Expect(1, 65470, '\p{Dt=nar}', ""); +Expect(0, 65470, '\p{^Dt=nar}', ""); +Expect(0, 65470, '\P{Dt=nar}', ""); +Expect(1, 65470, '\P{^Dt=nar}', ""); +Expect(0, 65376, '\p{Dt=nar}', ""); +Expect(1, 65376, '\p{^Dt=nar}', ""); +Expect(1, 65376, '\P{Dt=nar}', ""); +Expect(0, 65376, '\P{^Dt=nar}', ""); +Expect(1, 65470, '\p{Dt= nar}', ""); +Expect(0, 65470, '\p{^Dt= nar}', ""); +Expect(0, 65470, '\P{Dt= nar}', ""); +Expect(1, 65470, '\P{^Dt= nar}', ""); +Expect(0, 65376, '\p{Dt= nar}', ""); +Expect(1, 65376, '\p{^Dt= nar}', ""); +Expect(1, 65376, '\P{Dt= nar}', ""); +Expect(0, 65376, '\P{^Dt= nar}', ""); +Error('\p{Is_Decomposition_Type=:=_ Narrow}'); +Error('\P{Is_Decomposition_Type=:=_ Narrow}'); +Expect(1, 65470, '\p{Is_Decomposition_Type=narrow}', ""); +Expect(0, 65470, '\p{^Is_Decomposition_Type=narrow}', ""); +Expect(0, 65470, '\P{Is_Decomposition_Type=narrow}', ""); +Expect(1, 65470, '\P{^Is_Decomposition_Type=narrow}', ""); +Expect(0, 65376, '\p{Is_Decomposition_Type=narrow}', ""); +Expect(1, 65376, '\p{^Is_Decomposition_Type=narrow}', ""); +Expect(1, 65376, '\P{Is_Decomposition_Type=narrow}', ""); +Expect(0, 65376, '\P{^Is_Decomposition_Type=narrow}', ""); +Expect(1, 65470, '\p{Is_Decomposition_Type=- Narrow}', ""); +Expect(0, 65470, '\p{^Is_Decomposition_Type=- Narrow}', ""); +Expect(0, 65470, '\P{Is_Decomposition_Type=- Narrow}', ""); +Expect(1, 65470, '\P{^Is_Decomposition_Type=- Narrow}', ""); +Expect(0, 65376, '\p{Is_Decomposition_Type=- Narrow}', ""); +Expect(1, 65376, '\p{^Is_Decomposition_Type=- Narrow}', ""); +Expect(1, 65376, '\P{Is_Decomposition_Type=- Narrow}', ""); +Expect(0, 65376, '\P{^Is_Decomposition_Type=- Narrow}', ""); +Error('\p{Is_Dt=-:=nar}'); +Error('\P{Is_Dt=-:=nar}'); +Expect(1, 65470, '\p{Is_Dt=nar}', ""); +Expect(0, 65470, '\p{^Is_Dt=nar}', ""); +Expect(0, 65470, '\P{Is_Dt=nar}', ""); +Expect(1, 65470, '\P{^Is_Dt=nar}', ""); +Expect(0, 65376, '\p{Is_Dt=nar}', ""); +Expect(1, 65376, '\p{^Is_Dt=nar}', ""); +Expect(1, 65376, '\P{Is_Dt=nar}', ""); +Expect(0, 65376, '\P{^Is_Dt=nar}', ""); +Expect(1, 65470, '\p{Is_Dt= nar}', ""); +Expect(0, 65470, '\p{^Is_Dt= nar}', ""); +Expect(0, 65470, '\P{Is_Dt= nar}', ""); +Expect(1, 65470, '\P{^Is_Dt= nar}', ""); +Expect(0, 65376, '\p{Is_Dt= nar}', ""); +Expect(1, 65376, '\p{^Is_Dt= nar}', ""); +Expect(1, 65376, '\P{Is_Dt= nar}', ""); +Expect(0, 65376, '\P{^Is_Dt= nar}', ""); +Error('\p{Decomposition_Type=_Sub/a/}'); +Error('\P{Decomposition_Type=_Sub/a/}'); +Expect(1, 7530, '\p{Decomposition_Type=sub}', ""); +Expect(0, 7530, '\p{^Decomposition_Type=sub}', ""); +Expect(0, 7530, '\P{Decomposition_Type=sub}', ""); +Expect(1, 7530, '\P{^Decomposition_Type=sub}', ""); +Expect(0, 7521, '\p{Decomposition_Type=sub}', ""); +Expect(1, 7521, '\p{^Decomposition_Type=sub}', ""); +Expect(1, 7521, '\P{Decomposition_Type=sub}', ""); +Expect(0, 7521, '\P{^Decomposition_Type=sub}', ""); +Expect(1, 7530, '\p{Decomposition_Type:-Sub}', ""); +Expect(0, 7530, '\p{^Decomposition_Type:-Sub}', ""); +Expect(0, 7530, '\P{Decomposition_Type:-Sub}', ""); +Expect(1, 7530, '\P{^Decomposition_Type:-Sub}', ""); +Expect(0, 7521, '\p{Decomposition_Type:-Sub}', ""); +Expect(1, 7521, '\p{^Decomposition_Type:-Sub}', ""); +Expect(1, 7521, '\P{Decomposition_Type:-Sub}', ""); +Expect(0, 7521, '\P{^Decomposition_Type:-Sub}', ""); +Error('\p{Dt=-:=Sub}'); +Error('\P{Dt=-:=Sub}'); +Expect(1, 7530, '\p{Dt=sub}', ""); +Expect(0, 7530, '\p{^Dt=sub}', ""); +Expect(0, 7530, '\P{Dt=sub}', ""); +Expect(1, 7530, '\P{^Dt=sub}', ""); +Expect(0, 7521, '\p{Dt=sub}', ""); +Expect(1, 7521, '\p{^Dt=sub}', ""); +Expect(1, 7521, '\P{Dt=sub}', ""); +Expect(0, 7521, '\P{^Dt=sub}', ""); +Expect(1, 7530, '\p{Dt=_Sub}', ""); +Expect(0, 7530, '\p{^Dt=_Sub}', ""); +Expect(0, 7530, '\P{Dt=_Sub}', ""); +Expect(1, 7530, '\P{^Dt=_Sub}', ""); +Expect(0, 7521, '\p{Dt=_Sub}', ""); +Expect(1, 7521, '\p{^Dt=_Sub}', ""); +Expect(1, 7521, '\P{Dt=_Sub}', ""); +Expect(0, 7521, '\P{^Dt=_Sub}', ""); +Error('\p{Is_Decomposition_Type=:= _Sub}'); +Error('\P{Is_Decomposition_Type=:= _Sub}'); +Expect(1, 7530, '\p{Is_Decomposition_Type=sub}', ""); +Expect(0, 7530, '\p{^Is_Decomposition_Type=sub}', ""); +Expect(0, 7530, '\P{Is_Decomposition_Type=sub}', ""); +Expect(1, 7530, '\P{^Is_Decomposition_Type=sub}', ""); +Expect(0, 7521, '\p{Is_Decomposition_Type=sub}', ""); +Expect(1, 7521, '\p{^Is_Decomposition_Type=sub}', ""); +Expect(1, 7521, '\P{Is_Decomposition_Type=sub}', ""); +Expect(0, 7521, '\P{^Is_Decomposition_Type=sub}', ""); +Expect(1, 7530, '\p{Is_Decomposition_Type= _sub}', ""); +Expect(0, 7530, '\p{^Is_Decomposition_Type= _sub}', ""); +Expect(0, 7530, '\P{Is_Decomposition_Type= _sub}', ""); +Expect(1, 7530, '\P{^Is_Decomposition_Type= _sub}', ""); +Expect(0, 7521, '\p{Is_Decomposition_Type= _sub}', ""); +Expect(1, 7521, '\p{^Is_Decomposition_Type= _sub}', ""); +Expect(1, 7521, '\P{Is_Decomposition_Type= _sub}', ""); +Expect(0, 7521, '\P{^Is_Decomposition_Type= _sub}', ""); +Error('\p{Is_Dt=_/a/SUB}'); +Error('\P{Is_Dt=_/a/SUB}'); +Expect(1, 7530, '\p{Is_Dt=sub}', ""); +Expect(0, 7530, '\p{^Is_Dt=sub}', ""); +Expect(0, 7530, '\P{Is_Dt=sub}', ""); +Expect(1, 7530, '\P{^Is_Dt=sub}', ""); +Expect(0, 7521, '\p{Is_Dt=sub}', ""); +Expect(1, 7521, '\p{^Is_Dt=sub}', ""); +Expect(1, 7521, '\P{Is_Dt=sub}', ""); +Expect(0, 7521, '\P{^Is_Dt=sub}', ""); +Expect(1, 7530, '\p{Is_Dt=_ Sub}', ""); +Expect(0, 7530, '\p{^Is_Dt=_ Sub}', ""); +Expect(0, 7530, '\P{Is_Dt=_ Sub}', ""); +Expect(1, 7530, '\P{^Is_Dt=_ Sub}', ""); +Expect(0, 7521, '\p{Is_Dt=_ Sub}', ""); +Expect(1, 7521, '\p{^Is_Dt=_ Sub}', ""); +Expect(1, 7521, '\P{Is_Dt=_ Sub}', ""); +Expect(0, 7521, '\P{^Is_Dt=_ Sub}', ""); +Error('\p{Decomposition_Type= :=SQUARE}'); +Error('\P{Decomposition_Type= :=SQUARE}'); +Expect(1, 12880, '\p{Decomposition_Type=square}', ""); +Expect(0, 12880, '\p{^Decomposition_Type=square}', ""); +Expect(0, 12880, '\P{Decomposition_Type=square}', ""); +Expect(1, 12880, '\P{^Decomposition_Type=square}', ""); +Expect(0, 12879, '\p{Decomposition_Type=square}', ""); +Expect(1, 12879, '\p{^Decomposition_Type=square}', ""); +Expect(1, 12879, '\P{Decomposition_Type=square}', ""); +Expect(0, 12879, '\P{^Decomposition_Type=square}', ""); +Expect(1, 12880, '\p{Decomposition_Type=- SQUARE}', ""); +Expect(0, 12880, '\p{^Decomposition_Type=- SQUARE}', ""); +Expect(0, 12880, '\P{Decomposition_Type=- SQUARE}', ""); +Expect(1, 12880, '\P{^Decomposition_Type=- SQUARE}', ""); +Expect(0, 12879, '\p{Decomposition_Type=- SQUARE}', ""); +Expect(1, 12879, '\p{^Decomposition_Type=- SQUARE}', ""); +Expect(1, 12879, '\P{Decomposition_Type=- SQUARE}', ""); +Expect(0, 12879, '\P{^Decomposition_Type=- SQUARE}', ""); +Error('\p{Dt=:= SQR}'); +Error('\P{Dt=:= SQR}'); +Expect(1, 12880, '\p{Dt=sqr}', ""); +Expect(0, 12880, '\p{^Dt=sqr}', ""); +Expect(0, 12880, '\P{Dt=sqr}', ""); +Expect(1, 12880, '\P{^Dt=sqr}', ""); +Expect(0, 12879, '\p{Dt=sqr}', ""); +Expect(1, 12879, '\p{^Dt=sqr}', ""); +Expect(1, 12879, '\P{Dt=sqr}', ""); +Expect(0, 12879, '\P{^Dt=sqr}', ""); +Expect(1, 12880, '\p{Dt= -sqr}', ""); +Expect(0, 12880, '\p{^Dt= -sqr}', ""); +Expect(0, 12880, '\P{Dt= -sqr}', ""); +Expect(1, 12880, '\P{^Dt= -sqr}', ""); +Expect(0, 12879, '\p{Dt= -sqr}', ""); +Expect(1, 12879, '\p{^Dt= -sqr}', ""); +Expect(1, 12879, '\P{Dt= -sqr}', ""); +Expect(0, 12879, '\P{^Dt= -sqr}', ""); +Error('\p{Is_Decomposition_Type= Square/a/}'); +Error('\P{Is_Decomposition_Type= Square/a/}'); +Expect(1, 12880, '\p{Is_Decomposition_Type=square}', ""); +Expect(0, 12880, '\p{^Is_Decomposition_Type=square}', ""); +Expect(0, 12880, '\P{Is_Decomposition_Type=square}', ""); +Expect(1, 12880, '\P{^Is_Decomposition_Type=square}', ""); +Expect(0, 12879, '\p{Is_Decomposition_Type=square}', ""); +Expect(1, 12879, '\p{^Is_Decomposition_Type=square}', ""); +Expect(1, 12879, '\P{Is_Decomposition_Type=square}', ""); +Expect(0, 12879, '\P{^Is_Decomposition_Type=square}', ""); +Expect(1, 12880, '\p{Is_Decomposition_Type=-Square}', ""); +Expect(0, 12880, '\p{^Is_Decomposition_Type=-Square}', ""); +Expect(0, 12880, '\P{Is_Decomposition_Type=-Square}', ""); +Expect(1, 12880, '\P{^Is_Decomposition_Type=-Square}', ""); +Expect(0, 12879, '\p{Is_Decomposition_Type=-Square}', ""); +Expect(1, 12879, '\p{^Is_Decomposition_Type=-Square}', ""); +Expect(1, 12879, '\P{Is_Decomposition_Type=-Square}', ""); +Expect(0, 12879, '\P{^Is_Decomposition_Type=-Square}', ""); +Error('\p{Is_Dt=-Sqr/a/}'); +Error('\P{Is_Dt=-Sqr/a/}'); +Expect(1, 12880, '\p{Is_Dt=sqr}', ""); +Expect(0, 12880, '\p{^Is_Dt=sqr}', ""); +Expect(0, 12880, '\P{Is_Dt=sqr}', ""); +Expect(1, 12880, '\P{^Is_Dt=sqr}', ""); +Expect(0, 12879, '\p{Is_Dt=sqr}', ""); +Expect(1, 12879, '\p{^Is_Dt=sqr}', ""); +Expect(1, 12879, '\P{Is_Dt=sqr}', ""); +Expect(0, 12879, '\P{^Is_Dt=sqr}', ""); +Expect(1, 12880, '\p{Is_Dt=- Sqr}', ""); +Expect(0, 12880, '\p{^Is_Dt=- Sqr}', ""); +Expect(0, 12880, '\P{Is_Dt=- Sqr}', ""); +Expect(1, 12880, '\P{^Is_Dt=- Sqr}', ""); +Expect(0, 12879, '\p{Is_Dt=- Sqr}', ""); +Expect(1, 12879, '\p{^Is_Dt=- Sqr}', ""); +Expect(1, 12879, '\P{Is_Dt=- Sqr}', ""); +Expect(0, 12879, '\P{^Is_Dt=- Sqr}', ""); +Error('\p{Decomposition_Type=:= _Small}'); +Error('\P{Decomposition_Type=:= _Small}'); +Expect(1, 65106, '\p{Decomposition_Type=small}', ""); +Expect(0, 65106, '\p{^Decomposition_Type=small}', ""); +Expect(0, 65106, '\P{Decomposition_Type=small}', ""); +Expect(1, 65106, '\P{^Decomposition_Type=small}', ""); +Expect(0, 65103, '\p{Decomposition_Type=small}', ""); +Expect(1, 65103, '\p{^Decomposition_Type=small}', ""); +Expect(1, 65103, '\P{Decomposition_Type=small}', ""); +Expect(0, 65103, '\P{^Decomposition_Type=small}', ""); +Expect(1, 65106, '\p{Decomposition_Type=- SMALL}', ""); +Expect(0, 65106, '\p{^Decomposition_Type=- SMALL}', ""); +Expect(0, 65106, '\P{Decomposition_Type=- SMALL}', ""); +Expect(1, 65106, '\P{^Decomposition_Type=- SMALL}', ""); +Expect(0, 65103, '\p{Decomposition_Type=- SMALL}', ""); +Expect(1, 65103, '\p{^Decomposition_Type=- SMALL}', ""); +Expect(1, 65103, '\P{Decomposition_Type=- SMALL}', ""); +Expect(0, 65103, '\P{^Decomposition_Type=- SMALL}', ""); +Error('\p{Dt: _:=Sml}'); +Error('\P{Dt: _:=Sml}'); +Expect(1, 65106, '\p{Dt=sml}', ""); +Expect(0, 65106, '\p{^Dt=sml}', ""); +Expect(0, 65106, '\P{Dt=sml}', ""); +Expect(1, 65106, '\P{^Dt=sml}', ""); +Expect(0, 65103, '\p{Dt=sml}', ""); +Expect(1, 65103, '\p{^Dt=sml}', ""); +Expect(1, 65103, '\P{Dt=sml}', ""); +Expect(0, 65103, '\P{^Dt=sml}', ""); +Expect(1, 65106, '\p{Dt=_-Sml}', ""); +Expect(0, 65106, '\p{^Dt=_-Sml}', ""); +Expect(0, 65106, '\P{Dt=_-Sml}', ""); +Expect(1, 65106, '\P{^Dt=_-Sml}', ""); +Expect(0, 65103, '\p{Dt=_-Sml}', ""); +Expect(1, 65103, '\p{^Dt=_-Sml}', ""); +Expect(1, 65103, '\P{Dt=_-Sml}', ""); +Expect(0, 65103, '\P{^Dt=_-Sml}', ""); +Error('\p{Is_Decomposition_Type= Small:=}'); +Error('\P{Is_Decomposition_Type= Small:=}'); +Expect(1, 65106, '\p{Is_Decomposition_Type=small}', ""); +Expect(0, 65106, '\p{^Is_Decomposition_Type=small}', ""); +Expect(0, 65106, '\P{Is_Decomposition_Type=small}', ""); +Expect(1, 65106, '\P{^Is_Decomposition_Type=small}', ""); +Expect(0, 65103, '\p{Is_Decomposition_Type=small}', ""); +Expect(1, 65103, '\p{^Is_Decomposition_Type=small}', ""); +Expect(1, 65103, '\P{Is_Decomposition_Type=small}', ""); +Expect(0, 65103, '\P{^Is_Decomposition_Type=small}', ""); +Expect(1, 65106, '\p{Is_Decomposition_Type: SMALL}', ""); +Expect(0, 65106, '\p{^Is_Decomposition_Type: SMALL}', ""); +Expect(0, 65106, '\P{Is_Decomposition_Type: SMALL}', ""); +Expect(1, 65106, '\P{^Is_Decomposition_Type: SMALL}', ""); +Expect(0, 65103, '\p{Is_Decomposition_Type: SMALL}', ""); +Expect(1, 65103, '\p{^Is_Decomposition_Type: SMALL}', ""); +Expect(1, 65103, '\P{Is_Decomposition_Type: SMALL}', ""); +Expect(0, 65103, '\P{^Is_Decomposition_Type: SMALL}', ""); +Error('\p{Is_Dt=- Sml/a/}'); +Error('\P{Is_Dt=- Sml/a/}'); +Expect(1, 65106, '\p{Is_Dt=sml}', ""); +Expect(0, 65106, '\p{^Is_Dt=sml}', ""); +Expect(0, 65106, '\P{Is_Dt=sml}', ""); +Expect(1, 65106, '\P{^Is_Dt=sml}', ""); +Expect(0, 65103, '\p{Is_Dt=sml}', ""); +Expect(1, 65103, '\p{^Is_Dt=sml}', ""); +Expect(1, 65103, '\P{Is_Dt=sml}', ""); +Expect(0, 65103, '\P{^Is_Dt=sml}', ""); +Expect(1, 65106, '\p{Is_Dt= sml}', ""); +Expect(0, 65106, '\p{^Is_Dt= sml}', ""); +Expect(0, 65106, '\P{Is_Dt= sml}', ""); +Expect(1, 65106, '\P{^Is_Dt= sml}', ""); +Expect(0, 65103, '\p{Is_Dt= sml}', ""); +Expect(1, 65103, '\p{^Is_Dt= sml}', ""); +Expect(1, 65103, '\P{Is_Dt= sml}', ""); +Expect(0, 65103, '\P{^Is_Dt= sml}', ""); +Error('\p{Decomposition_Type=/a/ None}'); +Error('\P{Decomposition_Type=/a/ None}'); +Expect(1, 7, '\p{Decomposition_Type: none}', ""); +Expect(0, 7, '\p{^Decomposition_Type: none}', ""); +Expect(0, 7, '\P{Decomposition_Type: none}', ""); +Expect(1, 7, '\P{^Decomposition_Type: none}', ""); +Expect(0, 271, '\p{Decomposition_Type: none}', ""); +Expect(1, 271, '\p{^Decomposition_Type: none}', ""); +Expect(1, 271, '\P{Decomposition_Type: none}', ""); +Expect(0, 271, '\P{^Decomposition_Type: none}', ""); +Expect(1, 7, '\p{Decomposition_Type=- none}', ""); +Expect(0, 7, '\p{^Decomposition_Type=- none}', ""); +Expect(0, 7, '\P{Decomposition_Type=- none}', ""); +Expect(1, 7, '\P{^Decomposition_Type=- none}', ""); +Expect(0, 271, '\p{Decomposition_Type=- none}', ""); +Expect(1, 271, '\p{^Decomposition_Type=- none}', ""); +Expect(1, 271, '\P{Decomposition_Type=- none}', ""); +Expect(0, 271, '\P{^Decomposition_Type=- none}', ""); +Error('\p{Dt=-:=NONE}'); +Error('\P{Dt=-:=NONE}'); +Expect(1, 7, '\p{Dt: none}', ""); +Expect(0, 7, '\p{^Dt: none}', ""); +Expect(0, 7, '\P{Dt: none}', ""); +Expect(1, 7, '\P{^Dt: none}', ""); +Expect(0, 271, '\p{Dt: none}', ""); +Expect(1, 271, '\p{^Dt: none}', ""); +Expect(1, 271, '\P{Dt: none}', ""); +Expect(0, 271, '\P{^Dt: none}', ""); +Expect(1, 7, '\p{Dt=--none}', ""); +Expect(0, 7, '\p{^Dt=--none}', ""); +Expect(0, 7, '\P{Dt=--none}', ""); +Expect(1, 7, '\P{^Dt=--none}', ""); +Expect(0, 271, '\p{Dt=--none}', ""); +Expect(1, 271, '\p{^Dt=--none}', ""); +Expect(1, 271, '\P{Dt=--none}', ""); +Expect(0, 271, '\P{^Dt=--none}', ""); +Error('\p{Is_Decomposition_Type=_-None:=}'); +Error('\P{Is_Decomposition_Type=_-None:=}'); +Expect(1, 7, '\p{Is_Decomposition_Type=none}', ""); +Expect(0, 7, '\p{^Is_Decomposition_Type=none}', ""); +Expect(0, 7, '\P{Is_Decomposition_Type=none}', ""); +Expect(1, 7, '\P{^Is_Decomposition_Type=none}', ""); +Expect(0, 271, '\p{Is_Decomposition_Type=none}', ""); +Expect(1, 271, '\p{^Is_Decomposition_Type=none}', ""); +Expect(1, 271, '\P{Is_Decomposition_Type=none}', ""); +Expect(0, 271, '\P{^Is_Decomposition_Type=none}', ""); +Expect(1, 7, '\p{Is_Decomposition_Type:- NONE}', ""); +Expect(0, 7, '\p{^Is_Decomposition_Type:- NONE}', ""); +Expect(0, 7, '\P{Is_Decomposition_Type:- NONE}', ""); +Expect(1, 7, '\P{^Is_Decomposition_Type:- NONE}', ""); +Expect(0, 271, '\p{Is_Decomposition_Type:- NONE}', ""); +Expect(1, 271, '\p{^Is_Decomposition_Type:- NONE}', ""); +Expect(1, 271, '\P{Is_Decomposition_Type:- NONE}', ""); +Expect(0, 271, '\P{^Is_Decomposition_Type:- NONE}', ""); +Error('\p{Is_Dt=:= NONE}'); +Error('\P{Is_Dt=:= NONE}'); +Expect(1, 7, '\p{Is_Dt=none}', ""); +Expect(0, 7, '\p{^Is_Dt=none}', ""); +Expect(0, 7, '\P{Is_Dt=none}', ""); +Expect(1, 7, '\P{^Is_Dt=none}', ""); +Expect(0, 271, '\p{Is_Dt=none}', ""); +Expect(1, 271, '\p{^Is_Dt=none}', ""); +Expect(1, 271, '\P{Is_Dt=none}', ""); +Expect(0, 271, '\P{^Is_Dt=none}', ""); +Expect(1, 7, '\p{Is_Dt=--None}', ""); +Expect(0, 7, '\p{^Is_Dt=--None}', ""); +Expect(0, 7, '\P{Is_Dt=--None}', ""); +Expect(1, 7, '\P{^Is_Dt=--None}', ""); +Expect(0, 271, '\p{Is_Dt=--None}', ""); +Expect(1, 271, '\p{^Is_Dt=--None}', ""); +Expect(1, 271, '\P{Is_Dt=--None}', ""); +Expect(0, 271, '\P{^Is_Dt=--None}', ""); +Error('\p{Decomposition_Type=/a/ Isolated}'); +Error('\P{Decomposition_Type=/a/ Isolated}'); +Expect(1, 64336, '\p{Decomposition_Type=isolated}', ""); +Expect(0, 64336, '\p{^Decomposition_Type=isolated}', ""); +Expect(0, 64336, '\P{Decomposition_Type=isolated}', ""); +Expect(1, 64336, '\P{^Decomposition_Type=isolated}', ""); +Expect(0, 64335, '\p{Decomposition_Type=isolated}', ""); +Expect(1, 64335, '\p{^Decomposition_Type=isolated}', ""); +Expect(1, 64335, '\P{Decomposition_Type=isolated}', ""); +Expect(0, 64335, '\P{^Decomposition_Type=isolated}', ""); +Expect(1, 64336, '\p{Decomposition_Type= -isolated}', ""); +Expect(0, 64336, '\p{^Decomposition_Type= -isolated}', ""); +Expect(0, 64336, '\P{Decomposition_Type= -isolated}', ""); +Expect(1, 64336, '\P{^Decomposition_Type= -isolated}', ""); +Expect(0, 64335, '\p{Decomposition_Type= -isolated}', ""); +Expect(1, 64335, '\p{^Decomposition_Type= -isolated}', ""); +Expect(1, 64335, '\P{Decomposition_Type= -isolated}', ""); +Expect(0, 64335, '\P{^Decomposition_Type= -isolated}', ""); +Error('\p{Dt=- iso/a/}'); +Error('\P{Dt=- iso/a/}'); +Expect(1, 64336, '\p{Dt=iso}', ""); +Expect(0, 64336, '\p{^Dt=iso}', ""); +Expect(0, 64336, '\P{Dt=iso}', ""); +Expect(1, 64336, '\P{^Dt=iso}', ""); +Expect(0, 64335, '\p{Dt=iso}', ""); +Expect(1, 64335, '\p{^Dt=iso}', ""); +Expect(1, 64335, '\P{Dt=iso}', ""); +Expect(0, 64335, '\P{^Dt=iso}', ""); +Expect(1, 64336, '\p{Dt: -Iso}', ""); +Expect(0, 64336, '\p{^Dt: -Iso}', ""); +Expect(0, 64336, '\P{Dt: -Iso}', ""); +Expect(1, 64336, '\P{^Dt: -Iso}', ""); +Expect(0, 64335, '\p{Dt: -Iso}', ""); +Expect(1, 64335, '\p{^Dt: -Iso}', ""); +Expect(1, 64335, '\P{Dt: -Iso}', ""); +Expect(0, 64335, '\P{^Dt: -Iso}', ""); +Error('\p{Is_Decomposition_Type=Isolated/a/}'); +Error('\P{Is_Decomposition_Type=Isolated/a/}'); +Expect(1, 64336, '\p{Is_Decomposition_Type=isolated}', ""); +Expect(0, 64336, '\p{^Is_Decomposition_Type=isolated}', ""); +Expect(0, 64336, '\P{Is_Decomposition_Type=isolated}', ""); +Expect(1, 64336, '\P{^Is_Decomposition_Type=isolated}', ""); +Expect(0, 64335, '\p{Is_Decomposition_Type=isolated}', ""); +Expect(1, 64335, '\p{^Is_Decomposition_Type=isolated}', ""); +Expect(1, 64335, '\P{Is_Decomposition_Type=isolated}', ""); +Expect(0, 64335, '\P{^Is_Decomposition_Type=isolated}', ""); +Expect(1, 64336, '\p{Is_Decomposition_Type=_ISOLATED}', ""); +Expect(0, 64336, '\p{^Is_Decomposition_Type=_ISOLATED}', ""); +Expect(0, 64336, '\P{Is_Decomposition_Type=_ISOLATED}', ""); +Expect(1, 64336, '\P{^Is_Decomposition_Type=_ISOLATED}', ""); +Expect(0, 64335, '\p{Is_Decomposition_Type=_ISOLATED}', ""); +Expect(1, 64335, '\p{^Is_Decomposition_Type=_ISOLATED}', ""); +Expect(1, 64335, '\P{Is_Decomposition_Type=_ISOLATED}', ""); +Expect(0, 64335, '\P{^Is_Decomposition_Type=_ISOLATED}', ""); +Error('\p{Is_Dt=-_Iso:=}'); +Error('\P{Is_Dt=-_Iso:=}'); +Expect(1, 64336, '\p{Is_Dt=iso}', ""); +Expect(0, 64336, '\p{^Is_Dt=iso}', ""); +Expect(0, 64336, '\P{Is_Dt=iso}', ""); +Expect(1, 64336, '\P{^Is_Dt=iso}', ""); +Expect(0, 64335, '\p{Is_Dt=iso}', ""); +Expect(1, 64335, '\p{^Is_Dt=iso}', ""); +Expect(1, 64335, '\P{Is_Dt=iso}', ""); +Expect(0, 64335, '\P{^Is_Dt=iso}', ""); +Expect(1, 64336, '\p{Is_Dt= Iso}', ""); +Expect(0, 64336, '\p{^Is_Dt= Iso}', ""); +Expect(0, 64336, '\P{Is_Dt= Iso}', ""); +Expect(1, 64336, '\P{^Is_Dt= Iso}', ""); +Expect(0, 64335, '\p{Is_Dt= Iso}', ""); +Expect(1, 64335, '\p{^Is_Dt= Iso}', ""); +Expect(1, 64335, '\P{Is_Dt= Iso}', ""); +Expect(0, 64335, '\P{^Is_Dt= Iso}', ""); +Error('\p{Decomposition_Type=/a/-Compat}'); +Error('\P{Decomposition_Type=/a/-Compat}'); +Expect(1, 307, '\p{Decomposition_Type=compat}', ""); +Expect(0, 307, '\p{^Decomposition_Type=compat}', ""); +Expect(0, 307, '\P{Decomposition_Type=compat}', ""); +Expect(1, 307, '\P{^Decomposition_Type=compat}', ""); +Expect(0, 7, '\p{Decomposition_Type=compat}', ""); +Expect(1, 7, '\p{^Decomposition_Type=compat}', ""); +Expect(1, 7, '\P{Decomposition_Type=compat}', ""); +Expect(0, 7, '\P{^Decomposition_Type=compat}', ""); +Expect(1, 307, '\p{Decomposition_Type=_compat}', ""); +Expect(0, 307, '\p{^Decomposition_Type=_compat}', ""); +Expect(0, 307, '\P{Decomposition_Type=_compat}', ""); +Expect(1, 307, '\P{^Decomposition_Type=_compat}', ""); +Expect(0, 7, '\p{Decomposition_Type=_compat}', ""); +Expect(1, 7, '\p{^Decomposition_Type=_compat}', ""); +Expect(1, 7, '\P{Decomposition_Type=_compat}', ""); +Expect(0, 7, '\P{^Decomposition_Type=_compat}', ""); +Error('\p{Dt= /a/Com}'); +Error('\P{Dt= /a/Com}'); +Expect(1, 307, '\p{Dt=com}', ""); +Expect(0, 307, '\p{^Dt=com}', ""); +Expect(0, 307, '\P{Dt=com}', ""); +Expect(1, 307, '\P{^Dt=com}', ""); +Expect(0, 7, '\p{Dt=com}', ""); +Expect(1, 7, '\p{^Dt=com}', ""); +Expect(1, 7, '\P{Dt=com}', ""); +Expect(0, 7, '\P{^Dt=com}', ""); +Expect(1, 307, '\p{Dt=-Com}', ""); +Expect(0, 307, '\p{^Dt=-Com}', ""); +Expect(0, 307, '\P{Dt=-Com}', ""); +Expect(1, 307, '\P{^Dt=-Com}', ""); +Expect(0, 7, '\p{Dt=-Com}', ""); +Expect(1, 7, '\p{^Dt=-Com}', ""); +Expect(1, 7, '\P{Dt=-Com}', ""); +Expect(0, 7, '\P{^Dt=-Com}', ""); +Error('\p{Is_Decomposition_Type=/a/ -Compat}'); +Error('\P{Is_Decomposition_Type=/a/ -Compat}'); +Expect(1, 307, '\p{Is_Decomposition_Type=compat}', ""); +Expect(0, 307, '\p{^Is_Decomposition_Type=compat}', ""); +Expect(0, 307, '\P{Is_Decomposition_Type=compat}', ""); +Expect(1, 307, '\P{^Is_Decomposition_Type=compat}', ""); +Expect(0, 7, '\p{Is_Decomposition_Type=compat}', ""); +Expect(1, 7, '\p{^Is_Decomposition_Type=compat}', ""); +Expect(1, 7, '\P{Is_Decomposition_Type=compat}', ""); +Expect(0, 7, '\P{^Is_Decomposition_Type=compat}', ""); +Expect(1, 307, '\p{Is_Decomposition_Type: _compat}', ""); +Expect(0, 307, '\p{^Is_Decomposition_Type: _compat}', ""); +Expect(0, 307, '\P{Is_Decomposition_Type: _compat}', ""); +Expect(1, 307, '\P{^Is_Decomposition_Type: _compat}', ""); +Expect(0, 7, '\p{Is_Decomposition_Type: _compat}', ""); +Expect(1, 7, '\p{^Is_Decomposition_Type: _compat}', ""); +Expect(1, 7, '\P{Is_Decomposition_Type: _compat}', ""); +Expect(0, 7, '\P{^Is_Decomposition_Type: _compat}', ""); +Error('\p{Is_Dt=/a/ Com}'); +Error('\P{Is_Dt=/a/ Com}'); +Expect(1, 307, '\p{Is_Dt=com}', ""); +Expect(0, 307, '\p{^Is_Dt=com}', ""); +Expect(0, 307, '\P{Is_Dt=com}', ""); +Expect(1, 307, '\P{^Is_Dt=com}', ""); +Expect(0, 7, '\p{Is_Dt=com}', ""); +Expect(1, 7, '\p{^Is_Dt=com}', ""); +Expect(1, 7, '\P{Is_Dt=com}', ""); +Expect(0, 7, '\P{^Is_Dt=com}', ""); +Expect(1, 307, '\p{Is_Dt= COM}', ""); +Expect(0, 307, '\p{^Is_Dt= COM}', ""); +Expect(0, 307, '\P{Is_Dt= COM}', ""); +Expect(1, 307, '\P{^Is_Dt= COM}', ""); +Expect(0, 7, '\p{Is_Dt= COM}', ""); +Expect(1, 7, '\p{^Is_Dt= COM}', ""); +Expect(1, 7, '\P{Is_Dt= COM}', ""); +Expect(0, 7, '\P{^Is_Dt= COM}', ""); +Error('\p{Decomposition_Type=/a/ super}'); +Error('\P{Decomposition_Type=/a/ super}'); +Expect(1, 696, '\p{Decomposition_Type: super}', ""); +Expect(0, 696, '\p{^Decomposition_Type: super}', ""); +Expect(0, 696, '\P{Decomposition_Type: super}', ""); +Expect(1, 696, '\P{^Decomposition_Type: super}', ""); +Expect(0, 7, '\p{Decomposition_Type: super}', ""); +Expect(1, 7, '\p{^Decomposition_Type: super}', ""); +Expect(1, 7, '\P{Decomposition_Type: super}', ""); +Expect(0, 7, '\P{^Decomposition_Type: super}', ""); +Expect(1, 696, '\p{Decomposition_Type=-SUPER}', ""); +Expect(0, 696, '\p{^Decomposition_Type=-SUPER}', ""); +Expect(0, 696, '\P{Decomposition_Type=-SUPER}', ""); +Expect(1, 696, '\P{^Decomposition_Type=-SUPER}', ""); +Expect(0, 7, '\p{Decomposition_Type=-SUPER}', ""); +Expect(1, 7, '\p{^Decomposition_Type=-SUPER}', ""); +Expect(1, 7, '\P{Decomposition_Type=-SUPER}', ""); +Expect(0, 7, '\P{^Decomposition_Type=-SUPER}', ""); +Error('\p{Dt=_/a/Sup}'); +Error('\P{Dt=_/a/Sup}'); +Expect(1, 696, '\p{Dt=sup}', ""); +Expect(0, 696, '\p{^Dt=sup}', ""); +Expect(0, 696, '\P{Dt=sup}', ""); +Expect(1, 696, '\P{^Dt=sup}', ""); +Expect(0, 7, '\p{Dt=sup}', ""); +Expect(1, 7, '\p{^Dt=sup}', ""); +Expect(1, 7, '\P{Dt=sup}', ""); +Expect(0, 7, '\P{^Dt=sup}', ""); +Expect(1, 696, '\p{Dt=- sup}', ""); +Expect(0, 696, '\p{^Dt=- sup}', ""); +Expect(0, 696, '\P{Dt=- sup}', ""); +Expect(1, 696, '\P{^Dt=- sup}', ""); +Expect(0, 7, '\p{Dt=- sup}', ""); +Expect(1, 7, '\p{^Dt=- sup}', ""); +Expect(1, 7, '\P{Dt=- sup}', ""); +Expect(0, 7, '\P{^Dt=- sup}', ""); +Error('\p{Is_Decomposition_Type=:=-Super}'); +Error('\P{Is_Decomposition_Type=:=-Super}'); +Expect(1, 696, '\p{Is_Decomposition_Type:super}', ""); +Expect(0, 696, '\p{^Is_Decomposition_Type:super}', ""); +Expect(0, 696, '\P{Is_Decomposition_Type:super}', ""); +Expect(1, 696, '\P{^Is_Decomposition_Type:super}', ""); +Expect(0, 7, '\p{Is_Decomposition_Type:super}', ""); +Expect(1, 7, '\p{^Is_Decomposition_Type:super}', ""); +Expect(1, 7, '\P{Is_Decomposition_Type:super}', ""); +Expect(0, 7, '\P{^Is_Decomposition_Type:super}', ""); +Expect(1, 696, '\p{Is_Decomposition_Type: -_SUPER}', ""); +Expect(0, 696, '\p{^Is_Decomposition_Type: -_SUPER}', ""); +Expect(0, 696, '\P{Is_Decomposition_Type: -_SUPER}', ""); +Expect(1, 696, '\P{^Is_Decomposition_Type: -_SUPER}', ""); +Expect(0, 7, '\p{Is_Decomposition_Type: -_SUPER}', ""); +Expect(1, 7, '\p{^Is_Decomposition_Type: -_SUPER}', ""); +Expect(1, 7, '\P{Is_Decomposition_Type: -_SUPER}', ""); +Expect(0, 7, '\P{^Is_Decomposition_Type: -_SUPER}', ""); +Error('\p{Is_Dt=:= SUP}'); +Error('\P{Is_Dt=:= SUP}'); +Expect(1, 696, '\p{Is_Dt=sup}', ""); +Expect(0, 696, '\p{^Is_Dt=sup}', ""); +Expect(0, 696, '\P{Is_Dt=sup}', ""); +Expect(1, 696, '\P{^Is_Dt=sup}', ""); +Expect(0, 7, '\p{Is_Dt=sup}', ""); +Expect(1, 7, '\p{^Is_Dt=sup}', ""); +Expect(1, 7, '\P{Is_Dt=sup}', ""); +Expect(0, 7, '\P{^Is_Dt=sup}', ""); +Expect(1, 696, '\p{Is_Dt=- SUP}', ""); +Expect(0, 696, '\p{^Is_Dt=- SUP}', ""); +Expect(0, 696, '\P{Is_Dt=- SUP}', ""); +Expect(1, 696, '\P{^Is_Dt=- SUP}', ""); +Expect(0, 7, '\p{Is_Dt=- SUP}', ""); +Expect(1, 7, '\p{^Is_Dt=- SUP}', ""); +Expect(1, 7, '\P{Is_Dt=- SUP}', ""); +Expect(0, 7, '\P{^Is_Dt=- SUP}', ""); +Error('\p{Other_Math= /a/yes}'); +Error('\P{Other_Math= /a/yes}'); +Expect(1, 94, '\p{Other_Math=yes}', 'deprecated'); +Expect(0, 94, '\p{^Other_Math=yes}', 'deprecated'); +Expect(0, 94, '\P{Other_Math=yes}', 'deprecated'); +Expect(1, 94, '\P{^Other_Math=yes}', 'deprecated'); +Expect(0, 93, '\p{Other_Math=yes}', 'deprecated'); +Expect(1, 93, '\p{^Other_Math=yes}', 'deprecated'); +Expect(1, 93, '\P{Other_Math=yes}', 'deprecated'); +Expect(0, 93, '\P{^Other_Math=yes}', 'deprecated'); +Expect(1, 94, '\p{Other_Math= Yes}', 'deprecated'); +Expect(0, 94, '\p{^Other_Math= Yes}', 'deprecated'); +Expect(0, 94, '\P{Other_Math= Yes}', 'deprecated'); +Expect(1, 94, '\P{^Other_Math= Yes}', 'deprecated'); +Expect(0, 93, '\p{Other_Math= Yes}', 'deprecated'); +Expect(1, 93, '\p{^Other_Math= Yes}', 'deprecated'); +Expect(1, 93, '\P{Other_Math= Yes}', 'deprecated'); +Expect(0, 93, '\P{^Other_Math= Yes}', 'deprecated'); +Error('\p{OMath= :=Y}'); +Error('\P{OMath= :=Y}'); +Expect(1, 94, '\p{OMath=y}', 'deprecated'); +Expect(0, 94, '\p{^OMath=y}', 'deprecated'); +Expect(0, 94, '\P{OMath=y}', 'deprecated'); +Expect(1, 94, '\P{^OMath=y}', 'deprecated'); +Expect(0, 93, '\p{OMath=y}', 'deprecated'); +Expect(1, 93, '\p{^OMath=y}', 'deprecated'); +Expect(1, 93, '\P{OMath=y}', 'deprecated'); +Expect(0, 93, '\P{^OMath=y}', 'deprecated'); +Expect(1, 94, '\p{OMath=- Y}', 'deprecated'); +Expect(0, 94, '\p{^OMath=- Y}', 'deprecated'); +Expect(0, 94, '\P{OMath=- Y}', 'deprecated'); +Expect(1, 94, '\P{^OMath=- Y}', 'deprecated'); +Expect(0, 93, '\p{OMath=- Y}', 'deprecated'); +Expect(1, 93, '\p{^OMath=- Y}', 'deprecated'); +Expect(1, 93, '\P{OMath=- Y}', 'deprecated'); +Expect(0, 93, '\P{^OMath=- Y}', 'deprecated'); +Error('\p{Is_Other_Math= /a/t}'); +Error('\P{Is_Other_Math= /a/t}'); +Expect(1, 94, '\p{Is_Other_Math=t}', 'deprecated'); +Expect(0, 94, '\p{^Is_Other_Math=t}', 'deprecated'); +Expect(0, 94, '\P{Is_Other_Math=t}', 'deprecated'); +Expect(1, 94, '\P{^Is_Other_Math=t}', 'deprecated'); +Expect(0, 93, '\p{Is_Other_Math=t}', 'deprecated'); +Expect(1, 93, '\p{^Is_Other_Math=t}', 'deprecated'); +Expect(1, 93, '\P{Is_Other_Math=t}', 'deprecated'); +Expect(0, 93, '\P{^Is_Other_Math=t}', 'deprecated'); +Expect(1, 94, '\p{Is_Other_Math=- T}', 'deprecated'); +Expect(0, 94, '\p{^Is_Other_Math=- T}', 'deprecated'); +Expect(0, 94, '\P{Is_Other_Math=- T}', 'deprecated'); +Expect(1, 94, '\P{^Is_Other_Math=- T}', 'deprecated'); +Expect(0, 93, '\p{Is_Other_Math=- T}', 'deprecated'); +Expect(1, 93, '\p{^Is_Other_Math=- T}', 'deprecated'); +Expect(1, 93, '\P{Is_Other_Math=- T}', 'deprecated'); +Expect(0, 93, '\P{^Is_Other_Math=- T}', 'deprecated'); +Error('\p{Is_OMath=- True/a/}'); +Error('\P{Is_OMath=- True/a/}'); +Expect(1, 94, '\p{Is_OMath:true}', 'deprecated'); +Expect(0, 94, '\p{^Is_OMath:true}', 'deprecated'); +Expect(0, 94, '\P{Is_OMath:true}', 'deprecated'); +Expect(1, 94, '\P{^Is_OMath:true}', 'deprecated'); +Expect(0, 93, '\p{Is_OMath:true}', 'deprecated'); +Expect(1, 93, '\p{^Is_OMath:true}', 'deprecated'); +Expect(1, 93, '\P{Is_OMath:true}', 'deprecated'); +Expect(0, 93, '\P{^Is_OMath:true}', 'deprecated'); +Expect(1, 94, '\p{Is_OMath= _true}', 'deprecated'); +Expect(0, 94, '\p{^Is_OMath= _true}', 'deprecated'); +Expect(0, 94, '\P{Is_OMath= _true}', 'deprecated'); +Expect(1, 94, '\P{^Is_OMath= _true}', 'deprecated'); +Expect(0, 93, '\p{Is_OMath= _true}', 'deprecated'); +Expect(1, 93, '\p{^Is_OMath= _true}', 'deprecated'); +Expect(1, 93, '\P{Is_OMath= _true}', 'deprecated'); +Expect(0, 93, '\P{^Is_OMath= _true}', 'deprecated'); +Error('\p{Other_Math=--No:=}'); +Error('\P{Other_Math=--No:=}'); +Expect(1, 93, '\p{Other_Math=no}', 'deprecated'); +Expect(0, 93, '\p{^Other_Math=no}', 'deprecated'); +Expect(0, 93, '\P{Other_Math=no}', 'deprecated'); +Expect(1, 93, '\P{^Other_Math=no}', 'deprecated'); +Expect(0, 94, '\p{Other_Math=no}', 'deprecated'); +Expect(1, 94, '\p{^Other_Math=no}', 'deprecated'); +Expect(1, 94, '\P{Other_Math=no}', 'deprecated'); +Expect(0, 94, '\P{^Other_Math=no}', 'deprecated'); +Expect(1, 93, '\p{Other_Math= No}', 'deprecated'); +Expect(0, 93, '\p{^Other_Math= No}', 'deprecated'); +Expect(0, 93, '\P{Other_Math= No}', 'deprecated'); +Expect(1, 93, '\P{^Other_Math= No}', 'deprecated'); +Expect(0, 94, '\p{Other_Math= No}', 'deprecated'); +Expect(1, 94, '\p{^Other_Math= No}', 'deprecated'); +Expect(1, 94, '\P{Other_Math= No}', 'deprecated'); +Expect(0, 94, '\P{^Other_Math= No}', 'deprecated'); +Error('\p{OMath=/a/ N}'); +Error('\P{OMath=/a/ N}'); +Expect(1, 93, '\p{OMath=n}', 'deprecated'); +Expect(0, 93, '\p{^OMath=n}', 'deprecated'); +Expect(0, 93, '\P{OMath=n}', 'deprecated'); +Expect(1, 93, '\P{^OMath=n}', 'deprecated'); +Expect(0, 94, '\p{OMath=n}', 'deprecated'); +Expect(1, 94, '\p{^OMath=n}', 'deprecated'); +Expect(1, 94, '\P{OMath=n}', 'deprecated'); +Expect(0, 94, '\P{^OMath=n}', 'deprecated'); +Expect(1, 93, '\p{OMath= N}', 'deprecated'); +Expect(0, 93, '\p{^OMath= N}', 'deprecated'); +Expect(0, 93, '\P{OMath= N}', 'deprecated'); +Expect(1, 93, '\P{^OMath= N}', 'deprecated'); +Expect(0, 94, '\p{OMath= N}', 'deprecated'); +Expect(1, 94, '\p{^OMath= N}', 'deprecated'); +Expect(1, 94, '\P{OMath= N}', 'deprecated'); +Expect(0, 94, '\P{^OMath= N}', 'deprecated'); +Error('\p{Is_Other_Math=_F:=}'); +Error('\P{Is_Other_Math=_F:=}'); +Expect(1, 93, '\p{Is_Other_Math=f}', 'deprecated'); +Expect(0, 93, '\p{^Is_Other_Math=f}', 'deprecated'); +Expect(0, 93, '\P{Is_Other_Math=f}', 'deprecated'); +Expect(1, 93, '\P{^Is_Other_Math=f}', 'deprecated'); +Expect(0, 94, '\p{Is_Other_Math=f}', 'deprecated'); +Expect(1, 94, '\p{^Is_Other_Math=f}', 'deprecated'); +Expect(1, 94, '\P{Is_Other_Math=f}', 'deprecated'); +Expect(0, 94, '\P{^Is_Other_Math=f}', 'deprecated'); +Expect(1, 93, '\p{Is_Other_Math= F}', 'deprecated'); +Expect(0, 93, '\p{^Is_Other_Math= F}', 'deprecated'); +Expect(0, 93, '\P{Is_Other_Math= F}', 'deprecated'); +Expect(1, 93, '\P{^Is_Other_Math= F}', 'deprecated'); +Expect(0, 94, '\p{Is_Other_Math= F}', 'deprecated'); +Expect(1, 94, '\p{^Is_Other_Math= F}', 'deprecated'); +Expect(1, 94, '\P{Is_Other_Math= F}', 'deprecated'); +Expect(0, 94, '\P{^Is_Other_Math= F}', 'deprecated'); +Error('\p{Is_OMath=:= False}'); +Error('\P{Is_OMath=:= False}'); +Expect(1, 93, '\p{Is_OMath=false}', 'deprecated'); +Expect(0, 93, '\p{^Is_OMath=false}', 'deprecated'); +Expect(0, 93, '\P{Is_OMath=false}', 'deprecated'); +Expect(1, 93, '\P{^Is_OMath=false}', 'deprecated'); +Expect(0, 94, '\p{Is_OMath=false}', 'deprecated'); +Expect(1, 94, '\p{^Is_OMath=false}', 'deprecated'); +Expect(1, 94, '\P{Is_OMath=false}', 'deprecated'); +Expect(0, 94, '\P{^Is_OMath=false}', 'deprecated'); +Expect(1, 93, '\p{Is_OMath= FALSE}', 'deprecated'); +Expect(0, 93, '\p{^Is_OMath= FALSE}', 'deprecated'); +Expect(0, 93, '\P{Is_OMath= FALSE}', 'deprecated'); +Expect(1, 93, '\P{^Is_OMath= FALSE}', 'deprecated'); +Expect(0, 94, '\p{Is_OMath= FALSE}', 'deprecated'); +Expect(1, 94, '\p{^Is_OMath= FALSE}', 'deprecated'); +Expect(1, 94, '\P{Is_OMath= FALSE}', 'deprecated'); +Expect(0, 94, '\P{^Is_OMath= FALSE}', 'deprecated'); +Error('\p{Hyphen=:=--YES}'); +Error('\P{Hyphen=:=--YES}'); +Expect(1, 45, '\p{Hyphen=yes}', ""); +Expect(0, 45, '\p{^Hyphen=yes}', ""); +Expect(0, 45, '\P{Hyphen=yes}', ""); +Expect(1, 45, '\P{^Hyphen=yes}', ""); +Expect(0, 44, '\p{Hyphen=yes}', ""); +Expect(1, 44, '\p{^Hyphen=yes}', ""); +Expect(1, 44, '\P{Hyphen=yes}', ""); +Expect(0, 44, '\P{^Hyphen=yes}', ""); +Expect(1, 45, '\p{Hyphen= Yes}', ""); +Expect(0, 45, '\p{^Hyphen= Yes}', ""); +Expect(0, 45, '\P{Hyphen= Yes}', ""); +Expect(1, 45, '\P{^Hyphen= Yes}', ""); +Expect(0, 44, '\p{Hyphen= Yes}', ""); +Expect(1, 44, '\p{^Hyphen= Yes}', ""); +Expect(1, 44, '\P{Hyphen= Yes}', ""); +Expect(0, 44, '\P{^Hyphen= Yes}', ""); +Error('\p{Is_Hyphen=:=- y}'); +Error('\P{Is_Hyphen=:=- y}'); +Expect(1, 45, '\p{Is_Hyphen=y}', ""); +Expect(0, 45, '\p{^Is_Hyphen=y}', ""); +Expect(0, 45, '\P{Is_Hyphen=y}', ""); +Expect(1, 45, '\P{^Is_Hyphen=y}', ""); +Expect(0, 44, '\p{Is_Hyphen=y}', ""); +Expect(1, 44, '\p{^Is_Hyphen=y}', ""); +Expect(1, 44, '\P{Is_Hyphen=y}', ""); +Expect(0, 44, '\P{^Is_Hyphen=y}', ""); +Expect(1, 45, '\p{Is_Hyphen=__Y}', ""); +Expect(0, 45, '\p{^Is_Hyphen=__Y}', ""); +Expect(0, 45, '\P{Is_Hyphen=__Y}', ""); +Expect(1, 45, '\P{^Is_Hyphen=__Y}', ""); +Expect(0, 44, '\p{Is_Hyphen=__Y}', ""); +Expect(1, 44, '\p{^Is_Hyphen=__Y}', ""); +Expect(1, 44, '\P{Is_Hyphen=__Y}', ""); +Expect(0, 44, '\P{^Is_Hyphen=__Y}', ""); +Error('\p{Hyphen=-T/a/}'); +Error('\P{Hyphen=-T/a/}'); +Expect(1, 45, '\p{Hyphen=t}', ""); +Expect(0, 45, '\p{^Hyphen=t}', ""); +Expect(0, 45, '\P{Hyphen=t}', ""); +Expect(1, 45, '\P{^Hyphen=t}', ""); +Expect(0, 44, '\p{Hyphen=t}', ""); +Expect(1, 44, '\p{^Hyphen=t}', ""); +Expect(1, 44, '\P{Hyphen=t}', ""); +Expect(0, 44, '\P{^Hyphen=t}', ""); +Expect(1, 45, '\p{Hyphen=-_T}', ""); +Expect(0, 45, '\p{^Hyphen=-_T}', ""); +Expect(0, 45, '\P{Hyphen=-_T}', ""); +Expect(1, 45, '\P{^Hyphen=-_T}', ""); +Expect(0, 44, '\p{Hyphen=-_T}', ""); +Expect(1, 44, '\p{^Hyphen=-_T}', ""); +Expect(1, 44, '\P{Hyphen=-_T}', ""); +Expect(0, 44, '\P{^Hyphen=-_T}', ""); +Error('\p{Is_Hyphen=True:=}'); +Error('\P{Is_Hyphen=True:=}'); +Expect(1, 45, '\p{Is_Hyphen: true}', ""); +Expect(0, 45, '\p{^Is_Hyphen: true}', ""); +Expect(0, 45, '\P{Is_Hyphen: true}', ""); +Expect(1, 45, '\P{^Is_Hyphen: true}', ""); +Expect(0, 44, '\p{Is_Hyphen: true}', ""); +Expect(1, 44, '\p{^Is_Hyphen: true}', ""); +Expect(1, 44, '\P{Is_Hyphen: true}', ""); +Expect(0, 44, '\P{^Is_Hyphen: true}', ""); +Expect(1, 45, '\p{Is_Hyphen= True}', ""); +Expect(0, 45, '\p{^Is_Hyphen= True}', ""); +Expect(0, 45, '\P{Is_Hyphen= True}', ""); +Expect(1, 45, '\P{^Is_Hyphen= True}', ""); +Expect(0, 44, '\p{Is_Hyphen= True}', ""); +Expect(1, 44, '\p{^Is_Hyphen= True}', ""); +Expect(1, 44, '\P{Is_Hyphen= True}', ""); +Expect(0, 44, '\P{^Is_Hyphen= True}', ""); +Error('\p{Hyphen=-NO:=}'); +Error('\P{Hyphen=-NO:=}'); +Expect(1, 44, '\p{Hyphen=no}', ""); +Expect(0, 44, '\p{^Hyphen=no}', ""); +Expect(0, 44, '\P{Hyphen=no}', ""); +Expect(1, 44, '\P{^Hyphen=no}', ""); +Expect(0, 45, '\p{Hyphen=no}', ""); +Expect(1, 45, '\p{^Hyphen=no}', ""); +Expect(1, 45, '\P{Hyphen=no}', ""); +Expect(0, 45, '\P{^Hyphen=no}', ""); +Expect(1, 44, '\p{Hyphen= No}', ""); +Expect(0, 44, '\p{^Hyphen= No}', ""); +Expect(0, 44, '\P{Hyphen= No}', ""); +Expect(1, 44, '\P{^Hyphen= No}', ""); +Expect(0, 45, '\p{Hyphen= No}', ""); +Expect(1, 45, '\p{^Hyphen= No}', ""); +Expect(1, 45, '\P{Hyphen= No}', ""); +Expect(0, 45, '\P{^Hyphen= No}', ""); +Error('\p{Is_Hyphen=/a/ n}'); +Error('\P{Is_Hyphen=/a/ n}'); +Expect(1, 44, '\p{Is_Hyphen=n}', ""); +Expect(0, 44, '\p{^Is_Hyphen=n}', ""); +Expect(0, 44, '\P{Is_Hyphen=n}', ""); +Expect(1, 44, '\P{^Is_Hyphen=n}', ""); +Expect(0, 45, '\p{Is_Hyphen=n}', ""); +Expect(1, 45, '\p{^Is_Hyphen=n}', ""); +Expect(1, 45, '\P{Is_Hyphen=n}', ""); +Expect(0, 45, '\P{^Is_Hyphen=n}', ""); +Expect(1, 44, '\p{Is_Hyphen= -n}', ""); +Expect(0, 44, '\p{^Is_Hyphen= -n}', ""); +Expect(0, 44, '\P{Is_Hyphen= -n}', ""); +Expect(1, 44, '\P{^Is_Hyphen= -n}', ""); +Expect(0, 45, '\p{Is_Hyphen= -n}', ""); +Expect(1, 45, '\p{^Is_Hyphen= -n}', ""); +Expect(1, 45, '\P{Is_Hyphen= -n}', ""); +Expect(0, 45, '\P{^Is_Hyphen= -n}', ""); +Error('\p{Hyphen: /a/_F}'); +Error('\P{Hyphen: /a/_F}'); +Expect(1, 44, '\p{Hyphen=f}', ""); +Expect(0, 44, '\p{^Hyphen=f}', ""); +Expect(0, 44, '\P{Hyphen=f}', ""); +Expect(1, 44, '\P{^Hyphen=f}', ""); +Expect(0, 45, '\p{Hyphen=f}', ""); +Expect(1, 45, '\p{^Hyphen=f}', ""); +Expect(1, 45, '\P{Hyphen=f}', ""); +Expect(0, 45, '\P{^Hyphen=f}', ""); +Expect(1, 44, '\p{Hyphen= F}', ""); +Expect(0, 44, '\p{^Hyphen= F}', ""); +Expect(0, 44, '\P{Hyphen= F}', ""); +Expect(1, 44, '\P{^Hyphen= F}', ""); +Expect(0, 45, '\p{Hyphen= F}', ""); +Expect(1, 45, '\p{^Hyphen= F}', ""); +Expect(1, 45, '\P{Hyphen= F}', ""); +Expect(0, 45, '\P{^Hyphen= F}', ""); +Error('\p{Is_Hyphen= _False/a/}'); +Error('\P{Is_Hyphen= _False/a/}'); +Expect(1, 44, '\p{Is_Hyphen=false}', ""); +Expect(0, 44, '\p{^Is_Hyphen=false}', ""); +Expect(0, 44, '\P{Is_Hyphen=false}', ""); +Expect(1, 44, '\P{^Is_Hyphen=false}', ""); +Expect(0, 45, '\p{Is_Hyphen=false}', ""); +Expect(1, 45, '\p{^Is_Hyphen=false}', ""); +Expect(1, 45, '\P{Is_Hyphen=false}', ""); +Expect(0, 45, '\P{^Is_Hyphen=false}', ""); +Expect(1, 44, '\p{Is_Hyphen= False}', ""); +Expect(0, 44, '\p{^Is_Hyphen= False}', ""); +Expect(0, 44, '\P{Is_Hyphen= False}', ""); +Expect(1, 44, '\P{^Is_Hyphen= False}', ""); +Expect(0, 45, '\p{Is_Hyphen= False}', ""); +Expect(1, 45, '\p{^Is_Hyphen= False}', ""); +Expect(1, 45, '\P{Is_Hyphen= False}', ""); +Expect(0, 45, '\P{^Is_Hyphen= False}', ""); +Error('\p{White_Space=:=-Yes}'); +Error('\P{White_Space=:=-Yes}'); +Expect(1, 13, '\p{White_Space=yes}', ""); +Expect(0, 13, '\p{^White_Space=yes}', ""); +Expect(0, 13, '\P{White_Space=yes}', ""); +Expect(1, 13, '\P{^White_Space=yes}', ""); +Expect(0, 8, '\p{White_Space=yes}', ""); +Expect(1, 8, '\p{^White_Space=yes}', ""); +Expect(1, 8, '\P{White_Space=yes}', ""); +Expect(0, 8, '\P{^White_Space=yes}', ""); +Expect(1, 13, '\p{White_Space= Yes}', ""); +Expect(0, 13, '\p{^White_Space= Yes}', ""); +Expect(0, 13, '\P{White_Space= Yes}', ""); +Expect(1, 13, '\P{^White_Space= Yes}', ""); +Expect(0, 8, '\p{White_Space= Yes}', ""); +Expect(1, 8, '\p{^White_Space= Yes}', ""); +Expect(1, 8, '\P{White_Space= Yes}', ""); +Expect(0, 8, '\P{^White_Space= Yes}', ""); +Error('\p{WSpace= /a/Y}'); +Error('\P{WSpace= /a/Y}'); +Expect(1, 13, '\p{WSpace=y}', ""); +Expect(0, 13, '\p{^WSpace=y}', ""); +Expect(0, 13, '\P{WSpace=y}', ""); +Expect(1, 13, '\P{^WSpace=y}', ""); +Expect(0, 8, '\p{WSpace=y}', ""); +Expect(1, 8, '\p{^WSpace=y}', ""); +Expect(1, 8, '\P{WSpace=y}', ""); +Expect(0, 8, '\P{^WSpace=y}', ""); +Expect(1, 13, '\p{WSpace= _Y}', ""); +Expect(0, 13, '\p{^WSpace= _Y}', ""); +Expect(0, 13, '\P{WSpace= _Y}', ""); +Expect(1, 13, '\P{^WSpace= _Y}', ""); +Expect(0, 8, '\p{WSpace= _Y}', ""); +Expect(1, 8, '\p{^WSpace= _Y}', ""); +Expect(1, 8, '\P{WSpace= _Y}', ""); +Expect(0, 8, '\P{^WSpace= _Y}', ""); +Error('\p{Space=-_t:=}'); +Error('\P{Space=-_t:=}'); +Expect(1, 13, '\p{Space=t}', ""); +Expect(0, 13, '\p{^Space=t}', ""); +Expect(0, 13, '\P{Space=t}', ""); +Expect(1, 13, '\P{^Space=t}', ""); +Expect(0, 8, '\p{Space=t}', ""); +Expect(1, 8, '\p{^Space=t}', ""); +Expect(1, 8, '\P{Space=t}', ""); +Expect(0, 8, '\P{^Space=t}', ""); +Expect(1, 13, '\p{Space= T}', ""); +Expect(0, 13, '\p{^Space= T}', ""); +Expect(0, 13, '\P{Space= T}', ""); +Expect(1, 13, '\P{^Space= T}', ""); +Expect(0, 8, '\p{Space= T}', ""); +Expect(1, 8, '\p{^Space= T}', ""); +Expect(1, 8, '\P{Space= T}', ""); +Expect(0, 8, '\P{^Space= T}', ""); +Error('\p{Is_White_Space=_/a/TRUE}'); +Error('\P{Is_White_Space=_/a/TRUE}'); +Expect(1, 13, '\p{Is_White_Space=true}', ""); +Expect(0, 13, '\p{^Is_White_Space=true}', ""); +Expect(0, 13, '\P{Is_White_Space=true}', ""); +Expect(1, 13, '\P{^Is_White_Space=true}', ""); +Expect(0, 8, '\p{Is_White_Space=true}', ""); +Expect(1, 8, '\p{^Is_White_Space=true}', ""); +Expect(1, 8, '\P{Is_White_Space=true}', ""); +Expect(0, 8, '\P{^Is_White_Space=true}', ""); +Expect(1, 13, '\p{Is_White_Space=_true}', ""); +Expect(0, 13, '\p{^Is_White_Space=_true}', ""); +Expect(0, 13, '\P{Is_White_Space=_true}', ""); +Expect(1, 13, '\P{^Is_White_Space=_true}', ""); +Expect(0, 8, '\p{Is_White_Space=_true}', ""); +Expect(1, 8, '\p{^Is_White_Space=_true}', ""); +Expect(1, 8, '\P{Is_White_Space=_true}', ""); +Expect(0, 8, '\P{^Is_White_Space=_true}', ""); +Error('\p{Is_WSpace=__Yes/a/}'); +Error('\P{Is_WSpace=__Yes/a/}'); +Expect(1, 13, '\p{Is_WSpace=yes}', ""); +Expect(0, 13, '\p{^Is_WSpace=yes}', ""); +Expect(0, 13, '\P{Is_WSpace=yes}', ""); +Expect(1, 13, '\P{^Is_WSpace=yes}', ""); +Expect(0, 8, '\p{Is_WSpace=yes}', ""); +Expect(1, 8, '\p{^Is_WSpace=yes}', ""); +Expect(1, 8, '\P{Is_WSpace=yes}', ""); +Expect(0, 8, '\P{^Is_WSpace=yes}', ""); +Expect(1, 13, '\p{Is_WSpace= Yes}', ""); +Expect(0, 13, '\p{^Is_WSpace= Yes}', ""); +Expect(0, 13, '\P{Is_WSpace= Yes}', ""); +Expect(1, 13, '\P{^Is_WSpace= Yes}', ""); +Expect(0, 8, '\p{Is_WSpace= Yes}', ""); +Expect(1, 8, '\p{^Is_WSpace= Yes}', ""); +Expect(1, 8, '\P{Is_WSpace= Yes}', ""); +Expect(0, 8, '\P{^Is_WSpace= Yes}', ""); +Error('\p{Is_Space=/a/Y}'); +Error('\P{Is_Space=/a/Y}'); +Expect(1, 13, '\p{Is_Space=y}', ""); +Expect(0, 13, '\p{^Is_Space=y}', ""); +Expect(0, 13, '\P{Is_Space=y}', ""); +Expect(1, 13, '\P{^Is_Space=y}', ""); +Expect(0, 8, '\p{Is_Space=y}', ""); +Expect(1, 8, '\p{^Is_Space=y}', ""); +Expect(1, 8, '\P{Is_Space=y}', ""); +Expect(0, 8, '\P{^Is_Space=y}', ""); +Expect(1, 13, '\p{Is_Space=-y}', ""); +Expect(0, 13, '\p{^Is_Space=-y}', ""); +Expect(0, 13, '\P{Is_Space=-y}', ""); +Expect(1, 13, '\P{^Is_Space=-y}', ""); +Expect(0, 8, '\p{Is_Space=-y}', ""); +Expect(1, 8, '\p{^Is_Space=-y}', ""); +Expect(1, 8, '\P{Is_Space=-y}', ""); +Expect(0, 8, '\P{^Is_Space=-y}', ""); +Error('\p{White_Space: :=No}'); +Error('\P{White_Space: :=No}'); +Expect(1, 8, '\p{White_Space=no}', ""); +Expect(0, 8, '\p{^White_Space=no}', ""); +Expect(0, 8, '\P{White_Space=no}', ""); +Expect(1, 8, '\P{^White_Space=no}', ""); +Expect(0, 13, '\p{White_Space=no}', ""); +Expect(1, 13, '\p{^White_Space=no}', ""); +Expect(1, 13, '\P{White_Space=no}', ""); +Expect(0, 13, '\P{^White_Space=no}', ""); +Expect(1, 8, '\p{White_Space: -NO}', ""); +Expect(0, 8, '\p{^White_Space: -NO}', ""); +Expect(0, 8, '\P{White_Space: -NO}', ""); +Expect(1, 8, '\P{^White_Space: -NO}', ""); +Expect(0, 13, '\p{White_Space: -NO}', ""); +Expect(1, 13, '\p{^White_Space: -NO}', ""); +Expect(1, 13, '\P{White_Space: -NO}', ""); +Expect(0, 13, '\P{^White_Space: -NO}', ""); +Error('\p{WSpace: N:=}'); +Error('\P{WSpace: N:=}'); +Expect(1, 8, '\p{WSpace=n}', ""); +Expect(0, 8, '\p{^WSpace=n}', ""); +Expect(0, 8, '\P{WSpace=n}', ""); +Expect(1, 8, '\P{^WSpace=n}', ""); +Expect(0, 13, '\p{WSpace=n}', ""); +Expect(1, 13, '\p{^WSpace=n}', ""); +Expect(1, 13, '\P{WSpace=n}', ""); +Expect(0, 13, '\P{^WSpace=n}', ""); +Expect(1, 8, '\p{WSpace:_n}', ""); +Expect(0, 8, '\p{^WSpace:_n}', ""); +Expect(0, 8, '\P{WSpace:_n}', ""); +Expect(1, 8, '\P{^WSpace:_n}', ""); +Expect(0, 13, '\p{WSpace:_n}', ""); +Expect(1, 13, '\p{^WSpace:_n}', ""); +Expect(1, 13, '\P{WSpace:_n}', ""); +Expect(0, 13, '\P{^WSpace:_n}', ""); +Error('\p{Space=:= f}'); +Error('\P{Space=:= f}'); +Expect(1, 8, '\p{Space=f}', ""); +Expect(0, 8, '\p{^Space=f}', ""); +Expect(0, 8, '\P{Space=f}', ""); +Expect(1, 8, '\P{^Space=f}', ""); +Expect(0, 13, '\p{Space=f}', ""); +Expect(1, 13, '\p{^Space=f}', ""); +Expect(1, 13, '\P{Space=f}', ""); +Expect(0, 13, '\P{^Space=f}', ""); +Expect(1, 8, '\p{Space=_-f}', ""); +Expect(0, 8, '\p{^Space=_-f}', ""); +Expect(0, 8, '\P{Space=_-f}', ""); +Expect(1, 8, '\P{^Space=_-f}', ""); +Expect(0, 13, '\p{Space=_-f}', ""); +Expect(1, 13, '\p{^Space=_-f}', ""); +Expect(1, 13, '\P{Space=_-f}', ""); +Expect(0, 13, '\P{^Space=_-f}', ""); +Error('\p{Is_White_Space=_-false:=}'); +Error('\P{Is_White_Space=_-false:=}'); +Expect(1, 8, '\p{Is_White_Space=false}', ""); +Expect(0, 8, '\p{^Is_White_Space=false}', ""); +Expect(0, 8, '\P{Is_White_Space=false}', ""); +Expect(1, 8, '\P{^Is_White_Space=false}', ""); +Expect(0, 13, '\p{Is_White_Space=false}', ""); +Expect(1, 13, '\p{^Is_White_Space=false}', ""); +Expect(1, 13, '\P{Is_White_Space=false}', ""); +Expect(0, 13, '\P{^Is_White_Space=false}', ""); +Expect(1, 8, '\p{Is_White_Space=_ FALSE}', ""); +Expect(0, 8, '\p{^Is_White_Space=_ FALSE}', ""); +Expect(0, 8, '\P{Is_White_Space=_ FALSE}', ""); +Expect(1, 8, '\P{^Is_White_Space=_ FALSE}', ""); +Expect(0, 13, '\p{Is_White_Space=_ FALSE}', ""); +Expect(1, 13, '\p{^Is_White_Space=_ FALSE}', ""); +Expect(1, 13, '\P{Is_White_Space=_ FALSE}', ""); +Expect(0, 13, '\P{^Is_White_Space=_ FALSE}', ""); +Error('\p{Is_WSpace= _no/a/}'); +Error('\P{Is_WSpace= _no/a/}'); +Expect(1, 8, '\p{Is_WSpace=no}', ""); +Expect(0, 8, '\p{^Is_WSpace=no}', ""); +Expect(0, 8, '\P{Is_WSpace=no}', ""); +Expect(1, 8, '\P{^Is_WSpace=no}', ""); +Expect(0, 13, '\p{Is_WSpace=no}', ""); +Expect(1, 13, '\p{^Is_WSpace=no}', ""); +Expect(1, 13, '\P{Is_WSpace=no}', ""); +Expect(0, 13, '\P{^Is_WSpace=no}', ""); +Expect(1, 8, '\p{Is_WSpace: NO}', ""); +Expect(0, 8, '\p{^Is_WSpace: NO}', ""); +Expect(0, 8, '\P{Is_WSpace: NO}', ""); +Expect(1, 8, '\P{^Is_WSpace: NO}', ""); +Expect(0, 13, '\p{Is_WSpace: NO}', ""); +Expect(1, 13, '\p{^Is_WSpace: NO}', ""); +Expect(1, 13, '\P{Is_WSpace: NO}', ""); +Expect(0, 13, '\P{^Is_WSpace: NO}', ""); +Error('\p{Is_Space= N/a/}'); +Error('\P{Is_Space= N/a/}'); +Expect(1, 8, '\p{Is_Space=n}', ""); +Expect(0, 8, '\p{^Is_Space=n}', ""); +Expect(0, 8, '\P{Is_Space=n}', ""); +Expect(1, 8, '\P{^Is_Space=n}', ""); +Expect(0, 13, '\p{Is_Space=n}', ""); +Expect(1, 13, '\p{^Is_Space=n}', ""); +Expect(1, 13, '\P{Is_Space=n}', ""); +Expect(0, 13, '\P{^Is_Space=n}', ""); +Expect(1, 8, '\p{Is_Space=_ N}', ""); +Expect(0, 8, '\p{^Is_Space=_ N}', ""); +Expect(0, 8, '\P{Is_Space=_ N}', ""); +Expect(1, 8, '\P{^Is_Space=_ N}', ""); +Expect(0, 13, '\p{Is_Space=_ N}', ""); +Expect(1, 13, '\p{^Is_Space=_ N}', ""); +Expect(1, 13, '\P{Is_Space=_ N}', ""); +Expect(0, 13, '\P{^Is_Space=_ N}', ""); +Error('\p{XID_Continue= :=Yes}'); +Error('\P{XID_Continue= :=Yes}'); +Expect(1, 57, '\p{XID_Continue=yes}', ""); +Expect(0, 57, '\p{^XID_Continue=yes}', ""); +Expect(0, 57, '\P{XID_Continue=yes}', ""); +Expect(1, 57, '\P{^XID_Continue=yes}', ""); +Expect(0, 47, '\p{XID_Continue=yes}', ""); +Expect(1, 47, '\p{^XID_Continue=yes}', ""); +Expect(1, 47, '\P{XID_Continue=yes}', ""); +Expect(0, 47, '\P{^XID_Continue=yes}', ""); +Expect(1, 57, '\p{XID_Continue=- yes}', ""); +Expect(0, 57, '\p{^XID_Continue=- yes}', ""); +Expect(0, 57, '\P{XID_Continue=- yes}', ""); +Expect(1, 57, '\P{^XID_Continue=- yes}', ""); +Expect(0, 47, '\p{XID_Continue=- yes}', ""); +Expect(1, 47, '\p{^XID_Continue=- yes}', ""); +Expect(1, 47, '\P{XID_Continue=- yes}', ""); +Expect(0, 47, '\P{^XID_Continue=- yes}', ""); +Error('\p{XIDC=/a/ -Y}'); +Error('\P{XIDC=/a/ -Y}'); +Expect(1, 57, '\p{XIDC=y}', ""); +Expect(0, 57, '\p{^XIDC=y}', ""); +Expect(0, 57, '\P{XIDC=y}', ""); +Expect(1, 57, '\P{^XIDC=y}', ""); +Expect(0, 47, '\p{XIDC=y}', ""); +Expect(1, 47, '\p{^XIDC=y}', ""); +Expect(1, 47, '\P{XIDC=y}', ""); +Expect(0, 47, '\P{^XIDC=y}', ""); +Expect(1, 57, '\p{XIDC=-Y}', ""); +Expect(0, 57, '\p{^XIDC=-Y}', ""); +Expect(0, 57, '\P{XIDC=-Y}', ""); +Expect(1, 57, '\P{^XIDC=-Y}', ""); +Expect(0, 47, '\p{XIDC=-Y}', ""); +Expect(1, 47, '\p{^XIDC=-Y}', ""); +Expect(1, 47, '\P{XIDC=-Y}', ""); +Expect(0, 47, '\P{^XIDC=-Y}', ""); +Error('\p{Is_XID_Continue=:=__T}'); +Error('\P{Is_XID_Continue=:=__T}'); +Expect(1, 57, '\p{Is_XID_Continue=t}', ""); +Expect(0, 57, '\p{^Is_XID_Continue=t}', ""); +Expect(0, 57, '\P{Is_XID_Continue=t}', ""); +Expect(1, 57, '\P{^Is_XID_Continue=t}', ""); +Expect(0, 47, '\p{Is_XID_Continue=t}', ""); +Expect(1, 47, '\p{^Is_XID_Continue=t}', ""); +Expect(1, 47, '\P{Is_XID_Continue=t}', ""); +Expect(0, 47, '\P{^Is_XID_Continue=t}', ""); +Expect(1, 57, '\p{Is_XID_Continue=- T}', ""); +Expect(0, 57, '\p{^Is_XID_Continue=- T}', ""); +Expect(0, 57, '\P{Is_XID_Continue=- T}', ""); +Expect(1, 57, '\P{^Is_XID_Continue=- T}', ""); +Expect(0, 47, '\p{Is_XID_Continue=- T}', ""); +Expect(1, 47, '\p{^Is_XID_Continue=- T}', ""); +Expect(1, 47, '\P{Is_XID_Continue=- T}', ""); +Expect(0, 47, '\P{^Is_XID_Continue=- T}', ""); +Error('\p{Is_XIDC=:=true}'); +Error('\P{Is_XIDC=:=true}'); +Expect(1, 57, '\p{Is_XIDC=true}', ""); +Expect(0, 57, '\p{^Is_XIDC=true}', ""); +Expect(0, 57, '\P{Is_XIDC=true}', ""); +Expect(1, 57, '\P{^Is_XIDC=true}', ""); +Expect(0, 47, '\p{Is_XIDC=true}', ""); +Expect(1, 47, '\p{^Is_XIDC=true}', ""); +Expect(1, 47, '\P{Is_XIDC=true}', ""); +Expect(0, 47, '\P{^Is_XIDC=true}', ""); +Expect(1, 57, '\p{Is_XIDC= true}', ""); +Expect(0, 57, '\p{^Is_XIDC= true}', ""); +Expect(0, 57, '\P{Is_XIDC= true}', ""); +Expect(1, 57, '\P{^Is_XIDC= true}', ""); +Expect(0, 47, '\p{Is_XIDC= true}', ""); +Expect(1, 47, '\p{^Is_XIDC= true}', ""); +Expect(1, 47, '\P{Is_XIDC= true}', ""); +Expect(0, 47, '\P{^Is_XIDC= true}', ""); +Error('\p{XID_Continue=/a/No}'); +Error('\P{XID_Continue=/a/No}'); +Expect(1, 47, '\p{XID_Continue:no}', ""); +Expect(0, 47, '\p{^XID_Continue:no}', ""); +Expect(0, 47, '\P{XID_Continue:no}', ""); +Expect(1, 47, '\P{^XID_Continue:no}', ""); +Expect(0, 57, '\p{XID_Continue:no}', ""); +Expect(1, 57, '\p{^XID_Continue:no}', ""); +Expect(1, 57, '\P{XID_Continue:no}', ""); +Expect(0, 57, '\P{^XID_Continue:no}', ""); +Expect(1, 47, '\p{XID_Continue=--NO}', ""); +Expect(0, 47, '\p{^XID_Continue=--NO}', ""); +Expect(0, 47, '\P{XID_Continue=--NO}', ""); +Expect(1, 47, '\P{^XID_Continue=--NO}', ""); +Expect(0, 57, '\p{XID_Continue=--NO}', ""); +Expect(1, 57, '\p{^XID_Continue=--NO}', ""); +Expect(1, 57, '\P{XID_Continue=--NO}', ""); +Expect(0, 57, '\P{^XID_Continue=--NO}', ""); +Error('\p{XIDC=:=_ N}'); +Error('\P{XIDC=:=_ N}'); +Expect(1, 47, '\p{XIDC=n}', ""); +Expect(0, 47, '\p{^XIDC=n}', ""); +Expect(0, 47, '\P{XIDC=n}', ""); +Expect(1, 47, '\P{^XIDC=n}', ""); +Expect(0, 57, '\p{XIDC=n}', ""); +Expect(1, 57, '\p{^XIDC=n}', ""); +Expect(1, 57, '\P{XIDC=n}', ""); +Expect(0, 57, '\P{^XIDC=n}', ""); +Expect(1, 47, '\p{XIDC= _N}', ""); +Expect(0, 47, '\p{^XIDC= _N}', ""); +Expect(0, 47, '\P{XIDC= _N}', ""); +Expect(1, 47, '\P{^XIDC= _N}', ""); +Expect(0, 57, '\p{XIDC= _N}', ""); +Expect(1, 57, '\p{^XIDC= _N}', ""); +Expect(1, 57, '\P{XIDC= _N}', ""); +Expect(0, 57, '\P{^XIDC= _N}', ""); +Error('\p{Is_XID_Continue= F:=}'); +Error('\P{Is_XID_Continue= F:=}'); +Expect(1, 47, '\p{Is_XID_Continue=f}', ""); +Expect(0, 47, '\p{^Is_XID_Continue=f}', ""); +Expect(0, 47, '\P{Is_XID_Continue=f}', ""); +Expect(1, 47, '\P{^Is_XID_Continue=f}', ""); +Expect(0, 57, '\p{Is_XID_Continue=f}', ""); +Expect(1, 57, '\p{^Is_XID_Continue=f}', ""); +Expect(1, 57, '\P{Is_XID_Continue=f}', ""); +Expect(0, 57, '\P{^Is_XID_Continue=f}', ""); +Expect(1, 47, '\p{Is_XID_Continue=-_F}', ""); +Expect(0, 47, '\p{^Is_XID_Continue=-_F}', ""); +Expect(0, 47, '\P{Is_XID_Continue=-_F}', ""); +Expect(1, 47, '\P{^Is_XID_Continue=-_F}', ""); +Expect(0, 57, '\p{Is_XID_Continue=-_F}', ""); +Expect(1, 57, '\p{^Is_XID_Continue=-_F}', ""); +Expect(1, 57, '\P{Is_XID_Continue=-_F}', ""); +Expect(0, 57, '\P{^Is_XID_Continue=-_F}', ""); +Error('\p{Is_XIDC=:=- False}'); +Error('\P{Is_XIDC=:=- False}'); +Expect(1, 47, '\p{Is_XIDC=false}', ""); +Expect(0, 47, '\p{^Is_XIDC=false}', ""); +Expect(0, 47, '\P{Is_XIDC=false}', ""); +Expect(1, 47, '\P{^Is_XIDC=false}', ""); +Expect(0, 57, '\p{Is_XIDC=false}', ""); +Expect(1, 57, '\p{^Is_XIDC=false}', ""); +Expect(1, 57, '\P{Is_XIDC=false}', ""); +Expect(0, 57, '\P{^Is_XIDC=false}', ""); +Expect(1, 47, '\p{Is_XIDC=-false}', ""); +Expect(0, 47, '\p{^Is_XIDC=-false}', ""); +Expect(0, 47, '\P{Is_XIDC=-false}', ""); +Expect(1, 47, '\P{^Is_XIDC=-false}', ""); +Expect(0, 57, '\p{Is_XIDC=-false}', ""); +Expect(1, 57, '\p{^Is_XIDC=-false}', ""); +Expect(1, 57, '\P{Is_XIDC=-false}', ""); +Expect(0, 57, '\P{^Is_XIDC=-false}', ""); +Error('\p{XID_Start=:=_ Yes}'); +Error('\P{XID_Start=:=_ Yes}'); +Expect(1, 90, '\p{XID_Start=yes}', ""); +Expect(0, 90, '\p{^XID_Start=yes}', ""); +Expect(0, 90, '\P{XID_Start=yes}', ""); +Expect(1, 90, '\P{^XID_Start=yes}', ""); +Expect(0, 64, '\p{XID_Start=yes}', ""); +Expect(1, 64, '\p{^XID_Start=yes}', ""); +Expect(1, 64, '\P{XID_Start=yes}', ""); +Expect(0, 64, '\P{^XID_Start=yes}', ""); +Error('\p{XIDS::=Y}'); +Error('\P{XIDS::=Y}'); +Expect(1, 90, '\p{XIDS=y}', ""); +Expect(0, 90, '\p{^XIDS=y}', ""); +Expect(0, 90, '\P{XIDS=y}', ""); +Expect(1, 90, '\P{^XIDS=y}', ""); +Expect(0, 64, '\p{XIDS=y}', ""); +Expect(1, 64, '\p{^XIDS=y}', ""); +Expect(1, 64, '\P{XIDS=y}', ""); +Expect(0, 64, '\P{^XIDS=y}', ""); +Expect(1, 90, '\p{XIDS=-_Y}', ""); +Expect(0, 90, '\p{^XIDS=-_Y}', ""); +Expect(0, 90, '\P{XIDS=-_Y}', ""); +Expect(1, 90, '\P{^XIDS=-_Y}', ""); +Expect(0, 64, '\p{XIDS=-_Y}', ""); +Expect(1, 64, '\p{^XIDS=-_Y}', ""); +Expect(1, 64, '\P{XIDS=-_Y}', ""); +Expect(0, 64, '\P{^XIDS=-_Y}', ""); +Error('\p{Is_XID_Start=/a/_ T}'); +Error('\P{Is_XID_Start=/a/_ T}'); +Expect(1, 90, '\p{Is_XID_Start=t}', ""); +Expect(0, 90, '\p{^Is_XID_Start=t}', ""); +Expect(0, 90, '\P{Is_XID_Start=t}', ""); +Expect(1, 90, '\P{^Is_XID_Start=t}', ""); +Expect(0, 64, '\p{Is_XID_Start=t}', ""); +Expect(1, 64, '\p{^Is_XID_Start=t}', ""); +Expect(1, 64, '\P{Is_XID_Start=t}', ""); +Expect(0, 64, '\P{^Is_XID_Start=t}', ""); +Expect(1, 90, '\p{Is_XID_Start=- T}', ""); +Expect(0, 90, '\p{^Is_XID_Start=- T}', ""); +Expect(0, 90, '\P{Is_XID_Start=- T}', ""); +Expect(1, 90, '\P{^Is_XID_Start=- T}', ""); +Expect(0, 64, '\p{Is_XID_Start=- T}', ""); +Expect(1, 64, '\p{^Is_XID_Start=- T}', ""); +Expect(1, 64, '\P{Is_XID_Start=- T}', ""); +Expect(0, 64, '\P{^Is_XID_Start=- T}', ""); +Error('\p{Is_XIDS=- TRUE/a/}'); +Error('\P{Is_XIDS=- TRUE/a/}'); +Expect(1, 90, '\p{Is_XIDS: true}', ""); +Expect(0, 90, '\p{^Is_XIDS: true}', ""); +Expect(0, 90, '\P{Is_XIDS: true}', ""); +Expect(1, 90, '\P{^Is_XIDS: true}', ""); +Expect(0, 64, '\p{Is_XIDS: true}', ""); +Expect(1, 64, '\p{^Is_XIDS: true}', ""); +Expect(1, 64, '\P{Is_XIDS: true}', ""); +Expect(0, 64, '\P{^Is_XIDS: true}', ""); +Expect(1, 90, '\p{Is_XIDS: _True}', ""); +Expect(0, 90, '\p{^Is_XIDS: _True}', ""); +Expect(0, 90, '\P{Is_XIDS: _True}', ""); +Expect(1, 90, '\P{^Is_XIDS: _True}', ""); +Expect(0, 64, '\p{Is_XIDS: _True}', ""); +Expect(1, 64, '\p{^Is_XIDS: _True}', ""); +Expect(1, 64, '\P{Is_XIDS: _True}', ""); +Expect(0, 64, '\P{^Is_XIDS: _True}', ""); +Error('\p{XID_Start=-:=NO}'); +Error('\P{XID_Start=-:=NO}'); +Expect(1, 64, '\p{XID_Start=no}', ""); +Expect(0, 64, '\p{^XID_Start=no}', ""); +Expect(0, 64, '\P{XID_Start=no}', ""); +Expect(1, 64, '\P{^XID_Start=no}', ""); +Expect(0, 90, '\p{XID_Start=no}', ""); +Expect(1, 90, '\p{^XID_Start=no}', ""); +Expect(1, 90, '\P{XID_Start=no}', ""); +Expect(0, 90, '\P{^XID_Start=no}', ""); +Expect(1, 64, '\p{XID_Start: -NO}', ""); +Expect(0, 64, '\p{^XID_Start: -NO}', ""); +Expect(0, 64, '\P{XID_Start: -NO}', ""); +Expect(1, 64, '\P{^XID_Start: -NO}', ""); +Expect(0, 90, '\p{XID_Start: -NO}', ""); +Expect(1, 90, '\p{^XID_Start: -NO}', ""); +Expect(1, 90, '\P{XID_Start: -NO}', ""); +Expect(0, 90, '\P{^XID_Start: -NO}', ""); +Error('\p{XIDS: /a/ _n}'); +Error('\P{XIDS: /a/ _n}'); +Expect(1, 64, '\p{XIDS=n}', ""); +Expect(0, 64, '\p{^XIDS=n}', ""); +Expect(0, 64, '\P{XIDS=n}', ""); +Expect(1, 64, '\P{^XIDS=n}', ""); +Expect(0, 90, '\p{XIDS=n}', ""); +Expect(1, 90, '\p{^XIDS=n}', ""); +Expect(1, 90, '\P{XIDS=n}', ""); +Expect(0, 90, '\P{^XIDS=n}', ""); +Expect(1, 64, '\p{XIDS=__N}', ""); +Expect(0, 64, '\p{^XIDS=__N}', ""); +Expect(0, 64, '\P{XIDS=__N}', ""); +Expect(1, 64, '\P{^XIDS=__N}', ""); +Expect(0, 90, '\p{XIDS=__N}', ""); +Expect(1, 90, '\p{^XIDS=__N}', ""); +Expect(1, 90, '\P{XIDS=__N}', ""); +Expect(0, 90, '\P{^XIDS=__N}', ""); +Error('\p{Is_XID_Start=/a/ -F}'); +Error('\P{Is_XID_Start=/a/ -F}'); +Expect(1, 64, '\p{Is_XID_Start=f}', ""); +Expect(0, 64, '\p{^Is_XID_Start=f}', ""); +Expect(0, 64, '\P{Is_XID_Start=f}', ""); +Expect(1, 64, '\P{^Is_XID_Start=f}', ""); +Expect(0, 90, '\p{Is_XID_Start=f}', ""); +Expect(1, 90, '\p{^Is_XID_Start=f}', ""); +Expect(1, 90, '\P{Is_XID_Start=f}', ""); +Expect(0, 90, '\P{^Is_XID_Start=f}', ""); +Expect(1, 64, '\p{Is_XID_Start= _F}', ""); +Expect(0, 64, '\p{^Is_XID_Start= _F}', ""); +Expect(0, 64, '\P{Is_XID_Start= _F}', ""); +Expect(1, 64, '\P{^Is_XID_Start= _F}', ""); +Expect(0, 90, '\p{Is_XID_Start= _F}', ""); +Expect(1, 90, '\p{^Is_XID_Start= _F}', ""); +Expect(1, 90, '\P{Is_XID_Start= _F}', ""); +Expect(0, 90, '\P{^Is_XID_Start= _F}', ""); +Error('\p{Is_XIDS=/a/_False}'); +Error('\P{Is_XIDS=/a/_False}'); +Expect(1, 64, '\p{Is_XIDS=false}', ""); +Expect(0, 64, '\p{^Is_XIDS=false}', ""); +Expect(0, 64, '\P{Is_XIDS=false}', ""); +Expect(1, 64, '\P{^Is_XIDS=false}', ""); +Expect(0, 90, '\p{Is_XIDS=false}', ""); +Expect(1, 90, '\p{^Is_XIDS=false}', ""); +Expect(1, 90, '\P{Is_XIDS=false}', ""); +Expect(0, 90, '\P{^Is_XIDS=false}', ""); +Expect(1, 64, '\p{Is_XIDS= FALSE}', ""); +Expect(0, 64, '\p{^Is_XIDS= FALSE}', ""); +Expect(0, 64, '\P{Is_XIDS= FALSE}', ""); +Expect(1, 64, '\P{^Is_XIDS= FALSE}', ""); +Expect(0, 90, '\p{Is_XIDS= FALSE}', ""); +Expect(1, 90, '\p{^Is_XIDS= FALSE}', ""); +Expect(1, 90, '\P{Is_XIDS= FALSE}', ""); +Expect(0, 90, '\P{^Is_XIDS= FALSE}', ""); +Error('\p{Script:-_New:=Tai-lue}'); +Error('\P{Script:-_New:=Tai-lue}'); +Expect(1, 6569, '\p{Script=newtailue}', ""); +Expect(0, 6569, '\p{^Script=newtailue}', ""); +Expect(0, 6569, '\P{Script=newtailue}', ""); +Expect(1, 6569, '\P{^Script=newtailue}', ""); +Expect(0, 6527, '\p{Script=newtailue}', ""); +Expect(1, 6527, '\p{^Script=newtailue}', ""); +Expect(1, 6527, '\P{Script=newtailue}', ""); +Expect(0, 6527, '\P{^Script=newtailue}', ""); +Expect(1, 6569, '\p{Script=__NEW_TAI Lue}', ""); +Expect(0, 6569, '\p{^Script=__NEW_TAI Lue}', ""); +Expect(0, 6569, '\P{Script=__NEW_TAI Lue}', ""); +Expect(1, 6569, '\P{^Script=__NEW_TAI Lue}', ""); +Expect(0, 6527, '\p{Script=__NEW_TAI Lue}', ""); +Expect(1, 6527, '\p{^Script=__NEW_TAI Lue}', ""); +Expect(1, 6527, '\P{Script=__NEW_TAI Lue}', ""); +Expect(0, 6527, '\P{^Script=__NEW_TAI Lue}', ""); +Error('\p{Sc=/a/ -Talu}'); +Error('\P{Sc=/a/ -Talu}'); +Expect(1, 6569, '\p{Sc=talu}', ""); +Expect(0, 6569, '\p{^Sc=talu}', ""); +Expect(0, 6569, '\P{Sc=talu}', ""); +Expect(1, 6569, '\P{^Sc=talu}', ""); +Expect(0, 6527, '\p{Sc=talu}', ""); +Expect(1, 6527, '\p{^Sc=talu}', ""); +Expect(1, 6527, '\P{Sc=talu}', ""); +Expect(0, 6527, '\P{^Sc=talu}', ""); +Expect(1, 6569, '\p{Sc=_ Talu}', ""); +Expect(0, 6569, '\p{^Sc=_ Talu}', ""); +Expect(0, 6569, '\P{Sc=_ Talu}', ""); +Expect(1, 6569, '\P{^Sc=_ Talu}', ""); +Expect(0, 6527, '\p{Sc=_ Talu}', ""); +Expect(1, 6527, '\p{^Sc=_ Talu}', ""); +Expect(1, 6527, '\P{Sc=_ Talu}', ""); +Expect(0, 6527, '\P{^Sc=_ Talu}', ""); +Error('\p{Is_Script=__New:=TAI Lue}'); +Error('\P{Is_Script=__New:=TAI Lue}'); +Expect(1, 6569, '\p{Is_Script=newtailue}', ""); +Expect(0, 6569, '\p{^Is_Script=newtailue}', ""); +Expect(0, 6569, '\P{Is_Script=newtailue}', ""); +Expect(1, 6569, '\P{^Is_Script=newtailue}', ""); +Expect(0, 6527, '\p{Is_Script=newtailue}', ""); +Expect(1, 6527, '\p{^Is_Script=newtailue}', ""); +Expect(1, 6527, '\P{Is_Script=newtailue}', ""); +Expect(0, 6527, '\P{^Is_Script=newtailue}', ""); +Expect(1, 6569, '\p{Is_Script=_ New TaiLue}', ""); +Expect(0, 6569, '\p{^Is_Script=_ New TaiLue}', ""); +Expect(0, 6569, '\P{Is_Script=_ New TaiLue}', ""); +Expect(1, 6569, '\P{^Is_Script=_ New TaiLue}', ""); +Expect(0, 6527, '\p{Is_Script=_ New TaiLue}', ""); +Expect(1, 6527, '\p{^Is_Script=_ New TaiLue}', ""); +Expect(1, 6527, '\P{Is_Script=_ New TaiLue}', ""); +Expect(0, 6527, '\P{^Is_Script=_ New TaiLue}', ""); +Error('\p{Is_Sc:/a/_-talu}'); +Error('\P{Is_Sc:/a/_-talu}'); +Expect(1, 6569, '\p{Is_Sc: talu}', ""); +Expect(0, 6569, '\p{^Is_Sc: talu}', ""); +Expect(0, 6569, '\P{Is_Sc: talu}', ""); +Expect(1, 6569, '\P{^Is_Sc: talu}', ""); +Expect(0, 6527, '\p{Is_Sc: talu}', ""); +Expect(1, 6527, '\p{^Is_Sc: talu}', ""); +Expect(1, 6527, '\P{Is_Sc: talu}', ""); +Expect(0, 6527, '\P{^Is_Sc: talu}', ""); +Expect(1, 6569, '\p{Is_Sc= Talu}', ""); +Expect(0, 6569, '\p{^Is_Sc= Talu}', ""); +Expect(0, 6569, '\P{Is_Sc= Talu}', ""); +Expect(1, 6569, '\P{^Is_Sc= Talu}', ""); +Expect(0, 6527, '\p{Is_Sc= Talu}', ""); +Expect(1, 6527, '\p{^Is_Sc= Talu}', ""); +Expect(1, 6527, '\P{Is_Sc= Talu}', ""); +Expect(0, 6527, '\P{^Is_Sc= Talu}', ""); +Error('\p{Script=/a/GOTHIC}'); +Error('\P{Script=/a/GOTHIC}'); +Expect(1, 66378, '\p{Script=gothic}', ""); +Expect(0, 66378, '\p{^Script=gothic}', ""); +Expect(0, 66378, '\P{Script=gothic}', ""); +Expect(1, 66378, '\P{^Script=gothic}', ""); +Expect(0, 66351, '\p{Script=gothic}', ""); +Expect(1, 66351, '\p{^Script=gothic}', ""); +Expect(1, 66351, '\P{Script=gothic}', ""); +Expect(0, 66351, '\P{^Script=gothic}', ""); +Expect(1, 66378, '\p{Script= _GOTHIC}', ""); +Expect(0, 66378, '\p{^Script= _GOTHIC}', ""); +Expect(0, 66378, '\P{Script= _GOTHIC}', ""); +Expect(1, 66378, '\P{^Script= _GOTHIC}', ""); +Expect(0, 66351, '\p{Script= _GOTHIC}', ""); +Expect(1, 66351, '\p{^Script= _GOTHIC}', ""); +Expect(1, 66351, '\P{Script= _GOTHIC}', ""); +Expect(0, 66351, '\P{^Script= _GOTHIC}', ""); +Error('\p{Sc=:= GOTH}'); +Error('\P{Sc=:= GOTH}'); +Expect(1, 66378, '\p{Sc=goth}', ""); +Expect(0, 66378, '\p{^Sc=goth}', ""); +Expect(0, 66378, '\P{Sc=goth}', ""); +Expect(1, 66378, '\P{^Sc=goth}', ""); +Expect(0, 66351, '\p{Sc=goth}', ""); +Expect(1, 66351, '\p{^Sc=goth}', ""); +Expect(1, 66351, '\P{Sc=goth}', ""); +Expect(0, 66351, '\P{^Sc=goth}', ""); +Expect(1, 66378, '\p{Sc= GOTH}', ""); +Expect(0, 66378, '\p{^Sc= GOTH}', ""); +Expect(0, 66378, '\P{Sc= GOTH}', ""); +Expect(1, 66378, '\P{^Sc= GOTH}', ""); +Expect(0, 66351, '\p{Sc= GOTH}', ""); +Expect(1, 66351, '\p{^Sc= GOTH}', ""); +Expect(1, 66351, '\P{Sc= GOTH}', ""); +Expect(0, 66351, '\P{^Sc= GOTH}', ""); +Error('\p{Is_Script= gothic/a/}'); +Error('\P{Is_Script= gothic/a/}'); +Expect(1, 66378, '\p{Is_Script=gothic}', ""); +Expect(0, 66378, '\p{^Is_Script=gothic}', ""); +Expect(0, 66378, '\P{Is_Script=gothic}', ""); +Expect(1, 66378, '\P{^Is_Script=gothic}', ""); +Expect(0, 66351, '\p{Is_Script=gothic}', ""); +Expect(1, 66351, '\p{^Is_Script=gothic}', ""); +Expect(1, 66351, '\P{Is_Script=gothic}', ""); +Expect(0, 66351, '\P{^Is_Script=gothic}', ""); +Expect(1, 66378, '\p{Is_Script= Gothic}', ""); +Expect(0, 66378, '\p{^Is_Script= Gothic}', ""); +Expect(0, 66378, '\P{Is_Script= Gothic}', ""); +Expect(1, 66378, '\P{^Is_Script= Gothic}', ""); +Expect(0, 66351, '\p{Is_Script= Gothic}', ""); +Expect(1, 66351, '\p{^Is_Script= Gothic}', ""); +Expect(1, 66351, '\P{Is_Script= Gothic}', ""); +Expect(0, 66351, '\P{^Is_Script= Gothic}', ""); +Error('\p{Is_Sc= /a/Goth}'); +Error('\P{Is_Sc= /a/Goth}'); +Expect(1, 66378, '\p{Is_Sc: goth}', ""); +Expect(0, 66378, '\p{^Is_Sc: goth}', ""); +Expect(0, 66378, '\P{Is_Sc: goth}', ""); +Expect(1, 66378, '\P{^Is_Sc: goth}', ""); +Expect(0, 66351, '\p{Is_Sc: goth}', ""); +Expect(1, 66351, '\p{^Is_Sc: goth}', ""); +Expect(1, 66351, '\P{Is_Sc: goth}', ""); +Expect(0, 66351, '\P{^Is_Sc: goth}', ""); +Expect(1, 66378, '\p{Is_Sc=_ goth}', ""); +Expect(0, 66378, '\p{^Is_Sc=_ goth}', ""); +Expect(0, 66378, '\P{Is_Sc=_ goth}', ""); +Expect(1, 66378, '\P{^Is_Sc=_ goth}', ""); +Expect(0, 66351, '\p{Is_Sc=_ goth}', ""); +Expect(1, 66351, '\p{^Is_Sc=_ goth}', ""); +Expect(1, 66351, '\P{Is_Sc=_ goth}', ""); +Expect(0, 66351, '\P{^Is_Sc=_ goth}', ""); +Error('\p{Script=/a/Old-ITALIC}'); +Error('\P{Script=/a/Old-ITALIC}'); +Expect(1, 66334, '\p{Script=olditalic}', ""); +Expect(0, 66334, '\p{^Script=olditalic}', ""); +Expect(0, 66334, '\P{Script=olditalic}', ""); +Expect(1, 66334, '\P{^Script=olditalic}', ""); +Expect(0, 66303, '\p{Script=olditalic}', ""); +Expect(1, 66303, '\p{^Script=olditalic}', ""); +Expect(1, 66303, '\P{Script=olditalic}', ""); +Expect(0, 66303, '\P{^Script=olditalic}', ""); +Expect(1, 66334, '\p{Script: _-old Italic}', ""); +Expect(0, 66334, '\p{^Script: _-old Italic}', ""); +Expect(0, 66334, '\P{Script: _-old Italic}', ""); +Expect(1, 66334, '\P{^Script: _-old Italic}', ""); +Expect(0, 66303, '\p{Script: _-old Italic}', ""); +Expect(1, 66303, '\p{^Script: _-old Italic}', ""); +Expect(1, 66303, '\P{Script: _-old Italic}', ""); +Expect(0, 66303, '\P{^Script: _-old Italic}', ""); +Error('\p{Sc= :=ital}'); +Error('\P{Sc= :=ital}'); +Expect(1, 66334, '\p{Sc=ital}', ""); +Expect(0, 66334, '\p{^Sc=ital}', ""); +Expect(0, 66334, '\P{Sc=ital}', ""); +Expect(1, 66334, '\P{^Sc=ital}', ""); +Expect(0, 66303, '\p{Sc=ital}', ""); +Expect(1, 66303, '\p{^Sc=ital}', ""); +Expect(1, 66303, '\P{Sc=ital}', ""); +Expect(0, 66303, '\P{^Sc=ital}', ""); +Expect(1, 66334, '\p{Sc=__Ital}', ""); +Expect(0, 66334, '\p{^Sc=__Ital}', ""); +Expect(0, 66334, '\P{Sc=__Ital}', ""); +Expect(1, 66334, '\P{^Sc=__Ital}', ""); +Expect(0, 66303, '\p{Sc=__Ital}', ""); +Expect(1, 66303, '\p{^Sc=__Ital}', ""); +Expect(1, 66303, '\P{Sc=__Ital}', ""); +Expect(0, 66303, '\P{^Sc=__Ital}', ""); +Error('\p{Is_Script=:=_old italic}'); +Error('\P{Is_Script=:=_old italic}'); +Expect(1, 66334, '\p{Is_Script: olditalic}', ""); +Expect(0, 66334, '\p{^Is_Script: olditalic}', ""); +Expect(0, 66334, '\P{Is_Script: olditalic}', ""); +Expect(1, 66334, '\P{^Is_Script: olditalic}', ""); +Expect(0, 66303, '\p{Is_Script: olditalic}', ""); +Expect(1, 66303, '\p{^Is_Script: olditalic}', ""); +Expect(1, 66303, '\P{Is_Script: olditalic}', ""); +Expect(0, 66303, '\P{^Is_Script: olditalic}', ""); +Expect(1, 66334, '\p{Is_Script=-Old-ITALIC}', ""); +Expect(0, 66334, '\p{^Is_Script=-Old-ITALIC}', ""); +Expect(0, 66334, '\P{Is_Script=-Old-ITALIC}', ""); +Expect(1, 66334, '\P{^Is_Script=-Old-ITALIC}', ""); +Expect(0, 66303, '\p{Is_Script=-Old-ITALIC}', ""); +Expect(1, 66303, '\p{^Is_Script=-Old-ITALIC}', ""); +Expect(1, 66303, '\P{Is_Script=-Old-ITALIC}', ""); +Expect(0, 66303, '\P{^Is_Script=-Old-ITALIC}', ""); +Error('\p{Is_Sc: := Ital}'); +Error('\P{Is_Sc: := Ital}'); +Expect(1, 66334, '\p{Is_Sc:ital}', ""); +Expect(0, 66334, '\p{^Is_Sc:ital}', ""); +Expect(0, 66334, '\P{Is_Sc:ital}', ""); +Expect(1, 66334, '\P{^Is_Sc:ital}', ""); +Expect(0, 66303, '\p{Is_Sc:ital}', ""); +Expect(1, 66303, '\p{^Is_Sc:ital}', ""); +Expect(1, 66303, '\P{Is_Sc:ital}', ""); +Expect(0, 66303, '\P{^Is_Sc:ital}', ""); +Expect(1, 66334, '\p{Is_Sc=--ITAL}', ""); +Expect(0, 66334, '\p{^Is_Sc=--ITAL}', ""); +Expect(0, 66334, '\P{Is_Sc=--ITAL}', ""); +Expect(1, 66334, '\P{^Is_Sc=--ITAL}', ""); +Expect(0, 66303, '\p{Is_Sc=--ITAL}', ""); +Expect(1, 66303, '\p{^Is_Sc=--ITAL}', ""); +Expect(1, 66303, '\P{Is_Sc=--ITAL}', ""); +Expect(0, 66303, '\P{^Is_Sc=--ITAL}', ""); +Error('\p{Script= Vai/a/}'); +Error('\P{Script= Vai/a/}'); +Expect(1, 42539, '\p{Script=vai}', ""); +Expect(0, 42539, '\p{^Script=vai}', ""); +Expect(0, 42539, '\P{Script=vai}', ""); +Expect(1, 42539, '\P{^Script=vai}', ""); +Expect(0, 42239, '\p{Script=vai}', ""); +Expect(1, 42239, '\p{^Script=vai}', ""); +Expect(1, 42239, '\P{Script=vai}', ""); +Expect(0, 42239, '\P{^Script=vai}', ""); +Expect(1, 42539, '\p{Script=_ VAI}', ""); +Expect(0, 42539, '\p{^Script=_ VAI}', ""); +Expect(0, 42539, '\P{Script=_ VAI}', ""); +Expect(1, 42539, '\P{^Script=_ VAI}', ""); +Expect(0, 42239, '\p{Script=_ VAI}', ""); +Expect(1, 42239, '\p{^Script=_ VAI}', ""); +Expect(1, 42239, '\P{Script=_ VAI}', ""); +Expect(0, 42239, '\P{^Script=_ VAI}', ""); +Error('\p{Sc=:= Vaii}'); +Error('\P{Sc=:= Vaii}'); +Expect(1, 42539, '\p{Sc=vaii}', ""); +Expect(0, 42539, '\p{^Sc=vaii}', ""); +Expect(0, 42539, '\P{Sc=vaii}', ""); +Expect(1, 42539, '\P{^Sc=vaii}', ""); +Expect(0, 42239, '\p{Sc=vaii}', ""); +Expect(1, 42239, '\p{^Sc=vaii}', ""); +Expect(1, 42239, '\P{Sc=vaii}', ""); +Expect(0, 42239, '\P{^Sc=vaii}', ""); +Expect(1, 42539, '\p{Sc=__Vaii}', ""); +Expect(0, 42539, '\p{^Sc=__Vaii}', ""); +Expect(0, 42539, '\P{Sc=__Vaii}', ""); +Expect(1, 42539, '\P{^Sc=__Vaii}', ""); +Expect(0, 42239, '\p{Sc=__Vaii}', ""); +Expect(1, 42239, '\p{^Sc=__Vaii}', ""); +Expect(1, 42239, '\P{Sc=__Vaii}', ""); +Expect(0, 42239, '\P{^Sc=__Vaii}', ""); +Error('\p{Is_Script: /a/-Vai}'); +Error('\P{Is_Script: /a/-Vai}'); +Expect(1, 42539, '\p{Is_Script=vai}', ""); +Expect(0, 42539, '\p{^Is_Script=vai}', ""); +Expect(0, 42539, '\P{Is_Script=vai}', ""); +Expect(1, 42539, '\P{^Is_Script=vai}', ""); +Expect(0, 42239, '\p{Is_Script=vai}', ""); +Expect(1, 42239, '\p{^Is_Script=vai}', ""); +Expect(1, 42239, '\P{Is_Script=vai}', ""); +Expect(0, 42239, '\P{^Is_Script=vai}', ""); +Expect(1, 42539, '\p{Is_Script= Vai}', ""); +Expect(0, 42539, '\p{^Is_Script= Vai}', ""); +Expect(0, 42539, '\P{Is_Script= Vai}', ""); +Expect(1, 42539, '\P{^Is_Script= Vai}', ""); +Expect(0, 42239, '\p{Is_Script= Vai}', ""); +Expect(1, 42239, '\p{^Is_Script= Vai}', ""); +Expect(1, 42239, '\P{Is_Script= Vai}', ""); +Expect(0, 42239, '\P{^Is_Script= Vai}', ""); +Error('\p{Is_Sc: _/a/vaii}'); +Error('\P{Is_Sc: _/a/vaii}'); +Expect(1, 42539, '\p{Is_Sc=vaii}', ""); +Expect(0, 42539, '\p{^Is_Sc=vaii}', ""); +Expect(0, 42539, '\P{Is_Sc=vaii}', ""); +Expect(1, 42539, '\P{^Is_Sc=vaii}', ""); +Expect(0, 42239, '\p{Is_Sc=vaii}', ""); +Expect(1, 42239, '\p{^Is_Sc=vaii}', ""); +Expect(1, 42239, '\P{Is_Sc=vaii}', ""); +Expect(0, 42239, '\P{^Is_Sc=vaii}', ""); +Expect(1, 42539, '\p{Is_Sc=_Vaii}', ""); +Expect(0, 42539, '\p{^Is_Sc=_Vaii}', ""); +Expect(0, 42539, '\P{Is_Sc=_Vaii}', ""); +Expect(1, 42539, '\P{^Is_Sc=_Vaii}', ""); +Expect(0, 42239, '\p{Is_Sc=_Vaii}', ""); +Expect(1, 42239, '\p{^Is_Sc=_Vaii}', ""); +Expect(1, 42239, '\P{Is_Sc=_Vaii}', ""); +Expect(0, 42239, '\P{^Is_Sc=_Vaii}', ""); +Error('\p{Script=_Runic/a/}'); +Error('\P{Script=_Runic/a/}'); +Expect(1, 5866, '\p{Script=runic}', ""); +Expect(0, 5866, '\p{^Script=runic}', ""); +Expect(0, 5866, '\P{Script=runic}', ""); +Expect(1, 5866, '\P{^Script=runic}', ""); +Expect(0, 5791, '\p{Script=runic}', ""); +Expect(1, 5791, '\p{^Script=runic}', ""); +Expect(1, 5791, '\P{Script=runic}', ""); +Expect(0, 5791, '\P{^Script=runic}', ""); +Expect(1, 5866, '\p{Script=- RUNIC}', ""); +Expect(0, 5866, '\p{^Script=- RUNIC}', ""); +Expect(0, 5866, '\P{Script=- RUNIC}', ""); +Expect(1, 5866, '\P{^Script=- RUNIC}', ""); +Expect(0, 5791, '\p{Script=- RUNIC}', ""); +Expect(1, 5791, '\p{^Script=- RUNIC}', ""); +Expect(1, 5791, '\P{Script=- RUNIC}', ""); +Expect(0, 5791, '\P{^Script=- RUNIC}', ""); +Error('\p{Sc= :=Runr}'); +Error('\P{Sc= :=Runr}'); +Expect(1, 5866, '\p{Sc=runr}', ""); +Expect(0, 5866, '\p{^Sc=runr}', ""); +Expect(0, 5866, '\P{Sc=runr}', ""); +Expect(1, 5866, '\P{^Sc=runr}', ""); +Expect(0, 5791, '\p{Sc=runr}', ""); +Expect(1, 5791, '\p{^Sc=runr}', ""); +Expect(1, 5791, '\P{Sc=runr}', ""); +Expect(0, 5791, '\P{^Sc=runr}', ""); +Expect(1, 5866, '\p{Sc:-runr}', ""); +Expect(0, 5866, '\p{^Sc:-runr}', ""); +Expect(0, 5866, '\P{Sc:-runr}', ""); +Expect(1, 5866, '\P{^Sc:-runr}', ""); +Expect(0, 5791, '\p{Sc:-runr}', ""); +Expect(1, 5791, '\p{^Sc:-runr}', ""); +Expect(1, 5791, '\P{Sc:-runr}', ""); +Expect(0, 5791, '\P{^Sc:-runr}', ""); +Error('\p{Is_Script= /a/Runic}'); +Error('\P{Is_Script= /a/Runic}'); +Expect(1, 5866, '\p{Is_Script=runic}', ""); +Expect(0, 5866, '\p{^Is_Script=runic}', ""); +Expect(0, 5866, '\P{Is_Script=runic}', ""); +Expect(1, 5866, '\P{^Is_Script=runic}', ""); +Expect(0, 5791, '\p{Is_Script=runic}', ""); +Expect(1, 5791, '\p{^Is_Script=runic}', ""); +Expect(1, 5791, '\P{Is_Script=runic}', ""); +Expect(0, 5791, '\P{^Is_Script=runic}', ""); +Expect(1, 5866, '\p{Is_Script=- runic}', ""); +Expect(0, 5866, '\p{^Is_Script=- runic}', ""); +Expect(0, 5866, '\P{Is_Script=- runic}', ""); +Expect(1, 5866, '\P{^Is_Script=- runic}', ""); +Expect(0, 5791, '\p{Is_Script=- runic}', ""); +Expect(1, 5791, '\p{^Is_Script=- runic}', ""); +Expect(1, 5791, '\P{Is_Script=- runic}', ""); +Expect(0, 5791, '\P{^Is_Script=- runic}', ""); +Error('\p{Is_Sc=/a/-runr}'); +Error('\P{Is_Sc=/a/-runr}'); +Expect(1, 5866, '\p{Is_Sc=runr}', ""); +Expect(0, 5866, '\p{^Is_Sc=runr}', ""); +Expect(0, 5866, '\P{Is_Sc=runr}', ""); +Expect(1, 5866, '\P{^Is_Sc=runr}', ""); +Expect(0, 5791, '\p{Is_Sc=runr}', ""); +Expect(1, 5791, '\p{^Is_Sc=runr}', ""); +Expect(1, 5791, '\P{Is_Sc=runr}', ""); +Expect(0, 5791, '\P{^Is_Sc=runr}', ""); +Expect(1, 5866, '\p{Is_Sc= Runr}', ""); +Expect(0, 5866, '\p{^Is_Sc= Runr}', ""); +Expect(0, 5866, '\P{Is_Sc= Runr}', ""); +Expect(1, 5866, '\P{^Is_Sc= Runr}', ""); +Expect(0, 5791, '\p{Is_Sc= Runr}', ""); +Expect(1, 5791, '\p{^Is_Sc= Runr}', ""); +Expect(1, 5791, '\P{Is_Sc= Runr}', ""); +Expect(0, 5791, '\P{^Is_Sc= Runr}', ""); +Error('\p{Script= :=cherokee}'); +Error('\P{Script= :=cherokee}'); +Expect(1, 5108, '\p{Script=cherokee}', ""); +Expect(0, 5108, '\p{^Script=cherokee}', ""); +Expect(0, 5108, '\P{Script=cherokee}', ""); +Expect(1, 5108, '\P{^Script=cherokee}', ""); +Expect(0, 5023, '\p{Script=cherokee}', ""); +Expect(1, 5023, '\p{^Script=cherokee}', ""); +Expect(1, 5023, '\P{Script=cherokee}', ""); +Expect(0, 5023, '\P{^Script=cherokee}', ""); +Expect(1, 5108, '\p{Script= Cherokee}', ""); +Expect(0, 5108, '\p{^Script= Cherokee}', ""); +Expect(0, 5108, '\P{Script= Cherokee}', ""); +Expect(1, 5108, '\P{^Script= Cherokee}', ""); +Expect(0, 5023, '\p{Script= Cherokee}', ""); +Expect(1, 5023, '\p{^Script= Cherokee}', ""); +Expect(1, 5023, '\P{Script= Cherokee}', ""); +Expect(0, 5023, '\P{^Script= Cherokee}', ""); +Error('\p{Sc=- CHER:=}'); +Error('\P{Sc=- CHER:=}'); +Expect(1, 5108, '\p{Sc=cher}', ""); +Expect(0, 5108, '\p{^Sc=cher}', ""); +Expect(0, 5108, '\P{Sc=cher}', ""); +Expect(1, 5108, '\P{^Sc=cher}', ""); +Expect(0, 5023, '\p{Sc=cher}', ""); +Expect(1, 5023, '\p{^Sc=cher}', ""); +Expect(1, 5023, '\P{Sc=cher}', ""); +Expect(0, 5023, '\P{^Sc=cher}', ""); +Expect(1, 5108, '\p{Sc: - Cher}', ""); +Expect(0, 5108, '\p{^Sc: - Cher}', ""); +Expect(0, 5108, '\P{Sc: - Cher}', ""); +Expect(1, 5108, '\P{^Sc: - Cher}', ""); +Expect(0, 5023, '\p{Sc: - Cher}', ""); +Expect(1, 5023, '\p{^Sc: - Cher}', ""); +Expect(1, 5023, '\P{Sc: - Cher}', ""); +Expect(0, 5023, '\P{^Sc: - Cher}', ""); +Error('\p{Is_Script: /a/ CHEROKEE}'); +Error('\P{Is_Script: /a/ CHEROKEE}'); +Expect(1, 5108, '\p{Is_Script=cherokee}', ""); +Expect(0, 5108, '\p{^Is_Script=cherokee}', ""); +Expect(0, 5108, '\P{Is_Script=cherokee}', ""); +Expect(1, 5108, '\P{^Is_Script=cherokee}', ""); +Expect(0, 5023, '\p{Is_Script=cherokee}', ""); +Expect(1, 5023, '\p{^Is_Script=cherokee}', ""); +Expect(1, 5023, '\P{Is_Script=cherokee}', ""); +Expect(0, 5023, '\P{^Is_Script=cherokee}', ""); +Expect(1, 5108, '\p{Is_Script=_cherokee}', ""); +Expect(0, 5108, '\p{^Is_Script=_cherokee}', ""); +Expect(0, 5108, '\P{Is_Script=_cherokee}', ""); +Expect(1, 5108, '\P{^Is_Script=_cherokee}', ""); +Expect(0, 5023, '\p{Is_Script=_cherokee}', ""); +Expect(1, 5023, '\p{^Is_Script=_cherokee}', ""); +Expect(1, 5023, '\P{Is_Script=_cherokee}', ""); +Expect(0, 5023, '\P{^Is_Script=_cherokee}', ""); +Error('\p{Is_Sc: - Cher/a/}'); +Error('\P{Is_Sc: - Cher/a/}'); +Expect(1, 5108, '\p{Is_Sc=cher}', ""); +Expect(0, 5108, '\p{^Is_Sc=cher}', ""); +Expect(0, 5108, '\P{Is_Sc=cher}', ""); +Expect(1, 5108, '\P{^Is_Sc=cher}', ""); +Expect(0, 5023, '\p{Is_Sc=cher}', ""); +Expect(1, 5023, '\p{^Is_Sc=cher}', ""); +Expect(1, 5023, '\P{Is_Sc=cher}', ""); +Expect(0, 5023, '\P{^Is_Sc=cher}', ""); +Expect(1, 5108, '\p{Is_Sc= Cher}', ""); +Expect(0, 5108, '\p{^Is_Sc= Cher}', ""); +Expect(0, 5108, '\P{Is_Sc= Cher}', ""); +Expect(1, 5108, '\P{^Is_Sc= Cher}', ""); +Expect(0, 5023, '\p{Is_Sc= Cher}', ""); +Expect(1, 5023, '\p{^Is_Sc= Cher}', ""); +Expect(1, 5023, '\P{Is_Sc= Cher}', ""); +Expect(0, 5023, '\P{^Is_Sc= Cher}', ""); +Error('\p{Script: __OL/a/CHIKI}'); +Error('\P{Script: __OL/a/CHIKI}'); +Expect(1, 7295, '\p{Script=olchiki}', ""); +Expect(0, 7295, '\p{^Script=olchiki}', ""); +Expect(0, 7295, '\P{Script=olchiki}', ""); +Expect(1, 7295, '\P{^Script=olchiki}', ""); +Expect(0, 7247, '\p{Script=olchiki}', ""); +Expect(1, 7247, '\p{^Script=olchiki}', ""); +Expect(1, 7247, '\P{Script=olchiki}', ""); +Expect(0, 7247, '\P{^Script=olchiki}', ""); +Expect(1, 7295, '\p{Script=_-Ol chiki}', ""); +Expect(0, 7295, '\p{^Script=_-Ol chiki}', ""); +Expect(0, 7295, '\P{Script=_-Ol chiki}', ""); +Expect(1, 7295, '\P{^Script=_-Ol chiki}', ""); +Expect(0, 7247, '\p{Script=_-Ol chiki}', ""); +Expect(1, 7247, '\p{^Script=_-Ol chiki}', ""); +Expect(1, 7247, '\P{Script=_-Ol chiki}', ""); +Expect(0, 7247, '\P{^Script=_-Ol chiki}', ""); +Error('\p{Sc= /a/olck}'); +Error('\P{Sc= /a/olck}'); +Expect(1, 7295, '\p{Sc=olck}', ""); +Expect(0, 7295, '\p{^Sc=olck}', ""); +Expect(0, 7295, '\P{Sc=olck}', ""); +Expect(1, 7295, '\P{^Sc=olck}', ""); +Expect(0, 7247, '\p{Sc=olck}', ""); +Expect(1, 7247, '\p{^Sc=olck}', ""); +Expect(1, 7247, '\P{Sc=olck}', ""); +Expect(0, 7247, '\P{^Sc=olck}', ""); +Expect(1, 7295, '\p{Sc=-Olck}', ""); +Expect(0, 7295, '\p{^Sc=-Olck}', ""); +Expect(0, 7295, '\P{Sc=-Olck}', ""); +Expect(1, 7295, '\P{^Sc=-Olck}', ""); +Expect(0, 7247, '\p{Sc=-Olck}', ""); +Expect(1, 7247, '\p{^Sc=-Olck}', ""); +Expect(1, 7247, '\P{Sc=-Olck}', ""); +Expect(0, 7247, '\P{^Sc=-Olck}', ""); +Error('\p{Is_Script: ol:=Chiki}'); +Error('\P{Is_Script: ol:=Chiki}'); +Expect(1, 7295, '\p{Is_Script=olchiki}', ""); +Expect(0, 7295, '\p{^Is_Script=olchiki}', ""); +Expect(0, 7295, '\P{Is_Script=olchiki}', ""); +Expect(1, 7295, '\P{^Is_Script=olchiki}', ""); +Expect(0, 7247, '\p{Is_Script=olchiki}', ""); +Expect(1, 7247, '\p{^Is_Script=olchiki}', ""); +Expect(1, 7247, '\P{Is_Script=olchiki}', ""); +Expect(0, 7247, '\P{^Is_Script=olchiki}', ""); +Expect(1, 7295, '\p{Is_Script= OlChiki}', ""); +Expect(0, 7295, '\p{^Is_Script= OlChiki}', ""); +Expect(0, 7295, '\P{Is_Script= OlChiki}', ""); +Expect(1, 7295, '\P{^Is_Script= OlChiki}', ""); +Expect(0, 7247, '\p{Is_Script= OlChiki}', ""); +Expect(1, 7247, '\p{^Is_Script= OlChiki}', ""); +Expect(1, 7247, '\P{Is_Script= OlChiki}', ""); +Expect(0, 7247, '\P{^Is_Script= OlChiki}', ""); +Error('\p{Is_Sc=:=Olck}'); +Error('\P{Is_Sc=:=Olck}'); +Expect(1, 7295, '\p{Is_Sc=olck}', ""); +Expect(0, 7295, '\p{^Is_Sc=olck}', ""); +Expect(0, 7295, '\P{Is_Sc=olck}', ""); +Expect(1, 7295, '\P{^Is_Sc=olck}', ""); +Expect(0, 7247, '\p{Is_Sc=olck}', ""); +Expect(1, 7247, '\p{^Is_Sc=olck}', ""); +Expect(1, 7247, '\P{Is_Sc=olck}', ""); +Expect(0, 7247, '\P{^Is_Sc=olck}', ""); +Expect(1, 7295, '\p{Is_Sc=Olck}', ""); +Expect(0, 7295, '\p{^Is_Sc=Olck}', ""); +Expect(0, 7295, '\P{Is_Sc=Olck}', ""); +Expect(1, 7295, '\P{^Is_Sc=Olck}', ""); +Expect(0, 7247, '\p{Is_Sc=Olck}', ""); +Expect(1, 7247, '\p{^Is_Sc=Olck}', ""); +Expect(1, 7247, '\P{Is_Sc=Olck}', ""); +Expect(0, 7247, '\P{^Is_Sc=Olck}', ""); +Error('\p{Script= Ugaritic/a/}'); +Error('\P{Script= Ugaritic/a/}'); +Expect(1, 66461, '\p{Script=ugaritic}', ""); +Expect(0, 66461, '\p{^Script=ugaritic}', ""); +Expect(0, 66461, '\P{Script=ugaritic}', ""); +Expect(1, 66461, '\P{^Script=ugaritic}', ""); +Expect(0, 66431, '\p{Script=ugaritic}', ""); +Expect(1, 66431, '\p{^Script=ugaritic}', ""); +Expect(1, 66431, '\P{Script=ugaritic}', ""); +Expect(0, 66431, '\P{^Script=ugaritic}', ""); +Expect(1, 66461, '\p{Script=_ Ugaritic}', ""); +Expect(0, 66461, '\p{^Script=_ Ugaritic}', ""); +Expect(0, 66461, '\P{Script=_ Ugaritic}', ""); +Expect(1, 66461, '\P{^Script=_ Ugaritic}', ""); +Expect(0, 66431, '\p{Script=_ Ugaritic}', ""); +Expect(1, 66431, '\p{^Script=_ Ugaritic}', ""); +Expect(1, 66431, '\P{Script=_ Ugaritic}', ""); +Expect(0, 66431, '\P{^Script=_ Ugaritic}', ""); +Error('\p{Sc=:=-_Ugar}'); +Error('\P{Sc=:=-_Ugar}'); +Expect(1, 66461, '\p{Sc=ugar}', ""); +Expect(0, 66461, '\p{^Sc=ugar}', ""); +Expect(0, 66461, '\P{Sc=ugar}', ""); +Expect(1, 66461, '\P{^Sc=ugar}', ""); +Expect(0, 66431, '\p{Sc=ugar}', ""); +Expect(1, 66431, '\p{^Sc=ugar}', ""); +Expect(1, 66431, '\P{Sc=ugar}', ""); +Expect(0, 66431, '\P{^Sc=ugar}', ""); +Expect(1, 66461, '\p{Sc= ugar}', ""); +Expect(0, 66461, '\p{^Sc= ugar}', ""); +Expect(0, 66461, '\P{Sc= ugar}', ""); +Expect(1, 66461, '\P{^Sc= ugar}', ""); +Expect(0, 66431, '\p{Sc= ugar}', ""); +Expect(1, 66431, '\p{^Sc= ugar}', ""); +Expect(1, 66431, '\P{Sc= ugar}', ""); +Expect(0, 66431, '\P{^Sc= ugar}', ""); +Error('\p{Is_Script=:= -Ugaritic}'); +Error('\P{Is_Script=:= -Ugaritic}'); +Expect(1, 66461, '\p{Is_Script=ugaritic}', ""); +Expect(0, 66461, '\p{^Is_Script=ugaritic}', ""); +Expect(0, 66461, '\P{Is_Script=ugaritic}', ""); +Expect(1, 66461, '\P{^Is_Script=ugaritic}', ""); +Expect(0, 66431, '\p{Is_Script=ugaritic}', ""); +Expect(1, 66431, '\p{^Is_Script=ugaritic}', ""); +Expect(1, 66431, '\P{Is_Script=ugaritic}', ""); +Expect(0, 66431, '\P{^Is_Script=ugaritic}', ""); +Expect(1, 66461, '\p{Is_Script=_ ugaritic}', ""); +Expect(0, 66461, '\p{^Is_Script=_ ugaritic}', ""); +Expect(0, 66461, '\P{Is_Script=_ ugaritic}', ""); +Expect(1, 66461, '\P{^Is_Script=_ ugaritic}', ""); +Expect(0, 66431, '\p{Is_Script=_ ugaritic}', ""); +Expect(1, 66431, '\p{^Is_Script=_ ugaritic}', ""); +Expect(1, 66431, '\P{Is_Script=_ ugaritic}', ""); +Expect(0, 66431, '\P{^Is_Script=_ ugaritic}', ""); +Error('\p{Is_Sc=-/a/Ugar}'); +Error('\P{Is_Sc=-/a/Ugar}'); +Expect(1, 66461, '\p{Is_Sc=ugar}', ""); +Expect(0, 66461, '\p{^Is_Sc=ugar}', ""); +Expect(0, 66461, '\P{Is_Sc=ugar}', ""); +Expect(1, 66461, '\P{^Is_Sc=ugar}', ""); +Expect(0, 66431, '\p{Is_Sc=ugar}', ""); +Expect(1, 66431, '\p{^Is_Sc=ugar}', ""); +Expect(1, 66431, '\P{Is_Sc=ugar}', ""); +Expect(0, 66431, '\P{^Is_Sc=ugar}', ""); +Expect(1, 66461, '\p{Is_Sc= Ugar}', ""); +Expect(0, 66461, '\p{^Is_Sc= Ugar}', ""); +Expect(0, 66461, '\P{Is_Sc= Ugar}', ""); +Expect(1, 66461, '\P{^Is_Sc= Ugar}', ""); +Expect(0, 66431, '\p{Is_Sc= Ugar}', ""); +Expect(1, 66431, '\p{^Is_Sc= Ugar}', ""); +Expect(1, 66431, '\P{Is_Sc= Ugar}', ""); +Expect(0, 66431, '\P{^Is_Sc= Ugar}', ""); +Error('\p{Script=_Phags:=Pa}'); +Error('\P{Script=_Phags:=Pa}'); +Expect(1, 43127, '\p{Script=phagspa}', ""); +Expect(0, 43127, '\p{^Script=phagspa}', ""); +Expect(0, 43127, '\P{Script=phagspa}', ""); +Expect(1, 43127, '\P{^Script=phagspa}', ""); +Expect(0, 43071, '\p{Script=phagspa}', ""); +Expect(1, 43071, '\p{^Script=phagspa}', ""); +Expect(1, 43071, '\P{Script=phagspa}', ""); +Expect(0, 43071, '\P{^Script=phagspa}', ""); +Expect(1, 43127, '\p{Script=phags_Pa}', ""); +Expect(0, 43127, '\p{^Script=phags_Pa}', ""); +Expect(0, 43127, '\P{Script=phags_Pa}', ""); +Expect(1, 43127, '\P{^Script=phags_Pa}', ""); +Expect(0, 43071, '\p{Script=phags_Pa}', ""); +Expect(1, 43071, '\p{^Script=phags_Pa}', ""); +Expect(1, 43071, '\P{Script=phags_Pa}', ""); +Expect(0, 43071, '\P{^Script=phags_Pa}', ""); +Error('\p{Sc= /a/Phag}'); +Error('\P{Sc= /a/Phag}'); +Expect(1, 43127, '\p{Sc=phag}', ""); +Expect(0, 43127, '\p{^Sc=phag}', ""); +Expect(0, 43127, '\P{Sc=phag}', ""); +Expect(1, 43127, '\P{^Sc=phag}', ""); +Expect(0, 43071, '\p{Sc=phag}', ""); +Expect(1, 43071, '\p{^Sc=phag}', ""); +Expect(1, 43071, '\P{Sc=phag}', ""); +Expect(0, 43071, '\P{^Sc=phag}', ""); +Expect(1, 43127, '\p{Sc: -_Phag}', ""); +Expect(0, 43127, '\p{^Sc: -_Phag}', ""); +Expect(0, 43127, '\P{Sc: -_Phag}', ""); +Expect(1, 43127, '\P{^Sc: -_Phag}', ""); +Expect(0, 43071, '\p{Sc: -_Phag}', ""); +Expect(1, 43071, '\p{^Sc: -_Phag}', ""); +Expect(1, 43071, '\P{Sc: -_Phag}', ""); +Expect(0, 43071, '\P{^Sc: -_Phag}', ""); +Error('\p{Is_Script=-/a/phags_pa}'); +Error('\P{Is_Script=-/a/phags_pa}'); +Expect(1, 43127, '\p{Is_Script=phagspa}', ""); +Expect(0, 43127, '\p{^Is_Script=phagspa}', ""); +Expect(0, 43127, '\P{Is_Script=phagspa}', ""); +Expect(1, 43127, '\P{^Is_Script=phagspa}', ""); +Expect(0, 43071, '\p{Is_Script=phagspa}', ""); +Expect(1, 43071, '\p{^Is_Script=phagspa}', ""); +Expect(1, 43071, '\P{Is_Script=phagspa}', ""); +Expect(0, 43071, '\P{^Is_Script=phagspa}', ""); +Expect(1, 43127, '\p{Is_Script= _phags-Pa}', ""); +Expect(0, 43127, '\p{^Is_Script= _phags-Pa}', ""); +Expect(0, 43127, '\P{Is_Script= _phags-Pa}', ""); +Expect(1, 43127, '\P{^Is_Script= _phags-Pa}', ""); +Expect(0, 43071, '\p{Is_Script= _phags-Pa}', ""); +Expect(1, 43071, '\p{^Is_Script= _phags-Pa}', ""); +Expect(1, 43071, '\P{Is_Script= _phags-Pa}', ""); +Expect(0, 43071, '\P{^Is_Script= _phags-Pa}', ""); +Error('\p{Is_Sc=:=- Phag}'); +Error('\P{Is_Sc=:=- Phag}'); +Expect(1, 43127, '\p{Is_Sc=phag}', ""); +Expect(0, 43127, '\p{^Is_Sc=phag}', ""); +Expect(0, 43127, '\P{Is_Sc=phag}', ""); +Expect(1, 43127, '\P{^Is_Sc=phag}', ""); +Expect(0, 43071, '\p{Is_Sc=phag}', ""); +Expect(1, 43071, '\p{^Is_Sc=phag}', ""); +Expect(1, 43071, '\P{Is_Sc=phag}', ""); +Expect(0, 43071, '\P{^Is_Sc=phag}', ""); +Expect(1, 43127, '\p{Is_Sc= phag}', ""); +Expect(0, 43127, '\p{^Is_Sc= phag}', ""); +Expect(0, 43127, '\P{Is_Sc= phag}', ""); +Expect(1, 43127, '\P{^Is_Sc= phag}', ""); +Expect(0, 43071, '\p{Is_Sc= phag}', ""); +Expect(1, 43071, '\p{^Is_Sc= phag}', ""); +Expect(1, 43071, '\P{Is_Sc= phag}', ""); +Expect(0, 43071, '\P{^Is_Sc= phag}', ""); +Error('\p{Script= :=ARMENIAN}'); +Error('\P{Script= :=ARMENIAN}'); +Expect(1, 1366, '\p{Script=armenian}', ""); +Expect(0, 1366, '\p{^Script=armenian}', ""); +Expect(0, 1366, '\P{Script=armenian}', ""); +Expect(1, 1366, '\P{^Script=armenian}', ""); +Expect(0, 1328, '\p{Script=armenian}', ""); +Expect(1, 1328, '\p{^Script=armenian}', ""); +Expect(1, 1328, '\P{Script=armenian}', ""); +Expect(0, 1328, '\P{^Script=armenian}', ""); +Expect(1, 1366, '\p{Script=_-ARMENIAN}', ""); +Expect(0, 1366, '\p{^Script=_-ARMENIAN}', ""); +Expect(0, 1366, '\P{Script=_-ARMENIAN}', ""); +Expect(1, 1366, '\P{^Script=_-ARMENIAN}', ""); +Expect(0, 1328, '\p{Script=_-ARMENIAN}', ""); +Expect(1, 1328, '\p{^Script=_-ARMENIAN}', ""); +Expect(1, 1328, '\P{Script=_-ARMENIAN}', ""); +Expect(0, 1328, '\P{^Script=_-ARMENIAN}', ""); +Error('\p{Sc=/a/- ARMN}'); +Error('\P{Sc=/a/- ARMN}'); +Expect(1, 1366, '\p{Sc: armn}', ""); +Expect(0, 1366, '\p{^Sc: armn}', ""); +Expect(0, 1366, '\P{Sc: armn}', ""); +Expect(1, 1366, '\P{^Sc: armn}', ""); +Expect(0, 1328, '\p{Sc: armn}', ""); +Expect(1, 1328, '\p{^Sc: armn}', ""); +Expect(1, 1328, '\P{Sc: armn}', ""); +Expect(0, 1328, '\P{^Sc: armn}', ""); +Expect(1, 1366, '\p{Sc= Armn}', ""); +Expect(0, 1366, '\p{^Sc= Armn}', ""); +Expect(0, 1366, '\P{Sc= Armn}', ""); +Expect(1, 1366, '\P{^Sc= Armn}', ""); +Expect(0, 1328, '\p{Sc= Armn}', ""); +Expect(1, 1328, '\p{^Sc= Armn}', ""); +Expect(1, 1328, '\P{Sc= Armn}', ""); +Expect(0, 1328, '\P{^Sc= Armn}', ""); +Error('\p{Is_Script=ARMENIAN:=}'); +Error('\P{Is_Script=ARMENIAN:=}'); +Expect(1, 1366, '\p{Is_Script=armenian}', ""); +Expect(0, 1366, '\p{^Is_Script=armenian}', ""); +Expect(0, 1366, '\P{Is_Script=armenian}', ""); +Expect(1, 1366, '\P{^Is_Script=armenian}', ""); +Expect(0, 1328, '\p{Is_Script=armenian}', ""); +Expect(1, 1328, '\p{^Is_Script=armenian}', ""); +Expect(1, 1328, '\P{Is_Script=armenian}', ""); +Expect(0, 1328, '\P{^Is_Script=armenian}', ""); +Expect(1, 1366, '\p{Is_Script= ARMENIAN}', ""); +Expect(0, 1366, '\p{^Is_Script= ARMENIAN}', ""); +Expect(0, 1366, '\P{Is_Script= ARMENIAN}', ""); +Expect(1, 1366, '\P{^Is_Script= ARMENIAN}', ""); +Expect(0, 1328, '\p{Is_Script= ARMENIAN}', ""); +Expect(1, 1328, '\p{^Is_Script= ARMENIAN}', ""); +Expect(1, 1328, '\P{Is_Script= ARMENIAN}', ""); +Expect(0, 1328, '\P{^Is_Script= ARMENIAN}', ""); +Error('\p{Is_Sc: _/a/armn}'); +Error('\P{Is_Sc: _/a/armn}'); +Expect(1, 1366, '\p{Is_Sc=armn}', ""); +Expect(0, 1366, '\p{^Is_Sc=armn}', ""); +Expect(0, 1366, '\P{Is_Sc=armn}', ""); +Expect(1, 1366, '\P{^Is_Sc=armn}', ""); +Expect(0, 1328, '\p{Is_Sc=armn}', ""); +Expect(1, 1328, '\p{^Is_Sc=armn}', ""); +Expect(1, 1328, '\P{Is_Sc=armn}', ""); +Expect(0, 1328, '\P{^Is_Sc=armn}', ""); +Expect(1, 1366, '\p{Is_Sc:- armn}', ""); +Expect(0, 1366, '\p{^Is_Sc:- armn}', ""); +Expect(0, 1366, '\P{Is_Sc:- armn}', ""); +Expect(1, 1366, '\P{^Is_Sc:- armn}', ""); +Expect(0, 1328, '\p{Is_Sc:- armn}', ""); +Expect(1, 1328, '\p{^Is_Sc:- armn}', ""); +Expect(1, 1328, '\P{Is_Sc:- armn}', ""); +Expect(0, 1328, '\P{^Is_Sc:- armn}', ""); +Error('\p{Script= /a/syriac}'); +Error('\P{Script= /a/syriac}'); +Expect(1, 1805, '\p{Script:syriac}', ""); +Expect(0, 1805, '\p{^Script:syriac}', ""); +Expect(0, 1805, '\P{Script:syriac}', ""); +Expect(1, 1805, '\P{^Script:syriac}', ""); +Expect(0, 1791, '\p{Script:syriac}', ""); +Expect(1, 1791, '\p{^Script:syriac}', ""); +Expect(1, 1791, '\P{Script:syriac}', ""); +Expect(0, 1791, '\P{^Script:syriac}', ""); +Expect(1, 1805, '\p{Script=_-Syriac}', ""); +Expect(0, 1805, '\p{^Script=_-Syriac}', ""); +Expect(0, 1805, '\P{Script=_-Syriac}', ""); +Expect(1, 1805, '\P{^Script=_-Syriac}', ""); +Expect(0, 1791, '\p{Script=_-Syriac}', ""); +Expect(1, 1791, '\p{^Script=_-Syriac}', ""); +Expect(1, 1791, '\P{Script=_-Syriac}', ""); +Expect(0, 1791, '\P{^Script=_-Syriac}', ""); +Error('\p{Sc=/a/ _syrc}'); +Error('\P{Sc=/a/ _syrc}'); +Expect(1, 1805, '\p{Sc=syrc}', ""); +Expect(0, 1805, '\p{^Sc=syrc}', ""); +Expect(0, 1805, '\P{Sc=syrc}', ""); +Expect(1, 1805, '\P{^Sc=syrc}', ""); +Expect(0, 1791, '\p{Sc=syrc}', ""); +Expect(1, 1791, '\p{^Sc=syrc}', ""); +Expect(1, 1791, '\P{Sc=syrc}', ""); +Expect(0, 1791, '\P{^Sc=syrc}', ""); +Expect(1, 1805, '\p{Sc=-SYRC}', ""); +Expect(0, 1805, '\p{^Sc=-SYRC}', ""); +Expect(0, 1805, '\P{Sc=-SYRC}', ""); +Expect(1, 1805, '\P{^Sc=-SYRC}', ""); +Expect(0, 1791, '\p{Sc=-SYRC}', ""); +Expect(1, 1791, '\p{^Sc=-SYRC}', ""); +Expect(1, 1791, '\P{Sc=-SYRC}', ""); +Expect(0, 1791, '\P{^Sc=-SYRC}', ""); +Error('\p{Is_Script: SYRIAC:=}'); +Error('\P{Is_Script: SYRIAC:=}'); +Expect(1, 1805, '\p{Is_Script=syriac}', ""); +Expect(0, 1805, '\p{^Is_Script=syriac}', ""); +Expect(0, 1805, '\P{Is_Script=syriac}', ""); +Expect(1, 1805, '\P{^Is_Script=syriac}', ""); +Expect(0, 1791, '\p{Is_Script=syriac}', ""); +Expect(1, 1791, '\p{^Is_Script=syriac}', ""); +Expect(1, 1791, '\P{Is_Script=syriac}', ""); +Expect(0, 1791, '\P{^Is_Script=syriac}', ""); +Expect(1, 1805, '\p{Is_Script: _SYRIAC}', ""); +Expect(0, 1805, '\p{^Is_Script: _SYRIAC}', ""); +Expect(0, 1805, '\P{Is_Script: _SYRIAC}', ""); +Expect(1, 1805, '\P{^Is_Script: _SYRIAC}', ""); +Expect(0, 1791, '\p{Is_Script: _SYRIAC}', ""); +Expect(1, 1791, '\p{^Is_Script: _SYRIAC}', ""); +Expect(1, 1791, '\P{Is_Script: _SYRIAC}', ""); +Expect(0, 1791, '\P{^Is_Script: _SYRIAC}', ""); +Error('\p{Is_Sc=/a/- SYRC}'); +Error('\P{Is_Sc=/a/- SYRC}'); +Expect(1, 1805, '\p{Is_Sc=syrc}', ""); +Expect(0, 1805, '\p{^Is_Sc=syrc}', ""); +Expect(0, 1805, '\P{Is_Sc=syrc}', ""); +Expect(1, 1805, '\P{^Is_Sc=syrc}', ""); +Expect(0, 1791, '\p{Is_Sc=syrc}', ""); +Expect(1, 1791, '\p{^Is_Sc=syrc}', ""); +Expect(1, 1791, '\P{Is_Sc=syrc}', ""); +Expect(0, 1791, '\P{^Is_Sc=syrc}', ""); +Expect(1, 1805, '\p{Is_Sc: _ Syrc}', ""); +Expect(0, 1805, '\p{^Is_Sc: _ Syrc}', ""); +Expect(0, 1805, '\P{Is_Sc: _ Syrc}', ""); +Expect(1, 1805, '\P{^Is_Sc: _ Syrc}', ""); +Expect(0, 1791, '\p{Is_Sc: _ Syrc}', ""); +Expect(1, 1791, '\p{^Is_Sc: _ Syrc}', ""); +Expect(1, 1791, '\P{Is_Sc: _ Syrc}', ""); +Expect(0, 1791, '\P{^Is_Sc: _ Syrc}', ""); +Error('\p{Script=Yi:=}'); +Error('\P{Script=Yi:=}'); +Expect(1, 42124, '\p{Script=yi}', ""); +Expect(0, 42124, '\p{^Script=yi}', ""); +Expect(0, 42124, '\P{Script=yi}', ""); +Expect(1, 42124, '\P{^Script=yi}', ""); +Expect(0, 40959, '\p{Script=yi}', ""); +Expect(1, 40959, '\p{^Script=yi}', ""); +Expect(1, 40959, '\P{Script=yi}', ""); +Expect(0, 40959, '\P{^Script=yi}', ""); +Expect(1, 42124, '\p{Script=-Yi}', ""); +Expect(0, 42124, '\p{^Script=-Yi}', ""); +Expect(0, 42124, '\P{Script=-Yi}', ""); +Expect(1, 42124, '\P{^Script=-Yi}', ""); +Expect(0, 40959, '\p{Script=-Yi}', ""); +Expect(1, 40959, '\p{^Script=-Yi}', ""); +Expect(1, 40959, '\P{Script=-Yi}', ""); +Expect(0, 40959, '\P{^Script=-Yi}', ""); +Error('\p{Sc=-/a/yiii}'); +Error('\P{Sc=-/a/yiii}'); +Expect(1, 42124, '\p{Sc:yiii}', ""); +Expect(0, 42124, '\p{^Sc:yiii}', ""); +Expect(0, 42124, '\P{Sc:yiii}', ""); +Expect(1, 42124, '\P{^Sc:yiii}', ""); +Expect(0, 40959, '\p{Sc:yiii}', ""); +Expect(1, 40959, '\p{^Sc:yiii}', ""); +Expect(1, 40959, '\P{Sc:yiii}', ""); +Expect(0, 40959, '\P{^Sc:yiii}', ""); +Expect(1, 42124, '\p{Sc=-Yiii}', ""); +Expect(0, 42124, '\p{^Sc=-Yiii}', ""); +Expect(0, 42124, '\P{Sc=-Yiii}', ""); +Expect(1, 42124, '\P{^Sc=-Yiii}', ""); +Expect(0, 40959, '\p{Sc=-Yiii}', ""); +Expect(1, 40959, '\p{^Sc=-Yiii}', ""); +Expect(1, 40959, '\P{Sc=-Yiii}', ""); +Expect(0, 40959, '\P{^Sc=-Yiii}', ""); +Error('\p{Is_Script= Yi:=}'); +Error('\P{Is_Script= Yi:=}'); +Expect(1, 42124, '\p{Is_Script=yi}', ""); +Expect(0, 42124, '\p{^Is_Script=yi}', ""); +Expect(0, 42124, '\P{Is_Script=yi}', ""); +Expect(1, 42124, '\P{^Is_Script=yi}', ""); +Expect(0, 40959, '\p{Is_Script=yi}', ""); +Expect(1, 40959, '\p{^Is_Script=yi}', ""); +Expect(1, 40959, '\P{Is_Script=yi}', ""); +Expect(0, 40959, '\P{^Is_Script=yi}', ""); +Expect(1, 42124, '\p{Is_Script= YI}', ""); +Expect(0, 42124, '\p{^Is_Script= YI}', ""); +Expect(0, 42124, '\P{Is_Script= YI}', ""); +Expect(1, 42124, '\P{^Is_Script= YI}', ""); +Expect(0, 40959, '\p{Is_Script= YI}', ""); +Expect(1, 40959, '\p{^Is_Script= YI}', ""); +Expect(1, 40959, '\P{Is_Script= YI}', ""); +Expect(0, 40959, '\P{^Is_Script= YI}', ""); +Error('\p{Is_Sc=-/a/YIII}'); +Error('\P{Is_Sc=-/a/YIII}'); +Expect(1, 42124, '\p{Is_Sc=yiii}', ""); +Expect(0, 42124, '\p{^Is_Sc=yiii}', ""); +Expect(0, 42124, '\P{Is_Sc=yiii}', ""); +Expect(1, 42124, '\P{^Is_Sc=yiii}', ""); +Expect(0, 40959, '\p{Is_Sc=yiii}', ""); +Expect(1, 40959, '\p{^Is_Sc=yiii}', ""); +Expect(1, 40959, '\P{Is_Sc=yiii}', ""); +Expect(0, 40959, '\P{^Is_Sc=yiii}', ""); +Expect(1, 42124, '\p{Is_Sc=_-YIII}', ""); +Expect(0, 42124, '\p{^Is_Sc=_-YIII}', ""); +Expect(0, 42124, '\P{Is_Sc=_-YIII}', ""); +Expect(1, 42124, '\P{^Is_Sc=_-YIII}', ""); +Expect(0, 40959, '\p{Is_Sc=_-YIII}', ""); +Expect(1, 40959, '\p{^Is_Sc=_-YIII}', ""); +Expect(1, 40959, '\P{Is_Sc=_-YIII}', ""); +Expect(0, 40959, '\P{^Is_Sc=_-YIII}', ""); +Error('\p{Script=-/a/KATAKANA}'); +Error('\P{Script=-/a/KATAKANA}'); +Expect(1, 12538, '\p{Script=katakana}', ""); +Expect(0, 12538, '\p{^Script=katakana}', ""); +Expect(0, 12538, '\P{Script=katakana}', ""); +Expect(1, 12538, '\P{^Script=katakana}', ""); +Expect(0, 12448, '\p{Script=katakana}', ""); +Expect(1, 12448, '\p{^Script=katakana}', ""); +Expect(1, 12448, '\P{Script=katakana}', ""); +Expect(0, 12448, '\P{^Script=katakana}', ""); +Expect(1, 12538, '\p{Script= Katakana}', ""); +Expect(0, 12538, '\p{^Script= Katakana}', ""); +Expect(0, 12538, '\P{Script= Katakana}', ""); +Expect(1, 12538, '\P{^Script= Katakana}', ""); +Expect(0, 12448, '\p{Script= Katakana}', ""); +Expect(1, 12448, '\p{^Script= Katakana}', ""); +Expect(1, 12448, '\P{Script= Katakana}', ""); +Expect(0, 12448, '\P{^Script= Katakana}', ""); +Error('\p{Sc=-_Kana/a/}'); +Error('\P{Sc=-_Kana/a/}'); +Expect(1, 12538, '\p{Sc=kana}', ""); +Expect(0, 12538, '\p{^Sc=kana}', ""); +Expect(0, 12538, '\P{Sc=kana}', ""); +Expect(1, 12538, '\P{^Sc=kana}', ""); +Expect(0, 12448, '\p{Sc=kana}', ""); +Expect(1, 12448, '\p{^Sc=kana}', ""); +Expect(1, 12448, '\P{Sc=kana}', ""); +Expect(0, 12448, '\P{^Sc=kana}', ""); +Expect(1, 12538, '\p{Sc: Kana}', ""); +Expect(0, 12538, '\p{^Sc: Kana}', ""); +Expect(0, 12538, '\P{Sc: Kana}', ""); +Expect(1, 12538, '\P{^Sc: Kana}', ""); +Expect(0, 12448, '\p{Sc: Kana}', ""); +Expect(1, 12448, '\p{^Sc: Kana}', ""); +Expect(1, 12448, '\P{Sc: Kana}', ""); +Expect(0, 12448, '\P{^Sc: Kana}', ""); +Error('\p{Is_Script=_katakana:=}'); +Error('\P{Is_Script=_katakana:=}'); +Expect(1, 12538, '\p{Is_Script=katakana}', ""); +Expect(0, 12538, '\p{^Is_Script=katakana}', ""); +Expect(0, 12538, '\P{Is_Script=katakana}', ""); +Expect(1, 12538, '\P{^Is_Script=katakana}', ""); +Expect(0, 12448, '\p{Is_Script=katakana}', ""); +Expect(1, 12448, '\p{^Is_Script=katakana}', ""); +Expect(1, 12448, '\P{Is_Script=katakana}', ""); +Expect(0, 12448, '\P{^Is_Script=katakana}', ""); +Expect(1, 12538, '\p{Is_Script=-Katakana}', ""); +Expect(0, 12538, '\p{^Is_Script=-Katakana}', ""); +Expect(0, 12538, '\P{Is_Script=-Katakana}', ""); +Expect(1, 12538, '\P{^Is_Script=-Katakana}', ""); +Expect(0, 12448, '\p{Is_Script=-Katakana}', ""); +Expect(1, 12448, '\p{^Is_Script=-Katakana}', ""); +Expect(1, 12448, '\P{Is_Script=-Katakana}', ""); +Expect(0, 12448, '\P{^Is_Script=-Katakana}', ""); +Error('\p{Is_Sc=-/a/Kana}'); +Error('\P{Is_Sc=-/a/Kana}'); +Expect(1, 12538, '\p{Is_Sc=kana}', ""); +Expect(0, 12538, '\p{^Is_Sc=kana}', ""); +Expect(0, 12538, '\P{Is_Sc=kana}', ""); +Expect(1, 12538, '\P{^Is_Sc=kana}', ""); +Expect(0, 12448, '\p{Is_Sc=kana}', ""); +Expect(1, 12448, '\p{^Is_Sc=kana}', ""); +Expect(1, 12448, '\P{Is_Sc=kana}', ""); +Expect(0, 12448, '\P{^Is_Sc=kana}', ""); +Expect(1, 12538, '\p{Is_Sc=- KANA}', ""); +Expect(0, 12538, '\p{^Is_Sc=- KANA}', ""); +Expect(0, 12538, '\P{Is_Sc=- KANA}', ""); +Expect(1, 12538, '\P{^Is_Sc=- KANA}', ""); +Expect(0, 12448, '\p{Is_Sc=- KANA}', ""); +Expect(1, 12448, '\p{^Is_Sc=- KANA}', ""); +Expect(1, 12448, '\P{Is_Sc=- KANA}', ""); +Expect(0, 12448, '\P{^Is_Sc=- KANA}', ""); +Error('\p{Script=-Glagolitic/a/}'); +Error('\P{Script=-Glagolitic/a/}'); +Expect(1, 11310, '\p{Script=glagolitic}', ""); +Expect(0, 11310, '\p{^Script=glagolitic}', ""); +Expect(0, 11310, '\P{Script=glagolitic}', ""); +Expect(1, 11310, '\P{^Script=glagolitic}', ""); +Expect(0, 11263, '\p{Script=glagolitic}', ""); +Expect(1, 11263, '\p{^Script=glagolitic}', ""); +Expect(1, 11263, '\P{Script=glagolitic}', ""); +Expect(0, 11263, '\P{^Script=glagolitic}', ""); +Expect(1, 11310, '\p{Script= _Glagolitic}', ""); +Expect(0, 11310, '\p{^Script= _Glagolitic}', ""); +Expect(0, 11310, '\P{Script= _Glagolitic}', ""); +Expect(1, 11310, '\P{^Script= _Glagolitic}', ""); +Expect(0, 11263, '\p{Script= _Glagolitic}', ""); +Expect(1, 11263, '\p{^Script= _Glagolitic}', ""); +Expect(1, 11263, '\P{Script= _Glagolitic}', ""); +Expect(0, 11263, '\P{^Script= _Glagolitic}', ""); +Error('\p{Sc= glag:=}'); +Error('\P{Sc= glag:=}'); +Expect(1, 11310, '\p{Sc=glag}', ""); +Expect(0, 11310, '\p{^Sc=glag}', ""); +Expect(0, 11310, '\P{Sc=glag}', ""); +Expect(1, 11310, '\P{^Sc=glag}', ""); +Expect(0, 11263, '\p{Sc=glag}', ""); +Expect(1, 11263, '\p{^Sc=glag}', ""); +Expect(1, 11263, '\P{Sc=glag}', ""); +Expect(0, 11263, '\P{^Sc=glag}', ""); +Expect(1, 11310, '\p{Sc=_ Glag}', ""); +Expect(0, 11310, '\p{^Sc=_ Glag}', ""); +Expect(0, 11310, '\P{Sc=_ Glag}', ""); +Expect(1, 11310, '\P{^Sc=_ Glag}', ""); +Expect(0, 11263, '\p{Sc=_ Glag}', ""); +Expect(1, 11263, '\p{^Sc=_ Glag}', ""); +Expect(1, 11263, '\P{Sc=_ Glag}', ""); +Expect(0, 11263, '\P{^Sc=_ Glag}', ""); +Error('\p{Is_Script=_ Glagolitic:=}'); +Error('\P{Is_Script=_ Glagolitic:=}'); +Expect(1, 11310, '\p{Is_Script:glagolitic}', ""); +Expect(0, 11310, '\p{^Is_Script:glagolitic}', ""); +Expect(0, 11310, '\P{Is_Script:glagolitic}', ""); +Expect(1, 11310, '\P{^Is_Script:glagolitic}', ""); +Expect(0, 11263, '\p{Is_Script:glagolitic}', ""); +Expect(1, 11263, '\p{^Is_Script:glagolitic}', ""); +Expect(1, 11263, '\P{Is_Script:glagolitic}', ""); +Expect(0, 11263, '\P{^Is_Script:glagolitic}', ""); +Expect(1, 11310, '\p{Is_Script: Glagolitic}', ""); +Expect(0, 11310, '\p{^Is_Script: Glagolitic}', ""); +Expect(0, 11310, '\P{Is_Script: Glagolitic}', ""); +Expect(1, 11310, '\P{^Is_Script: Glagolitic}', ""); +Expect(0, 11263, '\p{Is_Script: Glagolitic}', ""); +Expect(1, 11263, '\p{^Is_Script: Glagolitic}', ""); +Expect(1, 11263, '\P{Is_Script: Glagolitic}', ""); +Expect(0, 11263, '\P{^Is_Script: Glagolitic}', ""); +Error('\p{Is_Sc=- Glag:=}'); +Error('\P{Is_Sc=- Glag:=}'); +Expect(1, 11310, '\p{Is_Sc=glag}', ""); +Expect(0, 11310, '\p{^Is_Sc=glag}', ""); +Expect(0, 11310, '\P{Is_Sc=glag}', ""); +Expect(1, 11310, '\P{^Is_Sc=glag}', ""); +Expect(0, 11263, '\p{Is_Sc=glag}', ""); +Expect(1, 11263, '\p{^Is_Sc=glag}', ""); +Expect(1, 11263, '\P{Is_Sc=glag}', ""); +Expect(0, 11263, '\P{^Is_Sc=glag}', ""); +Expect(1, 11310, '\p{Is_Sc= Glag}', ""); +Expect(0, 11310, '\p{^Is_Sc= Glag}', ""); +Expect(0, 11310, '\P{Is_Sc= Glag}', ""); +Expect(1, 11310, '\P{^Is_Sc= Glag}', ""); +Expect(0, 11263, '\p{Is_Sc= Glag}', ""); +Expect(1, 11263, '\p{^Is_Sc= Glag}', ""); +Expect(1, 11263, '\P{Is_Sc= Glag}', ""); +Expect(0, 11263, '\P{^Is_Sc= Glag}', ""); +Error('\p{Script=-:=THAANA}'); +Error('\P{Script=-:=THAANA}'); +Expect(1, 1969, '\p{Script=thaana}', ""); +Expect(0, 1969, '\p{^Script=thaana}', ""); +Expect(0, 1969, '\P{Script=thaana}', ""); +Expect(1, 1969, '\P{^Script=thaana}', ""); +Expect(0, 1919, '\p{Script=thaana}', ""); +Expect(1, 1919, '\p{^Script=thaana}', ""); +Expect(1, 1919, '\P{Script=thaana}', ""); +Expect(0, 1919, '\P{^Script=thaana}', ""); +Expect(1, 1969, '\p{Script= thaana}', ""); +Expect(0, 1969, '\p{^Script= thaana}', ""); +Expect(0, 1969, '\P{Script= thaana}', ""); +Expect(1, 1969, '\P{^Script= thaana}', ""); +Expect(0, 1919, '\p{Script= thaana}', ""); +Expect(1, 1919, '\p{^Script= thaana}', ""); +Expect(1, 1919, '\P{Script= thaana}', ""); +Expect(0, 1919, '\P{^Script= thaana}', ""); +Error('\p{Sc=:= thaa}'); +Error('\P{Sc=:= thaa}'); +Expect(1, 1969, '\p{Sc=thaa}', ""); +Expect(0, 1969, '\p{^Sc=thaa}', ""); +Expect(0, 1969, '\P{Sc=thaa}', ""); +Expect(1, 1969, '\P{^Sc=thaa}', ""); +Expect(0, 1919, '\p{Sc=thaa}', ""); +Expect(1, 1919, '\p{^Sc=thaa}', ""); +Expect(1, 1919, '\P{Sc=thaa}', ""); +Expect(0, 1919, '\P{^Sc=thaa}', ""); +Expect(1, 1969, '\p{Sc: THAA}', ""); +Expect(0, 1969, '\p{^Sc: THAA}', ""); +Expect(0, 1969, '\P{Sc: THAA}', ""); +Expect(1, 1969, '\P{^Sc: THAA}', ""); +Expect(0, 1919, '\p{Sc: THAA}', ""); +Expect(1, 1919, '\p{^Sc: THAA}', ""); +Expect(1, 1919, '\P{Sc: THAA}', ""); +Expect(0, 1919, '\P{^Sc: THAA}', ""); +Error('\p{Is_Script=-thaana/a/}'); +Error('\P{Is_Script=-thaana/a/}'); +Expect(1, 1969, '\p{Is_Script=thaana}', ""); +Expect(0, 1969, '\p{^Is_Script=thaana}', ""); +Expect(0, 1969, '\P{Is_Script=thaana}', ""); +Expect(1, 1969, '\P{^Is_Script=thaana}', ""); +Expect(0, 1919, '\p{Is_Script=thaana}', ""); +Expect(1, 1919, '\p{^Is_Script=thaana}', ""); +Expect(1, 1919, '\P{Is_Script=thaana}', ""); +Expect(0, 1919, '\P{^Is_Script=thaana}', ""); +Expect(1, 1969, '\p{Is_Script: THAANA}', ""); +Expect(0, 1969, '\p{^Is_Script: THAANA}', ""); +Expect(0, 1969, '\P{Is_Script: THAANA}', ""); +Expect(1, 1969, '\P{^Is_Script: THAANA}', ""); +Expect(0, 1919, '\p{Is_Script: THAANA}', ""); +Expect(1, 1919, '\p{^Is_Script: THAANA}', ""); +Expect(1, 1919, '\P{Is_Script: THAANA}', ""); +Expect(0, 1919, '\P{^Is_Script: THAANA}', ""); +Error('\p{Is_Sc=/a/ Thaa}'); +Error('\P{Is_Sc=/a/ Thaa}'); +Expect(1, 1969, '\p{Is_Sc=thaa}', ""); +Expect(0, 1969, '\p{^Is_Sc=thaa}', ""); +Expect(0, 1969, '\P{Is_Sc=thaa}', ""); +Expect(1, 1969, '\P{^Is_Sc=thaa}', ""); +Expect(0, 1919, '\p{Is_Sc=thaa}', ""); +Expect(1, 1919, '\p{^Is_Sc=thaa}', ""); +Expect(1, 1919, '\P{Is_Sc=thaa}', ""); +Expect(0, 1919, '\P{^Is_Sc=thaa}', ""); +Expect(1, 1969, '\p{Is_Sc= Thaa}', ""); +Expect(0, 1969, '\p{^Is_Sc= Thaa}', ""); +Expect(0, 1969, '\P{Is_Sc= Thaa}', ""); +Expect(1, 1969, '\P{^Is_Sc= Thaa}', ""); +Expect(0, 1919, '\p{Is_Sc= Thaa}', ""); +Expect(1, 1919, '\p{^Is_Sc= Thaa}', ""); +Expect(1, 1919, '\P{Is_Sc= Thaa}', ""); +Expect(0, 1919, '\P{^Is_Sc= Thaa}', ""); +Error('\p{Script: :=LEPCHA}'); +Error('\P{Script: :=LEPCHA}'); +Expect(1, 7223, '\p{Script=lepcha}', ""); +Expect(0, 7223, '\p{^Script=lepcha}', ""); +Expect(0, 7223, '\P{Script=lepcha}', ""); +Expect(1, 7223, '\P{^Script=lepcha}', ""); +Expect(0, 7167, '\p{Script=lepcha}', ""); +Expect(1, 7167, '\p{^Script=lepcha}', ""); +Expect(1, 7167, '\P{Script=lepcha}', ""); +Expect(0, 7167, '\P{^Script=lepcha}', ""); +Expect(1, 7223, '\p{Script=_lepcha}', ""); +Expect(0, 7223, '\p{^Script=_lepcha}', ""); +Expect(0, 7223, '\P{Script=_lepcha}', ""); +Expect(1, 7223, '\P{^Script=_lepcha}', ""); +Expect(0, 7167, '\p{Script=_lepcha}', ""); +Expect(1, 7167, '\p{^Script=_lepcha}', ""); +Expect(1, 7167, '\P{Script=_lepcha}', ""); +Expect(0, 7167, '\P{^Script=_lepcha}', ""); +Error('\p{Sc=-/a/Lepc}'); +Error('\P{Sc=-/a/Lepc}'); +Expect(1, 7223, '\p{Sc=lepc}', ""); +Expect(0, 7223, '\p{^Sc=lepc}', ""); +Expect(0, 7223, '\P{Sc=lepc}', ""); +Expect(1, 7223, '\P{^Sc=lepc}', ""); +Expect(0, 7167, '\p{Sc=lepc}', ""); +Expect(1, 7167, '\p{^Sc=lepc}', ""); +Expect(1, 7167, '\P{Sc=lepc}', ""); +Expect(0, 7167, '\P{^Sc=lepc}', ""); +Expect(1, 7223, '\p{Sc: -Lepc}', ""); +Expect(0, 7223, '\p{^Sc: -Lepc}', ""); +Expect(0, 7223, '\P{Sc: -Lepc}', ""); +Expect(1, 7223, '\P{^Sc: -Lepc}', ""); +Expect(0, 7167, '\p{Sc: -Lepc}', ""); +Expect(1, 7167, '\p{^Sc: -Lepc}', ""); +Expect(1, 7167, '\P{Sc: -Lepc}', ""); +Expect(0, 7167, '\P{^Sc: -Lepc}', ""); +Error('\p{Is_Script=:=-_lepcha}'); +Error('\P{Is_Script=:=-_lepcha}'); +Expect(1, 7223, '\p{Is_Script=lepcha}', ""); +Expect(0, 7223, '\p{^Is_Script=lepcha}', ""); +Expect(0, 7223, '\P{Is_Script=lepcha}', ""); +Expect(1, 7223, '\P{^Is_Script=lepcha}', ""); +Expect(0, 7167, '\p{Is_Script=lepcha}', ""); +Expect(1, 7167, '\p{^Is_Script=lepcha}', ""); +Expect(1, 7167, '\P{Is_Script=lepcha}', ""); +Expect(0, 7167, '\P{^Is_Script=lepcha}', ""); +Error('\p{Is_Sc=:=_ LEPC}'); +Error('\P{Is_Sc=:=_ LEPC}'); +Expect(1, 7223, '\p{Is_Sc=lepc}', ""); +Expect(0, 7223, '\p{^Is_Sc=lepc}', ""); +Expect(0, 7223, '\P{Is_Sc=lepc}', ""); +Expect(1, 7223, '\P{^Is_Sc=lepc}', ""); +Expect(0, 7167, '\p{Is_Sc=lepc}', ""); +Expect(1, 7167, '\p{^Is_Sc=lepc}', ""); +Expect(1, 7167, '\P{Is_Sc=lepc}', ""); +Expect(0, 7167, '\P{^Is_Sc=lepc}', ""); +Expect(1, 7223, '\p{Is_Sc=_-lepc}', ""); +Expect(0, 7223, '\p{^Is_Sc=_-lepc}', ""); +Expect(0, 7223, '\P{Is_Sc=_-lepc}', ""); +Expect(1, 7223, '\P{^Is_Sc=_-lepc}', ""); +Expect(0, 7167, '\p{Is_Sc=_-lepc}', ""); +Expect(1, 7167, '\p{^Is_Sc=_-lepc}', ""); +Expect(1, 7167, '\P{Is_Sc=_-lepc}', ""); +Expect(0, 7167, '\P{^Is_Sc=_-lepc}', ""); +Error('\p{Script=/a/ Coptic}'); +Error('\P{Script=/a/ Coptic}'); +Expect(1, 1007, '\p{Script=coptic}', ""); +Expect(0, 1007, '\p{^Script=coptic}', ""); +Expect(0, 1007, '\P{Script=coptic}', ""); +Expect(1, 1007, '\P{^Script=coptic}', ""); +Expect(0, 993, '\p{Script=coptic}', ""); +Expect(1, 993, '\p{^Script=coptic}', ""); +Expect(1, 993, '\P{Script=coptic}', ""); +Expect(0, 993, '\P{^Script=coptic}', ""); +Expect(1, 1007, '\p{Script= _coptic}', ""); +Expect(0, 1007, '\p{^Script= _coptic}', ""); +Expect(0, 1007, '\P{Script= _coptic}', ""); +Expect(1, 1007, '\P{^Script= _coptic}', ""); +Expect(0, 993, '\p{Script= _coptic}', ""); +Expect(1, 993, '\p{^Script= _coptic}', ""); +Expect(1, 993, '\P{Script= _coptic}', ""); +Expect(0, 993, '\P{^Script= _coptic}', ""); +Error('\p{Sc=-copt/a/}'); +Error('\P{Sc=-copt/a/}'); +Expect(1, 1007, '\p{Sc=copt}', ""); +Expect(0, 1007, '\p{^Sc=copt}', ""); +Expect(0, 1007, '\P{Sc=copt}', ""); +Expect(1, 1007, '\P{^Sc=copt}', ""); +Expect(0, 993, '\p{Sc=copt}', ""); +Expect(1, 993, '\p{^Sc=copt}', ""); +Expect(1, 993, '\P{Sc=copt}', ""); +Expect(0, 993, '\P{^Sc=copt}', ""); +Expect(1, 1007, '\p{Sc= Copt}', ""); +Expect(0, 1007, '\p{^Sc= Copt}', ""); +Expect(0, 1007, '\P{Sc= Copt}', ""); +Expect(1, 1007, '\P{^Sc= Copt}', ""); +Expect(0, 993, '\p{Sc= Copt}', ""); +Expect(1, 993, '\p{^Sc= Copt}', ""); +Expect(1, 993, '\P{Sc= Copt}', ""); +Expect(0, 993, '\P{^Sc= Copt}', ""); +Error('\p{Is_Script:_:=qaac}'); +Error('\P{Is_Script:_:=qaac}'); +Expect(1, 1007, '\p{Is_Script: qaac}', ""); +Expect(0, 1007, '\p{^Is_Script: qaac}', ""); +Expect(0, 1007, '\P{Is_Script: qaac}', ""); +Expect(1, 1007, '\P{^Is_Script: qaac}', ""); +Expect(0, 993, '\p{Is_Script: qaac}', ""); +Expect(1, 993, '\p{^Is_Script: qaac}', ""); +Expect(1, 993, '\P{Is_Script: qaac}', ""); +Expect(0, 993, '\P{^Is_Script: qaac}', ""); +Expect(1, 1007, '\p{Is_Script= -Qaac}', ""); +Expect(0, 1007, '\p{^Is_Script= -Qaac}', ""); +Expect(0, 1007, '\P{Is_Script= -Qaac}', ""); +Expect(1, 1007, '\P{^Is_Script= -Qaac}', ""); +Expect(0, 993, '\p{Is_Script= -Qaac}', ""); +Expect(1, 993, '\p{^Is_Script= -Qaac}', ""); +Expect(1, 993, '\P{Is_Script= -Qaac}', ""); +Expect(0, 993, '\P{^Is_Script= -Qaac}', ""); +Error('\p{Is_Sc= /a/Coptic}'); +Error('\P{Is_Sc= /a/Coptic}'); +Expect(1, 1007, '\p{Is_Sc=coptic}', ""); +Expect(0, 1007, '\p{^Is_Sc=coptic}', ""); +Expect(0, 1007, '\P{Is_Sc=coptic}', ""); +Expect(1, 1007, '\P{^Is_Sc=coptic}', ""); +Expect(0, 993, '\p{Is_Sc=coptic}', ""); +Expect(1, 993, '\p{^Is_Sc=coptic}', ""); +Expect(1, 993, '\P{Is_Sc=coptic}', ""); +Expect(0, 993, '\P{^Is_Sc=coptic}', ""); +Expect(1, 1007, '\p{Is_Sc=- COPTIC}', ""); +Expect(0, 1007, '\p{^Is_Sc=- COPTIC}', ""); +Expect(0, 1007, '\P{Is_Sc=- COPTIC}', ""); +Expect(1, 1007, '\P{^Is_Sc=- COPTIC}', ""); +Expect(0, 993, '\p{Is_Sc=- COPTIC}', ""); +Expect(1, 993, '\p{^Is_Sc=- COPTIC}', ""); +Expect(1, 993, '\P{Is_Sc=- COPTIC}', ""); +Expect(0, 993, '\P{^Is_Sc=- COPTIC}', ""); +Error('\p{Script=Katakana_Or_Hiragana}'); +Error('\P{Script=Katakana_Or_Hiragana}'); +Error('\p{Sc: Hrkt}'); +Error('\P{Sc: Hrkt}'); +Error('\p{Is_Script: Katakana_Or_Hiragana}'); +Error('\P{Is_Script: Katakana_Or_Hiragana}'); +Error('\p{Is_Sc=Hrkt}'); +Error('\P{Is_Sc=Hrkt}'); +Error('\p{Script=-Balinese:=}'); +Error('\P{Script=-Balinese:=}'); +Expect(1, 6987, '\p{Script=balinese}', ""); +Expect(0, 6987, '\p{^Script=balinese}', ""); +Expect(0, 6987, '\P{Script=balinese}', ""); +Expect(1, 6987, '\P{^Script=balinese}', ""); +Expect(0, 6911, '\p{Script=balinese}', ""); +Expect(1, 6911, '\p{^Script=balinese}', ""); +Expect(1, 6911, '\P{Script=balinese}', ""); +Expect(0, 6911, '\P{^Script=balinese}', ""); +Expect(1, 6987, '\p{Script=-Balinese}', ""); +Expect(0, 6987, '\p{^Script=-Balinese}', ""); +Expect(0, 6987, '\P{Script=-Balinese}', ""); +Expect(1, 6987, '\P{^Script=-Balinese}', ""); +Expect(0, 6911, '\p{Script=-Balinese}', ""); +Expect(1, 6911, '\p{^Script=-Balinese}', ""); +Expect(1, 6911, '\P{Script=-Balinese}', ""); +Expect(0, 6911, '\P{^Script=-Balinese}', ""); +Error('\p{Sc=/a/bali}'); +Error('\P{Sc=/a/bali}'); +Expect(1, 6987, '\p{Sc=bali}', ""); +Expect(0, 6987, '\p{^Sc=bali}', ""); +Expect(0, 6987, '\P{Sc=bali}', ""); +Expect(1, 6987, '\P{^Sc=bali}', ""); +Expect(0, 6911, '\p{Sc=bali}', ""); +Expect(1, 6911, '\p{^Sc=bali}', ""); +Expect(1, 6911, '\P{Sc=bali}', ""); +Expect(0, 6911, '\P{^Sc=bali}', ""); +Expect(1, 6987, '\p{Sc=-Bali}', ""); +Expect(0, 6987, '\p{^Sc=-Bali}', ""); +Expect(0, 6987, '\P{Sc=-Bali}', ""); +Expect(1, 6987, '\P{^Sc=-Bali}', ""); +Expect(0, 6911, '\p{Sc=-Bali}', ""); +Expect(1, 6911, '\p{^Sc=-Bali}', ""); +Expect(1, 6911, '\P{Sc=-Bali}', ""); +Expect(0, 6911, '\P{^Sc=-Bali}', ""); +Error('\p{Is_Script=-BALINESE/a/}'); +Error('\P{Is_Script=-BALINESE/a/}'); +Expect(1, 6987, '\p{Is_Script=balinese}', ""); +Expect(0, 6987, '\p{^Is_Script=balinese}', ""); +Expect(0, 6987, '\P{Is_Script=balinese}', ""); +Expect(1, 6987, '\P{^Is_Script=balinese}', ""); +Expect(0, 6911, '\p{Is_Script=balinese}', ""); +Expect(1, 6911, '\p{^Is_Script=balinese}', ""); +Expect(1, 6911, '\P{Is_Script=balinese}', ""); +Expect(0, 6911, '\P{^Is_Script=balinese}', ""); +Expect(1, 6987, '\p{Is_Script=-_balinese}', ""); +Expect(0, 6987, '\p{^Is_Script=-_balinese}', ""); +Expect(0, 6987, '\P{Is_Script=-_balinese}', ""); +Expect(1, 6987, '\P{^Is_Script=-_balinese}', ""); +Expect(0, 6911, '\p{Is_Script=-_balinese}', ""); +Expect(1, 6911, '\p{^Is_Script=-_balinese}', ""); +Expect(1, 6911, '\P{Is_Script=-_balinese}', ""); +Expect(0, 6911, '\P{^Is_Script=-_balinese}', ""); +Error('\p{Is_Sc= /a/Bali}'); +Error('\P{Is_Sc= /a/Bali}'); +Expect(1, 6987, '\p{Is_Sc=bali}', ""); +Expect(0, 6987, '\p{^Is_Sc=bali}', ""); +Expect(0, 6987, '\P{Is_Sc=bali}', ""); +Expect(1, 6987, '\P{^Is_Sc=bali}', ""); +Expect(0, 6911, '\p{Is_Sc=bali}', ""); +Expect(1, 6911, '\p{^Is_Sc=bali}', ""); +Expect(1, 6911, '\P{Is_Sc=bali}', ""); +Expect(0, 6911, '\P{^Is_Sc=bali}', ""); +Expect(1, 6987, '\p{Is_Sc= bali}', ""); +Expect(0, 6987, '\p{^Is_Sc= bali}', ""); +Expect(0, 6987, '\P{Is_Sc= bali}', ""); +Expect(1, 6987, '\P{^Is_Sc= bali}', ""); +Expect(0, 6911, '\p{Is_Sc= bali}', ""); +Expect(1, 6911, '\p{^Is_Sc= bali}', ""); +Expect(1, 6911, '\P{Is_Sc= bali}', ""); +Expect(0, 6911, '\P{^Is_Sc= bali}', ""); +Error('\p{Script=:= Tagbanwa}'); +Error('\P{Script=:= Tagbanwa}'); +Expect(1, 5996, '\p{Script=tagbanwa}', ""); +Expect(0, 5996, '\p{^Script=tagbanwa}', ""); +Expect(0, 5996, '\P{Script=tagbanwa}', ""); +Expect(1, 5996, '\P{^Script=tagbanwa}', ""); +Expect(0, 5983, '\p{Script=tagbanwa}', ""); +Expect(1, 5983, '\p{^Script=tagbanwa}', ""); +Expect(1, 5983, '\P{Script=tagbanwa}', ""); +Expect(0, 5983, '\P{^Script=tagbanwa}', ""); +Expect(1, 5996, '\p{Script=_ tagbanwa}', ""); +Expect(0, 5996, '\p{^Script=_ tagbanwa}', ""); +Expect(0, 5996, '\P{Script=_ tagbanwa}', ""); +Expect(1, 5996, '\P{^Script=_ tagbanwa}', ""); +Expect(0, 5983, '\p{Script=_ tagbanwa}', ""); +Expect(1, 5983, '\p{^Script=_ tagbanwa}', ""); +Expect(1, 5983, '\P{Script=_ tagbanwa}', ""); +Expect(0, 5983, '\P{^Script=_ tagbanwa}', ""); +Error('\p{Sc= TAGB:=}'); +Error('\P{Sc= TAGB:=}'); +Expect(1, 5996, '\p{Sc=tagb}', ""); +Expect(0, 5996, '\p{^Sc=tagb}', ""); +Expect(0, 5996, '\P{Sc=tagb}', ""); +Expect(1, 5996, '\P{^Sc=tagb}', ""); +Expect(0, 5983, '\p{Sc=tagb}', ""); +Expect(1, 5983, '\p{^Sc=tagb}', ""); +Expect(1, 5983, '\P{Sc=tagb}', ""); +Expect(0, 5983, '\P{^Sc=tagb}', ""); +Expect(1, 5996, '\p{Sc= Tagb}', ""); +Expect(0, 5996, '\p{^Sc= Tagb}', ""); +Expect(0, 5996, '\P{Sc= Tagb}', ""); +Expect(1, 5996, '\P{^Sc= Tagb}', ""); +Expect(0, 5983, '\p{Sc= Tagb}', ""); +Expect(1, 5983, '\p{^Sc= Tagb}', ""); +Expect(1, 5983, '\P{Sc= Tagb}', ""); +Expect(0, 5983, '\P{^Sc= Tagb}', ""); +Error('\p{Is_Script=_:=TAGBANWA}'); +Error('\P{Is_Script=_:=TAGBANWA}'); +Expect(1, 5996, '\p{Is_Script=tagbanwa}', ""); +Expect(0, 5996, '\p{^Is_Script=tagbanwa}', ""); +Expect(0, 5996, '\P{Is_Script=tagbanwa}', ""); +Expect(1, 5996, '\P{^Is_Script=tagbanwa}', ""); +Expect(0, 5983, '\p{Is_Script=tagbanwa}', ""); +Expect(1, 5983, '\p{^Is_Script=tagbanwa}', ""); +Expect(1, 5983, '\P{Is_Script=tagbanwa}', ""); +Expect(0, 5983, '\P{^Is_Script=tagbanwa}', ""); +Expect(1, 5996, '\p{Is_Script=__TAGBANWA}', ""); +Expect(0, 5996, '\p{^Is_Script=__TAGBANWA}', ""); +Expect(0, 5996, '\P{Is_Script=__TAGBANWA}', ""); +Expect(1, 5996, '\P{^Is_Script=__TAGBANWA}', ""); +Expect(0, 5983, '\p{Is_Script=__TAGBANWA}', ""); +Expect(1, 5983, '\p{^Is_Script=__TAGBANWA}', ""); +Expect(1, 5983, '\P{Is_Script=__TAGBANWA}', ""); +Expect(0, 5983, '\P{^Is_Script=__TAGBANWA}', ""); +Error('\p{Is_Sc=/a/tagb}'); +Error('\P{Is_Sc=/a/tagb}'); +Expect(1, 5996, '\p{Is_Sc=tagb}', ""); +Expect(0, 5996, '\p{^Is_Sc=tagb}', ""); +Expect(0, 5996, '\P{Is_Sc=tagb}', ""); +Expect(1, 5996, '\P{^Is_Sc=tagb}', ""); +Expect(0, 5983, '\p{Is_Sc=tagb}', ""); +Expect(1, 5983, '\p{^Is_Sc=tagb}', ""); +Expect(1, 5983, '\P{Is_Sc=tagb}', ""); +Expect(0, 5983, '\P{^Is_Sc=tagb}', ""); +Expect(1, 5996, '\p{Is_Sc= TAGB}', ""); +Expect(0, 5996, '\p{^Is_Sc= TAGB}', ""); +Expect(0, 5996, '\P{Is_Sc= TAGB}', ""); +Expect(1, 5996, '\P{^Is_Sc= TAGB}', ""); +Expect(0, 5983, '\p{Is_Sc= TAGB}', ""); +Expect(1, 5983, '\p{^Is_Sc= TAGB}', ""); +Expect(1, 5983, '\P{Is_Sc= TAGB}', ""); +Expect(0, 5983, '\P{^Is_Sc= TAGB}', ""); +Error('\p{Script=-SYLOTINagri:=}'); +Error('\P{Script=-SYLOTINagri:=}'); +Expect(1, 43051, '\p{Script=sylotinagri}', ""); +Expect(0, 43051, '\p{^Script=sylotinagri}', ""); +Expect(0, 43051, '\P{Script=sylotinagri}', ""); +Expect(1, 43051, '\P{^Script=sylotinagri}', ""); +Expect(0, 43007, '\p{Script=sylotinagri}', ""); +Expect(1, 43007, '\p{^Script=sylotinagri}', ""); +Expect(1, 43007, '\P{Script=sylotinagri}', ""); +Expect(0, 43007, '\P{^Script=sylotinagri}', ""); +Expect(1, 43051, '\p{Script=_sylotiNagri}', ""); +Expect(0, 43051, '\p{^Script=_sylotiNagri}', ""); +Expect(0, 43051, '\P{Script=_sylotiNagri}', ""); +Expect(1, 43051, '\P{^Script=_sylotiNagri}', ""); +Expect(0, 43007, '\p{Script=_sylotiNagri}', ""); +Expect(1, 43007, '\p{^Script=_sylotiNagri}', ""); +Expect(1, 43007, '\P{Script=_sylotiNagri}', ""); +Expect(0, 43007, '\P{^Script=_sylotiNagri}', ""); +Error('\p{Sc=_/a/Sylo}'); +Error('\P{Sc=_/a/Sylo}'); +Expect(1, 43051, '\p{Sc=sylo}', ""); +Expect(0, 43051, '\p{^Sc=sylo}', ""); +Expect(0, 43051, '\P{Sc=sylo}', ""); +Expect(1, 43051, '\P{^Sc=sylo}', ""); +Expect(0, 43007, '\p{Sc=sylo}', ""); +Expect(1, 43007, '\p{^Sc=sylo}', ""); +Expect(1, 43007, '\P{Sc=sylo}', ""); +Expect(0, 43007, '\P{^Sc=sylo}', ""); +Expect(1, 43051, '\p{Sc= -SYLO}', ""); +Expect(0, 43051, '\p{^Sc= -SYLO}', ""); +Expect(0, 43051, '\P{Sc= -SYLO}', ""); +Expect(1, 43051, '\P{^Sc= -SYLO}', ""); +Expect(0, 43007, '\p{Sc= -SYLO}', ""); +Expect(1, 43007, '\p{^Sc= -SYLO}', ""); +Expect(1, 43007, '\P{Sc= -SYLO}', ""); +Expect(0, 43007, '\P{^Sc= -SYLO}', ""); +Error('\p{Is_Script= :=SYLOTINagri}'); +Error('\P{Is_Script= :=SYLOTINagri}'); +Expect(1, 43051, '\p{Is_Script=sylotinagri}', ""); +Expect(0, 43051, '\p{^Is_Script=sylotinagri}', ""); +Expect(0, 43051, '\P{Is_Script=sylotinagri}', ""); +Expect(1, 43051, '\P{^Is_Script=sylotinagri}', ""); +Expect(0, 43007, '\p{Is_Script=sylotinagri}', ""); +Expect(1, 43007, '\p{^Is_Script=sylotinagri}', ""); +Expect(1, 43007, '\P{Is_Script=sylotinagri}', ""); +Expect(0, 43007, '\P{^Is_Script=sylotinagri}', ""); +Expect(1, 43051, '\p{Is_Script= SYLOTI Nagri}', ""); +Expect(0, 43051, '\p{^Is_Script= SYLOTI Nagri}', ""); +Expect(0, 43051, '\P{Is_Script= SYLOTI Nagri}', ""); +Expect(1, 43051, '\P{^Is_Script= SYLOTI Nagri}', ""); +Expect(0, 43007, '\p{Is_Script= SYLOTI Nagri}', ""); +Expect(1, 43007, '\p{^Is_Script= SYLOTI Nagri}', ""); +Expect(1, 43007, '\P{Is_Script= SYLOTI Nagri}', ""); +Expect(0, 43007, '\P{^Is_Script= SYLOTI Nagri}', ""); +Error('\p{Is_Sc: /a/SYLO}'); +Error('\P{Is_Sc: /a/SYLO}'); +Expect(1, 43051, '\p{Is_Sc=sylo}', ""); +Expect(0, 43051, '\p{^Is_Sc=sylo}', ""); +Expect(0, 43051, '\P{Is_Sc=sylo}', ""); +Expect(1, 43051, '\P{^Is_Sc=sylo}', ""); +Expect(0, 43007, '\p{Is_Sc=sylo}', ""); +Expect(1, 43007, '\p{^Is_Sc=sylo}', ""); +Expect(1, 43007, '\P{Is_Sc=sylo}', ""); +Expect(0, 43007, '\P{^Is_Sc=sylo}', ""); +Expect(1, 43051, '\p{Is_Sc= Sylo}', ""); +Expect(0, 43051, '\p{^Is_Sc= Sylo}', ""); +Expect(0, 43051, '\P{Is_Sc= Sylo}', ""); +Expect(1, 43051, '\P{^Is_Sc= Sylo}', ""); +Expect(0, 43007, '\p{Is_Sc= Sylo}', ""); +Expect(1, 43007, '\p{^Is_Sc= Sylo}', ""); +Expect(1, 43007, '\P{Is_Sc= Sylo}', ""); +Expect(0, 43007, '\P{^Is_Sc= Sylo}', ""); +Error('\p{Script= :=PHOENICIAN}'); +Error('\P{Script= :=PHOENICIAN}'); +Expect(1, 67865, '\p{Script=phoenician}', ""); +Expect(0, 67865, '\p{^Script=phoenician}', ""); +Expect(0, 67865, '\P{Script=phoenician}', ""); +Expect(1, 67865, '\P{^Script=phoenician}', ""); +Expect(0, 67839, '\p{Script=phoenician}', ""); +Expect(1, 67839, '\p{^Script=phoenician}', ""); +Expect(1, 67839, '\P{Script=phoenician}', ""); +Expect(0, 67839, '\P{^Script=phoenician}', ""); +Expect(1, 67865, '\p{Script= -Phoenician}', ""); +Expect(0, 67865, '\p{^Script= -Phoenician}', ""); +Expect(0, 67865, '\P{Script= -Phoenician}', ""); +Expect(1, 67865, '\P{^Script= -Phoenician}', ""); +Expect(0, 67839, '\p{Script= -Phoenician}', ""); +Expect(1, 67839, '\p{^Script= -Phoenician}', ""); +Expect(1, 67839, '\P{Script= -Phoenician}', ""); +Expect(0, 67839, '\P{^Script= -Phoenician}', ""); +Error('\p{Sc=Phnx/a/}'); +Error('\P{Sc=Phnx/a/}'); +Expect(1, 67865, '\p{Sc=phnx}', ""); +Expect(0, 67865, '\p{^Sc=phnx}', ""); +Expect(0, 67865, '\P{Sc=phnx}', ""); +Expect(1, 67865, '\P{^Sc=phnx}', ""); +Expect(0, 67839, '\p{Sc=phnx}', ""); +Expect(1, 67839, '\p{^Sc=phnx}', ""); +Expect(1, 67839, '\P{Sc=phnx}', ""); +Expect(0, 67839, '\P{^Sc=phnx}', ""); +Expect(1, 67865, '\p{Sc= phnx}', ""); +Expect(0, 67865, '\p{^Sc= phnx}', ""); +Expect(0, 67865, '\P{Sc= phnx}', ""); +Expect(1, 67865, '\P{^Sc= phnx}', ""); +Expect(0, 67839, '\p{Sc= phnx}', ""); +Expect(1, 67839, '\p{^Sc= phnx}', ""); +Expect(1, 67839, '\P{Sc= phnx}', ""); +Expect(0, 67839, '\P{^Sc= phnx}', ""); +Error('\p{Is_Script=-:=phoenician}'); +Error('\P{Is_Script=-:=phoenician}'); +Expect(1, 67865, '\p{Is_Script=phoenician}', ""); +Expect(0, 67865, '\p{^Is_Script=phoenician}', ""); +Expect(0, 67865, '\P{Is_Script=phoenician}', ""); +Expect(1, 67865, '\P{^Is_Script=phoenician}', ""); +Expect(0, 67839, '\p{Is_Script=phoenician}', ""); +Expect(1, 67839, '\p{^Is_Script=phoenician}', ""); +Expect(1, 67839, '\P{Is_Script=phoenician}', ""); +Expect(0, 67839, '\P{^Is_Script=phoenician}', ""); +Expect(1, 67865, '\p{Is_Script= PHOENICIAN}', ""); +Expect(0, 67865, '\p{^Is_Script= PHOENICIAN}', ""); +Expect(0, 67865, '\P{Is_Script= PHOENICIAN}', ""); +Expect(1, 67865, '\P{^Is_Script= PHOENICIAN}', ""); +Expect(0, 67839, '\p{Is_Script= PHOENICIAN}', ""); +Expect(1, 67839, '\p{^Is_Script= PHOENICIAN}', ""); +Expect(1, 67839, '\P{Is_Script= PHOENICIAN}', ""); +Expect(0, 67839, '\P{^Is_Script= PHOENICIAN}', ""); +Error('\p{Is_Sc= Phnx/a/}'); +Error('\P{Is_Sc= Phnx/a/}'); +Expect(1, 67865, '\p{Is_Sc=phnx}', ""); +Expect(0, 67865, '\p{^Is_Sc=phnx}', ""); +Expect(0, 67865, '\P{Is_Sc=phnx}', ""); +Expect(1, 67865, '\P{^Is_Sc=phnx}', ""); +Expect(0, 67839, '\p{Is_Sc=phnx}', ""); +Expect(1, 67839, '\p{^Is_Sc=phnx}', ""); +Expect(1, 67839, '\P{Is_Sc=phnx}', ""); +Expect(0, 67839, '\P{^Is_Sc=phnx}', ""); +Expect(1, 67865, '\p{Is_Sc: _PHNX}', ""); +Expect(0, 67865, '\p{^Is_Sc: _PHNX}', ""); +Expect(0, 67865, '\P{Is_Sc: _PHNX}', ""); +Expect(1, 67865, '\P{^Is_Sc: _PHNX}', ""); +Expect(0, 67839, '\p{Is_Sc: _PHNX}', ""); +Expect(1, 67839, '\p{^Is_Sc: _PHNX}', ""); +Expect(1, 67839, '\P{Is_Sc: _PHNX}', ""); +Expect(0, 67839, '\P{^Is_Sc: _PHNX}', ""); +Error('\p{Script=DEVANAGARI/a/}'); +Error('\P{Script=DEVANAGARI/a/}'); +Expect(1, 2361, '\p{Script: devanagari}', ""); +Expect(0, 2361, '\p{^Script: devanagari}', ""); +Expect(0, 2361, '\P{Script: devanagari}', ""); +Expect(1, 2361, '\P{^Script: devanagari}', ""); +Expect(0, 2304, '\p{Script: devanagari}', ""); +Expect(1, 2304, '\p{^Script: devanagari}', ""); +Expect(1, 2304, '\P{Script: devanagari}', ""); +Expect(0, 2304, '\P{^Script: devanagari}', ""); +Expect(1, 2361, '\p{Script=_Devanagari}', ""); +Expect(0, 2361, '\p{^Script=_Devanagari}', ""); +Expect(0, 2361, '\P{Script=_Devanagari}', ""); +Expect(1, 2361, '\P{^Script=_Devanagari}', ""); +Expect(0, 2304, '\p{Script=_Devanagari}', ""); +Expect(1, 2304, '\p{^Script=_Devanagari}', ""); +Expect(1, 2304, '\P{Script=_Devanagari}', ""); +Expect(0, 2304, '\P{^Script=_Devanagari}', ""); +Error('\p{Sc= DEVA/a/}'); +Error('\P{Sc= DEVA/a/}'); +Expect(1, 2361, '\p{Sc=deva}', ""); +Expect(0, 2361, '\p{^Sc=deva}', ""); +Expect(0, 2361, '\P{Sc=deva}', ""); +Expect(1, 2361, '\P{^Sc=deva}', ""); +Expect(0, 2304, '\p{Sc=deva}', ""); +Expect(1, 2304, '\p{^Sc=deva}', ""); +Expect(1, 2304, '\P{Sc=deva}', ""); +Expect(0, 2304, '\P{^Sc=deva}', ""); +Expect(1, 2361, '\p{Sc=--Deva}', ""); +Expect(0, 2361, '\p{^Sc=--Deva}', ""); +Expect(0, 2361, '\P{Sc=--Deva}', ""); +Expect(1, 2361, '\P{^Sc=--Deva}', ""); +Expect(0, 2304, '\p{Sc=--Deva}', ""); +Expect(1, 2304, '\p{^Sc=--Deva}', ""); +Expect(1, 2304, '\P{Sc=--Deva}', ""); +Expect(0, 2304, '\P{^Sc=--Deva}', ""); +Error('\p{Is_Script: := Devanagari}'); +Error('\P{Is_Script: := Devanagari}'); +Expect(1, 2361, '\p{Is_Script=devanagari}', ""); +Expect(0, 2361, '\p{^Is_Script=devanagari}', ""); +Expect(0, 2361, '\P{Is_Script=devanagari}', ""); +Expect(1, 2361, '\P{^Is_Script=devanagari}', ""); +Expect(0, 2304, '\p{Is_Script=devanagari}', ""); +Expect(1, 2304, '\p{^Is_Script=devanagari}', ""); +Expect(1, 2304, '\P{Is_Script=devanagari}', ""); +Expect(0, 2304, '\P{^Is_Script=devanagari}', ""); +Expect(1, 2361, '\p{Is_Script= Devanagari}', ""); +Expect(0, 2361, '\p{^Is_Script= Devanagari}', ""); +Expect(0, 2361, '\P{Is_Script= Devanagari}', ""); +Expect(1, 2361, '\P{^Is_Script= Devanagari}', ""); +Expect(0, 2304, '\p{Is_Script= Devanagari}', ""); +Expect(1, 2304, '\p{^Is_Script= Devanagari}', ""); +Expect(1, 2304, '\P{Is_Script= Devanagari}', ""); +Expect(0, 2304, '\P{^Is_Script= Devanagari}', ""); +Error('\p{Is_Sc=:= deva}'); +Error('\P{Is_Sc=:= deva}'); +Expect(1, 2361, '\p{Is_Sc=deva}', ""); +Expect(0, 2361, '\p{^Is_Sc=deva}', ""); +Expect(0, 2361, '\P{Is_Sc=deva}', ""); +Expect(1, 2361, '\P{^Is_Sc=deva}', ""); +Expect(0, 2304, '\p{Is_Sc=deva}', ""); +Expect(1, 2304, '\p{^Is_Sc=deva}', ""); +Expect(1, 2304, '\P{Is_Sc=deva}', ""); +Expect(0, 2304, '\P{^Is_Sc=deva}', ""); +Expect(1, 2361, '\p{Is_Sc=_-deva}', ""); +Expect(0, 2361, '\p{^Is_Sc=_-deva}', ""); +Expect(0, 2361, '\P{Is_Sc=_-deva}', ""); +Expect(1, 2361, '\P{^Is_Sc=_-deva}', ""); +Expect(0, 2304, '\p{Is_Sc=_-deva}', ""); +Expect(1, 2304, '\p{^Is_Sc=_-deva}', ""); +Expect(1, 2304, '\P{Is_Sc=_-deva}', ""); +Expect(0, 2304, '\P{^Is_Sc=_-deva}', ""); +Error('\p{Script=_Carian:=}'); +Error('\P{Script=_Carian:=}'); +Expect(1, 66256, '\p{Script=carian}', ""); +Expect(0, 66256, '\p{^Script=carian}', ""); +Expect(0, 66256, '\P{Script=carian}', ""); +Expect(1, 66256, '\P{^Script=carian}', ""); +Expect(0, 66207, '\p{Script=carian}', ""); +Expect(1, 66207, '\p{^Script=carian}', ""); +Expect(1, 66207, '\P{Script=carian}', ""); +Expect(0, 66207, '\P{^Script=carian}', ""); +Expect(1, 66256, '\p{Script=Carian}', ""); +Expect(0, 66256, '\p{^Script=Carian}', ""); +Expect(0, 66256, '\P{Script=Carian}', ""); +Expect(1, 66256, '\P{^Script=Carian}', ""); +Expect(0, 66207, '\p{Script=Carian}', ""); +Expect(1, 66207, '\p{^Script=Carian}', ""); +Expect(1, 66207, '\P{Script=Carian}', ""); +Expect(0, 66207, '\P{^Script=Carian}', ""); +Error('\p{Sc= CARI/a/}'); +Error('\P{Sc= CARI/a/}'); +Expect(1, 66256, '\p{Sc: cari}', ""); +Expect(0, 66256, '\p{^Sc: cari}', ""); +Expect(0, 66256, '\P{Sc: cari}', ""); +Expect(1, 66256, '\P{^Sc: cari}', ""); +Expect(0, 66207, '\p{Sc: cari}', ""); +Expect(1, 66207, '\p{^Sc: cari}', ""); +Expect(1, 66207, '\P{Sc: cari}', ""); +Expect(0, 66207, '\P{^Sc: cari}', ""); +Expect(1, 66256, '\p{Sc=- Cari}', ""); +Expect(0, 66256, '\p{^Sc=- Cari}', ""); +Expect(0, 66256, '\P{Sc=- Cari}', ""); +Expect(1, 66256, '\P{^Sc=- Cari}', ""); +Expect(0, 66207, '\p{Sc=- Cari}', ""); +Expect(1, 66207, '\p{^Sc=- Cari}', ""); +Expect(1, 66207, '\P{Sc=- Cari}', ""); +Expect(0, 66207, '\P{^Sc=- Cari}', ""); +Error('\p{Is_Script=:=Carian}'); +Error('\P{Is_Script=:=Carian}'); +Expect(1, 66256, '\p{Is_Script=carian}', ""); +Expect(0, 66256, '\p{^Is_Script=carian}', ""); +Expect(0, 66256, '\P{Is_Script=carian}', ""); +Expect(1, 66256, '\P{^Is_Script=carian}', ""); +Expect(0, 66207, '\p{Is_Script=carian}', ""); +Expect(1, 66207, '\p{^Is_Script=carian}', ""); +Expect(1, 66207, '\P{Is_Script=carian}', ""); +Expect(0, 66207, '\P{^Is_Script=carian}', ""); +Expect(1, 66256, '\p{Is_Script= CARIAN}', ""); +Expect(0, 66256, '\p{^Is_Script= CARIAN}', ""); +Expect(0, 66256, '\P{Is_Script= CARIAN}', ""); +Expect(1, 66256, '\P{^Is_Script= CARIAN}', ""); +Expect(0, 66207, '\p{Is_Script= CARIAN}', ""); +Expect(1, 66207, '\p{^Is_Script= CARIAN}', ""); +Expect(1, 66207, '\P{Is_Script= CARIAN}', ""); +Expect(0, 66207, '\P{^Is_Script= CARIAN}', ""); +Error('\p{Is_Sc=/a/ _cari}'); +Error('\P{Is_Sc=/a/ _cari}'); +Expect(1, 66256, '\p{Is_Sc: cari}', ""); +Expect(0, 66256, '\p{^Is_Sc: cari}', ""); +Expect(0, 66256, '\P{Is_Sc: cari}', ""); +Expect(1, 66256, '\P{^Is_Sc: cari}', ""); +Expect(0, 66207, '\p{Is_Sc: cari}', ""); +Expect(1, 66207, '\p{^Is_Sc: cari}', ""); +Expect(1, 66207, '\P{Is_Sc: cari}', ""); +Expect(0, 66207, '\P{^Is_Sc: cari}', ""); +Expect(1, 66256, '\p{Is_Sc= cari}', ""); +Expect(0, 66256, '\p{^Is_Sc= cari}', ""); +Expect(0, 66256, '\P{Is_Sc= cari}', ""); +Expect(1, 66256, '\P{^Is_Sc= cari}', ""); +Expect(0, 66207, '\p{Is_Sc= cari}', ""); +Expect(1, 66207, '\p{^Is_Sc= cari}', ""); +Expect(1, 66207, '\P{Is_Sc= cari}', ""); +Expect(0, 66207, '\P{^Is_Sc= cari}', ""); +Error('\p{Script= -buhid:=}'); +Error('\P{Script= -buhid:=}'); +Expect(1, 5971, '\p{Script=buhid}', ""); +Expect(0, 5971, '\p{^Script=buhid}', ""); +Expect(0, 5971, '\P{Script=buhid}', ""); +Expect(1, 5971, '\P{^Script=buhid}', ""); +Expect(0, 5951, '\p{Script=buhid}', ""); +Expect(1, 5951, '\p{^Script=buhid}', ""); +Expect(1, 5951, '\P{Script=buhid}', ""); +Expect(0, 5951, '\P{^Script=buhid}', ""); +Expect(1, 5971, '\p{Script=- Buhid}', ""); +Expect(0, 5971, '\p{^Script=- Buhid}', ""); +Expect(0, 5971, '\P{Script=- Buhid}', ""); +Expect(1, 5971, '\P{^Script=- Buhid}', ""); +Expect(0, 5951, '\p{Script=- Buhid}', ""); +Expect(1, 5951, '\p{^Script=- Buhid}', ""); +Expect(1, 5951, '\P{Script=- Buhid}', ""); +Expect(0, 5951, '\P{^Script=- Buhid}', ""); +Error('\p{Sc: /a/--Buhd}'); +Error('\P{Sc: /a/--Buhd}'); +Expect(1, 5971, '\p{Sc=buhd}', ""); +Expect(0, 5971, '\p{^Sc=buhd}', ""); +Expect(0, 5971, '\P{Sc=buhd}', ""); +Expect(1, 5971, '\P{^Sc=buhd}', ""); +Expect(0, 5951, '\p{Sc=buhd}', ""); +Expect(1, 5951, '\p{^Sc=buhd}', ""); +Expect(1, 5951, '\P{Sc=buhd}', ""); +Expect(0, 5951, '\P{^Sc=buhd}', ""); +Expect(1, 5971, '\p{Sc=--buhd}', ""); +Expect(0, 5971, '\p{^Sc=--buhd}', ""); +Expect(0, 5971, '\P{Sc=--buhd}', ""); +Expect(1, 5971, '\P{^Sc=--buhd}', ""); +Expect(0, 5951, '\p{Sc=--buhd}', ""); +Expect(1, 5951, '\p{^Sc=--buhd}', ""); +Expect(1, 5951, '\P{Sc=--buhd}', ""); +Expect(0, 5951, '\P{^Sc=--buhd}', ""); +Error('\p{Is_Script=__BUHID/a/}'); +Error('\P{Is_Script=__BUHID/a/}'); +Expect(1, 5971, '\p{Is_Script=buhid}', ""); +Expect(0, 5971, '\p{^Is_Script=buhid}', ""); +Expect(0, 5971, '\P{Is_Script=buhid}', ""); +Expect(1, 5971, '\P{^Is_Script=buhid}', ""); +Expect(0, 5951, '\p{Is_Script=buhid}', ""); +Expect(1, 5951, '\p{^Is_Script=buhid}', ""); +Expect(1, 5951, '\P{Is_Script=buhid}', ""); +Expect(0, 5951, '\P{^Is_Script=buhid}', ""); +Expect(1, 5971, '\p{Is_Script= -Buhid}', ""); +Expect(0, 5971, '\p{^Is_Script= -Buhid}', ""); +Expect(0, 5971, '\P{Is_Script= -Buhid}', ""); +Expect(1, 5971, '\P{^Is_Script= -Buhid}', ""); +Expect(0, 5951, '\p{Is_Script= -Buhid}', ""); +Expect(1, 5951, '\p{^Is_Script= -Buhid}', ""); +Expect(1, 5951, '\P{Is_Script= -Buhid}', ""); +Expect(0, 5951, '\P{^Is_Script= -Buhid}', ""); +Error('\p{Is_Sc= /a/BUHD}'); +Error('\P{Is_Sc= /a/BUHD}'); +Expect(1, 5971, '\p{Is_Sc=buhd}', ""); +Expect(0, 5971, '\p{^Is_Sc=buhd}', ""); +Expect(0, 5971, '\P{Is_Sc=buhd}', ""); +Expect(1, 5971, '\P{^Is_Sc=buhd}', ""); +Expect(0, 5951, '\p{Is_Sc=buhd}', ""); +Expect(1, 5951, '\p{^Is_Sc=buhd}', ""); +Expect(1, 5951, '\P{Is_Sc=buhd}', ""); +Expect(0, 5951, '\P{^Is_Sc=buhd}', ""); +Expect(1, 5971, '\p{Is_Sc: Buhd}', ""); +Expect(0, 5971, '\p{^Is_Sc: Buhd}', ""); +Expect(0, 5971, '\P{Is_Sc: Buhd}', ""); +Expect(1, 5971, '\P{^Is_Sc: Buhd}', ""); +Expect(0, 5951, '\p{Is_Sc: Buhd}', ""); +Expect(1, 5951, '\p{^Is_Sc: Buhd}', ""); +Expect(1, 5951, '\P{Is_Sc: Buhd}', ""); +Expect(0, 5951, '\P{^Is_Sc: Buhd}', ""); +Error('\p{Script=_ Limbu:=}'); +Error('\P{Script=_ Limbu:=}'); +Expect(1, 6428, '\p{Script:limbu}', ""); +Expect(0, 6428, '\p{^Script:limbu}', ""); +Expect(0, 6428, '\P{Script:limbu}', ""); +Expect(1, 6428, '\P{^Script:limbu}', ""); +Expect(0, 6399, '\p{Script:limbu}', ""); +Expect(1, 6399, '\p{^Script:limbu}', ""); +Expect(1, 6399, '\P{Script:limbu}', ""); +Expect(0, 6399, '\P{^Script:limbu}', ""); +Expect(1, 6428, '\p{Script= limbu}', ""); +Expect(0, 6428, '\p{^Script= limbu}', ""); +Expect(0, 6428, '\P{Script= limbu}', ""); +Expect(1, 6428, '\P{^Script= limbu}', ""); +Expect(0, 6399, '\p{Script= limbu}', ""); +Expect(1, 6399, '\p{^Script= limbu}', ""); +Expect(1, 6399, '\P{Script= limbu}', ""); +Expect(0, 6399, '\P{^Script= limbu}', ""); +Error('\p{Sc= :=Limb}'); +Error('\P{Sc= :=Limb}'); +Expect(1, 6428, '\p{Sc=limb}', ""); +Expect(0, 6428, '\p{^Sc=limb}', ""); +Expect(0, 6428, '\P{Sc=limb}', ""); +Expect(1, 6428, '\P{^Sc=limb}', ""); +Expect(0, 6399, '\p{Sc=limb}', ""); +Expect(1, 6399, '\p{^Sc=limb}', ""); +Expect(1, 6399, '\P{Sc=limb}', ""); +Expect(0, 6399, '\P{^Sc=limb}', ""); +Expect(1, 6428, '\p{Sc= limb}', ""); +Expect(0, 6428, '\p{^Sc= limb}', ""); +Expect(0, 6428, '\P{Sc= limb}', ""); +Expect(1, 6428, '\P{^Sc= limb}', ""); +Expect(0, 6399, '\p{Sc= limb}', ""); +Expect(1, 6399, '\p{^Sc= limb}', ""); +Expect(1, 6399, '\P{Sc= limb}', ""); +Expect(0, 6399, '\P{^Sc= limb}', ""); +Error('\p{Is_Script=/a/__limbu}'); +Error('\P{Is_Script=/a/__limbu}'); +Expect(1, 6428, '\p{Is_Script=limbu}', ""); +Expect(0, 6428, '\p{^Is_Script=limbu}', ""); +Expect(0, 6428, '\P{Is_Script=limbu}', ""); +Expect(1, 6428, '\P{^Is_Script=limbu}', ""); +Expect(0, 6399, '\p{Is_Script=limbu}', ""); +Expect(1, 6399, '\p{^Is_Script=limbu}', ""); +Expect(1, 6399, '\P{Is_Script=limbu}', ""); +Expect(0, 6399, '\P{^Is_Script=limbu}', ""); +Expect(1, 6428, '\p{Is_Script= Limbu}', ""); +Expect(0, 6428, '\p{^Is_Script= Limbu}', ""); +Expect(0, 6428, '\P{Is_Script= Limbu}', ""); +Expect(1, 6428, '\P{^Is_Script= Limbu}', ""); +Expect(0, 6399, '\p{Is_Script= Limbu}', ""); +Expect(1, 6399, '\p{^Is_Script= Limbu}', ""); +Expect(1, 6399, '\P{Is_Script= Limbu}', ""); +Expect(0, 6399, '\P{^Is_Script= Limbu}', ""); +Error('\p{Is_Sc=/a/LIMB}'); +Error('\P{Is_Sc=/a/LIMB}'); +Expect(1, 6428, '\p{Is_Sc=limb}', ""); +Expect(0, 6428, '\p{^Is_Sc=limb}', ""); +Expect(0, 6428, '\P{Is_Sc=limb}', ""); +Expect(1, 6428, '\P{^Is_Sc=limb}', ""); +Expect(0, 6399, '\p{Is_Sc=limb}', ""); +Expect(1, 6399, '\p{^Is_Sc=limb}', ""); +Expect(1, 6399, '\P{Is_Sc=limb}', ""); +Expect(0, 6399, '\P{^Is_Sc=limb}', ""); +Expect(1, 6428, '\p{Is_Sc=__LIMB}', ""); +Expect(0, 6428, '\p{^Is_Sc=__LIMB}', ""); +Expect(0, 6428, '\P{Is_Sc=__LIMB}', ""); +Expect(1, 6428, '\P{^Is_Sc=__LIMB}', ""); +Expect(0, 6399, '\p{Is_Sc=__LIMB}', ""); +Expect(1, 6399, '\p{^Is_Sc=__LIMB}', ""); +Expect(1, 6399, '\P{Is_Sc=__LIMB}', ""); +Expect(0, 6399, '\P{^Is_Sc=__LIMB}', ""); +Error('\p{Script=_ COMMON:=}'); +Error('\P{Script=_ COMMON:=}'); +Expect(1, 64, '\p{Script=common}', ""); +Expect(0, 64, '\p{^Script=common}', ""); +Expect(0, 64, '\P{Script=common}', ""); +Expect(1, 64, '\P{^Script=common}', ""); +Expect(0, 90, '\p{Script=common}', ""); +Expect(1, 90, '\p{^Script=common}', ""); +Expect(1, 90, '\P{Script=common}', ""); +Expect(0, 90, '\P{^Script=common}', ""); +Expect(1, 64, '\p{Script= Common}', ""); +Expect(0, 64, '\p{^Script= Common}', ""); +Expect(0, 64, '\P{Script= Common}', ""); +Expect(1, 64, '\P{^Script= Common}', ""); +Expect(0, 90, '\p{Script= Common}', ""); +Expect(1, 90, '\p{^Script= Common}', ""); +Expect(1, 90, '\P{Script= Common}', ""); +Expect(0, 90, '\P{^Script= Common}', ""); +Error('\p{Sc=/a/ZYYY}'); +Error('\P{Sc=/a/ZYYY}'); +Expect(1, 64, '\p{Sc=zyyy}', ""); +Expect(0, 64, '\p{^Sc=zyyy}', ""); +Expect(0, 64, '\P{Sc=zyyy}', ""); +Expect(1, 64, '\P{^Sc=zyyy}', ""); +Expect(0, 90, '\p{Sc=zyyy}', ""); +Expect(1, 90, '\p{^Sc=zyyy}', ""); +Expect(1, 90, '\P{Sc=zyyy}', ""); +Expect(0, 90, '\P{^Sc=zyyy}', ""); +Expect(1, 64, '\p{Sc=-Zyyy}', ""); +Expect(0, 64, '\p{^Sc=-Zyyy}', ""); +Expect(0, 64, '\P{Sc=-Zyyy}', ""); +Expect(1, 64, '\P{^Sc=-Zyyy}', ""); +Expect(0, 90, '\p{Sc=-Zyyy}', ""); +Expect(1, 90, '\p{^Sc=-Zyyy}', ""); +Expect(1, 90, '\P{Sc=-Zyyy}', ""); +Expect(0, 90, '\P{^Sc=-Zyyy}', ""); +Error('\p{Is_Script=:=--common}'); +Error('\P{Is_Script=:=--common}'); +Expect(1, 64, '\p{Is_Script=common}', ""); +Expect(0, 64, '\p{^Is_Script=common}', ""); +Expect(0, 64, '\P{Is_Script=common}', ""); +Expect(1, 64, '\P{^Is_Script=common}', ""); +Expect(0, 90, '\p{Is_Script=common}', ""); +Expect(1, 90, '\p{^Is_Script=common}', ""); +Expect(1, 90, '\P{Is_Script=common}', ""); +Expect(0, 90, '\P{^Is_Script=common}', ""); +Expect(1, 64, '\p{Is_Script= _common}', ""); +Expect(0, 64, '\p{^Is_Script= _common}', ""); +Expect(0, 64, '\P{Is_Script= _common}', ""); +Expect(1, 64, '\P{^Is_Script= _common}', ""); +Expect(0, 90, '\p{Is_Script= _common}', ""); +Expect(1, 90, '\p{^Is_Script= _common}', ""); +Expect(1, 90, '\P{Is_Script= _common}', ""); +Expect(0, 90, '\P{^Is_Script= _common}', ""); +Error('\p{Is_Sc=-zyyy:=}'); +Error('\P{Is_Sc=-zyyy:=}'); +Expect(1, 64, '\p{Is_Sc=zyyy}', ""); +Expect(0, 64, '\p{^Is_Sc=zyyy}', ""); +Expect(0, 64, '\P{Is_Sc=zyyy}', ""); +Expect(1, 64, '\P{^Is_Sc=zyyy}', ""); +Expect(0, 90, '\p{Is_Sc=zyyy}', ""); +Expect(1, 90, '\p{^Is_Sc=zyyy}', ""); +Expect(1, 90, '\P{Is_Sc=zyyy}', ""); +Expect(0, 90, '\P{^Is_Sc=zyyy}', ""); +Expect(1, 64, '\p{Is_Sc= zyyy}', ""); +Expect(0, 64, '\p{^Is_Sc= zyyy}', ""); +Expect(0, 64, '\P{Is_Sc= zyyy}', ""); +Expect(1, 64, '\P{^Is_Sc= zyyy}', ""); +Expect(0, 90, '\p{Is_Sc= zyyy}', ""); +Expect(1, 90, '\p{^Is_Sc= zyyy}', ""); +Expect(1, 90, '\P{Is_Sc= zyyy}', ""); +Expect(0, 90, '\P{^Is_Sc= zyyy}', ""); +Error('\p{Script= Latin/a/}'); +Error('\P{Script= Latin/a/}'); +Expect(1, 90, '\p{Script=latin}', ""); +Expect(0, 90, '\p{^Script=latin}', ""); +Expect(0, 90, '\P{Script=latin}', ""); +Expect(1, 90, '\P{^Script=latin}', ""); +Expect(0, 64, '\p{Script=latin}', ""); +Expect(1, 64, '\p{^Script=latin}', ""); +Expect(1, 64, '\P{Script=latin}', ""); +Expect(0, 64, '\P{^Script=latin}', ""); +Expect(1, 90, '\p{Script=_Latin}', ""); +Expect(0, 90, '\p{^Script=_Latin}', ""); +Expect(0, 90, '\P{Script=_Latin}', ""); +Expect(1, 90, '\P{^Script=_Latin}', ""); +Expect(0, 64, '\p{Script=_Latin}', ""); +Expect(1, 64, '\p{^Script=_Latin}', ""); +Expect(1, 64, '\P{Script=_Latin}', ""); +Expect(0, 64, '\P{^Script=_Latin}', ""); +Error('\p{Sc: _/a/LATN}'); +Error('\P{Sc: _/a/LATN}'); +Expect(1, 90, '\p{Sc=latn}', ""); +Expect(0, 90, '\p{^Sc=latn}', ""); +Expect(0, 90, '\P{Sc=latn}', ""); +Expect(1, 90, '\P{^Sc=latn}', ""); +Expect(0, 64, '\p{Sc=latn}', ""); +Expect(1, 64, '\p{^Sc=latn}', ""); +Expect(1, 64, '\P{Sc=latn}', ""); +Expect(0, 64, '\P{^Sc=latn}', ""); +Expect(1, 90, '\p{Sc=- Latn}', ""); +Expect(0, 90, '\p{^Sc=- Latn}', ""); +Expect(0, 90, '\P{Sc=- Latn}', ""); +Expect(1, 90, '\P{^Sc=- Latn}', ""); +Expect(0, 64, '\p{Sc=- Latn}', ""); +Expect(1, 64, '\p{^Sc=- Latn}', ""); +Expect(1, 64, '\P{Sc=- Latn}', ""); +Expect(0, 64, '\P{^Sc=- Latn}', ""); +Error('\p{Is_Script=- LATIN:=}'); +Error('\P{Is_Script=- LATIN:=}'); +Expect(1, 90, '\p{Is_Script=latin}', ""); +Expect(0, 90, '\p{^Is_Script=latin}', ""); +Expect(0, 90, '\P{Is_Script=latin}', ""); +Expect(1, 90, '\P{^Is_Script=latin}', ""); +Expect(0, 64, '\p{Is_Script=latin}', ""); +Expect(1, 64, '\p{^Is_Script=latin}', ""); +Expect(1, 64, '\P{Is_Script=latin}', ""); +Expect(0, 64, '\P{^Is_Script=latin}', ""); +Expect(1, 90, '\p{Is_Script= Latin}', ""); +Expect(0, 90, '\p{^Is_Script= Latin}', ""); +Expect(0, 90, '\P{Is_Script= Latin}', ""); +Expect(1, 90, '\P{^Is_Script= Latin}', ""); +Expect(0, 64, '\p{Is_Script= Latin}', ""); +Expect(1, 64, '\p{^Is_Script= Latin}', ""); +Expect(1, 64, '\P{Is_Script= Latin}', ""); +Expect(0, 64, '\P{^Is_Script= Latin}', ""); +Error('\p{Is_Sc=-Latn/a/}'); +Error('\P{Is_Sc=-Latn/a/}'); +Expect(1, 90, '\p{Is_Sc=latn}', ""); +Expect(0, 90, '\p{^Is_Sc=latn}', ""); +Expect(0, 90, '\P{Is_Sc=latn}', ""); +Expect(1, 90, '\P{^Is_Sc=latn}', ""); +Expect(0, 64, '\p{Is_Sc=latn}', ""); +Expect(1, 64, '\p{^Is_Sc=latn}', ""); +Expect(1, 64, '\P{Is_Sc=latn}', ""); +Expect(0, 64, '\P{^Is_Sc=latn}', ""); +Expect(1, 90, '\p{Is_Sc=--Latn}', ""); +Expect(0, 90, '\p{^Is_Sc=--Latn}', ""); +Expect(0, 90, '\P{Is_Sc=--Latn}', ""); +Expect(1, 90, '\P{^Is_Sc=--Latn}', ""); +Expect(0, 64, '\p{Is_Sc=--Latn}', ""); +Expect(1, 64, '\p{^Is_Sc=--Latn}', ""); +Expect(1, 64, '\P{Is_Sc=--Latn}', ""); +Expect(0, 64, '\P{^Is_Sc=--Latn}', ""); +Error('\p{Script=/a/ ethiopic}'); +Error('\P{Script=/a/ ethiopic}'); +Expect(1, 4680, '\p{Script=ethiopic}', ""); +Expect(0, 4680, '\p{^Script=ethiopic}', ""); +Expect(0, 4680, '\P{Script=ethiopic}', ""); +Expect(1, 4680, '\P{^Script=ethiopic}', ""); +Expect(0, 4607, '\p{Script=ethiopic}', ""); +Expect(1, 4607, '\p{^Script=ethiopic}', ""); +Expect(1, 4607, '\P{Script=ethiopic}', ""); +Expect(0, 4607, '\P{^Script=ethiopic}', ""); +Expect(1, 4680, '\p{Script= Ethiopic}', ""); +Expect(0, 4680, '\p{^Script= Ethiopic}', ""); +Expect(0, 4680, '\P{Script= Ethiopic}', ""); +Expect(1, 4680, '\P{^Script= Ethiopic}', ""); +Expect(0, 4607, '\p{Script= Ethiopic}', ""); +Expect(1, 4607, '\p{^Script= Ethiopic}', ""); +Expect(1, 4607, '\P{Script= Ethiopic}', ""); +Expect(0, 4607, '\P{^Script= Ethiopic}', ""); +Error('\p{Sc=/a/ -ETHI}'); +Error('\P{Sc=/a/ -ETHI}'); +Expect(1, 4680, '\p{Sc=ethi}', ""); +Expect(0, 4680, '\p{^Sc=ethi}', ""); +Expect(0, 4680, '\P{Sc=ethi}', ""); +Expect(1, 4680, '\P{^Sc=ethi}', ""); +Expect(0, 4607, '\p{Sc=ethi}', ""); +Expect(1, 4607, '\p{^Sc=ethi}', ""); +Expect(1, 4607, '\P{Sc=ethi}', ""); +Expect(0, 4607, '\P{^Sc=ethi}', ""); +Expect(1, 4680, '\p{Sc= Ethi}', ""); +Expect(0, 4680, '\p{^Sc= Ethi}', ""); +Expect(0, 4680, '\P{Sc= Ethi}', ""); +Expect(1, 4680, '\P{^Sc= Ethi}', ""); +Expect(0, 4607, '\p{Sc= Ethi}', ""); +Expect(1, 4607, '\p{^Sc= Ethi}', ""); +Expect(1, 4607, '\P{Sc= Ethi}', ""); +Expect(0, 4607, '\P{^Sc= Ethi}', ""); +Error('\p{Is_Script= /a/ETHIOPIC}'); +Error('\P{Is_Script= /a/ETHIOPIC}'); +Expect(1, 4680, '\p{Is_Script=ethiopic}', ""); +Expect(0, 4680, '\p{^Is_Script=ethiopic}', ""); +Expect(0, 4680, '\P{Is_Script=ethiopic}', ""); +Expect(1, 4680, '\P{^Is_Script=ethiopic}', ""); +Expect(0, 4607, '\p{Is_Script=ethiopic}', ""); +Expect(1, 4607, '\p{^Is_Script=ethiopic}', ""); +Expect(1, 4607, '\P{Is_Script=ethiopic}', ""); +Expect(0, 4607, '\P{^Is_Script=ethiopic}', ""); +Expect(1, 4680, '\p{Is_Script=--Ethiopic}', ""); +Expect(0, 4680, '\p{^Is_Script=--Ethiopic}', ""); +Expect(0, 4680, '\P{Is_Script=--Ethiopic}', ""); +Expect(1, 4680, '\P{^Is_Script=--Ethiopic}', ""); +Expect(0, 4607, '\p{Is_Script=--Ethiopic}', ""); +Expect(1, 4607, '\p{^Is_Script=--Ethiopic}', ""); +Expect(1, 4607, '\P{Is_Script=--Ethiopic}', ""); +Expect(0, 4607, '\P{^Is_Script=--Ethiopic}', ""); +Error('\p{Is_Sc= Ethi/a/}'); +Error('\P{Is_Sc= Ethi/a/}'); +Expect(1, 4680, '\p{Is_Sc=ethi}', ""); +Expect(0, 4680, '\p{^Is_Sc=ethi}', ""); +Expect(0, 4680, '\P{Is_Sc=ethi}', ""); +Expect(1, 4680, '\P{^Is_Sc=ethi}', ""); +Expect(0, 4607, '\p{Is_Sc=ethi}', ""); +Expect(1, 4607, '\p{^Is_Sc=ethi}', ""); +Expect(1, 4607, '\P{Is_Sc=ethi}', ""); +Expect(0, 4607, '\P{^Is_Sc=ethi}', ""); +Expect(1, 4680, '\p{Is_Sc=- ETHI}', ""); +Expect(0, 4680, '\p{^Is_Sc=- ETHI}', ""); +Expect(0, 4680, '\P{Is_Sc=- ETHI}', ""); +Expect(1, 4680, '\P{^Is_Sc=- ETHI}', ""); +Expect(0, 4607, '\p{Is_Sc=- ETHI}', ""); +Expect(1, 4607, '\p{^Is_Sc=- ETHI}', ""); +Expect(1, 4607, '\P{Is_Sc=- ETHI}', ""); +Expect(0, 4607, '\P{^Is_Sc=- ETHI}', ""); +Error('\p{Script= Hebrew/a/}'); +Error('\P{Script= Hebrew/a/}'); +Expect(1, 1479, '\p{Script=hebrew}', ""); +Expect(0, 1479, '\p{^Script=hebrew}', ""); +Expect(0, 1479, '\P{Script=hebrew}', ""); +Expect(1, 1479, '\P{^Script=hebrew}', ""); +Expect(0, 1424, '\p{Script=hebrew}', ""); +Expect(1, 1424, '\p{^Script=hebrew}', ""); +Expect(1, 1424, '\P{Script=hebrew}', ""); +Expect(0, 1424, '\P{^Script=hebrew}', ""); +Expect(1, 1479, '\p{Script=_ Hebrew}', ""); +Expect(0, 1479, '\p{^Script=_ Hebrew}', ""); +Expect(0, 1479, '\P{Script=_ Hebrew}', ""); +Expect(1, 1479, '\P{^Script=_ Hebrew}', ""); +Expect(0, 1424, '\p{Script=_ Hebrew}', ""); +Expect(1, 1424, '\p{^Script=_ Hebrew}', ""); +Expect(1, 1424, '\P{Script=_ Hebrew}', ""); +Expect(0, 1424, '\P{^Script=_ Hebrew}', ""); +Error('\p{Sc=/a/- Hebr}'); +Error('\P{Sc=/a/- Hebr}'); +Expect(1, 1479, '\p{Sc: hebr}', ""); +Expect(0, 1479, '\p{^Sc: hebr}', ""); +Expect(0, 1479, '\P{Sc: hebr}', ""); +Expect(1, 1479, '\P{^Sc: hebr}', ""); +Expect(0, 1424, '\p{Sc: hebr}', ""); +Expect(1, 1424, '\p{^Sc: hebr}', ""); +Expect(1, 1424, '\P{Sc: hebr}', ""); +Expect(0, 1424, '\P{^Sc: hebr}', ""); +Expect(1, 1479, '\p{Sc= HEBR}', ""); +Expect(0, 1479, '\p{^Sc= HEBR}', ""); +Expect(0, 1479, '\P{Sc= HEBR}', ""); +Expect(1, 1479, '\P{^Sc= HEBR}', ""); +Expect(0, 1424, '\p{Sc= HEBR}', ""); +Expect(1, 1424, '\p{^Sc= HEBR}', ""); +Expect(1, 1424, '\P{Sc= HEBR}', ""); +Expect(0, 1424, '\P{^Sc= HEBR}', ""); +Error('\p{Is_Script=_/a/HEBREW}'); +Error('\P{Is_Script=_/a/HEBREW}'); +Expect(1, 1479, '\p{Is_Script=hebrew}', ""); +Expect(0, 1479, '\p{^Is_Script=hebrew}', ""); +Expect(0, 1479, '\P{Is_Script=hebrew}', ""); +Expect(1, 1479, '\P{^Is_Script=hebrew}', ""); +Expect(0, 1424, '\p{Is_Script=hebrew}', ""); +Expect(1, 1424, '\p{^Is_Script=hebrew}', ""); +Expect(1, 1424, '\P{Is_Script=hebrew}', ""); +Expect(0, 1424, '\P{^Is_Script=hebrew}', ""); +Expect(1, 1479, '\p{Is_Script=--Hebrew}', ""); +Expect(0, 1479, '\p{^Is_Script=--Hebrew}', ""); +Expect(0, 1479, '\P{Is_Script=--Hebrew}', ""); +Expect(1, 1479, '\P{^Is_Script=--Hebrew}', ""); +Expect(0, 1424, '\p{Is_Script=--Hebrew}', ""); +Expect(1, 1424, '\p{^Is_Script=--Hebrew}', ""); +Expect(1, 1424, '\P{Is_Script=--Hebrew}', ""); +Expect(0, 1424, '\P{^Is_Script=--Hebrew}', ""); +Error('\p{Is_Sc=/a/ Hebr}'); +Error('\P{Is_Sc=/a/ Hebr}'); +Expect(1, 1479, '\p{Is_Sc=hebr}', ""); +Expect(0, 1479, '\p{^Is_Sc=hebr}', ""); +Expect(0, 1479, '\P{Is_Sc=hebr}', ""); +Expect(1, 1479, '\P{^Is_Sc=hebr}', ""); +Expect(0, 1424, '\p{Is_Sc=hebr}', ""); +Expect(1, 1424, '\p{^Is_Sc=hebr}', ""); +Expect(1, 1424, '\P{Is_Sc=hebr}', ""); +Expect(0, 1424, '\P{^Is_Sc=hebr}', ""); +Expect(1, 1479, '\p{Is_Sc= hebr}', ""); +Expect(0, 1479, '\p{^Is_Sc= hebr}', ""); +Expect(0, 1479, '\P{Is_Sc= hebr}', ""); +Expect(1, 1479, '\P{^Is_Sc= hebr}', ""); +Expect(0, 1424, '\p{Is_Sc= hebr}', ""); +Expect(1, 1424, '\p{^Is_Sc= hebr}', ""); +Expect(1, 1424, '\P{Is_Sc= hebr}', ""); +Expect(0, 1424, '\P{^Is_Sc= hebr}', ""); +Error('\p{Script=:=- BUGINESE}'); +Error('\P{Script=:=- BUGINESE}'); +Expect(1, 6683, '\p{Script=buginese}', ""); +Expect(0, 6683, '\p{^Script=buginese}', ""); +Expect(0, 6683, '\P{Script=buginese}', ""); +Expect(1, 6683, '\P{^Script=buginese}', ""); +Expect(0, 6655, '\p{Script=buginese}', ""); +Expect(1, 6655, '\p{^Script=buginese}', ""); +Expect(1, 6655, '\P{Script=buginese}', ""); +Expect(0, 6655, '\P{^Script=buginese}', ""); +Expect(1, 6683, '\p{Script= Buginese}', ""); +Expect(0, 6683, '\p{^Script= Buginese}', ""); +Expect(0, 6683, '\P{Script= Buginese}', ""); +Expect(1, 6683, '\P{^Script= Buginese}', ""); +Expect(0, 6655, '\p{Script= Buginese}', ""); +Expect(1, 6655, '\p{^Script= Buginese}', ""); +Expect(1, 6655, '\P{Script= Buginese}', ""); +Expect(0, 6655, '\P{^Script= Buginese}', ""); +Error('\p{Sc= Bugi/a/}'); +Error('\P{Sc= Bugi/a/}'); +Expect(1, 6683, '\p{Sc=bugi}', ""); +Expect(0, 6683, '\p{^Sc=bugi}', ""); +Expect(0, 6683, '\P{Sc=bugi}', ""); +Expect(1, 6683, '\P{^Sc=bugi}', ""); +Expect(0, 6655, '\p{Sc=bugi}', ""); +Expect(1, 6655, '\p{^Sc=bugi}', ""); +Expect(1, 6655, '\P{Sc=bugi}', ""); +Expect(0, 6655, '\P{^Sc=bugi}', ""); +Expect(1, 6683, '\p{Sc=Bugi}', ""); +Expect(0, 6683, '\p{^Sc=Bugi}', ""); +Expect(0, 6683, '\P{Sc=Bugi}', ""); +Expect(1, 6683, '\P{^Sc=Bugi}', ""); +Expect(0, 6655, '\p{Sc=Bugi}', ""); +Expect(1, 6655, '\p{^Sc=Bugi}', ""); +Expect(1, 6655, '\P{Sc=Bugi}', ""); +Expect(0, 6655, '\P{^Sc=Bugi}', ""); +Error('\p{Is_Script= /a/Buginese}'); +Error('\P{Is_Script= /a/Buginese}'); +Expect(1, 6683, '\p{Is_Script=buginese}', ""); +Expect(0, 6683, '\p{^Is_Script=buginese}', ""); +Expect(0, 6683, '\P{Is_Script=buginese}', ""); +Expect(1, 6683, '\P{^Is_Script=buginese}', ""); +Expect(0, 6655, '\p{Is_Script=buginese}', ""); +Expect(1, 6655, '\p{^Is_Script=buginese}', ""); +Expect(1, 6655, '\P{Is_Script=buginese}', ""); +Expect(0, 6655, '\P{^Is_Script=buginese}', ""); +Expect(1, 6683, '\p{Is_Script= -Buginese}', ""); +Expect(0, 6683, '\p{^Is_Script= -Buginese}', ""); +Expect(0, 6683, '\P{Is_Script= -Buginese}', ""); +Expect(1, 6683, '\P{^Is_Script= -Buginese}', ""); +Expect(0, 6655, '\p{Is_Script= -Buginese}', ""); +Expect(1, 6655, '\p{^Is_Script= -Buginese}', ""); +Expect(1, 6655, '\P{Is_Script= -Buginese}', ""); +Expect(0, 6655, '\P{^Is_Script= -Buginese}', ""); +Error('\p{Is_Sc=:= BUGI}'); +Error('\P{Is_Sc=:= BUGI}'); +Expect(1, 6683, '\p{Is_Sc=bugi}', ""); +Expect(0, 6683, '\p{^Is_Sc=bugi}', ""); +Expect(0, 6683, '\P{Is_Sc=bugi}', ""); +Expect(1, 6683, '\P{^Is_Sc=bugi}', ""); +Expect(0, 6655, '\p{Is_Sc=bugi}', ""); +Expect(1, 6655, '\p{^Is_Sc=bugi}', ""); +Expect(1, 6655, '\P{Is_Sc=bugi}', ""); +Expect(0, 6655, '\P{^Is_Sc=bugi}', ""); +Expect(1, 6683, '\p{Is_Sc=_ bugi}', ""); +Expect(0, 6683, '\p{^Is_Sc=_ bugi}', ""); +Expect(0, 6683, '\P{Is_Sc=_ bugi}', ""); +Expect(1, 6683, '\P{^Is_Sc=_ bugi}', ""); +Expect(0, 6655, '\p{Is_Sc=_ bugi}', ""); +Expect(1, 6655, '\p{^Is_Sc=_ bugi}', ""); +Expect(1, 6655, '\P{Is_Sc=_ bugi}', ""); +Expect(0, 6655, '\P{^Is_Sc=_ bugi}', ""); +Error('\p{Script=_-Gurmukhi/a/}'); +Error('\P{Script=_-Gurmukhi/a/}'); +Expect(1, 2563, '\p{Script=gurmukhi}', ""); +Expect(0, 2563, '\p{^Script=gurmukhi}', ""); +Expect(0, 2563, '\P{Script=gurmukhi}', ""); +Expect(1, 2563, '\P{^Script=gurmukhi}', ""); +Expect(0, 2560, '\p{Script=gurmukhi}', ""); +Expect(1, 2560, '\p{^Script=gurmukhi}', ""); +Expect(1, 2560, '\P{Script=gurmukhi}', ""); +Expect(0, 2560, '\P{^Script=gurmukhi}', ""); +Expect(1, 2563, '\p{Script=- Gurmukhi}', ""); +Expect(0, 2563, '\p{^Script=- Gurmukhi}', ""); +Expect(0, 2563, '\P{Script=- Gurmukhi}', ""); +Expect(1, 2563, '\P{^Script=- Gurmukhi}', ""); +Expect(0, 2560, '\p{Script=- Gurmukhi}', ""); +Expect(1, 2560, '\p{^Script=- Gurmukhi}', ""); +Expect(1, 2560, '\P{Script=- Gurmukhi}', ""); +Expect(0, 2560, '\P{^Script=- Gurmukhi}', ""); +Error('\p{Sc: guru:=}'); +Error('\P{Sc: guru:=}'); +Expect(1, 2563, '\p{Sc=guru}', ""); +Expect(0, 2563, '\p{^Sc=guru}', ""); +Expect(0, 2563, '\P{Sc=guru}', ""); +Expect(1, 2563, '\P{^Sc=guru}', ""); +Expect(0, 2560, '\p{Sc=guru}', ""); +Expect(1, 2560, '\p{^Sc=guru}', ""); +Expect(1, 2560, '\P{Sc=guru}', ""); +Expect(0, 2560, '\P{^Sc=guru}', ""); +Expect(1, 2563, '\p{Sc= guru}', ""); +Expect(0, 2563, '\p{^Sc= guru}', ""); +Expect(0, 2563, '\P{Sc= guru}', ""); +Expect(1, 2563, '\P{^Sc= guru}', ""); +Expect(0, 2560, '\p{Sc= guru}', ""); +Expect(1, 2560, '\p{^Sc= guru}', ""); +Expect(1, 2560, '\P{Sc= guru}', ""); +Expect(0, 2560, '\P{^Sc= guru}', ""); +Error('\p{Is_Script=:=_ Gurmukhi}'); +Error('\P{Is_Script=:=_ Gurmukhi}'); +Expect(1, 2563, '\p{Is_Script=gurmukhi}', ""); +Expect(0, 2563, '\p{^Is_Script=gurmukhi}', ""); +Expect(0, 2563, '\P{Is_Script=gurmukhi}', ""); +Expect(1, 2563, '\P{^Is_Script=gurmukhi}', ""); +Expect(0, 2560, '\p{Is_Script=gurmukhi}', ""); +Expect(1, 2560, '\p{^Is_Script=gurmukhi}', ""); +Expect(1, 2560, '\P{Is_Script=gurmukhi}', ""); +Expect(0, 2560, '\P{^Is_Script=gurmukhi}', ""); +Expect(1, 2563, '\p{Is_Script= -gurmukhi}', ""); +Expect(0, 2563, '\p{^Is_Script= -gurmukhi}', ""); +Expect(0, 2563, '\P{Is_Script= -gurmukhi}', ""); +Expect(1, 2563, '\P{^Is_Script= -gurmukhi}', ""); +Expect(0, 2560, '\p{Is_Script= -gurmukhi}', ""); +Expect(1, 2560, '\p{^Is_Script= -gurmukhi}', ""); +Expect(1, 2560, '\P{Is_Script= -gurmukhi}', ""); +Expect(0, 2560, '\P{^Is_Script= -gurmukhi}', ""); +Error('\p{Is_Sc=guru/a/}'); +Error('\P{Is_Sc=guru/a/}'); +Expect(1, 2563, '\p{Is_Sc: guru}', ""); +Expect(0, 2563, '\p{^Is_Sc: guru}', ""); +Expect(0, 2563, '\P{Is_Sc: guru}', ""); +Expect(1, 2563, '\P{^Is_Sc: guru}', ""); +Expect(0, 2560, '\p{Is_Sc: guru}', ""); +Expect(1, 2560, '\p{^Is_Sc: guru}', ""); +Expect(1, 2560, '\P{Is_Sc: guru}', ""); +Expect(0, 2560, '\P{^Is_Sc: guru}', ""); +Expect(1, 2563, '\p{Is_Sc=_-Guru}', ""); +Expect(0, 2563, '\p{^Is_Sc=_-Guru}', ""); +Expect(0, 2563, '\P{Is_Sc=_-Guru}', ""); +Expect(1, 2563, '\P{^Is_Sc=_-Guru}', ""); +Expect(0, 2560, '\p{Is_Sc=_-Guru}', ""); +Expect(1, 2560, '\p{^Is_Sc=_-Guru}', ""); +Expect(1, 2560, '\P{Is_Sc=_-Guru}', ""); +Expect(0, 2560, '\P{^Is_Sc=_-Guru}', ""); +Error('\p{Script=_CYPRIOT:=}'); +Error('\P{Script=_CYPRIOT:=}'); +Expect(1, 67589, '\p{Script=cypriot}', ""); +Expect(0, 67589, '\p{^Script=cypriot}', ""); +Expect(0, 67589, '\P{Script=cypriot}', ""); +Expect(1, 67589, '\P{^Script=cypriot}', ""); +Expect(0, 67583, '\p{Script=cypriot}', ""); +Expect(1, 67583, '\p{^Script=cypriot}', ""); +Expect(1, 67583, '\P{Script=cypriot}', ""); +Expect(0, 67583, '\P{^Script=cypriot}', ""); +Expect(1, 67589, '\p{Script= cypriot}', ""); +Expect(0, 67589, '\p{^Script= cypriot}', ""); +Expect(0, 67589, '\P{Script= cypriot}', ""); +Expect(1, 67589, '\P{^Script= cypriot}', ""); +Expect(0, 67583, '\p{Script= cypriot}', ""); +Expect(1, 67583, '\p{^Script= cypriot}', ""); +Expect(1, 67583, '\P{Script= cypriot}', ""); +Expect(0, 67583, '\P{^Script= cypriot}', ""); +Error('\p{Sc=_/a/Cprt}'); +Error('\P{Sc=_/a/Cprt}'); +Expect(1, 67589, '\p{Sc=cprt}', ""); +Expect(0, 67589, '\p{^Sc=cprt}', ""); +Expect(0, 67589, '\P{Sc=cprt}', ""); +Expect(1, 67589, '\P{^Sc=cprt}', ""); +Expect(0, 67583, '\p{Sc=cprt}', ""); +Expect(1, 67583, '\p{^Sc=cprt}', ""); +Expect(1, 67583, '\P{Sc=cprt}', ""); +Expect(0, 67583, '\P{^Sc=cprt}', ""); +Expect(1, 67589, '\p{Sc= cprt}', ""); +Expect(0, 67589, '\p{^Sc= cprt}', ""); +Expect(0, 67589, '\P{Sc= cprt}', ""); +Expect(1, 67589, '\P{^Sc= cprt}', ""); +Expect(0, 67583, '\p{Sc= cprt}', ""); +Expect(1, 67583, '\p{^Sc= cprt}', ""); +Expect(1, 67583, '\P{Sc= cprt}', ""); +Expect(0, 67583, '\P{^Sc= cprt}', ""); +Error('\p{Is_Script=_/a/cypriot}'); +Error('\P{Is_Script=_/a/cypriot}'); +Expect(1, 67589, '\p{Is_Script=cypriot}', ""); +Expect(0, 67589, '\p{^Is_Script=cypriot}', ""); +Expect(0, 67589, '\P{Is_Script=cypriot}', ""); +Expect(1, 67589, '\P{^Is_Script=cypriot}', ""); +Expect(0, 67583, '\p{Is_Script=cypriot}', ""); +Expect(1, 67583, '\p{^Is_Script=cypriot}', ""); +Expect(1, 67583, '\P{Is_Script=cypriot}', ""); +Expect(0, 67583, '\P{^Is_Script=cypriot}', ""); +Expect(1, 67589, '\p{Is_Script= Cypriot}', ""); +Expect(0, 67589, '\p{^Is_Script= Cypriot}', ""); +Expect(0, 67589, '\P{Is_Script= Cypriot}', ""); +Expect(1, 67589, '\P{^Is_Script= Cypriot}', ""); +Expect(0, 67583, '\p{Is_Script= Cypriot}', ""); +Expect(1, 67583, '\p{^Is_Script= Cypriot}', ""); +Expect(1, 67583, '\P{Is_Script= Cypriot}', ""); +Expect(0, 67583, '\P{^Is_Script= Cypriot}', ""); +Error('\p{Is_Sc= :=Cprt}'); +Error('\P{Is_Sc= :=Cprt}'); +Expect(1, 67589, '\p{Is_Sc=cprt}', ""); +Expect(0, 67589, '\p{^Is_Sc=cprt}', ""); +Expect(0, 67589, '\P{Is_Sc=cprt}', ""); +Expect(1, 67589, '\P{^Is_Sc=cprt}', ""); +Expect(0, 67583, '\p{Is_Sc=cprt}', ""); +Expect(1, 67583, '\p{^Is_Sc=cprt}', ""); +Expect(1, 67583, '\P{Is_Sc=cprt}', ""); +Expect(0, 67583, '\P{^Is_Sc=cprt}', ""); +Expect(1, 67589, '\p{Is_Sc=-_CPRT}', ""); +Expect(0, 67589, '\p{^Is_Sc=-_CPRT}', ""); +Expect(0, 67589, '\P{Is_Sc=-_CPRT}', ""); +Expect(1, 67589, '\P{^Is_Sc=-_CPRT}', ""); +Expect(0, 67583, '\p{Is_Sc=-_CPRT}', ""); +Expect(1, 67583, '\p{^Is_Sc=-_CPRT}', ""); +Expect(1, 67583, '\P{Is_Sc=-_CPRT}', ""); +Expect(0, 67583, '\P{^Is_Sc=-_CPRT}', ""); +Error('\p{Script=_ hangul/a/}'); +Error('\P{Script=_ hangul/a/}'); +Expect(1, 4441, '\p{Script=hangul}', ""); +Expect(0, 4441, '\p{^Script=hangul}', ""); +Expect(0, 4441, '\P{Script=hangul}', ""); +Expect(1, 4441, '\P{^Script=hangul}', ""); +Expect(0, 4351, '\p{Script=hangul}', ""); +Expect(1, 4351, '\p{^Script=hangul}', ""); +Expect(1, 4351, '\P{Script=hangul}', ""); +Expect(0, 4351, '\P{^Script=hangul}', ""); +Expect(1, 4441, '\p{Script: _Hangul}', ""); +Expect(0, 4441, '\p{^Script: _Hangul}', ""); +Expect(0, 4441, '\P{Script: _Hangul}', ""); +Expect(1, 4441, '\P{^Script: _Hangul}', ""); +Expect(0, 4351, '\p{Script: _Hangul}', ""); +Expect(1, 4351, '\p{^Script: _Hangul}', ""); +Expect(1, 4351, '\P{Script: _Hangul}', ""); +Expect(0, 4351, '\P{^Script: _Hangul}', ""); +Error('\p{Sc=:= hang}'); +Error('\P{Sc=:= hang}'); +Expect(1, 4441, '\p{Sc=hang}', ""); +Expect(0, 4441, '\p{^Sc=hang}', ""); +Expect(0, 4441, '\P{Sc=hang}', ""); +Expect(1, 4441, '\P{^Sc=hang}', ""); +Expect(0, 4351, '\p{Sc=hang}', ""); +Expect(1, 4351, '\p{^Sc=hang}', ""); +Expect(1, 4351, '\P{Sc=hang}', ""); +Expect(0, 4351, '\P{^Sc=hang}', ""); +Expect(1, 4441, '\p{Sc= hang}', ""); +Expect(0, 4441, '\p{^Sc= hang}', ""); +Expect(0, 4441, '\P{Sc= hang}', ""); +Expect(1, 4441, '\P{^Sc= hang}', ""); +Expect(0, 4351, '\p{Sc= hang}', ""); +Expect(1, 4351, '\p{^Sc= hang}', ""); +Expect(1, 4351, '\P{Sc= hang}', ""); +Expect(0, 4351, '\P{^Sc= hang}', ""); +Error('\p{Is_Script=/a/ hangul}'); +Error('\P{Is_Script=/a/ hangul}'); +Expect(1, 4441, '\p{Is_Script=hangul}', ""); +Expect(0, 4441, '\p{^Is_Script=hangul}', ""); +Expect(0, 4441, '\P{Is_Script=hangul}', ""); +Expect(1, 4441, '\P{^Is_Script=hangul}', ""); +Expect(0, 4351, '\p{Is_Script=hangul}', ""); +Expect(1, 4351, '\p{^Is_Script=hangul}', ""); +Expect(1, 4351, '\P{Is_Script=hangul}', ""); +Expect(0, 4351, '\P{^Is_Script=hangul}', ""); +Expect(1, 4441, '\p{Is_Script= Hangul}', ""); +Expect(0, 4441, '\p{^Is_Script= Hangul}', ""); +Expect(0, 4441, '\P{Is_Script= Hangul}', ""); +Expect(1, 4441, '\P{^Is_Script= Hangul}', ""); +Expect(0, 4351, '\p{Is_Script= Hangul}', ""); +Expect(1, 4351, '\p{^Is_Script= Hangul}', ""); +Expect(1, 4351, '\P{Is_Script= Hangul}', ""); +Expect(0, 4351, '\P{^Is_Script= Hangul}', ""); +Error('\p{Is_Sc= _Hang/a/}'); +Error('\P{Is_Sc= _Hang/a/}'); +Expect(1, 4441, '\p{Is_Sc: hang}', ""); +Expect(0, 4441, '\p{^Is_Sc: hang}', ""); +Expect(0, 4441, '\P{Is_Sc: hang}', ""); +Expect(1, 4441, '\P{^Is_Sc: hang}', ""); +Expect(0, 4351, '\p{Is_Sc: hang}', ""); +Expect(1, 4351, '\p{^Is_Sc: hang}', ""); +Expect(1, 4351, '\P{Is_Sc: hang}', ""); +Expect(0, 4351, '\P{^Is_Sc: hang}', ""); +Expect(1, 4441, '\p{Is_Sc= HANG}', ""); +Expect(0, 4441, '\p{^Is_Sc= HANG}', ""); +Expect(0, 4441, '\P{Is_Sc= HANG}', ""); +Expect(1, 4441, '\P{^Is_Sc= HANG}', ""); +Expect(0, 4351, '\p{Is_Sc= HANG}', ""); +Expect(1, 4351, '\p{^Is_Sc= HANG}', ""); +Expect(1, 4351, '\P{Is_Sc= HANG}', ""); +Expect(0, 4351, '\P{^Is_Sc= HANG}', ""); +Error('\p{Script=_:=UNKNOWN}'); +Error('\P{Script=_:=UNKNOWN}'); +Expect(1, 889, '\p{Script=unknown}', ""); +Expect(0, 889, '\p{^Script=unknown}', ""); +Expect(0, 889, '\P{Script=unknown}', ""); +Expect(1, 889, '\P{^Script=unknown}', ""); +Expect(0, 887, '\p{Script=unknown}', ""); +Expect(1, 887, '\p{^Script=unknown}', ""); +Expect(1, 887, '\P{Script=unknown}', ""); +Expect(0, 887, '\P{^Script=unknown}', ""); +Expect(1, 889, '\p{Script= -Unknown}', ""); +Expect(0, 889, '\p{^Script= -Unknown}', ""); +Expect(0, 889, '\P{Script= -Unknown}', ""); +Expect(1, 889, '\P{^Script= -Unknown}', ""); +Expect(0, 887, '\p{Script= -Unknown}', ""); +Expect(1, 887, '\p{^Script= -Unknown}', ""); +Expect(1, 887, '\P{Script= -Unknown}', ""); +Expect(0, 887, '\P{^Script= -Unknown}', ""); +Error('\p{Sc=_ zzzz/a/}'); +Error('\P{Sc=_ zzzz/a/}'); +Expect(1, 889, '\p{Sc=zzzz}', ""); +Expect(0, 889, '\p{^Sc=zzzz}', ""); +Expect(0, 889, '\P{Sc=zzzz}', ""); +Expect(1, 889, '\P{^Sc=zzzz}', ""); +Expect(0, 887, '\p{Sc=zzzz}', ""); +Expect(1, 887, '\p{^Sc=zzzz}', ""); +Expect(1, 887, '\P{Sc=zzzz}', ""); +Expect(0, 887, '\P{^Sc=zzzz}', ""); +Expect(1, 889, '\p{Sc=--Zzzz}', ""); +Expect(0, 889, '\p{^Sc=--Zzzz}', ""); +Expect(0, 889, '\P{Sc=--Zzzz}', ""); +Expect(1, 889, '\P{^Sc=--Zzzz}', ""); +Expect(0, 887, '\p{Sc=--Zzzz}', ""); +Expect(1, 887, '\p{^Sc=--Zzzz}', ""); +Expect(1, 887, '\P{Sc=--Zzzz}', ""); +Expect(0, 887, '\P{^Sc=--Zzzz}', ""); +Error('\p{Is_Script=:=Unknown}'); +Error('\P{Is_Script=:=Unknown}'); +Expect(1, 889, '\p{Is_Script: unknown}', ""); +Expect(0, 889, '\p{^Is_Script: unknown}', ""); +Expect(0, 889, '\P{Is_Script: unknown}', ""); +Expect(1, 889, '\P{^Is_Script: unknown}', ""); +Expect(0, 887, '\p{Is_Script: unknown}', ""); +Expect(1, 887, '\p{^Is_Script: unknown}', ""); +Expect(1, 887, '\P{Is_Script: unknown}', ""); +Expect(0, 887, '\P{^Is_Script: unknown}', ""); +Expect(1, 889, '\p{Is_Script= UNKNOWN}', ""); +Expect(0, 889, '\p{^Is_Script= UNKNOWN}', ""); +Expect(0, 889, '\P{Is_Script= UNKNOWN}', ""); +Expect(1, 889, '\P{^Is_Script= UNKNOWN}', ""); +Expect(0, 887, '\p{Is_Script= UNKNOWN}', ""); +Expect(1, 887, '\p{^Is_Script= UNKNOWN}', ""); +Expect(1, 887, '\P{Is_Script= UNKNOWN}', ""); +Expect(0, 887, '\P{^Is_Script= UNKNOWN}', ""); +Error('\p{Is_Sc= Zzzz/a/}'); +Error('\P{Is_Sc= Zzzz/a/}'); +Expect(1, 889, '\p{Is_Sc=zzzz}', ""); +Expect(0, 889, '\p{^Is_Sc=zzzz}', ""); +Expect(0, 889, '\P{Is_Sc=zzzz}', ""); +Expect(1, 889, '\P{^Is_Sc=zzzz}', ""); +Expect(0, 887, '\p{Is_Sc=zzzz}', ""); +Expect(1, 887, '\p{^Is_Sc=zzzz}', ""); +Expect(1, 887, '\P{Is_Sc=zzzz}', ""); +Expect(0, 887, '\P{^Is_Sc=zzzz}', ""); +Expect(1, 889, '\p{Is_Sc=--Zzzz}', ""); +Expect(0, 889, '\p{^Is_Sc=--Zzzz}', ""); +Expect(0, 889, '\P{Is_Sc=--Zzzz}', ""); +Expect(1, 889, '\P{^Is_Sc=--Zzzz}', ""); +Expect(0, 887, '\p{Is_Sc=--Zzzz}', ""); +Expect(1, 887, '\p{^Is_Sc=--Zzzz}', ""); +Expect(1, 887, '\P{Is_Sc=--Zzzz}', ""); +Expect(0, 887, '\P{^Is_Sc=--Zzzz}', ""); +Error('\p{Script: --Deseret/a/}'); +Error('\P{Script: --Deseret/a/}'); +Expect(1, 66639, '\p{Script=deseret}', ""); +Expect(0, 66639, '\p{^Script=deseret}', ""); +Expect(0, 66639, '\P{Script=deseret}', ""); +Expect(1, 66639, '\P{^Script=deseret}', ""); +Expect(0, 66559, '\p{Script=deseret}', ""); +Expect(1, 66559, '\p{^Script=deseret}', ""); +Expect(1, 66559, '\P{Script=deseret}', ""); +Expect(0, 66559, '\P{^Script=deseret}', ""); +Expect(1, 66639, '\p{Script=_-deseret}', ""); +Expect(0, 66639, '\p{^Script=_-deseret}', ""); +Expect(0, 66639, '\P{Script=_-deseret}', ""); +Expect(1, 66639, '\P{^Script=_-deseret}', ""); +Expect(0, 66559, '\p{Script=_-deseret}', ""); +Expect(1, 66559, '\p{^Script=_-deseret}', ""); +Expect(1, 66559, '\P{Script=_-deseret}', ""); +Expect(0, 66559, '\P{^Script=_-deseret}', ""); +Error('\p{Sc=:=-_DSRT}'); +Error('\P{Sc=:=-_DSRT}'); +Expect(1, 66639, '\p{Sc=dsrt}', ""); +Expect(0, 66639, '\p{^Sc=dsrt}', ""); +Expect(0, 66639, '\P{Sc=dsrt}', ""); +Expect(1, 66639, '\P{^Sc=dsrt}', ""); +Expect(0, 66559, '\p{Sc=dsrt}', ""); +Expect(1, 66559, '\p{^Sc=dsrt}', ""); +Expect(1, 66559, '\P{Sc=dsrt}', ""); +Expect(0, 66559, '\P{^Sc=dsrt}', ""); +Expect(1, 66639, '\p{Sc= _Dsrt}', ""); +Expect(0, 66639, '\p{^Sc= _Dsrt}', ""); +Expect(0, 66639, '\P{Sc= _Dsrt}', ""); +Expect(1, 66639, '\P{^Sc= _Dsrt}', ""); +Expect(0, 66559, '\p{Sc= _Dsrt}', ""); +Expect(1, 66559, '\p{^Sc= _Dsrt}', ""); +Expect(1, 66559, '\P{Sc= _Dsrt}', ""); +Expect(0, 66559, '\P{^Sc= _Dsrt}', ""); +Error('\p{Is_Script=:=-_DESERET}'); +Error('\P{Is_Script=:=-_DESERET}'); +Expect(1, 66639, '\p{Is_Script=deseret}', ""); +Expect(0, 66639, '\p{^Is_Script=deseret}', ""); +Expect(0, 66639, '\P{Is_Script=deseret}', ""); +Expect(1, 66639, '\P{^Is_Script=deseret}', ""); +Expect(0, 66559, '\p{Is_Script=deseret}', ""); +Expect(1, 66559, '\p{^Is_Script=deseret}', ""); +Expect(1, 66559, '\P{Is_Script=deseret}', ""); +Expect(0, 66559, '\P{^Is_Script=deseret}', ""); +Expect(1, 66639, '\p{Is_Script=-_DESERET}', ""); +Expect(0, 66639, '\p{^Is_Script=-_DESERET}', ""); +Expect(0, 66639, '\P{Is_Script=-_DESERET}', ""); +Expect(1, 66639, '\P{^Is_Script=-_DESERET}', ""); +Expect(0, 66559, '\p{Is_Script=-_DESERET}', ""); +Expect(1, 66559, '\p{^Is_Script=-_DESERET}', ""); +Expect(1, 66559, '\P{Is_Script=-_DESERET}', ""); +Expect(0, 66559, '\P{^Is_Script=-_DESERET}', ""); +Error('\p{Is_Sc=:= Dsrt}'); +Error('\P{Is_Sc=:= Dsrt}'); +Expect(1, 66639, '\p{Is_Sc=dsrt}', ""); +Expect(0, 66639, '\p{^Is_Sc=dsrt}', ""); +Expect(0, 66639, '\P{Is_Sc=dsrt}', ""); +Expect(1, 66639, '\P{^Is_Sc=dsrt}', ""); +Expect(0, 66559, '\p{Is_Sc=dsrt}', ""); +Expect(1, 66559, '\p{^Is_Sc=dsrt}', ""); +Expect(1, 66559, '\P{Is_Sc=dsrt}', ""); +Expect(0, 66559, '\P{^Is_Sc=dsrt}', ""); +Error('\p{Script= :=cuneiform}'); +Error('\P{Script= :=cuneiform}'); +Expect(1, 74606, '\p{Script=cuneiform}', ""); +Expect(0, 74606, '\p{^Script=cuneiform}', ""); +Expect(0, 74606, '\P{Script=cuneiform}', ""); +Expect(1, 74606, '\P{^Script=cuneiform}', ""); +Expect(0, 73727, '\p{Script=cuneiform}', ""); +Expect(1, 73727, '\p{^Script=cuneiform}', ""); +Expect(1, 73727, '\P{Script=cuneiform}', ""); +Expect(0, 73727, '\P{^Script=cuneiform}', ""); +Expect(1, 74606, '\p{Script=-Cuneiform}', ""); +Expect(0, 74606, '\p{^Script=-Cuneiform}', ""); +Expect(0, 74606, '\P{Script=-Cuneiform}', ""); +Expect(1, 74606, '\P{^Script=-Cuneiform}', ""); +Expect(0, 73727, '\p{Script=-Cuneiform}', ""); +Expect(1, 73727, '\p{^Script=-Cuneiform}', ""); +Expect(1, 73727, '\P{Script=-Cuneiform}', ""); +Expect(0, 73727, '\P{^Script=-Cuneiform}', ""); +Error('\p{Sc=_XSUX/a/}'); +Error('\P{Sc=_XSUX/a/}'); +Expect(1, 74606, '\p{Sc:xsux}', ""); +Expect(0, 74606, '\p{^Sc:xsux}', ""); +Expect(0, 74606, '\P{Sc:xsux}', ""); +Expect(1, 74606, '\P{^Sc:xsux}', ""); +Expect(0, 73727, '\p{Sc:xsux}', ""); +Expect(1, 73727, '\p{^Sc:xsux}', ""); +Expect(1, 73727, '\P{Sc:xsux}', ""); +Expect(0, 73727, '\P{^Sc:xsux}', ""); +Expect(1, 74606, '\p{Sc= Xsux}', ""); +Expect(0, 74606, '\p{^Sc= Xsux}', ""); +Expect(0, 74606, '\P{Sc= Xsux}', ""); +Expect(1, 74606, '\P{^Sc= Xsux}', ""); +Expect(0, 73727, '\p{Sc= Xsux}', ""); +Expect(1, 73727, '\p{^Sc= Xsux}', ""); +Expect(1, 73727, '\P{Sc= Xsux}', ""); +Expect(0, 73727, '\P{^Sc= Xsux}', ""); +Error('\p{Is_Script= -Cuneiform/a/}'); +Error('\P{Is_Script= -Cuneiform/a/}'); +Expect(1, 74606, '\p{Is_Script=cuneiform}', ""); +Expect(0, 74606, '\p{^Is_Script=cuneiform}', ""); +Expect(0, 74606, '\P{Is_Script=cuneiform}', ""); +Expect(1, 74606, '\P{^Is_Script=cuneiform}', ""); +Expect(0, 73727, '\p{Is_Script=cuneiform}', ""); +Expect(1, 73727, '\p{^Is_Script=cuneiform}', ""); +Expect(1, 73727, '\P{Is_Script=cuneiform}', ""); +Expect(0, 73727, '\P{^Is_Script=cuneiform}', ""); +Expect(1, 74606, '\p{Is_Script= Cuneiform}', ""); +Expect(0, 74606, '\p{^Is_Script= Cuneiform}', ""); +Expect(0, 74606, '\P{Is_Script= Cuneiform}', ""); +Expect(1, 74606, '\P{^Is_Script= Cuneiform}', ""); +Expect(0, 73727, '\p{Is_Script= Cuneiform}', ""); +Expect(1, 73727, '\p{^Is_Script= Cuneiform}', ""); +Expect(1, 73727, '\P{Is_Script= Cuneiform}', ""); +Expect(0, 73727, '\P{^Is_Script= Cuneiform}', ""); +Error('\p{Is_Sc=/a/ Xsux}'); +Error('\P{Is_Sc=/a/ Xsux}'); +Expect(1, 74606, '\p{Is_Sc: xsux}', ""); +Expect(0, 74606, '\p{^Is_Sc: xsux}', ""); +Expect(0, 74606, '\P{Is_Sc: xsux}', ""); +Expect(1, 74606, '\P{^Is_Sc: xsux}', ""); +Expect(0, 73727, '\p{Is_Sc: xsux}', ""); +Expect(1, 73727, '\p{^Is_Sc: xsux}', ""); +Expect(1, 73727, '\P{Is_Sc: xsux}', ""); +Expect(0, 73727, '\P{^Is_Sc: xsux}', ""); +Expect(1, 74606, '\p{Is_Sc=-xsux}', ""); +Expect(0, 74606, '\p{^Is_Sc=-xsux}', ""); +Expect(0, 74606, '\P{Is_Sc=-xsux}', ""); +Expect(1, 74606, '\P{^Is_Sc=-xsux}', ""); +Expect(0, 73727, '\p{Is_Sc=-xsux}', ""); +Expect(1, 73727, '\p{^Is_Sc=-xsux}', ""); +Expect(1, 73727, '\P{Is_Sc=-xsux}', ""); +Expect(0, 73727, '\P{^Is_Sc=-xsux}', ""); +Error('\p{Script= inherited:=}'); +Error('\P{Script= inherited:=}'); +Expect(1, 879, '\p{Script=inherited}', ""); +Expect(0, 879, '\p{^Script=inherited}', ""); +Expect(0, 879, '\P{Script=inherited}', ""); +Expect(1, 879, '\P{^Script=inherited}', ""); +Expect(0, 767, '\p{Script=inherited}', ""); +Expect(1, 767, '\p{^Script=inherited}', ""); +Expect(1, 767, '\P{Script=inherited}', ""); +Expect(0, 767, '\P{^Script=inherited}', ""); +Expect(1, 879, '\p{Script= inherited}', ""); +Expect(0, 879, '\p{^Script= inherited}', ""); +Expect(0, 879, '\P{Script= inherited}', ""); +Expect(1, 879, '\P{^Script= inherited}', ""); +Expect(0, 767, '\p{Script= inherited}', ""); +Expect(1, 767, '\p{^Script= inherited}', ""); +Expect(1, 767, '\P{Script= inherited}', ""); +Expect(0, 767, '\P{^Script= inherited}', ""); +Error('\p{Sc= /a/qaai}'); +Error('\P{Sc= /a/qaai}'); +Expect(1, 879, '\p{Sc:qaai}', ""); +Expect(0, 879, '\p{^Sc:qaai}', ""); +Expect(0, 879, '\P{Sc:qaai}', ""); +Expect(1, 879, '\P{^Sc:qaai}', ""); +Expect(0, 767, '\p{Sc:qaai}', ""); +Expect(1, 767, '\p{^Sc:qaai}', ""); +Expect(1, 767, '\P{Sc:qaai}', ""); +Expect(0, 767, '\P{^Sc:qaai}', ""); +Expect(1, 879, '\p{Sc=_QAAI}', ""); +Expect(0, 879, '\p{^Sc=_QAAI}', ""); +Expect(0, 879, '\P{Sc=_QAAI}', ""); +Expect(1, 879, '\P{^Sc=_QAAI}', ""); +Expect(0, 767, '\p{Sc=_QAAI}', ""); +Expect(1, 767, '\p{^Sc=_QAAI}', ""); +Expect(1, 767, '\P{Sc=_QAAI}', ""); +Expect(0, 767, '\P{^Sc=_QAAI}', ""); +Error('\p{Is_Script= Inherited/a/}'); +Error('\P{Is_Script= Inherited/a/}'); +Expect(1, 879, '\p{Is_Script: inherited}', ""); +Expect(0, 879, '\p{^Is_Script: inherited}', ""); +Expect(0, 879, '\P{Is_Script: inherited}', ""); +Expect(1, 879, '\P{^Is_Script: inherited}', ""); +Expect(0, 767, '\p{Is_Script: inherited}', ""); +Expect(1, 767, '\p{^Is_Script: inherited}', ""); +Expect(1, 767, '\P{Is_Script: inherited}', ""); +Expect(0, 767, '\P{^Is_Script: inherited}', ""); +Expect(1, 879, '\p{Is_Script=Inherited}', ""); +Expect(0, 879, '\p{^Is_Script=Inherited}', ""); +Expect(0, 879, '\P{Is_Script=Inherited}', ""); +Expect(1, 879, '\P{^Is_Script=Inherited}', ""); +Expect(0, 767, '\p{Is_Script=Inherited}', ""); +Expect(1, 767, '\p{^Is_Script=Inherited}', ""); +Expect(1, 767, '\P{Is_Script=Inherited}', ""); +Expect(0, 767, '\P{^Is_Script=Inherited}', ""); +Error('\p{Is_Sc=:=--Qaai}'); +Error('\P{Is_Sc=:=--Qaai}'); +Expect(1, 879, '\p{Is_Sc=qaai}', ""); +Expect(0, 879, '\p{^Is_Sc=qaai}', ""); +Expect(0, 879, '\P{Is_Sc=qaai}', ""); +Expect(1, 879, '\P{^Is_Sc=qaai}', ""); +Expect(0, 767, '\p{Is_Sc=qaai}', ""); +Expect(1, 767, '\p{^Is_Sc=qaai}', ""); +Expect(1, 767, '\P{Is_Sc=qaai}', ""); +Expect(0, 767, '\P{^Is_Sc=qaai}', ""); +Expect(1, 879, '\p{Is_Sc= Qaai}', ""); +Expect(0, 879, '\p{^Is_Sc= Qaai}', ""); +Expect(0, 879, '\P{Is_Sc= Qaai}', ""); +Expect(1, 879, '\P{^Is_Sc= Qaai}', ""); +Expect(0, 767, '\p{Is_Sc= Qaai}', ""); +Expect(1, 767, '\p{^Is_Sc= Qaai}', ""); +Expect(1, 767, '\P{Is_Sc= Qaai}', ""); +Expect(0, 767, '\P{^Is_Sc= Qaai}', ""); +Error('\p{Script=:= arabic}'); +Error('\P{Script=:= arabic}'); +Expect(1, 1547, '\p{Script=arabic}', ""); +Expect(0, 1547, '\p{^Script=arabic}', ""); +Expect(0, 1547, '\P{Script=arabic}', ""); +Expect(1, 1547, '\P{^Script=arabic}', ""); +Expect(0, 1541, '\p{Script=arabic}', ""); +Expect(1, 1541, '\p{^Script=arabic}', ""); +Expect(1, 1541, '\P{Script=arabic}', ""); +Expect(0, 1541, '\P{^Script=arabic}', ""); +Expect(1, 1547, '\p{Script=- Arabic}', ""); +Expect(0, 1547, '\p{^Script=- Arabic}', ""); +Expect(0, 1547, '\P{Script=- Arabic}', ""); +Expect(1, 1547, '\P{^Script=- Arabic}', ""); +Expect(0, 1541, '\p{Script=- Arabic}', ""); +Expect(1, 1541, '\p{^Script=- Arabic}', ""); +Expect(1, 1541, '\P{Script=- Arabic}', ""); +Expect(0, 1541, '\P{^Script=- Arabic}', ""); +Error('\p{Sc=:= _Arab}'); +Error('\P{Sc=:= _Arab}'); +Expect(1, 1547, '\p{Sc=arab}', ""); +Expect(0, 1547, '\p{^Sc=arab}', ""); +Expect(0, 1547, '\P{Sc=arab}', ""); +Expect(1, 1547, '\P{^Sc=arab}', ""); +Expect(0, 1541, '\p{Sc=arab}', ""); +Expect(1, 1541, '\p{^Sc=arab}', ""); +Expect(1, 1541, '\P{Sc=arab}', ""); +Expect(0, 1541, '\P{^Sc=arab}', ""); +Expect(1, 1547, '\p{Sc=--Arab}', ""); +Expect(0, 1547, '\p{^Sc=--Arab}', ""); +Expect(0, 1547, '\P{Sc=--Arab}', ""); +Expect(1, 1547, '\P{^Sc=--Arab}', ""); +Expect(0, 1541, '\p{Sc=--Arab}', ""); +Expect(1, 1541, '\p{^Sc=--Arab}', ""); +Expect(1, 1541, '\P{Sc=--Arab}', ""); +Expect(0, 1541, '\P{^Sc=--Arab}', ""); +Error('\p{Is_Script=-ARABIC/a/}'); +Error('\P{Is_Script=-ARABIC/a/}'); +Expect(1, 1547, '\p{Is_Script=arabic}', ""); +Expect(0, 1547, '\p{^Is_Script=arabic}', ""); +Expect(0, 1547, '\P{Is_Script=arabic}', ""); +Expect(1, 1547, '\P{^Is_Script=arabic}', ""); +Expect(0, 1541, '\p{Is_Script=arabic}', ""); +Expect(1, 1541, '\p{^Is_Script=arabic}', ""); +Expect(1, 1541, '\P{Is_Script=arabic}', ""); +Expect(0, 1541, '\P{^Is_Script=arabic}', ""); +Expect(1, 1547, '\p{Is_Script= -ARABIC}', ""); +Expect(0, 1547, '\p{^Is_Script= -ARABIC}', ""); +Expect(0, 1547, '\P{Is_Script= -ARABIC}', ""); +Expect(1, 1547, '\P{^Is_Script= -ARABIC}', ""); +Expect(0, 1541, '\p{Is_Script= -ARABIC}', ""); +Expect(1, 1541, '\p{^Is_Script= -ARABIC}', ""); +Expect(1, 1541, '\P{Is_Script= -ARABIC}', ""); +Expect(0, 1541, '\P{^Is_Script= -ARABIC}', ""); +Error('\p{Is_Sc=:=-Arab}'); +Error('\P{Is_Sc=:=-Arab}'); +Expect(1, 1547, '\p{Is_Sc=arab}', ""); +Expect(0, 1547, '\p{^Is_Sc=arab}', ""); +Expect(0, 1547, '\P{Is_Sc=arab}', ""); +Expect(1, 1547, '\P{^Is_Sc=arab}', ""); +Expect(0, 1541, '\p{Is_Sc=arab}', ""); +Expect(1, 1541, '\p{^Is_Sc=arab}', ""); +Expect(1, 1541, '\P{Is_Sc=arab}', ""); +Expect(0, 1541, '\P{^Is_Sc=arab}', ""); +Expect(1, 1547, '\p{Is_Sc=_ ARAB}', ""); +Expect(0, 1547, '\p{^Is_Sc=_ ARAB}', ""); +Expect(0, 1547, '\P{Is_Sc=_ ARAB}', ""); +Expect(1, 1547, '\P{^Is_Sc=_ ARAB}', ""); +Expect(0, 1541, '\p{Is_Sc=_ ARAB}', ""); +Expect(1, 1541, '\p{^Is_Sc=_ ARAB}', ""); +Expect(1, 1541, '\P{Is_Sc=_ ARAB}', ""); +Expect(0, 1541, '\P{^Is_Sc=_ ARAB}', ""); +Error('\p{Script=/a/-Shavian}'); +Error('\P{Script=/a/-Shavian}'); +Expect(1, 66687, '\p{Script: shavian}', ""); +Expect(0, 66687, '\p{^Script: shavian}', ""); +Expect(0, 66687, '\P{Script: shavian}', ""); +Expect(1, 66687, '\P{^Script: shavian}', ""); +Expect(0, 66639, '\p{Script: shavian}', ""); +Expect(1, 66639, '\p{^Script: shavian}', ""); +Expect(1, 66639, '\P{Script: shavian}', ""); +Expect(0, 66639, '\P{^Script: shavian}', ""); +Expect(1, 66687, '\p{Script=_ Shavian}', ""); +Expect(0, 66687, '\p{^Script=_ Shavian}', ""); +Expect(0, 66687, '\P{Script=_ Shavian}', ""); +Expect(1, 66687, '\P{^Script=_ Shavian}', ""); +Expect(0, 66639, '\p{Script=_ Shavian}', ""); +Expect(1, 66639, '\p{^Script=_ Shavian}', ""); +Expect(1, 66639, '\P{Script=_ Shavian}', ""); +Expect(0, 66639, '\P{^Script=_ Shavian}', ""); +Error('\p{Sc=/a/_Shaw}'); +Error('\P{Sc=/a/_Shaw}'); +Expect(1, 66687, '\p{Sc: shaw}', ""); +Expect(0, 66687, '\p{^Sc: shaw}', ""); +Expect(0, 66687, '\P{Sc: shaw}', ""); +Expect(1, 66687, '\P{^Sc: shaw}', ""); +Expect(0, 66639, '\p{Sc: shaw}', ""); +Expect(1, 66639, '\p{^Sc: shaw}', ""); +Expect(1, 66639, '\P{Sc: shaw}', ""); +Expect(0, 66639, '\P{^Sc: shaw}', ""); +Expect(1, 66687, '\p{Sc=Shaw}', ""); +Expect(0, 66687, '\p{^Sc=Shaw}', ""); +Expect(0, 66687, '\P{Sc=Shaw}', ""); +Expect(1, 66687, '\P{^Sc=Shaw}', ""); +Expect(0, 66639, '\p{Sc=Shaw}', ""); +Expect(1, 66639, '\p{^Sc=Shaw}', ""); +Expect(1, 66639, '\P{Sc=Shaw}', ""); +Expect(0, 66639, '\P{^Sc=Shaw}', ""); +Error('\p{Is_Script= /a/Shavian}'); +Error('\P{Is_Script= /a/Shavian}'); +Expect(1, 66687, '\p{Is_Script=shavian}', ""); +Expect(0, 66687, '\p{^Is_Script=shavian}', ""); +Expect(0, 66687, '\P{Is_Script=shavian}', ""); +Expect(1, 66687, '\P{^Is_Script=shavian}', ""); +Expect(0, 66639, '\p{Is_Script=shavian}', ""); +Expect(1, 66639, '\p{^Is_Script=shavian}', ""); +Expect(1, 66639, '\P{Is_Script=shavian}', ""); +Expect(0, 66639, '\P{^Is_Script=shavian}', ""); +Expect(1, 66687, '\p{Is_Script= Shavian}', ""); +Expect(0, 66687, '\p{^Is_Script= Shavian}', ""); +Expect(0, 66687, '\P{Is_Script= Shavian}', ""); +Expect(1, 66687, '\P{^Is_Script= Shavian}', ""); +Expect(0, 66639, '\p{Is_Script= Shavian}', ""); +Expect(1, 66639, '\p{^Is_Script= Shavian}', ""); +Expect(1, 66639, '\P{Is_Script= Shavian}', ""); +Expect(0, 66639, '\P{^Is_Script= Shavian}', ""); +Error('\p{Is_Sc=:= _shaw}'); +Error('\P{Is_Sc=:= _shaw}'); +Expect(1, 66687, '\p{Is_Sc:shaw}', ""); +Expect(0, 66687, '\p{^Is_Sc:shaw}', ""); +Expect(0, 66687, '\P{Is_Sc:shaw}', ""); +Expect(1, 66687, '\P{^Is_Sc:shaw}', ""); +Expect(0, 66639, '\p{Is_Sc:shaw}', ""); +Expect(1, 66639, '\p{^Is_Sc:shaw}', ""); +Expect(1, 66639, '\P{Is_Sc:shaw}', ""); +Expect(0, 66639, '\P{^Is_Sc:shaw}', ""); +Expect(1, 66687, '\p{Is_Sc=- shaw}', ""); +Expect(0, 66687, '\p{^Is_Sc=- shaw}', ""); +Expect(0, 66687, '\P{Is_Sc=- shaw}', ""); +Expect(1, 66687, '\P{^Is_Sc=- shaw}', ""); +Expect(0, 66639, '\p{Is_Sc=- shaw}', ""); +Expect(1, 66639, '\p{^Is_Sc=- shaw}', ""); +Expect(1, 66639, '\P{Is_Sc=- shaw}', ""); +Expect(0, 66639, '\P{^Is_Sc=- shaw}', ""); +Error('\p{Script= :=Canadian Aboriginal}'); +Error('\P{Script= :=Canadian Aboriginal}'); +Expect(1, 5750, '\p{Script=canadianaboriginal}', ""); +Expect(0, 5750, '\p{^Script=canadianaboriginal}', ""); +Expect(0, 5750, '\P{Script=canadianaboriginal}', ""); +Expect(1, 5750, '\P{^Script=canadianaboriginal}', ""); +Expect(0, 5120, '\p{Script=canadianaboriginal}', ""); +Expect(1, 5120, '\p{^Script=canadianaboriginal}', ""); +Expect(1, 5120, '\P{Script=canadianaboriginal}', ""); +Expect(0, 5120, '\P{^Script=canadianaboriginal}', ""); +Expect(1, 5750, '\p{Script= -CANADIAN_Aboriginal}', ""); +Expect(0, 5750, '\p{^Script= -CANADIAN_Aboriginal}', ""); +Expect(0, 5750, '\P{Script= -CANADIAN_Aboriginal}', ""); +Expect(1, 5750, '\P{^Script= -CANADIAN_Aboriginal}', ""); +Expect(0, 5120, '\p{Script= -CANADIAN_Aboriginal}', ""); +Expect(1, 5120, '\p{^Script= -CANADIAN_Aboriginal}', ""); +Expect(1, 5120, '\P{Script= -CANADIAN_Aboriginal}', ""); +Expect(0, 5120, '\P{^Script= -CANADIAN_Aboriginal}', ""); +Error('\p{Sc=-/a/Cans}'); +Error('\P{Sc=-/a/Cans}'); +Expect(1, 5750, '\p{Sc=cans}', ""); +Expect(0, 5750, '\p{^Sc=cans}', ""); +Expect(0, 5750, '\P{Sc=cans}', ""); +Expect(1, 5750, '\P{^Sc=cans}', ""); +Expect(0, 5120, '\p{Sc=cans}', ""); +Expect(1, 5120, '\p{^Sc=cans}', ""); +Expect(1, 5120, '\P{Sc=cans}', ""); +Expect(0, 5120, '\P{^Sc=cans}', ""); +Expect(1, 5750, '\p{Sc= -Cans}', ""); +Expect(0, 5750, '\p{^Sc= -Cans}', ""); +Expect(0, 5750, '\P{Sc= -Cans}', ""); +Expect(1, 5750, '\P{^Sc= -Cans}', ""); +Expect(0, 5120, '\p{Sc= -Cans}', ""); +Expect(1, 5120, '\p{^Sc= -Cans}', ""); +Expect(1, 5120, '\P{Sc= -Cans}', ""); +Expect(0, 5120, '\P{^Sc= -Cans}', ""); +Error('\p{Is_Script=Canadian/a/aboriginal}'); +Error('\P{Is_Script=Canadian/a/aboriginal}'); +Expect(1, 5750, '\p{Is_Script=canadianaboriginal}', ""); +Expect(0, 5750, '\p{^Is_Script=canadianaboriginal}', ""); +Expect(0, 5750, '\P{Is_Script=canadianaboriginal}', ""); +Expect(1, 5750, '\P{^Is_Script=canadianaboriginal}', ""); +Expect(0, 5120, '\p{Is_Script=canadianaboriginal}', ""); +Expect(1, 5120, '\p{^Is_Script=canadianaboriginal}', ""); +Expect(1, 5120, '\P{Is_Script=canadianaboriginal}', ""); +Expect(0, 5120, '\P{^Is_Script=canadianaboriginal}', ""); +Expect(1, 5750, '\p{Is_Script= CANADIAN-ABORIGINAL}', ""); +Expect(0, 5750, '\p{^Is_Script= CANADIAN-ABORIGINAL}', ""); +Expect(0, 5750, '\P{Is_Script= CANADIAN-ABORIGINAL}', ""); +Expect(1, 5750, '\P{^Is_Script= CANADIAN-ABORIGINAL}', ""); +Expect(0, 5120, '\p{Is_Script= CANADIAN-ABORIGINAL}', ""); +Expect(1, 5120, '\p{^Is_Script= CANADIAN-ABORIGINAL}', ""); +Expect(1, 5120, '\P{Is_Script= CANADIAN-ABORIGINAL}', ""); +Expect(0, 5120, '\P{^Is_Script= CANADIAN-ABORIGINAL}', ""); +Error('\p{Is_Sc=_CANS/a/}'); +Error('\P{Is_Sc=_CANS/a/}'); +Expect(1, 5750, '\p{Is_Sc=cans}', ""); +Expect(0, 5750, '\p{^Is_Sc=cans}', ""); +Expect(0, 5750, '\P{Is_Sc=cans}', ""); +Expect(1, 5750, '\P{^Is_Sc=cans}', ""); +Expect(0, 5120, '\p{Is_Sc=cans}', ""); +Expect(1, 5120, '\p{^Is_Sc=cans}', ""); +Expect(1, 5120, '\P{Is_Sc=cans}', ""); +Expect(0, 5120, '\P{^Is_Sc=cans}', ""); +Expect(1, 5750, '\p{Is_Sc= CANS}', ""); +Expect(0, 5750, '\p{^Is_Sc= CANS}', ""); +Expect(0, 5750, '\P{Is_Sc= CANS}', ""); +Expect(1, 5750, '\P{^Is_Sc= CANS}', ""); +Expect(0, 5120, '\p{Is_Sc= CANS}', ""); +Expect(1, 5120, '\p{^Is_Sc= CANS}', ""); +Expect(1, 5120, '\P{Is_Sc= CANS}', ""); +Expect(0, 5120, '\P{^Is_Sc= CANS}', ""); +Error('\p{Script: /a/ Lydian}'); +Error('\P{Script: /a/ Lydian}'); +Expect(1, 67897, '\p{Script=lydian}', ""); +Expect(0, 67897, '\p{^Script=lydian}', ""); +Expect(0, 67897, '\P{Script=lydian}', ""); +Expect(1, 67897, '\P{^Script=lydian}', ""); +Expect(0, 67871, '\p{Script=lydian}', ""); +Expect(1, 67871, '\p{^Script=lydian}', ""); +Expect(1, 67871, '\P{Script=lydian}', ""); +Expect(0, 67871, '\P{^Script=lydian}', ""); +Expect(1, 67897, '\p{Script=- LYDIAN}', ""); +Expect(0, 67897, '\p{^Script=- LYDIAN}', ""); +Expect(0, 67897, '\P{Script=- LYDIAN}', ""); +Expect(1, 67897, '\P{^Script=- LYDIAN}', ""); +Expect(0, 67871, '\p{Script=- LYDIAN}', ""); +Expect(1, 67871, '\p{^Script=- LYDIAN}', ""); +Expect(1, 67871, '\P{Script=- LYDIAN}', ""); +Expect(0, 67871, '\P{^Script=- LYDIAN}', ""); +Error('\p{Sc=/a/-LYDI}'); +Error('\P{Sc=/a/-LYDI}'); +Expect(1, 67897, '\p{Sc=lydi}', ""); +Expect(0, 67897, '\p{^Sc=lydi}', ""); +Expect(0, 67897, '\P{Sc=lydi}', ""); +Expect(1, 67897, '\P{^Sc=lydi}', ""); +Expect(0, 67871, '\p{Sc=lydi}', ""); +Expect(1, 67871, '\p{^Sc=lydi}', ""); +Expect(1, 67871, '\P{Sc=lydi}', ""); +Expect(0, 67871, '\P{^Sc=lydi}', ""); +Expect(1, 67897, '\p{Sc= Lydi}', ""); +Expect(0, 67897, '\p{^Sc= Lydi}', ""); +Expect(0, 67897, '\P{Sc= Lydi}', ""); +Expect(1, 67897, '\P{^Sc= Lydi}', ""); +Expect(0, 67871, '\p{Sc= Lydi}', ""); +Expect(1, 67871, '\p{^Sc= Lydi}', ""); +Expect(1, 67871, '\P{Sc= Lydi}', ""); +Expect(0, 67871, '\P{^Sc= Lydi}', ""); +Error('\p{Is_Script:--LYDIAN:=}'); +Error('\P{Is_Script:--LYDIAN:=}'); +Expect(1, 67897, '\p{Is_Script=lydian}', ""); +Expect(0, 67897, '\p{^Is_Script=lydian}', ""); +Expect(0, 67897, '\P{Is_Script=lydian}', ""); +Expect(1, 67897, '\P{^Is_Script=lydian}', ""); +Expect(0, 67871, '\p{Is_Script=lydian}', ""); +Expect(1, 67871, '\p{^Is_Script=lydian}', ""); +Expect(1, 67871, '\P{Is_Script=lydian}', ""); +Expect(0, 67871, '\P{^Is_Script=lydian}', ""); +Expect(1, 67897, '\p{Is_Script=-_Lydian}', ""); +Expect(0, 67897, '\p{^Is_Script=-_Lydian}', ""); +Expect(0, 67897, '\P{Is_Script=-_Lydian}', ""); +Expect(1, 67897, '\P{^Is_Script=-_Lydian}', ""); +Expect(0, 67871, '\p{Is_Script=-_Lydian}', ""); +Expect(1, 67871, '\p{^Is_Script=-_Lydian}', ""); +Expect(1, 67871, '\P{Is_Script=-_Lydian}', ""); +Expect(0, 67871, '\P{^Is_Script=-_Lydian}', ""); +Error('\p{Is_Sc= _lydi/a/}'); +Error('\P{Is_Sc= _lydi/a/}'); +Expect(1, 67897, '\p{Is_Sc=lydi}', ""); +Expect(0, 67897, '\p{^Is_Sc=lydi}', ""); +Expect(0, 67897, '\P{Is_Sc=lydi}', ""); +Expect(1, 67897, '\P{^Is_Sc=lydi}', ""); +Expect(0, 67871, '\p{Is_Sc=lydi}', ""); +Expect(1, 67871, '\p{^Is_Sc=lydi}', ""); +Expect(1, 67871, '\P{Is_Sc=lydi}', ""); +Expect(0, 67871, '\P{^Is_Sc=lydi}', ""); +Expect(1, 67897, '\p{Is_Sc= lydi}', ""); +Expect(0, 67897, '\p{^Is_Sc= lydi}', ""); +Expect(0, 67897, '\P{Is_Sc= lydi}', ""); +Expect(1, 67897, '\P{^Is_Sc= lydi}', ""); +Expect(0, 67871, '\p{Is_Sc= lydi}', ""); +Expect(1, 67871, '\p{^Is_Sc= lydi}', ""); +Expect(1, 67871, '\P{Is_Sc= lydi}', ""); +Expect(0, 67871, '\P{^Is_Sc= lydi}', ""); +Error('\p{Script=:= Mongolian}'); +Error('\P{Script=:= Mongolian}'); +Expect(1, 6145, '\p{Script=mongolian}', ""); +Expect(0, 6145, '\p{^Script=mongolian}', ""); +Expect(0, 6145, '\P{Script=mongolian}', ""); +Expect(1, 6145, '\P{^Script=mongolian}', ""); +Expect(0, 6143, '\p{Script=mongolian}', ""); +Expect(1, 6143, '\p{^Script=mongolian}', ""); +Expect(1, 6143, '\P{Script=mongolian}', ""); +Expect(0, 6143, '\P{^Script=mongolian}', ""); +Expect(1, 6145, '\p{Script=-Mongolian}', ""); +Expect(0, 6145, '\p{^Script=-Mongolian}', ""); +Expect(0, 6145, '\P{Script=-Mongolian}', ""); +Expect(1, 6145, '\P{^Script=-Mongolian}', ""); +Expect(0, 6143, '\p{Script=-Mongolian}', ""); +Expect(1, 6143, '\p{^Script=-Mongolian}', ""); +Expect(1, 6143, '\P{Script=-Mongolian}', ""); +Expect(0, 6143, '\P{^Script=-Mongolian}', ""); +Error('\p{Sc=/a/_mong}'); +Error('\P{Sc=/a/_mong}'); +Expect(1, 6145, '\p{Sc=mong}', ""); +Expect(0, 6145, '\p{^Sc=mong}', ""); +Expect(0, 6145, '\P{Sc=mong}', ""); +Expect(1, 6145, '\P{^Sc=mong}', ""); +Expect(0, 6143, '\p{Sc=mong}', ""); +Expect(1, 6143, '\p{^Sc=mong}', ""); +Expect(1, 6143, '\P{Sc=mong}', ""); +Expect(0, 6143, '\P{^Sc=mong}', ""); +Expect(1, 6145, '\p{Sc= Mong}', ""); +Expect(0, 6145, '\p{^Sc= Mong}', ""); +Expect(0, 6145, '\P{Sc= Mong}', ""); +Expect(1, 6145, '\P{^Sc= Mong}', ""); +Expect(0, 6143, '\p{Sc= Mong}', ""); +Expect(1, 6143, '\p{^Sc= Mong}', ""); +Expect(1, 6143, '\P{Sc= Mong}', ""); +Expect(0, 6143, '\P{^Sc= Mong}', ""); +Error('\p{Is_Script= mongolian/a/}'); +Error('\P{Is_Script= mongolian/a/}'); +Expect(1, 6145, '\p{Is_Script=mongolian}', ""); +Expect(0, 6145, '\p{^Is_Script=mongolian}', ""); +Expect(0, 6145, '\P{Is_Script=mongolian}', ""); +Expect(1, 6145, '\P{^Is_Script=mongolian}', ""); +Expect(0, 6143, '\p{Is_Script=mongolian}', ""); +Expect(1, 6143, '\p{^Is_Script=mongolian}', ""); +Expect(1, 6143, '\P{Is_Script=mongolian}', ""); +Expect(0, 6143, '\P{^Is_Script=mongolian}', ""); +Expect(1, 6145, '\p{Is_Script=_Mongolian}', ""); +Expect(0, 6145, '\p{^Is_Script=_Mongolian}', ""); +Expect(0, 6145, '\P{Is_Script=_Mongolian}', ""); +Expect(1, 6145, '\P{^Is_Script=_Mongolian}', ""); +Expect(0, 6143, '\p{Is_Script=_Mongolian}', ""); +Expect(1, 6143, '\p{^Is_Script=_Mongolian}', ""); +Expect(1, 6143, '\P{Is_Script=_Mongolian}', ""); +Expect(0, 6143, '\P{^Is_Script=_Mongolian}', ""); +Error('\p{Is_Sc=:= mong}'); +Error('\P{Is_Sc=:= mong}'); +Expect(1, 6145, '\p{Is_Sc=mong}', ""); +Expect(0, 6145, '\p{^Is_Sc=mong}', ""); +Expect(0, 6145, '\P{Is_Sc=mong}', ""); +Expect(1, 6145, '\P{^Is_Sc=mong}', ""); +Expect(0, 6143, '\p{Is_Sc=mong}', ""); +Expect(1, 6143, '\p{^Is_Sc=mong}', ""); +Expect(1, 6143, '\P{Is_Sc=mong}', ""); +Expect(0, 6143, '\P{^Is_Sc=mong}', ""); +Expect(1, 6145, '\p{Is_Sc= Mong}', ""); +Expect(0, 6145, '\p{^Is_Sc= Mong}', ""); +Expect(0, 6145, '\P{Is_Sc= Mong}', ""); +Expect(1, 6145, '\P{^Is_Sc= Mong}', ""); +Expect(0, 6143, '\p{Is_Sc= Mong}', ""); +Expect(1, 6143, '\p{^Is_Sc= Mong}', ""); +Expect(1, 6143, '\P{Is_Sc= Mong}', ""); +Expect(0, 6143, '\P{^Is_Sc= Mong}', ""); +Error('\p{Script=_-LAO:=}'); +Error('\P{Script=_-LAO:=}'); +Expect(1, 3714, '\p{Script=lao}', ""); +Expect(0, 3714, '\p{^Script=lao}', ""); +Expect(0, 3714, '\P{Script=lao}', ""); +Expect(1, 3714, '\P{^Script=lao}', ""); +Expect(0, 3712, '\p{Script=lao}', ""); +Expect(1, 3712, '\p{^Script=lao}', ""); +Expect(1, 3712, '\P{Script=lao}', ""); +Expect(0, 3712, '\P{^Script=lao}', ""); +Expect(1, 3714, '\p{Script= lao}', ""); +Expect(0, 3714, '\p{^Script= lao}', ""); +Expect(0, 3714, '\P{Script= lao}', ""); +Expect(1, 3714, '\P{^Script= lao}', ""); +Expect(0, 3712, '\p{Script= lao}', ""); +Expect(1, 3712, '\p{^Script= lao}', ""); +Expect(1, 3712, '\P{Script= lao}', ""); +Expect(0, 3712, '\P{^Script= lao}', ""); +Error('\p{Sc=/a/ Laoo}'); +Error('\P{Sc=/a/ Laoo}'); +Expect(1, 3714, '\p{Sc=laoo}', ""); +Expect(0, 3714, '\p{^Sc=laoo}', ""); +Expect(0, 3714, '\P{Sc=laoo}', ""); +Expect(1, 3714, '\P{^Sc=laoo}', ""); +Expect(0, 3712, '\p{Sc=laoo}', ""); +Expect(1, 3712, '\p{^Sc=laoo}', ""); +Expect(1, 3712, '\P{Sc=laoo}', ""); +Expect(0, 3712, '\P{^Sc=laoo}', ""); +Error('\p{Is_Script=_-lao:=}'); +Error('\P{Is_Script=_-lao:=}'); +Expect(1, 3714, '\p{Is_Script=lao}', ""); +Expect(0, 3714, '\p{^Is_Script=lao}', ""); +Expect(0, 3714, '\P{Is_Script=lao}', ""); +Expect(1, 3714, '\P{^Is_Script=lao}', ""); +Expect(0, 3712, '\p{Is_Script=lao}', ""); +Expect(1, 3712, '\p{^Is_Script=lao}', ""); +Expect(1, 3712, '\P{Is_Script=lao}', ""); +Expect(0, 3712, '\P{^Is_Script=lao}', ""); +Expect(1, 3714, '\p{Is_Script=--Lao}', ""); +Expect(0, 3714, '\p{^Is_Script=--Lao}', ""); +Expect(0, 3714, '\P{Is_Script=--Lao}', ""); +Expect(1, 3714, '\P{^Is_Script=--Lao}', ""); +Expect(0, 3712, '\p{Is_Script=--Lao}', ""); +Expect(1, 3712, '\p{^Is_Script=--Lao}', ""); +Expect(1, 3712, '\P{Is_Script=--Lao}', ""); +Expect(0, 3712, '\P{^Is_Script=--Lao}', ""); +Error('\p{Is_Sc=:=-laoo}'); +Error('\P{Is_Sc=:=-laoo}'); +Expect(1, 3714, '\p{Is_Sc=laoo}', ""); +Expect(0, 3714, '\p{^Is_Sc=laoo}', ""); +Expect(0, 3714, '\P{Is_Sc=laoo}', ""); +Expect(1, 3714, '\P{^Is_Sc=laoo}', ""); +Expect(0, 3712, '\p{Is_Sc=laoo}', ""); +Expect(1, 3712, '\p{^Is_Sc=laoo}', ""); +Expect(1, 3712, '\P{Is_Sc=laoo}', ""); +Expect(0, 3712, '\P{^Is_Sc=laoo}', ""); +Expect(1, 3714, '\p{Is_Sc= Laoo}', ""); +Expect(0, 3714, '\p{^Is_Sc= Laoo}', ""); +Expect(0, 3714, '\P{Is_Sc= Laoo}', ""); +Expect(1, 3714, '\P{^Is_Sc= Laoo}', ""); +Expect(0, 3712, '\p{Is_Sc= Laoo}', ""); +Expect(1, 3712, '\p{^Is_Sc= Laoo}', ""); +Expect(1, 3712, '\P{Is_Sc= Laoo}', ""); +Expect(0, 3712, '\P{^Is_Sc= Laoo}', ""); +Error('\p{Script=:=-Cyrillic}'); +Error('\P{Script=:=-Cyrillic}'); +Expect(1, 1315, '\p{Script=cyrillic}', ""); +Expect(0, 1315, '\p{^Script=cyrillic}', ""); +Expect(0, 1315, '\P{Script=cyrillic}', ""); +Expect(1, 1315, '\P{^Script=cyrillic}', ""); +Expect(0, 1023, '\p{Script=cyrillic}', ""); +Expect(1, 1023, '\p{^Script=cyrillic}', ""); +Expect(1, 1023, '\P{Script=cyrillic}', ""); +Expect(0, 1023, '\P{^Script=cyrillic}', ""); +Expect(1, 1315, '\p{Script= _Cyrillic}', ""); +Expect(0, 1315, '\p{^Script= _Cyrillic}', ""); +Expect(0, 1315, '\P{Script= _Cyrillic}', ""); +Expect(1, 1315, '\P{^Script= _Cyrillic}', ""); +Expect(0, 1023, '\p{Script= _Cyrillic}', ""); +Expect(1, 1023, '\p{^Script= _Cyrillic}', ""); +Expect(1, 1023, '\P{Script= _Cyrillic}', ""); +Expect(0, 1023, '\P{^Script= _Cyrillic}', ""); +Error('\p{Sc=Cyrl/a/}'); +Error('\P{Sc=Cyrl/a/}'); +Expect(1, 1315, '\p{Sc=cyrl}', ""); +Expect(0, 1315, '\p{^Sc=cyrl}', ""); +Expect(0, 1315, '\P{Sc=cyrl}', ""); +Expect(1, 1315, '\P{^Sc=cyrl}', ""); +Expect(0, 1023, '\p{Sc=cyrl}', ""); +Expect(1, 1023, '\p{^Sc=cyrl}', ""); +Expect(1, 1023, '\P{Sc=cyrl}', ""); +Expect(0, 1023, '\P{^Sc=cyrl}', ""); +Expect(1, 1315, '\p{Sc=--Cyrl}', ""); +Expect(0, 1315, '\p{^Sc=--Cyrl}', ""); +Expect(0, 1315, '\P{Sc=--Cyrl}', ""); +Expect(1, 1315, '\P{^Sc=--Cyrl}', ""); +Expect(0, 1023, '\p{Sc=--Cyrl}', ""); +Expect(1, 1023, '\p{^Sc=--Cyrl}', ""); +Expect(1, 1023, '\P{Sc=--Cyrl}', ""); +Expect(0, 1023, '\P{^Sc=--Cyrl}', ""); +Error('\p{Is_Script=:=_ CYRILLIC}'); +Error('\P{Is_Script=:=_ CYRILLIC}'); +Expect(1, 1315, '\p{Is_Script=cyrillic}', ""); +Expect(0, 1315, '\p{^Is_Script=cyrillic}', ""); +Expect(0, 1315, '\P{Is_Script=cyrillic}', ""); +Expect(1, 1315, '\P{^Is_Script=cyrillic}', ""); +Expect(0, 1023, '\p{Is_Script=cyrillic}', ""); +Expect(1, 1023, '\p{^Is_Script=cyrillic}', ""); +Expect(1, 1023, '\P{Is_Script=cyrillic}', ""); +Expect(0, 1023, '\P{^Is_Script=cyrillic}', ""); +Expect(1, 1315, '\p{Is_Script=__cyrillic}', ""); +Expect(0, 1315, '\p{^Is_Script=__cyrillic}', ""); +Expect(0, 1315, '\P{Is_Script=__cyrillic}', ""); +Expect(1, 1315, '\P{^Is_Script=__cyrillic}', ""); +Expect(0, 1023, '\p{Is_Script=__cyrillic}', ""); +Expect(1, 1023, '\p{^Is_Script=__cyrillic}', ""); +Expect(1, 1023, '\P{Is_Script=__cyrillic}', ""); +Expect(0, 1023, '\P{^Is_Script=__cyrillic}', ""); +Error('\p{Is_Sc=:= -CYRL}'); +Error('\P{Is_Sc=:= -CYRL}'); +Expect(1, 1315, '\p{Is_Sc: cyrl}', ""); +Expect(0, 1315, '\p{^Is_Sc: cyrl}', ""); +Expect(0, 1315, '\P{Is_Sc: cyrl}', ""); +Expect(1, 1315, '\P{^Is_Sc: cyrl}', ""); +Expect(0, 1023, '\p{Is_Sc: cyrl}', ""); +Expect(1, 1023, '\p{^Is_Sc: cyrl}', ""); +Expect(1, 1023, '\P{Is_Sc: cyrl}', ""); +Expect(0, 1023, '\P{^Is_Sc: cyrl}', ""); +Expect(1, 1315, '\p{Is_Sc=_Cyrl}', ""); +Expect(0, 1315, '\p{^Is_Sc=_Cyrl}', ""); +Expect(0, 1315, '\P{Is_Sc=_Cyrl}', ""); +Expect(1, 1315, '\P{^Is_Sc=_Cyrl}', ""); +Expect(0, 1023, '\p{Is_Sc=_Cyrl}', ""); +Expect(1, 1023, '\p{^Is_Sc=_Cyrl}', ""); +Expect(1, 1023, '\P{Is_Sc=_Cyrl}', ""); +Expect(0, 1023, '\P{^Is_Sc=_Cyrl}', ""); +Error('\p{Script=/a/-_Hiragana}'); +Error('\P{Script=/a/-_Hiragana}'); +Expect(1, 12438, '\p{Script=hiragana}', ""); +Expect(0, 12438, '\p{^Script=hiragana}', ""); +Expect(0, 12438, '\P{Script=hiragana}', ""); +Expect(1, 12438, '\P{^Script=hiragana}', ""); +Expect(0, 12352, '\p{Script=hiragana}', ""); +Expect(1, 12352, '\p{^Script=hiragana}', ""); +Expect(1, 12352, '\P{Script=hiragana}', ""); +Expect(0, 12352, '\P{^Script=hiragana}', ""); +Expect(1, 12438, '\p{Script= Hiragana}', ""); +Expect(0, 12438, '\p{^Script= Hiragana}', ""); +Expect(0, 12438, '\P{Script= Hiragana}', ""); +Expect(1, 12438, '\P{^Script= Hiragana}', ""); +Expect(0, 12352, '\p{Script= Hiragana}', ""); +Expect(1, 12352, '\p{^Script= Hiragana}', ""); +Expect(1, 12352, '\P{Script= Hiragana}', ""); +Expect(0, 12352, '\P{^Script= Hiragana}', ""); +Error('\p{Sc=/a/- HIRA}'); +Error('\P{Sc=/a/- HIRA}'); +Expect(1, 12438, '\p{Sc=hira}', ""); +Expect(0, 12438, '\p{^Sc=hira}', ""); +Expect(0, 12438, '\P{Sc=hira}', ""); +Expect(1, 12438, '\P{^Sc=hira}', ""); +Expect(0, 12352, '\p{Sc=hira}', ""); +Expect(1, 12352, '\p{^Sc=hira}', ""); +Expect(1, 12352, '\P{Sc=hira}', ""); +Expect(0, 12352, '\P{^Sc=hira}', ""); +Expect(1, 12438, '\p{Sc=_-hira}', ""); +Expect(0, 12438, '\p{^Sc=_-hira}', ""); +Expect(0, 12438, '\P{Sc=_-hira}', ""); +Expect(1, 12438, '\P{^Sc=_-hira}', ""); +Expect(0, 12352, '\p{Sc=_-hira}', ""); +Expect(1, 12352, '\p{^Sc=_-hira}', ""); +Expect(1, 12352, '\P{Sc=_-hira}', ""); +Expect(0, 12352, '\P{^Sc=_-hira}', ""); +Error('\p{Is_Script=_ Hiragana:=}'); +Error('\P{Is_Script=_ Hiragana:=}'); +Expect(1, 12438, '\p{Is_Script=hiragana}', ""); +Expect(0, 12438, '\p{^Is_Script=hiragana}', ""); +Expect(0, 12438, '\P{Is_Script=hiragana}', ""); +Expect(1, 12438, '\P{^Is_Script=hiragana}', ""); +Expect(0, 12352, '\p{Is_Script=hiragana}', ""); +Expect(1, 12352, '\p{^Is_Script=hiragana}', ""); +Expect(1, 12352, '\P{Is_Script=hiragana}', ""); +Expect(0, 12352, '\P{^Is_Script=hiragana}', ""); +Expect(1, 12438, '\p{Is_Script= -Hiragana}', ""); +Expect(0, 12438, '\p{^Is_Script= -Hiragana}', ""); +Expect(0, 12438, '\P{Is_Script= -Hiragana}', ""); +Expect(1, 12438, '\P{^Is_Script= -Hiragana}', ""); +Expect(0, 12352, '\p{Is_Script= -Hiragana}', ""); +Expect(1, 12352, '\p{^Is_Script= -Hiragana}', ""); +Expect(1, 12352, '\P{Is_Script= -Hiragana}', ""); +Expect(0, 12352, '\P{^Is_Script= -Hiragana}', ""); +Error('\p{Is_Sc=/a/hira}'); +Error('\P{Is_Sc=/a/hira}'); +Expect(1, 12438, '\p{Is_Sc=hira}', ""); +Expect(0, 12438, '\p{^Is_Sc=hira}', ""); +Expect(0, 12438, '\P{Is_Sc=hira}', ""); +Expect(1, 12438, '\P{^Is_Sc=hira}', ""); +Expect(0, 12352, '\p{Is_Sc=hira}', ""); +Expect(1, 12352, '\p{^Is_Sc=hira}', ""); +Expect(1, 12352, '\P{Is_Sc=hira}', ""); +Expect(0, 12352, '\P{^Is_Sc=hira}', ""); +Expect(1, 12438, '\p{Is_Sc= hira}', ""); +Expect(0, 12438, '\p{^Is_Sc= hira}', ""); +Expect(0, 12438, '\P{Is_Sc= hira}', ""); +Expect(1, 12438, '\P{^Is_Sc= hira}', ""); +Expect(0, 12352, '\p{Is_Sc= hira}', ""); +Expect(1, 12352, '\p{^Is_Sc= hira}', ""); +Expect(1, 12352, '\P{Is_Sc= hira}', ""); +Expect(0, 12352, '\P{^Is_Sc= hira}', ""); +Error('\p{Script=-/a/Braille}'); +Error('\P{Script=-/a/Braille}'); +Expect(1, 10495, '\p{Script=braille}', ""); +Expect(0, 10495, '\p{^Script=braille}', ""); +Expect(0, 10495, '\P{Script=braille}', ""); +Expect(1, 10495, '\P{^Script=braille}', ""); +Expect(0, 10239, '\p{Script=braille}', ""); +Expect(1, 10239, '\p{^Script=braille}', ""); +Expect(1, 10239, '\P{Script=braille}', ""); +Expect(0, 10239, '\P{^Script=braille}', ""); +Expect(1, 10495, '\p{Script=-braille}', ""); +Expect(0, 10495, '\p{^Script=-braille}', ""); +Expect(0, 10495, '\P{Script=-braille}', ""); +Expect(1, 10495, '\P{^Script=-braille}', ""); +Expect(0, 10239, '\p{Script=-braille}', ""); +Expect(1, 10239, '\p{^Script=-braille}', ""); +Expect(1, 10239, '\P{Script=-braille}', ""); +Expect(0, 10239, '\P{^Script=-braille}', ""); +Error('\p{Sc=_Brai/a/}'); +Error('\P{Sc=_Brai/a/}'); +Expect(1, 10495, '\p{Sc=brai}', ""); +Expect(0, 10495, '\p{^Sc=brai}', ""); +Expect(0, 10495, '\P{Sc=brai}', ""); +Expect(1, 10495, '\P{^Sc=brai}', ""); +Expect(0, 10239, '\p{Sc=brai}', ""); +Expect(1, 10239, '\p{^Sc=brai}', ""); +Expect(1, 10239, '\P{Sc=brai}', ""); +Expect(0, 10239, '\P{^Sc=brai}', ""); +Expect(1, 10495, '\p{Sc= brai}', ""); +Expect(0, 10495, '\p{^Sc= brai}', ""); +Expect(0, 10495, '\P{Sc= brai}', ""); +Expect(1, 10495, '\P{^Sc= brai}', ""); +Expect(0, 10239, '\p{Sc= brai}', ""); +Expect(1, 10239, '\p{^Sc= brai}', ""); +Expect(1, 10239, '\P{Sc= brai}', ""); +Expect(0, 10239, '\P{^Sc= brai}', ""); +Error('\p{Is_Script= -BRAILLE/a/}'); +Error('\P{Is_Script= -BRAILLE/a/}'); +Expect(1, 10495, '\p{Is_Script=braille}', ""); +Expect(0, 10495, '\p{^Is_Script=braille}', ""); +Expect(0, 10495, '\P{Is_Script=braille}', ""); +Expect(1, 10495, '\P{^Is_Script=braille}', ""); +Expect(0, 10239, '\p{Is_Script=braille}', ""); +Expect(1, 10239, '\p{^Is_Script=braille}', ""); +Expect(1, 10239, '\P{Is_Script=braille}', ""); +Expect(0, 10239, '\P{^Is_Script=braille}', ""); +Expect(1, 10495, '\p{Is_Script= Braille}', ""); +Expect(0, 10495, '\p{^Is_Script= Braille}', ""); +Expect(0, 10495, '\P{Is_Script= Braille}', ""); +Expect(1, 10495, '\P{^Is_Script= Braille}', ""); +Expect(0, 10239, '\p{Is_Script= Braille}', ""); +Expect(1, 10239, '\p{^Is_Script= Braille}', ""); +Expect(1, 10239, '\P{Is_Script= Braille}', ""); +Expect(0, 10239, '\P{^Is_Script= Braille}', ""); +Error('\p{Is_Sc=/a/brai}'); +Error('\P{Is_Sc=/a/brai}'); +Expect(1, 10495, '\p{Is_Sc=brai}', ""); +Expect(0, 10495, '\p{^Is_Sc=brai}', ""); +Expect(0, 10495, '\P{Is_Sc=brai}', ""); +Expect(1, 10495, '\P{^Is_Sc=brai}', ""); +Expect(0, 10239, '\p{Is_Sc=brai}', ""); +Expect(1, 10239, '\p{^Is_Sc=brai}', ""); +Expect(1, 10239, '\P{Is_Sc=brai}', ""); +Expect(0, 10239, '\P{^Is_Sc=brai}', ""); +Expect(1, 10495, '\p{Is_Sc=_ brai}', ""); +Expect(0, 10495, '\p{^Is_Sc=_ brai}', ""); +Expect(0, 10495, '\P{Is_Sc=_ brai}', ""); +Expect(1, 10495, '\P{^Is_Sc=_ brai}', ""); +Expect(0, 10239, '\p{Is_Sc=_ brai}', ""); +Expect(1, 10239, '\p{^Is_Sc=_ brai}', ""); +Expect(1, 10239, '\P{Is_Sc=_ brai}', ""); +Expect(0, 10239, '\P{^Is_Sc=_ brai}', ""); +Error('\p{Script=- Bengali/a/}'); +Error('\P{Script=- Bengali/a/}'); +Expect(1, 2435, '\p{Script=bengali}', ""); +Expect(0, 2435, '\p{^Script=bengali}', ""); +Expect(0, 2435, '\P{Script=bengali}', ""); +Expect(1, 2435, '\P{^Script=bengali}', ""); +Expect(0, 2432, '\p{Script=bengali}', ""); +Expect(1, 2432, '\p{^Script=bengali}', ""); +Expect(1, 2432, '\P{Script=bengali}', ""); +Expect(0, 2432, '\P{^Script=bengali}', ""); +Expect(1, 2435, '\p{Script= Bengali}', ""); +Expect(0, 2435, '\p{^Script= Bengali}', ""); +Expect(0, 2435, '\P{Script= Bengali}', ""); +Expect(1, 2435, '\P{^Script= Bengali}', ""); +Expect(0, 2432, '\p{Script= Bengali}', ""); +Expect(1, 2432, '\p{^Script= Bengali}', ""); +Expect(1, 2432, '\P{Script= Bengali}', ""); +Expect(0, 2432, '\P{^Script= Bengali}', ""); +Error('\p{Sc=__BENG:=}'); +Error('\P{Sc=__BENG:=}'); +Expect(1, 2435, '\p{Sc=beng}', ""); +Expect(0, 2435, '\p{^Sc=beng}', ""); +Expect(0, 2435, '\P{Sc=beng}', ""); +Expect(1, 2435, '\P{^Sc=beng}', ""); +Expect(0, 2432, '\p{Sc=beng}', ""); +Expect(1, 2432, '\p{^Sc=beng}', ""); +Expect(1, 2432, '\P{Sc=beng}', ""); +Expect(0, 2432, '\P{^Sc=beng}', ""); +Expect(1, 2435, '\p{Sc=-Beng}', ""); +Expect(0, 2435, '\p{^Sc=-Beng}', ""); +Expect(0, 2435, '\P{Sc=-Beng}', ""); +Expect(1, 2435, '\P{^Sc=-Beng}', ""); +Expect(0, 2432, '\p{Sc=-Beng}', ""); +Expect(1, 2432, '\p{^Sc=-Beng}', ""); +Expect(1, 2432, '\P{Sc=-Beng}', ""); +Expect(0, 2432, '\P{^Sc=-Beng}', ""); +Error('\p{Is_Script: :=-bengali}'); +Error('\P{Is_Script: :=-bengali}'); +Expect(1, 2435, '\p{Is_Script: bengali}', ""); +Expect(0, 2435, '\p{^Is_Script: bengali}', ""); +Expect(0, 2435, '\P{Is_Script: bengali}', ""); +Expect(1, 2435, '\P{^Is_Script: bengali}', ""); +Expect(0, 2432, '\p{Is_Script: bengali}', ""); +Expect(1, 2432, '\p{^Is_Script: bengali}', ""); +Expect(1, 2432, '\P{Is_Script: bengali}', ""); +Expect(0, 2432, '\P{^Is_Script: bengali}', ""); +Expect(1, 2435, '\p{Is_Script=--bengali}', ""); +Expect(0, 2435, '\p{^Is_Script=--bengali}', ""); +Expect(0, 2435, '\P{Is_Script=--bengali}', ""); +Expect(1, 2435, '\P{^Is_Script=--bengali}', ""); +Expect(0, 2432, '\p{Is_Script=--bengali}', ""); +Expect(1, 2432, '\p{^Is_Script=--bengali}', ""); +Expect(1, 2432, '\P{Is_Script=--bengali}', ""); +Expect(0, 2432, '\P{^Is_Script=--bengali}', ""); +Error('\p{Is_Sc= /a/Beng}'); +Error('\P{Is_Sc= /a/Beng}'); +Expect(1, 2435, '\p{Is_Sc=beng}', ""); +Expect(0, 2435, '\p{^Is_Sc=beng}', ""); +Expect(0, 2435, '\P{Is_Sc=beng}', ""); +Expect(1, 2435, '\P{^Is_Sc=beng}', ""); +Expect(0, 2432, '\p{Is_Sc=beng}', ""); +Expect(1, 2432, '\p{^Is_Sc=beng}', ""); +Expect(1, 2432, '\P{Is_Sc=beng}', ""); +Expect(0, 2432, '\P{^Is_Sc=beng}', ""); +Error('\p{Script= Kharoshthi:=}'); +Error('\P{Script= Kharoshthi:=}'); +Expect(1, 68099, '\p{Script=kharoshthi}', ""); +Expect(0, 68099, '\p{^Script=kharoshthi}', ""); +Expect(0, 68099, '\P{Script=kharoshthi}', ""); +Expect(1, 68099, '\P{^Script=kharoshthi}', ""); +Expect(0, 68095, '\p{Script=kharoshthi}', ""); +Expect(1, 68095, '\p{^Script=kharoshthi}', ""); +Expect(1, 68095, '\P{Script=kharoshthi}', ""); +Expect(0, 68095, '\P{^Script=kharoshthi}', ""); +Expect(1, 68099, '\p{Script: _-KHAROSHTHI}', ""); +Expect(0, 68099, '\p{^Script: _-KHAROSHTHI}', ""); +Expect(0, 68099, '\P{Script: _-KHAROSHTHI}', ""); +Expect(1, 68099, '\P{^Script: _-KHAROSHTHI}', ""); +Expect(0, 68095, '\p{Script: _-KHAROSHTHI}', ""); +Expect(1, 68095, '\p{^Script: _-KHAROSHTHI}', ""); +Expect(1, 68095, '\P{Script: _-KHAROSHTHI}', ""); +Expect(0, 68095, '\P{^Script: _-KHAROSHTHI}', ""); +Error('\p{Sc=/a/_khar}'); +Error('\P{Sc=/a/_khar}'); +Expect(1, 68099, '\p{Sc=khar}', ""); +Expect(0, 68099, '\p{^Sc=khar}', ""); +Expect(0, 68099, '\P{Sc=khar}', ""); +Expect(1, 68099, '\P{^Sc=khar}', ""); +Expect(0, 68095, '\p{Sc=khar}', ""); +Expect(1, 68095, '\p{^Sc=khar}', ""); +Expect(1, 68095, '\P{Sc=khar}', ""); +Expect(0, 68095, '\P{^Sc=khar}', ""); +Expect(1, 68099, '\p{Sc=_Khar}', ""); +Expect(0, 68099, '\p{^Sc=_Khar}', ""); +Expect(0, 68099, '\P{Sc=_Khar}', ""); +Expect(1, 68099, '\P{^Sc=_Khar}', ""); +Expect(0, 68095, '\p{Sc=_Khar}', ""); +Expect(1, 68095, '\p{^Sc=_Khar}', ""); +Expect(1, 68095, '\P{Sc=_Khar}', ""); +Expect(0, 68095, '\P{^Sc=_Khar}', ""); +Error('\p{Is_Script: -Kharoshthi:=}'); +Error('\P{Is_Script: -Kharoshthi:=}'); +Expect(1, 68099, '\p{Is_Script=kharoshthi}', ""); +Expect(0, 68099, '\p{^Is_Script=kharoshthi}', ""); +Expect(0, 68099, '\P{Is_Script=kharoshthi}', ""); +Expect(1, 68099, '\P{^Is_Script=kharoshthi}', ""); +Expect(0, 68095, '\p{Is_Script=kharoshthi}', ""); +Expect(1, 68095, '\p{^Is_Script=kharoshthi}', ""); +Expect(1, 68095, '\P{Is_Script=kharoshthi}', ""); +Expect(0, 68095, '\P{^Is_Script=kharoshthi}', ""); +Expect(1, 68099, '\p{Is_Script=_-KHAROSHTHI}', ""); +Expect(0, 68099, '\p{^Is_Script=_-KHAROSHTHI}', ""); +Expect(0, 68099, '\P{Is_Script=_-KHAROSHTHI}', ""); +Expect(1, 68099, '\P{^Is_Script=_-KHAROSHTHI}', ""); +Expect(0, 68095, '\p{Is_Script=_-KHAROSHTHI}', ""); +Expect(1, 68095, '\p{^Is_Script=_-KHAROSHTHI}', ""); +Expect(1, 68095, '\P{Is_Script=_-KHAROSHTHI}', ""); +Expect(0, 68095, '\P{^Is_Script=_-KHAROSHTHI}', ""); +Error('\p{Is_Sc: /a/Khar}'); +Error('\P{Is_Sc: /a/Khar}'); +Expect(1, 68099, '\p{Is_Sc=khar}', ""); +Expect(0, 68099, '\p{^Is_Sc=khar}', ""); +Expect(0, 68099, '\P{Is_Sc=khar}', ""); +Expect(1, 68099, '\P{^Is_Sc=khar}', ""); +Expect(0, 68095, '\p{Is_Sc=khar}', ""); +Expect(1, 68095, '\p{^Is_Sc=khar}', ""); +Expect(1, 68095, '\P{Is_Sc=khar}', ""); +Expect(0, 68095, '\P{^Is_Sc=khar}', ""); +Expect(1, 68099, '\p{Is_Sc=-Khar}', ""); +Expect(0, 68099, '\p{^Is_Sc=-Khar}', ""); +Expect(0, 68099, '\P{Is_Sc=-Khar}', ""); +Expect(1, 68099, '\P{^Is_Sc=-Khar}', ""); +Expect(0, 68095, '\p{Is_Sc=-Khar}', ""); +Expect(1, 68095, '\p{^Is_Sc=-Khar}', ""); +Expect(1, 68095, '\P{Is_Sc=-Khar}', ""); +Expect(0, 68095, '\P{^Is_Sc=-Khar}', ""); +Error('\p{Script= /a/lycian}'); +Error('\P{Script= /a/lycian}'); +Expect(1, 66204, '\p{Script=lycian}', ""); +Expect(0, 66204, '\p{^Script=lycian}', ""); +Expect(0, 66204, '\P{Script=lycian}', ""); +Expect(1, 66204, '\P{^Script=lycian}', ""); +Expect(0, 66175, '\p{Script=lycian}', ""); +Expect(1, 66175, '\p{^Script=lycian}', ""); +Expect(1, 66175, '\P{Script=lycian}', ""); +Expect(0, 66175, '\P{^Script=lycian}', ""); +Expect(1, 66204, '\p{Script= Lycian}', ""); +Expect(0, 66204, '\p{^Script= Lycian}', ""); +Expect(0, 66204, '\P{Script= Lycian}', ""); +Expect(1, 66204, '\P{^Script= Lycian}', ""); +Expect(0, 66175, '\p{Script= Lycian}', ""); +Expect(1, 66175, '\p{^Script= Lycian}', ""); +Expect(1, 66175, '\P{Script= Lycian}', ""); +Expect(0, 66175, '\P{^Script= Lycian}', ""); +Error('\p{Sc: -_LYCI/a/}'); +Error('\P{Sc: -_LYCI/a/}'); +Expect(1, 66204, '\p{Sc=lyci}', ""); +Expect(0, 66204, '\p{^Sc=lyci}', ""); +Expect(0, 66204, '\P{Sc=lyci}', ""); +Expect(1, 66204, '\P{^Sc=lyci}', ""); +Expect(0, 66175, '\p{Sc=lyci}', ""); +Expect(1, 66175, '\p{^Sc=lyci}', ""); +Expect(1, 66175, '\P{Sc=lyci}', ""); +Expect(0, 66175, '\P{^Sc=lyci}', ""); +Expect(1, 66204, '\p{Sc: -Lyci}', ""); +Expect(0, 66204, '\p{^Sc: -Lyci}', ""); +Expect(0, 66204, '\P{Sc: -Lyci}', ""); +Expect(1, 66204, '\P{^Sc: -Lyci}', ""); +Expect(0, 66175, '\p{Sc: -Lyci}', ""); +Expect(1, 66175, '\p{^Sc: -Lyci}', ""); +Expect(1, 66175, '\P{Sc: -Lyci}', ""); +Expect(0, 66175, '\P{^Sc: -Lyci}', ""); +Error('\p{Is_Script=_/a/Lycian}'); +Error('\P{Is_Script=_/a/Lycian}'); +Expect(1, 66204, '\p{Is_Script=lycian}', ""); +Expect(0, 66204, '\p{^Is_Script=lycian}', ""); +Expect(0, 66204, '\P{Is_Script=lycian}', ""); +Expect(1, 66204, '\P{^Is_Script=lycian}', ""); +Expect(0, 66175, '\p{Is_Script=lycian}', ""); +Expect(1, 66175, '\p{^Is_Script=lycian}', ""); +Expect(1, 66175, '\P{Is_Script=lycian}', ""); +Expect(0, 66175, '\P{^Is_Script=lycian}', ""); +Expect(1, 66204, '\p{Is_Script:_-lycian}', ""); +Expect(0, 66204, '\p{^Is_Script:_-lycian}', ""); +Expect(0, 66204, '\P{Is_Script:_-lycian}', ""); +Expect(1, 66204, '\P{^Is_Script:_-lycian}', ""); +Expect(0, 66175, '\p{Is_Script:_-lycian}', ""); +Expect(1, 66175, '\p{^Is_Script:_-lycian}', ""); +Expect(1, 66175, '\P{Is_Script:_-lycian}', ""); +Expect(0, 66175, '\P{^Is_Script:_-lycian}', ""); +Error('\p{Is_Sc= LYCI/a/}'); +Error('\P{Is_Sc= LYCI/a/}'); +Expect(1, 66204, '\p{Is_Sc=lyci}', ""); +Expect(0, 66204, '\p{^Is_Sc=lyci}', ""); +Expect(0, 66204, '\P{Is_Sc=lyci}', ""); +Expect(1, 66204, '\P{^Is_Sc=lyci}', ""); +Expect(0, 66175, '\p{Is_Sc=lyci}', ""); +Expect(1, 66175, '\p{^Is_Sc=lyci}', ""); +Expect(1, 66175, '\P{Is_Sc=lyci}', ""); +Expect(0, 66175, '\P{^Is_Sc=lyci}', ""); +Expect(1, 66204, '\p{Is_Sc=_Lyci}', ""); +Expect(0, 66204, '\p{^Is_Sc=_Lyci}', ""); +Expect(0, 66204, '\P{Is_Sc=_Lyci}', ""); +Expect(1, 66204, '\P{^Is_Sc=_Lyci}', ""); +Expect(0, 66175, '\p{Is_Sc=_Lyci}', ""); +Expect(1, 66175, '\p{^Is_Sc=_Lyci}', ""); +Expect(1, 66175, '\P{Is_Sc=_Lyci}', ""); +Expect(0, 66175, '\P{^Is_Sc=_Lyci}', ""); +Error('\p{Script=/a/_-bopomofo}'); +Error('\P{Script=/a/_-bopomofo}'); +Expect(1, 12589, '\p{Script=bopomofo}', ""); +Expect(0, 12589, '\p{^Script=bopomofo}', ""); +Expect(0, 12589, '\P{Script=bopomofo}', ""); +Expect(1, 12589, '\P{^Script=bopomofo}', ""); +Expect(0, 12548, '\p{Script=bopomofo}', ""); +Expect(1, 12548, '\p{^Script=bopomofo}', ""); +Expect(1, 12548, '\P{Script=bopomofo}', ""); +Expect(0, 12548, '\P{^Script=bopomofo}', ""); +Expect(1, 12589, '\p{Script=_bopomofo}', ""); +Expect(0, 12589, '\p{^Script=_bopomofo}', ""); +Expect(0, 12589, '\P{Script=_bopomofo}', ""); +Expect(1, 12589, '\P{^Script=_bopomofo}', ""); +Expect(0, 12548, '\p{Script=_bopomofo}', ""); +Expect(1, 12548, '\p{^Script=_bopomofo}', ""); +Expect(1, 12548, '\P{Script=_bopomofo}', ""); +Expect(0, 12548, '\P{^Script=_bopomofo}', ""); +Error('\p{Sc=:=_ Bopo}'); +Error('\P{Sc=:=_ Bopo}'); +Expect(1, 12589, '\p{Sc=bopo}', ""); +Expect(0, 12589, '\p{^Sc=bopo}', ""); +Expect(0, 12589, '\P{Sc=bopo}', ""); +Expect(1, 12589, '\P{^Sc=bopo}', ""); +Expect(0, 12548, '\p{Sc=bopo}', ""); +Expect(1, 12548, '\p{^Sc=bopo}', ""); +Expect(1, 12548, '\P{Sc=bopo}', ""); +Expect(0, 12548, '\P{^Sc=bopo}', ""); +Expect(1, 12589, '\p{Sc: _Bopo}', ""); +Expect(0, 12589, '\p{^Sc: _Bopo}', ""); +Expect(0, 12589, '\P{Sc: _Bopo}', ""); +Expect(1, 12589, '\P{^Sc: _Bopo}', ""); +Expect(0, 12548, '\p{Sc: _Bopo}', ""); +Expect(1, 12548, '\p{^Sc: _Bopo}', ""); +Expect(1, 12548, '\P{Sc: _Bopo}', ""); +Expect(0, 12548, '\P{^Sc: _Bopo}', ""); +Error('\p{Is_Script=-:=bopomofo}'); +Error('\P{Is_Script=-:=bopomofo}'); +Expect(1, 12589, '\p{Is_Script=bopomofo}', ""); +Expect(0, 12589, '\p{^Is_Script=bopomofo}', ""); +Expect(0, 12589, '\P{Is_Script=bopomofo}', ""); +Expect(1, 12589, '\P{^Is_Script=bopomofo}', ""); +Expect(0, 12548, '\p{Is_Script=bopomofo}', ""); +Expect(1, 12548, '\p{^Is_Script=bopomofo}', ""); +Expect(1, 12548, '\P{Is_Script=bopomofo}', ""); +Expect(0, 12548, '\P{^Is_Script=bopomofo}', ""); +Expect(1, 12589, '\p{Is_Script= _Bopomofo}', ""); +Expect(0, 12589, '\p{^Is_Script= _Bopomofo}', ""); +Expect(0, 12589, '\P{Is_Script= _Bopomofo}', ""); +Expect(1, 12589, '\P{^Is_Script= _Bopomofo}', ""); +Expect(0, 12548, '\p{Is_Script= _Bopomofo}', ""); +Expect(1, 12548, '\p{^Is_Script= _Bopomofo}', ""); +Expect(1, 12548, '\P{Is_Script= _Bopomofo}', ""); +Expect(0, 12548, '\P{^Is_Script= _Bopomofo}', ""); +Error('\p{Is_Sc=-:=Bopo}'); +Error('\P{Is_Sc=-:=Bopo}'); +Expect(1, 12589, '\p{Is_Sc=bopo}', ""); +Expect(0, 12589, '\p{^Is_Sc=bopo}', ""); +Expect(0, 12589, '\P{Is_Sc=bopo}', ""); +Expect(1, 12589, '\P{^Is_Sc=bopo}', ""); +Expect(0, 12548, '\p{Is_Sc=bopo}', ""); +Expect(1, 12548, '\p{^Is_Sc=bopo}', ""); +Expect(1, 12548, '\P{Is_Sc=bopo}', ""); +Expect(0, 12548, '\P{^Is_Sc=bopo}', ""); +Expect(1, 12589, '\p{Is_Sc: - Bopo}', ""); +Expect(0, 12589, '\p{^Is_Sc: - Bopo}', ""); +Expect(0, 12589, '\P{Is_Sc: - Bopo}', ""); +Expect(1, 12589, '\P{^Is_Sc: - Bopo}', ""); +Expect(0, 12548, '\p{Is_Sc: - Bopo}', ""); +Expect(1, 12548, '\p{^Is_Sc: - Bopo}', ""); +Expect(1, 12548, '\P{Is_Sc: - Bopo}', ""); +Expect(0, 12548, '\P{^Is_Sc: - Bopo}', ""); +Error('\p{Script=_ rejang:=}'); +Error('\P{Script=_ rejang:=}'); +Expect(1, 43347, '\p{Script=rejang}', ""); +Expect(0, 43347, '\p{^Script=rejang}', ""); +Expect(0, 43347, '\P{Script=rejang}', ""); +Expect(1, 43347, '\P{^Script=rejang}', ""); +Expect(0, 43311, '\p{Script=rejang}', ""); +Expect(1, 43311, '\p{^Script=rejang}', ""); +Expect(1, 43311, '\P{Script=rejang}', ""); +Expect(0, 43311, '\P{^Script=rejang}', ""); +Expect(1, 43347, '\p{Script=- rejang}', ""); +Expect(0, 43347, '\p{^Script=- rejang}', ""); +Expect(0, 43347, '\P{Script=- rejang}', ""); +Expect(1, 43347, '\P{^Script=- rejang}', ""); +Expect(0, 43311, '\p{Script=- rejang}', ""); +Expect(1, 43311, '\p{^Script=- rejang}', ""); +Expect(1, 43311, '\P{Script=- rejang}', ""); +Expect(0, 43311, '\P{^Script=- rejang}', ""); +Error('\p{Sc=:= rjng}'); +Error('\P{Sc=:= rjng}'); +Expect(1, 43347, '\p{Sc=rjng}', ""); +Expect(0, 43347, '\p{^Sc=rjng}', ""); +Expect(0, 43347, '\P{Sc=rjng}', ""); +Expect(1, 43347, '\P{^Sc=rjng}', ""); +Expect(0, 43311, '\p{Sc=rjng}', ""); +Expect(1, 43311, '\p{^Sc=rjng}', ""); +Expect(1, 43311, '\P{Sc=rjng}', ""); +Expect(0, 43311, '\P{^Sc=rjng}', ""); +Expect(1, 43347, '\p{Sc=_ RJNG}', ""); +Expect(0, 43347, '\p{^Sc=_ RJNG}', ""); +Expect(0, 43347, '\P{Sc=_ RJNG}', ""); +Expect(1, 43347, '\P{^Sc=_ RJNG}', ""); +Expect(0, 43311, '\p{Sc=_ RJNG}', ""); +Expect(1, 43311, '\p{^Sc=_ RJNG}', ""); +Expect(1, 43311, '\P{Sc=_ RJNG}', ""); +Expect(0, 43311, '\P{^Sc=_ RJNG}', ""); +Error('\p{Is_Script=_Rejang:=}'); +Error('\P{Is_Script=_Rejang:=}'); +Expect(1, 43347, '\p{Is_Script=rejang}', ""); +Expect(0, 43347, '\p{^Is_Script=rejang}', ""); +Expect(0, 43347, '\P{Is_Script=rejang}', ""); +Expect(1, 43347, '\P{^Is_Script=rejang}', ""); +Expect(0, 43311, '\p{Is_Script=rejang}', ""); +Expect(1, 43311, '\p{^Is_Script=rejang}', ""); +Expect(1, 43311, '\P{Is_Script=rejang}', ""); +Expect(0, 43311, '\P{^Is_Script=rejang}', ""); +Expect(1, 43347, '\p{Is_Script= Rejang}', ""); +Expect(0, 43347, '\p{^Is_Script= Rejang}', ""); +Expect(0, 43347, '\P{Is_Script= Rejang}', ""); +Expect(1, 43347, '\P{^Is_Script= Rejang}', ""); +Expect(0, 43311, '\p{Is_Script= Rejang}', ""); +Expect(1, 43311, '\p{^Is_Script= Rejang}', ""); +Expect(1, 43311, '\P{Is_Script= Rejang}', ""); +Expect(0, 43311, '\P{^Is_Script= Rejang}', ""); +Error('\p{Is_Sc: /a/_ Rjng}'); +Error('\P{Is_Sc: /a/_ Rjng}'); +Expect(1, 43347, '\p{Is_Sc=rjng}', ""); +Expect(0, 43347, '\p{^Is_Sc=rjng}', ""); +Expect(0, 43347, '\P{Is_Sc=rjng}', ""); +Expect(1, 43347, '\P{^Is_Sc=rjng}', ""); +Expect(0, 43311, '\p{Is_Sc=rjng}', ""); +Expect(1, 43311, '\p{^Is_Sc=rjng}', ""); +Expect(1, 43311, '\P{Is_Sc=rjng}', ""); +Expect(0, 43311, '\P{^Is_Sc=rjng}', ""); +Expect(1, 43347, '\p{Is_Sc=RJNG}', ""); +Expect(0, 43347, '\p{^Is_Sc=RJNG}', ""); +Expect(0, 43347, '\P{Is_Sc=RJNG}', ""); +Expect(1, 43347, '\P{^Is_Sc=RJNG}', ""); +Expect(0, 43311, '\p{Is_Sc=RJNG}', ""); +Expect(1, 43311, '\p{^Is_Sc=RJNG}', ""); +Expect(1, 43311, '\P{Is_Sc=RJNG}', ""); +Expect(0, 43311, '\P{^Is_Sc=RJNG}', ""); +Error('\p{Script= /a/HANUNOO}'); +Error('\P{Script= /a/HANUNOO}'); +Expect(1, 5940, '\p{Script=hanunoo}', ""); +Expect(0, 5940, '\p{^Script=hanunoo}', ""); +Expect(0, 5940, '\P{Script=hanunoo}', ""); +Expect(1, 5940, '\P{^Script=hanunoo}', ""); +Expect(0, 5919, '\p{Script=hanunoo}', ""); +Expect(1, 5919, '\p{^Script=hanunoo}', ""); +Expect(1, 5919, '\P{Script=hanunoo}', ""); +Expect(0, 5919, '\P{^Script=hanunoo}', ""); +Expect(1, 5940, '\p{Script= Hanunoo}', ""); +Expect(0, 5940, '\p{^Script= Hanunoo}', ""); +Expect(0, 5940, '\P{Script= Hanunoo}', ""); +Expect(1, 5940, '\P{^Script= Hanunoo}', ""); +Expect(0, 5919, '\p{Script= Hanunoo}', ""); +Expect(1, 5919, '\p{^Script= Hanunoo}', ""); +Expect(1, 5919, '\P{Script= Hanunoo}', ""); +Expect(0, 5919, '\P{^Script= Hanunoo}', ""); +Error('\p{Sc=:= hano}'); +Error('\P{Sc=:= hano}'); +Expect(1, 5940, '\p{Sc=hano}', ""); +Expect(0, 5940, '\p{^Sc=hano}', ""); +Expect(0, 5940, '\P{Sc=hano}', ""); +Expect(1, 5940, '\P{^Sc=hano}', ""); +Expect(0, 5919, '\p{Sc=hano}', ""); +Expect(1, 5919, '\p{^Sc=hano}', ""); +Expect(1, 5919, '\P{Sc=hano}', ""); +Expect(0, 5919, '\P{^Sc=hano}', ""); +Expect(1, 5940, '\p{Sc= _hano}', ""); +Expect(0, 5940, '\p{^Sc= _hano}', ""); +Expect(0, 5940, '\P{Sc= _hano}', ""); +Expect(1, 5940, '\P{^Sc= _hano}', ""); +Expect(0, 5919, '\p{Sc= _hano}', ""); +Expect(1, 5919, '\p{^Sc= _hano}', ""); +Expect(1, 5919, '\P{Sc= _hano}', ""); +Expect(0, 5919, '\P{^Sc= _hano}', ""); +Error('\p{Is_Script: :=--Hanunoo}'); +Error('\P{Is_Script: :=--Hanunoo}'); +Expect(1, 5940, '\p{Is_Script=hanunoo}', ""); +Expect(0, 5940, '\p{^Is_Script=hanunoo}', ""); +Expect(0, 5940, '\P{Is_Script=hanunoo}', ""); +Expect(1, 5940, '\P{^Is_Script=hanunoo}', ""); +Expect(0, 5919, '\p{Is_Script=hanunoo}', ""); +Expect(1, 5919, '\p{^Is_Script=hanunoo}', ""); +Expect(1, 5919, '\P{Is_Script=hanunoo}', ""); +Expect(0, 5919, '\P{^Is_Script=hanunoo}', ""); +Expect(1, 5940, '\p{Is_Script=_HANUNOO}', ""); +Expect(0, 5940, '\p{^Is_Script=_HANUNOO}', ""); +Expect(0, 5940, '\P{Is_Script=_HANUNOO}', ""); +Expect(1, 5940, '\P{^Is_Script=_HANUNOO}', ""); +Expect(0, 5919, '\p{Is_Script=_HANUNOO}', ""); +Expect(1, 5919, '\p{^Is_Script=_HANUNOO}', ""); +Expect(1, 5919, '\P{Is_Script=_HANUNOO}', ""); +Expect(0, 5919, '\P{^Is_Script=_HANUNOO}', ""); +Error('\p{Is_Sc=:=HANO}'); +Error('\P{Is_Sc=:=HANO}'); +Expect(1, 5940, '\p{Is_Sc=hano}', ""); +Expect(0, 5940, '\p{^Is_Sc=hano}', ""); +Expect(0, 5940, '\P{Is_Sc=hano}', ""); +Expect(1, 5940, '\P{^Is_Sc=hano}', ""); +Expect(0, 5919, '\p{Is_Sc=hano}', ""); +Expect(1, 5919, '\p{^Is_Sc=hano}', ""); +Expect(1, 5919, '\P{Is_Sc=hano}', ""); +Expect(0, 5919, '\P{^Is_Sc=hano}', ""); +Expect(1, 5940, '\p{Is_Sc=_-HANO}', ""); +Expect(0, 5940, '\p{^Is_Sc=_-HANO}', ""); +Expect(0, 5940, '\P{Is_Sc=_-HANO}', ""); +Expect(1, 5940, '\P{^Is_Sc=_-HANO}', ""); +Expect(0, 5919, '\p{Is_Sc=_-HANO}', ""); +Expect(1, 5919, '\p{^Is_Sc=_-HANO}', ""); +Expect(1, 5919, '\P{Is_Sc=_-HANO}', ""); +Expect(0, 5919, '\P{^Is_Sc=_-HANO}', ""); +Error('\p{Script= Kannada/a/}'); +Error('\P{Script= Kannada/a/}'); +Expect(1, 3203, '\p{Script=kannada}', ""); +Expect(0, 3203, '\p{^Script=kannada}', ""); +Expect(0, 3203, '\P{Script=kannada}', ""); +Expect(1, 3203, '\P{^Script=kannada}', ""); +Expect(0, 3201, '\p{Script=kannada}', ""); +Expect(1, 3201, '\p{^Script=kannada}', ""); +Expect(1, 3201, '\P{Script=kannada}', ""); +Expect(0, 3201, '\P{^Script=kannada}', ""); +Expect(1, 3203, '\p{Script=_ Kannada}', ""); +Expect(0, 3203, '\p{^Script=_ Kannada}', ""); +Expect(0, 3203, '\P{Script=_ Kannada}', ""); +Expect(1, 3203, '\P{^Script=_ Kannada}', ""); +Expect(0, 3201, '\p{Script=_ Kannada}', ""); +Expect(1, 3201, '\p{^Script=_ Kannada}', ""); +Expect(1, 3201, '\P{Script=_ Kannada}', ""); +Expect(0, 3201, '\P{^Script=_ Kannada}', ""); +Error('\p{Sc: := Knda}'); +Error('\P{Sc: := Knda}'); +Expect(1, 3203, '\p{Sc: knda}', ""); +Expect(0, 3203, '\p{^Sc: knda}', ""); +Expect(0, 3203, '\P{Sc: knda}', ""); +Expect(1, 3203, '\P{^Sc: knda}', ""); +Expect(0, 3201, '\p{Sc: knda}', ""); +Expect(1, 3201, '\p{^Sc: knda}', ""); +Expect(1, 3201, '\P{Sc: knda}', ""); +Expect(0, 3201, '\P{^Sc: knda}', ""); +Expect(1, 3203, '\p{Sc:_ Knda}', ""); +Expect(0, 3203, '\p{^Sc:_ Knda}', ""); +Expect(0, 3203, '\P{Sc:_ Knda}', ""); +Expect(1, 3203, '\P{^Sc:_ Knda}', ""); +Expect(0, 3201, '\p{Sc:_ Knda}', ""); +Expect(1, 3201, '\p{^Sc:_ Knda}', ""); +Expect(1, 3201, '\P{Sc:_ Knda}', ""); +Expect(0, 3201, '\P{^Sc:_ Knda}', ""); +Error('\p{Is_Script= kannada/a/}'); +Error('\P{Is_Script= kannada/a/}'); +Expect(1, 3203, '\p{Is_Script=kannada}', ""); +Expect(0, 3203, '\p{^Is_Script=kannada}', ""); +Expect(0, 3203, '\P{Is_Script=kannada}', ""); +Expect(1, 3203, '\P{^Is_Script=kannada}', ""); +Expect(0, 3201, '\p{Is_Script=kannada}', ""); +Expect(1, 3201, '\p{^Is_Script=kannada}', ""); +Expect(1, 3201, '\P{Is_Script=kannada}', ""); +Expect(0, 3201, '\P{^Is_Script=kannada}', ""); +Expect(1, 3203, '\p{Is_Script=- KANNADA}', ""); +Expect(0, 3203, '\p{^Is_Script=- KANNADA}', ""); +Expect(0, 3203, '\P{Is_Script=- KANNADA}', ""); +Expect(1, 3203, '\P{^Is_Script=- KANNADA}', ""); +Expect(0, 3201, '\p{Is_Script=- KANNADA}', ""); +Expect(1, 3201, '\p{^Is_Script=- KANNADA}', ""); +Expect(1, 3201, '\P{Is_Script=- KANNADA}', ""); +Expect(0, 3201, '\P{^Is_Script=- KANNADA}', ""); +Error('\p{Is_Sc= /a/KNDA}'); +Error('\P{Is_Sc= /a/KNDA}'); +Expect(1, 3203, '\p{Is_Sc=knda}', ""); +Expect(0, 3203, '\p{^Is_Sc=knda}', ""); +Expect(0, 3203, '\P{Is_Sc=knda}', ""); +Expect(1, 3203, '\P{^Is_Sc=knda}', ""); +Expect(0, 3201, '\p{Is_Sc=knda}', ""); +Expect(1, 3201, '\p{^Is_Sc=knda}', ""); +Expect(1, 3201, '\P{Is_Sc=knda}', ""); +Expect(0, 3201, '\P{^Is_Sc=knda}', ""); +Expect(1, 3203, '\p{Is_Sc= Knda}', ""); +Expect(0, 3203, '\p{^Is_Sc= Knda}', ""); +Expect(0, 3203, '\P{Is_Sc= Knda}', ""); +Expect(1, 3203, '\P{^Is_Sc= Knda}', ""); +Expect(0, 3201, '\p{Is_Sc= Knda}', ""); +Expect(1, 3201, '\p{^Is_Sc= Knda}', ""); +Expect(1, 3201, '\P{Is_Sc= Knda}', ""); +Expect(0, 3201, '\P{^Is_Sc= Knda}', ""); +Error('\p{Script=:= _khmer}'); +Error('\P{Script=:= _khmer}'); +Expect(1, 6109, '\p{Script=khmer}', ""); +Expect(0, 6109, '\p{^Script=khmer}', ""); +Expect(0, 6109, '\P{Script=khmer}', ""); +Expect(1, 6109, '\P{^Script=khmer}', ""); +Expect(0, 6015, '\p{Script=khmer}', ""); +Expect(1, 6015, '\p{^Script=khmer}', ""); +Expect(1, 6015, '\P{Script=khmer}', ""); +Expect(0, 6015, '\P{^Script=khmer}', ""); +Expect(1, 6109, '\p{Script=--KHMER}', ""); +Expect(0, 6109, '\p{^Script=--KHMER}', ""); +Expect(0, 6109, '\P{Script=--KHMER}', ""); +Expect(1, 6109, '\P{^Script=--KHMER}', ""); +Expect(0, 6015, '\p{Script=--KHMER}', ""); +Expect(1, 6015, '\p{^Script=--KHMER}', ""); +Expect(1, 6015, '\P{Script=--KHMER}', ""); +Expect(0, 6015, '\P{^Script=--KHMER}', ""); +Error('\p{Sc= Khmr:=}'); +Error('\P{Sc= Khmr:=}'); +Expect(1, 6109, '\p{Sc=khmr}', ""); +Expect(0, 6109, '\p{^Sc=khmr}', ""); +Expect(0, 6109, '\P{Sc=khmr}', ""); +Expect(1, 6109, '\P{^Sc=khmr}', ""); +Expect(0, 6015, '\p{Sc=khmr}', ""); +Expect(1, 6015, '\p{^Sc=khmr}', ""); +Expect(1, 6015, '\P{Sc=khmr}', ""); +Expect(0, 6015, '\P{^Sc=khmr}', ""); +Expect(1, 6109, '\p{Sc=-_Khmr}', ""); +Expect(0, 6109, '\p{^Sc=-_Khmr}', ""); +Expect(0, 6109, '\P{Sc=-_Khmr}', ""); +Expect(1, 6109, '\P{^Sc=-_Khmr}', ""); +Expect(0, 6015, '\p{Sc=-_Khmr}', ""); +Expect(1, 6015, '\p{^Sc=-_Khmr}', ""); +Expect(1, 6015, '\P{Sc=-_Khmr}', ""); +Expect(0, 6015, '\P{^Sc=-_Khmr}', ""); +Error('\p{Is_Script= KHMER/a/}'); +Error('\P{Is_Script= KHMER/a/}'); +Expect(1, 6109, '\p{Is_Script=khmer}', ""); +Expect(0, 6109, '\p{^Is_Script=khmer}', ""); +Expect(0, 6109, '\P{Is_Script=khmer}', ""); +Expect(1, 6109, '\P{^Is_Script=khmer}', ""); +Expect(0, 6015, '\p{Is_Script=khmer}', ""); +Expect(1, 6015, '\p{^Is_Script=khmer}', ""); +Expect(1, 6015, '\P{Is_Script=khmer}', ""); +Expect(0, 6015, '\P{^Is_Script=khmer}', ""); +Expect(1, 6109, '\p{Is_Script=- KHMER}', ""); +Expect(0, 6109, '\p{^Is_Script=- KHMER}', ""); +Expect(0, 6109, '\P{Is_Script=- KHMER}', ""); +Expect(1, 6109, '\P{^Is_Script=- KHMER}', ""); +Expect(0, 6015, '\p{Is_Script=- KHMER}', ""); +Expect(1, 6015, '\p{^Is_Script=- KHMER}', ""); +Expect(1, 6015, '\P{Is_Script=- KHMER}', ""); +Expect(0, 6015, '\P{^Is_Script=- KHMER}', ""); +Error('\p{Is_Sc=:= _khmr}'); +Error('\P{Is_Sc=:= _khmr}'); +Expect(1, 6109, '\p{Is_Sc=khmr}', ""); +Expect(0, 6109, '\p{^Is_Sc=khmr}', ""); +Expect(0, 6109, '\P{Is_Sc=khmr}', ""); +Expect(1, 6109, '\P{^Is_Sc=khmr}', ""); +Expect(0, 6015, '\p{Is_Sc=khmr}', ""); +Expect(1, 6015, '\p{^Is_Sc=khmr}', ""); +Expect(1, 6015, '\P{Is_Sc=khmr}', ""); +Expect(0, 6015, '\P{^Is_Sc=khmr}', ""); +Expect(1, 6109, '\p{Is_Sc= KHMR}', ""); +Expect(0, 6109, '\p{^Is_Sc= KHMR}', ""); +Expect(0, 6109, '\P{Is_Sc= KHMR}', ""); +Expect(1, 6109, '\P{^Is_Sc= KHMR}', ""); +Expect(0, 6015, '\p{Is_Sc= KHMR}', ""); +Expect(1, 6015, '\p{^Is_Sc= KHMR}', ""); +Expect(1, 6015, '\P{Is_Sc= KHMR}', ""); +Expect(0, 6015, '\P{^Is_Sc= KHMR}', ""); +Error('\p{Script=- Cham:=}'); +Error('\P{Script=- Cham:=}'); +Expect(1, 43574, '\p{Script:cham}', ""); +Expect(0, 43574, '\p{^Script:cham}', ""); +Expect(0, 43574, '\P{Script:cham}', ""); +Expect(1, 43574, '\P{^Script:cham}', ""); +Expect(0, 43519, '\p{Script:cham}', ""); +Expect(1, 43519, '\p{^Script:cham}', ""); +Expect(1, 43519, '\P{Script:cham}', ""); +Expect(0, 43519, '\P{^Script:cham}', ""); +Expect(1, 43574, '\p{Script= -Cham}', ""); +Expect(0, 43574, '\p{^Script= -Cham}', ""); +Expect(0, 43574, '\P{Script= -Cham}', ""); +Expect(1, 43574, '\P{^Script= -Cham}', ""); +Expect(0, 43519, '\p{Script= -Cham}', ""); +Expect(1, 43519, '\p{^Script= -Cham}', ""); +Expect(1, 43519, '\P{Script= -Cham}', ""); +Expect(0, 43519, '\P{^Script= -Cham}', ""); +Error('\p{Sc=-_Cham/a/}'); +Error('\P{Sc=-_Cham/a/}'); +Expect(1, 43574, '\p{Sc=cham}', ""); +Expect(0, 43574, '\p{^Sc=cham}', ""); +Expect(0, 43574, '\P{Sc=cham}', ""); +Expect(1, 43574, '\P{^Sc=cham}', ""); +Expect(0, 43519, '\p{Sc=cham}', ""); +Expect(1, 43519, '\p{^Sc=cham}', ""); +Expect(1, 43519, '\P{Sc=cham}', ""); +Expect(0, 43519, '\P{^Sc=cham}', ""); +Expect(1, 43574, '\p{Sc=-Cham}', ""); +Expect(0, 43574, '\p{^Sc=-Cham}', ""); +Expect(0, 43574, '\P{Sc=-Cham}', ""); +Expect(1, 43574, '\P{^Sc=-Cham}', ""); +Expect(0, 43519, '\p{Sc=-Cham}', ""); +Expect(1, 43519, '\p{^Sc=-Cham}', ""); +Expect(1, 43519, '\P{Sc=-Cham}', ""); +Expect(0, 43519, '\P{^Sc=-Cham}', ""); +Error('\p{Is_Script=_-cham:=}'); +Error('\P{Is_Script=_-cham:=}'); +Expect(1, 43574, '\p{Is_Script: cham}', ""); +Expect(0, 43574, '\p{^Is_Script: cham}', ""); +Expect(0, 43574, '\P{Is_Script: cham}', ""); +Expect(1, 43574, '\P{^Is_Script: cham}', ""); +Expect(0, 43519, '\p{Is_Script: cham}', ""); +Expect(1, 43519, '\p{^Is_Script: cham}', ""); +Expect(1, 43519, '\P{Is_Script: cham}', ""); +Expect(0, 43519, '\P{^Is_Script: cham}', ""); +Expect(1, 43574, '\p{Is_Script=- cham}', ""); +Expect(0, 43574, '\p{^Is_Script=- cham}', ""); +Expect(0, 43574, '\P{Is_Script=- cham}', ""); +Expect(1, 43574, '\P{^Is_Script=- cham}', ""); +Expect(0, 43519, '\p{Is_Script=- cham}', ""); +Expect(1, 43519, '\p{^Is_Script=- cham}', ""); +Expect(1, 43519, '\P{Is_Script=- cham}', ""); +Expect(0, 43519, '\P{^Is_Script=- cham}', ""); +Error('\p{Is_Sc=/a/CHAM}'); +Error('\P{Is_Sc=/a/CHAM}'); +Expect(1, 43574, '\p{Is_Sc=cham}', ""); +Expect(0, 43574, '\p{^Is_Sc=cham}', ""); +Expect(0, 43574, '\P{Is_Sc=cham}', ""); +Expect(1, 43574, '\P{^Is_Sc=cham}', ""); +Expect(0, 43519, '\p{Is_Sc=cham}', ""); +Expect(1, 43519, '\p{^Is_Sc=cham}', ""); +Expect(1, 43519, '\P{Is_Sc=cham}', ""); +Expect(0, 43519, '\P{^Is_Sc=cham}', ""); +Expect(1, 43574, '\p{Is_Sc= CHAM}', ""); +Expect(0, 43574, '\p{^Is_Sc= CHAM}', ""); +Expect(0, 43574, '\P{Is_Sc= CHAM}', ""); +Expect(1, 43574, '\P{^Is_Sc= CHAM}', ""); +Expect(0, 43519, '\p{Is_Sc= CHAM}', ""); +Expect(1, 43519, '\p{^Is_Sc= CHAM}', ""); +Expect(1, 43519, '\P{Is_Sc= CHAM}', ""); +Expect(0, 43519, '\P{^Is_Sc= CHAM}', ""); +Error('\p{Script=:= Tibetan}'); +Error('\P{Script=:= Tibetan}'); +Expect(1, 3911, '\p{Script=tibetan}', ""); +Expect(0, 3911, '\p{^Script=tibetan}', ""); +Expect(0, 3911, '\P{Script=tibetan}', ""); +Expect(1, 3911, '\P{^Script=tibetan}', ""); +Expect(0, 3839, '\p{Script=tibetan}', ""); +Expect(1, 3839, '\p{^Script=tibetan}', ""); +Expect(1, 3839, '\P{Script=tibetan}', ""); +Expect(0, 3839, '\P{^Script=tibetan}', ""); +Expect(1, 3911, '\p{Script=-Tibetan}', ""); +Expect(0, 3911, '\p{^Script=-Tibetan}', ""); +Expect(0, 3911, '\P{Script=-Tibetan}', ""); +Expect(1, 3911, '\P{^Script=-Tibetan}', ""); +Expect(0, 3839, '\p{Script=-Tibetan}', ""); +Expect(1, 3839, '\p{^Script=-Tibetan}', ""); +Expect(1, 3839, '\P{Script=-Tibetan}', ""); +Expect(0, 3839, '\P{^Script=-Tibetan}', ""); +Error('\p{Sc=:= tibt}'); +Error('\P{Sc=:= tibt}'); +Expect(1, 3911, '\p{Sc=tibt}', ""); +Expect(0, 3911, '\p{^Sc=tibt}', ""); +Expect(0, 3911, '\P{Sc=tibt}', ""); +Expect(1, 3911, '\P{^Sc=tibt}', ""); +Expect(0, 3839, '\p{Sc=tibt}', ""); +Expect(1, 3839, '\p{^Sc=tibt}', ""); +Expect(1, 3839, '\P{Sc=tibt}', ""); +Expect(0, 3839, '\P{^Sc=tibt}', ""); +Expect(1, 3911, '\p{Sc= _Tibt}', ""); +Expect(0, 3911, '\p{^Sc= _Tibt}', ""); +Expect(0, 3911, '\P{Sc= _Tibt}', ""); +Expect(1, 3911, '\P{^Sc= _Tibt}', ""); +Expect(0, 3839, '\p{Sc= _Tibt}', ""); +Expect(1, 3839, '\p{^Sc= _Tibt}', ""); +Expect(1, 3839, '\P{Sc= _Tibt}', ""); +Expect(0, 3839, '\P{^Sc= _Tibt}', ""); +Error('\p{Is_Script= -tibetan:=}'); +Error('\P{Is_Script= -tibetan:=}'); +Expect(1, 3911, '\p{Is_Script=tibetan}', ""); +Expect(0, 3911, '\p{^Is_Script=tibetan}', ""); +Expect(0, 3911, '\P{Is_Script=tibetan}', ""); +Expect(1, 3911, '\P{^Is_Script=tibetan}', ""); +Expect(0, 3839, '\p{Is_Script=tibetan}', ""); +Expect(1, 3839, '\p{^Is_Script=tibetan}', ""); +Expect(1, 3839, '\P{Is_Script=tibetan}', ""); +Expect(0, 3839, '\P{^Is_Script=tibetan}', ""); +Expect(1, 3911, '\p{Is_Script=--Tibetan}', ""); +Expect(0, 3911, '\p{^Is_Script=--Tibetan}', ""); +Expect(0, 3911, '\P{Is_Script=--Tibetan}', ""); +Expect(1, 3911, '\P{^Is_Script=--Tibetan}', ""); +Expect(0, 3839, '\p{Is_Script=--Tibetan}', ""); +Expect(1, 3839, '\p{^Is_Script=--Tibetan}', ""); +Expect(1, 3839, '\P{Is_Script=--Tibetan}', ""); +Expect(0, 3839, '\P{^Is_Script=--Tibetan}', ""); +Error('\p{Is_Sc= TIBT:=}'); +Error('\P{Is_Sc= TIBT:=}'); +Expect(1, 3911, '\p{Is_Sc=tibt}', ""); +Expect(0, 3911, '\p{^Is_Sc=tibt}', ""); +Expect(0, 3911, '\P{Is_Sc=tibt}', ""); +Expect(1, 3911, '\P{^Is_Sc=tibt}', ""); +Expect(0, 3839, '\p{Is_Sc=tibt}', ""); +Expect(1, 3839, '\p{^Is_Sc=tibt}', ""); +Expect(1, 3839, '\P{Is_Sc=tibt}', ""); +Expect(0, 3839, '\P{^Is_Sc=tibt}', ""); +Expect(1, 3911, '\p{Is_Sc= TIBT}', ""); +Expect(0, 3911, '\p{^Is_Sc= TIBT}', ""); +Expect(0, 3911, '\P{Is_Sc= TIBT}', ""); +Expect(1, 3911, '\P{^Is_Sc= TIBT}', ""); +Expect(0, 3839, '\p{Is_Sc= TIBT}', ""); +Expect(1, 3839, '\p{^Is_Sc= TIBT}', ""); +Expect(1, 3839, '\P{Is_Sc= TIBT}', ""); +Expect(0, 3839, '\P{^Is_Sc= TIBT}', ""); +Error('\p{Script=-:=Ogham}'); +Error('\P{Script=-:=Ogham}'); +Expect(1, 5788, '\p{Script=ogham}', ""); +Expect(0, 5788, '\p{^Script=ogham}', ""); +Expect(0, 5788, '\P{Script=ogham}', ""); +Expect(1, 5788, '\P{^Script=ogham}', ""); +Expect(0, 5759, '\p{Script=ogham}', ""); +Expect(1, 5759, '\p{^Script=ogham}', ""); +Expect(1, 5759, '\P{Script=ogham}', ""); +Expect(0, 5759, '\P{^Script=ogham}', ""); +Expect(1, 5788, '\p{Script=__Ogham}', ""); +Expect(0, 5788, '\p{^Script=__Ogham}', ""); +Expect(0, 5788, '\P{Script=__Ogham}', ""); +Expect(1, 5788, '\P{^Script=__Ogham}', ""); +Expect(0, 5759, '\p{Script=__Ogham}', ""); +Expect(1, 5759, '\p{^Script=__Ogham}', ""); +Expect(1, 5759, '\P{Script=__Ogham}', ""); +Expect(0, 5759, '\P{^Script=__Ogham}', ""); +Error('\p{Sc=:=--Ogam}'); +Error('\P{Sc=:=--Ogam}'); +Expect(1, 5788, '\p{Sc=ogam}', ""); +Expect(0, 5788, '\p{^Sc=ogam}', ""); +Expect(0, 5788, '\P{Sc=ogam}', ""); +Expect(1, 5788, '\P{^Sc=ogam}', ""); +Expect(0, 5759, '\p{Sc=ogam}', ""); +Expect(1, 5759, '\p{^Sc=ogam}', ""); +Expect(1, 5759, '\P{Sc=ogam}', ""); +Expect(0, 5759, '\P{^Sc=ogam}', ""); +Expect(1, 5788, '\p{Sc= Ogam}', ""); +Expect(0, 5788, '\p{^Sc= Ogam}', ""); +Expect(0, 5788, '\P{Sc= Ogam}', ""); +Expect(1, 5788, '\P{^Sc= Ogam}', ""); +Expect(0, 5759, '\p{Sc= Ogam}', ""); +Expect(1, 5759, '\p{^Sc= Ogam}', ""); +Expect(1, 5759, '\P{Sc= Ogam}', ""); +Expect(0, 5759, '\P{^Sc= Ogam}', ""); +Error('\p{Is_Script=:=OGHAM}'); +Error('\P{Is_Script=:=OGHAM}'); +Expect(1, 5788, '\p{Is_Script=ogham}', ""); +Expect(0, 5788, '\p{^Is_Script=ogham}', ""); +Expect(0, 5788, '\P{Is_Script=ogham}', ""); +Expect(1, 5788, '\P{^Is_Script=ogham}', ""); +Expect(0, 5759, '\p{Is_Script=ogham}', ""); +Expect(1, 5759, '\p{^Is_Script=ogham}', ""); +Expect(1, 5759, '\P{Is_Script=ogham}', ""); +Expect(0, 5759, '\P{^Is_Script=ogham}', ""); +Expect(1, 5788, '\p{Is_Script=-_OGHAM}', ""); +Expect(0, 5788, '\p{^Is_Script=-_OGHAM}', ""); +Expect(0, 5788, '\P{Is_Script=-_OGHAM}', ""); +Expect(1, 5788, '\P{^Is_Script=-_OGHAM}', ""); +Expect(0, 5759, '\p{Is_Script=-_OGHAM}', ""); +Expect(1, 5759, '\p{^Is_Script=-_OGHAM}', ""); +Expect(1, 5759, '\P{Is_Script=-_OGHAM}', ""); +Expect(0, 5759, '\P{^Is_Script=-_OGHAM}', ""); +Error('\p{Is_Sc= _Ogam/a/}'); +Error('\P{Is_Sc= _Ogam/a/}'); +Expect(1, 5788, '\p{Is_Sc: ogam}', ""); +Expect(0, 5788, '\p{^Is_Sc: ogam}', ""); +Expect(0, 5788, '\P{Is_Sc: ogam}', ""); +Expect(1, 5788, '\P{^Is_Sc: ogam}', ""); +Expect(0, 5759, '\p{Is_Sc: ogam}', ""); +Expect(1, 5759, '\p{^Is_Sc: ogam}', ""); +Expect(1, 5759, '\P{Is_Sc: ogam}', ""); +Expect(0, 5759, '\P{^Is_Sc: ogam}', ""); +Expect(1, 5788, '\p{Is_Sc=--Ogam}', ""); +Expect(0, 5788, '\p{^Is_Sc=--Ogam}', ""); +Expect(0, 5788, '\P{Is_Sc=--Ogam}', ""); +Expect(1, 5788, '\P{^Is_Sc=--Ogam}', ""); +Expect(0, 5759, '\p{Is_Sc=--Ogam}', ""); +Expect(1, 5759, '\p{^Is_Sc=--Ogam}', ""); +Expect(1, 5759, '\P{Is_Sc=--Ogam}', ""); +Expect(0, 5759, '\P{^Is_Sc=--Ogam}', ""); +Error('\p{Script=/a/Malayalam}'); +Error('\P{Script=/a/Malayalam}'); +Expect(1, 3331, '\p{Script: malayalam}', ""); +Expect(0, 3331, '\p{^Script: malayalam}', ""); +Expect(0, 3331, '\P{Script: malayalam}', ""); +Expect(1, 3331, '\P{^Script: malayalam}', ""); +Expect(0, 3329, '\p{Script: malayalam}', ""); +Expect(1, 3329, '\p{^Script: malayalam}', ""); +Expect(1, 3329, '\P{Script: malayalam}', ""); +Expect(0, 3329, '\P{^Script: malayalam}', ""); +Expect(1, 3331, '\p{Script= -Malayalam}', ""); +Expect(0, 3331, '\p{^Script= -Malayalam}', ""); +Expect(0, 3331, '\P{Script= -Malayalam}', ""); +Expect(1, 3331, '\P{^Script= -Malayalam}', ""); +Expect(0, 3329, '\p{Script= -Malayalam}', ""); +Expect(1, 3329, '\p{^Script= -Malayalam}', ""); +Expect(1, 3329, '\P{Script= -Malayalam}', ""); +Expect(0, 3329, '\P{^Script= -Malayalam}', ""); +Error('\p{Sc=:= mlym}'); +Error('\P{Sc=:= mlym}'); +Expect(1, 3331, '\p{Sc=mlym}', ""); +Expect(0, 3331, '\p{^Sc=mlym}', ""); +Expect(0, 3331, '\P{Sc=mlym}', ""); +Expect(1, 3331, '\P{^Sc=mlym}', ""); +Expect(0, 3329, '\p{Sc=mlym}', ""); +Expect(1, 3329, '\p{^Sc=mlym}', ""); +Expect(1, 3329, '\P{Sc=mlym}', ""); +Expect(0, 3329, '\P{^Sc=mlym}', ""); +Expect(1, 3331, '\p{Sc= Mlym}', ""); +Expect(0, 3331, '\p{^Sc= Mlym}', ""); +Expect(0, 3331, '\P{Sc= Mlym}', ""); +Expect(1, 3331, '\P{^Sc= Mlym}', ""); +Expect(0, 3329, '\p{Sc= Mlym}', ""); +Expect(1, 3329, '\p{^Sc= Mlym}', ""); +Expect(1, 3329, '\P{Sc= Mlym}', ""); +Expect(0, 3329, '\P{^Sc= Mlym}', ""); +Error('\p{Is_Script=/a/-malayalam}'); +Error('\P{Is_Script=/a/-malayalam}'); +Expect(1, 3331, '\p{Is_Script=malayalam}', ""); +Expect(0, 3331, '\p{^Is_Script=malayalam}', ""); +Expect(0, 3331, '\P{Is_Script=malayalam}', ""); +Expect(1, 3331, '\P{^Is_Script=malayalam}', ""); +Expect(0, 3329, '\p{Is_Script=malayalam}', ""); +Expect(1, 3329, '\p{^Is_Script=malayalam}', ""); +Expect(1, 3329, '\P{Is_Script=malayalam}', ""); +Expect(0, 3329, '\P{^Is_Script=malayalam}', ""); +Expect(1, 3331, '\p{Is_Script= Malayalam}', ""); +Expect(0, 3331, '\p{^Is_Script= Malayalam}', ""); +Expect(0, 3331, '\P{Is_Script= Malayalam}', ""); +Expect(1, 3331, '\P{^Is_Script= Malayalam}', ""); +Expect(0, 3329, '\p{Is_Script= Malayalam}', ""); +Expect(1, 3329, '\p{^Is_Script= Malayalam}', ""); +Expect(1, 3329, '\P{Is_Script= Malayalam}', ""); +Expect(0, 3329, '\P{^Is_Script= Malayalam}', ""); +Error('\p{Is_Sc=--Mlym/a/}'); +Error('\P{Is_Sc=--Mlym/a/}'); +Expect(1, 3331, '\p{Is_Sc=mlym}', ""); +Expect(0, 3331, '\p{^Is_Sc=mlym}', ""); +Expect(0, 3331, '\P{Is_Sc=mlym}', ""); +Expect(1, 3331, '\P{^Is_Sc=mlym}', ""); +Expect(0, 3329, '\p{Is_Sc=mlym}', ""); +Expect(1, 3329, '\p{^Is_Sc=mlym}', ""); +Expect(1, 3329, '\P{Is_Sc=mlym}', ""); +Expect(0, 3329, '\P{^Is_Sc=mlym}', ""); +Expect(1, 3331, '\p{Is_Sc= _Mlym}', ""); +Expect(0, 3331, '\p{^Is_Sc= _Mlym}', ""); +Expect(0, 3331, '\P{Is_Sc= _Mlym}', ""); +Expect(1, 3331, '\P{^Is_Sc= _Mlym}', ""); +Expect(0, 3329, '\p{Is_Sc= _Mlym}', ""); +Expect(1, 3329, '\p{^Is_Sc= _Mlym}', ""); +Expect(1, 3329, '\P{Is_Sc= _Mlym}', ""); +Expect(0, 3329, '\P{^Is_Sc= _Mlym}', ""); +Error('\p{Script=:=OldPersian}'); +Error('\P{Script=:=OldPersian}'); +Expect(1, 66499, '\p{Script=oldpersian}', ""); +Expect(0, 66499, '\p{^Script=oldpersian}', ""); +Expect(0, 66499, '\P{Script=oldpersian}', ""); +Expect(1, 66499, '\P{^Script=oldpersian}', ""); +Expect(0, 66463, '\p{Script=oldpersian}', ""); +Expect(1, 66463, '\p{^Script=oldpersian}', ""); +Expect(1, 66463, '\P{Script=oldpersian}', ""); +Expect(0, 66463, '\P{^Script=oldpersian}', ""); +Expect(1, 66499, '\p{Script= OLD-PERSIAN}', ""); +Expect(0, 66499, '\p{^Script= OLD-PERSIAN}', ""); +Expect(0, 66499, '\P{Script= OLD-PERSIAN}', ""); +Expect(1, 66499, '\P{^Script= OLD-PERSIAN}', ""); +Expect(0, 66463, '\p{Script= OLD-PERSIAN}', ""); +Expect(1, 66463, '\p{^Script= OLD-PERSIAN}', ""); +Expect(1, 66463, '\P{Script= OLD-PERSIAN}', ""); +Expect(0, 66463, '\P{^Script= OLD-PERSIAN}', ""); +Error('\p{Sc= Xpeo:=}'); +Error('\P{Sc= Xpeo:=}'); +Expect(1, 66499, '\p{Sc=xpeo}', ""); +Expect(0, 66499, '\p{^Sc=xpeo}', ""); +Expect(0, 66499, '\P{Sc=xpeo}', ""); +Expect(1, 66499, '\P{^Sc=xpeo}', ""); +Expect(0, 66463, '\p{Sc=xpeo}', ""); +Expect(1, 66463, '\p{^Sc=xpeo}', ""); +Expect(1, 66463, '\P{Sc=xpeo}', ""); +Expect(0, 66463, '\P{^Sc=xpeo}', ""); +Expect(1, 66499, '\p{Sc= xpeo}', ""); +Expect(0, 66499, '\p{^Sc= xpeo}', ""); +Expect(0, 66499, '\P{Sc= xpeo}', ""); +Expect(1, 66499, '\P{^Sc= xpeo}', ""); +Expect(0, 66463, '\p{Sc= xpeo}', ""); +Expect(1, 66463, '\p{^Sc= xpeo}', ""); +Expect(1, 66463, '\P{Sc= xpeo}', ""); +Expect(0, 66463, '\P{^Sc= xpeo}', ""); +Error('\p{Is_Script= old PERSIAN/a/}'); +Error('\P{Is_Script= old PERSIAN/a/}'); +Expect(1, 66499, '\p{Is_Script=oldpersian}', ""); +Expect(0, 66499, '\p{^Is_Script=oldpersian}', ""); +Expect(0, 66499, '\P{Is_Script=oldpersian}', ""); +Expect(1, 66499, '\P{^Is_Script=oldpersian}', ""); +Expect(0, 66463, '\p{Is_Script=oldpersian}', ""); +Expect(1, 66463, '\p{^Is_Script=oldpersian}', ""); +Expect(1, 66463, '\P{Is_Script=oldpersian}', ""); +Expect(0, 66463, '\P{^Is_Script=oldpersian}', ""); +Expect(1, 66499, '\p{Is_Script=_old Persian}', ""); +Expect(0, 66499, '\p{^Is_Script=_old Persian}', ""); +Expect(0, 66499, '\P{Is_Script=_old Persian}', ""); +Expect(1, 66499, '\P{^Is_Script=_old Persian}', ""); +Expect(0, 66463, '\p{Is_Script=_old Persian}', ""); +Expect(1, 66463, '\p{^Is_Script=_old Persian}', ""); +Expect(1, 66463, '\P{Is_Script=_old Persian}', ""); +Expect(0, 66463, '\P{^Is_Script=_old Persian}', ""); +Error('\p{Is_Sc=:=- Xpeo}'); +Error('\P{Is_Sc=:=- Xpeo}'); +Expect(1, 66499, '\p{Is_Sc=xpeo}', ""); +Expect(0, 66499, '\p{^Is_Sc=xpeo}', ""); +Expect(0, 66499, '\P{Is_Sc=xpeo}', ""); +Expect(1, 66499, '\P{^Is_Sc=xpeo}', ""); +Expect(0, 66463, '\p{Is_Sc=xpeo}', ""); +Expect(1, 66463, '\p{^Is_Sc=xpeo}', ""); +Expect(1, 66463, '\P{Is_Sc=xpeo}', ""); +Expect(0, 66463, '\P{^Is_Sc=xpeo}', ""); +Expect(1, 66499, '\p{Is_Sc: _xpeo}', ""); +Expect(0, 66499, '\p{^Is_Sc: _xpeo}', ""); +Expect(0, 66499, '\P{Is_Sc: _xpeo}', ""); +Expect(1, 66499, '\P{^Is_Sc: _xpeo}', ""); +Expect(0, 66463, '\p{Is_Sc: _xpeo}', ""); +Expect(1, 66463, '\p{^Is_Sc: _xpeo}', ""); +Expect(1, 66463, '\P{Is_Sc: _xpeo}', ""); +Expect(0, 66463, '\P{^Is_Sc: _xpeo}', ""); +Error('\p{Script= Myanmar:=}'); +Error('\P{Script= Myanmar:=}'); +Expect(1, 4249, '\p{Script=myanmar}', ""); +Expect(0, 4249, '\p{^Script=myanmar}', ""); +Expect(0, 4249, '\P{Script=myanmar}', ""); +Expect(1, 4249, '\P{^Script=myanmar}', ""); +Expect(0, 4095, '\p{Script=myanmar}', ""); +Expect(1, 4095, '\p{^Script=myanmar}', ""); +Expect(1, 4095, '\P{Script=myanmar}', ""); +Expect(0, 4095, '\P{^Script=myanmar}', ""); +Expect(1, 4249, '\p{Script= Myanmar}', ""); +Expect(0, 4249, '\p{^Script= Myanmar}', ""); +Expect(0, 4249, '\P{Script= Myanmar}', ""); +Expect(1, 4249, '\P{^Script= Myanmar}', ""); +Expect(0, 4095, '\p{Script= Myanmar}', ""); +Expect(1, 4095, '\p{^Script= Myanmar}', ""); +Expect(1, 4095, '\P{Script= Myanmar}', ""); +Expect(0, 4095, '\P{^Script= Myanmar}', ""); +Error('\p{Sc=/a/- mymr}'); +Error('\P{Sc=/a/- mymr}'); +Expect(1, 4249, '\p{Sc=mymr}', ""); +Expect(0, 4249, '\p{^Sc=mymr}', ""); +Expect(0, 4249, '\P{Sc=mymr}', ""); +Expect(1, 4249, '\P{^Sc=mymr}', ""); +Expect(0, 4095, '\p{Sc=mymr}', ""); +Expect(1, 4095, '\p{^Sc=mymr}', ""); +Expect(1, 4095, '\P{Sc=mymr}', ""); +Expect(0, 4095, '\P{^Sc=mymr}', ""); +Expect(1, 4249, '\p{Sc: Mymr}', ""); +Expect(0, 4249, '\p{^Sc: Mymr}', ""); +Expect(0, 4249, '\P{Sc: Mymr}', ""); +Expect(1, 4249, '\P{^Sc: Mymr}', ""); +Expect(0, 4095, '\p{Sc: Mymr}', ""); +Expect(1, 4095, '\p{^Sc: Mymr}', ""); +Expect(1, 4095, '\P{Sc: Mymr}', ""); +Expect(0, 4095, '\P{^Sc: Mymr}', ""); +Error('\p{Is_Script=/a/_MYANMAR}'); +Error('\P{Is_Script=/a/_MYANMAR}'); +Expect(1, 4249, '\p{Is_Script=myanmar}', ""); +Expect(0, 4249, '\p{^Is_Script=myanmar}', ""); +Expect(0, 4249, '\P{Is_Script=myanmar}', ""); +Expect(1, 4249, '\P{^Is_Script=myanmar}', ""); +Expect(0, 4095, '\p{Is_Script=myanmar}', ""); +Expect(1, 4095, '\p{^Is_Script=myanmar}', ""); +Expect(1, 4095, '\P{Is_Script=myanmar}', ""); +Expect(0, 4095, '\P{^Is_Script=myanmar}', ""); +Expect(1, 4249, '\p{Is_Script= _myanmar}', ""); +Expect(0, 4249, '\p{^Is_Script= _myanmar}', ""); +Expect(0, 4249, '\P{Is_Script= _myanmar}', ""); +Expect(1, 4249, '\P{^Is_Script= _myanmar}', ""); +Expect(0, 4095, '\p{Is_Script= _myanmar}', ""); +Expect(1, 4095, '\p{^Is_Script= _myanmar}', ""); +Expect(1, 4095, '\P{Is_Script= _myanmar}', ""); +Expect(0, 4095, '\P{^Is_Script= _myanmar}', ""); +Error('\p{Is_Sc=-:=Mymr}'); +Error('\P{Is_Sc=-:=Mymr}'); +Expect(1, 4249, '\p{Is_Sc=mymr}', ""); +Expect(0, 4249, '\p{^Is_Sc=mymr}', ""); +Expect(0, 4249, '\P{Is_Sc=mymr}', ""); +Expect(1, 4249, '\P{^Is_Sc=mymr}', ""); +Expect(0, 4095, '\p{Is_Sc=mymr}', ""); +Expect(1, 4095, '\p{^Is_Sc=mymr}', ""); +Expect(1, 4095, '\P{Is_Sc=mymr}', ""); +Expect(0, 4095, '\P{^Is_Sc=mymr}', ""); +Expect(1, 4249, '\p{Is_Sc:-Mymr}', ""); +Expect(0, 4249, '\p{^Is_Sc:-Mymr}', ""); +Expect(0, 4249, '\P{Is_Sc:-Mymr}', ""); +Expect(1, 4249, '\P{^Is_Sc:-Mymr}', ""); +Expect(0, 4095, '\p{Is_Sc:-Mymr}', ""); +Expect(1, 4095, '\p{^Is_Sc:-Mymr}', ""); +Expect(1, 4095, '\P{Is_Sc:-Mymr}', ""); +Expect(0, 4095, '\P{^Is_Sc:-Mymr}', ""); +Error('\p{Script= :=Osmanya}'); +Error('\P{Script= :=Osmanya}'); +Expect(1, 66717, '\p{Script=osmanya}', ""); +Expect(0, 66717, '\p{^Script=osmanya}', ""); +Expect(0, 66717, '\P{Script=osmanya}', ""); +Expect(1, 66717, '\P{^Script=osmanya}', ""); +Expect(0, 66687, '\p{Script=osmanya}', ""); +Expect(1, 66687, '\p{^Script=osmanya}', ""); +Expect(1, 66687, '\P{Script=osmanya}', ""); +Expect(0, 66687, '\P{^Script=osmanya}', ""); +Expect(1, 66717, '\p{Script=_-osmanya}', ""); +Expect(0, 66717, '\p{^Script=_-osmanya}', ""); +Expect(0, 66717, '\P{Script=_-osmanya}', ""); +Expect(1, 66717, '\P{^Script=_-osmanya}', ""); +Expect(0, 66687, '\p{Script=_-osmanya}', ""); +Expect(1, 66687, '\p{^Script=_-osmanya}', ""); +Expect(1, 66687, '\P{Script=_-osmanya}', ""); +Expect(0, 66687, '\P{^Script=_-osmanya}', ""); +Error('\p{Sc=/a/ -osma}'); +Error('\P{Sc=/a/ -osma}'); +Expect(1, 66717, '\p{Sc=osma}', ""); +Expect(0, 66717, '\p{^Sc=osma}', ""); +Expect(0, 66717, '\P{Sc=osma}', ""); +Expect(1, 66717, '\P{^Sc=osma}', ""); +Expect(0, 66687, '\p{Sc=osma}', ""); +Expect(1, 66687, '\p{^Sc=osma}', ""); +Expect(1, 66687, '\P{Sc=osma}', ""); +Expect(0, 66687, '\P{^Sc=osma}', ""); +Expect(1, 66717, '\p{Sc=_-Osma}', ""); +Expect(0, 66717, '\p{^Sc=_-Osma}', ""); +Expect(0, 66717, '\P{Sc=_-Osma}', ""); +Expect(1, 66717, '\P{^Sc=_-Osma}', ""); +Expect(0, 66687, '\p{Sc=_-Osma}', ""); +Expect(1, 66687, '\p{^Sc=_-Osma}', ""); +Expect(1, 66687, '\P{Sc=_-Osma}', ""); +Expect(0, 66687, '\P{^Sc=_-Osma}', ""); +Error('\p{Is_Script= -Osmanya:=}'); +Error('\P{Is_Script= -Osmanya:=}'); +Expect(1, 66717, '\p{Is_Script:osmanya}', ""); +Expect(0, 66717, '\p{^Is_Script:osmanya}', ""); +Expect(0, 66717, '\P{Is_Script:osmanya}', ""); +Expect(1, 66717, '\P{^Is_Script:osmanya}', ""); +Expect(0, 66687, '\p{Is_Script:osmanya}', ""); +Expect(1, 66687, '\p{^Is_Script:osmanya}', ""); +Expect(1, 66687, '\P{Is_Script:osmanya}', ""); +Expect(0, 66687, '\P{^Is_Script:osmanya}', ""); +Expect(1, 66717, '\p{Is_Script= Osmanya}', ""); +Expect(0, 66717, '\p{^Is_Script= Osmanya}', ""); +Expect(0, 66717, '\P{Is_Script= Osmanya}', ""); +Expect(1, 66717, '\P{^Is_Script= Osmanya}', ""); +Expect(0, 66687, '\p{Is_Script= Osmanya}', ""); +Expect(1, 66687, '\p{^Is_Script= Osmanya}', ""); +Expect(1, 66687, '\P{Is_Script= Osmanya}', ""); +Expect(0, 66687, '\P{^Is_Script= Osmanya}', ""); +Error('\p{Is_Sc=:=--OSMA}'); +Error('\P{Is_Sc=:=--OSMA}'); +Expect(1, 66717, '\p{Is_Sc=osma}', ""); +Expect(0, 66717, '\p{^Is_Sc=osma}', ""); +Expect(0, 66717, '\P{Is_Sc=osma}', ""); +Expect(1, 66717, '\P{^Is_Sc=osma}', ""); +Expect(0, 66687, '\p{Is_Sc=osma}', ""); +Expect(1, 66687, '\p{^Is_Sc=osma}', ""); +Expect(1, 66687, '\P{Is_Sc=osma}', ""); +Expect(0, 66687, '\P{^Is_Sc=osma}', ""); +Expect(1, 66717, '\p{Is_Sc=- OSMA}', ""); +Expect(0, 66717, '\p{^Is_Sc=- OSMA}', ""); +Expect(0, 66717, '\P{Is_Sc=- OSMA}', ""); +Expect(1, 66717, '\P{^Is_Sc=- OSMA}', ""); +Expect(0, 66687, '\p{Is_Sc=- OSMA}', ""); +Expect(1, 66687, '\p{^Is_Sc=- OSMA}', ""); +Expect(1, 66687, '\P{Is_Sc=- OSMA}', ""); +Expect(0, 66687, '\P{^Is_Sc=- OSMA}', ""); +Error('\p{Script= _TAGALOG/a/}'); +Error('\P{Script= _TAGALOG/a/}'); +Expect(1, 5900, '\p{Script=tagalog}', ""); +Expect(0, 5900, '\p{^Script=tagalog}', ""); +Expect(0, 5900, '\P{Script=tagalog}', ""); +Expect(1, 5900, '\P{^Script=tagalog}', ""); +Expect(0, 5887, '\p{Script=tagalog}', ""); +Expect(1, 5887, '\p{^Script=tagalog}', ""); +Expect(1, 5887, '\P{Script=tagalog}', ""); +Expect(0, 5887, '\P{^Script=tagalog}', ""); +Expect(1, 5900, '\p{Script=- tagalog}', ""); +Expect(0, 5900, '\p{^Script=- tagalog}', ""); +Expect(0, 5900, '\P{Script=- tagalog}', ""); +Expect(1, 5900, '\P{^Script=- tagalog}', ""); +Expect(0, 5887, '\p{Script=- tagalog}', ""); +Expect(1, 5887, '\p{^Script=- tagalog}', ""); +Expect(1, 5887, '\P{Script=- tagalog}', ""); +Expect(0, 5887, '\P{^Script=- tagalog}', ""); +Error('\p{Sc= -tglg/a/}'); +Error('\P{Sc= -tglg/a/}'); +Expect(1, 5900, '\p{Sc=tglg}', ""); +Expect(0, 5900, '\p{^Sc=tglg}', ""); +Expect(0, 5900, '\P{Sc=tglg}', ""); +Expect(1, 5900, '\P{^Sc=tglg}', ""); +Expect(0, 5887, '\p{Sc=tglg}', ""); +Expect(1, 5887, '\p{^Sc=tglg}', ""); +Expect(1, 5887, '\P{Sc=tglg}', ""); +Expect(0, 5887, '\P{^Sc=tglg}', ""); +Expect(1, 5900, '\p{Sc: _tglg}', ""); +Expect(0, 5900, '\p{^Sc: _tglg}', ""); +Expect(0, 5900, '\P{Sc: _tglg}', ""); +Expect(1, 5900, '\P{^Sc: _tglg}', ""); +Expect(0, 5887, '\p{Sc: _tglg}', ""); +Expect(1, 5887, '\p{^Sc: _tglg}', ""); +Expect(1, 5887, '\P{Sc: _tglg}', ""); +Expect(0, 5887, '\P{^Sc: _tglg}', ""); +Error('\p{Is_Script: := tagalog}'); +Error('\P{Is_Script: := tagalog}'); +Expect(1, 5900, '\p{Is_Script=tagalog}', ""); +Expect(0, 5900, '\p{^Is_Script=tagalog}', ""); +Expect(0, 5900, '\P{Is_Script=tagalog}', ""); +Expect(1, 5900, '\P{^Is_Script=tagalog}', ""); +Expect(0, 5887, '\p{Is_Script=tagalog}', ""); +Expect(1, 5887, '\p{^Is_Script=tagalog}', ""); +Expect(1, 5887, '\P{Is_Script=tagalog}', ""); +Expect(0, 5887, '\P{^Is_Script=tagalog}', ""); +Expect(1, 5900, '\p{Is_Script=--Tagalog}', ""); +Expect(0, 5900, '\p{^Is_Script=--Tagalog}', ""); +Expect(0, 5900, '\P{Is_Script=--Tagalog}', ""); +Expect(1, 5900, '\P{^Is_Script=--Tagalog}', ""); +Expect(0, 5887, '\p{Is_Script=--Tagalog}', ""); +Expect(1, 5887, '\p{^Is_Script=--Tagalog}', ""); +Expect(1, 5887, '\P{Is_Script=--Tagalog}', ""); +Expect(0, 5887, '\P{^Is_Script=--Tagalog}', ""); +Error('\p{Is_Sc=- Tglg:=}'); +Error('\P{Is_Sc=- Tglg:=}'); +Expect(1, 5900, '\p{Is_Sc=tglg}', ""); +Expect(0, 5900, '\p{^Is_Sc=tglg}', ""); +Expect(0, 5900, '\P{Is_Sc=tglg}', ""); +Expect(1, 5900, '\P{^Is_Sc=tglg}', ""); +Expect(0, 5887, '\p{Is_Sc=tglg}', ""); +Expect(1, 5887, '\p{^Is_Sc=tglg}', ""); +Expect(1, 5887, '\P{Is_Sc=tglg}', ""); +Expect(0, 5887, '\P{^Is_Sc=tglg}', ""); +Expect(1, 5900, '\p{Is_Sc= -Tglg}', ""); +Expect(0, 5900, '\p{^Is_Sc= -Tglg}', ""); +Expect(0, 5900, '\P{Is_Sc= -Tglg}', ""); +Expect(1, 5900, '\P{^Is_Sc= -Tglg}', ""); +Expect(0, 5887, '\p{Is_Sc= -Tglg}', ""); +Expect(1, 5887, '\p{^Is_Sc= -Tglg}', ""); +Expect(1, 5887, '\P{Is_Sc= -Tglg}', ""); +Expect(0, 5887, '\P{^Is_Sc= -Tglg}', ""); +Error('\p{Script=:= -gujarati}'); +Error('\P{Script=:= -gujarati}'); +Expect(1, 2691, '\p{Script=gujarati}', ""); +Expect(0, 2691, '\p{^Script=gujarati}', ""); +Expect(0, 2691, '\P{Script=gujarati}', ""); +Expect(1, 2691, '\P{^Script=gujarati}', ""); +Expect(0, 2688, '\p{Script=gujarati}', ""); +Expect(1, 2688, '\p{^Script=gujarati}', ""); +Expect(1, 2688, '\P{Script=gujarati}', ""); +Expect(0, 2688, '\P{^Script=gujarati}', ""); +Expect(1, 2691, '\p{Script=_GUJARATI}', ""); +Expect(0, 2691, '\p{^Script=_GUJARATI}', ""); +Expect(0, 2691, '\P{Script=_GUJARATI}', ""); +Expect(1, 2691, '\P{^Script=_GUJARATI}', ""); +Expect(0, 2688, '\p{Script=_GUJARATI}', ""); +Expect(1, 2688, '\p{^Script=_GUJARATI}', ""); +Expect(1, 2688, '\P{Script=_GUJARATI}', ""); +Expect(0, 2688, '\P{^Script=_GUJARATI}', ""); +Error('\p{Sc=:= _Gujr}'); +Error('\P{Sc=:= _Gujr}'); +Expect(1, 2691, '\p{Sc=gujr}', ""); +Expect(0, 2691, '\p{^Sc=gujr}', ""); +Expect(0, 2691, '\P{Sc=gujr}', ""); +Expect(1, 2691, '\P{^Sc=gujr}', ""); +Expect(0, 2688, '\p{Sc=gujr}', ""); +Expect(1, 2688, '\p{^Sc=gujr}', ""); +Expect(1, 2688, '\P{Sc=gujr}', ""); +Expect(0, 2688, '\P{^Sc=gujr}', ""); +Expect(1, 2691, '\p{Sc=-_gujr}', ""); +Expect(0, 2691, '\p{^Sc=-_gujr}', ""); +Expect(0, 2691, '\P{Sc=-_gujr}', ""); +Expect(1, 2691, '\P{^Sc=-_gujr}', ""); +Expect(0, 2688, '\p{Sc=-_gujr}', ""); +Expect(1, 2688, '\p{^Sc=-_gujr}', ""); +Expect(1, 2688, '\P{Sc=-_gujr}', ""); +Expect(0, 2688, '\P{^Sc=-_gujr}', ""); +Error('\p{Is_Script= :=GUJARATI}'); +Error('\P{Is_Script= :=GUJARATI}'); +Expect(1, 2691, '\p{Is_Script=gujarati}', ""); +Expect(0, 2691, '\p{^Is_Script=gujarati}', ""); +Expect(0, 2691, '\P{Is_Script=gujarati}', ""); +Expect(1, 2691, '\P{^Is_Script=gujarati}', ""); +Expect(0, 2688, '\p{Is_Script=gujarati}', ""); +Expect(1, 2688, '\p{^Is_Script=gujarati}', ""); +Expect(1, 2688, '\P{Is_Script=gujarati}', ""); +Expect(0, 2688, '\P{^Is_Script=gujarati}', ""); +Expect(1, 2691, '\p{Is_Script=- GUJARATI}', ""); +Expect(0, 2691, '\p{^Is_Script=- GUJARATI}', ""); +Expect(0, 2691, '\P{Is_Script=- GUJARATI}', ""); +Expect(1, 2691, '\P{^Is_Script=- GUJARATI}', ""); +Expect(0, 2688, '\p{Is_Script=- GUJARATI}', ""); +Expect(1, 2688, '\p{^Is_Script=- GUJARATI}', ""); +Expect(1, 2688, '\P{Is_Script=- GUJARATI}', ""); +Expect(0, 2688, '\P{^Is_Script=- GUJARATI}', ""); +Error('\p{Is_Sc=-GUJR:=}'); +Error('\P{Is_Sc=-GUJR:=}'); +Expect(1, 2691, '\p{Is_Sc=gujr}', ""); +Expect(0, 2691, '\p{^Is_Sc=gujr}', ""); +Expect(0, 2691, '\P{Is_Sc=gujr}', ""); +Expect(1, 2691, '\P{^Is_Sc=gujr}', ""); +Expect(0, 2688, '\p{Is_Sc=gujr}', ""); +Expect(1, 2688, '\p{^Is_Sc=gujr}', ""); +Expect(1, 2688, '\P{Is_Sc=gujr}', ""); +Expect(0, 2688, '\P{^Is_Sc=gujr}', ""); +Expect(1, 2691, '\p{Is_Sc=_gujr}', ""); +Expect(0, 2691, '\p{^Is_Sc=_gujr}', ""); +Expect(0, 2691, '\P{Is_Sc=_gujr}', ""); +Expect(1, 2691, '\P{^Is_Sc=_gujr}', ""); +Expect(0, 2688, '\p{Is_Sc=_gujr}', ""); +Expect(1, 2688, '\p{^Is_Sc=_gujr}', ""); +Expect(1, 2688, '\P{Is_Sc=_gujr}', ""); +Expect(0, 2688, '\P{^Is_Sc=_gujr}', ""); +Error('\p{Script=- Oriya/a/}'); +Error('\P{Script=- Oriya/a/}'); +Expect(1, 2819, '\p{Script=oriya}', ""); +Expect(0, 2819, '\p{^Script=oriya}', ""); +Expect(0, 2819, '\P{Script=oriya}', ""); +Expect(1, 2819, '\P{^Script=oriya}', ""); +Expect(0, 2816, '\p{Script=oriya}', ""); +Expect(1, 2816, '\p{^Script=oriya}', ""); +Expect(1, 2816, '\P{Script=oriya}', ""); +Expect(0, 2816, '\P{^Script=oriya}', ""); +Expect(1, 2819, '\p{Script=_ Oriya}', ""); +Expect(0, 2819, '\p{^Script=_ Oriya}', ""); +Expect(0, 2819, '\P{Script=_ Oriya}', ""); +Expect(1, 2819, '\P{^Script=_ Oriya}', ""); +Expect(0, 2816, '\p{Script=_ Oriya}', ""); +Expect(1, 2816, '\p{^Script=_ Oriya}', ""); +Expect(1, 2816, '\P{Script=_ Oriya}', ""); +Expect(0, 2816, '\P{^Script=_ Oriya}', ""); +Error('\p{Sc= ORYA/a/}'); +Error('\P{Sc= ORYA/a/}'); +Expect(1, 2819, '\p{Sc=orya}', ""); +Expect(0, 2819, '\p{^Sc=orya}', ""); +Expect(0, 2819, '\P{Sc=orya}', ""); +Expect(1, 2819, '\P{^Sc=orya}', ""); +Expect(0, 2816, '\p{Sc=orya}', ""); +Expect(1, 2816, '\p{^Sc=orya}', ""); +Expect(1, 2816, '\P{Sc=orya}', ""); +Expect(0, 2816, '\P{^Sc=orya}', ""); +Expect(1, 2819, '\p{Sc= Orya}', ""); +Expect(0, 2819, '\p{^Sc= Orya}', ""); +Expect(0, 2819, '\P{Sc= Orya}', ""); +Expect(1, 2819, '\P{^Sc= Orya}', ""); +Expect(0, 2816, '\p{Sc= Orya}', ""); +Expect(1, 2816, '\p{^Sc= Orya}', ""); +Expect(1, 2816, '\P{Sc= Orya}', ""); +Expect(0, 2816, '\P{^Sc= Orya}', ""); +Error('\p{Is_Script: oriya/a/}'); +Error('\P{Is_Script: oriya/a/}'); +Expect(1, 2819, '\p{Is_Script=oriya}', ""); +Expect(0, 2819, '\p{^Is_Script=oriya}', ""); +Expect(0, 2819, '\P{Is_Script=oriya}', ""); +Expect(1, 2819, '\P{^Is_Script=oriya}', ""); +Expect(0, 2816, '\p{Is_Script=oriya}', ""); +Expect(1, 2816, '\p{^Is_Script=oriya}', ""); +Expect(1, 2816, '\P{Is_Script=oriya}', ""); +Expect(0, 2816, '\P{^Is_Script=oriya}', ""); +Expect(1, 2819, '\p{Is_Script= oriya}', ""); +Expect(0, 2819, '\p{^Is_Script= oriya}', ""); +Expect(0, 2819, '\P{Is_Script= oriya}', ""); +Expect(1, 2819, '\P{^Is_Script= oriya}', ""); +Expect(0, 2816, '\p{Is_Script= oriya}', ""); +Expect(1, 2816, '\p{^Is_Script= oriya}', ""); +Expect(1, 2816, '\P{Is_Script= oriya}', ""); +Expect(0, 2816, '\P{^Is_Script= oriya}', ""); +Error('\p{Is_Sc: := _orya}'); +Error('\P{Is_Sc: := _orya}'); +Expect(1, 2819, '\p{Is_Sc=orya}', ""); +Expect(0, 2819, '\p{^Is_Sc=orya}', ""); +Expect(0, 2819, '\P{Is_Sc=orya}', ""); +Expect(1, 2819, '\P{^Is_Sc=orya}', ""); +Expect(0, 2816, '\p{Is_Sc=orya}', ""); +Expect(1, 2816, '\p{^Is_Sc=orya}', ""); +Expect(1, 2816, '\P{Is_Sc=orya}', ""); +Expect(0, 2816, '\P{^Is_Sc=orya}', ""); +Expect(1, 2819, '\p{Is_Sc=__Orya}', ""); +Expect(0, 2819, '\p{^Is_Sc=__Orya}', ""); +Expect(0, 2819, '\P{Is_Sc=__Orya}', ""); +Expect(1, 2819, '\P{^Is_Sc=__Orya}', ""); +Expect(0, 2816, '\p{Is_Sc=__Orya}', ""); +Expect(1, 2816, '\p{^Is_Sc=__Orya}', ""); +Expect(1, 2816, '\P{Is_Sc=__Orya}', ""); +Expect(0, 2816, '\P{^Is_Sc=__Orya}', ""); +Error('\p{Script=-_TAILe/a/}'); +Error('\P{Script=-_TAILe/a/}'); +Expect(1, 6509, '\p{Script=taile}', ""); +Expect(0, 6509, '\p{^Script=taile}', ""); +Expect(0, 6509, '\P{Script=taile}', ""); +Expect(1, 6509, '\P{^Script=taile}', ""); +Expect(0, 6479, '\p{Script=taile}', ""); +Expect(1, 6479, '\p{^Script=taile}', ""); +Expect(1, 6479, '\P{Script=taile}', ""); +Expect(0, 6479, '\P{^Script=taile}', ""); +Expect(1, 6509, '\p{Script=TAILe}', ""); +Expect(0, 6509, '\p{^Script=TAILe}', ""); +Expect(0, 6509, '\P{Script=TAILe}', ""); +Expect(1, 6509, '\P{^Script=TAILe}', ""); +Expect(0, 6479, '\p{Script=TAILe}', ""); +Expect(1, 6479, '\p{^Script=TAILe}', ""); +Expect(1, 6479, '\P{Script=TAILe}', ""); +Expect(0, 6479, '\P{^Script=TAILe}', ""); +Error('\p{Sc= Tale/a/}'); +Error('\P{Sc= Tale/a/}'); +Expect(1, 6509, '\p{Sc: tale}', ""); +Expect(0, 6509, '\p{^Sc: tale}', ""); +Expect(0, 6509, '\P{Sc: tale}', ""); +Expect(1, 6509, '\P{^Sc: tale}', ""); +Expect(0, 6479, '\p{Sc: tale}', ""); +Expect(1, 6479, '\p{^Sc: tale}', ""); +Expect(1, 6479, '\P{Sc: tale}', ""); +Expect(0, 6479, '\P{^Sc: tale}', ""); +Expect(1, 6509, '\p{Sc: _Tale}', ""); +Expect(0, 6509, '\p{^Sc: _Tale}', ""); +Expect(0, 6509, '\P{Sc: _Tale}', ""); +Expect(1, 6509, '\P{^Sc: _Tale}', ""); +Expect(0, 6479, '\p{Sc: _Tale}', ""); +Expect(1, 6479, '\p{^Sc: _Tale}', ""); +Expect(1, 6479, '\P{Sc: _Tale}', ""); +Expect(0, 6479, '\P{^Sc: _Tale}', ""); +Error('\p{Is_Script=/a/TaiLE}'); +Error('\P{Is_Script=/a/TaiLE}'); +Expect(1, 6509, '\p{Is_Script=taile}', ""); +Expect(0, 6509, '\p{^Is_Script=taile}', ""); +Expect(0, 6509, '\P{Is_Script=taile}', ""); +Expect(1, 6509, '\P{^Is_Script=taile}', ""); +Expect(0, 6479, '\p{Is_Script=taile}', ""); +Expect(1, 6479, '\p{^Is_Script=taile}', ""); +Expect(1, 6479, '\P{Is_Script=taile}', ""); +Expect(0, 6479, '\P{^Is_Script=taile}', ""); +Expect(1, 6509, '\p{Is_Script= TAI Le}', ""); +Expect(0, 6509, '\p{^Is_Script= TAI Le}', ""); +Expect(0, 6509, '\P{Is_Script= TAI Le}', ""); +Expect(1, 6509, '\P{^Is_Script= TAI Le}', ""); +Expect(0, 6479, '\p{Is_Script= TAI Le}', ""); +Expect(1, 6479, '\p{^Is_Script= TAI Le}', ""); +Expect(1, 6479, '\P{Is_Script= TAI Le}', ""); +Expect(0, 6479, '\P{^Is_Script= TAI Le}', ""); +Error('\p{Is_Sc=:=- Tale}'); +Error('\P{Is_Sc=:=- Tale}'); +Expect(1, 6509, '\p{Is_Sc=tale}', ""); +Expect(0, 6509, '\p{^Is_Sc=tale}', ""); +Expect(0, 6509, '\P{Is_Sc=tale}', ""); +Expect(1, 6509, '\P{^Is_Sc=tale}', ""); +Expect(0, 6479, '\p{Is_Sc=tale}', ""); +Expect(1, 6479, '\p{^Is_Sc=tale}', ""); +Expect(1, 6479, '\P{Is_Sc=tale}', ""); +Expect(0, 6479, '\P{^Is_Sc=tale}', ""); +Expect(1, 6509, '\p{Is_Sc=Tale}', ""); +Expect(0, 6509, '\p{^Is_Sc=Tale}', ""); +Expect(0, 6509, '\P{Is_Sc=Tale}', ""); +Expect(1, 6509, '\P{^Is_Sc=Tale}', ""); +Expect(0, 6479, '\p{Is_Sc=Tale}', ""); +Expect(1, 6479, '\p{^Is_Sc=Tale}', ""); +Expect(1, 6479, '\P{Is_Sc=Tale}', ""); +Expect(0, 6479, '\P{^Is_Sc=Tale}', ""); +Error('\p{Script=:=_-georgian}'); +Error('\P{Script=:=_-georgian}'); +Expect(1, 4293, '\p{Script=georgian}', ""); +Expect(0, 4293, '\p{^Script=georgian}', ""); +Expect(0, 4293, '\P{Script=georgian}', ""); +Expect(1, 4293, '\P{^Script=georgian}', ""); +Expect(0, 4255, '\p{Script=georgian}', ""); +Expect(1, 4255, '\p{^Script=georgian}', ""); +Expect(1, 4255, '\P{Script=georgian}', ""); +Expect(0, 4255, '\P{^Script=georgian}', ""); +Expect(1, 4293, '\p{Script=GEORGIAN}', ""); +Expect(0, 4293, '\p{^Script=GEORGIAN}', ""); +Expect(0, 4293, '\P{Script=GEORGIAN}', ""); +Expect(1, 4293, '\P{^Script=GEORGIAN}', ""); +Expect(0, 4255, '\p{Script=GEORGIAN}', ""); +Expect(1, 4255, '\p{^Script=GEORGIAN}', ""); +Expect(1, 4255, '\P{Script=GEORGIAN}', ""); +Expect(0, 4255, '\P{^Script=GEORGIAN}', ""); +Error('\p{Sc=/a/_geor}'); +Error('\P{Sc=/a/_geor}'); +Expect(1, 4293, '\p{Sc=geor}', ""); +Expect(0, 4293, '\p{^Sc=geor}', ""); +Expect(0, 4293, '\P{Sc=geor}', ""); +Expect(1, 4293, '\P{^Sc=geor}', ""); +Expect(0, 4255, '\p{Sc=geor}', ""); +Expect(1, 4255, '\p{^Sc=geor}', ""); +Expect(1, 4255, '\P{Sc=geor}', ""); +Expect(0, 4255, '\P{^Sc=geor}', ""); +Expect(1, 4293, '\p{Sc= -Geor}', ""); +Expect(0, 4293, '\p{^Sc= -Geor}', ""); +Expect(0, 4293, '\P{Sc= -Geor}', ""); +Expect(1, 4293, '\P{^Sc= -Geor}', ""); +Expect(0, 4255, '\p{Sc= -Geor}', ""); +Expect(1, 4255, '\p{^Sc= -Geor}', ""); +Expect(1, 4255, '\P{Sc= -Geor}', ""); +Expect(0, 4255, '\P{^Sc= -Geor}', ""); +Error('\p{Is_Script= GEORGIAN:=}'); +Error('\P{Is_Script= GEORGIAN:=}'); +Expect(1, 4293, '\p{Is_Script: georgian}', ""); +Expect(0, 4293, '\p{^Is_Script: georgian}', ""); +Expect(0, 4293, '\P{Is_Script: georgian}', ""); +Expect(1, 4293, '\P{^Is_Script: georgian}', ""); +Expect(0, 4255, '\p{Is_Script: georgian}', ""); +Expect(1, 4255, '\p{^Is_Script: georgian}', ""); +Expect(1, 4255, '\P{Is_Script: georgian}', ""); +Expect(0, 4255, '\P{^Is_Script: georgian}', ""); +Expect(1, 4293, '\p{Is_Script= Georgian}', ""); +Expect(0, 4293, '\p{^Is_Script= Georgian}', ""); +Expect(0, 4293, '\P{Is_Script= Georgian}', ""); +Expect(1, 4293, '\P{^Is_Script= Georgian}', ""); +Expect(0, 4255, '\p{Is_Script= Georgian}', ""); +Expect(1, 4255, '\p{^Is_Script= Georgian}', ""); +Expect(1, 4255, '\P{Is_Script= Georgian}', ""); +Expect(0, 4255, '\P{^Is_Script= Georgian}', ""); +Error('\p{Is_Sc=_ Geor/a/}'); +Error('\P{Is_Sc=_ Geor/a/}'); +Expect(1, 4293, '\p{Is_Sc=geor}', ""); +Expect(0, 4293, '\p{^Is_Sc=geor}', ""); +Expect(0, 4293, '\P{Is_Sc=geor}', ""); +Expect(1, 4293, '\P{^Is_Sc=geor}', ""); +Expect(0, 4255, '\p{Is_Sc=geor}', ""); +Expect(1, 4255, '\p{^Is_Sc=geor}', ""); +Expect(1, 4255, '\P{Is_Sc=geor}', ""); +Expect(0, 4255, '\P{^Is_Sc=geor}', ""); +Expect(1, 4293, '\p{Is_Sc= Geor}', ""); +Expect(0, 4293, '\p{^Is_Sc= Geor}', ""); +Expect(0, 4293, '\P{Is_Sc= Geor}', ""); +Expect(1, 4293, '\P{^Is_Sc= Geor}', ""); +Expect(0, 4255, '\p{Is_Sc= Geor}', ""); +Expect(1, 4255, '\p{^Is_Sc= Geor}', ""); +Expect(1, 4255, '\P{Is_Sc= Geor}', ""); +Expect(0, 4255, '\P{^Is_Sc= Geor}', ""); +Error('\p{Script=_telugu/a/}'); +Error('\P{Script=_telugu/a/}'); +Expect(1, 3075, '\p{Script=telugu}', ""); +Expect(0, 3075, '\p{^Script=telugu}', ""); +Expect(0, 3075, '\P{Script=telugu}', ""); +Expect(1, 3075, '\P{^Script=telugu}', ""); +Expect(0, 3072, '\p{Script=telugu}', ""); +Expect(1, 3072, '\p{^Script=telugu}', ""); +Expect(1, 3072, '\P{Script=telugu}', ""); +Expect(0, 3072, '\P{^Script=telugu}', ""); +Expect(1, 3075, '\p{Script= Telugu}', ""); +Expect(0, 3075, '\p{^Script= Telugu}', ""); +Expect(0, 3075, '\P{Script= Telugu}', ""); +Expect(1, 3075, '\P{^Script= Telugu}', ""); +Expect(0, 3072, '\p{Script= Telugu}', ""); +Expect(1, 3072, '\p{^Script= Telugu}', ""); +Expect(1, 3072, '\P{Script= Telugu}', ""); +Expect(0, 3072, '\P{^Script= Telugu}', ""); +Error('\p{Sc=-/a/TELU}'); +Error('\P{Sc=-/a/TELU}'); +Expect(1, 3075, '\p{Sc=telu}', ""); +Expect(0, 3075, '\p{^Sc=telu}', ""); +Expect(0, 3075, '\P{Sc=telu}', ""); +Expect(1, 3075, '\P{^Sc=telu}', ""); +Expect(0, 3072, '\p{Sc=telu}', ""); +Expect(1, 3072, '\p{^Sc=telu}', ""); +Expect(1, 3072, '\P{Sc=telu}', ""); +Expect(0, 3072, '\P{^Sc=telu}', ""); +Expect(1, 3075, '\p{Sc:-_telu}', ""); +Expect(0, 3075, '\p{^Sc:-_telu}', ""); +Expect(0, 3075, '\P{Sc:-_telu}', ""); +Expect(1, 3075, '\P{^Sc:-_telu}', ""); +Expect(0, 3072, '\p{Sc:-_telu}', ""); +Expect(1, 3072, '\p{^Sc:-_telu}', ""); +Expect(1, 3072, '\P{Sc:-_telu}', ""); +Expect(0, 3072, '\P{^Sc:-_telu}', ""); +Error('\p{Is_Script=/a/Telugu}'); +Error('\P{Is_Script=/a/Telugu}'); +Expect(1, 3075, '\p{Is_Script=telugu}', ""); +Expect(0, 3075, '\p{^Is_Script=telugu}', ""); +Expect(0, 3075, '\P{Is_Script=telugu}', ""); +Expect(1, 3075, '\P{^Is_Script=telugu}', ""); +Expect(0, 3072, '\p{Is_Script=telugu}', ""); +Expect(1, 3072, '\p{^Is_Script=telugu}', ""); +Expect(1, 3072, '\P{Is_Script=telugu}', ""); +Expect(0, 3072, '\P{^Is_Script=telugu}', ""); +Expect(1, 3075, '\p{Is_Script= Telugu}', ""); +Expect(0, 3075, '\p{^Is_Script= Telugu}', ""); +Expect(0, 3075, '\P{Is_Script= Telugu}', ""); +Expect(1, 3075, '\P{^Is_Script= Telugu}', ""); +Expect(0, 3072, '\p{Is_Script= Telugu}', ""); +Expect(1, 3072, '\p{^Is_Script= Telugu}', ""); +Expect(1, 3072, '\P{Is_Script= Telugu}', ""); +Expect(0, 3072, '\P{^Is_Script= Telugu}', ""); +Error('\p{Is_Sc= /a/Telu}'); +Error('\P{Is_Sc= /a/Telu}'); +Expect(1, 3075, '\p{Is_Sc=telu}', ""); +Expect(0, 3075, '\p{^Is_Sc=telu}', ""); +Expect(0, 3075, '\P{Is_Sc=telu}', ""); +Expect(1, 3075, '\P{^Is_Sc=telu}', ""); +Expect(0, 3072, '\p{Is_Sc=telu}', ""); +Expect(1, 3072, '\p{^Is_Sc=telu}', ""); +Expect(1, 3072, '\P{Is_Sc=telu}', ""); +Expect(0, 3072, '\P{^Is_Sc=telu}', ""); +Expect(1, 3075, '\p{Is_Sc=_Telu}', ""); +Expect(0, 3075, '\p{^Is_Sc=_Telu}', ""); +Expect(0, 3075, '\P{Is_Sc=_Telu}', ""); +Expect(1, 3075, '\P{^Is_Sc=_Telu}', ""); +Expect(0, 3072, '\p{Is_Sc=_Telu}', ""); +Expect(1, 3072, '\p{^Is_Sc=_Telu}', ""); +Expect(1, 3072, '\P{Is_Sc=_Telu}', ""); +Expect(0, 3072, '\P{^Is_Sc=_Telu}', ""); +Error('\p{Script= _tifinagh/a/}'); +Error('\P{Script= _tifinagh/a/}'); +Expect(1, 11621, '\p{Script=tifinagh}', ""); +Expect(0, 11621, '\p{^Script=tifinagh}', ""); +Expect(0, 11621, '\P{Script=tifinagh}', ""); +Expect(1, 11621, '\P{^Script=tifinagh}', ""); +Expect(0, 11567, '\p{Script=tifinagh}', ""); +Expect(1, 11567, '\p{^Script=tifinagh}', ""); +Expect(1, 11567, '\P{Script=tifinagh}', ""); +Expect(0, 11567, '\P{^Script=tifinagh}', ""); +Expect(1, 11621, '\p{Script=-TIFINAGH}', ""); +Expect(0, 11621, '\p{^Script=-TIFINAGH}', ""); +Expect(0, 11621, '\P{Script=-TIFINAGH}', ""); +Expect(1, 11621, '\P{^Script=-TIFINAGH}', ""); +Expect(0, 11567, '\p{Script=-TIFINAGH}', ""); +Expect(1, 11567, '\p{^Script=-TIFINAGH}', ""); +Expect(1, 11567, '\P{Script=-TIFINAGH}', ""); +Expect(0, 11567, '\P{^Script=-TIFINAGH}', ""); +Error('\p{Sc= :=Tfng}'); +Error('\P{Sc= :=Tfng}'); +Expect(1, 11621, '\p{Sc=tfng}', ""); +Expect(0, 11621, '\p{^Sc=tfng}', ""); +Expect(0, 11621, '\P{Sc=tfng}', ""); +Expect(1, 11621, '\P{^Sc=tfng}', ""); +Expect(0, 11567, '\p{Sc=tfng}', ""); +Expect(1, 11567, '\p{^Sc=tfng}', ""); +Expect(1, 11567, '\P{Sc=tfng}', ""); +Expect(0, 11567, '\P{^Sc=tfng}', ""); +Expect(1, 11621, '\p{Sc=_ TFNG}', ""); +Expect(0, 11621, '\p{^Sc=_ TFNG}', ""); +Expect(0, 11621, '\P{Sc=_ TFNG}', ""); +Expect(1, 11621, '\P{^Sc=_ TFNG}', ""); +Expect(0, 11567, '\p{Sc=_ TFNG}', ""); +Expect(1, 11567, '\p{^Sc=_ TFNG}', ""); +Expect(1, 11567, '\P{Sc=_ TFNG}', ""); +Expect(0, 11567, '\P{^Sc=_ TFNG}', ""); +Error('\p{Is_Script=:=- Tifinagh}'); +Error('\P{Is_Script=:=- Tifinagh}'); +Expect(1, 11621, '\p{Is_Script=tifinagh}', ""); +Expect(0, 11621, '\p{^Is_Script=tifinagh}', ""); +Expect(0, 11621, '\P{Is_Script=tifinagh}', ""); +Expect(1, 11621, '\P{^Is_Script=tifinagh}', ""); +Expect(0, 11567, '\p{Is_Script=tifinagh}', ""); +Expect(1, 11567, '\p{^Is_Script=tifinagh}', ""); +Expect(1, 11567, '\P{Is_Script=tifinagh}', ""); +Expect(0, 11567, '\P{^Is_Script=tifinagh}', ""); +Expect(1, 11621, '\p{Is_Script= Tifinagh}', ""); +Expect(0, 11621, '\p{^Is_Script= Tifinagh}', ""); +Expect(0, 11621, '\P{Is_Script= Tifinagh}', ""); +Expect(1, 11621, '\P{^Is_Script= Tifinagh}', ""); +Expect(0, 11567, '\p{Is_Script= Tifinagh}', ""); +Expect(1, 11567, '\p{^Is_Script= Tifinagh}', ""); +Expect(1, 11567, '\P{Is_Script= Tifinagh}', ""); +Expect(0, 11567, '\P{^Is_Script= Tifinagh}', ""); +Error('\p{Is_Sc=-TFNG/a/}'); +Error('\P{Is_Sc=-TFNG/a/}'); +Expect(1, 11621, '\p{Is_Sc=tfng}', ""); +Expect(0, 11621, '\p{^Is_Sc=tfng}', ""); +Expect(0, 11621, '\P{Is_Sc=tfng}', ""); +Expect(1, 11621, '\P{^Is_Sc=tfng}', ""); +Expect(0, 11567, '\p{Is_Sc=tfng}', ""); +Expect(1, 11567, '\p{^Is_Sc=tfng}', ""); +Expect(1, 11567, '\P{Is_Sc=tfng}', ""); +Expect(0, 11567, '\P{^Is_Sc=tfng}', ""); +Expect(1, 11621, '\p{Is_Sc=_Tfng}', ""); +Expect(0, 11621, '\p{^Is_Sc=_Tfng}', ""); +Expect(0, 11621, '\P{Is_Sc=_Tfng}', ""); +Expect(1, 11621, '\P{^Is_Sc=_Tfng}', ""); +Expect(0, 11567, '\p{Is_Sc=_Tfng}', ""); +Expect(1, 11567, '\p{^Is_Sc=_Tfng}', ""); +Expect(1, 11567, '\P{Is_Sc=_Tfng}', ""); +Expect(0, 11567, '\P{^Is_Sc=_Tfng}', ""); +Error('\p{Script= :=SINHALA}'); +Error('\P{Script= :=SINHALA}'); +Expect(1, 3459, '\p{Script=sinhala}', ""); +Expect(0, 3459, '\p{^Script=sinhala}', ""); +Expect(0, 3459, '\P{Script=sinhala}', ""); +Expect(1, 3459, '\P{^Script=sinhala}', ""); +Expect(0, 3457, '\p{Script=sinhala}', ""); +Expect(1, 3457, '\p{^Script=sinhala}', ""); +Expect(1, 3457, '\P{Script=sinhala}', ""); +Expect(0, 3457, '\P{^Script=sinhala}', ""); +Expect(1, 3459, '\p{Script=_ SINHALA}', ""); +Expect(0, 3459, '\p{^Script=_ SINHALA}', ""); +Expect(0, 3459, '\P{Script=_ SINHALA}', ""); +Expect(1, 3459, '\P{^Script=_ SINHALA}', ""); +Expect(0, 3457, '\p{Script=_ SINHALA}', ""); +Expect(1, 3457, '\p{^Script=_ SINHALA}', ""); +Expect(1, 3457, '\P{Script=_ SINHALA}', ""); +Expect(0, 3457, '\P{^Script=_ SINHALA}', ""); +Error('\p{Sc: -sinh:=}'); +Error('\P{Sc: -sinh:=}'); +Expect(1, 3459, '\p{Sc=sinh}', ""); +Expect(0, 3459, '\p{^Sc=sinh}', ""); +Expect(0, 3459, '\P{Sc=sinh}', ""); +Expect(1, 3459, '\P{^Sc=sinh}', ""); +Expect(0, 3457, '\p{Sc=sinh}', ""); +Expect(1, 3457, '\p{^Sc=sinh}', ""); +Expect(1, 3457, '\P{Sc=sinh}', ""); +Expect(0, 3457, '\P{^Sc=sinh}', ""); +Expect(1, 3459, '\p{Sc=--sinh}', ""); +Expect(0, 3459, '\p{^Sc=--sinh}', ""); +Expect(0, 3459, '\P{Sc=--sinh}', ""); +Expect(1, 3459, '\P{^Sc=--sinh}', ""); +Expect(0, 3457, '\p{Sc=--sinh}', ""); +Expect(1, 3457, '\p{^Sc=--sinh}', ""); +Expect(1, 3457, '\P{Sc=--sinh}', ""); +Expect(0, 3457, '\P{^Sc=--sinh}', ""); +Error('\p{Is_Script=:=-Sinhala}'); +Error('\P{Is_Script=:=-Sinhala}'); +Expect(1, 3459, '\p{Is_Script=sinhala}', ""); +Expect(0, 3459, '\p{^Is_Script=sinhala}', ""); +Expect(0, 3459, '\P{Is_Script=sinhala}', ""); +Expect(1, 3459, '\P{^Is_Script=sinhala}', ""); +Expect(0, 3457, '\p{Is_Script=sinhala}', ""); +Expect(1, 3457, '\p{^Is_Script=sinhala}', ""); +Expect(1, 3457, '\P{Is_Script=sinhala}', ""); +Expect(0, 3457, '\P{^Is_Script=sinhala}', ""); +Expect(1, 3459, '\p{Is_Script=-_Sinhala}', ""); +Expect(0, 3459, '\p{^Is_Script=-_Sinhala}', ""); +Expect(0, 3459, '\P{Is_Script=-_Sinhala}', ""); +Expect(1, 3459, '\P{^Is_Script=-_Sinhala}', ""); +Expect(0, 3457, '\p{Is_Script=-_Sinhala}', ""); +Expect(1, 3457, '\p{^Is_Script=-_Sinhala}', ""); +Expect(1, 3457, '\P{Is_Script=-_Sinhala}', ""); +Expect(0, 3457, '\P{^Is_Script=-_Sinhala}', ""); +Error('\p{Is_Sc=_SINH/a/}'); +Error('\P{Is_Sc=_SINH/a/}'); +Expect(1, 3459, '\p{Is_Sc=sinh}', ""); +Expect(0, 3459, '\p{^Is_Sc=sinh}', ""); +Expect(0, 3459, '\P{Is_Sc=sinh}', ""); +Expect(1, 3459, '\P{^Is_Sc=sinh}', ""); +Expect(0, 3457, '\p{Is_Sc=sinh}', ""); +Expect(1, 3457, '\p{^Is_Sc=sinh}', ""); +Expect(1, 3457, '\P{Is_Sc=sinh}', ""); +Expect(0, 3457, '\P{^Is_Sc=sinh}', ""); +Expect(1, 3459, '\p{Is_Sc= _SINH}', ""); +Expect(0, 3459, '\p{^Is_Sc= _SINH}', ""); +Expect(0, 3459, '\P{Is_Sc= _SINH}', ""); +Expect(1, 3459, '\P{^Is_Sc= _SINH}', ""); +Expect(0, 3457, '\p{Is_Sc= _SINH}', ""); +Expect(1, 3457, '\p{^Is_Sc= _SINH}', ""); +Expect(1, 3457, '\P{Is_Sc= _SINH}', ""); +Expect(0, 3457, '\P{^Is_Sc= _SINH}', ""); +Error('\p{Script=:=_Linear b}'); +Error('\P{Script=:=_Linear b}'); +Expect(1, 65547, '\p{Script: linearb}', ""); +Expect(0, 65547, '\p{^Script: linearb}', ""); +Expect(0, 65547, '\P{Script: linearb}', ""); +Expect(1, 65547, '\P{^Script: linearb}', ""); +Expect(0, 7, '\p{Script: linearb}', ""); +Expect(1, 7, '\p{^Script: linearb}', ""); +Expect(1, 7, '\P{Script: linearb}', ""); +Expect(0, 7, '\P{^Script: linearb}', ""); +Expect(1, 65547, '\p{Script= _Linear B}', ""); +Expect(0, 65547, '\p{^Script= _Linear B}', ""); +Expect(0, 65547, '\P{Script= _Linear B}', ""); +Expect(1, 65547, '\P{^Script= _Linear B}', ""); +Expect(0, 7, '\p{Script= _Linear B}', ""); +Expect(1, 7, '\p{^Script= _Linear B}', ""); +Expect(1, 7, '\P{Script= _Linear B}', ""); +Expect(0, 7, '\P{^Script= _Linear B}', ""); +Error('\p{Sc=:= Linb}'); +Error('\P{Sc=:= Linb}'); +Expect(1, 65547, '\p{Sc=linb}', ""); +Expect(0, 65547, '\p{^Sc=linb}', ""); +Expect(0, 65547, '\P{Sc=linb}', ""); +Expect(1, 65547, '\P{^Sc=linb}', ""); +Expect(0, 7, '\p{Sc=linb}', ""); +Expect(1, 7, '\p{^Sc=linb}', ""); +Expect(1, 7, '\P{Sc=linb}', ""); +Expect(0, 7, '\P{^Sc=linb}', ""); +Expect(1, 65547, '\p{Sc=_LINB}', ""); +Expect(0, 65547, '\p{^Sc=_LINB}', ""); +Expect(0, 65547, '\P{Sc=_LINB}', ""); +Expect(1, 65547, '\P{^Sc=_LINB}', ""); +Expect(0, 7, '\p{Sc=_LINB}', ""); +Expect(1, 7, '\p{^Sc=_LINB}', ""); +Expect(1, 7, '\P{Sc=_LINB}', ""); +Expect(0, 7, '\P{^Sc=_LINB}', ""); +Error('\p{Is_Script=-LINEAR B/a/}'); +Error('\P{Is_Script=-LINEAR B/a/}'); +Expect(1, 65547, '\p{Is_Script=linearb}', ""); +Expect(0, 65547, '\p{^Is_Script=linearb}', ""); +Expect(0, 65547, '\P{Is_Script=linearb}', ""); +Expect(1, 65547, '\P{^Is_Script=linearb}', ""); +Expect(0, 7, '\p{Is_Script=linearb}', ""); +Expect(1, 7, '\p{^Is_Script=linearb}', ""); +Expect(1, 7, '\P{Is_Script=linearb}', ""); +Expect(0, 7, '\P{^Is_Script=linearb}', ""); +Expect(1, 65547, '\p{Is_Script= LINEAR B}', ""); +Expect(0, 65547, '\p{^Is_Script= LINEAR B}', ""); +Expect(0, 65547, '\P{Is_Script= LINEAR B}', ""); +Expect(1, 65547, '\P{^Is_Script= LINEAR B}', ""); +Expect(0, 7, '\p{Is_Script= LINEAR B}', ""); +Expect(1, 7, '\p{^Is_Script= LINEAR B}', ""); +Expect(1, 7, '\P{Is_Script= LINEAR B}', ""); +Expect(0, 7, '\P{^Is_Script= LINEAR B}', ""); +Error('\p{Is_Sc=-/a/linb}'); +Error('\P{Is_Sc=-/a/linb}'); +Expect(1, 65547, '\p{Is_Sc=linb}', ""); +Expect(0, 65547, '\p{^Is_Sc=linb}', ""); +Expect(0, 65547, '\P{Is_Sc=linb}', ""); +Expect(1, 65547, '\P{^Is_Sc=linb}', ""); +Expect(0, 7, '\p{Is_Sc=linb}', ""); +Expect(1, 7, '\p{^Is_Sc=linb}', ""); +Expect(1, 7, '\P{Is_Sc=linb}', ""); +Expect(0, 7, '\P{^Is_Sc=linb}', ""); +Expect(1, 65547, '\p{Is_Sc= _LINB}', ""); +Expect(0, 65547, '\p{^Is_Sc= _LINB}', ""); +Expect(0, 65547, '\P{Is_Sc= _LINB}', ""); +Expect(1, 65547, '\P{^Is_Sc= _LINB}', ""); +Expect(0, 7, '\p{Is_Sc= _LINB}', ""); +Expect(1, 7, '\p{^Is_Sc= _LINB}', ""); +Expect(1, 7, '\P{Is_Sc= _LINB}', ""); +Expect(0, 7, '\P{^Is_Sc= _LINB}', ""); +Error('\p{Script=/a/ Saurashtra}'); +Error('\P{Script=/a/ Saurashtra}'); +Expect(1, 43204, '\p{Script=saurashtra}', ""); +Expect(0, 43204, '\p{^Script=saurashtra}', ""); +Expect(0, 43204, '\P{Script=saurashtra}', ""); +Expect(1, 43204, '\P{^Script=saurashtra}', ""); +Expect(0, 43135, '\p{Script=saurashtra}', ""); +Expect(1, 43135, '\p{^Script=saurashtra}', ""); +Expect(1, 43135, '\P{Script=saurashtra}', ""); +Expect(0, 43135, '\P{^Script=saurashtra}', ""); +Expect(1, 43204, '\p{Script= -Saurashtra}', ""); +Expect(0, 43204, '\p{^Script= -Saurashtra}', ""); +Expect(0, 43204, '\P{Script= -Saurashtra}', ""); +Expect(1, 43204, '\P{^Script= -Saurashtra}', ""); +Expect(0, 43135, '\p{Script= -Saurashtra}', ""); +Expect(1, 43135, '\p{^Script= -Saurashtra}', ""); +Expect(1, 43135, '\P{Script= -Saurashtra}', ""); +Expect(0, 43135, '\P{^Script= -Saurashtra}', ""); +Error('\p{Sc= Saur/a/}'); +Error('\P{Sc= Saur/a/}'); +Expect(1, 43204, '\p{Sc=saur}', ""); +Expect(0, 43204, '\p{^Sc=saur}', ""); +Expect(0, 43204, '\P{Sc=saur}', ""); +Expect(1, 43204, '\P{^Sc=saur}', ""); +Expect(0, 43135, '\p{Sc=saur}', ""); +Expect(1, 43135, '\p{^Sc=saur}', ""); +Expect(1, 43135, '\P{Sc=saur}', ""); +Expect(0, 43135, '\P{^Sc=saur}', ""); +Expect(1, 43204, '\p{Sc= -saur}', ""); +Expect(0, 43204, '\p{^Sc= -saur}', ""); +Expect(0, 43204, '\P{Sc= -saur}', ""); +Expect(1, 43204, '\P{^Sc= -saur}', ""); +Expect(0, 43135, '\p{Sc= -saur}', ""); +Expect(1, 43135, '\p{^Sc= -saur}', ""); +Expect(1, 43135, '\P{Sc= -saur}', ""); +Expect(0, 43135, '\P{^Sc= -saur}', ""); +Error('\p{Is_Script=SAURASHTRA:=}'); +Error('\P{Is_Script=SAURASHTRA:=}'); +Expect(1, 43204, '\p{Is_Script:saurashtra}', ""); +Expect(0, 43204, '\p{^Is_Script:saurashtra}', ""); +Expect(0, 43204, '\P{Is_Script:saurashtra}', ""); +Expect(1, 43204, '\P{^Is_Script:saurashtra}', ""); +Expect(0, 43135, '\p{Is_Script:saurashtra}', ""); +Expect(1, 43135, '\p{^Is_Script:saurashtra}', ""); +Expect(1, 43135, '\P{Is_Script:saurashtra}', ""); +Expect(0, 43135, '\P{^Is_Script:saurashtra}', ""); +Expect(1, 43204, '\p{Is_Script=-saurashtra}', ""); +Expect(0, 43204, '\p{^Is_Script=-saurashtra}', ""); +Expect(0, 43204, '\P{Is_Script=-saurashtra}', ""); +Expect(1, 43204, '\P{^Is_Script=-saurashtra}', ""); +Expect(0, 43135, '\p{Is_Script=-saurashtra}', ""); +Expect(1, 43135, '\p{^Is_Script=-saurashtra}', ""); +Expect(1, 43135, '\P{Is_Script=-saurashtra}', ""); +Expect(0, 43135, '\P{^Is_Script=-saurashtra}', ""); +Error('\p{Is_Sc= /a/saur}'); +Error('\P{Is_Sc= /a/saur}'); +Expect(1, 43204, '\p{Is_Sc=saur}', ""); +Expect(0, 43204, '\p{^Is_Sc=saur}', ""); +Expect(0, 43204, '\P{Is_Sc=saur}', ""); +Expect(1, 43204, '\P{^Is_Sc=saur}', ""); +Expect(0, 43135, '\p{Is_Sc=saur}', ""); +Expect(1, 43135, '\p{^Is_Sc=saur}', ""); +Expect(1, 43135, '\P{Is_Sc=saur}', ""); +Expect(0, 43135, '\P{^Is_Sc=saur}', ""); +Expect(1, 43204, '\p{Is_Sc:- saur}', ""); +Expect(0, 43204, '\p{^Is_Sc:- saur}', ""); +Expect(0, 43204, '\P{Is_Sc:- saur}', ""); +Expect(1, 43204, '\P{^Is_Sc:- saur}', ""); +Expect(0, 43135, '\p{Is_Sc:- saur}', ""); +Expect(1, 43135, '\p{^Is_Sc:- saur}', ""); +Expect(1, 43135, '\P{Is_Sc:- saur}', ""); +Expect(0, 43135, '\P{^Is_Sc:- saur}', ""); +Error('\p{Script=-:=Sundanese}'); +Error('\P{Script=-:=Sundanese}'); +Expect(1, 7082, '\p{Script=sundanese}', ""); +Expect(0, 7082, '\p{^Script=sundanese}', ""); +Expect(0, 7082, '\P{Script=sundanese}', ""); +Expect(1, 7082, '\P{^Script=sundanese}', ""); +Expect(0, 7039, '\p{Script=sundanese}', ""); +Expect(1, 7039, '\p{^Script=sundanese}', ""); +Expect(1, 7039, '\P{Script=sundanese}', ""); +Expect(0, 7039, '\P{^Script=sundanese}', ""); +Expect(1, 7082, '\p{Script= Sundanese}', ""); +Expect(0, 7082, '\p{^Script= Sundanese}', ""); +Expect(0, 7082, '\P{Script= Sundanese}', ""); +Expect(1, 7082, '\P{^Script= Sundanese}', ""); +Expect(0, 7039, '\p{Script= Sundanese}', ""); +Expect(1, 7039, '\p{^Script= Sundanese}', ""); +Expect(1, 7039, '\P{Script= Sundanese}', ""); +Expect(0, 7039, '\P{^Script= Sundanese}', ""); +Error('\p{Sc= sund:=}'); +Error('\P{Sc= sund:=}'); +Expect(1, 7082, '\p{Sc=sund}', ""); +Expect(0, 7082, '\p{^Sc=sund}', ""); +Expect(0, 7082, '\P{Sc=sund}', ""); +Expect(1, 7082, '\P{^Sc=sund}', ""); +Expect(0, 7039, '\p{Sc=sund}', ""); +Expect(1, 7039, '\p{^Sc=sund}', ""); +Expect(1, 7039, '\P{Sc=sund}', ""); +Expect(0, 7039, '\P{^Sc=sund}', ""); +Expect(1, 7082, '\p{Sc= Sund}', ""); +Expect(0, 7082, '\p{^Sc= Sund}', ""); +Expect(0, 7082, '\P{Sc= Sund}', ""); +Expect(1, 7082, '\P{^Sc= Sund}', ""); +Expect(0, 7039, '\p{Sc= Sund}', ""); +Expect(1, 7039, '\p{^Sc= Sund}', ""); +Expect(1, 7039, '\P{Sc= Sund}', ""); +Expect(0, 7039, '\P{^Sc= Sund}', ""); +Error('\p{Is_Script=/a/_ Sundanese}'); +Error('\P{Is_Script=/a/_ Sundanese}'); +Expect(1, 7082, '\p{Is_Script=sundanese}', ""); +Expect(0, 7082, '\p{^Is_Script=sundanese}', ""); +Expect(0, 7082, '\P{Is_Script=sundanese}', ""); +Expect(1, 7082, '\P{^Is_Script=sundanese}', ""); +Expect(0, 7039, '\p{Is_Script=sundanese}', ""); +Expect(1, 7039, '\p{^Is_Script=sundanese}', ""); +Expect(1, 7039, '\P{Is_Script=sundanese}', ""); +Expect(0, 7039, '\P{^Is_Script=sundanese}', ""); +Expect(1, 7082, '\p{Is_Script= Sundanese}', ""); +Expect(0, 7082, '\p{^Is_Script= Sundanese}', ""); +Expect(0, 7082, '\P{Is_Script= Sundanese}', ""); +Expect(1, 7082, '\P{^Is_Script= Sundanese}', ""); +Expect(0, 7039, '\p{Is_Script= Sundanese}', ""); +Expect(1, 7039, '\p{^Is_Script= Sundanese}', ""); +Expect(1, 7039, '\P{Is_Script= Sundanese}', ""); +Expect(0, 7039, '\P{^Is_Script= Sundanese}', ""); +Error('\p{Is_Sc=- SUND:=}'); +Error('\P{Is_Sc=- SUND:=}'); +Expect(1, 7082, '\p{Is_Sc=sund}', ""); +Expect(0, 7082, '\p{^Is_Sc=sund}', ""); +Expect(0, 7082, '\P{Is_Sc=sund}', ""); +Expect(1, 7082, '\P{^Is_Sc=sund}', ""); +Expect(0, 7039, '\p{Is_Sc=sund}', ""); +Expect(1, 7039, '\p{^Is_Sc=sund}', ""); +Expect(1, 7039, '\P{Is_Sc=sund}', ""); +Expect(0, 7039, '\P{^Is_Sc=sund}', ""); +Expect(1, 7082, '\p{Is_Sc=_sund}', ""); +Expect(0, 7082, '\p{^Is_Sc=_sund}', ""); +Expect(0, 7082, '\P{Is_Sc=_sund}', ""); +Expect(1, 7082, '\P{^Is_Sc=_sund}', ""); +Expect(0, 7039, '\p{Is_Sc=_sund}', ""); +Expect(1, 7039, '\p{^Is_Sc=_sund}', ""); +Expect(1, 7039, '\P{Is_Sc=_sund}', ""); +Expect(0, 7039, '\P{^Is_Sc=_sund}', ""); +Error('\p{Script: /a/_-NKO}'); +Error('\P{Script: /a/_-NKO}'); +Expect(1, 2042, '\p{Script=nko}', ""); +Expect(0, 2042, '\p{^Script=nko}', ""); +Expect(0, 2042, '\P{Script=nko}', ""); +Expect(1, 2042, '\P{^Script=nko}', ""); +Expect(0, 1983, '\p{Script=nko}', ""); +Expect(1, 1983, '\p{^Script=nko}', ""); +Expect(1, 1983, '\P{Script=nko}', ""); +Expect(0, 1983, '\P{^Script=nko}', ""); +Expect(1, 2042, '\p{Script=-_Nko}', ""); +Expect(0, 2042, '\p{^Script=-_Nko}', ""); +Expect(0, 2042, '\P{Script=-_Nko}', ""); +Expect(1, 2042, '\P{^Script=-_Nko}', ""); +Expect(0, 1983, '\p{Script=-_Nko}', ""); +Expect(1, 1983, '\p{^Script=-_Nko}', ""); +Expect(1, 1983, '\P{Script=-_Nko}', ""); +Expect(0, 1983, '\P{^Script=-_Nko}', ""); +Error('\p{Sc=:= Nkoo}'); +Error('\P{Sc=:= Nkoo}'); +Expect(1, 2042, '\p{Sc=nkoo}', ""); +Expect(0, 2042, '\p{^Sc=nkoo}', ""); +Expect(0, 2042, '\P{Sc=nkoo}', ""); +Expect(1, 2042, '\P{^Sc=nkoo}', ""); +Expect(0, 1983, '\p{Sc=nkoo}', ""); +Expect(1, 1983, '\p{^Sc=nkoo}', ""); +Expect(1, 1983, '\P{Sc=nkoo}', ""); +Expect(0, 1983, '\P{^Sc=nkoo}', ""); +Expect(1, 2042, '\p{Sc: -Nkoo}', ""); +Expect(0, 2042, '\p{^Sc: -Nkoo}', ""); +Expect(0, 2042, '\P{Sc: -Nkoo}', ""); +Expect(1, 2042, '\P{^Sc: -Nkoo}', ""); +Expect(0, 1983, '\p{Sc: -Nkoo}', ""); +Expect(1, 1983, '\p{^Sc: -Nkoo}', ""); +Expect(1, 1983, '\P{Sc: -Nkoo}', ""); +Expect(0, 1983, '\P{^Sc: -Nkoo}', ""); +Error('\p{Is_Script: _ NKO/a/}'); +Error('\P{Is_Script: _ NKO/a/}'); +Expect(1, 2042, '\p{Is_Script=nko}', ""); +Expect(0, 2042, '\p{^Is_Script=nko}', ""); +Expect(0, 2042, '\P{Is_Script=nko}', ""); +Expect(1, 2042, '\P{^Is_Script=nko}', ""); +Expect(0, 1983, '\p{Is_Script=nko}', ""); +Expect(1, 1983, '\p{^Is_Script=nko}', ""); +Expect(1, 1983, '\P{Is_Script=nko}', ""); +Expect(0, 1983, '\P{^Is_Script=nko}', ""); +Expect(1, 2042, '\p{Is_Script: Nko}', ""); +Expect(0, 2042, '\p{^Is_Script: Nko}', ""); +Expect(0, 2042, '\P{Is_Script: Nko}', ""); +Expect(1, 2042, '\P{^Is_Script: Nko}', ""); +Expect(0, 1983, '\p{Is_Script: Nko}', ""); +Expect(1, 1983, '\p{^Is_Script: Nko}', ""); +Expect(1, 1983, '\P{Is_Script: Nko}', ""); +Expect(0, 1983, '\P{^Is_Script: Nko}', ""); +Error('\p{Is_Sc=/a/ nkoo}'); +Error('\P{Is_Sc=/a/ nkoo}'); +Expect(1, 2042, '\p{Is_Sc=nkoo}', ""); +Expect(0, 2042, '\p{^Is_Sc=nkoo}', ""); +Expect(0, 2042, '\P{Is_Sc=nkoo}', ""); +Expect(1, 2042, '\P{^Is_Sc=nkoo}', ""); +Expect(0, 1983, '\p{Is_Sc=nkoo}', ""); +Expect(1, 1983, '\p{^Is_Sc=nkoo}', ""); +Expect(1, 1983, '\P{Is_Sc=nkoo}', ""); +Expect(0, 1983, '\P{^Is_Sc=nkoo}', ""); +Expect(1, 2042, '\p{Is_Sc= NKOO}', ""); +Expect(0, 2042, '\p{^Is_Sc= NKOO}', ""); +Expect(0, 2042, '\P{Is_Sc= NKOO}', ""); +Expect(1, 2042, '\P{^Is_Sc= NKOO}', ""); +Expect(0, 1983, '\p{Is_Sc= NKOO}', ""); +Expect(1, 1983, '\p{^Is_Sc= NKOO}', ""); +Expect(1, 1983, '\P{Is_Sc= NKOO}', ""); +Expect(0, 1983, '\P{^Is_Sc= NKOO}', ""); +Error('\p{Script= Han/a/}'); +Error('\P{Script= Han/a/}'); +Expect(1, 11929, '\p{Script=han}', ""); +Expect(0, 11929, '\p{^Script=han}', ""); +Expect(0, 11929, '\P{Script=han}', ""); +Expect(1, 11929, '\P{^Script=han}', ""); +Expect(0, 11903, '\p{Script=han}', ""); +Expect(1, 11903, '\p{^Script=han}', ""); +Expect(1, 11903, '\P{Script=han}', ""); +Expect(0, 11903, '\P{^Script=han}', ""); +Expect(1, 11929, '\p{Script=_ HAN}', ""); +Expect(0, 11929, '\p{^Script=_ HAN}', ""); +Expect(0, 11929, '\P{Script=_ HAN}', ""); +Expect(1, 11929, '\P{^Script=_ HAN}', ""); +Expect(0, 11903, '\p{Script=_ HAN}', ""); +Expect(1, 11903, '\p{^Script=_ HAN}', ""); +Expect(1, 11903, '\P{Script=_ HAN}', ""); +Expect(0, 11903, '\P{^Script=_ HAN}', ""); +Error('\p{Sc=_ Hani:=}'); +Error('\P{Sc=_ Hani:=}'); +Expect(1, 11929, '\p{Sc=hani}', ""); +Expect(0, 11929, '\p{^Sc=hani}', ""); +Expect(0, 11929, '\P{Sc=hani}', ""); +Expect(1, 11929, '\P{^Sc=hani}', ""); +Expect(0, 11903, '\p{Sc=hani}', ""); +Expect(1, 11903, '\p{^Sc=hani}', ""); +Expect(1, 11903, '\P{Sc=hani}', ""); +Expect(0, 11903, '\P{^Sc=hani}', ""); +Expect(1, 11929, '\p{Sc= hani}', ""); +Expect(0, 11929, '\p{^Sc= hani}', ""); +Expect(0, 11929, '\P{Sc= hani}', ""); +Expect(1, 11929, '\P{^Sc= hani}', ""); +Expect(0, 11903, '\p{Sc= hani}', ""); +Expect(1, 11903, '\p{^Sc= hani}', ""); +Expect(1, 11903, '\P{Sc= hani}', ""); +Expect(0, 11903, '\P{^Sc= hani}', ""); +Error('\p{Is_Script=/a/_HAN}'); +Error('\P{Is_Script=/a/_HAN}'); +Expect(1, 11929, '\p{Is_Script=han}', ""); +Expect(0, 11929, '\p{^Is_Script=han}', ""); +Expect(0, 11929, '\P{Is_Script=han}', ""); +Expect(1, 11929, '\P{^Is_Script=han}', ""); +Expect(0, 11903, '\p{Is_Script=han}', ""); +Expect(1, 11903, '\p{^Is_Script=han}', ""); +Expect(1, 11903, '\P{Is_Script=han}', ""); +Expect(0, 11903, '\P{^Is_Script=han}', ""); +Expect(1, 11929, '\p{Is_Script= -HAN}', ""); +Expect(0, 11929, '\p{^Is_Script= -HAN}', ""); +Expect(0, 11929, '\P{Is_Script= -HAN}', ""); +Expect(1, 11929, '\P{^Is_Script= -HAN}', ""); +Expect(0, 11903, '\p{Is_Script= -HAN}', ""); +Expect(1, 11903, '\p{^Is_Script= -HAN}', ""); +Expect(1, 11903, '\P{Is_Script= -HAN}', ""); +Expect(0, 11903, '\P{^Is_Script= -HAN}', ""); +Error('\p{Is_Sc= -HANI:=}'); +Error('\P{Is_Sc= -HANI:=}'); +Expect(1, 11929, '\p{Is_Sc=hani}', ""); +Expect(0, 11929, '\p{^Is_Sc=hani}', ""); +Expect(0, 11929, '\P{Is_Sc=hani}', ""); +Expect(1, 11929, '\P{^Is_Sc=hani}', ""); +Expect(0, 11903, '\p{Is_Sc=hani}', ""); +Expect(1, 11903, '\p{^Is_Sc=hani}', ""); +Expect(1, 11903, '\P{Is_Sc=hani}', ""); +Expect(0, 11903, '\P{^Is_Sc=hani}', ""); +Expect(1, 11929, '\p{Is_Sc=_Hani}', ""); +Expect(0, 11929, '\p{^Is_Sc=_Hani}', ""); +Expect(0, 11929, '\P{Is_Sc=_Hani}', ""); +Expect(1, 11929, '\P{^Is_Sc=_Hani}', ""); +Expect(0, 11903, '\p{Is_Sc=_Hani}', ""); +Expect(1, 11903, '\p{^Is_Sc=_Hani}', ""); +Expect(1, 11903, '\P{Is_Sc=_Hani}', ""); +Expect(0, 11903, '\P{^Is_Sc=_Hani}', ""); +Error('\p{Script=/a/ _Greek}'); +Error('\P{Script=/a/ _Greek}'); +Expect(1, 883, '\p{Script=greek}', ""); +Expect(0, 883, '\p{^Script=greek}', ""); +Expect(0, 883, '\P{Script=greek}', ""); +Expect(1, 883, '\P{^Script=greek}', ""); +Expect(0, 879, '\p{Script=greek}', ""); +Expect(1, 879, '\p{^Script=greek}', ""); +Expect(1, 879, '\P{Script=greek}', ""); +Expect(0, 879, '\P{^Script=greek}', ""); +Expect(1, 883, '\p{Script: - Greek}', ""); +Expect(0, 883, '\p{^Script: - Greek}', ""); +Expect(0, 883, '\P{Script: - Greek}', ""); +Expect(1, 883, '\P{^Script: - Greek}', ""); +Expect(0, 879, '\p{Script: - Greek}', ""); +Expect(1, 879, '\p{^Script: - Greek}', ""); +Expect(1, 879, '\P{Script: - Greek}', ""); +Expect(0, 879, '\P{^Script: - Greek}', ""); +Error('\p{Sc=/a/Grek}'); +Error('\P{Sc=/a/Grek}'); +Expect(1, 883, '\p{Sc=grek}', ""); +Expect(0, 883, '\p{^Sc=grek}', ""); +Expect(0, 883, '\P{Sc=grek}', ""); +Expect(1, 883, '\P{^Sc=grek}', ""); +Expect(0, 879, '\p{Sc=grek}', ""); +Expect(1, 879, '\p{^Sc=grek}', ""); +Expect(1, 879, '\P{Sc=grek}', ""); +Expect(0, 879, '\P{^Sc=grek}', ""); +Expect(1, 883, '\p{Sc= -Grek}', ""); +Expect(0, 883, '\p{^Sc= -Grek}', ""); +Expect(0, 883, '\P{Sc= -Grek}', ""); +Expect(1, 883, '\P{^Sc= -Grek}', ""); +Expect(0, 879, '\p{Sc= -Grek}', ""); +Expect(1, 879, '\p{^Sc= -Grek}', ""); +Expect(1, 879, '\P{Sc= -Grek}', ""); +Expect(0, 879, '\P{^Sc= -Grek}', ""); +Error('\p{Is_Script=:= Greek}'); +Error('\P{Is_Script=:= Greek}'); +Expect(1, 883, '\p{Is_Script: greek}', ""); +Expect(0, 883, '\p{^Is_Script: greek}', ""); +Expect(0, 883, '\P{Is_Script: greek}', ""); +Expect(1, 883, '\P{^Is_Script: greek}', ""); +Expect(0, 879, '\p{Is_Script: greek}', ""); +Expect(1, 879, '\p{^Is_Script: greek}', ""); +Expect(1, 879, '\P{Is_Script: greek}', ""); +Expect(0, 879, '\P{^Is_Script: greek}', ""); +Expect(1, 883, '\p{Is_Script=-_Greek}', ""); +Expect(0, 883, '\p{^Is_Script=-_Greek}', ""); +Expect(0, 883, '\P{Is_Script=-_Greek}', ""); +Expect(1, 883, '\P{^Is_Script=-_Greek}', ""); +Expect(0, 879, '\p{Is_Script=-_Greek}', ""); +Expect(1, 879, '\p{^Is_Script=-_Greek}', ""); +Expect(1, 879, '\P{Is_Script=-_Greek}', ""); +Expect(0, 879, '\P{^Is_Script=-_Greek}', ""); +Error('\p{Is_Sc=:= -Grek}'); +Error('\P{Is_Sc=:= -Grek}'); +Expect(1, 883, '\p{Is_Sc=grek}', ""); +Expect(0, 883, '\p{^Is_Sc=grek}', ""); +Expect(0, 883, '\P{Is_Sc=grek}', ""); +Expect(1, 883, '\P{^Is_Sc=grek}', ""); +Expect(0, 879, '\p{Is_Sc=grek}', ""); +Expect(1, 879, '\p{^Is_Sc=grek}', ""); +Expect(1, 879, '\P{Is_Sc=grek}', ""); +Expect(0, 879, '\P{^Is_Sc=grek}', ""); +Expect(1, 883, '\p{Is_Sc=- grek}', ""); +Expect(0, 883, '\p{^Is_Sc=- grek}', ""); +Expect(0, 883, '\P{Is_Sc=- grek}', ""); +Expect(1, 883, '\P{^Is_Sc=- grek}', ""); +Expect(0, 879, '\p{Is_Sc=- grek}', ""); +Expect(1, 879, '\p{^Is_Sc=- grek}', ""); +Expect(1, 879, '\P{Is_Sc=- grek}', ""); +Expect(0, 879, '\P{^Is_Sc=- grek}', ""); +Error('\p{Script= /a/Tamil}'); +Error('\P{Script= /a/Tamil}'); +Expect(1, 2947, '\p{Script=tamil}', ""); +Expect(0, 2947, '\p{^Script=tamil}', ""); +Expect(0, 2947, '\P{Script=tamil}', ""); +Expect(1, 2947, '\P{^Script=tamil}', ""); +Expect(0, 2945, '\p{Script=tamil}', ""); +Expect(1, 2945, '\p{^Script=tamil}', ""); +Expect(1, 2945, '\P{Script=tamil}', ""); +Expect(0, 2945, '\P{^Script=tamil}', ""); +Expect(1, 2947, '\p{Script= tamil}', ""); +Expect(0, 2947, '\p{^Script= tamil}', ""); +Expect(0, 2947, '\P{Script= tamil}', ""); +Expect(1, 2947, '\P{^Script= tamil}', ""); +Expect(0, 2945, '\p{Script= tamil}', ""); +Expect(1, 2945, '\p{^Script= tamil}', ""); +Expect(1, 2945, '\P{Script= tamil}', ""); +Expect(0, 2945, '\P{^Script= tamil}', ""); +Error('\p{Sc=_ taml:=}'); +Error('\P{Sc=_ taml:=}'); +Expect(1, 2947, '\p{Sc=taml}', ""); +Expect(0, 2947, '\p{^Sc=taml}', ""); +Expect(0, 2947, '\P{Sc=taml}', ""); +Expect(1, 2947, '\P{^Sc=taml}', ""); +Expect(0, 2945, '\p{Sc=taml}', ""); +Expect(1, 2945, '\p{^Sc=taml}', ""); +Expect(1, 2945, '\P{Sc=taml}', ""); +Expect(0, 2945, '\P{^Sc=taml}', ""); +Expect(1, 2947, '\p{Sc: Taml}', ""); +Expect(0, 2947, '\p{^Sc: Taml}', ""); +Expect(0, 2947, '\P{Sc: Taml}', ""); +Expect(1, 2947, '\P{^Sc: Taml}', ""); +Expect(0, 2945, '\p{Sc: Taml}', ""); +Expect(1, 2945, '\p{^Sc: Taml}', ""); +Expect(1, 2945, '\P{Sc: Taml}', ""); +Expect(0, 2945, '\P{^Sc: Taml}', ""); +Error('\p{Is_Script=__tamil:=}'); +Error('\P{Is_Script=__tamil:=}'); +Expect(1, 2947, '\p{Is_Script=tamil}', ""); +Expect(0, 2947, '\p{^Is_Script=tamil}', ""); +Expect(0, 2947, '\P{Is_Script=tamil}', ""); +Expect(1, 2947, '\P{^Is_Script=tamil}', ""); +Expect(0, 2945, '\p{Is_Script=tamil}', ""); +Expect(1, 2945, '\p{^Is_Script=tamil}', ""); +Expect(1, 2945, '\P{Is_Script=tamil}', ""); +Expect(0, 2945, '\P{^Is_Script=tamil}', ""); +Expect(1, 2947, '\p{Is_Script=__tamil}', ""); +Expect(0, 2947, '\p{^Is_Script=__tamil}', ""); +Expect(0, 2947, '\P{Is_Script=__tamil}', ""); +Expect(1, 2947, '\P{^Is_Script=__tamil}', ""); +Expect(0, 2945, '\p{Is_Script=__tamil}', ""); +Expect(1, 2945, '\p{^Is_Script=__tamil}', ""); +Expect(1, 2945, '\P{Is_Script=__tamil}', ""); +Expect(0, 2945, '\P{^Is_Script=__tamil}', ""); +Error('\p{Is_Sc: taml/a/}'); +Error('\P{Is_Sc: taml/a/}'); +Expect(1, 2947, '\p{Is_Sc=taml}', ""); +Expect(0, 2947, '\p{^Is_Sc=taml}', ""); +Expect(0, 2947, '\P{Is_Sc=taml}', ""); +Expect(1, 2947, '\P{^Is_Sc=taml}', ""); +Expect(0, 2945, '\p{Is_Sc=taml}', ""); +Expect(1, 2945, '\p{^Is_Sc=taml}', ""); +Expect(1, 2945, '\P{Is_Sc=taml}', ""); +Expect(0, 2945, '\P{^Is_Sc=taml}', ""); +Expect(1, 2947, '\p{Is_Sc= Taml}', ""); +Expect(0, 2947, '\p{^Is_Sc= Taml}', ""); +Expect(0, 2947, '\P{Is_Sc= Taml}', ""); +Expect(1, 2947, '\P{^Is_Sc= Taml}', ""); +Expect(0, 2945, '\p{Is_Sc= Taml}', ""); +Expect(1, 2945, '\p{^Is_Sc= Taml}', ""); +Expect(1, 2945, '\P{Is_Sc= Taml}', ""); +Expect(0, 2945, '\P{^Is_Sc= Taml}', ""); +Error('\p{Script= KayahLI:=}'); +Error('\P{Script= KayahLI:=}'); +Expect(1, 43311, '\p{Script=kayahli}', ""); +Expect(0, 43311, '\p{^Script=kayahli}', ""); +Expect(0, 43311, '\P{Script=kayahli}', ""); +Expect(1, 43311, '\P{^Script=kayahli}', ""); +Expect(0, 43263, '\p{Script=kayahli}', ""); +Expect(1, 43263, '\p{^Script=kayahli}', ""); +Expect(1, 43263, '\P{Script=kayahli}', ""); +Expect(0, 43263, '\P{^Script=kayahli}', ""); +Expect(1, 43311, '\p{Script= Kayah-li}', ""); +Expect(0, 43311, '\p{^Script= Kayah-li}', ""); +Expect(0, 43311, '\P{Script= Kayah-li}', ""); +Expect(1, 43311, '\P{^Script= Kayah-li}', ""); +Expect(0, 43263, '\p{Script= Kayah-li}', ""); +Expect(1, 43263, '\p{^Script= Kayah-li}', ""); +Expect(1, 43263, '\P{Script= Kayah-li}', ""); +Expect(0, 43263, '\P{^Script= Kayah-li}', ""); +Error('\p{Sc=/a/ Kali}'); +Error('\P{Sc=/a/ Kali}'); +Expect(1, 43311, '\p{Sc=kali}', ""); +Expect(0, 43311, '\p{^Sc=kali}', ""); +Expect(0, 43311, '\P{Sc=kali}', ""); +Expect(1, 43311, '\P{^Sc=kali}', ""); +Expect(0, 43263, '\p{Sc=kali}', ""); +Expect(1, 43263, '\p{^Sc=kali}', ""); +Expect(1, 43263, '\P{Sc=kali}', ""); +Expect(0, 43263, '\P{^Sc=kali}', ""); +Expect(1, 43311, '\p{Sc=__kali}', ""); +Expect(0, 43311, '\p{^Sc=__kali}', ""); +Expect(0, 43311, '\P{Sc=__kali}', ""); +Expect(1, 43311, '\P{^Sc=__kali}', ""); +Expect(0, 43263, '\p{Sc=__kali}', ""); +Expect(1, 43263, '\p{^Sc=__kali}', ""); +Expect(1, 43263, '\P{Sc=__kali}', ""); +Expect(0, 43263, '\P{^Sc=__kali}', ""); +Error('\p{Is_Script= _KAYAH-Li/a/}'); +Error('\P{Is_Script= _KAYAH-Li/a/}'); +Expect(1, 43311, '\p{Is_Script=kayahli}', ""); +Expect(0, 43311, '\p{^Is_Script=kayahli}', ""); +Expect(0, 43311, '\P{Is_Script=kayahli}', ""); +Expect(1, 43311, '\P{^Is_Script=kayahli}', ""); +Expect(0, 43263, '\p{Is_Script=kayahli}', ""); +Expect(1, 43263, '\p{^Is_Script=kayahli}', ""); +Expect(1, 43263, '\P{Is_Script=kayahli}', ""); +Expect(0, 43263, '\P{^Is_Script=kayahli}', ""); +Expect(1, 43311, '\p{Is_Script=-Kayah li}', ""); +Expect(0, 43311, '\p{^Is_Script=-Kayah li}', ""); +Expect(0, 43311, '\P{Is_Script=-Kayah li}', ""); +Expect(1, 43311, '\P{^Is_Script=-Kayah li}', ""); +Expect(0, 43263, '\p{Is_Script=-Kayah li}', ""); +Expect(1, 43263, '\p{^Is_Script=-Kayah li}', ""); +Expect(1, 43263, '\P{Is_Script=-Kayah li}', ""); +Expect(0, 43263, '\P{^Is_Script=-Kayah li}', ""); +Error('\p{Is_Sc= /a/kali}'); +Error('\P{Is_Sc= /a/kali}'); +Expect(1, 43311, '\p{Is_Sc=kali}', ""); +Expect(0, 43311, '\p{^Is_Sc=kali}', ""); +Expect(0, 43311, '\P{Is_Sc=kali}', ""); +Expect(1, 43311, '\P{^Is_Sc=kali}', ""); +Expect(0, 43263, '\p{Is_Sc=kali}', ""); +Expect(1, 43263, '\p{^Is_Sc=kali}', ""); +Expect(1, 43263, '\P{Is_Sc=kali}', ""); +Expect(0, 43263, '\P{^Is_Sc=kali}', ""); +Expect(1, 43311, '\p{Is_Sc=- kali}', ""); +Expect(0, 43311, '\p{^Is_Sc=- kali}', ""); +Expect(0, 43311, '\P{Is_Sc=- kali}', ""); +Expect(1, 43311, '\P{^Is_Sc=- kali}', ""); +Expect(0, 43263, '\p{Is_Sc=- kali}', ""); +Expect(1, 43263, '\p{^Is_Sc=- kali}', ""); +Expect(1, 43263, '\P{Is_Sc=- kali}', ""); +Expect(0, 43263, '\P{^Is_Sc=- kali}', ""); +Error('\p{Script=:= THAI}'); +Error('\P{Script=:= THAI}'); +Expect(1, 3642, '\p{Script=thai}', ""); +Expect(0, 3642, '\p{^Script=thai}', ""); +Expect(0, 3642, '\P{Script=thai}', ""); +Expect(1, 3642, '\P{^Script=thai}', ""); +Expect(0, 3584, '\p{Script=thai}', ""); +Expect(1, 3584, '\p{^Script=thai}', ""); +Expect(1, 3584, '\P{Script=thai}', ""); +Expect(0, 3584, '\P{^Script=thai}', ""); +Expect(1, 3642, '\p{Script= _THAI}', ""); +Expect(0, 3642, '\p{^Script= _THAI}', ""); +Expect(0, 3642, '\P{Script= _THAI}', ""); +Expect(1, 3642, '\P{^Script= _THAI}', ""); +Expect(0, 3584, '\p{Script= _THAI}', ""); +Expect(1, 3584, '\p{^Script= _THAI}', ""); +Expect(1, 3584, '\P{Script= _THAI}', ""); +Expect(0, 3584, '\P{^Script= _THAI}', ""); +Error('\p{Sc=:=-THAI}'); +Error('\P{Sc=:=-THAI}'); +Expect(1, 3642, '\p{Sc=thai}', ""); +Expect(0, 3642, '\p{^Sc=thai}', ""); +Expect(0, 3642, '\P{Sc=thai}', ""); +Expect(1, 3642, '\P{^Sc=thai}', ""); +Expect(0, 3584, '\p{Sc=thai}', ""); +Expect(1, 3584, '\p{^Sc=thai}', ""); +Expect(1, 3584, '\P{Sc=thai}', ""); +Expect(0, 3584, '\P{^Sc=thai}', ""); +Expect(1, 3642, '\p{Sc= thai}', ""); +Expect(0, 3642, '\p{^Sc= thai}', ""); +Expect(0, 3642, '\P{Sc= thai}', ""); +Expect(1, 3642, '\P{^Sc= thai}', ""); +Expect(0, 3584, '\p{Sc= thai}', ""); +Expect(1, 3584, '\p{^Sc= thai}', ""); +Expect(1, 3584, '\P{Sc= thai}', ""); +Expect(0, 3584, '\P{^Sc= thai}', ""); +Error('\p{Is_Script= :=THAI}'); +Error('\P{Is_Script= :=THAI}'); +Expect(1, 3642, '\p{Is_Script=thai}', ""); +Expect(0, 3642, '\p{^Is_Script=thai}', ""); +Expect(0, 3642, '\P{Is_Script=thai}', ""); +Expect(1, 3642, '\P{^Is_Script=thai}', ""); +Expect(0, 3584, '\p{Is_Script=thai}', ""); +Expect(1, 3584, '\p{^Is_Script=thai}', ""); +Expect(1, 3584, '\P{Is_Script=thai}', ""); +Expect(0, 3584, '\P{^Is_Script=thai}', ""); +Expect(1, 3642, '\p{Is_Script= -Thai}', ""); +Expect(0, 3642, '\p{^Is_Script= -Thai}', ""); +Expect(0, 3642, '\P{Is_Script= -Thai}', ""); +Expect(1, 3642, '\P{^Is_Script= -Thai}', ""); +Expect(0, 3584, '\p{Is_Script= -Thai}', ""); +Expect(1, 3584, '\p{^Is_Script= -Thai}', ""); +Expect(1, 3584, '\P{Is_Script= -Thai}', ""); +Expect(0, 3584, '\P{^Is_Script= -Thai}', ""); +Error('\p{Is_Sc: /a/_THAI}'); +Error('\P{Is_Sc: /a/_THAI}'); +Expect(1, 3642, '\p{Is_Sc=thai}', ""); +Expect(0, 3642, '\p{^Is_Sc=thai}', ""); +Expect(0, 3642, '\P{Is_Sc=thai}', ""); +Expect(1, 3642, '\P{^Is_Sc=thai}', ""); +Expect(0, 3584, '\p{Is_Sc=thai}', ""); +Expect(1, 3584, '\p{^Is_Sc=thai}', ""); +Expect(1, 3584, '\P{Is_Sc=thai}', ""); +Expect(0, 3584, '\P{^Is_Sc=thai}', ""); +Expect(1, 3642, '\p{Is_Sc= thai}', ""); +Expect(0, 3642, '\p{^Is_Sc= thai}', ""); +Expect(0, 3642, '\P{Is_Sc= thai}', ""); +Expect(1, 3642, '\P{^Is_Sc= thai}', ""); +Expect(0, 3584, '\p{Is_Sc= thai}', ""); +Expect(1, 3584, '\p{^Is_Sc= thai}', ""); +Expect(1, 3584, '\P{Is_Sc= thai}', ""); +Expect(0, 3584, '\P{^Is_Sc= thai}', ""); +Error('\p{Ideographic=/a/-_YES}'); +Error('\P{Ideographic=/a/-_YES}'); +Expect(1, 12295, '\p{Ideographic=yes}', ""); +Expect(0, 12295, '\p{^Ideographic=yes}', ""); +Expect(0, 12295, '\P{Ideographic=yes}', ""); +Expect(1, 12295, '\P{^Ideographic=yes}', ""); +Expect(0, 12293, '\p{Ideographic=yes}', ""); +Expect(1, 12293, '\p{^Ideographic=yes}', ""); +Expect(1, 12293, '\P{Ideographic=yes}', ""); +Expect(0, 12293, '\P{^Ideographic=yes}', ""); +Expect(1, 12295, '\p{Ideographic= yes}', ""); +Expect(0, 12295, '\p{^Ideographic= yes}', ""); +Expect(0, 12295, '\P{Ideographic= yes}', ""); +Expect(1, 12295, '\P{^Ideographic= yes}', ""); +Expect(0, 12293, '\p{Ideographic= yes}', ""); +Expect(1, 12293, '\p{^Ideographic= yes}', ""); +Expect(1, 12293, '\P{Ideographic= yes}', ""); +Expect(0, 12293, '\P{^Ideographic= yes}', ""); +Error('\p{Ideo=:= Y}'); +Error('\P{Ideo=:= Y}'); +Expect(1, 12295, '\p{Ideo=y}', ""); +Expect(0, 12295, '\p{^Ideo=y}', ""); +Expect(0, 12295, '\P{Ideo=y}', ""); +Expect(1, 12295, '\P{^Ideo=y}', ""); +Expect(0, 12293, '\p{Ideo=y}', ""); +Expect(1, 12293, '\p{^Ideo=y}', ""); +Expect(1, 12293, '\P{Ideo=y}', ""); +Expect(0, 12293, '\P{^Ideo=y}', ""); +Expect(1, 12295, '\p{Ideo= Y}', ""); +Expect(0, 12295, '\p{^Ideo= Y}', ""); +Expect(0, 12295, '\P{Ideo= Y}', ""); +Expect(1, 12295, '\P{^Ideo= Y}', ""); +Expect(0, 12293, '\p{Ideo= Y}', ""); +Expect(1, 12293, '\p{^Ideo= Y}', ""); +Expect(1, 12293, '\P{Ideo= Y}', ""); +Expect(0, 12293, '\P{^Ideo= Y}', ""); +Error('\p{Is_Ideographic= t:=}'); +Error('\P{Is_Ideographic= t:=}'); +Expect(1, 12295, '\p{Is_Ideographic=t}', ""); +Expect(0, 12295, '\p{^Is_Ideographic=t}', ""); +Expect(0, 12295, '\P{Is_Ideographic=t}', ""); +Expect(1, 12295, '\P{^Is_Ideographic=t}', ""); +Expect(0, 12293, '\p{Is_Ideographic=t}', ""); +Expect(1, 12293, '\p{^Is_Ideographic=t}', ""); +Expect(1, 12293, '\P{Is_Ideographic=t}', ""); +Expect(0, 12293, '\P{^Is_Ideographic=t}', ""); +Expect(1, 12295, '\p{Is_Ideographic= T}', ""); +Expect(0, 12295, '\p{^Is_Ideographic= T}', ""); +Expect(0, 12295, '\P{Is_Ideographic= T}', ""); +Expect(1, 12295, '\P{^Is_Ideographic= T}', ""); +Expect(0, 12293, '\p{Is_Ideographic= T}', ""); +Expect(1, 12293, '\p{^Is_Ideographic= T}', ""); +Expect(1, 12293, '\P{Is_Ideographic= T}', ""); +Expect(0, 12293, '\P{^Is_Ideographic= T}', ""); +Error('\p{Is_Ideo=/a/ true}'); +Error('\P{Is_Ideo=/a/ true}'); +Expect(1, 12295, '\p{Is_Ideo=true}', ""); +Expect(0, 12295, '\p{^Is_Ideo=true}', ""); +Expect(0, 12295, '\P{Is_Ideo=true}', ""); +Expect(1, 12295, '\P{^Is_Ideo=true}', ""); +Expect(0, 12293, '\p{Is_Ideo=true}', ""); +Expect(1, 12293, '\p{^Is_Ideo=true}', ""); +Expect(1, 12293, '\P{Is_Ideo=true}', ""); +Expect(0, 12293, '\P{^Is_Ideo=true}', ""); +Expect(1, 12295, '\p{Is_Ideo=-_true}', ""); +Expect(0, 12295, '\p{^Is_Ideo=-_true}', ""); +Expect(0, 12295, '\P{Is_Ideo=-_true}', ""); +Expect(1, 12295, '\P{^Is_Ideo=-_true}', ""); +Expect(0, 12293, '\p{Is_Ideo=-_true}', ""); +Expect(1, 12293, '\p{^Is_Ideo=-_true}', ""); +Expect(1, 12293, '\P{Is_Ideo=-_true}', ""); +Expect(0, 12293, '\P{^Is_Ideo=-_true}', ""); +Error('\p{Ideographic=:=no}'); +Error('\P{Ideographic=:=no}'); +Expect(1, 12293, '\p{Ideographic=no}', ""); +Expect(0, 12293, '\p{^Ideographic=no}', ""); +Expect(0, 12293, '\P{Ideographic=no}', ""); +Expect(1, 12293, '\P{^Ideographic=no}', ""); +Expect(0, 12295, '\p{Ideographic=no}', ""); +Expect(1, 12295, '\p{^Ideographic=no}', ""); +Expect(1, 12295, '\P{Ideographic=no}', ""); +Expect(0, 12295, '\P{^Ideographic=no}', ""); +Expect(1, 12293, '\p{Ideographic=_-No}', ""); +Expect(0, 12293, '\p{^Ideographic=_-No}', ""); +Expect(0, 12293, '\P{Ideographic=_-No}', ""); +Expect(1, 12293, '\P{^Ideographic=_-No}', ""); +Expect(0, 12295, '\p{Ideographic=_-No}', ""); +Expect(1, 12295, '\p{^Ideographic=_-No}', ""); +Expect(1, 12295, '\P{Ideographic=_-No}', ""); +Expect(0, 12295, '\P{^Ideographic=_-No}', ""); +Error('\p{Ideo= /a/N}'); +Error('\P{Ideo= /a/N}'); +Expect(1, 12293, '\p{Ideo: n}', ""); +Expect(0, 12293, '\p{^Ideo: n}', ""); +Expect(0, 12293, '\P{Ideo: n}', ""); +Expect(1, 12293, '\P{^Ideo: n}', ""); +Expect(0, 12295, '\p{Ideo: n}', ""); +Expect(1, 12295, '\p{^Ideo: n}', ""); +Expect(1, 12295, '\P{Ideo: n}', ""); +Expect(0, 12295, '\P{^Ideo: n}', ""); +Expect(1, 12293, '\p{Ideo=_N}', ""); +Expect(0, 12293, '\p{^Ideo=_N}', ""); +Expect(0, 12293, '\P{Ideo=_N}', ""); +Expect(1, 12293, '\P{^Ideo=_N}', ""); +Expect(0, 12295, '\p{Ideo=_N}', ""); +Expect(1, 12295, '\p{^Ideo=_N}', ""); +Expect(1, 12295, '\P{Ideo=_N}', ""); +Expect(0, 12295, '\P{^Ideo=_N}', ""); +Error('\p{Is_Ideographic= -F:=}'); +Error('\P{Is_Ideographic= -F:=}'); +Expect(1, 12293, '\p{Is_Ideographic: f}', ""); +Expect(0, 12293, '\p{^Is_Ideographic: f}', ""); +Expect(0, 12293, '\P{Is_Ideographic: f}', ""); +Expect(1, 12293, '\P{^Is_Ideographic: f}', ""); +Expect(0, 12295, '\p{Is_Ideographic: f}', ""); +Expect(1, 12295, '\p{^Is_Ideographic: f}', ""); +Expect(1, 12295, '\P{Is_Ideographic: f}', ""); +Expect(0, 12295, '\P{^Is_Ideographic: f}', ""); +Expect(1, 12293, '\p{Is_Ideographic=_F}', ""); +Expect(0, 12293, '\p{^Is_Ideographic=_F}', ""); +Expect(0, 12293, '\P{Is_Ideographic=_F}', ""); +Expect(1, 12293, '\P{^Is_Ideographic=_F}', ""); +Expect(0, 12295, '\p{Is_Ideographic=_F}', ""); +Expect(1, 12295, '\p{^Is_Ideographic=_F}', ""); +Expect(1, 12295, '\P{Is_Ideographic=_F}', ""); +Expect(0, 12295, '\P{^Is_Ideographic=_F}', ""); +Error('\p{Is_Ideo=__False/a/}'); +Error('\P{Is_Ideo=__False/a/}'); +Expect(1, 12293, '\p{Is_Ideo=false}', ""); +Expect(0, 12293, '\p{^Is_Ideo=false}', ""); +Expect(0, 12293, '\P{Is_Ideo=false}', ""); +Expect(1, 12293, '\P{^Is_Ideo=false}', ""); +Expect(0, 12295, '\p{Is_Ideo=false}', ""); +Expect(1, 12295, '\p{^Is_Ideo=false}', ""); +Expect(1, 12295, '\P{Is_Ideo=false}', ""); +Expect(0, 12295, '\P{^Is_Ideo=false}', ""); +Expect(1, 12293, '\p{Is_Ideo=_-False}', ""); +Expect(0, 12293, '\p{^Is_Ideo=_-False}', ""); +Expect(0, 12293, '\P{Is_Ideo=_-False}', ""); +Expect(1, 12293, '\P{^Is_Ideo=_-False}', ""); +Expect(0, 12295, '\p{Is_Ideo=_-False}', ""); +Expect(1, 12295, '\p{^Is_Ideo=_-False}', ""); +Expect(1, 12295, '\P{Is_Ideo=_-False}', ""); +Expect(0, 12295, '\P{^Is_Ideo=_-False}', ""); +Error('\p{Other_Grapheme_Extend=_yes:=}'); +Error('\P{Other_Grapheme_Extend=_yes:=}'); +Expect(1, 2494, '\p{Other_Grapheme_Extend: yes}', 'deprecated'); +Expect(0, 2494, '\p{^Other_Grapheme_Extend: yes}', 'deprecated'); +Expect(0, 2494, '\P{Other_Grapheme_Extend: yes}', 'deprecated'); +Expect(1, 2494, '\P{^Other_Grapheme_Extend: yes}', 'deprecated'); +Expect(0, 2493, '\p{Other_Grapheme_Extend: yes}', 'deprecated'); +Expect(1, 2493, '\p{^Other_Grapheme_Extend: yes}', 'deprecated'); +Expect(1, 2493, '\P{Other_Grapheme_Extend: yes}', 'deprecated'); +Expect(0, 2493, '\P{^Other_Grapheme_Extend: yes}', 'deprecated'); +Expect(1, 2494, '\p{Other_Grapheme_Extend= Yes}', 'deprecated'); +Expect(0, 2494, '\p{^Other_Grapheme_Extend= Yes}', 'deprecated'); +Expect(0, 2494, '\P{Other_Grapheme_Extend= Yes}', 'deprecated'); +Expect(1, 2494, '\P{^Other_Grapheme_Extend= Yes}', 'deprecated'); +Expect(0, 2493, '\p{Other_Grapheme_Extend= Yes}', 'deprecated'); +Expect(1, 2493, '\p{^Other_Grapheme_Extend= Yes}', 'deprecated'); +Expect(1, 2493, '\P{Other_Grapheme_Extend= Yes}', 'deprecated'); +Expect(0, 2493, '\P{^Other_Grapheme_Extend= Yes}', 'deprecated'); +Error('\p{OGr_Ext=/a/Y}'); +Error('\P{OGr_Ext=/a/Y}'); +Expect(1, 2494, '\p{OGr_Ext=y}', 'deprecated'); +Expect(0, 2494, '\p{^OGr_Ext=y}', 'deprecated'); +Expect(0, 2494, '\P{OGr_Ext=y}', 'deprecated'); +Expect(1, 2494, '\P{^OGr_Ext=y}', 'deprecated'); +Expect(0, 2493, '\p{OGr_Ext=y}', 'deprecated'); +Expect(1, 2493, '\p{^OGr_Ext=y}', 'deprecated'); +Expect(1, 2493, '\P{OGr_Ext=y}', 'deprecated'); +Expect(0, 2493, '\P{^OGr_Ext=y}', 'deprecated'); +Expect(1, 2494, '\p{OGr_Ext= -y}', 'deprecated'); +Expect(0, 2494, '\p{^OGr_Ext= -y}', 'deprecated'); +Expect(0, 2494, '\P{OGr_Ext= -y}', 'deprecated'); +Expect(1, 2494, '\P{^OGr_Ext= -y}', 'deprecated'); +Expect(0, 2493, '\p{OGr_Ext= -y}', 'deprecated'); +Expect(1, 2493, '\p{^OGr_Ext= -y}', 'deprecated'); +Expect(1, 2493, '\P{OGr_Ext= -y}', 'deprecated'); +Expect(0, 2493, '\P{^OGr_Ext= -y}', 'deprecated'); +Error('\p{Is_Other_Grapheme_Extend=-:=T}'); +Error('\P{Is_Other_Grapheme_Extend=-:=T}'); +Expect(1, 2494, '\p{Is_Other_Grapheme_Extend=t}', 'deprecated'); +Expect(0, 2494, '\p{^Is_Other_Grapheme_Extend=t}', 'deprecated'); +Expect(0, 2494, '\P{Is_Other_Grapheme_Extend=t}', 'deprecated'); +Expect(1, 2494, '\P{^Is_Other_Grapheme_Extend=t}', 'deprecated'); +Expect(0, 2493, '\p{Is_Other_Grapheme_Extend=t}', 'deprecated'); +Expect(1, 2493, '\p{^Is_Other_Grapheme_Extend=t}', 'deprecated'); +Expect(1, 2493, '\P{Is_Other_Grapheme_Extend=t}', 'deprecated'); +Expect(0, 2493, '\P{^Is_Other_Grapheme_Extend=t}', 'deprecated'); +Expect(1, 2494, '\p{Is_Other_Grapheme_Extend: _-T}', 'deprecated'); +Expect(0, 2494, '\p{^Is_Other_Grapheme_Extend: _-T}', 'deprecated'); +Expect(0, 2494, '\P{Is_Other_Grapheme_Extend: _-T}', 'deprecated'); +Expect(1, 2494, '\P{^Is_Other_Grapheme_Extend: _-T}', 'deprecated'); +Expect(0, 2493, '\p{Is_Other_Grapheme_Extend: _-T}', 'deprecated'); +Expect(1, 2493, '\p{^Is_Other_Grapheme_Extend: _-T}', 'deprecated'); +Expect(1, 2493, '\P{Is_Other_Grapheme_Extend: _-T}', 'deprecated'); +Expect(0, 2493, '\P{^Is_Other_Grapheme_Extend: _-T}', 'deprecated'); +Error('\p{Is_OGr_Ext=:= True}'); +Error('\P{Is_OGr_Ext=:= True}'); +Expect(1, 2494, '\p{Is_OGr_Ext=true}', 'deprecated'); +Expect(0, 2494, '\p{^Is_OGr_Ext=true}', 'deprecated'); +Expect(0, 2494, '\P{Is_OGr_Ext=true}', 'deprecated'); +Expect(1, 2494, '\P{^Is_OGr_Ext=true}', 'deprecated'); +Expect(0, 2493, '\p{Is_OGr_Ext=true}', 'deprecated'); +Expect(1, 2493, '\p{^Is_OGr_Ext=true}', 'deprecated'); +Expect(1, 2493, '\P{Is_OGr_Ext=true}', 'deprecated'); +Expect(0, 2493, '\P{^Is_OGr_Ext=true}', 'deprecated'); +Expect(1, 2494, '\p{Is_OGr_Ext=_-true}', 'deprecated'); +Expect(0, 2494, '\p{^Is_OGr_Ext=_-true}', 'deprecated'); +Expect(0, 2494, '\P{Is_OGr_Ext=_-true}', 'deprecated'); +Expect(1, 2494, '\P{^Is_OGr_Ext=_-true}', 'deprecated'); +Expect(0, 2493, '\p{Is_OGr_Ext=_-true}', 'deprecated'); +Expect(1, 2493, '\p{^Is_OGr_Ext=_-true}', 'deprecated'); +Expect(1, 2493, '\P{Is_OGr_Ext=_-true}', 'deprecated'); +Expect(0, 2493, '\P{^Is_OGr_Ext=_-true}', 'deprecated'); +Error('\p{Other_Grapheme_Extend=--NO/a/}'); +Error('\P{Other_Grapheme_Extend=--NO/a/}'); +Expect(1, 2493, '\p{Other_Grapheme_Extend=no}', 'deprecated'); +Expect(0, 2493, '\p{^Other_Grapheme_Extend=no}', 'deprecated'); +Expect(0, 2493, '\P{Other_Grapheme_Extend=no}', 'deprecated'); +Expect(1, 2493, '\P{^Other_Grapheme_Extend=no}', 'deprecated'); +Expect(0, 2494, '\p{Other_Grapheme_Extend=no}', 'deprecated'); +Expect(1, 2494, '\p{^Other_Grapheme_Extend=no}', 'deprecated'); +Expect(1, 2494, '\P{Other_Grapheme_Extend=no}', 'deprecated'); +Expect(0, 2494, '\P{^Other_Grapheme_Extend=no}', 'deprecated'); +Expect(1, 2493, '\p{Other_Grapheme_Extend= No}', 'deprecated'); +Expect(0, 2493, '\p{^Other_Grapheme_Extend= No}', 'deprecated'); +Expect(0, 2493, '\P{Other_Grapheme_Extend= No}', 'deprecated'); +Expect(1, 2493, '\P{^Other_Grapheme_Extend= No}', 'deprecated'); +Expect(0, 2494, '\p{Other_Grapheme_Extend= No}', 'deprecated'); +Expect(1, 2494, '\p{^Other_Grapheme_Extend= No}', 'deprecated'); +Expect(1, 2494, '\P{Other_Grapheme_Extend= No}', 'deprecated'); +Expect(0, 2494, '\P{^Other_Grapheme_Extend= No}', 'deprecated'); +Error('\p{OGr_Ext=/a/-_N}'); +Error('\P{OGr_Ext=/a/-_N}'); +Expect(1, 2493, '\p{OGr_Ext=n}', 'deprecated'); +Expect(0, 2493, '\p{^OGr_Ext=n}', 'deprecated'); +Expect(0, 2493, '\P{OGr_Ext=n}', 'deprecated'); +Expect(1, 2493, '\P{^OGr_Ext=n}', 'deprecated'); +Expect(0, 2494, '\p{OGr_Ext=n}', 'deprecated'); +Expect(1, 2494, '\p{^OGr_Ext=n}', 'deprecated'); +Expect(1, 2494, '\P{OGr_Ext=n}', 'deprecated'); +Expect(0, 2494, '\P{^OGr_Ext=n}', 'deprecated'); +Expect(1, 2493, '\p{OGr_Ext=--n}', 'deprecated'); +Expect(0, 2493, '\p{^OGr_Ext=--n}', 'deprecated'); +Expect(0, 2493, '\P{OGr_Ext=--n}', 'deprecated'); +Expect(1, 2493, '\P{^OGr_Ext=--n}', 'deprecated'); +Expect(0, 2494, '\p{OGr_Ext=--n}', 'deprecated'); +Expect(1, 2494, '\p{^OGr_Ext=--n}', 'deprecated'); +Expect(1, 2494, '\P{OGr_Ext=--n}', 'deprecated'); +Expect(0, 2494, '\P{^OGr_Ext=--n}', 'deprecated'); +Error('\p{Is_Other_Grapheme_Extend=_/a/F}'); +Error('\P{Is_Other_Grapheme_Extend=_/a/F}'); +Expect(1, 2493, '\p{Is_Other_Grapheme_Extend=f}', 'deprecated'); +Expect(0, 2493, '\p{^Is_Other_Grapheme_Extend=f}', 'deprecated'); +Expect(0, 2493, '\P{Is_Other_Grapheme_Extend=f}', 'deprecated'); +Expect(1, 2493, '\P{^Is_Other_Grapheme_Extend=f}', 'deprecated'); +Expect(0, 2494, '\p{Is_Other_Grapheme_Extend=f}', 'deprecated'); +Expect(1, 2494, '\p{^Is_Other_Grapheme_Extend=f}', 'deprecated'); +Expect(1, 2494, '\P{Is_Other_Grapheme_Extend=f}', 'deprecated'); +Expect(0, 2494, '\P{^Is_Other_Grapheme_Extend=f}', 'deprecated'); +Expect(1, 2493, '\p{Is_Other_Grapheme_Extend= -F}', 'deprecated'); +Expect(0, 2493, '\p{^Is_Other_Grapheme_Extend= -F}', 'deprecated'); +Expect(0, 2493, '\P{Is_Other_Grapheme_Extend= -F}', 'deprecated'); +Expect(1, 2493, '\P{^Is_Other_Grapheme_Extend= -F}', 'deprecated'); +Expect(0, 2494, '\p{Is_Other_Grapheme_Extend= -F}', 'deprecated'); +Expect(1, 2494, '\p{^Is_Other_Grapheme_Extend= -F}', 'deprecated'); +Expect(1, 2494, '\P{Is_Other_Grapheme_Extend= -F}', 'deprecated'); +Expect(0, 2494, '\P{^Is_Other_Grapheme_Extend= -F}', 'deprecated'); +Error('\p{Is_OGr_Ext=_/a/False}'); +Error('\P{Is_OGr_Ext=_/a/False}'); +Expect(1, 2493, '\p{Is_OGr_Ext=false}', 'deprecated'); +Expect(0, 2493, '\p{^Is_OGr_Ext=false}', 'deprecated'); +Expect(0, 2493, '\P{Is_OGr_Ext=false}', 'deprecated'); +Expect(1, 2493, '\P{^Is_OGr_Ext=false}', 'deprecated'); +Expect(0, 2494, '\p{Is_OGr_Ext=false}', 'deprecated'); +Expect(1, 2494, '\p{^Is_OGr_Ext=false}', 'deprecated'); +Expect(1, 2494, '\P{Is_OGr_Ext=false}', 'deprecated'); +Expect(0, 2494, '\P{^Is_OGr_Ext=false}', 'deprecated'); +Expect(1, 2493, '\p{Is_OGr_Ext= false}', 'deprecated'); +Expect(0, 2493, '\p{^Is_OGr_Ext= false}', 'deprecated'); +Expect(0, 2493, '\P{Is_OGr_Ext= false}', 'deprecated'); +Expect(1, 2493, '\P{^Is_OGr_Ext= false}', 'deprecated'); +Expect(0, 2494, '\p{Is_OGr_Ext= false}', 'deprecated'); +Expect(1, 2494, '\p{^Is_OGr_Ext= false}', 'deprecated'); +Expect(1, 2494, '\P{Is_OGr_Ext= false}', 'deprecated'); +Expect(0, 2494, '\P{^Is_OGr_Ext= false}', 'deprecated'); +Error('\p{Grapheme_Link=Yes}'); +Error('\P{Grapheme_Link=Yes}'); +Error('\p{Gr_Link=Y}'); +Error('\P{Gr_Link=Y}'); +Error('\p{Is_Grapheme_Link=T}'); +Error('\P{Is_Grapheme_Link=T}'); +Error('\p{Is_Gr_Link=True}'); +Error('\P{Is_Gr_Link=True}'); +Error('\p{Grapheme_Link=No}'); +Error('\P{Grapheme_Link=No}'); +Error('\p{Gr_Link=N}'); +Error('\P{Gr_Link=N}'); +Error('\p{Is_Grapheme_Link=F}'); +Error('\P{Is_Grapheme_Link=F}'); +Error('\p{Is_Gr_Link=False}'); +Error('\P{Is_Gr_Link=False}'); +Error('\p{Bidi_Control=/a/ _Yes}'); +Error('\P{Bidi_Control=/a/ _Yes}'); +Expect(1, 8207, '\p{Bidi_Control: yes}', ""); +Expect(0, 8207, '\p{^Bidi_Control: yes}', ""); +Expect(0, 8207, '\P{Bidi_Control: yes}', ""); +Expect(1, 8207, '\P{^Bidi_Control: yes}', ""); +Expect(0, 8205, '\p{Bidi_Control: yes}', ""); +Expect(1, 8205, '\p{^Bidi_Control: yes}', ""); +Expect(1, 8205, '\P{Bidi_Control: yes}', ""); +Expect(0, 8205, '\P{^Bidi_Control: yes}', ""); +Expect(1, 8207, '\p{Bidi_Control=-_YES}', ""); +Expect(0, 8207, '\p{^Bidi_Control=-_YES}', ""); +Expect(0, 8207, '\P{Bidi_Control=-_YES}', ""); +Expect(1, 8207, '\P{^Bidi_Control=-_YES}', ""); +Expect(0, 8205, '\p{Bidi_Control=-_YES}', ""); +Expect(1, 8205, '\p{^Bidi_Control=-_YES}', ""); +Expect(1, 8205, '\P{Bidi_Control=-_YES}', ""); +Expect(0, 8205, '\P{^Bidi_Control=-_YES}', ""); +Error('\p{Bidi_C=-/a/Y}'); +Error('\P{Bidi_C=-/a/Y}'); +Expect(1, 8207, '\p{Bidi_C=y}', ""); +Expect(0, 8207, '\p{^Bidi_C=y}', ""); +Expect(0, 8207, '\P{Bidi_C=y}', ""); +Expect(1, 8207, '\P{^Bidi_C=y}', ""); +Expect(0, 8205, '\p{Bidi_C=y}', ""); +Expect(1, 8205, '\p{^Bidi_C=y}', ""); +Expect(1, 8205, '\P{Bidi_C=y}', ""); +Expect(0, 8205, '\P{^Bidi_C=y}', ""); +Expect(1, 8207, '\p{Bidi_C=_ Y}', ""); +Expect(0, 8207, '\p{^Bidi_C=_ Y}', ""); +Expect(0, 8207, '\P{Bidi_C=_ Y}', ""); +Expect(1, 8207, '\P{^Bidi_C=_ Y}', ""); +Expect(0, 8205, '\p{Bidi_C=_ Y}', ""); +Expect(1, 8205, '\p{^Bidi_C=_ Y}', ""); +Expect(1, 8205, '\P{Bidi_C=_ Y}', ""); +Expect(0, 8205, '\P{^Bidi_C=_ Y}', ""); +Error('\p{Is_Bidi_Control= T:=}'); +Error('\P{Is_Bidi_Control= T:=}'); +Expect(1, 8207, '\p{Is_Bidi_Control=t}', ""); +Expect(0, 8207, '\p{^Is_Bidi_Control=t}', ""); +Expect(0, 8207, '\P{Is_Bidi_Control=t}', ""); +Expect(1, 8207, '\P{^Is_Bidi_Control=t}', ""); +Expect(0, 8205, '\p{Is_Bidi_Control=t}', ""); +Expect(1, 8205, '\p{^Is_Bidi_Control=t}', ""); +Expect(1, 8205, '\P{Is_Bidi_Control=t}', ""); +Expect(0, 8205, '\P{^Is_Bidi_Control=t}', ""); +Expect(1, 8207, '\p{Is_Bidi_Control=__T}', ""); +Expect(0, 8207, '\p{^Is_Bidi_Control=__T}', ""); +Expect(0, 8207, '\P{Is_Bidi_Control=__T}', ""); +Expect(1, 8207, '\P{^Is_Bidi_Control=__T}', ""); +Expect(0, 8205, '\p{Is_Bidi_Control=__T}', ""); +Expect(1, 8205, '\p{^Is_Bidi_Control=__T}', ""); +Expect(1, 8205, '\P{Is_Bidi_Control=__T}', ""); +Expect(0, 8205, '\P{^Is_Bidi_Control=__T}', ""); +Error('\p{Is_Bidi_C=:=_-True}'); +Error('\P{Is_Bidi_C=:=_-True}'); +Expect(1, 8207, '\p{Is_Bidi_C:true}', ""); +Expect(0, 8207, '\p{^Is_Bidi_C:true}', ""); +Expect(0, 8207, '\P{Is_Bidi_C:true}', ""); +Expect(1, 8207, '\P{^Is_Bidi_C:true}', ""); +Expect(0, 8205, '\p{Is_Bidi_C:true}', ""); +Expect(1, 8205, '\p{^Is_Bidi_C:true}', ""); +Expect(1, 8205, '\P{Is_Bidi_C:true}', ""); +Expect(0, 8205, '\P{^Is_Bidi_C:true}', ""); +Expect(1, 8207, '\p{Is_Bidi_C=-True}', ""); +Expect(0, 8207, '\p{^Is_Bidi_C=-True}', ""); +Expect(0, 8207, '\P{Is_Bidi_C=-True}', ""); +Expect(1, 8207, '\P{^Is_Bidi_C=-True}', ""); +Expect(0, 8205, '\p{Is_Bidi_C=-True}', ""); +Expect(1, 8205, '\p{^Is_Bidi_C=-True}', ""); +Expect(1, 8205, '\P{Is_Bidi_C=-True}', ""); +Expect(0, 8205, '\P{^Is_Bidi_C=-True}', ""); +Error('\p{Bidi_Control= No/a/}'); +Error('\P{Bidi_Control= No/a/}'); +Expect(1, 8205, '\p{Bidi_Control=no}', ""); +Expect(0, 8205, '\p{^Bidi_Control=no}', ""); +Expect(0, 8205, '\P{Bidi_Control=no}', ""); +Expect(1, 8205, '\P{^Bidi_Control=no}', ""); +Expect(0, 8207, '\p{Bidi_Control=no}', ""); +Expect(1, 8207, '\p{^Bidi_Control=no}', ""); +Expect(1, 8207, '\P{Bidi_Control=no}', ""); +Expect(0, 8207, '\P{^Bidi_Control=no}', ""); +Expect(1, 8205, '\p{Bidi_Control=-_No}', ""); +Expect(0, 8205, '\p{^Bidi_Control=-_No}', ""); +Expect(0, 8205, '\P{Bidi_Control=-_No}', ""); +Expect(1, 8205, '\P{^Bidi_Control=-_No}', ""); +Expect(0, 8207, '\p{Bidi_Control=-_No}', ""); +Expect(1, 8207, '\p{^Bidi_Control=-_No}', ""); +Expect(1, 8207, '\P{Bidi_Control=-_No}', ""); +Expect(0, 8207, '\P{^Bidi_Control=-_No}', ""); +Error('\p{Bidi_C= n/a/}'); +Error('\P{Bidi_C= n/a/}'); +Expect(1, 8205, '\p{Bidi_C=n}', ""); +Expect(0, 8205, '\p{^Bidi_C=n}', ""); +Expect(0, 8205, '\P{Bidi_C=n}', ""); +Expect(1, 8205, '\P{^Bidi_C=n}', ""); +Expect(0, 8207, '\p{Bidi_C=n}', ""); +Expect(1, 8207, '\p{^Bidi_C=n}', ""); +Expect(1, 8207, '\P{Bidi_C=n}', ""); +Expect(0, 8207, '\P{^Bidi_C=n}', ""); +Expect(1, 8205, '\p{Bidi_C= N}', ""); +Expect(0, 8205, '\p{^Bidi_C= N}', ""); +Expect(0, 8205, '\P{Bidi_C= N}', ""); +Expect(1, 8205, '\P{^Bidi_C= N}', ""); +Expect(0, 8207, '\p{Bidi_C= N}', ""); +Expect(1, 8207, '\p{^Bidi_C= N}', ""); +Expect(1, 8207, '\P{Bidi_C= N}', ""); +Expect(0, 8207, '\P{^Bidi_C= N}', ""); +Error('\p{Is_Bidi_Control=_:=F}'); +Error('\P{Is_Bidi_Control=_:=F}'); +Expect(1, 8205, '\p{Is_Bidi_Control: f}', ""); +Expect(0, 8205, '\p{^Is_Bidi_Control: f}', ""); +Expect(0, 8205, '\P{Is_Bidi_Control: f}', ""); +Expect(1, 8205, '\P{^Is_Bidi_Control: f}', ""); +Expect(0, 8207, '\p{Is_Bidi_Control: f}', ""); +Expect(1, 8207, '\p{^Is_Bidi_Control: f}', ""); +Expect(1, 8207, '\P{Is_Bidi_Control: f}', ""); +Expect(0, 8207, '\P{^Is_Bidi_Control: f}', ""); +Expect(1, 8205, '\p{Is_Bidi_Control=_-F}', ""); +Expect(0, 8205, '\p{^Is_Bidi_Control=_-F}', ""); +Expect(0, 8205, '\P{Is_Bidi_Control=_-F}', ""); +Expect(1, 8205, '\P{^Is_Bidi_Control=_-F}', ""); +Expect(0, 8207, '\p{Is_Bidi_Control=_-F}', ""); +Expect(1, 8207, '\p{^Is_Bidi_Control=_-F}', ""); +Expect(1, 8207, '\P{Is_Bidi_Control=_-F}', ""); +Expect(0, 8207, '\P{^Is_Bidi_Control=_-F}', ""); +Error('\p{Is_Bidi_C: _:=False}'); +Error('\P{Is_Bidi_C: _:=False}'); +Expect(1, 8205, '\p{Is_Bidi_C=false}', ""); +Expect(0, 8205, '\p{^Is_Bidi_C=false}', ""); +Expect(0, 8205, '\P{Is_Bidi_C=false}', ""); +Expect(1, 8205, '\P{^Is_Bidi_C=false}', ""); +Expect(0, 8207, '\p{Is_Bidi_C=false}', ""); +Expect(1, 8207, '\p{^Is_Bidi_C=false}', ""); +Expect(1, 8207, '\P{Is_Bidi_C=false}', ""); +Expect(0, 8207, '\P{^Is_Bidi_C=false}', ""); +Expect(1, 8205, '\p{Is_Bidi_C=-_False}', ""); +Expect(0, 8205, '\p{^Is_Bidi_C=-_False}', ""); +Expect(0, 8205, '\P{Is_Bidi_C=-_False}', ""); +Expect(1, 8205, '\P{^Is_Bidi_C=-_False}', ""); +Expect(0, 8207, '\p{Is_Bidi_C=-_False}', ""); +Expect(1, 8207, '\p{^Is_Bidi_C=-_False}', ""); +Expect(1, 8207, '\P{Is_Bidi_C=-_False}', ""); +Expect(0, 8207, '\P{^Is_Bidi_C=-_False}', ""); +Error('\p{ID_Continue= yes:=}'); +Error('\P{ID_Continue= yes:=}'); +Expect(1, 57, '\p{ID_Continue=yes}', ""); +Expect(0, 57, '\p{^ID_Continue=yes}', ""); +Expect(0, 57, '\P{ID_Continue=yes}', ""); +Expect(1, 57, '\P{^ID_Continue=yes}', ""); +Expect(0, 47, '\p{ID_Continue=yes}', ""); +Expect(1, 47, '\p{^ID_Continue=yes}', ""); +Expect(1, 47, '\P{ID_Continue=yes}', ""); +Expect(0, 47, '\P{^ID_Continue=yes}', ""); +Expect(1, 57, '\p{ID_Continue=_Yes}', ""); +Expect(0, 57, '\p{^ID_Continue=_Yes}', ""); +Expect(0, 57, '\P{ID_Continue=_Yes}', ""); +Expect(1, 57, '\P{^ID_Continue=_Yes}', ""); +Expect(0, 47, '\p{ID_Continue=_Yes}', ""); +Expect(1, 47, '\p{^ID_Continue=_Yes}', ""); +Expect(1, 47, '\P{ID_Continue=_Yes}', ""); +Expect(0, 47, '\P{^ID_Continue=_Yes}', ""); +Error('\p{IDC=_/a/y}'); +Error('\P{IDC=_/a/y}'); +Expect(1, 57, '\p{IDC=y}', ""); +Expect(0, 57, '\p{^IDC=y}', ""); +Expect(0, 57, '\P{IDC=y}', ""); +Expect(1, 57, '\P{^IDC=y}', ""); +Expect(0, 47, '\p{IDC=y}', ""); +Expect(1, 47, '\p{^IDC=y}', ""); +Expect(1, 47, '\P{IDC=y}', ""); +Expect(0, 47, '\P{^IDC=y}', ""); +Expect(1, 57, '\p{IDC: Y}', ""); +Expect(0, 57, '\p{^IDC: Y}', ""); +Expect(0, 57, '\P{IDC: Y}', ""); +Expect(1, 57, '\P{^IDC: Y}', ""); +Expect(0, 47, '\p{IDC: Y}', ""); +Expect(1, 47, '\p{^IDC: Y}', ""); +Expect(1, 47, '\P{IDC: Y}', ""); +Expect(0, 47, '\P{^IDC: Y}', ""); +Error('\p{Is_ID_Continue= t:=}'); +Error('\P{Is_ID_Continue= t:=}'); +Expect(1, 57, '\p{Is_ID_Continue=t}', ""); +Expect(0, 57, '\p{^Is_ID_Continue=t}', ""); +Expect(0, 57, '\P{Is_ID_Continue=t}', ""); +Expect(1, 57, '\P{^Is_ID_Continue=t}', ""); +Expect(0, 47, '\p{Is_ID_Continue=t}', ""); +Expect(1, 47, '\p{^Is_ID_Continue=t}', ""); +Expect(1, 47, '\P{Is_ID_Continue=t}', ""); +Expect(0, 47, '\P{^Is_ID_Continue=t}', ""); +Expect(1, 57, '\p{Is_ID_Continue= T}', ""); +Expect(0, 57, '\p{^Is_ID_Continue= T}', ""); +Expect(0, 57, '\P{Is_ID_Continue= T}', ""); +Expect(1, 57, '\P{^Is_ID_Continue= T}', ""); +Expect(0, 47, '\p{Is_ID_Continue= T}', ""); +Expect(1, 47, '\p{^Is_ID_Continue= T}', ""); +Expect(1, 47, '\P{Is_ID_Continue= T}', ""); +Expect(0, 47, '\P{^Is_ID_Continue= T}', ""); +Error('\p{Is_IDC= TRUE:=}'); +Error('\P{Is_IDC= TRUE:=}'); +Expect(1, 57, '\p{Is_IDC: true}', ""); +Expect(0, 57, '\p{^Is_IDC: true}', ""); +Expect(0, 57, '\P{Is_IDC: true}', ""); +Expect(1, 57, '\P{^Is_IDC: true}', ""); +Expect(0, 47, '\p{Is_IDC: true}', ""); +Expect(1, 47, '\p{^Is_IDC: true}', ""); +Expect(1, 47, '\P{Is_IDC: true}', ""); +Expect(0, 47, '\P{^Is_IDC: true}', ""); +Expect(1, 57, '\p{Is_IDC: _True}', ""); +Expect(0, 57, '\p{^Is_IDC: _True}', ""); +Expect(0, 57, '\P{Is_IDC: _True}', ""); +Expect(1, 57, '\P{^Is_IDC: _True}', ""); +Expect(0, 47, '\p{Is_IDC: _True}', ""); +Expect(1, 47, '\p{^Is_IDC: _True}', ""); +Expect(1, 47, '\P{Is_IDC: _True}', ""); +Expect(0, 47, '\P{^Is_IDC: _True}', ""); +Error('\p{ID_Continue=/a/NO}'); +Error('\P{ID_Continue=/a/NO}'); +Expect(1, 47, '\p{ID_Continue=no}', ""); +Expect(0, 47, '\p{^ID_Continue=no}', ""); +Expect(0, 47, '\P{ID_Continue=no}', ""); +Expect(1, 47, '\P{^ID_Continue=no}', ""); +Expect(0, 57, '\p{ID_Continue=no}', ""); +Expect(1, 57, '\p{^ID_Continue=no}', ""); +Expect(1, 57, '\P{ID_Continue=no}', ""); +Expect(0, 57, '\P{^ID_Continue=no}', ""); +Expect(1, 47, '\p{ID_Continue=_no}', ""); +Expect(0, 47, '\p{^ID_Continue=_no}', ""); +Expect(0, 47, '\P{ID_Continue=_no}', ""); +Expect(1, 47, '\P{^ID_Continue=_no}', ""); +Expect(0, 57, '\p{ID_Continue=_no}', ""); +Expect(1, 57, '\p{^ID_Continue=_no}', ""); +Expect(1, 57, '\P{ID_Continue=_no}', ""); +Expect(0, 57, '\P{^ID_Continue=_no}', ""); +Error('\p{IDC=/a/ N}'); +Error('\P{IDC=/a/ N}'); +Expect(1, 47, '\p{IDC=n}', ""); +Expect(0, 47, '\p{^IDC=n}', ""); +Expect(0, 47, '\P{IDC=n}', ""); +Expect(1, 47, '\P{^IDC=n}', ""); +Expect(0, 57, '\p{IDC=n}', ""); +Expect(1, 57, '\p{^IDC=n}', ""); +Expect(1, 57, '\P{IDC=n}', ""); +Expect(0, 57, '\P{^IDC=n}', ""); +Expect(1, 47, '\p{IDC= N}', ""); +Expect(0, 47, '\p{^IDC= N}', ""); +Expect(0, 47, '\P{IDC= N}', ""); +Expect(1, 47, '\P{^IDC= N}', ""); +Expect(0, 57, '\p{IDC= N}', ""); +Expect(1, 57, '\p{^IDC= N}', ""); +Expect(1, 57, '\P{IDC= N}', ""); +Expect(0, 57, '\P{^IDC= N}', ""); +Error('\p{Is_ID_Continue= _f:=}'); +Error('\P{Is_ID_Continue= _f:=}'); +Expect(1, 47, '\p{Is_ID_Continue=f}', ""); +Expect(0, 47, '\p{^Is_ID_Continue=f}', ""); +Expect(0, 47, '\P{Is_ID_Continue=f}', ""); +Expect(1, 47, '\P{^Is_ID_Continue=f}', ""); +Expect(0, 57, '\p{Is_ID_Continue=f}', ""); +Expect(1, 57, '\p{^Is_ID_Continue=f}', ""); +Expect(1, 57, '\P{Is_ID_Continue=f}', ""); +Expect(0, 57, '\P{^Is_ID_Continue=f}', ""); +Expect(1, 47, '\p{Is_ID_Continue=-F}', ""); +Expect(0, 47, '\p{^Is_ID_Continue=-F}', ""); +Expect(0, 47, '\P{Is_ID_Continue=-F}', ""); +Expect(1, 47, '\P{^Is_ID_Continue=-F}', ""); +Expect(0, 57, '\p{Is_ID_Continue=-F}', ""); +Expect(1, 57, '\p{^Is_ID_Continue=-F}', ""); +Expect(1, 57, '\P{Is_ID_Continue=-F}', ""); +Expect(0, 57, '\P{^Is_ID_Continue=-F}', ""); +Error('\p{Is_IDC=:= -False}'); +Error('\P{Is_IDC=:= -False}'); +Expect(1, 47, '\p{Is_IDC=false}', ""); +Expect(0, 47, '\p{^Is_IDC=false}', ""); +Expect(0, 47, '\P{Is_IDC=false}', ""); +Expect(1, 47, '\P{^Is_IDC=false}', ""); +Expect(0, 57, '\p{Is_IDC=false}', ""); +Expect(1, 57, '\p{^Is_IDC=false}', ""); +Expect(1, 57, '\P{Is_IDC=false}', ""); +Expect(0, 57, '\P{^Is_IDC=false}', ""); +Expect(1, 47, '\p{Is_IDC= -False}', ""); +Expect(0, 47, '\p{^Is_IDC= -False}', ""); +Expect(0, 47, '\P{Is_IDC= -False}', ""); +Expect(1, 47, '\P{^Is_IDC= -False}', ""); +Expect(0, 57, '\p{Is_IDC= -False}', ""); +Expect(1, 57, '\p{^Is_IDC= -False}', ""); +Expect(1, 57, '\P{Is_IDC= -False}', ""); +Expect(0, 57, '\P{^Is_IDC= -False}', ""); +Error('\p{Other_Alphabetic::= -Yes}'); +Error('\P{Other_Alphabetic::= -Yes}'); +Expect(1, 837, '\p{Other_Alphabetic=yes}', 'deprecated'); +Expect(0, 837, '\p{^Other_Alphabetic=yes}', 'deprecated'); +Expect(0, 837, '\P{Other_Alphabetic=yes}', 'deprecated'); +Expect(1, 837, '\P{^Other_Alphabetic=yes}', 'deprecated'); +Expect(0, 836, '\p{Other_Alphabetic=yes}', 'deprecated'); +Expect(1, 836, '\p{^Other_Alphabetic=yes}', 'deprecated'); +Expect(1, 836, '\P{Other_Alphabetic=yes}', 'deprecated'); +Expect(0, 836, '\P{^Other_Alphabetic=yes}', 'deprecated'); +Expect(1, 837, '\p{Other_Alphabetic: __yes}', 'deprecated'); +Expect(0, 837, '\p{^Other_Alphabetic: __yes}', 'deprecated'); +Expect(0, 837, '\P{Other_Alphabetic: __yes}', 'deprecated'); +Expect(1, 837, '\P{^Other_Alphabetic: __yes}', 'deprecated'); +Expect(0, 836, '\p{Other_Alphabetic: __yes}', 'deprecated'); +Expect(1, 836, '\p{^Other_Alphabetic: __yes}', 'deprecated'); +Expect(1, 836, '\P{Other_Alphabetic: __yes}', 'deprecated'); +Expect(0, 836, '\P{^Other_Alphabetic: __yes}', 'deprecated'); +Error('\p{OAlpha=-/a/Y}'); +Error('\P{OAlpha=-/a/Y}'); +Expect(1, 837, '\p{OAlpha=y}', 'deprecated'); +Expect(0, 837, '\p{^OAlpha=y}', 'deprecated'); +Expect(0, 837, '\P{OAlpha=y}', 'deprecated'); +Expect(1, 837, '\P{^OAlpha=y}', 'deprecated'); +Expect(0, 836, '\p{OAlpha=y}', 'deprecated'); +Expect(1, 836, '\p{^OAlpha=y}', 'deprecated'); +Expect(1, 836, '\P{OAlpha=y}', 'deprecated'); +Expect(0, 836, '\P{^OAlpha=y}', 'deprecated'); +Expect(1, 837, '\p{OAlpha= Y}', 'deprecated'); +Expect(0, 837, '\p{^OAlpha= Y}', 'deprecated'); +Expect(0, 837, '\P{OAlpha= Y}', 'deprecated'); +Expect(1, 837, '\P{^OAlpha= Y}', 'deprecated'); +Expect(0, 836, '\p{OAlpha= Y}', 'deprecated'); +Expect(1, 836, '\p{^OAlpha= Y}', 'deprecated'); +Expect(1, 836, '\P{OAlpha= Y}', 'deprecated'); +Expect(0, 836, '\P{^OAlpha= Y}', 'deprecated'); +Error('\p{Is_Other_Alphabetic=:= T}'); +Error('\P{Is_Other_Alphabetic=:= T}'); +Expect(1, 837, '\p{Is_Other_Alphabetic=t}', 'deprecated'); +Expect(0, 837, '\p{^Is_Other_Alphabetic=t}', 'deprecated'); +Expect(0, 837, '\P{Is_Other_Alphabetic=t}', 'deprecated'); +Expect(1, 837, '\P{^Is_Other_Alphabetic=t}', 'deprecated'); +Expect(0, 836, '\p{Is_Other_Alphabetic=t}', 'deprecated'); +Expect(1, 836, '\p{^Is_Other_Alphabetic=t}', 'deprecated'); +Expect(1, 836, '\P{Is_Other_Alphabetic=t}', 'deprecated'); +Expect(0, 836, '\P{^Is_Other_Alphabetic=t}', 'deprecated'); +Expect(1, 837, '\p{Is_Other_Alphabetic=_T}', 'deprecated'); +Expect(0, 837, '\p{^Is_Other_Alphabetic=_T}', 'deprecated'); +Expect(0, 837, '\P{Is_Other_Alphabetic=_T}', 'deprecated'); +Expect(1, 837, '\P{^Is_Other_Alphabetic=_T}', 'deprecated'); +Expect(0, 836, '\p{Is_Other_Alphabetic=_T}', 'deprecated'); +Expect(1, 836, '\p{^Is_Other_Alphabetic=_T}', 'deprecated'); +Expect(1, 836, '\P{Is_Other_Alphabetic=_T}', 'deprecated'); +Expect(0, 836, '\P{^Is_Other_Alphabetic=_T}', 'deprecated'); +Error('\p{Is_OAlpha=:=-True}'); +Error('\P{Is_OAlpha=:=-True}'); +Expect(1, 837, '\p{Is_OAlpha: true}', 'deprecated'); +Expect(0, 837, '\p{^Is_OAlpha: true}', 'deprecated'); +Expect(0, 837, '\P{Is_OAlpha: true}', 'deprecated'); +Expect(1, 837, '\P{^Is_OAlpha: true}', 'deprecated'); +Expect(0, 836, '\p{Is_OAlpha: true}', 'deprecated'); +Expect(1, 836, '\p{^Is_OAlpha: true}', 'deprecated'); +Expect(1, 836, '\P{Is_OAlpha: true}', 'deprecated'); +Expect(0, 836, '\P{^Is_OAlpha: true}', 'deprecated'); +Expect(1, 837, '\p{Is_OAlpha: _TRUE}', 'deprecated'); +Expect(0, 837, '\p{^Is_OAlpha: _TRUE}', 'deprecated'); +Expect(0, 837, '\P{Is_OAlpha: _TRUE}', 'deprecated'); +Expect(1, 837, '\P{^Is_OAlpha: _TRUE}', 'deprecated'); +Expect(0, 836, '\p{Is_OAlpha: _TRUE}', 'deprecated'); +Expect(1, 836, '\p{^Is_OAlpha: _TRUE}', 'deprecated'); +Expect(1, 836, '\P{Is_OAlpha: _TRUE}', 'deprecated'); +Expect(0, 836, '\P{^Is_OAlpha: _TRUE}', 'deprecated'); +Error('\p{Other_Alphabetic=/a/No}'); +Error('\P{Other_Alphabetic=/a/No}'); +Expect(1, 836, '\p{Other_Alphabetic=no}', 'deprecated'); +Expect(0, 836, '\p{^Other_Alphabetic=no}', 'deprecated'); +Expect(0, 836, '\P{Other_Alphabetic=no}', 'deprecated'); +Expect(1, 836, '\P{^Other_Alphabetic=no}', 'deprecated'); +Expect(0, 837, '\p{Other_Alphabetic=no}', 'deprecated'); +Expect(1, 837, '\p{^Other_Alphabetic=no}', 'deprecated'); +Expect(1, 837, '\P{Other_Alphabetic=no}', 'deprecated'); +Expect(0, 837, '\P{^Other_Alphabetic=no}', 'deprecated'); +Expect(1, 836, '\p{Other_Alphabetic= No}', 'deprecated'); +Expect(0, 836, '\p{^Other_Alphabetic= No}', 'deprecated'); +Expect(0, 836, '\P{Other_Alphabetic= No}', 'deprecated'); +Expect(1, 836, '\P{^Other_Alphabetic= No}', 'deprecated'); +Expect(0, 837, '\p{Other_Alphabetic= No}', 'deprecated'); +Expect(1, 837, '\p{^Other_Alphabetic= No}', 'deprecated'); +Expect(1, 837, '\P{Other_Alphabetic= No}', 'deprecated'); +Expect(0, 837, '\P{^Other_Alphabetic= No}', 'deprecated'); +Error('\p{OAlpha=:=N}'); +Error('\P{OAlpha=:=N}'); +Expect(1, 836, '\p{OAlpha=n}', 'deprecated'); +Expect(0, 836, '\p{^OAlpha=n}', 'deprecated'); +Expect(0, 836, '\P{OAlpha=n}', 'deprecated'); +Expect(1, 836, '\P{^OAlpha=n}', 'deprecated'); +Expect(0, 837, '\p{OAlpha=n}', 'deprecated'); +Expect(1, 837, '\p{^OAlpha=n}', 'deprecated'); +Expect(1, 837, '\P{OAlpha=n}', 'deprecated'); +Expect(0, 837, '\P{^OAlpha=n}', 'deprecated'); +Expect(1, 836, '\p{OAlpha= N}', 'deprecated'); +Expect(0, 836, '\p{^OAlpha= N}', 'deprecated'); +Expect(0, 836, '\P{OAlpha= N}', 'deprecated'); +Expect(1, 836, '\P{^OAlpha= N}', 'deprecated'); +Expect(0, 837, '\p{OAlpha= N}', 'deprecated'); +Expect(1, 837, '\p{^OAlpha= N}', 'deprecated'); +Expect(1, 837, '\P{OAlpha= N}', 'deprecated'); +Expect(0, 837, '\P{^OAlpha= N}', 'deprecated'); +Error('\p{Is_Other_Alphabetic=_:=F}'); +Error('\P{Is_Other_Alphabetic=_:=F}'); +Expect(1, 836, '\p{Is_Other_Alphabetic=f}', 'deprecated'); +Expect(0, 836, '\p{^Is_Other_Alphabetic=f}', 'deprecated'); +Expect(0, 836, '\P{Is_Other_Alphabetic=f}', 'deprecated'); +Expect(1, 836, '\P{^Is_Other_Alphabetic=f}', 'deprecated'); +Expect(0, 837, '\p{Is_Other_Alphabetic=f}', 'deprecated'); +Expect(1, 837, '\p{^Is_Other_Alphabetic=f}', 'deprecated'); +Expect(1, 837, '\P{Is_Other_Alphabetic=f}', 'deprecated'); +Expect(0, 837, '\P{^Is_Other_Alphabetic=f}', 'deprecated'); +Expect(1, 836, '\p{Is_Other_Alphabetic: _ F}', 'deprecated'); +Expect(0, 836, '\p{^Is_Other_Alphabetic: _ F}', 'deprecated'); +Expect(0, 836, '\P{Is_Other_Alphabetic: _ F}', 'deprecated'); +Expect(1, 836, '\P{^Is_Other_Alphabetic: _ F}', 'deprecated'); +Expect(0, 837, '\p{Is_Other_Alphabetic: _ F}', 'deprecated'); +Expect(1, 837, '\p{^Is_Other_Alphabetic: _ F}', 'deprecated'); +Expect(1, 837, '\P{Is_Other_Alphabetic: _ F}', 'deprecated'); +Expect(0, 837, '\P{^Is_Other_Alphabetic: _ F}', 'deprecated'); +Error('\p{Is_OAlpha: :=_ FALSE}'); +Error('\P{Is_OAlpha: :=_ FALSE}'); +Expect(1, 836, '\p{Is_OAlpha=false}', 'deprecated'); +Expect(0, 836, '\p{^Is_OAlpha=false}', 'deprecated'); +Expect(0, 836, '\P{Is_OAlpha=false}', 'deprecated'); +Expect(1, 836, '\P{^Is_OAlpha=false}', 'deprecated'); +Expect(0, 837, '\p{Is_OAlpha=false}', 'deprecated'); +Expect(1, 837, '\p{^Is_OAlpha=false}', 'deprecated'); +Expect(1, 837, '\P{Is_OAlpha=false}', 'deprecated'); +Expect(0, 837, '\P{^Is_OAlpha=false}', 'deprecated'); +Expect(1, 836, '\p{Is_OAlpha=_-False}', 'deprecated'); +Expect(0, 836, '\p{^Is_OAlpha=_-False}', 'deprecated'); +Expect(0, 836, '\P{Is_OAlpha=_-False}', 'deprecated'); +Expect(1, 836, '\P{^Is_OAlpha=_-False}', 'deprecated'); +Expect(0, 837, '\p{Is_OAlpha=_-False}', 'deprecated'); +Expect(1, 837, '\p{^Is_OAlpha=_-False}', 'deprecated'); +Expect(1, 837, '\P{Is_OAlpha=_-False}', 'deprecated'); +Expect(0, 837, '\P{^Is_OAlpha=_-False}', 'deprecated'); +Error('\p{NFKD_Quick_Check= :=Yes}'); +Error('\P{NFKD_Quick_Check= :=Yes}'); +Expect(1, 7, '\p{NFKD_Quick_Check=yes}', ""); +Expect(0, 7, '\p{^NFKD_Quick_Check=yes}', ""); +Expect(0, 7, '\P{NFKD_Quick_Check=yes}', ""); +Expect(1, 7, '\P{^NFKD_Quick_Check=yes}', ""); +Expect(0, 271, '\p{NFKD_Quick_Check=yes}', ""); +Expect(1, 271, '\p{^NFKD_Quick_Check=yes}', ""); +Expect(1, 271, '\P{NFKD_Quick_Check=yes}', ""); +Expect(0, 271, '\P{^NFKD_Quick_Check=yes}', ""); +Expect(1, 7, '\p{NFKD_Quick_Check: YES}', ""); +Expect(0, 7, '\p{^NFKD_Quick_Check: YES}', ""); +Expect(0, 7, '\P{NFKD_Quick_Check: YES}', ""); +Expect(1, 7, '\P{^NFKD_Quick_Check: YES}', ""); +Expect(0, 271, '\p{NFKD_Quick_Check: YES}', ""); +Expect(1, 271, '\p{^NFKD_Quick_Check: YES}', ""); +Expect(1, 271, '\P{NFKD_Quick_Check: YES}', ""); +Expect(0, 271, '\P{^NFKD_Quick_Check: YES}', ""); +Error('\p{NFKD_QC=:= Y}'); +Error('\P{NFKD_QC=:= Y}'); +Expect(1, 7, '\p{NFKD_QC=y}', ""); +Expect(0, 7, '\p{^NFKD_QC=y}', ""); +Expect(0, 7, '\P{NFKD_QC=y}', ""); +Expect(1, 7, '\P{^NFKD_QC=y}', ""); +Expect(0, 271, '\p{NFKD_QC=y}', ""); +Expect(1, 271, '\p{^NFKD_QC=y}', ""); +Expect(1, 271, '\P{NFKD_QC=y}', ""); +Expect(0, 271, '\P{^NFKD_QC=y}', ""); +Expect(1, 7, '\p{NFKD_QC=-Y}', ""); +Expect(0, 7, '\p{^NFKD_QC=-Y}', ""); +Expect(0, 7, '\P{NFKD_QC=-Y}', ""); +Expect(1, 7, '\P{^NFKD_QC=-Y}', ""); +Expect(0, 271, '\p{NFKD_QC=-Y}', ""); +Expect(1, 271, '\p{^NFKD_QC=-Y}', ""); +Expect(1, 271, '\P{NFKD_QC=-Y}', ""); +Expect(0, 271, '\P{^NFKD_QC=-Y}', ""); +Error('\p{Is_NFKD_Quick_Check=/a/-Yes}'); +Error('\P{Is_NFKD_Quick_Check=/a/-Yes}'); +Expect(1, 7, '\p{Is_NFKD_Quick_Check=yes}', ""); +Expect(0, 7, '\p{^Is_NFKD_Quick_Check=yes}', ""); +Expect(0, 7, '\P{Is_NFKD_Quick_Check=yes}', ""); +Expect(1, 7, '\P{^Is_NFKD_Quick_Check=yes}', ""); +Expect(0, 271, '\p{Is_NFKD_Quick_Check=yes}', ""); +Expect(1, 271, '\p{^Is_NFKD_Quick_Check=yes}', ""); +Expect(1, 271, '\P{Is_NFKD_Quick_Check=yes}', ""); +Expect(0, 271, '\P{^Is_NFKD_Quick_Check=yes}', ""); +Expect(1, 7, '\p{Is_NFKD_Quick_Check=-yes}', ""); +Expect(0, 7, '\p{^Is_NFKD_Quick_Check=-yes}', ""); +Expect(0, 7, '\P{Is_NFKD_Quick_Check=-yes}', ""); +Expect(1, 7, '\P{^Is_NFKD_Quick_Check=-yes}', ""); +Expect(0, 271, '\p{Is_NFKD_Quick_Check=-yes}', ""); +Expect(1, 271, '\p{^Is_NFKD_Quick_Check=-yes}', ""); +Expect(1, 271, '\P{Is_NFKD_Quick_Check=-yes}', ""); +Expect(0, 271, '\P{^Is_NFKD_Quick_Check=-yes}', ""); +Error('\p{Is_NFKD_QC=_:=Y}'); +Error('\P{Is_NFKD_QC=_:=Y}'); +Expect(1, 7, '\p{Is_NFKD_QC=y}', ""); +Expect(0, 7, '\p{^Is_NFKD_QC=y}', ""); +Expect(0, 7, '\P{Is_NFKD_QC=y}', ""); +Expect(1, 7, '\P{^Is_NFKD_QC=y}', ""); +Expect(0, 271, '\p{Is_NFKD_QC=y}', ""); +Expect(1, 271, '\p{^Is_NFKD_QC=y}', ""); +Expect(1, 271, '\P{Is_NFKD_QC=y}', ""); +Expect(0, 271, '\P{^Is_NFKD_QC=y}', ""); +Expect(1, 7, '\p{Is_NFKD_QC= y}', ""); +Expect(0, 7, '\p{^Is_NFKD_QC= y}', ""); +Expect(0, 7, '\P{Is_NFKD_QC= y}', ""); +Expect(1, 7, '\P{^Is_NFKD_QC= y}', ""); +Expect(0, 271, '\p{Is_NFKD_QC= y}', ""); +Expect(1, 271, '\p{^Is_NFKD_QC= y}', ""); +Expect(1, 271, '\P{Is_NFKD_QC= y}', ""); +Expect(0, 271, '\P{^Is_NFKD_QC= y}', ""); +Error('\p{NFKD_Quick_Check=_/a/No}'); +Error('\P{NFKD_Quick_Check=_/a/No}'); +Expect(1, 271, '\p{NFKD_Quick_Check=no}', ""); +Expect(0, 271, '\p{^NFKD_Quick_Check=no}', ""); +Expect(0, 271, '\P{NFKD_Quick_Check=no}', ""); +Expect(1, 271, '\P{^NFKD_Quick_Check=no}', ""); +Expect(0, 7, '\p{NFKD_Quick_Check=no}', ""); +Expect(1, 7, '\p{^NFKD_Quick_Check=no}', ""); +Expect(1, 7, '\P{NFKD_Quick_Check=no}', ""); +Expect(0, 7, '\P{^NFKD_Quick_Check=no}', ""); +Expect(1, 271, '\p{NFKD_Quick_Check: _NO}', ""); +Expect(0, 271, '\p{^NFKD_Quick_Check: _NO}', ""); +Expect(0, 271, '\P{NFKD_Quick_Check: _NO}', ""); +Expect(1, 271, '\P{^NFKD_Quick_Check: _NO}', ""); +Expect(0, 7, '\p{NFKD_Quick_Check: _NO}', ""); +Expect(1, 7, '\p{^NFKD_Quick_Check: _NO}', ""); +Expect(1, 7, '\P{NFKD_Quick_Check: _NO}', ""); +Expect(0, 7, '\P{^NFKD_Quick_Check: _NO}', ""); +Error('\p{NFKD_QC=:=-_N}'); +Error('\P{NFKD_QC=:=-_N}'); +Expect(1, 271, '\p{NFKD_QC: n}', ""); +Expect(0, 271, '\p{^NFKD_QC: n}', ""); +Expect(0, 271, '\P{NFKD_QC: n}', ""); +Expect(1, 271, '\P{^NFKD_QC: n}', ""); +Expect(0, 7, '\p{NFKD_QC: n}', ""); +Expect(1, 7, '\p{^NFKD_QC: n}', ""); +Expect(1, 7, '\P{NFKD_QC: n}', ""); +Expect(0, 7, '\P{^NFKD_QC: n}', ""); +Error('\p{Is_NFKD_Quick_Check=/a/ No}'); +Error('\P{Is_NFKD_Quick_Check=/a/ No}'); +Expect(1, 271, '\p{Is_NFKD_Quick_Check=no}', ""); +Expect(0, 271, '\p{^Is_NFKD_Quick_Check=no}', ""); +Expect(0, 271, '\P{Is_NFKD_Quick_Check=no}', ""); +Expect(1, 271, '\P{^Is_NFKD_Quick_Check=no}', ""); +Expect(0, 7, '\p{Is_NFKD_Quick_Check=no}', ""); +Expect(1, 7, '\p{^Is_NFKD_Quick_Check=no}', ""); +Expect(1, 7, '\P{Is_NFKD_Quick_Check=no}', ""); +Expect(0, 7, '\P{^Is_NFKD_Quick_Check=no}', ""); +Expect(1, 271, '\p{Is_NFKD_Quick_Check= _NO}', ""); +Expect(0, 271, '\p{^Is_NFKD_Quick_Check= _NO}', ""); +Expect(0, 271, '\P{Is_NFKD_Quick_Check= _NO}', ""); +Expect(1, 271, '\P{^Is_NFKD_Quick_Check= _NO}', ""); +Expect(0, 7, '\p{Is_NFKD_Quick_Check= _NO}', ""); +Expect(1, 7, '\p{^Is_NFKD_Quick_Check= _NO}', ""); +Expect(1, 7, '\P{Is_NFKD_Quick_Check= _NO}', ""); +Expect(0, 7, '\P{^Is_NFKD_Quick_Check= _NO}', ""); +Error('\p{Is_NFKD_QC=_n/a/}'); +Error('\P{Is_NFKD_QC=_n/a/}'); +Expect(1, 271, '\p{Is_NFKD_QC=n}', ""); +Expect(0, 271, '\p{^Is_NFKD_QC=n}', ""); +Expect(0, 271, '\P{Is_NFKD_QC=n}', ""); +Expect(1, 271, '\P{^Is_NFKD_QC=n}', ""); +Expect(0, 7, '\p{Is_NFKD_QC=n}', ""); +Expect(1, 7, '\p{^Is_NFKD_QC=n}', ""); +Expect(1, 7, '\P{Is_NFKD_QC=n}', ""); +Expect(0, 7, '\P{^Is_NFKD_QC=n}', ""); +Expect(1, 271, '\p{Is_NFKD_QC= N}', ""); +Expect(0, 271, '\p{^Is_NFKD_QC= N}', ""); +Expect(0, 271, '\P{Is_NFKD_QC= N}', ""); +Expect(1, 271, '\P{^Is_NFKD_QC= N}', ""); +Expect(0, 7, '\p{Is_NFKD_QC= N}', ""); +Expect(1, 7, '\p{^Is_NFKD_QC= N}', ""); +Expect(1, 7, '\P{Is_NFKD_QC= N}', ""); +Expect(0, 7, '\P{^Is_NFKD_QC= N}', ""); +Error('\p{Math=:=Yes}'); +Error('\P{Math=:=Yes}'); +Expect(1, 43, '\p{Math=yes}', ""); +Expect(0, 43, '\p{^Math=yes}', ""); +Expect(0, 43, '\P{Math=yes}', ""); +Expect(1, 43, '\P{^Math=yes}', ""); +Expect(0, 42, '\p{Math=yes}', ""); +Expect(1, 42, '\p{^Math=yes}', ""); +Expect(1, 42, '\P{Math=yes}', ""); +Expect(0, 42, '\P{^Math=yes}', ""); +Expect(1, 43, '\p{Math=_Yes}', ""); +Expect(0, 43, '\p{^Math=_Yes}', ""); +Expect(0, 43, '\P{Math=_Yes}', ""); +Expect(1, 43, '\P{^Math=_Yes}', ""); +Expect(0, 42, '\p{Math=_Yes}', ""); +Expect(1, 42, '\p{^Math=_Yes}', ""); +Expect(1, 42, '\P{Math=_Yes}', ""); +Expect(0, 42, '\P{^Math=_Yes}', ""); +Error('\p{Is_Math: /a/_Y}'); +Error('\P{Is_Math: /a/_Y}'); +Expect(1, 43, '\p{Is_Math=y}', ""); +Expect(0, 43, '\p{^Is_Math=y}', ""); +Expect(0, 43, '\P{Is_Math=y}', ""); +Expect(1, 43, '\P{^Is_Math=y}', ""); +Expect(0, 42, '\p{Is_Math=y}', ""); +Expect(1, 42, '\p{^Is_Math=y}', ""); +Expect(1, 42, '\P{Is_Math=y}', ""); +Expect(0, 42, '\P{^Is_Math=y}', ""); +Expect(1, 43, '\p{Is_Math=_ Y}', ""); +Expect(0, 43, '\p{^Is_Math=_ Y}', ""); +Expect(0, 43, '\P{Is_Math=_ Y}', ""); +Expect(1, 43, '\P{^Is_Math=_ Y}', ""); +Expect(0, 42, '\p{Is_Math=_ Y}', ""); +Expect(1, 42, '\p{^Is_Math=_ Y}', ""); +Expect(1, 42, '\P{Is_Math=_ Y}', ""); +Expect(0, 42, '\P{^Is_Math=_ Y}', ""); +Error('\p{Math=:=-_T}'); +Error('\P{Math=:=-_T}'); +Expect(1, 43, '\p{Math=t}', ""); +Expect(0, 43, '\p{^Math=t}', ""); +Expect(0, 43, '\P{Math=t}', ""); +Expect(1, 43, '\P{^Math=t}', ""); +Expect(0, 42, '\p{Math=t}', ""); +Expect(1, 42, '\p{^Math=t}', ""); +Expect(1, 42, '\P{Math=t}', ""); +Expect(0, 42, '\P{^Math=t}', ""); +Expect(1, 43, '\p{Math=_ T}', ""); +Expect(0, 43, '\p{^Math=_ T}', ""); +Expect(0, 43, '\P{Math=_ T}', ""); +Expect(1, 43, '\P{^Math=_ T}', ""); +Expect(0, 42, '\p{Math=_ T}', ""); +Expect(1, 42, '\p{^Math=_ T}', ""); +Expect(1, 42, '\P{Math=_ T}', ""); +Expect(0, 42, '\P{^Math=_ T}', ""); +Error('\p{Is_Math=- True/a/}'); +Error('\P{Is_Math=- True/a/}'); +Expect(1, 43, '\p{Is_Math:true}', ""); +Expect(0, 43, '\p{^Is_Math:true}', ""); +Expect(0, 43, '\P{Is_Math:true}', ""); +Expect(1, 43, '\P{^Is_Math:true}', ""); +Expect(0, 42, '\p{Is_Math:true}', ""); +Expect(1, 42, '\p{^Is_Math:true}', ""); +Expect(1, 42, '\P{Is_Math:true}', ""); +Expect(0, 42, '\P{^Is_Math:true}', ""); +Expect(1, 43, '\p{Is_Math: true}', ""); +Expect(0, 43, '\p{^Is_Math: true}', ""); +Expect(0, 43, '\P{Is_Math: true}', ""); +Expect(1, 43, '\P{^Is_Math: true}', ""); +Expect(0, 42, '\p{Is_Math: true}', ""); +Expect(1, 42, '\p{^Is_Math: true}', ""); +Expect(1, 42, '\P{Is_Math: true}', ""); +Expect(0, 42, '\P{^Is_Math: true}', ""); +Error('\p{Math=-/a/No}'); +Error('\P{Math=-/a/No}'); +Expect(1, 42, '\p{Math=no}', ""); +Expect(0, 42, '\p{^Math=no}', ""); +Expect(0, 42, '\P{Math=no}', ""); +Expect(1, 42, '\P{^Math=no}', ""); +Expect(0, 43, '\p{Math=no}', ""); +Expect(1, 43, '\p{^Math=no}', ""); +Expect(1, 43, '\P{Math=no}', ""); +Expect(0, 43, '\P{^Math=no}', ""); +Expect(1, 42, '\p{Math=-No}', ""); +Expect(0, 42, '\p{^Math=-No}', ""); +Expect(0, 42, '\P{Math=-No}', ""); +Expect(1, 42, '\P{^Math=-No}', ""); +Expect(0, 43, '\p{Math=-No}', ""); +Expect(1, 43, '\p{^Math=-No}', ""); +Expect(1, 43, '\P{Math=-No}', ""); +Expect(0, 43, '\P{^Math=-No}', ""); +Error('\p{Is_Math=-/a/n}'); +Error('\P{Is_Math=-/a/n}'); +Expect(1, 42, '\p{Is_Math=n}', ""); +Expect(0, 42, '\p{^Is_Math=n}', ""); +Expect(0, 42, '\P{Is_Math=n}', ""); +Expect(1, 42, '\P{^Is_Math=n}', ""); +Expect(0, 43, '\p{Is_Math=n}', ""); +Expect(1, 43, '\p{^Is_Math=n}', ""); +Expect(1, 43, '\P{Is_Math=n}', ""); +Expect(0, 43, '\P{^Is_Math=n}', ""); +Expect(1, 42, '\p{Is_Math= _N}', ""); +Expect(0, 42, '\p{^Is_Math= _N}', ""); +Expect(0, 42, '\P{Is_Math= _N}', ""); +Expect(1, 42, '\P{^Is_Math= _N}', ""); +Expect(0, 43, '\p{Is_Math= _N}', ""); +Expect(1, 43, '\p{^Is_Math= _N}', ""); +Expect(1, 43, '\P{Is_Math= _N}', ""); +Expect(0, 43, '\P{^Is_Math= _N}', ""); +Error('\p{Math= :=F}'); +Error('\P{Math= :=F}'); +Expect(1, 42, '\p{Math=f}', ""); +Expect(0, 42, '\p{^Math=f}', ""); +Expect(0, 42, '\P{Math=f}', ""); +Expect(1, 42, '\P{^Math=f}', ""); +Expect(0, 43, '\p{Math=f}', ""); +Expect(1, 43, '\p{^Math=f}', ""); +Expect(1, 43, '\P{Math=f}', ""); +Expect(0, 43, '\P{^Math=f}', ""); +Expect(1, 42, '\p{Math=--F}', ""); +Expect(0, 42, '\p{^Math=--F}', ""); +Expect(0, 42, '\P{Math=--F}', ""); +Expect(1, 42, '\P{^Math=--F}', ""); +Expect(0, 43, '\p{Math=--F}', ""); +Expect(1, 43, '\p{^Math=--F}', ""); +Expect(1, 43, '\P{Math=--F}', ""); +Expect(0, 43, '\P{^Math=--F}', ""); +Error('\p{Is_Math=-FALSE:=}'); +Error('\P{Is_Math=-FALSE:=}'); +Expect(1, 42, '\p{Is_Math=false}', ""); +Expect(0, 42, '\p{^Is_Math=false}', ""); +Expect(0, 42, '\P{Is_Math=false}', ""); +Expect(1, 42, '\P{^Is_Math=false}', ""); +Expect(0, 43, '\p{Is_Math=false}', ""); +Expect(1, 43, '\p{^Is_Math=false}', ""); +Expect(1, 43, '\P{Is_Math=false}', ""); +Expect(0, 43, '\P{^Is_Math=false}', ""); +Expect(1, 42, '\p{Is_Math= false}', ""); +Expect(0, 42, '\p{^Is_Math= false}', ""); +Expect(0, 42, '\P{Is_Math= false}', ""); +Expect(1, 42, '\P{^Is_Math= false}', ""); +Expect(0, 43, '\p{Is_Math= false}', ""); +Expect(1, 43, '\p{^Is_Math= false}', ""); +Expect(1, 43, '\P{Is_Math= false}', ""); +Expect(0, 43, '\P{^Is_Math= false}', ""); +Error('\p{Other_Uppercase::= yes}'); +Error('\P{Other_Uppercase::= yes}'); +Expect(1, 8559, '\p{Other_Uppercase=yes}', 'deprecated'); +Expect(0, 8559, '\p{^Other_Uppercase=yes}', 'deprecated'); +Expect(0, 8559, '\P{Other_Uppercase=yes}', 'deprecated'); +Expect(1, 8559, '\P{^Other_Uppercase=yes}', 'deprecated'); +Expect(0, 8543, '\p{Other_Uppercase=yes}', 'deprecated'); +Expect(1, 8543, '\p{^Other_Uppercase=yes}', 'deprecated'); +Expect(1, 8543, '\P{Other_Uppercase=yes}', 'deprecated'); +Expect(0, 8543, '\P{^Other_Uppercase=yes}', 'deprecated'); +Expect(1, 8559, '\p{Other_Uppercase=-YES}', 'deprecated'); +Expect(0, 8559, '\p{^Other_Uppercase=-YES}', 'deprecated'); +Expect(0, 8559, '\P{Other_Uppercase=-YES}', 'deprecated'); +Expect(1, 8559, '\P{^Other_Uppercase=-YES}', 'deprecated'); +Expect(0, 8543, '\p{Other_Uppercase=-YES}', 'deprecated'); +Expect(1, 8543, '\p{^Other_Uppercase=-YES}', 'deprecated'); +Expect(1, 8543, '\P{Other_Uppercase=-YES}', 'deprecated'); +Expect(0, 8543, '\P{^Other_Uppercase=-YES}', 'deprecated'); +Error('\p{OUpper=:=- Y}'); +Error('\P{OUpper=:=- Y}'); +Expect(1, 8559, '\p{OUpper=y}', 'deprecated'); +Expect(0, 8559, '\p{^OUpper=y}', 'deprecated'); +Expect(0, 8559, '\P{OUpper=y}', 'deprecated'); +Expect(1, 8559, '\P{^OUpper=y}', 'deprecated'); +Expect(0, 8543, '\p{OUpper=y}', 'deprecated'); +Expect(1, 8543, '\p{^OUpper=y}', 'deprecated'); +Expect(1, 8543, '\P{OUpper=y}', 'deprecated'); +Expect(0, 8543, '\P{^OUpper=y}', 'deprecated'); +Expect(1, 8559, '\p{OUpper= Y}', 'deprecated'); +Expect(0, 8559, '\p{^OUpper= Y}', 'deprecated'); +Expect(0, 8559, '\P{OUpper= Y}', 'deprecated'); +Expect(1, 8559, '\P{^OUpper= Y}', 'deprecated'); +Expect(0, 8543, '\p{OUpper= Y}', 'deprecated'); +Expect(1, 8543, '\p{^OUpper= Y}', 'deprecated'); +Expect(1, 8543, '\P{OUpper= Y}', 'deprecated'); +Expect(0, 8543, '\P{^OUpper= Y}', 'deprecated'); +Error('\p{Is_Other_Uppercase=/a/ T}'); +Error('\P{Is_Other_Uppercase=/a/ T}'); +Expect(1, 8559, '\p{Is_Other_Uppercase: t}', 'deprecated'); +Expect(0, 8559, '\p{^Is_Other_Uppercase: t}', 'deprecated'); +Expect(0, 8559, '\P{Is_Other_Uppercase: t}', 'deprecated'); +Expect(1, 8559, '\P{^Is_Other_Uppercase: t}', 'deprecated'); +Expect(0, 8543, '\p{Is_Other_Uppercase: t}', 'deprecated'); +Expect(1, 8543, '\p{^Is_Other_Uppercase: t}', 'deprecated'); +Expect(1, 8543, '\P{Is_Other_Uppercase: t}', 'deprecated'); +Expect(0, 8543, '\P{^Is_Other_Uppercase: t}', 'deprecated'); +Expect(1, 8559, '\p{Is_Other_Uppercase:- T}', 'deprecated'); +Expect(0, 8559, '\p{^Is_Other_Uppercase:- T}', 'deprecated'); +Expect(0, 8559, '\P{Is_Other_Uppercase:- T}', 'deprecated'); +Expect(1, 8559, '\P{^Is_Other_Uppercase:- T}', 'deprecated'); +Expect(0, 8543, '\p{Is_Other_Uppercase:- T}', 'deprecated'); +Expect(1, 8543, '\p{^Is_Other_Uppercase:- T}', 'deprecated'); +Expect(1, 8543, '\P{Is_Other_Uppercase:- T}', 'deprecated'); +Expect(0, 8543, '\P{^Is_Other_Uppercase:- T}', 'deprecated'); +Error('\p{Is_OUpper=:=- True}'); +Error('\P{Is_OUpper=:=- True}'); +Expect(1, 8559, '\p{Is_OUpper=true}', 'deprecated'); +Expect(0, 8559, '\p{^Is_OUpper=true}', 'deprecated'); +Expect(0, 8559, '\P{Is_OUpper=true}', 'deprecated'); +Expect(1, 8559, '\P{^Is_OUpper=true}', 'deprecated'); +Expect(0, 8543, '\p{Is_OUpper=true}', 'deprecated'); +Expect(1, 8543, '\p{^Is_OUpper=true}', 'deprecated'); +Expect(1, 8543, '\P{Is_OUpper=true}', 'deprecated'); +Expect(0, 8543, '\P{^Is_OUpper=true}', 'deprecated'); +Expect(1, 8559, '\p{Is_OUpper= True}', 'deprecated'); +Expect(0, 8559, '\p{^Is_OUpper= True}', 'deprecated'); +Expect(0, 8559, '\P{Is_OUpper= True}', 'deprecated'); +Expect(1, 8559, '\P{^Is_OUpper= True}', 'deprecated'); +Expect(0, 8543, '\p{Is_OUpper= True}', 'deprecated'); +Expect(1, 8543, '\p{^Is_OUpper= True}', 'deprecated'); +Expect(1, 8543, '\P{Is_OUpper= True}', 'deprecated'); +Expect(0, 8543, '\P{^Is_OUpper= True}', 'deprecated'); +Error('\p{Other_Uppercase=_:=No}'); +Error('\P{Other_Uppercase=_:=No}'); +Expect(1, 8543, '\p{Other_Uppercase: no}', 'deprecated'); +Expect(0, 8543, '\p{^Other_Uppercase: no}', 'deprecated'); +Expect(0, 8543, '\P{Other_Uppercase: no}', 'deprecated'); +Expect(1, 8543, '\P{^Other_Uppercase: no}', 'deprecated'); +Expect(0, 8559, '\p{Other_Uppercase: no}', 'deprecated'); +Expect(1, 8559, '\p{^Other_Uppercase: no}', 'deprecated'); +Expect(1, 8559, '\P{Other_Uppercase: no}', 'deprecated'); +Expect(0, 8559, '\P{^Other_Uppercase: no}', 'deprecated'); +Expect(1, 8543, '\p{Other_Uppercase: NO}', 'deprecated'); +Expect(0, 8543, '\p{^Other_Uppercase: NO}', 'deprecated'); +Expect(0, 8543, '\P{Other_Uppercase: NO}', 'deprecated'); +Expect(1, 8543, '\P{^Other_Uppercase: NO}', 'deprecated'); +Expect(0, 8559, '\p{Other_Uppercase: NO}', 'deprecated'); +Expect(1, 8559, '\p{^Other_Uppercase: NO}', 'deprecated'); +Expect(1, 8559, '\P{Other_Uppercase: NO}', 'deprecated'); +Expect(0, 8559, '\P{^Other_Uppercase: NO}', 'deprecated'); +Error('\p{OUpper= N/a/}'); +Error('\P{OUpper= N/a/}'); +Expect(1, 8543, '\p{OUpper=n}', 'deprecated'); +Expect(0, 8543, '\p{^OUpper=n}', 'deprecated'); +Expect(0, 8543, '\P{OUpper=n}', 'deprecated'); +Expect(1, 8543, '\P{^OUpper=n}', 'deprecated'); +Expect(0, 8559, '\p{OUpper=n}', 'deprecated'); +Expect(1, 8559, '\p{^OUpper=n}', 'deprecated'); +Expect(1, 8559, '\P{OUpper=n}', 'deprecated'); +Expect(0, 8559, '\P{^OUpper=n}', 'deprecated'); +Expect(1, 8543, '\p{OUpper=_ N}', 'deprecated'); +Expect(0, 8543, '\p{^OUpper=_ N}', 'deprecated'); +Expect(0, 8543, '\P{OUpper=_ N}', 'deprecated'); +Expect(1, 8543, '\P{^OUpper=_ N}', 'deprecated'); +Expect(0, 8559, '\p{OUpper=_ N}', 'deprecated'); +Expect(1, 8559, '\p{^OUpper=_ N}', 'deprecated'); +Expect(1, 8559, '\P{OUpper=_ N}', 'deprecated'); +Expect(0, 8559, '\P{^OUpper=_ N}', 'deprecated'); +Error('\p{Is_Other_Uppercase=/a/-f}'); +Error('\P{Is_Other_Uppercase=/a/-f}'); +Expect(1, 8543, '\p{Is_Other_Uppercase: f}', 'deprecated'); +Expect(0, 8543, '\p{^Is_Other_Uppercase: f}', 'deprecated'); +Expect(0, 8543, '\P{Is_Other_Uppercase: f}', 'deprecated'); +Expect(1, 8543, '\P{^Is_Other_Uppercase: f}', 'deprecated'); +Expect(0, 8559, '\p{Is_Other_Uppercase: f}', 'deprecated'); +Expect(1, 8559, '\p{^Is_Other_Uppercase: f}', 'deprecated'); +Expect(1, 8559, '\P{Is_Other_Uppercase: f}', 'deprecated'); +Expect(0, 8559, '\P{^Is_Other_Uppercase: f}', 'deprecated'); +Expect(1, 8543, '\p{Is_Other_Uppercase=_F}', 'deprecated'); +Expect(0, 8543, '\p{^Is_Other_Uppercase=_F}', 'deprecated'); +Expect(0, 8543, '\P{Is_Other_Uppercase=_F}', 'deprecated'); +Expect(1, 8543, '\P{^Is_Other_Uppercase=_F}', 'deprecated'); +Expect(0, 8559, '\p{Is_Other_Uppercase=_F}', 'deprecated'); +Expect(1, 8559, '\p{^Is_Other_Uppercase=_F}', 'deprecated'); +Expect(1, 8559, '\P{Is_Other_Uppercase=_F}', 'deprecated'); +Expect(0, 8559, '\P{^Is_Other_Uppercase=_F}', 'deprecated'); +Error('\p{Is_OUpper=_:=False}'); +Error('\P{Is_OUpper=_:=False}'); +Expect(1, 8543, '\p{Is_OUpper=false}', 'deprecated'); +Expect(0, 8543, '\p{^Is_OUpper=false}', 'deprecated'); +Expect(0, 8543, '\P{Is_OUpper=false}', 'deprecated'); +Expect(1, 8543, '\P{^Is_OUpper=false}', 'deprecated'); +Expect(0, 8559, '\p{Is_OUpper=false}', 'deprecated'); +Expect(1, 8559, '\p{^Is_OUpper=false}', 'deprecated'); +Expect(1, 8559, '\P{Is_OUpper=false}', 'deprecated'); +Expect(0, 8559, '\P{^Is_OUpper=false}', 'deprecated'); +Expect(1, 8543, '\p{Is_OUpper= FALSE}', 'deprecated'); +Expect(0, 8543, '\p{^Is_OUpper= FALSE}', 'deprecated'); +Expect(0, 8543, '\P{Is_OUpper= FALSE}', 'deprecated'); +Expect(1, 8543, '\P{^Is_OUpper= FALSE}', 'deprecated'); +Expect(0, 8559, '\p{Is_OUpper= FALSE}', 'deprecated'); +Expect(1, 8559, '\p{^Is_OUpper= FALSE}', 'deprecated'); +Expect(1, 8559, '\P{Is_OUpper= FALSE}', 'deprecated'); +Expect(0, 8559, '\P{^Is_OUpper= FALSE}', 'deprecated'); +Error('\p{Deprecated= yes/a/}'); +Error('\P{Deprecated= yes/a/}'); +Expect(1, 833, '\p{Deprecated=yes}', ""); +Expect(0, 833, '\p{^Deprecated=yes}', ""); +Expect(0, 833, '\P{Deprecated=yes}', ""); +Expect(1, 833, '\P{^Deprecated=yes}', ""); +Expect(0, 831, '\p{Deprecated=yes}', ""); +Expect(1, 831, '\p{^Deprecated=yes}', ""); +Expect(1, 831, '\P{Deprecated=yes}', ""); +Expect(0, 831, '\P{^Deprecated=yes}', ""); +Expect(1, 833, '\p{Deprecated= Yes}', ""); +Expect(0, 833, '\p{^Deprecated= Yes}', ""); +Expect(0, 833, '\P{Deprecated= Yes}', ""); +Expect(1, 833, '\P{^Deprecated= Yes}', ""); +Expect(0, 831, '\p{Deprecated= Yes}', ""); +Expect(1, 831, '\p{^Deprecated= Yes}', ""); +Expect(1, 831, '\P{Deprecated= Yes}', ""); +Expect(0, 831, '\P{^Deprecated= Yes}', ""); +Error('\p{Dep=/a/_y}'); +Error('\P{Dep=/a/_y}'); +Expect(1, 833, '\p{Dep: y}', ""); +Expect(0, 833, '\p{^Dep: y}', ""); +Expect(0, 833, '\P{Dep: y}', ""); +Expect(1, 833, '\P{^Dep: y}', ""); +Expect(0, 831, '\p{Dep: y}', ""); +Expect(1, 831, '\p{^Dep: y}', ""); +Expect(1, 831, '\P{Dep: y}', ""); +Expect(0, 831, '\P{^Dep: y}', ""); +Expect(1, 833, '\p{Dep=-_Y}', ""); +Expect(0, 833, '\p{^Dep=-_Y}', ""); +Expect(0, 833, '\P{Dep=-_Y}', ""); +Expect(1, 833, '\P{^Dep=-_Y}', ""); +Expect(0, 831, '\p{Dep=-_Y}', ""); +Expect(1, 831, '\p{^Dep=-_Y}', ""); +Expect(1, 831, '\P{Dep=-_Y}', ""); +Expect(0, 831, '\P{^Dep=-_Y}', ""); +Error('\p{Is_Deprecated= T:=}'); +Error('\P{Is_Deprecated= T:=}'); +Expect(1, 833, '\p{Is_Deprecated=t}', ""); +Expect(0, 833, '\p{^Is_Deprecated=t}', ""); +Expect(0, 833, '\P{Is_Deprecated=t}', ""); +Expect(1, 833, '\P{^Is_Deprecated=t}', ""); +Expect(0, 831, '\p{Is_Deprecated=t}', ""); +Expect(1, 831, '\p{^Is_Deprecated=t}', ""); +Expect(1, 831, '\P{Is_Deprecated=t}', ""); +Expect(0, 831, '\P{^Is_Deprecated=t}', ""); +Expect(1, 833, '\p{Is_Deprecated=_ T}', ""); +Expect(0, 833, '\p{^Is_Deprecated=_ T}', ""); +Expect(0, 833, '\P{Is_Deprecated=_ T}', ""); +Expect(1, 833, '\P{^Is_Deprecated=_ T}', ""); +Expect(0, 831, '\p{Is_Deprecated=_ T}', ""); +Expect(1, 831, '\p{^Is_Deprecated=_ T}', ""); +Expect(1, 831, '\P{Is_Deprecated=_ T}', ""); +Expect(0, 831, '\P{^Is_Deprecated=_ T}', ""); +Error('\p{Is_Dep=/a/-True}'); +Error('\P{Is_Dep=/a/-True}'); +Expect(1, 833, '\p{Is_Dep=true}', ""); +Expect(0, 833, '\p{^Is_Dep=true}', ""); +Expect(0, 833, '\P{Is_Dep=true}', ""); +Expect(1, 833, '\P{^Is_Dep=true}', ""); +Expect(0, 831, '\p{Is_Dep=true}', ""); +Expect(1, 831, '\p{^Is_Dep=true}', ""); +Expect(1, 831, '\P{Is_Dep=true}', ""); +Expect(0, 831, '\P{^Is_Dep=true}', ""); +Expect(1, 833, '\p{Is_Dep=_-true}', ""); +Expect(0, 833, '\p{^Is_Dep=_-true}', ""); +Expect(0, 833, '\P{Is_Dep=_-true}', ""); +Expect(1, 833, '\P{^Is_Dep=_-true}', ""); +Expect(0, 831, '\p{Is_Dep=_-true}', ""); +Expect(1, 831, '\p{^Is_Dep=_-true}', ""); +Expect(1, 831, '\P{Is_Dep=_-true}', ""); +Expect(0, 831, '\P{^Is_Dep=_-true}', ""); +Error('\p{Deprecated= -no/a/}'); +Error('\P{Deprecated= -no/a/}'); +Expect(1, 831, '\p{Deprecated=no}', ""); +Expect(0, 831, '\p{^Deprecated=no}', ""); +Expect(0, 831, '\P{Deprecated=no}', ""); +Expect(1, 831, '\P{^Deprecated=no}', ""); +Expect(0, 833, '\p{Deprecated=no}', ""); +Expect(1, 833, '\p{^Deprecated=no}', ""); +Expect(1, 833, '\P{Deprecated=no}', ""); +Expect(0, 833, '\P{^Deprecated=no}', ""); +Expect(1, 831, '\p{Deprecated=_No}', ""); +Expect(0, 831, '\p{^Deprecated=_No}', ""); +Expect(0, 831, '\P{Deprecated=_No}', ""); +Expect(1, 831, '\P{^Deprecated=_No}', ""); +Expect(0, 833, '\p{Deprecated=_No}', ""); +Expect(1, 833, '\p{^Deprecated=_No}', ""); +Expect(1, 833, '\P{Deprecated=_No}', ""); +Expect(0, 833, '\P{^Deprecated=_No}', ""); +Error('\p{Dep= :=n}'); +Error('\P{Dep= :=n}'); +Expect(1, 831, '\p{Dep=n}', ""); +Expect(0, 831, '\p{^Dep=n}', ""); +Expect(0, 831, '\P{Dep=n}', ""); +Expect(1, 831, '\P{^Dep=n}', ""); +Expect(0, 833, '\p{Dep=n}', ""); +Expect(1, 833, '\p{^Dep=n}', ""); +Expect(1, 833, '\P{Dep=n}', ""); +Expect(0, 833, '\P{^Dep=n}', ""); +Expect(1, 831, '\p{Dep= _N}', ""); +Expect(0, 831, '\p{^Dep= _N}', ""); +Expect(0, 831, '\P{Dep= _N}', ""); +Expect(1, 831, '\P{^Dep= _N}', ""); +Expect(0, 833, '\p{Dep= _N}', ""); +Expect(1, 833, '\p{^Dep= _N}', ""); +Expect(1, 833, '\P{Dep= _N}', ""); +Expect(0, 833, '\P{^Dep= _N}', ""); +Error('\p{Is_Deprecated=:= _F}'); +Error('\P{Is_Deprecated=:= _F}'); +Expect(1, 831, '\p{Is_Deprecated=f}', ""); +Expect(0, 831, '\p{^Is_Deprecated=f}', ""); +Expect(0, 831, '\P{Is_Deprecated=f}', ""); +Expect(1, 831, '\P{^Is_Deprecated=f}', ""); +Expect(0, 833, '\p{Is_Deprecated=f}', ""); +Expect(1, 833, '\p{^Is_Deprecated=f}', ""); +Expect(1, 833, '\P{Is_Deprecated=f}', ""); +Expect(0, 833, '\P{^Is_Deprecated=f}', ""); +Expect(1, 831, '\p{Is_Deprecated=_ f}', ""); +Expect(0, 831, '\p{^Is_Deprecated=_ f}', ""); +Expect(0, 831, '\P{Is_Deprecated=_ f}', ""); +Expect(1, 831, '\P{^Is_Deprecated=_ f}', ""); +Expect(0, 833, '\p{Is_Deprecated=_ f}', ""); +Expect(1, 833, '\p{^Is_Deprecated=_ f}', ""); +Expect(1, 833, '\P{Is_Deprecated=_ f}', ""); +Expect(0, 833, '\P{^Is_Deprecated=_ f}', ""); +Error('\p{Is_Dep= false:=}'); +Error('\P{Is_Dep= false:=}'); +Expect(1, 831, '\p{Is_Dep=false}', ""); +Expect(0, 831, '\p{^Is_Dep=false}', ""); +Expect(0, 831, '\P{Is_Dep=false}', ""); +Expect(1, 831, '\P{^Is_Dep=false}', ""); +Expect(0, 833, '\p{Is_Dep=false}', ""); +Expect(1, 833, '\p{^Is_Dep=false}', ""); +Expect(1, 833, '\P{Is_Dep=false}', ""); +Expect(0, 833, '\P{^Is_Dep=false}', ""); +Expect(1, 831, '\p{Is_Dep: False}', ""); +Expect(0, 831, '\p{^Is_Dep: False}', ""); +Expect(0, 831, '\P{Is_Dep: False}', ""); +Expect(1, 831, '\P{^Is_Dep: False}', ""); +Expect(0, 833, '\p{Is_Dep: False}', ""); +Expect(1, 833, '\p{^Is_Dep: False}', ""); +Expect(1, 833, '\P{Is_Dep: False}', ""); +Expect(0, 833, '\P{^Is_Dep: False}', ""); +Error('\p{Sentence_Break=-_Sp/a/}'); +Error('\P{Sentence_Break=-_Sp/a/}'); +Expect(1, 9, '\p{Sentence_Break=sp}', ""); +Expect(0, 9, '\p{^Sentence_Break=sp}', ""); +Expect(0, 9, '\P{Sentence_Break=sp}', ""); +Expect(1, 9, '\P{^Sentence_Break=sp}', ""); +Expect(0, 8, '\p{Sentence_Break=sp}', ""); +Expect(1, 8, '\p{^Sentence_Break=sp}', ""); +Expect(1, 8, '\P{Sentence_Break=sp}', ""); +Expect(0, 8, '\P{^Sentence_Break=sp}', ""); +Expect(1, 9, '\p{Sentence_Break= sp}', ""); +Expect(0, 9, '\p{^Sentence_Break= sp}', ""); +Expect(0, 9, '\P{Sentence_Break= sp}', ""); +Expect(1, 9, '\P{^Sentence_Break= sp}', ""); +Expect(0, 8, '\p{Sentence_Break= sp}', ""); +Expect(1, 8, '\p{^Sentence_Break= sp}', ""); +Expect(1, 8, '\P{Sentence_Break= sp}', ""); +Expect(0, 8, '\P{^Sentence_Break= sp}', ""); +Error('\p{SB=_:=Sp}'); +Error('\P{SB=_:=Sp}'); +Expect(1, 9, '\p{SB=sp}', ""); +Expect(0, 9, '\p{^SB=sp}', ""); +Expect(0, 9, '\P{SB=sp}', ""); +Expect(1, 9, '\P{^SB=sp}', ""); +Expect(0, 8, '\p{SB=sp}', ""); +Expect(1, 8, '\p{^SB=sp}', ""); +Expect(1, 8, '\P{SB=sp}', ""); +Expect(0, 8, '\P{^SB=sp}', ""); +Expect(1, 9, '\p{SB: sp}', ""); +Expect(0, 9, '\p{^SB: sp}', ""); +Expect(0, 9, '\P{SB: sp}', ""); +Expect(1, 9, '\P{^SB: sp}', ""); +Expect(0, 8, '\p{SB: sp}', ""); +Expect(1, 8, '\p{^SB: sp}', ""); +Expect(1, 8, '\P{SB: sp}', ""); +Expect(0, 8, '\P{^SB: sp}', ""); +Error('\p{Is_Sentence_Break=-/a/SP}'); +Error('\P{Is_Sentence_Break=-/a/SP}'); +Expect(1, 9, '\p{Is_Sentence_Break=sp}', ""); +Expect(0, 9, '\p{^Is_Sentence_Break=sp}', ""); +Expect(0, 9, '\P{Is_Sentence_Break=sp}', ""); +Expect(1, 9, '\P{^Is_Sentence_Break=sp}', ""); +Expect(0, 8, '\p{Is_Sentence_Break=sp}', ""); +Expect(1, 8, '\p{^Is_Sentence_Break=sp}', ""); +Expect(1, 8, '\P{Is_Sentence_Break=sp}', ""); +Expect(0, 8, '\P{^Is_Sentence_Break=sp}', ""); +Expect(1, 9, '\p{Is_Sentence_Break=_Sp}', ""); +Expect(0, 9, '\p{^Is_Sentence_Break=_Sp}', ""); +Expect(0, 9, '\P{Is_Sentence_Break=_Sp}', ""); +Expect(1, 9, '\P{^Is_Sentence_Break=_Sp}', ""); +Expect(0, 8, '\p{Is_Sentence_Break=_Sp}', ""); +Expect(1, 8, '\p{^Is_Sentence_Break=_Sp}', ""); +Expect(1, 8, '\P{Is_Sentence_Break=_Sp}', ""); +Expect(0, 8, '\P{^Is_Sentence_Break=_Sp}', ""); +Error('\p{Is_SB::=__SP}'); +Error('\P{Is_SB::=__SP}'); +Expect(1, 9, '\p{Is_SB=sp}', ""); +Expect(0, 9, '\p{^Is_SB=sp}', ""); +Expect(0, 9, '\P{Is_SB=sp}', ""); +Expect(1, 9, '\P{^Is_SB=sp}', ""); +Expect(0, 8, '\p{Is_SB=sp}', ""); +Expect(1, 8, '\p{^Is_SB=sp}', ""); +Expect(1, 8, '\P{Is_SB=sp}', ""); +Expect(0, 8, '\P{^Is_SB=sp}', ""); +Expect(1, 9, '\p{Is_SB: sp}', ""); +Expect(0, 9, '\p{^Is_SB: sp}', ""); +Expect(0, 9, '\P{Is_SB: sp}', ""); +Expect(1, 9, '\P{^Is_SB: sp}', ""); +Expect(0, 8, '\p{Is_SB: sp}', ""); +Expect(1, 8, '\p{^Is_SB: sp}', ""); +Expect(1, 8, '\P{Is_SB: sp}', ""); +Expect(0, 8, '\P{^Is_SB: sp}', ""); +Error('\p{Sentence_Break= SContinue:=}'); +Error('\P{Sentence_Break= SContinue:=}'); +Expect(1, 45, '\p{Sentence_Break=scontinue}', ""); +Expect(0, 45, '\p{^Sentence_Break=scontinue}', ""); +Expect(0, 45, '\P{Sentence_Break=scontinue}', ""); +Expect(1, 45, '\P{^Sentence_Break=scontinue}', ""); +Expect(0, 43, '\p{Sentence_Break=scontinue}', ""); +Expect(1, 43, '\p{^Sentence_Break=scontinue}', ""); +Expect(1, 43, '\P{Sentence_Break=scontinue}', ""); +Expect(0, 43, '\P{^Sentence_Break=scontinue}', ""); +Expect(1, 45, '\p{Sentence_Break: _SContinue}', ""); +Expect(0, 45, '\p{^Sentence_Break: _SContinue}', ""); +Expect(0, 45, '\P{Sentence_Break: _SContinue}', ""); +Expect(1, 45, '\P{^Sentence_Break: _SContinue}', ""); +Expect(0, 43, '\p{Sentence_Break: _SContinue}', ""); +Expect(1, 43, '\p{^Sentence_Break: _SContinue}', ""); +Expect(1, 43, '\P{Sentence_Break: _SContinue}', ""); +Expect(0, 43, '\P{^Sentence_Break: _SContinue}', ""); +Error('\p{SB=SC:=}'); +Error('\P{SB=SC:=}'); +Expect(1, 45, '\p{SB=sc}', ""); +Expect(0, 45, '\p{^SB=sc}', ""); +Expect(0, 45, '\P{SB=sc}', ""); +Expect(1, 45, '\P{^SB=sc}', ""); +Expect(0, 43, '\p{SB=sc}', ""); +Expect(1, 43, '\p{^SB=sc}', ""); +Expect(1, 43, '\P{SB=sc}', ""); +Expect(0, 43, '\P{^SB=sc}', ""); +Expect(1, 45, '\p{SB= SC}', ""); +Expect(0, 45, '\p{^SB= SC}', ""); +Expect(0, 45, '\P{SB= SC}', ""); +Expect(1, 45, '\P{^SB= SC}', ""); +Expect(0, 43, '\p{SB= SC}', ""); +Expect(1, 43, '\p{^SB= SC}', ""); +Expect(1, 43, '\P{SB= SC}', ""); +Expect(0, 43, '\P{^SB= SC}', ""); +Error('\p{Is_Sentence_Break= -SContinue:=}'); +Error('\P{Is_Sentence_Break= -SContinue:=}'); +Expect(1, 45, '\p{Is_Sentence_Break=scontinue}', ""); +Expect(0, 45, '\p{^Is_Sentence_Break=scontinue}', ""); +Expect(0, 45, '\P{Is_Sentence_Break=scontinue}', ""); +Expect(1, 45, '\P{^Is_Sentence_Break=scontinue}', ""); +Expect(0, 43, '\p{Is_Sentence_Break=scontinue}', ""); +Expect(1, 43, '\p{^Is_Sentence_Break=scontinue}', ""); +Expect(1, 43, '\P{Is_Sentence_Break=scontinue}', ""); +Expect(0, 43, '\P{^Is_Sentence_Break=scontinue}', ""); +Expect(1, 45, '\p{Is_Sentence_Break=-SCONTINUE}', ""); +Expect(0, 45, '\p{^Is_Sentence_Break=-SCONTINUE}', ""); +Expect(0, 45, '\P{Is_Sentence_Break=-SCONTINUE}', ""); +Expect(1, 45, '\P{^Is_Sentence_Break=-SCONTINUE}', ""); +Expect(0, 43, '\p{Is_Sentence_Break=-SCONTINUE}', ""); +Expect(1, 43, '\p{^Is_Sentence_Break=-SCONTINUE}', ""); +Expect(1, 43, '\P{Is_Sentence_Break=-SCONTINUE}', ""); +Expect(0, 43, '\P{^Is_Sentence_Break=-SCONTINUE}', ""); +Error('\p{Is_SB=_ SC/a/}'); +Error('\P{Is_SB=_ SC/a/}'); +Expect(1, 45, '\p{Is_SB=sc}', ""); +Expect(0, 45, '\p{^Is_SB=sc}', ""); +Expect(0, 45, '\P{Is_SB=sc}', ""); +Expect(1, 45, '\P{^Is_SB=sc}', ""); +Expect(0, 43, '\p{Is_SB=sc}', ""); +Expect(1, 43, '\p{^Is_SB=sc}', ""); +Expect(1, 43, '\P{Is_SB=sc}', ""); +Expect(0, 43, '\P{^Is_SB=sc}', ""); +Expect(1, 45, '\p{Is_SB=-SC}', ""); +Expect(0, 45, '\p{^Is_SB=-SC}', ""); +Expect(0, 45, '\P{Is_SB=-SC}', ""); +Expect(1, 45, '\P{^Is_SB=-SC}', ""); +Expect(0, 43, '\p{Is_SB=-SC}', ""); +Expect(1, 43, '\p{^Is_SB=-SC}', ""); +Expect(1, 43, '\P{Is_SB=-SC}', ""); +Expect(0, 43, '\P{^Is_SB=-SC}', ""); +Error('\p{Sentence_Break=/a/- aterm}'); +Error('\P{Sentence_Break=/a/- aterm}'); +Expect(1, 46, '\p{Sentence_Break=aterm}', ""); +Expect(0, 46, '\p{^Sentence_Break=aterm}', ""); +Expect(0, 46, '\P{Sentence_Break=aterm}', ""); +Expect(1, 46, '\P{^Sentence_Break=aterm}', ""); +Expect(0, 45, '\p{Sentence_Break=aterm}', ""); +Expect(1, 45, '\p{^Sentence_Break=aterm}', ""); +Expect(1, 45, '\P{Sentence_Break=aterm}', ""); +Expect(0, 45, '\P{^Sentence_Break=aterm}', ""); +Expect(1, 46, '\p{Sentence_Break= ATerm}', ""); +Expect(0, 46, '\p{^Sentence_Break= ATerm}', ""); +Expect(0, 46, '\P{Sentence_Break= ATerm}', ""); +Expect(1, 46, '\P{^Sentence_Break= ATerm}', ""); +Expect(0, 45, '\p{Sentence_Break= ATerm}', ""); +Expect(1, 45, '\p{^Sentence_Break= ATerm}', ""); +Expect(1, 45, '\P{Sentence_Break= ATerm}', ""); +Expect(0, 45, '\P{^Sentence_Break= ATerm}', ""); +Error('\p{SB=/a/ AT}'); +Error('\P{SB=/a/ AT}'); +Expect(1, 46, '\p{SB=at}', ""); +Expect(0, 46, '\p{^SB=at}', ""); +Expect(0, 46, '\P{SB=at}', ""); +Expect(1, 46, '\P{^SB=at}', ""); +Expect(0, 45, '\p{SB=at}', ""); +Expect(1, 45, '\p{^SB=at}', ""); +Expect(1, 45, '\P{SB=at}', ""); +Expect(0, 45, '\P{^SB=at}', ""); +Expect(1, 46, '\p{SB: _ AT}', ""); +Expect(0, 46, '\p{^SB: _ AT}', ""); +Expect(0, 46, '\P{SB: _ AT}', ""); +Expect(1, 46, '\P{^SB: _ AT}', ""); +Expect(0, 45, '\p{SB: _ AT}', ""); +Expect(1, 45, '\p{^SB: _ AT}', ""); +Expect(1, 45, '\P{SB: _ AT}', ""); +Expect(0, 45, '\P{^SB: _ AT}', ""); +Error('\p{Is_Sentence_Break:- ATERM:=}'); +Error('\P{Is_Sentence_Break:- ATERM:=}'); +Expect(1, 46, '\p{Is_Sentence_Break=aterm}', ""); +Expect(0, 46, '\p{^Is_Sentence_Break=aterm}', ""); +Expect(0, 46, '\P{Is_Sentence_Break=aterm}', ""); +Expect(1, 46, '\P{^Is_Sentence_Break=aterm}', ""); +Expect(0, 45, '\p{Is_Sentence_Break=aterm}', ""); +Expect(1, 45, '\p{^Is_Sentence_Break=aterm}', ""); +Expect(1, 45, '\P{Is_Sentence_Break=aterm}', ""); +Expect(0, 45, '\P{^Is_Sentence_Break=aterm}', ""); +Expect(1, 46, '\p{Is_Sentence_Break=_ATerm}', ""); +Expect(0, 46, '\p{^Is_Sentence_Break=_ATerm}', ""); +Expect(0, 46, '\P{Is_Sentence_Break=_ATerm}', ""); +Expect(1, 46, '\P{^Is_Sentence_Break=_ATerm}', ""); +Expect(0, 45, '\p{Is_Sentence_Break=_ATerm}', ""); +Expect(1, 45, '\p{^Is_Sentence_Break=_ATerm}', ""); +Expect(1, 45, '\P{Is_Sentence_Break=_ATerm}', ""); +Expect(0, 45, '\P{^Is_Sentence_Break=_ATerm}', ""); +Error('\p{Is_SB=:= at}'); +Error('\P{Is_SB=:= at}'); +Expect(1, 46, '\p{Is_SB:at}', ""); +Expect(0, 46, '\p{^Is_SB:at}', ""); +Expect(0, 46, '\P{Is_SB:at}', ""); +Expect(1, 46, '\P{^Is_SB:at}', ""); +Expect(0, 45, '\p{Is_SB:at}', ""); +Expect(1, 45, '\p{^Is_SB:at}', ""); +Expect(1, 45, '\P{Is_SB:at}', ""); +Expect(0, 45, '\P{^Is_SB:at}', ""); +Expect(1, 46, '\p{Is_SB= AT}', ""); +Expect(0, 46, '\p{^Is_SB= AT}', ""); +Expect(0, 46, '\P{Is_SB= AT}', ""); +Expect(1, 46, '\P{^Is_SB= AT}', ""); +Expect(0, 45, '\p{Is_SB= AT}', ""); +Expect(1, 45, '\p{^Is_SB= AT}', ""); +Expect(1, 45, '\P{Is_SB= AT}', ""); +Expect(0, 45, '\P{^Is_SB= AT}', ""); +Error('\p{Sentence_Break=_ OLETTER/a/}'); +Error('\P{Sentence_Break=_ OLETTER/a/}'); +Expect(1, 443, '\p{Sentence_Break: oletter}', ""); +Expect(0, 443, '\p{^Sentence_Break: oletter}', ""); +Expect(0, 443, '\P{Sentence_Break: oletter}', ""); +Expect(1, 443, '\P{^Sentence_Break: oletter}', ""); +Expect(0, 442, '\p{Sentence_Break: oletter}', ""); +Expect(1, 442, '\p{^Sentence_Break: oletter}', ""); +Expect(1, 442, '\P{Sentence_Break: oletter}', ""); +Expect(0, 442, '\P{^Sentence_Break: oletter}', ""); +Expect(1, 443, '\p{Sentence_Break=_ OLetter}', ""); +Expect(0, 443, '\p{^Sentence_Break=_ OLetter}', ""); +Expect(0, 443, '\P{Sentence_Break=_ OLetter}', ""); +Expect(1, 443, '\P{^Sentence_Break=_ OLetter}', ""); +Expect(0, 442, '\p{Sentence_Break=_ OLetter}', ""); +Expect(1, 442, '\p{^Sentence_Break=_ OLetter}', ""); +Expect(1, 442, '\P{Sentence_Break=_ OLetter}', ""); +Expect(0, 442, '\P{^Sentence_Break=_ OLetter}', ""); +Error('\p{SB: /a/ -LE}'); +Error('\P{SB: /a/ -LE}'); +Expect(1, 443, '\p{SB=le}', ""); +Expect(0, 443, '\p{^SB=le}', ""); +Expect(0, 443, '\P{SB=le}', ""); +Expect(1, 443, '\P{^SB=le}', ""); +Expect(0, 442, '\p{SB=le}', ""); +Expect(1, 442, '\p{^SB=le}', ""); +Expect(1, 442, '\P{SB=le}', ""); +Expect(0, 442, '\P{^SB=le}', ""); +Expect(1, 443, '\p{SB=-_LE}', ""); +Expect(0, 443, '\p{^SB=-_LE}', ""); +Expect(0, 443, '\P{SB=-_LE}', ""); +Expect(1, 443, '\P{^SB=-_LE}', ""); +Expect(0, 442, '\p{SB=-_LE}', ""); +Expect(1, 442, '\p{^SB=-_LE}', ""); +Expect(1, 442, '\P{SB=-_LE}', ""); +Expect(0, 442, '\P{^SB=-_LE}', ""); +Error('\p{Is_Sentence_Break=/a/ -oletter}'); +Error('\P{Is_Sentence_Break=/a/ -oletter}'); +Expect(1, 443, '\p{Is_Sentence_Break=oletter}', ""); +Expect(0, 443, '\p{^Is_Sentence_Break=oletter}', ""); +Expect(0, 443, '\P{Is_Sentence_Break=oletter}', ""); +Expect(1, 443, '\P{^Is_Sentence_Break=oletter}', ""); +Expect(0, 442, '\p{Is_Sentence_Break=oletter}', ""); +Expect(1, 442, '\p{^Is_Sentence_Break=oletter}', ""); +Expect(1, 442, '\P{Is_Sentence_Break=oletter}', ""); +Expect(0, 442, '\P{^Is_Sentence_Break=oletter}', ""); +Expect(1, 443, '\p{Is_Sentence_Break= OLetter}', ""); +Expect(0, 443, '\p{^Is_Sentence_Break= OLetter}', ""); +Expect(0, 443, '\P{Is_Sentence_Break= OLetter}', ""); +Expect(1, 443, '\P{^Is_Sentence_Break= OLetter}', ""); +Expect(0, 442, '\p{Is_Sentence_Break= OLetter}', ""); +Expect(1, 442, '\p{^Is_Sentence_Break= OLetter}', ""); +Expect(1, 442, '\P{Is_Sentence_Break= OLetter}', ""); +Expect(0, 442, '\P{^Is_Sentence_Break= OLetter}', ""); +Error('\p{Is_SB=-:=LE}'); +Error('\P{Is_SB=-:=LE}'); +Expect(1, 443, '\p{Is_SB=le}', ""); +Expect(0, 443, '\p{^Is_SB=le}', ""); +Expect(0, 443, '\P{Is_SB=le}', ""); +Expect(1, 443, '\P{^Is_SB=le}', ""); +Expect(0, 442, '\p{Is_SB=le}', ""); +Expect(1, 442, '\p{^Is_SB=le}', ""); +Expect(1, 442, '\P{Is_SB=le}', ""); +Expect(0, 442, '\P{^Is_SB=le}', ""); +Expect(1, 443, '\p{Is_SB=_ LE}', ""); +Expect(0, 443, '\p{^Is_SB=_ LE}', ""); +Expect(0, 443, '\P{Is_SB=_ LE}', ""); +Expect(1, 443, '\P{^Is_SB=_ LE}', ""); +Expect(0, 442, '\p{Is_SB=_ LE}', ""); +Expect(1, 442, '\p{^Is_SB=_ LE}', ""); +Expect(1, 442, '\P{Is_SB=_ LE}', ""); +Expect(0, 442, '\P{^Is_SB=_ LE}', ""); +Error('\p{Sentence_Break=-/a/CR}'); +Error('\P{Sentence_Break=-/a/CR}'); +Expect(1, 13, '\p{Sentence_Break=cr}', ""); +Expect(0, 13, '\p{^Sentence_Break=cr}', ""); +Expect(0, 13, '\P{Sentence_Break=cr}', ""); +Expect(1, 13, '\P{^Sentence_Break=cr}', ""); +Expect(0, 12, '\p{Sentence_Break=cr}', ""); +Expect(1, 12, '\p{^Sentence_Break=cr}', ""); +Expect(1, 12, '\P{Sentence_Break=cr}', ""); +Expect(0, 12, '\P{^Sentence_Break=cr}', ""); +Expect(1, 13, '\p{Sentence_Break= CR}', ""); +Expect(0, 13, '\p{^Sentence_Break= CR}', ""); +Expect(0, 13, '\P{Sentence_Break= CR}', ""); +Expect(1, 13, '\P{^Sentence_Break= CR}', ""); +Expect(0, 12, '\p{Sentence_Break= CR}', ""); +Expect(1, 12, '\p{^Sentence_Break= CR}', ""); +Expect(1, 12, '\P{Sentence_Break= CR}', ""); +Expect(0, 12, '\P{^Sentence_Break= CR}', ""); +Error('\p{SB=:=-CR}'); +Error('\P{SB=:=-CR}'); +Expect(1, 13, '\p{SB: cr}', ""); +Expect(0, 13, '\p{^SB: cr}', ""); +Expect(0, 13, '\P{SB: cr}', ""); +Expect(1, 13, '\P{^SB: cr}', ""); +Expect(0, 12, '\p{SB: cr}', ""); +Expect(1, 12, '\p{^SB: cr}', ""); +Expect(1, 12, '\P{SB: cr}', ""); +Expect(0, 12, '\P{^SB: cr}', ""); +Expect(1, 13, '\p{SB= _CR}', ""); +Expect(0, 13, '\p{^SB= _CR}', ""); +Expect(0, 13, '\P{SB= _CR}', ""); +Expect(1, 13, '\P{^SB= _CR}', ""); +Expect(0, 12, '\p{SB= _CR}', ""); +Expect(1, 12, '\p{^SB= _CR}', ""); +Expect(1, 12, '\P{SB= _CR}', ""); +Expect(0, 12, '\P{^SB= _CR}', ""); +Error('\p{Is_Sentence_Break=-_CR:=}'); +Error('\P{Is_Sentence_Break=-_CR:=}'); +Expect(1, 13, '\p{Is_Sentence_Break: cr}', ""); +Expect(0, 13, '\p{^Is_Sentence_Break: cr}', ""); +Expect(0, 13, '\P{Is_Sentence_Break: cr}', ""); +Expect(1, 13, '\P{^Is_Sentence_Break: cr}', ""); +Expect(0, 12, '\p{Is_Sentence_Break: cr}', ""); +Expect(1, 12, '\p{^Is_Sentence_Break: cr}', ""); +Expect(1, 12, '\P{Is_Sentence_Break: cr}', ""); +Expect(0, 12, '\P{^Is_Sentence_Break: cr}', ""); +Expect(1, 13, '\p{Is_Sentence_Break=_ cr}', ""); +Expect(0, 13, '\p{^Is_Sentence_Break=_ cr}', ""); +Expect(0, 13, '\P{Is_Sentence_Break=_ cr}', ""); +Expect(1, 13, '\P{^Is_Sentence_Break=_ cr}', ""); +Expect(0, 12, '\p{Is_Sentence_Break=_ cr}', ""); +Expect(1, 12, '\p{^Is_Sentence_Break=_ cr}', ""); +Expect(1, 12, '\P{Is_Sentence_Break=_ cr}', ""); +Expect(0, 12, '\P{^Is_Sentence_Break=_ cr}', ""); +Error('\p{Is_SB=/a/CR}'); +Error('\P{Is_SB=/a/CR}'); +Expect(1, 13, '\p{Is_SB=cr}', ""); +Expect(0, 13, '\p{^Is_SB=cr}', ""); +Expect(0, 13, '\P{Is_SB=cr}', ""); +Expect(1, 13, '\P{^Is_SB=cr}', ""); +Expect(0, 12, '\p{Is_SB=cr}', ""); +Expect(1, 12, '\p{^Is_SB=cr}', ""); +Expect(1, 12, '\P{Is_SB=cr}', ""); +Expect(0, 12, '\P{^Is_SB=cr}', ""); +Expect(1, 13, '\p{Is_SB= CR}', ""); +Expect(0, 13, '\p{^Is_SB= CR}', ""); +Expect(0, 13, '\P{Is_SB= CR}', ""); +Expect(1, 13, '\P{^Is_SB= CR}', ""); +Expect(0, 12, '\p{Is_SB= CR}', ""); +Expect(1, 12, '\p{^Is_SB= CR}', ""); +Expect(1, 12, '\P{Is_SB= CR}', ""); +Expect(0, 12, '\P{^Is_SB= CR}', ""); +Error('\p{Sentence_Break= _OTHER:=}'); +Error('\P{Sentence_Break= _OTHER:=}'); +Expect(1, 8, '\p{Sentence_Break=other}', ""); +Expect(0, 8, '\p{^Sentence_Break=other}', ""); +Expect(0, 8, '\P{Sentence_Break=other}', ""); +Expect(1, 8, '\P{^Sentence_Break=other}', ""); +Expect(0, 13, '\p{Sentence_Break=other}', ""); +Expect(1, 13, '\p{^Sentence_Break=other}', ""); +Expect(1, 13, '\P{Sentence_Break=other}', ""); +Expect(0, 13, '\P{^Sentence_Break=other}', ""); +Expect(1, 8, '\p{Sentence_Break= -Other}', ""); +Expect(0, 8, '\p{^Sentence_Break= -Other}', ""); +Expect(0, 8, '\P{Sentence_Break= -Other}', ""); +Expect(1, 8, '\P{^Sentence_Break= -Other}', ""); +Expect(0, 13, '\p{Sentence_Break= -Other}', ""); +Expect(1, 13, '\p{^Sentence_Break= -Other}', ""); +Expect(1, 13, '\P{Sentence_Break= -Other}', ""); +Expect(0, 13, '\P{^Sentence_Break= -Other}', ""); +Error('\p{SB=:= XX}'); +Error('\P{SB=:= XX}'); +Expect(1, 8, '\p{SB=xx}', ""); +Expect(0, 8, '\p{^SB=xx}', ""); +Expect(0, 8, '\P{SB=xx}', ""); +Expect(1, 8, '\P{^SB=xx}', ""); +Expect(0, 13, '\p{SB=xx}', ""); +Expect(1, 13, '\p{^SB=xx}', ""); +Expect(1, 13, '\P{SB=xx}', ""); +Expect(0, 13, '\P{^SB=xx}', ""); +Expect(1, 8, '\p{SB=-_XX}', ""); +Expect(0, 8, '\p{^SB=-_XX}', ""); +Expect(0, 8, '\P{SB=-_XX}', ""); +Expect(1, 8, '\P{^SB=-_XX}', ""); +Expect(0, 13, '\p{SB=-_XX}', ""); +Expect(1, 13, '\p{^SB=-_XX}', ""); +Expect(1, 13, '\P{SB=-_XX}', ""); +Expect(0, 13, '\P{^SB=-_XX}', ""); +Error('\p{Is_Sentence_Break= -other/a/}'); +Error('\P{Is_Sentence_Break= -other/a/}'); +Expect(1, 8, '\p{Is_Sentence_Break=other}', ""); +Expect(0, 8, '\p{^Is_Sentence_Break=other}', ""); +Expect(0, 8, '\P{Is_Sentence_Break=other}', ""); +Expect(1, 8, '\P{^Is_Sentence_Break=other}', ""); +Expect(0, 13, '\p{Is_Sentence_Break=other}', ""); +Expect(1, 13, '\p{^Is_Sentence_Break=other}', ""); +Expect(1, 13, '\P{Is_Sentence_Break=other}', ""); +Expect(0, 13, '\P{^Is_Sentence_Break=other}', ""); +Expect(1, 8, '\p{Is_Sentence_Break= Other}', ""); +Expect(0, 8, '\p{^Is_Sentence_Break= Other}', ""); +Expect(0, 8, '\P{Is_Sentence_Break= Other}', ""); +Expect(1, 8, '\P{^Is_Sentence_Break= Other}', ""); +Expect(0, 13, '\p{Is_Sentence_Break= Other}', ""); +Expect(1, 13, '\p{^Is_Sentence_Break= Other}', ""); +Expect(1, 13, '\P{Is_Sentence_Break= Other}', ""); +Expect(0, 13, '\P{^Is_Sentence_Break= Other}', ""); +Error('\p{Is_SB=_:=xx}'); +Error('\P{Is_SB=_:=xx}'); +Expect(1, 8, '\p{Is_SB=xx}', ""); +Expect(0, 8, '\p{^Is_SB=xx}', ""); +Expect(0, 8, '\P{Is_SB=xx}', ""); +Expect(1, 8, '\P{^Is_SB=xx}', ""); +Expect(0, 13, '\p{Is_SB=xx}', ""); +Expect(1, 13, '\p{^Is_SB=xx}', ""); +Expect(1, 13, '\P{Is_SB=xx}', ""); +Expect(0, 13, '\P{^Is_SB=xx}', ""); +Expect(1, 8, '\p{Is_SB=- XX}', ""); +Expect(0, 8, '\p{^Is_SB=- XX}', ""); +Expect(0, 8, '\P{Is_SB=- XX}', ""); +Expect(1, 8, '\P{^Is_SB=- XX}', ""); +Expect(0, 13, '\p{Is_SB=- XX}', ""); +Expect(1, 13, '\p{^Is_SB=- XX}', ""); +Expect(1, 13, '\P{Is_SB=- XX}', ""); +Expect(0, 13, '\P{^Is_SB=- XX}', ""); +Error('\p{Sentence_Break= Numeric:=}'); +Error('\P{Sentence_Break= Numeric:=}'); +Expect(1, 57, '\p{Sentence_Break=numeric}', ""); +Expect(0, 57, '\p{^Sentence_Break=numeric}', ""); +Expect(0, 57, '\P{Sentence_Break=numeric}', ""); +Expect(1, 57, '\P{^Sentence_Break=numeric}', ""); +Expect(0, 47, '\p{Sentence_Break=numeric}', ""); +Expect(1, 47, '\p{^Sentence_Break=numeric}', ""); +Expect(1, 47, '\P{Sentence_Break=numeric}', ""); +Expect(0, 47, '\P{^Sentence_Break=numeric}', ""); +Expect(1, 57, '\p{Sentence_Break=-Numeric}', ""); +Expect(0, 57, '\p{^Sentence_Break=-Numeric}', ""); +Expect(0, 57, '\P{Sentence_Break=-Numeric}', ""); +Expect(1, 57, '\P{^Sentence_Break=-Numeric}', ""); +Expect(0, 47, '\p{Sentence_Break=-Numeric}', ""); +Expect(1, 47, '\p{^Sentence_Break=-Numeric}', ""); +Expect(1, 47, '\P{Sentence_Break=-Numeric}', ""); +Expect(0, 47, '\P{^Sentence_Break=-Numeric}', ""); +Error('\p{SB= NU:=}'); +Error('\P{SB= NU:=}'); +Expect(1, 57, '\p{SB=nu}', ""); +Expect(0, 57, '\p{^SB=nu}', ""); +Expect(0, 57, '\P{SB=nu}', ""); +Expect(1, 57, '\P{^SB=nu}', ""); +Expect(0, 47, '\p{SB=nu}', ""); +Expect(1, 47, '\p{^SB=nu}', ""); +Expect(1, 47, '\P{SB=nu}', ""); +Expect(0, 47, '\P{^SB=nu}', ""); +Error('\p{Is_Sentence_Break=__Numeric:=}'); +Error('\P{Is_Sentence_Break=__Numeric:=}'); +Expect(1, 57, '\p{Is_Sentence_Break=numeric}', ""); +Expect(0, 57, '\p{^Is_Sentence_Break=numeric}', ""); +Expect(0, 57, '\P{Is_Sentence_Break=numeric}', ""); +Expect(1, 57, '\P{^Is_Sentence_Break=numeric}', ""); +Expect(0, 47, '\p{Is_Sentence_Break=numeric}', ""); +Expect(1, 47, '\p{^Is_Sentence_Break=numeric}', ""); +Expect(1, 47, '\P{Is_Sentence_Break=numeric}', ""); +Expect(0, 47, '\P{^Is_Sentence_Break=numeric}', ""); +Expect(1, 57, '\p{Is_Sentence_Break= NUMERIC}', ""); +Expect(0, 57, '\p{^Is_Sentence_Break= NUMERIC}', ""); +Expect(0, 57, '\P{Is_Sentence_Break= NUMERIC}', ""); +Expect(1, 57, '\P{^Is_Sentence_Break= NUMERIC}', ""); +Expect(0, 47, '\p{Is_Sentence_Break= NUMERIC}', ""); +Expect(1, 47, '\p{^Is_Sentence_Break= NUMERIC}', ""); +Expect(1, 47, '\P{Is_Sentence_Break= NUMERIC}', ""); +Expect(0, 47, '\P{^Is_Sentence_Break= NUMERIC}', ""); +Error('\p{Is_SB=:=nu}'); +Error('\P{Is_SB=:=nu}'); +Expect(1, 57, '\p{Is_SB: nu}', ""); +Expect(0, 57, '\p{^Is_SB: nu}', ""); +Expect(0, 57, '\P{Is_SB: nu}', ""); +Expect(1, 57, '\P{^Is_SB: nu}', ""); +Expect(0, 47, '\p{Is_SB: nu}', ""); +Expect(1, 47, '\p{^Is_SB: nu}', ""); +Expect(1, 47, '\P{Is_SB: nu}', ""); +Expect(0, 47, '\P{^Is_SB: nu}', ""); +Expect(1, 57, '\p{Is_SB= NU}', ""); +Expect(0, 57, '\p{^Is_SB= NU}', ""); +Expect(0, 57, '\P{Is_SB= NU}', ""); +Expect(1, 57, '\P{^Is_SB= NU}', ""); +Expect(0, 47, '\p{Is_SB= NU}', ""); +Expect(1, 47, '\p{^Is_SB= NU}', ""); +Expect(1, 47, '\P{Is_SB= NU}', ""); +Expect(0, 47, '\P{^Is_SB= NU}', ""); +Error('\p{Sentence_Break=_ Format/a/}'); +Error('\P{Sentence_Break=_ Format/a/}'); +Expect(1, 1539, '\p{Sentence_Break=format}', ""); +Expect(0, 1539, '\p{^Sentence_Break=format}', ""); +Expect(0, 1539, '\P{Sentence_Break=format}', ""); +Expect(1, 1539, '\P{^Sentence_Break=format}', ""); +Expect(0, 7, '\p{Sentence_Break=format}', ""); +Expect(1, 7, '\p{^Sentence_Break=format}', ""); +Expect(1, 7, '\P{Sentence_Break=format}', ""); +Expect(0, 7, '\P{^Sentence_Break=format}', ""); +Expect(1, 1539, '\p{Sentence_Break= Format}', ""); +Expect(0, 1539, '\p{^Sentence_Break= Format}', ""); +Expect(0, 1539, '\P{Sentence_Break= Format}', ""); +Expect(1, 1539, '\P{^Sentence_Break= Format}', ""); +Expect(0, 7, '\p{Sentence_Break= Format}', ""); +Expect(1, 7, '\p{^Sentence_Break= Format}', ""); +Expect(1, 7, '\P{Sentence_Break= Format}', ""); +Expect(0, 7, '\P{^Sentence_Break= Format}', ""); +Error('\p{SB=_fo:=}'); +Error('\P{SB=_fo:=}'); +Expect(1, 1539, '\p{SB=fo}', ""); +Expect(0, 1539, '\p{^SB=fo}', ""); +Expect(0, 1539, '\P{SB=fo}', ""); +Expect(1, 1539, '\P{^SB=fo}', ""); +Expect(0, 7, '\p{SB=fo}', ""); +Expect(1, 7, '\p{^SB=fo}', ""); +Expect(1, 7, '\P{SB=fo}', ""); +Expect(0, 7, '\P{^SB=fo}', ""); +Expect(1, 1539, '\p{SB=-_fo}', ""); +Expect(0, 1539, '\p{^SB=-_fo}', ""); +Expect(0, 1539, '\P{SB=-_fo}', ""); +Expect(1, 1539, '\P{^SB=-_fo}', ""); +Expect(0, 7, '\p{SB=-_fo}', ""); +Expect(1, 7, '\p{^SB=-_fo}', ""); +Expect(1, 7, '\P{SB=-_fo}', ""); +Expect(0, 7, '\P{^SB=-_fo}', ""); +Error('\p{Is_Sentence_Break= Format:=}'); +Error('\P{Is_Sentence_Break= Format:=}'); +Expect(1, 1539, '\p{Is_Sentence_Break=format}', ""); +Expect(0, 1539, '\p{^Is_Sentence_Break=format}', ""); +Expect(0, 1539, '\P{Is_Sentence_Break=format}', ""); +Expect(1, 1539, '\P{^Is_Sentence_Break=format}', ""); +Expect(0, 7, '\p{Is_Sentence_Break=format}', ""); +Expect(1, 7, '\p{^Is_Sentence_Break=format}', ""); +Expect(1, 7, '\P{Is_Sentence_Break=format}', ""); +Expect(0, 7, '\P{^Is_Sentence_Break=format}', ""); +Expect(1, 1539, '\p{Is_Sentence_Break= Format}', ""); +Expect(0, 1539, '\p{^Is_Sentence_Break= Format}', ""); +Expect(0, 1539, '\P{Is_Sentence_Break= Format}', ""); +Expect(1, 1539, '\P{^Is_Sentence_Break= Format}', ""); +Expect(0, 7, '\p{Is_Sentence_Break= Format}', ""); +Expect(1, 7, '\p{^Is_Sentence_Break= Format}', ""); +Expect(1, 7, '\P{Is_Sentence_Break= Format}', ""); +Expect(0, 7, '\P{^Is_Sentence_Break= Format}', ""); +Error('\p{Is_SB=/a/--FO}'); +Error('\P{Is_SB=/a/--FO}'); +Expect(1, 1539, '\p{Is_SB=fo}', ""); +Expect(0, 1539, '\p{^Is_SB=fo}', ""); +Expect(0, 1539, '\P{Is_SB=fo}', ""); +Expect(1, 1539, '\P{^Is_SB=fo}', ""); +Expect(0, 7, '\p{Is_SB=fo}', ""); +Expect(1, 7, '\p{^Is_SB=fo}', ""); +Expect(1, 7, '\P{Is_SB=fo}', ""); +Expect(0, 7, '\P{^Is_SB=fo}', ""); +Expect(1, 1539, '\p{Is_SB=_-FO}', ""); +Expect(0, 1539, '\p{^Is_SB=_-FO}', ""); +Expect(0, 1539, '\P{Is_SB=_-FO}', ""); +Expect(1, 1539, '\P{^Is_SB=_-FO}', ""); +Expect(0, 7, '\p{Is_SB=_-FO}', ""); +Expect(1, 7, '\p{^Is_SB=_-FO}', ""); +Expect(1, 7, '\P{Is_SB=_-FO}', ""); +Expect(0, 7, '\P{^Is_SB=_-FO}', ""); +Error('\p{Sentence_Break= _Lower/a/}'); +Error('\P{Sentence_Break= _Lower/a/}'); +Expect(1, 122, '\p{Sentence_Break=lower}', ""); +Expect(0, 122, '\p{^Sentence_Break=lower}', ""); +Expect(0, 122, '\P{Sentence_Break=lower}', ""); +Expect(1, 122, '\P{^Sentence_Break=lower}', ""); +Expect(0, 96, '\p{Sentence_Break=lower}', ""); +Expect(1, 96, '\p{^Sentence_Break=lower}', ""); +Expect(1, 96, '\P{Sentence_Break=lower}', ""); +Expect(0, 96, '\P{^Sentence_Break=lower}', ""); +Expect(1, 122, '\p{Sentence_Break= Lower}', ""); +Expect(0, 122, '\p{^Sentence_Break= Lower}', ""); +Expect(0, 122, '\P{Sentence_Break= Lower}', ""); +Expect(1, 122, '\P{^Sentence_Break= Lower}', ""); +Expect(0, 96, '\p{Sentence_Break= Lower}', ""); +Expect(1, 96, '\p{^Sentence_Break= Lower}', ""); +Expect(1, 96, '\P{Sentence_Break= Lower}', ""); +Expect(0, 96, '\P{^Sentence_Break= Lower}', ""); +Error('\p{SB= /a/LO}'); +Error('\P{SB= /a/LO}'); +Expect(1, 122, '\p{SB=lo}', ""); +Expect(0, 122, '\p{^SB=lo}', ""); +Expect(0, 122, '\P{SB=lo}', ""); +Expect(1, 122, '\P{^SB=lo}', ""); +Expect(0, 96, '\p{SB=lo}', ""); +Expect(1, 96, '\p{^SB=lo}', ""); +Expect(1, 96, '\P{SB=lo}', ""); +Expect(0, 96, '\P{^SB=lo}', ""); +Expect(1, 122, '\p{SB= lo}', ""); +Expect(0, 122, '\p{^SB= lo}', ""); +Expect(0, 122, '\P{SB= lo}', ""); +Expect(1, 122, '\P{^SB= lo}', ""); +Expect(0, 96, '\p{SB= lo}', ""); +Expect(1, 96, '\p{^SB= lo}', ""); +Expect(1, 96, '\P{SB= lo}', ""); +Expect(0, 96, '\P{^SB= lo}', ""); +Error('\p{Is_Sentence_Break=:= lower}'); +Error('\P{Is_Sentence_Break=:= lower}'); +Expect(1, 122, '\p{Is_Sentence_Break=lower}', ""); +Expect(0, 122, '\p{^Is_Sentence_Break=lower}', ""); +Expect(0, 122, '\P{Is_Sentence_Break=lower}', ""); +Expect(1, 122, '\P{^Is_Sentence_Break=lower}', ""); +Expect(0, 96, '\p{Is_Sentence_Break=lower}', ""); +Expect(1, 96, '\p{^Is_Sentence_Break=lower}', ""); +Expect(1, 96, '\P{Is_Sentence_Break=lower}', ""); +Expect(0, 96, '\P{^Is_Sentence_Break=lower}', ""); +Expect(1, 122, '\p{Is_Sentence_Break=_-LOWER}', ""); +Expect(0, 122, '\p{^Is_Sentence_Break=_-LOWER}', ""); +Expect(0, 122, '\P{Is_Sentence_Break=_-LOWER}', ""); +Expect(1, 122, '\P{^Is_Sentence_Break=_-LOWER}', ""); +Expect(0, 96, '\p{Is_Sentence_Break=_-LOWER}', ""); +Expect(1, 96, '\p{^Is_Sentence_Break=_-LOWER}', ""); +Expect(1, 96, '\P{Is_Sentence_Break=_-LOWER}', ""); +Expect(0, 96, '\P{^Is_Sentence_Break=_-LOWER}', ""); +Error('\p{Is_SB= LO/a/}'); +Error('\P{Is_SB= LO/a/}'); +Expect(1, 122, '\p{Is_SB=lo}', ""); +Expect(0, 122, '\p{^Is_SB=lo}', ""); +Expect(0, 122, '\P{Is_SB=lo}', ""); +Expect(1, 122, '\P{^Is_SB=lo}', ""); +Expect(0, 96, '\p{Is_SB=lo}', ""); +Expect(1, 96, '\p{^Is_SB=lo}', ""); +Expect(1, 96, '\P{Is_SB=lo}', ""); +Expect(0, 96, '\P{^Is_SB=lo}', ""); +Expect(1, 122, '\p{Is_SB=__lo}', ""); +Expect(0, 122, '\p{^Is_SB=__lo}', ""); +Expect(0, 122, '\P{Is_SB=__lo}', ""); +Expect(1, 122, '\P{^Is_SB=__lo}', ""); +Expect(0, 96, '\p{Is_SB=__lo}', ""); +Expect(1, 96, '\p{^Is_SB=__lo}', ""); +Expect(1, 96, '\P{Is_SB=__lo}', ""); +Expect(0, 96, '\P{^Is_SB=__lo}', ""); +Error('\p{Sentence_Break=:=_-Upper}'); +Error('\P{Sentence_Break=:=_-Upper}'); +Expect(1, 90, '\p{Sentence_Break=upper}', ""); +Expect(0, 90, '\p{^Sentence_Break=upper}', ""); +Expect(0, 90, '\P{Sentence_Break=upper}', ""); +Expect(1, 90, '\P{^Sentence_Break=upper}', ""); +Expect(0, 64, '\p{Sentence_Break=upper}', ""); +Expect(1, 64, '\p{^Sentence_Break=upper}', ""); +Expect(1, 64, '\P{Sentence_Break=upper}', ""); +Expect(0, 64, '\P{^Sentence_Break=upper}', ""); +Expect(1, 90, '\p{Sentence_Break=__Upper}', ""); +Expect(0, 90, '\p{^Sentence_Break=__Upper}', ""); +Expect(0, 90, '\P{Sentence_Break=__Upper}', ""); +Expect(1, 90, '\P{^Sentence_Break=__Upper}', ""); +Expect(0, 64, '\p{Sentence_Break=__Upper}', ""); +Expect(1, 64, '\p{^Sentence_Break=__Upper}', ""); +Expect(1, 64, '\P{Sentence_Break=__Upper}', ""); +Expect(0, 64, '\P{^Sentence_Break=__Upper}', ""); +Error('\p{SB= :=UP}'); +Error('\P{SB= :=UP}'); +Expect(1, 90, '\p{SB=up}', ""); +Expect(0, 90, '\p{^SB=up}', ""); +Expect(0, 90, '\P{SB=up}', ""); +Expect(1, 90, '\P{^SB=up}', ""); +Expect(0, 64, '\p{SB=up}', ""); +Expect(1, 64, '\p{^SB=up}', ""); +Expect(1, 64, '\P{SB=up}', ""); +Expect(0, 64, '\P{^SB=up}', ""); +Expect(1, 90, '\p{SB= UP}', ""); +Expect(0, 90, '\p{^SB= UP}', ""); +Expect(0, 90, '\P{SB= UP}', ""); +Expect(1, 90, '\P{^SB= UP}', ""); +Expect(0, 64, '\p{SB= UP}', ""); +Expect(1, 64, '\p{^SB= UP}', ""); +Expect(1, 64, '\P{SB= UP}', ""); +Expect(0, 64, '\P{^SB= UP}', ""); +Error('\p{Is_Sentence_Break=-_UPPER:=}'); +Error('\P{Is_Sentence_Break=-_UPPER:=}'); +Expect(1, 90, '\p{Is_Sentence_Break=upper}', ""); +Expect(0, 90, '\p{^Is_Sentence_Break=upper}', ""); +Expect(0, 90, '\P{Is_Sentence_Break=upper}', ""); +Expect(1, 90, '\P{^Is_Sentence_Break=upper}', ""); +Expect(0, 64, '\p{Is_Sentence_Break=upper}', ""); +Expect(1, 64, '\p{^Is_Sentence_Break=upper}', ""); +Expect(1, 64, '\P{Is_Sentence_Break=upper}', ""); +Expect(0, 64, '\P{^Is_Sentence_Break=upper}', ""); +Expect(1, 90, '\p{Is_Sentence_Break=_ Upper}', ""); +Expect(0, 90, '\p{^Is_Sentence_Break=_ Upper}', ""); +Expect(0, 90, '\P{Is_Sentence_Break=_ Upper}', ""); +Expect(1, 90, '\P{^Is_Sentence_Break=_ Upper}', ""); +Expect(0, 64, '\p{Is_Sentence_Break=_ Upper}', ""); +Expect(1, 64, '\p{^Is_Sentence_Break=_ Upper}', ""); +Expect(1, 64, '\P{Is_Sentence_Break=_ Upper}', ""); +Expect(0, 64, '\P{^Is_Sentence_Break=_ Upper}', ""); +Error('\p{Is_SB: /a/ _UP}'); +Error('\P{Is_SB: /a/ _UP}'); +Expect(1, 90, '\p{Is_SB=up}', ""); +Expect(0, 90, '\p{^Is_SB=up}', ""); +Expect(0, 90, '\P{Is_SB=up}', ""); +Expect(1, 90, '\P{^Is_SB=up}', ""); +Expect(0, 64, '\p{Is_SB=up}', ""); +Expect(1, 64, '\p{^Is_SB=up}', ""); +Expect(1, 64, '\P{Is_SB=up}', ""); +Expect(0, 64, '\P{^Is_SB=up}', ""); +Expect(1, 90, '\p{Is_SB: -UP}', ""); +Expect(0, 90, '\p{^Is_SB: -UP}', ""); +Expect(0, 90, '\P{Is_SB: -UP}', ""); +Expect(1, 90, '\P{^Is_SB: -UP}', ""); +Expect(0, 64, '\p{Is_SB: -UP}', ""); +Expect(1, 64, '\p{^Is_SB: -UP}', ""); +Expect(1, 64, '\P{Is_SB: -UP}', ""); +Expect(0, 64, '\P{^Is_SB: -UP}', ""); +Error('\p{Sentence_Break: _Sep:=}'); +Error('\P{Sentence_Break: _Sep:=}'); +Expect(1, 8233, '\p{Sentence_Break=sep}', ""); +Expect(0, 8233, '\p{^Sentence_Break=sep}', ""); +Expect(0, 8233, '\P{Sentence_Break=sep}', ""); +Expect(1, 8233, '\P{^Sentence_Break=sep}', ""); +Expect(0, 7, '\p{Sentence_Break=sep}', ""); +Expect(1, 7, '\p{^Sentence_Break=sep}', ""); +Expect(1, 7, '\P{Sentence_Break=sep}', ""); +Expect(0, 7, '\P{^Sentence_Break=sep}', ""); +Expect(1, 8233, '\p{Sentence_Break= _sep}', ""); +Expect(0, 8233, '\p{^Sentence_Break= _sep}', ""); +Expect(0, 8233, '\P{Sentence_Break= _sep}', ""); +Expect(1, 8233, '\P{^Sentence_Break= _sep}', ""); +Expect(0, 7, '\p{Sentence_Break= _sep}', ""); +Expect(1, 7, '\p{^Sentence_Break= _sep}', ""); +Expect(1, 7, '\P{Sentence_Break= _sep}', ""); +Expect(0, 7, '\P{^Sentence_Break= _sep}', ""); +Error('\p{SB= :=SE}'); +Error('\P{SB= :=SE}'); +Expect(1, 8233, '\p{SB:se}', ""); +Expect(0, 8233, '\p{^SB:se}', ""); +Expect(0, 8233, '\P{SB:se}', ""); +Expect(1, 8233, '\P{^SB:se}', ""); +Expect(0, 7, '\p{SB:se}', ""); +Expect(1, 7, '\p{^SB:se}', ""); +Expect(1, 7, '\P{SB:se}', ""); +Expect(0, 7, '\P{^SB:se}', ""); +Expect(1, 8233, '\p{SB= SE}', ""); +Expect(0, 8233, '\p{^SB= SE}', ""); +Expect(0, 8233, '\P{SB= SE}', ""); +Expect(1, 8233, '\P{^SB= SE}', ""); +Expect(0, 7, '\p{SB= SE}', ""); +Expect(1, 7, '\p{^SB= SE}', ""); +Expect(1, 7, '\P{SB= SE}', ""); +Expect(0, 7, '\P{^SB= SE}', ""); +Error('\p{Is_Sentence_Break=_ sep:=}'); +Error('\P{Is_Sentence_Break=_ sep:=}'); +Expect(1, 8233, '\p{Is_Sentence_Break=sep}', ""); +Expect(0, 8233, '\p{^Is_Sentence_Break=sep}', ""); +Expect(0, 8233, '\P{Is_Sentence_Break=sep}', ""); +Expect(1, 8233, '\P{^Is_Sentence_Break=sep}', ""); +Expect(0, 7, '\p{Is_Sentence_Break=sep}', ""); +Expect(1, 7, '\p{^Is_Sentence_Break=sep}', ""); +Expect(1, 7, '\P{Is_Sentence_Break=sep}', ""); +Expect(0, 7, '\P{^Is_Sentence_Break=sep}', ""); +Expect(1, 8233, '\p{Is_Sentence_Break:-_SEP}', ""); +Expect(0, 8233, '\p{^Is_Sentence_Break:-_SEP}', ""); +Expect(0, 8233, '\P{Is_Sentence_Break:-_SEP}', ""); +Expect(1, 8233, '\P{^Is_Sentence_Break:-_SEP}', ""); +Expect(0, 7, '\p{Is_Sentence_Break:-_SEP}', ""); +Expect(1, 7, '\p{^Is_Sentence_Break:-_SEP}', ""); +Expect(1, 7, '\P{Is_Sentence_Break:-_SEP}', ""); +Expect(0, 7, '\P{^Is_Sentence_Break:-_SEP}', ""); +Error('\p{Is_SB=:=_-SE}'); +Error('\P{Is_SB=:=_-SE}'); +Expect(1, 8233, '\p{Is_SB=se}', ""); +Expect(0, 8233, '\p{^Is_SB=se}', ""); +Expect(0, 8233, '\P{Is_SB=se}', ""); +Expect(1, 8233, '\P{^Is_SB=se}', ""); +Expect(0, 7, '\p{Is_SB=se}', ""); +Expect(1, 7, '\p{^Is_SB=se}', ""); +Expect(1, 7, '\P{Is_SB=se}', ""); +Expect(0, 7, '\P{^Is_SB=se}', ""); +Expect(1, 8233, '\p{Is_SB: _se}', ""); +Expect(0, 8233, '\p{^Is_SB: _se}', ""); +Expect(0, 8233, '\P{Is_SB: _se}', ""); +Expect(1, 8233, '\P{^Is_SB: _se}', ""); +Expect(0, 7, '\p{Is_SB: _se}', ""); +Expect(1, 7, '\p{^Is_SB: _se}', ""); +Expect(1, 7, '\P{Is_SB: _se}', ""); +Expect(0, 7, '\P{^Is_SB: _se}', ""); +Error('\p{Sentence_Break=/a/Extend}'); +Error('\P{Sentence_Break=/a/Extend}'); +Expect(1, 879, '\p{Sentence_Break=extend}', ""); +Expect(0, 879, '\p{^Sentence_Break=extend}', ""); +Expect(0, 879, '\P{Sentence_Break=extend}', ""); +Expect(1, 879, '\P{^Sentence_Break=extend}', ""); +Expect(0, 767, '\p{Sentence_Break=extend}', ""); +Expect(1, 767, '\p{^Sentence_Break=extend}', ""); +Expect(1, 767, '\P{Sentence_Break=extend}', ""); +Expect(0, 767, '\P{^Sentence_Break=extend}', ""); +Expect(1, 879, '\p{Sentence_Break=Extend}', ""); +Expect(0, 879, '\p{^Sentence_Break=Extend}', ""); +Expect(0, 879, '\P{Sentence_Break=Extend}', ""); +Expect(1, 879, '\P{^Sentence_Break=Extend}', ""); +Expect(0, 767, '\p{Sentence_Break=Extend}', ""); +Expect(1, 767, '\p{^Sentence_Break=Extend}', ""); +Expect(1, 767, '\P{Sentence_Break=Extend}', ""); +Expect(0, 767, '\P{^Sentence_Break=Extend}', ""); +Error('\p{SB= /a/EX}'); +Error('\P{SB= /a/EX}'); +Expect(1, 879, '\p{SB=ex}', ""); +Expect(0, 879, '\p{^SB=ex}', ""); +Expect(0, 879, '\P{SB=ex}', ""); +Expect(1, 879, '\P{^SB=ex}', ""); +Expect(0, 767, '\p{SB=ex}', ""); +Expect(1, 767, '\p{^SB=ex}', ""); +Expect(1, 767, '\P{SB=ex}', ""); +Expect(0, 767, '\P{^SB=ex}', ""); +Expect(1, 879, '\p{SB= EX}', ""); +Expect(0, 879, '\p{^SB= EX}', ""); +Expect(0, 879, '\P{SB= EX}', ""); +Expect(1, 879, '\P{^SB= EX}', ""); +Expect(0, 767, '\p{SB= EX}', ""); +Expect(1, 767, '\p{^SB= EX}', ""); +Expect(1, 767, '\P{SB= EX}', ""); +Expect(0, 767, '\P{^SB= EX}', ""); +Error('\p{Is_Sentence_Break=:= Extend}'); +Error('\P{Is_Sentence_Break=:= Extend}'); +Expect(1, 879, '\p{Is_Sentence_Break=extend}', ""); +Expect(0, 879, '\p{^Is_Sentence_Break=extend}', ""); +Expect(0, 879, '\P{Is_Sentence_Break=extend}', ""); +Expect(1, 879, '\P{^Is_Sentence_Break=extend}', ""); +Expect(0, 767, '\p{Is_Sentence_Break=extend}', ""); +Expect(1, 767, '\p{^Is_Sentence_Break=extend}', ""); +Expect(1, 767, '\P{Is_Sentence_Break=extend}', ""); +Expect(0, 767, '\P{^Is_Sentence_Break=extend}', ""); +Expect(1, 879, '\p{Is_Sentence_Break=-extend}', ""); +Expect(0, 879, '\p{^Is_Sentence_Break=-extend}', ""); +Expect(0, 879, '\P{Is_Sentence_Break=-extend}', ""); +Expect(1, 879, '\P{^Is_Sentence_Break=-extend}', ""); +Expect(0, 767, '\p{Is_Sentence_Break=-extend}', ""); +Expect(1, 767, '\p{^Is_Sentence_Break=-extend}', ""); +Expect(1, 767, '\P{Is_Sentence_Break=-extend}', ""); +Expect(0, 767, '\P{^Is_Sentence_Break=-extend}', ""); +Error('\p{Is_SB=:=ex}'); +Error('\P{Is_SB=:=ex}'); +Expect(1, 879, '\p{Is_SB=ex}', ""); +Expect(0, 879, '\p{^Is_SB=ex}', ""); +Expect(0, 879, '\P{Is_SB=ex}', ""); +Expect(1, 879, '\P{^Is_SB=ex}', ""); +Expect(0, 767, '\p{Is_SB=ex}', ""); +Expect(1, 767, '\p{^Is_SB=ex}', ""); +Expect(1, 767, '\P{Is_SB=ex}', ""); +Expect(0, 767, '\P{^Is_SB=ex}', ""); +Expect(1, 879, '\p{Is_SB: EX}', ""); +Expect(0, 879, '\p{^Is_SB: EX}', ""); +Expect(0, 879, '\P{Is_SB: EX}', ""); +Expect(1, 879, '\P{^Is_SB: EX}', ""); +Expect(0, 767, '\p{Is_SB: EX}', ""); +Expect(1, 767, '\p{^Is_SB: EX}', ""); +Expect(1, 767, '\P{Is_SB: EX}', ""); +Expect(0, 767, '\P{^Is_SB: EX}', ""); +Error('\p{Sentence_Break=:=_STerm}'); +Error('\P{Sentence_Break=:=_STerm}'); +Expect(1, 33, '\p{Sentence_Break=sterm}', ""); +Expect(0, 33, '\p{^Sentence_Break=sterm}', ""); +Expect(0, 33, '\P{Sentence_Break=sterm}', ""); +Expect(1, 33, '\P{^Sentence_Break=sterm}', ""); +Expect(0, 32, '\p{Sentence_Break=sterm}', ""); +Expect(1, 32, '\p{^Sentence_Break=sterm}', ""); +Expect(1, 32, '\P{Sentence_Break=sterm}', ""); +Expect(0, 32, '\P{^Sentence_Break=sterm}', ""); +Expect(1, 33, '\p{Sentence_Break:_sterm}', ""); +Expect(0, 33, '\p{^Sentence_Break:_sterm}', ""); +Expect(0, 33, '\P{Sentence_Break:_sterm}', ""); +Expect(1, 33, '\P{^Sentence_Break:_sterm}', ""); +Expect(0, 32, '\p{Sentence_Break:_sterm}', ""); +Expect(1, 32, '\p{^Sentence_Break:_sterm}', ""); +Expect(1, 32, '\P{Sentence_Break:_sterm}', ""); +Expect(0, 32, '\P{^Sentence_Break:_sterm}', ""); +Error('\p{SB= :=ST}'); +Error('\P{SB= :=ST}'); +Expect(1, 33, '\p{SB=st}', ""); +Expect(0, 33, '\p{^SB=st}', ""); +Expect(0, 33, '\P{SB=st}', ""); +Expect(1, 33, '\P{^SB=st}', ""); +Expect(0, 32, '\p{SB=st}', ""); +Expect(1, 32, '\p{^SB=st}', ""); +Expect(1, 32, '\P{SB=st}', ""); +Expect(0, 32, '\P{^SB=st}', ""); +Expect(1, 33, '\p{SB=- ST}', ""); +Expect(0, 33, '\p{^SB=- ST}', ""); +Expect(0, 33, '\P{SB=- ST}', ""); +Expect(1, 33, '\P{^SB=- ST}', ""); +Expect(0, 32, '\p{SB=- ST}', ""); +Expect(1, 32, '\p{^SB=- ST}', ""); +Expect(1, 32, '\P{SB=- ST}', ""); +Expect(0, 32, '\P{^SB=- ST}', ""); +Error('\p{Is_Sentence_Break=_:=STerm}'); +Error('\P{Is_Sentence_Break=_:=STerm}'); +Expect(1, 33, '\p{Is_Sentence_Break=sterm}', ""); +Expect(0, 33, '\p{^Is_Sentence_Break=sterm}', ""); +Expect(0, 33, '\P{Is_Sentence_Break=sterm}', ""); +Expect(1, 33, '\P{^Is_Sentence_Break=sterm}', ""); +Expect(0, 32, '\p{Is_Sentence_Break=sterm}', ""); +Expect(1, 32, '\p{^Is_Sentence_Break=sterm}', ""); +Expect(1, 32, '\P{Is_Sentence_Break=sterm}', ""); +Expect(0, 32, '\P{^Is_Sentence_Break=sterm}', ""); +Expect(1, 33, '\p{Is_Sentence_Break=- STerm}', ""); +Expect(0, 33, '\p{^Is_Sentence_Break=- STerm}', ""); +Expect(0, 33, '\P{Is_Sentence_Break=- STerm}', ""); +Expect(1, 33, '\P{^Is_Sentence_Break=- STerm}', ""); +Expect(0, 32, '\p{Is_Sentence_Break=- STerm}', ""); +Expect(1, 32, '\p{^Is_Sentence_Break=- STerm}', ""); +Expect(1, 32, '\P{Is_Sentence_Break=- STerm}', ""); +Expect(0, 32, '\P{^Is_Sentence_Break=- STerm}', ""); +Error('\p{Is_SB=_/a/ST}'); +Error('\P{Is_SB=_/a/ST}'); +Expect(1, 33, '\p{Is_SB=st}', ""); +Expect(0, 33, '\p{^Is_SB=st}', ""); +Expect(0, 33, '\P{Is_SB=st}', ""); +Expect(1, 33, '\P{^Is_SB=st}', ""); +Expect(0, 32, '\p{Is_SB=st}', ""); +Expect(1, 32, '\p{^Is_SB=st}', ""); +Expect(1, 32, '\P{Is_SB=st}', ""); +Expect(0, 32, '\P{^Is_SB=st}', ""); +Expect(1, 33, '\p{Is_SB: _ST}', ""); +Expect(0, 33, '\p{^Is_SB: _ST}', ""); +Expect(0, 33, '\P{Is_SB: _ST}', ""); +Expect(1, 33, '\P{^Is_SB: _ST}', ""); +Expect(0, 32, '\p{Is_SB: _ST}', ""); +Expect(1, 32, '\p{^Is_SB: _ST}', ""); +Expect(1, 32, '\P{Is_SB: _ST}', ""); +Expect(0, 32, '\P{^Is_SB: _ST}', ""); +Error('\p{Sentence_Break=:=_LF}'); +Error('\P{Sentence_Break=:=_LF}'); +Expect(1, 10, '\p{Sentence_Break=lf}', ""); +Expect(0, 10, '\p{^Sentence_Break=lf}', ""); +Expect(0, 10, '\P{Sentence_Break=lf}', ""); +Expect(1, 10, '\P{^Sentence_Break=lf}', ""); +Expect(0, 9, '\p{Sentence_Break=lf}', ""); +Expect(1, 9, '\p{^Sentence_Break=lf}', ""); +Expect(1, 9, '\P{Sentence_Break=lf}', ""); +Expect(0, 9, '\P{^Sentence_Break=lf}', ""); +Expect(1, 10, '\p{Sentence_Break= lf}', ""); +Expect(0, 10, '\p{^Sentence_Break= lf}', ""); +Expect(0, 10, '\P{Sentence_Break= lf}', ""); +Expect(1, 10, '\P{^Sentence_Break= lf}', ""); +Expect(0, 9, '\p{Sentence_Break= lf}', ""); +Expect(1, 9, '\p{^Sentence_Break= lf}', ""); +Expect(1, 9, '\P{Sentence_Break= lf}', ""); +Expect(0, 9, '\P{^Sentence_Break= lf}', ""); +Error('\p{SB=- LF/a/}'); +Error('\P{SB=- LF/a/}'); +Expect(1, 10, '\p{SB=lf}', ""); +Expect(0, 10, '\p{^SB=lf}', ""); +Expect(0, 10, '\P{SB=lf}', ""); +Expect(1, 10, '\P{^SB=lf}', ""); +Expect(0, 9, '\p{SB=lf}', ""); +Expect(1, 9, '\p{^SB=lf}', ""); +Expect(1, 9, '\P{SB=lf}', ""); +Expect(0, 9, '\P{^SB=lf}', ""); +Expect(1, 10, '\p{SB=_ LF}', ""); +Expect(0, 10, '\p{^SB=_ LF}', ""); +Expect(0, 10, '\P{SB=_ LF}', ""); +Expect(1, 10, '\P{^SB=_ LF}', ""); +Expect(0, 9, '\p{SB=_ LF}', ""); +Expect(1, 9, '\p{^SB=_ LF}', ""); +Expect(1, 9, '\P{SB=_ LF}', ""); +Expect(0, 9, '\P{^SB=_ LF}', ""); +Error('\p{Is_Sentence_Break=/a/LF}'); +Error('\P{Is_Sentence_Break=/a/LF}'); +Expect(1, 10, '\p{Is_Sentence_Break=lf}', ""); +Expect(0, 10, '\p{^Is_Sentence_Break=lf}', ""); +Expect(0, 10, '\P{Is_Sentence_Break=lf}', ""); +Expect(1, 10, '\P{^Is_Sentence_Break=lf}', ""); +Expect(0, 9, '\p{Is_Sentence_Break=lf}', ""); +Expect(1, 9, '\p{^Is_Sentence_Break=lf}', ""); +Expect(1, 9, '\P{Is_Sentence_Break=lf}', ""); +Expect(0, 9, '\P{^Is_Sentence_Break=lf}', ""); +Expect(1, 10, '\p{Is_Sentence_Break: -LF}', ""); +Expect(0, 10, '\p{^Is_Sentence_Break: -LF}', ""); +Expect(0, 10, '\P{Is_Sentence_Break: -LF}', ""); +Expect(1, 10, '\P{^Is_Sentence_Break: -LF}', ""); +Expect(0, 9, '\p{Is_Sentence_Break: -LF}', ""); +Expect(1, 9, '\p{^Is_Sentence_Break: -LF}', ""); +Expect(1, 9, '\P{Is_Sentence_Break: -LF}', ""); +Expect(0, 9, '\P{^Is_Sentence_Break: -LF}', ""); +Error('\p{Is_SB=-LF:=}'); +Error('\P{Is_SB=-LF:=}'); +Expect(1, 10, '\p{Is_SB=lf}', ""); +Expect(0, 10, '\p{^Is_SB=lf}', ""); +Expect(0, 10, '\P{Is_SB=lf}', ""); +Expect(1, 10, '\P{^Is_SB=lf}', ""); +Expect(0, 9, '\p{Is_SB=lf}', ""); +Expect(1, 9, '\p{^Is_SB=lf}', ""); +Expect(1, 9, '\P{Is_SB=lf}', ""); +Expect(0, 9, '\P{^Is_SB=lf}', ""); +Expect(1, 10, '\p{Is_SB= LF}', ""); +Expect(0, 10, '\p{^Is_SB= LF}', ""); +Expect(0, 10, '\P{Is_SB= LF}', ""); +Expect(1, 10, '\P{^Is_SB= LF}', ""); +Expect(0, 9, '\p{Is_SB= LF}', ""); +Expect(1, 9, '\p{^Is_SB= LF}', ""); +Expect(1, 9, '\P{Is_SB= LF}', ""); +Expect(0, 9, '\P{^Is_SB= LF}', ""); +Error('\p{Sentence_Break=_-Close:=}'); +Error('\P{Sentence_Break=_-Close:=}'); +Expect(1, 34, '\p{Sentence_Break: close}', ""); +Expect(0, 34, '\p{^Sentence_Break: close}', ""); +Expect(0, 34, '\P{Sentence_Break: close}', ""); +Expect(1, 34, '\P{^Sentence_Break: close}', ""); +Expect(0, 33, '\p{Sentence_Break: close}', ""); +Expect(1, 33, '\p{^Sentence_Break: close}', ""); +Expect(1, 33, '\P{Sentence_Break: close}', ""); +Expect(0, 33, '\P{^Sentence_Break: close}', ""); +Expect(1, 34, '\p{Sentence_Break=-CLOSE}', ""); +Expect(0, 34, '\p{^Sentence_Break=-CLOSE}', ""); +Expect(0, 34, '\P{Sentence_Break=-CLOSE}', ""); +Expect(1, 34, '\P{^Sentence_Break=-CLOSE}', ""); +Expect(0, 33, '\p{Sentence_Break=-CLOSE}', ""); +Expect(1, 33, '\p{^Sentence_Break=-CLOSE}', ""); +Expect(1, 33, '\P{Sentence_Break=-CLOSE}', ""); +Expect(0, 33, '\P{^Sentence_Break=-CLOSE}', ""); +Error('\p{SB=/a/ CL}'); +Error('\P{SB=/a/ CL}'); +Expect(1, 34, '\p{SB=cl}', ""); +Expect(0, 34, '\p{^SB=cl}', ""); +Expect(0, 34, '\P{SB=cl}', ""); +Expect(1, 34, '\P{^SB=cl}', ""); +Expect(0, 33, '\p{SB=cl}', ""); +Expect(1, 33, '\p{^SB=cl}', ""); +Expect(1, 33, '\P{SB=cl}', ""); +Expect(0, 33, '\P{^SB=cl}', ""); +Expect(1, 34, '\p{SB=CL}', ""); +Expect(0, 34, '\p{^SB=CL}', ""); +Expect(0, 34, '\P{SB=CL}', ""); +Expect(1, 34, '\P{^SB=CL}', ""); +Expect(0, 33, '\p{SB=CL}', ""); +Expect(1, 33, '\p{^SB=CL}', ""); +Expect(1, 33, '\P{SB=CL}', ""); +Expect(0, 33, '\P{^SB=CL}', ""); +Error('\p{Is_Sentence_Break: /a/- Close}'); +Error('\P{Is_Sentence_Break: /a/- Close}'); +Expect(1, 34, '\p{Is_Sentence_Break=close}', ""); +Expect(0, 34, '\p{^Is_Sentence_Break=close}', ""); +Expect(0, 34, '\P{Is_Sentence_Break=close}', ""); +Expect(1, 34, '\P{^Is_Sentence_Break=close}', ""); +Expect(0, 33, '\p{Is_Sentence_Break=close}', ""); +Expect(1, 33, '\p{^Is_Sentence_Break=close}', ""); +Expect(1, 33, '\P{Is_Sentence_Break=close}', ""); +Expect(0, 33, '\P{^Is_Sentence_Break=close}', ""); +Expect(1, 34, '\p{Is_Sentence_Break=-_CLOSE}', ""); +Expect(0, 34, '\p{^Is_Sentence_Break=-_CLOSE}', ""); +Expect(0, 34, '\P{Is_Sentence_Break=-_CLOSE}', ""); +Expect(1, 34, '\P{^Is_Sentence_Break=-_CLOSE}', ""); +Expect(0, 33, '\p{Is_Sentence_Break=-_CLOSE}', ""); +Expect(1, 33, '\p{^Is_Sentence_Break=-_CLOSE}', ""); +Expect(1, 33, '\P{Is_Sentence_Break=-_CLOSE}', ""); +Expect(0, 33, '\P{^Is_Sentence_Break=-_CLOSE}', ""); +Error('\p{Is_SB: /a/ CL}'); +Error('\P{Is_SB: /a/ CL}'); +Expect(1, 34, '\p{Is_SB=cl}', ""); +Expect(0, 34, '\p{^Is_SB=cl}', ""); +Expect(0, 34, '\P{Is_SB=cl}', ""); +Expect(1, 34, '\P{^Is_SB=cl}', ""); +Expect(0, 33, '\p{Is_SB=cl}', ""); +Expect(1, 33, '\p{^Is_SB=cl}', ""); +Expect(1, 33, '\P{Is_SB=cl}', ""); +Expect(0, 33, '\P{^Is_SB=cl}', ""); +Expect(1, 34, '\p{Is_SB=__CL}', ""); +Expect(0, 34, '\p{^Is_SB=__CL}', ""); +Expect(0, 34, '\P{Is_SB=__CL}', ""); +Expect(1, 34, '\P{^Is_SB=__CL}', ""); +Expect(0, 33, '\p{Is_SB=__CL}', ""); +Expect(1, 33, '\p{^Is_SB=__CL}', ""); +Expect(1, 33, '\P{Is_SB=__CL}', ""); +Expect(0, 33, '\P{^Is_SB=__CL}', ""); +Error('\p{Alphabetic=_:=yes}'); +Error('\P{Alphabetic=_:=yes}'); +Expect(1, 90, '\p{Alphabetic=yes}', ""); +Expect(0, 90, '\p{^Alphabetic=yes}', ""); +Expect(0, 90, '\P{Alphabetic=yes}', ""); +Expect(1, 90, '\P{^Alphabetic=yes}', ""); +Expect(0, 64, '\p{Alphabetic=yes}', ""); +Expect(1, 64, '\p{^Alphabetic=yes}', ""); +Expect(1, 64, '\P{Alphabetic=yes}', ""); +Expect(0, 64, '\P{^Alphabetic=yes}', ""); +Expect(1, 90, '\p{Alphabetic=_-yes}', ""); +Expect(0, 90, '\p{^Alphabetic=_-yes}', ""); +Expect(0, 90, '\P{Alphabetic=_-yes}', ""); +Expect(1, 90, '\P{^Alphabetic=_-yes}', ""); +Expect(0, 64, '\p{Alphabetic=_-yes}', ""); +Expect(1, 64, '\p{^Alphabetic=_-yes}', ""); +Expect(1, 64, '\P{Alphabetic=_-yes}', ""); +Expect(0, 64, '\P{^Alphabetic=_-yes}', ""); +Error('\p{Alpha= Y:=}'); +Error('\P{Alpha= Y:=}'); +Expect(1, 90, '\p{Alpha=y}', ""); +Expect(0, 90, '\p{^Alpha=y}', ""); +Expect(0, 90, '\P{Alpha=y}', ""); +Expect(1, 90, '\P{^Alpha=y}', ""); +Expect(0, 64, '\p{Alpha=y}', ""); +Expect(1, 64, '\p{^Alpha=y}', ""); +Expect(1, 64, '\P{Alpha=y}', ""); +Expect(0, 64, '\P{^Alpha=y}', ""); +Expect(1, 90, '\p{Alpha=__y}', ""); +Expect(0, 90, '\p{^Alpha=__y}', ""); +Expect(0, 90, '\P{Alpha=__y}', ""); +Expect(1, 90, '\P{^Alpha=__y}', ""); +Expect(0, 64, '\p{Alpha=__y}', ""); +Expect(1, 64, '\p{^Alpha=__y}', ""); +Expect(1, 64, '\P{Alpha=__y}', ""); +Expect(0, 64, '\P{^Alpha=__y}', ""); +Error('\p{Is_Alphabetic=:= T}'); +Error('\P{Is_Alphabetic=:= T}'); +Expect(1, 90, '\p{Is_Alphabetic: t}', ""); +Expect(0, 90, '\p{^Is_Alphabetic: t}', ""); +Expect(0, 90, '\P{Is_Alphabetic: t}', ""); +Expect(1, 90, '\P{^Is_Alphabetic: t}', ""); +Expect(0, 64, '\p{Is_Alphabetic: t}', ""); +Expect(1, 64, '\p{^Is_Alphabetic: t}', ""); +Expect(1, 64, '\P{Is_Alphabetic: t}', ""); +Expect(0, 64, '\P{^Is_Alphabetic: t}', ""); +Expect(1, 90, '\p{Is_Alphabetic=_T}', ""); +Expect(0, 90, '\p{^Is_Alphabetic=_T}', ""); +Expect(0, 90, '\P{Is_Alphabetic=_T}', ""); +Expect(1, 90, '\P{^Is_Alphabetic=_T}', ""); +Expect(0, 64, '\p{Is_Alphabetic=_T}', ""); +Expect(1, 64, '\p{^Is_Alphabetic=_T}', ""); +Expect(1, 64, '\P{Is_Alphabetic=_T}', ""); +Expect(0, 64, '\P{^Is_Alphabetic=_T}', ""); +Error('\p{Is_Alpha= true/a/}'); +Error('\P{Is_Alpha= true/a/}'); +Expect(1, 90, '\p{Is_Alpha=true}', ""); +Expect(0, 90, '\p{^Is_Alpha=true}', ""); +Expect(0, 90, '\P{Is_Alpha=true}', ""); +Expect(1, 90, '\P{^Is_Alpha=true}', ""); +Expect(0, 64, '\p{Is_Alpha=true}', ""); +Expect(1, 64, '\p{^Is_Alpha=true}', ""); +Expect(1, 64, '\P{Is_Alpha=true}', ""); +Expect(0, 64, '\P{^Is_Alpha=true}', ""); +Expect(1, 90, '\p{Is_Alpha= True}', ""); +Expect(0, 90, '\p{^Is_Alpha= True}', ""); +Expect(0, 90, '\P{Is_Alpha= True}', ""); +Expect(1, 90, '\P{^Is_Alpha= True}', ""); +Expect(0, 64, '\p{Is_Alpha= True}', ""); +Expect(1, 64, '\p{^Is_Alpha= True}', ""); +Expect(1, 64, '\P{Is_Alpha= True}', ""); +Expect(0, 64, '\P{^Is_Alpha= True}', ""); +Error('\p{Alphabetic=/a/_no}'); +Error('\P{Alphabetic=/a/_no}'); +Expect(1, 64, '\p{Alphabetic=no}', ""); +Expect(0, 64, '\p{^Alphabetic=no}', ""); +Expect(0, 64, '\P{Alphabetic=no}', ""); +Expect(1, 64, '\P{^Alphabetic=no}', ""); +Expect(0, 90, '\p{Alphabetic=no}', ""); +Expect(1, 90, '\p{^Alphabetic=no}', ""); +Expect(1, 90, '\P{Alphabetic=no}', ""); +Expect(0, 90, '\P{^Alphabetic=no}', ""); +Expect(1, 64, '\p{Alphabetic=-NO}', ""); +Expect(0, 64, '\p{^Alphabetic=-NO}', ""); +Expect(0, 64, '\P{Alphabetic=-NO}', ""); +Expect(1, 64, '\P{^Alphabetic=-NO}', ""); +Expect(0, 90, '\p{Alphabetic=-NO}', ""); +Expect(1, 90, '\p{^Alphabetic=-NO}', ""); +Expect(1, 90, '\P{Alphabetic=-NO}', ""); +Expect(0, 90, '\P{^Alphabetic=-NO}', ""); +Error('\p{Alpha=:=_N}'); +Error('\P{Alpha=:=_N}'); +Expect(1, 64, '\p{Alpha=n}', ""); +Expect(0, 64, '\p{^Alpha=n}', ""); +Expect(0, 64, '\P{Alpha=n}', ""); +Expect(1, 64, '\P{^Alpha=n}', ""); +Expect(0, 90, '\p{Alpha=n}', ""); +Expect(1, 90, '\p{^Alpha=n}', ""); +Expect(1, 90, '\P{Alpha=n}', ""); +Expect(0, 90, '\P{^Alpha=n}', ""); +Expect(1, 64, '\p{Alpha= N}', ""); +Expect(0, 64, '\p{^Alpha= N}', ""); +Expect(0, 64, '\P{Alpha= N}', ""); +Expect(1, 64, '\P{^Alpha= N}', ""); +Expect(0, 90, '\p{Alpha= N}', ""); +Expect(1, 90, '\p{^Alpha= N}', ""); +Expect(1, 90, '\P{Alpha= N}', ""); +Expect(0, 90, '\P{^Alpha= N}', ""); +Error('\p{Is_Alphabetic: -F:=}'); +Error('\P{Is_Alphabetic: -F:=}'); +Expect(1, 64, '\p{Is_Alphabetic=f}', ""); +Expect(0, 64, '\p{^Is_Alphabetic=f}', ""); +Expect(0, 64, '\P{Is_Alphabetic=f}', ""); +Expect(1, 64, '\P{^Is_Alphabetic=f}', ""); +Expect(0, 90, '\p{Is_Alphabetic=f}', ""); +Expect(1, 90, '\p{^Is_Alphabetic=f}', ""); +Expect(1, 90, '\P{Is_Alphabetic=f}', ""); +Expect(0, 90, '\P{^Is_Alphabetic=f}', ""); +Expect(1, 64, '\p{Is_Alphabetic: -F}', ""); +Expect(0, 64, '\p{^Is_Alphabetic: -F}', ""); +Expect(0, 64, '\P{Is_Alphabetic: -F}', ""); +Expect(1, 64, '\P{^Is_Alphabetic: -F}', ""); +Expect(0, 90, '\p{Is_Alphabetic: -F}', ""); +Expect(1, 90, '\p{^Is_Alphabetic: -F}', ""); +Expect(1, 90, '\P{Is_Alphabetic: -F}', ""); +Expect(0, 90, '\P{^Is_Alphabetic: -F}', ""); +Error('\p{Is_Alpha= false:=}'); +Error('\P{Is_Alpha= false:=}'); +Expect(1, 64, '\p{Is_Alpha=false}', ""); +Expect(0, 64, '\p{^Is_Alpha=false}', ""); +Expect(0, 64, '\P{Is_Alpha=false}', ""); +Expect(1, 64, '\P{^Is_Alpha=false}', ""); +Expect(0, 90, '\p{Is_Alpha=false}', ""); +Expect(1, 90, '\p{^Is_Alpha=false}', ""); +Expect(1, 90, '\P{Is_Alpha=false}', ""); +Expect(0, 90, '\P{^Is_Alpha=false}', ""); +Expect(1, 64, '\p{Is_Alpha= _False}', ""); +Expect(0, 64, '\p{^Is_Alpha= _False}', ""); +Expect(0, 64, '\P{Is_Alpha= _False}', ""); +Expect(1, 64, '\P{^Is_Alpha= _False}', ""); +Expect(0, 90, '\p{Is_Alpha= _False}', ""); +Expect(1, 90, '\p{^Is_Alpha= _False}', ""); +Expect(1, 90, '\P{Is_Alpha= _False}', ""); +Expect(0, 90, '\P{^Is_Alpha= _False}', ""); +Error('\p{Hex_Digit=- Yes/a/}'); +Error('\P{Hex_Digit=- Yes/a/}'); +Expect(1, 57, '\p{Hex_Digit=yes}', ""); +Expect(0, 57, '\p{^Hex_Digit=yes}', ""); +Expect(0, 57, '\P{Hex_Digit=yes}', ""); +Expect(1, 57, '\P{^Hex_Digit=yes}', ""); +Expect(0, 47, '\p{Hex_Digit=yes}', ""); +Expect(1, 47, '\p{^Hex_Digit=yes}', ""); +Expect(1, 47, '\P{Hex_Digit=yes}', ""); +Expect(0, 47, '\P{^Hex_Digit=yes}', ""); +Expect(1, 57, '\p{Hex_Digit= _YES}', ""); +Expect(0, 57, '\p{^Hex_Digit= _YES}', ""); +Expect(0, 57, '\P{Hex_Digit= _YES}', ""); +Expect(1, 57, '\P{^Hex_Digit= _YES}', ""); +Expect(0, 47, '\p{Hex_Digit= _YES}', ""); +Expect(1, 47, '\p{^Hex_Digit= _YES}', ""); +Expect(1, 47, '\P{Hex_Digit= _YES}', ""); +Expect(0, 47, '\P{^Hex_Digit= _YES}', ""); +Error('\p{Hex= /a/Y}'); +Error('\P{Hex= /a/Y}'); +Expect(1, 57, '\p{Hex:y}', ""); +Expect(0, 57, '\p{^Hex:y}', ""); +Expect(0, 57, '\P{Hex:y}', ""); +Expect(1, 57, '\P{^Hex:y}', ""); +Expect(0, 47, '\p{Hex:y}', ""); +Expect(1, 47, '\p{^Hex:y}', ""); +Expect(1, 47, '\P{Hex:y}', ""); +Expect(0, 47, '\P{^Hex:y}', ""); +Expect(1, 57, '\p{Hex= Y}', ""); +Expect(0, 57, '\p{^Hex= Y}', ""); +Expect(0, 57, '\P{Hex= Y}', ""); +Expect(1, 57, '\P{^Hex= Y}', ""); +Expect(0, 47, '\p{Hex= Y}', ""); +Expect(1, 47, '\p{^Hex= Y}', ""); +Expect(1, 47, '\P{Hex= Y}', ""); +Expect(0, 47, '\P{^Hex= Y}', ""); +Error('\p{Is_Hex_Digit=_T/a/}'); +Error('\P{Is_Hex_Digit=_T/a/}'); +Expect(1, 57, '\p{Is_Hex_Digit=t}', ""); +Expect(0, 57, '\p{^Is_Hex_Digit=t}', ""); +Expect(0, 57, '\P{Is_Hex_Digit=t}', ""); +Expect(1, 57, '\P{^Is_Hex_Digit=t}', ""); +Expect(0, 47, '\p{Is_Hex_Digit=t}', ""); +Expect(1, 47, '\p{^Is_Hex_Digit=t}', ""); +Expect(1, 47, '\P{Is_Hex_Digit=t}', ""); +Expect(0, 47, '\P{^Is_Hex_Digit=t}', ""); +Expect(1, 57, '\p{Is_Hex_Digit=-_T}', ""); +Expect(0, 57, '\p{^Is_Hex_Digit=-_T}', ""); +Expect(0, 57, '\P{Is_Hex_Digit=-_T}', ""); +Expect(1, 57, '\P{^Is_Hex_Digit=-_T}', ""); +Expect(0, 47, '\p{Is_Hex_Digit=-_T}', ""); +Expect(1, 47, '\p{^Is_Hex_Digit=-_T}', ""); +Expect(1, 47, '\P{Is_Hex_Digit=-_T}', ""); +Expect(0, 47, '\P{^Is_Hex_Digit=-_T}', ""); +Error('\p{Is_Hex= True/a/}'); +Error('\P{Is_Hex= True/a/}'); +Expect(1, 57, '\p{Is_Hex=true}', ""); +Expect(0, 57, '\p{^Is_Hex=true}', ""); +Expect(0, 57, '\P{Is_Hex=true}', ""); +Expect(1, 57, '\P{^Is_Hex=true}', ""); +Expect(0, 47, '\p{Is_Hex=true}', ""); +Expect(1, 47, '\p{^Is_Hex=true}', ""); +Expect(1, 47, '\P{Is_Hex=true}', ""); +Expect(0, 47, '\P{^Is_Hex=true}', ""); +Expect(1, 57, '\p{Is_Hex= -true}', ""); +Expect(0, 57, '\p{^Is_Hex= -true}', ""); +Expect(0, 57, '\P{Is_Hex= -true}', ""); +Expect(1, 57, '\P{^Is_Hex= -true}', ""); +Expect(0, 47, '\p{Is_Hex= -true}', ""); +Expect(1, 47, '\p{^Is_Hex= -true}', ""); +Expect(1, 47, '\P{Is_Hex= -true}', ""); +Expect(0, 47, '\P{^Is_Hex= -true}', ""); +Error('\p{Hex_Digit=_/a/no}'); +Error('\P{Hex_Digit=_/a/no}'); +Expect(1, 47, '\p{Hex_Digit=no}', ""); +Expect(0, 47, '\p{^Hex_Digit=no}', ""); +Expect(0, 47, '\P{Hex_Digit=no}', ""); +Expect(1, 47, '\P{^Hex_Digit=no}', ""); +Expect(0, 57, '\p{Hex_Digit=no}', ""); +Expect(1, 57, '\p{^Hex_Digit=no}', ""); +Expect(1, 57, '\P{Hex_Digit=no}', ""); +Expect(0, 57, '\P{^Hex_Digit=no}', ""); +Expect(1, 47, '\p{Hex_Digit= No}', ""); +Expect(0, 47, '\p{^Hex_Digit= No}', ""); +Expect(0, 47, '\P{Hex_Digit= No}', ""); +Expect(1, 47, '\P{^Hex_Digit= No}', ""); +Expect(0, 57, '\p{Hex_Digit= No}', ""); +Expect(1, 57, '\p{^Hex_Digit= No}', ""); +Expect(1, 57, '\P{Hex_Digit= No}', ""); +Expect(0, 57, '\P{^Hex_Digit= No}', ""); +Error('\p{Hex=_ n:=}'); +Error('\P{Hex=_ n:=}'); +Expect(1, 47, '\p{Hex=n}', ""); +Expect(0, 47, '\p{^Hex=n}', ""); +Expect(0, 47, '\P{Hex=n}', ""); +Expect(1, 47, '\P{^Hex=n}', ""); +Expect(0, 57, '\p{Hex=n}', ""); +Expect(1, 57, '\p{^Hex=n}', ""); +Expect(1, 57, '\P{Hex=n}', ""); +Expect(0, 57, '\P{^Hex=n}', ""); +Expect(1, 47, '\p{Hex=-N}', ""); +Expect(0, 47, '\p{^Hex=-N}', ""); +Expect(0, 47, '\P{Hex=-N}', ""); +Expect(1, 47, '\P{^Hex=-N}', ""); +Expect(0, 57, '\p{Hex=-N}', ""); +Expect(1, 57, '\p{^Hex=-N}', ""); +Expect(1, 57, '\P{Hex=-N}', ""); +Expect(0, 57, '\P{^Hex=-N}', ""); +Error('\p{Is_Hex_Digit= F/a/}'); +Error('\P{Is_Hex_Digit= F/a/}'); +Expect(1, 47, '\p{Is_Hex_Digit=f}', ""); +Expect(0, 47, '\p{^Is_Hex_Digit=f}', ""); +Expect(0, 47, '\P{Is_Hex_Digit=f}', ""); +Expect(1, 47, '\P{^Is_Hex_Digit=f}', ""); +Expect(0, 57, '\p{Is_Hex_Digit=f}', ""); +Expect(1, 57, '\p{^Is_Hex_Digit=f}', ""); +Expect(1, 57, '\P{Is_Hex_Digit=f}', ""); +Expect(0, 57, '\P{^Is_Hex_Digit=f}', ""); +Expect(1, 47, '\p{Is_Hex_Digit= _F}', ""); +Expect(0, 47, '\p{^Is_Hex_Digit= _F}', ""); +Expect(0, 47, '\P{Is_Hex_Digit= _F}', ""); +Expect(1, 47, '\P{^Is_Hex_Digit= _F}', ""); +Expect(0, 57, '\p{Is_Hex_Digit= _F}', ""); +Expect(1, 57, '\p{^Is_Hex_Digit= _F}', ""); +Expect(1, 57, '\P{Is_Hex_Digit= _F}', ""); +Expect(0, 57, '\P{^Is_Hex_Digit= _F}', ""); +Error('\p{Is_Hex= false:=}'); +Error('\P{Is_Hex= false:=}'); +Expect(1, 47, '\p{Is_Hex=false}', ""); +Expect(0, 47, '\p{^Is_Hex=false}', ""); +Expect(0, 47, '\P{Is_Hex=false}', ""); +Expect(1, 47, '\P{^Is_Hex=false}', ""); +Expect(0, 57, '\p{Is_Hex=false}', ""); +Expect(1, 57, '\p{^Is_Hex=false}', ""); +Expect(1, 57, '\P{Is_Hex=false}', ""); +Expect(0, 57, '\P{^Is_Hex=false}', ""); +Expect(1, 47, '\p{Is_Hex=-_false}', ""); +Expect(0, 47, '\p{^Is_Hex=-_false}', ""); +Expect(0, 47, '\P{Is_Hex=-_false}', ""); +Expect(1, 47, '\P{^Is_Hex=-_false}', ""); +Expect(0, 57, '\p{Is_Hex=-_false}', ""); +Expect(1, 57, '\p{^Is_Hex=-_false}', ""); +Expect(1, 57, '\P{Is_Hex=-_false}', ""); +Expect(0, 57, '\P{^Is_Hex=-_false}', ""); +Error('\p{Canonical_Combining_Class=-_+00/a/00 32}'); +Error('\P{Canonical_Combining_Class=-_+00/a/00 32}'); +Expect(1, 1562, '\p{Canonical_Combining_Class=0000032}', ""); +Expect(0, 1562, '\p{^Canonical_Combining_Class=0000032}', ""); +Expect(0, 1562, '\P{Canonical_Combining_Class=0000032}', ""); +Expect(1, 1562, '\P{^Canonical_Combining_Class=0000032}', ""); +Expect(0, 1561, '\p{Canonical_Combining_Class=0000032}', ""); +Expect(1, 1561, '\p{^Canonical_Combining_Class=0000032}', ""); +Expect(1, 1561, '\P{Canonical_Combining_Class=0000032}', ""); +Expect(0, 1561, '\P{^Canonical_Combining_Class=0000032}', ""); +Error('\p{Ccc=-_0 0_0:=0-0 0 0_032}'); +Error('\P{Ccc=-_0 0_0:=0-0 0 0_032}'); +Expect(1, 1562, '\p{Ccc=00003_2}', ""); +Expect(0, 1562, '\p{^Ccc=00003_2}', ""); +Expect(0, 1562, '\P{Ccc=00003_2}', ""); +Expect(1, 1562, '\P{^Ccc=00003_2}', ""); +Expect(0, 1561, '\p{Ccc=00003_2}', ""); +Expect(1, 1561, '\p{^Ccc=00003_2}', ""); +Expect(1, 1561, '\P{Ccc=00003_2}', ""); +Expect(0, 1561, '\P{^Ccc=00003_2}', ""); +Error('\p{Is_Canonical_Combining_Class=:=- 000000032}'); +Error('\P{Is_Canonical_Combining_Class=:=- 000000032}'); +Expect(1, 1562, '\p{Is_Canonical_Combining_Class=0000000032}', ""); +Expect(0, 1562, '\p{^Is_Canonical_Combining_Class=0000000032}', ""); +Expect(0, 1562, '\P{Is_Canonical_Combining_Class=0000000032}', ""); +Expect(1, 1562, '\P{^Is_Canonical_Combining_Class=0000000032}', ""); +Expect(0, 1561, '\p{Is_Canonical_Combining_Class=0000000032}', ""); +Expect(1, 1561, '\p{^Is_Canonical_Combining_Class=0000000032}', ""); +Expect(1, 1561, '\P{Is_Canonical_Combining_Class=0000000032}', ""); +Expect(0, 1561, '\P{^Is_Canonical_Combining_Class=0000000032}', ""); +Error('\p{Is_Ccc=--+0-0 0_0 00 0 0:=0_32}'); +Error('\P{Is_Ccc=--+0-0 0_0 00 0 0:=0_32}'); +Expect(1, 1562, '\p{Is_Ccc=0000_0000_32}', ""); +Expect(0, 1562, '\p{^Is_Ccc=0000_0000_32}', ""); +Expect(0, 1562, '\P{Is_Ccc=0000_0000_32}', ""); +Expect(1, 1562, '\P{^Is_Ccc=0000_0000_32}', ""); +Expect(0, 1561, '\p{Is_Ccc=0000_0000_32}', ""); +Expect(1, 1561, '\p{^Is_Ccc=0000_0000_32}', ""); +Expect(1, 1561, '\P{Is_Ccc=0000_0000_32}', ""); +Expect(0, 1561, '\P{^Is_Ccc=0000_0000_32}', ""); +Error('\p{Canonical_Combining_Class=-_0000000118/a/}'); +Error('\P{Canonical_Combining_Class=-_0000000118/a/}'); +Expect(1, 3769, '\p{Canonical_Combining_Class: 000118}', ""); +Expect(0, 3769, '\p{^Canonical_Combining_Class: 000118}', ""); +Expect(0, 3769, '\P{Canonical_Combining_Class: 000118}', ""); +Expect(1, 3769, '\P{^Canonical_Combining_Class: 000118}', ""); +Expect(0, 3767, '\p{Canonical_Combining_Class: 000118}', ""); +Expect(1, 3767, '\p{^Canonical_Combining_Class: 000118}', ""); +Expect(1, 3767, '\P{Canonical_Combining_Class: 000118}', ""); +Expect(0, 3767, '\P{^Canonical_Combining_Class: 000118}', ""); +Error('\p{Ccc= /a/+011 8}'); +Error('\P{Ccc= /a/+011 8}'); +Expect(1, 3769, '\p{Ccc=+00118}', ""); +Expect(0, 3769, '\p{^Ccc=+00118}', ""); +Expect(0, 3769, '\P{Ccc=+00118}', ""); +Expect(1, 3769, '\P{^Ccc=+00118}', ""); +Expect(0, 3767, '\p{Ccc=+00118}', ""); +Expect(1, 3767, '\p{^Ccc=+00118}', ""); +Expect(1, 3767, '\P{Ccc=+00118}', ""); +Expect(0, 3767, '\P{^Ccc=+00118}', ""); +Error('\p{Is_Canonical_Combining_Class= /a/000-011 8}'); +Error('\P{Is_Canonical_Combining_Class= /a/000-011 8}'); +Expect(1, 3769, '\p{Is_Canonical_Combining_Class=+00_00_01_18}', ""); +Expect(0, 3769, '\p{^Is_Canonical_Combining_Class=+00_00_01_18}', ""); +Expect(0, 3769, '\P{Is_Canonical_Combining_Class=+00_00_01_18}', ""); +Expect(1, 3769, '\P{^Is_Canonical_Combining_Class=+00_00_01_18}', ""); +Expect(0, 3767, '\p{Is_Canonical_Combining_Class=+00_00_01_18}', ""); +Expect(1, 3767, '\p{^Is_Canonical_Combining_Class=+00_00_01_18}', ""); +Expect(1, 3767, '\P{Is_Canonical_Combining_Class=+00_00_01_18}', ""); +Expect(0, 3767, '\P{^Is_Canonical_Combining_Class=+00_00_01_18}', ""); +Error('\p{Is_Ccc= :=118}'); +Error('\P{Is_Ccc= :=118}'); +Expect(1, 3769, '\p{Is_Ccc=+00000000118}', ""); +Expect(0, 3769, '\p{^Is_Ccc=+00000000118}', ""); +Expect(0, 3769, '\P{Is_Ccc=+00000000118}', ""); +Expect(1, 3769, '\P{^Is_Ccc=+00000000118}', ""); +Expect(0, 3767, '\p{Is_Ccc=+00000000118}', ""); +Expect(1, 3767, '\p{^Is_Ccc=+00000000118}', ""); +Expect(1, 3767, '\P{Is_Ccc=+00000000118}', ""); +Expect(0, 3767, '\P{^Is_Ccc=+00000000118}', ""); +Error('\p{Canonical_Combining_Class: -Double-above/a/}'); +Error('\P{Canonical_Combining_Class: -Double-above/a/}'); +Expect(1, 862, '\p{Canonical_Combining_Class=doubleabove}', ""); +Expect(0, 862, '\p{^Canonical_Combining_Class=doubleabove}', ""); +Expect(0, 862, '\P{Canonical_Combining_Class=doubleabove}', ""); +Expect(1, 862, '\P{^Canonical_Combining_Class=doubleabove}', ""); +Expect(0, 860, '\p{Canonical_Combining_Class=doubleabove}', ""); +Expect(1, 860, '\p{^Canonical_Combining_Class=doubleabove}', ""); +Expect(1, 860, '\P{Canonical_Combining_Class=doubleabove}', ""); +Expect(0, 860, '\P{^Canonical_Combining_Class=doubleabove}', ""); +Expect(1, 862, '\p{Canonical_Combining_Class: -DOUBLE_ABOVE}', ""); +Expect(0, 862, '\p{^Canonical_Combining_Class: -DOUBLE_ABOVE}', ""); +Expect(0, 862, '\P{Canonical_Combining_Class: -DOUBLE_ABOVE}', ""); +Expect(1, 862, '\P{^Canonical_Combining_Class: -DOUBLE_ABOVE}', ""); +Expect(0, 860, '\p{Canonical_Combining_Class: -DOUBLE_ABOVE}', ""); +Expect(1, 860, '\p{^Canonical_Combining_Class: -DOUBLE_ABOVE}', ""); +Expect(1, 860, '\P{Canonical_Combining_Class: -DOUBLE_ABOVE}', ""); +Expect(0, 860, '\P{^Canonical_Combining_Class: -DOUBLE_ABOVE}', ""); +Error('\p{Ccc=_/a/da}'); +Error('\P{Ccc=_/a/da}'); +Expect(1, 862, '\p{Ccc=da}', ""); +Expect(0, 862, '\p{^Ccc=da}', ""); +Expect(0, 862, '\P{Ccc=da}', ""); +Expect(1, 862, '\P{^Ccc=da}', ""); +Expect(0, 860, '\p{Ccc=da}', ""); +Expect(1, 860, '\p{^Ccc=da}', ""); +Expect(1, 860, '\P{Ccc=da}', ""); +Expect(0, 860, '\P{^Ccc=da}', ""); +Expect(1, 862, '\p{Ccc= -DA}', ""); +Expect(0, 862, '\p{^Ccc= -DA}', ""); +Expect(0, 862, '\P{Ccc= -DA}', ""); +Expect(1, 862, '\P{^Ccc= -DA}', ""); +Expect(0, 860, '\p{Ccc= -DA}', ""); +Expect(1, 860, '\p{^Ccc= -DA}', ""); +Expect(1, 860, '\P{Ccc= -DA}', ""); +Expect(0, 860, '\P{^Ccc= -DA}', ""); +Error('\p{Is_Canonical_Combining_Class=:=__000234}'); +Error('\P{Is_Canonical_Combining_Class=:=__000234}'); +Expect(1, 862, '\p{Is_Canonical_Combining_Class=000234}', ""); +Expect(0, 862, '\p{^Is_Canonical_Combining_Class=000234}', ""); +Expect(0, 862, '\P{Is_Canonical_Combining_Class=000234}', ""); +Expect(1, 862, '\P{^Is_Canonical_Combining_Class=000234}', ""); +Expect(0, 860, '\p{Is_Canonical_Combining_Class=000234}', ""); +Expect(1, 860, '\p{^Is_Canonical_Combining_Class=000234}', ""); +Expect(1, 860, '\P{Is_Canonical_Combining_Class=000234}', ""); +Expect(0, 860, '\P{^Is_Canonical_Combining_Class=000234}', ""); +Error('\p{Is_Ccc= Double:=Above}'); +Error('\P{Is_Ccc= Double:=Above}'); +Expect(1, 862, '\p{Is_Ccc: doubleabove}', ""); +Expect(0, 862, '\p{^Is_Ccc: doubleabove}', ""); +Expect(0, 862, '\P{Is_Ccc: doubleabove}', ""); +Expect(1, 862, '\P{^Is_Ccc: doubleabove}', ""); +Expect(0, 860, '\p{Is_Ccc: doubleabove}', ""); +Expect(1, 860, '\p{^Is_Ccc: doubleabove}', ""); +Expect(1, 860, '\P{Is_Ccc: doubleabove}', ""); +Expect(0, 860, '\P{^Is_Ccc: doubleabove}', ""); +Expect(1, 862, '\p{Is_Ccc= DOUBLE ABOVE}', ""); +Expect(0, 862, '\p{^Is_Ccc= DOUBLE ABOVE}', ""); +Expect(0, 862, '\P{Is_Ccc= DOUBLE ABOVE}', ""); +Expect(1, 862, '\P{^Is_Ccc= DOUBLE ABOVE}', ""); +Expect(0, 860, '\p{Is_Ccc= DOUBLE ABOVE}', ""); +Expect(1, 860, '\p{^Is_Ccc= DOUBLE ABOVE}', ""); +Expect(1, 860, '\P{Is_Ccc= DOUBLE ABOVE}', ""); +Expect(0, 860, '\P{^Is_Ccc= DOUBLE ABOVE}', ""); +Error('\p{Canonical_Combining_Class= Attached-BELOW/a/Left}'); +Error('\P{Canonical_Combining_Class= Attached-BELOW/a/Left}'); +Expect(0, 7, '\p{Canonical_Combining_Class=attachedbelowleft}', ""); +Expect(1, 7, '\p{^Canonical_Combining_Class=attachedbelowleft}', ""); +Expect(1, 7, '\P{Canonical_Combining_Class=attachedbelowleft}', ""); +Expect(0, 7, '\P{^Canonical_Combining_Class=attachedbelowleft}', ""); +Expect(0, 7, '\p{Canonical_Combining_Class: _ATTACHED_Below Left}', ""); +Expect(1, 7, '\p{^Canonical_Combining_Class: _ATTACHED_Below Left}', ""); +Expect(1, 7, '\P{Canonical_Combining_Class: _ATTACHED_Below Left}', ""); +Expect(0, 7, '\P{^Canonical_Combining_Class: _ATTACHED_Below Left}', ""); +Error('\p{Ccc=-/a/ATBL}'); +Error('\P{Ccc=-/a/ATBL}'); +Expect(0, 7, '\p{Ccc=atbl}', ""); +Expect(1, 7, '\p{^Ccc=atbl}', ""); +Expect(1, 7, '\P{Ccc=atbl}', ""); +Expect(0, 7, '\P{^Ccc=atbl}', ""); +Expect(0, 7, '\p{Ccc= -ATBL}', ""); +Expect(1, 7, '\p{^Ccc= -ATBL}', ""); +Expect(1, 7, '\P{Ccc= -ATBL}', ""); +Expect(0, 7, '\P{^Ccc= -ATBL}', ""); +Error('\p{Is_Canonical_Combining_Class=_-+0002 00:=}'); +Error('\P{Is_Canonical_Combining_Class=_-+0002 00:=}'); +Expect(0, 7, '\p{Is_Canonical_Combining_Class=00000_00002_00}', ""); +Expect(1, 7, '\p{^Is_Canonical_Combining_Class=00000_00002_00}', ""); +Expect(1, 7, '\P{Is_Canonical_Combining_Class=00000_00002_00}', ""); +Expect(0, 7, '\P{^Is_Canonical_Combining_Class=00000_00002_00}', ""); +Error('\p{Is_Ccc=_:=ATTACHED_Below_LEFT}'); +Error('\P{Is_Ccc=_:=ATTACHED_Below_LEFT}'); +Expect(0, 7, '\p{Is_Ccc=attachedbelowleft}', ""); +Expect(1, 7, '\p{^Is_Ccc=attachedbelowleft}', ""); +Expect(1, 7, '\P{Is_Ccc=attachedbelowleft}', ""); +Expect(0, 7, '\P{^Is_Ccc=attachedbelowleft}', ""); +Expect(0, 7, '\p{Is_Ccc=Attached Below-Left}', ""); +Expect(1, 7, '\p{^Is_Ccc=Attached Below-Left}', ""); +Expect(1, 7, '\P{Is_Ccc=Attached Below-Left}', ""); +Expect(0, 7, '\P{^Is_Ccc=Attached Below-Left}', ""); +Error('\p{Canonical_Combining_Class=-/a/+00018}'); +Error('\P{Canonical_Combining_Class=-/a/+00018}'); +Expect(1, 1464, '\p{Canonical_Combining_Class=000018}', ""); +Expect(0, 1464, '\p{^Canonical_Combining_Class=000018}', ""); +Expect(0, 1464, '\P{Canonical_Combining_Class=000018}', ""); +Expect(1, 1464, '\P{^Canonical_Combining_Class=000018}', ""); +Expect(0, 1463, '\p{Canonical_Combining_Class=000018}', ""); +Expect(1, 1463, '\p{^Canonical_Combining_Class=000018}', ""); +Expect(1, 1463, '\P{Canonical_Combining_Class=000018}', ""); +Expect(0, 1463, '\P{^Canonical_Combining_Class=000018}', ""); +Error('\p{Ccc= _018:=}'); +Error('\P{Ccc= _018:=}'); +Expect(1, 1464, '\p{Ccc=+001_8}', ""); +Expect(0, 1464, '\p{^Ccc=+001_8}', ""); +Expect(0, 1464, '\P{Ccc=+001_8}', ""); +Expect(1, 1464, '\P{^Ccc=+001_8}', ""); +Expect(0, 1463, '\p{Ccc=+001_8}', ""); +Expect(1, 1463, '\p{^Ccc=+001_8}', ""); +Expect(1, 1463, '\P{Ccc=+001_8}', ""); +Expect(0, 1463, '\P{^Ccc=+001_8}', ""); +Error('\p{Is_Canonical_Combining_Class= 0/a/0 0 0 0_0 0 018}'); +Error('\P{Is_Canonical_Combining_Class= 0/a/0 0 0 0_0 0 018}'); +Expect(1, 1464, '\p{Is_Canonical_Combining_Class=0018}', ""); +Expect(0, 1464, '\p{^Is_Canonical_Combining_Class=0018}', ""); +Expect(0, 1464, '\P{Is_Canonical_Combining_Class=0018}', ""); +Expect(1, 1464, '\P{^Is_Canonical_Combining_Class=0018}', ""); +Expect(0, 1463, '\p{Is_Canonical_Combining_Class=0018}', ""); +Expect(1, 1463, '\p{^Is_Canonical_Combining_Class=0018}', ""); +Expect(1, 1463, '\P{Is_Canonical_Combining_Class=0018}', ""); +Expect(0, 1463, '\P{^Is_Canonical_Combining_Class=0018}', ""); +Error('\p{Is_Ccc= 0000000018:=}'); +Error('\P{Is_Ccc= 0000000018:=}'); +Expect(1, 1464, '\p{Is_Ccc=+0_0_0_18}', ""); +Expect(0, 1464, '\p{^Is_Ccc=+0_0_0_18}', ""); +Expect(0, 1464, '\P{Is_Ccc=+0_0_0_18}', ""); +Expect(1, 1464, '\P{^Is_Ccc=+0_0_0_18}', ""); +Expect(0, 1463, '\p{Is_Ccc=+0_0_0_18}', ""); +Expect(1, 1463, '\p{^Is_Ccc=+0_0_0_18}', ""); +Expect(1, 1463, '\P{Is_Ccc=+0_0_0_18}', ""); +Expect(0, 1463, '\P{^Is_Ccc=+0_0_0_18}', ""); +Error('\p{Canonical_Combining_Class= 1/a/6}'); +Error('\P{Canonical_Combining_Class= 1/a/6}'); +Expect(1, 1462, '\p{Canonical_Combining_Class=+01_6}', ""); +Expect(0, 1462, '\p{^Canonical_Combining_Class=+01_6}', ""); +Expect(0, 1462, '\P{Canonical_Combining_Class=+01_6}', ""); +Expect(1, 1462, '\P{^Canonical_Combining_Class=+01_6}', ""); +Expect(0, 1461, '\p{Canonical_Combining_Class=+01_6}', ""); +Expect(1, 1461, '\p{^Canonical_Combining_Class=+01_6}', ""); +Expect(1, 1461, '\P{Canonical_Combining_Class=+01_6}', ""); +Expect(0, 1461, '\P{^Canonical_Combining_Class=+01_6}', ""); +Error('\p{Ccc= 0:=0 0 0_0_0016}'); +Error('\P{Ccc= 0:=0 0 0_0_0016}'); +Expect(1, 1462, '\p{Ccc=1_6}', ""); +Expect(0, 1462, '\p{^Ccc=1_6}', ""); +Expect(0, 1462, '\P{Ccc=1_6}', ""); +Expect(1, 1462, '\P{^Ccc=1_6}', ""); +Expect(0, 1461, '\p{Ccc=1_6}', ""); +Expect(1, 1461, '\p{^Ccc=1_6}', ""); +Expect(1, 1461, '\P{Ccc=1_6}', ""); +Expect(0, 1461, '\P{^Ccc=1_6}', ""); +Error('\p{Is_Canonical_Combining_Class=:=- 00016}'); +Error('\P{Is_Canonical_Combining_Class=:=- 00016}'); +Expect(1, 1462, '\p{Is_Canonical_Combining_Class=1_6}', ""); +Expect(0, 1462, '\p{^Is_Canonical_Combining_Class=1_6}', ""); +Expect(0, 1462, '\P{Is_Canonical_Combining_Class=1_6}', ""); +Expect(1, 1462, '\P{^Is_Canonical_Combining_Class=1_6}', ""); +Expect(0, 1461, '\p{Is_Canonical_Combining_Class=1_6}', ""); +Expect(1, 1461, '\p{^Is_Canonical_Combining_Class=1_6}', ""); +Expect(1, 1461, '\P{Is_Canonical_Combining_Class=1_6}', ""); +Expect(0, 1461, '\P{^Is_Canonical_Combining_Class=1_6}', ""); +Error('\p{Is_Ccc=_/a/0-0 0 0016}'); +Error('\P{Is_Ccc=_/a/0-0 0 0016}'); +Expect(1, 1462, '\p{Is_Ccc=+01_6}', ""); +Expect(0, 1462, '\p{^Is_Ccc=+01_6}', ""); +Expect(0, 1462, '\P{Is_Ccc=+01_6}', ""); +Expect(1, 1462, '\P{^Is_Ccc=+01_6}', ""); +Expect(0, 1461, '\p{Is_Ccc=+01_6}', ""); +Expect(1, 1461, '\p{^Is_Ccc=+01_6}', ""); +Expect(1, 1461, '\P{Is_Ccc=+01_6}', ""); +Expect(0, 1461, '\P{^Is_Ccc=+01_6}', ""); +Error('\p{Canonical_Combining_Class= /a/084}'); +Error('\P{Canonical_Combining_Class= /a/084}'); +Expect(1, 3157, '\p{Canonical_Combining_Class=00000084}', ""); +Expect(0, 3157, '\p{^Canonical_Combining_Class=00000084}', ""); +Expect(0, 3157, '\P{Canonical_Combining_Class=00000084}', ""); +Expect(1, 3157, '\P{^Canonical_Combining_Class=00000084}', ""); +Expect(0, 3156, '\p{Canonical_Combining_Class=00000084}', ""); +Expect(1, 3156, '\p{^Canonical_Combining_Class=00000084}', ""); +Expect(1, 3156, '\P{Canonical_Combining_Class=00000084}', ""); +Expect(0, 3156, '\P{^Canonical_Combining_Class=00000084}', ""); +Error('\p{Ccc: :=00000000084}'); +Error('\P{Ccc: :=00000000084}'); +Expect(1, 3157, '\p{Ccc: 0000084}', ""); +Expect(0, 3157, '\p{^Ccc: 0000084}', ""); +Expect(0, 3157, '\P{Ccc: 0000084}', ""); +Expect(1, 3157, '\P{^Ccc: 0000084}', ""); +Expect(0, 3156, '\p{Ccc: 0000084}', ""); +Expect(1, 3156, '\p{^Ccc: 0000084}', ""); +Expect(1, 3156, '\P{Ccc: 0000084}', ""); +Expect(0, 3156, '\P{^Ccc: 0000084}', ""); +Error('\p{Is_Canonical_Combining_Class= /a/+084}'); +Error('\P{Is_Canonical_Combining_Class= /a/+084}'); +Expect(1, 3157, '\p{Is_Canonical_Combining_Class=000084}', ""); +Expect(0, 3157, '\p{^Is_Canonical_Combining_Class=000084}', ""); +Expect(0, 3157, '\P{Is_Canonical_Combining_Class=000084}', ""); +Expect(1, 3157, '\P{^Is_Canonical_Combining_Class=000084}', ""); +Expect(0, 3156, '\p{Is_Canonical_Combining_Class=000084}', ""); +Expect(1, 3156, '\p{^Is_Canonical_Combining_Class=000084}', ""); +Expect(1, 3156, '\P{Is_Canonical_Combining_Class=000084}', ""); +Expect(0, 3156, '\P{^Is_Canonical_Combining_Class=000084}', ""); +Error('\p{Is_Ccc=:=_ 0-0-84}'); +Error('\P{Is_Ccc=:=_ 0-0-84}'); +Expect(1, 3157, '\p{Is_Ccc=+000_008_4}', ""); +Expect(0, 3157, '\p{^Is_Ccc=+000_008_4}', ""); +Expect(0, 3157, '\P{Is_Ccc=+000_008_4}', ""); +Expect(1, 3157, '\P{^Is_Ccc=+000_008_4}', ""); +Expect(0, 3156, '\p{Is_Ccc=+000_008_4}', ""); +Expect(1, 3156, '\p{^Is_Ccc=+000_008_4}', ""); +Expect(1, 3156, '\P{Is_Ccc=+000_008_4}', ""); +Expect(0, 3156, '\P{^Is_Ccc=+000_008_4}', ""); +Error('\p{Canonical_Combining_Class= :=00 0000 027}'); +Error('\P{Canonical_Combining_Class= :=00 0000 027}'); +Expect(1, 1611, '\p{Canonical_Combining_Class=00000000027}', ""); +Expect(0, 1611, '\p{^Canonical_Combining_Class=00000000027}', ""); +Expect(0, 1611, '\P{Canonical_Combining_Class=00000000027}', ""); +Expect(1, 1611, '\P{^Canonical_Combining_Class=00000000027}', ""); +Expect(0, 1610, '\p{Canonical_Combining_Class=00000000027}', ""); +Expect(1, 1610, '\p{^Canonical_Combining_Class=00000000027}', ""); +Expect(1, 1610, '\P{Canonical_Combining_Class=00000000027}', ""); +Expect(0, 1610, '\P{^Canonical_Combining_Class=00000000027}', ""); +Error('\p{Ccc= -027/a/}'); +Error('\P{Ccc= -027/a/}'); +Expect(1, 1611, '\p{Ccc=+27}', ""); +Expect(0, 1611, '\p{^Ccc=+27}', ""); +Expect(0, 1611, '\P{Ccc=+27}', ""); +Expect(1, 1611, '\P{^Ccc=+27}', ""); +Expect(0, 1610, '\p{Ccc=+27}', ""); +Expect(1, 1610, '\p{^Ccc=+27}', ""); +Expect(1, 1610, '\P{Ccc=+27}', ""); +Expect(0, 1610, '\P{^Ccc=+27}', ""); +Error('\p{Is_Canonical_Combining_Class=:= +027}'); +Error('\P{Is_Canonical_Combining_Class=:= +027}'); +Expect(1, 1611, '\p{Is_Canonical_Combining_Class=00000000027}', ""); +Expect(0, 1611, '\p{^Is_Canonical_Combining_Class=00000000027}', ""); +Expect(0, 1611, '\P{Is_Canonical_Combining_Class=00000000027}', ""); +Expect(1, 1611, '\P{^Is_Canonical_Combining_Class=00000000027}', ""); +Expect(0, 1610, '\p{Is_Canonical_Combining_Class=00000000027}', ""); +Expect(1, 1610, '\p{^Is_Canonical_Combining_Class=00000000027}', ""); +Expect(1, 1610, '\P{Is_Canonical_Combining_Class=00000000027}', ""); +Expect(0, 1610, '\P{^Is_Canonical_Combining_Class=00000000027}', ""); +Error('\p{Is_Ccc:_:=000000027}'); +Error('\P{Is_Ccc:_:=000000027}'); +Expect(1, 1611, '\p{Is_Ccc=0_0_0_0_0027}', ""); +Expect(0, 1611, '\p{^Is_Ccc=0_0_0_0_0027}', ""); +Expect(0, 1611, '\P{Is_Ccc=0_0_0_0_0027}', ""); +Expect(1, 1611, '\P{^Is_Ccc=0_0_0_0_0027}', ""); +Expect(0, 1610, '\p{Is_Ccc=0_0_0_0_0027}', ""); +Expect(1, 1610, '\p{^Is_Ccc=0_0_0_0_0027}', ""); +Expect(1, 1610, '\P{Is_Ccc=0_0_0_0_0027}', ""); +Expect(0, 1610, '\P{^Is_Ccc=0_0_0_0_0027}', ""); +Error('\p{Canonical_Combining_Class= DOUBLE_Below/a/}'); +Error('\P{Canonical_Combining_Class= DOUBLE_Below/a/}'); +Expect(1, 860, '\p{Canonical_Combining_Class=doublebelow}', ""); +Expect(0, 860, '\p{^Canonical_Combining_Class=doublebelow}', ""); +Expect(0, 860, '\P{Canonical_Combining_Class=doublebelow}', ""); +Expect(1, 860, '\P{^Canonical_Combining_Class=doublebelow}', ""); +Expect(0, 859, '\p{Canonical_Combining_Class=doublebelow}', ""); +Expect(1, 859, '\p{^Canonical_Combining_Class=doublebelow}', ""); +Expect(1, 859, '\P{Canonical_Combining_Class=doublebelow}', ""); +Expect(0, 859, '\P{^Canonical_Combining_Class=doublebelow}', ""); +Expect(1, 860, '\p{Canonical_Combining_Class= double_Below}', ""); +Expect(0, 860, '\p{^Canonical_Combining_Class= double_Below}', ""); +Expect(0, 860, '\P{Canonical_Combining_Class= double_Below}', ""); +Expect(1, 860, '\P{^Canonical_Combining_Class= double_Below}', ""); +Expect(0, 859, '\p{Canonical_Combining_Class= double_Below}', ""); +Expect(1, 859, '\p{^Canonical_Combining_Class= double_Below}', ""); +Expect(1, 859, '\P{Canonical_Combining_Class= double_Below}', ""); +Expect(0, 859, '\P{^Canonical_Combining_Class= double_Below}', ""); +Error('\p{Ccc=_:=DB}'); +Error('\P{Ccc=_:=DB}'); +Expect(1, 860, '\p{Ccc=db}', ""); +Expect(0, 860, '\p{^Ccc=db}', ""); +Expect(0, 860, '\P{Ccc=db}', ""); +Expect(1, 860, '\P{^Ccc=db}', ""); +Expect(0, 859, '\p{Ccc=db}', ""); +Expect(1, 859, '\p{^Ccc=db}', ""); +Expect(1, 859, '\P{Ccc=db}', ""); +Expect(0, 859, '\P{^Ccc=db}', ""); +Expect(1, 860, '\p{Ccc= DB}', ""); +Expect(0, 860, '\p{^Ccc= DB}', ""); +Expect(0, 860, '\P{Ccc= DB}', ""); +Expect(1, 860, '\P{^Ccc= DB}', ""); +Expect(0, 859, '\p{Ccc= DB}', ""); +Expect(1, 859, '\p{^Ccc= DB}', ""); +Expect(1, 859, '\P{Ccc= DB}', ""); +Expect(0, 859, '\P{^Ccc= DB}', ""); +Error('\p{Is_Canonical_Combining_Class: +0-0_0 00-0-0/a/233}'); +Error('\P{Is_Canonical_Combining_Class: +0-0_0 00-0-0/a/233}'); +Expect(1, 860, '\p{Is_Canonical_Combining_Class=0000233}', ""); +Expect(0, 860, '\p{^Is_Canonical_Combining_Class=0000233}', ""); +Expect(0, 860, '\P{Is_Canonical_Combining_Class=0000233}', ""); +Expect(1, 860, '\P{^Is_Canonical_Combining_Class=0000233}', ""); +Expect(0, 859, '\p{Is_Canonical_Combining_Class=0000233}', ""); +Expect(1, 859, '\p{^Is_Canonical_Combining_Class=0000233}', ""); +Expect(1, 859, '\P{Is_Canonical_Combining_Class=0000233}', ""); +Expect(0, 859, '\P{^Is_Canonical_Combining_Class=0000233}', ""); +Error('\p{Is_Ccc=:=DOUBLE Below}'); +Error('\P{Is_Ccc=:=DOUBLE Below}'); +Expect(1, 860, '\p{Is_Ccc=doublebelow}', ""); +Expect(0, 860, '\p{^Is_Ccc=doublebelow}', ""); +Expect(0, 860, '\P{Is_Ccc=doublebelow}', ""); +Expect(1, 860, '\P{^Is_Ccc=doublebelow}', ""); +Expect(0, 859, '\p{Is_Ccc=doublebelow}', ""); +Expect(1, 859, '\p{^Is_Ccc=doublebelow}', ""); +Expect(1, 859, '\P{Is_Ccc=doublebelow}', ""); +Expect(0, 859, '\P{^Is_Ccc=doublebelow}', ""); +Expect(1, 860, '\p{Is_Ccc= _DOUBLE_below}', ""); +Expect(0, 860, '\p{^Is_Ccc= _DOUBLE_below}', ""); +Expect(0, 860, '\P{Is_Ccc= _DOUBLE_below}', ""); +Expect(1, 860, '\P{^Is_Ccc= _DOUBLE_below}', ""); +Expect(0, 859, '\p{Is_Ccc= _DOUBLE_below}', ""); +Expect(1, 859, '\p{^Is_Ccc= _DOUBLE_below}', ""); +Expect(1, 859, '\P{Is_Ccc= _DOUBLE_below}', ""); +Expect(0, 859, '\P{^Is_Ccc= _DOUBLE_below}', ""); +Error('\p{Canonical_Combining_Class= BELOW Right/a/}'); +Error('\P{Canonical_Combining_Class= BELOW Right/a/}'); +Expect(1, 1434, '\p{Canonical_Combining_Class=belowright}', ""); +Expect(0, 1434, '\p{^Canonical_Combining_Class=belowright}', ""); +Expect(0, 1434, '\P{Canonical_Combining_Class=belowright}', ""); +Expect(1, 1434, '\P{^Canonical_Combining_Class=belowright}', ""); +Expect(0, 1433, '\p{Canonical_Combining_Class=belowright}', ""); +Expect(1, 1433, '\p{^Canonical_Combining_Class=belowright}', ""); +Expect(1, 1433, '\P{Canonical_Combining_Class=belowright}', ""); +Expect(0, 1433, '\P{^Canonical_Combining_Class=belowright}', ""); +Expect(1, 1434, '\p{Canonical_Combining_Class= _Below Right}', ""); +Expect(0, 1434, '\p{^Canonical_Combining_Class= _Below Right}', ""); +Expect(0, 1434, '\P{Canonical_Combining_Class= _Below Right}', ""); +Expect(1, 1434, '\P{^Canonical_Combining_Class= _Below Right}', ""); +Expect(0, 1433, '\p{Canonical_Combining_Class= _Below Right}', ""); +Expect(1, 1433, '\p{^Canonical_Combining_Class= _Below Right}', ""); +Expect(1, 1433, '\P{Canonical_Combining_Class= _Below Right}', ""); +Expect(0, 1433, '\P{^Canonical_Combining_Class= _Below Right}', ""); +Error('\p{Ccc= /a/br}'); +Error('\P{Ccc= /a/br}'); +Expect(1, 1434, '\p{Ccc=br}', ""); +Expect(0, 1434, '\p{^Ccc=br}', ""); +Expect(0, 1434, '\P{Ccc=br}', ""); +Expect(1, 1434, '\P{^Ccc=br}', ""); +Expect(0, 1433, '\p{Ccc=br}', ""); +Expect(1, 1433, '\p{^Ccc=br}', ""); +Expect(1, 1433, '\P{Ccc=br}', ""); +Expect(0, 1433, '\P{^Ccc=br}', ""); +Expect(1, 1434, '\p{Ccc=-BR}', ""); +Expect(0, 1434, '\p{^Ccc=-BR}', ""); +Expect(0, 1434, '\P{Ccc=-BR}', ""); +Expect(1, 1434, '\P{^Ccc=-BR}', ""); +Expect(0, 1433, '\p{Ccc=-BR}', ""); +Expect(1, 1433, '\p{^Ccc=-BR}', ""); +Expect(1, 1433, '\P{Ccc=-BR}', ""); +Expect(0, 1433, '\P{^Ccc=-BR}', ""); +Error('\p{Is_Canonical_Combining_Class=:=__+000222}'); +Error('\P{Is_Canonical_Combining_Class=:=__+000222}'); +Expect(1, 1434, '\p{Is_Canonical_Combining_Class: 0_0_0_0_0_0_0_2_22}', ""); +Expect(0, 1434, '\p{^Is_Canonical_Combining_Class: 0_0_0_0_0_0_0_2_22}', ""); +Expect(0, 1434, '\P{Is_Canonical_Combining_Class: 0_0_0_0_0_0_0_2_22}', ""); +Expect(1, 1434, '\P{^Is_Canonical_Combining_Class: 0_0_0_0_0_0_0_2_22}', ""); +Expect(0, 1433, '\p{Is_Canonical_Combining_Class: 0_0_0_0_0_0_0_2_22}', ""); +Expect(1, 1433, '\p{^Is_Canonical_Combining_Class: 0_0_0_0_0_0_0_2_22}', ""); +Expect(1, 1433, '\P{Is_Canonical_Combining_Class: 0_0_0_0_0_0_0_2_22}', ""); +Expect(0, 1433, '\P{^Is_Canonical_Combining_Class: 0_0_0_0_0_0_0_2_22}', ""); +Error('\p{Is_Ccc=/a/_ Below-Right}'); +Error('\P{Is_Ccc=/a/_ Below-Right}'); +Expect(1, 1434, '\p{Is_Ccc=belowright}', ""); +Expect(0, 1434, '\p{^Is_Ccc=belowright}', ""); +Expect(0, 1434, '\P{Is_Ccc=belowright}', ""); +Expect(1, 1434, '\P{^Is_Ccc=belowright}', ""); +Expect(0, 1433, '\p{Is_Ccc=belowright}', ""); +Expect(1, 1433, '\p{^Is_Ccc=belowright}', ""); +Expect(1, 1433, '\P{Is_Ccc=belowright}', ""); +Expect(0, 1433, '\P{^Is_Ccc=belowright}', ""); +Expect(1, 1434, '\p{Is_Ccc= -Below Right}', ""); +Expect(0, 1434, '\p{^Is_Ccc= -Below Right}', ""); +Expect(0, 1434, '\P{Is_Ccc= -Below Right}', ""); +Expect(1, 1434, '\P{^Is_Ccc= -Below Right}', ""); +Expect(0, 1433, '\p{Is_Ccc= -Below Right}', ""); +Expect(1, 1433, '\p{^Is_Ccc= -Below Right}', ""); +Expect(1, 1433, '\P{Is_Ccc= -Below Right}', ""); +Expect(0, 1433, '\P{^Is_Ccc= -Below Right}', ""); +Error('\p{Canonical_Combining_Class=- kana_VOICING:=}'); +Error('\P{Canonical_Combining_Class=- kana_VOICING:=}'); +Expect(1, 12442, '\p{Canonical_Combining_Class=kanavoicing}', ""); +Expect(0, 12442, '\p{^Canonical_Combining_Class=kanavoicing}', ""); +Expect(0, 12442, '\P{Canonical_Combining_Class=kanavoicing}', ""); +Expect(1, 12442, '\P{^Canonical_Combining_Class=kanavoicing}', ""); +Expect(0, 12440, '\p{Canonical_Combining_Class=kanavoicing}', ""); +Expect(1, 12440, '\p{^Canonical_Combining_Class=kanavoicing}', ""); +Expect(1, 12440, '\P{Canonical_Combining_Class=kanavoicing}', ""); +Expect(0, 12440, '\P{^Canonical_Combining_Class=kanavoicing}', ""); +Expect(1, 12442, '\p{Canonical_Combining_Class= -Kana_Voicing}', ""); +Expect(0, 12442, '\p{^Canonical_Combining_Class= -Kana_Voicing}', ""); +Expect(0, 12442, '\P{Canonical_Combining_Class= -Kana_Voicing}', ""); +Expect(1, 12442, '\P{^Canonical_Combining_Class= -Kana_Voicing}', ""); +Expect(0, 12440, '\p{Canonical_Combining_Class= -Kana_Voicing}', ""); +Expect(1, 12440, '\p{^Canonical_Combining_Class= -Kana_Voicing}', ""); +Expect(1, 12440, '\P{Canonical_Combining_Class= -Kana_Voicing}', ""); +Expect(0, 12440, '\P{^Canonical_Combining_Class= -Kana_Voicing}', ""); +Error('\p{Ccc=/a/_ KV}'); +Error('\P{Ccc=/a/_ KV}'); +Expect(1, 12442, '\p{Ccc=kv}', ""); +Expect(0, 12442, '\p{^Ccc=kv}', ""); +Expect(0, 12442, '\P{Ccc=kv}', ""); +Expect(1, 12442, '\P{^Ccc=kv}', ""); +Expect(0, 12440, '\p{Ccc=kv}', ""); +Expect(1, 12440, '\p{^Ccc=kv}', ""); +Expect(1, 12440, '\P{Ccc=kv}', ""); +Expect(0, 12440, '\P{^Ccc=kv}', ""); +Expect(1, 12442, '\p{Ccc=--KV}', ""); +Expect(0, 12442, '\p{^Ccc=--KV}', ""); +Expect(0, 12442, '\P{Ccc=--KV}', ""); +Expect(1, 12442, '\P{^Ccc=--KV}', ""); +Expect(0, 12440, '\p{Ccc=--KV}', ""); +Expect(1, 12440, '\p{^Ccc=--KV}', ""); +Expect(1, 12440, '\P{Ccc=--KV}', ""); +Expect(0, 12440, '\P{^Ccc=--KV}', ""); +Error('\p{Is_Canonical_Combining_Class=:=-000000008}'); +Error('\P{Is_Canonical_Combining_Class=:=-000000008}'); +Expect(1, 12442, '\p{Is_Canonical_Combining_Class=0_8}', ""); +Expect(0, 12442, '\p{^Is_Canonical_Combining_Class=0_8}', ""); +Expect(0, 12442, '\P{Is_Canonical_Combining_Class=0_8}', ""); +Expect(1, 12442, '\P{^Is_Canonical_Combining_Class=0_8}', ""); +Expect(0, 12440, '\p{Is_Canonical_Combining_Class=0_8}', ""); +Expect(1, 12440, '\p{^Is_Canonical_Combining_Class=0_8}', ""); +Expect(1, 12440, '\P{Is_Canonical_Combining_Class=0_8}', ""); +Expect(0, 12440, '\P{^Is_Canonical_Combining_Class=0_8}', ""); +Error('\p{Is_Ccc: _/a/KANAVoicing}'); +Error('\P{Is_Ccc: _/a/KANAVoicing}'); +Expect(1, 12442, '\p{Is_Ccc=kanavoicing}', ""); +Expect(0, 12442, '\p{^Is_Ccc=kanavoicing}', ""); +Expect(0, 12442, '\P{Is_Ccc=kanavoicing}', ""); +Expect(1, 12442, '\P{^Is_Ccc=kanavoicing}', ""); +Expect(0, 12440, '\p{Is_Ccc=kanavoicing}', ""); +Expect(1, 12440, '\p{^Is_Ccc=kanavoicing}', ""); +Expect(1, 12440, '\P{Is_Ccc=kanavoicing}', ""); +Expect(0, 12440, '\P{^Is_Ccc=kanavoicing}', ""); +Expect(1, 12442, '\p{Is_Ccc=_ KANAVoicing}', ""); +Expect(0, 12442, '\p{^Is_Ccc=_ KANAVoicing}', ""); +Expect(0, 12442, '\P{Is_Ccc=_ KANAVoicing}', ""); +Expect(1, 12442, '\P{^Is_Ccc=_ KANAVoicing}', ""); +Expect(0, 12440, '\p{Is_Ccc=_ KANAVoicing}', ""); +Expect(1, 12440, '\p{^Is_Ccc=_ KANAVoicing}', ""); +Expect(1, 12440, '\P{Is_Ccc=_ KANAVoicing}', ""); +Expect(0, 12440, '\P{^Is_Ccc=_ KANAVoicing}', ""); +Error('\p{Canonical_Combining_Class=--Below/a/}'); +Error('\P{Canonical_Combining_Class=--Below/a/}'); +Expect(1, 793, '\p{Canonical_Combining_Class=below}', ""); +Expect(0, 793, '\p{^Canonical_Combining_Class=below}', ""); +Expect(0, 793, '\P{Canonical_Combining_Class=below}', ""); +Expect(1, 793, '\P{^Canonical_Combining_Class=below}', ""); +Expect(0, 789, '\p{Canonical_Combining_Class=below}', ""); +Expect(1, 789, '\p{^Canonical_Combining_Class=below}', ""); +Expect(1, 789, '\P{Canonical_Combining_Class=below}', ""); +Expect(0, 789, '\P{^Canonical_Combining_Class=below}', ""); +Expect(1, 793, '\p{Canonical_Combining_Class=- Below}', ""); +Expect(0, 793, '\p{^Canonical_Combining_Class=- Below}', ""); +Expect(0, 793, '\P{Canonical_Combining_Class=- Below}', ""); +Expect(1, 793, '\P{^Canonical_Combining_Class=- Below}', ""); +Expect(0, 789, '\p{Canonical_Combining_Class=- Below}', ""); +Expect(1, 789, '\p{^Canonical_Combining_Class=- Below}', ""); +Expect(1, 789, '\P{Canonical_Combining_Class=- Below}', ""); +Expect(0, 789, '\P{^Canonical_Combining_Class=- Below}', ""); +Error('\p{Ccc=-B:=}'); +Error('\P{Ccc=-B:=}'); +Expect(1, 793, '\p{Ccc: b}', ""); +Expect(0, 793, '\p{^Ccc: b}', ""); +Expect(0, 793, '\P{Ccc: b}', ""); +Expect(1, 793, '\P{^Ccc: b}', ""); +Expect(0, 789, '\p{Ccc: b}', ""); +Expect(1, 789, '\p{^Ccc: b}', ""); +Expect(1, 789, '\P{Ccc: b}', ""); +Expect(0, 789, '\P{^Ccc: b}', ""); +Expect(1, 793, '\p{Ccc= b}', ""); +Expect(0, 793, '\p{^Ccc= b}', ""); +Expect(0, 793, '\P{Ccc= b}', ""); +Expect(1, 793, '\P{^Ccc= b}', ""); +Expect(0, 789, '\p{Ccc= b}', ""); +Expect(1, 789, '\p{^Ccc= b}', ""); +Expect(1, 789, '\P{Ccc= b}', ""); +Expect(0, 789, '\P{^Ccc= b}', ""); +Error('\p{Is_Canonical_Combining_Class=-:=+000 2 20}'); +Error('\P{Is_Canonical_Combining_Class=-:=+000 2 20}'); +Expect(1, 793, '\p{Is_Canonical_Combining_Class=+220}', ""); +Expect(0, 793, '\p{^Is_Canonical_Combining_Class=+220}', ""); +Expect(0, 793, '\P{Is_Canonical_Combining_Class=+220}', ""); +Expect(1, 793, '\P{^Is_Canonical_Combining_Class=+220}', ""); +Expect(0, 789, '\p{Is_Canonical_Combining_Class=+220}', ""); +Expect(1, 789, '\p{^Is_Canonical_Combining_Class=+220}', ""); +Expect(1, 789, '\P{Is_Canonical_Combining_Class=+220}', ""); +Expect(0, 789, '\P{^Is_Canonical_Combining_Class=+220}', ""); +Error('\p{Is_Ccc= /a/BELOW}'); +Error('\P{Is_Ccc= /a/BELOW}'); +Expect(1, 793, '\p{Is_Ccc=below}', ""); +Expect(0, 793, '\p{^Is_Ccc=below}', ""); +Expect(0, 793, '\P{Is_Ccc=below}', ""); +Expect(1, 793, '\P{^Is_Ccc=below}', ""); +Expect(0, 789, '\p{Is_Ccc=below}', ""); +Expect(1, 789, '\p{^Is_Ccc=below}', ""); +Expect(1, 789, '\P{Is_Ccc=below}', ""); +Expect(0, 789, '\P{^Is_Ccc=below}', ""); +Expect(1, 793, '\p{Is_Ccc= Below}', ""); +Expect(0, 793, '\p{^Is_Ccc= Below}', ""); +Expect(0, 793, '\P{Is_Ccc= Below}', ""); +Expect(1, 793, '\P{^Is_Ccc= Below}', ""); +Expect(0, 789, '\p{Is_Ccc= Below}', ""); +Expect(1, 789, '\p{^Is_Ccc= Below}', ""); +Expect(1, 789, '\P{Is_Ccc= Below}', ""); +Expect(0, 789, '\P{^Is_Ccc= Below}', ""); +Error('\p{Canonical_Combining_Class: _-+0000002 0:=}'); +Error('\P{Canonical_Combining_Class: _-+0000002 0:=}'); +Expect(1, 1467, '\p{Canonical_Combining_Class: +0000020}', ""); +Expect(0, 1467, '\p{^Canonical_Combining_Class: +0000020}', ""); +Expect(0, 1467, '\P{Canonical_Combining_Class: +0000020}', ""); +Expect(1, 1467, '\P{^Canonical_Combining_Class: +0000020}', ""); +Expect(0, 1466, '\p{Canonical_Combining_Class: +0000020}', ""); +Expect(1, 1466, '\p{^Canonical_Combining_Class: +0000020}', ""); +Expect(1, 1466, '\P{Canonical_Combining_Class: +0000020}', ""); +Expect(0, 1466, '\P{^Canonical_Combining_Class: +0000020}', ""); +Error('\p{Ccc=:= -0 0-20}'); +Error('\P{Ccc=:= -0 0-20}'); +Expect(1, 1467, '\p{Ccc=0_0_0_0_0_0_0_0_20}', ""); +Expect(0, 1467, '\p{^Ccc=0_0_0_0_0_0_0_0_20}', ""); +Expect(0, 1467, '\P{Ccc=0_0_0_0_0_0_0_0_20}', ""); +Expect(1, 1467, '\P{^Ccc=0_0_0_0_0_0_0_0_20}', ""); +Expect(0, 1466, '\p{Ccc=0_0_0_0_0_0_0_0_20}', ""); +Expect(1, 1466, '\p{^Ccc=0_0_0_0_0_0_0_0_20}', ""); +Expect(1, 1466, '\P{Ccc=0_0_0_0_0_0_0_0_20}', ""); +Expect(0, 1466, '\P{^Ccc=0_0_0_0_0_0_0_0_20}', ""); +Error('\p{Is_Canonical_Combining_Class=-0020:=}'); +Error('\P{Is_Canonical_Combining_Class=-0020:=}'); +Expect(1, 1467, '\p{Is_Canonical_Combining_Class=+0_0_0_20}', ""); +Expect(0, 1467, '\p{^Is_Canonical_Combining_Class=+0_0_0_20}', ""); +Expect(0, 1467, '\P{Is_Canonical_Combining_Class=+0_0_0_20}', ""); +Expect(1, 1467, '\P{^Is_Canonical_Combining_Class=+0_0_0_20}', ""); +Expect(0, 1466, '\p{Is_Canonical_Combining_Class=+0_0_0_20}', ""); +Expect(1, 1466, '\p{^Is_Canonical_Combining_Class=+0_0_0_20}', ""); +Expect(1, 1466, '\P{Is_Canonical_Combining_Class=+0_0_0_20}', ""); +Expect(0, 1466, '\P{^Is_Canonical_Combining_Class=+0_0_0_20}', ""); +Error('\p{Is_Ccc=:= 20}'); +Error('\P{Is_Ccc=:= 20}'); +Expect(1, 1467, '\p{Is_Ccc=0_0_20}', ""); +Expect(0, 1467, '\p{^Is_Ccc=0_0_20}', ""); +Expect(0, 1467, '\P{Is_Ccc=0_0_20}', ""); +Expect(1, 1467, '\P{^Is_Ccc=0_0_20}', ""); +Expect(0, 1466, '\p{Is_Ccc=0_0_20}', ""); +Expect(1, 1466, '\p{^Is_Ccc=0_0_20}', ""); +Expect(1, 1466, '\P{Is_Ccc=0_0_20}', ""); +Expect(0, 1466, '\P{^Is_Ccc=0_0_20}', ""); +Error('\p{Canonical_Combining_Class= Attached_Above:=right}'); +Error('\P{Canonical_Combining_Class= Attached_Above:=right}'); +Expect(1, 795, '\p{Canonical_Combining_Class=attachedaboveright}', ""); +Expect(0, 795, '\p{^Canonical_Combining_Class=attachedaboveright}', ""); +Expect(0, 795, '\P{Canonical_Combining_Class=attachedaboveright}', ""); +Expect(1, 795, '\P{^Canonical_Combining_Class=attachedaboveright}', ""); +Expect(0, 794, '\p{Canonical_Combining_Class=attachedaboveright}', ""); +Expect(1, 794, '\p{^Canonical_Combining_Class=attachedaboveright}', ""); +Expect(1, 794, '\P{Canonical_Combining_Class=attachedaboveright}', ""); +Expect(0, 794, '\P{^Canonical_Combining_Class=attachedaboveright}', ""); +Expect(1, 795, '\p{Canonical_Combining_Class= Attached-Above_right}', ""); +Expect(0, 795, '\p{^Canonical_Combining_Class= Attached-Above_right}', ""); +Expect(0, 795, '\P{Canonical_Combining_Class= Attached-Above_right}', ""); +Expect(1, 795, '\P{^Canonical_Combining_Class= Attached-Above_right}', ""); +Expect(0, 794, '\p{Canonical_Combining_Class= Attached-Above_right}', ""); +Expect(1, 794, '\p{^Canonical_Combining_Class= Attached-Above_right}', ""); +Expect(1, 794, '\P{Canonical_Combining_Class= Attached-Above_right}', ""); +Expect(0, 794, '\P{^Canonical_Combining_Class= Attached-Above_right}', ""); +Error('\p{Ccc=:=_atar}'); +Error('\P{Ccc=:=_atar}'); +Expect(1, 795, '\p{Ccc: atar}', ""); +Expect(0, 795, '\p{^Ccc: atar}', ""); +Expect(0, 795, '\P{Ccc: atar}', ""); +Expect(1, 795, '\P{^Ccc: atar}', ""); +Expect(0, 794, '\p{Ccc: atar}', ""); +Expect(1, 794, '\p{^Ccc: atar}', ""); +Expect(1, 794, '\P{Ccc: atar}', ""); +Expect(0, 794, '\P{^Ccc: atar}', ""); +Expect(1, 795, '\p{Ccc: ATAR}', ""); +Expect(0, 795, '\p{^Ccc: ATAR}', ""); +Expect(0, 795, '\P{Ccc: ATAR}', ""); +Expect(1, 795, '\P{^Ccc: ATAR}', ""); +Expect(0, 794, '\p{Ccc: ATAR}', ""); +Expect(1, 794, '\p{^Ccc: ATAR}', ""); +Expect(1, 794, '\P{Ccc: ATAR}', ""); +Expect(0, 794, '\P{^Ccc: ATAR}', ""); +Error('\p{Is_Canonical_Combining_Class= :=+216}'); +Error('\P{Is_Canonical_Combining_Class= :=+216}'); +Expect(1, 795, '\p{Is_Canonical_Combining_Class=000021_6}', ""); +Expect(0, 795, '\p{^Is_Canonical_Combining_Class=000021_6}', ""); +Expect(0, 795, '\P{Is_Canonical_Combining_Class=000021_6}', ""); +Expect(1, 795, '\P{^Is_Canonical_Combining_Class=000021_6}', ""); +Expect(0, 794, '\p{Is_Canonical_Combining_Class=000021_6}', ""); +Expect(1, 794, '\p{^Is_Canonical_Combining_Class=000021_6}', ""); +Expect(1, 794, '\P{Is_Canonical_Combining_Class=000021_6}', ""); +Expect(0, 794, '\P{^Is_Canonical_Combining_Class=000021_6}', ""); +Error('\p{Is_Ccc= Attached_Above:=Right}'); +Error('\P{Is_Ccc= Attached_Above:=Right}'); +Expect(1, 795, '\p{Is_Ccc=attachedaboveright}', ""); +Expect(0, 795, '\p{^Is_Ccc=attachedaboveright}', ""); +Expect(0, 795, '\P{Is_Ccc=attachedaboveright}', ""); +Expect(1, 795, '\P{^Is_Ccc=attachedaboveright}', ""); +Expect(0, 794, '\p{Is_Ccc=attachedaboveright}', ""); +Expect(1, 794, '\p{^Is_Ccc=attachedaboveright}', ""); +Expect(1, 794, '\P{Is_Ccc=attachedaboveright}', ""); +Expect(0, 794, '\P{^Is_Ccc=attachedaboveright}', ""); +Expect(1, 795, '\p{Is_Ccc= Attached-Above-right}', ""); +Expect(0, 795, '\p{^Is_Ccc= Attached-Above-right}', ""); +Expect(0, 795, '\P{Is_Ccc= Attached-Above-right}', ""); +Expect(1, 795, '\P{^Is_Ccc= Attached-Above-right}', ""); +Expect(0, 794, '\p{Is_Ccc= Attached-Above-right}', ""); +Expect(1, 794, '\p{^Is_Ccc= Attached-Above-right}', ""); +Expect(1, 794, '\P{Is_Ccc= Attached-Above-right}', ""); +Expect(0, 794, '\P{^Is_Ccc= Attached-Above-right}', ""); +Error('\p{Canonical_Combining_Class= 3 1:=}'); +Error('\P{Canonical_Combining_Class= 3 1:=}'); +Expect(1, 1561, '\p{Canonical_Combining_Class=3_1}', ""); +Expect(0, 1561, '\p{^Canonical_Combining_Class=3_1}', ""); +Expect(0, 1561, '\P{Canonical_Combining_Class=3_1}', ""); +Expect(1, 1561, '\P{^Canonical_Combining_Class=3_1}', ""); +Expect(0, 1560, '\p{Canonical_Combining_Class=3_1}', ""); +Expect(1, 1560, '\p{^Canonical_Combining_Class=3_1}', ""); +Expect(1, 1560, '\P{Canonical_Combining_Class=3_1}', ""); +Expect(0, 1560, '\P{^Canonical_Combining_Class=3_1}', ""); +Error('\p{Ccc= :=0031}'); +Error('\P{Ccc= :=0031}'); +Expect(1, 1561, '\p{Ccc=0_0_0_0_0_0_0031}', ""); +Expect(0, 1561, '\p{^Ccc=0_0_0_0_0_0_0031}', ""); +Expect(0, 1561, '\P{Ccc=0_0_0_0_0_0_0031}', ""); +Expect(1, 1561, '\P{^Ccc=0_0_0_0_0_0_0031}', ""); +Expect(0, 1560, '\p{Ccc=0_0_0_0_0_0_0031}', ""); +Expect(1, 1560, '\p{^Ccc=0_0_0_0_0_0_0031}', ""); +Expect(1, 1560, '\P{Ccc=0_0_0_0_0_0_0031}', ""); +Expect(0, 1560, '\P{^Ccc=0_0_0_0_0_0_0031}', ""); +Error('\p{Is_Canonical_Combining_Class= :=+00-31}'); +Error('\P{Is_Canonical_Combining_Class= :=+00-31}'); +Expect(1, 1561, '\p{Is_Canonical_Combining_Class: 0031}', ""); +Expect(0, 1561, '\p{^Is_Canonical_Combining_Class: 0031}', ""); +Expect(0, 1561, '\P{Is_Canonical_Combining_Class: 0031}', ""); +Expect(1, 1561, '\P{^Is_Canonical_Combining_Class: 0031}', ""); +Expect(0, 1560, '\p{Is_Canonical_Combining_Class: 0031}', ""); +Expect(1, 1560, '\p{^Is_Canonical_Combining_Class: 0031}', ""); +Expect(1, 1560, '\P{Is_Canonical_Combining_Class: 0031}', ""); +Expect(0, 1560, '\P{^Is_Canonical_Combining_Class: 0031}', ""); +Error('\p{Is_Ccc=_ +00_00 31:=}'); +Error('\P{Is_Ccc=_ +00_00 31:=}'); +Expect(1, 1561, '\p{Is_Ccc=000_003_1}', ""); +Expect(0, 1561, '\p{^Is_Ccc=000_003_1}', ""); +Expect(0, 1561, '\P{Is_Ccc=000_003_1}', ""); +Expect(1, 1561, '\P{^Is_Ccc=000_003_1}', ""); +Expect(0, 1560, '\p{Is_Ccc=000_003_1}', ""); +Expect(1, 1560, '\p{^Is_Ccc=000_003_1}', ""); +Expect(1, 1560, '\P{Is_Ccc=000_003_1}', ""); +Expect(0, 1560, '\P{^Is_Ccc=000_003_1}', ""); +Error('\p{Canonical_Combining_Class=/a/- +000035}'); +Error('\P{Canonical_Combining_Class=/a/- +000035}'); +Expect(1, 1648, '\p{Canonical_Combining_Class=0000000035}', ""); +Expect(0, 1648, '\p{^Canonical_Combining_Class=0000000035}', ""); +Expect(0, 1648, '\P{Canonical_Combining_Class=0000000035}', ""); +Expect(1, 1648, '\P{^Canonical_Combining_Class=0000000035}', ""); +Expect(0, 1647, '\p{Canonical_Combining_Class=0000000035}', ""); +Expect(1, 1647, '\p{^Canonical_Combining_Class=0000000035}', ""); +Expect(1, 1647, '\P{Canonical_Combining_Class=0000000035}', ""); +Expect(0, 1647, '\P{^Canonical_Combining_Class=0000000035}', ""); +Error('\p{Ccc=-_0 0:=035}'); +Error('\P{Ccc=-_0 0:=035}'); +Expect(1, 1648, '\p{Ccc=+035}', ""); +Expect(0, 1648, '\p{^Ccc=+035}', ""); +Expect(0, 1648, '\P{Ccc=+035}', ""); +Expect(1, 1648, '\P{^Ccc=+035}', ""); +Expect(0, 1647, '\p{Ccc=+035}', ""); +Expect(1, 1647, '\p{^Ccc=+035}', ""); +Expect(1, 1647, '\P{Ccc=+035}', ""); +Expect(0, 1647, '\P{^Ccc=+035}', ""); +Error('\p{Is_Canonical_Combining_Class=-:=00000_00003 5}'); +Error('\P{Is_Canonical_Combining_Class=-:=00000_00003 5}'); +Expect(1, 1648, '\p{Is_Canonical_Combining_Class=00_00_00_00_35}', ""); +Expect(0, 1648, '\p{^Is_Canonical_Combining_Class=00_00_00_00_35}', ""); +Expect(0, 1648, '\P{Is_Canonical_Combining_Class=00_00_00_00_35}', ""); +Expect(1, 1648, '\P{^Is_Canonical_Combining_Class=00_00_00_00_35}', ""); +Expect(0, 1647, '\p{Is_Canonical_Combining_Class=00_00_00_00_35}', ""); +Expect(1, 1647, '\p{^Is_Canonical_Combining_Class=00_00_00_00_35}', ""); +Expect(1, 1647, '\P{Is_Canonical_Combining_Class=00_00_00_00_35}', ""); +Expect(0, 1647, '\P{^Is_Canonical_Combining_Class=00_00_00_00_35}', ""); +Error('\p{Is_Ccc= 0 0/a/0-0_0 0_0_0035}'); +Error('\P{Is_Ccc= 0 0/a/0-0_0 0_0_0035}'); +Expect(1, 1648, '\p{Is_Ccc: 3_5}', ""); +Expect(0, 1648, '\p{^Is_Ccc: 3_5}', ""); +Expect(0, 1648, '\P{Is_Ccc: 3_5}', ""); +Expect(1, 1648, '\P{^Is_Ccc: 3_5}', ""); +Expect(0, 1647, '\p{Is_Ccc: 3_5}', ""); +Expect(1, 1647, '\p{^Is_Ccc: 3_5}', ""); +Expect(1, 1647, '\P{Is_Ccc: 3_5}', ""); +Expect(0, 1647, '\P{^Is_Ccc: 3_5}', ""); +Error('\p{Canonical_Combining_Class= 00011:=}'); +Error('\P{Canonical_Combining_Class= 00011:=}'); +Expect(1, 1457, '\p{Canonical_Combining_Class: 0_0_0_0_11}', ""); +Expect(0, 1457, '\p{^Canonical_Combining_Class: 0_0_0_0_11}', ""); +Expect(0, 1457, '\P{Canonical_Combining_Class: 0_0_0_0_11}', ""); +Expect(1, 1457, '\P{^Canonical_Combining_Class: 0_0_0_0_11}', ""); +Expect(0, 1456, '\p{Canonical_Combining_Class: 0_0_0_0_11}', ""); +Expect(1, 1456, '\p{^Canonical_Combining_Class: 0_0_0_0_11}', ""); +Expect(1, 1456, '\P{Canonical_Combining_Class: 0_0_0_0_11}', ""); +Expect(0, 1456, '\P{^Canonical_Combining_Class: 0_0_0_0_11}', ""); +Error('\p{Ccc=_/a/0011}'); +Error('\P{Ccc=_/a/0011}'); +Expect(1, 1457, '\p{Ccc=000011}', ""); +Expect(0, 1457, '\p{^Ccc=000011}', ""); +Expect(0, 1457, '\P{Ccc=000011}', ""); +Expect(1, 1457, '\P{^Ccc=000011}', ""); +Expect(0, 1456, '\p{Ccc=000011}', ""); +Expect(1, 1456, '\p{^Ccc=000011}', ""); +Expect(1, 1456, '\P{Ccc=000011}', ""); +Expect(0, 1456, '\P{^Ccc=000011}', ""); +Error('\p{Is_Canonical_Combining_Class=/a/0-0 11}'); +Error('\P{Is_Canonical_Combining_Class=/a/0-0 11}'); +Expect(1, 1457, '\p{Is_Canonical_Combining_Class=+00_00_00_011}', ""); +Expect(0, 1457, '\p{^Is_Canonical_Combining_Class=+00_00_00_011}', ""); +Expect(0, 1457, '\P{Is_Canonical_Combining_Class=+00_00_00_011}', ""); +Expect(1, 1457, '\P{^Is_Canonical_Combining_Class=+00_00_00_011}', ""); +Expect(0, 1456, '\p{Is_Canonical_Combining_Class=+00_00_00_011}', ""); +Expect(1, 1456, '\p{^Is_Canonical_Combining_Class=+00_00_00_011}', ""); +Expect(1, 1456, '\P{Is_Canonical_Combining_Class=+00_00_00_011}', ""); +Expect(0, 1456, '\P{^Is_Canonical_Combining_Class=+00_00_00_011}', ""); +Error('\p{Is_Ccc: :=_-0000000011}'); +Error('\P{Is_Ccc: :=_-0000000011}'); +Expect(1, 1457, '\p{Is_Ccc=000001_1}', ""); +Expect(0, 1457, '\p{^Is_Ccc=000001_1}', ""); +Expect(0, 1457, '\P{Is_Ccc=000001_1}', ""); +Expect(1, 1457, '\P{^Is_Ccc=000001_1}', ""); +Expect(0, 1456, '\p{Is_Ccc=000001_1}', ""); +Expect(1, 1456, '\p{^Is_Ccc=000001_1}', ""); +Expect(1, 1456, '\P{Is_Ccc=000001_1}', ""); +Expect(0, 1456, '\P{^Is_Ccc=000001_1}', ""); +Error('\p{Canonical_Combining_Class=:= _Iota-Subscript}'); +Error('\P{Canonical_Combining_Class=:= _Iota-Subscript}'); +Expect(1, 837, '\p{Canonical_Combining_Class=iotasubscript}', ""); +Expect(0, 837, '\p{^Canonical_Combining_Class=iotasubscript}', ""); +Expect(0, 837, '\P{Canonical_Combining_Class=iotasubscript}', ""); +Expect(1, 837, '\P{^Canonical_Combining_Class=iotasubscript}', ""); +Expect(0, 836, '\p{Canonical_Combining_Class=iotasubscript}', ""); +Expect(1, 836, '\p{^Canonical_Combining_Class=iotasubscript}', ""); +Expect(1, 836, '\P{Canonical_Combining_Class=iotasubscript}', ""); +Expect(0, 836, '\P{^Canonical_Combining_Class=iotasubscript}', ""); +Expect(1, 837, '\p{Canonical_Combining_Class=- Iota Subscript}', ""); +Expect(0, 837, '\p{^Canonical_Combining_Class=- Iota Subscript}', ""); +Expect(0, 837, '\P{Canonical_Combining_Class=- Iota Subscript}', ""); +Expect(1, 837, '\P{^Canonical_Combining_Class=- Iota Subscript}', ""); +Expect(0, 836, '\p{Canonical_Combining_Class=- Iota Subscript}', ""); +Expect(1, 836, '\p{^Canonical_Combining_Class=- Iota Subscript}', ""); +Expect(1, 836, '\P{Canonical_Combining_Class=- Iota Subscript}', ""); +Expect(0, 836, '\P{^Canonical_Combining_Class=- Iota Subscript}', ""); +Error('\p{Ccc=-/a/IS}'); +Error('\P{Ccc=-/a/IS}'); +Expect(1, 837, '\p{Ccc=is}', ""); +Expect(0, 837, '\p{^Ccc=is}', ""); +Expect(0, 837, '\P{Ccc=is}', ""); +Expect(1, 837, '\P{^Ccc=is}', ""); +Expect(0, 836, '\p{Ccc=is}', ""); +Expect(1, 836, '\p{^Ccc=is}', ""); +Expect(1, 836, '\P{Ccc=is}', ""); +Expect(0, 836, '\P{^Ccc=is}', ""); +Expect(1, 837, '\p{Ccc:-_is}', ""); +Expect(0, 837, '\p{^Ccc:-_is}', ""); +Expect(0, 837, '\P{Ccc:-_is}', ""); +Expect(1, 837, '\P{^Ccc:-_is}', ""); +Expect(0, 836, '\p{Ccc:-_is}', ""); +Expect(1, 836, '\p{^Ccc:-_is}', ""); +Expect(1, 836, '\P{Ccc:-_is}', ""); +Expect(0, 836, '\P{^Ccc:-_is}', ""); +Error('\p{Is_Canonical_Combining_Class= +0240:=}'); +Error('\P{Is_Canonical_Combining_Class= +0240:=}'); +Expect(1, 837, '\p{Is_Canonical_Combining_Class=24_0}', ""); +Expect(0, 837, '\p{^Is_Canonical_Combining_Class=24_0}', ""); +Expect(0, 837, '\P{Is_Canonical_Combining_Class=24_0}', ""); +Expect(1, 837, '\P{^Is_Canonical_Combining_Class=24_0}', ""); +Expect(0, 836, '\p{Is_Canonical_Combining_Class=24_0}', ""); +Expect(1, 836, '\p{^Is_Canonical_Combining_Class=24_0}', ""); +Expect(1, 836, '\P{Is_Canonical_Combining_Class=24_0}', ""); +Expect(0, 836, '\P{^Is_Canonical_Combining_Class=24_0}', ""); +Error('\p{Is_Ccc=-IOTA subscript/a/}'); +Error('\P{Is_Ccc=-IOTA subscript/a/}'); +Expect(1, 837, '\p{Is_Ccc=iotasubscript}', ""); +Expect(0, 837, '\p{^Is_Ccc=iotasubscript}', ""); +Expect(0, 837, '\P{Is_Ccc=iotasubscript}', ""); +Expect(1, 837, '\P{^Is_Ccc=iotasubscript}', ""); +Expect(0, 836, '\p{Is_Ccc=iotasubscript}', ""); +Expect(1, 836, '\p{^Is_Ccc=iotasubscript}', ""); +Expect(1, 836, '\P{Is_Ccc=iotasubscript}', ""); +Expect(0, 836, '\P{^Is_Ccc=iotasubscript}', ""); +Expect(1, 837, '\p{Is_Ccc=- Iota Subscript}', ""); +Expect(0, 837, '\p{^Is_Ccc=- Iota Subscript}', ""); +Expect(0, 837, '\P{Is_Ccc=- Iota Subscript}', ""); +Expect(1, 837, '\P{^Is_Ccc=- Iota Subscript}', ""); +Expect(0, 836, '\p{Is_Ccc=- Iota Subscript}', ""); +Expect(1, 836, '\p{^Is_Ccc=- Iota Subscript}', ""); +Expect(1, 836, '\P{Is_Ccc=- Iota Subscript}', ""); +Expect(0, 836, '\P{^Is_Ccc=- Iota Subscript}', ""); +Error('\p{Canonical_Combining_Class=/a/Aboveright}'); +Error('\P{Canonical_Combining_Class=/a/Aboveright}'); +Expect(1, 789, '\p{Canonical_Combining_Class=aboveright}', ""); +Expect(0, 789, '\p{^Canonical_Combining_Class=aboveright}', ""); +Expect(0, 789, '\P{Canonical_Combining_Class=aboveright}', ""); +Expect(1, 789, '\P{^Canonical_Combining_Class=aboveright}', ""); +Expect(0, 788, '\p{Canonical_Combining_Class=aboveright}', ""); +Expect(1, 788, '\p{^Canonical_Combining_Class=aboveright}', ""); +Expect(1, 788, '\P{Canonical_Combining_Class=aboveright}', ""); +Expect(0, 788, '\P{^Canonical_Combining_Class=aboveright}', ""); +Expect(1, 789, '\p{Canonical_Combining_Class= above_Right}', ""); +Expect(0, 789, '\p{^Canonical_Combining_Class= above_Right}', ""); +Expect(0, 789, '\P{Canonical_Combining_Class= above_Right}', ""); +Expect(1, 789, '\P{^Canonical_Combining_Class= above_Right}', ""); +Expect(0, 788, '\p{Canonical_Combining_Class= above_Right}', ""); +Expect(1, 788, '\p{^Canonical_Combining_Class= above_Right}', ""); +Expect(1, 788, '\P{Canonical_Combining_Class= above_Right}', ""); +Expect(0, 788, '\P{^Canonical_Combining_Class= above_Right}', ""); +Error('\p{Ccc= :=ar}'); +Error('\P{Ccc= :=ar}'); +Expect(1, 789, '\p{Ccc=ar}', ""); +Expect(0, 789, '\p{^Ccc=ar}', ""); +Expect(0, 789, '\P{Ccc=ar}', ""); +Expect(1, 789, '\P{^Ccc=ar}', ""); +Expect(0, 788, '\p{Ccc=ar}', ""); +Expect(1, 788, '\p{^Ccc=ar}', ""); +Expect(1, 788, '\P{Ccc=ar}', ""); +Expect(0, 788, '\P{^Ccc=ar}', ""); +Expect(1, 789, '\p{Ccc= -AR}', ""); +Expect(0, 789, '\p{^Ccc= -AR}', ""); +Expect(0, 789, '\P{Ccc= -AR}', ""); +Expect(1, 789, '\P{^Ccc= -AR}', ""); +Expect(0, 788, '\p{Ccc= -AR}', ""); +Expect(1, 788, '\p{^Ccc= -AR}', ""); +Expect(1, 788, '\P{Ccc= -AR}', ""); +Expect(0, 788, '\P{^Ccc= -AR}', ""); +Error('\p{Is_Canonical_Combining_Class=-00000:=00002_32}'); +Error('\P{Is_Canonical_Combining_Class=-00000:=00002_32}'); +Expect(1, 789, '\p{Is_Canonical_Combining_Class: 23_2}', ""); +Expect(0, 789, '\p{^Is_Canonical_Combining_Class: 23_2}', ""); +Expect(0, 789, '\P{Is_Canonical_Combining_Class: 23_2}', ""); +Expect(1, 789, '\P{^Is_Canonical_Combining_Class: 23_2}', ""); +Expect(0, 788, '\p{Is_Canonical_Combining_Class: 23_2}', ""); +Expect(1, 788, '\p{^Is_Canonical_Combining_Class: 23_2}', ""); +Expect(1, 788, '\P{Is_Canonical_Combining_Class: 23_2}', ""); +Expect(0, 788, '\P{^Is_Canonical_Combining_Class: 23_2}', ""); +Error('\p{Is_Ccc=_above/a/Right}'); +Error('\P{Is_Ccc=_above/a/Right}'); +Expect(1, 789, '\p{Is_Ccc=aboveright}', ""); +Expect(0, 789, '\p{^Is_Ccc=aboveright}', ""); +Expect(0, 789, '\P{Is_Ccc=aboveright}', ""); +Expect(1, 789, '\P{^Is_Ccc=aboveright}', ""); +Expect(0, 788, '\p{Is_Ccc=aboveright}', ""); +Expect(1, 788, '\p{^Is_Ccc=aboveright}', ""); +Expect(1, 788, '\P{Is_Ccc=aboveright}', ""); +Expect(0, 788, '\P{^Is_Ccc=aboveright}', ""); +Expect(1, 789, '\p{Is_Ccc=__Above_RIGHT}', ""); +Expect(0, 789, '\p{^Is_Ccc=__Above_RIGHT}', ""); +Expect(0, 789, '\P{Is_Ccc=__Above_RIGHT}', ""); +Expect(1, 789, '\P{^Is_Ccc=__Above_RIGHT}', ""); +Expect(0, 788, '\p{Is_Ccc=__Above_RIGHT}', ""); +Expect(1, 788, '\p{^Is_Ccc=__Above_RIGHT}', ""); +Expect(1, 788, '\P{Is_Ccc=__Above_RIGHT}', ""); +Expect(0, 788, '\P{^Is_Ccc=__Above_RIGHT}', ""); +Error('\p{Canonical_Combining_Class=:= 0 0-29}'); +Error('\P{Canonical_Combining_Class=:= 0 0-29}'); +Expect(1, 1613, '\p{Canonical_Combining_Class=0_0_0_0_0_0_0_29}', ""); +Expect(0, 1613, '\p{^Canonical_Combining_Class=0_0_0_0_0_0_0_29}', ""); +Expect(0, 1613, '\P{Canonical_Combining_Class=0_0_0_0_0_0_0_29}', ""); +Expect(1, 1613, '\P{^Canonical_Combining_Class=0_0_0_0_0_0_0_29}', ""); +Expect(0, 1612, '\p{Canonical_Combining_Class=0_0_0_0_0_0_0_29}', ""); +Expect(1, 1612, '\p{^Canonical_Combining_Class=0_0_0_0_0_0_0_29}', ""); +Expect(1, 1612, '\P{Canonical_Combining_Class=0_0_0_0_0_0_0_29}', ""); +Expect(0, 1612, '\P{^Canonical_Combining_Class=0_0_0_0_0_0_0_29}', ""); +Error('\p{Ccc=/a/-_0_0-0 29}'); +Error('\P{Ccc=/a/-_0_0-0 29}'); +Expect(1, 1613, '\p{Ccc=002_9}', ""); +Expect(0, 1613, '\p{^Ccc=002_9}', ""); +Expect(0, 1613, '\P{Ccc=002_9}', ""); +Expect(1, 1613, '\P{^Ccc=002_9}', ""); +Expect(0, 1612, '\p{Ccc=002_9}', ""); +Expect(1, 1612, '\p{^Ccc=002_9}', ""); +Expect(1, 1612, '\P{Ccc=002_9}', ""); +Expect(0, 1612, '\P{^Ccc=002_9}', ""); +Error('\p{Is_Canonical_Combining_Class=_-029/a/}'); +Error('\P{Is_Canonical_Combining_Class=_-029/a/}'); +Expect(1, 1613, '\p{Is_Canonical_Combining_Class: 000029}', ""); +Expect(0, 1613, '\p{^Is_Canonical_Combining_Class: 000029}', ""); +Expect(0, 1613, '\P{Is_Canonical_Combining_Class: 000029}', ""); +Expect(1, 1613, '\P{^Is_Canonical_Combining_Class: 000029}', ""); +Expect(0, 1612, '\p{Is_Canonical_Combining_Class: 000029}', ""); +Expect(1, 1612, '\p{^Is_Canonical_Combining_Class: 000029}', ""); +Expect(1, 1612, '\P{Is_Canonical_Combining_Class: 000029}', ""); +Expect(0, 1612, '\P{^Is_Canonical_Combining_Class: 000029}', ""); +Error('\p{Is_Ccc= 0000000029:=}'); +Error('\P{Is_Ccc= 0000000029:=}'); +Expect(1, 1613, '\p{Is_Ccc=00000_00002_9}', ""); +Expect(0, 1613, '\p{^Is_Ccc=00000_00002_9}', ""); +Expect(0, 1613, '\P{Is_Ccc=00000_00002_9}', ""); +Expect(1, 1613, '\P{^Is_Ccc=00000_00002_9}', ""); +Expect(0, 1612, '\p{Is_Ccc=00000_00002_9}', ""); +Expect(1, 1612, '\p{^Is_Ccc=00000_00002_9}', ""); +Expect(1, 1612, '\P{Is_Ccc=00000_00002_9}', ""); +Expect(0, 1612, '\P{^Is_Ccc=00000_00002_9}', ""); +Error('\p{Canonical_Combining_Class=:=Right}'); +Error('\P{Canonical_Combining_Class=:=Right}'); +Expect(1, 119149, '\p{Canonical_Combining_Class=right}', ""); +Expect(0, 119149, '\p{^Canonical_Combining_Class=right}', ""); +Expect(0, 119149, '\P{Canonical_Combining_Class=right}', ""); +Expect(1, 119149, '\P{^Canonical_Combining_Class=right}', ""); +Expect(0, 119148, '\p{Canonical_Combining_Class=right}', ""); +Expect(1, 119148, '\p{^Canonical_Combining_Class=right}', ""); +Expect(1, 119148, '\P{Canonical_Combining_Class=right}', ""); +Expect(0, 119148, '\P{^Canonical_Combining_Class=right}', ""); +Expect(1, 119149, '\p{Canonical_Combining_Class=-RIGHT}', ""); +Expect(0, 119149, '\p{^Canonical_Combining_Class=-RIGHT}', ""); +Expect(0, 119149, '\P{Canonical_Combining_Class=-RIGHT}', ""); +Expect(1, 119149, '\P{^Canonical_Combining_Class=-RIGHT}', ""); +Expect(0, 119148, '\p{Canonical_Combining_Class=-RIGHT}', ""); +Expect(1, 119148, '\p{^Canonical_Combining_Class=-RIGHT}', ""); +Expect(1, 119148, '\P{Canonical_Combining_Class=-RIGHT}', ""); +Expect(0, 119148, '\P{^Canonical_Combining_Class=-RIGHT}', ""); +Error('\p{Ccc=_-R:=}'); +Error('\P{Ccc=_-R:=}'); +Expect(1, 119149, '\p{Ccc=r}', ""); +Expect(0, 119149, '\p{^Ccc=r}', ""); +Expect(0, 119149, '\P{Ccc=r}', ""); +Expect(1, 119149, '\P{^Ccc=r}', ""); +Expect(0, 119148, '\p{Ccc=r}', ""); +Expect(1, 119148, '\p{^Ccc=r}', ""); +Expect(1, 119148, '\P{Ccc=r}', ""); +Expect(0, 119148, '\P{^Ccc=r}', ""); +Expect(1, 119149, '\p{Ccc=-_R}', ""); +Expect(0, 119149, '\p{^Ccc=-_R}', ""); +Expect(0, 119149, '\P{Ccc=-_R}', ""); +Expect(1, 119149, '\P{^Ccc=-_R}', ""); +Expect(0, 119148, '\p{Ccc=-_R}', ""); +Expect(1, 119148, '\p{^Ccc=-_R}', ""); +Expect(1, 119148, '\P{Ccc=-_R}', ""); +Expect(0, 119148, '\P{^Ccc=-_R}', ""); +Error('\p{Is_Canonical_Combining_Class=:=_+00000000226}'); +Error('\P{Is_Canonical_Combining_Class=:=_+00000000226}'); +Expect(1, 119149, '\p{Is_Canonical_Combining_Class=+00000000226}', ""); +Expect(0, 119149, '\p{^Is_Canonical_Combining_Class=+00000000226}', ""); +Expect(0, 119149, '\P{Is_Canonical_Combining_Class=+00000000226}', ""); +Expect(1, 119149, '\P{^Is_Canonical_Combining_Class=+00000000226}', ""); +Expect(0, 119148, '\p{Is_Canonical_Combining_Class=+00000000226}', ""); +Expect(1, 119148, '\p{^Is_Canonical_Combining_Class=+00000000226}', ""); +Expect(1, 119148, '\P{Is_Canonical_Combining_Class=+00000000226}', ""); +Expect(0, 119148, '\P{^Is_Canonical_Combining_Class=+00000000226}', ""); +Error('\p{Is_Ccc: :=_right}'); +Error('\P{Is_Ccc: :=_right}'); +Expect(1, 119149, '\p{Is_Ccc=right}', ""); +Expect(0, 119149, '\p{^Is_Ccc=right}', ""); +Expect(0, 119149, '\P{Is_Ccc=right}', ""); +Expect(1, 119149, '\P{^Is_Ccc=right}', ""); +Expect(0, 119148, '\p{Is_Ccc=right}', ""); +Expect(1, 119148, '\p{^Is_Ccc=right}', ""); +Expect(1, 119148, '\P{Is_Ccc=right}', ""); +Expect(0, 119148, '\P{^Is_Ccc=right}', ""); +Expect(1, 119149, '\p{Is_Ccc= Right}', ""); +Expect(0, 119149, '\p{^Is_Ccc= Right}', ""); +Expect(0, 119149, '\P{Is_Ccc= Right}', ""); +Expect(1, 119149, '\P{^Is_Ccc= Right}', ""); +Expect(0, 119148, '\p{Is_Ccc= Right}', ""); +Expect(1, 119148, '\p{^Is_Ccc= Right}', ""); +Expect(1, 119148, '\P{Is_Ccc= Right}', ""); +Expect(0, 119148, '\P{^Is_Ccc= Right}', ""); +Error('\p{Canonical_Combining_Class=_:=00000000015}'); +Error('\P{Canonical_Combining_Class=_:=00000000015}'); +Expect(1, 1461, '\p{Canonical_Combining_Class=000000015}', ""); +Expect(0, 1461, '\p{^Canonical_Combining_Class=000000015}', ""); +Expect(0, 1461, '\P{Canonical_Combining_Class=000000015}', ""); +Expect(1, 1461, '\P{^Canonical_Combining_Class=000000015}', ""); +Expect(0, 1460, '\p{Canonical_Combining_Class=000000015}', ""); +Expect(1, 1460, '\p{^Canonical_Combining_Class=000000015}', ""); +Expect(1, 1460, '\P{Canonical_Combining_Class=000000015}', ""); +Expect(0, 1460, '\P{^Canonical_Combining_Class=000000015}', ""); +Error('\p{Ccc= 00000000015:=}'); +Error('\P{Ccc= 00000000015:=}'); +Expect(1, 1461, '\p{Ccc=000000015}', ""); +Expect(0, 1461, '\p{^Ccc=000000015}', ""); +Expect(0, 1461, '\P{Ccc=000000015}', ""); +Expect(1, 1461, '\P{^Ccc=000000015}', ""); +Expect(0, 1460, '\p{Ccc=000000015}', ""); +Expect(1, 1460, '\p{^Ccc=000000015}', ""); +Expect(1, 1460, '\P{Ccc=000000015}', ""); +Expect(0, 1460, '\P{^Ccc=000000015}', ""); +Error('\p{Is_Canonical_Combining_Class=:= +00015}'); +Error('\P{Is_Canonical_Combining_Class=:= +00015}'); +Expect(1, 1461, '\p{Is_Canonical_Combining_Class=0000015}', ""); +Expect(0, 1461, '\p{^Is_Canonical_Combining_Class=0000015}', ""); +Expect(0, 1461, '\P{Is_Canonical_Combining_Class=0000015}', ""); +Expect(1, 1461, '\P{^Is_Canonical_Combining_Class=0000015}', ""); +Expect(0, 1460, '\p{Is_Canonical_Combining_Class=0000015}', ""); +Expect(1, 1460, '\p{^Is_Canonical_Combining_Class=0000015}', ""); +Expect(1, 1460, '\P{Is_Canonical_Combining_Class=0000015}', ""); +Expect(0, 1460, '\P{^Is_Canonical_Combining_Class=0000015}', ""); +Error('\p{Is_Ccc: -00:=00_01 5}'); +Error('\P{Is_Ccc: -00:=00_01 5}'); +Expect(1, 1461, '\p{Is_Ccc=00015}', ""); +Expect(0, 1461, '\p{^Is_Ccc=00015}', ""); +Expect(0, 1461, '\P{Is_Ccc=00015}', ""); +Expect(1, 1461, '\P{^Is_Ccc=00015}', ""); +Expect(0, 1460, '\p{Is_Ccc=00015}', ""); +Expect(1, 1460, '\p{^Is_Ccc=00015}', ""); +Expect(1, 1460, '\P{Is_Ccc=00015}', ""); +Expect(0, 1460, '\P{^Is_Ccc=00015}', ""); +Error('\p{Canonical_Combining_Class=:=Below Left}'); +Error('\P{Canonical_Combining_Class=:=Below Left}'); +Expect(1, 12330, '\p{Canonical_Combining_Class=belowleft}', ""); +Expect(0, 12330, '\p{^Canonical_Combining_Class=belowleft}', ""); +Expect(0, 12330, '\P{Canonical_Combining_Class=belowleft}', ""); +Expect(1, 12330, '\P{^Canonical_Combining_Class=belowleft}', ""); +Expect(0, 12329, '\p{Canonical_Combining_Class=belowleft}', ""); +Expect(1, 12329, '\p{^Canonical_Combining_Class=belowleft}', ""); +Expect(1, 12329, '\P{Canonical_Combining_Class=belowleft}', ""); +Expect(0, 12329, '\P{^Canonical_Combining_Class=belowleft}', ""); +Expect(1, 12330, '\p{Canonical_Combining_Class= BELOW-left}', ""); +Expect(0, 12330, '\p{^Canonical_Combining_Class= BELOW-left}', ""); +Expect(0, 12330, '\P{Canonical_Combining_Class= BELOW-left}', ""); +Expect(1, 12330, '\P{^Canonical_Combining_Class= BELOW-left}', ""); +Expect(0, 12329, '\p{Canonical_Combining_Class= BELOW-left}', ""); +Expect(1, 12329, '\p{^Canonical_Combining_Class= BELOW-left}', ""); +Expect(1, 12329, '\P{Canonical_Combining_Class= BELOW-left}', ""); +Expect(0, 12329, '\P{^Canonical_Combining_Class= BELOW-left}', ""); +Error('\p{Ccc=_:=BL}'); +Error('\P{Ccc=_:=BL}'); +Expect(1, 12330, '\p{Ccc=bl}', ""); +Expect(0, 12330, '\p{^Ccc=bl}', ""); +Expect(0, 12330, '\P{Ccc=bl}', ""); +Expect(1, 12330, '\P{^Ccc=bl}', ""); +Expect(0, 12329, '\p{Ccc=bl}', ""); +Expect(1, 12329, '\p{^Ccc=bl}', ""); +Expect(1, 12329, '\P{Ccc=bl}', ""); +Expect(0, 12329, '\P{^Ccc=bl}', ""); +Expect(1, 12330, '\p{Ccc=- BL}', ""); +Expect(0, 12330, '\p{^Ccc=- BL}', ""); +Expect(0, 12330, '\P{Ccc=- BL}', ""); +Expect(1, 12330, '\P{^Ccc=- BL}', ""); +Expect(0, 12329, '\p{Ccc=- BL}', ""); +Expect(1, 12329, '\p{^Ccc=- BL}', ""); +Expect(1, 12329, '\P{Ccc=- BL}', ""); +Expect(0, 12329, '\P{^Ccc=- BL}', ""); +Error('\p{Is_Canonical_Combining_Class= -000000218:=}'); +Error('\P{Is_Canonical_Combining_Class= -000000218:=}'); +Expect(1, 12330, '\p{Is_Canonical_Combining_Class: 218}', ""); +Expect(0, 12330, '\p{^Is_Canonical_Combining_Class: 218}', ""); +Expect(0, 12330, '\P{Is_Canonical_Combining_Class: 218}', ""); +Expect(1, 12330, '\P{^Is_Canonical_Combining_Class: 218}', ""); +Expect(0, 12329, '\p{Is_Canonical_Combining_Class: 218}', ""); +Expect(1, 12329, '\p{^Is_Canonical_Combining_Class: 218}', ""); +Expect(1, 12329, '\P{Is_Canonical_Combining_Class: 218}', ""); +Expect(0, 12329, '\P{^Is_Canonical_Combining_Class: 218}', ""); +Error('\p{Is_Ccc=-/a/BELOW_left}'); +Error('\P{Is_Ccc=-/a/BELOW_left}'); +Expect(1, 12330, '\p{Is_Ccc=belowleft}', ""); +Expect(0, 12330, '\p{^Is_Ccc=belowleft}', ""); +Expect(0, 12330, '\P{Is_Ccc=belowleft}', ""); +Expect(1, 12330, '\P{^Is_Ccc=belowleft}', ""); +Expect(0, 12329, '\p{Is_Ccc=belowleft}', ""); +Expect(1, 12329, '\p{^Is_Ccc=belowleft}', ""); +Expect(1, 12329, '\P{Is_Ccc=belowleft}', ""); +Expect(0, 12329, '\P{^Is_Ccc=belowleft}', ""); +Expect(1, 12330, '\p{Is_Ccc: _BELOW_Left}', ""); +Expect(0, 12330, '\p{^Is_Ccc: _BELOW_Left}', ""); +Expect(0, 12330, '\P{Is_Ccc: _BELOW_Left}', ""); +Expect(1, 12330, '\P{^Is_Ccc: _BELOW_Left}', ""); +Expect(0, 12329, '\p{Is_Ccc: _BELOW_Left}', ""); +Expect(1, 12329, '\p{^Is_Ccc: _BELOW_Left}', ""); +Expect(1, 12329, '\P{Is_Ccc: _BELOW_Left}', ""); +Expect(0, 12329, '\P{^Is_Ccc: _BELOW_Left}', ""); +Error('\p{Canonical_Combining_Class=/a/-_LEFT}'); +Error('\P{Canonical_Combining_Class=/a/-_LEFT}'); +Expect(1, 12335, '\p{Canonical_Combining_Class: left}', ""); +Expect(0, 12335, '\p{^Canonical_Combining_Class: left}', ""); +Expect(0, 12335, '\P{Canonical_Combining_Class: left}', ""); +Expect(1, 12335, '\P{^Canonical_Combining_Class: left}', ""); +Expect(0, 12333, '\p{Canonical_Combining_Class: left}', ""); +Expect(1, 12333, '\p{^Canonical_Combining_Class: left}', ""); +Expect(1, 12333, '\P{Canonical_Combining_Class: left}', ""); +Expect(0, 12333, '\P{^Canonical_Combining_Class: left}', ""); +Expect(1, 12335, '\p{Canonical_Combining_Class= Left}', ""); +Expect(0, 12335, '\p{^Canonical_Combining_Class= Left}', ""); +Expect(0, 12335, '\P{Canonical_Combining_Class= Left}', ""); +Expect(1, 12335, '\P{^Canonical_Combining_Class= Left}', ""); +Expect(0, 12333, '\p{Canonical_Combining_Class= Left}', ""); +Expect(1, 12333, '\p{^Canonical_Combining_Class= Left}', ""); +Expect(1, 12333, '\P{Canonical_Combining_Class= Left}', ""); +Expect(0, 12333, '\P{^Canonical_Combining_Class= Left}', ""); +Error('\p{Ccc= L/a/}'); +Error('\P{Ccc= L/a/}'); +Expect(1, 12335, '\p{Ccc=l}', ""); +Expect(0, 12335, '\p{^Ccc=l}', ""); +Expect(0, 12335, '\P{Ccc=l}', ""); +Expect(1, 12335, '\P{^Ccc=l}', ""); +Expect(0, 12333, '\p{Ccc=l}', ""); +Expect(1, 12333, '\p{^Ccc=l}', ""); +Expect(1, 12333, '\P{Ccc=l}', ""); +Expect(0, 12333, '\P{^Ccc=l}', ""); +Expect(1, 12335, '\p{Ccc: L}', ""); +Expect(0, 12335, '\p{^Ccc: L}', ""); +Expect(0, 12335, '\P{Ccc: L}', ""); +Expect(1, 12335, '\P{^Ccc: L}', ""); +Expect(0, 12333, '\p{Ccc: L}', ""); +Expect(1, 12333, '\p{^Ccc: L}', ""); +Expect(1, 12333, '\P{Ccc: L}', ""); +Expect(0, 12333, '\P{^Ccc: L}', ""); +Error('\p{Is_Canonical_Combining_Class: -022:=4}'); +Error('\P{Is_Canonical_Combining_Class: -022:=4}'); +Expect(1, 12335, '\p{Is_Canonical_Combining_Class=00224}', ""); +Expect(0, 12335, '\p{^Is_Canonical_Combining_Class=00224}', ""); +Expect(0, 12335, '\P{Is_Canonical_Combining_Class=00224}', ""); +Expect(1, 12335, '\P{^Is_Canonical_Combining_Class=00224}', ""); +Expect(0, 12333, '\p{Is_Canonical_Combining_Class=00224}', ""); +Expect(1, 12333, '\p{^Is_Canonical_Combining_Class=00224}', ""); +Expect(1, 12333, '\P{Is_Canonical_Combining_Class=00224}', ""); +Expect(0, 12333, '\P{^Is_Canonical_Combining_Class=00224}', ""); +Error('\p{Is_Ccc=:= LEFT}'); +Error('\P{Is_Ccc=:= LEFT}'); +Expect(1, 12335, '\p{Is_Ccc=left}', ""); +Expect(0, 12335, '\p{^Is_Ccc=left}', ""); +Expect(0, 12335, '\P{Is_Ccc=left}', ""); +Expect(1, 12335, '\P{^Is_Ccc=left}', ""); +Expect(0, 12333, '\p{Is_Ccc=left}', ""); +Expect(1, 12333, '\p{^Is_Ccc=left}', ""); +Expect(1, 12333, '\P{Is_Ccc=left}', ""); +Expect(0, 12333, '\P{^Is_Ccc=left}', ""); +Expect(1, 12335, '\p{Is_Ccc=-_left}', ""); +Expect(0, 12335, '\p{^Is_Ccc=-_left}', ""); +Expect(0, 12335, '\P{Is_Ccc=-_left}', ""); +Expect(1, 12335, '\P{^Is_Ccc=-_left}', ""); +Expect(0, 12333, '\p{Is_Ccc=-_left}', ""); +Expect(1, 12333, '\p{^Is_Ccc=-_left}', ""); +Expect(1, 12333, '\P{Is_Ccc=-_left}', ""); +Expect(0, 12333, '\P{^Is_Ccc=-_left}', ""); +Error('\p{Canonical_Combining_Class= /a/Above}'); +Error('\P{Canonical_Combining_Class= /a/Above}'); +Expect(1, 788, '\p{Canonical_Combining_Class=above}', ""); +Expect(0, 788, '\p{^Canonical_Combining_Class=above}', ""); +Expect(0, 788, '\P{Canonical_Combining_Class=above}', ""); +Expect(1, 788, '\P{^Canonical_Combining_Class=above}', ""); +Expect(0, 767, '\p{Canonical_Combining_Class=above}', ""); +Expect(1, 767, '\p{^Canonical_Combining_Class=above}', ""); +Expect(1, 767, '\P{Canonical_Combining_Class=above}', ""); +Expect(0, 767, '\P{^Canonical_Combining_Class=above}', ""); +Expect(1, 788, '\p{Canonical_Combining_Class=_Above}', ""); +Expect(0, 788, '\p{^Canonical_Combining_Class=_Above}', ""); +Expect(0, 788, '\P{Canonical_Combining_Class=_Above}', ""); +Expect(1, 788, '\P{^Canonical_Combining_Class=_Above}', ""); +Expect(0, 767, '\p{Canonical_Combining_Class=_Above}', ""); +Expect(1, 767, '\p{^Canonical_Combining_Class=_Above}', ""); +Expect(1, 767, '\P{Canonical_Combining_Class=_Above}', ""); +Expect(0, 767, '\P{^Canonical_Combining_Class=_Above}', ""); +Error('\p{Ccc= -A/a/}'); +Error('\P{Ccc= -A/a/}'); +Expect(1, 788, '\p{Ccc=a}', ""); +Expect(0, 788, '\p{^Ccc=a}', ""); +Expect(0, 788, '\P{Ccc=a}', ""); +Expect(1, 788, '\P{^Ccc=a}', ""); +Expect(0, 767, '\p{Ccc=a}', ""); +Expect(1, 767, '\p{^Ccc=a}', ""); +Expect(1, 767, '\P{Ccc=a}', ""); +Expect(0, 767, '\P{^Ccc=a}', ""); +Expect(1, 788, '\p{Ccc= _A}', ""); +Expect(0, 788, '\p{^Ccc= _A}', ""); +Expect(0, 788, '\P{Ccc= _A}', ""); +Expect(1, 788, '\P{^Ccc= _A}', ""); +Expect(0, 767, '\p{Ccc= _A}', ""); +Expect(1, 767, '\p{^Ccc= _A}', ""); +Expect(1, 767, '\P{Ccc= _A}', ""); +Expect(0, 767, '\P{^Ccc= _A}', ""); +Error('\p{Is_Canonical_Combining_Class:__0000230:=}'); +Error('\P{Is_Canonical_Combining_Class:__0000230:=}'); +Expect(1, 788, '\p{Is_Canonical_Combining_Class=23_0}', ""); +Expect(0, 788, '\p{^Is_Canonical_Combining_Class=23_0}', ""); +Expect(0, 788, '\P{Is_Canonical_Combining_Class=23_0}', ""); +Expect(1, 788, '\P{^Is_Canonical_Combining_Class=23_0}', ""); +Expect(0, 767, '\p{Is_Canonical_Combining_Class=23_0}', ""); +Expect(1, 767, '\p{^Is_Canonical_Combining_Class=23_0}', ""); +Expect(1, 767, '\P{Is_Canonical_Combining_Class=23_0}', ""); +Expect(0, 767, '\P{^Is_Canonical_Combining_Class=23_0}', ""); +Error('\p{Is_Ccc:/a/ABOVE}'); +Error('\P{Is_Ccc:/a/ABOVE}'); +Expect(1, 788, '\p{Is_Ccc=above}', ""); +Expect(0, 788, '\p{^Is_Ccc=above}', ""); +Expect(0, 788, '\P{Is_Ccc=above}', ""); +Expect(1, 788, '\P{^Is_Ccc=above}', ""); +Expect(0, 767, '\p{Is_Ccc=above}', ""); +Expect(1, 767, '\p{^Is_Ccc=above}', ""); +Expect(1, 767, '\P{Is_Ccc=above}', ""); +Expect(0, 767, '\P{^Is_Ccc=above}', ""); +Expect(1, 788, '\p{Is_Ccc= Above}', ""); +Expect(0, 788, '\p{^Is_Ccc= Above}', ""); +Expect(0, 788, '\P{Is_Ccc= Above}', ""); +Expect(1, 788, '\P{^Is_Ccc= Above}', ""); +Expect(0, 767, '\p{Is_Ccc= Above}', ""); +Expect(1, 767, '\p{^Is_Ccc= Above}', ""); +Expect(1, 767, '\P{Is_Ccc= Above}', ""); +Expect(0, 767, '\P{^Is_Ccc= Above}', ""); +Error('\p{Canonical_Combining_Class= _0-0:=00-0-0 0 129}'); +Error('\P{Canonical_Combining_Class= _0-0:=00-0-0 0 129}'); +Expect(1, 3953, '\p{Canonical_Combining_Class=0129}', ""); +Expect(0, 3953, '\p{^Canonical_Combining_Class=0129}', ""); +Expect(0, 3953, '\P{Canonical_Combining_Class=0129}', ""); +Expect(1, 3953, '\P{^Canonical_Combining_Class=0129}', ""); +Expect(0, 3952, '\p{Canonical_Combining_Class=0129}', ""); +Expect(1, 3952, '\p{^Canonical_Combining_Class=0129}', ""); +Expect(1, 3952, '\P{Canonical_Combining_Class=0129}', ""); +Expect(0, 3952, '\P{^Canonical_Combining_Class=0129}', ""); +Error('\p{Ccc= -0/a/0-0 0_0_0129}'); +Error('\P{Ccc= -0/a/0-0 0_0_0129}'); +Expect(1, 3953, '\p{Ccc:12_9}', ""); +Expect(0, 3953, '\p{^Ccc:12_9}', ""); +Expect(0, 3953, '\P{Ccc:12_9}', ""); +Expect(1, 3953, '\P{^Ccc:12_9}', ""); +Expect(0, 3952, '\p{Ccc:12_9}', ""); +Expect(1, 3952, '\p{^Ccc:12_9}', ""); +Expect(1, 3952, '\P{Ccc:12_9}', ""); +Expect(0, 3952, '\P{^Ccc:12_9}', ""); +Error('\p{Is_Canonical_Combining_Class=-:=12_9}'); +Error('\P{Is_Canonical_Combining_Class=-:=12_9}'); +Expect(1, 3953, '\p{Is_Canonical_Combining_Class: 0000129}', ""); +Expect(0, 3953, '\p{^Is_Canonical_Combining_Class: 0000129}', ""); +Expect(0, 3953, '\P{Is_Canonical_Combining_Class: 0000129}', ""); +Expect(1, 3953, '\P{^Is_Canonical_Combining_Class: 0000129}', ""); +Expect(0, 3952, '\p{Is_Canonical_Combining_Class: 0000129}', ""); +Expect(1, 3952, '\p{^Is_Canonical_Combining_Class: 0000129}', ""); +Expect(1, 3952, '\P{Is_Canonical_Combining_Class: 0000129}', ""); +Expect(0, 3952, '\P{^Is_Canonical_Combining_Class: 0000129}', ""); +Error('\p{Is_Ccc=:=_00000129}'); +Error('\P{Is_Ccc=:=_00000129}'); +Expect(1, 3953, '\p{Is_Ccc=+0_1_29}', ""); +Expect(0, 3953, '\p{^Is_Ccc=+0_1_29}', ""); +Expect(0, 3953, '\P{Is_Ccc=+0_1_29}', ""); +Expect(1, 3953, '\P{^Is_Ccc=+0_1_29}', ""); +Expect(0, 3952, '\p{Is_Ccc=+0_1_29}', ""); +Expect(1, 3952, '\p{^Is_Ccc=+0_1_29}', ""); +Expect(1, 3952, '\P{Is_Ccc=+0_1_29}', ""); +Expect(0, 3952, '\P{^Is_Ccc=+0_1_29}', ""); +Error('\p{Canonical_Combining_Class=:=_ 0_0_17}'); +Error('\P{Canonical_Combining_Class=:=_ 0_0_17}'); +Expect(1, 1463, '\p{Canonical_Combining_Class=000017}', ""); +Expect(0, 1463, '\p{^Canonical_Combining_Class=000017}', ""); +Expect(0, 1463, '\P{Canonical_Combining_Class=000017}', ""); +Expect(1, 1463, '\P{^Canonical_Combining_Class=000017}', ""); +Expect(0, 1462, '\p{Canonical_Combining_Class=000017}', ""); +Expect(1, 1462, '\p{^Canonical_Combining_Class=000017}', ""); +Expect(1, 1462, '\P{Canonical_Combining_Class=000017}', ""); +Expect(0, 1462, '\P{^Canonical_Combining_Class=000017}', ""); +Error('\p{Ccc=-:=+0000000017}'); +Error('\P{Ccc=-:=+0000000017}'); +Expect(1, 1463, '\p{Ccc=000000001_7}', ""); +Expect(0, 1463, '\p{^Ccc=000000001_7}', ""); +Expect(0, 1463, '\P{Ccc=000000001_7}', ""); +Expect(1, 1463, '\P{^Ccc=000000001_7}', ""); +Expect(0, 1462, '\p{Ccc=000000001_7}', ""); +Expect(1, 1462, '\p{^Ccc=000000001_7}', ""); +Expect(1, 1462, '\P{Ccc=000000001_7}', ""); +Expect(0, 1462, '\P{^Ccc=000000001_7}', ""); +Error('\p{Is_Canonical_Combining_Class= 0000000017/a/}'); +Error('\P{Is_Canonical_Combining_Class= 0000000017/a/}'); +Expect(1, 1463, '\p{Is_Canonical_Combining_Class=00000017}', ""); +Expect(0, 1463, '\p{^Is_Canonical_Combining_Class=00000017}', ""); +Expect(0, 1463, '\P{Is_Canonical_Combining_Class=00000017}', ""); +Expect(1, 1463, '\P{^Is_Canonical_Combining_Class=00000017}', ""); +Expect(0, 1462, '\p{Is_Canonical_Combining_Class=00000017}', ""); +Expect(1, 1462, '\p{^Is_Canonical_Combining_Class=00000017}', ""); +Expect(1, 1462, '\P{Is_Canonical_Combining_Class=00000017}', ""); +Expect(0, 1462, '\P{^Is_Canonical_Combining_Class=00000017}', ""); +Error('\p{Is_Ccc= 0017:=}'); +Error('\P{Is_Ccc= 0017:=}'); +Expect(1, 1463, '\p{Is_Ccc=+0_0_0_0_0017}', ""); +Expect(0, 1463, '\p{^Is_Ccc=+0_0_0_0_0017}', ""); +Expect(0, 1463, '\P{Is_Ccc=+0_0_0_0_0017}', ""); +Expect(1, 1463, '\P{^Is_Ccc=+0_0_0_0_0017}', ""); +Expect(0, 1462, '\p{Is_Ccc=+0_0_0_0_0017}', ""); +Expect(1, 1462, '\p{^Is_Ccc=+0_0_0_0_0017}', ""); +Expect(1, 1462, '\P{Is_Ccc=+0_0_0_0_0017}', ""); +Expect(0, 1462, '\P{^Is_Ccc=+0_0_0_0_0017}', ""); +Error('\p{Canonical_Combining_Class=/a/_-NOT-REORDERED}'); +Error('\P{Canonical_Combining_Class=/a/_-NOT-REORDERED}'); +Expect(1, 767, '\p{Canonical_Combining_Class: notreordered}', ""); +Expect(0, 767, '\p{^Canonical_Combining_Class: notreordered}', ""); +Expect(0, 767, '\P{Canonical_Combining_Class: notreordered}', ""); +Expect(1, 767, '\P{^Canonical_Combining_Class: notreordered}', ""); +Expect(0, 846, '\p{Canonical_Combining_Class: notreordered}', ""); +Expect(1, 846, '\p{^Canonical_Combining_Class: notreordered}', ""); +Expect(1, 846, '\P{Canonical_Combining_Class: notreordered}', ""); +Expect(0, 846, '\P{^Canonical_Combining_Class: notreordered}', ""); +Expect(1, 767, '\p{Canonical_Combining_Class= notREORDERED}', ""); +Expect(0, 767, '\p{^Canonical_Combining_Class= notREORDERED}', ""); +Expect(0, 767, '\P{Canonical_Combining_Class= notREORDERED}', ""); +Expect(1, 767, '\P{^Canonical_Combining_Class= notREORDERED}', ""); +Expect(0, 846, '\p{Canonical_Combining_Class= notREORDERED}', ""); +Expect(1, 846, '\p{^Canonical_Combining_Class= notREORDERED}', ""); +Expect(1, 846, '\P{Canonical_Combining_Class= notREORDERED}', ""); +Expect(0, 846, '\P{^Canonical_Combining_Class= notREORDERED}', ""); +Error('\p{Ccc=_-nr:=}'); +Error('\P{Ccc=_-nr:=}'); +Expect(1, 767, '\p{Ccc=nr}', ""); +Expect(0, 767, '\p{^Ccc=nr}', ""); +Expect(0, 767, '\P{Ccc=nr}', ""); +Expect(1, 767, '\P{^Ccc=nr}', ""); +Expect(0, 846, '\p{Ccc=nr}', ""); +Expect(1, 846, '\p{^Ccc=nr}', ""); +Expect(1, 846, '\P{Ccc=nr}', ""); +Expect(0, 846, '\P{^Ccc=nr}', ""); +Expect(1, 767, '\p{Ccc=_ NR}', ""); +Expect(0, 767, '\p{^Ccc=_ NR}', ""); +Expect(0, 767, '\P{Ccc=_ NR}', ""); +Expect(1, 767, '\P{^Ccc=_ NR}', ""); +Expect(0, 846, '\p{Ccc=_ NR}', ""); +Expect(1, 846, '\p{^Ccc=_ NR}', ""); +Expect(1, 846, '\P{Ccc=_ NR}', ""); +Expect(0, 846, '\P{^Ccc=_ NR}', ""); +Error('\p{Is_Canonical_Combining_Class:/a/_ 000}'); +Error('\P{Is_Canonical_Combining_Class:/a/_ 000}'); +Expect(1, 767, '\p{Is_Canonical_Combining_Class=00_00_00_00_00}', ""); +Expect(0, 767, '\p{^Is_Canonical_Combining_Class=00_00_00_00_00}', ""); +Expect(0, 767, '\P{Is_Canonical_Combining_Class=00_00_00_00_00}', ""); +Expect(1, 767, '\P{^Is_Canonical_Combining_Class=00_00_00_00_00}', ""); +Expect(0, 846, '\p{Is_Canonical_Combining_Class=00_00_00_00_00}', ""); +Expect(1, 846, '\p{^Is_Canonical_Combining_Class=00_00_00_00_00}', ""); +Expect(1, 846, '\P{Is_Canonical_Combining_Class=00_00_00_00_00}', ""); +Expect(0, 846, '\P{^Is_Canonical_Combining_Class=00_00_00_00_00}', ""); +Error('\p{Is_Ccc= not_Reordered:=}'); +Error('\P{Is_Ccc= not_Reordered:=}'); +Expect(1, 767, '\p{Is_Ccc=notreordered}', ""); +Expect(0, 767, '\p{^Is_Ccc=notreordered}', ""); +Expect(0, 767, '\P{Is_Ccc=notreordered}', ""); +Expect(1, 767, '\P{^Is_Ccc=notreordered}', ""); +Expect(0, 846, '\p{Is_Ccc=notreordered}', ""); +Expect(1, 846, '\p{^Is_Ccc=notreordered}', ""); +Expect(1, 846, '\P{Is_Ccc=notreordered}', ""); +Expect(0, 846, '\P{^Is_Ccc=notreordered}', ""); +Expect(1, 767, '\p{Is_Ccc=- Not REORDERED}', ""); +Expect(0, 767, '\p{^Is_Ccc=- Not REORDERED}', ""); +Expect(0, 767, '\P{Is_Ccc=- Not REORDERED}', ""); +Expect(1, 767, '\P{^Is_Ccc=- Not REORDERED}', ""); +Expect(0, 846, '\p{Is_Ccc=- Not REORDERED}', ""); +Expect(1, 846, '\p{^Is_Ccc=- Not REORDERED}', ""); +Expect(1, 846, '\P{Is_Ccc=- Not REORDERED}', ""); +Expect(0, 846, '\P{^Is_Ccc=- Not REORDERED}', ""); +Error('\p{Canonical_Combining_Class= Above/a/left}'); +Error('\P{Canonical_Combining_Class= Above/a/left}'); +Expect(1, 1454, '\p{Canonical_Combining_Class=aboveleft}', ""); +Expect(0, 1454, '\p{^Canonical_Combining_Class=aboveleft}', ""); +Expect(0, 1454, '\P{Canonical_Combining_Class=aboveleft}', ""); +Expect(1, 1454, '\P{^Canonical_Combining_Class=aboveleft}', ""); +Expect(0, 1453, '\p{Canonical_Combining_Class=aboveleft}', ""); +Expect(1, 1453, '\p{^Canonical_Combining_Class=aboveleft}', ""); +Expect(1, 1453, '\P{Canonical_Combining_Class=aboveleft}', ""); +Expect(0, 1453, '\P{^Canonical_Combining_Class=aboveleft}', ""); +Expect(1, 1454, '\p{Canonical_Combining_Class=__Above LEFT}', ""); +Expect(0, 1454, '\p{^Canonical_Combining_Class=__Above LEFT}', ""); +Expect(0, 1454, '\P{Canonical_Combining_Class=__Above LEFT}', ""); +Expect(1, 1454, '\P{^Canonical_Combining_Class=__Above LEFT}', ""); +Expect(0, 1453, '\p{Canonical_Combining_Class=__Above LEFT}', ""); +Expect(1, 1453, '\p{^Canonical_Combining_Class=__Above LEFT}', ""); +Expect(1, 1453, '\P{Canonical_Combining_Class=__Above LEFT}', ""); +Expect(0, 1453, '\P{^Canonical_Combining_Class=__Above LEFT}', ""); +Error('\p{Ccc= AL:=}'); +Error('\P{Ccc= AL:=}'); +Expect(1, 1454, '\p{Ccc=al}', ""); +Expect(0, 1454, '\p{^Ccc=al}', ""); +Expect(0, 1454, '\P{Ccc=al}', ""); +Expect(1, 1454, '\P{^Ccc=al}', ""); +Expect(0, 1453, '\p{Ccc=al}', ""); +Expect(1, 1453, '\p{^Ccc=al}', ""); +Expect(1, 1453, '\P{Ccc=al}', ""); +Expect(0, 1453, '\P{^Ccc=al}', ""); +Expect(1, 1454, '\p{Ccc= _AL}', ""); +Expect(0, 1454, '\p{^Ccc= _AL}', ""); +Expect(0, 1454, '\P{Ccc= _AL}', ""); +Expect(1, 1454, '\P{^Ccc= _AL}', ""); +Expect(0, 1453, '\p{Ccc= _AL}', ""); +Expect(1, 1453, '\p{^Ccc= _AL}', ""); +Expect(1, 1453, '\P{Ccc= _AL}', ""); +Expect(0, 1453, '\P{^Ccc= _AL}', ""); +Error('\p{Is_Canonical_Combining_Class: -000228/a/}'); +Error('\P{Is_Canonical_Combining_Class: -000228/a/}'); +Expect(1, 1454, '\p{Is_Canonical_Combining_Class=+00000228}', ""); +Expect(0, 1454, '\p{^Is_Canonical_Combining_Class=+00000228}', ""); +Expect(0, 1454, '\P{Is_Canonical_Combining_Class=+00000228}', ""); +Expect(1, 1454, '\P{^Is_Canonical_Combining_Class=+00000228}', ""); +Expect(0, 1453, '\p{Is_Canonical_Combining_Class=+00000228}', ""); +Expect(1, 1453, '\p{^Is_Canonical_Combining_Class=+00000228}', ""); +Expect(1, 1453, '\P{Is_Canonical_Combining_Class=+00000228}', ""); +Expect(0, 1453, '\P{^Is_Canonical_Combining_Class=+00000228}', ""); +Error('\p{Is_Ccc=-:=Above_left}'); +Error('\P{Is_Ccc=-:=Above_left}'); +Expect(1, 1454, '\p{Is_Ccc=aboveleft}', ""); +Expect(0, 1454, '\p{^Is_Ccc=aboveleft}', ""); +Expect(0, 1454, '\P{Is_Ccc=aboveleft}', ""); +Expect(1, 1454, '\P{^Is_Ccc=aboveleft}', ""); +Expect(0, 1453, '\p{Is_Ccc=aboveleft}', ""); +Expect(1, 1453, '\p{^Is_Ccc=aboveleft}', ""); +Expect(1, 1453, '\P{Is_Ccc=aboveleft}', ""); +Expect(0, 1453, '\P{^Is_Ccc=aboveleft}', ""); +Expect(1, 1454, '\p{Is_Ccc=-_Above_LEFT}', ""); +Expect(0, 1454, '\p{^Is_Ccc=-_Above_LEFT}', ""); +Expect(0, 1454, '\P{Is_Ccc=-_Above_LEFT}', ""); +Expect(1, 1454, '\P{^Is_Ccc=-_Above_LEFT}', ""); +Expect(0, 1453, '\p{Is_Ccc=-_Above_LEFT}', ""); +Expect(1, 1453, '\p{^Is_Ccc=-_Above_LEFT}', ""); +Expect(1, 1453, '\P{Is_Ccc=-_Above_LEFT}', ""); +Expect(0, 1453, '\P{^Is_Ccc=-_Above_LEFT}', ""); +Error('\p{Canonical_Combining_Class=-:=overlay}'); +Error('\P{Canonical_Combining_Class=-:=overlay}'); +Expect(1, 824, '\p{Canonical_Combining_Class=overlay}', ""); +Expect(0, 824, '\p{^Canonical_Combining_Class=overlay}', ""); +Expect(0, 824, '\P{Canonical_Combining_Class=overlay}', ""); +Expect(1, 824, '\P{^Canonical_Combining_Class=overlay}', ""); +Expect(0, 819, '\p{Canonical_Combining_Class=overlay}', ""); +Expect(1, 819, '\p{^Canonical_Combining_Class=overlay}', ""); +Expect(1, 819, '\P{Canonical_Combining_Class=overlay}', ""); +Expect(0, 819, '\P{^Canonical_Combining_Class=overlay}', ""); +Expect(1, 824, '\p{Canonical_Combining_Class= _Overlay}', ""); +Expect(0, 824, '\p{^Canonical_Combining_Class= _Overlay}', ""); +Expect(0, 824, '\P{Canonical_Combining_Class= _Overlay}', ""); +Expect(1, 824, '\P{^Canonical_Combining_Class= _Overlay}', ""); +Expect(0, 819, '\p{Canonical_Combining_Class= _Overlay}', ""); +Expect(1, 819, '\p{^Canonical_Combining_Class= _Overlay}', ""); +Expect(1, 819, '\P{Canonical_Combining_Class= _Overlay}', ""); +Expect(0, 819, '\P{^Canonical_Combining_Class= _Overlay}', ""); +Error('\p{Ccc=/a/- OV}'); +Error('\P{Ccc=/a/- OV}'); +Expect(1, 824, '\p{Ccc=ov}', ""); +Expect(0, 824, '\p{^Ccc=ov}', ""); +Expect(0, 824, '\P{Ccc=ov}', ""); +Expect(1, 824, '\P{^Ccc=ov}', ""); +Expect(0, 819, '\p{Ccc=ov}', ""); +Expect(1, 819, '\p{^Ccc=ov}', ""); +Expect(1, 819, '\P{Ccc=ov}', ""); +Expect(0, 819, '\P{^Ccc=ov}', ""); +Expect(1, 824, '\p{Ccc=--OV}', ""); +Expect(0, 824, '\p{^Ccc=--OV}', ""); +Expect(0, 824, '\P{Ccc=--OV}', ""); +Expect(1, 824, '\P{^Ccc=--OV}', ""); +Expect(0, 819, '\p{Ccc=--OV}', ""); +Expect(1, 819, '\p{^Ccc=--OV}', ""); +Expect(1, 819, '\P{Ccc=--OV}', ""); +Expect(0, 819, '\P{^Ccc=--OV}', ""); +Error('\p{Is_Canonical_Combining_Class=/a/0000000001}'); +Error('\P{Is_Canonical_Combining_Class=/a/0000000001}'); +Expect(1, 824, '\p{Is_Canonical_Combining_Class: 0_0_0_0_0_0001}', ""); +Expect(0, 824, '\p{^Is_Canonical_Combining_Class: 0_0_0_0_0_0001}', ""); +Expect(0, 824, '\P{Is_Canonical_Combining_Class: 0_0_0_0_0_0001}', ""); +Expect(1, 824, '\P{^Is_Canonical_Combining_Class: 0_0_0_0_0_0001}', ""); +Expect(0, 819, '\p{Is_Canonical_Combining_Class: 0_0_0_0_0_0001}', ""); +Expect(1, 819, '\p{^Is_Canonical_Combining_Class: 0_0_0_0_0_0001}', ""); +Expect(1, 819, '\P{Is_Canonical_Combining_Class: 0_0_0_0_0_0001}', ""); +Expect(0, 819, '\P{^Is_Canonical_Combining_Class: 0_0_0_0_0_0001}', ""); +Error('\p{Is_Ccc: :=OVERLAY}'); +Error('\P{Is_Ccc: :=OVERLAY}'); +Expect(1, 824, '\p{Is_Ccc=overlay}', ""); +Expect(0, 824, '\p{^Is_Ccc=overlay}', ""); +Expect(0, 824, '\P{Is_Ccc=overlay}', ""); +Expect(1, 824, '\P{^Is_Ccc=overlay}', ""); +Expect(0, 819, '\p{Is_Ccc=overlay}', ""); +Expect(1, 819, '\p{^Is_Ccc=overlay}', ""); +Expect(1, 819, '\P{Is_Ccc=overlay}', ""); +Expect(0, 819, '\P{^Is_Ccc=overlay}', ""); +Expect(1, 824, '\p{Is_Ccc: Overlay}', ""); +Expect(0, 824, '\p{^Is_Ccc: Overlay}', ""); +Expect(0, 824, '\P{Is_Ccc: Overlay}', ""); +Expect(1, 824, '\P{^Is_Ccc: Overlay}', ""); +Expect(0, 819, '\p{Is_Ccc: Overlay}', ""); +Expect(1, 819, '\p{^Is_Ccc: Overlay}', ""); +Expect(1, 819, '\P{Is_Ccc: Overlay}', ""); +Expect(0, 819, '\P{^Is_Ccc: Overlay}', ""); +Error('\p{Canonical_Combining_Class=-Virama:=}'); +Error('\P{Canonical_Combining_Class=-Virama:=}'); +Expect(1, 2381, '\p{Canonical_Combining_Class:virama}', ""); +Expect(0, 2381, '\p{^Canonical_Combining_Class:virama}', ""); +Expect(0, 2381, '\P{Canonical_Combining_Class:virama}', ""); +Expect(1, 2381, '\P{^Canonical_Combining_Class:virama}', ""); +Expect(0, 2380, '\p{Canonical_Combining_Class:virama}', ""); +Expect(1, 2380, '\p{^Canonical_Combining_Class:virama}', ""); +Expect(1, 2380, '\P{Canonical_Combining_Class:virama}', ""); +Expect(0, 2380, '\P{^Canonical_Combining_Class:virama}', ""); +Expect(1, 2381, '\p{Canonical_Combining_Class= VIRAMA}', ""); +Expect(0, 2381, '\p{^Canonical_Combining_Class= VIRAMA}', ""); +Expect(0, 2381, '\P{Canonical_Combining_Class= VIRAMA}', ""); +Expect(1, 2381, '\P{^Canonical_Combining_Class= VIRAMA}', ""); +Expect(0, 2380, '\p{Canonical_Combining_Class= VIRAMA}', ""); +Expect(1, 2380, '\p{^Canonical_Combining_Class= VIRAMA}', ""); +Expect(1, 2380, '\P{Canonical_Combining_Class= VIRAMA}', ""); +Expect(0, 2380, '\P{^Canonical_Combining_Class= VIRAMA}', ""); +Error('\p{Ccc= -vr:=}'); +Error('\P{Ccc= -vr:=}'); +Expect(1, 2381, '\p{Ccc=vr}', ""); +Expect(0, 2381, '\p{^Ccc=vr}', ""); +Expect(0, 2381, '\P{Ccc=vr}', ""); +Expect(1, 2381, '\P{^Ccc=vr}', ""); +Expect(0, 2380, '\p{Ccc=vr}', ""); +Expect(1, 2380, '\p{^Ccc=vr}', ""); +Expect(1, 2380, '\P{Ccc=vr}', ""); +Expect(0, 2380, '\P{^Ccc=vr}', ""); +Expect(1, 2381, '\p{Ccc=-_VR}', ""); +Expect(0, 2381, '\p{^Ccc=-_VR}', ""); +Expect(0, 2381, '\P{Ccc=-_VR}', ""); +Expect(1, 2381, '\P{^Ccc=-_VR}', ""); +Expect(0, 2380, '\p{Ccc=-_VR}', ""); +Expect(1, 2380, '\p{^Ccc=-_VR}', ""); +Expect(1, 2380, '\P{Ccc=-_VR}', ""); +Expect(0, 2380, '\P{^Ccc=-_VR}', ""); +Error('\p{Is_Canonical_Combining_Class=_0_00/a/0_0 0 0 0 09}'); +Error('\P{Is_Canonical_Combining_Class=_0_00/a/0_0 0 0 0 09}'); +Expect(1, 2381, '\p{Is_Canonical_Combining_Class=+0_0_0_0_0009}', ""); +Expect(0, 2381, '\p{^Is_Canonical_Combining_Class=+0_0_0_0_0009}', ""); +Expect(0, 2381, '\P{Is_Canonical_Combining_Class=+0_0_0_0_0009}', ""); +Expect(1, 2381, '\P{^Is_Canonical_Combining_Class=+0_0_0_0_0009}', ""); +Expect(0, 2380, '\p{Is_Canonical_Combining_Class=+0_0_0_0_0009}', ""); +Expect(1, 2380, '\p{^Is_Canonical_Combining_Class=+0_0_0_0_0009}', ""); +Expect(1, 2380, '\P{Is_Canonical_Combining_Class=+0_0_0_0_0009}', ""); +Expect(0, 2380, '\P{^Is_Canonical_Combining_Class=+0_0_0_0_0009}', ""); +Error('\p{Is_Ccc=/a/Virama}'); +Error('\P{Is_Ccc=/a/Virama}'); +Expect(1, 2381, '\p{Is_Ccc=virama}', ""); +Expect(0, 2381, '\p{^Is_Ccc=virama}', ""); +Expect(0, 2381, '\P{Is_Ccc=virama}', ""); +Expect(1, 2381, '\P{^Is_Ccc=virama}', ""); +Expect(0, 2380, '\p{Is_Ccc=virama}', ""); +Expect(1, 2380, '\p{^Is_Ccc=virama}', ""); +Expect(1, 2380, '\P{Is_Ccc=virama}', ""); +Expect(0, 2380, '\P{^Is_Ccc=virama}', ""); +Expect(1, 2381, '\p{Is_Ccc= VIRAMA}', ""); +Expect(0, 2381, '\p{^Is_Ccc= VIRAMA}', ""); +Expect(0, 2381, '\P{Is_Ccc= VIRAMA}', ""); +Expect(1, 2381, '\P{^Is_Ccc= VIRAMA}', ""); +Expect(0, 2380, '\p{Is_Ccc= VIRAMA}', ""); +Expect(1, 2380, '\p{^Is_Ccc= VIRAMA}', ""); +Expect(1, 2380, '\P{Is_Ccc= VIRAMA}', ""); +Expect(0, 2380, '\P{^Is_Ccc= VIRAMA}', ""); +Error('\p{Canonical_Combining_Class= AttachedBelow/a/}'); +Error('\P{Canonical_Combining_Class= AttachedBelow/a/}'); +Expect(1, 802, '\p{Canonical_Combining_Class=attachedbelow}', ""); +Expect(0, 802, '\p{^Canonical_Combining_Class=attachedbelow}', ""); +Expect(0, 802, '\P{Canonical_Combining_Class=attachedbelow}', ""); +Expect(1, 802, '\P{^Canonical_Combining_Class=attachedbelow}', ""); +Expect(0, 800, '\p{Canonical_Combining_Class=attachedbelow}', ""); +Expect(1, 800, '\p{^Canonical_Combining_Class=attachedbelow}', ""); +Expect(1, 800, '\P{Canonical_Combining_Class=attachedbelow}', ""); +Expect(0, 800, '\P{^Canonical_Combining_Class=attachedbelow}', ""); +Expect(1, 802, '\p{Canonical_Combining_Class= Attached Below}', ""); +Expect(0, 802, '\p{^Canonical_Combining_Class= Attached Below}', ""); +Expect(0, 802, '\P{Canonical_Combining_Class= Attached Below}', ""); +Expect(1, 802, '\P{^Canonical_Combining_Class= Attached Below}', ""); +Expect(0, 800, '\p{Canonical_Combining_Class= Attached Below}', ""); +Expect(1, 800, '\p{^Canonical_Combining_Class= Attached Below}', ""); +Expect(1, 800, '\P{Canonical_Combining_Class= Attached Below}', ""); +Expect(0, 800, '\P{^Canonical_Combining_Class= Attached Below}', ""); +Error('\p{Ccc=/a/-_ATB}'); +Error('\P{Ccc=/a/-_ATB}'); +Expect(1, 802, '\p{Ccc=atb}', ""); +Expect(0, 802, '\p{^Ccc=atb}', ""); +Expect(0, 802, '\P{Ccc=atb}', ""); +Expect(1, 802, '\P{^Ccc=atb}', ""); +Expect(0, 800, '\p{Ccc=atb}', ""); +Expect(1, 800, '\p{^Ccc=atb}', ""); +Expect(1, 800, '\P{Ccc=atb}', ""); +Expect(0, 800, '\P{^Ccc=atb}', ""); +Expect(1, 802, '\p{Ccc= ATB}', ""); +Expect(0, 802, '\p{^Ccc= ATB}', ""); +Expect(0, 802, '\P{Ccc= ATB}', ""); +Expect(1, 802, '\P{^Ccc= ATB}', ""); +Expect(0, 800, '\p{Ccc= ATB}', ""); +Expect(1, 800, '\p{^Ccc= ATB}', ""); +Expect(1, 800, '\P{Ccc= ATB}', ""); +Expect(0, 800, '\P{^Ccc= ATB}', ""); +Error('\p{Is_Canonical_Combining_Class= 0000202/a/}'); +Error('\P{Is_Canonical_Combining_Class= 0000202/a/}'); +Expect(1, 802, '\p{Is_Canonical_Combining_Class: +00202}', ""); +Expect(0, 802, '\p{^Is_Canonical_Combining_Class: +00202}', ""); +Expect(0, 802, '\P{Is_Canonical_Combining_Class: +00202}', ""); +Expect(1, 802, '\P{^Is_Canonical_Combining_Class: +00202}', ""); +Expect(0, 800, '\p{Is_Canonical_Combining_Class: +00202}', ""); +Expect(1, 800, '\p{^Is_Canonical_Combining_Class: +00202}', ""); +Expect(1, 800, '\P{Is_Canonical_Combining_Class: +00202}', ""); +Expect(0, 800, '\P{^Is_Canonical_Combining_Class: +00202}', ""); +Error('\p{Is_Ccc=/a/__ATTACHED Below}'); +Error('\P{Is_Ccc=/a/__ATTACHED Below}'); +Expect(1, 802, '\p{Is_Ccc=attachedbelow}', ""); +Expect(0, 802, '\p{^Is_Ccc=attachedbelow}', ""); +Expect(0, 802, '\P{Is_Ccc=attachedbelow}', ""); +Expect(1, 802, '\P{^Is_Ccc=attachedbelow}', ""); +Expect(0, 800, '\p{Is_Ccc=attachedbelow}', ""); +Expect(1, 800, '\p{^Is_Ccc=attachedbelow}', ""); +Expect(1, 800, '\P{Is_Ccc=attachedbelow}', ""); +Expect(0, 800, '\P{^Is_Ccc=attachedbelow}', ""); +Expect(1, 802, '\p{Is_Ccc= _attached_BELOW}', ""); +Expect(0, 802, '\p{^Is_Ccc= _attached_BELOW}', ""); +Expect(0, 802, '\P{Is_Ccc= _attached_BELOW}', ""); +Expect(1, 802, '\P{^Is_Ccc= _attached_BELOW}', ""); +Expect(0, 800, '\p{Is_Ccc= _attached_BELOW}', ""); +Expect(1, 800, '\p{^Is_Ccc= _attached_BELOW}', ""); +Expect(1, 800, '\P{Is_Ccc= _attached_BELOW}', ""); +Expect(0, 800, '\P{^Is_Ccc= _attached_BELOW}', ""); +Error('\p{Canonical_Combining_Class=:=0000014}'); +Error('\P{Canonical_Combining_Class=:=0000014}'); +Expect(1, 1460, '\p{Canonical_Combining_Class=00001_4}', ""); +Expect(0, 1460, '\p{^Canonical_Combining_Class=00001_4}', ""); +Expect(0, 1460, '\P{Canonical_Combining_Class=00001_4}', ""); +Expect(1, 1460, '\P{^Canonical_Combining_Class=00001_4}', ""); +Expect(0, 1459, '\p{Canonical_Combining_Class=00001_4}', ""); +Expect(1, 1459, '\p{^Canonical_Combining_Class=00001_4}', ""); +Expect(1, 1459, '\P{Canonical_Combining_Class=00001_4}', ""); +Expect(0, 1459, '\P{^Canonical_Combining_Class=00001_4}', ""); +Error('\p{Ccc=:=0000000014}'); +Error('\P{Ccc=:=0000000014}'); +Expect(1, 1460, '\p{Ccc=0_0_0_14}', ""); +Expect(0, 1460, '\p{^Ccc=0_0_0_14}', ""); +Expect(0, 1460, '\P{Ccc=0_0_0_14}', ""); +Expect(1, 1460, '\P{^Ccc=0_0_0_14}', ""); +Expect(0, 1459, '\p{Ccc=0_0_0_14}', ""); +Expect(1, 1459, '\p{^Ccc=0_0_0_14}', ""); +Expect(1, 1459, '\P{Ccc=0_0_0_14}', ""); +Expect(0, 1459, '\P{^Ccc=0_0_0_14}', ""); +Error('\p{Is_Canonical_Combining_Class=-0000000014:=}'); +Error('\P{Is_Canonical_Combining_Class=-0000000014:=}'); +Expect(1, 1460, '\p{Is_Canonical_Combining_Class=+014}', ""); +Expect(0, 1460, '\p{^Is_Canonical_Combining_Class=+014}', ""); +Expect(0, 1460, '\P{Is_Canonical_Combining_Class=+014}', ""); +Expect(1, 1460, '\P{^Is_Canonical_Combining_Class=+014}', ""); +Expect(0, 1459, '\p{Is_Canonical_Combining_Class=+014}', ""); +Expect(1, 1459, '\p{^Is_Canonical_Combining_Class=+014}', ""); +Expect(1, 1459, '\P{Is_Canonical_Combining_Class=+014}', ""); +Expect(0, 1459, '\P{^Is_Canonical_Combining_Class=+014}', ""); +Error('\p{Is_Ccc=-_+00_01 4:=}'); +Error('\P{Is_Ccc=-_+00_01 4:=}'); +Expect(1, 1460, '\p{Is_Ccc=0000014}', ""); +Expect(0, 1460, '\p{^Is_Ccc=0000014}', ""); +Expect(0, 1460, '\P{Is_Ccc=0000014}', ""); +Expect(1, 1460, '\P{^Is_Ccc=0000014}', ""); +Expect(0, 1459, '\p{Is_Ccc=0000014}', ""); +Expect(1, 1459, '\p{^Is_Ccc=0000014}', ""); +Expect(1, 1459, '\P{Is_Ccc=0000014}', ""); +Expect(0, 1459, '\P{^Is_Ccc=0000014}', ""); +Error('\p{Canonical_Combining_Class: --0 00-0000024:=}'); +Error('\P{Canonical_Combining_Class: --0 00-0000024:=}'); +Expect(1, 1473, '\p{Canonical_Combining_Class=0_0_0_0_0_0_00024}', ""); +Expect(0, 1473, '\p{^Canonical_Combining_Class=0_0_0_0_0_0_00024}', ""); +Expect(0, 1473, '\P{Canonical_Combining_Class=0_0_0_0_0_0_00024}', ""); +Expect(1, 1473, '\P{^Canonical_Combining_Class=0_0_0_0_0_0_00024}', ""); +Expect(0, 1472, '\p{Canonical_Combining_Class=0_0_0_0_0_0_00024}', ""); +Expect(1, 1472, '\p{^Canonical_Combining_Class=0_0_0_0_0_0_00024}', ""); +Expect(1, 1472, '\P{Canonical_Combining_Class=0_0_0_0_0_0_00024}', ""); +Expect(0, 1472, '\P{^Canonical_Combining_Class=0_0_0_0_0_0_00024}', ""); +Error('\p{Ccc=/a/-00000024}'); +Error('\P{Ccc=/a/-00000024}'); +Expect(1, 1473, '\p{Ccc=000_000_002_4}', ""); +Expect(0, 1473, '\p{^Ccc=000_000_002_4}', ""); +Expect(0, 1473, '\P{Ccc=000_000_002_4}', ""); +Expect(1, 1473, '\P{^Ccc=000_000_002_4}', ""); +Expect(0, 1472, '\p{Ccc=000_000_002_4}', ""); +Expect(1, 1472, '\p{^Ccc=000_000_002_4}', ""); +Expect(1, 1472, '\P{Ccc=000_000_002_4}', ""); +Expect(0, 1472, '\P{^Ccc=000_000_002_4}', ""); +Error('\p{Is_Canonical_Combining_Class=/a/+24}'); +Error('\P{Is_Canonical_Combining_Class=/a/+24}'); +Expect(1, 1473, '\p{Is_Canonical_Combining_Class=0_0_0_0_24}', ""); +Expect(0, 1473, '\p{^Is_Canonical_Combining_Class=0_0_0_0_24}', ""); +Expect(0, 1473, '\P{Is_Canonical_Combining_Class=0_0_0_0_24}', ""); +Expect(1, 1473, '\P{^Is_Canonical_Combining_Class=0_0_0_0_24}', ""); +Expect(0, 1472, '\p{Is_Canonical_Combining_Class=0_0_0_0_24}', ""); +Expect(1, 1472, '\p{^Is_Canonical_Combining_Class=0_0_0_0_24}', ""); +Expect(1, 1472, '\P{Is_Canonical_Combining_Class=0_0_0_0_24}', ""); +Expect(0, 1472, '\P{^Is_Canonical_Combining_Class=0_0_0_0_24}', ""); +Error('\p{Is_Ccc=/a/+0 0 00024}'); +Error('\P{Is_Ccc=/a/+0 0 00024}'); +Expect(1, 1473, '\p{Is_Ccc=0000024}', ""); +Expect(0, 1473, '\p{^Is_Ccc=0000024}', ""); +Expect(0, 1473, '\P{Is_Ccc=0000024}', ""); +Expect(1, 1473, '\P{^Is_Ccc=0000024}', ""); +Expect(0, 1472, '\p{Is_Ccc=0000024}', ""); +Expect(1, 1472, '\p{^Is_Ccc=0000024}', ""); +Expect(1, 1472, '\P{Is_Ccc=0000024}', ""); +Expect(0, 1472, '\P{^Is_Ccc=0000024}', ""); +Error('\p{Canonical_Combining_Class=+0-0-0:=23}'); +Error('\P{Canonical_Combining_Class=+0-0-0:=23}'); +Expect(1, 1471, '\p{Canonical_Combining_Class: 2_3}', ""); +Expect(0, 1471, '\p{^Canonical_Combining_Class: 2_3}', ""); +Expect(0, 1471, '\P{Canonical_Combining_Class: 2_3}', ""); +Expect(1, 1471, '\P{^Canonical_Combining_Class: 2_3}', ""); +Expect(0, 1470, '\p{Canonical_Combining_Class: 2_3}', ""); +Expect(1, 1470, '\p{^Canonical_Combining_Class: 2_3}', ""); +Expect(1, 1470, '\P{Canonical_Combining_Class: 2_3}', ""); +Expect(0, 1470, '\P{^Canonical_Combining_Class: 2_3}', ""); +Error('\p{Ccc=_-+000000023/a/}'); +Error('\P{Ccc=_-+000000023/a/}'); +Expect(1, 1471, '\p{Ccc: 0_0_0_0_0_0_0_0_0_23}', ""); +Expect(0, 1471, '\p{^Ccc: 0_0_0_0_0_0_0_0_0_23}', ""); +Expect(0, 1471, '\P{Ccc: 0_0_0_0_0_0_0_0_0_23}', ""); +Expect(1, 1471, '\P{^Ccc: 0_0_0_0_0_0_0_0_0_23}', ""); +Expect(0, 1470, '\p{Ccc: 0_0_0_0_0_0_0_0_0_23}', ""); +Expect(1, 1470, '\p{^Ccc: 0_0_0_0_0_0_0_0_0_23}', ""); +Expect(1, 1470, '\P{Ccc: 0_0_0_0_0_0_0_0_0_23}', ""); +Expect(0, 1470, '\P{^Ccc: 0_0_0_0_0_0_0_0_0_23}', ""); +Error('\p{Is_Canonical_Combining_Class= _+0023:=}'); +Error('\P{Is_Canonical_Combining_Class= _+0023:=}'); +Expect(1, 1471, '\p{Is_Canonical_Combining_Class=000023}', ""); +Expect(0, 1471, '\p{^Is_Canonical_Combining_Class=000023}', ""); +Expect(0, 1471, '\P{Is_Canonical_Combining_Class=000023}', ""); +Expect(1, 1471, '\P{^Is_Canonical_Combining_Class=000023}', ""); +Expect(0, 1470, '\p{Is_Canonical_Combining_Class=000023}', ""); +Expect(1, 1470, '\p{^Is_Canonical_Combining_Class=000023}', ""); +Expect(1, 1470, '\P{Is_Canonical_Combining_Class=000023}', ""); +Expect(0, 1470, '\P{^Is_Canonical_Combining_Class=000023}', ""); +Error('\p{Is_Ccc=:=_ 00000000023}'); +Error('\P{Is_Ccc=:=_ 00000000023}'); +Expect(1, 1471, '\p{Is_Ccc=00_00_00_23}', ""); +Expect(0, 1471, '\p{^Is_Ccc=00_00_00_23}', ""); +Expect(0, 1471, '\P{Is_Ccc=00_00_00_23}', ""); +Expect(1, 1471, '\P{^Is_Ccc=00_00_00_23}', ""); +Expect(0, 1470, '\p{Is_Ccc=00_00_00_23}', ""); +Expect(1, 1470, '\p{^Is_Ccc=00_00_00_23}', ""); +Expect(1, 1470, '\P{Is_Ccc=00_00_00_23}', ""); +Expect(0, 1470, '\P{^Is_Ccc=00_00_00_23}', ""); +Error('\p{Canonical_Combining_Class=/a/ _Nukta}'); +Error('\P{Canonical_Combining_Class=/a/ _Nukta}'); +Expect(1, 2364, '\p{Canonical_Combining_Class=nukta}', ""); +Expect(0, 2364, '\p{^Canonical_Combining_Class=nukta}', ""); +Expect(0, 2364, '\P{Canonical_Combining_Class=nukta}', ""); +Expect(1, 2364, '\P{^Canonical_Combining_Class=nukta}', ""); +Expect(0, 2363, '\p{Canonical_Combining_Class=nukta}', ""); +Expect(1, 2363, '\p{^Canonical_Combining_Class=nukta}', ""); +Expect(1, 2363, '\P{Canonical_Combining_Class=nukta}', ""); +Expect(0, 2363, '\P{^Canonical_Combining_Class=nukta}', ""); +Expect(1, 2364, '\p{Canonical_Combining_Class=--NUKTA}', ""); +Expect(0, 2364, '\p{^Canonical_Combining_Class=--NUKTA}', ""); +Expect(0, 2364, '\P{Canonical_Combining_Class=--NUKTA}', ""); +Expect(1, 2364, '\P{^Canonical_Combining_Class=--NUKTA}', ""); +Expect(0, 2363, '\p{Canonical_Combining_Class=--NUKTA}', ""); +Expect(1, 2363, '\p{^Canonical_Combining_Class=--NUKTA}', ""); +Expect(1, 2363, '\P{Canonical_Combining_Class=--NUKTA}', ""); +Expect(0, 2363, '\P{^Canonical_Combining_Class=--NUKTA}', ""); +Error('\p{Ccc=-nk/a/}'); +Error('\P{Ccc=-nk/a/}'); +Expect(1, 2364, '\p{Ccc=nk}', ""); +Expect(0, 2364, '\p{^Ccc=nk}', ""); +Expect(0, 2364, '\P{Ccc=nk}', ""); +Expect(1, 2364, '\P{^Ccc=nk}', ""); +Expect(0, 2363, '\p{Ccc=nk}', ""); +Expect(1, 2363, '\p{^Ccc=nk}', ""); +Expect(1, 2363, '\P{Ccc=nk}', ""); +Expect(0, 2363, '\P{^Ccc=nk}', ""); +Expect(1, 2364, '\p{Ccc= NK}', ""); +Expect(0, 2364, '\p{^Ccc= NK}', ""); +Expect(0, 2364, '\P{Ccc= NK}', ""); +Expect(1, 2364, '\P{^Ccc= NK}', ""); +Expect(0, 2363, '\p{Ccc= NK}', ""); +Expect(1, 2363, '\p{^Ccc= NK}', ""); +Expect(1, 2363, '\P{Ccc= NK}', ""); +Expect(0, 2363, '\P{^Ccc= NK}', ""); +Error('\p{Is_Canonical_Combining_Class:--+0000007:=}'); +Error('\P{Is_Canonical_Combining_Class:--+0000007:=}'); +Expect(1, 2364, '\p{Is_Canonical_Combining_Class=007}', ""); +Expect(0, 2364, '\p{^Is_Canonical_Combining_Class=007}', ""); +Expect(0, 2364, '\P{Is_Canonical_Combining_Class=007}', ""); +Expect(1, 2364, '\P{^Is_Canonical_Combining_Class=007}', ""); +Expect(0, 2363, '\p{Is_Canonical_Combining_Class=007}', ""); +Expect(1, 2363, '\p{^Is_Canonical_Combining_Class=007}', ""); +Expect(1, 2363, '\P{Is_Canonical_Combining_Class=007}', ""); +Expect(0, 2363, '\P{^Is_Canonical_Combining_Class=007}', ""); +Error('\p{Is_Ccc: nukta:=}'); +Error('\P{Is_Ccc: nukta:=}'); +Expect(1, 2364, '\p{Is_Ccc: nukta}', ""); +Expect(0, 2364, '\p{^Is_Ccc: nukta}', ""); +Expect(0, 2364, '\P{Is_Ccc: nukta}', ""); +Expect(1, 2364, '\P{^Is_Ccc: nukta}', ""); +Expect(0, 2363, '\p{Is_Ccc: nukta}', ""); +Expect(1, 2363, '\p{^Is_Ccc: nukta}', ""); +Expect(1, 2363, '\P{Is_Ccc: nukta}', ""); +Expect(0, 2363, '\P{^Is_Ccc: nukta}', ""); +Expect(1, 2364, '\p{Is_Ccc= _Nukta}', ""); +Expect(0, 2364, '\p{^Is_Ccc= _Nukta}', ""); +Expect(0, 2364, '\P{Is_Ccc= _Nukta}', ""); +Expect(1, 2364, '\P{^Is_Ccc= _Nukta}', ""); +Expect(0, 2363, '\p{Is_Ccc= _Nukta}', ""); +Expect(1, 2363, '\p{^Is_Ccc= _Nukta}', ""); +Expect(1, 2363, '\P{Is_Ccc= _Nukta}', ""); +Expect(0, 2363, '\P{^Is_Ccc= _Nukta}', ""); +Error('\p{Canonical_Combining_Class=__+000000033:=}'); +Error('\P{Canonical_Combining_Class=__+000000033:=}'); +Expect(1, 1617, '\p{Canonical_Combining_Class=000003_3}', ""); +Expect(0, 1617, '\p{^Canonical_Combining_Class=000003_3}', ""); +Expect(0, 1617, '\P{Canonical_Combining_Class=000003_3}', ""); +Expect(1, 1617, '\P{^Canonical_Combining_Class=000003_3}', ""); +Expect(0, 1616, '\p{Canonical_Combining_Class=000003_3}', ""); +Expect(1, 1616, '\p{^Canonical_Combining_Class=000003_3}', ""); +Expect(1, 1616, '\P{Canonical_Combining_Class=000003_3}', ""); +Expect(0, 1616, '\P{^Canonical_Combining_Class=000003_3}', ""); +Error('\p{Ccc= _+0000003/a/3}'); +Error('\P{Ccc= _+0000003/a/3}'); +Expect(1, 1617, '\p{Ccc=+00000000033}', ""); +Expect(0, 1617, '\p{^Ccc=+00000000033}', ""); +Expect(0, 1617, '\P{Ccc=+00000000033}', ""); +Expect(1, 1617, '\P{^Ccc=+00000000033}', ""); +Expect(0, 1616, '\p{Ccc=+00000000033}', ""); +Expect(1, 1616, '\p{^Ccc=+00000000033}', ""); +Expect(1, 1616, '\P{Ccc=+00000000033}', ""); +Expect(0, 1616, '\P{^Ccc=+00000000033}', ""); +Error('\p{Is_Canonical_Combining_Class: :=+33}'); +Error('\P{Is_Canonical_Combining_Class: :=+33}'); +Expect(1, 1617, '\p{Is_Canonical_Combining_Class=033}', ""); +Expect(0, 1617, '\p{^Is_Canonical_Combining_Class=033}', ""); +Expect(0, 1617, '\P{Is_Canonical_Combining_Class=033}', ""); +Expect(1, 1617, '\P{^Is_Canonical_Combining_Class=033}', ""); +Expect(0, 1616, '\p{Is_Canonical_Combining_Class=033}', ""); +Expect(1, 1616, '\p{^Is_Canonical_Combining_Class=033}', ""); +Expect(1, 1616, '\P{Is_Canonical_Combining_Class=033}', ""); +Expect(0, 1616, '\P{^Is_Canonical_Combining_Class=033}', ""); +Error('\p{Is_Ccc=-_000000033:=}'); +Error('\P{Is_Ccc=-_000000033:=}'); +Expect(1, 1617, '\p{Is_Ccc=+33}', ""); +Expect(0, 1617, '\p{^Is_Ccc=+33}', ""); +Expect(0, 1617, '\P{Is_Ccc=+33}', ""); +Expect(1, 1617, '\P{^Is_Ccc=+33}', ""); +Expect(0, 1616, '\p{Is_Ccc=+33}', ""); +Expect(1, 1616, '\p{^Is_Ccc=+33}', ""); +Expect(1, 1616, '\P{Is_Ccc=+33}', ""); +Expect(0, 1616, '\P{^Is_Ccc=+33}', ""); +Error('\p{Canonical_Combining_Class=_/a/+0-0-0_0_0-0021}'); +Error('\P{Canonical_Combining_Class=_/a/+0-0-0_0_0-0021}'); +Expect(1, 1468, '\p{Canonical_Combining_Class=0_0_21}', ""); +Expect(0, 1468, '\p{^Canonical_Combining_Class=0_0_21}', ""); +Expect(0, 1468, '\P{Canonical_Combining_Class=0_0_21}', ""); +Expect(1, 1468, '\P{^Canonical_Combining_Class=0_0_21}', ""); +Expect(0, 1467, '\p{Canonical_Combining_Class=0_0_21}', ""); +Expect(1, 1467, '\p{^Canonical_Combining_Class=0_0_21}', ""); +Expect(1, 1467, '\P{Canonical_Combining_Class=0_0_21}', ""); +Expect(0, 1467, '\P{^Canonical_Combining_Class=0_0_21}', ""); +Error('\p{Ccc: _00:=0 0_0-00 0021}'); +Error('\P{Ccc: _00:=0 0_0-00 0021}'); +Expect(1, 1468, '\p{Ccc=21}', ""); +Expect(0, 1468, '\p{^Ccc=21}', ""); +Expect(0, 1468, '\P{Ccc=21}', ""); +Expect(1, 1468, '\P{^Ccc=21}', ""); +Expect(0, 1467, '\p{Ccc=21}', ""); +Expect(1, 1467, '\p{^Ccc=21}', ""); +Expect(1, 1467, '\P{Ccc=21}', ""); +Expect(0, 1467, '\P{^Ccc=21}', ""); +Error('\p{Is_Canonical_Combining_Class=_/a/+0000021}'); +Error('\P{Is_Canonical_Combining_Class=_/a/+0000021}'); +Expect(1, 1468, '\p{Is_Canonical_Combining_Class=021}', ""); +Expect(0, 1468, '\p{^Is_Canonical_Combining_Class=021}', ""); +Expect(0, 1468, '\P{Is_Canonical_Combining_Class=021}', ""); +Expect(1, 1468, '\P{^Is_Canonical_Combining_Class=021}', ""); +Expect(0, 1467, '\p{Is_Canonical_Combining_Class=021}', ""); +Expect(1, 1467, '\p{^Is_Canonical_Combining_Class=021}', ""); +Expect(1, 1467, '\P{Is_Canonical_Combining_Class=021}', ""); +Expect(0, 1467, '\P{^Is_Canonical_Combining_Class=021}', ""); +Error('\p{Is_Ccc=:= 002-1}'); +Error('\P{Is_Ccc=:= 002-1}'); +Expect(1, 1468, '\p{Is_Ccc=00000021}', ""); +Expect(0, 1468, '\p{^Is_Ccc=00000021}', ""); +Expect(0, 1468, '\P{Is_Ccc=00000021}', ""); +Expect(1, 1468, '\P{^Is_Ccc=00000021}', ""); +Expect(0, 1467, '\p{Is_Ccc=00000021}', ""); +Expect(1, 1467, '\p{^Is_Ccc=00000021}', ""); +Expect(1, 1467, '\P{Is_Ccc=00000021}', ""); +Expect(0, 1467, '\P{^Is_Ccc=00000021}', ""); +Error('\p{Canonical_Combining_Class= 0_0 0 0 0:=00026}'); +Error('\P{Canonical_Combining_Class= 0_0 0 0 0:=00026}'); +Expect(1, 64286, '\p{Canonical_Combining_Class=002_6}', ""); +Expect(0, 64286, '\p{^Canonical_Combining_Class=002_6}', ""); +Expect(0, 64286, '\P{Canonical_Combining_Class=002_6}', ""); +Expect(1, 64286, '\P{^Canonical_Combining_Class=002_6}', ""); +Expect(0, 64285, '\p{Canonical_Combining_Class=002_6}', ""); +Expect(1, 64285, '\p{^Canonical_Combining_Class=002_6}', ""); +Expect(1, 64285, '\P{Canonical_Combining_Class=002_6}', ""); +Expect(0, 64285, '\P{^Canonical_Combining_Class=002_6}', ""); +Error('\p{Ccc=_ 000000026:=}'); +Error('\P{Ccc=_ 000000026:=}'); +Expect(1, 64286, '\p{Ccc=+00000026}', ""); +Expect(0, 64286, '\p{^Ccc=+00000026}', ""); +Expect(0, 64286, '\P{Ccc=+00000026}', ""); +Expect(1, 64286, '\P{^Ccc=+00000026}', ""); +Expect(0, 64285, '\p{Ccc=+00000026}', ""); +Expect(1, 64285, '\p{^Ccc=+00000026}', ""); +Expect(1, 64285, '\P{Ccc=+00000026}', ""); +Expect(0, 64285, '\P{^Ccc=+00000026}', ""); +Error('\p{Is_Canonical_Combining_Class=_-+0026/a/}'); +Error('\P{Is_Canonical_Combining_Class=_-+0026/a/}'); +Expect(1, 64286, '\p{Is_Canonical_Combining_Class=+00026}', ""); +Expect(0, 64286, '\p{^Is_Canonical_Combining_Class=+00026}', ""); +Expect(0, 64286, '\P{Is_Canonical_Combining_Class=+00026}', ""); +Expect(1, 64286, '\P{^Is_Canonical_Combining_Class=+00026}', ""); +Expect(0, 64285, '\p{Is_Canonical_Combining_Class=+00026}', ""); +Expect(1, 64285, '\p{^Is_Canonical_Combining_Class=+00026}', ""); +Expect(1, 64285, '\P{Is_Canonical_Combining_Class=+00026}', ""); +Expect(0, 64285, '\P{^Is_Canonical_Combining_Class=+00026}', ""); +Error('\p{Is_Ccc=--+0-0_0:=00026}'); +Error('\P{Is_Ccc=--+0-0_0:=00026}'); +Expect(1, 64286, '\p{Is_Ccc=00000026}', ""); +Expect(0, 64286, '\p{^Is_Ccc=00000026}', ""); +Expect(0, 64286, '\P{Is_Ccc=00000026}', ""); +Expect(1, 64286, '\P{^Is_Ccc=00000026}', ""); +Expect(0, 64285, '\p{Is_Ccc=00000026}', ""); +Expect(1, 64285, '\p{^Is_Ccc=00000026}', ""); +Expect(1, 64285, '\P{Is_Ccc=00000026}', ""); +Expect(0, 64285, '\P{^Is_Ccc=00000026}', ""); +Error('\p{Canonical_Combining_Class=-0000103:=}'); +Error('\P{Canonical_Combining_Class=-0000103:=}'); +Expect(1, 3641, '\p{Canonical_Combining_Class=0000103}', ""); +Expect(0, 3641, '\p{^Canonical_Combining_Class=0000103}', ""); +Expect(0, 3641, '\P{Canonical_Combining_Class=0000103}', ""); +Expect(1, 3641, '\P{^Canonical_Combining_Class=0000103}', ""); +Expect(0, 3639, '\p{Canonical_Combining_Class=0000103}', ""); +Expect(1, 3639, '\p{^Canonical_Combining_Class=0000103}', ""); +Expect(1, 3639, '\P{Canonical_Combining_Class=0000103}', ""); +Expect(0, 3639, '\P{^Canonical_Combining_Class=0000103}', ""); +Error('\p{Ccc: 10 3/a/}'); +Error('\P{Ccc: 10 3/a/}'); +Expect(1, 3641, '\p{Ccc=000103}', ""); +Expect(0, 3641, '\p{^Ccc=000103}', ""); +Expect(0, 3641, '\P{Ccc=000103}', ""); +Expect(1, 3641, '\P{^Ccc=000103}', ""); +Expect(0, 3639, '\p{Ccc=000103}', ""); +Expect(1, 3639, '\p{^Ccc=000103}', ""); +Expect(1, 3639, '\P{Ccc=000103}', ""); +Expect(0, 3639, '\P{^Ccc=000103}', ""); +Error('\p{Is_Canonical_Combining_Class=-/a/+103}'); +Error('\P{Is_Canonical_Combining_Class=-/a/+103}'); +Expect(1, 3641, '\p{Is_Canonical_Combining_Class=10_3}', ""); +Expect(0, 3641, '\p{^Is_Canonical_Combining_Class=10_3}', ""); +Expect(0, 3641, '\P{Is_Canonical_Combining_Class=10_3}', ""); +Expect(1, 3641, '\P{^Is_Canonical_Combining_Class=10_3}', ""); +Expect(0, 3639, '\p{Is_Canonical_Combining_Class=10_3}', ""); +Expect(1, 3639, '\p{^Is_Canonical_Combining_Class=10_3}', ""); +Expect(1, 3639, '\P{Is_Canonical_Combining_Class=10_3}', ""); +Expect(0, 3639, '\P{^Is_Canonical_Combining_Class=10_3}', ""); +Error('\p{Is_Ccc: /a/__00000000103}'); +Error('\P{Is_Ccc: /a/__00000000103}'); +Expect(1, 3641, '\p{Is_Ccc=103}', ""); +Expect(0, 3641, '\p{^Is_Ccc=103}', ""); +Expect(0, 3641, '\P{Is_Ccc=103}', ""); +Expect(1, 3641, '\P{^Is_Ccc=103}', ""); +Expect(0, 3639, '\p{Is_Ccc=103}', ""); +Expect(1, 3639, '\p{^Is_Ccc=103}', ""); +Expect(1, 3639, '\P{Is_Ccc=103}', ""); +Expect(0, 3639, '\P{^Is_Ccc=103}', ""); +Error('\p{Canonical_Combining_Class=:=010}'); +Error('\P{Canonical_Combining_Class=:=010}'); +Expect(1, 1456, '\p{Canonical_Combining_Class=00000010}', ""); +Expect(0, 1456, '\p{^Canonical_Combining_Class=00000010}', ""); +Expect(0, 1456, '\P{Canonical_Combining_Class=00000010}', ""); +Expect(1, 1456, '\P{^Canonical_Combining_Class=00000010}', ""); +Expect(0, 1455, '\p{Canonical_Combining_Class=00000010}', ""); +Expect(1, 1455, '\p{^Canonical_Combining_Class=00000010}', ""); +Expect(1, 1455, '\P{Canonical_Combining_Class=00000010}', ""); +Expect(0, 1455, '\P{^Canonical_Combining_Class=00000010}', ""); +Error('\p{Ccc= _0000000010:=}'); +Error('\P{Ccc= _0000000010:=}'); +Expect(1, 1456, '\p{Ccc=1_0}', ""); +Expect(0, 1456, '\p{^Ccc=1_0}', ""); +Expect(0, 1456, '\P{Ccc=1_0}', ""); +Expect(1, 1456, '\P{^Ccc=1_0}', ""); +Expect(0, 1455, '\p{Ccc=1_0}', ""); +Expect(1, 1455, '\p{^Ccc=1_0}', ""); +Expect(1, 1455, '\P{Ccc=1_0}', ""); +Expect(0, 1455, '\P{^Ccc=1_0}', ""); +Error('\p{Is_Canonical_Combining_Class=- 010/a/}'); +Error('\P{Is_Canonical_Combining_Class=- 010/a/}'); +Expect(1, 1456, '\p{Is_Canonical_Combining_Class=0_0_0_0_0010}', ""); +Expect(0, 1456, '\p{^Is_Canonical_Combining_Class=0_0_0_0_0010}', ""); +Expect(0, 1456, '\P{Is_Canonical_Combining_Class=0_0_0_0_0010}', ""); +Expect(1, 1456, '\P{^Is_Canonical_Combining_Class=0_0_0_0_0010}', ""); +Expect(0, 1455, '\p{Is_Canonical_Combining_Class=0_0_0_0_0010}', ""); +Expect(1, 1455, '\p{^Is_Canonical_Combining_Class=0_0_0_0_0010}', ""); +Expect(1, 1455, '\P{Is_Canonical_Combining_Class=0_0_0_0_0010}', ""); +Expect(0, 1455, '\P{^Is_Canonical_Combining_Class=0_0_0_0_0010}', ""); +Error('\p{Is_Ccc=:=_ 0000010}'); +Error('\P{Is_Ccc=:=_ 0000010}'); +Expect(1, 1456, '\p{Is_Ccc=0_0_0_10}', ""); +Expect(0, 1456, '\p{^Is_Ccc=0_0_0_10}', ""); +Expect(0, 1456, '\P{Is_Ccc=0_0_0_10}', ""); +Expect(1, 1456, '\P{^Is_Ccc=0_0_0_10}', ""); +Expect(0, 1455, '\p{Is_Ccc=0_0_0_10}', ""); +Expect(1, 1455, '\p{^Is_Ccc=0_0_0_10}', ""); +Expect(1, 1455, '\P{Is_Ccc=0_0_0_10}', ""); +Expect(0, 1455, '\P{^Is_Ccc=0_0_0_10}', ""); +Error('\p{Canonical_Combining_Class=_:=+0091}'); +Error('\P{Canonical_Combining_Class=_:=+0091}'); +Expect(1, 3158, '\p{Canonical_Combining_Class=+00_00_00_091}', ""); +Expect(0, 3158, '\p{^Canonical_Combining_Class=+00_00_00_091}', ""); +Expect(0, 3158, '\P{Canonical_Combining_Class=+00_00_00_091}', ""); +Expect(1, 3158, '\P{^Canonical_Combining_Class=+00_00_00_091}', ""); +Expect(0, 3157, '\p{Canonical_Combining_Class=+00_00_00_091}', ""); +Expect(1, 3157, '\p{^Canonical_Combining_Class=+00_00_00_091}', ""); +Expect(1, 3157, '\P{Canonical_Combining_Class=+00_00_00_091}', ""); +Expect(0, 3157, '\P{^Canonical_Combining_Class=+00_00_00_091}', ""); +Error('\p{Ccc=--+000000091/a/}'); +Error('\P{Ccc=--+000000091/a/}'); +Expect(1, 3158, '\p{Ccc=+0_0_0_0_0_00091}', ""); +Expect(0, 3158, '\p{^Ccc=+0_0_0_0_0_00091}', ""); +Expect(0, 3158, '\P{Ccc=+0_0_0_0_0_00091}', ""); +Expect(1, 3158, '\P{^Ccc=+0_0_0_0_0_00091}', ""); +Expect(0, 3157, '\p{Ccc=+0_0_0_0_0_00091}', ""); +Expect(1, 3157, '\p{^Ccc=+0_0_0_0_0_00091}', ""); +Expect(1, 3157, '\P{Ccc=+0_0_0_0_0_00091}', ""); +Expect(0, 3157, '\P{^Ccc=+0_0_0_0_0_00091}', ""); +Error('\p{Is_Canonical_Combining_Class=-/a/0000000091}'); +Error('\P{Is_Canonical_Combining_Class=-/a/0000000091}'); +Expect(1, 3158, '\p{Is_Canonical_Combining_Class=000091}', ""); +Expect(0, 3158, '\p{^Is_Canonical_Combining_Class=000091}', ""); +Expect(0, 3158, '\P{Is_Canonical_Combining_Class=000091}', ""); +Expect(1, 3158, '\P{^Is_Canonical_Combining_Class=000091}', ""); +Expect(0, 3157, '\p{Is_Canonical_Combining_Class=000091}', ""); +Expect(1, 3157, '\p{^Is_Canonical_Combining_Class=000091}', ""); +Expect(1, 3157, '\P{Is_Canonical_Combining_Class=000091}', ""); +Expect(0, 3157, '\P{^Is_Canonical_Combining_Class=000091}', ""); +Error('\p{Is_Ccc=/a/__+000000 000 91}'); +Error('\P{Is_Ccc=/a/__+000000 000 91}'); +Expect(1, 3158, '\p{Is_Ccc=0_0_0_0_0_0_91}', ""); +Expect(0, 3158, '\p{^Is_Ccc=0_0_0_0_0_0_91}', ""); +Expect(0, 3158, '\P{Is_Ccc=0_0_0_0_0_0_91}', ""); +Expect(1, 3158, '\P{^Is_Ccc=0_0_0_0_0_0_91}', ""); +Expect(0, 3157, '\p{Is_Ccc=0_0_0_0_0_0_91}', ""); +Expect(1, 3157, '\p{^Is_Ccc=0_0_0_0_0_0_91}', ""); +Expect(1, 3157, '\P{Is_Ccc=0_0_0_0_0_0_91}', ""); +Expect(0, 3157, '\P{^Is_Ccc=0_0_0_0_0_0_91}', ""); +Error('\p{Canonical_Combining_Class= 010-7:=}'); +Error('\P{Canonical_Combining_Class= 010-7:=}'); +Expect(1, 3659, '\p{Canonical_Combining_Class:00000107}', ""); +Expect(0, 3659, '\p{^Canonical_Combining_Class:00000107}', ""); +Expect(0, 3659, '\P{Canonical_Combining_Class:00000107}', ""); +Expect(1, 3659, '\P{^Canonical_Combining_Class:00000107}', ""); +Expect(0, 3655, '\p{Canonical_Combining_Class:00000107}', ""); +Expect(1, 3655, '\p{^Canonical_Combining_Class:00000107}', ""); +Expect(1, 3655, '\P{Canonical_Combining_Class:00000107}', ""); +Expect(0, 3655, '\P{^Canonical_Combining_Class:00000107}', ""); +Error('\p{Ccc=:=_+000000107}'); +Error('\P{Ccc=:=_+000000107}'); +Expect(1, 3659, '\p{Ccc=0010_7}', ""); +Expect(0, 3659, '\p{^Ccc=0010_7}', ""); +Expect(0, 3659, '\P{Ccc=0010_7}', ""); +Expect(1, 3659, '\P{^Ccc=0010_7}', ""); +Expect(0, 3655, '\p{Ccc=0010_7}', ""); +Expect(1, 3655, '\p{^Ccc=0010_7}', ""); +Expect(1, 3655, '\P{Ccc=0010_7}', ""); +Expect(0, 3655, '\P{^Ccc=0010_7}', ""); +Error('\p{Is_Canonical_Combining_Class= +00000000010:=7}'); +Error('\P{Is_Canonical_Combining_Class= +00000000010:=7}'); +Expect(1, 3659, '\p{Is_Canonical_Combining_Class=0000000107}', ""); +Expect(0, 3659, '\p{^Is_Canonical_Combining_Class=0000000107}', ""); +Expect(0, 3659, '\P{Is_Canonical_Combining_Class=0000000107}', ""); +Expect(1, 3659, '\P{^Is_Canonical_Combining_Class=0000000107}', ""); +Expect(0, 3655, '\p{Is_Canonical_Combining_Class=0000000107}', ""); +Expect(1, 3655, '\p{^Is_Canonical_Combining_Class=0000000107}', ""); +Expect(1, 3655, '\P{Is_Canonical_Combining_Class=0000000107}', ""); +Expect(0, 3655, '\P{^Is_Canonical_Combining_Class=0000000107}', ""); +Error('\p{Is_Ccc= +10/a/7}'); +Error('\P{Is_Ccc= +10/a/7}'); +Expect(1, 3659, '\p{Is_Ccc=0_0_0_0_1_07}', ""); +Expect(0, 3659, '\p{^Is_Ccc=0_0_0_0_1_07}', ""); +Expect(0, 3659, '\P{Is_Ccc=0_0_0_0_1_07}', ""); +Expect(1, 3659, '\P{^Is_Ccc=0_0_0_0_1_07}', ""); +Expect(0, 3655, '\p{Is_Ccc=0_0_0_0_1_07}', ""); +Expect(1, 3655, '\p{^Is_Ccc=0_0_0_0_1_07}', ""); +Expect(1, 3655, '\P{Is_Ccc=0_0_0_0_1_07}', ""); +Expect(0, 3655, '\P{^Is_Ccc=0_0_0_0_1_07}', ""); +Error('\p{Canonical_Combining_Class=-00000000214/a/}'); +Error('\P{Canonical_Combining_Class=-00000000214/a/}'); +Expect(1, 7630, '\p{Canonical_Combining_Class=+0000214}', ""); +Expect(0, 7630, '\p{^Canonical_Combining_Class=+0000214}', ""); +Expect(0, 7630, '\P{Canonical_Combining_Class=+0000214}', ""); +Expect(1, 7630, '\P{^Canonical_Combining_Class=+0000214}', ""); +Expect(0, 7629, '\p{Canonical_Combining_Class=+0000214}', ""); +Expect(1, 7629, '\p{^Canonical_Combining_Class=+0000214}', ""); +Expect(1, 7629, '\P{Canonical_Combining_Class=+0000214}', ""); +Expect(0, 7629, '\P{^Canonical_Combining_Class=+0000214}', ""); +Error('\p{Ccc=/a/ -+0000214}'); +Error('\P{Ccc=/a/ -+0000214}'); +Expect(1, 7630, '\p{Ccc=+0021_4}', ""); +Expect(0, 7630, '\p{^Ccc=+0021_4}', ""); +Expect(0, 7630, '\P{Ccc=+0021_4}', ""); +Expect(1, 7630, '\P{^Ccc=+0021_4}', ""); +Expect(0, 7629, '\p{Ccc=+0021_4}', ""); +Expect(1, 7629, '\p{^Ccc=+0021_4}', ""); +Expect(1, 7629, '\P{Ccc=+0021_4}', ""); +Expect(0, 7629, '\P{^Ccc=+0021_4}', ""); +Error('\p{Is_Canonical_Combining_Class= _0-0 0:=0-0-0 0 0 0_214}'); +Error('\P{Is_Canonical_Combining_Class= _0-0 0:=0-0-0 0 0 0_214}'); +Expect(1, 7630, '\p{Is_Canonical_Combining_Class: +0_0_0_2_14}', ""); +Expect(0, 7630, '\p{^Is_Canonical_Combining_Class: +0_0_0_2_14}', ""); +Expect(0, 7630, '\P{Is_Canonical_Combining_Class: +0_0_0_2_14}', ""); +Expect(1, 7630, '\P{^Is_Canonical_Combining_Class: +0_0_0_2_14}', ""); +Expect(0, 7629, '\p{Is_Canonical_Combining_Class: +0_0_0_2_14}', ""); +Expect(1, 7629, '\p{^Is_Canonical_Combining_Class: +0_0_0_2_14}', ""); +Expect(1, 7629, '\P{Is_Canonical_Combining_Class: +0_0_0_2_14}', ""); +Expect(0, 7629, '\P{^Is_Canonical_Combining_Class: +0_0_0_2_14}', ""); +Error('\p{Is_Ccc: _+021 4/a/}'); +Error('\P{Is_Ccc: _+021 4/a/}'); +Expect(1, 7630, '\p{Is_Ccc=0000021_4}', ""); +Expect(0, 7630, '\p{^Is_Ccc=0000021_4}', ""); +Expect(0, 7630, '\P{Is_Ccc=0000021_4}', ""); +Expect(1, 7630, '\P{^Is_Ccc=0000021_4}', ""); +Expect(0, 7629, '\p{Is_Ccc=0000021_4}', ""); +Expect(1, 7629, '\p{^Is_Ccc=0000021_4}', ""); +Expect(1, 7629, '\P{Is_Ccc=0000021_4}', ""); +Expect(0, 7629, '\P{^Is_Ccc=0000021_4}', ""); +Error('\p{Canonical_Combining_Class= :=00 00_00 00 01 2}'); +Error('\P{Canonical_Combining_Class= :=00 00_00 00 01 2}'); +Expect(1, 1458, '\p{Canonical_Combining_Class=00000000012}', ""); +Expect(0, 1458, '\p{^Canonical_Combining_Class=00000000012}', ""); +Expect(0, 1458, '\P{Canonical_Combining_Class=00000000012}', ""); +Expect(1, 1458, '\P{^Canonical_Combining_Class=00000000012}', ""); +Expect(0, 1457, '\p{Canonical_Combining_Class=00000000012}', ""); +Expect(1, 1457, '\p{^Canonical_Combining_Class=00000000012}', ""); +Expect(1, 1457, '\P{Canonical_Combining_Class=00000000012}', ""); +Expect(0, 1457, '\P{^Canonical_Combining_Class=00000000012}', ""); +Error('\p{Ccc=-/a/12}'); +Error('\P{Ccc=-/a/12}'); +Expect(1, 1458, '\p{Ccc: 0000000012}', ""); +Expect(0, 1458, '\p{^Ccc: 0000000012}', ""); +Expect(0, 1458, '\P{Ccc: 0000000012}', ""); +Expect(1, 1458, '\P{^Ccc: 0000000012}', ""); +Expect(0, 1457, '\p{Ccc: 0000000012}', ""); +Expect(1, 1457, '\p{^Ccc: 0000000012}', ""); +Expect(1, 1457, '\P{Ccc: 0000000012}', ""); +Expect(0, 1457, '\P{^Ccc: 0000000012}', ""); +Error('\p{Is_Canonical_Combining_Class=:=- 01-2}'); +Error('\P{Is_Canonical_Combining_Class=:=- 01-2}'); +Expect(1, 1458, '\p{Is_Canonical_Combining_Class=0_0_0_0_12}', ""); +Expect(0, 1458, '\p{^Is_Canonical_Combining_Class=0_0_0_0_12}', ""); +Expect(0, 1458, '\P{Is_Canonical_Combining_Class=0_0_0_0_12}', ""); +Expect(1, 1458, '\P{^Is_Canonical_Combining_Class=0_0_0_0_12}', ""); +Expect(0, 1457, '\p{Is_Canonical_Combining_Class=0_0_0_0_12}', ""); +Expect(1, 1457, '\p{^Is_Canonical_Combining_Class=0_0_0_0_12}', ""); +Expect(1, 1457, '\P{Is_Canonical_Combining_Class=0_0_0_0_12}', ""); +Expect(0, 1457, '\P{^Is_Canonical_Combining_Class=0_0_0_0_12}', ""); +Error('\p{Is_Ccc=-/a/00000000012}'); +Error('\P{Is_Ccc=-/a/00000000012}'); +Expect(1, 1458, '\p{Is_Ccc=12}', ""); +Expect(0, 1458, '\p{^Is_Ccc=12}', ""); +Expect(0, 1458, '\P{Is_Ccc=12}', ""); +Expect(1, 1458, '\P{^Is_Ccc=12}', ""); +Expect(0, 1457, '\p{Is_Ccc=12}', ""); +Expect(1, 1457, '\p{^Is_Ccc=12}', ""); +Expect(1, 1457, '\P{Is_Ccc=12}', ""); +Expect(0, 1457, '\P{^Is_Ccc=12}', ""); +Error('\p{Canonical_Combining_Class=_:=0000000019}'); +Error('\P{Canonical_Combining_Class=_:=0000000019}'); +Expect(1, 1466, '\p{Canonical_Combining_Class=00000019}', ""); +Expect(0, 1466, '\p{^Canonical_Combining_Class=00000019}', ""); +Expect(0, 1466, '\P{Canonical_Combining_Class=00000019}', ""); +Expect(1, 1466, '\P{^Canonical_Combining_Class=00000019}', ""); +Expect(0, 1464, '\p{Canonical_Combining_Class=00000019}', ""); +Expect(1, 1464, '\p{^Canonical_Combining_Class=00000019}', ""); +Expect(1, 1464, '\P{Canonical_Combining_Class=00000019}', ""); +Expect(0, 1464, '\P{^Canonical_Combining_Class=00000019}', ""); +Error('\p{Ccc: _000019/a/}'); +Error('\P{Ccc: _000019/a/}'); +Expect(1, 1466, '\p{Ccc=0_0_0_0_0_019}', ""); +Expect(0, 1466, '\p{^Ccc=0_0_0_0_0_019}', ""); +Expect(0, 1466, '\P{Ccc=0_0_0_0_0_019}', ""); +Expect(1, 1466, '\P{^Ccc=0_0_0_0_0_019}', ""); +Expect(0, 1464, '\p{Ccc=0_0_0_0_0_019}', ""); +Expect(1, 1464, '\p{^Ccc=0_0_0_0_0_019}', ""); +Expect(1, 1464, '\P{Ccc=0_0_0_0_0_019}', ""); +Expect(0, 1464, '\P{^Ccc=0_0_0_0_0_019}', ""); +Error('\p{Is_Canonical_Combining_Class= 000/a/001_9}'); +Error('\P{Is_Canonical_Combining_Class= 000/a/001_9}'); +Expect(1, 1466, '\p{Is_Canonical_Combining_Class=01_9}', ""); +Expect(0, 1466, '\p{^Is_Canonical_Combining_Class=01_9}', ""); +Expect(0, 1466, '\P{Is_Canonical_Combining_Class=01_9}', ""); +Expect(1, 1466, '\P{^Is_Canonical_Combining_Class=01_9}', ""); +Expect(0, 1464, '\p{Is_Canonical_Combining_Class=01_9}', ""); +Expect(1, 1464, '\p{^Is_Canonical_Combining_Class=01_9}', ""); +Expect(1, 1464, '\P{Is_Canonical_Combining_Class=01_9}', ""); +Expect(0, 1464, '\P{^Is_Canonical_Combining_Class=01_9}', ""); +Error('\p{Is_Ccc=_0 0 00/a/0_00019}'); +Error('\P{Is_Ccc=_0 0 00/a/0_00019}'); +Expect(1, 1466, '\p{Is_Ccc=0_0_19}', ""); +Expect(0, 1466, '\p{^Is_Ccc=0_0_19}', ""); +Expect(0, 1466, '\P{Is_Ccc=0_0_19}', ""); +Expect(1, 1466, '\P{^Is_Ccc=0_0_19}', ""); +Expect(0, 1464, '\p{Is_Ccc=0_0_19}', ""); +Expect(1, 1464, '\p{^Is_Ccc=0_0_19}', ""); +Expect(1, 1464, '\P{Is_Ccc=0_0_19}', ""); +Expect(0, 1464, '\P{^Is_Ccc=0_0_19}', ""); +Error('\p{Canonical_Combining_Class: /a/-_030}'); +Error('\P{Canonical_Combining_Class: /a/-_030}'); +Expect(1, 1560, '\p{Canonical_Combining_Class=0_0_30}', ""); +Expect(0, 1560, '\p{^Canonical_Combining_Class=0_0_30}', ""); +Expect(0, 1560, '\P{Canonical_Combining_Class=0_0_30}', ""); +Expect(1, 1560, '\P{^Canonical_Combining_Class=0_0_30}', ""); +Expect(0, 1559, '\p{Canonical_Combining_Class=0_0_30}', ""); +Expect(1, 1559, '\p{^Canonical_Combining_Class=0_0_30}', ""); +Expect(1, 1559, '\P{Canonical_Combining_Class=0_0_30}', ""); +Expect(0, 1559, '\P{^Canonical_Combining_Class=0_0_30}', ""); +Error('\p{Ccc= +03:=0}'); +Error('\P{Ccc= +03:=0}'); +Expect(1, 1560, '\p{Ccc=0000_0003_0}', ""); +Expect(0, 1560, '\p{^Ccc=0000_0003_0}', ""); +Expect(0, 1560, '\P{Ccc=0000_0003_0}', ""); +Expect(1, 1560, '\P{^Ccc=0000_0003_0}', ""); +Expect(0, 1559, '\p{Ccc=0000_0003_0}', ""); +Expect(1, 1559, '\p{^Ccc=0000_0003_0}', ""); +Expect(1, 1559, '\P{Ccc=0000_0003_0}', ""); +Expect(0, 1559, '\P{^Ccc=0000_0003_0}', ""); +Error('\p{Is_Canonical_Combining_Class=/a/000003-0}'); +Error('\P{Is_Canonical_Combining_Class=/a/000003-0}'); +Expect(1, 1560, '\p{Is_Canonical_Combining_Class=+00000030}', ""); +Expect(0, 1560, '\p{^Is_Canonical_Combining_Class=+00000030}', ""); +Expect(0, 1560, '\P{Is_Canonical_Combining_Class=+00000030}', ""); +Expect(1, 1560, '\P{^Is_Canonical_Combining_Class=+00000030}', ""); +Expect(0, 1559, '\p{Is_Canonical_Combining_Class=+00000030}', ""); +Expect(1, 1559, '\p{^Is_Canonical_Combining_Class=+00000030}', ""); +Expect(1, 1559, '\P{Is_Canonical_Combining_Class=+00000030}', ""); +Expect(0, 1559, '\P{^Is_Canonical_Combining_Class=+00000030}', ""); +Error('\p{Is_Ccc=__+0000030:=}'); +Error('\P{Is_Ccc=__+0000030:=}'); +Expect(1, 1560, '\p{Is_Ccc:0000030}', ""); +Expect(0, 1560, '\p{^Is_Ccc:0000030}', ""); +Expect(0, 1560, '\P{Is_Ccc:0000030}', ""); +Expect(1, 1560, '\P{^Is_Ccc:0000030}', ""); +Expect(0, 1559, '\p{Is_Ccc:0000030}', ""); +Expect(1, 1559, '\p{^Is_Ccc:0000030}', ""); +Expect(1, 1559, '\P{Is_Ccc:0000030}', ""); +Expect(0, 1559, '\P{^Is_Ccc:0000030}', ""); +Error('\p{Canonical_Combining_Class= :=0000-0002-5}'); +Error('\P{Canonical_Combining_Class= :=0000-0002-5}'); +Expect(1, 1474, '\p{Canonical_Combining_Class=0_0_0_025}', ""); +Expect(0, 1474, '\p{^Canonical_Combining_Class=0_0_0_025}', ""); +Expect(0, 1474, '\P{Canonical_Combining_Class=0_0_0_025}', ""); +Expect(1, 1474, '\P{^Canonical_Combining_Class=0_0_0_025}', ""); +Expect(0, 1473, '\p{Canonical_Combining_Class=0_0_0_025}', ""); +Expect(1, 1473, '\p{^Canonical_Combining_Class=0_0_0_025}', ""); +Expect(1, 1473, '\P{Canonical_Combining_Class=0_0_0_025}', ""); +Expect(0, 1473, '\P{^Canonical_Combining_Class=0_0_0_025}', ""); +Error('\p{Ccc=-/a/00000002-5}'); +Error('\P{Ccc=-/a/00000002-5}'); +Expect(1, 1474, '\p{Ccc=02_5}', ""); +Expect(0, 1474, '\p{^Ccc=02_5}', ""); +Expect(0, 1474, '\P{Ccc=02_5}', ""); +Expect(1, 1474, '\P{^Ccc=02_5}', ""); +Expect(0, 1473, '\p{Ccc=02_5}', ""); +Expect(1, 1473, '\p{^Ccc=02_5}', ""); +Expect(1, 1473, '\P{Ccc=02_5}', ""); +Expect(0, 1473, '\P{^Ccc=02_5}', ""); +Error('\p{Is_Canonical_Combining_Class=-:=00 00 00025}'); +Error('\P{Is_Canonical_Combining_Class=-:=00 00 00025}'); +Expect(1, 1474, '\p{Is_Canonical_Combining_Class=025}', ""); +Expect(0, 1474, '\p{^Is_Canonical_Combining_Class=025}', ""); +Expect(0, 1474, '\P{Is_Canonical_Combining_Class=025}', ""); +Expect(1, 1474, '\P{^Is_Canonical_Combining_Class=025}', ""); +Expect(0, 1473, '\p{Is_Canonical_Combining_Class=025}', ""); +Expect(1, 1473, '\p{^Is_Canonical_Combining_Class=025}', ""); +Expect(1, 1473, '\P{Is_Canonical_Combining_Class=025}', ""); +Expect(0, 1473, '\P{^Is_Canonical_Combining_Class=025}', ""); +Error('\p{Is_Ccc: -00/a/02 5}'); +Error('\P{Is_Ccc: -00/a/02 5}'); +Expect(1, 1474, '\p{Is_Ccc: +0_0_0_0_0_0_25}', ""); +Expect(0, 1474, '\p{^Is_Ccc: +0_0_0_0_0_0_25}', ""); +Expect(0, 1474, '\P{Is_Ccc: +0_0_0_0_0_0_25}', ""); +Expect(1, 1474, '\P{^Is_Ccc: +0_0_0_0_0_0_25}', ""); +Expect(0, 1473, '\p{Is_Ccc: +0_0_0_0_0_0_25}', ""); +Expect(1, 1473, '\p{^Is_Ccc: +0_0_0_0_0_0_25}', ""); +Expect(1, 1473, '\P{Is_Ccc: +0_0_0_0_0_0_25}', ""); +Expect(0, 1473, '\P{^Is_Ccc: +0_0_0_0_0_0_25}', ""); +Error('\p{Canonical_Combining_Class=_+0028:=}'); +Error('\P{Canonical_Combining_Class=_+0028:=}'); +Expect(1, 1612, '\p{Canonical_Combining_Class=+2_8}', ""); +Expect(0, 1612, '\p{^Canonical_Combining_Class=+2_8}', ""); +Expect(0, 1612, '\P{Canonical_Combining_Class=+2_8}', ""); +Expect(1, 1612, '\P{^Canonical_Combining_Class=+2_8}', ""); +Expect(0, 1611, '\p{Canonical_Combining_Class=+2_8}', ""); +Expect(1, 1611, '\p{^Canonical_Combining_Class=+2_8}', ""); +Expect(1, 1611, '\P{Canonical_Combining_Class=+2_8}', ""); +Expect(0, 1611, '\P{^Canonical_Combining_Class=+2_8}', ""); +Error('\p{Ccc=-_00 00 00:=28}'); +Error('\P{Ccc=-_00 00 00:=28}'); +Expect(1, 1612, '\p{Ccc=+0028}', ""); +Expect(0, 1612, '\p{^Ccc=+0028}', ""); +Expect(0, 1612, '\P{Ccc=+0028}', ""); +Expect(1, 1612, '\P{^Ccc=+0028}', ""); +Expect(0, 1611, '\p{Ccc=+0028}', ""); +Expect(1, 1611, '\p{^Ccc=+0028}', ""); +Expect(1, 1611, '\P{Ccc=+0028}', ""); +Expect(0, 1611, '\P{^Ccc=+0028}', ""); +Error('\p{Is_Canonical_Combining_Class: 00002:=8}'); +Error('\P{Is_Canonical_Combining_Class: 00002:=8}'); +Expect(1, 1612, '\p{Is_Canonical_Combining_Class:2_8}', ""); +Expect(0, 1612, '\p{^Is_Canonical_Combining_Class:2_8}', ""); +Expect(0, 1612, '\P{Is_Canonical_Combining_Class:2_8}', ""); +Expect(1, 1612, '\P{^Is_Canonical_Combining_Class:2_8}', ""); +Expect(0, 1611, '\p{Is_Canonical_Combining_Class:2_8}', ""); +Expect(1, 1611, '\p{^Is_Canonical_Combining_Class:2_8}', ""); +Expect(1, 1611, '\P{Is_Canonical_Combining_Class:2_8}', ""); +Expect(0, 1611, '\P{^Is_Canonical_Combining_Class:2_8}', ""); +Error('\p{Is_Ccc=_ 000028:=}'); +Error('\P{Is_Ccc=_ 000028:=}'); +Expect(1, 1612, '\p{Is_Ccc=0_0_0_0_28}', ""); +Expect(0, 1612, '\p{^Is_Ccc=0_0_0_0_28}', ""); +Expect(0, 1612, '\P{Is_Ccc=0_0_0_0_28}', ""); +Expect(1, 1612, '\P{^Is_Ccc=0_0_0_0_28}', ""); +Expect(0, 1611, '\p{Is_Ccc=0_0_0_0_28}', ""); +Expect(1, 1611, '\p{^Is_Ccc=0_0_0_0_28}', ""); +Expect(1, 1611, '\P{Is_Ccc=0_0_0_0_28}', ""); +Expect(0, 1611, '\P{^Is_Ccc=0_0_0_0_28}', ""); +Error('\p{Canonical_Combining_Class=-_00-00 00/a/130}'); +Error('\P{Canonical_Combining_Class=-_00-00 00/a/130}'); +Expect(1, 3954, '\p{Canonical_Combining_Class: 0000013_0}', ""); +Expect(0, 3954, '\p{^Canonical_Combining_Class: 0000013_0}', ""); +Expect(0, 3954, '\P{Canonical_Combining_Class: 0000013_0}', ""); +Expect(1, 3954, '\P{^Canonical_Combining_Class: 0000013_0}', ""); +Expect(0, 3953, '\p{Canonical_Combining_Class: 0000013_0}', ""); +Expect(1, 3953, '\p{^Canonical_Combining_Class: 0000013_0}', ""); +Expect(1, 3953, '\P{Canonical_Combining_Class: 0000013_0}', ""); +Expect(0, 3953, '\P{^Canonical_Combining_Class: 0000013_0}', ""); +Error('\p{Ccc=__+00_00 00:=130}'); +Error('\P{Ccc=__+00_00 00:=130}'); +Expect(1, 3954, '\p{Ccc=000000000130}', ""); +Expect(0, 3954, '\p{^Ccc=000000000130}', ""); +Expect(0, 3954, '\P{Ccc=000000000130}', ""); +Expect(1, 3954, '\P{^Ccc=000000000130}', ""); +Expect(0, 3953, '\p{Ccc=000000000130}', ""); +Expect(1, 3953, '\p{^Ccc=000000000130}', ""); +Expect(1, 3953, '\P{Ccc=000000000130}', ""); +Expect(0, 3953, '\P{^Ccc=000000000130}', ""); +Error('\p{Is_Canonical_Combining_Class=:=_+000000000130}'); +Error('\P{Is_Canonical_Combining_Class=:=_+000000000130}'); +Expect(1, 3954, '\p{Is_Canonical_Combining_Class=+000000013_0}', ""); +Expect(0, 3954, '\p{^Is_Canonical_Combining_Class=+000000013_0}', ""); +Expect(0, 3954, '\P{Is_Canonical_Combining_Class=+000000013_0}', ""); +Expect(1, 3954, '\P{^Is_Canonical_Combining_Class=+000000013_0}', ""); +Expect(0, 3953, '\p{Is_Canonical_Combining_Class=+000000013_0}', ""); +Expect(1, 3953, '\p{^Is_Canonical_Combining_Class=+000000013_0}', ""); +Expect(1, 3953, '\P{Is_Canonical_Combining_Class=+000000013_0}', ""); +Expect(0, 3953, '\P{^Is_Canonical_Combining_Class=+000000013_0}', ""); +Error('\p{Is_Ccc=__+00_00:=00-13 0}'); +Error('\P{Is_Ccc=__+00_00:=00-13 0}'); +Expect(1, 3954, '\p{Is_Ccc: 0_0_0_1_30}', ""); +Expect(0, 3954, '\p{^Is_Ccc: 0_0_0_1_30}', ""); +Expect(0, 3954, '\P{Is_Ccc: 0_0_0_1_30}', ""); +Expect(1, 3954, '\P{^Is_Ccc: 0_0_0_1_30}', ""); +Expect(0, 3953, '\p{Is_Ccc: 0_0_0_1_30}', ""); +Expect(1, 3953, '\p{^Is_Ccc: 0_0_0_1_30}', ""); +Expect(1, 3953, '\P{Is_Ccc: 0_0_0_1_30}', ""); +Expect(0, 3953, '\P{^Is_Ccc: 0_0_0_1_30}', ""); +Error('\p{Canonical_Combining_Class=/a/0000000122}'); +Error('\P{Canonical_Combining_Class=/a/0000000122}'); +Expect(1, 3787, '\p{Canonical_Combining_Class=+0000000122}', ""); +Expect(0, 3787, '\p{^Canonical_Combining_Class=+0000000122}', ""); +Expect(0, 3787, '\P{Canonical_Combining_Class=+0000000122}', ""); +Expect(1, 3787, '\P{^Canonical_Combining_Class=+0000000122}', ""); +Expect(0, 3783, '\p{Canonical_Combining_Class=+0000000122}', ""); +Expect(1, 3783, '\p{^Canonical_Combining_Class=+0000000122}', ""); +Expect(1, 3783, '\P{Canonical_Combining_Class=+0000000122}', ""); +Expect(0, 3783, '\P{^Canonical_Combining_Class=+0000000122}', ""); +Error('\p{Ccc=- 000000122/a/}'); +Error('\P{Ccc=- 000000122/a/}'); +Expect(1, 3787, '\p{Ccc=+00000000012_2}', ""); +Expect(0, 3787, '\p{^Ccc=+00000000012_2}', ""); +Expect(0, 3787, '\P{Ccc=+00000000012_2}', ""); +Expect(1, 3787, '\P{^Ccc=+00000000012_2}', ""); +Expect(0, 3783, '\p{Ccc=+00000000012_2}', ""); +Expect(1, 3783, '\p{^Ccc=+00000000012_2}', ""); +Expect(1, 3783, '\P{Ccc=+00000000012_2}', ""); +Expect(0, 3783, '\P{^Ccc=+00000000012_2}', ""); +Error('\p{Is_Canonical_Combining_Class=:=_ 00000122}'); +Error('\P{Is_Canonical_Combining_Class=:=_ 00000122}'); +Expect(1, 3787, '\p{Is_Canonical_Combining_Class=0_0_0_0_0_0_0_0_0122}', ""); +Expect(0, 3787, '\p{^Is_Canonical_Combining_Class=0_0_0_0_0_0_0_0_0122}', ""); +Expect(0, 3787, '\P{Is_Canonical_Combining_Class=0_0_0_0_0_0_0_0_0122}', ""); +Expect(1, 3787, '\P{^Is_Canonical_Combining_Class=0_0_0_0_0_0_0_0_0122}', ""); +Expect(0, 3783, '\p{Is_Canonical_Combining_Class=0_0_0_0_0_0_0_0_0122}', ""); +Expect(1, 3783, '\p{^Is_Canonical_Combining_Class=0_0_0_0_0_0_0_0_0122}', ""); +Expect(1, 3783, '\P{Is_Canonical_Combining_Class=0_0_0_0_0_0_0_0_0122}', ""); +Expect(0, 3783, '\P{^Is_Canonical_Combining_Class=0_0_0_0_0_0_0_0_0122}', ""); +Error('\p{Is_Ccc= _0122:=}'); +Error('\P{Is_Ccc= _0122:=}'); +Expect(1, 3787, '\p{Is_Ccc=+0122}', ""); +Expect(0, 3787, '\p{^Is_Ccc=+0122}', ""); +Expect(0, 3787, '\P{Is_Ccc=+0122}', ""); +Expect(1, 3787, '\P{^Is_Ccc=+0122}', ""); +Expect(0, 3783, '\p{Is_Ccc=+0122}', ""); +Expect(1, 3783, '\p{^Is_Ccc=+0122}', ""); +Expect(1, 3783, '\P{Is_Ccc=+0122}', ""); +Expect(0, 3783, '\P{^Is_Ccc=+0122}', ""); +Error('\p{Canonical_Combining_Class=_:=22}'); +Error('\P{Canonical_Combining_Class=_:=22}'); +Expect(1, 1469, '\p{Canonical_Combining_Class=+0_0_0_0_0022}', ""); +Expect(0, 1469, '\p{^Canonical_Combining_Class=+0_0_0_0_0022}', ""); +Expect(0, 1469, '\P{Canonical_Combining_Class=+0_0_0_0_0022}', ""); +Expect(1, 1469, '\P{^Canonical_Combining_Class=+0_0_0_0_0022}', ""); +Expect(0, 1468, '\p{Canonical_Combining_Class=+0_0_0_0_0022}', ""); +Expect(1, 1468, '\p{^Canonical_Combining_Class=+0_0_0_0_0022}', ""); +Expect(1, 1468, '\P{Canonical_Combining_Class=+0_0_0_0_0022}', ""); +Expect(0, 1468, '\P{^Canonical_Combining_Class=+0_0_0_0_0022}', ""); +Error('\p{Ccc=:=- 0000000022}'); +Error('\P{Ccc=:=- 0000000022}'); +Expect(1, 1469, '\p{Ccc=0_0_22}', ""); +Expect(0, 1469, '\p{^Ccc=0_0_22}', ""); +Expect(0, 1469, '\P{Ccc=0_0_22}', ""); +Expect(1, 1469, '\P{^Ccc=0_0_22}', ""); +Expect(0, 1468, '\p{Ccc=0_0_22}', ""); +Expect(1, 1468, '\p{^Ccc=0_0_22}', ""); +Expect(1, 1468, '\P{Ccc=0_0_22}', ""); +Expect(0, 1468, '\P{^Ccc=0_0_22}', ""); +Error('\p{Is_Canonical_Combining_Class=0 0/a/00-0-00022}'); +Error('\P{Is_Canonical_Combining_Class=0 0/a/00-0-00022}'); +Expect(1, 1469, '\p{Is_Canonical_Combining_Class=+000022}', ""); +Expect(0, 1469, '\p{^Is_Canonical_Combining_Class=+000022}', ""); +Expect(0, 1469, '\P{Is_Canonical_Combining_Class=+000022}', ""); +Expect(1, 1469, '\P{^Is_Canonical_Combining_Class=+000022}', ""); +Expect(0, 1468, '\p{Is_Canonical_Combining_Class=+000022}', ""); +Expect(1, 1468, '\p{^Is_Canonical_Combining_Class=+000022}', ""); +Expect(1, 1468, '\P{Is_Canonical_Combining_Class=+000022}', ""); +Expect(0, 1468, '\P{^Is_Canonical_Combining_Class=+000022}', ""); +Error('\p{Is_Ccc=/a/ -00000000022}'); +Error('\P{Is_Ccc=/a/ -00000000022}'); +Expect(1, 1469, '\p{Is_Ccc=000000002_2}', ""); +Expect(0, 1469, '\p{^Is_Ccc=000000002_2}', ""); +Expect(0, 1469, '\P{Is_Ccc=000000002_2}', ""); +Expect(1, 1469, '\P{^Is_Ccc=000000002_2}', ""); +Expect(0, 1468, '\p{Is_Ccc=000000002_2}', ""); +Expect(1, 1468, '\p{^Is_Ccc=000000002_2}', ""); +Expect(1, 1468, '\P{Is_Ccc=000000002_2}', ""); +Expect(0, 1468, '\P{^Is_Ccc=000000002_2}', ""); +Error('\p{Canonical_Combining_Class= -1/a/3}'); +Error('\P{Canonical_Combining_Class= -1/a/3}'); +Expect(1, 1459, '\p{Canonical_Combining_Class: 00000000013}', ""); +Expect(0, 1459, '\p{^Canonical_Combining_Class: 00000000013}', ""); +Expect(0, 1459, '\P{Canonical_Combining_Class: 00000000013}', ""); +Expect(1, 1459, '\P{^Canonical_Combining_Class: 00000000013}', ""); +Expect(0, 1458, '\p{Canonical_Combining_Class: 00000000013}', ""); +Expect(1, 1458, '\p{^Canonical_Combining_Class: 00000000013}', ""); +Expect(1, 1458, '\P{Canonical_Combining_Class: 00000000013}', ""); +Expect(0, 1458, '\P{^Canonical_Combining_Class: 00000000013}', ""); +Error('\p{Ccc=:=+00 0001-3}'); +Error('\P{Ccc=:=+00 0001-3}'); +Expect(1, 1459, '\p{Ccc=00013}', ""); +Expect(0, 1459, '\p{^Ccc=00013}', ""); +Expect(0, 1459, '\P{Ccc=00013}', ""); +Expect(1, 1459, '\P{^Ccc=00013}', ""); +Expect(0, 1458, '\p{Ccc=00013}', ""); +Expect(1, 1458, '\p{^Ccc=00013}', ""); +Expect(1, 1458, '\P{Ccc=00013}', ""); +Expect(0, 1458, '\P{^Ccc=00013}', ""); +Error('\p{Is_Canonical_Combining_Class= :=01_3}'); +Error('\P{Is_Canonical_Combining_Class= :=01_3}'); +Expect(1, 1459, '\p{Is_Canonical_Combining_Class=0000013}', ""); +Expect(0, 1459, '\p{^Is_Canonical_Combining_Class=0000013}', ""); +Expect(0, 1459, '\P{Is_Canonical_Combining_Class=0000013}', ""); +Expect(1, 1459, '\P{^Is_Canonical_Combining_Class=0000013}', ""); +Expect(0, 1458, '\p{Is_Canonical_Combining_Class=0000013}', ""); +Expect(1, 1458, '\p{^Is_Canonical_Combining_Class=0000013}', ""); +Expect(1, 1458, '\P{Is_Canonical_Combining_Class=0000013}', ""); +Expect(0, 1458, '\P{^Is_Canonical_Combining_Class=0000013}', ""); +Error('\p{Is_Ccc= 00_01:=3}'); +Error('\P{Is_Ccc= 00_01:=3}'); +Expect(1, 1459, '\p{Is_Ccc=0_0_0_0_0_0_0_0013}', ""); +Expect(0, 1459, '\p{^Is_Ccc=0_0_0_0_0_0_0_0013}', ""); +Expect(0, 1459, '\P{Is_Ccc=0_0_0_0_0_0_0_0013}', ""); +Expect(1, 1459, '\P{^Is_Ccc=0_0_0_0_0_0_0_0013}', ""); +Expect(0, 1458, '\p{Is_Ccc=0_0_0_0_0_0_0_0013}', ""); +Expect(1, 1458, '\p{^Is_Ccc=0_0_0_0_0_0_0_0013}', ""); +Expect(1, 1458, '\P{Is_Ccc=0_0_0_0_0_0_0_0013}', ""); +Expect(0, 1458, '\P{^Is_Ccc=0_0_0_0_0_0_0_0013}', ""); +Error('\p{Canonical_Combining_Class= _00:=0000 036}'); +Error('\P{Canonical_Combining_Class= _00:=0000 036}'); +Expect(1, 1809, '\p{Canonical_Combining_Class=+00036}', ""); +Expect(0, 1809, '\p{^Canonical_Combining_Class=+00036}', ""); +Expect(0, 1809, '\P{Canonical_Combining_Class=+00036}', ""); +Expect(1, 1809, '\P{^Canonical_Combining_Class=+00036}', ""); +Expect(0, 1808, '\p{Canonical_Combining_Class=+00036}', ""); +Expect(1, 1808, '\p{^Canonical_Combining_Class=+00036}', ""); +Expect(1, 1808, '\P{Canonical_Combining_Class=+00036}', ""); +Expect(0, 1808, '\P{^Canonical_Combining_Class=+00036}', ""); +Error('\p{Ccc: /a/_+00000000036}'); +Error('\P{Ccc: /a/_+00000000036}'); +Expect(1, 1809, '\p{Ccc=0036}', ""); +Expect(0, 1809, '\p{^Ccc=0036}', ""); +Expect(0, 1809, '\P{Ccc=0036}', ""); +Expect(1, 1809, '\P{^Ccc=0036}', ""); +Expect(0, 1808, '\p{Ccc=0036}', ""); +Expect(1, 1808, '\p{^Ccc=0036}', ""); +Expect(1, 1808, '\P{Ccc=0036}', ""); +Expect(0, 1808, '\P{^Ccc=0036}', ""); +Error('\p{Is_Canonical_Combining_Class= 036/a/}'); +Error('\P{Is_Canonical_Combining_Class= 036/a/}'); +Expect(1, 1809, '\p{Is_Canonical_Combining_Class=00_00_00_00_36}', ""); +Expect(0, 1809, '\p{^Is_Canonical_Combining_Class=00_00_00_00_36}', ""); +Expect(0, 1809, '\P{Is_Canonical_Combining_Class=00_00_00_00_36}', ""); +Expect(1, 1809, '\P{^Is_Canonical_Combining_Class=00_00_00_00_36}', ""); +Expect(0, 1808, '\p{Is_Canonical_Combining_Class=00_00_00_00_36}', ""); +Expect(1, 1808, '\p{^Is_Canonical_Combining_Class=00_00_00_00_36}', ""); +Expect(1, 1808, '\P{Is_Canonical_Combining_Class=00_00_00_00_36}', ""); +Expect(0, 1808, '\P{^Is_Canonical_Combining_Class=00_00_00_00_36}', ""); +Error('\p{Is_Ccc=/a/_-36}'); +Error('\P{Is_Ccc=/a/_-36}'); +Expect(1, 1809, '\p{Is_Ccc=+036}', ""); +Expect(0, 1809, '\p{^Is_Ccc=+036}', ""); +Expect(0, 1809, '\P{Is_Ccc=+036}', ""); +Expect(1, 1809, '\P{^Is_Ccc=+036}', ""); +Expect(0, 1808, '\p{Is_Ccc=+036}', ""); +Expect(1, 1808, '\p{^Is_Ccc=+036}', ""); +Expect(1, 1808, '\P{Is_Ccc=+036}', ""); +Expect(0, 1808, '\P{^Is_Ccc=+036}', ""); +Error('\p{Canonical_Combining_Class: +0:=0 0 00_0-0-034}'); +Error('\P{Canonical_Combining_Class: +0:=0 0 00_0-0-034}'); +Expect(1, 1618, '\p{Canonical_Combining_Class=00_03_4}', ""); +Expect(0, 1618, '\p{^Canonical_Combining_Class=00_03_4}', ""); +Expect(0, 1618, '\P{Canonical_Combining_Class=00_03_4}', ""); +Expect(1, 1618, '\P{^Canonical_Combining_Class=00_03_4}', ""); +Expect(0, 1617, '\p{Canonical_Combining_Class=00_03_4}', ""); +Expect(1, 1617, '\p{^Canonical_Combining_Class=00_03_4}', ""); +Expect(1, 1617, '\P{Canonical_Combining_Class=00_03_4}', ""); +Expect(0, 1617, '\P{^Canonical_Combining_Class=00_03_4}', ""); +Error('\p{Ccc=00:=00 00 00 34}'); +Error('\P{Ccc=00:=00 00 00 34}'); +Expect(1, 1618, '\p{Ccc=0000034}', ""); +Expect(0, 1618, '\p{^Ccc=0000034}', ""); +Expect(0, 1618, '\P{Ccc=0000034}', ""); +Expect(1, 1618, '\P{^Ccc=0000034}', ""); +Expect(0, 1617, '\p{Ccc=0000034}', ""); +Expect(1, 1617, '\p{^Ccc=0000034}', ""); +Expect(1, 1617, '\P{Ccc=0000034}', ""); +Expect(0, 1617, '\P{^Ccc=0000034}', ""); +Error('\p{Is_Canonical_Combining_Class: /a/+00034}'); +Error('\P{Is_Canonical_Combining_Class: /a/+00034}'); +Expect(1, 1618, '\p{Is_Canonical_Combining_Class=0000000034}', ""); +Expect(0, 1618, '\p{^Is_Canonical_Combining_Class=0000000034}', ""); +Expect(0, 1618, '\P{Is_Canonical_Combining_Class=0000000034}', ""); +Expect(1, 1618, '\P{^Is_Canonical_Combining_Class=0000000034}', ""); +Expect(0, 1617, '\p{Is_Canonical_Combining_Class=0000000034}', ""); +Expect(1, 1617, '\p{^Is_Canonical_Combining_Class=0000000034}', ""); +Expect(1, 1617, '\P{Is_Canonical_Combining_Class=0000000034}', ""); +Expect(0, 1617, '\P{^Is_Canonical_Combining_Class=0000000034}', ""); +Error('\p{Is_Ccc=:= 00034}'); +Error('\P{Is_Ccc=:= 00034}'); +Expect(1, 1618, '\p{Is_Ccc=+000000034}', ""); +Expect(0, 1618, '\p{^Is_Ccc=+000000034}', ""); +Expect(0, 1618, '\P{Is_Ccc=+000000034}', ""); +Expect(1, 1618, '\P{^Is_Ccc=+000000034}', ""); +Expect(0, 1617, '\p{Is_Ccc=+000000034}', ""); +Expect(1, 1617, '\p{^Is_Ccc=+000000034}', ""); +Expect(1, 1617, '\P{Is_Ccc=+000000034}', ""); +Expect(0, 1617, '\P{^Is_Ccc=+000000034}', ""); +Error('\p{Canonical_Combining_Class= /a/000132}'); +Error('\P{Canonical_Combining_Class= /a/000132}'); +Expect(1, 3956, '\p{Canonical_Combining_Class=0_0_0_0_0_00132}', ""); +Expect(0, 3956, '\p{^Canonical_Combining_Class=0_0_0_0_0_00132}', ""); +Expect(0, 3956, '\P{Canonical_Combining_Class=0_0_0_0_0_00132}', ""); +Expect(1, 3956, '\P{^Canonical_Combining_Class=0_0_0_0_0_00132}', ""); +Expect(0, 3955, '\p{Canonical_Combining_Class=0_0_0_0_0_00132}', ""); +Expect(1, 3955, '\p{^Canonical_Combining_Class=0_0_0_0_0_00132}', ""); +Expect(1, 3955, '\P{Canonical_Combining_Class=0_0_0_0_0_00132}', ""); +Expect(0, 3955, '\P{^Canonical_Combining_Class=0_0_0_0_0_00132}', ""); +Error('\p{Ccc=/a/+0000132}'); +Error('\P{Ccc=/a/+0000132}'); +Expect(1, 3956, '\p{Ccc=132}', ""); +Expect(0, 3956, '\p{^Ccc=132}', ""); +Expect(0, 3956, '\P{Ccc=132}', ""); +Expect(1, 3956, '\P{^Ccc=132}', ""); +Expect(0, 3955, '\p{Ccc=132}', ""); +Expect(1, 3955, '\p{^Ccc=132}', ""); +Expect(1, 3955, '\P{Ccc=132}', ""); +Expect(0, 3955, '\P{^Ccc=132}', ""); +Error('\p{Is_Canonical_Combining_Class=-:=0_0 00 0-0 1-32}'); +Error('\P{Is_Canonical_Combining_Class=-:=0_0 00 0-0 1-32}'); +Expect(1, 3956, '\p{Is_Canonical_Combining_Class=000000132}', ""); +Expect(0, 3956, '\p{^Is_Canonical_Combining_Class=000000132}', ""); +Expect(0, 3956, '\P{Is_Canonical_Combining_Class=000000132}', ""); +Expect(1, 3956, '\P{^Is_Canonical_Combining_Class=000000132}', ""); +Expect(0, 3955, '\p{Is_Canonical_Combining_Class=000000132}', ""); +Expect(1, 3955, '\p{^Is_Canonical_Combining_Class=000000132}', ""); +Expect(1, 3955, '\P{Is_Canonical_Combining_Class=000000132}', ""); +Expect(0, 3955, '\P{^Is_Canonical_Combining_Class=000000132}', ""); +Error('\p{Is_Ccc=00132/a/}'); +Error('\P{Is_Ccc=00132/a/}'); +Expect(1, 3956, '\p{Is_Ccc=0000132}', ""); +Expect(0, 3956, '\p{^Is_Ccc=0000132}', ""); +Expect(0, 3956, '\P{Is_Ccc=0000132}', ""); +Expect(1, 3956, '\P{^Is_Ccc=0000132}', ""); +Expect(0, 3955, '\p{Is_Ccc=0000132}', ""); +Expect(1, 3955, '\p{^Is_Ccc=0000132}', ""); +Expect(1, 3955, '\P{Is_Ccc=0000132}', ""); +Expect(0, 3955, '\P{^Is_Ccc=0000132}', ""); +Error('\p{Bidi_Class= segment separator:=}'); +Error('\P{Bidi_Class= segment separator:=}'); +Expect(1, 9, '\p{Bidi_Class=segmentseparator}', ""); +Expect(0, 9, '\p{^Bidi_Class=segmentseparator}', ""); +Expect(0, 9, '\P{Bidi_Class=segmentseparator}', ""); +Expect(1, 9, '\P{^Bidi_Class=segmentseparator}', ""); +Expect(0, 8, '\p{Bidi_Class=segmentseparator}', ""); +Expect(1, 8, '\p{^Bidi_Class=segmentseparator}', ""); +Expect(1, 8, '\P{Bidi_Class=segmentseparator}', ""); +Expect(0, 8, '\P{^Bidi_Class=segmentseparator}', ""); +Expect(1, 9, '\p{Bidi_Class= Segment SEPARATOR}', ""); +Expect(0, 9, '\p{^Bidi_Class= Segment SEPARATOR}', ""); +Expect(0, 9, '\P{Bidi_Class= Segment SEPARATOR}', ""); +Expect(1, 9, '\P{^Bidi_Class= Segment SEPARATOR}', ""); +Expect(0, 8, '\p{Bidi_Class= Segment SEPARATOR}', ""); +Expect(1, 8, '\p{^Bidi_Class= Segment SEPARATOR}', ""); +Expect(1, 8, '\P{Bidi_Class= Segment SEPARATOR}', ""); +Expect(0, 8, '\P{^Bidi_Class= Segment SEPARATOR}', ""); +Error('\p{Bc=:= S}'); +Error('\P{Bc=:= S}'); +Expect(1, 9, '\p{Bc=s}', ""); +Expect(0, 9, '\p{^Bc=s}', ""); +Expect(0, 9, '\P{Bc=s}', ""); +Expect(1, 9, '\P{^Bc=s}', ""); +Expect(0, 8, '\p{Bc=s}', ""); +Expect(1, 8, '\p{^Bc=s}', ""); +Expect(1, 8, '\P{Bc=s}', ""); +Expect(0, 8, '\P{^Bc=s}', ""); +Expect(1, 9, '\p{Bc= -S}', ""); +Expect(0, 9, '\p{^Bc= -S}', ""); +Expect(0, 9, '\P{Bc= -S}', ""); +Expect(1, 9, '\P{^Bc= -S}', ""); +Expect(0, 8, '\p{Bc= -S}', ""); +Expect(1, 8, '\p{^Bc= -S}', ""); +Expect(1, 8, '\P{Bc= -S}', ""); +Expect(0, 8, '\P{^Bc= -S}', ""); +Error('\p{Is_Bidi_Class=:=- Segment separator}'); +Error('\P{Is_Bidi_Class=:=- Segment separator}'); +Expect(1, 9, '\p{Is_Bidi_Class=segmentseparator}', ""); +Expect(0, 9, '\p{^Is_Bidi_Class=segmentseparator}', ""); +Expect(0, 9, '\P{Is_Bidi_Class=segmentseparator}', ""); +Expect(1, 9, '\P{^Is_Bidi_Class=segmentseparator}', ""); +Expect(0, 8, '\p{Is_Bidi_Class=segmentseparator}', ""); +Expect(1, 8, '\p{^Is_Bidi_Class=segmentseparator}', ""); +Expect(1, 8, '\P{Is_Bidi_Class=segmentseparator}', ""); +Expect(0, 8, '\P{^Is_Bidi_Class=segmentseparator}', ""); +Expect(1, 9, '\p{Is_Bidi_Class: _segment SEPARATOR}', ""); +Expect(0, 9, '\p{^Is_Bidi_Class: _segment SEPARATOR}', ""); +Expect(0, 9, '\P{Is_Bidi_Class: _segment SEPARATOR}', ""); +Expect(1, 9, '\P{^Is_Bidi_Class: _segment SEPARATOR}', ""); +Expect(0, 8, '\p{Is_Bidi_Class: _segment SEPARATOR}', ""); +Expect(1, 8, '\p{^Is_Bidi_Class: _segment SEPARATOR}', ""); +Expect(1, 8, '\P{Is_Bidi_Class: _segment SEPARATOR}', ""); +Expect(0, 8, '\P{^Is_Bidi_Class: _segment SEPARATOR}', ""); +Error('\p{Is_Bc=/a/S}'); +Error('\P{Is_Bc=/a/S}'); +Expect(1, 9, '\p{Is_Bc=s}', ""); +Expect(0, 9, '\p{^Is_Bc=s}', ""); +Expect(0, 9, '\P{Is_Bc=s}', ""); +Expect(1, 9, '\P{^Is_Bc=s}', ""); +Expect(0, 8, '\p{Is_Bc=s}', ""); +Expect(1, 8, '\p{^Is_Bc=s}', ""); +Expect(1, 8, '\P{Is_Bc=s}', ""); +Expect(0, 8, '\P{^Is_Bc=s}', ""); +Expect(1, 9, '\p{Is_Bc= s}', ""); +Expect(0, 9, '\p{^Is_Bc= s}', ""); +Expect(0, 9, '\P{Is_Bc= s}', ""); +Expect(1, 9, '\P{^Is_Bc= s}', ""); +Expect(0, 8, '\p{Is_Bc= s}', ""); +Expect(1, 8, '\p{^Is_Bc= s}', ""); +Expect(1, 8, '\P{Is_Bc= s}', ""); +Expect(0, 8, '\P{^Is_Bc= s}', ""); +Error('\p{Bidi_Class= :=RIGHT TO-left-override}'); +Error('\P{Bidi_Class= :=RIGHT TO-left-override}'); +Expect(1, 8238, '\p{Bidi_Class=righttoleftoverride}', ""); +Expect(0, 8238, '\p{^Bidi_Class=righttoleftoverride}', ""); +Expect(0, 8238, '\P{Bidi_Class=righttoleftoverride}', ""); +Expect(1, 8238, '\P{^Bidi_Class=righttoleftoverride}', ""); +Expect(0, 8237, '\p{Bidi_Class=righttoleftoverride}', ""); +Expect(1, 8237, '\p{^Bidi_Class=righttoleftoverride}', ""); +Expect(1, 8237, '\P{Bidi_Class=righttoleftoverride}', ""); +Expect(0, 8237, '\P{^Bidi_Class=righttoleftoverride}', ""); +Expect(1, 8238, '\p{Bidi_Class=_ RIGHT_to_LEFT_Override}', ""); +Expect(0, 8238, '\p{^Bidi_Class=_ RIGHT_to_LEFT_Override}', ""); +Expect(0, 8238, '\P{Bidi_Class=_ RIGHT_to_LEFT_Override}', ""); +Expect(1, 8238, '\P{^Bidi_Class=_ RIGHT_to_LEFT_Override}', ""); +Expect(0, 8237, '\p{Bidi_Class=_ RIGHT_to_LEFT_Override}', ""); +Expect(1, 8237, '\p{^Bidi_Class=_ RIGHT_to_LEFT_Override}', ""); +Expect(1, 8237, '\P{Bidi_Class=_ RIGHT_to_LEFT_Override}', ""); +Expect(0, 8237, '\P{^Bidi_Class=_ RIGHT_to_LEFT_Override}', ""); +Error('\p{Bc=/a/_RLO}'); +Error('\P{Bc=/a/_RLO}'); +Expect(1, 8238, '\p{Bc=rlo}', ""); +Expect(0, 8238, '\p{^Bc=rlo}', ""); +Expect(0, 8238, '\P{Bc=rlo}', ""); +Expect(1, 8238, '\P{^Bc=rlo}', ""); +Expect(0, 8237, '\p{Bc=rlo}', ""); +Expect(1, 8237, '\p{^Bc=rlo}', ""); +Expect(1, 8237, '\P{Bc=rlo}', ""); +Expect(0, 8237, '\P{^Bc=rlo}', ""); +Expect(1, 8238, '\p{Bc= RLO}', ""); +Expect(0, 8238, '\p{^Bc= RLO}', ""); +Expect(0, 8238, '\P{Bc= RLO}', ""); +Expect(1, 8238, '\P{^Bc= RLO}', ""); +Expect(0, 8237, '\p{Bc= RLO}', ""); +Expect(1, 8237, '\p{^Bc= RLO}', ""); +Expect(1, 8237, '\P{Bc= RLO}', ""); +Expect(0, 8237, '\P{^Bc= RLO}', ""); +Error('\p{Is_Bidi_Class=/a/RIGHT-To-left Override}'); +Error('\P{Is_Bidi_Class=/a/RIGHT-To-left Override}'); +Expect(1, 8238, '\p{Is_Bidi_Class=righttoleftoverride}', ""); +Expect(0, 8238, '\p{^Is_Bidi_Class=righttoleftoverride}', ""); +Expect(0, 8238, '\P{Is_Bidi_Class=righttoleftoverride}', ""); +Expect(1, 8238, '\P{^Is_Bidi_Class=righttoleftoverride}', ""); +Expect(0, 8237, '\p{Is_Bidi_Class=righttoleftoverride}', ""); +Expect(1, 8237, '\p{^Is_Bidi_Class=righttoleftoverride}', ""); +Expect(1, 8237, '\P{Is_Bidi_Class=righttoleftoverride}', ""); +Expect(0, 8237, '\P{^Is_Bidi_Class=righttoleftoverride}', ""); +Expect(1, 8238, '\p{Is_Bidi_Class=RIGHT_to Left override}', ""); +Expect(0, 8238, '\p{^Is_Bidi_Class=RIGHT_to Left override}', ""); +Expect(0, 8238, '\P{Is_Bidi_Class=RIGHT_to Left override}', ""); +Expect(1, 8238, '\P{^Is_Bidi_Class=RIGHT_to Left override}', ""); +Expect(0, 8237, '\p{Is_Bidi_Class=RIGHT_to Left override}', ""); +Expect(1, 8237, '\p{^Is_Bidi_Class=RIGHT_to Left override}', ""); +Expect(1, 8237, '\P{Is_Bidi_Class=RIGHT_to Left override}', ""); +Expect(0, 8237, '\P{^Is_Bidi_Class=RIGHT_to Left override}', ""); +Error('\p{Is_Bc:__RLO:=}'); +Error('\P{Is_Bc:__RLO:=}'); +Expect(1, 8238, '\p{Is_Bc=rlo}', ""); +Expect(0, 8238, '\p{^Is_Bc=rlo}', ""); +Expect(0, 8238, '\P{Is_Bc=rlo}', ""); +Expect(1, 8238, '\P{^Is_Bc=rlo}', ""); +Expect(0, 8237, '\p{Is_Bc=rlo}', ""); +Expect(1, 8237, '\p{^Is_Bc=rlo}', ""); +Expect(1, 8237, '\P{Is_Bc=rlo}', ""); +Expect(0, 8237, '\P{^Is_Bc=rlo}', ""); +Expect(1, 8238, '\p{Is_Bc= _RLO}', ""); +Expect(0, 8238, '\p{^Is_Bc= _RLO}', ""); +Expect(0, 8238, '\P{Is_Bc= _RLO}', ""); +Expect(1, 8238, '\P{^Is_Bc= _RLO}', ""); +Expect(0, 8237, '\p{Is_Bc= _RLO}', ""); +Expect(1, 8237, '\p{^Is_Bc= _RLO}', ""); +Expect(1, 8237, '\P{Is_Bc= _RLO}', ""); +Expect(0, 8237, '\P{^Is_Bc= _RLO}', ""); +Error('\p{Bidi_Class=_-LEFTTO Right override:=}'); +Error('\P{Bidi_Class=_-LEFTTO Right override:=}'); +Expect(1, 8237, '\p{Bidi_Class: lefttorightoverride}', ""); +Expect(0, 8237, '\p{^Bidi_Class: lefttorightoverride}', ""); +Expect(0, 8237, '\P{Bidi_Class: lefttorightoverride}', ""); +Expect(1, 8237, '\P{^Bidi_Class: lefttorightoverride}', ""); +Expect(0, 8236, '\p{Bidi_Class: lefttorightoverride}', ""); +Expect(1, 8236, '\p{^Bidi_Class: lefttorightoverride}', ""); +Expect(1, 8236, '\P{Bidi_Class: lefttorightoverride}', ""); +Expect(0, 8236, '\P{^Bidi_Class: lefttorightoverride}', ""); +Expect(1, 8237, '\p{Bidi_Class= LeftTo Right OVERRIDE}', ""); +Expect(0, 8237, '\p{^Bidi_Class= LeftTo Right OVERRIDE}', ""); +Expect(0, 8237, '\P{Bidi_Class= LeftTo Right OVERRIDE}', ""); +Expect(1, 8237, '\P{^Bidi_Class= LeftTo Right OVERRIDE}', ""); +Expect(0, 8236, '\p{Bidi_Class= LeftTo Right OVERRIDE}', ""); +Expect(1, 8236, '\p{^Bidi_Class= LeftTo Right OVERRIDE}', ""); +Expect(1, 8236, '\P{Bidi_Class= LeftTo Right OVERRIDE}', ""); +Expect(0, 8236, '\P{^Bidi_Class= LeftTo Right OVERRIDE}', ""); +Error('\p{Bc=_LRO/a/}'); +Error('\P{Bc=_LRO/a/}'); +Expect(1, 8237, '\p{Bc: lro}', ""); +Expect(0, 8237, '\p{^Bc: lro}', ""); +Expect(0, 8237, '\P{Bc: lro}', ""); +Expect(1, 8237, '\P{^Bc: lro}', ""); +Expect(0, 8236, '\p{Bc: lro}', ""); +Expect(1, 8236, '\p{^Bc: lro}', ""); +Expect(1, 8236, '\P{Bc: lro}', ""); +Expect(0, 8236, '\P{^Bc: lro}', ""); +Expect(1, 8237, '\p{Bc=_-LRO}', ""); +Expect(0, 8237, '\p{^Bc=_-LRO}', ""); +Expect(0, 8237, '\P{Bc=_-LRO}', ""); +Expect(1, 8237, '\P{^Bc=_-LRO}', ""); +Expect(0, 8236, '\p{Bc=_-LRO}', ""); +Expect(1, 8236, '\p{^Bc=_-LRO}', ""); +Expect(1, 8236, '\P{Bc=_-LRO}', ""); +Expect(0, 8236, '\P{^Bc=_-LRO}', ""); +Error('\p{Is_Bidi_Class= left_TO/a/right-Override}'); +Error('\P{Is_Bidi_Class= left_TO/a/right-Override}'); +Expect(1, 8237, '\p{Is_Bidi_Class=lefttorightoverride}', ""); +Expect(0, 8237, '\p{^Is_Bidi_Class=lefttorightoverride}', ""); +Expect(0, 8237, '\P{Is_Bidi_Class=lefttorightoverride}', ""); +Expect(1, 8237, '\P{^Is_Bidi_Class=lefttorightoverride}', ""); +Expect(0, 8236, '\p{Is_Bidi_Class=lefttorightoverride}', ""); +Expect(1, 8236, '\p{^Is_Bidi_Class=lefttorightoverride}', ""); +Expect(1, 8236, '\P{Is_Bidi_Class=lefttorightoverride}', ""); +Expect(0, 8236, '\P{^Is_Bidi_Class=lefttorightoverride}', ""); +Expect(1, 8237, '\p{Is_Bidi_Class: -LEFT TO-Right_Override}', ""); +Expect(0, 8237, '\p{^Is_Bidi_Class: -LEFT TO-Right_Override}', ""); +Expect(0, 8237, '\P{Is_Bidi_Class: -LEFT TO-Right_Override}', ""); +Expect(1, 8237, '\P{^Is_Bidi_Class: -LEFT TO-Right_Override}', ""); +Expect(0, 8236, '\p{Is_Bidi_Class: -LEFT TO-Right_Override}', ""); +Expect(1, 8236, '\p{^Is_Bidi_Class: -LEFT TO-Right_Override}', ""); +Expect(1, 8236, '\P{Is_Bidi_Class: -LEFT TO-Right_Override}', ""); +Expect(0, 8236, '\P{^Is_Bidi_Class: -LEFT TO-Right_Override}', ""); +Error('\p{Is_Bc: /a/_ LRO}'); +Error('\P{Is_Bc: /a/_ LRO}'); +Expect(1, 8237, '\p{Is_Bc=lro}', ""); +Expect(0, 8237, '\p{^Is_Bc=lro}', ""); +Expect(0, 8237, '\P{Is_Bc=lro}', ""); +Expect(1, 8237, '\P{^Is_Bc=lro}', ""); +Expect(0, 8236, '\p{Is_Bc=lro}', ""); +Expect(1, 8236, '\p{^Is_Bc=lro}', ""); +Expect(1, 8236, '\P{Is_Bc=lro}', ""); +Expect(0, 8236, '\P{^Is_Bc=lro}', ""); +Expect(1, 8237, '\p{Is_Bc: - LRO}', ""); +Expect(0, 8237, '\p{^Is_Bc: - LRO}', ""); +Expect(0, 8237, '\P{Is_Bc: - LRO}', ""); +Expect(1, 8237, '\P{^Is_Bc: - LRO}', ""); +Expect(0, 8236, '\p{Is_Bc: - LRO}', ""); +Expect(1, 8236, '\p{^Is_Bc: - LRO}', ""); +Expect(1, 8236, '\P{Is_Bc: - LRO}', ""); +Expect(0, 8236, '\P{^Is_Bc: - LRO}', ""); +Error('\p{Bidi_Class=_Left ToRIGHT:=}'); +Error('\P{Bidi_Class=_Left ToRIGHT:=}'); +Expect(1, 90, '\p{Bidi_Class=lefttoright}', ""); +Expect(0, 90, '\p{^Bidi_Class=lefttoright}', ""); +Expect(0, 90, '\P{Bidi_Class=lefttoright}', ""); +Expect(1, 90, '\P{^Bidi_Class=lefttoright}', ""); +Expect(0, 64, '\p{Bidi_Class=lefttoright}', ""); +Expect(1, 64, '\p{^Bidi_Class=lefttoright}', ""); +Expect(1, 64, '\P{Bidi_Class=lefttoright}', ""); +Expect(0, 64, '\P{^Bidi_Class=lefttoright}', ""); +Expect(1, 90, '\p{Bidi_Class=-_LeftTo right}', ""); +Expect(0, 90, '\p{^Bidi_Class=-_LeftTo right}', ""); +Expect(0, 90, '\P{Bidi_Class=-_LeftTo right}', ""); +Expect(1, 90, '\P{^Bidi_Class=-_LeftTo right}', ""); +Expect(0, 64, '\p{Bidi_Class=-_LeftTo right}', ""); +Expect(1, 64, '\p{^Bidi_Class=-_LeftTo right}', ""); +Expect(1, 64, '\P{Bidi_Class=-_LeftTo right}', ""); +Expect(0, 64, '\P{^Bidi_Class=-_LeftTo right}', ""); +Error('\p{Bc=_/a/L}'); +Error('\P{Bc=_/a/L}'); +Expect(1, 90, '\p{Bc=l}', ""); +Expect(0, 90, '\p{^Bc=l}', ""); +Expect(0, 90, '\P{Bc=l}', ""); +Expect(1, 90, '\P{^Bc=l}', ""); +Expect(0, 64, '\p{Bc=l}', ""); +Expect(1, 64, '\p{^Bc=l}', ""); +Expect(1, 64, '\P{Bc=l}', ""); +Expect(0, 64, '\P{^Bc=l}', ""); +Expect(1, 90, '\p{Bc=_ L}', ""); +Expect(0, 90, '\p{^Bc=_ L}', ""); +Expect(0, 90, '\P{Bc=_ L}', ""); +Expect(1, 90, '\P{^Bc=_ L}', ""); +Expect(0, 64, '\p{Bc=_ L}', ""); +Expect(1, 64, '\p{^Bc=_ L}', ""); +Expect(1, 64, '\P{Bc=_ L}', ""); +Expect(0, 64, '\P{^Bc=_ L}', ""); +Error('\p{Is_Bidi_Class=- LEFT/a/TO-Right}'); +Error('\P{Is_Bidi_Class=- LEFT/a/TO-Right}'); +Expect(1, 90, '\p{Is_Bidi_Class=lefttoright}', ""); +Expect(0, 90, '\p{^Is_Bidi_Class=lefttoright}', ""); +Expect(0, 90, '\P{Is_Bidi_Class=lefttoright}', ""); +Expect(1, 90, '\P{^Is_Bidi_Class=lefttoright}', ""); +Expect(0, 64, '\p{Is_Bidi_Class=lefttoright}', ""); +Expect(1, 64, '\p{^Is_Bidi_Class=lefttoright}', ""); +Expect(1, 64, '\P{Is_Bidi_Class=lefttoright}', ""); +Expect(0, 64, '\P{^Is_Bidi_Class=lefttoright}', ""); +Expect(1, 90, '\p{Is_Bidi_Class= -Left TO Right}', ""); +Expect(0, 90, '\p{^Is_Bidi_Class= -Left TO Right}', ""); +Expect(0, 90, '\P{Is_Bidi_Class= -Left TO Right}', ""); +Expect(1, 90, '\P{^Is_Bidi_Class= -Left TO Right}', ""); +Expect(0, 64, '\p{Is_Bidi_Class= -Left TO Right}', ""); +Expect(1, 64, '\p{^Is_Bidi_Class= -Left TO Right}', ""); +Expect(1, 64, '\P{Is_Bidi_Class= -Left TO Right}', ""); +Expect(0, 64, '\P{^Is_Bidi_Class= -Left TO Right}', ""); +Error('\p{Is_Bc=_-L/a/}'); +Error('\P{Is_Bc=_-L/a/}'); +Expect(1, 90, '\p{Is_Bc=l}', ""); +Expect(0, 90, '\p{^Is_Bc=l}', ""); +Expect(0, 90, '\P{Is_Bc=l}', ""); +Expect(1, 90, '\P{^Is_Bc=l}', ""); +Expect(0, 64, '\p{Is_Bc=l}', ""); +Expect(1, 64, '\p{^Is_Bc=l}', ""); +Expect(1, 64, '\P{Is_Bc=l}', ""); +Expect(0, 64, '\P{^Is_Bc=l}', ""); +Expect(1, 90, '\p{Is_Bc= L}', ""); +Expect(0, 90, '\p{^Is_Bc= L}', ""); +Expect(0, 90, '\P{Is_Bc= L}', ""); +Expect(1, 90, '\P{^Is_Bc= L}', ""); +Expect(0, 64, '\p{Is_Bc= L}', ""); +Expect(1, 64, '\p{^Is_Bc= L}', ""); +Expect(1, 64, '\P{Is_Bc= L}', ""); +Expect(0, 64, '\P{^Is_Bc= L}', ""); +Error('\p{Bidi_Class= RIGHT To-Left_Embedding/a/}'); +Error('\P{Bidi_Class= RIGHT To-Left_Embedding/a/}'); +Expect(1, 8235, '\p{Bidi_Class=righttoleftembedding}', ""); +Expect(0, 8235, '\p{^Bidi_Class=righttoleftembedding}', ""); +Expect(0, 8235, '\P{Bidi_Class=righttoleftembedding}', ""); +Expect(1, 8235, '\P{^Bidi_Class=righttoleftembedding}', ""); +Expect(0, 8234, '\p{Bidi_Class=righttoleftembedding}', ""); +Expect(1, 8234, '\p{^Bidi_Class=righttoleftembedding}', ""); +Expect(1, 8234, '\P{Bidi_Class=righttoleftembedding}', ""); +Expect(0, 8234, '\P{^Bidi_Class=righttoleftembedding}', ""); +Expect(1, 8235, '\p{Bidi_Class=_Right to LEFT_embedding}', ""); +Expect(0, 8235, '\p{^Bidi_Class=_Right to LEFT_embedding}', ""); +Expect(0, 8235, '\P{Bidi_Class=_Right to LEFT_embedding}', ""); +Expect(1, 8235, '\P{^Bidi_Class=_Right to LEFT_embedding}', ""); +Expect(0, 8234, '\p{Bidi_Class=_Right to LEFT_embedding}', ""); +Expect(1, 8234, '\p{^Bidi_Class=_Right to LEFT_embedding}', ""); +Expect(1, 8234, '\P{Bidi_Class=_Right to LEFT_embedding}', ""); +Expect(0, 8234, '\P{^Bidi_Class=_Right to LEFT_embedding}', ""); +Error('\p{Bc=/a/ rle}'); +Error('\P{Bc=/a/ rle}'); +Expect(1, 8235, '\p{Bc=rle}', ""); +Expect(0, 8235, '\p{^Bc=rle}', ""); +Expect(0, 8235, '\P{Bc=rle}', ""); +Expect(1, 8235, '\P{^Bc=rle}', ""); +Expect(0, 8234, '\p{Bc=rle}', ""); +Expect(1, 8234, '\p{^Bc=rle}', ""); +Expect(1, 8234, '\P{Bc=rle}', ""); +Expect(0, 8234, '\P{^Bc=rle}', ""); +Expect(1, 8235, '\p{Bc= RLE}', ""); +Expect(0, 8235, '\p{^Bc= RLE}', ""); +Expect(0, 8235, '\P{Bc= RLE}', ""); +Expect(1, 8235, '\P{^Bc= RLE}', ""); +Expect(0, 8234, '\p{Bc= RLE}', ""); +Expect(1, 8234, '\p{^Bc= RLE}', ""); +Expect(1, 8234, '\P{Bc= RLE}', ""); +Expect(0, 8234, '\P{^Bc= RLE}', ""); +Error('\p{Is_Bidi_Class= Right:=TO-left-Embedding}'); +Error('\P{Is_Bidi_Class= Right:=TO-left-Embedding}'); +Expect(1, 8235, '\p{Is_Bidi_Class=righttoleftembedding}', ""); +Expect(0, 8235, '\p{^Is_Bidi_Class=righttoleftembedding}', ""); +Expect(0, 8235, '\P{Is_Bidi_Class=righttoleftembedding}', ""); +Expect(1, 8235, '\P{^Is_Bidi_Class=righttoleftembedding}', ""); +Expect(0, 8234, '\p{Is_Bidi_Class=righttoleftembedding}', ""); +Expect(1, 8234, '\p{^Is_Bidi_Class=righttoleftembedding}', ""); +Expect(1, 8234, '\P{Is_Bidi_Class=righttoleftembedding}', ""); +Expect(0, 8234, '\P{^Is_Bidi_Class=righttoleftembedding}', ""); +Expect(1, 8235, '\p{Is_Bidi_Class=- rightTo Left embedding}', ""); +Expect(0, 8235, '\p{^Is_Bidi_Class=- rightTo Left embedding}', ""); +Expect(0, 8235, '\P{Is_Bidi_Class=- rightTo Left embedding}', ""); +Expect(1, 8235, '\P{^Is_Bidi_Class=- rightTo Left embedding}', ""); +Expect(0, 8234, '\p{Is_Bidi_Class=- rightTo Left embedding}', ""); +Expect(1, 8234, '\p{^Is_Bidi_Class=- rightTo Left embedding}', ""); +Expect(1, 8234, '\P{Is_Bidi_Class=- rightTo Left embedding}', ""); +Expect(0, 8234, '\P{^Is_Bidi_Class=- rightTo Left embedding}', ""); +Error('\p{Is_Bc=:= -rle}'); +Error('\P{Is_Bc=:= -rle}'); +Expect(1, 8235, '\p{Is_Bc=rle}', ""); +Expect(0, 8235, '\p{^Is_Bc=rle}', ""); +Expect(0, 8235, '\P{Is_Bc=rle}', ""); +Expect(1, 8235, '\P{^Is_Bc=rle}', ""); +Expect(0, 8234, '\p{Is_Bc=rle}', ""); +Expect(1, 8234, '\p{^Is_Bc=rle}', ""); +Expect(1, 8234, '\P{Is_Bc=rle}', ""); +Expect(0, 8234, '\P{^Is_Bc=rle}', ""); +Expect(1, 8235, '\p{Is_Bc= RLE}', ""); +Expect(0, 8235, '\p{^Is_Bc= RLE}', ""); +Expect(0, 8235, '\P{Is_Bc= RLE}', ""); +Expect(1, 8235, '\P{^Is_Bc= RLE}', ""); +Expect(0, 8234, '\p{Is_Bc= RLE}', ""); +Expect(1, 8234, '\p{^Is_Bc= RLE}', ""); +Expect(1, 8234, '\P{Is_Bc= RLE}', ""); +Expect(0, 8234, '\P{^Is_Bc= RLE}', ""); +Error('\p{Bidi_Class=/a/Other-neutral}'); +Error('\P{Bidi_Class=/a/Other-neutral}'); +Expect(1, 34, '\p{Bidi_Class=otherneutral}', ""); +Expect(0, 34, '\p{^Bidi_Class=otherneutral}', ""); +Expect(0, 34, '\P{Bidi_Class=otherneutral}', ""); +Expect(1, 34, '\P{^Bidi_Class=otherneutral}', ""); +Expect(0, 32, '\p{Bidi_Class=otherneutral}', ""); +Expect(1, 32, '\p{^Bidi_Class=otherneutral}', ""); +Expect(1, 32, '\P{Bidi_Class=otherneutral}', ""); +Expect(0, 32, '\P{^Bidi_Class=otherneutral}', ""); +Expect(1, 34, '\p{Bidi_Class=-Other Neutral}', ""); +Expect(0, 34, '\p{^Bidi_Class=-Other Neutral}', ""); +Expect(0, 34, '\P{Bidi_Class=-Other Neutral}', ""); +Expect(1, 34, '\P{^Bidi_Class=-Other Neutral}', ""); +Expect(0, 32, '\p{Bidi_Class=-Other Neutral}', ""); +Expect(1, 32, '\p{^Bidi_Class=-Other Neutral}', ""); +Expect(1, 32, '\P{Bidi_Class=-Other Neutral}', ""); +Expect(0, 32, '\P{^Bidi_Class=-Other Neutral}', ""); +Error('\p{Bc=- ON/a/}'); +Error('\P{Bc=- ON/a/}'); +Expect(1, 34, '\p{Bc=on}', ""); +Expect(0, 34, '\p{^Bc=on}', ""); +Expect(0, 34, '\P{Bc=on}', ""); +Expect(1, 34, '\P{^Bc=on}', ""); +Expect(0, 32, '\p{Bc=on}', ""); +Expect(1, 32, '\p{^Bc=on}', ""); +Expect(1, 32, '\P{Bc=on}', ""); +Expect(0, 32, '\P{^Bc=on}', ""); +Expect(1, 34, '\p{Bc= ON}', ""); +Expect(0, 34, '\p{^Bc= ON}', ""); +Expect(0, 34, '\P{Bc= ON}', ""); +Expect(1, 34, '\P{^Bc= ON}', ""); +Expect(0, 32, '\p{Bc= ON}', ""); +Expect(1, 32, '\p{^Bc= ON}', ""); +Expect(1, 32, '\P{Bc= ON}', ""); +Expect(0, 32, '\P{^Bc= ON}', ""); +Error('\p{Is_Bidi_Class= _Other:=neutral}'); +Error('\P{Is_Bidi_Class= _Other:=neutral}'); +Expect(1, 34, '\p{Is_Bidi_Class=otherneutral}', ""); +Expect(0, 34, '\p{^Is_Bidi_Class=otherneutral}', ""); +Expect(0, 34, '\P{Is_Bidi_Class=otherneutral}', ""); +Expect(1, 34, '\P{^Is_Bidi_Class=otherneutral}', ""); +Expect(0, 32, '\p{Is_Bidi_Class=otherneutral}', ""); +Expect(1, 32, '\p{^Is_Bidi_Class=otherneutral}', ""); +Expect(1, 32, '\P{Is_Bidi_Class=otherneutral}', ""); +Expect(0, 32, '\P{^Is_Bidi_Class=otherneutral}', ""); +Expect(1, 34, '\p{Is_Bidi_Class= Other-Neutral}', ""); +Expect(0, 34, '\p{^Is_Bidi_Class= Other-Neutral}', ""); +Expect(0, 34, '\P{Is_Bidi_Class= Other-Neutral}', ""); +Expect(1, 34, '\P{^Is_Bidi_Class= Other-Neutral}', ""); +Expect(0, 32, '\p{Is_Bidi_Class= Other-Neutral}', ""); +Expect(1, 32, '\p{^Is_Bidi_Class= Other-Neutral}', ""); +Expect(1, 32, '\P{Is_Bidi_Class= Other-Neutral}', ""); +Expect(0, 32, '\P{^Is_Bidi_Class= Other-Neutral}', ""); +Error('\p{Is_Bc=_:=ON}'); +Error('\P{Is_Bc=_:=ON}'); +Expect(1, 34, '\p{Is_Bc=on}', ""); +Expect(0, 34, '\p{^Is_Bc=on}', ""); +Expect(0, 34, '\P{Is_Bc=on}', ""); +Expect(1, 34, '\P{^Is_Bc=on}', ""); +Expect(0, 32, '\p{Is_Bc=on}', ""); +Expect(1, 32, '\p{^Is_Bc=on}', ""); +Expect(1, 32, '\P{Is_Bc=on}', ""); +Expect(0, 32, '\P{^Is_Bc=on}', ""); +Expect(1, 34, '\p{Is_Bc=_-ON}', ""); +Expect(0, 34, '\p{^Is_Bc=_-ON}', ""); +Expect(0, 34, '\P{Is_Bc=_-ON}', ""); +Expect(1, 34, '\P{^Is_Bc=_-ON}', ""); +Expect(0, 32, '\p{Is_Bc=_-ON}', ""); +Expect(1, 32, '\p{^Is_Bc=_-ON}', ""); +Expect(1, 32, '\P{Is_Bc=_-ON}', ""); +Expect(0, 32, '\P{^Is_Bc=_-ON}', ""); +Error('\p{Bidi_Class: :=BOUNDARY_neutral}'); +Error('\P{Bidi_Class: :=BOUNDARY_neutral}'); +Expect(1, 8, '\p{Bidi_Class=boundaryneutral}', ""); +Expect(0, 8, '\p{^Bidi_Class=boundaryneutral}', ""); +Expect(0, 8, '\P{Bidi_Class=boundaryneutral}', ""); +Expect(1, 8, '\P{^Bidi_Class=boundaryneutral}', ""); +Expect(0, 13, '\p{Bidi_Class=boundaryneutral}', ""); +Expect(1, 13, '\p{^Bidi_Class=boundaryneutral}', ""); +Expect(1, 13, '\P{Bidi_Class=boundaryneutral}', ""); +Expect(0, 13, '\P{^Bidi_Class=boundaryneutral}', ""); +Expect(1, 8, '\p{Bidi_Class= -Boundary_Neutral}', ""); +Expect(0, 8, '\p{^Bidi_Class= -Boundary_Neutral}', ""); +Expect(0, 8, '\P{Bidi_Class= -Boundary_Neutral}', ""); +Expect(1, 8, '\P{^Bidi_Class= -Boundary_Neutral}', ""); +Expect(0, 13, '\p{Bidi_Class= -Boundary_Neutral}', ""); +Expect(1, 13, '\p{^Bidi_Class= -Boundary_Neutral}', ""); +Expect(1, 13, '\P{Bidi_Class= -Boundary_Neutral}', ""); +Expect(0, 13, '\P{^Bidi_Class= -Boundary_Neutral}', ""); +Error('\p{Bc= /a/BN}'); +Error('\P{Bc= /a/BN}'); +Expect(1, 8, '\p{Bc=bn}', ""); +Expect(0, 8, '\p{^Bc=bn}', ""); +Expect(0, 8, '\P{Bc=bn}', ""); +Expect(1, 8, '\P{^Bc=bn}', ""); +Expect(0, 13, '\p{Bc=bn}', ""); +Expect(1, 13, '\p{^Bc=bn}', ""); +Expect(1, 13, '\P{Bc=bn}', ""); +Expect(0, 13, '\P{^Bc=bn}', ""); +Expect(1, 8, '\p{Bc: __BN}', ""); +Expect(0, 8, '\p{^Bc: __BN}', ""); +Expect(0, 8, '\P{Bc: __BN}', ""); +Expect(1, 8, '\P{^Bc: __BN}', ""); +Expect(0, 13, '\p{Bc: __BN}', ""); +Expect(1, 13, '\p{^Bc: __BN}', ""); +Expect(1, 13, '\P{Bc: __BN}', ""); +Expect(0, 13, '\P{^Bc: __BN}', ""); +Error('\p{Is_Bidi_Class= /a/Boundary-Neutral}'); +Error('\P{Is_Bidi_Class= /a/Boundary-Neutral}'); +Expect(1, 8, '\p{Is_Bidi_Class=boundaryneutral}', ""); +Expect(0, 8, '\p{^Is_Bidi_Class=boundaryneutral}', ""); +Expect(0, 8, '\P{Is_Bidi_Class=boundaryneutral}', ""); +Expect(1, 8, '\P{^Is_Bidi_Class=boundaryneutral}', ""); +Expect(0, 13, '\p{Is_Bidi_Class=boundaryneutral}', ""); +Expect(1, 13, '\p{^Is_Bidi_Class=boundaryneutral}', ""); +Expect(1, 13, '\P{Is_Bidi_Class=boundaryneutral}', ""); +Expect(0, 13, '\P{^Is_Bidi_Class=boundaryneutral}', ""); +Expect(1, 8, '\p{Is_Bidi_Class=_ BOUNDARY NEUTRAL}', ""); +Expect(0, 8, '\p{^Is_Bidi_Class=_ BOUNDARY NEUTRAL}', ""); +Expect(0, 8, '\P{Is_Bidi_Class=_ BOUNDARY NEUTRAL}', ""); +Expect(1, 8, '\P{^Is_Bidi_Class=_ BOUNDARY NEUTRAL}', ""); +Expect(0, 13, '\p{Is_Bidi_Class=_ BOUNDARY NEUTRAL}', ""); +Expect(1, 13, '\p{^Is_Bidi_Class=_ BOUNDARY NEUTRAL}', ""); +Expect(1, 13, '\P{Is_Bidi_Class=_ BOUNDARY NEUTRAL}', ""); +Expect(0, 13, '\P{^Is_Bidi_Class=_ BOUNDARY NEUTRAL}', ""); +Error('\p{Is_Bc=:= bn}'); +Error('\P{Is_Bc=:= bn}'); +Expect(1, 8, '\p{Is_Bc=bn}', ""); +Expect(0, 8, '\p{^Is_Bc=bn}', ""); +Expect(0, 8, '\P{Is_Bc=bn}', ""); +Expect(1, 8, '\P{^Is_Bc=bn}', ""); +Expect(0, 13, '\p{Is_Bc=bn}', ""); +Expect(1, 13, '\p{^Is_Bc=bn}', ""); +Expect(1, 13, '\P{Is_Bc=bn}', ""); +Expect(0, 13, '\P{^Is_Bc=bn}', ""); +Expect(1, 8, '\p{Is_Bc= bn}', ""); +Expect(0, 8, '\p{^Is_Bc= bn}', ""); +Expect(0, 8, '\P{Is_Bc= bn}', ""); +Expect(1, 8, '\P{^Is_Bc= bn}', ""); +Expect(0, 13, '\p{Is_Bc= bn}', ""); +Expect(1, 13, '\p{^Is_Bc= bn}', ""); +Expect(1, 13, '\P{Is_Bc= bn}', ""); +Expect(0, 13, '\P{^Is_Bc= bn}', ""); +Error('\p{Bidi_Class=--POP Directional format:=}'); +Error('\P{Bidi_Class=--POP Directional format:=}'); +Expect(1, 8236, '\p{Bidi_Class=popdirectionalformat}', ""); +Expect(0, 8236, '\p{^Bidi_Class=popdirectionalformat}', ""); +Expect(0, 8236, '\P{Bidi_Class=popdirectionalformat}', ""); +Expect(1, 8236, '\P{^Bidi_Class=popdirectionalformat}', ""); +Expect(0, 8235, '\p{Bidi_Class=popdirectionalformat}', ""); +Expect(1, 8235, '\p{^Bidi_Class=popdirectionalformat}', ""); +Expect(1, 8235, '\P{Bidi_Class=popdirectionalformat}', ""); +Expect(0, 8235, '\P{^Bidi_Class=popdirectionalformat}', ""); +Expect(1, 8236, '\p{Bidi_Class:__Pop_Directional Format}', ""); +Expect(0, 8236, '\p{^Bidi_Class:__Pop_Directional Format}', ""); +Expect(0, 8236, '\P{Bidi_Class:__Pop_Directional Format}', ""); +Expect(1, 8236, '\P{^Bidi_Class:__Pop_Directional Format}', ""); +Expect(0, 8235, '\p{Bidi_Class:__Pop_Directional Format}', ""); +Expect(1, 8235, '\p{^Bidi_Class:__Pop_Directional Format}', ""); +Expect(1, 8235, '\P{Bidi_Class:__Pop_Directional Format}', ""); +Expect(0, 8235, '\P{^Bidi_Class:__Pop_Directional Format}', ""); +Error('\p{Bc=_:=PDF}'); +Error('\P{Bc=_:=PDF}'); +Expect(1, 8236, '\p{Bc=pdf}', ""); +Expect(0, 8236, '\p{^Bc=pdf}', ""); +Expect(0, 8236, '\P{Bc=pdf}', ""); +Expect(1, 8236, '\P{^Bc=pdf}', ""); +Expect(0, 8235, '\p{Bc=pdf}', ""); +Expect(1, 8235, '\p{^Bc=pdf}', ""); +Expect(1, 8235, '\P{Bc=pdf}', ""); +Expect(0, 8235, '\P{^Bc=pdf}', ""); +Expect(1, 8236, '\p{Bc= PDF}', ""); +Expect(0, 8236, '\p{^Bc= PDF}', ""); +Expect(0, 8236, '\P{Bc= PDF}', ""); +Expect(1, 8236, '\P{^Bc= PDF}', ""); +Expect(0, 8235, '\p{Bc= PDF}', ""); +Expect(1, 8235, '\p{^Bc= PDF}', ""); +Expect(1, 8235, '\P{Bc= PDF}', ""); +Expect(0, 8235, '\P{^Bc= PDF}', ""); +Error('\p{Is_Bidi_Class= pop_Directional Format/a/}'); +Error('\P{Is_Bidi_Class= pop_Directional Format/a/}'); +Expect(1, 8236, '\p{Is_Bidi_Class=popdirectionalformat}', ""); +Expect(0, 8236, '\p{^Is_Bidi_Class=popdirectionalformat}', ""); +Expect(0, 8236, '\P{Is_Bidi_Class=popdirectionalformat}', ""); +Expect(1, 8236, '\P{^Is_Bidi_Class=popdirectionalformat}', ""); +Expect(0, 8235, '\p{Is_Bidi_Class=popdirectionalformat}', ""); +Expect(1, 8235, '\p{^Is_Bidi_Class=popdirectionalformat}', ""); +Expect(1, 8235, '\P{Is_Bidi_Class=popdirectionalformat}', ""); +Expect(0, 8235, '\P{^Is_Bidi_Class=popdirectionalformat}', ""); +Expect(1, 8236, '\p{Is_Bidi_Class=_ popDirectional format}', ""); +Expect(0, 8236, '\p{^Is_Bidi_Class=_ popDirectional format}', ""); +Expect(0, 8236, '\P{Is_Bidi_Class=_ popDirectional format}', ""); +Expect(1, 8236, '\P{^Is_Bidi_Class=_ popDirectional format}', ""); +Expect(0, 8235, '\p{Is_Bidi_Class=_ popDirectional format}', ""); +Expect(1, 8235, '\p{^Is_Bidi_Class=_ popDirectional format}', ""); +Expect(1, 8235, '\P{Is_Bidi_Class=_ popDirectional format}', ""); +Expect(0, 8235, '\P{^Is_Bidi_Class=_ popDirectional format}', ""); +Error('\p{Is_Bc=/a/PDF}'); +Error('\P{Is_Bc=/a/PDF}'); +Expect(1, 8236, '\p{Is_Bc=pdf}', ""); +Expect(0, 8236, '\p{^Is_Bc=pdf}', ""); +Expect(0, 8236, '\P{Is_Bc=pdf}', ""); +Expect(1, 8236, '\P{^Is_Bc=pdf}', ""); +Expect(0, 8235, '\p{Is_Bc=pdf}', ""); +Expect(1, 8235, '\p{^Is_Bc=pdf}', ""); +Expect(1, 8235, '\P{Is_Bc=pdf}', ""); +Expect(0, 8235, '\P{^Is_Bc=pdf}', ""); +Expect(1, 8236, '\p{Is_Bc= PDF}', ""); +Expect(0, 8236, '\p{^Is_Bc= PDF}', ""); +Expect(0, 8236, '\P{Is_Bc= PDF}', ""); +Expect(1, 8236, '\P{^Is_Bc= PDF}', ""); +Expect(0, 8235, '\p{Is_Bc= PDF}', ""); +Expect(1, 8235, '\p{^Is_Bc= PDF}', ""); +Expect(1, 8235, '\P{Is_Bc= PDF}', ""); +Expect(0, 8235, '\P{^Is_Bc= PDF}', ""); +Error('\p{Bidi_Class: :=LEFT to RIGHT_EMBEDDING}'); +Error('\P{Bidi_Class: :=LEFT to RIGHT_EMBEDDING}'); +Expect(1, 8234, '\p{Bidi_Class=lefttorightembedding}', ""); +Expect(0, 8234, '\p{^Bidi_Class=lefttorightembedding}', ""); +Expect(0, 8234, '\P{Bidi_Class=lefttorightembedding}', ""); +Expect(1, 8234, '\P{^Bidi_Class=lefttorightembedding}', ""); +Expect(0, 8233, '\p{Bidi_Class=lefttorightembedding}', ""); +Expect(1, 8233, '\p{^Bidi_Class=lefttorightembedding}', ""); +Expect(1, 8233, '\P{Bidi_Class=lefttorightembedding}', ""); +Expect(0, 8233, '\P{^Bidi_Class=lefttorightembedding}', ""); +Expect(1, 8234, '\p{Bidi_Class=_Left to RightEmbedding}', ""); +Expect(0, 8234, '\p{^Bidi_Class=_Left to RightEmbedding}', ""); +Expect(0, 8234, '\P{Bidi_Class=_Left to RightEmbedding}', ""); +Expect(1, 8234, '\P{^Bidi_Class=_Left to RightEmbedding}', ""); +Expect(0, 8233, '\p{Bidi_Class=_Left to RightEmbedding}', ""); +Expect(1, 8233, '\p{^Bidi_Class=_Left to RightEmbedding}', ""); +Expect(1, 8233, '\P{Bidi_Class=_Left to RightEmbedding}', ""); +Expect(0, 8233, '\P{^Bidi_Class=_Left to RightEmbedding}', ""); +Error('\p{Bc: :=lre}'); +Error('\P{Bc: :=lre}'); +Expect(1, 8234, '\p{Bc=lre}', ""); +Expect(0, 8234, '\p{^Bc=lre}', ""); +Expect(0, 8234, '\P{Bc=lre}', ""); +Expect(1, 8234, '\P{^Bc=lre}', ""); +Expect(0, 8233, '\p{Bc=lre}', ""); +Expect(1, 8233, '\p{^Bc=lre}', ""); +Expect(1, 8233, '\P{Bc=lre}', ""); +Expect(0, 8233, '\P{^Bc=lre}', ""); +Expect(1, 8234, '\p{Bc=- LRE}', ""); +Expect(0, 8234, '\p{^Bc=- LRE}', ""); +Expect(0, 8234, '\P{Bc=- LRE}', ""); +Expect(1, 8234, '\P{^Bc=- LRE}', ""); +Expect(0, 8233, '\p{Bc=- LRE}', ""); +Expect(1, 8233, '\p{^Bc=- LRE}', ""); +Expect(1, 8233, '\P{Bc=- LRE}', ""); +Expect(0, 8233, '\P{^Bc=- LRE}', ""); +Error('\p{Is_Bidi_Class=/a/ LEFTTO rightEMBEDDING}'); +Error('\P{Is_Bidi_Class=/a/ LEFTTO rightEMBEDDING}'); +Expect(1, 8234, '\p{Is_Bidi_Class=lefttorightembedding}', ""); +Expect(0, 8234, '\p{^Is_Bidi_Class=lefttorightembedding}', ""); +Expect(0, 8234, '\P{Is_Bidi_Class=lefttorightembedding}', ""); +Expect(1, 8234, '\P{^Is_Bidi_Class=lefttorightembedding}', ""); +Expect(0, 8233, '\p{Is_Bidi_Class=lefttorightembedding}', ""); +Expect(1, 8233, '\p{^Is_Bidi_Class=lefttorightembedding}', ""); +Expect(1, 8233, '\P{Is_Bidi_Class=lefttorightembedding}', ""); +Expect(0, 8233, '\P{^Is_Bidi_Class=lefttorightembedding}', ""); +Expect(1, 8234, '\p{Is_Bidi_Class= _Left To-RIGHTEmbedding}', ""); +Expect(0, 8234, '\p{^Is_Bidi_Class= _Left To-RIGHTEmbedding}', ""); +Expect(0, 8234, '\P{Is_Bidi_Class= _Left To-RIGHTEmbedding}', ""); +Expect(1, 8234, '\P{^Is_Bidi_Class= _Left To-RIGHTEmbedding}', ""); +Expect(0, 8233, '\p{Is_Bidi_Class= _Left To-RIGHTEmbedding}', ""); +Expect(1, 8233, '\p{^Is_Bidi_Class= _Left To-RIGHTEmbedding}', ""); +Expect(1, 8233, '\P{Is_Bidi_Class= _Left To-RIGHTEmbedding}', ""); +Expect(0, 8233, '\P{^Is_Bidi_Class= _Left To-RIGHTEmbedding}', ""); +Error('\p{Is_Bc=/a/- LRE}'); +Error('\P{Is_Bc=/a/- LRE}'); +Expect(1, 8234, '\p{Is_Bc=lre}', ""); +Expect(0, 8234, '\p{^Is_Bc=lre}', ""); +Expect(0, 8234, '\P{Is_Bc=lre}', ""); +Expect(1, 8234, '\P{^Is_Bc=lre}', ""); +Expect(0, 8233, '\p{Is_Bc=lre}', ""); +Expect(1, 8233, '\p{^Is_Bc=lre}', ""); +Expect(1, 8233, '\P{Is_Bc=lre}', ""); +Expect(0, 8233, '\P{^Is_Bc=lre}', ""); +Expect(1, 8234, '\p{Is_Bc=--lre}', ""); +Expect(0, 8234, '\p{^Is_Bc=--lre}', ""); +Expect(0, 8234, '\P{Is_Bc=--lre}', ""); +Expect(1, 8234, '\P{^Is_Bc=--lre}', ""); +Expect(0, 8233, '\p{Is_Bc=--lre}', ""); +Expect(1, 8233, '\p{^Is_Bc=--lre}', ""); +Expect(1, 8233, '\P{Is_Bc=--lre}', ""); +Expect(0, 8233, '\P{^Is_Bc=--lre}', ""); +Error('\p{Bidi_Class= _arabic_Letter/a/}'); +Error('\P{Bidi_Class= _arabic_Letter/a/}'); +Expect(1, 1541, '\p{Bidi_Class=arabicletter}', ""); +Expect(0, 1541, '\p{^Bidi_Class=arabicletter}', ""); +Expect(0, 1541, '\P{Bidi_Class=arabicletter}', ""); +Expect(1, 1541, '\P{^Bidi_Class=arabicletter}', ""); +Expect(0, 1539, '\p{Bidi_Class=arabicletter}', ""); +Expect(1, 1539, '\p{^Bidi_Class=arabicletter}', ""); +Expect(1, 1539, '\P{Bidi_Class=arabicletter}', ""); +Expect(0, 1539, '\P{^Bidi_Class=arabicletter}', ""); +Expect(1, 1541, '\p{Bidi_Class= _Arabic_Letter}', ""); +Expect(0, 1541, '\p{^Bidi_Class= _Arabic_Letter}', ""); +Expect(0, 1541, '\P{Bidi_Class= _Arabic_Letter}', ""); +Expect(1, 1541, '\P{^Bidi_Class= _Arabic_Letter}', ""); +Expect(0, 1539, '\p{Bidi_Class= _Arabic_Letter}', ""); +Expect(1, 1539, '\p{^Bidi_Class= _Arabic_Letter}', ""); +Expect(1, 1539, '\P{Bidi_Class= _Arabic_Letter}', ""); +Expect(0, 1539, '\P{^Bidi_Class= _Arabic_Letter}', ""); +Error('\p{Bc=/a/ _al}'); +Error('\P{Bc=/a/ _al}'); +Expect(1, 1541, '\p{Bc=al}', ""); +Expect(0, 1541, '\p{^Bc=al}', ""); +Expect(0, 1541, '\P{Bc=al}', ""); +Expect(1, 1541, '\P{^Bc=al}', ""); +Expect(0, 1539, '\p{Bc=al}', ""); +Expect(1, 1539, '\p{^Bc=al}', ""); +Expect(1, 1539, '\P{Bc=al}', ""); +Expect(0, 1539, '\P{^Bc=al}', ""); +Expect(1, 1541, '\p{Bc: -al}', ""); +Expect(0, 1541, '\p{^Bc: -al}', ""); +Expect(0, 1541, '\P{Bc: -al}', ""); +Expect(1, 1541, '\P{^Bc: -al}', ""); +Expect(0, 1539, '\p{Bc: -al}', ""); +Expect(1, 1539, '\p{^Bc: -al}', ""); +Expect(1, 1539, '\P{Bc: -al}', ""); +Expect(0, 1539, '\P{^Bc: -al}', ""); +Error('\p{Is_Bidi_Class= Arabic-Letter/a/}'); +Error('\P{Is_Bidi_Class= Arabic-Letter/a/}'); +Expect(1, 1541, '\p{Is_Bidi_Class=arabicletter}', ""); +Expect(0, 1541, '\p{^Is_Bidi_Class=arabicletter}', ""); +Expect(0, 1541, '\P{Is_Bidi_Class=arabicletter}', ""); +Expect(1, 1541, '\P{^Is_Bidi_Class=arabicletter}', ""); +Expect(0, 1539, '\p{Is_Bidi_Class=arabicletter}', ""); +Expect(1, 1539, '\p{^Is_Bidi_Class=arabicletter}', ""); +Expect(1, 1539, '\P{Is_Bidi_Class=arabicletter}', ""); +Expect(0, 1539, '\P{^Is_Bidi_Class=arabicletter}', ""); +Expect(1, 1541, '\p{Is_Bidi_Class= Arabic_LETTER}', ""); +Expect(0, 1541, '\p{^Is_Bidi_Class= Arabic_LETTER}', ""); +Expect(0, 1541, '\P{Is_Bidi_Class= Arabic_LETTER}', ""); +Expect(1, 1541, '\P{^Is_Bidi_Class= Arabic_LETTER}', ""); +Expect(0, 1539, '\p{Is_Bidi_Class= Arabic_LETTER}', ""); +Expect(1, 1539, '\p{^Is_Bidi_Class= Arabic_LETTER}', ""); +Expect(1, 1539, '\P{Is_Bidi_Class= Arabic_LETTER}', ""); +Expect(0, 1539, '\P{^Is_Bidi_Class= Arabic_LETTER}', ""); +Error('\p{Is_Bc=_AL:=}'); +Error('\P{Is_Bc=_AL:=}'); +Expect(1, 1541, '\p{Is_Bc=al}', ""); +Expect(0, 1541, '\p{^Is_Bc=al}', ""); +Expect(0, 1541, '\P{Is_Bc=al}', ""); +Expect(1, 1541, '\P{^Is_Bc=al}', ""); +Expect(0, 1539, '\p{Is_Bc=al}', ""); +Expect(1, 1539, '\p{^Is_Bc=al}', ""); +Expect(1, 1539, '\P{Is_Bc=al}', ""); +Expect(0, 1539, '\P{^Is_Bc=al}', ""); +Expect(1, 1541, '\p{Is_Bc= _AL}', ""); +Expect(0, 1541, '\p{^Is_Bc= _AL}', ""); +Expect(0, 1541, '\P{Is_Bc= _AL}', ""); +Expect(1, 1541, '\P{^Is_Bc= _AL}', ""); +Expect(0, 1539, '\p{Is_Bc= _AL}', ""); +Expect(1, 1539, '\p{^Is_Bc= _AL}', ""); +Expect(1, 1539, '\P{Is_Bc= _AL}', ""); +Expect(0, 1539, '\P{^Is_Bc= _AL}', ""); +Error('\p{Bidi_Class=:=-common_separator}'); +Error('\P{Bidi_Class=:=-common_separator}'); +Expect(1, 44, '\p{Bidi_Class: commonseparator}', ""); +Expect(0, 44, '\p{^Bidi_Class: commonseparator}', ""); +Expect(0, 44, '\P{Bidi_Class: commonseparator}', ""); +Expect(1, 44, '\P{^Bidi_Class: commonseparator}', ""); +Expect(0, 43, '\p{Bidi_Class: commonseparator}', ""); +Expect(1, 43, '\p{^Bidi_Class: commonseparator}', ""); +Expect(1, 43, '\P{Bidi_Class: commonseparator}', ""); +Expect(0, 43, '\P{^Bidi_Class: commonseparator}', ""); +Expect(1, 44, '\p{Bidi_Class= _common Separator}', ""); +Expect(0, 44, '\p{^Bidi_Class= _common Separator}', ""); +Expect(0, 44, '\P{Bidi_Class= _common Separator}', ""); +Expect(1, 44, '\P{^Bidi_Class= _common Separator}', ""); +Expect(0, 43, '\p{Bidi_Class= _common Separator}', ""); +Expect(1, 43, '\p{^Bidi_Class= _common Separator}', ""); +Expect(1, 43, '\P{Bidi_Class= _common Separator}', ""); +Expect(0, 43, '\P{^Bidi_Class= _common Separator}', ""); +Error('\p{Bc=:=_ CS}'); +Error('\P{Bc=:=_ CS}'); +Expect(1, 44, '\p{Bc=cs}', ""); +Expect(0, 44, '\p{^Bc=cs}', ""); +Expect(0, 44, '\P{Bc=cs}', ""); +Expect(1, 44, '\P{^Bc=cs}', ""); +Expect(0, 43, '\p{Bc=cs}', ""); +Expect(1, 43, '\p{^Bc=cs}', ""); +Expect(1, 43, '\P{Bc=cs}', ""); +Expect(0, 43, '\P{^Bc=cs}', ""); +Expect(1, 44, '\p{Bc= CS}', ""); +Expect(0, 44, '\p{^Bc= CS}', ""); +Expect(0, 44, '\P{Bc= CS}', ""); +Expect(1, 44, '\P{^Bc= CS}', ""); +Expect(0, 43, '\p{Bc= CS}', ""); +Expect(1, 43, '\p{^Bc= CS}', ""); +Expect(1, 43, '\P{Bc= CS}', ""); +Expect(0, 43, '\P{^Bc= CS}', ""); +Error('\p{Is_Bidi_Class= common Separator/a/}'); +Error('\P{Is_Bidi_Class= common Separator/a/}'); +Expect(1, 44, '\p{Is_Bidi_Class=commonseparator}', ""); +Expect(0, 44, '\p{^Is_Bidi_Class=commonseparator}', ""); +Expect(0, 44, '\P{Is_Bidi_Class=commonseparator}', ""); +Expect(1, 44, '\P{^Is_Bidi_Class=commonseparator}', ""); +Expect(0, 43, '\p{Is_Bidi_Class=commonseparator}', ""); +Expect(1, 43, '\p{^Is_Bidi_Class=commonseparator}', ""); +Expect(1, 43, '\P{Is_Bidi_Class=commonseparator}', ""); +Expect(0, 43, '\P{^Is_Bidi_Class=commonseparator}', ""); +Expect(1, 44, '\p{Is_Bidi_Class= -Common-Separator}', ""); +Expect(0, 44, '\p{^Is_Bidi_Class= -Common-Separator}', ""); +Expect(0, 44, '\P{Is_Bidi_Class= -Common-Separator}', ""); +Expect(1, 44, '\P{^Is_Bidi_Class= -Common-Separator}', ""); +Expect(0, 43, '\p{Is_Bidi_Class= -Common-Separator}', ""); +Expect(1, 43, '\p{^Is_Bidi_Class= -Common-Separator}', ""); +Expect(1, 43, '\P{Is_Bidi_Class= -Common-Separator}', ""); +Expect(0, 43, '\P{^Is_Bidi_Class= -Common-Separator}', ""); +Error('\p{Is_Bc= /a/CS}'); +Error('\P{Is_Bc= /a/CS}'); +Expect(1, 44, '\p{Is_Bc=cs}', ""); +Expect(0, 44, '\p{^Is_Bc=cs}', ""); +Expect(0, 44, '\P{Is_Bc=cs}', ""); +Expect(1, 44, '\P{^Is_Bc=cs}', ""); +Expect(0, 43, '\p{Is_Bc=cs}', ""); +Expect(1, 43, '\p{^Is_Bc=cs}', ""); +Expect(1, 43, '\P{Is_Bc=cs}', ""); +Expect(0, 43, '\P{^Is_Bc=cs}', ""); +Expect(1, 44, '\p{Is_Bc: - CS}', ""); +Expect(0, 44, '\p{^Is_Bc: - CS}', ""); +Expect(0, 44, '\P{Is_Bc: - CS}', ""); +Expect(1, 44, '\P{^Is_Bc: - CS}', ""); +Expect(0, 43, '\p{Is_Bc: - CS}', ""); +Expect(1, 43, '\p{^Is_Bc: - CS}', ""); +Expect(1, 43, '\P{Is_Bc: - CS}', ""); +Expect(0, 43, '\P{^Is_Bc: - CS}', ""); +Error('\p{Bidi_Class= :=White_space}'); +Error('\P{Bidi_Class= :=White_space}'); +Expect(1, 12, '\p{Bidi_Class=whitespace}', ""); +Expect(0, 12, '\p{^Bidi_Class=whitespace}', ""); +Expect(0, 12, '\P{Bidi_Class=whitespace}', ""); +Expect(1, 12, '\P{^Bidi_Class=whitespace}', ""); +Expect(0, 7, '\p{Bidi_Class=whitespace}', ""); +Expect(1, 7, '\p{^Bidi_Class=whitespace}', ""); +Expect(1, 7, '\P{Bidi_Class=whitespace}', ""); +Expect(0, 7, '\P{^Bidi_Class=whitespace}', ""); +Expect(1, 12, '\p{Bidi_Class=_ whiteSPACE}', ""); +Expect(0, 12, '\p{^Bidi_Class=_ whiteSPACE}', ""); +Expect(0, 12, '\P{Bidi_Class=_ whiteSPACE}', ""); +Expect(1, 12, '\P{^Bidi_Class=_ whiteSPACE}', ""); +Expect(0, 7, '\p{Bidi_Class=_ whiteSPACE}', ""); +Expect(1, 7, '\p{^Bidi_Class=_ whiteSPACE}', ""); +Expect(1, 7, '\P{Bidi_Class=_ whiteSPACE}', ""); +Expect(0, 7, '\P{^Bidi_Class=_ whiteSPACE}', ""); +Error('\p{Bc=/a/_ WS}'); +Error('\P{Bc=/a/_ WS}'); +Expect(1, 12, '\p{Bc=ws}', ""); +Expect(0, 12, '\p{^Bc=ws}', ""); +Expect(0, 12, '\P{Bc=ws}', ""); +Expect(1, 12, '\P{^Bc=ws}', ""); +Expect(0, 7, '\p{Bc=ws}', ""); +Expect(1, 7, '\p{^Bc=ws}', ""); +Expect(1, 7, '\P{Bc=ws}', ""); +Expect(0, 7, '\P{^Bc=ws}', ""); +Expect(1, 12, '\p{Bc= -WS}', ""); +Expect(0, 12, '\p{^Bc= -WS}', ""); +Expect(0, 12, '\P{Bc= -WS}', ""); +Expect(1, 12, '\P{^Bc= -WS}', ""); +Expect(0, 7, '\p{Bc= -WS}', ""); +Expect(1, 7, '\p{^Bc= -WS}', ""); +Expect(1, 7, '\P{Bc= -WS}', ""); +Expect(0, 7, '\P{^Bc= -WS}', ""); +Error('\p{Is_Bidi_Class: /a/__White SPACE}'); +Error('\P{Is_Bidi_Class: /a/__White SPACE}'); +Expect(1, 12, '\p{Is_Bidi_Class=whitespace}', ""); +Expect(0, 12, '\p{^Is_Bidi_Class=whitespace}', ""); +Expect(0, 12, '\P{Is_Bidi_Class=whitespace}', ""); +Expect(1, 12, '\P{^Is_Bidi_Class=whitespace}', ""); +Expect(0, 7, '\p{Is_Bidi_Class=whitespace}', ""); +Expect(1, 7, '\p{^Is_Bidi_Class=whitespace}', ""); +Expect(1, 7, '\P{Is_Bidi_Class=whitespace}', ""); +Expect(0, 7, '\P{^Is_Bidi_Class=whitespace}', ""); +Expect(1, 12, '\p{Is_Bidi_Class=-_White SPACE}', ""); +Expect(0, 12, '\p{^Is_Bidi_Class=-_White SPACE}', ""); +Expect(0, 12, '\P{Is_Bidi_Class=-_White SPACE}', ""); +Expect(1, 12, '\P{^Is_Bidi_Class=-_White SPACE}', ""); +Expect(0, 7, '\p{Is_Bidi_Class=-_White SPACE}', ""); +Expect(1, 7, '\p{^Is_Bidi_Class=-_White SPACE}', ""); +Expect(1, 7, '\P{Is_Bidi_Class=-_White SPACE}', ""); +Expect(0, 7, '\P{^Is_Bidi_Class=-_White SPACE}', ""); +Error('\p{Is_Bc=/a/ -ws}'); +Error('\P{Is_Bc=/a/ -ws}'); +Expect(1, 12, '\p{Is_Bc=ws}', ""); +Expect(0, 12, '\p{^Is_Bc=ws}', ""); +Expect(0, 12, '\P{Is_Bc=ws}', ""); +Expect(1, 12, '\P{^Is_Bc=ws}', ""); +Expect(0, 7, '\p{Is_Bc=ws}', ""); +Expect(1, 7, '\p{^Is_Bc=ws}', ""); +Expect(1, 7, '\P{Is_Bc=ws}', ""); +Expect(0, 7, '\P{^Is_Bc=ws}', ""); +Expect(1, 12, '\p{Is_Bc: - WS}', ""); +Expect(0, 12, '\p{^Is_Bc: - WS}', ""); +Expect(0, 12, '\P{Is_Bc: - WS}', ""); +Expect(1, 12, '\P{^Is_Bc: - WS}', ""); +Expect(0, 7, '\p{Is_Bc: - WS}', ""); +Expect(1, 7, '\p{^Is_Bc: - WS}', ""); +Expect(1, 7, '\P{Is_Bc: - WS}', ""); +Expect(0, 7, '\P{^Is_Bc: - WS}', ""); +Error('\p{Bidi_Class=-ParagraphSeparator:=}'); +Error('\P{Bidi_Class=-ParagraphSeparator:=}'); +Expect(1, 10, '\p{Bidi_Class=paragraphseparator}', ""); +Expect(0, 10, '\p{^Bidi_Class=paragraphseparator}', ""); +Expect(0, 10, '\P{Bidi_Class=paragraphseparator}', ""); +Expect(1, 10, '\P{^Bidi_Class=paragraphseparator}', ""); +Expect(0, 9, '\p{Bidi_Class=paragraphseparator}', ""); +Expect(1, 9, '\p{^Bidi_Class=paragraphseparator}', ""); +Expect(1, 9, '\P{Bidi_Class=paragraphseparator}', ""); +Expect(0, 9, '\P{^Bidi_Class=paragraphseparator}', ""); +Expect(1, 10, '\p{Bidi_Class= -Paragraph Separator}', ""); +Expect(0, 10, '\p{^Bidi_Class= -Paragraph Separator}', ""); +Expect(0, 10, '\P{Bidi_Class= -Paragraph Separator}', ""); +Expect(1, 10, '\P{^Bidi_Class= -Paragraph Separator}', ""); +Expect(0, 9, '\p{Bidi_Class= -Paragraph Separator}', ""); +Expect(1, 9, '\p{^Bidi_Class= -Paragraph Separator}', ""); +Expect(1, 9, '\P{Bidi_Class= -Paragraph Separator}', ""); +Expect(0, 9, '\P{^Bidi_Class= -Paragraph Separator}', ""); +Error('\p{Bc= :=B}'); +Error('\P{Bc= :=B}'); +Expect(1, 10, '\p{Bc=b}', ""); +Expect(0, 10, '\p{^Bc=b}', ""); +Expect(0, 10, '\P{Bc=b}', ""); +Expect(1, 10, '\P{^Bc=b}', ""); +Expect(0, 9, '\p{Bc=b}', ""); +Expect(1, 9, '\p{^Bc=b}', ""); +Expect(1, 9, '\P{Bc=b}', ""); +Expect(0, 9, '\P{^Bc=b}', ""); +Expect(1, 10, '\p{Bc= B}', ""); +Expect(0, 10, '\p{^Bc= B}', ""); +Expect(0, 10, '\P{Bc= B}', ""); +Expect(1, 10, '\P{^Bc= B}', ""); +Expect(0, 9, '\p{Bc= B}', ""); +Expect(1, 9, '\p{^Bc= B}', ""); +Expect(1, 9, '\P{Bc= B}', ""); +Expect(0, 9, '\P{^Bc= B}', ""); +Error('\p{Is_Bidi_Class=--Paragraph/a/separator}'); +Error('\P{Is_Bidi_Class=--Paragraph/a/separator}'); +Expect(1, 10, '\p{Is_Bidi_Class=paragraphseparator}', ""); +Expect(0, 10, '\p{^Is_Bidi_Class=paragraphseparator}', ""); +Expect(0, 10, '\P{Is_Bidi_Class=paragraphseparator}', ""); +Expect(1, 10, '\P{^Is_Bidi_Class=paragraphseparator}', ""); +Expect(0, 9, '\p{Is_Bidi_Class=paragraphseparator}', ""); +Expect(1, 9, '\p{^Is_Bidi_Class=paragraphseparator}', ""); +Expect(1, 9, '\P{Is_Bidi_Class=paragraphseparator}', ""); +Expect(0, 9, '\P{^Is_Bidi_Class=paragraphseparator}', ""); +Expect(1, 10, '\p{Is_Bidi_Class: Paragraphseparator}', ""); +Expect(0, 10, '\p{^Is_Bidi_Class: Paragraphseparator}', ""); +Expect(0, 10, '\P{Is_Bidi_Class: Paragraphseparator}', ""); +Expect(1, 10, '\P{^Is_Bidi_Class: Paragraphseparator}', ""); +Expect(0, 9, '\p{Is_Bidi_Class: Paragraphseparator}', ""); +Expect(1, 9, '\p{^Is_Bidi_Class: Paragraphseparator}', ""); +Expect(1, 9, '\P{Is_Bidi_Class: Paragraphseparator}', ""); +Expect(0, 9, '\P{^Is_Bidi_Class: Paragraphseparator}', ""); +Error('\p{Is_Bc=:= b}'); +Error('\P{Is_Bc=:= b}'); +Expect(1, 10, '\p{Is_Bc=b}', ""); +Expect(0, 10, '\p{^Is_Bc=b}', ""); +Expect(0, 10, '\P{Is_Bc=b}', ""); +Expect(1, 10, '\P{^Is_Bc=b}', ""); +Expect(0, 9, '\p{Is_Bc=b}', ""); +Expect(1, 9, '\p{^Is_Bc=b}', ""); +Expect(1, 9, '\P{Is_Bc=b}', ""); +Expect(0, 9, '\P{^Is_Bc=b}', ""); +Expect(1, 10, '\p{Is_Bc: -B}', ""); +Expect(0, 10, '\p{^Is_Bc: -B}', ""); +Expect(0, 10, '\P{Is_Bc: -B}', ""); +Expect(1, 10, '\P{^Is_Bc: -B}', ""); +Expect(0, 9, '\p{Is_Bc: -B}', ""); +Expect(1, 9, '\p{^Is_Bc: -B}', ""); +Expect(1, 9, '\P{Is_Bc: -B}', ""); +Expect(0, 9, '\P{^Is_Bc: -B}', ""); +Error('\p{Bidi_Class=Nonspacing/a/mark}'); +Error('\P{Bidi_Class=Nonspacing/a/mark}'); +Expect(1, 879, '\p{Bidi_Class=nonspacingmark}', ""); +Expect(0, 879, '\p{^Bidi_Class=nonspacingmark}', ""); +Expect(0, 879, '\P{Bidi_Class=nonspacingmark}', ""); +Expect(1, 879, '\P{^Bidi_Class=nonspacingmark}', ""); +Expect(0, 767, '\p{Bidi_Class=nonspacingmark}', ""); +Expect(1, 767, '\p{^Bidi_Class=nonspacingmark}', ""); +Expect(1, 767, '\P{Bidi_Class=nonspacingmark}', ""); +Expect(0, 767, '\P{^Bidi_Class=nonspacingmark}', ""); +Expect(1, 879, '\p{Bidi_Class= -NonspacingMARK}', ""); +Expect(0, 879, '\p{^Bidi_Class= -NonspacingMARK}', ""); +Expect(0, 879, '\P{Bidi_Class= -NonspacingMARK}', ""); +Expect(1, 879, '\P{^Bidi_Class= -NonspacingMARK}', ""); +Expect(0, 767, '\p{Bidi_Class= -NonspacingMARK}', ""); +Expect(1, 767, '\p{^Bidi_Class= -NonspacingMARK}', ""); +Expect(1, 767, '\P{Bidi_Class= -NonspacingMARK}', ""); +Expect(0, 767, '\P{^Bidi_Class= -NonspacingMARK}', ""); +Error('\p{Bc=:= _NSM}'); +Error('\P{Bc=:= _NSM}'); +Expect(1, 879, '\p{Bc=nsm}', ""); +Expect(0, 879, '\p{^Bc=nsm}', ""); +Expect(0, 879, '\P{Bc=nsm}', ""); +Expect(1, 879, '\P{^Bc=nsm}', ""); +Expect(0, 767, '\p{Bc=nsm}', ""); +Expect(1, 767, '\p{^Bc=nsm}', ""); +Expect(1, 767, '\P{Bc=nsm}', ""); +Expect(0, 767, '\P{^Bc=nsm}', ""); +Expect(1, 879, '\p{Bc=NSM}', ""); +Expect(0, 879, '\p{^Bc=NSM}', ""); +Expect(0, 879, '\P{Bc=NSM}', ""); +Expect(1, 879, '\P{^Bc=NSM}', ""); +Expect(0, 767, '\p{Bc=NSM}', ""); +Expect(1, 767, '\p{^Bc=NSM}', ""); +Expect(1, 767, '\P{Bc=NSM}', ""); +Expect(0, 767, '\P{^Bc=NSM}', ""); +Error('\p{Is_Bidi_Class: nonspacing_mark/a/}'); +Error('\P{Is_Bidi_Class: nonspacing_mark/a/}'); +Expect(1, 879, '\p{Is_Bidi_Class=nonspacingmark}', ""); +Expect(0, 879, '\p{^Is_Bidi_Class=nonspacingmark}', ""); +Expect(0, 879, '\P{Is_Bidi_Class=nonspacingmark}', ""); +Expect(1, 879, '\P{^Is_Bidi_Class=nonspacingmark}', ""); +Expect(0, 767, '\p{Is_Bidi_Class=nonspacingmark}', ""); +Expect(1, 767, '\p{^Is_Bidi_Class=nonspacingmark}', ""); +Expect(1, 767, '\P{Is_Bidi_Class=nonspacingmark}', ""); +Expect(0, 767, '\P{^Is_Bidi_Class=nonspacingmark}', ""); +Expect(1, 879, '\p{Is_Bidi_Class= nonspacing MARK}', ""); +Expect(0, 879, '\p{^Is_Bidi_Class= nonspacing MARK}', ""); +Expect(0, 879, '\P{Is_Bidi_Class= nonspacing MARK}', ""); +Expect(1, 879, '\P{^Is_Bidi_Class= nonspacing MARK}', ""); +Expect(0, 767, '\p{Is_Bidi_Class= nonspacing MARK}', ""); +Expect(1, 767, '\p{^Is_Bidi_Class= nonspacing MARK}', ""); +Expect(1, 767, '\P{Is_Bidi_Class= nonspacing MARK}', ""); +Expect(0, 767, '\P{^Is_Bidi_Class= nonspacing MARK}', ""); +Error('\p{Is_Bc:- nsm:=}'); +Error('\P{Is_Bc:- nsm:=}'); +Expect(1, 879, '\p{Is_Bc=nsm}', ""); +Expect(0, 879, '\p{^Is_Bc=nsm}', ""); +Expect(0, 879, '\P{Is_Bc=nsm}', ""); +Expect(1, 879, '\P{^Is_Bc=nsm}', ""); +Expect(0, 767, '\p{Is_Bc=nsm}', ""); +Expect(1, 767, '\p{^Is_Bc=nsm}', ""); +Expect(1, 767, '\P{Is_Bc=nsm}', ""); +Expect(0, 767, '\P{^Is_Bc=nsm}', ""); +Expect(1, 879, '\p{Is_Bc=--NSM}', ""); +Expect(0, 879, '\p{^Is_Bc=--NSM}', ""); +Expect(0, 879, '\P{Is_Bc=--NSM}', ""); +Expect(1, 879, '\P{^Is_Bc=--NSM}', ""); +Expect(0, 767, '\p{Is_Bc=--NSM}', ""); +Expect(1, 767, '\p{^Is_Bc=--NSM}', ""); +Expect(1, 767, '\P{Is_Bc=--NSM}', ""); +Expect(0, 767, '\P{^Is_Bc=--NSM}', ""); +Error('\p{Bidi_Class::= EUROPEAN_SEPARATOR}'); +Error('\P{Bidi_Class::= EUROPEAN_SEPARATOR}'); +Expect(1, 43, '\p{Bidi_Class: europeanseparator}', ""); +Expect(0, 43, '\p{^Bidi_Class: europeanseparator}', ""); +Expect(0, 43, '\P{Bidi_Class: europeanseparator}', ""); +Expect(1, 43, '\P{^Bidi_Class: europeanseparator}', ""); +Expect(0, 42, '\p{Bidi_Class: europeanseparator}', ""); +Expect(1, 42, '\p{^Bidi_Class: europeanseparator}', ""); +Expect(1, 42, '\P{Bidi_Class: europeanseparator}', ""); +Expect(0, 42, '\P{^Bidi_Class: europeanseparator}', ""); +Expect(1, 43, '\p{Bidi_Class=-European SEPARATOR}', ""); +Expect(0, 43, '\p{^Bidi_Class=-European SEPARATOR}', ""); +Expect(0, 43, '\P{Bidi_Class=-European SEPARATOR}', ""); +Expect(1, 43, '\P{^Bidi_Class=-European SEPARATOR}', ""); +Expect(0, 42, '\p{Bidi_Class=-European SEPARATOR}', ""); +Expect(1, 42, '\p{^Bidi_Class=-European SEPARATOR}', ""); +Expect(1, 42, '\P{Bidi_Class=-European SEPARATOR}', ""); +Expect(0, 42, '\P{^Bidi_Class=-European SEPARATOR}', ""); +Error('\p{Bc= _ES:=}'); +Error('\P{Bc= _ES:=}'); +Expect(1, 43, '\p{Bc=es}', ""); +Expect(0, 43, '\p{^Bc=es}', ""); +Expect(0, 43, '\P{Bc=es}', ""); +Expect(1, 43, '\P{^Bc=es}', ""); +Expect(0, 42, '\p{Bc=es}', ""); +Expect(1, 42, '\p{^Bc=es}', ""); +Expect(1, 42, '\P{Bc=es}', ""); +Expect(0, 42, '\P{^Bc=es}', ""); +Expect(1, 43, '\p{Bc=_ES}', ""); +Expect(0, 43, '\p{^Bc=_ES}', ""); +Expect(0, 43, '\P{Bc=_ES}', ""); +Expect(1, 43, '\P{^Bc=_ES}', ""); +Expect(0, 42, '\p{Bc=_ES}', ""); +Expect(1, 42, '\p{^Bc=_ES}', ""); +Expect(1, 42, '\P{Bc=_ES}', ""); +Expect(0, 42, '\P{^Bc=_ES}', ""); +Error('\p{Is_Bidi_Class= :=europeanSeparator}'); +Error('\P{Is_Bidi_Class= :=europeanSeparator}'); +Expect(1, 43, '\p{Is_Bidi_Class=europeanseparator}', ""); +Expect(0, 43, '\p{^Is_Bidi_Class=europeanseparator}', ""); +Expect(0, 43, '\P{Is_Bidi_Class=europeanseparator}', ""); +Expect(1, 43, '\P{^Is_Bidi_Class=europeanseparator}', ""); +Expect(0, 42, '\p{Is_Bidi_Class=europeanseparator}', ""); +Expect(1, 42, '\p{^Is_Bidi_Class=europeanseparator}', ""); +Expect(1, 42, '\P{Is_Bidi_Class=europeanseparator}', ""); +Expect(0, 42, '\P{^Is_Bidi_Class=europeanseparator}', ""); +Expect(1, 43, '\p{Is_Bidi_Class=-european_Separator}', ""); +Expect(0, 43, '\p{^Is_Bidi_Class=-european_Separator}', ""); +Expect(0, 43, '\P{Is_Bidi_Class=-european_Separator}', ""); +Expect(1, 43, '\P{^Is_Bidi_Class=-european_Separator}', ""); +Expect(0, 42, '\p{Is_Bidi_Class=-european_Separator}', ""); +Expect(1, 42, '\p{^Is_Bidi_Class=-european_Separator}', ""); +Expect(1, 42, '\P{Is_Bidi_Class=-european_Separator}', ""); +Expect(0, 42, '\P{^Is_Bidi_Class=-european_Separator}', ""); +Error('\p{Is_Bc=/a/ ES}'); +Error('\P{Is_Bc=/a/ ES}'); +Expect(1, 43, '\p{Is_Bc=es}', ""); +Expect(0, 43, '\p{^Is_Bc=es}', ""); +Expect(0, 43, '\P{Is_Bc=es}', ""); +Expect(1, 43, '\P{^Is_Bc=es}', ""); +Expect(0, 42, '\p{Is_Bc=es}', ""); +Expect(1, 42, '\p{^Is_Bc=es}', ""); +Expect(1, 42, '\P{Is_Bc=es}', ""); +Expect(0, 42, '\P{^Is_Bc=es}', ""); +Expect(1, 43, '\p{Is_Bc= ES}', ""); +Expect(0, 43, '\p{^Is_Bc= ES}', ""); +Expect(0, 43, '\P{Is_Bc= ES}', ""); +Expect(1, 43, '\P{^Is_Bc= ES}', ""); +Expect(0, 42, '\p{Is_Bc= ES}', ""); +Expect(1, 42, '\p{^Is_Bc= ES}', ""); +Expect(1, 42, '\P{Is_Bc= ES}', ""); +Expect(0, 42, '\P{^Is_Bc= ES}', ""); +Error('\p{Bidi_Class=-:=EUROPEAN Number}'); +Error('\P{Bidi_Class=-:=EUROPEAN Number}'); +Expect(1, 57, '\p{Bidi_Class=europeannumber}', ""); +Expect(0, 57, '\p{^Bidi_Class=europeannumber}', ""); +Expect(0, 57, '\P{Bidi_Class=europeannumber}', ""); +Expect(1, 57, '\P{^Bidi_Class=europeannumber}', ""); +Expect(0, 47, '\p{Bidi_Class=europeannumber}', ""); +Expect(1, 47, '\p{^Bidi_Class=europeannumber}', ""); +Expect(1, 47, '\P{Bidi_Class=europeannumber}', ""); +Expect(0, 47, '\P{^Bidi_Class=europeannumber}', ""); +Expect(1, 57, '\p{Bidi_Class: European-Number}', ""); +Expect(0, 57, '\p{^Bidi_Class: European-Number}', ""); +Expect(0, 57, '\P{Bidi_Class: European-Number}', ""); +Expect(1, 57, '\P{^Bidi_Class: European-Number}', ""); +Expect(0, 47, '\p{Bidi_Class: European-Number}', ""); +Expect(1, 47, '\p{^Bidi_Class: European-Number}', ""); +Expect(1, 47, '\P{Bidi_Class: European-Number}', ""); +Expect(0, 47, '\P{^Bidi_Class: European-Number}', ""); +Error('\p{Bc=_EN/a/}'); +Error('\P{Bc=_EN/a/}'); +Expect(1, 57, '\p{Bc=en}', ""); +Expect(0, 57, '\p{^Bc=en}', ""); +Expect(0, 57, '\P{Bc=en}', ""); +Expect(1, 57, '\P{^Bc=en}', ""); +Expect(0, 47, '\p{Bc=en}', ""); +Expect(1, 47, '\p{^Bc=en}', ""); +Expect(1, 47, '\P{Bc=en}', ""); +Expect(0, 47, '\P{^Bc=en}', ""); +Expect(1, 57, '\p{Bc= _EN}', ""); +Expect(0, 57, '\p{^Bc= _EN}', ""); +Expect(0, 57, '\P{Bc= _EN}', ""); +Expect(1, 57, '\P{^Bc= _EN}', ""); +Expect(0, 47, '\p{Bc= _EN}', ""); +Expect(1, 47, '\p{^Bc= _EN}', ""); +Expect(1, 47, '\P{Bc= _EN}', ""); +Expect(0, 47, '\P{^Bc= _EN}', ""); +Error('\p{Is_Bidi_Class: -EUROPEAN:=number}'); +Error('\P{Is_Bidi_Class: -EUROPEAN:=number}'); +Expect(1, 57, '\p{Is_Bidi_Class=europeannumber}', ""); +Expect(0, 57, '\p{^Is_Bidi_Class=europeannumber}', ""); +Expect(0, 57, '\P{Is_Bidi_Class=europeannumber}', ""); +Expect(1, 57, '\P{^Is_Bidi_Class=europeannumber}', ""); +Expect(0, 47, '\p{Is_Bidi_Class=europeannumber}', ""); +Expect(1, 47, '\p{^Is_Bidi_Class=europeannumber}', ""); +Expect(1, 47, '\P{Is_Bidi_Class=europeannumber}', ""); +Expect(0, 47, '\P{^Is_Bidi_Class=europeannumber}', ""); +Expect(1, 57, '\p{Is_Bidi_Class= -EUROPEAN Number}', ""); +Expect(0, 57, '\p{^Is_Bidi_Class= -EUROPEAN Number}', ""); +Expect(0, 57, '\P{Is_Bidi_Class= -EUROPEAN Number}', ""); +Expect(1, 57, '\P{^Is_Bidi_Class= -EUROPEAN Number}', ""); +Expect(0, 47, '\p{Is_Bidi_Class= -EUROPEAN Number}', ""); +Expect(1, 47, '\p{^Is_Bidi_Class= -EUROPEAN Number}', ""); +Expect(1, 47, '\P{Is_Bidi_Class= -EUROPEAN Number}', ""); +Expect(0, 47, '\P{^Is_Bidi_Class= -EUROPEAN Number}', ""); +Error('\p{Is_Bc= -EN/a/}'); +Error('\P{Is_Bc= -EN/a/}'); +Expect(1, 57, '\p{Is_Bc=en}', ""); +Expect(0, 57, '\p{^Is_Bc=en}', ""); +Expect(0, 57, '\P{Is_Bc=en}', ""); +Expect(1, 57, '\P{^Is_Bc=en}', ""); +Expect(0, 47, '\p{Is_Bc=en}', ""); +Expect(1, 47, '\p{^Is_Bc=en}', ""); +Expect(1, 47, '\P{Is_Bc=en}', ""); +Expect(0, 47, '\P{^Is_Bc=en}', ""); +Expect(1, 57, '\p{Is_Bc=_-EN}', ""); +Expect(0, 57, '\p{^Is_Bc=_-EN}', ""); +Expect(0, 57, '\P{Is_Bc=_-EN}', ""); +Expect(1, 57, '\P{^Is_Bc=_-EN}', ""); +Expect(0, 47, '\p{Is_Bc=_-EN}', ""); +Expect(1, 47, '\p{^Is_Bc=_-EN}', ""); +Expect(1, 47, '\P{Is_Bc=_-EN}', ""); +Expect(0, 47, '\P{^Is_Bc=_-EN}', ""); +Error('\p{Bidi_Class=:=European Terminator}'); +Error('\P{Bidi_Class=:=European Terminator}'); +Expect(1, 37, '\p{Bidi_Class=europeanterminator}', ""); +Expect(0, 37, '\p{^Bidi_Class=europeanterminator}', ""); +Expect(0, 37, '\P{Bidi_Class=europeanterminator}', ""); +Expect(1, 37, '\P{^Bidi_Class=europeanterminator}', ""); +Expect(0, 34, '\p{Bidi_Class=europeanterminator}', ""); +Expect(1, 34, '\p{^Bidi_Class=europeanterminator}', ""); +Expect(1, 34, '\P{Bidi_Class=europeanterminator}', ""); +Expect(0, 34, '\P{^Bidi_Class=europeanterminator}', ""); +Expect(1, 37, '\p{Bidi_Class= European terminator}', ""); +Expect(0, 37, '\p{^Bidi_Class= European terminator}', ""); +Expect(0, 37, '\P{Bidi_Class= European terminator}', ""); +Expect(1, 37, '\P{^Bidi_Class= European terminator}', ""); +Expect(0, 34, '\p{Bidi_Class= European terminator}', ""); +Expect(1, 34, '\p{^Bidi_Class= European terminator}', ""); +Expect(1, 34, '\P{Bidi_Class= European terminator}', ""); +Expect(0, 34, '\P{^Bidi_Class= European terminator}', ""); +Error('\p{Bc=_ ET/a/}'); +Error('\P{Bc=_ ET/a/}'); +Expect(1, 37, '\p{Bc=et}', ""); +Expect(0, 37, '\p{^Bc=et}', ""); +Expect(0, 37, '\P{Bc=et}', ""); +Expect(1, 37, '\P{^Bc=et}', ""); +Expect(0, 34, '\p{Bc=et}', ""); +Expect(1, 34, '\p{^Bc=et}', ""); +Expect(1, 34, '\P{Bc=et}', ""); +Expect(0, 34, '\P{^Bc=et}', ""); +Expect(1, 37, '\p{Bc=_et}', ""); +Expect(0, 37, '\p{^Bc=_et}', ""); +Expect(0, 37, '\P{Bc=_et}', ""); +Expect(1, 37, '\P{^Bc=_et}', ""); +Expect(0, 34, '\p{Bc=_et}', ""); +Expect(1, 34, '\p{^Bc=_et}', ""); +Expect(1, 34, '\P{Bc=_et}', ""); +Expect(0, 34, '\P{^Bc=_et}', ""); +Error('\p{Is_Bidi_Class=:=_European_terminator}'); +Error('\P{Is_Bidi_Class=:=_European_terminator}'); +Expect(1, 37, '\p{Is_Bidi_Class=europeanterminator}', ""); +Expect(0, 37, '\p{^Is_Bidi_Class=europeanterminator}', ""); +Expect(0, 37, '\P{Is_Bidi_Class=europeanterminator}', ""); +Expect(1, 37, '\P{^Is_Bidi_Class=europeanterminator}', ""); +Expect(0, 34, '\p{Is_Bidi_Class=europeanterminator}', ""); +Expect(1, 34, '\p{^Is_Bidi_Class=europeanterminator}', ""); +Expect(1, 34, '\P{Is_Bidi_Class=europeanterminator}', ""); +Expect(0, 34, '\P{^Is_Bidi_Class=europeanterminator}', ""); +Expect(1, 37, '\p{Is_Bidi_Class=_European_Terminator}', ""); +Expect(0, 37, '\p{^Is_Bidi_Class=_European_Terminator}', ""); +Expect(0, 37, '\P{Is_Bidi_Class=_European_Terminator}', ""); +Expect(1, 37, '\P{^Is_Bidi_Class=_European_Terminator}', ""); +Expect(0, 34, '\p{Is_Bidi_Class=_European_Terminator}', ""); +Expect(1, 34, '\p{^Is_Bidi_Class=_European_Terminator}', ""); +Expect(1, 34, '\P{Is_Bidi_Class=_European_Terminator}', ""); +Expect(0, 34, '\P{^Is_Bidi_Class=_European_Terminator}', ""); +Error('\p{Is_Bc= _et:=}'); +Error('\P{Is_Bc= _et:=}'); +Expect(1, 37, '\p{Is_Bc=et}', ""); +Expect(0, 37, '\p{^Is_Bc=et}', ""); +Expect(0, 37, '\P{Is_Bc=et}', ""); +Expect(1, 37, '\P{^Is_Bc=et}', ""); +Expect(0, 34, '\p{Is_Bc=et}', ""); +Expect(1, 34, '\p{^Is_Bc=et}', ""); +Expect(1, 34, '\P{Is_Bc=et}', ""); +Expect(0, 34, '\P{^Is_Bc=et}', ""); +Error('\p{Bidi_Class= Arabic/a/number}'); +Error('\P{Bidi_Class= Arabic/a/number}'); +Expect(1, 1539, '\p{Bidi_Class=arabicnumber}', ""); +Expect(0, 1539, '\p{^Bidi_Class=arabicnumber}', ""); +Expect(0, 1539, '\P{Bidi_Class=arabicnumber}', ""); +Expect(1, 1539, '\P{^Bidi_Class=arabicnumber}', ""); +Expect(0, 1535, '\p{Bidi_Class=arabicnumber}', ""); +Expect(1, 1535, '\p{^Bidi_Class=arabicnumber}', ""); +Expect(1, 1535, '\P{Bidi_Class=arabicnumber}', ""); +Expect(0, 1535, '\P{^Bidi_Class=arabicnumber}', ""); +Expect(1, 1539, '\p{Bidi_Class=_Arabic_Number}', ""); +Expect(0, 1539, '\p{^Bidi_Class=_Arabic_Number}', ""); +Expect(0, 1539, '\P{Bidi_Class=_Arabic_Number}', ""); +Expect(1, 1539, '\P{^Bidi_Class=_Arabic_Number}', ""); +Expect(0, 1535, '\p{Bidi_Class=_Arabic_Number}', ""); +Expect(1, 1535, '\p{^Bidi_Class=_Arabic_Number}', ""); +Expect(1, 1535, '\P{Bidi_Class=_Arabic_Number}', ""); +Expect(0, 1535, '\P{^Bidi_Class=_Arabic_Number}', ""); +Error('\p{Bc=/a/ _an}'); +Error('\P{Bc=/a/ _an}'); +Expect(1, 1539, '\p{Bc: an}', ""); +Expect(0, 1539, '\p{^Bc: an}', ""); +Expect(0, 1539, '\P{Bc: an}', ""); +Expect(1, 1539, '\P{^Bc: an}', ""); +Expect(0, 1535, '\p{Bc: an}', ""); +Expect(1, 1535, '\p{^Bc: an}', ""); +Expect(1, 1535, '\P{Bc: an}', ""); +Expect(0, 1535, '\P{^Bc: an}', ""); +Expect(1, 1539, '\p{Bc= -AN}', ""); +Expect(0, 1539, '\p{^Bc= -AN}', ""); +Expect(0, 1539, '\P{Bc= -AN}', ""); +Expect(1, 1539, '\P{^Bc= -AN}', ""); +Expect(0, 1535, '\p{Bc= -AN}', ""); +Expect(1, 1535, '\p{^Bc= -AN}', ""); +Expect(1, 1535, '\P{Bc= -AN}', ""); +Expect(0, 1535, '\P{^Bc= -AN}', ""); +Error('\p{Is_Bidi_Class= ARABIC:=Number}'); +Error('\P{Is_Bidi_Class= ARABIC:=Number}'); +Expect(1, 1539, '\p{Is_Bidi_Class=arabicnumber}', ""); +Expect(0, 1539, '\p{^Is_Bidi_Class=arabicnumber}', ""); +Expect(0, 1539, '\P{Is_Bidi_Class=arabicnumber}', ""); +Expect(1, 1539, '\P{^Is_Bidi_Class=arabicnumber}', ""); +Expect(0, 1535, '\p{Is_Bidi_Class=arabicnumber}', ""); +Expect(1, 1535, '\p{^Is_Bidi_Class=arabicnumber}', ""); +Expect(1, 1535, '\P{Is_Bidi_Class=arabicnumber}', ""); +Expect(0, 1535, '\P{^Is_Bidi_Class=arabicnumber}', ""); +Expect(1, 1539, '\p{Is_Bidi_Class= _arabic-Number}', ""); +Expect(0, 1539, '\p{^Is_Bidi_Class= _arabic-Number}', ""); +Expect(0, 1539, '\P{Is_Bidi_Class= _arabic-Number}', ""); +Expect(1, 1539, '\P{^Is_Bidi_Class= _arabic-Number}', ""); +Expect(0, 1535, '\p{Is_Bidi_Class= _arabic-Number}', ""); +Expect(1, 1535, '\p{^Is_Bidi_Class= _arabic-Number}', ""); +Expect(1, 1535, '\P{Is_Bidi_Class= _arabic-Number}', ""); +Expect(0, 1535, '\P{^Is_Bidi_Class= _arabic-Number}', ""); +Error('\p{Is_Bc=/a/ -an}'); +Error('\P{Is_Bc=/a/ -an}'); +Expect(1, 1539, '\p{Is_Bc=an}', ""); +Expect(0, 1539, '\p{^Is_Bc=an}', ""); +Expect(0, 1539, '\P{Is_Bc=an}', ""); +Expect(1, 1539, '\P{^Is_Bc=an}', ""); +Expect(0, 1535, '\p{Is_Bc=an}', ""); +Expect(1, 1535, '\p{^Is_Bc=an}', ""); +Expect(1, 1535, '\P{Is_Bc=an}', ""); +Expect(0, 1535, '\P{^Is_Bc=an}', ""); +Expect(1, 1539, '\p{Is_Bc=- an}', ""); +Expect(0, 1539, '\p{^Is_Bc=- an}', ""); +Expect(0, 1539, '\P{Is_Bc=- an}', ""); +Expect(1, 1539, '\P{^Is_Bc=- an}', ""); +Expect(0, 1535, '\p{Is_Bc=- an}', ""); +Expect(1, 1535, '\p{^Is_Bc=- an}', ""); +Expect(1, 1535, '\P{Is_Bc=- an}', ""); +Expect(0, 1535, '\P{^Is_Bc=- an}', ""); +Error('\p{Bidi_Class= right TO:=LEFT}'); +Error('\P{Bidi_Class= right TO:=LEFT}'); +Expect(1, 1424, '\p{Bidi_Class=righttoleft}', ""); +Expect(0, 1424, '\p{^Bidi_Class=righttoleft}', ""); +Expect(0, 1424, '\P{Bidi_Class=righttoleft}', ""); +Expect(1, 1424, '\P{^Bidi_Class=righttoleft}', ""); +Expect(0, 1423, '\p{Bidi_Class=righttoleft}', ""); +Expect(1, 1423, '\p{^Bidi_Class=righttoleft}', ""); +Expect(1, 1423, '\P{Bidi_Class=righttoleft}', ""); +Expect(0, 1423, '\P{^Bidi_Class=righttoleft}', ""); +Expect(1, 1424, '\p{Bidi_Class= right TO Left}', ""); +Expect(0, 1424, '\p{^Bidi_Class= right TO Left}', ""); +Expect(0, 1424, '\P{Bidi_Class= right TO Left}', ""); +Expect(1, 1424, '\P{^Bidi_Class= right TO Left}', ""); +Expect(0, 1423, '\p{Bidi_Class= right TO Left}', ""); +Expect(1, 1423, '\p{^Bidi_Class= right TO Left}', ""); +Expect(1, 1423, '\P{Bidi_Class= right TO Left}', ""); +Expect(0, 1423, '\P{^Bidi_Class= right TO Left}', ""); +Error('\p{Bc=:= -R}'); +Error('\P{Bc=:= -R}'); +Expect(1, 1424, '\p{Bc: r}', ""); +Expect(0, 1424, '\p{^Bc: r}', ""); +Expect(0, 1424, '\P{Bc: r}', ""); +Expect(1, 1424, '\P{^Bc: r}', ""); +Expect(0, 1423, '\p{Bc: r}', ""); +Expect(1, 1423, '\p{^Bc: r}', ""); +Expect(1, 1423, '\P{Bc: r}', ""); +Expect(0, 1423, '\P{^Bc: r}', ""); +Expect(1, 1424, '\p{Bc=_-R}', ""); +Expect(0, 1424, '\p{^Bc=_-R}', ""); +Expect(0, 1424, '\P{Bc=_-R}', ""); +Expect(1, 1424, '\P{^Bc=_-R}', ""); +Expect(0, 1423, '\p{Bc=_-R}', ""); +Expect(1, 1423, '\p{^Bc=_-R}', ""); +Expect(1, 1423, '\P{Bc=_-R}', ""); +Expect(0, 1423, '\P{^Bc=_-R}', ""); +Error('\p{Is_Bidi_Class=- RIGHT/a/TO_left}'); +Error('\P{Is_Bidi_Class=- RIGHT/a/TO_left}'); +Expect(1, 1424, '\p{Is_Bidi_Class=righttoleft}', ""); +Expect(0, 1424, '\p{^Is_Bidi_Class=righttoleft}', ""); +Expect(0, 1424, '\P{Is_Bidi_Class=righttoleft}', ""); +Expect(1, 1424, '\P{^Is_Bidi_Class=righttoleft}', ""); +Expect(0, 1423, '\p{Is_Bidi_Class=righttoleft}', ""); +Expect(1, 1423, '\p{^Is_Bidi_Class=righttoleft}', ""); +Expect(1, 1423, '\P{Is_Bidi_Class=righttoleft}', ""); +Expect(0, 1423, '\P{^Is_Bidi_Class=righttoleft}', ""); +Expect(1, 1424, '\p{Is_Bidi_Class= _right_TOLeft}', ""); +Expect(0, 1424, '\p{^Is_Bidi_Class= _right_TOLeft}', ""); +Expect(0, 1424, '\P{Is_Bidi_Class= _right_TOLeft}', ""); +Expect(1, 1424, '\P{^Is_Bidi_Class= _right_TOLeft}', ""); +Expect(0, 1423, '\p{Is_Bidi_Class= _right_TOLeft}', ""); +Expect(1, 1423, '\p{^Is_Bidi_Class= _right_TOLeft}', ""); +Expect(1, 1423, '\P{Is_Bidi_Class= _right_TOLeft}', ""); +Expect(0, 1423, '\P{^Is_Bidi_Class= _right_TOLeft}', ""); +Error('\p{Is_Bc=-:=R}'); +Error('\P{Is_Bc=-:=R}'); +Expect(1, 1424, '\p{Is_Bc=r}', ""); +Expect(0, 1424, '\p{^Is_Bc=r}', ""); +Expect(0, 1424, '\P{Is_Bc=r}', ""); +Expect(1, 1424, '\P{^Is_Bc=r}', ""); +Expect(0, 1423, '\p{Is_Bc=r}', ""); +Expect(1, 1423, '\p{^Is_Bc=r}', ""); +Expect(1, 1423, '\P{Is_Bc=r}', ""); +Expect(0, 1423, '\P{^Is_Bc=r}', ""); +Expect(1, 1424, '\p{Is_Bc=_R}', ""); +Expect(0, 1424, '\p{^Is_Bc=_R}', ""); +Expect(0, 1424, '\P{Is_Bc=_R}', ""); +Expect(1, 1424, '\P{^Is_Bc=_R}', ""); +Expect(0, 1423, '\p{Is_Bc=_R}', ""); +Expect(1, 1423, '\p{^Is_Bc=_R}', ""); +Expect(1, 1423, '\P{Is_Bc=_R}', ""); +Expect(0, 1423, '\P{^Is_Bc=_R}', ""); +Error('\p{Radical=_Yes:=}'); +Error('\P{Radical=_Yes:=}'); +Expect(1, 11929, '\p{Radical=yes}', ""); +Expect(0, 11929, '\p{^Radical=yes}', ""); +Expect(0, 11929, '\P{Radical=yes}', ""); +Expect(1, 11929, '\P{^Radical=yes}', ""); +Expect(0, 11903, '\p{Radical=yes}', ""); +Expect(1, 11903, '\p{^Radical=yes}', ""); +Expect(1, 11903, '\P{Radical=yes}', ""); +Expect(0, 11903, '\P{^Radical=yes}', ""); +Expect(1, 11929, '\p{Radical= YES}', ""); +Expect(0, 11929, '\p{^Radical= YES}', ""); +Expect(0, 11929, '\P{Radical= YES}', ""); +Expect(1, 11929, '\P{^Radical= YES}', ""); +Expect(0, 11903, '\p{Radical= YES}', ""); +Expect(1, 11903, '\p{^Radical= YES}', ""); +Expect(1, 11903, '\P{Radical= YES}', ""); +Expect(0, 11903, '\P{^Radical= YES}', ""); +Error('\p{Is_Radical=- Y/a/}'); +Error('\P{Is_Radical=- Y/a/}'); +Expect(1, 11929, '\p{Is_Radical=y}', ""); +Expect(0, 11929, '\p{^Is_Radical=y}', ""); +Expect(0, 11929, '\P{Is_Radical=y}', ""); +Expect(1, 11929, '\P{^Is_Radical=y}', ""); +Expect(0, 11903, '\p{Is_Radical=y}', ""); +Expect(1, 11903, '\p{^Is_Radical=y}', ""); +Expect(1, 11903, '\P{Is_Radical=y}', ""); +Expect(0, 11903, '\P{^Is_Radical=y}', ""); +Expect(1, 11929, '\p{Is_Radical= -Y}', ""); +Expect(0, 11929, '\p{^Is_Radical= -Y}', ""); +Expect(0, 11929, '\P{Is_Radical= -Y}', ""); +Expect(1, 11929, '\P{^Is_Radical= -Y}', ""); +Expect(0, 11903, '\p{Is_Radical= -Y}', ""); +Expect(1, 11903, '\p{^Is_Radical= -Y}', ""); +Expect(1, 11903, '\P{Is_Radical= -Y}', ""); +Expect(0, 11903, '\P{^Is_Radical= -Y}', ""); +Error('\p{Radical=-/a/T}'); +Error('\P{Radical=-/a/T}'); +Expect(1, 11929, '\p{Radical=t}', ""); +Expect(0, 11929, '\p{^Radical=t}', ""); +Expect(0, 11929, '\P{Radical=t}', ""); +Expect(1, 11929, '\P{^Radical=t}', ""); +Expect(0, 11903, '\p{Radical=t}', ""); +Expect(1, 11903, '\p{^Radical=t}', ""); +Expect(1, 11903, '\P{Radical=t}', ""); +Expect(0, 11903, '\P{^Radical=t}', ""); +Expect(1, 11929, '\p{Radical=- t}', ""); +Expect(0, 11929, '\p{^Radical=- t}', ""); +Expect(0, 11929, '\P{Radical=- t}', ""); +Expect(1, 11929, '\P{^Radical=- t}', ""); +Expect(0, 11903, '\p{Radical=- t}', ""); +Expect(1, 11903, '\p{^Radical=- t}', ""); +Expect(1, 11903, '\P{Radical=- t}', ""); +Expect(0, 11903, '\P{^Radical=- t}', ""); +Error('\p{Is_Radical=:=True}'); +Error('\P{Is_Radical=:=True}'); +Expect(1, 11929, '\p{Is_Radical=true}', ""); +Expect(0, 11929, '\p{^Is_Radical=true}', ""); +Expect(0, 11929, '\P{Is_Radical=true}', ""); +Expect(1, 11929, '\P{^Is_Radical=true}', ""); +Expect(0, 11903, '\p{Is_Radical=true}', ""); +Expect(1, 11903, '\p{^Is_Radical=true}', ""); +Expect(1, 11903, '\P{Is_Radical=true}', ""); +Expect(0, 11903, '\P{^Is_Radical=true}', ""); +Expect(1, 11929, '\p{Is_Radical=_ true}', ""); +Expect(0, 11929, '\p{^Is_Radical=_ true}', ""); +Expect(0, 11929, '\P{Is_Radical=_ true}', ""); +Expect(1, 11929, '\P{^Is_Radical=_ true}', ""); +Expect(0, 11903, '\p{Is_Radical=_ true}', ""); +Expect(1, 11903, '\p{^Is_Radical=_ true}', ""); +Expect(1, 11903, '\P{Is_Radical=_ true}', ""); +Expect(0, 11903, '\P{^Is_Radical=_ true}', ""); +Error('\p{Radical: /a/no}'); +Error('\P{Radical: /a/no}'); +Expect(1, 11903, '\p{Radical=no}', ""); +Expect(0, 11903, '\p{^Radical=no}', ""); +Expect(0, 11903, '\P{Radical=no}', ""); +Expect(1, 11903, '\P{^Radical=no}', ""); +Expect(0, 11929, '\p{Radical=no}', ""); +Expect(1, 11929, '\p{^Radical=no}', ""); +Expect(1, 11929, '\P{Radical=no}', ""); +Expect(0, 11929, '\P{^Radical=no}', ""); +Expect(1, 11903, '\p{Radical= _NO}', ""); +Expect(0, 11903, '\p{^Radical= _NO}', ""); +Expect(0, 11903, '\P{Radical= _NO}', ""); +Expect(1, 11903, '\P{^Radical= _NO}', ""); +Expect(0, 11929, '\p{Radical= _NO}', ""); +Expect(1, 11929, '\p{^Radical= _NO}', ""); +Expect(1, 11929, '\P{Radical= _NO}', ""); +Expect(0, 11929, '\P{^Radical= _NO}', ""); +Error('\p{Is_Radical=:=_N}'); +Error('\P{Is_Radical=:=_N}'); +Expect(1, 11903, '\p{Is_Radical=n}', ""); +Expect(0, 11903, '\p{^Is_Radical=n}', ""); +Expect(0, 11903, '\P{Is_Radical=n}', ""); +Expect(1, 11903, '\P{^Is_Radical=n}', ""); +Expect(0, 11929, '\p{Is_Radical=n}', ""); +Expect(1, 11929, '\p{^Is_Radical=n}', ""); +Expect(1, 11929, '\P{Is_Radical=n}', ""); +Expect(0, 11929, '\P{^Is_Radical=n}', ""); +Expect(1, 11903, '\p{Is_Radical=- N}', ""); +Expect(0, 11903, '\p{^Is_Radical=- N}', ""); +Expect(0, 11903, '\P{Is_Radical=- N}', ""); +Expect(1, 11903, '\P{^Is_Radical=- N}', ""); +Expect(0, 11929, '\p{Is_Radical=- N}', ""); +Expect(1, 11929, '\p{^Is_Radical=- N}', ""); +Expect(1, 11929, '\P{Is_Radical=- N}', ""); +Expect(0, 11929, '\P{^Is_Radical=- N}', ""); +Error('\p{Radical=_-F/a/}'); +Error('\P{Radical=_-F/a/}'); +Expect(1, 11903, '\p{Radical=f}', ""); +Expect(0, 11903, '\p{^Radical=f}', ""); +Expect(0, 11903, '\P{Radical=f}', ""); +Expect(1, 11903, '\P{^Radical=f}', ""); +Expect(0, 11929, '\p{Radical=f}', ""); +Expect(1, 11929, '\p{^Radical=f}', ""); +Expect(1, 11929, '\P{Radical=f}', ""); +Expect(0, 11929, '\P{^Radical=f}', ""); +Expect(1, 11903, '\p{Radical=_f}', ""); +Expect(0, 11903, '\p{^Radical=_f}', ""); +Expect(0, 11903, '\P{Radical=_f}', ""); +Expect(1, 11903, '\P{^Radical=_f}', ""); +Expect(0, 11929, '\p{Radical=_f}', ""); +Expect(1, 11929, '\p{^Radical=_f}', ""); +Expect(1, 11929, '\P{Radical=_f}', ""); +Expect(0, 11929, '\P{^Radical=_f}', ""); +Error('\p{Is_Radical= /a/False}'); +Error('\P{Is_Radical= /a/False}'); +Expect(1, 11903, '\p{Is_Radical: false}', ""); +Expect(0, 11903, '\p{^Is_Radical: false}', ""); +Expect(0, 11903, '\P{Is_Radical: false}', ""); +Expect(1, 11903, '\P{^Is_Radical: false}', ""); +Expect(0, 11929, '\p{Is_Radical: false}', ""); +Expect(1, 11929, '\p{^Is_Radical: false}', ""); +Expect(1, 11929, '\P{Is_Radical: false}', ""); +Expect(0, 11929, '\P{^Is_Radical: false}', ""); +Expect(1, 11903, '\p{Is_Radical=False}', ""); +Expect(0, 11903, '\p{^Is_Radical=False}', ""); +Expect(0, 11903, '\P{Is_Radical=False}', ""); +Expect(1, 11903, '\P{^Is_Radical=False}', ""); +Expect(0, 11929, '\p{Is_Radical=False}', ""); +Expect(1, 11929, '\p{^Is_Radical=False}', ""); +Expect(1, 11929, '\P{Is_Radical=False}', ""); +Expect(0, 11929, '\P{^Is_Radical=False}', ""); +Error('\p{Quotation_Mark=/a/ YES}'); +Error('\P{Quotation_Mark=/a/ YES}'); +Expect(1, 34, '\p{Quotation_Mark: yes}', ""); +Expect(0, 34, '\p{^Quotation_Mark: yes}', ""); +Expect(0, 34, '\P{Quotation_Mark: yes}', ""); +Expect(1, 34, '\P{^Quotation_Mark: yes}', ""); +Expect(0, 33, '\p{Quotation_Mark: yes}', ""); +Expect(1, 33, '\p{^Quotation_Mark: yes}', ""); +Expect(1, 33, '\P{Quotation_Mark: yes}', ""); +Expect(0, 33, '\P{^Quotation_Mark: yes}', ""); +Expect(1, 34, '\p{Quotation_Mark= _yes}', ""); +Expect(0, 34, '\p{^Quotation_Mark= _yes}', ""); +Expect(0, 34, '\P{Quotation_Mark= _yes}', ""); +Expect(1, 34, '\P{^Quotation_Mark= _yes}', ""); +Expect(0, 33, '\p{Quotation_Mark= _yes}', ""); +Expect(1, 33, '\p{^Quotation_Mark= _yes}', ""); +Expect(1, 33, '\P{Quotation_Mark= _yes}', ""); +Expect(0, 33, '\P{^Quotation_Mark= _yes}', ""); +Error('\p{QMark=-Y:=}'); +Error('\P{QMark=-Y:=}'); +Expect(1, 34, '\p{QMark=y}', ""); +Expect(0, 34, '\p{^QMark=y}', ""); +Expect(0, 34, '\P{QMark=y}', ""); +Expect(1, 34, '\P{^QMark=y}', ""); +Expect(0, 33, '\p{QMark=y}', ""); +Expect(1, 33, '\p{^QMark=y}', ""); +Expect(1, 33, '\P{QMark=y}', ""); +Expect(0, 33, '\P{^QMark=y}', ""); +Expect(1, 34, '\p{QMark= _Y}', ""); +Expect(0, 34, '\p{^QMark= _Y}', ""); +Expect(0, 34, '\P{QMark= _Y}', ""); +Expect(1, 34, '\P{^QMark= _Y}', ""); +Expect(0, 33, '\p{QMark= _Y}', ""); +Expect(1, 33, '\p{^QMark= _Y}', ""); +Expect(1, 33, '\P{QMark= _Y}', ""); +Expect(0, 33, '\P{^QMark= _Y}', ""); +Error('\p{Is_Quotation_Mark= -T:=}'); +Error('\P{Is_Quotation_Mark= -T:=}'); +Expect(1, 34, '\p{Is_Quotation_Mark=t}', ""); +Expect(0, 34, '\p{^Is_Quotation_Mark=t}', ""); +Expect(0, 34, '\P{Is_Quotation_Mark=t}', ""); +Expect(1, 34, '\P{^Is_Quotation_Mark=t}', ""); +Expect(0, 33, '\p{Is_Quotation_Mark=t}', ""); +Expect(1, 33, '\p{^Is_Quotation_Mark=t}', ""); +Expect(1, 33, '\P{Is_Quotation_Mark=t}', ""); +Expect(0, 33, '\P{^Is_Quotation_Mark=t}', ""); +Expect(1, 34, '\p{Is_Quotation_Mark=T}', ""); +Expect(0, 34, '\p{^Is_Quotation_Mark=T}', ""); +Expect(0, 34, '\P{Is_Quotation_Mark=T}', ""); +Expect(1, 34, '\P{^Is_Quotation_Mark=T}', ""); +Expect(0, 33, '\p{Is_Quotation_Mark=T}', ""); +Expect(1, 33, '\p{^Is_Quotation_Mark=T}', ""); +Expect(1, 33, '\P{Is_Quotation_Mark=T}', ""); +Expect(0, 33, '\P{^Is_Quotation_Mark=T}', ""); +Error('\p{Is_QMark=-True:=}'); +Error('\P{Is_QMark=-True:=}'); +Expect(1, 34, '\p{Is_QMark=true}', ""); +Expect(0, 34, '\p{^Is_QMark=true}', ""); +Expect(0, 34, '\P{Is_QMark=true}', ""); +Expect(1, 34, '\P{^Is_QMark=true}', ""); +Expect(0, 33, '\p{Is_QMark=true}', ""); +Expect(1, 33, '\p{^Is_QMark=true}', ""); +Expect(1, 33, '\P{Is_QMark=true}', ""); +Expect(0, 33, '\P{^Is_QMark=true}', ""); +Expect(1, 34, '\p{Is_QMark=_ True}', ""); +Expect(0, 34, '\p{^Is_QMark=_ True}', ""); +Expect(0, 34, '\P{Is_QMark=_ True}', ""); +Expect(1, 34, '\P{^Is_QMark=_ True}', ""); +Expect(0, 33, '\p{Is_QMark=_ True}', ""); +Expect(1, 33, '\p{^Is_QMark=_ True}', ""); +Expect(1, 33, '\P{Is_QMark=_ True}', ""); +Expect(0, 33, '\P{^Is_QMark=_ True}', ""); +Error('\p{Quotation_Mark= No:=}'); +Error('\P{Quotation_Mark= No:=}'); +Expect(1, 33, '\p{Quotation_Mark:no}', ""); +Expect(0, 33, '\p{^Quotation_Mark:no}', ""); +Expect(0, 33, '\P{Quotation_Mark:no}', ""); +Expect(1, 33, '\P{^Quotation_Mark:no}', ""); +Expect(0, 34, '\p{Quotation_Mark:no}', ""); +Expect(1, 34, '\p{^Quotation_Mark:no}', ""); +Expect(1, 34, '\P{Quotation_Mark:no}', ""); +Expect(0, 34, '\P{^Quotation_Mark:no}', ""); +Expect(1, 33, '\p{Quotation_Mark: _-no}', ""); +Expect(0, 33, '\p{^Quotation_Mark: _-no}', ""); +Expect(0, 33, '\P{Quotation_Mark: _-no}', ""); +Expect(1, 33, '\P{^Quotation_Mark: _-no}', ""); +Expect(0, 34, '\p{Quotation_Mark: _-no}', ""); +Expect(1, 34, '\p{^Quotation_Mark: _-no}', ""); +Expect(1, 34, '\P{Quotation_Mark: _-no}', ""); +Expect(0, 34, '\P{^Quotation_Mark: _-no}', ""); +Error('\p{QMark=- N/a/}'); +Error('\P{QMark=- N/a/}'); +Expect(1, 33, '\p{QMark=n}', ""); +Expect(0, 33, '\p{^QMark=n}', ""); +Expect(0, 33, '\P{QMark=n}', ""); +Expect(1, 33, '\P{^QMark=n}', ""); +Expect(0, 34, '\p{QMark=n}', ""); +Expect(1, 34, '\p{^QMark=n}', ""); +Expect(1, 34, '\P{QMark=n}', ""); +Expect(0, 34, '\P{^QMark=n}', ""); +Expect(1, 33, '\p{QMark= N}', ""); +Expect(0, 33, '\p{^QMark= N}', ""); +Expect(0, 33, '\P{QMark= N}', ""); +Expect(1, 33, '\P{^QMark= N}', ""); +Expect(0, 34, '\p{QMark= N}', ""); +Expect(1, 34, '\p{^QMark= N}', ""); +Expect(1, 34, '\P{QMark= N}', ""); +Expect(0, 34, '\P{^QMark= N}', ""); +Error('\p{Is_Quotation_Mark=_F:=}'); +Error('\P{Is_Quotation_Mark=_F:=}'); +Expect(1, 33, '\p{Is_Quotation_Mark=f}', ""); +Expect(0, 33, '\p{^Is_Quotation_Mark=f}', ""); +Expect(0, 33, '\P{Is_Quotation_Mark=f}', ""); +Expect(1, 33, '\P{^Is_Quotation_Mark=f}', ""); +Expect(0, 34, '\p{Is_Quotation_Mark=f}', ""); +Expect(1, 34, '\p{^Is_Quotation_Mark=f}', ""); +Expect(1, 34, '\P{Is_Quotation_Mark=f}', ""); +Expect(0, 34, '\P{^Is_Quotation_Mark=f}', ""); +Expect(1, 33, '\p{Is_Quotation_Mark=_F}', ""); +Expect(0, 33, '\p{^Is_Quotation_Mark=_F}', ""); +Expect(0, 33, '\P{Is_Quotation_Mark=_F}', ""); +Expect(1, 33, '\P{^Is_Quotation_Mark=_F}', ""); +Expect(0, 34, '\p{Is_Quotation_Mark=_F}', ""); +Expect(1, 34, '\p{^Is_Quotation_Mark=_F}', ""); +Expect(1, 34, '\P{Is_Quotation_Mark=_F}', ""); +Expect(0, 34, '\P{^Is_Quotation_Mark=_F}', ""); +Error('\p{Is_QMark: false:=}'); +Error('\P{Is_QMark: false:=}'); +Expect(1, 33, '\p{Is_QMark=false}', ""); +Expect(0, 33, '\p{^Is_QMark=false}', ""); +Expect(0, 33, '\P{Is_QMark=false}', ""); +Expect(1, 33, '\P{^Is_QMark=false}', ""); +Expect(0, 34, '\p{Is_QMark=false}', ""); +Expect(1, 34, '\p{^Is_QMark=false}', ""); +Expect(1, 34, '\P{Is_QMark=false}', ""); +Expect(0, 34, '\P{^Is_QMark=false}', ""); +Expect(1, 33, '\p{Is_QMark: _ False}', ""); +Expect(0, 33, '\p{^Is_QMark: _ False}', ""); +Expect(0, 33, '\P{Is_QMark: _ False}', ""); +Expect(1, 33, '\P{^Is_QMark: _ False}', ""); +Expect(0, 34, '\p{Is_QMark: _ False}', ""); +Expect(1, 34, '\p{^Is_QMark: _ False}', ""); +Expect(1, 34, '\P{Is_QMark: _ False}', ""); +Expect(0, 34, '\P{^Is_QMark: _ False}', ""); +Error('\p{Expands_On_NFD=Yes}'); +Error('\P{Expands_On_NFD=Yes}'); +Error('\p{XO_NFD:Y}'); +Error('\P{XO_NFD:Y}'); +Error('\p{Is_Expands_On_NFD=T}'); +Error('\P{Is_Expands_On_NFD=T}'); +Error('\p{Is_XO_NFD=True}'); +Error('\P{Is_XO_NFD=True}'); +Error('\p{Expands_On_NFD=No}'); +Error('\P{Expands_On_NFD=No}'); +Error('\p{XO_NFD=N}'); +Error('\P{XO_NFD=N}'); +Error('\p{Is_Expands_On_NFD: F}'); +Error('\P{Is_Expands_On_NFD: F}'); +Error('\p{Is_XO_NFD=False}'); +Error('\P{Is_XO_NFD=False}'); +Error('\p{Soft_Dotted=-/a/yes}'); +Error('\P{Soft_Dotted=-/a/yes}'); +Expect(1, 106, '\p{Soft_Dotted=yes}', ""); +Expect(0, 106, '\p{^Soft_Dotted=yes}', ""); +Expect(0, 106, '\P{Soft_Dotted=yes}', ""); +Expect(1, 106, '\P{^Soft_Dotted=yes}', ""); +Expect(0, 104, '\p{Soft_Dotted=yes}', ""); +Expect(1, 104, '\p{^Soft_Dotted=yes}', ""); +Expect(1, 104, '\P{Soft_Dotted=yes}', ""); +Expect(0, 104, '\P{^Soft_Dotted=yes}', ""); +Expect(1, 106, '\p{Soft_Dotted: _Yes}', ""); +Expect(0, 106, '\p{^Soft_Dotted: _Yes}', ""); +Expect(0, 106, '\P{Soft_Dotted: _Yes}', ""); +Expect(1, 106, '\P{^Soft_Dotted: _Yes}', ""); +Expect(0, 104, '\p{Soft_Dotted: _Yes}', ""); +Expect(1, 104, '\p{^Soft_Dotted: _Yes}', ""); +Expect(1, 104, '\P{Soft_Dotted: _Yes}', ""); +Expect(0, 104, '\P{^Soft_Dotted: _Yes}', ""); +Error('\p{SD=/a/_-Y}'); +Error('\P{SD=/a/_-Y}'); +Expect(1, 106, '\p{SD=y}', ""); +Expect(0, 106, '\p{^SD=y}', ""); +Expect(0, 106, '\P{SD=y}', ""); +Expect(1, 106, '\P{^SD=y}', ""); +Expect(0, 104, '\p{SD=y}', ""); +Expect(1, 104, '\p{^SD=y}', ""); +Expect(1, 104, '\P{SD=y}', ""); +Expect(0, 104, '\P{^SD=y}', ""); +Expect(1, 106, '\p{SD= _y}', ""); +Expect(0, 106, '\p{^SD= _y}', ""); +Expect(0, 106, '\P{SD= _y}', ""); +Expect(1, 106, '\P{^SD= _y}', ""); +Expect(0, 104, '\p{SD= _y}', ""); +Expect(1, 104, '\p{^SD= _y}', ""); +Expect(1, 104, '\P{SD= _y}', ""); +Expect(0, 104, '\P{^SD= _y}', ""); +Error('\p{Is_Soft_Dotted=:=-T}'); +Error('\P{Is_Soft_Dotted=:=-T}'); +Expect(1, 106, '\p{Is_Soft_Dotted=t}', ""); +Expect(0, 106, '\p{^Is_Soft_Dotted=t}', ""); +Expect(0, 106, '\P{Is_Soft_Dotted=t}', ""); +Expect(1, 106, '\P{^Is_Soft_Dotted=t}', ""); +Expect(0, 104, '\p{Is_Soft_Dotted=t}', ""); +Expect(1, 104, '\p{^Is_Soft_Dotted=t}', ""); +Expect(1, 104, '\P{Is_Soft_Dotted=t}', ""); +Expect(0, 104, '\P{^Is_Soft_Dotted=t}', ""); +Expect(1, 106, '\p{Is_Soft_Dotted: _ t}', ""); +Expect(0, 106, '\p{^Is_Soft_Dotted: _ t}', ""); +Expect(0, 106, '\P{Is_Soft_Dotted: _ t}', ""); +Expect(1, 106, '\P{^Is_Soft_Dotted: _ t}', ""); +Expect(0, 104, '\p{Is_Soft_Dotted: _ t}', ""); +Expect(1, 104, '\p{^Is_Soft_Dotted: _ t}', ""); +Expect(1, 104, '\P{Is_Soft_Dotted: _ t}', ""); +Expect(0, 104, '\P{^Is_Soft_Dotted: _ t}', ""); +Error('\p{Is_SD:/a/ TRUE}'); +Error('\P{Is_SD:/a/ TRUE}'); +Expect(1, 106, '\p{Is_SD=true}', ""); +Expect(0, 106, '\p{^Is_SD=true}', ""); +Expect(0, 106, '\P{Is_SD=true}', ""); +Expect(1, 106, '\P{^Is_SD=true}', ""); +Expect(0, 104, '\p{Is_SD=true}', ""); +Expect(1, 104, '\p{^Is_SD=true}', ""); +Expect(1, 104, '\P{Is_SD=true}', ""); +Expect(0, 104, '\P{^Is_SD=true}', ""); +Expect(1, 106, '\p{Is_SD=-_true}', ""); +Expect(0, 106, '\p{^Is_SD=-_true}', ""); +Expect(0, 106, '\P{Is_SD=-_true}', ""); +Expect(1, 106, '\P{^Is_SD=-_true}', ""); +Expect(0, 104, '\p{Is_SD=-_true}', ""); +Expect(1, 104, '\p{^Is_SD=-_true}', ""); +Expect(1, 104, '\P{Is_SD=-_true}', ""); +Expect(0, 104, '\P{^Is_SD=-_true}', ""); +Error('\p{Soft_Dotted= no/a/}'); +Error('\P{Soft_Dotted= no/a/}'); +Expect(1, 104, '\p{Soft_Dotted=no}', ""); +Expect(0, 104, '\p{^Soft_Dotted=no}', ""); +Expect(0, 104, '\P{Soft_Dotted=no}', ""); +Expect(1, 104, '\P{^Soft_Dotted=no}', ""); +Expect(0, 106, '\p{Soft_Dotted=no}', ""); +Expect(1, 106, '\p{^Soft_Dotted=no}', ""); +Expect(1, 106, '\P{Soft_Dotted=no}', ""); +Expect(0, 106, '\P{^Soft_Dotted=no}', ""); +Expect(1, 104, '\p{Soft_Dotted= NO}', ""); +Expect(0, 104, '\p{^Soft_Dotted= NO}', ""); +Expect(0, 104, '\P{Soft_Dotted= NO}', ""); +Expect(1, 104, '\P{^Soft_Dotted= NO}', ""); +Expect(0, 106, '\p{Soft_Dotted= NO}', ""); +Expect(1, 106, '\p{^Soft_Dotted= NO}', ""); +Expect(1, 106, '\P{Soft_Dotted= NO}', ""); +Expect(0, 106, '\P{^Soft_Dotted= NO}', ""); +Error('\p{SD= N/a/}'); +Error('\P{SD= N/a/}'); +Expect(1, 104, '\p{SD=n}', ""); +Expect(0, 104, '\p{^SD=n}', ""); +Expect(0, 104, '\P{SD=n}', ""); +Expect(1, 104, '\P{^SD=n}', ""); +Expect(0, 106, '\p{SD=n}', ""); +Expect(1, 106, '\p{^SD=n}', ""); +Expect(1, 106, '\P{SD=n}', ""); +Expect(0, 106, '\P{^SD=n}', ""); +Expect(1, 104, '\p{SD=__N}', ""); +Expect(0, 104, '\p{^SD=__N}', ""); +Expect(0, 104, '\P{SD=__N}', ""); +Expect(1, 104, '\P{^SD=__N}', ""); +Expect(0, 106, '\p{SD=__N}', ""); +Expect(1, 106, '\p{^SD=__N}', ""); +Expect(1, 106, '\P{SD=__N}', ""); +Expect(0, 106, '\P{^SD=__N}', ""); +Error('\p{Is_Soft_Dotted=_ F/a/}'); +Error('\P{Is_Soft_Dotted=_ F/a/}'); +Expect(1, 104, '\p{Is_Soft_Dotted=f}', ""); +Expect(0, 104, '\p{^Is_Soft_Dotted=f}', ""); +Expect(0, 104, '\P{Is_Soft_Dotted=f}', ""); +Expect(1, 104, '\P{^Is_Soft_Dotted=f}', ""); +Expect(0, 106, '\p{Is_Soft_Dotted=f}', ""); +Expect(1, 106, '\p{^Is_Soft_Dotted=f}', ""); +Expect(1, 106, '\P{Is_Soft_Dotted=f}', ""); +Expect(0, 106, '\P{^Is_Soft_Dotted=f}', ""); +Expect(1, 104, '\p{Is_Soft_Dotted=F}', ""); +Expect(0, 104, '\p{^Is_Soft_Dotted=F}', ""); +Expect(0, 104, '\P{Is_Soft_Dotted=F}', ""); +Expect(1, 104, '\P{^Is_Soft_Dotted=F}', ""); +Expect(0, 106, '\p{Is_Soft_Dotted=F}', ""); +Expect(1, 106, '\p{^Is_Soft_Dotted=F}', ""); +Expect(1, 106, '\P{Is_Soft_Dotted=F}', ""); +Expect(0, 106, '\P{^Is_Soft_Dotted=F}', ""); +Error('\p{Is_SD=:=_false}'); +Error('\P{Is_SD=:=_false}'); +Expect(1, 104, '\p{Is_SD: false}', ""); +Expect(0, 104, '\p{^Is_SD: false}', ""); +Expect(0, 104, '\P{Is_SD: false}', ""); +Expect(1, 104, '\P{^Is_SD: false}', ""); +Expect(0, 106, '\p{Is_SD: false}', ""); +Expect(1, 106, '\p{^Is_SD: false}', ""); +Expect(1, 106, '\P{Is_SD: false}', ""); +Expect(0, 106, '\P{^Is_SD: false}', ""); +Expect(1, 104, '\p{Is_SD=__false}', ""); +Expect(0, 104, '\p{^Is_SD=__false}', ""); +Expect(0, 104, '\P{Is_SD=__false}', ""); +Expect(1, 104, '\P{^Is_SD=__false}', ""); +Expect(0, 106, '\p{Is_SD=__false}', ""); +Expect(1, 106, '\p{^Is_SD=__false}', ""); +Expect(1, 106, '\P{Is_SD=__false}', ""); +Expect(0, 106, '\P{^Is_SD=__false}', ""); +Error('\p{Other_ID_Start=-_Yes/a/}'); +Error('\P{Other_ID_Start=-_Yes/a/}'); +Expect(1, 8472, '\p{Other_ID_Start=yes}', 'deprecated'); +Expect(0, 8472, '\p{^Other_ID_Start=yes}', 'deprecated'); +Expect(0, 8472, '\P{Other_ID_Start=yes}', 'deprecated'); +Expect(1, 8472, '\P{^Other_ID_Start=yes}', 'deprecated'); +Expect(0, 8471, '\p{Other_ID_Start=yes}', 'deprecated'); +Expect(1, 8471, '\p{^Other_ID_Start=yes}', 'deprecated'); +Expect(1, 8471, '\P{Other_ID_Start=yes}', 'deprecated'); +Expect(0, 8471, '\P{^Other_ID_Start=yes}', 'deprecated'); +Expect(1, 8472, '\p{Other_ID_Start: _YES}', 'deprecated'); +Expect(0, 8472, '\p{^Other_ID_Start: _YES}', 'deprecated'); +Expect(0, 8472, '\P{Other_ID_Start: _YES}', 'deprecated'); +Expect(1, 8472, '\P{^Other_ID_Start: _YES}', 'deprecated'); +Expect(0, 8471, '\p{Other_ID_Start: _YES}', 'deprecated'); +Expect(1, 8471, '\p{^Other_ID_Start: _YES}', 'deprecated'); +Expect(1, 8471, '\P{Other_ID_Start: _YES}', 'deprecated'); +Expect(0, 8471, '\P{^Other_ID_Start: _YES}', 'deprecated'); +Error('\p{OIDS=/a/_ Y}'); +Error('\P{OIDS=/a/_ Y}'); +Expect(1, 8472, '\p{OIDS=y}', 'deprecated'); +Expect(0, 8472, '\p{^OIDS=y}', 'deprecated'); +Expect(0, 8472, '\P{OIDS=y}', 'deprecated'); +Expect(1, 8472, '\P{^OIDS=y}', 'deprecated'); +Expect(0, 8471, '\p{OIDS=y}', 'deprecated'); +Expect(1, 8471, '\p{^OIDS=y}', 'deprecated'); +Expect(1, 8471, '\P{OIDS=y}', 'deprecated'); +Expect(0, 8471, '\P{^OIDS=y}', 'deprecated'); +Expect(1, 8472, '\p{OIDS: Y}', 'deprecated'); +Expect(0, 8472, '\p{^OIDS: Y}', 'deprecated'); +Expect(0, 8472, '\P{OIDS: Y}', 'deprecated'); +Expect(1, 8472, '\P{^OIDS: Y}', 'deprecated'); +Expect(0, 8471, '\p{OIDS: Y}', 'deprecated'); +Expect(1, 8471, '\p{^OIDS: Y}', 'deprecated'); +Expect(1, 8471, '\P{OIDS: Y}', 'deprecated'); +Expect(0, 8471, '\P{^OIDS: Y}', 'deprecated'); +Error('\p{Is_Other_ID_Start: :=-T}'); +Error('\P{Is_Other_ID_Start: :=-T}'); +Expect(1, 8472, '\p{Is_Other_ID_Start=t}', 'deprecated'); +Expect(0, 8472, '\p{^Is_Other_ID_Start=t}', 'deprecated'); +Expect(0, 8472, '\P{Is_Other_ID_Start=t}', 'deprecated'); +Expect(1, 8472, '\P{^Is_Other_ID_Start=t}', 'deprecated'); +Expect(0, 8471, '\p{Is_Other_ID_Start=t}', 'deprecated'); +Expect(1, 8471, '\p{^Is_Other_ID_Start=t}', 'deprecated'); +Expect(1, 8471, '\P{Is_Other_ID_Start=t}', 'deprecated'); +Expect(0, 8471, '\P{^Is_Other_ID_Start=t}', 'deprecated'); +Expect(1, 8472, '\p{Is_Other_ID_Start=-_T}', 'deprecated'); +Expect(0, 8472, '\p{^Is_Other_ID_Start=-_T}', 'deprecated'); +Expect(0, 8472, '\P{Is_Other_ID_Start=-_T}', 'deprecated'); +Expect(1, 8472, '\P{^Is_Other_ID_Start=-_T}', 'deprecated'); +Expect(0, 8471, '\p{Is_Other_ID_Start=-_T}', 'deprecated'); +Expect(1, 8471, '\p{^Is_Other_ID_Start=-_T}', 'deprecated'); +Expect(1, 8471, '\P{Is_Other_ID_Start=-_T}', 'deprecated'); +Expect(0, 8471, '\P{^Is_Other_ID_Start=-_T}', 'deprecated'); +Error('\p{Is_OIDS=:=True}'); +Error('\P{Is_OIDS=:=True}'); +Expect(1, 8472, '\p{Is_OIDS=true}', 'deprecated'); +Expect(0, 8472, '\p{^Is_OIDS=true}', 'deprecated'); +Expect(0, 8472, '\P{Is_OIDS=true}', 'deprecated'); +Expect(1, 8472, '\P{^Is_OIDS=true}', 'deprecated'); +Expect(0, 8471, '\p{Is_OIDS=true}', 'deprecated'); +Expect(1, 8471, '\p{^Is_OIDS=true}', 'deprecated'); +Expect(1, 8471, '\P{Is_OIDS=true}', 'deprecated'); +Expect(0, 8471, '\P{^Is_OIDS=true}', 'deprecated'); +Expect(1, 8472, '\p{Is_OIDS= True}', 'deprecated'); +Expect(0, 8472, '\p{^Is_OIDS= True}', 'deprecated'); +Expect(0, 8472, '\P{Is_OIDS= True}', 'deprecated'); +Expect(1, 8472, '\P{^Is_OIDS= True}', 'deprecated'); +Expect(0, 8471, '\p{Is_OIDS= True}', 'deprecated'); +Expect(1, 8471, '\p{^Is_OIDS= True}', 'deprecated'); +Expect(1, 8471, '\P{Is_OIDS= True}', 'deprecated'); +Expect(0, 8471, '\P{^Is_OIDS= True}', 'deprecated'); +Error('\p{Other_ID_Start=:=_ No}'); +Error('\P{Other_ID_Start=:=_ No}'); +Expect(1, 8471, '\p{Other_ID_Start=no}', 'deprecated'); +Expect(0, 8471, '\p{^Other_ID_Start=no}', 'deprecated'); +Expect(0, 8471, '\P{Other_ID_Start=no}', 'deprecated'); +Expect(1, 8471, '\P{^Other_ID_Start=no}', 'deprecated'); +Expect(0, 8472, '\p{Other_ID_Start=no}', 'deprecated'); +Expect(1, 8472, '\p{^Other_ID_Start=no}', 'deprecated'); +Expect(1, 8472, '\P{Other_ID_Start=no}', 'deprecated'); +Expect(0, 8472, '\P{^Other_ID_Start=no}', 'deprecated'); +Expect(1, 8471, '\p{Other_ID_Start= No}', 'deprecated'); +Expect(0, 8471, '\p{^Other_ID_Start= No}', 'deprecated'); +Expect(0, 8471, '\P{Other_ID_Start= No}', 'deprecated'); +Expect(1, 8471, '\P{^Other_ID_Start= No}', 'deprecated'); +Expect(0, 8472, '\p{Other_ID_Start= No}', 'deprecated'); +Expect(1, 8472, '\p{^Other_ID_Start= No}', 'deprecated'); +Expect(1, 8472, '\P{Other_ID_Start= No}', 'deprecated'); +Expect(0, 8472, '\P{^Other_ID_Start= No}', 'deprecated'); +Error('\p{OIDS=:= -N}'); +Error('\P{OIDS=:= -N}'); +Expect(1, 8471, '\p{OIDS=n}', 'deprecated'); +Expect(0, 8471, '\p{^OIDS=n}', 'deprecated'); +Expect(0, 8471, '\P{OIDS=n}', 'deprecated'); +Expect(1, 8471, '\P{^OIDS=n}', 'deprecated'); +Expect(0, 8472, '\p{OIDS=n}', 'deprecated'); +Expect(1, 8472, '\p{^OIDS=n}', 'deprecated'); +Expect(1, 8472, '\P{OIDS=n}', 'deprecated'); +Expect(0, 8472, '\P{^OIDS=n}', 'deprecated'); +Expect(1, 8471, '\p{OIDS= N}', 'deprecated'); +Expect(0, 8471, '\p{^OIDS= N}', 'deprecated'); +Expect(0, 8471, '\P{OIDS= N}', 'deprecated'); +Expect(1, 8471, '\P{^OIDS= N}', 'deprecated'); +Expect(0, 8472, '\p{OIDS= N}', 'deprecated'); +Expect(1, 8472, '\p{^OIDS= N}', 'deprecated'); +Expect(1, 8472, '\P{OIDS= N}', 'deprecated'); +Expect(0, 8472, '\P{^OIDS= N}', 'deprecated'); +Error('\p{Is_Other_ID_Start=-_F/a/}'); +Error('\P{Is_Other_ID_Start=-_F/a/}'); +Expect(1, 8471, '\p{Is_Other_ID_Start=f}', 'deprecated'); +Expect(0, 8471, '\p{^Is_Other_ID_Start=f}', 'deprecated'); +Expect(0, 8471, '\P{Is_Other_ID_Start=f}', 'deprecated'); +Expect(1, 8471, '\P{^Is_Other_ID_Start=f}', 'deprecated'); +Expect(0, 8472, '\p{Is_Other_ID_Start=f}', 'deprecated'); +Expect(1, 8472, '\p{^Is_Other_ID_Start=f}', 'deprecated'); +Expect(1, 8472, '\P{Is_Other_ID_Start=f}', 'deprecated'); +Expect(0, 8472, '\P{^Is_Other_ID_Start=f}', 'deprecated'); +Expect(1, 8471, '\p{Is_Other_ID_Start= _F}', 'deprecated'); +Expect(0, 8471, '\p{^Is_Other_ID_Start= _F}', 'deprecated'); +Expect(0, 8471, '\P{Is_Other_ID_Start= _F}', 'deprecated'); +Expect(1, 8471, '\P{^Is_Other_ID_Start= _F}', 'deprecated'); +Expect(0, 8472, '\p{Is_Other_ID_Start= _F}', 'deprecated'); +Expect(1, 8472, '\p{^Is_Other_ID_Start= _F}', 'deprecated'); +Expect(1, 8472, '\P{Is_Other_ID_Start= _F}', 'deprecated'); +Expect(0, 8472, '\P{^Is_Other_ID_Start= _F}', 'deprecated'); +Error('\p{Is_OIDS= :=False}'); +Error('\P{Is_OIDS= :=False}'); +Expect(1, 8471, '\p{Is_OIDS=false}', 'deprecated'); +Expect(0, 8471, '\p{^Is_OIDS=false}', 'deprecated'); +Expect(0, 8471, '\P{Is_OIDS=false}', 'deprecated'); +Expect(1, 8471, '\P{^Is_OIDS=false}', 'deprecated'); +Expect(0, 8472, '\p{Is_OIDS=false}', 'deprecated'); +Expect(1, 8472, '\p{^Is_OIDS=false}', 'deprecated'); +Expect(1, 8472, '\P{Is_OIDS=false}', 'deprecated'); +Expect(0, 8472, '\P{^Is_OIDS=false}', 'deprecated'); +Expect(1, 8471, '\p{Is_OIDS= FALSE}', 'deprecated'); +Expect(0, 8471, '\p{^Is_OIDS= FALSE}', 'deprecated'); +Expect(0, 8471, '\P{Is_OIDS= FALSE}', 'deprecated'); +Expect(1, 8471, '\P{^Is_OIDS= FALSE}', 'deprecated'); +Expect(0, 8472, '\p{Is_OIDS= FALSE}', 'deprecated'); +Expect(1, 8472, '\p{^Is_OIDS= FALSE}', 'deprecated'); +Expect(1, 8472, '\P{Is_OIDS= FALSE}', 'deprecated'); +Expect(0, 8472, '\P{^Is_OIDS= FALSE}', 'deprecated'); +Error('\p{Grapheme_Base= Yes/a/}'); +Error('\P{Grapheme_Base= Yes/a/}'); +Expect(1, 126, '\p{Grapheme_Base=yes}', ""); +Expect(0, 126, '\p{^Grapheme_Base=yes}', ""); +Expect(0, 126, '\P{Grapheme_Base=yes}', ""); +Expect(1, 126, '\P{^Grapheme_Base=yes}', ""); +Expect(0, 7, '\p{Grapheme_Base=yes}', ""); +Expect(1, 7, '\p{^Grapheme_Base=yes}', ""); +Expect(1, 7, '\P{Grapheme_Base=yes}', ""); +Expect(0, 7, '\P{^Grapheme_Base=yes}', ""); +Expect(1, 126, '\p{Grapheme_Base=_-YES}', ""); +Expect(0, 126, '\p{^Grapheme_Base=_-YES}', ""); +Expect(0, 126, '\P{Grapheme_Base=_-YES}', ""); +Expect(1, 126, '\P{^Grapheme_Base=_-YES}', ""); +Expect(0, 7, '\p{Grapheme_Base=_-YES}', ""); +Expect(1, 7, '\p{^Grapheme_Base=_-YES}', ""); +Expect(1, 7, '\P{Grapheme_Base=_-YES}', ""); +Expect(0, 7, '\P{^Grapheme_Base=_-YES}', ""); +Error('\p{Gr_Base=--y:=}'); +Error('\P{Gr_Base=--y:=}'); +Expect(1, 126, '\p{Gr_Base=y}', ""); +Expect(0, 126, '\p{^Gr_Base=y}', ""); +Expect(0, 126, '\P{Gr_Base=y}', ""); +Expect(1, 126, '\P{^Gr_Base=y}', ""); +Expect(0, 7, '\p{Gr_Base=y}', ""); +Expect(1, 7, '\p{^Gr_Base=y}', ""); +Expect(1, 7, '\P{Gr_Base=y}', ""); +Expect(0, 7, '\P{^Gr_Base=y}', ""); +Expect(1, 126, '\p{Gr_Base: -Y}', ""); +Expect(0, 126, '\p{^Gr_Base: -Y}', ""); +Expect(0, 126, '\P{Gr_Base: -Y}', ""); +Expect(1, 126, '\P{^Gr_Base: -Y}', ""); +Expect(0, 7, '\p{Gr_Base: -Y}', ""); +Expect(1, 7, '\p{^Gr_Base: -Y}', ""); +Expect(1, 7, '\P{Gr_Base: -Y}', ""); +Expect(0, 7, '\P{^Gr_Base: -Y}', ""); +Error('\p{Is_Grapheme_Base=_:=T}'); +Error('\P{Is_Grapheme_Base=_:=T}'); +Expect(1, 126, '\p{Is_Grapheme_Base=t}', ""); +Expect(0, 126, '\p{^Is_Grapheme_Base=t}', ""); +Expect(0, 126, '\P{Is_Grapheme_Base=t}', ""); +Expect(1, 126, '\P{^Is_Grapheme_Base=t}', ""); +Expect(0, 7, '\p{Is_Grapheme_Base=t}', ""); +Expect(1, 7, '\p{^Is_Grapheme_Base=t}', ""); +Expect(1, 7, '\P{Is_Grapheme_Base=t}', ""); +Expect(0, 7, '\P{^Is_Grapheme_Base=t}', ""); +Expect(1, 126, '\p{Is_Grapheme_Base=-_T}', ""); +Expect(0, 126, '\p{^Is_Grapheme_Base=-_T}', ""); +Expect(0, 126, '\P{Is_Grapheme_Base=-_T}', ""); +Expect(1, 126, '\P{^Is_Grapheme_Base=-_T}', ""); +Expect(0, 7, '\p{Is_Grapheme_Base=-_T}', ""); +Expect(1, 7, '\p{^Is_Grapheme_Base=-_T}', ""); +Expect(1, 7, '\P{Is_Grapheme_Base=-_T}', ""); +Expect(0, 7, '\P{^Is_Grapheme_Base=-_T}', ""); +Error('\p{Is_Gr_Base:_True/a/}'); +Error('\P{Is_Gr_Base:_True/a/}'); +Expect(1, 126, '\p{Is_Gr_Base=true}', ""); +Expect(0, 126, '\p{^Is_Gr_Base=true}', ""); +Expect(0, 126, '\P{Is_Gr_Base=true}', ""); +Expect(1, 126, '\P{^Is_Gr_Base=true}', ""); +Expect(0, 7, '\p{Is_Gr_Base=true}', ""); +Expect(1, 7, '\p{^Is_Gr_Base=true}', ""); +Expect(1, 7, '\P{Is_Gr_Base=true}', ""); +Expect(0, 7, '\P{^Is_Gr_Base=true}', ""); +Expect(1, 126, '\p{Is_Gr_Base=--TRUE}', ""); +Expect(0, 126, '\p{^Is_Gr_Base=--TRUE}', ""); +Expect(0, 126, '\P{Is_Gr_Base=--TRUE}', ""); +Expect(1, 126, '\P{^Is_Gr_Base=--TRUE}', ""); +Expect(0, 7, '\p{Is_Gr_Base=--TRUE}', ""); +Expect(1, 7, '\p{^Is_Gr_Base=--TRUE}', ""); +Expect(1, 7, '\P{Is_Gr_Base=--TRUE}', ""); +Expect(0, 7, '\P{^Is_Gr_Base=--TRUE}', ""); +Error('\p{Grapheme_Base= -No:=}'); +Error('\P{Grapheme_Base= -No:=}'); +Expect(1, 7, '\p{Grapheme_Base=no}', ""); +Expect(0, 7, '\p{^Grapheme_Base=no}', ""); +Expect(0, 7, '\P{Grapheme_Base=no}', ""); +Expect(1, 7, '\P{^Grapheme_Base=no}', ""); +Expect(0, 126, '\p{Grapheme_Base=no}', ""); +Expect(1, 126, '\p{^Grapheme_Base=no}', ""); +Expect(1, 126, '\P{Grapheme_Base=no}', ""); +Expect(0, 126, '\P{^Grapheme_Base=no}', ""); +Expect(1, 7, '\p{Grapheme_Base: No}', ""); +Expect(0, 7, '\p{^Grapheme_Base: No}', ""); +Expect(0, 7, '\P{Grapheme_Base: No}', ""); +Expect(1, 7, '\P{^Grapheme_Base: No}', ""); +Expect(0, 126, '\p{Grapheme_Base: No}', ""); +Expect(1, 126, '\p{^Grapheme_Base: No}', ""); +Expect(1, 126, '\P{Grapheme_Base: No}', ""); +Expect(0, 126, '\P{^Grapheme_Base: No}', ""); +Error('\p{Gr_Base=/a/ -N}'); +Error('\P{Gr_Base=/a/ -N}'); +Expect(1, 7, '\p{Gr_Base=n}', ""); +Expect(0, 7, '\p{^Gr_Base=n}', ""); +Expect(0, 7, '\P{Gr_Base=n}', ""); +Expect(1, 7, '\P{^Gr_Base=n}', ""); +Expect(0, 126, '\p{Gr_Base=n}', ""); +Expect(1, 126, '\p{^Gr_Base=n}', ""); +Expect(1, 126, '\P{Gr_Base=n}', ""); +Expect(0, 126, '\P{^Gr_Base=n}', ""); +Expect(1, 7, '\p{Gr_Base=-n}', ""); +Expect(0, 7, '\p{^Gr_Base=-n}', ""); +Expect(0, 7, '\P{Gr_Base=-n}', ""); +Expect(1, 7, '\P{^Gr_Base=-n}', ""); +Expect(0, 126, '\p{Gr_Base=-n}', ""); +Expect(1, 126, '\p{^Gr_Base=-n}', ""); +Expect(1, 126, '\P{Gr_Base=-n}', ""); +Expect(0, 126, '\P{^Gr_Base=-n}', ""); +Error('\p{Is_Grapheme_Base: /a/_-F}'); +Error('\P{Is_Grapheme_Base: /a/_-F}'); +Expect(1, 7, '\p{Is_Grapheme_Base: f}', ""); +Expect(0, 7, '\p{^Is_Grapheme_Base: f}', ""); +Expect(0, 7, '\P{Is_Grapheme_Base: f}', ""); +Expect(1, 7, '\P{^Is_Grapheme_Base: f}', ""); +Expect(0, 126, '\p{Is_Grapheme_Base: f}', ""); +Expect(1, 126, '\p{^Is_Grapheme_Base: f}', ""); +Expect(1, 126, '\P{Is_Grapheme_Base: f}', ""); +Expect(0, 126, '\P{^Is_Grapheme_Base: f}', ""); +Expect(1, 7, '\p{Is_Grapheme_Base=- F}', ""); +Expect(0, 7, '\p{^Is_Grapheme_Base=- F}', ""); +Expect(0, 7, '\P{Is_Grapheme_Base=- F}', ""); +Expect(1, 7, '\P{^Is_Grapheme_Base=- F}', ""); +Expect(0, 126, '\p{Is_Grapheme_Base=- F}', ""); +Expect(1, 126, '\p{^Is_Grapheme_Base=- F}', ""); +Expect(1, 126, '\P{Is_Grapheme_Base=- F}', ""); +Expect(0, 126, '\P{^Is_Grapheme_Base=- F}', ""); +Error('\p{Is_Gr_Base=:=-FALSE}'); +Error('\P{Is_Gr_Base=:=-FALSE}'); +Expect(1, 7, '\p{Is_Gr_Base=false}', ""); +Expect(0, 7, '\p{^Is_Gr_Base=false}', ""); +Expect(0, 7, '\P{Is_Gr_Base=false}', ""); +Expect(1, 7, '\P{^Is_Gr_Base=false}', ""); +Expect(0, 126, '\p{Is_Gr_Base=false}', ""); +Expect(1, 126, '\p{^Is_Gr_Base=false}', ""); +Expect(1, 126, '\P{Is_Gr_Base=false}', ""); +Expect(0, 126, '\P{^Is_Gr_Base=false}', ""); +Expect(1, 7, '\p{Is_Gr_Base=-_False}', ""); +Expect(0, 7, '\p{^Is_Gr_Base=-_False}', ""); +Expect(0, 7, '\P{Is_Gr_Base=-_False}', ""); +Expect(1, 7, '\P{^Is_Gr_Base=-_False}', ""); +Expect(0, 126, '\p{Is_Gr_Base=-_False}', ""); +Expect(1, 126, '\p{^Is_Gr_Base=-_False}', ""); +Expect(1, 126, '\P{Is_Gr_Base=-_False}', ""); +Expect(0, 126, '\P{^Is_Gr_Base=-_False}', ""); +Error('\p{Numeric_Value= 0000000033/a/}'); +Error('\P{Numeric_Value= 0000000033/a/}'); +Expect(1, 12893, '\p{Numeric_Value=+00033}', ""); +Expect(0, 12893, '\p{^Numeric_Value=+00033}', ""); +Expect(0, 12893, '\P{Numeric_Value=+00033}', ""); +Expect(1, 12893, '\P{^Numeric_Value=+00033}', ""); +Expect(0, 12892, '\p{Numeric_Value=+00033}', ""); +Expect(1, 12892, '\p{^Numeric_Value=+00033}', ""); +Expect(1, 12892, '\P{Numeric_Value=+00033}', ""); +Expect(0, 12892, '\P{^Numeric_Value=+00033}', ""); +Error('\p{Nv=-00033:=}'); +Error('\P{Nv=-00033:=}'); +Expect(1, 12893, '\p{Nv=0_0_0_033}', ""); +Expect(0, 12893, '\p{^Nv=0_0_0_033}', ""); +Expect(0, 12893, '\P{Nv=0_0_0_033}', ""); +Expect(1, 12893, '\P{^Nv=0_0_0_033}', ""); +Expect(0, 12892, '\p{Nv=0_0_0_033}', ""); +Expect(1, 12892, '\p{^Nv=0_0_0_033}', ""); +Expect(1, 12892, '\P{Nv=0_0_0_033}', ""); +Expect(0, 12892, '\P{^Nv=0_0_0_033}', ""); +Error('\p{Is_Numeric_Value: :=+33}'); +Error('\P{Is_Numeric_Value: :=+33}'); +Expect(1, 12893, '\p{Is_Numeric_Value=0000_0000_33}', ""); +Expect(0, 12893, '\p{^Is_Numeric_Value=0000_0000_33}', ""); +Expect(0, 12893, '\P{Is_Numeric_Value=0000_0000_33}', ""); +Expect(1, 12893, '\P{^Is_Numeric_Value=0000_0000_33}', ""); +Expect(0, 12892, '\p{Is_Numeric_Value=0000_0000_33}', ""); +Expect(1, 12892, '\p{^Is_Numeric_Value=0000_0000_33}', ""); +Expect(1, 12892, '\P{Is_Numeric_Value=0000_0000_33}', ""); +Expect(0, 12892, '\P{^Is_Numeric_Value=0000_0000_33}', ""); +Error('\p{Is_Nv= :=+0 0 00 0 033}'); +Error('\P{Is_Nv= :=+0 0 00 0 033}'); +Expect(1, 12893, '\p{Is_Nv: 0_0_0_33}', ""); +Expect(0, 12893, '\p{^Is_Nv: 0_0_0_33}', ""); +Expect(0, 12893, '\P{Is_Nv: 0_0_0_33}', ""); +Expect(1, 12893, '\P{^Is_Nv: 0_0_0_33}', ""); +Expect(0, 12892, '\p{Is_Nv: 0_0_0_33}', ""); +Expect(1, 12892, '\p{^Is_Nv: 0_0_0_33}', ""); +Expect(1, 12892, '\P{Is_Nv: 0_0_0_33}', ""); +Expect(0, 12892, '\P{^Is_Nv: 0_0_0_33}', ""); +Error('\p{Numeric_Value=- 0032:=}'); +Error('\P{Numeric_Value=- 0032:=}'); +Expect(1, 12892, '\p{Numeric_Value=0_0_32}', ""); +Expect(0, 12892, '\p{^Numeric_Value=0_0_32}', ""); +Expect(0, 12892, '\P{Numeric_Value=0_0_32}', ""); +Expect(1, 12892, '\P{^Numeric_Value=0_0_32}', ""); +Expect(0, 12891, '\p{Numeric_Value=0_0_32}', ""); +Expect(1, 12891, '\p{^Numeric_Value=0_0_32}', ""); +Expect(1, 12891, '\P{Numeric_Value=0_0_32}', ""); +Expect(0, 12891, '\P{^Numeric_Value=0_0_32}', ""); +Error('\p{Nv= 000000032/a/}'); +Error('\P{Nv= 000000032/a/}'); +Expect(1, 12892, '\p{Nv=3_2}', ""); +Expect(0, 12892, '\p{^Nv=3_2}', ""); +Expect(0, 12892, '\P{Nv=3_2}', ""); +Expect(1, 12892, '\P{^Nv=3_2}', ""); +Expect(0, 12891, '\p{Nv=3_2}', ""); +Expect(1, 12891, '\p{^Nv=3_2}', ""); +Expect(1, 12891, '\P{Nv=3_2}', ""); +Expect(0, 12891, '\P{^Nv=3_2}', ""); +Error('\p{Is_Numeric_Value: -_+00032/a/}'); +Error('\P{Is_Numeric_Value: -_+00032/a/}'); +Expect(1, 12892, '\p{Is_Numeric_Value=0_0_32}', ""); +Expect(0, 12892, '\p{^Is_Numeric_Value=0_0_32}', ""); +Expect(0, 12892, '\P{Is_Numeric_Value=0_0_32}', ""); +Expect(1, 12892, '\P{^Is_Numeric_Value=0_0_32}', ""); +Expect(0, 12891, '\p{Is_Numeric_Value=0_0_32}', ""); +Expect(1, 12891, '\p{^Is_Numeric_Value=0_0_32}', ""); +Expect(1, 12891, '\P{Is_Numeric_Value=0_0_32}', ""); +Expect(0, 12891, '\P{^Is_Numeric_Value=0_0_32}', ""); +Error('\p{Is_Nv=_:=32}'); +Error('\P{Is_Nv=_:=32}'); +Expect(1, 12892, '\p{Is_Nv=0000032}', ""); +Expect(0, 12892, '\p{^Is_Nv=0000032}', ""); +Expect(0, 12892, '\P{Is_Nv=0000032}', ""); +Expect(1, 12892, '\P{^Is_Nv=0000032}', ""); +Expect(0, 12891, '\p{Is_Nv=0000032}', ""); +Expect(1, 12891, '\p{^Is_Nv=0000032}', ""); +Expect(1, 12891, '\P{Is_Nv=0000032}', ""); +Expect(0, 12891, '\P{^Is_Nv=0000032}', ""); +Error('\p{Numeric_Value=/a/_ +000021}'); +Error('\P{Numeric_Value=/a/_ +000021}'); +Expect(1, 12881, '\p{Numeric_Value=+000000021}', ""); +Expect(0, 12881, '\p{^Numeric_Value=+000000021}', ""); +Expect(0, 12881, '\P{Numeric_Value=+000000021}', ""); +Expect(1, 12881, '\P{^Numeric_Value=+000000021}', ""); +Expect(0, 12880, '\p{Numeric_Value=+000000021}', ""); +Expect(1, 12880, '\p{^Numeric_Value=+000000021}', ""); +Expect(1, 12880, '\P{Numeric_Value=+000000021}', ""); +Expect(0, 12880, '\P{^Numeric_Value=+000000021}', ""); +Error('\p{Nv=:=21}'); +Error('\P{Nv=:=21}'); +Expect(1, 12881, '\p{Nv=0000_0002_1}', ""); +Expect(0, 12881, '\p{^Nv=0000_0002_1}', ""); +Expect(0, 12881, '\P{Nv=0000_0002_1}', ""); +Expect(1, 12881, '\P{^Nv=0000_0002_1}', ""); +Expect(0, 12880, '\p{Nv=0000_0002_1}', ""); +Expect(1, 12880, '\p{^Nv=0000_0002_1}', ""); +Expect(1, 12880, '\P{Nv=0000_0002_1}', ""); +Expect(0, 12880, '\P{^Nv=0000_0002_1}', ""); +Error('\p{Is_Numeric_Value=_:=+002 1}'); +Error('\P{Is_Numeric_Value=_:=+002 1}'); +Expect(1, 12881, '\p{Is_Numeric_Value=0000000021}', ""); +Expect(0, 12881, '\p{^Is_Numeric_Value=0000000021}', ""); +Expect(0, 12881, '\P{Is_Numeric_Value=0000000021}', ""); +Expect(1, 12881, '\P{^Is_Numeric_Value=0000000021}', ""); +Expect(0, 12880, '\p{Is_Numeric_Value=0000000021}', ""); +Expect(1, 12880, '\p{^Is_Numeric_Value=0000000021}', ""); +Expect(1, 12880, '\P{Is_Numeric_Value=0000000021}', ""); +Expect(0, 12880, '\P{^Is_Numeric_Value=0000000021}', ""); +Error('\p{Is_Nv: /a/_ 021}'); +Error('\P{Is_Nv: /a/_ 021}'); +Expect(1, 12881, '\p{Is_Nv=02_1}', ""); +Expect(0, 12881, '\p{^Is_Nv=02_1}', ""); +Expect(0, 12881, '\P{Is_Nv=02_1}', ""); +Expect(1, 12881, '\P{^Is_Nv=02_1}', ""); +Expect(0, 12880, '\p{Is_Nv=02_1}', ""); +Expect(1, 12880, '\p{^Is_Nv=02_1}', ""); +Expect(1, 12880, '\P{Is_Nv=02_1}', ""); +Expect(0, 12880, '\P{^Is_Nv=02_1}', ""); +Error('\p{Numeric_Value=- +00090/a/}'); +Error('\P{Numeric_Value=- +00090/a/}'); +Expect(1, 4986, '\p{Numeric_Value=0000000009_0}', ""); +Expect(0, 4986, '\p{^Numeric_Value=0000000009_0}', ""); +Expect(0, 4986, '\P{Numeric_Value=0000000009_0}', ""); +Expect(1, 4986, '\P{^Numeric_Value=0000000009_0}', ""); +Expect(0, 4985, '\p{Numeric_Value=0000000009_0}', ""); +Expect(1, 4985, '\p{^Numeric_Value=0000000009_0}', ""); +Expect(1, 4985, '\P{Numeric_Value=0000000009_0}', ""); +Expect(0, 4985, '\P{^Numeric_Value=0000000009_0}', ""); +Error('\p{Nv= 00000000090/a/}'); +Error('\P{Nv= 00000000090/a/}'); +Expect(1, 4986, '\p{Nv: 09_0}', ""); +Expect(0, 4986, '\p{^Nv: 09_0}', ""); +Expect(0, 4986, '\P{Nv: 09_0}', ""); +Expect(1, 4986, '\P{^Nv: 09_0}', ""); +Expect(0, 4985, '\p{Nv: 09_0}', ""); +Expect(1, 4985, '\p{^Nv: 09_0}', ""); +Expect(1, 4985, '\P{Nv: 09_0}', ""); +Expect(0, 4985, '\P{^Nv: 09_0}', ""); +Error('\p{Is_Numeric_Value=_ 000000090/a/}'); +Error('\P{Is_Numeric_Value=_ 000000090/a/}'); +Expect(1, 4986, '\p{Is_Numeric_Value: 00090}', ""); +Expect(0, 4986, '\p{^Is_Numeric_Value: 00090}', ""); +Expect(0, 4986, '\P{Is_Numeric_Value: 00090}', ""); +Expect(1, 4986, '\P{^Is_Numeric_Value: 00090}', ""); +Expect(0, 4985, '\p{Is_Numeric_Value: 00090}', ""); +Expect(1, 4985, '\p{^Is_Numeric_Value: 00090}', ""); +Expect(1, 4985, '\P{Is_Numeric_Value: 00090}', ""); +Expect(0, 4985, '\P{^Is_Numeric_Value: 00090}', ""); +Error('\p{Is_Nv=:= -000000090}'); +Error('\P{Is_Nv=:= -000000090}'); +Expect(1, 4986, '\p{Is_Nv=+000_000_009_0}', ""); +Expect(0, 4986, '\p{^Is_Nv=+000_000_009_0}', ""); +Expect(0, 4986, '\P{Is_Nv=+000_000_009_0}', ""); +Expect(1, 4986, '\P{^Is_Nv=+000_000_009_0}', ""); +Expect(0, 4985, '\p{Is_Nv=+000_000_009_0}', ""); +Expect(1, 4985, '\p{^Is_Nv=+000_000_009_0}', ""); +Expect(1, 4985, '\P{Is_Nv=+000_000_009_0}', ""); +Expect(0, 4985, '\P{^Is_Nv=+000_000_009_0}', ""); +Error('\p{Numeric_Value=/a/ -000007}'); +Error('\P{Numeric_Value=/a/ -000007}'); +Expect(1, 55, '\p{Numeric_Value=00_7}', ""); +Expect(0, 55, '\p{^Numeric_Value=00_7}', ""); +Expect(0, 55, '\P{Numeric_Value=00_7}', ""); +Expect(1, 55, '\P{^Numeric_Value=00_7}', ""); +Expect(0, 54, '\p{Numeric_Value=00_7}', ""); +Expect(1, 54, '\p{^Numeric_Value=00_7}', ""); +Expect(1, 54, '\P{Numeric_Value=00_7}', ""); +Expect(0, 54, '\P{^Numeric_Value=00_7}', ""); +Error('\p{Nv= 0-0 0 0:=0-0 007}'); +Error('\P{Nv= 0-0 0 0:=0-0 007}'); +Expect(1, 55, '\p{Nv=+0_0_0_0_0_007}', ""); +Expect(0, 55, '\p{^Nv=+0_0_0_0_0_007}', ""); +Expect(0, 55, '\P{Nv=+0_0_0_0_0_007}', ""); +Expect(1, 55, '\P{^Nv=+0_0_0_0_0_007}', ""); +Expect(0, 54, '\p{Nv=+0_0_0_0_0_007}', ""); +Expect(1, 54, '\p{^Nv=+0_0_0_0_0_007}', ""); +Expect(1, 54, '\P{Nv=+0_0_0_0_0_007}', ""); +Expect(0, 54, '\P{^Nv=+0_0_0_0_0_007}', ""); +Error('\p{Is_Numeric_Value=_/a/00-007}'); +Error('\P{Is_Numeric_Value=_/a/00-007}'); +Expect(1, 55, '\p{Is_Numeric_Value=00_00_00_00_7}', ""); +Expect(0, 55, '\p{^Is_Numeric_Value=00_00_00_00_7}', ""); +Expect(0, 55, '\P{Is_Numeric_Value=00_00_00_00_7}', ""); +Expect(1, 55, '\P{^Is_Numeric_Value=00_00_00_00_7}', ""); +Expect(0, 54, '\p{Is_Numeric_Value=00_00_00_00_7}', ""); +Expect(1, 54, '\p{^Is_Numeric_Value=00_00_00_00_7}', ""); +Expect(1, 54, '\P{Is_Numeric_Value=00_00_00_00_7}', ""); +Expect(0, 54, '\P{^Is_Numeric_Value=00_00_00_00_7}', ""); +Error('\p{Is_Nv= 0_0 0:=0007}'); +Error('\P{Is_Nv= 0_0 0:=0007}'); +Expect(1, 55, '\p{Is_Nv=+0007}', ""); +Expect(0, 55, '\p{^Is_Nv=+0007}', ""); +Expect(0, 55, '\P{Is_Nv=+0007}', ""); +Expect(1, 55, '\P{^Is_Nv=+0007}', ""); +Expect(0, 54, '\p{Is_Nv=+0007}', ""); +Expect(1, 54, '\p{^Is_Nv=+0007}', ""); +Expect(1, 54, '\P{Is_Nv=+0007}', ""); +Expect(0, 54, '\P{^Is_Nv=+0007}', ""); +Error('\p{Numeric_Value= _+0:=0 0_00_00 6 00}'); +Error('\P{Numeric_Value= _+0:=0 0_00_00 6 00}'); +Expect(1, 65822, '\p{Numeric_Value=0_0_0_0_0_0_600}', ""); +Expect(0, 65822, '\p{^Numeric_Value=0_0_0_0_0_0_600}', ""); +Expect(0, 65822, '\P{Numeric_Value=0_0_0_0_0_0_600}', ""); +Expect(1, 65822, '\P{^Numeric_Value=0_0_0_0_0_0_600}', ""); +Expect(0, 65821, '\p{Numeric_Value=0_0_0_0_0_0_600}', ""); +Expect(1, 65821, '\p{^Numeric_Value=0_0_0_0_0_0_600}', ""); +Expect(1, 65821, '\P{Numeric_Value=0_0_0_0_0_0_600}', ""); +Expect(0, 65821, '\P{^Numeric_Value=0_0_0_0_0_0_600}', ""); +Error('\p{Nv=:=600}'); +Error('\P{Nv=:=600}'); +Expect(1, 65822, '\p{Nv=600}', ""); +Expect(0, 65822, '\p{^Nv=600}', ""); +Expect(0, 65822, '\P{Nv=600}', ""); +Expect(1, 65822, '\P{^Nv=600}', ""); +Expect(0, 65821, '\p{Nv=600}', ""); +Expect(1, 65821, '\p{^Nv=600}', ""); +Expect(1, 65821, '\P{Nv=600}', ""); +Expect(0, 65821, '\P{^Nv=600}', ""); +Error('\p{Is_Numeric_Value= :=000000600}'); +Error('\P{Is_Numeric_Value= :=000000600}'); +Expect(1, 65822, '\p{Is_Numeric_Value:+000600}', ""); +Expect(0, 65822, '\p{^Is_Numeric_Value:+000600}', ""); +Expect(0, 65822, '\P{Is_Numeric_Value:+000600}', ""); +Expect(1, 65822, '\P{^Is_Numeric_Value:+000600}', ""); +Expect(0, 65821, '\p{Is_Numeric_Value:+000600}', ""); +Expect(1, 65821, '\p{^Is_Numeric_Value:+000600}', ""); +Expect(1, 65821, '\P{Is_Numeric_Value:+000600}', ""); +Expect(0, 65821, '\P{^Is_Numeric_Value:+000600}', ""); +Error('\p{Is_Nv=__0600:=}'); +Error('\P{Is_Nv=__0600:=}'); +Expect(1, 65822, '\p{Is_Nv=+000000600}', ""); +Expect(0, 65822, '\p{^Is_Nv=+000000600}', ""); +Expect(0, 65822, '\P{Is_Nv=+000000600}', ""); +Expect(1, 65822, '\P{^Is_Nv=+000000600}', ""); +Expect(0, 65821, '\p{Is_Nv=+000000600}', ""); +Expect(1, 65821, '\p{^Is_Nv=+000000600}', ""); +Expect(1, 65821, '\P{Is_Nv=+000000600}', ""); +Expect(0, 65821, '\P{^Is_Nv=+000000600}', ""); +Error('\p{Numeric_Value=:=+0026}'); +Error('\P{Numeric_Value=:=+0026}'); +Expect(1, 12886, '\p{Numeric_Value: 00_00_26}', ""); +Expect(0, 12886, '\p{^Numeric_Value: 00_00_26}', ""); +Expect(0, 12886, '\P{Numeric_Value: 00_00_26}', ""); +Expect(1, 12886, '\P{^Numeric_Value: 00_00_26}', ""); +Expect(0, 12885, '\p{Numeric_Value: 00_00_26}', ""); +Expect(1, 12885, '\p{^Numeric_Value: 00_00_26}', ""); +Expect(1, 12885, '\P{Numeric_Value: 00_00_26}', ""); +Expect(0, 12885, '\P{^Numeric_Value: 00_00_26}', ""); +Error('\p{Nv=_ +0000026:=}'); +Error('\P{Nv=_ +0000026:=}'); +Expect(1, 12886, '\p{Nv=0026}', ""); +Expect(0, 12886, '\p{^Nv=0026}', ""); +Expect(0, 12886, '\P{Nv=0026}', ""); +Expect(1, 12886, '\P{^Nv=0026}', ""); +Expect(0, 12885, '\p{Nv=0026}', ""); +Expect(1, 12885, '\p{^Nv=0026}', ""); +Expect(1, 12885, '\P{Nv=0026}', ""); +Expect(0, 12885, '\P{^Nv=0026}', ""); +Error('\p{Is_Numeric_Value=/a/- +00000002_6}'); +Error('\P{Is_Numeric_Value=/a/- +00000002_6}'); +Expect(1, 12886, '\p{Is_Numeric_Value=026}', ""); +Expect(0, 12886, '\p{^Is_Numeric_Value=026}', ""); +Expect(0, 12886, '\P{Is_Numeric_Value=026}', ""); +Expect(1, 12886, '\P{^Is_Numeric_Value=026}', ""); +Expect(0, 12885, '\p{Is_Numeric_Value=026}', ""); +Expect(1, 12885, '\p{^Is_Numeric_Value=026}', ""); +Expect(1, 12885, '\P{Is_Numeric_Value=026}', ""); +Expect(0, 12885, '\P{^Is_Numeric_Value=026}', ""); +Error('\p{Is_Nv= /a/0_0 0-00026}'); +Error('\P{Is_Nv= /a/0_0 0-00026}'); +Expect(1, 12886, '\p{Is_Nv=000000026}', ""); +Expect(0, 12886, '\p{^Is_Nv=000000026}', ""); +Expect(0, 12886, '\P{Is_Nv=000000026}', ""); +Expect(1, 12886, '\P{^Is_Nv=000000026}', ""); +Expect(0, 12885, '\p{Is_Nv=000000026}', ""); +Expect(1, 12885, '\p{^Is_Nv=000000026}', ""); +Expect(1, 12885, '\P{Is_Nv=000000026}', ""); +Expect(0, 12885, '\P{^Is_Nv=000000026}', ""); +Error('\p{Numeric_Value: __0000000080/a/}'); +Error('\P{Numeric_Value: __0000000080/a/}'); +Expect(1, 4985, '\p{Numeric_Value=00000000080}', ""); +Expect(0, 4985, '\p{^Numeric_Value=00000000080}', ""); +Expect(0, 4985, '\P{Numeric_Value=00000000080}', ""); +Expect(1, 4985, '\P{^Numeric_Value=00000000080}', ""); +Expect(0, 4984, '\p{Numeric_Value=00000000080}', ""); +Expect(1, 4984, '\p{^Numeric_Value=00000000080}', ""); +Expect(1, 4984, '\P{Numeric_Value=00000000080}', ""); +Expect(0, 4984, '\P{^Numeric_Value=00000000080}', ""); +Error('\p{Nv=-_000000080/a/}'); +Error('\P{Nv=-_000000080/a/}'); +Expect(1, 4985, '\p{Nv=0000000080}', ""); +Expect(0, 4985, '\p{^Nv=0000000080}', ""); +Expect(0, 4985, '\P{Nv=0000000080}', ""); +Expect(1, 4985, '\P{^Nv=0000000080}', ""); +Expect(0, 4984, '\p{Nv=0000000080}', ""); +Expect(1, 4984, '\p{^Nv=0000000080}', ""); +Expect(1, 4984, '\P{Nv=0000000080}', ""); +Expect(0, 4984, '\P{^Nv=0000000080}', ""); +Error('\p{Is_Numeric_Value=_/a/000080}'); +Error('\P{Is_Numeric_Value=_/a/000080}'); +Expect(1, 4985, '\p{Is_Numeric_Value=+0000080}', ""); +Expect(0, 4985, '\p{^Is_Numeric_Value=+0000080}', ""); +Expect(0, 4985, '\P{Is_Numeric_Value=+0000080}', ""); +Expect(1, 4985, '\P{^Is_Numeric_Value=+0000080}', ""); +Expect(0, 4984, '\p{Is_Numeric_Value=+0000080}', ""); +Expect(1, 4984, '\p{^Is_Numeric_Value=+0000080}', ""); +Expect(1, 4984, '\P{Is_Numeric_Value=+0000080}', ""); +Expect(0, 4984, '\P{^Is_Numeric_Value=+0000080}', ""); +Error('\p{Is_Nv=_/a/00 0000-00 080}'); +Error('\P{Is_Nv=_/a/00 0000-00 080}'); +Expect(1, 4985, '\p{Is_Nv=008_0}', ""); +Expect(0, 4985, '\p{^Is_Nv=008_0}', ""); +Expect(0, 4985, '\P{Is_Nv=008_0}', ""); +Expect(1, 4985, '\P{^Is_Nv=008_0}', ""); +Expect(0, 4984, '\p{Is_Nv=008_0}', ""); +Expect(1, 4984, '\p{^Is_Nv=008_0}', ""); +Expect(1, 4984, '\P{Is_Nv=008_0}', ""); +Expect(0, 4984, '\P{^Is_Nv=008_0}', ""); +Error('\p{Numeric_Value=-:=0000000200}'); +Error('\P{Numeric_Value=-:=0000000200}'); +Expect(1, 65818, '\p{Numeric_Value: 20_0}', ""); +Expect(0, 65818, '\p{^Numeric_Value: 20_0}', ""); +Expect(0, 65818, '\P{Numeric_Value: 20_0}', ""); +Expect(1, 65818, '\P{^Numeric_Value: 20_0}', ""); +Expect(0, 65817, '\p{Numeric_Value: 20_0}', ""); +Expect(1, 65817, '\p{^Numeric_Value: 20_0}', ""); +Expect(1, 65817, '\P{Numeric_Value: 20_0}', ""); +Expect(0, 65817, '\P{^Numeric_Value: 20_0}', ""); +Error('\p{Nv: 0000000002:=00}'); +Error('\P{Nv: 0000000002:=00}'); +Expect(1, 65818, '\p{Nv=+000000200}', ""); +Expect(0, 65818, '\p{^Nv=+000000200}', ""); +Expect(0, 65818, '\P{Nv=+000000200}', ""); +Expect(1, 65818, '\P{^Nv=+000000200}', ""); +Expect(0, 65817, '\p{Nv=+000000200}', ""); +Expect(1, 65817, '\p{^Nv=+000000200}', ""); +Expect(1, 65817, '\P{Nv=+000000200}', ""); +Expect(0, 65817, '\P{^Nv=+000000200}', ""); +Error('\p{Is_Numeric_Value=-/a/000000000200}'); +Error('\P{Is_Numeric_Value=-/a/000000000200}'); +Expect(1, 65818, '\p{Is_Numeric_Value=0_0_0_0_0_0200}', ""); +Expect(0, 65818, '\p{^Is_Numeric_Value=0_0_0_0_0_0200}', ""); +Expect(0, 65818, '\P{Is_Numeric_Value=0_0_0_0_0_0200}', ""); +Expect(1, 65818, '\P{^Is_Numeric_Value=0_0_0_0_0_0200}', ""); +Expect(0, 65817, '\p{Is_Numeric_Value=0_0_0_0_0_0200}', ""); +Expect(1, 65817, '\p{^Is_Numeric_Value=0_0_0_0_0_0200}', ""); +Expect(1, 65817, '\P{Is_Numeric_Value=0_0_0_0_0_0200}', ""); +Expect(0, 65817, '\P{^Is_Numeric_Value=0_0_0_0_0_0200}', ""); +Error('\p{Is_Nv=- +0 0 0_0/a/0 00200}'); +Error('\P{Is_Nv=- +0 0 0_0/a/0 00200}'); +Expect(1, 65818, '\p{Is_Nv=0000200}', ""); +Expect(0, 65818, '\p{^Is_Nv=0000200}', ""); +Expect(0, 65818, '\P{Is_Nv=0000200}', ""); +Expect(1, 65818, '\P{^Is_Nv=0000200}', ""); +Expect(0, 65817, '\p{Is_Nv=0000200}', ""); +Expect(1, 65817, '\p{^Is_Nv=0000200}', ""); +Expect(1, 65817, '\P{Is_Nv=0000200}', ""); +Expect(0, 65817, '\P{^Is_Nv=0000200}', ""); +Error('\p{Numeric_Value= 0-0:=00 0_0018}'); +Error('\P{Numeric_Value= 0-0:=00 0_0018}'); +Expect(1, 5871, '\p{Numeric_Value:00000018}', ""); +Expect(0, 5871, '\p{^Numeric_Value:00000018}', ""); +Expect(0, 5871, '\P{Numeric_Value:00000018}', ""); +Expect(1, 5871, '\P{^Numeric_Value:00000018}', ""); +Expect(0, 5870, '\p{Numeric_Value:00000018}', ""); +Expect(1, 5870, '\p{^Numeric_Value:00000018}', ""); +Expect(1, 5870, '\P{Numeric_Value:00000018}', ""); +Expect(0, 5870, '\P{^Numeric_Value:00000018}', ""); +Error('\p{Nv=/a/-001 8}'); +Error('\P{Nv=/a/-001 8}'); +Expect(1, 5871, '\p{Nv=0000018}', ""); +Expect(0, 5871, '\p{^Nv=0000018}', ""); +Expect(0, 5871, '\P{Nv=0000018}', ""); +Expect(1, 5871, '\P{^Nv=0000018}', ""); +Expect(0, 5870, '\p{Nv=0000018}', ""); +Expect(1, 5870, '\p{^Nv=0000018}', ""); +Expect(1, 5870, '\P{Nv=0000018}', ""); +Expect(0, 5870, '\P{^Nv=0000018}', ""); +Error('\p{Is_Numeric_Value=:=-0000018}'); +Error('\P{Is_Numeric_Value=:=-0000018}'); +Expect(1, 5871, '\p{Is_Numeric_Value=0_0_0_0_0_0_0_0_018}', ""); +Expect(0, 5871, '\p{^Is_Numeric_Value=0_0_0_0_0_0_0_0_018}', ""); +Expect(0, 5871, '\P{Is_Numeric_Value=0_0_0_0_0_0_0_0_018}', ""); +Expect(1, 5871, '\P{^Is_Numeric_Value=0_0_0_0_0_0_0_0_018}', ""); +Expect(0, 5870, '\p{Is_Numeric_Value=0_0_0_0_0_0_0_0_018}', ""); +Expect(1, 5870, '\p{^Is_Numeric_Value=0_0_0_0_0_0_0_0_018}', ""); +Expect(1, 5870, '\P{Is_Numeric_Value=0_0_0_0_0_0_0_0_018}', ""); +Expect(0, 5870, '\P{^Is_Numeric_Value=0_0_0_0_0_0_0_0_018}', ""); +Error('\p{Is_Nv=-/a/001 8}'); +Error('\P{Is_Nv=-/a/001 8}'); +Expect(1, 5871, '\p{Is_Nv=000_000_000_18}', ""); +Expect(0, 5871, '\p{^Is_Nv=000_000_000_18}', ""); +Expect(0, 5871, '\P{Is_Nv=000_000_000_18}', ""); +Expect(1, 5871, '\P{^Is_Nv=000_000_000_18}', ""); +Expect(0, 5870, '\p{Is_Nv=000_000_000_18}', ""); +Expect(1, 5870, '\p{^Is_Nv=000_000_000_18}', ""); +Expect(1, 5870, '\P{Is_Nv=000_000_000_18}', ""); +Expect(0, 5870, '\P{^Is_Nv=000_000_000_18}', ""); +Error('\p{Numeric_Value:--0003/00008:=}'); +Error('\P{Numeric_Value:--0003/00008:=}'); +Expect(1, 8540, '\p{Numeric_Value:+3/008}', ""); +Expect(0, 8540, '\p{^Numeric_Value:+3/008}', ""); +Expect(0, 8540, '\P{Numeric_Value:+3/008}', ""); +Expect(1, 8540, '\P{^Numeric_Value:+3/008}', ""); +Expect(0, 8539, '\p{Numeric_Value:+3/008}', ""); +Expect(1, 8539, '\p{^Numeric_Value:+3/008}', ""); +Expect(1, 8539, '\P{Numeric_Value:+3/008}', ""); +Expect(0, 8539, '\P{^Numeric_Value:+3/008}', ""); +Error('\p{Numeric_Value=0.38}'); +Error('\P{Numeric_Value=0.38}'); +Expect(1, 8540, '\p{Numeric_Value=0.375}', ""); +Expect(0, 8540, '\p{^Numeric_Value=0.375}', ""); +Expect(0, 8540, '\P{Numeric_Value=0.375}', ""); +Expect(1, 8540, '\P{^Numeric_Value=0.375}', ""); +Expect(0, 8539, '\p{Numeric_Value=0.375}', ""); +Expect(1, 8539, '\p{^Numeric_Value=0.375}', ""); +Expect(1, 8539, '\P{Numeric_Value=0.375}', ""); +Expect(0, 8539, '\P{^Numeric_Value=0.375}', ""); +Error('\p{Nv=/a/03/000008}'); +Error('\P{Nv=/a/03/000008}'); +Expect(1, 8540, '\p{Nv=+0000000003/00000008}', ""); +Expect(0, 8540, '\p{^Nv=+0000000003/00000008}', ""); +Expect(0, 8540, '\P{Nv=+0000000003/00000008}', ""); +Expect(1, 8540, '\P{^Nv=+0000000003/00000008}', ""); +Expect(0, 8539, '\p{Nv=+0000000003/00000008}', ""); +Expect(1, 8539, '\p{^Nv=+0000000003/00000008}', ""); +Expect(1, 8539, '\P{Nv=+0000000003/00000008}', ""); +Expect(0, 8539, '\P{^Nv=+0000000003/00000008}', ""); +Error('\p{Nv: 0.38}'); +Error('\P{Nv: 0.38}'); +Expect(1, 8540, '\p{Nv=0.375}', ""); +Expect(0, 8540, '\p{^Nv=0.375}', ""); +Expect(0, 8540, '\P{Nv=0.375}', ""); +Expect(1, 8540, '\P{^Nv=0.375}', ""); +Expect(0, 8539, '\p{Nv=0.375}', ""); +Expect(1, 8539, '\p{^Nv=0.375}', ""); +Expect(1, 8539, '\P{Nv=0.375}', ""); +Expect(0, 8539, '\P{^Nv=0.375}', ""); +Error('\p{Is_Numeric_Value=/a/ _+0000000003/008}'); +Error('\P{Is_Numeric_Value=/a/ _+0000000003/008}'); +Expect(1, 8540, '\p{Is_Numeric_Value=00003/8}', ""); +Expect(0, 8540, '\p{^Is_Numeric_Value=00003/8}', ""); +Expect(0, 8540, '\P{Is_Numeric_Value=00003/8}', ""); +Expect(1, 8540, '\P{^Is_Numeric_Value=00003/8}', ""); +Expect(0, 8539, '\p{Is_Numeric_Value=00003/8}', ""); +Expect(1, 8539, '\p{^Is_Numeric_Value=00003/8}', ""); +Expect(1, 8539, '\P{Is_Numeric_Value=00003/8}', ""); +Expect(0, 8539, '\P{^Is_Numeric_Value=00003/8}', ""); +Error('\p{Is_Numeric_Value=0.38}'); +Error('\P{Is_Numeric_Value=0.38}'); +Expect(1, 8540, '\p{Is_Numeric_Value: 0.375}', ""); +Expect(0, 8540, '\p{^Is_Numeric_Value: 0.375}', ""); +Expect(0, 8540, '\P{Is_Numeric_Value: 0.375}', ""); +Expect(1, 8540, '\P{^Is_Numeric_Value: 0.375}', ""); +Expect(0, 8539, '\p{Is_Numeric_Value: 0.375}', ""); +Expect(1, 8539, '\p{^Is_Numeric_Value: 0.375}', ""); +Expect(1, 8539, '\P{Is_Numeric_Value: 0.375}', ""); +Expect(0, 8539, '\P{^Is_Numeric_Value: 0.375}', ""); +Error('\p{Is_Nv=/a/ 000000003/000000008}'); +Error('\P{Is_Nv=/a/ 000000003/000000008}'); +Expect(1, 8540, '\p{Is_Nv=003/008}', ""); +Expect(0, 8540, '\p{^Is_Nv=003/008}', ""); +Expect(0, 8540, '\P{Is_Nv=003/008}', ""); +Expect(1, 8540, '\P{^Is_Nv=003/008}', ""); +Expect(0, 8539, '\p{Is_Nv=003/008}', ""); +Expect(1, 8539, '\p{^Is_Nv=003/008}', ""); +Expect(1, 8539, '\P{Is_Nv=003/008}', ""); +Expect(0, 8539, '\P{^Is_Nv=003/008}', ""); +Error('\p{Is_Nv=0.38}'); +Error('\P{Is_Nv=0.38}'); +Expect(1, 8540, '\p{Is_Nv=0.375}', ""); +Expect(0, 8540, '\p{^Is_Nv=0.375}', ""); +Expect(0, 8540, '\P{Is_Nv=0.375}', ""); +Expect(1, 8540, '\P{^Is_Nv=0.375}', ""); +Expect(0, 8539, '\p{Is_Nv=0.375}', ""); +Expect(1, 8539, '\p{^Is_Nv=0.375}', ""); +Expect(1, 8539, '\P{Is_Nv=0.375}', ""); +Expect(0, 8539, '\P{^Is_Nv=0.375}', ""); +Error('\p{Numeric_Value= /a/+000000500}'); +Error('\P{Numeric_Value= /a/+000000500}'); +Expect(1, 8558, '\p{Numeric_Value=+0500}', ""); +Expect(0, 8558, '\p{^Numeric_Value=+0500}', ""); +Expect(0, 8558, '\P{Numeric_Value=+0500}', ""); +Expect(1, 8558, '\P{^Numeric_Value=+0500}', ""); +Expect(0, 8557, '\p{Numeric_Value=+0500}', ""); +Expect(1, 8557, '\p{^Numeric_Value=+0500}', ""); +Expect(1, 8557, '\P{Numeric_Value=+0500}', ""); +Expect(0, 8557, '\P{^Numeric_Value=+0500}', ""); +Error('\p{Nv=_:=00000000050-0}'); +Error('\P{Nv=_:=00000000050-0}'); +Expect(1, 8558, '\p{Nv=00000500}', ""); +Expect(0, 8558, '\p{^Nv=00000500}', ""); +Expect(0, 8558, '\P{Nv=00000500}', ""); +Expect(1, 8558, '\P{^Nv=00000500}', ""); +Expect(0, 8557, '\p{Nv=00000500}', ""); +Expect(1, 8557, '\p{^Nv=00000500}', ""); +Expect(1, 8557, '\P{Nv=00000500}', ""); +Expect(0, 8557, '\P{^Nv=00000500}', ""); +Error('\p{Is_Numeric_Value= :=0000000005_00}'); +Error('\P{Is_Numeric_Value= :=0000000005_00}'); +Expect(1, 8558, '\p{Is_Numeric_Value: +0050_0}', ""); +Expect(0, 8558, '\p{^Is_Numeric_Value: +0050_0}', ""); +Expect(0, 8558, '\P{Is_Numeric_Value: +0050_0}', ""); +Expect(1, 8558, '\P{^Is_Numeric_Value: +0050_0}', ""); +Expect(0, 8557, '\p{Is_Numeric_Value: +0050_0}', ""); +Expect(1, 8557, '\p{^Is_Numeric_Value: +0050_0}', ""); +Expect(1, 8557, '\P{Is_Numeric_Value: +0050_0}', ""); +Expect(0, 8557, '\P{^Is_Numeric_Value: +0050_0}', ""); +Error('\p{Is_Nv=_-0 0 0 0/a/0 500}'); +Error('\P{Is_Nv=_-0 0 0 0/a/0 500}'); +Expect(1, 8558, '\p{Is_Nv=0_0_0_0_0_0_0_00500}', ""); +Expect(0, 8558, '\p{^Is_Nv=0_0_0_0_0_0_0_00500}', ""); +Expect(0, 8558, '\P{Is_Nv=0_0_0_0_0_0_0_00500}', ""); +Expect(1, 8558, '\P{^Is_Nv=0_0_0_0_0_0_0_00500}', ""); +Expect(0, 8557, '\p{Is_Nv=0_0_0_0_0_0_0_00500}', ""); +Expect(1, 8557, '\p{^Is_Nv=0_0_0_0_0_0_0_00500}', ""); +Expect(1, 8557, '\P{Is_Nv=0_0_0_0_0_0_0_00500}', ""); +Expect(0, 8557, '\P{^Is_Nv=0_0_0_0_0_0_0_00500}', ""); +Error('\p{Numeric_Value= _+016/a/}'); +Error('\P{Numeric_Value= _+016/a/}'); +Expect(1, 2553, '\p{Numeric_Value=+00001_6}', ""); +Expect(0, 2553, '\p{^Numeric_Value=+00001_6}', ""); +Expect(0, 2553, '\P{Numeric_Value=+00001_6}', ""); +Expect(1, 2553, '\P{^Numeric_Value=+00001_6}', ""); +Expect(0, 2552, '\p{Numeric_Value=+00001_6}', ""); +Expect(1, 2552, '\p{^Numeric_Value=+00001_6}', ""); +Expect(1, 2552, '\P{Numeric_Value=+00001_6}', ""); +Expect(0, 2552, '\P{^Numeric_Value=+00001_6}', ""); +Error('\p{Nv=-16/a/}'); +Error('\P{Nv=-16/a/}'); +Expect(1, 2553, '\p{Nv=0000016}', ""); +Expect(0, 2553, '\p{^Nv=0000016}', ""); +Expect(0, 2553, '\P{Nv=0000016}', ""); +Expect(1, 2553, '\P{^Nv=0000016}', ""); +Expect(0, 2552, '\p{Nv=0000016}', ""); +Expect(1, 2552, '\p{^Nv=0000016}', ""); +Expect(1, 2552, '\P{Nv=0000016}', ""); +Expect(0, 2552, '\P{^Nv=0000016}', ""); +Error('\p{Is_Numeric_Value=_0000000016/a/}'); +Error('\P{Is_Numeric_Value=_0000000016/a/}'); +Expect(1, 2553, '\p{Is_Numeric_Value=0_0_0_0_0_0_16}', ""); +Expect(0, 2553, '\p{^Is_Numeric_Value=0_0_0_0_0_0_16}', ""); +Expect(0, 2553, '\P{Is_Numeric_Value=0_0_0_0_0_0_16}', ""); +Expect(1, 2553, '\P{^Is_Numeric_Value=0_0_0_0_0_0_16}', ""); +Expect(0, 2552, '\p{Is_Numeric_Value=0_0_0_0_0_0_16}', ""); +Expect(1, 2552, '\p{^Is_Numeric_Value=0_0_0_0_0_0_16}', ""); +Expect(1, 2552, '\P{Is_Numeric_Value=0_0_0_0_0_0_16}', ""); +Expect(0, 2552, '\P{^Is_Numeric_Value=0_0_0_0_0_0_16}', ""); +Error('\p{Is_Nv= :=01_6}'); +Error('\P{Is_Nv= :=01_6}'); +Expect(1, 2553, '\p{Is_Nv=01_6}', ""); +Expect(0, 2553, '\p{^Is_Nv=01_6}', ""); +Expect(0, 2553, '\P{Is_Nv=01_6}', ""); +Expect(1, 2553, '\P{^Is_Nv=01_6}', ""); +Expect(0, 2552, '\p{Is_Nv=01_6}', ""); +Expect(1, 2552, '\p{^Is_Nv=01_6}', ""); +Expect(1, 2552, '\P{Is_Nv=01_6}', ""); +Expect(0, 2552, '\P{^Is_Nv=01_6}', ""); +Error('\p{Numeric_Value=-_+00 00:=44}'); +Error('\P{Numeric_Value=-_+00 00:=44}'); +Expect(1, 12985, '\p{Numeric_Value=+0_0_44}', ""); +Expect(0, 12985, '\p{^Numeric_Value=+0_0_44}', ""); +Expect(0, 12985, '\P{Numeric_Value=+0_0_44}', ""); +Expect(1, 12985, '\P{^Numeric_Value=+0_0_44}', ""); +Expect(0, 12984, '\p{Numeric_Value=+0_0_44}', ""); +Expect(1, 12984, '\p{^Numeric_Value=+0_0_44}', ""); +Expect(1, 12984, '\P{Numeric_Value=+0_0_44}', ""); +Expect(0, 12984, '\P{^Numeric_Value=+0_0_44}', ""); +Error('\p{Nv=_ 0000000044/a/}'); +Error('\P{Nv=_ 0000000044/a/}'); +Expect(1, 12985, '\p{Nv=00_00_44}', ""); +Expect(0, 12985, '\p{^Nv=00_00_44}', ""); +Expect(0, 12985, '\P{Nv=00_00_44}', ""); +Expect(1, 12985, '\P{^Nv=00_00_44}', ""); +Expect(0, 12984, '\p{Nv=00_00_44}', ""); +Expect(1, 12984, '\p{^Nv=00_00_44}', ""); +Expect(1, 12984, '\P{Nv=00_00_44}', ""); +Expect(0, 12984, '\P{^Nv=00_00_44}', ""); +Error('\p{Is_Numeric_Value= 00000044/a/}'); +Error('\P{Is_Numeric_Value= 00000044/a/}'); +Expect(1, 12985, '\p{Is_Numeric_Value=00044}', ""); +Expect(0, 12985, '\p{^Is_Numeric_Value=00044}', ""); +Expect(0, 12985, '\P{Is_Numeric_Value=00044}', ""); +Expect(1, 12985, '\P{^Is_Numeric_Value=00044}', ""); +Expect(0, 12984, '\p{Is_Numeric_Value=00044}', ""); +Expect(1, 12984, '\p{^Is_Numeric_Value=00044}', ""); +Expect(1, 12984, '\P{Is_Numeric_Value=00044}', ""); +Expect(0, 12984, '\P{^Is_Numeric_Value=00044}', ""); +Error('\p{Is_Nv= 0 0 0 044/a/}'); +Error('\P{Is_Nv= 0 0 0 044/a/}'); +Expect(1, 12985, '\p{Is_Nv=0000044}', ""); +Expect(0, 12985, '\p{^Is_Nv=0000044}', ""); +Expect(0, 12985, '\P{Is_Nv=0000044}', ""); +Expect(1, 12985, '\P{^Is_Nv=0000044}', ""); +Expect(0, 12984, '\p{Is_Nv=0000044}', ""); +Expect(1, 12984, '\p{^Is_Nv=0000044}', ""); +Expect(1, 12984, '\P{Is_Nv=0000044}', ""); +Expect(0, 12984, '\P{^Is_Nv=0000044}', ""); +Error('\p{Numeric_Value=-:=0000027}'); +Error('\P{Numeric_Value=-:=0000027}'); +Expect(1, 12887, '\p{Numeric_Value=00027}', ""); +Expect(0, 12887, '\p{^Numeric_Value=00027}', ""); +Expect(0, 12887, '\P{Numeric_Value=00027}', ""); +Expect(1, 12887, '\P{^Numeric_Value=00027}', ""); +Expect(0, 12886, '\p{Numeric_Value=00027}', ""); +Expect(1, 12886, '\p{^Numeric_Value=00027}', ""); +Expect(1, 12886, '\P{Numeric_Value=00027}', ""); +Expect(0, 12886, '\P{^Numeric_Value=00027}', ""); +Error('\p{Nv=/a/+00 02_7}'); +Error('\P{Nv=/a/+00 02_7}'); +Expect(1, 12887, '\p{Nv=0027}', ""); +Expect(0, 12887, '\p{^Nv=0027}', ""); +Expect(0, 12887, '\P{Nv=0027}', ""); +Expect(1, 12887, '\P{^Nv=0027}', ""); +Expect(0, 12886, '\p{Nv=0027}', ""); +Expect(1, 12886, '\p{^Nv=0027}', ""); +Expect(1, 12886, '\P{Nv=0027}', ""); +Expect(0, 12886, '\P{^Nv=0027}', ""); +Error('\p{Is_Numeric_Value=:= -+02_7}'); +Error('\P{Is_Numeric_Value=:= -+02_7}'); +Expect(1, 12887, '\p{Is_Numeric_Value: 027}', ""); +Expect(0, 12887, '\p{^Is_Numeric_Value: 027}', ""); +Expect(0, 12887, '\P{Is_Numeric_Value: 027}', ""); +Expect(1, 12887, '\P{^Is_Numeric_Value: 027}', ""); +Expect(0, 12886, '\p{Is_Numeric_Value: 027}', ""); +Expect(1, 12886, '\p{^Is_Numeric_Value: 027}', ""); +Expect(1, 12886, '\P{Is_Numeric_Value: 027}', ""); +Expect(0, 12886, '\P{^Is_Numeric_Value: 027}', ""); +Error('\p{Is_Nv= /a/+00000000027}'); +Error('\P{Is_Nv= /a/+00000000027}'); +Expect(1, 12887, '\p{Is_Nv=27}', ""); +Expect(0, 12887, '\p{^Is_Nv=27}', ""); +Expect(0, 12887, '\P{Is_Nv=27}', ""); +Expect(1, 12887, '\P{^Is_Nv=27}', ""); +Expect(0, 12886, '\p{Is_Nv=27}', ""); +Expect(1, 12886, '\p{^Is_Nv=27}', ""); +Expect(1, 12886, '\P{Is_Nv=27}', ""); +Expect(0, 12886, '\P{^Is_Nv=27}', ""); +Error('\p{Numeric_Value=_+0000010000000:=0}'); +Error('\P{Numeric_Value=_+0000010000000:=0}'); +Expect(1, 20159, '\p{Numeric_Value=00010_00000_00}', ""); +Expect(0, 20159, '\p{^Numeric_Value=00010_00000_00}', ""); +Expect(0, 20159, '\P{Numeric_Value=00010_00000_00}', ""); +Expect(1, 20159, '\P{^Numeric_Value=00010_00000_00}', ""); +Expect(0, 20158, '\p{Numeric_Value=00010_00000_00}', ""); +Expect(1, 20158, '\p{^Numeric_Value=00010_00000_00}', ""); +Expect(1, 20158, '\P{Numeric_Value=00010_00000_00}', ""); +Expect(0, 20158, '\P{^Numeric_Value=00010_00000_00}', ""); +Error('\p{Nv=-_00 00 10 0000000/a/}'); +Error('\P{Nv=-_00 00 10 0000000/a/}'); +Expect(1, 20159, '\p{Nv:+0_0_0_0_0_1_0_0_000000}', ""); +Expect(0, 20159, '\p{^Nv:+0_0_0_0_0_1_0_0_000000}', ""); +Expect(0, 20159, '\P{Nv:+0_0_0_0_0_1_0_0_000000}', ""); +Expect(1, 20159, '\P{^Nv:+0_0_0_0_0_1_0_0_000000}', ""); +Expect(0, 20158, '\p{Nv:+0_0_0_0_0_1_0_0_000000}', ""); +Expect(1, 20158, '\p{^Nv:+0_0_0_0_0_1_0_0_000000}', ""); +Expect(1, 20158, '\P{Nv:+0_0_0_0_0_1_0_0_000000}', ""); +Expect(0, 20158, '\P{^Nv:+0_0_0_0_0_1_0_0_000000}', ""); +Error('\p{Is_Numeric_Value= :=+00000100000000}'); +Error('\P{Is_Numeric_Value= :=+00000100000000}'); +Expect(1, 20159, '\p{Is_Numeric_Value=000000100000000}', ""); +Expect(0, 20159, '\p{^Is_Numeric_Value=000000100000000}', ""); +Expect(0, 20159, '\P{Is_Numeric_Value=000000100000000}', ""); +Expect(1, 20159, '\P{^Is_Numeric_Value=000000100000000}', ""); +Expect(0, 20158, '\p{Is_Numeric_Value=000000100000000}', ""); +Expect(1, 20158, '\p{^Is_Numeric_Value=000000100000000}', ""); +Expect(1, 20158, '\P{Is_Numeric_Value=000000100000000}', ""); +Expect(0, 20158, '\P{^Is_Numeric_Value=000000100000000}', ""); +Error('\p{Is_Nv=_0000_10:=0000000}'); +Error('\P{Is_Nv=_0000_10:=0000000}'); +Expect(1, 20159, '\p{Is_Nv=+0_0_0_0_0_0_0_0_0_1_0_0_0_0_0000}', ""); +Expect(0, 20159, '\p{^Is_Nv=+0_0_0_0_0_0_0_0_0_1_0_0_0_0_0000}', ""); +Expect(0, 20159, '\P{Is_Nv=+0_0_0_0_0_0_0_0_0_1_0_0_0_0_0000}', ""); +Expect(1, 20159, '\P{^Is_Nv=+0_0_0_0_0_0_0_0_0_1_0_0_0_0_0000}', ""); +Expect(0, 20158, '\p{Is_Nv=+0_0_0_0_0_0_0_0_0_1_0_0_0_0_0000}', ""); +Expect(1, 20158, '\p{^Is_Nv=+0_0_0_0_0_0_0_0_0_1_0_0_0_0_0000}', ""); +Expect(1, 20158, '\P{Is_Nv=+0_0_0_0_0_0_0_0_0_1_0_0_0_0_0000}', ""); +Expect(0, 20158, '\P{^Is_Nv=+0_0_0_0_0_0_0_0_0_1_0_0_0_0_0000}', ""); +Error('\p{Numeric_Value=-:=40_0}'); +Error('\P{Numeric_Value=-:=40_0}'); +Expect(1, 65820, '\p{Numeric_Value=40_0}', ""); +Expect(0, 65820, '\p{^Numeric_Value=40_0}', ""); +Expect(0, 65820, '\P{Numeric_Value=40_0}', ""); +Expect(1, 65820, '\P{^Numeric_Value=40_0}', ""); +Expect(0, 65819, '\p{Numeric_Value=40_0}', ""); +Expect(1, 65819, '\p{^Numeric_Value=40_0}', ""); +Expect(1, 65819, '\P{Numeric_Value=40_0}', ""); +Expect(0, 65819, '\P{^Numeric_Value=40_0}', ""); +Error('\p{Nv=-:=000000040_0}'); +Error('\P{Nv=-:=000000040_0}'); +Expect(1, 65820, '\p{Nv=0_0_0_4_00}', ""); +Expect(0, 65820, '\p{^Nv=0_0_0_4_00}', ""); +Expect(0, 65820, '\P{Nv=0_0_0_4_00}', ""); +Expect(1, 65820, '\P{^Nv=0_0_0_4_00}', ""); +Expect(0, 65819, '\p{Nv=0_0_0_4_00}', ""); +Expect(1, 65819, '\p{^Nv=0_0_0_4_00}', ""); +Expect(1, 65819, '\P{Nv=0_0_0_4_00}', ""); +Expect(0, 65819, '\P{^Nv=0_0_0_4_00}', ""); +Error('\p{Is_Numeric_Value=/a/ 000400}'); +Error('\P{Is_Numeric_Value=/a/ 000400}'); +Expect(1, 65820, '\p{Is_Numeric_Value=+000000400}', ""); +Expect(0, 65820, '\p{^Is_Numeric_Value=+000000400}', ""); +Expect(0, 65820, '\P{Is_Numeric_Value=+000000400}', ""); +Expect(1, 65820, '\P{^Is_Numeric_Value=+000000400}', ""); +Expect(0, 65819, '\p{Is_Numeric_Value=+000000400}', ""); +Expect(1, 65819, '\p{^Is_Numeric_Value=+000000400}', ""); +Expect(1, 65819, '\P{Is_Numeric_Value=+000000400}', ""); +Expect(0, 65819, '\P{^Is_Numeric_Value=+000000400}', ""); +Error('\p{Is_Nv=_:=000400}'); +Error('\P{Is_Nv=_:=000400}'); +Expect(1, 65820, '\p{Is_Nv=+00400}', ""); +Expect(0, 65820, '\p{^Is_Nv=+00400}', ""); +Expect(0, 65820, '\P{Is_Nv=+00400}', ""); +Expect(1, 65820, '\P{^Is_Nv=+00400}', ""); +Expect(0, 65819, '\p{Is_Nv=+00400}', ""); +Expect(1, 65819, '\p{^Is_Nv=+00400}', ""); +Expect(1, 65819, '\P{Is_Nv=+00400}', ""); +Expect(0, 65819, '\P{^Is_Nv=+00400}', ""); +Error('\p{Numeric_Value=/a/- 00005/000008}'); +Error('\P{Numeric_Value=/a/- 00005/000008}'); +Expect(1, 8541, '\p{Numeric_Value=+5/0000008}', ""); +Expect(0, 8541, '\p{^Numeric_Value=+5/0000008}', ""); +Expect(0, 8541, '\P{Numeric_Value=+5/0000008}', ""); +Expect(1, 8541, '\P{^Numeric_Value=+5/0000008}', ""); +Expect(0, 8540, '\p{Numeric_Value=+5/0000008}', ""); +Expect(1, 8540, '\p{^Numeric_Value=+5/0000008}', ""); +Expect(1, 8540, '\P{Numeric_Value=+5/0000008}', ""); +Expect(0, 8540, '\P{^Numeric_Value=+5/0000008}', ""); +Error('\p{Numeric_Value=0.62}'); +Error('\P{Numeric_Value=0.62}'); +Expect(1, 8541, '\p{Numeric_Value=0.625}', ""); +Expect(0, 8541, '\p{^Numeric_Value=0.625}', ""); +Expect(0, 8541, '\P{Numeric_Value=0.625}', ""); +Expect(1, 8541, '\P{^Numeric_Value=0.625}', ""); +Expect(0, 8540, '\p{Numeric_Value=0.625}', ""); +Expect(1, 8540, '\p{^Numeric_Value=0.625}', ""); +Expect(1, 8540, '\P{Numeric_Value=0.625}', ""); +Expect(0, 8540, '\P{^Numeric_Value=0.625}', ""); +Error('\p{Nv= /a/0000000005/0000008}'); +Error('\P{Nv= /a/0000000005/0000008}'); +Expect(1, 8541, '\p{Nv=005/00000008}', ""); +Expect(0, 8541, '\p{^Nv=005/00000008}', ""); +Expect(0, 8541, '\P{Nv=005/00000008}', ""); +Expect(1, 8541, '\P{^Nv=005/00000008}', ""); +Expect(0, 8540, '\p{Nv=005/00000008}', ""); +Expect(1, 8540, '\p{^Nv=005/00000008}', ""); +Expect(1, 8540, '\P{Nv=005/00000008}', ""); +Expect(0, 8540, '\P{^Nv=005/00000008}', ""); +Error('\p{Nv=0.62}'); +Error('\P{Nv=0.62}'); +Expect(1, 8541, '\p{Nv=0.625}', ""); +Expect(0, 8541, '\p{^Nv=0.625}', ""); +Expect(0, 8541, '\P{Nv=0.625}', ""); +Expect(1, 8541, '\P{^Nv=0.625}', ""); +Expect(0, 8540, '\p{Nv=0.625}', ""); +Expect(1, 8540, '\p{^Nv=0.625}', ""); +Expect(1, 8540, '\P{Nv=0.625}', ""); +Expect(0, 8540, '\P{^Nv=0.625}', ""); +Error('\p{Is_Numeric_Value= +0000005/8/a/}'); +Error('\P{Is_Numeric_Value= +0000005/8/a/}'); +Expect(1, 8541, '\p{Is_Numeric_Value:5/08}', ""); +Expect(0, 8541, '\p{^Is_Numeric_Value:5/08}', ""); +Expect(0, 8541, '\P{Is_Numeric_Value:5/08}', ""); +Expect(1, 8541, '\P{^Is_Numeric_Value:5/08}', ""); +Expect(0, 8540, '\p{Is_Numeric_Value:5/08}', ""); +Expect(1, 8540, '\p{^Is_Numeric_Value:5/08}', ""); +Expect(1, 8540, '\P{Is_Numeric_Value:5/08}', ""); +Expect(0, 8540, '\P{^Is_Numeric_Value:5/08}', ""); +Error('\p{Is_Numeric_Value=0.62}'); +Error('\P{Is_Numeric_Value=0.62}'); +Expect(1, 8541, '\p{Is_Numeric_Value=0.625}', ""); +Expect(0, 8541, '\p{^Is_Numeric_Value=0.625}', ""); +Expect(0, 8541, '\P{Is_Numeric_Value=0.625}', ""); +Expect(1, 8541, '\P{^Is_Numeric_Value=0.625}', ""); +Expect(0, 8540, '\p{Is_Numeric_Value=0.625}', ""); +Expect(1, 8540, '\p{^Is_Numeric_Value=0.625}', ""); +Expect(1, 8540, '\P{Is_Numeric_Value=0.625}', ""); +Expect(0, 8540, '\P{^Is_Numeric_Value=0.625}', ""); +Error('\p{Is_Nv=:=_00005/000000008}'); +Error('\P{Is_Nv=:=_00005/000000008}'); +Expect(1, 8541, '\p{Is_Nv=000000005/0008}', ""); +Expect(0, 8541, '\p{^Is_Nv=000000005/0008}', ""); +Expect(0, 8541, '\P{Is_Nv=000000005/0008}', ""); +Expect(1, 8541, '\P{^Is_Nv=000000005/0008}', ""); +Expect(0, 8540, '\p{Is_Nv=000000005/0008}', ""); +Expect(1, 8540, '\p{^Is_Nv=000000005/0008}', ""); +Expect(1, 8540, '\P{Is_Nv=000000005/0008}', ""); +Expect(0, 8540, '\P{^Is_Nv=000000005/0008}', ""); +Error('\p{Is_Nv=0.62}'); +Error('\P{Is_Nv=0.62}'); +Expect(1, 8541, '\p{Is_Nv=0.625}', ""); +Expect(0, 8541, '\p{^Is_Nv=0.625}', ""); +Expect(0, 8541, '\P{Is_Nv=0.625}', ""); +Expect(1, 8541, '\P{^Is_Nv=0.625}', ""); +Expect(0, 8540, '\p{Is_Nv=0.625}', ""); +Expect(1, 8540, '\p{^Is_Nv=0.625}', ""); +Expect(1, 8540, '\P{Is_Nv=0.625}', ""); +Expect(0, 8540, '\P{^Is_Nv=0.625}', ""); +Error('\p{Numeric_Value= 00/a/00_020}'); +Error('\P{Numeric_Value= 00/a/00_020}'); +Expect(1, 4979, '\p{Numeric_Value=00020}', ""); +Expect(0, 4979, '\p{^Numeric_Value=00020}', ""); +Expect(0, 4979, '\P{Numeric_Value=00020}', ""); +Expect(1, 4979, '\P{^Numeric_Value=00020}', ""); +Expect(0, 4978, '\p{Numeric_Value=00020}', ""); +Expect(1, 4978, '\p{^Numeric_Value=00020}', ""); +Expect(1, 4978, '\P{Numeric_Value=00020}', ""); +Expect(0, 4978, '\P{^Numeric_Value=00020}', ""); +Error('\p{Nv=:=-02 0}'); +Error('\P{Nv=:=-02 0}'); +Expect(1, 4979, '\p{Nv=000_002_0}', ""); +Expect(0, 4979, '\p{^Nv=000_002_0}', ""); +Expect(0, 4979, '\P{Nv=000_002_0}', ""); +Expect(1, 4979, '\P{^Nv=000_002_0}', ""); +Expect(0, 4978, '\p{Nv=000_002_0}', ""); +Expect(1, 4978, '\p{^Nv=000_002_0}', ""); +Expect(1, 4978, '\P{Nv=000_002_0}', ""); +Expect(0, 4978, '\P{^Nv=000_002_0}', ""); +Error('\p{Is_Numeric_Value: 00_00-00/a/20}'); +Error('\P{Is_Numeric_Value: 00_00-00/a/20}'); +Expect(1, 4979, '\p{Is_Numeric_Value=00020}', ""); +Expect(0, 4979, '\p{^Is_Numeric_Value=00020}', ""); +Expect(0, 4979, '\P{Is_Numeric_Value=00020}', ""); +Expect(1, 4979, '\P{^Is_Numeric_Value=00020}', ""); +Expect(0, 4978, '\p{Is_Numeric_Value=00020}', ""); +Expect(1, 4978, '\p{^Is_Numeric_Value=00020}', ""); +Expect(1, 4978, '\P{Is_Numeric_Value=00020}', ""); +Expect(0, 4978, '\P{^Is_Numeric_Value=00020}', ""); +Error('\p{Is_Nv=-:=00020}'); +Error('\P{Is_Nv=-:=00020}'); +Expect(1, 4979, '\p{Is_Nv=+020}', ""); +Expect(0, 4979, '\p{^Is_Nv=+020}', ""); +Expect(0, 4979, '\P{Is_Nv=+020}', ""); +Expect(1, 4979, '\P{^Is_Nv=+020}', ""); +Expect(0, 4978, '\p{Is_Nv=+020}', ""); +Expect(1, 4978, '\p{^Is_Nv=+020}', ""); +Expect(1, 4978, '\P{Is_Nv=+020}', ""); +Expect(0, 4978, '\P{^Is_Nv=+020}', ""); +Error('\p{Numeric_Value=/a/ _0000030000}'); +Error('\P{Numeric_Value=/a/ _0000030000}'); +Expect(1, 65837, '\p{Numeric_Value=00000030000}', ""); +Expect(0, 65837, '\p{^Numeric_Value=00000030000}', ""); +Expect(0, 65837, '\P{Numeric_Value=00000030000}', ""); +Expect(1, 65837, '\P{^Numeric_Value=00000030000}', ""); +Expect(0, 65836, '\p{Numeric_Value=00000030000}', ""); +Expect(1, 65836, '\p{^Numeric_Value=00000030000}', ""); +Expect(1, 65836, '\P{Numeric_Value=00000030000}', ""); +Expect(0, 65836, '\P{^Numeric_Value=00000030000}', ""); +Error('\p{Nv=:= +000030000}'); +Error('\P{Nv=:= +000030000}'); +Expect(1, 65837, '\p{Nv: 00000000030000}', ""); +Expect(0, 65837, '\p{^Nv: 00000000030000}', ""); +Expect(0, 65837, '\P{Nv: 00000000030000}', ""); +Expect(1, 65837, '\P{^Nv: 00000000030000}', ""); +Expect(0, 65836, '\p{Nv: 00000000030000}', ""); +Expect(1, 65836, '\p{^Nv: 00000000030000}', ""); +Expect(1, 65836, '\P{Nv: 00000000030000}', ""); +Expect(0, 65836, '\P{^Nv: 00000000030000}', ""); +Error('\p{Is_Numeric_Value= /a/+0000000030000}'); +Error('\P{Is_Numeric_Value= /a/+0000000030000}'); +Expect(1, 65837, '\p{Is_Numeric_Value=000_000_030_000}', ""); +Expect(0, 65837, '\p{^Is_Numeric_Value=000_000_030_000}', ""); +Expect(0, 65837, '\P{Is_Numeric_Value=000_000_030_000}', ""); +Expect(1, 65837, '\P{^Is_Numeric_Value=000_000_030_000}', ""); +Expect(0, 65836, '\p{Is_Numeric_Value=000_000_030_000}', ""); +Expect(1, 65836, '\p{^Is_Numeric_Value=000_000_030_000}', ""); +Expect(1, 65836, '\P{Is_Numeric_Value=000_000_030_000}', ""); +Expect(0, 65836, '\P{^Is_Numeric_Value=000_000_030_000}', ""); +Error('\p{Is_Nv= -0 0 0 0:=0 0-0-030000}'); +Error('\P{Is_Nv= -0 0 0 0:=0 0-0-030000}'); +Expect(1, 65837, '\p{Is_Nv=000_000_000_300_00}', ""); +Expect(0, 65837, '\p{^Is_Nv=000_000_000_300_00}', ""); +Expect(0, 65837, '\P{Is_Nv=000_000_000_300_00}', ""); +Expect(1, 65837, '\P{^Is_Nv=000_000_000_300_00}', ""); +Expect(0, 65836, '\p{Is_Nv=000_000_000_300_00}', ""); +Expect(1, 65836, '\p{^Is_Nv=000_000_000_300_00}', ""); +Expect(1, 65836, '\P{Is_Nv=000_000_000_300_00}', ""); +Expect(0, 65836, '\P{^Is_Nv=000_000_000_300_00}', ""); +Error('\p{Numeric_Value=_ 00/a/0_00-00010}'); +Error('\P{Numeric_Value=_ 00/a/0_00-00010}'); +Expect(1, 3056, '\p{Numeric_Value:000001_0}', ""); +Expect(0, 3056, '\p{^Numeric_Value:000001_0}', ""); +Expect(0, 3056, '\P{Numeric_Value:000001_0}', ""); +Expect(1, 3056, '\P{^Numeric_Value:000001_0}', ""); +Expect(0, 3055, '\p{Numeric_Value:000001_0}', ""); +Expect(1, 3055, '\p{^Numeric_Value:000001_0}', ""); +Expect(1, 3055, '\P{Numeric_Value:000001_0}', ""); +Expect(0, 3055, '\P{^Numeric_Value:000001_0}', ""); +Error('\p{Nv= /a/00 01_0}'); +Error('\P{Nv= /a/00 01_0}'); +Expect(1, 3056, '\p{Nv: +0010}', ""); +Expect(0, 3056, '\p{^Nv: +0010}', ""); +Expect(0, 3056, '\P{Nv: +0010}', ""); +Expect(1, 3056, '\P{^Nv: +0010}', ""); +Expect(0, 3055, '\p{Nv: +0010}', ""); +Expect(1, 3055, '\p{^Nv: +0010}', ""); +Expect(1, 3055, '\P{Nv: +0010}', ""); +Expect(0, 3055, '\P{^Nv: +0010}', ""); +Error('\p{Is_Numeric_Value=:=-0010}'); +Error('\P{Is_Numeric_Value=:=-0010}'); +Expect(1, 3056, '\p{Is_Numeric_Value=0_0_0_0_0_0_0_010}', ""); +Expect(0, 3056, '\p{^Is_Numeric_Value=0_0_0_0_0_0_0_010}', ""); +Expect(0, 3056, '\P{Is_Numeric_Value=0_0_0_0_0_0_0_010}', ""); +Expect(1, 3056, '\P{^Is_Numeric_Value=0_0_0_0_0_0_0_010}', ""); +Expect(0, 3055, '\p{Is_Numeric_Value=0_0_0_0_0_0_0_010}', ""); +Expect(1, 3055, '\p{^Is_Numeric_Value=0_0_0_0_0_0_0_010}', ""); +Expect(1, 3055, '\P{Is_Numeric_Value=0_0_0_0_0_0_0_010}', ""); +Expect(0, 3055, '\P{^Is_Numeric_Value=0_0_0_0_0_0_0_010}', ""); +Error('\p{Is_Nv= /a/+1 0}'); +Error('\P{Is_Nv= /a/+1 0}'); +Expect(1, 3056, '\p{Is_Nv=001_0}', ""); +Expect(0, 3056, '\p{^Is_Nv=001_0}', ""); +Expect(0, 3056, '\P{Is_Nv=001_0}', ""); +Expect(1, 3056, '\P{^Is_Nv=001_0}', ""); +Expect(0, 3055, '\p{Is_Nv=001_0}', ""); +Expect(1, 3055, '\p{^Is_Nv=001_0}', ""); +Expect(1, 3055, '\P{Is_Nv=001_0}', ""); +Expect(0, 3055, '\P{^Is_Nv=001_0}', ""); +Error('\p{Numeric_Value: 000 000 31:=}'); +Error('\P{Numeric_Value: 000 000 31:=}'); +Expect(1, 12891, '\p{Numeric_Value=0_0_0_0_0_0_0_031}', ""); +Expect(0, 12891, '\p{^Numeric_Value=0_0_0_0_0_0_0_031}', ""); +Expect(0, 12891, '\P{Numeric_Value=0_0_0_0_0_0_0_031}', ""); +Expect(1, 12891, '\P{^Numeric_Value=0_0_0_0_0_0_0_031}', ""); +Expect(0, 12890, '\p{Numeric_Value=0_0_0_0_0_0_0_031}', ""); +Expect(1, 12890, '\p{^Numeric_Value=0_0_0_0_0_0_0_031}', ""); +Expect(1, 12890, '\P{Numeric_Value=0_0_0_0_0_0_0_031}', ""); +Expect(0, 12890, '\P{^Numeric_Value=0_0_0_0_0_0_0_031}', ""); +Error('\p{Nv=--+00000000031/a/}'); +Error('\P{Nv=--+00000000031/a/}'); +Expect(1, 12891, '\p{Nv=03_1}', ""); +Expect(0, 12891, '\p{^Nv=03_1}', ""); +Expect(0, 12891, '\P{Nv=03_1}', ""); +Expect(1, 12891, '\P{^Nv=03_1}', ""); +Expect(0, 12890, '\p{Nv=03_1}', ""); +Expect(1, 12890, '\p{^Nv=03_1}', ""); +Expect(1, 12890, '\P{Nv=03_1}', ""); +Expect(0, 12890, '\P{^Nv=03_1}', ""); +Error('\p{Is_Numeric_Value=:=+0000031}'); +Error('\P{Is_Numeric_Value=:=+0000031}'); +Expect(1, 12891, '\p{Is_Numeric_Value=0_0_0_0_031}', ""); +Expect(0, 12891, '\p{^Is_Numeric_Value=0_0_0_0_031}', ""); +Expect(0, 12891, '\P{Is_Numeric_Value=0_0_0_0_031}', ""); +Expect(1, 12891, '\P{^Is_Numeric_Value=0_0_0_0_031}', ""); +Expect(0, 12890, '\p{Is_Numeric_Value=0_0_0_0_031}', ""); +Expect(1, 12890, '\p{^Is_Numeric_Value=0_0_0_0_031}', ""); +Expect(1, 12890, '\P{Is_Numeric_Value=0_0_0_0_031}', ""); +Expect(0, 12890, '\P{^Is_Numeric_Value=0_0_0_0_031}', ""); +Error('\p{Is_Nv= -00 03:=1}'); +Error('\P{Is_Nv= -00 03:=1}'); +Expect(1, 12891, '\p{Is_Nv=+3_1}', ""); +Expect(0, 12891, '\p{^Is_Nv=+3_1}', ""); +Expect(0, 12891, '\P{Is_Nv=+3_1}', ""); +Expect(1, 12891, '\P{^Is_Nv=+3_1}', ""); +Expect(0, 12890, '\p{Is_Nv=+3_1}', ""); +Expect(1, 12890, '\p{^Is_Nv=+3_1}', ""); +Expect(1, 12890, '\P{Is_Nv=+3_1}', ""); +Expect(0, 12890, '\P{^Is_Nv=+3_1}', ""); +Error('\p{Numeric_Value= 00008000/a/}'); +Error('\P{Numeric_Value= 00008000/a/}'); +Expect(1, 65833, '\p{Numeric_Value=0_0_0_0_8_000}', ""); +Expect(0, 65833, '\p{^Numeric_Value=0_0_0_0_8_000}', ""); +Expect(0, 65833, '\P{Numeric_Value=0_0_0_0_8_000}', ""); +Expect(1, 65833, '\P{^Numeric_Value=0_0_0_0_8_000}', ""); +Expect(0, 65832, '\p{Numeric_Value=0_0_0_0_8_000}', ""); +Expect(1, 65832, '\p{^Numeric_Value=0_0_0_0_8_000}', ""); +Expect(1, 65832, '\P{Numeric_Value=0_0_0_0_8_000}', ""); +Expect(0, 65832, '\P{^Numeric_Value=0_0_0_0_8_000}', ""); +Error('\p{Nv: +0008000/a/}'); +Error('\P{Nv: +0008000/a/}'); +Expect(1, 65833, '\p{Nv=008000}', ""); +Expect(0, 65833, '\p{^Nv=008000}', ""); +Expect(0, 65833, '\P{Nv=008000}', ""); +Expect(1, 65833, '\P{^Nv=008000}', ""); +Expect(0, 65832, '\p{Nv=008000}', ""); +Expect(1, 65832, '\p{^Nv=008000}', ""); +Expect(1, 65832, '\P{Nv=008000}', ""); +Expect(0, 65832, '\P{^Nv=008000}', ""); +Error('\p{Is_Numeric_Value=:=000008000}'); +Error('\P{Is_Numeric_Value=:=000008000}'); +Expect(1, 65833, '\p{Is_Numeric_Value=+000_000_000_800_0}', ""); +Expect(0, 65833, '\p{^Is_Numeric_Value=+000_000_000_800_0}', ""); +Expect(0, 65833, '\P{Is_Numeric_Value=+000_000_000_800_0}', ""); +Expect(1, 65833, '\P{^Is_Numeric_Value=+000_000_000_800_0}', ""); +Expect(0, 65832, '\p{Is_Numeric_Value=+000_000_000_800_0}', ""); +Expect(1, 65832, '\p{^Is_Numeric_Value=+000_000_000_800_0}', ""); +Expect(1, 65832, '\P{Is_Numeric_Value=+000_000_000_800_0}', ""); +Expect(0, 65832, '\P{^Is_Numeric_Value=+000_000_000_800_0}', ""); +Error('\p{Is_Nv=-008000:=}'); +Error('\P{Is_Nv=-008000:=}'); +Expect(1, 65833, '\p{Is_Nv: 00_00_00_00_80_00}', ""); +Expect(0, 65833, '\p{^Is_Nv: 00_00_00_00_80_00}', ""); +Expect(0, 65833, '\P{Is_Nv: 00_00_00_00_80_00}', ""); +Expect(1, 65833, '\P{^Is_Nv: 00_00_00_00_80_00}', ""); +Expect(0, 65832, '\p{Is_Nv: 00_00_00_00_80_00}', ""); +Expect(1, 65832, '\p{^Is_Nv: 00_00_00_00_80_00}', ""); +Expect(1, 65832, '\P{Is_Nv: 00_00_00_00_80_00}', ""); +Expect(0, 65832, '\P{^Is_Nv: 00_00_00_00_80_00}', ""); +Error('\p{Numeric_Value=_:=0 0 0 0 0_01-0_0 0 00 0-0 00000}'); +Error('\P{Numeric_Value=_:=0 0 0 0 0_01-0_0 0 00 0-0 00000}'); +Expect(1, 20806, '\p{Numeric_Value=1000000000000}', ""); +Expect(0, 20806, '\p{^Numeric_Value=1000000000000}', ""); +Expect(0, 20806, '\P{Numeric_Value=1000000000000}', ""); +Expect(1, 20806, '\P{^Numeric_Value=1000000000000}', ""); +Expect(0, 20805, '\p{Numeric_Value=1000000000000}', ""); +Expect(1, 20805, '\p{^Numeric_Value=1000000000000}', ""); +Expect(1, 20805, '\P{Numeric_Value=1000000000000}', ""); +Expect(0, 20805, '\P{^Numeric_Value=1000000000000}', ""); +Error('\p{Nv= 000100 000 000/a/0000}'); +Error('\P{Nv= 000100 000 000/a/0000}'); +Expect(1, 20806, '\p{Nv:+001000000000000}', ""); +Expect(0, 20806, '\p{^Nv:+001000000000000}', ""); +Expect(0, 20806, '\P{Nv:+001000000000000}', ""); +Expect(1, 20806, '\P{^Nv:+001000000000000}', ""); +Expect(0, 20805, '\p{Nv:+001000000000000}', ""); +Expect(1, 20805, '\p{^Nv:+001000000000000}', ""); +Expect(1, 20805, '\P{Nv:+001000000000000}', ""); +Expect(0, 20805, '\P{^Nv:+001000000000000}', ""); +Error('\p{Is_Numeric_Value=_+00001000000000000:=}'); +Error('\P{Is_Numeric_Value=_+00001000000000000:=}'); +Expect(1, 20806, '\p{Is_Numeric_Value=0_0_0_0_0_0_1_0_0_0_0_0_0_000000}', ""); +Expect(0, 20806, '\p{^Is_Numeric_Value=0_0_0_0_0_0_1_0_0_0_0_0_0_000000}', ""); +Expect(0, 20806, '\P{Is_Numeric_Value=0_0_0_0_0_0_1_0_0_0_0_0_0_000000}', ""); +Expect(1, 20806, '\P{^Is_Numeric_Value=0_0_0_0_0_0_1_0_0_0_0_0_0_000000}', ""); +Expect(0, 20805, '\p{Is_Numeric_Value=0_0_0_0_0_0_1_0_0_0_0_0_0_000000}', ""); +Expect(1, 20805, '\p{^Is_Numeric_Value=0_0_0_0_0_0_1_0_0_0_0_0_0_000000}', ""); +Expect(1, 20805, '\P{Is_Numeric_Value=0_0_0_0_0_0_1_0_0_0_0_0_0_000000}', ""); +Expect(0, 20805, '\P{^Is_Numeric_Value=0_0_0_0_0_0_1_0_0_0_0_0_0_000000}', ""); +Error('\p{Is_Nv: /a/000001000000000000}'); +Error('\P{Is_Nv: /a/000001000000000000}'); +Expect(1, 20806, '\p{Is_Nv=0_0_0_0_0_0_0_0_1_0_0_0_0_0_0_0_0_0_0_00}', ""); +Expect(0, 20806, '\p{^Is_Nv=0_0_0_0_0_0_0_0_1_0_0_0_0_0_0_0_0_0_0_00}', ""); +Expect(0, 20806, '\P{Is_Nv=0_0_0_0_0_0_0_0_1_0_0_0_0_0_0_0_0_0_0_00}', ""); +Expect(1, 20806, '\P{^Is_Nv=0_0_0_0_0_0_0_0_1_0_0_0_0_0_0_0_0_0_0_00}', ""); +Expect(0, 20805, '\p{Is_Nv=0_0_0_0_0_0_0_0_1_0_0_0_0_0_0_0_0_0_0_00}', ""); +Expect(1, 20805, '\p{^Is_Nv=0_0_0_0_0_0_0_0_1_0_0_0_0_0_0_0_0_0_0_00}', ""); +Expect(1, 20805, '\P{Is_Nv=0_0_0_0_0_0_0_0_1_0_0_0_0_0_0_0_0_0_0_00}', ""); +Expect(0, 20805, '\P{^Is_Nv=0_0_0_0_0_0_0_0_1_0_0_0_0_0_0_0_0_0_0_00}', ""); +Error('\p{Numeric_Value= _00-00/a/00 0035}'); +Error('\P{Numeric_Value= _00-00/a/00 0035}'); +Expect(1, 12895, '\p{Numeric_Value=+03_5}', ""); +Expect(0, 12895, '\p{^Numeric_Value=+03_5}', ""); +Expect(0, 12895, '\P{Numeric_Value=+03_5}', ""); +Expect(1, 12895, '\P{^Numeric_Value=+03_5}', ""); +Expect(0, 12894, '\p{Numeric_Value=+03_5}', ""); +Expect(1, 12894, '\p{^Numeric_Value=+03_5}', ""); +Expect(1, 12894, '\P{Numeric_Value=+03_5}', ""); +Expect(0, 12894, '\P{^Numeric_Value=+03_5}', ""); +Error('\p{Nv= -+035:=}'); +Error('\P{Nv= -+035:=}'); +Expect(1, 12895, '\p{Nv=003_5}', ""); +Expect(0, 12895, '\p{^Nv=003_5}', ""); +Expect(0, 12895, '\P{Nv=003_5}', ""); +Expect(1, 12895, '\P{^Nv=003_5}', ""); +Expect(0, 12894, '\p{Nv=003_5}', ""); +Expect(1, 12894, '\p{^Nv=003_5}', ""); +Expect(1, 12894, '\P{Nv=003_5}', ""); +Expect(0, 12894, '\P{^Nv=003_5}', ""); +Error('\p{Is_Numeric_Value= :=00000000035}'); +Error('\P{Is_Numeric_Value= :=00000000035}'); +Expect(1, 12895, '\p{Is_Numeric_Value=00000035}', ""); +Expect(0, 12895, '\p{^Is_Numeric_Value=00000035}', ""); +Expect(0, 12895, '\P{Is_Numeric_Value=00000035}', ""); +Expect(1, 12895, '\P{^Is_Numeric_Value=00000035}', ""); +Expect(0, 12894, '\p{Is_Numeric_Value=00000035}', ""); +Expect(1, 12894, '\p{^Is_Numeric_Value=00000035}', ""); +Expect(1, 12894, '\P{Is_Numeric_Value=00000035}', ""); +Expect(0, 12894, '\P{^Is_Numeric_Value=00000035}', ""); +Error('\p{Is_Nv= 00035/a/}'); +Error('\P{Is_Nv= 00035/a/}'); +Expect(1, 12895, '\p{Is_Nv=00000000035}', ""); +Expect(0, 12895, '\p{^Is_Nv=00000000035}', ""); +Expect(0, 12895, '\P{Is_Nv=00000000035}', ""); +Expect(1, 12895, '\P{^Is_Nv=00000000035}', ""); +Expect(0, 12894, '\p{Is_Nv=00000000035}', ""); +Expect(1, 12894, '\p{^Is_Nv=00000000035}', ""); +Expect(1, 12894, '\P{Is_Nv=00000000035}', ""); +Expect(0, 12894, '\P{^Is_Nv=00000000035}', ""); +Error('\p{Numeric_Value=-:=0-0_0_00-0 11}'); +Error('\P{Numeric_Value=-:=0-0_0_00-0 11}'); +Expect(1, 8554, '\p{Numeric_Value=+00011}', ""); +Expect(0, 8554, '\p{^Numeric_Value=+00011}', ""); +Expect(0, 8554, '\P{Numeric_Value=+00011}', ""); +Expect(1, 8554, '\P{^Numeric_Value=+00011}', ""); +Expect(0, 8553, '\p{Numeric_Value=+00011}', ""); +Expect(1, 8553, '\p{^Numeric_Value=+00011}', ""); +Expect(1, 8553, '\P{Numeric_Value=+00011}', ""); +Expect(0, 8553, '\P{^Numeric_Value=+00011}', ""); +Error('\p{Nv=- 01:=1}'); +Error('\P{Nv=- 01:=1}'); +Expect(1, 8554, '\p{Nv=011}', ""); +Expect(0, 8554, '\p{^Nv=011}', ""); +Expect(0, 8554, '\P{Nv=011}', ""); +Expect(1, 8554, '\P{^Nv=011}', ""); +Expect(0, 8553, '\p{Nv=011}', ""); +Expect(1, 8553, '\p{^Nv=011}', ""); +Expect(1, 8553, '\P{Nv=011}', ""); +Expect(0, 8553, '\P{^Nv=011}', ""); +Error('\p{Is_Numeric_Value: /a/+00-011}'); +Error('\P{Is_Numeric_Value: /a/+00-011}'); +Expect(1, 8554, '\p{Is_Numeric_Value=0_0_0_0_11}', ""); +Expect(0, 8554, '\p{^Is_Numeric_Value=0_0_0_0_11}', ""); +Expect(0, 8554, '\P{Is_Numeric_Value=0_0_0_0_11}', ""); +Expect(1, 8554, '\P{^Is_Numeric_Value=0_0_0_0_11}', ""); +Expect(0, 8553, '\p{Is_Numeric_Value=0_0_0_0_11}', ""); +Expect(1, 8553, '\p{^Is_Numeric_Value=0_0_0_0_11}', ""); +Expect(1, 8553, '\P{Is_Numeric_Value=0_0_0_0_11}', ""); +Expect(0, 8553, '\P{^Is_Numeric_Value=0_0_0_0_11}', ""); +Error('\p{Is_Nv=_ 1:=1}'); +Error('\P{Is_Nv=_ 1:=1}'); +Expect(1, 8554, '\p{Is_Nv:+01_1}', ""); +Expect(0, 8554, '\p{^Is_Nv:+01_1}', ""); +Expect(0, 8554, '\P{Is_Nv:+01_1}', ""); +Expect(1, 8554, '\P{^Is_Nv:+01_1}', ""); +Expect(0, 8553, '\p{Is_Nv:+01_1}', ""); +Expect(1, 8553, '\p{^Is_Nv:+01_1}', ""); +Expect(1, 8553, '\P{Is_Nv:+01_1}', ""); +Expect(0, 8553, '\P{^Is_Nv:+01_1}', ""); +Error('\p{Numeric_Value=-_+000001/00005/a/}'); +Error('\P{Numeric_Value=-_+000001/00005/a/}'); +Expect(1, 8533, '\p{Numeric_Value=+00000001/00000005}', ""); +Expect(0, 8533, '\p{^Numeric_Value=+00000001/00000005}', ""); +Expect(0, 8533, '\P{Numeric_Value=+00000001/00000005}', ""); +Expect(1, 8533, '\P{^Numeric_Value=+00000001/00000005}', ""); +Expect(0, 8532, '\p{Numeric_Value=+00000001/00000005}', ""); +Expect(1, 8532, '\p{^Numeric_Value=+00000001/00000005}', ""); +Expect(1, 8532, '\P{Numeric_Value=+00000001/00000005}', ""); +Expect(0, 8532, '\P{^Numeric_Value=+00000001/00000005}', ""); +Expect(1, 8533, '\p{Numeric_Value=0.200}', ""); +Expect(0, 8533, '\p{^Numeric_Value=0.200}', ""); +Expect(0, 8533, '\P{Numeric_Value=0.200}', ""); +Expect(1, 8533, '\P{^Numeric_Value=0.200}', ""); +Expect(0, 8532, '\p{Numeric_Value=0.200}', ""); +Expect(1, 8532, '\p{^Numeric_Value=0.200}', ""); +Expect(1, 8532, '\P{Numeric_Value=0.200}', ""); +Expect(0, 8532, '\P{^Numeric_Value=0.200}', ""); +Error('\p{Nv=--1/05:=}'); +Error('\P{Nv=--1/05:=}'); +Expect(1, 8533, '\p{Nv=+000000001/0000000005}', ""); +Expect(0, 8533, '\p{^Nv=+000000001/0000000005}', ""); +Expect(0, 8533, '\P{Nv=+000000001/0000000005}', ""); +Expect(1, 8533, '\P{^Nv=+000000001/0000000005}', ""); +Expect(0, 8532, '\p{Nv=+000000001/0000000005}', ""); +Expect(1, 8532, '\p{^Nv=+000000001/0000000005}', ""); +Expect(1, 8532, '\P{Nv=+000000001/0000000005}', ""); +Expect(0, 8532, '\P{^Nv=+000000001/0000000005}', ""); +Expect(1, 8533, '\p{Nv=0.200}', ""); +Expect(0, 8533, '\p{^Nv=0.200}', ""); +Expect(0, 8533, '\P{Nv=0.200}', ""); +Expect(1, 8533, '\P{^Nv=0.200}', ""); +Expect(0, 8532, '\p{Nv=0.200}', ""); +Expect(1, 8532, '\p{^Nv=0.200}', ""); +Expect(1, 8532, '\P{Nv=0.200}', ""); +Expect(0, 8532, '\P{^Nv=0.200}', ""); +Error('\p{Is_Numeric_Value= :=001/0000005}'); +Error('\P{Is_Numeric_Value= :=001/0000005}'); +Expect(1, 8533, '\p{Is_Numeric_Value=+000001/0005}', ""); +Expect(0, 8533, '\p{^Is_Numeric_Value=+000001/0005}', ""); +Expect(0, 8533, '\P{Is_Numeric_Value=+000001/0005}', ""); +Expect(1, 8533, '\P{^Is_Numeric_Value=+000001/0005}', ""); +Expect(0, 8532, '\p{Is_Numeric_Value=+000001/0005}', ""); +Expect(1, 8532, '\p{^Is_Numeric_Value=+000001/0005}', ""); +Expect(1, 8532, '\P{Is_Numeric_Value=+000001/0005}', ""); +Expect(0, 8532, '\P{^Is_Numeric_Value=+000001/0005}', ""); +Expect(1, 8533, '\p{Is_Numeric_Value=0.200}', ""); +Expect(0, 8533, '\p{^Is_Numeric_Value=0.200}', ""); +Expect(0, 8533, '\P{Is_Numeric_Value=0.200}', ""); +Expect(1, 8533, '\P{^Is_Numeric_Value=0.200}', ""); +Expect(0, 8532, '\p{Is_Numeric_Value=0.200}', ""); +Expect(1, 8532, '\p{^Is_Numeric_Value=0.200}', ""); +Expect(1, 8532, '\P{Is_Numeric_Value=0.200}', ""); +Expect(0, 8532, '\P{^Is_Numeric_Value=0.200}', ""); +Error('\p{Is_Nv: _ +0000001/005/a/}'); +Error('\P{Is_Nv: _ +0000001/005/a/}'); +Expect(1, 8533, '\p{Is_Nv=000000001/0000005}', ""); +Expect(0, 8533, '\p{^Is_Nv=000000001/0000005}', ""); +Expect(0, 8533, '\P{Is_Nv=000000001/0000005}', ""); +Expect(1, 8533, '\P{^Is_Nv=000000001/0000005}', ""); +Expect(0, 8532, '\p{Is_Nv=000000001/0000005}', ""); +Expect(1, 8532, '\p{^Is_Nv=000000001/0000005}', ""); +Expect(1, 8532, '\P{Is_Nv=000000001/0000005}', ""); +Expect(0, 8532, '\P{^Is_Nv=000000001/0000005}', ""); +Expect(1, 8533, '\p{Is_Nv=0.200}', ""); +Expect(0, 8533, '\p{^Is_Nv=0.200}', ""); +Expect(0, 8533, '\P{Is_Nv=0.200}', ""); +Expect(1, 8533, '\P{^Is_Nv=0.200}', ""); +Expect(0, 8532, '\p{Is_Nv=0.200}', ""); +Expect(1, 8532, '\p{^Is_Nv=0.200}', ""); +Expect(1, 8532, '\P{Is_Nv=0.200}', ""); +Expect(0, 8532, '\P{^Is_Nv=0.200}', ""); +Error('\p{Numeric_Value= -NAN:=}'); +Error('\P{Numeric_Value= -NAN:=}'); +Expect(1, 47, '\p{Numeric_Value=nan}', ""); +Expect(0, 47, '\p{^Numeric_Value=nan}', ""); +Expect(0, 47, '\P{Numeric_Value=nan}', ""); +Expect(1, 47, '\P{^Numeric_Value=nan}', ""); +Expect(0, 57, '\p{Numeric_Value=nan}', ""); +Expect(1, 57, '\p{^Numeric_Value=nan}', ""); +Expect(1, 57, '\P{Numeric_Value=nan}', ""); +Expect(0, 57, '\P{^Numeric_Value=nan}', ""); +Expect(1, 47, '\p{Numeric_Value=_ nan}', ""); +Expect(0, 47, '\p{^Numeric_Value=_ nan}', ""); +Expect(0, 47, '\P{Numeric_Value=_ nan}', ""); +Expect(1, 47, '\P{^Numeric_Value=_ nan}', ""); +Expect(0, 57, '\p{Numeric_Value=_ nan}', ""); +Expect(1, 57, '\p{^Numeric_Value=_ nan}', ""); +Expect(1, 57, '\P{Numeric_Value=_ nan}', ""); +Expect(0, 57, '\P{^Numeric_Value=_ nan}', ""); +Error('\p{Nv=/a/-nan}'); +Error('\P{Nv=/a/-nan}'); +Expect(1, 47, '\p{Nv=nan}', ""); +Expect(0, 47, '\p{^Nv=nan}', ""); +Expect(0, 47, '\P{Nv=nan}', ""); +Expect(1, 47, '\P{^Nv=nan}', ""); +Expect(0, 57, '\p{Nv=nan}', ""); +Expect(1, 57, '\p{^Nv=nan}', ""); +Expect(1, 57, '\P{Nv=nan}', ""); +Expect(0, 57, '\P{^Nv=nan}', ""); +Expect(1, 47, '\p{Nv=_ NaN}', ""); +Expect(0, 47, '\p{^Nv=_ NaN}', ""); +Expect(0, 47, '\P{Nv=_ NaN}', ""); +Expect(1, 47, '\P{^Nv=_ NaN}', ""); +Expect(0, 57, '\p{Nv=_ NaN}', ""); +Expect(1, 57, '\p{^Nv=_ NaN}', ""); +Expect(1, 57, '\P{Nv=_ NaN}', ""); +Expect(0, 57, '\P{^Nv=_ NaN}', ""); +Error('\p{Is_Numeric_Value=-/a/NAN}'); +Error('\P{Is_Numeric_Value=-/a/NAN}'); +Expect(1, 47, '\p{Is_Numeric_Value=nan}', ""); +Expect(0, 47, '\p{^Is_Numeric_Value=nan}', ""); +Expect(0, 47, '\P{Is_Numeric_Value=nan}', ""); +Expect(1, 47, '\P{^Is_Numeric_Value=nan}', ""); +Expect(0, 57, '\p{Is_Numeric_Value=nan}', ""); +Expect(1, 57, '\p{^Is_Numeric_Value=nan}', ""); +Expect(1, 57, '\P{Is_Numeric_Value=nan}', ""); +Expect(0, 57, '\P{^Is_Numeric_Value=nan}', ""); +Expect(1, 47, '\p{Is_Numeric_Value=_nan}', ""); +Expect(0, 47, '\p{^Is_Numeric_Value=_nan}', ""); +Expect(0, 47, '\P{Is_Numeric_Value=_nan}', ""); +Expect(1, 47, '\P{^Is_Numeric_Value=_nan}', ""); +Expect(0, 57, '\p{Is_Numeric_Value=_nan}', ""); +Expect(1, 57, '\p{^Is_Numeric_Value=_nan}', ""); +Expect(1, 57, '\P{Is_Numeric_Value=_nan}', ""); +Expect(0, 57, '\P{^Is_Numeric_Value=_nan}', ""); +Error('\p{Is_Nv=__NAN/a/}'); +Error('\P{Is_Nv=__NAN/a/}'); +Expect(1, 47, '\p{Is_Nv:nan}', ""); +Expect(0, 47, '\p{^Is_Nv:nan}', ""); +Expect(0, 47, '\P{Is_Nv:nan}', ""); +Expect(1, 47, '\P{^Is_Nv:nan}', ""); +Expect(0, 57, '\p{Is_Nv:nan}', ""); +Expect(1, 57, '\p{^Is_Nv:nan}', ""); +Expect(1, 57, '\P{Is_Nv:nan}', ""); +Expect(0, 57, '\P{^Is_Nv:nan}', ""); +Expect(1, 47, '\p{Is_Nv=_ NaN}', ""); +Expect(0, 47, '\p{^Is_Nv=_ NaN}', ""); +Expect(0, 47, '\P{Is_Nv=_ NaN}', ""); +Expect(1, 47, '\P{^Is_Nv=_ NaN}', ""); +Expect(0, 57, '\p{Is_Nv=_ NaN}', ""); +Expect(1, 57, '\p{^Is_Nv=_ NaN}', ""); +Expect(1, 57, '\P{Is_Nv=_ NaN}', ""); +Expect(0, 57, '\P{^Is_Nv=_ NaN}', ""); +Error('\p{Numeric_Value= -0000015/00000002/a/}'); +Error('\P{Numeric_Value= -0000015/00000002/a/}'); +Expect(1, 3889, '\p{Numeric_Value=0000000015/02}', ""); +Expect(0, 3889, '\p{^Numeric_Value=0000000015/02}', ""); +Expect(0, 3889, '\P{Numeric_Value=0000000015/02}', ""); +Expect(1, 3889, '\P{^Numeric_Value=0000000015/02}', ""); +Expect(0, 3888, '\p{Numeric_Value=0000000015/02}', ""); +Expect(1, 3888, '\p{^Numeric_Value=0000000015/02}', ""); +Expect(1, 3888, '\P{Numeric_Value=0000000015/02}', ""); +Expect(0, 3888, '\P{^Numeric_Value=0000000015/02}', ""); +Expect(1, 3889, '\p{Numeric_Value=7.500}', ""); +Expect(0, 3889, '\p{^Numeric_Value=7.500}', ""); +Expect(0, 3889, '\P{Numeric_Value=7.500}', ""); +Expect(1, 3889, '\P{^Numeric_Value=7.500}', ""); +Expect(0, 3888, '\p{Numeric_Value=7.500}', ""); +Expect(1, 3888, '\p{^Numeric_Value=7.500}', ""); +Expect(1, 3888, '\P{Numeric_Value=7.500}', ""); +Expect(0, 3888, '\P{^Numeric_Value=7.500}', ""); +Error('\p{Nv=/a/00015/2}'); +Error('\P{Nv=/a/00015/2}'); +Expect(1, 3889, '\p{Nv=+015/2}', ""); +Expect(0, 3889, '\p{^Nv=+015/2}', ""); +Expect(0, 3889, '\P{Nv=+015/2}', ""); +Expect(1, 3889, '\P{^Nv=+015/2}', ""); +Expect(0, 3888, '\p{Nv=+015/2}', ""); +Expect(1, 3888, '\p{^Nv=+015/2}', ""); +Expect(1, 3888, '\P{Nv=+015/2}', ""); +Expect(0, 3888, '\P{^Nv=+015/2}', ""); +Expect(1, 3889, '\p{Nv=7.500}', ""); +Expect(0, 3889, '\p{^Nv=7.500}', ""); +Expect(0, 3889, '\P{Nv=7.500}', ""); +Expect(1, 3889, '\P{^Nv=7.500}', ""); +Expect(0, 3888, '\p{Nv=7.500}', ""); +Expect(1, 3888, '\p{^Nv=7.500}', ""); +Expect(1, 3888, '\P{Nv=7.500}', ""); +Expect(0, 3888, '\P{^Nv=7.500}', ""); +Error('\p{Is_Numeric_Value=_:=+00000015/2}'); +Error('\P{Is_Numeric_Value=_:=+00000015/2}'); +Expect(1, 3889, '\p{Is_Numeric_Value=+00015/00000002}', ""); +Expect(0, 3889, '\p{^Is_Numeric_Value=+00015/00000002}', ""); +Expect(0, 3889, '\P{Is_Numeric_Value=+00015/00000002}', ""); +Expect(1, 3889, '\P{^Is_Numeric_Value=+00015/00000002}', ""); +Expect(0, 3888, '\p{Is_Numeric_Value=+00015/00000002}', ""); +Expect(1, 3888, '\p{^Is_Numeric_Value=+00015/00000002}', ""); +Expect(1, 3888, '\P{Is_Numeric_Value=+00015/00000002}', ""); +Expect(0, 3888, '\P{^Is_Numeric_Value=+00015/00000002}', ""); +Expect(1, 3889, '\p{Is_Numeric_Value=7.500}', ""); +Expect(0, 3889, '\p{^Is_Numeric_Value=7.500}', ""); +Expect(0, 3889, '\P{Is_Numeric_Value=7.500}', ""); +Expect(1, 3889, '\P{^Is_Numeric_Value=7.500}', ""); +Expect(0, 3888, '\p{Is_Numeric_Value=7.500}', ""); +Expect(1, 3888, '\p{^Is_Numeric_Value=7.500}', ""); +Expect(1, 3888, '\P{Is_Numeric_Value=7.500}', ""); +Expect(0, 3888, '\P{^Is_Numeric_Value=7.500}', ""); +Error('\p{Is_Nv= /a/+00000000015/00000002}'); +Error('\P{Is_Nv= /a/+00000000015/00000002}'); +Expect(1, 3889, '\p{Is_Nv=+00000000015/00002}', ""); +Expect(0, 3889, '\p{^Is_Nv=+00000000015/00002}', ""); +Expect(0, 3889, '\P{Is_Nv=+00000000015/00002}', ""); +Expect(1, 3889, '\P{^Is_Nv=+00000000015/00002}', ""); +Expect(0, 3888, '\p{Is_Nv=+00000000015/00002}', ""); +Expect(1, 3888, '\p{^Is_Nv=+00000000015/00002}', ""); +Expect(1, 3888, '\P{Is_Nv=+00000000015/00002}', ""); +Expect(0, 3888, '\P{^Is_Nv=+00000000015/00002}', ""); +Expect(1, 3889, '\p{Is_Nv=7.500}', ""); +Expect(0, 3889, '\p{^Is_Nv=7.500}', ""); +Expect(0, 3889, '\P{Is_Nv=7.500}', ""); +Expect(1, 3889, '\P{^Is_Nv=7.500}', ""); +Expect(0, 3888, '\p{Is_Nv=7.500}', ""); +Expect(1, 3888, '\p{^Is_Nv=7.500}', ""); +Expect(1, 3888, '\P{Is_Nv=7.500}', ""); +Expect(0, 3888, '\P{^Is_Nv=7.500}', ""); +Error('\p{Numeric_Value= /a/0000000007/00008}'); +Error('\P{Numeric_Value= /a/0000000007/00008}'); +Expect(1, 8542, '\p{Numeric_Value:000000007/0000000008}', ""); +Expect(0, 8542, '\p{^Numeric_Value:000000007/0000000008}', ""); +Expect(0, 8542, '\P{Numeric_Value:000000007/0000000008}', ""); +Expect(1, 8542, '\P{^Numeric_Value:000000007/0000000008}', ""); +Expect(0, 8541, '\p{Numeric_Value:000000007/0000000008}', ""); +Expect(1, 8541, '\p{^Numeric_Value:000000007/0000000008}', ""); +Expect(1, 8541, '\P{Numeric_Value:000000007/0000000008}', ""); +Expect(0, 8541, '\P{^Numeric_Value:000000007/0000000008}', ""); +Error('\p{Numeric_Value=0.9}'); +Error('\P{Numeric_Value=0.9}'); +Error('\p{Numeric_Value=0.88}'); +Error('\P{Numeric_Value=0.88}'); +Expect(1, 8542, '\p{Numeric_Value=0.875}', ""); +Expect(0, 8542, '\p{^Numeric_Value=0.875}', ""); +Expect(0, 8542, '\P{Numeric_Value=0.875}', ""); +Expect(1, 8542, '\P{^Numeric_Value=0.875}', ""); +Expect(0, 8541, '\p{Numeric_Value=0.875}', ""); +Expect(1, 8541, '\p{^Numeric_Value=0.875}', ""); +Expect(1, 8541, '\P{Numeric_Value=0.875}', ""); +Expect(0, 8541, '\P{^Numeric_Value=0.875}', ""); +Error('\p{Nv=/a/ 0007/000000008}'); +Error('\P{Nv=/a/ 0007/000000008}'); +Expect(1, 8542, '\p{Nv=0000000007/0008}', ""); +Expect(0, 8542, '\p{^Nv=0000000007/0008}', ""); +Expect(0, 8542, '\P{Nv=0000000007/0008}', ""); +Expect(1, 8542, '\P{^Nv=0000000007/0008}', ""); +Expect(0, 8541, '\p{Nv=0000000007/0008}', ""); +Expect(1, 8541, '\p{^Nv=0000000007/0008}', ""); +Expect(1, 8541, '\P{Nv=0000000007/0008}', ""); +Expect(0, 8541, '\P{^Nv=0000000007/0008}', ""); +Error('\p{Nv=0.9}'); +Error('\P{Nv=0.9}'); +Error('\p{Nv=0.88}'); +Error('\P{Nv=0.88}'); +Expect(1, 8542, '\p{Nv=0.875}', ""); +Expect(0, 8542, '\p{^Nv=0.875}', ""); +Expect(0, 8542, '\P{Nv=0.875}', ""); +Expect(1, 8542, '\P{^Nv=0.875}', ""); +Expect(0, 8541, '\p{Nv=0.875}', ""); +Expect(1, 8541, '\p{^Nv=0.875}', ""); +Expect(1, 8541, '\P{Nv=0.875}', ""); +Expect(0, 8541, '\P{^Nv=0.875}', ""); +Error('\p{Is_Numeric_Value=- +00000007/000000008:=}'); +Error('\P{Is_Numeric_Value=- +00000007/000000008:=}'); +Expect(1, 8542, '\p{Is_Numeric_Value=000007/0000000008}', ""); +Expect(0, 8542, '\p{^Is_Numeric_Value=000007/0000000008}', ""); +Expect(0, 8542, '\P{Is_Numeric_Value=000007/0000000008}', ""); +Expect(1, 8542, '\P{^Is_Numeric_Value=000007/0000000008}', ""); +Expect(0, 8541, '\p{Is_Numeric_Value=000007/0000000008}', ""); +Expect(1, 8541, '\p{^Is_Numeric_Value=000007/0000000008}', ""); +Expect(1, 8541, '\P{Is_Numeric_Value=000007/0000000008}', ""); +Expect(0, 8541, '\P{^Is_Numeric_Value=000007/0000000008}', ""); +Error('\p{Is_Numeric_Value=0.9}'); +Error('\P{Is_Numeric_Value=0.9}'); +Error('\p{Is_Numeric_Value=0.88}'); +Error('\P{Is_Numeric_Value=0.88}'); +Expect(1, 8542, '\p{Is_Numeric_Value: 0.875}', ""); +Expect(0, 8542, '\p{^Is_Numeric_Value: 0.875}', ""); +Expect(0, 8542, '\P{Is_Numeric_Value: 0.875}', ""); +Expect(1, 8542, '\P{^Is_Numeric_Value: 0.875}', ""); +Expect(0, 8541, '\p{Is_Numeric_Value: 0.875}', ""); +Expect(1, 8541, '\p{^Is_Numeric_Value: 0.875}', ""); +Expect(1, 8541, '\P{Is_Numeric_Value: 0.875}', ""); +Expect(0, 8541, '\P{^Is_Numeric_Value: 0.875}', ""); +Error('\p{Is_Nv= /a/0000007/0008}'); +Error('\P{Is_Nv= /a/0000007/0008}'); +Expect(1, 8542, '\p{Is_Nv=00007/008}', ""); +Expect(0, 8542, '\p{^Is_Nv=00007/008}', ""); +Expect(0, 8542, '\P{Is_Nv=00007/008}', ""); +Expect(1, 8542, '\P{^Is_Nv=00007/008}', ""); +Expect(0, 8541, '\p{Is_Nv=00007/008}', ""); +Expect(1, 8541, '\p{^Is_Nv=00007/008}', ""); +Expect(1, 8541, '\P{Is_Nv=00007/008}', ""); +Expect(0, 8541, '\P{^Is_Nv=00007/008}', ""); +Error('\p{Is_Nv=0.9}'); +Error('\P{Is_Nv=0.9}'); +Error('\p{Is_Nv=0.88}'); +Error('\P{Is_Nv=0.88}'); +Expect(1, 8542, '\p{Is_Nv=0.875}', ""); +Expect(0, 8542, '\p{^Is_Nv=0.875}', ""); +Expect(0, 8542, '\P{Is_Nv=0.875}', ""); +Expect(1, 8542, '\P{^Is_Nv=0.875}', ""); +Expect(0, 8541, '\p{Is_Nv=0.875}', ""); +Expect(1, 8541, '\p{^Is_Nv=0.875}', ""); +Expect(1, 8541, '\P{Is_Nv=0.875}', ""); +Expect(0, 8541, '\P{^Is_Nv=0.875}', ""); +Error('\p{Numeric_Value=:=_+00000000070 0}'); +Error('\P{Numeric_Value=:=_+00000000070 0}'); +Expect(1, 65823, '\p{Numeric_Value=00000700}', ""); +Expect(0, 65823, '\p{^Numeric_Value=00000700}', ""); +Expect(0, 65823, '\P{Numeric_Value=00000700}', ""); +Expect(1, 65823, '\P{^Numeric_Value=00000700}', ""); +Expect(0, 65822, '\p{Numeric_Value=00000700}', ""); +Expect(1, 65822, '\p{^Numeric_Value=00000700}', ""); +Expect(1, 65822, '\P{Numeric_Value=00000700}', ""); +Expect(0, 65822, '\P{^Numeric_Value=00000700}', ""); +Error('\p{Nv=_070/a/0}'); +Error('\P{Nv=_070/a/0}'); +Expect(1, 65823, '\p{Nv=00000700}', ""); +Expect(0, 65823, '\p{^Nv=00000700}', ""); +Expect(0, 65823, '\P{Nv=00000700}', ""); +Expect(1, 65823, '\P{^Nv=00000700}', ""); +Expect(0, 65822, '\p{Nv=00000700}', ""); +Expect(1, 65822, '\p{^Nv=00000700}', ""); +Expect(1, 65822, '\P{Nv=00000700}', ""); +Expect(0, 65822, '\P{^Nv=00000700}', ""); +Error('\p{Is_Numeric_Value=:= _+00000 00007-00}'); +Error('\P{Is_Numeric_Value=:= _+00000 00007-00}'); +Expect(1, 65823, '\p{Is_Numeric_Value=0_0_0_0_0_0_700}', ""); +Expect(0, 65823, '\p{^Is_Numeric_Value=0_0_0_0_0_0_700}', ""); +Expect(0, 65823, '\P{Is_Numeric_Value=0_0_0_0_0_0_700}', ""); +Expect(1, 65823, '\P{^Is_Numeric_Value=0_0_0_0_0_0_700}', ""); +Expect(0, 65822, '\p{Is_Numeric_Value=0_0_0_0_0_0_700}', ""); +Expect(1, 65822, '\p{^Is_Numeric_Value=0_0_0_0_0_0_700}', ""); +Expect(1, 65822, '\P{Is_Numeric_Value=0_0_0_0_0_0_700}', ""); +Expect(0, 65822, '\P{^Is_Numeric_Value=0_0_0_0_0_0_700}', ""); +Error('\p{Is_Nv=:=_ 000700}'); +Error('\P{Is_Nv=:=_ 000700}'); +Expect(1, 65823, '\p{Is_Nv=+0_0_0_0_0_7_00}', ""); +Expect(0, 65823, '\p{^Is_Nv=+0_0_0_0_0_7_00}', ""); +Expect(0, 65823, '\P{Is_Nv=+0_0_0_0_0_7_00}', ""); +Expect(1, 65823, '\P{^Is_Nv=+0_0_0_0_0_7_00}', ""); +Expect(0, 65822, '\p{Is_Nv=+0_0_0_0_0_7_00}', ""); +Expect(1, 65822, '\p{^Is_Nv=+0_0_0_0_0_7_00}', ""); +Expect(1, 65822, '\P{Is_Nv=+0_0_0_0_0_7_00}', ""); +Expect(0, 65822, '\P{^Is_Nv=+0_0_0_0_0_7_00}', ""); +Error('\p{Numeric_Value= /a/00013/0002}'); +Error('\P{Numeric_Value= /a/00013/0002}'); +Expect(1, 3888, '\p{Numeric_Value=0000000013/2}', ""); +Expect(0, 3888, '\p{^Numeric_Value=0000000013/2}', ""); +Expect(0, 3888, '\P{Numeric_Value=0000000013/2}', ""); +Expect(1, 3888, '\P{^Numeric_Value=0000000013/2}', ""); +Expect(0, 3887, '\p{Numeric_Value=0000000013/2}', ""); +Expect(1, 3887, '\p{^Numeric_Value=0000000013/2}', ""); +Expect(1, 3887, '\P{Numeric_Value=0000000013/2}', ""); +Expect(0, 3887, '\P{^Numeric_Value=0000000013/2}', ""); +Expect(1, 3888, '\p{Numeric_Value:6.500}', ""); +Expect(0, 3888, '\p{^Numeric_Value:6.500}', ""); +Expect(0, 3888, '\P{Numeric_Value:6.500}', ""); +Expect(1, 3888, '\P{^Numeric_Value:6.500}', ""); +Expect(0, 3887, '\p{Numeric_Value:6.500}', ""); +Expect(1, 3887, '\p{^Numeric_Value:6.500}', ""); +Expect(1, 3887, '\P{Numeric_Value:6.500}', ""); +Expect(0, 3887, '\P{^Numeric_Value:6.500}', ""); +Error('\p{Nv= /a/13/0002}'); +Error('\P{Nv= /a/13/0002}'); +Expect(1, 3888, '\p{Nv=0000013/00000002}', ""); +Expect(0, 3888, '\p{^Nv=0000013/00000002}', ""); +Expect(0, 3888, '\P{Nv=0000013/00000002}', ""); +Expect(1, 3888, '\P{^Nv=0000013/00000002}', ""); +Expect(0, 3887, '\p{Nv=0000013/00000002}', ""); +Expect(1, 3887, '\p{^Nv=0000013/00000002}', ""); +Expect(1, 3887, '\P{Nv=0000013/00000002}', ""); +Expect(0, 3887, '\P{^Nv=0000013/00000002}', ""); +Expect(1, 3888, '\p{Nv:6.500}', ""); +Expect(0, 3888, '\p{^Nv:6.500}', ""); +Expect(0, 3888, '\P{Nv:6.500}', ""); +Expect(1, 3888, '\P{^Nv:6.500}', ""); +Expect(0, 3887, '\p{Nv:6.500}', ""); +Expect(1, 3887, '\p{^Nv:6.500}', ""); +Expect(1, 3887, '\P{Nv:6.500}', ""); +Expect(0, 3887, '\P{^Nv:6.500}', ""); +Error('\p{Is_Numeric_Value: :=0000000013/2}'); +Error('\P{Is_Numeric_Value: :=0000000013/2}'); +Expect(1, 3888, '\p{Is_Numeric_Value=+00000013/00000002}', ""); +Expect(0, 3888, '\p{^Is_Numeric_Value=+00000013/00000002}', ""); +Expect(0, 3888, '\P{Is_Numeric_Value=+00000013/00000002}', ""); +Expect(1, 3888, '\P{^Is_Numeric_Value=+00000013/00000002}', ""); +Expect(0, 3887, '\p{Is_Numeric_Value=+00000013/00000002}', ""); +Expect(1, 3887, '\p{^Is_Numeric_Value=+00000013/00000002}', ""); +Expect(1, 3887, '\P{Is_Numeric_Value=+00000013/00000002}', ""); +Expect(0, 3887, '\P{^Is_Numeric_Value=+00000013/00000002}', ""); +Expect(1, 3888, '\p{Is_Numeric_Value=6.500}', ""); +Expect(0, 3888, '\p{^Is_Numeric_Value=6.500}', ""); +Expect(0, 3888, '\P{Is_Numeric_Value=6.500}', ""); +Expect(1, 3888, '\P{^Is_Numeric_Value=6.500}', ""); +Expect(0, 3887, '\p{Is_Numeric_Value=6.500}', ""); +Expect(1, 3887, '\p{^Is_Numeric_Value=6.500}', ""); +Expect(1, 3887, '\P{Is_Numeric_Value=6.500}', ""); +Expect(0, 3887, '\P{^Is_Numeric_Value=6.500}', ""); +Error('\p{Is_Nv=/a/ +13/000000002}'); +Error('\P{Is_Nv=/a/ +13/000000002}'); +Expect(1, 3888, '\p{Is_Nv=+0000013/02}', ""); +Expect(0, 3888, '\p{^Is_Nv=+0000013/02}', ""); +Expect(0, 3888, '\P{Is_Nv=+0000013/02}', ""); +Expect(1, 3888, '\P{^Is_Nv=+0000013/02}', ""); +Expect(0, 3887, '\p{Is_Nv=+0000013/02}', ""); +Expect(1, 3887, '\p{^Is_Nv=+0000013/02}', ""); +Expect(1, 3887, '\P{Is_Nv=+0000013/02}', ""); +Expect(0, 3887, '\P{^Is_Nv=+0000013/02}', ""); +Expect(1, 3888, '\p{Is_Nv: 6.500}', ""); +Expect(0, 3888, '\p{^Is_Nv: 6.500}', ""); +Expect(0, 3888, '\P{Is_Nv: 6.500}', ""); +Expect(1, 3888, '\P{^Is_Nv: 6.500}', ""); +Expect(0, 3887, '\p{Is_Nv: 6.500}', ""); +Expect(1, 3887, '\p{^Is_Nv: 6.500}', ""); +Expect(1, 3887, '\P{Is_Nv: 6.500}', ""); +Expect(0, 3887, '\P{^Is_Nv: 6.500}', ""); +Error('\p{Numeric_Value= :=+00000 00004 8}'); +Error('\P{Numeric_Value= :=+00000 00004 8}'); +Expect(1, 12989, '\p{Numeric_Value: 00000048}', ""); +Expect(0, 12989, '\p{^Numeric_Value: 00000048}', ""); +Expect(0, 12989, '\P{Numeric_Value: 00000048}', ""); +Expect(1, 12989, '\P{^Numeric_Value: 00000048}', ""); +Expect(0, 12988, '\p{Numeric_Value: 00000048}', ""); +Expect(1, 12988, '\p{^Numeric_Value: 00000048}', ""); +Expect(1, 12988, '\P{Numeric_Value: 00000048}', ""); +Expect(0, 12988, '\P{^Numeric_Value: 00000048}', ""); +Error('\p{Nv=/a/- 0 048}'); +Error('\P{Nv=/a/- 0 048}'); +Expect(1, 12989, '\p{Nv=0_0_0_0_048}', ""); +Expect(0, 12989, '\p{^Nv=0_0_0_0_048}', ""); +Expect(0, 12989, '\P{Nv=0_0_0_0_048}', ""); +Expect(1, 12989, '\P{^Nv=0_0_0_0_048}', ""); +Expect(0, 12988, '\p{Nv=0_0_0_0_048}', ""); +Expect(1, 12988, '\p{^Nv=0_0_0_0_048}', ""); +Expect(1, 12988, '\P{Nv=0_0_0_0_048}', ""); +Expect(0, 12988, '\P{^Nv=0_0_0_0_048}', ""); +Error('\p{Is_Numeric_Value=_/a/+0 0-0-0 0 0 00-048}'); +Error('\P{Is_Numeric_Value=_/a/+0 0-0-0 0 0 00-048}'); +Expect(1, 12989, '\p{Is_Numeric_Value=+0_0_0_0_0_0_0_048}', ""); +Expect(0, 12989, '\p{^Is_Numeric_Value=+0_0_0_0_0_0_0_048}', ""); +Expect(0, 12989, '\P{Is_Numeric_Value=+0_0_0_0_0_0_0_048}', ""); +Expect(1, 12989, '\P{^Is_Numeric_Value=+0_0_0_0_0_0_0_048}', ""); +Expect(0, 12988, '\p{Is_Numeric_Value=+0_0_0_0_0_0_0_048}', ""); +Expect(1, 12988, '\p{^Is_Numeric_Value=+0_0_0_0_0_0_0_048}', ""); +Expect(1, 12988, '\P{Is_Numeric_Value=+0_0_0_0_0_0_0_048}', ""); +Expect(0, 12988, '\P{^Is_Numeric_Value=+0_0_0_0_0_0_0_048}', ""); +Error('\p{Is_Nv= /a/+048}'); +Error('\P{Is_Nv= /a/+048}'); +Expect(1, 12989, '\p{Is_Nv=00_00_48}', ""); +Expect(0, 12989, '\p{^Is_Nv=00_00_48}', ""); +Expect(0, 12989, '\P{Is_Nv=00_00_48}', ""); +Expect(1, 12989, '\P{^Is_Nv=00_00_48}', ""); +Expect(0, 12988, '\p{Is_Nv=00_00_48}', ""); +Expect(1, 12988, '\p{^Is_Nv=00_00_48}', ""); +Expect(1, 12988, '\P{Is_Nv=00_00_48}', ""); +Expect(0, 12988, '\P{^Is_Nv=00_00_48}', ""); +Error('\p{Numeric_Value=/a/--000001/003}'); +Error('\P{Numeric_Value=/a/--000001/003}'); +Expect(1, 8531, '\p{Numeric_Value=00000001/000000003}', ""); +Expect(0, 8531, '\p{^Numeric_Value=00000001/000000003}', ""); +Expect(0, 8531, '\P{Numeric_Value=00000001/000000003}', ""); +Expect(1, 8531, '\P{^Numeric_Value=00000001/000000003}', ""); +Expect(0, 8530, '\p{Numeric_Value=00000001/000000003}', ""); +Expect(1, 8530, '\p{^Numeric_Value=00000001/000000003}', ""); +Expect(1, 8530, '\P{Numeric_Value=00000001/000000003}', ""); +Expect(0, 8530, '\P{^Numeric_Value=00000001/000000003}', ""); +Error('\p{Numeric_Value:0.3}'); +Error('\P{Numeric_Value:0.3}'); +Error('\p{Numeric_Value=0.33}'); +Error('\P{Numeric_Value=0.33}'); +Expect(1, 8531, '\p{Numeric_Value=0.333}', ""); +Expect(0, 8531, '\p{^Numeric_Value=0.333}', ""); +Expect(0, 8531, '\P{Numeric_Value=0.333}', ""); +Expect(1, 8531, '\P{^Numeric_Value=0.333}', ""); +Expect(0, 8530, '\p{Numeric_Value=0.333}', ""); +Expect(1, 8530, '\p{^Numeric_Value=0.333}', ""); +Expect(1, 8530, '\P{Numeric_Value=0.333}', ""); +Expect(0, 8530, '\P{^Numeric_Value=0.333}', ""); +Error('\p{Nv=/a/- 0001/03}'); +Error('\P{Nv=/a/- 0001/03}'); +Expect(1, 8531, '\p{Nv=0000000001/000003}', ""); +Expect(0, 8531, '\p{^Nv=0000000001/000003}', ""); +Expect(0, 8531, '\P{Nv=0000000001/000003}', ""); +Expect(1, 8531, '\P{^Nv=0000000001/000003}', ""); +Expect(0, 8530, '\p{Nv=0000000001/000003}', ""); +Expect(1, 8530, '\p{^Nv=0000000001/000003}', ""); +Expect(1, 8530, '\P{Nv=0000000001/000003}', ""); +Expect(0, 8530, '\P{^Nv=0000000001/000003}', ""); +Error('\p{Nv=0.3}'); +Error('\P{Nv=0.3}'); +Error('\p{Nv=0.33}'); +Error('\P{Nv=0.33}'); +Expect(1, 8531, '\p{Nv=0.333}', ""); +Expect(0, 8531, '\p{^Nv=0.333}', ""); +Expect(0, 8531, '\P{Nv=0.333}', ""); +Expect(1, 8531, '\P{^Nv=0.333}', ""); +Expect(0, 8530, '\p{Nv=0.333}', ""); +Expect(1, 8530, '\p{^Nv=0.333}', ""); +Expect(1, 8530, '\P{Nv=0.333}', ""); +Expect(0, 8530, '\P{^Nv=0.333}', ""); +Error('\p{Is_Numeric_Value= 001/0003:=}'); +Error('\P{Is_Numeric_Value= 001/0003:=}'); +Expect(1, 8531, '\p{Is_Numeric_Value=00001/0000000003}', ""); +Expect(0, 8531, '\p{^Is_Numeric_Value=00001/0000000003}', ""); +Expect(0, 8531, '\P{Is_Numeric_Value=00001/0000000003}', ""); +Expect(1, 8531, '\P{^Is_Numeric_Value=00001/0000000003}', ""); +Expect(0, 8530, '\p{Is_Numeric_Value=00001/0000000003}', ""); +Expect(1, 8530, '\p{^Is_Numeric_Value=00001/0000000003}', ""); +Expect(1, 8530, '\P{Is_Numeric_Value=00001/0000000003}', ""); +Expect(0, 8530, '\P{^Is_Numeric_Value=00001/0000000003}', ""); +Error('\p{Is_Numeric_Value=0.3}'); +Error('\P{Is_Numeric_Value=0.3}'); +Error('\p{Is_Numeric_Value=0.33}'); +Error('\P{Is_Numeric_Value=0.33}'); +Expect(1, 8531, '\p{Is_Numeric_Value=0.333}', ""); +Expect(0, 8531, '\p{^Is_Numeric_Value=0.333}', ""); +Expect(0, 8531, '\P{Is_Numeric_Value=0.333}', ""); +Expect(1, 8531, '\P{^Is_Numeric_Value=0.333}', ""); +Expect(0, 8530, '\p{Is_Numeric_Value=0.333}', ""); +Expect(1, 8530, '\p{^Is_Numeric_Value=0.333}', ""); +Expect(1, 8530, '\P{Is_Numeric_Value=0.333}', ""); +Expect(0, 8530, '\P{^Is_Numeric_Value=0.333}', ""); +Error('\p{Is_Nv=_+0000001/00003/a/}'); +Error('\P{Is_Nv=_+0000001/00003/a/}'); +Expect(1, 8531, '\p{Is_Nv=+001/3}', ""); +Expect(0, 8531, '\p{^Is_Nv=+001/3}', ""); +Expect(0, 8531, '\P{Is_Nv=+001/3}', ""); +Expect(1, 8531, '\P{^Is_Nv=+001/3}', ""); +Expect(0, 8530, '\p{Is_Nv=+001/3}', ""); +Expect(1, 8530, '\p{^Is_Nv=+001/3}', ""); +Expect(1, 8530, '\P{Is_Nv=+001/3}', ""); +Expect(0, 8530, '\P{^Is_Nv=+001/3}', ""); +Error('\p{Is_Nv=0.3}'); +Error('\P{Is_Nv=0.3}'); +Error('\p{Is_Nv=0.33}'); +Error('\P{Is_Nv=0.33}'); +Expect(1, 8531, '\p{Is_Nv=0.333}', ""); +Expect(0, 8531, '\p{^Is_Nv=0.333}', ""); +Expect(0, 8531, '\P{Is_Nv=0.333}', ""); +Expect(1, 8531, '\P{^Is_Nv=0.333}', ""); +Expect(0, 8530, '\p{Is_Nv=0.333}', ""); +Expect(1, 8530, '\p{^Is_Nv=0.333}', ""); +Expect(1, 8530, '\P{Is_Nv=0.333}', ""); +Expect(0, 8530, '\P{^Is_Nv=0.333}', ""); +Error('\p{Numeric_Value= /a/000002000}'); +Error('\P{Numeric_Value= /a/000002000}'); +Expect(1, 65827, '\p{Numeric_Value=00000002000}', ""); +Expect(0, 65827, '\p{^Numeric_Value=00000002000}', ""); +Expect(0, 65827, '\P{Numeric_Value=00000002000}', ""); +Expect(1, 65827, '\P{^Numeric_Value=00000002000}', ""); +Expect(0, 65826, '\p{Numeric_Value=00000002000}', ""); +Expect(1, 65826, '\p{^Numeric_Value=00000002000}', ""); +Expect(1, 65826, '\P{Numeric_Value=00000002000}', ""); +Expect(0, 65826, '\P{^Numeric_Value=00000002000}', ""); +Error('\p{Nv=:=-+002000}'); +Error('\P{Nv=:=-+002000}'); +Expect(1, 65827, '\p{Nv=00_02_00_0}', ""); +Expect(0, 65827, '\p{^Nv=00_02_00_0}', ""); +Expect(0, 65827, '\P{Nv=00_02_00_0}', ""); +Expect(1, 65827, '\P{^Nv=00_02_00_0}', ""); +Expect(0, 65826, '\p{Nv=00_02_00_0}', ""); +Expect(1, 65826, '\p{^Nv=00_02_00_0}', ""); +Expect(1, 65826, '\P{Nv=00_02_00_0}', ""); +Expect(0, 65826, '\P{^Nv=00_02_00_0}', ""); +Error('\p{Is_Numeric_Value=:=_0002000}'); +Error('\P{Is_Numeric_Value=:=_0002000}'); +Expect(1, 65827, '\p{Is_Numeric_Value=0_2_0_00}', ""); +Expect(0, 65827, '\p{^Is_Numeric_Value=0_2_0_00}', ""); +Expect(0, 65827, '\P{Is_Numeric_Value=0_2_0_00}', ""); +Expect(1, 65827, '\P{^Is_Numeric_Value=0_2_0_00}', ""); +Expect(0, 65826, '\p{Is_Numeric_Value=0_2_0_00}', ""); +Expect(1, 65826, '\p{^Is_Numeric_Value=0_2_0_00}', ""); +Expect(1, 65826, '\P{Is_Numeric_Value=0_2_0_00}', ""); +Expect(0, 65826, '\P{^Is_Numeric_Value=0_2_0_00}', ""); +Error('\p{Is_Nv=-/a/+002000}'); +Error('\P{Is_Nv=-/a/+002000}'); +Expect(1, 65827, '\p{Is_Nv=+0_0_0_0_0_0_0_0_02000}', ""); +Expect(0, 65827, '\p{^Is_Nv=+0_0_0_0_0_0_0_0_02000}', ""); +Expect(0, 65827, '\P{Is_Nv=+0_0_0_0_0_0_0_0_02000}', ""); +Expect(1, 65827, '\P{^Is_Nv=+0_0_0_0_0_0_0_0_02000}', ""); +Expect(0, 65826, '\p{Is_Nv=+0_0_0_0_0_0_0_0_02000}', ""); +Expect(1, 65826, '\p{^Is_Nv=+0_0_0_0_0_0_0_0_02000}', ""); +Expect(1, 65826, '\P{Is_Nv=+0_0_0_0_0_0_0_0_02000}', ""); +Expect(0, 65826, '\P{^Is_Nv=+0_0_0_0_0_0_0_0_02000}', ""); +Error('\p{Numeric_Value= 0 0:=0_0-0 0 00-0 29}'); +Error('\P{Numeric_Value= 0 0:=0_0-0 0 00-0 29}'); +Expect(1, 12889, '\p{Numeric_Value: 0029}', ""); +Expect(0, 12889, '\p{^Numeric_Value: 0029}', ""); +Expect(0, 12889, '\P{Numeric_Value: 0029}', ""); +Expect(1, 12889, '\P{^Numeric_Value: 0029}', ""); +Expect(0, 12888, '\p{Numeric_Value: 0029}', ""); +Expect(1, 12888, '\p{^Numeric_Value: 0029}', ""); +Expect(1, 12888, '\P{Numeric_Value: 0029}', ""); +Expect(0, 12888, '\P{^Numeric_Value: 0029}', ""); +Error('\p{Nv=:=_0000029}'); +Error('\P{Nv=:=_0000029}'); +Expect(1, 12889, '\p{Nv=0_0_0_0_0_0_0_0029}', ""); +Expect(0, 12889, '\p{^Nv=0_0_0_0_0_0_0_0029}', ""); +Expect(0, 12889, '\P{Nv=0_0_0_0_0_0_0_0029}', ""); +Expect(1, 12889, '\P{^Nv=0_0_0_0_0_0_0_0029}', ""); +Expect(0, 12888, '\p{Nv=0_0_0_0_0_0_0_0029}', ""); +Expect(1, 12888, '\p{^Nv=0_0_0_0_0_0_0_0029}', ""); +Expect(1, 12888, '\P{Nv=0_0_0_0_0_0_0_0029}', ""); +Expect(0, 12888, '\P{^Nv=0_0_0_0_0_0_0_0029}', ""); +Error('\p{Is_Numeric_Value=_-+000029/a/}'); +Error('\P{Is_Numeric_Value=_-+000029/a/}'); +Expect(1, 12889, '\p{Is_Numeric_Value=00029}', ""); +Expect(0, 12889, '\p{^Is_Numeric_Value=00029}', ""); +Expect(0, 12889, '\P{Is_Numeric_Value=00029}', ""); +Expect(1, 12889, '\P{^Is_Numeric_Value=00029}', ""); +Expect(0, 12888, '\p{Is_Numeric_Value=00029}', ""); +Expect(1, 12888, '\p{^Is_Numeric_Value=00029}', ""); +Expect(1, 12888, '\P{Is_Numeric_Value=00029}', ""); +Expect(0, 12888, '\P{^Is_Numeric_Value=00029}', ""); +Error('\p{Is_Nv: - +02:=9}'); +Error('\P{Is_Nv: - +02:=9}'); +Expect(1, 12889, '\p{Is_Nv=0029}', ""); +Expect(0, 12889, '\p{^Is_Nv=0029}', ""); +Expect(0, 12889, '\P{Is_Nv=0029}', ""); +Expect(1, 12889, '\P{^Is_Nv=0029}', ""); +Expect(0, 12888, '\p{Is_Nv=0029}', ""); +Expect(1, 12888, '\p{^Is_Nv=0029}', ""); +Expect(1, 12888, '\P{Is_Nv=0029}', ""); +Expect(0, 12888, '\P{^Is_Nv=0029}', ""); +Error('\p{Numeric_Value=/a/- 00000000100000}'); +Error('\P{Numeric_Value=/a/- 00000000100000}'); +Expect(1, 8584, '\p{Numeric_Value=+000000000100000}', ""); +Expect(0, 8584, '\p{^Numeric_Value=+000000000100000}', ""); +Expect(0, 8584, '\P{Numeric_Value=+000000000100000}', ""); +Expect(1, 8584, '\P{^Numeric_Value=+000000000100000}', ""); +Expect(0, 8583, '\p{Numeric_Value=+000000000100000}', ""); +Expect(1, 8583, '\p{^Numeric_Value=+000000000100000}', ""); +Expect(1, 8583, '\P{Numeric_Value=+000000000100000}', ""); +Expect(0, 8583, '\P{^Numeric_Value=+000000000100000}', ""); +Error('\p{Nv=:= 0000010000 0}'); +Error('\P{Nv=:= 0000010000 0}'); +Expect(1, 8584, '\p{Nv: 000000100000}', ""); +Expect(0, 8584, '\p{^Nv: 000000100000}', ""); +Expect(0, 8584, '\P{Nv: 000000100000}', ""); +Expect(1, 8584, '\P{^Nv: 000000100000}', ""); +Expect(0, 8583, '\p{Nv: 000000100000}', ""); +Expect(1, 8583, '\p{^Nv: 000000100000}', ""); +Expect(1, 8583, '\P{Nv: 000000100000}', ""); +Expect(0, 8583, '\P{^Nv: 000000100000}', ""); +Error('\p{Is_Numeric_Value=/a/00000100000}'); +Error('\P{Is_Numeric_Value=/a/00000100000}'); +Expect(1, 8584, '\p{Is_Numeric_Value=0000100000}', ""); +Expect(0, 8584, '\p{^Is_Numeric_Value=0000100000}', ""); +Expect(0, 8584, '\P{Is_Numeric_Value=0000100000}', ""); +Expect(1, 8584, '\P{^Is_Numeric_Value=0000100000}', ""); +Expect(0, 8583, '\p{Is_Numeric_Value=0000100000}', ""); +Expect(1, 8583, '\p{^Is_Numeric_Value=0000100000}', ""); +Expect(1, 8583, '\P{Is_Numeric_Value=0000100000}', ""); +Expect(0, 8583, '\P{^Is_Numeric_Value=0000100000}', ""); +Error('\p{Is_Nv= +0:=0_0 0_00-0_1_00000}'); +Error('\P{Is_Nv= +0:=0_0 0_00-0_1_00000}'); +Expect(1, 8584, '\p{Is_Nv=0000000100000}', ""); +Expect(0, 8584, '\p{^Is_Nv=0000000100000}', ""); +Expect(0, 8584, '\P{Is_Nv=0000000100000}', ""); +Expect(1, 8584, '\P{^Is_Nv=0000000100000}', ""); +Expect(0, 8583, '\p{Is_Nv=0000000100000}', ""); +Expect(1, 8583, '\p{^Is_Nv=0000000100000}', ""); +Expect(1, 8583, '\P{Is_Nv=0000000100000}', ""); +Expect(0, 8583, '\P{^Is_Nv=0000000100000}', ""); +Error('\p{Numeric_Value=:=_ 00000050}'); +Error('\P{Numeric_Value=:=_ 00000050}'); +Expect(1, 4982, '\p{Numeric_Value=+050}', ""); +Expect(0, 4982, '\p{^Numeric_Value=+050}', ""); +Expect(0, 4982, '\P{Numeric_Value=+050}', ""); +Expect(1, 4982, '\P{^Numeric_Value=+050}', ""); +Expect(0, 4981, '\p{Numeric_Value=+050}', ""); +Expect(1, 4981, '\p{^Numeric_Value=+050}', ""); +Expect(1, 4981, '\P{Numeric_Value=+050}', ""); +Expect(0, 4981, '\P{^Numeric_Value=+050}', ""); +Error('\p{Nv=-_0050:=}'); +Error('\P{Nv=-_0050:=}'); +Expect(1, 4982, '\p{Nv=00050}', ""); +Expect(0, 4982, '\p{^Nv=00050}', ""); +Expect(0, 4982, '\P{Nv=00050}', ""); +Expect(1, 4982, '\P{^Nv=00050}', ""); +Expect(0, 4981, '\p{Nv=00050}', ""); +Expect(1, 4981, '\p{^Nv=00050}', ""); +Expect(1, 4981, '\P{Nv=00050}', ""); +Expect(0, 4981, '\P{^Nv=00050}', ""); +Error('\p{Is_Numeric_Value=-_+0:=0-0 0_0 0 00050}'); +Error('\P{Is_Numeric_Value=-_+0:=0-0 0_0 0 00050}'); +Expect(1, 4982, '\p{Is_Numeric_Value=0_0_0_0_0_0_0050}', ""); +Expect(0, 4982, '\p{^Is_Numeric_Value=0_0_0_0_0_0_0050}', ""); +Expect(0, 4982, '\P{Is_Numeric_Value=0_0_0_0_0_0_0050}', ""); +Expect(1, 4982, '\P{^Is_Numeric_Value=0_0_0_0_0_0_0050}', ""); +Expect(0, 4981, '\p{Is_Numeric_Value=0_0_0_0_0_0_0050}', ""); +Expect(1, 4981, '\p{^Is_Numeric_Value=0_0_0_0_0_0_0050}', ""); +Expect(1, 4981, '\P{Is_Numeric_Value=0_0_0_0_0_0_0050}', ""); +Expect(0, 4981, '\P{^Is_Numeric_Value=0_0_0_0_0_0_0050}', ""); +Error('\p{Is_Nv: :=+0000050}'); +Error('\P{Is_Nv: :=+0000050}'); +Expect(1, 4982, '\p{Is_Nv=00_00_00_00_50}', ""); +Expect(0, 4982, '\p{^Is_Nv=00_00_00_00_50}', ""); +Expect(0, 4982, '\P{Is_Nv=00_00_00_00_50}', ""); +Expect(1, 4982, '\P{^Is_Nv=00_00_00_00_50}', ""); +Expect(0, 4981, '\p{Is_Nv=00_00_00_00_50}', ""); +Expect(1, 4981, '\p{^Is_Nv=00_00_00_00_50}', ""); +Expect(1, 4981, '\P{Is_Nv=00_00_00_00_50}', ""); +Expect(0, 4981, '\P{^Is_Nv=00_00_00_00_50}', ""); +Error('\p{Numeric_Value: /a/_ 000000039}'); +Error('\P{Numeric_Value: /a/_ 000000039}'); +Expect(1, 12980, '\p{Numeric_Value=0_0_0_0_0_0_39}', ""); +Expect(0, 12980, '\p{^Numeric_Value=0_0_0_0_0_0_39}', ""); +Expect(0, 12980, '\P{Numeric_Value=0_0_0_0_0_0_39}', ""); +Expect(1, 12980, '\P{^Numeric_Value=0_0_0_0_0_0_39}', ""); +Expect(0, 12979, '\p{Numeric_Value=0_0_0_0_0_0_39}', ""); +Expect(1, 12979, '\p{^Numeric_Value=0_0_0_0_0_0_39}', ""); +Expect(1, 12979, '\P{Numeric_Value=0_0_0_0_0_0_39}', ""); +Expect(0, 12979, '\P{^Numeric_Value=0_0_0_0_0_0_39}', ""); +Error('\p{Nv=- +00000 000039:=}'); +Error('\P{Nv=- +00000 000039:=}'); +Expect(1, 12980, '\p{Nv=039}', ""); +Expect(0, 12980, '\p{^Nv=039}', ""); +Expect(0, 12980, '\P{Nv=039}', ""); +Expect(1, 12980, '\P{^Nv=039}', ""); +Expect(0, 12979, '\p{Nv=039}', ""); +Expect(1, 12979, '\p{^Nv=039}', ""); +Expect(1, 12979, '\P{Nv=039}', ""); +Expect(0, 12979, '\P{^Nv=039}', ""); +Error('\p{Is_Numeric_Value=/a/ 00000039}'); +Error('\P{Is_Numeric_Value=/a/ 00000039}'); +Expect(1, 12980, '\p{Is_Numeric_Value=39}', ""); +Expect(0, 12980, '\p{^Is_Numeric_Value=39}', ""); +Expect(0, 12980, '\P{Is_Numeric_Value=39}', ""); +Expect(1, 12980, '\P{^Is_Numeric_Value=39}', ""); +Expect(0, 12979, '\p{Is_Numeric_Value=39}', ""); +Expect(1, 12979, '\p{^Is_Numeric_Value=39}', ""); +Expect(1, 12979, '\P{Is_Numeric_Value=39}', ""); +Expect(0, 12979, '\P{^Is_Numeric_Value=39}', ""); +Error('\p{Is_Nv=:= +0000000039}'); +Error('\P{Is_Nv=:= +0000000039}'); +Expect(1, 12980, '\p{Is_Nv=039}', ""); +Expect(0, 12980, '\p{^Is_Nv=039}', ""); +Expect(0, 12980, '\P{Is_Nv=039}', ""); +Expect(1, 12980, '\P{^Is_Nv=039}', ""); +Expect(0, 12979, '\p{Is_Nv=039}', ""); +Expect(1, 12979, '\p{^Is_Nv=039}', ""); +Expect(1, 12979, '\P{Is_Nv=039}', ""); +Expect(0, 12979, '\P{^Is_Nv=039}', ""); +Error('\p{Numeric_Value=_/a/0003/002}'); +Error('\P{Numeric_Value=_/a/0003/002}'); +Expect(1, 3883, '\p{Numeric_Value: +0000000003/00002}', ""); +Expect(0, 3883, '\p{^Numeric_Value: +0000000003/00002}', ""); +Expect(0, 3883, '\P{Numeric_Value: +0000000003/00002}', ""); +Expect(1, 3883, '\P{^Numeric_Value: +0000000003/00002}', ""); +Expect(0, 3882, '\p{Numeric_Value: +0000000003/00002}', ""); +Expect(1, 3882, '\p{^Numeric_Value: +0000000003/00002}', ""); +Expect(1, 3882, '\P{Numeric_Value: +0000000003/00002}', ""); +Expect(0, 3882, '\P{^Numeric_Value: +0000000003/00002}', ""); +Expect(1, 3883, '\p{Numeric_Value=1.500}', ""); +Expect(0, 3883, '\p{^Numeric_Value=1.500}', ""); +Expect(0, 3883, '\P{Numeric_Value=1.500}', ""); +Expect(1, 3883, '\P{^Numeric_Value=1.500}', ""); +Expect(0, 3882, '\p{Numeric_Value=1.500}', ""); +Expect(1, 3882, '\p{^Numeric_Value=1.500}', ""); +Expect(1, 3882, '\P{Numeric_Value=1.500}', ""); +Expect(0, 3882, '\P{^Numeric_Value=1.500}', ""); +Error('\p{Nv=_0003/0000000002/a/}'); +Error('\P{Nv=_0003/0000000002/a/}'); +Expect(1, 3883, '\p{Nv:0000003/002}', ""); +Expect(0, 3883, '\p{^Nv:0000003/002}', ""); +Expect(0, 3883, '\P{Nv:0000003/002}', ""); +Expect(1, 3883, '\P{^Nv:0000003/002}', ""); +Expect(0, 3882, '\p{Nv:0000003/002}', ""); +Expect(1, 3882, '\p{^Nv:0000003/002}', ""); +Expect(1, 3882, '\P{Nv:0000003/002}', ""); +Expect(0, 3882, '\P{^Nv:0000003/002}', ""); +Expect(1, 3883, '\p{Nv=1.500}', ""); +Expect(0, 3883, '\p{^Nv=1.500}', ""); +Expect(0, 3883, '\P{Nv=1.500}', ""); +Expect(1, 3883, '\P{^Nv=1.500}', ""); +Expect(0, 3882, '\p{Nv=1.500}', ""); +Expect(1, 3882, '\p{^Nv=1.500}', ""); +Expect(1, 3882, '\P{Nv=1.500}', ""); +Expect(0, 3882, '\P{^Nv=1.500}', ""); +Error('\p{Is_Numeric_Value=/a/ +0000003/2}'); +Error('\P{Is_Numeric_Value=/a/ +0000003/2}'); +Expect(1, 3883, '\p{Is_Numeric_Value=003/002}', ""); +Expect(0, 3883, '\p{^Is_Numeric_Value=003/002}', ""); +Expect(0, 3883, '\P{Is_Numeric_Value=003/002}', ""); +Expect(1, 3883, '\P{^Is_Numeric_Value=003/002}', ""); +Expect(0, 3882, '\p{Is_Numeric_Value=003/002}', ""); +Expect(1, 3882, '\p{^Is_Numeric_Value=003/002}', ""); +Expect(1, 3882, '\P{Is_Numeric_Value=003/002}', ""); +Expect(0, 3882, '\P{^Is_Numeric_Value=003/002}', ""); +Expect(1, 3883, '\p{Is_Numeric_Value:1.500}', ""); +Expect(0, 3883, '\p{^Is_Numeric_Value:1.500}', ""); +Expect(0, 3883, '\P{Is_Numeric_Value:1.500}', ""); +Expect(1, 3883, '\P{^Is_Numeric_Value:1.500}', ""); +Expect(0, 3882, '\p{Is_Numeric_Value:1.500}', ""); +Expect(1, 3882, '\p{^Is_Numeric_Value:1.500}', ""); +Expect(1, 3882, '\P{Is_Numeric_Value:1.500}', ""); +Expect(0, 3882, '\P{^Is_Numeric_Value:1.500}', ""); +Error('\p{Is_Nv=_ 03/00000002:=}'); +Error('\P{Is_Nv=_ 03/00000002:=}'); +Expect(1, 3883, '\p{Is_Nv: 00003/002}', ""); +Expect(0, 3883, '\p{^Is_Nv: 00003/002}', ""); +Expect(0, 3883, '\P{Is_Nv: 00003/002}', ""); +Expect(1, 3883, '\P{^Is_Nv: 00003/002}', ""); +Expect(0, 3882, '\p{Is_Nv: 00003/002}', ""); +Expect(1, 3882, '\p{^Is_Nv: 00003/002}', ""); +Expect(1, 3882, '\P{Is_Nv: 00003/002}', ""); +Expect(0, 3882, '\P{^Is_Nv: 00003/002}', ""); +Expect(1, 3883, '\p{Is_Nv=1.500}', ""); +Expect(0, 3883, '\p{^Is_Nv=1.500}', ""); +Expect(0, 3883, '\P{Is_Nv=1.500}', ""); +Expect(1, 3883, '\P{^Is_Nv=1.500}', ""); +Expect(0, 3882, '\p{Is_Nv=1.500}', ""); +Expect(1, 3882, '\p{^Is_Nv=1.500}', ""); +Expect(1, 3882, '\P{Is_Nv=1.500}', ""); +Expect(0, 3882, '\P{^Is_Nv=1.500}', ""); +Error('\p{Numeric_Value:- +0:=0_0 00 41}'); +Error('\P{Numeric_Value:- +0:=0_0 00 41}'); +Expect(1, 12982, '\p{Numeric_Value=0_0_0_0_0_0_0_0_041}', ""); +Expect(0, 12982, '\p{^Numeric_Value=0_0_0_0_0_0_0_0_041}', ""); +Expect(0, 12982, '\P{Numeric_Value=0_0_0_0_0_0_0_0_041}', ""); +Expect(1, 12982, '\P{^Numeric_Value=0_0_0_0_0_0_0_0_041}', ""); +Expect(0, 12981, '\p{Numeric_Value=0_0_0_0_0_0_0_0_041}', ""); +Expect(1, 12981, '\p{^Numeric_Value=0_0_0_0_0_0_0_0_041}', ""); +Expect(1, 12981, '\P{Numeric_Value=0_0_0_0_0_0_0_0_041}', ""); +Expect(0, 12981, '\P{^Numeric_Value=0_0_0_0_0_0_0_0_041}', ""); +Error('\p{Nv=:=0000041}'); +Error('\P{Nv=:=0000041}'); +Expect(1, 12982, '\p{Nv=0000041}', ""); +Expect(0, 12982, '\p{^Nv=0000041}', ""); +Expect(0, 12982, '\P{Nv=0000041}', ""); +Expect(1, 12982, '\P{^Nv=0000041}', ""); +Expect(0, 12981, '\p{Nv=0000041}', ""); +Expect(1, 12981, '\p{^Nv=0000041}', ""); +Expect(1, 12981, '\P{Nv=0000041}', ""); +Expect(0, 12981, '\P{^Nv=0000041}', ""); +Error('\p{Is_Numeric_Value=-:=+0 0 0 0 041}'); +Error('\P{Is_Numeric_Value=-:=+0 0 0 0 041}'); +Expect(1, 12982, '\p{Is_Numeric_Value=00_00_04_1}', ""); +Expect(0, 12982, '\p{^Is_Numeric_Value=00_00_04_1}', ""); +Expect(0, 12982, '\P{Is_Numeric_Value=00_00_04_1}', ""); +Expect(1, 12982, '\P{^Is_Numeric_Value=00_00_04_1}', ""); +Expect(0, 12981, '\p{Is_Numeric_Value=00_00_04_1}', ""); +Expect(1, 12981, '\p{^Is_Numeric_Value=00_00_04_1}', ""); +Expect(1, 12981, '\P{Is_Numeric_Value=00_00_04_1}', ""); +Expect(0, 12981, '\P{^Is_Numeric_Value=00_00_04_1}', ""); +Error('\p{Is_Nv=-_41:=}'); +Error('\P{Is_Nv=-_41:=}'); +Expect(1, 12982, '\p{Is_Nv=00000041}', ""); +Expect(0, 12982, '\p{^Is_Nv=00000041}', ""); +Expect(0, 12982, '\P{Is_Nv=00000041}', ""); +Expect(1, 12982, '\P{^Is_Nv=00000041}', ""); +Expect(0, 12981, '\p{Is_Nv=00000041}', ""); +Expect(1, 12981, '\p{^Is_Nv=00000041}', ""); +Expect(1, 12981, '\P{Is_Nv=00000041}', ""); +Expect(0, 12981, '\P{^Is_Nv=00000041}', ""); +Error('\p{Numeric_Value=-1/a/2}'); +Error('\P{Numeric_Value=-1/a/2}'); +Expect(1, 8555, '\p{Numeric_Value=0000000012}', ""); +Expect(0, 8555, '\p{^Numeric_Value=0000000012}', ""); +Expect(0, 8555, '\P{Numeric_Value=0000000012}', ""); +Expect(1, 8555, '\P{^Numeric_Value=0000000012}', ""); +Expect(0, 8554, '\p{Numeric_Value=0000000012}', ""); +Expect(1, 8554, '\p{^Numeric_Value=0000000012}', ""); +Expect(1, 8554, '\P{Numeric_Value=0000000012}', ""); +Expect(0, 8554, '\P{^Numeric_Value=0000000012}', ""); +Error('\p{Nv=:=0012}'); +Error('\P{Nv=:=0012}'); +Expect(1, 8555, '\p{Nv: 000000012}', ""); +Expect(0, 8555, '\p{^Nv: 000000012}', ""); +Expect(0, 8555, '\P{Nv: 000000012}', ""); +Expect(1, 8555, '\P{^Nv: 000000012}', ""); +Expect(0, 8554, '\p{Nv: 000000012}', ""); +Expect(1, 8554, '\p{^Nv: 000000012}', ""); +Expect(1, 8554, '\P{Nv: 000000012}', ""); +Expect(0, 8554, '\P{^Nv: 000000012}', ""); +Error('\p{Is_Numeric_Value=:=_+00012}'); +Error('\P{Is_Numeric_Value=:=_+00012}'); +Expect(1, 8555, '\p{Is_Numeric_Value=012}', ""); +Expect(0, 8555, '\p{^Is_Numeric_Value=012}', ""); +Expect(0, 8555, '\P{Is_Numeric_Value=012}', ""); +Expect(1, 8555, '\P{^Is_Numeric_Value=012}', ""); +Expect(0, 8554, '\p{Is_Numeric_Value=012}', ""); +Expect(1, 8554, '\p{^Is_Numeric_Value=012}', ""); +Expect(1, 8554, '\P{Is_Numeric_Value=012}', ""); +Expect(0, 8554, '\P{^Is_Numeric_Value=012}', ""); +Error('\p{Is_Nv= +0000:=01_2}'); +Error('\P{Is_Nv= +0000:=01_2}'); +Expect(1, 8555, '\p{Is_Nv=000000012}', ""); +Expect(0, 8555, '\p{^Is_Nv=000000012}', ""); +Expect(0, 8555, '\P{Is_Nv=000000012}', ""); +Expect(1, 8555, '\P{^Is_Nv=000000012}', ""); +Expect(0, 8554, '\p{Is_Nv=000000012}', ""); +Expect(1, 8554, '\p{^Is_Nv=000000012}', ""); +Expect(1, 8554, '\P{Is_Nv=000000012}', ""); +Expect(0, 8554, '\P{^Is_Nv=000000012}', ""); +Error('\p{Numeric_Value= _000015/a/}'); +Error('\P{Numeric_Value= _000015/a/}'); +Expect(1, 9326, '\p{Numeric_Value=+000000015}', ""); +Expect(0, 9326, '\p{^Numeric_Value=+000000015}', ""); +Expect(0, 9326, '\P{Numeric_Value=+000000015}', ""); +Expect(1, 9326, '\P{^Numeric_Value=+000000015}', ""); +Expect(0, 9325, '\p{Numeric_Value=+000000015}', ""); +Expect(1, 9325, '\p{^Numeric_Value=+000000015}', ""); +Expect(1, 9325, '\P{Numeric_Value=+000000015}', ""); +Expect(0, 9325, '\P{^Numeric_Value=+000000015}', ""); +Error('\p{Nv= +0/a/0 0_00-0 0_0-015}'); +Error('\P{Nv= +0/a/0 0_00-0 0_0-015}'); +Expect(1, 9326, '\p{Nv=+015}', ""); +Expect(0, 9326, '\p{^Nv=+015}', ""); +Expect(0, 9326, '\P{Nv=+015}', ""); +Expect(1, 9326, '\P{^Nv=+015}', ""); +Expect(0, 9325, '\p{Nv=+015}', ""); +Expect(1, 9325, '\p{^Nv=+015}', ""); +Expect(1, 9325, '\P{Nv=+015}', ""); +Expect(0, 9325, '\P{^Nv=+015}', ""); +Error('\p{Is_Numeric_Value= _15/a/}'); +Error('\P{Is_Numeric_Value= _15/a/}'); +Expect(1, 9326, '\p{Is_Numeric_Value: 015}', ""); +Expect(0, 9326, '\p{^Is_Numeric_Value: 015}', ""); +Expect(0, 9326, '\P{Is_Numeric_Value: 015}', ""); +Expect(1, 9326, '\P{^Is_Numeric_Value: 015}', ""); +Expect(0, 9325, '\p{Is_Numeric_Value: 015}', ""); +Expect(1, 9325, '\p{^Is_Numeric_Value: 015}', ""); +Expect(1, 9325, '\P{Is_Numeric_Value: 015}', ""); +Expect(0, 9325, '\P{^Is_Numeric_Value: 015}', ""); +Error('\p{Is_Nv= +000015:=}'); +Error('\P{Is_Nv= +000015:=}'); +Expect(1, 9326, '\p{Is_Nv=00000015}', ""); +Expect(0, 9326, '\p{^Is_Nv=00000015}', ""); +Expect(0, 9326, '\P{Is_Nv=00000015}', ""); +Expect(1, 9326, '\P{^Is_Nv=00000015}', ""); +Expect(0, 9325, '\p{Is_Nv=00000015}', ""); +Expect(1, 9325, '\p{^Is_Nv=00000015}', ""); +Expect(1, 9325, '\P{Is_Nv=00000015}', ""); +Expect(0, 9325, '\P{^Is_Nv=00000015}', ""); +Error('\p{Numeric_Value=/a/-000001/002}'); +Error('\P{Numeric_Value=/a/-000001/002}'); +Expect(1, 3891, '\p{Numeric_Value=-00000001/0000000002}', ""); +Expect(0, 3891, '\p{^Numeric_Value=-00000001/0000000002}', ""); +Expect(0, 3891, '\P{Numeric_Value=-00000001/0000000002}', ""); +Expect(1, 3891, '\P{^Numeric_Value=-00000001/0000000002}', ""); +Expect(0, 3890, '\p{Numeric_Value=-00000001/0000000002}', ""); +Expect(1, 3890, '\p{^Numeric_Value=-00000001/0000000002}', ""); +Expect(1, 3890, '\P{Numeric_Value=-00000001/0000000002}', ""); +Expect(0, 3890, '\P{^Numeric_Value=-00000001/0000000002}', ""); +Expect(1, 3891, '\p{Numeric_Value=-0.500}', ""); +Expect(0, 3891, '\p{^Numeric_Value=-0.500}', ""); +Expect(0, 3891, '\P{Numeric_Value=-0.500}', ""); +Expect(1, 3891, '\P{^Numeric_Value=-0.500}', ""); +Expect(0, 3890, '\p{Numeric_Value=-0.500}', ""); +Expect(1, 3890, '\p{^Numeric_Value=-0.500}', ""); +Expect(1, 3890, '\P{Numeric_Value=-0.500}', ""); +Expect(0, 3890, '\P{^Numeric_Value=-0.500}', ""); +Error('\p{Nv: _000001/00002:=}'); +Error('\P{Nv: _000001/00002:=}'); +Expect(1, 3891, '\p{Nv=-001/00000002}', ""); +Expect(0, 3891, '\p{^Nv=-001/00000002}', ""); +Expect(0, 3891, '\P{Nv=-001/00000002}', ""); +Expect(1, 3891, '\P{^Nv=-001/00000002}', ""); +Expect(0, 3890, '\p{Nv=-001/00000002}', ""); +Expect(1, 3890, '\p{^Nv=-001/00000002}', ""); +Expect(1, 3890, '\P{Nv=-001/00000002}', ""); +Expect(0, 3890, '\P{^Nv=-001/00000002}', ""); +Expect(1, 3891, '\p{Nv=-0.500}', ""); +Expect(0, 3891, '\p{^Nv=-0.500}', ""); +Expect(0, 3891, '\P{Nv=-0.500}', ""); +Expect(1, 3891, '\P{^Nv=-0.500}', ""); +Expect(0, 3890, '\p{Nv=-0.500}', ""); +Expect(1, 3890, '\p{^Nv=-0.500}', ""); +Expect(1, 3890, '\P{Nv=-0.500}', ""); +Expect(0, 3890, '\P{^Nv=-0.500}', ""); +Error('\p{Is_Numeric_Value=:=_00000001/00002}'); +Error('\P{Is_Numeric_Value=:=_00000001/00002}'); +Expect(1, 3891, '\p{Is_Numeric_Value=-000001/0002}', ""); +Expect(0, 3891, '\p{^Is_Numeric_Value=-000001/0002}', ""); +Expect(0, 3891, '\P{Is_Numeric_Value=-000001/0002}', ""); +Expect(1, 3891, '\P{^Is_Numeric_Value=-000001/0002}', ""); +Expect(0, 3890, '\p{Is_Numeric_Value=-000001/0002}', ""); +Expect(1, 3890, '\p{^Is_Numeric_Value=-000001/0002}', ""); +Expect(1, 3890, '\P{Is_Numeric_Value=-000001/0002}', ""); +Expect(0, 3890, '\P{^Is_Numeric_Value=-000001/0002}', ""); +Expect(1, 3891, '\p{Is_Numeric_Value=-0.500}', ""); +Expect(0, 3891, '\p{^Is_Numeric_Value=-0.500}', ""); +Expect(0, 3891, '\P{Is_Numeric_Value=-0.500}', ""); +Expect(1, 3891, '\P{^Is_Numeric_Value=-0.500}', ""); +Expect(0, 3890, '\p{Is_Numeric_Value=-0.500}', ""); +Expect(1, 3890, '\p{^Is_Numeric_Value=-0.500}', ""); +Expect(1, 3890, '\P{Is_Numeric_Value=-0.500}', ""); +Expect(0, 3890, '\P{^Is_Numeric_Value=-0.500}', ""); +Error('\p{Is_Nv=_:= 0001/0002}'); +Error('\P{Is_Nv=_:= 0001/0002}'); +Expect(1, 3891, '\p{Is_Nv=-0000001/000000002}', ""); +Expect(0, 3891, '\p{^Is_Nv=-0000001/000000002}', ""); +Expect(0, 3891, '\P{Is_Nv=-0000001/000000002}', ""); +Expect(1, 3891, '\P{^Is_Nv=-0000001/000000002}', ""); +Expect(0, 3890, '\p{Is_Nv=-0000001/000000002}', ""); +Expect(1, 3890, '\p{^Is_Nv=-0000001/000000002}', ""); +Expect(1, 3890, '\P{Is_Nv=-0000001/000000002}', ""); +Expect(0, 3890, '\P{^Is_Nv=-0000001/000000002}', ""); +Expect(1, 3891, '\p{Is_Nv=-0.500}', ""); +Expect(0, 3891, '\p{^Is_Nv=-0.500}', ""); +Expect(0, 3891, '\P{Is_Nv=-0.500}', ""); +Expect(1, 3891, '\P{^Is_Nv=-0.500}', ""); +Expect(0, 3890, '\p{Is_Nv=-0.500}', ""); +Expect(1, 3890, '\p{^Is_Nv=-0.500}', ""); +Expect(1, 3890, '\P{Is_Nv=-0.500}', ""); +Expect(0, 3890, '\P{^Is_Nv=-0.500}', ""); +Error('\p{Numeric_Value:_/a/0000000080000}'); +Error('\P{Numeric_Value:_/a/0000000080000}'); +Expect(1, 65842, '\p{Numeric_Value=+00000000080000}', ""); +Expect(0, 65842, '\p{^Numeric_Value=+00000000080000}', ""); +Expect(0, 65842, '\P{Numeric_Value=+00000000080000}', ""); +Expect(1, 65842, '\P{^Numeric_Value=+00000000080000}', ""); +Expect(0, 65841, '\p{Numeric_Value=+00000000080000}', ""); +Expect(1, 65841, '\p{^Numeric_Value=+00000000080000}', ""); +Expect(1, 65841, '\P{Numeric_Value=+00000000080000}', ""); +Expect(0, 65841, '\P{^Numeric_Value=+00000000080000}', ""); +Error('\p{Nv= /a/00000080000}'); +Error('\P{Nv= /a/00000080000}'); +Expect(1, 65842, '\p{Nv: 0_0_0_8_0_0_00}', ""); +Expect(0, 65842, '\p{^Nv: 0_0_0_8_0_0_00}', ""); +Expect(0, 65842, '\P{Nv: 0_0_0_8_0_0_00}', ""); +Expect(1, 65842, '\P{^Nv: 0_0_0_8_0_0_00}', ""); +Expect(0, 65841, '\p{Nv: 0_0_0_8_0_0_00}', ""); +Expect(1, 65841, '\p{^Nv: 0_0_0_8_0_0_00}', ""); +Expect(1, 65841, '\P{Nv: 0_0_0_8_0_0_00}', ""); +Expect(0, 65841, '\P{^Nv: 0_0_0_8_0_0_00}', ""); +Error('\p{Is_Numeric_Value=_ +00000080000/a/}'); +Error('\P{Is_Numeric_Value=_ +00000080000/a/}'); +Expect(1, 65842, '\p{Is_Numeric_Value:+00080000}', ""); +Expect(0, 65842, '\p{^Is_Numeric_Value:+00080000}', ""); +Expect(0, 65842, '\P{Is_Numeric_Value:+00080000}', ""); +Expect(1, 65842, '\P{^Is_Numeric_Value:+00080000}', ""); +Expect(0, 65841, '\p{Is_Numeric_Value:+00080000}', ""); +Expect(1, 65841, '\p{^Is_Numeric_Value:+00080000}', ""); +Expect(1, 65841, '\P{Is_Numeric_Value:+00080000}', ""); +Expect(0, 65841, '\P{^Is_Numeric_Value:+00080000}', ""); +Error('\p{Is_Nv=_ 00 0_0_0-0 0_0:=8-0_000}'); +Error('\P{Is_Nv=_ 00 0_0_0-0 0_0:=8-0_000}'); +Expect(1, 65842, '\p{Is_Nv=0000080000}', ""); +Expect(0, 65842, '\p{^Is_Nv=0000080000}', ""); +Expect(0, 65842, '\P{Is_Nv=0000080000}', ""); +Expect(1, 65842, '\P{^Is_Nv=0000080000}', ""); +Expect(0, 65841, '\p{Is_Nv=0000080000}', ""); +Expect(1, 65841, '\p{^Is_Nv=0000080000}', ""); +Expect(1, 65841, '\P{Is_Nv=0000080000}', ""); +Expect(0, 65841, '\P{^Is_Nv=0000080000}', ""); +Error('\p{Numeric_Value= /a/0_060}'); +Error('\P{Numeric_Value= /a/0_060}'); +Expect(1, 4983, '\p{Numeric_Value=+00_06_0}', ""); +Expect(0, 4983, '\p{^Numeric_Value=+00_06_0}', ""); +Expect(0, 4983, '\P{Numeric_Value=+00_06_0}', ""); +Expect(1, 4983, '\P{^Numeric_Value=+00_06_0}', ""); +Expect(0, 4982, '\p{Numeric_Value=+00_06_0}', ""); +Expect(1, 4982, '\p{^Numeric_Value=+00_06_0}', ""); +Expect(1, 4982, '\P{Numeric_Value=+00_06_0}', ""); +Expect(0, 4982, '\P{^Numeric_Value=+00_06_0}', ""); +Error('\p{Nv=-:=0_0_00 0-60}'); +Error('\P{Nv=-:=0_0_00 0-60}'); +Expect(1, 4983, '\p{Nv=0_0_0_060}', ""); +Expect(0, 4983, '\p{^Nv=0_0_0_060}', ""); +Expect(0, 4983, '\P{Nv=0_0_0_060}', ""); +Expect(1, 4983, '\P{^Nv=0_0_0_060}', ""); +Expect(0, 4982, '\p{Nv=0_0_0_060}', ""); +Expect(1, 4982, '\p{^Nv=0_0_0_060}', ""); +Expect(1, 4982, '\P{Nv=0_0_0_060}', ""); +Expect(0, 4982, '\P{^Nv=0_0_0_060}', ""); +Error('\p{Is_Numeric_Value=_+06-0:=}'); +Error('\P{Is_Numeric_Value=_+06-0:=}'); +Expect(1, 4983, '\p{Is_Numeric_Value=0000000060}', ""); +Expect(0, 4983, '\p{^Is_Numeric_Value=0000000060}', ""); +Expect(0, 4983, '\P{Is_Numeric_Value=0000000060}', ""); +Expect(1, 4983, '\P{^Is_Numeric_Value=0000000060}', ""); +Expect(0, 4982, '\p{Is_Numeric_Value=0000000060}', ""); +Expect(1, 4982, '\p{^Is_Numeric_Value=0000000060}', ""); +Expect(1, 4982, '\P{Is_Numeric_Value=0000000060}', ""); +Expect(0, 4982, '\P{^Is_Numeric_Value=0000000060}', ""); +Error('\p{Is_Nv=- 060:=}'); +Error('\P{Is_Nv=- 060:=}'); +Expect(1, 4983, '\p{Is_Nv=000060}', ""); +Expect(0, 4983, '\p{^Is_Nv=000060}', ""); +Expect(0, 4983, '\P{Is_Nv=000060}', ""); +Expect(1, 4983, '\P{^Is_Nv=000060}', ""); +Expect(0, 4982, '\p{Is_Nv=000060}', ""); +Expect(1, 4982, '\p{^Is_Nv=000060}', ""); +Expect(1, 4982, '\P{Is_Nv=000060}', ""); +Expect(0, 4982, '\P{^Is_Nv=000060}', ""); +Error('\p{Numeric_Value=_/a/00004 5}'); +Error('\P{Numeric_Value=_/a/00004 5}'); +Expect(1, 12986, '\p{Numeric_Value=000045}', ""); +Expect(0, 12986, '\p{^Numeric_Value=000045}', ""); +Expect(0, 12986, '\P{Numeric_Value=000045}', ""); +Expect(1, 12986, '\P{^Numeric_Value=000045}', ""); +Expect(0, 12985, '\p{Numeric_Value=000045}', ""); +Expect(1, 12985, '\p{^Numeric_Value=000045}', ""); +Expect(1, 12985, '\P{Numeric_Value=000045}', ""); +Expect(0, 12985, '\P{^Numeric_Value=000045}', ""); +Error('\p{Nv= /a/+4 5}'); +Error('\P{Nv= /a/+4 5}'); +Expect(1, 12986, '\p{Nv=00000045}', ""); +Expect(0, 12986, '\p{^Nv=00000045}', ""); +Expect(0, 12986, '\P{Nv=00000045}', ""); +Expect(1, 12986, '\P{^Nv=00000045}', ""); +Expect(0, 12985, '\p{Nv=00000045}', ""); +Expect(1, 12985, '\p{^Nv=00000045}', ""); +Expect(1, 12985, '\P{Nv=00000045}', ""); +Expect(0, 12985, '\P{^Nv=00000045}', ""); +Error('\p{Is_Numeric_Value=:=0000045}'); +Error('\P{Is_Numeric_Value=:=0000045}'); +Expect(1, 12986, '\p{Is_Numeric_Value=0045}', ""); +Expect(0, 12986, '\p{^Is_Numeric_Value=0045}', ""); +Expect(0, 12986, '\P{Is_Numeric_Value=0045}', ""); +Expect(1, 12986, '\P{^Is_Numeric_Value=0045}', ""); +Expect(0, 12985, '\p{Is_Numeric_Value=0045}', ""); +Expect(1, 12985, '\p{^Is_Numeric_Value=0045}', ""); +Expect(1, 12985, '\P{Is_Numeric_Value=0045}', ""); +Expect(0, 12985, '\P{^Is_Numeric_Value=0045}', ""); +Error('\p{Is_Nv=_:=00000000045}'); +Error('\P{Is_Nv=_:=00000000045}'); +Expect(1, 12986, '\p{Is_Nv:+0_0_0_0_0_0_0045}', ""); +Expect(0, 12986, '\p{^Is_Nv:+0_0_0_0_0_0_0045}', ""); +Expect(0, 12986, '\P{Is_Nv:+0_0_0_0_0_0_0045}', ""); +Expect(1, 12986, '\P{^Is_Nv:+0_0_0_0_0_0_0045}', ""); +Expect(0, 12985, '\p{Is_Nv:+0_0_0_0_0_0_0045}', ""); +Expect(1, 12985, '\p{^Is_Nv:+0_0_0_0_0_0_0045}', ""); +Expect(1, 12985, '\P{Is_Nv:+0_0_0_0_0_0_0045}', ""); +Expect(0, 12985, '\P{^Is_Nv:+0_0_0_0_0_0_0045}', ""); +Error('\p{Numeric_Value=--00000001_9/a/}'); +Error('\P{Numeric_Value=--00000001_9/a/}'); +Expect(1, 5872, '\p{Numeric_Value=+1_9}', ""); +Expect(0, 5872, '\p{^Numeric_Value=+1_9}', ""); +Expect(0, 5872, '\P{Numeric_Value=+1_9}', ""); +Expect(1, 5872, '\P{^Numeric_Value=+1_9}', ""); +Expect(0, 5871, '\p{Numeric_Value=+1_9}', ""); +Expect(1, 5871, '\p{^Numeric_Value=+1_9}', ""); +Expect(1, 5871, '\P{Numeric_Value=+1_9}', ""); +Expect(0, 5871, '\P{^Numeric_Value=+1_9}', ""); +Error('\p{Nv= -0000019/a/}'); +Error('\P{Nv= -0000019/a/}'); +Expect(1, 5872, '\p{Nv=00_00_00_01_9}', ""); +Expect(0, 5872, '\p{^Nv=00_00_00_01_9}', ""); +Expect(0, 5872, '\P{Nv=00_00_00_01_9}', ""); +Expect(1, 5872, '\P{^Nv=00_00_00_01_9}', ""); +Expect(0, 5871, '\p{Nv=00_00_00_01_9}', ""); +Expect(1, 5871, '\p{^Nv=00_00_00_01_9}', ""); +Expect(1, 5871, '\P{Nv=00_00_00_01_9}', ""); +Expect(0, 5871, '\P{^Nv=00_00_00_01_9}', ""); +Error('\p{Is_Numeric_Value= 000-000:=00019}'); +Error('\P{Is_Numeric_Value= 000-000:=00019}'); +Expect(1, 5872, '\p{Is_Numeric_Value=0019}', ""); +Expect(0, 5872, '\p{^Is_Numeric_Value=0019}', ""); +Expect(0, 5872, '\P{Is_Numeric_Value=0019}', ""); +Expect(1, 5872, '\P{^Is_Numeric_Value=0019}', ""); +Expect(0, 5871, '\p{Is_Numeric_Value=0019}', ""); +Expect(1, 5871, '\p{^Is_Numeric_Value=0019}', ""); +Expect(1, 5871, '\P{Is_Numeric_Value=0019}', ""); +Expect(0, 5871, '\P{^Is_Numeric_Value=0019}', ""); +Error('\p{Is_Nv: _-+1_9:=}'); +Error('\P{Is_Nv: _-+1_9:=}'); +Expect(1, 5872, '\p{Is_Nv=001_9}', ""); +Expect(0, 5872, '\p{^Is_Nv=001_9}', ""); +Expect(0, 5872, '\P{Is_Nv=001_9}', ""); +Expect(1, 5872, '\P{^Is_Nv=001_9}', ""); +Expect(0, 5871, '\p{Is_Nv=001_9}', ""); +Expect(1, 5871, '\p{^Is_Nv=001_9}', ""); +Expect(1, 5871, '\P{Is_Nv=001_9}', ""); +Expect(0, 5871, '\P{^Is_Nv=001_9}', ""); +Error('\p{Numeric_Value= 11/002:=}'); +Error('\P{Numeric_Value= 11/002:=}'); +Expect(1, 3887, '\p{Numeric_Value: 00000011/002}', ""); +Expect(0, 3887, '\p{^Numeric_Value: 00000011/002}', ""); +Expect(0, 3887, '\P{Numeric_Value: 00000011/002}', ""); +Expect(1, 3887, '\P{^Numeric_Value: 00000011/002}', ""); +Expect(0, 3886, '\p{Numeric_Value: 00000011/002}', ""); +Expect(1, 3886, '\p{^Numeric_Value: 00000011/002}', ""); +Expect(1, 3886, '\P{Numeric_Value: 00000011/002}', ""); +Expect(0, 3886, '\P{^Numeric_Value: 00000011/002}', ""); +Expect(1, 3887, '\p{Numeric_Value=5.500}', ""); +Expect(0, 3887, '\p{^Numeric_Value=5.500}', ""); +Expect(0, 3887, '\P{Numeric_Value=5.500}', ""); +Expect(1, 3887, '\P{^Numeric_Value=5.500}', ""); +Expect(0, 3886, '\p{Numeric_Value=5.500}', ""); +Expect(1, 3886, '\p{^Numeric_Value=5.500}', ""); +Expect(1, 3886, '\P{Numeric_Value=5.500}', ""); +Expect(0, 3886, '\P{^Numeric_Value=5.500}', ""); +Error('\p{Nv=/a/ _0000000011/002}'); +Error('\P{Nv=/a/ _0000000011/002}'); +Expect(1, 3887, '\p{Nv=+00000000011/000000002}', ""); +Expect(0, 3887, '\p{^Nv=+00000000011/000000002}', ""); +Expect(0, 3887, '\P{Nv=+00000000011/000000002}', ""); +Expect(1, 3887, '\P{^Nv=+00000000011/000000002}', ""); +Expect(0, 3886, '\p{Nv=+00000000011/000000002}', ""); +Expect(1, 3886, '\p{^Nv=+00000000011/000000002}', ""); +Expect(1, 3886, '\P{Nv=+00000000011/000000002}', ""); +Expect(0, 3886, '\P{^Nv=+00000000011/000000002}', ""); +Expect(1, 3887, '\p{Nv=5.500}', ""); +Expect(0, 3887, '\p{^Nv=5.500}', ""); +Expect(0, 3887, '\P{Nv=5.500}', ""); +Expect(1, 3887, '\P{^Nv=5.500}', ""); +Expect(0, 3886, '\p{Nv=5.500}', ""); +Expect(1, 3886, '\p{^Nv=5.500}', ""); +Expect(1, 3886, '\P{Nv=5.500}', ""); +Expect(0, 3886, '\P{^Nv=5.500}', ""); +Error('\p{Is_Numeric_Value=/a/+00011/00002}'); +Error('\P{Is_Numeric_Value=/a/+00011/00002}'); +Expect(1, 3887, '\p{Is_Numeric_Value: 00000011/00002}', ""); +Expect(0, 3887, '\p{^Is_Numeric_Value: 00000011/00002}', ""); +Expect(0, 3887, '\P{Is_Numeric_Value: 00000011/00002}', ""); +Expect(1, 3887, '\P{^Is_Numeric_Value: 00000011/00002}', ""); +Expect(0, 3886, '\p{Is_Numeric_Value: 00000011/00002}', ""); +Expect(1, 3886, '\p{^Is_Numeric_Value: 00000011/00002}', ""); +Expect(1, 3886, '\P{Is_Numeric_Value: 00000011/00002}', ""); +Expect(0, 3886, '\P{^Is_Numeric_Value: 00000011/00002}', ""); +Expect(1, 3887, '\p{Is_Numeric_Value=5.500}', ""); +Expect(0, 3887, '\p{^Is_Numeric_Value=5.500}', ""); +Expect(0, 3887, '\P{Is_Numeric_Value=5.500}', ""); +Expect(1, 3887, '\P{^Is_Numeric_Value=5.500}', ""); +Expect(0, 3886, '\p{Is_Numeric_Value=5.500}', ""); +Expect(1, 3886, '\p{^Is_Numeric_Value=5.500}', ""); +Expect(1, 3886, '\P{Is_Numeric_Value=5.500}', ""); +Expect(0, 3886, '\P{^Is_Numeric_Value=5.500}', ""); +Error('\p{Is_Nv=-:=11/0002}'); +Error('\P{Is_Nv=-:=11/0002}'); +Expect(1, 3887, '\p{Is_Nv:00000011/000002}', ""); +Expect(0, 3887, '\p{^Is_Nv:00000011/000002}', ""); +Expect(0, 3887, '\P{Is_Nv:00000011/000002}', ""); +Expect(1, 3887, '\P{^Is_Nv:00000011/000002}', ""); +Expect(0, 3886, '\p{Is_Nv:00000011/000002}', ""); +Expect(1, 3886, '\p{^Is_Nv:00000011/000002}', ""); +Expect(1, 3886, '\P{Is_Nv:00000011/000002}', ""); +Expect(0, 3886, '\P{^Is_Nv:00000011/000002}', ""); +Expect(1, 3887, '\p{Is_Nv=5.500}', ""); +Expect(0, 3887, '\p{^Is_Nv=5.500}', ""); +Expect(0, 3887, '\P{Is_Nv=5.500}', ""); +Expect(1, 3887, '\P{^Is_Nv=5.500}', ""); +Expect(0, 3886, '\p{Is_Nv=5.500}', ""); +Expect(1, 3886, '\p{^Is_Nv=5.500}', ""); +Expect(1, 3886, '\P{Is_Nv=5.500}', ""); +Expect(0, 3886, '\P{^Is_Nv=5.500}', ""); +Error('\p{Numeric_Value= 0_0/a/0_0 70}'); +Error('\P{Numeric_Value= 0_0/a/0_0 70}'); +Expect(1, 4984, '\p{Numeric_Value=+0_0_0_0_0_0_0_070}', ""); +Expect(0, 4984, '\p{^Numeric_Value=+0_0_0_0_0_0_0_070}', ""); +Expect(0, 4984, '\P{Numeric_Value=+0_0_0_0_0_0_0_070}', ""); +Expect(1, 4984, '\P{^Numeric_Value=+0_0_0_0_0_0_0_070}', ""); +Expect(0, 4983, '\p{Numeric_Value=+0_0_0_0_0_0_0_070}', ""); +Expect(1, 4983, '\p{^Numeric_Value=+0_0_0_0_0_0_0_070}', ""); +Expect(1, 4983, '\P{Numeric_Value=+0_0_0_0_0_0_0_070}', ""); +Expect(0, 4983, '\P{^Numeric_Value=+0_0_0_0_0_0_0_070}', ""); +Error('\p{Nv= :=0000070}'); +Error('\P{Nv= :=0000070}'); +Expect(1, 4984, '\p{Nv=+00_00_70}', ""); +Expect(0, 4984, '\p{^Nv=+00_00_70}', ""); +Expect(0, 4984, '\P{Nv=+00_00_70}', ""); +Expect(1, 4984, '\P{^Nv=+00_00_70}', ""); +Expect(0, 4983, '\p{Nv=+00_00_70}', ""); +Expect(1, 4983, '\p{^Nv=+00_00_70}', ""); +Expect(1, 4983, '\P{Nv=+00_00_70}', ""); +Expect(0, 4983, '\P{^Nv=+00_00_70}', ""); +Error('\p{Is_Numeric_Value=-/a/7 0}'); +Error('\P{Is_Numeric_Value=-/a/7 0}'); +Expect(1, 4984, '\p{Is_Numeric_Value=0070}', ""); +Expect(0, 4984, '\p{^Is_Numeric_Value=0070}', ""); +Expect(0, 4984, '\P{Is_Numeric_Value=0070}', ""); +Expect(1, 4984, '\P{^Is_Numeric_Value=0070}', ""); +Expect(0, 4983, '\p{Is_Numeric_Value=0070}', ""); +Expect(1, 4983, '\p{^Is_Numeric_Value=0070}', ""); +Expect(1, 4983, '\P{Is_Numeric_Value=0070}', ""); +Expect(0, 4983, '\P{^Is_Numeric_Value=0070}', ""); +Error('\p{Is_Nv=-+00000007-0:=}'); +Error('\P{Is_Nv=-+00000007-0:=}'); +Expect(1, 4984, '\p{Is_Nv=+0_0_70}', ""); +Expect(0, 4984, '\p{^Is_Nv=+0_0_70}', ""); +Expect(0, 4984, '\P{Is_Nv=+0_0_70}', ""); +Expect(1, 4984, '\P{^Is_Nv=+0_0_70}', ""); +Expect(0, 4983, '\p{Is_Nv=+0_0_70}', ""); +Expect(1, 4983, '\p{^Is_Nv=+0_0_70}', ""); +Expect(1, 4983, '\P{Is_Nv=+0_0_70}', ""); +Expect(0, 4983, '\P{^Is_Nv=+0_0_70}', ""); +Error('\p{Numeric_Value= 0/a/0 0-0-0-002}'); +Error('\P{Numeric_Value= 0/a/0 0-0-0-002}'); +Expect(1, 50, '\p{Numeric_Value=2}', ""); +Expect(0, 50, '\p{^Numeric_Value=2}', ""); +Expect(0, 50, '\P{Numeric_Value=2}', ""); +Expect(1, 50, '\P{^Numeric_Value=2}', ""); +Expect(0, 49, '\p{Numeric_Value=2}', ""); +Expect(1, 49, '\p{^Numeric_Value=2}', ""); +Expect(1, 49, '\P{Numeric_Value=2}', ""); +Expect(0, 49, '\P{^Numeric_Value=2}', ""); +Error('\p{Nv= _0:=0 02}'); +Error('\P{Nv= _0:=0 02}'); +Expect(1, 50, '\p{Nv=0002}', ""); +Expect(0, 50, '\p{^Nv=0002}', ""); +Expect(0, 50, '\P{Nv=0002}', ""); +Expect(1, 50, '\P{^Nv=0002}', ""); +Expect(0, 49, '\p{Nv=0002}', ""); +Expect(1, 49, '\p{^Nv=0002}', ""); +Expect(1, 49, '\P{Nv=0002}', ""); +Expect(0, 49, '\P{^Nv=0002}', ""); +Error('\p{Is_Numeric_Value= 00 2:=}'); +Error('\P{Is_Numeric_Value= 00 2:=}'); +Expect(1, 50, '\p{Is_Numeric_Value=+0_0_0_0_0_0_0002}', ""); +Expect(0, 50, '\p{^Is_Numeric_Value=+0_0_0_0_0_0_0002}', ""); +Expect(0, 50, '\P{Is_Numeric_Value=+0_0_0_0_0_0_0002}', ""); +Expect(1, 50, '\P{^Is_Numeric_Value=+0_0_0_0_0_0_0002}', ""); +Expect(0, 49, '\p{Is_Numeric_Value=+0_0_0_0_0_0_0002}', ""); +Expect(1, 49, '\p{^Is_Numeric_Value=+0_0_0_0_0_0_0002}', ""); +Expect(1, 49, '\P{Is_Numeric_Value=+0_0_0_0_0_0_0002}', ""); +Expect(0, 49, '\P{^Is_Numeric_Value=+0_0_0_0_0_0_0002}', ""); +Error('\p{Is_Nv: :=- 0000002}'); +Error('\P{Is_Nv: :=- 0000002}'); +Expect(1, 50, '\p{Is_Nv=00_00_00_02}', ""); +Expect(0, 50, '\p{^Is_Nv=00_00_00_02}', ""); +Expect(0, 50, '\P{Is_Nv=00_00_00_02}', ""); +Expect(1, 50, '\P{^Is_Nv=00_00_00_02}', ""); +Expect(0, 49, '\p{Is_Nv=00_00_00_02}', ""); +Expect(1, 49, '\p{^Is_Nv=00_00_00_02}', ""); +Expect(1, 49, '\P{Is_Nv=00_00_00_02}', ""); +Expect(0, 49, '\P{^Is_Nv=00_00_00_02}', ""); +Error('\p{Numeric_Value= :=+000000017}'); +Error('\P{Numeric_Value= :=+000000017}'); +Expect(1, 5870, '\p{Numeric_Value: 0017}', ""); +Expect(0, 5870, '\p{^Numeric_Value: 0017}', ""); +Expect(0, 5870, '\P{Numeric_Value: 0017}', ""); +Expect(1, 5870, '\P{^Numeric_Value: 0017}', ""); +Expect(0, 5869, '\p{Numeric_Value: 0017}', ""); +Expect(1, 5869, '\p{^Numeric_Value: 0017}', ""); +Expect(1, 5869, '\P{Numeric_Value: 0017}', ""); +Expect(0, 5869, '\P{^Numeric_Value: 0017}', ""); +Error('\p{Nv: :=000017}'); +Error('\P{Nv: :=000017}'); +Expect(1, 5870, '\p{Nv=00000017}', ""); +Expect(0, 5870, '\p{^Nv=00000017}', ""); +Expect(0, 5870, '\P{Nv=00000017}', ""); +Expect(1, 5870, '\P{^Nv=00000017}', ""); +Expect(0, 5869, '\p{Nv=00000017}', ""); +Expect(1, 5869, '\p{^Nv=00000017}', ""); +Expect(1, 5869, '\P{Nv=00000017}', ""); +Expect(0, 5869, '\P{^Nv=00000017}', ""); +Error('\p{Is_Numeric_Value=-/a/00017}'); +Error('\P{Is_Numeric_Value=-/a/00017}'); +Expect(1, 5870, '\p{Is_Numeric_Value=00000000017}', ""); +Expect(0, 5870, '\p{^Is_Numeric_Value=00000000017}', ""); +Expect(0, 5870, '\P{Is_Numeric_Value=00000000017}', ""); +Expect(1, 5870, '\P{^Is_Numeric_Value=00000000017}', ""); +Expect(0, 5869, '\p{Is_Numeric_Value=00000000017}', ""); +Expect(1, 5869, '\p{^Is_Numeric_Value=00000000017}', ""); +Expect(1, 5869, '\P{Is_Numeric_Value=00000000017}', ""); +Expect(0, 5869, '\P{^Is_Numeric_Value=00000000017}', ""); +Error('\p{Is_Nv: /a/0000001-7}'); +Error('\P{Is_Nv: /a/0000001-7}'); +Expect(1, 5870, '\p{Is_Nv=+00017}', ""); +Expect(0, 5870, '\p{^Is_Nv=+00017}', ""); +Expect(0, 5870, '\P{Is_Nv=+00017}', ""); +Expect(1, 5870, '\P{^Is_Nv=+00017}', ""); +Expect(0, 5869, '\p{Is_Nv=+00017}', ""); +Expect(1, 5869, '\p{^Is_Nv=+00017}', ""); +Expect(1, 5869, '\P{Is_Nv=+00017}', ""); +Expect(0, 5869, '\P{^Is_Nv=+00017}', ""); +Error('\p{Numeric_Value= /a/0 0_0_00-0-00020000}'); +Error('\P{Numeric_Value= /a/0 0_0_00-0-00020000}'); +Expect(1, 65836, '\p{Numeric_Value=0_0_2_0_0_00}', ""); +Expect(0, 65836, '\p{^Numeric_Value=0_0_2_0_0_00}', ""); +Expect(0, 65836, '\P{Numeric_Value=0_0_2_0_0_00}', ""); +Expect(1, 65836, '\P{^Numeric_Value=0_0_2_0_0_00}', ""); +Expect(0, 65835, '\p{Numeric_Value=0_0_2_0_0_00}', ""); +Expect(1, 65835, '\p{^Numeric_Value=0_0_2_0_0_00}', ""); +Expect(1, 65835, '\P{Numeric_Value=0_0_2_0_0_00}', ""); +Expect(0, 65835, '\P{^Numeric_Value=0_0_2_0_0_00}', ""); +Error('\p{Nv=/a/-_00020000}'); +Error('\P{Nv=/a/-_00020000}'); +Expect(1, 65836, '\p{Nv=0_0_0_0_0_0_0_0_0_2_0_0_00}', ""); +Expect(0, 65836, '\p{^Nv=0_0_0_0_0_0_0_0_0_2_0_0_00}', ""); +Expect(0, 65836, '\P{Nv=0_0_0_0_0_0_0_0_0_2_0_0_00}', ""); +Expect(1, 65836, '\P{^Nv=0_0_0_0_0_0_0_0_0_2_0_0_00}', ""); +Expect(0, 65835, '\p{Nv=0_0_0_0_0_0_0_0_0_2_0_0_00}', ""); +Expect(1, 65835, '\p{^Nv=0_0_0_0_0_0_0_0_0_2_0_0_00}', ""); +Expect(1, 65835, '\P{Nv=0_0_0_0_0_0_0_0_0_2_0_0_00}', ""); +Expect(0, 65835, '\P{^Nv=0_0_0_0_0_0_0_0_0_2_0_0_00}', ""); +Error('\p{Is_Numeric_Value=__+00:=00 20000}'); +Error('\P{Is_Numeric_Value=__+00:=00 20000}'); +Expect(1, 65836, '\p{Is_Numeric_Value=0020000}', ""); +Expect(0, 65836, '\p{^Is_Numeric_Value=0020000}', ""); +Expect(0, 65836, '\P{Is_Numeric_Value=0020000}', ""); +Expect(1, 65836, '\P{^Is_Numeric_Value=0020000}', ""); +Expect(0, 65835, '\p{Is_Numeric_Value=0020000}', ""); +Expect(1, 65835, '\p{^Is_Numeric_Value=0020000}', ""); +Expect(1, 65835, '\P{Is_Numeric_Value=0020000}', ""); +Expect(0, 65835, '\P{^Is_Numeric_Value=0020000}', ""); +Error('\p{Is_Nv:/a/ 00020000}'); +Error('\P{Is_Nv:/a/ 00020000}'); +Expect(1, 65836, '\p{Is_Nv=00_00_20_00_0}', ""); +Expect(0, 65836, '\p{^Is_Nv=00_00_20_00_0}', ""); +Expect(0, 65836, '\P{Is_Nv=00_00_20_00_0}', ""); +Expect(1, 65836, '\P{^Is_Nv=00_00_20_00_0}', ""); +Expect(0, 65835, '\p{Is_Nv=00_00_20_00_0}', ""); +Expect(1, 65835, '\p{^Is_Nv=00_00_20_00_0}', ""); +Expect(1, 65835, '\P{Is_Nv=00_00_20_00_0}', ""); +Expect(0, 65835, '\P{^Is_Nv=00_00_20_00_0}', ""); +Error('\p{Numeric_Value= /a/+0000_000001}'); +Error('\P{Numeric_Value= /a/+0000_000001}'); +Expect(1, 49, '\p{Numeric_Value: 0001}', ""); +Expect(0, 49, '\p{^Numeric_Value: 0001}', ""); +Expect(0, 49, '\P{Numeric_Value: 0001}', ""); +Expect(1, 49, '\P{^Numeric_Value: 0001}', ""); +Expect(0, 48, '\p{Numeric_Value: 0001}', ""); +Expect(1, 48, '\p{^Numeric_Value: 0001}', ""); +Expect(1, 48, '\P{Numeric_Value: 0001}', ""); +Expect(0, 48, '\P{^Numeric_Value: 0001}', ""); +Error('\p{Nv=-/a/0 1}'); +Error('\P{Nv=-/a/0 1}'); +Expect(1, 49, '\p{Nv=00000001}', ""); +Expect(0, 49, '\p{^Nv=00000001}', ""); +Expect(0, 49, '\P{Nv=00000001}', ""); +Expect(1, 49, '\P{^Nv=00000001}', ""); +Expect(0, 48, '\p{Nv=00000001}', ""); +Expect(1, 48, '\p{^Nv=00000001}', ""); +Expect(1, 48, '\P{Nv=00000001}', ""); +Expect(0, 48, '\P{^Nv=00000001}', ""); +Error('\p{Is_Numeric_Value=-/a/+0000001}'); +Error('\P{Is_Numeric_Value=-/a/+0000001}'); +Expect(1, 49, '\p{Is_Numeric_Value=0001}', ""); +Expect(0, 49, '\p{^Is_Numeric_Value=0001}', ""); +Expect(0, 49, '\P{Is_Numeric_Value=0001}', ""); +Expect(1, 49, '\P{^Is_Numeric_Value=0001}', ""); +Expect(0, 48, '\p{Is_Numeric_Value=0001}', ""); +Expect(1, 48, '\p{^Is_Numeric_Value=0001}', ""); +Expect(1, 48, '\P{Is_Numeric_Value=0001}', ""); +Expect(0, 48, '\P{^Is_Numeric_Value=0001}', ""); +Error('\p{Is_Nv= 00001/a/}'); +Error('\P{Is_Nv= 00001/a/}'); +Expect(1, 49, '\p{Is_Nv=000001}', ""); +Expect(0, 49, '\p{^Is_Nv=000001}', ""); +Expect(0, 49, '\P{Is_Nv=000001}', ""); +Expect(1, 49, '\P{^Is_Nv=000001}', ""); +Expect(0, 48, '\p{Is_Nv=000001}', ""); +Expect(1, 48, '\p{^Is_Nv=000001}', ""); +Expect(1, 48, '\P{Is_Nv=000001}', ""); +Expect(0, 48, '\P{^Is_Nv=000001}', ""); +Error('\p{Numeric_Value:_:=000_06000}'); +Error('\P{Numeric_Value:_:=000_06000}'); +Expect(1, 65831, '\p{Numeric_Value=600_0}', ""); +Expect(0, 65831, '\p{^Numeric_Value=600_0}', ""); +Expect(0, 65831, '\P{Numeric_Value=600_0}', ""); +Expect(1, 65831, '\P{^Numeric_Value=600_0}', ""); +Expect(0, 65830, '\p{Numeric_Value=600_0}', ""); +Expect(1, 65830, '\p{^Numeric_Value=600_0}', ""); +Expect(1, 65830, '\P{Numeric_Value=600_0}', ""); +Expect(0, 65830, '\P{^Numeric_Value=600_0}', ""); +Error('\p{Nv=_:=0 0-0 0 6-000}'); +Error('\P{Nv=_:=0 0-0 0 6-000}'); +Expect(1, 65831, '\p{Nv=0000000006000}', ""); +Expect(0, 65831, '\p{^Nv=0000000006000}', ""); +Expect(0, 65831, '\P{Nv=0000000006000}', ""); +Expect(1, 65831, '\P{^Nv=0000000006000}', ""); +Expect(0, 65830, '\p{Nv=0000000006000}', ""); +Expect(1, 65830, '\p{^Nv=0000000006000}', ""); +Expect(1, 65830, '\P{Nv=0000000006000}', ""); +Expect(0, 65830, '\P{^Nv=0000000006000}', ""); +Error('\p{Is_Numeric_Value::=000 000_600-0}'); +Error('\P{Is_Numeric_Value::=000 000_600-0}'); +Expect(1, 65831, '\p{Is_Numeric_Value=00000006000}', ""); +Expect(0, 65831, '\p{^Is_Numeric_Value=00000006000}', ""); +Expect(0, 65831, '\P{Is_Numeric_Value=00000006000}', ""); +Expect(1, 65831, '\P{^Is_Numeric_Value=00000006000}', ""); +Expect(0, 65830, '\p{Is_Numeric_Value=00000006000}', ""); +Expect(1, 65830, '\p{^Is_Numeric_Value=00000006000}', ""); +Expect(1, 65830, '\P{Is_Numeric_Value=00000006000}', ""); +Expect(0, 65830, '\P{^Is_Numeric_Value=00000006000}', ""); +Error('\p{Is_Nv=_-+00006000/a/}'); +Error('\P{Is_Nv=_-+00006000/a/}'); +Expect(1, 65831, '\p{Is_Nv: 0000_0000_0600_0}', ""); +Expect(0, 65831, '\p{^Is_Nv: 0000_0000_0600_0}', ""); +Expect(0, 65831, '\P{Is_Nv: 0000_0000_0600_0}', ""); +Expect(1, 65831, '\P{^Is_Nv: 0000_0000_0600_0}', ""); +Expect(0, 65830, '\p{Is_Nv: 0000_0000_0600_0}', ""); +Expect(1, 65830, '\p{^Is_Nv: 0000_0000_0600_0}', ""); +Expect(1, 65830, '\P{Is_Nv: 0000_0000_0600_0}', ""); +Expect(0, 65830, '\P{^Is_Nv: 0000_0000_0600_0}', ""); +Error('\p{Numeric_Value= :=+00003-0}'); +Error('\P{Numeric_Value= :=+00003-0}'); +Expect(1, 4980, '\p{Numeric_Value=+0000000030}', ""); +Expect(0, 4980, '\p{^Numeric_Value=+0000000030}', ""); +Expect(0, 4980, '\P{Numeric_Value=+0000000030}', ""); +Expect(1, 4980, '\P{^Numeric_Value=+0000000030}', ""); +Expect(0, 4979, '\p{Numeric_Value=+0000000030}', ""); +Expect(1, 4979, '\p{^Numeric_Value=+0000000030}', ""); +Expect(1, 4979, '\P{Numeric_Value=+0000000030}', ""); +Expect(0, 4979, '\P{^Numeric_Value=+0000000030}', ""); +Error('\p{Nv= 00030/a/}'); +Error('\P{Nv= 00030/a/}'); +Expect(1, 4980, '\p{Nv=+00_00_30}', ""); +Expect(0, 4980, '\p{^Nv=+00_00_30}', ""); +Expect(0, 4980, '\P{Nv=+00_00_30}', ""); +Expect(1, 4980, '\P{^Nv=+00_00_30}', ""); +Expect(0, 4979, '\p{Nv=+00_00_30}', ""); +Expect(1, 4979, '\p{^Nv=+00_00_30}', ""); +Expect(1, 4979, '\P{Nv=+00_00_30}', ""); +Expect(0, 4979, '\P{^Nv=+00_00_30}', ""); +Error('\p{Is_Numeric_Value=/a/_0000030}'); +Error('\P{Is_Numeric_Value=/a/_0000030}'); +Expect(1, 4980, '\p{Is_Numeric_Value=00000000030}', ""); +Expect(0, 4980, '\p{^Is_Numeric_Value=00000000030}', ""); +Expect(0, 4980, '\P{Is_Numeric_Value=00000000030}', ""); +Expect(1, 4980, '\P{^Is_Numeric_Value=00000000030}', ""); +Expect(0, 4979, '\p{Is_Numeric_Value=00000000030}', ""); +Expect(1, 4979, '\p{^Is_Numeric_Value=00000000030}', ""); +Expect(1, 4979, '\P{Is_Numeric_Value=00000000030}', ""); +Expect(0, 4979, '\P{^Is_Numeric_Value=00000000030}', ""); +Error('\p{Is_Nv=_/a/+000000030}'); +Error('\P{Is_Nv=_/a/+000000030}'); +Expect(1, 4980, '\p{Is_Nv=0000000030}', ""); +Expect(0, 4980, '\p{^Is_Nv=0000000030}', ""); +Expect(0, 4980, '\P{Is_Nv=0000000030}', ""); +Expect(1, 4980, '\P{^Is_Nv=0000000030}', ""); +Expect(0, 4979, '\p{Is_Nv=0000000030}', ""); +Expect(1, 4979, '\p{^Is_Nv=0000000030}', ""); +Expect(1, 4979, '\P{Is_Nv=0000000030}', ""); +Expect(0, 4979, '\P{^Is_Nv=0000000030}', ""); +Error('\p{Numeric_Value=:= +000000002/00003}'); +Error('\P{Numeric_Value=:= +000000002/00003}'); +Expect(1, 8532, '\p{Numeric_Value=2/000000003}', ""); +Expect(0, 8532, '\p{^Numeric_Value=2/000000003}', ""); +Expect(0, 8532, '\P{Numeric_Value=2/000000003}', ""); +Expect(1, 8532, '\P{^Numeric_Value=2/000000003}', ""); +Expect(0, 8531, '\p{Numeric_Value=2/000000003}', ""); +Expect(1, 8531, '\p{^Numeric_Value=2/000000003}', ""); +Expect(1, 8531, '\P{Numeric_Value=2/000000003}', ""); +Expect(0, 8531, '\P{^Numeric_Value=2/000000003}', ""); +Error('\p{Numeric_Value=0.7}'); +Error('\P{Numeric_Value=0.7}'); +Error('\p{Numeric_Value=0.67}'); +Error('\P{Numeric_Value=0.67}'); +Expect(1, 8532, '\p{Numeric_Value:0.667}', ""); +Expect(0, 8532, '\p{^Numeric_Value:0.667}', ""); +Expect(0, 8532, '\P{Numeric_Value:0.667}', ""); +Expect(1, 8532, '\P{^Numeric_Value:0.667}', ""); +Expect(0, 8531, '\p{Numeric_Value:0.667}', ""); +Expect(1, 8531, '\p{^Numeric_Value:0.667}', ""); +Expect(1, 8531, '\P{Numeric_Value:0.667}', ""); +Expect(0, 8531, '\P{^Numeric_Value:0.667}', ""); +Error('\p{Nv=:=__000000002/0000003}'); +Error('\P{Nv=:=__000000002/0000003}'); +Expect(1, 8532, '\p{Nv=+0000000002/0000003}', ""); +Expect(0, 8532, '\p{^Nv=+0000000002/0000003}', ""); +Expect(0, 8532, '\P{Nv=+0000000002/0000003}', ""); +Expect(1, 8532, '\P{^Nv=+0000000002/0000003}', ""); +Expect(0, 8531, '\p{Nv=+0000000002/0000003}', ""); +Expect(1, 8531, '\p{^Nv=+0000000002/0000003}', ""); +Expect(1, 8531, '\P{Nv=+0000000002/0000003}', ""); +Expect(0, 8531, '\P{^Nv=+0000000002/0000003}', ""); +Error('\p{Nv=0.7}'); +Error('\P{Nv=0.7}'); +Error('\p{Nv: 0.67}'); +Error('\P{Nv: 0.67}'); +Expect(1, 8532, '\p{Nv=0.667}', ""); +Expect(0, 8532, '\p{^Nv=0.667}', ""); +Expect(0, 8532, '\P{Nv=0.667}', ""); +Expect(1, 8532, '\P{^Nv=0.667}', ""); +Expect(0, 8531, '\p{Nv=0.667}', ""); +Expect(1, 8531, '\p{^Nv=0.667}', ""); +Expect(1, 8531, '\P{Nv=0.667}', ""); +Expect(0, 8531, '\P{^Nv=0.667}', ""); +Error('\p{Is_Numeric_Value=:= -+0002/000003}'); +Error('\P{Is_Numeric_Value=:= -+0002/000003}'); +Expect(1, 8532, '\p{Is_Numeric_Value:+000002/003}', ""); +Expect(0, 8532, '\p{^Is_Numeric_Value:+000002/003}', ""); +Expect(0, 8532, '\P{Is_Numeric_Value:+000002/003}', ""); +Expect(1, 8532, '\P{^Is_Numeric_Value:+000002/003}', ""); +Expect(0, 8531, '\p{Is_Numeric_Value:+000002/003}', ""); +Expect(1, 8531, '\p{^Is_Numeric_Value:+000002/003}', ""); +Expect(1, 8531, '\P{Is_Numeric_Value:+000002/003}', ""); +Expect(0, 8531, '\P{^Is_Numeric_Value:+000002/003}', ""); +Error('\p{Is_Numeric_Value=0.7}'); +Error('\P{Is_Numeric_Value=0.7}'); +Error('\p{Is_Numeric_Value=0.67}'); +Error('\P{Is_Numeric_Value=0.67}'); +Expect(1, 8532, '\p{Is_Numeric_Value=0.667}', ""); +Expect(0, 8532, '\p{^Is_Numeric_Value=0.667}', ""); +Expect(0, 8532, '\P{Is_Numeric_Value=0.667}', ""); +Expect(1, 8532, '\P{^Is_Numeric_Value=0.667}', ""); +Expect(0, 8531, '\p{Is_Numeric_Value=0.667}', ""); +Expect(1, 8531, '\p{^Is_Numeric_Value=0.667}', ""); +Expect(1, 8531, '\P{Is_Numeric_Value=0.667}', ""); +Expect(0, 8531, '\P{^Is_Numeric_Value=0.667}', ""); +Error('\p{Is_Nv=_:=0000000002/0000003}'); +Error('\P{Is_Nv=_:=0000000002/0000003}'); +Expect(1, 8532, '\p{Is_Nv=000002/03}', ""); +Expect(0, 8532, '\p{^Is_Nv=000002/03}', ""); +Expect(0, 8532, '\P{Is_Nv=000002/03}', ""); +Expect(1, 8532, '\P{^Is_Nv=000002/03}', ""); +Expect(0, 8531, '\p{Is_Nv=000002/03}', ""); +Expect(1, 8531, '\p{^Is_Nv=000002/03}', ""); +Expect(1, 8531, '\P{Is_Nv=000002/03}', ""); +Expect(0, 8531, '\P{^Is_Nv=000002/03}', ""); +Error('\p{Is_Nv=0.7}'); +Error('\P{Is_Nv=0.7}'); +Error('\p{Is_Nv=0.67}'); +Error('\P{Is_Nv=0.67}'); +Expect(1, 8532, '\p{Is_Nv=0.667}', ""); +Expect(0, 8532, '\p{^Is_Nv=0.667}', ""); +Expect(0, 8532, '\P{Is_Nv=0.667}', ""); +Expect(1, 8532, '\P{^Is_Nv=0.667}', ""); +Expect(0, 8531, '\p{Is_Nv=0.667}', ""); +Expect(1, 8531, '\p{^Is_Nv=0.667}', ""); +Expect(1, 8531, '\P{Is_Nv=0.667}', ""); +Expect(0, 8531, '\P{^Is_Nv=0.667}', ""); +Error('\p{Numeric_Value=_ 00004000/a/}'); +Error('\P{Numeric_Value=_ 00004000/a/}'); +Expect(1, 65829, '\p{Numeric_Value=00004000}', ""); +Expect(0, 65829, '\p{^Numeric_Value=00004000}', ""); +Expect(0, 65829, '\P{Numeric_Value=00004000}', ""); +Expect(1, 65829, '\P{^Numeric_Value=00004000}', ""); +Expect(0, 65828, '\p{Numeric_Value=00004000}', ""); +Expect(1, 65828, '\p{^Numeric_Value=00004000}', ""); +Expect(1, 65828, '\P{Numeric_Value=00004000}', ""); +Expect(0, 65828, '\P{^Numeric_Value=00004000}', ""); +Error('\p{Nv=_/a/0000004000}'); +Error('\P{Nv=_/a/0000004000}'); +Expect(1, 65829, '\p{Nv=+000004000}', ""); +Expect(0, 65829, '\p{^Nv=+000004000}', ""); +Expect(0, 65829, '\P{Nv=+000004000}', ""); +Expect(1, 65829, '\P{^Nv=+000004000}', ""); +Expect(0, 65828, '\p{Nv=+000004000}', ""); +Expect(1, 65828, '\p{^Nv=+000004000}', ""); +Expect(1, 65828, '\P{Nv=+000004000}', ""); +Expect(0, 65828, '\P{^Nv=+000004000}', ""); +Error('\p{Is_Numeric_Value=:=- +0000000004000}'); +Error('\P{Is_Numeric_Value=:=- +0000000004000}'); +Expect(1, 65829, '\p{Is_Numeric_Value:+4_0_00}', ""); +Expect(0, 65829, '\p{^Is_Numeric_Value:+4_0_00}', ""); +Expect(0, 65829, '\P{Is_Numeric_Value:+4_0_00}', ""); +Expect(1, 65829, '\P{^Is_Numeric_Value:+4_0_00}', ""); +Expect(0, 65828, '\p{Is_Numeric_Value:+4_0_00}', ""); +Expect(1, 65828, '\p{^Is_Numeric_Value:+4_0_00}', ""); +Expect(1, 65828, '\P{Is_Numeric_Value:+4_0_00}', ""); +Expect(0, 65828, '\P{^Is_Numeric_Value:+4_0_00}', ""); +Error('\p{Is_Nv=- 400/a/0}'); +Error('\P{Is_Nv=- 400/a/0}'); +Expect(1, 65829, '\p{Is_Nv=+04000}', ""); +Expect(0, 65829, '\p{^Is_Nv=+04000}', ""); +Expect(0, 65829, '\P{Is_Nv=+04000}', ""); +Expect(1, 65829, '\P{^Is_Nv=+04000}', ""); +Expect(0, 65828, '\p{Is_Nv=+04000}', ""); +Expect(1, 65828, '\p{^Is_Nv=+04000}', ""); +Expect(1, 65828, '\P{Is_Nv=+04000}', ""); +Expect(0, 65828, '\P{^Is_Nv=+04000}', ""); +Error('\p{Numeric_Value=:=-+00100}'); +Error('\P{Numeric_Value=:=-+00100}'); +Expect(1, 3057, '\p{Numeric_Value=000_000_001_00}', ""); +Expect(0, 3057, '\p{^Numeric_Value=000_000_001_00}', ""); +Expect(0, 3057, '\P{Numeric_Value=000_000_001_00}', ""); +Expect(1, 3057, '\P{^Numeric_Value=000_000_001_00}', ""); +Expect(0, 3056, '\p{Numeric_Value=000_000_001_00}', ""); +Expect(1, 3056, '\p{^Numeric_Value=000_000_001_00}', ""); +Expect(1, 3056, '\P{Numeric_Value=000_000_001_00}', ""); +Expect(0, 3056, '\P{^Numeric_Value=000_000_001_00}', ""); +Error('\p{Nv: -0000000100:=}'); +Error('\P{Nv: -0000000100:=}'); +Expect(1, 3057, '\p{Nv=0_0_0_0_0_0_00100}', ""); +Expect(0, 3057, '\p{^Nv=0_0_0_0_0_0_00100}', ""); +Expect(0, 3057, '\P{Nv=0_0_0_0_0_0_00100}', ""); +Expect(1, 3057, '\P{^Nv=0_0_0_0_0_0_00100}', ""); +Expect(0, 3056, '\p{Nv=0_0_0_0_0_0_00100}', ""); +Expect(1, 3056, '\p{^Nv=0_0_0_0_0_0_00100}', ""); +Expect(1, 3056, '\P{Nv=0_0_0_0_0_0_00100}', ""); +Expect(0, 3056, '\P{^Nv=0_0_0_0_0_0_00100}', ""); +Error('\p{Is_Numeric_Value=_ 0:=1 00}'); +Error('\P{Is_Numeric_Value=_ 0:=1 00}'); +Expect(1, 3057, '\p{Is_Numeric_Value=+0000100}', ""); +Expect(0, 3057, '\p{^Is_Numeric_Value=+0000100}', ""); +Expect(0, 3057, '\P{Is_Numeric_Value=+0000100}', ""); +Expect(1, 3057, '\P{^Is_Numeric_Value=+0000100}', ""); +Expect(0, 3056, '\p{Is_Numeric_Value=+0000100}', ""); +Expect(1, 3056, '\p{^Is_Numeric_Value=+0000100}', ""); +Expect(1, 3056, '\P{Is_Numeric_Value=+0000100}', ""); +Expect(0, 3056, '\P{^Is_Numeric_Value=+0000100}', ""); +Error('\p{Is_Nv=:=_0000010_0}'); +Error('\P{Is_Nv=:=_0000010_0}'); +Expect(1, 3057, '\p{Is_Nv=0000_0010_0}', ""); +Expect(0, 3057, '\p{^Is_Nv=0000_0010_0}', ""); +Expect(0, 3057, '\P{Is_Nv=0000_0010_0}', ""); +Expect(1, 3057, '\P{^Is_Nv=0000_0010_0}', ""); +Expect(0, 3056, '\p{Is_Nv=0000_0010_0}', ""); +Expect(1, 3056, '\p{^Is_Nv=0000_0010_0}', ""); +Expect(1, 3056, '\P{Is_Nv=0000_0010_0}', ""); +Expect(0, 3056, '\P{^Is_Nv=0000_0010_0}', ""); +Error('\p{Numeric_Value= /a/+0000000300}'); +Error('\P{Numeric_Value= /a/+0000000300}'); +Expect(1, 65819, '\p{Numeric_Value=+0000000300}', ""); +Expect(0, 65819, '\p{^Numeric_Value=+0000000300}', ""); +Expect(0, 65819, '\P{Numeric_Value=+0000000300}', ""); +Expect(1, 65819, '\P{^Numeric_Value=+0000000300}', ""); +Expect(0, 65818, '\p{Numeric_Value=+0000000300}', ""); +Expect(1, 65818, '\p{^Numeric_Value=+0000000300}', ""); +Expect(1, 65818, '\P{Numeric_Value=+0000000300}', ""); +Expect(0, 65818, '\P{^Numeric_Value=+0000000300}', ""); +Error('\p{Nv= -+00_00/a/00_00_300}'); +Error('\P{Nv= -+00_00/a/00_00_300}'); +Expect(1, 65819, '\p{Nv=00000000300}', ""); +Expect(0, 65819, '\p{^Nv=00000000300}', ""); +Expect(0, 65819, '\P{Nv=00000000300}', ""); +Expect(1, 65819, '\P{^Nv=00000000300}', ""); +Expect(0, 65818, '\p{Nv=00000000300}', ""); +Expect(1, 65818, '\p{^Nv=00000000300}', ""); +Expect(1, 65818, '\P{Nv=00000000300}', ""); +Expect(0, 65818, '\P{^Nv=00000000300}', ""); +Error('\p{Is_Numeric_Value=- 0-0:=3-00}'); +Error('\P{Is_Numeric_Value=- 0-0:=3-00}'); +Expect(1, 65819, '\p{Is_Numeric_Value=0_0_0_0_0_0300}', ""); +Expect(0, 65819, '\p{^Is_Numeric_Value=0_0_0_0_0_0300}', ""); +Expect(0, 65819, '\P{Is_Numeric_Value=0_0_0_0_0_0300}', ""); +Expect(1, 65819, '\P{^Is_Numeric_Value=0_0_0_0_0_0300}', ""); +Expect(0, 65818, '\p{Is_Numeric_Value=0_0_0_0_0_0300}', ""); +Expect(1, 65818, '\p{^Is_Numeric_Value=0_0_0_0_0_0300}', ""); +Expect(1, 65818, '\P{Is_Numeric_Value=0_0_0_0_0_0300}', ""); +Expect(0, 65818, '\P{^Is_Numeric_Value=0_0_0_0_0_0300}', ""); +Error('\p{Is_Nv: /a/000 003 00}'); +Error('\P{Is_Nv: /a/000 003 00}'); +Expect(1, 65819, '\p{Is_Nv=+00300}', ""); +Expect(0, 65819, '\p{^Is_Nv=+00300}', ""); +Expect(0, 65819, '\P{Is_Nv=+00300}', ""); +Expect(1, 65819, '\P{^Is_Nv=+00300}', ""); +Expect(0, 65818, '\p{Is_Nv=+00300}', ""); +Expect(1, 65818, '\p{^Is_Nv=+00300}', ""); +Expect(1, 65818, '\P{Is_Nv=+00300}', ""); +Expect(0, 65818, '\P{^Is_Nv=+00300}', ""); +Error('\p{Numeric_Value=/a/ -5/0000006}'); +Error('\P{Numeric_Value=/a/ -5/0000006}'); +Expect(1, 8538, '\p{Numeric_Value=+5/06}', ""); +Expect(0, 8538, '\p{^Numeric_Value=+5/06}', ""); +Expect(0, 8538, '\P{Numeric_Value=+5/06}', ""); +Expect(1, 8538, '\P{^Numeric_Value=+5/06}', ""); +Expect(0, 8537, '\p{Numeric_Value=+5/06}', ""); +Expect(1, 8537, '\p{^Numeric_Value=+5/06}', ""); +Expect(1, 8537, '\P{Numeric_Value=+5/06}', ""); +Expect(0, 8537, '\P{^Numeric_Value=+5/06}', ""); +Error('\p{Numeric_Value: 0.83}'); +Error('\P{Numeric_Value: 0.83}'); +Expect(1, 8538, '\p{Numeric_Value=0.833}', ""); +Expect(0, 8538, '\p{^Numeric_Value=0.833}', ""); +Expect(0, 8538, '\P{Numeric_Value=0.833}', ""); +Expect(1, 8538, '\P{^Numeric_Value=0.833}', ""); +Expect(0, 8537, '\p{Numeric_Value=0.833}', ""); +Expect(1, 8537, '\p{^Numeric_Value=0.833}', ""); +Expect(1, 8537, '\P{Numeric_Value=0.833}', ""); +Expect(0, 8537, '\P{^Numeric_Value=0.833}', ""); +Error('\p{Nv= :=000000005/006}'); +Error('\P{Nv= :=000000005/006}'); +Expect(1, 8538, '\p{Nv: 00005/0000006}', ""); +Expect(0, 8538, '\p{^Nv: 00005/0000006}', ""); +Expect(0, 8538, '\P{Nv: 00005/0000006}', ""); +Expect(1, 8538, '\P{^Nv: 00005/0000006}', ""); +Expect(0, 8537, '\p{Nv: 00005/0000006}', ""); +Expect(1, 8537, '\p{^Nv: 00005/0000006}', ""); +Expect(1, 8537, '\P{Nv: 00005/0000006}', ""); +Expect(0, 8537, '\P{^Nv: 00005/0000006}', ""); +Error('\p{Nv=0.83}'); +Error('\P{Nv=0.83}'); +Expect(1, 8538, '\p{Nv:0.833}', ""); +Expect(0, 8538, '\p{^Nv:0.833}', ""); +Expect(0, 8538, '\P{Nv:0.833}', ""); +Expect(1, 8538, '\P{^Nv:0.833}', ""); +Expect(0, 8537, '\p{Nv:0.833}', ""); +Expect(1, 8537, '\p{^Nv:0.833}', ""); +Expect(1, 8537, '\P{Nv:0.833}', ""); +Expect(0, 8537, '\P{^Nv:0.833}', ""); +Error('\p{Is_Numeric_Value= /a/00005/00000006}'); +Error('\P{Is_Numeric_Value= /a/00005/00000006}'); +Expect(1, 8538, '\p{Is_Numeric_Value=+00000005/0000006}', ""); +Expect(0, 8538, '\p{^Is_Numeric_Value=+00000005/0000006}', ""); +Expect(0, 8538, '\P{Is_Numeric_Value=+00000005/0000006}', ""); +Expect(1, 8538, '\P{^Is_Numeric_Value=+00000005/0000006}', ""); +Expect(0, 8537, '\p{Is_Numeric_Value=+00000005/0000006}', ""); +Expect(1, 8537, '\p{^Is_Numeric_Value=+00000005/0000006}', ""); +Expect(1, 8537, '\P{Is_Numeric_Value=+00000005/0000006}', ""); +Expect(0, 8537, '\P{^Is_Numeric_Value=+00000005/0000006}', ""); +Error('\p{Is_Numeric_Value:0.83}'); +Error('\P{Is_Numeric_Value:0.83}'); +Expect(1, 8538, '\p{Is_Numeric_Value=0.833}', ""); +Expect(0, 8538, '\p{^Is_Numeric_Value=0.833}', ""); +Expect(0, 8538, '\P{Is_Numeric_Value=0.833}', ""); +Expect(1, 8538, '\P{^Is_Numeric_Value=0.833}', ""); +Expect(0, 8537, '\p{Is_Numeric_Value=0.833}', ""); +Expect(1, 8537, '\p{^Is_Numeric_Value=0.833}', ""); +Expect(1, 8537, '\P{Is_Numeric_Value=0.833}', ""); +Expect(0, 8537, '\P{^Is_Numeric_Value=0.833}', ""); +Error('\p{Is_Nv: /a/--+00000005/06}'); +Error('\P{Is_Nv: /a/--+00000005/06}'); +Expect(1, 8538, '\p{Is_Nv=05/006}', ""); +Expect(0, 8538, '\p{^Is_Nv=05/006}', ""); +Expect(0, 8538, '\P{Is_Nv=05/006}', ""); +Expect(1, 8538, '\P{^Is_Nv=05/006}', ""); +Expect(0, 8537, '\p{Is_Nv=05/006}', ""); +Expect(1, 8537, '\p{^Is_Nv=05/006}', ""); +Expect(1, 8537, '\P{Is_Nv=05/006}', ""); +Expect(0, 8537, '\P{^Is_Nv=05/006}', ""); +Error('\p{Is_Nv=0.83}'); +Error('\P{Is_Nv=0.83}'); +Expect(1, 8538, '\p{Is_Nv=0.833}', ""); +Expect(0, 8538, '\p{^Is_Nv=0.833}', ""); +Expect(0, 8538, '\P{Is_Nv=0.833}', ""); +Expect(1, 8538, '\P{^Is_Nv=0.833}', ""); +Expect(0, 8537, '\p{Is_Nv=0.833}', ""); +Expect(1, 8537, '\p{^Is_Nv=0.833}', ""); +Expect(1, 8537, '\P{Is_Nv=0.833}', ""); +Expect(0, 8537, '\P{^Is_Nv=0.833}', ""); +Error('\p{Numeric_Value= :=0001/000000008}'); +Error('\P{Numeric_Value= :=0001/000000008}'); +Expect(1, 8539, '\p{Numeric_Value=1/0008}', ""); +Expect(0, 8539, '\p{^Numeric_Value=1/0008}', ""); +Expect(0, 8539, '\P{Numeric_Value=1/0008}', ""); +Expect(1, 8539, '\P{^Numeric_Value=1/0008}', ""); +Expect(0, 8538, '\p{Numeric_Value=1/0008}', ""); +Expect(1, 8538, '\p{^Numeric_Value=1/0008}', ""); +Expect(1, 8538, '\P{Numeric_Value=1/0008}', ""); +Expect(0, 8538, '\P{^Numeric_Value=1/0008}', ""); +Error('\p{Numeric_Value=0.1}'); +Error('\P{Numeric_Value=0.1}'); +Error('\p{Numeric_Value=0.12}'); +Error('\P{Numeric_Value=0.12}'); +Expect(1, 8539, '\p{Numeric_Value=0.125}', ""); +Expect(0, 8539, '\p{^Numeric_Value=0.125}', ""); +Expect(0, 8539, '\P{Numeric_Value=0.125}', ""); +Expect(1, 8539, '\P{^Numeric_Value=0.125}', ""); +Expect(0, 8538, '\p{Numeric_Value=0.125}', ""); +Expect(1, 8538, '\p{^Numeric_Value=0.125}', ""); +Expect(1, 8538, '\P{Numeric_Value=0.125}', ""); +Expect(0, 8538, '\P{^Numeric_Value=0.125}', ""); +Error('\p{Nv=- 01/008/a/}'); +Error('\P{Nv=- 01/008/a/}'); +Expect(1, 8539, '\p{Nv: 001/008}', ""); +Expect(0, 8539, '\p{^Nv: 001/008}', ""); +Expect(0, 8539, '\P{Nv: 001/008}', ""); +Expect(1, 8539, '\P{^Nv: 001/008}', ""); +Expect(0, 8538, '\p{Nv: 001/008}', ""); +Expect(1, 8538, '\p{^Nv: 001/008}', ""); +Expect(1, 8538, '\P{Nv: 001/008}', ""); +Expect(0, 8538, '\P{^Nv: 001/008}', ""); +Error('\p{Nv=0.1}'); +Error('\P{Nv=0.1}'); +Error('\p{Nv=0.12}'); +Error('\P{Nv=0.12}'); +Expect(1, 8539, '\p{Nv=0.125}', ""); +Expect(0, 8539, '\p{^Nv=0.125}', ""); +Expect(0, 8539, '\P{Nv=0.125}', ""); +Expect(1, 8539, '\P{^Nv=0.125}', ""); +Expect(0, 8538, '\p{Nv=0.125}', ""); +Expect(1, 8538, '\p{^Nv=0.125}', ""); +Expect(1, 8538, '\P{Nv=0.125}', ""); +Expect(0, 8538, '\P{^Nv=0.125}', ""); +Error('\p{Is_Numeric_Value= :=+001/008}'); +Error('\P{Is_Numeric_Value= :=+001/008}'); +Expect(1, 8539, '\p{Is_Numeric_Value=+01/00000008}', ""); +Expect(0, 8539, '\p{^Is_Numeric_Value=+01/00000008}', ""); +Expect(0, 8539, '\P{Is_Numeric_Value=+01/00000008}', ""); +Expect(1, 8539, '\P{^Is_Numeric_Value=+01/00000008}', ""); +Expect(0, 8538, '\p{Is_Numeric_Value=+01/00000008}', ""); +Expect(1, 8538, '\p{^Is_Numeric_Value=+01/00000008}', ""); +Expect(1, 8538, '\P{Is_Numeric_Value=+01/00000008}', ""); +Expect(0, 8538, '\P{^Is_Numeric_Value=+01/00000008}', ""); +Error('\p{Is_Numeric_Value: 0.1}'); +Error('\P{Is_Numeric_Value: 0.1}'); +Error('\p{Is_Numeric_Value=0.12}'); +Error('\P{Is_Numeric_Value=0.12}'); +Expect(1, 8539, '\p{Is_Numeric_Value=0.125}', ""); +Expect(0, 8539, '\p{^Is_Numeric_Value=0.125}', ""); +Expect(0, 8539, '\P{Is_Numeric_Value=0.125}', ""); +Expect(1, 8539, '\P{^Is_Numeric_Value=0.125}', ""); +Expect(0, 8538, '\p{Is_Numeric_Value=0.125}', ""); +Expect(1, 8538, '\p{^Is_Numeric_Value=0.125}', ""); +Expect(1, 8538, '\P{Is_Numeric_Value=0.125}', ""); +Expect(0, 8538, '\P{^Is_Numeric_Value=0.125}', ""); +Error('\p{Is_Nv=_-0000000001/0008/a/}'); +Error('\P{Is_Nv=_-0000000001/0008/a/}'); +Expect(1, 8539, '\p{Is_Nv=000000001/0008}', ""); +Expect(0, 8539, '\p{^Is_Nv=000000001/0008}', ""); +Expect(0, 8539, '\P{Is_Nv=000000001/0008}', ""); +Expect(1, 8539, '\P{^Is_Nv=000000001/0008}', ""); +Expect(0, 8538, '\p{Is_Nv=000000001/0008}', ""); +Expect(1, 8538, '\p{^Is_Nv=000000001/0008}', ""); +Expect(1, 8538, '\P{Is_Nv=000000001/0008}', ""); +Expect(0, 8538, '\P{^Is_Nv=000000001/0008}', ""); +Error('\p{Is_Nv=0.1}'); +Error('\P{Is_Nv=0.1}'); +Error('\p{Is_Nv=0.12}'); +Error('\P{Is_Nv=0.12}'); +Expect(1, 8539, '\p{Is_Nv=0.125}', ""); +Expect(0, 8539, '\p{^Is_Nv=0.125}', ""); +Expect(0, 8539, '\P{Is_Nv=0.125}', ""); +Expect(1, 8539, '\P{^Is_Nv=0.125}', ""); +Expect(0, 8538, '\p{Is_Nv=0.125}', ""); +Expect(1, 8538, '\p{^Is_Nv=0.125}', ""); +Expect(1, 8538, '\P{Is_Nv=0.125}', ""); +Expect(0, 8538, '\P{^Is_Nv=0.125}', ""); +Error('\p{Numeric_Value: _+25/a/}'); +Error('\P{Numeric_Value: _+25/a/}'); +Expect(1, 12885, '\p{Numeric_Value=0_0_0_0_025}', ""); +Expect(0, 12885, '\p{^Numeric_Value=0_0_0_0_025}', ""); +Expect(0, 12885, '\P{Numeric_Value=0_0_0_0_025}', ""); +Expect(1, 12885, '\P{^Numeric_Value=0_0_0_0_025}', ""); +Expect(0, 12884, '\p{Numeric_Value=0_0_0_0_025}', ""); +Expect(1, 12884, '\p{^Numeric_Value=0_0_0_0_025}', ""); +Expect(1, 12884, '\P{Numeric_Value=0_0_0_0_025}', ""); +Expect(0, 12884, '\P{^Numeric_Value=0_0_0_0_025}', ""); +Error('\p{Nv=:=_ 2-5}'); +Error('\P{Nv=:=_ 2-5}'); +Expect(1, 12885, '\p{Nv=+0_0_0_0_0_0_0025}', ""); +Expect(0, 12885, '\p{^Nv=+0_0_0_0_0_0_0025}', ""); +Expect(0, 12885, '\P{Nv=+0_0_0_0_0_0_0025}', ""); +Expect(1, 12885, '\P{^Nv=+0_0_0_0_0_0_0025}', ""); +Expect(0, 12884, '\p{Nv=+0_0_0_0_0_0_0025}', ""); +Expect(1, 12884, '\p{^Nv=+0_0_0_0_0_0_0025}', ""); +Expect(1, 12884, '\P{Nv=+0_0_0_0_0_0_0025}', ""); +Expect(0, 12884, '\P{^Nv=+0_0_0_0_0_0_0025}', ""); +Error('\p{Is_Numeric_Value=/a/--25}'); +Error('\P{Is_Numeric_Value=/a/--25}'); +Expect(1, 12885, '\p{Is_Numeric_Value=0000025}', ""); +Expect(0, 12885, '\p{^Is_Numeric_Value=0000025}', ""); +Expect(0, 12885, '\P{Is_Numeric_Value=0000025}', ""); +Expect(1, 12885, '\P{^Is_Numeric_Value=0000025}', ""); +Expect(0, 12884, '\p{Is_Numeric_Value=0000025}', ""); +Expect(1, 12884, '\p{^Is_Numeric_Value=0000025}', ""); +Expect(1, 12884, '\P{Is_Numeric_Value=0000025}', ""); +Expect(0, 12884, '\P{^Is_Numeric_Value=0000025}', ""); +Error('\p{Is_Nv=/a/ 25}'); +Error('\P{Is_Nv=/a/ 25}'); +Expect(1, 12885, '\p{Is_Nv=02_5}', ""); +Expect(0, 12885, '\p{^Is_Nv=02_5}', ""); +Expect(0, 12885, '\P{Is_Nv=02_5}', ""); +Expect(1, 12885, '\P{^Is_Nv=02_5}', ""); +Expect(0, 12884, '\p{Is_Nv=02_5}', ""); +Expect(1, 12884, '\p{^Is_Nv=02_5}', ""); +Expect(1, 12884, '\P{Is_Nv=02_5}', ""); +Expect(0, 12884, '\P{^Is_Nv=02_5}', ""); +Error('\p{Numeric_Value: +0_0 0 0 0_28:=}'); +Error('\P{Numeric_Value: +0_0 0 0 0_28:=}'); +Expect(1, 12888, '\p{Numeric_Value: 2_8}', ""); +Expect(0, 12888, '\p{^Numeric_Value: 2_8}', ""); +Expect(0, 12888, '\P{Numeric_Value: 2_8}', ""); +Expect(1, 12888, '\P{^Numeric_Value: 2_8}', ""); +Expect(0, 12887, '\p{Numeric_Value: 2_8}', ""); +Expect(1, 12887, '\p{^Numeric_Value: 2_8}', ""); +Expect(1, 12887, '\P{Numeric_Value: 2_8}', ""); +Expect(0, 12887, '\P{^Numeric_Value: 2_8}', ""); +Error('\p{Nv=_/a/+0000000028}'); +Error('\P{Nv=_/a/+0000000028}'); +Expect(1, 12888, '\p{Nv=000000028}', ""); +Expect(0, 12888, '\p{^Nv=000000028}', ""); +Expect(0, 12888, '\P{Nv=000000028}', ""); +Expect(1, 12888, '\P{^Nv=000000028}', ""); +Expect(0, 12887, '\p{Nv=000000028}', ""); +Expect(1, 12887, '\p{^Nv=000000028}', ""); +Expect(1, 12887, '\P{Nv=000000028}', ""); +Expect(0, 12887, '\P{^Nv=000000028}', ""); +Error('\p{Is_Numeric_Value=/a/_ 0000028}'); +Error('\P{Is_Numeric_Value=/a/_ 0000028}'); +Expect(1, 12888, '\p{Is_Numeric_Value=+00000000028}', ""); +Expect(0, 12888, '\p{^Is_Numeric_Value=+00000000028}', ""); +Expect(0, 12888, '\P{Is_Numeric_Value=+00000000028}', ""); +Expect(1, 12888, '\P{^Is_Numeric_Value=+00000000028}', ""); +Expect(0, 12887, '\p{Is_Numeric_Value=+00000000028}', ""); +Expect(1, 12887, '\p{^Is_Numeric_Value=+00000000028}', ""); +Expect(1, 12887, '\P{Is_Numeric_Value=+00000000028}', ""); +Expect(0, 12887, '\P{^Is_Numeric_Value=+00000000028}', ""); +Error('\p{Is_Nv=:= _+02_8}'); +Error('\P{Is_Nv=:= _+02_8}'); +Expect(1, 12888, '\p{Is_Nv: 2_8}', ""); +Expect(0, 12888, '\p{^Is_Nv: 2_8}', ""); +Expect(0, 12888, '\P{Is_Nv: 2_8}', ""); +Expect(1, 12888, '\P{^Is_Nv: 2_8}', ""); +Expect(0, 12887, '\p{Is_Nv: 2_8}', ""); +Expect(1, 12887, '\p{^Is_Nv: 2_8}', ""); +Expect(1, 12887, '\P{Is_Nv: 2_8}', ""); +Expect(0, 12887, '\P{^Is_Nv: 2_8}', ""); +Error('\p{Numeric_Value=/a/ 007/00002}'); +Error('\P{Numeric_Value=/a/ 007/00002}'); +Expect(1, 3885, '\p{Numeric_Value=7/00002}', ""); +Expect(0, 3885, '\p{^Numeric_Value=7/00002}', ""); +Expect(0, 3885, '\P{Numeric_Value=7/00002}', ""); +Expect(1, 3885, '\P{^Numeric_Value=7/00002}', ""); +Expect(0, 3884, '\p{Numeric_Value=7/00002}', ""); +Expect(1, 3884, '\p{^Numeric_Value=7/00002}', ""); +Expect(1, 3884, '\P{Numeric_Value=7/00002}', ""); +Expect(0, 3884, '\P{^Numeric_Value=7/00002}', ""); +Expect(1, 3885, '\p{Numeric_Value=3.500}', ""); +Expect(0, 3885, '\p{^Numeric_Value=3.500}', ""); +Expect(0, 3885, '\P{Numeric_Value=3.500}', ""); +Expect(1, 3885, '\P{^Numeric_Value=3.500}', ""); +Expect(0, 3884, '\p{Numeric_Value=3.500}', ""); +Expect(1, 3884, '\p{^Numeric_Value=3.500}', ""); +Expect(1, 3884, '\P{Numeric_Value=3.500}', ""); +Expect(0, 3884, '\P{^Numeric_Value=3.500}', ""); +Error('\p{Nv= 000007/000000002/a/}'); +Error('\P{Nv= 000007/000000002/a/}'); +Expect(1, 3885, '\p{Nv=0007/0000000002}', ""); +Expect(0, 3885, '\p{^Nv=0007/0000000002}', ""); +Expect(0, 3885, '\P{Nv=0007/0000000002}', ""); +Expect(1, 3885, '\P{^Nv=0007/0000000002}', ""); +Expect(0, 3884, '\p{Nv=0007/0000000002}', ""); +Expect(1, 3884, '\p{^Nv=0007/0000000002}', ""); +Expect(1, 3884, '\P{Nv=0007/0000000002}', ""); +Expect(0, 3884, '\P{^Nv=0007/0000000002}', ""); +Expect(1, 3885, '\p{Nv=3.500}', ""); +Expect(0, 3885, '\p{^Nv=3.500}', ""); +Expect(0, 3885, '\P{Nv=3.500}', ""); +Expect(1, 3885, '\P{^Nv=3.500}', ""); +Expect(0, 3884, '\p{Nv=3.500}', ""); +Expect(1, 3884, '\p{^Nv=3.500}', ""); +Expect(1, 3884, '\P{Nv=3.500}', ""); +Expect(0, 3884, '\P{^Nv=3.500}', ""); +Error('\p{Is_Numeric_Value=:=-7/0000000002}'); +Error('\P{Is_Numeric_Value=:=-7/0000000002}'); +Expect(1, 3885, '\p{Is_Numeric_Value=+0000007/000002}', ""); +Expect(0, 3885, '\p{^Is_Numeric_Value=+0000007/000002}', ""); +Expect(0, 3885, '\P{Is_Numeric_Value=+0000007/000002}', ""); +Expect(1, 3885, '\P{^Is_Numeric_Value=+0000007/000002}', ""); +Expect(0, 3884, '\p{Is_Numeric_Value=+0000007/000002}', ""); +Expect(1, 3884, '\p{^Is_Numeric_Value=+0000007/000002}', ""); +Expect(1, 3884, '\P{Is_Numeric_Value=+0000007/000002}', ""); +Expect(0, 3884, '\P{^Is_Numeric_Value=+0000007/000002}', ""); +Expect(1, 3885, '\p{Is_Numeric_Value=3.500}', ""); +Expect(0, 3885, '\p{^Is_Numeric_Value=3.500}', ""); +Expect(0, 3885, '\P{Is_Numeric_Value=3.500}', ""); +Expect(1, 3885, '\P{^Is_Numeric_Value=3.500}', ""); +Expect(0, 3884, '\p{Is_Numeric_Value=3.500}', ""); +Expect(1, 3884, '\p{^Is_Numeric_Value=3.500}', ""); +Expect(1, 3884, '\P{Is_Numeric_Value=3.500}', ""); +Expect(0, 3884, '\P{^Is_Numeric_Value=3.500}', ""); +Error('\p{Is_Nv=_:=+007/2}'); +Error('\P{Is_Nv=_:=+007/2}'); +Expect(1, 3885, '\p{Is_Nv=+0007/00002}', ""); +Expect(0, 3885, '\p{^Is_Nv=+0007/00002}', ""); +Expect(0, 3885, '\P{Is_Nv=+0007/00002}', ""); +Expect(1, 3885, '\P{^Is_Nv=+0007/00002}', ""); +Expect(0, 3884, '\p{Is_Nv=+0007/00002}', ""); +Expect(1, 3884, '\p{^Is_Nv=+0007/00002}', ""); +Expect(1, 3884, '\P{Is_Nv=+0007/00002}', ""); +Expect(0, 3884, '\P{^Is_Nv=+0007/00002}', ""); +Expect(1, 3885, '\p{Is_Nv=3.500}', ""); +Expect(0, 3885, '\p{^Is_Nv=3.500}', ""); +Expect(0, 3885, '\P{Is_Nv=3.500}', ""); +Expect(1, 3885, '\P{^Is_Nv=3.500}', ""); +Expect(0, 3884, '\p{Is_Nv=3.500}', ""); +Expect(1, 3884, '\p{^Is_Nv=3.500}', ""); +Expect(1, 3884, '\P{Is_Nv=3.500}', ""); +Expect(0, 3884, '\P{^Is_Nv=3.500}', ""); +Error('\p{Numeric_Value=/a/ -009/0000002}'); +Error('\P{Numeric_Value=/a/ -009/0000002}'); +Expect(1, 3886, '\p{Numeric_Value:000000009/0002}', ""); +Expect(0, 3886, '\p{^Numeric_Value:000000009/0002}', ""); +Expect(0, 3886, '\P{Numeric_Value:000000009/0002}', ""); +Expect(1, 3886, '\P{^Numeric_Value:000000009/0002}', ""); +Expect(0, 3885, '\p{Numeric_Value:000000009/0002}', ""); +Expect(1, 3885, '\p{^Numeric_Value:000000009/0002}', ""); +Expect(1, 3885, '\P{Numeric_Value:000000009/0002}', ""); +Expect(0, 3885, '\P{^Numeric_Value:000000009/0002}', ""); +Expect(1, 3886, '\p{Numeric_Value=4.500}', ""); +Expect(0, 3886, '\p{^Numeric_Value=4.500}', ""); +Expect(0, 3886, '\P{Numeric_Value=4.500}', ""); +Expect(1, 3886, '\P{^Numeric_Value=4.500}', ""); +Expect(0, 3885, '\p{Numeric_Value=4.500}', ""); +Expect(1, 3885, '\p{^Numeric_Value=4.500}', ""); +Expect(1, 3885, '\P{Numeric_Value=4.500}', ""); +Expect(0, 3885, '\P{^Numeric_Value=4.500}', ""); +Error('\p{Nv=/a/00009/002}'); +Error('\P{Nv=/a/00009/002}'); +Expect(1, 3886, '\p{Nv=00009/02}', ""); +Expect(0, 3886, '\p{^Nv=00009/02}', ""); +Expect(0, 3886, '\P{Nv=00009/02}', ""); +Expect(1, 3886, '\P{^Nv=00009/02}', ""); +Expect(0, 3885, '\p{Nv=00009/02}', ""); +Expect(1, 3885, '\p{^Nv=00009/02}', ""); +Expect(1, 3885, '\P{Nv=00009/02}', ""); +Expect(0, 3885, '\P{^Nv=00009/02}', ""); +Expect(1, 3886, '\p{Nv=4.500}', ""); +Expect(0, 3886, '\p{^Nv=4.500}', ""); +Expect(0, 3886, '\P{Nv=4.500}', ""); +Expect(1, 3886, '\P{^Nv=4.500}', ""); +Expect(0, 3885, '\p{Nv=4.500}', ""); +Expect(1, 3885, '\p{^Nv=4.500}', ""); +Expect(1, 3885, '\P{Nv=4.500}', ""); +Expect(0, 3885, '\P{^Nv=4.500}', ""); +Error('\p{Is_Numeric_Value= 09/00000002:=}'); +Error('\P{Is_Numeric_Value= 09/00000002:=}'); +Expect(1, 3886, '\p{Is_Numeric_Value=+00000009/0000000002}', ""); +Expect(0, 3886, '\p{^Is_Numeric_Value=+00000009/0000000002}', ""); +Expect(0, 3886, '\P{Is_Numeric_Value=+00000009/0000000002}', ""); +Expect(1, 3886, '\P{^Is_Numeric_Value=+00000009/0000000002}', ""); +Expect(0, 3885, '\p{Is_Numeric_Value=+00000009/0000000002}', ""); +Expect(1, 3885, '\p{^Is_Numeric_Value=+00000009/0000000002}', ""); +Expect(1, 3885, '\P{Is_Numeric_Value=+00000009/0000000002}', ""); +Expect(0, 3885, '\P{^Is_Numeric_Value=+00000009/0000000002}', ""); +Expect(1, 3886, '\p{Is_Numeric_Value: 4.500}', ""); +Expect(0, 3886, '\p{^Is_Numeric_Value: 4.500}', ""); +Expect(0, 3886, '\P{Is_Numeric_Value: 4.500}', ""); +Expect(1, 3886, '\P{^Is_Numeric_Value: 4.500}', ""); +Expect(0, 3885, '\p{Is_Numeric_Value: 4.500}', ""); +Expect(1, 3885, '\p{^Is_Numeric_Value: 4.500}', ""); +Expect(1, 3885, '\P{Is_Numeric_Value: 4.500}', ""); +Expect(0, 3885, '\P{^Is_Numeric_Value: 4.500}', ""); +Error('\p{Is_Nv=- +000000009/2:=}'); +Error('\P{Is_Nv=- +000000009/2:=}'); +Expect(1, 3886, '\p{Is_Nv: 00000009/0000000002}', ""); +Expect(0, 3886, '\p{^Is_Nv: 00000009/0000000002}', ""); +Expect(0, 3886, '\P{Is_Nv: 00000009/0000000002}', ""); +Expect(1, 3886, '\P{^Is_Nv: 00000009/0000000002}', ""); +Expect(0, 3885, '\p{Is_Nv: 00000009/0000000002}', ""); +Expect(1, 3885, '\p{^Is_Nv: 00000009/0000000002}', ""); +Expect(1, 3885, '\P{Is_Nv: 00000009/0000000002}', ""); +Expect(0, 3885, '\P{^Is_Nv: 00000009/0000000002}', ""); +Expect(1, 3886, '\p{Is_Nv=4.500}', ""); +Expect(0, 3886, '\p{^Is_Nv=4.500}', ""); +Expect(0, 3886, '\P{Is_Nv=4.500}', ""); +Expect(1, 3886, '\P{^Is_Nv=4.500}', ""); +Expect(0, 3885, '\p{Is_Nv=4.500}', ""); +Expect(1, 3885, '\p{^Is_Nv=4.500}', ""); +Expect(1, 3885, '\P{Is_Nv=4.500}', ""); +Expect(0, 3885, '\P{^Is_Nv=4.500}', ""); +Error('\p{Numeric_Value=__000-000:=40}'); +Error('\P{Numeric_Value=__000-000:=40}'); +Expect(1, 4981, '\p{Numeric_Value=00000000040}', ""); +Expect(0, 4981, '\p{^Numeric_Value=00000000040}', ""); +Expect(0, 4981, '\P{Numeric_Value=00000000040}', ""); +Expect(1, 4981, '\P{^Numeric_Value=00000000040}', ""); +Expect(0, 4980, '\p{Numeric_Value=00000000040}', ""); +Expect(1, 4980, '\p{^Numeric_Value=00000000040}', ""); +Expect(1, 4980, '\P{Numeric_Value=00000000040}', ""); +Expect(0, 4980, '\P{^Numeric_Value=00000000040}', ""); +Error('\p{Nv=_:=+004_0}'); +Error('\P{Nv=_:=+004_0}'); +Expect(1, 4981, '\p{Nv=+0040}', ""); +Expect(0, 4981, '\p{^Nv=+0040}', ""); +Expect(0, 4981, '\P{Nv=+0040}', ""); +Expect(1, 4981, '\P{^Nv=+0040}', ""); +Expect(0, 4980, '\p{Nv=+0040}', ""); +Expect(1, 4980, '\p{^Nv=+0040}', ""); +Expect(1, 4980, '\P{Nv=+0040}', ""); +Expect(0, 4980, '\P{^Nv=+0040}', ""); +Error('\p{Is_Numeric_Value=- +00 00:=00 04 0}'); +Error('\P{Is_Numeric_Value=- +00 00:=00 04 0}'); +Expect(1, 4981, '\p{Is_Numeric_Value=+40}', ""); +Expect(0, 4981, '\p{^Is_Numeric_Value=+40}', ""); +Expect(0, 4981, '\P{Is_Numeric_Value=+40}', ""); +Expect(1, 4981, '\P{^Is_Numeric_Value=+40}', ""); +Expect(0, 4980, '\p{Is_Numeric_Value=+40}', ""); +Expect(1, 4980, '\p{^Is_Numeric_Value=+40}', ""); +Expect(1, 4980, '\P{Is_Numeric_Value=+40}', ""); +Expect(0, 4980, '\P{^Is_Numeric_Value=+40}', ""); +Error('\p{Is_Nv:_/a/00-04 0}'); +Error('\P{Is_Nv:_/a/00-04 0}'); +Expect(1, 4981, '\p{Is_Nv=00000040}', ""); +Expect(0, 4981, '\p{^Is_Nv=00000040}', ""); +Expect(0, 4981, '\P{Is_Nv=00000040}', ""); +Expect(1, 4981, '\P{^Is_Nv=00000040}', ""); +Expect(0, 4980, '\p{Is_Nv=00000040}', ""); +Expect(1, 4980, '\p{^Is_Nv=00000040}', ""); +Expect(1, 4980, '\P{Is_Nv=00000040}', ""); +Expect(0, 4980, '\P{^Is_Nv=00000040}', ""); +Error('\p{Numeric_Value=_:=+3000}'); +Error('\P{Numeric_Value=_:=+3000}'); +Expect(1, 65828, '\p{Numeric_Value=000003000}', ""); +Expect(0, 65828, '\p{^Numeric_Value=000003000}', ""); +Expect(0, 65828, '\P{Numeric_Value=000003000}', ""); +Expect(1, 65828, '\P{^Numeric_Value=000003000}', ""); +Expect(0, 65827, '\p{Numeric_Value=000003000}', ""); +Expect(1, 65827, '\p{^Numeric_Value=000003000}', ""); +Expect(1, 65827, '\P{Numeric_Value=000003000}', ""); +Expect(0, 65827, '\P{^Numeric_Value=000003000}', ""); +Error('\p{Nv=/a/--+0 0_0 0 03000}'); +Error('\P{Nv=/a/--+0 0_0 0 03000}'); +Expect(1, 65828, '\p{Nv=0_0_0_0_0_0_0_0_0_3000}', ""); +Expect(0, 65828, '\p{^Nv=0_0_0_0_0_0_0_0_0_3000}', ""); +Expect(0, 65828, '\P{Nv=0_0_0_0_0_0_0_0_0_3000}', ""); +Expect(1, 65828, '\P{^Nv=0_0_0_0_0_0_0_0_0_3000}', ""); +Expect(0, 65827, '\p{Nv=0_0_0_0_0_0_0_0_0_3000}', ""); +Expect(1, 65827, '\p{^Nv=0_0_0_0_0_0_0_0_0_3000}', ""); +Expect(1, 65827, '\P{Nv=0_0_0_0_0_0_0_0_0_3000}', ""); +Expect(0, 65827, '\P{^Nv=0_0_0_0_0_0_0_0_0_3000}', ""); +Error('\p{Is_Numeric_Value=_-0000-0030 00/a/}'); +Error('\P{Is_Numeric_Value=_-0000-0030 00/a/}'); +Expect(1, 65828, '\p{Is_Numeric_Value=03000}', ""); +Expect(0, 65828, '\p{^Is_Numeric_Value=03000}', ""); +Expect(0, 65828, '\P{Is_Numeric_Value=03000}', ""); +Expect(1, 65828, '\P{^Is_Numeric_Value=03000}', ""); +Expect(0, 65827, '\p{Is_Numeric_Value=03000}', ""); +Expect(1, 65827, '\p{^Is_Numeric_Value=03000}', ""); +Expect(1, 65827, '\P{Is_Numeric_Value=03000}', ""); +Expect(0, 65827, '\P{^Is_Numeric_Value=03000}', ""); +Error('\p{Is_Nv: :=_0000003000}'); +Error('\P{Is_Nv: :=_0000003000}'); +Expect(1, 65828, '\p{Is_Nv=00_00_03_000}', ""); +Expect(0, 65828, '\p{^Is_Nv=00_00_03_000}', ""); +Expect(0, 65828, '\P{Is_Nv=00_00_03_000}', ""); +Expect(1, 65828, '\P{^Is_Nv=00_00_03_000}', ""); +Expect(0, 65827, '\p{Is_Nv=00_00_03_000}', ""); +Expect(1, 65827, '\p{^Is_Nv=00_00_03_000}', ""); +Expect(1, 65827, '\P{Is_Nv=00_00_03_000}', ""); +Expect(0, 65827, '\P{^Is_Nv=00_00_03_000}', ""); +Error('\p{Numeric_Value=/a/0000000800}'); +Error('\P{Numeric_Value=/a/0000000800}'); +Expect(1, 65824, '\p{Numeric_Value=00000800}', ""); +Expect(0, 65824, '\p{^Numeric_Value=00000800}', ""); +Expect(0, 65824, '\P{Numeric_Value=00000800}', ""); +Expect(1, 65824, '\P{^Numeric_Value=00000800}', ""); +Expect(0, 65823, '\p{Numeric_Value=00000800}', ""); +Expect(1, 65823, '\p{^Numeric_Value=00000800}', ""); +Expect(1, 65823, '\P{Numeric_Value=00000800}', ""); +Expect(0, 65823, '\P{^Numeric_Value=00000800}', ""); +Error('\p{Nv= /a/0-0-00_0_800}'); +Error('\P{Nv= /a/0-0-00_0_800}'); +Expect(1, 65824, '\p{Nv=000000800}', ""); +Expect(0, 65824, '\p{^Nv=000000800}', ""); +Expect(0, 65824, '\P{Nv=000000800}', ""); +Expect(1, 65824, '\P{^Nv=000000800}', ""); +Expect(0, 65823, '\p{Nv=000000800}', ""); +Expect(1, 65823, '\p{^Nv=000000800}', ""); +Expect(1, 65823, '\P{Nv=000000800}', ""); +Expect(0, 65823, '\P{^Nv=000000800}', ""); +Error('\p{Is_Numeric_Value: - 0000000800/a/}'); +Error('\P{Is_Numeric_Value: - 0000000800/a/}'); +Expect(1, 65824, '\p{Is_Numeric_Value=0_0_0_0_800}', ""); +Expect(0, 65824, '\p{^Is_Numeric_Value=0_0_0_0_800}', ""); +Expect(0, 65824, '\P{Is_Numeric_Value=0_0_0_0_800}', ""); +Expect(1, 65824, '\P{^Is_Numeric_Value=0_0_0_0_800}', ""); +Expect(0, 65823, '\p{Is_Numeric_Value=0_0_0_0_800}', ""); +Expect(1, 65823, '\p{^Is_Numeric_Value=0_0_0_0_800}', ""); +Expect(1, 65823, '\P{Is_Numeric_Value=0_0_0_0_800}', ""); +Expect(0, 65823, '\P{^Is_Numeric_Value=0_0_0_0_800}', ""); +Error('\p{Is_Nv: _+0:=0 0 0_0-800}'); +Error('\P{Is_Nv: _+0:=0 0 0_0-800}'); +Expect(1, 65824, '\p{Is_Nv=0000000800}', ""); +Expect(0, 65824, '\p{^Is_Nv=0000000800}', ""); +Expect(0, 65824, '\P{Is_Nv=0000000800}', ""); +Expect(1, 65824, '\P{^Is_Nv=0000000800}', ""); +Expect(0, 65823, '\p{Is_Nv=0000000800}', ""); +Expect(1, 65823, '\p{^Is_Nv=0000000800}', ""); +Expect(1, 65823, '\P{Is_Nv=0000000800}', ""); +Expect(0, 65823, '\P{^Is_Nv=0000000800}', ""); +Error('\p{Numeric_Value= 00:=90 00}'); +Error('\P{Numeric_Value= 00:=90 00}'); +Expect(1, 65834, '\p{Numeric_Value=0_0_0_0_0_0_0_0_09000}', ""); +Expect(0, 65834, '\p{^Numeric_Value=0_0_0_0_0_0_0_0_09000}', ""); +Expect(0, 65834, '\P{Numeric_Value=0_0_0_0_0_0_0_0_09000}', ""); +Expect(1, 65834, '\P{^Numeric_Value=0_0_0_0_0_0_0_0_09000}', ""); +Expect(0, 65833, '\p{Numeric_Value=0_0_0_0_0_0_0_0_09000}', ""); +Expect(1, 65833, '\p{^Numeric_Value=0_0_0_0_0_0_0_0_09000}', ""); +Expect(1, 65833, '\P{Numeric_Value=0_0_0_0_0_0_0_0_09000}', ""); +Expect(0, 65833, '\P{^Numeric_Value=0_0_0_0_0_0_0_0_09000}', ""); +Error('\p{Nv=:= 00009000}'); +Error('\P{Nv=:= 00009000}'); +Expect(1, 65834, '\p{Nv:00009000}', ""); +Expect(0, 65834, '\p{^Nv:00009000}', ""); +Expect(0, 65834, '\P{Nv:00009000}', ""); +Expect(1, 65834, '\P{^Nv:00009000}', ""); +Expect(0, 65833, '\p{Nv:00009000}', ""); +Expect(1, 65833, '\p{^Nv:00009000}', ""); +Expect(1, 65833, '\P{Nv:00009000}', ""); +Expect(0, 65833, '\P{^Nv:00009000}', ""); +Error('\p{Is_Numeric_Value=_:=+9-000}'); +Error('\P{Is_Numeric_Value=_:=+9-000}'); +Expect(1, 65834, '\p{Is_Numeric_Value=09000}', ""); +Expect(0, 65834, '\p{^Is_Numeric_Value=09000}', ""); +Expect(0, 65834, '\P{Is_Numeric_Value=09000}', ""); +Expect(1, 65834, '\P{^Is_Numeric_Value=09000}', ""); +Expect(0, 65833, '\p{Is_Numeric_Value=09000}', ""); +Expect(1, 65833, '\p{^Is_Numeric_Value=09000}', ""); +Expect(1, 65833, '\P{Is_Numeric_Value=09000}', ""); +Expect(0, 65833, '\P{^Is_Numeric_Value=09000}', ""); +Error('\p{Is_Nv= 00000 00900/a/0}'); +Error('\P{Is_Nv= 00000 00900/a/0}'); +Expect(1, 65834, '\p{Is_Nv=+000009000}', ""); +Expect(0, 65834, '\p{^Is_Nv=+000009000}', ""); +Expect(0, 65834, '\P{Is_Nv=+000009000}', ""); +Expect(1, 65834, '\P{^Is_Nv=+000009000}', ""); +Expect(0, 65833, '\p{Is_Nv=+000009000}', ""); +Expect(1, 65833, '\p{^Is_Nv=+000009000}', ""); +Expect(1, 65833, '\P{Is_Nv=+000009000}', ""); +Expect(0, 65833, '\P{^Is_Nv=+000009000}', ""); +Error('\p{Numeric_Value: :=0014}'); +Error('\P{Numeric_Value: :=0014}'); +Expect(1, 9325, '\p{Numeric_Value=14}', ""); +Expect(0, 9325, '\p{^Numeric_Value=14}', ""); +Expect(0, 9325, '\P{Numeric_Value=14}', ""); +Expect(1, 9325, '\P{^Numeric_Value=14}', ""); +Expect(0, 9324, '\p{Numeric_Value=14}', ""); +Expect(1, 9324, '\p{^Numeric_Value=14}', ""); +Expect(1, 9324, '\P{Numeric_Value=14}', ""); +Expect(0, 9324, '\P{^Numeric_Value=14}', ""); +Error('\p{Nv= /a/01 4}'); +Error('\P{Nv= /a/01 4}'); +Expect(1, 9325, '\p{Nv=01_4}', ""); +Expect(0, 9325, '\p{^Nv=01_4}', ""); +Expect(0, 9325, '\P{Nv=01_4}', ""); +Expect(1, 9325, '\P{^Nv=01_4}', ""); +Expect(0, 9324, '\p{Nv=01_4}', ""); +Expect(1, 9324, '\p{^Nv=01_4}', ""); +Expect(1, 9324, '\P{Nv=01_4}', ""); +Expect(0, 9324, '\P{^Nv=01_4}', ""); +Error('\p{Is_Numeric_Value=- 000014:=}'); +Error('\P{Is_Numeric_Value=- 000014:=}'); +Expect(1, 9325, '\p{Is_Numeric_Value=0_0_0_0_0_014}', ""); +Expect(0, 9325, '\p{^Is_Numeric_Value=0_0_0_0_0_014}', ""); +Expect(0, 9325, '\P{Is_Numeric_Value=0_0_0_0_0_014}', ""); +Expect(1, 9325, '\P{^Is_Numeric_Value=0_0_0_0_0_014}', ""); +Expect(0, 9324, '\p{Is_Numeric_Value=0_0_0_0_0_014}', ""); +Expect(1, 9324, '\p{^Is_Numeric_Value=0_0_0_0_0_014}', ""); +Expect(1, 9324, '\P{Is_Numeric_Value=0_0_0_0_0_014}', ""); +Expect(0, 9324, '\P{^Is_Numeric_Value=0_0_0_0_0_014}', ""); +Error('\p{Is_Nv=_ +014:=}'); +Error('\P{Is_Nv=_ +014:=}'); +Expect(1, 9325, '\p{Is_Nv=0_0_0_0_0_0_0_0_0_14}', ""); +Expect(0, 9325, '\p{^Is_Nv=0_0_0_0_0_0_0_0_0_14}', ""); +Expect(0, 9325, '\P{Is_Nv=0_0_0_0_0_0_0_0_0_14}', ""); +Expect(1, 9325, '\P{^Is_Nv=0_0_0_0_0_0_0_0_0_14}', ""); +Expect(0, 9324, '\p{Is_Nv=0_0_0_0_0_0_0_0_0_14}', ""); +Expect(1, 9324, '\p{^Is_Nv=0_0_0_0_0_0_0_0_0_14}', ""); +Expect(1, 9324, '\P{Is_Nv=0_0_0_0_0_0_0_0_0_14}', ""); +Expect(0, 9324, '\P{^Is_Nv=0_0_0_0_0_0_0_0_0_14}', ""); +Error('\p{Numeric_Value:-_0 0 0 0:=0_0 6_0000}'); +Error('\P{Numeric_Value:-_0 0 0 0:=0_0 6_0000}'); +Expect(1, 65840, '\p{Numeric_Value: 0_6_0_0_00}', ""); +Expect(0, 65840, '\p{^Numeric_Value: 0_6_0_0_00}', ""); +Expect(0, 65840, '\P{Numeric_Value: 0_6_0_0_00}', ""); +Expect(1, 65840, '\P{^Numeric_Value: 0_6_0_0_00}', ""); +Expect(0, 65839, '\p{Numeric_Value: 0_6_0_0_00}', ""); +Expect(1, 65839, '\p{^Numeric_Value: 0_6_0_0_00}', ""); +Expect(1, 65839, '\P{Numeric_Value: 0_6_0_0_00}', ""); +Expect(0, 65839, '\P{^Numeric_Value: 0_6_0_0_00}', ""); +Error('\p{Nv=:=__000000060000}'); +Error('\P{Nv=:=__000000060000}'); +Expect(1, 65840, '\p{Nv=0000060000}', ""); +Expect(0, 65840, '\p{^Nv=0000060000}', ""); +Expect(0, 65840, '\P{Nv=0000060000}', ""); +Expect(1, 65840, '\P{^Nv=0000060000}', ""); +Expect(0, 65839, '\p{Nv=0000060000}', ""); +Expect(1, 65839, '\p{^Nv=0000060000}', ""); +Expect(1, 65839, '\P{Nv=0000060000}', ""); +Expect(0, 65839, '\P{^Nv=0000060000}', ""); +Error('\p{Is_Numeric_Value= -00-00:=00 0006 0000}'); +Error('\P{Is_Numeric_Value= -00-00:=00 0006 0000}'); +Expect(1, 65840, '\p{Is_Numeric_Value=000060000}', ""); +Expect(0, 65840, '\p{^Is_Numeric_Value=000060000}', ""); +Expect(0, 65840, '\P{Is_Numeric_Value=000060000}', ""); +Expect(1, 65840, '\P{^Is_Numeric_Value=000060000}', ""); +Expect(0, 65839, '\p{Is_Numeric_Value=000060000}', ""); +Expect(1, 65839, '\p{^Is_Numeric_Value=000060000}', ""); +Expect(1, 65839, '\P{Is_Numeric_Value=000060000}', ""); +Expect(0, 65839, '\P{^Is_Numeric_Value=000060000}', ""); +Error('\p{Is_Nv=/a/ 00000000060000}'); +Error('\P{Is_Nv=/a/ 00000000060000}'); +Expect(1, 65840, '\p{Is_Nv=0060000}', ""); +Expect(0, 65840, '\p{^Is_Nv=0060000}', ""); +Expect(0, 65840, '\P{Is_Nv=0060000}', ""); +Expect(1, 65840, '\P{^Is_Nv=0060000}', ""); +Expect(0, 65839, '\p{Is_Nv=0060000}', ""); +Expect(1, 65839, '\p{^Is_Nv=0060000}', ""); +Expect(1, 65839, '\P{Is_Nv=0060000}', ""); +Expect(0, 65839, '\P{^Is_Nv=0060000}', ""); +Error('\p{Numeric_Value=/a/ -049}'); +Error('\P{Numeric_Value=/a/ -049}'); +Expect(1, 12990, '\p{Numeric_Value=000000049}', ""); +Expect(0, 12990, '\p{^Numeric_Value=000000049}', ""); +Expect(0, 12990, '\P{Numeric_Value=000000049}', ""); +Expect(1, 12990, '\P{^Numeric_Value=000000049}', ""); +Expect(0, 12989, '\p{Numeric_Value=000000049}', ""); +Expect(1, 12989, '\p{^Numeric_Value=000000049}', ""); +Expect(1, 12989, '\P{Numeric_Value=000000049}', ""); +Expect(0, 12989, '\P{^Numeric_Value=000000049}', ""); +Error('\p{Nv= /a/049}'); +Error('\P{Nv= /a/049}'); +Expect(1, 12990, '\p{Nv=04_9}', ""); +Expect(0, 12990, '\p{^Nv=04_9}', ""); +Expect(0, 12990, '\P{Nv=04_9}', ""); +Expect(1, 12990, '\P{^Nv=04_9}', ""); +Expect(0, 12989, '\p{Nv=04_9}', ""); +Expect(1, 12989, '\p{^Nv=04_9}', ""); +Expect(1, 12989, '\P{Nv=04_9}', ""); +Expect(0, 12989, '\P{^Nv=04_9}', ""); +Error('\p{Is_Numeric_Value= :=000000049}'); +Error('\P{Is_Numeric_Value= :=000000049}'); +Expect(1, 12990, '\p{Is_Numeric_Value=+04_9}', ""); +Expect(0, 12990, '\p{^Is_Numeric_Value=+04_9}', ""); +Expect(0, 12990, '\P{Is_Numeric_Value=+04_9}', ""); +Expect(1, 12990, '\P{^Is_Numeric_Value=+04_9}', ""); +Expect(0, 12989, '\p{Is_Numeric_Value=+04_9}', ""); +Expect(1, 12989, '\p{^Is_Numeric_Value=+04_9}', ""); +Expect(1, 12989, '\P{Is_Numeric_Value=+04_9}', ""); +Expect(0, 12989, '\P{^Is_Numeric_Value=+04_9}', ""); +Error('\p{Is_Nv= 004 9/a/}'); +Error('\P{Is_Nv= 004 9/a/}'); +Expect(1, 12990, '\p{Is_Nv=4_9}', ""); +Expect(0, 12990, '\p{^Is_Nv=4_9}', ""); +Expect(0, 12990, '\P{Is_Nv=4_9}', ""); +Expect(1, 12990, '\P{^Is_Nv=4_9}', ""); +Expect(0, 12989, '\p{Is_Nv=4_9}', ""); +Expect(1, 12989, '\p{^Is_Nv=4_9}', ""); +Expect(1, 12989, '\P{Is_Nv=4_9}', ""); +Expect(0, 12989, '\P{^Is_Nv=4_9}', ""); +Error('\p{Numeric_Value=_002 4/a/}'); +Error('\P{Numeric_Value=_002 4/a/}'); +Expect(1, 12884, '\p{Numeric_Value=+02_4}', ""); +Expect(0, 12884, '\p{^Numeric_Value=+02_4}', ""); +Expect(0, 12884, '\P{Numeric_Value=+02_4}', ""); +Expect(1, 12884, '\P{^Numeric_Value=+02_4}', ""); +Expect(0, 12883, '\p{Numeric_Value=+02_4}', ""); +Expect(1, 12883, '\p{^Numeric_Value=+02_4}', ""); +Expect(1, 12883, '\P{Numeric_Value=+02_4}', ""); +Expect(0, 12883, '\P{^Numeric_Value=+02_4}', ""); +Error('\p{Nv= 0/a/0 0 0-0 24}'); +Error('\P{Nv= 0/a/0 0 0-0 24}'); +Expect(1, 12884, '\p{Nv=00_00_00_24}', ""); +Expect(0, 12884, '\p{^Nv=00_00_00_24}', ""); +Expect(0, 12884, '\P{Nv=00_00_00_24}', ""); +Expect(1, 12884, '\P{^Nv=00_00_00_24}', ""); +Expect(0, 12883, '\p{Nv=00_00_00_24}', ""); +Expect(1, 12883, '\p{^Nv=00_00_00_24}', ""); +Expect(1, 12883, '\P{Nv=00_00_00_24}', ""); +Expect(0, 12883, '\P{^Nv=00_00_00_24}', ""); +Error('\p{Is_Numeric_Value= :=00 00 00024}'); +Error('\P{Is_Numeric_Value= :=00 00 00024}'); +Expect(1, 12884, '\p{Is_Numeric_Value=00000000024}', ""); +Expect(0, 12884, '\p{^Is_Numeric_Value=00000000024}', ""); +Expect(0, 12884, '\P{Is_Numeric_Value=00000000024}', ""); +Expect(1, 12884, '\P{^Is_Numeric_Value=00000000024}', ""); +Expect(0, 12883, '\p{Is_Numeric_Value=00000000024}', ""); +Expect(1, 12883, '\p{^Is_Numeric_Value=00000000024}', ""); +Expect(1, 12883, '\P{Is_Numeric_Value=00000000024}', ""); +Expect(0, 12883, '\P{^Is_Numeric_Value=00000000024}', ""); +Error('\p{Is_Nv=--00-0000 0002/a/4}'); +Error('\P{Is_Nv=--00-0000 0002/a/4}'); +Expect(1, 12884, '\p{Is_Nv=0000002_4}', ""); +Expect(0, 12884, '\p{^Is_Nv=0000002_4}', ""); +Expect(0, 12884, '\P{Is_Nv=0000002_4}', ""); +Expect(1, 12884, '\P{^Is_Nv=0000002_4}', ""); +Expect(0, 12883, '\p{Is_Nv=0000002_4}', ""); +Expect(1, 12883, '\p{^Is_Nv=0000002_4}', ""); +Expect(1, 12883, '\P{Is_Nv=0000002_4}', ""); +Expect(0, 12883, '\P{^Is_Nv=0000002_4}', ""); +Error('\p{Numeric_Value=:=__+0001/00000004}'); +Error('\P{Numeric_Value=:=__+0001/00000004}'); +Expect(1, 3443, '\p{Numeric_Value=+00001/04}', ""); +Expect(0, 3443, '\p{^Numeric_Value=+00001/04}', ""); +Expect(0, 3443, '\P{Numeric_Value=+00001/04}', ""); +Expect(1, 3443, '\P{^Numeric_Value=+00001/04}', ""); +Expect(0, 7, '\p{Numeric_Value=+00001/04}', ""); +Expect(1, 7, '\p{^Numeric_Value=+00001/04}', ""); +Expect(1, 7, '\P{Numeric_Value=+00001/04}', ""); +Expect(0, 7, '\P{^Numeric_Value=+00001/04}', ""); +Expect(1, 3443, '\p{Numeric_Value=0.250}', ""); +Expect(0, 3443, '\p{^Numeric_Value=0.250}', ""); +Expect(0, 3443, '\P{Numeric_Value=0.250}', ""); +Expect(1, 3443, '\P{^Numeric_Value=0.250}', ""); +Expect(0, 7, '\p{Numeric_Value=0.250}', ""); +Expect(1, 7, '\p{^Numeric_Value=0.250}', ""); +Expect(1, 7, '\P{Numeric_Value=0.250}', ""); +Expect(0, 7, '\P{^Numeric_Value=0.250}', ""); +Error('\p{Nv=/a/- +0001/00000004}'); +Error('\P{Nv=/a/- +0001/00000004}'); +Expect(1, 3443, '\p{Nv=01/000000004}', ""); +Expect(0, 3443, '\p{^Nv=01/000000004}', ""); +Expect(0, 3443, '\P{Nv=01/000000004}', ""); +Expect(1, 3443, '\P{^Nv=01/000000004}', ""); +Expect(0, 7, '\p{Nv=01/000000004}', ""); +Expect(1, 7, '\p{^Nv=01/000000004}', ""); +Expect(1, 7, '\P{Nv=01/000000004}', ""); +Expect(0, 7, '\P{^Nv=01/000000004}', ""); +Expect(1, 3443, '\p{Nv=0.250}', ""); +Expect(0, 3443, '\p{^Nv=0.250}', ""); +Expect(0, 3443, '\P{Nv=0.250}', ""); +Expect(1, 3443, '\P{^Nv=0.250}', ""); +Expect(0, 7, '\p{Nv=0.250}', ""); +Expect(1, 7, '\p{^Nv=0.250}', ""); +Expect(1, 7, '\P{Nv=0.250}', ""); +Expect(0, 7, '\P{^Nv=0.250}', ""); +Error('\p{Is_Numeric_Value=-/a/00001/0000000004}'); +Error('\P{Is_Numeric_Value=-/a/00001/0000000004}'); +Expect(1, 3443, '\p{Is_Numeric_Value=0000000001/04}', ""); +Expect(0, 3443, '\p{^Is_Numeric_Value=0000000001/04}', ""); +Expect(0, 3443, '\P{Is_Numeric_Value=0000000001/04}', ""); +Expect(1, 3443, '\P{^Is_Numeric_Value=0000000001/04}', ""); +Expect(0, 7, '\p{Is_Numeric_Value=0000000001/04}', ""); +Expect(1, 7, '\p{^Is_Numeric_Value=0000000001/04}', ""); +Expect(1, 7, '\P{Is_Numeric_Value=0000000001/04}', ""); +Expect(0, 7, '\P{^Is_Numeric_Value=0000000001/04}', ""); +Expect(1, 3443, '\p{Is_Numeric_Value=0.250}', ""); +Expect(0, 3443, '\p{^Is_Numeric_Value=0.250}', ""); +Expect(0, 3443, '\P{Is_Numeric_Value=0.250}', ""); +Expect(1, 3443, '\P{^Is_Numeric_Value=0.250}', ""); +Expect(0, 7, '\p{Is_Numeric_Value=0.250}', ""); +Expect(1, 7, '\p{^Is_Numeric_Value=0.250}', ""); +Expect(1, 7, '\P{Is_Numeric_Value=0.250}', ""); +Expect(0, 7, '\P{^Is_Numeric_Value=0.250}', ""); +Error('\p{Is_Nv=/a/__000001/4}'); +Error('\P{Is_Nv=/a/__000001/4}'); +Expect(1, 3443, '\p{Is_Nv=00000001/004}', ""); +Expect(0, 3443, '\p{^Is_Nv=00000001/004}', ""); +Expect(0, 3443, '\P{Is_Nv=00000001/004}', ""); +Expect(1, 3443, '\P{^Is_Nv=00000001/004}', ""); +Expect(0, 7, '\p{Is_Nv=00000001/004}', ""); +Expect(1, 7, '\p{^Is_Nv=00000001/004}', ""); +Expect(1, 7, '\P{Is_Nv=00000001/004}', ""); +Expect(0, 7, '\P{^Is_Nv=00000001/004}', ""); +Expect(1, 3443, '\p{Is_Nv=0.250}', ""); +Expect(0, 3443, '\p{^Is_Nv=0.250}', ""); +Expect(0, 3443, '\P{Is_Nv=0.250}', ""); +Expect(1, 3443, '\P{^Is_Nv=0.250}', ""); +Expect(0, 7, '\p{Is_Nv=0.250}', ""); +Expect(1, 7, '\p{^Is_Nv=0.250}', ""); +Expect(1, 7, '\P{Is_Nv=0.250}', ""); +Expect(0, 7, '\P{^Is_Nv=0.250}', ""); +Error('\p{Numeric_Value=_ 090000/a/}'); +Error('\P{Numeric_Value=_ 090000/a/}'); +Expect(1, 65843, '\p{Numeric_Value=0_0_9_0_0_00}', ""); +Expect(0, 65843, '\p{^Numeric_Value=0_0_9_0_0_00}', ""); +Expect(0, 65843, '\P{Numeric_Value=0_0_9_0_0_00}', ""); +Expect(1, 65843, '\P{^Numeric_Value=0_0_9_0_0_00}', ""); +Expect(0, 65842, '\p{Numeric_Value=0_0_9_0_0_00}', ""); +Expect(1, 65842, '\p{^Numeric_Value=0_0_9_0_0_00}', ""); +Expect(1, 65842, '\P{Numeric_Value=0_0_9_0_0_00}', ""); +Expect(0, 65842, '\P{^Numeric_Value=0_0_9_0_0_00}', ""); +Error('\p{Nv= :=0000090000}'); +Error('\P{Nv= :=0000090000}'); +Expect(1, 65843, '\p{Nv=+90000}', ""); +Expect(0, 65843, '\p{^Nv=+90000}', ""); +Expect(0, 65843, '\P{Nv=+90000}', ""); +Expect(1, 65843, '\P{^Nv=+90000}', ""); +Expect(0, 65842, '\p{Nv=+90000}', ""); +Expect(1, 65842, '\p{^Nv=+90000}', ""); +Expect(1, 65842, '\P{Nv=+90000}', ""); +Expect(0, 65842, '\P{^Nv=+90000}', ""); +Error('\p{Is_Numeric_Value=- 0 0:=00-0 009-0 0_00}'); +Error('\P{Is_Numeric_Value=- 0 0:=00-0 009-0 0_00}'); +Expect(1, 65843, '\p{Is_Numeric_Value=+00090000}', ""); +Expect(0, 65843, '\p{^Is_Numeric_Value=+00090000}', ""); +Expect(0, 65843, '\P{Is_Numeric_Value=+00090000}', ""); +Expect(1, 65843, '\P{^Is_Numeric_Value=+00090000}', ""); +Expect(0, 65842, '\p{Is_Numeric_Value=+00090000}', ""); +Expect(1, 65842, '\p{^Is_Numeric_Value=+00090000}', ""); +Expect(1, 65842, '\P{Is_Numeric_Value=+00090000}', ""); +Expect(0, 65842, '\P{^Is_Numeric_Value=+00090000}', ""); +Error('\p{Is_Nv=:=--00090000}'); +Error('\P{Is_Nv=:=--00090000}'); +Expect(1, 65843, '\p{Is_Nv=0_0_0_0_0_0_0_0_90000}', ""); +Expect(0, 65843, '\p{^Is_Nv=0_0_0_0_0_0_0_0_90000}', ""); +Expect(0, 65843, '\P{Is_Nv=0_0_0_0_0_0_0_0_90000}', ""); +Expect(1, 65843, '\P{^Is_Nv=0_0_0_0_0_0_0_0_90000}', ""); +Expect(0, 65842, '\p{Is_Nv=0_0_0_0_0_0_0_0_90000}', ""); +Expect(1, 65842, '\p{^Is_Nv=0_0_0_0_0_0_0_0_90000}', ""); +Expect(1, 65842, '\P{Is_Nv=0_0_0_0_0_0_0_0_90000}', ""); +Expect(0, 65842, '\P{^Is_Nv=0_0_0_0_0_0_0_0_90000}', ""); +Error('\p{Numeric_Value=:= 000000050000}'); +Error('\P{Numeric_Value=:= 000000050000}'); +Expect(1, 8583, '\p{Numeric_Value=0000_0000_5000_0}', ""); +Expect(0, 8583, '\p{^Numeric_Value=0000_0000_5000_0}', ""); +Expect(0, 8583, '\P{Numeric_Value=0000_0000_5000_0}', ""); +Expect(1, 8583, '\P{^Numeric_Value=0000_0000_5000_0}', ""); +Expect(0, 8582, '\p{Numeric_Value=0000_0000_5000_0}', ""); +Expect(1, 8582, '\p{^Numeric_Value=0000_0000_5000_0}', ""); +Expect(1, 8582, '\P{Numeric_Value=0000_0000_5000_0}', ""); +Expect(0, 8582, '\P{^Numeric_Value=0000_0000_5000_0}', ""); +Error('\p{Nv=- 05/a/00-00}'); +Error('\P{Nv=- 05/a/00-00}'); +Expect(1, 8583, '\p{Nv=+0_0_5_0_0_00}', ""); +Expect(0, 8583, '\p{^Nv=+0_0_5_0_0_00}', ""); +Expect(0, 8583, '\P{Nv=+0_0_5_0_0_00}', ""); +Expect(1, 8583, '\P{^Nv=+0_0_5_0_0_00}', ""); +Expect(0, 8582, '\p{Nv=+0_0_5_0_0_00}', ""); +Expect(1, 8582, '\p{^Nv=+0_0_5_0_0_00}', ""); +Expect(1, 8582, '\P{Nv=+0_0_5_0_0_00}', ""); +Expect(0, 8582, '\P{^Nv=+0_0_5_0_0_00}', ""); +Error('\p{Is_Numeric_Value= 0:=0-0 0-0 0 0 0 05_0 0_00}'); +Error('\P{Is_Numeric_Value= 0:=0-0 0-0 0 0 0 05_0 0_00}'); +Expect(1, 8583, '\p{Is_Numeric_Value=50000}', ""); +Expect(0, 8583, '\p{^Is_Numeric_Value=50000}', ""); +Expect(0, 8583, '\P{Is_Numeric_Value=50000}', ""); +Expect(1, 8583, '\P{^Is_Numeric_Value=50000}', ""); +Expect(0, 8582, '\p{Is_Numeric_Value=50000}', ""); +Expect(1, 8582, '\p{^Is_Numeric_Value=50000}', ""); +Expect(1, 8582, '\P{Is_Numeric_Value=50000}', ""); +Expect(0, 8582, '\P{^Is_Numeric_Value=50000}', ""); +Error('\p{Is_Nv: -/a/5_0 0_00}'); +Error('\P{Is_Nv: -/a/5_0 0_00}'); +Expect(1, 8583, '\p{Is_Nv=050000}', ""); +Expect(0, 8583, '\p{^Is_Nv=050000}', ""); +Expect(0, 8583, '\P{Is_Nv=050000}', ""); +Expect(1, 8583, '\P{^Is_Nv=050000}', ""); +Expect(0, 8582, '\p{Is_Nv=050000}', ""); +Expect(1, 8582, '\p{^Is_Nv=050000}', ""); +Expect(1, 8582, '\P{Is_Nv=050000}', ""); +Expect(0, 8582, '\P{^Is_Nv=050000}', ""); +Error('\p{Numeric_Value= -+000000040000:=}'); +Error('\P{Numeric_Value= -+000000040000:=}'); +Expect(1, 65838, '\p{Numeric_Value=0_0_0_0_4_0_0_00}', ""); +Expect(0, 65838, '\p{^Numeric_Value=0_0_0_0_4_0_0_00}', ""); +Expect(0, 65838, '\P{Numeric_Value=0_0_0_0_4_0_0_00}', ""); +Expect(1, 65838, '\P{^Numeric_Value=0_0_0_0_4_0_0_00}', ""); +Expect(0, 65837, '\p{Numeric_Value=0_0_0_0_4_0_0_00}', ""); +Expect(1, 65837, '\p{^Numeric_Value=0_0_0_0_4_0_0_00}', ""); +Expect(1, 65837, '\P{Numeric_Value=0_0_0_0_4_0_0_00}', ""); +Expect(0, 65837, '\P{^Numeric_Value=0_0_0_0_4_0_0_00}', ""); +Error('\p{Nv: /a/-40000}'); +Error('\P{Nv: /a/-40000}'); +Expect(1, 65838, '\p{Nv=+0000000040000}', ""); +Expect(0, 65838, '\p{^Nv=+0000000040000}', ""); +Expect(0, 65838, '\P{Nv=+0000000040000}', ""); +Expect(1, 65838, '\P{^Nv=+0000000040000}', ""); +Expect(0, 65837, '\p{Nv=+0000000040000}', ""); +Expect(1, 65837, '\p{^Nv=+0000000040000}', ""); +Expect(1, 65837, '\P{Nv=+0000000040000}', ""); +Expect(0, 65837, '\P{^Nv=+0000000040000}', ""); +Error('\p{Is_Numeric_Value=/a/ 000040000}'); +Error('\P{Is_Numeric_Value=/a/ 000040000}'); +Expect(1, 65838, '\p{Is_Numeric_Value=+00000040000}', ""); +Expect(0, 65838, '\p{^Is_Numeric_Value=+00000040000}', ""); +Expect(0, 65838, '\P{Is_Numeric_Value=+00000040000}', ""); +Expect(1, 65838, '\P{^Is_Numeric_Value=+00000040000}', ""); +Expect(0, 65837, '\p{Is_Numeric_Value=+00000040000}', ""); +Expect(1, 65837, '\p{^Is_Numeric_Value=+00000040000}', ""); +Expect(1, 65837, '\P{Is_Numeric_Value=+00000040000}', ""); +Expect(0, 65837, '\P{^Is_Numeric_Value=+00000040000}', ""); +Error('\p{Is_Nv: _:=0 0 4-0 000}'); +Error('\P{Is_Nv: _:=0 0 4-0 000}'); +Expect(1, 65838, '\p{Is_Nv=0_0_0_0_0_0_0_4_0_0_00}', ""); +Expect(0, 65838, '\p{^Is_Nv=0_0_0_0_0_0_0_4_0_0_00}', ""); +Expect(0, 65838, '\P{Is_Nv=0_0_0_0_0_0_0_4_0_0_00}', ""); +Expect(1, 65838, '\P{^Is_Nv=0_0_0_0_0_0_0_4_0_0_00}', ""); +Expect(0, 65837, '\p{Is_Nv=0_0_0_0_0_0_0_4_0_0_00}', ""); +Expect(1, 65837, '\p{^Is_Nv=0_0_0_0_0_0_0_4_0_0_00}', ""); +Expect(1, 65837, '\P{Is_Nv=0_0_0_0_0_0_0_4_0_0_00}', ""); +Expect(0, 65837, '\P{^Is_Nv=0_0_0_0_0_0_0_4_0_0_00}', ""); +Error('\p{Numeric_Value=__000000001/002:=}'); +Error('\P{Numeric_Value=__000000001/002:=}'); +Expect(1, 3444, '\p{Numeric_Value=001/0000000002}', ""); +Expect(0, 3444, '\p{^Numeric_Value=001/0000000002}', ""); +Expect(0, 3444, '\P{Numeric_Value=001/0000000002}', ""); +Expect(1, 3444, '\P{^Numeric_Value=001/0000000002}', ""); +Expect(0, 7, '\p{Numeric_Value=001/0000000002}', ""); +Expect(1, 7, '\p{^Numeric_Value=001/0000000002}', ""); +Expect(1, 7, '\P{Numeric_Value=001/0000000002}', ""); +Expect(0, 7, '\P{^Numeric_Value=001/0000000002}', ""); +Expect(1, 3444, '\p{Numeric_Value=0.500}', ""); +Expect(0, 3444, '\p{^Numeric_Value=0.500}', ""); +Expect(0, 3444, '\P{Numeric_Value=0.500}', ""); +Expect(1, 3444, '\P{^Numeric_Value=0.500}', ""); +Expect(0, 7, '\p{Numeric_Value=0.500}', ""); +Expect(1, 7, '\p{^Numeric_Value=0.500}', ""); +Expect(1, 7, '\P{Numeric_Value=0.500}', ""); +Expect(0, 7, '\P{^Numeric_Value=0.500}', ""); +Error('\p{Nv=/a/00000001/0000000002}'); +Error('\P{Nv=/a/00000001/0000000002}'); +Expect(1, 3444, '\p{Nv=+1/0000002}', ""); +Expect(0, 3444, '\p{^Nv=+1/0000002}', ""); +Expect(0, 3444, '\P{Nv=+1/0000002}', ""); +Expect(1, 3444, '\P{^Nv=+1/0000002}', ""); +Expect(0, 7, '\p{Nv=+1/0000002}', ""); +Expect(1, 7, '\p{^Nv=+1/0000002}', ""); +Expect(1, 7, '\P{Nv=+1/0000002}', ""); +Expect(0, 7, '\P{^Nv=+1/0000002}', ""); +Expect(1, 3444, '\p{Nv=0.500}', ""); +Expect(0, 3444, '\p{^Nv=0.500}', ""); +Expect(0, 3444, '\P{Nv=0.500}', ""); +Expect(1, 3444, '\P{^Nv=0.500}', ""); +Expect(0, 7, '\p{Nv=0.500}', ""); +Expect(1, 7, '\p{^Nv=0.500}', ""); +Expect(1, 7, '\P{Nv=0.500}', ""); +Expect(0, 7, '\P{^Nv=0.500}', ""); +Error('\p{Is_Numeric_Value: :=00001/0000000002}'); +Error('\P{Is_Numeric_Value: :=00001/0000000002}'); +Expect(1, 3444, '\p{Is_Numeric_Value=+0001/000000002}', ""); +Expect(0, 3444, '\p{^Is_Numeric_Value=+0001/000000002}', ""); +Expect(0, 3444, '\P{Is_Numeric_Value=+0001/000000002}', ""); +Expect(1, 3444, '\P{^Is_Numeric_Value=+0001/000000002}', ""); +Expect(0, 7, '\p{Is_Numeric_Value=+0001/000000002}', ""); +Expect(1, 7, '\p{^Is_Numeric_Value=+0001/000000002}', ""); +Expect(1, 7, '\P{Is_Numeric_Value=+0001/000000002}', ""); +Expect(0, 7, '\P{^Is_Numeric_Value=+0001/000000002}', ""); +Expect(1, 3444, '\p{Is_Numeric_Value=0.500}', ""); +Expect(0, 3444, '\p{^Is_Numeric_Value=0.500}', ""); +Expect(0, 3444, '\P{Is_Numeric_Value=0.500}', ""); +Expect(1, 3444, '\P{^Is_Numeric_Value=0.500}', ""); +Expect(0, 7, '\p{Is_Numeric_Value=0.500}', ""); +Expect(1, 7, '\p{^Is_Numeric_Value=0.500}', ""); +Expect(1, 7, '\P{Is_Numeric_Value=0.500}', ""); +Expect(0, 7, '\P{^Is_Numeric_Value=0.500}', ""); +Error('\p{Is_Nv= :=+0000000001/002}'); +Error('\P{Is_Nv= :=+0000000001/002}'); +Expect(1, 3444, '\p{Is_Nv=0000001/0000002}', ""); +Expect(0, 3444, '\p{^Is_Nv=0000001/0000002}', ""); +Expect(0, 3444, '\P{Is_Nv=0000001/0000002}', ""); +Expect(1, 3444, '\P{^Is_Nv=0000001/0000002}', ""); +Expect(0, 7, '\p{Is_Nv=0000001/0000002}', ""); +Expect(1, 7, '\p{^Is_Nv=0000001/0000002}', ""); +Expect(1, 7, '\P{Is_Nv=0000001/0000002}', ""); +Expect(0, 7, '\P{^Is_Nv=0000001/0000002}', ""); +Expect(1, 3444, '\p{Is_Nv=0.500}', ""); +Expect(0, 3444, '\p{^Is_Nv=0.500}', ""); +Expect(0, 3444, '\P{Is_Nv=0.500}', ""); +Expect(1, 3444, '\P{^Is_Nv=0.500}', ""); +Expect(0, 7, '\p{Is_Nv=0.500}', ""); +Expect(1, 7, '\p{^Is_Nv=0.500}', ""); +Expect(1, 7, '\P{Is_Nv=0.500}', ""); +Expect(0, 7, '\P{^Is_Nv=0.500}', ""); +Error('\p{Numeric_Value=__0007000:=}'); +Error('\P{Numeric_Value=__0007000:=}'); +Expect(1, 65832, '\p{Numeric_Value=+00_00_00_00_7000}', ""); +Expect(0, 65832, '\p{^Numeric_Value=+00_00_00_00_7000}', ""); +Expect(0, 65832, '\P{Numeric_Value=+00_00_00_00_7000}', ""); +Expect(1, 65832, '\P{^Numeric_Value=+00_00_00_00_7000}', ""); +Expect(0, 65831, '\p{Numeric_Value=+00_00_00_00_7000}', ""); +Expect(1, 65831, '\p{^Numeric_Value=+00_00_00_00_7000}', ""); +Expect(1, 65831, '\P{Numeric_Value=+00_00_00_00_7000}', ""); +Expect(0, 65831, '\P{^Numeric_Value=+00_00_00_00_7000}', ""); +Error('\p{Nv=/a/ 007000}'); +Error('\P{Nv=/a/ 007000}'); +Expect(1, 65832, '\p{Nv=+00_00_00_70_00}', ""); +Expect(0, 65832, '\p{^Nv=+00_00_00_70_00}', ""); +Expect(0, 65832, '\P{Nv=+00_00_00_70_00}', ""); +Expect(1, 65832, '\P{^Nv=+00_00_00_70_00}', ""); +Expect(0, 65831, '\p{Nv=+00_00_00_70_00}', ""); +Expect(1, 65831, '\p{^Nv=+00_00_00_70_00}', ""); +Expect(1, 65831, '\P{Nv=+00_00_00_70_00}', ""); +Expect(0, 65831, '\P{^Nv=+00_00_00_70_00}', ""); +Error('\p{Is_Numeric_Value= -+0 0:=07-0-00}'); +Error('\P{Is_Numeric_Value= -+0 0:=07-0-00}'); +Expect(1, 65832, '\p{Is_Numeric_Value=0_0_0_0_0_0_007000}', ""); +Expect(0, 65832, '\p{^Is_Numeric_Value=0_0_0_0_0_0_007000}', ""); +Expect(0, 65832, '\P{Is_Numeric_Value=0_0_0_0_0_0_007000}', ""); +Expect(1, 65832, '\P{^Is_Numeric_Value=0_0_0_0_0_0_007000}', ""); +Expect(0, 65831, '\p{Is_Numeric_Value=0_0_0_0_0_0_007000}', ""); +Expect(1, 65831, '\p{^Is_Numeric_Value=0_0_0_0_0_0_007000}', ""); +Expect(1, 65831, '\P{Is_Numeric_Value=0_0_0_0_0_0_007000}', ""); +Expect(0, 65831, '\P{^Is_Numeric_Value=0_0_0_0_0_0_007000}', ""); +Error('\p{Is_Nv=/a/ 00000007000}'); +Error('\P{Is_Nv=/a/ 00000007000}'); +Expect(1, 65832, '\p{Is_Nv=00_00_00_07_00_0}', ""); +Expect(0, 65832, '\p{^Is_Nv=00_00_00_07_00_0}', ""); +Expect(0, 65832, '\P{Is_Nv=00_00_00_07_00_0}', ""); +Expect(1, 65832, '\P{^Is_Nv=00_00_00_07_00_0}', ""); +Expect(0, 65831, '\p{Is_Nv=00_00_00_07_00_0}', ""); +Expect(1, 65831, '\p{^Is_Nv=00_00_00_07_00_0}', ""); +Expect(1, 65831, '\P{Is_Nv=00_00_00_07_00_0}', ""); +Expect(0, 65831, '\P{^Is_Nv=00_00_00_07_00_0}', ""); +Error('\p{Numeric_Value=- 000003/00000005:=}'); +Error('\P{Numeric_Value=- 000003/00000005:=}'); +Expect(1, 8535, '\p{Numeric_Value=+00000003/5}', ""); +Expect(0, 8535, '\p{^Numeric_Value=+00000003/5}', ""); +Expect(0, 8535, '\P{Numeric_Value=+00000003/5}', ""); +Expect(1, 8535, '\P{^Numeric_Value=+00000003/5}', ""); +Expect(0, 8534, '\p{Numeric_Value=+00000003/5}', ""); +Expect(1, 8534, '\p{^Numeric_Value=+00000003/5}', ""); +Expect(1, 8534, '\P{Numeric_Value=+00000003/5}', ""); +Expect(0, 8534, '\P{^Numeric_Value=+00000003/5}', ""); +Expect(1, 8535, '\p{Numeric_Value=0.600}', ""); +Expect(0, 8535, '\p{^Numeric_Value=0.600}', ""); +Expect(0, 8535, '\P{Numeric_Value=0.600}', ""); +Expect(1, 8535, '\P{^Numeric_Value=0.600}', ""); +Expect(0, 8534, '\p{Numeric_Value=0.600}', ""); +Expect(1, 8534, '\p{^Numeric_Value=0.600}', ""); +Expect(1, 8534, '\P{Numeric_Value=0.600}', ""); +Expect(0, 8534, '\P{^Numeric_Value=0.600}', ""); +Error('\p{Nv=/a/ +003/000000005}'); +Error('\P{Nv=/a/ +003/000000005}'); +Expect(1, 8535, '\p{Nv=+03/00000005}', ""); +Expect(0, 8535, '\p{^Nv=+03/00000005}', ""); +Expect(0, 8535, '\P{Nv=+03/00000005}', ""); +Expect(1, 8535, '\P{^Nv=+03/00000005}', ""); +Expect(0, 8534, '\p{Nv=+03/00000005}', ""); +Expect(1, 8534, '\p{^Nv=+03/00000005}', ""); +Expect(1, 8534, '\P{Nv=+03/00000005}', ""); +Expect(0, 8534, '\P{^Nv=+03/00000005}', ""); +Expect(1, 8535, '\p{Nv=0.600}', ""); +Expect(0, 8535, '\p{^Nv=0.600}', ""); +Expect(0, 8535, '\P{Nv=0.600}', ""); +Expect(1, 8535, '\P{^Nv=0.600}', ""); +Expect(0, 8534, '\p{Nv=0.600}', ""); +Expect(1, 8534, '\p{^Nv=0.600}', ""); +Expect(1, 8534, '\P{Nv=0.600}', ""); +Expect(0, 8534, '\P{^Nv=0.600}', ""); +Error('\p{Is_Numeric_Value= /a/00000003/00005}'); +Error('\P{Is_Numeric_Value= /a/00000003/00005}'); +Expect(1, 8535, '\p{Is_Numeric_Value=00003/0000005}', ""); +Expect(0, 8535, '\p{^Is_Numeric_Value=00003/0000005}', ""); +Expect(0, 8535, '\P{Is_Numeric_Value=00003/0000005}', ""); +Expect(1, 8535, '\P{^Is_Numeric_Value=00003/0000005}', ""); +Expect(0, 8534, '\p{Is_Numeric_Value=00003/0000005}', ""); +Expect(1, 8534, '\p{^Is_Numeric_Value=00003/0000005}', ""); +Expect(1, 8534, '\P{Is_Numeric_Value=00003/0000005}', ""); +Expect(0, 8534, '\P{^Is_Numeric_Value=00003/0000005}', ""); +Expect(1, 8535, '\p{Is_Numeric_Value=0.600}', ""); +Expect(0, 8535, '\p{^Is_Numeric_Value=0.600}', ""); +Expect(0, 8535, '\P{Is_Numeric_Value=0.600}', ""); +Expect(1, 8535, '\P{^Is_Numeric_Value=0.600}', ""); +Expect(0, 8534, '\p{Is_Numeric_Value=0.600}', ""); +Expect(1, 8534, '\p{^Is_Numeric_Value=0.600}', ""); +Expect(1, 8534, '\P{Is_Numeric_Value=0.600}', ""); +Expect(0, 8534, '\P{^Is_Numeric_Value=0.600}', ""); +Error('\p{Is_Nv=:= 0003/0005}'); +Error('\P{Is_Nv=:= 0003/0005}'); +Expect(1, 8535, '\p{Is_Nv: +00000003/0000005}', ""); +Expect(0, 8535, '\p{^Is_Nv: +00000003/0000005}', ""); +Expect(0, 8535, '\P{Is_Nv: +00000003/0000005}', ""); +Expect(1, 8535, '\P{^Is_Nv: +00000003/0000005}', ""); +Expect(0, 8534, '\p{Is_Nv: +00000003/0000005}', ""); +Expect(1, 8534, '\p{^Is_Nv: +00000003/0000005}', ""); +Expect(1, 8534, '\P{Is_Nv: +00000003/0000005}', ""); +Expect(0, 8534, '\P{^Is_Nv: +00000003/0000005}', ""); +Expect(1, 8535, '\p{Is_Nv=0.600}', ""); +Expect(0, 8535, '\p{^Is_Nv=0.600}', ""); +Expect(0, 8535, '\P{Is_Nv=0.600}', ""); +Expect(1, 8535, '\P{^Is_Nv=0.600}', ""); +Expect(0, 8534, '\p{Is_Nv=0.600}', ""); +Expect(1, 8534, '\p{^Is_Nv=0.600}', ""); +Expect(1, 8534, '\P{Is_Nv=0.600}', ""); +Expect(0, 8534, '\P{^Is_Nv=0.600}', ""); +Error('\p{Numeric_Value= -00017/02/a/}'); +Error('\P{Numeric_Value= -00017/02/a/}'); +Expect(1, 3890, '\p{Numeric_Value=000000017/0002}', ""); +Expect(0, 3890, '\p{^Numeric_Value=000000017/0002}', ""); +Expect(0, 3890, '\P{Numeric_Value=000000017/0002}', ""); +Expect(1, 3890, '\P{^Numeric_Value=000000017/0002}', ""); +Expect(0, 3889, '\p{Numeric_Value=000000017/0002}', ""); +Expect(1, 3889, '\p{^Numeric_Value=000000017/0002}', ""); +Expect(1, 3889, '\P{Numeric_Value=000000017/0002}', ""); +Expect(0, 3889, '\P{^Numeric_Value=000000017/0002}', ""); +Expect(1, 3890, '\p{Numeric_Value: 8.500}', ""); +Expect(0, 3890, '\p{^Numeric_Value: 8.500}', ""); +Expect(0, 3890, '\P{Numeric_Value: 8.500}', ""); +Expect(1, 3890, '\P{^Numeric_Value: 8.500}', ""); +Expect(0, 3889, '\p{Numeric_Value: 8.500}', ""); +Expect(1, 3889, '\p{^Numeric_Value: 8.500}', ""); +Expect(1, 3889, '\P{Numeric_Value: 8.500}', ""); +Expect(0, 3889, '\P{^Numeric_Value: 8.500}', ""); +Error('\p{Nv= 0017/02:=}'); +Error('\P{Nv= 0017/02:=}'); +Expect(1, 3890, '\p{Nv=0017/00002}', ""); +Expect(0, 3890, '\p{^Nv=0017/00002}', ""); +Expect(0, 3890, '\P{Nv=0017/00002}', ""); +Expect(1, 3890, '\P{^Nv=0017/00002}', ""); +Expect(0, 3889, '\p{Nv=0017/00002}', ""); +Expect(1, 3889, '\p{^Nv=0017/00002}', ""); +Expect(1, 3889, '\P{Nv=0017/00002}', ""); +Expect(0, 3889, '\P{^Nv=0017/00002}', ""); +Expect(1, 3890, '\p{Nv=8.500}', ""); +Expect(0, 3890, '\p{^Nv=8.500}', ""); +Expect(0, 3890, '\P{Nv=8.500}', ""); +Expect(1, 3890, '\P{^Nv=8.500}', ""); +Expect(0, 3889, '\p{Nv=8.500}', ""); +Expect(1, 3889, '\p{^Nv=8.500}', ""); +Expect(1, 3889, '\P{Nv=8.500}', ""); +Expect(0, 3889, '\P{^Nv=8.500}', ""); +Error('\p{Is_Numeric_Value=/a/ +017/0000002}'); +Error('\P{Is_Numeric_Value=/a/ +017/0000002}'); +Expect(1, 3890, '\p{Is_Numeric_Value=+000017/00002}', ""); +Expect(0, 3890, '\p{^Is_Numeric_Value=+000017/00002}', ""); +Expect(0, 3890, '\P{Is_Numeric_Value=+000017/00002}', ""); +Expect(1, 3890, '\P{^Is_Numeric_Value=+000017/00002}', ""); +Expect(0, 3889, '\p{Is_Numeric_Value=+000017/00002}', ""); +Expect(1, 3889, '\p{^Is_Numeric_Value=+000017/00002}', ""); +Expect(1, 3889, '\P{Is_Numeric_Value=+000017/00002}', ""); +Expect(0, 3889, '\P{^Is_Numeric_Value=+000017/00002}', ""); +Expect(1, 3890, '\p{Is_Numeric_Value=8.500}', ""); +Expect(0, 3890, '\p{^Is_Numeric_Value=8.500}', ""); +Expect(0, 3890, '\P{Is_Numeric_Value=8.500}', ""); +Expect(1, 3890, '\P{^Is_Numeric_Value=8.500}', ""); +Expect(0, 3889, '\p{Is_Numeric_Value=8.500}', ""); +Expect(1, 3889, '\p{^Is_Numeric_Value=8.500}', ""); +Expect(1, 3889, '\P{Is_Numeric_Value=8.500}', ""); +Expect(0, 3889, '\P{^Is_Numeric_Value=8.500}', ""); +Error('\p{Is_Nv=_000000017/000002:=}'); +Error('\P{Is_Nv=_000000017/000002:=}'); +Expect(1, 3890, '\p{Is_Nv=017/002}', ""); +Expect(0, 3890, '\p{^Is_Nv=017/002}', ""); +Expect(0, 3890, '\P{Is_Nv=017/002}', ""); +Expect(1, 3890, '\P{^Is_Nv=017/002}', ""); +Expect(0, 3889, '\p{Is_Nv=017/002}', ""); +Expect(1, 3889, '\p{^Is_Nv=017/002}', ""); +Expect(1, 3889, '\P{Is_Nv=017/002}', ""); +Expect(0, 3889, '\P{^Is_Nv=017/002}', ""); +Expect(1, 3890, '\p{Is_Nv=8.500}', ""); +Expect(0, 3890, '\p{^Is_Nv=8.500}', ""); +Expect(0, 3890, '\P{Is_Nv=8.500}', ""); +Expect(1, 3890, '\P{^Is_Nv=8.500}', ""); +Expect(0, 3889, '\p{Is_Nv=8.500}', ""); +Expect(1, 3889, '\p{^Is_Nv=8.500}', ""); +Expect(1, 3889, '\P{Is_Nv=8.500}', ""); +Expect(0, 3889, '\P{^Is_Nv=8.500}', ""); +Error('\p{Numeric_Value: _ 00000000042/a/}'); +Error('\P{Numeric_Value: _ 00000000042/a/}'); +Expect(1, 12983, '\p{Numeric_Value=00_00_42}', ""); +Expect(0, 12983, '\p{^Numeric_Value=00_00_42}', ""); +Expect(0, 12983, '\P{Numeric_Value=00_00_42}', ""); +Expect(1, 12983, '\P{^Numeric_Value=00_00_42}', ""); +Expect(0, 12982, '\p{Numeric_Value=00_00_42}', ""); +Expect(1, 12982, '\p{^Numeric_Value=00_00_42}', ""); +Expect(1, 12982, '\P{Numeric_Value=00_00_42}', ""); +Expect(0, 12982, '\P{^Numeric_Value=00_00_42}', ""); +Error('\p{Nv=__0/a/0 0-0 0 0 0042}'); +Error('\P{Nv=__0/a/0 0-0 0 0 0042}'); +Expect(1, 12983, '\p{Nv=00000000042}', ""); +Expect(0, 12983, '\p{^Nv=00000000042}', ""); +Expect(0, 12983, '\P{Nv=00000000042}', ""); +Expect(1, 12983, '\P{^Nv=00000000042}', ""); +Expect(0, 12982, '\p{Nv=00000000042}', ""); +Expect(1, 12982, '\p{^Nv=00000000042}', ""); +Expect(1, 12982, '\P{Nv=00000000042}', ""); +Expect(0, 12982, '\P{^Nv=00000000042}', ""); +Error('\p{Is_Numeric_Value=_/a/000000042}'); +Error('\P{Is_Numeric_Value=_/a/000000042}'); +Expect(1, 12983, '\p{Is_Numeric_Value=000_000_004_2}', ""); +Expect(0, 12983, '\p{^Is_Numeric_Value=000_000_004_2}', ""); +Expect(0, 12983, '\P{Is_Numeric_Value=000_000_004_2}', ""); +Expect(1, 12983, '\P{^Is_Numeric_Value=000_000_004_2}', ""); +Expect(0, 12982, '\p{Is_Numeric_Value=000_000_004_2}', ""); +Expect(1, 12982, '\p{^Is_Numeric_Value=000_000_004_2}', ""); +Expect(1, 12982, '\P{Is_Numeric_Value=000_000_004_2}', ""); +Expect(0, 12982, '\P{^Is_Numeric_Value=000_000_004_2}', ""); +Error('\p{Is_Nv=-:=0_0_42}'); +Error('\P{Is_Nv=-:=0_0_42}'); +Expect(1, 12983, '\p{Is_Nv=00_00_00_04_2}', ""); +Expect(0, 12983, '\p{^Is_Nv=00_00_00_04_2}', ""); +Expect(0, 12983, '\P{Is_Nv=00_00_00_04_2}', ""); +Expect(1, 12983, '\P{^Is_Nv=00_00_00_04_2}', ""); +Expect(0, 12982, '\p{Is_Nv=00_00_00_04_2}', ""); +Expect(1, 12982, '\p{^Is_Nv=00_00_00_04_2}', ""); +Expect(1, 12982, '\P{Is_Nv=00_00_00_04_2}', ""); +Expect(0, 12982, '\P{^Is_Nv=00_00_00_04_2}', ""); +Error('\p{Numeric_Value= 00000000022:=}'); +Error('\P{Numeric_Value= 00000000022:=}'); +Expect(1, 12882, '\p{Numeric_Value=+00000_00002_2}', ""); +Expect(0, 12882, '\p{^Numeric_Value=+00000_00002_2}', ""); +Expect(0, 12882, '\P{Numeric_Value=+00000_00002_2}', ""); +Expect(1, 12882, '\P{^Numeric_Value=+00000_00002_2}', ""); +Expect(0, 12881, '\p{Numeric_Value=+00000_00002_2}', ""); +Expect(1, 12881, '\p{^Numeric_Value=+00000_00002_2}', ""); +Expect(1, 12881, '\P{Numeric_Value=+00000_00002_2}', ""); +Expect(0, 12881, '\P{^Numeric_Value=+00000_00002_2}', ""); +Error('\p{Nv=:= 000000022}'); +Error('\P{Nv=:= 000000022}'); +Expect(1, 12882, '\p{Nv=+0022}', ""); +Expect(0, 12882, '\p{^Nv=+0022}', ""); +Expect(0, 12882, '\P{Nv=+0022}', ""); +Expect(1, 12882, '\P{^Nv=+0022}', ""); +Expect(0, 12881, '\p{Nv=+0022}', ""); +Expect(1, 12881, '\p{^Nv=+0022}', ""); +Expect(1, 12881, '\P{Nv=+0022}', ""); +Expect(0, 12881, '\P{^Nv=+0022}', ""); +Error('\p{Is_Numeric_Value=/a/00000022}'); +Error('\P{Is_Numeric_Value=/a/00000022}'); +Expect(1, 12882, '\p{Is_Numeric_Value=+022}', ""); +Expect(0, 12882, '\p{^Is_Numeric_Value=+022}', ""); +Expect(0, 12882, '\P{Is_Numeric_Value=+022}', ""); +Expect(1, 12882, '\P{^Is_Numeric_Value=+022}', ""); +Expect(0, 12881, '\p{Is_Numeric_Value=+022}', ""); +Expect(1, 12881, '\p{^Is_Numeric_Value=+022}', ""); +Expect(1, 12881, '\P{Is_Numeric_Value=+022}', ""); +Expect(0, 12881, '\P{^Is_Numeric_Value=+022}', ""); +Error('\p{Is_Nv=/a/_00000002_2}'); +Error('\P{Is_Nv=/a/_00000002_2}'); +Expect(1, 12882, '\p{Is_Nv=00_02_2}', ""); +Expect(0, 12882, '\p{^Is_Nv=00_02_2}', ""); +Expect(0, 12882, '\P{Is_Nv=00_02_2}', ""); +Expect(1, 12882, '\P{^Is_Nv=00_02_2}', ""); +Expect(0, 12881, '\p{Is_Nv=00_02_2}', ""); +Expect(1, 12881, '\p{^Is_Nv=00_02_2}', ""); +Expect(1, 12881, '\P{Is_Nv=00_02_2}', ""); +Expect(0, 12881, '\P{^Is_Nv=00_02_2}', ""); +Error('\p{Numeric_Value=:=_-900}'); +Error('\P{Numeric_Value=:=_-900}'); +Expect(1, 65825, '\p{Numeric_Value=900}', ""); +Expect(0, 65825, '\p{^Numeric_Value=900}', ""); +Expect(0, 65825, '\P{Numeric_Value=900}', ""); +Expect(1, 65825, '\P{^Numeric_Value=900}', ""); +Expect(0, 65824, '\p{Numeric_Value=900}', ""); +Expect(1, 65824, '\p{^Numeric_Value=900}', ""); +Expect(1, 65824, '\P{Numeric_Value=900}', ""); +Expect(0, 65824, '\P{^Numeric_Value=900}', ""); +Error('\p{Nv= :=00000900}'); +Error('\P{Nv= :=00000900}'); +Expect(1, 65825, '\p{Nv: 00_90_0}', ""); +Expect(0, 65825, '\p{^Nv: 00_90_0}', ""); +Expect(0, 65825, '\P{Nv: 00_90_0}', ""); +Expect(1, 65825, '\P{^Nv: 00_90_0}', ""); +Expect(0, 65824, '\p{Nv: 00_90_0}', ""); +Expect(1, 65824, '\p{^Nv: 00_90_0}', ""); +Expect(1, 65824, '\P{Nv: 00_90_0}', ""); +Expect(0, 65824, '\P{^Nv: 00_90_0}', ""); +Error('\p{Is_Numeric_Value= +090:=0}'); +Error('\P{Is_Numeric_Value= +090:=0}'); +Expect(1, 65825, '\p{Is_Numeric_Value=000000900}', ""); +Expect(0, 65825, '\p{^Is_Numeric_Value=000000900}', ""); +Expect(0, 65825, '\P{Is_Numeric_Value=000000900}', ""); +Expect(1, 65825, '\P{^Is_Numeric_Value=000000900}', ""); +Expect(0, 65824, '\p{Is_Numeric_Value=000000900}', ""); +Expect(1, 65824, '\p{^Is_Numeric_Value=000000900}', ""); +Expect(1, 65824, '\P{Is_Numeric_Value=000000900}', ""); +Expect(0, 65824, '\P{^Is_Numeric_Value=000000900}', ""); +Error('\p{Is_Nv=- 90 0:=}'); +Error('\P{Is_Nv=- 90 0:=}'); +Expect(1, 65825, '\p{Is_Nv=90_0}', ""); +Expect(0, 65825, '\p{^Is_Nv=90_0}', ""); +Expect(0, 65825, '\P{Is_Nv=90_0}', ""); +Expect(1, 65825, '\P{^Is_Nv=90_0}', ""); +Expect(0, 65824, '\p{Is_Nv=90_0}', ""); +Expect(1, 65824, '\p{^Is_Nv=90_0}', ""); +Expect(1, 65824, '\P{Is_Nv=90_0}', ""); +Expect(0, 65824, '\P{^Is_Nv=90_0}', ""); +Error('\p{Numeric_Value=_ 2/5:=}'); +Error('\P{Numeric_Value=_ 2/5:=}'); +Expect(1, 8534, '\p{Numeric_Value=0002/0000000005}', ""); +Expect(0, 8534, '\p{^Numeric_Value=0002/0000000005}', ""); +Expect(0, 8534, '\P{Numeric_Value=0002/0000000005}', ""); +Expect(1, 8534, '\P{^Numeric_Value=0002/0000000005}', ""); +Expect(0, 8533, '\p{Numeric_Value=0002/0000000005}', ""); +Expect(1, 8533, '\p{^Numeric_Value=0002/0000000005}', ""); +Expect(1, 8533, '\P{Numeric_Value=0002/0000000005}', ""); +Expect(0, 8533, '\P{^Numeric_Value=0002/0000000005}', ""); +Expect(1, 8534, '\p{Numeric_Value=0.400}', ""); +Expect(0, 8534, '\p{^Numeric_Value=0.400}', ""); +Expect(0, 8534, '\P{Numeric_Value=0.400}', ""); +Expect(1, 8534, '\P{^Numeric_Value=0.400}', ""); +Expect(0, 8533, '\p{Numeric_Value=0.400}', ""); +Expect(1, 8533, '\p{^Numeric_Value=0.400}', ""); +Expect(1, 8533, '\P{Numeric_Value=0.400}', ""); +Expect(0, 8533, '\P{^Numeric_Value=0.400}', ""); +Error('\p{Nv:00002/0000000005/a/}'); +Error('\P{Nv:00002/0000000005/a/}'); +Expect(1, 8534, '\p{Nv=+0000000002/05}', ""); +Expect(0, 8534, '\p{^Nv=+0000000002/05}', ""); +Expect(0, 8534, '\P{Nv=+0000000002/05}', ""); +Expect(1, 8534, '\P{^Nv=+0000000002/05}', ""); +Expect(0, 8533, '\p{Nv=+0000000002/05}', ""); +Expect(1, 8533, '\p{^Nv=+0000000002/05}', ""); +Expect(1, 8533, '\P{Nv=+0000000002/05}', ""); +Expect(0, 8533, '\P{^Nv=+0000000002/05}', ""); +Expect(1, 8534, '\p{Nv=0.400}', ""); +Expect(0, 8534, '\p{^Nv=0.400}', ""); +Expect(0, 8534, '\P{Nv=0.400}', ""); +Expect(1, 8534, '\P{^Nv=0.400}', ""); +Expect(0, 8533, '\p{Nv=0.400}', ""); +Expect(1, 8533, '\p{^Nv=0.400}', ""); +Expect(1, 8533, '\P{Nv=0.400}', ""); +Expect(0, 8533, '\P{^Nv=0.400}', ""); +Error('\p{Is_Numeric_Value=_:=+0000002/0005}'); +Error('\P{Is_Numeric_Value=_:=+0000002/0005}'); +Expect(1, 8534, '\p{Is_Numeric_Value=002/00000005}', ""); +Expect(0, 8534, '\p{^Is_Numeric_Value=002/00000005}', ""); +Expect(0, 8534, '\P{Is_Numeric_Value=002/00000005}', ""); +Expect(1, 8534, '\P{^Is_Numeric_Value=002/00000005}', ""); +Expect(0, 8533, '\p{Is_Numeric_Value=002/00000005}', ""); +Expect(1, 8533, '\p{^Is_Numeric_Value=002/00000005}', ""); +Expect(1, 8533, '\P{Is_Numeric_Value=002/00000005}', ""); +Expect(0, 8533, '\P{^Is_Numeric_Value=002/00000005}', ""); +Expect(1, 8534, '\p{Is_Numeric_Value=0.400}', ""); +Expect(0, 8534, '\p{^Is_Numeric_Value=0.400}', ""); +Expect(0, 8534, '\P{Is_Numeric_Value=0.400}', ""); +Expect(1, 8534, '\P{^Is_Numeric_Value=0.400}', ""); +Expect(0, 8533, '\p{Is_Numeric_Value=0.400}', ""); +Expect(1, 8533, '\p{^Is_Numeric_Value=0.400}', ""); +Expect(1, 8533, '\P{Is_Numeric_Value=0.400}', ""); +Expect(0, 8533, '\P{^Is_Numeric_Value=0.400}', ""); +Error('\p{Is_Nv=_:=0000000002/000000005}'); +Error('\P{Is_Nv=_:=0000000002/000000005}'); +Expect(1, 8534, '\p{Is_Nv=0000000002/05}', ""); +Expect(0, 8534, '\p{^Is_Nv=0000000002/05}', ""); +Expect(0, 8534, '\P{Is_Nv=0000000002/05}', ""); +Expect(1, 8534, '\P{^Is_Nv=0000000002/05}', ""); +Expect(0, 8533, '\p{Is_Nv=0000000002/05}', ""); +Expect(1, 8533, '\p{^Is_Nv=0000000002/05}', ""); +Expect(1, 8533, '\P{Is_Nv=0000000002/05}', ""); +Expect(0, 8533, '\P{^Is_Nv=0000000002/05}', ""); +Expect(1, 8534, '\p{Is_Nv=0.400}', ""); +Expect(0, 8534, '\p{^Is_Nv=0.400}', ""); +Expect(0, 8534, '\P{Is_Nv=0.400}', ""); +Expect(1, 8534, '\P{^Is_Nv=0.400}', ""); +Expect(0, 8533, '\p{Is_Nv=0.400}', ""); +Expect(1, 8533, '\p{^Is_Nv=0.400}', ""); +Expect(1, 8533, '\P{Is_Nv=0.400}', ""); +Expect(0, 8533, '\P{^Is_Nv=0.400}', ""); +Error('\p{Numeric_Value=:=_+00 0046}'); +Error('\P{Numeric_Value=:=_+00 0046}'); +Expect(1, 12987, '\p{Numeric_Value=+00000000046}', ""); +Expect(0, 12987, '\p{^Numeric_Value=+00000000046}', ""); +Expect(0, 12987, '\P{Numeric_Value=+00000000046}', ""); +Expect(1, 12987, '\P{^Numeric_Value=+00000000046}', ""); +Expect(0, 12986, '\p{Numeric_Value=+00000000046}', ""); +Expect(1, 12986, '\p{^Numeric_Value=+00000000046}', ""); +Expect(1, 12986, '\P{Numeric_Value=+00000000046}', ""); +Expect(0, 12986, '\P{^Numeric_Value=+00000000046}', ""); +Error('\p{Nv: /a/00000000046}'); +Error('\P{Nv: /a/00000000046}'); +Expect(1, 12987, '\p{Nv=+000046}', ""); +Expect(0, 12987, '\p{^Nv=+000046}', ""); +Expect(0, 12987, '\P{Nv=+000046}', ""); +Expect(1, 12987, '\P{^Nv=+000046}', ""); +Expect(0, 12986, '\p{Nv=+000046}', ""); +Expect(1, 12986, '\p{^Nv=+000046}', ""); +Expect(1, 12986, '\P{Nv=+000046}', ""); +Expect(0, 12986, '\P{^Nv=+000046}', ""); +Error('\p{Is_Numeric_Value= :=00046}'); +Error('\P{Is_Numeric_Value= :=00046}'); +Expect(1, 12987, '\p{Is_Numeric_Value=0_0_0_0_0_00046}', ""); +Expect(0, 12987, '\p{^Is_Numeric_Value=0_0_0_0_0_00046}', ""); +Expect(0, 12987, '\P{Is_Numeric_Value=0_0_0_0_0_00046}', ""); +Expect(1, 12987, '\P{^Is_Numeric_Value=0_0_0_0_0_00046}', ""); +Expect(0, 12986, '\p{Is_Numeric_Value=0_0_0_0_0_00046}', ""); +Expect(1, 12986, '\p{^Is_Numeric_Value=0_0_0_0_0_00046}', ""); +Expect(1, 12986, '\P{Is_Numeric_Value=0_0_0_0_0_00046}', ""); +Expect(0, 12986, '\P{^Is_Numeric_Value=0_0_0_0_0_00046}', ""); +Error('\p{Is_Nv:/a/ _0_00 0-0 046}'); +Error('\P{Is_Nv:/a/ _0_00 0-0 046}'); +Expect(1, 12987, '\p{Is_Nv=00_00_46}', ""); +Expect(0, 12987, '\p{^Is_Nv=00_00_46}', ""); +Expect(0, 12987, '\P{Is_Nv=00_00_46}', ""); +Expect(1, 12987, '\P{^Is_Nv=00_00_46}', ""); +Expect(0, 12986, '\p{Is_Nv=00_00_46}', ""); +Expect(1, 12986, '\p{^Is_Nv=00_00_46}', ""); +Expect(1, 12986, '\P{Is_Nv=00_00_46}', ""); +Expect(0, 12986, '\P{^Is_Nv=00_00_46}', ""); +Error('\p{Numeric_Value= /a/+000 000_0}'); +Error('\P{Numeric_Value= /a/+000 000_0}'); +Expect(1, 48, '\p{Numeric_Value=+0}', ""); +Expect(0, 48, '\p{^Numeric_Value=+0}', ""); +Expect(0, 48, '\P{Numeric_Value=+0}', ""); +Expect(1, 48, '\P{^Numeric_Value=+0}', ""); +Expect(0, 47, '\p{Numeric_Value=+0}', ""); +Expect(1, 47, '\p{^Numeric_Value=+0}', ""); +Expect(1, 47, '\P{Numeric_Value=+0}', ""); +Expect(0, 47, '\P{^Numeric_Value=+0}', ""); +Error('\p{Nv= -00 00/a/0}'); +Error('\P{Nv= -00 00/a/0}'); +Expect(1, 48, '\p{Nv=0000}', ""); +Expect(0, 48, '\p{^Nv=0000}', ""); +Expect(0, 48, '\P{Nv=0000}', ""); +Expect(1, 48, '\P{^Nv=0000}', ""); +Expect(0, 47, '\p{Nv=0000}', ""); +Expect(1, 47, '\p{^Nv=0000}', ""); +Expect(1, 47, '\P{Nv=0000}', ""); +Expect(0, 47, '\P{^Nv=0000}', ""); +Error('\p{Is_Numeric_Value=_ +0 0:=00}'); +Error('\P{Is_Numeric_Value=_ +0 0:=00}'); +Expect(1, 48, '\p{Is_Numeric_Value=0}', ""); +Expect(0, 48, '\p{^Is_Numeric_Value=0}', ""); +Expect(0, 48, '\P{Is_Numeric_Value=0}', ""); +Expect(1, 48, '\P{^Is_Numeric_Value=0}', ""); +Expect(0, 47, '\p{Is_Numeric_Value=0}', ""); +Expect(1, 47, '\p{^Is_Numeric_Value=0}', ""); +Expect(1, 47, '\P{Is_Numeric_Value=0}', ""); +Expect(0, 47, '\P{^Is_Numeric_Value=0}', ""); +Error('\p{Is_Nv=_ 0 0:=0 00}'); +Error('\P{Is_Nv=_ 0 0:=0 00}'); +Expect(1, 48, '\p{Is_Nv=000_000_0}', ""); +Expect(0, 48, '\p{^Is_Nv=000_000_0}', ""); +Expect(0, 48, '\P{Is_Nv=000_000_0}', ""); +Expect(1, 48, '\P{^Is_Nv=000_000_0}', ""); +Expect(0, 47, '\p{Is_Nv=000_000_0}', ""); +Expect(1, 47, '\p{^Is_Nv=000_000_0}', ""); +Expect(1, 47, '\P{Is_Nv=000_000_0}', ""); +Expect(0, 47, '\P{^Is_Nv=000_000_0}', ""); +Error('\p{Numeric_Value=/a/ _+000004/0000005}'); +Error('\P{Numeric_Value=/a/ _+000004/0000005}'); +Expect(1, 8536, '\p{Numeric_Value=+000000004/0005}', ""); +Expect(0, 8536, '\p{^Numeric_Value=+000000004/0005}', ""); +Expect(0, 8536, '\P{Numeric_Value=+000000004/0005}', ""); +Expect(1, 8536, '\P{^Numeric_Value=+000000004/0005}', ""); +Expect(0, 8535, '\p{Numeric_Value=+000000004/0005}', ""); +Expect(1, 8535, '\p{^Numeric_Value=+000000004/0005}', ""); +Expect(1, 8535, '\P{Numeric_Value=+000000004/0005}', ""); +Expect(0, 8535, '\P{^Numeric_Value=+000000004/0005}', ""); +Expect(1, 8536, '\p{Numeric_Value=0.800}', ""); +Expect(0, 8536, '\p{^Numeric_Value=0.800}', ""); +Expect(0, 8536, '\P{Numeric_Value=0.800}', ""); +Expect(1, 8536, '\P{^Numeric_Value=0.800}', ""); +Expect(0, 8535, '\p{Numeric_Value=0.800}', ""); +Expect(1, 8535, '\p{^Numeric_Value=0.800}', ""); +Expect(1, 8535, '\P{Numeric_Value=0.800}', ""); +Expect(0, 8535, '\P{^Numeric_Value=0.800}', ""); +Error('\p{Nv=/a/-_00000004/00000005}'); +Error('\P{Nv=/a/-_00000004/00000005}'); +Expect(1, 8536, '\p{Nv=0000000004/000000005}', ""); +Expect(0, 8536, '\p{^Nv=0000000004/000000005}', ""); +Expect(0, 8536, '\P{Nv=0000000004/000000005}', ""); +Expect(1, 8536, '\P{^Nv=0000000004/000000005}', ""); +Expect(0, 8535, '\p{Nv=0000000004/000000005}', ""); +Expect(1, 8535, '\p{^Nv=0000000004/000000005}', ""); +Expect(1, 8535, '\P{Nv=0000000004/000000005}', ""); +Expect(0, 8535, '\P{^Nv=0000000004/000000005}', ""); +Expect(1, 8536, '\p{Nv=0.800}', ""); +Expect(0, 8536, '\p{^Nv=0.800}', ""); +Expect(0, 8536, '\P{Nv=0.800}', ""); +Expect(1, 8536, '\P{^Nv=0.800}', ""); +Expect(0, 8535, '\p{Nv=0.800}', ""); +Expect(1, 8535, '\p{^Nv=0.800}', ""); +Expect(1, 8535, '\P{Nv=0.800}', ""); +Expect(0, 8535, '\P{^Nv=0.800}', ""); +Error('\p{Is_Numeric_Value: +0004/000000005/a/}'); +Error('\P{Is_Numeric_Value: +0004/000000005/a/}'); +Expect(1, 8536, '\p{Is_Numeric_Value=04/5}', ""); +Expect(0, 8536, '\p{^Is_Numeric_Value=04/5}', ""); +Expect(0, 8536, '\P{Is_Numeric_Value=04/5}', ""); +Expect(1, 8536, '\P{^Is_Numeric_Value=04/5}', ""); +Expect(0, 8535, '\p{Is_Numeric_Value=04/5}', ""); +Expect(1, 8535, '\p{^Is_Numeric_Value=04/5}', ""); +Expect(1, 8535, '\P{Is_Numeric_Value=04/5}', ""); +Expect(0, 8535, '\P{^Is_Numeric_Value=04/5}', ""); +Expect(1, 8536, '\p{Is_Numeric_Value: 0.800}', ""); +Expect(0, 8536, '\p{^Is_Numeric_Value: 0.800}', ""); +Expect(0, 8536, '\P{Is_Numeric_Value: 0.800}', ""); +Expect(1, 8536, '\P{^Is_Numeric_Value: 0.800}', ""); +Expect(0, 8535, '\p{Is_Numeric_Value: 0.800}', ""); +Expect(1, 8535, '\p{^Is_Numeric_Value: 0.800}', ""); +Expect(1, 8535, '\P{Is_Numeric_Value: 0.800}', ""); +Expect(0, 8535, '\P{^Is_Numeric_Value: 0.800}', ""); +Error('\p{Is_Nv=- +0000004/00000005:=}'); +Error('\P{Is_Nv=- +0000004/00000005:=}'); +Expect(1, 8536, '\p{Is_Nv=000004/00000005}', ""); +Expect(0, 8536, '\p{^Is_Nv=000004/00000005}', ""); +Expect(0, 8536, '\P{Is_Nv=000004/00000005}', ""); +Expect(1, 8536, '\P{^Is_Nv=000004/00000005}', ""); +Expect(0, 8535, '\p{Is_Nv=000004/00000005}', ""); +Expect(1, 8535, '\p{^Is_Nv=000004/00000005}', ""); +Expect(1, 8535, '\P{Is_Nv=000004/00000005}', ""); +Expect(0, 8535, '\P{^Is_Nv=000004/00000005}', ""); +Expect(1, 8536, '\p{Is_Nv=0.800}', ""); +Expect(0, 8536, '\p{^Is_Nv=0.800}', ""); +Expect(0, 8536, '\P{Is_Nv=0.800}', ""); +Expect(1, 8536, '\P{^Is_Nv=0.800}', ""); +Expect(0, 8535, '\p{Is_Nv=0.800}', ""); +Expect(1, 8535, '\p{^Is_Nv=0.800}', ""); +Expect(1, 8535, '\P{Is_Nv=0.800}', ""); +Expect(0, 8535, '\P{^Is_Nv=0.800}', ""); +Error('\p{Numeric_Value=_-+0000000013:=}'); +Error('\P{Numeric_Value=_-+0000000013:=}'); +Expect(1, 9324, '\p{Numeric_Value=+0000013}', ""); +Expect(0, 9324, '\p{^Numeric_Value=+0000013}', ""); +Expect(0, 9324, '\P{Numeric_Value=+0000013}', ""); +Expect(1, 9324, '\P{^Numeric_Value=+0000013}', ""); +Expect(0, 9323, '\p{Numeric_Value=+0000013}', ""); +Expect(1, 9323, '\p{^Numeric_Value=+0000013}', ""); +Expect(1, 9323, '\P{Numeric_Value=+0000013}', ""); +Expect(0, 9323, '\P{^Numeric_Value=+0000013}', ""); +Error('\p{Nv:/a/ 00000013}'); +Error('\P{Nv:/a/ 00000013}'); +Expect(1, 9324, '\p{Nv=0013}', ""); +Expect(0, 9324, '\p{^Nv=0013}', ""); +Expect(0, 9324, '\P{Nv=0013}', ""); +Expect(1, 9324, '\P{^Nv=0013}', ""); +Expect(0, 9323, '\p{Nv=0013}', ""); +Expect(1, 9323, '\p{^Nv=0013}', ""); +Expect(1, 9323, '\P{Nv=0013}', ""); +Expect(0, 9323, '\P{^Nv=0013}', ""); +Error('\p{Is_Numeric_Value=/a/ 0013}'); +Error('\P{Is_Numeric_Value=/a/ 0013}'); +Expect(1, 9324, '\p{Is_Numeric_Value=0_0_13}', ""); +Expect(0, 9324, '\p{^Is_Numeric_Value=0_0_13}', ""); +Expect(0, 9324, '\P{Is_Numeric_Value=0_0_13}', ""); +Expect(1, 9324, '\P{^Is_Numeric_Value=0_0_13}', ""); +Expect(0, 9323, '\p{Is_Numeric_Value=0_0_13}', ""); +Expect(1, 9323, '\p{^Is_Numeric_Value=0_0_13}', ""); +Expect(1, 9323, '\P{Is_Numeric_Value=0_0_13}', ""); +Expect(0, 9323, '\P{^Is_Numeric_Value=0_0_13}', ""); +Error('\p{Is_Nv= _+1 3/a/}'); +Error('\P{Is_Nv= _+1 3/a/}'); +Expect(1, 9324, '\p{Is_Nv=013}', ""); +Expect(0, 9324, '\p{^Is_Nv=013}', ""); +Expect(0, 9324, '\P{Is_Nv=013}', ""); +Expect(1, 9324, '\P{^Is_Nv=013}', ""); +Expect(0, 9323, '\p{Is_Nv=013}', ""); +Expect(1, 9323, '\p{^Is_Nv=013}', ""); +Expect(1, 9323, '\P{Is_Nv=013}', ""); +Expect(0, 9323, '\P{^Is_Nv=013}', ""); +Error('\p{Numeric_Value: - 02/a/3}'); +Error('\P{Numeric_Value: - 02/a/3}'); +Expect(1, 12883, '\p{Numeric_Value=00000000023}', ""); +Expect(0, 12883, '\p{^Numeric_Value=00000000023}', ""); +Expect(0, 12883, '\P{Numeric_Value=00000000023}', ""); +Expect(1, 12883, '\P{^Numeric_Value=00000000023}', ""); +Expect(0, 12882, '\p{Numeric_Value=00000000023}', ""); +Expect(1, 12882, '\p{^Numeric_Value=00000000023}', ""); +Expect(1, 12882, '\P{Numeric_Value=00000000023}', ""); +Expect(0, 12882, '\P{^Numeric_Value=00000000023}', ""); +Error('\p{Nv= 00000000023/a/}'); +Error('\P{Nv= 00000000023/a/}'); +Expect(1, 12883, '\p{Nv=23}', ""); +Expect(0, 12883, '\p{^Nv=23}', ""); +Expect(0, 12883, '\P{Nv=23}', ""); +Expect(1, 12883, '\P{^Nv=23}', ""); +Expect(0, 12882, '\p{Nv=23}', ""); +Expect(1, 12882, '\p{^Nv=23}', ""); +Expect(1, 12882, '\P{Nv=23}', ""); +Expect(0, 12882, '\P{^Nv=23}', ""); +Error('\p{Is_Numeric_Value: _0 0/a/0-0_00 0 23}'); +Error('\P{Is_Numeric_Value: _0 0/a/0-0_00 0 23}'); +Expect(1, 12883, '\p{Is_Numeric_Value: +0023}', ""); +Expect(0, 12883, '\p{^Is_Numeric_Value: +0023}', ""); +Expect(0, 12883, '\P{Is_Numeric_Value: +0023}', ""); +Expect(1, 12883, '\P{^Is_Numeric_Value: +0023}', ""); +Expect(0, 12882, '\p{Is_Numeric_Value: +0023}', ""); +Expect(1, 12882, '\p{^Is_Numeric_Value: +0023}', ""); +Expect(1, 12882, '\P{Is_Numeric_Value: +0023}', ""); +Expect(0, 12882, '\P{^Is_Numeric_Value: +0023}', ""); +Error('\p{Is_Nv=_ 0023/a/}'); +Error('\P{Is_Nv=_ 0023/a/}'); +Expect(1, 12883, '\p{Is_Nv=00023}', ""); +Expect(0, 12883, '\p{^Is_Nv=00023}', ""); +Expect(0, 12883, '\P{Is_Nv=00023}', ""); +Expect(1, 12883, '\P{^Is_Nv=00023}', ""); +Expect(0, 12882, '\p{Is_Nv=00023}', ""); +Expect(1, 12882, '\p{^Is_Nv=00023}', ""); +Expect(1, 12882, '\P{Is_Nv=00023}', ""); +Expect(0, 12882, '\P{^Is_Nv=00023}', ""); +Error('\p{Numeric_Value=:=- 00006}'); +Error('\P{Numeric_Value=:=- 00006}'); +Expect(1, 54, '\p{Numeric_Value=0000_6}', ""); +Expect(0, 54, '\p{^Numeric_Value=0000_6}', ""); +Expect(0, 54, '\P{Numeric_Value=0000_6}', ""); +Expect(1, 54, '\P{^Numeric_Value=0000_6}', ""); +Expect(0, 53, '\p{Numeric_Value=0000_6}', ""); +Expect(1, 53, '\p{^Numeric_Value=0000_6}', ""); +Expect(1, 53, '\P{Numeric_Value=0000_6}', ""); +Expect(0, 53, '\P{^Numeric_Value=0000_6}', ""); +Error('\p{Nv=:= _0 0 0-06}'); +Error('\P{Nv=:= _0 0 0-06}'); +Expect(1, 54, '\p{Nv=0006}', ""); +Expect(0, 54, '\p{^Nv=0006}', ""); +Expect(0, 54, '\P{Nv=0006}', ""); +Expect(1, 54, '\P{^Nv=0006}', ""); +Expect(0, 53, '\p{Nv=0006}', ""); +Expect(1, 53, '\p{^Nv=0006}', ""); +Expect(1, 53, '\P{Nv=0006}', ""); +Expect(0, 53, '\P{^Nv=0006}', ""); +Error('\p{Is_Numeric_Value=/a/ +000000 6}'); +Error('\P{Is_Numeric_Value=/a/ +000000 6}'); +Expect(1, 54, '\p{Is_Numeric_Value:6}', ""); +Expect(0, 54, '\p{^Is_Numeric_Value:6}', ""); +Expect(0, 54, '\P{Is_Numeric_Value:6}', ""); +Expect(1, 54, '\P{^Is_Numeric_Value:6}', ""); +Expect(0, 53, '\p{Is_Numeric_Value:6}', ""); +Expect(1, 53, '\p{^Is_Numeric_Value:6}', ""); +Expect(1, 53, '\P{Is_Numeric_Value:6}', ""); +Expect(0, 53, '\P{^Is_Numeric_Value:6}', ""); +Error('\p{Is_Nv= 6:=}'); +Error('\P{Is_Nv= 6:=}'); +Expect(1, 54, '\p{Is_Nv=0_0_0_0_006}', ""); +Expect(0, 54, '\p{^Is_Nv=0_0_0_0_006}', ""); +Expect(0, 54, '\P{Is_Nv=0_0_0_0_006}', ""); +Expect(1, 54, '\P{^Is_Nv=0_0_0_0_006}', ""); +Expect(0, 53, '\p{Is_Nv=0_0_0_0_006}', ""); +Expect(1, 53, '\p{^Is_Nv=0_0_0_0_006}', ""); +Expect(1, 53, '\P{Is_Nv=0_0_0_0_006}', ""); +Expect(0, 53, '\P{^Is_Nv=0_0_0_0_006}', ""); +Error('\p{Numeric_Value=_ 07000 0:=}'); +Error('\P{Numeric_Value=_ 07000 0:=}'); +Expect(1, 65841, '\p{Numeric_Value=+0000070000}', ""); +Expect(0, 65841, '\p{^Numeric_Value=+0000070000}', ""); +Expect(0, 65841, '\P{Numeric_Value=+0000070000}', ""); +Expect(1, 65841, '\P{^Numeric_Value=+0000070000}', ""); +Expect(0, 65840, '\p{Numeric_Value=+0000070000}', ""); +Expect(1, 65840, '\p{^Numeric_Value=+0000070000}', ""); +Expect(1, 65840, '\P{Numeric_Value=+0000070000}', ""); +Expect(0, 65840, '\P{^Numeric_Value=+0000070000}', ""); +Error('\p{Nv= /a/+0000070000}'); +Error('\P{Nv= /a/+0000070000}'); +Expect(1, 65841, '\p{Nv=000_000_070_000}', ""); +Expect(0, 65841, '\p{^Nv=000_000_070_000}', ""); +Expect(0, 65841, '\P{Nv=000_000_070_000}', ""); +Expect(1, 65841, '\P{^Nv=000_000_070_000}', ""); +Expect(0, 65840, '\p{Nv=000_000_070_000}', ""); +Expect(1, 65840, '\p{^Nv=000_000_070_000}', ""); +Expect(1, 65840, '\P{Nv=000_000_070_000}', ""); +Expect(0, 65840, '\P{^Nv=000_000_070_000}', ""); +Error('\p{Is_Numeric_Value= 0_0:=0 0 0 0-0070000}'); +Error('\P{Is_Numeric_Value= 0_0:=0 0 0 0-0070000}'); +Expect(1, 65841, '\p{Is_Numeric_Value=0000000070000}', ""); +Expect(0, 65841, '\p{^Is_Numeric_Value=0000000070000}', ""); +Expect(0, 65841, '\P{Is_Numeric_Value=0000000070000}', ""); +Expect(1, 65841, '\P{^Is_Numeric_Value=0000000070000}', ""); +Expect(0, 65840, '\p{Is_Numeric_Value=0000000070000}', ""); +Expect(1, 65840, '\p{^Is_Numeric_Value=0000000070000}', ""); +Expect(1, 65840, '\P{Is_Numeric_Value=0000000070000}', ""); +Expect(0, 65840, '\P{^Is_Numeric_Value=0000000070000}', ""); +Error('\p{Is_Nv=_:=+00000000070000}'); +Error('\P{Is_Nv=_:=+00000000070000}'); +Expect(1, 65841, '\p{Is_Nv=0000000070000}', ""); +Expect(0, 65841, '\p{^Is_Nv=0000000070000}', ""); +Expect(0, 65841, '\P{Is_Nv=0000000070000}', ""); +Expect(1, 65841, '\P{^Is_Nv=0000000070000}', ""); +Expect(0, 65840, '\p{Is_Nv=0000000070000}', ""); +Expect(1, 65840, '\p{^Is_Nv=0000000070000}', ""); +Expect(1, 65840, '\P{Is_Nv=0000000070000}', ""); +Expect(0, 65840, '\P{^Is_Nv=0000000070000}', ""); +Error('\p{Numeric_Value=-_36:=}'); +Error('\P{Numeric_Value=-_36:=}'); +Expect(1, 12977, '\p{Numeric_Value=000036}', ""); +Expect(0, 12977, '\p{^Numeric_Value=000036}', ""); +Expect(0, 12977, '\P{Numeric_Value=000036}', ""); +Expect(1, 12977, '\P{^Numeric_Value=000036}', ""); +Expect(0, 12976, '\p{Numeric_Value=000036}', ""); +Expect(1, 12976, '\p{^Numeric_Value=000036}', ""); +Expect(1, 12976, '\P{Numeric_Value=000036}', ""); +Expect(0, 12976, '\P{^Numeric_Value=000036}', ""); +Error('\p{Nv=-+00-03/a/6}'); +Error('\P{Nv=-+00-03/a/6}'); +Expect(1, 12977, '\p{Nv=36}', ""); +Expect(0, 12977, '\p{^Nv=36}', ""); +Expect(0, 12977, '\P{Nv=36}', ""); +Expect(1, 12977, '\P{^Nv=36}', ""); +Expect(0, 12976, '\p{Nv=36}', ""); +Expect(1, 12976, '\p{^Nv=36}', ""); +Expect(1, 12976, '\P{Nv=36}', ""); +Expect(0, 12976, '\P{^Nv=36}', ""); +Error('\p{Is_Numeric_Value=-:=0 0 0-0 0 0_0036}'); +Error('\P{Is_Numeric_Value=-:=0 0 0-0 0 0_0036}'); +Expect(1, 12977, '\p{Is_Numeric_Value=0_0_0_0_0_0_00036}', ""); +Expect(0, 12977, '\p{^Is_Numeric_Value=0_0_0_0_0_0_00036}', ""); +Expect(0, 12977, '\P{Is_Numeric_Value=0_0_0_0_0_0_00036}', ""); +Expect(1, 12977, '\P{^Is_Numeric_Value=0_0_0_0_0_0_00036}', ""); +Expect(0, 12976, '\p{Is_Numeric_Value=0_0_0_0_0_0_00036}', ""); +Expect(1, 12976, '\p{^Is_Numeric_Value=0_0_0_0_0_0_00036}', ""); +Expect(1, 12976, '\P{Is_Numeric_Value=0_0_0_0_0_0_00036}', ""); +Expect(0, 12976, '\P{^Is_Numeric_Value=0_0_0_0_0_0_00036}', ""); +Error('\p{Is_Nv=/a/ -000000036}'); +Error('\P{Is_Nv=/a/ -000000036}'); +Expect(1, 12977, '\p{Is_Nv=00003_6}', ""); +Expect(0, 12977, '\p{^Is_Nv=00003_6}', ""); +Expect(0, 12977, '\P{Is_Nv=00003_6}', ""); +Expect(1, 12977, '\P{^Is_Nv=00003_6}', ""); +Expect(0, 12976, '\p{Is_Nv=00003_6}', ""); +Expect(1, 12976, '\p{^Is_Nv=00003_6}', ""); +Expect(1, 12976, '\P{Is_Nv=00003_6}', ""); +Expect(0, 12976, '\P{^Is_Nv=00003_6}', ""); +Error('\p{Numeric_Value= 00000 3:=}'); +Error('\P{Numeric_Value= 00000 3:=}'); +Expect(1, 51, '\p{Numeric_Value: +03}', ""); +Expect(0, 51, '\p{^Numeric_Value: +03}', ""); +Expect(0, 51, '\P{Numeric_Value: +03}', ""); +Expect(1, 51, '\P{^Numeric_Value: +03}', ""); +Expect(0, 50, '\p{Numeric_Value: +03}', ""); +Expect(1, 50, '\p{^Numeric_Value: +03}', ""); +Expect(1, 50, '\P{Numeric_Value: +03}', ""); +Expect(0, 50, '\P{^Numeric_Value: +03}', ""); +Error('\p{Nv= 03/a/}'); +Error('\P{Nv= 03/a/}'); +Expect(1, 51, '\p{Nv=+000000003}', ""); +Expect(0, 51, '\p{^Nv=+000000003}', ""); +Expect(0, 51, '\P{Nv=+000000003}', ""); +Expect(1, 51, '\P{^Nv=+000000003}', ""); +Expect(0, 50, '\p{Nv=+000000003}', ""); +Expect(1, 50, '\p{^Nv=+000000003}', ""); +Expect(1, 50, '\P{Nv=+000000003}', ""); +Expect(0, 50, '\P{^Nv=+000000003}', ""); +Error('\p{Is_Numeric_Value=/a/ _0_0 003}'); +Error('\P{Is_Numeric_Value=/a/ _0_0 003}'); +Expect(1, 51, '\p{Is_Numeric_Value=+0000_3}', ""); +Expect(0, 51, '\p{^Is_Numeric_Value=+0000_3}', ""); +Expect(0, 51, '\P{Is_Numeric_Value=+0000_3}', ""); +Expect(1, 51, '\P{^Is_Numeric_Value=+0000_3}', ""); +Expect(0, 50, '\p{Is_Numeric_Value=+0000_3}', ""); +Expect(1, 50, '\p{^Is_Numeric_Value=+0000_3}', ""); +Expect(1, 50, '\P{Is_Numeric_Value=+0000_3}', ""); +Expect(0, 50, '\P{^Is_Numeric_Value=+0000_3}', ""); +Error('\p{Is_Nv=/a/ +0-3}'); +Error('\P{Is_Nv=/a/ +0-3}'); +Expect(1, 51, '\p{Is_Nv=+003}', ""); +Expect(0, 51, '\p{^Is_Nv=+003}', ""); +Expect(0, 51, '\P{Is_Nv=+003}', ""); +Expect(1, 51, '\P{^Is_Nv=+003}', ""); +Expect(0, 50, '\p{Is_Nv=+003}', ""); +Expect(1, 50, '\p{^Is_Nv=+003}', ""); +Expect(1, 50, '\P{Is_Nv=+003}', ""); +Expect(0, 50, '\P{^Is_Nv=+003}', ""); +Error('\p{Numeric_Value=_/a/05000}'); +Error('\P{Numeric_Value=_/a/05000}'); +Expect(1, 8577, '\p{Numeric_Value=00005000}', ""); +Expect(0, 8577, '\p{^Numeric_Value=00005000}', ""); +Expect(0, 8577, '\P{Numeric_Value=00005000}', ""); +Expect(1, 8577, '\P{^Numeric_Value=00005000}', ""); +Expect(0, 8576, '\p{Numeric_Value=00005000}', ""); +Expect(1, 8576, '\p{^Numeric_Value=00005000}', ""); +Expect(1, 8576, '\P{Numeric_Value=00005000}', ""); +Expect(0, 8576, '\P{^Numeric_Value=00005000}', ""); +Error('\p{Nv: /a/-00005000}'); +Error('\P{Nv: /a/-00005000}'); +Expect(1, 8577, '\p{Nv=0005000}', ""); +Expect(0, 8577, '\p{^Nv=0005000}', ""); +Expect(0, 8577, '\P{Nv=0005000}', ""); +Expect(1, 8577, '\P{^Nv=0005000}', ""); +Expect(0, 8576, '\p{Nv=0005000}', ""); +Expect(1, 8576, '\p{^Nv=0005000}', ""); +Expect(1, 8576, '\P{Nv=0005000}', ""); +Expect(0, 8576, '\P{^Nv=0005000}', ""); +Error('\p{Is_Numeric_Value=:=_-00 50_00}'); +Error('\P{Is_Numeric_Value=:=_-00 50_00}'); +Expect(1, 8577, '\p{Is_Numeric_Value: 0000000005000}', ""); +Expect(0, 8577, '\p{^Is_Numeric_Value: 0000000005000}', ""); +Expect(0, 8577, '\P{Is_Numeric_Value: 0000000005000}', ""); +Expect(1, 8577, '\P{^Is_Numeric_Value: 0000000005000}', ""); +Expect(0, 8576, '\p{Is_Numeric_Value: 0000000005000}', ""); +Expect(1, 8576, '\p{^Is_Numeric_Value: 0000000005000}', ""); +Expect(1, 8576, '\P{Is_Numeric_Value: 0000000005000}', ""); +Expect(0, 8576, '\P{^Is_Numeric_Value: 0000000005000}', ""); +Error('\p{Is_Nv= :=+0 0 0_5-000}'); +Error('\P{Is_Nv= :=+0 0 0_5-000}'); +Expect(1, 8577, '\p{Is_Nv: 00500_0}', ""); +Expect(0, 8577, '\p{^Is_Nv: 00500_0}', ""); +Expect(0, 8577, '\P{Is_Nv: 00500_0}', ""); +Expect(1, 8577, '\P{^Is_Nv: 00500_0}', ""); +Expect(0, 8576, '\p{Is_Nv: 00500_0}', ""); +Expect(1, 8576, '\p{^Is_Nv: 00500_0}', ""); +Expect(1, 8576, '\P{Is_Nv: 00500_0}', ""); +Expect(0, 8576, '\P{^Is_Nv: 00500_0}', ""); +Error('\p{Numeric_Value=- 00009:=}'); +Error('\P{Numeric_Value=- 00009:=}'); +Expect(1, 57, '\p{Numeric_Value=+9}', ""); +Expect(0, 57, '\p{^Numeric_Value=+9}', ""); +Expect(0, 57, '\P{Numeric_Value=+9}', ""); +Expect(1, 57, '\P{^Numeric_Value=+9}', ""); +Expect(0, 56, '\p{Numeric_Value=+9}', ""); +Expect(1, 56, '\p{^Numeric_Value=+9}', ""); +Expect(1, 56, '\P{Numeric_Value=+9}', ""); +Expect(0, 56, '\P{^Numeric_Value=+9}', ""); +Error('\p{Nv=_ +00000009/a/}'); +Error('\P{Nv=_ +00000009/a/}'); +Expect(1, 57, '\p{Nv=+000009}', ""); +Expect(0, 57, '\p{^Nv=+000009}', ""); +Expect(0, 57, '\P{Nv=+000009}', ""); +Expect(1, 57, '\P{^Nv=+000009}', ""); +Expect(0, 56, '\p{Nv=+000009}', ""); +Expect(1, 56, '\p{^Nv=+000009}', ""); +Expect(1, 56, '\P{Nv=+000009}', ""); +Expect(0, 56, '\P{^Nv=+000009}', ""); +Error('\p{Is_Numeric_Value= -00009:=}'); +Error('\P{Is_Numeric_Value= -00009:=}'); +Expect(1, 57, '\p{Is_Numeric_Value=000_9}', ""); +Expect(0, 57, '\p{^Is_Numeric_Value=000_9}', ""); +Expect(0, 57, '\P{Is_Numeric_Value=000_9}', ""); +Expect(1, 57, '\P{^Is_Numeric_Value=000_9}', ""); +Expect(0, 56, '\p{Is_Numeric_Value=000_9}', ""); +Expect(1, 56, '\p{^Is_Numeric_Value=000_9}', ""); +Expect(1, 56, '\P{Is_Numeric_Value=000_9}', ""); +Expect(0, 56, '\P{^Is_Numeric_Value=000_9}', ""); +Error('\p{Is_Nv=-0/a/0_00-00 009}'); +Error('\P{Is_Nv=-0/a/0_00-00 009}'); +Expect(1, 57, '\p{Is_Nv=000000009}', ""); +Expect(0, 57, '\p{^Is_Nv=000000009}', ""); +Expect(0, 57, '\P{Is_Nv=000000009}', ""); +Expect(1, 57, '\P{^Is_Nv=000000009}', ""); +Expect(0, 56, '\p{Is_Nv=000000009}', ""); +Expect(1, 56, '\p{^Is_Nv=000000009}', ""); +Expect(1, 56, '\P{Is_Nv=000000009}', ""); +Expect(0, 56, '\P{^Is_Nv=000000009}', ""); +Error('\p{Numeric_Value=_00010000:=}'); +Error('\P{Numeric_Value=_00010000:=}'); +Expect(1, 4988, '\p{Numeric_Value=00000000010000}', ""); +Expect(0, 4988, '\p{^Numeric_Value=00000000010000}', ""); +Expect(0, 4988, '\P{Numeric_Value=00000000010000}', ""); +Expect(1, 4988, '\P{^Numeric_Value=00000000010000}', ""); +Expect(0, 4987, '\p{Numeric_Value=00000000010000}', ""); +Expect(1, 4987, '\p{^Numeric_Value=00000000010000}', ""); +Expect(1, 4987, '\P{Numeric_Value=00000000010000}', ""); +Expect(0, 4987, '\P{^Numeric_Value=00000000010000}', ""); +Error('\p{Nv=/a/__+0 0_0 0 0 0-010000}'); +Error('\P{Nv=/a/__+0 0_0 0 0 0-010000}'); +Expect(1, 4988, '\p{Nv=+0_0_0_0_0_0_1_0_0_00}', ""); +Expect(0, 4988, '\p{^Nv=+0_0_0_0_0_0_1_0_0_00}', ""); +Expect(0, 4988, '\P{Nv=+0_0_0_0_0_0_1_0_0_00}', ""); +Expect(1, 4988, '\P{^Nv=+0_0_0_0_0_0_1_0_0_00}', ""); +Expect(0, 4987, '\p{Nv=+0_0_0_0_0_0_1_0_0_00}', ""); +Expect(1, 4987, '\p{^Nv=+0_0_0_0_0_0_1_0_0_00}', ""); +Expect(1, 4987, '\P{Nv=+0_0_0_0_0_0_1_0_0_00}', ""); +Expect(0, 4987, '\P{^Nv=+0_0_0_0_0_0_1_0_0_00}', ""); +Error('\p{Is_Numeric_Value= 0 0_0/a/0_0_0010000}'); +Error('\P{Is_Numeric_Value= 0 0_0/a/0_0_0010000}'); +Expect(1, 4988, '\p{Is_Numeric_Value=+010000}', ""); +Expect(0, 4988, '\p{^Is_Numeric_Value=+010000}', ""); +Expect(0, 4988, '\P{Is_Numeric_Value=+010000}', ""); +Expect(1, 4988, '\P{^Is_Numeric_Value=+010000}', ""); +Expect(0, 4987, '\p{Is_Numeric_Value=+010000}', ""); +Expect(1, 4987, '\p{^Is_Numeric_Value=+010000}', ""); +Expect(1, 4987, '\P{Is_Numeric_Value=+010000}', ""); +Expect(0, 4987, '\P{^Is_Numeric_Value=+010000}', ""); +Error('\p{Is_Nv=/a/+0000010000}'); +Error('\P{Is_Nv=/a/+0000010000}'); +Expect(1, 4988, '\p{Is_Nv=000_000_010_000}', ""); +Expect(0, 4988, '\p{^Is_Nv=000_000_010_000}', ""); +Expect(0, 4988, '\P{Is_Nv=000_000_010_000}', ""); +Expect(1, 4988, '\P{^Is_Nv=000_000_010_000}', ""); +Expect(0, 4987, '\p{Is_Nv=000_000_010_000}', ""); +Expect(1, 4987, '\p{^Is_Nv=000_000_010_000}', ""); +Expect(1, 4987, '\P{Is_Nv=000_000_010_000}', ""); +Expect(0, 4987, '\P{^Is_Nv=000_000_010_000}', ""); +Error('\p{Numeric_Value= /a/0000 0004_7}'); +Error('\P{Numeric_Value= /a/0000 0004_7}'); +Expect(1, 12988, '\p{Numeric_Value=+047}', ""); +Expect(0, 12988, '\p{^Numeric_Value=+047}', ""); +Expect(0, 12988, '\P{Numeric_Value=+047}', ""); +Expect(1, 12988, '\P{^Numeric_Value=+047}', ""); +Expect(0, 12987, '\p{Numeric_Value=+047}', ""); +Expect(1, 12987, '\p{^Numeric_Value=+047}', ""); +Expect(1, 12987, '\P{Numeric_Value=+047}', ""); +Expect(0, 12987, '\P{^Numeric_Value=+047}', ""); +Error('\p{Nv=--00/a/00_47}'); +Error('\P{Nv=--00/a/00_47}'); +Expect(1, 12988, '\p{Nv=000047}', ""); +Expect(0, 12988, '\p{^Nv=000047}', ""); +Expect(0, 12988, '\P{Nv=000047}', ""); +Expect(1, 12988, '\P{^Nv=000047}', ""); +Expect(0, 12987, '\p{Nv=000047}', ""); +Expect(1, 12987, '\p{^Nv=000047}', ""); +Expect(1, 12987, '\P{Nv=000047}', ""); +Expect(0, 12987, '\P{^Nv=000047}', ""); +Error('\p{Is_Numeric_Value= -00_0 47:=}'); +Error('\P{Is_Numeric_Value= -00_0 47:=}'); +Expect(1, 12988, '\p{Is_Numeric_Value=00000047}', ""); +Expect(0, 12988, '\p{^Is_Numeric_Value=00000047}', ""); +Expect(0, 12988, '\P{Is_Numeric_Value=00000047}', ""); +Expect(1, 12988, '\P{^Is_Numeric_Value=00000047}', ""); +Expect(0, 12987, '\p{Is_Numeric_Value=00000047}', ""); +Expect(1, 12987, '\p{^Is_Numeric_Value=00000047}', ""); +Expect(1, 12987, '\P{Is_Numeric_Value=00000047}', ""); +Expect(0, 12987, '\P{^Is_Numeric_Value=00000047}', ""); +Error('\p{Is_Nv=/a/-_000000047}'); +Error('\P{Is_Nv=/a/-_000000047}'); +Expect(1, 12988, '\p{Is_Nv=00000047}', ""); +Expect(0, 12988, '\p{^Is_Nv=00000047}', ""); +Expect(0, 12988, '\P{Is_Nv=00000047}', ""); +Expect(1, 12988, '\P{^Is_Nv=00000047}', ""); +Expect(0, 12987, '\p{Is_Nv=00000047}', ""); +Expect(1, 12987, '\p{^Is_Nv=00000047}', ""); +Expect(1, 12987, '\P{Is_Nv=00000047}', ""); +Expect(0, 12987, '\P{^Is_Nv=00000047}', ""); +Error('\p{Numeric_Value=:=000000001/000006}'); +Error('\P{Numeric_Value=:=000000001/000006}'); +Expect(1, 8537, '\p{Numeric_Value=+1/0006}', ""); +Expect(0, 8537, '\p{^Numeric_Value=+1/0006}', ""); +Expect(0, 8537, '\P{Numeric_Value=+1/0006}', ""); +Expect(1, 8537, '\P{^Numeric_Value=+1/0006}', ""); +Expect(0, 8536, '\p{Numeric_Value=+1/0006}', ""); +Expect(1, 8536, '\p{^Numeric_Value=+1/0006}', ""); +Expect(1, 8536, '\P{Numeric_Value=+1/0006}', ""); +Expect(0, 8536, '\P{^Numeric_Value=+1/0006}', ""); +Error('\p{Numeric_Value=0.17}'); +Error('\P{Numeric_Value=0.17}'); +Expect(1, 8537, '\p{Numeric_Value=0.167}', ""); +Expect(0, 8537, '\p{^Numeric_Value=0.167}', ""); +Expect(0, 8537, '\P{Numeric_Value=0.167}', ""); +Expect(1, 8537, '\P{^Numeric_Value=0.167}', ""); +Expect(0, 8536, '\p{Numeric_Value=0.167}', ""); +Expect(1, 8536, '\p{^Numeric_Value=0.167}', ""); +Expect(1, 8536, '\P{Numeric_Value=0.167}', ""); +Expect(0, 8536, '\P{^Numeric_Value=0.167}', ""); +Error('\p{Nv=_-000000001/00006:=}'); +Error('\P{Nv=_-000000001/00006:=}'); +Expect(1, 8537, '\p{Nv=000001/06}', ""); +Expect(0, 8537, '\p{^Nv=000001/06}', ""); +Expect(0, 8537, '\P{Nv=000001/06}', ""); +Expect(1, 8537, '\P{^Nv=000001/06}', ""); +Expect(0, 8536, '\p{Nv=000001/06}', ""); +Expect(1, 8536, '\p{^Nv=000001/06}', ""); +Expect(1, 8536, '\P{Nv=000001/06}', ""); +Expect(0, 8536, '\P{^Nv=000001/06}', ""); +Error('\p{Nv=0.17}'); +Error('\P{Nv=0.17}'); +Expect(1, 8537, '\p{Nv=0.167}', ""); +Expect(0, 8537, '\p{^Nv=0.167}', ""); +Expect(0, 8537, '\P{Nv=0.167}', ""); +Expect(1, 8537, '\P{^Nv=0.167}', ""); +Expect(0, 8536, '\p{Nv=0.167}', ""); +Expect(1, 8536, '\p{^Nv=0.167}', ""); +Expect(1, 8536, '\P{Nv=0.167}', ""); +Expect(0, 8536, '\P{^Nv=0.167}', ""); +Error('\p{Is_Numeric_Value= +00000001/06/a/}'); +Error('\P{Is_Numeric_Value= +00000001/06/a/}'); +Expect(1, 8537, '\p{Is_Numeric_Value: +0001/006}', ""); +Expect(0, 8537, '\p{^Is_Numeric_Value: +0001/006}', ""); +Expect(0, 8537, '\P{Is_Numeric_Value: +0001/006}', ""); +Expect(1, 8537, '\P{^Is_Numeric_Value: +0001/006}', ""); +Expect(0, 8536, '\p{Is_Numeric_Value: +0001/006}', ""); +Expect(1, 8536, '\p{^Is_Numeric_Value: +0001/006}', ""); +Expect(1, 8536, '\P{Is_Numeric_Value: +0001/006}', ""); +Expect(0, 8536, '\P{^Is_Numeric_Value: +0001/006}', ""); +Error('\p{Is_Numeric_Value=0.17}'); +Error('\P{Is_Numeric_Value=0.17}'); +Expect(1, 8537, '\p{Is_Numeric_Value=0.167}', ""); +Expect(0, 8537, '\p{^Is_Numeric_Value=0.167}', ""); +Expect(0, 8537, '\P{Is_Numeric_Value=0.167}', ""); +Expect(1, 8537, '\P{^Is_Numeric_Value=0.167}', ""); +Expect(0, 8536, '\p{Is_Numeric_Value=0.167}', ""); +Expect(1, 8536, '\p{^Is_Numeric_Value=0.167}', ""); +Expect(1, 8536, '\P{Is_Numeric_Value=0.167}', ""); +Expect(0, 8536, '\P{^Is_Numeric_Value=0.167}', ""); +Error('\p{Is_Nv= :=0000000001/00000006}'); +Error('\P{Is_Nv= :=0000000001/00000006}'); +Expect(1, 8537, '\p{Is_Nv=0000001/000000006}', ""); +Expect(0, 8537, '\p{^Is_Nv=0000001/000000006}', ""); +Expect(0, 8537, '\P{Is_Nv=0000001/000000006}', ""); +Expect(1, 8537, '\P{^Is_Nv=0000001/000000006}', ""); +Expect(0, 8536, '\p{Is_Nv=0000001/000000006}', ""); +Expect(1, 8536, '\p{^Is_Nv=0000001/000000006}', ""); +Expect(1, 8536, '\P{Is_Nv=0000001/000000006}', ""); +Expect(0, 8536, '\P{^Is_Nv=0000001/000000006}', ""); +Error('\p{Is_Nv=0.17}'); +Error('\P{Is_Nv=0.17}'); +Expect(1, 8537, '\p{Is_Nv=0.167}', ""); +Expect(0, 8537, '\p{^Is_Nv=0.167}', ""); +Expect(0, 8537, '\P{Is_Nv=0.167}', ""); +Expect(1, 8537, '\P{^Is_Nv=0.167}', ""); +Expect(0, 8536, '\p{Is_Nv=0.167}', ""); +Expect(1, 8536, '\p{^Is_Nv=0.167}', ""); +Expect(1, 8536, '\P{Is_Nv=0.167}', ""); +Expect(0, 8536, '\P{^Is_Nv=0.167}', ""); +Error('\p{Numeric_Value=/a/ 00000038}'); +Error('\P{Numeric_Value=/a/ 00000038}'); +Expect(1, 12979, '\p{Numeric_Value=00_00_03_8}', ""); +Expect(0, 12979, '\p{^Numeric_Value=00_00_03_8}', ""); +Expect(0, 12979, '\P{Numeric_Value=00_00_03_8}', ""); +Expect(1, 12979, '\P{^Numeric_Value=00_00_03_8}', ""); +Expect(0, 12978, '\p{Numeric_Value=00_00_03_8}', ""); +Expect(1, 12978, '\p{^Numeric_Value=00_00_03_8}', ""); +Expect(1, 12978, '\P{Numeric_Value=00_00_03_8}', ""); +Expect(0, 12978, '\P{^Numeric_Value=00_00_03_8}', ""); +Error('\p{Nv=:= _3 8}'); +Error('\P{Nv=:= _3 8}'); +Expect(1, 12979, '\p{Nv=0038}', ""); +Expect(0, 12979, '\p{^Nv=0038}', ""); +Expect(0, 12979, '\P{Nv=0038}', ""); +Expect(1, 12979, '\P{^Nv=0038}', ""); +Expect(0, 12978, '\p{Nv=0038}', ""); +Expect(1, 12978, '\p{^Nv=0038}', ""); +Expect(1, 12978, '\P{Nv=0038}', ""); +Expect(0, 12978, '\P{^Nv=0038}', ""); +Error('\p{Is_Numeric_Value= :=+000 000 003-8}'); +Error('\P{Is_Numeric_Value= :=+000 000 003-8}'); +Expect(1, 12979, '\p{Is_Numeric_Value=00000038}', ""); +Expect(0, 12979, '\p{^Is_Numeric_Value=00000038}', ""); +Expect(0, 12979, '\P{Is_Numeric_Value=00000038}', ""); +Expect(1, 12979, '\P{^Is_Numeric_Value=00000038}', ""); +Expect(0, 12978, '\p{Is_Numeric_Value=00000038}', ""); +Expect(1, 12978, '\p{^Is_Numeric_Value=00000038}', ""); +Expect(1, 12978, '\P{Is_Numeric_Value=00000038}', ""); +Expect(0, 12978, '\P{^Is_Numeric_Value=00000038}', ""); +Error('\p{Is_Nv=-_0_0/a/0 38}'); +Error('\P{Is_Nv=-_0_0/a/0 38}'); +Expect(1, 12979, '\p{Is_Nv=0_0_38}', ""); +Expect(0, 12979, '\p{^Is_Nv=0_0_38}', ""); +Expect(0, 12979, '\P{Is_Nv=0_0_38}', ""); +Expect(1, 12979, '\P{^Is_Nv=0_0_38}', ""); +Expect(0, 12978, '\p{Is_Nv=0_0_38}', ""); +Expect(1, 12978, '\p{^Is_Nv=0_0_38}', ""); +Expect(1, 12978, '\P{Is_Nv=0_0_38}', ""); +Expect(0, 12978, '\P{^Is_Nv=0_0_38}', ""); +Error('\p{Numeric_Value=_+008:=}'); +Error('\P{Numeric_Value=_+008:=}'); +Expect(1, 56, '\p{Numeric_Value=0008}', ""); +Expect(0, 56, '\p{^Numeric_Value=0008}', ""); +Expect(0, 56, '\P{Numeric_Value=0008}', ""); +Expect(1, 56, '\P{^Numeric_Value=0008}', ""); +Expect(0, 55, '\p{Numeric_Value=0008}', ""); +Expect(1, 55, '\p{^Numeric_Value=0008}', ""); +Expect(1, 55, '\P{Numeric_Value=0008}', ""); +Expect(0, 55, '\P{^Numeric_Value=0008}', ""); +Error('\p{Nv=:= -0000000008}'); +Error('\P{Nv=:= -0000000008}'); +Expect(1, 56, '\p{Nv: 8}', ""); +Expect(0, 56, '\p{^Nv: 8}', ""); +Expect(0, 56, '\P{Nv: 8}', ""); +Expect(1, 56, '\P{^Nv: 8}', ""); +Expect(0, 55, '\p{Nv: 8}', ""); +Expect(1, 55, '\p{^Nv: 8}', ""); +Expect(1, 55, '\P{Nv: 8}', ""); +Expect(0, 55, '\P{^Nv: 8}', ""); +Error('\p{Is_Numeric_Value=/a/ _+8}'); +Error('\P{Is_Numeric_Value=/a/ _+8}'); +Expect(1, 56, '\p{Is_Numeric_Value=0_0_0_0_0008}', ""); +Expect(0, 56, '\p{^Is_Numeric_Value=0_0_0_0_0008}', ""); +Expect(0, 56, '\P{Is_Numeric_Value=0_0_0_0_0008}', ""); +Expect(1, 56, '\P{^Is_Numeric_Value=0_0_0_0_0008}', ""); +Expect(0, 55, '\p{Is_Numeric_Value=0_0_0_0_0008}', ""); +Expect(1, 55, '\p{^Is_Numeric_Value=0_0_0_0_0008}', ""); +Expect(1, 55, '\P{Is_Numeric_Value=0_0_0_0_0008}', ""); +Expect(0, 55, '\P{^Is_Numeric_Value=0_0_0_0_0008}', ""); +Error('\p{Is_Nv=-+008/a/}'); +Error('\P{Is_Nv=-+008/a/}'); +Expect(1, 56, '\p{Is_Nv=00000008}', ""); +Expect(0, 56, '\p{^Is_Nv=00000008}', ""); +Expect(0, 56, '\P{Is_Nv=00000008}', ""); +Expect(1, 56, '\P{^Is_Nv=00000008}', ""); +Expect(0, 55, '\p{Is_Nv=00000008}', ""); +Expect(1, 55, '\p{^Is_Nv=00000008}', ""); +Expect(1, 55, '\P{Is_Nv=00000008}', ""); +Expect(0, 55, '\P{^Is_Nv=00000008}', ""); +Error('\p{Numeric_Value=/a/ 0000000003/000000004}'); +Error('\P{Numeric_Value=/a/ 0000000003/000000004}'); +Expect(1, 3445, '\p{Numeric_Value:00003/00004}', ""); +Expect(0, 3445, '\p{^Numeric_Value:00003/00004}', ""); +Expect(0, 3445, '\P{Numeric_Value:00003/00004}', ""); +Expect(1, 3445, '\P{^Numeric_Value:00003/00004}', ""); +Expect(0, 7, '\p{Numeric_Value:00003/00004}', ""); +Expect(1, 7, '\p{^Numeric_Value:00003/00004}', ""); +Expect(1, 7, '\P{Numeric_Value:00003/00004}', ""); +Expect(0, 7, '\P{^Numeric_Value:00003/00004}', ""); +Expect(1, 3445, '\p{Numeric_Value=0.750}', ""); +Expect(0, 3445, '\p{^Numeric_Value=0.750}', ""); +Expect(0, 3445, '\P{Numeric_Value=0.750}', ""); +Expect(1, 3445, '\P{^Numeric_Value=0.750}', ""); +Expect(0, 7, '\p{Numeric_Value=0.750}', ""); +Expect(1, 7, '\p{^Numeric_Value=0.750}', ""); +Expect(1, 7, '\P{Numeric_Value=0.750}', ""); +Expect(0, 7, '\P{^Numeric_Value=0.750}', ""); +Error('\p{Nv= :=000003/004}'); +Error('\P{Nv= :=000003/004}'); +Expect(1, 3445, '\p{Nv=00000003/000004}', ""); +Expect(0, 3445, '\p{^Nv=00000003/000004}', ""); +Expect(0, 3445, '\P{Nv=00000003/000004}', ""); +Expect(1, 3445, '\P{^Nv=00000003/000004}', ""); +Expect(0, 7, '\p{Nv=00000003/000004}', ""); +Expect(1, 7, '\p{^Nv=00000003/000004}', ""); +Expect(1, 7, '\P{Nv=00000003/000004}', ""); +Expect(0, 7, '\P{^Nv=00000003/000004}', ""); +Expect(1, 3445, '\p{Nv=0.750}', ""); +Expect(0, 3445, '\p{^Nv=0.750}', ""); +Expect(0, 3445, '\P{Nv=0.750}', ""); +Expect(1, 3445, '\P{^Nv=0.750}', ""); +Expect(0, 7, '\p{Nv=0.750}', ""); +Expect(1, 7, '\p{^Nv=0.750}', ""); +Expect(1, 7, '\P{Nv=0.750}', ""); +Expect(0, 7, '\P{^Nv=0.750}', ""); +Error('\p{Is_Numeric_Value= 003/4/a/}'); +Error('\P{Is_Numeric_Value= 003/4/a/}'); +Expect(1, 3445, '\p{Is_Numeric_Value=03/04}', ""); +Expect(0, 3445, '\p{^Is_Numeric_Value=03/04}', ""); +Expect(0, 3445, '\P{Is_Numeric_Value=03/04}', ""); +Expect(1, 3445, '\P{^Is_Numeric_Value=03/04}', ""); +Expect(0, 7, '\p{Is_Numeric_Value=03/04}', ""); +Expect(1, 7, '\p{^Is_Numeric_Value=03/04}', ""); +Expect(1, 7, '\P{Is_Numeric_Value=03/04}', ""); +Expect(0, 7, '\P{^Is_Numeric_Value=03/04}', ""); +Expect(1, 3445, '\p{Is_Numeric_Value=0.750}', ""); +Expect(0, 3445, '\p{^Is_Numeric_Value=0.750}', ""); +Expect(0, 3445, '\P{Is_Numeric_Value=0.750}', ""); +Expect(1, 3445, '\P{^Is_Numeric_Value=0.750}', ""); +Expect(0, 7, '\p{Is_Numeric_Value=0.750}', ""); +Expect(1, 7, '\p{^Is_Numeric_Value=0.750}', ""); +Expect(1, 7, '\P{Is_Numeric_Value=0.750}', ""); +Expect(0, 7, '\P{^Is_Numeric_Value=0.750}', ""); +Error('\p{Is_Nv=_:=00003/0000000004}'); +Error('\P{Is_Nv=_:=00003/0000000004}'); +Expect(1, 3445, '\p{Is_Nv=0000000003/04}', ""); +Expect(0, 3445, '\p{^Is_Nv=0000000003/04}', ""); +Expect(0, 3445, '\P{Is_Nv=0000000003/04}', ""); +Expect(1, 3445, '\P{^Is_Nv=0000000003/04}', ""); +Expect(0, 7, '\p{Is_Nv=0000000003/04}', ""); +Expect(1, 7, '\p{^Is_Nv=0000000003/04}', ""); +Expect(1, 7, '\P{Is_Nv=0000000003/04}', ""); +Expect(0, 7, '\P{^Is_Nv=0000000003/04}', ""); +Expect(1, 3445, '\p{Is_Nv: 0.750}', ""); +Expect(0, 3445, '\p{^Is_Nv: 0.750}', ""); +Expect(0, 3445, '\P{Is_Nv: 0.750}', ""); +Expect(1, 3445, '\P{^Is_Nv: 0.750}', ""); +Expect(0, 7, '\p{Is_Nv: 0.750}', ""); +Expect(1, 7, '\p{^Is_Nv: 0.750}', ""); +Expect(1, 7, '\P{Is_Nv: 0.750}', ""); +Expect(0, 7, '\P{^Is_Nv: 0.750}', ""); +Error('\p{Numeric_Value=/a/--0004}'); +Error('\P{Numeric_Value=/a/--0004}'); +Expect(1, 52, '\p{Numeric_Value=00_00_4}', ""); +Expect(0, 52, '\p{^Numeric_Value=00_00_4}', ""); +Expect(0, 52, '\P{Numeric_Value=00_00_4}', ""); +Expect(1, 52, '\P{^Numeric_Value=00_00_4}', ""); +Expect(0, 51, '\p{Numeric_Value=00_00_4}', ""); +Expect(1, 51, '\p{^Numeric_Value=00_00_4}', ""); +Expect(1, 51, '\P{Numeric_Value=00_00_4}', ""); +Expect(0, 51, '\P{^Numeric_Value=00_00_4}', ""); +Error('\p{Nv= -0/a/4}'); +Error('\P{Nv= -0/a/4}'); +Expect(1, 52, '\p{Nv=+0_0_0_004}', ""); +Expect(0, 52, '\p{^Nv=+0_0_0_004}', ""); +Expect(0, 52, '\P{Nv=+0_0_0_004}', ""); +Expect(1, 52, '\P{^Nv=+0_0_0_004}', ""); +Expect(0, 51, '\p{Nv=+0_0_0_004}', ""); +Expect(1, 51, '\p{^Nv=+0_0_0_004}', ""); +Expect(1, 51, '\P{Nv=+0_0_0_004}', ""); +Expect(0, 51, '\P{^Nv=+0_0_0_004}', ""); +Error('\p{Is_Numeric_Value=_04/a/}'); +Error('\P{Is_Numeric_Value=_04/a/}'); +Expect(1, 52, '\p{Is_Numeric_Value=+00_00_00_00_4}', ""); +Expect(0, 52, '\p{^Is_Numeric_Value=+00_00_00_00_4}', ""); +Expect(0, 52, '\P{Is_Numeric_Value=+00_00_00_00_4}', ""); +Expect(1, 52, '\P{^Is_Numeric_Value=+00_00_00_00_4}', ""); +Expect(0, 51, '\p{Is_Numeric_Value=+00_00_00_00_4}', ""); +Expect(1, 51, '\p{^Is_Numeric_Value=+00_00_00_00_4}', ""); +Expect(1, 51, '\P{Is_Numeric_Value=+00_00_00_00_4}', ""); +Expect(0, 51, '\P{^Is_Numeric_Value=+00_00_00_00_4}', ""); +Error('\p{Is_Nv=:= +0000004}'); +Error('\P{Is_Nv=:= +0000004}'); +Expect(1, 52, '\p{Is_Nv=4}', ""); +Expect(0, 52, '\p{^Is_Nv=4}', ""); +Expect(0, 52, '\P{Is_Nv=4}', ""); +Expect(1, 52, '\P{^Is_Nv=4}', ""); +Expect(0, 51, '\p{Is_Nv=4}', ""); +Expect(1, 51, '\p{^Is_Nv=4}', ""); +Expect(1, 51, '\P{Is_Nv=4}', ""); +Expect(0, 51, '\P{^Is_Nv=4}', ""); +Error('\p{Numeric_Value=-:=000034}'); +Error('\P{Numeric_Value=-:=000034}'); +Expect(1, 12894, '\p{Numeric_Value=0003_4}', ""); +Expect(0, 12894, '\p{^Numeric_Value=0003_4}', ""); +Expect(0, 12894, '\P{Numeric_Value=0003_4}', ""); +Expect(1, 12894, '\P{^Numeric_Value=0003_4}', ""); +Expect(0, 12893, '\p{Numeric_Value=0003_4}', ""); +Expect(1, 12893, '\p{^Numeric_Value=0003_4}', ""); +Expect(1, 12893, '\P{Numeric_Value=0003_4}', ""); +Expect(0, 12893, '\P{^Numeric_Value=0003_4}', ""); +Error('\p{Nv=__0000034/a/}'); +Error('\P{Nv=__0000034/a/}'); +Expect(1, 12894, '\p{Nv=00000000034}', ""); +Expect(0, 12894, '\p{^Nv=00000000034}', ""); +Expect(0, 12894, '\P{Nv=00000000034}', ""); +Expect(1, 12894, '\P{^Nv=00000000034}', ""); +Expect(0, 12893, '\p{Nv=00000000034}', ""); +Expect(1, 12893, '\p{^Nv=00000000034}', ""); +Expect(1, 12893, '\P{Nv=00000000034}', ""); +Expect(0, 12893, '\P{^Nv=00000000034}', ""); +Error('\p{Is_Numeric_Value=:=+000000034}'); +Error('\P{Is_Numeric_Value=:=+000000034}'); +Expect(1, 12894, '\p{Is_Numeric_Value=0_0_34}', ""); +Expect(0, 12894, '\p{^Is_Numeric_Value=0_0_34}', ""); +Expect(0, 12894, '\P{Is_Numeric_Value=0_0_34}', ""); +Expect(1, 12894, '\P{^Is_Numeric_Value=0_0_34}', ""); +Expect(0, 12893, '\p{Is_Numeric_Value=0_0_34}', ""); +Expect(1, 12893, '\p{^Is_Numeric_Value=0_0_34}', ""); +Expect(1, 12893, '\P{Is_Numeric_Value=0_0_34}', ""); +Expect(0, 12893, '\P{^Is_Numeric_Value=0_0_34}', ""); +Error('\p{Is_Nv= /a/+03-4}'); +Error('\P{Is_Nv= /a/+03-4}'); +Expect(1, 12894, '\p{Is_Nv=3_4}', ""); +Expect(0, 12894, '\p{^Is_Nv=3_4}', ""); +Expect(0, 12894, '\P{Is_Nv=3_4}', ""); +Expect(1, 12894, '\P{^Is_Nv=3_4}', ""); +Expect(0, 12893, '\p{Is_Nv=3_4}', ""); +Expect(1, 12893, '\p{^Is_Nv=3_4}', ""); +Expect(1, 12893, '\P{Is_Nv=3_4}', ""); +Expect(0, 12893, '\P{^Is_Nv=3_4}', ""); +Error('\p{Numeric_Value=- +00000037:=}'); +Error('\P{Numeric_Value=- +00000037:=}'); +Expect(1, 12978, '\p{Numeric_Value=+037}', ""); +Expect(0, 12978, '\p{^Numeric_Value=+037}', ""); +Expect(0, 12978, '\P{Numeric_Value=+037}', ""); +Expect(1, 12978, '\P{^Numeric_Value=+037}', ""); +Expect(0, 12977, '\p{Numeric_Value=+037}', ""); +Expect(1, 12977, '\p{^Numeric_Value=+037}', ""); +Expect(1, 12977, '\P{Numeric_Value=+037}', ""); +Expect(0, 12977, '\P{^Numeric_Value=+037}', ""); +Error('\p{Nv=:= 0000037}'); +Error('\P{Nv=:= 0000037}'); +Expect(1, 12978, '\p{Nv=0000003_7}', ""); +Expect(0, 12978, '\p{^Nv=0000003_7}', ""); +Expect(0, 12978, '\P{Nv=0000003_7}', ""); +Expect(1, 12978, '\P{^Nv=0000003_7}', ""); +Expect(0, 12977, '\p{Nv=0000003_7}', ""); +Expect(1, 12977, '\p{^Nv=0000003_7}', ""); +Expect(1, 12977, '\P{Nv=0000003_7}', ""); +Expect(0, 12977, '\P{^Nv=0000003_7}', ""); +Error('\p{Is_Numeric_Value= +000:=000 003 7}'); +Error('\P{Is_Numeric_Value= +000:=000 003 7}'); +Expect(1, 12978, '\p{Is_Numeric_Value=0037}', ""); +Expect(0, 12978, '\p{^Is_Numeric_Value=0037}', ""); +Expect(0, 12978, '\P{Is_Numeric_Value=0037}', ""); +Expect(1, 12978, '\P{^Is_Numeric_Value=0037}', ""); +Expect(0, 12977, '\p{Is_Numeric_Value=0037}', ""); +Expect(1, 12977, '\p{^Is_Numeric_Value=0037}', ""); +Expect(1, 12977, '\P{Is_Numeric_Value=0037}', ""); +Expect(0, 12977, '\P{^Is_Numeric_Value=0037}', ""); +Error('\p{Is_Nv=/a/ 0000037}'); +Error('\P{Is_Nv=/a/ 0000037}'); +Expect(1, 12978, '\p{Is_Nv=00_00_37}', ""); +Expect(0, 12978, '\p{^Is_Nv=00_00_37}', ""); +Expect(0, 12978, '\P{Is_Nv=00_00_37}', ""); +Expect(1, 12978, '\P{^Is_Nv=00_00_37}', ""); +Expect(0, 12977, '\p{Is_Nv=00_00_37}', ""); +Expect(1, 12977, '\p{^Is_Nv=00_00_37}', ""); +Expect(1, 12977, '\P{Is_Nv=00_00_37}', ""); +Expect(0, 12977, '\P{^Is_Nv=00_00_37}', ""); +Error('\p{Numeric_Value= 000000005/000000002/a/}'); +Error('\P{Numeric_Value= 000000005/000000002/a/}'); +Expect(1, 3884, '\p{Numeric_Value=0000000005/2}', ""); +Expect(0, 3884, '\p{^Numeric_Value=0000000005/2}', ""); +Expect(0, 3884, '\P{Numeric_Value=0000000005/2}', ""); +Expect(1, 3884, '\P{^Numeric_Value=0000000005/2}', ""); +Expect(0, 3883, '\p{Numeric_Value=0000000005/2}', ""); +Expect(1, 3883, '\p{^Numeric_Value=0000000005/2}', ""); +Expect(1, 3883, '\P{Numeric_Value=0000000005/2}', ""); +Expect(0, 3883, '\P{^Numeric_Value=0000000005/2}', ""); +Expect(1, 3884, '\p{Numeric_Value=2.500}', ""); +Expect(0, 3884, '\p{^Numeric_Value=2.500}', ""); +Expect(0, 3884, '\P{Numeric_Value=2.500}', ""); +Expect(1, 3884, '\P{^Numeric_Value=2.500}', ""); +Expect(0, 3883, '\p{Numeric_Value=2.500}', ""); +Expect(1, 3883, '\p{^Numeric_Value=2.500}', ""); +Expect(1, 3883, '\P{Numeric_Value=2.500}', ""); +Expect(0, 3883, '\P{^Numeric_Value=2.500}', ""); +Error('\p{Nv=_ 5/000000002:=}'); +Error('\P{Nv=_ 5/000000002:=}'); +Expect(1, 3884, '\p{Nv=+0000000005/0002}', ""); +Expect(0, 3884, '\p{^Nv=+0000000005/0002}', ""); +Expect(0, 3884, '\P{Nv=+0000000005/0002}', ""); +Expect(1, 3884, '\P{^Nv=+0000000005/0002}', ""); +Expect(0, 3883, '\p{Nv=+0000000005/0002}', ""); +Expect(1, 3883, '\p{^Nv=+0000000005/0002}', ""); +Expect(1, 3883, '\P{Nv=+0000000005/0002}', ""); +Expect(0, 3883, '\P{^Nv=+0000000005/0002}', ""); +Expect(1, 3884, '\p{Nv=2.500}', ""); +Expect(0, 3884, '\p{^Nv=2.500}', ""); +Expect(0, 3884, '\P{Nv=2.500}', ""); +Expect(1, 3884, '\P{^Nv=2.500}', ""); +Expect(0, 3883, '\p{Nv=2.500}', ""); +Expect(1, 3883, '\p{^Nv=2.500}', ""); +Expect(1, 3883, '\P{Nv=2.500}', ""); +Expect(0, 3883, '\P{^Nv=2.500}', ""); +Error('\p{Is_Numeric_Value= /a/5/002}'); +Error('\P{Is_Numeric_Value= /a/5/002}'); +Expect(1, 3884, '\p{Is_Numeric_Value=000000005/00002}', ""); +Expect(0, 3884, '\p{^Is_Numeric_Value=000000005/00002}', ""); +Expect(0, 3884, '\P{Is_Numeric_Value=000000005/00002}', ""); +Expect(1, 3884, '\P{^Is_Numeric_Value=000000005/00002}', ""); +Expect(0, 3883, '\p{Is_Numeric_Value=000000005/00002}', ""); +Expect(1, 3883, '\p{^Is_Numeric_Value=000000005/00002}', ""); +Expect(1, 3883, '\P{Is_Numeric_Value=000000005/00002}', ""); +Expect(0, 3883, '\P{^Is_Numeric_Value=000000005/00002}', ""); +Expect(1, 3884, '\p{Is_Numeric_Value=2.500}', ""); +Expect(0, 3884, '\p{^Is_Numeric_Value=2.500}', ""); +Expect(0, 3884, '\P{Is_Numeric_Value=2.500}', ""); +Expect(1, 3884, '\P{^Is_Numeric_Value=2.500}', ""); +Expect(0, 3883, '\p{Is_Numeric_Value=2.500}', ""); +Expect(1, 3883, '\p{^Is_Numeric_Value=2.500}', ""); +Expect(1, 3883, '\P{Is_Numeric_Value=2.500}', ""); +Expect(0, 3883, '\P{^Is_Numeric_Value=2.500}', ""); +Error('\p{Is_Nv=_:=+5/00000002}'); +Error('\P{Is_Nv=_:=+5/00000002}'); +Expect(1, 3884, '\p{Is_Nv: 000005/0002}', ""); +Expect(0, 3884, '\p{^Is_Nv: 000005/0002}', ""); +Expect(0, 3884, '\P{Is_Nv: 000005/0002}', ""); +Expect(1, 3884, '\P{^Is_Nv: 000005/0002}', ""); +Expect(0, 3883, '\p{Is_Nv: 000005/0002}', ""); +Expect(1, 3883, '\p{^Is_Nv: 000005/0002}', ""); +Expect(1, 3883, '\P{Is_Nv: 000005/0002}', ""); +Expect(0, 3883, '\P{^Is_Nv: 000005/0002}', ""); +Expect(1, 3884, '\p{Is_Nv:2.500}', ""); +Expect(0, 3884, '\p{^Is_Nv:2.500}', ""); +Expect(0, 3884, '\P{Is_Nv:2.500}', ""); +Expect(1, 3884, '\P{^Is_Nv:2.500}', ""); +Expect(0, 3883, '\p{Is_Nv:2.500}', ""); +Expect(1, 3883, '\p{^Is_Nv:2.500}', ""); +Expect(1, 3883, '\P{Is_Nv:2.500}', ""); +Expect(0, 3883, '\P{^Is_Nv:2.500}', ""); +Error('\p{Numeric_Value=-/a/1000}'); +Error('\P{Numeric_Value=-/a/1000}'); +Expect(1, 3058, '\p{Numeric_Value=+0001000}', ""); +Expect(0, 3058, '\p{^Numeric_Value=+0001000}', ""); +Expect(0, 3058, '\P{Numeric_Value=+0001000}', ""); +Expect(1, 3058, '\P{^Numeric_Value=+0001000}', ""); +Expect(0, 3057, '\p{Numeric_Value=+0001000}', ""); +Expect(1, 3057, '\p{^Numeric_Value=+0001000}', ""); +Expect(1, 3057, '\P{Numeric_Value=+0001000}', ""); +Expect(0, 3057, '\P{^Numeric_Value=+0001000}', ""); +Error('\p{Nv=:= +0000001000}'); +Error('\P{Nv=:= +0000001000}'); +Expect(1, 3058, '\p{Nv=+00001000}', ""); +Expect(0, 3058, '\p{^Nv=+00001000}', ""); +Expect(0, 3058, '\P{Nv=+00001000}', ""); +Expect(1, 3058, '\P{^Nv=+00001000}', ""); +Expect(0, 3057, '\p{Nv=+00001000}', ""); +Expect(1, 3057, '\p{^Nv=+00001000}', ""); +Expect(1, 3057, '\P{Nv=+00001000}', ""); +Expect(0, 3057, '\P{^Nv=+00001000}', ""); +Error('\p{Is_Numeric_Value= -001000:=}'); +Error('\P{Is_Numeric_Value= -001000:=}'); +Expect(1, 3058, '\p{Is_Numeric_Value=+01000}', ""); +Expect(0, 3058, '\p{^Is_Numeric_Value=+01000}', ""); +Expect(0, 3058, '\P{Is_Numeric_Value=+01000}', ""); +Expect(1, 3058, '\P{^Is_Numeric_Value=+01000}', ""); +Expect(0, 3057, '\p{Is_Numeric_Value=+01000}', ""); +Expect(1, 3057, '\p{^Is_Numeric_Value=+01000}', ""); +Expect(1, 3057, '\P{Is_Numeric_Value=+01000}', ""); +Expect(0, 3057, '\P{^Is_Numeric_Value=+01000}', ""); +Error('\p{Is_Nv=_/a/0001000}'); +Error('\P{Is_Nv=_/a/0001000}'); +Expect(1, 3058, '\p{Is_Nv=+0_0_0_0_1_000}', ""); +Expect(0, 3058, '\p{^Is_Nv=+0_0_0_0_1_000}', ""); +Expect(0, 3058, '\P{Is_Nv=+0_0_0_0_1_000}', ""); +Expect(1, 3058, '\P{^Is_Nv=+0_0_0_0_1_000}', ""); +Expect(0, 3057, '\p{Is_Nv=+0_0_0_0_1_000}', ""); +Expect(1, 3057, '\p{^Is_Nv=+0_0_0_0_1_000}', ""); +Expect(1, 3057, '\P{Is_Nv=+0_0_0_0_1_000}', ""); +Expect(0, 3057, '\P{^Is_Nv=+0_0_0_0_1_000}', ""); +Error('\p{Numeric_Value=:= -043}'); +Error('\P{Numeric_Value=:= -043}'); +Expect(1, 12984, '\p{Numeric_Value=0_0_0_043}', ""); +Expect(0, 12984, '\p{^Numeric_Value=0_0_0_043}', ""); +Expect(0, 12984, '\P{Numeric_Value=0_0_0_043}', ""); +Expect(1, 12984, '\P{^Numeric_Value=0_0_0_043}', ""); +Expect(0, 12983, '\p{Numeric_Value=0_0_0_043}', ""); +Expect(1, 12983, '\p{^Numeric_Value=0_0_0_043}', ""); +Expect(1, 12983, '\P{Numeric_Value=0_0_0_043}', ""); +Expect(0, 12983, '\P{^Numeric_Value=0_0_0_043}', ""); +Error('\p{Nv=:=__0000000043}'); +Error('\P{Nv=:=__0000000043}'); +Expect(1, 12984, '\p{Nv=+00000043}', ""); +Expect(0, 12984, '\p{^Nv=+00000043}', ""); +Expect(0, 12984, '\P{Nv=+00000043}', ""); +Expect(1, 12984, '\P{^Nv=+00000043}', ""); +Expect(0, 12983, '\p{Nv=+00000043}', ""); +Expect(1, 12983, '\p{^Nv=+00000043}', ""); +Expect(1, 12983, '\P{Nv=+00000043}', ""); +Expect(0, 12983, '\P{^Nv=+00000043}', ""); +Error('\p{Is_Numeric_Value=:= _00000_00004 3}'); +Error('\P{Is_Numeric_Value=:= _00000_00004 3}'); +Expect(1, 12984, '\p{Is_Numeric_Value=000_000_004_3}', ""); +Expect(0, 12984, '\p{^Is_Numeric_Value=000_000_004_3}', ""); +Expect(0, 12984, '\P{Is_Numeric_Value=000_000_004_3}', ""); +Expect(1, 12984, '\P{^Is_Numeric_Value=000_000_004_3}', ""); +Expect(0, 12983, '\p{Is_Numeric_Value=000_000_004_3}', ""); +Expect(1, 12983, '\p{^Is_Numeric_Value=000_000_004_3}', ""); +Expect(1, 12983, '\P{Is_Numeric_Value=000_000_004_3}', ""); +Expect(0, 12983, '\P{^Is_Numeric_Value=000_000_004_3}', ""); +Error('\p{Is_Nv= /a/00000000043}'); +Error('\P{Is_Nv= /a/00000000043}'); +Expect(1, 12984, '\p{Is_Nv=00000043}', ""); +Expect(0, 12984, '\p{^Is_Nv=00000043}', ""); +Expect(0, 12984, '\P{Is_Nv=00000043}', ""); +Expect(1, 12984, '\P{^Is_Nv=00000043}', ""); +Expect(0, 12983, '\p{Is_Nv=00000043}', ""); +Expect(1, 12983, '\p{^Is_Nv=00000043}', ""); +Expect(1, 12983, '\P{Is_Nv=00000043}', ""); +Expect(0, 12983, '\P{^Is_Nv=00000043}', ""); +Error('\p{Numeric_Value= +00:=5}'); +Error('\P{Numeric_Value= +00:=5}'); +Expect(1, 53, '\p{Numeric_Value=+5}', ""); +Expect(0, 53, '\p{^Numeric_Value=+5}', ""); +Expect(0, 53, '\P{Numeric_Value=+5}', ""); +Expect(1, 53, '\P{^Numeric_Value=+5}', ""); +Expect(0, 52, '\p{Numeric_Value=+5}', ""); +Expect(1, 52, '\p{^Numeric_Value=+5}', ""); +Expect(1, 52, '\P{Numeric_Value=+5}', ""); +Expect(0, 52, '\P{^Numeric_Value=+5}', ""); +Error('\p{Nv=_:=5}'); +Error('\P{Nv=_:=5}'); +Expect(1, 53, '\p{Nv=00000005}', ""); +Expect(0, 53, '\p{^Nv=00000005}', ""); +Expect(0, 53, '\P{Nv=00000005}', ""); +Expect(1, 53, '\P{^Nv=00000005}', ""); +Expect(0, 52, '\p{Nv=00000005}', ""); +Expect(1, 52, '\p{^Nv=00000005}', ""); +Expect(1, 52, '\P{Nv=00000005}', ""); +Expect(0, 52, '\P{^Nv=00000005}', ""); +Error('\p{Is_Numeric_Value=:= 0005}'); +Error('\P{Is_Numeric_Value=:= 0005}'); +Expect(1, 53, '\p{Is_Numeric_Value=+00005}', ""); +Expect(0, 53, '\p{^Is_Numeric_Value=+00005}', ""); +Expect(0, 53, '\P{Is_Numeric_Value=+00005}', ""); +Expect(1, 53, '\P{^Is_Numeric_Value=+00005}', ""); +Expect(0, 52, '\p{Is_Numeric_Value=+00005}', ""); +Expect(1, 52, '\p{^Is_Numeric_Value=+00005}', ""); +Expect(1, 52, '\P{Is_Numeric_Value=+00005}', ""); +Expect(0, 52, '\P{^Is_Numeric_Value=+00005}', ""); +Error('\p{Is_Nv=/a/00000005}'); +Error('\P{Is_Nv=/a/00000005}'); +Expect(1, 53, '\p{Is_Nv=0_0_05}', ""); +Expect(0, 53, '\p{^Is_Nv=0_0_05}', ""); +Expect(0, 53, '\P{Is_Nv=0_0_05}', ""); +Expect(1, 53, '\P{^Is_Nv=0_0_05}', ""); +Expect(0, 52, '\p{Is_Nv=0_0_05}', ""); +Expect(1, 52, '\p{^Is_Nv=0_0_05}', ""); +Expect(1, 52, '\P{Is_Nv=0_0_05}', ""); +Expect(0, 52, '\P{^Is_Nv=0_0_05}', ""); +Error('\p{Pattern_Syntax=_YES/a/}'); +Error('\P{Pattern_Syntax=_YES/a/}'); +Expect(1, 47, '\p{Pattern_Syntax=yes}', ""); +Expect(0, 47, '\p{^Pattern_Syntax=yes}', ""); +Expect(0, 47, '\P{Pattern_Syntax=yes}', ""); +Expect(1, 47, '\P{^Pattern_Syntax=yes}', ""); +Expect(0, 32, '\p{Pattern_Syntax=yes}', ""); +Expect(1, 32, '\p{^Pattern_Syntax=yes}', ""); +Expect(1, 32, '\P{Pattern_Syntax=yes}', ""); +Expect(0, 32, '\P{^Pattern_Syntax=yes}', ""); +Expect(1, 47, '\p{Pattern_Syntax=-_yes}', ""); +Expect(0, 47, '\p{^Pattern_Syntax=-_yes}', ""); +Expect(0, 47, '\P{Pattern_Syntax=-_yes}', ""); +Expect(1, 47, '\P{^Pattern_Syntax=-_yes}', ""); +Expect(0, 32, '\p{Pattern_Syntax=-_yes}', ""); +Expect(1, 32, '\p{^Pattern_Syntax=-_yes}', ""); +Expect(1, 32, '\P{Pattern_Syntax=-_yes}', ""); +Expect(0, 32, '\P{^Pattern_Syntax=-_yes}', ""); +Error('\p{Pat_Syn=:=-Y}'); +Error('\P{Pat_Syn=:=-Y}'); +Expect(1, 47, '\p{Pat_Syn=y}', ""); +Expect(0, 47, '\p{^Pat_Syn=y}', ""); +Expect(0, 47, '\P{Pat_Syn=y}', ""); +Expect(1, 47, '\P{^Pat_Syn=y}', ""); +Expect(0, 32, '\p{Pat_Syn=y}', ""); +Expect(1, 32, '\p{^Pat_Syn=y}', ""); +Expect(1, 32, '\P{Pat_Syn=y}', ""); +Expect(0, 32, '\P{^Pat_Syn=y}', ""); +Expect(1, 47, '\p{Pat_Syn= Y}', ""); +Expect(0, 47, '\p{^Pat_Syn= Y}', ""); +Expect(0, 47, '\P{Pat_Syn= Y}', ""); +Expect(1, 47, '\P{^Pat_Syn= Y}', ""); +Expect(0, 32, '\p{Pat_Syn= Y}', ""); +Expect(1, 32, '\p{^Pat_Syn= Y}', ""); +Expect(1, 32, '\P{Pat_Syn= Y}', ""); +Expect(0, 32, '\P{^Pat_Syn= Y}', ""); +Error('\p{Is_Pattern_Syntax= T/a/}'); +Error('\P{Is_Pattern_Syntax= T/a/}'); +Expect(1, 47, '\p{Is_Pattern_Syntax:t}', ""); +Expect(0, 47, '\p{^Is_Pattern_Syntax:t}', ""); +Expect(0, 47, '\P{Is_Pattern_Syntax:t}', ""); +Expect(1, 47, '\P{^Is_Pattern_Syntax:t}', ""); +Expect(0, 32, '\p{Is_Pattern_Syntax:t}', ""); +Expect(1, 32, '\p{^Is_Pattern_Syntax:t}', ""); +Expect(1, 32, '\P{Is_Pattern_Syntax:t}', ""); +Expect(0, 32, '\P{^Is_Pattern_Syntax:t}', ""); +Expect(1, 47, '\p{Is_Pattern_Syntax= T}', ""); +Expect(0, 47, '\p{^Is_Pattern_Syntax= T}', ""); +Expect(0, 47, '\P{Is_Pattern_Syntax= T}', ""); +Expect(1, 47, '\P{^Is_Pattern_Syntax= T}', ""); +Expect(0, 32, '\p{Is_Pattern_Syntax= T}', ""); +Expect(1, 32, '\p{^Is_Pattern_Syntax= T}', ""); +Expect(1, 32, '\P{Is_Pattern_Syntax= T}', ""); +Expect(0, 32, '\P{^Is_Pattern_Syntax= T}', ""); +Error('\p{Is_Pat_Syn= True:=}'); +Error('\P{Is_Pat_Syn= True:=}'); +Expect(1, 47, '\p{Is_Pat_Syn=true}', ""); +Expect(0, 47, '\p{^Is_Pat_Syn=true}', ""); +Expect(0, 47, '\P{Is_Pat_Syn=true}', ""); +Expect(1, 47, '\P{^Is_Pat_Syn=true}', ""); +Expect(0, 32, '\p{Is_Pat_Syn=true}', ""); +Expect(1, 32, '\p{^Is_Pat_Syn=true}', ""); +Expect(1, 32, '\P{Is_Pat_Syn=true}', ""); +Expect(0, 32, '\P{^Is_Pat_Syn=true}', ""); +Expect(1, 47, '\p{Is_Pat_Syn= -True}', ""); +Expect(0, 47, '\p{^Is_Pat_Syn= -True}', ""); +Expect(0, 47, '\P{Is_Pat_Syn= -True}', ""); +Expect(1, 47, '\P{^Is_Pat_Syn= -True}', ""); +Expect(0, 32, '\p{Is_Pat_Syn= -True}', ""); +Expect(1, 32, '\p{^Is_Pat_Syn= -True}', ""); +Expect(1, 32, '\P{Is_Pat_Syn= -True}', ""); +Expect(0, 32, '\P{^Is_Pat_Syn= -True}', ""); +Error('\p{Pattern_Syntax= No:=}'); +Error('\P{Pattern_Syntax= No:=}'); +Expect(1, 32, '\p{Pattern_Syntax=no}', ""); +Expect(0, 32, '\p{^Pattern_Syntax=no}', ""); +Expect(0, 32, '\P{Pattern_Syntax=no}', ""); +Expect(1, 32, '\P{^Pattern_Syntax=no}', ""); +Expect(0, 47, '\p{Pattern_Syntax=no}', ""); +Expect(1, 47, '\p{^Pattern_Syntax=no}', ""); +Expect(1, 47, '\P{Pattern_Syntax=no}', ""); +Expect(0, 47, '\P{^Pattern_Syntax=no}', ""); +Expect(1, 32, '\p{Pattern_Syntax= no}', ""); +Expect(0, 32, '\p{^Pattern_Syntax= no}', ""); +Expect(0, 32, '\P{Pattern_Syntax= no}', ""); +Expect(1, 32, '\P{^Pattern_Syntax= no}', ""); +Expect(0, 47, '\p{Pattern_Syntax= no}', ""); +Expect(1, 47, '\p{^Pattern_Syntax= no}', ""); +Expect(1, 47, '\P{Pattern_Syntax= no}', ""); +Expect(0, 47, '\P{^Pattern_Syntax= no}', ""); +Error('\p{Pat_Syn=_/a/N}'); +Error('\P{Pat_Syn=_/a/N}'); +Expect(1, 32, '\p{Pat_Syn=n}', ""); +Expect(0, 32, '\p{^Pat_Syn=n}', ""); +Expect(0, 32, '\P{Pat_Syn=n}', ""); +Expect(1, 32, '\P{^Pat_Syn=n}', ""); +Expect(0, 47, '\p{Pat_Syn=n}', ""); +Expect(1, 47, '\p{^Pat_Syn=n}', ""); +Expect(1, 47, '\P{Pat_Syn=n}', ""); +Expect(0, 47, '\P{^Pat_Syn=n}', ""); +Expect(1, 32, '\p{Pat_Syn= n}', ""); +Expect(0, 32, '\p{^Pat_Syn= n}', ""); +Expect(0, 32, '\P{Pat_Syn= n}', ""); +Expect(1, 32, '\P{^Pat_Syn= n}', ""); +Expect(0, 47, '\p{Pat_Syn= n}', ""); +Expect(1, 47, '\p{^Pat_Syn= n}', ""); +Expect(1, 47, '\P{Pat_Syn= n}', ""); +Expect(0, 47, '\P{^Pat_Syn= n}', ""); +Error('\p{Is_Pattern_Syntax= :=f}'); +Error('\P{Is_Pattern_Syntax= :=f}'); +Expect(1, 32, '\p{Is_Pattern_Syntax=f}', ""); +Expect(0, 32, '\p{^Is_Pattern_Syntax=f}', ""); +Expect(0, 32, '\P{Is_Pattern_Syntax=f}', ""); +Expect(1, 32, '\P{^Is_Pattern_Syntax=f}', ""); +Expect(0, 47, '\p{Is_Pattern_Syntax=f}', ""); +Expect(1, 47, '\p{^Is_Pattern_Syntax=f}', ""); +Expect(1, 47, '\P{Is_Pattern_Syntax=f}', ""); +Expect(0, 47, '\P{^Is_Pattern_Syntax=f}', ""); +Expect(1, 32, '\p{Is_Pattern_Syntax=__f}', ""); +Expect(0, 32, '\p{^Is_Pattern_Syntax=__f}', ""); +Expect(0, 32, '\P{Is_Pattern_Syntax=__f}', ""); +Expect(1, 32, '\P{^Is_Pattern_Syntax=__f}', ""); +Expect(0, 47, '\p{Is_Pattern_Syntax=__f}', ""); +Expect(1, 47, '\p{^Is_Pattern_Syntax=__f}', ""); +Expect(1, 47, '\P{Is_Pattern_Syntax=__f}', ""); +Expect(0, 47, '\P{^Is_Pattern_Syntax=__f}', ""); +Error('\p{Is_Pat_Syn: _/a/False}'); +Error('\P{Is_Pat_Syn: _/a/False}'); +Expect(1, 32, '\p{Is_Pat_Syn: false}', ""); +Expect(0, 32, '\p{^Is_Pat_Syn: false}', ""); +Expect(0, 32, '\P{Is_Pat_Syn: false}', ""); +Expect(1, 32, '\P{^Is_Pat_Syn: false}', ""); +Expect(0, 47, '\p{Is_Pat_Syn: false}', ""); +Expect(1, 47, '\p{^Is_Pat_Syn: false}', ""); +Expect(1, 47, '\P{Is_Pat_Syn: false}', ""); +Expect(0, 47, '\P{^Is_Pat_Syn: false}', ""); +Expect(1, 32, '\p{Is_Pat_Syn=- FALSE}', ""); +Expect(0, 32, '\p{^Is_Pat_Syn=- FALSE}', ""); +Expect(0, 32, '\P{Is_Pat_Syn=- FALSE}', ""); +Expect(1, 32, '\P{^Is_Pat_Syn=- FALSE}', ""); +Expect(0, 47, '\p{Is_Pat_Syn=- FALSE}', ""); +Expect(1, 47, '\p{^Is_Pat_Syn=- FALSE}', ""); +Expect(1, 47, '\P{Is_Pat_Syn=- FALSE}', ""); +Expect(0, 47, '\P{^Is_Pat_Syn=- FALSE}', ""); +Error('\p{Numeric_Type=_/a/None}'); +Error('\P{Numeric_Type=_/a/None}'); +Expect(1, 47, '\p{Numeric_Type=none}', ""); +Expect(0, 47, '\p{^Numeric_Type=none}', ""); +Expect(0, 47, '\P{Numeric_Type=none}', ""); +Expect(1, 47, '\P{^Numeric_Type=none}', ""); +Expect(0, 57, '\p{Numeric_Type=none}', ""); +Expect(1, 57, '\p{^Numeric_Type=none}', ""); +Expect(1, 57, '\P{Numeric_Type=none}', ""); +Expect(0, 57, '\P{^Numeric_Type=none}', ""); +Expect(1, 47, '\p{Numeric_Type= none}', ""); +Expect(0, 47, '\p{^Numeric_Type= none}', ""); +Expect(0, 47, '\P{Numeric_Type= none}', ""); +Expect(1, 47, '\P{^Numeric_Type= none}', ""); +Expect(0, 57, '\p{Numeric_Type= none}', ""); +Expect(1, 57, '\p{^Numeric_Type= none}', ""); +Expect(1, 57, '\P{Numeric_Type= none}', ""); +Expect(0, 57, '\P{^Numeric_Type= none}', ""); +Error('\p{Nt=/a/ -none}'); +Error('\P{Nt=/a/ -none}'); +Expect(1, 47, '\p{Nt=none}', ""); +Expect(0, 47, '\p{^Nt=none}', ""); +Expect(0, 47, '\P{Nt=none}', ""); +Expect(1, 47, '\P{^Nt=none}', ""); +Expect(0, 57, '\p{Nt=none}', ""); +Expect(1, 57, '\p{^Nt=none}', ""); +Expect(1, 57, '\P{Nt=none}', ""); +Expect(0, 57, '\P{^Nt=none}', ""); +Expect(1, 47, '\p{Nt=_-None}', ""); +Expect(0, 47, '\p{^Nt=_-None}', ""); +Expect(0, 47, '\P{Nt=_-None}', ""); +Expect(1, 47, '\P{^Nt=_-None}', ""); +Expect(0, 57, '\p{Nt=_-None}', ""); +Expect(1, 57, '\p{^Nt=_-None}', ""); +Expect(1, 57, '\P{Nt=_-None}', ""); +Expect(0, 57, '\P{^Nt=_-None}', ""); +Error('\p{Is_Numeric_Type=- None:=}'); +Error('\P{Is_Numeric_Type=- None:=}'); +Expect(1, 47, '\p{Is_Numeric_Type=none}', ""); +Expect(0, 47, '\p{^Is_Numeric_Type=none}', ""); +Expect(0, 47, '\P{Is_Numeric_Type=none}', ""); +Expect(1, 47, '\P{^Is_Numeric_Type=none}', ""); +Expect(0, 57, '\p{Is_Numeric_Type=none}', ""); +Expect(1, 57, '\p{^Is_Numeric_Type=none}', ""); +Expect(1, 57, '\P{Is_Numeric_Type=none}', ""); +Expect(0, 57, '\P{^Is_Numeric_Type=none}', ""); +Expect(1, 47, '\p{Is_Numeric_Type=- None}', ""); +Expect(0, 47, '\p{^Is_Numeric_Type=- None}', ""); +Expect(0, 47, '\P{Is_Numeric_Type=- None}', ""); +Expect(1, 47, '\P{^Is_Numeric_Type=- None}', ""); +Expect(0, 57, '\p{Is_Numeric_Type=- None}', ""); +Expect(1, 57, '\p{^Is_Numeric_Type=- None}', ""); +Expect(1, 57, '\P{Is_Numeric_Type=- None}', ""); +Expect(0, 57, '\P{^Is_Numeric_Type=- None}', ""); +Error('\p{Is_Nt=_ none:=}'); +Error('\P{Is_Nt=_ none:=}'); +Expect(1, 47, '\p{Is_Nt=none}', ""); +Expect(0, 47, '\p{^Is_Nt=none}', ""); +Expect(0, 47, '\P{Is_Nt=none}', ""); +Expect(1, 47, '\P{^Is_Nt=none}', ""); +Expect(0, 57, '\p{Is_Nt=none}', ""); +Expect(1, 57, '\p{^Is_Nt=none}', ""); +Expect(1, 57, '\P{Is_Nt=none}', ""); +Expect(0, 57, '\P{^Is_Nt=none}', ""); +Expect(1, 47, '\p{Is_Nt=- NONE}', ""); +Expect(0, 47, '\p{^Is_Nt=- NONE}', ""); +Expect(0, 47, '\P{Is_Nt=- NONE}', ""); +Expect(1, 47, '\P{^Is_Nt=- NONE}', ""); +Expect(0, 57, '\p{Is_Nt=- NONE}', ""); +Expect(1, 57, '\p{^Is_Nt=- NONE}', ""); +Expect(1, 57, '\P{Is_Nt=- NONE}', ""); +Expect(0, 57, '\P{^Is_Nt=- NONE}', ""); +Error('\p{Numeric_Type=-DIGIT:=}'); +Error('\P{Numeric_Type=-DIGIT:=}'); +Expect(1, 4977, '\p{Numeric_Type=digit}', ""); +Expect(0, 4977, '\p{^Numeric_Type=digit}', ""); +Expect(0, 4977, '\P{Numeric_Type=digit}', ""); +Expect(1, 4977, '\P{^Numeric_Type=digit}', ""); +Expect(0, 7, '\p{Numeric_Type=digit}', ""); +Expect(1, 7, '\p{^Numeric_Type=digit}', ""); +Expect(1, 7, '\P{Numeric_Type=digit}', ""); +Expect(0, 7, '\P{^Numeric_Type=digit}', ""); +Expect(1, 4977, '\p{Numeric_Type=_ digit}', ""); +Expect(0, 4977, '\p{^Numeric_Type=_ digit}', ""); +Expect(0, 4977, '\P{Numeric_Type=_ digit}', ""); +Expect(1, 4977, '\P{^Numeric_Type=_ digit}', ""); +Expect(0, 7, '\p{Numeric_Type=_ digit}', ""); +Expect(1, 7, '\p{^Numeric_Type=_ digit}', ""); +Expect(1, 7, '\P{Numeric_Type=_ digit}', ""); +Expect(0, 7, '\P{^Numeric_Type=_ digit}', ""); +Error('\p{Nt=/a/Di}'); +Error('\P{Nt=/a/Di}'); +Expect(1, 4977, '\p{Nt=di}', ""); +Expect(0, 4977, '\p{^Nt=di}', ""); +Expect(0, 4977, '\P{Nt=di}', ""); +Expect(1, 4977, '\P{^Nt=di}', ""); +Expect(0, 7, '\p{Nt=di}', ""); +Expect(1, 7, '\p{^Nt=di}', ""); +Expect(1, 7, '\P{Nt=di}', ""); +Expect(0, 7, '\P{^Nt=di}', ""); +Expect(1, 4977, '\p{Nt=-di}', ""); +Expect(0, 4977, '\p{^Nt=-di}', ""); +Expect(0, 4977, '\P{Nt=-di}', ""); +Expect(1, 4977, '\P{^Nt=-di}', ""); +Expect(0, 7, '\p{Nt=-di}', ""); +Expect(1, 7, '\p{^Nt=-di}', ""); +Expect(1, 7, '\P{Nt=-di}', ""); +Expect(0, 7, '\P{^Nt=-di}', ""); +Error('\p{Is_Numeric_Type= DIGIT/a/}'); +Error('\P{Is_Numeric_Type= DIGIT/a/}'); +Expect(1, 4977, '\p{Is_Numeric_Type=digit}', ""); +Expect(0, 4977, '\p{^Is_Numeric_Type=digit}', ""); +Expect(0, 4977, '\P{Is_Numeric_Type=digit}', ""); +Expect(1, 4977, '\P{^Is_Numeric_Type=digit}', ""); +Expect(0, 7, '\p{Is_Numeric_Type=digit}', ""); +Expect(1, 7, '\p{^Is_Numeric_Type=digit}', ""); +Expect(1, 7, '\P{Is_Numeric_Type=digit}', ""); +Expect(0, 7, '\P{^Is_Numeric_Type=digit}', ""); +Expect(1, 4977, '\p{Is_Numeric_Type= Digit}', ""); +Expect(0, 4977, '\p{^Is_Numeric_Type= Digit}', ""); +Expect(0, 4977, '\P{Is_Numeric_Type= Digit}', ""); +Expect(1, 4977, '\P{^Is_Numeric_Type= Digit}', ""); +Expect(0, 7, '\p{Is_Numeric_Type= Digit}', ""); +Expect(1, 7, '\p{^Is_Numeric_Type= Digit}', ""); +Expect(1, 7, '\P{Is_Numeric_Type= Digit}', ""); +Expect(0, 7, '\P{^Is_Numeric_Type= Digit}', ""); +Error('\p{Is_Nt=:= Di}'); +Error('\P{Is_Nt=:= Di}'); +Expect(1, 4977, '\p{Is_Nt=di}', ""); +Expect(0, 4977, '\p{^Is_Nt=di}', ""); +Expect(0, 4977, '\P{Is_Nt=di}', ""); +Expect(1, 4977, '\P{^Is_Nt=di}', ""); +Expect(0, 7, '\p{Is_Nt=di}', ""); +Expect(1, 7, '\p{^Is_Nt=di}', ""); +Expect(1, 7, '\P{Is_Nt=di}', ""); +Expect(0, 7, '\P{^Is_Nt=di}', ""); +Expect(1, 4977, '\p{Is_Nt: _-DI}', ""); +Expect(0, 4977, '\p{^Is_Nt: _-DI}', ""); +Expect(0, 4977, '\P{Is_Nt: _-DI}', ""); +Expect(1, 4977, '\P{^Is_Nt: _-DI}', ""); +Expect(0, 7, '\p{Is_Nt: _-DI}', ""); +Expect(1, 7, '\p{^Is_Nt: _-DI}', ""); +Expect(1, 7, '\P{Is_Nt: _-DI}', ""); +Expect(0, 7, '\P{^Is_Nt: _-DI}', ""); +Error('\p{Numeric_Type= -decimal:=}'); +Error('\P{Numeric_Type= -decimal:=}'); +Expect(1, 57, '\p{Numeric_Type=decimal}', ""); +Expect(0, 57, '\p{^Numeric_Type=decimal}', ""); +Expect(0, 57, '\P{Numeric_Type=decimal}', ""); +Expect(1, 57, '\P{^Numeric_Type=decimal}', ""); +Expect(0, 47, '\p{Numeric_Type=decimal}', ""); +Expect(1, 47, '\p{^Numeric_Type=decimal}', ""); +Expect(1, 47, '\P{Numeric_Type=decimal}', ""); +Expect(0, 47, '\P{^Numeric_Type=decimal}', ""); +Expect(1, 57, '\p{Numeric_Type=_decimal}', ""); +Expect(0, 57, '\p{^Numeric_Type=_decimal}', ""); +Expect(0, 57, '\P{Numeric_Type=_decimal}', ""); +Expect(1, 57, '\P{^Numeric_Type=_decimal}', ""); +Expect(0, 47, '\p{Numeric_Type=_decimal}', ""); +Expect(1, 47, '\p{^Numeric_Type=_decimal}', ""); +Expect(1, 47, '\P{Numeric_Type=_decimal}', ""); +Expect(0, 47, '\P{^Numeric_Type=_decimal}', ""); +Error('\p{Nt=:=_ de}'); +Error('\P{Nt=:=_ de}'); +Expect(1, 57, '\p{Nt=de}', ""); +Expect(0, 57, '\p{^Nt=de}', ""); +Expect(0, 57, '\P{Nt=de}', ""); +Expect(1, 57, '\P{^Nt=de}', ""); +Expect(0, 47, '\p{Nt=de}', ""); +Expect(1, 47, '\p{^Nt=de}', ""); +Expect(1, 47, '\P{Nt=de}', ""); +Expect(0, 47, '\P{^Nt=de}', ""); +Expect(1, 57, '\p{Nt= _de}', ""); +Expect(0, 57, '\p{^Nt= _de}', ""); +Expect(0, 57, '\P{Nt= _de}', ""); +Expect(1, 57, '\P{^Nt= _de}', ""); +Expect(0, 47, '\p{Nt= _de}', ""); +Expect(1, 47, '\p{^Nt= _de}', ""); +Expect(1, 47, '\P{Nt= _de}', ""); +Expect(0, 47, '\P{^Nt= _de}', ""); +Error('\p{Is_Numeric_Type=:=-DECIMAL}'); +Error('\P{Is_Numeric_Type=:=-DECIMAL}'); +Expect(1, 57, '\p{Is_Numeric_Type=decimal}', ""); +Expect(0, 57, '\p{^Is_Numeric_Type=decimal}', ""); +Expect(0, 57, '\P{Is_Numeric_Type=decimal}', ""); +Expect(1, 57, '\P{^Is_Numeric_Type=decimal}', ""); +Expect(0, 47, '\p{Is_Numeric_Type=decimal}', ""); +Expect(1, 47, '\p{^Is_Numeric_Type=decimal}', ""); +Expect(1, 47, '\P{Is_Numeric_Type=decimal}', ""); +Expect(0, 47, '\P{^Is_Numeric_Type=decimal}', ""); +Expect(1, 57, '\p{Is_Numeric_Type=_DECIMAL}', ""); +Expect(0, 57, '\p{^Is_Numeric_Type=_DECIMAL}', ""); +Expect(0, 57, '\P{Is_Numeric_Type=_DECIMAL}', ""); +Expect(1, 57, '\P{^Is_Numeric_Type=_DECIMAL}', ""); +Expect(0, 47, '\p{Is_Numeric_Type=_DECIMAL}', ""); +Expect(1, 47, '\p{^Is_Numeric_Type=_DECIMAL}', ""); +Expect(1, 47, '\P{Is_Numeric_Type=_DECIMAL}', ""); +Expect(0, 47, '\P{^Is_Numeric_Type=_DECIMAL}', ""); +Error('\p{Is_Nt=/a/ de}'); +Error('\P{Is_Nt=/a/ de}'); +Expect(1, 57, '\p{Is_Nt=de}', ""); +Expect(0, 57, '\p{^Is_Nt=de}', ""); +Expect(0, 57, '\P{Is_Nt=de}', ""); +Expect(1, 57, '\P{^Is_Nt=de}', ""); +Expect(0, 47, '\p{Is_Nt=de}', ""); +Expect(1, 47, '\p{^Is_Nt=de}', ""); +Expect(1, 47, '\P{Is_Nt=de}', ""); +Expect(0, 47, '\P{^Is_Nt=de}', ""); +Expect(1, 57, '\p{Is_Nt= de}', ""); +Expect(0, 57, '\p{^Is_Nt= de}', ""); +Expect(0, 57, '\P{Is_Nt= de}', ""); +Expect(1, 57, '\P{^Is_Nt= de}', ""); +Expect(0, 47, '\p{Is_Nt= de}', ""); +Expect(1, 47, '\p{^Is_Nt= de}', ""); +Expect(1, 47, '\P{Is_Nt= de}', ""); +Expect(0, 47, '\P{^Is_Nt= de}', ""); +Error('\p{Numeric_Type=_:=NUMERIC}'); +Error('\P{Numeric_Type=_:=NUMERIC}'); +Expect(1, 2551, '\p{Numeric_Type=numeric}', ""); +Expect(0, 2551, '\p{^Numeric_Type=numeric}', ""); +Expect(0, 2551, '\P{Numeric_Type=numeric}', ""); +Expect(1, 2551, '\P{^Numeric_Type=numeric}', ""); +Expect(0, 7, '\p{Numeric_Type=numeric}', ""); +Expect(1, 7, '\p{^Numeric_Type=numeric}', ""); +Expect(1, 7, '\P{Numeric_Type=numeric}', ""); +Expect(0, 7, '\P{^Numeric_Type=numeric}', ""); +Expect(1, 2551, '\p{Numeric_Type= -NUMERIC}', ""); +Expect(0, 2551, '\p{^Numeric_Type= -NUMERIC}', ""); +Expect(0, 2551, '\P{Numeric_Type= -NUMERIC}', ""); +Expect(1, 2551, '\P{^Numeric_Type= -NUMERIC}', ""); +Expect(0, 7, '\p{Numeric_Type= -NUMERIC}', ""); +Expect(1, 7, '\p{^Numeric_Type= -NUMERIC}', ""); +Expect(1, 7, '\P{Numeric_Type= -NUMERIC}', ""); +Expect(0, 7, '\P{^Numeric_Type= -NUMERIC}', ""); +Error('\p{Nt= :=NU}'); +Error('\P{Nt= :=NU}'); +Expect(1, 2551, '\p{Nt=nu}', ""); +Expect(0, 2551, '\p{^Nt=nu}', ""); +Expect(0, 2551, '\P{Nt=nu}', ""); +Expect(1, 2551, '\P{^Nt=nu}', ""); +Expect(0, 7, '\p{Nt=nu}', ""); +Expect(1, 7, '\p{^Nt=nu}', ""); +Expect(1, 7, '\P{Nt=nu}', ""); +Expect(0, 7, '\P{^Nt=nu}', ""); +Expect(1, 2551, '\p{Nt= _Nu}', ""); +Expect(0, 2551, '\p{^Nt= _Nu}', ""); +Expect(0, 2551, '\P{Nt= _Nu}', ""); +Expect(1, 2551, '\P{^Nt= _Nu}', ""); +Expect(0, 7, '\p{Nt= _Nu}', ""); +Expect(1, 7, '\p{^Nt= _Nu}', ""); +Expect(1, 7, '\P{Nt= _Nu}', ""); +Expect(0, 7, '\P{^Nt= _Nu}', ""); +Error('\p{Is_Numeric_Type:/a/ Numeric}'); +Error('\P{Is_Numeric_Type:/a/ Numeric}'); +Expect(1, 2551, '\p{Is_Numeric_Type=numeric}', ""); +Expect(0, 2551, '\p{^Is_Numeric_Type=numeric}', ""); +Expect(0, 2551, '\P{Is_Numeric_Type=numeric}', ""); +Expect(1, 2551, '\P{^Is_Numeric_Type=numeric}', ""); +Expect(0, 7, '\p{Is_Numeric_Type=numeric}', ""); +Expect(1, 7, '\p{^Is_Numeric_Type=numeric}', ""); +Expect(1, 7, '\P{Is_Numeric_Type=numeric}', ""); +Expect(0, 7, '\P{^Is_Numeric_Type=numeric}', ""); +Expect(1, 2551, '\p{Is_Numeric_Type=__Numeric}', ""); +Expect(0, 2551, '\p{^Is_Numeric_Type=__Numeric}', ""); +Expect(0, 2551, '\P{Is_Numeric_Type=__Numeric}', ""); +Expect(1, 2551, '\P{^Is_Numeric_Type=__Numeric}', ""); +Expect(0, 7, '\p{Is_Numeric_Type=__Numeric}', ""); +Expect(1, 7, '\p{^Is_Numeric_Type=__Numeric}', ""); +Expect(1, 7, '\P{Is_Numeric_Type=__Numeric}', ""); +Expect(0, 7, '\P{^Is_Numeric_Type=__Numeric}', ""); +Error('\p{Is_Nt: -/a/nu}'); +Error('\P{Is_Nt: -/a/nu}'); +Expect(1, 2551, '\p{Is_Nt=nu}', ""); +Expect(0, 2551, '\p{^Is_Nt=nu}', ""); +Expect(0, 2551, '\P{Is_Nt=nu}', ""); +Expect(1, 2551, '\P{^Is_Nt=nu}', ""); +Expect(0, 7, '\p{Is_Nt=nu}', ""); +Expect(1, 7, '\p{^Is_Nt=nu}', ""); +Expect(1, 7, '\P{Is_Nt=nu}', ""); +Expect(0, 7, '\P{^Is_Nt=nu}', ""); +Expect(1, 2551, '\p{Is_Nt=_-Nu}', ""); +Expect(0, 2551, '\p{^Is_Nt=_-Nu}', ""); +Expect(0, 2551, '\P{Is_Nt=_-Nu}', ""); +Expect(1, 2551, '\P{^Is_Nt=_-Nu}', ""); +Expect(0, 7, '\p{Is_Nt=_-Nu}', ""); +Expect(1, 7, '\p{^Is_Nt=_-Nu}', ""); +Expect(1, 7, '\P{Is_Nt=_-Nu}', ""); +Expect(0, 7, '\P{^Is_Nt=_-Nu}', ""); +Error('\p{Expands_On_NFC=Yes}'); +Error('\P{Expands_On_NFC=Yes}'); +Error('\p{XO_NFC=Y}'); +Error('\P{XO_NFC=Y}'); +Error('\p{Is_Expands_On_NFC=T}'); +Error('\P{Is_Expands_On_NFC=T}'); +Error('\p{Is_XO_NFC=True}'); +Error('\P{Is_XO_NFC=True}'); +Error('\p{Expands_On_NFC=No}'); +Error('\P{Expands_On_NFC=No}'); +Error('\p{XO_NFC=N}'); +Error('\P{XO_NFC=N}'); +Error('\p{Is_Expands_On_NFC=F}'); +Error('\P{Is_Expands_On_NFC=F}'); +Error('\p{Is_XO_NFC=False}'); +Error('\P{Is_XO_NFC=False}'); +Error('\p{Dash=:=- yes}'); +Error('\P{Dash=:=- yes}'); +Expect(1, 45, '\p{Dash=yes}', ""); +Expect(0, 45, '\p{^Dash=yes}', ""); +Expect(0, 45, '\P{Dash=yes}', ""); +Expect(1, 45, '\P{^Dash=yes}', ""); +Expect(0, 44, '\p{Dash=yes}', ""); +Expect(1, 44, '\p{^Dash=yes}', ""); +Expect(1, 44, '\P{Dash=yes}', ""); +Expect(0, 44, '\P{^Dash=yes}', ""); +Expect(1, 45, '\p{Dash=--YES}', ""); +Expect(0, 45, '\p{^Dash=--YES}', ""); +Expect(0, 45, '\P{Dash=--YES}', ""); +Expect(1, 45, '\P{^Dash=--YES}', ""); +Expect(0, 44, '\p{Dash=--YES}', ""); +Expect(1, 44, '\p{^Dash=--YES}', ""); +Expect(1, 44, '\P{Dash=--YES}', ""); +Expect(0, 44, '\P{^Dash=--YES}', ""); +Error('\p{Is_Dash=_/a/Y}'); +Error('\P{Is_Dash=_/a/Y}'); +Expect(1, 45, '\p{Is_Dash=y}', ""); +Expect(0, 45, '\p{^Is_Dash=y}', ""); +Expect(0, 45, '\P{Is_Dash=y}', ""); +Expect(1, 45, '\P{^Is_Dash=y}', ""); +Expect(0, 44, '\p{Is_Dash=y}', ""); +Expect(1, 44, '\p{^Is_Dash=y}', ""); +Expect(1, 44, '\P{Is_Dash=y}', ""); +Expect(0, 44, '\P{^Is_Dash=y}', ""); +Expect(1, 45, '\p{Is_Dash= Y}', ""); +Expect(0, 45, '\p{^Is_Dash= Y}', ""); +Expect(0, 45, '\P{Is_Dash= Y}', ""); +Expect(1, 45, '\P{^Is_Dash= Y}', ""); +Expect(0, 44, '\p{Is_Dash= Y}', ""); +Expect(1, 44, '\p{^Is_Dash= Y}', ""); +Expect(1, 44, '\P{Is_Dash= Y}', ""); +Expect(0, 44, '\P{^Is_Dash= Y}', ""); +Error('\p{Dash= t:=}'); +Error('\P{Dash= t:=}'); +Expect(1, 45, '\p{Dash: t}', ""); +Expect(0, 45, '\p{^Dash: t}', ""); +Expect(0, 45, '\P{Dash: t}', ""); +Expect(1, 45, '\P{^Dash: t}', ""); +Expect(0, 44, '\p{Dash: t}', ""); +Expect(1, 44, '\p{^Dash: t}', ""); +Expect(1, 44, '\P{Dash: t}', ""); +Expect(0, 44, '\P{^Dash: t}', ""); +Expect(1, 45, '\p{Dash=- t}', ""); +Expect(0, 45, '\p{^Dash=- t}', ""); +Expect(0, 45, '\P{Dash=- t}', ""); +Expect(1, 45, '\P{^Dash=- t}', ""); +Expect(0, 44, '\p{Dash=- t}', ""); +Expect(1, 44, '\p{^Dash=- t}', ""); +Expect(1, 44, '\P{Dash=- t}', ""); +Expect(0, 44, '\P{^Dash=- t}', ""); +Error('\p{Is_Dash= True:=}'); +Error('\P{Is_Dash= True:=}'); +Expect(1, 45, '\p{Is_Dash=true}', ""); +Expect(0, 45, '\p{^Is_Dash=true}', ""); +Expect(0, 45, '\P{Is_Dash=true}', ""); +Expect(1, 45, '\P{^Is_Dash=true}', ""); +Expect(0, 44, '\p{Is_Dash=true}', ""); +Expect(1, 44, '\p{^Is_Dash=true}', ""); +Expect(1, 44, '\P{Is_Dash=true}', ""); +Expect(0, 44, '\P{^Is_Dash=true}', ""); +Expect(1, 45, '\p{Is_Dash=True}', ""); +Expect(0, 45, '\p{^Is_Dash=True}', ""); +Expect(0, 45, '\P{Is_Dash=True}', ""); +Expect(1, 45, '\P{^Is_Dash=True}', ""); +Expect(0, 44, '\p{Is_Dash=True}', ""); +Expect(1, 44, '\p{^Is_Dash=True}', ""); +Expect(1, 44, '\P{Is_Dash=True}', ""); +Expect(0, 44, '\P{^Is_Dash=True}', ""); +Error('\p{Dash=-/a/No}'); +Error('\P{Dash=-/a/No}'); +Expect(1, 44, '\p{Dash=no}', ""); +Expect(0, 44, '\p{^Dash=no}', ""); +Expect(0, 44, '\P{Dash=no}', ""); +Expect(1, 44, '\P{^Dash=no}', ""); +Expect(0, 45, '\p{Dash=no}', ""); +Expect(1, 45, '\p{^Dash=no}', ""); +Expect(1, 45, '\P{Dash=no}', ""); +Expect(0, 45, '\P{^Dash=no}', ""); +Expect(1, 44, '\p{Dash=-no}', ""); +Expect(0, 44, '\p{^Dash=-no}', ""); +Expect(0, 44, '\P{Dash=-no}', ""); +Expect(1, 44, '\P{^Dash=-no}', ""); +Expect(0, 45, '\p{Dash=-no}', ""); +Expect(1, 45, '\p{^Dash=-no}', ""); +Expect(1, 45, '\P{Dash=-no}', ""); +Expect(0, 45, '\P{^Dash=-no}', ""); +Error('\p{Is_Dash=/a/ _N}'); +Error('\P{Is_Dash=/a/ _N}'); +Expect(1, 44, '\p{Is_Dash=n}', ""); +Expect(0, 44, '\p{^Is_Dash=n}', ""); +Expect(0, 44, '\P{Is_Dash=n}', ""); +Expect(1, 44, '\P{^Is_Dash=n}', ""); +Expect(0, 45, '\p{Is_Dash=n}', ""); +Expect(1, 45, '\p{^Is_Dash=n}', ""); +Expect(1, 45, '\P{Is_Dash=n}', ""); +Expect(0, 45, '\P{^Is_Dash=n}', ""); +Expect(1, 44, '\p{Is_Dash= -N}', ""); +Expect(0, 44, '\p{^Is_Dash= -N}', ""); +Expect(0, 44, '\P{Is_Dash= -N}', ""); +Expect(1, 44, '\P{^Is_Dash= -N}', ""); +Expect(0, 45, '\p{Is_Dash= -N}', ""); +Expect(1, 45, '\p{^Is_Dash= -N}', ""); +Expect(1, 45, '\P{Is_Dash= -N}', ""); +Expect(0, 45, '\P{^Is_Dash= -N}', ""); +Error('\p{Dash= F/a/}'); +Error('\P{Dash= F/a/}'); +Expect(1, 44, '\p{Dash: f}', ""); +Expect(0, 44, '\p{^Dash: f}', ""); +Expect(0, 44, '\P{Dash: f}', ""); +Expect(1, 44, '\P{^Dash: f}', ""); +Expect(0, 45, '\p{Dash: f}', ""); +Expect(1, 45, '\p{^Dash: f}', ""); +Expect(1, 45, '\P{Dash: f}', ""); +Expect(0, 45, '\P{^Dash: f}', ""); +Expect(1, 44, '\p{Dash= F}', ""); +Expect(0, 44, '\p{^Dash= F}', ""); +Expect(0, 44, '\P{Dash= F}', ""); +Expect(1, 44, '\P{^Dash= F}', ""); +Expect(0, 45, '\p{Dash= F}', ""); +Expect(1, 45, '\p{^Dash= F}', ""); +Expect(1, 45, '\P{Dash= F}', ""); +Expect(0, 45, '\P{^Dash= F}', ""); +Error('\p{Is_Dash=:= _false}'); +Error('\P{Is_Dash=:= _false}'); +Expect(1, 44, '\p{Is_Dash=false}', ""); +Expect(0, 44, '\p{^Is_Dash=false}', ""); +Expect(0, 44, '\P{Is_Dash=false}', ""); +Expect(1, 44, '\P{^Is_Dash=false}', ""); +Expect(0, 45, '\p{Is_Dash=false}', ""); +Expect(1, 45, '\p{^Is_Dash=false}', ""); +Expect(1, 45, '\P{Is_Dash=false}', ""); +Expect(0, 45, '\P{^Is_Dash=false}', ""); +Expect(1, 44, '\p{Is_Dash=- false}', ""); +Expect(0, 44, '\p{^Is_Dash=- false}', ""); +Expect(0, 44, '\P{Is_Dash=- false}', ""); +Expect(1, 44, '\P{^Is_Dash=- false}', ""); +Expect(0, 45, '\p{Is_Dash=- false}', ""); +Expect(1, 45, '\p{^Is_Dash=- false}', ""); +Expect(1, 45, '\P{Is_Dash=- false}', ""); +Expect(0, 45, '\P{^Is_Dash=- false}', ""); +Error('\p{Hangul_Syllable_Type=_-trailingJAMO:=}'); +Error('\P{Hangul_Syllable_Type=_-trailingJAMO:=}'); +Expect(1, 4601, '\p{Hangul_Syllable_Type=trailingjamo}', ""); +Expect(0, 4601, '\p{^Hangul_Syllable_Type=trailingjamo}', ""); +Expect(0, 4601, '\P{Hangul_Syllable_Type=trailingjamo}', ""); +Expect(1, 4601, '\P{^Hangul_Syllable_Type=trailingjamo}', ""); +Expect(0, 4519, '\p{Hangul_Syllable_Type=trailingjamo}', ""); +Expect(1, 4519, '\p{^Hangul_Syllable_Type=trailingjamo}', ""); +Expect(1, 4519, '\P{Hangul_Syllable_Type=trailingjamo}', ""); +Expect(0, 4519, '\P{^Hangul_Syllable_Type=trailingjamo}', ""); +Expect(1, 4601, '\p{Hangul_Syllable_Type= TRAILINGJamo}', ""); +Expect(0, 4601, '\p{^Hangul_Syllable_Type= TRAILINGJamo}', ""); +Expect(0, 4601, '\P{Hangul_Syllable_Type= TRAILINGJamo}', ""); +Expect(1, 4601, '\P{^Hangul_Syllable_Type= TRAILINGJamo}', ""); +Expect(0, 4519, '\p{Hangul_Syllable_Type= TRAILINGJamo}', ""); +Expect(1, 4519, '\p{^Hangul_Syllable_Type= TRAILINGJamo}', ""); +Expect(1, 4519, '\P{Hangul_Syllable_Type= TRAILINGJamo}', ""); +Expect(0, 4519, '\P{^Hangul_Syllable_Type= TRAILINGJamo}', ""); +Error('\p{Hst=:=-t}'); +Error('\P{Hst=:=-t}'); +Expect(1, 4601, '\p{Hst=t}', ""); +Expect(0, 4601, '\p{^Hst=t}', ""); +Expect(0, 4601, '\P{Hst=t}', ""); +Expect(1, 4601, '\P{^Hst=t}', ""); +Expect(0, 4519, '\p{Hst=t}', ""); +Expect(1, 4519, '\p{^Hst=t}', ""); +Expect(1, 4519, '\P{Hst=t}', ""); +Expect(0, 4519, '\P{^Hst=t}', ""); +Expect(1, 4601, '\p{Hst= -T}', ""); +Expect(0, 4601, '\p{^Hst= -T}', ""); +Expect(0, 4601, '\P{Hst= -T}', ""); +Expect(1, 4601, '\P{^Hst= -T}', ""); +Expect(0, 4519, '\p{Hst= -T}', ""); +Expect(1, 4519, '\p{^Hst= -T}', ""); +Expect(1, 4519, '\P{Hst= -T}', ""); +Expect(0, 4519, '\P{^Hst= -T}', ""); +Error('\p{Is_Hangul_Syllable_Type: /a/TRAILING Jamo}'); +Error('\P{Is_Hangul_Syllable_Type: /a/TRAILING Jamo}'); +Expect(1, 4601, '\p{Is_Hangul_Syllable_Type:trailingjamo}', ""); +Expect(0, 4601, '\p{^Is_Hangul_Syllable_Type:trailingjamo}', ""); +Expect(0, 4601, '\P{Is_Hangul_Syllable_Type:trailingjamo}', ""); +Expect(1, 4601, '\P{^Is_Hangul_Syllable_Type:trailingjamo}', ""); +Expect(0, 4519, '\p{Is_Hangul_Syllable_Type:trailingjamo}', ""); +Expect(1, 4519, '\p{^Is_Hangul_Syllable_Type:trailingjamo}', ""); +Expect(1, 4519, '\P{Is_Hangul_Syllable_Type:trailingjamo}', ""); +Expect(0, 4519, '\P{^Is_Hangul_Syllable_Type:trailingjamo}', ""); +Expect(1, 4601, '\p{Is_Hangul_Syllable_Type= trailing_jamo}', ""); +Expect(0, 4601, '\p{^Is_Hangul_Syllable_Type= trailing_jamo}', ""); +Expect(0, 4601, '\P{Is_Hangul_Syllable_Type= trailing_jamo}', ""); +Expect(1, 4601, '\P{^Is_Hangul_Syllable_Type= trailing_jamo}', ""); +Expect(0, 4519, '\p{Is_Hangul_Syllable_Type= trailing_jamo}', ""); +Expect(1, 4519, '\p{^Is_Hangul_Syllable_Type= trailing_jamo}', ""); +Expect(1, 4519, '\P{Is_Hangul_Syllable_Type= trailing_jamo}', ""); +Expect(0, 4519, '\P{^Is_Hangul_Syllable_Type= trailing_jamo}', ""); +Error('\p{Is_Hst= :=t}'); +Error('\P{Is_Hst= :=t}'); +Expect(1, 4601, '\p{Is_Hst=t}', ""); +Expect(0, 4601, '\p{^Is_Hst=t}', ""); +Expect(0, 4601, '\P{Is_Hst=t}', ""); +Expect(1, 4601, '\P{^Is_Hst=t}', ""); +Expect(0, 4519, '\p{Is_Hst=t}', ""); +Expect(1, 4519, '\p{^Is_Hst=t}', ""); +Expect(1, 4519, '\P{Is_Hst=t}', ""); +Expect(0, 4519, '\P{^Is_Hst=t}', ""); +Expect(1, 4601, '\p{Is_Hst= -T}', ""); +Expect(0, 4601, '\p{^Is_Hst= -T}', ""); +Expect(0, 4601, '\P{Is_Hst= -T}', ""); +Expect(1, 4601, '\P{^Is_Hst= -T}', ""); +Expect(0, 4519, '\p{Is_Hst= -T}', ""); +Expect(1, 4519, '\p{^Is_Hst= -T}', ""); +Expect(1, 4519, '\P{Is_Hst= -T}', ""); +Expect(0, 4519, '\P{^Is_Hst= -T}', ""); +Error('\p{Hangul_Syllable_Type=/a/_ LVT SYLLABLE}'); +Error('\P{Hangul_Syllable_Type=/a/_ LVT SYLLABLE}'); +Expect(1, 44059, '\p{Hangul_Syllable_Type:lvtsyllable}', ""); +Expect(0, 44059, '\p{^Hangul_Syllable_Type:lvtsyllable}', ""); +Expect(0, 44059, '\P{Hangul_Syllable_Type:lvtsyllable}', ""); +Expect(1, 44059, '\P{^Hangul_Syllable_Type:lvtsyllable}', ""); +Expect(0, 44032, '\p{Hangul_Syllable_Type:lvtsyllable}', ""); +Expect(1, 44032, '\p{^Hangul_Syllable_Type:lvtsyllable}', ""); +Expect(1, 44032, '\P{Hangul_Syllable_Type:lvtsyllable}', ""); +Expect(0, 44032, '\P{^Hangul_Syllable_Type:lvtsyllable}', ""); +Expect(1, 44059, '\p{Hangul_Syllable_Type=--LVT-Syllable}', ""); +Expect(0, 44059, '\p{^Hangul_Syllable_Type=--LVT-Syllable}', ""); +Expect(0, 44059, '\P{Hangul_Syllable_Type=--LVT-Syllable}', ""); +Expect(1, 44059, '\P{^Hangul_Syllable_Type=--LVT-Syllable}', ""); +Expect(0, 44032, '\p{Hangul_Syllable_Type=--LVT-Syllable}', ""); +Expect(1, 44032, '\p{^Hangul_Syllable_Type=--LVT-Syllable}', ""); +Expect(1, 44032, '\P{Hangul_Syllable_Type=--LVT-Syllable}', ""); +Expect(0, 44032, '\P{^Hangul_Syllable_Type=--LVT-Syllable}', ""); +Error('\p{Hst=-lvt/a/}'); +Error('\P{Hst=-lvt/a/}'); +Expect(1, 44059, '\p{Hst=lvt}', ""); +Expect(0, 44059, '\p{^Hst=lvt}', ""); +Expect(0, 44059, '\P{Hst=lvt}', ""); +Expect(1, 44059, '\P{^Hst=lvt}', ""); +Expect(0, 44032, '\p{Hst=lvt}', ""); +Expect(1, 44032, '\p{^Hst=lvt}', ""); +Expect(1, 44032, '\P{Hst=lvt}', ""); +Expect(0, 44032, '\P{^Hst=lvt}', ""); +Expect(1, 44059, '\p{Hst= LVT}', ""); +Expect(0, 44059, '\p{^Hst= LVT}', ""); +Expect(0, 44059, '\P{Hst= LVT}', ""); +Expect(1, 44059, '\P{^Hst= LVT}', ""); +Expect(0, 44032, '\p{Hst= LVT}', ""); +Expect(1, 44032, '\p{^Hst= LVT}', ""); +Expect(1, 44032, '\P{Hst= LVT}', ""); +Expect(0, 44032, '\P{^Hst= LVT}', ""); +Error('\p{Is_Hangul_Syllable_Type=__LVT:=Syllable}'); +Error('\P{Is_Hangul_Syllable_Type=__LVT:=Syllable}'); +Expect(1, 44059, '\p{Is_Hangul_Syllable_Type=lvtsyllable}', ""); +Expect(0, 44059, '\p{^Is_Hangul_Syllable_Type=lvtsyllable}', ""); +Expect(0, 44059, '\P{Is_Hangul_Syllable_Type=lvtsyllable}', ""); +Expect(1, 44059, '\P{^Is_Hangul_Syllable_Type=lvtsyllable}', ""); +Expect(0, 44032, '\p{Is_Hangul_Syllable_Type=lvtsyllable}', ""); +Expect(1, 44032, '\p{^Is_Hangul_Syllable_Type=lvtsyllable}', ""); +Expect(1, 44032, '\P{Is_Hangul_Syllable_Type=lvtsyllable}', ""); +Expect(0, 44032, '\P{^Is_Hangul_Syllable_Type=lvtsyllable}', ""); +Expect(1, 44059, '\p{Is_Hangul_Syllable_Type= _LVTSYLLABLE}', ""); +Expect(0, 44059, '\p{^Is_Hangul_Syllable_Type= _LVTSYLLABLE}', ""); +Expect(0, 44059, '\P{Is_Hangul_Syllable_Type= _LVTSYLLABLE}', ""); +Expect(1, 44059, '\P{^Is_Hangul_Syllable_Type= _LVTSYLLABLE}', ""); +Expect(0, 44032, '\p{Is_Hangul_Syllable_Type= _LVTSYLLABLE}', ""); +Expect(1, 44032, '\p{^Is_Hangul_Syllable_Type= _LVTSYLLABLE}', ""); +Expect(1, 44032, '\P{Is_Hangul_Syllable_Type= _LVTSYLLABLE}', ""); +Expect(0, 44032, '\P{^Is_Hangul_Syllable_Type= _LVTSYLLABLE}', ""); +Error('\p{Is_Hst=:= LVT}'); +Error('\P{Is_Hst=:= LVT}'); +Expect(1, 44059, '\p{Is_Hst=lvt}', ""); +Expect(0, 44059, '\p{^Is_Hst=lvt}', ""); +Expect(0, 44059, '\P{Is_Hst=lvt}', ""); +Expect(1, 44059, '\P{^Is_Hst=lvt}', ""); +Expect(0, 44032, '\p{Is_Hst=lvt}', ""); +Expect(1, 44032, '\p{^Is_Hst=lvt}', ""); +Expect(1, 44032, '\P{Is_Hst=lvt}', ""); +Expect(0, 44032, '\P{^Is_Hst=lvt}', ""); +Expect(1, 44059, '\p{Is_Hst=_-LVT}', ""); +Expect(0, 44059, '\p{^Is_Hst=_-LVT}', ""); +Expect(0, 44059, '\P{Is_Hst=_-LVT}', ""); +Expect(1, 44059, '\P{^Is_Hst=_-LVT}', ""); +Expect(0, 44032, '\p{Is_Hst=_-LVT}', ""); +Expect(1, 44032, '\p{^Is_Hst=_-LVT}', ""); +Expect(1, 44032, '\P{Is_Hst=_-LVT}', ""); +Expect(0, 44032, '\P{^Is_Hst=_-LVT}', ""); +Error('\p{Hangul_Syllable_Type: _-vowel/a/Jamo}'); +Error('\P{Hangul_Syllable_Type: _-vowel/a/Jamo}'); +Expect(1, 4514, '\p{Hangul_Syllable_Type=voweljamo}', ""); +Expect(0, 4514, '\p{^Hangul_Syllable_Type=voweljamo}', ""); +Expect(0, 4514, '\P{Hangul_Syllable_Type=voweljamo}', ""); +Expect(1, 4514, '\P{^Hangul_Syllable_Type=voweljamo}', ""); +Expect(0, 4447, '\p{Hangul_Syllable_Type=voweljamo}', ""); +Expect(1, 4447, '\p{^Hangul_Syllable_Type=voweljamo}', ""); +Expect(1, 4447, '\P{Hangul_Syllable_Type=voweljamo}', ""); +Expect(0, 4447, '\P{^Hangul_Syllable_Type=voweljamo}', ""); +Expect(1, 4514, '\p{Hangul_Syllable_Type= Vowel jamo}', ""); +Expect(0, 4514, '\p{^Hangul_Syllable_Type= Vowel jamo}', ""); +Expect(0, 4514, '\P{Hangul_Syllable_Type= Vowel jamo}', ""); +Expect(1, 4514, '\P{^Hangul_Syllable_Type= Vowel jamo}', ""); +Expect(0, 4447, '\p{Hangul_Syllable_Type= Vowel jamo}', ""); +Expect(1, 4447, '\p{^Hangul_Syllable_Type= Vowel jamo}', ""); +Expect(1, 4447, '\P{Hangul_Syllable_Type= Vowel jamo}', ""); +Expect(0, 4447, '\P{^Hangul_Syllable_Type= Vowel jamo}', ""); +Error('\p{Hst=/a/_-V}'); +Error('\P{Hst=/a/_-V}'); +Expect(1, 4514, '\p{Hst=v}', ""); +Expect(0, 4514, '\p{^Hst=v}', ""); +Expect(0, 4514, '\P{Hst=v}', ""); +Expect(1, 4514, '\P{^Hst=v}', ""); +Expect(0, 4447, '\p{Hst=v}', ""); +Expect(1, 4447, '\p{^Hst=v}', ""); +Expect(1, 4447, '\P{Hst=v}', ""); +Expect(0, 4447, '\P{^Hst=v}', ""); +Expect(1, 4514, '\p{Hst=_ V}', ""); +Expect(0, 4514, '\p{^Hst=_ V}', ""); +Expect(0, 4514, '\P{Hst=_ V}', ""); +Expect(1, 4514, '\P{^Hst=_ V}', ""); +Expect(0, 4447, '\p{Hst=_ V}', ""); +Expect(1, 4447, '\p{^Hst=_ V}', ""); +Expect(1, 4447, '\P{Hst=_ V}', ""); +Expect(0, 4447, '\P{^Hst=_ V}', ""); +Error('\p{Is_Hangul_Syllable_Type=__VOWEL/a/jamo}'); +Error('\P{Is_Hangul_Syllable_Type=__VOWEL/a/jamo}'); +Expect(1, 4514, '\p{Is_Hangul_Syllable_Type=voweljamo}', ""); +Expect(0, 4514, '\p{^Is_Hangul_Syllable_Type=voweljamo}', ""); +Expect(0, 4514, '\P{Is_Hangul_Syllable_Type=voweljamo}', ""); +Expect(1, 4514, '\P{^Is_Hangul_Syllable_Type=voweljamo}', ""); +Expect(0, 4447, '\p{Is_Hangul_Syllable_Type=voweljamo}', ""); +Expect(1, 4447, '\p{^Is_Hangul_Syllable_Type=voweljamo}', ""); +Expect(1, 4447, '\P{Is_Hangul_Syllable_Type=voweljamo}', ""); +Expect(0, 4447, '\P{^Is_Hangul_Syllable_Type=voweljamo}', ""); +Expect(1, 4514, '\p{Is_Hangul_Syllable_Type= Vowel-Jamo}', ""); +Expect(0, 4514, '\p{^Is_Hangul_Syllable_Type= Vowel-Jamo}', ""); +Expect(0, 4514, '\P{Is_Hangul_Syllable_Type= Vowel-Jamo}', ""); +Expect(1, 4514, '\P{^Is_Hangul_Syllable_Type= Vowel-Jamo}', ""); +Expect(0, 4447, '\p{Is_Hangul_Syllable_Type= Vowel-Jamo}', ""); +Expect(1, 4447, '\p{^Is_Hangul_Syllable_Type= Vowel-Jamo}', ""); +Expect(1, 4447, '\P{Is_Hangul_Syllable_Type= Vowel-Jamo}', ""); +Expect(0, 4447, '\P{^Is_Hangul_Syllable_Type= Vowel-Jamo}', ""); +Error('\p{Is_Hst=_:=V}'); +Error('\P{Is_Hst=_:=V}'); +Expect(1, 4514, '\p{Is_Hst=v}', ""); +Expect(0, 4514, '\p{^Is_Hst=v}', ""); +Expect(0, 4514, '\P{Is_Hst=v}', ""); +Expect(1, 4514, '\P{^Is_Hst=v}', ""); +Expect(0, 4447, '\p{Is_Hst=v}', ""); +Expect(1, 4447, '\p{^Is_Hst=v}', ""); +Expect(1, 4447, '\P{Is_Hst=v}', ""); +Expect(0, 4447, '\P{^Is_Hst=v}', ""); +Expect(1, 4514, '\p{Is_Hst=_ V}', ""); +Expect(0, 4514, '\p{^Is_Hst=_ V}', ""); +Expect(0, 4514, '\P{Is_Hst=_ V}', ""); +Expect(1, 4514, '\P{^Is_Hst=_ V}', ""); +Expect(0, 4447, '\p{Is_Hst=_ V}', ""); +Expect(1, 4447, '\p{^Is_Hst=_ V}', ""); +Expect(1, 4447, '\P{Is_Hst=_ V}', ""); +Expect(0, 4447, '\P{^Is_Hst=_ V}', ""); +Error('\p{Hangul_Syllable_Type= LV-Syllable:=}'); +Error('\P{Hangul_Syllable_Type= LV-Syllable:=}'); +Expect(1, 44032, '\p{Hangul_Syllable_Type: lvsyllable}', ""); +Expect(0, 44032, '\p{^Hangul_Syllable_Type: lvsyllable}', ""); +Expect(0, 44032, '\P{Hangul_Syllable_Type: lvsyllable}', ""); +Expect(1, 44032, '\P{^Hangul_Syllable_Type: lvsyllable}', ""); +Expect(0, 44031, '\p{Hangul_Syllable_Type: lvsyllable}', ""); +Expect(1, 44031, '\p{^Hangul_Syllable_Type: lvsyllable}', ""); +Expect(1, 44031, '\P{Hangul_Syllable_Type: lvsyllable}', ""); +Expect(0, 44031, '\P{^Hangul_Syllable_Type: lvsyllable}', ""); +Expect(1, 44032, '\p{Hangul_Syllable_Type= _LV syllable}', ""); +Expect(0, 44032, '\p{^Hangul_Syllable_Type= _LV syllable}', ""); +Expect(0, 44032, '\P{Hangul_Syllable_Type= _LV syllable}', ""); +Expect(1, 44032, '\P{^Hangul_Syllable_Type= _LV syllable}', ""); +Expect(0, 44031, '\p{Hangul_Syllable_Type= _LV syllable}', ""); +Expect(1, 44031, '\p{^Hangul_Syllable_Type= _LV syllable}', ""); +Expect(1, 44031, '\P{Hangul_Syllable_Type= _LV syllable}', ""); +Expect(0, 44031, '\P{^Hangul_Syllable_Type= _LV syllable}', ""); +Error('\p{Hst=LV:=}'); +Error('\P{Hst=LV:=}'); +Expect(1, 44032, '\p{Hst=lv}', ""); +Expect(0, 44032, '\p{^Hst=lv}', ""); +Expect(0, 44032, '\P{Hst=lv}', ""); +Expect(1, 44032, '\P{^Hst=lv}', ""); +Expect(0, 44031, '\p{Hst=lv}', ""); +Expect(1, 44031, '\p{^Hst=lv}', ""); +Expect(1, 44031, '\P{Hst=lv}', ""); +Expect(0, 44031, '\P{^Hst=lv}', ""); +Expect(1, 44032, '\p{Hst=-LV}', ""); +Expect(0, 44032, '\p{^Hst=-LV}', ""); +Expect(0, 44032, '\P{Hst=-LV}', ""); +Expect(1, 44032, '\P{^Hst=-LV}', ""); +Expect(0, 44031, '\p{Hst=-LV}', ""); +Expect(1, 44031, '\p{^Hst=-LV}', ""); +Expect(1, 44031, '\P{Hst=-LV}', ""); +Expect(0, 44031, '\P{^Hst=-LV}', ""); +Error('\p{Is_Hangul_Syllable_Type=/a/ LV_SYLLABLE}'); +Error('\P{Is_Hangul_Syllable_Type=/a/ LV_SYLLABLE}'); +Expect(1, 44032, '\p{Is_Hangul_Syllable_Type=lvsyllable}', ""); +Expect(0, 44032, '\p{^Is_Hangul_Syllable_Type=lvsyllable}', ""); +Expect(0, 44032, '\P{Is_Hangul_Syllable_Type=lvsyllable}', ""); +Expect(1, 44032, '\P{^Is_Hangul_Syllable_Type=lvsyllable}', ""); +Expect(0, 44031, '\p{Is_Hangul_Syllable_Type=lvsyllable}', ""); +Expect(1, 44031, '\p{^Is_Hangul_Syllable_Type=lvsyllable}', ""); +Expect(1, 44031, '\P{Is_Hangul_Syllable_Type=lvsyllable}', ""); +Expect(0, 44031, '\P{^Is_Hangul_Syllable_Type=lvsyllable}', ""); +Expect(1, 44032, '\p{Is_Hangul_Syllable_Type=_ LV syllable}', ""); +Expect(0, 44032, '\p{^Is_Hangul_Syllable_Type=_ LV syllable}', ""); +Expect(0, 44032, '\P{Is_Hangul_Syllable_Type=_ LV syllable}', ""); +Expect(1, 44032, '\P{^Is_Hangul_Syllable_Type=_ LV syllable}', ""); +Expect(0, 44031, '\p{Is_Hangul_Syllable_Type=_ LV syllable}', ""); +Expect(1, 44031, '\p{^Is_Hangul_Syllable_Type=_ LV syllable}', ""); +Expect(1, 44031, '\P{Is_Hangul_Syllable_Type=_ LV syllable}', ""); +Expect(0, 44031, '\P{^Is_Hangul_Syllable_Type=_ LV syllable}', ""); +Error('\p{Is_Hst=_/a/lv}'); +Error('\P{Is_Hst=_/a/lv}'); +Expect(1, 44032, '\p{Is_Hst=lv}', ""); +Expect(0, 44032, '\p{^Is_Hst=lv}', ""); +Expect(0, 44032, '\P{Is_Hst=lv}', ""); +Expect(1, 44032, '\P{^Is_Hst=lv}', ""); +Expect(0, 44031, '\p{Is_Hst=lv}', ""); +Expect(1, 44031, '\p{^Is_Hst=lv}', ""); +Expect(1, 44031, '\P{Is_Hst=lv}', ""); +Expect(0, 44031, '\P{^Is_Hst=lv}', ""); +Expect(1, 44032, '\p{Is_Hst= -LV}', ""); +Expect(0, 44032, '\p{^Is_Hst= -LV}', ""); +Expect(0, 44032, '\P{Is_Hst= -LV}', ""); +Expect(1, 44032, '\P{^Is_Hst= -LV}', ""); +Expect(0, 44031, '\p{Is_Hst= -LV}', ""); +Expect(1, 44031, '\p{^Is_Hst= -LV}', ""); +Expect(1, 44031, '\P{Is_Hst= -LV}', ""); +Expect(0, 44031, '\P{^Is_Hst= -LV}', ""); +Error('\p{Hangul_Syllable_Type=--Not-Applicable/a/}'); +Error('\P{Hangul_Syllable_Type=--Not-Applicable/a/}'); +Expect(1, 4351, '\p{Hangul_Syllable_Type=notapplicable}', ""); +Expect(0, 4351, '\p{^Hangul_Syllable_Type=notapplicable}', ""); +Expect(0, 4351, '\P{Hangul_Syllable_Type=notapplicable}', ""); +Expect(1, 4351, '\P{^Hangul_Syllable_Type=notapplicable}', ""); +Expect(0, 4441, '\p{Hangul_Syllable_Type=notapplicable}', ""); +Expect(1, 4441, '\p{^Hangul_Syllable_Type=notapplicable}', ""); +Expect(1, 4441, '\P{Hangul_Syllable_Type=notapplicable}', ""); +Expect(0, 4441, '\P{^Hangul_Syllable_Type=notapplicable}', ""); +Expect(1, 4351, '\p{Hangul_Syllable_Type=-NotApplicable}', ""); +Expect(0, 4351, '\p{^Hangul_Syllable_Type=-NotApplicable}', ""); +Expect(0, 4351, '\P{Hangul_Syllable_Type=-NotApplicable}', ""); +Expect(1, 4351, '\P{^Hangul_Syllable_Type=-NotApplicable}', ""); +Expect(0, 4441, '\p{Hangul_Syllable_Type=-NotApplicable}', ""); +Expect(1, 4441, '\p{^Hangul_Syllable_Type=-NotApplicable}', ""); +Expect(1, 4441, '\P{Hangul_Syllable_Type=-NotApplicable}', ""); +Expect(0, 4441, '\P{^Hangul_Syllable_Type=-NotApplicable}', ""); +Error('\p{Hst=-:=NA}'); +Error('\P{Hst=-:=NA}'); +Expect(1, 4351, '\p{Hst=na}', ""); +Expect(0, 4351, '\p{^Hst=na}', ""); +Expect(0, 4351, '\P{Hst=na}', ""); +Expect(1, 4351, '\P{^Hst=na}', ""); +Expect(0, 4441, '\p{Hst=na}', ""); +Expect(1, 4441, '\p{^Hst=na}', ""); +Expect(1, 4441, '\P{Hst=na}', ""); +Expect(0, 4441, '\P{^Hst=na}', ""); +Expect(1, 4351, '\p{Hst=_NA}', ""); +Expect(0, 4351, '\p{^Hst=_NA}', ""); +Expect(0, 4351, '\P{Hst=_NA}', ""); +Expect(1, 4351, '\P{^Hst=_NA}', ""); +Expect(0, 4441, '\p{Hst=_NA}', ""); +Expect(1, 4441, '\p{^Hst=_NA}', ""); +Expect(1, 4441, '\P{Hst=_NA}', ""); +Expect(0, 4441, '\P{^Hst=_NA}', ""); +Error('\p{Is_Hangul_Syllable_Type=_ not:=applicable}'); +Error('\P{Is_Hangul_Syllable_Type=_ not:=applicable}'); +Expect(1, 4351, '\p{Is_Hangul_Syllable_Type=notapplicable}', ""); +Expect(0, 4351, '\p{^Is_Hangul_Syllable_Type=notapplicable}', ""); +Expect(0, 4351, '\P{Is_Hangul_Syllable_Type=notapplicable}', ""); +Expect(1, 4351, '\P{^Is_Hangul_Syllable_Type=notapplicable}', ""); +Expect(0, 4441, '\p{Is_Hangul_Syllable_Type=notapplicable}', ""); +Expect(1, 4441, '\p{^Is_Hangul_Syllable_Type=notapplicable}', ""); +Expect(1, 4441, '\P{Is_Hangul_Syllable_Type=notapplicable}', ""); +Expect(0, 4441, '\P{^Is_Hangul_Syllable_Type=notapplicable}', ""); +Expect(1, 4351, '\p{Is_Hangul_Syllable_Type=-Not applicable}', ""); +Expect(0, 4351, '\p{^Is_Hangul_Syllable_Type=-Not applicable}', ""); +Expect(0, 4351, '\P{Is_Hangul_Syllable_Type=-Not applicable}', ""); +Expect(1, 4351, '\P{^Is_Hangul_Syllable_Type=-Not applicable}', ""); +Expect(0, 4441, '\p{Is_Hangul_Syllable_Type=-Not applicable}', ""); +Expect(1, 4441, '\p{^Is_Hangul_Syllable_Type=-Not applicable}', ""); +Expect(1, 4441, '\P{Is_Hangul_Syllable_Type=-Not applicable}', ""); +Expect(0, 4441, '\P{^Is_Hangul_Syllable_Type=-Not applicable}', ""); +Error('\p{Is_Hst= /a/na}'); +Error('\P{Is_Hst= /a/na}'); +Expect(1, 4351, '\p{Is_Hst=na}', ""); +Expect(0, 4351, '\p{^Is_Hst=na}', ""); +Expect(0, 4351, '\P{Is_Hst=na}', ""); +Expect(1, 4351, '\P{^Is_Hst=na}', ""); +Expect(0, 4441, '\p{Is_Hst=na}', ""); +Expect(1, 4441, '\p{^Is_Hst=na}', ""); +Expect(1, 4441, '\P{Is_Hst=na}', ""); +Expect(0, 4441, '\P{^Is_Hst=na}', ""); +Expect(1, 4351, '\p{Is_Hst= NA}', ""); +Expect(0, 4351, '\p{^Is_Hst= NA}', ""); +Expect(0, 4351, '\P{Is_Hst= NA}', ""); +Expect(1, 4351, '\P{^Is_Hst= NA}', ""); +Expect(0, 4441, '\p{Is_Hst= NA}', ""); +Expect(1, 4441, '\p{^Is_Hst= NA}', ""); +Expect(1, 4441, '\P{Is_Hst= NA}', ""); +Expect(0, 4441, '\P{^Is_Hst= NA}', ""); +Error('\p{Hangul_Syllable_Type=/a/ _LEADING-Jamo}'); +Error('\P{Hangul_Syllable_Type=/a/ _LEADING-Jamo}'); +Expect(1, 4441, '\p{Hangul_Syllable_Type=leadingjamo}', ""); +Expect(0, 4441, '\p{^Hangul_Syllable_Type=leadingjamo}', ""); +Expect(0, 4441, '\P{Hangul_Syllable_Type=leadingjamo}', ""); +Expect(1, 4441, '\P{^Hangul_Syllable_Type=leadingjamo}', ""); +Expect(0, 4351, '\p{Hangul_Syllable_Type=leadingjamo}', ""); +Expect(1, 4351, '\p{^Hangul_Syllable_Type=leadingjamo}', ""); +Expect(1, 4351, '\P{Hangul_Syllable_Type=leadingjamo}', ""); +Expect(0, 4351, '\P{^Hangul_Syllable_Type=leadingjamo}', ""); +Expect(1, 4441, '\p{Hangul_Syllable_Type=- LEADING jamo}', ""); +Expect(0, 4441, '\p{^Hangul_Syllable_Type=- LEADING jamo}', ""); +Expect(0, 4441, '\P{Hangul_Syllable_Type=- LEADING jamo}', ""); +Expect(1, 4441, '\P{^Hangul_Syllable_Type=- LEADING jamo}', ""); +Expect(0, 4351, '\p{Hangul_Syllable_Type=- LEADING jamo}', ""); +Expect(1, 4351, '\p{^Hangul_Syllable_Type=- LEADING jamo}', ""); +Expect(1, 4351, '\P{Hangul_Syllable_Type=- LEADING jamo}', ""); +Expect(0, 4351, '\P{^Hangul_Syllable_Type=- LEADING jamo}', ""); +Error('\p{Hst=:= L}'); +Error('\P{Hst=:= L}'); +Expect(1, 4441, '\p{Hst=l}', ""); +Expect(0, 4441, '\p{^Hst=l}', ""); +Expect(0, 4441, '\P{Hst=l}', ""); +Expect(1, 4441, '\P{^Hst=l}', ""); +Expect(0, 4351, '\p{Hst=l}', ""); +Expect(1, 4351, '\p{^Hst=l}', ""); +Expect(1, 4351, '\P{Hst=l}', ""); +Expect(0, 4351, '\P{^Hst=l}', ""); +Expect(1, 4441, '\p{Hst=- L}', ""); +Expect(0, 4441, '\p{^Hst=- L}', ""); +Expect(0, 4441, '\P{Hst=- L}', ""); +Expect(1, 4441, '\P{^Hst=- L}', ""); +Expect(0, 4351, '\p{Hst=- L}', ""); +Expect(1, 4351, '\p{^Hst=- L}', ""); +Expect(1, 4351, '\P{Hst=- L}', ""); +Expect(0, 4351, '\P{^Hst=- L}', ""); +Error('\p{Is_Hangul_Syllable_Type= /a/Leading Jamo}'); +Error('\P{Is_Hangul_Syllable_Type= /a/Leading Jamo}'); +Expect(1, 4441, '\p{Is_Hangul_Syllable_Type=leadingjamo}', ""); +Expect(0, 4441, '\p{^Is_Hangul_Syllable_Type=leadingjamo}', ""); +Expect(0, 4441, '\P{Is_Hangul_Syllable_Type=leadingjamo}', ""); +Expect(1, 4441, '\P{^Is_Hangul_Syllable_Type=leadingjamo}', ""); +Expect(0, 4351, '\p{Is_Hangul_Syllable_Type=leadingjamo}', ""); +Expect(1, 4351, '\p{^Is_Hangul_Syllable_Type=leadingjamo}', ""); +Expect(1, 4351, '\P{Is_Hangul_Syllable_Type=leadingjamo}', ""); +Expect(0, 4351, '\P{^Is_Hangul_Syllable_Type=leadingjamo}', ""); +Expect(1, 4441, '\p{Is_Hangul_Syllable_Type=-Leading_JAMO}', ""); +Expect(0, 4441, '\p{^Is_Hangul_Syllable_Type=-Leading_JAMO}', ""); +Expect(0, 4441, '\P{Is_Hangul_Syllable_Type=-Leading_JAMO}', ""); +Expect(1, 4441, '\P{^Is_Hangul_Syllable_Type=-Leading_JAMO}', ""); +Expect(0, 4351, '\p{Is_Hangul_Syllable_Type=-Leading_JAMO}', ""); +Expect(1, 4351, '\p{^Is_Hangul_Syllable_Type=-Leading_JAMO}', ""); +Expect(1, 4351, '\P{Is_Hangul_Syllable_Type=-Leading_JAMO}', ""); +Expect(0, 4351, '\P{^Is_Hangul_Syllable_Type=-Leading_JAMO}', ""); +Error('\p{Is_Hst: /a/L}'); +Error('\P{Is_Hst: /a/L}'); +Expect(1, 4441, '\p{Is_Hst=l}', ""); +Expect(0, 4441, '\p{^Is_Hst=l}', ""); +Expect(0, 4441, '\P{Is_Hst=l}', ""); +Expect(1, 4441, '\P{^Is_Hst=l}', ""); +Expect(0, 4351, '\p{Is_Hst=l}', ""); +Expect(1, 4351, '\p{^Is_Hst=l}', ""); +Expect(1, 4351, '\P{Is_Hst=l}', ""); +Expect(0, 4351, '\P{^Is_Hst=l}', ""); +Expect(1, 4441, '\p{Is_Hst=- L}', ""); +Expect(0, 4441, '\p{^Is_Hst=- L}', ""); +Expect(0, 4441, '\P{Is_Hst=- L}', ""); +Expect(1, 4441, '\P{^Is_Hst=- L}', ""); +Expect(0, 4351, '\p{Is_Hst=- L}', ""); +Expect(1, 4351, '\p{^Is_Hst=- L}', ""); +Expect(1, 4351, '\P{Is_Hst=- L}', ""); +Expect(0, 4351, '\P{^Is_Hst=- L}', ""); +Error('\p{Noncharacter_Code_Point: __Yes/a/}'); +Error('\P{Noncharacter_Code_Point: __Yes/a/}'); +Expect(0, 64975, '\p{Noncharacter_Code_Point=yes}', ""); +Expect(1, 64975, '\p{^Noncharacter_Code_Point=yes}', ""); +Expect(1, 64975, '\P{Noncharacter_Code_Point=yes}', ""); +Expect(0, 64975, '\P{^Noncharacter_Code_Point=yes}', ""); +Expect(0, 64975, '\p{Noncharacter_Code_Point= Yes}', ""); +Expect(1, 64975, '\p{^Noncharacter_Code_Point= Yes}', ""); +Expect(1, 64975, '\P{Noncharacter_Code_Point= Yes}', ""); +Expect(0, 64975, '\P{^Noncharacter_Code_Point= Yes}', ""); +Error('\p{NChar=-:=Y}'); +Error('\P{NChar=-:=Y}'); +Expect(0, 64975, '\p{NChar=y}', ""); +Expect(1, 64975, '\p{^NChar=y}', ""); +Expect(1, 64975, '\P{NChar=y}', ""); +Expect(0, 64975, '\P{^NChar=y}', ""); +Expect(0, 64975, '\p{NChar=-y}', ""); +Expect(1, 64975, '\p{^NChar=-y}', ""); +Expect(1, 64975, '\P{NChar=-y}', ""); +Expect(0, 64975, '\P{^NChar=-y}', ""); +Error('\p{Is_Noncharacter_Code_Point=:=_T}'); +Error('\P{Is_Noncharacter_Code_Point=:=_T}'); +Expect(0, 64975, '\p{Is_Noncharacter_Code_Point=t}', ""); +Expect(1, 64975, '\p{^Is_Noncharacter_Code_Point=t}', ""); +Expect(1, 64975, '\P{Is_Noncharacter_Code_Point=t}', ""); +Expect(0, 64975, '\P{^Is_Noncharacter_Code_Point=t}', ""); +Expect(0, 64975, '\p{Is_Noncharacter_Code_Point: T}', ""); +Expect(1, 64975, '\p{^Is_Noncharacter_Code_Point: T}', ""); +Expect(1, 64975, '\P{Is_Noncharacter_Code_Point: T}', ""); +Expect(0, 64975, '\P{^Is_Noncharacter_Code_Point: T}', ""); +Error('\p{Is_NChar= TRUE:=}'); +Error('\P{Is_NChar= TRUE:=}'); +Expect(0, 64975, '\p{Is_NChar=true}', ""); +Expect(1, 64975, '\p{^Is_NChar=true}', ""); +Expect(1, 64975, '\P{Is_NChar=true}', ""); +Expect(0, 64975, '\P{^Is_NChar=true}', ""); +Expect(0, 64975, '\p{Is_NChar=- TRUE}', ""); +Expect(1, 64975, '\p{^Is_NChar=- TRUE}', ""); +Expect(1, 64975, '\P{Is_NChar=- TRUE}', ""); +Expect(0, 64975, '\P{^Is_NChar=- TRUE}', ""); +Error('\p{Noncharacter_Code_Point=/a/ No}'); +Error('\P{Noncharacter_Code_Point=/a/ No}'); +Expect(1, 64975, '\p{Noncharacter_Code_Point=no}', ""); +Expect(0, 64975, '\p{^Noncharacter_Code_Point=no}', ""); +Expect(0, 64975, '\P{Noncharacter_Code_Point=no}', ""); +Expect(1, 64975, '\P{^Noncharacter_Code_Point=no}', ""); +Expect(1, 64975, '\p{Noncharacter_Code_Point=- No}', ""); +Expect(0, 64975, '\p{^Noncharacter_Code_Point=- No}', ""); +Expect(0, 64975, '\P{Noncharacter_Code_Point=- No}', ""); +Expect(1, 64975, '\P{^Noncharacter_Code_Point=- No}', ""); +Error('\p{NChar= N/a/}'); +Error('\P{NChar= N/a/}'); +Expect(1, 64975, '\p{NChar:n}', ""); +Expect(0, 64975, '\p{^NChar:n}', ""); +Expect(0, 64975, '\P{NChar:n}', ""); +Expect(1, 64975, '\P{^NChar:n}', ""); +Expect(1, 64975, '\p{NChar=-n}', ""); +Expect(0, 64975, '\p{^NChar=-n}', ""); +Expect(0, 64975, '\P{NChar=-n}', ""); +Expect(1, 64975, '\P{^NChar=-n}', ""); +Error('\p{Is_Noncharacter_Code_Point= _F/a/}'); +Error('\P{Is_Noncharacter_Code_Point= _F/a/}'); +Expect(1, 64975, '\p{Is_Noncharacter_Code_Point:f}', ""); +Expect(0, 64975, '\p{^Is_Noncharacter_Code_Point:f}', ""); +Expect(0, 64975, '\P{Is_Noncharacter_Code_Point:f}', ""); +Expect(1, 64975, '\P{^Is_Noncharacter_Code_Point:f}', ""); +Expect(1, 64975, '\p{Is_Noncharacter_Code_Point= F}', ""); +Expect(0, 64975, '\p{^Is_Noncharacter_Code_Point= F}', ""); +Expect(0, 64975, '\P{Is_Noncharacter_Code_Point= F}', ""); +Expect(1, 64975, '\P{^Is_Noncharacter_Code_Point= F}', ""); +Error('\p{Is_NChar= False/a/}'); +Error('\P{Is_NChar= False/a/}'); +Expect(1, 64975, '\p{Is_NChar=false}', ""); +Expect(0, 64975, '\p{^Is_NChar=false}', ""); +Expect(0, 64975, '\P{Is_NChar=false}', ""); +Expect(1, 64975, '\P{^Is_NChar=false}', ""); +Expect(1, 64975, '\p{Is_NChar= False}', ""); +Expect(0, 64975, '\p{^Is_NChar= False}', ""); +Expect(0, 64975, '\P{Is_NChar= False}', ""); +Expect(1, 64975, '\P{^Is_NChar= False}', ""); +Error('\p{Unified_Ideograph= :=Yes}'); +Error('\P{Unified_Ideograph= :=Yes}'); +Expect(1, 19893, '\p{Unified_Ideograph=yes}', ""); +Expect(0, 19893, '\p{^Unified_Ideograph=yes}', ""); +Expect(0, 19893, '\P{Unified_Ideograph=yes}', ""); +Expect(1, 19893, '\P{^Unified_Ideograph=yes}', ""); +Expect(0, 13311, '\p{Unified_Ideograph=yes}', ""); +Expect(1, 13311, '\p{^Unified_Ideograph=yes}', ""); +Expect(1, 13311, '\P{Unified_Ideograph=yes}', ""); +Expect(0, 13311, '\P{^Unified_Ideograph=yes}', ""); +Expect(1, 19893, '\p{Unified_Ideograph=_ YES}', ""); +Expect(0, 19893, '\p{^Unified_Ideograph=_ YES}', ""); +Expect(0, 19893, '\P{Unified_Ideograph=_ YES}', ""); +Expect(1, 19893, '\P{^Unified_Ideograph=_ YES}', ""); +Expect(0, 13311, '\p{Unified_Ideograph=_ YES}', ""); +Expect(1, 13311, '\p{^Unified_Ideograph=_ YES}', ""); +Expect(1, 13311, '\P{Unified_Ideograph=_ YES}', ""); +Expect(0, 13311, '\P{^Unified_Ideograph=_ YES}', ""); +Error('\p{UIdeo= _Y/a/}'); +Error('\P{UIdeo= _Y/a/}'); +Expect(1, 19893, '\p{UIdeo=y}', ""); +Expect(0, 19893, '\p{^UIdeo=y}', ""); +Expect(0, 19893, '\P{UIdeo=y}', ""); +Expect(1, 19893, '\P{^UIdeo=y}', ""); +Expect(0, 13311, '\p{UIdeo=y}', ""); +Expect(1, 13311, '\p{^UIdeo=y}', ""); +Expect(1, 13311, '\P{UIdeo=y}', ""); +Expect(0, 13311, '\P{^UIdeo=y}', ""); +Expect(1, 19893, '\p{UIdeo=_-Y}', ""); +Expect(0, 19893, '\p{^UIdeo=_-Y}', ""); +Expect(0, 19893, '\P{UIdeo=_-Y}', ""); +Expect(1, 19893, '\P{^UIdeo=_-Y}', ""); +Expect(0, 13311, '\p{UIdeo=_-Y}', ""); +Expect(1, 13311, '\p{^UIdeo=_-Y}', ""); +Expect(1, 13311, '\P{UIdeo=_-Y}', ""); +Expect(0, 13311, '\P{^UIdeo=_-Y}', ""); +Error('\p{Is_Unified_Ideograph= t:=}'); +Error('\P{Is_Unified_Ideograph= t:=}'); +Expect(1, 19893, '\p{Is_Unified_Ideograph=t}', ""); +Expect(0, 19893, '\p{^Is_Unified_Ideograph=t}', ""); +Expect(0, 19893, '\P{Is_Unified_Ideograph=t}', ""); +Expect(1, 19893, '\P{^Is_Unified_Ideograph=t}', ""); +Expect(0, 13311, '\p{Is_Unified_Ideograph=t}', ""); +Expect(1, 13311, '\p{^Is_Unified_Ideograph=t}', ""); +Expect(1, 13311, '\P{Is_Unified_Ideograph=t}', ""); +Expect(0, 13311, '\P{^Is_Unified_Ideograph=t}', ""); +Expect(1, 19893, '\p{Is_Unified_Ideograph= T}', ""); +Expect(0, 19893, '\p{^Is_Unified_Ideograph= T}', ""); +Expect(0, 19893, '\P{Is_Unified_Ideograph= T}', ""); +Expect(1, 19893, '\P{^Is_Unified_Ideograph= T}', ""); +Expect(0, 13311, '\p{Is_Unified_Ideograph= T}', ""); +Expect(1, 13311, '\p{^Is_Unified_Ideograph= T}', ""); +Expect(1, 13311, '\P{Is_Unified_Ideograph= T}', ""); +Expect(0, 13311, '\P{^Is_Unified_Ideograph= T}', ""); +Error('\p{Is_UIdeo=_/a/True}'); +Error('\P{Is_UIdeo=_/a/True}'); +Expect(1, 19893, '\p{Is_UIdeo=true}', ""); +Expect(0, 19893, '\p{^Is_UIdeo=true}', ""); +Expect(0, 19893, '\P{Is_UIdeo=true}', ""); +Expect(1, 19893, '\P{^Is_UIdeo=true}', ""); +Expect(0, 13311, '\p{Is_UIdeo=true}', ""); +Expect(1, 13311, '\p{^Is_UIdeo=true}', ""); +Expect(1, 13311, '\P{Is_UIdeo=true}', ""); +Expect(0, 13311, '\P{^Is_UIdeo=true}', ""); +Expect(1, 19893, '\p{Is_UIdeo:_-TRUE}', ""); +Expect(0, 19893, '\p{^Is_UIdeo:_-TRUE}', ""); +Expect(0, 19893, '\P{Is_UIdeo:_-TRUE}', ""); +Expect(1, 19893, '\P{^Is_UIdeo:_-TRUE}', ""); +Expect(0, 13311, '\p{Is_UIdeo:_-TRUE}', ""); +Expect(1, 13311, '\p{^Is_UIdeo:_-TRUE}', ""); +Expect(1, 13311, '\P{Is_UIdeo:_-TRUE}', ""); +Expect(0, 13311, '\P{^Is_UIdeo:_-TRUE}', ""); +Error('\p{Unified_Ideograph: _:=NO}'); +Error('\P{Unified_Ideograph: _:=NO}'); +Expect(1, 13311, '\p{Unified_Ideograph: no}', ""); +Expect(0, 13311, '\p{^Unified_Ideograph: no}', ""); +Expect(0, 13311, '\P{Unified_Ideograph: no}', ""); +Expect(1, 13311, '\P{^Unified_Ideograph: no}', ""); +Expect(0, 19893, '\p{Unified_Ideograph: no}', ""); +Expect(1, 19893, '\p{^Unified_Ideograph: no}', ""); +Expect(1, 19893, '\P{Unified_Ideograph: no}', ""); +Expect(0, 19893, '\P{^Unified_Ideograph: no}', ""); +Expect(1, 13311, '\p{Unified_Ideograph=-No}', ""); +Expect(0, 13311, '\p{^Unified_Ideograph=-No}', ""); +Expect(0, 13311, '\P{Unified_Ideograph=-No}', ""); +Expect(1, 13311, '\P{^Unified_Ideograph=-No}', ""); +Expect(0, 19893, '\p{Unified_Ideograph=-No}', ""); +Expect(1, 19893, '\p{^Unified_Ideograph=-No}', ""); +Expect(1, 19893, '\P{Unified_Ideograph=-No}', ""); +Expect(0, 19893, '\P{^Unified_Ideograph=-No}', ""); +Error('\p{UIdeo=/a/-_N}'); +Error('\P{UIdeo=/a/-_N}'); +Expect(1, 13311, '\p{UIdeo=n}', ""); +Expect(0, 13311, '\p{^UIdeo=n}', ""); +Expect(0, 13311, '\P{UIdeo=n}', ""); +Expect(1, 13311, '\P{^UIdeo=n}', ""); +Expect(0, 19893, '\p{UIdeo=n}', ""); +Expect(1, 19893, '\p{^UIdeo=n}', ""); +Expect(1, 19893, '\P{UIdeo=n}', ""); +Expect(0, 19893, '\P{^UIdeo=n}', ""); +Expect(1, 13311, '\p{UIdeo= -N}', ""); +Expect(0, 13311, '\p{^UIdeo= -N}', ""); +Expect(0, 13311, '\P{UIdeo= -N}', ""); +Expect(1, 13311, '\P{^UIdeo= -N}', ""); +Expect(0, 19893, '\p{UIdeo= -N}', ""); +Expect(1, 19893, '\p{^UIdeo= -N}', ""); +Expect(1, 19893, '\P{UIdeo= -N}', ""); +Expect(0, 19893, '\P{^UIdeo= -N}', ""); +Error('\p{Is_Unified_Ideograph: := F}'); +Error('\P{Is_Unified_Ideograph: := F}'); +Expect(1, 13311, '\p{Is_Unified_Ideograph=f}', ""); +Expect(0, 13311, '\p{^Is_Unified_Ideograph=f}', ""); +Expect(0, 13311, '\P{Is_Unified_Ideograph=f}', ""); +Expect(1, 13311, '\P{^Is_Unified_Ideograph=f}', ""); +Expect(0, 19893, '\p{Is_Unified_Ideograph=f}', ""); +Expect(1, 19893, '\p{^Is_Unified_Ideograph=f}', ""); +Expect(1, 19893, '\P{Is_Unified_Ideograph=f}', ""); +Expect(0, 19893, '\P{^Is_Unified_Ideograph=f}', ""); +Expect(1, 13311, '\p{Is_Unified_Ideograph: F}', ""); +Expect(0, 13311, '\p{^Is_Unified_Ideograph: F}', ""); +Expect(0, 13311, '\P{Is_Unified_Ideograph: F}', ""); +Expect(1, 13311, '\P{^Is_Unified_Ideograph: F}', ""); +Expect(0, 19893, '\p{Is_Unified_Ideograph: F}', ""); +Expect(1, 19893, '\p{^Is_Unified_Ideograph: F}', ""); +Expect(1, 19893, '\P{Is_Unified_Ideograph: F}', ""); +Expect(0, 19893, '\P{^Is_Unified_Ideograph: F}', ""); +Error('\p{Is_UIdeo= FALSE:=}'); +Error('\P{Is_UIdeo= FALSE:=}'); +Expect(1, 13311, '\p{Is_UIdeo=false}', ""); +Expect(0, 13311, '\p{^Is_UIdeo=false}', ""); +Expect(0, 13311, '\P{Is_UIdeo=false}', ""); +Expect(1, 13311, '\P{^Is_UIdeo=false}', ""); +Expect(0, 19893, '\p{Is_UIdeo=false}', ""); +Expect(1, 19893, '\p{^Is_UIdeo=false}', ""); +Expect(1, 19893, '\P{Is_UIdeo=false}', ""); +Expect(0, 19893, '\P{^Is_UIdeo=false}', ""); +Expect(1, 13311, '\p{Is_UIdeo: - False}', ""); +Expect(0, 13311, '\p{^Is_UIdeo: - False}', ""); +Expect(0, 13311, '\P{Is_UIdeo: - False}', ""); +Expect(1, 13311, '\P{^Is_UIdeo: - False}', ""); +Expect(0, 19893, '\p{Is_UIdeo: - False}', ""); +Expect(1, 19893, '\p{^Is_UIdeo: - False}', ""); +Expect(1, 19893, '\P{Is_UIdeo: - False}', ""); +Expect(0, 19893, '\P{^Is_UIdeo: - False}', ""); +Error('\p{Diacritic=/a/_Yes}'); +Error('\P{Diacritic=/a/_Yes}'); +Expect(1, 94, '\p{Diacritic=yes}', ""); +Expect(0, 94, '\p{^Diacritic=yes}', ""); +Expect(0, 94, '\P{Diacritic=yes}', ""); +Expect(1, 94, '\P{^Diacritic=yes}', ""); +Expect(0, 93, '\p{Diacritic=yes}', ""); +Expect(1, 93, '\p{^Diacritic=yes}', ""); +Expect(1, 93, '\P{Diacritic=yes}', ""); +Expect(0, 93, '\P{^Diacritic=yes}', ""); +Expect(1, 94, '\p{Diacritic= yes}', ""); +Expect(0, 94, '\p{^Diacritic= yes}', ""); +Expect(0, 94, '\P{Diacritic= yes}', ""); +Expect(1, 94, '\P{^Diacritic= yes}', ""); +Expect(0, 93, '\p{Diacritic= yes}', ""); +Expect(1, 93, '\p{^Diacritic= yes}', ""); +Expect(1, 93, '\P{Diacritic= yes}', ""); +Expect(0, 93, '\P{^Diacritic= yes}', ""); +Error('\p{Dia=_ Y:=}'); +Error('\P{Dia=_ Y:=}'); +Expect(1, 94, '\p{Dia=y}', ""); +Expect(0, 94, '\p{^Dia=y}', ""); +Expect(0, 94, '\P{Dia=y}', ""); +Expect(1, 94, '\P{^Dia=y}', ""); +Expect(0, 93, '\p{Dia=y}', ""); +Expect(1, 93, '\p{^Dia=y}', ""); +Expect(1, 93, '\P{Dia=y}', ""); +Expect(0, 93, '\P{^Dia=y}', ""); +Expect(1, 94, '\p{Dia=Y}', ""); +Expect(0, 94, '\p{^Dia=Y}', ""); +Expect(0, 94, '\P{Dia=Y}', ""); +Expect(1, 94, '\P{^Dia=Y}', ""); +Expect(0, 93, '\p{Dia=Y}', ""); +Expect(1, 93, '\p{^Dia=Y}', ""); +Expect(1, 93, '\P{Dia=Y}', ""); +Expect(0, 93, '\P{^Dia=Y}', ""); +Error('\p{Is_Diacritic= -t/a/}'); +Error('\P{Is_Diacritic= -t/a/}'); +Expect(1, 94, '\p{Is_Diacritic: t}', ""); +Expect(0, 94, '\p{^Is_Diacritic: t}', ""); +Expect(0, 94, '\P{Is_Diacritic: t}', ""); +Expect(1, 94, '\P{^Is_Diacritic: t}', ""); +Expect(0, 93, '\p{Is_Diacritic: t}', ""); +Expect(1, 93, '\p{^Is_Diacritic: t}', ""); +Expect(1, 93, '\P{Is_Diacritic: t}', ""); +Expect(0, 93, '\P{^Is_Diacritic: t}', ""); +Expect(1, 94, '\p{Is_Diacritic= t}', ""); +Expect(0, 94, '\p{^Is_Diacritic= t}', ""); +Expect(0, 94, '\P{Is_Diacritic= t}', ""); +Expect(1, 94, '\P{^Is_Diacritic= t}', ""); +Expect(0, 93, '\p{Is_Diacritic= t}', ""); +Expect(1, 93, '\p{^Is_Diacritic= t}', ""); +Expect(1, 93, '\P{Is_Diacritic= t}', ""); +Expect(0, 93, '\P{^Is_Diacritic= t}', ""); +Error('\p{Is_Dia= :=true}'); +Error('\P{Is_Dia= :=true}'); +Expect(1, 94, '\p{Is_Dia=true}', ""); +Expect(0, 94, '\p{^Is_Dia=true}', ""); +Expect(0, 94, '\P{Is_Dia=true}', ""); +Expect(1, 94, '\P{^Is_Dia=true}', ""); +Expect(0, 93, '\p{Is_Dia=true}', ""); +Expect(1, 93, '\p{^Is_Dia=true}', ""); +Expect(1, 93, '\P{Is_Dia=true}', ""); +Expect(0, 93, '\P{^Is_Dia=true}', ""); +Expect(1, 94, '\p{Is_Dia:- True}', ""); +Expect(0, 94, '\p{^Is_Dia:- True}', ""); +Expect(0, 94, '\P{Is_Dia:- True}', ""); +Expect(1, 94, '\P{^Is_Dia:- True}', ""); +Expect(0, 93, '\p{Is_Dia:- True}', ""); +Expect(1, 93, '\p{^Is_Dia:- True}', ""); +Expect(1, 93, '\P{Is_Dia:- True}', ""); +Expect(0, 93, '\P{^Is_Dia:- True}', ""); +Error('\p{Diacritic=/a/No}'); +Error('\P{Diacritic=/a/No}'); +Expect(1, 93, '\p{Diacritic=no}', ""); +Expect(0, 93, '\p{^Diacritic=no}', ""); +Expect(0, 93, '\P{Diacritic=no}', ""); +Expect(1, 93, '\P{^Diacritic=no}', ""); +Expect(0, 94, '\p{Diacritic=no}', ""); +Expect(1, 94, '\p{^Diacritic=no}', ""); +Expect(1, 94, '\P{Diacritic=no}', ""); +Expect(0, 94, '\P{^Diacritic=no}', ""); +Expect(1, 93, '\p{Diacritic=_NO}', ""); +Expect(0, 93, '\p{^Diacritic=_NO}', ""); +Expect(0, 93, '\P{Diacritic=_NO}', ""); +Expect(1, 93, '\P{^Diacritic=_NO}', ""); +Expect(0, 94, '\p{Diacritic=_NO}', ""); +Expect(1, 94, '\p{^Diacritic=_NO}', ""); +Expect(1, 94, '\P{Diacritic=_NO}', ""); +Expect(0, 94, '\P{^Diacritic=_NO}', ""); +Error('\p{Dia: /a/-N}'); +Error('\P{Dia: /a/-N}'); +Expect(1, 93, '\p{Dia=n}', ""); +Expect(0, 93, '\p{^Dia=n}', ""); +Expect(0, 93, '\P{Dia=n}', ""); +Expect(1, 93, '\P{^Dia=n}', ""); +Expect(0, 94, '\p{Dia=n}', ""); +Expect(1, 94, '\p{^Dia=n}', ""); +Expect(1, 94, '\P{Dia=n}', ""); +Expect(0, 94, '\P{^Dia=n}', ""); +Expect(1, 93, '\p{Dia= -N}', ""); +Expect(0, 93, '\p{^Dia= -N}', ""); +Expect(0, 93, '\P{Dia= -N}', ""); +Expect(1, 93, '\P{^Dia= -N}', ""); +Expect(0, 94, '\p{Dia= -N}', ""); +Expect(1, 94, '\p{^Dia= -N}', ""); +Expect(1, 94, '\P{Dia= -N}', ""); +Expect(0, 94, '\P{^Dia= -N}', ""); +Error('\p{Is_Diacritic=-:=F}'); +Error('\P{Is_Diacritic=-:=F}'); +Expect(1, 93, '\p{Is_Diacritic: f}', ""); +Expect(0, 93, '\p{^Is_Diacritic: f}', ""); +Expect(0, 93, '\P{Is_Diacritic: f}', ""); +Expect(1, 93, '\P{^Is_Diacritic: f}', ""); +Expect(0, 94, '\p{Is_Diacritic: f}', ""); +Expect(1, 94, '\p{^Is_Diacritic: f}', ""); +Expect(1, 94, '\P{Is_Diacritic: f}', ""); +Expect(0, 94, '\P{^Is_Diacritic: f}', ""); +Expect(1, 93, '\p{Is_Diacritic= F}', ""); +Expect(0, 93, '\p{^Is_Diacritic= F}', ""); +Expect(0, 93, '\P{Is_Diacritic= F}', ""); +Expect(1, 93, '\P{^Is_Diacritic= F}', ""); +Expect(0, 94, '\p{Is_Diacritic= F}', ""); +Expect(1, 94, '\p{^Is_Diacritic= F}', ""); +Expect(1, 94, '\P{Is_Diacritic= F}', ""); +Expect(0, 94, '\P{^Is_Diacritic= F}', ""); +Error('\p{Is_Dia=_ false/a/}'); +Error('\P{Is_Dia=_ false/a/}'); +Expect(1, 93, '\p{Is_Dia=false}', ""); +Expect(0, 93, '\p{^Is_Dia=false}', ""); +Expect(0, 93, '\P{Is_Dia=false}', ""); +Expect(1, 93, '\P{^Is_Dia=false}', ""); +Expect(0, 94, '\p{Is_Dia=false}', ""); +Expect(1, 94, '\p{^Is_Dia=false}', ""); +Expect(1, 94, '\P{Is_Dia=false}', ""); +Expect(0, 94, '\P{^Is_Dia=false}', ""); +Expect(1, 93, '\p{Is_Dia= false}', ""); +Expect(0, 93, '\p{^Is_Dia= false}', ""); +Expect(0, 93, '\P{Is_Dia= false}', ""); +Expect(1, 93, '\P{^Is_Dia= false}', ""); +Expect(0, 94, '\p{Is_Dia= false}', ""); +Expect(1, 94, '\p{^Is_Dia= false}', ""); +Expect(1, 94, '\P{Is_Dia= false}', ""); +Expect(0, 94, '\P{^Is_Dia= false}', ""); +Error('\p{Perl_Canonical_Combining_Class=0}'); +Error('\P{Perl_Canonical_Combining_Class=0}'); +Error('\p{Perl_ccc: 0}'); +Error('\P{Perl_ccc: 0}'); +Error('\p{Grapheme_Extend=/a/ yes}'); +Error('\P{Grapheme_Extend=/a/ yes}'); +Expect(1, 879, '\p{Grapheme_Extend=yes}', ""); +Expect(0, 879, '\p{^Grapheme_Extend=yes}', ""); +Expect(0, 879, '\P{Grapheme_Extend=yes}', ""); +Expect(1, 879, '\P{^Grapheme_Extend=yes}', ""); +Expect(0, 767, '\p{Grapheme_Extend=yes}', ""); +Expect(1, 767, '\p{^Grapheme_Extend=yes}', ""); +Expect(1, 767, '\P{Grapheme_Extend=yes}', ""); +Expect(0, 767, '\P{^Grapheme_Extend=yes}', ""); +Expect(1, 879, '\p{Grapheme_Extend= _yes}', ""); +Expect(0, 879, '\p{^Grapheme_Extend= _yes}', ""); +Expect(0, 879, '\P{Grapheme_Extend= _yes}', ""); +Expect(1, 879, '\P{^Grapheme_Extend= _yes}', ""); +Expect(0, 767, '\p{Grapheme_Extend= _yes}', ""); +Expect(1, 767, '\p{^Grapheme_Extend= _yes}', ""); +Expect(1, 767, '\P{Grapheme_Extend= _yes}', ""); +Expect(0, 767, '\P{^Grapheme_Extend= _yes}', ""); +Error('\p{Gr_Ext=- Y/a/}'); +Error('\P{Gr_Ext=- Y/a/}'); +Expect(1, 879, '\p{Gr_Ext=y}', ""); +Expect(0, 879, '\p{^Gr_Ext=y}', ""); +Expect(0, 879, '\P{Gr_Ext=y}', ""); +Expect(1, 879, '\P{^Gr_Ext=y}', ""); +Expect(0, 767, '\p{Gr_Ext=y}', ""); +Expect(1, 767, '\p{^Gr_Ext=y}', ""); +Expect(1, 767, '\P{Gr_Ext=y}', ""); +Expect(0, 767, '\P{^Gr_Ext=y}', ""); +Expect(1, 879, '\p{Gr_Ext= -Y}', ""); +Expect(0, 879, '\p{^Gr_Ext= -Y}', ""); +Expect(0, 879, '\P{Gr_Ext= -Y}', ""); +Expect(1, 879, '\P{^Gr_Ext= -Y}', ""); +Expect(0, 767, '\p{Gr_Ext= -Y}', ""); +Expect(1, 767, '\p{^Gr_Ext= -Y}', ""); +Expect(1, 767, '\P{Gr_Ext= -Y}', ""); +Expect(0, 767, '\P{^Gr_Ext= -Y}', ""); +Error('\p{Is_Grapheme_Extend= t:=}'); +Error('\P{Is_Grapheme_Extend= t:=}'); +Expect(1, 879, '\p{Is_Grapheme_Extend=t}', ""); +Expect(0, 879, '\p{^Is_Grapheme_Extend=t}', ""); +Expect(0, 879, '\P{Is_Grapheme_Extend=t}', ""); +Expect(1, 879, '\P{^Is_Grapheme_Extend=t}', ""); +Expect(0, 767, '\p{Is_Grapheme_Extend=t}', ""); +Expect(1, 767, '\p{^Is_Grapheme_Extend=t}', ""); +Expect(1, 767, '\P{Is_Grapheme_Extend=t}', ""); +Expect(0, 767, '\P{^Is_Grapheme_Extend=t}', ""); +Expect(1, 879, '\p{Is_Grapheme_Extend=--T}', ""); +Expect(0, 879, '\p{^Is_Grapheme_Extend=--T}', ""); +Expect(0, 879, '\P{Is_Grapheme_Extend=--T}', ""); +Expect(1, 879, '\P{^Is_Grapheme_Extend=--T}', ""); +Expect(0, 767, '\p{Is_Grapheme_Extend=--T}', ""); +Expect(1, 767, '\p{^Is_Grapheme_Extend=--T}', ""); +Expect(1, 767, '\P{Is_Grapheme_Extend=--T}', ""); +Expect(0, 767, '\P{^Is_Grapheme_Extend=--T}', ""); +Error('\p{Is_Gr_Ext:-True/a/}'); +Error('\P{Is_Gr_Ext:-True/a/}'); +Expect(1, 879, '\p{Is_Gr_Ext: true}', ""); +Expect(0, 879, '\p{^Is_Gr_Ext: true}', ""); +Expect(0, 879, '\P{Is_Gr_Ext: true}', ""); +Expect(1, 879, '\P{^Is_Gr_Ext: true}', ""); +Expect(0, 767, '\p{Is_Gr_Ext: true}', ""); +Expect(1, 767, '\p{^Is_Gr_Ext: true}', ""); +Expect(1, 767, '\P{Is_Gr_Ext: true}', ""); +Expect(0, 767, '\P{^Is_Gr_Ext: true}', ""); +Expect(1, 879, '\p{Is_Gr_Ext=- True}', ""); +Expect(0, 879, '\p{^Is_Gr_Ext=- True}', ""); +Expect(0, 879, '\P{Is_Gr_Ext=- True}', ""); +Expect(1, 879, '\P{^Is_Gr_Ext=- True}', ""); +Expect(0, 767, '\p{Is_Gr_Ext=- True}', ""); +Expect(1, 767, '\p{^Is_Gr_Ext=- True}', ""); +Expect(1, 767, '\P{Is_Gr_Ext=- True}', ""); +Expect(0, 767, '\P{^Is_Gr_Ext=- True}', ""); +Error('\p{Grapheme_Extend= /a/no}'); +Error('\P{Grapheme_Extend= /a/no}'); +Expect(1, 767, '\p{Grapheme_Extend=no}', ""); +Expect(0, 767, '\p{^Grapheme_Extend=no}', ""); +Expect(0, 767, '\P{Grapheme_Extend=no}', ""); +Expect(1, 767, '\P{^Grapheme_Extend=no}', ""); +Expect(0, 879, '\p{Grapheme_Extend=no}', ""); +Expect(1, 879, '\p{^Grapheme_Extend=no}', ""); +Expect(1, 879, '\P{Grapheme_Extend=no}', ""); +Expect(0, 879, '\P{^Grapheme_Extend=no}', ""); +Expect(1, 767, '\p{Grapheme_Extend=-No}', ""); +Expect(0, 767, '\p{^Grapheme_Extend=-No}', ""); +Expect(0, 767, '\P{Grapheme_Extend=-No}', ""); +Expect(1, 767, '\P{^Grapheme_Extend=-No}', ""); +Expect(0, 879, '\p{Grapheme_Extend=-No}', ""); +Expect(1, 879, '\p{^Grapheme_Extend=-No}', ""); +Expect(1, 879, '\P{Grapheme_Extend=-No}', ""); +Expect(0, 879, '\P{^Grapheme_Extend=-No}', ""); +Error('\p{Gr_Ext: _ N/a/}'); +Error('\P{Gr_Ext: _ N/a/}'); +Expect(1, 767, '\p{Gr_Ext=n}', ""); +Expect(0, 767, '\p{^Gr_Ext=n}', ""); +Expect(0, 767, '\P{Gr_Ext=n}', ""); +Expect(1, 767, '\P{^Gr_Ext=n}', ""); +Expect(0, 879, '\p{Gr_Ext=n}', ""); +Expect(1, 879, '\p{^Gr_Ext=n}', ""); +Expect(1, 879, '\P{Gr_Ext=n}', ""); +Expect(0, 879, '\P{^Gr_Ext=n}', ""); +Expect(1, 767, '\p{Gr_Ext= N}', ""); +Expect(0, 767, '\p{^Gr_Ext= N}', ""); +Expect(0, 767, '\P{Gr_Ext= N}', ""); +Expect(1, 767, '\P{^Gr_Ext= N}', ""); +Expect(0, 879, '\p{Gr_Ext= N}', ""); +Expect(1, 879, '\p{^Gr_Ext= N}', ""); +Expect(1, 879, '\P{Gr_Ext= N}', ""); +Expect(0, 879, '\P{^Gr_Ext= N}', ""); +Error('\p{Is_Grapheme_Extend=/a/ -F}'); +Error('\P{Is_Grapheme_Extend=/a/ -F}'); +Expect(1, 767, '\p{Is_Grapheme_Extend=f}', ""); +Expect(0, 767, '\p{^Is_Grapheme_Extend=f}', ""); +Expect(0, 767, '\P{Is_Grapheme_Extend=f}', ""); +Expect(1, 767, '\P{^Is_Grapheme_Extend=f}', ""); +Expect(0, 879, '\p{Is_Grapheme_Extend=f}', ""); +Expect(1, 879, '\p{^Is_Grapheme_Extend=f}', ""); +Expect(1, 879, '\P{Is_Grapheme_Extend=f}', ""); +Expect(0, 879, '\P{^Is_Grapheme_Extend=f}', ""); +Expect(1, 767, '\p{Is_Grapheme_Extend: _F}', ""); +Expect(0, 767, '\p{^Is_Grapheme_Extend: _F}', ""); +Expect(0, 767, '\P{Is_Grapheme_Extend: _F}', ""); +Expect(1, 767, '\P{^Is_Grapheme_Extend: _F}', ""); +Expect(0, 879, '\p{Is_Grapheme_Extend: _F}', ""); +Expect(1, 879, '\p{^Is_Grapheme_Extend: _F}', ""); +Expect(1, 879, '\P{Is_Grapheme_Extend: _F}', ""); +Expect(0, 879, '\P{^Is_Grapheme_Extend: _F}', ""); +Error('\p{Is_Gr_Ext: :=False}'); +Error('\P{Is_Gr_Ext: :=False}'); +Expect(1, 767, '\p{Is_Gr_Ext:false}', ""); +Expect(0, 767, '\p{^Is_Gr_Ext:false}', ""); +Expect(0, 767, '\P{Is_Gr_Ext:false}', ""); +Expect(1, 767, '\P{^Is_Gr_Ext:false}', ""); +Expect(0, 879, '\p{Is_Gr_Ext:false}', ""); +Expect(1, 879, '\p{^Is_Gr_Ext:false}', ""); +Expect(1, 879, '\P{Is_Gr_Ext:false}', ""); +Expect(0, 879, '\P{^Is_Gr_Ext:false}', ""); +Expect(1, 767, '\p{Is_Gr_Ext=_ False}', ""); +Expect(0, 767, '\p{^Is_Gr_Ext=_ False}', ""); +Expect(0, 767, '\P{Is_Gr_Ext=_ False}', ""); +Expect(1, 767, '\P{^Is_Gr_Ext=_ False}', ""); +Expect(0, 879, '\p{Is_Gr_Ext=_ False}', ""); +Expect(1, 879, '\p{^Is_Gr_Ext=_ False}', ""); +Expect(1, 879, '\P{Is_Gr_Ext=_ False}', ""); +Expect(0, 879, '\P{^Is_Gr_Ext=_ False}', ""); +Error('\p{Other_ID_Continue= YES/a/}'); +Error('\P{Other_ID_Continue= YES/a/}'); +Expect(1, 903, '\p{Other_ID_Continue=yes}', 'deprecated'); +Expect(0, 903, '\p{^Other_ID_Continue=yes}', 'deprecated'); +Expect(0, 903, '\P{Other_ID_Continue=yes}', 'deprecated'); +Expect(1, 903, '\P{^Other_ID_Continue=yes}', 'deprecated'); +Expect(0, 7, '\p{Other_ID_Continue=yes}', 'deprecated'); +Expect(1, 7, '\p{^Other_ID_Continue=yes}', 'deprecated'); +Expect(1, 7, '\P{Other_ID_Continue=yes}', 'deprecated'); +Expect(0, 7, '\P{^Other_ID_Continue=yes}', 'deprecated'); +Expect(1, 903, '\p{Other_ID_Continue= yes}', 'deprecated'); +Expect(0, 903, '\p{^Other_ID_Continue= yes}', 'deprecated'); +Expect(0, 903, '\P{Other_ID_Continue= yes}', 'deprecated'); +Expect(1, 903, '\P{^Other_ID_Continue= yes}', 'deprecated'); +Expect(0, 7, '\p{Other_ID_Continue= yes}', 'deprecated'); +Expect(1, 7, '\p{^Other_ID_Continue= yes}', 'deprecated'); +Expect(1, 7, '\P{Other_ID_Continue= yes}', 'deprecated'); +Expect(0, 7, '\P{^Other_ID_Continue= yes}', 'deprecated'); +Error('\p{OIDC=/a/_Y}'); +Error('\P{OIDC=/a/_Y}'); +Expect(1, 903, '\p{OIDC=y}', 'deprecated'); +Expect(0, 903, '\p{^OIDC=y}', 'deprecated'); +Expect(0, 903, '\P{OIDC=y}', 'deprecated'); +Expect(1, 903, '\P{^OIDC=y}', 'deprecated'); +Expect(0, 7, '\p{OIDC=y}', 'deprecated'); +Expect(1, 7, '\p{^OIDC=y}', 'deprecated'); +Expect(1, 7, '\P{OIDC=y}', 'deprecated'); +Expect(0, 7, '\P{^OIDC=y}', 'deprecated'); +Expect(1, 903, '\p{OIDC: y}', 'deprecated'); +Expect(0, 903, '\p{^OIDC: y}', 'deprecated'); +Expect(0, 903, '\P{OIDC: y}', 'deprecated'); +Expect(1, 903, '\P{^OIDC: y}', 'deprecated'); +Expect(0, 7, '\p{OIDC: y}', 'deprecated'); +Expect(1, 7, '\p{^OIDC: y}', 'deprecated'); +Expect(1, 7, '\P{OIDC: y}', 'deprecated'); +Expect(0, 7, '\P{^OIDC: y}', 'deprecated'); +Error('\p{Is_Other_ID_Continue=_:=T}'); +Error('\P{Is_Other_ID_Continue=_:=T}'); +Expect(1, 903, '\p{Is_Other_ID_Continue=t}', 'deprecated'); +Expect(0, 903, '\p{^Is_Other_ID_Continue=t}', 'deprecated'); +Expect(0, 903, '\P{Is_Other_ID_Continue=t}', 'deprecated'); +Expect(1, 903, '\P{^Is_Other_ID_Continue=t}', 'deprecated'); +Expect(0, 7, '\p{Is_Other_ID_Continue=t}', 'deprecated'); +Expect(1, 7, '\p{^Is_Other_ID_Continue=t}', 'deprecated'); +Expect(1, 7, '\P{Is_Other_ID_Continue=t}', 'deprecated'); +Expect(0, 7, '\P{^Is_Other_ID_Continue=t}', 'deprecated'); +Expect(1, 903, '\p{Is_Other_ID_Continue=--T}', 'deprecated'); +Expect(0, 903, '\p{^Is_Other_ID_Continue=--T}', 'deprecated'); +Expect(0, 903, '\P{Is_Other_ID_Continue=--T}', 'deprecated'); +Expect(1, 903, '\P{^Is_Other_ID_Continue=--T}', 'deprecated'); +Expect(0, 7, '\p{Is_Other_ID_Continue=--T}', 'deprecated'); +Expect(1, 7, '\p{^Is_Other_ID_Continue=--T}', 'deprecated'); +Expect(1, 7, '\P{Is_Other_ID_Continue=--T}', 'deprecated'); +Expect(0, 7, '\P{^Is_Other_ID_Continue=--T}', 'deprecated'); +Error('\p{Is_OIDC:/a/ true}'); +Error('\P{Is_OIDC:/a/ true}'); +Expect(1, 903, '\p{Is_OIDC=true}', 'deprecated'); +Expect(0, 903, '\p{^Is_OIDC=true}', 'deprecated'); +Expect(0, 903, '\P{Is_OIDC=true}', 'deprecated'); +Expect(1, 903, '\P{^Is_OIDC=true}', 'deprecated'); +Expect(0, 7, '\p{Is_OIDC=true}', 'deprecated'); +Expect(1, 7, '\p{^Is_OIDC=true}', 'deprecated'); +Expect(1, 7, '\P{Is_OIDC=true}', 'deprecated'); +Expect(0, 7, '\P{^Is_OIDC=true}', 'deprecated'); +Expect(1, 903, '\p{Is_OIDC= True}', 'deprecated'); +Expect(0, 903, '\p{^Is_OIDC= True}', 'deprecated'); +Expect(0, 903, '\P{Is_OIDC= True}', 'deprecated'); +Expect(1, 903, '\P{^Is_OIDC= True}', 'deprecated'); +Expect(0, 7, '\p{Is_OIDC= True}', 'deprecated'); +Expect(1, 7, '\p{^Is_OIDC= True}', 'deprecated'); +Expect(1, 7, '\P{Is_OIDC= True}', 'deprecated'); +Expect(0, 7, '\P{^Is_OIDC= True}', 'deprecated'); +Error('\p{Other_ID_Continue: /a/no}'); +Error('\P{Other_ID_Continue: /a/no}'); +Expect(1, 7, '\p{Other_ID_Continue: no}', 'deprecated'); +Expect(0, 7, '\p{^Other_ID_Continue: no}', 'deprecated'); +Expect(0, 7, '\P{Other_ID_Continue: no}', 'deprecated'); +Expect(1, 7, '\P{^Other_ID_Continue: no}', 'deprecated'); +Expect(0, 903, '\p{Other_ID_Continue: no}', 'deprecated'); +Expect(1, 903, '\p{^Other_ID_Continue: no}', 'deprecated'); +Expect(1, 903, '\P{Other_ID_Continue: no}', 'deprecated'); +Expect(0, 903, '\P{^Other_ID_Continue: no}', 'deprecated'); +Expect(1, 7, '\p{Other_ID_Continue=_ NO}', 'deprecated'); +Expect(0, 7, '\p{^Other_ID_Continue=_ NO}', 'deprecated'); +Expect(0, 7, '\P{Other_ID_Continue=_ NO}', 'deprecated'); +Expect(1, 7, '\P{^Other_ID_Continue=_ NO}', 'deprecated'); +Expect(0, 903, '\p{Other_ID_Continue=_ NO}', 'deprecated'); +Expect(1, 903, '\p{^Other_ID_Continue=_ NO}', 'deprecated'); +Expect(1, 903, '\P{Other_ID_Continue=_ NO}', 'deprecated'); +Expect(0, 903, '\P{^Other_ID_Continue=_ NO}', 'deprecated'); +Error('\p{OIDC=/a/n}'); +Error('\P{OIDC=/a/n}'); +Expect(1, 7, '\p{OIDC=n}', 'deprecated'); +Expect(0, 7, '\p{^OIDC=n}', 'deprecated'); +Expect(0, 7, '\P{OIDC=n}', 'deprecated'); +Expect(1, 7, '\P{^OIDC=n}', 'deprecated'); +Expect(0, 903, '\p{OIDC=n}', 'deprecated'); +Expect(1, 903, '\p{^OIDC=n}', 'deprecated'); +Expect(1, 903, '\P{OIDC=n}', 'deprecated'); +Expect(0, 903, '\P{^OIDC=n}', 'deprecated'); +Expect(1, 7, '\p{OIDC=-N}', 'deprecated'); +Expect(0, 7, '\p{^OIDC=-N}', 'deprecated'); +Expect(0, 7, '\P{OIDC=-N}', 'deprecated'); +Expect(1, 7, '\P{^OIDC=-N}', 'deprecated'); +Expect(0, 903, '\p{OIDC=-N}', 'deprecated'); +Expect(1, 903, '\p{^OIDC=-N}', 'deprecated'); +Expect(1, 903, '\P{OIDC=-N}', 'deprecated'); +Expect(0, 903, '\P{^OIDC=-N}', 'deprecated'); +Error('\p{Is_Other_ID_Continue=:=-F}'); +Error('\P{Is_Other_ID_Continue=:=-F}'); +Expect(1, 7, '\p{Is_Other_ID_Continue=f}', 'deprecated'); +Expect(0, 7, '\p{^Is_Other_ID_Continue=f}', 'deprecated'); +Expect(0, 7, '\P{Is_Other_ID_Continue=f}', 'deprecated'); +Expect(1, 7, '\P{^Is_Other_ID_Continue=f}', 'deprecated'); +Expect(0, 903, '\p{Is_Other_ID_Continue=f}', 'deprecated'); +Expect(1, 903, '\p{^Is_Other_ID_Continue=f}', 'deprecated'); +Expect(1, 903, '\P{Is_Other_ID_Continue=f}', 'deprecated'); +Expect(0, 903, '\P{^Is_Other_ID_Continue=f}', 'deprecated'); +Expect(1, 7, '\p{Is_Other_ID_Continue= F}', 'deprecated'); +Expect(0, 7, '\p{^Is_Other_ID_Continue= F}', 'deprecated'); +Expect(0, 7, '\P{Is_Other_ID_Continue= F}', 'deprecated'); +Expect(1, 7, '\P{^Is_Other_ID_Continue= F}', 'deprecated'); +Expect(0, 903, '\p{Is_Other_ID_Continue= F}', 'deprecated'); +Expect(1, 903, '\p{^Is_Other_ID_Continue= F}', 'deprecated'); +Expect(1, 903, '\P{Is_Other_ID_Continue= F}', 'deprecated'); +Expect(0, 903, '\P{^Is_Other_ID_Continue= F}', 'deprecated'); +Error('\p{Is_OIDC=:=_false}'); +Error('\P{Is_OIDC=:=_false}'); +Expect(1, 7, '\p{Is_OIDC=false}', 'deprecated'); +Expect(0, 7, '\p{^Is_OIDC=false}', 'deprecated'); +Expect(0, 7, '\P{Is_OIDC=false}', 'deprecated'); +Expect(1, 7, '\P{^Is_OIDC=false}', 'deprecated'); +Expect(0, 903, '\p{Is_OIDC=false}', 'deprecated'); +Expect(1, 903, '\p{^Is_OIDC=false}', 'deprecated'); +Expect(1, 903, '\P{Is_OIDC=false}', 'deprecated'); +Expect(0, 903, '\P{^Is_OIDC=false}', 'deprecated'); +Expect(1, 7, '\p{Is_OIDC: false}', 'deprecated'); +Expect(0, 7, '\p{^Is_OIDC: false}', 'deprecated'); +Expect(0, 7, '\P{Is_OIDC: false}', 'deprecated'); +Expect(1, 7, '\P{^Is_OIDC: false}', 'deprecated'); +Expect(0, 903, '\p{Is_OIDC: false}', 'deprecated'); +Expect(1, 903, '\p{^Is_OIDC: false}', 'deprecated'); +Expect(1, 903, '\P{Is_OIDC: false}', 'deprecated'); +Expect(0, 903, '\P{^Is_OIDC: false}', 'deprecated'); +Error('\p{Joining_Group= SWASH/a/Kaf}'); +Error('\P{Joining_Group= SWASH/a/Kaf}'); +Expect(1, 1706, '\p{Joining_Group=swashkaf}', ""); +Expect(0, 1706, '\p{^Joining_Group=swashkaf}', ""); +Expect(0, 1706, '\P{Joining_Group=swashkaf}', ""); +Expect(1, 1706, '\P{^Joining_Group=swashkaf}', ""); +Expect(0, 1705, '\p{Joining_Group=swashkaf}', ""); +Expect(1, 1705, '\p{^Joining_Group=swashkaf}', ""); +Expect(1, 1705, '\P{Joining_Group=swashkaf}', ""); +Expect(0, 1705, '\P{^Joining_Group=swashkaf}', ""); +Expect(1, 1706, '\p{Joining_Group=_swash Kaf}', ""); +Expect(0, 1706, '\p{^Joining_Group=_swash Kaf}', ""); +Expect(0, 1706, '\P{Joining_Group=_swash Kaf}', ""); +Expect(1, 1706, '\P{^Joining_Group=_swash Kaf}', ""); +Expect(0, 1705, '\p{Joining_Group=_swash Kaf}', ""); +Expect(1, 1705, '\p{^Joining_Group=_swash Kaf}', ""); +Expect(1, 1705, '\P{Joining_Group=_swash Kaf}', ""); +Expect(0, 1705, '\P{^Joining_Group=_swash Kaf}', ""); +Error('\p{Jg=:= -swash Kaf}'); +Error('\P{Jg=:= -swash Kaf}'); +Expect(1, 1706, '\p{Jg=swashkaf}', ""); +Expect(0, 1706, '\p{^Jg=swashkaf}', ""); +Expect(0, 1706, '\P{Jg=swashkaf}', ""); +Expect(1, 1706, '\P{^Jg=swashkaf}', ""); +Expect(0, 1705, '\p{Jg=swashkaf}', ""); +Expect(1, 1705, '\p{^Jg=swashkaf}', ""); +Expect(1, 1705, '\P{Jg=swashkaf}', ""); +Expect(0, 1705, '\P{^Jg=swashkaf}', ""); +Expect(1, 1706, '\p{Jg=_ SWASH kaf}', ""); +Expect(0, 1706, '\p{^Jg=_ SWASH kaf}', ""); +Expect(0, 1706, '\P{Jg=_ SWASH kaf}', ""); +Expect(1, 1706, '\P{^Jg=_ SWASH kaf}', ""); +Expect(0, 1705, '\p{Jg=_ SWASH kaf}', ""); +Expect(1, 1705, '\p{^Jg=_ SWASH kaf}', ""); +Expect(1, 1705, '\P{Jg=_ SWASH kaf}', ""); +Expect(0, 1705, '\P{^Jg=_ SWASH kaf}', ""); +Error('\p{Is_Joining_Group=/a/ Swash KAF}'); +Error('\P{Is_Joining_Group=/a/ Swash KAF}'); +Expect(1, 1706, '\p{Is_Joining_Group=swashkaf}', ""); +Expect(0, 1706, '\p{^Is_Joining_Group=swashkaf}', ""); +Expect(0, 1706, '\P{Is_Joining_Group=swashkaf}', ""); +Expect(1, 1706, '\P{^Is_Joining_Group=swashkaf}', ""); +Expect(0, 1705, '\p{Is_Joining_Group=swashkaf}', ""); +Expect(1, 1705, '\p{^Is_Joining_Group=swashkaf}', ""); +Expect(1, 1705, '\P{Is_Joining_Group=swashkaf}', ""); +Expect(0, 1705, '\P{^Is_Joining_Group=swashkaf}', ""); +Expect(1, 1706, '\p{Is_Joining_Group= Swash Kaf}', ""); +Expect(0, 1706, '\p{^Is_Joining_Group= Swash Kaf}', ""); +Expect(0, 1706, '\P{Is_Joining_Group= Swash Kaf}', ""); +Expect(1, 1706, '\P{^Is_Joining_Group= Swash Kaf}', ""); +Expect(0, 1705, '\p{Is_Joining_Group= Swash Kaf}', ""); +Expect(1, 1705, '\p{^Is_Joining_Group= Swash Kaf}', ""); +Expect(1, 1705, '\P{Is_Joining_Group= Swash Kaf}', ""); +Expect(0, 1705, '\P{^Is_Joining_Group= Swash Kaf}', ""); +Error('\p{Is_Jg: := swash_KAF}'); +Error('\P{Is_Jg: := swash_KAF}'); +Expect(1, 1706, '\p{Is_Jg=swashkaf}', ""); +Expect(0, 1706, '\p{^Is_Jg=swashkaf}', ""); +Expect(0, 1706, '\P{Is_Jg=swashkaf}', ""); +Expect(1, 1706, '\P{^Is_Jg=swashkaf}', ""); +Expect(0, 1705, '\p{Is_Jg=swashkaf}', ""); +Expect(1, 1705, '\p{^Is_Jg=swashkaf}', ""); +Expect(1, 1705, '\P{Is_Jg=swashkaf}', ""); +Expect(0, 1705, '\P{^Is_Jg=swashkaf}', ""); +Expect(1, 1706, '\p{Is_Jg: __swash Kaf}', ""); +Expect(0, 1706, '\p{^Is_Jg: __swash Kaf}', ""); +Expect(0, 1706, '\P{Is_Jg: __swash Kaf}', ""); +Expect(1, 1706, '\P{^Is_Jg: __swash Kaf}', ""); +Expect(0, 1705, '\p{Is_Jg: __swash Kaf}', ""); +Expect(1, 1705, '\p{^Is_Jg: __swash Kaf}', ""); +Expect(1, 1705, '\P{Is_Jg: __swash Kaf}', ""); +Expect(0, 1705, '\P{^Is_Jg: __swash Kaf}', ""); +Error('\p{Joining_Group= -SEEN:=}'); +Error('\P{Joining_Group= -SEEN:=}'); +Expect(1, 1588, '\p{Joining_Group=seen}', ""); +Expect(0, 1588, '\p{^Joining_Group=seen}', ""); +Expect(0, 1588, '\P{Joining_Group=seen}', ""); +Expect(1, 1588, '\P{^Joining_Group=seen}', ""); +Expect(0, 1586, '\p{Joining_Group=seen}', ""); +Expect(1, 1586, '\p{^Joining_Group=seen}', ""); +Expect(1, 1586, '\P{Joining_Group=seen}', ""); +Expect(0, 1586, '\P{^Joining_Group=seen}', ""); +Expect(1, 1588, '\p{Joining_Group= Seen}', ""); +Expect(0, 1588, '\p{^Joining_Group= Seen}', ""); +Expect(0, 1588, '\P{Joining_Group= Seen}', ""); +Expect(1, 1588, '\P{^Joining_Group= Seen}', ""); +Expect(0, 1586, '\p{Joining_Group= Seen}', ""); +Expect(1, 1586, '\p{^Joining_Group= Seen}', ""); +Expect(1, 1586, '\P{Joining_Group= Seen}', ""); +Expect(0, 1586, '\P{^Joining_Group= Seen}', ""); +Error('\p{Jg= :=Seen}'); +Error('\P{Jg= :=Seen}'); +Expect(1, 1588, '\p{Jg=seen}', ""); +Expect(0, 1588, '\p{^Jg=seen}', ""); +Expect(0, 1588, '\P{Jg=seen}', ""); +Expect(1, 1588, '\P{^Jg=seen}', ""); +Expect(0, 1586, '\p{Jg=seen}', ""); +Expect(1, 1586, '\p{^Jg=seen}', ""); +Expect(1, 1586, '\P{Jg=seen}', ""); +Expect(0, 1586, '\P{^Jg=seen}', ""); +Expect(1, 1588, '\p{Jg= _Seen}', ""); +Expect(0, 1588, '\p{^Jg= _Seen}', ""); +Expect(0, 1588, '\P{Jg= _Seen}', ""); +Expect(1, 1588, '\P{^Jg= _Seen}', ""); +Expect(0, 1586, '\p{Jg= _Seen}', ""); +Expect(1, 1586, '\p{^Jg= _Seen}', ""); +Expect(1, 1586, '\P{Jg= _Seen}', ""); +Expect(0, 1586, '\P{^Jg= _Seen}', ""); +Error('\p{Is_Joining_Group: /a/_ Seen}'); +Error('\P{Is_Joining_Group: /a/_ Seen}'); +Expect(1, 1588, '\p{Is_Joining_Group=seen}', ""); +Expect(0, 1588, '\p{^Is_Joining_Group=seen}', ""); +Expect(0, 1588, '\P{Is_Joining_Group=seen}', ""); +Expect(1, 1588, '\P{^Is_Joining_Group=seen}', ""); +Expect(0, 1586, '\p{Is_Joining_Group=seen}', ""); +Expect(1, 1586, '\p{^Is_Joining_Group=seen}', ""); +Expect(1, 1586, '\P{Is_Joining_Group=seen}', ""); +Expect(0, 1586, '\P{^Is_Joining_Group=seen}', ""); +Expect(1, 1588, '\p{Is_Joining_Group= -seen}', ""); +Expect(0, 1588, '\p{^Is_Joining_Group= -seen}', ""); +Expect(0, 1588, '\P{Is_Joining_Group= -seen}', ""); +Expect(1, 1588, '\P{^Is_Joining_Group= -seen}', ""); +Expect(0, 1586, '\p{Is_Joining_Group= -seen}', ""); +Expect(1, 1586, '\p{^Is_Joining_Group= -seen}', ""); +Expect(1, 1586, '\P{Is_Joining_Group= -seen}', ""); +Expect(0, 1586, '\P{^Is_Joining_Group= -seen}', ""); +Error('\p{Is_Jg: /a/Seen}'); +Error('\P{Is_Jg: /a/Seen}'); +Expect(1, 1588, '\p{Is_Jg=seen}', ""); +Expect(0, 1588, '\p{^Is_Jg=seen}', ""); +Expect(0, 1588, '\P{Is_Jg=seen}', ""); +Expect(1, 1588, '\P{^Is_Jg=seen}', ""); +Expect(0, 1586, '\p{Is_Jg=seen}', ""); +Expect(1, 1586, '\p{^Is_Jg=seen}', ""); +Expect(1, 1586, '\P{Is_Jg=seen}', ""); +Expect(0, 1586, '\P{^Is_Jg=seen}', ""); +Expect(1, 1588, '\p{Is_Jg= Seen}', ""); +Expect(0, 1588, '\p{^Is_Jg= Seen}', ""); +Expect(0, 1588, '\P{Is_Jg= Seen}', ""); +Expect(1, 1588, '\P{^Is_Jg= Seen}', ""); +Expect(0, 1586, '\p{Is_Jg= Seen}', ""); +Expect(1, 1586, '\p{^Is_Jg= Seen}', ""); +Expect(1, 1586, '\P{Is_Jg= Seen}', ""); +Expect(0, 1586, '\P{^Is_Jg= Seen}', ""); +Error('\p{Joining_Group= /a/Beth}'); +Error('\P{Joining_Group= /a/Beth}'); +Expect(1, 1810, '\p{Joining_Group=beth}', ""); +Expect(0, 1810, '\p{^Joining_Group=beth}', ""); +Expect(0, 1810, '\P{Joining_Group=beth}', ""); +Expect(1, 1810, '\P{^Joining_Group=beth}', ""); +Expect(0, 1809, '\p{Joining_Group=beth}', ""); +Expect(1, 1809, '\p{^Joining_Group=beth}', ""); +Expect(1, 1809, '\P{Joining_Group=beth}', ""); +Expect(0, 1809, '\P{^Joining_Group=beth}', ""); +Expect(1, 1810, '\p{Joining_Group= _Beth}', ""); +Expect(0, 1810, '\p{^Joining_Group= _Beth}', ""); +Expect(0, 1810, '\P{Joining_Group= _Beth}', ""); +Expect(1, 1810, '\P{^Joining_Group= _Beth}', ""); +Expect(0, 1809, '\p{Joining_Group= _Beth}', ""); +Expect(1, 1809, '\p{^Joining_Group= _Beth}', ""); +Expect(1, 1809, '\P{Joining_Group= _Beth}', ""); +Expect(0, 1809, '\P{^Joining_Group= _Beth}', ""); +Error('\p{Jg: /a/ beth}'); +Error('\P{Jg: /a/ beth}'); +Expect(1, 1810, '\p{Jg=beth}', ""); +Expect(0, 1810, '\p{^Jg=beth}', ""); +Expect(0, 1810, '\P{Jg=beth}', ""); +Expect(1, 1810, '\P{^Jg=beth}', ""); +Expect(0, 1809, '\p{Jg=beth}', ""); +Expect(1, 1809, '\p{^Jg=beth}', ""); +Expect(1, 1809, '\P{Jg=beth}', ""); +Expect(0, 1809, '\P{^Jg=beth}', ""); +Expect(1, 1810, '\p{Jg=-Beth}', ""); +Expect(0, 1810, '\p{^Jg=-Beth}', ""); +Expect(0, 1810, '\P{Jg=-Beth}', ""); +Expect(1, 1810, '\P{^Jg=-Beth}', ""); +Expect(0, 1809, '\p{Jg=-Beth}', ""); +Expect(1, 1809, '\p{^Jg=-Beth}', ""); +Expect(1, 1809, '\P{Jg=-Beth}', ""); +Expect(0, 1809, '\P{^Jg=-Beth}', ""); +Error('\p{Is_Joining_Group=_/a/beth}'); +Error('\P{Is_Joining_Group=_/a/beth}'); +Expect(1, 1810, '\p{Is_Joining_Group=beth}', ""); +Expect(0, 1810, '\p{^Is_Joining_Group=beth}', ""); +Expect(0, 1810, '\P{Is_Joining_Group=beth}', ""); +Expect(1, 1810, '\P{^Is_Joining_Group=beth}', ""); +Expect(0, 1809, '\p{Is_Joining_Group=beth}', ""); +Expect(1, 1809, '\p{^Is_Joining_Group=beth}', ""); +Expect(1, 1809, '\P{Is_Joining_Group=beth}', ""); +Expect(0, 1809, '\P{^Is_Joining_Group=beth}', ""); +Expect(1, 1810, '\p{Is_Joining_Group=- Beth}', ""); +Expect(0, 1810, '\p{^Is_Joining_Group=- Beth}', ""); +Expect(0, 1810, '\P{Is_Joining_Group=- Beth}', ""); +Expect(1, 1810, '\P{^Is_Joining_Group=- Beth}', ""); +Expect(0, 1809, '\p{Is_Joining_Group=- Beth}', ""); +Expect(1, 1809, '\p{^Is_Joining_Group=- Beth}', ""); +Expect(1, 1809, '\P{Is_Joining_Group=- Beth}', ""); +Expect(0, 1809, '\P{^Is_Joining_Group=- Beth}', ""); +Error('\p{Is_Jg=-beth:=}'); +Error('\P{Is_Jg=-beth:=}'); +Expect(1, 1810, '\p{Is_Jg=beth}', ""); +Expect(0, 1810, '\p{^Is_Jg=beth}', ""); +Expect(0, 1810, '\P{Is_Jg=beth}', ""); +Expect(1, 1810, '\P{^Is_Jg=beth}', ""); +Expect(0, 1809, '\p{Is_Jg=beth}', ""); +Expect(1, 1809, '\p{^Is_Jg=beth}', ""); +Expect(1, 1809, '\P{Is_Jg=beth}', ""); +Expect(0, 1809, '\P{^Is_Jg=beth}', ""); +Expect(1, 1810, '\p{Is_Jg: - BETH}', ""); +Expect(0, 1810, '\p{^Is_Jg: - BETH}', ""); +Expect(0, 1810, '\P{Is_Jg: - BETH}', ""); +Expect(1, 1810, '\P{^Is_Jg: - BETH}', ""); +Expect(0, 1809, '\p{Is_Jg: - BETH}', ""); +Expect(1, 1809, '\p{^Is_Jg: - BETH}', ""); +Expect(1, 1809, '\P{Is_Jg: - BETH}', ""); +Expect(0, 1809, '\P{^Is_Jg: - BETH}', ""); +Error('\p{Joining_Group= _SEMKATH/a/}'); +Error('\P{Joining_Group= _SEMKATH/a/}'); +Expect(1, 1827, '\p{Joining_Group=semkath}', ""); +Expect(0, 1827, '\p{^Joining_Group=semkath}', ""); +Expect(0, 1827, '\P{Joining_Group=semkath}', ""); +Expect(1, 1827, '\P{^Joining_Group=semkath}', ""); +Expect(0, 1826, '\p{Joining_Group=semkath}', ""); +Expect(1, 1826, '\p{^Joining_Group=semkath}', ""); +Expect(1, 1826, '\P{Joining_Group=semkath}', ""); +Expect(0, 1826, '\P{^Joining_Group=semkath}', ""); +Expect(1, 1827, '\p{Joining_Group=-_semkath}', ""); +Expect(0, 1827, '\p{^Joining_Group=-_semkath}', ""); +Expect(0, 1827, '\P{Joining_Group=-_semkath}', ""); +Expect(1, 1827, '\P{^Joining_Group=-_semkath}', ""); +Expect(0, 1826, '\p{Joining_Group=-_semkath}', ""); +Expect(1, 1826, '\p{^Joining_Group=-_semkath}', ""); +Expect(1, 1826, '\P{Joining_Group=-_semkath}', ""); +Expect(0, 1826, '\P{^Joining_Group=-_semkath}', ""); +Error('\p{Jg=- Semkath/a/}'); +Error('\P{Jg=- Semkath/a/}'); +Expect(1, 1827, '\p{Jg=semkath}', ""); +Expect(0, 1827, '\p{^Jg=semkath}', ""); +Expect(0, 1827, '\P{Jg=semkath}', ""); +Expect(1, 1827, '\P{^Jg=semkath}', ""); +Expect(0, 1826, '\p{Jg=semkath}', ""); +Expect(1, 1826, '\p{^Jg=semkath}', ""); +Expect(1, 1826, '\P{Jg=semkath}', ""); +Expect(0, 1826, '\P{^Jg=semkath}', ""); +Expect(1, 1827, '\p{Jg= Semkath}', ""); +Expect(0, 1827, '\p{^Jg= Semkath}', ""); +Expect(0, 1827, '\P{Jg= Semkath}', ""); +Expect(1, 1827, '\P{^Jg= Semkath}', ""); +Expect(0, 1826, '\p{Jg= Semkath}', ""); +Expect(1, 1826, '\p{^Jg= Semkath}', ""); +Expect(1, 1826, '\P{Jg= Semkath}', ""); +Expect(0, 1826, '\P{^Jg= Semkath}', ""); +Error('\p{Is_Joining_Group= /a/Semkath}'); +Error('\P{Is_Joining_Group= /a/Semkath}'); +Expect(1, 1827, '\p{Is_Joining_Group: semkath}', ""); +Expect(0, 1827, '\p{^Is_Joining_Group: semkath}', ""); +Expect(0, 1827, '\P{Is_Joining_Group: semkath}', ""); +Expect(1, 1827, '\P{^Is_Joining_Group: semkath}', ""); +Expect(0, 1826, '\p{Is_Joining_Group: semkath}', ""); +Expect(1, 1826, '\p{^Is_Joining_Group: semkath}', ""); +Expect(1, 1826, '\P{Is_Joining_Group: semkath}', ""); +Expect(0, 1826, '\P{^Is_Joining_Group: semkath}', ""); +Expect(1, 1827, '\p{Is_Joining_Group=_SEMKATH}', ""); +Expect(0, 1827, '\p{^Is_Joining_Group=_SEMKATH}', ""); +Expect(0, 1827, '\P{Is_Joining_Group=_SEMKATH}', ""); +Expect(1, 1827, '\P{^Is_Joining_Group=_SEMKATH}', ""); +Expect(0, 1826, '\p{Is_Joining_Group=_SEMKATH}', ""); +Expect(1, 1826, '\p{^Is_Joining_Group=_SEMKATH}', ""); +Expect(1, 1826, '\P{Is_Joining_Group=_SEMKATH}', ""); +Expect(0, 1826, '\P{^Is_Joining_Group=_SEMKATH}', ""); +Error('\p{Is_Jg=/a/_Semkath}'); +Error('\P{Is_Jg=/a/_Semkath}'); +Expect(1, 1827, '\p{Is_Jg=semkath}', ""); +Expect(0, 1827, '\p{^Is_Jg=semkath}', ""); +Expect(0, 1827, '\P{Is_Jg=semkath}', ""); +Expect(1, 1827, '\P{^Is_Jg=semkath}', ""); +Expect(0, 1826, '\p{Is_Jg=semkath}', ""); +Expect(1, 1826, '\p{^Is_Jg=semkath}', ""); +Expect(1, 1826, '\P{Is_Jg=semkath}', ""); +Expect(0, 1826, '\P{^Is_Jg=semkath}', ""); +Expect(1, 1827, '\p{Is_Jg=_ Semkath}', ""); +Expect(0, 1827, '\p{^Is_Jg=_ Semkath}', ""); +Expect(0, 1827, '\P{Is_Jg=_ Semkath}', ""); +Expect(1, 1827, '\P{^Is_Jg=_ Semkath}', ""); +Expect(0, 1826, '\p{Is_Jg=_ Semkath}', ""); +Expect(1, 1826, '\p{^Is_Jg=_ Semkath}', ""); +Expect(1, 1826, '\P{Is_Jg=_ Semkath}', ""); +Expect(0, 1826, '\P{^Is_Jg=_ Semkath}', ""); +Error('\p{Joining_Group= /a/hah}'); +Error('\P{Joining_Group= /a/hah}'); +Expect(1, 1582, '\p{Joining_Group=hah}', ""); +Expect(0, 1582, '\p{^Joining_Group=hah}', ""); +Expect(0, 1582, '\P{Joining_Group=hah}', ""); +Expect(1, 1582, '\P{^Joining_Group=hah}', ""); +Expect(0, 1579, '\p{Joining_Group=hah}', ""); +Expect(1, 1579, '\p{^Joining_Group=hah}', ""); +Expect(1, 1579, '\P{Joining_Group=hah}', ""); +Expect(0, 1579, '\P{^Joining_Group=hah}', ""); +Expect(1, 1582, '\p{Joining_Group= Hah}', ""); +Expect(0, 1582, '\p{^Joining_Group= Hah}', ""); +Expect(0, 1582, '\P{Joining_Group= Hah}', ""); +Expect(1, 1582, '\P{^Joining_Group= Hah}', ""); +Expect(0, 1579, '\p{Joining_Group= Hah}', ""); +Expect(1, 1579, '\p{^Joining_Group= Hah}', ""); +Expect(1, 1579, '\P{Joining_Group= Hah}', ""); +Expect(0, 1579, '\P{^Joining_Group= Hah}', ""); +Error('\p{Jg=:=HAH}'); +Error('\P{Jg=:=HAH}'); +Expect(1, 1582, '\p{Jg=hah}', ""); +Expect(0, 1582, '\p{^Jg=hah}', ""); +Expect(0, 1582, '\P{Jg=hah}', ""); +Expect(1, 1582, '\P{^Jg=hah}', ""); +Expect(0, 1579, '\p{Jg=hah}', ""); +Expect(1, 1579, '\p{^Jg=hah}', ""); +Expect(1, 1579, '\P{Jg=hah}', ""); +Expect(0, 1579, '\P{^Jg=hah}', ""); +Expect(1, 1582, '\p{Jg=Hah}', ""); +Expect(0, 1582, '\p{^Jg=Hah}', ""); +Expect(0, 1582, '\P{Jg=Hah}', ""); +Expect(1, 1582, '\P{^Jg=Hah}', ""); +Expect(0, 1579, '\p{Jg=Hah}', ""); +Expect(1, 1579, '\p{^Jg=Hah}', ""); +Expect(1, 1579, '\P{Jg=Hah}', ""); +Expect(0, 1579, '\P{^Jg=Hah}', ""); +Error('\p{Is_Joining_Group: _hah/a/}'); +Error('\P{Is_Joining_Group: _hah/a/}'); +Expect(1, 1582, '\p{Is_Joining_Group: hah}', ""); +Expect(0, 1582, '\p{^Is_Joining_Group: hah}', ""); +Expect(0, 1582, '\P{Is_Joining_Group: hah}', ""); +Expect(1, 1582, '\P{^Is_Joining_Group: hah}', ""); +Expect(0, 1579, '\p{Is_Joining_Group: hah}', ""); +Expect(1, 1579, '\p{^Is_Joining_Group: hah}', ""); +Expect(1, 1579, '\P{Is_Joining_Group: hah}', ""); +Expect(0, 1579, '\P{^Is_Joining_Group: hah}', ""); +Expect(1, 1582, '\p{Is_Joining_Group=-_hah}', ""); +Expect(0, 1582, '\p{^Is_Joining_Group=-_hah}', ""); +Expect(0, 1582, '\P{Is_Joining_Group=-_hah}', ""); +Expect(1, 1582, '\P{^Is_Joining_Group=-_hah}', ""); +Expect(0, 1579, '\p{Is_Joining_Group=-_hah}', ""); +Expect(1, 1579, '\p{^Is_Joining_Group=-_hah}', ""); +Expect(1, 1579, '\P{Is_Joining_Group=-_hah}', ""); +Expect(0, 1579, '\P{^Is_Joining_Group=-_hah}', ""); +Error('\p{Is_Jg=- Hah:=}'); +Error('\P{Is_Jg=- Hah:=}'); +Expect(1, 1582, '\p{Is_Jg:hah}', ""); +Expect(0, 1582, '\p{^Is_Jg:hah}', ""); +Expect(0, 1582, '\P{Is_Jg:hah}', ""); +Expect(1, 1582, '\P{^Is_Jg:hah}', ""); +Expect(0, 1579, '\p{Is_Jg:hah}', ""); +Expect(1, 1579, '\p{^Is_Jg:hah}', ""); +Expect(1, 1579, '\P{Is_Jg:hah}', ""); +Expect(0, 1579, '\P{^Is_Jg:hah}', ""); +Expect(1, 1582, '\p{Is_Jg= _hah}', ""); +Expect(0, 1582, '\p{^Is_Jg= _hah}', ""); +Expect(0, 1582, '\P{Is_Jg= _hah}', ""); +Expect(1, 1582, '\P{^Is_Jg= _hah}', ""); +Expect(0, 1579, '\p{Is_Jg= _hah}', ""); +Expect(1, 1579, '\p{^Is_Jg= _hah}', ""); +Expect(1, 1579, '\P{Is_Jg= _hah}', ""); +Expect(0, 1579, '\P{^Is_Jg= _hah}', ""); +Error('\p{Joining_Group=:= _SYRIACWaw}'); +Error('\P{Joining_Group=:= _SYRIACWaw}'); +Expect(1, 1816, '\p{Joining_Group=syriacwaw}', ""); +Expect(0, 1816, '\p{^Joining_Group=syriacwaw}', ""); +Expect(0, 1816, '\P{Joining_Group=syriacwaw}', ""); +Expect(1, 1816, '\P{^Joining_Group=syriacwaw}', ""); +Expect(0, 1815, '\p{Joining_Group=syriacwaw}', ""); +Expect(1, 1815, '\p{^Joining_Group=syriacwaw}', ""); +Expect(1, 1815, '\P{Joining_Group=syriacwaw}', ""); +Expect(0, 1815, '\P{^Joining_Group=syriacwaw}', ""); +Expect(1, 1816, '\p{Joining_Group= Syriac-Waw}', ""); +Expect(0, 1816, '\p{^Joining_Group= Syriac-Waw}', ""); +Expect(0, 1816, '\P{Joining_Group= Syriac-Waw}', ""); +Expect(1, 1816, '\P{^Joining_Group= Syriac-Waw}', ""); +Expect(0, 1815, '\p{Joining_Group= Syriac-Waw}', ""); +Expect(1, 1815, '\p{^Joining_Group= Syriac-Waw}', ""); +Expect(1, 1815, '\P{Joining_Group= Syriac-Waw}', ""); +Expect(0, 1815, '\P{^Joining_Group= Syriac-Waw}', ""); +Error('\p{Jg: /a/SYRIAC Waw}'); +Error('\P{Jg: /a/SYRIAC Waw}'); +Expect(1, 1816, '\p{Jg=syriacwaw}', ""); +Expect(0, 1816, '\p{^Jg=syriacwaw}', ""); +Expect(0, 1816, '\P{Jg=syriacwaw}', ""); +Expect(1, 1816, '\P{^Jg=syriacwaw}', ""); +Expect(0, 1815, '\p{Jg=syriacwaw}', ""); +Expect(1, 1815, '\p{^Jg=syriacwaw}', ""); +Expect(1, 1815, '\P{Jg=syriacwaw}', ""); +Expect(0, 1815, '\P{^Jg=syriacwaw}', ""); +Expect(1, 1816, '\p{Jg=_ SYRIACwaw}', ""); +Expect(0, 1816, '\p{^Jg=_ SYRIACwaw}', ""); +Expect(0, 1816, '\P{Jg=_ SYRIACwaw}', ""); +Expect(1, 1816, '\P{^Jg=_ SYRIACwaw}', ""); +Expect(0, 1815, '\p{Jg=_ SYRIACwaw}', ""); +Expect(1, 1815, '\p{^Jg=_ SYRIACwaw}', ""); +Expect(1, 1815, '\P{Jg=_ SYRIACwaw}', ""); +Expect(0, 1815, '\P{^Jg=_ SYRIACwaw}', ""); +Error('\p{Is_Joining_Group= :=Syriac waw}'); +Error('\P{Is_Joining_Group= :=Syriac waw}'); +Expect(1, 1816, '\p{Is_Joining_Group=syriacwaw}', ""); +Expect(0, 1816, '\p{^Is_Joining_Group=syriacwaw}', ""); +Expect(0, 1816, '\P{Is_Joining_Group=syriacwaw}', ""); +Expect(1, 1816, '\P{^Is_Joining_Group=syriacwaw}', ""); +Expect(0, 1815, '\p{Is_Joining_Group=syriacwaw}', ""); +Expect(1, 1815, '\p{^Is_Joining_Group=syriacwaw}', ""); +Expect(1, 1815, '\P{Is_Joining_Group=syriacwaw}', ""); +Expect(0, 1815, '\P{^Is_Joining_Group=syriacwaw}', ""); +Expect(1, 1816, '\p{Is_Joining_Group=-Syriac_Waw}', ""); +Expect(0, 1816, '\p{^Is_Joining_Group=-Syriac_Waw}', ""); +Expect(0, 1816, '\P{Is_Joining_Group=-Syriac_Waw}', ""); +Expect(1, 1816, '\P{^Is_Joining_Group=-Syriac_Waw}', ""); +Expect(0, 1815, '\p{Is_Joining_Group=-Syriac_Waw}', ""); +Expect(1, 1815, '\p{^Is_Joining_Group=-Syriac_Waw}', ""); +Expect(1, 1815, '\P{Is_Joining_Group=-Syriac_Waw}', ""); +Expect(0, 1815, '\P{^Is_Joining_Group=-Syriac_Waw}', ""); +Error('\p{Is_Jg: _SyriacWAW/a/}'); +Error('\P{Is_Jg: _SyriacWAW/a/}'); +Expect(1, 1816, '\p{Is_Jg=syriacwaw}', ""); +Expect(0, 1816, '\p{^Is_Jg=syriacwaw}', ""); +Expect(0, 1816, '\P{Is_Jg=syriacwaw}', ""); +Expect(1, 1816, '\P{^Is_Jg=syriacwaw}', ""); +Expect(0, 1815, '\p{Is_Jg=syriacwaw}', ""); +Expect(1, 1815, '\p{^Is_Jg=syriacwaw}', ""); +Expect(1, 1815, '\P{Is_Jg=syriacwaw}', ""); +Expect(0, 1815, '\P{^Is_Jg=syriacwaw}', ""); +Expect(1, 1816, '\p{Is_Jg=__Syriac waw}', ""); +Expect(0, 1816, '\p{^Is_Jg=__Syriac waw}', ""); +Expect(0, 1816, '\P{Is_Jg=__Syriac waw}', ""); +Expect(1, 1816, '\P{^Is_Jg=__Syriac waw}', ""); +Expect(0, 1815, '\p{Is_Jg=__Syriac waw}', ""); +Expect(1, 1815, '\p{^Is_Jg=__Syriac waw}', ""); +Expect(1, 1815, '\P{Is_Jg=__Syriac waw}', ""); +Expect(0, 1815, '\P{^Is_Jg=__Syriac waw}', ""); +Error('\p{Joining_Group=/a/-Taw}'); +Error('\P{Joining_Group=/a/-Taw}'); +Expect(1, 1836, '\p{Joining_Group=taw}', ""); +Expect(0, 1836, '\p{^Joining_Group=taw}', ""); +Expect(0, 1836, '\P{Joining_Group=taw}', ""); +Expect(1, 1836, '\P{^Joining_Group=taw}', ""); +Expect(0, 1835, '\p{Joining_Group=taw}', ""); +Expect(1, 1835, '\p{^Joining_Group=taw}', ""); +Expect(1, 1835, '\P{Joining_Group=taw}', ""); +Expect(0, 1835, '\P{^Joining_Group=taw}', ""); +Expect(1, 1836, '\p{Joining_Group=_ taw}', ""); +Expect(0, 1836, '\p{^Joining_Group=_ taw}', ""); +Expect(0, 1836, '\P{Joining_Group=_ taw}', ""); +Expect(1, 1836, '\P{^Joining_Group=_ taw}', ""); +Expect(0, 1835, '\p{Joining_Group=_ taw}', ""); +Expect(1, 1835, '\p{^Joining_Group=_ taw}', ""); +Expect(1, 1835, '\P{Joining_Group=_ taw}', ""); +Expect(0, 1835, '\P{^Joining_Group=_ taw}', ""); +Error('\p{Jg=:= taw}'); +Error('\P{Jg=:= taw}'); +Expect(1, 1836, '\p{Jg=taw}', ""); +Expect(0, 1836, '\p{^Jg=taw}', ""); +Expect(0, 1836, '\P{Jg=taw}', ""); +Expect(1, 1836, '\P{^Jg=taw}', ""); +Expect(0, 1835, '\p{Jg=taw}', ""); +Expect(1, 1835, '\p{^Jg=taw}', ""); +Expect(1, 1835, '\P{Jg=taw}', ""); +Expect(0, 1835, '\P{^Jg=taw}', ""); +Expect(1, 1836, '\p{Jg=Taw}', ""); +Expect(0, 1836, '\p{^Jg=Taw}', ""); +Expect(0, 1836, '\P{Jg=Taw}', ""); +Expect(1, 1836, '\P{^Jg=Taw}', ""); +Expect(0, 1835, '\p{Jg=Taw}', ""); +Expect(1, 1835, '\p{^Jg=Taw}', ""); +Expect(1, 1835, '\P{Jg=Taw}', ""); +Expect(0, 1835, '\P{^Jg=Taw}', ""); +Error('\p{Is_Joining_Group: _ Taw:=}'); +Error('\P{Is_Joining_Group: _ Taw:=}'); +Expect(1, 1836, '\p{Is_Joining_Group=taw}', ""); +Expect(0, 1836, '\p{^Is_Joining_Group=taw}', ""); +Expect(0, 1836, '\P{Is_Joining_Group=taw}', ""); +Expect(1, 1836, '\P{^Is_Joining_Group=taw}', ""); +Expect(0, 1835, '\p{Is_Joining_Group=taw}', ""); +Expect(1, 1835, '\p{^Is_Joining_Group=taw}', ""); +Expect(1, 1835, '\P{Is_Joining_Group=taw}', ""); +Expect(0, 1835, '\P{^Is_Joining_Group=taw}', ""); +Expect(1, 1836, '\p{Is_Joining_Group=_TAW}', ""); +Expect(0, 1836, '\p{^Is_Joining_Group=_TAW}', ""); +Expect(0, 1836, '\P{Is_Joining_Group=_TAW}', ""); +Expect(1, 1836, '\P{^Is_Joining_Group=_TAW}', ""); +Expect(0, 1835, '\p{Is_Joining_Group=_TAW}', ""); +Expect(1, 1835, '\p{^Is_Joining_Group=_TAW}', ""); +Expect(1, 1835, '\P{Is_Joining_Group=_TAW}', ""); +Expect(0, 1835, '\P{^Is_Joining_Group=_TAW}', ""); +Error('\p{Is_Jg=-/a/Taw}'); +Error('\P{Is_Jg=-/a/Taw}'); +Expect(1, 1836, '\p{Is_Jg=taw}', ""); +Expect(0, 1836, '\p{^Is_Jg=taw}', ""); +Expect(0, 1836, '\P{Is_Jg=taw}', ""); +Expect(1, 1836, '\P{^Is_Jg=taw}', ""); +Expect(0, 1835, '\p{Is_Jg=taw}', ""); +Expect(1, 1835, '\p{^Is_Jg=taw}', ""); +Expect(1, 1835, '\P{Is_Jg=taw}', ""); +Expect(0, 1835, '\P{^Is_Jg=taw}', ""); +Expect(1, 1836, '\p{Is_Jg: Taw}', ""); +Expect(0, 1836, '\p{^Is_Jg: Taw}', ""); +Expect(0, 1836, '\P{Is_Jg: Taw}', ""); +Expect(1, 1836, '\P{^Is_Jg: Taw}', ""); +Expect(0, 1835, '\p{Is_Jg: Taw}', ""); +Expect(1, 1835, '\p{^Is_Jg: Taw}', ""); +Expect(1, 1835, '\P{Is_Jg: Taw}', ""); +Expect(0, 1835, '\P{^Is_Jg: Taw}', ""); +Error('\p{Joining_Group=/a/_FinalSemkath}'); +Error('\P{Joining_Group=/a/_FinalSemkath}'); +Expect(1, 1828, '\p{Joining_Group=finalsemkath}', ""); +Expect(0, 1828, '\p{^Joining_Group=finalsemkath}', ""); +Expect(0, 1828, '\P{Joining_Group=finalsemkath}', ""); +Expect(1, 1828, '\P{^Joining_Group=finalsemkath}', ""); +Expect(0, 1827, '\p{Joining_Group=finalsemkath}', ""); +Expect(1, 1827, '\p{^Joining_Group=finalsemkath}', ""); +Expect(1, 1827, '\P{Joining_Group=finalsemkath}', ""); +Expect(0, 1827, '\P{^Joining_Group=finalsemkath}', ""); +Expect(1, 1828, '\p{Joining_Group= Final Semkath}', ""); +Expect(0, 1828, '\p{^Joining_Group= Final Semkath}', ""); +Expect(0, 1828, '\P{Joining_Group= Final Semkath}', ""); +Expect(1, 1828, '\P{^Joining_Group= Final Semkath}', ""); +Expect(0, 1827, '\p{Joining_Group= Final Semkath}', ""); +Expect(1, 1827, '\p{^Joining_Group= Final Semkath}', ""); +Expect(1, 1827, '\P{Joining_Group= Final Semkath}', ""); +Expect(0, 1827, '\P{^Joining_Group= Final Semkath}', ""); +Error('\p{Jg= FinalSemkath/a/}'); +Error('\P{Jg= FinalSemkath/a/}'); +Expect(1, 1828, '\p{Jg=finalsemkath}', ""); +Expect(0, 1828, '\p{^Jg=finalsemkath}', ""); +Expect(0, 1828, '\P{Jg=finalsemkath}', ""); +Expect(1, 1828, '\P{^Jg=finalsemkath}', ""); +Expect(0, 1827, '\p{Jg=finalsemkath}', ""); +Expect(1, 1827, '\p{^Jg=finalsemkath}', ""); +Expect(1, 1827, '\P{Jg=finalsemkath}', ""); +Expect(0, 1827, '\P{^Jg=finalsemkath}', ""); +Expect(1, 1828, '\p{Jg=-final Semkath}', ""); +Expect(0, 1828, '\p{^Jg=-final Semkath}', ""); +Expect(0, 1828, '\P{Jg=-final Semkath}', ""); +Expect(1, 1828, '\P{^Jg=-final Semkath}', ""); +Expect(0, 1827, '\p{Jg=-final Semkath}', ""); +Expect(1, 1827, '\p{^Jg=-final Semkath}', ""); +Expect(1, 1827, '\P{Jg=-final Semkath}', ""); +Expect(0, 1827, '\P{^Jg=-final Semkath}', ""); +Error('\p{Is_Joining_Group=:=_ Final Semkath}'); +Error('\P{Is_Joining_Group=:=_ Final Semkath}'); +Expect(1, 1828, '\p{Is_Joining_Group=finalsemkath}', ""); +Expect(0, 1828, '\p{^Is_Joining_Group=finalsemkath}', ""); +Expect(0, 1828, '\P{Is_Joining_Group=finalsemkath}', ""); +Expect(1, 1828, '\P{^Is_Joining_Group=finalsemkath}', ""); +Expect(0, 1827, '\p{Is_Joining_Group=finalsemkath}', ""); +Expect(1, 1827, '\p{^Is_Joining_Group=finalsemkath}', ""); +Expect(1, 1827, '\P{Is_Joining_Group=finalsemkath}', ""); +Expect(0, 1827, '\P{^Is_Joining_Group=finalsemkath}', ""); +Expect(1, 1828, '\p{Is_Joining_Group: --Final_Semkath}', ""); +Expect(0, 1828, '\p{^Is_Joining_Group: --Final_Semkath}', ""); +Expect(0, 1828, '\P{Is_Joining_Group: --Final_Semkath}', ""); +Expect(1, 1828, '\P{^Is_Joining_Group: --Final_Semkath}', ""); +Expect(0, 1827, '\p{Is_Joining_Group: --Final_Semkath}', ""); +Expect(1, 1827, '\p{^Is_Joining_Group: --Final_Semkath}', ""); +Expect(1, 1827, '\P{Is_Joining_Group: --Final_Semkath}', ""); +Expect(0, 1827, '\P{^Is_Joining_Group: --Final_Semkath}', ""); +Error('\p{Is_Jg= Final_semkath:=}'); +Error('\P{Is_Jg= Final_semkath:=}'); +Expect(1, 1828, '\p{Is_Jg=finalsemkath}', ""); +Expect(0, 1828, '\p{^Is_Jg=finalsemkath}', ""); +Expect(0, 1828, '\P{Is_Jg=finalsemkath}', ""); +Expect(1, 1828, '\P{^Is_Jg=finalsemkath}', ""); +Expect(0, 1827, '\p{Is_Jg=finalsemkath}', ""); +Expect(1, 1827, '\p{^Is_Jg=finalsemkath}', ""); +Expect(1, 1827, '\P{Is_Jg=finalsemkath}', ""); +Expect(0, 1827, '\P{^Is_Jg=finalsemkath}', ""); +Expect(1, 1828, '\p{Is_Jg=-FINAL_Semkath}', ""); +Expect(0, 1828, '\p{^Is_Jg=-FINAL_Semkath}', ""); +Expect(0, 1828, '\P{Is_Jg=-FINAL_Semkath}', ""); +Expect(1, 1828, '\P{^Is_Jg=-FINAL_Semkath}', ""); +Expect(0, 1827, '\p{Is_Jg=-FINAL_Semkath}', ""); +Expect(1, 1827, '\p{^Is_Jg=-FINAL_Semkath}', ""); +Expect(1, 1827, '\P{Is_Jg=-FINAL_Semkath}', ""); +Expect(0, 1827, '\P{^Is_Jg=-FINAL_Semkath}', ""); +Error('\p{Joining_Group=_Knotted/a/Heh}'); +Error('\P{Joining_Group=_Knotted/a/Heh}'); +Expect(1, 1726, '\p{Joining_Group: knottedheh}', ""); +Expect(0, 1726, '\p{^Joining_Group: knottedheh}', ""); +Expect(0, 1726, '\P{Joining_Group: knottedheh}', ""); +Expect(1, 1726, '\P{^Joining_Group: knottedheh}', ""); +Expect(0, 1725, '\p{Joining_Group: knottedheh}', ""); +Expect(1, 1725, '\p{^Joining_Group: knottedheh}', ""); +Expect(1, 1725, '\P{Joining_Group: knottedheh}', ""); +Expect(0, 1725, '\P{^Joining_Group: knottedheh}', ""); +Expect(1, 1726, '\p{Joining_Group=_ Knotted Heh}', ""); +Expect(0, 1726, '\p{^Joining_Group=_ Knotted Heh}', ""); +Expect(0, 1726, '\P{Joining_Group=_ Knotted Heh}', ""); +Expect(1, 1726, '\P{^Joining_Group=_ Knotted Heh}', ""); +Expect(0, 1725, '\p{Joining_Group=_ Knotted Heh}', ""); +Expect(1, 1725, '\p{^Joining_Group=_ Knotted Heh}', ""); +Expect(1, 1725, '\P{Joining_Group=_ Knotted Heh}', ""); +Expect(0, 1725, '\P{^Joining_Group=_ Knotted Heh}', ""); +Error('\p{Jg=/a/ KNOTTEDHeh}'); +Error('\P{Jg=/a/ KNOTTEDHeh}'); +Expect(1, 1726, '\p{Jg=knottedheh}', ""); +Expect(0, 1726, '\p{^Jg=knottedheh}', ""); +Expect(0, 1726, '\P{Jg=knottedheh}', ""); +Expect(1, 1726, '\P{^Jg=knottedheh}', ""); +Expect(0, 1725, '\p{Jg=knottedheh}', ""); +Expect(1, 1725, '\p{^Jg=knottedheh}', ""); +Expect(1, 1725, '\P{Jg=knottedheh}', ""); +Expect(0, 1725, '\P{^Jg=knottedheh}', ""); +Expect(1, 1726, '\p{Jg=_KNOTTEDHeh}', ""); +Expect(0, 1726, '\p{^Jg=_KNOTTEDHeh}', ""); +Expect(0, 1726, '\P{Jg=_KNOTTEDHeh}', ""); +Expect(1, 1726, '\P{^Jg=_KNOTTEDHeh}', ""); +Expect(0, 1725, '\p{Jg=_KNOTTEDHeh}', ""); +Expect(1, 1725, '\p{^Jg=_KNOTTEDHeh}', ""); +Expect(1, 1725, '\P{Jg=_KNOTTEDHeh}', ""); +Expect(0, 1725, '\P{^Jg=_KNOTTEDHeh}', ""); +Error('\p{Is_Joining_Group=_KNOTTED:=heh}'); +Error('\P{Is_Joining_Group=_KNOTTED:=heh}'); +Expect(1, 1726, '\p{Is_Joining_Group=knottedheh}', ""); +Expect(0, 1726, '\p{^Is_Joining_Group=knottedheh}', ""); +Expect(0, 1726, '\P{Is_Joining_Group=knottedheh}', ""); +Expect(1, 1726, '\P{^Is_Joining_Group=knottedheh}', ""); +Expect(0, 1725, '\p{Is_Joining_Group=knottedheh}', ""); +Expect(1, 1725, '\p{^Is_Joining_Group=knottedheh}', ""); +Expect(1, 1725, '\P{Is_Joining_Group=knottedheh}', ""); +Expect(0, 1725, '\P{^Is_Joining_Group=knottedheh}', ""); +Expect(1, 1726, '\p{Is_Joining_Group=_-knotted_heh}', ""); +Expect(0, 1726, '\p{^Is_Joining_Group=_-knotted_heh}', ""); +Expect(0, 1726, '\P{Is_Joining_Group=_-knotted_heh}', ""); +Expect(1, 1726, '\P{^Is_Joining_Group=_-knotted_heh}', ""); +Expect(0, 1725, '\p{Is_Joining_Group=_-knotted_heh}', ""); +Expect(1, 1725, '\p{^Is_Joining_Group=_-knotted_heh}', ""); +Expect(1, 1725, '\P{Is_Joining_Group=_-knotted_heh}', ""); +Expect(0, 1725, '\P{^Is_Joining_Group=_-knotted_heh}', ""); +Error('\p{Is_Jg=_:=KNOTTED-HEH}'); +Error('\P{Is_Jg=_:=KNOTTED-HEH}'); +Expect(1, 1726, '\p{Is_Jg=knottedheh}', ""); +Expect(0, 1726, '\p{^Is_Jg=knottedheh}', ""); +Expect(0, 1726, '\P{Is_Jg=knottedheh}', ""); +Expect(1, 1726, '\P{^Is_Jg=knottedheh}', ""); +Expect(0, 1725, '\p{Is_Jg=knottedheh}', ""); +Expect(1, 1725, '\p{^Is_Jg=knottedheh}', ""); +Expect(1, 1725, '\P{Is_Jg=knottedheh}', ""); +Expect(0, 1725, '\P{^Is_Jg=knottedheh}', ""); +Expect(1, 1726, '\p{Is_Jg=_KNOTTED-heh}', ""); +Expect(0, 1726, '\p{^Is_Jg=_KNOTTED-heh}', ""); +Expect(0, 1726, '\P{Is_Jg=_KNOTTED-heh}', ""); +Expect(1, 1726, '\P{^Is_Jg=_KNOTTED-heh}', ""); +Expect(0, 1725, '\p{Is_Jg=_KNOTTED-heh}', ""); +Expect(1, 1725, '\p{^Is_Jg=_KNOTTED-heh}', ""); +Expect(1, 1725, '\P{Is_Jg=_KNOTTED-heh}', ""); +Expect(0, 1725, '\P{^Is_Jg=_KNOTTED-heh}', ""); +Error('\p{Joining_Group=:= KAF}'); +Error('\P{Joining_Group=:= KAF}'); +Expect(1, 1603, '\p{Joining_Group=kaf}', ""); +Expect(0, 1603, '\p{^Joining_Group=kaf}', ""); +Expect(0, 1603, '\P{Joining_Group=kaf}', ""); +Expect(1, 1603, '\P{^Joining_Group=kaf}', ""); +Expect(0, 1602, '\p{Joining_Group=kaf}', ""); +Expect(1, 1602, '\p{^Joining_Group=kaf}', ""); +Expect(1, 1602, '\P{Joining_Group=kaf}', ""); +Expect(0, 1602, '\P{^Joining_Group=kaf}', ""); +Expect(1, 1603, '\p{Joining_Group= KAF}', ""); +Expect(0, 1603, '\p{^Joining_Group= KAF}', ""); +Expect(0, 1603, '\P{Joining_Group= KAF}', ""); +Expect(1, 1603, '\P{^Joining_Group= KAF}', ""); +Expect(0, 1602, '\p{Joining_Group= KAF}', ""); +Expect(1, 1602, '\p{^Joining_Group= KAF}', ""); +Expect(1, 1602, '\P{Joining_Group= KAF}', ""); +Expect(0, 1602, '\P{^Joining_Group= KAF}', ""); +Error('\p{Jg=:= kaf}'); +Error('\P{Jg=:= kaf}'); +Expect(1, 1603, '\p{Jg: kaf}', ""); +Expect(0, 1603, '\p{^Jg: kaf}', ""); +Expect(0, 1603, '\P{Jg: kaf}', ""); +Expect(1, 1603, '\P{^Jg: kaf}', ""); +Expect(0, 1602, '\p{Jg: kaf}', ""); +Expect(1, 1602, '\p{^Jg: kaf}', ""); +Expect(1, 1602, '\P{Jg: kaf}', ""); +Expect(0, 1602, '\P{^Jg: kaf}', ""); +Expect(1, 1603, '\p{Jg=_Kaf}', ""); +Expect(0, 1603, '\p{^Jg=_Kaf}', ""); +Expect(0, 1603, '\P{Jg=_Kaf}', ""); +Expect(1, 1603, '\P{^Jg=_Kaf}', ""); +Expect(0, 1602, '\p{Jg=_Kaf}', ""); +Expect(1, 1602, '\p{^Jg=_Kaf}', ""); +Expect(1, 1602, '\P{Jg=_Kaf}', ""); +Expect(0, 1602, '\P{^Jg=_Kaf}', ""); +Error('\p{Is_Joining_Group=-:=kaf}'); +Error('\P{Is_Joining_Group=-:=kaf}'); +Expect(1, 1603, '\p{Is_Joining_Group=kaf}', ""); +Expect(0, 1603, '\p{^Is_Joining_Group=kaf}', ""); +Expect(0, 1603, '\P{Is_Joining_Group=kaf}', ""); +Expect(1, 1603, '\P{^Is_Joining_Group=kaf}', ""); +Expect(0, 1602, '\p{Is_Joining_Group=kaf}', ""); +Expect(1, 1602, '\p{^Is_Joining_Group=kaf}', ""); +Expect(1, 1602, '\P{Is_Joining_Group=kaf}', ""); +Expect(0, 1602, '\P{^Is_Joining_Group=kaf}', ""); +Expect(1, 1603, '\p{Is_Joining_Group= _Kaf}', ""); +Expect(0, 1603, '\p{^Is_Joining_Group= _Kaf}', ""); +Expect(0, 1603, '\P{Is_Joining_Group= _Kaf}', ""); +Expect(1, 1603, '\P{^Is_Joining_Group= _Kaf}', ""); +Expect(0, 1602, '\p{Is_Joining_Group= _Kaf}', ""); +Expect(1, 1602, '\p{^Is_Joining_Group= _Kaf}', ""); +Expect(1, 1602, '\P{Is_Joining_Group= _Kaf}', ""); +Expect(0, 1602, '\P{^Is_Joining_Group= _Kaf}', ""); +Error('\p{Is_Jg=_ Kaf:=}'); +Error('\P{Is_Jg=_ Kaf:=}'); +Expect(1, 1603, '\p{Is_Jg=kaf}', ""); +Expect(0, 1603, '\p{^Is_Jg=kaf}', ""); +Expect(0, 1603, '\P{Is_Jg=kaf}', ""); +Expect(1, 1603, '\P{^Is_Jg=kaf}', ""); +Expect(0, 1602, '\p{Is_Jg=kaf}', ""); +Expect(1, 1602, '\p{^Is_Jg=kaf}', ""); +Expect(1, 1602, '\P{Is_Jg=kaf}', ""); +Expect(0, 1602, '\P{^Is_Jg=kaf}', ""); +Expect(1, 1603, '\p{Is_Jg= kaf}', ""); +Expect(0, 1603, '\p{^Is_Jg= kaf}', ""); +Expect(0, 1603, '\P{Is_Jg= kaf}', ""); +Expect(1, 1603, '\P{^Is_Jg= kaf}', ""); +Expect(0, 1602, '\p{Is_Jg= kaf}', ""); +Expect(1, 1602, '\p{^Is_Jg= kaf}', ""); +Expect(1, 1602, '\P{Is_Jg= kaf}', ""); +Expect(0, 1602, '\P{^Is_Jg= kaf}', ""); +Error('\p{Joining_Group=_Fe:=}'); +Error('\P{Joining_Group=_Fe:=}'); +Expect(1, 1871, '\p{Joining_Group=fe}', ""); +Expect(0, 1871, '\p{^Joining_Group=fe}', ""); +Expect(0, 1871, '\P{Joining_Group=fe}', ""); +Expect(1, 1871, '\P{^Joining_Group=fe}', ""); +Expect(0, 1870, '\p{Joining_Group=fe}', ""); +Expect(1, 1870, '\p{^Joining_Group=fe}', ""); +Expect(1, 1870, '\P{Joining_Group=fe}', ""); +Expect(0, 1870, '\P{^Joining_Group=fe}', ""); +Expect(1, 1871, '\p{Joining_Group= Fe}', ""); +Expect(0, 1871, '\p{^Joining_Group= Fe}', ""); +Expect(0, 1871, '\P{Joining_Group= Fe}', ""); +Expect(1, 1871, '\P{^Joining_Group= Fe}', ""); +Expect(0, 1870, '\p{Joining_Group= Fe}', ""); +Expect(1, 1870, '\p{^Joining_Group= Fe}', ""); +Expect(1, 1870, '\P{Joining_Group= Fe}', ""); +Expect(0, 1870, '\P{^Joining_Group= Fe}', ""); +Error('\p{Jg= /a/fe}'); +Error('\P{Jg= /a/fe}'); +Expect(1, 1871, '\p{Jg=fe}', ""); +Expect(0, 1871, '\p{^Jg=fe}', ""); +Expect(0, 1871, '\P{Jg=fe}', ""); +Expect(1, 1871, '\P{^Jg=fe}', ""); +Expect(0, 1870, '\p{Jg=fe}', ""); +Expect(1, 1870, '\p{^Jg=fe}', ""); +Expect(1, 1870, '\P{Jg=fe}', ""); +Expect(0, 1870, '\P{^Jg=fe}', ""); +Expect(1, 1871, '\p{Jg= Fe}', ""); +Expect(0, 1871, '\p{^Jg= Fe}', ""); +Expect(0, 1871, '\P{Jg= Fe}', ""); +Expect(1, 1871, '\P{^Jg= Fe}', ""); +Expect(0, 1870, '\p{Jg= Fe}', ""); +Expect(1, 1870, '\p{^Jg= Fe}', ""); +Expect(1, 1870, '\P{Jg= Fe}', ""); +Expect(0, 1870, '\P{^Jg= Fe}', ""); +Error('\p{Is_Joining_Group=:= -fe}'); +Error('\P{Is_Joining_Group=:= -fe}'); +Expect(1, 1871, '\p{Is_Joining_Group=fe}', ""); +Expect(0, 1871, '\p{^Is_Joining_Group=fe}', ""); +Expect(0, 1871, '\P{Is_Joining_Group=fe}', ""); +Expect(1, 1871, '\P{^Is_Joining_Group=fe}', ""); +Expect(0, 1870, '\p{Is_Joining_Group=fe}', ""); +Expect(1, 1870, '\p{^Is_Joining_Group=fe}', ""); +Expect(1, 1870, '\P{Is_Joining_Group=fe}', ""); +Expect(0, 1870, '\P{^Is_Joining_Group=fe}', ""); +Expect(1, 1871, '\p{Is_Joining_Group: -fe}', ""); +Expect(0, 1871, '\p{^Is_Joining_Group: -fe}', ""); +Expect(0, 1871, '\P{Is_Joining_Group: -fe}', ""); +Expect(1, 1871, '\P{^Is_Joining_Group: -fe}', ""); +Expect(0, 1870, '\p{Is_Joining_Group: -fe}', ""); +Expect(1, 1870, '\p{^Is_Joining_Group: -fe}', ""); +Expect(1, 1870, '\P{Is_Joining_Group: -fe}', ""); +Expect(0, 1870, '\P{^Is_Joining_Group: -fe}', ""); +Error('\p{Is_Jg=-/a/fe}'); +Error('\P{Is_Jg=-/a/fe}'); +Expect(1, 1871, '\p{Is_Jg=fe}', ""); +Expect(0, 1871, '\p{^Is_Jg=fe}', ""); +Expect(0, 1871, '\P{Is_Jg=fe}', ""); +Expect(1, 1871, '\P{^Is_Jg=fe}', ""); +Expect(0, 1870, '\p{Is_Jg=fe}', ""); +Expect(1, 1870, '\p{^Is_Jg=fe}', ""); +Expect(1, 1870, '\P{Is_Jg=fe}', ""); +Expect(0, 1870, '\P{^Is_Jg=fe}', ""); +Expect(1, 1871, '\p{Is_Jg: Fe}', ""); +Expect(0, 1871, '\p{^Is_Jg: Fe}', ""); +Expect(0, 1871, '\P{Is_Jg: Fe}', ""); +Expect(1, 1871, '\P{^Is_Jg: Fe}', ""); +Expect(0, 1870, '\p{Is_Jg: Fe}', ""); +Expect(1, 1870, '\p{^Is_Jg: Fe}', ""); +Expect(1, 1870, '\P{Is_Jg: Fe}', ""); +Expect(0, 1870, '\P{^Is_Jg: Fe}', ""); +Error('\p{Joining_Group=- Alaph/a/}'); +Error('\P{Joining_Group=- Alaph/a/}'); +Expect(1, 1808, '\p{Joining_Group=alaph}', ""); +Expect(0, 1808, '\p{^Joining_Group=alaph}', ""); +Expect(0, 1808, '\P{Joining_Group=alaph}', ""); +Expect(1, 1808, '\P{^Joining_Group=alaph}', ""); +Expect(0, 1807, '\p{Joining_Group=alaph}', ""); +Expect(1, 1807, '\p{^Joining_Group=alaph}', ""); +Expect(1, 1807, '\P{Joining_Group=alaph}', ""); +Expect(0, 1807, '\P{^Joining_Group=alaph}', ""); +Expect(1, 1808, '\p{Joining_Group=-Alaph}', ""); +Expect(0, 1808, '\p{^Joining_Group=-Alaph}', ""); +Expect(0, 1808, '\P{Joining_Group=-Alaph}', ""); +Expect(1, 1808, '\P{^Joining_Group=-Alaph}', ""); +Expect(0, 1807, '\p{Joining_Group=-Alaph}', ""); +Expect(1, 1807, '\p{^Joining_Group=-Alaph}', ""); +Expect(1, 1807, '\P{Joining_Group=-Alaph}', ""); +Expect(0, 1807, '\P{^Joining_Group=-Alaph}', ""); +Error('\p{Jg=ALAPH/a/}'); +Error('\P{Jg=ALAPH/a/}'); +Expect(1, 1808, '\p{Jg=alaph}', ""); +Expect(0, 1808, '\p{^Jg=alaph}', ""); +Expect(0, 1808, '\P{Jg=alaph}', ""); +Expect(1, 1808, '\P{^Jg=alaph}', ""); +Expect(0, 1807, '\p{Jg=alaph}', ""); +Expect(1, 1807, '\p{^Jg=alaph}', ""); +Expect(1, 1807, '\P{Jg=alaph}', ""); +Expect(0, 1807, '\P{^Jg=alaph}', ""); +Expect(1, 1808, '\p{Jg=-Alaph}', ""); +Expect(0, 1808, '\p{^Jg=-Alaph}', ""); +Expect(0, 1808, '\P{Jg=-Alaph}', ""); +Expect(1, 1808, '\P{^Jg=-Alaph}', ""); +Expect(0, 1807, '\p{Jg=-Alaph}', ""); +Expect(1, 1807, '\p{^Jg=-Alaph}', ""); +Expect(1, 1807, '\P{Jg=-Alaph}', ""); +Expect(0, 1807, '\P{^Jg=-Alaph}', ""); +Error('\p{Is_Joining_Group= :=alaph}'); +Error('\P{Is_Joining_Group= :=alaph}'); +Expect(1, 1808, '\p{Is_Joining_Group=alaph}', ""); +Expect(0, 1808, '\p{^Is_Joining_Group=alaph}', ""); +Expect(0, 1808, '\P{Is_Joining_Group=alaph}', ""); +Expect(1, 1808, '\P{^Is_Joining_Group=alaph}', ""); +Expect(0, 1807, '\p{Is_Joining_Group=alaph}', ""); +Expect(1, 1807, '\p{^Is_Joining_Group=alaph}', ""); +Expect(1, 1807, '\P{Is_Joining_Group=alaph}', ""); +Expect(0, 1807, '\P{^Is_Joining_Group=alaph}', ""); +Expect(1, 1808, '\p{Is_Joining_Group= ALAPH}', ""); +Expect(0, 1808, '\p{^Is_Joining_Group= ALAPH}', ""); +Expect(0, 1808, '\P{Is_Joining_Group= ALAPH}', ""); +Expect(1, 1808, '\P{^Is_Joining_Group= ALAPH}', ""); +Expect(0, 1807, '\p{Is_Joining_Group= ALAPH}', ""); +Expect(1, 1807, '\p{^Is_Joining_Group= ALAPH}', ""); +Expect(1, 1807, '\P{Is_Joining_Group= ALAPH}', ""); +Expect(0, 1807, '\P{^Is_Joining_Group= ALAPH}', ""); +Error('\p{Is_Jg= ALAPH/a/}'); +Error('\P{Is_Jg= ALAPH/a/}'); +Expect(1, 1808, '\p{Is_Jg=alaph}', ""); +Expect(0, 1808, '\p{^Is_Jg=alaph}', ""); +Expect(0, 1808, '\P{Is_Jg=alaph}', ""); +Expect(1, 1808, '\P{^Is_Jg=alaph}', ""); +Expect(0, 1807, '\p{Is_Jg=alaph}', ""); +Expect(1, 1807, '\p{^Is_Jg=alaph}', ""); +Expect(1, 1807, '\P{Is_Jg=alaph}', ""); +Expect(0, 1807, '\P{^Is_Jg=alaph}', ""); +Expect(1, 1808, '\p{Is_Jg= _Alaph}', ""); +Expect(0, 1808, '\p{^Is_Jg= _Alaph}', ""); +Expect(0, 1808, '\P{Is_Jg= _Alaph}', ""); +Expect(1, 1808, '\P{^Is_Jg= _Alaph}', ""); +Expect(0, 1807, '\p{Is_Jg= _Alaph}', ""); +Expect(1, 1807, '\p{^Is_Jg= _Alaph}', ""); +Expect(1, 1807, '\P{Is_Jg= _Alaph}', ""); +Expect(0, 1807, '\P{^Is_Jg= _Alaph}', ""); +Error('\p{Joining_Group=:=--Lamadh}'); +Error('\P{Joining_Group=:=--Lamadh}'); +Expect(1, 1824, '\p{Joining_Group=lamadh}', ""); +Expect(0, 1824, '\p{^Joining_Group=lamadh}', ""); +Expect(0, 1824, '\P{Joining_Group=lamadh}', ""); +Expect(1, 1824, '\P{^Joining_Group=lamadh}', ""); +Expect(0, 1823, '\p{Joining_Group=lamadh}', ""); +Expect(1, 1823, '\p{^Joining_Group=lamadh}', ""); +Expect(1, 1823, '\P{Joining_Group=lamadh}', ""); +Expect(0, 1823, '\P{^Joining_Group=lamadh}', ""); +Expect(1, 1824, '\p{Joining_Group= Lamadh}', ""); +Expect(0, 1824, '\p{^Joining_Group= Lamadh}', ""); +Expect(0, 1824, '\P{Joining_Group= Lamadh}', ""); +Expect(1, 1824, '\P{^Joining_Group= Lamadh}', ""); +Expect(0, 1823, '\p{Joining_Group= Lamadh}', ""); +Expect(1, 1823, '\p{^Joining_Group= Lamadh}', ""); +Expect(1, 1823, '\P{Joining_Group= Lamadh}', ""); +Expect(0, 1823, '\P{^Joining_Group= Lamadh}', ""); +Error('\p{Jg=:=-Lamadh}'); +Error('\P{Jg=:=-Lamadh}'); +Expect(1, 1824, '\p{Jg=lamadh}', ""); +Expect(0, 1824, '\p{^Jg=lamadh}', ""); +Expect(0, 1824, '\P{Jg=lamadh}', ""); +Expect(1, 1824, '\P{^Jg=lamadh}', ""); +Expect(0, 1823, '\p{Jg=lamadh}', ""); +Expect(1, 1823, '\p{^Jg=lamadh}', ""); +Expect(1, 1823, '\P{Jg=lamadh}', ""); +Expect(0, 1823, '\P{^Jg=lamadh}', ""); +Expect(1, 1824, '\p{Jg=_ Lamadh}', ""); +Expect(0, 1824, '\p{^Jg=_ Lamadh}', ""); +Expect(0, 1824, '\P{Jg=_ Lamadh}', ""); +Expect(1, 1824, '\P{^Jg=_ Lamadh}', ""); +Expect(0, 1823, '\p{Jg=_ Lamadh}', ""); +Expect(1, 1823, '\p{^Jg=_ Lamadh}', ""); +Expect(1, 1823, '\P{Jg=_ Lamadh}', ""); +Expect(0, 1823, '\P{^Jg=_ Lamadh}', ""); +Error('\p{Is_Joining_Group=/a/LAMADH}'); +Error('\P{Is_Joining_Group=/a/LAMADH}'); +Expect(1, 1824, '\p{Is_Joining_Group=lamadh}', ""); +Expect(0, 1824, '\p{^Is_Joining_Group=lamadh}', ""); +Expect(0, 1824, '\P{Is_Joining_Group=lamadh}', ""); +Expect(1, 1824, '\P{^Is_Joining_Group=lamadh}', ""); +Expect(0, 1823, '\p{Is_Joining_Group=lamadh}', ""); +Expect(1, 1823, '\p{^Is_Joining_Group=lamadh}', ""); +Expect(1, 1823, '\P{Is_Joining_Group=lamadh}', ""); +Expect(0, 1823, '\P{^Is_Joining_Group=lamadh}', ""); +Expect(1, 1824, '\p{Is_Joining_Group= LAMADH}', ""); +Expect(0, 1824, '\p{^Is_Joining_Group= LAMADH}', ""); +Expect(0, 1824, '\P{Is_Joining_Group= LAMADH}', ""); +Expect(1, 1824, '\P{^Is_Joining_Group= LAMADH}', ""); +Expect(0, 1823, '\p{Is_Joining_Group= LAMADH}', ""); +Expect(1, 1823, '\p{^Is_Joining_Group= LAMADH}', ""); +Expect(1, 1823, '\P{Is_Joining_Group= LAMADH}', ""); +Expect(0, 1823, '\P{^Is_Joining_Group= LAMADH}', ""); +Error('\p{Is_Jg: := -Lamadh}'); +Error('\P{Is_Jg: := -Lamadh}'); +Expect(1, 1824, '\p{Is_Jg=lamadh}', ""); +Expect(0, 1824, '\p{^Is_Jg=lamadh}', ""); +Expect(0, 1824, '\P{Is_Jg=lamadh}', ""); +Expect(1, 1824, '\P{^Is_Jg=lamadh}', ""); +Expect(0, 1823, '\p{Is_Jg=lamadh}', ""); +Expect(1, 1823, '\p{^Is_Jg=lamadh}', ""); +Expect(1, 1823, '\P{Is_Jg=lamadh}', ""); +Expect(0, 1823, '\P{^Is_Jg=lamadh}', ""); +Expect(1, 1824, '\p{Is_Jg: _LAMADH}', ""); +Expect(0, 1824, '\p{^Is_Jg: _LAMADH}', ""); +Expect(0, 1824, '\P{Is_Jg: _LAMADH}', ""); +Expect(1, 1824, '\P{^Is_Jg: _LAMADH}', ""); +Expect(0, 1823, '\p{Is_Jg: _LAMADH}', ""); +Expect(1, 1823, '\p{^Is_Jg: _LAMADH}', ""); +Expect(1, 1823, '\P{Is_Jg: _LAMADH}', ""); +Expect(0, 1823, '\P{^Is_Jg: _LAMADH}', ""); +Error('\p{Joining_Group=:=_ E}'); +Error('\P{Joining_Group=:=_ E}'); +Expect(1, 1829, '\p{Joining_Group=e}', ""); +Expect(0, 1829, '\p{^Joining_Group=e}', ""); +Expect(0, 1829, '\P{Joining_Group=e}', ""); +Expect(1, 1829, '\P{^Joining_Group=e}', ""); +Expect(0, 1828, '\p{Joining_Group=e}', ""); +Expect(1, 1828, '\p{^Joining_Group=e}', ""); +Expect(1, 1828, '\P{Joining_Group=e}', ""); +Expect(0, 1828, '\P{^Joining_Group=e}', ""); +Expect(1, 1829, '\p{Joining_Group= -E}', ""); +Expect(0, 1829, '\p{^Joining_Group= -E}', ""); +Expect(0, 1829, '\P{Joining_Group= -E}', ""); +Expect(1, 1829, '\P{^Joining_Group= -E}', ""); +Expect(0, 1828, '\p{Joining_Group= -E}', ""); +Expect(1, 1828, '\p{^Joining_Group= -E}', ""); +Expect(1, 1828, '\P{Joining_Group= -E}', ""); +Expect(0, 1828, '\P{^Joining_Group= -E}', ""); +Error('\p{Jg=/a/ E}'); +Error('\P{Jg=/a/ E}'); +Expect(1, 1829, '\p{Jg:e}', ""); +Expect(0, 1829, '\p{^Jg:e}', ""); +Expect(0, 1829, '\P{Jg:e}', ""); +Expect(1, 1829, '\P{^Jg:e}', ""); +Expect(0, 1828, '\p{Jg:e}', ""); +Expect(1, 1828, '\p{^Jg:e}', ""); +Expect(1, 1828, '\P{Jg:e}', ""); +Expect(0, 1828, '\P{^Jg:e}', ""); +Expect(1, 1829, '\p{Jg=_ E}', ""); +Expect(0, 1829, '\p{^Jg=_ E}', ""); +Expect(0, 1829, '\P{Jg=_ E}', ""); +Expect(1, 1829, '\P{^Jg=_ E}', ""); +Expect(0, 1828, '\p{Jg=_ E}', ""); +Expect(1, 1828, '\p{^Jg=_ E}', ""); +Expect(1, 1828, '\P{Jg=_ E}', ""); +Expect(0, 1828, '\P{^Jg=_ E}', ""); +Error('\p{Is_Joining_Group= /a/E}'); +Error('\P{Is_Joining_Group= /a/E}'); +Expect(1, 1829, '\p{Is_Joining_Group=e}', ""); +Expect(0, 1829, '\p{^Is_Joining_Group=e}', ""); +Expect(0, 1829, '\P{Is_Joining_Group=e}', ""); +Expect(1, 1829, '\P{^Is_Joining_Group=e}', ""); +Expect(0, 1828, '\p{Is_Joining_Group=e}', ""); +Expect(1, 1828, '\p{^Is_Joining_Group=e}', ""); +Expect(1, 1828, '\P{Is_Joining_Group=e}', ""); +Expect(0, 1828, '\P{^Is_Joining_Group=e}', ""); +Expect(1, 1829, '\p{Is_Joining_Group=_-e}', ""); +Expect(0, 1829, '\p{^Is_Joining_Group=_-e}', ""); +Expect(0, 1829, '\P{Is_Joining_Group=_-e}', ""); +Expect(1, 1829, '\P{^Is_Joining_Group=_-e}', ""); +Expect(0, 1828, '\p{Is_Joining_Group=_-e}', ""); +Expect(1, 1828, '\p{^Is_Joining_Group=_-e}', ""); +Expect(1, 1828, '\P{Is_Joining_Group=_-e}', ""); +Expect(0, 1828, '\P{^Is_Joining_Group=_-e}', ""); +Error('\p{Is_Jg=:= _E}'); +Error('\P{Is_Jg=:= _E}'); +Expect(1, 1829, '\p{Is_Jg=e}', ""); +Expect(0, 1829, '\p{^Is_Jg=e}', ""); +Expect(0, 1829, '\P{Is_Jg=e}', ""); +Expect(1, 1829, '\P{^Is_Jg=e}', ""); +Expect(0, 1828, '\p{Is_Jg=e}', ""); +Expect(1, 1828, '\p{^Is_Jg=e}', ""); +Expect(1, 1828, '\P{Is_Jg=e}', ""); +Expect(0, 1828, '\P{^Is_Jg=e}', ""); +Expect(1, 1829, '\p{Is_Jg=--E}', ""); +Expect(0, 1829, '\p{^Is_Jg=--E}', ""); +Expect(0, 1829, '\P{Is_Jg=--E}', ""); +Expect(1, 1829, '\P{^Is_Jg=--E}', ""); +Expect(0, 1828, '\p{Is_Jg=--E}', ""); +Expect(1, 1828, '\p{^Is_Jg=--E}', ""); +Expect(1, 1828, '\P{Is_Jg=--E}', ""); +Expect(0, 1828, '\P{^Is_Jg=--E}', ""); +Error('\p{Joining_Group=:=_ Yeh BARREE}'); +Error('\P{Joining_Group=:=_ Yeh BARREE}'); +Expect(1, 1747, '\p{Joining_Group=yehbarree}', ""); +Expect(0, 1747, '\p{^Joining_Group=yehbarree}', ""); +Expect(0, 1747, '\P{Joining_Group=yehbarree}', ""); +Expect(1, 1747, '\P{^Joining_Group=yehbarree}', ""); +Expect(0, 1745, '\p{Joining_Group=yehbarree}', ""); +Expect(1, 1745, '\p{^Joining_Group=yehbarree}', ""); +Expect(1, 1745, '\P{Joining_Group=yehbarree}', ""); +Expect(0, 1745, '\P{^Joining_Group=yehbarree}', ""); +Expect(1, 1747, '\p{Joining_Group=-_YehBarree}', ""); +Expect(0, 1747, '\p{^Joining_Group=-_YehBarree}', ""); +Expect(0, 1747, '\P{Joining_Group=-_YehBarree}', ""); +Expect(1, 1747, '\P{^Joining_Group=-_YehBarree}', ""); +Expect(0, 1745, '\p{Joining_Group=-_YehBarree}', ""); +Expect(1, 1745, '\p{^Joining_Group=-_YehBarree}', ""); +Expect(1, 1745, '\P{Joining_Group=-_YehBarree}', ""); +Expect(0, 1745, '\P{^Joining_Group=-_YehBarree}', ""); +Error('\p{Jg= _Yeh:=BARREE}'); +Error('\P{Jg= _Yeh:=BARREE}'); +Expect(1, 1747, '\p{Jg=yehbarree}', ""); +Expect(0, 1747, '\p{^Jg=yehbarree}', ""); +Expect(0, 1747, '\P{Jg=yehbarree}', ""); +Expect(1, 1747, '\P{^Jg=yehbarree}', ""); +Expect(0, 1745, '\p{Jg=yehbarree}', ""); +Expect(1, 1745, '\p{^Jg=yehbarree}', ""); +Expect(1, 1745, '\P{Jg=yehbarree}', ""); +Expect(0, 1745, '\P{^Jg=yehbarree}', ""); +Expect(1, 1747, '\p{Jg: _-Yeh Barree}', ""); +Expect(0, 1747, '\p{^Jg: _-Yeh Barree}', ""); +Expect(0, 1747, '\P{Jg: _-Yeh Barree}', ""); +Expect(1, 1747, '\P{^Jg: _-Yeh Barree}', ""); +Expect(0, 1745, '\p{Jg: _-Yeh Barree}', ""); +Expect(1, 1745, '\p{^Jg: _-Yeh Barree}', ""); +Expect(1, 1745, '\P{Jg: _-Yeh Barree}', ""); +Expect(0, 1745, '\P{^Jg: _-Yeh Barree}', ""); +Error('\p{Is_Joining_Group: YehBarree/a/}'); +Error('\P{Is_Joining_Group: YehBarree/a/}'); +Expect(1, 1747, '\p{Is_Joining_Group=yehbarree}', ""); +Expect(0, 1747, '\p{^Is_Joining_Group=yehbarree}', ""); +Expect(0, 1747, '\P{Is_Joining_Group=yehbarree}', ""); +Expect(1, 1747, '\P{^Is_Joining_Group=yehbarree}', ""); +Expect(0, 1745, '\p{Is_Joining_Group=yehbarree}', ""); +Expect(1, 1745, '\p{^Is_Joining_Group=yehbarree}', ""); +Expect(1, 1745, '\P{Is_Joining_Group=yehbarree}', ""); +Expect(0, 1745, '\P{^Is_Joining_Group=yehbarree}', ""); +Expect(1, 1747, '\p{Is_Joining_Group=_Yeh-Barree}', ""); +Expect(0, 1747, '\p{^Is_Joining_Group=_Yeh-Barree}', ""); +Expect(0, 1747, '\P{Is_Joining_Group=_Yeh-Barree}', ""); +Expect(1, 1747, '\P{^Is_Joining_Group=_Yeh-Barree}', ""); +Expect(0, 1745, '\p{Is_Joining_Group=_Yeh-Barree}', ""); +Expect(1, 1745, '\p{^Is_Joining_Group=_Yeh-Barree}', ""); +Expect(1, 1745, '\P{Is_Joining_Group=_Yeh-Barree}', ""); +Expect(0, 1745, '\P{^Is_Joining_Group=_Yeh-Barree}', ""); +Error('\p{Is_Jg: -_Yehbarree:=}'); +Error('\P{Is_Jg: -_Yehbarree:=}'); +Expect(1, 1747, '\p{Is_Jg=yehbarree}', ""); +Expect(0, 1747, '\p{^Is_Jg=yehbarree}', ""); +Expect(0, 1747, '\P{Is_Jg=yehbarree}', ""); +Expect(1, 1747, '\P{^Is_Jg=yehbarree}', ""); +Expect(0, 1745, '\p{Is_Jg=yehbarree}', ""); +Expect(1, 1745, '\p{^Is_Jg=yehbarree}', ""); +Expect(1, 1745, '\P{Is_Jg=yehbarree}', ""); +Expect(0, 1745, '\P{^Is_Jg=yehbarree}', ""); +Expect(1, 1747, '\p{Is_Jg=_yeh Barree}', ""); +Expect(0, 1747, '\p{^Is_Jg=_yeh Barree}', ""); +Expect(0, 1747, '\P{Is_Jg=_yeh Barree}', ""); +Expect(1, 1747, '\P{^Is_Jg=_yeh Barree}', ""); +Expect(0, 1745, '\p{Is_Jg=_yeh Barree}', ""); +Expect(1, 1745, '\p{^Is_Jg=_yeh Barree}', ""); +Expect(1, 1745, '\P{Is_Jg=_yeh Barree}', ""); +Expect(0, 1745, '\P{^Is_Jg=_yeh Barree}', ""); +Error('\p{Joining_Group=/a/- Nun}'); +Error('\P{Joining_Group=/a/- Nun}'); +Expect(1, 1826, '\p{Joining_Group=nun}', ""); +Expect(0, 1826, '\p{^Joining_Group=nun}', ""); +Expect(0, 1826, '\P{Joining_Group=nun}', ""); +Expect(1, 1826, '\P{^Joining_Group=nun}', ""); +Expect(0, 1825, '\p{Joining_Group=nun}', ""); +Expect(1, 1825, '\p{^Joining_Group=nun}', ""); +Expect(1, 1825, '\P{Joining_Group=nun}', ""); +Expect(0, 1825, '\P{^Joining_Group=nun}', ""); +Expect(1, 1826, '\p{Joining_Group= nun}', ""); +Expect(0, 1826, '\p{^Joining_Group= nun}', ""); +Expect(0, 1826, '\P{Joining_Group= nun}', ""); +Expect(1, 1826, '\P{^Joining_Group= nun}', ""); +Expect(0, 1825, '\p{Joining_Group= nun}', ""); +Expect(1, 1825, '\p{^Joining_Group= nun}', ""); +Expect(1, 1825, '\P{Joining_Group= nun}', ""); +Expect(0, 1825, '\P{^Joining_Group= nun}', ""); +Error('\p{Jg=-/a/Nun}'); +Error('\P{Jg=-/a/Nun}'); +Expect(1, 1826, '\p{Jg=nun}', ""); +Expect(0, 1826, '\p{^Jg=nun}', ""); +Expect(0, 1826, '\P{Jg=nun}', ""); +Expect(1, 1826, '\P{^Jg=nun}', ""); +Expect(0, 1825, '\p{Jg=nun}', ""); +Expect(1, 1825, '\p{^Jg=nun}', ""); +Expect(1, 1825, '\P{Jg=nun}', ""); +Expect(0, 1825, '\P{^Jg=nun}', ""); +Expect(1, 1826, '\p{Jg=_Nun}', ""); +Expect(0, 1826, '\p{^Jg=_Nun}', ""); +Expect(0, 1826, '\P{Jg=_Nun}', ""); +Expect(1, 1826, '\P{^Jg=_Nun}', ""); +Expect(0, 1825, '\p{Jg=_Nun}', ""); +Expect(1, 1825, '\p{^Jg=_Nun}', ""); +Expect(1, 1825, '\P{Jg=_Nun}', ""); +Expect(0, 1825, '\P{^Jg=_Nun}', ""); +Error('\p{Is_Joining_Group: NUN:=}'); +Error('\P{Is_Joining_Group: NUN:=}'); +Expect(1, 1826, '\p{Is_Joining_Group: nun}', ""); +Expect(0, 1826, '\p{^Is_Joining_Group: nun}', ""); +Expect(0, 1826, '\P{Is_Joining_Group: nun}', ""); +Expect(1, 1826, '\P{^Is_Joining_Group: nun}', ""); +Expect(0, 1825, '\p{Is_Joining_Group: nun}', ""); +Expect(1, 1825, '\p{^Is_Joining_Group: nun}', ""); +Expect(1, 1825, '\P{Is_Joining_Group: nun}', ""); +Expect(0, 1825, '\P{^Is_Joining_Group: nun}', ""); +Expect(1, 1826, '\p{Is_Joining_Group= Nun}', ""); +Expect(0, 1826, '\p{^Is_Joining_Group= Nun}', ""); +Expect(0, 1826, '\P{Is_Joining_Group= Nun}', ""); +Expect(1, 1826, '\P{^Is_Joining_Group= Nun}', ""); +Expect(0, 1825, '\p{Is_Joining_Group= Nun}', ""); +Expect(1, 1825, '\p{^Is_Joining_Group= Nun}', ""); +Expect(1, 1825, '\P{Is_Joining_Group= Nun}', ""); +Expect(0, 1825, '\P{^Is_Joining_Group= Nun}', ""); +Error('\p{Is_Jg=-:=nun}'); +Error('\P{Is_Jg=-:=nun}'); +Expect(1, 1826, '\p{Is_Jg: nun}', ""); +Expect(0, 1826, '\p{^Is_Jg: nun}', ""); +Expect(0, 1826, '\P{Is_Jg: nun}', ""); +Expect(1, 1826, '\P{^Is_Jg: nun}', ""); +Expect(0, 1825, '\p{Is_Jg: nun}', ""); +Expect(1, 1825, '\p{^Is_Jg: nun}', ""); +Expect(1, 1825, '\P{Is_Jg: nun}', ""); +Expect(0, 1825, '\P{^Is_Jg: nun}', ""); +Expect(1, 1826, '\p{Is_Jg=Nun}', ""); +Expect(0, 1826, '\p{^Is_Jg=Nun}', ""); +Expect(0, 1826, '\P{Is_Jg=Nun}', ""); +Expect(1, 1826, '\P{^Is_Jg=Nun}', ""); +Expect(0, 1825, '\p{Is_Jg=Nun}', ""); +Expect(1, 1825, '\p{^Is_Jg=Nun}', ""); +Expect(1, 1825, '\P{Is_Jg=Nun}', ""); +Expect(0, 1825, '\P{^Is_Jg=Nun}', ""); +Error('\p{Joining_Group=_:=lam}'); +Error('\P{Joining_Group=_:=lam}'); +Expect(1, 1604, '\p{Joining_Group: lam}', ""); +Expect(0, 1604, '\p{^Joining_Group: lam}', ""); +Expect(0, 1604, '\P{Joining_Group: lam}', ""); +Expect(1, 1604, '\P{^Joining_Group: lam}', ""); +Expect(0, 1603, '\p{Joining_Group: lam}', ""); +Expect(1, 1603, '\p{^Joining_Group: lam}', ""); +Expect(1, 1603, '\P{Joining_Group: lam}', ""); +Expect(0, 1603, '\P{^Joining_Group: lam}', ""); +Expect(1, 1604, '\p{Joining_Group: -Lam}', ""); +Expect(0, 1604, '\p{^Joining_Group: -Lam}', ""); +Expect(0, 1604, '\P{Joining_Group: -Lam}', ""); +Expect(1, 1604, '\P{^Joining_Group: -Lam}', ""); +Expect(0, 1603, '\p{Joining_Group: -Lam}', ""); +Expect(1, 1603, '\p{^Joining_Group: -Lam}', ""); +Expect(1, 1603, '\P{Joining_Group: -Lam}', ""); +Expect(0, 1603, '\P{^Joining_Group: -Lam}', ""); +Error('\p{Jg= /a/Lam}'); +Error('\P{Jg= /a/Lam}'); +Expect(1, 1604, '\p{Jg=lam}', ""); +Expect(0, 1604, '\p{^Jg=lam}', ""); +Expect(0, 1604, '\P{Jg=lam}', ""); +Expect(1, 1604, '\P{^Jg=lam}', ""); +Expect(0, 1603, '\p{Jg=lam}', ""); +Expect(1, 1603, '\p{^Jg=lam}', ""); +Expect(1, 1603, '\P{Jg=lam}', ""); +Expect(0, 1603, '\P{^Jg=lam}', ""); +Expect(1, 1604, '\p{Jg= Lam}', ""); +Expect(0, 1604, '\p{^Jg= Lam}', ""); +Expect(0, 1604, '\P{Jg= Lam}', ""); +Expect(1, 1604, '\P{^Jg= Lam}', ""); +Expect(0, 1603, '\p{Jg= Lam}', ""); +Expect(1, 1603, '\p{^Jg= Lam}', ""); +Expect(1, 1603, '\P{Jg= Lam}', ""); +Expect(0, 1603, '\P{^Jg= Lam}', ""); +Error('\p{Is_Joining_Group=/a/_lam}'); +Error('\P{Is_Joining_Group=/a/_lam}'); +Expect(1, 1604, '\p{Is_Joining_Group:lam}', ""); +Expect(0, 1604, '\p{^Is_Joining_Group:lam}', ""); +Expect(0, 1604, '\P{Is_Joining_Group:lam}', ""); +Expect(1, 1604, '\P{^Is_Joining_Group:lam}', ""); +Expect(0, 1603, '\p{Is_Joining_Group:lam}', ""); +Expect(1, 1603, '\p{^Is_Joining_Group:lam}', ""); +Expect(1, 1603, '\P{Is_Joining_Group:lam}', ""); +Expect(0, 1603, '\P{^Is_Joining_Group:lam}', ""); +Expect(1, 1604, '\p{Is_Joining_Group=_Lam}', ""); +Expect(0, 1604, '\p{^Is_Joining_Group=_Lam}', ""); +Expect(0, 1604, '\P{Is_Joining_Group=_Lam}', ""); +Expect(1, 1604, '\P{^Is_Joining_Group=_Lam}', ""); +Expect(0, 1603, '\p{Is_Joining_Group=_Lam}', ""); +Expect(1, 1603, '\p{^Is_Joining_Group=_Lam}', ""); +Expect(1, 1603, '\P{Is_Joining_Group=_Lam}', ""); +Expect(0, 1603, '\P{^Is_Joining_Group=_Lam}', ""); +Error('\p{Is_Jg=/a/Lam}'); +Error('\P{Is_Jg=/a/Lam}'); +Expect(1, 1604, '\p{Is_Jg=lam}', ""); +Expect(0, 1604, '\p{^Is_Jg=lam}', ""); +Expect(0, 1604, '\P{Is_Jg=lam}', ""); +Expect(1, 1604, '\P{^Is_Jg=lam}', ""); +Expect(0, 1603, '\p{Is_Jg=lam}', ""); +Expect(1, 1603, '\p{^Is_Jg=lam}', ""); +Expect(1, 1603, '\P{Is_Jg=lam}', ""); +Expect(0, 1603, '\P{^Is_Jg=lam}', ""); +Expect(1, 1604, '\p{Is_Jg: lam}', ""); +Expect(0, 1604, '\p{^Is_Jg: lam}', ""); +Expect(0, 1604, '\P{Is_Jg: lam}', ""); +Expect(1, 1604, '\P{^Is_Jg: lam}', ""); +Expect(0, 1603, '\p{Is_Jg: lam}', ""); +Expect(1, 1603, '\p{^Is_Jg: lam}', ""); +Expect(1, 1603, '\P{Is_Jg: lam}', ""); +Expect(0, 1603, '\P{^Is_Jg: lam}', ""); +Error('\p{Joining_Group=__Ain/a/}'); +Error('\P{Joining_Group=__Ain/a/}'); +Expect(1, 1594, '\p{Joining_Group: ain}', ""); +Expect(0, 1594, '\p{^Joining_Group: ain}', ""); +Expect(0, 1594, '\P{Joining_Group: ain}', ""); +Expect(1, 1594, '\P{^Joining_Group: ain}', ""); +Expect(0, 1592, '\p{Joining_Group: ain}', ""); +Expect(1, 1592, '\p{^Joining_Group: ain}', ""); +Expect(1, 1592, '\P{Joining_Group: ain}', ""); +Expect(0, 1592, '\P{^Joining_Group: ain}', ""); +Expect(1, 1594, '\p{Joining_Group= ain}', ""); +Expect(0, 1594, '\p{^Joining_Group= ain}', ""); +Expect(0, 1594, '\P{Joining_Group= ain}', ""); +Expect(1, 1594, '\P{^Joining_Group= ain}', ""); +Expect(0, 1592, '\p{Joining_Group= ain}', ""); +Expect(1, 1592, '\p{^Joining_Group= ain}', ""); +Expect(1, 1592, '\P{Joining_Group= ain}', ""); +Expect(0, 1592, '\P{^Joining_Group= ain}', ""); +Error('\p{Jg=:=--Ain}'); +Error('\P{Jg=:=--Ain}'); +Expect(1, 1594, '\p{Jg=ain}', ""); +Expect(0, 1594, '\p{^Jg=ain}', ""); +Expect(0, 1594, '\P{Jg=ain}', ""); +Expect(1, 1594, '\P{^Jg=ain}', ""); +Expect(0, 1592, '\p{Jg=ain}', ""); +Expect(1, 1592, '\p{^Jg=ain}', ""); +Expect(1, 1592, '\P{Jg=ain}', ""); +Expect(0, 1592, '\P{^Jg=ain}', ""); +Expect(1, 1594, '\p{Jg=-AIN}', ""); +Expect(0, 1594, '\p{^Jg=-AIN}', ""); +Expect(0, 1594, '\P{Jg=-AIN}', ""); +Expect(1, 1594, '\P{^Jg=-AIN}', ""); +Expect(0, 1592, '\p{Jg=-AIN}', ""); +Expect(1, 1592, '\p{^Jg=-AIN}', ""); +Expect(1, 1592, '\P{Jg=-AIN}', ""); +Expect(0, 1592, '\P{^Jg=-AIN}', ""); +Error('\p{Is_Joining_Group=:=-_ain}'); +Error('\P{Is_Joining_Group=:=-_ain}'); +Expect(1, 1594, '\p{Is_Joining_Group=ain}', ""); +Expect(0, 1594, '\p{^Is_Joining_Group=ain}', ""); +Expect(0, 1594, '\P{Is_Joining_Group=ain}', ""); +Expect(1, 1594, '\P{^Is_Joining_Group=ain}', ""); +Expect(0, 1592, '\p{Is_Joining_Group=ain}', ""); +Expect(1, 1592, '\p{^Is_Joining_Group=ain}', ""); +Expect(1, 1592, '\P{Is_Joining_Group=ain}', ""); +Expect(0, 1592, '\P{^Is_Joining_Group=ain}', ""); +Expect(1, 1594, '\p{Is_Joining_Group= ain}', ""); +Expect(0, 1594, '\p{^Is_Joining_Group= ain}', ""); +Expect(0, 1594, '\P{Is_Joining_Group= ain}', ""); +Expect(1, 1594, '\P{^Is_Joining_Group= ain}', ""); +Expect(0, 1592, '\p{Is_Joining_Group= ain}', ""); +Expect(1, 1592, '\p{^Is_Joining_Group= ain}', ""); +Expect(1, 1592, '\P{Is_Joining_Group= ain}', ""); +Expect(0, 1592, '\P{^Is_Joining_Group= ain}', ""); +Error('\p{Is_Jg=__Ain/a/}'); +Error('\P{Is_Jg=__Ain/a/}'); +Expect(1, 1594, '\p{Is_Jg: ain}', ""); +Expect(0, 1594, '\p{^Is_Jg: ain}', ""); +Expect(0, 1594, '\P{Is_Jg: ain}', ""); +Expect(1, 1594, '\P{^Is_Jg: ain}', ""); +Expect(0, 1592, '\p{Is_Jg: ain}', ""); +Expect(1, 1592, '\p{^Is_Jg: ain}', ""); +Expect(1, 1592, '\P{Is_Jg: ain}', ""); +Expect(0, 1592, '\P{^Is_Jg: ain}', ""); +Expect(1, 1594, '\p{Is_Jg= AIN}', ""); +Expect(0, 1594, '\p{^Is_Jg= AIN}', ""); +Expect(0, 1594, '\P{Is_Jg= AIN}', ""); +Expect(1, 1594, '\P{^Is_Jg= AIN}', ""); +Expect(0, 1592, '\p{Is_Jg= AIN}', ""); +Expect(1, 1592, '\p{^Is_Jg= AIN}', ""); +Expect(1, 1592, '\P{Is_Jg= AIN}', ""); +Expect(0, 1592, '\P{^Is_Jg= AIN}', ""); +Error('\p{Joining_Group=_:=heh}'); +Error('\P{Joining_Group=_:=heh}'); +Expect(1, 1607, '\p{Joining_Group=heh}', ""); +Expect(0, 1607, '\p{^Joining_Group=heh}', ""); +Expect(0, 1607, '\P{Joining_Group=heh}', ""); +Expect(1, 1607, '\P{^Joining_Group=heh}', ""); +Expect(0, 1606, '\p{Joining_Group=heh}', ""); +Expect(1, 1606, '\p{^Joining_Group=heh}', ""); +Expect(1, 1606, '\P{Joining_Group=heh}', ""); +Expect(0, 1606, '\P{^Joining_Group=heh}', ""); +Expect(1, 1607, '\p{Joining_Group= Heh}', ""); +Expect(0, 1607, '\p{^Joining_Group= Heh}', ""); +Expect(0, 1607, '\P{Joining_Group= Heh}', ""); +Expect(1, 1607, '\P{^Joining_Group= Heh}', ""); +Expect(0, 1606, '\p{Joining_Group= Heh}', ""); +Expect(1, 1606, '\p{^Joining_Group= Heh}', ""); +Expect(1, 1606, '\P{Joining_Group= Heh}', ""); +Expect(0, 1606, '\P{^Joining_Group= Heh}', ""); +Error('\p{Jg=-:=heh}'); +Error('\P{Jg=-:=heh}'); +Expect(1, 1607, '\p{Jg=heh}', ""); +Expect(0, 1607, '\p{^Jg=heh}', ""); +Expect(0, 1607, '\P{Jg=heh}', ""); +Expect(1, 1607, '\P{^Jg=heh}', ""); +Expect(0, 1606, '\p{Jg=heh}', ""); +Expect(1, 1606, '\p{^Jg=heh}', ""); +Expect(1, 1606, '\P{Jg=heh}', ""); +Expect(0, 1606, '\P{^Jg=heh}', ""); +Expect(1, 1607, '\p{Jg=_-Heh}', ""); +Expect(0, 1607, '\p{^Jg=_-Heh}', ""); +Expect(0, 1607, '\P{Jg=_-Heh}', ""); +Expect(1, 1607, '\P{^Jg=_-Heh}', ""); +Expect(0, 1606, '\p{Jg=_-Heh}', ""); +Expect(1, 1606, '\p{^Jg=_-Heh}', ""); +Expect(1, 1606, '\P{Jg=_-Heh}', ""); +Expect(0, 1606, '\P{^Jg=_-Heh}', ""); +Error('\p{Is_Joining_Group=:= heh}'); +Error('\P{Is_Joining_Group=:= heh}'); +Expect(1, 1607, '\p{Is_Joining_Group=heh}', ""); +Expect(0, 1607, '\p{^Is_Joining_Group=heh}', ""); +Expect(0, 1607, '\P{Is_Joining_Group=heh}', ""); +Expect(1, 1607, '\P{^Is_Joining_Group=heh}', ""); +Expect(0, 1606, '\p{Is_Joining_Group=heh}', ""); +Expect(1, 1606, '\p{^Is_Joining_Group=heh}', ""); +Expect(1, 1606, '\P{Is_Joining_Group=heh}', ""); +Expect(0, 1606, '\P{^Is_Joining_Group=heh}', ""); +Expect(1, 1607, '\p{Is_Joining_Group= -heh}', ""); +Expect(0, 1607, '\p{^Is_Joining_Group= -heh}', ""); +Expect(0, 1607, '\P{Is_Joining_Group= -heh}', ""); +Expect(1, 1607, '\P{^Is_Joining_Group= -heh}', ""); +Expect(0, 1606, '\p{Is_Joining_Group= -heh}', ""); +Expect(1, 1606, '\p{^Is_Joining_Group= -heh}', ""); +Expect(1, 1606, '\P{Is_Joining_Group= -heh}', ""); +Expect(0, 1606, '\P{^Is_Joining_Group= -heh}', ""); +Error('\p{Is_Jg=:= -HEH}'); +Error('\P{Is_Jg=:= -HEH}'); +Expect(1, 1607, '\p{Is_Jg=heh}', ""); +Expect(0, 1607, '\p{^Is_Jg=heh}', ""); +Expect(0, 1607, '\P{Is_Jg=heh}', ""); +Expect(1, 1607, '\P{^Is_Jg=heh}', ""); +Expect(0, 1606, '\p{Is_Jg=heh}', ""); +Expect(1, 1606, '\p{^Is_Jg=heh}', ""); +Expect(1, 1606, '\P{Is_Jg=heh}', ""); +Expect(0, 1606, '\P{^Is_Jg=heh}', ""); +Expect(1, 1607, '\p{Is_Jg: -heh}', ""); +Expect(0, 1607, '\p{^Is_Jg: -heh}', ""); +Expect(0, 1607, '\P{Is_Jg: -heh}', ""); +Expect(1, 1607, '\P{^Is_Jg: -heh}', ""); +Expect(0, 1606, '\p{Is_Jg: -heh}', ""); +Expect(1, 1606, '\p{^Is_Jg: -heh}', ""); +Expect(1, 1606, '\P{Is_Jg: -heh}', ""); +Expect(0, 1606, '\P{^Is_Jg: -heh}', ""); +Error('\p{Joining_Group=:= _qaph}'); +Error('\P{Joining_Group=:= _qaph}'); +Expect(1, 1833, '\p{Joining_Group=qaph}', ""); +Expect(0, 1833, '\p{^Joining_Group=qaph}', ""); +Expect(0, 1833, '\P{Joining_Group=qaph}', ""); +Expect(1, 1833, '\P{^Joining_Group=qaph}', ""); +Expect(0, 1832, '\p{Joining_Group=qaph}', ""); +Expect(1, 1832, '\p{^Joining_Group=qaph}', ""); +Expect(1, 1832, '\P{Joining_Group=qaph}', ""); +Expect(0, 1832, '\P{^Joining_Group=qaph}', ""); +Expect(1, 1833, '\p{Joining_Group=_-QAPH}', ""); +Expect(0, 1833, '\p{^Joining_Group=_-QAPH}', ""); +Expect(0, 1833, '\P{Joining_Group=_-QAPH}', ""); +Expect(1, 1833, '\P{^Joining_Group=_-QAPH}', ""); +Expect(0, 1832, '\p{Joining_Group=_-QAPH}', ""); +Expect(1, 1832, '\p{^Joining_Group=_-QAPH}', ""); +Expect(1, 1832, '\P{Joining_Group=_-QAPH}', ""); +Expect(0, 1832, '\P{^Joining_Group=_-QAPH}', ""); +Error('\p{Jg=/a/- Qaph}'); +Error('\P{Jg=/a/- Qaph}'); +Expect(1, 1833, '\p{Jg=qaph}', ""); +Expect(0, 1833, '\p{^Jg=qaph}', ""); +Expect(0, 1833, '\P{Jg=qaph}', ""); +Expect(1, 1833, '\P{^Jg=qaph}', ""); +Expect(0, 1832, '\p{Jg=qaph}', ""); +Expect(1, 1832, '\p{^Jg=qaph}', ""); +Expect(1, 1832, '\P{Jg=qaph}', ""); +Expect(0, 1832, '\P{^Jg=qaph}', ""); +Expect(1, 1833, '\p{Jg=- QAPH}', ""); +Expect(0, 1833, '\p{^Jg=- QAPH}', ""); +Expect(0, 1833, '\P{Jg=- QAPH}', ""); +Expect(1, 1833, '\P{^Jg=- QAPH}', ""); +Expect(0, 1832, '\p{Jg=- QAPH}', ""); +Expect(1, 1832, '\p{^Jg=- QAPH}', ""); +Expect(1, 1832, '\P{Jg=- QAPH}', ""); +Expect(0, 1832, '\P{^Jg=- QAPH}', ""); +Error('\p{Is_Joining_Group= _qaph/a/}'); +Error('\P{Is_Joining_Group= _qaph/a/}'); +Expect(1, 1833, '\p{Is_Joining_Group=qaph}', ""); +Expect(0, 1833, '\p{^Is_Joining_Group=qaph}', ""); +Expect(0, 1833, '\P{Is_Joining_Group=qaph}', ""); +Expect(1, 1833, '\P{^Is_Joining_Group=qaph}', ""); +Expect(0, 1832, '\p{Is_Joining_Group=qaph}', ""); +Expect(1, 1832, '\p{^Is_Joining_Group=qaph}', ""); +Expect(1, 1832, '\P{Is_Joining_Group=qaph}', ""); +Expect(0, 1832, '\P{^Is_Joining_Group=qaph}', ""); +Expect(1, 1833, '\p{Is_Joining_Group=--Qaph}', ""); +Expect(0, 1833, '\p{^Is_Joining_Group=--Qaph}', ""); +Expect(0, 1833, '\P{Is_Joining_Group=--Qaph}', ""); +Expect(1, 1833, '\P{^Is_Joining_Group=--Qaph}', ""); +Expect(0, 1832, '\p{Is_Joining_Group=--Qaph}', ""); +Expect(1, 1832, '\p{^Is_Joining_Group=--Qaph}', ""); +Expect(1, 1832, '\P{Is_Joining_Group=--Qaph}', ""); +Expect(0, 1832, '\P{^Is_Joining_Group=--Qaph}', ""); +Error('\p{Is_Jg= /a/qaph}'); +Error('\P{Is_Jg= /a/qaph}'); +Expect(1, 1833, '\p{Is_Jg=qaph}', ""); +Expect(0, 1833, '\p{^Is_Jg=qaph}', ""); +Expect(0, 1833, '\P{Is_Jg=qaph}', ""); +Expect(1, 1833, '\P{^Is_Jg=qaph}', ""); +Expect(0, 1832, '\p{Is_Jg=qaph}', ""); +Expect(1, 1832, '\p{^Is_Jg=qaph}', ""); +Expect(1, 1832, '\P{Is_Jg=qaph}', ""); +Expect(0, 1832, '\P{^Is_Jg=qaph}', ""); +Expect(1, 1833, '\p{Is_Jg: Qaph}', ""); +Expect(0, 1833, '\p{^Is_Jg: Qaph}', ""); +Expect(0, 1833, '\P{Is_Jg: Qaph}', ""); +Expect(1, 1833, '\P{^Is_Jg: Qaph}', ""); +Expect(0, 1832, '\p{Is_Jg: Qaph}', ""); +Expect(1, 1832, '\p{^Is_Jg: Qaph}', ""); +Expect(1, 1832, '\P{Is_Jg: Qaph}', ""); +Expect(0, 1832, '\P{^Is_Jg: Qaph}', ""); +Error('\p{Joining_Group= HETH:=}'); +Error('\P{Joining_Group= HETH:=}'); +Expect(1, 1818, '\p{Joining_Group=heth}', ""); +Expect(0, 1818, '\p{^Joining_Group=heth}', ""); +Expect(0, 1818, '\P{Joining_Group=heth}', ""); +Expect(1, 1818, '\P{^Joining_Group=heth}', ""); +Expect(0, 1817, '\p{Joining_Group=heth}', ""); +Expect(1, 1817, '\p{^Joining_Group=heth}', ""); +Expect(1, 1817, '\P{Joining_Group=heth}', ""); +Expect(0, 1817, '\P{^Joining_Group=heth}', ""); +Expect(1, 1818, '\p{Joining_Group=Heth}', ""); +Expect(0, 1818, '\p{^Joining_Group=Heth}', ""); +Expect(0, 1818, '\P{Joining_Group=Heth}', ""); +Expect(1, 1818, '\P{^Joining_Group=Heth}', ""); +Expect(0, 1817, '\p{Joining_Group=Heth}', ""); +Expect(1, 1817, '\p{^Joining_Group=Heth}', ""); +Expect(1, 1817, '\P{Joining_Group=Heth}', ""); +Expect(0, 1817, '\P{^Joining_Group=Heth}', ""); +Error('\p{Jg=/a/ HETH}'); +Error('\P{Jg=/a/ HETH}'); +Expect(1, 1818, '\p{Jg: heth}', ""); +Expect(0, 1818, '\p{^Jg: heth}', ""); +Expect(0, 1818, '\P{Jg: heth}', ""); +Expect(1, 1818, '\P{^Jg: heth}', ""); +Expect(0, 1817, '\p{Jg: heth}', ""); +Expect(1, 1817, '\p{^Jg: heth}', ""); +Expect(1, 1817, '\P{Jg: heth}', ""); +Expect(0, 1817, '\P{^Jg: heth}', ""); +Expect(1, 1818, '\p{Jg=Heth}', ""); +Expect(0, 1818, '\p{^Jg=Heth}', ""); +Expect(0, 1818, '\P{Jg=Heth}', ""); +Expect(1, 1818, '\P{^Jg=Heth}', ""); +Expect(0, 1817, '\p{Jg=Heth}', ""); +Expect(1, 1817, '\p{^Jg=Heth}', ""); +Expect(1, 1817, '\P{Jg=Heth}', ""); +Expect(0, 1817, '\P{^Jg=Heth}', ""); +Error('\p{Is_Joining_Group: -_Heth/a/}'); +Error('\P{Is_Joining_Group: -_Heth/a/}'); +Expect(1, 1818, '\p{Is_Joining_Group=heth}', ""); +Expect(0, 1818, '\p{^Is_Joining_Group=heth}', ""); +Expect(0, 1818, '\P{Is_Joining_Group=heth}', ""); +Expect(1, 1818, '\P{^Is_Joining_Group=heth}', ""); +Expect(0, 1817, '\p{Is_Joining_Group=heth}', ""); +Expect(1, 1817, '\p{^Is_Joining_Group=heth}', ""); +Expect(1, 1817, '\P{Is_Joining_Group=heth}', ""); +Expect(0, 1817, '\P{^Is_Joining_Group=heth}', ""); +Expect(1, 1818, '\p{Is_Joining_Group=_-Heth}', ""); +Expect(0, 1818, '\p{^Is_Joining_Group=_-Heth}', ""); +Expect(0, 1818, '\P{Is_Joining_Group=_-Heth}', ""); +Expect(1, 1818, '\P{^Is_Joining_Group=_-Heth}', ""); +Expect(0, 1817, '\p{Is_Joining_Group=_-Heth}', ""); +Expect(1, 1817, '\p{^Is_Joining_Group=_-Heth}', ""); +Expect(1, 1817, '\P{Is_Joining_Group=_-Heth}', ""); +Expect(0, 1817, '\P{^Is_Joining_Group=_-Heth}', ""); +Error('\p{Is_Jg=/a/ _HETH}'); +Error('\P{Is_Jg=/a/ _HETH}'); +Expect(1, 1818, '\p{Is_Jg=heth}', ""); +Expect(0, 1818, '\p{^Is_Jg=heth}', ""); +Expect(0, 1818, '\P{Is_Jg=heth}', ""); +Expect(1, 1818, '\P{^Is_Jg=heth}', ""); +Expect(0, 1817, '\p{Is_Jg=heth}', ""); +Expect(1, 1817, '\p{^Is_Jg=heth}', ""); +Expect(1, 1817, '\P{Is_Jg=heth}', ""); +Expect(0, 1817, '\P{^Is_Jg=heth}', ""); +Expect(1, 1818, '\p{Is_Jg=_-Heth}', ""); +Expect(0, 1818, '\p{^Is_Jg=_-Heth}', ""); +Expect(0, 1818, '\P{Is_Jg=_-Heth}', ""); +Expect(1, 1818, '\P{^Is_Jg=_-Heth}', ""); +Expect(0, 1817, '\p{Is_Jg=_-Heth}', ""); +Expect(1, 1817, '\p{^Is_Jg=_-Heth}', ""); +Expect(1, 1817, '\P{Is_Jg=_-Heth}', ""); +Expect(0, 1817, '\P{^Is_Jg=_-Heth}', ""); +Error('\p{Joining_Group=-:=TETH}'); +Error('\P{Joining_Group=-:=TETH}'); +Expect(1, 1820, '\p{Joining_Group=teth}', ""); +Expect(0, 1820, '\p{^Joining_Group=teth}', ""); +Expect(0, 1820, '\P{Joining_Group=teth}', ""); +Expect(1, 1820, '\P{^Joining_Group=teth}', ""); +Expect(0, 1818, '\p{Joining_Group=teth}', ""); +Expect(1, 1818, '\p{^Joining_Group=teth}', ""); +Expect(1, 1818, '\P{Joining_Group=teth}', ""); +Expect(0, 1818, '\P{^Joining_Group=teth}', ""); +Expect(1, 1820, '\p{Joining_Group: teth}', ""); +Expect(0, 1820, '\p{^Joining_Group: teth}', ""); +Expect(0, 1820, '\P{Joining_Group: teth}', ""); +Expect(1, 1820, '\P{^Joining_Group: teth}', ""); +Expect(0, 1818, '\p{Joining_Group: teth}', ""); +Expect(1, 1818, '\p{^Joining_Group: teth}', ""); +Expect(1, 1818, '\P{Joining_Group: teth}', ""); +Expect(0, 1818, '\P{^Joining_Group: teth}', ""); +Error('\p{Jg: /a/_-Teth}'); +Error('\P{Jg: /a/_-Teth}'); +Expect(1, 1820, '\p{Jg=teth}', ""); +Expect(0, 1820, '\p{^Jg=teth}', ""); +Expect(0, 1820, '\P{Jg=teth}', ""); +Expect(1, 1820, '\P{^Jg=teth}', ""); +Expect(0, 1818, '\p{Jg=teth}', ""); +Expect(1, 1818, '\p{^Jg=teth}', ""); +Expect(1, 1818, '\P{Jg=teth}', ""); +Expect(0, 1818, '\P{^Jg=teth}', ""); +Expect(1, 1820, '\p{Jg=- TETH}', ""); +Expect(0, 1820, '\p{^Jg=- TETH}', ""); +Expect(0, 1820, '\P{Jg=- TETH}', ""); +Expect(1, 1820, '\P{^Jg=- TETH}', ""); +Expect(0, 1818, '\p{Jg=- TETH}', ""); +Expect(1, 1818, '\p{^Jg=- TETH}', ""); +Expect(1, 1818, '\P{Jg=- TETH}', ""); +Expect(0, 1818, '\P{^Jg=- TETH}', ""); +Error('\p{Is_Joining_Group=teth/a/}'); +Error('\P{Is_Joining_Group=teth/a/}'); +Expect(1, 1820, '\p{Is_Joining_Group=teth}', ""); +Expect(0, 1820, '\p{^Is_Joining_Group=teth}', ""); +Expect(0, 1820, '\P{Is_Joining_Group=teth}', ""); +Expect(1, 1820, '\P{^Is_Joining_Group=teth}', ""); +Expect(0, 1818, '\p{Is_Joining_Group=teth}', ""); +Expect(1, 1818, '\p{^Is_Joining_Group=teth}', ""); +Expect(1, 1818, '\P{Is_Joining_Group=teth}', ""); +Expect(0, 1818, '\P{^Is_Joining_Group=teth}', ""); +Expect(1, 1820, '\p{Is_Joining_Group=- Teth}', ""); +Expect(0, 1820, '\p{^Is_Joining_Group=- Teth}', ""); +Expect(0, 1820, '\P{Is_Joining_Group=- Teth}', ""); +Expect(1, 1820, '\P{^Is_Joining_Group=- Teth}', ""); +Expect(0, 1818, '\p{Is_Joining_Group=- Teth}', ""); +Expect(1, 1818, '\p{^Is_Joining_Group=- Teth}', ""); +Expect(1, 1818, '\P{Is_Joining_Group=- Teth}', ""); +Expect(0, 1818, '\P{^Is_Joining_Group=- Teth}', ""); +Error('\p{Is_Jg=:=TETH}'); +Error('\P{Is_Jg=:=TETH}'); +Expect(1, 1820, '\p{Is_Jg=teth}', ""); +Expect(0, 1820, '\p{^Is_Jg=teth}', ""); +Expect(0, 1820, '\P{Is_Jg=teth}', ""); +Expect(1, 1820, '\P{^Is_Jg=teth}', ""); +Expect(0, 1818, '\p{Is_Jg=teth}', ""); +Expect(1, 1818, '\p{^Is_Jg=teth}', ""); +Expect(1, 1818, '\P{Is_Jg=teth}', ""); +Expect(0, 1818, '\P{^Is_Jg=teth}', ""); +Expect(1, 1820, '\p{Is_Jg= Teth}', ""); +Expect(0, 1820, '\p{^Is_Jg= Teth}', ""); +Expect(0, 1820, '\P{Is_Jg= Teth}', ""); +Expect(1, 1820, '\P{^Is_Jg= Teth}', ""); +Expect(0, 1818, '\p{Is_Jg= Teth}', ""); +Expect(1, 1818, '\p{^Is_Jg= Teth}', ""); +Expect(1, 1818, '\P{Is_Jg= Teth}', ""); +Expect(0, 1818, '\P{^Is_Jg= Teth}', ""); +Error('\p{Joining_Group=:= DALATH-rish}'); +Error('\P{Joining_Group=:= DALATH-rish}'); +Expect(1, 1814, '\p{Joining_Group=dalathrish}', ""); +Expect(0, 1814, '\p{^Joining_Group=dalathrish}', ""); +Expect(0, 1814, '\P{Joining_Group=dalathrish}', ""); +Expect(1, 1814, '\P{^Joining_Group=dalathrish}', ""); +Expect(0, 1812, '\p{Joining_Group=dalathrish}', ""); +Expect(1, 1812, '\p{^Joining_Group=dalathrish}', ""); +Expect(1, 1812, '\P{Joining_Group=dalathrish}', ""); +Expect(0, 1812, '\P{^Joining_Group=dalathrish}', ""); +Expect(1, 1814, '\p{Joining_Group=_Dalath-Rish}', ""); +Expect(0, 1814, '\p{^Joining_Group=_Dalath-Rish}', ""); +Expect(0, 1814, '\P{Joining_Group=_Dalath-Rish}', ""); +Expect(1, 1814, '\P{^Joining_Group=_Dalath-Rish}', ""); +Expect(0, 1812, '\p{Joining_Group=_Dalath-Rish}', ""); +Expect(1, 1812, '\p{^Joining_Group=_Dalath-Rish}', ""); +Expect(1, 1812, '\P{Joining_Group=_Dalath-Rish}', ""); +Expect(0, 1812, '\P{^Joining_Group=_Dalath-Rish}', ""); +Error('\p{Jg=/a/Dalath_Rish}'); +Error('\P{Jg=/a/Dalath_Rish}'); +Expect(1, 1814, '\p{Jg=dalathrish}', ""); +Expect(0, 1814, '\p{^Jg=dalathrish}', ""); +Expect(0, 1814, '\P{Jg=dalathrish}', ""); +Expect(1, 1814, '\P{^Jg=dalathrish}', ""); +Expect(0, 1812, '\p{Jg=dalathrish}', ""); +Expect(1, 1812, '\p{^Jg=dalathrish}', ""); +Expect(1, 1812, '\P{Jg=dalathrish}', ""); +Expect(0, 1812, '\P{^Jg=dalathrish}', ""); +Expect(1, 1814, '\p{Jg=_-Dalath_Rish}', ""); +Expect(0, 1814, '\p{^Jg=_-Dalath_Rish}', ""); +Expect(0, 1814, '\P{Jg=_-Dalath_Rish}', ""); +Expect(1, 1814, '\P{^Jg=_-Dalath_Rish}', ""); +Expect(0, 1812, '\p{Jg=_-Dalath_Rish}', ""); +Expect(1, 1812, '\p{^Jg=_-Dalath_Rish}', ""); +Expect(1, 1812, '\P{Jg=_-Dalath_Rish}', ""); +Expect(0, 1812, '\P{^Jg=_-Dalath_Rish}', ""); +Error('\p{Is_Joining_Group: _/a/dalath-RISH}'); +Error('\P{Is_Joining_Group: _/a/dalath-RISH}'); +Expect(1, 1814, '\p{Is_Joining_Group: dalathrish}', ""); +Expect(0, 1814, '\p{^Is_Joining_Group: dalathrish}', ""); +Expect(0, 1814, '\P{Is_Joining_Group: dalathrish}', ""); +Expect(1, 1814, '\P{^Is_Joining_Group: dalathrish}', ""); +Expect(0, 1812, '\p{Is_Joining_Group: dalathrish}', ""); +Expect(1, 1812, '\p{^Is_Joining_Group: dalathrish}', ""); +Expect(1, 1812, '\P{Is_Joining_Group: dalathrish}', ""); +Expect(0, 1812, '\P{^Is_Joining_Group: dalathrish}', ""); +Expect(1, 1814, '\p{Is_Joining_Group=_-dalathRish}', ""); +Expect(0, 1814, '\p{^Is_Joining_Group=_-dalathRish}', ""); +Expect(0, 1814, '\P{Is_Joining_Group=_-dalathRish}', ""); +Expect(1, 1814, '\P{^Is_Joining_Group=_-dalathRish}', ""); +Expect(0, 1812, '\p{Is_Joining_Group=_-dalathRish}', ""); +Expect(1, 1812, '\p{^Is_Joining_Group=_-dalathRish}', ""); +Expect(1, 1812, '\P{Is_Joining_Group=_-dalathRish}', ""); +Expect(0, 1812, '\P{^Is_Joining_Group=_-dalathRish}', ""); +Error('\p{Is_Jg=Dalath_Rish:=}'); +Error('\P{Is_Jg=Dalath_Rish:=}'); +Expect(1, 1814, '\p{Is_Jg=dalathrish}', ""); +Expect(0, 1814, '\p{^Is_Jg=dalathrish}', ""); +Expect(0, 1814, '\P{Is_Jg=dalathrish}', ""); +Expect(1, 1814, '\P{^Is_Jg=dalathrish}', ""); +Expect(0, 1812, '\p{Is_Jg=dalathrish}', ""); +Expect(1, 1812, '\p{^Is_Jg=dalathrish}', ""); +Expect(1, 1812, '\P{Is_Jg=dalathrish}', ""); +Expect(0, 1812, '\P{^Is_Jg=dalathrish}', ""); +Expect(1, 1814, '\p{Is_Jg=-_dalathRish}', ""); +Expect(0, 1814, '\p{^Is_Jg=-_dalathRish}', ""); +Expect(0, 1814, '\P{Is_Jg=-_dalathRish}', ""); +Expect(1, 1814, '\P{^Is_Jg=-_dalathRish}', ""); +Expect(0, 1812, '\p{Is_Jg=-_dalathRish}', ""); +Expect(1, 1812, '\p{^Is_Jg=-_dalathRish}', ""); +Expect(1, 1812, '\P{Is_Jg=-_dalathRish}', ""); +Expect(0, 1812, '\P{^Is_Jg=-_dalathRish}', ""); +Error('\p{Joining_Group=:= yudh HE}'); +Error('\P{Joining_Group=:= yudh HE}'); +Expect(1, 1822, '\p{Joining_Group=yudhhe}', ""); +Expect(0, 1822, '\p{^Joining_Group=yudhhe}', ""); +Expect(0, 1822, '\P{Joining_Group=yudhhe}', ""); +Expect(1, 1822, '\P{^Joining_Group=yudhhe}', ""); +Expect(0, 1821, '\p{Joining_Group=yudhhe}', ""); +Expect(1, 1821, '\p{^Joining_Group=yudhhe}', ""); +Expect(1, 1821, '\P{Joining_Group=yudhhe}', ""); +Expect(0, 1821, '\P{^Joining_Group=yudhhe}', ""); +Expect(1, 1822, '\p{Joining_Group=-Yudh-HE}', ""); +Expect(0, 1822, '\p{^Joining_Group=-Yudh-HE}', ""); +Expect(0, 1822, '\P{Joining_Group=-Yudh-HE}', ""); +Expect(1, 1822, '\P{^Joining_Group=-Yudh-HE}', ""); +Expect(0, 1821, '\p{Joining_Group=-Yudh-HE}', ""); +Expect(1, 1821, '\p{^Joining_Group=-Yudh-HE}', ""); +Expect(1, 1821, '\P{Joining_Group=-Yudh-HE}', ""); +Expect(0, 1821, '\P{^Joining_Group=-Yudh-HE}', ""); +Error('\p{Jg: /a/ Yudhhe}'); +Error('\P{Jg: /a/ Yudhhe}'); +Expect(1, 1822, '\p{Jg=yudhhe}', ""); +Expect(0, 1822, '\p{^Jg=yudhhe}', ""); +Expect(0, 1822, '\P{Jg=yudhhe}', ""); +Expect(1, 1822, '\P{^Jg=yudhhe}', ""); +Expect(0, 1821, '\p{Jg=yudhhe}', ""); +Expect(1, 1821, '\p{^Jg=yudhhe}', ""); +Expect(1, 1821, '\P{Jg=yudhhe}', ""); +Expect(0, 1821, '\P{^Jg=yudhhe}', ""); +Expect(1, 1822, '\p{Jg= YUDHHe}', ""); +Expect(0, 1822, '\p{^Jg= YUDHHe}', ""); +Expect(0, 1822, '\P{Jg= YUDHHe}', ""); +Expect(1, 1822, '\P{^Jg= YUDHHe}', ""); +Expect(0, 1821, '\p{Jg= YUDHHe}', ""); +Expect(1, 1821, '\p{^Jg= YUDHHe}', ""); +Expect(1, 1821, '\P{Jg= YUDHHe}', ""); +Expect(0, 1821, '\P{^Jg= YUDHHe}', ""); +Error('\p{Is_Joining_Group: -YUDHHE:=}'); +Error('\P{Is_Joining_Group: -YUDHHE:=}'); +Expect(1, 1822, '\p{Is_Joining_Group=yudhhe}', ""); +Expect(0, 1822, '\p{^Is_Joining_Group=yudhhe}', ""); +Expect(0, 1822, '\P{Is_Joining_Group=yudhhe}', ""); +Expect(1, 1822, '\P{^Is_Joining_Group=yudhhe}', ""); +Expect(0, 1821, '\p{Is_Joining_Group=yudhhe}', ""); +Expect(1, 1821, '\p{^Is_Joining_Group=yudhhe}', ""); +Expect(1, 1821, '\P{Is_Joining_Group=yudhhe}', ""); +Expect(0, 1821, '\P{^Is_Joining_Group=yudhhe}', ""); +Expect(1, 1822, '\p{Is_Joining_Group=-Yudh HE}', ""); +Expect(0, 1822, '\p{^Is_Joining_Group=-Yudh HE}', ""); +Expect(0, 1822, '\P{Is_Joining_Group=-Yudh HE}', ""); +Expect(1, 1822, '\P{^Is_Joining_Group=-Yudh HE}', ""); +Expect(0, 1821, '\p{Is_Joining_Group=-Yudh HE}', ""); +Expect(1, 1821, '\p{^Is_Joining_Group=-Yudh HE}', ""); +Expect(1, 1821, '\P{Is_Joining_Group=-Yudh HE}', ""); +Expect(0, 1821, '\P{^Is_Joining_Group=-Yudh HE}', ""); +Error('\p{Is_Jg: := YUDH He}'); +Error('\P{Is_Jg: := YUDH He}'); +Expect(1, 1822, '\p{Is_Jg=yudhhe}', ""); +Expect(0, 1822, '\p{^Is_Jg=yudhhe}', ""); +Expect(0, 1822, '\P{Is_Jg=yudhhe}', ""); +Expect(1, 1822, '\P{^Is_Jg=yudhhe}', ""); +Expect(0, 1821, '\p{Is_Jg=yudhhe}', ""); +Expect(1, 1821, '\p{^Is_Jg=yudhhe}', ""); +Expect(1, 1821, '\P{Is_Jg=yudhhe}', ""); +Expect(0, 1821, '\P{^Is_Jg=yudhhe}', ""); +Expect(1, 1822, '\p{Is_Jg= yudh-he}', ""); +Expect(0, 1822, '\p{^Is_Jg= yudh-he}', ""); +Expect(0, 1822, '\P{Is_Jg= yudh-he}', ""); +Expect(1, 1822, '\P{^Is_Jg= yudh-he}', ""); +Expect(0, 1821, '\p{Is_Jg= yudh-he}', ""); +Expect(1, 1821, '\p{^Is_Jg= yudh-he}', ""); +Expect(1, 1821, '\P{Is_Jg= yudh-he}', ""); +Expect(0, 1821, '\P{^Is_Jg= yudh-he}', ""); +Error('\p{Joining_Group= /a/NOON}'); +Error('\P{Joining_Group= /a/NOON}'); +Expect(1, 1606, '\p{Joining_Group=noon}', ""); +Expect(0, 1606, '\p{^Joining_Group=noon}', ""); +Expect(0, 1606, '\P{Joining_Group=noon}', ""); +Expect(1, 1606, '\P{^Joining_Group=noon}', ""); +Expect(0, 1605, '\p{Joining_Group=noon}', ""); +Expect(1, 1605, '\p{^Joining_Group=noon}', ""); +Expect(1, 1605, '\P{Joining_Group=noon}', ""); +Expect(0, 1605, '\P{^Joining_Group=noon}', ""); +Expect(1, 1606, '\p{Joining_Group=- noon}', ""); +Expect(0, 1606, '\p{^Joining_Group=- noon}', ""); +Expect(0, 1606, '\P{Joining_Group=- noon}', ""); +Expect(1, 1606, '\P{^Joining_Group=- noon}', ""); +Expect(0, 1605, '\p{Joining_Group=- noon}', ""); +Expect(1, 1605, '\p{^Joining_Group=- noon}', ""); +Expect(1, 1605, '\P{Joining_Group=- noon}', ""); +Expect(0, 1605, '\P{^Joining_Group=- noon}', ""); +Error('\p{Jg=:= Noon}'); +Error('\P{Jg=:= Noon}'); +Expect(1, 1606, '\p{Jg=noon}', ""); +Expect(0, 1606, '\p{^Jg=noon}', ""); +Expect(0, 1606, '\P{Jg=noon}', ""); +Expect(1, 1606, '\P{^Jg=noon}', ""); +Expect(0, 1605, '\p{Jg=noon}', ""); +Expect(1, 1605, '\p{^Jg=noon}', ""); +Expect(1, 1605, '\P{Jg=noon}', ""); +Expect(0, 1605, '\P{^Jg=noon}', ""); +Expect(1, 1606, '\p{Jg=-noon}', ""); +Expect(0, 1606, '\p{^Jg=-noon}', ""); +Expect(0, 1606, '\P{Jg=-noon}', ""); +Expect(1, 1606, '\P{^Jg=-noon}', ""); +Expect(0, 1605, '\p{Jg=-noon}', ""); +Expect(1, 1605, '\p{^Jg=-noon}', ""); +Expect(1, 1605, '\P{Jg=-noon}', ""); +Expect(0, 1605, '\P{^Jg=-noon}', ""); +Error('\p{Is_Joining_Group: :=_-NOON}'); +Error('\P{Is_Joining_Group: :=_-NOON}'); +Expect(1, 1606, '\p{Is_Joining_Group=noon}', ""); +Expect(0, 1606, '\p{^Is_Joining_Group=noon}', ""); +Expect(0, 1606, '\P{Is_Joining_Group=noon}', ""); +Expect(1, 1606, '\P{^Is_Joining_Group=noon}', ""); +Expect(0, 1605, '\p{Is_Joining_Group=noon}', ""); +Expect(1, 1605, '\p{^Is_Joining_Group=noon}', ""); +Expect(1, 1605, '\P{Is_Joining_Group=noon}', ""); +Expect(0, 1605, '\P{^Is_Joining_Group=noon}', ""); +Expect(1, 1606, '\p{Is_Joining_Group=_Noon}', ""); +Expect(0, 1606, '\p{^Is_Joining_Group=_Noon}', ""); +Expect(0, 1606, '\P{Is_Joining_Group=_Noon}', ""); +Expect(1, 1606, '\P{^Is_Joining_Group=_Noon}', ""); +Expect(0, 1605, '\p{Is_Joining_Group=_Noon}', ""); +Expect(1, 1605, '\p{^Is_Joining_Group=_Noon}', ""); +Expect(1, 1605, '\P{Is_Joining_Group=_Noon}', ""); +Expect(0, 1605, '\P{^Is_Joining_Group=_Noon}', ""); +Error('\p{Is_Jg= -Noon:=}'); +Error('\P{Is_Jg= -Noon:=}'); +Expect(1, 1606, '\p{Is_Jg=noon}', ""); +Expect(0, 1606, '\p{^Is_Jg=noon}', ""); +Expect(0, 1606, '\P{Is_Jg=noon}', ""); +Expect(1, 1606, '\P{^Is_Jg=noon}', ""); +Expect(0, 1605, '\p{Is_Jg=noon}', ""); +Expect(1, 1605, '\p{^Is_Jg=noon}', ""); +Expect(1, 1605, '\P{Is_Jg=noon}', ""); +Expect(0, 1605, '\P{^Is_Jg=noon}', ""); +Expect(1, 1606, '\p{Is_Jg=__noon}', ""); +Expect(0, 1606, '\p{^Is_Jg=__noon}', ""); +Expect(0, 1606, '\P{Is_Jg=__noon}', ""); +Expect(1, 1606, '\P{^Is_Jg=__noon}', ""); +Expect(0, 1605, '\p{Is_Jg=__noon}', ""); +Expect(1, 1605, '\p{^Is_Jg=__noon}', ""); +Expect(1, 1605, '\P{Is_Jg=__noon}', ""); +Expect(0, 1605, '\P{^Is_Jg=__noon}', ""); +Error('\p{Joining_Group=/a/-Mim}'); +Error('\P{Joining_Group=/a/-Mim}'); +Expect(1, 1825, '\p{Joining_Group=mim}', ""); +Expect(0, 1825, '\p{^Joining_Group=mim}', ""); +Expect(0, 1825, '\P{Joining_Group=mim}', ""); +Expect(1, 1825, '\P{^Joining_Group=mim}', ""); +Expect(0, 1824, '\p{Joining_Group=mim}', ""); +Expect(1, 1824, '\p{^Joining_Group=mim}', ""); +Expect(1, 1824, '\P{Joining_Group=mim}', ""); +Expect(0, 1824, '\P{^Joining_Group=mim}', ""); +Expect(1, 1825, '\p{Joining_Group=-_Mim}', ""); +Expect(0, 1825, '\p{^Joining_Group=-_Mim}', ""); +Expect(0, 1825, '\P{Joining_Group=-_Mim}', ""); +Expect(1, 1825, '\P{^Joining_Group=-_Mim}', ""); +Expect(0, 1824, '\p{Joining_Group=-_Mim}', ""); +Expect(1, 1824, '\p{^Joining_Group=-_Mim}', ""); +Expect(1, 1824, '\P{Joining_Group=-_Mim}', ""); +Expect(0, 1824, '\P{^Joining_Group=-_Mim}', ""); +Error('\p{Jg= _Mim/a/}'); +Error('\P{Jg= _Mim/a/}'); +Expect(1, 1825, '\p{Jg=mim}', ""); +Expect(0, 1825, '\p{^Jg=mim}', ""); +Expect(0, 1825, '\P{Jg=mim}', ""); +Expect(1, 1825, '\P{^Jg=mim}', ""); +Expect(0, 1824, '\p{Jg=mim}', ""); +Expect(1, 1824, '\p{^Jg=mim}', ""); +Expect(1, 1824, '\P{Jg=mim}', ""); +Expect(0, 1824, '\P{^Jg=mim}', ""); +Expect(1, 1825, '\p{Jg=_Mim}', ""); +Expect(0, 1825, '\p{^Jg=_Mim}', ""); +Expect(0, 1825, '\P{Jg=_Mim}', ""); +Expect(1, 1825, '\P{^Jg=_Mim}', ""); +Expect(0, 1824, '\p{Jg=_Mim}', ""); +Expect(1, 1824, '\p{^Jg=_Mim}', ""); +Expect(1, 1824, '\P{Jg=_Mim}', ""); +Expect(0, 1824, '\P{^Jg=_Mim}', ""); +Error('\p{Is_Joining_Group: -Mim/a/}'); +Error('\P{Is_Joining_Group: -Mim/a/}'); +Expect(1, 1825, '\p{Is_Joining_Group=mim}', ""); +Expect(0, 1825, '\p{^Is_Joining_Group=mim}', ""); +Expect(0, 1825, '\P{Is_Joining_Group=mim}', ""); +Expect(1, 1825, '\P{^Is_Joining_Group=mim}', ""); +Expect(0, 1824, '\p{Is_Joining_Group=mim}', ""); +Expect(1, 1824, '\p{^Is_Joining_Group=mim}', ""); +Expect(1, 1824, '\P{Is_Joining_Group=mim}', ""); +Expect(0, 1824, '\P{^Is_Joining_Group=mim}', ""); +Expect(1, 1825, '\p{Is_Joining_Group=- Mim}', ""); +Expect(0, 1825, '\p{^Is_Joining_Group=- Mim}', ""); +Expect(0, 1825, '\P{Is_Joining_Group=- Mim}', ""); +Expect(1, 1825, '\P{^Is_Joining_Group=- Mim}', ""); +Expect(0, 1824, '\p{Is_Joining_Group=- Mim}', ""); +Expect(1, 1824, '\p{^Is_Joining_Group=- Mim}', ""); +Expect(1, 1824, '\P{Is_Joining_Group=- Mim}', ""); +Expect(0, 1824, '\P{^Is_Joining_Group=- Mim}', ""); +Error('\p{Is_Jg=/a/ -Mim}'); +Error('\P{Is_Jg=/a/ -Mim}'); +Expect(1, 1825, '\p{Is_Jg=mim}', ""); +Expect(0, 1825, '\p{^Is_Jg=mim}', ""); +Expect(0, 1825, '\P{Is_Jg=mim}', ""); +Expect(1, 1825, '\P{^Is_Jg=mim}', ""); +Expect(0, 1824, '\p{Is_Jg=mim}', ""); +Expect(1, 1824, '\p{^Is_Jg=mim}', ""); +Expect(1, 1824, '\P{Is_Jg=mim}', ""); +Expect(0, 1824, '\P{^Is_Jg=mim}', ""); +Expect(1, 1825, '\p{Is_Jg: _Mim}', ""); +Expect(0, 1825, '\p{^Is_Jg: _Mim}', ""); +Expect(0, 1825, '\P{Is_Jg: _Mim}', ""); +Expect(1, 1825, '\P{^Is_Jg: _Mim}', ""); +Expect(0, 1824, '\p{Is_Jg: _Mim}', ""); +Expect(1, 1824, '\p{^Is_Jg: _Mim}', ""); +Expect(1, 1824, '\P{Is_Jg: _Mim}', ""); +Expect(0, 1824, '\P{^Is_Jg: _Mim}', ""); +Error('\p{Joining_Group= /a/Heh_GOAL}'); +Error('\P{Joining_Group= /a/Heh_GOAL}'); +Expect(1, 1730, '\p{Joining_Group=hehgoal}', ""); +Expect(0, 1730, '\p{^Joining_Group=hehgoal}', ""); +Expect(0, 1730, '\P{Joining_Group=hehgoal}', ""); +Expect(1, 1730, '\P{^Joining_Group=hehgoal}', ""); +Expect(0, 1728, '\p{Joining_Group=hehgoal}', ""); +Expect(1, 1728, '\p{^Joining_Group=hehgoal}', ""); +Expect(1, 1728, '\P{Joining_Group=hehgoal}', ""); +Expect(0, 1728, '\P{^Joining_Group=hehgoal}', ""); +Expect(1, 1730, '\p{Joining_Group:_ Heh Goal}', ""); +Expect(0, 1730, '\p{^Joining_Group:_ Heh Goal}', ""); +Expect(0, 1730, '\P{Joining_Group:_ Heh Goal}', ""); +Expect(1, 1730, '\P{^Joining_Group:_ Heh Goal}', ""); +Expect(0, 1728, '\p{Joining_Group:_ Heh Goal}', ""); +Expect(1, 1728, '\p{^Joining_Group:_ Heh Goal}', ""); +Expect(1, 1728, '\P{Joining_Group:_ Heh Goal}', ""); +Expect(0, 1728, '\P{^Joining_Group:_ Heh Goal}', ""); +Error('\p{Jg=-:=HEH Goal}'); +Error('\P{Jg=-:=HEH Goal}'); +Expect(1, 1730, '\p{Jg=hehgoal}', ""); +Expect(0, 1730, '\p{^Jg=hehgoal}', ""); +Expect(0, 1730, '\P{Jg=hehgoal}', ""); +Expect(1, 1730, '\P{^Jg=hehgoal}', ""); +Expect(0, 1728, '\p{Jg=hehgoal}', ""); +Expect(1, 1728, '\p{^Jg=hehgoal}', ""); +Expect(1, 1728, '\P{Jg=hehgoal}', ""); +Expect(0, 1728, '\P{^Jg=hehgoal}', ""); +Expect(1, 1730, '\p{Jg: HEHGoal}', ""); +Expect(0, 1730, '\p{^Jg: HEHGoal}', ""); +Expect(0, 1730, '\P{Jg: HEHGoal}', ""); +Expect(1, 1730, '\P{^Jg: HEHGoal}', ""); +Expect(0, 1728, '\p{Jg: HEHGoal}', ""); +Expect(1, 1728, '\p{^Jg: HEHGoal}', ""); +Expect(1, 1728, '\P{Jg: HEHGoal}', ""); +Expect(0, 1728, '\P{^Jg: HEHGoal}', ""); +Error('\p{Is_Joining_Group: :=HEH GOAL}'); +Error('\P{Is_Joining_Group: :=HEH GOAL}'); +Expect(1, 1730, '\p{Is_Joining_Group=hehgoal}', ""); +Expect(0, 1730, '\p{^Is_Joining_Group=hehgoal}', ""); +Expect(0, 1730, '\P{Is_Joining_Group=hehgoal}', ""); +Expect(1, 1730, '\P{^Is_Joining_Group=hehgoal}', ""); +Expect(0, 1728, '\p{Is_Joining_Group=hehgoal}', ""); +Expect(1, 1728, '\p{^Is_Joining_Group=hehgoal}', ""); +Expect(1, 1728, '\P{Is_Joining_Group=hehgoal}', ""); +Expect(0, 1728, '\P{^Is_Joining_Group=hehgoal}', ""); +Expect(1, 1730, '\p{Is_Joining_Group= -Hehgoal}', ""); +Expect(0, 1730, '\p{^Is_Joining_Group= -Hehgoal}', ""); +Expect(0, 1730, '\P{Is_Joining_Group= -Hehgoal}', ""); +Expect(1, 1730, '\P{^Is_Joining_Group= -Hehgoal}', ""); +Expect(0, 1728, '\p{Is_Joining_Group= -Hehgoal}', ""); +Expect(1, 1728, '\p{^Is_Joining_Group= -Hehgoal}', ""); +Expect(1, 1728, '\P{Is_Joining_Group= -Hehgoal}', ""); +Expect(0, 1728, '\P{^Is_Joining_Group= -Hehgoal}', ""); +Error('\p{Is_Jg=/a/ _Heh goal}'); +Error('\P{Is_Jg=/a/ _Heh goal}'); +Expect(1, 1730, '\p{Is_Jg=hehgoal}', ""); +Expect(0, 1730, '\p{^Is_Jg=hehgoal}', ""); +Expect(0, 1730, '\P{Is_Jg=hehgoal}', ""); +Expect(1, 1730, '\P{^Is_Jg=hehgoal}', ""); +Expect(0, 1728, '\p{Is_Jg=hehgoal}', ""); +Expect(1, 1728, '\p{^Is_Jg=hehgoal}', ""); +Expect(1, 1728, '\P{Is_Jg=hehgoal}', ""); +Expect(0, 1728, '\P{^Is_Jg=hehgoal}', ""); +Expect(1, 1730, '\p{Is_Jg= Heh_goal}', ""); +Expect(0, 1730, '\p{^Is_Jg= Heh_goal}', ""); +Expect(0, 1730, '\P{Is_Jg= Heh_goal}', ""); +Expect(1, 1730, '\P{^Is_Jg= Heh_goal}', ""); +Expect(0, 1728, '\p{Is_Jg= Heh_goal}', ""); +Expect(1, 1728, '\p{^Is_Jg= Heh_goal}', ""); +Expect(1, 1728, '\P{Is_Jg= Heh_goal}', ""); +Expect(0, 1728, '\P{^Is_Jg= Heh_goal}', ""); +Error('\p{Joining_Group=_/a/KHAPH}'); +Error('\P{Joining_Group=_/a/KHAPH}'); +Expect(1, 1870, '\p{Joining_Group=khaph}', ""); +Expect(0, 1870, '\p{^Joining_Group=khaph}', ""); +Expect(0, 1870, '\P{Joining_Group=khaph}', ""); +Expect(1, 1870, '\P{^Joining_Group=khaph}', ""); +Expect(0, 1869, '\p{Joining_Group=khaph}', ""); +Expect(1, 1869, '\p{^Joining_Group=khaph}', ""); +Expect(1, 1869, '\P{Joining_Group=khaph}', ""); +Expect(0, 1869, '\P{^Joining_Group=khaph}', ""); +Expect(1, 1870, '\p{Joining_Group= Khaph}', ""); +Expect(0, 1870, '\p{^Joining_Group= Khaph}', ""); +Expect(0, 1870, '\P{Joining_Group= Khaph}', ""); +Expect(1, 1870, '\P{^Joining_Group= Khaph}', ""); +Expect(0, 1869, '\p{Joining_Group= Khaph}', ""); +Expect(1, 1869, '\p{^Joining_Group= Khaph}', ""); +Expect(1, 1869, '\P{Joining_Group= Khaph}', ""); +Expect(0, 1869, '\P{^Joining_Group= Khaph}', ""); +Error('\p{Jg= _KHAPH:=}'); +Error('\P{Jg= _KHAPH:=}'); +Expect(1, 1870, '\p{Jg=khaph}', ""); +Expect(0, 1870, '\p{^Jg=khaph}', ""); +Expect(0, 1870, '\P{Jg=khaph}', ""); +Expect(1, 1870, '\P{^Jg=khaph}', ""); +Expect(0, 1869, '\p{Jg=khaph}', ""); +Expect(1, 1869, '\p{^Jg=khaph}', ""); +Expect(1, 1869, '\P{Jg=khaph}', ""); +Expect(0, 1869, '\P{^Jg=khaph}', ""); +Expect(1, 1870, '\p{Jg=- khaph}', ""); +Expect(0, 1870, '\p{^Jg=- khaph}', ""); +Expect(0, 1870, '\P{Jg=- khaph}', ""); +Expect(1, 1870, '\P{^Jg=- khaph}', ""); +Expect(0, 1869, '\p{Jg=- khaph}', ""); +Expect(1, 1869, '\p{^Jg=- khaph}', ""); +Expect(1, 1869, '\P{Jg=- khaph}', ""); +Expect(0, 1869, '\P{^Jg=- khaph}', ""); +Error('\p{Is_Joining_Group= khaph:=}'); +Error('\P{Is_Joining_Group= khaph:=}'); +Expect(1, 1870, '\p{Is_Joining_Group=khaph}', ""); +Expect(0, 1870, '\p{^Is_Joining_Group=khaph}', ""); +Expect(0, 1870, '\P{Is_Joining_Group=khaph}', ""); +Expect(1, 1870, '\P{^Is_Joining_Group=khaph}', ""); +Expect(0, 1869, '\p{Is_Joining_Group=khaph}', ""); +Expect(1, 1869, '\p{^Is_Joining_Group=khaph}', ""); +Expect(1, 1869, '\P{Is_Joining_Group=khaph}', ""); +Expect(0, 1869, '\P{^Is_Joining_Group=khaph}', ""); +Expect(1, 1870, '\p{Is_Joining_Group:_-Khaph}', ""); +Expect(0, 1870, '\p{^Is_Joining_Group:_-Khaph}', ""); +Expect(0, 1870, '\P{Is_Joining_Group:_-Khaph}', ""); +Expect(1, 1870, '\P{^Is_Joining_Group:_-Khaph}', ""); +Expect(0, 1869, '\p{Is_Joining_Group:_-Khaph}', ""); +Expect(1, 1869, '\p{^Is_Joining_Group:_-Khaph}', ""); +Expect(1, 1869, '\P{Is_Joining_Group:_-Khaph}', ""); +Expect(0, 1869, '\P{^Is_Joining_Group:_-Khaph}', ""); +Error('\p{Is_Jg=_:=Khaph}'); +Error('\P{Is_Jg=_:=Khaph}'); +Expect(1, 1870, '\p{Is_Jg=khaph}', ""); +Expect(0, 1870, '\p{^Is_Jg=khaph}', ""); +Expect(0, 1870, '\P{Is_Jg=khaph}', ""); +Expect(1, 1870, '\P{^Is_Jg=khaph}', ""); +Expect(0, 1869, '\p{Is_Jg=khaph}', ""); +Expect(1, 1869, '\p{^Is_Jg=khaph}', ""); +Expect(1, 1869, '\P{Is_Jg=khaph}', ""); +Expect(0, 1869, '\P{^Is_Jg=khaph}', ""); +Expect(1, 1870, '\p{Is_Jg= -Khaph}', ""); +Expect(0, 1870, '\p{^Is_Jg= -Khaph}', ""); +Expect(0, 1870, '\P{Is_Jg= -Khaph}', ""); +Expect(1, 1870, '\P{^Is_Jg= -Khaph}', ""); +Expect(0, 1869, '\p{Is_Jg= -Khaph}', ""); +Expect(1, 1869, '\p{^Is_Jg= -Khaph}', ""); +Expect(1, 1869, '\P{Is_Jg= -Khaph}', ""); +Expect(0, 1869, '\P{^Is_Jg= -Khaph}', ""); +Error('\p{Joining_Group=--Sad:=}'); +Error('\P{Joining_Group=--Sad:=}'); +Expect(1, 1590, '\p{Joining_Group=sad}', ""); +Expect(0, 1590, '\p{^Joining_Group=sad}', ""); +Expect(0, 1590, '\P{Joining_Group=sad}', ""); +Expect(1, 1590, '\P{^Joining_Group=sad}', ""); +Expect(0, 1588, '\p{Joining_Group=sad}', ""); +Expect(1, 1588, '\p{^Joining_Group=sad}', ""); +Expect(1, 1588, '\P{Joining_Group=sad}', ""); +Expect(0, 1588, '\P{^Joining_Group=sad}', ""); +Expect(1, 1590, '\p{Joining_Group= SAD}', ""); +Expect(0, 1590, '\p{^Joining_Group= SAD}', ""); +Expect(0, 1590, '\P{Joining_Group= SAD}', ""); +Expect(1, 1590, '\P{^Joining_Group= SAD}', ""); +Expect(0, 1588, '\p{Joining_Group= SAD}', ""); +Expect(1, 1588, '\p{^Joining_Group= SAD}', ""); +Expect(1, 1588, '\P{Joining_Group= SAD}', ""); +Expect(0, 1588, '\P{^Joining_Group= SAD}', ""); +Error('\p{Jg= :=sad}'); +Error('\P{Jg= :=sad}'); +Expect(1, 1590, '\p{Jg=sad}', ""); +Expect(0, 1590, '\p{^Jg=sad}', ""); +Expect(0, 1590, '\P{Jg=sad}', ""); +Expect(1, 1590, '\P{^Jg=sad}', ""); +Expect(0, 1588, '\p{Jg=sad}', ""); +Expect(1, 1588, '\p{^Jg=sad}', ""); +Expect(1, 1588, '\P{Jg=sad}', ""); +Expect(0, 1588, '\P{^Jg=sad}', ""); +Expect(1, 1590, '\p{Jg:_Sad}', ""); +Expect(0, 1590, '\p{^Jg:_Sad}', ""); +Expect(0, 1590, '\P{Jg:_Sad}', ""); +Expect(1, 1590, '\P{^Jg:_Sad}', ""); +Expect(0, 1588, '\p{Jg:_Sad}', ""); +Expect(1, 1588, '\p{^Jg:_Sad}', ""); +Expect(1, 1588, '\P{Jg:_Sad}', ""); +Expect(0, 1588, '\P{^Jg:_Sad}', ""); +Error('\p{Is_Joining_Group=_sad/a/}'); +Error('\P{Is_Joining_Group=_sad/a/}'); +Expect(1, 1590, '\p{Is_Joining_Group=sad}', ""); +Expect(0, 1590, '\p{^Is_Joining_Group=sad}', ""); +Expect(0, 1590, '\P{Is_Joining_Group=sad}', ""); +Expect(1, 1590, '\P{^Is_Joining_Group=sad}', ""); +Expect(0, 1588, '\p{Is_Joining_Group=sad}', ""); +Expect(1, 1588, '\p{^Is_Joining_Group=sad}', ""); +Expect(1, 1588, '\P{Is_Joining_Group=sad}', ""); +Expect(0, 1588, '\P{^Is_Joining_Group=sad}', ""); +Expect(1, 1590, '\p{Is_Joining_Group=--sad}', ""); +Expect(0, 1590, '\p{^Is_Joining_Group=--sad}', ""); +Expect(0, 1590, '\P{Is_Joining_Group=--sad}', ""); +Expect(1, 1590, '\P{^Is_Joining_Group=--sad}', ""); +Expect(0, 1588, '\p{Is_Joining_Group=--sad}', ""); +Expect(1, 1588, '\p{^Is_Joining_Group=--sad}', ""); +Expect(1, 1588, '\P{Is_Joining_Group=--sad}', ""); +Expect(0, 1588, '\P{^Is_Joining_Group=--sad}', ""); +Error('\p{Is_Jg=/a/ SAD}'); +Error('\P{Is_Jg=/a/ SAD}'); +Expect(1, 1590, '\p{Is_Jg=sad}', ""); +Expect(0, 1590, '\p{^Is_Jg=sad}', ""); +Expect(0, 1590, '\P{Is_Jg=sad}', ""); +Expect(1, 1590, '\P{^Is_Jg=sad}', ""); +Expect(0, 1588, '\p{Is_Jg=sad}', ""); +Expect(1, 1588, '\p{^Is_Jg=sad}', ""); +Expect(1, 1588, '\P{Is_Jg=sad}', ""); +Expect(0, 1588, '\P{^Is_Jg=sad}', ""); +Expect(1, 1590, '\p{Is_Jg=-Sad}', ""); +Expect(0, 1590, '\p{^Is_Jg=-Sad}', ""); +Expect(0, 1590, '\P{Is_Jg=-Sad}', ""); +Expect(1, 1590, '\P{^Is_Jg=-Sad}', ""); +Expect(0, 1588, '\p{Is_Jg=-Sad}', ""); +Expect(1, 1588, '\p{^Is_Jg=-Sad}', ""); +Expect(1, 1588, '\P{Is_Jg=-Sad}', ""); +Expect(0, 1588, '\P{^Is_Jg=-Sad}', ""); +Error('\p{Joining_Group=__qaf/a/}'); +Error('\P{Joining_Group=__qaf/a/}'); +Expect(1, 1602, '\p{Joining_Group=qaf}', ""); +Expect(0, 1602, '\p{^Joining_Group=qaf}', ""); +Expect(0, 1602, '\P{Joining_Group=qaf}', ""); +Expect(1, 1602, '\P{^Joining_Group=qaf}', ""); +Expect(0, 1601, '\p{Joining_Group=qaf}', ""); +Expect(1, 1601, '\p{^Joining_Group=qaf}', ""); +Expect(1, 1601, '\P{Joining_Group=qaf}', ""); +Expect(0, 1601, '\P{^Joining_Group=qaf}', ""); +Expect(1, 1602, '\p{Joining_Group= QAF}', ""); +Expect(0, 1602, '\p{^Joining_Group= QAF}', ""); +Expect(0, 1602, '\P{Joining_Group= QAF}', ""); +Expect(1, 1602, '\P{^Joining_Group= QAF}', ""); +Expect(0, 1601, '\p{Joining_Group= QAF}', ""); +Expect(1, 1601, '\p{^Joining_Group= QAF}', ""); +Expect(1, 1601, '\P{Joining_Group= QAF}', ""); +Expect(0, 1601, '\P{^Joining_Group= QAF}', ""); +Error('\p{Jg=/a/qaf}'); +Error('\P{Jg=/a/qaf}'); +Expect(1, 1602, '\p{Jg: qaf}', ""); +Expect(0, 1602, '\p{^Jg: qaf}', ""); +Expect(0, 1602, '\P{Jg: qaf}', ""); +Expect(1, 1602, '\P{^Jg: qaf}', ""); +Expect(0, 1601, '\p{Jg: qaf}', ""); +Expect(1, 1601, '\p{^Jg: qaf}', ""); +Expect(1, 1601, '\P{Jg: qaf}', ""); +Expect(0, 1601, '\P{^Jg: qaf}', ""); +Expect(1, 1602, '\p{Jg=Qaf}', ""); +Expect(0, 1602, '\p{^Jg=Qaf}', ""); +Expect(0, 1602, '\P{Jg=Qaf}', ""); +Expect(1, 1602, '\P{^Jg=Qaf}', ""); +Expect(0, 1601, '\p{Jg=Qaf}', ""); +Expect(1, 1601, '\p{^Jg=Qaf}', ""); +Expect(1, 1601, '\P{Jg=Qaf}', ""); +Expect(0, 1601, '\P{^Jg=Qaf}', ""); +Error('\p{Is_Joining_Group=/a/ QAF}'); +Error('\P{Is_Joining_Group=/a/ QAF}'); +Expect(1, 1602, '\p{Is_Joining_Group=qaf}', ""); +Expect(0, 1602, '\p{^Is_Joining_Group=qaf}', ""); +Expect(0, 1602, '\P{Is_Joining_Group=qaf}', ""); +Expect(1, 1602, '\P{^Is_Joining_Group=qaf}', ""); +Expect(0, 1601, '\p{Is_Joining_Group=qaf}', ""); +Expect(1, 1601, '\p{^Is_Joining_Group=qaf}', ""); +Expect(1, 1601, '\P{Is_Joining_Group=qaf}', ""); +Expect(0, 1601, '\P{^Is_Joining_Group=qaf}', ""); +Expect(1, 1602, '\p{Is_Joining_Group=_-qaf}', ""); +Expect(0, 1602, '\p{^Is_Joining_Group=_-qaf}', ""); +Expect(0, 1602, '\P{Is_Joining_Group=_-qaf}', ""); +Expect(1, 1602, '\P{^Is_Joining_Group=_-qaf}', ""); +Expect(0, 1601, '\p{Is_Joining_Group=_-qaf}', ""); +Expect(1, 1601, '\p{^Is_Joining_Group=_-qaf}', ""); +Expect(1, 1601, '\P{Is_Joining_Group=_-qaf}', ""); +Expect(0, 1601, '\P{^Is_Joining_Group=_-qaf}', ""); +Error('\p{Is_Jg=:= _qaf}'); +Error('\P{Is_Jg=:= _qaf}'); +Expect(1, 1602, '\p{Is_Jg=qaf}', ""); +Expect(0, 1602, '\p{^Is_Jg=qaf}', ""); +Expect(0, 1602, '\P{Is_Jg=qaf}', ""); +Expect(1, 1602, '\P{^Is_Jg=qaf}', ""); +Expect(0, 1601, '\p{Is_Jg=qaf}', ""); +Expect(1, 1601, '\p{^Is_Jg=qaf}', ""); +Expect(1, 1601, '\P{Is_Jg=qaf}', ""); +Expect(0, 1601, '\P{^Is_Jg=qaf}', ""); +Expect(1, 1602, '\p{Is_Jg=_ Qaf}', ""); +Expect(0, 1602, '\p{^Is_Jg=_ Qaf}', ""); +Expect(0, 1602, '\P{Is_Jg=_ Qaf}', ""); +Expect(1, 1602, '\P{^Is_Jg=_ Qaf}', ""); +Expect(0, 1601, '\p{Is_Jg=_ Qaf}', ""); +Expect(1, 1601, '\p{^Is_Jg=_ Qaf}', ""); +Expect(1, 1601, '\P{Is_Jg=_ Qaf}', ""); +Expect(0, 1601, '\P{^Is_Jg=_ Qaf}', ""); +Error('\p{Joining_Group=-/a/Kaph}'); +Error('\P{Joining_Group=-/a/Kaph}'); +Expect(1, 1823, '\p{Joining_Group=kaph}', ""); +Expect(0, 1823, '\p{^Joining_Group=kaph}', ""); +Expect(0, 1823, '\P{Joining_Group=kaph}', ""); +Expect(1, 1823, '\P{^Joining_Group=kaph}', ""); +Expect(0, 1822, '\p{Joining_Group=kaph}', ""); +Expect(1, 1822, '\p{^Joining_Group=kaph}', ""); +Expect(1, 1822, '\P{Joining_Group=kaph}', ""); +Expect(0, 1822, '\P{^Joining_Group=kaph}', ""); +Expect(1, 1823, '\p{Joining_Group=_ Kaph}', ""); +Expect(0, 1823, '\p{^Joining_Group=_ Kaph}', ""); +Expect(0, 1823, '\P{Joining_Group=_ Kaph}', ""); +Expect(1, 1823, '\P{^Joining_Group=_ Kaph}', ""); +Expect(0, 1822, '\p{Joining_Group=_ Kaph}', ""); +Expect(1, 1822, '\p{^Joining_Group=_ Kaph}', ""); +Expect(1, 1822, '\P{Joining_Group=_ Kaph}', ""); +Expect(0, 1822, '\P{^Joining_Group=_ Kaph}', ""); +Error('\p{Jg=:=__kaph}'); +Error('\P{Jg=:=__kaph}'); +Expect(1, 1823, '\p{Jg=kaph}', ""); +Expect(0, 1823, '\p{^Jg=kaph}', ""); +Expect(0, 1823, '\P{Jg=kaph}', ""); +Expect(1, 1823, '\P{^Jg=kaph}', ""); +Expect(0, 1822, '\p{Jg=kaph}', ""); +Expect(1, 1822, '\p{^Jg=kaph}', ""); +Expect(1, 1822, '\P{Jg=kaph}', ""); +Expect(0, 1822, '\P{^Jg=kaph}', ""); +Expect(1, 1823, '\p{Jg= kaph}', ""); +Expect(0, 1823, '\p{^Jg= kaph}', ""); +Expect(0, 1823, '\P{Jg= kaph}', ""); +Expect(1, 1823, '\P{^Jg= kaph}', ""); +Expect(0, 1822, '\p{Jg= kaph}', ""); +Expect(1, 1822, '\p{^Jg= kaph}', ""); +Expect(1, 1822, '\P{Jg= kaph}', ""); +Expect(0, 1822, '\P{^Jg= kaph}', ""); +Error('\p{Is_Joining_Group=:=-Kaph}'); +Error('\P{Is_Joining_Group=:=-Kaph}'); +Expect(1, 1823, '\p{Is_Joining_Group=kaph}', ""); +Expect(0, 1823, '\p{^Is_Joining_Group=kaph}', ""); +Expect(0, 1823, '\P{Is_Joining_Group=kaph}', ""); +Expect(1, 1823, '\P{^Is_Joining_Group=kaph}', ""); +Expect(0, 1822, '\p{Is_Joining_Group=kaph}', ""); +Expect(1, 1822, '\p{^Is_Joining_Group=kaph}', ""); +Expect(1, 1822, '\P{Is_Joining_Group=kaph}', ""); +Expect(0, 1822, '\P{^Is_Joining_Group=kaph}', ""); +Expect(1, 1823, '\p{Is_Joining_Group=-Kaph}', ""); +Expect(0, 1823, '\p{^Is_Joining_Group=-Kaph}', ""); +Expect(0, 1823, '\P{Is_Joining_Group=-Kaph}', ""); +Expect(1, 1823, '\P{^Is_Joining_Group=-Kaph}', ""); +Expect(0, 1822, '\p{Is_Joining_Group=-Kaph}', ""); +Expect(1, 1822, '\p{^Is_Joining_Group=-Kaph}', ""); +Expect(1, 1822, '\P{Is_Joining_Group=-Kaph}', ""); +Expect(0, 1822, '\P{^Is_Joining_Group=-Kaph}', ""); +Error('\p{Is_Jg=/a/ Kaph}'); +Error('\P{Is_Jg=/a/ Kaph}'); +Expect(1, 1823, '\p{Is_Jg=kaph}', ""); +Expect(0, 1823, '\p{^Is_Jg=kaph}', ""); +Expect(0, 1823, '\P{Is_Jg=kaph}', ""); +Expect(1, 1823, '\P{^Is_Jg=kaph}', ""); +Expect(0, 1822, '\p{Is_Jg=kaph}', ""); +Expect(1, 1822, '\p{^Is_Jg=kaph}', ""); +Expect(1, 1822, '\P{Is_Jg=kaph}', ""); +Expect(0, 1822, '\P{^Is_Jg=kaph}', ""); +Expect(1, 1823, '\p{Is_Jg=_Kaph}', ""); +Expect(0, 1823, '\p{^Is_Jg=_Kaph}', ""); +Expect(0, 1823, '\P{Is_Jg=_Kaph}', ""); +Expect(1, 1823, '\P{^Is_Jg=_Kaph}', ""); +Expect(0, 1822, '\p{Is_Jg=_Kaph}', ""); +Expect(1, 1822, '\p{^Is_Jg=_Kaph}', ""); +Expect(1, 1822, '\P{Is_Jg=_Kaph}', ""); +Expect(0, 1822, '\P{^Is_Jg=_Kaph}', ""); +Error('\p{Joining_Group=:= _feh}'); +Error('\P{Joining_Group=:= _feh}'); +Expect(1, 1601, '\p{Joining_Group=feh}', ""); +Expect(0, 1601, '\p{^Joining_Group=feh}', ""); +Expect(0, 1601, '\P{Joining_Group=feh}', ""); +Expect(1, 1601, '\P{^Joining_Group=feh}', ""); +Expect(0, 1600, '\p{Joining_Group=feh}', ""); +Expect(1, 1600, '\p{^Joining_Group=feh}', ""); +Expect(1, 1600, '\P{Joining_Group=feh}', ""); +Expect(0, 1600, '\P{^Joining_Group=feh}', ""); +Expect(1, 1601, '\p{Joining_Group: feh}', ""); +Expect(0, 1601, '\p{^Joining_Group: feh}', ""); +Expect(0, 1601, '\P{Joining_Group: feh}', ""); +Expect(1, 1601, '\P{^Joining_Group: feh}', ""); +Expect(0, 1600, '\p{Joining_Group: feh}', ""); +Expect(1, 1600, '\p{^Joining_Group: feh}', ""); +Expect(1, 1600, '\P{Joining_Group: feh}', ""); +Expect(0, 1600, '\P{^Joining_Group: feh}', ""); +Error('\p{Jg: :=- Feh}'); +Error('\P{Jg: :=- Feh}'); +Expect(1, 1601, '\p{Jg=feh}', ""); +Expect(0, 1601, '\p{^Jg=feh}', ""); +Expect(0, 1601, '\P{Jg=feh}', ""); +Expect(1, 1601, '\P{^Jg=feh}', ""); +Expect(0, 1600, '\p{Jg=feh}', ""); +Expect(1, 1600, '\p{^Jg=feh}', ""); +Expect(1, 1600, '\P{Jg=feh}', ""); +Expect(0, 1600, '\P{^Jg=feh}', ""); +Expect(1, 1601, '\p{Jg= FEH}', ""); +Expect(0, 1601, '\p{^Jg= FEH}', ""); +Expect(0, 1601, '\P{Jg= FEH}', ""); +Expect(1, 1601, '\P{^Jg= FEH}', ""); +Expect(0, 1600, '\p{Jg= FEH}', ""); +Expect(1, 1600, '\p{^Jg= FEH}', ""); +Expect(1, 1600, '\P{Jg= FEH}', ""); +Expect(0, 1600, '\P{^Jg= FEH}', ""); +Error('\p{Is_Joining_Group=/a/ FEH}'); +Error('\P{Is_Joining_Group=/a/ FEH}'); +Expect(1, 1601, '\p{Is_Joining_Group=feh}', ""); +Expect(0, 1601, '\p{^Is_Joining_Group=feh}', ""); +Expect(0, 1601, '\P{Is_Joining_Group=feh}', ""); +Expect(1, 1601, '\P{^Is_Joining_Group=feh}', ""); +Expect(0, 1600, '\p{Is_Joining_Group=feh}', ""); +Expect(1, 1600, '\p{^Is_Joining_Group=feh}', ""); +Expect(1, 1600, '\P{Is_Joining_Group=feh}', ""); +Expect(0, 1600, '\P{^Is_Joining_Group=feh}', ""); +Expect(1, 1601, '\p{Is_Joining_Group=--Feh}', ""); +Expect(0, 1601, '\p{^Is_Joining_Group=--Feh}', ""); +Expect(0, 1601, '\P{Is_Joining_Group=--Feh}', ""); +Expect(1, 1601, '\P{^Is_Joining_Group=--Feh}', ""); +Expect(0, 1600, '\p{Is_Joining_Group=--Feh}', ""); +Expect(1, 1600, '\p{^Is_Joining_Group=--Feh}', ""); +Expect(1, 1600, '\P{Is_Joining_Group=--Feh}', ""); +Expect(0, 1600, '\P{^Is_Joining_Group=--Feh}', ""); +Error('\p{Is_Jg=-_FEH:=}'); +Error('\P{Is_Jg=-_FEH:=}'); +Expect(1, 1601, '\p{Is_Jg=feh}', ""); +Expect(0, 1601, '\p{^Is_Jg=feh}', ""); +Expect(0, 1601, '\P{Is_Jg=feh}', ""); +Expect(1, 1601, '\P{^Is_Jg=feh}', ""); +Expect(0, 1600, '\p{Is_Jg=feh}', ""); +Expect(1, 1600, '\p{^Is_Jg=feh}', ""); +Expect(1, 1600, '\P{Is_Jg=feh}', ""); +Expect(0, 1600, '\P{^Is_Jg=feh}', ""); +Expect(1, 1601, '\p{Is_Jg=-FEH}', ""); +Expect(0, 1601, '\p{^Is_Jg=-FEH}', ""); +Expect(0, 1601, '\P{Is_Jg=-FEH}', ""); +Expect(1, 1601, '\P{^Is_Jg=-FEH}', ""); +Expect(0, 1600, '\p{Is_Jg=-FEH}', ""); +Expect(1, 1600, '\p{^Is_Jg=-FEH}', ""); +Expect(1, 1600, '\P{Is_Jg=-FEH}', ""); +Expect(0, 1600, '\P{^Is_Jg=-FEH}', ""); +Error('\p{Joining_Group=_ REVERSED:=Pe}'); +Error('\P{Joining_Group=_ REVERSED:=Pe}'); +Expect(1, 1831, '\p{Joining_Group=reversedpe}', ""); +Expect(0, 1831, '\p{^Joining_Group=reversedpe}', ""); +Expect(0, 1831, '\P{Joining_Group=reversedpe}', ""); +Expect(1, 1831, '\P{^Joining_Group=reversedpe}', ""); +Expect(0, 1830, '\p{Joining_Group=reversedpe}', ""); +Expect(1, 1830, '\p{^Joining_Group=reversedpe}', ""); +Expect(1, 1830, '\P{Joining_Group=reversedpe}', ""); +Expect(0, 1830, '\P{^Joining_Group=reversedpe}', ""); +Expect(1, 1831, '\p{Joining_Group=_-Reversed-Pe}', ""); +Expect(0, 1831, '\p{^Joining_Group=_-Reversed-Pe}', ""); +Expect(0, 1831, '\P{Joining_Group=_-Reversed-Pe}', ""); +Expect(1, 1831, '\P{^Joining_Group=_-Reversed-Pe}', ""); +Expect(0, 1830, '\p{Joining_Group=_-Reversed-Pe}', ""); +Expect(1, 1830, '\p{^Joining_Group=_-Reversed-Pe}', ""); +Expect(1, 1830, '\P{Joining_Group=_-Reversed-Pe}', ""); +Expect(0, 1830, '\P{^Joining_Group=_-Reversed-Pe}', ""); +Error('\p{Jg= :=Reversed_pe}'); +Error('\P{Jg= :=Reversed_pe}'); +Expect(1, 1831, '\p{Jg: reversedpe}', ""); +Expect(0, 1831, '\p{^Jg: reversedpe}', ""); +Expect(0, 1831, '\P{Jg: reversedpe}', ""); +Expect(1, 1831, '\P{^Jg: reversedpe}', ""); +Expect(0, 1830, '\p{Jg: reversedpe}', ""); +Expect(1, 1830, '\p{^Jg: reversedpe}', ""); +Expect(1, 1830, '\P{Jg: reversedpe}', ""); +Expect(0, 1830, '\P{^Jg: reversedpe}', ""); +Expect(1, 1831, '\p{Jg: _Reversed pe}', ""); +Expect(0, 1831, '\p{^Jg: _Reversed pe}', ""); +Expect(0, 1831, '\P{Jg: _Reversed pe}', ""); +Expect(1, 1831, '\P{^Jg: _Reversed pe}', ""); +Expect(0, 1830, '\p{Jg: _Reversed pe}', ""); +Expect(1, 1830, '\p{^Jg: _Reversed pe}', ""); +Expect(1, 1830, '\P{Jg: _Reversed pe}', ""); +Expect(0, 1830, '\P{^Jg: _Reversed pe}', ""); +Error('\p{Is_Joining_Group=_Reversed-pe/a/}'); +Error('\P{Is_Joining_Group=_Reversed-pe/a/}'); +Expect(1, 1831, '\p{Is_Joining_Group=reversedpe}', ""); +Expect(0, 1831, '\p{^Is_Joining_Group=reversedpe}', ""); +Expect(0, 1831, '\P{Is_Joining_Group=reversedpe}', ""); +Expect(1, 1831, '\P{^Is_Joining_Group=reversedpe}', ""); +Expect(0, 1830, '\p{Is_Joining_Group=reversedpe}', ""); +Expect(1, 1830, '\p{^Is_Joining_Group=reversedpe}', ""); +Expect(1, 1830, '\P{Is_Joining_Group=reversedpe}', ""); +Expect(0, 1830, '\P{^Is_Joining_Group=reversedpe}', ""); +Expect(1, 1831, '\p{Is_Joining_Group= reversed_PE}', ""); +Expect(0, 1831, '\p{^Is_Joining_Group= reversed_PE}', ""); +Expect(0, 1831, '\P{Is_Joining_Group= reversed_PE}', ""); +Expect(1, 1831, '\P{^Is_Joining_Group= reversed_PE}', ""); +Expect(0, 1830, '\p{Is_Joining_Group= reversed_PE}', ""); +Expect(1, 1830, '\p{^Is_Joining_Group= reversed_PE}', ""); +Expect(1, 1830, '\P{Is_Joining_Group= reversed_PE}', ""); +Expect(0, 1830, '\P{^Is_Joining_Group= reversed_PE}', ""); +Error('\p{Is_Jg= _REVERSED-Pe:=}'); +Error('\P{Is_Jg= _REVERSED-Pe:=}'); +Expect(1, 1831, '\p{Is_Jg=reversedpe}', ""); +Expect(0, 1831, '\p{^Is_Jg=reversedpe}', ""); +Expect(0, 1831, '\P{Is_Jg=reversedpe}', ""); +Expect(1, 1831, '\P{^Is_Jg=reversedpe}', ""); +Expect(0, 1830, '\p{Is_Jg=reversedpe}', ""); +Expect(1, 1830, '\p{^Is_Jg=reversedpe}', ""); +Expect(1, 1830, '\P{Is_Jg=reversedpe}', ""); +Expect(0, 1830, '\P{^Is_Jg=reversedpe}', ""); +Expect(1, 1831, '\p{Is_Jg= Reversed_Pe}', ""); +Expect(0, 1831, '\p{^Is_Jg= Reversed_Pe}', ""); +Expect(0, 1831, '\P{Is_Jg= Reversed_Pe}', ""); +Expect(1, 1831, '\P{^Is_Jg= Reversed_Pe}', ""); +Expect(0, 1830, '\p{Is_Jg= Reversed_Pe}', ""); +Expect(1, 1830, '\p{^Is_Jg= Reversed_Pe}', ""); +Expect(1, 1830, '\P{Is_Jg= Reversed_Pe}', ""); +Expect(0, 1830, '\P{^Is_Jg= Reversed_Pe}', ""); +Error('\p{Joining_Group=-:=SHIN}'); +Error('\P{Joining_Group=-:=SHIN}'); +Expect(1, 1835, '\p{Joining_Group=shin}', ""); +Expect(0, 1835, '\p{^Joining_Group=shin}', ""); +Expect(0, 1835, '\P{Joining_Group=shin}', ""); +Expect(1, 1835, '\P{^Joining_Group=shin}', ""); +Expect(0, 1834, '\p{Joining_Group=shin}', ""); +Expect(1, 1834, '\p{^Joining_Group=shin}', ""); +Expect(1, 1834, '\P{Joining_Group=shin}', ""); +Expect(0, 1834, '\P{^Joining_Group=shin}', ""); +Error('\p{Jg=:=Shin}'); +Error('\P{Jg=:=Shin}'); +Expect(1, 1835, '\p{Jg=shin}', ""); +Expect(0, 1835, '\p{^Jg=shin}', ""); +Expect(0, 1835, '\P{Jg=shin}', ""); +Expect(1, 1835, '\P{^Jg=shin}', ""); +Expect(0, 1834, '\p{Jg=shin}', ""); +Expect(1, 1834, '\p{^Jg=shin}', ""); +Expect(1, 1834, '\P{Jg=shin}', ""); +Expect(0, 1834, '\P{^Jg=shin}', ""); +Expect(1, 1835, '\p{Jg=--shin}', ""); +Expect(0, 1835, '\p{^Jg=--shin}', ""); +Expect(0, 1835, '\P{Jg=--shin}', ""); +Expect(1, 1835, '\P{^Jg=--shin}', ""); +Expect(0, 1834, '\p{Jg=--shin}', ""); +Expect(1, 1834, '\p{^Jg=--shin}', ""); +Expect(1, 1834, '\P{Jg=--shin}', ""); +Expect(0, 1834, '\P{^Jg=--shin}', ""); +Error('\p{Is_Joining_Group=-/a/Shin}'); +Error('\P{Is_Joining_Group=-/a/Shin}'); +Expect(1, 1835, '\p{Is_Joining_Group: shin}', ""); +Expect(0, 1835, '\p{^Is_Joining_Group: shin}', ""); +Expect(0, 1835, '\P{Is_Joining_Group: shin}', ""); +Expect(1, 1835, '\P{^Is_Joining_Group: shin}', ""); +Expect(0, 1834, '\p{Is_Joining_Group: shin}', ""); +Expect(1, 1834, '\p{^Is_Joining_Group: shin}', ""); +Expect(1, 1834, '\P{Is_Joining_Group: shin}', ""); +Expect(0, 1834, '\P{^Is_Joining_Group: shin}', ""); +Expect(1, 1835, '\p{Is_Joining_Group: - Shin}', ""); +Expect(0, 1835, '\p{^Is_Joining_Group: - Shin}', ""); +Expect(0, 1835, '\P{Is_Joining_Group: - Shin}', ""); +Expect(1, 1835, '\P{^Is_Joining_Group: - Shin}', ""); +Expect(0, 1834, '\p{Is_Joining_Group: - Shin}', ""); +Expect(1, 1834, '\p{^Is_Joining_Group: - Shin}', ""); +Expect(1, 1834, '\P{Is_Joining_Group: - Shin}', ""); +Expect(0, 1834, '\P{^Is_Joining_Group: - Shin}', ""); +Error('\p{Is_Jg=-/a/Shin}'); +Error('\P{Is_Jg=-/a/Shin}'); +Expect(1, 1835, '\p{Is_Jg=shin}', ""); +Expect(0, 1835, '\p{^Is_Jg=shin}', ""); +Expect(0, 1835, '\P{Is_Jg=shin}', ""); +Expect(1, 1835, '\P{^Is_Jg=shin}', ""); +Expect(0, 1834, '\p{Is_Jg=shin}', ""); +Expect(1, 1834, '\p{^Is_Jg=shin}', ""); +Expect(1, 1834, '\P{Is_Jg=shin}', ""); +Expect(0, 1834, '\P{^Is_Jg=shin}', ""); +Expect(1, 1835, '\p{Is_Jg: _ Shin}', ""); +Expect(0, 1835, '\p{^Is_Jg: _ Shin}', ""); +Expect(0, 1835, '\P{Is_Jg: _ Shin}', ""); +Expect(1, 1835, '\P{^Is_Jg: _ Shin}', ""); +Expect(0, 1834, '\p{Is_Jg: _ Shin}', ""); +Expect(1, 1834, '\p{^Is_Jg: _ Shin}', ""); +Expect(1, 1834, '\P{Is_Jg: _ Shin}', ""); +Expect(0, 1834, '\P{^Is_Jg: _ Shin}', ""); +Error('\p{Joining_Group=-_Yeh:=}'); +Error('\P{Joining_Group=-_Yeh:=}'); +Expect(1, 1574, '\p{Joining_Group=yeh}', ""); +Expect(0, 1574, '\p{^Joining_Group=yeh}', ""); +Expect(0, 1574, '\P{Joining_Group=yeh}', ""); +Expect(1, 1574, '\P{^Joining_Group=yeh}', ""); +Expect(0, 1573, '\p{Joining_Group=yeh}', ""); +Expect(1, 1573, '\p{^Joining_Group=yeh}', ""); +Expect(1, 1573, '\P{Joining_Group=yeh}', ""); +Expect(0, 1573, '\P{^Joining_Group=yeh}', ""); +Error('\p{Jg=Yeh:=}'); +Error('\P{Jg=Yeh:=}'); +Expect(1, 1574, '\p{Jg=yeh}', ""); +Expect(0, 1574, '\p{^Jg=yeh}', ""); +Expect(0, 1574, '\P{Jg=yeh}', ""); +Expect(1, 1574, '\P{^Jg=yeh}', ""); +Expect(0, 1573, '\p{Jg=yeh}', ""); +Expect(1, 1573, '\p{^Jg=yeh}', ""); +Expect(1, 1573, '\P{Jg=yeh}', ""); +Expect(0, 1573, '\P{^Jg=yeh}', ""); +Expect(1, 1574, '\p{Jg=_ Yeh}', ""); +Expect(0, 1574, '\p{^Jg=_ Yeh}', ""); +Expect(0, 1574, '\P{Jg=_ Yeh}', ""); +Expect(1, 1574, '\P{^Jg=_ Yeh}', ""); +Expect(0, 1573, '\p{Jg=_ Yeh}', ""); +Expect(1, 1573, '\p{^Jg=_ Yeh}', ""); +Expect(1, 1573, '\P{Jg=_ Yeh}', ""); +Expect(0, 1573, '\P{^Jg=_ Yeh}', ""); +Error('\p{Is_Joining_Group= YEH:=}'); +Error('\P{Is_Joining_Group= YEH:=}'); +Expect(1, 1574, '\p{Is_Joining_Group: yeh}', ""); +Expect(0, 1574, '\p{^Is_Joining_Group: yeh}', ""); +Expect(0, 1574, '\P{Is_Joining_Group: yeh}', ""); +Expect(1, 1574, '\P{^Is_Joining_Group: yeh}', ""); +Expect(0, 1573, '\p{Is_Joining_Group: yeh}', ""); +Expect(1, 1573, '\p{^Is_Joining_Group: yeh}', ""); +Expect(1, 1573, '\P{Is_Joining_Group: yeh}', ""); +Expect(0, 1573, '\P{^Is_Joining_Group: yeh}', ""); +Expect(1, 1574, '\p{Is_Joining_Group= -Yeh}', ""); +Expect(0, 1574, '\p{^Is_Joining_Group= -Yeh}', ""); +Expect(0, 1574, '\P{Is_Joining_Group= -Yeh}', ""); +Expect(1, 1574, '\P{^Is_Joining_Group= -Yeh}', ""); +Expect(0, 1573, '\p{Is_Joining_Group= -Yeh}', ""); +Expect(1, 1573, '\p{^Is_Joining_Group= -Yeh}', ""); +Expect(1, 1573, '\P{Is_Joining_Group= -Yeh}', ""); +Expect(0, 1573, '\P{^Is_Joining_Group= -Yeh}', ""); +Error('\p{Is_Jg:/a/_ YEH}'); +Error('\P{Is_Jg:/a/_ YEH}'); +Expect(1, 1574, '\p{Is_Jg=yeh}', ""); +Expect(0, 1574, '\p{^Is_Jg=yeh}', ""); +Expect(0, 1574, '\P{Is_Jg=yeh}', ""); +Expect(1, 1574, '\P{^Is_Jg=yeh}', ""); +Expect(0, 1573, '\p{Is_Jg=yeh}', ""); +Expect(1, 1573, '\p{^Is_Jg=yeh}', ""); +Expect(1, 1573, '\P{Is_Jg=yeh}', ""); +Expect(0, 1573, '\P{^Is_Jg=yeh}', ""); +Expect(1, 1574, '\p{Is_Jg= YEH}', ""); +Expect(0, 1574, '\p{^Is_Jg= YEH}', ""); +Expect(0, 1574, '\P{Is_Jg= YEH}', ""); +Expect(1, 1574, '\P{^Is_Jg= YEH}', ""); +Expect(0, 1573, '\p{Is_Jg= YEH}', ""); +Expect(1, 1573, '\p{^Is_Jg= YEH}', ""); +Expect(1, 1573, '\P{Is_Jg= YEH}', ""); +Expect(0, 1573, '\P{^Is_Jg= YEH}', ""); +Error('\p{Joining_Group=:= DAL}'); +Error('\P{Joining_Group=:= DAL}'); +Expect(1, 1584, '\p{Joining_Group: dal}', ""); +Expect(0, 1584, '\p{^Joining_Group: dal}', ""); +Expect(0, 1584, '\P{Joining_Group: dal}', ""); +Expect(1, 1584, '\P{^Joining_Group: dal}', ""); +Expect(0, 1582, '\p{Joining_Group: dal}', ""); +Expect(1, 1582, '\p{^Joining_Group: dal}', ""); +Expect(1, 1582, '\P{Joining_Group: dal}', ""); +Expect(0, 1582, '\P{^Joining_Group: dal}', ""); +Expect(1, 1584, '\p{Joining_Group=_DAL}', ""); +Expect(0, 1584, '\p{^Joining_Group=_DAL}', ""); +Expect(0, 1584, '\P{Joining_Group=_DAL}', ""); +Expect(1, 1584, '\P{^Joining_Group=_DAL}', ""); +Expect(0, 1582, '\p{Joining_Group=_DAL}', ""); +Expect(1, 1582, '\p{^Joining_Group=_DAL}', ""); +Expect(1, 1582, '\P{Joining_Group=_DAL}', ""); +Expect(0, 1582, '\P{^Joining_Group=_DAL}', ""); +Error('\p{Jg: dal:=}'); +Error('\P{Jg: dal:=}'); +Expect(1, 1584, '\p{Jg: dal}', ""); +Expect(0, 1584, '\p{^Jg: dal}', ""); +Expect(0, 1584, '\P{Jg: dal}', ""); +Expect(1, 1584, '\P{^Jg: dal}', ""); +Expect(0, 1582, '\p{Jg: dal}', ""); +Expect(1, 1582, '\p{^Jg: dal}', ""); +Expect(1, 1582, '\P{Jg: dal}', ""); +Expect(0, 1582, '\P{^Jg: dal}', ""); +Expect(1, 1584, '\p{Jg=_ Dal}', ""); +Expect(0, 1584, '\p{^Jg=_ Dal}', ""); +Expect(0, 1584, '\P{Jg=_ Dal}', ""); +Expect(1, 1584, '\P{^Jg=_ Dal}', ""); +Expect(0, 1582, '\p{Jg=_ Dal}', ""); +Expect(1, 1582, '\p{^Jg=_ Dal}', ""); +Expect(1, 1582, '\P{Jg=_ Dal}', ""); +Expect(0, 1582, '\P{^Jg=_ Dal}', ""); +Error('\p{Is_Joining_Group=/a/_-Dal}'); +Error('\P{Is_Joining_Group=/a/_-Dal}'); +Expect(1, 1584, '\p{Is_Joining_Group=dal}', ""); +Expect(0, 1584, '\p{^Is_Joining_Group=dal}', ""); +Expect(0, 1584, '\P{Is_Joining_Group=dal}', ""); +Expect(1, 1584, '\P{^Is_Joining_Group=dal}', ""); +Expect(0, 1582, '\p{Is_Joining_Group=dal}', ""); +Expect(1, 1582, '\p{^Is_Joining_Group=dal}', ""); +Expect(1, 1582, '\P{Is_Joining_Group=dal}', ""); +Expect(0, 1582, '\P{^Is_Joining_Group=dal}', ""); +Expect(1, 1584, '\p{Is_Joining_Group=- Dal}', ""); +Expect(0, 1584, '\p{^Is_Joining_Group=- Dal}', ""); +Expect(0, 1584, '\P{Is_Joining_Group=- Dal}', ""); +Expect(1, 1584, '\P{^Is_Joining_Group=- Dal}', ""); +Expect(0, 1582, '\p{Is_Joining_Group=- Dal}', ""); +Expect(1, 1582, '\p{^Is_Joining_Group=- Dal}', ""); +Expect(1, 1582, '\P{Is_Joining_Group=- Dal}', ""); +Expect(0, 1582, '\P{^Is_Joining_Group=- Dal}', ""); +Error('\p{Is_Jg= /a/Dal}'); +Error('\P{Is_Jg= /a/Dal}'); +Expect(1, 1584, '\p{Is_Jg=dal}', ""); +Expect(0, 1584, '\p{^Is_Jg=dal}', ""); +Expect(0, 1584, '\P{Is_Jg=dal}', ""); +Expect(1, 1584, '\P{^Is_Jg=dal}', ""); +Expect(0, 1582, '\p{Is_Jg=dal}', ""); +Expect(1, 1582, '\p{^Is_Jg=dal}', ""); +Expect(1, 1582, '\P{Is_Jg=dal}', ""); +Expect(0, 1582, '\P{^Is_Jg=dal}', ""); +Expect(1, 1584, '\p{Is_Jg= DAL}', ""); +Expect(0, 1584, '\p{^Is_Jg= DAL}', ""); +Expect(0, 1584, '\P{Is_Jg= DAL}', ""); +Expect(1, 1584, '\P{^Is_Jg= DAL}', ""); +Expect(0, 1582, '\p{Is_Jg= DAL}', ""); +Expect(1, 1582, '\p{^Is_Jg= DAL}', ""); +Expect(1, 1582, '\P{Is_Jg= DAL}', ""); +Expect(0, 1582, '\P{^Is_Jg= DAL}', ""); +Error('\p{Joining_Group=:=_-Hamza_ON_HEH-goal}'); +Error('\P{Joining_Group=:=_-Hamza_ON_HEH-goal}'); +Expect(1, 1731, '\p{Joining_Group=hamzaonhehgoal}', ""); +Expect(0, 1731, '\p{^Joining_Group=hamzaonhehgoal}', ""); +Expect(0, 1731, '\P{Joining_Group=hamzaonhehgoal}', ""); +Expect(1, 1731, '\P{^Joining_Group=hamzaonhehgoal}', ""); +Expect(0, 1730, '\p{Joining_Group=hamzaonhehgoal}', ""); +Expect(1, 1730, '\p{^Joining_Group=hamzaonhehgoal}', ""); +Expect(1, 1730, '\P{Joining_Group=hamzaonhehgoal}', ""); +Expect(0, 1730, '\P{^Joining_Group=hamzaonhehgoal}', ""); +Expect(1, 1731, '\p{Joining_Group= _HAMZAonHeh-Goal}', ""); +Expect(0, 1731, '\p{^Joining_Group= _HAMZAonHeh-Goal}', ""); +Expect(0, 1731, '\P{Joining_Group= _HAMZAonHeh-Goal}', ""); +Expect(1, 1731, '\P{^Joining_Group= _HAMZAonHeh-Goal}', ""); +Expect(0, 1730, '\p{Joining_Group= _HAMZAonHeh-Goal}', ""); +Expect(1, 1730, '\p{^Joining_Group= _HAMZAonHeh-Goal}', ""); +Expect(1, 1730, '\P{Joining_Group= _HAMZAonHeh-Goal}', ""); +Expect(0, 1730, '\P{^Joining_Group= _HAMZAonHeh-Goal}', ""); +Error('\p{Jg=_/a/Hamza_On-Heh GOAL}'); +Error('\P{Jg=_/a/Hamza_On-Heh GOAL}'); +Expect(1, 1731, '\p{Jg=hamzaonhehgoal}', ""); +Expect(0, 1731, '\p{^Jg=hamzaonhehgoal}', ""); +Expect(0, 1731, '\P{Jg=hamzaonhehgoal}', ""); +Expect(1, 1731, '\P{^Jg=hamzaonhehgoal}', ""); +Expect(0, 1730, '\p{Jg=hamzaonhehgoal}', ""); +Expect(1, 1730, '\p{^Jg=hamzaonhehgoal}', ""); +Expect(1, 1730, '\P{Jg=hamzaonhehgoal}', ""); +Expect(0, 1730, '\P{^Jg=hamzaonhehgoal}', ""); +Expect(1, 1731, '\p{Jg=_ hamza-On HehGoal}', ""); +Expect(0, 1731, '\p{^Jg=_ hamza-On HehGoal}', ""); +Expect(0, 1731, '\P{Jg=_ hamza-On HehGoal}', ""); +Expect(1, 1731, '\P{^Jg=_ hamza-On HehGoal}', ""); +Expect(0, 1730, '\p{Jg=_ hamza-On HehGoal}', ""); +Expect(1, 1730, '\p{^Jg=_ hamza-On HehGoal}', ""); +Expect(1, 1730, '\P{Jg=_ hamza-On HehGoal}', ""); +Expect(0, 1730, '\P{^Jg=_ hamza-On HehGoal}', ""); +Error('\p{Is_Joining_Group=/a/HamzaON_heh goal}'); +Error('\P{Is_Joining_Group=/a/HamzaON_heh goal}'); +Expect(1, 1731, '\p{Is_Joining_Group=hamzaonhehgoal}', ""); +Expect(0, 1731, '\p{^Is_Joining_Group=hamzaonhehgoal}', ""); +Expect(0, 1731, '\P{Is_Joining_Group=hamzaonhehgoal}', ""); +Expect(1, 1731, '\P{^Is_Joining_Group=hamzaonhehgoal}', ""); +Expect(0, 1730, '\p{Is_Joining_Group=hamzaonhehgoal}', ""); +Expect(1, 1730, '\p{^Is_Joining_Group=hamzaonhehgoal}', ""); +Expect(1, 1730, '\P{Is_Joining_Group=hamzaonhehgoal}', ""); +Expect(0, 1730, '\P{^Is_Joining_Group=hamzaonhehgoal}', ""); +Expect(1, 1731, '\p{Is_Joining_Group=- Hamza on_HehGoal}', ""); +Expect(0, 1731, '\p{^Is_Joining_Group=- Hamza on_HehGoal}', ""); +Expect(0, 1731, '\P{Is_Joining_Group=- Hamza on_HehGoal}', ""); +Expect(1, 1731, '\P{^Is_Joining_Group=- Hamza on_HehGoal}', ""); +Expect(0, 1730, '\p{Is_Joining_Group=- Hamza on_HehGoal}', ""); +Expect(1, 1730, '\p{^Is_Joining_Group=- Hamza on_HehGoal}', ""); +Expect(1, 1730, '\P{Is_Joining_Group=- Hamza on_HehGoal}', ""); +Expect(0, 1730, '\P{^Is_Joining_Group=- Hamza on_HehGoal}', ""); +Error('\p{Is_Jg=/a/hamza on Heh Goal}'); +Error('\P{Is_Jg=/a/hamza on Heh Goal}'); +Expect(1, 1731, '\p{Is_Jg=hamzaonhehgoal}', ""); +Expect(0, 1731, '\p{^Is_Jg=hamzaonhehgoal}', ""); +Expect(0, 1731, '\P{Is_Jg=hamzaonhehgoal}', ""); +Expect(1, 1731, '\P{^Is_Jg=hamzaonhehgoal}', ""); +Expect(0, 1730, '\p{Is_Jg=hamzaonhehgoal}', ""); +Expect(1, 1730, '\p{^Is_Jg=hamzaonhehgoal}', ""); +Expect(1, 1730, '\P{Is_Jg=hamzaonhehgoal}', ""); +Expect(0, 1730, '\P{^Is_Jg=hamzaonhehgoal}', ""); +Expect(1, 1731, '\p{Is_Jg=Hamza ON Heh_Goal}', ""); +Expect(0, 1731, '\p{^Is_Jg=Hamza ON Heh_Goal}', ""); +Expect(0, 1731, '\P{Is_Jg=Hamza ON Heh_Goal}', ""); +Expect(1, 1731, '\P{^Is_Jg=Hamza ON Heh_Goal}', ""); +Expect(0, 1730, '\p{Is_Jg=Hamza ON Heh_Goal}', ""); +Expect(1, 1730, '\p{^Is_Jg=Hamza ON Heh_Goal}', ""); +Expect(1, 1730, '\P{Is_Jg=Hamza ON Heh_Goal}', ""); +Expect(0, 1730, '\P{^Is_Jg=Hamza ON Heh_Goal}', ""); +Error('\p{Joining_Group=-:=HE}'); +Error('\P{Joining_Group=-:=HE}'); +Expect(1, 1815, '\p{Joining_Group=he}', ""); +Expect(0, 1815, '\p{^Joining_Group=he}', ""); +Expect(0, 1815, '\P{Joining_Group=he}', ""); +Expect(1, 1815, '\P{^Joining_Group=he}', ""); +Expect(0, 1814, '\p{Joining_Group=he}', ""); +Expect(1, 1814, '\p{^Joining_Group=he}', ""); +Expect(1, 1814, '\P{Joining_Group=he}', ""); +Expect(0, 1814, '\P{^Joining_Group=he}', ""); +Expect(1, 1815, '\p{Joining_Group= _He}', ""); +Expect(0, 1815, '\p{^Joining_Group= _He}', ""); +Expect(0, 1815, '\P{Joining_Group= _He}', ""); +Expect(1, 1815, '\P{^Joining_Group= _He}', ""); +Expect(0, 1814, '\p{Joining_Group= _He}', ""); +Expect(1, 1814, '\p{^Joining_Group= _He}', ""); +Expect(1, 1814, '\P{Joining_Group= _He}', ""); +Expect(0, 1814, '\P{^Joining_Group= _He}', ""); +Error('\p{Jg= HE:=}'); +Error('\P{Jg= HE:=}'); +Expect(1, 1815, '\p{Jg=he}', ""); +Expect(0, 1815, '\p{^Jg=he}', ""); +Expect(0, 1815, '\P{Jg=he}', ""); +Expect(1, 1815, '\P{^Jg=he}', ""); +Expect(0, 1814, '\p{Jg=he}', ""); +Expect(1, 1814, '\p{^Jg=he}', ""); +Expect(1, 1814, '\P{Jg=he}', ""); +Expect(0, 1814, '\P{^Jg=he}', ""); +Expect(1, 1815, '\p{Jg= He}', ""); +Expect(0, 1815, '\p{^Jg= He}', ""); +Expect(0, 1815, '\P{Jg= He}', ""); +Expect(1, 1815, '\P{^Jg= He}', ""); +Expect(0, 1814, '\p{Jg= He}', ""); +Expect(1, 1814, '\p{^Jg= He}', ""); +Expect(1, 1814, '\P{Jg= He}', ""); +Expect(0, 1814, '\P{^Jg= He}', ""); +Error('\p{Is_Joining_Group=_:=He}'); +Error('\P{Is_Joining_Group=_:=He}'); +Expect(1, 1815, '\p{Is_Joining_Group=he}', ""); +Expect(0, 1815, '\p{^Is_Joining_Group=he}', ""); +Expect(0, 1815, '\P{Is_Joining_Group=he}', ""); +Expect(1, 1815, '\P{^Is_Joining_Group=he}', ""); +Expect(0, 1814, '\p{Is_Joining_Group=he}', ""); +Expect(1, 1814, '\p{^Is_Joining_Group=he}', ""); +Expect(1, 1814, '\P{Is_Joining_Group=he}', ""); +Expect(0, 1814, '\P{^Is_Joining_Group=he}', ""); +Expect(1, 1815, '\p{Is_Joining_Group= HE}', ""); +Expect(0, 1815, '\p{^Is_Joining_Group= HE}', ""); +Expect(0, 1815, '\P{Is_Joining_Group= HE}', ""); +Expect(1, 1815, '\P{^Is_Joining_Group= HE}', ""); +Expect(0, 1814, '\p{Is_Joining_Group= HE}', ""); +Expect(1, 1814, '\p{^Is_Joining_Group= HE}', ""); +Expect(1, 1814, '\P{Is_Joining_Group= HE}', ""); +Expect(0, 1814, '\P{^Is_Joining_Group= HE}', ""); +Error('\p{Is_Jg=:=HE}'); +Error('\P{Is_Jg=:=HE}'); +Expect(1, 1815, '\p{Is_Jg=he}', ""); +Expect(0, 1815, '\p{^Is_Jg=he}', ""); +Expect(0, 1815, '\P{Is_Jg=he}', ""); +Expect(1, 1815, '\P{^Is_Jg=he}', ""); +Expect(0, 1814, '\p{Is_Jg=he}', ""); +Expect(1, 1814, '\p{^Is_Jg=he}', ""); +Expect(1, 1814, '\P{Is_Jg=he}', ""); +Expect(0, 1814, '\P{^Is_Jg=he}', ""); +Expect(1, 1815, '\p{Is_Jg=- He}', ""); +Expect(0, 1815, '\p{^Is_Jg=- He}', ""); +Expect(0, 1815, '\P{Is_Jg=- He}', ""); +Expect(1, 1815, '\P{^Is_Jg=- He}', ""); +Expect(0, 1814, '\p{Is_Jg=- He}', ""); +Expect(1, 1814, '\p{^Is_Jg=- He}', ""); +Expect(1, 1814, '\P{Is_Jg=- He}', ""); +Expect(0, 1814, '\P{^Is_Jg=- He}', ""); +Error('\p{Joining_Group=:=No JOININGGroup}'); +Error('\P{Joining_Group=:=No JOININGGroup}'); +Expect(1, 1569, '\p{Joining_Group=nojoininggroup}', ""); +Expect(0, 1569, '\p{^Joining_Group=nojoininggroup}', ""); +Expect(0, 1569, '\P{Joining_Group=nojoininggroup}', ""); +Expect(1, 1569, '\P{^Joining_Group=nojoininggroup}', ""); +Expect(0, 1599, '\p{Joining_Group=nojoininggroup}', ""); +Expect(1, 1599, '\p{^Joining_Group=nojoininggroup}', ""); +Expect(1, 1599, '\P{Joining_Group=nojoininggroup}', ""); +Expect(0, 1599, '\P{^Joining_Group=nojoininggroup}', ""); +Expect(1, 1569, '\p{Joining_Group: -NO JoiningGroup}', ""); +Expect(0, 1569, '\p{^Joining_Group: -NO JoiningGroup}', ""); +Expect(0, 1569, '\P{Joining_Group: -NO JoiningGroup}', ""); +Expect(1, 1569, '\P{^Joining_Group: -NO JoiningGroup}', ""); +Expect(0, 1599, '\p{Joining_Group: -NO JoiningGroup}', ""); +Expect(1, 1599, '\p{^Joining_Group: -NO JoiningGroup}', ""); +Expect(1, 1599, '\P{Joining_Group: -NO JoiningGroup}', ""); +Expect(0, 1599, '\P{^Joining_Group: -NO JoiningGroup}', ""); +Error('\p{Jg=:=-NO_joining-GROUP}'); +Error('\P{Jg=:=-NO_joining-GROUP}'); +Expect(1, 1569, '\p{Jg=nojoininggroup}', ""); +Expect(0, 1569, '\p{^Jg=nojoininggroup}', ""); +Expect(0, 1569, '\P{Jg=nojoininggroup}', ""); +Expect(1, 1569, '\P{^Jg=nojoininggroup}', ""); +Expect(0, 1599, '\p{Jg=nojoininggroup}', ""); +Expect(1, 1599, '\p{^Jg=nojoininggroup}', ""); +Expect(1, 1599, '\P{Jg=nojoininggroup}', ""); +Expect(0, 1599, '\P{^Jg=nojoininggroup}', ""); +Expect(1, 1569, '\p{Jg= -No-Joining GROUP}', ""); +Expect(0, 1569, '\p{^Jg= -No-Joining GROUP}', ""); +Expect(0, 1569, '\P{Jg= -No-Joining GROUP}', ""); +Expect(1, 1569, '\P{^Jg= -No-Joining GROUP}', ""); +Expect(0, 1599, '\p{Jg= -No-Joining GROUP}', ""); +Expect(1, 1599, '\p{^Jg= -No-Joining GROUP}', ""); +Expect(1, 1599, '\P{Jg= -No-Joining GROUP}', ""); +Expect(0, 1599, '\P{^Jg= -No-Joining GROUP}', ""); +Error('\p{Is_Joining_Group=-No/a/joining group}'); +Error('\P{Is_Joining_Group=-No/a/joining group}'); +Expect(1, 1569, '\p{Is_Joining_Group=nojoininggroup}', ""); +Expect(0, 1569, '\p{^Is_Joining_Group=nojoininggroup}', ""); +Expect(0, 1569, '\P{Is_Joining_Group=nojoininggroup}', ""); +Expect(1, 1569, '\P{^Is_Joining_Group=nojoininggroup}', ""); +Expect(0, 1599, '\p{Is_Joining_Group=nojoininggroup}', ""); +Expect(1, 1599, '\p{^Is_Joining_Group=nojoininggroup}', ""); +Expect(1, 1599, '\P{Is_Joining_Group=nojoininggroup}', ""); +Expect(0, 1599, '\P{^Is_Joining_Group=nojoininggroup}', ""); +Expect(1, 1569, '\p{Is_Joining_Group= NOJOINING-GROUP}', ""); +Expect(0, 1569, '\p{^Is_Joining_Group= NOJOINING-GROUP}', ""); +Expect(0, 1569, '\P{Is_Joining_Group= NOJOINING-GROUP}', ""); +Expect(1, 1569, '\P{^Is_Joining_Group= NOJOINING-GROUP}', ""); +Expect(0, 1599, '\p{Is_Joining_Group= NOJOINING-GROUP}', ""); +Expect(1, 1599, '\p{^Is_Joining_Group= NOJOINING-GROUP}', ""); +Expect(1, 1599, '\P{Is_Joining_Group= NOJOINING-GROUP}', ""); +Expect(0, 1599, '\P{^Is_Joining_Group= NOJOINING-GROUP}', ""); +Error('\p{Is_Jg=- NO/a/joining Group}'); +Error('\P{Is_Jg=- NO/a/joining Group}'); +Expect(1, 1569, '\p{Is_Jg=nojoininggroup}', ""); +Expect(0, 1569, '\p{^Is_Jg=nojoininggroup}', ""); +Expect(0, 1569, '\P{Is_Jg=nojoininggroup}', ""); +Expect(1, 1569, '\P{^Is_Jg=nojoininggroup}', ""); +Expect(0, 1599, '\p{Is_Jg=nojoininggroup}', ""); +Expect(1, 1599, '\p{^Is_Jg=nojoininggroup}', ""); +Expect(1, 1599, '\P{Is_Jg=nojoininggroup}', ""); +Expect(0, 1599, '\P{^Is_Jg=nojoininggroup}', ""); +Expect(1, 1569, '\p{Is_Jg= no JoiningGroup}', ""); +Expect(0, 1569, '\p{^Is_Jg= no JoiningGroup}', ""); +Expect(0, 1569, '\P{Is_Jg= no JoiningGroup}', ""); +Expect(1, 1569, '\P{^Is_Jg= no JoiningGroup}', ""); +Expect(0, 1599, '\p{Is_Jg= no JoiningGroup}', ""); +Expect(1, 1599, '\p{^Is_Jg= no JoiningGroup}', ""); +Expect(1, 1599, '\P{Is_Jg= no JoiningGroup}', ""); +Expect(0, 1599, '\P{^Is_Jg= no JoiningGroup}', ""); +Error('\p{Joining_Group= _Burushaski_Yeh/a/Barree}'); +Error('\P{Joining_Group= _Burushaski_Yeh/a/Barree}'); +Expect(1, 1915, '\p{Joining_Group=burushaskiyehbarree}', ""); +Expect(0, 1915, '\p{^Joining_Group=burushaskiyehbarree}', ""); +Expect(0, 1915, '\P{Joining_Group=burushaskiyehbarree}', ""); +Expect(1, 1915, '\P{^Joining_Group=burushaskiyehbarree}', ""); +Expect(0, 1913, '\p{Joining_Group=burushaskiyehbarree}', ""); +Expect(1, 1913, '\p{^Joining_Group=burushaskiyehbarree}', ""); +Expect(1, 1913, '\P{Joining_Group=burushaskiyehbarree}', ""); +Expect(0, 1913, '\P{^Joining_Group=burushaskiyehbarree}', ""); +Expect(1, 1915, '\p{Joining_Group= -Burushaski_YehBARREE}', ""); +Expect(0, 1915, '\p{^Joining_Group= -Burushaski_YehBARREE}', ""); +Expect(0, 1915, '\P{Joining_Group= -Burushaski_YehBARREE}', ""); +Expect(1, 1915, '\P{^Joining_Group= -Burushaski_YehBARREE}', ""); +Expect(0, 1913, '\p{Joining_Group= -Burushaski_YehBARREE}', ""); +Expect(1, 1913, '\p{^Joining_Group= -Burushaski_YehBARREE}', ""); +Expect(1, 1913, '\P{Joining_Group= -Burushaski_YehBARREE}', ""); +Expect(0, 1913, '\P{^Joining_Group= -Burushaski_YehBARREE}', ""); +Error('\p{Jg=/a/-BURUSHASKI_Yeh Barree}'); +Error('\P{Jg=/a/-BURUSHASKI_Yeh Barree}'); +Expect(1, 1915, '\p{Jg=burushaskiyehbarree}', ""); +Expect(0, 1915, '\p{^Jg=burushaskiyehbarree}', ""); +Expect(0, 1915, '\P{Jg=burushaskiyehbarree}', ""); +Expect(1, 1915, '\P{^Jg=burushaskiyehbarree}', ""); +Expect(0, 1913, '\p{Jg=burushaskiyehbarree}', ""); +Expect(1, 1913, '\p{^Jg=burushaskiyehbarree}', ""); +Expect(1, 1913, '\P{Jg=burushaskiyehbarree}', ""); +Expect(0, 1913, '\P{^Jg=burushaskiyehbarree}', ""); +Expect(1, 1915, '\p{Jg= BURUSHASKI_yeh-BARREE}', ""); +Expect(0, 1915, '\p{^Jg= BURUSHASKI_yeh-BARREE}', ""); +Expect(0, 1915, '\P{Jg= BURUSHASKI_yeh-BARREE}', ""); +Expect(1, 1915, '\P{^Jg= BURUSHASKI_yeh-BARREE}', ""); +Expect(0, 1913, '\p{Jg= BURUSHASKI_yeh-BARREE}', ""); +Expect(1, 1913, '\p{^Jg= BURUSHASKI_yeh-BARREE}', ""); +Expect(1, 1913, '\P{Jg= BURUSHASKI_yeh-BARREE}', ""); +Expect(0, 1913, '\P{^Jg= BURUSHASKI_yeh-BARREE}', ""); +Error('\p{Is_Joining_Group=-BURUSHASKIYeh-barree:=}'); +Error('\P{Is_Joining_Group=-BURUSHASKIYeh-barree:=}'); +Expect(1, 1915, '\p{Is_Joining_Group=burushaskiyehbarree}', ""); +Expect(0, 1915, '\p{^Is_Joining_Group=burushaskiyehbarree}', ""); +Expect(0, 1915, '\P{Is_Joining_Group=burushaskiyehbarree}', ""); +Expect(1, 1915, '\P{^Is_Joining_Group=burushaskiyehbarree}', ""); +Expect(0, 1913, '\p{Is_Joining_Group=burushaskiyehbarree}', ""); +Expect(1, 1913, '\p{^Is_Joining_Group=burushaskiyehbarree}', ""); +Expect(1, 1913, '\P{Is_Joining_Group=burushaskiyehbarree}', ""); +Expect(0, 1913, '\P{^Is_Joining_Group=burushaskiyehbarree}', ""); +Expect(1, 1915, '\p{Is_Joining_Group=-BURUSHASKI-Yeh_barree}', ""); +Expect(0, 1915, '\p{^Is_Joining_Group=-BURUSHASKI-Yeh_barree}', ""); +Expect(0, 1915, '\P{Is_Joining_Group=-BURUSHASKI-Yeh_barree}', ""); +Expect(1, 1915, '\P{^Is_Joining_Group=-BURUSHASKI-Yeh_barree}', ""); +Expect(0, 1913, '\p{Is_Joining_Group=-BURUSHASKI-Yeh_barree}', ""); +Expect(1, 1913, '\p{^Is_Joining_Group=-BURUSHASKI-Yeh_barree}', ""); +Expect(1, 1913, '\P{Is_Joining_Group=-BURUSHASKI-Yeh_barree}', ""); +Expect(0, 1913, '\P{^Is_Joining_Group=-BURUSHASKI-Yeh_barree}', ""); +Error('\p{Is_Jg= Burushaski_Yeh/a/BARREE}'); +Error('\P{Is_Jg= Burushaski_Yeh/a/BARREE}'); +Expect(1, 1915, '\p{Is_Jg=burushaskiyehbarree}', ""); +Expect(0, 1915, '\p{^Is_Jg=burushaskiyehbarree}', ""); +Expect(0, 1915, '\P{Is_Jg=burushaskiyehbarree}', ""); +Expect(1, 1915, '\P{^Is_Jg=burushaskiyehbarree}', ""); +Expect(0, 1913, '\p{Is_Jg=burushaskiyehbarree}', ""); +Expect(1, 1913, '\p{^Is_Jg=burushaskiyehbarree}', ""); +Expect(1, 1913, '\P{Is_Jg=burushaskiyehbarree}', ""); +Expect(0, 1913, '\P{^Is_Jg=burushaskiyehbarree}', ""); +Expect(1, 1915, '\p{Is_Jg=__Burushaski_Yeh Barree}', ""); +Expect(0, 1915, '\p{^Is_Jg=__Burushaski_Yeh Barree}', ""); +Expect(0, 1915, '\P{Is_Jg=__Burushaski_Yeh Barree}', ""); +Expect(1, 1915, '\P{^Is_Jg=__Burushaski_Yeh Barree}', ""); +Expect(0, 1913, '\p{Is_Jg=__Burushaski_Yeh Barree}', ""); +Expect(1, 1913, '\p{^Is_Jg=__Burushaski_Yeh Barree}', ""); +Expect(1, 1913, '\P{Is_Jg=__Burushaski_Yeh Barree}', ""); +Expect(0, 1913, '\P{^Is_Jg=__Burushaski_Yeh Barree}', ""); +Error('\p{Joining_Group: Teh/a/MARBUTA}'); +Error('\P{Joining_Group: Teh/a/MARBUTA}'); +Expect(1, 1577, '\p{Joining_Group=tehmarbuta}', ""); +Expect(0, 1577, '\p{^Joining_Group=tehmarbuta}', ""); +Expect(0, 1577, '\P{Joining_Group=tehmarbuta}', ""); +Expect(1, 1577, '\P{^Joining_Group=tehmarbuta}', ""); +Expect(0, 1576, '\p{Joining_Group=tehmarbuta}', ""); +Expect(1, 1576, '\p{^Joining_Group=tehmarbuta}', ""); +Expect(1, 1576, '\P{Joining_Group=tehmarbuta}', ""); +Expect(0, 1576, '\P{^Joining_Group=tehmarbuta}', ""); +Expect(1, 1577, '\p{Joining_Group= teh Marbuta}', ""); +Expect(0, 1577, '\p{^Joining_Group= teh Marbuta}', ""); +Expect(0, 1577, '\P{Joining_Group= teh Marbuta}', ""); +Expect(1, 1577, '\P{^Joining_Group= teh Marbuta}', ""); +Expect(0, 1576, '\p{Joining_Group= teh Marbuta}', ""); +Expect(1, 1576, '\p{^Joining_Group= teh Marbuta}', ""); +Expect(1, 1576, '\P{Joining_Group= teh Marbuta}', ""); +Expect(0, 1576, '\P{^Joining_Group= teh Marbuta}', ""); +Error('\p{Jg=- teh Marbuta/a/}'); +Error('\P{Jg=- teh Marbuta/a/}'); +Expect(1, 1577, '\p{Jg=tehmarbuta}', ""); +Expect(0, 1577, '\p{^Jg=tehmarbuta}', ""); +Expect(0, 1577, '\P{Jg=tehmarbuta}', ""); +Expect(1, 1577, '\P{^Jg=tehmarbuta}', ""); +Expect(0, 1576, '\p{Jg=tehmarbuta}', ""); +Expect(1, 1576, '\p{^Jg=tehmarbuta}', ""); +Expect(1, 1576, '\P{Jg=tehmarbuta}', ""); +Expect(0, 1576, '\P{^Jg=tehmarbuta}', ""); +Expect(1, 1577, '\p{Jg=_teh_marbuta}', ""); +Expect(0, 1577, '\p{^Jg=_teh_marbuta}', ""); +Expect(0, 1577, '\P{Jg=_teh_marbuta}', ""); +Expect(1, 1577, '\P{^Jg=_teh_marbuta}', ""); +Expect(0, 1576, '\p{Jg=_teh_marbuta}', ""); +Expect(1, 1576, '\p{^Jg=_teh_marbuta}', ""); +Expect(1, 1576, '\P{Jg=_teh_marbuta}', ""); +Expect(0, 1576, '\P{^Jg=_teh_marbuta}', ""); +Error('\p{Is_Joining_Group=-_Teh/a/Marbuta}'); +Error('\P{Is_Joining_Group=-_Teh/a/Marbuta}'); +Expect(1, 1577, '\p{Is_Joining_Group=tehmarbuta}', ""); +Expect(0, 1577, '\p{^Is_Joining_Group=tehmarbuta}', ""); +Expect(0, 1577, '\P{Is_Joining_Group=tehmarbuta}', ""); +Expect(1, 1577, '\P{^Is_Joining_Group=tehmarbuta}', ""); +Expect(0, 1576, '\p{Is_Joining_Group=tehmarbuta}', ""); +Expect(1, 1576, '\p{^Is_Joining_Group=tehmarbuta}', ""); +Expect(1, 1576, '\P{Is_Joining_Group=tehmarbuta}', ""); +Expect(0, 1576, '\P{^Is_Joining_Group=tehmarbuta}', ""); +Expect(1, 1577, '\p{Is_Joining_Group=--TehMARBUTA}', ""); +Expect(0, 1577, '\p{^Is_Joining_Group=--TehMARBUTA}', ""); +Expect(0, 1577, '\P{Is_Joining_Group=--TehMARBUTA}', ""); +Expect(1, 1577, '\P{^Is_Joining_Group=--TehMARBUTA}', ""); +Expect(0, 1576, '\p{Is_Joining_Group=--TehMARBUTA}', ""); +Expect(1, 1576, '\p{^Is_Joining_Group=--TehMARBUTA}', ""); +Expect(1, 1576, '\P{Is_Joining_Group=--TehMARBUTA}', ""); +Expect(0, 1576, '\P{^Is_Joining_Group=--TehMARBUTA}', ""); +Error('\p{Is_Jg: -TEH_Marbuta/a/}'); +Error('\P{Is_Jg: -TEH_Marbuta/a/}'); +Expect(1, 1577, '\p{Is_Jg=tehmarbuta}', ""); +Expect(0, 1577, '\p{^Is_Jg=tehmarbuta}', ""); +Expect(0, 1577, '\P{Is_Jg=tehmarbuta}', ""); +Expect(1, 1577, '\P{^Is_Jg=tehmarbuta}', ""); +Expect(0, 1576, '\p{Is_Jg=tehmarbuta}', ""); +Expect(1, 1576, '\p{^Is_Jg=tehmarbuta}', ""); +Expect(1, 1576, '\P{Is_Jg=tehmarbuta}', ""); +Expect(0, 1576, '\P{^Is_Jg=tehmarbuta}', ""); +Expect(1, 1577, '\p{Is_Jg= _TEH MARBUTA}', ""); +Expect(0, 1577, '\p{^Is_Jg= _TEH MARBUTA}', ""); +Expect(0, 1577, '\P{Is_Jg= _TEH MARBUTA}', ""); +Expect(1, 1577, '\P{^Is_Jg= _TEH MARBUTA}', ""); +Expect(0, 1576, '\p{Is_Jg= _TEH MARBUTA}', ""); +Expect(1, 1576, '\p{^Is_Jg= _TEH MARBUTA}', ""); +Expect(1, 1576, '\P{Is_Jg= _TEH MARBUTA}', ""); +Expect(0, 1576, '\P{^Is_Jg= _TEH MARBUTA}', ""); +Error('\p{Joining_Group: := _reh}'); +Error('\P{Joining_Group: := _reh}'); +Expect(1, 1586, '\p{Joining_Group=reh}', ""); +Expect(0, 1586, '\p{^Joining_Group=reh}', ""); +Expect(0, 1586, '\P{Joining_Group=reh}', ""); +Expect(1, 1586, '\P{^Joining_Group=reh}', ""); +Expect(0, 1584, '\p{Joining_Group=reh}', ""); +Expect(1, 1584, '\p{^Joining_Group=reh}', ""); +Expect(1, 1584, '\P{Joining_Group=reh}', ""); +Expect(0, 1584, '\P{^Joining_Group=reh}', ""); +Expect(1, 1586, '\p{Joining_Group= Reh}', ""); +Expect(0, 1586, '\p{^Joining_Group= Reh}', ""); +Expect(0, 1586, '\P{Joining_Group= Reh}', ""); +Expect(1, 1586, '\P{^Joining_Group= Reh}', ""); +Expect(0, 1584, '\p{Joining_Group= Reh}', ""); +Expect(1, 1584, '\p{^Joining_Group= Reh}', ""); +Expect(1, 1584, '\P{Joining_Group= Reh}', ""); +Expect(0, 1584, '\P{^Joining_Group= Reh}', ""); +Error('\p{Jg= :=Reh}'); +Error('\P{Jg= :=Reh}'); +Expect(1, 1586, '\p{Jg=reh}', ""); +Expect(0, 1586, '\p{^Jg=reh}', ""); +Expect(0, 1586, '\P{Jg=reh}', ""); +Expect(1, 1586, '\P{^Jg=reh}', ""); +Expect(0, 1584, '\p{Jg=reh}', ""); +Expect(1, 1584, '\p{^Jg=reh}', ""); +Expect(1, 1584, '\P{Jg=reh}', ""); +Expect(0, 1584, '\P{^Jg=reh}', ""); +Error('\p{Is_Joining_Group= /a/Reh}'); +Error('\P{Is_Joining_Group= /a/Reh}'); +Expect(1, 1586, '\p{Is_Joining_Group=reh}', ""); +Expect(0, 1586, '\p{^Is_Joining_Group=reh}', ""); +Expect(0, 1586, '\P{Is_Joining_Group=reh}', ""); +Expect(1, 1586, '\P{^Is_Joining_Group=reh}', ""); +Expect(0, 1584, '\p{Is_Joining_Group=reh}', ""); +Expect(1, 1584, '\p{^Is_Joining_Group=reh}', ""); +Expect(1, 1584, '\P{Is_Joining_Group=reh}', ""); +Expect(0, 1584, '\P{^Is_Joining_Group=reh}', ""); +Expect(1, 1586, '\p{Is_Joining_Group= REH}', ""); +Expect(0, 1586, '\p{^Is_Joining_Group= REH}', ""); +Expect(0, 1586, '\P{Is_Joining_Group= REH}', ""); +Expect(1, 1586, '\P{^Is_Joining_Group= REH}', ""); +Expect(0, 1584, '\p{Is_Joining_Group= REH}', ""); +Expect(1, 1584, '\p{^Is_Joining_Group= REH}', ""); +Expect(1, 1584, '\P{Is_Joining_Group= REH}', ""); +Expect(0, 1584, '\P{^Is_Joining_Group= REH}', ""); +Error('\p{Is_Jg=:=_Reh}'); +Error('\P{Is_Jg=:=_Reh}'); +Expect(1, 1586, '\p{Is_Jg=reh}', ""); +Expect(0, 1586, '\p{^Is_Jg=reh}', ""); +Expect(0, 1586, '\P{Is_Jg=reh}', ""); +Expect(1, 1586, '\P{^Is_Jg=reh}', ""); +Expect(0, 1584, '\p{Is_Jg=reh}', ""); +Expect(1, 1584, '\p{^Is_Jg=reh}', ""); +Expect(1, 1584, '\P{Is_Jg=reh}', ""); +Expect(0, 1584, '\P{^Is_Jg=reh}', ""); +Expect(1, 1586, '\p{Is_Jg=_-Reh}', ""); +Expect(0, 1586, '\p{^Is_Jg=_-Reh}', ""); +Expect(0, 1586, '\P{Is_Jg=_-Reh}', ""); +Expect(1, 1586, '\P{^Is_Jg=_-Reh}', ""); +Expect(0, 1584, '\p{Is_Jg=_-Reh}', ""); +Expect(1, 1584, '\p{^Is_Jg=_-Reh}', ""); +Expect(1, 1584, '\P{Is_Jg=_-Reh}', ""); +Expect(0, 1584, '\P{^Is_Jg=_-Reh}', ""); +Error('\p{Joining_Group= /a/ZAIN}'); +Error('\P{Joining_Group= /a/ZAIN}'); +Expect(1, 1817, '\p{Joining_Group=zain}', ""); +Expect(0, 1817, '\p{^Joining_Group=zain}', ""); +Expect(0, 1817, '\P{Joining_Group=zain}', ""); +Expect(1, 1817, '\P{^Joining_Group=zain}', ""); +Expect(0, 1816, '\p{Joining_Group=zain}', ""); +Expect(1, 1816, '\p{^Joining_Group=zain}', ""); +Expect(1, 1816, '\P{Joining_Group=zain}', ""); +Expect(0, 1816, '\P{^Joining_Group=zain}', ""); +Expect(1, 1817, '\p{Joining_Group=_zain}', ""); +Expect(0, 1817, '\p{^Joining_Group=_zain}', ""); +Expect(0, 1817, '\P{Joining_Group=_zain}', ""); +Expect(1, 1817, '\P{^Joining_Group=_zain}', ""); +Expect(0, 1816, '\p{Joining_Group=_zain}', ""); +Expect(1, 1816, '\p{^Joining_Group=_zain}', ""); +Expect(1, 1816, '\P{Joining_Group=_zain}', ""); +Expect(0, 1816, '\P{^Joining_Group=_zain}', ""); +Error('\p{Jg= -zain:=}'); +Error('\P{Jg= -zain:=}'); +Expect(1, 1817, '\p{Jg=zain}', ""); +Expect(0, 1817, '\p{^Jg=zain}', ""); +Expect(0, 1817, '\P{Jg=zain}', ""); +Expect(1, 1817, '\P{^Jg=zain}', ""); +Expect(0, 1816, '\p{Jg=zain}', ""); +Expect(1, 1816, '\p{^Jg=zain}', ""); +Expect(1, 1816, '\P{Jg=zain}', ""); +Expect(0, 1816, '\P{^Jg=zain}', ""); +Expect(1, 1817, '\p{Jg=_-Zain}', ""); +Expect(0, 1817, '\p{^Jg=_-Zain}', ""); +Expect(0, 1817, '\P{Jg=_-Zain}', ""); +Expect(1, 1817, '\P{^Jg=_-Zain}', ""); +Expect(0, 1816, '\p{Jg=_-Zain}', ""); +Expect(1, 1816, '\p{^Jg=_-Zain}', ""); +Expect(1, 1816, '\P{Jg=_-Zain}', ""); +Expect(0, 1816, '\P{^Jg=_-Zain}', ""); +Error('\p{Is_Joining_Group=/a/Zain}'); +Error('\P{Is_Joining_Group=/a/Zain}'); +Expect(1, 1817, '\p{Is_Joining_Group=zain}', ""); +Expect(0, 1817, '\p{^Is_Joining_Group=zain}', ""); +Expect(0, 1817, '\P{Is_Joining_Group=zain}', ""); +Expect(1, 1817, '\P{^Is_Joining_Group=zain}', ""); +Expect(0, 1816, '\p{Is_Joining_Group=zain}', ""); +Expect(1, 1816, '\p{^Is_Joining_Group=zain}', ""); +Expect(1, 1816, '\P{Is_Joining_Group=zain}', ""); +Expect(0, 1816, '\P{^Is_Joining_Group=zain}', ""); +Expect(1, 1817, '\p{Is_Joining_Group= Zain}', ""); +Expect(0, 1817, '\p{^Is_Joining_Group= Zain}', ""); +Expect(0, 1817, '\P{Is_Joining_Group= Zain}', ""); +Expect(1, 1817, '\P{^Is_Joining_Group= Zain}', ""); +Expect(0, 1816, '\p{Is_Joining_Group= Zain}', ""); +Expect(1, 1816, '\p{^Is_Joining_Group= Zain}', ""); +Expect(1, 1816, '\P{Is_Joining_Group= Zain}', ""); +Expect(0, 1816, '\P{^Is_Joining_Group= Zain}', ""); +Error('\p{Is_Jg=-/a/ZAIN}'); +Error('\P{Is_Jg=-/a/ZAIN}'); +Expect(1, 1817, '\p{Is_Jg=zain}', ""); +Expect(0, 1817, '\p{^Is_Jg=zain}', ""); +Expect(0, 1817, '\P{Is_Jg=zain}', ""); +Expect(1, 1817, '\P{^Is_Jg=zain}', ""); +Expect(0, 1816, '\p{Is_Jg=zain}', ""); +Expect(1, 1816, '\p{^Is_Jg=zain}', ""); +Expect(1, 1816, '\P{Is_Jg=zain}', ""); +Expect(0, 1816, '\P{^Is_Jg=zain}', ""); +Expect(1, 1817, '\p{Is_Jg=__zain}', ""); +Expect(0, 1817, '\p{^Is_Jg=__zain}', ""); +Expect(0, 1817, '\P{Is_Jg=__zain}', ""); +Expect(1, 1817, '\P{^Is_Jg=__zain}', ""); +Expect(0, 1816, '\p{Is_Jg=__zain}', ""); +Expect(1, 1816, '\p{^Is_Jg=__zain}', ""); +Expect(1, 1816, '\P{Is_Jg=__zain}', ""); +Expect(0, 1816, '\P{^Is_Jg=__zain}', ""); +Error('\p{Joining_Group= :=ALEF}'); +Error('\P{Joining_Group= :=ALEF}'); +Expect(1, 1571, '\p{Joining_Group=alef}', ""); +Expect(0, 1571, '\p{^Joining_Group=alef}', ""); +Expect(0, 1571, '\P{Joining_Group=alef}', ""); +Expect(1, 1571, '\P{^Joining_Group=alef}', ""); +Expect(0, 1569, '\p{Joining_Group=alef}', ""); +Expect(1, 1569, '\p{^Joining_Group=alef}', ""); +Expect(1, 1569, '\P{Joining_Group=alef}', ""); +Expect(0, 1569, '\P{^Joining_Group=alef}', ""); +Error('\p{Jg=:= alef}'); +Error('\P{Jg=:= alef}'); +Expect(1, 1571, '\p{Jg=alef}', ""); +Expect(0, 1571, '\p{^Jg=alef}', ""); +Expect(0, 1571, '\P{Jg=alef}', ""); +Expect(1, 1571, '\P{^Jg=alef}', ""); +Expect(0, 1569, '\p{Jg=alef}', ""); +Expect(1, 1569, '\p{^Jg=alef}', ""); +Expect(1, 1569, '\P{Jg=alef}', ""); +Expect(0, 1569, '\P{^Jg=alef}', ""); +Expect(1, 1571, '\p{Jg=-Alef}', ""); +Expect(0, 1571, '\p{^Jg=-Alef}', ""); +Expect(0, 1571, '\P{Jg=-Alef}', ""); +Expect(1, 1571, '\P{^Jg=-Alef}', ""); +Expect(0, 1569, '\p{Jg=-Alef}', ""); +Expect(1, 1569, '\p{^Jg=-Alef}', ""); +Expect(1, 1569, '\P{Jg=-Alef}', ""); +Expect(0, 1569, '\P{^Jg=-Alef}', ""); +Error('\p{Is_Joining_Group= :=ALEF}'); +Error('\P{Is_Joining_Group= :=ALEF}'); +Expect(1, 1571, '\p{Is_Joining_Group=alef}', ""); +Expect(0, 1571, '\p{^Is_Joining_Group=alef}', ""); +Expect(0, 1571, '\P{Is_Joining_Group=alef}', ""); +Expect(1, 1571, '\P{^Is_Joining_Group=alef}', ""); +Expect(0, 1569, '\p{Is_Joining_Group=alef}', ""); +Expect(1, 1569, '\p{^Is_Joining_Group=alef}', ""); +Expect(1, 1569, '\P{Is_Joining_Group=alef}', ""); +Expect(0, 1569, '\P{^Is_Joining_Group=alef}', ""); +Expect(1, 1571, '\p{Is_Joining_Group: ALEF}', ""); +Expect(0, 1571, '\p{^Is_Joining_Group: ALEF}', ""); +Expect(0, 1571, '\P{Is_Joining_Group: ALEF}', ""); +Expect(1, 1571, '\P{^Is_Joining_Group: ALEF}', ""); +Expect(0, 1569, '\p{Is_Joining_Group: ALEF}', ""); +Expect(1, 1569, '\p{^Is_Joining_Group: ALEF}', ""); +Expect(1, 1569, '\P{Is_Joining_Group: ALEF}', ""); +Expect(0, 1569, '\P{^Is_Joining_Group: ALEF}', ""); +Error('\p{Is_Jg: /a/ alef}'); +Error('\P{Is_Jg: /a/ alef}'); +Expect(1, 1571, '\p{Is_Jg=alef}', ""); +Expect(0, 1571, '\p{^Is_Jg=alef}', ""); +Expect(0, 1571, '\P{Is_Jg=alef}', ""); +Expect(1, 1571, '\P{^Is_Jg=alef}', ""); +Expect(0, 1569, '\p{Is_Jg=alef}', ""); +Expect(1, 1569, '\p{^Is_Jg=alef}', ""); +Expect(1, 1569, '\P{Is_Jg=alef}', ""); +Expect(0, 1569, '\P{^Is_Jg=alef}', ""); +Expect(1, 1571, '\p{Is_Jg=__alef}', ""); +Expect(0, 1571, '\p{^Is_Jg=__alef}', ""); +Expect(0, 1571, '\P{Is_Jg=__alef}', ""); +Expect(1, 1571, '\P{^Is_Jg=__alef}', ""); +Expect(0, 1569, '\p{Is_Jg=__alef}', ""); +Expect(1, 1569, '\p{^Is_Jg=__alef}', ""); +Expect(1, 1569, '\P{Is_Jg=__alef}', ""); +Expect(0, 1569, '\P{^Is_Jg=__alef}', ""); +Error('\p{Joining_Group=-Gamal/a/}'); +Error('\P{Joining_Group=-Gamal/a/}'); +Expect(1, 1812, '\p{Joining_Group=gamal}', ""); +Expect(0, 1812, '\p{^Joining_Group=gamal}', ""); +Expect(0, 1812, '\P{Joining_Group=gamal}', ""); +Expect(1, 1812, '\P{^Joining_Group=gamal}', ""); +Expect(0, 1810, '\p{Joining_Group=gamal}', ""); +Expect(1, 1810, '\p{^Joining_Group=gamal}', ""); +Expect(1, 1810, '\P{Joining_Group=gamal}', ""); +Expect(0, 1810, '\P{^Joining_Group=gamal}', ""); +Expect(1, 1812, '\p{Joining_Group= Gamal}', ""); +Expect(0, 1812, '\p{^Joining_Group= Gamal}', ""); +Expect(0, 1812, '\P{Joining_Group= Gamal}', ""); +Expect(1, 1812, '\P{^Joining_Group= Gamal}', ""); +Expect(0, 1810, '\p{Joining_Group= Gamal}', ""); +Expect(1, 1810, '\p{^Joining_Group= Gamal}', ""); +Expect(1, 1810, '\P{Joining_Group= Gamal}', ""); +Expect(0, 1810, '\P{^Joining_Group= Gamal}', ""); +Error('\p{Jg= :=Gamal}'); +Error('\P{Jg= :=Gamal}'); +Expect(1, 1812, '\p{Jg=gamal}', ""); +Expect(0, 1812, '\p{^Jg=gamal}', ""); +Expect(0, 1812, '\P{Jg=gamal}', ""); +Expect(1, 1812, '\P{^Jg=gamal}', ""); +Expect(0, 1810, '\p{Jg=gamal}', ""); +Expect(1, 1810, '\p{^Jg=gamal}', ""); +Expect(1, 1810, '\P{Jg=gamal}', ""); +Expect(0, 1810, '\P{^Jg=gamal}', ""); +Expect(1, 1812, '\p{Jg= Gamal}', ""); +Expect(0, 1812, '\p{^Jg= Gamal}', ""); +Expect(0, 1812, '\P{Jg= Gamal}', ""); +Expect(1, 1812, '\P{^Jg= Gamal}', ""); +Expect(0, 1810, '\p{Jg= Gamal}', ""); +Expect(1, 1810, '\p{^Jg= Gamal}', ""); +Expect(1, 1810, '\P{Jg= Gamal}', ""); +Expect(0, 1810, '\P{^Jg= Gamal}', ""); +Error('\p{Is_Joining_Group=:=gamal}'); +Error('\P{Is_Joining_Group=:=gamal}'); +Expect(1, 1812, '\p{Is_Joining_Group=gamal}', ""); +Expect(0, 1812, '\p{^Is_Joining_Group=gamal}', ""); +Expect(0, 1812, '\P{Is_Joining_Group=gamal}', ""); +Expect(1, 1812, '\P{^Is_Joining_Group=gamal}', ""); +Expect(0, 1810, '\p{Is_Joining_Group=gamal}', ""); +Expect(1, 1810, '\p{^Is_Joining_Group=gamal}', ""); +Expect(1, 1810, '\P{Is_Joining_Group=gamal}', ""); +Expect(0, 1810, '\P{^Is_Joining_Group=gamal}', ""); +Expect(1, 1812, '\p{Is_Joining_Group=-_Gamal}', ""); +Expect(0, 1812, '\p{^Is_Joining_Group=-_Gamal}', ""); +Expect(0, 1812, '\P{Is_Joining_Group=-_Gamal}', ""); +Expect(1, 1812, '\P{^Is_Joining_Group=-_Gamal}', ""); +Expect(0, 1810, '\p{Is_Joining_Group=-_Gamal}', ""); +Expect(1, 1810, '\p{^Is_Joining_Group=-_Gamal}', ""); +Expect(1, 1810, '\P{Is_Joining_Group=-_Gamal}', ""); +Expect(0, 1810, '\P{^Is_Joining_Group=-_Gamal}', ""); +Error('\p{Is_Jg= gamal/a/}'); +Error('\P{Is_Jg= gamal/a/}'); +Expect(1, 1812, '\p{Is_Jg: gamal}', ""); +Expect(0, 1812, '\p{^Is_Jg: gamal}', ""); +Expect(0, 1812, '\P{Is_Jg: gamal}', ""); +Expect(1, 1812, '\P{^Is_Jg: gamal}', ""); +Expect(0, 1810, '\p{Is_Jg: gamal}', ""); +Expect(1, 1810, '\p{^Is_Jg: gamal}', ""); +Expect(1, 1810, '\P{Is_Jg: gamal}', ""); +Expect(0, 1810, '\P{^Is_Jg: gamal}', ""); +Expect(1, 1812, '\p{Is_Jg=- gamal}', ""); +Expect(0, 1812, '\p{^Is_Jg=- gamal}', ""); +Expect(0, 1812, '\P{Is_Jg=- gamal}', ""); +Expect(1, 1812, '\P{^Is_Jg=- gamal}', ""); +Expect(0, 1810, '\p{Is_Jg=- gamal}', ""); +Expect(1, 1810, '\p{^Is_Jg=- gamal}', ""); +Expect(1, 1810, '\P{Is_Jg=- gamal}', ""); +Expect(0, 1810, '\P{^Is_Jg=- gamal}', ""); +Error('\p{Joining_Group=/a/__meem}'); +Error('\P{Joining_Group=/a/__meem}'); +Expect(1, 1605, '\p{Joining_Group=meem}', ""); +Expect(0, 1605, '\p{^Joining_Group=meem}', ""); +Expect(0, 1605, '\P{Joining_Group=meem}', ""); +Expect(1, 1605, '\P{^Joining_Group=meem}', ""); +Expect(0, 1604, '\p{Joining_Group=meem}', ""); +Expect(1, 1604, '\p{^Joining_Group=meem}', ""); +Expect(1, 1604, '\P{Joining_Group=meem}', ""); +Expect(0, 1604, '\P{^Joining_Group=meem}', ""); +Expect(1, 1605, '\p{Joining_Group=_-Meem}', ""); +Expect(0, 1605, '\p{^Joining_Group=_-Meem}', ""); +Expect(0, 1605, '\P{Joining_Group=_-Meem}', ""); +Expect(1, 1605, '\P{^Joining_Group=_-Meem}', ""); +Expect(0, 1604, '\p{Joining_Group=_-Meem}', ""); +Expect(1, 1604, '\p{^Joining_Group=_-Meem}', ""); +Expect(1, 1604, '\P{Joining_Group=_-Meem}', ""); +Expect(0, 1604, '\P{^Joining_Group=_-Meem}', ""); +Error('\p{Jg:-_meem:=}'); +Error('\P{Jg:-_meem:=}'); +Expect(1, 1605, '\p{Jg: meem}', ""); +Expect(0, 1605, '\p{^Jg: meem}', ""); +Expect(0, 1605, '\P{Jg: meem}', ""); +Expect(1, 1605, '\P{^Jg: meem}', ""); +Expect(0, 1604, '\p{Jg: meem}', ""); +Expect(1, 1604, '\p{^Jg: meem}', ""); +Expect(1, 1604, '\P{Jg: meem}', ""); +Expect(0, 1604, '\P{^Jg: meem}', ""); +Expect(1, 1605, '\p{Jg=-Meem}', ""); +Expect(0, 1605, '\p{^Jg=-Meem}', ""); +Expect(0, 1605, '\P{Jg=-Meem}', ""); +Expect(1, 1605, '\P{^Jg=-Meem}', ""); +Expect(0, 1604, '\p{Jg=-Meem}', ""); +Expect(1, 1604, '\p{^Jg=-Meem}', ""); +Expect(1, 1604, '\P{Jg=-Meem}', ""); +Expect(0, 1604, '\P{^Jg=-Meem}', ""); +Error('\p{Is_Joining_Group=_ Meem/a/}'); +Error('\P{Is_Joining_Group=_ Meem/a/}'); +Expect(1, 1605, '\p{Is_Joining_Group=meem}', ""); +Expect(0, 1605, '\p{^Is_Joining_Group=meem}', ""); +Expect(0, 1605, '\P{Is_Joining_Group=meem}', ""); +Expect(1, 1605, '\P{^Is_Joining_Group=meem}', ""); +Expect(0, 1604, '\p{Is_Joining_Group=meem}', ""); +Expect(1, 1604, '\p{^Is_Joining_Group=meem}', ""); +Expect(1, 1604, '\P{Is_Joining_Group=meem}', ""); +Expect(0, 1604, '\P{^Is_Joining_Group=meem}', ""); +Expect(1, 1605, '\p{Is_Joining_Group= -Meem}', ""); +Expect(0, 1605, '\p{^Is_Joining_Group= -Meem}', ""); +Expect(0, 1605, '\P{Is_Joining_Group= -Meem}', ""); +Expect(1, 1605, '\P{^Is_Joining_Group= -Meem}', ""); +Expect(0, 1604, '\p{Is_Joining_Group= -Meem}', ""); +Expect(1, 1604, '\p{^Is_Joining_Group= -Meem}', ""); +Expect(1, 1604, '\P{Is_Joining_Group= -Meem}', ""); +Expect(0, 1604, '\P{^Is_Joining_Group= -Meem}', ""); +Error('\p{Is_Jg= :=MEEM}'); +Error('\P{Is_Jg= :=MEEM}'); +Expect(1, 1605, '\p{Is_Jg: meem}', ""); +Expect(0, 1605, '\p{^Is_Jg: meem}', ""); +Expect(0, 1605, '\P{Is_Jg: meem}', ""); +Expect(1, 1605, '\P{^Is_Jg: meem}', ""); +Expect(0, 1604, '\p{Is_Jg: meem}', ""); +Expect(1, 1604, '\p{^Is_Jg: meem}', ""); +Expect(1, 1604, '\P{Is_Jg: meem}', ""); +Expect(0, 1604, '\P{^Is_Jg: meem}', ""); +Expect(1, 1605, '\p{Is_Jg=_Meem}', ""); +Expect(0, 1605, '\p{^Is_Jg=_Meem}', ""); +Expect(0, 1605, '\P{Is_Jg=_Meem}', ""); +Expect(1, 1605, '\P{^Is_Jg=_Meem}', ""); +Expect(0, 1604, '\p{Is_Jg=_Meem}', ""); +Expect(1, 1604, '\p{^Is_Jg=_Meem}', ""); +Expect(1, 1604, '\P{Is_Jg=_Meem}', ""); +Expect(0, 1604, '\P{^Is_Jg=_Meem}', ""); +Error('\p{Joining_Group=:= Sadhe}'); +Error('\P{Joining_Group=:= Sadhe}'); +Expect(1, 1832, '\p{Joining_Group=sadhe}', ""); +Expect(0, 1832, '\p{^Joining_Group=sadhe}', ""); +Expect(0, 1832, '\P{Joining_Group=sadhe}', ""); +Expect(1, 1832, '\P{^Joining_Group=sadhe}', ""); +Expect(0, 1831, '\p{Joining_Group=sadhe}', ""); +Expect(1, 1831, '\p{^Joining_Group=sadhe}', ""); +Expect(1, 1831, '\P{Joining_Group=sadhe}', ""); +Expect(0, 1831, '\P{^Joining_Group=sadhe}', ""); +Expect(1, 1832, '\p{Joining_Group=-_sadhe}', ""); +Expect(0, 1832, '\p{^Joining_Group=-_sadhe}', ""); +Expect(0, 1832, '\P{Joining_Group=-_sadhe}', ""); +Expect(1, 1832, '\P{^Joining_Group=-_sadhe}', ""); +Expect(0, 1831, '\p{Joining_Group=-_sadhe}', ""); +Expect(1, 1831, '\p{^Joining_Group=-_sadhe}', ""); +Expect(1, 1831, '\P{Joining_Group=-_sadhe}', ""); +Expect(0, 1831, '\P{^Joining_Group=-_sadhe}', ""); +Error('\p{Jg=:= -sadhe}'); +Error('\P{Jg=:= -sadhe}'); +Expect(1, 1832, '\p{Jg=sadhe}', ""); +Expect(0, 1832, '\p{^Jg=sadhe}', ""); +Expect(0, 1832, '\P{Jg=sadhe}', ""); +Expect(1, 1832, '\P{^Jg=sadhe}', ""); +Expect(0, 1831, '\p{Jg=sadhe}', ""); +Expect(1, 1831, '\p{^Jg=sadhe}', ""); +Expect(1, 1831, '\P{Jg=sadhe}', ""); +Expect(0, 1831, '\P{^Jg=sadhe}', ""); +Expect(1, 1832, '\p{Jg= _Sadhe}', ""); +Expect(0, 1832, '\p{^Jg= _Sadhe}', ""); +Expect(0, 1832, '\P{Jg= _Sadhe}', ""); +Expect(1, 1832, '\P{^Jg= _Sadhe}', ""); +Expect(0, 1831, '\p{Jg= _Sadhe}', ""); +Expect(1, 1831, '\p{^Jg= _Sadhe}', ""); +Expect(1, 1831, '\P{Jg= _Sadhe}', ""); +Expect(0, 1831, '\P{^Jg= _Sadhe}', ""); +Error('\p{Is_Joining_Group=:= SADHE}'); +Error('\P{Is_Joining_Group=:= SADHE}'); +Expect(1, 1832, '\p{Is_Joining_Group=sadhe}', ""); +Expect(0, 1832, '\p{^Is_Joining_Group=sadhe}', ""); +Expect(0, 1832, '\P{Is_Joining_Group=sadhe}', ""); +Expect(1, 1832, '\P{^Is_Joining_Group=sadhe}', ""); +Expect(0, 1831, '\p{Is_Joining_Group=sadhe}', ""); +Expect(1, 1831, '\p{^Is_Joining_Group=sadhe}', ""); +Expect(1, 1831, '\P{Is_Joining_Group=sadhe}', ""); +Expect(0, 1831, '\P{^Is_Joining_Group=sadhe}', ""); +Expect(1, 1832, '\p{Is_Joining_Group= Sadhe}', ""); +Expect(0, 1832, '\p{^Is_Joining_Group= Sadhe}', ""); +Expect(0, 1832, '\P{Is_Joining_Group= Sadhe}', ""); +Expect(1, 1832, '\P{^Is_Joining_Group= Sadhe}', ""); +Expect(0, 1831, '\p{Is_Joining_Group= Sadhe}', ""); +Expect(1, 1831, '\p{^Is_Joining_Group= Sadhe}', ""); +Expect(1, 1831, '\P{Is_Joining_Group= Sadhe}', ""); +Expect(0, 1831, '\P{^Is_Joining_Group= Sadhe}', ""); +Error('\p{Is_Jg=:=_sadhe}'); +Error('\P{Is_Jg=:=_sadhe}'); +Expect(1, 1832, '\p{Is_Jg:sadhe}', ""); +Expect(0, 1832, '\p{^Is_Jg:sadhe}', ""); +Expect(0, 1832, '\P{Is_Jg:sadhe}', ""); +Expect(1, 1832, '\P{^Is_Jg:sadhe}', ""); +Expect(0, 1831, '\p{Is_Jg:sadhe}', ""); +Expect(1, 1831, '\p{^Is_Jg:sadhe}', ""); +Expect(1, 1831, '\P{Is_Jg:sadhe}', ""); +Expect(0, 1831, '\P{^Is_Jg:sadhe}', ""); +Expect(1, 1832, '\p{Is_Jg=_SADHE}', ""); +Expect(0, 1832, '\p{^Is_Jg=_SADHE}', ""); +Expect(0, 1832, '\P{Is_Jg=_SADHE}', ""); +Expect(1, 1832, '\P{^Is_Jg=_SADHE}', ""); +Expect(0, 1831, '\p{Is_Jg=_SADHE}', ""); +Expect(1, 1831, '\p{^Is_Jg=_SADHE}', ""); +Expect(1, 1831, '\P{Is_Jg=_SADHE}', ""); +Expect(0, 1831, '\P{^Is_Jg=_SADHE}', ""); +Error('\p{Joining_Group=-/a/beh}'); +Error('\P{Joining_Group=-/a/beh}'); +Expect(1, 1576, '\p{Joining_Group=beh}', ""); +Expect(0, 1576, '\p{^Joining_Group=beh}', ""); +Expect(0, 1576, '\P{Joining_Group=beh}', ""); +Expect(1, 1576, '\P{^Joining_Group=beh}', ""); +Expect(0, 1575, '\p{Joining_Group=beh}', ""); +Expect(1, 1575, '\p{^Joining_Group=beh}', ""); +Expect(1, 1575, '\P{Joining_Group=beh}', ""); +Expect(0, 1575, '\P{^Joining_Group=beh}', ""); +Expect(1, 1576, '\p{Joining_Group: _ beh}', ""); +Expect(0, 1576, '\p{^Joining_Group: _ beh}', ""); +Expect(0, 1576, '\P{Joining_Group: _ beh}', ""); +Expect(1, 1576, '\P{^Joining_Group: _ beh}', ""); +Expect(0, 1575, '\p{Joining_Group: _ beh}', ""); +Expect(1, 1575, '\p{^Joining_Group: _ beh}', ""); +Expect(1, 1575, '\P{Joining_Group: _ beh}', ""); +Expect(0, 1575, '\P{^Joining_Group: _ beh}', ""); +Error('\p{Jg= _BEH/a/}'); +Error('\P{Jg= _BEH/a/}'); +Expect(1, 1576, '\p{Jg=beh}', ""); +Expect(0, 1576, '\p{^Jg=beh}', ""); +Expect(0, 1576, '\P{Jg=beh}', ""); +Expect(1, 1576, '\P{^Jg=beh}', ""); +Expect(0, 1575, '\p{Jg=beh}', ""); +Expect(1, 1575, '\p{^Jg=beh}', ""); +Expect(1, 1575, '\P{Jg=beh}', ""); +Expect(0, 1575, '\P{^Jg=beh}', ""); +Expect(1, 1576, '\p{Jg=_ beh}', ""); +Expect(0, 1576, '\p{^Jg=_ beh}', ""); +Expect(0, 1576, '\P{Jg=_ beh}', ""); +Expect(1, 1576, '\P{^Jg=_ beh}', ""); +Expect(0, 1575, '\p{Jg=_ beh}', ""); +Expect(1, 1575, '\p{^Jg=_ beh}', ""); +Expect(1, 1575, '\P{Jg=_ beh}', ""); +Expect(0, 1575, '\P{^Jg=_ beh}', ""); +Error('\p{Is_Joining_Group=/a/ _Beh}'); +Error('\P{Is_Joining_Group=/a/ _Beh}'); +Expect(1, 1576, '\p{Is_Joining_Group=beh}', ""); +Expect(0, 1576, '\p{^Is_Joining_Group=beh}', ""); +Expect(0, 1576, '\P{Is_Joining_Group=beh}', ""); +Expect(1, 1576, '\P{^Is_Joining_Group=beh}', ""); +Expect(0, 1575, '\p{Is_Joining_Group=beh}', ""); +Expect(1, 1575, '\p{^Is_Joining_Group=beh}', ""); +Expect(1, 1575, '\P{Is_Joining_Group=beh}', ""); +Expect(0, 1575, '\P{^Is_Joining_Group=beh}', ""); +Expect(1, 1576, '\p{Is_Joining_Group=- Beh}', ""); +Expect(0, 1576, '\p{^Is_Joining_Group=- Beh}', ""); +Expect(0, 1576, '\P{Is_Joining_Group=- Beh}', ""); +Expect(1, 1576, '\P{^Is_Joining_Group=- Beh}', ""); +Expect(0, 1575, '\p{Is_Joining_Group=- Beh}', ""); +Expect(1, 1575, '\p{^Is_Joining_Group=- Beh}', ""); +Expect(1, 1575, '\P{Is_Joining_Group=- Beh}', ""); +Expect(0, 1575, '\P{^Is_Joining_Group=- Beh}', ""); +Error('\p{Is_Jg=_/a/Beh}'); +Error('\P{Is_Jg=_/a/Beh}'); +Expect(1, 1576, '\p{Is_Jg=beh}', ""); +Expect(0, 1576, '\p{^Is_Jg=beh}', ""); +Expect(0, 1576, '\P{Is_Jg=beh}', ""); +Expect(1, 1576, '\P{^Is_Jg=beh}', ""); +Expect(0, 1575, '\p{Is_Jg=beh}', ""); +Expect(1, 1575, '\p{^Is_Jg=beh}', ""); +Expect(1, 1575, '\P{Is_Jg=beh}', ""); +Expect(0, 1575, '\P{^Is_Jg=beh}', ""); +Expect(1, 1576, '\p{Is_Jg= BEH}', ""); +Expect(0, 1576, '\p{^Is_Jg= BEH}', ""); +Expect(0, 1576, '\P{Is_Jg= BEH}', ""); +Expect(1, 1576, '\P{^Is_Jg= BEH}', ""); +Expect(0, 1575, '\p{Is_Jg= BEH}', ""); +Expect(1, 1575, '\p{^Is_Jg= BEH}', ""); +Expect(1, 1575, '\P{Is_Jg= BEH}', ""); +Expect(0, 1575, '\P{^Is_Jg= BEH}', ""); +Error('\p{Joining_Group=-:=YEH-With-Tail}'); +Error('\P{Joining_Group=-:=YEH-With-Tail}'); +Expect(1, 1741, '\p{Joining_Group: yehwithtail}', ""); +Expect(0, 1741, '\p{^Joining_Group: yehwithtail}', ""); +Expect(0, 1741, '\P{Joining_Group: yehwithtail}', ""); +Expect(1, 1741, '\P{^Joining_Group: yehwithtail}', ""); +Expect(0, 1740, '\p{Joining_Group: yehwithtail}', ""); +Expect(1, 1740, '\p{^Joining_Group: yehwithtail}', ""); +Expect(1, 1740, '\P{Joining_Group: yehwithtail}', ""); +Expect(0, 1740, '\P{^Joining_Group: yehwithtail}', ""); +Expect(1, 1741, '\p{Joining_Group: YEH withTail}', ""); +Expect(0, 1741, '\p{^Joining_Group: YEH withTail}', ""); +Expect(0, 1741, '\P{Joining_Group: YEH withTail}', ""); +Expect(1, 1741, '\P{^Joining_Group: YEH withTail}', ""); +Expect(0, 1740, '\p{Joining_Group: YEH withTail}', ""); +Expect(1, 1740, '\p{^Joining_Group: YEH withTail}', ""); +Expect(1, 1740, '\P{Joining_Group: YEH withTail}', ""); +Expect(0, 1740, '\P{^Joining_Group: YEH withTail}', ""); +Error('\p{Jg= _yeh:=WITH Tail}'); +Error('\P{Jg= _yeh:=WITH Tail}'); +Expect(1, 1741, '\p{Jg=yehwithtail}', ""); +Expect(0, 1741, '\p{^Jg=yehwithtail}', ""); +Expect(0, 1741, '\P{Jg=yehwithtail}', ""); +Expect(1, 1741, '\P{^Jg=yehwithtail}', ""); +Expect(0, 1740, '\p{Jg=yehwithtail}', ""); +Expect(1, 1740, '\p{^Jg=yehwithtail}', ""); +Expect(1, 1740, '\P{Jg=yehwithtail}', ""); +Expect(0, 1740, '\P{^Jg=yehwithtail}', ""); +Expect(1, 1741, '\p{Jg: -YEHWithTail}', ""); +Expect(0, 1741, '\p{^Jg: -YEHWithTail}', ""); +Expect(0, 1741, '\P{Jg: -YEHWithTail}', ""); +Expect(1, 1741, '\P{^Jg: -YEHWithTail}', ""); +Expect(0, 1740, '\p{Jg: -YEHWithTail}', ""); +Expect(1, 1740, '\p{^Jg: -YEHWithTail}', ""); +Expect(1, 1740, '\P{Jg: -YEHWithTail}', ""); +Expect(0, 1740, '\P{^Jg: -YEHWithTail}', ""); +Error('\p{Is_Joining_Group=_ Yeh With:=Tail}'); +Error('\P{Is_Joining_Group=_ Yeh With:=Tail}'); +Expect(1, 1741, '\p{Is_Joining_Group=yehwithtail}', ""); +Expect(0, 1741, '\p{^Is_Joining_Group=yehwithtail}', ""); +Expect(0, 1741, '\P{Is_Joining_Group=yehwithtail}', ""); +Expect(1, 1741, '\P{^Is_Joining_Group=yehwithtail}', ""); +Expect(0, 1740, '\p{Is_Joining_Group=yehwithtail}', ""); +Expect(1, 1740, '\p{^Is_Joining_Group=yehwithtail}', ""); +Expect(1, 1740, '\P{Is_Joining_Group=yehwithtail}', ""); +Expect(0, 1740, '\P{^Is_Joining_Group=yehwithtail}', ""); +Expect(1, 1741, '\p{Is_Joining_Group: -yehWith TAIL}', ""); +Expect(0, 1741, '\p{^Is_Joining_Group: -yehWith TAIL}', ""); +Expect(0, 1741, '\P{Is_Joining_Group: -yehWith TAIL}', ""); +Expect(1, 1741, '\P{^Is_Joining_Group: -yehWith TAIL}', ""); +Expect(0, 1740, '\p{Is_Joining_Group: -yehWith TAIL}', ""); +Expect(1, 1740, '\p{^Is_Joining_Group: -yehWith TAIL}', ""); +Expect(1, 1740, '\P{Is_Joining_Group: -yehWith TAIL}', ""); +Expect(0, 1740, '\P{^Is_Joining_Group: -yehWith TAIL}', ""); +Error('\p{Is_Jg: _/a/YEH with Tail}'); +Error('\P{Is_Jg: _/a/YEH with Tail}'); +Expect(1, 1741, '\p{Is_Jg=yehwithtail}', ""); +Expect(0, 1741, '\p{^Is_Jg=yehwithtail}', ""); +Expect(0, 1741, '\P{Is_Jg=yehwithtail}', ""); +Expect(1, 1741, '\P{^Is_Jg=yehwithtail}', ""); +Expect(0, 1740, '\p{Is_Jg=yehwithtail}', ""); +Expect(1, 1740, '\p{^Is_Jg=yehwithtail}', ""); +Expect(1, 1740, '\P{Is_Jg=yehwithtail}', ""); +Expect(0, 1740, '\P{^Is_Jg=yehwithtail}', ""); +Expect(1, 1741, '\p{Is_Jg: yeh_With tail}', ""); +Expect(0, 1741, '\p{^Is_Jg: yeh_With tail}', ""); +Expect(0, 1741, '\P{Is_Jg: yeh_With tail}', ""); +Expect(1, 1741, '\P{^Is_Jg: yeh_With tail}', ""); +Expect(0, 1740, '\p{Is_Jg: yeh_With tail}', ""); +Expect(1, 1740, '\p{^Is_Jg: yeh_With tail}', ""); +Expect(1, 1740, '\P{Is_Jg: yeh_With tail}', ""); +Expect(0, 1740, '\P{^Is_Jg: yeh_With tail}', ""); +Error('\p{Joining_Group= :=tah}'); +Error('\P{Joining_Group= :=tah}'); +Expect(1, 1592, '\p{Joining_Group=tah}', ""); +Expect(0, 1592, '\p{^Joining_Group=tah}', ""); +Expect(0, 1592, '\P{Joining_Group=tah}', ""); +Expect(1, 1592, '\P{^Joining_Group=tah}', ""); +Expect(0, 1590, '\p{Joining_Group=tah}', ""); +Expect(1, 1590, '\p{^Joining_Group=tah}', ""); +Expect(1, 1590, '\P{Joining_Group=tah}', ""); +Expect(0, 1590, '\P{^Joining_Group=tah}', ""); +Expect(1, 1592, '\p{Joining_Group=-_Tah}', ""); +Expect(0, 1592, '\p{^Joining_Group=-_Tah}', ""); +Expect(0, 1592, '\P{Joining_Group=-_Tah}', ""); +Expect(1, 1592, '\P{^Joining_Group=-_Tah}', ""); +Expect(0, 1590, '\p{Joining_Group=-_Tah}', ""); +Expect(1, 1590, '\p{^Joining_Group=-_Tah}', ""); +Expect(1, 1590, '\P{Joining_Group=-_Tah}', ""); +Expect(0, 1590, '\P{^Joining_Group=-_Tah}', ""); +Error('\p{Jg=-:=Tah}'); +Error('\P{Jg=-:=Tah}'); +Expect(1, 1592, '\p{Jg=tah}', ""); +Expect(0, 1592, '\p{^Jg=tah}', ""); +Expect(0, 1592, '\P{Jg=tah}', ""); +Expect(1, 1592, '\P{^Jg=tah}', ""); +Expect(0, 1590, '\p{Jg=tah}', ""); +Expect(1, 1590, '\p{^Jg=tah}', ""); +Expect(1, 1590, '\P{Jg=tah}', ""); +Expect(0, 1590, '\P{^Jg=tah}', ""); +Expect(1, 1592, '\p{Jg=_Tah}', ""); +Expect(0, 1592, '\p{^Jg=_Tah}', ""); +Expect(0, 1592, '\P{Jg=_Tah}', ""); +Expect(1, 1592, '\P{^Jg=_Tah}', ""); +Expect(0, 1590, '\p{Jg=_Tah}', ""); +Expect(1, 1590, '\p{^Jg=_Tah}', ""); +Expect(1, 1590, '\P{Jg=_Tah}', ""); +Expect(0, 1590, '\P{^Jg=_Tah}', ""); +Error('\p{Is_Joining_Group=:=Tah}'); +Error('\P{Is_Joining_Group=:=Tah}'); +Expect(1, 1592, '\p{Is_Joining_Group=tah}', ""); +Expect(0, 1592, '\p{^Is_Joining_Group=tah}', ""); +Expect(0, 1592, '\P{Is_Joining_Group=tah}', ""); +Expect(1, 1592, '\P{^Is_Joining_Group=tah}', ""); +Expect(0, 1590, '\p{Is_Joining_Group=tah}', ""); +Expect(1, 1590, '\p{^Is_Joining_Group=tah}', ""); +Expect(1, 1590, '\P{Is_Joining_Group=tah}', ""); +Expect(0, 1590, '\P{^Is_Joining_Group=tah}', ""); +Expect(1, 1592, '\p{Is_Joining_Group=_tah}', ""); +Expect(0, 1592, '\p{^Is_Joining_Group=_tah}', ""); +Expect(0, 1592, '\P{Is_Joining_Group=_tah}', ""); +Expect(1, 1592, '\P{^Is_Joining_Group=_tah}', ""); +Expect(0, 1590, '\p{Is_Joining_Group=_tah}', ""); +Expect(1, 1590, '\p{^Is_Joining_Group=_tah}', ""); +Expect(1, 1590, '\P{Is_Joining_Group=_tah}', ""); +Expect(0, 1590, '\P{^Is_Joining_Group=_tah}', ""); +Error('\p{Is_Jg= /a/TAH}'); +Error('\P{Is_Jg= /a/TAH}'); +Expect(1, 1592, '\p{Is_Jg=tah}', ""); +Expect(0, 1592, '\p{^Is_Jg=tah}', ""); +Expect(0, 1592, '\P{Is_Jg=tah}', ""); +Expect(1, 1592, '\P{^Is_Jg=tah}', ""); +Expect(0, 1590, '\p{Is_Jg=tah}', ""); +Expect(1, 1590, '\p{^Is_Jg=tah}', ""); +Expect(1, 1590, '\P{Is_Jg=tah}', ""); +Expect(0, 1590, '\P{^Is_Jg=tah}', ""); +Expect(1, 1592, '\p{Is_Jg: tah}', ""); +Expect(0, 1592, '\p{^Is_Jg: tah}', ""); +Expect(0, 1592, '\P{Is_Jg: tah}', ""); +Expect(1, 1592, '\P{^Is_Jg: tah}', ""); +Expect(0, 1590, '\p{Is_Jg: tah}', ""); +Expect(1, 1590, '\p{^Is_Jg: tah}', ""); +Expect(1, 1590, '\P{Is_Jg: tah}', ""); +Expect(0, 1590, '\P{^Is_Jg: tah}', ""); +Error('\p{Joining_Group=--zhain:=}'); +Error('\P{Joining_Group=--zhain:=}'); +Expect(1, 1869, '\p{Joining_Group=zhain}', ""); +Expect(0, 1869, '\p{^Joining_Group=zhain}', ""); +Expect(0, 1869, '\P{Joining_Group=zhain}', ""); +Expect(1, 1869, '\P{^Joining_Group=zhain}', ""); +Expect(0, 1868, '\p{Joining_Group=zhain}', ""); +Expect(1, 1868, '\p{^Joining_Group=zhain}', ""); +Expect(1, 1868, '\P{Joining_Group=zhain}', ""); +Expect(0, 1868, '\P{^Joining_Group=zhain}', ""); +Expect(1, 1869, '\p{Joining_Group=_ Zhain}', ""); +Expect(0, 1869, '\p{^Joining_Group=_ Zhain}', ""); +Expect(0, 1869, '\P{Joining_Group=_ Zhain}', ""); +Expect(1, 1869, '\P{^Joining_Group=_ Zhain}', ""); +Expect(0, 1868, '\p{Joining_Group=_ Zhain}', ""); +Expect(1, 1868, '\p{^Joining_Group=_ Zhain}', ""); +Expect(1, 1868, '\P{Joining_Group=_ Zhain}', ""); +Expect(0, 1868, '\P{^Joining_Group=_ Zhain}', ""); +Error('\p{Jg=/a/- zhain}'); +Error('\P{Jg=/a/- zhain}'); +Expect(1, 1869, '\p{Jg=zhain}', ""); +Expect(0, 1869, '\p{^Jg=zhain}', ""); +Expect(0, 1869, '\P{Jg=zhain}', ""); +Expect(1, 1869, '\P{^Jg=zhain}', ""); +Expect(0, 1868, '\p{Jg=zhain}', ""); +Expect(1, 1868, '\p{^Jg=zhain}', ""); +Expect(1, 1868, '\P{Jg=zhain}', ""); +Expect(0, 1868, '\P{^Jg=zhain}', ""); +Expect(1, 1869, '\p{Jg: ZHAIN}', ""); +Expect(0, 1869, '\p{^Jg: ZHAIN}', ""); +Expect(0, 1869, '\P{Jg: ZHAIN}', ""); +Expect(1, 1869, '\P{^Jg: ZHAIN}', ""); +Expect(0, 1868, '\p{Jg: ZHAIN}', ""); +Expect(1, 1868, '\p{^Jg: ZHAIN}', ""); +Expect(1, 1868, '\P{Jg: ZHAIN}', ""); +Expect(0, 1868, '\P{^Jg: ZHAIN}', ""); +Error('\p{Is_Joining_Group=:=_ ZHAIN}'); +Error('\P{Is_Joining_Group=:=_ ZHAIN}'); +Expect(1, 1869, '\p{Is_Joining_Group=zhain}', ""); +Expect(0, 1869, '\p{^Is_Joining_Group=zhain}', ""); +Expect(0, 1869, '\P{Is_Joining_Group=zhain}', ""); +Expect(1, 1869, '\P{^Is_Joining_Group=zhain}', ""); +Expect(0, 1868, '\p{Is_Joining_Group=zhain}', ""); +Expect(1, 1868, '\p{^Is_Joining_Group=zhain}', ""); +Expect(1, 1868, '\P{Is_Joining_Group=zhain}', ""); +Expect(0, 1868, '\P{^Is_Joining_Group=zhain}', ""); +Expect(1, 1869, '\p{Is_Joining_Group= -Zhain}', ""); +Expect(0, 1869, '\p{^Is_Joining_Group= -Zhain}', ""); +Expect(0, 1869, '\P{Is_Joining_Group= -Zhain}', ""); +Expect(1, 1869, '\P{^Is_Joining_Group= -Zhain}', ""); +Expect(0, 1868, '\p{Is_Joining_Group= -Zhain}', ""); +Expect(1, 1868, '\p{^Is_Joining_Group= -Zhain}', ""); +Expect(1, 1868, '\P{Is_Joining_Group= -Zhain}', ""); +Expect(0, 1868, '\P{^Is_Joining_Group= -Zhain}', ""); +Error('\p{Is_Jg=:=-Zhain}'); +Error('\P{Is_Jg=:=-Zhain}'); +Expect(1, 1869, '\p{Is_Jg=zhain}', ""); +Expect(0, 1869, '\p{^Is_Jg=zhain}', ""); +Expect(0, 1869, '\P{Is_Jg=zhain}', ""); +Expect(1, 1869, '\P{^Is_Jg=zhain}', ""); +Expect(0, 1868, '\p{Is_Jg=zhain}', ""); +Expect(1, 1868, '\p{^Is_Jg=zhain}', ""); +Expect(1, 1868, '\P{Is_Jg=zhain}', ""); +Expect(0, 1868, '\P{^Is_Jg=zhain}', ""); +Expect(1, 1869, '\p{Is_Jg=- Zhain}', ""); +Expect(0, 1869, '\p{^Is_Jg=- Zhain}', ""); +Expect(0, 1869, '\P{Is_Jg=- Zhain}', ""); +Expect(1, 1869, '\P{^Is_Jg=- Zhain}', ""); +Expect(0, 1868, '\p{Is_Jg=- Zhain}', ""); +Expect(1, 1868, '\p{^Is_Jg=- Zhain}', ""); +Expect(1, 1868, '\P{Is_Jg=- Zhain}', ""); +Expect(0, 1868, '\P{^Is_Jg=- Zhain}', ""); +Error('\p{Joining_Group=:=_ Pe}'); +Error('\P{Joining_Group=:=_ Pe}'); +Expect(1, 1830, '\p{Joining_Group=pe}', ""); +Expect(0, 1830, '\p{^Joining_Group=pe}', ""); +Expect(0, 1830, '\P{Joining_Group=pe}', ""); +Expect(1, 1830, '\P{^Joining_Group=pe}', ""); +Expect(0, 1829, '\p{Joining_Group=pe}', ""); +Expect(1, 1829, '\p{^Joining_Group=pe}', ""); +Expect(1, 1829, '\P{Joining_Group=pe}', ""); +Expect(0, 1829, '\P{^Joining_Group=pe}', ""); +Expect(1, 1830, '\p{Joining_Group= PE}', ""); +Expect(0, 1830, '\p{^Joining_Group= PE}', ""); +Expect(0, 1830, '\P{Joining_Group= PE}', ""); +Expect(1, 1830, '\P{^Joining_Group= PE}', ""); +Expect(0, 1829, '\p{Joining_Group= PE}', ""); +Expect(1, 1829, '\p{^Joining_Group= PE}', ""); +Expect(1, 1829, '\P{Joining_Group= PE}', ""); +Expect(0, 1829, '\P{^Joining_Group= PE}', ""); +Error('\p{Jg=-/a/Pe}'); +Error('\P{Jg=-/a/Pe}'); +Expect(1, 1830, '\p{Jg=pe}', ""); +Expect(0, 1830, '\p{^Jg=pe}', ""); +Expect(0, 1830, '\P{Jg=pe}', ""); +Expect(1, 1830, '\P{^Jg=pe}', ""); +Expect(0, 1829, '\p{Jg=pe}', ""); +Expect(1, 1829, '\p{^Jg=pe}', ""); +Expect(1, 1829, '\P{Jg=pe}', ""); +Expect(0, 1829, '\P{^Jg=pe}', ""); +Expect(1, 1830, '\p{Jg= pe}', ""); +Expect(0, 1830, '\p{^Jg= pe}', ""); +Expect(0, 1830, '\P{Jg= pe}', ""); +Expect(1, 1830, '\P{^Jg= pe}', ""); +Expect(0, 1829, '\p{Jg= pe}', ""); +Expect(1, 1829, '\p{^Jg= pe}', ""); +Expect(1, 1829, '\P{Jg= pe}', ""); +Expect(0, 1829, '\P{^Jg= pe}', ""); +Error('\p{Is_Joining_Group= Pe/a/}'); +Error('\P{Is_Joining_Group= Pe/a/}'); +Expect(1, 1830, '\p{Is_Joining_Group=pe}', ""); +Expect(0, 1830, '\p{^Is_Joining_Group=pe}', ""); +Expect(0, 1830, '\P{Is_Joining_Group=pe}', ""); +Expect(1, 1830, '\P{^Is_Joining_Group=pe}', ""); +Expect(0, 1829, '\p{Is_Joining_Group=pe}', ""); +Expect(1, 1829, '\p{^Is_Joining_Group=pe}', ""); +Expect(1, 1829, '\P{Is_Joining_Group=pe}', ""); +Expect(0, 1829, '\P{^Is_Joining_Group=pe}', ""); +Expect(1, 1830, '\p{Is_Joining_Group= Pe}', ""); +Expect(0, 1830, '\p{^Is_Joining_Group= Pe}', ""); +Expect(0, 1830, '\P{Is_Joining_Group= Pe}', ""); +Expect(1, 1830, '\P{^Is_Joining_Group= Pe}', ""); +Expect(0, 1829, '\p{Is_Joining_Group= Pe}', ""); +Expect(1, 1829, '\p{^Is_Joining_Group= Pe}', ""); +Expect(1, 1829, '\P{Is_Joining_Group= Pe}', ""); +Expect(0, 1829, '\P{^Is_Joining_Group= Pe}', ""); +Error('\p{Is_Jg=-/a/PE}'); +Error('\P{Is_Jg=-/a/PE}'); +Expect(1, 1830, '\p{Is_Jg=pe}', ""); +Expect(0, 1830, '\p{^Is_Jg=pe}', ""); +Expect(0, 1830, '\P{Is_Jg=pe}', ""); +Expect(1, 1830, '\P{^Is_Jg=pe}', ""); +Expect(0, 1829, '\p{Is_Jg=pe}', ""); +Expect(1, 1829, '\p{^Is_Jg=pe}', ""); +Expect(1, 1829, '\P{Is_Jg=pe}', ""); +Expect(0, 1829, '\P{^Is_Jg=pe}', ""); +Expect(1, 1830, '\p{Is_Jg= _pe}', ""); +Expect(0, 1830, '\p{^Is_Jg= _pe}', ""); +Expect(0, 1830, '\P{Is_Jg= _pe}', ""); +Expect(1, 1830, '\P{^Is_Jg= _pe}', ""); +Expect(0, 1829, '\p{Is_Jg= _pe}', ""); +Expect(1, 1829, '\p{^Is_Jg= _pe}', ""); +Expect(1, 1829, '\P{Is_Jg= _pe}', ""); +Expect(0, 1829, '\P{^Is_Jg= _pe}', ""); +Error('\p{Joining_Group=:= Gaf}'); +Error('\P{Joining_Group=:= Gaf}'); +Expect(1, 1596, '\p{Joining_Group=gaf}', ""); +Expect(0, 1596, '\p{^Joining_Group=gaf}', ""); +Expect(0, 1596, '\P{Joining_Group=gaf}', ""); +Expect(1, 1596, '\P{^Joining_Group=gaf}', ""); +Expect(0, 1594, '\p{Joining_Group=gaf}', ""); +Expect(1, 1594, '\p{^Joining_Group=gaf}', ""); +Expect(1, 1594, '\P{Joining_Group=gaf}', ""); +Expect(0, 1594, '\P{^Joining_Group=gaf}', ""); +Expect(1, 1596, '\p{Joining_Group= _GAF}', ""); +Expect(0, 1596, '\p{^Joining_Group= _GAF}', ""); +Expect(0, 1596, '\P{Joining_Group= _GAF}', ""); +Expect(1, 1596, '\P{^Joining_Group= _GAF}', ""); +Expect(0, 1594, '\p{Joining_Group= _GAF}', ""); +Expect(1, 1594, '\p{^Joining_Group= _GAF}', ""); +Expect(1, 1594, '\P{Joining_Group= _GAF}', ""); +Expect(0, 1594, '\P{^Joining_Group= _GAF}', ""); +Error('\p{Jg=:= Gaf}'); +Error('\P{Jg=:= Gaf}'); +Expect(1, 1596, '\p{Jg: gaf}', ""); +Expect(0, 1596, '\p{^Jg: gaf}', ""); +Expect(0, 1596, '\P{Jg: gaf}', ""); +Expect(1, 1596, '\P{^Jg: gaf}', ""); +Expect(0, 1594, '\p{Jg: gaf}', ""); +Expect(1, 1594, '\p{^Jg: gaf}', ""); +Expect(1, 1594, '\P{Jg: gaf}', ""); +Expect(0, 1594, '\P{^Jg: gaf}', ""); +Expect(1, 1596, '\p{Jg: Gaf}', ""); +Expect(0, 1596, '\p{^Jg: Gaf}', ""); +Expect(0, 1596, '\P{Jg: Gaf}', ""); +Expect(1, 1596, '\P{^Jg: Gaf}', ""); +Expect(0, 1594, '\p{Jg: Gaf}', ""); +Expect(1, 1594, '\p{^Jg: Gaf}', ""); +Expect(1, 1594, '\P{Jg: Gaf}', ""); +Expect(0, 1594, '\P{^Jg: Gaf}', ""); +Error('\p{Is_Joining_Group=:=-_Gaf}'); +Error('\P{Is_Joining_Group=:=-_Gaf}'); +Expect(1, 1596, '\p{Is_Joining_Group=gaf}', ""); +Expect(0, 1596, '\p{^Is_Joining_Group=gaf}', ""); +Expect(0, 1596, '\P{Is_Joining_Group=gaf}', ""); +Expect(1, 1596, '\P{^Is_Joining_Group=gaf}', ""); +Expect(0, 1594, '\p{Is_Joining_Group=gaf}', ""); +Expect(1, 1594, '\p{^Is_Joining_Group=gaf}', ""); +Expect(1, 1594, '\P{Is_Joining_Group=gaf}', ""); +Expect(0, 1594, '\P{^Is_Joining_Group=gaf}', ""); +Expect(1, 1596, '\p{Is_Joining_Group: gaf}', ""); +Expect(0, 1596, '\p{^Is_Joining_Group: gaf}', ""); +Expect(0, 1596, '\P{Is_Joining_Group: gaf}', ""); +Expect(1, 1596, '\P{^Is_Joining_Group: gaf}', ""); +Expect(0, 1594, '\p{Is_Joining_Group: gaf}', ""); +Expect(1, 1594, '\p{^Is_Joining_Group: gaf}', ""); +Expect(1, 1594, '\P{Is_Joining_Group: gaf}', ""); +Expect(0, 1594, '\P{^Is_Joining_Group: gaf}', ""); +Error('\p{Is_Jg=:=_-gaf}'); +Error('\P{Is_Jg=:=_-gaf}'); +Expect(1, 1596, '\p{Is_Jg=gaf}', ""); +Expect(0, 1596, '\p{^Is_Jg=gaf}', ""); +Expect(0, 1596, '\P{Is_Jg=gaf}', ""); +Expect(1, 1596, '\P{^Is_Jg=gaf}', ""); +Expect(0, 1594, '\p{Is_Jg=gaf}', ""); +Expect(1, 1594, '\p{^Is_Jg=gaf}', ""); +Expect(1, 1594, '\P{Is_Jg=gaf}', ""); +Expect(0, 1594, '\P{^Is_Jg=gaf}', ""); +Expect(1, 1596, '\p{Is_Jg=_-Gaf}', ""); +Expect(0, 1596, '\p{^Is_Jg=_-Gaf}', ""); +Expect(0, 1596, '\P{Is_Jg=_-Gaf}', ""); +Expect(1, 1596, '\P{^Is_Jg=_-Gaf}', ""); +Expect(0, 1594, '\p{Is_Jg=_-Gaf}', ""); +Expect(1, 1594, '\p{^Is_Jg=_-Gaf}', ""); +Expect(1, 1594, '\P{Is_Jg=_-Gaf}', ""); +Expect(0, 1594, '\P{^Is_Jg=_-Gaf}', ""); +Error('\p{Joining_Group= :=Waw}'); +Error('\P{Joining_Group= :=Waw}'); +Expect(1, 1572, '\p{Joining_Group=waw}', ""); +Expect(0, 1572, '\p{^Joining_Group=waw}', ""); +Expect(0, 1572, '\P{Joining_Group=waw}', ""); +Expect(1, 1572, '\P{^Joining_Group=waw}', ""); +Expect(0, 1571, '\p{Joining_Group=waw}', ""); +Expect(1, 1571, '\p{^Joining_Group=waw}', ""); +Expect(1, 1571, '\P{Joining_Group=waw}', ""); +Expect(0, 1571, '\P{^Joining_Group=waw}', ""); +Expect(1, 1572, '\p{Joining_Group=-WAW}', ""); +Expect(0, 1572, '\p{^Joining_Group=-WAW}', ""); +Expect(0, 1572, '\P{Joining_Group=-WAW}', ""); +Expect(1, 1572, '\P{^Joining_Group=-WAW}', ""); +Expect(0, 1571, '\p{Joining_Group=-WAW}', ""); +Expect(1, 1571, '\p{^Joining_Group=-WAW}', ""); +Expect(1, 1571, '\P{Joining_Group=-WAW}', ""); +Expect(0, 1571, '\P{^Joining_Group=-WAW}', ""); +Error('\p{Jg= /a/WAW}'); +Error('\P{Jg= /a/WAW}'); +Expect(1, 1572, '\p{Jg=waw}', ""); +Expect(0, 1572, '\p{^Jg=waw}', ""); +Expect(0, 1572, '\P{Jg=waw}', ""); +Expect(1, 1572, '\P{^Jg=waw}', ""); +Expect(0, 1571, '\p{Jg=waw}', ""); +Expect(1, 1571, '\p{^Jg=waw}', ""); +Expect(1, 1571, '\P{Jg=waw}', ""); +Expect(0, 1571, '\P{^Jg=waw}', ""); +Expect(1, 1572, '\p{Jg=-WAW}', ""); +Expect(0, 1572, '\p{^Jg=-WAW}', ""); +Expect(0, 1572, '\P{Jg=-WAW}', ""); +Expect(1, 1572, '\P{^Jg=-WAW}', ""); +Expect(0, 1571, '\p{Jg=-WAW}', ""); +Expect(1, 1571, '\p{^Jg=-WAW}', ""); +Expect(1, 1571, '\P{Jg=-WAW}', ""); +Expect(0, 1571, '\P{^Jg=-WAW}', ""); +Error('\p{Is_Joining_Group=_:=Waw}'); +Error('\P{Is_Joining_Group=_:=Waw}'); +Expect(1, 1572, '\p{Is_Joining_Group: waw}', ""); +Expect(0, 1572, '\p{^Is_Joining_Group: waw}', ""); +Expect(0, 1572, '\P{Is_Joining_Group: waw}', ""); +Expect(1, 1572, '\P{^Is_Joining_Group: waw}', ""); +Expect(0, 1571, '\p{Is_Joining_Group: waw}', ""); +Expect(1, 1571, '\p{^Is_Joining_Group: waw}', ""); +Expect(1, 1571, '\P{Is_Joining_Group: waw}', ""); +Expect(0, 1571, '\P{^Is_Joining_Group: waw}', ""); +Expect(1, 1572, '\p{Is_Joining_Group: _waw}', ""); +Expect(0, 1572, '\p{^Is_Joining_Group: _waw}', ""); +Expect(0, 1572, '\P{Is_Joining_Group: _waw}', ""); +Expect(1, 1572, '\P{^Is_Joining_Group: _waw}', ""); +Expect(0, 1571, '\p{Is_Joining_Group: _waw}', ""); +Expect(1, 1571, '\p{^Is_Joining_Group: _waw}', ""); +Expect(1, 1571, '\P{Is_Joining_Group: _waw}', ""); +Expect(0, 1571, '\P{^Is_Joining_Group: _waw}', ""); +Error('\p{Is_Jg=/a/ Waw}'); +Error('\P{Is_Jg=/a/ Waw}'); +Expect(1, 1572, '\p{Is_Jg=waw}', ""); +Expect(0, 1572, '\p{^Is_Jg=waw}', ""); +Expect(0, 1572, '\P{Is_Jg=waw}', ""); +Expect(1, 1572, '\P{^Is_Jg=waw}', ""); +Expect(0, 1571, '\p{Is_Jg=waw}', ""); +Expect(1, 1571, '\p{^Is_Jg=waw}', ""); +Expect(1, 1571, '\P{Is_Jg=waw}', ""); +Expect(0, 1571, '\P{^Is_Jg=waw}', ""); +Expect(1, 1572, '\p{Is_Jg=- waw}', ""); +Expect(0, 1572, '\p{^Is_Jg=- waw}', ""); +Expect(0, 1572, '\P{Is_Jg=- waw}', ""); +Expect(1, 1572, '\P{^Is_Jg=- waw}', ""); +Expect(0, 1571, '\p{Is_Jg=- waw}', ""); +Expect(1, 1571, '\p{^Is_Jg=- waw}', ""); +Expect(1, 1571, '\P{Is_Jg=- waw}', ""); +Expect(0, 1571, '\P{^Is_Jg=- waw}', ""); +Error('\p{Joining_Group=:=_Yudh}'); +Error('\P{Joining_Group=:=_Yudh}'); +Expect(1, 1821, '\p{Joining_Group=yudh}', ""); +Expect(0, 1821, '\p{^Joining_Group=yudh}', ""); +Expect(0, 1821, '\P{Joining_Group=yudh}', ""); +Expect(1, 1821, '\P{^Joining_Group=yudh}', ""); +Expect(0, 1820, '\p{Joining_Group=yudh}', ""); +Expect(1, 1820, '\p{^Joining_Group=yudh}', ""); +Expect(1, 1820, '\P{Joining_Group=yudh}', ""); +Expect(0, 1820, '\P{^Joining_Group=yudh}', ""); +Expect(1, 1821, '\p{Joining_Group=_Yudh}', ""); +Expect(0, 1821, '\p{^Joining_Group=_Yudh}', ""); +Expect(0, 1821, '\P{Joining_Group=_Yudh}', ""); +Expect(1, 1821, '\P{^Joining_Group=_Yudh}', ""); +Expect(0, 1820, '\p{Joining_Group=_Yudh}', ""); +Expect(1, 1820, '\p{^Joining_Group=_Yudh}', ""); +Expect(1, 1820, '\P{Joining_Group=_Yudh}', ""); +Expect(0, 1820, '\P{^Joining_Group=_Yudh}', ""); +Error('\p{Jg: - Yudh/a/}'); +Error('\P{Jg: - Yudh/a/}'); +Expect(1, 1821, '\p{Jg=yudh}', ""); +Expect(0, 1821, '\p{^Jg=yudh}', ""); +Expect(0, 1821, '\P{Jg=yudh}', ""); +Expect(1, 1821, '\P{^Jg=yudh}', ""); +Expect(0, 1820, '\p{Jg=yudh}', ""); +Expect(1, 1820, '\p{^Jg=yudh}', ""); +Expect(1, 1820, '\P{Jg=yudh}', ""); +Expect(0, 1820, '\P{^Jg=yudh}', ""); +Expect(1, 1821, '\p{Jg: _Yudh}', ""); +Expect(0, 1821, '\p{^Jg: _Yudh}', ""); +Expect(0, 1821, '\P{Jg: _Yudh}', ""); +Expect(1, 1821, '\P{^Jg: _Yudh}', ""); +Expect(0, 1820, '\p{Jg: _Yudh}', ""); +Expect(1, 1820, '\p{^Jg: _Yudh}', ""); +Expect(1, 1820, '\P{Jg: _Yudh}', ""); +Expect(0, 1820, '\P{^Jg: _Yudh}', ""); +Error('\p{Is_Joining_Group=/a/_-Yudh}'); +Error('\P{Is_Joining_Group=/a/_-Yudh}'); +Expect(1, 1821, '\p{Is_Joining_Group:yudh}', ""); +Expect(0, 1821, '\p{^Is_Joining_Group:yudh}', ""); +Expect(0, 1821, '\P{Is_Joining_Group:yudh}', ""); +Expect(1, 1821, '\P{^Is_Joining_Group:yudh}', ""); +Expect(0, 1820, '\p{Is_Joining_Group:yudh}', ""); +Expect(1, 1820, '\p{^Is_Joining_Group:yudh}', ""); +Expect(1, 1820, '\P{Is_Joining_Group:yudh}', ""); +Expect(0, 1820, '\P{^Is_Joining_Group:yudh}', ""); +Expect(1, 1821, '\p{Is_Joining_Group=_yudh}', ""); +Expect(0, 1821, '\p{^Is_Joining_Group=_yudh}', ""); +Expect(0, 1821, '\P{Is_Joining_Group=_yudh}', ""); +Expect(1, 1821, '\P{^Is_Joining_Group=_yudh}', ""); +Expect(0, 1820, '\p{Is_Joining_Group=_yudh}', ""); +Expect(1, 1820, '\p{^Is_Joining_Group=_yudh}', ""); +Expect(1, 1820, '\P{Is_Joining_Group=_yudh}', ""); +Expect(0, 1820, '\P{^Is_Joining_Group=_yudh}', ""); +Error('\p{Is_Jg=_:=YUDH}'); +Error('\P{Is_Jg=_:=YUDH}'); +Expect(1, 1821, '\p{Is_Jg=yudh}', ""); +Expect(0, 1821, '\p{^Is_Jg=yudh}', ""); +Expect(0, 1821, '\P{Is_Jg=yudh}', ""); +Expect(1, 1821, '\P{^Is_Jg=yudh}', ""); +Expect(0, 1820, '\p{Is_Jg=yudh}', ""); +Expect(1, 1820, '\p{^Is_Jg=yudh}', ""); +Expect(1, 1820, '\P{Is_Jg=yudh}', ""); +Expect(0, 1820, '\P{^Is_Jg=yudh}', ""); +Expect(1, 1821, '\p{Is_Jg= -Yudh}', ""); +Expect(0, 1821, '\p{^Is_Jg= -Yudh}', ""); +Expect(0, 1821, '\P{Is_Jg= -Yudh}', ""); +Expect(1, 1821, '\P{^Is_Jg= -Yudh}', ""); +Expect(0, 1820, '\p{Is_Jg= -Yudh}', ""); +Expect(1, 1820, '\p{^Is_Jg= -Yudh}', ""); +Expect(1, 1820, '\P{Is_Jg= -Yudh}', ""); +Expect(0, 1820, '\P{^Is_Jg= -Yudh}', ""); +Error('\p{Pattern_White_Space=:=_YES}'); +Error('\P{Pattern_White_Space=:=_YES}'); +Expect(1, 13, '\p{Pattern_White_Space=yes}', ""); +Expect(0, 13, '\p{^Pattern_White_Space=yes}', ""); +Expect(0, 13, '\P{Pattern_White_Space=yes}', ""); +Expect(1, 13, '\P{^Pattern_White_Space=yes}', ""); +Expect(0, 8, '\p{Pattern_White_Space=yes}', ""); +Expect(1, 8, '\p{^Pattern_White_Space=yes}', ""); +Expect(1, 8, '\P{Pattern_White_Space=yes}', ""); +Expect(0, 8, '\P{^Pattern_White_Space=yes}', ""); +Expect(1, 13, '\p{Pattern_White_Space=- YES}', ""); +Expect(0, 13, '\p{^Pattern_White_Space=- YES}', ""); +Expect(0, 13, '\P{Pattern_White_Space=- YES}', ""); +Expect(1, 13, '\P{^Pattern_White_Space=- YES}', ""); +Expect(0, 8, '\p{Pattern_White_Space=- YES}', ""); +Expect(1, 8, '\p{^Pattern_White_Space=- YES}', ""); +Expect(1, 8, '\P{Pattern_White_Space=- YES}', ""); +Expect(0, 8, '\P{^Pattern_White_Space=- YES}', ""); +Error('\p{Pat_WS= Y:=}'); +Error('\P{Pat_WS= Y:=}'); +Expect(1, 13, '\p{Pat_WS:y}', ""); +Expect(0, 13, '\p{^Pat_WS:y}', ""); +Expect(0, 13, '\P{Pat_WS:y}', ""); +Expect(1, 13, '\P{^Pat_WS:y}', ""); +Expect(0, 8, '\p{Pat_WS:y}', ""); +Expect(1, 8, '\p{^Pat_WS:y}', ""); +Expect(1, 8, '\P{Pat_WS:y}', ""); +Expect(0, 8, '\P{^Pat_WS:y}', ""); +Expect(1, 13, '\p{Pat_WS= y}', ""); +Expect(0, 13, '\p{^Pat_WS= y}', ""); +Expect(0, 13, '\P{Pat_WS= y}', ""); +Expect(1, 13, '\P{^Pat_WS= y}', ""); +Expect(0, 8, '\p{Pat_WS= y}', ""); +Expect(1, 8, '\p{^Pat_WS= y}', ""); +Expect(1, 8, '\P{Pat_WS= y}', ""); +Expect(0, 8, '\P{^Pat_WS= y}', ""); +Error('\p{Is_Pattern_White_Space=:= T}'); +Error('\P{Is_Pattern_White_Space=:= T}'); +Expect(1, 13, '\p{Is_Pattern_White_Space=t}', ""); +Expect(0, 13, '\p{^Is_Pattern_White_Space=t}', ""); +Expect(0, 13, '\P{Is_Pattern_White_Space=t}', ""); +Expect(1, 13, '\P{^Is_Pattern_White_Space=t}', ""); +Expect(0, 8, '\p{Is_Pattern_White_Space=t}', ""); +Expect(1, 8, '\p{^Is_Pattern_White_Space=t}', ""); +Expect(1, 8, '\P{Is_Pattern_White_Space=t}', ""); +Expect(0, 8, '\P{^Is_Pattern_White_Space=t}', ""); +Expect(1, 13, '\p{Is_Pattern_White_Space= T}', ""); +Expect(0, 13, '\p{^Is_Pattern_White_Space= T}', ""); +Expect(0, 13, '\P{Is_Pattern_White_Space= T}', ""); +Expect(1, 13, '\P{^Is_Pattern_White_Space= T}', ""); +Expect(0, 8, '\p{Is_Pattern_White_Space= T}', ""); +Expect(1, 8, '\p{^Is_Pattern_White_Space= T}', ""); +Expect(1, 8, '\P{Is_Pattern_White_Space= T}', ""); +Expect(0, 8, '\P{^Is_Pattern_White_Space= T}', ""); +Error('\p{Is_Pat_WS=/a/_-TRUE}'); +Error('\P{Is_Pat_WS=/a/_-TRUE}'); +Expect(1, 13, '\p{Is_Pat_WS=true}', ""); +Expect(0, 13, '\p{^Is_Pat_WS=true}', ""); +Expect(0, 13, '\P{Is_Pat_WS=true}', ""); +Expect(1, 13, '\P{^Is_Pat_WS=true}', ""); +Expect(0, 8, '\p{Is_Pat_WS=true}', ""); +Expect(1, 8, '\p{^Is_Pat_WS=true}', ""); +Expect(1, 8, '\P{Is_Pat_WS=true}', ""); +Expect(0, 8, '\P{^Is_Pat_WS=true}', ""); +Expect(1, 13, '\p{Is_Pat_WS= _True}', ""); +Expect(0, 13, '\p{^Is_Pat_WS= _True}', ""); +Expect(0, 13, '\P{Is_Pat_WS= _True}', ""); +Expect(1, 13, '\P{^Is_Pat_WS= _True}', ""); +Expect(0, 8, '\p{Is_Pat_WS= _True}', ""); +Expect(1, 8, '\p{^Is_Pat_WS= _True}', ""); +Expect(1, 8, '\P{Is_Pat_WS= _True}', ""); +Expect(0, 8, '\P{^Is_Pat_WS= _True}', ""); +Error('\p{Pattern_White_Space= /a/no}'); +Error('\P{Pattern_White_Space= /a/no}'); +Expect(1, 8, '\p{Pattern_White_Space=no}', ""); +Expect(0, 8, '\p{^Pattern_White_Space=no}', ""); +Expect(0, 8, '\P{Pattern_White_Space=no}', ""); +Expect(1, 8, '\P{^Pattern_White_Space=no}', ""); +Expect(0, 13, '\p{Pattern_White_Space=no}', ""); +Expect(1, 13, '\p{^Pattern_White_Space=no}', ""); +Expect(1, 13, '\P{Pattern_White_Space=no}', ""); +Expect(0, 13, '\P{^Pattern_White_Space=no}', ""); +Expect(1, 8, '\p{Pattern_White_Space= no}', ""); +Expect(0, 8, '\p{^Pattern_White_Space= no}', ""); +Expect(0, 8, '\P{Pattern_White_Space= no}', ""); +Expect(1, 8, '\P{^Pattern_White_Space= no}', ""); +Expect(0, 13, '\p{Pattern_White_Space= no}', ""); +Expect(1, 13, '\p{^Pattern_White_Space= no}', ""); +Expect(1, 13, '\P{Pattern_White_Space= no}', ""); +Expect(0, 13, '\P{^Pattern_White_Space= no}', ""); +Error('\p{Pat_WS= N/a/}'); +Error('\P{Pat_WS= N/a/}'); +Expect(1, 8, '\p{Pat_WS=n}', ""); +Expect(0, 8, '\p{^Pat_WS=n}', ""); +Expect(0, 8, '\P{Pat_WS=n}', ""); +Expect(1, 8, '\P{^Pat_WS=n}', ""); +Expect(0, 13, '\p{Pat_WS=n}', ""); +Expect(1, 13, '\p{^Pat_WS=n}', ""); +Expect(1, 13, '\P{Pat_WS=n}', ""); +Expect(0, 13, '\P{^Pat_WS=n}', ""); +Expect(1, 8, '\p{Pat_WS= N}', ""); +Expect(0, 8, '\p{^Pat_WS= N}', ""); +Expect(0, 8, '\P{Pat_WS= N}', ""); +Expect(1, 8, '\P{^Pat_WS= N}', ""); +Expect(0, 13, '\p{Pat_WS= N}', ""); +Expect(1, 13, '\p{^Pat_WS= N}', ""); +Expect(1, 13, '\P{Pat_WS= N}', ""); +Expect(0, 13, '\P{^Pat_WS= N}', ""); +Error('\p{Is_Pattern_White_Space= :=F}'); +Error('\P{Is_Pattern_White_Space= :=F}'); +Expect(1, 8, '\p{Is_Pattern_White_Space=f}', ""); +Expect(0, 8, '\p{^Is_Pattern_White_Space=f}', ""); +Expect(0, 8, '\P{Is_Pattern_White_Space=f}', ""); +Expect(1, 8, '\P{^Is_Pattern_White_Space=f}', ""); +Expect(0, 13, '\p{Is_Pattern_White_Space=f}', ""); +Expect(1, 13, '\p{^Is_Pattern_White_Space=f}', ""); +Expect(1, 13, '\P{Is_Pattern_White_Space=f}', ""); +Expect(0, 13, '\P{^Is_Pattern_White_Space=f}', ""); +Expect(1, 8, '\p{Is_Pattern_White_Space=__F}', ""); +Expect(0, 8, '\p{^Is_Pattern_White_Space=__F}', ""); +Expect(0, 8, '\P{Is_Pattern_White_Space=__F}', ""); +Expect(1, 8, '\P{^Is_Pattern_White_Space=__F}', ""); +Expect(0, 13, '\p{Is_Pattern_White_Space=__F}', ""); +Expect(1, 13, '\p{^Is_Pattern_White_Space=__F}', ""); +Expect(1, 13, '\P{Is_Pattern_White_Space=__F}', ""); +Expect(0, 13, '\P{^Is_Pattern_White_Space=__F}', ""); +Error('\p{Is_Pat_WS=_/a/False}'); +Error('\P{Is_Pat_WS=_/a/False}'); +Expect(1, 8, '\p{Is_Pat_WS=false}', ""); +Expect(0, 8, '\p{^Is_Pat_WS=false}', ""); +Expect(0, 8, '\P{Is_Pat_WS=false}', ""); +Expect(1, 8, '\P{^Is_Pat_WS=false}', ""); +Expect(0, 13, '\p{Is_Pat_WS=false}', ""); +Expect(1, 13, '\p{^Is_Pat_WS=false}', ""); +Expect(1, 13, '\P{Is_Pat_WS=false}', ""); +Expect(0, 13, '\P{^Is_Pat_WS=false}', ""); +Expect(1, 8, '\p{Is_Pat_WS= FALSE}', ""); +Expect(0, 8, '\p{^Is_Pat_WS= FALSE}', ""); +Expect(0, 8, '\P{Is_Pat_WS= FALSE}', ""); +Expect(1, 8, '\P{^Is_Pat_WS= FALSE}', ""); +Expect(0, 13, '\p{Is_Pat_WS= FALSE}', ""); +Expect(1, 13, '\p{^Is_Pat_WS= FALSE}', ""); +Expect(1, 13, '\P{Is_Pat_WS= FALSE}', ""); +Expect(0, 13, '\P{^Is_Pat_WS= FALSE}', ""); +Error('\p{Join_Control=-_Yes/a/}'); +Error('\P{Join_Control=-_Yes/a/}'); +Expect(1, 8205, '\p{Join_Control=yes}', ""); +Expect(0, 8205, '\p{^Join_Control=yes}', ""); +Expect(0, 8205, '\P{Join_Control=yes}', ""); +Expect(1, 8205, '\P{^Join_Control=yes}', ""); +Expect(0, 8203, '\p{Join_Control=yes}', ""); +Expect(1, 8203, '\p{^Join_Control=yes}', ""); +Expect(1, 8203, '\P{Join_Control=yes}', ""); +Expect(0, 8203, '\P{^Join_Control=yes}', ""); +Error('\p{Join_C=-:=Y}'); +Error('\P{Join_C=-:=Y}'); +Expect(1, 8205, '\p{Join_C: y}', ""); +Expect(0, 8205, '\p{^Join_C: y}', ""); +Expect(0, 8205, '\P{Join_C: y}', ""); +Expect(1, 8205, '\P{^Join_C: y}', ""); +Expect(0, 8203, '\p{Join_C: y}', ""); +Expect(1, 8203, '\p{^Join_C: y}', ""); +Expect(1, 8203, '\P{Join_C: y}', ""); +Expect(0, 8203, '\P{^Join_C: y}', ""); +Expect(1, 8205, '\p{Join_C=_ y}', ""); +Expect(0, 8205, '\p{^Join_C=_ y}', ""); +Expect(0, 8205, '\P{Join_C=_ y}', ""); +Expect(1, 8205, '\P{^Join_C=_ y}', ""); +Expect(0, 8203, '\p{Join_C=_ y}', ""); +Expect(1, 8203, '\p{^Join_C=_ y}', ""); +Expect(1, 8203, '\P{Join_C=_ y}', ""); +Expect(0, 8203, '\P{^Join_C=_ y}', ""); +Error('\p{Is_Join_Control=-T/a/}'); +Error('\P{Is_Join_Control=-T/a/}'); +Expect(1, 8205, '\p{Is_Join_Control=t}', ""); +Expect(0, 8205, '\p{^Is_Join_Control=t}', ""); +Expect(0, 8205, '\P{Is_Join_Control=t}', ""); +Expect(1, 8205, '\P{^Is_Join_Control=t}', ""); +Expect(0, 8203, '\p{Is_Join_Control=t}', ""); +Expect(1, 8203, '\p{^Is_Join_Control=t}', ""); +Expect(1, 8203, '\P{Is_Join_Control=t}', ""); +Expect(0, 8203, '\P{^Is_Join_Control=t}', ""); +Expect(1, 8205, '\p{Is_Join_Control=--T}', ""); +Expect(0, 8205, '\p{^Is_Join_Control=--T}', ""); +Expect(0, 8205, '\P{Is_Join_Control=--T}', ""); +Expect(1, 8205, '\P{^Is_Join_Control=--T}', ""); +Expect(0, 8203, '\p{Is_Join_Control=--T}', ""); +Expect(1, 8203, '\p{^Is_Join_Control=--T}', ""); +Expect(1, 8203, '\P{Is_Join_Control=--T}', ""); +Expect(0, 8203, '\P{^Is_Join_Control=--T}', ""); +Error('\p{Is_Join_C=/a/ True}'); +Error('\P{Is_Join_C=/a/ True}'); +Expect(1, 8205, '\p{Is_Join_C=true}', ""); +Expect(0, 8205, '\p{^Is_Join_C=true}', ""); +Expect(0, 8205, '\P{Is_Join_C=true}', ""); +Expect(1, 8205, '\P{^Is_Join_C=true}', ""); +Expect(0, 8203, '\p{Is_Join_C=true}', ""); +Expect(1, 8203, '\p{^Is_Join_C=true}', ""); +Expect(1, 8203, '\P{Is_Join_C=true}', ""); +Expect(0, 8203, '\P{^Is_Join_C=true}', ""); +Expect(1, 8205, '\p{Is_Join_C=_ True}', ""); +Expect(0, 8205, '\p{^Is_Join_C=_ True}', ""); +Expect(0, 8205, '\P{Is_Join_C=_ True}', ""); +Expect(1, 8205, '\P{^Is_Join_C=_ True}', ""); +Expect(0, 8203, '\p{Is_Join_C=_ True}', ""); +Expect(1, 8203, '\p{^Is_Join_C=_ True}', ""); +Expect(1, 8203, '\P{Is_Join_C=_ True}', ""); +Expect(0, 8203, '\P{^Is_Join_C=_ True}', ""); +Error('\p{Join_Control=:=--NO}'); +Error('\P{Join_Control=:=--NO}'); +Expect(1, 8203, '\p{Join_Control=no}', ""); +Expect(0, 8203, '\p{^Join_Control=no}', ""); +Expect(0, 8203, '\P{Join_Control=no}', ""); +Expect(1, 8203, '\P{^Join_Control=no}', ""); +Expect(0, 8205, '\p{Join_Control=no}', ""); +Expect(1, 8205, '\p{^Join_Control=no}', ""); +Expect(1, 8205, '\P{Join_Control=no}', ""); +Expect(0, 8205, '\P{^Join_Control=no}', ""); +Expect(1, 8203, '\p{Join_Control= no}', ""); +Expect(0, 8203, '\p{^Join_Control= no}', ""); +Expect(0, 8203, '\P{Join_Control= no}', ""); +Expect(1, 8203, '\P{^Join_Control= no}', ""); +Expect(0, 8205, '\p{Join_Control= no}', ""); +Expect(1, 8205, '\p{^Join_Control= no}', ""); +Expect(1, 8205, '\P{Join_Control= no}', ""); +Expect(0, 8205, '\P{^Join_Control= no}', ""); +Error('\p{Join_C=-N/a/}'); +Error('\P{Join_C=-N/a/}'); +Expect(1, 8203, '\p{Join_C=n}', ""); +Expect(0, 8203, '\p{^Join_C=n}', ""); +Expect(0, 8203, '\P{Join_C=n}', ""); +Expect(1, 8203, '\P{^Join_C=n}', ""); +Expect(0, 8205, '\p{Join_C=n}', ""); +Expect(1, 8205, '\p{^Join_C=n}', ""); +Expect(1, 8205, '\P{Join_C=n}', ""); +Expect(0, 8205, '\P{^Join_C=n}', ""); +Expect(1, 8203, '\p{Join_C= -N}', ""); +Expect(0, 8203, '\p{^Join_C= -N}', ""); +Expect(0, 8203, '\P{Join_C= -N}', ""); +Expect(1, 8203, '\P{^Join_C= -N}', ""); +Expect(0, 8205, '\p{Join_C= -N}', ""); +Expect(1, 8205, '\p{^Join_C= -N}', ""); +Expect(1, 8205, '\P{Join_C= -N}', ""); +Expect(0, 8205, '\P{^Join_C= -N}', ""); +Error('\p{Is_Join_Control= :=f}'); +Error('\P{Is_Join_Control= :=f}'); +Expect(1, 8203, '\p{Is_Join_Control:f}', ""); +Expect(0, 8203, '\p{^Is_Join_Control:f}', ""); +Expect(0, 8203, '\P{Is_Join_Control:f}', ""); +Expect(1, 8203, '\P{^Is_Join_Control:f}', ""); +Expect(0, 8205, '\p{Is_Join_Control:f}', ""); +Expect(1, 8205, '\p{^Is_Join_Control:f}', ""); +Expect(1, 8205, '\P{Is_Join_Control:f}', ""); +Expect(0, 8205, '\P{^Is_Join_Control:f}', ""); +Expect(1, 8203, '\p{Is_Join_Control=--F}', ""); +Expect(0, 8203, '\p{^Is_Join_Control=--F}', ""); +Expect(0, 8203, '\P{Is_Join_Control=--F}', ""); +Expect(1, 8203, '\P{^Is_Join_Control=--F}', ""); +Expect(0, 8205, '\p{Is_Join_Control=--F}', ""); +Expect(1, 8205, '\p{^Is_Join_Control=--F}', ""); +Expect(1, 8205, '\P{Is_Join_Control=--F}', ""); +Expect(0, 8205, '\P{^Is_Join_Control=--F}', ""); +Error('\p{Is_Join_C=:= false}'); +Error('\P{Is_Join_C=:= false}'); +Expect(1, 8203, '\p{Is_Join_C=false}', ""); +Expect(0, 8203, '\p{^Is_Join_C=false}', ""); +Expect(0, 8203, '\P{Is_Join_C=false}', ""); +Expect(1, 8203, '\P{^Is_Join_C=false}', ""); +Expect(0, 8205, '\p{Is_Join_C=false}', ""); +Expect(1, 8205, '\p{^Is_Join_C=false}', ""); +Expect(1, 8205, '\P{Is_Join_C=false}', ""); +Expect(0, 8205, '\P{^Is_Join_C=false}', ""); +Expect(1, 8203, '\p{Is_Join_C:- false}', ""); +Expect(0, 8203, '\p{^Is_Join_C:- false}', ""); +Expect(0, 8203, '\P{Is_Join_C:- false}', ""); +Expect(1, 8203, '\P{^Is_Join_C:- false}', ""); +Expect(0, 8205, '\p{Is_Join_C:- false}', ""); +Expect(1, 8205, '\p{^Is_Join_C:- false}', ""); +Expect(1, 8205, '\P{Is_Join_C:- false}', ""); +Expect(0, 8205, '\P{^Is_Join_C:- false}', ""); +Error('\p{Other_Default_Ignorable_Code_Point=/a/ _yes}'); +Error('\P{Other_Default_Ignorable_Code_Point=/a/ _yes}'); +Expect(1, 847, '\p{Other_Default_Ignorable_Code_Point=yes}', 'deprecated'); +Expect(0, 847, '\p{^Other_Default_Ignorable_Code_Point=yes}', 'deprecated'); +Expect(0, 847, '\P{Other_Default_Ignorable_Code_Point=yes}', 'deprecated'); +Expect(1, 847, '\P{^Other_Default_Ignorable_Code_Point=yes}', 'deprecated'); +Expect(0, 846, '\p{Other_Default_Ignorable_Code_Point=yes}', 'deprecated'); +Expect(1, 846, '\p{^Other_Default_Ignorable_Code_Point=yes}', 'deprecated'); +Expect(1, 846, '\P{Other_Default_Ignorable_Code_Point=yes}', 'deprecated'); +Expect(0, 846, '\P{^Other_Default_Ignorable_Code_Point=yes}', 'deprecated'); +Expect(1, 847, '\p{Other_Default_Ignorable_Code_Point=_ Yes}', 'deprecated'); +Expect(0, 847, '\p{^Other_Default_Ignorable_Code_Point=_ Yes}', 'deprecated'); +Expect(0, 847, '\P{Other_Default_Ignorable_Code_Point=_ Yes}', 'deprecated'); +Expect(1, 847, '\P{^Other_Default_Ignorable_Code_Point=_ Yes}', 'deprecated'); +Expect(0, 846, '\p{Other_Default_Ignorable_Code_Point=_ Yes}', 'deprecated'); +Expect(1, 846, '\p{^Other_Default_Ignorable_Code_Point=_ Yes}', 'deprecated'); +Expect(1, 846, '\P{Other_Default_Ignorable_Code_Point=_ Yes}', 'deprecated'); +Expect(0, 846, '\P{^Other_Default_Ignorable_Code_Point=_ Yes}', 'deprecated'); +Error('\p{ODI=-_Y/a/}'); +Error('\P{ODI=-_Y/a/}'); +Expect(1, 847, '\p{ODI=y}', 'deprecated'); +Expect(0, 847, '\p{^ODI=y}', 'deprecated'); +Expect(0, 847, '\P{ODI=y}', 'deprecated'); +Expect(1, 847, '\P{^ODI=y}', 'deprecated'); +Expect(0, 846, '\p{ODI=y}', 'deprecated'); +Expect(1, 846, '\p{^ODI=y}', 'deprecated'); +Expect(1, 846, '\P{ODI=y}', 'deprecated'); +Expect(0, 846, '\P{^ODI=y}', 'deprecated'); +Expect(1, 847, '\p{ODI=-Y}', 'deprecated'); +Expect(0, 847, '\p{^ODI=-Y}', 'deprecated'); +Expect(0, 847, '\P{ODI=-Y}', 'deprecated'); +Expect(1, 847, '\P{^ODI=-Y}', 'deprecated'); +Expect(0, 846, '\p{ODI=-Y}', 'deprecated'); +Expect(1, 846, '\p{^ODI=-Y}', 'deprecated'); +Expect(1, 846, '\P{ODI=-Y}', 'deprecated'); +Expect(0, 846, '\P{^ODI=-Y}', 'deprecated'); +Error('\p{Is_Other_Default_Ignorable_Code_Point= /a/T}'); +Error('\P{Is_Other_Default_Ignorable_Code_Point= /a/T}'); +Expect(1, 847, '\p{Is_Other_Default_Ignorable_Code_Point=t}', 'deprecated'); +Expect(0, 847, '\p{^Is_Other_Default_Ignorable_Code_Point=t}', 'deprecated'); +Expect(0, 847, '\P{Is_Other_Default_Ignorable_Code_Point=t}', 'deprecated'); +Expect(1, 847, '\P{^Is_Other_Default_Ignorable_Code_Point=t}', 'deprecated'); +Expect(0, 846, '\p{Is_Other_Default_Ignorable_Code_Point=t}', 'deprecated'); +Expect(1, 846, '\p{^Is_Other_Default_Ignorable_Code_Point=t}', 'deprecated'); +Expect(1, 846, '\P{Is_Other_Default_Ignorable_Code_Point=t}', 'deprecated'); +Expect(0, 846, '\P{^Is_Other_Default_Ignorable_Code_Point=t}', 'deprecated'); +Expect(1, 847, '\p{Is_Other_Default_Ignorable_Code_Point=-T}', 'deprecated'); +Expect(0, 847, '\p{^Is_Other_Default_Ignorable_Code_Point=-T}', 'deprecated'); +Expect(0, 847, '\P{Is_Other_Default_Ignorable_Code_Point=-T}', 'deprecated'); +Expect(1, 847, '\P{^Is_Other_Default_Ignorable_Code_Point=-T}', 'deprecated'); +Expect(0, 846, '\p{Is_Other_Default_Ignorable_Code_Point=-T}', 'deprecated'); +Expect(1, 846, '\p{^Is_Other_Default_Ignorable_Code_Point=-T}', 'deprecated'); +Expect(1, 846, '\P{Is_Other_Default_Ignorable_Code_Point=-T}', 'deprecated'); +Expect(0, 846, '\P{^Is_Other_Default_Ignorable_Code_Point=-T}', 'deprecated'); +Error('\p{Is_ODI: True:=}'); +Error('\P{Is_ODI: True:=}'); +Expect(1, 847, '\p{Is_ODI=true}', 'deprecated'); +Expect(0, 847, '\p{^Is_ODI=true}', 'deprecated'); +Expect(0, 847, '\P{Is_ODI=true}', 'deprecated'); +Expect(1, 847, '\P{^Is_ODI=true}', 'deprecated'); +Expect(0, 846, '\p{Is_ODI=true}', 'deprecated'); +Expect(1, 846, '\p{^Is_ODI=true}', 'deprecated'); +Expect(1, 846, '\P{Is_ODI=true}', 'deprecated'); +Expect(0, 846, '\P{^Is_ODI=true}', 'deprecated'); +Expect(1, 847, '\p{Is_ODI=__True}', 'deprecated'); +Expect(0, 847, '\p{^Is_ODI=__True}', 'deprecated'); +Expect(0, 847, '\P{Is_ODI=__True}', 'deprecated'); +Expect(1, 847, '\P{^Is_ODI=__True}', 'deprecated'); +Expect(0, 846, '\p{Is_ODI=__True}', 'deprecated'); +Expect(1, 846, '\p{^Is_ODI=__True}', 'deprecated'); +Expect(1, 846, '\P{Is_ODI=__True}', 'deprecated'); +Expect(0, 846, '\P{^Is_ODI=__True}', 'deprecated'); +Error('\p{Other_Default_Ignorable_Code_Point: --No/a/}'); +Error('\P{Other_Default_Ignorable_Code_Point: --No/a/}'); +Expect(1, 846, '\p{Other_Default_Ignorable_Code_Point: no}', 'deprecated'); +Expect(0, 846, '\p{^Other_Default_Ignorable_Code_Point: no}', 'deprecated'); +Expect(0, 846, '\P{Other_Default_Ignorable_Code_Point: no}', 'deprecated'); +Expect(1, 846, '\P{^Other_Default_Ignorable_Code_Point: no}', 'deprecated'); +Expect(0, 847, '\p{Other_Default_Ignorable_Code_Point: no}', 'deprecated'); +Expect(1, 847, '\p{^Other_Default_Ignorable_Code_Point: no}', 'deprecated'); +Expect(1, 847, '\P{Other_Default_Ignorable_Code_Point: no}', 'deprecated'); +Expect(0, 847, '\P{^Other_Default_Ignorable_Code_Point: no}', 'deprecated'); +Error('\p{ODI=-/a/N}'); +Error('\P{ODI=-/a/N}'); +Expect(1, 846, '\p{ODI: n}', 'deprecated'); +Expect(0, 846, '\p{^ODI: n}', 'deprecated'); +Expect(0, 846, '\P{ODI: n}', 'deprecated'); +Expect(1, 846, '\P{^ODI: n}', 'deprecated'); +Expect(0, 847, '\p{ODI: n}', 'deprecated'); +Expect(1, 847, '\p{^ODI: n}', 'deprecated'); +Expect(1, 847, '\P{ODI: n}', 'deprecated'); +Expect(0, 847, '\P{^ODI: n}', 'deprecated'); +Expect(1, 846, '\p{ODI=- N}', 'deprecated'); +Expect(0, 846, '\p{^ODI=- N}', 'deprecated'); +Expect(0, 846, '\P{ODI=- N}', 'deprecated'); +Expect(1, 846, '\P{^ODI=- N}', 'deprecated'); +Expect(0, 847, '\p{ODI=- N}', 'deprecated'); +Expect(1, 847, '\p{^ODI=- N}', 'deprecated'); +Expect(1, 847, '\P{ODI=- N}', 'deprecated'); +Expect(0, 847, '\P{^ODI=- N}', 'deprecated'); +Error('\p{Is_Other_Default_Ignorable_Code_Point=/a/ -f}'); +Error('\P{Is_Other_Default_Ignorable_Code_Point=/a/ -f}'); +Expect(1, 846, '\p{Is_Other_Default_Ignorable_Code_Point=f}', 'deprecated'); +Expect(0, 846, '\p{^Is_Other_Default_Ignorable_Code_Point=f}', 'deprecated'); +Expect(0, 846, '\P{Is_Other_Default_Ignorable_Code_Point=f}', 'deprecated'); +Expect(1, 846, '\P{^Is_Other_Default_Ignorable_Code_Point=f}', 'deprecated'); +Expect(0, 847, '\p{Is_Other_Default_Ignorable_Code_Point=f}', 'deprecated'); +Expect(1, 847, '\p{^Is_Other_Default_Ignorable_Code_Point=f}', 'deprecated'); +Expect(1, 847, '\P{Is_Other_Default_Ignorable_Code_Point=f}', 'deprecated'); +Expect(0, 847, '\P{^Is_Other_Default_Ignorable_Code_Point=f}', 'deprecated'); +Expect(1, 846, '\p{Is_Other_Default_Ignorable_Code_Point= -F}', 'deprecated'); +Expect(0, 846, '\p{^Is_Other_Default_Ignorable_Code_Point= -F}', 'deprecated'); +Expect(0, 846, '\P{Is_Other_Default_Ignorable_Code_Point= -F}', 'deprecated'); +Expect(1, 846, '\P{^Is_Other_Default_Ignorable_Code_Point= -F}', 'deprecated'); +Expect(0, 847, '\p{Is_Other_Default_Ignorable_Code_Point= -F}', 'deprecated'); +Expect(1, 847, '\p{^Is_Other_Default_Ignorable_Code_Point= -F}', 'deprecated'); +Expect(1, 847, '\P{Is_Other_Default_Ignorable_Code_Point= -F}', 'deprecated'); +Expect(0, 847, '\P{^Is_Other_Default_Ignorable_Code_Point= -F}', 'deprecated'); +Error('\p{Is_ODI=- False/a/}'); +Error('\P{Is_ODI=- False/a/}'); +Expect(1, 846, '\p{Is_ODI=false}', 'deprecated'); +Expect(0, 846, '\p{^Is_ODI=false}', 'deprecated'); +Expect(0, 846, '\P{Is_ODI=false}', 'deprecated'); +Expect(1, 846, '\P{^Is_ODI=false}', 'deprecated'); +Expect(0, 847, '\p{Is_ODI=false}', 'deprecated'); +Expect(1, 847, '\p{^Is_ODI=false}', 'deprecated'); +Expect(1, 847, '\P{Is_ODI=false}', 'deprecated'); +Expect(0, 847, '\P{^Is_ODI=false}', 'deprecated'); +Expect(1, 846, '\p{Is_ODI= False}', 'deprecated'); +Expect(0, 846, '\p{^Is_ODI= False}', 'deprecated'); +Expect(0, 846, '\P{Is_ODI= False}', 'deprecated'); +Expect(1, 846, '\P{^Is_ODI= False}', 'deprecated'); +Expect(0, 847, '\p{Is_ODI= False}', 'deprecated'); +Expect(1, 847, '\p{^Is_ODI= False}', 'deprecated'); +Expect(1, 847, '\P{Is_ODI= False}', 'deprecated'); +Expect(0, 847, '\P{^Is_ODI= False}', 'deprecated'); +Error('\p{Joining_Type=:=Transparent}'); +Error('\P{Joining_Type=:=Transparent}'); +Expect(1, 879, '\p{Joining_Type=transparent}', ""); +Expect(0, 879, '\p{^Joining_Type=transparent}', ""); +Expect(0, 879, '\P{Joining_Type=transparent}', ""); +Expect(1, 879, '\P{^Joining_Type=transparent}', ""); +Expect(0, 7, '\p{Joining_Type=transparent}', ""); +Expect(1, 7, '\p{^Joining_Type=transparent}', ""); +Expect(1, 7, '\P{Joining_Type=transparent}', ""); +Expect(0, 7, '\P{^Joining_Type=transparent}', ""); +Expect(1, 879, '\p{Joining_Type=_ transparent}', ""); +Expect(0, 879, '\p{^Joining_Type=_ transparent}', ""); +Expect(0, 879, '\P{Joining_Type=_ transparent}', ""); +Expect(1, 879, '\P{^Joining_Type=_ transparent}', ""); +Expect(0, 7, '\p{Joining_Type=_ transparent}', ""); +Expect(1, 7, '\p{^Joining_Type=_ transparent}', ""); +Expect(1, 7, '\P{Joining_Type=_ transparent}', ""); +Expect(0, 7, '\P{^Joining_Type=_ transparent}', ""); +Error('\p{Jt= /a/T}'); +Error('\P{Jt= /a/T}'); +Expect(1, 879, '\p{Jt=t}', ""); +Expect(0, 879, '\p{^Jt=t}', ""); +Expect(0, 879, '\P{Jt=t}', ""); +Expect(1, 879, '\P{^Jt=t}', ""); +Expect(0, 7, '\p{Jt=t}', ""); +Expect(1, 7, '\p{^Jt=t}', ""); +Expect(1, 7, '\P{Jt=t}', ""); +Expect(0, 7, '\P{^Jt=t}', ""); +Expect(1, 879, '\p{Jt: _T}', ""); +Expect(0, 879, '\p{^Jt: _T}', ""); +Expect(0, 879, '\P{Jt: _T}', ""); +Expect(1, 879, '\P{^Jt: _T}', ""); +Expect(0, 7, '\p{Jt: _T}', ""); +Expect(1, 7, '\p{^Jt: _T}', ""); +Expect(1, 7, '\P{Jt: _T}', ""); +Expect(0, 7, '\P{^Jt: _T}', ""); +Error('\p{Is_Joining_Type=:=_transparent}'); +Error('\P{Is_Joining_Type=:=_transparent}'); +Expect(1, 879, '\p{Is_Joining_Type=transparent}', ""); +Expect(0, 879, '\p{^Is_Joining_Type=transparent}', ""); +Expect(0, 879, '\P{Is_Joining_Type=transparent}', ""); +Expect(1, 879, '\P{^Is_Joining_Type=transparent}', ""); +Expect(0, 7, '\p{Is_Joining_Type=transparent}', ""); +Expect(1, 7, '\p{^Is_Joining_Type=transparent}', ""); +Expect(1, 7, '\P{Is_Joining_Type=transparent}', ""); +Expect(0, 7, '\P{^Is_Joining_Type=transparent}', ""); +Expect(1, 879, '\p{Is_Joining_Type= transparent}', ""); +Expect(0, 879, '\p{^Is_Joining_Type= transparent}', ""); +Expect(0, 879, '\P{Is_Joining_Type= transparent}', ""); +Expect(1, 879, '\P{^Is_Joining_Type= transparent}', ""); +Expect(0, 7, '\p{Is_Joining_Type= transparent}', ""); +Expect(1, 7, '\p{^Is_Joining_Type= transparent}', ""); +Expect(1, 7, '\P{Is_Joining_Type= transparent}', ""); +Expect(0, 7, '\P{^Is_Joining_Type= transparent}', ""); +Error('\p{Is_Jt= t:=}'); +Error('\P{Is_Jt= t:=}'); +Expect(1, 879, '\p{Is_Jt=t}', ""); +Expect(0, 879, '\p{^Is_Jt=t}', ""); +Expect(0, 879, '\P{Is_Jt=t}', ""); +Expect(1, 879, '\P{^Is_Jt=t}', ""); +Expect(0, 7, '\p{Is_Jt=t}', ""); +Expect(1, 7, '\p{^Is_Jt=t}', ""); +Expect(1, 7, '\P{Is_Jt=t}', ""); +Expect(0, 7, '\P{^Is_Jt=t}', ""); +Expect(1, 879, '\p{Is_Jt= _t}', ""); +Expect(0, 879, '\p{^Is_Jt= _t}', ""); +Expect(0, 879, '\P{Is_Jt= _t}', ""); +Expect(1, 879, '\P{^Is_Jt= _t}', ""); +Expect(0, 7, '\p{Is_Jt= _t}', ""); +Expect(1, 7, '\p{^Is_Jt= _t}', ""); +Expect(1, 7, '\P{Is_Jt= _t}', ""); +Expect(0, 7, '\P{^Is_Jt= _t}', ""); +Error('\p{Joining_Type=_:=RIGHT_Joining}'); +Error('\P{Joining_Type=_:=RIGHT_Joining}'); +Expect(1, 1573, '\p{Joining_Type=rightjoining}', ""); +Expect(0, 1573, '\p{^Joining_Type=rightjoining}', ""); +Expect(0, 1573, '\P{Joining_Type=rightjoining}', ""); +Expect(1, 1573, '\P{^Joining_Type=rightjoining}', ""); +Expect(0, 1569, '\p{Joining_Type=rightjoining}', ""); +Expect(1, 1569, '\p{^Joining_Type=rightjoining}', ""); +Expect(1, 1569, '\P{Joining_Type=rightjoining}', ""); +Expect(0, 1569, '\P{^Joining_Type=rightjoining}', ""); +Expect(1, 1573, '\p{Joining_Type= Right joining}', ""); +Expect(0, 1573, '\p{^Joining_Type= Right joining}', ""); +Expect(0, 1573, '\P{Joining_Type= Right joining}', ""); +Expect(1, 1573, '\P{^Joining_Type= Right joining}', ""); +Expect(0, 1569, '\p{Joining_Type= Right joining}', ""); +Expect(1, 1569, '\p{^Joining_Type= Right joining}', ""); +Expect(1, 1569, '\P{Joining_Type= Right joining}', ""); +Expect(0, 1569, '\P{^Joining_Type= Right joining}', ""); +Error('\p{Jt::= _R}'); +Error('\P{Jt::= _R}'); +Expect(1, 1573, '\p{Jt=r}', ""); +Expect(0, 1573, '\p{^Jt=r}', ""); +Expect(0, 1573, '\P{Jt=r}', ""); +Expect(1, 1573, '\P{^Jt=r}', ""); +Expect(0, 1569, '\p{Jt=r}', ""); +Expect(1, 1569, '\p{^Jt=r}', ""); +Expect(1, 1569, '\P{Jt=r}', ""); +Expect(0, 1569, '\P{^Jt=r}', ""); +Expect(1, 1573, '\p{Jt=-R}', ""); +Expect(0, 1573, '\p{^Jt=-R}', ""); +Expect(0, 1573, '\P{Jt=-R}', ""); +Expect(1, 1573, '\P{^Jt=-R}', ""); +Expect(0, 1569, '\p{Jt=-R}', ""); +Expect(1, 1569, '\p{^Jt=-R}', ""); +Expect(1, 1569, '\P{Jt=-R}', ""); +Expect(0, 1569, '\P{^Jt=-R}', ""); +Error('\p{Is_Joining_Type: RightJoining/a/}'); +Error('\P{Is_Joining_Type: RightJoining/a/}'); +Expect(1, 1573, '\p{Is_Joining_Type=rightjoining}', ""); +Expect(0, 1573, '\p{^Is_Joining_Type=rightjoining}', ""); +Expect(0, 1573, '\P{Is_Joining_Type=rightjoining}', ""); +Expect(1, 1573, '\P{^Is_Joining_Type=rightjoining}', ""); +Expect(0, 1569, '\p{Is_Joining_Type=rightjoining}', ""); +Expect(1, 1569, '\p{^Is_Joining_Type=rightjoining}', ""); +Expect(1, 1569, '\P{Is_Joining_Type=rightjoining}', ""); +Expect(0, 1569, '\P{^Is_Joining_Type=rightjoining}', ""); +Expect(1, 1573, '\p{Is_Joining_Type=_ RIGHT_Joining}', ""); +Expect(0, 1573, '\p{^Is_Joining_Type=_ RIGHT_Joining}', ""); +Expect(0, 1573, '\P{Is_Joining_Type=_ RIGHT_Joining}', ""); +Expect(1, 1573, '\P{^Is_Joining_Type=_ RIGHT_Joining}', ""); +Expect(0, 1569, '\p{Is_Joining_Type=_ RIGHT_Joining}', ""); +Expect(1, 1569, '\p{^Is_Joining_Type=_ RIGHT_Joining}', ""); +Expect(1, 1569, '\P{Is_Joining_Type=_ RIGHT_Joining}', ""); +Expect(0, 1569, '\P{^Is_Joining_Type=_ RIGHT_Joining}', ""); +Error('\p{Is_Jt=/a/-_R}'); +Error('\P{Is_Jt=/a/-_R}'); +Expect(1, 1573, '\p{Is_Jt=r}', ""); +Expect(0, 1573, '\p{^Is_Jt=r}', ""); +Expect(0, 1573, '\P{Is_Jt=r}', ""); +Expect(1, 1573, '\P{^Is_Jt=r}', ""); +Expect(0, 1569, '\p{Is_Jt=r}', ""); +Expect(1, 1569, '\p{^Is_Jt=r}', ""); +Expect(1, 1569, '\P{Is_Jt=r}', ""); +Expect(0, 1569, '\P{^Is_Jt=r}', ""); +Expect(1, 1573, '\p{Is_Jt=- R}', ""); +Expect(0, 1573, '\p{^Is_Jt=- R}', ""); +Expect(0, 1573, '\P{Is_Jt=- R}', ""); +Expect(1, 1573, '\P{^Is_Jt=- R}', ""); +Expect(0, 1569, '\p{Is_Jt=- R}', ""); +Expect(1, 1569, '\p{^Is_Jt=- R}', ""); +Expect(1, 1569, '\P{Is_Jt=- R}', ""); +Expect(0, 1569, '\P{^Is_Jt=- R}', ""); +Error('\p{Joining_Type= /a/Join-CAUSING}'); +Error('\P{Joining_Type= /a/Join-CAUSING}'); +Expect(1, 1600, '\p{Joining_Type=joincausing}', ""); +Expect(0, 1600, '\p{^Joining_Type=joincausing}', ""); +Expect(0, 1600, '\P{Joining_Type=joincausing}', ""); +Expect(1, 1600, '\P{^Joining_Type=joincausing}', ""); +Expect(0, 1599, '\p{Joining_Type=joincausing}', ""); +Expect(1, 1599, '\p{^Joining_Type=joincausing}', ""); +Expect(1, 1599, '\P{Joining_Type=joincausing}', ""); +Expect(0, 1599, '\P{^Joining_Type=joincausing}', ""); +Expect(1, 1600, '\p{Joining_Type= -Join causing}', ""); +Expect(0, 1600, '\p{^Joining_Type= -Join causing}', ""); +Expect(0, 1600, '\P{Joining_Type= -Join causing}', ""); +Expect(1, 1600, '\P{^Joining_Type= -Join causing}', ""); +Expect(0, 1599, '\p{Joining_Type= -Join causing}', ""); +Expect(1, 1599, '\p{^Joining_Type= -Join causing}', ""); +Expect(1, 1599, '\P{Joining_Type= -Join causing}', ""); +Expect(0, 1599, '\P{^Joining_Type= -Join causing}', ""); +Error('\p{Jt: := C}'); +Error('\P{Jt: := C}'); +Expect(1, 1600, '\p{Jt=c}', ""); +Expect(0, 1600, '\p{^Jt=c}', ""); +Expect(0, 1600, '\P{Jt=c}', ""); +Expect(1, 1600, '\P{^Jt=c}', ""); +Expect(0, 1599, '\p{Jt=c}', ""); +Expect(1, 1599, '\p{^Jt=c}', ""); +Expect(1, 1599, '\P{Jt=c}', ""); +Expect(0, 1599, '\P{^Jt=c}', ""); +Expect(1, 1600, '\p{Jt=-_C}', ""); +Expect(0, 1600, '\p{^Jt=-_C}', ""); +Expect(0, 1600, '\P{Jt=-_C}', ""); +Expect(1, 1600, '\P{^Jt=-_C}', ""); +Expect(0, 1599, '\p{Jt=-_C}', ""); +Expect(1, 1599, '\p{^Jt=-_C}', ""); +Expect(1, 1599, '\P{Jt=-_C}', ""); +Expect(0, 1599, '\P{^Jt=-_C}', ""); +Error('\p{Is_Joining_Type=-_Join-CAUSING:=}'); +Error('\P{Is_Joining_Type=-_Join-CAUSING:=}'); +Expect(1, 1600, '\p{Is_Joining_Type=joincausing}', ""); +Expect(0, 1600, '\p{^Is_Joining_Type=joincausing}', ""); +Expect(0, 1600, '\P{Is_Joining_Type=joincausing}', ""); +Expect(1, 1600, '\P{^Is_Joining_Type=joincausing}', ""); +Expect(0, 1599, '\p{Is_Joining_Type=joincausing}', ""); +Expect(1, 1599, '\p{^Is_Joining_Type=joincausing}', ""); +Expect(1, 1599, '\P{Is_Joining_Type=joincausing}', ""); +Expect(0, 1599, '\P{^Is_Joining_Type=joincausing}', ""); +Expect(1, 1600, '\p{Is_Joining_Type= _JoinCausing}', ""); +Expect(0, 1600, '\p{^Is_Joining_Type= _JoinCausing}', ""); +Expect(0, 1600, '\P{Is_Joining_Type= _JoinCausing}', ""); +Expect(1, 1600, '\P{^Is_Joining_Type= _JoinCausing}', ""); +Expect(0, 1599, '\p{Is_Joining_Type= _JoinCausing}', ""); +Expect(1, 1599, '\p{^Is_Joining_Type= _JoinCausing}', ""); +Expect(1, 1599, '\P{Is_Joining_Type= _JoinCausing}', ""); +Expect(0, 1599, '\P{^Is_Joining_Type= _JoinCausing}', ""); +Error('\p{Is_Jt= -C/a/}'); +Error('\P{Is_Jt= -C/a/}'); +Expect(1, 1600, '\p{Is_Jt=c}', ""); +Expect(0, 1600, '\p{^Is_Jt=c}', ""); +Expect(0, 1600, '\P{Is_Jt=c}', ""); +Expect(1, 1600, '\P{^Is_Jt=c}', ""); +Expect(0, 1599, '\p{Is_Jt=c}', ""); +Expect(1, 1599, '\p{^Is_Jt=c}', ""); +Expect(1, 1599, '\P{Is_Jt=c}', ""); +Expect(0, 1599, '\P{^Is_Jt=c}', ""); +Expect(1, 1600, '\p{Is_Jt: c}', ""); +Expect(0, 1600, '\p{^Is_Jt: c}', ""); +Expect(0, 1600, '\P{Is_Jt: c}', ""); +Expect(1, 1600, '\P{^Is_Jt: c}', ""); +Expect(0, 1599, '\p{Is_Jt: c}', ""); +Expect(1, 1599, '\p{^Is_Jt: c}', ""); +Expect(1, 1599, '\P{Is_Jt: c}', ""); +Expect(0, 1599, '\P{^Is_Jt: c}', ""); +Error('\p{Joining_Type=-_NonJoining/a/}'); +Error('\P{Joining_Type=-_NonJoining/a/}'); +Expect(1, 7, '\p{Joining_Type=nonjoining}', ""); +Expect(0, 7, '\p{^Joining_Type=nonjoining}', ""); +Expect(0, 7, '\P{Joining_Type=nonjoining}', ""); +Expect(1, 7, '\P{^Joining_Type=nonjoining}', ""); +Expect(0, 879, '\p{Joining_Type=nonjoining}', ""); +Expect(1, 879, '\p{^Joining_Type=nonjoining}', ""); +Expect(1, 879, '\P{Joining_Type=nonjoining}', ""); +Expect(0, 879, '\P{^Joining_Type=nonjoining}', ""); +Expect(1, 7, '\p{Joining_Type= Nonjoining}', ""); +Expect(0, 7, '\p{^Joining_Type= Nonjoining}', ""); +Expect(0, 7, '\P{Joining_Type= Nonjoining}', ""); +Expect(1, 7, '\P{^Joining_Type= Nonjoining}', ""); +Expect(0, 879, '\p{Joining_Type= Nonjoining}', ""); +Expect(1, 879, '\p{^Joining_Type= Nonjoining}', ""); +Expect(1, 879, '\P{Joining_Type= Nonjoining}', ""); +Expect(0, 879, '\P{^Joining_Type= Nonjoining}', ""); +Error('\p{Jt= U:=}'); +Error('\P{Jt= U:=}'); +Expect(1, 7, '\p{Jt=u}', ""); +Expect(0, 7, '\p{^Jt=u}', ""); +Expect(0, 7, '\P{Jt=u}', ""); +Expect(1, 7, '\P{^Jt=u}', ""); +Expect(0, 879, '\p{Jt=u}', ""); +Expect(1, 879, '\p{^Jt=u}', ""); +Expect(1, 879, '\P{Jt=u}', ""); +Expect(0, 879, '\P{^Jt=u}', ""); +Expect(1, 7, '\p{Jt:_-U}', ""); +Expect(0, 7, '\p{^Jt:_-U}', ""); +Expect(0, 7, '\P{Jt:_-U}', ""); +Expect(1, 7, '\P{^Jt:_-U}', ""); +Expect(0, 879, '\p{Jt:_-U}', ""); +Expect(1, 879, '\p{^Jt:_-U}', ""); +Expect(1, 879, '\P{Jt:_-U}', ""); +Expect(0, 879, '\P{^Jt:_-U}', ""); +Error('\p{Is_Joining_Type: -:=NONJoining}'); +Error('\P{Is_Joining_Type: -:=NONJoining}'); +Expect(1, 7, '\p{Is_Joining_Type=nonjoining}', ""); +Expect(0, 7, '\p{^Is_Joining_Type=nonjoining}', ""); +Expect(0, 7, '\P{Is_Joining_Type=nonjoining}', ""); +Expect(1, 7, '\P{^Is_Joining_Type=nonjoining}', ""); +Expect(0, 879, '\p{Is_Joining_Type=nonjoining}', ""); +Expect(1, 879, '\p{^Is_Joining_Type=nonjoining}', ""); +Expect(1, 879, '\P{Is_Joining_Type=nonjoining}', ""); +Expect(0, 879, '\P{^Is_Joining_Type=nonjoining}', ""); +Expect(1, 7, '\p{Is_Joining_Type= Non_Joining}', ""); +Expect(0, 7, '\p{^Is_Joining_Type= Non_Joining}', ""); +Expect(0, 7, '\P{Is_Joining_Type= Non_Joining}', ""); +Expect(1, 7, '\P{^Is_Joining_Type= Non_Joining}', ""); +Expect(0, 879, '\p{Is_Joining_Type= Non_Joining}', ""); +Expect(1, 879, '\p{^Is_Joining_Type= Non_Joining}', ""); +Expect(1, 879, '\P{Is_Joining_Type= Non_Joining}', ""); +Expect(0, 879, '\P{^Is_Joining_Type= Non_Joining}', ""); +Error('\p{Is_Jt=:= u}'); +Error('\P{Is_Jt=:= u}'); +Expect(1, 7, '\p{Is_Jt=u}', ""); +Expect(0, 7, '\p{^Is_Jt=u}', ""); +Expect(0, 7, '\P{Is_Jt=u}', ""); +Expect(1, 7, '\P{^Is_Jt=u}', ""); +Expect(0, 879, '\p{Is_Jt=u}', ""); +Expect(1, 879, '\p{^Is_Jt=u}', ""); +Expect(1, 879, '\P{Is_Jt=u}', ""); +Expect(0, 879, '\P{^Is_Jt=u}', ""); +Expect(1, 7, '\p{Is_Jt= U}', ""); +Expect(0, 7, '\p{^Is_Jt= U}', ""); +Expect(0, 7, '\P{Is_Jt= U}', ""); +Expect(1, 7, '\P{^Is_Jt= U}', ""); +Expect(0, 879, '\p{Is_Jt= U}', ""); +Expect(1, 879, '\p{^Is_Jt= U}', ""); +Expect(1, 879, '\P{Is_Jt= U}', ""); +Expect(0, 879, '\P{^Is_Jt= U}', ""); +Error('\p{Joining_Type:__dual/a/Joining}'); +Error('\P{Joining_Type:__dual/a/Joining}'); +Expect(1, 1574, '\p{Joining_Type=dualjoining}', ""); +Expect(0, 1574, '\p{^Joining_Type=dualjoining}', ""); +Expect(0, 1574, '\P{Joining_Type=dualjoining}', ""); +Expect(1, 1574, '\P{^Joining_Type=dualjoining}', ""); +Expect(0, 1573, '\p{Joining_Type=dualjoining}', ""); +Expect(1, 1573, '\p{^Joining_Type=dualjoining}', ""); +Expect(1, 1573, '\P{Joining_Type=dualjoining}', ""); +Expect(0, 1573, '\P{^Joining_Type=dualjoining}', ""); +Expect(1, 1574, '\p{Joining_Type= -Dual Joining}', ""); +Expect(0, 1574, '\p{^Joining_Type= -Dual Joining}', ""); +Expect(0, 1574, '\P{Joining_Type= -Dual Joining}', ""); +Expect(1, 1574, '\P{^Joining_Type= -Dual Joining}', ""); +Expect(0, 1573, '\p{Joining_Type= -Dual Joining}', ""); +Expect(1, 1573, '\p{^Joining_Type= -Dual Joining}', ""); +Expect(1, 1573, '\P{Joining_Type= -Dual Joining}', ""); +Expect(0, 1573, '\P{^Joining_Type= -Dual Joining}', ""); +Error('\p{Jt= -D/a/}'); +Error('\P{Jt= -D/a/}'); +Expect(1, 1574, '\p{Jt=d}', ""); +Expect(0, 1574, '\p{^Jt=d}', ""); +Expect(0, 1574, '\P{Jt=d}', ""); +Expect(1, 1574, '\P{^Jt=d}', ""); +Expect(0, 1573, '\p{Jt=d}', ""); +Expect(1, 1573, '\p{^Jt=d}', ""); +Expect(1, 1573, '\P{Jt=d}', ""); +Expect(0, 1573, '\P{^Jt=d}', ""); +Expect(1, 1574, '\p{Jt= D}', ""); +Expect(0, 1574, '\p{^Jt= D}', ""); +Expect(0, 1574, '\P{Jt= D}', ""); +Expect(1, 1574, '\P{^Jt= D}', ""); +Expect(0, 1573, '\p{Jt= D}', ""); +Expect(1, 1573, '\p{^Jt= D}', ""); +Expect(1, 1573, '\P{Jt= D}', ""); +Expect(0, 1573, '\P{^Jt= D}', ""); +Error('\p{Is_Joining_Type= dual Joining:=}'); +Error('\P{Is_Joining_Type= dual Joining:=}'); +Expect(1, 1574, '\p{Is_Joining_Type=dualjoining}', ""); +Expect(0, 1574, '\p{^Is_Joining_Type=dualjoining}', ""); +Expect(0, 1574, '\P{Is_Joining_Type=dualjoining}', ""); +Expect(1, 1574, '\P{^Is_Joining_Type=dualjoining}', ""); +Expect(0, 1573, '\p{Is_Joining_Type=dualjoining}', ""); +Expect(1, 1573, '\p{^Is_Joining_Type=dualjoining}', ""); +Expect(1, 1573, '\P{Is_Joining_Type=dualjoining}', ""); +Expect(0, 1573, '\P{^Is_Joining_Type=dualjoining}', ""); +Expect(1, 1574, '\p{Is_Joining_Type=_Dual_Joining}', ""); +Expect(0, 1574, '\p{^Is_Joining_Type=_Dual_Joining}', ""); +Expect(0, 1574, '\P{Is_Joining_Type=_Dual_Joining}', ""); +Expect(1, 1574, '\P{^Is_Joining_Type=_Dual_Joining}', ""); +Expect(0, 1573, '\p{Is_Joining_Type=_Dual_Joining}', ""); +Expect(1, 1573, '\p{^Is_Joining_Type=_Dual_Joining}', ""); +Expect(1, 1573, '\P{Is_Joining_Type=_Dual_Joining}', ""); +Expect(0, 1573, '\P{^Is_Joining_Type=_Dual_Joining}', ""); +Error('\p{Is_Jt=:=D}'); +Error('\P{Is_Jt=:=D}'); +Expect(1, 1574, '\p{Is_Jt=d}', ""); +Expect(0, 1574, '\p{^Is_Jt=d}', ""); +Expect(0, 1574, '\P{Is_Jt=d}', ""); +Expect(1, 1574, '\P{^Is_Jt=d}', ""); +Expect(0, 1573, '\p{Is_Jt=d}', ""); +Expect(1, 1573, '\p{^Is_Jt=d}', ""); +Expect(1, 1573, '\P{Is_Jt=d}', ""); +Expect(0, 1573, '\P{^Is_Jt=d}', ""); +Expect(1, 1574, '\p{Is_Jt=-_D}', ""); +Expect(0, 1574, '\p{^Is_Jt=-_D}', ""); +Expect(0, 1574, '\P{Is_Jt=-_D}', ""); +Expect(1, 1574, '\P{^Is_Jt=-_D}', ""); +Expect(0, 1573, '\p{Is_Jt=-_D}', ""); +Expect(1, 1573, '\p{^Is_Jt=-_D}', ""); +Expect(1, 1573, '\P{Is_Jt=-_D}', ""); +Expect(0, 1573, '\P{^Is_Jt=-_D}', ""); +Error('\p{Joining_Type= /a/LeftJoining}'); +Error('\P{Joining_Type= /a/LeftJoining}'); +Expect(0, 7, '\p{Joining_Type=leftjoining}', ""); +Expect(1, 7, '\p{^Joining_Type=leftjoining}', ""); +Expect(1, 7, '\P{Joining_Type=leftjoining}', ""); +Expect(0, 7, '\P{^Joining_Type=leftjoining}', ""); +Expect(0, 7, '\p{Joining_Type: left joining}', ""); +Expect(1, 7, '\p{^Joining_Type: left joining}', ""); +Expect(1, 7, '\P{Joining_Type: left joining}', ""); +Expect(0, 7, '\P{^Joining_Type: left joining}', ""); +Error('\p{Jt=/a/_l}'); +Error('\P{Jt=/a/_l}'); +Expect(0, 7, '\p{Jt:l}', ""); +Expect(1, 7, '\p{^Jt:l}', ""); +Expect(1, 7, '\P{Jt:l}', ""); +Expect(0, 7, '\P{^Jt:l}', ""); +Expect(0, 7, '\p{Jt=-_L}', ""); +Expect(1, 7, '\p{^Jt=-_L}', ""); +Expect(1, 7, '\P{Jt=-_L}', ""); +Expect(0, 7, '\P{^Jt=-_L}', ""); +Error('\p{Is_Joining_Type=-/a/Left joining}'); +Error('\P{Is_Joining_Type=-/a/Left joining}'); +Expect(0, 7, '\p{Is_Joining_Type=leftjoining}', ""); +Expect(1, 7, '\p{^Is_Joining_Type=leftjoining}', ""); +Expect(1, 7, '\P{Is_Joining_Type=leftjoining}', ""); +Expect(0, 7, '\P{^Is_Joining_Type=leftjoining}', ""); +Expect(0, 7, '\p{Is_Joining_Type=Left joining}', ""); +Expect(1, 7, '\p{^Is_Joining_Type=Left joining}', ""); +Expect(1, 7, '\P{Is_Joining_Type=Left joining}', ""); +Expect(0, 7, '\P{^Is_Joining_Type=Left joining}', ""); +Error('\p{Is_Jt=-:=L}'); +Error('\P{Is_Jt=-:=L}'); +Expect(0, 7, '\p{Is_Jt=l}', ""); +Expect(1, 7, '\p{^Is_Jt=l}', ""); +Expect(1, 7, '\P{Is_Jt=l}', ""); +Expect(0, 7, '\P{^Is_Jt=l}', ""); +Expect(0, 7, '\p{Is_Jt= l}', ""); +Expect(1, 7, '\p{^Is_Jt= l}', ""); +Expect(1, 7, '\P{Is_Jt= l}', ""); +Expect(0, 7, '\P{^Is_Jt= l}', ""); +Error('\p{ID_Start=/a/ yes}'); +Error('\P{ID_Start=/a/ yes}'); +Expect(1, 90, '\p{ID_Start=yes}', ""); +Expect(0, 90, '\p{^ID_Start=yes}', ""); +Expect(0, 90, '\P{ID_Start=yes}', ""); +Expect(1, 90, '\P{^ID_Start=yes}', ""); +Expect(0, 64, '\p{ID_Start=yes}', ""); +Expect(1, 64, '\p{^ID_Start=yes}', ""); +Expect(1, 64, '\P{ID_Start=yes}', ""); +Expect(0, 64, '\P{^ID_Start=yes}', ""); +Expect(1, 90, '\p{ID_Start=Yes}', ""); +Expect(0, 90, '\p{^ID_Start=Yes}', ""); +Expect(0, 90, '\P{ID_Start=Yes}', ""); +Expect(1, 90, '\P{^ID_Start=Yes}', ""); +Expect(0, 64, '\p{ID_Start=Yes}', ""); +Expect(1, 64, '\p{^ID_Start=Yes}', ""); +Expect(1, 64, '\P{ID_Start=Yes}', ""); +Expect(0, 64, '\P{^ID_Start=Yes}', ""); +Error('\p{IDS= :=Y}'); +Error('\P{IDS= :=Y}'); +Expect(1, 90, '\p{IDS=y}', ""); +Expect(0, 90, '\p{^IDS=y}', ""); +Expect(0, 90, '\P{IDS=y}', ""); +Expect(1, 90, '\P{^IDS=y}', ""); +Expect(0, 64, '\p{IDS=y}', ""); +Expect(1, 64, '\p{^IDS=y}', ""); +Expect(1, 64, '\P{IDS=y}', ""); +Expect(0, 64, '\P{^IDS=y}', ""); +Expect(1, 90, '\p{IDS=-_Y}', ""); +Expect(0, 90, '\p{^IDS=-_Y}', ""); +Expect(0, 90, '\P{IDS=-_Y}', ""); +Expect(1, 90, '\P{^IDS=-_Y}', ""); +Expect(0, 64, '\p{IDS=-_Y}', ""); +Expect(1, 64, '\p{^IDS=-_Y}', ""); +Expect(1, 64, '\P{IDS=-_Y}', ""); +Expect(0, 64, '\P{^IDS=-_Y}', ""); +Error('\p{Is_ID_Start= T/a/}'); +Error('\P{Is_ID_Start= T/a/}'); +Expect(1, 90, '\p{Is_ID_Start=t}', ""); +Expect(0, 90, '\p{^Is_ID_Start=t}', ""); +Expect(0, 90, '\P{Is_ID_Start=t}', ""); +Expect(1, 90, '\P{^Is_ID_Start=t}', ""); +Expect(0, 64, '\p{Is_ID_Start=t}', ""); +Expect(1, 64, '\p{^Is_ID_Start=t}', ""); +Expect(1, 64, '\P{Is_ID_Start=t}', ""); +Expect(0, 64, '\P{^Is_ID_Start=t}', ""); +Expect(1, 90, '\p{Is_ID_Start=__T}', ""); +Expect(0, 90, '\p{^Is_ID_Start=__T}', ""); +Expect(0, 90, '\P{Is_ID_Start=__T}', ""); +Expect(1, 90, '\P{^Is_ID_Start=__T}', ""); +Expect(0, 64, '\p{Is_ID_Start=__T}', ""); +Expect(1, 64, '\p{^Is_ID_Start=__T}', ""); +Expect(1, 64, '\P{Is_ID_Start=__T}', ""); +Expect(0, 64, '\P{^Is_ID_Start=__T}', ""); +Error('\p{Is_IDS=--True/a/}'); +Error('\P{Is_IDS=--True/a/}'); +Expect(1, 90, '\p{Is_IDS=true}', ""); +Expect(0, 90, '\p{^Is_IDS=true}', ""); +Expect(0, 90, '\P{Is_IDS=true}', ""); +Expect(1, 90, '\P{^Is_IDS=true}', ""); +Expect(0, 64, '\p{Is_IDS=true}', ""); +Expect(1, 64, '\p{^Is_IDS=true}', ""); +Expect(1, 64, '\P{Is_IDS=true}', ""); +Expect(0, 64, '\P{^Is_IDS=true}', ""); +Expect(1, 90, '\p{Is_IDS=_True}', ""); +Expect(0, 90, '\p{^Is_IDS=_True}', ""); +Expect(0, 90, '\P{Is_IDS=_True}', ""); +Expect(1, 90, '\P{^Is_IDS=_True}', ""); +Expect(0, 64, '\p{Is_IDS=_True}', ""); +Expect(1, 64, '\p{^Is_IDS=_True}', ""); +Expect(1, 64, '\P{Is_IDS=_True}', ""); +Expect(0, 64, '\P{^Is_IDS=_True}', ""); +Error('\p{ID_Start=-no/a/}'); +Error('\P{ID_Start=-no/a/}'); +Expect(1, 64, '\p{ID_Start=no}', ""); +Expect(0, 64, '\p{^ID_Start=no}', ""); +Expect(0, 64, '\P{ID_Start=no}', ""); +Expect(1, 64, '\P{^ID_Start=no}', ""); +Expect(0, 90, '\p{ID_Start=no}', ""); +Expect(1, 90, '\p{^ID_Start=no}', ""); +Expect(1, 90, '\P{ID_Start=no}', ""); +Expect(0, 90, '\P{^ID_Start=no}', ""); +Expect(1, 64, '\p{ID_Start= No}', ""); +Expect(0, 64, '\p{^ID_Start= No}', ""); +Expect(0, 64, '\P{ID_Start= No}', ""); +Expect(1, 64, '\P{^ID_Start= No}', ""); +Expect(0, 90, '\p{ID_Start= No}', ""); +Expect(1, 90, '\p{^ID_Start= No}', ""); +Expect(1, 90, '\P{ID_Start= No}', ""); +Expect(0, 90, '\P{^ID_Start= No}', ""); +Error('\p{IDS:/a/n}'); +Error('\P{IDS:/a/n}'); +Expect(1, 64, '\p{IDS:n}', ""); +Expect(0, 64, '\p{^IDS:n}', ""); +Expect(0, 64, '\P{IDS:n}', ""); +Expect(1, 64, '\P{^IDS:n}', ""); +Expect(0, 90, '\p{IDS:n}', ""); +Expect(1, 90, '\p{^IDS:n}', ""); +Expect(1, 90, '\P{IDS:n}', ""); +Expect(0, 90, '\P{^IDS:n}', ""); +Expect(1, 64, '\p{IDS=- n}', ""); +Expect(0, 64, '\p{^IDS=- n}', ""); +Expect(0, 64, '\P{IDS=- n}', ""); +Expect(1, 64, '\P{^IDS=- n}', ""); +Expect(0, 90, '\p{IDS=- n}', ""); +Expect(1, 90, '\p{^IDS=- n}', ""); +Expect(1, 90, '\P{IDS=- n}', ""); +Expect(0, 90, '\P{^IDS=- n}', ""); +Error('\p{Is_ID_Start=:=_f}'); +Error('\P{Is_ID_Start=:=_f}'); +Expect(1, 64, '\p{Is_ID_Start=f}', ""); +Expect(0, 64, '\p{^Is_ID_Start=f}', ""); +Expect(0, 64, '\P{Is_ID_Start=f}', ""); +Expect(1, 64, '\P{^Is_ID_Start=f}', ""); +Expect(0, 90, '\p{Is_ID_Start=f}', ""); +Expect(1, 90, '\p{^Is_ID_Start=f}', ""); +Expect(1, 90, '\P{Is_ID_Start=f}', ""); +Expect(0, 90, '\P{^Is_ID_Start=f}', ""); +Expect(1, 64, '\p{Is_ID_Start=-F}', ""); +Expect(0, 64, '\p{^Is_ID_Start=-F}', ""); +Expect(0, 64, '\P{Is_ID_Start=-F}', ""); +Expect(1, 64, '\P{^Is_ID_Start=-F}', ""); +Expect(0, 90, '\p{Is_ID_Start=-F}', ""); +Expect(1, 90, '\p{^Is_ID_Start=-F}', ""); +Expect(1, 90, '\P{Is_ID_Start=-F}', ""); +Expect(0, 90, '\P{^Is_ID_Start=-F}', ""); +Error('\p{Is_IDS=/a/ False}'); +Error('\P{Is_IDS=/a/ False}'); +Expect(1, 64, '\p{Is_IDS=false}', ""); +Expect(0, 64, '\p{^Is_IDS=false}', ""); +Expect(0, 64, '\P{Is_IDS=false}', ""); +Expect(1, 64, '\P{^Is_IDS=false}', ""); +Expect(0, 90, '\p{Is_IDS=false}', ""); +Expect(1, 90, '\p{^Is_IDS=false}', ""); +Expect(1, 90, '\P{Is_IDS=false}', ""); +Expect(0, 90, '\P{^Is_IDS=false}', ""); +Expect(1, 64, '\p{Is_IDS= -FALSE}', ""); +Expect(0, 64, '\p{^Is_IDS= -FALSE}', ""); +Expect(0, 64, '\P{Is_IDS= -FALSE}', ""); +Expect(1, 64, '\P{^Is_IDS= -FALSE}', ""); +Expect(0, 90, '\p{Is_IDS= -FALSE}', ""); +Expect(1, 90, '\p{^Is_IDS= -FALSE}', ""); +Expect(1, 90, '\P{Is_IDS= -FALSE}', ""); +Expect(0, 90, '\P{^Is_IDS= -FALSE}', ""); +Error('\p{NFC_Quick_Check=/a/_-Yes}'); +Error('\P{NFC_Quick_Check=/a/_-Yes}'); +Expect(1, 767, '\p{NFC_Quick_Check=yes}', ""); +Expect(0, 767, '\p{^NFC_Quick_Check=yes}', ""); +Expect(0, 767, '\P{NFC_Quick_Check=yes}', ""); +Expect(1, 767, '\P{^NFC_Quick_Check=yes}', ""); +Expect(0, 772, '\p{NFC_Quick_Check=yes}', ""); +Expect(1, 772, '\p{^NFC_Quick_Check=yes}', ""); +Expect(1, 772, '\P{NFC_Quick_Check=yes}', ""); +Expect(0, 772, '\P{^NFC_Quick_Check=yes}', ""); +Expect(1, 767, '\p{NFC_Quick_Check= yes}', ""); +Expect(0, 767, '\p{^NFC_Quick_Check= yes}', ""); +Expect(0, 767, '\P{NFC_Quick_Check= yes}', ""); +Expect(1, 767, '\P{^NFC_Quick_Check= yes}', ""); +Expect(0, 772, '\p{NFC_Quick_Check= yes}', ""); +Expect(1, 772, '\p{^NFC_Quick_Check= yes}', ""); +Expect(1, 772, '\P{NFC_Quick_Check= yes}', ""); +Expect(0, 772, '\P{^NFC_Quick_Check= yes}', ""); +Error('\p{NFC_QC=/a/ Y}'); +Error('\P{NFC_QC=/a/ Y}'); +Expect(1, 767, '\p{NFC_QC=y}', ""); +Expect(0, 767, '\p{^NFC_QC=y}', ""); +Expect(0, 767, '\P{NFC_QC=y}', ""); +Expect(1, 767, '\P{^NFC_QC=y}', ""); +Expect(0, 772, '\p{NFC_QC=y}', ""); +Expect(1, 772, '\p{^NFC_QC=y}', ""); +Expect(1, 772, '\P{NFC_QC=y}', ""); +Expect(0, 772, '\P{^NFC_QC=y}', ""); +Expect(1, 767, '\p{NFC_QC= Y}', ""); +Expect(0, 767, '\p{^NFC_QC= Y}', ""); +Expect(0, 767, '\P{NFC_QC= Y}', ""); +Expect(1, 767, '\P{^NFC_QC= Y}', ""); +Expect(0, 772, '\p{NFC_QC= Y}', ""); +Expect(1, 772, '\p{^NFC_QC= Y}', ""); +Expect(1, 772, '\P{NFC_QC= Y}', ""); +Expect(0, 772, '\P{^NFC_QC= Y}', ""); +Error('\p{Is_NFC_Quick_Check=-_YES:=}'); +Error('\P{Is_NFC_Quick_Check=-_YES:=}'); +Expect(1, 767, '\p{Is_NFC_Quick_Check=yes}', ""); +Expect(0, 767, '\p{^Is_NFC_Quick_Check=yes}', ""); +Expect(0, 767, '\P{Is_NFC_Quick_Check=yes}', ""); +Expect(1, 767, '\P{^Is_NFC_Quick_Check=yes}', ""); +Expect(0, 772, '\p{Is_NFC_Quick_Check=yes}', ""); +Expect(1, 772, '\p{^Is_NFC_Quick_Check=yes}', ""); +Expect(1, 772, '\P{Is_NFC_Quick_Check=yes}', ""); +Expect(0, 772, '\P{^Is_NFC_Quick_Check=yes}', ""); +Expect(1, 767, '\p{Is_NFC_Quick_Check=Yes}', ""); +Expect(0, 767, '\p{^Is_NFC_Quick_Check=Yes}', ""); +Expect(0, 767, '\P{Is_NFC_Quick_Check=Yes}', ""); +Expect(1, 767, '\P{^Is_NFC_Quick_Check=Yes}', ""); +Expect(0, 772, '\p{Is_NFC_Quick_Check=Yes}', ""); +Expect(1, 772, '\p{^Is_NFC_Quick_Check=Yes}', ""); +Expect(1, 772, '\P{Is_NFC_Quick_Check=Yes}', ""); +Expect(0, 772, '\P{^Is_NFC_Quick_Check=Yes}', ""); +Error('\p{Is_NFC_QC=:= -y}'); +Error('\P{Is_NFC_QC=:= -y}'); +Expect(1, 767, '\p{Is_NFC_QC=y}', ""); +Expect(0, 767, '\p{^Is_NFC_QC=y}', ""); +Expect(0, 767, '\P{Is_NFC_QC=y}', ""); +Expect(1, 767, '\P{^Is_NFC_QC=y}', ""); +Expect(0, 772, '\p{Is_NFC_QC=y}', ""); +Expect(1, 772, '\p{^Is_NFC_QC=y}', ""); +Expect(1, 772, '\P{Is_NFC_QC=y}', ""); +Expect(0, 772, '\P{^Is_NFC_QC=y}', ""); +Expect(1, 767, '\p{Is_NFC_QC= Y}', ""); +Expect(0, 767, '\p{^Is_NFC_QC= Y}', ""); +Expect(0, 767, '\P{Is_NFC_QC= Y}', ""); +Expect(1, 767, '\P{^Is_NFC_QC= Y}', ""); +Expect(0, 772, '\p{Is_NFC_QC= Y}', ""); +Expect(1, 772, '\p{^Is_NFC_QC= Y}', ""); +Expect(1, 772, '\P{Is_NFC_QC= Y}', ""); +Expect(0, 772, '\P{^Is_NFC_QC= Y}', ""); +Error('\p{NFC_Quick_Check= /a/No}'); +Error('\P{NFC_Quick_Check= /a/No}'); +Expect(1, 833, '\p{NFC_Quick_Check=no}', ""); +Expect(0, 833, '\p{^NFC_Quick_Check=no}', ""); +Expect(0, 833, '\P{NFC_Quick_Check=no}', ""); +Expect(1, 833, '\P{^NFC_Quick_Check=no}', ""); +Expect(0, 831, '\p{NFC_Quick_Check=no}', ""); +Expect(1, 831, '\p{^NFC_Quick_Check=no}', ""); +Expect(1, 831, '\P{NFC_Quick_Check=no}', ""); +Expect(0, 831, '\P{^NFC_Quick_Check=no}', ""); +Expect(1, 833, '\p{NFC_Quick_Check=_No}', ""); +Expect(0, 833, '\p{^NFC_Quick_Check=_No}', ""); +Expect(0, 833, '\P{NFC_Quick_Check=_No}', ""); +Expect(1, 833, '\P{^NFC_Quick_Check=_No}', ""); +Expect(0, 831, '\p{NFC_Quick_Check=_No}', ""); +Expect(1, 831, '\p{^NFC_Quick_Check=_No}', ""); +Expect(1, 831, '\P{NFC_Quick_Check=_No}', ""); +Expect(0, 831, '\P{^NFC_Quick_Check=_No}', ""); +Error('\p{NFC_QC=:=n}'); +Error('\P{NFC_QC=:=n}'); +Expect(1, 833, '\p{NFC_QC=n}', ""); +Expect(0, 833, '\p{^NFC_QC=n}', ""); +Expect(0, 833, '\P{NFC_QC=n}', ""); +Expect(1, 833, '\P{^NFC_QC=n}', ""); +Expect(0, 831, '\p{NFC_QC=n}', ""); +Expect(1, 831, '\p{^NFC_QC=n}', ""); +Expect(1, 831, '\P{NFC_QC=n}', ""); +Expect(0, 831, '\P{^NFC_QC=n}', ""); +Expect(1, 833, '\p{NFC_QC= n}', ""); +Expect(0, 833, '\p{^NFC_QC= n}', ""); +Expect(0, 833, '\P{NFC_QC= n}', ""); +Expect(1, 833, '\P{^NFC_QC= n}', ""); +Expect(0, 831, '\p{NFC_QC= n}', ""); +Expect(1, 831, '\p{^NFC_QC= n}', ""); +Expect(1, 831, '\P{NFC_QC= n}', ""); +Expect(0, 831, '\P{^NFC_QC= n}', ""); +Error('\p{Is_NFC_Quick_Check: /a/no}'); +Error('\P{Is_NFC_Quick_Check: /a/no}'); +Expect(1, 833, '\p{Is_NFC_Quick_Check=no}', ""); +Expect(0, 833, '\p{^Is_NFC_Quick_Check=no}', ""); +Expect(0, 833, '\P{Is_NFC_Quick_Check=no}', ""); +Expect(1, 833, '\P{^Is_NFC_Quick_Check=no}', ""); +Expect(0, 831, '\p{Is_NFC_Quick_Check=no}', ""); +Expect(1, 831, '\p{^Is_NFC_Quick_Check=no}', ""); +Expect(1, 831, '\P{Is_NFC_Quick_Check=no}', ""); +Expect(0, 831, '\P{^Is_NFC_Quick_Check=no}', ""); +Expect(1, 833, '\p{Is_NFC_Quick_Check: NO}', ""); +Expect(0, 833, '\p{^Is_NFC_Quick_Check: NO}', ""); +Expect(0, 833, '\P{Is_NFC_Quick_Check: NO}', ""); +Expect(1, 833, '\P{^Is_NFC_Quick_Check: NO}', ""); +Expect(0, 831, '\p{Is_NFC_Quick_Check: NO}', ""); +Expect(1, 831, '\p{^Is_NFC_Quick_Check: NO}', ""); +Expect(1, 831, '\P{Is_NFC_Quick_Check: NO}', ""); +Expect(0, 831, '\P{^Is_NFC_Quick_Check: NO}', ""); +Error('\p{Is_NFC_QC=_-n/a/}'); +Error('\P{Is_NFC_QC=_-n/a/}'); +Expect(1, 833, '\p{Is_NFC_QC=n}', ""); +Expect(0, 833, '\p{^Is_NFC_QC=n}', ""); +Expect(0, 833, '\P{Is_NFC_QC=n}', ""); +Expect(1, 833, '\P{^Is_NFC_QC=n}', ""); +Expect(0, 831, '\p{Is_NFC_QC=n}', ""); +Expect(1, 831, '\p{^Is_NFC_QC=n}', ""); +Expect(1, 831, '\P{Is_NFC_QC=n}', ""); +Expect(0, 831, '\P{^Is_NFC_QC=n}', ""); +Expect(1, 833, '\p{Is_NFC_QC= _N}', ""); +Expect(0, 833, '\p{^Is_NFC_QC= _N}', ""); +Expect(0, 833, '\P{Is_NFC_QC= _N}', ""); +Expect(1, 833, '\P{^Is_NFC_QC= _N}', ""); +Expect(0, 831, '\p{Is_NFC_QC= _N}', ""); +Expect(1, 831, '\p{^Is_NFC_QC= _N}', ""); +Expect(1, 831, '\P{Is_NFC_QC= _N}', ""); +Expect(0, 831, '\P{^Is_NFC_QC= _N}', ""); +Error('\p{NFC_Quick_Check= _maybe/a/}'); +Error('\P{NFC_Quick_Check= _maybe/a/}'); +Expect(1, 772, '\p{NFC_Quick_Check=maybe}', ""); +Expect(0, 772, '\p{^NFC_Quick_Check=maybe}', ""); +Expect(0, 772, '\P{NFC_Quick_Check=maybe}', ""); +Expect(1, 772, '\P{^NFC_Quick_Check=maybe}', ""); +Expect(0, 767, '\p{NFC_Quick_Check=maybe}', ""); +Expect(1, 767, '\p{^NFC_Quick_Check=maybe}', ""); +Expect(1, 767, '\P{NFC_Quick_Check=maybe}', ""); +Expect(0, 767, '\P{^NFC_Quick_Check=maybe}', ""); +Expect(1, 772, '\p{NFC_Quick_Check: -Maybe}', ""); +Expect(0, 772, '\p{^NFC_Quick_Check: -Maybe}', ""); +Expect(0, 772, '\P{NFC_Quick_Check: -Maybe}', ""); +Expect(1, 772, '\P{^NFC_Quick_Check: -Maybe}', ""); +Expect(0, 767, '\p{NFC_Quick_Check: -Maybe}', ""); +Expect(1, 767, '\p{^NFC_Quick_Check: -Maybe}', ""); +Expect(1, 767, '\P{NFC_Quick_Check: -Maybe}', ""); +Expect(0, 767, '\P{^NFC_Quick_Check: -Maybe}', ""); +Error('\p{NFC_QC= M:=}'); +Error('\P{NFC_QC= M:=}'); +Expect(1, 772, '\p{NFC_QC: m}', ""); +Expect(0, 772, '\p{^NFC_QC: m}', ""); +Expect(0, 772, '\P{NFC_QC: m}', ""); +Expect(1, 772, '\P{^NFC_QC: m}', ""); +Expect(0, 767, '\p{NFC_QC: m}', ""); +Expect(1, 767, '\p{^NFC_QC: m}', ""); +Expect(1, 767, '\P{NFC_QC: m}', ""); +Expect(0, 767, '\P{^NFC_QC: m}', ""); +Expect(1, 772, '\p{NFC_QC=_-m}', ""); +Expect(0, 772, '\p{^NFC_QC=_-m}', ""); +Expect(0, 772, '\P{NFC_QC=_-m}', ""); +Expect(1, 772, '\P{^NFC_QC=_-m}', ""); +Expect(0, 767, '\p{NFC_QC=_-m}', ""); +Expect(1, 767, '\p{^NFC_QC=_-m}', ""); +Expect(1, 767, '\P{NFC_QC=_-m}', ""); +Expect(0, 767, '\P{^NFC_QC=_-m}', ""); +Error('\p{Is_NFC_Quick_Check=/a/--Maybe}'); +Error('\P{Is_NFC_Quick_Check=/a/--Maybe}'); +Expect(1, 772, '\p{Is_NFC_Quick_Check:maybe}', ""); +Expect(0, 772, '\p{^Is_NFC_Quick_Check:maybe}', ""); +Expect(0, 772, '\P{Is_NFC_Quick_Check:maybe}', ""); +Expect(1, 772, '\P{^Is_NFC_Quick_Check:maybe}', ""); +Expect(0, 767, '\p{Is_NFC_Quick_Check:maybe}', ""); +Expect(1, 767, '\p{^Is_NFC_Quick_Check:maybe}', ""); +Expect(1, 767, '\P{Is_NFC_Quick_Check:maybe}', ""); +Expect(0, 767, '\P{^Is_NFC_Quick_Check:maybe}', ""); +Expect(1, 772, '\p{Is_NFC_Quick_Check=- maybe}', ""); +Expect(0, 772, '\p{^Is_NFC_Quick_Check=- maybe}', ""); +Expect(0, 772, '\P{Is_NFC_Quick_Check=- maybe}', ""); +Expect(1, 772, '\P{^Is_NFC_Quick_Check=- maybe}', ""); +Expect(0, 767, '\p{Is_NFC_Quick_Check=- maybe}', ""); +Expect(1, 767, '\p{^Is_NFC_Quick_Check=- maybe}', ""); +Expect(1, 767, '\P{Is_NFC_Quick_Check=- maybe}', ""); +Expect(0, 767, '\P{^Is_NFC_Quick_Check=- maybe}', ""); +Error('\p{Is_NFC_QC=/a/ M}'); +Error('\P{Is_NFC_QC=/a/ M}'); +Expect(1, 772, '\p{Is_NFC_QC: m}', ""); +Expect(0, 772, '\p{^Is_NFC_QC: m}', ""); +Expect(0, 772, '\P{Is_NFC_QC: m}', ""); +Expect(1, 772, '\P{^Is_NFC_QC: m}', ""); +Expect(0, 767, '\p{Is_NFC_QC: m}', ""); +Expect(1, 767, '\p{^Is_NFC_QC: m}', ""); +Expect(1, 767, '\P{Is_NFC_QC: m}', ""); +Expect(0, 767, '\P{^Is_NFC_QC: m}', ""); +Expect(1, 772, '\p{Is_NFC_QC= M}', ""); +Expect(0, 772, '\p{^Is_NFC_QC= M}', ""); +Expect(0, 772, '\P{Is_NFC_QC= M}', ""); +Expect(1, 772, '\P{^Is_NFC_QC= M}', ""); +Expect(0, 767, '\p{Is_NFC_QC= M}', ""); +Expect(1, 767, '\p{^Is_NFC_QC= M}', ""); +Expect(1, 767, '\P{Is_NFC_QC= M}', ""); +Expect(0, 767, '\P{^Is_NFC_QC= M}', ""); +Error('\p{Word_Break=:= NEWLINE}'); +Error('\P{Word_Break=:= NEWLINE}'); +Expect(1, 12, '\p{Word_Break=newline}', ""); +Expect(0, 12, '\p{^Word_Break=newline}', ""); +Expect(0, 12, '\P{Word_Break=newline}', ""); +Expect(1, 12, '\P{^Word_Break=newline}', ""); +Expect(0, 10, '\p{Word_Break=newline}', ""); +Expect(1, 10, '\p{^Word_Break=newline}', ""); +Expect(1, 10, '\P{Word_Break=newline}', ""); +Expect(0, 10, '\P{^Word_Break=newline}', ""); +Error('\p{WB: :=nl}'); +Error('\P{WB: :=nl}'); +Expect(1, 12, '\p{WB=nl}', ""); +Expect(0, 12, '\p{^WB=nl}', ""); +Expect(0, 12, '\P{WB=nl}', ""); +Expect(1, 12, '\P{^WB=nl}', ""); +Expect(0, 10, '\p{WB=nl}', ""); +Expect(1, 10, '\p{^WB=nl}', ""); +Expect(1, 10, '\P{WB=nl}', ""); +Expect(0, 10, '\P{^WB=nl}', ""); +Expect(1, 12, '\p{WB= NL}', ""); +Expect(0, 12, '\p{^WB= NL}', ""); +Expect(0, 12, '\P{WB= NL}', ""); +Expect(1, 12, '\P{^WB= NL}', ""); +Expect(0, 10, '\p{WB= NL}', ""); +Expect(1, 10, '\p{^WB= NL}', ""); +Expect(1, 10, '\P{WB= NL}', ""); +Expect(0, 10, '\P{^WB= NL}', ""); +Error('\p{Is_Word_Break=:=NEWLINE}'); +Error('\P{Is_Word_Break=:=NEWLINE}'); +Expect(1, 12, '\p{Is_Word_Break=newline}', ""); +Expect(0, 12, '\p{^Is_Word_Break=newline}', ""); +Expect(0, 12, '\P{Is_Word_Break=newline}', ""); +Expect(1, 12, '\P{^Is_Word_Break=newline}', ""); +Expect(0, 10, '\p{Is_Word_Break=newline}', ""); +Expect(1, 10, '\p{^Is_Word_Break=newline}', ""); +Expect(1, 10, '\P{Is_Word_Break=newline}', ""); +Expect(0, 10, '\P{^Is_Word_Break=newline}', ""); +Expect(1, 12, '\p{Is_Word_Break= Newline}', ""); +Expect(0, 12, '\p{^Is_Word_Break= Newline}', ""); +Expect(0, 12, '\P{Is_Word_Break= Newline}', ""); +Expect(1, 12, '\P{^Is_Word_Break= Newline}', ""); +Expect(0, 10, '\p{Is_Word_Break= Newline}', ""); +Expect(1, 10, '\p{^Is_Word_Break= Newline}', ""); +Expect(1, 10, '\P{Is_Word_Break= Newline}', ""); +Expect(0, 10, '\P{^Is_Word_Break= Newline}', ""); +Error('\p{Is_WB=/a/_NL}'); +Error('\P{Is_WB=/a/_NL}'); +Expect(1, 12, '\p{Is_WB=nl}', ""); +Expect(0, 12, '\p{^Is_WB=nl}', ""); +Expect(0, 12, '\P{Is_WB=nl}', ""); +Expect(1, 12, '\P{^Is_WB=nl}', ""); +Expect(0, 10, '\p{Is_WB=nl}', ""); +Expect(1, 10, '\p{^Is_WB=nl}', ""); +Expect(1, 10, '\P{Is_WB=nl}', ""); +Expect(0, 10, '\P{^Is_WB=nl}', ""); +Expect(1, 12, '\p{Is_WB= nl}', ""); +Expect(0, 12, '\p{^Is_WB= nl}', ""); +Expect(0, 12, '\P{Is_WB= nl}', ""); +Expect(1, 12, '\P{^Is_WB= nl}', ""); +Expect(0, 10, '\p{Is_WB= nl}', ""); +Expect(1, 10, '\p{^Is_WB= nl}', ""); +Expect(1, 10, '\P{Is_WB= nl}', ""); +Expect(0, 10, '\P{^Is_WB= nl}', ""); +Error('\p{Word_Break= /a/aletter}'); +Error('\P{Word_Break= /a/aletter}'); +Expect(1, 90, '\p{Word_Break=aletter}', ""); +Expect(0, 90, '\p{^Word_Break=aletter}', ""); +Expect(0, 90, '\P{Word_Break=aletter}', ""); +Expect(1, 90, '\P{^Word_Break=aletter}', ""); +Expect(0, 64, '\p{Word_Break=aletter}', ""); +Expect(1, 64, '\p{^Word_Break=aletter}', ""); +Expect(1, 64, '\P{Word_Break=aletter}', ""); +Expect(0, 64, '\P{^Word_Break=aletter}', ""); +Expect(1, 90, '\p{Word_Break: ALetter}', ""); +Expect(0, 90, '\p{^Word_Break: ALetter}', ""); +Expect(0, 90, '\P{Word_Break: ALetter}', ""); +Expect(1, 90, '\P{^Word_Break: ALetter}', ""); +Expect(0, 64, '\p{Word_Break: ALetter}', ""); +Expect(1, 64, '\p{^Word_Break: ALetter}', ""); +Expect(1, 64, '\P{Word_Break: ALetter}', ""); +Expect(0, 64, '\P{^Word_Break: ALetter}', ""); +Error('\p{WB=_:=le}'); +Error('\P{WB=_:=le}'); +Expect(1, 90, '\p{WB=le}', ""); +Expect(0, 90, '\p{^WB=le}', ""); +Expect(0, 90, '\P{WB=le}', ""); +Expect(1, 90, '\P{^WB=le}', ""); +Expect(0, 64, '\p{WB=le}', ""); +Expect(1, 64, '\p{^WB=le}', ""); +Expect(1, 64, '\P{WB=le}', ""); +Expect(0, 64, '\P{^WB=le}', ""); +Expect(1, 90, '\p{WB= le}', ""); +Expect(0, 90, '\p{^WB= le}', ""); +Expect(0, 90, '\P{WB= le}', ""); +Expect(1, 90, '\P{^WB= le}', ""); +Expect(0, 64, '\p{WB= le}', ""); +Expect(1, 64, '\p{^WB= le}', ""); +Expect(1, 64, '\P{WB= le}', ""); +Expect(0, 64, '\P{^WB= le}', ""); +Error('\p{Is_Word_Break=:= ALETTER}'); +Error('\P{Is_Word_Break=:= ALETTER}'); +Expect(1, 90, '\p{Is_Word_Break=aletter}', ""); +Expect(0, 90, '\p{^Is_Word_Break=aletter}', ""); +Expect(0, 90, '\P{Is_Word_Break=aletter}', ""); +Expect(1, 90, '\P{^Is_Word_Break=aletter}', ""); +Expect(0, 64, '\p{Is_Word_Break=aletter}', ""); +Expect(1, 64, '\p{^Is_Word_Break=aletter}', ""); +Expect(1, 64, '\P{Is_Word_Break=aletter}', ""); +Expect(0, 64, '\P{^Is_Word_Break=aletter}', ""); +Expect(1, 90, '\p{Is_Word_Break= ALETTER}', ""); +Expect(0, 90, '\p{^Is_Word_Break= ALETTER}', ""); +Expect(0, 90, '\P{Is_Word_Break= ALETTER}', ""); +Expect(1, 90, '\P{^Is_Word_Break= ALETTER}', ""); +Expect(0, 64, '\p{Is_Word_Break= ALETTER}', ""); +Expect(1, 64, '\p{^Is_Word_Break= ALETTER}', ""); +Expect(1, 64, '\P{Is_Word_Break= ALETTER}', ""); +Expect(0, 64, '\P{^Is_Word_Break= ALETTER}', ""); +Error('\p{Is_WB=/a/--LE}'); +Error('\P{Is_WB=/a/--LE}'); +Expect(1, 90, '\p{Is_WB=le}', ""); +Expect(0, 90, '\p{^Is_WB=le}', ""); +Expect(0, 90, '\P{Is_WB=le}', ""); +Expect(1, 90, '\P{^Is_WB=le}', ""); +Expect(0, 64, '\p{Is_WB=le}', ""); +Expect(1, 64, '\p{^Is_WB=le}', ""); +Expect(1, 64, '\P{Is_WB=le}', ""); +Expect(0, 64, '\P{^Is_WB=le}', ""); +Expect(1, 90, '\p{Is_WB:-LE}', ""); +Expect(0, 90, '\p{^Is_WB:-LE}', ""); +Expect(0, 90, '\P{Is_WB:-LE}', ""); +Expect(1, 90, '\P{^Is_WB:-LE}', ""); +Expect(0, 64, '\p{Is_WB:-LE}', ""); +Expect(1, 64, '\p{^Is_WB:-LE}', ""); +Expect(1, 64, '\P{Is_WB:-LE}', ""); +Expect(0, 64, '\P{^Is_WB:-LE}', ""); +Error('\p{Word_Break=/a/CR}'); +Error('\P{Word_Break=/a/CR}'); +Expect(1, 13, '\p{Word_Break=cr}', ""); +Expect(0, 13, '\p{^Word_Break=cr}', ""); +Expect(0, 13, '\P{Word_Break=cr}', ""); +Expect(1, 13, '\P{^Word_Break=cr}', ""); +Expect(0, 12, '\p{Word_Break=cr}', ""); +Expect(1, 12, '\p{^Word_Break=cr}', ""); +Expect(1, 12, '\P{Word_Break=cr}', ""); +Expect(0, 12, '\P{^Word_Break=cr}', ""); +Expect(1, 13, '\p{Word_Break=-_CR}', ""); +Expect(0, 13, '\p{^Word_Break=-_CR}', ""); +Expect(0, 13, '\P{Word_Break=-_CR}', ""); +Expect(1, 13, '\P{^Word_Break=-_CR}', ""); +Expect(0, 12, '\p{Word_Break=-_CR}', ""); +Expect(1, 12, '\p{^Word_Break=-_CR}', ""); +Expect(1, 12, '\P{Word_Break=-_CR}', ""); +Expect(0, 12, '\P{^Word_Break=-_CR}', ""); +Error('\p{WB: :=_CR}'); +Error('\P{WB: :=_CR}'); +Expect(1, 13, '\p{WB=cr}', ""); +Expect(0, 13, '\p{^WB=cr}', ""); +Expect(0, 13, '\P{WB=cr}', ""); +Expect(1, 13, '\P{^WB=cr}', ""); +Expect(0, 12, '\p{WB=cr}', ""); +Expect(1, 12, '\p{^WB=cr}', ""); +Expect(1, 12, '\P{WB=cr}', ""); +Expect(0, 12, '\P{^WB=cr}', ""); +Expect(1, 13, '\p{WB= cr}', ""); +Expect(0, 13, '\p{^WB= cr}', ""); +Expect(0, 13, '\P{WB= cr}', ""); +Expect(1, 13, '\P{^WB= cr}', ""); +Expect(0, 12, '\p{WB= cr}', ""); +Expect(1, 12, '\p{^WB= cr}', ""); +Expect(1, 12, '\P{WB= cr}', ""); +Expect(0, 12, '\P{^WB= cr}', ""); +Error('\p{Is_Word_Break=_/a/CR}'); +Error('\P{Is_Word_Break=_/a/CR}'); +Expect(1, 13, '\p{Is_Word_Break=cr}', ""); +Expect(0, 13, '\p{^Is_Word_Break=cr}', ""); +Expect(0, 13, '\P{Is_Word_Break=cr}', ""); +Expect(1, 13, '\P{^Is_Word_Break=cr}', ""); +Expect(0, 12, '\p{Is_Word_Break=cr}', ""); +Expect(1, 12, '\p{^Is_Word_Break=cr}', ""); +Expect(1, 12, '\P{Is_Word_Break=cr}', ""); +Expect(0, 12, '\P{^Is_Word_Break=cr}', ""); +Expect(1, 13, '\p{Is_Word_Break= _CR}', ""); +Expect(0, 13, '\p{^Is_Word_Break= _CR}', ""); +Expect(0, 13, '\P{Is_Word_Break= _CR}', ""); +Expect(1, 13, '\P{^Is_Word_Break= _CR}', ""); +Expect(0, 12, '\p{Is_Word_Break= _CR}', ""); +Expect(1, 12, '\p{^Is_Word_Break= _CR}', ""); +Expect(1, 12, '\P{Is_Word_Break= _CR}', ""); +Expect(0, 12, '\P{^Is_Word_Break= _CR}', ""); +Error('\p{Is_WB=/a/ CR}'); +Error('\P{Is_WB=/a/ CR}'); +Expect(1, 13, '\p{Is_WB=cr}', ""); +Expect(0, 13, '\p{^Is_WB=cr}', ""); +Expect(0, 13, '\P{Is_WB=cr}', ""); +Expect(1, 13, '\P{^Is_WB=cr}', ""); +Expect(0, 12, '\p{Is_WB=cr}', ""); +Expect(1, 12, '\p{^Is_WB=cr}', ""); +Expect(1, 12, '\P{Is_WB=cr}', ""); +Expect(0, 12, '\P{^Is_WB=cr}', ""); +Expect(1, 13, '\p{Is_WB=-CR}', ""); +Expect(0, 13, '\p{^Is_WB=-CR}', ""); +Expect(0, 13, '\P{Is_WB=-CR}', ""); +Expect(1, 13, '\P{^Is_WB=-CR}', ""); +Expect(0, 12, '\p{Is_WB=-CR}', ""); +Expect(1, 12, '\p{^Is_WB=-CR}', ""); +Expect(1, 12, '\P{Is_WB=-CR}', ""); +Expect(0, 12, '\P{^Is_WB=-CR}', ""); +Error('\p{Word_Break=__other:=}'); +Error('\P{Word_Break=__other:=}'); +Expect(1, 9, '\p{Word_Break=other}', ""); +Expect(0, 9, '\p{^Word_Break=other}', ""); +Expect(0, 9, '\P{Word_Break=other}', ""); +Expect(1, 9, '\P{^Word_Break=other}', ""); +Expect(0, 13, '\p{Word_Break=other}', ""); +Expect(1, 13, '\p{^Word_Break=other}', ""); +Expect(1, 13, '\P{Word_Break=other}', ""); +Expect(0, 13, '\P{^Word_Break=other}', ""); +Expect(1, 9, '\p{Word_Break=-OTHER}', ""); +Expect(0, 9, '\p{^Word_Break=-OTHER}', ""); +Expect(0, 9, '\P{Word_Break=-OTHER}', ""); +Expect(1, 9, '\P{^Word_Break=-OTHER}', ""); +Expect(0, 13, '\p{Word_Break=-OTHER}', ""); +Expect(1, 13, '\p{^Word_Break=-OTHER}', ""); +Expect(1, 13, '\P{Word_Break=-OTHER}', ""); +Expect(0, 13, '\P{^Word_Break=-OTHER}', ""); +Error('\p{WB= /a/XX}'); +Error('\P{WB= /a/XX}'); +Expect(1, 9, '\p{WB=xx}', ""); +Expect(0, 9, '\p{^WB=xx}', ""); +Expect(0, 9, '\P{WB=xx}', ""); +Expect(1, 9, '\P{^WB=xx}', ""); +Expect(0, 13, '\p{WB=xx}', ""); +Expect(1, 13, '\p{^WB=xx}', ""); +Expect(1, 13, '\P{WB=xx}', ""); +Expect(0, 13, '\P{^WB=xx}', ""); +Expect(1, 9, '\p{WB=- XX}', ""); +Expect(0, 9, '\p{^WB=- XX}', ""); +Expect(0, 9, '\P{WB=- XX}', ""); +Expect(1, 9, '\P{^WB=- XX}', ""); +Expect(0, 13, '\p{WB=- XX}', ""); +Expect(1, 13, '\p{^WB=- XX}', ""); +Expect(1, 13, '\P{WB=- XX}', ""); +Expect(0, 13, '\P{^WB=- XX}', ""); +Error('\p{Is_Word_Break=/a/ _other}'); +Error('\P{Is_Word_Break=/a/ _other}'); +Expect(1, 9, '\p{Is_Word_Break=other}', ""); +Expect(0, 9, '\p{^Is_Word_Break=other}', ""); +Expect(0, 9, '\P{Is_Word_Break=other}', ""); +Expect(1, 9, '\P{^Is_Word_Break=other}', ""); +Expect(0, 13, '\p{Is_Word_Break=other}', ""); +Expect(1, 13, '\p{^Is_Word_Break=other}', ""); +Expect(1, 13, '\P{Is_Word_Break=other}', ""); +Expect(0, 13, '\P{^Is_Word_Break=other}', ""); +Expect(1, 9, '\p{Is_Word_Break=--Other}', ""); +Expect(0, 9, '\p{^Is_Word_Break=--Other}', ""); +Expect(0, 9, '\P{Is_Word_Break=--Other}', ""); +Expect(1, 9, '\P{^Is_Word_Break=--Other}', ""); +Expect(0, 13, '\p{Is_Word_Break=--Other}', ""); +Expect(1, 13, '\p{^Is_Word_Break=--Other}', ""); +Expect(1, 13, '\P{Is_Word_Break=--Other}', ""); +Expect(0, 13, '\P{^Is_Word_Break=--Other}', ""); +Error('\p{Is_WB=:=-XX}'); +Error('\P{Is_WB=:=-XX}'); +Expect(1, 9, '\p{Is_WB=xx}', ""); +Expect(0, 9, '\p{^Is_WB=xx}', ""); +Expect(0, 9, '\P{Is_WB=xx}', ""); +Expect(1, 9, '\P{^Is_WB=xx}', ""); +Expect(0, 13, '\p{Is_WB=xx}', ""); +Expect(1, 13, '\p{^Is_WB=xx}', ""); +Expect(1, 13, '\P{Is_WB=xx}', ""); +Expect(0, 13, '\P{^Is_WB=xx}', ""); +Expect(1, 9, '\p{Is_WB=_XX}', ""); +Expect(0, 9, '\p{^Is_WB=_XX}', ""); +Expect(0, 9, '\P{Is_WB=_XX}', ""); +Expect(1, 9, '\P{^Is_WB=_XX}', ""); +Expect(0, 13, '\p{Is_WB=_XX}', ""); +Expect(1, 13, '\p{^Is_WB=_XX}', ""); +Expect(1, 13, '\P{Is_WB=_XX}', ""); +Expect(0, 13, '\P{^Is_WB=_XX}', ""); +Error('\p{Word_Break= :=Numeric}'); +Error('\P{Word_Break= :=Numeric}'); +Expect(1, 57, '\p{Word_Break=numeric}', ""); +Expect(0, 57, '\p{^Word_Break=numeric}', ""); +Expect(0, 57, '\P{Word_Break=numeric}', ""); +Expect(1, 57, '\P{^Word_Break=numeric}', ""); +Expect(0, 47, '\p{Word_Break=numeric}', ""); +Expect(1, 47, '\p{^Word_Break=numeric}', ""); +Expect(1, 47, '\P{Word_Break=numeric}', ""); +Expect(0, 47, '\P{^Word_Break=numeric}', ""); +Expect(1, 57, '\p{Word_Break=__NUMERIC}', ""); +Expect(0, 57, '\p{^Word_Break=__NUMERIC}', ""); +Expect(0, 57, '\P{Word_Break=__NUMERIC}', ""); +Expect(1, 57, '\P{^Word_Break=__NUMERIC}', ""); +Expect(0, 47, '\p{Word_Break=__NUMERIC}', ""); +Expect(1, 47, '\p{^Word_Break=__NUMERIC}', ""); +Expect(1, 47, '\P{Word_Break=__NUMERIC}', ""); +Expect(0, 47, '\P{^Word_Break=__NUMERIC}', ""); +Error('\p{WB=/a/--nu}'); +Error('\P{WB=/a/--nu}'); +Expect(1, 57, '\p{WB: nu}', ""); +Expect(0, 57, '\p{^WB: nu}', ""); +Expect(0, 57, '\P{WB: nu}', ""); +Expect(1, 57, '\P{^WB: nu}', ""); +Expect(0, 47, '\p{WB: nu}', ""); +Expect(1, 47, '\p{^WB: nu}', ""); +Expect(1, 47, '\P{WB: nu}', ""); +Expect(0, 47, '\P{^WB: nu}', ""); +Expect(1, 57, '\p{WB= -NU}', ""); +Expect(0, 57, '\p{^WB= -NU}', ""); +Expect(0, 57, '\P{WB= -NU}', ""); +Expect(1, 57, '\P{^WB= -NU}', ""); +Expect(0, 47, '\p{WB= -NU}', ""); +Expect(1, 47, '\p{^WB= -NU}', ""); +Expect(1, 47, '\P{WB= -NU}', ""); +Expect(0, 47, '\P{^WB= -NU}', ""); +Error('\p{Is_Word_Break=:=_ numeric}'); +Error('\P{Is_Word_Break=:=_ numeric}'); +Expect(1, 57, '\p{Is_Word_Break:numeric}', ""); +Expect(0, 57, '\p{^Is_Word_Break:numeric}', ""); +Expect(0, 57, '\P{Is_Word_Break:numeric}', ""); +Expect(1, 57, '\P{^Is_Word_Break:numeric}', ""); +Expect(0, 47, '\p{Is_Word_Break:numeric}', ""); +Expect(1, 47, '\p{^Is_Word_Break:numeric}', ""); +Expect(1, 47, '\P{Is_Word_Break:numeric}', ""); +Expect(0, 47, '\P{^Is_Word_Break:numeric}', ""); +Expect(1, 57, '\p{Is_Word_Break: numeric}', ""); +Expect(0, 57, '\p{^Is_Word_Break: numeric}', ""); +Expect(0, 57, '\P{Is_Word_Break: numeric}', ""); +Expect(1, 57, '\P{^Is_Word_Break: numeric}', ""); +Expect(0, 47, '\p{Is_Word_Break: numeric}', ""); +Expect(1, 47, '\p{^Is_Word_Break: numeric}', ""); +Expect(1, 47, '\P{Is_Word_Break: numeric}', ""); +Expect(0, 47, '\P{^Is_Word_Break: numeric}', ""); +Error('\p{Is_WB=_/a/nu}'); +Error('\P{Is_WB=_/a/nu}'); +Expect(1, 57, '\p{Is_WB: nu}', ""); +Expect(0, 57, '\p{^Is_WB: nu}', ""); +Expect(0, 57, '\P{Is_WB: nu}', ""); +Expect(1, 57, '\P{^Is_WB: nu}', ""); +Expect(0, 47, '\p{Is_WB: nu}', ""); +Expect(1, 47, '\p{^Is_WB: nu}', ""); +Expect(1, 47, '\P{Is_WB: nu}', ""); +Expect(0, 47, '\P{^Is_WB: nu}', ""); +Expect(1, 57, '\p{Is_WB: NU}', ""); +Expect(0, 57, '\p{^Is_WB: NU}', ""); +Expect(0, 57, '\P{Is_WB: NU}', ""); +Expect(1, 57, '\P{^Is_WB: NU}', ""); +Expect(0, 47, '\p{Is_WB: NU}', ""); +Expect(1, 47, '\p{^Is_WB: NU}', ""); +Expect(1, 47, '\P{Is_WB: NU}', ""); +Expect(0, 47, '\P{^Is_WB: NU}', ""); +Error('\p{Word_Break=:=format}'); +Error('\P{Word_Break=:=format}'); +Expect(1, 1539, '\p{Word_Break: format}', ""); +Expect(0, 1539, '\p{^Word_Break: format}', ""); +Expect(0, 1539, '\P{Word_Break: format}', ""); +Expect(1, 1539, '\P{^Word_Break: format}', ""); +Expect(0, 7, '\p{Word_Break: format}', ""); +Expect(1, 7, '\p{^Word_Break: format}', ""); +Expect(1, 7, '\P{Word_Break: format}', ""); +Expect(0, 7, '\P{^Word_Break: format}', ""); +Expect(1, 1539, '\p{Word_Break=_Format}', ""); +Expect(0, 1539, '\p{^Word_Break=_Format}', ""); +Expect(0, 1539, '\P{Word_Break=_Format}', ""); +Expect(1, 1539, '\P{^Word_Break=_Format}', ""); +Expect(0, 7, '\p{Word_Break=_Format}', ""); +Expect(1, 7, '\p{^Word_Break=_Format}', ""); +Expect(1, 7, '\P{Word_Break=_Format}', ""); +Expect(0, 7, '\P{^Word_Break=_Format}', ""); +Error('\p{WB=--FO/a/}'); +Error('\P{WB=--FO/a/}'); +Expect(1, 1539, '\p{WB=fo}', ""); +Expect(0, 1539, '\p{^WB=fo}', ""); +Expect(0, 1539, '\P{WB=fo}', ""); +Expect(1, 1539, '\P{^WB=fo}', ""); +Expect(0, 7, '\p{WB=fo}', ""); +Expect(1, 7, '\p{^WB=fo}', ""); +Expect(1, 7, '\P{WB=fo}', ""); +Expect(0, 7, '\P{^WB=fo}', ""); +Expect(1, 1539, '\p{WB= _FO}', ""); +Expect(0, 1539, '\p{^WB= _FO}', ""); +Expect(0, 1539, '\P{WB= _FO}', ""); +Expect(1, 1539, '\P{^WB= _FO}', ""); +Expect(0, 7, '\p{WB= _FO}', ""); +Expect(1, 7, '\p{^WB= _FO}', ""); +Expect(1, 7, '\P{WB= _FO}', ""); +Expect(0, 7, '\P{^WB= _FO}', ""); +Error('\p{Is_Word_Break=-/a/Format}'); +Error('\P{Is_Word_Break=-/a/Format}'); +Expect(1, 1539, '\p{Is_Word_Break=format}', ""); +Expect(0, 1539, '\p{^Is_Word_Break=format}', ""); +Expect(0, 1539, '\P{Is_Word_Break=format}', ""); +Expect(1, 1539, '\P{^Is_Word_Break=format}', ""); +Expect(0, 7, '\p{Is_Word_Break=format}', ""); +Expect(1, 7, '\p{^Is_Word_Break=format}', ""); +Expect(1, 7, '\P{Is_Word_Break=format}', ""); +Expect(0, 7, '\P{^Is_Word_Break=format}', ""); +Expect(1, 1539, '\p{Is_Word_Break= Format}', ""); +Expect(0, 1539, '\p{^Is_Word_Break= Format}', ""); +Expect(0, 1539, '\P{Is_Word_Break= Format}', ""); +Expect(1, 1539, '\P{^Is_Word_Break= Format}', ""); +Expect(0, 7, '\p{Is_Word_Break= Format}', ""); +Expect(1, 7, '\p{^Is_Word_Break= Format}', ""); +Expect(1, 7, '\P{Is_Word_Break= Format}', ""); +Expect(0, 7, '\P{^Is_Word_Break= Format}', ""); +Error('\p{Is_WB= fo/a/}'); +Error('\P{Is_WB= fo/a/}'); +Expect(1, 1539, '\p{Is_WB=fo}', ""); +Expect(0, 1539, '\p{^Is_WB=fo}', ""); +Expect(0, 1539, '\P{Is_WB=fo}', ""); +Expect(1, 1539, '\P{^Is_WB=fo}', ""); +Expect(0, 7, '\p{Is_WB=fo}', ""); +Expect(1, 7, '\p{^Is_WB=fo}', ""); +Expect(1, 7, '\P{Is_WB=fo}', ""); +Expect(0, 7, '\P{^Is_WB=fo}', ""); +Expect(1, 1539, '\p{Is_WB=--FO}', ""); +Expect(0, 1539, '\p{^Is_WB=--FO}', ""); +Expect(0, 1539, '\P{Is_WB=--FO}', ""); +Expect(1, 1539, '\P{^Is_WB=--FO}', ""); +Expect(0, 7, '\p{Is_WB=--FO}', ""); +Expect(1, 7, '\p{^Is_WB=--FO}', ""); +Expect(1, 7, '\P{Is_WB=--FO}', ""); +Expect(0, 7, '\P{^Is_WB=--FO}', ""); +Error('\p{Word_Break= /a/ExtendNumLet}'); +Error('\P{Word_Break= /a/ExtendNumLet}'); +Expect(1, 95, '\p{Word_Break=extendnumlet}', ""); +Expect(0, 95, '\p{^Word_Break=extendnumlet}', ""); +Expect(0, 95, '\P{Word_Break=extendnumlet}', ""); +Expect(1, 95, '\P{^Word_Break=extendnumlet}', ""); +Expect(0, 94, '\p{Word_Break=extendnumlet}', ""); +Expect(1, 94, '\p{^Word_Break=extendnumlet}', ""); +Expect(1, 94, '\P{Word_Break=extendnumlet}', ""); +Expect(0, 94, '\P{^Word_Break=extendnumlet}', ""); +Expect(1, 95, '\p{Word_Break: -EXTENDNUMLET}', ""); +Expect(0, 95, '\p{^Word_Break: -EXTENDNUMLET}', ""); +Expect(0, 95, '\P{Word_Break: -EXTENDNUMLET}', ""); +Expect(1, 95, '\P{^Word_Break: -EXTENDNUMLET}', ""); +Expect(0, 94, '\p{Word_Break: -EXTENDNUMLET}', ""); +Expect(1, 94, '\p{^Word_Break: -EXTENDNUMLET}', ""); +Expect(1, 94, '\P{Word_Break: -EXTENDNUMLET}', ""); +Expect(0, 94, '\P{^Word_Break: -EXTENDNUMLET}', ""); +Error('\p{WB=-EX:=}'); +Error('\P{WB=-EX:=}'); +Expect(1, 95, '\p{WB=ex}', ""); +Expect(0, 95, '\p{^WB=ex}', ""); +Expect(0, 95, '\P{WB=ex}', ""); +Expect(1, 95, '\P{^WB=ex}', ""); +Expect(0, 94, '\p{WB=ex}', ""); +Expect(1, 94, '\p{^WB=ex}', ""); +Expect(1, 94, '\P{WB=ex}', ""); +Expect(0, 94, '\P{^WB=ex}', ""); +Expect(1, 95, '\p{WB=_ex}', ""); +Expect(0, 95, '\p{^WB=_ex}', ""); +Expect(0, 95, '\P{WB=_ex}', ""); +Expect(1, 95, '\P{^WB=_ex}', ""); +Expect(0, 94, '\p{WB=_ex}', ""); +Expect(1, 94, '\p{^WB=_ex}', ""); +Expect(1, 94, '\P{WB=_ex}', ""); +Expect(0, 94, '\P{^WB=_ex}', ""); +Error('\p{Is_Word_Break= ExtendNumLet:=}'); +Error('\P{Is_Word_Break= ExtendNumLet:=}'); +Expect(1, 95, '\p{Is_Word_Break=extendnumlet}', ""); +Expect(0, 95, '\p{^Is_Word_Break=extendnumlet}', ""); +Expect(0, 95, '\P{Is_Word_Break=extendnumlet}', ""); +Expect(1, 95, '\P{^Is_Word_Break=extendnumlet}', ""); +Expect(0, 94, '\p{Is_Word_Break=extendnumlet}', ""); +Expect(1, 94, '\p{^Is_Word_Break=extendnumlet}', ""); +Expect(1, 94, '\P{Is_Word_Break=extendnumlet}', ""); +Expect(0, 94, '\P{^Is_Word_Break=extendnumlet}', ""); +Expect(1, 95, '\p{Is_Word_Break= ExtendNumLet}', ""); +Expect(0, 95, '\p{^Is_Word_Break= ExtendNumLet}', ""); +Expect(0, 95, '\P{Is_Word_Break= ExtendNumLet}', ""); +Expect(1, 95, '\P{^Is_Word_Break= ExtendNumLet}', ""); +Expect(0, 94, '\p{Is_Word_Break= ExtendNumLet}', ""); +Expect(1, 94, '\p{^Is_Word_Break= ExtendNumLet}', ""); +Expect(1, 94, '\P{Is_Word_Break= ExtendNumLet}', ""); +Expect(0, 94, '\P{^Is_Word_Break= ExtendNumLet}', ""); +Error('\p{Is_WB= :=EX}'); +Error('\P{Is_WB= :=EX}'); +Expect(1, 95, '\p{Is_WB=ex}', ""); +Expect(0, 95, '\p{^Is_WB=ex}', ""); +Expect(0, 95, '\P{Is_WB=ex}', ""); +Expect(1, 95, '\P{^Is_WB=ex}', ""); +Expect(0, 94, '\p{Is_WB=ex}', ""); +Expect(1, 94, '\p{^Is_WB=ex}', ""); +Expect(1, 94, '\P{Is_WB=ex}', ""); +Expect(0, 94, '\P{^Is_WB=ex}', ""); +Expect(1, 95, '\p{Is_WB= _EX}', ""); +Expect(0, 95, '\p{^Is_WB= _EX}', ""); +Expect(0, 95, '\P{Is_WB= _EX}', ""); +Expect(1, 95, '\P{^Is_WB= _EX}', ""); +Expect(0, 94, '\p{Is_WB= _EX}', ""); +Expect(1, 94, '\p{^Is_WB= _EX}', ""); +Expect(1, 94, '\P{Is_WB= _EX}', ""); +Expect(0, 94, '\P{^Is_WB= _EX}', ""); +Error('\p{Word_Break= :=Extend}'); +Error('\P{Word_Break= :=Extend}'); +Expect(1, 879, '\p{Word_Break:extend}', ""); +Expect(0, 879, '\p{^Word_Break:extend}', ""); +Expect(0, 879, '\P{Word_Break:extend}', ""); +Expect(1, 879, '\P{^Word_Break:extend}', ""); +Expect(0, 767, '\p{Word_Break:extend}', ""); +Expect(1, 767, '\p{^Word_Break:extend}', ""); +Expect(1, 767, '\P{Word_Break:extend}', ""); +Expect(0, 767, '\P{^Word_Break:extend}', ""); +Expect(1, 879, '\p{Word_Break: -extend}', ""); +Expect(0, 879, '\p{^Word_Break: -extend}', ""); +Expect(0, 879, '\P{Word_Break: -extend}', ""); +Expect(1, 879, '\P{^Word_Break: -extend}', ""); +Expect(0, 767, '\p{Word_Break: -extend}', ""); +Expect(1, 767, '\p{^Word_Break: -extend}', ""); +Expect(1, 767, '\P{Word_Break: -extend}', ""); +Expect(0, 767, '\P{^Word_Break: -extend}', ""); +Error('\p{WB= _Extend:=}'); +Error('\P{WB= _Extend:=}'); +Expect(1, 879, '\p{WB=extend}', ""); +Expect(0, 879, '\p{^WB=extend}', ""); +Expect(0, 879, '\P{WB=extend}', ""); +Expect(1, 879, '\P{^WB=extend}', ""); +Expect(0, 767, '\p{WB=extend}', ""); +Expect(1, 767, '\p{^WB=extend}', ""); +Expect(1, 767, '\P{WB=extend}', ""); +Expect(0, 767, '\P{^WB=extend}', ""); +Expect(1, 879, '\p{WB= _EXTEND}', ""); +Expect(0, 879, '\p{^WB= _EXTEND}', ""); +Expect(0, 879, '\P{WB= _EXTEND}', ""); +Expect(1, 879, '\P{^WB= _EXTEND}', ""); +Expect(0, 767, '\p{WB= _EXTEND}', ""); +Expect(1, 767, '\p{^WB= _EXTEND}', ""); +Expect(1, 767, '\P{WB= _EXTEND}', ""); +Expect(0, 767, '\P{^WB= _EXTEND}', ""); +Error('\p{Is_Word_Break=/a/Extend}'); +Error('\P{Is_Word_Break=/a/Extend}'); +Expect(1, 879, '\p{Is_Word_Break=extend}', ""); +Expect(0, 879, '\p{^Is_Word_Break=extend}', ""); +Expect(0, 879, '\P{Is_Word_Break=extend}', ""); +Expect(1, 879, '\P{^Is_Word_Break=extend}', ""); +Expect(0, 767, '\p{Is_Word_Break=extend}', ""); +Expect(1, 767, '\p{^Is_Word_Break=extend}', ""); +Expect(1, 767, '\P{Is_Word_Break=extend}', ""); +Expect(0, 767, '\P{^Is_Word_Break=extend}', ""); +Expect(1, 879, '\p{Is_Word_Break: Extend}', ""); +Expect(0, 879, '\p{^Is_Word_Break: Extend}', ""); +Expect(0, 879, '\P{Is_Word_Break: Extend}', ""); +Expect(1, 879, '\P{^Is_Word_Break: Extend}', ""); +Expect(0, 767, '\p{Is_Word_Break: Extend}', ""); +Expect(1, 767, '\p{^Is_Word_Break: Extend}', ""); +Expect(1, 767, '\P{Is_Word_Break: Extend}', ""); +Expect(0, 767, '\P{^Is_Word_Break: Extend}', ""); +Error('\p{Is_WB=/a/ extend}'); +Error('\P{Is_WB=/a/ extend}'); +Expect(1, 879, '\p{Is_WB=extend}', ""); +Expect(0, 879, '\p{^Is_WB=extend}', ""); +Expect(0, 879, '\P{Is_WB=extend}', ""); +Expect(1, 879, '\P{^Is_WB=extend}', ""); +Expect(0, 767, '\p{Is_WB=extend}', ""); +Expect(1, 767, '\p{^Is_WB=extend}', ""); +Expect(1, 767, '\P{Is_WB=extend}', ""); +Expect(0, 767, '\P{^Is_WB=extend}', ""); +Expect(1, 879, '\p{Is_WB: --Extend}', ""); +Expect(0, 879, '\p{^Is_WB: --Extend}', ""); +Expect(0, 879, '\P{Is_WB: --Extend}', ""); +Expect(1, 879, '\P{^Is_WB: --Extend}', ""); +Expect(0, 767, '\p{Is_WB: --Extend}', ""); +Expect(1, 767, '\p{^Is_WB: --Extend}', ""); +Expect(1, 767, '\P{Is_WB: --Extend}', ""); +Expect(0, 767, '\P{^Is_WB: --Extend}', ""); +Error('\p{Word_Break=/a/ MidLetter}'); +Error('\P{Word_Break=/a/ MidLetter}'); +Expect(1, 58, '\p{Word_Break=midletter}', ""); +Expect(0, 58, '\p{^Word_Break=midletter}', ""); +Expect(0, 58, '\P{Word_Break=midletter}', ""); +Expect(1, 58, '\P{^Word_Break=midletter}', ""); +Expect(0, 57, '\p{Word_Break=midletter}', ""); +Expect(1, 57, '\p{^Word_Break=midletter}', ""); +Expect(1, 57, '\P{Word_Break=midletter}', ""); +Expect(0, 57, '\P{^Word_Break=midletter}', ""); +Expect(1, 58, '\p{Word_Break= MidLetter}', ""); +Expect(0, 58, '\p{^Word_Break= MidLetter}', ""); +Expect(0, 58, '\P{Word_Break= MidLetter}', ""); +Expect(1, 58, '\P{^Word_Break= MidLetter}', ""); +Expect(0, 57, '\p{Word_Break= MidLetter}', ""); +Expect(1, 57, '\p{^Word_Break= MidLetter}', ""); +Expect(1, 57, '\P{Word_Break= MidLetter}', ""); +Expect(0, 57, '\P{^Word_Break= MidLetter}', ""); +Error('\p{WB= -ML/a/}'); +Error('\P{WB= -ML/a/}'); +Expect(1, 58, '\p{WB=ml}', ""); +Expect(0, 58, '\p{^WB=ml}', ""); +Expect(0, 58, '\P{WB=ml}', ""); +Expect(1, 58, '\P{^WB=ml}', ""); +Expect(0, 57, '\p{WB=ml}', ""); +Expect(1, 57, '\p{^WB=ml}', ""); +Expect(1, 57, '\P{WB=ml}', ""); +Expect(0, 57, '\P{^WB=ml}', ""); +Expect(1, 58, '\p{WB= -ML}', ""); +Expect(0, 58, '\p{^WB= -ML}', ""); +Expect(0, 58, '\P{WB= -ML}', ""); +Expect(1, 58, '\P{^WB= -ML}', ""); +Expect(0, 57, '\p{WB= -ML}', ""); +Expect(1, 57, '\p{^WB= -ML}', ""); +Expect(1, 57, '\P{WB= -ML}', ""); +Expect(0, 57, '\P{^WB= -ML}', ""); +Error('\p{Is_Word_Break= MidLetter:=}'); +Error('\P{Is_Word_Break= MidLetter:=}'); +Expect(1, 58, '\p{Is_Word_Break=midletter}', ""); +Expect(0, 58, '\p{^Is_Word_Break=midletter}', ""); +Expect(0, 58, '\P{Is_Word_Break=midletter}', ""); +Expect(1, 58, '\P{^Is_Word_Break=midletter}', ""); +Expect(0, 57, '\p{Is_Word_Break=midletter}', ""); +Expect(1, 57, '\p{^Is_Word_Break=midletter}', ""); +Expect(1, 57, '\P{Is_Word_Break=midletter}', ""); +Expect(0, 57, '\P{^Is_Word_Break=midletter}', ""); +Expect(1, 58, '\p{Is_Word_Break: _MidLetter}', ""); +Expect(0, 58, '\p{^Is_Word_Break: _MidLetter}', ""); +Expect(0, 58, '\P{Is_Word_Break: _MidLetter}', ""); +Expect(1, 58, '\P{^Is_Word_Break: _MidLetter}', ""); +Expect(0, 57, '\p{Is_Word_Break: _MidLetter}', ""); +Expect(1, 57, '\p{^Is_Word_Break: _MidLetter}', ""); +Expect(1, 57, '\P{Is_Word_Break: _MidLetter}', ""); +Expect(0, 57, '\P{^Is_Word_Break: _MidLetter}', ""); +Error('\p{Is_WB= -ml/a/}'); +Error('\P{Is_WB= -ml/a/}'); +Expect(1, 58, '\p{Is_WB=ml}', ""); +Expect(0, 58, '\p{^Is_WB=ml}', ""); +Expect(0, 58, '\P{Is_WB=ml}', ""); +Expect(1, 58, '\P{^Is_WB=ml}', ""); +Expect(0, 57, '\p{Is_WB=ml}', ""); +Expect(1, 57, '\p{^Is_WB=ml}', ""); +Expect(1, 57, '\P{Is_WB=ml}', ""); +Expect(0, 57, '\P{^Is_WB=ml}', ""); +Expect(1, 58, '\p{Is_WB=-ML}', ""); +Expect(0, 58, '\p{^Is_WB=-ML}', ""); +Expect(0, 58, '\P{Is_WB=-ML}', ""); +Expect(1, 58, '\P{^Is_WB=-ML}', ""); +Expect(0, 57, '\p{Is_WB=-ML}', ""); +Expect(1, 57, '\p{^Is_WB=-ML}', ""); +Expect(1, 57, '\P{Is_WB=-ML}', ""); +Expect(0, 57, '\P{^Is_WB=-ML}', ""); +Error('\p{Word_Break=/a/midnumlet}'); +Error('\P{Word_Break=/a/midnumlet}'); +Expect(1, 39, '\p{Word_Break=midnumlet}', ""); +Expect(0, 39, '\p{^Word_Break=midnumlet}', ""); +Expect(0, 39, '\P{Word_Break=midnumlet}', ""); +Expect(1, 39, '\P{^Word_Break=midnumlet}', ""); +Expect(0, 38, '\p{Word_Break=midnumlet}', ""); +Expect(1, 38, '\p{^Word_Break=midnumlet}', ""); +Expect(1, 38, '\P{Word_Break=midnumlet}', ""); +Expect(0, 38, '\P{^Word_Break=midnumlet}', ""); +Expect(1, 39, '\p{Word_Break=_ MidNumLet}', ""); +Expect(0, 39, '\p{^Word_Break=_ MidNumLet}', ""); +Expect(0, 39, '\P{Word_Break=_ MidNumLet}', ""); +Expect(1, 39, '\P{^Word_Break=_ MidNumLet}', ""); +Expect(0, 38, '\p{Word_Break=_ MidNumLet}', ""); +Expect(1, 38, '\p{^Word_Break=_ MidNumLet}', ""); +Expect(1, 38, '\P{Word_Break=_ MidNumLet}', ""); +Expect(0, 38, '\P{^Word_Break=_ MidNumLet}', ""); +Error('\p{WB=/a/MB}'); +Error('\P{WB=/a/MB}'); +Expect(1, 39, '\p{WB=mb}', ""); +Expect(0, 39, '\p{^WB=mb}', ""); +Expect(0, 39, '\P{WB=mb}', ""); +Expect(1, 39, '\P{^WB=mb}', ""); +Expect(0, 38, '\p{WB=mb}', ""); +Expect(1, 38, '\p{^WB=mb}', ""); +Expect(1, 38, '\P{WB=mb}', ""); +Expect(0, 38, '\P{^WB=mb}', ""); +Expect(1, 39, '\p{WB=__MB}', ""); +Expect(0, 39, '\p{^WB=__MB}', ""); +Expect(0, 39, '\P{WB=__MB}', ""); +Expect(1, 39, '\P{^WB=__MB}', ""); +Expect(0, 38, '\p{WB=__MB}', ""); +Expect(1, 38, '\p{^WB=__MB}', ""); +Expect(1, 38, '\P{WB=__MB}', ""); +Expect(0, 38, '\P{^WB=__MB}', ""); +Error('\p{Is_Word_Break= :=MidNumLet}'); +Error('\P{Is_Word_Break= :=MidNumLet}'); +Expect(1, 39, '\p{Is_Word_Break=midnumlet}', ""); +Expect(0, 39, '\p{^Is_Word_Break=midnumlet}', ""); +Expect(0, 39, '\P{Is_Word_Break=midnumlet}', ""); +Expect(1, 39, '\P{^Is_Word_Break=midnumlet}', ""); +Expect(0, 38, '\p{Is_Word_Break=midnumlet}', ""); +Expect(1, 38, '\p{^Is_Word_Break=midnumlet}', ""); +Expect(1, 38, '\P{Is_Word_Break=midnumlet}', ""); +Expect(0, 38, '\P{^Is_Word_Break=midnumlet}', ""); +Expect(1, 39, '\p{Is_Word_Break: __MidNumLet}', ""); +Expect(0, 39, '\p{^Is_Word_Break: __MidNumLet}', ""); +Expect(0, 39, '\P{Is_Word_Break: __MidNumLet}', ""); +Expect(1, 39, '\P{^Is_Word_Break: __MidNumLet}', ""); +Expect(0, 38, '\p{Is_Word_Break: __MidNumLet}', ""); +Expect(1, 38, '\p{^Is_Word_Break: __MidNumLet}', ""); +Expect(1, 38, '\P{Is_Word_Break: __MidNumLet}', ""); +Expect(0, 38, '\P{^Is_Word_Break: __MidNumLet}', ""); +Error('\p{Is_WB= MB:=}'); +Error('\P{Is_WB= MB:=}'); +Expect(1, 39, '\p{Is_WB=mb}', ""); +Expect(0, 39, '\p{^Is_WB=mb}', ""); +Expect(0, 39, '\P{Is_WB=mb}', ""); +Expect(1, 39, '\P{^Is_WB=mb}', ""); +Expect(0, 38, '\p{Is_WB=mb}', ""); +Expect(1, 38, '\p{^Is_WB=mb}', ""); +Expect(1, 38, '\P{Is_WB=mb}', ""); +Expect(0, 38, '\P{^Is_WB=mb}', ""); +Expect(1, 39, '\p{Is_WB=- MB}', ""); +Expect(0, 39, '\p{^Is_WB=- MB}', ""); +Expect(0, 39, '\P{Is_WB=- MB}', ""); +Expect(1, 39, '\P{^Is_WB=- MB}', ""); +Expect(0, 38, '\p{Is_WB=- MB}', ""); +Expect(1, 38, '\p{^Is_WB=- MB}', ""); +Expect(1, 38, '\P{Is_WB=- MB}', ""); +Expect(0, 38, '\P{^Is_WB=- MB}', ""); +Error('\p{Word_Break=_-midnum/a/}'); +Error('\P{Word_Break=_-midnum/a/}'); +Expect(1, 44, '\p{Word_Break=midnum}', ""); +Expect(0, 44, '\p{^Word_Break=midnum}', ""); +Expect(0, 44, '\P{Word_Break=midnum}', ""); +Expect(1, 44, '\P{^Word_Break=midnum}', ""); +Expect(0, 43, '\p{Word_Break=midnum}', ""); +Expect(1, 43, '\p{^Word_Break=midnum}', ""); +Expect(1, 43, '\P{Word_Break=midnum}', ""); +Expect(0, 43, '\P{^Word_Break=midnum}', ""); +Expect(1, 44, '\p{Word_Break= MidNum}', ""); +Expect(0, 44, '\p{^Word_Break= MidNum}', ""); +Expect(0, 44, '\P{Word_Break= MidNum}', ""); +Expect(1, 44, '\P{^Word_Break= MidNum}', ""); +Expect(0, 43, '\p{Word_Break= MidNum}', ""); +Expect(1, 43, '\p{^Word_Break= MidNum}', ""); +Expect(1, 43, '\P{Word_Break= MidNum}', ""); +Expect(0, 43, '\P{^Word_Break= MidNum}', ""); +Error('\p{WB=:=MN}'); +Error('\P{WB=:=MN}'); +Expect(1, 44, '\p{WB=mn}', ""); +Expect(0, 44, '\p{^WB=mn}', ""); +Expect(0, 44, '\P{WB=mn}', ""); +Expect(1, 44, '\P{^WB=mn}', ""); +Expect(0, 43, '\p{WB=mn}', ""); +Expect(1, 43, '\p{^WB=mn}', ""); +Expect(1, 43, '\P{WB=mn}', ""); +Expect(0, 43, '\P{^WB=mn}', ""); +Expect(1, 44, '\p{WB: -MN}', ""); +Expect(0, 44, '\p{^WB: -MN}', ""); +Expect(0, 44, '\P{WB: -MN}', ""); +Expect(1, 44, '\P{^WB: -MN}', ""); +Expect(0, 43, '\p{WB: -MN}', ""); +Expect(1, 43, '\p{^WB: -MN}', ""); +Expect(1, 43, '\P{WB: -MN}', ""); +Expect(0, 43, '\P{^WB: -MN}', ""); +Error('\p{Is_Word_Break=-:=MidNum}'); +Error('\P{Is_Word_Break=-:=MidNum}'); +Expect(1, 44, '\p{Is_Word_Break=midnum}', ""); +Expect(0, 44, '\p{^Is_Word_Break=midnum}', ""); +Expect(0, 44, '\P{Is_Word_Break=midnum}', ""); +Expect(1, 44, '\P{^Is_Word_Break=midnum}', ""); +Expect(0, 43, '\p{Is_Word_Break=midnum}', ""); +Expect(1, 43, '\p{^Is_Word_Break=midnum}', ""); +Expect(1, 43, '\P{Is_Word_Break=midnum}', ""); +Expect(0, 43, '\P{^Is_Word_Break=midnum}', ""); +Expect(1, 44, '\p{Is_Word_Break= MidNum}', ""); +Expect(0, 44, '\p{^Is_Word_Break= MidNum}', ""); +Expect(0, 44, '\P{Is_Word_Break= MidNum}', ""); +Expect(1, 44, '\P{^Is_Word_Break= MidNum}', ""); +Expect(0, 43, '\p{Is_Word_Break= MidNum}', ""); +Expect(1, 43, '\p{^Is_Word_Break= MidNum}', ""); +Expect(1, 43, '\P{Is_Word_Break= MidNum}', ""); +Expect(0, 43, '\P{^Is_Word_Break= MidNum}', ""); +Error('\p{Is_WB=_:=MN}'); +Error('\P{Is_WB=_:=MN}'); +Expect(1, 44, '\p{Is_WB=mn}', ""); +Expect(0, 44, '\p{^Is_WB=mn}', ""); +Expect(0, 44, '\P{Is_WB=mn}', ""); +Expect(1, 44, '\P{^Is_WB=mn}', ""); +Expect(0, 43, '\p{Is_WB=mn}', ""); +Expect(1, 43, '\p{^Is_WB=mn}', ""); +Expect(1, 43, '\P{Is_WB=mn}', ""); +Expect(0, 43, '\P{^Is_WB=mn}', ""); +Expect(1, 44, '\p{Is_WB=_ MN}', ""); +Expect(0, 44, '\p{^Is_WB=_ MN}', ""); +Expect(0, 44, '\P{Is_WB=_ MN}', ""); +Expect(1, 44, '\P{^Is_WB=_ MN}', ""); +Expect(0, 43, '\p{Is_WB=_ MN}', ""); +Expect(1, 43, '\p{^Is_WB=_ MN}', ""); +Expect(1, 43, '\P{Is_WB=_ MN}', ""); +Expect(0, 43, '\P{^Is_WB=_ MN}', ""); +Error('\p{Word_Break=- KATAKANA:=}'); +Error('\P{Word_Break=- KATAKANA:=}'); +Expect(1, 12341, '\p{Word_Break=katakana}', ""); +Expect(0, 12341, '\p{^Word_Break=katakana}', ""); +Expect(0, 12341, '\P{Word_Break=katakana}', ""); +Expect(1, 12341, '\P{^Word_Break=katakana}', ""); +Expect(0, 12336, '\p{Word_Break=katakana}', ""); +Expect(1, 12336, '\p{^Word_Break=katakana}', ""); +Expect(1, 12336, '\P{Word_Break=katakana}', ""); +Expect(0, 12336, '\P{^Word_Break=katakana}', ""); +Expect(1, 12341, '\p{Word_Break: katakana}', ""); +Expect(0, 12341, '\p{^Word_Break: katakana}', ""); +Expect(0, 12341, '\P{Word_Break: katakana}', ""); +Expect(1, 12341, '\P{^Word_Break: katakana}', ""); +Expect(0, 12336, '\p{Word_Break: katakana}', ""); +Expect(1, 12336, '\p{^Word_Break: katakana}', ""); +Expect(1, 12336, '\P{Word_Break: katakana}', ""); +Expect(0, 12336, '\P{^Word_Break: katakana}', ""); +Error('\p{WB=:= KA}'); +Error('\P{WB=:= KA}'); +Expect(1, 12341, '\p{WB=ka}', ""); +Expect(0, 12341, '\p{^WB=ka}', ""); +Expect(0, 12341, '\P{WB=ka}', ""); +Expect(1, 12341, '\P{^WB=ka}', ""); +Expect(0, 12336, '\p{WB=ka}', ""); +Expect(1, 12336, '\p{^WB=ka}', ""); +Expect(1, 12336, '\P{WB=ka}', ""); +Expect(0, 12336, '\P{^WB=ka}', ""); +Expect(1, 12341, '\p{WB=_-KA}', ""); +Expect(0, 12341, '\p{^WB=_-KA}', ""); +Expect(0, 12341, '\P{WB=_-KA}', ""); +Expect(1, 12341, '\P{^WB=_-KA}', ""); +Expect(0, 12336, '\p{WB=_-KA}', ""); +Expect(1, 12336, '\p{^WB=_-KA}', ""); +Expect(1, 12336, '\P{WB=_-KA}', ""); +Expect(0, 12336, '\P{^WB=_-KA}', ""); +Error('\p{Is_Word_Break: /a/Katakana}'); +Error('\P{Is_Word_Break: /a/Katakana}'); +Expect(1, 12341, '\p{Is_Word_Break: katakana}', ""); +Expect(0, 12341, '\p{^Is_Word_Break: katakana}', ""); +Expect(0, 12341, '\P{Is_Word_Break: katakana}', ""); +Expect(1, 12341, '\P{^Is_Word_Break: katakana}', ""); +Expect(0, 12336, '\p{Is_Word_Break: katakana}', ""); +Expect(1, 12336, '\p{^Is_Word_Break: katakana}', ""); +Expect(1, 12336, '\P{Is_Word_Break: katakana}', ""); +Expect(0, 12336, '\P{^Is_Word_Break: katakana}', ""); +Expect(1, 12341, '\p{Is_Word_Break=-katakana}', ""); +Expect(0, 12341, '\p{^Is_Word_Break=-katakana}', ""); +Expect(0, 12341, '\P{Is_Word_Break=-katakana}', ""); +Expect(1, 12341, '\P{^Is_Word_Break=-katakana}', ""); +Expect(0, 12336, '\p{Is_Word_Break=-katakana}', ""); +Expect(1, 12336, '\p{^Is_Word_Break=-katakana}', ""); +Expect(1, 12336, '\P{Is_Word_Break=-katakana}', ""); +Expect(0, 12336, '\P{^Is_Word_Break=-katakana}', ""); +Error('\p{Is_WB=_-KA:=}'); +Error('\P{Is_WB=_-KA:=}'); +Expect(1, 12341, '\p{Is_WB: ka}', ""); +Expect(0, 12341, '\p{^Is_WB: ka}', ""); +Expect(0, 12341, '\P{Is_WB: ka}', ""); +Expect(1, 12341, '\P{^Is_WB: ka}', ""); +Expect(0, 12336, '\p{Is_WB: ka}', ""); +Expect(1, 12336, '\p{^Is_WB: ka}', ""); +Expect(1, 12336, '\P{Is_WB: ka}', ""); +Expect(0, 12336, '\P{^Is_WB: ka}', ""); +Expect(1, 12341, '\p{Is_WB: _KA}', ""); +Expect(0, 12341, '\p{^Is_WB: _KA}', ""); +Expect(0, 12341, '\P{Is_WB: _KA}', ""); +Expect(1, 12341, '\P{^Is_WB: _KA}', ""); +Expect(0, 12336, '\p{Is_WB: _KA}', ""); +Expect(1, 12336, '\p{^Is_WB: _KA}', ""); +Expect(1, 12336, '\P{Is_WB: _KA}', ""); +Expect(0, 12336, '\P{^Is_WB: _KA}', ""); +Error('\p{Word_Break= /a/LF}'); +Error('\P{Word_Break= /a/LF}'); +Expect(1, 10, '\p{Word_Break=lf}', ""); +Expect(0, 10, '\p{^Word_Break=lf}', ""); +Expect(0, 10, '\P{Word_Break=lf}', ""); +Expect(1, 10, '\P{^Word_Break=lf}', ""); +Expect(0, 9, '\p{Word_Break=lf}', ""); +Expect(1, 9, '\p{^Word_Break=lf}', ""); +Expect(1, 9, '\P{Word_Break=lf}', ""); +Expect(0, 9, '\P{^Word_Break=lf}', ""); +Expect(1, 10, '\p{Word_Break:__LF}', ""); +Expect(0, 10, '\p{^Word_Break:__LF}', ""); +Expect(0, 10, '\P{Word_Break:__LF}', ""); +Expect(1, 10, '\P{^Word_Break:__LF}', ""); +Expect(0, 9, '\p{Word_Break:__LF}', ""); +Expect(1, 9, '\p{^Word_Break:__LF}', ""); +Expect(1, 9, '\P{Word_Break:__LF}', ""); +Expect(0, 9, '\P{^Word_Break:__LF}', ""); +Error('\p{WB=_:=LF}'); +Error('\P{WB=_:=LF}'); +Expect(1, 10, '\p{WB=lf}', ""); +Expect(0, 10, '\p{^WB=lf}', ""); +Expect(0, 10, '\P{WB=lf}', ""); +Expect(1, 10, '\P{^WB=lf}', ""); +Expect(0, 9, '\p{WB=lf}', ""); +Expect(1, 9, '\p{^WB=lf}', ""); +Expect(1, 9, '\P{WB=lf}', ""); +Expect(0, 9, '\P{^WB=lf}', ""); +Expect(1, 10, '\p{WB=_ LF}', ""); +Expect(0, 10, '\p{^WB=_ LF}', ""); +Expect(0, 10, '\P{WB=_ LF}', ""); +Expect(1, 10, '\P{^WB=_ LF}', ""); +Expect(0, 9, '\p{WB=_ LF}', ""); +Expect(1, 9, '\p{^WB=_ LF}', ""); +Expect(1, 9, '\P{WB=_ LF}', ""); +Expect(0, 9, '\P{^WB=_ LF}', ""); +Error('\p{Is_Word_Break=-:=LF}'); +Error('\P{Is_Word_Break=-:=LF}'); +Expect(1, 10, '\p{Is_Word_Break=lf}', ""); +Expect(0, 10, '\p{^Is_Word_Break=lf}', ""); +Expect(0, 10, '\P{Is_Word_Break=lf}', ""); +Expect(1, 10, '\P{^Is_Word_Break=lf}', ""); +Expect(0, 9, '\p{Is_Word_Break=lf}', ""); +Expect(1, 9, '\p{^Is_Word_Break=lf}', ""); +Expect(1, 9, '\P{Is_Word_Break=lf}', ""); +Expect(0, 9, '\P{^Is_Word_Break=lf}', ""); +Expect(1, 10, '\p{Is_Word_Break= LF}', ""); +Expect(0, 10, '\p{^Is_Word_Break= LF}', ""); +Expect(0, 10, '\P{Is_Word_Break= LF}', ""); +Expect(1, 10, '\P{^Is_Word_Break= LF}', ""); +Expect(0, 9, '\p{Is_Word_Break= LF}', ""); +Expect(1, 9, '\p{^Is_Word_Break= LF}', ""); +Expect(1, 9, '\P{Is_Word_Break= LF}', ""); +Expect(0, 9, '\P{^Is_Word_Break= LF}', ""); +Error('\p{Is_WB: /a/LF}'); +Error('\P{Is_WB: /a/LF}'); +Expect(1, 10, '\p{Is_WB=lf}', ""); +Expect(0, 10, '\p{^Is_WB=lf}', ""); +Expect(0, 10, '\P{Is_WB=lf}', ""); +Expect(1, 10, '\P{^Is_WB=lf}', ""); +Expect(0, 9, '\p{Is_WB=lf}', ""); +Expect(1, 9, '\p{^Is_WB=lf}', ""); +Expect(1, 9, '\P{Is_WB=lf}', ""); +Expect(0, 9, '\P{^Is_WB=lf}', ""); +Expect(1, 10, '\p{Is_WB=_LF}', ""); +Expect(0, 10, '\p{^Is_WB=_LF}', ""); +Expect(0, 10, '\P{Is_WB=_LF}', ""); +Expect(1, 10, '\P{^Is_WB=_LF}', ""); +Expect(0, 9, '\p{Is_WB=_LF}', ""); +Expect(1, 9, '\p{^Is_WB=_LF}', ""); +Expect(1, 9, '\P{Is_WB=_LF}', ""); +Expect(0, 9, '\P{^Is_WB=_LF}', ""); +Error('\p{_-gothic/a/}'); +Error('\P{_-gothic/a/}'); +Expect(1, 66378, '\p{gothic}', ""); +Expect(0, 66378, '\p{^gothic}', ""); +Expect(0, 66378, '\P{gothic}', ""); +Expect(1, 66378, '\P{^gothic}', ""); +Expect(0, 66351, '\p{gothic}', ""); +Expect(1, 66351, '\p{^gothic}', ""); +Expect(1, 66351, '\P{gothic}', ""); +Expect(0, 66351, '\P{^gothic}', ""); +Expect(1, 66378, '\p{_Gothic}', ""); +Expect(0, 66378, '\p{^_Gothic}', ""); +Expect(0, 66378, '\P{_Gothic}', ""); +Expect(1, 66378, '\P{^_Gothic}', ""); +Expect(0, 66351, '\p{_Gothic}', ""); +Expect(1, 66351, '\p{^_Gothic}', ""); +Expect(1, 66351, '\P{_Gothic}', ""); +Expect(0, 66351, '\P{^_Gothic}', ""); +Error('\p{--Isgothic:=}'); +Error('\P{--Isgothic:=}'); +Expect(1, 66378, '\p{isgothic}', ""); +Expect(0, 66378, '\p{^isgothic}', ""); +Expect(0, 66378, '\P{isgothic}', ""); +Expect(1, 66378, '\P{^isgothic}', ""); +Expect(0, 66351, '\p{isgothic}', ""); +Expect(1, 66351, '\p{^isgothic}', ""); +Expect(1, 66351, '\P{isgothic}', ""); +Expect(0, 66351, '\P{^isgothic}', ""); +Expect(1, 66378, '\p{- Is-Gothic}', ""); +Expect(0, 66378, '\p{^- Is-Gothic}', ""); +Expect(0, 66378, '\P{- Is-Gothic}', ""); +Expect(1, 66378, '\P{^- Is-Gothic}', ""); +Expect(0, 66351, '\p{- Is-Gothic}', ""); +Expect(1, 66351, '\p{^- Is-Gothic}', ""); +Expect(1, 66351, '\P{- Is-Gothic}', ""); +Expect(0, 66351, '\P{^- Is-Gothic}', ""); +Error('\p{_goth:=}'); +Error('\P{_goth:=}'); +Expect(1, 66378, '\p{goth}', ""); +Expect(0, 66378, '\p{^goth}', ""); +Expect(0, 66378, '\P{goth}', ""); +Expect(1, 66378, '\P{^goth}', ""); +Expect(0, 66351, '\p{goth}', ""); +Expect(1, 66351, '\p{^goth}', ""); +Expect(1, 66351, '\P{goth}', ""); +Expect(0, 66351, '\P{^goth}', ""); +Expect(1, 66378, '\p{_-GOTH}', ""); +Expect(0, 66378, '\p{^_-GOTH}', ""); +Expect(0, 66378, '\P{_-GOTH}', ""); +Expect(1, 66378, '\P{^_-GOTH}', ""); +Expect(0, 66351, '\p{_-GOTH}', ""); +Expect(1, 66351, '\p{^_-GOTH}', ""); +Expect(1, 66351, '\P{_-GOTH}', ""); +Expect(0, 66351, '\P{^_-GOTH}', ""); +Error('\p{ Is-Goth/a/}'); +Error('\P{ Is-Goth/a/}'); +Expect(1, 66378, '\p{isgoth}', ""); +Expect(0, 66378, '\p{^isgoth}', ""); +Expect(0, 66378, '\P{isgoth}', ""); +Expect(1, 66378, '\P{^isgoth}', ""); +Expect(0, 66351, '\p{isgoth}', ""); +Expect(1, 66351, '\p{^isgoth}', ""); +Expect(1, 66351, '\P{isgoth}', ""); +Expect(0, 66351, '\P{^isgoth}', ""); +Expect(1, 66378, '\p{is-GOTH}', ""); +Expect(0, 66378, '\p{^is-GOTH}', ""); +Expect(0, 66378, '\P{is-GOTH}', ""); +Expect(1, 66378, '\P{^is-GOTH}', ""); +Expect(0, 66351, '\p{is-GOTH}', ""); +Expect(1, 66351, '\p{^is-GOTH}', ""); +Expect(1, 66351, '\P{is-GOTH}', ""); +Expect(0, 66351, '\P{^is-GOTH}', ""); +Error('\p{BLANK:=}'); +Error('\P{BLANK:=}'); +Expect(1, 9, '\p{blank}', ""); +Expect(0, 9, '\p{^blank}', ""); +Expect(0, 9, '\P{blank}', ""); +Expect(1, 9, '\P{^blank}', ""); +Expect(0, 8, '\p{blank}', ""); +Expect(1, 8, '\p{^blank}', ""); +Expect(1, 8, '\P{blank}', ""); +Expect(0, 8, '\P{^blank}', ""); +Expect(1, 9, '\p{ BLANK}', ""); +Expect(0, 9, '\p{^ BLANK}', ""); +Expect(0, 9, '\P{ BLANK}', ""); +Expect(1, 9, '\P{^ BLANK}', ""); +Expect(0, 8, '\p{ BLANK}', ""); +Expect(1, 8, '\p{^ BLANK}', ""); +Expect(1, 8, '\P{ BLANK}', ""); +Expect(0, 8, '\P{^ BLANK}', ""); +Error('\p{HorizSpace/a/}'); +Error('\P{HorizSpace/a/}'); +Expect(1, 9, '\p{horizspace}', ""); +Expect(0, 9, '\p{^horizspace}', ""); +Expect(0, 9, '\P{horizspace}', ""); +Expect(1, 9, '\P{^horizspace}', ""); +Expect(0, 8, '\p{horizspace}', ""); +Expect(1, 8, '\p{^horizspace}', ""); +Expect(1, 8, '\P{horizspace}', ""); +Expect(0, 8, '\P{^horizspace}', ""); +Expect(1, 9, '\p{_-HorizSpace}', ""); +Expect(0, 9, '\p{^_-HorizSpace}', ""); +Expect(0, 9, '\P{_-HorizSpace}', ""); +Expect(1, 9, '\P{^_-HorizSpace}', ""); +Expect(0, 8, '\p{_-HorizSpace}', ""); +Expect(1, 8, '\p{^_-HorizSpace}', ""); +Expect(1, 8, '\P{_-HorizSpace}', ""); +Expect(0, 8, '\P{^_-HorizSpace}', ""); +Error('\p{__IS/a/Blank}'); +Error('\P{__IS/a/Blank}'); +Expect(1, 9, '\p{isblank}', ""); +Expect(0, 9, '\p{^isblank}', ""); +Expect(0, 9, '\P{isblank}', ""); +Expect(1, 9, '\P{^isblank}', ""); +Expect(0, 8, '\p{isblank}', ""); +Expect(1, 8, '\p{^isblank}', ""); +Expect(1, 8, '\P{isblank}', ""); +Expect(0, 8, '\P{^isblank}', ""); +Error('\p{ isHORIZSPACE/a/}'); +Error('\P{ isHORIZSPACE/a/}'); +Expect(1, 9, '\p{ishorizspace}', ""); +Expect(0, 9, '\p{^ishorizspace}', ""); +Expect(0, 9, '\P{ishorizspace}', ""); +Expect(1, 9, '\P{^ishorizspace}', ""); +Expect(0, 8, '\p{ishorizspace}', ""); +Expect(1, 8, '\p{^ishorizspace}', ""); +Expect(1, 8, '\P{ishorizspace}', ""); +Expect(0, 8, '\P{^ishorizspace}', ""); +Expect(1, 9, '\p{- Is HorizSpace}', ""); +Expect(0, 9, '\p{^- Is HorizSpace}', ""); +Expect(0, 9, '\P{- Is HorizSpace}', ""); +Expect(1, 9, '\P{^- Is HorizSpace}', ""); +Expect(0, 8, '\p{- Is HorizSpace}', ""); +Expect(1, 8, '\p{^- Is HorizSpace}', ""); +Expect(1, 8, '\P{- Is HorizSpace}', ""); +Expect(0, 8, '\P{^- Is HorizSpace}', ""); +Error('\p{:=_Combining diacritical-Marks}'); +Error('\P{:=_Combining diacritical-Marks}'); +Expect(1, 879, '\p{combiningdiacriticalmarks}', ""); +Expect(0, 879, '\p{^combiningdiacriticalmarks}', ""); +Expect(0, 879, '\P{combiningdiacriticalmarks}', ""); +Expect(1, 879, '\P{^combiningdiacriticalmarks}', ""); +Expect(0, 767, '\p{combiningdiacriticalmarks}', ""); +Expect(1, 767, '\p{^combiningdiacriticalmarks}', ""); +Expect(1, 767, '\P{combiningdiacriticalmarks}', ""); +Expect(0, 767, '\P{^combiningdiacriticalmarks}', ""); +Expect(1, 879, '\p{COMBINING_DIACRITICALMARKS}', ""); +Expect(0, 879, '\p{^COMBINING_DIACRITICALMARKS}', ""); +Expect(0, 879, '\P{COMBINING_DIACRITICALMARKS}', ""); +Expect(1, 879, '\P{^COMBINING_DIACRITICALMARKS}', ""); +Expect(0, 767, '\p{COMBINING_DIACRITICALMARKS}', ""); +Expect(1, 767, '\p{^COMBINING_DIACRITICALMARKS}', ""); +Expect(1, 767, '\P{COMBINING_DIACRITICALMARKS}', ""); +Expect(0, 767, '\P{^COMBINING_DIACRITICALMARKS}', ""); +Error('\p{ Is COMBINING:=diacritical_MARKS}'); +Error('\P{ Is COMBINING:=diacritical_MARKS}'); +Expect(1, 879, '\p{iscombiningdiacriticalmarks}', ""); +Expect(0, 879, '\p{^iscombiningdiacriticalmarks}', ""); +Expect(0, 879, '\P{iscombiningdiacriticalmarks}', ""); +Expect(1, 879, '\P{^iscombiningdiacriticalmarks}', ""); +Expect(0, 767, '\p{iscombiningdiacriticalmarks}', ""); +Expect(1, 767, '\p{^iscombiningdiacriticalmarks}', ""); +Expect(1, 767, '\P{iscombiningdiacriticalmarks}', ""); +Expect(0, 767, '\P{^iscombiningdiacriticalmarks}', ""); +Expect(1, 879, '\p{ IsCOMBINING_DiacriticalMARKS}', ""); +Expect(0, 879, '\p{^ IsCOMBINING_DiacriticalMARKS}', ""); +Expect(0, 879, '\P{ IsCOMBINING_DiacriticalMARKS}', ""); +Expect(1, 879, '\P{^ IsCOMBINING_DiacriticalMARKS}', ""); +Expect(0, 767, '\p{ IsCOMBINING_DiacriticalMARKS}', ""); +Expect(1, 767, '\p{^ IsCOMBINING_DiacriticalMARKS}', ""); +Expect(1, 767, '\P{ IsCOMBINING_DiacriticalMARKS}', ""); +Expect(0, 767, '\P{^ IsCOMBINING_DiacriticalMARKS}', ""); +Error('\p{:=InCOMBINING diacritical_MARKS}'); +Error('\P{:=InCOMBINING diacritical_MARKS}'); +Expect(1, 879, '\p{incombiningdiacriticalmarks}', ""); +Expect(0, 879, '\p{^incombiningdiacriticalmarks}', ""); +Expect(0, 879, '\P{incombiningdiacriticalmarks}', ""); +Expect(1, 879, '\P{^incombiningdiacriticalmarks}', ""); +Expect(0, 767, '\p{incombiningdiacriticalmarks}', ""); +Expect(1, 767, '\p{^incombiningdiacriticalmarks}', ""); +Expect(1, 767, '\P{incombiningdiacriticalmarks}', ""); +Expect(0, 767, '\P{^incombiningdiacriticalmarks}', ""); +Expect(1, 879, '\p{--In_COMBINING Diacritical-Marks}', ""); +Expect(0, 879, '\p{^--In_COMBINING Diacritical-Marks}', ""); +Expect(0, 879, '\P{--In_COMBINING Diacritical-Marks}', ""); +Expect(1, 879, '\P{^--In_COMBINING Diacritical-Marks}', ""); +Expect(0, 767, '\p{--In_COMBINING Diacritical-Marks}', ""); +Expect(1, 767, '\p{^--In_COMBINING Diacritical-Marks}', ""); +Expect(1, 767, '\P{--In_COMBINING Diacritical-Marks}', ""); +Expect(0, 767, '\P{^--In_COMBINING Diacritical-Marks}', ""); +Error('\p{/a/_ETHIOPIC Supplement}'); +Error('\P{/a/_ETHIOPIC Supplement}'); +Expect(1, 5023, '\p{ethiopicsupplement}', ""); +Expect(0, 5023, '\p{^ethiopicsupplement}', ""); +Expect(0, 5023, '\P{ethiopicsupplement}', ""); +Expect(1, 5023, '\P{^ethiopicsupplement}', ""); +Expect(0, 4991, '\p{ethiopicsupplement}', ""); +Expect(1, 4991, '\p{^ethiopicsupplement}', ""); +Expect(1, 4991, '\P{ethiopicsupplement}', ""); +Expect(0, 4991, '\P{^ethiopicsupplement}', ""); +Expect(1, 5023, '\p{Ethiopic supplement}', ""); +Expect(0, 5023, '\p{^Ethiopic supplement}', ""); +Expect(0, 5023, '\P{Ethiopic supplement}', ""); +Expect(1, 5023, '\P{^Ethiopic supplement}', ""); +Expect(0, 4991, '\p{Ethiopic supplement}', ""); +Expect(1, 4991, '\p{^Ethiopic supplement}', ""); +Expect(1, 4991, '\P{Ethiopic supplement}', ""); +Expect(0, 4991, '\P{^Ethiopic supplement}', ""); +Error('\p{Is_ethiopic-Supplement/a/}'); +Error('\P{Is_ethiopic-Supplement/a/}'); +Expect(1, 5023, '\p{isethiopicsupplement}', ""); +Expect(0, 5023, '\p{^isethiopicsupplement}', ""); +Expect(0, 5023, '\P{isethiopicsupplement}', ""); +Expect(1, 5023, '\P{^isethiopicsupplement}', ""); +Expect(0, 4991, '\p{isethiopicsupplement}', ""); +Expect(1, 4991, '\p{^isethiopicsupplement}', ""); +Expect(1, 4991, '\P{isethiopicsupplement}', ""); +Expect(0, 4991, '\P{^isethiopicsupplement}', ""); +Expect(1, 5023, '\p{-_IS_EthiopicSUPPLEMENT}', ""); +Expect(0, 5023, '\p{^-_IS_EthiopicSUPPLEMENT}', ""); +Expect(0, 5023, '\P{-_IS_EthiopicSUPPLEMENT}', ""); +Expect(1, 5023, '\P{^-_IS_EthiopicSUPPLEMENT}', ""); +Expect(0, 4991, '\p{-_IS_EthiopicSUPPLEMENT}', ""); +Expect(1, 4991, '\p{^-_IS_EthiopicSUPPLEMENT}', ""); +Expect(1, 4991, '\P{-_IS_EthiopicSUPPLEMENT}', ""); +Expect(0, 4991, '\P{^-_IS_EthiopicSUPPLEMENT}', ""); +Error('\p{-:=INethiopic SUPPLEMENT}'); +Error('\P{-:=INethiopic SUPPLEMENT}'); +Expect(1, 5023, '\p{inethiopicsupplement}', ""); +Expect(0, 5023, '\p{^inethiopicsupplement}', ""); +Expect(0, 5023, '\P{inethiopicsupplement}', ""); +Expect(1, 5023, '\P{^inethiopicsupplement}', ""); +Expect(0, 4991, '\p{inethiopicsupplement}', ""); +Expect(1, 4991, '\p{^inethiopicsupplement}', ""); +Expect(1, 4991, '\P{inethiopicsupplement}', ""); +Expect(0, 4991, '\P{^inethiopicsupplement}', ""); +Expect(1, 5023, '\p{ _in ethiopicsupplement}', ""); +Expect(0, 5023, '\p{^ _in ethiopicsupplement}', ""); +Expect(0, 5023, '\P{ _in ethiopicsupplement}', ""); +Expect(1, 5023, '\P{^ _in ethiopicsupplement}', ""); +Expect(0, 4991, '\p{ _in ethiopicsupplement}', ""); +Expect(1, 4991, '\p{^ _in ethiopicsupplement}', ""); +Expect(1, 4991, '\P{ _in ethiopicsupplement}', ""); +Expect(0, 4991, '\P{^ _in ethiopicsupplement}', ""); +Error('\p{-/a/Dingbats}'); +Error('\P{-/a/Dingbats}'); +Expect(1, 10175, '\p{dingbats}', ""); +Expect(0, 10175, '\p{^dingbats}', ""); +Expect(0, 10175, '\P{dingbats}', ""); +Expect(1, 10175, '\P{^dingbats}', ""); +Expect(0, 9983, '\p{dingbats}', ""); +Expect(1, 9983, '\p{^dingbats}', ""); +Expect(1, 9983, '\P{dingbats}', ""); +Expect(0, 9983, '\P{^dingbats}', ""); +Expect(1, 10175, '\p{ dingbats}', ""); +Expect(0, 10175, '\p{^ dingbats}', ""); +Expect(0, 10175, '\P{ dingbats}', ""); +Expect(1, 10175, '\P{^ dingbats}', ""); +Expect(0, 9983, '\p{ dingbats}', ""); +Expect(1, 9983, '\p{^ dingbats}', ""); +Expect(1, 9983, '\P{ dingbats}', ""); +Expect(0, 9983, '\P{^ dingbats}', ""); +Error('\p{ _IS dingbats:=}'); +Error('\P{ _IS dingbats:=}'); +Expect(1, 10175, '\p{isdingbats}', ""); +Expect(0, 10175, '\p{^isdingbats}', ""); +Expect(0, 10175, '\P{isdingbats}', ""); +Expect(1, 10175, '\P{^isdingbats}', ""); +Expect(0, 9983, '\p{isdingbats}', ""); +Expect(1, 9983, '\p{^isdingbats}', ""); +Expect(1, 9983, '\P{isdingbats}', ""); +Expect(0, 9983, '\P{^isdingbats}', ""); +Expect(1, 10175, '\p{-_Is dingbats}', ""); +Expect(0, 10175, '\p{^-_Is dingbats}', ""); +Expect(0, 10175, '\P{-_Is dingbats}', ""); +Expect(1, 10175, '\P{^-_Is dingbats}', ""); +Expect(0, 9983, '\p{-_Is dingbats}', ""); +Expect(1, 9983, '\p{^-_Is dingbats}', ""); +Expect(1, 9983, '\P{-_Is dingbats}', ""); +Expect(0, 9983, '\P{^-_Is dingbats}', ""); +Error('\p{ in/a/dingbats}'); +Error('\P{ in/a/dingbats}'); +Expect(1, 10175, '\p{indingbats}', ""); +Expect(0, 10175, '\p{^indingbats}', ""); +Expect(0, 10175, '\P{indingbats}', ""); +Expect(1, 10175, '\P{^indingbats}', ""); +Expect(0, 9983, '\p{indingbats}', ""); +Expect(1, 9983, '\p{^indingbats}', ""); +Expect(1, 9983, '\P{indingbats}', ""); +Expect(0, 9983, '\P{^indingbats}', ""); +Expect(1, 10175, '\p{-in-DINGBATS}', ""); +Expect(0, 10175, '\p{^-in-DINGBATS}', ""); +Expect(0, 10175, '\P{-in-DINGBATS}', ""); +Expect(1, 10175, '\P{^-in-DINGBATS}', ""); +Expect(0, 9983, '\p{-in-DINGBATS}', ""); +Expect(1, 9983, '\p{^-in-DINGBATS}', ""); +Expect(1, 9983, '\P{-in-DINGBATS}', ""); +Expect(0, 9983, '\P{^-in-DINGBATS}', ""); +Error('\p{/a/- Logical-ORDER_Exception}'); +Error('\P{/a/- Logical-ORDER_Exception}'); +Expect(1, 3652, '\p{logicalorderexception}', ""); +Expect(0, 3652, '\p{^logicalorderexception}', ""); +Expect(0, 3652, '\P{logicalorderexception}', ""); +Expect(1, 3652, '\P{^logicalorderexception}', ""); +Expect(0, 3647, '\p{logicalorderexception}', ""); +Expect(1, 3647, '\p{^logicalorderexception}', ""); +Expect(1, 3647, '\P{logicalorderexception}', ""); +Expect(0, 3647, '\P{^logicalorderexception}', ""); +Expect(1, 3652, '\p{-_LOGICAL-OrderException}', ""); +Expect(0, 3652, '\p{^-_LOGICAL-OrderException}', ""); +Expect(0, 3652, '\P{-_LOGICAL-OrderException}', ""); +Expect(1, 3652, '\P{^-_LOGICAL-OrderException}', ""); +Expect(0, 3647, '\p{-_LOGICAL-OrderException}', ""); +Expect(1, 3647, '\p{^-_LOGICAL-OrderException}', ""); +Expect(1, 3647, '\P{-_LOGICAL-OrderException}', ""); +Expect(0, 3647, '\P{^-_LOGICAL-OrderException}', ""); +Error('\p{-:=IS_LOGICAL order Exception}'); +Error('\P{-:=IS_LOGICAL order Exception}'); +Expect(1, 3652, '\p{islogicalorderexception}', ""); +Expect(0, 3652, '\p{^islogicalorderexception}', ""); +Expect(0, 3652, '\P{islogicalorderexception}', ""); +Expect(1, 3652, '\P{^islogicalorderexception}', ""); +Expect(0, 3647, '\p{islogicalorderexception}', ""); +Expect(1, 3647, '\p{^islogicalorderexception}', ""); +Expect(1, 3647, '\P{islogicalorderexception}', ""); +Expect(0, 3647, '\P{^islogicalorderexception}', ""); +Expect(1, 3652, '\p{_ is Logical Order-exception}', ""); +Expect(0, 3652, '\p{^_ is Logical Order-exception}', ""); +Expect(0, 3652, '\P{_ is Logical Order-exception}', ""); +Expect(1, 3652, '\P{^_ is Logical Order-exception}', ""); +Expect(0, 3647, '\p{_ is Logical Order-exception}', ""); +Expect(1, 3647, '\p{^_ is Logical Order-exception}', ""); +Expect(1, 3647, '\P{_ is Logical Order-exception}', ""); +Expect(0, 3647, '\P{^_ is Logical Order-exception}', ""); +Error('\p{ LOE:=}'); +Error('\P{ LOE:=}'); +Expect(1, 3652, '\p{loe}', ""); +Expect(0, 3652, '\p{^loe}', ""); +Expect(0, 3652, '\P{loe}', ""); +Expect(1, 3652, '\P{^loe}', ""); +Expect(0, 3647, '\p{loe}', ""); +Expect(1, 3647, '\p{^loe}', ""); +Expect(1, 3647, '\P{loe}', ""); +Expect(0, 3647, '\P{^loe}', ""); +Expect(1, 3652, '\p{__LOE}', ""); +Expect(0, 3652, '\p{^__LOE}', ""); +Expect(0, 3652, '\P{__LOE}', ""); +Expect(1, 3652, '\P{^__LOE}', ""); +Expect(0, 3647, '\p{__LOE}', ""); +Expect(1, 3647, '\p{^__LOE}', ""); +Expect(1, 3647, '\P{__LOE}', ""); +Expect(0, 3647, '\P{^__LOE}', ""); +Error('\p{/a/_-Is LOE}'); +Error('\P{/a/_-Is LOE}'); +Expect(1, 3652, '\p{isloe}', ""); +Expect(0, 3652, '\p{^isloe}', ""); +Expect(0, 3652, '\P{isloe}', ""); +Expect(1, 3652, '\P{^isloe}', ""); +Expect(0, 3647, '\p{isloe}', ""); +Expect(1, 3647, '\p{^isloe}', ""); +Expect(1, 3647, '\P{isloe}', ""); +Expect(0, 3647, '\P{^isloe}', ""); +Expect(1, 3652, '\p{--Isloe}', ""); +Expect(0, 3652, '\p{^--Isloe}', ""); +Expect(0, 3652, '\P{--Isloe}', ""); +Expect(1, 3652, '\P{^--Isloe}', ""); +Expect(0, 3647, '\p{--Isloe}', ""); +Expect(1, 3647, '\p{^--Isloe}', ""); +Expect(1, 3647, '\P{--Isloe}', ""); +Expect(0, 3647, '\P{^--Isloe}', ""); +Error('\p{:= in lycian}'); +Error('\P{:= in lycian}'); +Expect(1, 66207, '\p{inlycian}', ""); +Expect(0, 66207, '\p{^inlycian}', ""); +Expect(0, 66207, '\P{inlycian}', ""); +Expect(1, 66207, '\P{^inlycian}', ""); +Expect(0, 66175, '\p{inlycian}', ""); +Expect(1, 66175, '\p{^inlycian}', ""); +Expect(1, 66175, '\P{inlycian}', ""); +Expect(0, 66175, '\P{^inlycian}', ""); +Expect(1, 66207, '\p{ In LYCIAN}', ""); +Expect(0, 66207, '\p{^ In LYCIAN}', ""); +Expect(0, 66207, '\P{ In LYCIAN}', ""); +Expect(1, 66207, '\P{^ In LYCIAN}', ""); +Expect(0, 66175, '\p{ In LYCIAN}', ""); +Expect(1, 66175, '\p{^ In LYCIAN}', ""); +Expect(1, 66175, '\P{ In LYCIAN}', ""); +Expect(0, 66175, '\P{^ In LYCIAN}', ""); +Error('\p{__Vai/a/}'); +Error('\P{__Vai/a/}'); +Expect(1, 42539, '\p{vai}', ""); +Expect(0, 42539, '\p{^vai}', ""); +Expect(0, 42539, '\P{vai}', ""); +Expect(1, 42539, '\P{^vai}', ""); +Expect(0, 42239, '\p{vai}', ""); +Expect(1, 42239, '\p{^vai}', ""); +Expect(1, 42239, '\P{vai}', ""); +Expect(0, 42239, '\P{^vai}', ""); +Expect(1, 42539, '\p{_ Vai}', ""); +Expect(0, 42539, '\p{^_ Vai}', ""); +Expect(0, 42539, '\P{_ Vai}', ""); +Expect(1, 42539, '\P{^_ Vai}', ""); +Expect(0, 42239, '\p{_ Vai}', ""); +Expect(1, 42239, '\p{^_ Vai}', ""); +Expect(1, 42239, '\P{_ Vai}', ""); +Expect(0, 42239, '\P{^_ Vai}', ""); +Error('\p{-/a/IS_VAI}'); +Error('\P{-/a/IS_VAI}'); +Expect(1, 42539, '\p{isvai}', ""); +Expect(0, 42539, '\p{^isvai}', ""); +Expect(0, 42539, '\P{isvai}', ""); +Expect(1, 42539, '\P{^isvai}', ""); +Expect(0, 42239, '\p{isvai}', ""); +Expect(1, 42239, '\p{^isvai}', ""); +Expect(1, 42239, '\P{isvai}', ""); +Expect(0, 42239, '\P{^isvai}', ""); +Expect(1, 42539, '\p{_IS-Vai}', ""); +Expect(0, 42539, '\p{^_IS-Vai}', ""); +Expect(0, 42539, '\P{_IS-Vai}', ""); +Expect(1, 42539, '\P{^_IS-Vai}', ""); +Expect(0, 42239, '\p{_IS-Vai}', ""); +Expect(1, 42239, '\p{^_IS-Vai}', ""); +Expect(1, 42239, '\P{_IS-Vai}', ""); +Expect(0, 42239, '\P{^_IS-Vai}', ""); +Error('\p{ Vaii/a/}'); +Error('\P{ Vaii/a/}'); +Expect(1, 42539, '\p{vaii}', ""); +Expect(0, 42539, '\p{^vaii}', ""); +Expect(0, 42539, '\P{vaii}', ""); +Expect(1, 42539, '\P{^vaii}', ""); +Expect(0, 42239, '\p{vaii}', ""); +Expect(1, 42239, '\p{^vaii}', ""); +Expect(1, 42239, '\P{vaii}', ""); +Expect(0, 42239, '\P{^vaii}', ""); +Expect(1, 42539, '\p{-Vaii}', ""); +Expect(0, 42539, '\p{^-Vaii}', ""); +Expect(0, 42539, '\P{-Vaii}', ""); +Expect(1, 42539, '\P{^-Vaii}', ""); +Expect(0, 42239, '\p{-Vaii}', ""); +Expect(1, 42239, '\p{^-Vaii}', ""); +Expect(1, 42239, '\P{-Vaii}', ""); +Expect(0, 42239, '\P{^-Vaii}', ""); +Error('\p{ _Is-vaii:=}'); +Error('\P{ _Is-vaii:=}'); +Expect(1, 42539, '\p{isvaii}', ""); +Expect(0, 42539, '\p{^isvaii}', ""); +Expect(0, 42539, '\P{isvaii}', ""); +Expect(1, 42539, '\P{^isvaii}', ""); +Expect(0, 42239, '\p{isvaii}', ""); +Expect(1, 42239, '\p{^isvaii}', ""); +Expect(1, 42239, '\P{isvaii}', ""); +Expect(0, 42239, '\P{^isvaii}', ""); +Expect(1, 42539, '\p{ IS_VAII}', ""); +Expect(0, 42539, '\p{^ IS_VAII}', ""); +Expect(0, 42539, '\P{ IS_VAII}', ""); +Expect(1, 42539, '\P{^ IS_VAII}', ""); +Expect(0, 42239, '\p{ IS_VAII}', ""); +Expect(1, 42239, '\p{^ IS_VAII}', ""); +Expect(1, 42239, '\P{ IS_VAII}', ""); +Expect(0, 42239, '\P{^ IS_VAII}', ""); +Error('\p{ /a/SPACING_MARK}'); +Error('\P{ /a/SPACING_MARK}'); +Expect(1, 2307, '\p{spacingmark}', ""); +Expect(0, 2307, '\p{^spacingmark}', ""); +Expect(0, 2307, '\P{spacingmark}', ""); +Expect(1, 2307, '\P{^spacingmark}', ""); +Expect(0, 2306, '\p{spacingmark}', ""); +Expect(1, 2306, '\p{^spacingmark}', ""); +Expect(1, 2306, '\P{spacingmark}', ""); +Expect(0, 2306, '\P{^spacingmark}', ""); +Expect(1, 2307, '\p{_ spacing MARK}', ""); +Expect(0, 2307, '\p{^_ spacing MARK}', ""); +Expect(0, 2307, '\P{_ spacing MARK}', ""); +Expect(1, 2307, '\P{^_ spacing MARK}', ""); +Expect(0, 2306, '\p{_ spacing MARK}', ""); +Expect(1, 2306, '\p{^_ spacing MARK}', ""); +Expect(1, 2306, '\P{_ spacing MARK}', ""); +Expect(0, 2306, '\P{^_ spacing MARK}', ""); +Error('\p{ is/a/SpacingMARK}'); +Error('\P{ is/a/SpacingMARK}'); +Expect(1, 2307, '\p{isspacingmark}', ""); +Expect(0, 2307, '\p{^isspacingmark}', ""); +Expect(0, 2307, '\P{isspacingmark}', ""); +Expect(1, 2307, '\P{^isspacingmark}', ""); +Expect(0, 2306, '\p{isspacingmark}', ""); +Expect(1, 2306, '\p{^isspacingmark}', ""); +Expect(1, 2306, '\P{isspacingmark}', ""); +Expect(0, 2306, '\P{^isspacingmark}', ""); +Expect(1, 2307, '\p{ -ISSpacing-Mark}', ""); +Expect(0, 2307, '\p{^ -ISSpacing-Mark}', ""); +Expect(0, 2307, '\P{ -ISSpacing-Mark}', ""); +Expect(1, 2307, '\P{^ -ISSpacing-Mark}', ""); +Expect(0, 2306, '\p{ -ISSpacing-Mark}', ""); +Expect(1, 2306, '\p{^ -ISSpacing-Mark}', ""); +Expect(1, 2306, '\P{ -ISSpacing-Mark}', ""); +Expect(0, 2306, '\P{^ -ISSpacing-Mark}', ""); +Error('\p{ :=Mc}'); +Error('\P{ :=Mc}'); +Expect(1, 2307, '\p{mc}', ""); +Expect(0, 2307, '\p{^mc}', ""); +Expect(0, 2307, '\P{mc}', ""); +Expect(1, 2307, '\P{^mc}', ""); +Expect(0, 2306, '\p{mc}', ""); +Expect(1, 2306, '\p{^mc}', ""); +Expect(1, 2306, '\P{mc}', ""); +Expect(0, 2306, '\P{^mc}', ""); +Error('\p{ :=Ismc}'); +Error('\P{ :=Ismc}'); +Expect(1, 2307, '\p{ismc}', ""); +Expect(0, 2307, '\p{^ismc}', ""); +Expect(0, 2307, '\P{ismc}', ""); +Expect(1, 2307, '\P{^ismc}', ""); +Expect(0, 2306, '\p{ismc}', ""); +Expect(1, 2306, '\p{^ismc}', ""); +Expect(1, 2306, '\P{ismc}', ""); +Expect(0, 2306, '\P{^ismc}', ""); +Expect(1, 2307, '\p{- Is_mc}', ""); +Expect(0, 2307, '\p{^- Is_mc}', ""); +Expect(0, 2307, '\P{- Is_mc}', ""); +Expect(1, 2307, '\P{^- Is_mc}', ""); +Expect(0, 2306, '\p{- Is_mc}', ""); +Expect(1, 2306, '\p{^- Is_mc}', ""); +Expect(1, 2306, '\P{- Is_mc}', ""); +Expect(0, 2306, '\P{^- Is_mc}', ""); +Error('\p{:=_ lower}'); +Error('\P{:=_ lower}'); +Expect(1, 122, '\p{lower}', ""); +Expect(0, 122, '\p{^lower}', ""); +Expect(0, 122, '\P{lower}', ""); +Expect(1, 122, '\P{^lower}', ""); +Expect(0, 96, '\p{lower}', ""); +Expect(1, 96, '\p{^lower}', ""); +Expect(1, 96, '\P{lower}', ""); +Expect(0, 96, '\P{^lower}', ""); +Expect(1, 122, '\p{_lower}', ""); +Expect(0, 122, '\p{^_lower}', ""); +Expect(0, 122, '\P{_lower}', ""); +Expect(1, 122, '\P{^_lower}', ""); +Expect(0, 96, '\p{_lower}', ""); +Expect(1, 96, '\p{^_lower}', ""); +Expect(1, 96, '\P{_lower}', ""); +Expect(0, 96, '\P{^_lower}', ""); +Error('\p{ is/a/LOWER}'); +Error('\P{ is/a/LOWER}'); +Expect(1, 122, '\p{islower}', ""); +Expect(0, 122, '\p{^islower}', ""); +Expect(0, 122, '\P{islower}', ""); +Expect(1, 122, '\P{^islower}', ""); +Expect(0, 96, '\p{islower}', ""); +Expect(1, 96, '\p{^islower}', ""); +Expect(1, 96, '\P{islower}', ""); +Expect(0, 96, '\P{^islower}', ""); +Expect(1, 122, '\p{ _is Lower}', ""); +Expect(0, 122, '\p{^ _is Lower}', ""); +Expect(0, 122, '\P{ _is Lower}', ""); +Expect(1, 122, '\P{^ _is Lower}', ""); +Expect(0, 96, '\p{ _is Lower}', ""); +Expect(1, 96, '\p{^ _is Lower}', ""); +Expect(1, 96, '\P{ _is Lower}', ""); +Expect(0, 96, '\P{^ _is Lower}', ""); +Error('\p{_-Lowercase:=}'); +Error('\P{_-Lowercase:=}'); +Expect(1, 122, '\p{lowercase}', ""); +Expect(0, 122, '\p{^lowercase}', ""); +Expect(0, 122, '\P{lowercase}', ""); +Expect(1, 122, '\P{^lowercase}', ""); +Expect(0, 96, '\p{lowercase}', ""); +Expect(1, 96, '\p{^lowercase}', ""); +Expect(1, 96, '\P{lowercase}', ""); +Expect(0, 96, '\P{^lowercase}', ""); +Expect(1, 122, '\p{ _Lowercase}', ""); +Expect(0, 122, '\p{^ _Lowercase}', ""); +Expect(0, 122, '\P{ _Lowercase}', ""); +Expect(1, 122, '\P{^ _Lowercase}', ""); +Expect(0, 96, '\p{ _Lowercase}', ""); +Expect(1, 96, '\p{^ _Lowercase}', ""); +Expect(1, 96, '\P{ _Lowercase}', ""); +Expect(0, 96, '\P{^ _Lowercase}', ""); +Error('\p{_:=is_Lowercase}'); +Error('\P{_:=is_Lowercase}'); +Expect(1, 122, '\p{islowercase}', ""); +Expect(0, 122, '\p{^islowercase}', ""); +Expect(0, 122, '\P{islowercase}', ""); +Expect(1, 122, '\P{^islowercase}', ""); +Expect(0, 96, '\p{islowercase}', ""); +Expect(1, 96, '\p{^islowercase}', ""); +Expect(1, 96, '\P{islowercase}', ""); +Expect(0, 96, '\P{^islowercase}', ""); +Expect(1, 122, '\p{Is_lowercase}', ""); +Expect(0, 122, '\p{^Is_lowercase}', ""); +Expect(0, 122, '\P{Is_lowercase}', ""); +Expect(1, 122, '\P{^Is_lowercase}', ""); +Expect(0, 96, '\p{Is_lowercase}', ""); +Expect(1, 96, '\p{^Is_lowercase}', ""); +Expect(1, 96, '\P{Is_lowercase}', ""); +Expect(0, 96, '\P{^Is_lowercase}', ""); +Error('\p{Expands_On_NFKD}'); +Error('\P{Expands_On_NFKD}'); +Error('\p{Is_Expands_On_NFKD}'); +Error('\P{Is_Expands_On_NFKD}'); +Error('\p{XO_NFKD}'); +Error('\P{XO_NFKD}'); +Error('\p{Is_XO_NFKD}'); +Error('\P{Is_XO_NFKD}'); +Error('\p{/a/_-Close_PUNCTUATION}'); +Error('\P{/a/_-Close_PUNCTUATION}'); +Expect(1, 41, '\p{closepunctuation}', ""); +Expect(0, 41, '\p{^closepunctuation}', ""); +Expect(0, 41, '\P{closepunctuation}', ""); +Expect(1, 41, '\P{^closepunctuation}', ""); +Expect(0, 40, '\p{closepunctuation}', ""); +Expect(1, 40, '\p{^closepunctuation}', ""); +Expect(1, 40, '\P{closepunctuation}', ""); +Expect(0, 40, '\P{^closepunctuation}', ""); +Expect(1, 41, '\p{_-CLOSE punctuation}', ""); +Expect(0, 41, '\p{^_-CLOSE punctuation}', ""); +Expect(0, 41, '\P{_-CLOSE punctuation}', ""); +Expect(1, 41, '\P{^_-CLOSE punctuation}', ""); +Expect(0, 40, '\p{_-CLOSE punctuation}', ""); +Expect(1, 40, '\p{^_-CLOSE punctuation}', ""); +Expect(1, 40, '\P{_-CLOSE punctuation}', ""); +Expect(0, 40, '\P{^_-CLOSE punctuation}', ""); +Error('\p{ -Is:=Close_PUNCTUATION}'); +Error('\P{ -Is:=Close_PUNCTUATION}'); +Expect(1, 41, '\p{isclosepunctuation}', ""); +Expect(0, 41, '\p{^isclosepunctuation}', ""); +Expect(0, 41, '\P{isclosepunctuation}', ""); +Expect(1, 41, '\P{^isclosepunctuation}', ""); +Expect(0, 40, '\p{isclosepunctuation}', ""); +Expect(1, 40, '\p{^isclosepunctuation}', ""); +Expect(1, 40, '\P{isclosepunctuation}', ""); +Expect(0, 40, '\P{^isclosepunctuation}', ""); +Expect(1, 41, '\p{ Is Close_Punctuation}', ""); +Expect(0, 41, '\p{^ Is Close_Punctuation}', ""); +Expect(0, 41, '\P{ Is Close_Punctuation}', ""); +Expect(1, 41, '\P{^ Is Close_Punctuation}', ""); +Expect(0, 40, '\p{ Is Close_Punctuation}', ""); +Expect(1, 40, '\p{^ Is Close_Punctuation}', ""); +Expect(1, 40, '\P{ Is Close_Punctuation}', ""); +Expect(0, 40, '\P{^ Is Close_Punctuation}', ""); +Error('\p{:= Pe}'); +Error('\P{:= Pe}'); +Expect(1, 41, '\p{pe}', ""); +Expect(0, 41, '\p{^pe}', ""); +Expect(0, 41, '\P{pe}', ""); +Expect(1, 41, '\P{^pe}', ""); +Expect(0, 40, '\p{pe}', ""); +Expect(1, 40, '\p{^pe}', ""); +Expect(1, 40, '\P{pe}', ""); +Expect(0, 40, '\P{^pe}', ""); +Expect(1, 41, '\p{ PE}', ""); +Expect(0, 41, '\p{^ PE}', ""); +Expect(0, 41, '\P{ PE}', ""); +Expect(1, 41, '\P{^ PE}', ""); +Expect(0, 40, '\p{ PE}', ""); +Expect(1, 40, '\p{^ PE}', ""); +Expect(1, 40, '\P{ PE}', ""); +Expect(0, 40, '\P{^ PE}', ""); +Error('\p{ :=ispe}'); +Error('\P{ :=ispe}'); +Expect(1, 41, '\p{ispe}', ""); +Expect(0, 41, '\p{^ispe}', ""); +Expect(0, 41, '\P{ispe}', ""); +Expect(1, 41, '\P{^ispe}', ""); +Expect(0, 40, '\p{ispe}', ""); +Expect(1, 40, '\p{^ispe}', ""); +Expect(1, 40, '\P{ispe}', ""); +Expect(0, 40, '\P{^ispe}', ""); +Expect(1, 41, '\p{-Is PE}', ""); +Expect(0, 41, '\p{^-Is PE}', ""); +Expect(0, 41, '\P{-Is PE}', ""); +Expect(1, 41, '\P{^-Is PE}', ""); +Expect(0, 40, '\p{-Is PE}', ""); +Expect(1, 40, '\p{^-Is PE}', ""); +Expect(1, 40, '\P{-Is PE}', ""); +Expect(0, 40, '\P{^-Is PE}', ""); +Error('\p{Expands_On_NFKC}'); +Error('\P{Expands_On_NFKC}'); +Error('\p{Is_Expands_On_NFKC}'); +Error('\P{Is_Expands_On_NFKC}'); +Error('\p{XO_NFKC}'); +Error('\P{XO_NFKC}'); +Error('\p{Is_XO_NFKC}'); +Error('\P{Is_XO_NFKC}'); +Error('\p{__UNKNOWN/a/}'); +Error('\P{__UNKNOWN/a/}'); +Expect(1, 889, '\p{unknown}', ""); +Expect(0, 889, '\p{^unknown}', ""); +Expect(0, 889, '\P{unknown}', ""); +Expect(1, 889, '\P{^unknown}', ""); +Expect(0, 887, '\p{unknown}', ""); +Expect(1, 887, '\p{^unknown}', ""); +Expect(1, 887, '\P{unknown}', ""); +Expect(0, 887, '\P{^unknown}', ""); +Expect(1, 889, '\p{ Unknown}', ""); +Expect(0, 889, '\p{^ Unknown}', ""); +Expect(0, 889, '\P{ Unknown}', ""); +Expect(1, 889, '\P{^ Unknown}', ""); +Expect(0, 887, '\p{ Unknown}', ""); +Expect(1, 887, '\p{^ Unknown}', ""); +Expect(1, 887, '\P{ Unknown}', ""); +Expect(0, 887, '\P{^ Unknown}', ""); +Error('\p{--IS:=UNKNOWN}'); +Error('\P{--IS:=UNKNOWN}'); +Expect(1, 889, '\p{isunknown}', ""); +Expect(0, 889, '\p{^isunknown}', ""); +Expect(0, 889, '\P{isunknown}', ""); +Expect(1, 889, '\P{^isunknown}', ""); +Expect(0, 887, '\p{isunknown}', ""); +Expect(1, 887, '\p{^isunknown}', ""); +Expect(1, 887, '\P{isunknown}', ""); +Expect(0, 887, '\P{^isunknown}', ""); +Expect(1, 889, '\p{- IsUNKNOWN}', ""); +Expect(0, 889, '\p{^- IsUNKNOWN}', ""); +Expect(0, 889, '\P{- IsUNKNOWN}', ""); +Expect(1, 889, '\P{^- IsUNKNOWN}', ""); +Expect(0, 887, '\p{- IsUNKNOWN}', ""); +Expect(1, 887, '\p{^- IsUNKNOWN}', ""); +Expect(1, 887, '\P{- IsUNKNOWN}', ""); +Expect(0, 887, '\P{^- IsUNKNOWN}', ""); +Error('\p{-/a/zzzz}'); +Error('\P{-/a/zzzz}'); +Expect(1, 889, '\p{zzzz}', ""); +Expect(0, 889, '\p{^zzzz}', ""); +Expect(0, 889, '\P{zzzz}', ""); +Expect(1, 889, '\P{^zzzz}', ""); +Expect(0, 887, '\p{zzzz}', ""); +Expect(1, 887, '\p{^zzzz}', ""); +Expect(1, 887, '\P{zzzz}', ""); +Expect(0, 887, '\P{^zzzz}', ""); +Expect(1, 889, '\p{--Zzzz}', ""); +Expect(0, 889, '\p{^--Zzzz}', ""); +Expect(0, 889, '\P{--Zzzz}', ""); +Expect(1, 889, '\P{^--Zzzz}', ""); +Expect(0, 887, '\p{--Zzzz}', ""); +Expect(1, 887, '\p{^--Zzzz}', ""); +Expect(1, 887, '\P{--Zzzz}', ""); +Expect(0, 887, '\P{^--Zzzz}', ""); +Error('\p{/a/is Zzzz}'); +Error('\P{/a/is Zzzz}'); +Expect(1, 889, '\p{iszzzz}', ""); +Expect(0, 889, '\p{^iszzzz}', ""); +Expect(0, 889, '\P{iszzzz}', ""); +Expect(1, 889, '\P{^iszzzz}', ""); +Expect(0, 887, '\p{iszzzz}', ""); +Expect(1, 887, '\p{^iszzzz}', ""); +Expect(1, 887, '\P{iszzzz}', ""); +Expect(0, 887, '\P{^iszzzz}', ""); +Expect(1, 889, '\p{--Is Zzzz}', ""); +Expect(0, 889, '\p{^--Is Zzzz}', ""); +Expect(0, 889, '\P{--Is Zzzz}', ""); +Expect(1, 889, '\P{^--Is Zzzz}', ""); +Expect(0, 887, '\p{--Is Zzzz}', ""); +Expect(1, 887, '\p{^--Is Zzzz}', ""); +Expect(1, 887, '\P{--Is Zzzz}', ""); +Expect(0, 887, '\P{^--Is Zzzz}', ""); +Error('\p{:= LINEARB Ideograms}'); +Error('\P{:= LINEARB Ideograms}'); +Expect(1, 65791, '\p{linearbideograms}', ""); +Expect(0, 65791, '\p{^linearbideograms}', ""); +Expect(0, 65791, '\P{linearbideograms}', ""); +Expect(1, 65791, '\P{^linearbideograms}', ""); +Expect(0, 65663, '\p{linearbideograms}', ""); +Expect(1, 65663, '\p{^linearbideograms}', ""); +Expect(1, 65663, '\P{linearbideograms}', ""); +Expect(0, 65663, '\P{^linearbideograms}', ""); +Expect(1, 65791, '\p{ LinearB IDEOGRAMS}', ""); +Expect(0, 65791, '\p{^ LinearB IDEOGRAMS}', ""); +Expect(0, 65791, '\P{ LinearB IDEOGRAMS}', ""); +Expect(1, 65791, '\P{^ LinearB IDEOGRAMS}', ""); +Expect(0, 65663, '\p{ LinearB IDEOGRAMS}', ""); +Expect(1, 65663, '\p{^ LinearB IDEOGRAMS}', ""); +Expect(1, 65663, '\P{ LinearB IDEOGRAMS}', ""); +Expect(0, 65663, '\P{^ LinearB IDEOGRAMS}', ""); +Error('\p{ _Is/a/Linear-B_IDEOGRAMS}'); +Error('\P{ _Is/a/Linear-B_IDEOGRAMS}'); +Expect(1, 65791, '\p{islinearbideograms}', ""); +Expect(0, 65791, '\p{^islinearbideograms}', ""); +Expect(0, 65791, '\P{islinearbideograms}', ""); +Expect(1, 65791, '\P{^islinearbideograms}', ""); +Expect(0, 65663, '\p{islinearbideograms}', ""); +Expect(1, 65663, '\p{^islinearbideograms}', ""); +Expect(1, 65663, '\P{islinearbideograms}', ""); +Expect(0, 65663, '\P{^islinearbideograms}', ""); +Expect(1, 65791, '\p{ ISLINEAR_B Ideograms}', ""); +Expect(0, 65791, '\p{^ ISLINEAR_B Ideograms}', ""); +Expect(0, 65791, '\P{ ISLINEAR_B Ideograms}', ""); +Expect(1, 65791, '\P{^ ISLINEAR_B Ideograms}', ""); +Expect(0, 65663, '\p{ ISLINEAR_B Ideograms}', ""); +Expect(1, 65663, '\p{^ ISLINEAR_B Ideograms}', ""); +Expect(1, 65663, '\P{ ISLINEAR_B Ideograms}', ""); +Expect(0, 65663, '\P{^ ISLINEAR_B Ideograms}', ""); +Error('\p{ IN-LinearB:=IDEOGRAMS}'); +Error('\P{ IN-LinearB:=IDEOGRAMS}'); +Expect(1, 65791, '\p{inlinearbideograms}', ""); +Expect(0, 65791, '\p{^inlinearbideograms}', ""); +Expect(0, 65791, '\P{inlinearbideograms}', ""); +Expect(1, 65791, '\P{^inlinearbideograms}', ""); +Expect(0, 65663, '\p{inlinearbideograms}', ""); +Expect(1, 65663, '\p{^inlinearbideograms}', ""); +Expect(1, 65663, '\P{inlinearbideograms}', ""); +Expect(0, 65663, '\P{^inlinearbideograms}', ""); +Expect(1, 65791, '\p{ InLinearB Ideograms}', ""); +Expect(0, 65791, '\p{^ InLinearB Ideograms}', ""); +Expect(0, 65791, '\P{ InLinearB Ideograms}', ""); +Expect(1, 65791, '\P{^ InLinearB Ideograms}', ""); +Expect(0, 65663, '\p{ InLinearB Ideograms}', ""); +Expect(1, 65663, '\p{^ InLinearB Ideograms}', ""); +Expect(1, 65663, '\P{ InLinearB Ideograms}', ""); +Expect(0, 65663, '\P{^ InLinearB Ideograms}', ""); +Error('\p{ Enclosed-alphanumerics:=}'); +Error('\P{ Enclosed-alphanumerics:=}'); +Expect(1, 9471, '\p{enclosedalphanumerics}', ""); +Expect(0, 9471, '\p{^enclosedalphanumerics}', ""); +Expect(0, 9471, '\P{enclosedalphanumerics}', ""); +Expect(1, 9471, '\P{^enclosedalphanumerics}', ""); +Expect(0, 9311, '\p{enclosedalphanumerics}', ""); +Expect(1, 9311, '\p{^enclosedalphanumerics}', ""); +Expect(1, 9311, '\P{enclosedalphanumerics}', ""); +Expect(0, 9311, '\P{^enclosedalphanumerics}', ""); +Expect(1, 9471, '\p{ Enclosed-alphanumerics}', ""); +Expect(0, 9471, '\p{^ Enclosed-alphanumerics}', ""); +Expect(0, 9471, '\P{ Enclosed-alphanumerics}', ""); +Expect(1, 9471, '\P{^ Enclosed-alphanumerics}', ""); +Expect(0, 9311, '\p{ Enclosed-alphanumerics}', ""); +Expect(1, 9311, '\p{^ Enclosed-alphanumerics}', ""); +Expect(1, 9311, '\P{ Enclosed-alphanumerics}', ""); +Expect(0, 9311, '\P{^ Enclosed-alphanumerics}', ""); +Error('\p{:= _is-enclosed-alphanumerics}'); +Error('\P{:= _is-enclosed-alphanumerics}'); +Expect(1, 9471, '\p{isenclosedalphanumerics}', ""); +Expect(0, 9471, '\p{^isenclosedalphanumerics}', ""); +Expect(0, 9471, '\P{isenclosedalphanumerics}', ""); +Expect(1, 9471, '\P{^isenclosedalphanumerics}', ""); +Expect(0, 9311, '\p{isenclosedalphanumerics}', ""); +Expect(1, 9311, '\p{^isenclosedalphanumerics}', ""); +Expect(1, 9311, '\P{isenclosedalphanumerics}', ""); +Expect(0, 9311, '\P{^isenclosedalphanumerics}', ""); +Expect(1, 9471, '\p{ Is_Enclosed_Alphanumerics}', ""); +Expect(0, 9471, '\p{^ Is_Enclosed_Alphanumerics}', ""); +Expect(0, 9471, '\P{ Is_Enclosed_Alphanumerics}', ""); +Expect(1, 9471, '\P{^ Is_Enclosed_Alphanumerics}', ""); +Expect(0, 9311, '\p{ Is_Enclosed_Alphanumerics}', ""); +Expect(1, 9311, '\p{^ Is_Enclosed_Alphanumerics}', ""); +Expect(1, 9311, '\P{ Is_Enclosed_Alphanumerics}', ""); +Expect(0, 9311, '\P{^ Is_Enclosed_Alphanumerics}', ""); +Error('\p{ :=InENCLOSED Alphanumerics}'); +Error('\P{ :=InENCLOSED Alphanumerics}'); +Expect(1, 9471, '\p{inenclosedalphanumerics}', ""); +Expect(0, 9471, '\p{^inenclosedalphanumerics}', ""); +Expect(0, 9471, '\P{inenclosedalphanumerics}', ""); +Expect(1, 9471, '\P{^inenclosedalphanumerics}', ""); +Expect(0, 9311, '\p{inenclosedalphanumerics}', ""); +Expect(1, 9311, '\p{^inenclosedalphanumerics}', ""); +Expect(1, 9311, '\P{inenclosedalphanumerics}', ""); +Expect(0, 9311, '\P{^inenclosedalphanumerics}', ""); +Expect(1, 9471, '\p{_-IN Enclosed Alphanumerics}', ""); +Expect(0, 9471, '\p{^_-IN Enclosed Alphanumerics}', ""); +Expect(0, 9471, '\P{_-IN Enclosed Alphanumerics}', ""); +Expect(1, 9471, '\P{^_-IN Enclosed Alphanumerics}', ""); +Expect(0, 9311, '\p{_-IN Enclosed Alphanumerics}', ""); +Expect(1, 9311, '\p{^_-IN Enclosed Alphanumerics}', ""); +Expect(1, 9311, '\P{_-IN Enclosed Alphanumerics}', ""); +Expect(0, 9311, '\P{^_-IN Enclosed Alphanumerics}', ""); +Error('\p{__Extender/a/}'); +Error('\P{__Extender/a/}'); +Expect(1, 721, '\p{extender}', ""); +Expect(0, 721, '\p{^extender}', ""); +Expect(0, 721, '\P{extender}', ""); +Expect(1, 721, '\P{^extender}', ""); +Expect(0, 7, '\p{extender}', ""); +Expect(1, 7, '\p{^extender}', ""); +Expect(1, 7, '\P{extender}', ""); +Expect(0, 7, '\P{^extender}', ""); +Expect(1, 721, '\p{_ Extender}', ""); +Expect(0, 721, '\p{^_ Extender}', ""); +Expect(0, 721, '\P{_ Extender}', ""); +Expect(1, 721, '\P{^_ Extender}', ""); +Expect(0, 7, '\p{_ Extender}', ""); +Expect(1, 7, '\p{^_ Extender}', ""); +Expect(1, 7, '\P{_ Extender}', ""); +Expect(0, 7, '\P{^_ Extender}', ""); +Error('\p{ /a/Is Extender}'); +Error('\P{ /a/Is Extender}'); +Expect(1, 721, '\p{isextender}', ""); +Expect(0, 721, '\p{^isextender}', ""); +Expect(0, 721, '\P{isextender}', ""); +Expect(1, 721, '\P{^isextender}', ""); +Expect(0, 7, '\p{isextender}', ""); +Expect(1, 7, '\p{^isextender}', ""); +Expect(1, 7, '\P{isextender}', ""); +Expect(0, 7, '\P{^isextender}', ""); +Expect(1, 721, '\p{is-EXTENDER}', ""); +Expect(0, 721, '\p{^is-EXTENDER}', ""); +Expect(0, 721, '\P{is-EXTENDER}', ""); +Expect(1, 721, '\P{^is-EXTENDER}', ""); +Expect(0, 7, '\p{is-EXTENDER}', ""); +Expect(1, 7, '\p{^is-EXTENDER}', ""); +Expect(1, 7, '\P{is-EXTENDER}', ""); +Expect(0, 7, '\P{^is-EXTENDER}', ""); +Error('\p{:=EXT}'); +Error('\P{:=EXT}'); +Expect(1, 721, '\p{ext}', ""); +Expect(0, 721, '\p{^ext}', ""); +Expect(0, 721, '\P{ext}', ""); +Expect(1, 721, '\P{^ext}', ""); +Expect(0, 7, '\p{ext}', ""); +Expect(1, 7, '\p{^ext}', ""); +Expect(1, 7, '\P{ext}', ""); +Expect(0, 7, '\P{^ext}', ""); +Expect(1, 721, '\p{_ Ext}', ""); +Expect(0, 721, '\p{^_ Ext}', ""); +Expect(0, 721, '\P{_ Ext}', ""); +Expect(1, 721, '\P{^_ Ext}', ""); +Expect(0, 7, '\p{_ Ext}', ""); +Expect(1, 7, '\p{^_ Ext}', ""); +Expect(1, 7, '\P{_ Ext}', ""); +Expect(0, 7, '\P{^_ Ext}', ""); +Error('\p{ is/a/ext}'); +Error('\P{ is/a/ext}'); +Expect(1, 721, '\p{isext}', ""); +Expect(0, 721, '\p{^isext}', ""); +Expect(0, 721, '\P{isext}', ""); +Expect(1, 721, '\P{^isext}', ""); +Expect(0, 7, '\p{isext}', ""); +Expect(1, 7, '\p{^isext}', ""); +Expect(1, 7, '\P{isext}', ""); +Expect(0, 7, '\P{^isext}', ""); +Expect(1, 721, '\p{ is_Ext}', ""); +Expect(0, 721, '\p{^ is_Ext}', ""); +Expect(0, 721, '\P{ is_Ext}', ""); +Expect(1, 721, '\P{^ is_Ext}', ""); +Expect(0, 7, '\p{ is_Ext}', ""); +Expect(1, 7, '\p{^ is_Ext}', ""); +Expect(1, 7, '\P{ is_Ext}', ""); +Expect(0, 7, '\P{^ is_Ext}', ""); +Error('\p{/a/-COMPOSITION exclusion}'); +Error('\P{/a/-COMPOSITION exclusion}'); +Expect(1, 2399, '\p{compositionexclusion}', ""); +Expect(0, 2399, '\p{^compositionexclusion}', ""); +Expect(0, 2399, '\P{compositionexclusion}', ""); +Expect(1, 2399, '\P{^compositionexclusion}', ""); +Expect(0, 2391, '\p{compositionexclusion}', ""); +Expect(1, 2391, '\p{^compositionexclusion}', ""); +Expect(1, 2391, '\P{compositionexclusion}', ""); +Expect(0, 2391, '\P{^compositionexclusion}', ""); +Expect(1, 2399, '\p{Composition exclusion}', ""); +Expect(0, 2399, '\p{^Composition exclusion}', ""); +Expect(0, 2399, '\P{Composition exclusion}', ""); +Expect(1, 2399, '\P{^Composition exclusion}', ""); +Expect(0, 2391, '\p{Composition exclusion}', ""); +Expect(1, 2391, '\p{^Composition exclusion}', ""); +Expect(1, 2391, '\P{Composition exclusion}', ""); +Expect(0, 2391, '\P{^Composition exclusion}', ""); +Error('\p{_/a/Is COMPOSITION exclusion}'); +Error('\P{_/a/Is COMPOSITION exclusion}'); +Expect(1, 2399, '\p{iscompositionexclusion}', ""); +Expect(0, 2399, '\p{^iscompositionexclusion}', ""); +Expect(0, 2399, '\P{iscompositionexclusion}', ""); +Expect(1, 2399, '\P{^iscompositionexclusion}', ""); +Expect(0, 2391, '\p{iscompositionexclusion}', ""); +Expect(1, 2391, '\p{^iscompositionexclusion}', ""); +Expect(1, 2391, '\P{iscompositionexclusion}', ""); +Expect(0, 2391, '\P{^iscompositionexclusion}', ""); +Expect(1, 2399, '\p{-_IsCOMPOSITION exclusion}', ""); +Expect(0, 2399, '\p{^-_IsCOMPOSITION exclusion}', ""); +Expect(0, 2399, '\P{-_IsCOMPOSITION exclusion}', ""); +Expect(1, 2399, '\P{^-_IsCOMPOSITION exclusion}', ""); +Expect(0, 2391, '\p{-_IsCOMPOSITION exclusion}', ""); +Expect(1, 2391, '\p{^-_IsCOMPOSITION exclusion}', ""); +Expect(1, 2391, '\P{-_IsCOMPOSITION exclusion}', ""); +Expect(0, 2391, '\P{^-_IsCOMPOSITION exclusion}', ""); +Error('\p{:=-_ce}'); +Error('\P{:=-_ce}'); +Expect(1, 2399, '\p{ce}', ""); +Expect(0, 2399, '\p{^ce}', ""); +Expect(0, 2399, '\P{ce}', ""); +Expect(1, 2399, '\P{^ce}', ""); +Expect(0, 2391, '\p{ce}', ""); +Expect(1, 2391, '\p{^ce}', ""); +Expect(1, 2391, '\P{ce}', ""); +Expect(0, 2391, '\P{^ce}', ""); +Expect(1, 2399, '\p{_CE}', ""); +Expect(0, 2399, '\p{^_CE}', ""); +Expect(0, 2399, '\P{_CE}', ""); +Expect(1, 2399, '\P{^_CE}', ""); +Expect(0, 2391, '\p{_CE}', ""); +Expect(1, 2391, '\p{^_CE}', ""); +Expect(1, 2391, '\P{_CE}', ""); +Expect(0, 2391, '\P{^_CE}', ""); +Error('\p{/a/ is-CE}'); +Error('\P{/a/ is-CE}'); +Expect(1, 2399, '\p{isce}', ""); +Expect(0, 2399, '\p{^isce}', ""); +Expect(0, 2399, '\P{isce}', ""); +Expect(1, 2399, '\P{^isce}', ""); +Expect(0, 2391, '\p{isce}', ""); +Expect(1, 2391, '\p{^isce}', ""); +Expect(1, 2391, '\P{isce}', ""); +Expect(0, 2391, '\P{^isce}', ""); +Expect(1, 2399, '\p{_-Is CE}', ""); +Expect(0, 2399, '\p{^_-Is CE}', ""); +Expect(0, 2399, '\P{_-Is CE}', ""); +Expect(1, 2399, '\P{^_-Is CE}', ""); +Expect(0, 2391, '\p{_-Is CE}', ""); +Expect(1, 2391, '\p{^_-Is CE}', ""); +Expect(1, 2391, '\P{_-Is CE}', ""); +Expect(0, 2391, '\P{^_-Is CE}', ""); +Error('\p{ :=Enclosed_CJK-Letters andMonths}'); +Error('\P{ :=Enclosed_CJK-Letters andMonths}'); +Expect(1, 13055, '\p{enclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\p{^enclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\P{enclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\P{^enclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\p{enclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\p{^enclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\P{enclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\P{^enclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\p{Enclosed CJK Letters And Months}', ""); +Expect(0, 13055, '\p{^Enclosed CJK Letters And Months}', ""); +Expect(0, 13055, '\P{Enclosed CJK Letters And Months}', ""); +Expect(1, 13055, '\P{^Enclosed CJK Letters And Months}', ""); +Expect(0, 12799, '\p{Enclosed CJK Letters And Months}', ""); +Expect(1, 12799, '\p{^Enclosed CJK Letters And Months}', ""); +Expect(1, 12799, '\P{Enclosed CJK Letters And Months}', ""); +Expect(0, 12799, '\P{^Enclosed CJK Letters And Months}', ""); +Error('\p{ Is EnclosedCJK:=letters ANDMonths}'); +Error('\P{ Is EnclosedCJK:=letters ANDMonths}'); +Expect(1, 13055, '\p{isenclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\p{^isenclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\P{isenclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\P{^isenclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\p{isenclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\p{^isenclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\P{isenclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\P{^isenclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\p{_-ISENCLOSED-CJK_letters And Months}', ""); +Expect(0, 13055, '\p{^_-ISENCLOSED-CJK_letters And Months}', ""); +Expect(0, 13055, '\P{_-ISENCLOSED-CJK_letters And Months}', ""); +Expect(1, 13055, '\P{^_-ISENCLOSED-CJK_letters And Months}', ""); +Expect(0, 12799, '\p{_-ISENCLOSED-CJK_letters And Months}', ""); +Expect(1, 12799, '\p{^_-ISENCLOSED-CJK_letters And Months}', ""); +Expect(1, 12799, '\P{_-ISENCLOSED-CJK_letters And Months}', ""); +Expect(0, 12799, '\P{^_-ISENCLOSED-CJK_letters And Months}', ""); +Error('\p{ in/a/enclosed_cjk Letters-And Months}'); +Error('\P{ in/a/enclosed_cjk Letters-And Months}'); +Expect(1, 13055, '\p{inenclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\p{^inenclosedcjklettersandmonths}', ""); +Expect(0, 13055, '\P{inenclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\P{^inenclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\p{inenclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\p{^inenclosedcjklettersandmonths}', ""); +Expect(1, 12799, '\P{inenclosedcjklettersandmonths}', ""); +Expect(0, 12799, '\P{^inenclosedcjklettersandmonths}', ""); +Expect(1, 13055, '\p{-_In-Enclosed_cjk_Letters and_Months}', ""); +Expect(0, 13055, '\p{^-_In-Enclosed_cjk_Letters and_Months}', ""); +Expect(0, 13055, '\P{-_In-Enclosed_cjk_Letters and_Months}', ""); +Expect(1, 13055, '\P{^-_In-Enclosed_cjk_Letters and_Months}', ""); +Expect(0, 12799, '\p{-_In-Enclosed_cjk_Letters and_Months}', ""); +Expect(1, 12799, '\p{^-_In-Enclosed_cjk_Letters and_Months}', ""); +Expect(1, 12799, '\P{-_In-Enclosed_cjk_Letters and_Months}', ""); +Expect(0, 12799, '\P{^-_In-Enclosed_cjk_Letters and_Months}', ""); +Error('\p{-/a/space Separator}'); +Error('\P{-/a/space Separator}'); +Expect(1, 32, '\p{spaceseparator}', ""); +Expect(0, 32, '\p{^spaceseparator}', ""); +Expect(0, 32, '\P{spaceseparator}', ""); +Expect(1, 32, '\P{^spaceseparator}', ""); +Expect(0, 7, '\p{spaceseparator}', ""); +Expect(1, 7, '\p{^spaceseparator}', ""); +Expect(1, 7, '\P{spaceseparator}', ""); +Expect(0, 7, '\P{^spaceseparator}', ""); +Expect(1, 32, '\p{- spaceSeparator}', ""); +Expect(0, 32, '\p{^- spaceSeparator}', ""); +Expect(0, 32, '\P{- spaceSeparator}', ""); +Expect(1, 32, '\P{^- spaceSeparator}', ""); +Expect(0, 7, '\p{- spaceSeparator}', ""); +Expect(1, 7, '\p{^- spaceSeparator}', ""); +Expect(1, 7, '\P{- spaceSeparator}', ""); +Expect(0, 7, '\P{^- spaceSeparator}', ""); +Error('\p{/a/- Isspace-separator}'); +Error('\P{/a/- Isspace-separator}'); +Expect(1, 32, '\p{isspaceseparator}', ""); +Expect(0, 32, '\p{^isspaceseparator}', ""); +Expect(0, 32, '\P{isspaceseparator}', ""); +Expect(1, 32, '\P{^isspaceseparator}', ""); +Expect(0, 7, '\p{isspaceseparator}', ""); +Expect(1, 7, '\p{^isspaceseparator}', ""); +Expect(1, 7, '\P{isspaceseparator}', ""); +Expect(0, 7, '\P{^isspaceseparator}', ""); +Expect(1, 32, '\p{_ IS SPACE_SEPARATOR}', ""); +Expect(0, 32, '\p{^_ IS SPACE_SEPARATOR}', ""); +Expect(0, 32, '\P{_ IS SPACE_SEPARATOR}', ""); +Expect(1, 32, '\P{^_ IS SPACE_SEPARATOR}', ""); +Expect(0, 7, '\p{_ IS SPACE_SEPARATOR}', ""); +Expect(1, 7, '\p{^_ IS SPACE_SEPARATOR}', ""); +Expect(1, 7, '\P{_ IS SPACE_SEPARATOR}', ""); +Expect(0, 7, '\P{^_ IS SPACE_SEPARATOR}', ""); +Error('\p{_-Zs:=}'); +Error('\P{_-Zs:=}'); +Expect(1, 32, '\p{zs}', ""); +Expect(0, 32, '\p{^zs}', ""); +Expect(0, 32, '\P{zs}', ""); +Expect(1, 32, '\P{^zs}', ""); +Expect(0, 7, '\p{zs}', ""); +Expect(1, 7, '\p{^zs}', ""); +Expect(1, 7, '\P{zs}', ""); +Expect(0, 7, '\P{^zs}', ""); +Expect(1, 32, '\p{ -Zs}', ""); +Expect(0, 32, '\p{^ -Zs}', ""); +Expect(0, 32, '\P{ -Zs}', ""); +Expect(1, 32, '\P{^ -Zs}', ""); +Expect(0, 7, '\p{ -Zs}', ""); +Expect(1, 7, '\p{^ -Zs}', ""); +Expect(1, 7, '\P{ -Zs}', ""); +Expect(0, 7, '\P{^ -Zs}', ""); +Error('\p{-/a/Is-ZS}'); +Error('\P{-/a/Is-ZS}'); +Expect(1, 32, '\p{iszs}', ""); +Expect(0, 32, '\p{^iszs}', ""); +Expect(0, 32, '\P{iszs}', ""); +Expect(1, 32, '\P{^iszs}', ""); +Expect(0, 7, '\p{iszs}', ""); +Expect(1, 7, '\p{^iszs}', ""); +Expect(1, 7, '\P{iszs}', ""); +Expect(0, 7, '\P{^iszs}', ""); +Expect(1, 32, '\p{- Is Zs}', ""); +Expect(0, 32, '\p{^- Is Zs}', ""); +Expect(0, 32, '\P{- Is Zs}', ""); +Expect(1, 32, '\P{^- Is Zs}', ""); +Expect(0, 7, '\p{- Is Zs}', ""); +Expect(1, 7, '\p{^- Is Zs}', ""); +Expect(1, 7, '\P{- Is Zs}', ""); +Expect(0, 7, '\P{^- Is Zs}', ""); +Error('\p{- Supplemental-PUNCTUATION:=}'); +Error('\P{- Supplemental-PUNCTUATION:=}'); +Expect(1, 11903, '\p{supplementalpunctuation}', ""); +Expect(0, 11903, '\p{^supplementalpunctuation}', ""); +Expect(0, 11903, '\P{supplementalpunctuation}', ""); +Expect(1, 11903, '\P{^supplementalpunctuation}', ""); +Expect(0, 11775, '\p{supplementalpunctuation}', ""); +Expect(1, 11775, '\p{^supplementalpunctuation}', ""); +Expect(1, 11775, '\P{supplementalpunctuation}', ""); +Expect(0, 11775, '\P{^supplementalpunctuation}', ""); +Expect(1, 11903, '\p{_Supplemental punctuation}', ""); +Expect(0, 11903, '\p{^_Supplemental punctuation}', ""); +Expect(0, 11903, '\P{_Supplemental punctuation}', ""); +Expect(1, 11903, '\P{^_Supplemental punctuation}', ""); +Expect(0, 11775, '\p{_Supplemental punctuation}', ""); +Expect(1, 11775, '\p{^_Supplemental punctuation}', ""); +Expect(1, 11775, '\P{_Supplemental punctuation}', ""); +Expect(0, 11775, '\P{^_Supplemental punctuation}', ""); +Error('\p{:= -IS-SUPPLEMENTAL-punctuation}'); +Error('\P{:= -IS-SUPPLEMENTAL-punctuation}'); +Expect(1, 11903, '\p{issupplementalpunctuation}', ""); +Expect(0, 11903, '\p{^issupplementalpunctuation}', ""); +Expect(0, 11903, '\P{issupplementalpunctuation}', ""); +Expect(1, 11903, '\P{^issupplementalpunctuation}', ""); +Expect(0, 11775, '\p{issupplementalpunctuation}', ""); +Expect(1, 11775, '\p{^issupplementalpunctuation}', ""); +Expect(1, 11775, '\P{issupplementalpunctuation}', ""); +Expect(0, 11775, '\P{^issupplementalpunctuation}', ""); +Expect(1, 11903, '\p{ -Is Supplemental PUNCTUATION}', ""); +Expect(0, 11903, '\p{^ -Is Supplemental PUNCTUATION}', ""); +Expect(0, 11903, '\P{ -Is Supplemental PUNCTUATION}', ""); +Expect(1, 11903, '\P{^ -Is Supplemental PUNCTUATION}', ""); +Expect(0, 11775, '\p{ -Is Supplemental PUNCTUATION}', ""); +Expect(1, 11775, '\p{^ -Is Supplemental PUNCTUATION}', ""); +Expect(1, 11775, '\P{ -Is Supplemental PUNCTUATION}', ""); +Expect(0, 11775, '\P{^ -Is Supplemental PUNCTUATION}', ""); +Error('\p{/a/IN Supplemental_Punctuation}'); +Error('\P{/a/IN Supplemental_Punctuation}'); +Expect(1, 11903, '\p{insupplementalpunctuation}', ""); +Expect(0, 11903, '\p{^insupplementalpunctuation}', ""); +Expect(0, 11903, '\P{insupplementalpunctuation}', ""); +Expect(1, 11903, '\P{^insupplementalpunctuation}', ""); +Expect(0, 11775, '\p{insupplementalpunctuation}', ""); +Expect(1, 11775, '\p{^insupplementalpunctuation}', ""); +Expect(1, 11775, '\P{insupplementalpunctuation}', ""); +Expect(0, 11775, '\P{^insupplementalpunctuation}', ""); +Expect(1, 11903, '\p{_In supplemental-punctuation}', ""); +Expect(0, 11903, '\p{^_In supplemental-punctuation}', ""); +Expect(0, 11903, '\P{_In supplemental-punctuation}', ""); +Expect(1, 11903, '\P{^_In supplemental-punctuation}', ""); +Expect(0, 11775, '\p{_In supplemental-punctuation}', ""); +Expect(1, 11775, '\p{^_In supplemental-punctuation}', ""); +Expect(1, 11775, '\P{_In supplemental-punctuation}', ""); +Expect(0, 11775, '\P{^_In supplemental-punctuation}', ""); +Error('\p{:=Katakana PhoneticEXTENSIONS}'); +Error('\P{:=Katakana PhoneticEXTENSIONS}'); +Expect(1, 12799, '\p{katakanaphoneticextensions}', ""); +Expect(0, 12799, '\p{^katakanaphoneticextensions}', ""); +Expect(0, 12799, '\P{katakanaphoneticextensions}', ""); +Expect(1, 12799, '\P{^katakanaphoneticextensions}', ""); +Expect(0, 12783, '\p{katakanaphoneticextensions}', ""); +Expect(1, 12783, '\p{^katakanaphoneticextensions}', ""); +Expect(1, 12783, '\P{katakanaphoneticextensions}', ""); +Expect(0, 12783, '\P{^katakanaphoneticextensions}', ""); +Expect(1, 12799, '\p{ KATAKANA phoneticExtensions}', ""); +Expect(0, 12799, '\p{^ KATAKANA phoneticExtensions}', ""); +Expect(0, 12799, '\P{ KATAKANA phoneticExtensions}', ""); +Expect(1, 12799, '\P{^ KATAKANA phoneticExtensions}', ""); +Expect(0, 12783, '\p{ KATAKANA phoneticExtensions}', ""); +Expect(1, 12783, '\p{^ KATAKANA phoneticExtensions}', ""); +Expect(1, 12783, '\P{ KATAKANA phoneticExtensions}', ""); +Expect(0, 12783, '\P{^ KATAKANA phoneticExtensions}', ""); +Error('\p{--IS/a/KATAKANA Phonetic EXTENSIONS}'); +Error('\P{--IS/a/KATAKANA Phonetic EXTENSIONS}'); +Expect(1, 12799, '\p{iskatakanaphoneticextensions}', ""); +Expect(0, 12799, '\p{^iskatakanaphoneticextensions}', ""); +Expect(0, 12799, '\P{iskatakanaphoneticextensions}', ""); +Expect(1, 12799, '\P{^iskatakanaphoneticextensions}', ""); +Expect(0, 12783, '\p{iskatakanaphoneticextensions}', ""); +Expect(1, 12783, '\p{^iskatakanaphoneticextensions}', ""); +Expect(1, 12783, '\P{iskatakanaphoneticextensions}', ""); +Expect(0, 12783, '\P{^iskatakanaphoneticextensions}', ""); +Expect(1, 12799, '\p{ Is-Katakana PHONETIC-Extensions}', ""); +Expect(0, 12799, '\p{^ Is-Katakana PHONETIC-Extensions}', ""); +Expect(0, 12799, '\P{ Is-Katakana PHONETIC-Extensions}', ""); +Expect(1, 12799, '\P{^ Is-Katakana PHONETIC-Extensions}', ""); +Expect(0, 12783, '\p{ Is-Katakana PHONETIC-Extensions}', ""); +Expect(1, 12783, '\p{^ Is-Katakana PHONETIC-Extensions}', ""); +Expect(1, 12783, '\P{ Is-Katakana PHONETIC-Extensions}', ""); +Expect(0, 12783, '\P{^ Is-Katakana PHONETIC-Extensions}', ""); +Error('\p{ IN_KATAKANA_Phonetic_extensions/a/}'); +Error('\P{ IN_KATAKANA_Phonetic_extensions/a/}'); +Expect(1, 12799, '\p{inkatakanaphoneticextensions}', ""); +Expect(0, 12799, '\p{^inkatakanaphoneticextensions}', ""); +Expect(0, 12799, '\P{inkatakanaphoneticextensions}', ""); +Expect(1, 12799, '\P{^inkatakanaphoneticextensions}', ""); +Expect(0, 12783, '\p{inkatakanaphoneticextensions}', ""); +Expect(1, 12783, '\p{^inkatakanaphoneticextensions}', ""); +Expect(1, 12783, '\P{inkatakanaphoneticextensions}', ""); +Expect(0, 12783, '\P{^inkatakanaphoneticextensions}', ""); +Expect(1, 12799, '\p{_InKATAKANA_phoneticEXTENSIONS}', ""); +Expect(0, 12799, '\p{^_InKATAKANA_phoneticEXTENSIONS}', ""); +Expect(0, 12799, '\P{_InKATAKANA_phoneticEXTENSIONS}', ""); +Expect(1, 12799, '\P{^_InKATAKANA_phoneticEXTENSIONS}', ""); +Expect(0, 12783, '\p{_InKATAKANA_phoneticEXTENSIONS}', ""); +Expect(1, 12783, '\p{^_InKATAKANA_phoneticEXTENSIONS}', ""); +Expect(1, 12783, '\P{_InKATAKANA_phoneticEXTENSIONS}', ""); +Expect(0, 12783, '\P{^_InKATAKANA_phoneticEXTENSIONS}', ""); +Error('\p{_:=Modifier-symbol}'); +Error('\P{_:=Modifier-symbol}'); +Expect(1, 94, '\p{modifiersymbol}', ""); +Expect(0, 94, '\p{^modifiersymbol}', ""); +Expect(0, 94, '\P{modifiersymbol}', ""); +Expect(1, 94, '\P{^modifiersymbol}', ""); +Expect(0, 93, '\p{modifiersymbol}', ""); +Expect(1, 93, '\p{^modifiersymbol}', ""); +Expect(1, 93, '\P{modifiersymbol}', ""); +Expect(0, 93, '\P{^modifiersymbol}', ""); +Expect(1, 94, '\p{ -Modifier_symbol}', ""); +Expect(0, 94, '\p{^ -Modifier_symbol}', ""); +Expect(0, 94, '\P{ -Modifier_symbol}', ""); +Expect(1, 94, '\P{^ -Modifier_symbol}', ""); +Expect(0, 93, '\p{ -Modifier_symbol}', ""); +Expect(1, 93, '\p{^ -Modifier_symbol}', ""); +Expect(1, 93, '\P{ -Modifier_symbol}', ""); +Expect(0, 93, '\P{^ -Modifier_symbol}', ""); +Error('\p{ -is-Modifier/a/SYMBOL}'); +Error('\P{ -is-Modifier/a/SYMBOL}'); +Expect(1, 94, '\p{ismodifiersymbol}', ""); +Expect(0, 94, '\p{^ismodifiersymbol}', ""); +Expect(0, 94, '\P{ismodifiersymbol}', ""); +Expect(1, 94, '\P{^ismodifiersymbol}', ""); +Expect(0, 93, '\p{ismodifiersymbol}', ""); +Expect(1, 93, '\p{^ismodifiersymbol}', ""); +Expect(1, 93, '\P{ismodifiersymbol}', ""); +Expect(0, 93, '\P{^ismodifiersymbol}', ""); +Expect(1, 94, '\p{--is-Modifier Symbol}', ""); +Expect(0, 94, '\p{^--is-Modifier Symbol}', ""); +Expect(0, 94, '\P{--is-Modifier Symbol}', ""); +Expect(1, 94, '\P{^--is-Modifier Symbol}', ""); +Expect(0, 93, '\p{--is-Modifier Symbol}', ""); +Expect(1, 93, '\p{^--is-Modifier Symbol}', ""); +Expect(1, 93, '\P{--is-Modifier Symbol}', ""); +Expect(0, 93, '\P{^--is-Modifier Symbol}', ""); +Error('\p{--Sk:=}'); +Error('\P{--Sk:=}'); +Expect(1, 94, '\p{sk}', ""); +Expect(0, 94, '\p{^sk}', ""); +Expect(0, 94, '\P{sk}', ""); +Expect(1, 94, '\P{^sk}', ""); +Expect(0, 93, '\p{sk}', ""); +Expect(1, 93, '\p{^sk}', ""); +Expect(1, 93, '\P{sk}', ""); +Expect(0, 93, '\P{^sk}', ""); +Expect(1, 94, '\p{ Sk}', ""); +Expect(0, 94, '\p{^ Sk}', ""); +Expect(0, 94, '\P{ Sk}', ""); +Expect(1, 94, '\P{^ Sk}', ""); +Expect(0, 93, '\p{ Sk}', ""); +Expect(1, 93, '\p{^ Sk}', ""); +Expect(1, 93, '\P{ Sk}', ""); +Expect(0, 93, '\P{^ Sk}', ""); +Error('\p{ IS:=sk}'); +Error('\P{ IS:=sk}'); +Expect(1, 94, '\p{issk}', ""); +Expect(0, 94, '\p{^issk}', ""); +Expect(0, 94, '\P{issk}', ""); +Expect(1, 94, '\P{^issk}', ""); +Expect(0, 93, '\p{issk}', ""); +Expect(1, 93, '\p{^issk}', ""); +Expect(1, 93, '\P{issk}', ""); +Expect(0, 93, '\P{^issk}', ""); +Expect(1, 94, '\p{ Is-Sk}', ""); +Expect(0, 94, '\p{^ Is-Sk}', ""); +Expect(0, 94, '\P{ Is-Sk}', ""); +Expect(1, 94, '\P{^ Is-Sk}', ""); +Expect(0, 93, '\p{ Is-Sk}', ""); +Expect(1, 93, '\p{^ Is-Sk}', ""); +Expect(1, 93, '\P{ Is-Sk}', ""); +Expect(0, 93, '\P{^ Is-Sk}', ""); +Error('\p{/a/__Armenian}'); +Error('\P{/a/__Armenian}'); +Expect(1, 1366, '\p{armenian}', ""); +Expect(0, 1366, '\p{^armenian}', ""); +Expect(0, 1366, '\P{armenian}', ""); +Expect(1, 1366, '\P{^armenian}', ""); +Expect(0, 1328, '\p{armenian}', ""); +Expect(1, 1328, '\p{^armenian}', ""); +Expect(1, 1328, '\P{armenian}', ""); +Expect(0, 1328, '\P{^armenian}', ""); +Expect(1, 1366, '\p{_ARMENIAN}', ""); +Expect(0, 1366, '\p{^_ARMENIAN}', ""); +Expect(0, 1366, '\P{_ARMENIAN}', ""); +Expect(1, 1366, '\P{^_ARMENIAN}', ""); +Expect(0, 1328, '\p{_ARMENIAN}', ""); +Expect(1, 1328, '\p{^_ARMENIAN}', ""); +Expect(1, 1328, '\P{_ARMENIAN}', ""); +Expect(0, 1328, '\P{^_ARMENIAN}', ""); +Error('\p{--Is_ARMENIAN/a/}'); +Error('\P{--Is_ARMENIAN/a/}'); +Expect(1, 1366, '\p{isarmenian}', ""); +Expect(0, 1366, '\p{^isarmenian}', ""); +Expect(0, 1366, '\P{isarmenian}', ""); +Expect(1, 1366, '\P{^isarmenian}', ""); +Expect(0, 1328, '\p{isarmenian}', ""); +Expect(1, 1328, '\p{^isarmenian}', ""); +Expect(1, 1328, '\P{isarmenian}', ""); +Expect(0, 1328, '\P{^isarmenian}', ""); +Expect(1, 1366, '\p{ Is_ARMENIAN}', ""); +Expect(0, 1366, '\p{^ Is_ARMENIAN}', ""); +Expect(0, 1366, '\P{ Is_ARMENIAN}', ""); +Expect(1, 1366, '\P{^ Is_ARMENIAN}', ""); +Expect(0, 1328, '\p{ Is_ARMENIAN}', ""); +Expect(1, 1328, '\p{^ Is_ARMENIAN}', ""); +Expect(1, 1328, '\P{ Is_ARMENIAN}', ""); +Expect(0, 1328, '\P{^ Is_ARMENIAN}', ""); +Error('\p{:=Armn}'); +Error('\P{:=Armn}'); +Expect(1, 1366, '\p{armn}', ""); +Expect(0, 1366, '\p{^armn}', ""); +Expect(0, 1366, '\P{armn}', ""); +Expect(1, 1366, '\P{^armn}', ""); +Expect(0, 1328, '\p{armn}', ""); +Expect(1, 1328, '\p{^armn}', ""); +Expect(1, 1328, '\P{armn}', ""); +Expect(0, 1328, '\P{^armn}', ""); +Expect(1, 1366, '\p{_ Armn}', ""); +Expect(0, 1366, '\p{^_ Armn}', ""); +Expect(0, 1366, '\P{_ Armn}', ""); +Expect(1, 1366, '\P{^_ Armn}', ""); +Expect(0, 1328, '\p{_ Armn}', ""); +Expect(1, 1328, '\p{^_ Armn}', ""); +Expect(1, 1328, '\P{_ Armn}', ""); +Expect(0, 1328, '\P{^_ Armn}', ""); +Error('\p{/a/ isARMN}'); +Error('\P{/a/ isARMN}'); +Expect(1, 1366, '\p{isarmn}', ""); +Expect(0, 1366, '\p{^isarmn}', ""); +Expect(0, 1366, '\P{isarmn}', ""); +Expect(1, 1366, '\P{^isarmn}', ""); +Expect(0, 1328, '\p{isarmn}', ""); +Expect(1, 1328, '\p{^isarmn}', ""); +Expect(1, 1328, '\P{isarmn}', ""); +Expect(0, 1328, '\P{^isarmn}', ""); +Expect(1, 1366, '\p{ Isarmn}', ""); +Expect(0, 1366, '\p{^ Isarmn}', ""); +Expect(0, 1366, '\P{ Isarmn}', ""); +Expect(1, 1366, '\P{^ Isarmn}', ""); +Expect(0, 1328, '\p{ Isarmn}', ""); +Expect(1, 1328, '\p{^ Isarmn}', ""); +Expect(1, 1328, '\P{ Isarmn}', ""); +Expect(0, 1328, '\P{^ Isarmn}', ""); +Error('\p{:= XID continue}'); +Error('\P{:= XID continue}'); +Expect(1, 57, '\p{xidcontinue}', ""); +Expect(0, 57, '\p{^xidcontinue}', ""); +Expect(0, 57, '\P{xidcontinue}', ""); +Expect(1, 57, '\P{^xidcontinue}', ""); +Expect(0, 47, '\p{xidcontinue}', ""); +Expect(1, 47, '\p{^xidcontinue}', ""); +Expect(1, 47, '\P{xidcontinue}', ""); +Expect(0, 47, '\P{^xidcontinue}', ""); +Expect(1, 57, '\p{_XID Continue}', ""); +Expect(0, 57, '\p{^_XID Continue}', ""); +Expect(0, 57, '\P{_XID Continue}', ""); +Expect(1, 57, '\P{^_XID Continue}', ""); +Expect(0, 47, '\p{_XID Continue}', ""); +Expect(1, 47, '\p{^_XID Continue}', ""); +Expect(1, 47, '\P{_XID Continue}', ""); +Expect(0, 47, '\P{^_XID Continue}', ""); +Error('\p{ /a/Is xid-continue}'); +Error('\P{ /a/Is xid-continue}'); +Expect(1, 57, '\p{isxidcontinue}', ""); +Expect(0, 57, '\p{^isxidcontinue}', ""); +Expect(0, 57, '\P{isxidcontinue}', ""); +Expect(1, 57, '\P{^isxidcontinue}', ""); +Expect(0, 47, '\p{isxidcontinue}', ""); +Expect(1, 47, '\p{^isxidcontinue}', ""); +Expect(1, 47, '\P{isxidcontinue}', ""); +Expect(0, 47, '\P{^isxidcontinue}', ""); +Expect(1, 57, '\p{-_is_XID_Continue}', ""); +Expect(0, 57, '\p{^-_is_XID_Continue}', ""); +Expect(0, 57, '\P{-_is_XID_Continue}', ""); +Expect(1, 57, '\P{^-_is_XID_Continue}', ""); +Expect(0, 47, '\p{-_is_XID_Continue}', ""); +Expect(1, 47, '\p{^-_is_XID_Continue}', ""); +Expect(1, 47, '\P{-_is_XID_Continue}', ""); +Expect(0, 47, '\P{^-_is_XID_Continue}', ""); +Error('\p{_-xidc:=}'); +Error('\P{_-xidc:=}'); +Expect(1, 57, '\p{xidc}', ""); +Expect(0, 57, '\p{^xidc}', ""); +Expect(0, 57, '\P{xidc}', ""); +Expect(1, 57, '\P{^xidc}', ""); +Expect(0, 47, '\p{xidc}', ""); +Expect(1, 47, '\p{^xidc}', ""); +Expect(1, 47, '\P{xidc}', ""); +Expect(0, 47, '\P{^xidc}', ""); +Expect(1, 57, '\p{_ XIDC}', ""); +Expect(0, 57, '\p{^_ XIDC}', ""); +Expect(0, 57, '\P{_ XIDC}', ""); +Expect(1, 57, '\P{^_ XIDC}', ""); +Expect(0, 47, '\p{_ XIDC}', ""); +Expect(1, 47, '\p{^_ XIDC}', ""); +Expect(1, 47, '\P{_ XIDC}', ""); +Expect(0, 47, '\P{^_ XIDC}', ""); +Error('\p{-:=is_XIDC}'); +Error('\P{-:=is_XIDC}'); +Expect(1, 57, '\p{isxidc}', ""); +Expect(0, 57, '\p{^isxidc}', ""); +Expect(0, 57, '\P{isxidc}', ""); +Expect(1, 57, '\P{^isxidc}', ""); +Expect(0, 47, '\p{isxidc}', ""); +Expect(1, 47, '\p{^isxidc}', ""); +Expect(1, 47, '\P{isxidc}', ""); +Expect(0, 47, '\P{^isxidc}', ""); +Expect(1, 57, '\p{ IS-XIDC}', ""); +Expect(0, 57, '\p{^ IS-XIDC}', ""); +Expect(0, 57, '\P{ IS-XIDC}', ""); +Expect(1, 57, '\P{^ IS-XIDC}', ""); +Expect(0, 47, '\p{ IS-XIDC}', ""); +Expect(1, 47, '\p{^ IS-XIDC}', ""); +Expect(1, 47, '\P{ IS-XIDC}', ""); +Expect(0, 47, '\P{^ IS-XIDC}', ""); +Error('\p{ _Hyphen/a/}'); +Error('\P{ _Hyphen/a/}'); +Expect(1, 45, '\p{hyphen}', ""); +Expect(0, 45, '\p{^hyphen}', ""); +Expect(0, 45, '\P{hyphen}', ""); +Expect(1, 45, '\P{^hyphen}', ""); +Expect(0, 44, '\p{hyphen}', ""); +Expect(1, 44, '\p{^hyphen}', ""); +Expect(1, 44, '\P{hyphen}', ""); +Expect(0, 44, '\P{^hyphen}', ""); +Expect(1, 45, '\p{ hyphen}', ""); +Expect(0, 45, '\p{^ hyphen}', ""); +Expect(0, 45, '\P{ hyphen}', ""); +Expect(1, 45, '\P{^ hyphen}', ""); +Expect(0, 44, '\p{ hyphen}', ""); +Expect(1, 44, '\p{^ hyphen}', ""); +Expect(1, 44, '\P{ hyphen}', ""); +Expect(0, 44, '\P{^ hyphen}', ""); +Error('\p{/a/ -Is_Hyphen}'); +Error('\P{/a/ -Is_Hyphen}'); +Expect(1, 45, '\p{ishyphen}', ""); +Expect(0, 45, '\p{^ishyphen}', ""); +Expect(0, 45, '\P{ishyphen}', ""); +Expect(1, 45, '\P{^ishyphen}', ""); +Expect(0, 44, '\p{ishyphen}', ""); +Expect(1, 44, '\p{^ishyphen}', ""); +Expect(1, 44, '\P{ishyphen}', ""); +Expect(0, 44, '\P{^ishyphen}', ""); +Expect(1, 45, '\p{_ is HYPHEN}', ""); +Expect(0, 45, '\p{^_ is HYPHEN}', ""); +Expect(0, 45, '\P{_ is HYPHEN}', ""); +Expect(1, 45, '\P{^_ is HYPHEN}', ""); +Expect(0, 44, '\p{_ is HYPHEN}', ""); +Expect(1, 44, '\p{^_ is HYPHEN}', ""); +Expect(1, 44, '\P{_ is HYPHEN}', ""); +Expect(0, 44, '\P{^_ is HYPHEN}', ""); +Error('\p{ -Unified Canadian/a/Aboriginal-Syllabics}'); +Error('\P{ -Unified Canadian/a/Aboriginal-Syllabics}'); +Expect(1, 5759, '\p{unifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5759, '\p{^unifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5759, '\P{unifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5759, '\P{^unifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5119, '\p{unifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5119, '\p{^unifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5119, '\P{unifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5119, '\P{^unifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5759, '\p{_ UNIFIED_Canadian-ABORIGINAL-SYLLABICS}', ""); +Expect(0, 5759, '\p{^_ UNIFIED_Canadian-ABORIGINAL-SYLLABICS}', ""); +Expect(0, 5759, '\P{_ UNIFIED_Canadian-ABORIGINAL-SYLLABICS}', ""); +Expect(1, 5759, '\P{^_ UNIFIED_Canadian-ABORIGINAL-SYLLABICS}', ""); +Expect(0, 5119, '\p{_ UNIFIED_Canadian-ABORIGINAL-SYLLABICS}', ""); +Expect(1, 5119, '\p{^_ UNIFIED_Canadian-ABORIGINAL-SYLLABICS}', ""); +Expect(1, 5119, '\P{_ UNIFIED_Canadian-ABORIGINAL-SYLLABICS}', ""); +Expect(0, 5119, '\P{^_ UNIFIED_Canadian-ABORIGINAL-SYLLABICS}', ""); +Error('\p{ :=Is_unified canadian Aboriginalsyllabics}'); +Error('\P{ :=Is_unified canadian Aboriginalsyllabics}'); +Expect(1, 5759, '\p{isunifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5759, '\p{^isunifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5759, '\P{isunifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5759, '\P{^isunifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5119, '\p{isunifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5119, '\p{^isunifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5119, '\P{isunifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5119, '\P{^isunifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5759, '\p{-Is Unified CANADIAN ABORIGINAL Syllabics}', ""); +Expect(0, 5759, '\p{^-Is Unified CANADIAN ABORIGINAL Syllabics}', ""); +Expect(0, 5759, '\P{-Is Unified CANADIAN ABORIGINAL Syllabics}', ""); +Expect(1, 5759, '\P{^-Is Unified CANADIAN ABORIGINAL Syllabics}', ""); +Expect(0, 5119, '\p{-Is Unified CANADIAN ABORIGINAL Syllabics}', ""); +Expect(1, 5119, '\p{^-Is Unified CANADIAN ABORIGINAL Syllabics}', ""); +Expect(1, 5119, '\P{-Is Unified CANADIAN ABORIGINAL Syllabics}', ""); +Expect(0, 5119, '\P{^-Is Unified CANADIAN ABORIGINAL Syllabics}', ""); +Error('\p{ IN UNIFIED:=canadian AboriginalSyllabics}'); +Error('\P{ IN UNIFIED:=canadian AboriginalSyllabics}'); +Expect(1, 5759, '\p{inunifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5759, '\p{^inunifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5759, '\P{inunifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5759, '\P{^inunifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5119, '\p{inunifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5119, '\p{^inunifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5119, '\P{inunifiedcanadianaboriginalsyllabics}', ""); +Expect(0, 5119, '\P{^inunifiedcanadianaboriginalsyllabics}', ""); +Expect(1, 5759, '\p{ -IN Unified canadian_Aboriginal-SYLLABICS}', ""); +Expect(0, 5759, '\p{^ -IN Unified canadian_Aboriginal-SYLLABICS}', ""); +Expect(0, 5759, '\P{ -IN Unified canadian_Aboriginal-SYLLABICS}', ""); +Expect(1, 5759, '\P{^ -IN Unified canadian_Aboriginal-SYLLABICS}', ""); +Expect(0, 5119, '\p{ -IN Unified canadian_Aboriginal-SYLLABICS}', ""); +Expect(1, 5119, '\p{^ -IN Unified canadian_Aboriginal-SYLLABICS}', ""); +Expect(1, 5119, '\P{ -IN Unified canadian_Aboriginal-SYLLABICS}', ""); +Expect(0, 5119, '\P{^ -IN Unified canadian_Aboriginal-SYLLABICS}', ""); +Error('\p{-_Canadian-Syllabics:=}'); +Error('\P{-_Canadian-Syllabics:=}'); +Expect(1, 5759, '\p{canadiansyllabics}', ""); +Expect(0, 5759, '\p{^canadiansyllabics}', ""); +Expect(0, 5759, '\P{canadiansyllabics}', ""); +Expect(1, 5759, '\P{^canadiansyllabics}', ""); +Expect(0, 5119, '\p{canadiansyllabics}', ""); +Expect(1, 5119, '\p{^canadiansyllabics}', ""); +Expect(1, 5119, '\P{canadiansyllabics}', ""); +Expect(0, 5119, '\P{^canadiansyllabics}', ""); +Expect(1, 5759, '\p{ _Canadian Syllabics}', ""); +Expect(0, 5759, '\p{^ _Canadian Syllabics}', ""); +Expect(0, 5759, '\P{ _Canadian Syllabics}', ""); +Expect(1, 5759, '\P{^ _Canadian Syllabics}', ""); +Expect(0, 5119, '\p{ _Canadian Syllabics}', ""); +Expect(1, 5119, '\p{^ _Canadian Syllabics}', ""); +Expect(1, 5119, '\P{ _Canadian Syllabics}', ""); +Expect(0, 5119, '\P{^ _Canadian Syllabics}', ""); +Error('\p{/a/Is Canadian Syllabics}'); +Error('\P{/a/Is Canadian Syllabics}'); +Expect(1, 5759, '\p{iscanadiansyllabics}', ""); +Expect(0, 5759, '\p{^iscanadiansyllabics}', ""); +Expect(0, 5759, '\P{iscanadiansyllabics}', ""); +Expect(1, 5759, '\P{^iscanadiansyllabics}', ""); +Expect(0, 5119, '\p{iscanadiansyllabics}', ""); +Expect(1, 5119, '\p{^iscanadiansyllabics}', ""); +Expect(1, 5119, '\P{iscanadiansyllabics}', ""); +Expect(0, 5119, '\P{^iscanadiansyllabics}', ""); +Expect(1, 5759, '\p{_-Is Canadian SYLLABICS}', ""); +Expect(0, 5759, '\p{^_-Is Canadian SYLLABICS}', ""); +Expect(0, 5759, '\P{_-Is Canadian SYLLABICS}', ""); +Expect(1, 5759, '\P{^_-Is Canadian SYLLABICS}', ""); +Expect(0, 5119, '\p{_-Is Canadian SYLLABICS}', ""); +Expect(1, 5119, '\p{^_-Is Canadian SYLLABICS}', ""); +Expect(1, 5119, '\P{_-Is Canadian SYLLABICS}', ""); +Expect(0, 5119, '\P{^_-Is Canadian SYLLABICS}', ""); +Error('\p{_In CanadianSyllabics/a/}'); +Error('\P{_In CanadianSyllabics/a/}'); +Expect(1, 5759, '\p{incanadiansyllabics}', ""); +Expect(0, 5759, '\p{^incanadiansyllabics}', ""); +Expect(0, 5759, '\P{incanadiansyllabics}', ""); +Expect(1, 5759, '\P{^incanadiansyllabics}', ""); +Expect(0, 5119, '\p{incanadiansyllabics}', ""); +Expect(1, 5119, '\p{^incanadiansyllabics}', ""); +Expect(1, 5119, '\P{incanadiansyllabics}', ""); +Expect(0, 5119, '\P{^incanadiansyllabics}', ""); +Expect(1, 5759, '\p{-in canadian-Syllabics}', ""); +Expect(0, 5759, '\p{^-in canadian-Syllabics}', ""); +Expect(0, 5759, '\P{-in canadian-Syllabics}', ""); +Expect(1, 5759, '\P{^-in canadian-Syllabics}', ""); +Expect(0, 5119, '\p{-in canadian-Syllabics}', ""); +Expect(1, 5119, '\p{^-in canadian-Syllabics}', ""); +Expect(1, 5119, '\P{-in canadian-Syllabics}', ""); +Expect(0, 5119, '\P{^-in canadian-Syllabics}', ""); +Error('\p{_Aegean Numbers/a/}'); +Error('\P{_Aegean Numbers/a/}'); +Expect(1, 65855, '\p{aegeannumbers}', ""); +Expect(0, 65855, '\p{^aegeannumbers}', ""); +Expect(0, 65855, '\P{aegeannumbers}', ""); +Expect(1, 65855, '\P{^aegeannumbers}', ""); +Expect(0, 65791, '\p{aegeannumbers}', ""); +Expect(1, 65791, '\p{^aegeannumbers}', ""); +Expect(1, 65791, '\P{aegeannumbers}', ""); +Expect(0, 65791, '\P{^aegeannumbers}', ""); +Expect(1, 65855, '\p{ -Aegean-Numbers}', ""); +Expect(0, 65855, '\p{^ -Aegean-Numbers}', ""); +Expect(0, 65855, '\P{ -Aegean-Numbers}', ""); +Expect(1, 65855, '\P{^ -Aegean-Numbers}', ""); +Expect(0, 65791, '\p{ -Aegean-Numbers}', ""); +Expect(1, 65791, '\p{^ -Aegean-Numbers}', ""); +Expect(1, 65791, '\P{ -Aegean-Numbers}', ""); +Expect(0, 65791, '\P{^ -Aegean-Numbers}', ""); +Error('\p{_-is:=Aegean-Numbers}'); +Error('\P{_-is:=Aegean-Numbers}'); +Expect(1, 65855, '\p{isaegeannumbers}', ""); +Expect(0, 65855, '\p{^isaegeannumbers}', ""); +Expect(0, 65855, '\P{isaegeannumbers}', ""); +Expect(1, 65855, '\P{^isaegeannumbers}', ""); +Expect(0, 65791, '\p{isaegeannumbers}', ""); +Expect(1, 65791, '\p{^isaegeannumbers}', ""); +Expect(1, 65791, '\P{isaegeannumbers}', ""); +Expect(0, 65791, '\P{^isaegeannumbers}', ""); +Expect(1, 65855, '\p{ IS-AegeanNumbers}', ""); +Expect(0, 65855, '\p{^ IS-AegeanNumbers}', ""); +Expect(0, 65855, '\P{ IS-AegeanNumbers}', ""); +Expect(1, 65855, '\P{^ IS-AegeanNumbers}', ""); +Expect(0, 65791, '\p{ IS-AegeanNumbers}', ""); +Expect(1, 65791, '\p{^ IS-AegeanNumbers}', ""); +Expect(1, 65791, '\P{ IS-AegeanNumbers}', ""); +Expect(0, 65791, '\P{^ IS-AegeanNumbers}', ""); +Error('\p{ -In/a/Aegean Numbers}'); +Error('\P{ -In/a/Aegean Numbers}'); +Expect(1, 65855, '\p{inaegeannumbers}', ""); +Expect(0, 65855, '\p{^inaegeannumbers}', ""); +Expect(0, 65855, '\P{inaegeannumbers}', ""); +Expect(1, 65855, '\P{^inaegeannumbers}', ""); +Expect(0, 65791, '\p{inaegeannumbers}', ""); +Expect(1, 65791, '\p{^inaegeannumbers}', ""); +Expect(1, 65791, '\P{inaegeannumbers}', ""); +Expect(0, 65791, '\P{^inaegeannumbers}', ""); +Expect(1, 65855, '\p{-IN AEGEAN-NUMBERS}', ""); +Expect(0, 65855, '\p{^-IN AEGEAN-NUMBERS}', ""); +Expect(0, 65855, '\P{-IN AEGEAN-NUMBERS}', ""); +Expect(1, 65855, '\P{^-IN AEGEAN-NUMBERS}', ""); +Expect(0, 65791, '\p{-IN AEGEAN-NUMBERS}', ""); +Expect(1, 65791, '\p{^-IN AEGEAN-NUMBERS}', ""); +Expect(1, 65791, '\P{-IN AEGEAN-NUMBERS}', ""); +Expect(0, 65791, '\P{^-IN AEGEAN-NUMBERS}', ""); +Error('\p{ bidi-control:=}'); +Error('\P{ bidi-control:=}'); +Expect(1, 8207, '\p{bidicontrol}', ""); +Expect(0, 8207, '\p{^bidicontrol}', ""); +Expect(0, 8207, '\P{bidicontrol}', ""); +Expect(1, 8207, '\P{^bidicontrol}', ""); +Expect(0, 8205, '\p{bidicontrol}', ""); +Expect(1, 8205, '\p{^bidicontrol}', ""); +Expect(1, 8205, '\P{bidicontrol}', ""); +Expect(0, 8205, '\P{^bidicontrol}', ""); +Expect(1, 8207, '\p{ bidi-Control}', ""); +Expect(0, 8207, '\p{^ bidi-Control}', ""); +Expect(0, 8207, '\P{ bidi-Control}', ""); +Expect(1, 8207, '\P{^ bidi-Control}', ""); +Expect(0, 8205, '\p{ bidi-Control}', ""); +Expect(1, 8205, '\p{^ bidi-Control}', ""); +Expect(1, 8205, '\P{ bidi-Control}', ""); +Expect(0, 8205, '\P{^ bidi-Control}', ""); +Error('\p{-/a/is Bidi-Control}'); +Error('\P{-/a/is Bidi-Control}'); +Expect(1, 8207, '\p{isbidicontrol}', ""); +Expect(0, 8207, '\p{^isbidicontrol}', ""); +Expect(0, 8207, '\P{isbidicontrol}', ""); +Expect(1, 8207, '\P{^isbidicontrol}', ""); +Expect(0, 8205, '\p{isbidicontrol}', ""); +Expect(1, 8205, '\p{^isbidicontrol}', ""); +Expect(1, 8205, '\P{isbidicontrol}', ""); +Expect(0, 8205, '\P{^isbidicontrol}', ""); +Expect(1, 8207, '\p{ is bidi_control}', ""); +Expect(0, 8207, '\p{^ is bidi_control}', ""); +Expect(0, 8207, '\P{ is bidi_control}', ""); +Expect(1, 8207, '\P{^ is bidi_control}', ""); +Expect(0, 8205, '\p{ is bidi_control}', ""); +Expect(1, 8205, '\p{^ is bidi_control}', ""); +Expect(1, 8205, '\P{ is bidi_control}', ""); +Expect(0, 8205, '\P{^ is bidi_control}', ""); +Error('\p{ -Bidi/a/c}'); +Error('\P{ -Bidi/a/c}'); +Expect(1, 8207, '\p{bidic}', ""); +Expect(0, 8207, '\p{^bidic}', ""); +Expect(0, 8207, '\P{bidic}', ""); +Expect(1, 8207, '\P{^bidic}', ""); +Expect(0, 8205, '\p{bidic}', ""); +Expect(1, 8205, '\p{^bidic}', ""); +Expect(1, 8205, '\P{bidic}', ""); +Expect(0, 8205, '\P{^bidic}', ""); +Expect(1, 8207, '\p{ BidiC}', ""); +Expect(0, 8207, '\p{^ BidiC}', ""); +Expect(0, 8207, '\P{ BidiC}', ""); +Expect(1, 8207, '\P{^ BidiC}', ""); +Expect(0, 8205, '\p{ BidiC}', ""); +Expect(1, 8205, '\p{^ BidiC}', ""); +Expect(1, 8205, '\P{ BidiC}', ""); +Expect(0, 8205, '\P{^ BidiC}', ""); +Error('\p{_-Is:=bidi_C}'); +Error('\P{_-Is:=bidi_C}'); +Expect(1, 8207, '\p{isbidic}', ""); +Expect(0, 8207, '\p{^isbidic}', ""); +Expect(0, 8207, '\P{isbidic}', ""); +Expect(1, 8207, '\P{^isbidic}', ""); +Expect(0, 8205, '\p{isbidic}', ""); +Expect(1, 8205, '\p{^isbidic}', ""); +Expect(1, 8205, '\P{isbidic}', ""); +Expect(0, 8205, '\P{^isbidic}', ""); +Expect(1, 8207, '\p{--IS Bidi_C}', ""); +Expect(0, 8207, '\p{^--IS Bidi_C}', ""); +Expect(0, 8207, '\P{--IS Bidi_C}', ""); +Expect(1, 8207, '\P{^--IS Bidi_C}', ""); +Expect(0, 8205, '\p{--IS Bidi_C}', ""); +Expect(1, 8205, '\p{^--IS Bidi_C}', ""); +Expect(1, 8205, '\P{--IS Bidi_C}', ""); +Expect(0, 8205, '\P{^--IS Bidi_C}', ""); +Error('\p{ _Combining-diacritical-MARKS FOR:=symbols}'); +Error('\P{ _Combining-diacritical-MARKS FOR:=symbols}'); +Expect(1, 8447, '\p{combiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8447, '\p{^combiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8447, '\P{combiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8447, '\P{^combiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8399, '\p{combiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8399, '\p{^combiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8399, '\P{combiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8399, '\P{^combiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8447, '\p{ _Combining_diacritical Marks For Symbols}', ""); +Expect(0, 8447, '\p{^ _Combining_diacritical Marks For Symbols}', ""); +Expect(0, 8447, '\P{ _Combining_diacritical Marks For Symbols}', ""); +Expect(1, 8447, '\P{^ _Combining_diacritical Marks For Symbols}', ""); +Expect(0, 8399, '\p{ _Combining_diacritical Marks For Symbols}', ""); +Expect(1, 8399, '\p{^ _Combining_diacritical Marks For Symbols}', ""); +Expect(1, 8399, '\P{ _Combining_diacritical Marks For Symbols}', ""); +Expect(0, 8399, '\P{^ _Combining_diacritical Marks For Symbols}', ""); +Error('\p{:= -Is COMBINING Diacritical-marks FORSymbols}'); +Error('\P{:= -Is COMBINING Diacritical-marks FORSymbols}'); +Expect(1, 8447, '\p{iscombiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8447, '\p{^iscombiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8447, '\P{iscombiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8447, '\P{^iscombiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8399, '\p{iscombiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8399, '\p{^iscombiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8399, '\P{iscombiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8399, '\P{^iscombiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8447, '\p{_is Combining-diacriticalMarksfor SYMBOLS}', ""); +Expect(0, 8447, '\p{^_is Combining-diacriticalMarksfor SYMBOLS}', ""); +Expect(0, 8447, '\P{_is Combining-diacriticalMarksfor SYMBOLS}', ""); +Expect(1, 8447, '\P{^_is Combining-diacriticalMarksfor SYMBOLS}', ""); +Expect(0, 8399, '\p{_is Combining-diacriticalMarksfor SYMBOLS}', ""); +Expect(1, 8399, '\p{^_is Combining-diacriticalMarksfor SYMBOLS}', ""); +Expect(1, 8399, '\P{_is Combining-diacriticalMarksfor SYMBOLS}', ""); +Expect(0, 8399, '\P{^_is Combining-diacriticalMarksfor SYMBOLS}', ""); +Error('\p{--In/a/combining-DIACRITICAL-marks_Forsymbols}'); +Error('\P{--In/a/combining-DIACRITICAL-marks_Forsymbols}'); +Expect(1, 8447, '\p{incombiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8447, '\p{^incombiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8447, '\P{incombiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8447, '\P{^incombiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8399, '\p{incombiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8399, '\p{^incombiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8399, '\P{incombiningdiacriticalmarksforsymbols}', ""); +Expect(0, 8399, '\P{^incombiningdiacriticalmarksforsymbols}', ""); +Expect(1, 8447, '\p{- IN Combining DiacriticalMARKS FOR-Symbols}', ""); +Expect(0, 8447, '\p{^- IN Combining DiacriticalMARKS FOR-Symbols}', ""); +Expect(0, 8447, '\P{- IN Combining DiacriticalMARKS FOR-Symbols}', ""); +Expect(1, 8447, '\P{^- IN Combining DiacriticalMARKS FOR-Symbols}', ""); +Expect(0, 8399, '\p{- IN Combining DiacriticalMARKS FOR-Symbols}', ""); +Expect(1, 8399, '\p{^- IN Combining DiacriticalMARKS FOR-Symbols}', ""); +Expect(1, 8399, '\P{- IN Combining DiacriticalMARKS FOR-Symbols}', ""); +Expect(0, 8399, '\P{^- IN Combining DiacriticalMARKS FOR-Symbols}', ""); +Error('\p{_Combiningmarks/a/For Symbols}'); +Error('\P{_Combiningmarks/a/For Symbols}'); +Expect(1, 8447, '\p{combiningmarksforsymbols}', ""); +Expect(0, 8447, '\p{^combiningmarksforsymbols}', ""); +Expect(0, 8447, '\P{combiningmarksforsymbols}', ""); +Expect(1, 8447, '\P{^combiningmarksforsymbols}', ""); +Expect(0, 8399, '\p{combiningmarksforsymbols}', ""); +Expect(1, 8399, '\p{^combiningmarksforsymbols}', ""); +Expect(1, 8399, '\P{combiningmarksforsymbols}', ""); +Expect(0, 8399, '\P{^combiningmarksforsymbols}', ""); +Expect(1, 8447, '\p{ Combining Marks For_SYMBOLS}', ""); +Expect(0, 8447, '\p{^ Combining Marks For_SYMBOLS}', ""); +Expect(0, 8447, '\P{ Combining Marks For_SYMBOLS}', ""); +Expect(1, 8447, '\P{^ Combining Marks For_SYMBOLS}', ""); +Expect(0, 8399, '\p{ Combining Marks For_SYMBOLS}', ""); +Expect(1, 8399, '\p{^ Combining Marks For_SYMBOLS}', ""); +Expect(1, 8399, '\P{ Combining Marks For_SYMBOLS}', ""); +Expect(0, 8399, '\P{^ Combining Marks For_SYMBOLS}', ""); +Error('\p{ Is/a/COMBININGmarks For SYMBOLS}'); +Error('\P{ Is/a/COMBININGmarks For SYMBOLS}'); +Expect(1, 8447, '\p{iscombiningmarksforsymbols}', ""); +Expect(0, 8447, '\p{^iscombiningmarksforsymbols}', ""); +Expect(0, 8447, '\P{iscombiningmarksforsymbols}', ""); +Expect(1, 8447, '\P{^iscombiningmarksforsymbols}', ""); +Expect(0, 8399, '\p{iscombiningmarksforsymbols}', ""); +Expect(1, 8399, '\p{^iscombiningmarksforsymbols}', ""); +Expect(1, 8399, '\P{iscombiningmarksforsymbols}', ""); +Expect(0, 8399, '\P{^iscombiningmarksforsymbols}', ""); +Expect(1, 8447, '\p{ -is COMBINING-marks FOR-Symbols}', ""); +Expect(0, 8447, '\p{^ -is COMBINING-marks FOR-Symbols}', ""); +Expect(0, 8447, '\P{ -is COMBINING-marks FOR-Symbols}', ""); +Expect(1, 8447, '\P{^ -is COMBINING-marks FOR-Symbols}', ""); +Expect(0, 8399, '\p{ -is COMBINING-marks FOR-Symbols}', ""); +Expect(1, 8399, '\p{^ -is COMBINING-marks FOR-Symbols}', ""); +Expect(1, 8399, '\P{ -is COMBINING-marks FOR-Symbols}', ""); +Expect(0, 8399, '\P{^ -is COMBINING-marks FOR-Symbols}', ""); +Error('\p{:=In_COMBININGmarksFORSYMBOLS}'); +Error('\P{:=In_COMBININGmarksFORSYMBOLS}'); +Expect(1, 8447, '\p{incombiningmarksforsymbols}', ""); +Expect(0, 8447, '\p{^incombiningmarksforsymbols}', ""); +Expect(0, 8447, '\P{incombiningmarksforsymbols}', ""); +Expect(1, 8447, '\P{^incombiningmarksforsymbols}', ""); +Expect(0, 8399, '\p{incombiningmarksforsymbols}', ""); +Expect(1, 8399, '\p{^incombiningmarksforsymbols}', ""); +Expect(1, 8399, '\P{incombiningmarksforsymbols}', ""); +Expect(0, 8399, '\P{^incombiningmarksforsymbols}', ""); +Expect(1, 8447, '\p{ in Combining-Marks_For-Symbols}', ""); +Expect(0, 8447, '\p{^ in Combining-Marks_For-Symbols}', ""); +Expect(0, 8447, '\P{ in Combining-Marks_For-Symbols}', ""); +Expect(1, 8447, '\P{^ in Combining-Marks_For-Symbols}', ""); +Expect(0, 8399, '\p{ in Combining-Marks_For-Symbols}', ""); +Expect(1, 8399, '\p{^ in Combining-Marks_For-Symbols}', ""); +Expect(1, 8399, '\P{ in Combining-Marks_For-Symbols}', ""); +Expect(0, 8399, '\P{^ in Combining-Marks_For-Symbols}', ""); +Error('\p{- SmallForm:=variants}'); +Error('\P{- SmallForm:=variants}'); +Expect(1, 65135, '\p{smallformvariants}', ""); +Expect(0, 65135, '\p{^smallformvariants}', ""); +Expect(0, 65135, '\P{smallformvariants}', ""); +Expect(1, 65135, '\P{^smallformvariants}', ""); +Expect(0, 65103, '\p{smallformvariants}', ""); +Expect(1, 65103, '\p{^smallformvariants}', ""); +Expect(1, 65103, '\P{smallformvariants}', ""); +Expect(0, 65103, '\P{^smallformvariants}', ""); +Expect(1, 65135, '\p{ _SmallFORM VARIANTS}', ""); +Expect(0, 65135, '\p{^ _SmallFORM VARIANTS}', ""); +Expect(0, 65135, '\P{ _SmallFORM VARIANTS}', ""); +Expect(1, 65135, '\P{^ _SmallFORM VARIANTS}', ""); +Expect(0, 65103, '\p{ _SmallFORM VARIANTS}', ""); +Expect(1, 65103, '\p{^ _SmallFORM VARIANTS}', ""); +Expect(1, 65103, '\P{ _SmallFORM VARIANTS}', ""); +Expect(0, 65103, '\P{^ _SmallFORM VARIANTS}', ""); +Error('\p{ Is SMALL-FORM VARIANTS/a/}'); +Error('\P{ Is SMALL-FORM VARIANTS/a/}'); +Expect(1, 65135, '\p{issmallformvariants}', ""); +Expect(0, 65135, '\p{^issmallformvariants}', ""); +Expect(0, 65135, '\P{issmallformvariants}', ""); +Expect(1, 65135, '\P{^issmallformvariants}', ""); +Expect(0, 65103, '\p{issmallformvariants}', ""); +Expect(1, 65103, '\p{^issmallformvariants}', ""); +Expect(1, 65103, '\P{issmallformvariants}', ""); +Expect(0, 65103, '\P{^issmallformvariants}', ""); +Expect(1, 65135, '\p{ isSmall_form-VARIANTS}', ""); +Expect(0, 65135, '\p{^ isSmall_form-VARIANTS}', ""); +Expect(0, 65135, '\P{ isSmall_form-VARIANTS}', ""); +Expect(1, 65135, '\P{^ isSmall_form-VARIANTS}', ""); +Expect(0, 65103, '\p{ isSmall_form-VARIANTS}', ""); +Expect(1, 65103, '\p{^ isSmall_form-VARIANTS}', ""); +Expect(1, 65103, '\P{ isSmall_form-VARIANTS}', ""); +Expect(0, 65103, '\P{^ isSmall_form-VARIANTS}', ""); +Error('\p{_IN SMALL form/a/VARIANTS}'); +Error('\P{_IN SMALL form/a/VARIANTS}'); +Expect(1, 65135, '\p{insmallformvariants}', ""); +Expect(0, 65135, '\p{^insmallformvariants}', ""); +Expect(0, 65135, '\P{insmallformvariants}', ""); +Expect(1, 65135, '\P{^insmallformvariants}', ""); +Expect(0, 65103, '\p{insmallformvariants}', ""); +Expect(1, 65103, '\p{^insmallformvariants}', ""); +Expect(1, 65103, '\P{insmallformvariants}', ""); +Expect(0, 65103, '\P{^insmallformvariants}', ""); +Expect(1, 65135, '\p{ -in-smallFORMVariants}', ""); +Expect(0, 65135, '\p{^ -in-smallFORMVariants}', ""); +Expect(0, 65135, '\P{ -in-smallFORMVariants}', ""); +Expect(1, 65135, '\P{^ -in-smallFORMVariants}', ""); +Expect(0, 65103, '\p{ -in-smallFORMVariants}', ""); +Expect(1, 65103, '\p{^ -in-smallFORMVariants}', ""); +Expect(1, 65103, '\P{ -in-smallFORMVariants}', ""); +Expect(0, 65103, '\P{^ -in-smallFORMVariants}', ""); +Error('\p{/a/NKO}'); +Error('\P{/a/NKO}'); +Expect(1, 2042, '\p{nko}', ""); +Expect(0, 2042, '\p{^nko}', ""); +Expect(0, 2042, '\P{nko}', ""); +Expect(1, 2042, '\P{^nko}', ""); +Expect(0, 1983, '\p{nko}', ""); +Expect(1, 1983, '\p{^nko}', ""); +Expect(1, 1983, '\P{nko}', ""); +Expect(0, 1983, '\P{^nko}', ""); +Expect(1, 2042, '\p{_ Nko}', ""); +Expect(0, 2042, '\p{^_ Nko}', ""); +Expect(0, 2042, '\P{_ Nko}', ""); +Expect(1, 2042, '\P{^_ Nko}', ""); +Expect(0, 1983, '\p{_ Nko}', ""); +Expect(1, 1983, '\p{^_ Nko}', ""); +Expect(1, 1983, '\P{_ Nko}', ""); +Expect(0, 1983, '\P{^_ Nko}', ""); +Error('\p{ _Is:=Nko}'); +Error('\P{ _Is:=Nko}'); +Expect(1, 2042, '\p{isnko}', ""); +Expect(0, 2042, '\p{^isnko}', ""); +Expect(0, 2042, '\P{isnko}', ""); +Expect(1, 2042, '\P{^isnko}', ""); +Expect(0, 1983, '\p{isnko}', ""); +Expect(1, 1983, '\p{^isnko}', ""); +Expect(1, 1983, '\P{isnko}', ""); +Expect(0, 1983, '\P{^isnko}', ""); +Expect(1, 2042, '\p{ _IS_nko}', ""); +Expect(0, 2042, '\p{^ _IS_nko}', ""); +Expect(0, 2042, '\P{ _IS_nko}', ""); +Expect(1, 2042, '\P{^ _IS_nko}', ""); +Expect(0, 1983, '\p{ _IS_nko}', ""); +Expect(1, 1983, '\p{^ _IS_nko}', ""); +Expect(1, 1983, '\P{ _IS_nko}', ""); +Expect(0, 1983, '\P{^ _IS_nko}', ""); +Error('\p{:= nkoo}'); +Error('\P{:= nkoo}'); +Expect(1, 2042, '\p{nkoo}', ""); +Expect(0, 2042, '\p{^nkoo}', ""); +Expect(0, 2042, '\P{nkoo}', ""); +Expect(1, 2042, '\P{^nkoo}', ""); +Expect(0, 1983, '\p{nkoo}', ""); +Expect(1, 1983, '\p{^nkoo}', ""); +Expect(1, 1983, '\P{nkoo}', ""); +Expect(0, 1983, '\P{^nkoo}', ""); +Expect(1, 2042, '\p{_NKOO}', ""); +Expect(0, 2042, '\p{^_NKOO}', ""); +Expect(0, 2042, '\P{_NKOO}', ""); +Expect(1, 2042, '\P{^_NKOO}', ""); +Expect(0, 1983, '\p{_NKOO}', ""); +Expect(1, 1983, '\p{^_NKOO}', ""); +Expect(1, 1983, '\P{_NKOO}', ""); +Expect(0, 1983, '\P{^_NKOO}', ""); +Error('\p{-_IsNKOO/a/}'); +Error('\P{-_IsNKOO/a/}'); +Expect(1, 2042, '\p{isnkoo}', ""); +Expect(0, 2042, '\p{^isnkoo}', ""); +Expect(0, 2042, '\P{isnkoo}', ""); +Expect(1, 2042, '\P{^isnkoo}', ""); +Expect(0, 1983, '\p{isnkoo}', ""); +Expect(1, 1983, '\p{^isnkoo}', ""); +Expect(1, 1983, '\P{isnkoo}', ""); +Expect(0, 1983, '\P{^isnkoo}', ""); +Expect(1, 2042, '\p{- Is Nkoo}', ""); +Expect(0, 2042, '\p{^- Is Nkoo}', ""); +Expect(0, 2042, '\P{- Is Nkoo}', ""); +Expect(1, 2042, '\P{^- Is Nkoo}', ""); +Expect(0, 1983, '\p{- Is Nkoo}', ""); +Expect(1, 1983, '\p{^- Is Nkoo}', ""); +Expect(1, 1983, '\P{- Is Nkoo}', ""); +Expect(0, 1983, '\P{^- Is Nkoo}', ""); +Error('\p{ /a/Mathematical alphanumeric_Symbols}'); +Error('\P{ /a/Mathematical alphanumeric_Symbols}'); +Expect(1, 120831, '\p{mathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\p{^mathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\P{mathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\P{^mathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\p{mathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\p{^mathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\P{mathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\P{^mathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\p{ _Mathematical alphanumeric SYMBOLS}', ""); +Expect(0, 120831, '\p{^ _Mathematical alphanumeric SYMBOLS}', ""); +Expect(0, 120831, '\P{ _Mathematical alphanumeric SYMBOLS}', ""); +Expect(1, 120831, '\P{^ _Mathematical alphanumeric SYMBOLS}', ""); +Expect(0, 119807, '\p{ _Mathematical alphanumeric SYMBOLS}', ""); +Expect(1, 119807, '\p{^ _Mathematical alphanumeric SYMBOLS}', ""); +Expect(1, 119807, '\P{ _Mathematical alphanumeric SYMBOLS}', ""); +Expect(0, 119807, '\P{^ _Mathematical alphanumeric SYMBOLS}', ""); +Error('\p{ :=IS-MathematicalALPHANUMERIC Symbols}'); +Error('\P{ :=IS-MathematicalALPHANUMERIC Symbols}'); +Expect(1, 120831, '\p{ismathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\p{^ismathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\P{ismathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\P{^ismathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\p{ismathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\p{^ismathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\P{ismathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\P{^ismathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\p{ is_MATHEMATICALAlphanumericsymbols}', ""); +Expect(0, 120831, '\p{^ is_MATHEMATICALAlphanumericsymbols}', ""); +Expect(0, 120831, '\P{ is_MATHEMATICALAlphanumericsymbols}', ""); +Expect(1, 120831, '\P{^ is_MATHEMATICALAlphanumericsymbols}', ""); +Expect(0, 119807, '\p{ is_MATHEMATICALAlphanumericsymbols}', ""); +Expect(1, 119807, '\p{^ is_MATHEMATICALAlphanumericsymbols}', ""); +Expect(1, 119807, '\P{ is_MATHEMATICALAlphanumericsymbols}', ""); +Expect(0, 119807, '\P{^ is_MATHEMATICALAlphanumericsymbols}', ""); +Error('\p{/a/-IN Mathematical Alphanumeric-symbols}'); +Error('\P{/a/-IN Mathematical Alphanumeric-symbols}'); +Expect(1, 120831, '\p{inmathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\p{^inmathematicalalphanumericsymbols}', ""); +Expect(0, 120831, '\P{inmathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\P{^inmathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\p{inmathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\p{^inmathematicalalphanumericsymbols}', ""); +Expect(1, 119807, '\P{inmathematicalalphanumericsymbols}', ""); +Expect(0, 119807, '\P{^inmathematicalalphanumericsymbols}', ""); +Expect(1, 120831, '\p{-_In_Mathematical_Alphanumeric-Symbols}', ""); +Expect(0, 120831, '\p{^-_In_Mathematical_Alphanumeric-Symbols}', ""); +Expect(0, 120831, '\P{-_In_Mathematical_Alphanumeric-Symbols}', ""); +Expect(1, 120831, '\P{^-_In_Mathematical_Alphanumeric-Symbols}', ""); +Expect(0, 119807, '\p{-_In_Mathematical_Alphanumeric-Symbols}', ""); +Expect(1, 119807, '\p{^-_In_Mathematical_Alphanumeric-Symbols}', ""); +Expect(1, 119807, '\P{-_In_Mathematical_Alphanumeric-Symbols}', ""); +Expect(0, 119807, '\P{^-_In_Mathematical_Alphanumeric-Symbols}', ""); +Error('\p{/a/-_lydian}'); +Error('\P{/a/-_lydian}'); +Expect(1, 67897, '\p{lydian}', ""); +Expect(0, 67897, '\p{^lydian}', ""); +Expect(0, 67897, '\P{lydian}', ""); +Expect(1, 67897, '\P{^lydian}', ""); +Expect(0, 67871, '\p{lydian}', ""); +Expect(1, 67871, '\p{^lydian}', ""); +Expect(1, 67871, '\P{lydian}', ""); +Expect(0, 67871, '\P{^lydian}', ""); +Expect(1, 67897, '\p{ Lydian}', ""); +Expect(0, 67897, '\p{^ Lydian}', ""); +Expect(0, 67897, '\P{ Lydian}', ""); +Expect(1, 67897, '\P{^ Lydian}', ""); +Expect(0, 67871, '\p{ Lydian}', ""); +Expect(1, 67871, '\p{^ Lydian}', ""); +Expect(1, 67871, '\P{ Lydian}', ""); +Expect(0, 67871, '\P{^ Lydian}', ""); +Error('\p{ -Is:=lydian}'); +Error('\P{ -Is:=lydian}'); +Expect(1, 67897, '\p{islydian}', ""); +Expect(0, 67897, '\p{^islydian}', ""); +Expect(0, 67897, '\P{islydian}', ""); +Expect(1, 67897, '\P{^islydian}', ""); +Expect(0, 67871, '\p{islydian}', ""); +Expect(1, 67871, '\p{^islydian}', ""); +Expect(1, 67871, '\P{islydian}', ""); +Expect(0, 67871, '\P{^islydian}', ""); +Expect(1, 67897, '\p{ IsLydian}', ""); +Expect(0, 67897, '\p{^ IsLydian}', ""); +Expect(0, 67897, '\P{ IsLydian}', ""); +Expect(1, 67897, '\P{^ IsLydian}', ""); +Expect(0, 67871, '\p{ IsLydian}', ""); +Expect(1, 67871, '\p{^ IsLydian}', ""); +Expect(1, 67871, '\P{ IsLydian}', ""); +Expect(0, 67871, '\P{^ IsLydian}', ""); +Error('\p{-lydi:=}'); +Error('\P{-lydi:=}'); +Expect(1, 67897, '\p{lydi}', ""); +Expect(0, 67897, '\p{^lydi}', ""); +Expect(0, 67897, '\P{lydi}', ""); +Expect(1, 67897, '\P{^lydi}', ""); +Expect(0, 67871, '\p{lydi}', ""); +Expect(1, 67871, '\p{^lydi}', ""); +Expect(1, 67871, '\P{lydi}', ""); +Expect(0, 67871, '\P{^lydi}', ""); +Expect(1, 67897, '\p{ lydi}', ""); +Expect(0, 67897, '\p{^ lydi}', ""); +Expect(0, 67897, '\P{ lydi}', ""); +Expect(1, 67897, '\P{^ lydi}', ""); +Expect(0, 67871, '\p{ lydi}', ""); +Expect(1, 67871, '\p{^ lydi}', ""); +Expect(1, 67871, '\P{ lydi}', ""); +Expect(0, 67871, '\P{^ lydi}', ""); +Error('\p{_:=Is Lydi}'); +Error('\P{_:=Is Lydi}'); +Expect(1, 67897, '\p{islydi}', ""); +Expect(0, 67897, '\p{^islydi}', ""); +Expect(0, 67897, '\P{islydi}', ""); +Expect(1, 67897, '\P{^islydi}', ""); +Expect(0, 67871, '\p{islydi}', ""); +Expect(1, 67871, '\p{^islydi}', ""); +Expect(1, 67871, '\P{islydi}', ""); +Expect(0, 67871, '\P{^islydi}', ""); +Expect(1, 67897, '\p{_-IS_LYDI}', ""); +Expect(0, 67897, '\p{^_-IS_LYDI}', ""); +Expect(0, 67897, '\P{_-IS_LYDI}', ""); +Expect(1, 67897, '\P{^_-IS_LYDI}', ""); +Expect(0, 67871, '\p{_-IS_LYDI}', ""); +Expect(1, 67871, '\p{^_-IS_LYDI}', ""); +Expect(1, 67871, '\P{_-IS_LYDI}', ""); +Expect(0, 67871, '\P{^_-IS_LYDI}', ""); +Error('\p{_/a/Georgian supplement}'); +Error('\P{_/a/Georgian supplement}'); +Expect(1, 11567, '\p{georgiansupplement}', ""); +Expect(0, 11567, '\p{^georgiansupplement}', ""); +Expect(0, 11567, '\P{georgiansupplement}', ""); +Expect(1, 11567, '\P{^georgiansupplement}', ""); +Expect(0, 11519, '\p{georgiansupplement}', ""); +Expect(1, 11519, '\p{^georgiansupplement}', ""); +Expect(1, 11519, '\P{georgiansupplement}', ""); +Expect(0, 11519, '\P{^georgiansupplement}', ""); +Expect(1, 11567, '\p{ Georgian_Supplement}', ""); +Expect(0, 11567, '\p{^ Georgian_Supplement}', ""); +Expect(0, 11567, '\P{ Georgian_Supplement}', ""); +Expect(1, 11567, '\P{^ Georgian_Supplement}', ""); +Expect(0, 11519, '\p{ Georgian_Supplement}', ""); +Expect(1, 11519, '\p{^ Georgian_Supplement}', ""); +Expect(1, 11519, '\P{ Georgian_Supplement}', ""); +Expect(0, 11519, '\P{^ Georgian_Supplement}', ""); +Error('\p{ /a/is_Georgian SUPPLEMENT}'); +Error('\P{ /a/is_Georgian SUPPLEMENT}'); +Expect(1, 11567, '\p{isgeorgiansupplement}', ""); +Expect(0, 11567, '\p{^isgeorgiansupplement}', ""); +Expect(0, 11567, '\P{isgeorgiansupplement}', ""); +Expect(1, 11567, '\P{^isgeorgiansupplement}', ""); +Expect(0, 11519, '\p{isgeorgiansupplement}', ""); +Expect(1, 11519, '\p{^isgeorgiansupplement}', ""); +Expect(1, 11519, '\P{isgeorgiansupplement}', ""); +Expect(0, 11519, '\P{^isgeorgiansupplement}', ""); +Expect(1, 11567, '\p{ IS-Georgian-supplement}', ""); +Expect(0, 11567, '\p{^ IS-Georgian-supplement}', ""); +Expect(0, 11567, '\P{ IS-Georgian-supplement}', ""); +Expect(1, 11567, '\P{^ IS-Georgian-supplement}', ""); +Expect(0, 11519, '\p{ IS-Georgian-supplement}', ""); +Expect(1, 11519, '\p{^ IS-Georgian-supplement}', ""); +Expect(1, 11519, '\P{ IS-Georgian-supplement}', ""); +Expect(0, 11519, '\P{^ IS-Georgian-supplement}', ""); +Error('\p{ In/a/GEORGIAN SUPPLEMENT}'); +Error('\P{ In/a/GEORGIAN SUPPLEMENT}'); +Expect(1, 11567, '\p{ingeorgiansupplement}', ""); +Expect(0, 11567, '\p{^ingeorgiansupplement}', ""); +Expect(0, 11567, '\P{ingeorgiansupplement}', ""); +Expect(1, 11567, '\P{^ingeorgiansupplement}', ""); +Expect(0, 11519, '\p{ingeorgiansupplement}', ""); +Expect(1, 11519, '\p{^ingeorgiansupplement}', ""); +Expect(1, 11519, '\P{ingeorgiansupplement}', ""); +Expect(0, 11519, '\P{^ingeorgiansupplement}', ""); +Expect(1, 11567, '\p{ IN georgian-Supplement}', ""); +Expect(0, 11567, '\p{^ IN georgian-Supplement}', ""); +Expect(0, 11567, '\P{ IN georgian-Supplement}', ""); +Expect(1, 11567, '\P{^ IN georgian-Supplement}', ""); +Expect(0, 11519, '\p{ IN georgian-Supplement}', ""); +Expect(1, 11519, '\p{^ IN georgian-Supplement}', ""); +Expect(1, 11519, '\P{ IN georgian-Supplement}', ""); +Expect(0, 11519, '\P{^ IN georgian-Supplement}', ""); +Error('\p{-/a/LETTER}'); +Error('\P{-/a/LETTER}'); +Expect(1, 90, '\p{letter}', ""); +Expect(0, 90, '\p{^letter}', ""); +Expect(0, 90, '\P{letter}', ""); +Expect(1, 90, '\P{^letter}', ""); +Expect(0, 64, '\p{letter}', ""); +Expect(1, 64, '\p{^letter}', ""); +Expect(1, 64, '\P{letter}', ""); +Expect(0, 64, '\P{^letter}', ""); +Expect(1, 90, '\p{_ LETTER}', ""); +Expect(0, 90, '\p{^_ LETTER}', ""); +Expect(0, 90, '\P{_ LETTER}', ""); +Expect(1, 90, '\P{^_ LETTER}', ""); +Expect(0, 64, '\p{_ LETTER}', ""); +Expect(1, 64, '\p{^_ LETTER}', ""); +Expect(1, 64, '\P{_ LETTER}', ""); +Expect(0, 64, '\P{^_ LETTER}', ""); +Error('\p{-:=is_Letter}'); +Error('\P{-:=is_Letter}'); +Expect(1, 90, '\p{isletter}', ""); +Expect(0, 90, '\p{^isletter}', ""); +Expect(0, 90, '\P{isletter}', ""); +Expect(1, 90, '\P{^isletter}', ""); +Expect(0, 64, '\p{isletter}', ""); +Expect(1, 64, '\p{^isletter}', ""); +Expect(1, 64, '\P{isletter}', ""); +Expect(0, 64, '\P{^isletter}', ""); +Expect(1, 90, '\p{ -IsLETTER}', ""); +Expect(0, 90, '\p{^ -IsLETTER}', ""); +Expect(0, 90, '\P{ -IsLETTER}', ""); +Expect(1, 90, '\P{^ -IsLETTER}', ""); +Expect(0, 64, '\p{ -IsLETTER}', ""); +Expect(1, 64, '\p{^ -IsLETTER}', ""); +Expect(1, 64, '\P{ -IsLETTER}', ""); +Expect(0, 64, '\P{^ -IsLETTER}', ""); +Error('\p{ L/a/}'); +Error('\P{ L/a/}'); +Expect(1, 90, '\p{l}', ""); +Expect(0, 90, '\p{^l}', ""); +Expect(0, 90, '\P{l}', ""); +Expect(1, 90, '\P{^l}', ""); +Expect(0, 64, '\p{l}', ""); +Expect(1, 64, '\p{^l}', ""); +Expect(1, 64, '\P{l}', ""); +Expect(0, 64, '\P{^l}', ""); +Expect(1, 90, '\p{_L}', ""); +Expect(0, 90, '\p{^_L}', ""); +Expect(0, 90, '\P{_L}', ""); +Expect(1, 90, '\P{^_L}', ""); +Expect(0, 64, '\p{_L}', ""); +Expect(1, 64, '\p{^_L}', ""); +Expect(1, 64, '\P{_L}', ""); +Expect(0, 64, '\P{^_L}', ""); +Error('\p{- IS-L/a/}'); +Error('\P{- IS-L/a/}'); +Expect(1, 90, '\p{isl}', ""); +Expect(0, 90, '\p{^isl}', ""); +Expect(0, 90, '\P{isl}', ""); +Expect(1, 90, '\P{^isl}', ""); +Expect(0, 64, '\p{isl}', ""); +Expect(1, 64, '\p{^isl}', ""); +Expect(1, 64, '\P{isl}', ""); +Expect(0, 64, '\P{^isl}', ""); +Expect(1, 90, '\p{ -is_l}', ""); +Expect(0, 90, '\p{^ -is_l}', ""); +Expect(0, 90, '\P{ -is_l}', ""); +Expect(1, 90, '\P{^ -is_l}', ""); +Expect(0, 64, '\p{ -is_l}', ""); +Expect(1, 64, '\p{^ -is_l}', ""); +Expect(1, 64, '\P{ -is_l}', ""); +Expect(0, 64, '\P{^ -is_l}', ""); +Error('\p{-cyrillic Extended b/a/}'); +Error('\P{-cyrillic Extended b/a/}'); +Expect(1, 42655, '\p{cyrillicextendedb}', ""); +Expect(0, 42655, '\p{^cyrillicextendedb}', ""); +Expect(0, 42655, '\P{cyrillicextendedb}', ""); +Expect(1, 42655, '\P{^cyrillicextendedb}', ""); +Expect(0, 42559, '\p{cyrillicextendedb}', ""); +Expect(1, 42559, '\p{^cyrillicextendedb}', ""); +Expect(1, 42559, '\P{cyrillicextendedb}', ""); +Expect(0, 42559, '\P{^cyrillicextendedb}', ""); +Expect(1, 42655, '\p{- CYRILLIC-Extended b}', ""); +Expect(0, 42655, '\p{^- CYRILLIC-Extended b}', ""); +Expect(0, 42655, '\P{- CYRILLIC-Extended b}', ""); +Expect(1, 42655, '\P{^- CYRILLIC-Extended b}', ""); +Expect(0, 42559, '\p{- CYRILLIC-Extended b}', ""); +Expect(1, 42559, '\p{^- CYRILLIC-Extended b}', ""); +Expect(1, 42559, '\P{- CYRILLIC-Extended b}', ""); +Expect(0, 42559, '\P{^- CYRILLIC-Extended b}', ""); +Error('\p{/a/_IsCyrillic_Extended B}'); +Error('\P{/a/_IsCyrillic_Extended B}'); +Expect(1, 42655, '\p{iscyrillicextendedb}', ""); +Expect(0, 42655, '\p{^iscyrillicextendedb}', ""); +Expect(0, 42655, '\P{iscyrillicextendedb}', ""); +Expect(1, 42655, '\P{^iscyrillicextendedb}', ""); +Expect(0, 42559, '\p{iscyrillicextendedb}', ""); +Expect(1, 42559, '\p{^iscyrillicextendedb}', ""); +Expect(1, 42559, '\P{iscyrillicextendedb}', ""); +Expect(0, 42559, '\P{^iscyrillicextendedb}', ""); +Expect(1, 42655, '\p{_Is-CYRILLIC-extended-B}', ""); +Expect(0, 42655, '\p{^_Is-CYRILLIC-extended-B}', ""); +Expect(0, 42655, '\P{_Is-CYRILLIC-extended-B}', ""); +Expect(1, 42655, '\P{^_Is-CYRILLIC-extended-B}', ""); +Expect(0, 42559, '\p{_Is-CYRILLIC-extended-B}', ""); +Expect(1, 42559, '\p{^_Is-CYRILLIC-extended-B}', ""); +Expect(1, 42559, '\P{_Is-CYRILLIC-extended-B}', ""); +Expect(0, 42559, '\P{^_Is-CYRILLIC-extended-B}', ""); +Error('\p{:= In Cyrillic-Extended-b}'); +Error('\P{:= In Cyrillic-Extended-b}'); +Expect(1, 42655, '\p{incyrillicextendedb}', ""); +Expect(0, 42655, '\p{^incyrillicextendedb}', ""); +Expect(0, 42655, '\P{incyrillicextendedb}', ""); +Expect(1, 42655, '\P{^incyrillicextendedb}', ""); +Expect(0, 42559, '\p{incyrillicextendedb}', ""); +Expect(1, 42559, '\p{^incyrillicextendedb}', ""); +Expect(1, 42559, '\P{incyrillicextendedb}', ""); +Expect(0, 42559, '\P{^incyrillicextendedb}', ""); +Expect(1, 42655, '\p{ In-CYRILLICextended B}', ""); +Expect(0, 42655, '\p{^ In-CYRILLICextended B}', ""); +Expect(0, 42655, '\P{ In-CYRILLICextended B}', ""); +Expect(1, 42655, '\P{^ In-CYRILLICextended B}', ""); +Expect(0, 42559, '\p{ In-CYRILLICextended B}', ""); +Expect(1, 42559, '\p{^ In-CYRILLICextended B}', ""); +Expect(1, 42559, '\P{ In-CYRILLICextended B}', ""); +Expect(0, 42559, '\P{^ In-CYRILLICextended B}', ""); +Error('\p{_:=HEBREW}'); +Error('\P{_:=HEBREW}'); +Expect(1, 1479, '\p{hebrew}', ""); +Expect(0, 1479, '\p{^hebrew}', ""); +Expect(0, 1479, '\P{hebrew}', ""); +Expect(1, 1479, '\P{^hebrew}', ""); +Expect(0, 1424, '\p{hebrew}', ""); +Expect(1, 1424, '\p{^hebrew}', ""); +Expect(1, 1424, '\P{hebrew}', ""); +Expect(0, 1424, '\P{^hebrew}', ""); +Expect(1, 1479, '\p{- Hebrew}', ""); +Expect(0, 1479, '\p{^- Hebrew}', ""); +Expect(0, 1479, '\P{- Hebrew}', ""); +Expect(1, 1479, '\P{^- Hebrew}', ""); +Expect(0, 1424, '\p{- Hebrew}', ""); +Expect(1, 1424, '\p{^- Hebrew}', ""); +Expect(1, 1424, '\P{- Hebrew}', ""); +Expect(0, 1424, '\P{^- Hebrew}', ""); +Error('\p{ IsHEBREW:=}'); +Error('\P{ IsHEBREW:=}'); +Expect(1, 1479, '\p{ishebrew}', ""); +Expect(0, 1479, '\p{^ishebrew}', ""); +Expect(0, 1479, '\P{ishebrew}', ""); +Expect(1, 1479, '\P{^ishebrew}', ""); +Expect(0, 1424, '\p{ishebrew}', ""); +Expect(1, 1424, '\p{^ishebrew}', ""); +Expect(1, 1424, '\P{ishebrew}', ""); +Expect(0, 1424, '\P{^ishebrew}', ""); +Expect(1, 1479, '\p{-Is_Hebrew}', ""); +Expect(0, 1479, '\p{^-Is_Hebrew}', ""); +Expect(0, 1479, '\P{-Is_Hebrew}', ""); +Expect(1, 1479, '\P{^-Is_Hebrew}', ""); +Expect(0, 1424, '\p{-Is_Hebrew}', ""); +Expect(1, 1424, '\p{^-Is_Hebrew}', ""); +Expect(1, 1424, '\P{-Is_Hebrew}', ""); +Expect(0, 1424, '\P{^-Is_Hebrew}', ""); +Error('\p{:=HEBR}'); +Error('\P{:=HEBR}'); +Expect(1, 1479, '\p{hebr}', ""); +Expect(0, 1479, '\p{^hebr}', ""); +Expect(0, 1479, '\P{hebr}', ""); +Expect(1, 1479, '\P{^hebr}', ""); +Expect(0, 1424, '\p{hebr}', ""); +Expect(1, 1424, '\p{^hebr}', ""); +Expect(1, 1424, '\P{hebr}', ""); +Expect(0, 1424, '\P{^hebr}', ""); +Error('\p{/a/IS_hebr}'); +Error('\P{/a/IS_hebr}'); +Expect(1, 1479, '\p{ishebr}', ""); +Expect(0, 1479, '\p{^ishebr}', ""); +Expect(0, 1479, '\P{ishebr}', ""); +Expect(1, 1479, '\P{^ishebr}', ""); +Expect(0, 1424, '\p{ishebr}', ""); +Expect(1, 1424, '\p{^ishebr}', ""); +Expect(1, 1424, '\P{ishebr}', ""); +Expect(0, 1424, '\P{^ishebr}', ""); +Expect(1, 1479, '\p{- Is_Hebr}', ""); +Expect(0, 1479, '\p{^- Is_Hebr}', ""); +Expect(0, 1479, '\P{- Is_Hebr}', ""); +Expect(1, 1479, '\P{^- Is_Hebr}', ""); +Expect(0, 1424, '\p{- Is_Hebr}', ""); +Expect(1, 1424, '\p{^- Is_Hebr}', ""); +Expect(1, 1424, '\P{- Is_Hebr}', ""); +Expect(0, 1424, '\P{^- Is_Hebr}', ""); +Error('\p{ /a/IN_HIRAGANA}'); +Error('\P{ /a/IN_HIRAGANA}'); +Expect(1, 12447, '\p{inhiragana}', ""); +Expect(0, 12447, '\p{^inhiragana}', ""); +Expect(0, 12447, '\P{inhiragana}', ""); +Expect(1, 12447, '\P{^inhiragana}', ""); +Expect(0, 12351, '\p{inhiragana}', ""); +Expect(1, 12351, '\p{^inhiragana}', ""); +Expect(1, 12351, '\P{inhiragana}', ""); +Expect(0, 12351, '\P{^inhiragana}', ""); +Expect(1, 12447, '\p{INhiragana}', ""); +Expect(0, 12447, '\p{^INhiragana}', ""); +Expect(0, 12447, '\P{INhiragana}', ""); +Expect(1, 12447, '\P{^INhiragana}', ""); +Expect(0, 12351, '\p{INhiragana}', ""); +Expect(1, 12351, '\p{^INhiragana}', ""); +Expect(1, 12351, '\P{INhiragana}', ""); +Expect(0, 12351, '\P{^INhiragana}', ""); +Error('\p{ /a/latin}'); +Error('\P{ /a/latin}'); +Expect(1, 90, '\p{latin}', ""); +Expect(0, 90, '\p{^latin}', ""); +Expect(0, 90, '\P{latin}', ""); +Expect(1, 90, '\P{^latin}', ""); +Expect(0, 64, '\p{latin}', ""); +Expect(1, 64, '\p{^latin}', ""); +Expect(1, 64, '\P{latin}', ""); +Expect(0, 64, '\P{^latin}', ""); +Expect(1, 90, '\p{ LATIN}', ""); +Expect(0, 90, '\p{^ LATIN}', ""); +Expect(0, 90, '\P{ LATIN}', ""); +Expect(1, 90, '\P{^ LATIN}', ""); +Expect(0, 64, '\p{ LATIN}', ""); +Expect(1, 64, '\p{^ LATIN}', ""); +Expect(1, 64, '\P{ LATIN}', ""); +Expect(0, 64, '\P{^ LATIN}', ""); +Error('\p{_/a/ISlatin}'); +Error('\P{_/a/ISlatin}'); +Expect(1, 90, '\p{islatin}', ""); +Expect(0, 90, '\p{^islatin}', ""); +Expect(0, 90, '\P{islatin}', ""); +Expect(1, 90, '\P{^islatin}', ""); +Expect(0, 64, '\p{islatin}', ""); +Expect(1, 64, '\p{^islatin}', ""); +Expect(1, 64, '\P{islatin}', ""); +Expect(0, 64, '\P{^islatin}', ""); +Expect(1, 90, '\p{_ is LATIN}', ""); +Expect(0, 90, '\p{^_ is LATIN}', ""); +Expect(0, 90, '\P{_ is LATIN}', ""); +Expect(1, 90, '\P{^_ is LATIN}', ""); +Expect(0, 64, '\p{_ is LATIN}', ""); +Expect(1, 64, '\p{^_ is LATIN}', ""); +Expect(1, 64, '\P{_ is LATIN}', ""); +Expect(0, 64, '\P{^_ is LATIN}', ""); +Error('\p{:=latn}'); +Error('\P{:=latn}'); +Expect(1, 90, '\p{latn}', ""); +Expect(0, 90, '\p{^latn}', ""); +Expect(0, 90, '\P{latn}', ""); +Expect(1, 90, '\P{^latn}', ""); +Expect(0, 64, '\p{latn}', ""); +Expect(1, 64, '\p{^latn}', ""); +Expect(1, 64, '\P{latn}', ""); +Expect(0, 64, '\P{^latn}', ""); +Expect(1, 90, '\p{__Latn}', ""); +Expect(0, 90, '\p{^__Latn}', ""); +Expect(0, 90, '\P{__Latn}', ""); +Expect(1, 90, '\P{^__Latn}', ""); +Expect(0, 64, '\p{__Latn}', ""); +Expect(1, 64, '\p{^__Latn}', ""); +Expect(1, 64, '\P{__Latn}', ""); +Expect(0, 64, '\P{^__Latn}', ""); +Error('\p{:=--Is LATN}'); +Error('\P{:=--Is LATN}'); +Expect(1, 90, '\p{islatn}', ""); +Expect(0, 90, '\p{^islatn}', ""); +Expect(0, 90, '\P{islatn}', ""); +Expect(1, 90, '\P{^islatn}', ""); +Expect(0, 64, '\p{islatn}', ""); +Expect(1, 64, '\p{^islatn}', ""); +Expect(1, 64, '\P{islatn}', ""); +Expect(0, 64, '\P{^islatn}', ""); +Expect(1, 90, '\p{_ Is Latn}', ""); +Expect(0, 90, '\p{^_ Is Latn}', ""); +Expect(0, 90, '\P{_ Is Latn}', ""); +Expect(1, 90, '\P{^_ Is Latn}', ""); +Expect(0, 64, '\p{_ Is Latn}', ""); +Expect(1, 64, '\p{^_ Is Latn}', ""); +Expect(1, 64, '\P{_ Is Latn}', ""); +Expect(0, 64, '\P{^_ Is Latn}', ""); +Error('\p{_:=Enclosing_MARK}'); +Error('\P{_:=Enclosing_MARK}'); +Expect(1, 1161, '\p{enclosingmark}', ""); +Expect(0, 1161, '\p{^enclosingmark}', ""); +Expect(0, 1161, '\P{enclosingmark}', ""); +Expect(1, 1161, '\P{^enclosingmark}', ""); +Expect(0, 1159, '\p{enclosingmark}', ""); +Expect(1, 1159, '\p{^enclosingmark}', ""); +Expect(1, 1159, '\P{enclosingmark}', ""); +Expect(0, 1159, '\P{^enclosingmark}', ""); +Expect(1, 1161, '\p{ _ENCLOSING_Mark}', ""); +Expect(0, 1161, '\p{^ _ENCLOSING_Mark}', ""); +Expect(0, 1161, '\P{ _ENCLOSING_Mark}', ""); +Expect(1, 1161, '\P{^ _ENCLOSING_Mark}', ""); +Expect(0, 1159, '\p{ _ENCLOSING_Mark}', ""); +Expect(1, 1159, '\p{^ _ENCLOSING_Mark}', ""); +Expect(1, 1159, '\P{ _ENCLOSING_Mark}', ""); +Expect(0, 1159, '\P{^ _ENCLOSING_Mark}', ""); +Error('\p{- IS-ENCLOSING/a/Mark}'); +Error('\P{- IS-ENCLOSING/a/Mark}'); +Expect(1, 1161, '\p{isenclosingmark}', ""); +Expect(0, 1161, '\p{^isenclosingmark}', ""); +Expect(0, 1161, '\P{isenclosingmark}', ""); +Expect(1, 1161, '\P{^isenclosingmark}', ""); +Expect(0, 1159, '\p{isenclosingmark}', ""); +Expect(1, 1159, '\p{^isenclosingmark}', ""); +Expect(1, 1159, '\P{isenclosingmark}', ""); +Expect(0, 1159, '\P{^isenclosingmark}', ""); +Expect(1, 1161, '\p{_ is Enclosing_Mark}', ""); +Expect(0, 1161, '\p{^_ is Enclosing_Mark}', ""); +Expect(0, 1161, '\P{_ is Enclosing_Mark}', ""); +Expect(1, 1161, '\P{^_ is Enclosing_Mark}', ""); +Expect(0, 1159, '\p{_ is Enclosing_Mark}', ""); +Expect(1, 1159, '\p{^_ is Enclosing_Mark}', ""); +Expect(1, 1159, '\P{_ is Enclosing_Mark}', ""); +Expect(0, 1159, '\P{^_ is Enclosing_Mark}', ""); +Error('\p{ Me:=}'); +Error('\P{ Me:=}'); +Expect(1, 1161, '\p{me}', ""); +Expect(0, 1161, '\p{^me}', ""); +Expect(0, 1161, '\P{me}', ""); +Expect(1, 1161, '\P{^me}', ""); +Expect(0, 1159, '\p{me}', ""); +Expect(1, 1159, '\p{^me}', ""); +Expect(1, 1159, '\P{me}', ""); +Expect(0, 1159, '\P{^me}', ""); +Expect(1, 1161, '\p{-_me}', ""); +Expect(0, 1161, '\p{^-_me}', ""); +Expect(0, 1161, '\P{-_me}', ""); +Expect(1, 1161, '\P{^-_me}', ""); +Expect(0, 1159, '\p{-_me}', ""); +Expect(1, 1159, '\p{^-_me}', ""); +Expect(1, 1159, '\P{-_me}', ""); +Expect(0, 1159, '\P{^-_me}', ""); +Error('\p{ :=IS_Me}'); +Error('\P{ :=IS_Me}'); +Expect(1, 1161, '\p{isme}', ""); +Expect(0, 1161, '\p{^isme}', ""); +Expect(0, 1161, '\P{isme}', ""); +Expect(1, 1161, '\P{^isme}', ""); +Expect(0, 1159, '\p{isme}', ""); +Expect(1, 1159, '\p{^isme}', ""); +Expect(1, 1159, '\P{isme}', ""); +Expect(0, 1159, '\P{^isme}', ""); +Expect(1, 1161, '\p{ -IS Me}', ""); +Expect(0, 1161, '\p{^ -IS Me}', ""); +Expect(0, 1161, '\P{ -IS Me}', ""); +Expect(1, 1161, '\P{^ -IS Me}', ""); +Expect(0, 1159, '\p{ -IS Me}', ""); +Expect(1, 1159, '\p{^ -IS Me}', ""); +Expect(1, 1159, '\P{ -IS Me}', ""); +Expect(0, 1159, '\P{^ -IS Me}', ""); +Error('\p{ format:=}'); +Error('\P{ format:=}'); +Expect(1, 1539, '\p{format}', ""); +Expect(0, 1539, '\p{^format}', ""); +Expect(0, 1539, '\P{format}', ""); +Expect(1, 1539, '\P{^format}', ""); +Expect(0, 7, '\p{format}', ""); +Expect(1, 7, '\p{^format}', ""); +Expect(1, 7, '\P{format}', ""); +Expect(0, 7, '\P{^format}', ""); +Expect(1, 1539, '\p{- Format}', ""); +Expect(0, 1539, '\p{^- Format}', ""); +Expect(0, 1539, '\P{- Format}', ""); +Expect(1, 1539, '\P{^- Format}', ""); +Expect(0, 7, '\p{- Format}', ""); +Expect(1, 7, '\p{^- Format}', ""); +Expect(1, 7, '\P{- Format}', ""); +Expect(0, 7, '\P{^- Format}', ""); +Error('\p{/a/Is_Format}'); +Error('\P{/a/Is_Format}'); +Expect(1, 1539, '\p{isformat}', ""); +Expect(0, 1539, '\p{^isformat}', ""); +Expect(0, 1539, '\P{isformat}', ""); +Expect(1, 1539, '\P{^isformat}', ""); +Expect(0, 7, '\p{isformat}', ""); +Expect(1, 7, '\p{^isformat}', ""); +Expect(1, 7, '\P{isformat}', ""); +Expect(0, 7, '\P{^isformat}', ""); +Expect(1, 1539, '\p{Is Format}', ""); +Expect(0, 1539, '\p{^Is Format}', ""); +Expect(0, 1539, '\P{Is Format}', ""); +Expect(1, 1539, '\P{^Is Format}', ""); +Expect(0, 7, '\p{Is Format}', ""); +Expect(1, 7, '\p{^Is Format}', ""); +Expect(1, 7, '\P{Is Format}', ""); +Expect(0, 7, '\P{^Is Format}', ""); +Error('\p{ _Cf/a/}'); +Error('\P{ _Cf/a/}'); +Expect(1, 1539, '\p{cf}', ""); +Expect(0, 1539, '\p{^cf}', ""); +Expect(0, 1539, '\P{cf}', ""); +Expect(1, 1539, '\P{^cf}', ""); +Expect(0, 7, '\p{cf}', ""); +Expect(1, 7, '\p{^cf}', ""); +Expect(1, 7, '\P{cf}', ""); +Expect(0, 7, '\P{^cf}', ""); +Expect(1, 1539, '\p{_Cf}', ""); +Expect(0, 1539, '\p{^_Cf}', ""); +Expect(0, 1539, '\P{_Cf}', ""); +Expect(1, 1539, '\P{^_Cf}', ""); +Expect(0, 7, '\p{_Cf}', ""); +Expect(1, 7, '\p{^_Cf}', ""); +Expect(1, 7, '\P{_Cf}', ""); +Expect(0, 7, '\P{^_Cf}', ""); +Error('\p{ _IsCf:=}'); +Error('\P{ _IsCf:=}'); +Expect(1, 1539, '\p{iscf}', ""); +Expect(0, 1539, '\p{^iscf}', ""); +Expect(0, 1539, '\P{iscf}', ""); +Expect(1, 1539, '\P{^iscf}', ""); +Expect(0, 7, '\p{iscf}', ""); +Expect(1, 7, '\p{^iscf}', ""); +Expect(1, 7, '\P{iscf}', ""); +Expect(0, 7, '\P{^iscf}', ""); +Expect(1, 1539, '\p{ Is Cf}', ""); +Expect(0, 1539, '\p{^ Is Cf}', ""); +Expect(0, 1539, '\P{ Is Cf}', ""); +Expect(1, 1539, '\P{^ Is Cf}', ""); +Expect(0, 7, '\p{ Is Cf}', ""); +Expect(1, 7, '\p{^ Is Cf}', ""); +Expect(1, 7, '\P{ Is Cf}', ""); +Expect(0, 7, '\P{^ Is Cf}', ""); +Error('\p{:=otherNumber}'); +Error('\P{:=otherNumber}'); +Expect(1, 2553, '\p{othernumber}', ""); +Expect(0, 2553, '\p{^othernumber}', ""); +Expect(0, 2553, '\P{othernumber}', ""); +Expect(1, 2553, '\P{^othernumber}', ""); +Expect(0, 7, '\p{othernumber}', ""); +Expect(1, 7, '\p{^othernumber}', ""); +Expect(1, 7, '\P{othernumber}', ""); +Expect(0, 7, '\P{^othernumber}', ""); +Expect(1, 2553, '\p{- OTHER-NUMBER}', ""); +Expect(0, 2553, '\p{^- OTHER-NUMBER}', ""); +Expect(0, 2553, '\P{- OTHER-NUMBER}', ""); +Expect(1, 2553, '\P{^- OTHER-NUMBER}', ""); +Expect(0, 7, '\p{- OTHER-NUMBER}', ""); +Expect(1, 7, '\p{^- OTHER-NUMBER}', ""); +Expect(1, 7, '\P{- OTHER-NUMBER}', ""); +Expect(0, 7, '\P{^- OTHER-NUMBER}', ""); +Error('\p{/a/ Is_Other-NUMBER}'); +Error('\P{/a/ Is_Other-NUMBER}'); +Expect(1, 2553, '\p{isothernumber}', ""); +Expect(0, 2553, '\p{^isothernumber}', ""); +Expect(0, 2553, '\P{isothernumber}', ""); +Expect(1, 2553, '\P{^isothernumber}', ""); +Expect(0, 7, '\p{isothernumber}', ""); +Expect(1, 7, '\p{^isothernumber}', ""); +Expect(1, 7, '\P{isothernumber}', ""); +Expect(0, 7, '\P{^isothernumber}', ""); +Expect(1, 2553, '\p{- Is Other-number}', ""); +Expect(0, 2553, '\p{^- Is Other-number}', ""); +Expect(0, 2553, '\P{- Is Other-number}', ""); +Expect(1, 2553, '\P{^- Is Other-number}', ""); +Expect(0, 7, '\p{- Is Other-number}', ""); +Expect(1, 7, '\p{^- Is Other-number}', ""); +Expect(1, 7, '\P{- Is Other-number}', ""); +Expect(0, 7, '\P{^- Is Other-number}', ""); +Error('\p{__NO/a/}'); +Error('\P{__NO/a/}'); +Expect(1, 2553, '\p{no}', ""); +Expect(0, 2553, '\p{^no}', ""); +Expect(0, 2553, '\P{no}', ""); +Expect(1, 2553, '\P{^no}', ""); +Expect(0, 7, '\p{no}', ""); +Expect(1, 7, '\p{^no}', ""); +Expect(1, 7, '\P{no}', ""); +Expect(0, 7, '\P{^no}', ""); +Expect(1, 2553, '\p{ NO}', ""); +Expect(0, 2553, '\p{^ NO}', ""); +Expect(0, 2553, '\P{ NO}', ""); +Expect(1, 2553, '\P{^ NO}', ""); +Expect(0, 7, '\p{ NO}', ""); +Expect(1, 7, '\p{^ NO}', ""); +Expect(1, 7, '\P{ NO}', ""); +Expect(0, 7, '\P{^ NO}', ""); +Error('\p{ :=IS no}'); +Error('\P{ :=IS no}'); +Expect(1, 2553, '\p{isno}', ""); +Expect(0, 2553, '\p{^isno}', ""); +Expect(0, 2553, '\P{isno}', ""); +Expect(1, 2553, '\P{^isno}', ""); +Expect(0, 7, '\p{isno}', ""); +Expect(1, 7, '\p{^isno}', ""); +Expect(1, 7, '\P{isno}', ""); +Expect(0, 7, '\P{^isno}', ""); +Expect(1, 2553, '\p{ -Is No}', ""); +Expect(0, 2553, '\p{^ -Is No}', ""); +Expect(0, 2553, '\P{ -Is No}', ""); +Expect(1, 2553, '\P{^ -Is No}', ""); +Expect(0, 7, '\p{ -Is No}', ""); +Expect(1, 7, '\p{^ -Is No}', ""); +Expect(1, 7, '\P{ -Is No}', ""); +Expect(0, 7, '\P{^ -Is No}', ""); +Error('\p{__Latin-1/a/Supplement}'); +Error('\P{__Latin-1/a/Supplement}'); +Expect(1, 255, '\p{latin1supplement}', ""); +Expect(0, 255, '\p{^latin1supplement}', ""); +Expect(0, 255, '\P{latin1supplement}', ""); +Expect(1, 255, '\P{^latin1supplement}', ""); +Expect(0, 7, '\p{latin1supplement}', ""); +Expect(1, 7, '\p{^latin1supplement}', ""); +Expect(1, 7, '\P{latin1supplement}', ""); +Expect(0, 7, '\P{^latin1supplement}', ""); +Expect(1, 255, '\p{-Latin_1 SUPPLEMENT}', ""); +Expect(0, 255, '\p{^-Latin_1 SUPPLEMENT}', ""); +Expect(0, 255, '\P{-Latin_1 SUPPLEMENT}', ""); +Expect(1, 255, '\P{^-Latin_1 SUPPLEMENT}', ""); +Expect(0, 7, '\p{-Latin_1 SUPPLEMENT}', ""); +Expect(1, 7, '\p{^-Latin_1 SUPPLEMENT}', ""); +Expect(1, 7, '\P{-Latin_1 SUPPLEMENT}', ""); +Expect(0, 7, '\P{^-Latin_1 SUPPLEMENT}', ""); +Error('\p{__IS Latin 1 Supplement:=}'); +Error('\P{__IS Latin 1 Supplement:=}'); +Expect(1, 255, '\p{islatin1supplement}', ""); +Expect(0, 255, '\p{^islatin1supplement}', ""); +Expect(0, 255, '\P{islatin1supplement}', ""); +Expect(1, 255, '\P{^islatin1supplement}', ""); +Expect(0, 7, '\p{islatin1supplement}', ""); +Expect(1, 7, '\p{^islatin1supplement}', ""); +Expect(1, 7, '\P{islatin1supplement}', ""); +Expect(0, 7, '\P{^islatin1supplement}', ""); +Expect(1, 255, '\p{-Is LATIN 1_SUPPLEMENT}', ""); +Expect(0, 255, '\p{^-Is LATIN 1_SUPPLEMENT}', ""); +Expect(0, 255, '\P{-Is LATIN 1_SUPPLEMENT}', ""); +Expect(1, 255, '\P{^-Is LATIN 1_SUPPLEMENT}', ""); +Expect(0, 7, '\p{-Is LATIN 1_SUPPLEMENT}', ""); +Expect(1, 7, '\p{^-Is LATIN 1_SUPPLEMENT}', ""); +Expect(1, 7, '\P{-Is LATIN 1_SUPPLEMENT}', ""); +Expect(0, 7, '\P{^-Is LATIN 1_SUPPLEMENT}', ""); +Error('\p{_In_Latin 1:=SUPPLEMENT}'); +Error('\P{_In_Latin 1:=SUPPLEMENT}'); +Expect(1, 255, '\p{inlatin1supplement}', ""); +Expect(0, 255, '\p{^inlatin1supplement}', ""); +Expect(0, 255, '\P{inlatin1supplement}', ""); +Expect(1, 255, '\P{^inlatin1supplement}', ""); +Expect(0, 7, '\p{inlatin1supplement}', ""); +Expect(1, 7, '\p{^inlatin1supplement}', ""); +Expect(1, 7, '\P{inlatin1supplement}', ""); +Expect(0, 7, '\P{^inlatin1supplement}', ""); +Expect(1, 255, '\p{_ IN Latin-1 supplement}', ""); +Expect(0, 255, '\p{^_ IN Latin-1 supplement}', ""); +Expect(0, 255, '\P{_ IN Latin-1 supplement}', ""); +Expect(1, 255, '\P{^_ IN Latin-1 supplement}', ""); +Expect(0, 7, '\p{_ IN Latin-1 supplement}', ""); +Expect(1, 7, '\p{^_ IN Latin-1 supplement}', ""); +Expect(1, 7, '\P{_ IN Latin-1 supplement}', ""); +Expect(0, 7, '\P{^_ IN Latin-1 supplement}', ""); +Error('\p{- LATIN:=1}'); +Error('\P{- LATIN:=1}'); +Expect(1, 255, '\p{latin1}', ""); +Expect(0, 255, '\p{^latin1}', ""); +Expect(0, 255, '\P{latin1}', ""); +Expect(1, 255, '\P{^latin1}', ""); +Expect(0, 7, '\p{latin1}', ""); +Expect(1, 7, '\p{^latin1}', ""); +Expect(1, 7, '\P{latin1}', ""); +Expect(0, 7, '\P{^latin1}', ""); +Expect(1, 255, '\p{ -Latin1}', ""); +Expect(0, 255, '\p{^ -Latin1}', ""); +Expect(0, 255, '\P{ -Latin1}', ""); +Expect(1, 255, '\P{^ -Latin1}', ""); +Expect(0, 7, '\p{ -Latin1}', ""); +Expect(1, 7, '\p{^ -Latin1}', ""); +Expect(1, 7, '\P{ -Latin1}', ""); +Expect(0, 7, '\P{^ -Latin1}', ""); +Error('\p{ _is/a/Latin-1}'); +Error('\P{ _is/a/Latin-1}'); +Expect(1, 255, '\p{islatin1}', ""); +Expect(0, 255, '\p{^islatin1}', ""); +Expect(0, 255, '\P{islatin1}', ""); +Expect(1, 255, '\P{^islatin1}', ""); +Expect(0, 7, '\p{islatin1}', ""); +Expect(1, 7, '\p{^islatin1}', ""); +Expect(1, 7, '\P{islatin1}', ""); +Expect(0, 7, '\P{^islatin1}', ""); +Expect(1, 255, '\p{ IS latin 1}', ""); +Expect(0, 255, '\p{^ IS latin 1}', ""); +Expect(0, 255, '\P{ IS latin 1}', ""); +Expect(1, 255, '\P{^ IS latin 1}', ""); +Expect(0, 7, '\p{ IS latin 1}', ""); +Expect(1, 7, '\p{^ IS latin 1}', ""); +Expect(1, 7, '\P{ IS latin 1}', ""); +Expect(0, 7, '\P{^ IS latin 1}', ""); +Error('\p{:=_ InLATIN1}'); +Error('\P{:=_ InLATIN1}'); +Expect(1, 255, '\p{inlatin1}', ""); +Expect(0, 255, '\p{^inlatin1}', ""); +Expect(0, 255, '\P{inlatin1}', ""); +Expect(1, 255, '\P{^inlatin1}', ""); +Expect(0, 7, '\p{inlatin1}', ""); +Expect(1, 7, '\p{^inlatin1}', ""); +Expect(1, 7, '\P{inlatin1}', ""); +Expect(0, 7, '\P{^inlatin1}', ""); +Expect(1, 255, '\p{-In-latin_1}', ""); +Expect(0, 255, '\p{^-In-latin_1}', ""); +Expect(0, 255, '\P{-In-latin_1}', ""); +Expect(1, 255, '\P{^-In-latin_1}', ""); +Expect(0, 7, '\p{-In-latin_1}', ""); +Expect(1, 7, '\p{^-In-latin_1}', ""); +Expect(1, 7, '\P{-In-latin_1}', ""); +Expect(0, 7, '\P{^-In-latin_1}', ""); +Error('\p{ tamil:=}'); +Error('\P{ tamil:=}'); +Expect(1, 2947, '\p{tamil}', ""); +Expect(0, 2947, '\p{^tamil}', ""); +Expect(0, 2947, '\P{tamil}', ""); +Expect(1, 2947, '\P{^tamil}', ""); +Expect(0, 2945, '\p{tamil}', ""); +Expect(1, 2945, '\p{^tamil}', ""); +Expect(1, 2945, '\P{tamil}', ""); +Expect(0, 2945, '\P{^tamil}', ""); +Expect(1, 2947, '\p{ Tamil}', ""); +Expect(0, 2947, '\p{^ Tamil}', ""); +Expect(0, 2947, '\P{ Tamil}', ""); +Expect(1, 2947, '\P{^ Tamil}', ""); +Expect(0, 2945, '\p{ Tamil}', ""); +Expect(1, 2945, '\p{^ Tamil}', ""); +Expect(1, 2945, '\P{ Tamil}', ""); +Expect(0, 2945, '\P{^ Tamil}', ""); +Error('\p{/a/ Is-TAMIL}'); +Error('\P{/a/ Is-TAMIL}'); +Expect(1, 2947, '\p{istamil}', ""); +Expect(0, 2947, '\p{^istamil}', ""); +Expect(0, 2947, '\P{istamil}', ""); +Expect(1, 2947, '\P{^istamil}', ""); +Expect(0, 2945, '\p{istamil}', ""); +Expect(1, 2945, '\p{^istamil}', ""); +Expect(1, 2945, '\P{istamil}', ""); +Expect(0, 2945, '\P{^istamil}', ""); +Expect(1, 2947, '\p{Is tamil}', ""); +Expect(0, 2947, '\p{^Is tamil}', ""); +Expect(0, 2947, '\P{Is tamil}', ""); +Expect(1, 2947, '\P{^Is tamil}', ""); +Expect(0, 2945, '\p{Is tamil}', ""); +Expect(1, 2945, '\p{^Is tamil}', ""); +Expect(1, 2945, '\P{Is tamil}', ""); +Expect(0, 2945, '\P{^Is tamil}', ""); +Error('\p{:=_ taml}'); +Error('\P{:=_ taml}'); +Expect(1, 2947, '\p{taml}', ""); +Expect(0, 2947, '\p{^taml}', ""); +Expect(0, 2947, '\P{taml}', ""); +Expect(1, 2947, '\P{^taml}', ""); +Expect(0, 2945, '\p{taml}', ""); +Expect(1, 2945, '\p{^taml}', ""); +Expect(1, 2945, '\P{taml}', ""); +Expect(0, 2945, '\P{^taml}', ""); +Expect(1, 2947, '\p{ TAML}', ""); +Expect(0, 2947, '\p{^ TAML}', ""); +Expect(0, 2947, '\P{ TAML}', ""); +Expect(1, 2947, '\P{^ TAML}', ""); +Expect(0, 2945, '\p{ TAML}', ""); +Expect(1, 2945, '\p{^ TAML}', ""); +Expect(1, 2945, '\P{ TAML}', ""); +Expect(0, 2945, '\P{^ TAML}', ""); +Error('\p{_Is_Taml:=}'); +Error('\P{_Is_Taml:=}'); +Expect(1, 2947, '\p{istaml}', ""); +Expect(0, 2947, '\p{^istaml}', ""); +Expect(0, 2947, '\P{istaml}', ""); +Expect(1, 2947, '\P{^istaml}', ""); +Expect(0, 2945, '\p{istaml}', ""); +Expect(1, 2945, '\p{^istaml}', ""); +Expect(1, 2945, '\P{istaml}', ""); +Expect(0, 2945, '\P{^istaml}', ""); +Expect(1, 2947, '\p{_IS-TAML}', ""); +Expect(0, 2947, '\p{^_IS-TAML}', ""); +Expect(0, 2947, '\P{_IS-TAML}', ""); +Expect(1, 2947, '\P{^_IS-TAML}', ""); +Expect(0, 2945, '\p{_IS-TAML}', ""); +Expect(1, 2945, '\p{^_IS-TAML}', ""); +Expect(1, 2945, '\P{_IS-TAML}', ""); +Expect(0, 2945, '\P{^_IS-TAML}', ""); +Error('\p{/a/-shavian}'); +Error('\P{/a/-shavian}'); +Expect(1, 66687, '\p{shavian}', ""); +Expect(0, 66687, '\p{^shavian}', ""); +Expect(0, 66687, '\P{shavian}', ""); +Expect(1, 66687, '\P{^shavian}', ""); +Expect(0, 66639, '\p{shavian}', ""); +Expect(1, 66639, '\p{^shavian}', ""); +Expect(1, 66639, '\P{shavian}', ""); +Expect(0, 66639, '\P{^shavian}', ""); +Expect(1, 66687, '\p{--shavian}', ""); +Expect(0, 66687, '\p{^--shavian}', ""); +Expect(0, 66687, '\P{--shavian}', ""); +Expect(1, 66687, '\P{^--shavian}', ""); +Expect(0, 66639, '\p{--shavian}', ""); +Expect(1, 66639, '\p{^--shavian}', ""); +Expect(1, 66639, '\P{--shavian}', ""); +Expect(0, 66639, '\P{^--shavian}', ""); +Error('\p{:=-_ISSHAVIAN}'); +Error('\P{:=-_ISSHAVIAN}'); +Expect(1, 66687, '\p{isshavian}', ""); +Expect(0, 66687, '\p{^isshavian}', ""); +Expect(0, 66687, '\P{isshavian}', ""); +Expect(1, 66687, '\P{^isshavian}', ""); +Expect(0, 66639, '\p{isshavian}', ""); +Expect(1, 66639, '\p{^isshavian}', ""); +Expect(1, 66639, '\P{isshavian}', ""); +Expect(0, 66639, '\P{^isshavian}', ""); +Expect(1, 66687, '\p{ Is_Shavian}', ""); +Expect(0, 66687, '\p{^ Is_Shavian}', ""); +Expect(0, 66687, '\P{ Is_Shavian}', ""); +Expect(1, 66687, '\P{^ Is_Shavian}', ""); +Expect(0, 66639, '\p{ Is_Shavian}', ""); +Expect(1, 66639, '\p{^ Is_Shavian}', ""); +Expect(1, 66639, '\P{ Is_Shavian}', ""); +Expect(0, 66639, '\P{^ Is_Shavian}', ""); +Error('\p{ :=SHAW}'); +Error('\P{ :=SHAW}'); +Expect(1, 66687, '\p{shaw}', ""); +Expect(0, 66687, '\p{^shaw}', ""); +Expect(0, 66687, '\P{shaw}', ""); +Expect(1, 66687, '\P{^shaw}', ""); +Expect(0, 66639, '\p{shaw}', ""); +Expect(1, 66639, '\p{^shaw}', ""); +Expect(1, 66639, '\P{shaw}', ""); +Expect(0, 66639, '\P{^shaw}', ""); +Expect(1, 66687, '\p{- shaw}', ""); +Expect(0, 66687, '\p{^- shaw}', ""); +Expect(0, 66687, '\P{- shaw}', ""); +Expect(1, 66687, '\P{^- shaw}', ""); +Expect(0, 66639, '\p{- shaw}', ""); +Expect(1, 66639, '\p{^- shaw}', ""); +Expect(1, 66639, '\P{- shaw}', ""); +Expect(0, 66639, '\P{^- shaw}', ""); +Error('\p{:=-is-SHAW}'); +Error('\P{:=-is-SHAW}'); +Expect(1, 66687, '\p{isshaw}', ""); +Expect(0, 66687, '\p{^isshaw}', ""); +Expect(0, 66687, '\P{isshaw}', ""); +Expect(1, 66687, '\P{^isshaw}', ""); +Expect(0, 66639, '\p{isshaw}', ""); +Expect(1, 66639, '\p{^isshaw}', ""); +Expect(1, 66639, '\P{isshaw}', ""); +Expect(0, 66639, '\P{^isshaw}', ""); +Expect(1, 66687, '\p{ _IS shaw}', ""); +Expect(0, 66687, '\p{^ _IS shaw}', ""); +Expect(0, 66687, '\P{ _IS shaw}', ""); +Expect(1, 66687, '\P{^ _IS shaw}', ""); +Expect(0, 66639, '\p{ _IS shaw}', ""); +Expect(1, 66639, '\p{^ _IS shaw}', ""); +Expect(1, 66639, '\P{ _IS shaw}', ""); +Expect(0, 66639, '\P{^ _IS shaw}', ""); +Error('\p{:=- IPA-Extensions}'); +Error('\P{:=- IPA-Extensions}'); +Expect(1, 687, '\p{ipaextensions}', ""); +Expect(0, 687, '\p{^ipaextensions}', ""); +Expect(0, 687, '\P{ipaextensions}', ""); +Expect(1, 687, '\P{^ipaextensions}', ""); +Expect(0, 591, '\p{ipaextensions}', ""); +Expect(1, 591, '\p{^ipaextensions}', ""); +Expect(1, 591, '\P{ipaextensions}', ""); +Expect(0, 591, '\P{^ipaextensions}', ""); +Expect(1, 687, '\p{ IPAextensions}', ""); +Expect(0, 687, '\p{^ IPAextensions}', ""); +Expect(0, 687, '\P{ IPAextensions}', ""); +Expect(1, 687, '\P{^ IPAextensions}', ""); +Expect(0, 591, '\p{ IPAextensions}', ""); +Expect(1, 591, '\p{^ IPAextensions}', ""); +Expect(1, 591, '\P{ IPAextensions}', ""); +Expect(0, 591, '\P{^ IPAextensions}', ""); +Error('\p{_:=Is IPA extensions}'); +Error('\P{_:=Is IPA extensions}'); +Expect(1, 687, '\p{isipaextensions}', ""); +Expect(0, 687, '\p{^isipaextensions}', ""); +Expect(0, 687, '\P{isipaextensions}', ""); +Expect(1, 687, '\P{^isipaextensions}', ""); +Expect(0, 591, '\p{isipaextensions}', ""); +Expect(1, 591, '\p{^isipaextensions}', ""); +Expect(1, 591, '\P{isipaextensions}', ""); +Expect(0, 591, '\P{^isipaextensions}', ""); +Expect(1, 687, '\p{_-IS ipa-Extensions}', ""); +Expect(0, 687, '\p{^_-IS ipa-Extensions}', ""); +Expect(0, 687, '\P{_-IS ipa-Extensions}', ""); +Expect(1, 687, '\P{^_-IS ipa-Extensions}', ""); +Expect(0, 591, '\p{_-IS ipa-Extensions}', ""); +Expect(1, 591, '\p{^_-IS ipa-Extensions}', ""); +Expect(1, 591, '\P{_-IS ipa-Extensions}', ""); +Expect(0, 591, '\P{^_-IS ipa-Extensions}', ""); +Error('\p{:= _INIPA_Extensions}'); +Error('\P{:= _INIPA_Extensions}'); +Expect(1, 687, '\p{inipaextensions}', ""); +Expect(0, 687, '\p{^inipaextensions}', ""); +Expect(0, 687, '\P{inipaextensions}', ""); +Expect(1, 687, '\P{^inipaextensions}', ""); +Expect(0, 591, '\p{inipaextensions}', ""); +Expect(1, 591, '\p{^inipaextensions}', ""); +Expect(1, 591, '\P{inipaextensions}', ""); +Expect(0, 591, '\P{^inipaextensions}', ""); +Expect(1, 687, '\p{-_InIPA_Extensions}', ""); +Expect(0, 687, '\p{^-_InIPA_Extensions}', ""); +Expect(0, 687, '\P{-_InIPA_Extensions}', ""); +Expect(1, 687, '\P{^-_InIPA_Extensions}', ""); +Expect(0, 591, '\p{-_InIPA_Extensions}', ""); +Expect(1, 591, '\p{^-_InIPA_Extensions}', ""); +Expect(1, 591, '\P{-_InIPA_Extensions}', ""); +Expect(0, 591, '\P{^-_InIPA_Extensions}', ""); +Error('\p{/a/ Hiragana}'); +Error('\P{/a/ Hiragana}'); +Expect(1, 12438, '\p{hiragana}', ""); +Expect(0, 12438, '\p{^hiragana}', ""); +Expect(0, 12438, '\P{hiragana}', ""); +Expect(1, 12438, '\P{^hiragana}', ""); +Expect(0, 12352, '\p{hiragana}', ""); +Expect(1, 12352, '\p{^hiragana}', ""); +Expect(1, 12352, '\P{hiragana}', ""); +Expect(0, 12352, '\P{^hiragana}', ""); +Expect(1, 12438, '\p{_-Hiragana}', ""); +Expect(0, 12438, '\p{^_-Hiragana}', ""); +Expect(0, 12438, '\P{_-Hiragana}', ""); +Expect(1, 12438, '\P{^_-Hiragana}', ""); +Expect(0, 12352, '\p{_-Hiragana}', ""); +Expect(1, 12352, '\p{^_-Hiragana}', ""); +Expect(1, 12352, '\P{_-Hiragana}', ""); +Expect(0, 12352, '\P{^_-Hiragana}', ""); +Error('\p{ :=Is hiragana}'); +Error('\P{ :=Is hiragana}'); +Expect(1, 12438, '\p{ishiragana}', ""); +Expect(0, 12438, '\p{^ishiragana}', ""); +Expect(0, 12438, '\P{ishiragana}', ""); +Expect(1, 12438, '\P{^ishiragana}', ""); +Expect(0, 12352, '\p{ishiragana}', ""); +Expect(1, 12352, '\p{^ishiragana}', ""); +Expect(1, 12352, '\P{ishiragana}', ""); +Expect(0, 12352, '\P{^ishiragana}', ""); +Expect(1, 12438, '\p{Is-Hiragana}', ""); +Expect(0, 12438, '\p{^Is-Hiragana}', ""); +Expect(0, 12438, '\P{Is-Hiragana}', ""); +Expect(1, 12438, '\P{^Is-Hiragana}', ""); +Expect(0, 12352, '\p{Is-Hiragana}', ""); +Expect(1, 12352, '\p{^Is-Hiragana}', ""); +Expect(1, 12352, '\P{Is-Hiragana}', ""); +Expect(0, 12352, '\P{^Is-Hiragana}', ""); +Error('\p{Hira:=}'); +Error('\P{Hira:=}'); +Expect(1, 12438, '\p{hira}', ""); +Expect(0, 12438, '\p{^hira}', ""); +Expect(0, 12438, '\P{hira}', ""); +Expect(1, 12438, '\P{^hira}', ""); +Expect(0, 12352, '\p{hira}', ""); +Expect(1, 12352, '\p{^hira}', ""); +Expect(1, 12352, '\P{hira}', ""); +Expect(0, 12352, '\P{^hira}', ""); +Expect(1, 12438, '\p{ hira}', ""); +Expect(0, 12438, '\p{^ hira}', ""); +Expect(0, 12438, '\P{ hira}', ""); +Expect(1, 12438, '\P{^ hira}', ""); +Expect(0, 12352, '\p{ hira}', ""); +Expect(1, 12352, '\p{^ hira}', ""); +Expect(1, 12352, '\P{ hira}', ""); +Expect(0, 12352, '\P{^ hira}', ""); +Error('\p{- ISHira/a/}'); +Error('\P{- ISHira/a/}'); +Expect(1, 12438, '\p{ishira}', ""); +Expect(0, 12438, '\p{^ishira}', ""); +Expect(0, 12438, '\P{ishira}', ""); +Expect(1, 12438, '\P{^ishira}', ""); +Expect(0, 12352, '\p{ishira}', ""); +Expect(1, 12352, '\p{^ishira}', ""); +Expect(1, 12352, '\P{ishira}', ""); +Expect(0, 12352, '\P{^ishira}', ""); +Expect(1, 12438, '\p{_ Is Hira}', ""); +Expect(0, 12438, '\p{^_ Is Hira}', ""); +Expect(0, 12438, '\P{_ Is Hira}', ""); +Expect(1, 12438, '\P{^_ Is Hira}', ""); +Expect(0, 12352, '\p{_ Is Hira}', ""); +Expect(1, 12352, '\p{^_ Is Hira}', ""); +Expect(1, 12352, '\P{_ Is Hira}', ""); +Expect(0, 12352, '\P{^_ Is Hira}', ""); +Error('\p{_Greek:=}'); +Error('\P{_Greek:=}'); +Expect(1, 883, '\p{greek}', ""); +Expect(0, 883, '\p{^greek}', ""); +Expect(0, 883, '\P{greek}', ""); +Expect(1, 883, '\P{^greek}', ""); +Expect(0, 879, '\p{greek}', ""); +Expect(1, 879, '\p{^greek}', ""); +Expect(1, 879, '\P{greek}', ""); +Expect(0, 879, '\P{^greek}', ""); +Expect(1, 883, '\p{ _Greek}', ""); +Expect(0, 883, '\p{^ _Greek}', ""); +Expect(0, 883, '\P{ _Greek}', ""); +Expect(1, 883, '\P{^ _Greek}', ""); +Expect(0, 879, '\p{ _Greek}', ""); +Expect(1, 879, '\p{^ _Greek}', ""); +Expect(1, 879, '\P{ _Greek}', ""); +Expect(0, 879, '\P{^ _Greek}', ""); +Error('\p{-:=IS greek}'); +Error('\P{-:=IS greek}'); +Expect(1, 883, '\p{isgreek}', ""); +Expect(0, 883, '\p{^isgreek}', ""); +Expect(0, 883, '\P{isgreek}', ""); +Expect(1, 883, '\P{^isgreek}', ""); +Expect(0, 879, '\p{isgreek}', ""); +Expect(1, 879, '\p{^isgreek}', ""); +Expect(1, 879, '\P{isgreek}', ""); +Expect(0, 879, '\P{^isgreek}', ""); +Expect(1, 883, '\p{ IS Greek}', ""); +Expect(0, 883, '\p{^ IS Greek}', ""); +Expect(0, 883, '\P{ IS Greek}', ""); +Expect(1, 883, '\P{^ IS Greek}', ""); +Expect(0, 879, '\p{ IS Greek}', ""); +Expect(1, 879, '\p{^ IS Greek}', ""); +Expect(1, 879, '\P{ IS Greek}', ""); +Expect(0, 879, '\P{^ IS Greek}', ""); +Error('\p{ -grek:=}'); +Error('\P{ -grek:=}'); +Expect(1, 883, '\p{grek}', ""); +Expect(0, 883, '\p{^grek}', ""); +Expect(0, 883, '\P{grek}', ""); +Expect(1, 883, '\P{^grek}', ""); +Expect(0, 879, '\p{grek}', ""); +Expect(1, 879, '\p{^grek}', ""); +Expect(1, 879, '\P{grek}', ""); +Expect(0, 879, '\P{^grek}', ""); +Expect(1, 883, '\p{_grek}', ""); +Expect(0, 883, '\p{^_grek}', ""); +Expect(0, 883, '\P{_grek}', ""); +Expect(1, 883, '\P{^_grek}', ""); +Expect(0, 879, '\p{_grek}', ""); +Expect(1, 879, '\p{^_grek}', ""); +Expect(1, 879, '\P{_grek}', ""); +Expect(0, 879, '\P{^_grek}', ""); +Error('\p{_Is:=Grek}'); +Error('\P{_Is:=Grek}'); +Expect(1, 883, '\p{isgrek}', ""); +Expect(0, 883, '\p{^isgrek}', ""); +Expect(0, 883, '\P{isgrek}', ""); +Expect(1, 883, '\P{^isgrek}', ""); +Expect(0, 879, '\p{isgrek}', ""); +Expect(1, 879, '\p{^isgrek}', ""); +Expect(1, 879, '\P{isgrek}', ""); +Expect(0, 879, '\P{^isgrek}', ""); +Expect(1, 883, '\p{-Is grek}', ""); +Expect(0, 883, '\p{^-Is grek}', ""); +Expect(0, 883, '\P{-Is grek}', ""); +Expect(1, 883, '\P{^-Is grek}', ""); +Expect(0, 879, '\p{-Is grek}', ""); +Expect(1, 879, '\p{^-Is grek}', ""); +Expect(1, 879, '\P{-Is grek}', ""); +Expect(0, 879, '\P{^-Is grek}', ""); +Error('\p{ _IN Thai/a/}'); +Error('\P{ _IN Thai/a/}'); +Expect(1, 3711, '\p{inthai}', ""); +Expect(0, 3711, '\p{^inthai}', ""); +Expect(0, 3711, '\P{inthai}', ""); +Expect(1, 3711, '\P{^inthai}', ""); +Expect(0, 3583, '\p{inthai}', ""); +Expect(1, 3583, '\p{^inthai}', ""); +Expect(1, 3583, '\P{inthai}', ""); +Expect(0, 3583, '\P{^inthai}', ""); +Expect(1, 3711, '\p{ In Thai}', ""); +Expect(0, 3711, '\p{^ In Thai}', ""); +Expect(0, 3711, '\P{ In Thai}', ""); +Expect(1, 3711, '\P{^ In Thai}', ""); +Expect(0, 3583, '\p{ In Thai}', ""); +Expect(1, 3583, '\p{^ In Thai}', ""); +Expect(1, 3583, '\P{ In Thai}', ""); +Expect(0, 3583, '\P{^ In Thai}', ""); +Error('\p{-LINE_SEPARATOR:=}'); +Error('\P{-LINE_SEPARATOR:=}'); +Expect(1, 8232, '\p{lineseparator}', ""); +Expect(0, 8232, '\p{^lineseparator}', ""); +Expect(0, 8232, '\P{lineseparator}', ""); +Expect(1, 8232, '\P{^lineseparator}', ""); +Expect(0, 8231, '\p{lineseparator}', ""); +Expect(1, 8231, '\p{^lineseparator}', ""); +Expect(1, 8231, '\P{lineseparator}', ""); +Expect(0, 8231, '\P{^lineseparator}', ""); +Expect(1, 8232, '\p{-_lineSEPARATOR}', ""); +Expect(0, 8232, '\p{^-_lineSEPARATOR}', ""); +Expect(0, 8232, '\P{-_lineSEPARATOR}', ""); +Expect(1, 8232, '\P{^-_lineSEPARATOR}', ""); +Expect(0, 8231, '\p{-_lineSEPARATOR}', ""); +Expect(1, 8231, '\p{^-_lineSEPARATOR}', ""); +Expect(1, 8231, '\P{-_lineSEPARATOR}', ""); +Expect(0, 8231, '\P{^-_lineSEPARATOR}', ""); +Error('\p{ /a/IsLINE Separator}'); +Error('\P{ /a/IsLINE Separator}'); +Expect(1, 8232, '\p{islineseparator}', ""); +Expect(0, 8232, '\p{^islineseparator}', ""); +Expect(0, 8232, '\P{islineseparator}', ""); +Expect(1, 8232, '\P{^islineseparator}', ""); +Expect(0, 8231, '\p{islineseparator}', ""); +Expect(1, 8231, '\p{^islineseparator}', ""); +Expect(1, 8231, '\P{islineseparator}', ""); +Expect(0, 8231, '\P{^islineseparator}', ""); +Expect(1, 8232, '\p{Is LineSeparator}', ""); +Expect(0, 8232, '\p{^Is LineSeparator}', ""); +Expect(0, 8232, '\P{Is LineSeparator}', ""); +Expect(1, 8232, '\P{^Is LineSeparator}', ""); +Expect(0, 8231, '\p{Is LineSeparator}', ""); +Expect(1, 8231, '\p{^Is LineSeparator}', ""); +Expect(1, 8231, '\P{Is LineSeparator}', ""); +Expect(0, 8231, '\P{^Is LineSeparator}', ""); +Error('\p{ ZL:=}'); +Error('\P{ ZL:=}'); +Expect(1, 8232, '\p{zl}', ""); +Expect(0, 8232, '\p{^zl}', ""); +Expect(0, 8232, '\P{zl}', ""); +Expect(1, 8232, '\P{^zl}', ""); +Expect(0, 8231, '\p{zl}', ""); +Expect(1, 8231, '\p{^zl}', ""); +Expect(1, 8231, '\P{zl}', ""); +Expect(0, 8231, '\P{^zl}', ""); +Expect(1, 8232, '\p{_ Zl}', ""); +Expect(0, 8232, '\p{^_ Zl}', ""); +Expect(0, 8232, '\P{_ Zl}', ""); +Expect(1, 8232, '\P{^_ Zl}', ""); +Expect(0, 8231, '\p{_ Zl}', ""); +Expect(1, 8231, '\p{^_ Zl}', ""); +Expect(1, 8231, '\P{_ Zl}', ""); +Expect(0, 8231, '\P{^_ Zl}', ""); +Error('\p{ IS zl/a/}'); +Error('\P{ IS zl/a/}'); +Expect(1, 8232, '\p{iszl}', ""); +Expect(0, 8232, '\p{^iszl}', ""); +Expect(0, 8232, '\P{iszl}', ""); +Expect(1, 8232, '\P{^iszl}', ""); +Expect(0, 8231, '\p{iszl}', ""); +Expect(1, 8231, '\p{^iszl}', ""); +Expect(1, 8231, '\P{iszl}', ""); +Expect(0, 8231, '\P{^iszl}', ""); +Expect(1, 8232, '\p{ _IS Zl}', ""); +Expect(0, 8232, '\p{^ _IS Zl}', ""); +Expect(0, 8232, '\P{ _IS Zl}', ""); +Expect(1, 8232, '\P{^ _IS Zl}', ""); +Expect(0, 8231, '\p{ _IS Zl}', ""); +Expect(1, 8231, '\p{^ _IS Zl}', ""); +Expect(1, 8231, '\P{ _IS Zl}', ""); +Expect(0, 8231, '\P{^ _IS Zl}', ""); +Error('\p{:= OL-chiki}'); +Error('\P{:= OL-chiki}'); +Expect(1, 7295, '\p{olchiki}', ""); +Expect(0, 7295, '\p{^olchiki}', ""); +Expect(0, 7295, '\P{olchiki}', ""); +Expect(1, 7295, '\P{^olchiki}', ""); +Expect(0, 7247, '\p{olchiki}', ""); +Expect(1, 7247, '\p{^olchiki}', ""); +Expect(1, 7247, '\P{olchiki}', ""); +Expect(0, 7247, '\P{^olchiki}', ""); +Expect(1, 7295, '\p{ OL Chiki}', ""); +Expect(0, 7295, '\p{^ OL Chiki}', ""); +Expect(0, 7295, '\P{ OL Chiki}', ""); +Expect(1, 7295, '\P{^ OL Chiki}', ""); +Expect(0, 7247, '\p{ OL Chiki}', ""); +Expect(1, 7247, '\p{^ OL Chiki}', ""); +Expect(1, 7247, '\P{ OL Chiki}', ""); +Expect(0, 7247, '\P{^ OL Chiki}', ""); +Error('\p{-:=Is-Ol Chiki}'); +Error('\P{-:=Is-Ol Chiki}'); +Expect(1, 7295, '\p{isolchiki}', ""); +Expect(0, 7295, '\p{^isolchiki}', ""); +Expect(0, 7295, '\P{isolchiki}', ""); +Expect(1, 7295, '\P{^isolchiki}', ""); +Expect(0, 7247, '\p{isolchiki}', ""); +Expect(1, 7247, '\p{^isolchiki}', ""); +Expect(1, 7247, '\P{isolchiki}', ""); +Expect(0, 7247, '\P{^isolchiki}', ""); +Expect(1, 7295, '\p{_-Is ol_Chiki}', ""); +Expect(0, 7295, '\p{^_-Is ol_Chiki}', ""); +Expect(0, 7295, '\P{_-Is ol_Chiki}', ""); +Expect(1, 7295, '\P{^_-Is ol_Chiki}', ""); +Expect(0, 7247, '\p{_-Is ol_Chiki}', ""); +Expect(1, 7247, '\p{^_-Is ol_Chiki}', ""); +Expect(1, 7247, '\P{_-Is ol_Chiki}', ""); +Expect(0, 7247, '\P{^_-Is ol_Chiki}', ""); +Error('\p{ Olck/a/}'); +Error('\P{ Olck/a/}'); +Expect(1, 7295, '\p{olck}', ""); +Expect(0, 7295, '\p{^olck}', ""); +Expect(0, 7295, '\P{olck}', ""); +Expect(1, 7295, '\P{^olck}', ""); +Expect(0, 7247, '\p{olck}', ""); +Expect(1, 7247, '\p{^olck}', ""); +Expect(1, 7247, '\P{olck}', ""); +Expect(0, 7247, '\P{^olck}', ""); +Expect(1, 7295, '\p{_olck}', ""); +Expect(0, 7295, '\p{^_olck}', ""); +Expect(0, 7295, '\P{_olck}', ""); +Expect(1, 7295, '\P{^_olck}', ""); +Expect(0, 7247, '\p{_olck}', ""); +Expect(1, 7247, '\p{^_olck}', ""); +Expect(1, 7247, '\P{_olck}', ""); +Expect(0, 7247, '\P{^_olck}', ""); +Error('\p{:= IsOLCK}'); +Error('\P{:= IsOLCK}'); +Expect(1, 7295, '\p{isolck}', ""); +Expect(0, 7295, '\p{^isolck}', ""); +Expect(0, 7295, '\P{isolck}', ""); +Expect(1, 7295, '\P{^isolck}', ""); +Expect(0, 7247, '\p{isolck}', ""); +Expect(1, 7247, '\p{^isolck}', ""); +Expect(1, 7247, '\P{isolck}', ""); +Expect(0, 7247, '\P{^isolck}', ""); +Expect(1, 7295, '\p{ -Is olck}', ""); +Expect(0, 7295, '\p{^ -Is olck}', ""); +Expect(0, 7295, '\P{ -Is olck}', ""); +Expect(1, 7295, '\P{^ -Is olck}', ""); +Expect(0, 7247, '\p{ -Is olck}', ""); +Expect(1, 7247, '\p{^ -Is olck}', ""); +Expect(1, 7247, '\P{ -Is olck}', ""); +Expect(0, 7247, '\P{^ -Is olck}', ""); +Error('\p{_ Thai:=}'); +Error('\P{_ Thai:=}'); +Expect(1, 3642, '\p{thai}', ""); +Expect(0, 3642, '\p{^thai}', ""); +Expect(0, 3642, '\P{thai}', ""); +Expect(1, 3642, '\P{^thai}', ""); +Expect(0, 3584, '\p{thai}', ""); +Expect(1, 3584, '\p{^thai}', ""); +Expect(1, 3584, '\P{thai}', ""); +Expect(0, 3584, '\P{^thai}', ""); +Expect(1, 3642, '\p{ THAI}', ""); +Expect(0, 3642, '\p{^ THAI}', ""); +Expect(0, 3642, '\P{ THAI}', ""); +Expect(1, 3642, '\P{^ THAI}', ""); +Expect(0, 3584, '\p{ THAI}', ""); +Expect(1, 3584, '\p{^ THAI}', ""); +Expect(1, 3584, '\P{ THAI}', ""); +Expect(0, 3584, '\P{^ THAI}', ""); +Error('\p{_:=is_thai}'); +Error('\P{_:=is_thai}'); +Expect(1, 3642, '\p{isthai}', ""); +Expect(0, 3642, '\p{^isthai}', ""); +Expect(0, 3642, '\P{isthai}', ""); +Expect(1, 3642, '\P{^isthai}', ""); +Expect(0, 3584, '\p{isthai}', ""); +Expect(1, 3584, '\p{^isthai}', ""); +Expect(1, 3584, '\P{isthai}', ""); +Expect(0, 3584, '\P{^isthai}', ""); +Expect(1, 3642, '\p{-IS THAI}', ""); +Expect(0, 3642, '\p{^-IS THAI}', ""); +Expect(0, 3642, '\P{-IS THAI}', ""); +Expect(1, 3642, '\P{^-IS THAI}', ""); +Expect(0, 3584, '\p{-IS THAI}', ""); +Expect(1, 3584, '\p{^-IS THAI}', ""); +Expect(1, 3584, '\P{-IS THAI}', ""); +Expect(0, 3584, '\P{^-IS THAI}', ""); +Error('\p{ -ASCII/a/}'); +Error('\P{ -ASCII/a/}'); +Expect(1, 7, '\p{ascii}', ""); +Expect(0, 7, '\p{^ascii}', ""); +Expect(0, 7, '\P{ascii}', ""); +Expect(1, 7, '\P{^ascii}', ""); +Expect(0, 256, '\p{ascii}', ""); +Expect(1, 256, '\p{^ascii}', ""); +Expect(1, 256, '\P{ascii}', ""); +Expect(0, 256, '\P{^ascii}', ""); +Expect(1, 7, '\p{_ ASCII}', ""); +Expect(0, 7, '\p{^_ ASCII}', ""); +Expect(0, 7, '\P{_ ASCII}', ""); +Expect(1, 7, '\P{^_ ASCII}', ""); +Expect(0, 256, '\p{_ ASCII}', ""); +Expect(1, 256, '\p{^_ ASCII}', ""); +Expect(1, 256, '\P{_ ASCII}', ""); +Expect(0, 256, '\P{^_ ASCII}', ""); +Error('\p{--IS-ASCII:=}'); +Error('\P{--IS-ASCII:=}'); +Expect(1, 7, '\p{isascii}', ""); +Expect(0, 7, '\p{^isascii}', ""); +Expect(0, 7, '\P{isascii}', ""); +Expect(1, 7, '\P{^isascii}', ""); +Expect(0, 256, '\p{isascii}', ""); +Expect(1, 256, '\p{^isascii}', ""); +Expect(1, 256, '\P{isascii}', ""); +Expect(0, 256, '\P{^isascii}', ""); +Expect(1, 7, '\p{ -IS-ASCII}', ""); +Expect(0, 7, '\p{^ -IS-ASCII}', ""); +Expect(0, 7, '\P{ -IS-ASCII}', ""); +Expect(1, 7, '\P{^ -IS-ASCII}', ""); +Expect(0, 256, '\p{ -IS-ASCII}', ""); +Expect(1, 256, '\p{^ -IS-ASCII}', ""); +Expect(1, 256, '\P{ -IS-ASCII}', ""); +Expect(0, 256, '\P{^ -IS-ASCII}', ""); +Error('\p{ BASIC/a/Latin}'); +Error('\P{ BASIC/a/Latin}'); +Expect(1, 7, '\p{basiclatin}', ""); +Expect(0, 7, '\p{^basiclatin}', ""); +Expect(0, 7, '\P{basiclatin}', ""); +Expect(1, 7, '\P{^basiclatin}', ""); +Expect(0, 256, '\p{basiclatin}', ""); +Expect(1, 256, '\p{^basiclatin}', ""); +Expect(1, 256, '\P{basiclatin}', ""); +Expect(0, 256, '\P{^basiclatin}', ""); +Expect(1, 7, '\p{ _BASIC Latin}', ""); +Expect(0, 7, '\p{^ _BASIC Latin}', ""); +Expect(0, 7, '\P{ _BASIC Latin}', ""); +Expect(1, 7, '\P{^ _BASIC Latin}', ""); +Expect(0, 256, '\p{ _BASIC Latin}', ""); +Expect(1, 256, '\p{^ _BASIC Latin}', ""); +Expect(1, 256, '\P{ _BASIC Latin}', ""); +Expect(0, 256, '\P{^ _BASIC Latin}', ""); +Error('\p{ IS Basic Latin/a/}'); +Error('\P{ IS Basic Latin/a/}'); +Expect(1, 7, '\p{isbasiclatin}', ""); +Expect(0, 7, '\p{^isbasiclatin}', ""); +Expect(0, 7, '\P{isbasiclatin}', ""); +Expect(1, 7, '\P{^isbasiclatin}', ""); +Expect(0, 256, '\p{isbasiclatin}', ""); +Expect(1, 256, '\p{^isbasiclatin}', ""); +Expect(1, 256, '\P{isbasiclatin}', ""); +Expect(0, 256, '\P{^isbasiclatin}', ""); +Expect(1, 7, '\p{ Is_BASIC Latin}', ""); +Expect(0, 7, '\p{^ Is_BASIC Latin}', ""); +Expect(0, 7, '\P{ Is_BASIC Latin}', ""); +Expect(1, 7, '\P{^ Is_BASIC Latin}', ""); +Expect(0, 256, '\p{ Is_BASIC Latin}', ""); +Expect(1, 256, '\p{^ Is_BASIC Latin}', ""); +Expect(1, 256, '\P{ Is_BASIC Latin}', ""); +Expect(0, 256, '\P{^ Is_BASIC Latin}', ""); +Error('\p{_ In-basic_latin:=}'); +Error('\P{_ In-basic_latin:=}'); +Expect(1, 7, '\p{inbasiclatin}', ""); +Expect(0, 7, '\p{^inbasiclatin}', ""); +Expect(0, 7, '\P{inbasiclatin}', ""); +Expect(1, 7, '\P{^inbasiclatin}', ""); +Expect(0, 256, '\p{inbasiclatin}', ""); +Expect(1, 256, '\p{^inbasiclatin}', ""); +Expect(1, 256, '\P{inbasiclatin}', ""); +Expect(0, 256, '\P{^inbasiclatin}', ""); +Expect(1, 7, '\p{- in BASIC latin}', ""); +Expect(0, 7, '\p{^- in BASIC latin}', ""); +Expect(0, 7, '\P{- in BASIC latin}', ""); +Expect(1, 7, '\P{^- in BASIC latin}', ""); +Expect(0, 256, '\p{- in BASIC latin}', ""); +Expect(1, 256, '\p{^- in BASIC latin}', ""); +Expect(1, 256, '\P{- in BASIC latin}', ""); +Expect(0, 256, '\P{^- in BASIC latin}', ""); +Error('\p{ /a/In ASCII}'); +Error('\P{ /a/In ASCII}'); +Expect(1, 7, '\p{inascii}', ""); +Expect(0, 7, '\p{^inascii}', ""); +Expect(0, 7, '\P{inascii}', ""); +Expect(1, 7, '\P{^inascii}', ""); +Expect(0, 256, '\p{inascii}', ""); +Expect(1, 256, '\p{^inascii}', ""); +Expect(1, 256, '\P{inascii}', ""); +Expect(0, 256, '\P{^inascii}', ""); +Expect(1, 7, '\p{ In ASCII}', ""); +Expect(0, 7, '\p{^ In ASCII}', ""); +Expect(0, 7, '\P{ In ASCII}', ""); +Expect(1, 7, '\P{^ In ASCII}', ""); +Expect(0, 256, '\p{ In ASCII}', ""); +Expect(1, 256, '\p{^ In ASCII}', ""); +Expect(1, 256, '\P{ In ASCII}', ""); +Expect(0, 256, '\P{^ In ASCII}', ""); +Error('\p{ YIsyllables/a/}'); +Error('\P{ YIsyllables/a/}'); +Expect(1, 42127, '\p{yisyllables}', ""); +Expect(0, 42127, '\p{^yisyllables}', ""); +Expect(0, 42127, '\P{yisyllables}', ""); +Expect(1, 42127, '\P{^yisyllables}', ""); +Expect(0, 40959, '\p{yisyllables}', ""); +Expect(1, 40959, '\p{^yisyllables}', ""); +Expect(1, 40959, '\P{yisyllables}', ""); +Expect(0, 40959, '\P{^yisyllables}', ""); +Expect(1, 42127, '\p{- YISyllables}', ""); +Expect(0, 42127, '\p{^- YISyllables}', ""); +Expect(0, 42127, '\P{- YISyllables}', ""); +Expect(1, 42127, '\P{^- YISyllables}', ""); +Expect(0, 40959, '\p{- YISyllables}', ""); +Expect(1, 40959, '\p{^- YISyllables}', ""); +Expect(1, 40959, '\P{- YISyllables}', ""); +Expect(0, 40959, '\P{^- YISyllables}', ""); +Error('\p{- Is:=YI Syllables}'); +Error('\P{- Is:=YI Syllables}'); +Expect(1, 42127, '\p{isyisyllables}', ""); +Expect(0, 42127, '\p{^isyisyllables}', ""); +Expect(0, 42127, '\P{isyisyllables}', ""); +Expect(1, 42127, '\P{^isyisyllables}', ""); +Expect(0, 40959, '\p{isyisyllables}', ""); +Expect(1, 40959, '\p{^isyisyllables}', ""); +Expect(1, 40959, '\P{isyisyllables}', ""); +Expect(0, 40959, '\P{^isyisyllables}', ""); +Expect(1, 42127, '\p{ Is Yi_Syllables}', ""); +Expect(0, 42127, '\p{^ Is Yi_Syllables}', ""); +Expect(0, 42127, '\P{ Is Yi_Syllables}', ""); +Expect(1, 42127, '\P{^ Is Yi_Syllables}', ""); +Expect(0, 40959, '\p{ Is Yi_Syllables}', ""); +Expect(1, 40959, '\p{^ Is Yi_Syllables}', ""); +Expect(1, 40959, '\P{ Is Yi_Syllables}', ""); +Expect(0, 40959, '\P{^ Is Yi_Syllables}', ""); +Error('\p{/a/IN_Yi Syllables}'); +Error('\P{/a/IN_Yi Syllables}'); +Expect(1, 42127, '\p{inyisyllables}', ""); +Expect(0, 42127, '\p{^inyisyllables}', ""); +Expect(0, 42127, '\P{inyisyllables}', ""); +Expect(1, 42127, '\P{^inyisyllables}', ""); +Expect(0, 40959, '\p{inyisyllables}', ""); +Expect(1, 40959, '\p{^inyisyllables}', ""); +Expect(1, 40959, '\P{inyisyllables}', ""); +Expect(0, 40959, '\P{^inyisyllables}', ""); +Expect(1, 42127, '\p{ _In yi syllables}', ""); +Expect(0, 42127, '\p{^ _In yi syllables}', ""); +Expect(0, 42127, '\P{ _In yi syllables}', ""); +Expect(1, 42127, '\P{^ _In yi syllables}', ""); +Expect(0, 40959, '\p{ _In yi syllables}', ""); +Expect(1, 40959, '\p{^ _In yi syllables}', ""); +Expect(1, 40959, '\P{ _In yi syllables}', ""); +Expect(0, 40959, '\P{^ _In yi syllables}', ""); +Error('\p{:= punct}'); +Error('\P{:= punct}'); +Expect(1, 35, '\p{punct}', ""); +Expect(0, 35, '\p{^punct}', ""); +Expect(0, 35, '\P{punct}', ""); +Expect(1, 35, '\P{^punct}', ""); +Expect(0, 32, '\p{punct}', ""); +Expect(1, 32, '\p{^punct}', ""); +Expect(1, 32, '\P{punct}', ""); +Expect(0, 32, '\P{^punct}', ""); +Expect(1, 35, '\p{ Punct}', ""); +Expect(0, 35, '\p{^ Punct}', ""); +Expect(0, 35, '\P{ Punct}', ""); +Expect(1, 35, '\P{^ Punct}', ""); +Expect(0, 32, '\p{ Punct}', ""); +Expect(1, 32, '\p{^ Punct}', ""); +Expect(1, 32, '\P{ Punct}', ""); +Expect(0, 32, '\P{^ Punct}', ""); +Error('\p{/a/ ispunct}'); +Error('\P{/a/ ispunct}'); +Expect(1, 35, '\p{ispunct}', ""); +Expect(0, 35, '\p{^ispunct}', ""); +Expect(0, 35, '\P{ispunct}', ""); +Expect(1, 35, '\P{^ispunct}', ""); +Expect(0, 32, '\p{ispunct}', ""); +Expect(1, 32, '\p{^ispunct}', ""); +Expect(1, 32, '\P{ispunct}', ""); +Expect(0, 32, '\P{^ispunct}', ""); +Expect(1, 35, '\p{-IS_PUNCT}', ""); +Expect(0, 35, '\p{^-IS_PUNCT}', ""); +Expect(0, 35, '\P{-IS_PUNCT}', ""); +Expect(1, 35, '\P{^-IS_PUNCT}', ""); +Expect(0, 32, '\p{-IS_PUNCT}', ""); +Expect(1, 32, '\p{^-IS_PUNCT}', ""); +Expect(1, 32, '\P{-IS_PUNCT}', ""); +Expect(0, 32, '\P{^-IS_PUNCT}', ""); +Error('\p{:=_ PUNCTUATION}'); +Error('\P{:=_ PUNCTUATION}'); +Expect(1, 35, '\p{punctuation}', ""); +Expect(0, 35, '\p{^punctuation}', ""); +Expect(0, 35, '\P{punctuation}', ""); +Expect(1, 35, '\P{^punctuation}', ""); +Expect(0, 32, '\p{punctuation}', ""); +Expect(1, 32, '\p{^punctuation}', ""); +Expect(1, 32, '\P{punctuation}', ""); +Expect(0, 32, '\P{^punctuation}', ""); +Expect(1, 35, '\p{ Punctuation}', ""); +Expect(0, 35, '\p{^ Punctuation}', ""); +Expect(0, 35, '\P{ Punctuation}', ""); +Expect(1, 35, '\P{^ Punctuation}', ""); +Expect(0, 32, '\p{ Punctuation}', ""); +Expect(1, 32, '\p{^ Punctuation}', ""); +Expect(1, 32, '\P{ Punctuation}', ""); +Expect(0, 32, '\P{^ Punctuation}', ""); +Error('\p{-:=Is Punctuation}'); +Error('\P{-:=Is Punctuation}'); +Expect(1, 35, '\p{ispunctuation}', ""); +Expect(0, 35, '\p{^ispunctuation}', ""); +Expect(0, 35, '\P{ispunctuation}', ""); +Expect(1, 35, '\P{^ispunctuation}', ""); +Expect(0, 32, '\p{ispunctuation}', ""); +Expect(1, 32, '\p{^ispunctuation}', ""); +Expect(1, 32, '\P{ispunctuation}', ""); +Expect(0, 32, '\P{^ispunctuation}', ""); +Expect(1, 35, '\p{ is_PUNCTUATION}', ""); +Expect(0, 35, '\p{^ is_PUNCTUATION}', ""); +Expect(0, 35, '\P{ is_PUNCTUATION}', ""); +Expect(1, 35, '\P{^ is_PUNCTUATION}', ""); +Expect(0, 32, '\p{ is_PUNCTUATION}', ""); +Expect(1, 32, '\p{^ is_PUNCTUATION}', ""); +Expect(1, 32, '\P{ is_PUNCTUATION}', ""); +Expect(0, 32, '\P{^ is_PUNCTUATION}', ""); +Error('\p{/a/ -P}'); +Error('\P{/a/ -P}'); +Expect(1, 35, '\p{p}', ""); +Expect(0, 35, '\p{^p}', ""); +Expect(0, 35, '\P{p}', ""); +Expect(1, 35, '\P{^p}', ""); +Expect(0, 32, '\p{p}', ""); +Expect(1, 32, '\p{^p}', ""); +Expect(1, 32, '\P{p}', ""); +Expect(0, 32, '\P{^p}', ""); +Expect(1, 35, '\p{ P}', ""); +Expect(0, 35, '\p{^ P}', ""); +Expect(0, 35, '\P{ P}', ""); +Expect(1, 35, '\P{^ P}', ""); +Expect(0, 32, '\p{ P}', ""); +Expect(1, 32, '\p{^ P}', ""); +Expect(1, 32, '\P{ P}', ""); +Expect(0, 32, '\P{^ P}', ""); +Error('\p{ -Is P:=}'); +Error('\P{ -Is P:=}'); +Expect(1, 35, '\p{isp}', ""); +Expect(0, 35, '\p{^isp}', ""); +Expect(0, 35, '\P{isp}', ""); +Expect(1, 35, '\P{^isp}', ""); +Expect(0, 32, '\p{isp}', ""); +Expect(1, 32, '\p{^isp}', ""); +Expect(1, 32, '\P{isp}', ""); +Expect(0, 32, '\P{^isp}', ""); +Expect(1, 35, '\p{ _is p}', ""); +Expect(0, 35, '\p{^ _is p}', ""); +Expect(0, 35, '\P{ _is p}', ""); +Expect(1, 35, '\P{^ _is p}', ""); +Expect(0, 32, '\p{ _is p}', ""); +Expect(1, 32, '\p{^ _is p}', ""); +Expect(1, 32, '\P{ _is p}', ""); +Expect(0, 32, '\P{^ _is p}', ""); +Error('\p{Expands_On_NFD}'); +Error('\P{Expands_On_NFD}'); +Error('\p{Is_Expands_On_NFD}'); +Error('\P{Is_Expands_On_NFD}'); +Error('\p{XO_NFD}'); +Error('\P{XO_NFD}'); +Error('\p{Is_XO_NFD}'); +Error('\P{Is_XO_NFD}'); +Error('\p{ SUPERSCRIPTS and_subscripts:=}'); +Error('\P{ SUPERSCRIPTS and_subscripts:=}'); +Expect(1, 8351, '\p{superscriptsandsubscripts}', ""); +Expect(0, 8351, '\p{^superscriptsandsubscripts}', ""); +Expect(0, 8351, '\P{superscriptsandsubscripts}', ""); +Expect(1, 8351, '\P{^superscriptsandsubscripts}', ""); +Expect(0, 8303, '\p{superscriptsandsubscripts}', ""); +Expect(1, 8303, '\p{^superscriptsandsubscripts}', ""); +Expect(1, 8303, '\P{superscriptsandsubscripts}', ""); +Expect(0, 8303, '\P{^superscriptsandsubscripts}', ""); +Expect(1, 8351, '\p{-_Superscripts_ANDSubscripts}', ""); +Expect(0, 8351, '\p{^-_Superscripts_ANDSubscripts}', ""); +Expect(0, 8351, '\P{-_Superscripts_ANDSubscripts}', ""); +Expect(1, 8351, '\P{^-_Superscripts_ANDSubscripts}', ""); +Expect(0, 8303, '\p{-_Superscripts_ANDSubscripts}', ""); +Expect(1, 8303, '\p{^-_Superscripts_ANDSubscripts}', ""); +Expect(1, 8303, '\P{-_Superscripts_ANDSubscripts}', ""); +Expect(0, 8303, '\P{^-_Superscripts_ANDSubscripts}', ""); +Error('\p{/a/IS superscriptsAnd_SUBSCRIPTS}'); +Error('\P{/a/IS superscriptsAnd_SUBSCRIPTS}'); +Expect(1, 8351, '\p{issuperscriptsandsubscripts}', ""); +Expect(0, 8351, '\p{^issuperscriptsandsubscripts}', ""); +Expect(0, 8351, '\P{issuperscriptsandsubscripts}', ""); +Expect(1, 8351, '\P{^issuperscriptsandsubscripts}', ""); +Expect(0, 8303, '\p{issuperscriptsandsubscripts}', ""); +Expect(1, 8303, '\p{^issuperscriptsandsubscripts}', ""); +Expect(1, 8303, '\P{issuperscriptsandsubscripts}', ""); +Expect(0, 8303, '\P{^issuperscriptsandsubscripts}', ""); +Expect(1, 8351, '\p{ Is-Superscriptsand subscripts}', ""); +Expect(0, 8351, '\p{^ Is-Superscriptsand subscripts}', ""); +Expect(0, 8351, '\P{ Is-Superscriptsand subscripts}', ""); +Expect(1, 8351, '\P{^ Is-Superscriptsand subscripts}', ""); +Expect(0, 8303, '\p{ Is-Superscriptsand subscripts}', ""); +Expect(1, 8303, '\p{^ Is-Superscriptsand subscripts}', ""); +Expect(1, 8303, '\P{ Is-Superscriptsand subscripts}', ""); +Expect(0, 8303, '\P{^ Is-Superscriptsand subscripts}', ""); +Error('\p{:=In_Superscripts AND subscripts}'); +Error('\P{:=In_Superscripts AND subscripts}'); +Expect(1, 8351, '\p{insuperscriptsandsubscripts}', ""); +Expect(0, 8351, '\p{^insuperscriptsandsubscripts}', ""); +Expect(0, 8351, '\P{insuperscriptsandsubscripts}', ""); +Expect(1, 8351, '\P{^insuperscriptsandsubscripts}', ""); +Expect(0, 8303, '\p{insuperscriptsandsubscripts}', ""); +Expect(1, 8303, '\p{^insuperscriptsandsubscripts}', ""); +Expect(1, 8303, '\P{insuperscriptsandsubscripts}', ""); +Expect(0, 8303, '\P{^insuperscriptsandsubscripts}', ""); +Expect(1, 8351, '\p{-IN-Superscripts And_Subscripts}', ""); +Expect(0, 8351, '\p{^-IN-Superscripts And_Subscripts}', ""); +Expect(0, 8351, '\P{-IN-Superscripts And_Subscripts}', ""); +Expect(1, 8351, '\P{^-IN-Superscripts And_Subscripts}', ""); +Expect(0, 8303, '\p{-IN-Superscripts And_Subscripts}', ""); +Expect(1, 8303, '\p{^-IN-Superscripts And_Subscripts}', ""); +Expect(1, 8303, '\P{-IN-Superscripts And_Subscripts}', ""); +Expect(0, 8303, '\P{^-IN-Superscripts And_Subscripts}', ""); +Error('\p{-:=In BALINESE}'); +Error('\P{-:=In BALINESE}'); +Expect(1, 7039, '\p{inbalinese}', ""); +Expect(0, 7039, '\p{^inbalinese}', ""); +Expect(0, 7039, '\P{inbalinese}', ""); +Expect(1, 7039, '\P{^inbalinese}', ""); +Expect(0, 6911, '\p{inbalinese}', ""); +Expect(1, 6911, '\p{^inbalinese}', ""); +Expect(1, 6911, '\P{inbalinese}', ""); +Expect(0, 6911, '\P{^inbalinese}', ""); +Expect(1, 7039, '\p{_in-Balinese}', ""); +Expect(0, 7039, '\p{^_in-Balinese}', ""); +Expect(0, 7039, '\P{_in-Balinese}', ""); +Expect(1, 7039, '\P{^_in-Balinese}', ""); +Expect(0, 6911, '\p{_in-Balinese}', ""); +Expect(1, 6911, '\p{^_in-Balinese}', ""); +Expect(1, 6911, '\P{_in-Balinese}', ""); +Expect(0, 6911, '\P{^_in-Balinese}', ""); +Error('\p{:=__DEPRECATED}'); +Error('\P{:=__DEPRECATED}'); +Expect(1, 833, '\p{deprecated}', ""); +Expect(0, 833, '\p{^deprecated}', ""); +Expect(0, 833, '\P{deprecated}', ""); +Expect(1, 833, '\P{^deprecated}', ""); +Expect(0, 831, '\p{deprecated}', ""); +Expect(1, 831, '\p{^deprecated}', ""); +Expect(1, 831, '\P{deprecated}', ""); +Expect(0, 831, '\P{^deprecated}', ""); +Expect(1, 833, '\p{_DEPRECATED}', ""); +Expect(0, 833, '\p{^_DEPRECATED}', ""); +Expect(0, 833, '\P{_DEPRECATED}', ""); +Expect(1, 833, '\P{^_DEPRECATED}', ""); +Expect(0, 831, '\p{_DEPRECATED}', ""); +Expect(1, 831, '\p{^_DEPRECATED}', ""); +Expect(1, 831, '\P{_DEPRECATED}', ""); +Expect(0, 831, '\P{^_DEPRECATED}', ""); +Error('\p{ -IsDeprecated/a/}'); +Error('\P{ -IsDeprecated/a/}'); +Expect(1, 833, '\p{isdeprecated}', ""); +Expect(0, 833, '\p{^isdeprecated}', ""); +Expect(0, 833, '\P{isdeprecated}', ""); +Expect(1, 833, '\P{^isdeprecated}', ""); +Expect(0, 831, '\p{isdeprecated}', ""); +Expect(1, 831, '\p{^isdeprecated}', ""); +Expect(1, 831, '\P{isdeprecated}', ""); +Expect(0, 831, '\P{^isdeprecated}', ""); +Expect(1, 833, '\p{ ISDeprecated}', ""); +Expect(0, 833, '\p{^ ISDeprecated}', ""); +Expect(0, 833, '\P{ ISDeprecated}', ""); +Expect(1, 833, '\P{^ ISDeprecated}', ""); +Expect(0, 831, '\p{ ISDeprecated}', ""); +Expect(1, 831, '\p{^ ISDeprecated}', ""); +Expect(1, 831, '\P{ ISDeprecated}', ""); +Expect(0, 831, '\P{^ ISDeprecated}', ""); +Error('\p{:=Dep}'); +Error('\P{:=Dep}'); +Expect(1, 833, '\p{dep}', ""); +Expect(0, 833, '\p{^dep}', ""); +Expect(0, 833, '\P{dep}', ""); +Expect(1, 833, '\P{^dep}', ""); +Expect(0, 831, '\p{dep}', ""); +Expect(1, 831, '\p{^dep}', ""); +Expect(1, 831, '\P{dep}', ""); +Expect(0, 831, '\P{^dep}', ""); +Expect(1, 833, '\p{ -DEP}', ""); +Expect(0, 833, '\p{^ -DEP}', ""); +Expect(0, 833, '\P{ -DEP}', ""); +Expect(1, 833, '\P{^ -DEP}', ""); +Expect(0, 831, '\p{ -DEP}', ""); +Expect(1, 831, '\p{^ -DEP}', ""); +Expect(1, 831, '\P{ -DEP}', ""); +Expect(0, 831, '\P{^ -DEP}', ""); +Error('\p{Is/a/DEP}'); +Error('\P{Is/a/DEP}'); +Expect(1, 833, '\p{isdep}', ""); +Expect(0, 833, '\p{^isdep}', ""); +Expect(0, 833, '\P{isdep}', ""); +Expect(1, 833, '\P{^isdep}', ""); +Expect(0, 831, '\p{isdep}', ""); +Expect(1, 831, '\p{^isdep}', ""); +Expect(1, 831, '\P{isdep}', ""); +Expect(0, 831, '\P{^isdep}', ""); +Expect(1, 833, '\p{ Is-Dep}', ""); +Expect(0, 833, '\p{^ Is-Dep}', ""); +Expect(0, 833, '\P{ Is-Dep}', ""); +Expect(1, 833, '\P{^ Is-Dep}', ""); +Expect(0, 831, '\p{ Is-Dep}', ""); +Expect(1, 831, '\p{^ Is-Dep}', ""); +Expect(1, 831, '\P{ Is-Dep}', ""); +Expect(0, 831, '\P{^ Is-Dep}', ""); +Error('\p{:=-Myanmar}'); +Error('\P{:=-Myanmar}'); +Expect(1, 4249, '\p{myanmar}', ""); +Expect(0, 4249, '\p{^myanmar}', ""); +Expect(0, 4249, '\P{myanmar}', ""); +Expect(1, 4249, '\P{^myanmar}', ""); +Expect(0, 4095, '\p{myanmar}', ""); +Expect(1, 4095, '\p{^myanmar}', ""); +Expect(1, 4095, '\P{myanmar}', ""); +Expect(0, 4095, '\P{^myanmar}', ""); +Expect(1, 4249, '\p{- Myanmar}', ""); +Expect(0, 4249, '\p{^- Myanmar}', ""); +Expect(0, 4249, '\P{- Myanmar}', ""); +Expect(1, 4249, '\P{^- Myanmar}', ""); +Expect(0, 4095, '\p{- Myanmar}', ""); +Expect(1, 4095, '\p{^- Myanmar}', ""); +Expect(1, 4095, '\P{- Myanmar}', ""); +Expect(0, 4095, '\P{^- Myanmar}', ""); +Error('\p{ IS myanmar/a/}'); +Error('\P{ IS myanmar/a/}'); +Expect(1, 4249, '\p{ismyanmar}', ""); +Expect(0, 4249, '\p{^ismyanmar}', ""); +Expect(0, 4249, '\P{ismyanmar}', ""); +Expect(1, 4249, '\P{^ismyanmar}', ""); +Expect(0, 4095, '\p{ismyanmar}', ""); +Expect(1, 4095, '\p{^ismyanmar}', ""); +Expect(1, 4095, '\P{ismyanmar}', ""); +Expect(0, 4095, '\P{^ismyanmar}', ""); +Expect(1, 4249, '\p{_Is-MYANMAR}', ""); +Expect(0, 4249, '\p{^_Is-MYANMAR}', ""); +Expect(0, 4249, '\P{_Is-MYANMAR}', ""); +Expect(1, 4249, '\P{^_Is-MYANMAR}', ""); +Expect(0, 4095, '\p{_Is-MYANMAR}', ""); +Expect(1, 4095, '\p{^_Is-MYANMAR}', ""); +Expect(1, 4095, '\P{_Is-MYANMAR}', ""); +Expect(0, 4095, '\P{^_Is-MYANMAR}', ""); +Error('\p{ MYMR:=}'); +Error('\P{ MYMR:=}'); +Expect(1, 4249, '\p{mymr}', ""); +Expect(0, 4249, '\p{^mymr}', ""); +Expect(0, 4249, '\P{mymr}', ""); +Expect(1, 4249, '\P{^mymr}', ""); +Expect(0, 4095, '\p{mymr}', ""); +Expect(1, 4095, '\p{^mymr}', ""); +Expect(1, 4095, '\P{mymr}', ""); +Expect(0, 4095, '\P{^mymr}', ""); +Expect(1, 4249, '\p{ MYMR}', ""); +Expect(0, 4249, '\p{^ MYMR}', ""); +Expect(0, 4249, '\P{ MYMR}', ""); +Expect(1, 4249, '\P{^ MYMR}', ""); +Expect(0, 4095, '\p{ MYMR}', ""); +Expect(1, 4095, '\p{^ MYMR}', ""); +Expect(1, 4095, '\P{ MYMR}', ""); +Expect(0, 4095, '\P{^ MYMR}', ""); +Error('\p{:= IS_Mymr}'); +Error('\P{:= IS_Mymr}'); +Expect(1, 4249, '\p{ismymr}', ""); +Expect(0, 4249, '\p{^ismymr}', ""); +Expect(0, 4249, '\P{ismymr}', ""); +Expect(1, 4249, '\P{^ismymr}', ""); +Expect(0, 4095, '\p{ismymr}', ""); +Expect(1, 4095, '\p{^ismymr}', ""); +Expect(1, 4095, '\P{ismymr}', ""); +Expect(0, 4095, '\P{^ismymr}', ""); +Expect(1, 4249, '\p{__Is Mymr}', ""); +Expect(0, 4249, '\p{^__Is Mymr}', ""); +Expect(0, 4249, '\P{__Is Mymr}', ""); +Expect(1, 4249, '\P{^__Is Mymr}', ""); +Expect(0, 4095, '\p{__Is Mymr}', ""); +Expect(1, 4095, '\p{^__Is Mymr}', ""); +Expect(1, 4095, '\P{__Is Mymr}', ""); +Expect(0, 4095, '\P{^__Is Mymr}', ""); +Error('\p{:=initial-Punctuation}'); +Error('\P{:=initial-Punctuation}'); +Expect(1, 8216, '\p{initialpunctuation}', ""); +Expect(0, 8216, '\p{^initialpunctuation}', ""); +Expect(0, 8216, '\P{initialpunctuation}', ""); +Expect(1, 8216, '\P{^initialpunctuation}', ""); +Expect(0, 7, '\p{initialpunctuation}', ""); +Expect(1, 7, '\p{^initialpunctuation}', ""); +Expect(1, 7, '\P{initialpunctuation}', ""); +Expect(0, 7, '\P{^initialpunctuation}', ""); +Expect(1, 8216, '\p{_Initial-punctuation}', ""); +Expect(0, 8216, '\p{^_Initial-punctuation}', ""); +Expect(0, 8216, '\P{_Initial-punctuation}', ""); +Expect(1, 8216, '\P{^_Initial-punctuation}', ""); +Expect(0, 7, '\p{_Initial-punctuation}', ""); +Expect(1, 7, '\p{^_Initial-punctuation}', ""); +Expect(1, 7, '\P{_Initial-punctuation}', ""); +Expect(0, 7, '\P{^_Initial-punctuation}', ""); +Error('\p{- IS-Initial Punctuation:=}'); +Error('\P{- IS-Initial Punctuation:=}'); +Expect(1, 8216, '\p{isinitialpunctuation}', ""); +Expect(0, 8216, '\p{^isinitialpunctuation}', ""); +Expect(0, 8216, '\P{isinitialpunctuation}', ""); +Expect(1, 8216, '\P{^isinitialpunctuation}', ""); +Expect(0, 7, '\p{isinitialpunctuation}', ""); +Expect(1, 7, '\p{^isinitialpunctuation}', ""); +Expect(1, 7, '\P{isinitialpunctuation}', ""); +Expect(0, 7, '\P{^isinitialpunctuation}', ""); +Expect(1, 8216, '\p{-is-initial-PUNCTUATION}', ""); +Expect(0, 8216, '\p{^-is-initial-PUNCTUATION}', ""); +Expect(0, 8216, '\P{-is-initial-PUNCTUATION}', ""); +Expect(1, 8216, '\P{^-is-initial-PUNCTUATION}', ""); +Expect(0, 7, '\p{-is-initial-PUNCTUATION}', ""); +Expect(1, 7, '\p{^-is-initial-PUNCTUATION}', ""); +Expect(1, 7, '\P{-is-initial-PUNCTUATION}', ""); +Expect(0, 7, '\P{^-is-initial-PUNCTUATION}', ""); +Error('\p{ _Pi/a/}'); +Error('\P{ _Pi/a/}'); +Expect(1, 8216, '\p{pi}', ""); +Expect(0, 8216, '\p{^pi}', ""); +Expect(0, 8216, '\P{pi}', ""); +Expect(1, 8216, '\P{^pi}', ""); +Expect(0, 7, '\p{pi}', ""); +Expect(1, 7, '\p{^pi}', ""); +Expect(1, 7, '\P{pi}', ""); +Expect(0, 7, '\P{^pi}', ""); +Expect(1, 8216, '\p{ _PI}', ""); +Expect(0, 8216, '\p{^ _PI}', ""); +Expect(0, 8216, '\P{ _PI}', ""); +Expect(1, 8216, '\P{^ _PI}', ""); +Expect(0, 7, '\p{ _PI}', ""); +Expect(1, 7, '\p{^ _PI}', ""); +Expect(1, 7, '\P{ _PI}', ""); +Expect(0, 7, '\P{^ _PI}', ""); +Error('\p{-_Is:=PI}'); +Error('\P{-_Is:=PI}'); +Expect(1, 8216, '\p{ispi}', ""); +Expect(0, 8216, '\p{^ispi}', ""); +Expect(0, 8216, '\P{ispi}', ""); +Expect(1, 8216, '\P{^ispi}', ""); +Expect(0, 7, '\p{ispi}', ""); +Expect(1, 7, '\p{^ispi}', ""); +Expect(1, 7, '\P{ispi}', ""); +Expect(0, 7, '\P{^ispi}', ""); +Expect(1, 8216, '\p{__Is_PI}', ""); +Expect(0, 8216, '\p{^__Is_PI}', ""); +Expect(0, 8216, '\P{__Is_PI}', ""); +Expect(1, 8216, '\P{^__Is_PI}', ""); +Expect(0, 7, '\p{__Is_PI}', ""); +Expect(1, 7, '\p{^__Is_PI}', ""); +Expect(1, 7, '\P{__Is_PI}', ""); +Expect(0, 7, '\P{^__Is_PI}', ""); +Error('\p{ Common:=}'); +Error('\P{ Common:=}'); +Expect(1, 64, '\p{common}', ""); +Expect(0, 64, '\p{^common}', ""); +Expect(0, 64, '\P{common}', ""); +Expect(1, 64, '\P{^common}', ""); +Expect(0, 90, '\p{common}', ""); +Expect(1, 90, '\p{^common}', ""); +Expect(1, 90, '\P{common}', ""); +Expect(0, 90, '\P{^common}', ""); +Expect(1, 64, '\p{- Common}', ""); +Expect(0, 64, '\p{^- Common}', ""); +Expect(0, 64, '\P{- Common}', ""); +Expect(1, 64, '\P{^- Common}', ""); +Expect(0, 90, '\p{- Common}', ""); +Expect(1, 90, '\p{^- Common}', ""); +Expect(1, 90, '\P{- Common}', ""); +Expect(0, 90, '\P{^- Common}', ""); +Error('\p{ -ISCommon:=}'); +Error('\P{ -ISCommon:=}'); +Expect(1, 64, '\p{iscommon}', ""); +Expect(0, 64, '\p{^iscommon}', ""); +Expect(0, 64, '\P{iscommon}', ""); +Expect(1, 64, '\P{^iscommon}', ""); +Expect(0, 90, '\p{iscommon}', ""); +Expect(1, 90, '\p{^iscommon}', ""); +Expect(1, 90, '\P{iscommon}', ""); +Expect(0, 90, '\P{^iscommon}', ""); +Expect(1, 64, '\p{ is Common}', ""); +Expect(0, 64, '\p{^ is Common}', ""); +Expect(0, 64, '\P{ is Common}', ""); +Expect(1, 64, '\P{^ is Common}', ""); +Expect(0, 90, '\p{ is Common}', ""); +Expect(1, 90, '\p{^ is Common}', ""); +Expect(1, 90, '\P{ is Common}', ""); +Expect(0, 90, '\P{^ is Common}', ""); +Error('\p{ zyyy:=}'); +Error('\P{ zyyy:=}'); +Expect(1, 64, '\p{zyyy}', ""); +Expect(0, 64, '\p{^zyyy}', ""); +Expect(0, 64, '\P{zyyy}', ""); +Expect(1, 64, '\P{^zyyy}', ""); +Expect(0, 90, '\p{zyyy}', ""); +Expect(1, 90, '\p{^zyyy}', ""); +Expect(1, 90, '\P{zyyy}', ""); +Expect(0, 90, '\P{^zyyy}', ""); +Expect(1, 64, '\p{ ZYYY}', ""); +Expect(0, 64, '\p{^ ZYYY}', ""); +Expect(0, 64, '\P{ ZYYY}', ""); +Expect(1, 64, '\P{^ ZYYY}', ""); +Expect(0, 90, '\p{ ZYYY}', ""); +Expect(1, 90, '\p{^ ZYYY}', ""); +Expect(1, 90, '\P{ ZYYY}', ""); +Expect(0, 90, '\P{^ ZYYY}', ""); +Error('\p{ IS_Zyyy/a/}'); +Error('\P{ IS_Zyyy/a/}'); +Expect(1, 64, '\p{iszyyy}', ""); +Expect(0, 64, '\p{^iszyyy}', ""); +Expect(0, 64, '\P{iszyyy}', ""); +Expect(1, 64, '\P{^iszyyy}', ""); +Expect(0, 90, '\p{iszyyy}', ""); +Expect(1, 90, '\p{^iszyyy}', ""); +Expect(1, 90, '\P{iszyyy}', ""); +Expect(0, 90, '\P{^iszyyy}', ""); +Expect(1, 64, '\p{_isZYYY}', ""); +Expect(0, 64, '\p{^_isZYYY}', ""); +Expect(0, 64, '\P{_isZYYY}', ""); +Expect(1, 64, '\P{^_isZYYY}', ""); +Expect(0, 90, '\p{_isZYYY}', ""); +Expect(1, 90, '\p{^_isZYYY}', ""); +Expect(1, 90, '\P{_isZYYY}', ""); +Expect(0, 90, '\P{^_isZYYY}', ""); +Error('\p{ HANGUL_Jamo/a/}'); +Error('\P{ HANGUL_Jamo/a/}'); +Expect(1, 4607, '\p{hanguljamo}', ""); +Expect(0, 4607, '\p{^hanguljamo}', ""); +Expect(0, 4607, '\P{hanguljamo}', ""); +Expect(1, 4607, '\P{^hanguljamo}', ""); +Expect(0, 4351, '\p{hanguljamo}', ""); +Expect(1, 4351, '\p{^hanguljamo}', ""); +Expect(1, 4351, '\P{hanguljamo}', ""); +Expect(0, 4351, '\P{^hanguljamo}', ""); +Expect(1, 4607, '\p{- hangul_Jamo}', ""); +Expect(0, 4607, '\p{^- hangul_Jamo}', ""); +Expect(0, 4607, '\P{- hangul_Jamo}', ""); +Expect(1, 4607, '\P{^- hangul_Jamo}', ""); +Expect(0, 4351, '\p{- hangul_Jamo}', ""); +Expect(1, 4351, '\p{^- hangul_Jamo}', ""); +Expect(1, 4351, '\P{- hangul_Jamo}', ""); +Expect(0, 4351, '\P{^- hangul_Jamo}', ""); +Error('\p{-/a/ISHangul Jamo}'); +Error('\P{-/a/ISHangul Jamo}'); +Expect(1, 4607, '\p{ishanguljamo}', ""); +Expect(0, 4607, '\p{^ishanguljamo}', ""); +Expect(0, 4607, '\P{ishanguljamo}', ""); +Expect(1, 4607, '\P{^ishanguljamo}', ""); +Expect(0, 4351, '\p{ishanguljamo}', ""); +Expect(1, 4351, '\p{^ishanguljamo}', ""); +Expect(1, 4351, '\P{ishanguljamo}', ""); +Expect(0, 4351, '\P{^ishanguljamo}', ""); +Expect(1, 4607, '\p{-_is Hangul JAMO}', ""); +Expect(0, 4607, '\p{^-_is Hangul JAMO}', ""); +Expect(0, 4607, '\P{-_is Hangul JAMO}', ""); +Expect(1, 4607, '\P{^-_is Hangul JAMO}', ""); +Expect(0, 4351, '\p{-_is Hangul JAMO}', ""); +Expect(1, 4351, '\p{^-_is Hangul JAMO}', ""); +Expect(1, 4351, '\P{-_is Hangul JAMO}', ""); +Expect(0, 4351, '\P{^-_is Hangul JAMO}', ""); +Error('\p{/a/_IN Hangul-JAMO}'); +Error('\P{/a/_IN Hangul-JAMO}'); +Expect(1, 4607, '\p{inhanguljamo}', ""); +Expect(0, 4607, '\p{^inhanguljamo}', ""); +Expect(0, 4607, '\P{inhanguljamo}', ""); +Expect(1, 4607, '\P{^inhanguljamo}', ""); +Expect(0, 4351, '\p{inhanguljamo}', ""); +Expect(1, 4351, '\p{^inhanguljamo}', ""); +Expect(1, 4351, '\P{inhanguljamo}', ""); +Expect(0, 4351, '\P{^inhanguljamo}', ""); +Expect(1, 4607, '\p{_ In-Hangul Jamo}', ""); +Expect(0, 4607, '\p{^_ In-Hangul Jamo}', ""); +Expect(0, 4607, '\P{_ In-Hangul Jamo}', ""); +Expect(1, 4607, '\P{^_ In-Hangul Jamo}', ""); +Expect(0, 4351, '\p{_ In-Hangul Jamo}', ""); +Expect(1, 4351, '\p{^_ In-Hangul Jamo}', ""); +Expect(1, 4351, '\P{_ In-Hangul Jamo}', ""); +Expect(0, 4351, '\P{^_ In-Hangul Jamo}', ""); +Error('\p{/a/ canadian aboriginal}'); +Error('\P{/a/ canadian aboriginal}'); +Expect(1, 5750, '\p{canadianaboriginal}', ""); +Expect(0, 5750, '\p{^canadianaboriginal}', ""); +Expect(0, 5750, '\P{canadianaboriginal}', ""); +Expect(1, 5750, '\P{^canadianaboriginal}', ""); +Expect(0, 5120, '\p{canadianaboriginal}', ""); +Expect(1, 5120, '\p{^canadianaboriginal}', ""); +Expect(1, 5120, '\P{canadianaboriginal}', ""); +Expect(0, 5120, '\P{^canadianaboriginal}', ""); +Expect(1, 5750, '\p{_-canadian-Aboriginal}', ""); +Expect(0, 5750, '\p{^_-canadian-Aboriginal}', ""); +Expect(0, 5750, '\P{_-canadian-Aboriginal}', ""); +Expect(1, 5750, '\P{^_-canadian-Aboriginal}', ""); +Expect(0, 5120, '\p{_-canadian-Aboriginal}', ""); +Expect(1, 5120, '\p{^_-canadian-Aboriginal}', ""); +Expect(1, 5120, '\P{_-canadian-Aboriginal}', ""); +Expect(0, 5120, '\P{^_-canadian-Aboriginal}', ""); +Error('\p{ :=IS Canadian Aboriginal}'); +Error('\P{ :=IS Canadian Aboriginal}'); +Expect(1, 5750, '\p{iscanadianaboriginal}', ""); +Expect(0, 5750, '\p{^iscanadianaboriginal}', ""); +Expect(0, 5750, '\P{iscanadianaboriginal}', ""); +Expect(1, 5750, '\P{^iscanadianaboriginal}', ""); +Expect(0, 5120, '\p{iscanadianaboriginal}', ""); +Expect(1, 5120, '\p{^iscanadianaboriginal}', ""); +Expect(1, 5120, '\P{iscanadianaboriginal}', ""); +Expect(0, 5120, '\P{^iscanadianaboriginal}', ""); +Expect(1, 5750, '\p{_ is Canadian aboriginal}', ""); +Expect(0, 5750, '\p{^_ is Canadian aboriginal}', ""); +Expect(0, 5750, '\P{_ is Canadian aboriginal}', ""); +Expect(1, 5750, '\P{^_ is Canadian aboriginal}', ""); +Expect(0, 5120, '\p{_ is Canadian aboriginal}', ""); +Expect(1, 5120, '\p{^_ is Canadian aboriginal}', ""); +Expect(1, 5120, '\P{_ is Canadian aboriginal}', ""); +Expect(0, 5120, '\P{^_ is Canadian aboriginal}', ""); +Error('\p{/a/ cans}'); +Error('\P{/a/ cans}'); +Expect(1, 5750, '\p{cans}', ""); +Expect(0, 5750, '\p{^cans}', ""); +Expect(0, 5750, '\P{cans}', ""); +Expect(1, 5750, '\P{^cans}', ""); +Expect(0, 5120, '\p{cans}', ""); +Expect(1, 5120, '\p{^cans}', ""); +Expect(1, 5120, '\P{cans}', ""); +Expect(0, 5120, '\P{^cans}', ""); +Expect(1, 5750, '\p{-cans}', ""); +Expect(0, 5750, '\p{^-cans}', ""); +Expect(0, 5750, '\P{-cans}', ""); +Expect(1, 5750, '\P{^-cans}', ""); +Expect(0, 5120, '\p{-cans}', ""); +Expect(1, 5120, '\p{^-cans}', ""); +Expect(1, 5120, '\P{-cans}', ""); +Expect(0, 5120, '\P{^-cans}', ""); +Error('\p{ :=Is CANS}'); +Error('\P{ :=Is CANS}'); +Expect(1, 5750, '\p{iscans}', ""); +Expect(0, 5750, '\p{^iscans}', ""); +Expect(0, 5750, '\P{iscans}', ""); +Expect(1, 5750, '\P{^iscans}', ""); +Expect(0, 5120, '\p{iscans}', ""); +Expect(1, 5120, '\p{^iscans}', ""); +Expect(1, 5120, '\P{iscans}', ""); +Expect(0, 5120, '\P{^iscans}', ""); +Expect(1, 5750, '\p{ is CANS}', ""); +Expect(0, 5750, '\p{^ is CANS}', ""); +Expect(0, 5750, '\P{ is CANS}', ""); +Expect(1, 5750, '\P{^ is CANS}', ""); +Expect(0, 5120, '\p{ is CANS}', ""); +Expect(1, 5120, '\p{^ is CANS}', ""); +Expect(1, 5120, '\P{ is CANS}', ""); +Expect(0, 5120, '\P{^ is CANS}', ""); +Error('\p{:= Pattern-SYNTAX}'); +Error('\P{:= Pattern-SYNTAX}'); +Expect(1, 47, '\p{patternsyntax}', ""); +Expect(0, 47, '\p{^patternsyntax}', ""); +Expect(0, 47, '\P{patternsyntax}', ""); +Expect(1, 47, '\P{^patternsyntax}', ""); +Expect(0, 32, '\p{patternsyntax}', ""); +Expect(1, 32, '\p{^patternsyntax}', ""); +Expect(1, 32, '\P{patternsyntax}', ""); +Expect(0, 32, '\P{^patternsyntax}', ""); +Expect(1, 47, '\p{ pattern-syntax}', ""); +Expect(0, 47, '\p{^ pattern-syntax}', ""); +Expect(0, 47, '\P{ pattern-syntax}', ""); +Expect(1, 47, '\P{^ pattern-syntax}', ""); +Expect(0, 32, '\p{ pattern-syntax}', ""); +Expect(1, 32, '\p{^ pattern-syntax}', ""); +Expect(1, 32, '\P{ pattern-syntax}', ""); +Expect(0, 32, '\P{^ pattern-syntax}', ""); +Error('\p{- IS_Pattern:=Syntax}'); +Error('\P{- IS_Pattern:=Syntax}'); +Expect(1, 47, '\p{ispatternsyntax}', ""); +Expect(0, 47, '\p{^ispatternsyntax}', ""); +Expect(0, 47, '\P{ispatternsyntax}', ""); +Expect(1, 47, '\P{^ispatternsyntax}', ""); +Expect(0, 32, '\p{ispatternsyntax}', ""); +Expect(1, 32, '\p{^ispatternsyntax}', ""); +Expect(1, 32, '\P{ispatternsyntax}', ""); +Expect(0, 32, '\P{^ispatternsyntax}', ""); +Expect(1, 47, '\p{ _Is_PATTERNsyntax}', ""); +Expect(0, 47, '\p{^ _Is_PATTERNsyntax}', ""); +Expect(0, 47, '\P{ _Is_PATTERNsyntax}', ""); +Expect(1, 47, '\P{^ _Is_PATTERNsyntax}', ""); +Expect(0, 32, '\p{ _Is_PATTERNsyntax}', ""); +Expect(1, 32, '\p{^ _Is_PATTERNsyntax}', ""); +Expect(1, 32, '\P{ _Is_PATTERNsyntax}', ""); +Expect(0, 32, '\P{^ _Is_PATTERNsyntax}', ""); +Error('\p{-:=pat SYN}'); +Error('\P{-:=pat SYN}'); +Expect(1, 47, '\p{patsyn}', ""); +Expect(0, 47, '\p{^patsyn}', ""); +Expect(0, 47, '\P{patsyn}', ""); +Expect(1, 47, '\P{^patsyn}', ""); +Expect(0, 32, '\p{patsyn}', ""); +Expect(1, 32, '\p{^patsyn}', ""); +Expect(1, 32, '\P{patsyn}', ""); +Expect(0, 32, '\P{^patsyn}', ""); +Expect(1, 47, '\p{ PAT syn}', ""); +Expect(0, 47, '\p{^ PAT syn}', ""); +Expect(0, 47, '\P{ PAT syn}', ""); +Expect(1, 47, '\P{^ PAT syn}', ""); +Expect(0, 32, '\p{ PAT syn}', ""); +Expect(1, 32, '\p{^ PAT syn}', ""); +Expect(1, 32, '\P{ PAT syn}', ""); +Expect(0, 32, '\P{^ PAT syn}', ""); +Error('\p{- isPat Syn:=}'); +Error('\P{- isPat Syn:=}'); +Expect(1, 47, '\p{ispatsyn}', ""); +Expect(0, 47, '\p{^ispatsyn}', ""); +Expect(0, 47, '\P{ispatsyn}', ""); +Expect(1, 47, '\P{^ispatsyn}', ""); +Expect(0, 32, '\p{ispatsyn}', ""); +Expect(1, 32, '\p{^ispatsyn}', ""); +Expect(1, 32, '\P{ispatsyn}', ""); +Expect(0, 32, '\P{^ispatsyn}', ""); +Expect(1, 47, '\p{_-is Pat-Syn}', ""); +Expect(0, 47, '\p{^_-is Pat-Syn}', ""); +Expect(0, 47, '\P{_-is Pat-Syn}', ""); +Expect(1, 47, '\P{^_-is Pat-Syn}', ""); +Expect(0, 32, '\p{_-is Pat-Syn}', ""); +Expect(1, 32, '\p{^_-is Pat-Syn}', ""); +Expect(1, 32, '\P{_-is Pat-Syn}', ""); +Expect(0, 32, '\P{^_-is Pat-Syn}', ""); +Error('\p{ Other:=}'); +Error('\P{ Other:=}'); +Expect(1, 7, '\p{other}', ""); +Expect(0, 7, '\p{^other}', ""); +Expect(0, 7, '\P{other}', ""); +Expect(1, 7, '\P{^other}', ""); +Expect(0, 126, '\p{other}', ""); +Expect(1, 126, '\p{^other}', ""); +Expect(1, 126, '\P{other}', ""); +Expect(0, 126, '\P{^other}', ""); +Expect(1, 7, '\p{__OTHER}', ""); +Expect(0, 7, '\p{^__OTHER}', ""); +Expect(0, 7, '\P{__OTHER}', ""); +Expect(1, 7, '\P{^__OTHER}', ""); +Expect(0, 126, '\p{__OTHER}', ""); +Expect(1, 126, '\p{^__OTHER}', ""); +Expect(1, 126, '\P{__OTHER}', ""); +Expect(0, 126, '\P{^__OTHER}', ""); +Error('\p{:=Is_other}'); +Error('\P{:=Is_other}'); +Expect(1, 7, '\p{isother}', ""); +Expect(0, 7, '\p{^isother}', ""); +Expect(0, 7, '\P{isother}', ""); +Expect(1, 7, '\P{^isother}', ""); +Expect(0, 126, '\p{isother}', ""); +Expect(1, 126, '\p{^isother}', ""); +Expect(1, 126, '\P{isother}', ""); +Expect(0, 126, '\P{^isother}', ""); +Expect(1, 7, '\p{ _Is Other}', ""); +Expect(0, 7, '\p{^ _Is Other}', ""); +Expect(0, 7, '\P{ _Is Other}', ""); +Expect(1, 7, '\P{^ _Is Other}', ""); +Expect(0, 126, '\p{ _Is Other}', ""); +Expect(1, 126, '\p{^ _Is Other}', ""); +Expect(1, 126, '\P{ _Is Other}', ""); +Expect(0, 126, '\P{^ _Is Other}', ""); +Error('\p{ /a/C}'); +Error('\P{ /a/C}'); +Expect(1, 7, '\p{c}', ""); +Expect(0, 7, '\p{^c}', ""); +Expect(0, 7, '\P{c}', ""); +Expect(1, 7, '\P{^c}', ""); +Expect(0, 126, '\p{c}', ""); +Expect(1, 126, '\p{^c}', ""); +Expect(1, 126, '\P{c}', ""); +Expect(0, 126, '\P{^c}', ""); +Expect(1, 7, '\p{ C}', ""); +Expect(0, 7, '\p{^ C}', ""); +Expect(0, 7, '\P{ C}', ""); +Expect(1, 7, '\P{^ C}', ""); +Expect(0, 126, '\p{ C}', ""); +Expect(1, 126, '\p{^ C}', ""); +Expect(1, 126, '\P{ C}', ""); +Expect(0, 126, '\P{^ C}', ""); +Error('\p{ Is_c:=}'); +Error('\P{ Is_c:=}'); +Expect(1, 7, '\p{isc}', ""); +Expect(0, 7, '\p{^isc}', ""); +Expect(0, 7, '\P{isc}', ""); +Expect(1, 7, '\P{^isc}', ""); +Expect(0, 126, '\p{isc}', ""); +Expect(1, 126, '\p{^isc}', ""); +Expect(1, 126, '\P{isc}', ""); +Expect(0, 126, '\P{^isc}', ""); +Expect(1, 7, '\p{ Is_C}', ""); +Expect(0, 7, '\p{^ Is_C}', ""); +Expect(0, 7, '\P{ Is_C}', ""); +Expect(1, 7, '\P{^ Is_C}', ""); +Expect(0, 126, '\p{ Is_C}', ""); +Expect(1, 126, '\p{^ Is_C}', ""); +Expect(1, 126, '\P{ Is_C}', ""); +Expect(0, 126, '\P{^ Is_C}', ""); +Error('\p{-/a/VariationSELECTOR}'); +Error('\P{-/a/VariationSELECTOR}'); +Expect(1, 6157, '\p{variationselector}', ""); +Expect(0, 6157, '\p{^variationselector}', ""); +Expect(0, 6157, '\P{variationselector}', ""); +Expect(1, 6157, '\P{^variationselector}', ""); +Expect(0, 6154, '\p{variationselector}', ""); +Expect(1, 6154, '\p{^variationselector}', ""); +Expect(1, 6154, '\P{variationselector}', ""); +Expect(0, 6154, '\P{^variationselector}', ""); +Expect(1, 6157, '\p{ -VARIATION-SELECTOR}', ""); +Expect(0, 6157, '\p{^ -VARIATION-SELECTOR}', ""); +Expect(0, 6157, '\P{ -VARIATION-SELECTOR}', ""); +Expect(1, 6157, '\P{^ -VARIATION-SELECTOR}', ""); +Expect(0, 6154, '\p{ -VARIATION-SELECTOR}', ""); +Expect(1, 6154, '\p{^ -VARIATION-SELECTOR}', ""); +Expect(1, 6154, '\P{ -VARIATION-SELECTOR}', ""); +Expect(0, 6154, '\P{^ -VARIATION-SELECTOR}', ""); +Error('\p{:=_-Is VARIATION-Selector}'); +Error('\P{:=_-Is VARIATION-Selector}'); +Expect(1, 6157, '\p{isvariationselector}', ""); +Expect(0, 6157, '\p{^isvariationselector}', ""); +Expect(0, 6157, '\P{isvariationselector}', ""); +Expect(1, 6157, '\P{^isvariationselector}', ""); +Expect(0, 6154, '\p{isvariationselector}', ""); +Expect(1, 6154, '\p{^isvariationselector}', ""); +Expect(1, 6154, '\P{isvariationselector}', ""); +Expect(0, 6154, '\P{^isvariationselector}', ""); +Expect(1, 6157, '\p{ _IsVARIATION-SELECTOR}', ""); +Expect(0, 6157, '\p{^ _IsVARIATION-SELECTOR}', ""); +Expect(0, 6157, '\P{ _IsVARIATION-SELECTOR}', ""); +Expect(1, 6157, '\P{^ _IsVARIATION-SELECTOR}', ""); +Expect(0, 6154, '\p{ _IsVARIATION-SELECTOR}', ""); +Expect(1, 6154, '\p{^ _IsVARIATION-SELECTOR}', ""); +Expect(1, 6154, '\P{ _IsVARIATION-SELECTOR}', ""); +Expect(0, 6154, '\P{^ _IsVARIATION-SELECTOR}', ""); +Error('\p{-VS:=}'); +Error('\P{-VS:=}'); +Expect(1, 6157, '\p{vs}', ""); +Expect(0, 6157, '\p{^vs}', ""); +Expect(0, 6157, '\P{vs}', ""); +Expect(1, 6157, '\P{^vs}', ""); +Expect(0, 6154, '\p{vs}', ""); +Expect(1, 6154, '\p{^vs}', ""); +Expect(1, 6154, '\P{vs}', ""); +Expect(0, 6154, '\P{^vs}', ""); +Expect(1, 6157, '\p{ VS}', ""); +Expect(0, 6157, '\p{^ VS}', ""); +Expect(0, 6157, '\P{ VS}', ""); +Expect(1, 6157, '\P{^ VS}', ""); +Expect(0, 6154, '\p{ VS}', ""); +Expect(1, 6154, '\p{^ VS}', ""); +Expect(1, 6154, '\P{ VS}', ""); +Expect(0, 6154, '\P{^ VS}', ""); +Error('\p{/a/ _IS VS}'); +Error('\P{/a/ _IS VS}'); +Expect(1, 6157, '\p{isvs}', ""); +Expect(0, 6157, '\p{^isvs}', ""); +Expect(0, 6157, '\P{isvs}', ""); +Expect(1, 6157, '\P{^isvs}', ""); +Expect(0, 6154, '\p{isvs}', ""); +Expect(1, 6154, '\p{^isvs}', ""); +Expect(1, 6154, '\P{isvs}', ""); +Expect(0, 6154, '\P{^isvs}', ""); +Expect(1, 6157, '\p{ IsVS}', ""); +Expect(0, 6157, '\p{^ IsVS}', ""); +Expect(0, 6157, '\P{ IsVS}', ""); +Expect(1, 6157, '\P{^ IsVS}', ""); +Expect(0, 6154, '\p{ IsVS}', ""); +Expect(1, 6154, '\p{^ IsVS}', ""); +Expect(1, 6154, '\P{ IsVS}', ""); +Expect(0, 6154, '\P{^ IsVS}', ""); +Error('\p{:=_ Cypriot Syllabary}'); +Error('\P{:=_ Cypriot Syllabary}'); +Expect(1, 67647, '\p{cypriotsyllabary}', ""); +Expect(0, 67647, '\p{^cypriotsyllabary}', ""); +Expect(0, 67647, '\P{cypriotsyllabary}', ""); +Expect(1, 67647, '\P{^cypriotsyllabary}', ""); +Expect(0, 67583, '\p{cypriotsyllabary}', ""); +Expect(1, 67583, '\p{^cypriotsyllabary}', ""); +Expect(1, 67583, '\P{cypriotsyllabary}', ""); +Expect(0, 67583, '\P{^cypriotsyllabary}', ""); +Expect(1, 67647, '\p{- cypriot SYLLABARY}', ""); +Expect(0, 67647, '\p{^- cypriot SYLLABARY}', ""); +Expect(0, 67647, '\P{- cypriot SYLLABARY}', ""); +Expect(1, 67647, '\P{^- cypriot SYLLABARY}', ""); +Expect(0, 67583, '\p{- cypriot SYLLABARY}', ""); +Expect(1, 67583, '\p{^- cypriot SYLLABARY}', ""); +Expect(1, 67583, '\P{- cypriot SYLLABARY}', ""); +Expect(0, 67583, '\P{^- cypriot SYLLABARY}', ""); +Error('\p{ _IS/a/Cypriotsyllabary}'); +Error('\P{ _IS/a/Cypriotsyllabary}'); +Expect(1, 67647, '\p{iscypriotsyllabary}', ""); +Expect(0, 67647, '\p{^iscypriotsyllabary}', ""); +Expect(0, 67647, '\P{iscypriotsyllabary}', ""); +Expect(1, 67647, '\P{^iscypriotsyllabary}', ""); +Expect(0, 67583, '\p{iscypriotsyllabary}', ""); +Expect(1, 67583, '\p{^iscypriotsyllabary}', ""); +Expect(1, 67583, '\P{iscypriotsyllabary}', ""); +Expect(0, 67583, '\P{^iscypriotsyllabary}', ""); +Expect(1, 67647, '\p{- Is_Cypriot Syllabary}', ""); +Expect(0, 67647, '\p{^- Is_Cypriot Syllabary}', ""); +Expect(0, 67647, '\P{- Is_Cypriot Syllabary}', ""); +Expect(1, 67647, '\P{^- Is_Cypriot Syllabary}', ""); +Expect(0, 67583, '\p{- Is_Cypriot Syllabary}', ""); +Expect(1, 67583, '\p{^- Is_Cypriot Syllabary}', ""); +Expect(1, 67583, '\P{- Is_Cypriot Syllabary}', ""); +Expect(0, 67583, '\P{^- Is_Cypriot Syllabary}', ""); +Error('\p{_:=INCypriot Syllabary}'); +Error('\P{_:=INCypriot Syllabary}'); +Expect(1, 67647, '\p{incypriotsyllabary}', ""); +Expect(0, 67647, '\p{^incypriotsyllabary}', ""); +Expect(0, 67647, '\P{incypriotsyllabary}', ""); +Expect(1, 67647, '\P{^incypriotsyllabary}', ""); +Expect(0, 67583, '\p{incypriotsyllabary}', ""); +Expect(1, 67583, '\p{^incypriotsyllabary}', ""); +Expect(1, 67583, '\P{incypriotsyllabary}', ""); +Expect(0, 67583, '\P{^incypriotsyllabary}', ""); +Expect(1, 67647, '\p{ IN CypriotSyllabary}', ""); +Expect(0, 67647, '\p{^ IN CypriotSyllabary}', ""); +Expect(0, 67647, '\P{ IN CypriotSyllabary}', ""); +Expect(1, 67647, '\P{^ IN CypriotSyllabary}', ""); +Expect(0, 67583, '\p{ IN CypriotSyllabary}', ""); +Expect(1, 67583, '\p{^ IN CypriotSyllabary}', ""); +Expect(1, 67583, '\P{ IN CypriotSyllabary}', ""); +Expect(0, 67583, '\P{^ IN CypriotSyllabary}', ""); +Error('\p{:=COPTIC}'); +Error('\P{:=COPTIC}'); +Expect(1, 1007, '\p{coptic}', ""); +Expect(0, 1007, '\p{^coptic}', ""); +Expect(0, 1007, '\P{coptic}', ""); +Expect(1, 1007, '\P{^coptic}', ""); +Expect(0, 993, '\p{coptic}', ""); +Expect(1, 993, '\p{^coptic}', ""); +Expect(1, 993, '\P{coptic}', ""); +Expect(0, 993, '\P{^coptic}', ""); +Expect(1, 1007, '\p{COPTIC}', ""); +Expect(0, 1007, '\p{^COPTIC}', ""); +Expect(0, 1007, '\P{COPTIC}', ""); +Expect(1, 1007, '\P{^COPTIC}', ""); +Expect(0, 993, '\p{COPTIC}', ""); +Expect(1, 993, '\p{^COPTIC}', ""); +Expect(1, 993, '\P{COPTIC}', ""); +Expect(0, 993, '\P{^COPTIC}', ""); +Error('\p{ Is/a/Coptic}'); +Error('\P{ Is/a/Coptic}'); +Expect(1, 1007, '\p{iscoptic}', ""); +Expect(0, 1007, '\p{^iscoptic}', ""); +Expect(0, 1007, '\P{iscoptic}', ""); +Expect(1, 1007, '\P{^iscoptic}', ""); +Expect(0, 993, '\p{iscoptic}', ""); +Expect(1, 993, '\p{^iscoptic}', ""); +Expect(1, 993, '\P{iscoptic}', ""); +Expect(0, 993, '\P{^iscoptic}', ""); +Expect(1, 1007, '\p{__Is_COPTIC}', ""); +Expect(0, 1007, '\p{^__Is_COPTIC}', ""); +Expect(0, 1007, '\P{__Is_COPTIC}', ""); +Expect(1, 1007, '\P{^__Is_COPTIC}', ""); +Expect(0, 993, '\p{__Is_COPTIC}', ""); +Expect(1, 993, '\p{^__Is_COPTIC}', ""); +Expect(1, 993, '\P{__Is_COPTIC}', ""); +Expect(0, 993, '\P{^__Is_COPTIC}', ""); +Error('\p{/a/ copt}'); +Error('\P{/a/ copt}'); +Expect(1, 1007, '\p{copt}', ""); +Expect(0, 1007, '\p{^copt}', ""); +Expect(0, 1007, '\P{copt}', ""); +Expect(1, 1007, '\P{^copt}', ""); +Expect(0, 993, '\p{copt}', ""); +Expect(1, 993, '\p{^copt}', ""); +Expect(1, 993, '\P{copt}', ""); +Expect(0, 993, '\P{^copt}', ""); +Expect(1, 1007, '\p{ copt}', ""); +Expect(0, 1007, '\p{^ copt}', ""); +Expect(0, 1007, '\P{ copt}', ""); +Expect(1, 1007, '\P{^ copt}', ""); +Expect(0, 993, '\p{ copt}', ""); +Expect(1, 993, '\p{^ copt}', ""); +Expect(1, 993, '\P{ copt}', ""); +Expect(0, 993, '\P{^ copt}', ""); +Error('\p{ -Is:=copt}'); +Error('\P{ -Is:=copt}'); +Expect(1, 1007, '\p{iscopt}', ""); +Expect(0, 1007, '\p{^iscopt}', ""); +Expect(0, 1007, '\P{iscopt}', ""); +Expect(1, 1007, '\P{^iscopt}', ""); +Expect(0, 993, '\p{iscopt}', ""); +Expect(1, 993, '\p{^iscopt}', ""); +Expect(1, 993, '\P{iscopt}', ""); +Expect(0, 993, '\P{^iscopt}', ""); +Expect(1, 1007, '\p{ Is-Copt}', ""); +Expect(0, 1007, '\p{^ Is-Copt}', ""); +Expect(0, 1007, '\P{ Is-Copt}', ""); +Expect(1, 1007, '\P{^ Is-Copt}', ""); +Expect(0, 993, '\p{ Is-Copt}', ""); +Expect(1, 993, '\p{^ Is-Copt}', ""); +Expect(1, 993, '\P{ Is-Copt}', ""); +Expect(0, 993, '\P{^ Is-Copt}', ""); +Error('\p{_/a/QAAC}'); +Error('\P{_/a/QAAC}'); +Expect(1, 1007, '\p{qaac}', ""); +Expect(0, 1007, '\p{^qaac}', ""); +Expect(0, 1007, '\P{qaac}', ""); +Expect(1, 1007, '\P{^qaac}', ""); +Expect(0, 993, '\p{qaac}', ""); +Expect(1, 993, '\p{^qaac}', ""); +Expect(1, 993, '\P{qaac}', ""); +Expect(0, 993, '\P{^qaac}', ""); +Expect(1, 1007, '\p{ QAAC}', ""); +Expect(0, 1007, '\p{^ QAAC}', ""); +Expect(0, 1007, '\P{ QAAC}', ""); +Expect(1, 1007, '\P{^ QAAC}', ""); +Expect(0, 993, '\p{ QAAC}', ""); +Expect(1, 993, '\p{^ QAAC}', ""); +Expect(1, 993, '\P{ QAAC}', ""); +Expect(0, 993, '\P{^ QAAC}', ""); +Error('\p{_:=is Qaac}'); +Error('\P{_:=is Qaac}'); +Expect(1, 1007, '\p{isqaac}', ""); +Expect(0, 1007, '\p{^isqaac}', ""); +Expect(0, 1007, '\P{isqaac}', ""); +Expect(1, 1007, '\P{^isqaac}', ""); +Expect(0, 993, '\p{isqaac}', ""); +Expect(1, 993, '\p{^isqaac}', ""); +Expect(1, 993, '\P{isqaac}', ""); +Expect(0, 993, '\P{^isqaac}', ""); +Expect(1, 1007, '\p{_-IS QAAC}', ""); +Expect(0, 1007, '\p{^_-IS QAAC}', ""); +Expect(0, 1007, '\P{_-IS QAAC}', ""); +Expect(1, 1007, '\P{^_-IS QAAC}', ""); +Expect(0, 993, '\p{_-IS QAAC}', ""); +Expect(1, 993, '\p{^_-IS QAAC}', ""); +Expect(1, 993, '\P{_-IS QAAC}', ""); +Expect(0, 993, '\P{^_-IS QAAC}', ""); +Error('\p{_SUPPLEMENTAL/a/ARROWS b}'); +Error('\P{_SUPPLEMENTAL/a/ARROWS b}'); +Expect(1, 10623, '\p{supplementalarrowsb}', ""); +Expect(0, 10623, '\p{^supplementalarrowsb}', ""); +Expect(0, 10623, '\P{supplementalarrowsb}', ""); +Expect(1, 10623, '\P{^supplementalarrowsb}', ""); +Expect(0, 10495, '\p{supplementalarrowsb}', ""); +Expect(1, 10495, '\p{^supplementalarrowsb}', ""); +Expect(1, 10495, '\P{supplementalarrowsb}', ""); +Expect(0, 10495, '\P{^supplementalarrowsb}', ""); +Expect(1, 10623, '\p{-supplemental arrowsB}', ""); +Expect(0, 10623, '\p{^-supplemental arrowsB}', ""); +Expect(0, 10623, '\P{-supplemental arrowsB}', ""); +Expect(1, 10623, '\P{^-supplemental arrowsB}', ""); +Expect(0, 10495, '\p{-supplemental arrowsB}', ""); +Expect(1, 10495, '\p{^-supplemental arrowsB}', ""); +Expect(1, 10495, '\P{-supplemental arrowsB}', ""); +Expect(0, 10495, '\P{^-supplemental arrowsB}', ""); +Error('\p{_:=IS Supplemental-Arrows-B}'); +Error('\P{_:=IS Supplemental-Arrows-B}'); +Expect(1, 10623, '\p{issupplementalarrowsb}', ""); +Expect(0, 10623, '\p{^issupplementalarrowsb}', ""); +Expect(0, 10623, '\P{issupplementalarrowsb}', ""); +Expect(1, 10623, '\P{^issupplementalarrowsb}', ""); +Expect(0, 10495, '\p{issupplementalarrowsb}', ""); +Expect(1, 10495, '\p{^issupplementalarrowsb}', ""); +Expect(1, 10495, '\P{issupplementalarrowsb}', ""); +Expect(0, 10495, '\P{^issupplementalarrowsb}', ""); +Expect(1, 10623, '\p{is SUPPLEMENTAL_Arrows-B}', ""); +Expect(0, 10623, '\p{^is SUPPLEMENTAL_Arrows-B}', ""); +Expect(0, 10623, '\P{is SUPPLEMENTAL_Arrows-B}', ""); +Expect(1, 10623, '\P{^is SUPPLEMENTAL_Arrows-B}', ""); +Expect(0, 10495, '\p{is SUPPLEMENTAL_Arrows-B}', ""); +Expect(1, 10495, '\p{^is SUPPLEMENTAL_Arrows-B}', ""); +Expect(1, 10495, '\P{is SUPPLEMENTAL_Arrows-B}', ""); +Expect(0, 10495, '\P{^is SUPPLEMENTAL_Arrows-B}', ""); +Error('\p{- InSUPPLEMENTAL:=arrows-b}'); +Error('\P{- InSUPPLEMENTAL:=arrows-b}'); +Expect(1, 10623, '\p{insupplementalarrowsb}', ""); +Expect(0, 10623, '\p{^insupplementalarrowsb}', ""); +Expect(0, 10623, '\P{insupplementalarrowsb}', ""); +Expect(1, 10623, '\P{^insupplementalarrowsb}', ""); +Expect(0, 10495, '\p{insupplementalarrowsb}', ""); +Expect(1, 10495, '\p{^insupplementalarrowsb}', ""); +Expect(1, 10495, '\P{insupplementalarrowsb}', ""); +Expect(0, 10495, '\P{^insupplementalarrowsb}', ""); +Expect(1, 10623, '\p{_-In_SUPPLEMENTAL arrows_B}', ""); +Expect(0, 10623, '\p{^_-In_SUPPLEMENTAL arrows_B}', ""); +Expect(0, 10623, '\P{_-In_SUPPLEMENTAL arrows_B}', ""); +Expect(1, 10623, '\P{^_-In_SUPPLEMENTAL arrows_B}', ""); +Expect(0, 10495, '\p{_-In_SUPPLEMENTAL arrows_B}', ""); +Expect(1, 10495, '\p{^_-In_SUPPLEMENTAL arrows_B}', ""); +Expect(1, 10495, '\P{_-In_SUPPLEMENTAL arrows_B}', ""); +Expect(0, 10495, '\P{^_-In_SUPPLEMENTAL arrows_B}', ""); +Error('\p{Expands_On_NFC}'); +Error('\P{Expands_On_NFC}'); +Error('\p{Is_Expands_On_NFC}'); +Error('\P{Is_Expands_On_NFC}'); +Error('\p{XO_NFC}'); +Error('\P{XO_NFC}'); +Error('\p{Is_XO_NFC}'); +Error('\P{Is_XO_NFC}'); +Error('\p{ other Math/a/}'); +Error('\P{ other Math/a/}'); +Expect(1, 94, '\p{othermath}', 'deprecated'); +Expect(0, 94, '\p{^othermath}', 'deprecated'); +Expect(0, 94, '\P{othermath}', 'deprecated'); +Expect(1, 94, '\P{^othermath}', 'deprecated'); +Expect(0, 93, '\p{othermath}', 'deprecated'); +Expect(1, 93, '\p{^othermath}', 'deprecated'); +Expect(1, 93, '\P{othermath}', 'deprecated'); +Expect(0, 93, '\P{^othermath}', 'deprecated'); +Expect(1, 94, '\p{ Other MATH}', 'deprecated'); +Expect(0, 94, '\p{^ Other MATH}', 'deprecated'); +Expect(0, 94, '\P{ Other MATH}', 'deprecated'); +Expect(1, 94, '\P{^ Other MATH}', 'deprecated'); +Expect(0, 93, '\p{ Other MATH}', 'deprecated'); +Expect(1, 93, '\p{^ Other MATH}', 'deprecated'); +Expect(1, 93, '\P{ Other MATH}', 'deprecated'); +Expect(0, 93, '\P{^ Other MATH}', 'deprecated'); +Error('\p{_Is/a/OtherMath}'); +Error('\P{_Is/a/OtherMath}'); +Expect(1, 94, '\p{isothermath}', 'deprecated'); +Expect(0, 94, '\p{^isothermath}', 'deprecated'); +Expect(0, 94, '\P{isothermath}', 'deprecated'); +Expect(1, 94, '\P{^isothermath}', 'deprecated'); +Expect(0, 93, '\p{isothermath}', 'deprecated'); +Expect(1, 93, '\p{^isothermath}', 'deprecated'); +Expect(1, 93, '\P{isothermath}', 'deprecated'); +Expect(0, 93, '\P{^isothermath}', 'deprecated'); +Expect(1, 94, '\p{- IS OTHER MATH}', 'deprecated'); +Expect(0, 94, '\p{^- IS OTHER MATH}', 'deprecated'); +Expect(0, 94, '\P{- IS OTHER MATH}', 'deprecated'); +Expect(1, 94, '\P{^- IS OTHER MATH}', 'deprecated'); +Expect(0, 93, '\p{- IS OTHER MATH}', 'deprecated'); +Expect(1, 93, '\p{^- IS OTHER MATH}', 'deprecated'); +Expect(1, 93, '\P{- IS OTHER MATH}', 'deprecated'); +Expect(0, 93, '\P{^- IS OTHER MATH}', 'deprecated'); +Error('\p{/a/ OMath}'); +Error('\P{/a/ OMath}'); +Expect(1, 94, '\p{omath}', 'deprecated'); +Expect(0, 94, '\p{^omath}', 'deprecated'); +Expect(0, 94, '\P{omath}', 'deprecated'); +Expect(1, 94, '\P{^omath}', 'deprecated'); +Expect(0, 93, '\p{omath}', 'deprecated'); +Expect(1, 93, '\p{^omath}', 'deprecated'); +Expect(1, 93, '\P{omath}', 'deprecated'); +Expect(0, 93, '\P{^omath}', 'deprecated'); +Expect(1, 94, '\p{ OMath}', 'deprecated'); +Expect(0, 94, '\p{^ OMath}', 'deprecated'); +Expect(0, 94, '\P{ OMath}', 'deprecated'); +Expect(1, 94, '\P{^ OMath}', 'deprecated'); +Expect(0, 93, '\p{ OMath}', 'deprecated'); +Expect(1, 93, '\p{^ OMath}', 'deprecated'); +Expect(1, 93, '\P{ OMath}', 'deprecated'); +Expect(0, 93, '\P{^ OMath}', 'deprecated'); +Error('\p{:=-Is-OMath}'); +Error('\P{:=-Is-OMath}'); +Expect(1, 94, '\p{isomath}', 'deprecated'); +Expect(0, 94, '\p{^isomath}', 'deprecated'); +Expect(0, 94, '\P{isomath}', 'deprecated'); +Expect(1, 94, '\P{^isomath}', 'deprecated'); +Expect(0, 93, '\p{isomath}', 'deprecated'); +Expect(1, 93, '\p{^isomath}', 'deprecated'); +Expect(1, 93, '\P{isomath}', 'deprecated'); +Expect(0, 93, '\P{^isomath}', 'deprecated'); +Expect(1, 94, '\p{_is_OMATH}', 'deprecated'); +Expect(0, 94, '\p{^_is_OMATH}', 'deprecated'); +Expect(0, 94, '\P{_is_OMATH}', 'deprecated'); +Expect(1, 94, '\P{^_is_OMATH}', 'deprecated'); +Expect(0, 93, '\p{_is_OMATH}', 'deprecated'); +Expect(1, 93, '\p{^_is_OMATH}', 'deprecated'); +Expect(1, 93, '\P{_is_OMATH}', 'deprecated'); +Expect(0, 93, '\P{^_is_OMATH}', 'deprecated'); +Error('\p{ Latin/a/EXTENDED-Additional}'); +Error('\P{ Latin/a/EXTENDED-Additional}'); +Expect(1, 7935, '\p{latinextendedadditional}', ""); +Expect(0, 7935, '\p{^latinextendedadditional}', ""); +Expect(0, 7935, '\P{latinextendedadditional}', ""); +Expect(1, 7935, '\P{^latinextendedadditional}', ""); +Expect(0, 7679, '\p{latinextendedadditional}', ""); +Expect(1, 7679, '\p{^latinextendedadditional}', ""); +Expect(1, 7679, '\P{latinextendedadditional}', ""); +Expect(0, 7679, '\P{^latinextendedadditional}', ""); +Expect(1, 7935, '\p{- Latin EXTENDED additional}', ""); +Expect(0, 7935, '\p{^- Latin EXTENDED additional}', ""); +Expect(0, 7935, '\P{- Latin EXTENDED additional}', ""); +Expect(1, 7935, '\P{^- Latin EXTENDED additional}', ""); +Expect(0, 7679, '\p{- Latin EXTENDED additional}', ""); +Expect(1, 7679, '\p{^- Latin EXTENDED additional}', ""); +Expect(1, 7679, '\P{- Latin EXTENDED additional}', ""); +Expect(0, 7679, '\P{^- Latin EXTENDED additional}', ""); +Error('\p{ IS/a/latin extended Additional}'); +Error('\P{ IS/a/latin extended Additional}'); +Expect(1, 7935, '\p{islatinextendedadditional}', ""); +Expect(0, 7935, '\p{^islatinextendedadditional}', ""); +Expect(0, 7935, '\P{islatinextendedadditional}', ""); +Expect(1, 7935, '\P{^islatinextendedadditional}', ""); +Expect(0, 7679, '\p{islatinextendedadditional}', ""); +Expect(1, 7679, '\p{^islatinextendedadditional}', ""); +Expect(1, 7679, '\P{islatinextendedadditional}', ""); +Expect(0, 7679, '\P{^islatinextendedadditional}', ""); +Expect(1, 7935, '\p{ is-LatinEXTENDEDAdditional}', ""); +Expect(0, 7935, '\p{^ is-LatinEXTENDEDAdditional}', ""); +Expect(0, 7935, '\P{ is-LatinEXTENDEDAdditional}', ""); +Expect(1, 7935, '\P{^ is-LatinEXTENDEDAdditional}', ""); +Expect(0, 7679, '\p{ is-LatinEXTENDEDAdditional}', ""); +Expect(1, 7679, '\p{^ is-LatinEXTENDEDAdditional}', ""); +Expect(1, 7679, '\P{ is-LatinEXTENDEDAdditional}', ""); +Expect(0, 7679, '\P{^ is-LatinEXTENDEDAdditional}', ""); +Error('\p{:=In_Latin extended_ADDITIONAL}'); +Error('\P{:=In_Latin extended_ADDITIONAL}'); +Expect(1, 7935, '\p{inlatinextendedadditional}', ""); +Expect(0, 7935, '\p{^inlatinextendedadditional}', ""); +Expect(0, 7935, '\P{inlatinextendedadditional}', ""); +Expect(1, 7935, '\P{^inlatinextendedadditional}', ""); +Expect(0, 7679, '\p{inlatinextendedadditional}', ""); +Expect(1, 7679, '\p{^inlatinextendedadditional}', ""); +Expect(1, 7679, '\P{inlatinextendedadditional}', ""); +Expect(0, 7679, '\P{^inlatinextendedadditional}', ""); +Expect(1, 7935, '\p{ In_LATINEXTENDED additional}', ""); +Expect(0, 7935, '\p{^ In_LATINEXTENDED additional}', ""); +Expect(0, 7935, '\P{ In_LATINEXTENDED additional}', ""); +Expect(1, 7935, '\P{^ In_LATINEXTENDED additional}', ""); +Expect(0, 7679, '\p{ In_LATINEXTENDED additional}', ""); +Expect(1, 7679, '\p{^ In_LATINEXTENDED additional}', ""); +Expect(1, 7679, '\P{ In_LATINEXTENDED additional}', ""); +Expect(0, 7679, '\P{^ In_LATINEXTENDED additional}', ""); +Error('\p{ Kannada:=}'); +Error('\P{ Kannada:=}'); +Expect(1, 3203, '\p{kannada}', ""); +Expect(0, 3203, '\p{^kannada}', ""); +Expect(0, 3203, '\P{kannada}', ""); +Expect(1, 3203, '\P{^kannada}', ""); +Expect(0, 3201, '\p{kannada}', ""); +Expect(1, 3201, '\p{^kannada}', ""); +Expect(1, 3201, '\P{kannada}', ""); +Expect(0, 3201, '\P{^kannada}', ""); +Expect(1, 3203, '\p{ kannada}', ""); +Expect(0, 3203, '\p{^ kannada}', ""); +Expect(0, 3203, '\P{ kannada}', ""); +Expect(1, 3203, '\P{^ kannada}', ""); +Expect(0, 3201, '\p{ kannada}', ""); +Expect(1, 3201, '\p{^ kannada}', ""); +Expect(1, 3201, '\P{ kannada}', ""); +Expect(0, 3201, '\P{^ kannada}', ""); +Error('\p{ Is_Kannada/a/}'); +Error('\P{ Is_Kannada/a/}'); +Expect(1, 3203, '\p{iskannada}', ""); +Expect(0, 3203, '\p{^iskannada}', ""); +Expect(0, 3203, '\P{iskannada}', ""); +Expect(1, 3203, '\P{^iskannada}', ""); +Expect(0, 3201, '\p{iskannada}', ""); +Expect(1, 3201, '\p{^iskannada}', ""); +Expect(1, 3201, '\P{iskannada}', ""); +Expect(0, 3201, '\P{^iskannada}', ""); +Expect(1, 3203, '\p{_ Is_kannada}', ""); +Expect(0, 3203, '\p{^_ Is_kannada}', ""); +Expect(0, 3203, '\P{_ Is_kannada}', ""); +Expect(1, 3203, '\P{^_ Is_kannada}', ""); +Expect(0, 3201, '\p{_ Is_kannada}', ""); +Expect(1, 3201, '\p{^_ Is_kannada}', ""); +Expect(1, 3201, '\P{_ Is_kannada}', ""); +Expect(0, 3201, '\P{^_ Is_kannada}', ""); +Error('\p{-KNDA:=}'); +Error('\P{-KNDA:=}'); +Expect(1, 3203, '\p{knda}', ""); +Expect(0, 3203, '\p{^knda}', ""); +Expect(0, 3203, '\P{knda}', ""); +Expect(1, 3203, '\P{^knda}', ""); +Expect(0, 3201, '\p{knda}', ""); +Expect(1, 3201, '\p{^knda}', ""); +Expect(1, 3201, '\P{knda}', ""); +Expect(0, 3201, '\P{^knda}', ""); +Expect(1, 3203, '\p{- knda}', ""); +Expect(0, 3203, '\p{^- knda}', ""); +Expect(0, 3203, '\P{- knda}', ""); +Expect(1, 3203, '\P{^- knda}', ""); +Expect(0, 3201, '\p{- knda}', ""); +Expect(1, 3201, '\p{^- knda}', ""); +Expect(1, 3201, '\P{- knda}', ""); +Expect(0, 3201, '\P{^- knda}', ""); +Error('\p{ :=is_Knda}'); +Error('\P{ :=is_Knda}'); +Expect(1, 3203, '\p{isknda}', ""); +Expect(0, 3203, '\p{^isknda}', ""); +Expect(0, 3203, '\P{isknda}', ""); +Expect(1, 3203, '\P{^isknda}', ""); +Expect(0, 3201, '\p{isknda}', ""); +Expect(1, 3201, '\p{^isknda}', ""); +Expect(1, 3201, '\P{isknda}', ""); +Expect(0, 3201, '\P{^isknda}', ""); +Expect(1, 3203, '\p{ -IS Knda}', ""); +Expect(0, 3203, '\p{^ -IS Knda}', ""); +Expect(0, 3203, '\P{ -IS Knda}', ""); +Expect(1, 3203, '\P{^ -IS Knda}', ""); +Expect(0, 3201, '\p{ -IS Knda}', ""); +Expect(1, 3201, '\p{^ -IS Knda}', ""); +Expect(1, 3201, '\P{ -IS Knda}', ""); +Expect(0, 3201, '\P{^ -IS Knda}', ""); +Error('\p{--LAO/a/}'); +Error('\P{--LAO/a/}'); +Expect(1, 3714, '\p{lao}', ""); +Expect(0, 3714, '\p{^lao}', ""); +Expect(0, 3714, '\P{lao}', ""); +Expect(1, 3714, '\P{^lao}', ""); +Expect(0, 3712, '\p{lao}', ""); +Expect(1, 3712, '\p{^lao}', ""); +Expect(1, 3712, '\P{lao}', ""); +Expect(0, 3712, '\P{^lao}', ""); +Expect(1, 3714, '\p{_-Lao}', ""); +Expect(0, 3714, '\p{^_-Lao}', ""); +Expect(0, 3714, '\P{_-Lao}', ""); +Expect(1, 3714, '\P{^_-Lao}', ""); +Expect(0, 3712, '\p{_-Lao}', ""); +Expect(1, 3712, '\p{^_-Lao}', ""); +Expect(1, 3712, '\P{_-Lao}', ""); +Expect(0, 3712, '\P{^_-Lao}', ""); +Error('\p{ _Is/a/LAO}'); +Error('\P{ _Is/a/LAO}'); +Expect(1, 3714, '\p{islao}', ""); +Expect(0, 3714, '\p{^islao}', ""); +Expect(0, 3714, '\P{islao}', ""); +Expect(1, 3714, '\P{^islao}', ""); +Expect(0, 3712, '\p{islao}', ""); +Expect(1, 3712, '\p{^islao}', ""); +Expect(1, 3712, '\P{islao}', ""); +Expect(0, 3712, '\P{^islao}', ""); +Expect(1, 3714, '\p{ is-lao}', ""); +Expect(0, 3714, '\p{^ is-lao}', ""); +Expect(0, 3714, '\P{ is-lao}', ""); +Expect(1, 3714, '\P{^ is-lao}', ""); +Expect(0, 3712, '\p{ is-lao}', ""); +Expect(1, 3712, '\p{^ is-lao}', ""); +Expect(1, 3712, '\P{ is-lao}', ""); +Expect(0, 3712, '\P{^ is-lao}', ""); +Error('\p{ /a/Laoo}'); +Error('\P{ /a/Laoo}'); +Expect(1, 3714, '\p{laoo}', ""); +Expect(0, 3714, '\p{^laoo}', ""); +Expect(0, 3714, '\P{laoo}', ""); +Expect(1, 3714, '\P{^laoo}', ""); +Expect(0, 3712, '\p{laoo}', ""); +Expect(1, 3712, '\p{^laoo}', ""); +Expect(1, 3712, '\P{laoo}', ""); +Expect(0, 3712, '\P{^laoo}', ""); +Expect(1, 3714, '\p{--LAOO}', ""); +Expect(0, 3714, '\p{^--LAOO}', ""); +Expect(0, 3714, '\P{--LAOO}', ""); +Expect(1, 3714, '\P{^--LAOO}', ""); +Expect(0, 3712, '\p{--LAOO}', ""); +Expect(1, 3712, '\p{^--LAOO}', ""); +Expect(1, 3712, '\P{--LAOO}', ""); +Expect(0, 3712, '\P{^--LAOO}', ""); +Error('\p{__IS LAOO/a/}'); +Error('\P{__IS LAOO/a/}'); +Expect(1, 3714, '\p{islaoo}', ""); +Expect(0, 3714, '\p{^islaoo}', ""); +Expect(0, 3714, '\P{islaoo}', ""); +Expect(1, 3714, '\P{^islaoo}', ""); +Expect(0, 3712, '\p{islaoo}', ""); +Expect(1, 3712, '\p{^islaoo}', ""); +Expect(1, 3712, '\P{islaoo}', ""); +Expect(0, 3712, '\P{^islaoo}', ""); +Expect(1, 3714, '\p{ IsLaoo}', ""); +Expect(0, 3714, '\p{^ IsLaoo}', ""); +Expect(0, 3714, '\P{ IsLaoo}', ""); +Expect(1, 3714, '\P{^ IsLaoo}', ""); +Expect(0, 3712, '\p{ IsLaoo}', ""); +Expect(1, 3712, '\p{^ IsLaoo}', ""); +Expect(1, 3712, '\P{ IsLaoo}', ""); +Expect(0, 3712, '\P{^ IsLaoo}', ""); +Error('\p{_ Digit/a/}'); +Error('\P{_ Digit/a/}'); +Expect(1, 57, '\p{digit}', ""); +Expect(0, 57, '\p{^digit}', ""); +Expect(0, 57, '\P{digit}', ""); +Expect(1, 57, '\P{^digit}', ""); +Expect(0, 47, '\p{digit}', ""); +Expect(1, 47, '\p{^digit}', ""); +Expect(1, 47, '\P{digit}', ""); +Expect(0, 47, '\P{^digit}', ""); +Expect(1, 57, '\p{_Digit}', ""); +Expect(0, 57, '\p{^_Digit}', ""); +Expect(0, 57, '\P{_Digit}', ""); +Expect(1, 57, '\P{^_Digit}', ""); +Expect(0, 47, '\p{_Digit}', ""); +Expect(1, 47, '\p{^_Digit}', ""); +Expect(1, 47, '\P{_Digit}', ""); +Expect(0, 47, '\P{^_Digit}', ""); +Error('\p{ Is:=Digit}'); +Error('\P{ Is:=Digit}'); +Expect(1, 57, '\p{isdigit}', ""); +Expect(0, 57, '\p{^isdigit}', ""); +Expect(0, 57, '\P{isdigit}', ""); +Expect(1, 57, '\P{^isdigit}', ""); +Expect(0, 47, '\p{isdigit}', ""); +Expect(1, 47, '\p{^isdigit}', ""); +Expect(1, 47, '\P{isdigit}', ""); +Expect(0, 47, '\P{^isdigit}', ""); +Expect(1, 57, '\p{_ IS DIGIT}', ""); +Expect(0, 57, '\p{^_ IS DIGIT}', ""); +Expect(0, 57, '\P{_ IS DIGIT}', ""); +Expect(1, 57, '\P{^_ IS DIGIT}', ""); +Expect(0, 47, '\p{_ IS DIGIT}', ""); +Expect(1, 47, '\p{^_ IS DIGIT}', ""); +Expect(1, 47, '\P{_ IS DIGIT}', ""); +Expect(0, 47, '\P{^_ IS DIGIT}', ""); +Error('\p{/a/ DECIMALNUMBER}'); +Error('\P{/a/ DECIMALNUMBER}'); +Expect(1, 57, '\p{decimalnumber}', ""); +Expect(0, 57, '\p{^decimalnumber}', ""); +Expect(0, 57, '\P{decimalnumber}', ""); +Expect(1, 57, '\P{^decimalnumber}', ""); +Expect(0, 47, '\p{decimalnumber}', ""); +Expect(1, 47, '\p{^decimalnumber}', ""); +Expect(1, 47, '\P{decimalnumber}', ""); +Expect(0, 47, '\P{^decimalnumber}', ""); +Expect(1, 57, '\p{DecimalNumber}', ""); +Expect(0, 57, '\p{^DecimalNumber}', ""); +Expect(0, 57, '\P{DecimalNumber}', ""); +Expect(1, 57, '\P{^DecimalNumber}', ""); +Expect(0, 47, '\p{DecimalNumber}', ""); +Expect(1, 47, '\p{^DecimalNumber}', ""); +Expect(1, 47, '\P{DecimalNumber}', ""); +Expect(0, 47, '\P{^DecimalNumber}', ""); +Error('\p{ is Decimal:=number}'); +Error('\P{ is Decimal:=number}'); +Expect(1, 57, '\p{isdecimalnumber}', ""); +Expect(0, 57, '\p{^isdecimalnumber}', ""); +Expect(0, 57, '\P{isdecimalnumber}', ""); +Expect(1, 57, '\P{^isdecimalnumber}', ""); +Expect(0, 47, '\p{isdecimalnumber}', ""); +Expect(1, 47, '\p{^isdecimalnumber}', ""); +Expect(1, 47, '\P{isdecimalnumber}', ""); +Expect(0, 47, '\P{^isdecimalnumber}', ""); +Expect(1, 57, '\p{_ Is_decimal-NUMBER}', ""); +Expect(0, 57, '\p{^_ Is_decimal-NUMBER}', ""); +Expect(0, 57, '\P{_ Is_decimal-NUMBER}', ""); +Expect(1, 57, '\P{^_ Is_decimal-NUMBER}', ""); +Expect(0, 47, '\p{_ Is_decimal-NUMBER}', ""); +Expect(1, 47, '\p{^_ Is_decimal-NUMBER}', ""); +Expect(1, 47, '\P{_ Is_decimal-NUMBER}', ""); +Expect(0, 47, '\P{^_ Is_decimal-NUMBER}', ""); +Error('\p{ Nd:=}'); +Error('\P{ Nd:=}'); +Expect(1, 57, '\p{nd}', ""); +Expect(0, 57, '\p{^nd}', ""); +Expect(0, 57, '\P{nd}', ""); +Expect(1, 57, '\P{^nd}', ""); +Expect(0, 47, '\p{nd}', ""); +Expect(1, 47, '\p{^nd}', ""); +Expect(1, 47, '\P{nd}', ""); +Expect(0, 47, '\P{^nd}', ""); +Expect(1, 57, '\p{_nd}', ""); +Expect(0, 57, '\p{^_nd}', ""); +Expect(0, 57, '\P{_nd}', ""); +Expect(1, 57, '\P{^_nd}', ""); +Expect(0, 47, '\p{_nd}', ""); +Expect(1, 47, '\p{^_nd}', ""); +Expect(1, 47, '\P{_nd}', ""); +Expect(0, 47, '\P{^_nd}', ""); +Error('\p{ _is:=nd}'); +Error('\P{ _is:=nd}'); +Expect(1, 57, '\p{isnd}', ""); +Expect(0, 57, '\p{^isnd}', ""); +Expect(0, 57, '\P{isnd}', ""); +Expect(1, 57, '\P{^isnd}', ""); +Expect(0, 47, '\p{isnd}', ""); +Expect(1, 47, '\p{^isnd}', ""); +Expect(1, 47, '\P{isnd}', ""); +Expect(0, 47, '\P{^isnd}', ""); +Expect(1, 57, '\p{_ isnd}', ""); +Expect(0, 57, '\p{^_ isnd}', ""); +Expect(0, 57, '\P{_ isnd}', ""); +Expect(1, 57, '\P{^_ isnd}', ""); +Expect(0, 47, '\p{_ isnd}', ""); +Expect(1, 47, '\p{^_ isnd}', ""); +Expect(1, 47, '\P{_ isnd}', ""); +Expect(0, 47, '\P{^_ isnd}', ""); +Error('\p{/a/- Osmanya}'); +Error('\P{/a/- Osmanya}'); +Expect(1, 66717, '\p{osmanya}', ""); +Expect(0, 66717, '\p{^osmanya}', ""); +Expect(0, 66717, '\P{osmanya}', ""); +Expect(1, 66717, '\P{^osmanya}', ""); +Expect(0, 66687, '\p{osmanya}', ""); +Expect(1, 66687, '\p{^osmanya}', ""); +Expect(1, 66687, '\P{osmanya}', ""); +Expect(0, 66687, '\P{^osmanya}', ""); +Expect(1, 66717, '\p{__OSMANYA}', ""); +Expect(0, 66717, '\p{^__OSMANYA}', ""); +Expect(0, 66717, '\P{__OSMANYA}', ""); +Expect(1, 66717, '\P{^__OSMANYA}', ""); +Expect(0, 66687, '\p{__OSMANYA}', ""); +Expect(1, 66687, '\p{^__OSMANYA}', ""); +Expect(1, 66687, '\P{__OSMANYA}', ""); +Expect(0, 66687, '\P{^__OSMANYA}', ""); +Error('\p{-Is/a/OSMANYA}'); +Error('\P{-Is/a/OSMANYA}'); +Expect(1, 66717, '\p{isosmanya}', ""); +Expect(0, 66717, '\p{^isosmanya}', ""); +Expect(0, 66717, '\P{isosmanya}', ""); +Expect(1, 66717, '\P{^isosmanya}', ""); +Expect(0, 66687, '\p{isosmanya}', ""); +Expect(1, 66687, '\p{^isosmanya}', ""); +Expect(1, 66687, '\P{isosmanya}', ""); +Expect(0, 66687, '\P{^isosmanya}', ""); +Expect(1, 66717, '\p{- Is osmanya}', ""); +Expect(0, 66717, '\p{^- Is osmanya}', ""); +Expect(0, 66717, '\P{- Is osmanya}', ""); +Expect(1, 66717, '\P{^- Is osmanya}', ""); +Expect(0, 66687, '\p{- Is osmanya}', ""); +Expect(1, 66687, '\p{^- Is osmanya}', ""); +Expect(1, 66687, '\P{- Is osmanya}', ""); +Expect(0, 66687, '\P{^- Is osmanya}', ""); +Error('\p{/a/ OSMA}'); +Error('\P{/a/ OSMA}'); +Expect(1, 66717, '\p{osma}', ""); +Expect(0, 66717, '\p{^osma}', ""); +Expect(0, 66717, '\P{osma}', ""); +Expect(1, 66717, '\P{^osma}', ""); +Expect(0, 66687, '\p{osma}', ""); +Expect(1, 66687, '\p{^osma}', ""); +Expect(1, 66687, '\P{osma}', ""); +Expect(0, 66687, '\P{^osma}', ""); +Expect(1, 66717, '\p{-Osma}', ""); +Expect(0, 66717, '\p{^-Osma}', ""); +Expect(0, 66717, '\P{-Osma}', ""); +Expect(1, 66717, '\P{^-Osma}', ""); +Expect(0, 66687, '\p{-Osma}', ""); +Expect(1, 66687, '\p{^-Osma}', ""); +Expect(1, 66687, '\P{-Osma}', ""); +Expect(0, 66687, '\P{^-Osma}', ""); +Error('\p{:=_Is Osma}'); +Error('\P{:=_Is Osma}'); +Expect(1, 66717, '\p{isosma}', ""); +Expect(0, 66717, '\p{^isosma}', ""); +Expect(0, 66717, '\P{isosma}', ""); +Expect(1, 66717, '\P{^isosma}', ""); +Expect(0, 66687, '\p{isosma}', ""); +Expect(1, 66687, '\p{^isosma}', ""); +Expect(1, 66687, '\P{isosma}', ""); +Expect(0, 66687, '\P{^isosma}', ""); +Expect(1, 66717, '\p{ _is OSMA}', ""); +Expect(0, 66717, '\p{^ _is OSMA}', ""); +Expect(0, 66717, '\P{ _is OSMA}', ""); +Expect(1, 66717, '\P{^ _is OSMA}', ""); +Expect(0, 66687, '\p{ _is OSMA}', ""); +Expect(1, 66687, '\p{^ _is OSMA}', ""); +Expect(1, 66687, '\P{ _is OSMA}', ""); +Expect(0, 66687, '\P{^ _is OSMA}', ""); +Error('\p{--Unified-ideograph/a/}'); +Error('\P{--Unified-ideograph/a/}'); +Expect(1, 19893, '\p{unifiedideograph}', ""); +Expect(0, 19893, '\p{^unifiedideograph}', ""); +Expect(0, 19893, '\P{unifiedideograph}', ""); +Expect(1, 19893, '\P{^unifiedideograph}', ""); +Expect(0, 13311, '\p{unifiedideograph}', ""); +Expect(1, 13311, '\p{^unifiedideograph}', ""); +Expect(1, 13311, '\P{unifiedideograph}', ""); +Expect(0, 13311, '\P{^unifiedideograph}', ""); +Expect(1, 19893, '\p{_ Unified-Ideograph}', ""); +Expect(0, 19893, '\p{^_ Unified-Ideograph}', ""); +Expect(0, 19893, '\P{_ Unified-Ideograph}', ""); +Expect(1, 19893, '\P{^_ Unified-Ideograph}', ""); +Expect(0, 13311, '\p{_ Unified-Ideograph}', ""); +Expect(1, 13311, '\p{^_ Unified-Ideograph}', ""); +Expect(1, 13311, '\P{_ Unified-Ideograph}', ""); +Expect(0, 13311, '\P{^_ Unified-Ideograph}', ""); +Error('\p{:= Isunified-IDEOGRAPH}'); +Error('\P{:= Isunified-IDEOGRAPH}'); +Expect(1, 19893, '\p{isunifiedideograph}', ""); +Expect(0, 19893, '\p{^isunifiedideograph}', ""); +Expect(0, 19893, '\P{isunifiedideograph}', ""); +Expect(1, 19893, '\P{^isunifiedideograph}', ""); +Expect(0, 13311, '\p{isunifiedideograph}', ""); +Expect(1, 13311, '\p{^isunifiedideograph}', ""); +Expect(1, 13311, '\P{isunifiedideograph}', ""); +Expect(0, 13311, '\P{^isunifiedideograph}', ""); +Expect(1, 19893, '\p{- Is_UNIFIED IDEOGRAPH}', ""); +Expect(0, 19893, '\p{^- Is_UNIFIED IDEOGRAPH}', ""); +Expect(0, 19893, '\P{- Is_UNIFIED IDEOGRAPH}', ""); +Expect(1, 19893, '\P{^- Is_UNIFIED IDEOGRAPH}', ""); +Expect(0, 13311, '\p{- Is_UNIFIED IDEOGRAPH}', ""); +Expect(1, 13311, '\p{^- Is_UNIFIED IDEOGRAPH}', ""); +Expect(1, 13311, '\P{- Is_UNIFIED IDEOGRAPH}', ""); +Expect(0, 13311, '\P{^- Is_UNIFIED IDEOGRAPH}', ""); +Error('\p{/a/uideo}'); +Error('\P{/a/uideo}'); +Expect(1, 19893, '\p{uideo}', ""); +Expect(0, 19893, '\p{^uideo}', ""); +Expect(0, 19893, '\P{uideo}', ""); +Expect(1, 19893, '\P{^uideo}', ""); +Expect(0, 13311, '\p{uideo}', ""); +Expect(1, 13311, '\p{^uideo}', ""); +Expect(1, 13311, '\P{uideo}', ""); +Expect(0, 13311, '\P{^uideo}', ""); +Expect(1, 19893, '\p{_-UIDEO}', ""); +Expect(0, 19893, '\p{^_-UIDEO}', ""); +Expect(0, 19893, '\P{_-UIDEO}', ""); +Expect(1, 19893, '\P{^_-UIDEO}', ""); +Expect(0, 13311, '\p{_-UIDEO}', ""); +Expect(1, 13311, '\p{^_-UIDEO}', ""); +Expect(1, 13311, '\P{_-UIDEO}', ""); +Expect(0, 13311, '\P{^_-UIDEO}', ""); +Error('\p{/a/Is UIdeo}'); +Error('\P{/a/Is UIdeo}'); +Expect(1, 19893, '\p{isuideo}', ""); +Expect(0, 19893, '\p{^isuideo}', ""); +Expect(0, 19893, '\P{isuideo}', ""); +Expect(1, 19893, '\P{^isuideo}', ""); +Expect(0, 13311, '\p{isuideo}', ""); +Expect(1, 13311, '\p{^isuideo}', ""); +Expect(1, 13311, '\P{isuideo}', ""); +Expect(0, 13311, '\P{^isuideo}', ""); +Expect(1, 19893, '\p{ _Is-UIdeo}', ""); +Expect(0, 19893, '\p{^ _Is-UIdeo}', ""); +Expect(0, 19893, '\P{ _Is-UIdeo}', ""); +Expect(1, 19893, '\P{^ _Is-UIdeo}', ""); +Expect(0, 13311, '\p{ _Is-UIdeo}', ""); +Expect(1, 13311, '\p{^ _Is-UIdeo}', ""); +Expect(1, 13311, '\P{ _Is-UIdeo}', ""); +Expect(0, 13311, '\P{^ _Is-UIdeo}', ""); +Error('\p{:=_Bopomofo}'); +Error('\P{:=_Bopomofo}'); +Expect(1, 12589, '\p{bopomofo}', ""); +Expect(0, 12589, '\p{^bopomofo}', ""); +Expect(0, 12589, '\P{bopomofo}', ""); +Expect(1, 12589, '\P{^bopomofo}', ""); +Expect(0, 12548, '\p{bopomofo}', ""); +Expect(1, 12548, '\p{^bopomofo}', ""); +Expect(1, 12548, '\P{bopomofo}', ""); +Expect(0, 12548, '\P{^bopomofo}', ""); +Expect(1, 12589, '\p{_-bopomofo}', ""); +Expect(0, 12589, '\p{^_-bopomofo}', ""); +Expect(0, 12589, '\P{_-bopomofo}', ""); +Expect(1, 12589, '\P{^_-bopomofo}', ""); +Expect(0, 12548, '\p{_-bopomofo}', ""); +Expect(1, 12548, '\p{^_-bopomofo}', ""); +Expect(1, 12548, '\P{_-bopomofo}', ""); +Expect(0, 12548, '\P{^_-bopomofo}', ""); +Error('\p{:=IS-Bopomofo}'); +Error('\P{:=IS-Bopomofo}'); +Expect(1, 12589, '\p{isbopomofo}', ""); +Expect(0, 12589, '\p{^isbopomofo}', ""); +Expect(0, 12589, '\P{isbopomofo}', ""); +Expect(1, 12589, '\P{^isbopomofo}', ""); +Expect(0, 12548, '\p{isbopomofo}', ""); +Expect(1, 12548, '\p{^isbopomofo}', ""); +Expect(1, 12548, '\P{isbopomofo}', ""); +Expect(0, 12548, '\P{^isbopomofo}', ""); +Expect(1, 12589, '\p{ Is-Bopomofo}', ""); +Expect(0, 12589, '\p{^ Is-Bopomofo}', ""); +Expect(0, 12589, '\P{ Is-Bopomofo}', ""); +Expect(1, 12589, '\P{^ Is-Bopomofo}', ""); +Expect(0, 12548, '\p{ Is-Bopomofo}', ""); +Expect(1, 12548, '\p{^ Is-Bopomofo}', ""); +Expect(1, 12548, '\P{ Is-Bopomofo}', ""); +Expect(0, 12548, '\P{^ Is-Bopomofo}', ""); +Error('\p{:= bopo}'); +Error('\P{:= bopo}'); +Expect(1, 12589, '\p{bopo}', ""); +Expect(0, 12589, '\p{^bopo}', ""); +Expect(0, 12589, '\P{bopo}', ""); +Expect(1, 12589, '\P{^bopo}', ""); +Expect(0, 12548, '\p{bopo}', ""); +Expect(1, 12548, '\p{^bopo}', ""); +Expect(1, 12548, '\P{bopo}', ""); +Expect(0, 12548, '\P{^bopo}', ""); +Expect(1, 12589, '\p{ Bopo}', ""); +Expect(0, 12589, '\p{^ Bopo}', ""); +Expect(0, 12589, '\P{ Bopo}', ""); +Expect(1, 12589, '\P{^ Bopo}', ""); +Expect(0, 12548, '\p{ Bopo}', ""); +Expect(1, 12548, '\p{^ Bopo}', ""); +Expect(1, 12548, '\P{ Bopo}', ""); +Expect(0, 12548, '\P{^ Bopo}', ""); +Error('\p{ /a/IS bopo}'); +Error('\P{ /a/IS bopo}'); +Expect(1, 12589, '\p{isbopo}', ""); +Expect(0, 12589, '\p{^isbopo}', ""); +Expect(0, 12589, '\P{isbopo}', ""); +Expect(1, 12589, '\P{^isbopo}', ""); +Expect(0, 12548, '\p{isbopo}', ""); +Expect(1, 12548, '\p{^isbopo}', ""); +Expect(1, 12548, '\P{isbopo}', ""); +Expect(0, 12548, '\P{^isbopo}', ""); +Expect(1, 12589, '\p{-Is Bopo}', ""); +Expect(0, 12589, '\p{^-Is Bopo}', ""); +Expect(0, 12589, '\P{-Is Bopo}', ""); +Expect(1, 12589, '\P{^-Is Bopo}', ""); +Expect(0, 12548, '\p{-Is Bopo}', ""); +Expect(1, 12548, '\p{^-Is Bopo}', ""); +Expect(1, 12548, '\P{-Is Bopo}', ""); +Expect(0, 12548, '\P{^-Is Bopo}', ""); +Error('\p{ MISCELLANEOUS:=technical}'); +Error('\P{ MISCELLANEOUS:=technical}'); +Expect(1, 9215, '\p{miscellaneoustechnical}', ""); +Expect(0, 9215, '\p{^miscellaneoustechnical}', ""); +Expect(0, 9215, '\P{miscellaneoustechnical}', ""); +Expect(1, 9215, '\P{^miscellaneoustechnical}', ""); +Expect(0, 8959, '\p{miscellaneoustechnical}', ""); +Expect(1, 8959, '\p{^miscellaneoustechnical}', ""); +Expect(1, 8959, '\P{miscellaneoustechnical}', ""); +Expect(0, 8959, '\P{^miscellaneoustechnical}', ""); +Expect(1, 9215, '\p{ _Miscellaneous Technical}', ""); +Expect(0, 9215, '\p{^ _Miscellaneous Technical}', ""); +Expect(0, 9215, '\P{ _Miscellaneous Technical}', ""); +Expect(1, 9215, '\P{^ _Miscellaneous Technical}', ""); +Expect(0, 8959, '\p{ _Miscellaneous Technical}', ""); +Expect(1, 8959, '\p{^ _Miscellaneous Technical}', ""); +Expect(1, 8959, '\P{ _Miscellaneous Technical}', ""); +Expect(0, 8959, '\P{^ _Miscellaneous Technical}', ""); +Error('\p{:= IsMiscellaneousTechnical}'); +Error('\P{:= IsMiscellaneousTechnical}'); +Expect(1, 9215, '\p{ismiscellaneoustechnical}', ""); +Expect(0, 9215, '\p{^ismiscellaneoustechnical}', ""); +Expect(0, 9215, '\P{ismiscellaneoustechnical}', ""); +Expect(1, 9215, '\P{^ismiscellaneoustechnical}', ""); +Expect(0, 8959, '\p{ismiscellaneoustechnical}', ""); +Expect(1, 8959, '\p{^ismiscellaneoustechnical}', ""); +Expect(1, 8959, '\P{ismiscellaneoustechnical}', ""); +Expect(0, 8959, '\P{^ismiscellaneoustechnical}', ""); +Expect(1, 9215, '\p{ _Is miscellaneous_Technical}', ""); +Expect(0, 9215, '\p{^ _Is miscellaneous_Technical}', ""); +Expect(0, 9215, '\P{ _Is miscellaneous_Technical}', ""); +Expect(1, 9215, '\P{^ _Is miscellaneous_Technical}', ""); +Expect(0, 8959, '\p{ _Is miscellaneous_Technical}', ""); +Expect(1, 8959, '\p{^ _Is miscellaneous_Technical}', ""); +Expect(1, 8959, '\P{ _Is miscellaneous_Technical}', ""); +Expect(0, 8959, '\P{^ _Is miscellaneous_Technical}', ""); +Error('\p{-In:=miscellaneous-TECHNICAL}'); +Error('\P{-In:=miscellaneous-TECHNICAL}'); +Expect(1, 9215, '\p{inmiscellaneoustechnical}', ""); +Expect(0, 9215, '\p{^inmiscellaneoustechnical}', ""); +Expect(0, 9215, '\P{inmiscellaneoustechnical}', ""); +Expect(1, 9215, '\P{^inmiscellaneoustechnical}', ""); +Expect(0, 8959, '\p{inmiscellaneoustechnical}', ""); +Expect(1, 8959, '\p{^inmiscellaneoustechnical}', ""); +Expect(1, 8959, '\P{inmiscellaneoustechnical}', ""); +Expect(0, 8959, '\P{^inmiscellaneoustechnical}', ""); +Expect(1, 9215, '\p{_-In Miscellaneous-technical}', ""); +Expect(0, 9215, '\p{^_-In Miscellaneous-technical}', ""); +Expect(0, 9215, '\P{_-In Miscellaneous-technical}', ""); +Expect(1, 9215, '\P{^_-In Miscellaneous-technical}', ""); +Expect(0, 8959, '\p{_-In Miscellaneous-technical}', ""); +Expect(1, 8959, '\p{^_-In Miscellaneous-technical}', ""); +Expect(1, 8959, '\P{_-In Miscellaneous-technical}', ""); +Expect(0, 8959, '\P{^_-In Miscellaneous-technical}', ""); +Error('\p{ MAHJONG/a/TILES}'); +Error('\P{ MAHJONG/a/TILES}'); +Expect(1, 127023, '\p{mahjongtiles}', ""); +Expect(0, 127023, '\p{^mahjongtiles}', ""); +Expect(0, 127023, '\P{mahjongtiles}', ""); +Expect(1, 127023, '\P{^mahjongtiles}', ""); +Expect(0, 126975, '\p{mahjongtiles}', ""); +Expect(1, 126975, '\p{^mahjongtiles}', ""); +Expect(1, 126975, '\P{mahjongtiles}', ""); +Expect(0, 126975, '\P{^mahjongtiles}', ""); +Expect(1, 127023, '\p{ mahjongTILES}', ""); +Expect(0, 127023, '\p{^ mahjongTILES}', ""); +Expect(0, 127023, '\P{ mahjongTILES}', ""); +Expect(1, 127023, '\P{^ mahjongTILES}', ""); +Expect(0, 126975, '\p{ mahjongTILES}', ""); +Expect(1, 126975, '\p{^ mahjongTILES}', ""); +Expect(1, 126975, '\P{ mahjongTILES}', ""); +Expect(0, 126975, '\P{^ mahjongTILES}', ""); +Error('\p{ IS_mahjong:=tiles}'); +Error('\P{ IS_mahjong:=tiles}'); +Expect(1, 127023, '\p{ismahjongtiles}', ""); +Expect(0, 127023, '\p{^ismahjongtiles}', ""); +Expect(0, 127023, '\P{ismahjongtiles}', ""); +Expect(1, 127023, '\P{^ismahjongtiles}', ""); +Expect(0, 126975, '\p{ismahjongtiles}', ""); +Expect(1, 126975, '\p{^ismahjongtiles}', ""); +Expect(1, 126975, '\P{ismahjongtiles}', ""); +Expect(0, 126975, '\P{^ismahjongtiles}', ""); +Expect(1, 127023, '\p{- is Mahjong TILES}', ""); +Expect(0, 127023, '\p{^- is Mahjong TILES}', ""); +Expect(0, 127023, '\P{- is Mahjong TILES}', ""); +Expect(1, 127023, '\P{^- is Mahjong TILES}', ""); +Expect(0, 126975, '\p{- is Mahjong TILES}', ""); +Expect(1, 126975, '\p{^- is Mahjong TILES}', ""); +Expect(1, 126975, '\P{- is Mahjong TILES}', ""); +Expect(0, 126975, '\P{^- is Mahjong TILES}', ""); +Error('\p{ -in Mahjong:=Tiles}'); +Error('\P{ -in Mahjong:=Tiles}'); +Expect(1, 127023, '\p{inmahjongtiles}', ""); +Expect(0, 127023, '\p{^inmahjongtiles}', ""); +Expect(0, 127023, '\P{inmahjongtiles}', ""); +Expect(1, 127023, '\P{^inmahjongtiles}', ""); +Expect(0, 126975, '\p{inmahjongtiles}', ""); +Expect(1, 126975, '\p{^inmahjongtiles}', ""); +Expect(1, 126975, '\P{inmahjongtiles}', ""); +Expect(0, 126975, '\P{^inmahjongtiles}', ""); +Expect(1, 127023, '\p{ IN MAHJONGTILES}', ""); +Expect(0, 127023, '\p{^ IN MAHJONGTILES}', ""); +Expect(0, 127023, '\P{ IN MAHJONGTILES}', ""); +Expect(1, 127023, '\P{^ IN MAHJONGTILES}', ""); +Expect(0, 126975, '\p{ IN MAHJONGTILES}', ""); +Expect(1, 126975, '\p{^ IN MAHJONGTILES}', ""); +Expect(1, 126975, '\P{ IN MAHJONGTILES}', ""); +Expect(0, 126975, '\P{^ IN MAHJONGTILES}', ""); +Error('\p{-MiscellaneousMathematical/a/Symbols_B}'); +Error('\P{-MiscellaneousMathematical/a/Symbols_B}'); +Expect(1, 10751, '\p{miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\p{^miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\P{miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\P{^miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\p{miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\p{^miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\P{miscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\P{^miscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\p{_MISCELLANEOUS MATHEMATICAL SYMBOLS-B}', ""); +Expect(0, 10751, '\p{^_MISCELLANEOUS MATHEMATICAL SYMBOLS-B}', ""); +Expect(0, 10751, '\P{_MISCELLANEOUS MATHEMATICAL SYMBOLS-B}', ""); +Expect(1, 10751, '\P{^_MISCELLANEOUS MATHEMATICAL SYMBOLS-B}', ""); +Expect(0, 10623, '\p{_MISCELLANEOUS MATHEMATICAL SYMBOLS-B}', ""); +Expect(1, 10623, '\p{^_MISCELLANEOUS MATHEMATICAL SYMBOLS-B}', ""); +Expect(1, 10623, '\P{_MISCELLANEOUS MATHEMATICAL SYMBOLS-B}', ""); +Expect(0, 10623, '\P{^_MISCELLANEOUS MATHEMATICAL SYMBOLS-B}', ""); +Error('\p{ Is:=Miscellaneous MathematicalSymbolsb}'); +Error('\P{ Is:=Miscellaneous MathematicalSymbolsb}'); +Expect(1, 10751, '\p{ismiscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\p{^ismiscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\P{ismiscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\P{^ismiscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\p{ismiscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\p{^ismiscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\P{ismiscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\P{^ismiscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\p{is MiscellaneousMathematical_symbolsb}', ""); +Expect(0, 10751, '\p{^is MiscellaneousMathematical_symbolsb}', ""); +Expect(0, 10751, '\P{is MiscellaneousMathematical_symbolsb}', ""); +Expect(1, 10751, '\P{^is MiscellaneousMathematical_symbolsb}', ""); +Expect(0, 10623, '\p{is MiscellaneousMathematical_symbolsb}', ""); +Expect(1, 10623, '\p{^is MiscellaneousMathematical_symbolsb}', ""); +Expect(1, 10623, '\P{is MiscellaneousMathematical_symbolsb}', ""); +Expect(0, 10623, '\P{^is MiscellaneousMathematical_symbolsb}', ""); +Error('\p{-:=in_Miscellaneous-MATHEMATICAL-SYMBOLS_B}'); +Error('\P{-:=in_Miscellaneous-MATHEMATICAL-SYMBOLS_B}'); +Expect(1, 10751, '\p{inmiscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\p{^inmiscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10751, '\P{inmiscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\P{^inmiscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\p{inmiscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\p{^inmiscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10623, '\P{inmiscellaneousmathematicalsymbolsb}', ""); +Expect(0, 10623, '\P{^inmiscellaneousmathematicalsymbolsb}', ""); +Expect(1, 10751, '\p{ -InMiscellaneous Mathematicalsymbols B}', ""); +Expect(0, 10751, '\p{^ -InMiscellaneous Mathematicalsymbols B}', ""); +Expect(0, 10751, '\P{ -InMiscellaneous Mathematicalsymbols B}', ""); +Expect(1, 10751, '\P{^ -InMiscellaneous Mathematicalsymbols B}', ""); +Expect(0, 10623, '\p{ -InMiscellaneous Mathematicalsymbols B}', ""); +Expect(1, 10623, '\p{^ -InMiscellaneous Mathematicalsymbols B}', ""); +Expect(1, 10623, '\P{ -InMiscellaneous Mathematicalsymbols B}', ""); +Expect(0, 10623, '\P{^ -InMiscellaneous Mathematicalsymbols B}', ""); +Error('\p{:=-_Malayalam}'); +Error('\P{:=-_Malayalam}'); +Expect(1, 3331, '\p{malayalam}', ""); +Expect(0, 3331, '\p{^malayalam}', ""); +Expect(0, 3331, '\P{malayalam}', ""); +Expect(1, 3331, '\P{^malayalam}', ""); +Expect(0, 3329, '\p{malayalam}', ""); +Expect(1, 3329, '\p{^malayalam}', ""); +Expect(1, 3329, '\P{malayalam}', ""); +Expect(0, 3329, '\P{^malayalam}', ""); +Expect(1, 3331, '\p{ Malayalam}', ""); +Expect(0, 3331, '\p{^ Malayalam}', ""); +Expect(0, 3331, '\P{ Malayalam}', ""); +Expect(1, 3331, '\P{^ Malayalam}', ""); +Expect(0, 3329, '\p{ Malayalam}', ""); +Expect(1, 3329, '\p{^ Malayalam}', ""); +Expect(1, 3329, '\P{ Malayalam}', ""); +Expect(0, 3329, '\P{^ Malayalam}', ""); +Error('\p{ IS_Malayalam:=}'); +Error('\P{ IS_Malayalam:=}'); +Expect(1, 3331, '\p{ismalayalam}', ""); +Expect(0, 3331, '\p{^ismalayalam}', ""); +Expect(0, 3331, '\P{ismalayalam}', ""); +Expect(1, 3331, '\P{^ismalayalam}', ""); +Expect(0, 3329, '\p{ismalayalam}', ""); +Expect(1, 3329, '\p{^ismalayalam}', ""); +Expect(1, 3329, '\P{ismalayalam}', ""); +Expect(0, 3329, '\P{^ismalayalam}', ""); +Expect(1, 3331, '\p{ IS-MALAYALAM}', ""); +Expect(0, 3331, '\p{^ IS-MALAYALAM}', ""); +Expect(0, 3331, '\P{ IS-MALAYALAM}', ""); +Expect(1, 3331, '\P{^ IS-MALAYALAM}', ""); +Expect(0, 3329, '\p{ IS-MALAYALAM}', ""); +Expect(1, 3329, '\p{^ IS-MALAYALAM}', ""); +Expect(1, 3329, '\P{ IS-MALAYALAM}', ""); +Expect(0, 3329, '\P{^ IS-MALAYALAM}', ""); +Error('\p{/a/ mlym}'); +Error('\P{/a/ mlym}'); +Expect(1, 3331, '\p{mlym}', ""); +Expect(0, 3331, '\p{^mlym}', ""); +Expect(0, 3331, '\P{mlym}', ""); +Expect(1, 3331, '\P{^mlym}', ""); +Expect(0, 3329, '\p{mlym}', ""); +Expect(1, 3329, '\p{^mlym}', ""); +Expect(1, 3329, '\P{mlym}', ""); +Expect(0, 3329, '\P{^mlym}', ""); +Error('\p{- is MLYM:=}'); +Error('\P{- is MLYM:=}'); +Expect(1, 3331, '\p{ismlym}', ""); +Expect(0, 3331, '\p{^ismlym}', ""); +Expect(0, 3331, '\P{ismlym}', ""); +Expect(1, 3331, '\P{^ismlym}', ""); +Expect(0, 3329, '\p{ismlym}', ""); +Expect(1, 3329, '\p{^ismlym}', ""); +Expect(1, 3329, '\P{ismlym}', ""); +Expect(0, 3329, '\P{^ismlym}', ""); +Expect(1, 3331, '\p{-IS_Mlym}', ""); +Expect(0, 3331, '\p{^-IS_Mlym}', ""); +Expect(0, 3331, '\P{-IS_Mlym}', ""); +Expect(1, 3331, '\P{^-IS_Mlym}', ""); +Expect(0, 3329, '\p{-IS_Mlym}', ""); +Expect(1, 3329, '\p{^-IS_Mlym}', ""); +Expect(1, 3329, '\P{-IS_Mlym}', ""); +Expect(0, 3329, '\P{^-IS_Mlym}', ""); +Error('\p{ Nonspacing MARK/a/}'); +Error('\P{ Nonspacing MARK/a/}'); +Expect(1, 879, '\p{nonspacingmark}', ""); +Expect(0, 879, '\p{^nonspacingmark}', ""); +Expect(0, 879, '\P{nonspacingmark}', ""); +Expect(1, 879, '\P{^nonspacingmark}', ""); +Expect(0, 767, '\p{nonspacingmark}', ""); +Expect(1, 767, '\p{^nonspacingmark}', ""); +Expect(1, 767, '\P{nonspacingmark}', ""); +Expect(0, 767, '\P{^nonspacingmark}', ""); +Expect(1, 879, '\p{- Nonspacing mark}', ""); +Expect(0, 879, '\p{^- Nonspacing mark}', ""); +Expect(0, 879, '\P{- Nonspacing mark}', ""); +Expect(1, 879, '\P{^- Nonspacing mark}', ""); +Expect(0, 767, '\p{- Nonspacing mark}', ""); +Expect(1, 767, '\p{^- Nonspacing mark}', ""); +Expect(1, 767, '\P{- Nonspacing mark}', ""); +Expect(0, 767, '\P{^- Nonspacing mark}', ""); +Error('\p{/a/ is-NONSPACING_Mark}'); +Error('\P{/a/ is-NONSPACING_Mark}'); +Expect(1, 879, '\p{isnonspacingmark}', ""); +Expect(0, 879, '\p{^isnonspacingmark}', ""); +Expect(0, 879, '\P{isnonspacingmark}', ""); +Expect(1, 879, '\P{^isnonspacingmark}', ""); +Expect(0, 767, '\p{isnonspacingmark}', ""); +Expect(1, 767, '\p{^isnonspacingmark}', ""); +Expect(1, 767, '\P{isnonspacingmark}', ""); +Expect(0, 767, '\P{^isnonspacingmark}', ""); +Expect(1, 879, '\p{ Is nonspacingMark}', ""); +Expect(0, 879, '\p{^ Is nonspacingMark}', ""); +Expect(0, 879, '\P{ Is nonspacingMark}', ""); +Expect(1, 879, '\P{^ Is nonspacingMark}', ""); +Expect(0, 767, '\p{ Is nonspacingMark}', ""); +Expect(1, 767, '\p{^ Is nonspacingMark}', ""); +Expect(1, 767, '\P{ Is nonspacingMark}', ""); +Expect(0, 767, '\P{^ Is nonspacingMark}', ""); +Error('\p{-MN:=}'); +Error('\P{-MN:=}'); +Expect(1, 879, '\p{mn}', ""); +Expect(0, 879, '\p{^mn}', ""); +Expect(0, 879, '\P{mn}', ""); +Expect(1, 879, '\P{^mn}', ""); +Expect(0, 767, '\p{mn}', ""); +Expect(1, 767, '\p{^mn}', ""); +Expect(1, 767, '\P{mn}', ""); +Expect(0, 767, '\P{^mn}', ""); +Expect(1, 879, '\p{ mn}', ""); +Expect(0, 879, '\p{^ mn}', ""); +Expect(0, 879, '\P{ mn}', ""); +Expect(1, 879, '\P{^ mn}', ""); +Expect(0, 767, '\p{ mn}', ""); +Expect(1, 767, '\p{^ mn}', ""); +Expect(1, 767, '\P{ mn}', ""); +Expect(0, 767, '\P{^ mn}', ""); +Error('\p{:= -Is-mn}'); +Error('\P{:= -Is-mn}'); +Expect(1, 879, '\p{ismn}', ""); +Expect(0, 879, '\p{^ismn}', ""); +Expect(0, 879, '\P{ismn}', ""); +Expect(1, 879, '\P{^ismn}', ""); +Expect(0, 767, '\p{ismn}', ""); +Expect(1, 767, '\p{^ismn}', ""); +Expect(1, 767, '\P{ismn}', ""); +Expect(0, 767, '\P{^ismn}', ""); +Expect(1, 879, '\p{ IsMN}', ""); +Expect(0, 879, '\p{^ IsMN}', ""); +Expect(0, 879, '\P{ IsMN}', ""); +Expect(1, 879, '\P{^ IsMN}', ""); +Expect(0, 767, '\p{ IsMN}', ""); +Expect(1, 767, '\p{^ IsMN}', ""); +Expect(1, 767, '\P{ IsMN}', ""); +Expect(0, 767, '\P{^ IsMN}', ""); +Error('\p{-/a/full_Composition_Exclusion}'); +Error('\P{-/a/full_Composition_Exclusion}'); +Expect(1, 833, '\p{fullcompositionexclusion}', ""); +Expect(0, 833, '\p{^fullcompositionexclusion}', ""); +Expect(0, 833, '\P{fullcompositionexclusion}', ""); +Expect(1, 833, '\P{^fullcompositionexclusion}', ""); +Expect(0, 831, '\p{fullcompositionexclusion}', ""); +Expect(1, 831, '\p{^fullcompositionexclusion}', ""); +Expect(1, 831, '\P{fullcompositionexclusion}', ""); +Expect(0, 831, '\P{^fullcompositionexclusion}', ""); +Expect(1, 833, '\p{-Full CompositionExclusion}', ""); +Expect(0, 833, '\p{^-Full CompositionExclusion}', ""); +Expect(0, 833, '\P{-Full CompositionExclusion}', ""); +Expect(1, 833, '\P{^-Full CompositionExclusion}', ""); +Expect(0, 831, '\p{-Full CompositionExclusion}', ""); +Expect(1, 831, '\p{^-Full CompositionExclusion}', ""); +Expect(1, 831, '\P{-Full CompositionExclusion}', ""); +Expect(0, 831, '\P{^-Full CompositionExclusion}', ""); +Error('\p{IS FULL/a/Composition_EXCLUSION}'); +Error('\P{IS FULL/a/Composition_EXCLUSION}'); +Expect(1, 833, '\p{isfullcompositionexclusion}', ""); +Expect(0, 833, '\p{^isfullcompositionexclusion}', ""); +Expect(0, 833, '\P{isfullcompositionexclusion}', ""); +Expect(1, 833, '\P{^isfullcompositionexclusion}', ""); +Expect(0, 831, '\p{isfullcompositionexclusion}', ""); +Expect(1, 831, '\p{^isfullcompositionexclusion}', ""); +Expect(1, 831, '\P{isfullcompositionexclusion}', ""); +Expect(0, 831, '\P{^isfullcompositionexclusion}', ""); +Expect(1, 833, '\p{ -Is-FULL COMPOSITION_EXCLUSION}', ""); +Expect(0, 833, '\p{^ -Is-FULL COMPOSITION_EXCLUSION}', ""); +Expect(0, 833, '\P{ -Is-FULL COMPOSITION_EXCLUSION}', ""); +Expect(1, 833, '\P{^ -Is-FULL COMPOSITION_EXCLUSION}', ""); +Expect(0, 831, '\p{ -Is-FULL COMPOSITION_EXCLUSION}', ""); +Expect(1, 831, '\p{^ -Is-FULL COMPOSITION_EXCLUSION}', ""); +Expect(1, 831, '\P{ -Is-FULL COMPOSITION_EXCLUSION}', ""); +Expect(0, 831, '\P{^ -Is-FULL COMPOSITION_EXCLUSION}', ""); +Error('\p{ comp Ex:=}'); +Error('\P{ comp Ex:=}'); +Expect(1, 833, '\p{compex}', ""); +Expect(0, 833, '\p{^compex}', ""); +Expect(0, 833, '\P{compex}', ""); +Expect(1, 833, '\P{^compex}', ""); +Expect(0, 831, '\p{compex}', ""); +Expect(1, 831, '\p{^compex}', ""); +Expect(1, 831, '\P{compex}', ""); +Expect(0, 831, '\P{^compex}', ""); +Expect(1, 833, '\p{ Comp ex}', ""); +Expect(0, 833, '\p{^ Comp ex}', ""); +Expect(0, 833, '\P{ Comp ex}', ""); +Expect(1, 833, '\P{^ Comp ex}', ""); +Expect(0, 831, '\p{ Comp ex}', ""); +Expect(1, 831, '\p{^ Comp ex}', ""); +Expect(1, 831, '\P{ Comp ex}', ""); +Expect(0, 831, '\P{^ Comp ex}', ""); +Error('\p{-/a/is-comp-ex}'); +Error('\P{-/a/is-comp-ex}'); +Expect(1, 833, '\p{iscompex}', ""); +Expect(0, 833, '\p{^iscompex}', ""); +Expect(0, 833, '\P{iscompex}', ""); +Expect(1, 833, '\P{^iscompex}', ""); +Expect(0, 831, '\p{iscompex}', ""); +Expect(1, 831, '\p{^iscompex}', ""); +Expect(1, 831, '\P{iscompex}', ""); +Expect(0, 831, '\P{^iscompex}', ""); +Expect(1, 833, '\p{ IS_Comp EX}', ""); +Expect(0, 833, '\p{^ IS_Comp EX}', ""); +Expect(0, 833, '\P{ IS_Comp EX}', ""); +Expect(1, 833, '\P{^ IS_Comp EX}', ""); +Expect(0, 831, '\p{ IS_Comp EX}', ""); +Expect(1, 831, '\p{^ IS_Comp EX}', ""); +Expect(1, 831, '\P{ IS_Comp EX}', ""); +Expect(0, 831, '\P{^ IS_Comp EX}', ""); +Error('\p{/a/- joincontrol}'); +Error('\P{/a/- joincontrol}'); +Expect(1, 8205, '\p{joincontrol}', ""); +Expect(0, 8205, '\p{^joincontrol}', ""); +Expect(0, 8205, '\P{joincontrol}', ""); +Expect(1, 8205, '\P{^joincontrol}', ""); +Expect(0, 8203, '\p{joincontrol}', ""); +Expect(1, 8203, '\p{^joincontrol}', ""); +Expect(1, 8203, '\P{joincontrol}', ""); +Expect(0, 8203, '\P{^joincontrol}', ""); +Expect(1, 8205, '\p{ JoinControl}', ""); +Expect(0, 8205, '\p{^ JoinControl}', ""); +Expect(0, 8205, '\P{ JoinControl}', ""); +Expect(1, 8205, '\P{^ JoinControl}', ""); +Expect(0, 8203, '\p{ JoinControl}', ""); +Expect(1, 8203, '\p{^ JoinControl}', ""); +Expect(1, 8203, '\P{ JoinControl}', ""); +Expect(0, 8203, '\P{^ JoinControl}', ""); +Error('\p{-Is/a/join-CONTROL}'); +Error('\P{-Is/a/join-CONTROL}'); +Expect(1, 8205, '\p{isjoincontrol}', ""); +Expect(0, 8205, '\p{^isjoincontrol}', ""); +Expect(0, 8205, '\P{isjoincontrol}', ""); +Expect(1, 8205, '\P{^isjoincontrol}', ""); +Expect(0, 8203, '\p{isjoincontrol}', ""); +Expect(1, 8203, '\p{^isjoincontrol}', ""); +Expect(1, 8203, '\P{isjoincontrol}', ""); +Expect(0, 8203, '\P{^isjoincontrol}', ""); +Expect(1, 8205, '\p{_ Is_Join Control}', ""); +Expect(0, 8205, '\p{^_ Is_Join Control}', ""); +Expect(0, 8205, '\P{_ Is_Join Control}', ""); +Expect(1, 8205, '\P{^_ Is_Join Control}', ""); +Expect(0, 8203, '\p{_ Is_Join Control}', ""); +Expect(1, 8203, '\p{^_ Is_Join Control}', ""); +Expect(1, 8203, '\P{_ Is_Join Control}', ""); +Expect(0, 8203, '\P{^_ Is_Join Control}', ""); +Error('\p{/a/_-JOIN C}'); +Error('\P{/a/_-JOIN C}'); +Expect(1, 8205, '\p{joinc}', ""); +Expect(0, 8205, '\p{^joinc}', ""); +Expect(0, 8205, '\P{joinc}', ""); +Expect(1, 8205, '\P{^joinc}', ""); +Expect(0, 8203, '\p{joinc}', ""); +Expect(1, 8203, '\p{^joinc}', ""); +Expect(1, 8203, '\P{joinc}', ""); +Expect(0, 8203, '\P{^joinc}', ""); +Expect(1, 8205, '\p{ -Join C}', ""); +Expect(0, 8205, '\p{^ -Join C}', ""); +Expect(0, 8205, '\P{ -Join C}', ""); +Expect(1, 8205, '\P{^ -Join C}', ""); +Expect(0, 8203, '\p{ -Join C}', ""); +Expect(1, 8203, '\p{^ -Join C}', ""); +Expect(1, 8203, '\P{ -Join C}', ""); +Expect(0, 8203, '\P{^ -Join C}', ""); +Error('\p{ _Isjoin-C:=}'); +Error('\P{ _Isjoin-C:=}'); +Expect(1, 8205, '\p{isjoinc}', ""); +Expect(0, 8205, '\p{^isjoinc}', ""); +Expect(0, 8205, '\P{isjoinc}', ""); +Expect(1, 8205, '\P{^isjoinc}', ""); +Expect(0, 8203, '\p{isjoinc}', ""); +Expect(1, 8203, '\p{^isjoinc}', ""); +Expect(1, 8203, '\P{isjoinc}', ""); +Expect(0, 8203, '\P{^isjoinc}', ""); +Expect(1, 8205, '\p{_-Is-joinC}', ""); +Expect(0, 8205, '\p{^_-Is-joinC}', ""); +Expect(0, 8205, '\P{_-Is-joinC}', ""); +Expect(1, 8205, '\P{^_-Is-joinC}', ""); +Expect(0, 8203, '\p{_-Is-joinC}', ""); +Expect(1, 8203, '\p{^_-Is-joinC}', ""); +Expect(1, 8203, '\P{_-Is-joinC}', ""); +Expect(0, 8203, '\P{^_-Is-joinC}', ""); +Error('\p{:=- UPPER}'); +Error('\P{:=- UPPER}'); +Expect(1, 90, '\p{upper}', ""); +Expect(0, 90, '\p{^upper}', ""); +Expect(0, 90, '\P{upper}', ""); +Expect(1, 90, '\P{^upper}', ""); +Expect(0, 64, '\p{upper}', ""); +Expect(1, 64, '\p{^upper}', ""); +Expect(1, 64, '\P{upper}', ""); +Expect(0, 64, '\P{^upper}', ""); +Expect(1, 90, '\p{ Upper}', ""); +Expect(0, 90, '\p{^ Upper}', ""); +Expect(0, 90, '\P{ Upper}', ""); +Expect(1, 90, '\P{^ Upper}', ""); +Expect(0, 64, '\p{ Upper}', ""); +Expect(1, 64, '\p{^ Upper}', ""); +Expect(1, 64, '\P{ Upper}', ""); +Expect(0, 64, '\P{^ Upper}', ""); +Error('\p{/a/IS UPPER}'); +Error('\P{/a/IS UPPER}'); +Expect(1, 90, '\p{isupper}', ""); +Expect(0, 90, '\p{^isupper}', ""); +Expect(0, 90, '\P{isupper}', ""); +Expect(1, 90, '\P{^isupper}', ""); +Expect(0, 64, '\p{isupper}', ""); +Expect(1, 64, '\p{^isupper}', ""); +Expect(1, 64, '\P{isupper}', ""); +Expect(0, 64, '\P{^isupper}', ""); +Expect(1, 90, '\p{-is_UPPER}', ""); +Expect(0, 90, '\p{^-is_UPPER}', ""); +Expect(0, 90, '\P{-is_UPPER}', ""); +Expect(1, 90, '\P{^-is_UPPER}', ""); +Expect(0, 64, '\p{-is_UPPER}', ""); +Expect(1, 64, '\p{^-is_UPPER}', ""); +Expect(1, 64, '\P{-is_UPPER}', ""); +Expect(0, 64, '\P{^-is_UPPER}', ""); +Error('\p{ /a/Uppercase}'); +Error('\P{ /a/Uppercase}'); +Expect(1, 90, '\p{uppercase}', ""); +Expect(0, 90, '\p{^uppercase}', ""); +Expect(0, 90, '\P{uppercase}', ""); +Expect(1, 90, '\P{^uppercase}', ""); +Expect(0, 64, '\p{uppercase}', ""); +Expect(1, 64, '\p{^uppercase}', ""); +Expect(1, 64, '\P{uppercase}', ""); +Expect(0, 64, '\P{^uppercase}', ""); +Expect(1, 90, '\p{ _UPPERCASE}', ""); +Expect(0, 90, '\p{^ _UPPERCASE}', ""); +Expect(0, 90, '\P{ _UPPERCASE}', ""); +Expect(1, 90, '\P{^ _UPPERCASE}', ""); +Expect(0, 64, '\p{ _UPPERCASE}', ""); +Expect(1, 64, '\p{^ _UPPERCASE}', ""); +Expect(1, 64, '\P{ _UPPERCASE}', ""); +Expect(0, 64, '\P{^ _UPPERCASE}', ""); +Error('\p{ Is UPPERCASE:=}'); +Error('\P{ Is UPPERCASE:=}'); +Expect(1, 90, '\p{isuppercase}', ""); +Expect(0, 90, '\p{^isuppercase}', ""); +Expect(0, 90, '\P{isuppercase}', ""); +Expect(1, 90, '\P{^isuppercase}', ""); +Expect(0, 64, '\p{isuppercase}', ""); +Expect(1, 64, '\p{^isuppercase}', ""); +Expect(1, 64, '\P{isuppercase}', ""); +Expect(0, 64, '\P{^isuppercase}', ""); +Expect(1, 90, '\p{- Is_UPPERCASE}', ""); +Expect(0, 90, '\p{^- Is_UPPERCASE}', ""); +Expect(0, 90, '\P{- Is_UPPERCASE}', ""); +Expect(1, 90, '\P{^- Is_UPPERCASE}', ""); +Expect(0, 64, '\p{- Is_UPPERCASE}', ""); +Expect(1, 64, '\p{^- Is_UPPERCASE}', ""); +Expect(1, 64, '\P{- Is_UPPERCASE}', ""); +Expect(0, 64, '\P{^- Is_UPPERCASE}', ""); +Error('\p{_ BRAILLE-Patterns:=}'); +Error('\P{_ BRAILLE-Patterns:=}'); +Expect(1, 10495, '\p{braillepatterns}', ""); +Expect(0, 10495, '\p{^braillepatterns}', ""); +Expect(0, 10495, '\P{braillepatterns}', ""); +Expect(1, 10495, '\P{^braillepatterns}', ""); +Expect(0, 10239, '\p{braillepatterns}', ""); +Expect(1, 10239, '\p{^braillepatterns}', ""); +Expect(1, 10239, '\P{braillepatterns}', ""); +Expect(0, 10239, '\P{^braillepatterns}', ""); +Expect(1, 10495, '\p{Braille PATTERNS}', ""); +Expect(0, 10495, '\p{^Braille PATTERNS}', ""); +Expect(0, 10495, '\P{Braille PATTERNS}', ""); +Expect(1, 10495, '\P{^Braille PATTERNS}', ""); +Expect(0, 10239, '\p{Braille PATTERNS}', ""); +Expect(1, 10239, '\p{^Braille PATTERNS}', ""); +Expect(1, 10239, '\P{Braille PATTERNS}', ""); +Expect(0, 10239, '\P{^Braille PATTERNS}', ""); +Error('\p{_:=IsBraille patterns}'); +Error('\P{_:=IsBraille patterns}'); +Expect(1, 10495, '\p{isbraillepatterns}', ""); +Expect(0, 10495, '\p{^isbraillepatterns}', ""); +Expect(0, 10495, '\P{isbraillepatterns}', ""); +Expect(1, 10495, '\P{^isbraillepatterns}', ""); +Expect(0, 10239, '\p{isbraillepatterns}', ""); +Expect(1, 10239, '\p{^isbraillepatterns}', ""); +Expect(1, 10239, '\P{isbraillepatterns}', ""); +Expect(0, 10239, '\P{^isbraillepatterns}', ""); +Expect(1, 10495, '\p{_-Is_BRAILLEpatterns}', ""); +Expect(0, 10495, '\p{^_-Is_BRAILLEpatterns}', ""); +Expect(0, 10495, '\P{_-Is_BRAILLEpatterns}', ""); +Expect(1, 10495, '\P{^_-Is_BRAILLEpatterns}', ""); +Expect(0, 10239, '\p{_-Is_BRAILLEpatterns}', ""); +Expect(1, 10239, '\p{^_-Is_BRAILLEpatterns}', ""); +Expect(1, 10239, '\P{_-Is_BRAILLEpatterns}', ""); +Expect(0, 10239, '\P{^_-Is_BRAILLEpatterns}', ""); +Error('\p{- In BRAILLE:=Patterns}'); +Error('\P{- In BRAILLE:=Patterns}'); +Expect(1, 10495, '\p{inbraillepatterns}', ""); +Expect(0, 10495, '\p{^inbraillepatterns}', ""); +Expect(0, 10495, '\P{inbraillepatterns}', ""); +Expect(1, 10495, '\P{^inbraillepatterns}', ""); +Expect(0, 10239, '\p{inbraillepatterns}', ""); +Expect(1, 10239, '\p{^inbraillepatterns}', ""); +Expect(1, 10239, '\P{inbraillepatterns}', ""); +Expect(0, 10239, '\P{^inbraillepatterns}', ""); +Expect(1, 10495, '\p{ _IN_BraillePATTERNS}', ""); +Expect(0, 10495, '\p{^ _IN_BraillePATTERNS}', ""); +Expect(0, 10495, '\P{ _IN_BraillePATTERNS}', ""); +Expect(1, 10495, '\P{^ _IN_BraillePATTERNS}', ""); +Expect(0, 10239, '\p{ _IN_BraillePATTERNS}', ""); +Expect(1, 10239, '\p{^ _IN_BraillePATTERNS}', ""); +Expect(1, 10239, '\P{ _IN_BraillePATTERNS}', ""); +Expect(0, 10239, '\P{^ _IN_BraillePATTERNS}', ""); +Error('\p{:=__Katakana}'); +Error('\P{:=__Katakana}'); +Expect(1, 12538, '\p{katakana}', ""); +Expect(0, 12538, '\p{^katakana}', ""); +Expect(0, 12538, '\P{katakana}', ""); +Expect(1, 12538, '\P{^katakana}', ""); +Expect(0, 12448, '\p{katakana}', ""); +Expect(1, 12448, '\p{^katakana}', ""); +Expect(1, 12448, '\P{katakana}', ""); +Expect(0, 12448, '\P{^katakana}', ""); +Expect(1, 12538, '\p{ katakana}', ""); +Expect(0, 12538, '\p{^ katakana}', ""); +Expect(0, 12538, '\P{ katakana}', ""); +Expect(1, 12538, '\P{^ katakana}', ""); +Expect(0, 12448, '\p{ katakana}', ""); +Expect(1, 12448, '\p{^ katakana}', ""); +Expect(1, 12448, '\P{ katakana}', ""); +Expect(0, 12448, '\P{^ katakana}', ""); +Error('\p{/a/Is-KATAKANA}'); +Error('\P{/a/Is-KATAKANA}'); +Expect(1, 12538, '\p{iskatakana}', ""); +Expect(0, 12538, '\p{^iskatakana}', ""); +Expect(0, 12538, '\P{iskatakana}', ""); +Expect(1, 12538, '\P{^iskatakana}', ""); +Expect(0, 12448, '\p{iskatakana}', ""); +Expect(1, 12448, '\p{^iskatakana}', ""); +Expect(1, 12448, '\P{iskatakana}', ""); +Expect(0, 12448, '\P{^iskatakana}', ""); +Expect(1, 12538, '\p{Is KATAKANA}', ""); +Expect(0, 12538, '\p{^Is KATAKANA}', ""); +Expect(0, 12538, '\P{Is KATAKANA}', ""); +Expect(1, 12538, '\P{^Is KATAKANA}', ""); +Expect(0, 12448, '\p{Is KATAKANA}', ""); +Expect(1, 12448, '\p{^Is KATAKANA}', ""); +Expect(1, 12448, '\P{Is KATAKANA}', ""); +Expect(0, 12448, '\P{^Is KATAKANA}', ""); +Error('\p{:=_ Kana}'); +Error('\P{:=_ Kana}'); +Expect(1, 12538, '\p{kana}', ""); +Expect(0, 12538, '\p{^kana}', ""); +Expect(0, 12538, '\P{kana}', ""); +Expect(1, 12538, '\P{^kana}', ""); +Expect(0, 12448, '\p{kana}', ""); +Expect(1, 12448, '\p{^kana}', ""); +Expect(1, 12448, '\P{kana}', ""); +Expect(0, 12448, '\P{^kana}', ""); +Expect(1, 12538, '\p{ KANA}', ""); +Expect(0, 12538, '\p{^ KANA}', ""); +Expect(0, 12538, '\P{ KANA}', ""); +Expect(1, 12538, '\P{^ KANA}', ""); +Expect(0, 12448, '\p{ KANA}', ""); +Expect(1, 12448, '\p{^ KANA}', ""); +Expect(1, 12448, '\P{ KANA}', ""); +Expect(0, 12448, '\P{^ KANA}', ""); +Error('\p{:= -IsKana}'); +Error('\P{:= -IsKana}'); +Expect(1, 12538, '\p{iskana}', ""); +Expect(0, 12538, '\p{^iskana}', ""); +Expect(0, 12538, '\P{iskana}', ""); +Expect(1, 12538, '\P{^iskana}', ""); +Expect(0, 12448, '\p{iskana}', ""); +Expect(1, 12448, '\p{^iskana}', ""); +Expect(1, 12448, '\P{iskana}', ""); +Expect(0, 12448, '\P{^iskana}', ""); +Expect(1, 12538, '\p{_ Iskana}', ""); +Expect(0, 12538, '\p{^_ Iskana}', ""); +Expect(0, 12538, '\P{_ Iskana}', ""); +Expect(1, 12538, '\P{^_ Iskana}', ""); +Expect(0, 12448, '\p{_ Iskana}', ""); +Expect(1, 12448, '\p{^_ Iskana}', ""); +Expect(1, 12448, '\P{_ Iskana}', ""); +Expect(0, 12448, '\P{^_ Iskana}', ""); +Error('\p{ :=PATTERN_White-Space}'); +Error('\P{ :=PATTERN_White-Space}'); +Expect(1, 13, '\p{patternwhitespace}', ""); +Expect(0, 13, '\p{^patternwhitespace}', ""); +Expect(0, 13, '\P{patternwhitespace}', ""); +Expect(1, 13, '\P{^patternwhitespace}', ""); +Expect(0, 8, '\p{patternwhitespace}', ""); +Expect(1, 8, '\p{^patternwhitespace}', ""); +Expect(1, 8, '\P{patternwhitespace}', ""); +Expect(0, 8, '\P{^patternwhitespace}', ""); +Expect(1, 13, '\p{_-Pattern-WHITE Space}', ""); +Expect(0, 13, '\p{^_-Pattern-WHITE Space}', ""); +Expect(0, 13, '\P{_-Pattern-WHITE Space}', ""); +Expect(1, 13, '\P{^_-Pattern-WHITE Space}', ""); +Expect(0, 8, '\p{_-Pattern-WHITE Space}', ""); +Expect(1, 8, '\p{^_-Pattern-WHITE Space}', ""); +Expect(1, 8, '\P{_-Pattern-WHITE Space}', ""); +Expect(0, 8, '\P{^_-Pattern-WHITE Space}', ""); +Error('\p{ is/a/pattern_white-Space}'); +Error('\P{ is/a/pattern_white-Space}'); +Expect(1, 13, '\p{ispatternwhitespace}', ""); +Expect(0, 13, '\p{^ispatternwhitespace}', ""); +Expect(0, 13, '\P{ispatternwhitespace}', ""); +Expect(1, 13, '\P{^ispatternwhitespace}', ""); +Expect(0, 8, '\p{ispatternwhitespace}', ""); +Expect(1, 8, '\p{^ispatternwhitespace}', ""); +Expect(1, 8, '\P{ispatternwhitespace}', ""); +Expect(0, 8, '\P{^ispatternwhitespace}', ""); +Expect(1, 13, '\p{ _Is_PATTERN White SPACE}', ""); +Expect(0, 13, '\p{^ _Is_PATTERN White SPACE}', ""); +Expect(0, 13, '\P{ _Is_PATTERN White SPACE}', ""); +Expect(1, 13, '\P{^ _Is_PATTERN White SPACE}', ""); +Expect(0, 8, '\p{ _Is_PATTERN White SPACE}', ""); +Expect(1, 8, '\p{^ _Is_PATTERN White SPACE}', ""); +Expect(1, 8, '\P{ _Is_PATTERN White SPACE}', ""); +Expect(0, 8, '\P{^ _Is_PATTERN White SPACE}', ""); +Error('\p{:=__Pat-WS}'); +Error('\P{:=__Pat-WS}'); +Expect(1, 13, '\p{patws}', ""); +Expect(0, 13, '\p{^patws}', ""); +Expect(0, 13, '\P{patws}', ""); +Expect(1, 13, '\P{^patws}', ""); +Expect(0, 8, '\p{patws}', ""); +Expect(1, 8, '\p{^patws}', ""); +Expect(1, 8, '\P{patws}', ""); +Expect(0, 8, '\P{^patws}', ""); +Expect(1, 13, '\p{ PAT WS}', ""); +Expect(0, 13, '\p{^ PAT WS}', ""); +Expect(0, 13, '\P{ PAT WS}', ""); +Expect(1, 13, '\P{^ PAT WS}', ""); +Expect(0, 8, '\p{ PAT WS}', ""); +Expect(1, 8, '\p{^ PAT WS}', ""); +Expect(1, 8, '\P{ PAT WS}', ""); +Expect(0, 8, '\P{^ PAT WS}', ""); +Error('\p{- Is_PAT WS:=}'); +Error('\P{- Is_PAT WS:=}'); +Expect(1, 13, '\p{ispatws}', ""); +Expect(0, 13, '\p{^ispatws}', ""); +Expect(0, 13, '\P{ispatws}', ""); +Expect(1, 13, '\P{^ispatws}', ""); +Expect(0, 8, '\p{ispatws}', ""); +Expect(1, 8, '\p{^ispatws}', ""); +Expect(1, 8, '\P{ispatws}', ""); +Expect(0, 8, '\P{^ispatws}', ""); +Expect(1, 13, '\p{_ Ispat ws}', ""); +Expect(0, 13, '\p{^_ Ispat ws}', ""); +Expect(0, 13, '\P{_ Ispat ws}', ""); +Expect(1, 13, '\P{^_ Ispat ws}', ""); +Expect(0, 8, '\p{_ Ispat ws}', ""); +Expect(1, 8, '\p{^_ Ispat ws}', ""); +Expect(1, 8, '\P{_ Ispat ws}', ""); +Expect(0, 8, '\P{^_ Ispat ws}', ""); +Error('\p{_:=NONCHARACTERCode_point}'); +Error('\P{_:=NONCHARACTERCode_point}'); +Expect(0, 64975, '\p{noncharactercodepoint}', ""); +Expect(1, 64975, '\p{^noncharactercodepoint}', ""); +Expect(1, 64975, '\P{noncharactercodepoint}', ""); +Expect(0, 64975, '\P{^noncharactercodepoint}', ""); +Expect(0, 64975, '\p{-NONCHARACTERCode-POINT}', ""); +Expect(1, 64975, '\p{^-NONCHARACTERCode-POINT}', ""); +Expect(1, 64975, '\P{-NONCHARACTERCode-POINT}', ""); +Expect(0, 64975, '\P{^-NONCHARACTERCode-POINT}', ""); +Error('\p{Is NONCHARACTER:=CodePoint}'); +Error('\P{Is NONCHARACTER:=CodePoint}'); +Expect(0, 64975, '\p{isnoncharactercodepoint}', ""); +Expect(1, 64975, '\p{^isnoncharactercodepoint}', ""); +Expect(1, 64975, '\P{isnoncharactercodepoint}', ""); +Expect(0, 64975, '\P{^isnoncharactercodepoint}', ""); +Expect(0, 64975, '\p{-Is_noncharacter codePOINT}', ""); +Expect(1, 64975, '\p{^-Is_noncharacter codePOINT}', ""); +Expect(1, 64975, '\P{-Is_noncharacter codePOINT}', ""); +Expect(0, 64975, '\P{^-Is_noncharacter codePOINT}', ""); +Error('\p{/a/ nchar}'); +Error('\P{/a/ nchar}'); +Expect(0, 64975, '\p{nchar}', ""); +Expect(1, 64975, '\p{^nchar}', ""); +Expect(1, 64975, '\P{nchar}', ""); +Expect(0, 64975, '\P{^nchar}', ""); +Expect(0, 64975, '\p{ NCHAR}', ""); +Expect(1, 64975, '\p{^ NCHAR}', ""); +Expect(1, 64975, '\P{ NCHAR}', ""); +Expect(0, 64975, '\P{^ NCHAR}', ""); +Error('\p{_ IS NCHAR/a/}'); +Error('\P{_ IS NCHAR/a/}'); +Expect(0, 64975, '\p{isnchar}', ""); +Expect(1, 64975, '\p{^isnchar}', ""); +Expect(1, 64975, '\P{isnchar}', ""); +Expect(0, 64975, '\P{^isnchar}', ""); +Expect(0, 64975, '\p{_-IsNChar}', ""); +Expect(1, 64975, '\p{^_-IsNChar}', ""); +Expect(1, 64975, '\P{_-IsNChar}', ""); +Expect(0, 64975, '\P{^_-IsNChar}', ""); +Error('\p{ In:=OGHAM}'); +Error('\P{ In:=OGHAM}'); +Expect(1, 5791, '\p{inogham}', ""); +Expect(0, 5791, '\p{^inogham}', ""); +Expect(0, 5791, '\P{inogham}', ""); +Expect(1, 5791, '\P{^inogham}', ""); +Expect(0, 5759, '\p{inogham}', ""); +Expect(1, 5759, '\p{^inogham}', ""); +Expect(1, 5759, '\P{inogham}', ""); +Expect(0, 5759, '\P{^inogham}', ""); +Expect(1, 5791, '\p{ In Ogham}', ""); +Expect(0, 5791, '\p{^ In Ogham}', ""); +Expect(0, 5791, '\P{ In Ogham}', ""); +Expect(1, 5791, '\P{^ In Ogham}', ""); +Expect(0, 5759, '\p{ In Ogham}', ""); +Expect(1, 5759, '\p{^ In Ogham}', ""); +Expect(1, 5759, '\P{ In Ogham}', ""); +Expect(0, 5759, '\P{^ In Ogham}', ""); +Error('\p{/a/ -Alphabetic Presentation Forms}'); +Error('\P{/a/ -Alphabetic Presentation Forms}'); +Expect(1, 64335, '\p{alphabeticpresentationforms}', ""); +Expect(0, 64335, '\p{^alphabeticpresentationforms}', ""); +Expect(0, 64335, '\P{alphabeticpresentationforms}', ""); +Expect(1, 64335, '\P{^alphabeticpresentationforms}', ""); +Expect(0, 64255, '\p{alphabeticpresentationforms}', ""); +Expect(1, 64255, '\p{^alphabeticpresentationforms}', ""); +Expect(1, 64255, '\P{alphabeticpresentationforms}', ""); +Expect(0, 64255, '\P{^alphabeticpresentationforms}', ""); +Expect(1, 64335, '\p{_Alphabetic presentationFORMS}', ""); +Expect(0, 64335, '\p{^_Alphabetic presentationFORMS}', ""); +Expect(0, 64335, '\P{_Alphabetic presentationFORMS}', ""); +Expect(1, 64335, '\P{^_Alphabetic presentationFORMS}', ""); +Expect(0, 64255, '\p{_Alphabetic presentationFORMS}', ""); +Expect(1, 64255, '\p{^_Alphabetic presentationFORMS}', ""); +Expect(1, 64255, '\P{_Alphabetic presentationFORMS}', ""); +Expect(0, 64255, '\P{^_Alphabetic presentationFORMS}', ""); +Error('\p{ :=IS_alphabetic PRESENTATION forms}'); +Error('\P{ :=IS_alphabetic PRESENTATION forms}'); +Expect(1, 64335, '\p{isalphabeticpresentationforms}', ""); +Expect(0, 64335, '\p{^isalphabeticpresentationforms}', ""); +Expect(0, 64335, '\P{isalphabeticpresentationforms}', ""); +Expect(1, 64335, '\P{^isalphabeticpresentationforms}', ""); +Expect(0, 64255, '\p{isalphabeticpresentationforms}', ""); +Expect(1, 64255, '\p{^isalphabeticpresentationforms}', ""); +Expect(1, 64255, '\P{isalphabeticpresentationforms}', ""); +Expect(0, 64255, '\P{^isalphabeticpresentationforms}', ""); +Expect(1, 64335, '\p{ is-Alphabetic Presentation forms}', ""); +Expect(0, 64335, '\p{^ is-Alphabetic Presentation forms}', ""); +Expect(0, 64335, '\P{ is-Alphabetic Presentation forms}', ""); +Expect(1, 64335, '\P{^ is-Alphabetic Presentation forms}', ""); +Expect(0, 64255, '\p{ is-Alphabetic Presentation forms}', ""); +Expect(1, 64255, '\p{^ is-Alphabetic Presentation forms}', ""); +Expect(1, 64255, '\P{ is-Alphabetic Presentation forms}', ""); +Expect(0, 64255, '\P{^ is-Alphabetic Presentation forms}', ""); +Error('\p{- IN_ALPHABETIC-Presentation Forms:=}'); +Error('\P{- IN_ALPHABETIC-Presentation Forms:=}'); +Expect(1, 64335, '\p{inalphabeticpresentationforms}', ""); +Expect(0, 64335, '\p{^inalphabeticpresentationforms}', ""); +Expect(0, 64335, '\P{inalphabeticpresentationforms}', ""); +Expect(1, 64335, '\P{^inalphabeticpresentationforms}', ""); +Expect(0, 64255, '\p{inalphabeticpresentationforms}', ""); +Expect(1, 64255, '\p{^inalphabeticpresentationforms}', ""); +Expect(1, 64255, '\P{inalphabeticpresentationforms}', ""); +Expect(0, 64255, '\P{^inalphabeticpresentationforms}', ""); +Expect(1, 64335, '\p{ In ALPHABETIC Presentation-FORMS}', ""); +Expect(0, 64335, '\p{^ In ALPHABETIC Presentation-FORMS}', ""); +Expect(0, 64335, '\P{ In ALPHABETIC Presentation-FORMS}', ""); +Expect(1, 64335, '\P{^ In ALPHABETIC Presentation-FORMS}', ""); +Expect(0, 64255, '\p{ In ALPHABETIC Presentation-FORMS}', ""); +Expect(1, 64255, '\p{^ In ALPHABETIC Presentation-FORMS}', ""); +Expect(1, 64255, '\P{ In ALPHABETIC Presentation-FORMS}', ""); +Expect(0, 64255, '\P{^ In ALPHABETIC Presentation-FORMS}', ""); +Error('\p{:=_Domino tiles}'); +Error('\P{:=_Domino tiles}'); +Expect(1, 127135, '\p{dominotiles}', ""); +Expect(0, 127135, '\p{^dominotiles}', ""); +Expect(0, 127135, '\P{dominotiles}', ""); +Expect(1, 127135, '\P{^dominotiles}', ""); +Expect(0, 127023, '\p{dominotiles}', ""); +Expect(1, 127023, '\p{^dominotiles}', ""); +Expect(1, 127023, '\P{dominotiles}', ""); +Expect(0, 127023, '\P{^dominotiles}', ""); +Expect(1, 127135, '\p{DOMINO_tiles}', ""); +Expect(0, 127135, '\p{^DOMINO_tiles}', ""); +Expect(0, 127135, '\P{DOMINO_tiles}', ""); +Expect(1, 127135, '\P{^DOMINO_tiles}', ""); +Expect(0, 127023, '\p{DOMINO_tiles}', ""); +Expect(1, 127023, '\p{^DOMINO_tiles}', ""); +Expect(1, 127023, '\P{DOMINO_tiles}', ""); +Expect(0, 127023, '\P{^DOMINO_tiles}', ""); +Error('\p{ Is-domino:=Tiles}'); +Error('\P{ Is-domino:=Tiles}'); +Expect(1, 127135, '\p{isdominotiles}', ""); +Expect(0, 127135, '\p{^isdominotiles}', ""); +Expect(0, 127135, '\P{isdominotiles}', ""); +Expect(1, 127135, '\P{^isdominotiles}', ""); +Expect(0, 127023, '\p{isdominotiles}', ""); +Expect(1, 127023, '\p{^isdominotiles}', ""); +Expect(1, 127023, '\P{isdominotiles}', ""); +Expect(0, 127023, '\P{^isdominotiles}', ""); +Expect(1, 127135, '\p{ is Domino tiles}', ""); +Expect(0, 127135, '\p{^ is Domino tiles}', ""); +Expect(0, 127135, '\P{ is Domino tiles}', ""); +Expect(1, 127135, '\P{^ is Domino tiles}', ""); +Expect(0, 127023, '\p{ is Domino tiles}', ""); +Expect(1, 127023, '\p{^ is Domino tiles}', ""); +Expect(1, 127023, '\P{ is Domino tiles}', ""); +Expect(0, 127023, '\P{^ is Domino tiles}', ""); +Error('\p{-INDomino/a/TILES}'); +Error('\P{-INDomino/a/TILES}'); +Expect(1, 127135, '\p{indominotiles}', ""); +Expect(0, 127135, '\p{^indominotiles}', ""); +Expect(0, 127135, '\P{indominotiles}', ""); +Expect(1, 127135, '\P{^indominotiles}', ""); +Expect(0, 127023, '\p{indominotiles}', ""); +Expect(1, 127023, '\p{^indominotiles}', ""); +Expect(1, 127023, '\P{indominotiles}', ""); +Expect(0, 127023, '\P{^indominotiles}', ""); +Expect(1, 127135, '\p{ Indomino-tiles}', ""); +Expect(0, 127135, '\p{^ Indomino-tiles}', ""); +Expect(0, 127135, '\P{ Indomino-tiles}', ""); +Expect(1, 127135, '\P{^ Indomino-tiles}', ""); +Expect(0, 127023, '\p{ Indomino-tiles}', ""); +Expect(1, 127023, '\p{^ Indomino-tiles}', ""); +Expect(1, 127023, '\P{ Indomino-tiles}', ""); +Expect(0, 127023, '\P{^ Indomino-tiles}', ""); +Error('\p{/a/ In-Kayah LI}'); +Error('\P{/a/ In-Kayah LI}'); +Expect(1, 43311, '\p{inkayahli}', ""); +Expect(0, 43311, '\p{^inkayahli}', ""); +Expect(0, 43311, '\P{inkayahli}', ""); +Expect(1, 43311, '\P{^inkayahli}', ""); +Expect(0, 43263, '\p{inkayahli}', ""); +Expect(1, 43263, '\p{^inkayahli}', ""); +Expect(1, 43263, '\P{inkayahli}', ""); +Expect(0, 43263, '\P{^inkayahli}', ""); +Expect(1, 43311, '\p{-_In Kayah-Li}', ""); +Expect(0, 43311, '\p{^-_In Kayah-Li}', ""); +Expect(0, 43311, '\P{-_In Kayah-Li}', ""); +Expect(1, 43311, '\P{^-_In Kayah-Li}', ""); +Expect(0, 43263, '\p{-_In Kayah-Li}', ""); +Expect(1, 43263, '\p{^-_In Kayah-Li}', ""); +Expect(1, 43263, '\P{-_In Kayah-Li}', ""); +Expect(0, 43263, '\P{^-_In Kayah-Li}', ""); +Error('\p{ _uppercase:=letter}'); +Error('\P{ _uppercase:=letter}'); +Expect(1, 90, '\p{uppercaseletter}', ""); +Expect(0, 90, '\p{^uppercaseletter}', ""); +Expect(0, 90, '\P{uppercaseletter}', ""); +Expect(1, 90, '\P{^uppercaseletter}', ""); +Expect(0, 64, '\p{uppercaseletter}', ""); +Expect(1, 64, '\p{^uppercaseletter}', ""); +Expect(1, 64, '\P{uppercaseletter}', ""); +Expect(0, 64, '\P{^uppercaseletter}', ""); +Expect(1, 90, '\p{--uppercase_letter}', ""); +Expect(0, 90, '\p{^--uppercase_letter}', ""); +Expect(0, 90, '\P{--uppercase_letter}', ""); +Expect(1, 90, '\P{^--uppercase_letter}', ""); +Expect(0, 64, '\p{--uppercase_letter}', ""); +Expect(1, 64, '\p{^--uppercase_letter}', ""); +Expect(1, 64, '\P{--uppercase_letter}', ""); +Expect(0, 64, '\P{^--uppercase_letter}', ""); +Error('\p{__is-UPPERCASE/a/Letter}'); +Error('\P{__is-UPPERCASE/a/Letter}'); +Expect(1, 90, '\p{isuppercaseletter}', ""); +Expect(0, 90, '\p{^isuppercaseletter}', ""); +Expect(0, 90, '\P{isuppercaseletter}', ""); +Expect(1, 90, '\P{^isuppercaseletter}', ""); +Expect(0, 64, '\p{isuppercaseletter}', ""); +Expect(1, 64, '\p{^isuppercaseletter}', ""); +Expect(1, 64, '\P{isuppercaseletter}', ""); +Expect(0, 64, '\P{^isuppercaseletter}', ""); +Expect(1, 90, '\p{ Isuppercase-Letter}', ""); +Expect(0, 90, '\p{^ Isuppercase-Letter}', ""); +Expect(0, 90, '\P{ Isuppercase-Letter}', ""); +Expect(1, 90, '\P{^ Isuppercase-Letter}', ""); +Expect(0, 64, '\p{ Isuppercase-Letter}', ""); +Expect(1, 64, '\p{^ Isuppercase-Letter}', ""); +Expect(1, 64, '\P{ Isuppercase-Letter}', ""); +Expect(0, 64, '\P{^ Isuppercase-Letter}', ""); +Error('\p{ Lu:=}'); +Error('\P{ Lu:=}'); +Expect(1, 90, '\p{lu}', ""); +Expect(0, 90, '\p{^lu}', ""); +Expect(0, 90, '\P{lu}', ""); +Expect(1, 90, '\P{^lu}', ""); +Expect(0, 64, '\p{lu}', ""); +Expect(1, 64, '\p{^lu}', ""); +Expect(1, 64, '\P{lu}', ""); +Expect(0, 64, '\P{^lu}', ""); +Expect(1, 90, '\p{ -Lu}', ""); +Expect(0, 90, '\p{^ -Lu}', ""); +Expect(0, 90, '\P{ -Lu}', ""); +Expect(1, 90, '\P{^ -Lu}', ""); +Expect(0, 64, '\p{ -Lu}', ""); +Expect(1, 64, '\p{^ -Lu}', ""); +Expect(1, 64, '\P{ -Lu}', ""); +Expect(0, 64, '\P{^ -Lu}', ""); +Error('\p{ Is Lu/a/}'); +Error('\P{ Is Lu/a/}'); +Expect(1, 90, '\p{islu}', ""); +Expect(0, 90, '\p{^islu}', ""); +Expect(0, 90, '\P{islu}', ""); +Expect(1, 90, '\P{^islu}', ""); +Expect(0, 64, '\p{islu}', ""); +Expect(1, 64, '\p{^islu}', ""); +Expect(1, 64, '\P{islu}', ""); +Expect(0, 64, '\P{^islu}', ""); +Expect(1, 90, '\p{is Lu}', ""); +Expect(0, 90, '\p{^is Lu}', ""); +Expect(0, 90, '\P{is Lu}', ""); +Expect(1, 90, '\P{^is Lu}', ""); +Expect(0, 64, '\p{is Lu}', ""); +Expect(1, 64, '\p{^is Lu}', ""); +Expect(1, 64, '\P{is Lu}', ""); +Expect(0, 64, '\P{^is Lu}', ""); +Error('\p{_ tai/a/Le}'); +Error('\P{_ tai/a/Le}'); +Expect(1, 6509, '\p{taile}', ""); +Expect(0, 6509, '\p{^taile}', ""); +Expect(0, 6509, '\P{taile}', ""); +Expect(1, 6509, '\P{^taile}', ""); +Expect(0, 6479, '\p{taile}', ""); +Expect(1, 6479, '\p{^taile}', ""); +Expect(1, 6479, '\P{taile}', ""); +Expect(0, 6479, '\P{^taile}', ""); +Expect(1, 6509, '\p{__tai_LE}', ""); +Expect(0, 6509, '\p{^__tai_LE}', ""); +Expect(0, 6509, '\P{__tai_LE}', ""); +Expect(1, 6509, '\P{^__tai_LE}', ""); +Expect(0, 6479, '\p{__tai_LE}', ""); +Expect(1, 6479, '\p{^__tai_LE}', ""); +Expect(1, 6479, '\P{__tai_LE}', ""); +Expect(0, 6479, '\P{^__tai_LE}', ""); +Error('\p{ is:=Tai-le}'); +Error('\P{ is:=Tai-le}'); +Expect(1, 6509, '\p{istaile}', ""); +Expect(0, 6509, '\p{^istaile}', ""); +Expect(0, 6509, '\P{istaile}', ""); +Expect(1, 6509, '\P{^istaile}', ""); +Expect(0, 6479, '\p{istaile}', ""); +Expect(1, 6479, '\p{^istaile}', ""); +Expect(1, 6479, '\P{istaile}', ""); +Expect(0, 6479, '\P{^istaile}', ""); +Expect(1, 6509, '\p{-Is TAI-LE}', ""); +Expect(0, 6509, '\p{^-Is TAI-LE}', ""); +Expect(0, 6509, '\P{-Is TAI-LE}', ""); +Expect(1, 6509, '\P{^-Is TAI-LE}', ""); +Expect(0, 6479, '\p{-Is TAI-LE}', ""); +Expect(1, 6479, '\p{^-Is TAI-LE}', ""); +Expect(1, 6479, '\P{-Is TAI-LE}', ""); +Expect(0, 6479, '\P{^-Is TAI-LE}', ""); +Error('\p{ :=tale}'); +Error('\P{ :=tale}'); +Expect(1, 6509, '\p{tale}', ""); +Expect(0, 6509, '\p{^tale}', ""); +Expect(0, 6509, '\P{tale}', ""); +Expect(1, 6509, '\P{^tale}', ""); +Expect(0, 6479, '\p{tale}', ""); +Expect(1, 6479, '\p{^tale}', ""); +Expect(1, 6479, '\P{tale}', ""); +Expect(0, 6479, '\P{^tale}', ""); +Expect(1, 6509, '\p{ Tale}', ""); +Expect(0, 6509, '\p{^ Tale}', ""); +Expect(0, 6509, '\P{ Tale}', ""); +Expect(1, 6509, '\P{^ Tale}', ""); +Expect(0, 6479, '\p{ Tale}', ""); +Expect(1, 6479, '\p{^ Tale}', ""); +Expect(1, 6479, '\P{ Tale}', ""); +Expect(0, 6479, '\P{^ Tale}', ""); +Error('\p{ -IS/a/tale}'); +Error('\P{ -IS/a/tale}'); +Expect(1, 6509, '\p{istale}', ""); +Expect(0, 6509, '\p{^istale}', ""); +Expect(0, 6509, '\P{istale}', ""); +Expect(1, 6509, '\P{^istale}', ""); +Expect(0, 6479, '\p{istale}', ""); +Expect(1, 6479, '\p{^istale}', ""); +Expect(1, 6479, '\P{istale}', ""); +Expect(0, 6479, '\P{^istale}', ""); +Expect(1, 6509, '\p{--Is-Tale}', ""); +Expect(0, 6509, '\p{^--Is-Tale}', ""); +Expect(0, 6509, '\P{--Is-Tale}', ""); +Expect(1, 6509, '\P{^--Is-Tale}', ""); +Expect(0, 6479, '\p{--Is-Tale}', ""); +Expect(1, 6479, '\p{^--Is-Tale}', ""); +Expect(1, 6479, '\P{--Is-Tale}', ""); +Expect(0, 6479, '\P{^--Is-Tale}', ""); +Error('\p{-XDigit/a/}'); +Error('\P{-XDigit/a/}'); +Expect(1, 57, '\p{xdigit}', ""); +Expect(0, 57, '\p{^xdigit}', ""); +Expect(0, 57, '\P{xdigit}', ""); +Expect(1, 57, '\P{^xdigit}', ""); +Expect(0, 47, '\p{xdigit}', ""); +Expect(1, 47, '\p{^xdigit}', ""); +Expect(1, 47, '\P{xdigit}', ""); +Expect(0, 47, '\P{^xdigit}', ""); +Expect(1, 57, '\p{_ xdigit}', ""); +Expect(0, 57, '\p{^_ xdigit}', ""); +Expect(0, 57, '\P{_ xdigit}', ""); +Expect(1, 57, '\P{^_ xdigit}', ""); +Expect(0, 47, '\p{_ xdigit}', ""); +Expect(1, 47, '\p{^_ xdigit}', ""); +Expect(1, 47, '\P{_ xdigit}', ""); +Expect(0, 47, '\P{^_ xdigit}', ""); +Error('\p{-/a/IS XDigit}'); +Error('\P{-/a/IS XDigit}'); +Expect(1, 57, '\p{isxdigit}', ""); +Expect(0, 57, '\p{^isxdigit}', ""); +Expect(0, 57, '\P{isxdigit}', ""); +Expect(1, 57, '\P{^isxdigit}', ""); +Expect(0, 47, '\p{isxdigit}', ""); +Expect(1, 47, '\p{^isxdigit}', ""); +Expect(1, 47, '\P{isxdigit}', ""); +Expect(0, 47, '\P{^isxdigit}', ""); +Expect(1, 57, '\p{ IS XDIGIT}', ""); +Expect(0, 57, '\p{^ IS XDIGIT}', ""); +Expect(0, 57, '\P{ IS XDIGIT}', ""); +Expect(1, 57, '\P{^ IS XDIGIT}', ""); +Expect(0, 47, '\p{ IS XDIGIT}', ""); +Expect(1, 47, '\p{^ IS XDIGIT}', ""); +Expect(1, 47, '\P{ IS XDIGIT}', ""); +Expect(0, 47, '\P{^ IS XDIGIT}', ""); +Error('\p{ :=ascii Hex_Digit}'); +Error('\P{ :=ascii Hex_Digit}'); +Expect(1, 57, '\p{asciihexdigit}', ""); +Expect(0, 57, '\p{^asciihexdigit}', ""); +Expect(0, 57, '\P{asciihexdigit}', ""); +Expect(1, 57, '\P{^asciihexdigit}', ""); +Expect(0, 47, '\p{asciihexdigit}', ""); +Expect(1, 47, '\p{^asciihexdigit}', ""); +Expect(1, 47, '\P{asciihexdigit}', ""); +Expect(0, 47, '\P{^asciihexdigit}', ""); +Expect(1, 57, '\p{ asciiHEX_digit}', ""); +Expect(0, 57, '\p{^ asciiHEX_digit}', ""); +Expect(0, 57, '\P{ asciiHEX_digit}', ""); +Expect(1, 57, '\P{^ asciiHEX_digit}', ""); +Expect(0, 47, '\p{ asciiHEX_digit}', ""); +Expect(1, 47, '\p{^ asciiHEX_digit}', ""); +Expect(1, 47, '\P{ asciiHEX_digit}', ""); +Expect(0, 47, '\P{^ asciiHEX_digit}', ""); +Error('\p{-Is ascii/a/Hex-digit}'); +Error('\P{-Is ascii/a/Hex-digit}'); +Expect(1, 57, '\p{isasciihexdigit}', ""); +Expect(0, 57, '\p{^isasciihexdigit}', ""); +Expect(0, 57, '\P{isasciihexdigit}', ""); +Expect(1, 57, '\P{^isasciihexdigit}', ""); +Expect(0, 47, '\p{isasciihexdigit}', ""); +Expect(1, 47, '\p{^isasciihexdigit}', ""); +Expect(1, 47, '\P{isasciihexdigit}', ""); +Expect(0, 47, '\P{^isasciihexdigit}', ""); +Expect(1, 57, '\p{ is_ASCII_HEXdigit}', ""); +Expect(0, 57, '\p{^ is_ASCII_HEXdigit}', ""); +Expect(0, 57, '\P{ is_ASCII_HEXdigit}', ""); +Expect(1, 57, '\P{^ is_ASCII_HEXdigit}', ""); +Expect(0, 47, '\p{ is_ASCII_HEXdigit}', ""); +Expect(1, 47, '\p{^ is_ASCII_HEXdigit}', ""); +Expect(1, 47, '\P{ is_ASCII_HEXdigit}', ""); +Expect(0, 47, '\P{^ is_ASCII_HEXdigit}', ""); +Error('\p{/a/--AHEX}'); +Error('\P{/a/--AHEX}'); +Expect(1, 57, '\p{ahex}', ""); +Expect(0, 57, '\p{^ahex}', ""); +Expect(0, 57, '\P{ahex}', ""); +Expect(1, 57, '\P{^ahex}', ""); +Expect(0, 47, '\p{ahex}', ""); +Expect(1, 47, '\p{^ahex}', ""); +Expect(1, 47, '\P{ahex}', ""); +Expect(0, 47, '\P{^ahex}', ""); +Expect(1, 57, '\p{ AHEX}', ""); +Expect(0, 57, '\p{^ AHEX}', ""); +Expect(0, 57, '\P{ AHEX}', ""); +Expect(1, 57, '\P{^ AHEX}', ""); +Expect(0, 47, '\p{ AHEX}', ""); +Expect(1, 47, '\p{^ AHEX}', ""); +Expect(1, 47, '\P{ AHEX}', ""); +Expect(0, 47, '\P{^ AHEX}', ""); +Error('\p{:=Is ahex}'); +Error('\P{:=Is ahex}'); +Expect(1, 57, '\p{isahex}', ""); +Expect(0, 57, '\p{^isahex}', ""); +Expect(0, 57, '\P{isahex}', ""); +Expect(1, 57, '\P{^isahex}', ""); +Expect(0, 47, '\p{isahex}', ""); +Expect(1, 47, '\p{^isahex}', ""); +Expect(1, 47, '\P{isahex}', ""); +Expect(0, 47, '\P{^isahex}', ""); +Expect(1, 57, '\p{ is-AHex}', ""); +Expect(0, 57, '\p{^ is-AHex}', ""); +Expect(0, 57, '\P{ is-AHex}', ""); +Expect(1, 57, '\P{^ is-AHex}', ""); +Expect(0, 47, '\p{ is-AHex}', ""); +Expect(1, 47, '\p{^ is-AHex}', ""); +Expect(1, 47, '\P{ is-AHex}', ""); +Expect(0, 47, '\P{^ is-AHex}', ""); +Error('\p{:=REJANG}'); +Error('\P{:=REJANG}'); +Expect(1, 43347, '\p{rejang}', ""); +Expect(0, 43347, '\p{^rejang}', ""); +Expect(0, 43347, '\P{rejang}', ""); +Expect(1, 43347, '\P{^rejang}', ""); +Expect(0, 43311, '\p{rejang}', ""); +Expect(1, 43311, '\p{^rejang}', ""); +Expect(1, 43311, '\P{rejang}', ""); +Expect(0, 43311, '\P{^rejang}', ""); +Expect(1, 43347, '\p{ rejang}', ""); +Expect(0, 43347, '\p{^ rejang}', ""); +Expect(0, 43347, '\P{ rejang}', ""); +Expect(1, 43347, '\P{^ rejang}', ""); +Expect(0, 43311, '\p{ rejang}', ""); +Expect(1, 43311, '\p{^ rejang}', ""); +Expect(1, 43311, '\P{ rejang}', ""); +Expect(0, 43311, '\P{^ rejang}', ""); +Error('\p{-Is/a/Rejang}'); +Error('\P{-Is/a/Rejang}'); +Expect(1, 43347, '\p{isrejang}', ""); +Expect(0, 43347, '\p{^isrejang}', ""); +Expect(0, 43347, '\P{isrejang}', ""); +Expect(1, 43347, '\P{^isrejang}', ""); +Expect(0, 43311, '\p{isrejang}', ""); +Expect(1, 43311, '\p{^isrejang}', ""); +Expect(1, 43311, '\P{isrejang}', ""); +Expect(0, 43311, '\P{^isrejang}', ""); +Expect(1, 43347, '\p{__Is_Rejang}', ""); +Expect(0, 43347, '\p{^__Is_Rejang}', ""); +Expect(0, 43347, '\P{__Is_Rejang}', ""); +Expect(1, 43347, '\P{^__Is_Rejang}', ""); +Expect(0, 43311, '\p{__Is_Rejang}', ""); +Expect(1, 43311, '\p{^__Is_Rejang}', ""); +Expect(1, 43311, '\P{__Is_Rejang}', ""); +Expect(0, 43311, '\P{^__Is_Rejang}', ""); +Error('\p{/a/_Rjng}'); +Error('\P{/a/_Rjng}'); +Expect(1, 43347, '\p{rjng}', ""); +Expect(0, 43347, '\p{^rjng}', ""); +Expect(0, 43347, '\P{rjng}', ""); +Expect(1, 43347, '\P{^rjng}', ""); +Expect(0, 43311, '\p{rjng}', ""); +Expect(1, 43311, '\p{^rjng}', ""); +Expect(1, 43311, '\P{rjng}', ""); +Expect(0, 43311, '\P{^rjng}', ""); +Expect(1, 43347, '\p{ RJNG}', ""); +Expect(0, 43347, '\p{^ RJNG}', ""); +Expect(0, 43347, '\P{ RJNG}', ""); +Expect(1, 43347, '\P{^ RJNG}', ""); +Expect(0, 43311, '\p{ RJNG}', ""); +Expect(1, 43311, '\p{^ RJNG}', ""); +Expect(1, 43311, '\P{ RJNG}', ""); +Expect(0, 43311, '\P{^ RJNG}', ""); +Error('\p{/a/is RJNG}'); +Error('\P{/a/is RJNG}'); +Expect(1, 43347, '\p{isrjng}', ""); +Expect(0, 43347, '\p{^isrjng}', ""); +Expect(0, 43347, '\P{isrjng}', ""); +Expect(1, 43347, '\P{^isrjng}', ""); +Expect(0, 43311, '\p{isrjng}', ""); +Expect(1, 43311, '\p{^isrjng}', ""); +Expect(1, 43311, '\P{isrjng}', ""); +Expect(0, 43311, '\P{^isrjng}', ""); +Expect(1, 43347, '\p{ Is Rjng}', ""); +Expect(0, 43347, '\p{^ Is Rjng}', ""); +Expect(0, 43347, '\P{ Is Rjng}', ""); +Expect(1, 43347, '\P{^ Is Rjng}', ""); +Expect(0, 43311, '\p{ Is Rjng}', ""); +Expect(1, 43311, '\p{^ Is Rjng}', ""); +Expect(1, 43311, '\P{ Is Rjng}', ""); +Expect(0, 43311, '\P{^ Is Rjng}', ""); +Error('\p{:=Glagolitic}'); +Error('\P{:=Glagolitic}'); +Expect(1, 11310, '\p{glagolitic}', ""); +Expect(0, 11310, '\p{^glagolitic}', ""); +Expect(0, 11310, '\P{glagolitic}', ""); +Expect(1, 11310, '\P{^glagolitic}', ""); +Expect(0, 11263, '\p{glagolitic}', ""); +Expect(1, 11263, '\p{^glagolitic}', ""); +Expect(1, 11263, '\P{glagolitic}', ""); +Expect(0, 11263, '\P{^glagolitic}', ""); +Expect(1, 11310, '\p{_-GLAGOLITIC}', ""); +Expect(0, 11310, '\p{^_-GLAGOLITIC}', ""); +Expect(0, 11310, '\P{_-GLAGOLITIC}', ""); +Expect(1, 11310, '\P{^_-GLAGOLITIC}', ""); +Expect(0, 11263, '\p{_-GLAGOLITIC}', ""); +Expect(1, 11263, '\p{^_-GLAGOLITIC}', ""); +Expect(1, 11263, '\P{_-GLAGOLITIC}', ""); +Expect(0, 11263, '\P{^_-GLAGOLITIC}', ""); +Error('\p{/a/ Is Glagolitic}'); +Error('\P{/a/ Is Glagolitic}'); +Expect(1, 11310, '\p{isglagolitic}', ""); +Expect(0, 11310, '\p{^isglagolitic}', ""); +Expect(0, 11310, '\P{isglagolitic}', ""); +Expect(1, 11310, '\P{^isglagolitic}', ""); +Expect(0, 11263, '\p{isglagolitic}', ""); +Expect(1, 11263, '\p{^isglagolitic}', ""); +Expect(1, 11263, '\P{isglagolitic}', ""); +Expect(0, 11263, '\P{^isglagolitic}', ""); +Expect(1, 11310, '\p{ IS-glagolitic}', ""); +Expect(0, 11310, '\p{^ IS-glagolitic}', ""); +Expect(0, 11310, '\P{ IS-glagolitic}', ""); +Expect(1, 11310, '\P{^ IS-glagolitic}', ""); +Expect(0, 11263, '\p{ IS-glagolitic}', ""); +Expect(1, 11263, '\p{^ IS-glagolitic}', ""); +Expect(1, 11263, '\P{ IS-glagolitic}', ""); +Expect(0, 11263, '\P{^ IS-glagolitic}', ""); +Error('\p{:=GLAG}'); +Error('\P{:=GLAG}'); +Expect(1, 11310, '\p{glag}', ""); +Expect(0, 11310, '\p{^glag}', ""); +Expect(0, 11310, '\P{glag}', ""); +Expect(1, 11310, '\P{^glag}', ""); +Expect(0, 11263, '\p{glag}', ""); +Expect(1, 11263, '\p{^glag}', ""); +Expect(1, 11263, '\P{glag}', ""); +Expect(0, 11263, '\P{^glag}', ""); +Expect(1, 11310, '\p{- GLAG}', ""); +Expect(0, 11310, '\p{^- GLAG}', ""); +Expect(0, 11310, '\P{- GLAG}', ""); +Expect(1, 11310, '\P{^- GLAG}', ""); +Expect(0, 11263, '\p{- GLAG}', ""); +Expect(1, 11263, '\p{^- GLAG}', ""); +Expect(1, 11263, '\P{- GLAG}', ""); +Expect(0, 11263, '\P{^- GLAG}', ""); +Error('\p{_IS:=Glag}'); +Error('\P{_IS:=Glag}'); +Expect(1, 11310, '\p{isglag}', ""); +Expect(0, 11310, '\p{^isglag}', ""); +Expect(0, 11310, '\P{isglag}', ""); +Expect(1, 11310, '\P{^isglag}', ""); +Expect(0, 11263, '\p{isglag}', ""); +Expect(1, 11263, '\p{^isglag}', ""); +Expect(1, 11263, '\P{isglag}', ""); +Expect(0, 11263, '\P{^isglag}', ""); +Expect(1, 11310, '\p{- Is Glag}', ""); +Expect(0, 11310, '\p{^- Is Glag}', ""); +Expect(0, 11310, '\P{- Is Glag}', ""); +Expect(1, 11310, '\P{^- Is Glag}', ""); +Expect(0, 11263, '\p{- Is Glag}', ""); +Expect(1, 11263, '\p{^- Is Glag}', ""); +Expect(1, 11263, '\P{- Is Glag}', ""); +Expect(0, 11263, '\P{^- Is Glag}', ""); +Error('\p{ :=in OL Chiki}'); +Error('\P{ :=in OL Chiki}'); +Expect(1, 7295, '\p{inolchiki}', ""); +Expect(0, 7295, '\p{^inolchiki}', ""); +Expect(0, 7295, '\P{inolchiki}', ""); +Expect(1, 7295, '\P{^inolchiki}', ""); +Expect(0, 7247, '\p{inolchiki}', ""); +Expect(1, 7247, '\p{^inolchiki}', ""); +Expect(1, 7247, '\P{inolchiki}', ""); +Expect(0, 7247, '\P{^inolchiki}', ""); +Expect(1, 7295, '\p{ _IN Ol-Chiki}', ""); +Expect(0, 7295, '\p{^ _IN Ol-Chiki}', ""); +Expect(0, 7295, '\P{ _IN Ol-Chiki}', ""); +Expect(1, 7295, '\P{^ _IN Ol-Chiki}', ""); +Expect(0, 7247, '\p{ _IN Ol-Chiki}', ""); +Expect(1, 7247, '\p{^ _IN Ol-Chiki}', ""); +Expect(1, 7247, '\P{ _IN Ol-Chiki}', ""); +Expect(0, 7247, '\P{^ _IN Ol-Chiki}', ""); +Error('\p{ cjk/a/strokes}'); +Error('\P{ cjk/a/strokes}'); +Expect(1, 12783, '\p{cjkstrokes}', ""); +Expect(0, 12783, '\p{^cjkstrokes}', ""); +Expect(0, 12783, '\P{cjkstrokes}', ""); +Expect(1, 12783, '\P{^cjkstrokes}', ""); +Expect(0, 12735, '\p{cjkstrokes}', ""); +Expect(1, 12735, '\p{^cjkstrokes}', ""); +Expect(1, 12735, '\P{cjkstrokes}', ""); +Expect(0, 12735, '\P{^cjkstrokes}', ""); +Expect(1, 12783, '\p{ CJK Strokes}', ""); +Expect(0, 12783, '\p{^ CJK Strokes}', ""); +Expect(0, 12783, '\P{ CJK Strokes}', ""); +Expect(1, 12783, '\P{^ CJK Strokes}', ""); +Expect(0, 12735, '\p{ CJK Strokes}', ""); +Expect(1, 12735, '\p{^ CJK Strokes}', ""); +Expect(1, 12735, '\P{ CJK Strokes}', ""); +Expect(0, 12735, '\P{^ CJK Strokes}', ""); +Error('\p{ is CJK Strokes:=}'); +Error('\P{ is CJK Strokes:=}'); +Expect(1, 12783, '\p{iscjkstrokes}', ""); +Expect(0, 12783, '\p{^iscjkstrokes}', ""); +Expect(0, 12783, '\P{iscjkstrokes}', ""); +Expect(1, 12783, '\P{^iscjkstrokes}', ""); +Expect(0, 12735, '\p{iscjkstrokes}', ""); +Expect(1, 12735, '\p{^iscjkstrokes}', ""); +Expect(1, 12735, '\P{iscjkstrokes}', ""); +Expect(0, 12735, '\P{^iscjkstrokes}', ""); +Expect(1, 12783, '\p{-is cjkSTROKES}', ""); +Expect(0, 12783, '\p{^-is cjkSTROKES}', ""); +Expect(0, 12783, '\P{-is cjkSTROKES}', ""); +Expect(1, 12783, '\P{^-is cjkSTROKES}', ""); +Expect(0, 12735, '\p{-is cjkSTROKES}', ""); +Expect(1, 12735, '\p{^-is cjkSTROKES}', ""); +Expect(1, 12735, '\P{-is cjkSTROKES}', ""); +Expect(0, 12735, '\P{^-is cjkSTROKES}', ""); +Error('\p{ _In CJK:=STROKES}'); +Error('\P{ _In CJK:=STROKES}'); +Expect(1, 12783, '\p{incjkstrokes}', ""); +Expect(0, 12783, '\p{^incjkstrokes}', ""); +Expect(0, 12783, '\P{incjkstrokes}', ""); +Expect(1, 12783, '\P{^incjkstrokes}', ""); +Expect(0, 12735, '\p{incjkstrokes}', ""); +Expect(1, 12735, '\p{^incjkstrokes}', ""); +Expect(1, 12735, '\P{incjkstrokes}', ""); +Expect(0, 12735, '\P{^incjkstrokes}', ""); +Expect(1, 12783, '\p{ inCJK strokes}', ""); +Expect(0, 12783, '\p{^ inCJK strokes}', ""); +Expect(0, 12783, '\P{ inCJK strokes}', ""); +Expect(1, 12783, '\P{^ inCJK strokes}', ""); +Expect(0, 12735, '\p{ inCJK strokes}', ""); +Expect(1, 12735, '\p{^ inCJK strokes}', ""); +Expect(1, 12735, '\P{ inCJK strokes}', ""); +Expect(0, 12735, '\P{^ inCJK strokes}', ""); +Error('\p{/a/--sinhala}'); +Error('\P{/a/--sinhala}'); +Expect(1, 3459, '\p{sinhala}', ""); +Expect(0, 3459, '\p{^sinhala}', ""); +Expect(0, 3459, '\P{sinhala}', ""); +Expect(1, 3459, '\P{^sinhala}', ""); +Expect(0, 3457, '\p{sinhala}', ""); +Expect(1, 3457, '\p{^sinhala}', ""); +Expect(1, 3457, '\P{sinhala}', ""); +Expect(0, 3457, '\P{^sinhala}', ""); +Expect(1, 3459, '\p{ sinhala}', ""); +Expect(0, 3459, '\p{^ sinhala}', ""); +Expect(0, 3459, '\P{ sinhala}', ""); +Expect(1, 3459, '\P{^ sinhala}', ""); +Expect(0, 3457, '\p{ sinhala}', ""); +Expect(1, 3457, '\p{^ sinhala}', ""); +Expect(1, 3457, '\P{ sinhala}', ""); +Expect(0, 3457, '\P{^ sinhala}', ""); +Error('\p{__Is:=SINHALA}'); +Error('\P{__Is:=SINHALA}'); +Expect(1, 3459, '\p{issinhala}', ""); +Expect(0, 3459, '\p{^issinhala}', ""); +Expect(0, 3459, '\P{issinhala}', ""); +Expect(1, 3459, '\P{^issinhala}', ""); +Expect(0, 3457, '\p{issinhala}', ""); +Expect(1, 3457, '\p{^issinhala}', ""); +Expect(1, 3457, '\P{issinhala}', ""); +Expect(0, 3457, '\P{^issinhala}', ""); +Expect(1, 3459, '\p{_IS SINHALA}', ""); +Expect(0, 3459, '\p{^_IS SINHALA}', ""); +Expect(0, 3459, '\P{_IS SINHALA}', ""); +Expect(1, 3459, '\P{^_IS SINHALA}', ""); +Expect(0, 3457, '\p{_IS SINHALA}', ""); +Expect(1, 3457, '\p{^_IS SINHALA}', ""); +Expect(1, 3457, '\P{_IS SINHALA}', ""); +Expect(0, 3457, '\P{^_IS SINHALA}', ""); +Error('\p{:=_-Sinh}'); +Error('\P{:=_-Sinh}'); +Expect(1, 3459, '\p{sinh}', ""); +Expect(0, 3459, '\p{^sinh}', ""); +Expect(0, 3459, '\P{sinh}', ""); +Expect(1, 3459, '\P{^sinh}', ""); +Expect(0, 3457, '\p{sinh}', ""); +Expect(1, 3457, '\p{^sinh}', ""); +Expect(1, 3457, '\P{sinh}', ""); +Expect(0, 3457, '\P{^sinh}', ""); +Expect(1, 3459, '\p{ sinh}', ""); +Expect(0, 3459, '\p{^ sinh}', ""); +Expect(0, 3459, '\P{ sinh}', ""); +Expect(1, 3459, '\P{^ sinh}', ""); +Expect(0, 3457, '\p{ sinh}', ""); +Expect(1, 3457, '\p{^ sinh}', ""); +Expect(1, 3457, '\P{ sinh}', ""); +Expect(0, 3457, '\P{^ sinh}', ""); +Error('\p{ -is:=SINH}'); +Error('\P{ -is:=SINH}'); +Expect(1, 3459, '\p{issinh}', ""); +Expect(0, 3459, '\p{^issinh}', ""); +Expect(0, 3459, '\P{issinh}', ""); +Expect(1, 3459, '\P{^issinh}', ""); +Expect(0, 3457, '\p{issinh}', ""); +Expect(1, 3457, '\p{^issinh}', ""); +Expect(1, 3457, '\P{issinh}', ""); +Expect(0, 3457, '\P{^issinh}', ""); +Expect(1, 3459, '\p{ -IS Sinh}', ""); +Expect(0, 3459, '\p{^ -IS Sinh}', ""); +Expect(0, 3459, '\P{ -IS Sinh}', ""); +Expect(1, 3459, '\P{^ -IS Sinh}', ""); +Expect(0, 3457, '\p{ -IS Sinh}', ""); +Expect(1, 3457, '\p{^ -IS Sinh}', ""); +Expect(1, 3457, '\P{ -IS Sinh}', ""); +Expect(0, 3457, '\P{^ -IS Sinh}', ""); +Error('\p{_/a/UGARITIC}'); +Error('\P{_/a/UGARITIC}'); +Expect(1, 66461, '\p{ugaritic}', ""); +Expect(0, 66461, '\p{^ugaritic}', ""); +Expect(0, 66461, '\P{ugaritic}', ""); +Expect(1, 66461, '\P{^ugaritic}', ""); +Expect(0, 66431, '\p{ugaritic}', ""); +Expect(1, 66431, '\p{^ugaritic}', ""); +Expect(1, 66431, '\P{ugaritic}', ""); +Expect(0, 66431, '\P{^ugaritic}', ""); +Expect(1, 66461, '\p{_Ugaritic}', ""); +Expect(0, 66461, '\p{^_Ugaritic}', ""); +Expect(0, 66461, '\P{_Ugaritic}', ""); +Expect(1, 66461, '\P{^_Ugaritic}', ""); +Expect(0, 66431, '\p{_Ugaritic}', ""); +Expect(1, 66431, '\p{^_Ugaritic}', ""); +Expect(1, 66431, '\P{_Ugaritic}', ""); +Expect(0, 66431, '\P{^_Ugaritic}', ""); +Error('\p{ _is/a/Ugaritic}'); +Error('\P{ _is/a/Ugaritic}'); +Expect(1, 66461, '\p{isugaritic}', ""); +Expect(0, 66461, '\p{^isugaritic}', ""); +Expect(0, 66461, '\P{isugaritic}', ""); +Expect(1, 66461, '\P{^isugaritic}', ""); +Expect(0, 66431, '\p{isugaritic}', ""); +Expect(1, 66431, '\p{^isugaritic}', ""); +Expect(1, 66431, '\P{isugaritic}', ""); +Expect(0, 66431, '\P{^isugaritic}', ""); +Expect(1, 66461, '\p{ _Is Ugaritic}', ""); +Expect(0, 66461, '\p{^ _Is Ugaritic}', ""); +Expect(0, 66461, '\P{ _Is Ugaritic}', ""); +Expect(1, 66461, '\P{^ _Is Ugaritic}', ""); +Expect(0, 66431, '\p{ _Is Ugaritic}', ""); +Expect(1, 66431, '\p{^ _Is Ugaritic}', ""); +Expect(1, 66431, '\P{ _Is Ugaritic}', ""); +Expect(0, 66431, '\P{^ _Is Ugaritic}', ""); +Error('\p{_-UGAR:=}'); +Error('\P{_-UGAR:=}'); +Expect(1, 66461, '\p{ugar}', ""); +Expect(0, 66461, '\p{^ugar}', ""); +Expect(0, 66461, '\P{ugar}', ""); +Expect(1, 66461, '\P{^ugar}', ""); +Expect(0, 66431, '\p{ugar}', ""); +Expect(1, 66431, '\p{^ugar}', ""); +Expect(1, 66431, '\P{ugar}', ""); +Expect(0, 66431, '\P{^ugar}', ""); +Expect(1, 66461, '\p{_ugar}', ""); +Expect(0, 66461, '\p{^_ugar}', ""); +Expect(0, 66461, '\P{_ugar}', ""); +Expect(1, 66461, '\P{^_ugar}', ""); +Expect(0, 66431, '\p{_ugar}', ""); +Expect(1, 66431, '\p{^_ugar}', ""); +Expect(1, 66431, '\P{_ugar}', ""); +Expect(0, 66431, '\P{^_ugar}', ""); +Error('\p{ Is UGAR/a/}'); +Error('\P{ Is UGAR/a/}'); +Expect(1, 66461, '\p{isugar}', ""); +Expect(0, 66461, '\p{^isugar}', ""); +Expect(0, 66461, '\P{isugar}', ""); +Expect(1, 66461, '\P{^isugar}', ""); +Expect(0, 66431, '\p{isugar}', ""); +Expect(1, 66431, '\p{^isugar}', ""); +Expect(1, 66431, '\P{isugar}', ""); +Expect(0, 66431, '\P{^isugar}', ""); +Expect(1, 66461, '\p{ Is_Ugar}', ""); +Expect(0, 66461, '\p{^ Is_Ugar}', ""); +Expect(0, 66461, '\P{ Is_Ugar}', ""); +Expect(1, 66461, '\P{^ Is_Ugar}', ""); +Expect(0, 66431, '\p{ Is_Ugar}', ""); +Expect(1, 66431, '\p{^ Is_Ugar}', ""); +Expect(1, 66431, '\P{ Is_Ugar}', ""); +Expect(0, 66431, '\P{^ Is_Ugar}', ""); +Error('\p{_/a/OGHAM}'); +Error('\P{_/a/OGHAM}'); +Expect(1, 5788, '\p{ogham}', ""); +Expect(0, 5788, '\p{^ogham}', ""); +Expect(0, 5788, '\P{ogham}', ""); +Expect(1, 5788, '\P{^ogham}', ""); +Expect(0, 5759, '\p{ogham}', ""); +Expect(1, 5759, '\p{^ogham}', ""); +Expect(1, 5759, '\P{ogham}', ""); +Expect(0, 5759, '\P{^ogham}', ""); +Expect(1, 5788, '\p{ OGHAM}', ""); +Expect(0, 5788, '\p{^ OGHAM}', ""); +Expect(0, 5788, '\P{ OGHAM}', ""); +Expect(1, 5788, '\P{^ OGHAM}', ""); +Expect(0, 5759, '\p{ OGHAM}', ""); +Expect(1, 5759, '\p{^ OGHAM}', ""); +Expect(1, 5759, '\P{ OGHAM}', ""); +Expect(0, 5759, '\P{^ OGHAM}', ""); +Error('\p{-IS:=Ogham}'); +Error('\P{-IS:=Ogham}'); +Expect(1, 5788, '\p{isogham}', ""); +Expect(0, 5788, '\p{^isogham}', ""); +Expect(0, 5788, '\P{isogham}', ""); +Expect(1, 5788, '\P{^isogham}', ""); +Expect(0, 5759, '\p{isogham}', ""); +Expect(1, 5759, '\p{^isogham}', ""); +Expect(1, 5759, '\P{isogham}', ""); +Expect(0, 5759, '\P{^isogham}', ""); +Expect(1, 5788, '\p{ is Ogham}', ""); +Expect(0, 5788, '\p{^ is Ogham}', ""); +Expect(0, 5788, '\P{ is Ogham}', ""); +Expect(1, 5788, '\P{^ is Ogham}', ""); +Expect(0, 5759, '\p{ is Ogham}', ""); +Expect(1, 5759, '\p{^ is Ogham}', ""); +Expect(1, 5759, '\P{ is Ogham}', ""); +Expect(0, 5759, '\P{^ is Ogham}', ""); +Error('\p{_:=OGAM}'); +Error('\P{_:=OGAM}'); +Expect(1, 5788, '\p{ogam}', ""); +Expect(0, 5788, '\p{^ogam}', ""); +Expect(0, 5788, '\P{ogam}', ""); +Expect(1, 5788, '\P{^ogam}', ""); +Expect(0, 5759, '\p{ogam}', ""); +Expect(1, 5759, '\p{^ogam}', ""); +Expect(1, 5759, '\P{ogam}', ""); +Expect(0, 5759, '\P{^ogam}', ""); +Expect(1, 5788, '\p{ _Ogam}', ""); +Expect(0, 5788, '\p{^ _Ogam}', ""); +Expect(0, 5788, '\P{ _Ogam}', ""); +Expect(1, 5788, '\P{^ _Ogam}', ""); +Expect(0, 5759, '\p{ _Ogam}', ""); +Expect(1, 5759, '\p{^ _Ogam}', ""); +Expect(1, 5759, '\P{ _Ogam}', ""); +Expect(0, 5759, '\P{^ _Ogam}', ""); +Error('\p{:= _isOgam}'); +Error('\P{:= _isOgam}'); +Expect(1, 5788, '\p{isogam}', ""); +Expect(0, 5788, '\p{^isogam}', ""); +Expect(0, 5788, '\P{isogam}', ""); +Expect(1, 5788, '\P{^isogam}', ""); +Expect(0, 5759, '\p{isogam}', ""); +Expect(1, 5759, '\p{^isogam}', ""); +Expect(1, 5759, '\P{isogam}', ""); +Expect(0, 5759, '\P{^isogam}', ""); +Expect(1, 5788, '\p{ -Isogam}', ""); +Expect(0, 5788, '\p{^ -Isogam}', ""); +Expect(0, 5788, '\P{ -Isogam}', ""); +Expect(1, 5788, '\P{^ -Isogam}', ""); +Expect(0, 5759, '\p{ -Isogam}', ""); +Expect(1, 5759, '\p{^ -Isogam}', ""); +Expect(1, 5759, '\P{ -Isogam}', ""); +Expect(0, 5759, '\P{^ -Isogam}', ""); +Error('\p{ Bengali:=}'); +Error('\P{ Bengali:=}'); +Expect(1, 2435, '\p{bengali}', ""); +Expect(0, 2435, '\p{^bengali}', ""); +Expect(0, 2435, '\P{bengali}', ""); +Expect(1, 2435, '\P{^bengali}', ""); +Expect(0, 2432, '\p{bengali}', ""); +Expect(1, 2432, '\p{^bengali}', ""); +Expect(1, 2432, '\P{bengali}', ""); +Expect(0, 2432, '\P{^bengali}', ""); +Expect(1, 2435, '\p{ bengali}', ""); +Expect(0, 2435, '\p{^ bengali}', ""); +Expect(0, 2435, '\P{ bengali}', ""); +Expect(1, 2435, '\P{^ bengali}', ""); +Expect(0, 2432, '\p{ bengali}', ""); +Expect(1, 2432, '\p{^ bengali}', ""); +Expect(1, 2432, '\P{ bengali}', ""); +Expect(0, 2432, '\P{^ bengali}', ""); +Error('\p{/a/ IS-Bengali}'); +Error('\P{/a/ IS-Bengali}'); +Expect(1, 2435, '\p{isbengali}', ""); +Expect(0, 2435, '\p{^isbengali}', ""); +Expect(0, 2435, '\P{isbengali}', ""); +Expect(1, 2435, '\P{^isbengali}', ""); +Expect(0, 2432, '\p{isbengali}', ""); +Expect(1, 2432, '\p{^isbengali}', ""); +Expect(1, 2432, '\P{isbengali}', ""); +Expect(0, 2432, '\P{^isbengali}', ""); +Expect(1, 2435, '\p{-isBENGALI}', ""); +Expect(0, 2435, '\p{^-isBENGALI}', ""); +Expect(0, 2435, '\P{-isBENGALI}', ""); +Expect(1, 2435, '\P{^-isBENGALI}', ""); +Expect(0, 2432, '\p{-isBENGALI}', ""); +Expect(1, 2432, '\p{^-isBENGALI}', ""); +Expect(1, 2432, '\P{-isBENGALI}', ""); +Expect(0, 2432, '\P{^-isBENGALI}', ""); +Error('\p{_/a/Beng}'); +Error('\P{_/a/Beng}'); +Expect(1, 2435, '\p{beng}', ""); +Expect(0, 2435, '\p{^beng}', ""); +Expect(0, 2435, '\P{beng}', ""); +Expect(1, 2435, '\P{^beng}', ""); +Expect(0, 2432, '\p{beng}', ""); +Expect(1, 2432, '\p{^beng}', ""); +Expect(1, 2432, '\P{beng}', ""); +Expect(0, 2432, '\P{^beng}', ""); +Expect(1, 2435, '\p{-_beng}', ""); +Expect(0, 2435, '\p{^-_beng}', ""); +Expect(0, 2435, '\P{-_beng}', ""); +Expect(1, 2435, '\P{^-_beng}', ""); +Expect(0, 2432, '\p{-_beng}', ""); +Expect(1, 2432, '\p{^-_beng}', ""); +Expect(1, 2432, '\P{-_beng}', ""); +Expect(0, 2432, '\P{^-_beng}', ""); +Error('\p{:= IS beng}'); +Error('\P{:= IS beng}'); +Expect(1, 2435, '\p{isbeng}', ""); +Expect(0, 2435, '\p{^isbeng}', ""); +Expect(0, 2435, '\P{isbeng}', ""); +Expect(1, 2435, '\P{^isbeng}', ""); +Expect(0, 2432, '\p{isbeng}', ""); +Expect(1, 2432, '\p{^isbeng}', ""); +Expect(1, 2432, '\P{isbeng}', ""); +Expect(0, 2432, '\P{^isbeng}', ""); +Expect(1, 2435, '\p{ Is-BENG}', ""); +Expect(0, 2435, '\p{^ Is-BENG}', ""); +Expect(0, 2435, '\P{ Is-BENG}', ""); +Expect(1, 2435, '\P{^ Is-BENG}', ""); +Expect(0, 2432, '\p{ Is-BENG}', ""); +Expect(1, 2432, '\p{^ Is-BENG}', ""); +Expect(1, 2432, '\P{ Is-BENG}', ""); +Expect(0, 2432, '\P{^ Is-BENG}', ""); +Error('\p{-diacritic/a/}'); +Error('\P{-diacritic/a/}'); +Expect(1, 94, '\p{diacritic}', ""); +Expect(0, 94, '\p{^diacritic}', ""); +Expect(0, 94, '\P{diacritic}', ""); +Expect(1, 94, '\P{^diacritic}', ""); +Expect(0, 93, '\p{diacritic}', ""); +Expect(1, 93, '\p{^diacritic}', ""); +Expect(1, 93, '\P{diacritic}', ""); +Expect(0, 93, '\P{^diacritic}', ""); +Expect(1, 94, '\p{ _Diacritic}', ""); +Expect(0, 94, '\p{^ _Diacritic}', ""); +Expect(0, 94, '\P{ _Diacritic}', ""); +Expect(1, 94, '\P{^ _Diacritic}', ""); +Expect(0, 93, '\p{ _Diacritic}', ""); +Expect(1, 93, '\p{^ _Diacritic}', ""); +Expect(1, 93, '\P{ _Diacritic}', ""); +Expect(0, 93, '\P{^ _Diacritic}', ""); +Error('\p{ :=is_diacritic}'); +Error('\P{ :=is_diacritic}'); +Expect(1, 94, '\p{isdiacritic}', ""); +Expect(0, 94, '\p{^isdiacritic}', ""); +Expect(0, 94, '\P{isdiacritic}', ""); +Expect(1, 94, '\P{^isdiacritic}', ""); +Expect(0, 93, '\p{isdiacritic}', ""); +Expect(1, 93, '\p{^isdiacritic}', ""); +Expect(1, 93, '\P{isdiacritic}', ""); +Expect(0, 93, '\P{^isdiacritic}', ""); +Expect(1, 94, '\p{_-is diacritic}', ""); +Expect(0, 94, '\p{^_-is diacritic}', ""); +Expect(0, 94, '\P{_-is diacritic}', ""); +Expect(1, 94, '\P{^_-is diacritic}', ""); +Expect(0, 93, '\p{_-is diacritic}', ""); +Expect(1, 93, '\p{^_-is diacritic}', ""); +Expect(1, 93, '\P{_-is diacritic}', ""); +Expect(0, 93, '\P{^_-is diacritic}', ""); +Error('\p{_/a/Dia}'); +Error('\P{_/a/Dia}'); +Expect(1, 94, '\p{dia}', ""); +Expect(0, 94, '\p{^dia}', ""); +Expect(0, 94, '\P{dia}', ""); +Expect(1, 94, '\P{^dia}', ""); +Expect(0, 93, '\p{dia}', ""); +Expect(1, 93, '\p{^dia}', ""); +Expect(1, 93, '\P{dia}', ""); +Expect(0, 93, '\P{^dia}', ""); +Expect(1, 94, '\p{ Dia}', ""); +Expect(0, 94, '\p{^ Dia}', ""); +Expect(0, 94, '\P{ Dia}', ""); +Expect(1, 94, '\P{^ Dia}', ""); +Expect(0, 93, '\p{ Dia}', ""); +Expect(1, 93, '\p{^ Dia}', ""); +Expect(1, 93, '\P{ Dia}', ""); +Expect(0, 93, '\P{^ Dia}', ""); +Error('\p{ Is DIA:=}'); +Error('\P{ Is DIA:=}'); +Expect(1, 94, '\p{isdia}', ""); +Expect(0, 94, '\p{^isdia}', ""); +Expect(0, 94, '\P{isdia}', ""); +Expect(1, 94, '\P{^isdia}', ""); +Expect(0, 93, '\p{isdia}', ""); +Expect(1, 93, '\p{^isdia}', ""); +Expect(1, 93, '\P{isdia}', ""); +Expect(0, 93, '\P{^isdia}', ""); +Expect(1, 94, '\p{_ Isdia}', ""); +Expect(0, 94, '\p{^_ Isdia}', ""); +Expect(0, 94, '\P{_ Isdia}', ""); +Expect(1, 94, '\P{^_ Isdia}', ""); +Expect(0, 93, '\p{_ Isdia}', ""); +Expect(1, 93, '\p{^_ Isdia}', ""); +Expect(1, 93, '\P{_ Isdia}', ""); +Expect(0, 93, '\P{^_ Isdia}', ""); +Error('\p{/a/lowercase LETTER}'); +Error('\P{/a/lowercase LETTER}'); +Expect(1, 122, '\p{lowercaseletter}', ""); +Expect(0, 122, '\p{^lowercaseletter}', ""); +Expect(0, 122, '\P{lowercaseletter}', ""); +Expect(1, 122, '\P{^lowercaseletter}', ""); +Expect(0, 96, '\p{lowercaseletter}', ""); +Expect(1, 96, '\p{^lowercaseletter}', ""); +Expect(1, 96, '\P{lowercaseletter}', ""); +Expect(0, 96, '\P{^lowercaseletter}', ""); +Expect(1, 122, '\p{ LOWERCASE letter}', ""); +Expect(0, 122, '\p{^ LOWERCASE letter}', ""); +Expect(0, 122, '\P{ LOWERCASE letter}', ""); +Expect(1, 122, '\P{^ LOWERCASE letter}', ""); +Expect(0, 96, '\p{ LOWERCASE letter}', ""); +Expect(1, 96, '\p{^ LOWERCASE letter}', ""); +Expect(1, 96, '\P{ LOWERCASE letter}', ""); +Expect(0, 96, '\P{^ LOWERCASE letter}', ""); +Error('\p{__Is/a/lowercaseletter}'); +Error('\P{__Is/a/lowercaseletter}'); +Expect(1, 122, '\p{islowercaseletter}', ""); +Expect(0, 122, '\p{^islowercaseletter}', ""); +Expect(0, 122, '\P{islowercaseletter}', ""); +Expect(1, 122, '\P{^islowercaseletter}', ""); +Expect(0, 96, '\p{islowercaseletter}', ""); +Expect(1, 96, '\p{^islowercaseletter}', ""); +Expect(1, 96, '\P{islowercaseletter}', ""); +Expect(0, 96, '\P{^islowercaseletter}', ""); +Expect(1, 122, '\p{ IS-Lowercase Letter}', ""); +Expect(0, 122, '\p{^ IS-Lowercase Letter}', ""); +Expect(0, 122, '\P{ IS-Lowercase Letter}', ""); +Expect(1, 122, '\P{^ IS-Lowercase Letter}', ""); +Expect(0, 96, '\p{ IS-Lowercase Letter}', ""); +Expect(1, 96, '\p{^ IS-Lowercase Letter}', ""); +Expect(1, 96, '\P{ IS-Lowercase Letter}', ""); +Expect(0, 96, '\P{^ IS-Lowercase Letter}', ""); +Error('\p{_ Ll:=}'); +Error('\P{_ Ll:=}'); +Expect(1, 122, '\p{ll}', ""); +Expect(0, 122, '\p{^ll}', ""); +Expect(0, 122, '\P{ll}', ""); +Expect(1, 122, '\P{^ll}', ""); +Expect(0, 96, '\p{ll}', ""); +Expect(1, 96, '\p{^ll}', ""); +Expect(1, 96, '\P{ll}', ""); +Expect(0, 96, '\P{^ll}', ""); +Expect(1, 122, '\p{_-Ll}', ""); +Expect(0, 122, '\p{^_-Ll}', ""); +Expect(0, 122, '\P{_-Ll}', ""); +Expect(1, 122, '\P{^_-Ll}', ""); +Expect(0, 96, '\p{_-Ll}', ""); +Expect(1, 96, '\p{^_-Ll}', ""); +Expect(1, 96, '\P{_-Ll}', ""); +Expect(0, 96, '\P{^_-Ll}', ""); +Error('\p{-Is:=LL}'); +Error('\P{-Is:=LL}'); +Expect(1, 122, '\p{isll}', ""); +Expect(0, 122, '\p{^isll}', ""); +Expect(0, 122, '\P{isll}', ""); +Expect(1, 122, '\P{^isll}', ""); +Expect(0, 96, '\p{isll}', ""); +Expect(1, 96, '\p{^isll}', ""); +Expect(1, 96, '\P{isll}', ""); +Expect(0, 96, '\P{^isll}', ""); +Expect(1, 122, '\p{__IS_Ll}', ""); +Expect(0, 122, '\p{^__IS_Ll}', ""); +Expect(0, 122, '\P{__IS_Ll}', ""); +Expect(1, 122, '\P{^__IS_Ll}', ""); +Expect(0, 96, '\p{__IS_Ll}', ""); +Expect(1, 96, '\p{^__IS_Ll}', ""); +Expect(1, 96, '\P{__IS_Ll}', ""); +Expect(0, 96, '\P{^__IS_Ll}', ""); +Error('\p{-HANGUL-COMPATIBILITYJamo/a/}'); +Error('\P{-HANGUL-COMPATIBILITYJamo/a/}'); +Expect(1, 12687, '\p{hangulcompatibilityjamo}', ""); +Expect(0, 12687, '\p{^hangulcompatibilityjamo}', ""); +Expect(0, 12687, '\P{hangulcompatibilityjamo}', ""); +Expect(1, 12687, '\P{^hangulcompatibilityjamo}', ""); +Expect(0, 12591, '\p{hangulcompatibilityjamo}', ""); +Expect(1, 12591, '\p{^hangulcompatibilityjamo}', ""); +Expect(1, 12591, '\P{hangulcompatibilityjamo}', ""); +Expect(0, 12591, '\P{^hangulcompatibilityjamo}', ""); +Expect(1, 12687, '\p{ Hangul COMPATIBILITY jamo}', ""); +Expect(0, 12687, '\p{^ Hangul COMPATIBILITY jamo}', ""); +Expect(0, 12687, '\P{ Hangul COMPATIBILITY jamo}', ""); +Expect(1, 12687, '\P{^ Hangul COMPATIBILITY jamo}', ""); +Expect(0, 12591, '\p{ Hangul COMPATIBILITY jamo}', ""); +Expect(1, 12591, '\p{^ Hangul COMPATIBILITY jamo}', ""); +Expect(1, 12591, '\P{ Hangul COMPATIBILITY jamo}', ""); +Expect(0, 12591, '\P{^ Hangul COMPATIBILITY jamo}', ""); +Error('\p{_IsHANGUL-Compatibility:=Jamo}'); +Error('\P{_IsHANGUL-Compatibility:=Jamo}'); +Expect(1, 12687, '\p{ishangulcompatibilityjamo}', ""); +Expect(0, 12687, '\p{^ishangulcompatibilityjamo}', ""); +Expect(0, 12687, '\P{ishangulcompatibilityjamo}', ""); +Expect(1, 12687, '\P{^ishangulcompatibilityjamo}', ""); +Expect(0, 12591, '\p{ishangulcompatibilityjamo}', ""); +Expect(1, 12591, '\p{^ishangulcompatibilityjamo}', ""); +Expect(1, 12591, '\P{ishangulcompatibilityjamo}', ""); +Expect(0, 12591, '\P{^ishangulcompatibilityjamo}', ""); +Expect(1, 12687, '\p{_ isHangul Compatibility-JAMO}', ""); +Expect(0, 12687, '\p{^_ isHangul Compatibility-JAMO}', ""); +Expect(0, 12687, '\P{_ isHangul Compatibility-JAMO}', ""); +Expect(1, 12687, '\P{^_ isHangul Compatibility-JAMO}', ""); +Expect(0, 12591, '\p{_ isHangul Compatibility-JAMO}', ""); +Expect(1, 12591, '\p{^_ isHangul Compatibility-JAMO}', ""); +Expect(1, 12591, '\P{_ isHangul Compatibility-JAMO}', ""); +Expect(0, 12591, '\P{^_ isHangul Compatibility-JAMO}', ""); +Error('\p{ _IN_hangul-COMPATIBILITY-jamo/a/}'); +Error('\P{ _IN_hangul-COMPATIBILITY-jamo/a/}'); +Expect(1, 12687, '\p{inhangulcompatibilityjamo}', ""); +Expect(0, 12687, '\p{^inhangulcompatibilityjamo}', ""); +Expect(0, 12687, '\P{inhangulcompatibilityjamo}', ""); +Expect(1, 12687, '\P{^inhangulcompatibilityjamo}', ""); +Expect(0, 12591, '\p{inhangulcompatibilityjamo}', ""); +Expect(1, 12591, '\p{^inhangulcompatibilityjamo}', ""); +Expect(1, 12591, '\P{inhangulcompatibilityjamo}', ""); +Expect(0, 12591, '\P{^inhangulcompatibilityjamo}', ""); +Expect(1, 12687, '\p{ -In_hangul Compatibility Jamo}', ""); +Expect(0, 12687, '\p{^ -In_hangul Compatibility Jamo}', ""); +Expect(0, 12687, '\P{ -In_hangul Compatibility Jamo}', ""); +Expect(1, 12687, '\P{^ -In_hangul Compatibility Jamo}', ""); +Expect(0, 12591, '\p{ -In_hangul Compatibility Jamo}', ""); +Expect(1, 12591, '\p{^ -In_hangul Compatibility Jamo}', ""); +Expect(1, 12591, '\P{ -In_hangul Compatibility Jamo}', ""); +Expect(0, 12591, '\P{^ -In_hangul Compatibility Jamo}', ""); +Error('\p{ -Musical-Symbols/a/}'); +Error('\P{ -Musical-Symbols/a/}'); +Expect(1, 119295, '\p{musicalsymbols}', ""); +Expect(0, 119295, '\p{^musicalsymbols}', ""); +Expect(0, 119295, '\P{musicalsymbols}', ""); +Expect(1, 119295, '\P{^musicalsymbols}', ""); +Expect(0, 119039, '\p{musicalsymbols}', ""); +Expect(1, 119039, '\p{^musicalsymbols}', ""); +Expect(1, 119039, '\P{musicalsymbols}', ""); +Expect(0, 119039, '\P{^musicalsymbols}', ""); +Expect(1, 119295, '\p{ _Musical-Symbols}', ""); +Expect(0, 119295, '\p{^ _Musical-Symbols}', ""); +Expect(0, 119295, '\P{ _Musical-Symbols}', ""); +Expect(1, 119295, '\P{^ _Musical-Symbols}', ""); +Expect(0, 119039, '\p{ _Musical-Symbols}', ""); +Expect(1, 119039, '\p{^ _Musical-Symbols}', ""); +Expect(1, 119039, '\P{ _Musical-Symbols}', ""); +Expect(0, 119039, '\P{^ _Musical-Symbols}', ""); +Error('\p{_:=Is-Musical symbols}'); +Error('\P{_:=Is-Musical symbols}'); +Expect(1, 119295, '\p{ismusicalsymbols}', ""); +Expect(0, 119295, '\p{^ismusicalsymbols}', ""); +Expect(0, 119295, '\P{ismusicalsymbols}', ""); +Expect(1, 119295, '\P{^ismusicalsymbols}', ""); +Expect(0, 119039, '\p{ismusicalsymbols}', ""); +Expect(1, 119039, '\p{^ismusicalsymbols}', ""); +Expect(1, 119039, '\P{ismusicalsymbols}', ""); +Expect(0, 119039, '\P{^ismusicalsymbols}', ""); +Expect(1, 119295, '\p{--Is_Musical SYMBOLS}', ""); +Expect(0, 119295, '\p{^--Is_Musical SYMBOLS}', ""); +Expect(0, 119295, '\P{--Is_Musical SYMBOLS}', ""); +Expect(1, 119295, '\P{^--Is_Musical SYMBOLS}', ""); +Expect(0, 119039, '\p{--Is_Musical SYMBOLS}', ""); +Expect(1, 119039, '\p{^--Is_Musical SYMBOLS}', ""); +Expect(1, 119039, '\P{--Is_Musical SYMBOLS}', ""); +Expect(0, 119039, '\P{^--Is_Musical SYMBOLS}', ""); +Error('\p{inMusical-Symbols/a/}'); +Error('\P{inMusical-Symbols/a/}'); +Expect(1, 119295, '\p{inmusicalsymbols}', ""); +Expect(0, 119295, '\p{^inmusicalsymbols}', ""); +Expect(0, 119295, '\P{inmusicalsymbols}', ""); +Expect(1, 119295, '\P{^inmusicalsymbols}', ""); +Expect(0, 119039, '\p{inmusicalsymbols}', ""); +Expect(1, 119039, '\p{^inmusicalsymbols}', ""); +Expect(1, 119039, '\P{inmusicalsymbols}', ""); +Expect(0, 119039, '\P{^inmusicalsymbols}', ""); +Expect(1, 119295, '\p{ in-Musical Symbols}', ""); +Expect(0, 119295, '\p{^ in-Musical Symbols}', ""); +Expect(0, 119295, '\P{ in-Musical Symbols}', ""); +Expect(1, 119295, '\P{^ in-Musical Symbols}', ""); +Expect(0, 119039, '\p{ in-Musical Symbols}', ""); +Expect(1, 119039, '\p{^ in-Musical Symbols}', ""); +Expect(1, 119039, '\P{ in-Musical Symbols}', ""); +Expect(0, 119039, '\P{^ in-Musical Symbols}', ""); +Error('\p{:=__tags}'); +Error('\P{:=__tags}'); +Expect(1, 917631, '\p{tags}', ""); +Expect(0, 917631, '\p{^tags}', ""); +Expect(0, 917631, '\P{tags}', ""); +Expect(1, 917631, '\P{^tags}', ""); +Expect(0, 7, '\p{tags}', ""); +Expect(1, 7, '\p{^tags}', ""); +Expect(1, 7, '\P{tags}', ""); +Expect(0, 7, '\P{^tags}', ""); +Expect(1, 917631, '\p{_ TAGS}', ""); +Expect(0, 917631, '\p{^_ TAGS}', ""); +Expect(0, 917631, '\P{_ TAGS}', ""); +Expect(1, 917631, '\P{^_ TAGS}', ""); +Expect(0, 7, '\p{_ TAGS}', ""); +Expect(1, 7, '\p{^_ TAGS}', ""); +Expect(1, 7, '\P{_ TAGS}', ""); +Expect(0, 7, '\P{^_ TAGS}', ""); +Error('\p{__IS TAGS:=}'); +Error('\P{__IS TAGS:=}'); +Expect(1, 917631, '\p{istags}', ""); +Expect(0, 917631, '\p{^istags}', ""); +Expect(0, 917631, '\P{istags}', ""); +Expect(1, 917631, '\P{^istags}', ""); +Expect(0, 7, '\p{istags}', ""); +Expect(1, 7, '\p{^istags}', ""); +Expect(1, 7, '\P{istags}', ""); +Expect(0, 7, '\P{^istags}', ""); +Expect(1, 917631, '\p{ IStags}', ""); +Expect(0, 917631, '\p{^ IStags}', ""); +Expect(0, 917631, '\P{ IStags}', ""); +Expect(1, 917631, '\P{^ IStags}', ""); +Expect(0, 7, '\p{ IStags}', ""); +Expect(1, 7, '\p{^ IStags}', ""); +Expect(1, 7, '\P{ IStags}', ""); +Expect(0, 7, '\P{^ IStags}', ""); +Error('\p{/a/-In_TAGS}'); +Error('\P{/a/-In_TAGS}'); +Expect(1, 917631, '\p{intags}', ""); +Expect(0, 917631, '\p{^intags}', ""); +Expect(0, 917631, '\P{intags}', ""); +Expect(1, 917631, '\P{^intags}', ""); +Expect(0, 7, '\p{intags}', ""); +Expect(1, 7, '\p{^intags}', ""); +Expect(1, 7, '\P{intags}', ""); +Expect(0, 7, '\P{^intags}', ""); +Expect(1, 917631, '\p{In Tags}', ""); +Expect(0, 917631, '\p{^In Tags}', ""); +Expect(0, 917631, '\P{In Tags}', ""); +Expect(1, 917631, '\P{^In Tags}', ""); +Expect(0, 7, '\p{In Tags}', ""); +Expect(1, 7, '\p{^In Tags}', ""); +Expect(1, 7, '\P{In Tags}', ""); +Expect(0, 7, '\P{^In Tags}', ""); +Error('\p{ /a/separator}'); +Error('\P{ /a/separator}'); +Expect(1, 32, '\p{separator}', ""); +Expect(0, 32, '\p{^separator}', ""); +Expect(0, 32, '\P{separator}', ""); +Expect(1, 32, '\P{^separator}', ""); +Expect(0, 7, '\p{separator}', ""); +Expect(1, 7, '\p{^separator}', ""); +Expect(1, 7, '\P{separator}', ""); +Expect(0, 7, '\P{^separator}', ""); +Expect(1, 32, '\p{ Separator}', ""); +Expect(0, 32, '\p{^ Separator}', ""); +Expect(0, 32, '\P{ Separator}', ""); +Expect(1, 32, '\P{^ Separator}', ""); +Expect(0, 7, '\p{ Separator}', ""); +Expect(1, 7, '\p{^ Separator}', ""); +Expect(1, 7, '\P{ Separator}', ""); +Expect(0, 7, '\P{^ Separator}', ""); +Error('\p{-/a/Is SEPARATOR}'); +Error('\P{-/a/Is SEPARATOR}'); +Expect(1, 32, '\p{isseparator}', ""); +Expect(0, 32, '\p{^isseparator}', ""); +Expect(0, 32, '\P{isseparator}', ""); +Expect(1, 32, '\P{^isseparator}', ""); +Expect(0, 7, '\p{isseparator}', ""); +Expect(1, 7, '\p{^isseparator}', ""); +Expect(1, 7, '\P{isseparator}', ""); +Expect(0, 7, '\P{^isseparator}', ""); +Expect(1, 32, '\p{__is Separator}', ""); +Expect(0, 32, '\p{^__is Separator}', ""); +Expect(0, 32, '\P{__is Separator}', ""); +Expect(1, 32, '\P{^__is Separator}', ""); +Expect(0, 7, '\p{__is Separator}', ""); +Expect(1, 7, '\p{^__is Separator}', ""); +Expect(1, 7, '\P{__is Separator}', ""); +Expect(0, 7, '\P{^__is Separator}', ""); +Error('\p{:=--z}'); +Error('\P{:=--z}'); +Expect(1, 32, '\p{z}', ""); +Expect(0, 32, '\p{^z}', ""); +Expect(0, 32, '\P{z}', ""); +Expect(1, 32, '\P{^z}', ""); +Expect(0, 7, '\p{z}', ""); +Expect(1, 7, '\p{^z}', ""); +Expect(1, 7, '\P{z}', ""); +Expect(0, 7, '\P{^z}', ""); +Expect(1, 32, '\p{ Z}', ""); +Expect(0, 32, '\p{^ Z}', ""); +Expect(0, 32, '\P{ Z}', ""); +Expect(1, 32, '\P{^ Z}', ""); +Expect(0, 7, '\p{ Z}', ""); +Expect(1, 7, '\p{^ Z}', ""); +Expect(1, 7, '\P{ Z}', ""); +Expect(0, 7, '\P{^ Z}', ""); +Error('\p{_IsZ:=}'); +Error('\P{_IsZ:=}'); +Expect(1, 32, '\p{isz}', ""); +Expect(0, 32, '\p{^isz}', ""); +Expect(0, 32, '\P{isz}', ""); +Expect(1, 32, '\P{^isz}', ""); +Expect(0, 7, '\p{isz}', ""); +Expect(1, 7, '\p{^isz}', ""); +Expect(1, 7, '\P{isz}', ""); +Expect(0, 7, '\P{^isz}', ""); +Expect(1, 32, '\p{ _Is Z}', ""); +Expect(0, 32, '\p{^ _Is Z}', ""); +Expect(0, 32, '\P{ _Is Z}', ""); +Expect(1, 32, '\P{^ _Is Z}', ""); +Expect(0, 7, '\p{ _Is Z}', ""); +Expect(1, 7, '\p{^ _Is Z}', ""); +Expect(1, 7, '\P{ _Is Z}', ""); +Expect(0, 7, '\P{^ _Is Z}', ""); +Error('\p{ -ancient GREEK:=Musical Notation}'); +Error('\P{ -ancient GREEK:=Musical Notation}'); +Expect(1, 119375, '\p{ancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\p{^ancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\P{ancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\P{^ancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\p{ancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\p{^ancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\P{ancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\P{^ancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\p{_Ancient-GREEK Musical-Notation}', ""); +Expect(0, 119375, '\p{^_Ancient-GREEK Musical-Notation}', ""); +Expect(0, 119375, '\P{_Ancient-GREEK Musical-Notation}', ""); +Expect(1, 119375, '\P{^_Ancient-GREEK Musical-Notation}', ""); +Expect(0, 119295, '\p{_Ancient-GREEK Musical-Notation}', ""); +Expect(1, 119295, '\p{^_Ancient-GREEK Musical-Notation}', ""); +Expect(1, 119295, '\P{_Ancient-GREEK Musical-Notation}', ""); +Expect(0, 119295, '\P{^_Ancient-GREEK Musical-Notation}', ""); +Error('\p{_:=Is_ANCIENT_Greek Musical-notation}'); +Error('\P{_:=Is_ANCIENT_Greek Musical-notation}'); +Expect(1, 119375, '\p{isancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\p{^isancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\P{isancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\P{^isancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\p{isancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\p{^isancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\P{isancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\P{^isancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\p{-IsANCIENTGreek_musical NOTATION}', ""); +Expect(0, 119375, '\p{^-IsANCIENTGreek_musical NOTATION}', ""); +Expect(0, 119375, '\P{-IsANCIENTGreek_musical NOTATION}', ""); +Expect(1, 119375, '\P{^-IsANCIENTGreek_musical NOTATION}', ""); +Expect(0, 119295, '\p{-IsANCIENTGreek_musical NOTATION}', ""); +Expect(1, 119295, '\p{^-IsANCIENTGreek_musical NOTATION}', ""); +Expect(1, 119295, '\P{-IsANCIENTGreek_musical NOTATION}', ""); +Expect(0, 119295, '\P{^-IsANCIENTGreek_musical NOTATION}', ""); +Error('\p{_-In Ancient Greek:=musical Notation}'); +Error('\P{_-In Ancient Greek:=musical Notation}'); +Expect(1, 119375, '\p{inancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\p{^inancientgreekmusicalnotation}', ""); +Expect(0, 119375, '\P{inancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\P{^inancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\p{inancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\p{^inancientgreekmusicalnotation}', ""); +Expect(1, 119295, '\P{inancientgreekmusicalnotation}', ""); +Expect(0, 119295, '\P{^inancientgreekmusicalnotation}', ""); +Expect(1, 119375, '\p{- In_ancient Greek-Musical_notation}', ""); +Expect(0, 119375, '\p{^- In_ancient Greek-Musical_notation}', ""); +Expect(0, 119375, '\P{- In_ancient Greek-Musical_notation}', ""); +Expect(1, 119375, '\P{^- In_ancient Greek-Musical_notation}', ""); +Expect(0, 119295, '\p{- In_ancient Greek-Musical_notation}', ""); +Expect(1, 119295, '\p{^- In_ancient Greek-Musical_notation}', ""); +Expect(1, 119295, '\P{- In_ancient Greek-Musical_notation}', ""); +Expect(0, 119295, '\P{^- In_ancient Greek-Musical_notation}', ""); +Error('\p{ PosixBlank:=}'); +Error('\P{ PosixBlank:=}'); +Expect(1, 9, '\p{posixblank}', ""); +Expect(0, 9, '\p{^posixblank}', ""); +Expect(0, 9, '\P{posixblank}', ""); +Expect(1, 9, '\P{^posixblank}', ""); +Expect(0, 8, '\p{posixblank}', ""); +Expect(1, 8, '\p{^posixblank}', ""); +Expect(1, 8, '\P{posixblank}', ""); +Expect(0, 8, '\P{^posixblank}', ""); +Expect(1, 9, '\p{ posixblank}', ""); +Expect(0, 9, '\p{^ posixblank}', ""); +Expect(0, 9, '\P{ posixblank}', ""); +Expect(1, 9, '\P{^ posixblank}', ""); +Expect(0, 8, '\p{ posixblank}', ""); +Expect(1, 8, '\p{^ posixblank}', ""); +Expect(1, 8, '\P{ posixblank}', ""); +Expect(0, 8, '\P{^ posixblank}', ""); +Error('\p{/a/ -ISPosixBlank}'); +Error('\P{/a/ -ISPosixBlank}'); +Expect(1, 9, '\p{isposixblank}', ""); +Expect(0, 9, '\p{^isposixblank}', ""); +Expect(0, 9, '\P{isposixblank}', ""); +Expect(1, 9, '\P{^isposixblank}', ""); +Expect(0, 8, '\p{isposixblank}', ""); +Expect(1, 8, '\p{^isposixblank}', ""); +Expect(1, 8, '\P{isposixblank}', ""); +Expect(0, 8, '\P{^isposixblank}', ""); +Expect(1, 9, '\p{ _is_POSIXBLANK}', ""); +Expect(0, 9, '\p{^ _is_POSIXBLANK}', ""); +Expect(0, 9, '\P{ _is_POSIXBLANK}', ""); +Expect(1, 9, '\P{^ _is_POSIXBLANK}', ""); +Expect(0, 8, '\p{ _is_POSIXBLANK}', ""); +Expect(1, 8, '\p{^ _is_POSIXBLANK}', ""); +Expect(1, 8, '\P{ _is_POSIXBLANK}', ""); +Expect(0, 8, '\P{^ _is_POSIXBLANK}', ""); +Error('\p{ in_Sinhala:=}'); +Error('\P{ in_Sinhala:=}'); +Expect(1, 3583, '\p{insinhala}', ""); +Expect(0, 3583, '\p{^insinhala}', ""); +Expect(0, 3583, '\P{insinhala}', ""); +Expect(1, 3583, '\P{^insinhala}', ""); +Expect(0, 3455, '\p{insinhala}', ""); +Expect(1, 3455, '\p{^insinhala}', ""); +Expect(1, 3455, '\P{insinhala}', ""); +Expect(0, 3455, '\P{^insinhala}', ""); +Expect(1, 3583, '\p{-In Sinhala}', ""); +Expect(0, 3583, '\p{^-In Sinhala}', ""); +Expect(0, 3583, '\P{-In Sinhala}', ""); +Expect(1, 3583, '\P{^-In Sinhala}', ""); +Expect(0, 3455, '\p{-In Sinhala}', ""); +Expect(1, 3455, '\p{^-In Sinhala}', ""); +Expect(1, 3455, '\P{-In Sinhala}', ""); +Expect(0, 3455, '\P{^-In Sinhala}', ""); +Error('\p{ /a/Mongolian}'); +Error('\P{ /a/Mongolian}'); +Expect(1, 6145, '\p{mongolian}', ""); +Expect(0, 6145, '\p{^mongolian}', ""); +Expect(0, 6145, '\P{mongolian}', ""); +Expect(1, 6145, '\P{^mongolian}', ""); +Expect(0, 6143, '\p{mongolian}', ""); +Expect(1, 6143, '\p{^mongolian}', ""); +Expect(1, 6143, '\P{mongolian}', ""); +Expect(0, 6143, '\P{^mongolian}', ""); +Expect(1, 6145, '\p{_ Mongolian}', ""); +Expect(0, 6145, '\p{^_ Mongolian}', ""); +Expect(0, 6145, '\P{_ Mongolian}', ""); +Expect(1, 6145, '\P{^_ Mongolian}', ""); +Expect(0, 6143, '\p{_ Mongolian}', ""); +Expect(1, 6143, '\p{^_ Mongolian}', ""); +Expect(1, 6143, '\P{_ Mongolian}', ""); +Expect(0, 6143, '\P{^_ Mongolian}', ""); +Error('\p{/a/ is MONGOLIAN}'); +Error('\P{/a/ is MONGOLIAN}'); +Expect(1, 6145, '\p{ismongolian}', ""); +Expect(0, 6145, '\p{^ismongolian}', ""); +Expect(0, 6145, '\P{ismongolian}', ""); +Expect(1, 6145, '\P{^ismongolian}', ""); +Expect(0, 6143, '\p{ismongolian}', ""); +Expect(1, 6143, '\p{^ismongolian}', ""); +Expect(1, 6143, '\P{ismongolian}', ""); +Expect(0, 6143, '\P{^ismongolian}', ""); +Expect(1, 6145, '\p{__isMONGOLIAN}', ""); +Expect(0, 6145, '\p{^__isMONGOLIAN}', ""); +Expect(0, 6145, '\P{__isMONGOLIAN}', ""); +Expect(1, 6145, '\P{^__isMONGOLIAN}', ""); +Expect(0, 6143, '\p{__isMONGOLIAN}', ""); +Expect(1, 6143, '\p{^__isMONGOLIAN}', ""); +Expect(1, 6143, '\P{__isMONGOLIAN}', ""); +Expect(0, 6143, '\P{^__isMONGOLIAN}', ""); +Error('\p{ :=Mong}'); +Error('\P{ :=Mong}'); +Expect(1, 6145, '\p{mong}', ""); +Expect(0, 6145, '\p{^mong}', ""); +Expect(0, 6145, '\P{mong}', ""); +Expect(1, 6145, '\P{^mong}', ""); +Expect(0, 6143, '\p{mong}', ""); +Expect(1, 6143, '\p{^mong}', ""); +Expect(1, 6143, '\P{mong}', ""); +Expect(0, 6143, '\P{^mong}', ""); +Expect(1, 6145, '\p{_ Mong}', ""); +Expect(0, 6145, '\p{^_ Mong}', ""); +Expect(0, 6145, '\P{_ Mong}', ""); +Expect(1, 6145, '\P{^_ Mong}', ""); +Expect(0, 6143, '\p{_ Mong}', ""); +Expect(1, 6143, '\p{^_ Mong}', ""); +Expect(1, 6143, '\P{_ Mong}', ""); +Expect(0, 6143, '\P{^_ Mong}', ""); +Error('\p{-/a/IS MONG}'); +Error('\P{-/a/IS MONG}'); +Expect(1, 6145, '\p{ismong}', ""); +Expect(0, 6145, '\p{^ismong}', ""); +Expect(0, 6145, '\P{ismong}', ""); +Expect(1, 6145, '\P{^ismong}', ""); +Expect(0, 6143, '\p{ismong}', ""); +Expect(1, 6143, '\p{^ismong}', ""); +Expect(1, 6143, '\P{ismong}', ""); +Expect(0, 6143, '\P{^ismong}', ""); +Expect(1, 6145, '\p{ is_mong}', ""); +Expect(0, 6145, '\p{^ is_mong}', ""); +Expect(0, 6145, '\P{ is_mong}', ""); +Expect(1, 6145, '\P{^ is_mong}', ""); +Expect(0, 6143, '\p{ is_mong}', ""); +Expect(1, 6143, '\p{^ is_mong}', ""); +Expect(1, 6143, '\P{ is_mong}', ""); +Expect(0, 6143, '\P{^ is_mong}', ""); +Error('\p{ CHEROKEE:=}'); +Error('\P{ CHEROKEE:=}'); +Expect(1, 5108, '\p{cherokee}', ""); +Expect(0, 5108, '\p{^cherokee}', ""); +Expect(0, 5108, '\P{cherokee}', ""); +Expect(1, 5108, '\P{^cherokee}', ""); +Expect(0, 5023, '\p{cherokee}', ""); +Expect(1, 5023, '\p{^cherokee}', ""); +Expect(1, 5023, '\P{cherokee}', ""); +Expect(0, 5023, '\P{^cherokee}', ""); +Expect(1, 5108, '\p{ CHEROKEE}', ""); +Expect(0, 5108, '\p{^ CHEROKEE}', ""); +Expect(0, 5108, '\P{ CHEROKEE}', ""); +Expect(1, 5108, '\P{^ CHEROKEE}', ""); +Expect(0, 5023, '\p{ CHEROKEE}', ""); +Expect(1, 5023, '\p{^ CHEROKEE}', ""); +Expect(1, 5023, '\P{ CHEROKEE}', ""); +Expect(0, 5023, '\P{^ CHEROKEE}', ""); +Error('\p{_-Is_Cherokee/a/}'); +Error('\P{_-Is_Cherokee/a/}'); +Expect(1, 5108, '\p{ischerokee}', ""); +Expect(0, 5108, '\p{^ischerokee}', ""); +Expect(0, 5108, '\P{ischerokee}', ""); +Expect(1, 5108, '\P{^ischerokee}', ""); +Expect(0, 5023, '\p{ischerokee}', ""); +Expect(1, 5023, '\p{^ischerokee}', ""); +Expect(1, 5023, '\P{ischerokee}', ""); +Expect(0, 5023, '\P{^ischerokee}', ""); +Expect(1, 5108, '\p{--Is Cherokee}', ""); +Expect(0, 5108, '\p{^--Is Cherokee}', ""); +Expect(0, 5108, '\P{--Is Cherokee}', ""); +Expect(1, 5108, '\P{^--Is Cherokee}', ""); +Expect(0, 5023, '\p{--Is Cherokee}', ""); +Expect(1, 5023, '\p{^--Is Cherokee}', ""); +Expect(1, 5023, '\P{--Is Cherokee}', ""); +Expect(0, 5023, '\P{^--Is Cherokee}', ""); +Error('\p{_:=Cher}'); +Error('\P{_:=Cher}'); +Expect(1, 5108, '\p{cher}', ""); +Expect(0, 5108, '\p{^cher}', ""); +Expect(0, 5108, '\P{cher}', ""); +Expect(1, 5108, '\P{^cher}', ""); +Expect(0, 5023, '\p{cher}', ""); +Expect(1, 5023, '\p{^cher}', ""); +Expect(1, 5023, '\P{cher}', ""); +Expect(0, 5023, '\P{^cher}', ""); +Expect(1, 5108, '\p{ Cher}', ""); +Expect(0, 5108, '\p{^ Cher}', ""); +Expect(0, 5108, '\P{ Cher}', ""); +Expect(1, 5108, '\P{^ Cher}', ""); +Expect(0, 5023, '\p{ Cher}', ""); +Expect(1, 5023, '\p{^ Cher}', ""); +Expect(1, 5023, '\P{ Cher}', ""); +Expect(0, 5023, '\P{^ Cher}', ""); +Error('\p{ Is Cher:=}'); +Error('\P{ Is Cher:=}'); +Expect(1, 5108, '\p{ischer}', ""); +Expect(0, 5108, '\p{^ischer}', ""); +Expect(0, 5108, '\P{ischer}', ""); +Expect(1, 5108, '\P{^ischer}', ""); +Expect(0, 5023, '\p{ischer}', ""); +Expect(1, 5023, '\p{^ischer}', ""); +Expect(1, 5023, '\P{ischer}', ""); +Expect(0, 5023, '\P{^ischer}', ""); +Expect(1, 5108, '\p{_ Is cher}', ""); +Expect(0, 5108, '\p{^_ Is cher}', ""); +Expect(0, 5108, '\P{_ Is cher}', ""); +Expect(1, 5108, '\P{^_ Is cher}', ""); +Expect(0, 5023, '\p{_ Is cher}', ""); +Expect(1, 5023, '\p{^_ Is cher}', ""); +Expect(1, 5023, '\P{_ Is cher}', ""); +Expect(0, 5023, '\P{^_ Is cher}', ""); +Error('\p{_ other/a/PUNCTUATION}'); +Error('\P{_ other/a/PUNCTUATION}'); +Expect(1, 35, '\p{otherpunctuation}', ""); +Expect(0, 35, '\p{^otherpunctuation}', ""); +Expect(0, 35, '\P{otherpunctuation}', ""); +Expect(1, 35, '\P{^otherpunctuation}', ""); +Expect(0, 32, '\p{otherpunctuation}', ""); +Expect(1, 32, '\p{^otherpunctuation}', ""); +Expect(1, 32, '\P{otherpunctuation}', ""); +Expect(0, 32, '\P{^otherpunctuation}', ""); +Expect(1, 35, '\p{ _OTHER Punctuation}', ""); +Expect(0, 35, '\p{^ _OTHER Punctuation}', ""); +Expect(0, 35, '\P{ _OTHER Punctuation}', ""); +Expect(1, 35, '\P{^ _OTHER Punctuation}', ""); +Expect(0, 32, '\p{ _OTHER Punctuation}', ""); +Expect(1, 32, '\p{^ _OTHER Punctuation}', ""); +Expect(1, 32, '\P{ _OTHER Punctuation}', ""); +Expect(0, 32, '\P{^ _OTHER Punctuation}', ""); +Error('\p{IS Other_Punctuation/a/}'); +Error('\P{IS Other_Punctuation/a/}'); +Expect(1, 35, '\p{isotherpunctuation}', ""); +Expect(0, 35, '\p{^isotherpunctuation}', ""); +Expect(0, 35, '\P{isotherpunctuation}', ""); +Expect(1, 35, '\P{^isotherpunctuation}', ""); +Expect(0, 32, '\p{isotherpunctuation}', ""); +Expect(1, 32, '\p{^isotherpunctuation}', ""); +Expect(1, 32, '\P{isotherpunctuation}', ""); +Expect(0, 32, '\P{^isotherpunctuation}', ""); +Expect(1, 35, '\p{-_Is OTHER Punctuation}', ""); +Expect(0, 35, '\p{^-_Is OTHER Punctuation}', ""); +Expect(0, 35, '\P{-_Is OTHER Punctuation}', ""); +Expect(1, 35, '\P{^-_Is OTHER Punctuation}', ""); +Expect(0, 32, '\p{-_Is OTHER Punctuation}', ""); +Expect(1, 32, '\p{^-_Is OTHER Punctuation}', ""); +Expect(1, 32, '\P{-_Is OTHER Punctuation}', ""); +Expect(0, 32, '\P{^-_Is OTHER Punctuation}', ""); +Error('\p{_:=Po}'); +Error('\P{_:=Po}'); +Expect(1, 35, '\p{po}', ""); +Expect(0, 35, '\p{^po}', ""); +Expect(0, 35, '\P{po}', ""); +Expect(1, 35, '\P{^po}', ""); +Expect(0, 32, '\p{po}', ""); +Expect(1, 32, '\p{^po}', ""); +Expect(1, 32, '\P{po}', ""); +Expect(0, 32, '\P{^po}', ""); +Expect(1, 35, '\p{ po}', ""); +Expect(0, 35, '\p{^ po}', ""); +Expect(0, 35, '\P{ po}', ""); +Expect(1, 35, '\P{^ po}', ""); +Expect(0, 32, '\p{ po}', ""); +Expect(1, 32, '\p{^ po}', ""); +Expect(1, 32, '\P{ po}', ""); +Expect(0, 32, '\P{^ po}', ""); +Error('\p{ :=Is_po}'); +Error('\P{ :=Is_po}'); +Expect(1, 35, '\p{ispo}', ""); +Expect(0, 35, '\p{^ispo}', ""); +Expect(0, 35, '\P{ispo}', ""); +Expect(1, 35, '\P{^ispo}', ""); +Expect(0, 32, '\p{ispo}', ""); +Expect(1, 32, '\p{^ispo}', ""); +Expect(1, 32, '\P{ispo}', ""); +Expect(0, 32, '\P{^ispo}', ""); +Expect(1, 35, '\p{__is_po}', ""); +Expect(0, 35, '\p{^__is_po}', ""); +Expect(0, 35, '\P{__is_po}', ""); +Expect(1, 35, '\P{^__is_po}', ""); +Expect(0, 32, '\p{__is_po}', ""); +Expect(1, 32, '\p{^__is_po}', ""); +Expect(1, 32, '\P{__is_po}', ""); +Expect(0, 32, '\P{^__is_po}', ""); +Error('\p{:=- IN-CHEROKEE}'); +Error('\P{:=- IN-CHEROKEE}'); +Expect(1, 5119, '\p{incherokee}', ""); +Expect(0, 5119, '\p{^incherokee}', ""); +Expect(0, 5119, '\P{incherokee}', ""); +Expect(1, 5119, '\P{^incherokee}', ""); +Expect(0, 5023, '\p{incherokee}', ""); +Expect(1, 5023, '\p{^incherokee}', ""); +Expect(1, 5023, '\P{incherokee}', ""); +Expect(0, 5023, '\P{^incherokee}', ""); +Expect(1, 5119, '\p{ _in cherokee}', ""); +Expect(0, 5119, '\p{^ _in cherokee}', ""); +Expect(0, 5119, '\P{ _in cherokee}', ""); +Expect(1, 5119, '\P{^ _in cherokee}', ""); +Expect(0, 5023, '\p{ _in cherokee}', ""); +Expect(1, 5023, '\p{^ _in cherokee}', ""); +Expect(1, 5023, '\P{ _in cherokee}', ""); +Expect(0, 5023, '\P{^ _in cherokee}', ""); +Error('\p{_:=ethiopic}'); +Error('\P{_:=ethiopic}'); +Expect(1, 4680, '\p{ethiopic}', ""); +Expect(0, 4680, '\p{^ethiopic}', ""); +Expect(0, 4680, '\P{ethiopic}', ""); +Expect(1, 4680, '\P{^ethiopic}', ""); +Expect(0, 4607, '\p{ethiopic}', ""); +Expect(1, 4607, '\p{^ethiopic}', ""); +Expect(1, 4607, '\P{ethiopic}', ""); +Expect(0, 4607, '\P{^ethiopic}', ""); +Expect(1, 4680, '\p{_ ethiopic}', ""); +Expect(0, 4680, '\p{^_ ethiopic}', ""); +Expect(0, 4680, '\P{_ ethiopic}', ""); +Expect(1, 4680, '\P{^_ ethiopic}', ""); +Expect(0, 4607, '\p{_ ethiopic}', ""); +Expect(1, 4607, '\p{^_ ethiopic}', ""); +Expect(1, 4607, '\P{_ ethiopic}', ""); +Expect(0, 4607, '\P{^_ ethiopic}', ""); +Error('\p{_-Is:=Ethiopic}'); +Error('\P{_-Is:=Ethiopic}'); +Expect(1, 4680, '\p{isethiopic}', ""); +Expect(0, 4680, '\p{^isethiopic}', ""); +Expect(0, 4680, '\P{isethiopic}', ""); +Expect(1, 4680, '\P{^isethiopic}', ""); +Expect(0, 4607, '\p{isethiopic}', ""); +Expect(1, 4607, '\p{^isethiopic}', ""); +Expect(1, 4607, '\P{isethiopic}', ""); +Expect(0, 4607, '\P{^isethiopic}', ""); +Expect(1, 4680, '\p{IS ETHIOPIC}', ""); +Expect(0, 4680, '\p{^IS ETHIOPIC}', ""); +Expect(0, 4680, '\P{IS ETHIOPIC}', ""); +Expect(1, 4680, '\P{^IS ETHIOPIC}', ""); +Expect(0, 4607, '\p{IS ETHIOPIC}', ""); +Expect(1, 4607, '\p{^IS ETHIOPIC}', ""); +Expect(1, 4607, '\P{IS ETHIOPIC}', ""); +Expect(0, 4607, '\P{^IS ETHIOPIC}', ""); +Error('\p{/a/__ETHI}'); +Error('\P{/a/__ETHI}'); +Expect(1, 4680, '\p{ethi}', ""); +Expect(0, 4680, '\p{^ethi}', ""); +Expect(0, 4680, '\P{ethi}', ""); +Expect(1, 4680, '\P{^ethi}', ""); +Expect(0, 4607, '\p{ethi}', ""); +Expect(1, 4607, '\p{^ethi}', ""); +Expect(1, 4607, '\P{ethi}', ""); +Expect(0, 4607, '\P{^ethi}', ""); +Expect(1, 4680, '\p{ Ethi}', ""); +Expect(0, 4680, '\p{^ Ethi}', ""); +Expect(0, 4680, '\P{ Ethi}', ""); +Expect(1, 4680, '\P{^ Ethi}', ""); +Expect(0, 4607, '\p{ Ethi}', ""); +Expect(1, 4607, '\p{^ Ethi}', ""); +Expect(1, 4607, '\P{ Ethi}', ""); +Expect(0, 4607, '\P{^ Ethi}', ""); +Error('\p{:=IS_ethi}'); +Error('\P{:=IS_ethi}'); +Expect(1, 4680, '\p{isethi}', ""); +Expect(0, 4680, '\p{^isethi}', ""); +Expect(0, 4680, '\P{isethi}', ""); +Expect(1, 4680, '\P{^isethi}', ""); +Expect(0, 4607, '\p{isethi}', ""); +Expect(1, 4607, '\p{^isethi}', ""); +Expect(1, 4607, '\P{isethi}', ""); +Expect(0, 4607, '\P{^isethi}', ""); +Expect(1, 4680, '\p{_ ISEthi}', ""); +Expect(0, 4680, '\p{^_ ISEthi}', ""); +Expect(0, 4680, '\P{_ ISEthi}', ""); +Expect(1, 4680, '\P{^_ ISEthi}', ""); +Expect(0, 4607, '\p{_ ISEthi}', ""); +Expect(1, 4607, '\p{^_ ISEthi}', ""); +Expect(1, 4607, '\P{_ ISEthi}', ""); +Expect(0, 4607, '\P{^_ ISEthi}', ""); +Error('\p{ -Yi:=}'); +Error('\P{ -Yi:=}'); +Expect(1, 42124, '\p{yi}', ""); +Expect(0, 42124, '\p{^yi}', ""); +Expect(0, 42124, '\P{yi}', ""); +Expect(1, 42124, '\P{^yi}', ""); +Expect(0, 40959, '\p{yi}', ""); +Expect(1, 40959, '\p{^yi}', ""); +Expect(1, 40959, '\P{yi}', ""); +Expect(0, 40959, '\P{^yi}', ""); +Expect(1, 42124, '\p{ _Yi}', ""); +Expect(0, 42124, '\p{^ _Yi}', ""); +Expect(0, 42124, '\P{ _Yi}', ""); +Expect(1, 42124, '\P{^ _Yi}', ""); +Expect(0, 40959, '\p{ _Yi}', ""); +Expect(1, 40959, '\p{^ _Yi}', ""); +Expect(1, 40959, '\P{ _Yi}', ""); +Expect(0, 40959, '\P{^ _Yi}', ""); +Error('\p{:=_ IS YI}'); +Error('\P{:=_ IS YI}'); +Expect(1, 42124, '\p{isyi}', ""); +Expect(0, 42124, '\p{^isyi}', ""); +Expect(0, 42124, '\P{isyi}', ""); +Expect(1, 42124, '\P{^isyi}', ""); +Expect(0, 40959, '\p{isyi}', ""); +Expect(1, 40959, '\p{^isyi}', ""); +Expect(1, 40959, '\P{isyi}', ""); +Expect(0, 40959, '\P{^isyi}', ""); +Expect(1, 42124, '\p{ IS-YI}', ""); +Expect(0, 42124, '\p{^ IS-YI}', ""); +Expect(0, 42124, '\P{ IS-YI}', ""); +Expect(1, 42124, '\P{^ IS-YI}', ""); +Expect(0, 40959, '\p{ IS-YI}', ""); +Expect(1, 40959, '\p{^ IS-YI}', ""); +Expect(1, 40959, '\P{ IS-YI}', ""); +Expect(0, 40959, '\P{^ IS-YI}', ""); +Error('\p{YIII:=}'); +Error('\P{YIII:=}'); +Expect(1, 42124, '\p{yiii}', ""); +Expect(0, 42124, '\p{^yiii}', ""); +Expect(0, 42124, '\P{yiii}', ""); +Expect(1, 42124, '\P{^yiii}', ""); +Expect(0, 40959, '\p{yiii}', ""); +Expect(1, 40959, '\p{^yiii}', ""); +Expect(1, 40959, '\P{yiii}', ""); +Expect(0, 40959, '\P{^yiii}', ""); +Expect(1, 42124, '\p{-YIII}', ""); +Expect(0, 42124, '\p{^-YIII}', ""); +Expect(0, 42124, '\P{-YIII}', ""); +Expect(1, 42124, '\P{^-YIII}', ""); +Expect(0, 40959, '\p{-YIII}', ""); +Expect(1, 40959, '\p{^-YIII}', ""); +Expect(1, 40959, '\P{-YIII}', ""); +Expect(0, 40959, '\P{^-YIII}', ""); +Error('\p{:=Is Yiii}'); +Error('\P{:=Is Yiii}'); +Expect(1, 42124, '\p{isyiii}', ""); +Expect(0, 42124, '\p{^isyiii}', ""); +Expect(0, 42124, '\P{isyiii}', ""); +Expect(1, 42124, '\P{^isyiii}', ""); +Expect(0, 40959, '\p{isyiii}', ""); +Expect(1, 40959, '\p{^isyiii}', ""); +Expect(1, 40959, '\P{isyiii}', ""); +Expect(0, 40959, '\P{^isyiii}', ""); +Expect(1, 42124, '\p{ _Isyiii}', ""); +Expect(0, 42124, '\p{^ _Isyiii}', ""); +Expect(0, 42124, '\P{ _Isyiii}', ""); +Expect(1, 42124, '\P{^ _Isyiii}', ""); +Expect(0, 40959, '\p{ _Isyiii}', ""); +Expect(1, 40959, '\p{^ _Isyiii}', ""); +Expect(1, 40959, '\P{ _Isyiii}', ""); +Expect(0, 40959, '\P{^ _Isyiii}', ""); +Error('\p{-GURMUKHI/a/}'); +Error('\P{-GURMUKHI/a/}'); +Expect(1, 2563, '\p{gurmukhi}', ""); +Expect(0, 2563, '\p{^gurmukhi}', ""); +Expect(0, 2563, '\P{gurmukhi}', ""); +Expect(1, 2563, '\P{^gurmukhi}', ""); +Expect(0, 2560, '\p{gurmukhi}', ""); +Expect(1, 2560, '\p{^gurmukhi}', ""); +Expect(1, 2560, '\P{gurmukhi}', ""); +Expect(0, 2560, '\P{^gurmukhi}', ""); +Expect(1, 2563, '\p{ gurmukhi}', ""); +Expect(0, 2563, '\p{^ gurmukhi}', ""); +Expect(0, 2563, '\P{ gurmukhi}', ""); +Expect(1, 2563, '\P{^ gurmukhi}', ""); +Expect(0, 2560, '\p{ gurmukhi}', ""); +Expect(1, 2560, '\p{^ gurmukhi}', ""); +Expect(1, 2560, '\P{ gurmukhi}', ""); +Expect(0, 2560, '\P{^ gurmukhi}', ""); +Error('\p{/a/ _IS Gurmukhi}'); +Error('\P{/a/ _IS Gurmukhi}'); +Expect(1, 2563, '\p{isgurmukhi}', ""); +Expect(0, 2563, '\p{^isgurmukhi}', ""); +Expect(0, 2563, '\P{isgurmukhi}', ""); +Expect(1, 2563, '\P{^isgurmukhi}', ""); +Expect(0, 2560, '\p{isgurmukhi}', ""); +Expect(1, 2560, '\p{^isgurmukhi}', ""); +Expect(1, 2560, '\P{isgurmukhi}', ""); +Expect(0, 2560, '\P{^isgurmukhi}', ""); +Expect(1, 2563, '\p{ IsGurmukhi}', ""); +Expect(0, 2563, '\p{^ IsGurmukhi}', ""); +Expect(0, 2563, '\P{ IsGurmukhi}', ""); +Expect(1, 2563, '\P{^ IsGurmukhi}', ""); +Expect(0, 2560, '\p{ IsGurmukhi}', ""); +Expect(1, 2560, '\p{^ IsGurmukhi}', ""); +Expect(1, 2560, '\P{ IsGurmukhi}', ""); +Expect(0, 2560, '\P{^ IsGurmukhi}', ""); +Error('\p{:= guru}'); +Error('\P{:= guru}'); +Expect(1, 2563, '\p{guru}', ""); +Expect(0, 2563, '\p{^guru}', ""); +Expect(0, 2563, '\P{guru}', ""); +Expect(1, 2563, '\P{^guru}', ""); +Expect(0, 2560, '\p{guru}', ""); +Expect(1, 2560, '\p{^guru}', ""); +Expect(1, 2560, '\P{guru}', ""); +Expect(0, 2560, '\P{^guru}', ""); +Expect(1, 2563, '\p{ Guru}', ""); +Expect(0, 2563, '\p{^ Guru}', ""); +Expect(0, 2563, '\P{ Guru}', ""); +Expect(1, 2563, '\P{^ Guru}', ""); +Expect(0, 2560, '\p{ Guru}', ""); +Expect(1, 2560, '\p{^ Guru}', ""); +Expect(1, 2560, '\P{ Guru}', ""); +Expect(0, 2560, '\P{^ Guru}', ""); +Error('\p{:=IS GURU}'); +Error('\P{:=IS GURU}'); +Expect(1, 2563, '\p{isguru}', ""); +Expect(0, 2563, '\p{^isguru}', ""); +Expect(0, 2563, '\P{isguru}', ""); +Expect(1, 2563, '\P{^isguru}', ""); +Expect(0, 2560, '\p{isguru}', ""); +Expect(1, 2560, '\p{^isguru}', ""); +Expect(1, 2560, '\P{isguru}', ""); +Expect(0, 2560, '\P{^isguru}', ""); +Expect(1, 2563, '\p{ is_Guru}', ""); +Expect(0, 2563, '\p{^ is_Guru}', ""); +Expect(0, 2563, '\P{ is_Guru}', ""); +Expect(1, 2563, '\P{^ is_Guru}', ""); +Expect(0, 2560, '\p{ is_Guru}', ""); +Expect(1, 2560, '\p{^ is_Guru}', ""); +Expect(1, 2560, '\P{ is_Guru}', ""); +Expect(0, 2560, '\P{^ is_Guru}', ""); +Error('\p{ _LATIN/a/ExtendedB}'); +Error('\P{ _LATIN/a/ExtendedB}'); +Expect(1, 591, '\p{latinextendedb}', ""); +Expect(0, 591, '\p{^latinextendedb}', ""); +Expect(0, 591, '\P{latinextendedb}', ""); +Expect(1, 591, '\P{^latinextendedb}', ""); +Expect(0, 383, '\p{latinextendedb}', ""); +Expect(1, 383, '\p{^latinextendedb}', ""); +Expect(1, 383, '\P{latinextendedb}', ""); +Expect(0, 383, '\P{^latinextendedb}', ""); +Expect(1, 591, '\p{-_latin ExtendedB}', ""); +Expect(0, 591, '\p{^-_latin ExtendedB}', ""); +Expect(0, 591, '\P{-_latin ExtendedB}', ""); +Expect(1, 591, '\P{^-_latin ExtendedB}', ""); +Expect(0, 383, '\p{-_latin ExtendedB}', ""); +Expect(1, 383, '\p{^-_latin ExtendedB}', ""); +Expect(1, 383, '\P{-_latin ExtendedB}', ""); +Expect(0, 383, '\P{^-_latin ExtendedB}', ""); +Error('\p{__IS/a/latin_EXTENDED B}'); +Error('\P{__IS/a/latin_EXTENDED B}'); +Expect(1, 591, '\p{islatinextendedb}', ""); +Expect(0, 591, '\p{^islatinextendedb}', ""); +Expect(0, 591, '\P{islatinextendedb}', ""); +Expect(1, 591, '\P{^islatinextendedb}', ""); +Expect(0, 383, '\p{islatinextendedb}', ""); +Expect(1, 383, '\p{^islatinextendedb}', ""); +Expect(1, 383, '\P{islatinextendedb}', ""); +Expect(0, 383, '\P{^islatinextendedb}', ""); +Expect(1, 591, '\p{ Is_latinextended_b}', ""); +Expect(0, 591, '\p{^ Is_latinextended_b}', ""); +Expect(0, 591, '\P{ Is_latinextended_b}', ""); +Expect(1, 591, '\P{^ Is_latinextended_b}', ""); +Expect(0, 383, '\p{ Is_latinextended_b}', ""); +Expect(1, 383, '\p{^ Is_latinextended_b}', ""); +Expect(1, 383, '\P{ Is_latinextended_b}', ""); +Expect(0, 383, '\P{^ Is_latinextended_b}', ""); +Error('\p{-_in Latin Extended:=B}'); +Error('\P{-_in Latin Extended:=B}'); +Expect(1, 591, '\p{inlatinextendedb}', ""); +Expect(0, 591, '\p{^inlatinextendedb}', ""); +Expect(0, 591, '\P{inlatinextendedb}', ""); +Expect(1, 591, '\P{^inlatinextendedb}', ""); +Expect(0, 383, '\p{inlatinextendedb}', ""); +Expect(1, 383, '\p{^inlatinextendedb}', ""); +Expect(1, 383, '\P{inlatinextendedb}', ""); +Expect(0, 383, '\P{^inlatinextendedb}', ""); +Expect(1, 591, '\p{-In-Latin_extended-B}', ""); +Expect(0, 591, '\p{^-In-Latin_extended-B}', ""); +Expect(0, 591, '\P{-In-Latin_extended-B}', ""); +Expect(1, 591, '\P{^-In-Latin_extended-B}', ""); +Expect(0, 383, '\p{-In-Latin_extended-B}', ""); +Expect(1, 383, '\p{^-In-Latin_extended-B}', ""); +Expect(1, 383, '\P{-In-Latin_extended-B}', ""); +Expect(0, 383, '\P{^-In-Latin_extended-B}', ""); +Error('\p{ /a/cyrillic}'); +Error('\P{ /a/cyrillic}'); +Expect(1, 1315, '\p{cyrillic}', ""); +Expect(0, 1315, '\p{^cyrillic}', ""); +Expect(0, 1315, '\P{cyrillic}', ""); +Expect(1, 1315, '\P{^cyrillic}', ""); +Expect(0, 1023, '\p{cyrillic}', ""); +Expect(1, 1023, '\p{^cyrillic}', ""); +Expect(1, 1023, '\P{cyrillic}', ""); +Expect(0, 1023, '\P{^cyrillic}', ""); +Expect(1, 1315, '\p{ -CYRILLIC}', ""); +Expect(0, 1315, '\p{^ -CYRILLIC}', ""); +Expect(0, 1315, '\P{ -CYRILLIC}', ""); +Expect(1, 1315, '\P{^ -CYRILLIC}', ""); +Expect(0, 1023, '\p{ -CYRILLIC}', ""); +Expect(1, 1023, '\p{^ -CYRILLIC}', ""); +Expect(1, 1023, '\P{ -CYRILLIC}', ""); +Expect(0, 1023, '\P{^ -CYRILLIC}', ""); +Error('\p{:=_ ISCYRILLIC}'); +Error('\P{:=_ ISCYRILLIC}'); +Expect(1, 1315, '\p{iscyrillic}', ""); +Expect(0, 1315, '\p{^iscyrillic}', ""); +Expect(0, 1315, '\P{iscyrillic}', ""); +Expect(1, 1315, '\P{^iscyrillic}', ""); +Expect(0, 1023, '\p{iscyrillic}', ""); +Expect(1, 1023, '\p{^iscyrillic}', ""); +Expect(1, 1023, '\P{iscyrillic}', ""); +Expect(0, 1023, '\P{^iscyrillic}', ""); +Expect(1, 1315, '\p{ is cyrillic}', ""); +Expect(0, 1315, '\p{^ is cyrillic}', ""); +Expect(0, 1315, '\P{ is cyrillic}', ""); +Expect(1, 1315, '\P{^ is cyrillic}', ""); +Expect(0, 1023, '\p{ is cyrillic}', ""); +Expect(1, 1023, '\p{^ is cyrillic}', ""); +Expect(1, 1023, '\P{ is cyrillic}', ""); +Expect(0, 1023, '\P{^ is cyrillic}', ""); +Error('\p{ :=Cyrl}'); +Error('\P{ :=Cyrl}'); +Expect(1, 1315, '\p{cyrl}', ""); +Expect(0, 1315, '\p{^cyrl}', ""); +Expect(0, 1315, '\P{cyrl}', ""); +Expect(1, 1315, '\P{^cyrl}', ""); +Expect(0, 1023, '\p{cyrl}', ""); +Expect(1, 1023, '\p{^cyrl}', ""); +Expect(1, 1023, '\P{cyrl}', ""); +Expect(0, 1023, '\P{^cyrl}', ""); +Expect(1, 1315, '\p{- CYRL}', ""); +Expect(0, 1315, '\p{^- CYRL}', ""); +Expect(0, 1315, '\P{- CYRL}', ""); +Expect(1, 1315, '\P{^- CYRL}', ""); +Expect(0, 1023, '\p{- CYRL}', ""); +Expect(1, 1023, '\p{^- CYRL}', ""); +Expect(1, 1023, '\P{- CYRL}', ""); +Expect(0, 1023, '\P{^- CYRL}', ""); +Error('\p{ -Is-Cyrl:=}'); +Error('\P{ -Is-Cyrl:=}'); +Expect(1, 1315, '\p{iscyrl}', ""); +Expect(0, 1315, '\p{^iscyrl}', ""); +Expect(0, 1315, '\P{iscyrl}', ""); +Expect(1, 1315, '\P{^iscyrl}', ""); +Expect(0, 1023, '\p{iscyrl}', ""); +Expect(1, 1023, '\p{^iscyrl}', ""); +Expect(1, 1023, '\P{iscyrl}', ""); +Expect(0, 1023, '\P{^iscyrl}', ""); +Expect(1, 1315, '\p{ is-Cyrl}', ""); +Expect(0, 1315, '\p{^ is-Cyrl}', ""); +Expect(0, 1315, '\P{ is-Cyrl}', ""); +Expect(1, 1315, '\P{^ is-Cyrl}', ""); +Expect(0, 1023, '\p{ is-Cyrl}', ""); +Expect(1, 1023, '\p{^ is-Cyrl}', ""); +Expect(1, 1023, '\P{ is-Cyrl}', ""); +Expect(0, 1023, '\P{^ is-Cyrl}', ""); +Error('\p{/a/ Latin_extended_c}'); +Error('\P{/a/ Latin_extended_c}'); +Expect(1, 11391, '\p{latinextendedc}', ""); +Expect(0, 11391, '\p{^latinextendedc}', ""); +Expect(0, 11391, '\P{latinextendedc}', ""); +Expect(1, 11391, '\P{^latinextendedc}', ""); +Expect(0, 11359, '\p{latinextendedc}', ""); +Expect(1, 11359, '\p{^latinextendedc}', ""); +Expect(1, 11359, '\P{latinextendedc}', ""); +Expect(0, 11359, '\P{^latinextendedc}', ""); +Expect(1, 11391, '\p{- latin extended-C}', ""); +Expect(0, 11391, '\p{^- latin extended-C}', ""); +Expect(0, 11391, '\P{- latin extended-C}', ""); +Expect(1, 11391, '\P{^- latin extended-C}', ""); +Expect(0, 11359, '\p{- latin extended-C}', ""); +Expect(1, 11359, '\p{^- latin extended-C}', ""); +Expect(1, 11359, '\P{- latin extended-C}', ""); +Expect(0, 11359, '\P{^- latin extended-C}', ""); +Error('\p{_-Is latin Extended/a/C}'); +Error('\P{_-Is latin Extended/a/C}'); +Expect(1, 11391, '\p{islatinextendedc}', ""); +Expect(0, 11391, '\p{^islatinextendedc}', ""); +Expect(0, 11391, '\P{islatinextendedc}', ""); +Expect(1, 11391, '\P{^islatinextendedc}', ""); +Expect(0, 11359, '\p{islatinextendedc}', ""); +Expect(1, 11359, '\p{^islatinextendedc}', ""); +Expect(1, 11359, '\P{islatinextendedc}', ""); +Expect(0, 11359, '\P{^islatinextendedc}', ""); +Expect(1, 11391, '\p{-_IS Latin extended-C}', ""); +Expect(0, 11391, '\p{^-_IS Latin extended-C}', ""); +Expect(0, 11391, '\P{-_IS Latin extended-C}', ""); +Expect(1, 11391, '\P{^-_IS Latin extended-C}', ""); +Expect(0, 11359, '\p{-_IS Latin extended-C}', ""); +Expect(1, 11359, '\p{^-_IS Latin extended-C}', ""); +Expect(1, 11359, '\P{-_IS Latin extended-C}', ""); +Expect(0, 11359, '\P{^-_IS Latin extended-C}', ""); +Error('\p{:= _in Latin Extended c}'); +Error('\P{:= _in Latin Extended c}'); +Expect(1, 11391, '\p{inlatinextendedc}', ""); +Expect(0, 11391, '\p{^inlatinextendedc}', ""); +Expect(0, 11391, '\P{inlatinextendedc}', ""); +Expect(1, 11391, '\P{^inlatinextendedc}', ""); +Expect(0, 11359, '\p{inlatinextendedc}', ""); +Expect(1, 11359, '\p{^inlatinextendedc}', ""); +Expect(1, 11359, '\P{inlatinextendedc}', ""); +Expect(0, 11359, '\P{^inlatinextendedc}', ""); +Expect(1, 11391, '\p{-in_LATIN Extended C}', ""); +Expect(0, 11391, '\p{^-in_LATIN Extended C}', ""); +Expect(0, 11391, '\P{-in_LATIN Extended C}', ""); +Expect(1, 11391, '\P{^-in_LATIN Extended C}', ""); +Expect(0, 11359, '\p{-in_LATIN Extended C}', ""); +Expect(1, 11359, '\p{^-in_LATIN Extended C}', ""); +Expect(1, 11359, '\P{-in_LATIN Extended C}', ""); +Expect(0, 11359, '\P{^-in_LATIN Extended C}', ""); +Error('\p{/a/ IN Rejang}'); +Error('\P{/a/ IN Rejang}'); +Expect(1, 43359, '\p{inrejang}', ""); +Expect(0, 43359, '\p{^inrejang}', ""); +Expect(0, 43359, '\P{inrejang}', ""); +Expect(1, 43359, '\P{^inrejang}', ""); +Expect(0, 43311, '\p{inrejang}', ""); +Expect(1, 43311, '\p{^inrejang}', ""); +Expect(1, 43311, '\P{inrejang}', ""); +Expect(0, 43311, '\P{^inrejang}', ""); +Expect(1, 43359, '\p{ -In_rejang}', ""); +Expect(0, 43359, '\p{^ -In_rejang}', ""); +Expect(0, 43359, '\P{ -In_rejang}', ""); +Expect(1, 43359, '\P{^ -In_rejang}', ""); +Expect(0, 43311, '\p{ -In_rejang}', ""); +Expect(1, 43311, '\p{^ -In_rejang}', ""); +Expect(1, 43311, '\P{ -In_rejang}', ""); +Expect(0, 43311, '\P{^ -In_rejang}', ""); +Error('\p{ Combining/a/DIACRITICALMARKS-SUPPLEMENT}'); +Error('\P{ Combining/a/DIACRITICALMARKS-SUPPLEMENT}'); +Expect(1, 7679, '\p{combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\p{^combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\P{combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\P{^combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\p{combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\p{^combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\P{combiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\P{^combiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\p{--COMBINING_DiacriticalMARKS supplement}', ""); +Expect(0, 7679, '\p{^--COMBINING_DiacriticalMARKS supplement}', ""); +Expect(0, 7679, '\P{--COMBINING_DiacriticalMARKS supplement}', ""); +Expect(1, 7679, '\P{^--COMBINING_DiacriticalMARKS supplement}', ""); +Expect(0, 7615, '\p{--COMBINING_DiacriticalMARKS supplement}', ""); +Expect(1, 7615, '\p{^--COMBINING_DiacriticalMARKS supplement}', ""); +Expect(1, 7615, '\P{--COMBINING_DiacriticalMARKS supplement}', ""); +Expect(0, 7615, '\P{^--COMBINING_DiacriticalMARKS supplement}', ""); +Error('\p{_:=Is Combining_Diacritical marks-Supplement}'); +Error('\P{_:=Is Combining_Diacritical marks-Supplement}'); +Expect(1, 7679, '\p{iscombiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\p{^iscombiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\P{iscombiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\P{^iscombiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\p{iscombiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\p{^iscombiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\P{iscombiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\P{^iscombiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\p{_IS_COMBINING-diacritical_MARKSsupplement}', ""); +Expect(0, 7679, '\p{^_IS_COMBINING-diacritical_MARKSsupplement}', ""); +Expect(0, 7679, '\P{_IS_COMBINING-diacritical_MARKSsupplement}', ""); +Expect(1, 7679, '\P{^_IS_COMBINING-diacritical_MARKSsupplement}', ""); +Expect(0, 7615, '\p{_IS_COMBINING-diacritical_MARKSsupplement}', ""); +Expect(1, 7615, '\p{^_IS_COMBINING-diacritical_MARKSsupplement}', ""); +Expect(1, 7615, '\P{_IS_COMBINING-diacritical_MARKSsupplement}', ""); +Expect(0, 7615, '\P{^_IS_COMBINING-diacritical_MARKSsupplement}', ""); +Error('\p{ _In:=Combining_diacriticalmarks Supplement}'); +Error('\P{ _In:=Combining_diacriticalmarks Supplement}'); +Expect(1, 7679, '\p{incombiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\p{^incombiningdiacriticalmarkssupplement}', ""); +Expect(0, 7679, '\P{incombiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\P{^incombiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\p{incombiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\p{^incombiningdiacriticalmarkssupplement}', ""); +Expect(1, 7615, '\P{incombiningdiacriticalmarkssupplement}', ""); +Expect(0, 7615, '\P{^incombiningdiacriticalmarkssupplement}', ""); +Expect(1, 7679, '\p{ _In Combining_DIACRITICAL MARKS Supplement}', ""); +Expect(0, 7679, '\p{^ _In Combining_DIACRITICAL MARKS Supplement}', ""); +Expect(0, 7679, '\P{ _In Combining_DIACRITICAL MARKS Supplement}', ""); +Expect(1, 7679, '\P{^ _In Combining_DIACRITICAL MARKS Supplement}', ""); +Expect(0, 7615, '\p{ _In Combining_DIACRITICAL MARKS Supplement}', ""); +Expect(1, 7615, '\p{^ _In Combining_DIACRITICAL MARKS Supplement}', ""); +Expect(1, 7615, '\P{ _In Combining_DIACRITICAL MARKS Supplement}', ""); +Expect(0, 7615, '\P{^ _In Combining_DIACRITICAL MARKS Supplement}', ""); +Error('\p{/a/ -STerm}'); +Error('\P{/a/ -STerm}'); +Expect(1, 33, '\p{sterm}', ""); +Expect(0, 33, '\p{^sterm}', ""); +Expect(0, 33, '\P{sterm}', ""); +Expect(1, 33, '\P{^sterm}', ""); +Expect(0, 32, '\p{sterm}', ""); +Expect(1, 32, '\p{^sterm}', ""); +Expect(1, 32, '\P{sterm}', ""); +Expect(0, 32, '\P{^sterm}', ""); +Expect(1, 33, '\p{-_STerm}', ""); +Expect(0, 33, '\p{^-_STerm}', ""); +Expect(0, 33, '\P{-_STerm}', ""); +Expect(1, 33, '\P{^-_STerm}', ""); +Expect(0, 32, '\p{-_STerm}', ""); +Expect(1, 32, '\p{^-_STerm}', ""); +Expect(1, 32, '\P{-_STerm}', ""); +Expect(0, 32, '\P{^-_STerm}', ""); +Error('\p{:= ISSTerm}'); +Error('\P{:= ISSTerm}'); +Expect(1, 33, '\p{issterm}', ""); +Expect(0, 33, '\p{^issterm}', ""); +Expect(0, 33, '\P{issterm}', ""); +Expect(1, 33, '\P{^issterm}', ""); +Expect(0, 32, '\p{issterm}', ""); +Expect(1, 32, '\p{^issterm}', ""); +Expect(1, 32, '\P{issterm}', ""); +Expect(0, 32, '\P{^issterm}', ""); +Expect(1, 33, '\p{--IsSTerm}', ""); +Expect(0, 33, '\p{^--IsSTerm}', ""); +Expect(0, 33, '\P{--IsSTerm}', ""); +Expect(1, 33, '\P{^--IsSTerm}', ""); +Expect(0, 32, '\p{--IsSTerm}', ""); +Expect(1, 32, '\p{^--IsSTerm}', ""); +Expect(1, 32, '\P{--IsSTerm}', ""); +Expect(0, 32, '\P{^--IsSTerm}', ""); +Error('\p{_ IN Kannada/a/}'); +Error('\P{_ IN Kannada/a/}'); +Expect(1, 3327, '\p{inkannada}', ""); +Expect(0, 3327, '\p{^inkannada}', ""); +Expect(0, 3327, '\P{inkannada}', ""); +Expect(1, 3327, '\P{^inkannada}', ""); +Expect(0, 3199, '\p{inkannada}', ""); +Expect(1, 3199, '\p{^inkannada}', ""); +Expect(1, 3199, '\P{inkannada}', ""); +Expect(0, 3199, '\P{^inkannada}', ""); +Expect(1, 3327, '\p{ _INKANNADA}', ""); +Expect(0, 3327, '\p{^ _INKANNADA}', ""); +Expect(0, 3327, '\P{ _INKANNADA}', ""); +Expect(1, 3327, '\P{^ _INKANNADA}', ""); +Expect(0, 3199, '\p{ _INKANNADA}', ""); +Expect(1, 3199, '\p{^ _INKANNADA}', ""); +Expect(1, 3199, '\P{ _INKANNADA}', ""); +Expect(0, 3199, '\P{^ _INKANNADA}', ""); +Error('\p{/a/Word}'); +Error('\P{/a/Word}'); +Expect(1, 57, '\p{word}', ""); +Expect(0, 57, '\p{^word}', ""); +Expect(0, 57, '\P{word}', ""); +Expect(1, 57, '\P{^word}', ""); +Expect(0, 47, '\p{word}', ""); +Expect(1, 47, '\p{^word}', ""); +Expect(1, 47, '\P{word}', ""); +Expect(0, 47, '\P{^word}', ""); +Expect(1, 57, '\p{--WORD}', ""); +Expect(0, 57, '\p{^--WORD}', ""); +Expect(0, 57, '\P{--WORD}', ""); +Expect(1, 57, '\P{^--WORD}', ""); +Expect(0, 47, '\p{--WORD}', ""); +Expect(1, 47, '\p{^--WORD}', ""); +Expect(1, 47, '\P{--WORD}', ""); +Expect(0, 47, '\P{^--WORD}', ""); +Error('\p{_is:=word}'); +Error('\P{_is:=word}'); +Expect(1, 57, '\p{isword}', ""); +Expect(0, 57, '\p{^isword}', ""); +Expect(0, 57, '\P{isword}', ""); +Expect(1, 57, '\P{^isword}', ""); +Expect(0, 47, '\p{isword}', ""); +Expect(1, 47, '\p{^isword}', ""); +Expect(1, 47, '\P{isword}', ""); +Expect(0, 47, '\P{^isword}', ""); +Expect(1, 57, '\p{ is word}', ""); +Expect(0, 57, '\p{^ is word}', ""); +Expect(0, 57, '\P{ is word}', ""); +Expect(1, 57, '\P{^ is word}', ""); +Expect(0, 47, '\p{ is word}', ""); +Expect(1, 47, '\p{^ is word}', ""); +Expect(1, 47, '\P{ is word}', ""); +Expect(0, 47, '\P{^ is word}', ""); +Error('\p{_SOFT dotted/a/}'); +Error('\P{_SOFT dotted/a/}'); +Expect(1, 106, '\p{softdotted}', ""); +Expect(0, 106, '\p{^softdotted}', ""); +Expect(0, 106, '\P{softdotted}', ""); +Expect(1, 106, '\P{^softdotted}', ""); +Expect(0, 104, '\p{softdotted}', ""); +Expect(1, 104, '\p{^softdotted}', ""); +Expect(1, 104, '\P{softdotted}', ""); +Expect(0, 104, '\P{^softdotted}', ""); +Expect(1, 106, '\p{ softdotted}', ""); +Expect(0, 106, '\p{^ softdotted}', ""); +Expect(0, 106, '\P{ softdotted}', ""); +Expect(1, 106, '\P{^ softdotted}', ""); +Expect(0, 104, '\p{ softdotted}', ""); +Expect(1, 104, '\p{^ softdotted}', ""); +Expect(1, 104, '\P{ softdotted}', ""); +Expect(0, 104, '\P{^ softdotted}', ""); +Error('\p{ IS:=Soft_DOTTED}'); +Error('\P{ IS:=Soft_DOTTED}'); +Expect(1, 106, '\p{issoftdotted}', ""); +Expect(0, 106, '\p{^issoftdotted}', ""); +Expect(0, 106, '\P{issoftdotted}', ""); +Expect(1, 106, '\P{^issoftdotted}', ""); +Expect(0, 104, '\p{issoftdotted}', ""); +Expect(1, 104, '\p{^issoftdotted}', ""); +Expect(1, 104, '\P{issoftdotted}', ""); +Expect(0, 104, '\P{^issoftdotted}', ""); +Expect(1, 106, '\p{_-IS_SOFT-dotted}', ""); +Expect(0, 106, '\p{^_-IS_SOFT-dotted}', ""); +Expect(0, 106, '\P{_-IS_SOFT-dotted}', ""); +Expect(1, 106, '\P{^_-IS_SOFT-dotted}', ""); +Expect(0, 104, '\p{_-IS_SOFT-dotted}', ""); +Expect(1, 104, '\p{^_-IS_SOFT-dotted}', ""); +Expect(1, 104, '\P{_-IS_SOFT-dotted}', ""); +Expect(0, 104, '\P{^_-IS_SOFT-dotted}', ""); +Error('\p{/a/ -SD}'); +Error('\P{/a/ -SD}'); +Expect(1, 106, '\p{sd}', ""); +Expect(0, 106, '\p{^sd}', ""); +Expect(0, 106, '\P{sd}', ""); +Expect(1, 106, '\P{^sd}', ""); +Expect(0, 104, '\p{sd}', ""); +Expect(1, 104, '\p{^sd}', ""); +Expect(1, 104, '\P{sd}', ""); +Expect(0, 104, '\P{^sd}', ""); +Expect(1, 106, '\p{-SD}', ""); +Expect(0, 106, '\p{^-SD}', ""); +Expect(0, 106, '\P{-SD}', ""); +Expect(1, 106, '\P{^-SD}', ""); +Expect(0, 104, '\p{-SD}', ""); +Expect(1, 104, '\p{^-SD}', ""); +Expect(1, 104, '\P{-SD}', ""); +Expect(0, 104, '\P{^-SD}', ""); +Error('\p{ _IS/a/sd}'); +Error('\P{ _IS/a/sd}'); +Expect(1, 106, '\p{issd}', ""); +Expect(0, 106, '\p{^issd}', ""); +Expect(0, 106, '\P{issd}', ""); +Expect(1, 106, '\P{^issd}', ""); +Expect(0, 104, '\p{issd}', ""); +Expect(1, 104, '\p{^issd}', ""); +Expect(1, 104, '\P{issd}', ""); +Expect(0, 104, '\P{^issd}', ""); +Expect(1, 106, '\p{ -IS SD}', ""); +Expect(0, 106, '\p{^ -IS SD}', ""); +Expect(0, 106, '\P{ -IS SD}', ""); +Expect(1, 106, '\P{^ -IS SD}', ""); +Expect(0, 104, '\p{ -IS SD}', ""); +Expect(1, 104, '\p{^ -IS SD}', ""); +Expect(1, 104, '\P{ -IS SD}', ""); +Expect(0, 104, '\P{^ -IS SD}', ""); +Error('\p{_:=-CanonDCIJ}'); +Error('\P{_:=-CanonDCIJ}'); +Expect(1, 106, '\p{_CanonDCIJ}', ""); +Expect(0, 106, '\p{^_CanonDCIJ}', ""); +Expect(0, 106, '\P{_CanonDCIJ}', ""); +Expect(1, 106, '\P{^_CanonDCIJ}', ""); +Expect(0, 104, '\p{_CanonDCIJ}', ""); +Expect(1, 104, '\p{^_CanonDCIJ}', ""); +Expect(1, 104, '\P{_CanonDCIJ}', ""); +Expect(0, 104, '\P{^_CanonDCIJ}', ""); +Error('\p{_:=-GCB_EXTEND}'); +Error('\P{_:=-GCB_EXTEND}'); +Expect(1, 879, '\p{_GCB_EXTEND}', ""); +Expect(0, 879, '\p{^_GCB_EXTEND}', ""); +Expect(0, 879, '\P{_GCB_EXTEND}', ""); +Expect(1, 879, '\P{^_GCB_EXTEND}', ""); +Expect(0, 767, '\p{_GCB_EXTEND}', ""); +Expect(1, 767, '\p{^_GCB_EXTEND}', ""); +Expect(1, 767, '\P{_GCB_EXTEND}', ""); +Expect(0, 767, '\P{^_GCB_EXTEND}', ""); +Error('\p{/a/_Control PICTURES}'); +Error('\P{/a/_Control PICTURES}'); +Expect(1, 9279, '\p{controlpictures}', ""); +Expect(0, 9279, '\p{^controlpictures}', ""); +Expect(0, 9279, '\P{controlpictures}', ""); +Expect(1, 9279, '\P{^controlpictures}', ""); +Expect(0, 9215, '\p{controlpictures}', ""); +Expect(1, 9215, '\p{^controlpictures}', ""); +Expect(1, 9215, '\P{controlpictures}', ""); +Expect(0, 9215, '\P{^controlpictures}', ""); +Expect(1, 9279, '\p{ control pictures}', ""); +Expect(0, 9279, '\p{^ control pictures}', ""); +Expect(0, 9279, '\P{ control pictures}', ""); +Expect(1, 9279, '\P{^ control pictures}', ""); +Expect(0, 9215, '\p{ control pictures}', ""); +Expect(1, 9215, '\p{^ control pictures}', ""); +Expect(1, 9215, '\P{ control pictures}', ""); +Expect(0, 9215, '\P{^ control pictures}', ""); +Error('\p{ -Is:=CONTROL Pictures}'); +Error('\P{ -Is:=CONTROL Pictures}'); +Expect(1, 9279, '\p{iscontrolpictures}', ""); +Expect(0, 9279, '\p{^iscontrolpictures}', ""); +Expect(0, 9279, '\P{iscontrolpictures}', ""); +Expect(1, 9279, '\P{^iscontrolpictures}', ""); +Expect(0, 9215, '\p{iscontrolpictures}', ""); +Expect(1, 9215, '\p{^iscontrolpictures}', ""); +Expect(1, 9215, '\P{iscontrolpictures}', ""); +Expect(0, 9215, '\P{^iscontrolpictures}', ""); +Expect(1, 9279, '\p{ Is_Control PICTURES}', ""); +Expect(0, 9279, '\p{^ Is_Control PICTURES}', ""); +Expect(0, 9279, '\P{ Is_Control PICTURES}', ""); +Expect(1, 9279, '\P{^ Is_Control PICTURES}', ""); +Expect(0, 9215, '\p{ Is_Control PICTURES}', ""); +Expect(1, 9215, '\p{^ Is_Control PICTURES}', ""); +Expect(1, 9215, '\P{ Is_Control PICTURES}', ""); +Expect(0, 9215, '\P{^ Is_Control PICTURES}', ""); +Error('\p{:= In-Control_PICTURES}'); +Error('\P{:= In-Control_PICTURES}'); +Expect(1, 9279, '\p{incontrolpictures}', ""); +Expect(0, 9279, '\p{^incontrolpictures}', ""); +Expect(0, 9279, '\P{incontrolpictures}', ""); +Expect(1, 9279, '\P{^incontrolpictures}', ""); +Expect(0, 9215, '\p{incontrolpictures}', ""); +Expect(1, 9215, '\p{^incontrolpictures}', ""); +Expect(1, 9215, '\P{incontrolpictures}', ""); +Expect(0, 9215, '\P{^incontrolpictures}', ""); +Expect(1, 9279, '\p{ In_Control PICTURES}', ""); +Expect(0, 9279, '\p{^ In_Control PICTURES}', ""); +Expect(0, 9279, '\P{ In_Control PICTURES}', ""); +Expect(1, 9279, '\P{^ In_Control PICTURES}', ""); +Expect(0, 9215, '\p{ In_Control PICTURES}', ""); +Expect(1, 9215, '\p{^ In_Control PICTURES}', ""); +Expect(1, 9215, '\P{ In_Control PICTURES}', ""); +Expect(0, 9215, '\P{^ In_Control PICTURES}', ""); +Error('\p{- Latin:=Extended A}'); +Error('\P{- Latin:=Extended A}'); +Expect(1, 383, '\p{latinextendeda}', ""); +Expect(0, 383, '\p{^latinextendeda}', ""); +Expect(0, 383, '\P{latinextendeda}', ""); +Expect(1, 383, '\P{^latinextendeda}', ""); +Expect(0, 7, '\p{latinextendeda}', ""); +Expect(1, 7, '\p{^latinextendeda}', ""); +Expect(1, 7, '\P{latinextendeda}', ""); +Expect(0, 7, '\P{^latinextendeda}', ""); +Expect(1, 383, '\p{--latin EXTENDED A}', ""); +Expect(0, 383, '\p{^--latin EXTENDED A}', ""); +Expect(0, 383, '\P{--latin EXTENDED A}', ""); +Expect(1, 383, '\P{^--latin EXTENDED A}', ""); +Expect(0, 7, '\p{--latin EXTENDED A}', ""); +Expect(1, 7, '\p{^--latin EXTENDED A}', ""); +Expect(1, 7, '\P{--latin EXTENDED A}', ""); +Expect(0, 7, '\P{^--latin EXTENDED A}', ""); +Error('\p{IS:=latin Extended-A}'); +Error('\P{IS:=latin Extended-A}'); +Expect(1, 383, '\p{islatinextendeda}', ""); +Expect(0, 383, '\p{^islatinextendeda}', ""); +Expect(0, 383, '\P{islatinextendeda}', ""); +Expect(1, 383, '\P{^islatinextendeda}', ""); +Expect(0, 7, '\p{islatinextendeda}', ""); +Expect(1, 7, '\p{^islatinextendeda}', ""); +Expect(1, 7, '\P{islatinextendeda}', ""); +Expect(0, 7, '\P{^islatinextendeda}', ""); +Expect(1, 383, '\p{ -Is Latin extendeda}', ""); +Expect(0, 383, '\p{^ -Is Latin extendeda}', ""); +Expect(0, 383, '\P{ -Is Latin extendeda}', ""); +Expect(1, 383, '\P{^ -Is Latin extendeda}', ""); +Expect(0, 7, '\p{ -Is Latin extendeda}', ""); +Expect(1, 7, '\p{^ -Is Latin extendeda}', ""); +Expect(1, 7, '\P{ -Is Latin extendeda}', ""); +Expect(0, 7, '\P{^ -Is Latin extendeda}', ""); +Error('\p{_IN-latinExtended_A:=}'); +Error('\P{_IN-latinExtended_A:=}'); +Expect(1, 383, '\p{inlatinextendeda}', ""); +Expect(0, 383, '\p{^inlatinextendeda}', ""); +Expect(0, 383, '\P{inlatinextendeda}', ""); +Expect(1, 383, '\P{^inlatinextendeda}', ""); +Expect(0, 7, '\p{inlatinextendeda}', ""); +Expect(1, 7, '\p{^inlatinextendeda}', ""); +Expect(1, 7, '\P{inlatinextendeda}', ""); +Expect(0, 7, '\P{^inlatinextendeda}', ""); +Expect(1, 383, '\p{ IN Latin Extended a}', ""); +Expect(0, 383, '\p{^ IN Latin Extended a}', ""); +Expect(0, 383, '\P{ IN Latin Extended a}', ""); +Expect(1, 383, '\P{^ IN Latin Extended a}', ""); +Expect(0, 7, '\p{ IN Latin Extended a}', ""); +Expect(1, 7, '\p{^ IN Latin Extended a}', ""); +Expect(1, 7, '\P{ IN Latin Extended a}', ""); +Expect(0, 7, '\P{^ IN Latin Extended a}', ""); +Error('\p{ /a/gujarati}'); +Error('\P{ /a/gujarati}'); +Expect(1, 2691, '\p{gujarati}', ""); +Expect(0, 2691, '\p{^gujarati}', ""); +Expect(0, 2691, '\P{gujarati}', ""); +Expect(1, 2691, '\P{^gujarati}', ""); +Expect(0, 2688, '\p{gujarati}', ""); +Expect(1, 2688, '\p{^gujarati}', ""); +Expect(1, 2688, '\P{gujarati}', ""); +Expect(0, 2688, '\P{^gujarati}', ""); +Expect(1, 2691, '\p{ Gujarati}', ""); +Expect(0, 2691, '\p{^ Gujarati}', ""); +Expect(0, 2691, '\P{ Gujarati}', ""); +Expect(1, 2691, '\P{^ Gujarati}', ""); +Expect(0, 2688, '\p{ Gujarati}', ""); +Expect(1, 2688, '\p{^ Gujarati}', ""); +Expect(1, 2688, '\P{ Gujarati}', ""); +Expect(0, 2688, '\P{^ Gujarati}', ""); +Error('\p{_Is Gujarati:=}'); +Error('\P{_Is Gujarati:=}'); +Expect(1, 2691, '\p{isgujarati}', ""); +Expect(0, 2691, '\p{^isgujarati}', ""); +Expect(0, 2691, '\P{isgujarati}', ""); +Expect(1, 2691, '\P{^isgujarati}', ""); +Expect(0, 2688, '\p{isgujarati}', ""); +Expect(1, 2688, '\p{^isgujarati}', ""); +Expect(1, 2688, '\P{isgujarati}', ""); +Expect(0, 2688, '\P{^isgujarati}', ""); +Expect(1, 2691, '\p{ -Is GUJARATI}', ""); +Expect(0, 2691, '\p{^ -Is GUJARATI}', ""); +Expect(0, 2691, '\P{ -Is GUJARATI}', ""); +Expect(1, 2691, '\P{^ -Is GUJARATI}', ""); +Expect(0, 2688, '\p{ -Is GUJARATI}', ""); +Expect(1, 2688, '\p{^ -Is GUJARATI}', ""); +Expect(1, 2688, '\P{ -Is GUJARATI}', ""); +Expect(0, 2688, '\P{^ -Is GUJARATI}', ""); +Error('\p{:= gujr}'); +Error('\P{:= gujr}'); +Expect(1, 2691, '\p{gujr}', ""); +Expect(0, 2691, '\p{^gujr}', ""); +Expect(0, 2691, '\P{gujr}', ""); +Expect(1, 2691, '\P{^gujr}', ""); +Expect(0, 2688, '\p{gujr}', ""); +Expect(1, 2688, '\p{^gujr}', ""); +Expect(1, 2688, '\P{gujr}', ""); +Expect(0, 2688, '\P{^gujr}', ""); +Expect(1, 2691, '\p{ GUJR}', ""); +Expect(0, 2691, '\p{^ GUJR}', ""); +Expect(0, 2691, '\P{ GUJR}', ""); +Expect(1, 2691, '\P{^ GUJR}', ""); +Expect(0, 2688, '\p{ GUJR}', ""); +Expect(1, 2688, '\p{^ GUJR}', ""); +Expect(1, 2688, '\P{ GUJR}', ""); +Expect(0, 2688, '\P{^ GUJR}', ""); +Error('\p{ IS GUJR:=}'); +Error('\P{ IS GUJR:=}'); +Expect(1, 2691, '\p{isgujr}', ""); +Expect(0, 2691, '\p{^isgujr}', ""); +Expect(0, 2691, '\P{isgujr}', ""); +Expect(1, 2691, '\P{^isgujr}', ""); +Expect(0, 2688, '\p{isgujr}', ""); +Expect(1, 2688, '\p{^isgujr}', ""); +Expect(1, 2688, '\P{isgujr}', ""); +Expect(0, 2688, '\P{^isgujr}', ""); +Expect(1, 2691, '\p{ Is_GUJR}', ""); +Expect(0, 2691, '\p{^ Is_GUJR}', ""); +Expect(0, 2691, '\P{ Is_GUJR}', ""); +Expect(1, 2691, '\P{^ Is_GUJR}', ""); +Expect(0, 2688, '\p{ Is_GUJR}', ""); +Expect(1, 2688, '\p{^ Is_GUJR}', ""); +Expect(1, 2688, '\P{ Is_GUJR}', ""); +Expect(0, 2688, '\P{^ Is_GUJR}', ""); +Error('\p{/a/SPACEPERL}'); +Error('\P{/a/SPACEPERL}'); +Expect(1, 10, '\p{spaceperl}', ""); +Expect(0, 10, '\p{^spaceperl}', ""); +Expect(0, 10, '\P{spaceperl}', ""); +Expect(1, 10, '\P{^spaceperl}', ""); +Expect(0, 8, '\p{spaceperl}', ""); +Expect(1, 8, '\p{^spaceperl}', ""); +Expect(1, 8, '\P{spaceperl}', ""); +Expect(0, 8, '\P{^spaceperl}', ""); +Expect(1, 10, '\p{_ SPACEPERL}', ""); +Expect(0, 10, '\p{^_ SPACEPERL}', ""); +Expect(0, 10, '\P{_ SPACEPERL}', ""); +Expect(1, 10, '\P{^_ SPACEPERL}', ""); +Expect(0, 8, '\p{_ SPACEPERL}', ""); +Expect(1, 8, '\p{^_ SPACEPERL}', ""); +Expect(1, 8, '\P{_ SPACEPERL}', ""); +Expect(0, 8, '\P{^_ SPACEPERL}', ""); +Error('\p{/a/-IS spaceperl}'); +Error('\P{/a/-IS spaceperl}'); +Expect(1, 10, '\p{isspaceperl}', ""); +Expect(0, 10, '\p{^isspaceperl}', ""); +Expect(0, 10, '\P{isspaceperl}', ""); +Expect(1, 10, '\P{^isspaceperl}', ""); +Expect(0, 8, '\p{isspaceperl}', ""); +Expect(1, 8, '\p{^isspaceperl}', ""); +Expect(1, 8, '\P{isspaceperl}', ""); +Expect(0, 8, '\P{^isspaceperl}', ""); +Expect(1, 10, '\p{-_is SpacePerl}', ""); +Expect(0, 10, '\p{^-_is SpacePerl}', ""); +Expect(0, 10, '\P{-_is SpacePerl}', ""); +Expect(1, 10, '\P{^-_is SpacePerl}', ""); +Expect(0, 8, '\p{-_is SpacePerl}', ""); +Expect(1, 8, '\p{^-_is SpacePerl}', ""); +Expect(1, 8, '\P{-_is SpacePerl}', ""); +Expect(0, 8, '\P{^-_is SpacePerl}', ""); +Error('\p{_In:=Oriya}'); +Error('\P{_In:=Oriya}'); +Expect(1, 2943, '\p{inoriya}', ""); +Expect(0, 2943, '\p{^inoriya}', ""); +Expect(0, 2943, '\P{inoriya}', ""); +Expect(1, 2943, '\P{^inoriya}', ""); +Expect(0, 2815, '\p{inoriya}', ""); +Expect(1, 2815, '\p{^inoriya}', ""); +Expect(1, 2815, '\P{inoriya}', ""); +Expect(0, 2815, '\P{^inoriya}', ""); +Expect(1, 2943, '\p{_ In_Oriya}', ""); +Expect(0, 2943, '\p{^_ In_Oriya}', ""); +Expect(0, 2943, '\P{_ In_Oriya}', ""); +Expect(1, 2943, '\P{^_ In_Oriya}', ""); +Expect(0, 2815, '\p{_ In_Oriya}', ""); +Expect(1, 2815, '\p{^_ In_Oriya}', ""); +Expect(1, 2815, '\P{_ In_Oriya}', ""); +Expect(0, 2815, '\P{^_ In_Oriya}', ""); +Error('\p{ CJK/a/unified_Ideographs}'); +Error('\P{ CJK/a/unified_Ideographs}'); +Expect(1, 40959, '\p{cjkunifiedideographs}', ""); +Expect(0, 40959, '\p{^cjkunifiedideographs}', ""); +Expect(0, 40959, '\P{cjkunifiedideographs}', ""); +Expect(1, 40959, '\P{^cjkunifiedideographs}', ""); +Expect(0, 19967, '\p{cjkunifiedideographs}', ""); +Expect(1, 19967, '\p{^cjkunifiedideographs}', ""); +Expect(1, 19967, '\P{cjkunifiedideographs}', ""); +Expect(0, 19967, '\P{^cjkunifiedideographs}', ""); +Expect(1, 40959, '\p{ -CJKUnified Ideographs}', ""); +Expect(0, 40959, '\p{^ -CJKUnified Ideographs}', ""); +Expect(0, 40959, '\P{ -CJKUnified Ideographs}', ""); +Expect(1, 40959, '\P{^ -CJKUnified Ideographs}', ""); +Expect(0, 19967, '\p{ -CJKUnified Ideographs}', ""); +Expect(1, 19967, '\p{^ -CJKUnified Ideographs}', ""); +Expect(1, 19967, '\P{ -CJKUnified Ideographs}', ""); +Expect(0, 19967, '\P{^ -CJKUnified Ideographs}', ""); +Error('\p{ Is CJK Unified:=IDEOGRAPHS}'); +Error('\P{ Is CJK Unified:=IDEOGRAPHS}'); +Expect(1, 40959, '\p{iscjkunifiedideographs}', ""); +Expect(0, 40959, '\p{^iscjkunifiedideographs}', ""); +Expect(0, 40959, '\P{iscjkunifiedideographs}', ""); +Expect(1, 40959, '\P{^iscjkunifiedideographs}', ""); +Expect(0, 19967, '\p{iscjkunifiedideographs}', ""); +Expect(1, 19967, '\p{^iscjkunifiedideographs}', ""); +Expect(1, 19967, '\P{iscjkunifiedideographs}', ""); +Expect(0, 19967, '\P{^iscjkunifiedideographs}', ""); +Expect(1, 40959, '\p{_-Is cjk Unified-ideographs}', ""); +Expect(0, 40959, '\p{^_-Is cjk Unified-ideographs}', ""); +Expect(0, 40959, '\P{_-Is cjk Unified-ideographs}', ""); +Expect(1, 40959, '\P{^_-Is cjk Unified-ideographs}', ""); +Expect(0, 19967, '\p{_-Is cjk Unified-ideographs}', ""); +Expect(1, 19967, '\p{^_-Is cjk Unified-ideographs}', ""); +Expect(1, 19967, '\P{_-Is cjk Unified-ideographs}', ""); +Expect(0, 19967, '\P{^_-Is cjk Unified-ideographs}', ""); +Error('\p{/a/In CJK_UnifiedIdeographs}'); +Error('\P{/a/In CJK_UnifiedIdeographs}'); +Expect(1, 40959, '\p{incjkunifiedideographs}', ""); +Expect(0, 40959, '\p{^incjkunifiedideographs}', ""); +Expect(0, 40959, '\P{incjkunifiedideographs}', ""); +Expect(1, 40959, '\P{^incjkunifiedideographs}', ""); +Expect(0, 19967, '\p{incjkunifiedideographs}', ""); +Expect(1, 19967, '\p{^incjkunifiedideographs}', ""); +Expect(1, 19967, '\P{incjkunifiedideographs}', ""); +Expect(0, 19967, '\P{^incjkunifiedideographs}', ""); +Expect(1, 40959, '\p{- In-CJK unified Ideographs}', ""); +Expect(0, 40959, '\p{^- In-CJK unified Ideographs}', ""); +Expect(0, 40959, '\P{- In-CJK unified Ideographs}', ""); +Expect(1, 40959, '\P{^- In-CJK unified Ideographs}', ""); +Expect(0, 19967, '\p{- In-CJK unified Ideographs}', ""); +Expect(1, 19967, '\p{^- In-CJK unified Ideographs}', ""); +Expect(1, 19967, '\P{- In-CJK unified Ideographs}', ""); +Expect(0, 19967, '\P{^- In-CJK unified Ideographs}', ""); +Error('\p{ :=ID_CONTINUE}'); +Error('\P{ :=ID_CONTINUE}'); +Expect(1, 57, '\p{idcontinue}', ""); +Expect(0, 57, '\p{^idcontinue}', ""); +Expect(0, 57, '\P{idcontinue}', ""); +Expect(1, 57, '\P{^idcontinue}', ""); +Expect(0, 47, '\p{idcontinue}', ""); +Expect(1, 47, '\p{^idcontinue}', ""); +Expect(1, 47, '\P{idcontinue}', ""); +Expect(0, 47, '\P{^idcontinue}', ""); +Expect(1, 57, '\p{_ id Continue}', ""); +Expect(0, 57, '\p{^_ id Continue}', ""); +Expect(0, 57, '\P{_ id Continue}', ""); +Expect(1, 57, '\P{^_ id Continue}', ""); +Expect(0, 47, '\p{_ id Continue}', ""); +Expect(1, 47, '\p{^_ id Continue}', ""); +Expect(1, 47, '\P{_ id Continue}', ""); +Expect(0, 47, '\P{^_ id Continue}', ""); +Error('\p{ /a/IS ID Continue}'); +Error('\P{ /a/IS ID Continue}'); +Expect(1, 57, '\p{isidcontinue}', ""); +Expect(0, 57, '\p{^isidcontinue}', ""); +Expect(0, 57, '\P{isidcontinue}', ""); +Expect(1, 57, '\P{^isidcontinue}', ""); +Expect(0, 47, '\p{isidcontinue}', ""); +Expect(1, 47, '\p{^isidcontinue}', ""); +Expect(1, 47, '\P{isidcontinue}', ""); +Expect(0, 47, '\P{^isidcontinue}', ""); +Expect(1, 57, '\p{-ISid-continue}', ""); +Expect(0, 57, '\p{^-ISid-continue}', ""); +Expect(0, 57, '\P{-ISid-continue}', ""); +Expect(1, 57, '\P{^-ISid-continue}', ""); +Expect(0, 47, '\p{-ISid-continue}', ""); +Expect(1, 47, '\p{^-ISid-continue}', ""); +Expect(1, 47, '\P{-ISid-continue}', ""); +Expect(0, 47, '\P{^-ISid-continue}', ""); +Error('\p{ :=IDC}'); +Error('\P{ :=IDC}'); +Expect(1, 57, '\p{idc}', ""); +Expect(0, 57, '\p{^idc}', ""); +Expect(0, 57, '\P{idc}', ""); +Expect(1, 57, '\P{^idc}', ""); +Expect(0, 47, '\p{idc}', ""); +Expect(1, 47, '\p{^idc}', ""); +Expect(1, 47, '\P{idc}', ""); +Expect(0, 47, '\P{^idc}', ""); +Expect(1, 57, '\p{ IDC}', ""); +Expect(0, 57, '\p{^ IDC}', ""); +Expect(0, 57, '\P{ IDC}', ""); +Expect(1, 57, '\P{^ IDC}', ""); +Expect(0, 47, '\p{ IDC}', ""); +Expect(1, 47, '\p{^ IDC}', ""); +Expect(1, 47, '\P{ IDC}', ""); +Expect(0, 47, '\P{^ IDC}', ""); +Error('\p{:=-IS IDC}'); +Error('\P{:=-IS IDC}'); +Expect(1, 57, '\p{isidc}', ""); +Expect(0, 57, '\p{^isidc}', ""); +Expect(0, 57, '\P{isidc}', ""); +Expect(1, 57, '\P{^isidc}', ""); +Expect(0, 47, '\p{isidc}', ""); +Expect(1, 47, '\p{^isidc}', ""); +Expect(1, 47, '\P{isidc}', ""); +Expect(0, 47, '\P{^isidc}', ""); +Expect(1, 57, '\p{ ISIDC}', ""); +Expect(0, 57, '\p{^ ISIDC}', ""); +Expect(0, 57, '\P{ ISIDC}', ""); +Expect(1, 57, '\P{^ ISIDC}', ""); +Expect(0, 47, '\p{ ISIDC}', ""); +Expect(1, 47, '\p{^ ISIDC}', ""); +Expect(1, 47, '\P{ ISIDC}', ""); +Expect(0, 47, '\P{^ ISIDC}', ""); +Error('\p{:= in-GLAGOLITIC}'); +Error('\P{:= in-GLAGOLITIC}'); +Expect(1, 11359, '\p{inglagolitic}', ""); +Expect(0, 11359, '\p{^inglagolitic}', ""); +Expect(0, 11359, '\P{inglagolitic}', ""); +Expect(1, 11359, '\P{^inglagolitic}', ""); +Expect(0, 11263, '\p{inglagolitic}', ""); +Expect(1, 11263, '\p{^inglagolitic}', ""); +Expect(1, 11263, '\P{inglagolitic}', ""); +Expect(0, 11263, '\P{^inglagolitic}', ""); +Expect(1, 11359, '\p{- IN-glagolitic}', ""); +Expect(0, 11359, '\p{^- IN-glagolitic}', ""); +Expect(0, 11359, '\P{- IN-glagolitic}', ""); +Expect(1, 11359, '\P{^- IN-glagolitic}', ""); +Expect(0, 11263, '\p{- IN-glagolitic}', ""); +Expect(1, 11263, '\p{^- IN-glagolitic}', ""); +Expect(1, 11263, '\P{- IN-glagolitic}', ""); +Expect(0, 11263, '\P{^- IN-glagolitic}', ""); +Error('\p{_ open/a/PUNCTUATION}'); +Error('\P{_ open/a/PUNCTUATION}'); +Expect(1, 40, '\p{openpunctuation}', ""); +Expect(0, 40, '\p{^openpunctuation}', ""); +Expect(0, 40, '\P{openpunctuation}', ""); +Expect(1, 40, '\P{^openpunctuation}', ""); +Expect(0, 39, '\p{openpunctuation}', ""); +Expect(1, 39, '\p{^openpunctuation}', ""); +Expect(1, 39, '\P{openpunctuation}', ""); +Expect(0, 39, '\P{^openpunctuation}', ""); +Expect(1, 40, '\p{open Punctuation}', ""); +Expect(0, 40, '\p{^open Punctuation}', ""); +Expect(0, 40, '\P{open Punctuation}', ""); +Expect(1, 40, '\P{^open Punctuation}', ""); +Expect(0, 39, '\p{open Punctuation}', ""); +Expect(1, 39, '\p{^open Punctuation}', ""); +Expect(1, 39, '\P{open Punctuation}', ""); +Expect(0, 39, '\P{^open Punctuation}', ""); +Error('\p{-Is/a/open PUNCTUATION}'); +Error('\P{-Is/a/open PUNCTUATION}'); +Expect(1, 40, '\p{isopenpunctuation}', ""); +Expect(0, 40, '\p{^isopenpunctuation}', ""); +Expect(0, 40, '\P{isopenpunctuation}', ""); +Expect(1, 40, '\P{^isopenpunctuation}', ""); +Expect(0, 39, '\p{isopenpunctuation}', ""); +Expect(1, 39, '\p{^isopenpunctuation}', ""); +Expect(1, 39, '\P{isopenpunctuation}', ""); +Expect(0, 39, '\P{^isopenpunctuation}', ""); +Expect(1, 40, '\p{ Is_openpunctuation}', ""); +Expect(0, 40, '\p{^ Is_openpunctuation}', ""); +Expect(0, 40, '\P{ Is_openpunctuation}', ""); +Expect(1, 40, '\P{^ Is_openpunctuation}', ""); +Expect(0, 39, '\p{ Is_openpunctuation}', ""); +Expect(1, 39, '\p{^ Is_openpunctuation}', ""); +Expect(1, 39, '\P{ Is_openpunctuation}', ""); +Expect(0, 39, '\P{^ Is_openpunctuation}', ""); +Error('\p{Ps:=}'); +Error('\P{Ps:=}'); +Expect(1, 40, '\p{ps}', ""); +Expect(0, 40, '\p{^ps}', ""); +Expect(0, 40, '\P{ps}', ""); +Expect(1, 40, '\P{^ps}', ""); +Expect(0, 39, '\p{ps}', ""); +Expect(1, 39, '\p{^ps}', ""); +Expect(1, 39, '\P{ps}', ""); +Expect(0, 39, '\P{^ps}', ""); +Expect(1, 40, '\p{ Ps}', ""); +Expect(0, 40, '\p{^ Ps}', ""); +Expect(0, 40, '\P{ Ps}', ""); +Expect(1, 40, '\P{^ Ps}', ""); +Expect(0, 39, '\p{ Ps}', ""); +Expect(1, 39, '\p{^ Ps}', ""); +Expect(1, 39, '\P{ Ps}', ""); +Expect(0, 39, '\P{^ Ps}', ""); +Error('\p{ Is Ps:=}'); +Error('\P{ Is Ps:=}'); +Expect(1, 40, '\p{isps}', ""); +Expect(0, 40, '\p{^isps}', ""); +Expect(0, 40, '\P{isps}', ""); +Expect(1, 40, '\P{^isps}', ""); +Expect(0, 39, '\p{isps}', ""); +Expect(1, 39, '\p{^isps}', ""); +Expect(1, 39, '\P{isps}', ""); +Expect(0, 39, '\P{^isps}', ""); +Expect(1, 40, '\p{_Is ps}', ""); +Expect(0, 40, '\p{^_Is ps}', ""); +Expect(0, 40, '\P{_Is ps}', ""); +Expect(1, 40, '\P{^_Is ps}', ""); +Expect(0, 39, '\p{_Is ps}', ""); +Expect(1, 39, '\p{^_Is ps}', ""); +Expect(1, 39, '\P{_Is ps}', ""); +Expect(0, 39, '\P{^_Is ps}', ""); +Error('\p{ Hangul/a/}'); +Error('\P{ Hangul/a/}'); +Expect(1, 4441, '\p{hangul}', ""); +Expect(0, 4441, '\p{^hangul}', ""); +Expect(0, 4441, '\P{hangul}', ""); +Expect(1, 4441, '\P{^hangul}', ""); +Expect(0, 4351, '\p{hangul}', ""); +Expect(1, 4351, '\p{^hangul}', ""); +Expect(1, 4351, '\P{hangul}', ""); +Expect(0, 4351, '\P{^hangul}', ""); +Expect(1, 4441, '\p{- Hangul}', ""); +Expect(0, 4441, '\p{^- Hangul}', ""); +Expect(0, 4441, '\P{- Hangul}', ""); +Expect(1, 4441, '\P{^- Hangul}', ""); +Expect(0, 4351, '\p{- Hangul}', ""); +Expect(1, 4351, '\p{^- Hangul}', ""); +Expect(1, 4351, '\P{- Hangul}', ""); +Expect(0, 4351, '\P{^- Hangul}', ""); +Error('\p{ IS:=Hangul}'); +Error('\P{ IS:=Hangul}'); +Expect(1, 4441, '\p{ishangul}', ""); +Expect(0, 4441, '\p{^ishangul}', ""); +Expect(0, 4441, '\P{ishangul}', ""); +Expect(1, 4441, '\P{^ishangul}', ""); +Expect(0, 4351, '\p{ishangul}', ""); +Expect(1, 4351, '\p{^ishangul}', ""); +Expect(1, 4351, '\P{ishangul}', ""); +Expect(0, 4351, '\P{^ishangul}', ""); +Expect(1, 4441, '\p{_-IS-Hangul}', ""); +Expect(0, 4441, '\p{^_-IS-Hangul}', ""); +Expect(0, 4441, '\P{_-IS-Hangul}', ""); +Expect(1, 4441, '\P{^_-IS-Hangul}', ""); +Expect(0, 4351, '\p{_-IS-Hangul}', ""); +Expect(1, 4351, '\p{^_-IS-Hangul}', ""); +Expect(1, 4351, '\P{_-IS-Hangul}', ""); +Expect(0, 4351, '\P{^_-IS-Hangul}', ""); +Error('\p{:=hang}'); +Error('\P{:=hang}'); +Expect(1, 4441, '\p{hang}', ""); +Expect(0, 4441, '\p{^hang}', ""); +Expect(0, 4441, '\P{hang}', ""); +Expect(1, 4441, '\P{^hang}', ""); +Expect(0, 4351, '\p{hang}', ""); +Expect(1, 4351, '\p{^hang}', ""); +Expect(1, 4351, '\P{hang}', ""); +Expect(0, 4351, '\P{^hang}', ""); +Expect(1, 4441, '\p{ Hang}', ""); +Expect(0, 4441, '\p{^ Hang}', ""); +Expect(0, 4441, '\P{ Hang}', ""); +Expect(1, 4441, '\P{^ Hang}', ""); +Expect(0, 4351, '\p{ Hang}', ""); +Expect(1, 4351, '\p{^ Hang}', ""); +Expect(1, 4351, '\P{ Hang}', ""); +Expect(0, 4351, '\P{^ Hang}', ""); +Error('\p{ is HANG/a/}'); +Error('\P{ is HANG/a/}'); +Expect(1, 4441, '\p{ishang}', ""); +Expect(0, 4441, '\p{^ishang}', ""); +Expect(0, 4441, '\P{ishang}', ""); +Expect(1, 4441, '\P{^ishang}', ""); +Expect(0, 4351, '\p{ishang}', ""); +Expect(1, 4351, '\p{^ishang}', ""); +Expect(1, 4351, '\P{ishang}', ""); +Expect(0, 4351, '\P{^ishang}', ""); +Expect(1, 4441, '\p{-is hang}', ""); +Expect(0, 4441, '\p{^-is hang}', ""); +Expect(0, 4441, '\P{-is hang}', ""); +Expect(1, 4441, '\P{^-is hang}', ""); +Expect(0, 4351, '\p{-is hang}', ""); +Expect(1, 4351, '\p{^-is hang}', ""); +Expect(1, 4351, '\P{-is hang}', ""); +Expect(0, 4351, '\P{^-is hang}', ""); +Error('\p{_Cypriot:=}'); +Error('\P{_Cypriot:=}'); +Expect(1, 67589, '\p{cypriot}', ""); +Expect(0, 67589, '\p{^cypriot}', ""); +Expect(0, 67589, '\P{cypriot}', ""); +Expect(1, 67589, '\P{^cypriot}', ""); +Expect(0, 67583, '\p{cypriot}', ""); +Expect(1, 67583, '\p{^cypriot}', ""); +Expect(1, 67583, '\P{cypriot}', ""); +Expect(0, 67583, '\P{^cypriot}', ""); +Expect(1, 67589, '\p{ Cypriot}', ""); +Expect(0, 67589, '\p{^ Cypriot}', ""); +Expect(0, 67589, '\P{ Cypriot}', ""); +Expect(1, 67589, '\P{^ Cypriot}', ""); +Expect(0, 67583, '\p{ Cypriot}', ""); +Expect(1, 67583, '\p{^ Cypriot}', ""); +Expect(1, 67583, '\P{ Cypriot}', ""); +Expect(0, 67583, '\P{^ Cypriot}', ""); +Error('\p{_:=is-CYPRIOT}'); +Error('\P{_:=is-CYPRIOT}'); +Expect(1, 67589, '\p{iscypriot}', ""); +Expect(0, 67589, '\p{^iscypriot}', ""); +Expect(0, 67589, '\P{iscypriot}', ""); +Expect(1, 67589, '\P{^iscypriot}', ""); +Expect(0, 67583, '\p{iscypriot}', ""); +Expect(1, 67583, '\p{^iscypriot}', ""); +Expect(1, 67583, '\P{iscypriot}', ""); +Expect(0, 67583, '\P{^iscypriot}', ""); +Expect(1, 67589, '\p{ IS Cypriot}', ""); +Expect(0, 67589, '\p{^ IS Cypriot}', ""); +Expect(0, 67589, '\P{ IS Cypriot}', ""); +Expect(1, 67589, '\P{^ IS Cypriot}', ""); +Expect(0, 67583, '\p{ IS Cypriot}', ""); +Expect(1, 67583, '\p{^ IS Cypriot}', ""); +Expect(1, 67583, '\P{ IS Cypriot}', ""); +Expect(0, 67583, '\P{^ IS Cypriot}', ""); +Error('\p{ -Cprt/a/}'); +Error('\P{ -Cprt/a/}'); +Expect(1, 67589, '\p{cprt}', ""); +Expect(0, 67589, '\p{^cprt}', ""); +Expect(0, 67589, '\P{cprt}', ""); +Expect(1, 67589, '\P{^cprt}', ""); +Expect(0, 67583, '\p{cprt}', ""); +Expect(1, 67583, '\p{^cprt}', ""); +Expect(1, 67583, '\P{cprt}', ""); +Expect(0, 67583, '\P{^cprt}', ""); +Expect(1, 67589, '\p{ cprt}', ""); +Expect(0, 67589, '\p{^ cprt}', ""); +Expect(0, 67589, '\P{ cprt}', ""); +Expect(1, 67589, '\P{^ cprt}', ""); +Expect(0, 67583, '\p{ cprt}', ""); +Expect(1, 67583, '\p{^ cprt}', ""); +Expect(1, 67583, '\P{ cprt}', ""); +Expect(0, 67583, '\P{^ cprt}', ""); +Error('\p{:=Is-Cprt}'); +Error('\P{:=Is-Cprt}'); +Expect(1, 67589, '\p{iscprt}', ""); +Expect(0, 67589, '\p{^iscprt}', ""); +Expect(0, 67589, '\P{iscprt}', ""); +Expect(1, 67589, '\P{^iscprt}', ""); +Expect(0, 67583, '\p{iscprt}', ""); +Expect(1, 67583, '\p{^iscprt}', ""); +Expect(1, 67583, '\P{iscprt}', ""); +Expect(0, 67583, '\P{^iscprt}', ""); +Expect(1, 67589, '\p{ IScprt}', ""); +Expect(0, 67589, '\p{^ IScprt}', ""); +Expect(0, 67589, '\P{ IScprt}', ""); +Expect(1, 67589, '\P{^ IScprt}', ""); +Expect(0, 67583, '\p{ IScprt}', ""); +Expect(1, 67583, '\p{^ IScprt}', ""); +Expect(1, 67583, '\P{ IScprt}', ""); +Expect(0, 67583, '\P{^ IScprt}', ""); +Error('\p{_ byzantine_musical-symbols/a/}'); +Error('\P{_ byzantine_musical-symbols/a/}'); +Expect(1, 119039, '\p{byzantinemusicalsymbols}', ""); +Expect(0, 119039, '\p{^byzantinemusicalsymbols}', ""); +Expect(0, 119039, '\P{byzantinemusicalsymbols}', ""); +Expect(1, 119039, '\P{^byzantinemusicalsymbols}', ""); +Expect(0, 118783, '\p{byzantinemusicalsymbols}', ""); +Expect(1, 118783, '\p{^byzantinemusicalsymbols}', ""); +Expect(1, 118783, '\P{byzantinemusicalsymbols}', ""); +Expect(0, 118783, '\P{^byzantinemusicalsymbols}', ""); +Expect(1, 119039, '\p{ byzantine Musical Symbols}', ""); +Expect(0, 119039, '\p{^ byzantine Musical Symbols}', ""); +Expect(0, 119039, '\P{ byzantine Musical Symbols}', ""); +Expect(1, 119039, '\P{^ byzantine Musical Symbols}', ""); +Expect(0, 118783, '\p{ byzantine Musical Symbols}', ""); +Expect(1, 118783, '\p{^ byzantine Musical Symbols}', ""); +Expect(1, 118783, '\P{ byzantine Musical Symbols}', ""); +Expect(0, 118783, '\P{^ byzantine Musical Symbols}', ""); +Error('\p{:=__Is Byzantine MUSICAL Symbols}'); +Error('\P{:=__Is Byzantine MUSICAL Symbols}'); +Expect(1, 119039, '\p{isbyzantinemusicalsymbols}', ""); +Expect(0, 119039, '\p{^isbyzantinemusicalsymbols}', ""); +Expect(0, 119039, '\P{isbyzantinemusicalsymbols}', ""); +Expect(1, 119039, '\P{^isbyzantinemusicalsymbols}', ""); +Expect(0, 118783, '\p{isbyzantinemusicalsymbols}', ""); +Expect(1, 118783, '\p{^isbyzantinemusicalsymbols}', ""); +Expect(1, 118783, '\P{isbyzantinemusicalsymbols}', ""); +Expect(0, 118783, '\P{^isbyzantinemusicalsymbols}', ""); +Expect(1, 119039, '\p{ Is BYZANTINE Musical Symbols}', ""); +Expect(0, 119039, '\p{^ Is BYZANTINE Musical Symbols}', ""); +Expect(0, 119039, '\P{ Is BYZANTINE Musical Symbols}', ""); +Expect(1, 119039, '\P{^ Is BYZANTINE Musical Symbols}', ""); +Expect(0, 118783, '\p{ Is BYZANTINE Musical Symbols}', ""); +Expect(1, 118783, '\p{^ Is BYZANTINE Musical Symbols}', ""); +Expect(1, 118783, '\P{ Is BYZANTINE Musical Symbols}', ""); +Expect(0, 118783, '\P{^ Is BYZANTINE Musical Symbols}', ""); +Error('\p{ _in:=Byzantine_musical_symbols}'); +Error('\P{ _in:=Byzantine_musical_symbols}'); +Expect(1, 119039, '\p{inbyzantinemusicalsymbols}', ""); +Expect(0, 119039, '\p{^inbyzantinemusicalsymbols}', ""); +Expect(0, 119039, '\P{inbyzantinemusicalsymbols}', ""); +Expect(1, 119039, '\P{^inbyzantinemusicalsymbols}', ""); +Expect(0, 118783, '\p{inbyzantinemusicalsymbols}', ""); +Expect(1, 118783, '\p{^inbyzantinemusicalsymbols}', ""); +Expect(1, 118783, '\P{inbyzantinemusicalsymbols}', ""); +Expect(0, 118783, '\P{^inbyzantinemusicalsymbols}', ""); +Expect(1, 119039, '\p{--in Byzantine_MUSICAL Symbols}', ""); +Expect(0, 119039, '\p{^--in Byzantine_MUSICAL Symbols}', ""); +Expect(0, 119039, '\P{--in Byzantine_MUSICAL Symbols}', ""); +Expect(1, 119039, '\P{^--in Byzantine_MUSICAL Symbols}', ""); +Expect(0, 118783, '\p{--in Byzantine_MUSICAL Symbols}', ""); +Expect(1, 118783, '\p{^--in Byzantine_MUSICAL Symbols}', ""); +Expect(1, 118783, '\P{--in Byzantine_MUSICAL Symbols}', ""); +Expect(0, 118783, '\P{^--in Byzantine_MUSICAL Symbols}', ""); +Error('\p{-PosixUpper/a/}'); +Error('\P{-PosixUpper/a/}'); +Expect(1, 90, '\p{posixupper}', ""); +Expect(0, 90, '\p{^posixupper}', ""); +Expect(0, 90, '\P{posixupper}', ""); +Expect(1, 90, '\P{^posixupper}', ""); +Expect(0, 64, '\p{posixupper}', ""); +Expect(1, 64, '\p{^posixupper}', ""); +Expect(1, 64, '\P{posixupper}', ""); +Expect(0, 64, '\P{^posixupper}', ""); +Expect(1, 90, '\p{_-posixupper}', ""); +Expect(0, 90, '\p{^_-posixupper}', ""); +Expect(0, 90, '\P{_-posixupper}', ""); +Expect(1, 90, '\P{^_-posixupper}', ""); +Expect(0, 64, '\p{_-posixupper}', ""); +Expect(1, 64, '\p{^_-posixupper}', ""); +Expect(1, 64, '\P{_-posixupper}', ""); +Expect(0, 64, '\P{^_-posixupper}', ""); +Error('\p{ Is_posixupper/a/}'); +Error('\P{ Is_posixupper/a/}'); +Expect(1, 90, '\p{isposixupper}', ""); +Expect(0, 90, '\p{^isposixupper}', ""); +Expect(0, 90, '\P{isposixupper}', ""); +Expect(1, 90, '\P{^isposixupper}', ""); +Expect(0, 64, '\p{isposixupper}', ""); +Expect(1, 64, '\p{^isposixupper}', ""); +Expect(1, 64, '\P{isposixupper}', ""); +Expect(0, 64, '\P{^isposixupper}', ""); +Expect(1, 90, '\p{- IS POSIXUPPER}', ""); +Expect(0, 90, '\p{^- IS POSIXUPPER}', ""); +Expect(0, 90, '\P{- IS POSIXUPPER}', ""); +Expect(1, 90, '\P{^- IS POSIXUPPER}', ""); +Expect(0, 64, '\p{- IS POSIXUPPER}', ""); +Expect(1, 64, '\p{^- IS POSIXUPPER}', ""); +Expect(1, 64, '\P{- IS POSIXUPPER}', ""); +Expect(0, 64, '\P{^- IS POSIXUPPER}', ""); +Error('\p{ /a/In_armenian}'); +Error('\P{ /a/In_armenian}'); +Expect(1, 1423, '\p{inarmenian}', ""); +Expect(0, 1423, '\p{^inarmenian}', ""); +Expect(0, 1423, '\P{inarmenian}', ""); +Expect(1, 1423, '\P{^inarmenian}', ""); +Expect(0, 1327, '\p{inarmenian}', ""); +Expect(1, 1327, '\p{^inarmenian}', ""); +Expect(1, 1327, '\P{inarmenian}', ""); +Expect(0, 1327, '\P{^inarmenian}', ""); +Expect(1, 1423, '\p{--in Armenian}', ""); +Expect(0, 1423, '\p{^--in Armenian}', ""); +Expect(0, 1423, '\P{--in Armenian}', ""); +Expect(1, 1423, '\P{^--in Armenian}', ""); +Expect(0, 1327, '\p{--in Armenian}', ""); +Expect(1, 1327, '\p{^--in Armenian}', ""); +Expect(1, 1327, '\P{--in Armenian}', ""); +Expect(0, 1327, '\P{^--in Armenian}', ""); +Error('\p{ -PosixAlpha/a/}'); +Error('\P{ -PosixAlpha/a/}'); +Expect(1, 90, '\p{posixalpha}', ""); +Expect(0, 90, '\p{^posixalpha}', ""); +Expect(0, 90, '\P{posixalpha}', ""); +Expect(1, 90, '\P{^posixalpha}', ""); +Expect(0, 64, '\p{posixalpha}', ""); +Expect(1, 64, '\p{^posixalpha}', ""); +Expect(1, 64, '\P{posixalpha}', ""); +Expect(0, 64, '\P{^posixalpha}', ""); +Expect(1, 90, '\p{_ posixalpha}', ""); +Expect(0, 90, '\p{^_ posixalpha}', ""); +Expect(0, 90, '\P{_ posixalpha}', ""); +Expect(1, 90, '\P{^_ posixalpha}', ""); +Expect(0, 64, '\p{_ posixalpha}', ""); +Expect(1, 64, '\p{^_ posixalpha}', ""); +Expect(1, 64, '\P{_ posixalpha}', ""); +Expect(0, 64, '\P{^_ posixalpha}', ""); +Error('\p{__Is POSIXALPHA/a/}'); +Error('\P{__Is POSIXALPHA/a/}'); +Expect(1, 90, '\p{isposixalpha}', ""); +Expect(0, 90, '\p{^isposixalpha}', ""); +Expect(0, 90, '\P{isposixalpha}', ""); +Expect(1, 90, '\P{^isposixalpha}', ""); +Expect(0, 64, '\p{isposixalpha}', ""); +Expect(1, 64, '\p{^isposixalpha}', ""); +Expect(1, 64, '\P{isposixalpha}', ""); +Expect(0, 64, '\P{^isposixalpha}', ""); +Expect(1, 90, '\p{ -Is_PosixAlpha}', ""); +Expect(0, 90, '\p{^ -Is_PosixAlpha}', ""); +Expect(0, 90, '\P{ -Is_PosixAlpha}', ""); +Expect(1, 90, '\P{^ -Is_PosixAlpha}', ""); +Expect(0, 64, '\p{ -Is_PosixAlpha}', ""); +Expect(1, 64, '\p{^ -Is_PosixAlpha}', ""); +Expect(1, 64, '\P{ -Is_PosixAlpha}', ""); +Expect(0, 64, '\P{^ -Is_PosixAlpha}', ""); +Error('\p{:= Paragraph_SEPARATOR}'); +Error('\P{:= Paragraph_SEPARATOR}'); +Expect(1, 8233, '\p{paragraphseparator}', ""); +Expect(0, 8233, '\p{^paragraphseparator}', ""); +Expect(0, 8233, '\P{paragraphseparator}', ""); +Expect(1, 8233, '\P{^paragraphseparator}', ""); +Expect(0, 8232, '\p{paragraphseparator}', ""); +Expect(1, 8232, '\p{^paragraphseparator}', ""); +Expect(1, 8232, '\P{paragraphseparator}', ""); +Expect(0, 8232, '\P{^paragraphseparator}', ""); +Expect(1, 8233, '\p{__paragraph_SEPARATOR}', ""); +Expect(0, 8233, '\p{^__paragraph_SEPARATOR}', ""); +Expect(0, 8233, '\P{__paragraph_SEPARATOR}', ""); +Expect(1, 8233, '\P{^__paragraph_SEPARATOR}', ""); +Expect(0, 8232, '\p{__paragraph_SEPARATOR}', ""); +Expect(1, 8232, '\p{^__paragraph_SEPARATOR}', ""); +Expect(1, 8232, '\P{__paragraph_SEPARATOR}', ""); +Expect(0, 8232, '\P{^__paragraph_SEPARATOR}', ""); +Error('\p{:=is-Paragraph separator}'); +Error('\P{:=is-Paragraph separator}'); +Expect(1, 8233, '\p{isparagraphseparator}', ""); +Expect(0, 8233, '\p{^isparagraphseparator}', ""); +Expect(0, 8233, '\P{isparagraphseparator}', ""); +Expect(1, 8233, '\P{^isparagraphseparator}', ""); +Expect(0, 8232, '\p{isparagraphseparator}', ""); +Expect(1, 8232, '\p{^isparagraphseparator}', ""); +Expect(1, 8232, '\P{isparagraphseparator}', ""); +Expect(0, 8232, '\P{^isparagraphseparator}', ""); +Expect(1, 8233, '\p{ is-paragraph Separator}', ""); +Expect(0, 8233, '\p{^ is-paragraph Separator}', ""); +Expect(0, 8233, '\P{ is-paragraph Separator}', ""); +Expect(1, 8233, '\P{^ is-paragraph Separator}', ""); +Expect(0, 8232, '\p{ is-paragraph Separator}', ""); +Expect(1, 8232, '\p{^ is-paragraph Separator}', ""); +Expect(1, 8232, '\P{ is-paragraph Separator}', ""); +Expect(0, 8232, '\P{^ is-paragraph Separator}', ""); +Error('\p{ /a/ZP}'); +Error('\P{ /a/ZP}'); +Expect(1, 8233, '\p{zp}', ""); +Expect(0, 8233, '\p{^zp}', ""); +Expect(0, 8233, '\P{zp}', ""); +Expect(1, 8233, '\P{^zp}', ""); +Expect(0, 8232, '\p{zp}', ""); +Expect(1, 8232, '\p{^zp}', ""); +Expect(1, 8232, '\P{zp}', ""); +Expect(0, 8232, '\P{^zp}', ""); +Expect(1, 8233, '\p{- zp}', ""); +Expect(0, 8233, '\p{^- zp}', ""); +Expect(0, 8233, '\P{- zp}', ""); +Expect(1, 8233, '\P{^- zp}', ""); +Expect(0, 8232, '\p{- zp}', ""); +Expect(1, 8232, '\p{^- zp}', ""); +Expect(1, 8232, '\P{- zp}', ""); +Expect(0, 8232, '\P{^- zp}', ""); +Error('\p{_:=is-Zp}'); +Error('\P{_:=is-Zp}'); +Expect(1, 8233, '\p{iszp}', ""); +Expect(0, 8233, '\p{^iszp}', ""); +Expect(0, 8233, '\P{iszp}', ""); +Expect(1, 8233, '\P{^iszp}', ""); +Expect(0, 8232, '\p{iszp}', ""); +Expect(1, 8232, '\p{^iszp}', ""); +Expect(1, 8232, '\P{iszp}', ""); +Expect(0, 8232, '\P{^iszp}', ""); +Expect(1, 8233, '\p{_ IS Zp}', ""); +Expect(0, 8233, '\p{^_ IS Zp}', ""); +Expect(0, 8233, '\P{_ IS Zp}', ""); +Expect(1, 8233, '\P{^_ IS Zp}', ""); +Expect(0, 8232, '\p{_ IS Zp}', ""); +Expect(1, 8232, '\p{^_ IS Zp}', ""); +Expect(1, 8232, '\P{_ IS Zp}', ""); +Expect(0, 8232, '\P{^_ IS Zp}', ""); +Error('\p{ phagsPa/a/}'); +Error('\P{ phagsPa/a/}'); +Expect(1, 43127, '\p{phagspa}', ""); +Expect(0, 43127, '\p{^phagspa}', ""); +Expect(0, 43127, '\P{phagspa}', ""); +Expect(1, 43127, '\P{^phagspa}', ""); +Expect(0, 43071, '\p{phagspa}', ""); +Expect(1, 43071, '\p{^phagspa}', ""); +Expect(1, 43071, '\P{phagspa}', ""); +Expect(0, 43071, '\P{^phagspa}', ""); +Expect(1, 43127, '\p{ PhagsPa}', ""); +Expect(0, 43127, '\p{^ PhagsPa}', ""); +Expect(0, 43127, '\P{ PhagsPa}', ""); +Expect(1, 43127, '\P{^ PhagsPa}', ""); +Expect(0, 43071, '\p{ PhagsPa}', ""); +Expect(1, 43071, '\p{^ PhagsPa}', ""); +Expect(1, 43071, '\P{ PhagsPa}', ""); +Expect(0, 43071, '\P{^ PhagsPa}', ""); +Error('\p{-_IsPhags:=PA}'); +Error('\P{-_IsPhags:=PA}'); +Expect(1, 43127, '\p{isphagspa}', ""); +Expect(0, 43127, '\p{^isphagspa}', ""); +Expect(0, 43127, '\P{isphagspa}', ""); +Expect(1, 43127, '\P{^isphagspa}', ""); +Expect(0, 43071, '\p{isphagspa}', ""); +Expect(1, 43071, '\p{^isphagspa}', ""); +Expect(1, 43071, '\P{isphagspa}', ""); +Expect(0, 43071, '\P{^isphagspa}', ""); +Expect(1, 43127, '\p{ _is PHAGS Pa}', ""); +Expect(0, 43127, '\p{^ _is PHAGS Pa}', ""); +Expect(0, 43127, '\P{ _is PHAGS Pa}', ""); +Expect(1, 43127, '\P{^ _is PHAGS Pa}', ""); +Expect(0, 43071, '\p{ _is PHAGS Pa}', ""); +Expect(1, 43071, '\p{^ _is PHAGS Pa}', ""); +Expect(1, 43071, '\P{ _is PHAGS Pa}', ""); +Expect(0, 43071, '\P{^ _is PHAGS Pa}', ""); +Error('\p{/a/Phag}'); +Error('\P{/a/Phag}'); +Expect(1, 43127, '\p{phag}', ""); +Expect(0, 43127, '\p{^phag}', ""); +Expect(0, 43127, '\P{phag}', ""); +Expect(1, 43127, '\P{^phag}', ""); +Expect(0, 43071, '\p{phag}', ""); +Expect(1, 43071, '\p{^phag}', ""); +Expect(1, 43071, '\P{phag}', ""); +Expect(0, 43071, '\P{^phag}', ""); +Expect(1, 43127, '\p{ PHAG}', ""); +Expect(0, 43127, '\p{^ PHAG}', ""); +Expect(0, 43127, '\P{ PHAG}', ""); +Expect(1, 43127, '\P{^ PHAG}', ""); +Expect(0, 43071, '\p{ PHAG}', ""); +Expect(1, 43071, '\p{^ PHAG}', ""); +Expect(1, 43071, '\P{ PHAG}', ""); +Expect(0, 43071, '\P{^ PHAG}', ""); +Error('\p{/a/--is_PHAG}'); +Error('\P{/a/--is_PHAG}'); +Expect(1, 43127, '\p{isphag}', ""); +Expect(0, 43127, '\p{^isphag}', ""); +Expect(0, 43127, '\P{isphag}', ""); +Expect(1, 43127, '\P{^isphag}', ""); +Expect(0, 43071, '\p{isphag}', ""); +Expect(1, 43071, '\p{^isphag}', ""); +Expect(1, 43071, '\P{isphag}', ""); +Expect(0, 43071, '\P{^isphag}', ""); +Expect(1, 43127, '\p{ _ISPhag}', ""); +Expect(0, 43127, '\p{^ _ISPhag}', ""); +Expect(0, 43127, '\P{ _ISPhag}', ""); +Expect(1, 43127, '\P{^ _ISPhag}', ""); +Expect(0, 43071, '\p{ _ISPhag}', ""); +Expect(1, 43071, '\p{^ _ISPhag}', ""); +Expect(1, 43071, '\P{ _ISPhag}', ""); +Expect(0, 43071, '\P{^ _ISPhag}', ""); +Error('\p{/a/LETTERNumber}'); +Error('\P{/a/LETTERNumber}'); +Expect(1, 5872, '\p{letternumber}', ""); +Expect(0, 5872, '\p{^letternumber}', ""); +Expect(0, 5872, '\P{letternumber}', ""); +Expect(1, 5872, '\P{^letternumber}', ""); +Expect(0, 5869, '\p{letternumber}', ""); +Expect(1, 5869, '\p{^letternumber}', ""); +Expect(1, 5869, '\P{letternumber}', ""); +Expect(0, 5869, '\P{^letternumber}', ""); +Expect(1, 5872, '\p{_LETTER_number}', ""); +Expect(0, 5872, '\p{^_LETTER_number}', ""); +Expect(0, 5872, '\P{_LETTER_number}', ""); +Expect(1, 5872, '\P{^_LETTER_number}', ""); +Expect(0, 5869, '\p{_LETTER_number}', ""); +Expect(1, 5869, '\p{^_LETTER_number}', ""); +Expect(1, 5869, '\P{_LETTER_number}', ""); +Expect(0, 5869, '\P{^_LETTER_number}', ""); +Error('\p{/a/- IS_letter NUMBER}'); +Error('\P{/a/- IS_letter NUMBER}'); +Expect(1, 5872, '\p{isletternumber}', ""); +Expect(0, 5872, '\p{^isletternumber}', ""); +Expect(0, 5872, '\P{isletternumber}', ""); +Expect(1, 5872, '\P{^isletternumber}', ""); +Expect(0, 5869, '\p{isletternumber}', ""); +Expect(1, 5869, '\p{^isletternumber}', ""); +Expect(1, 5869, '\P{isletternumber}', ""); +Expect(0, 5869, '\P{^isletternumber}', ""); +Expect(1, 5872, '\p{- ISLETTER_Number}', ""); +Expect(0, 5872, '\p{^- ISLETTER_Number}', ""); +Expect(0, 5872, '\P{- ISLETTER_Number}', ""); +Expect(1, 5872, '\P{^- ISLETTER_Number}', ""); +Expect(0, 5869, '\p{- ISLETTER_Number}', ""); +Expect(1, 5869, '\p{^- ISLETTER_Number}', ""); +Expect(1, 5869, '\P{- ISLETTER_Number}', ""); +Expect(0, 5869, '\P{^- ISLETTER_Number}', ""); +Error('\p{:= _Nl}'); +Error('\P{:= _Nl}'); +Expect(1, 5872, '\p{nl}', ""); +Expect(0, 5872, '\p{^nl}', ""); +Expect(0, 5872, '\P{nl}', ""); +Expect(1, 5872, '\P{^nl}', ""); +Expect(0, 5869, '\p{nl}', ""); +Expect(1, 5869, '\p{^nl}', ""); +Expect(1, 5869, '\P{nl}', ""); +Expect(0, 5869, '\P{^nl}', ""); +Expect(1, 5872, '\p{ Nl}', ""); +Expect(0, 5872, '\p{^ Nl}', ""); +Expect(0, 5872, '\P{ Nl}', ""); +Expect(1, 5872, '\P{^ Nl}', ""); +Expect(0, 5869, '\p{ Nl}', ""); +Expect(1, 5869, '\p{^ Nl}', ""); +Expect(1, 5869, '\P{ Nl}', ""); +Expect(0, 5869, '\P{^ Nl}', ""); +Error('\p{--Is Nl:=}'); +Error('\P{--Is Nl:=}'); +Expect(1, 5872, '\p{isnl}', ""); +Expect(0, 5872, '\p{^isnl}', ""); +Expect(0, 5872, '\P{isnl}', ""); +Expect(1, 5872, '\P{^isnl}', ""); +Expect(0, 5869, '\p{isnl}', ""); +Expect(1, 5869, '\p{^isnl}', ""); +Expect(1, 5869, '\P{isnl}', ""); +Expect(0, 5869, '\P{^isnl}', ""); +Expect(1, 5872, '\p{ Is_NL}', ""); +Expect(0, 5872, '\p{^ Is_NL}', ""); +Expect(0, 5872, '\P{ Is_NL}', ""); +Expect(1, 5872, '\P{^ Is_NL}', ""); +Expect(0, 5869, '\p{ Is_NL}', ""); +Expect(1, 5869, '\p{^ Is_NL}', ""); +Expect(1, 5869, '\P{ Is_NL}', ""); +Expect(0, 5869, '\P{^ Is_NL}', ""); +Error('\p{_ NUMBER:=Forms}'); +Error('\P{_ NUMBER:=Forms}'); +Expect(1, 8591, '\p{numberforms}', ""); +Expect(0, 8591, '\p{^numberforms}', ""); +Expect(0, 8591, '\P{numberforms}', ""); +Expect(1, 8591, '\P{^numberforms}', ""); +Expect(0, 8527, '\p{numberforms}', ""); +Expect(1, 8527, '\p{^numberforms}', ""); +Expect(1, 8527, '\P{numberforms}', ""); +Expect(0, 8527, '\P{^numberforms}', ""); +Expect(1, 8591, '\p{ Number FORMS}', ""); +Expect(0, 8591, '\p{^ Number FORMS}', ""); +Expect(0, 8591, '\P{ Number FORMS}', ""); +Expect(1, 8591, '\P{^ Number FORMS}', ""); +Expect(0, 8527, '\p{ Number FORMS}', ""); +Expect(1, 8527, '\p{^ Number FORMS}', ""); +Expect(1, 8527, '\P{ Number FORMS}', ""); +Expect(0, 8527, '\P{^ Number FORMS}', ""); +Error('\p{/a/ -Is Number Forms}'); +Error('\P{/a/ -Is Number Forms}'); +Expect(1, 8591, '\p{isnumberforms}', ""); +Expect(0, 8591, '\p{^isnumberforms}', ""); +Expect(0, 8591, '\P{isnumberforms}', ""); +Expect(1, 8591, '\P{^isnumberforms}', ""); +Expect(0, 8527, '\p{isnumberforms}', ""); +Expect(1, 8527, '\p{^isnumberforms}', ""); +Expect(1, 8527, '\P{isnumberforms}', ""); +Expect(0, 8527, '\P{^isnumberforms}', ""); +Expect(1, 8591, '\p{ Is NUMBER forms}', ""); +Expect(0, 8591, '\p{^ Is NUMBER forms}', ""); +Expect(0, 8591, '\P{ Is NUMBER forms}', ""); +Expect(1, 8591, '\P{^ Is NUMBER forms}', ""); +Expect(0, 8527, '\p{ Is NUMBER forms}', ""); +Expect(1, 8527, '\p{^ Is NUMBER forms}', ""); +Expect(1, 8527, '\P{ Is NUMBER forms}', ""); +Expect(0, 8527, '\P{^ Is NUMBER forms}', ""); +Error('\p{:=-In NUMBERForms}'); +Error('\P{:=-In NUMBERForms}'); +Expect(1, 8591, '\p{innumberforms}', ""); +Expect(0, 8591, '\p{^innumberforms}', ""); +Expect(0, 8591, '\P{innumberforms}', ""); +Expect(1, 8591, '\P{^innumberforms}', ""); +Expect(0, 8527, '\p{innumberforms}', ""); +Expect(1, 8527, '\p{^innumberforms}', ""); +Expect(1, 8527, '\P{innumberforms}', ""); +Expect(0, 8527, '\P{^innumberforms}', ""); +Expect(1, 8591, '\p{_ in Number-Forms}', ""); +Expect(0, 8591, '\p{^_ in Number-Forms}', ""); +Expect(0, 8591, '\P{_ in Number-Forms}', ""); +Expect(1, 8591, '\P{^_ in Number-Forms}', ""); +Expect(0, 8527, '\p{_ in Number-Forms}', ""); +Expect(1, 8527, '\p{^_ in Number-Forms}', ""); +Expect(1, 8527, '\P{_ in Number-Forms}', ""); +Expect(0, 8527, '\P{^_ in Number-Forms}', ""); +Error('\p{ /a/alnum}'); +Error('\P{ /a/alnum}'); +Expect(1, 57, '\p{alnum}', ""); +Expect(0, 57, '\p{^alnum}', ""); +Expect(0, 57, '\P{alnum}', ""); +Expect(1, 57, '\P{^alnum}', ""); +Expect(0, 47, '\p{alnum}', ""); +Expect(1, 47, '\p{^alnum}', ""); +Expect(1, 47, '\P{alnum}', ""); +Expect(0, 47, '\P{^alnum}', ""); +Expect(1, 57, '\p{ ALNUM}', ""); +Expect(0, 57, '\p{^ ALNUM}', ""); +Expect(0, 57, '\P{ ALNUM}', ""); +Expect(1, 57, '\P{^ ALNUM}', ""); +Expect(0, 47, '\p{ ALNUM}', ""); +Expect(1, 47, '\p{^ ALNUM}', ""); +Expect(1, 47, '\P{ ALNUM}', ""); +Expect(0, 47, '\P{^ ALNUM}', ""); +Error('\p{ _Is alnum/a/}'); +Error('\P{ _Is alnum/a/}'); +Expect(1, 57, '\p{isalnum}', ""); +Expect(0, 57, '\p{^isalnum}', ""); +Expect(0, 57, '\P{isalnum}', ""); +Expect(1, 57, '\P{^isalnum}', ""); +Expect(0, 47, '\p{isalnum}', ""); +Expect(1, 47, '\p{^isalnum}', ""); +Expect(1, 47, '\P{isalnum}', ""); +Expect(0, 47, '\P{^isalnum}', ""); +Expect(1, 57, '\p{_ IS-Alnum}', ""); +Expect(0, 57, '\p{^_ IS-Alnum}', ""); +Expect(0, 57, '\P{_ IS-Alnum}', ""); +Expect(1, 57, '\P{^_ IS-Alnum}', ""); +Expect(0, 47, '\p{_ IS-Alnum}', ""); +Expect(1, 47, '\p{^_ IS-Alnum}', ""); +Expect(1, 47, '\P{_ IS-Alnum}', ""); +Expect(0, 47, '\P{^_ IS-Alnum}', ""); +Error('\p{-/a/In SUNDANESE}'); +Error('\P{-/a/In SUNDANESE}'); +Expect(1, 7103, '\p{insundanese}', ""); +Expect(0, 7103, '\p{^insundanese}', ""); +Expect(0, 7103, '\P{insundanese}', ""); +Expect(1, 7103, '\P{^insundanese}', ""); +Expect(0, 7039, '\p{insundanese}', ""); +Expect(1, 7039, '\p{^insundanese}', ""); +Expect(1, 7039, '\P{insundanese}', ""); +Expect(0, 7039, '\P{^insundanese}', ""); +Expect(1, 7103, '\p{ In_sundanese}', ""); +Expect(0, 7103, '\p{^ In_sundanese}', ""); +Expect(0, 7103, '\P{ In_sundanese}', ""); +Expect(1, 7103, '\P{^ In_sundanese}', ""); +Expect(0, 7039, '\p{ In_sundanese}', ""); +Expect(1, 7039, '\p{^ In_sundanese}', ""); +Expect(1, 7039, '\P{ In_sundanese}', ""); +Expect(0, 7039, '\P{^ In_sundanese}', ""); +Error('\p{-ARABIC:=presentation_Forms-b}'); +Error('\P{-ARABIC:=presentation_Forms-b}'); +Expect(1, 65279, '\p{arabicpresentationformsb}', ""); +Expect(0, 65279, '\p{^arabicpresentationformsb}', ""); +Expect(0, 65279, '\P{arabicpresentationformsb}', ""); +Expect(1, 65279, '\P{^arabicpresentationformsb}', ""); +Expect(0, 65135, '\p{arabicpresentationformsb}', ""); +Expect(1, 65135, '\p{^arabicpresentationformsb}', ""); +Expect(1, 65135, '\P{arabicpresentationformsb}', ""); +Expect(0, 65135, '\P{^arabicpresentationformsb}', ""); +Expect(1, 65279, '\p{ Arabic PRESENTATION Forms b}', ""); +Expect(0, 65279, '\p{^ Arabic PRESENTATION Forms b}', ""); +Expect(0, 65279, '\P{ Arabic PRESENTATION Forms b}', ""); +Expect(1, 65279, '\P{^ Arabic PRESENTATION Forms b}', ""); +Expect(0, 65135, '\p{ Arabic PRESENTATION Forms b}', ""); +Expect(1, 65135, '\p{^ Arabic PRESENTATION Forms b}', ""); +Expect(1, 65135, '\P{ Arabic PRESENTATION Forms b}', ""); +Expect(0, 65135, '\P{^ Arabic PRESENTATION Forms b}', ""); +Error('\p{ /a/IS Arabic_Presentation_Forms B}'); +Error('\P{ /a/IS Arabic_Presentation_Forms B}'); +Expect(1, 65279, '\p{isarabicpresentationformsb}', ""); +Expect(0, 65279, '\p{^isarabicpresentationformsb}', ""); +Expect(0, 65279, '\P{isarabicpresentationformsb}', ""); +Expect(1, 65279, '\P{^isarabicpresentationformsb}', ""); +Expect(0, 65135, '\p{isarabicpresentationformsb}', ""); +Expect(1, 65135, '\p{^isarabicpresentationformsb}', ""); +Expect(1, 65135, '\P{isarabicpresentationformsb}', ""); +Expect(0, 65135, '\P{^isarabicpresentationformsb}', ""); +Expect(1, 65279, '\p{_Is ArabicPRESENTATION_FORMS_b}', ""); +Expect(0, 65279, '\p{^_Is ArabicPRESENTATION_FORMS_b}', ""); +Expect(0, 65279, '\P{_Is ArabicPRESENTATION_FORMS_b}', ""); +Expect(1, 65279, '\P{^_Is ArabicPRESENTATION_FORMS_b}', ""); +Expect(0, 65135, '\p{_Is ArabicPRESENTATION_FORMS_b}', ""); +Expect(1, 65135, '\p{^_Is ArabicPRESENTATION_FORMS_b}', ""); +Expect(1, 65135, '\P{_Is ArabicPRESENTATION_FORMS_b}', ""); +Expect(0, 65135, '\P{^_Is ArabicPRESENTATION_FORMS_b}', ""); +Error('\p{-/a/in ARABIC Presentation forms-B}'); +Error('\P{-/a/in ARABIC Presentation forms-B}'); +Expect(1, 65279, '\p{inarabicpresentationformsb}', ""); +Expect(0, 65279, '\p{^inarabicpresentationformsb}', ""); +Expect(0, 65279, '\P{inarabicpresentationformsb}', ""); +Expect(1, 65279, '\P{^inarabicpresentationformsb}', ""); +Expect(0, 65135, '\p{inarabicpresentationformsb}', ""); +Expect(1, 65135, '\p{^inarabicpresentationformsb}', ""); +Expect(1, 65135, '\P{inarabicpresentationformsb}', ""); +Expect(0, 65135, '\P{^inarabicpresentationformsb}', ""); +Expect(1, 65279, '\p{-_INarabic PresentationForms B}', ""); +Expect(0, 65279, '\p{^-_INarabic PresentationForms B}', ""); +Expect(0, 65279, '\P{-_INarabic PresentationForms B}', ""); +Expect(1, 65279, '\P{^-_INarabic PresentationForms B}', ""); +Expect(0, 65135, '\p{-_INarabic PresentationForms B}', ""); +Expect(1, 65135, '\p{^-_INarabic PresentationForms B}', ""); +Expect(1, 65135, '\P{-_INarabic PresentationForms B}', ""); +Expect(0, 65135, '\P{^-_INarabic PresentationForms B}', ""); +Error('\p{ -alpha/a/}'); +Error('\P{ -alpha/a/}'); +Expect(1, 90, '\p{alpha}', ""); +Expect(0, 90, '\p{^alpha}', ""); +Expect(0, 90, '\P{alpha}', ""); +Expect(1, 90, '\P{^alpha}', ""); +Expect(0, 64, '\p{alpha}', ""); +Expect(1, 64, '\p{^alpha}', ""); +Expect(1, 64, '\P{alpha}', ""); +Expect(0, 64, '\P{^alpha}', ""); +Expect(1, 90, '\p{Alpha}', ""); +Expect(0, 90, '\p{^Alpha}', ""); +Expect(0, 90, '\P{Alpha}', ""); +Expect(1, 90, '\P{^Alpha}', ""); +Expect(0, 64, '\p{Alpha}', ""); +Expect(1, 64, '\p{^Alpha}', ""); +Expect(1, 64, '\P{Alpha}', ""); +Expect(0, 64, '\P{^Alpha}', ""); +Error('\p{ :=is-Alpha}'); +Error('\P{ :=is-Alpha}'); +Expect(1, 90, '\p{isalpha}', ""); +Expect(0, 90, '\p{^isalpha}', ""); +Expect(0, 90, '\P{isalpha}', ""); +Expect(1, 90, '\P{^isalpha}', ""); +Expect(0, 64, '\p{isalpha}', ""); +Expect(1, 64, '\p{^isalpha}', ""); +Expect(1, 64, '\P{isalpha}', ""); +Expect(0, 64, '\P{^isalpha}', ""); +Expect(1, 90, '\p{ IsAlpha}', ""); +Expect(0, 90, '\p{^ IsAlpha}', ""); +Expect(0, 90, '\P{ IsAlpha}', ""); +Expect(1, 90, '\P{^ IsAlpha}', ""); +Expect(0, 64, '\p{ IsAlpha}', ""); +Expect(1, 64, '\p{^ IsAlpha}', ""); +Expect(1, 64, '\P{ IsAlpha}', ""); +Expect(0, 64, '\P{^ IsAlpha}', ""); +Error('\p{-ALPHABETIC/a/}'); +Error('\P{-ALPHABETIC/a/}'); +Expect(1, 90, '\p{alphabetic}', ""); +Expect(0, 90, '\p{^alphabetic}', ""); +Expect(0, 90, '\P{alphabetic}', ""); +Expect(1, 90, '\P{^alphabetic}', ""); +Expect(0, 64, '\p{alphabetic}', ""); +Expect(1, 64, '\p{^alphabetic}', ""); +Expect(1, 64, '\P{alphabetic}', ""); +Expect(0, 64, '\P{^alphabetic}', ""); +Expect(1, 90, '\p{ _Alphabetic}', ""); +Expect(0, 90, '\p{^ _Alphabetic}', ""); +Expect(0, 90, '\P{ _Alphabetic}', ""); +Expect(1, 90, '\P{^ _Alphabetic}', ""); +Expect(0, 64, '\p{ _Alphabetic}', ""); +Expect(1, 64, '\p{^ _Alphabetic}', ""); +Expect(1, 64, '\P{ _Alphabetic}', ""); +Expect(0, 64, '\P{^ _Alphabetic}', ""); +Error('\p{ _IS:=alphabetic}'); +Error('\P{ _IS:=alphabetic}'); +Expect(1, 90, '\p{isalphabetic}', ""); +Expect(0, 90, '\p{^isalphabetic}', ""); +Expect(0, 90, '\P{isalphabetic}', ""); +Expect(1, 90, '\P{^isalphabetic}', ""); +Expect(0, 64, '\p{isalphabetic}', ""); +Expect(1, 64, '\p{^isalphabetic}', ""); +Expect(1, 64, '\P{isalphabetic}', ""); +Expect(0, 64, '\P{^isalphabetic}', ""); +Expect(1, 90, '\p{-Is alphabetic}', ""); +Expect(0, 90, '\p{^-Is alphabetic}', ""); +Expect(0, 90, '\P{-Is alphabetic}', ""); +Expect(1, 90, '\P{^-Is alphabetic}', ""); +Expect(0, 64, '\p{-Is alphabetic}', ""); +Expect(1, 64, '\p{^-Is alphabetic}', ""); +Expect(1, 64, '\P{-Is alphabetic}', ""); +Expect(0, 64, '\P{^-Is alphabetic}', ""); +Error('\p{ _in/a/MYANMAR}'); +Error('\P{ _in/a/MYANMAR}'); +Expect(1, 4255, '\p{inmyanmar}', ""); +Expect(0, 4255, '\p{^inmyanmar}', ""); +Expect(0, 4255, '\P{inmyanmar}', ""); +Expect(1, 4255, '\P{^inmyanmar}', ""); +Expect(0, 4095, '\p{inmyanmar}', ""); +Expect(1, 4095, '\p{^inmyanmar}', ""); +Expect(1, 4095, '\P{inmyanmar}', ""); +Expect(0, 4095, '\P{^inmyanmar}', ""); +Expect(1, 4255, '\p{ inmyanmar}', ""); +Expect(0, 4255, '\p{^ inmyanmar}', ""); +Expect(0, 4255, '\P{ inmyanmar}', ""); +Expect(1, 4255, '\P{^ inmyanmar}', ""); +Expect(0, 4095, '\p{ inmyanmar}', ""); +Expect(1, 4095, '\p{^ inmyanmar}', ""); +Expect(1, 4095, '\P{ inmyanmar}', ""); +Expect(0, 4095, '\P{^ inmyanmar}', ""); +Error('\p{/a/_ greek_Extended}'); +Error('\P{/a/_ greek_Extended}'); +Expect(1, 8191, '\p{greekextended}', ""); +Expect(0, 8191, '\p{^greekextended}', ""); +Expect(0, 8191, '\P{greekextended}', ""); +Expect(1, 8191, '\P{^greekextended}', ""); +Expect(0, 7935, '\p{greekextended}', ""); +Expect(1, 7935, '\p{^greekextended}', ""); +Expect(1, 7935, '\P{greekextended}', ""); +Expect(0, 7935, '\P{^greekextended}', ""); +Expect(1, 8191, '\p{ _GreekEXTENDED}', ""); +Expect(0, 8191, '\p{^ _GreekEXTENDED}', ""); +Expect(0, 8191, '\P{ _GreekEXTENDED}', ""); +Expect(1, 8191, '\P{^ _GreekEXTENDED}', ""); +Expect(0, 7935, '\p{ _GreekEXTENDED}', ""); +Expect(1, 7935, '\p{^ _GreekEXTENDED}', ""); +Expect(1, 7935, '\P{ _GreekEXTENDED}', ""); +Expect(0, 7935, '\P{^ _GreekEXTENDED}', ""); +Error('\p{/a/-Isgreek-Extended}'); +Error('\P{/a/-Isgreek-Extended}'); +Expect(1, 8191, '\p{isgreekextended}', ""); +Expect(0, 8191, '\p{^isgreekextended}', ""); +Expect(0, 8191, '\P{isgreekextended}', ""); +Expect(1, 8191, '\P{^isgreekextended}', ""); +Expect(0, 7935, '\p{isgreekextended}', ""); +Expect(1, 7935, '\p{^isgreekextended}', ""); +Expect(1, 7935, '\P{isgreekextended}', ""); +Expect(0, 7935, '\P{^isgreekextended}', ""); +Expect(1, 8191, '\p{-IS_GREEK Extended}', ""); +Expect(0, 8191, '\p{^-IS_GREEK Extended}', ""); +Expect(0, 8191, '\P{-IS_GREEK Extended}', ""); +Expect(1, 8191, '\P{^-IS_GREEK Extended}', ""); +Expect(0, 7935, '\p{-IS_GREEK Extended}', ""); +Expect(1, 7935, '\p{^-IS_GREEK Extended}', ""); +Expect(1, 7935, '\P{-IS_GREEK Extended}', ""); +Expect(0, 7935, '\P{^-IS_GREEK Extended}', ""); +Error('\p{__In:=Greek EXTENDED}'); +Error('\P{__In:=Greek EXTENDED}'); +Expect(1, 8191, '\p{ingreekextended}', ""); +Expect(0, 8191, '\p{^ingreekextended}', ""); +Expect(0, 8191, '\P{ingreekextended}', ""); +Expect(1, 8191, '\P{^ingreekextended}', ""); +Expect(0, 7935, '\p{ingreekextended}', ""); +Expect(1, 7935, '\p{^ingreekextended}', ""); +Expect(1, 7935, '\P{ingreekextended}', ""); +Expect(0, 7935, '\P{^ingreekextended}', ""); +Expect(1, 8191, '\p{-In Greek_Extended}', ""); +Expect(0, 8191, '\p{^-In Greek_Extended}', ""); +Expect(0, 8191, '\P{-In Greek_Extended}', ""); +Expect(1, 8191, '\P{^-In Greek_Extended}', ""); +Expect(0, 7935, '\p{-In Greek_Extended}', ""); +Expect(1, 7935, '\p{^-In Greek_Extended}', ""); +Expect(1, 7935, '\P{-In Greek_Extended}', ""); +Expect(0, 7935, '\P{^-In Greek_Extended}', ""); +Error('\p{ /a/RADICAL}'); +Error('\P{ /a/RADICAL}'); +Expect(1, 11929, '\p{radical}', ""); +Expect(0, 11929, '\p{^radical}', ""); +Expect(0, 11929, '\P{radical}', ""); +Expect(1, 11929, '\P{^radical}', ""); +Expect(0, 11903, '\p{radical}', ""); +Expect(1, 11903, '\p{^radical}', ""); +Expect(1, 11903, '\P{radical}', ""); +Expect(0, 11903, '\P{^radical}', ""); +Expect(1, 11929, '\p{__Radical}', ""); +Expect(0, 11929, '\p{^__Radical}', ""); +Expect(0, 11929, '\P{__Radical}', ""); +Expect(1, 11929, '\P{^__Radical}', ""); +Expect(0, 11903, '\p{__Radical}', ""); +Expect(1, 11903, '\p{^__Radical}', ""); +Expect(1, 11903, '\P{__Radical}', ""); +Expect(0, 11903, '\P{^__Radical}', ""); +Error('\p{ /a/isRADICAL}'); +Error('\P{ /a/isRADICAL}'); +Expect(1, 11929, '\p{isradical}', ""); +Expect(0, 11929, '\p{^isradical}', ""); +Expect(0, 11929, '\P{isradical}', ""); +Expect(1, 11929, '\P{^isradical}', ""); +Expect(0, 11903, '\p{isradical}', ""); +Expect(1, 11903, '\p{^isradical}', ""); +Expect(1, 11903, '\P{isradical}', ""); +Expect(0, 11903, '\P{^isradical}', ""); +Expect(1, 11929, '\p{ -Is Radical}', ""); +Expect(0, 11929, '\p{^ -Is Radical}', ""); +Expect(0, 11929, '\P{ -Is Radical}', ""); +Expect(1, 11929, '\P{^ -Is Radical}', ""); +Expect(0, 11903, '\p{ -Is Radical}', ""); +Expect(1, 11903, '\p{^ -Is Radical}', ""); +Expect(1, 11903, '\P{ -Is Radical}', ""); +Expect(0, 11903, '\P{^ -Is Radical}', ""); +Error('\p{- Low-surrogates:=}'); +Error('\P{- Low-surrogates:=}'); +Expect(0, 7, '\p{lowsurrogates}', ""); +Expect(1, 7, '\p{^lowsurrogates}', ""); +Expect(1, 7, '\P{lowsurrogates}', ""); +Expect(0, 7, '\P{^lowsurrogates}', ""); +Expect(0, 7, '\p{ Low SURROGATES}', ""); +Expect(1, 7, '\p{^ Low SURROGATES}', ""); +Expect(1, 7, '\P{ Low SURROGATES}', ""); +Expect(0, 7, '\P{^ Low SURROGATES}', ""); +Error('\p{ Is-LOWSURROGATES:=}'); +Error('\P{ Is-LOWSURROGATES:=}'); +Expect(0, 7, '\p{islowsurrogates}', ""); +Expect(1, 7, '\p{^islowsurrogates}', ""); +Expect(1, 7, '\P{islowsurrogates}', ""); +Expect(0, 7, '\P{^islowsurrogates}', ""); +Expect(0, 7, '\p{-_Is LOW SURROGATES}', ""); +Expect(1, 7, '\p{^-_Is LOW SURROGATES}', ""); +Expect(1, 7, '\P{-_Is LOW SURROGATES}', ""); +Expect(0, 7, '\P{^-_Is LOW SURROGATES}', ""); +Error('\p{ In_LOWSurrogates/a/}'); +Error('\P{ In_LOWSurrogates/a/}'); +Expect(0, 7, '\p{inlowsurrogates}', ""); +Expect(1, 7, '\p{^inlowsurrogates}', ""); +Expect(1, 7, '\P{inlowsurrogates}', ""); +Expect(0, 7, '\P{^inlowsurrogates}', ""); +Expect(0, 7, '\p{-In-low Surrogates}', ""); +Expect(1, 7, '\p{^-In-low Surrogates}', ""); +Expect(1, 7, '\P{-In-low Surrogates}', ""); +Expect(0, 7, '\P{^-In-low Surrogates}', ""); +Error('\p{ -IN-Phags:=Pa}'); +Error('\P{ -IN-Phags:=Pa}'); +Expect(1, 43135, '\p{inphagspa}', ""); +Expect(0, 43135, '\p{^inphagspa}', ""); +Expect(0, 43135, '\P{inphagspa}', ""); +Expect(1, 43135, '\P{^inphagspa}', ""); +Expect(0, 43071, '\p{inphagspa}', ""); +Expect(1, 43071, '\p{^inphagspa}', ""); +Expect(1, 43071, '\P{inphagspa}', ""); +Expect(0, 43071, '\P{^inphagspa}', ""); +Expect(1, 43135, '\p{- IN PHAGSpa}', ""); +Expect(0, 43135, '\p{^- IN PHAGSpa}', ""); +Expect(0, 43135, '\P{- IN PHAGSpa}', ""); +Expect(1, 43135, '\P{^- IN PHAGSpa}', ""); +Expect(0, 43071, '\p{- IN PHAGSpa}', ""); +Expect(1, 43071, '\p{^- IN PHAGSpa}', ""); +Expect(1, 43071, '\P{- IN PHAGSpa}', ""); +Expect(0, 43071, '\P{^- IN PHAGSpa}', ""); +Error('\p{/a/PerlSpace}'); +Error('\P{/a/PerlSpace}'); +Expect(1, 10, '\p{perlspace}', ""); +Expect(0, 10, '\p{^perlspace}', ""); +Expect(0, 10, '\P{perlspace}', ""); +Expect(1, 10, '\P{^perlspace}', ""); +Expect(0, 8, '\p{perlspace}', ""); +Expect(1, 8, '\p{^perlspace}', ""); +Expect(1, 8, '\P{perlspace}', ""); +Expect(0, 8, '\P{^perlspace}', ""); +Expect(1, 10, '\p{ PerlSpace}', ""); +Expect(0, 10, '\p{^ PerlSpace}', ""); +Expect(0, 10, '\P{ PerlSpace}', ""); +Expect(1, 10, '\P{^ PerlSpace}', ""); +Expect(0, 8, '\p{ PerlSpace}', ""); +Expect(1, 8, '\p{^ PerlSpace}', ""); +Expect(1, 8, '\P{ PerlSpace}', ""); +Expect(0, 8, '\P{^ PerlSpace}', ""); +Error('\p{ /a/is-PERLSPACE}'); +Error('\P{ /a/is-PERLSPACE}'); +Expect(1, 10, '\p{isperlspace}', ""); +Expect(0, 10, '\p{^isperlspace}', ""); +Expect(0, 10, '\P{isperlspace}', ""); +Expect(1, 10, '\P{^isperlspace}', ""); +Expect(0, 8, '\p{isperlspace}', ""); +Expect(1, 8, '\p{^isperlspace}', ""); +Expect(1, 8, '\P{isperlspace}', ""); +Expect(0, 8, '\P{^isperlspace}', ""); +Expect(1, 10, '\p{_ Is_PerlSpace}', ""); +Expect(0, 10, '\p{^_ Is_PerlSpace}', ""); +Expect(0, 10, '\P{_ Is_PerlSpace}', ""); +Expect(1, 10, '\P{^_ Is_PerlSpace}', ""); +Expect(0, 8, '\p{_ Is_PerlSpace}', ""); +Expect(1, 8, '\p{^_ Is_PerlSpace}', ""); +Expect(1, 8, '\P{_ Is_PerlSpace}', ""); +Expect(0, 8, '\P{^_ Is_PerlSpace}', ""); +Error('\p{ _IDS-Binary-Operator/a/}'); +Error('\P{ _IDS-Binary-Operator/a/}'); +Expect(1, 12273, '\p{idsbinaryoperator}', ""); +Expect(0, 12273, '\p{^idsbinaryoperator}', ""); +Expect(0, 12273, '\P{idsbinaryoperator}', ""); +Expect(1, 12273, '\P{^idsbinaryoperator}', ""); +Expect(0, 12271, '\p{idsbinaryoperator}', ""); +Expect(1, 12271, '\p{^idsbinaryoperator}', ""); +Expect(1, 12271, '\P{idsbinaryoperator}', ""); +Expect(0, 12271, '\P{^idsbinaryoperator}', ""); +Expect(1, 12273, '\p{__IDS Binary Operator}', ""); +Expect(0, 12273, '\p{^__IDS Binary Operator}', ""); +Expect(0, 12273, '\P{__IDS Binary Operator}', ""); +Expect(1, 12273, '\P{^__IDS Binary Operator}', ""); +Expect(0, 12271, '\p{__IDS Binary Operator}', ""); +Expect(1, 12271, '\p{^__IDS Binary Operator}', ""); +Expect(1, 12271, '\P{__IDS Binary Operator}', ""); +Expect(0, 12271, '\P{^__IDS Binary Operator}', ""); +Error('\p{ :=Is IDS_BINARYOPERATOR}'); +Error('\P{ :=Is IDS_BINARYOPERATOR}'); +Expect(1, 12273, '\p{isidsbinaryoperator}', ""); +Expect(0, 12273, '\p{^isidsbinaryoperator}', ""); +Expect(0, 12273, '\P{isidsbinaryoperator}', ""); +Expect(1, 12273, '\P{^isidsbinaryoperator}', ""); +Expect(0, 12271, '\p{isidsbinaryoperator}', ""); +Expect(1, 12271, '\p{^isidsbinaryoperator}', ""); +Expect(1, 12271, '\P{isidsbinaryoperator}', ""); +Expect(0, 12271, '\P{^isidsbinaryoperator}', ""); +Expect(1, 12273, '\p{-Is_IDS-binary-Operator}', ""); +Expect(0, 12273, '\p{^-Is_IDS-binary-Operator}', ""); +Expect(0, 12273, '\P{-Is_IDS-binary-Operator}', ""); +Expect(1, 12273, '\P{^-Is_IDS-binary-Operator}', ""); +Expect(0, 12271, '\p{-Is_IDS-binary-Operator}', ""); +Expect(1, 12271, '\p{^-Is_IDS-binary-Operator}', ""); +Expect(1, 12271, '\P{-Is_IDS-binary-Operator}', ""); +Expect(0, 12271, '\P{^-Is_IDS-binary-Operator}', ""); +Error('\p{:=_idsb}'); +Error('\P{:=_idsb}'); +Expect(1, 12273, '\p{idsb}', ""); +Expect(0, 12273, '\p{^idsb}', ""); +Expect(0, 12273, '\P{idsb}', ""); +Expect(1, 12273, '\P{^idsb}', ""); +Expect(0, 12271, '\p{idsb}', ""); +Expect(1, 12271, '\p{^idsb}', ""); +Expect(1, 12271, '\P{idsb}', ""); +Expect(0, 12271, '\P{^idsb}', ""); +Expect(1, 12273, '\p{-idsb}', ""); +Expect(0, 12273, '\p{^-idsb}', ""); +Expect(0, 12273, '\P{-idsb}', ""); +Expect(1, 12273, '\P{^-idsb}', ""); +Expect(0, 12271, '\p{-idsb}', ""); +Expect(1, 12271, '\p{^-idsb}', ""); +Expect(1, 12271, '\P{-idsb}', ""); +Expect(0, 12271, '\P{^-idsb}', ""); +Error('\p{/a/- isIDSB}'); +Error('\P{/a/- isIDSB}'); +Expect(1, 12273, '\p{isidsb}', ""); +Expect(0, 12273, '\p{^isidsb}', ""); +Expect(0, 12273, '\P{isidsb}', ""); +Expect(1, 12273, '\P{^isidsb}', ""); +Expect(0, 12271, '\p{isidsb}', ""); +Expect(1, 12271, '\p{^isidsb}', ""); +Expect(1, 12271, '\P{isidsb}', ""); +Expect(0, 12271, '\P{^isidsb}', ""); +Expect(1, 12273, '\p{ _Is_IDSB}', ""); +Expect(0, 12273, '\p{^ _Is_IDSB}', ""); +Expect(0, 12273, '\P{ _Is_IDSB}', ""); +Expect(1, 12273, '\P{^ _Is_IDSB}', ""); +Expect(0, 12271, '\p{ _Is_IDSB}', ""); +Expect(1, 12271, '\p{^ _Is_IDSB}', ""); +Expect(1, 12271, '\P{ _Is_IDSB}', ""); +Expect(0, 12271, '\P{^ _Is_IDSB}', ""); +Error('\p{ Cntrl:=}'); +Error('\P{ Cntrl:=}'); +Expect(1, 7, '\p{cntrl}', ""); +Expect(0, 7, '\p{^cntrl}', ""); +Expect(0, 7, '\P{cntrl}', ""); +Expect(1, 7, '\P{^cntrl}', ""); +Expect(0, 126, '\p{cntrl}', ""); +Expect(1, 126, '\p{^cntrl}', ""); +Expect(1, 126, '\P{cntrl}', ""); +Expect(0, 126, '\P{^cntrl}', ""); +Expect(1, 7, '\p{-_CNTRL}', ""); +Expect(0, 7, '\p{^-_CNTRL}', ""); +Expect(0, 7, '\P{-_CNTRL}', ""); +Expect(1, 7, '\P{^-_CNTRL}', ""); +Expect(0, 126, '\p{-_CNTRL}', ""); +Expect(1, 126, '\p{^-_CNTRL}', ""); +Expect(1, 126, '\P{-_CNTRL}', ""); +Expect(0, 126, '\P{^-_CNTRL}', ""); +Error('\p{:=Is CNTRL}'); +Error('\P{:=Is CNTRL}'); +Expect(1, 7, '\p{iscntrl}', ""); +Expect(0, 7, '\p{^iscntrl}', ""); +Expect(0, 7, '\P{iscntrl}', ""); +Expect(1, 7, '\P{^iscntrl}', ""); +Expect(0, 126, '\p{iscntrl}', ""); +Expect(1, 126, '\p{^iscntrl}', ""); +Expect(1, 126, '\P{iscntrl}', ""); +Expect(0, 126, '\P{^iscntrl}', ""); +Expect(1, 7, '\p{ Is_cntrl}', ""); +Expect(0, 7, '\p{^ Is_cntrl}', ""); +Expect(0, 7, '\P{ Is_cntrl}', ""); +Expect(1, 7, '\P{^ Is_cntrl}', ""); +Expect(0, 126, '\p{ Is_cntrl}', ""); +Expect(1, 126, '\p{^ Is_cntrl}', ""); +Expect(1, 126, '\P{ Is_cntrl}', ""); +Expect(0, 126, '\P{^ Is_cntrl}', ""); +Error('\p{:= Control}'); +Error('\P{:= Control}'); +Expect(1, 7, '\p{control}', ""); +Expect(0, 7, '\p{^control}', ""); +Expect(0, 7, '\P{control}', ""); +Expect(1, 7, '\P{^control}', ""); +Expect(0, 126, '\p{control}', ""); +Expect(1, 126, '\p{^control}', ""); +Expect(1, 126, '\P{control}', ""); +Expect(0, 126, '\P{^control}', ""); +Expect(1, 7, '\p{ Control}', ""); +Expect(0, 7, '\p{^ Control}', ""); +Expect(0, 7, '\P{ Control}', ""); +Expect(1, 7, '\P{^ Control}', ""); +Expect(0, 126, '\p{ Control}', ""); +Expect(1, 126, '\p{^ Control}', ""); +Expect(1, 126, '\P{ Control}', ""); +Expect(0, 126, '\P{^ Control}', ""); +Error('\p{:= _IS Control}'); +Error('\P{:= _IS Control}'); +Expect(1, 7, '\p{iscontrol}', ""); +Expect(0, 7, '\p{^iscontrol}', ""); +Expect(0, 7, '\P{iscontrol}', ""); +Expect(1, 7, '\P{^iscontrol}', ""); +Expect(0, 126, '\p{iscontrol}', ""); +Expect(1, 126, '\p{^iscontrol}', ""); +Expect(1, 126, '\P{iscontrol}', ""); +Expect(0, 126, '\P{^iscontrol}', ""); +Expect(1, 7, '\p{_Is control}', ""); +Expect(0, 7, '\p{^_Is control}', ""); +Expect(0, 7, '\P{_Is control}', ""); +Expect(1, 7, '\P{^_Is control}', ""); +Expect(0, 126, '\p{_Is control}', ""); +Expect(1, 126, '\p{^_Is control}', ""); +Expect(1, 126, '\P{_Is control}', ""); +Expect(0, 126, '\P{^_Is control}', ""); +Error('\p{/a/_-Cc}'); +Error('\P{/a/_-Cc}'); +Expect(1, 7, '\p{cc}', ""); +Expect(0, 7, '\p{^cc}', ""); +Expect(0, 7, '\P{cc}', ""); +Expect(1, 7, '\P{^cc}', ""); +Expect(0, 126, '\p{cc}', ""); +Expect(1, 126, '\p{^cc}', ""); +Expect(1, 126, '\P{cc}', ""); +Expect(0, 126, '\P{^cc}', ""); +Expect(1, 7, '\p{ CC}', ""); +Expect(0, 7, '\p{^ CC}', ""); +Expect(0, 7, '\P{ CC}', ""); +Expect(1, 7, '\P{^ CC}', ""); +Expect(0, 126, '\p{ CC}', ""); +Expect(1, 126, '\p{^ CC}', ""); +Expect(1, 126, '\P{ CC}', ""); +Expect(0, 126, '\P{^ CC}', ""); +Error('\p{- IsCc:=}'); +Error('\P{- IsCc:=}'); +Expect(1, 7, '\p{iscc}', ""); +Expect(0, 7, '\p{^iscc}', ""); +Expect(0, 7, '\P{iscc}', ""); +Expect(1, 7, '\P{^iscc}', ""); +Expect(0, 126, '\p{iscc}', ""); +Expect(1, 126, '\p{^iscc}', ""); +Expect(1, 126, '\P{iscc}', ""); +Expect(0, 126, '\P{^iscc}', ""); +Expect(1, 7, '\p{Is-cc}', ""); +Expect(0, 7, '\p{^Is-cc}', ""); +Expect(0, 7, '\P{Is-cc}', ""); +Expect(1, 7, '\P{^Is-cc}', ""); +Expect(0, 126, '\p{Is-cc}', ""); +Expect(1, 126, '\p{^Is-cc}', ""); +Expect(1, 126, '\P{Is-cc}', ""); +Expect(0, 126, '\P{^Is-cc}', ""); +Error('\p{_ Cyrillic:=EXTENDED A}'); +Error('\P{_ Cyrillic:=EXTENDED A}'); +Expect(1, 11775, '\p{cyrillicextendeda}', ""); +Expect(0, 11775, '\p{^cyrillicextendeda}', ""); +Expect(0, 11775, '\P{cyrillicextendeda}', ""); +Expect(1, 11775, '\P{^cyrillicextendeda}', ""); +Expect(0, 11743, '\p{cyrillicextendeda}', ""); +Expect(1, 11743, '\p{^cyrillicextendeda}', ""); +Expect(1, 11743, '\P{cyrillicextendeda}', ""); +Expect(0, 11743, '\P{^cyrillicextendeda}', ""); +Expect(1, 11775, '\p{- cyrillic_Extended_A}', ""); +Expect(0, 11775, '\p{^- cyrillic_Extended_A}', ""); +Expect(0, 11775, '\P{- cyrillic_Extended_A}', ""); +Expect(1, 11775, '\P{^- cyrillic_Extended_A}', ""); +Expect(0, 11743, '\p{- cyrillic_Extended_A}', ""); +Expect(1, 11743, '\p{^- cyrillic_Extended_A}', ""); +Expect(1, 11743, '\P{- cyrillic_Extended_A}', ""); +Expect(0, 11743, '\P{^- cyrillic_Extended_A}', ""); +Error('\p{_/a/IS cyrillicextended a}'); +Error('\P{_/a/IS cyrillicextended a}'); +Expect(1, 11775, '\p{iscyrillicextendeda}', ""); +Expect(0, 11775, '\p{^iscyrillicextendeda}', ""); +Expect(0, 11775, '\P{iscyrillicextendeda}', ""); +Expect(1, 11775, '\P{^iscyrillicextendeda}', ""); +Expect(0, 11743, '\p{iscyrillicextendeda}', ""); +Expect(1, 11743, '\p{^iscyrillicextendeda}', ""); +Expect(1, 11743, '\P{iscyrillicextendeda}', ""); +Expect(0, 11743, '\P{^iscyrillicextendeda}', ""); +Expect(1, 11775, '\p{-_Is Cyrillic Extended_a}', ""); +Expect(0, 11775, '\p{^-_Is Cyrillic Extended_a}', ""); +Expect(0, 11775, '\P{-_Is Cyrillic Extended_a}', ""); +Expect(1, 11775, '\P{^-_Is Cyrillic Extended_a}', ""); +Expect(0, 11743, '\p{-_Is Cyrillic Extended_a}', ""); +Expect(1, 11743, '\p{^-_Is Cyrillic Extended_a}', ""); +Expect(1, 11743, '\P{-_Is Cyrillic Extended_a}', ""); +Expect(0, 11743, '\P{^-_Is Cyrillic Extended_a}', ""); +Error('\p{--In_CYRILLIC:=EXTENDED-A}'); +Error('\P{--In_CYRILLIC:=EXTENDED-A}'); +Expect(1, 11775, '\p{incyrillicextendeda}', ""); +Expect(0, 11775, '\p{^incyrillicextendeda}', ""); +Expect(0, 11775, '\P{incyrillicextendeda}', ""); +Expect(1, 11775, '\P{^incyrillicextendeda}', ""); +Expect(0, 11743, '\p{incyrillicextendeda}', ""); +Expect(1, 11743, '\p{^incyrillicextendeda}', ""); +Expect(1, 11743, '\P{incyrillicextendeda}', ""); +Expect(0, 11743, '\P{^incyrillicextendeda}', ""); +Expect(1, 11775, '\p{ In Cyrillic-Extended A}', ""); +Expect(0, 11775, '\p{^ In Cyrillic-Extended A}', ""); +Expect(0, 11775, '\P{ In Cyrillic-Extended A}', ""); +Expect(1, 11775, '\P{^ In Cyrillic-Extended A}', ""); +Expect(0, 11743, '\p{ In Cyrillic-Extended A}', ""); +Expect(1, 11743, '\p{^ In Cyrillic-Extended A}', ""); +Expect(1, 11743, '\P{ In Cyrillic-Extended A}', ""); +Expect(0, 11743, '\P{^ In Cyrillic-Extended A}', ""); +Error('\p{ :=PosixLower}'); +Error('\P{ :=PosixLower}'); +Expect(1, 122, '\p{posixlower}', ""); +Expect(0, 122, '\p{^posixlower}', ""); +Expect(0, 122, '\P{posixlower}', ""); +Expect(1, 122, '\P{^posixlower}', ""); +Expect(0, 96, '\p{posixlower}', ""); +Expect(1, 96, '\p{^posixlower}', ""); +Expect(1, 96, '\P{posixlower}', ""); +Expect(0, 96, '\P{^posixlower}', ""); +Expect(1, 122, '\p{ PosixLower}', ""); +Expect(0, 122, '\p{^ PosixLower}', ""); +Expect(0, 122, '\P{ PosixLower}', ""); +Expect(1, 122, '\P{^ PosixLower}', ""); +Expect(0, 96, '\p{ PosixLower}', ""); +Expect(1, 96, '\p{^ PosixLower}', ""); +Expect(1, 96, '\P{ PosixLower}', ""); +Expect(0, 96, '\P{^ PosixLower}', ""); +Error('\p{ /a/Is-posixlower}'); +Error('\P{ /a/Is-posixlower}'); +Expect(1, 122, '\p{isposixlower}', ""); +Expect(0, 122, '\p{^isposixlower}', ""); +Expect(0, 122, '\P{isposixlower}', ""); +Expect(1, 122, '\P{^isposixlower}', ""); +Expect(0, 96, '\p{isposixlower}', ""); +Expect(1, 96, '\p{^isposixlower}', ""); +Expect(1, 96, '\P{isposixlower}', ""); +Expect(0, 96, '\P{^isposixlower}', ""); +Expect(1, 122, '\p{_ is PosixLower}', ""); +Expect(0, 122, '\p{^_ is PosixLower}', ""); +Expect(0, 122, '\P{_ is PosixLower}', ""); +Expect(1, 122, '\P{^_ is PosixLower}', ""); +Expect(0, 96, '\p{_ is PosixLower}', ""); +Expect(1, 96, '\p{^_ is PosixLower}', ""); +Expect(1, 96, '\P{_ is PosixLower}', ""); +Expect(0, 96, '\P{^_ is PosixLower}', ""); +Error('\p{ -OTHER:=Grapheme_Extend}'); +Error('\P{ -OTHER:=Grapheme_Extend}'); +Expect(1, 2494, '\p{othergraphemeextend}', 'deprecated'); +Expect(0, 2494, '\p{^othergraphemeextend}', 'deprecated'); +Expect(0, 2494, '\P{othergraphemeextend}', 'deprecated'); +Expect(1, 2494, '\P{^othergraphemeextend}', 'deprecated'); +Expect(0, 2493, '\p{othergraphemeextend}', 'deprecated'); +Expect(1, 2493, '\p{^othergraphemeextend}', 'deprecated'); +Expect(1, 2493, '\P{othergraphemeextend}', 'deprecated'); +Expect(0, 2493, '\P{^othergraphemeextend}', 'deprecated'); +Expect(1, 2494, '\p{OTHER-grapheme Extend}', 'deprecated'); +Expect(0, 2494, '\p{^OTHER-grapheme Extend}', 'deprecated'); +Expect(0, 2494, '\P{OTHER-grapheme Extend}', 'deprecated'); +Expect(1, 2494, '\P{^OTHER-grapheme Extend}', 'deprecated'); +Expect(0, 2493, '\p{OTHER-grapheme Extend}', 'deprecated'); +Expect(1, 2493, '\p{^OTHER-grapheme Extend}', 'deprecated'); +Expect(1, 2493, '\P{OTHER-grapheme Extend}', 'deprecated'); +Expect(0, 2493, '\P{^OTHER-grapheme Extend}', 'deprecated'); +Error('\p{/a/ Is-Othergrapheme_EXTEND}'); +Error('\P{/a/ Is-Othergrapheme_EXTEND}'); +Expect(1, 2494, '\p{isothergraphemeextend}', 'deprecated'); +Expect(0, 2494, '\p{^isothergraphemeextend}', 'deprecated'); +Expect(0, 2494, '\P{isothergraphemeextend}', 'deprecated'); +Expect(1, 2494, '\P{^isothergraphemeextend}', 'deprecated'); +Expect(0, 2493, '\p{isothergraphemeextend}', 'deprecated'); +Expect(1, 2493, '\p{^isothergraphemeextend}', 'deprecated'); +Expect(1, 2493, '\P{isothergraphemeextend}', 'deprecated'); +Expect(0, 2493, '\P{^isothergraphemeextend}', 'deprecated'); +Expect(1, 2494, '\p{__IsOTHER_GRAPHEME_EXTEND}', 'deprecated'); +Expect(0, 2494, '\p{^__IsOTHER_GRAPHEME_EXTEND}', 'deprecated'); +Expect(0, 2494, '\P{__IsOTHER_GRAPHEME_EXTEND}', 'deprecated'); +Expect(1, 2494, '\P{^__IsOTHER_GRAPHEME_EXTEND}', 'deprecated'); +Expect(0, 2493, '\p{__IsOTHER_GRAPHEME_EXTEND}', 'deprecated'); +Expect(1, 2493, '\p{^__IsOTHER_GRAPHEME_EXTEND}', 'deprecated'); +Expect(1, 2493, '\P{__IsOTHER_GRAPHEME_EXTEND}', 'deprecated'); +Expect(0, 2493, '\P{^__IsOTHER_GRAPHEME_EXTEND}', 'deprecated'); +Error('\p{_-OGr Ext:=}'); +Error('\P{_-OGr Ext:=}'); +Expect(1, 2494, '\p{ogrext}', 'deprecated'); +Expect(0, 2494, '\p{^ogrext}', 'deprecated'); +Expect(0, 2494, '\P{ogrext}', 'deprecated'); +Expect(1, 2494, '\P{^ogrext}', 'deprecated'); +Expect(0, 2493, '\p{ogrext}', 'deprecated'); +Expect(1, 2493, '\p{^ogrext}', 'deprecated'); +Expect(1, 2493, '\P{ogrext}', 'deprecated'); +Expect(0, 2493, '\P{^ogrext}', 'deprecated'); +Expect(1, 2494, '\p{_OGRExt}', 'deprecated'); +Expect(0, 2494, '\p{^_OGRExt}', 'deprecated'); +Expect(0, 2494, '\P{_OGRExt}', 'deprecated'); +Expect(1, 2494, '\P{^_OGRExt}', 'deprecated'); +Expect(0, 2493, '\p{_OGRExt}', 'deprecated'); +Expect(1, 2493, '\p{^_OGRExt}', 'deprecated'); +Expect(1, 2493, '\P{_OGRExt}', 'deprecated'); +Expect(0, 2493, '\P{^_OGRExt}', 'deprecated'); +Error('\p{:= Is-OGr_ext}'); +Error('\P{:= Is-OGr_ext}'); +Expect(1, 2494, '\p{isogrext}', 'deprecated'); +Expect(0, 2494, '\p{^isogrext}', 'deprecated'); +Expect(0, 2494, '\P{isogrext}', 'deprecated'); +Expect(1, 2494, '\P{^isogrext}', 'deprecated'); +Expect(0, 2493, '\p{isogrext}', 'deprecated'); +Expect(1, 2493, '\p{^isogrext}', 'deprecated'); +Expect(1, 2493, '\P{isogrext}', 'deprecated'); +Expect(0, 2493, '\P{^isogrext}', 'deprecated'); +Expect(1, 2494, '\p{ _Is_OGr-EXT}', 'deprecated'); +Expect(0, 2494, '\p{^ _Is_OGr-EXT}', 'deprecated'); +Expect(0, 2494, '\P{ _Is_OGr-EXT}', 'deprecated'); +Expect(1, 2494, '\P{^ _Is_OGr-EXT}', 'deprecated'); +Expect(0, 2493, '\p{ _Is_OGr-EXT}', 'deprecated'); +Expect(1, 2493, '\p{^ _Is_OGr-EXT}', 'deprecated'); +Expect(1, 2493, '\P{ _Is_OGr-EXT}', 'deprecated'); +Expect(0, 2493, '\P{^ _Is_OGr-EXT}', 'deprecated'); +Error('\p{_:=Old_persian}'); +Error('\P{_:=Old_persian}'); +Expect(1, 66499, '\p{oldpersian}', ""); +Expect(0, 66499, '\p{^oldpersian}', ""); +Expect(0, 66499, '\P{oldpersian}', ""); +Expect(1, 66499, '\P{^oldpersian}', ""); +Expect(0, 66463, '\p{oldpersian}', ""); +Expect(1, 66463, '\p{^oldpersian}', ""); +Expect(1, 66463, '\P{oldpersian}', ""); +Expect(0, 66463, '\P{^oldpersian}', ""); +Expect(1, 66499, '\p{ Old-Persian}', ""); +Expect(0, 66499, '\p{^ Old-Persian}', ""); +Expect(0, 66499, '\P{ Old-Persian}', ""); +Expect(1, 66499, '\P{^ Old-Persian}', ""); +Expect(0, 66463, '\p{ Old-Persian}', ""); +Expect(1, 66463, '\p{^ Old-Persian}', ""); +Expect(1, 66463, '\P{ Old-Persian}', ""); +Expect(0, 66463, '\P{^ Old-Persian}', ""); +Error('\p{/a/ -Is_old persian}'); +Error('\P{/a/ -Is_old persian}'); +Expect(1, 66499, '\p{isoldpersian}', ""); +Expect(0, 66499, '\p{^isoldpersian}', ""); +Expect(0, 66499, '\P{isoldpersian}', ""); +Expect(1, 66499, '\P{^isoldpersian}', ""); +Expect(0, 66463, '\p{isoldpersian}', ""); +Expect(1, 66463, '\p{^isoldpersian}', ""); +Expect(1, 66463, '\P{isoldpersian}', ""); +Expect(0, 66463, '\P{^isoldpersian}', ""); +Expect(1, 66499, '\p{ Is_old_Persian}', ""); +Expect(0, 66499, '\p{^ Is_old_Persian}', ""); +Expect(0, 66499, '\P{ Is_old_Persian}', ""); +Expect(1, 66499, '\P{^ Is_old_Persian}', ""); +Expect(0, 66463, '\p{ Is_old_Persian}', ""); +Expect(1, 66463, '\p{^ Is_old_Persian}', ""); +Expect(1, 66463, '\P{ Is_old_Persian}', ""); +Expect(0, 66463, '\P{^ Is_old_Persian}', ""); +Error('\p{/a/_Xpeo}'); +Error('\P{/a/_Xpeo}'); +Expect(1, 66499, '\p{xpeo}', ""); +Expect(0, 66499, '\p{^xpeo}', ""); +Expect(0, 66499, '\P{xpeo}', ""); +Expect(1, 66499, '\P{^xpeo}', ""); +Expect(0, 66463, '\p{xpeo}', ""); +Expect(1, 66463, '\p{^xpeo}', ""); +Expect(1, 66463, '\P{xpeo}', ""); +Expect(0, 66463, '\P{^xpeo}', ""); +Expect(1, 66499, '\p{_ XPEO}', ""); +Expect(0, 66499, '\p{^_ XPEO}', ""); +Expect(0, 66499, '\P{_ XPEO}', ""); +Expect(1, 66499, '\P{^_ XPEO}', ""); +Expect(0, 66463, '\p{_ XPEO}', ""); +Expect(1, 66463, '\p{^_ XPEO}', ""); +Expect(1, 66463, '\P{_ XPEO}', ""); +Expect(0, 66463, '\P{^_ XPEO}', ""); +Error('\p{_/a/is-Xpeo}'); +Error('\P{_/a/is-Xpeo}'); +Expect(1, 66499, '\p{isxpeo}', ""); +Expect(0, 66499, '\p{^isxpeo}', ""); +Expect(0, 66499, '\P{isxpeo}', ""); +Expect(1, 66499, '\P{^isxpeo}', ""); +Expect(0, 66463, '\p{isxpeo}', ""); +Expect(1, 66463, '\p{^isxpeo}', ""); +Expect(1, 66463, '\P{isxpeo}', ""); +Expect(0, 66463, '\P{^isxpeo}', ""); +Expect(1, 66499, '\p{ -Is Xpeo}', ""); +Expect(0, 66499, '\p{^ -Is Xpeo}', ""); +Expect(0, 66499, '\P{ -Is Xpeo}', ""); +Expect(1, 66499, '\P{^ -Is Xpeo}', ""); +Expect(0, 66463, '\p{ -Is Xpeo}', ""); +Expect(1, 66463, '\p{^ -Is Xpeo}', ""); +Expect(1, 66463, '\P{ -Is Xpeo}', ""); +Expect(0, 66463, '\P{^ -Is Xpeo}', ""); +Error('\p{ :=New Tai-Lue}'); +Error('\P{ :=New Tai-Lue}'); +Expect(1, 6569, '\p{newtailue}', ""); +Expect(0, 6569, '\p{^newtailue}', ""); +Expect(0, 6569, '\P{newtailue}', ""); +Expect(1, 6569, '\P{^newtailue}', ""); +Expect(0, 6527, '\p{newtailue}', ""); +Expect(1, 6527, '\p{^newtailue}', ""); +Expect(1, 6527, '\P{newtailue}', ""); +Expect(0, 6527, '\P{^newtailue}', ""); +Expect(1, 6569, '\p{ New tai Lue}', ""); +Expect(0, 6569, '\p{^ New tai Lue}', ""); +Expect(0, 6569, '\P{ New tai Lue}', ""); +Expect(1, 6569, '\P{^ New tai Lue}', ""); +Expect(0, 6527, '\p{ New tai Lue}', ""); +Expect(1, 6527, '\p{^ New tai Lue}', ""); +Expect(1, 6527, '\P{ New tai Lue}', ""); +Expect(0, 6527, '\P{^ New tai Lue}', ""); +Error('\p{ -Is_New-Tai:=LUE}'); +Error('\P{ -Is_New-Tai:=LUE}'); +Expect(1, 6569, '\p{isnewtailue}', ""); +Expect(0, 6569, '\p{^isnewtailue}', ""); +Expect(0, 6569, '\P{isnewtailue}', ""); +Expect(1, 6569, '\P{^isnewtailue}', ""); +Expect(0, 6527, '\p{isnewtailue}', ""); +Expect(1, 6527, '\p{^isnewtailue}', ""); +Expect(1, 6527, '\P{isnewtailue}', ""); +Expect(0, 6527, '\P{^isnewtailue}', ""); +Expect(1, 6569, '\p{ ISNEWTAI-Lue}', ""); +Expect(0, 6569, '\p{^ ISNEWTAI-Lue}', ""); +Expect(0, 6569, '\P{ ISNEWTAI-Lue}', ""); +Expect(1, 6569, '\P{^ ISNEWTAI-Lue}', ""); +Expect(0, 6527, '\p{ ISNEWTAI-Lue}', ""); +Expect(1, 6527, '\p{^ ISNEWTAI-Lue}', ""); +Expect(1, 6527, '\P{ ISNEWTAI-Lue}', ""); +Expect(0, 6527, '\P{^ ISNEWTAI-Lue}', ""); +Error('\p{ -talu/a/}'); +Error('\P{ -talu/a/}'); +Expect(1, 6569, '\p{talu}', ""); +Expect(0, 6569, '\p{^talu}', ""); +Expect(0, 6569, '\P{talu}', ""); +Expect(1, 6569, '\P{^talu}', ""); +Expect(0, 6527, '\p{talu}', ""); +Expect(1, 6527, '\p{^talu}', ""); +Expect(1, 6527, '\P{talu}', ""); +Expect(0, 6527, '\P{^talu}', ""); +Expect(1, 6569, '\p{_-Talu}', ""); +Expect(0, 6569, '\p{^_-Talu}', ""); +Expect(0, 6569, '\P{_-Talu}', ""); +Expect(1, 6569, '\P{^_-Talu}', ""); +Expect(0, 6527, '\p{_-Talu}', ""); +Expect(1, 6527, '\p{^_-Talu}', ""); +Expect(1, 6527, '\P{_-Talu}', ""); +Expect(0, 6527, '\P{^_-Talu}', ""); +Error('\p{ -is/a/Talu}'); +Error('\P{ -is/a/Talu}'); +Expect(1, 6569, '\p{istalu}', ""); +Expect(0, 6569, '\p{^istalu}', ""); +Expect(0, 6569, '\P{istalu}', ""); +Expect(1, 6569, '\P{^istalu}', ""); +Expect(0, 6527, '\p{istalu}', ""); +Expect(1, 6527, '\p{^istalu}', ""); +Expect(1, 6527, '\P{istalu}', ""); +Expect(0, 6527, '\P{^istalu}', ""); +Expect(1, 6569, '\p{-IS talu}', ""); +Expect(0, 6569, '\p{^-IS talu}', ""); +Expect(0, 6569, '\P{-IS talu}', ""); +Expect(1, 6569, '\P{^-IS talu}', ""); +Expect(0, 6527, '\p{-IS talu}', ""); +Expect(1, 6527, '\p{^-IS talu}', ""); +Expect(1, 6527, '\P{-IS talu}', ""); +Expect(0, 6527, '\P{^-IS talu}', ""); +Error('\p{ unassigned:=}'); +Error('\P{ unassigned:=}'); +Expect(1, 889, '\p{unassigned}', ""); +Expect(0, 889, '\p{^unassigned}', ""); +Expect(0, 889, '\P{unassigned}', ""); +Expect(1, 889, '\P{^unassigned}', ""); +Expect(0, 887, '\p{unassigned}', ""); +Expect(1, 887, '\p{^unassigned}', ""); +Expect(1, 887, '\P{unassigned}', ""); +Expect(0, 887, '\P{^unassigned}', ""); +Expect(1, 889, '\p{ Unassigned}', ""); +Expect(0, 889, '\p{^ Unassigned}', ""); +Expect(0, 889, '\P{ Unassigned}', ""); +Expect(1, 889, '\P{^ Unassigned}', ""); +Expect(0, 887, '\p{ Unassigned}', ""); +Expect(1, 887, '\p{^ Unassigned}', ""); +Expect(1, 887, '\P{ Unassigned}', ""); +Expect(0, 887, '\P{^ Unassigned}', ""); +Error('\p{ /a/isUnassigned}'); +Error('\P{ /a/isUnassigned}'); +Expect(1, 889, '\p{isunassigned}', ""); +Expect(0, 889, '\p{^isunassigned}', ""); +Expect(0, 889, '\P{isunassigned}', ""); +Expect(1, 889, '\P{^isunassigned}', ""); +Expect(0, 887, '\p{isunassigned}', ""); +Expect(1, 887, '\p{^isunassigned}', ""); +Expect(1, 887, '\P{isunassigned}', ""); +Expect(0, 887, '\P{^isunassigned}', ""); +Expect(1, 889, '\p{-IsUNASSIGNED}', ""); +Expect(0, 889, '\p{^-IsUNASSIGNED}', ""); +Expect(0, 889, '\P{-IsUNASSIGNED}', ""); +Expect(1, 889, '\P{^-IsUNASSIGNED}', ""); +Expect(0, 887, '\p{-IsUNASSIGNED}', ""); +Expect(1, 887, '\p{^-IsUNASSIGNED}', ""); +Expect(1, 887, '\P{-IsUNASSIGNED}', ""); +Expect(0, 887, '\P{^-IsUNASSIGNED}', ""); +Error('\p{:= CN}'); +Error('\P{:= CN}'); +Expect(1, 889, '\p{cn}', ""); +Expect(0, 889, '\p{^cn}', ""); +Expect(0, 889, '\P{cn}', ""); +Expect(1, 889, '\P{^cn}', ""); +Expect(0, 887, '\p{cn}', ""); +Expect(1, 887, '\p{^cn}', ""); +Expect(1, 887, '\P{cn}', ""); +Expect(0, 887, '\P{^cn}', ""); +Expect(1, 889, '\p{_cn}', ""); +Expect(0, 889, '\p{^_cn}', ""); +Expect(0, 889, '\P{_cn}', ""); +Expect(1, 889, '\P{^_cn}', ""); +Expect(0, 887, '\p{_cn}', ""); +Expect(1, 887, '\p{^_cn}', ""); +Expect(1, 887, '\P{_cn}', ""); +Expect(0, 887, '\P{^_cn}', ""); +Error('\p{/a/is Cn}'); +Error('\P{/a/is Cn}'); +Expect(1, 889, '\p{iscn}', ""); +Expect(0, 889, '\p{^iscn}', ""); +Expect(0, 889, '\P{iscn}', ""); +Expect(1, 889, '\P{^iscn}', ""); +Expect(0, 887, '\p{iscn}', ""); +Expect(1, 887, '\p{^iscn}', ""); +Expect(1, 887, '\P{iscn}', ""); +Expect(0, 887, '\P{^iscn}', ""); +Expect(1, 889, '\p{_-is_Cn}', ""); +Expect(0, 889, '\p{^_-is_Cn}', ""); +Expect(0, 889, '\P{_-is_Cn}', ""); +Expect(1, 889, '\P{^_-is_Cn}', ""); +Expect(0, 887, '\p{_-is_Cn}', ""); +Expect(1, 887, '\p{^_-is_Cn}', ""); +Expect(1, 887, '\P{_-is_Cn}', ""); +Expect(0, 887, '\P{^_-is_Cn}', ""); +Error('\p{:= Lepcha}'); +Error('\P{:= Lepcha}'); +Expect(1, 7223, '\p{lepcha}', ""); +Expect(0, 7223, '\p{^lepcha}', ""); +Expect(0, 7223, '\P{lepcha}', ""); +Expect(1, 7223, '\P{^lepcha}', ""); +Expect(0, 7167, '\p{lepcha}', ""); +Expect(1, 7167, '\p{^lepcha}', ""); +Expect(1, 7167, '\P{lepcha}', ""); +Expect(0, 7167, '\P{^lepcha}', ""); +Expect(1, 7223, '\p{ -LEPCHA}', ""); +Expect(0, 7223, '\p{^ -LEPCHA}', ""); +Expect(0, 7223, '\P{ -LEPCHA}', ""); +Expect(1, 7223, '\P{^ -LEPCHA}', ""); +Expect(0, 7167, '\p{ -LEPCHA}', ""); +Expect(1, 7167, '\p{^ -LEPCHA}', ""); +Expect(1, 7167, '\P{ -LEPCHA}', ""); +Expect(0, 7167, '\P{^ -LEPCHA}', ""); +Error('\p{/a/_Is Lepcha}'); +Error('\P{/a/_Is Lepcha}'); +Expect(1, 7223, '\p{islepcha}', ""); +Expect(0, 7223, '\p{^islepcha}', ""); +Expect(0, 7223, '\P{islepcha}', ""); +Expect(1, 7223, '\P{^islepcha}', ""); +Expect(0, 7167, '\p{islepcha}', ""); +Expect(1, 7167, '\p{^islepcha}', ""); +Expect(1, 7167, '\P{islepcha}', ""); +Expect(0, 7167, '\P{^islepcha}', ""); +Expect(1, 7223, '\p{-IS_Lepcha}', ""); +Expect(0, 7223, '\p{^-IS_Lepcha}', ""); +Expect(0, 7223, '\P{-IS_Lepcha}', ""); +Expect(1, 7223, '\P{^-IS_Lepcha}', ""); +Expect(0, 7167, '\p{-IS_Lepcha}', ""); +Expect(1, 7167, '\p{^-IS_Lepcha}', ""); +Expect(1, 7167, '\P{-IS_Lepcha}', ""); +Expect(0, 7167, '\P{^-IS_Lepcha}', ""); +Error('\p{_LEPC:=}'); +Error('\P{_LEPC:=}'); +Expect(1, 7223, '\p{lepc}', ""); +Expect(0, 7223, '\p{^lepc}', ""); +Expect(0, 7223, '\P{lepc}', ""); +Expect(1, 7223, '\P{^lepc}', ""); +Expect(0, 7167, '\p{lepc}', ""); +Expect(1, 7167, '\p{^lepc}', ""); +Expect(1, 7167, '\P{lepc}', ""); +Expect(0, 7167, '\P{^lepc}', ""); +Expect(1, 7223, '\p{ LEPC}', ""); +Expect(0, 7223, '\p{^ LEPC}', ""); +Expect(0, 7223, '\P{ LEPC}', ""); +Expect(1, 7223, '\P{^ LEPC}', ""); +Expect(0, 7167, '\p{ LEPC}', ""); +Expect(1, 7167, '\p{^ LEPC}', ""); +Expect(1, 7167, '\P{ LEPC}', ""); +Expect(0, 7167, '\P{^ LEPC}', ""); +Error('\p{_ is:=Lepc}'); +Error('\P{_ is:=Lepc}'); +Expect(1, 7223, '\p{islepc}', ""); +Expect(0, 7223, '\p{^islepc}', ""); +Expect(0, 7223, '\P{islepc}', ""); +Expect(1, 7223, '\P{^islepc}', ""); +Expect(0, 7167, '\p{islepc}', ""); +Expect(1, 7167, '\p{^islepc}', ""); +Expect(1, 7167, '\P{islepc}', ""); +Expect(0, 7167, '\P{^islepc}', ""); +Expect(1, 7223, '\p{ ISLEPC}', ""); +Expect(0, 7223, '\p{^ ISLEPC}', ""); +Expect(0, 7223, '\P{ ISLEPC}', ""); +Expect(1, 7223, '\P{^ ISLEPC}', ""); +Expect(0, 7167, '\p{ ISLEPC}', ""); +Expect(1, 7167, '\p{^ ISLEPC}', ""); +Expect(1, 7167, '\P{ ISLEPC}', ""); +Expect(0, 7167, '\P{^ ISLEPC}', ""); +Error('\p{_:=IDEOGRAPHIC description_characters}'); +Error('\P{_:=IDEOGRAPHIC description_characters}'); +Expect(1, 12287, '\p{ideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\p{^ideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\P{ideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\P{^ideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\p{ideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\p{^ideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\P{ideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\P{^ideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\p{ Ideographic_Description-CHARACTERS}', ""); +Expect(0, 12287, '\p{^ Ideographic_Description-CHARACTERS}', ""); +Expect(0, 12287, '\P{ Ideographic_Description-CHARACTERS}', ""); +Expect(1, 12287, '\P{^ Ideographic_Description-CHARACTERS}', ""); +Expect(0, 12271, '\p{ Ideographic_Description-CHARACTERS}', ""); +Expect(1, 12271, '\p{^ Ideographic_Description-CHARACTERS}', ""); +Expect(1, 12271, '\P{ Ideographic_Description-CHARACTERS}', ""); +Expect(0, 12271, '\P{^ Ideographic_Description-CHARACTERS}', ""); +Error('\p{_:=Is-ideographicDESCRIPTION-characters}'); +Error('\P{_:=Is-ideographicDESCRIPTION-characters}'); +Expect(1, 12287, '\p{isideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\p{^isideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\P{isideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\P{^isideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\p{isideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\p{^isideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\P{isideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\P{^isideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\p{ IsIDEOGRAPHIC description characters}', ""); +Expect(0, 12287, '\p{^ IsIDEOGRAPHIC description characters}', ""); +Expect(0, 12287, '\P{ IsIDEOGRAPHIC description characters}', ""); +Expect(1, 12287, '\P{^ IsIDEOGRAPHIC description characters}', ""); +Expect(0, 12271, '\p{ IsIDEOGRAPHIC description characters}', ""); +Expect(1, 12271, '\p{^ IsIDEOGRAPHIC description characters}', ""); +Expect(1, 12271, '\P{ IsIDEOGRAPHIC description characters}', ""); +Expect(0, 12271, '\P{^ IsIDEOGRAPHIC description characters}', ""); +Error('\p{-In/a/Ideographic_Description_Characters}'); +Error('\P{-In/a/Ideographic_Description_Characters}'); +Expect(1, 12287, '\p{inideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\p{^inideographicdescriptioncharacters}', ""); +Expect(0, 12287, '\P{inideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\P{^inideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\p{inideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\p{^inideographicdescriptioncharacters}', ""); +Expect(1, 12271, '\P{inideographicdescriptioncharacters}', ""); +Expect(0, 12271, '\P{^inideographicdescriptioncharacters}', ""); +Expect(1, 12287, '\p{- IN ideographic description-characters}', ""); +Expect(0, 12287, '\p{^- IN ideographic description-characters}', ""); +Expect(0, 12287, '\P{- IN ideographic description-characters}', ""); +Expect(1, 12287, '\P{^- IN ideographic description-characters}', ""); +Expect(0, 12271, '\p{- IN ideographic description-characters}', ""); +Expect(1, 12271, '\p{^- IN ideographic description-characters}', ""); +Expect(1, 12271, '\P{- IN ideographic description-characters}', ""); +Expect(0, 12271, '\P{^- IN ideographic description-characters}', ""); +Error('\p{ Combining-Half_Marks:=}'); +Error('\P{ Combining-Half_Marks:=}'); +Expect(1, 65071, '\p{combininghalfmarks}', ""); +Expect(0, 65071, '\p{^combininghalfmarks}', ""); +Expect(0, 65071, '\P{combininghalfmarks}', ""); +Expect(1, 65071, '\P{^combininghalfmarks}', ""); +Expect(0, 65055, '\p{combininghalfmarks}', ""); +Expect(1, 65055, '\p{^combininghalfmarks}', ""); +Expect(1, 65055, '\P{combininghalfmarks}', ""); +Expect(0, 65055, '\P{^combininghalfmarks}', ""); +Expect(1, 65071, '\p{ _combiningHalf Marks}', ""); +Expect(0, 65071, '\p{^ _combiningHalf Marks}', ""); +Expect(0, 65071, '\P{ _combiningHalf Marks}', ""); +Expect(1, 65071, '\P{^ _combiningHalf Marks}', ""); +Expect(0, 65055, '\p{ _combiningHalf Marks}', ""); +Expect(1, 65055, '\p{^ _combiningHalf Marks}', ""); +Expect(1, 65055, '\P{ _combiningHalf Marks}', ""); +Expect(0, 65055, '\P{^ _combiningHalf Marks}', ""); +Error('\p{_-is_combining HALF MARKS:=}'); +Error('\P{_-is_combining HALF MARKS:=}'); +Expect(1, 65071, '\p{iscombininghalfmarks}', ""); +Expect(0, 65071, '\p{^iscombininghalfmarks}', ""); +Expect(0, 65071, '\P{iscombininghalfmarks}', ""); +Expect(1, 65071, '\P{^iscombininghalfmarks}', ""); +Expect(0, 65055, '\p{iscombininghalfmarks}', ""); +Expect(1, 65055, '\p{^iscombininghalfmarks}', ""); +Expect(1, 65055, '\P{iscombininghalfmarks}', ""); +Expect(0, 65055, '\P{^iscombininghalfmarks}', ""); +Expect(1, 65071, '\p{ -Is_COMBINING Half_MARKS}', ""); +Expect(0, 65071, '\p{^ -Is_COMBINING Half_MARKS}', ""); +Expect(0, 65071, '\P{ -Is_COMBINING Half_MARKS}', ""); +Expect(1, 65071, '\P{^ -Is_COMBINING Half_MARKS}', ""); +Expect(0, 65055, '\p{ -Is_COMBINING Half_MARKS}', ""); +Expect(1, 65055, '\p{^ -Is_COMBINING Half_MARKS}', ""); +Expect(1, 65055, '\P{ -Is_COMBINING Half_MARKS}', ""); +Expect(0, 65055, '\P{^ -Is_COMBINING Half_MARKS}', ""); +Error('\p{-_in_CombiningHalf-Marks:=}'); +Error('\P{-_in_CombiningHalf-Marks:=}'); +Expect(1, 65071, '\p{incombininghalfmarks}', ""); +Expect(0, 65071, '\p{^incombininghalfmarks}', ""); +Expect(0, 65071, '\P{incombininghalfmarks}', ""); +Expect(1, 65071, '\P{^incombininghalfmarks}', ""); +Expect(0, 65055, '\p{incombininghalfmarks}', ""); +Expect(1, 65055, '\p{^incombininghalfmarks}', ""); +Expect(1, 65055, '\P{incombininghalfmarks}', ""); +Expect(0, 65055, '\P{^incombininghalfmarks}', ""); +Expect(1, 65071, '\p{ In_combining-Half Marks}', ""); +Expect(0, 65071, '\p{^ In_combining-Half Marks}', ""); +Expect(0, 65071, '\P{ In_combining-Half Marks}', ""); +Expect(1, 65071, '\P{^ In_combining-Half Marks}', ""); +Expect(0, 65055, '\p{ In_combining-Half Marks}', ""); +Expect(1, 65055, '\p{^ In_combining-Half Marks}', ""); +Expect(1, 65055, '\P{ In_combining-Half Marks}', ""); +Expect(0, 65055, '\P{^ In_combining-Half Marks}', ""); +Error('\p{ /a/Oriya}'); +Error('\P{ /a/Oriya}'); +Expect(1, 2819, '\p{oriya}', ""); +Expect(0, 2819, '\p{^oriya}', ""); +Expect(0, 2819, '\P{oriya}', ""); +Expect(1, 2819, '\P{^oriya}', ""); +Expect(0, 2816, '\p{oriya}', ""); +Expect(1, 2816, '\p{^oriya}', ""); +Expect(1, 2816, '\P{oriya}', ""); +Expect(0, 2816, '\P{^oriya}', ""); +Expect(1, 2819, '\p{_ORIYA}', ""); +Expect(0, 2819, '\p{^_ORIYA}', ""); +Expect(0, 2819, '\P{_ORIYA}', ""); +Expect(1, 2819, '\P{^_ORIYA}', ""); +Expect(0, 2816, '\p{_ORIYA}', ""); +Expect(1, 2816, '\p{^_ORIYA}', ""); +Expect(1, 2816, '\P{_ORIYA}', ""); +Expect(0, 2816, '\P{^_ORIYA}', ""); +Error('\p{ IS/a/Oriya}'); +Error('\P{ IS/a/Oriya}'); +Expect(1, 2819, '\p{isoriya}', ""); +Expect(0, 2819, '\p{^isoriya}', ""); +Expect(0, 2819, '\P{isoriya}', ""); +Expect(1, 2819, '\P{^isoriya}', ""); +Expect(0, 2816, '\p{isoriya}', ""); +Expect(1, 2816, '\p{^isoriya}', ""); +Expect(1, 2816, '\P{isoriya}', ""); +Expect(0, 2816, '\P{^isoriya}', ""); +Expect(1, 2819, '\p{- Is Oriya}', ""); +Expect(0, 2819, '\p{^- Is Oriya}', ""); +Expect(0, 2819, '\P{- Is Oriya}', ""); +Expect(1, 2819, '\P{^- Is Oriya}', ""); +Expect(0, 2816, '\p{- Is Oriya}', ""); +Expect(1, 2816, '\p{^- Is Oriya}', ""); +Expect(1, 2816, '\P{- Is Oriya}', ""); +Expect(0, 2816, '\P{^- Is Oriya}', ""); +Error('\p{ /a/orya}'); +Error('\P{ /a/orya}'); +Expect(1, 2819, '\p{orya}', ""); +Expect(0, 2819, '\p{^orya}', ""); +Expect(0, 2819, '\P{orya}', ""); +Expect(1, 2819, '\P{^orya}', ""); +Expect(0, 2816, '\p{orya}', ""); +Expect(1, 2816, '\p{^orya}', ""); +Expect(1, 2816, '\P{orya}', ""); +Expect(0, 2816, '\P{^orya}', ""); +Expect(1, 2819, '\p{ orya}', ""); +Expect(0, 2819, '\p{^ orya}', ""); +Expect(0, 2819, '\P{ orya}', ""); +Expect(1, 2819, '\P{^ orya}', ""); +Expect(0, 2816, '\p{ orya}', ""); +Expect(1, 2816, '\p{^ orya}', ""); +Expect(1, 2816, '\P{ orya}', ""); +Expect(0, 2816, '\P{^ orya}', ""); +Error('\p{ IS/a/ORYA}'); +Error('\P{ IS/a/ORYA}'); +Expect(1, 2819, '\p{isorya}', ""); +Expect(0, 2819, '\p{^isorya}', ""); +Expect(0, 2819, '\P{isorya}', ""); +Expect(1, 2819, '\P{^isorya}', ""); +Expect(0, 2816, '\p{isorya}', ""); +Expect(1, 2816, '\p{^isorya}', ""); +Expect(1, 2816, '\P{isorya}', ""); +Expect(0, 2816, '\P{^isorya}', ""); +Expect(1, 2819, '\p{ isorya}', ""); +Expect(0, 2819, '\p{^ isorya}', ""); +Expect(0, 2819, '\P{ isorya}', ""); +Expect(1, 2819, '\P{^ isorya}', ""); +Expect(0, 2816, '\p{ isorya}', ""); +Expect(1, 2816, '\p{^ isorya}', ""); +Expect(1, 2816, '\P{ isorya}', ""); +Expect(0, 2816, '\P{^ isorya}', ""); +Error('\p{__Phonetic_extensions/a/}'); +Error('\P{__Phonetic_extensions/a/}'); +Expect(1, 7551, '\p{phoneticextensions}', ""); +Expect(0, 7551, '\p{^phoneticextensions}', ""); +Expect(0, 7551, '\P{phoneticextensions}', ""); +Expect(1, 7551, '\P{^phoneticextensions}', ""); +Expect(0, 7423, '\p{phoneticextensions}', ""); +Expect(1, 7423, '\p{^phoneticextensions}', ""); +Expect(1, 7423, '\P{phoneticextensions}', ""); +Expect(0, 7423, '\P{^phoneticextensions}', ""); +Expect(1, 7551, '\p{ phonetic-Extensions}', ""); +Expect(0, 7551, '\p{^ phonetic-Extensions}', ""); +Expect(0, 7551, '\P{ phonetic-Extensions}', ""); +Expect(1, 7551, '\P{^ phonetic-Extensions}', ""); +Expect(0, 7423, '\p{ phonetic-Extensions}', ""); +Expect(1, 7423, '\p{^ phonetic-Extensions}', ""); +Expect(1, 7423, '\P{ phonetic-Extensions}', ""); +Expect(0, 7423, '\P{^ phonetic-Extensions}', ""); +Error('\p{ :=Is_Phonetic-EXTENSIONS}'); +Error('\P{ :=Is_Phonetic-EXTENSIONS}'); +Expect(1, 7551, '\p{isphoneticextensions}', ""); +Expect(0, 7551, '\p{^isphoneticextensions}', ""); +Expect(0, 7551, '\P{isphoneticextensions}', ""); +Expect(1, 7551, '\P{^isphoneticextensions}', ""); +Expect(0, 7423, '\p{isphoneticextensions}', ""); +Expect(1, 7423, '\p{^isphoneticextensions}', ""); +Expect(1, 7423, '\P{isphoneticextensions}', ""); +Expect(0, 7423, '\P{^isphoneticextensions}', ""); +Expect(1, 7551, '\p{-IS Phonetic extensions}', ""); +Expect(0, 7551, '\p{^-IS Phonetic extensions}', ""); +Expect(0, 7551, '\P{-IS Phonetic extensions}', ""); +Expect(1, 7551, '\P{^-IS Phonetic extensions}', ""); +Expect(0, 7423, '\p{-IS Phonetic extensions}', ""); +Expect(1, 7423, '\p{^-IS Phonetic extensions}', ""); +Expect(1, 7423, '\P{-IS Phonetic extensions}', ""); +Expect(0, 7423, '\P{^-IS Phonetic extensions}', ""); +Error('\p{:= _In_phonetic EXTENSIONS}'); +Error('\P{:= _In_phonetic EXTENSIONS}'); +Expect(1, 7551, '\p{inphoneticextensions}', ""); +Expect(0, 7551, '\p{^inphoneticextensions}', ""); +Expect(0, 7551, '\P{inphoneticextensions}', ""); +Expect(1, 7551, '\P{^inphoneticextensions}', ""); +Expect(0, 7423, '\p{inphoneticextensions}', ""); +Expect(1, 7423, '\p{^inphoneticextensions}', ""); +Expect(1, 7423, '\P{inphoneticextensions}', ""); +Expect(0, 7423, '\P{^inphoneticextensions}', ""); +Expect(1, 7551, '\p{_In phonetic Extensions}', ""); +Expect(0, 7551, '\p{^_In phonetic Extensions}', ""); +Expect(0, 7551, '\P{_In phonetic Extensions}', ""); +Expect(1, 7551, '\P{^_In phonetic Extensions}', ""); +Expect(0, 7423, '\p{_In phonetic Extensions}', ""); +Expect(1, 7423, '\p{^_In phonetic Extensions}', ""); +Expect(1, 7423, '\P{_In phonetic Extensions}', ""); +Expect(0, 7423, '\P{^_In phonetic Extensions}', ""); +Error('\p{/a/_ Grapheme extend}'); +Error('\P{/a/_ Grapheme extend}'); +Expect(1, 879, '\p{graphemeextend}', ""); +Expect(0, 879, '\p{^graphemeextend}', ""); +Expect(0, 879, '\P{graphemeextend}', ""); +Expect(1, 879, '\P{^graphemeextend}', ""); +Expect(0, 767, '\p{graphemeextend}', ""); +Expect(1, 767, '\p{^graphemeextend}', ""); +Expect(1, 767, '\P{graphemeextend}', ""); +Expect(0, 767, '\P{^graphemeextend}', ""); +Expect(1, 879, '\p{ Grapheme Extend}', ""); +Expect(0, 879, '\p{^ Grapheme Extend}', ""); +Expect(0, 879, '\P{ Grapheme Extend}', ""); +Expect(1, 879, '\P{^ Grapheme Extend}', ""); +Expect(0, 767, '\p{ Grapheme Extend}', ""); +Expect(1, 767, '\p{^ Grapheme Extend}', ""); +Expect(1, 767, '\P{ Grapheme Extend}', ""); +Expect(0, 767, '\P{^ Grapheme Extend}', ""); +Error('\p{_:=is graphemeExtend}'); +Error('\P{_:=is graphemeExtend}'); +Expect(1, 879, '\p{isgraphemeextend}', ""); +Expect(0, 879, '\p{^isgraphemeextend}', ""); +Expect(0, 879, '\P{isgraphemeextend}', ""); +Expect(1, 879, '\P{^isgraphemeextend}', ""); +Expect(0, 767, '\p{isgraphemeextend}', ""); +Expect(1, 767, '\p{^isgraphemeextend}', ""); +Expect(1, 767, '\P{isgraphemeextend}', ""); +Expect(0, 767, '\P{^isgraphemeextend}', ""); +Expect(1, 879, '\p{ Is grapheme-EXTEND}', ""); +Expect(0, 879, '\p{^ Is grapheme-EXTEND}', ""); +Expect(0, 879, '\P{ Is grapheme-EXTEND}', ""); +Expect(1, 879, '\P{^ Is grapheme-EXTEND}', ""); +Expect(0, 767, '\p{ Is grapheme-EXTEND}', ""); +Expect(1, 767, '\p{^ Is grapheme-EXTEND}', ""); +Expect(1, 767, '\P{ Is grapheme-EXTEND}', ""); +Expect(0, 767, '\P{^ Is grapheme-EXTEND}', ""); +Error('\p{ _Gr EXT:=}'); +Error('\P{ _Gr EXT:=}'); +Expect(1, 879, '\p{grext}', ""); +Expect(0, 879, '\p{^grext}', ""); +Expect(0, 879, '\P{grext}', ""); +Expect(1, 879, '\P{^grext}', ""); +Expect(0, 767, '\p{grext}', ""); +Expect(1, 767, '\p{^grext}', ""); +Expect(1, 767, '\P{grext}', ""); +Expect(0, 767, '\P{^grext}', ""); +Expect(1, 879, '\p{ Gr-ext}', ""); +Expect(0, 879, '\p{^ Gr-ext}', ""); +Expect(0, 879, '\P{ Gr-ext}', ""); +Expect(1, 879, '\P{^ Gr-ext}', ""); +Expect(0, 767, '\p{ Gr-ext}', ""); +Expect(1, 767, '\p{^ Gr-ext}', ""); +Expect(1, 767, '\P{ Gr-ext}', ""); +Expect(0, 767, '\P{^ Gr-ext}', ""); +Error('\p{ :=IS GrExt}'); +Error('\P{ :=IS GrExt}'); +Expect(1, 879, '\p{isgrext}', ""); +Expect(0, 879, '\p{^isgrext}', ""); +Expect(0, 879, '\P{isgrext}', ""); +Expect(1, 879, '\P{^isgrext}', ""); +Expect(0, 767, '\p{isgrext}', ""); +Expect(1, 767, '\p{^isgrext}', ""); +Expect(1, 767, '\P{isgrext}', ""); +Expect(0, 767, '\P{^isgrext}', ""); +Expect(1, 879, '\p{- Is-Gr-EXT}', ""); +Expect(0, 879, '\p{^- Is-Gr-EXT}', ""); +Expect(0, 879, '\P{- Is-Gr-EXT}', ""); +Expect(1, 879, '\P{^- Is-Gr-EXT}', ""); +Expect(0, 767, '\p{- Is-Gr-EXT}', ""); +Expect(1, 767, '\p{^- Is-Gr-EXT}', ""); +Expect(1, 767, '\P{- Is-Gr-EXT}', ""); +Expect(0, 767, '\P{^- Is-Gr-EXT}', ""); +Error('\p{_ default-IGNORABLE_code/a/point}'); +Error('\P{_ default-IGNORABLE_code/a/point}'); +Expect(1, 847, '\p{defaultignorablecodepoint}', ""); +Expect(0, 847, '\p{^defaultignorablecodepoint}', ""); +Expect(0, 847, '\P{defaultignorablecodepoint}', ""); +Expect(1, 847, '\P{^defaultignorablecodepoint}', ""); +Expect(0, 7, '\p{defaultignorablecodepoint}', ""); +Expect(1, 7, '\p{^defaultignorablecodepoint}', ""); +Expect(1, 7, '\P{defaultignorablecodepoint}', ""); +Expect(0, 7, '\P{^defaultignorablecodepoint}', ""); +Expect(1, 847, '\p{ Default ignorable Code Point}', ""); +Expect(0, 847, '\p{^ Default ignorable Code Point}', ""); +Expect(0, 847, '\P{ Default ignorable Code Point}', ""); +Expect(1, 847, '\P{^ Default ignorable Code Point}', ""); +Expect(0, 7, '\p{ Default ignorable Code Point}', ""); +Expect(1, 7, '\p{^ Default ignorable Code Point}', ""); +Expect(1, 7, '\P{ Default ignorable Code Point}', ""); +Expect(0, 7, '\P{^ Default ignorable Code Point}', ""); +Error('\p{_:=ISdefault Ignorable CodePOINT}'); +Error('\P{_:=ISdefault Ignorable CodePOINT}'); +Expect(1, 847, '\p{isdefaultignorablecodepoint}', ""); +Expect(0, 847, '\p{^isdefaultignorablecodepoint}', ""); +Expect(0, 847, '\P{isdefaultignorablecodepoint}', ""); +Expect(1, 847, '\P{^isdefaultignorablecodepoint}', ""); +Expect(0, 7, '\p{isdefaultignorablecodepoint}', ""); +Expect(1, 7, '\p{^isdefaultignorablecodepoint}', ""); +Expect(1, 7, '\P{isdefaultignorablecodepoint}', ""); +Expect(0, 7, '\P{^isdefaultignorablecodepoint}', ""); +Expect(1, 847, '\p{__Isdefault ignorable Code-point}', ""); +Expect(0, 847, '\p{^__Isdefault ignorable Code-point}', ""); +Expect(0, 847, '\P{__Isdefault ignorable Code-point}', ""); +Expect(1, 847, '\P{^__Isdefault ignorable Code-point}', ""); +Expect(0, 7, '\p{__Isdefault ignorable Code-point}', ""); +Expect(1, 7, '\p{^__Isdefault ignorable Code-point}', ""); +Expect(1, 7, '\P{__Isdefault ignorable Code-point}', ""); +Expect(0, 7, '\P{^__Isdefault ignorable Code-point}', ""); +Error('\p{/a/ DI}'); +Error('\P{/a/ DI}'); +Expect(1, 847, '\p{di}', ""); +Expect(0, 847, '\p{^di}', ""); +Expect(0, 847, '\P{di}', ""); +Expect(1, 847, '\P{^di}', ""); +Expect(0, 7, '\p{di}', ""); +Expect(1, 7, '\p{^di}', ""); +Expect(1, 7, '\P{di}', ""); +Expect(0, 7, '\P{^di}', ""); +Expect(1, 847, '\p{ DI}', ""); +Expect(0, 847, '\p{^ DI}', ""); +Expect(0, 847, '\P{ DI}', ""); +Expect(1, 847, '\P{^ DI}', ""); +Expect(0, 7, '\p{ DI}', ""); +Expect(1, 7, '\p{^ DI}', ""); +Expect(1, 7, '\P{ DI}', ""); +Expect(0, 7, '\P{^ DI}', ""); +Error('\p{-/a/isDI}'); +Error('\P{-/a/isDI}'); +Expect(1, 847, '\p{isdi}', ""); +Expect(0, 847, '\p{^isdi}', ""); +Expect(0, 847, '\P{isdi}', ""); +Expect(1, 847, '\P{^isdi}', ""); +Expect(0, 7, '\p{isdi}', ""); +Expect(1, 7, '\p{^isdi}', ""); +Expect(1, 7, '\P{isdi}', ""); +Expect(0, 7, '\P{^isdi}', ""); +Expect(1, 847, '\p{ Is DI}', ""); +Expect(0, 847, '\p{^ Is DI}', ""); +Expect(0, 847, '\P{ Is DI}', ""); +Expect(1, 847, '\P{^ Is DI}', ""); +Expect(0, 7, '\p{ Is DI}', ""); +Expect(1, 7, '\p{^ Is DI}', ""); +Expect(1, 7, '\P{ Is DI}', ""); +Expect(0, 7, '\P{^ Is DI}', ""); +Error('\p{ID/a/Start}'); +Error('\P{ID/a/Start}'); +Expect(1, 90, '\p{idstart}', ""); +Expect(0, 90, '\p{^idstart}', ""); +Expect(0, 90, '\P{idstart}', ""); +Expect(1, 90, '\P{^idstart}', ""); +Expect(0, 64, '\p{idstart}', ""); +Expect(1, 64, '\p{^idstart}', ""); +Expect(1, 64, '\P{idstart}', ""); +Expect(0, 64, '\P{^idstart}', ""); +Expect(1, 90, '\p{__ID START}', ""); +Expect(0, 90, '\p{^__ID START}', ""); +Expect(0, 90, '\P{__ID START}', ""); +Expect(1, 90, '\P{^__ID START}', ""); +Expect(0, 64, '\p{__ID START}', ""); +Expect(1, 64, '\p{^__ID START}', ""); +Expect(1, 64, '\P{__ID START}', ""); +Expect(0, 64, '\P{^__ID START}', ""); +Error('\p{-Is IDStart:=}'); +Error('\P{-Is IDStart:=}'); +Expect(1, 90, '\p{isidstart}', ""); +Expect(0, 90, '\p{^isidstart}', ""); +Expect(0, 90, '\P{isidstart}', ""); +Expect(1, 90, '\P{^isidstart}', ""); +Expect(0, 64, '\p{isidstart}', ""); +Expect(1, 64, '\p{^isidstart}', ""); +Expect(1, 64, '\P{isidstart}', ""); +Expect(0, 64, '\P{^isidstart}', ""); +Expect(1, 90, '\p{_IS ID_Start}', ""); +Expect(0, 90, '\p{^_IS ID_Start}', ""); +Expect(0, 90, '\P{_IS ID_Start}', ""); +Expect(1, 90, '\P{^_IS ID_Start}', ""); +Expect(0, 64, '\p{_IS ID_Start}', ""); +Expect(1, 64, '\p{^_IS ID_Start}', ""); +Expect(1, 64, '\P{_IS ID_Start}', ""); +Expect(0, 64, '\P{^_IS ID_Start}', ""); +Error('\p{_:=IDS}'); +Error('\P{_:=IDS}'); +Expect(1, 90, '\p{ids}', ""); +Expect(0, 90, '\p{^ids}', ""); +Expect(0, 90, '\P{ids}', ""); +Expect(1, 90, '\P{^ids}', ""); +Expect(0, 64, '\p{ids}', ""); +Expect(1, 64, '\p{^ids}', ""); +Expect(1, 64, '\P{ids}', ""); +Expect(0, 64, '\P{^ids}', ""); +Expect(1, 90, '\p{_ ids}', ""); +Expect(0, 90, '\p{^_ ids}', ""); +Expect(0, 90, '\P{_ ids}', ""); +Expect(1, 90, '\P{^_ ids}', ""); +Expect(0, 64, '\p{_ ids}', ""); +Expect(1, 64, '\p{^_ ids}', ""); +Expect(1, 64, '\P{_ ids}', ""); +Expect(0, 64, '\P{^_ ids}', ""); +Error('\p{ :=ISIDS}'); +Error('\P{ :=ISIDS}'); +Expect(1, 90, '\p{isids}', ""); +Expect(0, 90, '\p{^isids}', ""); +Expect(0, 90, '\P{isids}', ""); +Expect(1, 90, '\P{^isids}', ""); +Expect(0, 64, '\p{isids}', ""); +Expect(1, 64, '\p{^isids}', ""); +Expect(1, 64, '\P{isids}', ""); +Expect(0, 64, '\P{^isids}', ""); +Expect(1, 90, '\p{-Is_IDS}', ""); +Expect(0, 90, '\p{^-Is_IDS}', ""); +Expect(0, 90, '\P{-Is_IDS}', ""); +Expect(1, 90, '\P{^-Is_IDS}', ""); +Expect(0, 64, '\p{-Is_IDS}', ""); +Expect(1, 64, '\p{^-Is_IDS}', ""); +Expect(1, 64, '\P{-Is_IDS}', ""); +Expect(0, 64, '\P{^-Is_IDS}', ""); +Error('\p{ /a/Cyrillic_supplement}'); +Error('\P{ /a/Cyrillic_supplement}'); +Expect(1, 1327, '\p{cyrillicsupplement}', ""); +Expect(0, 1327, '\p{^cyrillicsupplement}', ""); +Expect(0, 1327, '\P{cyrillicsupplement}', ""); +Expect(1, 1327, '\P{^cyrillicsupplement}', ""); +Expect(0, 1279, '\p{cyrillicsupplement}', ""); +Expect(1, 1279, '\p{^cyrillicsupplement}', ""); +Expect(1, 1279, '\P{cyrillicsupplement}', ""); +Expect(0, 1279, '\P{^cyrillicsupplement}', ""); +Expect(1, 1327, '\p{ -CYRILLIC Supplement}', ""); +Expect(0, 1327, '\p{^ -CYRILLIC Supplement}', ""); +Expect(0, 1327, '\P{ -CYRILLIC Supplement}', ""); +Expect(1, 1327, '\P{^ -CYRILLIC Supplement}', ""); +Expect(0, 1279, '\p{ -CYRILLIC Supplement}', ""); +Expect(1, 1279, '\p{^ -CYRILLIC Supplement}', ""); +Expect(1, 1279, '\P{ -CYRILLIC Supplement}', ""); +Expect(0, 1279, '\P{^ -CYRILLIC Supplement}', ""); +Error('\p{/a/- Is Cyrillic-supplement}'); +Error('\P{/a/- Is Cyrillic-supplement}'); +Expect(1, 1327, '\p{iscyrillicsupplement}', ""); +Expect(0, 1327, '\p{^iscyrillicsupplement}', ""); +Expect(0, 1327, '\P{iscyrillicsupplement}', ""); +Expect(1, 1327, '\P{^iscyrillicsupplement}', ""); +Expect(0, 1279, '\p{iscyrillicsupplement}', ""); +Expect(1, 1279, '\p{^iscyrillicsupplement}', ""); +Expect(1, 1279, '\P{iscyrillicsupplement}', ""); +Expect(0, 1279, '\P{^iscyrillicsupplement}', ""); +Expect(1, 1327, '\p{-Is CYRILLIC Supplement}', ""); +Expect(0, 1327, '\p{^-Is CYRILLIC Supplement}', ""); +Expect(0, 1327, '\P{-Is CYRILLIC Supplement}', ""); +Expect(1, 1327, '\P{^-Is CYRILLIC Supplement}', ""); +Expect(0, 1279, '\p{-Is CYRILLIC Supplement}', ""); +Expect(1, 1279, '\p{^-Is CYRILLIC Supplement}', ""); +Expect(1, 1279, '\P{-Is CYRILLIC Supplement}', ""); +Expect(0, 1279, '\P{^-Is CYRILLIC Supplement}', ""); +Error('\p{_in:=CYRILLIC Supplement}'); +Error('\P{_in:=CYRILLIC Supplement}'); +Expect(1, 1327, '\p{incyrillicsupplement}', ""); +Expect(0, 1327, '\p{^incyrillicsupplement}', ""); +Expect(0, 1327, '\P{incyrillicsupplement}', ""); +Expect(1, 1327, '\P{^incyrillicsupplement}', ""); +Expect(0, 1279, '\p{incyrillicsupplement}', ""); +Expect(1, 1279, '\p{^incyrillicsupplement}', ""); +Expect(1, 1279, '\P{incyrillicsupplement}', ""); +Expect(0, 1279, '\P{^incyrillicsupplement}', ""); +Expect(1, 1327, '\p{ in cyrillic-SUPPLEMENT}', ""); +Expect(0, 1327, '\p{^ in cyrillic-SUPPLEMENT}', ""); +Expect(0, 1327, '\P{ in cyrillic-SUPPLEMENT}', ""); +Expect(1, 1327, '\P{^ in cyrillic-SUPPLEMENT}', ""); +Expect(0, 1279, '\p{ in cyrillic-SUPPLEMENT}', ""); +Expect(1, 1279, '\p{^ in cyrillic-SUPPLEMENT}', ""); +Expect(1, 1279, '\P{ in cyrillic-SUPPLEMENT}', ""); +Expect(0, 1279, '\P{^ in cyrillic-SUPPLEMENT}', ""); +Error('\p{-/a/cyrillic Supplementary}'); +Error('\P{-/a/cyrillic Supplementary}'); +Expect(1, 1327, '\p{cyrillicsupplementary}', ""); +Expect(0, 1327, '\p{^cyrillicsupplementary}', ""); +Expect(0, 1327, '\P{cyrillicsupplementary}', ""); +Expect(1, 1327, '\P{^cyrillicsupplementary}', ""); +Expect(0, 1279, '\p{cyrillicsupplementary}', ""); +Expect(1, 1279, '\p{^cyrillicsupplementary}', ""); +Expect(1, 1279, '\P{cyrillicsupplementary}', ""); +Expect(0, 1279, '\P{^cyrillicsupplementary}', ""); +Expect(1, 1327, '\p{ cyrillic supplementary}', ""); +Expect(0, 1327, '\p{^ cyrillic supplementary}', ""); +Expect(0, 1327, '\P{ cyrillic supplementary}', ""); +Expect(1, 1327, '\P{^ cyrillic supplementary}', ""); +Expect(0, 1279, '\p{ cyrillic supplementary}', ""); +Expect(1, 1279, '\p{^ cyrillic supplementary}', ""); +Expect(1, 1279, '\P{ cyrillic supplementary}', ""); +Expect(0, 1279, '\P{^ cyrillic supplementary}', ""); +Error('\p{-:=Is_cyrillic-Supplementary}'); +Error('\P{-:=Is_cyrillic-Supplementary}'); +Expect(1, 1327, '\p{iscyrillicsupplementary}', ""); +Expect(0, 1327, '\p{^iscyrillicsupplementary}', ""); +Expect(0, 1327, '\P{iscyrillicsupplementary}', ""); +Expect(1, 1327, '\P{^iscyrillicsupplementary}', ""); +Expect(0, 1279, '\p{iscyrillicsupplementary}', ""); +Expect(1, 1279, '\p{^iscyrillicsupplementary}', ""); +Expect(1, 1279, '\P{iscyrillicsupplementary}', ""); +Expect(0, 1279, '\P{^iscyrillicsupplementary}', ""); +Expect(1, 1327, '\p{ ISCyrillic-Supplementary}', ""); +Expect(0, 1327, '\p{^ ISCyrillic-Supplementary}', ""); +Expect(0, 1327, '\P{ ISCyrillic-Supplementary}', ""); +Expect(1, 1327, '\P{^ ISCyrillic-Supplementary}', ""); +Expect(0, 1279, '\p{ ISCyrillic-Supplementary}', ""); +Expect(1, 1279, '\p{^ ISCyrillic-Supplementary}', ""); +Expect(1, 1279, '\P{ ISCyrillic-Supplementary}', ""); +Expect(0, 1279, '\P{^ ISCyrillic-Supplementary}', ""); +Error('\p{:=In cyrillic supplementary}'); +Error('\P{:=In cyrillic supplementary}'); +Expect(1, 1327, '\p{incyrillicsupplementary}', ""); +Expect(0, 1327, '\p{^incyrillicsupplementary}', ""); +Expect(0, 1327, '\P{incyrillicsupplementary}', ""); +Expect(1, 1327, '\P{^incyrillicsupplementary}', ""); +Expect(0, 1279, '\p{incyrillicsupplementary}', ""); +Expect(1, 1279, '\p{^incyrillicsupplementary}', ""); +Expect(1, 1279, '\P{incyrillicsupplementary}', ""); +Expect(0, 1279, '\P{^incyrillicsupplementary}', ""); +Expect(1, 1327, '\p{ IN cyrillic Supplementary}', ""); +Expect(0, 1327, '\p{^ IN cyrillic Supplementary}', ""); +Expect(0, 1327, '\P{ IN cyrillic Supplementary}', ""); +Expect(1, 1327, '\P{^ IN cyrillic Supplementary}', ""); +Expect(0, 1279, '\p{ IN cyrillic Supplementary}', ""); +Expect(1, 1279, '\p{^ IN cyrillic Supplementary}', ""); +Expect(1, 1279, '\P{ IN cyrillic Supplementary}', ""); +Expect(0, 1279, '\P{^ IN cyrillic Supplementary}', ""); +Error('\p{ -Geometric Shapes:=}'); +Error('\P{ -Geometric Shapes:=}'); +Expect(1, 9727, '\p{geometricshapes}', ""); +Expect(0, 9727, '\p{^geometricshapes}', ""); +Expect(0, 9727, '\P{geometricshapes}', ""); +Expect(1, 9727, '\P{^geometricshapes}', ""); +Expect(0, 9631, '\p{geometricshapes}', ""); +Expect(1, 9631, '\p{^geometricshapes}', ""); +Expect(1, 9631, '\P{geometricshapes}', ""); +Expect(0, 9631, '\P{^geometricshapes}', ""); +Expect(1, 9727, '\p{- Geometric Shapes}', ""); +Expect(0, 9727, '\p{^- Geometric Shapes}', ""); +Expect(0, 9727, '\P{- Geometric Shapes}', ""); +Expect(1, 9727, '\P{^- Geometric Shapes}', ""); +Expect(0, 9631, '\p{- Geometric Shapes}', ""); +Expect(1, 9631, '\p{^- Geometric Shapes}', ""); +Expect(1, 9631, '\P{- Geometric Shapes}', ""); +Expect(0, 9631, '\P{^- Geometric Shapes}', ""); +Error('\p{ Is GEOMETRICSHAPES:=}'); +Error('\P{ Is GEOMETRICSHAPES:=}'); +Expect(1, 9727, '\p{isgeometricshapes}', ""); +Expect(0, 9727, '\p{^isgeometricshapes}', ""); +Expect(0, 9727, '\P{isgeometricshapes}', ""); +Expect(1, 9727, '\P{^isgeometricshapes}', ""); +Expect(0, 9631, '\p{isgeometricshapes}', ""); +Expect(1, 9631, '\p{^isgeometricshapes}', ""); +Expect(1, 9631, '\P{isgeometricshapes}', ""); +Expect(0, 9631, '\P{^isgeometricshapes}', ""); +Expect(1, 9727, '\p{-is GEOMETRIC SHAPES}', ""); +Expect(0, 9727, '\p{^-is GEOMETRIC SHAPES}', ""); +Expect(0, 9727, '\P{-is GEOMETRIC SHAPES}', ""); +Expect(1, 9727, '\P{^-is GEOMETRIC SHAPES}', ""); +Expect(0, 9631, '\p{-is GEOMETRIC SHAPES}', ""); +Expect(1, 9631, '\p{^-is GEOMETRIC SHAPES}', ""); +Expect(1, 9631, '\P{-is GEOMETRIC SHAPES}', ""); +Expect(0, 9631, '\P{^-is GEOMETRIC SHAPES}', ""); +Error('\p{ :=IN-Geometric-Shapes}'); +Error('\P{ :=IN-Geometric-Shapes}'); +Expect(1, 9727, '\p{ingeometricshapes}', ""); +Expect(0, 9727, '\p{^ingeometricshapes}', ""); +Expect(0, 9727, '\P{ingeometricshapes}', ""); +Expect(1, 9727, '\P{^ingeometricshapes}', ""); +Expect(0, 9631, '\p{ingeometricshapes}', ""); +Expect(1, 9631, '\p{^ingeometricshapes}', ""); +Expect(1, 9631, '\P{ingeometricshapes}', ""); +Expect(0, 9631, '\P{^ingeometricshapes}', ""); +Expect(1, 9727, '\p{--IN Geometric_SHAPES}', ""); +Expect(0, 9727, '\p{^--IN Geometric_SHAPES}', ""); +Expect(0, 9727, '\P{--IN Geometric_SHAPES}', ""); +Expect(1, 9727, '\P{^--IN Geometric_SHAPES}', ""); +Expect(0, 9631, '\p{--IN Geometric_SHAPES}', ""); +Expect(1, 9631, '\p{^--IN Geometric_SHAPES}', ""); +Expect(1, 9631, '\P{--IN Geometric_SHAPES}', ""); +Expect(0, 9631, '\P{^--IN Geometric_SHAPES}', ""); +Error('\p{_ Latin-EXTENDED/a/D}'); +Error('\P{_ Latin-EXTENDED/a/D}'); +Expect(1, 43007, '\p{latinextendedd}', ""); +Expect(0, 43007, '\p{^latinextendedd}', ""); +Expect(0, 43007, '\P{latinextendedd}', ""); +Expect(1, 43007, '\P{^latinextendedd}', ""); +Expect(0, 42783, '\p{latinextendedd}', ""); +Expect(1, 42783, '\p{^latinextendedd}', ""); +Expect(1, 42783, '\P{latinextendedd}', ""); +Expect(0, 42783, '\P{^latinextendedd}', ""); +Expect(1, 43007, '\p{ _Latin-EXTENDED D}', ""); +Expect(0, 43007, '\p{^ _Latin-EXTENDED D}', ""); +Expect(0, 43007, '\P{ _Latin-EXTENDED D}', ""); +Expect(1, 43007, '\P{^ _Latin-EXTENDED D}', ""); +Expect(0, 42783, '\p{ _Latin-EXTENDED D}', ""); +Expect(1, 42783, '\p{^ _Latin-EXTENDED D}', ""); +Expect(1, 42783, '\P{ _Latin-EXTENDED D}', ""); +Expect(0, 42783, '\P{^ _Latin-EXTENDED D}', ""); +Error('\p{/a/__Is LatinExtendedD}'); +Error('\P{/a/__Is LatinExtendedD}'); +Expect(1, 43007, '\p{islatinextendedd}', ""); +Expect(0, 43007, '\p{^islatinextendedd}', ""); +Expect(0, 43007, '\P{islatinextendedd}', ""); +Expect(1, 43007, '\P{^islatinextendedd}', ""); +Expect(0, 42783, '\p{islatinextendedd}', ""); +Expect(1, 42783, '\p{^islatinextendedd}', ""); +Expect(1, 42783, '\P{islatinextendedd}', ""); +Expect(0, 42783, '\P{^islatinextendedd}', ""); +Expect(1, 43007, '\p{ Is_latin_EXTENDED-d}', ""); +Expect(0, 43007, '\p{^ Is_latin_EXTENDED-d}', ""); +Expect(0, 43007, '\P{ Is_latin_EXTENDED-d}', ""); +Expect(1, 43007, '\P{^ Is_latin_EXTENDED-d}', ""); +Expect(0, 42783, '\p{ Is_latin_EXTENDED-d}', ""); +Expect(1, 42783, '\p{^ Is_latin_EXTENDED-d}', ""); +Expect(1, 42783, '\P{ Is_latin_EXTENDED-d}', ""); +Expect(0, 42783, '\P{^ Is_latin_EXTENDED-d}', ""); +Error('\p{-/a/In-Latin_ExtendedD}'); +Error('\P{-/a/In-Latin_ExtendedD}'); +Expect(1, 43007, '\p{inlatinextendedd}', ""); +Expect(0, 43007, '\p{^inlatinextendedd}', ""); +Expect(0, 43007, '\P{inlatinextendedd}', ""); +Expect(1, 43007, '\P{^inlatinextendedd}', ""); +Expect(0, 42783, '\p{inlatinextendedd}', ""); +Expect(1, 42783, '\p{^inlatinextendedd}', ""); +Expect(1, 42783, '\P{inlatinextendedd}', ""); +Expect(0, 42783, '\P{^inlatinextendedd}', ""); +Expect(1, 43007, '\p{-inLatin Extended D}', ""); +Expect(0, 43007, '\p{^-inLatin Extended D}', ""); +Expect(0, 43007, '\P{-inLatin Extended D}', ""); +Expect(1, 43007, '\P{^-inLatin Extended D}', ""); +Expect(0, 42783, '\p{-inLatin Extended D}', ""); +Expect(1, 42783, '\p{^-inLatin Extended D}', ""); +Expect(1, 42783, '\P{-inLatin Extended D}', ""); +Expect(0, 42783, '\P{^-inLatin Extended D}', ""); +Error('\p{/a/ Buginese}'); +Error('\P{/a/ Buginese}'); +Expect(1, 6683, '\p{buginese}', ""); +Expect(0, 6683, '\p{^buginese}', ""); +Expect(0, 6683, '\P{buginese}', ""); +Expect(1, 6683, '\P{^buginese}', ""); +Expect(0, 6655, '\p{buginese}', ""); +Expect(1, 6655, '\p{^buginese}', ""); +Expect(1, 6655, '\P{buginese}', ""); +Expect(0, 6655, '\P{^buginese}', ""); +Expect(1, 6683, '\p{ Buginese}', ""); +Expect(0, 6683, '\p{^ Buginese}', ""); +Expect(0, 6683, '\P{ Buginese}', ""); +Expect(1, 6683, '\P{^ Buginese}', ""); +Expect(0, 6655, '\p{ Buginese}', ""); +Expect(1, 6655, '\p{^ Buginese}', ""); +Expect(1, 6655, '\P{ Buginese}', ""); +Expect(0, 6655, '\P{^ Buginese}', ""); +Error('\p{_:=is-buginese}'); +Error('\P{_:=is-buginese}'); +Expect(1, 6683, '\p{isbuginese}', ""); +Expect(0, 6683, '\p{^isbuginese}', ""); +Expect(0, 6683, '\P{isbuginese}', ""); +Expect(1, 6683, '\P{^isbuginese}', ""); +Expect(0, 6655, '\p{isbuginese}', ""); +Expect(1, 6655, '\p{^isbuginese}', ""); +Expect(1, 6655, '\P{isbuginese}', ""); +Expect(0, 6655, '\P{^isbuginese}', ""); +Expect(1, 6683, '\p{- is Buginese}', ""); +Expect(0, 6683, '\p{^- is Buginese}', ""); +Expect(0, 6683, '\P{- is Buginese}', ""); +Expect(1, 6683, '\P{^- is Buginese}', ""); +Expect(0, 6655, '\p{- is Buginese}', ""); +Expect(1, 6655, '\p{^- is Buginese}', ""); +Expect(1, 6655, '\P{- is Buginese}', ""); +Expect(0, 6655, '\P{^- is Buginese}', ""); +Error('\p{_/a/BUGI}'); +Error('\P{_/a/BUGI}'); +Expect(1, 6683, '\p{bugi}', ""); +Expect(0, 6683, '\p{^bugi}', ""); +Expect(0, 6683, '\P{bugi}', ""); +Expect(1, 6683, '\P{^bugi}', ""); +Expect(0, 6655, '\p{bugi}', ""); +Expect(1, 6655, '\p{^bugi}', ""); +Expect(1, 6655, '\P{bugi}', ""); +Expect(0, 6655, '\P{^bugi}', ""); +Expect(1, 6683, '\p{ Bugi}', ""); +Expect(0, 6683, '\p{^ Bugi}', ""); +Expect(0, 6683, '\P{ Bugi}', ""); +Expect(1, 6683, '\P{^ Bugi}', ""); +Expect(0, 6655, '\p{ Bugi}', ""); +Expect(1, 6655, '\p{^ Bugi}', ""); +Expect(1, 6655, '\P{ Bugi}', ""); +Expect(0, 6655, '\P{^ Bugi}', ""); +Error('\p{- IS/a/Bugi}'); +Error('\P{- IS/a/Bugi}'); +Expect(1, 6683, '\p{isbugi}', ""); +Expect(0, 6683, '\p{^isbugi}', ""); +Expect(0, 6683, '\P{isbugi}', ""); +Expect(1, 6683, '\P{^isbugi}', ""); +Expect(0, 6655, '\p{isbugi}', ""); +Expect(1, 6655, '\p{^isbugi}', ""); +Expect(1, 6655, '\P{isbugi}', ""); +Expect(0, 6655, '\P{^isbugi}', ""); +Expect(1, 6683, '\p{_-ISBUGI}', ""); +Expect(0, 6683, '\p{^_-ISBUGI}', ""); +Expect(0, 6683, '\P{_-ISBUGI}', ""); +Expect(1, 6683, '\P{^_-ISBUGI}', ""); +Expect(0, 6655, '\p{_-ISBUGI}', ""); +Expect(1, 6655, '\p{^_-ISBUGI}', ""); +Expect(1, 6655, '\P{_-ISBUGI}', ""); +Expect(0, 6655, '\P{^_-ISBUGI}', ""); +Error('\p{:= In-Malayalam}'); +Error('\P{:= In-Malayalam}'); +Expect(1, 3455, '\p{inmalayalam}', ""); +Expect(0, 3455, '\p{^inmalayalam}', ""); +Expect(0, 3455, '\P{inmalayalam}', ""); +Expect(1, 3455, '\P{^inmalayalam}', ""); +Expect(0, 3327, '\p{inmalayalam}', ""); +Expect(1, 3327, '\p{^inmalayalam}', ""); +Expect(1, 3327, '\P{inmalayalam}', ""); +Expect(0, 3327, '\P{^inmalayalam}', ""); +Expect(1, 3455, '\p{_In malayalam}', ""); +Expect(0, 3455, '\p{^_In malayalam}', ""); +Expect(0, 3455, '\P{_In malayalam}', ""); +Expect(1, 3455, '\P{^_In malayalam}', ""); +Expect(0, 3327, '\p{_In malayalam}', ""); +Expect(1, 3327, '\p{^_In malayalam}', ""); +Expect(1, 3327, '\P{_In malayalam}', ""); +Expect(0, 3327, '\P{^_In malayalam}', ""); +Error('\p{ :=CHAM}'); +Error('\P{ :=CHAM}'); +Expect(1, 43574, '\p{cham}', ""); +Expect(0, 43574, '\p{^cham}', ""); +Expect(0, 43574, '\P{cham}', ""); +Expect(1, 43574, '\P{^cham}', ""); +Expect(0, 43519, '\p{cham}', ""); +Expect(1, 43519, '\p{^cham}', ""); +Expect(1, 43519, '\P{cham}', ""); +Expect(0, 43519, '\P{^cham}', ""); +Expect(1, 43574, '\p{-CHAM}', ""); +Expect(0, 43574, '\p{^-CHAM}', ""); +Expect(0, 43574, '\P{-CHAM}', ""); +Expect(1, 43574, '\P{^-CHAM}', ""); +Expect(0, 43519, '\p{-CHAM}', ""); +Expect(1, 43519, '\p{^-CHAM}', ""); +Expect(1, 43519, '\P{-CHAM}', ""); +Expect(0, 43519, '\P{^-CHAM}', ""); +Error('\p{_/a/IS_cham}'); +Error('\P{_/a/IS_cham}'); +Expect(1, 43574, '\p{ischam}', ""); +Expect(0, 43574, '\p{^ischam}', ""); +Expect(0, 43574, '\P{ischam}', ""); +Expect(1, 43574, '\P{^ischam}', ""); +Expect(0, 43519, '\p{ischam}', ""); +Expect(1, 43519, '\p{^ischam}', ""); +Expect(1, 43519, '\P{ischam}', ""); +Expect(0, 43519, '\P{^ischam}', ""); +Expect(1, 43574, '\p{ is_CHAM}', ""); +Expect(0, 43574, '\p{^ is_CHAM}', ""); +Expect(0, 43574, '\P{ is_CHAM}', ""); +Expect(1, 43574, '\P{^ is_CHAM}', ""); +Expect(0, 43519, '\p{ is_CHAM}', ""); +Expect(1, 43519, '\p{^ is_CHAM}', ""); +Expect(1, 43519, '\P{ is_CHAM}', ""); +Expect(0, 43519, '\P{^ is_CHAM}', ""); +Error('\p{ Braille/a/}'); +Error('\P{ Braille/a/}'); +Expect(1, 10495, '\p{braille}', ""); +Expect(0, 10495, '\p{^braille}', ""); +Expect(0, 10495, '\P{braille}', ""); +Expect(1, 10495, '\P{^braille}', ""); +Expect(0, 10239, '\p{braille}', ""); +Expect(1, 10239, '\p{^braille}', ""); +Expect(1, 10239, '\P{braille}', ""); +Expect(0, 10239, '\P{^braille}', ""); +Expect(1, 10495, '\p{_-Braille}', ""); +Expect(0, 10495, '\p{^_-Braille}', ""); +Expect(0, 10495, '\P{_-Braille}', ""); +Expect(1, 10495, '\P{^_-Braille}', ""); +Expect(0, 10239, '\p{_-Braille}', ""); +Expect(1, 10239, '\p{^_-Braille}', ""); +Expect(1, 10239, '\P{_-Braille}', ""); +Expect(0, 10239, '\P{^_-Braille}', ""); +Error('\p{/a/_ Is_Braille}'); +Error('\P{/a/_ Is_Braille}'); +Expect(1, 10495, '\p{isbraille}', ""); +Expect(0, 10495, '\p{^isbraille}', ""); +Expect(0, 10495, '\P{isbraille}', ""); +Expect(1, 10495, '\P{^isbraille}', ""); +Expect(0, 10239, '\p{isbraille}', ""); +Expect(1, 10239, '\p{^isbraille}', ""); +Expect(1, 10239, '\P{isbraille}', ""); +Expect(0, 10239, '\P{^isbraille}', ""); +Expect(1, 10495, '\p{ IS Braille}', ""); +Expect(0, 10495, '\p{^ IS Braille}', ""); +Expect(0, 10495, '\P{ IS Braille}', ""); +Expect(1, 10495, '\P{^ IS Braille}', ""); +Expect(0, 10239, '\p{ IS Braille}', ""); +Expect(1, 10239, '\p{^ IS Braille}', ""); +Expect(1, 10239, '\P{ IS Braille}', ""); +Expect(0, 10239, '\P{^ IS Braille}', ""); +Error('\p{ Brai:=}'); +Error('\P{ Brai:=}'); +Expect(1, 10495, '\p{brai}', ""); +Expect(0, 10495, '\p{^brai}', ""); +Expect(0, 10495, '\P{brai}', ""); +Expect(1, 10495, '\P{^brai}', ""); +Expect(0, 10239, '\p{brai}', ""); +Expect(1, 10239, '\p{^brai}', ""); +Expect(1, 10239, '\P{brai}', ""); +Expect(0, 10239, '\P{^brai}', ""); +Expect(1, 10495, '\p{_BRAI}', ""); +Expect(0, 10495, '\p{^_BRAI}', ""); +Expect(0, 10495, '\P{_BRAI}', ""); +Expect(1, 10495, '\P{^_BRAI}', ""); +Expect(0, 10239, '\p{_BRAI}', ""); +Expect(1, 10239, '\p{^_BRAI}', ""); +Expect(1, 10239, '\P{_BRAI}', ""); +Expect(0, 10239, '\P{^_BRAI}', ""); +Error('\p{ /a/Is_brai}'); +Error('\P{ /a/Is_brai}'); +Expect(1, 10495, '\p{isbrai}', ""); +Expect(0, 10495, '\p{^isbrai}', ""); +Expect(0, 10495, '\P{isbrai}', ""); +Expect(1, 10495, '\P{^isbrai}', ""); +Expect(0, 10239, '\p{isbrai}', ""); +Expect(1, 10239, '\p{^isbrai}', ""); +Expect(1, 10239, '\P{isbrai}', ""); +Expect(0, 10239, '\P{^isbrai}', ""); +Expect(1, 10495, '\p{_Is Brai}', ""); +Expect(0, 10495, '\p{^_Is Brai}', ""); +Expect(0, 10495, '\P{_Is Brai}', ""); +Expect(1, 10495, '\P{^_Is Brai}', ""); +Expect(0, 10239, '\p{_Is Brai}', ""); +Expect(1, 10239, '\p{^_Is Brai}', ""); +Expect(1, 10239, '\P{_Is Brai}', ""); +Expect(0, 10239, '\P{^_Is Brai}', ""); +Error('\p{ -In/a/Old-Persian}'); +Error('\P{ -In/a/Old-Persian}'); +Expect(1, 66527, '\p{inoldpersian}', ""); +Expect(0, 66527, '\p{^inoldpersian}', ""); +Expect(0, 66527, '\P{inoldpersian}', ""); +Expect(1, 66527, '\P{^inoldpersian}', ""); +Expect(0, 66463, '\p{inoldpersian}', ""); +Expect(1, 66463, '\p{^inoldpersian}', ""); +Expect(1, 66463, '\P{inoldpersian}', ""); +Expect(0, 66463, '\P{^inoldpersian}', ""); +Expect(1, 66527, '\p{__In_OldPERSIAN}', ""); +Expect(0, 66527, '\p{^__In_OldPERSIAN}', ""); +Expect(0, 66527, '\P{__In_OldPERSIAN}', ""); +Expect(1, 66527, '\P{^__In_OldPERSIAN}', ""); +Expect(0, 66463, '\p{__In_OldPERSIAN}', ""); +Expect(1, 66463, '\p{^__In_OldPERSIAN}', ""); +Expect(1, 66463, '\P{__In_OldPERSIAN}', ""); +Expect(0, 66463, '\P{^__In_OldPERSIAN}', ""); +Error('\p{ :=Box drawing}'); +Error('\P{ :=Box drawing}'); +Expect(1, 9599, '\p{boxdrawing}', ""); +Expect(0, 9599, '\p{^boxdrawing}', ""); +Expect(0, 9599, '\P{boxdrawing}', ""); +Expect(1, 9599, '\P{^boxdrawing}', ""); +Expect(0, 9471, '\p{boxdrawing}', ""); +Expect(1, 9471, '\p{^boxdrawing}', ""); +Expect(1, 9471, '\P{boxdrawing}', ""); +Expect(0, 9471, '\P{^boxdrawing}', ""); +Expect(1, 9599, '\p{__Box DRAWING}', ""); +Expect(0, 9599, '\p{^__Box DRAWING}', ""); +Expect(0, 9599, '\P{__Box DRAWING}', ""); +Expect(1, 9599, '\P{^__Box DRAWING}', ""); +Expect(0, 9471, '\p{__Box DRAWING}', ""); +Expect(1, 9471, '\p{^__Box DRAWING}', ""); +Expect(1, 9471, '\P{__Box DRAWING}', ""); +Expect(0, 9471, '\P{^__Box DRAWING}', ""); +Error('\p{/a/- Is-BoxDrawing}'); +Error('\P{/a/- Is-BoxDrawing}'); +Expect(1, 9599, '\p{isboxdrawing}', ""); +Expect(0, 9599, '\p{^isboxdrawing}', ""); +Expect(0, 9599, '\P{isboxdrawing}', ""); +Expect(1, 9599, '\P{^isboxdrawing}', ""); +Expect(0, 9471, '\p{isboxdrawing}', ""); +Expect(1, 9471, '\p{^isboxdrawing}', ""); +Expect(1, 9471, '\P{isboxdrawing}', ""); +Expect(0, 9471, '\P{^isboxdrawing}', ""); +Expect(1, 9599, '\p{ isBOX_Drawing}', ""); +Expect(0, 9599, '\p{^ isBOX_Drawing}', ""); +Expect(0, 9599, '\P{ isBOX_Drawing}', ""); +Expect(1, 9599, '\P{^ isBOX_Drawing}', ""); +Expect(0, 9471, '\p{ isBOX_Drawing}', ""); +Expect(1, 9471, '\p{^ isBOX_Drawing}', ""); +Expect(1, 9471, '\P{ isBOX_Drawing}', ""); +Expect(0, 9471, '\P{^ isBOX_Drawing}', ""); +Error('\p{In/a/box Drawing}'); +Error('\P{In/a/box Drawing}'); +Expect(1, 9599, '\p{inboxdrawing}', ""); +Expect(0, 9599, '\p{^inboxdrawing}', ""); +Expect(0, 9599, '\P{inboxdrawing}', ""); +Expect(1, 9599, '\P{^inboxdrawing}', ""); +Expect(0, 9471, '\p{inboxdrawing}', ""); +Expect(1, 9471, '\p{^inboxdrawing}', ""); +Expect(1, 9471, '\P{inboxdrawing}', ""); +Expect(0, 9471, '\P{^inboxdrawing}', ""); +Expect(1, 9599, '\p{ InBox_DRAWING}', ""); +Expect(0, 9599, '\p{^ InBox_DRAWING}', ""); +Expect(0, 9599, '\P{ InBox_DRAWING}', ""); +Expect(1, 9599, '\P{^ InBox_DRAWING}', ""); +Expect(0, 9471, '\p{ InBox_DRAWING}', ""); +Expect(1, 9471, '\p{^ InBox_DRAWING}', ""); +Expect(1, 9471, '\P{ InBox_DRAWING}', ""); +Expect(0, 9471, '\P{^ InBox_DRAWING}', ""); +Error('\p{:=LINEAR_B}'); +Error('\P{:=LINEAR_B}'); +Expect(1, 65547, '\p{linearb}', ""); +Expect(0, 65547, '\p{^linearb}', ""); +Expect(0, 65547, '\P{linearb}', ""); +Expect(1, 65547, '\P{^linearb}', ""); +Expect(0, 7, '\p{linearb}', ""); +Expect(1, 7, '\p{^linearb}', ""); +Expect(1, 7, '\P{linearb}', ""); +Expect(0, 7, '\P{^linearb}', ""); +Expect(1, 65547, '\p{-_LINEARB}', ""); +Expect(0, 65547, '\p{^-_LINEARB}', ""); +Expect(0, 65547, '\P{-_LINEARB}', ""); +Expect(1, 65547, '\P{^-_LINEARB}', ""); +Expect(0, 7, '\p{-_LINEARB}', ""); +Expect(1, 7, '\p{^-_LINEARB}', ""); +Expect(1, 7, '\P{-_LINEARB}', ""); +Expect(0, 7, '\P{^-_LINEARB}', ""); +Error('\p{/a/ IS linearB}'); +Error('\P{/a/ IS linearB}'); +Expect(1, 65547, '\p{islinearb}', ""); +Expect(0, 65547, '\p{^islinearb}', ""); +Expect(0, 65547, '\P{islinearb}', ""); +Expect(1, 65547, '\P{^islinearb}', ""); +Expect(0, 7, '\p{islinearb}', ""); +Expect(1, 7, '\p{^islinearb}', ""); +Expect(1, 7, '\P{islinearb}', ""); +Expect(0, 7, '\P{^islinearb}', ""); +Expect(1, 65547, '\p{_-IsLINEAR-B}', ""); +Expect(0, 65547, '\p{^_-IsLINEAR-B}', ""); +Expect(0, 65547, '\P{_-IsLINEAR-B}', ""); +Expect(1, 65547, '\P{^_-IsLINEAR-B}', ""); +Expect(0, 7, '\p{_-IsLINEAR-B}', ""); +Expect(1, 7, '\p{^_-IsLINEAR-B}', ""); +Expect(1, 7, '\P{_-IsLINEAR-B}', ""); +Expect(0, 7, '\P{^_-IsLINEAR-B}', ""); +Error('\p{_/a/Linb}'); +Error('\P{_/a/Linb}'); +Expect(1, 65547, '\p{linb}', ""); +Expect(0, 65547, '\p{^linb}', ""); +Expect(0, 65547, '\P{linb}', ""); +Expect(1, 65547, '\P{^linb}', ""); +Expect(0, 7, '\p{linb}', ""); +Expect(1, 7, '\p{^linb}', ""); +Expect(1, 7, '\P{linb}', ""); +Expect(0, 7, '\P{^linb}', ""); +Expect(1, 65547, '\p{_-LINB}', ""); +Expect(0, 65547, '\p{^_-LINB}', ""); +Expect(0, 65547, '\P{_-LINB}', ""); +Expect(1, 65547, '\P{^_-LINB}', ""); +Expect(0, 7, '\p{_-LINB}', ""); +Expect(1, 7, '\p{^_-LINB}', ""); +Expect(1, 7, '\P{_-LINB}', ""); +Expect(0, 7, '\P{^_-LINB}', ""); +Error('\p{-Is-linb:=}'); +Error('\P{-Is-linb:=}'); +Expect(1, 65547, '\p{islinb}', ""); +Expect(0, 65547, '\p{^islinb}', ""); +Expect(0, 65547, '\P{islinb}', ""); +Expect(1, 65547, '\P{^islinb}', ""); +Expect(0, 7, '\p{islinb}', ""); +Expect(1, 7, '\p{^islinb}', ""); +Expect(1, 7, '\P{islinb}', ""); +Expect(0, 7, '\P{^islinb}', ""); +Expect(1, 65547, '\p{ -IS Linb}', ""); +Expect(0, 65547, '\p{^ -IS Linb}', ""); +Expect(0, 65547, '\P{ -IS Linb}', ""); +Expect(1, 65547, '\P{^ -IS Linb}', ""); +Expect(0, 7, '\p{ -IS Linb}', ""); +Expect(1, 7, '\p{^ -IS Linb}', ""); +Expect(1, 7, '\P{ -IS Linb}', ""); +Expect(0, 7, '\P{^ -IS Linb}', ""); +Error('\p{/a/ _tifinagh}'); +Error('\P{/a/ _tifinagh}'); +Expect(1, 11621, '\p{tifinagh}', ""); +Expect(0, 11621, '\p{^tifinagh}', ""); +Expect(0, 11621, '\P{tifinagh}', ""); +Expect(1, 11621, '\P{^tifinagh}', ""); +Expect(0, 11567, '\p{tifinagh}', ""); +Expect(1, 11567, '\p{^tifinagh}', ""); +Expect(1, 11567, '\P{tifinagh}', ""); +Expect(0, 11567, '\P{^tifinagh}', ""); +Expect(1, 11621, '\p{-TIFINAGH}', ""); +Expect(0, 11621, '\p{^-TIFINAGH}', ""); +Expect(0, 11621, '\P{-TIFINAGH}', ""); +Expect(1, 11621, '\P{^-TIFINAGH}', ""); +Expect(0, 11567, '\p{-TIFINAGH}', ""); +Expect(1, 11567, '\p{^-TIFINAGH}', ""); +Expect(1, 11567, '\P{-TIFINAGH}', ""); +Expect(0, 11567, '\P{^-TIFINAGH}', ""); +Error('\p{-/a/Is-tifinagh}'); +Error('\P{-/a/Is-tifinagh}'); +Expect(1, 11621, '\p{istifinagh}', ""); +Expect(0, 11621, '\p{^istifinagh}', ""); +Expect(0, 11621, '\P{istifinagh}', ""); +Expect(1, 11621, '\P{^istifinagh}', ""); +Expect(0, 11567, '\p{istifinagh}', ""); +Expect(1, 11567, '\p{^istifinagh}', ""); +Expect(1, 11567, '\P{istifinagh}', ""); +Expect(0, 11567, '\P{^istifinagh}', ""); +Expect(1, 11621, '\p{Is_tifinagh}', ""); +Expect(0, 11621, '\p{^Is_tifinagh}', ""); +Expect(0, 11621, '\P{Is_tifinagh}', ""); +Expect(1, 11621, '\P{^Is_tifinagh}', ""); +Expect(0, 11567, '\p{Is_tifinagh}', ""); +Expect(1, 11567, '\p{^Is_tifinagh}', ""); +Expect(1, 11567, '\P{Is_tifinagh}', ""); +Expect(0, 11567, '\P{^Is_tifinagh}', ""); +Error('\p{:=_Tfng}'); +Error('\P{:=_Tfng}'); +Expect(1, 11621, '\p{tfng}', ""); +Expect(0, 11621, '\p{^tfng}', ""); +Expect(0, 11621, '\P{tfng}', ""); +Expect(1, 11621, '\P{^tfng}', ""); +Expect(0, 11567, '\p{tfng}', ""); +Expect(1, 11567, '\p{^tfng}', ""); +Expect(1, 11567, '\P{tfng}', ""); +Expect(0, 11567, '\P{^tfng}', ""); +Expect(1, 11621, '\p{ Tfng}', ""); +Expect(0, 11621, '\p{^ Tfng}', ""); +Expect(0, 11621, '\P{ Tfng}', ""); +Expect(1, 11621, '\P{^ Tfng}', ""); +Expect(0, 11567, '\p{ Tfng}', ""); +Expect(1, 11567, '\p{^ Tfng}', ""); +Expect(1, 11567, '\P{ Tfng}', ""); +Expect(0, 11567, '\P{^ Tfng}', ""); +Error('\p{ Is tfng:=}'); +Error('\P{ Is tfng:=}'); +Expect(1, 11621, '\p{istfng}', ""); +Expect(0, 11621, '\p{^istfng}', ""); +Expect(0, 11621, '\P{istfng}', ""); +Expect(1, 11621, '\P{^istfng}', ""); +Expect(0, 11567, '\p{istfng}', ""); +Expect(1, 11567, '\p{^istfng}', ""); +Expect(1, 11567, '\P{istfng}', ""); +Expect(0, 11567, '\P{^istfng}', ""); +Expect(1, 11621, '\p{ -Is_TFNG}', ""); +Expect(0, 11621, '\p{^ -Is_TFNG}', ""); +Expect(0, 11621, '\P{ -Is_TFNG}', ""); +Expect(1, 11621, '\P{^ -Is_TFNG}', ""); +Expect(0, 11567, '\p{ -Is_TFNG}', ""); +Expect(1, 11567, '\p{^ -Is_TFNG}', ""); +Expect(1, 11567, '\P{ -Is_TFNG}', ""); +Expect(0, 11567, '\P{^ -Is_TFNG}', ""); +Error('\p{/a/ Syloti NAGRI}'); +Error('\P{/a/ Syloti NAGRI}'); +Expect(1, 43051, '\p{sylotinagri}', ""); +Expect(0, 43051, '\p{^sylotinagri}', ""); +Expect(0, 43051, '\P{sylotinagri}', ""); +Expect(1, 43051, '\P{^sylotinagri}', ""); +Expect(0, 43007, '\p{sylotinagri}', ""); +Expect(1, 43007, '\p{^sylotinagri}', ""); +Expect(1, 43007, '\P{sylotinagri}', ""); +Expect(0, 43007, '\P{^sylotinagri}', ""); +Expect(1, 43051, '\p{ _SYLOTI nagri}', ""); +Expect(0, 43051, '\p{^ _SYLOTI nagri}', ""); +Expect(0, 43051, '\P{ _SYLOTI nagri}', ""); +Expect(1, 43051, '\P{^ _SYLOTI nagri}', ""); +Expect(0, 43007, '\p{ _SYLOTI nagri}', ""); +Expect(1, 43007, '\p{^ _SYLOTI nagri}', ""); +Expect(1, 43007, '\P{ _SYLOTI nagri}', ""); +Expect(0, 43007, '\P{^ _SYLOTI nagri}', ""); +Error('\p{ /a/IS-Syloti-Nagri}'); +Error('\P{ /a/IS-Syloti-Nagri}'); +Expect(1, 43051, '\p{issylotinagri}', ""); +Expect(0, 43051, '\p{^issylotinagri}', ""); +Expect(0, 43051, '\P{issylotinagri}', ""); +Expect(1, 43051, '\P{^issylotinagri}', ""); +Expect(0, 43007, '\p{issylotinagri}', ""); +Expect(1, 43007, '\p{^issylotinagri}', ""); +Expect(1, 43007, '\P{issylotinagri}', ""); +Expect(0, 43007, '\P{^issylotinagri}', ""); +Expect(1, 43051, '\p{ _IsSYLOTI Nagri}', ""); +Expect(0, 43051, '\p{^ _IsSYLOTI Nagri}', ""); +Expect(0, 43051, '\P{ _IsSYLOTI Nagri}', ""); +Expect(1, 43051, '\P{^ _IsSYLOTI Nagri}', ""); +Expect(0, 43007, '\p{ _IsSYLOTI Nagri}', ""); +Expect(1, 43007, '\p{^ _IsSYLOTI Nagri}', ""); +Expect(1, 43007, '\P{ _IsSYLOTI Nagri}', ""); +Expect(0, 43007, '\P{^ _IsSYLOTI Nagri}', ""); +Error('\p{ _Sylo/a/}'); +Error('\P{ _Sylo/a/}'); +Expect(1, 43051, '\p{sylo}', ""); +Expect(0, 43051, '\p{^sylo}', ""); +Expect(0, 43051, '\P{sylo}', ""); +Expect(1, 43051, '\P{^sylo}', ""); +Expect(0, 43007, '\p{sylo}', ""); +Expect(1, 43007, '\p{^sylo}', ""); +Expect(1, 43007, '\P{sylo}', ""); +Expect(0, 43007, '\P{^sylo}', ""); +Expect(1, 43051, '\p{_Sylo}', ""); +Expect(0, 43051, '\p{^_Sylo}', ""); +Expect(0, 43051, '\P{_Sylo}', ""); +Expect(1, 43051, '\P{^_Sylo}', ""); +Expect(0, 43007, '\p{_Sylo}', ""); +Expect(1, 43007, '\p{^_Sylo}', ""); +Expect(1, 43007, '\P{_Sylo}', ""); +Expect(0, 43007, '\P{^_Sylo}', ""); +Error('\p{/a/IsSylo}'); +Error('\P{/a/IsSylo}'); +Expect(1, 43051, '\p{issylo}', ""); +Expect(0, 43051, '\p{^issylo}', ""); +Expect(0, 43051, '\P{issylo}', ""); +Expect(1, 43051, '\P{^issylo}', ""); +Expect(0, 43007, '\p{issylo}', ""); +Expect(1, 43007, '\p{^issylo}', ""); +Expect(1, 43007, '\P{issylo}', ""); +Expect(0, 43007, '\P{^issylo}', ""); +Expect(1, 43051, '\p{Is_Sylo}', ""); +Expect(0, 43051, '\p{^Is_Sylo}', ""); +Expect(0, 43051, '\P{Is_Sylo}', ""); +Expect(1, 43051, '\P{^Is_Sylo}', ""); +Expect(0, 43007, '\p{Is_Sylo}', ""); +Expect(1, 43007, '\p{^Is_Sylo}', ""); +Expect(1, 43007, '\P{Is_Sylo}', ""); +Expect(0, 43007, '\P{^Is_Sylo}', ""); +Error('\p{:= balinese}'); +Error('\P{:= balinese}'); +Expect(1, 6987, '\p{balinese}', ""); +Expect(0, 6987, '\p{^balinese}', ""); +Expect(0, 6987, '\P{balinese}', ""); +Expect(1, 6987, '\P{^balinese}', ""); +Expect(0, 6911, '\p{balinese}', ""); +Expect(1, 6911, '\p{^balinese}', ""); +Expect(1, 6911, '\P{balinese}', ""); +Expect(0, 6911, '\P{^balinese}', ""); +Expect(1, 6987, '\p{_ Balinese}', ""); +Expect(0, 6987, '\p{^_ Balinese}', ""); +Expect(0, 6987, '\P{_ Balinese}', ""); +Expect(1, 6987, '\P{^_ Balinese}', ""); +Expect(0, 6911, '\p{_ Balinese}', ""); +Expect(1, 6911, '\p{^_ Balinese}', ""); +Expect(1, 6911, '\P{_ Balinese}', ""); +Expect(0, 6911, '\P{^_ Balinese}', ""); +Error('\p{ :=is_Balinese}'); +Error('\P{ :=is_Balinese}'); +Expect(1, 6987, '\p{isbalinese}', ""); +Expect(0, 6987, '\p{^isbalinese}', ""); +Expect(0, 6987, '\P{isbalinese}', ""); +Expect(1, 6987, '\P{^isbalinese}', ""); +Expect(0, 6911, '\p{isbalinese}', ""); +Expect(1, 6911, '\p{^isbalinese}', ""); +Expect(1, 6911, '\P{isbalinese}', ""); +Expect(0, 6911, '\P{^isbalinese}', ""); +Expect(1, 6987, '\p{-Is balinese}', ""); +Expect(0, 6987, '\p{^-Is balinese}', ""); +Expect(0, 6987, '\P{-Is balinese}', ""); +Expect(1, 6987, '\P{^-Is balinese}', ""); +Expect(0, 6911, '\p{-Is balinese}', ""); +Expect(1, 6911, '\p{^-Is balinese}', ""); +Expect(1, 6911, '\P{-Is balinese}', ""); +Expect(0, 6911, '\P{^-Is balinese}', ""); +Error('\p{ BALI/a/}'); +Error('\P{ BALI/a/}'); +Expect(1, 6987, '\p{bali}', ""); +Expect(0, 6987, '\p{^bali}', ""); +Expect(0, 6987, '\P{bali}', ""); +Expect(1, 6987, '\P{^bali}', ""); +Expect(0, 6911, '\p{bali}', ""); +Expect(1, 6911, '\p{^bali}', ""); +Expect(1, 6911, '\P{bali}', ""); +Expect(0, 6911, '\P{^bali}', ""); +Expect(1, 6987, '\p{ Bali}', ""); +Expect(0, 6987, '\p{^ Bali}', ""); +Expect(0, 6987, '\P{ Bali}', ""); +Expect(1, 6987, '\P{^ Bali}', ""); +Expect(0, 6911, '\p{ Bali}', ""); +Expect(1, 6911, '\p{^ Bali}', ""); +Expect(1, 6911, '\P{ Bali}', ""); +Expect(0, 6911, '\P{^ Bali}', ""); +Error('\p{/a/ is-BALI}'); +Error('\P{/a/ is-BALI}'); +Expect(1, 6987, '\p{isbali}', ""); +Expect(0, 6987, '\p{^isbali}', ""); +Expect(0, 6987, '\P{isbali}', ""); +Expect(1, 6987, '\P{^isbali}', ""); +Expect(0, 6911, '\p{isbali}', ""); +Expect(1, 6911, '\p{^isbali}', ""); +Expect(1, 6911, '\P{isbali}', ""); +Expect(0, 6911, '\P{^isbali}', ""); +Expect(1, 6987, '\p{_-isbali}', ""); +Expect(0, 6987, '\p{^_-isbali}', ""); +Expect(0, 6987, '\P{_-isbali}', ""); +Expect(1, 6987, '\P{^_-isbali}', ""); +Expect(0, 6911, '\p{_-isbali}', ""); +Expect(1, 6911, '\p{^_-isbali}', ""); +Expect(1, 6911, '\P{_-isbali}', ""); +Expect(0, 6911, '\P{^_-isbali}', ""); +Error('\p{-MISCELLANEOUS/a/Symbols-And arrows}'); +Error('\P{-MISCELLANEOUS/a/Symbols-And arrows}'); +Expect(1, 11263, '\p{miscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\p{^miscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\P{miscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\P{^miscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\p{miscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\p{^miscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\P{miscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\P{^miscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\p{- MISCELLANEOUS SymbolsAND-Arrows}', ""); +Expect(0, 11263, '\p{^- MISCELLANEOUS SymbolsAND-Arrows}', ""); +Expect(0, 11263, '\P{- MISCELLANEOUS SymbolsAND-Arrows}', ""); +Expect(1, 11263, '\P{^- MISCELLANEOUS SymbolsAND-Arrows}', ""); +Expect(0, 11007, '\p{- MISCELLANEOUS SymbolsAND-Arrows}', ""); +Expect(1, 11007, '\p{^- MISCELLANEOUS SymbolsAND-Arrows}', ""); +Expect(1, 11007, '\P{- MISCELLANEOUS SymbolsAND-Arrows}', ""); +Expect(0, 11007, '\P{^- MISCELLANEOUS SymbolsAND-Arrows}', ""); +Error('\p{ Is/a/Miscellaneous_symbolsAND arrows}'); +Error('\P{ Is/a/Miscellaneous_symbolsAND arrows}'); +Expect(1, 11263, '\p{ismiscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\p{^ismiscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\P{ismiscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\P{^ismiscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\p{ismiscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\p{^ismiscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\P{ismiscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\P{^ismiscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\p{ _IS_miscellaneous_symbols_andARROWS}', ""); +Expect(0, 11263, '\p{^ _IS_miscellaneous_symbols_andARROWS}', ""); +Expect(0, 11263, '\P{ _IS_miscellaneous_symbols_andARROWS}', ""); +Expect(1, 11263, '\P{^ _IS_miscellaneous_symbols_andARROWS}', ""); +Expect(0, 11007, '\p{ _IS_miscellaneous_symbols_andARROWS}', ""); +Expect(1, 11007, '\p{^ _IS_miscellaneous_symbols_andARROWS}', ""); +Expect(1, 11007, '\P{ _IS_miscellaneous_symbols_andARROWS}', ""); +Expect(0, 11007, '\P{^ _IS_miscellaneous_symbols_andARROWS}', ""); +Error('\p{ -In-miscellaneous:=SYMBOLS And arrows}'); +Error('\P{ -In-miscellaneous:=SYMBOLS And arrows}'); +Expect(1, 11263, '\p{inmiscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\p{^inmiscellaneoussymbolsandarrows}', ""); +Expect(0, 11263, '\P{inmiscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\P{^inmiscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\p{inmiscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\p{^inmiscellaneoussymbolsandarrows}', ""); +Expect(1, 11007, '\P{inmiscellaneoussymbolsandarrows}', ""); +Expect(0, 11007, '\P{^inmiscellaneoussymbolsandarrows}', ""); +Expect(1, 11263, '\p{- inmiscellaneoussymbols-AND arrows}', ""); +Expect(0, 11263, '\p{^- inmiscellaneoussymbols-AND arrows}', ""); +Expect(0, 11263, '\P{- inmiscellaneoussymbols-AND arrows}', ""); +Expect(1, 11263, '\P{^- inmiscellaneoussymbols-AND arrows}', ""); +Expect(0, 11007, '\p{- inmiscellaneoussymbols-AND arrows}', ""); +Expect(1, 11007, '\p{^- inmiscellaneoussymbols-AND arrows}', ""); +Expect(1, 11007, '\P{- inmiscellaneoussymbols-AND arrows}', ""); +Expect(0, 11007, '\P{^- inmiscellaneoussymbols-AND arrows}', ""); +Error('\p{-/a/Print}'); +Error('\P{-/a/Print}'); +Expect(1, 126, '\p{print}', ""); +Expect(0, 126, '\p{^print}', ""); +Expect(0, 126, '\P{print}', ""); +Expect(1, 126, '\P{^print}', ""); +Expect(0, 7, '\p{print}', ""); +Expect(1, 7, '\p{^print}', ""); +Expect(1, 7, '\P{print}', ""); +Expect(0, 7, '\P{^print}', ""); +Expect(1, 126, '\p{ print}', ""); +Expect(0, 126, '\p{^ print}', ""); +Expect(0, 126, '\P{ print}', ""); +Expect(1, 126, '\P{^ print}', ""); +Expect(0, 7, '\p{ print}', ""); +Expect(1, 7, '\p{^ print}', ""); +Expect(1, 7, '\P{ print}', ""); +Expect(0, 7, '\P{^ print}', ""); +Error('\p{ -isPRINT:=}'); +Error('\P{ -isPRINT:=}'); +Expect(1, 126, '\p{isprint}', ""); +Expect(0, 126, '\p{^isprint}', ""); +Expect(0, 126, '\P{isprint}', ""); +Expect(1, 126, '\P{^isprint}', ""); +Expect(0, 7, '\p{isprint}', ""); +Expect(1, 7, '\p{^isprint}', ""); +Expect(1, 7, '\P{isprint}', ""); +Expect(0, 7, '\P{^isprint}', ""); +Expect(1, 126, '\p{-is Print}', ""); +Expect(0, 126, '\p{^-is Print}', ""); +Expect(0, 126, '\P{-is Print}', ""); +Expect(1, 126, '\P{^-is Print}', ""); +Expect(0, 7, '\p{-is Print}', ""); +Expect(1, 7, '\p{^-is Print}', ""); +Expect(1, 7, '\P{-is Print}', ""); +Expect(0, 7, '\P{^-is Print}', ""); +Error('\p{ IDS trinary operator/a/}'); +Error('\P{ IDS trinary operator/a/}'); +Expect(1, 12275, '\p{idstrinaryoperator}', ""); +Expect(0, 12275, '\p{^idstrinaryoperator}', ""); +Expect(0, 12275, '\P{idstrinaryoperator}', ""); +Expect(1, 12275, '\P{^idstrinaryoperator}', ""); +Expect(0, 12273, '\p{idstrinaryoperator}', ""); +Expect(1, 12273, '\p{^idstrinaryoperator}', ""); +Expect(1, 12273, '\P{idstrinaryoperator}', ""); +Expect(0, 12273, '\P{^idstrinaryoperator}', ""); +Expect(1, 12275, '\p{ _IDS-TRINARY OPERATOR}', ""); +Expect(0, 12275, '\p{^ _IDS-TRINARY OPERATOR}', ""); +Expect(0, 12275, '\P{ _IDS-TRINARY OPERATOR}', ""); +Expect(1, 12275, '\P{^ _IDS-TRINARY OPERATOR}', ""); +Expect(0, 12273, '\p{ _IDS-TRINARY OPERATOR}', ""); +Expect(1, 12273, '\p{^ _IDS-TRINARY OPERATOR}', ""); +Expect(1, 12273, '\P{ _IDS-TRINARY OPERATOR}', ""); +Expect(0, 12273, '\P{^ _IDS-TRINARY OPERATOR}', ""); +Error('\p{_ Is ids trinary/a/operator}'); +Error('\P{_ Is ids trinary/a/operator}'); +Expect(1, 12275, '\p{isidstrinaryoperator}', ""); +Expect(0, 12275, '\p{^isidstrinaryoperator}', ""); +Expect(0, 12275, '\P{isidstrinaryoperator}', ""); +Expect(1, 12275, '\P{^isidstrinaryoperator}', ""); +Expect(0, 12273, '\p{isidstrinaryoperator}', ""); +Expect(1, 12273, '\p{^isidstrinaryoperator}', ""); +Expect(1, 12273, '\P{isidstrinaryoperator}', ""); +Expect(0, 12273, '\P{^isidstrinaryoperator}', ""); +Expect(1, 12275, '\p{ IS ids-trinary Operator}', ""); +Expect(0, 12275, '\p{^ IS ids-trinary Operator}', ""); +Expect(0, 12275, '\P{ IS ids-trinary Operator}', ""); +Expect(1, 12275, '\P{^ IS ids-trinary Operator}', ""); +Expect(0, 12273, '\p{ IS ids-trinary Operator}', ""); +Expect(1, 12273, '\p{^ IS ids-trinary Operator}', ""); +Expect(1, 12273, '\P{ IS ids-trinary Operator}', ""); +Expect(0, 12273, '\P{^ IS ids-trinary Operator}', ""); +Error('\p{/a/ IDST}'); +Error('\P{/a/ IDST}'); +Expect(1, 12275, '\p{idst}', ""); +Expect(0, 12275, '\p{^idst}', ""); +Expect(0, 12275, '\P{idst}', ""); +Expect(1, 12275, '\P{^idst}', ""); +Expect(0, 12273, '\p{idst}', ""); +Expect(1, 12273, '\p{^idst}', ""); +Expect(1, 12273, '\P{idst}', ""); +Expect(0, 12273, '\P{^idst}', ""); +Expect(1, 12275, '\p{ IDST}', ""); +Expect(0, 12275, '\p{^ IDST}', ""); +Expect(0, 12275, '\P{ IDST}', ""); +Expect(1, 12275, '\P{^ IDST}', ""); +Expect(0, 12273, '\p{ IDST}', ""); +Expect(1, 12273, '\p{^ IDST}', ""); +Expect(1, 12273, '\P{ IDST}', ""); +Expect(0, 12273, '\P{^ IDST}', ""); +Error('\p{ _is_IDST:=}'); +Error('\P{ _is_IDST:=}'); +Expect(1, 12275, '\p{isidst}', ""); +Expect(0, 12275, '\p{^isidst}', ""); +Expect(0, 12275, '\P{isidst}', ""); +Expect(1, 12275, '\P{^isidst}', ""); +Expect(0, 12273, '\p{isidst}', ""); +Expect(1, 12273, '\p{^isidst}', ""); +Expect(1, 12273, '\P{isidst}', ""); +Expect(0, 12273, '\P{^isidst}', ""); +Expect(1, 12275, '\p{ -IS-IDST}', ""); +Expect(0, 12275, '\p{^ -IS-IDST}', ""); +Expect(0, 12275, '\P{ -IS-IDST}', ""); +Expect(1, 12275, '\P{^ -IS-IDST}', ""); +Expect(0, 12273, '\p{ -IS-IDST}', ""); +Expect(1, 12273, '\p{^ -IS-IDST}', ""); +Expect(1, 12273, '\P{ -IS-IDST}', ""); +Expect(0, 12273, '\P{^ -IS-IDST}', ""); +Error('\p{ cjk/a/radicals Supplement}'); +Error('\P{ cjk/a/radicals Supplement}'); +Expect(1, 12031, '\p{cjkradicalssupplement}', ""); +Expect(0, 12031, '\p{^cjkradicalssupplement}', ""); +Expect(0, 12031, '\P{cjkradicalssupplement}', ""); +Expect(1, 12031, '\P{^cjkradicalssupplement}', ""); +Expect(0, 11903, '\p{cjkradicalssupplement}', ""); +Expect(1, 11903, '\p{^cjkradicalssupplement}', ""); +Expect(1, 11903, '\P{cjkradicalssupplement}', ""); +Expect(0, 11903, '\P{^cjkradicalssupplement}', ""); +Expect(1, 12031, '\p{ CJK-RadicalsSUPPLEMENT}', ""); +Expect(0, 12031, '\p{^ CJK-RadicalsSUPPLEMENT}', ""); +Expect(0, 12031, '\P{ CJK-RadicalsSUPPLEMENT}', ""); +Expect(1, 12031, '\P{^ CJK-RadicalsSUPPLEMENT}', ""); +Expect(0, 11903, '\p{ CJK-RadicalsSUPPLEMENT}', ""); +Expect(1, 11903, '\p{^ CJK-RadicalsSUPPLEMENT}', ""); +Expect(1, 11903, '\P{ CJK-RadicalsSUPPLEMENT}', ""); +Expect(0, 11903, '\P{^ CJK-RadicalsSUPPLEMENT}', ""); +Error('\p{--Is cjk radicals/a/Supplement}'); +Error('\P{--Is cjk radicals/a/Supplement}'); +Expect(1, 12031, '\p{iscjkradicalssupplement}', ""); +Expect(0, 12031, '\p{^iscjkradicalssupplement}', ""); +Expect(0, 12031, '\P{iscjkradicalssupplement}', ""); +Expect(1, 12031, '\P{^iscjkradicalssupplement}', ""); +Expect(0, 11903, '\p{iscjkradicalssupplement}', ""); +Expect(1, 11903, '\p{^iscjkradicalssupplement}', ""); +Expect(1, 11903, '\P{iscjkradicalssupplement}', ""); +Expect(0, 11903, '\P{^iscjkradicalssupplement}', ""); +Expect(1, 12031, '\p{is CJK-Radicals supplement}', ""); +Expect(0, 12031, '\p{^is CJK-Radicals supplement}', ""); +Expect(0, 12031, '\P{is CJK-Radicals supplement}', ""); +Expect(1, 12031, '\P{^is CJK-Radicals supplement}', ""); +Expect(0, 11903, '\p{is CJK-Radicals supplement}', ""); +Expect(1, 11903, '\p{^is CJK-Radicals supplement}', ""); +Expect(1, 11903, '\P{is CJK-Radicals supplement}', ""); +Expect(0, 11903, '\P{^is CJK-Radicals supplement}', ""); +Error('\p{__IN CJK/a/RADICALS supplement}'); +Error('\P{__IN CJK/a/RADICALS supplement}'); +Expect(1, 12031, '\p{incjkradicalssupplement}', ""); +Expect(0, 12031, '\p{^incjkradicalssupplement}', ""); +Expect(0, 12031, '\P{incjkradicalssupplement}', ""); +Expect(1, 12031, '\P{^incjkradicalssupplement}', ""); +Expect(0, 11903, '\p{incjkradicalssupplement}', ""); +Expect(1, 11903, '\p{^incjkradicalssupplement}', ""); +Expect(1, 11903, '\P{incjkradicalssupplement}', ""); +Expect(0, 11903, '\P{^incjkradicalssupplement}', ""); +Expect(1, 12031, '\p{ Incjk_Radicals SUPPLEMENT}', ""); +Expect(0, 12031, '\p{^ Incjk_Radicals SUPPLEMENT}', ""); +Expect(0, 12031, '\P{ Incjk_Radicals SUPPLEMENT}', ""); +Expect(1, 12031, '\P{^ Incjk_Radicals SUPPLEMENT}', ""); +Expect(0, 11903, '\p{ Incjk_Radicals SUPPLEMENT}', ""); +Expect(1, 11903, '\p{^ Incjk_Radicals SUPPLEMENT}', ""); +Expect(1, 11903, '\P{ Incjk_Radicals SUPPLEMENT}', ""); +Expect(0, 11903, '\P{^ Incjk_Radicals SUPPLEMENT}', ""); +Error('\p{ /a/In Vai}'); +Error('\P{ /a/In Vai}'); +Expect(1, 42559, '\p{invai}', ""); +Expect(0, 42559, '\p{^invai}', ""); +Expect(0, 42559, '\P{invai}', ""); +Expect(1, 42559, '\P{^invai}', ""); +Expect(0, 42239, '\p{invai}', ""); +Expect(1, 42239, '\p{^invai}', ""); +Expect(1, 42239, '\P{invai}', ""); +Expect(0, 42239, '\P{^invai}', ""); +Expect(1, 42559, '\p{ _In_Vai}', ""); +Expect(0, 42559, '\p{^ _In_Vai}', ""); +Expect(0, 42559, '\P{ _In_Vai}', ""); +Expect(1, 42559, '\P{^ _In_Vai}', ""); +Expect(0, 42239, '\p{ _In_Vai}', ""); +Expect(1, 42239, '\p{^ _In_Vai}', ""); +Expect(1, 42239, '\P{ _In_Vai}', ""); +Expect(0, 42239, '\P{^ _In_Vai}', ""); +Error('\p{--Thaana:=}'); +Error('\P{--Thaana:=}'); +Expect(1, 1969, '\p{thaana}', ""); +Expect(0, 1969, '\p{^thaana}', ""); +Expect(0, 1969, '\P{thaana}', ""); +Expect(1, 1969, '\P{^thaana}', ""); +Expect(0, 1919, '\p{thaana}', ""); +Expect(1, 1919, '\p{^thaana}', ""); +Expect(1, 1919, '\P{thaana}', ""); +Expect(0, 1919, '\P{^thaana}', ""); +Expect(1, 1969, '\p{_ Thaana}', ""); +Expect(0, 1969, '\p{^_ Thaana}', ""); +Expect(0, 1969, '\P{_ Thaana}', ""); +Expect(1, 1969, '\P{^_ Thaana}', ""); +Expect(0, 1919, '\p{_ Thaana}', ""); +Expect(1, 1919, '\p{^_ Thaana}', ""); +Expect(1, 1919, '\P{_ Thaana}', ""); +Expect(0, 1919, '\P{^_ Thaana}', ""); +Error('\p{/a/_Is_THAANA}'); +Error('\P{/a/_Is_THAANA}'); +Expect(1, 1969, '\p{isthaana}', ""); +Expect(0, 1969, '\p{^isthaana}', ""); +Expect(0, 1969, '\P{isthaana}', ""); +Expect(1, 1969, '\P{^isthaana}', ""); +Expect(0, 1919, '\p{isthaana}', ""); +Expect(1, 1919, '\p{^isthaana}', ""); +Expect(1, 1919, '\P{isthaana}', ""); +Expect(0, 1919, '\P{^isthaana}', ""); +Expect(1, 1969, '\p{--is Thaana}', ""); +Expect(0, 1969, '\p{^--is Thaana}', ""); +Expect(0, 1969, '\P{--is Thaana}', ""); +Expect(1, 1969, '\P{^--is Thaana}', ""); +Expect(0, 1919, '\p{--is Thaana}', ""); +Expect(1, 1919, '\p{^--is Thaana}', ""); +Expect(1, 1919, '\P{--is Thaana}', ""); +Expect(0, 1919, '\P{^--is Thaana}', ""); +Error('\p{:= Thaa}'); +Error('\P{:= Thaa}'); +Expect(1, 1969, '\p{thaa}', ""); +Expect(0, 1969, '\p{^thaa}', ""); +Expect(0, 1969, '\P{thaa}', ""); +Expect(1, 1969, '\P{^thaa}', ""); +Expect(0, 1919, '\p{thaa}', ""); +Expect(1, 1919, '\p{^thaa}', ""); +Expect(1, 1919, '\P{thaa}', ""); +Expect(0, 1919, '\P{^thaa}', ""); +Expect(1, 1969, '\p{ _Thaa}', ""); +Expect(0, 1969, '\p{^ _Thaa}', ""); +Expect(0, 1969, '\P{ _Thaa}', ""); +Expect(1, 1969, '\P{^ _Thaa}', ""); +Expect(0, 1919, '\p{ _Thaa}', ""); +Expect(1, 1919, '\p{^ _Thaa}', ""); +Expect(1, 1919, '\P{ _Thaa}', ""); +Expect(0, 1919, '\P{^ _Thaa}', ""); +Error('\p{-_Is/a/thaa}'); +Error('\P{-_Is/a/thaa}'); +Expect(1, 1969, '\p{isthaa}', ""); +Expect(0, 1969, '\p{^isthaa}', ""); +Expect(0, 1969, '\P{isthaa}', ""); +Expect(1, 1969, '\P{^isthaa}', ""); +Expect(0, 1919, '\p{isthaa}', ""); +Expect(1, 1919, '\p{^isthaa}', ""); +Expect(1, 1919, '\P{isthaa}', ""); +Expect(0, 1919, '\P{^isthaa}', ""); +Expect(1, 1969, '\p{Is-Thaa}', ""); +Expect(0, 1969, '\p{^Is-Thaa}', ""); +Expect(0, 1969, '\P{Is-Thaa}', ""); +Expect(1, 1969, '\P{^Is-Thaa}', ""); +Expect(0, 1919, '\p{Is-Thaa}', ""); +Expect(1, 1919, '\p{^Is-Thaa}', ""); +Expect(1, 1919, '\P{Is-Thaa}', ""); +Expect(0, 1919, '\P{^Is-Thaa}', ""); +Error('\p{:=_OtherID START}'); +Error('\P{:=_OtherID START}'); +Expect(1, 8472, '\p{otheridstart}', 'deprecated'); +Expect(0, 8472, '\p{^otheridstart}', 'deprecated'); +Expect(0, 8472, '\P{otheridstart}', 'deprecated'); +Expect(1, 8472, '\P{^otheridstart}', 'deprecated'); +Expect(0, 8471, '\p{otheridstart}', 'deprecated'); +Expect(1, 8471, '\p{^otheridstart}', 'deprecated'); +Expect(1, 8471, '\P{otheridstart}', 'deprecated'); +Expect(0, 8471, '\P{^otheridstart}', 'deprecated'); +Expect(1, 8472, '\p{Other-ID_Start}', 'deprecated'); +Expect(0, 8472, '\p{^Other-ID_Start}', 'deprecated'); +Expect(0, 8472, '\P{Other-ID_Start}', 'deprecated'); +Expect(1, 8472, '\P{^Other-ID_Start}', 'deprecated'); +Expect(0, 8471, '\p{Other-ID_Start}', 'deprecated'); +Expect(1, 8471, '\p{^Other-ID_Start}', 'deprecated'); +Expect(1, 8471, '\P{Other-ID_Start}', 'deprecated'); +Expect(0, 8471, '\P{^Other-ID_Start}', 'deprecated'); +Error('\p{-:=ISOtherIDstart}'); +Error('\P{-:=ISOtherIDstart}'); +Expect(1, 8472, '\p{isotheridstart}', 'deprecated'); +Expect(0, 8472, '\p{^isotheridstart}', 'deprecated'); +Expect(0, 8472, '\P{isotheridstart}', 'deprecated'); +Expect(1, 8472, '\P{^isotheridstart}', 'deprecated'); +Expect(0, 8471, '\p{isotheridstart}', 'deprecated'); +Expect(1, 8471, '\p{^isotheridstart}', 'deprecated'); +Expect(1, 8471, '\P{isotheridstart}', 'deprecated'); +Expect(0, 8471, '\P{^isotheridstart}', 'deprecated'); +Expect(1, 8472, '\p{ IS other_IDSTART}', 'deprecated'); +Expect(0, 8472, '\p{^ IS other_IDSTART}', 'deprecated'); +Expect(0, 8472, '\P{ IS other_IDSTART}', 'deprecated'); +Expect(1, 8472, '\P{^ IS other_IDSTART}', 'deprecated'); +Expect(0, 8471, '\p{ IS other_IDSTART}', 'deprecated'); +Expect(1, 8471, '\p{^ IS other_IDSTART}', 'deprecated'); +Expect(1, 8471, '\P{ IS other_IDSTART}', 'deprecated'); +Expect(0, 8471, '\P{^ IS other_IDSTART}', 'deprecated'); +Error('\p{:=OIDS}'); +Error('\P{:=OIDS}'); +Expect(1, 8472, '\p{oids}', 'deprecated'); +Expect(0, 8472, '\p{^oids}', 'deprecated'); +Expect(0, 8472, '\P{oids}', 'deprecated'); +Expect(1, 8472, '\P{^oids}', 'deprecated'); +Expect(0, 8471, '\p{oids}', 'deprecated'); +Expect(1, 8471, '\p{^oids}', 'deprecated'); +Expect(1, 8471, '\P{oids}', 'deprecated'); +Expect(0, 8471, '\P{^oids}', 'deprecated'); +Expect(1, 8472, '\p{ -OIDS}', 'deprecated'); +Expect(0, 8472, '\p{^ -OIDS}', 'deprecated'); +Expect(0, 8472, '\P{ -OIDS}', 'deprecated'); +Expect(1, 8472, '\P{^ -OIDS}', 'deprecated'); +Expect(0, 8471, '\p{ -OIDS}', 'deprecated'); +Expect(1, 8471, '\p{^ -OIDS}', 'deprecated'); +Expect(1, 8471, '\P{ -OIDS}', 'deprecated'); +Expect(0, 8471, '\P{^ -OIDS}', 'deprecated'); +Error('\p{is_OIDS/a/}'); +Error('\P{is_OIDS/a/}'); +Expect(1, 8472, '\p{isoids}', 'deprecated'); +Expect(0, 8472, '\p{^isoids}', 'deprecated'); +Expect(0, 8472, '\P{isoids}', 'deprecated'); +Expect(1, 8472, '\P{^isoids}', 'deprecated'); +Expect(0, 8471, '\p{isoids}', 'deprecated'); +Expect(1, 8471, '\p{^isoids}', 'deprecated'); +Expect(1, 8471, '\P{isoids}', 'deprecated'); +Expect(0, 8471, '\P{^isoids}', 'deprecated'); +Expect(1, 8472, '\p{-_is oids}', 'deprecated'); +Expect(0, 8472, '\p{^-_is oids}', 'deprecated'); +Expect(0, 8472, '\P{-_is oids}', 'deprecated'); +Expect(1, 8472, '\P{^-_is oids}', 'deprecated'); +Expect(0, 8471, '\p{-_is oids}', 'deprecated'); +Expect(1, 8471, '\p{^-_is oids}', 'deprecated'); +Expect(1, 8471, '\P{-_is oids}', 'deprecated'); +Expect(0, 8471, '\P{^-_is oids}', 'deprecated'); +Error('\p{/a/-SPECIALS}'); +Error('\P{/a/-SPECIALS}'); +Expect(1, 65520, '\p{specials}', ""); +Expect(0, 65520, '\p{^specials}', ""); +Expect(0, 65520, '\P{specials}', ""); +Expect(1, 65520, '\P{^specials}', ""); +Expect(0, 65519, '\p{specials}', ""); +Expect(1, 65519, '\p{^specials}', ""); +Expect(1, 65519, '\P{specials}', ""); +Expect(0, 65519, '\P{^specials}', ""); +Expect(1, 65520, '\p{__Specials}', ""); +Expect(0, 65520, '\p{^__Specials}', ""); +Expect(0, 65520, '\P{__Specials}', ""); +Expect(1, 65520, '\P{^__Specials}', ""); +Expect(0, 65519, '\p{__Specials}', ""); +Expect(1, 65519, '\p{^__Specials}', ""); +Expect(1, 65519, '\P{__Specials}', ""); +Expect(0, 65519, '\P{^__Specials}', ""); +Error('\p{ _IS Specials:=}'); +Error('\P{ _IS Specials:=}'); +Expect(1, 65520, '\p{isspecials}', ""); +Expect(0, 65520, '\p{^isspecials}', ""); +Expect(0, 65520, '\P{isspecials}', ""); +Expect(1, 65520, '\P{^isspecials}', ""); +Expect(0, 65519, '\p{isspecials}', ""); +Expect(1, 65519, '\p{^isspecials}', ""); +Expect(1, 65519, '\P{isspecials}', ""); +Expect(0, 65519, '\P{^isspecials}', ""); +Expect(1, 65520, '\p{ Is Specials}', ""); +Expect(0, 65520, '\p{^ Is Specials}', ""); +Expect(0, 65520, '\P{ Is Specials}', ""); +Expect(1, 65520, '\P{^ Is Specials}', ""); +Expect(0, 65519, '\p{ Is Specials}', ""); +Expect(1, 65519, '\p{^ Is Specials}', ""); +Expect(1, 65519, '\P{ Is Specials}', ""); +Expect(0, 65519, '\P{^ Is Specials}', ""); +Error('\p{ /a/INSpecials}'); +Error('\P{ /a/INSpecials}'); +Expect(1, 65520, '\p{inspecials}', ""); +Expect(0, 65520, '\p{^inspecials}', ""); +Expect(0, 65520, '\P{inspecials}', ""); +Expect(1, 65520, '\P{^inspecials}', ""); +Expect(0, 65519, '\p{inspecials}', ""); +Expect(1, 65519, '\p{^inspecials}', ""); +Expect(1, 65519, '\P{inspecials}', ""); +Expect(0, 65519, '\P{^inspecials}', ""); +Expect(1, 65520, '\p{-In-Specials}', ""); +Expect(0, 65520, '\p{^-In-Specials}', ""); +Expect(0, 65520, '\P{-In-Specials}', ""); +Expect(1, 65520, '\P{^-In-Specials}', ""); +Expect(0, 65519, '\p{-In-Specials}', ""); +Expect(1, 65519, '\p{^-In-Specials}', ""); +Expect(1, 65519, '\P{-In-Specials}', ""); +Expect(0, 65519, '\P{^-In-Specials}', ""); +Error('\p{-MATHEMATICAL Operators:=}'); +Error('\P{-MATHEMATICAL Operators:=}'); +Expect(1, 8959, '\p{mathematicaloperators}', ""); +Expect(0, 8959, '\p{^mathematicaloperators}', ""); +Expect(0, 8959, '\P{mathematicaloperators}', ""); +Expect(1, 8959, '\P{^mathematicaloperators}', ""); +Expect(0, 8703, '\p{mathematicaloperators}', ""); +Expect(1, 8703, '\p{^mathematicaloperators}', ""); +Expect(1, 8703, '\P{mathematicaloperators}', ""); +Expect(0, 8703, '\P{^mathematicaloperators}', ""); +Expect(1, 8959, '\p{_ mathematical operators}', ""); +Expect(0, 8959, '\p{^_ mathematical operators}', ""); +Expect(0, 8959, '\P{_ mathematical operators}', ""); +Expect(1, 8959, '\P{^_ mathematical operators}', ""); +Expect(0, 8703, '\p{_ mathematical operators}', ""); +Expect(1, 8703, '\p{^_ mathematical operators}', ""); +Expect(1, 8703, '\P{_ mathematical operators}', ""); +Expect(0, 8703, '\P{^_ mathematical operators}', ""); +Error('\p{ is mathematical/a/operators}'); +Error('\P{ is mathematical/a/operators}'); +Expect(1, 8959, '\p{ismathematicaloperators}', ""); +Expect(0, 8959, '\p{^ismathematicaloperators}', ""); +Expect(0, 8959, '\P{ismathematicaloperators}', ""); +Expect(1, 8959, '\P{^ismathematicaloperators}', ""); +Expect(0, 8703, '\p{ismathematicaloperators}', ""); +Expect(1, 8703, '\p{^ismathematicaloperators}', ""); +Expect(1, 8703, '\P{ismathematicaloperators}', ""); +Expect(0, 8703, '\P{^ismathematicaloperators}', ""); +Expect(1, 8959, '\p{_ISMathematicalOPERATORS}', ""); +Expect(0, 8959, '\p{^_ISMathematicalOPERATORS}', ""); +Expect(0, 8959, '\P{_ISMathematicalOPERATORS}', ""); +Expect(1, 8959, '\P{^_ISMathematicalOPERATORS}', ""); +Expect(0, 8703, '\p{_ISMathematicalOPERATORS}', ""); +Expect(1, 8703, '\p{^_ISMathematicalOPERATORS}', ""); +Expect(1, 8703, '\P{_ISMathematicalOPERATORS}', ""); +Expect(0, 8703, '\P{^_ISMathematicalOPERATORS}', ""); +Error('\p{- inMathematical/a/Operators}'); +Error('\P{- inMathematical/a/Operators}'); +Expect(1, 8959, '\p{inmathematicaloperators}', ""); +Expect(0, 8959, '\p{^inmathematicaloperators}', ""); +Expect(0, 8959, '\P{inmathematicaloperators}', ""); +Expect(1, 8959, '\P{^inmathematicaloperators}', ""); +Expect(0, 8703, '\p{inmathematicaloperators}', ""); +Expect(1, 8703, '\p{^inmathematicaloperators}', ""); +Expect(1, 8703, '\P{inmathematicaloperators}', ""); +Expect(0, 8703, '\P{^inmathematicaloperators}', ""); +Expect(1, 8959, '\p{ -In_mathematical Operators}', ""); +Expect(0, 8959, '\p{^ -In_mathematical Operators}', ""); +Expect(0, 8959, '\P{ -In_mathematical Operators}', ""); +Expect(1, 8959, '\P{^ -In_mathematical Operators}', ""); +Expect(0, 8703, '\p{ -In_mathematical Operators}', ""); +Expect(1, 8703, '\p{^ -In_mathematical Operators}', ""); +Expect(1, 8703, '\P{ -In_mathematical Operators}', ""); +Expect(0, 8703, '\P{^ -In_mathematical Operators}', ""); +Error('\p{:=- Bidi Mirrored}'); +Error('\P{:=- Bidi Mirrored}'); +Expect(1, 41, '\p{bidimirrored}', ""); +Expect(0, 41, '\p{^bidimirrored}', ""); +Expect(0, 41, '\P{bidimirrored}', ""); +Expect(1, 41, '\P{^bidimirrored}', ""); +Expect(0, 39, '\p{bidimirrored}', ""); +Expect(1, 39, '\p{^bidimirrored}', ""); +Expect(1, 39, '\P{bidimirrored}', ""); +Expect(0, 39, '\P{^bidimirrored}', ""); +Expect(1, 41, '\p{ _bidi-MIRRORED}', ""); +Expect(0, 41, '\p{^ _bidi-MIRRORED}', ""); +Expect(0, 41, '\P{ _bidi-MIRRORED}', ""); +Expect(1, 41, '\P{^ _bidi-MIRRORED}', ""); +Expect(0, 39, '\p{ _bidi-MIRRORED}', ""); +Expect(1, 39, '\p{^ _bidi-MIRRORED}', ""); +Expect(1, 39, '\P{ _bidi-MIRRORED}', ""); +Expect(0, 39, '\P{^ _bidi-MIRRORED}', ""); +Error('\p{ Is_bidiMirrored:=}'); +Error('\P{ Is_bidiMirrored:=}'); +Expect(1, 41, '\p{isbidimirrored}', ""); +Expect(0, 41, '\p{^isbidimirrored}', ""); +Expect(0, 41, '\P{isbidimirrored}', ""); +Expect(1, 41, '\P{^isbidimirrored}', ""); +Expect(0, 39, '\p{isbidimirrored}', ""); +Expect(1, 39, '\p{^isbidimirrored}', ""); +Expect(1, 39, '\P{isbidimirrored}', ""); +Expect(0, 39, '\P{^isbidimirrored}', ""); +Expect(1, 41, '\p{- Is Bidi MIRRORED}', ""); +Expect(0, 41, '\p{^- Is Bidi MIRRORED}', ""); +Expect(0, 41, '\P{- Is Bidi MIRRORED}', ""); +Expect(1, 41, '\P{^- Is Bidi MIRRORED}', ""); +Expect(0, 39, '\p{- Is Bidi MIRRORED}', ""); +Expect(1, 39, '\p{^- Is Bidi MIRRORED}', ""); +Expect(1, 39, '\P{- Is Bidi MIRRORED}', ""); +Expect(0, 39, '\P{^- Is Bidi MIRRORED}', ""); +Error('\p{ :=Bidi_m}'); +Error('\P{ :=Bidi_m}'); +Expect(1, 41, '\p{bidim}', ""); +Expect(0, 41, '\p{^bidim}', ""); +Expect(0, 41, '\P{bidim}', ""); +Expect(1, 41, '\P{^bidim}', ""); +Expect(0, 39, '\p{bidim}', ""); +Expect(1, 39, '\p{^bidim}', ""); +Expect(1, 39, '\P{bidim}', ""); +Expect(0, 39, '\P{^bidim}', ""); +Expect(1, 41, '\p{ Bidi_M}', ""); +Expect(0, 41, '\p{^ Bidi_M}', ""); +Expect(0, 41, '\P{ Bidi_M}', ""); +Expect(1, 41, '\P{^ Bidi_M}', ""); +Expect(0, 39, '\p{ Bidi_M}', ""); +Expect(1, 39, '\p{^ Bidi_M}', ""); +Expect(1, 39, '\P{ Bidi_M}', ""); +Expect(0, 39, '\P{^ Bidi_M}', ""); +Error('\p{/a/-_Is Bidi M}'); +Error('\P{/a/-_Is Bidi M}'); +Expect(1, 41, '\p{isbidim}', ""); +Expect(0, 41, '\p{^isbidim}', ""); +Expect(0, 41, '\P{isbidim}', ""); +Expect(1, 41, '\P{^isbidim}', ""); +Expect(0, 39, '\p{isbidim}', ""); +Expect(1, 39, '\p{^isbidim}', ""); +Expect(1, 39, '\P{isbidim}', ""); +Expect(0, 39, '\P{^isbidim}', ""); +Expect(1, 41, '\p{ ISBIDI-M}', ""); +Expect(0, 41, '\p{^ ISBIDI-M}', ""); +Expect(0, 41, '\P{ ISBIDI-M}', ""); +Expect(1, 41, '\P{^ ISBIDI-M}', ""); +Expect(0, 39, '\p{ ISBIDI-M}', ""); +Expect(1, 39, '\p{^ ISBIDI-M}', ""); +Expect(1, 39, '\P{ ISBIDI-M}', ""); +Expect(0, 39, '\P{^ ISBIDI-M}', ""); +Error('\p{Katakana_Or_Hiragana}'); +Error('\P{Katakana_Or_Hiragana}'); +Error('\p{Is_Katakana_Or_Hiragana}'); +Error('\P{Is_Katakana_Or_Hiragana}'); +Error('\p{Hrkt}'); +Error('\P{Hrkt}'); +Error('\p{Is_Hrkt}'); +Error('\P{Is_Hrkt}'); +Error('\p{ _OtherSYMBOL/a/}'); +Error('\P{ _OtherSYMBOL/a/}'); +Expect(1, 1154, '\p{othersymbol}', ""); +Expect(0, 1154, '\p{^othersymbol}', ""); +Expect(0, 1154, '\P{othersymbol}', ""); +Expect(1, 1154, '\P{^othersymbol}', ""); +Expect(0, 7, '\p{othersymbol}', ""); +Expect(1, 7, '\p{^othersymbol}', ""); +Expect(1, 7, '\P{othersymbol}', ""); +Expect(0, 7, '\P{^othersymbol}', ""); +Expect(1, 1154, '\p{-_Other_SYMBOL}', ""); +Expect(0, 1154, '\p{^-_Other_SYMBOL}', ""); +Expect(0, 1154, '\P{-_Other_SYMBOL}', ""); +Expect(1, 1154, '\P{^-_Other_SYMBOL}', ""); +Expect(0, 7, '\p{-_Other_SYMBOL}', ""); +Expect(1, 7, '\p{^-_Other_SYMBOL}', ""); +Expect(1, 7, '\P{-_Other_SYMBOL}', ""); +Expect(0, 7, '\P{^-_Other_SYMBOL}', ""); +Error('\p{ :=ISOther_SYMBOL}'); +Error('\P{ :=ISOther_SYMBOL}'); +Expect(1, 1154, '\p{isothersymbol}', ""); +Expect(0, 1154, '\p{^isothersymbol}', ""); +Expect(0, 1154, '\P{isothersymbol}', ""); +Expect(1, 1154, '\P{^isothersymbol}', ""); +Expect(0, 7, '\p{isothersymbol}', ""); +Expect(1, 7, '\p{^isothersymbol}', ""); +Expect(1, 7, '\P{isothersymbol}', ""); +Expect(0, 7, '\P{^isothersymbol}', ""); +Expect(1, 1154, '\p{_-is-OTHER SYMBOL}', ""); +Expect(0, 1154, '\p{^_-is-OTHER SYMBOL}', ""); +Expect(0, 1154, '\P{_-is-OTHER SYMBOL}', ""); +Expect(1, 1154, '\P{^_-is-OTHER SYMBOL}', ""); +Expect(0, 7, '\p{_-is-OTHER SYMBOL}', ""); +Expect(1, 7, '\p{^_-is-OTHER SYMBOL}', ""); +Expect(1, 7, '\P{_-is-OTHER SYMBOL}', ""); +Expect(0, 7, '\P{^_-is-OTHER SYMBOL}', ""); +Error('\p{:=- So}'); +Error('\P{:=- So}'); +Expect(1, 1154, '\p{so}', ""); +Expect(0, 1154, '\p{^so}', ""); +Expect(0, 1154, '\P{so}', ""); +Expect(1, 1154, '\P{^so}', ""); +Expect(0, 7, '\p{so}', ""); +Expect(1, 7, '\p{^so}', ""); +Expect(1, 7, '\P{so}', ""); +Expect(0, 7, '\P{^so}', ""); +Expect(1, 1154, '\p{- so}', ""); +Expect(0, 1154, '\p{^- so}', ""); +Expect(0, 1154, '\P{- so}', ""); +Expect(1, 1154, '\P{^- so}', ""); +Expect(0, 7, '\p{- so}', ""); +Expect(1, 7, '\p{^- so}', ""); +Expect(1, 7, '\P{- so}', ""); +Expect(0, 7, '\P{^- so}', ""); +Error('\p{/a/is_so}'); +Error('\P{/a/is_so}'); +Expect(1, 1154, '\p{isso}', ""); +Expect(0, 1154, '\p{^isso}', ""); +Expect(0, 1154, '\P{isso}', ""); +Expect(1, 1154, '\P{^isso}', ""); +Expect(0, 7, '\p{isso}', ""); +Expect(1, 7, '\p{^isso}', ""); +Expect(1, 7, '\P{isso}', ""); +Expect(0, 7, '\P{^isso}', ""); +Expect(1, 1154, '\p{ _IS_so}', ""); +Expect(0, 1154, '\p{^ _IS_so}', ""); +Expect(0, 1154, '\P{ _IS_so}', ""); +Expect(1, 1154, '\P{^ _IS_so}', ""); +Expect(0, 7, '\p{ _IS_so}', ""); +Expect(1, 7, '\p{^ _IS_so}', ""); +Expect(1, 7, '\P{ _IS_so}', ""); +Expect(0, 7, '\P{^ _IS_so}', ""); +Error('\p{:=- ANY}'); +Error('\P{:=- ANY}'); +Expect(1, 7, '\p{any}', ""); +Expect(0, 7, '\p{^any}', ""); +Expect(0, 7, '\P{any}', ""); +Expect(1, 7, '\P{^any}', ""); +Expect(1, 7, '\p{- Any}', ""); +Expect(0, 7, '\p{^- Any}', ""); +Expect(0, 7, '\P{- Any}', ""); +Expect(1, 7, '\P{^- Any}', ""); +Error('\p{--ALL:=}'); +Error('\P{--ALL:=}'); +Expect(1, 7, '\p{all}', ""); +Expect(0, 7, '\p{^all}', ""); +Expect(0, 7, '\P{all}', ""); +Expect(1, 7, '\P{^all}', ""); +Expect(1, 7, '\p{ All}', ""); +Expect(0, 7, '\p{^ All}', ""); +Expect(0, 7, '\P{ All}', ""); +Expect(1, 7, '\P{^ All}', ""); +Error('\p{:= Isany}'); +Error('\P{:= Isany}'); +Expect(1, 7, '\p{isany}', ""); +Expect(0, 7, '\p{^isany}', ""); +Expect(0, 7, '\P{isany}', ""); +Expect(1, 7, '\P{^isany}', ""); +Expect(1, 7, '\p{- Is Any}', ""); +Expect(0, 7, '\p{^- Is Any}', ""); +Expect(0, 7, '\P{- Is Any}', ""); +Expect(1, 7, '\P{^- Is Any}', ""); +Error('\p{_/a/IS All}'); +Error('\P{_/a/IS All}'); +Expect(1, 7, '\p{isall}', ""); +Expect(0, 7, '\p{^isall}', ""); +Expect(0, 7, '\P{isall}', ""); +Expect(1, 7, '\P{^isall}', ""); +Expect(1, 7, '\p{ IS all}', ""); +Expect(0, 7, '\p{^ IS all}', ""); +Expect(0, 7, '\P{ IS all}', ""); +Expect(1, 7, '\P{^ IS all}', ""); +Error('\p{/a/_-OTHER-letter}'); +Error('\P{/a/_-OTHER-letter}'); +Expect(1, 443, '\p{otherletter}', ""); +Expect(0, 443, '\p{^otherletter}', ""); +Expect(0, 443, '\P{otherletter}', ""); +Expect(1, 443, '\P{^otherletter}', ""); +Expect(0, 442, '\p{otherletter}', ""); +Expect(1, 442, '\p{^otherletter}', ""); +Expect(1, 442, '\P{otherletter}', ""); +Expect(0, 442, '\P{^otherletter}', ""); +Expect(1, 443, '\p{ -OtherLetter}', ""); +Expect(0, 443, '\p{^ -OtherLetter}', ""); +Expect(0, 443, '\P{ -OtherLetter}', ""); +Expect(1, 443, '\P{^ -OtherLetter}', ""); +Expect(0, 442, '\p{ -OtherLetter}', ""); +Expect(1, 442, '\p{^ -OtherLetter}', ""); +Expect(1, 442, '\P{ -OtherLetter}', ""); +Expect(0, 442, '\P{^ -OtherLetter}', ""); +Error('\p{ IS:=Other_Letter}'); +Error('\P{ IS:=Other_Letter}'); +Expect(1, 443, '\p{isotherletter}', ""); +Expect(0, 443, '\p{^isotherletter}', ""); +Expect(0, 443, '\P{isotherletter}', ""); +Expect(1, 443, '\P{^isotherletter}', ""); +Expect(0, 442, '\p{isotherletter}', ""); +Expect(1, 442, '\p{^isotherletter}', ""); +Expect(1, 442, '\P{isotherletter}', ""); +Expect(0, 442, '\P{^isotherletter}', ""); +Expect(1, 443, '\p{ Is other Letter}', ""); +Expect(0, 443, '\p{^ Is other Letter}', ""); +Expect(0, 443, '\P{ Is other Letter}', ""); +Expect(1, 443, '\P{^ Is other Letter}', ""); +Expect(0, 442, '\p{ Is other Letter}', ""); +Expect(1, 442, '\p{^ Is other Letter}', ""); +Expect(1, 442, '\P{ Is other Letter}', ""); +Expect(0, 442, '\P{^ Is other Letter}', ""); +Error('\p{_LO:=}'); +Error('\P{_LO:=}'); +Expect(1, 443, '\p{lo}', ""); +Expect(0, 443, '\p{^lo}', ""); +Expect(0, 443, '\P{lo}', ""); +Expect(1, 443, '\P{^lo}', ""); +Expect(0, 442, '\p{lo}', ""); +Expect(1, 442, '\p{^lo}', ""); +Expect(1, 442, '\P{lo}', ""); +Expect(0, 442, '\P{^lo}', ""); +Expect(1, 443, '\p{_-lo}', ""); +Expect(0, 443, '\p{^_-lo}', ""); +Expect(0, 443, '\P{_-lo}', ""); +Expect(1, 443, '\P{^_-lo}', ""); +Expect(0, 442, '\p{_-lo}', ""); +Expect(1, 442, '\p{^_-lo}', ""); +Expect(1, 442, '\P{_-lo}', ""); +Expect(0, 442, '\P{^_-lo}', ""); +Error('\p{:=_-is-LO}'); +Error('\P{:=_-is-LO}'); +Expect(1, 443, '\p{islo}', ""); +Expect(0, 443, '\p{^islo}', ""); +Expect(0, 443, '\P{islo}', ""); +Expect(1, 443, '\P{^islo}', ""); +Expect(0, 442, '\p{islo}', ""); +Expect(1, 442, '\p{^islo}', ""); +Expect(1, 442, '\P{islo}', ""); +Expect(0, 442, '\P{^islo}', ""); +Expect(1, 443, '\p{_ IS_lo}', ""); +Expect(0, 443, '\p{^_ IS_lo}', ""); +Expect(0, 443, '\P{_ IS_lo}', ""); +Expect(1, 443, '\P{^_ IS_lo}', ""); +Expect(0, 442, '\p{_ IS_lo}', ""); +Expect(1, 442, '\p{^_ IS_lo}', ""); +Expect(1, 442, '\P{_ IS_lo}', ""); +Expect(0, 442, '\P{^_ IS_lo}', ""); +Error('\p{-Other/a/DEFAULT ignorable code Point}'); +Error('\P{-Other/a/DEFAULT ignorable code Point}'); +Expect(1, 847, '\p{otherdefaultignorablecodepoint}', 'deprecated'); +Expect(0, 847, '\p{^otherdefaultignorablecodepoint}', 'deprecated'); +Expect(0, 847, '\P{otherdefaultignorablecodepoint}', 'deprecated'); +Expect(1, 847, '\P{^otherdefaultignorablecodepoint}', 'deprecated'); +Expect(0, 846, '\p{otherdefaultignorablecodepoint}', 'deprecated'); +Expect(1, 846, '\p{^otherdefaultignorablecodepoint}', 'deprecated'); +Expect(1, 846, '\P{otherdefaultignorablecodepoint}', 'deprecated'); +Expect(0, 846, '\P{^otherdefaultignorablecodepoint}', 'deprecated'); +Expect(1, 847, '\p{-Other-Default_Ignorable-Codepoint}', 'deprecated'); +Expect(0, 847, '\p{^-Other-Default_Ignorable-Codepoint}', 'deprecated'); +Expect(0, 847, '\P{-Other-Default_Ignorable-Codepoint}', 'deprecated'); +Expect(1, 847, '\P{^-Other-Default_Ignorable-Codepoint}', 'deprecated'); +Expect(0, 846, '\p{-Other-Default_Ignorable-Codepoint}', 'deprecated'); +Expect(1, 846, '\p{^-Other-Default_Ignorable-Codepoint}', 'deprecated'); +Expect(1, 846, '\P{-Other-Default_Ignorable-Codepoint}', 'deprecated'); +Expect(0, 846, '\P{^-Other-Default_Ignorable-Codepoint}', 'deprecated'); +Error('\p{ -is_Other:=Default IGNORABLECode-point}'); +Error('\P{ -is_Other:=Default IGNORABLECode-point}'); +Expect(1, 847, '\p{isotherdefaultignorablecodepoint}', 'deprecated'); +Expect(0, 847, '\p{^isotherdefaultignorablecodepoint}', 'deprecated'); +Expect(0, 847, '\P{isotherdefaultignorablecodepoint}', 'deprecated'); +Expect(1, 847, '\P{^isotherdefaultignorablecodepoint}', 'deprecated'); +Expect(0, 846, '\p{isotherdefaultignorablecodepoint}', 'deprecated'); +Expect(1, 846, '\p{^isotherdefaultignorablecodepoint}', 'deprecated'); +Expect(1, 846, '\P{isotherdefaultignorablecodepoint}', 'deprecated'); +Expect(0, 846, '\P{^isotherdefaultignorablecodepoint}', 'deprecated'); +Expect(1, 847, '\p{--IS-Other Default IgnorableCode-Point}', 'deprecated'); +Expect(0, 847, '\p{^--IS-Other Default IgnorableCode-Point}', 'deprecated'); +Expect(0, 847, '\P{--IS-Other Default IgnorableCode-Point}', 'deprecated'); +Expect(1, 847, '\P{^--IS-Other Default IgnorableCode-Point}', 'deprecated'); +Expect(0, 846, '\p{--IS-Other Default IgnorableCode-Point}', 'deprecated'); +Expect(1, 846, '\p{^--IS-Other Default IgnorableCode-Point}', 'deprecated'); +Expect(1, 846, '\P{--IS-Other Default IgnorableCode-Point}', 'deprecated'); +Expect(0, 846, '\P{^--IS-Other Default IgnorableCode-Point}', 'deprecated'); +Error('\p{ odi:=}'); +Error('\P{ odi:=}'); +Expect(1, 847, '\p{odi}', 'deprecated'); +Expect(0, 847, '\p{^odi}', 'deprecated'); +Expect(0, 847, '\P{odi}', 'deprecated'); +Expect(1, 847, '\P{^odi}', 'deprecated'); +Expect(0, 846, '\p{odi}', 'deprecated'); +Expect(1, 846, '\p{^odi}', 'deprecated'); +Expect(1, 846, '\P{odi}', 'deprecated'); +Expect(0, 846, '\P{^odi}', 'deprecated'); +Expect(1, 847, '\p{_ odi}', 'deprecated'); +Expect(0, 847, '\p{^_ odi}', 'deprecated'); +Expect(0, 847, '\P{_ odi}', 'deprecated'); +Expect(1, 847, '\P{^_ odi}', 'deprecated'); +Expect(0, 846, '\p{_ odi}', 'deprecated'); +Expect(1, 846, '\p{^_ odi}', 'deprecated'); +Expect(1, 846, '\P{_ odi}', 'deprecated'); +Expect(0, 846, '\P{^_ odi}', 'deprecated'); +Error('\p{ /a/ISODI}'); +Error('\P{ /a/ISODI}'); +Expect(1, 847, '\p{isodi}', 'deprecated'); +Expect(0, 847, '\p{^isodi}', 'deprecated'); +Expect(0, 847, '\P{isodi}', 'deprecated'); +Expect(1, 847, '\P{^isodi}', 'deprecated'); +Expect(0, 846, '\p{isodi}', 'deprecated'); +Expect(1, 846, '\p{^isodi}', 'deprecated'); +Expect(1, 846, '\P{isodi}', 'deprecated'); +Expect(0, 846, '\P{^isodi}', 'deprecated'); +Expect(1, 847, '\p{--Is ODI}', 'deprecated'); +Expect(0, 847, '\p{^--Is ODI}', 'deprecated'); +Expect(0, 847, '\P{--Is ODI}', 'deprecated'); +Expect(1, 847, '\P{^--Is ODI}', 'deprecated'); +Expect(0, 846, '\p{--Is ODI}', 'deprecated'); +Expect(1, 846, '\p{^--Is ODI}', 'deprecated'); +Expect(1, 846, '\P{--Is ODI}', 'deprecated'); +Expect(0, 846, '\P{^--Is ODI}', 'deprecated'); +Error('\p{ Sundanese:=}'); +Error('\P{ Sundanese:=}'); +Expect(1, 7082, '\p{sundanese}', ""); +Expect(0, 7082, '\p{^sundanese}', ""); +Expect(0, 7082, '\P{sundanese}', ""); +Expect(1, 7082, '\P{^sundanese}', ""); +Expect(0, 7039, '\p{sundanese}', ""); +Expect(1, 7039, '\p{^sundanese}', ""); +Expect(1, 7039, '\P{sundanese}', ""); +Expect(0, 7039, '\P{^sundanese}', ""); +Expect(1, 7082, '\p{-Sundanese}', ""); +Expect(0, 7082, '\p{^-Sundanese}', ""); +Expect(0, 7082, '\P{-Sundanese}', ""); +Expect(1, 7082, '\P{^-Sundanese}', ""); +Expect(0, 7039, '\p{-Sundanese}', ""); +Expect(1, 7039, '\p{^-Sundanese}', ""); +Expect(1, 7039, '\P{-Sundanese}', ""); +Expect(0, 7039, '\P{^-Sundanese}', ""); +Error('\p{-:=is sundanese}'); +Error('\P{-:=is sundanese}'); +Expect(1, 7082, '\p{issundanese}', ""); +Expect(0, 7082, '\p{^issundanese}', ""); +Expect(0, 7082, '\P{issundanese}', ""); +Expect(1, 7082, '\P{^issundanese}', ""); +Expect(0, 7039, '\p{issundanese}', ""); +Expect(1, 7039, '\p{^issundanese}', ""); +Expect(1, 7039, '\P{issundanese}', ""); +Expect(0, 7039, '\P{^issundanese}', ""); +Expect(1, 7082, '\p{- Is-SUNDANESE}', ""); +Expect(0, 7082, '\p{^- Is-SUNDANESE}', ""); +Expect(0, 7082, '\P{- Is-SUNDANESE}', ""); +Expect(1, 7082, '\P{^- Is-SUNDANESE}', ""); +Expect(0, 7039, '\p{- Is-SUNDANESE}', ""); +Expect(1, 7039, '\p{^- Is-SUNDANESE}', ""); +Expect(1, 7039, '\P{- Is-SUNDANESE}', ""); +Expect(0, 7039, '\P{^- Is-SUNDANESE}', ""); +Error('\p{ sund/a/}'); +Error('\P{ sund/a/}'); +Expect(1, 7082, '\p{sund}', ""); +Expect(0, 7082, '\p{^sund}', ""); +Expect(0, 7082, '\P{sund}', ""); +Expect(1, 7082, '\P{^sund}', ""); +Expect(0, 7039, '\p{sund}', ""); +Expect(1, 7039, '\p{^sund}', ""); +Expect(1, 7039, '\P{sund}', ""); +Expect(0, 7039, '\P{^sund}', ""); +Expect(1, 7082, '\p{_Sund}', ""); +Expect(0, 7082, '\p{^_Sund}', ""); +Expect(0, 7082, '\P{_Sund}', ""); +Expect(1, 7082, '\P{^_Sund}', ""); +Expect(0, 7039, '\p{_Sund}', ""); +Expect(1, 7039, '\p{^_Sund}', ""); +Expect(1, 7039, '\P{_Sund}', ""); +Expect(0, 7039, '\P{^_Sund}', ""); +Error('\p{ -IS/a/Sund}'); +Error('\P{ -IS/a/Sund}'); +Expect(1, 7082, '\p{issund}', ""); +Expect(0, 7082, '\p{^issund}', ""); +Expect(0, 7082, '\P{issund}', ""); +Expect(1, 7082, '\P{^issund}', ""); +Expect(0, 7039, '\p{issund}', ""); +Expect(1, 7039, '\p{^issund}', ""); +Expect(1, 7039, '\P{issund}', ""); +Expect(0, 7039, '\P{^issund}', ""); +Expect(1, 7082, '\p{ IS-sund}', ""); +Expect(0, 7082, '\p{^ IS-sund}', ""); +Expect(0, 7082, '\P{ IS-sund}', ""); +Expect(1, 7082, '\P{^ IS-sund}', ""); +Expect(0, 7039, '\p{ IS-sund}', ""); +Expect(1, 7039, '\p{^ IS-sund}', ""); +Expect(1, 7039, '\P{ IS-sund}', ""); +Expect(0, 7039, '\P{^ IS-sund}', ""); +Error('\p{ Carian/a/}'); +Error('\P{ Carian/a/}'); +Expect(1, 66256, '\p{carian}', ""); +Expect(0, 66256, '\p{^carian}', ""); +Expect(0, 66256, '\P{carian}', ""); +Expect(1, 66256, '\P{^carian}', ""); +Expect(0, 66207, '\p{carian}', ""); +Expect(1, 66207, '\p{^carian}', ""); +Expect(1, 66207, '\P{carian}', ""); +Expect(0, 66207, '\P{^carian}', ""); +Expect(1, 66256, '\p{ -Carian}', ""); +Expect(0, 66256, '\p{^ -Carian}', ""); +Expect(0, 66256, '\P{ -Carian}', ""); +Expect(1, 66256, '\P{^ -Carian}', ""); +Expect(0, 66207, '\p{ -Carian}', ""); +Expect(1, 66207, '\p{^ -Carian}', ""); +Expect(1, 66207, '\P{ -Carian}', ""); +Expect(0, 66207, '\P{^ -Carian}', ""); +Error('\p{-_ISCARIAN/a/}'); +Error('\P{-_ISCARIAN/a/}'); +Expect(1, 66256, '\p{iscarian}', ""); +Expect(0, 66256, '\p{^iscarian}', ""); +Expect(0, 66256, '\P{iscarian}', ""); +Expect(1, 66256, '\P{^iscarian}', ""); +Expect(0, 66207, '\p{iscarian}', ""); +Expect(1, 66207, '\p{^iscarian}', ""); +Expect(1, 66207, '\P{iscarian}', ""); +Expect(0, 66207, '\P{^iscarian}', ""); +Expect(1, 66256, '\p{-Is carian}', ""); +Expect(0, 66256, '\p{^-Is carian}', ""); +Expect(0, 66256, '\P{-Is carian}', ""); +Expect(1, 66256, '\P{^-Is carian}', ""); +Expect(0, 66207, '\p{-Is carian}', ""); +Expect(1, 66207, '\p{^-Is carian}', ""); +Expect(1, 66207, '\P{-Is carian}', ""); +Expect(0, 66207, '\P{^-Is carian}', ""); +Error('\p{/a/ -Cari}'); +Error('\P{/a/ -Cari}'); +Expect(1, 66256, '\p{cari}', ""); +Expect(0, 66256, '\p{^cari}', ""); +Expect(0, 66256, '\P{cari}', ""); +Expect(1, 66256, '\P{^cari}', ""); +Expect(0, 66207, '\p{cari}', ""); +Expect(1, 66207, '\p{^cari}', ""); +Expect(1, 66207, '\P{cari}', ""); +Expect(0, 66207, '\P{^cari}', ""); +Expect(1, 66256, '\p{_-Cari}', ""); +Expect(0, 66256, '\p{^_-Cari}', ""); +Expect(0, 66256, '\P{_-Cari}', ""); +Expect(1, 66256, '\P{^_-Cari}', ""); +Expect(0, 66207, '\p{_-Cari}', ""); +Expect(1, 66207, '\p{^_-Cari}', ""); +Expect(1, 66207, '\P{_-Cari}', ""); +Expect(0, 66207, '\P{^_-Cari}', ""); +Error('\p{ is_Cari/a/}'); +Error('\P{ is_Cari/a/}'); +Expect(1, 66256, '\p{iscari}', ""); +Expect(0, 66256, '\p{^iscari}', ""); +Expect(0, 66256, '\P{iscari}', ""); +Expect(1, 66256, '\P{^iscari}', ""); +Expect(0, 66207, '\p{iscari}', ""); +Expect(1, 66207, '\p{^iscari}', ""); +Expect(1, 66207, '\P{iscari}', ""); +Expect(0, 66207, '\P{^iscari}', ""); +Expect(1, 66256, '\p{ _IsCari}', ""); +Expect(0, 66256, '\p{^ _IsCari}', ""); +Expect(0, 66256, '\P{ _IsCari}', ""); +Expect(1, 66256, '\P{^ _IsCari}', ""); +Expect(0, 66207, '\p{ _IsCari}', ""); +Expect(1, 66207, '\p{^ _IsCari}', ""); +Expect(1, 66207, '\P{ _IsCari}', ""); +Expect(0, 66207, '\P{^ _IsCari}', ""); +Error('\p{:=Old ITALIC}'); +Error('\P{:=Old ITALIC}'); +Expect(1, 66334, '\p{olditalic}', ""); +Expect(0, 66334, '\p{^olditalic}', ""); +Expect(0, 66334, '\P{olditalic}', ""); +Expect(1, 66334, '\P{^olditalic}', ""); +Expect(0, 66303, '\p{olditalic}', ""); +Expect(1, 66303, '\p{^olditalic}', ""); +Expect(1, 66303, '\P{olditalic}', ""); +Expect(0, 66303, '\P{^olditalic}', ""); +Expect(1, 66334, '\p{ -oldITALIC}', ""); +Expect(0, 66334, '\p{^ -oldITALIC}', ""); +Expect(0, 66334, '\P{ -oldITALIC}', ""); +Expect(1, 66334, '\P{^ -oldITALIC}', ""); +Expect(0, 66303, '\p{ -oldITALIC}', ""); +Expect(1, 66303, '\p{^ -oldITALIC}', ""); +Expect(1, 66303, '\P{ -oldITALIC}', ""); +Expect(0, 66303, '\P{^ -oldITALIC}', ""); +Error('\p{ IS:=old Italic}'); +Error('\P{ IS:=old Italic}'); +Expect(1, 66334, '\p{isolditalic}', ""); +Expect(0, 66334, '\p{^isolditalic}', ""); +Expect(0, 66334, '\P{isolditalic}', ""); +Expect(1, 66334, '\P{^isolditalic}', ""); +Expect(0, 66303, '\p{isolditalic}', ""); +Expect(1, 66303, '\p{^isolditalic}', ""); +Expect(1, 66303, '\P{isolditalic}', ""); +Expect(0, 66303, '\P{^isolditalic}', ""); +Expect(1, 66334, '\p{- Isold-italic}', ""); +Expect(0, 66334, '\p{^- Isold-italic}', ""); +Expect(0, 66334, '\P{- Isold-italic}', ""); +Expect(1, 66334, '\P{^- Isold-italic}', ""); +Expect(0, 66303, '\p{- Isold-italic}', ""); +Expect(1, 66303, '\p{^- Isold-italic}', ""); +Expect(1, 66303, '\P{- Isold-italic}', ""); +Expect(0, 66303, '\P{^- Isold-italic}', ""); +Error('\p{_/a/Ital}'); +Error('\P{_/a/Ital}'); +Expect(1, 66334, '\p{ital}', ""); +Expect(0, 66334, '\p{^ital}', ""); +Expect(0, 66334, '\P{ital}', ""); +Expect(1, 66334, '\P{^ital}', ""); +Expect(0, 66303, '\p{ital}', ""); +Expect(1, 66303, '\p{^ital}', ""); +Expect(1, 66303, '\P{ital}', ""); +Expect(0, 66303, '\P{^ital}', ""); +Expect(1, 66334, '\p{ Ital}', ""); +Expect(0, 66334, '\p{^ Ital}', ""); +Expect(0, 66334, '\P{ Ital}', ""); +Expect(1, 66334, '\P{^ Ital}', ""); +Expect(0, 66303, '\p{ Ital}', ""); +Expect(1, 66303, '\p{^ Ital}', ""); +Expect(1, 66303, '\P{ Ital}', ""); +Expect(0, 66303, '\P{^ Ital}', ""); +Error('\p{/a/ IS_Ital}'); +Error('\P{/a/ IS_Ital}'); +Expect(1, 66334, '\p{isital}', ""); +Expect(0, 66334, '\p{^isital}', ""); +Expect(0, 66334, '\P{isital}', ""); +Expect(1, 66334, '\P{^isital}', ""); +Expect(0, 66303, '\p{isital}', ""); +Expect(1, 66303, '\p{^isital}', ""); +Expect(1, 66303, '\P{isital}', ""); +Expect(0, 66303, '\P{^isital}', ""); +Expect(1, 66334, '\p{_ IS ITAL}', ""); +Expect(0, 66334, '\p{^_ IS ITAL}', ""); +Expect(0, 66334, '\P{_ IS ITAL}', ""); +Expect(1, 66334, '\P{^_ IS ITAL}', ""); +Expect(0, 66303, '\p{_ IS ITAL}', ""); +Expect(1, 66303, '\p{^_ IS ITAL}', ""); +Expect(1, 66303, '\P{_ IS ITAL}', ""); +Expect(0, 66303, '\P{^_ IS ITAL}', ""); +Error('\p{_ hex_Digit:=}'); +Error('\P{_ hex_Digit:=}'); +Expect(1, 57, '\p{hexdigit}', ""); +Expect(0, 57, '\p{^hexdigit}', ""); +Expect(0, 57, '\P{hexdigit}', ""); +Expect(1, 57, '\P{^hexdigit}', ""); +Expect(0, 47, '\p{hexdigit}', ""); +Expect(1, 47, '\p{^hexdigit}', ""); +Expect(1, 47, '\P{hexdigit}', ""); +Expect(0, 47, '\P{^hexdigit}', ""); +Expect(1, 57, '\p{-HexDIGIT}', ""); +Expect(0, 57, '\p{^-HexDIGIT}', ""); +Expect(0, 57, '\P{-HexDIGIT}', ""); +Expect(1, 57, '\P{^-HexDIGIT}', ""); +Expect(0, 47, '\p{-HexDIGIT}', ""); +Expect(1, 47, '\p{^-HexDIGIT}', ""); +Expect(1, 47, '\P{-HexDIGIT}', ""); +Expect(0, 47, '\P{^-HexDIGIT}', ""); +Error('\p{ IS Hex Digit/a/}'); +Error('\P{ IS Hex Digit/a/}'); +Expect(1, 57, '\p{ishexdigit}', ""); +Expect(0, 57, '\p{^ishexdigit}', ""); +Expect(0, 57, '\P{ishexdigit}', ""); +Expect(1, 57, '\P{^ishexdigit}', ""); +Expect(0, 47, '\p{ishexdigit}', ""); +Expect(1, 47, '\p{^ishexdigit}', ""); +Expect(1, 47, '\P{ishexdigit}', ""); +Expect(0, 47, '\P{^ishexdigit}', ""); +Expect(1, 57, '\p{ is hex Digit}', ""); +Expect(0, 57, '\p{^ is hex Digit}', ""); +Expect(0, 57, '\P{ is hex Digit}', ""); +Expect(1, 57, '\P{^ is hex Digit}', ""); +Expect(0, 47, '\p{ is hex Digit}', ""); +Expect(1, 47, '\p{^ is hex Digit}', ""); +Expect(1, 47, '\P{ is hex Digit}', ""); +Expect(0, 47, '\P{^ is hex Digit}', ""); +Error('\p{_/a/HEX}'); +Error('\P{_/a/HEX}'); +Expect(1, 57, '\p{hex}', ""); +Expect(0, 57, '\p{^hex}', ""); +Expect(0, 57, '\P{hex}', ""); +Expect(1, 57, '\P{^hex}', ""); +Expect(0, 47, '\p{hex}', ""); +Expect(1, 47, '\p{^hex}', ""); +Expect(1, 47, '\P{hex}', ""); +Expect(0, 47, '\P{^hex}', ""); +Expect(1, 57, '\p{ HEX}', ""); +Expect(0, 57, '\p{^ HEX}', ""); +Expect(0, 57, '\P{ HEX}', ""); +Expect(1, 57, '\P{^ HEX}', ""); +Expect(0, 47, '\p{ HEX}', ""); +Expect(1, 47, '\p{^ HEX}', ""); +Expect(1, 47, '\P{ HEX}', ""); +Expect(0, 47, '\P{^ HEX}', ""); +Error('\p{_:=Is-HEX}'); +Error('\P{_:=Is-HEX}'); +Expect(1, 57, '\p{ishex}', ""); +Expect(0, 57, '\p{^ishex}', ""); +Expect(0, 57, '\P{ishex}', ""); +Expect(1, 57, '\P{^ishex}', ""); +Expect(0, 47, '\p{ishex}', ""); +Expect(1, 47, '\p{^ishex}', ""); +Expect(1, 47, '\P{ishex}', ""); +Expect(0, 47, '\P{^ishex}', ""); +Expect(1, 57, '\p{ is_Hex}', ""); +Expect(0, 57, '\p{^ is_Hex}', ""); +Expect(0, 57, '\P{ is_Hex}', ""); +Expect(1, 57, '\P{^ is_Hex}', ""); +Expect(0, 47, '\p{ is_Hex}', ""); +Expect(1, 47, '\p{^ is_Hex}', ""); +Expect(1, 47, '\P{ is_Hex}', ""); +Expect(0, 47, '\P{^ is_Hex}', ""); +Error('\p{/a/__title}'); +Error('\P{/a/__title}'); +Expect(1, 453, '\p{title}', ""); +Expect(0, 453, '\p{^title}', ""); +Expect(0, 453, '\P{title}', ""); +Expect(1, 453, '\P{^title}', ""); +Expect(0, 452, '\p{title}', ""); +Expect(1, 452, '\p{^title}', ""); +Expect(1, 452, '\P{title}', ""); +Expect(0, 452, '\P{^title}', ""); +Expect(1, 453, '\p{ _Title}', ""); +Expect(0, 453, '\p{^ _Title}', ""); +Expect(0, 453, '\P{ _Title}', ""); +Expect(1, 453, '\P{^ _Title}', ""); +Expect(0, 452, '\p{ _Title}', ""); +Expect(1, 452, '\p{^ _Title}', ""); +Expect(1, 452, '\P{ _Title}', ""); +Expect(0, 452, '\P{^ _Title}', ""); +Error('\p{_ IS:=title}'); +Error('\P{_ IS:=title}'); +Expect(1, 453, '\p{istitle}', ""); +Expect(0, 453, '\p{^istitle}', ""); +Expect(0, 453, '\P{istitle}', ""); +Expect(1, 453, '\P{^istitle}', ""); +Expect(0, 452, '\p{istitle}', ""); +Expect(1, 452, '\p{^istitle}', ""); +Expect(1, 452, '\P{istitle}', ""); +Expect(0, 452, '\P{^istitle}', ""); +Expect(1, 453, '\p{_ Is title}', ""); +Expect(0, 453, '\p{^_ Is title}', ""); +Expect(0, 453, '\P{_ Is title}', ""); +Expect(1, 453, '\P{^_ Is title}', ""); +Expect(0, 452, '\p{_ Is title}', ""); +Expect(1, 452, '\p{^_ Is title}', ""); +Expect(1, 452, '\P{_ Is title}', ""); +Expect(0, 452, '\P{^_ Is title}', ""); +Error('\p{ _Titlecaseletter:=}'); +Error('\P{ _Titlecaseletter:=}'); +Expect(1, 453, '\p{titlecaseletter}', ""); +Expect(0, 453, '\p{^titlecaseletter}', ""); +Expect(0, 453, '\P{titlecaseletter}', ""); +Expect(1, 453, '\P{^titlecaseletter}', ""); +Expect(0, 452, '\p{titlecaseletter}', ""); +Expect(1, 452, '\p{^titlecaseletter}', ""); +Expect(1, 452, '\P{titlecaseletter}', ""); +Expect(0, 452, '\P{^titlecaseletter}', ""); +Expect(1, 453, '\p{ _Titlecase_letter}', ""); +Expect(0, 453, '\p{^ _Titlecase_letter}', ""); +Expect(0, 453, '\P{ _Titlecase_letter}', ""); +Expect(1, 453, '\P{^ _Titlecase_letter}', ""); +Expect(0, 452, '\p{ _Titlecase_letter}', ""); +Expect(1, 452, '\p{^ _Titlecase_letter}', ""); +Expect(1, 452, '\P{ _Titlecase_letter}', ""); +Expect(0, 452, '\P{^ _Titlecase_letter}', ""); +Error('\p{:=_IstitlecaseLetter}'); +Error('\P{:=_IstitlecaseLetter}'); +Expect(1, 453, '\p{istitlecaseletter}', ""); +Expect(0, 453, '\p{^istitlecaseletter}', ""); +Expect(0, 453, '\P{istitlecaseletter}', ""); +Expect(1, 453, '\P{^istitlecaseletter}', ""); +Expect(0, 452, '\p{istitlecaseletter}', ""); +Expect(1, 452, '\p{^istitlecaseletter}', ""); +Expect(1, 452, '\P{istitlecaseletter}', ""); +Expect(0, 452, '\P{^istitlecaseletter}', ""); +Expect(1, 453, '\p{_is-titlecase_Letter}', ""); +Expect(0, 453, '\p{^_is-titlecase_Letter}', ""); +Expect(0, 453, '\P{_is-titlecase_Letter}', ""); +Expect(1, 453, '\P{^_is-titlecase_Letter}', ""); +Expect(0, 452, '\p{_is-titlecase_Letter}', ""); +Expect(1, 452, '\p{^_is-titlecase_Letter}', ""); +Expect(1, 452, '\P{_is-titlecase_Letter}', ""); +Expect(0, 452, '\P{^_is-titlecase_Letter}', ""); +Error('\p{_ LT:=}'); +Error('\P{_ LT:=}'); +Expect(1, 453, '\p{lt}', ""); +Expect(0, 453, '\p{^lt}', ""); +Expect(0, 453, '\P{lt}', ""); +Expect(1, 453, '\P{^lt}', ""); +Expect(0, 452, '\p{lt}', ""); +Expect(1, 452, '\p{^lt}', ""); +Expect(1, 452, '\P{lt}', ""); +Expect(0, 452, '\P{^lt}', ""); +Expect(1, 453, '\p{ lt}', ""); +Expect(0, 453, '\p{^ lt}', ""); +Expect(0, 453, '\P{ lt}', ""); +Expect(1, 453, '\P{^ lt}', ""); +Expect(0, 452, '\p{ lt}', ""); +Expect(1, 452, '\p{^ lt}', ""); +Expect(1, 452, '\P{ lt}', ""); +Expect(0, 452, '\P{^ lt}', ""); +Error('\p{--Is-Lt/a/}'); +Error('\P{--Is-Lt/a/}'); +Expect(1, 453, '\p{islt}', ""); +Expect(0, 453, '\p{^islt}', ""); +Expect(0, 453, '\P{islt}', ""); +Expect(1, 453, '\P{^islt}', ""); +Expect(0, 452, '\p{islt}', ""); +Expect(1, 452, '\p{^islt}', ""); +Expect(1, 452, '\P{islt}', ""); +Expect(0, 452, '\P{^islt}', ""); +Expect(1, 453, '\p{_IS Lt}', ""); +Expect(0, 453, '\p{^_IS Lt}', ""); +Expect(0, 453, '\P{_IS Lt}', ""); +Expect(1, 453, '\P{^_IS Lt}', ""); +Expect(0, 452, '\p{_IS Lt}', ""); +Expect(1, 452, '\p{^_IS Lt}', ""); +Expect(1, 452, '\P{_IS Lt}', ""); +Expect(0, 452, '\P{^_IS Lt}', ""); +Error('\p{ spacing:=modifierLetters}'); +Error('\P{ spacing:=modifierLetters}'); +Expect(1, 767, '\p{spacingmodifierletters}', ""); +Expect(0, 767, '\p{^spacingmodifierletters}', ""); +Expect(0, 767, '\P{spacingmodifierletters}', ""); +Expect(1, 767, '\P{^spacingmodifierletters}', ""); +Expect(0, 687, '\p{spacingmodifierletters}', ""); +Expect(1, 687, '\p{^spacingmodifierletters}', ""); +Expect(1, 687, '\P{spacingmodifierletters}', ""); +Expect(0, 687, '\P{^spacingmodifierletters}', ""); +Expect(1, 767, '\p{--Spacing modifier LETTERS}', ""); +Expect(0, 767, '\p{^--Spacing modifier LETTERS}', ""); +Expect(0, 767, '\P{--Spacing modifier LETTERS}', ""); +Expect(1, 767, '\P{^--Spacing modifier LETTERS}', ""); +Expect(0, 687, '\p{--Spacing modifier LETTERS}', ""); +Expect(1, 687, '\p{^--Spacing modifier LETTERS}', ""); +Expect(1, 687, '\P{--Spacing modifier LETTERS}', ""); +Expect(0, 687, '\P{^--Spacing modifier LETTERS}', ""); +Error('\p{--Is/a/Spacing Modifier_Letters}'); +Error('\P{--Is/a/Spacing Modifier_Letters}'); +Expect(1, 767, '\p{isspacingmodifierletters}', ""); +Expect(0, 767, '\p{^isspacingmodifierletters}', ""); +Expect(0, 767, '\P{isspacingmodifierletters}', ""); +Expect(1, 767, '\P{^isspacingmodifierletters}', ""); +Expect(0, 687, '\p{isspacingmodifierletters}', ""); +Expect(1, 687, '\p{^isspacingmodifierletters}', ""); +Expect(1, 687, '\P{isspacingmodifierletters}', ""); +Expect(0, 687, '\P{^isspacingmodifierletters}', ""); +Expect(1, 767, '\p{ is-spacing_modifier-letters}', ""); +Expect(0, 767, '\p{^ is-spacing_modifier-letters}', ""); +Expect(0, 767, '\P{ is-spacing_modifier-letters}', ""); +Expect(1, 767, '\P{^ is-spacing_modifier-letters}', ""); +Expect(0, 687, '\p{ is-spacing_modifier-letters}', ""); +Expect(1, 687, '\p{^ is-spacing_modifier-letters}', ""); +Expect(1, 687, '\P{ is-spacing_modifier-letters}', ""); +Expect(0, 687, '\P{^ is-spacing_modifier-letters}', ""); +Error('\p{_/a/InSpacing_modifier-Letters}'); +Error('\P{_/a/InSpacing_modifier-Letters}'); +Expect(1, 767, '\p{inspacingmodifierletters}', ""); +Expect(0, 767, '\p{^inspacingmodifierletters}', ""); +Expect(0, 767, '\P{inspacingmodifierletters}', ""); +Expect(1, 767, '\P{^inspacingmodifierletters}', ""); +Expect(0, 687, '\p{inspacingmodifierletters}', ""); +Expect(1, 687, '\p{^inspacingmodifierletters}', ""); +Expect(1, 687, '\P{inspacingmodifierletters}', ""); +Expect(0, 687, '\P{^inspacingmodifierletters}', ""); +Expect(1, 767, '\p{ in Spacing Modifier_LETTERS}', ""); +Expect(0, 767, '\p{^ in Spacing Modifier_LETTERS}', ""); +Expect(0, 767, '\P{ in Spacing Modifier_LETTERS}', ""); +Expect(1, 767, '\P{^ in Spacing Modifier_LETTERS}', ""); +Expect(0, 687, '\p{ in Spacing Modifier_LETTERS}', ""); +Expect(1, 687, '\p{^ in Spacing Modifier_LETTERS}', ""); +Expect(1, 687, '\P{ in Spacing Modifier_LETTERS}', ""); +Expect(0, 687, '\P{^ in Spacing Modifier_LETTERS}', ""); +Error('\p{Grapheme_Link}'); +Error('\P{Grapheme_Link}'); +Error('\p{Is_Grapheme_Link}'); +Error('\P{Is_Grapheme_Link}'); +Error('\p{Gr_Link}'); +Error('\P{Gr_Link}'); +Error('\p{Is_Gr_Link}'); +Error('\P{Is_Gr_Link}'); +Error('\p{ OTHERlowercase:=}'); +Error('\P{ OTHERlowercase:=}'); +Expect(1, 696, '\p{otherlowercase}', 'deprecated'); +Expect(0, 696, '\p{^otherlowercase}', 'deprecated'); +Expect(0, 696, '\P{otherlowercase}', 'deprecated'); +Expect(1, 696, '\P{^otherlowercase}', 'deprecated'); +Expect(0, 687, '\p{otherlowercase}', 'deprecated'); +Expect(1, 687, '\p{^otherlowercase}', 'deprecated'); +Expect(1, 687, '\P{otherlowercase}', 'deprecated'); +Expect(0, 687, '\P{^otherlowercase}', 'deprecated'); +Expect(1, 696, '\p{-_Other_LOWERCASE}', 'deprecated'); +Expect(0, 696, '\p{^-_Other_LOWERCASE}', 'deprecated'); +Expect(0, 696, '\P{-_Other_LOWERCASE}', 'deprecated'); +Expect(1, 696, '\P{^-_Other_LOWERCASE}', 'deprecated'); +Expect(0, 687, '\p{-_Other_LOWERCASE}', 'deprecated'); +Expect(1, 687, '\p{^-_Other_LOWERCASE}', 'deprecated'); +Expect(1, 687, '\P{-_Other_LOWERCASE}', 'deprecated'); +Expect(0, 687, '\P{^-_Other_LOWERCASE}', 'deprecated'); +Error('\p{ ISother/a/Lowercase}'); +Error('\P{ ISother/a/Lowercase}'); +Expect(1, 696, '\p{isotherlowercase}', 'deprecated'); +Expect(0, 696, '\p{^isotherlowercase}', 'deprecated'); +Expect(0, 696, '\P{isotherlowercase}', 'deprecated'); +Expect(1, 696, '\P{^isotherlowercase}', 'deprecated'); +Expect(0, 687, '\p{isotherlowercase}', 'deprecated'); +Expect(1, 687, '\p{^isotherlowercase}', 'deprecated'); +Expect(1, 687, '\P{isotherlowercase}', 'deprecated'); +Expect(0, 687, '\P{^isotherlowercase}', 'deprecated'); +Expect(1, 696, '\p{ IsOther lowercase}', 'deprecated'); +Expect(0, 696, '\p{^ IsOther lowercase}', 'deprecated'); +Expect(0, 696, '\P{ IsOther lowercase}', 'deprecated'); +Expect(1, 696, '\P{^ IsOther lowercase}', 'deprecated'); +Expect(0, 687, '\p{ IsOther lowercase}', 'deprecated'); +Expect(1, 687, '\p{^ IsOther lowercase}', 'deprecated'); +Expect(1, 687, '\P{ IsOther lowercase}', 'deprecated'); +Expect(0, 687, '\P{^ IsOther lowercase}', 'deprecated'); +Error('\p{/a/ -olower}'); +Error('\P{/a/ -olower}'); +Expect(1, 696, '\p{olower}', 'deprecated'); +Expect(0, 696, '\p{^olower}', 'deprecated'); +Expect(0, 696, '\P{olower}', 'deprecated'); +Expect(1, 696, '\P{^olower}', 'deprecated'); +Expect(0, 687, '\p{olower}', 'deprecated'); +Expect(1, 687, '\p{^olower}', 'deprecated'); +Expect(1, 687, '\P{olower}', 'deprecated'); +Expect(0, 687, '\P{^olower}', 'deprecated'); +Expect(1, 696, '\p{ olower}', 'deprecated'); +Expect(0, 696, '\p{^ olower}', 'deprecated'); +Expect(0, 696, '\P{ olower}', 'deprecated'); +Expect(1, 696, '\P{^ olower}', 'deprecated'); +Expect(0, 687, '\p{ olower}', 'deprecated'); +Expect(1, 687, '\p{^ olower}', 'deprecated'); +Expect(1, 687, '\P{ olower}', 'deprecated'); +Expect(0, 687, '\P{^ olower}', 'deprecated'); +Error('\p{ _Is OLOWER:=}'); +Error('\P{ _Is OLOWER:=}'); +Expect(1, 696, '\p{isolower}', 'deprecated'); +Expect(0, 696, '\p{^isolower}', 'deprecated'); +Expect(0, 696, '\P{isolower}', 'deprecated'); +Expect(1, 696, '\P{^isolower}', 'deprecated'); +Expect(0, 687, '\p{isolower}', 'deprecated'); +Expect(1, 687, '\p{^isolower}', 'deprecated'); +Expect(1, 687, '\P{isolower}', 'deprecated'); +Expect(0, 687, '\P{^isolower}', 'deprecated'); +Expect(1, 696, '\p{ IS OLOWER}', 'deprecated'); +Expect(0, 696, '\p{^ IS OLOWER}', 'deprecated'); +Expect(0, 696, '\P{ IS OLOWER}', 'deprecated'); +Expect(1, 696, '\P{^ IS OLOWER}', 'deprecated'); +Expect(0, 687, '\p{ IS OLOWER}', 'deprecated'); +Expect(1, 687, '\p{^ IS OLOWER}', 'deprecated'); +Expect(1, 687, '\P{ IS OLOWER}', 'deprecated'); +Expect(0, 687, '\P{^ IS OLOWER}', 'deprecated'); +Error('\p{/a/ Arabic}'); +Error('\P{/a/ Arabic}'); +Expect(1, 1547, '\p{arabic}', ""); +Expect(0, 1547, '\p{^arabic}', ""); +Expect(0, 1547, '\P{arabic}', ""); +Expect(1, 1547, '\P{^arabic}', ""); +Expect(0, 1541, '\p{arabic}', ""); +Expect(1, 1541, '\p{^arabic}', ""); +Expect(1, 1541, '\P{arabic}', ""); +Expect(0, 1541, '\P{^arabic}', ""); +Expect(1, 1547, '\p{- Arabic}', ""); +Expect(0, 1547, '\p{^- Arabic}', ""); +Expect(0, 1547, '\P{- Arabic}', ""); +Expect(1, 1547, '\P{^- Arabic}', ""); +Expect(0, 1541, '\p{- Arabic}', ""); +Expect(1, 1541, '\p{^- Arabic}', ""); +Expect(1, 1541, '\P{- Arabic}', ""); +Expect(0, 1541, '\P{^- Arabic}', ""); +Error('\p{ :=Is_arabic}'); +Error('\P{ :=Is_arabic}'); +Expect(1, 1547, '\p{isarabic}', ""); +Expect(0, 1547, '\p{^isarabic}', ""); +Expect(0, 1547, '\P{isarabic}', ""); +Expect(1, 1547, '\P{^isarabic}', ""); +Expect(0, 1541, '\p{isarabic}', ""); +Expect(1, 1541, '\p{^isarabic}', ""); +Expect(1, 1541, '\P{isarabic}', ""); +Expect(0, 1541, '\P{^isarabic}', ""); +Expect(1, 1547, '\p{ Is-Arabic}', ""); +Expect(0, 1547, '\p{^ Is-Arabic}', ""); +Expect(0, 1547, '\P{ Is-Arabic}', ""); +Expect(1, 1547, '\P{^ Is-Arabic}', ""); +Expect(0, 1541, '\p{ Is-Arabic}', ""); +Expect(1, 1541, '\p{^ Is-Arabic}', ""); +Expect(1, 1541, '\P{ Is-Arabic}', ""); +Expect(0, 1541, '\P{^ Is-Arabic}', ""); +Error('\p{_ arab/a/}'); +Error('\P{_ arab/a/}'); +Expect(1, 1547, '\p{arab}', ""); +Expect(0, 1547, '\p{^arab}', ""); +Expect(0, 1547, '\P{arab}', ""); +Expect(1, 1547, '\P{^arab}', ""); +Expect(0, 1541, '\p{arab}', ""); +Expect(1, 1541, '\p{^arab}', ""); +Expect(1, 1541, '\P{arab}', ""); +Expect(0, 1541, '\P{^arab}', ""); +Expect(1, 1547, '\p{_ Arab}', ""); +Expect(0, 1547, '\p{^_ Arab}', ""); +Expect(0, 1547, '\P{_ Arab}', ""); +Expect(1, 1547, '\P{^_ Arab}', ""); +Expect(0, 1541, '\p{_ Arab}', ""); +Expect(1, 1541, '\p{^_ Arab}', ""); +Expect(1, 1541, '\P{_ Arab}', ""); +Expect(0, 1541, '\P{^_ Arab}', ""); +Error('\p{--Is Arab:=}'); +Error('\P{--Is Arab:=}'); +Expect(1, 1547, '\p{isarab}', ""); +Expect(0, 1547, '\p{^isarab}', ""); +Expect(0, 1547, '\P{isarab}', ""); +Expect(1, 1547, '\P{^isarab}', ""); +Expect(0, 1541, '\p{isarab}', ""); +Expect(1, 1541, '\p{^isarab}', ""); +Expect(1, 1541, '\P{isarab}', ""); +Expect(0, 1541, '\P{^isarab}', ""); +Expect(1, 1547, '\p{-Is ARAB}', ""); +Expect(0, 1547, '\p{^-Is ARAB}', ""); +Expect(0, 1547, '\P{-Is ARAB}', ""); +Expect(1, 1547, '\P{^-Is ARAB}', ""); +Expect(0, 1541, '\p{-Is ARAB}', ""); +Expect(1, 1541, '\p{^-Is ARAB}', ""); +Expect(1, 1541, '\P{-Is ARAB}', ""); +Expect(0, 1541, '\P{^-Is ARAB}', ""); +Error('\p{:=_deseret}'); +Error('\P{:=_deseret}'); +Expect(1, 66639, '\p{deseret}', ""); +Expect(0, 66639, '\p{^deseret}', ""); +Expect(0, 66639, '\P{deseret}', ""); +Expect(1, 66639, '\P{^deseret}', ""); +Expect(0, 66559, '\p{deseret}', ""); +Expect(1, 66559, '\p{^deseret}', ""); +Expect(1, 66559, '\P{deseret}', ""); +Expect(0, 66559, '\P{^deseret}', ""); +Expect(1, 66639, '\p{-Deseret}', ""); +Expect(0, 66639, '\p{^-Deseret}', ""); +Expect(0, 66639, '\P{-Deseret}', ""); +Expect(1, 66639, '\P{^-Deseret}', ""); +Expect(0, 66559, '\p{-Deseret}', ""); +Expect(1, 66559, '\p{^-Deseret}', ""); +Expect(1, 66559, '\P{-Deseret}', ""); +Expect(0, 66559, '\P{^-Deseret}', ""); +Error('\p{ Is/a/DESERET}'); +Error('\P{ Is/a/DESERET}'); +Expect(1, 66639, '\p{isdeseret}', ""); +Expect(0, 66639, '\p{^isdeseret}', ""); +Expect(0, 66639, '\P{isdeseret}', ""); +Expect(1, 66639, '\P{^isdeseret}', ""); +Expect(0, 66559, '\p{isdeseret}', ""); +Expect(1, 66559, '\p{^isdeseret}', ""); +Expect(1, 66559, '\P{isdeseret}', ""); +Expect(0, 66559, '\P{^isdeseret}', ""); +Expect(1, 66639, '\p{ is Deseret}', ""); +Expect(0, 66639, '\p{^ is Deseret}', ""); +Expect(0, 66639, '\P{ is Deseret}', ""); +Expect(1, 66639, '\P{^ is Deseret}', ""); +Expect(0, 66559, '\p{ is Deseret}', ""); +Expect(1, 66559, '\p{^ is Deseret}', ""); +Expect(1, 66559, '\P{ is Deseret}', ""); +Expect(0, 66559, '\P{^ is Deseret}', ""); +Error('\p{:= _Dsrt}'); +Error('\P{:= _Dsrt}'); +Expect(1, 66639, '\p{dsrt}', ""); +Expect(0, 66639, '\p{^dsrt}', ""); +Expect(0, 66639, '\P{dsrt}', ""); +Expect(1, 66639, '\P{^dsrt}', ""); +Expect(0, 66559, '\p{dsrt}', ""); +Expect(1, 66559, '\p{^dsrt}', ""); +Expect(1, 66559, '\P{dsrt}', ""); +Expect(0, 66559, '\P{^dsrt}', ""); +Expect(1, 66639, '\p{--Dsrt}', ""); +Expect(0, 66639, '\p{^--Dsrt}', ""); +Expect(0, 66639, '\P{--Dsrt}', ""); +Expect(1, 66639, '\P{^--Dsrt}', ""); +Expect(0, 66559, '\p{--Dsrt}', ""); +Expect(1, 66559, '\p{^--Dsrt}', ""); +Expect(1, 66559, '\P{--Dsrt}', ""); +Expect(0, 66559, '\P{^--Dsrt}', ""); +Error('\p{_is_Dsrt:=}'); +Error('\P{_is_Dsrt:=}'); +Expect(1, 66639, '\p{isdsrt}', ""); +Expect(0, 66639, '\p{^isdsrt}', ""); +Expect(0, 66639, '\P{isdsrt}', ""); +Expect(1, 66639, '\P{^isdsrt}', ""); +Expect(0, 66559, '\p{isdsrt}', ""); +Expect(1, 66559, '\p{^isdsrt}', ""); +Expect(1, 66559, '\P{isdsrt}', ""); +Expect(0, 66559, '\P{^isdsrt}', ""); +Expect(1, 66639, '\p{- is Dsrt}', ""); +Expect(0, 66639, '\p{^- is Dsrt}', ""); +Expect(0, 66639, '\P{- is Dsrt}', ""); +Expect(1, 66639, '\P{^- is Dsrt}', ""); +Expect(0, 66559, '\p{- is Dsrt}', ""); +Expect(1, 66559, '\p{^- is Dsrt}', ""); +Expect(1, 66559, '\P{- is Dsrt}', ""); +Expect(0, 66559, '\P{^- is Dsrt}', ""); +Error('\p{:= CASED_Letter}'); +Error('\P{:= CASED_Letter}'); +Expect(1, 90, '\p{casedletter}', ""); +Expect(0, 90, '\p{^casedletter}', ""); +Expect(0, 90, '\P{casedletter}', ""); +Expect(1, 90, '\P{^casedletter}', ""); +Expect(0, 64, '\p{casedletter}', ""); +Expect(1, 64, '\p{^casedletter}', ""); +Expect(1, 64, '\P{casedletter}', ""); +Expect(0, 64, '\P{^casedletter}', ""); +Expect(1, 90, '\p{-CasedLetter}', ""); +Expect(0, 90, '\p{^-CasedLetter}', ""); +Expect(0, 90, '\P{-CasedLetter}', ""); +Expect(1, 90, '\P{^-CasedLetter}', ""); +Expect(0, 64, '\p{-CasedLetter}', ""); +Expect(1, 64, '\p{^-CasedLetter}', ""); +Expect(1, 64, '\P{-CasedLetter}', ""); +Expect(0, 64, '\P{^-CasedLetter}', ""); +Error('\p{:=Is_Cased Letter}'); +Error('\P{:=Is_Cased Letter}'); +Expect(1, 90, '\p{iscasedletter}', ""); +Expect(0, 90, '\p{^iscasedletter}', ""); +Expect(0, 90, '\P{iscasedletter}', ""); +Expect(1, 90, '\P{^iscasedletter}', ""); +Expect(0, 64, '\p{iscasedletter}', ""); +Expect(1, 64, '\p{^iscasedletter}', ""); +Expect(1, 64, '\P{iscasedletter}', ""); +Expect(0, 64, '\P{^iscasedletter}', ""); +Expect(1, 90, '\p{__IS-cased Letter}', ""); +Expect(0, 90, '\p{^__IS-cased Letter}', ""); +Expect(0, 90, '\P{__IS-cased Letter}', ""); +Expect(1, 90, '\P{^__IS-cased Letter}', ""); +Expect(0, 64, '\p{__IS-cased Letter}', ""); +Expect(1, 64, '\p{^__IS-cased Letter}', ""); +Expect(1, 64, '\P{__IS-cased Letter}', ""); +Expect(0, 64, '\P{^__IS-cased Letter}', ""); +Error('\p{-LC/a/}'); +Error('\P{-LC/a/}'); +Expect(1, 90, '\p{lc}', ""); +Expect(0, 90, '\p{^lc}', ""); +Expect(0, 90, '\P{lc}', ""); +Expect(1, 90, '\P{^lc}', ""); +Expect(0, 64, '\p{lc}', ""); +Expect(1, 64, '\p{^lc}', ""); +Expect(1, 64, '\P{lc}', ""); +Expect(0, 64, '\P{^lc}', ""); +Error('\p{ _Is_LC:=}'); +Error('\P{ _Is_LC:=}'); +Expect(1, 90, '\p{islc}', ""); +Expect(0, 90, '\p{^islc}', ""); +Expect(0, 90, '\P{islc}', ""); +Expect(1, 90, '\P{^islc}', ""); +Expect(0, 64, '\p{islc}', ""); +Expect(1, 64, '\p{^islc}', ""); +Expect(1, 64, '\P{islc}', ""); +Expect(0, 64, '\P{^islc}', ""); +Expect(1, 90, '\p{IsLC}', ""); +Expect(0, 90, '\p{^IsLC}', ""); +Expect(0, 90, '\P{IsLC}', ""); +Expect(1, 90, '\P{^IsLC}', ""); +Expect(0, 64, '\p{IsLC}', ""); +Expect(1, 64, '\p{^IsLC}', ""); +Expect(1, 64, '\P{IsLC}', ""); +Expect(0, 64, '\P{^IsLC}', ""); +Error('\p{ /a/L}'); +Error('\P{ /a/L}'); +Expect(1, 90, '\p{l_}', ""); +Expect(0, 90, '\p{^l_}', ""); +Expect(0, 90, '\P{l_}', ""); +Expect(1, 90, '\P{^l_}', ""); +Expect(0, 64, '\p{l_}', ""); +Expect(1, 64, '\p{^l_}', ""); +Expect(1, 64, '\P{l_}', ""); +Expect(0, 64, '\P{^l_}', ""); +Expect(1, 90, '\p{_ L}', ""); +Expect(0, 90, '\p{^_ L}', ""); +Expect(0, 90, '\P{_ L}', ""); +Expect(1, 90, '\P{^_ L}', ""); +Expect(0, 64, '\p{_ L}', ""); +Expect(1, 64, '\p{^_ L}', ""); +Expect(1, 64, '\P{_ L}', ""); +Expect(0, 64, '\P{^_ L}', ""); +Error('\p{_ IsL:=}'); +Error('\P{_ IsL:=}'); +Expect(1, 90, '\p{isl_}', ""); +Expect(0, 90, '\p{^isl_}', ""); +Expect(0, 90, '\P{isl_}', ""); +Expect(1, 90, '\P{^isl_}', ""); +Expect(0, 64, '\p{isl_}', ""); +Expect(1, 64, '\p{^isl_}', ""); +Expect(1, 64, '\P{isl_}', ""); +Expect(0, 64, '\P{^isl_}', ""); +Expect(1, 90, '\p{is L}', ""); +Expect(0, 90, '\p{^is L}', ""); +Expect(0, 90, '\P{is L}', ""); +Expect(1, 90, '\P{^is L}', ""); +Expect(0, 64, '\p{is L}', ""); +Expect(1, 64, '\p{^is L}', ""); +Expect(1, 64, '\P{is L}', ""); +Expect(0, 64, '\P{^is L}', ""); +Error('\p{:= l&}'); +Error('\P{:= l&}'); +Expect(1, 90, '\p{l&}', ""); +Expect(0, 90, '\p{^l&}', ""); +Expect(0, 90, '\P{l&}', ""); +Expect(1, 90, '\P{^l&}', ""); +Expect(0, 64, '\p{l&}', ""); +Expect(1, 64, '\p{^l&}', ""); +Expect(1, 64, '\P{l&}', ""); +Expect(0, 64, '\P{^l&}', ""); +Expect(1, 90, '\p{-l&}', ""); +Expect(0, 90, '\p{^-l&}', ""); +Expect(0, 90, '\P{-l&}', ""); +Expect(1, 90, '\P{^-l&}', ""); +Expect(0, 64, '\p{-l&}', ""); +Expect(1, 64, '\p{^-l&}', ""); +Expect(1, 64, '\P{-l&}', ""); +Expect(0, 64, '\P{^-l&}', ""); +Error('\p{- is L&:=}'); +Error('\P{- is L&:=}'); +Expect(1, 90, '\p{isl&}', ""); +Expect(0, 90, '\p{^isl&}', ""); +Expect(0, 90, '\P{isl&}', ""); +Expect(1, 90, '\P{^isl&}', ""); +Expect(0, 64, '\p{isl&}', ""); +Expect(1, 64, '\p{^isl&}', ""); +Expect(1, 64, '\P{isl&}', ""); +Expect(0, 64, '\P{^isl&}', ""); +Expect(1, 90, '\p{ IS L&}', ""); +Expect(0, 90, '\p{^ IS L&}', ""); +Expect(0, 90, '\P{ IS L&}', ""); +Expect(1, 90, '\P{^ IS L&}', ""); +Expect(0, 64, '\p{ IS L&}', ""); +Expect(1, 64, '\p{^ IS L&}', ""); +Expect(1, 64, '\P{ IS L&}', ""); +Expect(0, 64, '\P{^ IS L&}', ""); +Error('\p{-_Symbol/a/}'); +Error('\P{-_Symbol/a/}'); +Expect(1, 36, '\p{symbol}', ""); +Expect(0, 36, '\p{^symbol}', ""); +Expect(0, 36, '\P{symbol}', ""); +Expect(1, 36, '\P{^symbol}', ""); +Expect(0, 35, '\p{symbol}', ""); +Expect(1, 35, '\p{^symbol}', ""); +Expect(1, 35, '\P{symbol}', ""); +Expect(0, 35, '\P{^symbol}', ""); +Expect(1, 36, '\p{_ symbol}', ""); +Expect(0, 36, '\p{^_ symbol}', ""); +Expect(0, 36, '\P{_ symbol}', ""); +Expect(1, 36, '\P{^_ symbol}', ""); +Expect(0, 35, '\p{_ symbol}', ""); +Expect(1, 35, '\p{^_ symbol}', ""); +Expect(1, 35, '\P{_ symbol}', ""); +Expect(0, 35, '\P{^_ symbol}', ""); +Error('\p{ :=Is_Symbol}'); +Error('\P{ :=Is_Symbol}'); +Expect(1, 36, '\p{issymbol}', ""); +Expect(0, 36, '\p{^issymbol}', ""); +Expect(0, 36, '\P{issymbol}', ""); +Expect(1, 36, '\P{^issymbol}', ""); +Expect(0, 35, '\p{issymbol}', ""); +Expect(1, 35, '\p{^issymbol}', ""); +Expect(1, 35, '\P{issymbol}', ""); +Expect(0, 35, '\P{^issymbol}', ""); +Expect(1, 36, '\p{ -IsSYMBOL}', ""); +Expect(0, 36, '\p{^ -IsSYMBOL}', ""); +Expect(0, 36, '\P{ -IsSYMBOL}', ""); +Expect(1, 36, '\P{^ -IsSYMBOL}', ""); +Expect(0, 35, '\p{ -IsSYMBOL}', ""); +Expect(1, 35, '\p{^ -IsSYMBOL}', ""); +Expect(1, 35, '\P{ -IsSYMBOL}', ""); +Expect(0, 35, '\P{^ -IsSYMBOL}', ""); +Error('\p{_ S:=}'); +Error('\P{_ S:=}'); +Expect(1, 36, '\p{s}', ""); +Expect(0, 36, '\p{^s}', ""); +Expect(0, 36, '\P{s}', ""); +Expect(1, 36, '\P{^s}', ""); +Expect(0, 35, '\p{s}', ""); +Expect(1, 35, '\p{^s}', ""); +Expect(1, 35, '\P{s}', ""); +Expect(0, 35, '\P{^s}', ""); +Expect(1, 36, '\p{ -S}', ""); +Expect(0, 36, '\p{^ -S}', ""); +Expect(0, 36, '\P{ -S}', ""); +Expect(1, 36, '\P{^ -S}', ""); +Expect(0, 35, '\p{ -S}', ""); +Expect(1, 35, '\p{^ -S}', ""); +Expect(1, 35, '\P{ -S}', ""); +Expect(0, 35, '\P{^ -S}', ""); +Error('\p{:= _IS_S}'); +Error('\P{:= _IS_S}'); +Expect(1, 36, '\p{iss}', ""); +Expect(0, 36, '\p{^iss}', ""); +Expect(0, 36, '\P{iss}', ""); +Expect(1, 36, '\P{^iss}', ""); +Expect(0, 35, '\p{iss}', ""); +Expect(1, 35, '\p{^iss}', ""); +Expect(1, 35, '\P{iss}', ""); +Expect(0, 35, '\P{^iss}', ""); +Expect(1, 36, '\p{ Is-s}', ""); +Expect(0, 36, '\p{^ Is-s}', ""); +Expect(0, 36, '\P{ Is-s}', ""); +Expect(1, 36, '\P{^ Is-s}', ""); +Expect(0, 35, '\p{ Is-s}', ""); +Expect(1, 35, '\p{^ Is-s}', ""); +Expect(1, 35, '\P{ Is-s}', ""); +Expect(0, 35, '\P{^ Is-s}', ""); +Error('\p{ -INHERITED:=}'); +Error('\P{ -INHERITED:=}'); +Expect(1, 879, '\p{inherited}', ""); +Expect(0, 879, '\p{^inherited}', ""); +Expect(0, 879, '\P{inherited}', ""); +Expect(1, 879, '\P{^inherited}', ""); +Expect(0, 767, '\p{inherited}', ""); +Expect(1, 767, '\p{^inherited}', ""); +Expect(1, 767, '\P{inherited}', ""); +Expect(0, 767, '\P{^inherited}', ""); +Error('\p{ :=is_inherited}'); +Error('\P{ :=is_inherited}'); +Expect(1, 879, '\p{isinherited}', ""); +Expect(0, 879, '\p{^isinherited}', ""); +Expect(0, 879, '\P{isinherited}', ""); +Expect(1, 879, '\P{^isinherited}', ""); +Expect(0, 767, '\p{isinherited}', ""); +Expect(1, 767, '\p{^isinherited}', ""); +Expect(1, 767, '\P{isinherited}', ""); +Expect(0, 767, '\P{^isinherited}', ""); +Expect(1, 879, '\p{__IS Inherited}', ""); +Expect(0, 879, '\p{^__IS Inherited}', ""); +Expect(0, 879, '\P{__IS Inherited}', ""); +Expect(1, 879, '\P{^__IS Inherited}', ""); +Expect(0, 767, '\p{__IS Inherited}', ""); +Expect(1, 767, '\p{^__IS Inherited}', ""); +Expect(1, 767, '\P{__IS Inherited}', ""); +Expect(0, 767, '\P{^__IS Inherited}', ""); +Error('\p{/a/QAAI}'); +Error('\P{/a/QAAI}'); +Expect(1, 879, '\p{qaai}', ""); +Expect(0, 879, '\p{^qaai}', ""); +Expect(0, 879, '\P{qaai}', ""); +Expect(1, 879, '\P{^qaai}', ""); +Expect(0, 767, '\p{qaai}', ""); +Expect(1, 767, '\p{^qaai}', ""); +Expect(1, 767, '\P{qaai}', ""); +Expect(0, 767, '\P{^qaai}', ""); +Expect(1, 879, '\p{_-Qaai}', ""); +Expect(0, 879, '\p{^_-Qaai}', ""); +Expect(0, 879, '\P{_-Qaai}', ""); +Expect(1, 879, '\P{^_-Qaai}', ""); +Expect(0, 767, '\p{_-Qaai}', ""); +Expect(1, 767, '\p{^_-Qaai}', ""); +Expect(1, 767, '\P{_-Qaai}', ""); +Expect(0, 767, '\P{^_-Qaai}', ""); +Error('\p{-_IS-Qaai:=}'); +Error('\P{-_IS-Qaai:=}'); +Expect(1, 879, '\p{isqaai}', ""); +Expect(0, 879, '\p{^isqaai}', ""); +Expect(0, 879, '\P{isqaai}', ""); +Expect(1, 879, '\P{^isqaai}', ""); +Expect(0, 767, '\p{isqaai}', ""); +Expect(1, 767, '\p{^isqaai}', ""); +Expect(1, 767, '\P{isqaai}', ""); +Expect(0, 767, '\P{^isqaai}', ""); +Expect(1, 879, '\p{ _Is qaai}', ""); +Expect(0, 879, '\p{^ _Is qaai}', ""); +Expect(0, 879, '\P{ _Is qaai}', ""); +Expect(1, 879, '\P{^ _Is qaai}', ""); +Expect(0, 767, '\p{ _Is qaai}', ""); +Expect(1, 767, '\p{^ _Is qaai}', ""); +Expect(1, 767, '\P{ _Is qaai}', ""); +Expect(0, 767, '\P{^ _Is qaai}', ""); +Error('\p{ yijing HEXAGRAM/a/symbols}'); +Error('\P{ yijing HEXAGRAM/a/symbols}'); +Expect(1, 19967, '\p{yijinghexagramsymbols}', ""); +Expect(0, 19967, '\p{^yijinghexagramsymbols}', ""); +Expect(0, 19967, '\P{yijinghexagramsymbols}', ""); +Expect(1, 19967, '\P{^yijinghexagramsymbols}', ""); +Expect(0, 19903, '\p{yijinghexagramsymbols}', ""); +Expect(1, 19903, '\p{^yijinghexagramsymbols}', ""); +Expect(1, 19903, '\P{yijinghexagramsymbols}', ""); +Expect(0, 19903, '\P{^yijinghexagramsymbols}', ""); +Expect(1, 19967, '\p{ YijingHexagram_symbols}', ""); +Expect(0, 19967, '\p{^ YijingHexagram_symbols}', ""); +Expect(0, 19967, '\P{ YijingHexagram_symbols}', ""); +Expect(1, 19967, '\P{^ YijingHexagram_symbols}', ""); +Expect(0, 19903, '\p{ YijingHexagram_symbols}', ""); +Expect(1, 19903, '\p{^ YijingHexagram_symbols}', ""); +Expect(1, 19903, '\P{ YijingHexagram_symbols}', ""); +Expect(0, 19903, '\P{^ YijingHexagram_symbols}', ""); +Error('\p{_is-YIJING/a/Hexagram-SYMBOLS}'); +Error('\P{_is-YIJING/a/Hexagram-SYMBOLS}'); +Expect(1, 19967, '\p{isyijinghexagramsymbols}', ""); +Expect(0, 19967, '\p{^isyijinghexagramsymbols}', ""); +Expect(0, 19967, '\P{isyijinghexagramsymbols}', ""); +Expect(1, 19967, '\P{^isyijinghexagramsymbols}', ""); +Expect(0, 19903, '\p{isyijinghexagramsymbols}', ""); +Expect(1, 19903, '\p{^isyijinghexagramsymbols}', ""); +Expect(1, 19903, '\P{isyijinghexagramsymbols}', ""); +Expect(0, 19903, '\P{^isyijinghexagramsymbols}', ""); +Expect(1, 19967, '\p{_-Is yijingHexagram-Symbols}', ""); +Expect(0, 19967, '\p{^_-Is yijingHexagram-Symbols}', ""); +Expect(0, 19967, '\P{_-Is yijingHexagram-Symbols}', ""); +Expect(1, 19967, '\P{^_-Is yijingHexagram-Symbols}', ""); +Expect(0, 19903, '\p{_-Is yijingHexagram-Symbols}', ""); +Expect(1, 19903, '\p{^_-Is yijingHexagram-Symbols}', ""); +Expect(1, 19903, '\P{_-Is yijingHexagram-Symbols}', ""); +Expect(0, 19903, '\P{^_-Is yijingHexagram-Symbols}', ""); +Error('\p{:= INYijing Hexagram_Symbols}'); +Error('\P{:= INYijing Hexagram_Symbols}'); +Expect(1, 19967, '\p{inyijinghexagramsymbols}', ""); +Expect(0, 19967, '\p{^inyijinghexagramsymbols}', ""); +Expect(0, 19967, '\P{inyijinghexagramsymbols}', ""); +Expect(1, 19967, '\P{^inyijinghexagramsymbols}', ""); +Expect(0, 19903, '\p{inyijinghexagramsymbols}', ""); +Expect(1, 19903, '\p{^inyijinghexagramsymbols}', ""); +Expect(1, 19903, '\P{inyijinghexagramsymbols}', ""); +Expect(0, 19903, '\P{^inyijinghexagramsymbols}', ""); +Expect(1, 19967, '\p{ In-YIJING HexagramSymbols}', ""); +Expect(0, 19967, '\p{^ In-YIJING HexagramSymbols}', ""); +Expect(0, 19967, '\P{ In-YIJING HexagramSymbols}', ""); +Expect(1, 19967, '\P{^ In-YIJING HexagramSymbols}', ""); +Expect(0, 19903, '\p{ In-YIJING HexagramSymbols}', ""); +Expect(1, 19903, '\p{^ In-YIJING HexagramSymbols}', ""); +Expect(1, 19903, '\P{ In-YIJING HexagramSymbols}', ""); +Expect(0, 19903, '\P{^ In-YIJING HexagramSymbols}', ""); +Error('\p{:=__PosixSpace}'); +Error('\P{:=__PosixSpace}'); +Expect(1, 13, '\p{posixspace}', ""); +Expect(0, 13, '\p{^posixspace}', ""); +Expect(0, 13, '\P{posixspace}', ""); +Expect(1, 13, '\P{^posixspace}', ""); +Expect(0, 8, '\p{posixspace}', ""); +Expect(1, 8, '\p{^posixspace}', ""); +Expect(1, 8, '\P{posixspace}', ""); +Expect(0, 8, '\P{^posixspace}', ""); +Expect(1, 13, '\p{ PosixSpace}', ""); +Expect(0, 13, '\p{^ PosixSpace}', ""); +Expect(0, 13, '\P{ PosixSpace}', ""); +Expect(1, 13, '\P{^ PosixSpace}', ""); +Expect(0, 8, '\p{ PosixSpace}', ""); +Expect(1, 8, '\p{^ PosixSpace}', ""); +Expect(1, 8, '\P{ PosixSpace}', ""); +Expect(0, 8, '\P{^ PosixSpace}', ""); +Error('\p{_ is-POSIXSPACE:=}'); +Error('\P{_ is-POSIXSPACE:=}'); +Expect(1, 13, '\p{isposixspace}', ""); +Expect(0, 13, '\p{^isposixspace}', ""); +Expect(0, 13, '\P{isposixspace}', ""); +Expect(1, 13, '\P{^isposixspace}', ""); +Expect(0, 8, '\p{isposixspace}', ""); +Expect(1, 8, '\p{^isposixspace}', ""); +Expect(1, 8, '\P{isposixspace}', ""); +Expect(0, 8, '\P{^isposixspace}', ""); +Expect(1, 13, '\p{-is_PosixSpace}', ""); +Expect(0, 13, '\p{^-is_PosixSpace}', ""); +Expect(0, 13, '\P{-is_PosixSpace}', ""); +Expect(1, 13, '\P{^-is_PosixSpace}', ""); +Expect(0, 8, '\p{-is_PosixSpace}', ""); +Expect(1, 8, '\p{^-is_PosixSpace}', ""); +Expect(1, 8, '\P{-is_PosixSpace}', ""); +Expect(0, 8, '\P{^-is_PosixSpace}', ""); +Error('\p{/a/- currency symbols}'); +Error('\P{/a/- currency symbols}'); +Expect(1, 8399, '\p{currencysymbols}', ""); +Expect(0, 8399, '\p{^currencysymbols}', ""); +Expect(0, 8399, '\P{currencysymbols}', ""); +Expect(1, 8399, '\P{^currencysymbols}', ""); +Expect(0, 8351, '\p{currencysymbols}', ""); +Expect(1, 8351, '\p{^currencysymbols}', ""); +Expect(1, 8351, '\P{currencysymbols}', ""); +Expect(0, 8351, '\P{^currencysymbols}', ""); +Expect(1, 8399, '\p{-Currency Symbols}', ""); +Expect(0, 8399, '\p{^-Currency Symbols}', ""); +Expect(0, 8399, '\P{-Currency Symbols}', ""); +Expect(1, 8399, '\P{^-Currency Symbols}', ""); +Expect(0, 8351, '\p{-Currency Symbols}', ""); +Expect(1, 8351, '\p{^-Currency Symbols}', ""); +Expect(1, 8351, '\P{-Currency Symbols}', ""); +Expect(0, 8351, '\P{^-Currency Symbols}', ""); +Error('\p{_ is CURRENCY/a/Symbols}'); +Error('\P{_ is CURRENCY/a/Symbols}'); +Expect(1, 8399, '\p{iscurrencysymbols}', ""); +Expect(0, 8399, '\p{^iscurrencysymbols}', ""); +Expect(0, 8399, '\P{iscurrencysymbols}', ""); +Expect(1, 8399, '\P{^iscurrencysymbols}', ""); +Expect(0, 8351, '\p{iscurrencysymbols}', ""); +Expect(1, 8351, '\p{^iscurrencysymbols}', ""); +Expect(1, 8351, '\P{iscurrencysymbols}', ""); +Expect(0, 8351, '\P{^iscurrencysymbols}', ""); +Expect(1, 8399, '\p{_Is CURRENCYSymbols}', ""); +Expect(0, 8399, '\p{^_Is CURRENCYSymbols}', ""); +Expect(0, 8399, '\P{_Is CURRENCYSymbols}', ""); +Expect(1, 8399, '\P{^_Is CURRENCYSymbols}', ""); +Expect(0, 8351, '\p{_Is CURRENCYSymbols}', ""); +Expect(1, 8351, '\p{^_Is CURRENCYSymbols}', ""); +Expect(1, 8351, '\P{_Is CURRENCYSymbols}', ""); +Expect(0, 8351, '\P{^_Is CURRENCYSymbols}', ""); +Error('\p{_-In/a/currency-symbols}'); +Error('\P{_-In/a/currency-symbols}'); +Expect(1, 8399, '\p{incurrencysymbols}', ""); +Expect(0, 8399, '\p{^incurrencysymbols}', ""); +Expect(0, 8399, '\P{incurrencysymbols}', ""); +Expect(1, 8399, '\P{^incurrencysymbols}', ""); +Expect(0, 8351, '\p{incurrencysymbols}', ""); +Expect(1, 8351, '\p{^incurrencysymbols}', ""); +Expect(1, 8351, '\P{incurrencysymbols}', ""); +Expect(0, 8351, '\P{^incurrencysymbols}', ""); +Expect(1, 8399, '\p{ _In-currency_Symbols}', ""); +Expect(0, 8399, '\p{^ _In-currency_Symbols}', ""); +Expect(0, 8399, '\P{ _In-currency_Symbols}', ""); +Expect(1, 8399, '\P{^ _In-currency_Symbols}', ""); +Expect(0, 8351, '\p{ _In-currency_Symbols}', ""); +Expect(1, 8351, '\p{^ _In-currency_Symbols}', ""); +Expect(1, 8351, '\P{ _In-currency_Symbols}', ""); +Expect(0, 8351, '\P{^ _In-currency_Symbols}', ""); +Error('\p{ -Currency/a/Symbol}'); +Error('\P{ -Currency/a/Symbol}'); +Expect(1, 36, '\p{currencysymbol}', ""); +Expect(0, 36, '\p{^currencysymbol}', ""); +Expect(0, 36, '\P{currencysymbol}', ""); +Expect(1, 36, '\P{^currencysymbol}', ""); +Expect(0, 35, '\p{currencysymbol}', ""); +Expect(1, 35, '\p{^currencysymbol}', ""); +Expect(1, 35, '\P{currencysymbol}', ""); +Expect(0, 35, '\P{^currencysymbol}', ""); +Expect(1, 36, '\p{ -CurrencySymbol}', ""); +Expect(0, 36, '\p{^ -CurrencySymbol}', ""); +Expect(0, 36, '\P{ -CurrencySymbol}', ""); +Expect(1, 36, '\P{^ -CurrencySymbol}', ""); +Expect(0, 35, '\p{ -CurrencySymbol}', ""); +Expect(1, 35, '\p{^ -CurrencySymbol}', ""); +Expect(1, 35, '\P{ -CurrencySymbol}', ""); +Expect(0, 35, '\P{^ -CurrencySymbol}', ""); +Error('\p{-Is:=CURRENCY-Symbol}'); +Error('\P{-Is:=CURRENCY-Symbol}'); +Expect(1, 36, '\p{iscurrencysymbol}', ""); +Expect(0, 36, '\p{^iscurrencysymbol}', ""); +Expect(0, 36, '\P{iscurrencysymbol}', ""); +Expect(1, 36, '\P{^iscurrencysymbol}', ""); +Expect(0, 35, '\p{iscurrencysymbol}', ""); +Expect(1, 35, '\p{^iscurrencysymbol}', ""); +Expect(1, 35, '\P{iscurrencysymbol}', ""); +Expect(0, 35, '\P{^iscurrencysymbol}', ""); +Expect(1, 36, '\p{-_IS_currency Symbol}', ""); +Expect(0, 36, '\p{^-_IS_currency Symbol}', ""); +Expect(0, 36, '\P{-_IS_currency Symbol}', ""); +Expect(1, 36, '\P{^-_IS_currency Symbol}', ""); +Expect(0, 35, '\p{-_IS_currency Symbol}', ""); +Expect(1, 35, '\p{^-_IS_currency Symbol}', ""); +Expect(1, 35, '\P{-_IS_currency Symbol}', ""); +Expect(0, 35, '\P{^-_IS_currency Symbol}', ""); +Error('\p{_Sc:=}'); +Error('\P{_Sc:=}'); +Expect(1, 36, '\p{sc}', ""); +Expect(0, 36, '\p{^sc}', ""); +Expect(0, 36, '\P{sc}', ""); +Expect(1, 36, '\P{^sc}', ""); +Expect(0, 35, '\p{sc}', ""); +Expect(1, 35, '\p{^sc}', ""); +Expect(1, 35, '\P{sc}', ""); +Expect(0, 35, '\P{^sc}', ""); +Expect(1, 36, '\p{ Sc}', ""); +Expect(0, 36, '\p{^ Sc}', ""); +Expect(0, 36, '\P{ Sc}', ""); +Expect(1, 36, '\P{^ Sc}', ""); +Expect(0, 35, '\p{ Sc}', ""); +Expect(1, 35, '\p{^ Sc}', ""); +Expect(1, 35, '\P{ Sc}', ""); +Expect(0, 35, '\P{^ Sc}', ""); +Error('\p{ is:=Sc}'); +Error('\P{ is:=Sc}'); +Expect(1, 36, '\p{issc}', ""); +Expect(0, 36, '\p{^issc}', ""); +Expect(0, 36, '\P{issc}', ""); +Expect(1, 36, '\P{^issc}', ""); +Expect(0, 35, '\p{issc}', ""); +Expect(1, 35, '\p{^issc}', ""); +Expect(1, 35, '\P{issc}', ""); +Expect(0, 35, '\P{^issc}', ""); +Expect(1, 36, '\p{ Is SC}', ""); +Expect(0, 36, '\p{^ Is SC}', ""); +Expect(0, 36, '\P{ Is SC}', ""); +Expect(1, 36, '\P{^ Is SC}', ""); +Expect(0, 35, '\p{ Is SC}', ""); +Expect(1, 35, '\p{^ Is SC}', ""); +Expect(1, 35, '\P{ Is SC}', ""); +Expect(0, 35, '\P{^ Is SC}', ""); +Error('\p{ -HIGH/a/surrogates}'); +Error('\P{ -HIGH/a/surrogates}'); +Expect(0, 55295, '\p{highsurrogates}', ""); +Expect(1, 55295, '\p{^highsurrogates}', ""); +Expect(1, 55295, '\P{highsurrogates}', ""); +Expect(0, 55295, '\P{^highsurrogates}', ""); +Expect(0, 55295, '\p{ -High_Surrogates}', ""); +Expect(1, 55295, '\p{^ -High_Surrogates}', ""); +Expect(1, 55295, '\P{ -High_Surrogates}', ""); +Expect(0, 55295, '\P{^ -High_Surrogates}', ""); +Error('\p{/a/--ISHIGH Surrogates}'); +Error('\P{/a/--ISHIGH Surrogates}'); +Expect(0, 55295, '\p{ishighsurrogates}', ""); +Expect(1, 55295, '\p{^ishighsurrogates}', ""); +Expect(1, 55295, '\P{ishighsurrogates}', ""); +Expect(0, 55295, '\P{^ishighsurrogates}', ""); +Expect(0, 55295, '\p{-IS_High-SURROGATES}', ""); +Expect(1, 55295, '\p{^-IS_High-SURROGATES}', ""); +Expect(1, 55295, '\P{-IS_High-SURROGATES}', ""); +Expect(0, 55295, '\P{^-IS_High-SURROGATES}', ""); +Error('\p{:= In High surrogates}'); +Error('\P{:= In High surrogates}'); +Expect(0, 55295, '\p{inhighsurrogates}', ""); +Expect(1, 55295, '\p{^inhighsurrogates}', ""); +Expect(1, 55295, '\P{inhighsurrogates}', ""); +Expect(0, 55295, '\P{^inhighsurrogates}', ""); +Expect(0, 55295, '\p{_-In HIGH_SURROGATES}', ""); +Expect(1, 55295, '\p{^_-In HIGH_SURROGATES}', ""); +Expect(1, 55295, '\P{_-In HIGH_SURROGATES}', ""); +Expect(0, 55295, '\P{^_-In HIGH_SURROGATES}', ""); +Error('\p{:=inDeseret}'); +Error('\P{:=inDeseret}'); +Expect(1, 66639, '\p{indeseret}', ""); +Expect(0, 66639, '\p{^indeseret}', ""); +Expect(0, 66639, '\P{indeseret}', ""); +Expect(1, 66639, '\P{^indeseret}', ""); +Expect(0, 66559, '\p{indeseret}', ""); +Expect(1, 66559, '\p{^indeseret}', ""); +Expect(1, 66559, '\P{indeseret}', ""); +Expect(0, 66559, '\P{^indeseret}', ""); +Expect(1, 66639, '\p{ In Deseret}', ""); +Expect(0, 66639, '\p{^ In Deseret}', ""); +Expect(0, 66639, '\P{ In Deseret}', ""); +Expect(1, 66639, '\P{^ In Deseret}', ""); +Expect(0, 66559, '\p{ In Deseret}', ""); +Expect(1, 66559, '\p{^ In Deseret}', ""); +Expect(1, 66559, '\P{ In Deseret}', ""); +Expect(0, 66559, '\P{^ In Deseret}', ""); +Error('\p{:= OTHER-Alphabetic}'); +Error('\P{:= OTHER-Alphabetic}'); +Expect(1, 837, '\p{otheralphabetic}', 'deprecated'); +Expect(0, 837, '\p{^otheralphabetic}', 'deprecated'); +Expect(0, 837, '\P{otheralphabetic}', 'deprecated'); +Expect(1, 837, '\P{^otheralphabetic}', 'deprecated'); +Expect(0, 836, '\p{otheralphabetic}', 'deprecated'); +Expect(1, 836, '\p{^otheralphabetic}', 'deprecated'); +Expect(1, 836, '\P{otheralphabetic}', 'deprecated'); +Expect(0, 836, '\P{^otheralphabetic}', 'deprecated'); +Expect(1, 837, '\p{_-Other_alphabetic}', 'deprecated'); +Expect(0, 837, '\p{^_-Other_alphabetic}', 'deprecated'); +Expect(0, 837, '\P{_-Other_alphabetic}', 'deprecated'); +Expect(1, 837, '\P{^_-Other_alphabetic}', 'deprecated'); +Expect(0, 836, '\p{_-Other_alphabetic}', 'deprecated'); +Expect(1, 836, '\p{^_-Other_alphabetic}', 'deprecated'); +Expect(1, 836, '\P{_-Other_alphabetic}', 'deprecated'); +Expect(0, 836, '\P{^_-Other_alphabetic}', 'deprecated'); +Error('\p{__Is:=Other_ALPHABETIC}'); +Error('\P{__Is:=Other_ALPHABETIC}'); +Expect(1, 837, '\p{isotheralphabetic}', 'deprecated'); +Expect(0, 837, '\p{^isotheralphabetic}', 'deprecated'); +Expect(0, 837, '\P{isotheralphabetic}', 'deprecated'); +Expect(1, 837, '\P{^isotheralphabetic}', 'deprecated'); +Expect(0, 836, '\p{isotheralphabetic}', 'deprecated'); +Expect(1, 836, '\p{^isotheralphabetic}', 'deprecated'); +Expect(1, 836, '\P{isotheralphabetic}', 'deprecated'); +Expect(0, 836, '\P{^isotheralphabetic}', 'deprecated'); +Expect(1, 837, '\p{ -IS_OTHER-Alphabetic}', 'deprecated'); +Expect(0, 837, '\p{^ -IS_OTHER-Alphabetic}', 'deprecated'); +Expect(0, 837, '\P{ -IS_OTHER-Alphabetic}', 'deprecated'); +Expect(1, 837, '\P{^ -IS_OTHER-Alphabetic}', 'deprecated'); +Expect(0, 836, '\p{ -IS_OTHER-Alphabetic}', 'deprecated'); +Expect(1, 836, '\p{^ -IS_OTHER-Alphabetic}', 'deprecated'); +Expect(1, 836, '\P{ -IS_OTHER-Alphabetic}', 'deprecated'); +Expect(0, 836, '\P{^ -IS_OTHER-Alphabetic}', 'deprecated'); +Error('\p{:=-oalpha}'); +Error('\P{:=-oalpha}'); +Expect(1, 837, '\p{oalpha}', 'deprecated'); +Expect(0, 837, '\p{^oalpha}', 'deprecated'); +Expect(0, 837, '\P{oalpha}', 'deprecated'); +Expect(1, 837, '\P{^oalpha}', 'deprecated'); +Expect(0, 836, '\p{oalpha}', 'deprecated'); +Expect(1, 836, '\p{^oalpha}', 'deprecated'); +Expect(1, 836, '\P{oalpha}', 'deprecated'); +Expect(0, 836, '\P{^oalpha}', 'deprecated'); +Expect(1, 837, '\p{-OALPHA}', 'deprecated'); +Expect(0, 837, '\p{^-OALPHA}', 'deprecated'); +Expect(0, 837, '\P{-OALPHA}', 'deprecated'); +Expect(1, 837, '\P{^-OALPHA}', 'deprecated'); +Expect(0, 836, '\p{-OALPHA}', 'deprecated'); +Expect(1, 836, '\p{^-OALPHA}', 'deprecated'); +Expect(1, 836, '\P{-OALPHA}', 'deprecated'); +Expect(0, 836, '\P{^-OALPHA}', 'deprecated'); +Error('\p{_:=Is-OALPHA}'); +Error('\P{_:=Is-OALPHA}'); +Expect(1, 837, '\p{isoalpha}', 'deprecated'); +Expect(0, 837, '\p{^isoalpha}', 'deprecated'); +Expect(0, 837, '\P{isoalpha}', 'deprecated'); +Expect(1, 837, '\P{^isoalpha}', 'deprecated'); +Expect(0, 836, '\p{isoalpha}', 'deprecated'); +Expect(1, 836, '\p{^isoalpha}', 'deprecated'); +Expect(1, 836, '\P{isoalpha}', 'deprecated'); +Expect(0, 836, '\P{^isoalpha}', 'deprecated'); +Expect(1, 837, '\p{ Is-OALPHA}', 'deprecated'); +Expect(0, 837, '\p{^ Is-OALPHA}', 'deprecated'); +Expect(0, 837, '\P{ Is-OALPHA}', 'deprecated'); +Expect(1, 837, '\P{^ Is-OALPHA}', 'deprecated'); +Expect(0, 836, '\p{ Is-OALPHA}', 'deprecated'); +Expect(1, 836, '\p{^ Is-OALPHA}', 'deprecated'); +Expect(1, 836, '\P{ Is-OALPHA}', 'deprecated'); +Expect(0, 836, '\P{^ Is-OALPHA}', 'deprecated'); +Error('\p{supplementaryPrivate/a/use Areaa}'); +Error('\P{supplementaryPrivate/a/use Areaa}'); +Expect(1, 983040, '\p{supplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\p{^supplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\P{supplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\P{^supplementaryprivateuseareaa}', ""); +Expect(0, 7, '\p{supplementaryprivateuseareaa}', ""); +Expect(1, 7, '\p{^supplementaryprivateuseareaa}', ""); +Expect(1, 7, '\P{supplementaryprivateuseareaa}', ""); +Expect(0, 7, '\P{^supplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\p{- supplementaryPrivate Use AREA_A}', ""); +Expect(0, 983040, '\p{^- supplementaryPrivate Use AREA_A}', ""); +Expect(0, 983040, '\P{- supplementaryPrivate Use AREA_A}', ""); +Expect(1, 983040, '\P{^- supplementaryPrivate Use AREA_A}', ""); +Expect(0, 7, '\p{- supplementaryPrivate Use AREA_A}', ""); +Expect(1, 7, '\p{^- supplementaryPrivate Use AREA_A}', ""); +Expect(1, 7, '\P{- supplementaryPrivate Use AREA_A}', ""); +Expect(0, 7, '\P{^- supplementaryPrivate Use AREA_A}', ""); +Error('\p{ Issupplementary:=PrivateUsearea A}'); +Error('\P{ Issupplementary:=PrivateUsearea A}'); +Expect(1, 983040, '\p{issupplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\p{^issupplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\P{issupplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\P{^issupplementaryprivateuseareaa}', ""); +Expect(0, 7, '\p{issupplementaryprivateuseareaa}', ""); +Expect(1, 7, '\p{^issupplementaryprivateuseareaa}', ""); +Expect(1, 7, '\P{issupplementaryprivateuseareaa}', ""); +Expect(0, 7, '\P{^issupplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\p{_ IS-SUPPLEMENTARY PRIVATE_USE_AreaA}', ""); +Expect(0, 983040, '\p{^_ IS-SUPPLEMENTARY PRIVATE_USE_AreaA}', ""); +Expect(0, 983040, '\P{_ IS-SUPPLEMENTARY PRIVATE_USE_AreaA}', ""); +Expect(1, 983040, '\P{^_ IS-SUPPLEMENTARY PRIVATE_USE_AreaA}', ""); +Expect(0, 7, '\p{_ IS-SUPPLEMENTARY PRIVATE_USE_AreaA}', ""); +Expect(1, 7, '\p{^_ IS-SUPPLEMENTARY PRIVATE_USE_AreaA}', ""); +Expect(1, 7, '\P{_ IS-SUPPLEMENTARY PRIVATE_USE_AreaA}', ""); +Expect(0, 7, '\P{^_ IS-SUPPLEMENTARY PRIVATE_USE_AreaA}', ""); +Error('\p{ In:=Supplementary_PRIVATE-UseArea A}'); +Error('\P{ In:=Supplementary_PRIVATE-UseArea A}'); +Expect(1, 983040, '\p{insupplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\p{^insupplementaryprivateuseareaa}', ""); +Expect(0, 983040, '\P{insupplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\P{^insupplementaryprivateuseareaa}', ""); +Expect(0, 7, '\p{insupplementaryprivateuseareaa}', ""); +Expect(1, 7, '\p{^insupplementaryprivateuseareaa}', ""); +Expect(1, 7, '\P{insupplementaryprivateuseareaa}', ""); +Expect(0, 7, '\P{^insupplementaryprivateuseareaa}', ""); +Expect(1, 983040, '\p{_In_SUPPLEMENTARYPRIVATE-use-Area A}', ""); +Expect(0, 983040, '\p{^_In_SUPPLEMENTARYPRIVATE-use-Area A}', ""); +Expect(0, 983040, '\P{_In_SUPPLEMENTARYPRIVATE-use-Area A}', ""); +Expect(1, 983040, '\P{^_In_SUPPLEMENTARYPRIVATE-use-Area A}', ""); +Expect(0, 7, '\p{_In_SUPPLEMENTARYPRIVATE-use-Area A}', ""); +Expect(1, 7, '\p{^_In_SUPPLEMENTARYPRIVATE-use-Area A}', ""); +Expect(1, 7, '\P{_In_SUPPLEMENTARYPRIVATE-use-Area A}', ""); +Expect(0, 7, '\P{^_In_SUPPLEMENTARYPRIVATE-use-Area A}', ""); +Error('\p{ Saurashtra/a/}'); +Error('\P{ Saurashtra/a/}'); +Expect(1, 43204, '\p{saurashtra}', ""); +Expect(0, 43204, '\p{^saurashtra}', ""); +Expect(0, 43204, '\P{saurashtra}', ""); +Expect(1, 43204, '\P{^saurashtra}', ""); +Expect(0, 43135, '\p{saurashtra}', ""); +Expect(1, 43135, '\p{^saurashtra}', ""); +Expect(1, 43135, '\P{saurashtra}', ""); +Expect(0, 43135, '\P{^saurashtra}', ""); +Expect(1, 43204, '\p{- saurashtra}', ""); +Expect(0, 43204, '\p{^- saurashtra}', ""); +Expect(0, 43204, '\P{- saurashtra}', ""); +Expect(1, 43204, '\P{^- saurashtra}', ""); +Expect(0, 43135, '\p{- saurashtra}', ""); +Expect(1, 43135, '\p{^- saurashtra}', ""); +Expect(1, 43135, '\P{- saurashtra}', ""); +Expect(0, 43135, '\P{^- saurashtra}', ""); +Error('\p{_:=Is_saurashtra}'); +Error('\P{_:=Is_saurashtra}'); +Expect(1, 43204, '\p{issaurashtra}', ""); +Expect(0, 43204, '\p{^issaurashtra}', ""); +Expect(0, 43204, '\P{issaurashtra}', ""); +Expect(1, 43204, '\P{^issaurashtra}', ""); +Expect(0, 43135, '\p{issaurashtra}', ""); +Expect(1, 43135, '\p{^issaurashtra}', ""); +Expect(1, 43135, '\P{issaurashtra}', ""); +Expect(0, 43135, '\P{^issaurashtra}', ""); +Expect(1, 43204, '\p{ Is-saurashtra}', ""); +Expect(0, 43204, '\p{^ Is-saurashtra}', ""); +Expect(0, 43204, '\P{ Is-saurashtra}', ""); +Expect(1, 43204, '\P{^ Is-saurashtra}', ""); +Expect(0, 43135, '\p{ Is-saurashtra}', ""); +Expect(1, 43135, '\p{^ Is-saurashtra}', ""); +Expect(1, 43135, '\P{ Is-saurashtra}', ""); +Expect(0, 43135, '\P{^ Is-saurashtra}', ""); +Error('\p{:=Saur}'); +Error('\P{:=Saur}'); +Expect(1, 43204, '\p{saur}', ""); +Expect(0, 43204, '\p{^saur}', ""); +Expect(0, 43204, '\P{saur}', ""); +Expect(1, 43204, '\P{^saur}', ""); +Expect(0, 43135, '\p{saur}', ""); +Expect(1, 43135, '\p{^saur}', ""); +Expect(1, 43135, '\P{saur}', ""); +Expect(0, 43135, '\P{^saur}', ""); +Expect(1, 43204, '\p{_ Saur}', ""); +Expect(0, 43204, '\p{^_ Saur}', ""); +Expect(0, 43204, '\P{_ Saur}', ""); +Expect(1, 43204, '\P{^_ Saur}', ""); +Expect(0, 43135, '\p{_ Saur}', ""); +Expect(1, 43135, '\p{^_ Saur}', ""); +Expect(1, 43135, '\P{_ Saur}', ""); +Expect(0, 43135, '\P{^_ Saur}', ""); +Error('\p{ :=is Saur}'); +Error('\P{ :=is Saur}'); +Expect(1, 43204, '\p{issaur}', ""); +Expect(0, 43204, '\p{^issaur}', ""); +Expect(0, 43204, '\P{issaur}', ""); +Expect(1, 43204, '\P{^issaur}', ""); +Expect(0, 43135, '\p{issaur}', ""); +Expect(1, 43135, '\p{^issaur}', ""); +Expect(1, 43135, '\P{issaur}', ""); +Expect(0, 43135, '\P{^issaur}', ""); +Expect(1, 43204, '\p{ -IsSaur}', ""); +Expect(0, 43204, '\p{^ -IsSaur}', ""); +Expect(0, 43204, '\P{ -IsSaur}', ""); +Expect(1, 43204, '\P{^ -IsSaur}', ""); +Expect(0, 43135, '\p{ -IsSaur}', ""); +Expect(1, 43135, '\p{^ -IsSaur}', ""); +Expect(1, 43135, '\P{ -IsSaur}', ""); +Expect(0, 43135, '\P{^ -IsSaur}', ""); +Error('\p{-tagbanwa:=}'); +Error('\P{-tagbanwa:=}'); +Expect(1, 5996, '\p{tagbanwa}', ""); +Expect(0, 5996, '\p{^tagbanwa}', ""); +Expect(0, 5996, '\P{tagbanwa}', ""); +Expect(1, 5996, '\P{^tagbanwa}', ""); +Expect(0, 5983, '\p{tagbanwa}', ""); +Expect(1, 5983, '\p{^tagbanwa}', ""); +Expect(1, 5983, '\P{tagbanwa}', ""); +Expect(0, 5983, '\P{^tagbanwa}', ""); +Expect(1, 5996, '\p{-_TAGBANWA}', ""); +Expect(0, 5996, '\p{^-_TAGBANWA}', ""); +Expect(0, 5996, '\P{-_TAGBANWA}', ""); +Expect(1, 5996, '\P{^-_TAGBANWA}', ""); +Expect(0, 5983, '\p{-_TAGBANWA}', ""); +Expect(1, 5983, '\p{^-_TAGBANWA}', ""); +Expect(1, 5983, '\P{-_TAGBANWA}', ""); +Expect(0, 5983, '\P{^-_TAGBANWA}', ""); +Error('\p{_/a/ISTagbanwa}'); +Error('\P{_/a/ISTagbanwa}'); +Expect(1, 5996, '\p{istagbanwa}', ""); +Expect(0, 5996, '\p{^istagbanwa}', ""); +Expect(0, 5996, '\P{istagbanwa}', ""); +Expect(1, 5996, '\P{^istagbanwa}', ""); +Expect(0, 5983, '\p{istagbanwa}', ""); +Expect(1, 5983, '\p{^istagbanwa}', ""); +Expect(1, 5983, '\P{istagbanwa}', ""); +Expect(0, 5983, '\P{^istagbanwa}', ""); +Expect(1, 5996, '\p{- Is_Tagbanwa}', ""); +Expect(0, 5996, '\p{^- Is_Tagbanwa}', ""); +Expect(0, 5996, '\P{- Is_Tagbanwa}', ""); +Expect(1, 5996, '\P{^- Is_Tagbanwa}', ""); +Expect(0, 5983, '\p{- Is_Tagbanwa}', ""); +Expect(1, 5983, '\p{^- Is_Tagbanwa}', ""); +Expect(1, 5983, '\P{- Is_Tagbanwa}', ""); +Expect(0, 5983, '\P{^- Is_Tagbanwa}', ""); +Error('\p{_:=TAGB}'); +Error('\P{_:=TAGB}'); +Expect(1, 5996, '\p{tagb}', ""); +Expect(0, 5996, '\p{^tagb}', ""); +Expect(0, 5996, '\P{tagb}', ""); +Expect(1, 5996, '\P{^tagb}', ""); +Expect(0, 5983, '\p{tagb}', ""); +Expect(1, 5983, '\p{^tagb}', ""); +Expect(1, 5983, '\P{tagb}', ""); +Expect(0, 5983, '\P{^tagb}', ""); +Expect(1, 5996, '\p{ -Tagb}', ""); +Expect(0, 5996, '\p{^ -Tagb}', ""); +Expect(0, 5996, '\P{ -Tagb}', ""); +Expect(1, 5996, '\P{^ -Tagb}', ""); +Expect(0, 5983, '\p{ -Tagb}', ""); +Expect(1, 5983, '\p{^ -Tagb}', ""); +Expect(1, 5983, '\P{ -Tagb}', ""); +Expect(0, 5983, '\P{^ -Tagb}', ""); +Error('\p{/a/ -Istagb}'); +Error('\P{/a/ -Istagb}'); +Expect(1, 5996, '\p{istagb}', ""); +Expect(0, 5996, '\p{^istagb}', ""); +Expect(0, 5996, '\P{istagb}', ""); +Expect(1, 5996, '\P{^istagb}', ""); +Expect(0, 5983, '\p{istagb}', ""); +Expect(1, 5983, '\p{^istagb}', ""); +Expect(1, 5983, '\P{istagb}', ""); +Expect(0, 5983, '\P{^istagb}', ""); +Expect(1, 5996, '\p{ -IS_Tagb}', ""); +Expect(0, 5996, '\p{^ -IS_Tagb}', ""); +Expect(0, 5996, '\P{ -IS_Tagb}', ""); +Expect(1, 5996, '\P{^ -IS_Tagb}', ""); +Expect(0, 5983, '\p{ -IS_Tagb}', ""); +Expect(1, 5983, '\p{^ -IS_Tagb}', ""); +Expect(1, 5983, '\P{ -IS_Tagb}', ""); +Expect(0, 5983, '\P{^ -IS_Tagb}', ""); +Error('\p{_khmer/a/Symbols}'); +Error('\P{_khmer/a/Symbols}'); +Expect(1, 6655, '\p{khmersymbols}', ""); +Expect(0, 6655, '\p{^khmersymbols}', ""); +Expect(0, 6655, '\P{khmersymbols}', ""); +Expect(1, 6655, '\P{^khmersymbols}', ""); +Expect(0, 6623, '\p{khmersymbols}', ""); +Expect(1, 6623, '\p{^khmersymbols}', ""); +Expect(1, 6623, '\P{khmersymbols}', ""); +Expect(0, 6623, '\P{^khmersymbols}', ""); +Expect(1, 6655, '\p{- Khmer Symbols}', ""); +Expect(0, 6655, '\p{^- Khmer Symbols}', ""); +Expect(0, 6655, '\P{- Khmer Symbols}', ""); +Expect(1, 6655, '\P{^- Khmer Symbols}', ""); +Expect(0, 6623, '\p{- Khmer Symbols}', ""); +Expect(1, 6623, '\p{^- Khmer Symbols}', ""); +Expect(1, 6623, '\P{- Khmer Symbols}', ""); +Expect(0, 6623, '\P{^- Khmer Symbols}', ""); +Error('\p{_ IsKhmer/a/Symbols}'); +Error('\P{_ IsKhmer/a/Symbols}'); +Expect(1, 6655, '\p{iskhmersymbols}', ""); +Expect(0, 6655, '\p{^iskhmersymbols}', ""); +Expect(0, 6655, '\P{iskhmersymbols}', ""); +Expect(1, 6655, '\P{^iskhmersymbols}', ""); +Expect(0, 6623, '\p{iskhmersymbols}', ""); +Expect(1, 6623, '\p{^iskhmersymbols}', ""); +Expect(1, 6623, '\P{iskhmersymbols}', ""); +Expect(0, 6623, '\P{^iskhmersymbols}', ""); +Expect(1, 6655, '\p{ _IS-khmersymbols}', ""); +Expect(0, 6655, '\p{^ _IS-khmersymbols}', ""); +Expect(0, 6655, '\P{ _IS-khmersymbols}', ""); +Expect(1, 6655, '\P{^ _IS-khmersymbols}', ""); +Expect(0, 6623, '\p{ _IS-khmersymbols}', ""); +Expect(1, 6623, '\p{^ _IS-khmersymbols}', ""); +Expect(1, 6623, '\P{ _IS-khmersymbols}', ""); +Expect(0, 6623, '\P{^ _IS-khmersymbols}', ""); +Error('\p{ _in_khmer:=SYMBOLS}'); +Error('\P{ _in_khmer:=SYMBOLS}'); +Expect(1, 6655, '\p{inkhmersymbols}', ""); +Expect(0, 6655, '\p{^inkhmersymbols}', ""); +Expect(0, 6655, '\P{inkhmersymbols}', ""); +Expect(1, 6655, '\P{^inkhmersymbols}', ""); +Expect(0, 6623, '\p{inkhmersymbols}', ""); +Expect(1, 6623, '\p{^inkhmersymbols}', ""); +Expect(1, 6623, '\P{inkhmersymbols}', ""); +Expect(0, 6623, '\P{^inkhmersymbols}', ""); +Expect(1, 6655, '\p{ -In_KHMER Symbols}', ""); +Expect(0, 6655, '\p{^ -In_KHMER Symbols}', ""); +Expect(0, 6655, '\P{ -In_KHMER Symbols}', ""); +Expect(1, 6655, '\P{^ -In_KHMER Symbols}', ""); +Expect(0, 6623, '\p{ -In_KHMER Symbols}', ""); +Expect(1, 6623, '\p{^ -In_KHMER Symbols}', ""); +Expect(1, 6623, '\P{ -In_KHMER Symbols}', ""); +Expect(0, 6623, '\P{^ -In_KHMER Symbols}', ""); +Error('\p{:= Math}'); +Error('\P{:= Math}'); +Expect(1, 43, '\p{math}', ""); +Expect(0, 43, '\p{^math}', ""); +Expect(0, 43, '\P{math}', ""); +Expect(1, 43, '\P{^math}', ""); +Expect(0, 42, '\p{math}', ""); +Expect(1, 42, '\p{^math}', ""); +Expect(1, 42, '\P{math}', ""); +Expect(0, 42, '\P{^math}', ""); +Expect(1, 43, '\p{ -Math}', ""); +Expect(0, 43, '\p{^ -Math}', ""); +Expect(0, 43, '\P{ -Math}', ""); +Expect(1, 43, '\P{^ -Math}', ""); +Expect(0, 42, '\p{ -Math}', ""); +Expect(1, 42, '\p{^ -Math}', ""); +Expect(1, 42, '\P{ -Math}', ""); +Expect(0, 42, '\P{^ -Math}', ""); +Error('\p{ IsMath/a/}'); +Error('\P{ IsMath/a/}'); +Expect(1, 43, '\p{ismath}', ""); +Expect(0, 43, '\p{^ismath}', ""); +Expect(0, 43, '\P{ismath}', ""); +Expect(1, 43, '\P{^ismath}', ""); +Expect(0, 42, '\p{ismath}', ""); +Expect(1, 42, '\p{^ismath}', ""); +Expect(1, 42, '\P{ismath}', ""); +Expect(0, 42, '\P{^ismath}', ""); +Expect(1, 43, '\p{_is_MATH}', ""); +Expect(0, 43, '\p{^_is_MATH}', ""); +Expect(0, 43, '\P{_is_MATH}', ""); +Expect(1, 43, '\P{^_is_MATH}', ""); +Expect(0, 42, '\p{_is_MATH}', ""); +Expect(1, 42, '\p{^_is_MATH}', ""); +Expect(1, 42, '\P{_is_MATH}', ""); +Expect(0, 42, '\P{^_is_MATH}', ""); +Error('\p{ Buhid/a/}'); +Error('\P{ Buhid/a/}'); +Expect(1, 5971, '\p{buhid}', ""); +Expect(0, 5971, '\p{^buhid}', ""); +Expect(0, 5971, '\P{buhid}', ""); +Expect(1, 5971, '\P{^buhid}', ""); +Expect(0, 5951, '\p{buhid}', ""); +Expect(1, 5951, '\p{^buhid}', ""); +Expect(1, 5951, '\P{buhid}', ""); +Expect(0, 5951, '\P{^buhid}', ""); +Expect(1, 5971, '\p{ _BUHID}', ""); +Expect(0, 5971, '\p{^ _BUHID}', ""); +Expect(0, 5971, '\P{ _BUHID}', ""); +Expect(1, 5971, '\P{^ _BUHID}', ""); +Expect(0, 5951, '\p{ _BUHID}', ""); +Expect(1, 5951, '\p{^ _BUHID}', ""); +Expect(1, 5951, '\P{ _BUHID}', ""); +Expect(0, 5951, '\P{^ _BUHID}', ""); +Error('\p{_Is_Buhid:=}'); +Error('\P{_Is_Buhid:=}'); +Expect(1, 5971, '\p{isbuhid}', ""); +Expect(0, 5971, '\p{^isbuhid}', ""); +Expect(0, 5971, '\P{isbuhid}', ""); +Expect(1, 5971, '\P{^isbuhid}', ""); +Expect(0, 5951, '\p{isbuhid}', ""); +Expect(1, 5951, '\p{^isbuhid}', ""); +Expect(1, 5951, '\P{isbuhid}', ""); +Expect(0, 5951, '\P{^isbuhid}', ""); +Expect(1, 5971, '\p{_ IS_Buhid}', ""); +Expect(0, 5971, '\p{^_ IS_Buhid}', ""); +Expect(0, 5971, '\P{_ IS_Buhid}', ""); +Expect(1, 5971, '\P{^_ IS_Buhid}', ""); +Expect(0, 5951, '\p{_ IS_Buhid}', ""); +Expect(1, 5951, '\p{^_ IS_Buhid}', ""); +Expect(1, 5951, '\P{_ IS_Buhid}', ""); +Expect(0, 5951, '\P{^_ IS_Buhid}', ""); +Error('\p{_Buhd:=}'); +Error('\P{_Buhd:=}'); +Expect(1, 5971, '\p{buhd}', ""); +Expect(0, 5971, '\p{^buhd}', ""); +Expect(0, 5971, '\P{buhd}', ""); +Expect(1, 5971, '\P{^buhd}', ""); +Expect(0, 5951, '\p{buhd}', ""); +Expect(1, 5951, '\p{^buhd}', ""); +Expect(1, 5951, '\P{buhd}', ""); +Expect(0, 5951, '\P{^buhd}', ""); +Expect(1, 5971, '\p{ _Buhd}', ""); +Expect(0, 5971, '\p{^ _Buhd}', ""); +Expect(0, 5971, '\P{ _Buhd}', ""); +Expect(1, 5971, '\P{^ _Buhd}', ""); +Expect(0, 5951, '\p{ _Buhd}', ""); +Expect(1, 5951, '\p{^ _Buhd}', ""); +Expect(1, 5951, '\P{ _Buhd}', ""); +Expect(0, 5951, '\P{^ _Buhd}', ""); +Error('\p{--ISBuhd:=}'); +Error('\P{--ISBuhd:=}'); +Expect(1, 5971, '\p{isbuhd}', ""); +Expect(0, 5971, '\p{^isbuhd}', ""); +Expect(0, 5971, '\P{isbuhd}', ""); +Expect(1, 5971, '\P{^isbuhd}', ""); +Expect(0, 5951, '\p{isbuhd}', ""); +Expect(1, 5951, '\p{^isbuhd}', ""); +Expect(1, 5951, '\P{isbuhd}', ""); +Expect(0, 5951, '\P{^isbuhd}', ""); +Expect(1, 5971, '\p{ _ISBuhd}', ""); +Expect(0, 5971, '\p{^ _ISBuhd}', ""); +Expect(0, 5971, '\P{ _ISBuhd}', ""); +Expect(1, 5971, '\P{^ _ISBuhd}', ""); +Expect(0, 5951, '\p{ _ISBuhd}', ""); +Expect(1, 5951, '\p{^ _ISBuhd}', ""); +Expect(1, 5951, '\P{ _ISBuhd}', ""); +Expect(0, 5951, '\P{^ _ISBuhd}', ""); +Error('\p{ Greek:=AND coptic}'); +Error('\P{ Greek:=AND coptic}'); +Expect(1, 1023, '\p{greekandcoptic}', ""); +Expect(0, 1023, '\p{^greekandcoptic}', ""); +Expect(0, 1023, '\P{greekandcoptic}', ""); +Expect(1, 1023, '\P{^greekandcoptic}', ""); +Expect(0, 879, '\p{greekandcoptic}', ""); +Expect(1, 879, '\p{^greekandcoptic}', ""); +Expect(1, 879, '\P{greekandcoptic}', ""); +Expect(0, 879, '\P{^greekandcoptic}', ""); +Expect(1, 1023, '\p{_-Greek And Coptic}', ""); +Expect(0, 1023, '\p{^_-Greek And Coptic}', ""); +Expect(0, 1023, '\P{_-Greek And Coptic}', ""); +Expect(1, 1023, '\P{^_-Greek And Coptic}', ""); +Expect(0, 879, '\p{_-Greek And Coptic}', ""); +Expect(1, 879, '\p{^_-Greek And Coptic}', ""); +Expect(1, 879, '\P{_-Greek And Coptic}', ""); +Expect(0, 879, '\P{^_-Greek And Coptic}', ""); +Error('\p{ _is greek-And-COPTIC/a/}'); +Error('\P{ _is greek-And-COPTIC/a/}'); +Expect(1, 1023, '\p{isgreekandcoptic}', ""); +Expect(0, 1023, '\p{^isgreekandcoptic}', ""); +Expect(0, 1023, '\P{isgreekandcoptic}', ""); +Expect(1, 1023, '\P{^isgreekandcoptic}', ""); +Expect(0, 879, '\p{isgreekandcoptic}', ""); +Expect(1, 879, '\p{^isgreekandcoptic}', ""); +Expect(1, 879, '\P{isgreekandcoptic}', ""); +Expect(0, 879, '\P{^isgreekandcoptic}', ""); +Expect(1, 1023, '\p{Is_greek AND-Coptic}', ""); +Expect(0, 1023, '\p{^Is_greek AND-Coptic}', ""); +Expect(0, 1023, '\P{Is_greek AND-Coptic}', ""); +Expect(1, 1023, '\P{^Is_greek AND-Coptic}', ""); +Expect(0, 879, '\p{Is_greek AND-Coptic}', ""); +Expect(1, 879, '\p{^Is_greek AND-Coptic}', ""); +Expect(1, 879, '\P{Is_greek AND-Coptic}', ""); +Expect(0, 879, '\P{^Is_greek AND-Coptic}', ""); +Error('\p{ In_Greek-AND/a/COPTIC}'); +Error('\P{ In_Greek-AND/a/COPTIC}'); +Expect(1, 1023, '\p{ingreekandcoptic}', ""); +Expect(0, 1023, '\p{^ingreekandcoptic}', ""); +Expect(0, 1023, '\P{ingreekandcoptic}', ""); +Expect(1, 1023, '\P{^ingreekandcoptic}', ""); +Expect(0, 879, '\p{ingreekandcoptic}', ""); +Expect(1, 879, '\p{^ingreekandcoptic}', ""); +Expect(1, 879, '\P{ingreekandcoptic}', ""); +Expect(0, 879, '\P{^ingreekandcoptic}', ""); +Expect(1, 1023, '\p{- In greek_And_COPTIC}', ""); +Expect(0, 1023, '\p{^- In greek_And_COPTIC}', ""); +Expect(0, 1023, '\P{- In greek_And_COPTIC}', ""); +Expect(1, 1023, '\P{^- In greek_And_COPTIC}', ""); +Expect(0, 879, '\p{- In greek_And_COPTIC}', ""); +Expect(1, 879, '\p{^- In greek_And_COPTIC}', ""); +Expect(1, 879, '\P{- In greek_And_COPTIC}', ""); +Expect(0, 879, '\P{^- In greek_And_COPTIC}', ""); +Error('\p{/a/In-Greek}'); +Error('\P{/a/In-Greek}'); +Expect(1, 1023, '\p{ingreek}', ""); +Expect(0, 1023, '\p{^ingreek}', ""); +Expect(0, 1023, '\P{ingreek}', ""); +Expect(1, 1023, '\P{^ingreek}', ""); +Expect(0, 879, '\p{ingreek}', ""); +Expect(1, 879, '\p{^ingreek}', ""); +Expect(1, 879, '\P{ingreek}', ""); +Expect(0, 879, '\P{^ingreek}', ""); +Expect(1, 1023, '\p{ In-greek}', ""); +Expect(0, 1023, '\p{^ In-greek}', ""); +Expect(0, 1023, '\P{ In-greek}', ""); +Expect(1, 1023, '\P{^ In-greek}', ""); +Expect(0, 879, '\p{ In-greek}', ""); +Expect(1, 879, '\p{^ In-greek}', ""); +Expect(1, 879, '\P{ In-greek}', ""); +Expect(0, 879, '\P{^ In-greek}', ""); +Error('\p{white SPACE/a/}'); +Error('\P{white SPACE/a/}'); +Expect(1, 13, '\p{whitespace}', ""); +Expect(0, 13, '\p{^whitespace}', ""); +Expect(0, 13, '\P{whitespace}', ""); +Expect(1, 13, '\P{^whitespace}', ""); +Expect(0, 8, '\p{whitespace}', ""); +Expect(1, 8, '\p{^whitespace}', ""); +Expect(1, 8, '\P{whitespace}', ""); +Expect(0, 8, '\P{^whitespace}', ""); +Expect(1, 13, '\p{ WHITE space}', ""); +Expect(0, 13, '\p{^ WHITE space}', ""); +Expect(0, 13, '\P{ WHITE space}', ""); +Expect(1, 13, '\P{^ WHITE space}', ""); +Expect(0, 8, '\p{ WHITE space}', ""); +Expect(1, 8, '\p{^ WHITE space}', ""); +Expect(1, 8, '\P{ WHITE space}', ""); +Expect(0, 8, '\P{^ WHITE space}', ""); +Error('\p{ Is:=WHITE_space}'); +Error('\P{ Is:=WHITE_space}'); +Expect(1, 13, '\p{iswhitespace}', ""); +Expect(0, 13, '\p{^iswhitespace}', ""); +Expect(0, 13, '\P{iswhitespace}', ""); +Expect(1, 13, '\P{^iswhitespace}', ""); +Expect(0, 8, '\p{iswhitespace}', ""); +Expect(1, 8, '\p{^iswhitespace}', ""); +Expect(1, 8, '\P{iswhitespace}', ""); +Expect(0, 8, '\P{^iswhitespace}', ""); +Expect(1, 13, '\p{_-Is white_Space}', ""); +Expect(0, 13, '\p{^_-Is white_Space}', ""); +Expect(0, 13, '\P{_-Is white_Space}', ""); +Expect(1, 13, '\P{^_-Is white_Space}', ""); +Expect(0, 8, '\p{_-Is white_Space}', ""); +Expect(1, 8, '\p{^_-Is white_Space}', ""); +Expect(1, 8, '\P{_-Is white_Space}', ""); +Expect(0, 8, '\P{^_-Is white_Space}', ""); +Error('\p{-:=wspace}'); +Error('\P{-:=wspace}'); +Expect(1, 13, '\p{wspace}', ""); +Expect(0, 13, '\p{^wspace}', ""); +Expect(0, 13, '\P{wspace}', ""); +Expect(1, 13, '\P{^wspace}', ""); +Expect(0, 8, '\p{wspace}', ""); +Expect(1, 8, '\p{^wspace}', ""); +Expect(1, 8, '\P{wspace}', ""); +Expect(0, 8, '\P{^wspace}', ""); +Expect(1, 13, '\p{_WSpace}', ""); +Expect(0, 13, '\p{^_WSpace}', ""); +Expect(0, 13, '\P{_WSpace}', ""); +Expect(1, 13, '\P{^_WSpace}', ""); +Expect(0, 8, '\p{_WSpace}', ""); +Expect(1, 8, '\p{^_WSpace}', ""); +Expect(1, 8, '\P{_WSpace}', ""); +Expect(0, 8, '\P{^_WSpace}', ""); +Error('\p{ /a/isWSpace}'); +Error('\P{ /a/isWSpace}'); +Expect(1, 13, '\p{iswspace}', ""); +Expect(0, 13, '\p{^iswspace}', ""); +Expect(0, 13, '\P{iswspace}', ""); +Expect(1, 13, '\P{^iswspace}', ""); +Expect(0, 8, '\p{iswspace}', ""); +Expect(1, 8, '\p{^iswspace}', ""); +Expect(1, 8, '\P{iswspace}', ""); +Expect(0, 8, '\P{^iswspace}', ""); +Expect(1, 13, '\p{--IS-WSpace}', ""); +Expect(0, 13, '\p{^--IS-WSpace}', ""); +Expect(0, 13, '\P{--IS-WSpace}', ""); +Expect(1, 13, '\P{^--IS-WSpace}', ""); +Expect(0, 8, '\p{--IS-WSpace}', ""); +Expect(1, 8, '\p{^--IS-WSpace}', ""); +Expect(1, 8, '\P{--IS-WSpace}', ""); +Expect(0, 8, '\P{^--IS-WSpace}', ""); +Error('\p{_:=SUPPLEMENTARY_PrivateUse_Area_B}'); +Error('\P{_:=SUPPLEMENTARY_PrivateUse_Area_B}'); +Expect(1, 1048576, '\p{supplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\p{^supplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\P{supplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\P{^supplementaryprivateuseareab}', ""); +Expect(0, 7, '\p{supplementaryprivateuseareab}', ""); +Expect(1, 7, '\p{^supplementaryprivateuseareab}', ""); +Expect(1, 7, '\P{supplementaryprivateuseareab}', ""); +Expect(0, 7, '\P{^supplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\p{ Supplementary private UseAREA B}', ""); +Expect(0, 1048576, '\p{^ Supplementary private UseAREA B}', ""); +Expect(0, 1048576, '\P{ Supplementary private UseAREA B}', ""); +Expect(1, 1048576, '\P{^ Supplementary private UseAREA B}', ""); +Expect(0, 7, '\p{ Supplementary private UseAREA B}', ""); +Expect(1, 7, '\p{^ Supplementary private UseAREA B}', ""); +Expect(1, 7, '\P{ Supplementary private UseAREA B}', ""); +Expect(0, 7, '\P{^ Supplementary private UseAREA B}', ""); +Error('\p{_:=is_Supplementary-PRIVATE USE-Area B}'); +Error('\P{_:=is_Supplementary-PRIVATE USE-Area B}'); +Expect(1, 1048576, '\p{issupplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\p{^issupplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\P{issupplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\P{^issupplementaryprivateuseareab}', ""); +Expect(0, 7, '\p{issupplementaryprivateuseareab}', ""); +Expect(1, 7, '\p{^issupplementaryprivateuseareab}', ""); +Expect(1, 7, '\P{issupplementaryprivateuseareab}', ""); +Expect(0, 7, '\P{^issupplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\p{_-IsSupplementary Private_USE-Area B}', ""); +Expect(0, 1048576, '\p{^_-IsSupplementary Private_USE-Area B}', ""); +Expect(0, 1048576, '\P{_-IsSupplementary Private_USE-Area B}', ""); +Expect(1, 1048576, '\P{^_-IsSupplementary Private_USE-Area B}', ""); +Expect(0, 7, '\p{_-IsSupplementary Private_USE-Area B}', ""); +Expect(1, 7, '\p{^_-IsSupplementary Private_USE-Area B}', ""); +Expect(1, 7, '\P{_-IsSupplementary Private_USE-Area B}', ""); +Expect(0, 7, '\P{^_-IsSupplementary Private_USE-Area B}', ""); +Error('\p{ insupplementary-Private-USE:=AREA_B}'); +Error('\P{ insupplementary-Private-USE:=AREA_B}'); +Expect(1, 1048576, '\p{insupplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\p{^insupplementaryprivateuseareab}', ""); +Expect(0, 1048576, '\P{insupplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\P{^insupplementaryprivateuseareab}', ""); +Expect(0, 7, '\p{insupplementaryprivateuseareab}', ""); +Expect(1, 7, '\p{^insupplementaryprivateuseareab}', ""); +Expect(1, 7, '\P{insupplementaryprivateuseareab}', ""); +Expect(0, 7, '\P{^insupplementaryprivateuseareab}', ""); +Expect(1, 1048576, '\p{_-InsupplementaryPRIVATE-USE area B}', ""); +Expect(0, 1048576, '\p{^_-InsupplementaryPRIVATE-USE area B}', ""); +Expect(0, 1048576, '\P{_-InsupplementaryPRIVATE-USE area B}', ""); +Expect(1, 1048576, '\P{^_-InsupplementaryPRIVATE-USE area B}', ""); +Expect(0, 7, '\p{_-InsupplementaryPRIVATE-USE area B}', ""); +Expect(1, 7, '\p{^_-InsupplementaryPRIVATE-USE area B}', ""); +Expect(1, 7, '\P{_-InsupplementaryPRIVATE-USE area B}', ""); +Expect(0, 7, '\P{^_-InsupplementaryPRIVATE-USE area B}', ""); +Error('\p{ IN/a/Cuneiform}'); +Error('\P{ IN/a/Cuneiform}'); +Expect(1, 74751, '\p{incuneiform}', ""); +Expect(0, 74751, '\p{^incuneiform}', ""); +Expect(0, 74751, '\P{incuneiform}', ""); +Expect(1, 74751, '\P{^incuneiform}', ""); +Expect(0, 73727, '\p{incuneiform}', ""); +Expect(1, 73727, '\p{^incuneiform}', ""); +Expect(1, 73727, '\P{incuneiform}', ""); +Expect(0, 73727, '\P{^incuneiform}', ""); +Expect(1, 74751, '\p{_ in_CUNEIFORM}', ""); +Expect(0, 74751, '\p{^_ in_CUNEIFORM}', ""); +Expect(0, 74751, '\P{_ in_CUNEIFORM}', ""); +Expect(1, 74751, '\P{^_ in_CUNEIFORM}', ""); +Expect(0, 73727, '\p{_ in_CUNEIFORM}', ""); +Expect(1, 73727, '\p{^_ in_CUNEIFORM}', ""); +Expect(1, 73727, '\P{_ in_CUNEIFORM}', ""); +Expect(0, 73727, '\P{^_ in_CUNEIFORM}', ""); +Error('\p{- CJK:=SYMBOLSand-PUNCTUATION}'); +Error('\P{- CJK:=SYMBOLSand-PUNCTUATION}'); +Expect(1, 12351, '\p{cjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\p{^cjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\P{cjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\P{^cjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\p{cjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\p{^cjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\P{cjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\P{^cjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\p{ CJK-Symbols_And Punctuation}', ""); +Expect(0, 12351, '\p{^ CJK-Symbols_And Punctuation}', ""); +Expect(0, 12351, '\P{ CJK-Symbols_And Punctuation}', ""); +Expect(1, 12351, '\P{^ CJK-Symbols_And Punctuation}', ""); +Expect(0, 12287, '\p{ CJK-Symbols_And Punctuation}', ""); +Expect(1, 12287, '\p{^ CJK-Symbols_And Punctuation}', ""); +Expect(1, 12287, '\P{ CJK-Symbols_And Punctuation}', ""); +Expect(0, 12287, '\P{^ CJK-Symbols_And Punctuation}', ""); +Error('\p{_/a/is_CJK Symbols-and_Punctuation}'); +Error('\P{_/a/is_CJK Symbols-and_Punctuation}'); +Expect(1, 12351, '\p{iscjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\p{^iscjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\P{iscjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\P{^iscjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\p{iscjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\p{^iscjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\P{iscjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\P{^iscjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\p{ Is_cjk_Symbols and Punctuation}', ""); +Expect(0, 12351, '\p{^ Is_cjk_Symbols and Punctuation}', ""); +Expect(0, 12351, '\P{ Is_cjk_Symbols and Punctuation}', ""); +Expect(1, 12351, '\P{^ Is_cjk_Symbols and Punctuation}', ""); +Expect(0, 12287, '\p{ Is_cjk_Symbols and Punctuation}', ""); +Expect(1, 12287, '\p{^ Is_cjk_Symbols and Punctuation}', ""); +Expect(1, 12287, '\P{ Is_cjk_Symbols and Punctuation}', ""); +Expect(0, 12287, '\P{^ Is_cjk_Symbols and Punctuation}', ""); +Error('\p{ INcjk-SymbolsAndPunctuation/a/}'); +Error('\P{ INcjk-SymbolsAndPunctuation/a/}'); +Expect(1, 12351, '\p{incjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\p{^incjksymbolsandpunctuation}', ""); +Expect(0, 12351, '\P{incjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\P{^incjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\p{incjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\p{^incjksymbolsandpunctuation}', ""); +Expect(1, 12287, '\P{incjksymbolsandpunctuation}', ""); +Expect(0, 12287, '\P{^incjksymbolsandpunctuation}', ""); +Expect(1, 12351, '\p{ -Incjk SYMBOLS-and-PUNCTUATION}', ""); +Expect(0, 12351, '\p{^ -Incjk SYMBOLS-and-PUNCTUATION}', ""); +Expect(0, 12351, '\P{ -Incjk SYMBOLS-and-PUNCTUATION}', ""); +Expect(1, 12351, '\P{^ -Incjk SYMBOLS-and-PUNCTUATION}', ""); +Expect(0, 12287, '\p{ -Incjk SYMBOLS-and-PUNCTUATION}', ""); +Expect(1, 12287, '\p{^ -Incjk SYMBOLS-and-PUNCTUATION}', ""); +Expect(1, 12287, '\P{ -Incjk SYMBOLS-and-PUNCTUATION}', ""); +Expect(0, 12287, '\P{^ -Incjk SYMBOLS-and-PUNCTUATION}', ""); +Error('\p{ surrogate:=}'); +Error('\P{ surrogate:=}'); +Expect(0, 55295, '\p{surrogate}', ""); +Expect(1, 55295, '\p{^surrogate}', ""); +Expect(1, 55295, '\P{surrogate}', ""); +Expect(0, 55295, '\P{^surrogate}', ""); +Expect(0, 55295, '\p{ Surrogate}', ""); +Expect(1, 55295, '\p{^ Surrogate}', ""); +Expect(1, 55295, '\P{ Surrogate}', ""); +Expect(0, 55295, '\P{^ Surrogate}', ""); +Error('\p{ IS:=Surrogate}'); +Error('\P{ IS:=Surrogate}'); +Expect(0, 55295, '\p{issurrogate}', ""); +Expect(1, 55295, '\p{^issurrogate}', ""); +Expect(1, 55295, '\P{issurrogate}', ""); +Expect(0, 55295, '\P{^issurrogate}', ""); +Expect(0, 55295, '\p{- IS surrogate}', ""); +Expect(1, 55295, '\p{^- IS surrogate}', ""); +Expect(1, 55295, '\P{- IS surrogate}', ""); +Expect(0, 55295, '\P{^- IS surrogate}', ""); +Error('\p{/a/ Cs}'); +Error('\P{/a/ Cs}'); +Expect(0, 55295, '\p{cs}', ""); +Expect(1, 55295, '\p{^cs}', ""); +Expect(1, 55295, '\P{cs}', ""); +Expect(0, 55295, '\P{^cs}', ""); +Expect(0, 55295, '\p{_-CS}', ""); +Expect(1, 55295, '\p{^_-CS}', ""); +Expect(1, 55295, '\P{_-CS}', ""); +Expect(0, 55295, '\P{^_-CS}', ""); +Error('\p{/a/Is Cs}'); +Error('\P{/a/Is Cs}'); +Expect(0, 55295, '\p{iscs}', ""); +Expect(1, 55295, '\p{^iscs}', ""); +Expect(1, 55295, '\P{iscs}', ""); +Expect(0, 55295, '\P{^iscs}', ""); +Expect(0, 55295, '\p{-_Is Cs}', ""); +Expect(1, 55295, '\p{^-_Is Cs}', ""); +Expect(1, 55295, '\P{-_Is Cs}', ""); +Expect(0, 55295, '\P{^-_Is Cs}', ""); +Error('\p{- In-Coptic:=}'); +Error('\P{- In-Coptic:=}'); +Expect(1, 11519, '\p{incoptic}', ""); +Expect(0, 11519, '\p{^incoptic}', ""); +Expect(0, 11519, '\P{incoptic}', ""); +Expect(1, 11519, '\P{^incoptic}', ""); +Expect(0, 11391, '\p{incoptic}', ""); +Expect(1, 11391, '\p{^incoptic}', ""); +Expect(1, 11391, '\P{incoptic}', ""); +Expect(0, 11391, '\P{^incoptic}', ""); +Expect(1, 11519, '\p{ -In-coptic}', ""); +Expect(0, 11519, '\p{^ -In-coptic}', ""); +Expect(0, 11519, '\P{ -In-coptic}', ""); +Expect(1, 11519, '\P{^ -In-coptic}', ""); +Expect(0, 11391, '\p{ -In-coptic}', ""); +Expect(1, 11391, '\p{^ -In-coptic}', ""); +Expect(1, 11391, '\P{ -In-coptic}', ""); +Expect(0, 11391, '\P{^ -In-coptic}', ""); +Error('\p{/a/khmer}'); +Error('\P{/a/khmer}'); +Expect(1, 6109, '\p{khmer}', ""); +Expect(0, 6109, '\p{^khmer}', ""); +Expect(0, 6109, '\P{khmer}', ""); +Expect(1, 6109, '\P{^khmer}', ""); +Expect(0, 6015, '\p{khmer}', ""); +Expect(1, 6015, '\p{^khmer}', ""); +Expect(1, 6015, '\P{khmer}', ""); +Expect(0, 6015, '\P{^khmer}', ""); +Expect(1, 6109, '\p{- Khmer}', ""); +Expect(0, 6109, '\p{^- Khmer}', ""); +Expect(0, 6109, '\P{- Khmer}', ""); +Expect(1, 6109, '\P{^- Khmer}', ""); +Expect(0, 6015, '\p{- Khmer}', ""); +Expect(1, 6015, '\p{^- Khmer}', ""); +Expect(1, 6015, '\P{- Khmer}', ""); +Expect(0, 6015, '\P{^- Khmer}', ""); +Error('\p{/a/ IsKhmer}'); +Error('\P{/a/ IsKhmer}'); +Expect(1, 6109, '\p{iskhmer}', ""); +Expect(0, 6109, '\p{^iskhmer}', ""); +Expect(0, 6109, '\P{iskhmer}', ""); +Expect(1, 6109, '\P{^iskhmer}', ""); +Expect(0, 6015, '\p{iskhmer}', ""); +Expect(1, 6015, '\p{^iskhmer}', ""); +Expect(1, 6015, '\P{iskhmer}', ""); +Expect(0, 6015, '\P{^iskhmer}', ""); +Expect(1, 6109, '\p{- ISKhmer}', ""); +Expect(0, 6109, '\p{^- ISKhmer}', ""); +Expect(0, 6109, '\P{- ISKhmer}', ""); +Expect(1, 6109, '\P{^- ISKhmer}', ""); +Expect(0, 6015, '\p{- ISKhmer}', ""); +Expect(1, 6015, '\p{^- ISKhmer}', ""); +Expect(1, 6015, '\P{- ISKhmer}', ""); +Expect(0, 6015, '\P{^- ISKhmer}', ""); +Error('\p{:=- Khmr}'); +Error('\P{:=- Khmr}'); +Expect(1, 6109, '\p{khmr}', ""); +Expect(0, 6109, '\p{^khmr}', ""); +Expect(0, 6109, '\P{khmr}', ""); +Expect(1, 6109, '\P{^khmr}', ""); +Expect(0, 6015, '\p{khmr}', ""); +Expect(1, 6015, '\p{^khmr}', ""); +Expect(1, 6015, '\P{khmr}', ""); +Expect(0, 6015, '\P{^khmr}', ""); +Expect(1, 6109, '\p{_ khmr}', ""); +Expect(0, 6109, '\p{^_ khmr}', ""); +Expect(0, 6109, '\P{_ khmr}', ""); +Expect(1, 6109, '\P{^_ khmr}', ""); +Expect(0, 6015, '\p{_ khmr}', ""); +Expect(1, 6015, '\p{^_ khmr}', ""); +Expect(1, 6015, '\P{_ khmr}', ""); +Expect(0, 6015, '\P{^_ khmr}', ""); +Error('\p{- IsKhmr/a/}'); +Error('\P{- IsKhmr/a/}'); +Expect(1, 6109, '\p{iskhmr}', ""); +Expect(0, 6109, '\p{^iskhmr}', ""); +Expect(0, 6109, '\P{iskhmr}', ""); +Expect(1, 6109, '\P{^iskhmr}', ""); +Expect(0, 6015, '\p{iskhmr}', ""); +Expect(1, 6015, '\p{^iskhmr}', ""); +Expect(1, 6015, '\P{iskhmr}', ""); +Expect(0, 6015, '\P{^iskhmr}', ""); +Expect(1, 6109, '\p{-Is Khmr}', ""); +Expect(0, 6109, '\p{^-Is Khmr}', ""); +Expect(0, 6109, '\P{-Is Khmr}', ""); +Expect(1, 6109, '\P{^-Is Khmr}', ""); +Expect(0, 6015, '\p{-Is Khmr}', ""); +Expect(1, 6015, '\p{^-Is Khmr}', ""); +Expect(1, 6015, '\P{-Is Khmr}', ""); +Expect(0, 6015, '\P{^-Is Khmr}', ""); +Error('\p{ IN NKo:=}'); +Error('\P{ IN NKo:=}'); +Expect(1, 2047, '\p{innko}', ""); +Expect(0, 2047, '\p{^innko}', ""); +Expect(0, 2047, '\P{innko}', ""); +Expect(1, 2047, '\P{^innko}', ""); +Expect(0, 1983, '\p{innko}', ""); +Expect(1, 1983, '\p{^innko}', ""); +Expect(1, 1983, '\P{innko}', ""); +Expect(0, 1983, '\P{^innko}', ""); +Expect(1, 2047, '\p{ In_nko}', ""); +Expect(0, 2047, '\p{^ In_nko}', ""); +Expect(0, 2047, '\P{ In_nko}', ""); +Expect(1, 2047, '\P{^ In_nko}', ""); +Expect(0, 1983, '\p{ In_nko}', ""); +Expect(1, 1983, '\p{^ In_nko}', ""); +Expect(1, 1983, '\P{ In_nko}', ""); +Expect(0, 1983, '\P{^ In_nko}', ""); +Error('\p{:=Linear_bsyllabary}'); +Error('\P{:=Linear_bsyllabary}'); +Expect(1, 65663, '\p{linearbsyllabary}', ""); +Expect(0, 65663, '\p{^linearbsyllabary}', ""); +Expect(0, 65663, '\P{linearbsyllabary}', ""); +Expect(1, 65663, '\P{^linearbsyllabary}', ""); +Expect(0, 7, '\p{linearbsyllabary}', ""); +Expect(1, 7, '\p{^linearbsyllabary}', ""); +Expect(1, 7, '\P{linearbsyllabary}', ""); +Expect(0, 7, '\P{^linearbsyllabary}', ""); +Expect(1, 65663, '\p{-_linear B-Syllabary}', ""); +Expect(0, 65663, '\p{^-_linear B-Syllabary}', ""); +Expect(0, 65663, '\P{-_linear B-Syllabary}', ""); +Expect(1, 65663, '\P{^-_linear B-Syllabary}', ""); +Expect(0, 7, '\p{-_linear B-Syllabary}', ""); +Expect(1, 7, '\p{^-_linear B-Syllabary}', ""); +Expect(1, 7, '\P{-_linear B-Syllabary}', ""); +Expect(0, 7, '\P{^-_linear B-Syllabary}', ""); +Error('\p{ Is Linear/a/BSyllabary}'); +Error('\P{ Is Linear/a/BSyllabary}'); +Expect(1, 65663, '\p{islinearbsyllabary}', ""); +Expect(0, 65663, '\p{^islinearbsyllabary}', ""); +Expect(0, 65663, '\P{islinearbsyllabary}', ""); +Expect(1, 65663, '\P{^islinearbsyllabary}', ""); +Expect(0, 7, '\p{islinearbsyllabary}', ""); +Expect(1, 7, '\p{^islinearbsyllabary}', ""); +Expect(1, 7, '\P{islinearbsyllabary}', ""); +Expect(0, 7, '\P{^islinearbsyllabary}', ""); +Expect(1, 65663, '\p{ IS-LINEARB Syllabary}', ""); +Expect(0, 65663, '\p{^ IS-LINEARB Syllabary}', ""); +Expect(0, 65663, '\P{ IS-LINEARB Syllabary}', ""); +Expect(1, 65663, '\P{^ IS-LINEARB Syllabary}', ""); +Expect(0, 7, '\p{ IS-LINEARB Syllabary}', ""); +Expect(1, 7, '\p{^ IS-LINEARB Syllabary}', ""); +Expect(1, 7, '\P{ IS-LINEARB Syllabary}', ""); +Expect(0, 7, '\P{^ IS-LINEARB Syllabary}', ""); +Error('\p{ In-LINEAR:=B-Syllabary}'); +Error('\P{ In-LINEAR:=B-Syllabary}'); +Expect(1, 65663, '\p{inlinearbsyllabary}', ""); +Expect(0, 65663, '\p{^inlinearbsyllabary}', ""); +Expect(0, 65663, '\P{inlinearbsyllabary}', ""); +Expect(1, 65663, '\P{^inlinearbsyllabary}', ""); +Expect(0, 7, '\p{inlinearbsyllabary}', ""); +Expect(1, 7, '\p{^inlinearbsyllabary}', ""); +Expect(1, 7, '\P{inlinearbsyllabary}', ""); +Expect(0, 7, '\P{^inlinearbsyllabary}', ""); +Expect(1, 65663, '\p{__INLINEAR-B_syllabary}', ""); +Expect(0, 65663, '\p{^__INLINEAR-B_syllabary}', ""); +Expect(0, 65663, '\P{__INLINEAR-B_syllabary}', ""); +Expect(1, 65663, '\P{^__INLINEAR-B_syllabary}', ""); +Expect(0, 7, '\p{__INLINEAR-B_syllabary}', ""); +Expect(1, 7, '\p{^__INLINEAR-B_syllabary}', ""); +Expect(1, 7, '\P{__INLINEAR-B_syllabary}', ""); +Expect(0, 7, '\P{^__INLINEAR-B_syllabary}', ""); +Error('\p{:=- In-Buginese}'); +Error('\P{:=- In-Buginese}'); +Expect(1, 6687, '\p{inbuginese}', ""); +Expect(0, 6687, '\p{^inbuginese}', ""); +Expect(0, 6687, '\P{inbuginese}', ""); +Expect(1, 6687, '\P{^inbuginese}', ""); +Expect(0, 6655, '\p{inbuginese}', ""); +Expect(1, 6655, '\p{^inbuginese}', ""); +Expect(1, 6655, '\P{inbuginese}', ""); +Expect(0, 6655, '\P{^inbuginese}', ""); +Expect(1, 6687, '\p{_In Buginese}', ""); +Expect(0, 6687, '\p{^_In Buginese}', ""); +Expect(0, 6687, '\P{_In Buginese}', ""); +Expect(1, 6687, '\P{^_In Buginese}', ""); +Expect(0, 6655, '\p{_In Buginese}', ""); +Expect(1, 6655, '\p{^_In Buginese}', ""); +Expect(1, 6655, '\P{_In Buginese}', ""); +Expect(0, 6655, '\P{^_In Buginese}', ""); +Error('\p{/a/- in-TAGBANWA}'); +Error('\P{/a/- in-TAGBANWA}'); +Expect(1, 6015, '\p{intagbanwa}', ""); +Expect(0, 6015, '\p{^intagbanwa}', ""); +Expect(0, 6015, '\P{intagbanwa}', ""); +Expect(1, 6015, '\P{^intagbanwa}', ""); +Expect(0, 5983, '\p{intagbanwa}', ""); +Expect(1, 5983, '\p{^intagbanwa}', ""); +Expect(1, 5983, '\P{intagbanwa}', ""); +Expect(0, 5983, '\P{^intagbanwa}', ""); +Expect(1, 6015, '\p{_IN-Tagbanwa}', ""); +Expect(0, 6015, '\p{^_IN-Tagbanwa}', ""); +Expect(0, 6015, '\P{_IN-Tagbanwa}', ""); +Expect(1, 6015, '\P{^_IN-Tagbanwa}', ""); +Expect(0, 5983, '\p{_IN-Tagbanwa}', ""); +Expect(1, 5983, '\p{^_IN-Tagbanwa}', ""); +Expect(1, 5983, '\P{_IN-Tagbanwa}', ""); +Expect(0, 5983, '\P{^_IN-Tagbanwa}', ""); +Error('\p{/a/ XID Start}'); +Error('\P{/a/ XID Start}'); +Expect(1, 90, '\p{xidstart}', ""); +Expect(0, 90, '\p{^xidstart}', ""); +Expect(0, 90, '\P{xidstart}', ""); +Expect(1, 90, '\P{^xidstart}', ""); +Expect(0, 64, '\p{xidstart}', ""); +Expect(1, 64, '\p{^xidstart}', ""); +Expect(1, 64, '\P{xidstart}', ""); +Expect(0, 64, '\P{^xidstart}', ""); +Expect(1, 90, '\p{_xid-Start}', ""); +Expect(0, 90, '\p{^_xid-Start}', ""); +Expect(0, 90, '\P{_xid-Start}', ""); +Expect(1, 90, '\P{^_xid-Start}', ""); +Expect(0, 64, '\p{_xid-Start}', ""); +Expect(1, 64, '\p{^_xid-Start}', ""); +Expect(1, 64, '\P{_xid-Start}', ""); +Expect(0, 64, '\P{^_xid-Start}', ""); +Error('\p{:=_ IS XID Start}'); +Error('\P{:=_ IS XID Start}'); +Expect(1, 90, '\p{isxidstart}', ""); +Expect(0, 90, '\p{^isxidstart}', ""); +Expect(0, 90, '\P{isxidstart}', ""); +Expect(1, 90, '\P{^isxidstart}', ""); +Expect(0, 64, '\p{isxidstart}', ""); +Expect(1, 64, '\p{^isxidstart}', ""); +Expect(1, 64, '\P{isxidstart}', ""); +Expect(0, 64, '\P{^isxidstart}', ""); +Expect(1, 90, '\p{ _Is-XIDStart}', ""); +Expect(0, 90, '\p{^ _Is-XIDStart}', ""); +Expect(0, 90, '\P{ _Is-XIDStart}', ""); +Expect(1, 90, '\P{^ _Is-XIDStart}', ""); +Expect(0, 64, '\p{ _Is-XIDStart}', ""); +Expect(1, 64, '\p{^ _Is-XIDStart}', ""); +Expect(1, 64, '\P{ _Is-XIDStart}', ""); +Expect(0, 64, '\P{^ _Is-XIDStart}', ""); +Error('\p{ XIDS:=}'); +Error('\P{ XIDS:=}'); +Expect(1, 90, '\p{xids}', ""); +Expect(0, 90, '\p{^xids}', ""); +Expect(0, 90, '\P{xids}', ""); +Expect(1, 90, '\P{^xids}', ""); +Expect(0, 64, '\p{xids}', ""); +Expect(1, 64, '\p{^xids}', ""); +Expect(1, 64, '\P{xids}', ""); +Expect(0, 64, '\P{^xids}', ""); +Expect(1, 90, '\p{_XIDS}', ""); +Expect(0, 90, '\p{^_XIDS}', ""); +Expect(0, 90, '\P{_XIDS}', ""); +Expect(1, 90, '\P{^_XIDS}', ""); +Expect(0, 64, '\p{_XIDS}', ""); +Expect(1, 64, '\p{^_XIDS}', ""); +Expect(1, 64, '\P{_XIDS}', ""); +Expect(0, 64, '\P{^_XIDS}', ""); +Error('\p{-:=is XIDS}'); +Error('\P{-:=is XIDS}'); +Expect(1, 90, '\p{isxids}', ""); +Expect(0, 90, '\p{^isxids}', ""); +Expect(0, 90, '\P{isxids}', ""); +Expect(1, 90, '\P{^isxids}', ""); +Expect(0, 64, '\p{isxids}', ""); +Expect(1, 64, '\p{^isxids}', ""); +Expect(1, 64, '\P{isxids}', ""); +Expect(0, 64, '\P{^isxids}', ""); +Expect(1, 90, '\p{_ IS XIDS}', ""); +Expect(0, 90, '\p{^_ IS XIDS}', ""); +Expect(0, 90, '\P{_ IS XIDS}', ""); +Expect(1, 90, '\P{^_ IS XIDS}', ""); +Expect(0, 64, '\p{_ IS XIDS}', ""); +Expect(1, 64, '\p{^_ IS XIDS}', ""); +Expect(1, 64, '\P{_ IS XIDS}', ""); +Expect(0, 64, '\P{^_ IS XIDS}', ""); +Error('\p{/a/- graph}'); +Error('\P{/a/- graph}'); +Expect(1, 126, '\p{graph}', ""); +Expect(0, 126, '\p{^graph}', ""); +Expect(0, 126, '\P{graph}', ""); +Expect(1, 126, '\P{^graph}', ""); +Expect(0, 32, '\p{graph}', ""); +Expect(1, 32, '\p{^graph}', ""); +Expect(1, 32, '\P{graph}', ""); +Expect(0, 32, '\P{^graph}', ""); +Expect(1, 126, '\p{_-Graph}', ""); +Expect(0, 126, '\p{^_-Graph}', ""); +Expect(0, 126, '\P{_-Graph}', ""); +Expect(1, 126, '\P{^_-Graph}', ""); +Expect(0, 32, '\p{_-Graph}', ""); +Expect(1, 32, '\p{^_-Graph}', ""); +Expect(1, 32, '\P{_-Graph}', ""); +Expect(0, 32, '\P{^_-Graph}', ""); +Error('\p{-/a/Is Graph}'); +Error('\P{-/a/Is Graph}'); +Expect(1, 126, '\p{isgraph}', ""); +Expect(0, 126, '\p{^isgraph}', ""); +Expect(0, 126, '\P{isgraph}', ""); +Expect(1, 126, '\P{^isgraph}', ""); +Expect(0, 32, '\p{isgraph}', ""); +Expect(1, 32, '\p{^isgraph}', ""); +Expect(1, 32, '\P{isgraph}', ""); +Expect(0, 32, '\P{^isgraph}', ""); +Expect(1, 126, '\p{ is-graph}', ""); +Expect(0, 126, '\p{^ is-graph}', ""); +Expect(0, 126, '\P{ is-graph}', ""); +Expect(1, 126, '\P{^ is-graph}', ""); +Expect(0, 32, '\p{ is-graph}', ""); +Expect(1, 32, '\p{^ is-graph}', ""); +Expect(1, 32, '\P{ is-graph}', ""); +Expect(0, 32, '\P{^ is-graph}', ""); +Error('\p{ Phonetic/a/ExtensionsSupplement}'); +Error('\P{ Phonetic/a/ExtensionsSupplement}'); +Expect(1, 7615, '\p{phoneticextensionssupplement}', ""); +Expect(0, 7615, '\p{^phoneticextensionssupplement}', ""); +Expect(0, 7615, '\P{phoneticextensionssupplement}', ""); +Expect(1, 7615, '\P{^phoneticextensionssupplement}', ""); +Expect(0, 7551, '\p{phoneticextensionssupplement}', ""); +Expect(1, 7551, '\p{^phoneticextensionssupplement}', ""); +Expect(1, 7551, '\P{phoneticextensionssupplement}', ""); +Expect(0, 7551, '\P{^phoneticextensionssupplement}', ""); +Expect(1, 7615, '\p{ PhoneticExtensions-Supplement}', ""); +Expect(0, 7615, '\p{^ PhoneticExtensions-Supplement}', ""); +Expect(0, 7615, '\P{ PhoneticExtensions-Supplement}', ""); +Expect(1, 7615, '\P{^ PhoneticExtensions-Supplement}', ""); +Expect(0, 7551, '\p{ PhoneticExtensions-Supplement}', ""); +Expect(1, 7551, '\p{^ PhoneticExtensions-Supplement}', ""); +Expect(1, 7551, '\P{ PhoneticExtensions-Supplement}', ""); +Expect(0, 7551, '\P{^ PhoneticExtensions-Supplement}', ""); +Error('\p{Is/a/Phonetic-EXTENSIONS SUPPLEMENT}'); +Error('\P{Is/a/Phonetic-EXTENSIONS SUPPLEMENT}'); +Expect(1, 7615, '\p{isphoneticextensionssupplement}', ""); +Expect(0, 7615, '\p{^isphoneticextensionssupplement}', ""); +Expect(0, 7615, '\P{isphoneticextensionssupplement}', ""); +Expect(1, 7615, '\P{^isphoneticextensionssupplement}', ""); +Expect(0, 7551, '\p{isphoneticextensionssupplement}', ""); +Expect(1, 7551, '\p{^isphoneticextensionssupplement}', ""); +Expect(1, 7551, '\P{isphoneticextensionssupplement}', ""); +Expect(0, 7551, '\P{^isphoneticextensionssupplement}', ""); +Expect(1, 7615, '\p{ _isPhonetic EXTENSIONS_Supplement}', ""); +Expect(0, 7615, '\p{^ _isPhonetic EXTENSIONS_Supplement}', ""); +Expect(0, 7615, '\P{ _isPhonetic EXTENSIONS_Supplement}', ""); +Expect(1, 7615, '\P{^ _isPhonetic EXTENSIONS_Supplement}', ""); +Expect(0, 7551, '\p{ _isPhonetic EXTENSIONS_Supplement}', ""); +Expect(1, 7551, '\p{^ _isPhonetic EXTENSIONS_Supplement}', ""); +Expect(1, 7551, '\P{ _isPhonetic EXTENSIONS_Supplement}', ""); +Expect(0, 7551, '\P{^ _isPhonetic EXTENSIONS_Supplement}', ""); +Error('\p{_-In:=phonetic extensions_SUPPLEMENT}'); +Error('\P{_-In:=phonetic extensions_SUPPLEMENT}'); +Expect(1, 7615, '\p{inphoneticextensionssupplement}', ""); +Expect(0, 7615, '\p{^inphoneticextensionssupplement}', ""); +Expect(0, 7615, '\P{inphoneticextensionssupplement}', ""); +Expect(1, 7615, '\P{^inphoneticextensionssupplement}', ""); +Expect(0, 7551, '\p{inphoneticextensionssupplement}', ""); +Expect(1, 7551, '\p{^inphoneticextensionssupplement}', ""); +Expect(1, 7551, '\P{inphoneticextensionssupplement}', ""); +Expect(0, 7551, '\P{^inphoneticextensionssupplement}', ""); +Expect(1, 7615, '\p{ IN Phonetic Extensions Supplement}', ""); +Expect(0, 7615, '\p{^ IN Phonetic Extensions Supplement}', ""); +Expect(0, 7615, '\P{ IN Phonetic Extensions Supplement}', ""); +Expect(1, 7615, '\P{^ IN Phonetic Extensions Supplement}', ""); +Expect(0, 7551, '\p{ IN Phonetic Extensions Supplement}', ""); +Expect(1, 7551, '\p{^ IN Phonetic Extensions Supplement}', ""); +Expect(1, 7551, '\P{ IN Phonetic Extensions Supplement}', ""); +Expect(0, 7551, '\P{^ IN Phonetic Extensions Supplement}', ""); +Error('\p{ MODIFIER_Tone:=letters}'); +Error('\P{ MODIFIER_Tone:=letters}'); +Expect(1, 42783, '\p{modifiertoneletters}', ""); +Expect(0, 42783, '\p{^modifiertoneletters}', ""); +Expect(0, 42783, '\P{modifiertoneletters}', ""); +Expect(1, 42783, '\P{^modifiertoneletters}', ""); +Expect(0, 42751, '\p{modifiertoneletters}', ""); +Expect(1, 42751, '\p{^modifiertoneletters}', ""); +Expect(1, 42751, '\P{modifiertoneletters}', ""); +Expect(0, 42751, '\P{^modifiertoneletters}', ""); +Expect(1, 42783, '\p{ Modifier Tone-letters}', ""); +Expect(0, 42783, '\p{^ Modifier Tone-letters}', ""); +Expect(0, 42783, '\P{ Modifier Tone-letters}', ""); +Expect(1, 42783, '\P{^ Modifier Tone-letters}', ""); +Expect(0, 42751, '\p{ Modifier Tone-letters}', ""); +Expect(1, 42751, '\p{^ Modifier Tone-letters}', ""); +Expect(1, 42751, '\P{ Modifier Tone-letters}', ""); +Expect(0, 42751, '\P{^ Modifier Tone-letters}', ""); +Error('\p{_/a/ismodifier Tone_Letters}'); +Error('\P{_/a/ismodifier Tone_Letters}'); +Expect(1, 42783, '\p{ismodifiertoneletters}', ""); +Expect(0, 42783, '\p{^ismodifiertoneletters}', ""); +Expect(0, 42783, '\P{ismodifiertoneletters}', ""); +Expect(1, 42783, '\P{^ismodifiertoneletters}', ""); +Expect(0, 42751, '\p{ismodifiertoneletters}', ""); +Expect(1, 42751, '\p{^ismodifiertoneletters}', ""); +Expect(1, 42751, '\P{ismodifiertoneletters}', ""); +Expect(0, 42751, '\P{^ismodifiertoneletters}', ""); +Expect(1, 42783, '\p{ IsModifier tone Letters}', ""); +Expect(0, 42783, '\p{^ IsModifier tone Letters}', ""); +Expect(0, 42783, '\P{ IsModifier tone Letters}', ""); +Expect(1, 42783, '\P{^ IsModifier tone Letters}', ""); +Expect(0, 42751, '\p{ IsModifier tone Letters}', ""); +Expect(1, 42751, '\p{^ IsModifier tone Letters}', ""); +Expect(1, 42751, '\P{ IsModifier tone Letters}', ""); +Expect(0, 42751, '\P{^ IsModifier tone Letters}', ""); +Error('\p{ In/a/Modifier-Tone Letters}'); +Error('\P{ In/a/Modifier-Tone Letters}'); +Expect(1, 42783, '\p{inmodifiertoneletters}', ""); +Expect(0, 42783, '\p{^inmodifiertoneletters}', ""); +Expect(0, 42783, '\P{inmodifiertoneletters}', ""); +Expect(1, 42783, '\P{^inmodifiertoneletters}', ""); +Expect(0, 42751, '\p{inmodifiertoneletters}', ""); +Expect(1, 42751, '\p{^inmodifiertoneletters}', ""); +Expect(1, 42751, '\P{inmodifiertoneletters}', ""); +Expect(0, 42751, '\P{^inmodifiertoneletters}', ""); +Expect(1, 42783, '\p{ IN_modifier-TONE-Letters}', ""); +Expect(0, 42783, '\p{^ IN_modifier-TONE-Letters}', ""); +Expect(0, 42783, '\P{ IN_modifier-TONE-Letters}', ""); +Expect(1, 42783, '\P{^ IN_modifier-TONE-Letters}', ""); +Expect(0, 42751, '\p{ IN_modifier-TONE-Letters}', ""); +Expect(1, 42751, '\p{^ IN_modifier-TONE-Letters}', ""); +Expect(1, 42751, '\P{ IN_modifier-TONE-Letters}', ""); +Expect(0, 42751, '\P{^ IN_modifier-TONE-Letters}', ""); +Error('\p{_ private:=Use_area}'); +Error('\P{_ private:=Use_area}'); +Expect(1, 63743, '\p{privateusearea}', ""); +Expect(0, 63743, '\p{^privateusearea}', ""); +Expect(0, 63743, '\P{privateusearea}', ""); +Expect(1, 63743, '\P{^privateusearea}', ""); +Expect(0, 7, '\p{privateusearea}', ""); +Expect(1, 7, '\p{^privateusearea}', ""); +Expect(1, 7, '\P{privateusearea}', ""); +Expect(0, 7, '\P{^privateusearea}', ""); +Expect(1, 63743, '\p{ _Private USE AREA}', ""); +Expect(0, 63743, '\p{^ _Private USE AREA}', ""); +Expect(0, 63743, '\P{ _Private USE AREA}', ""); +Expect(1, 63743, '\P{^ _Private USE AREA}', ""); +Expect(0, 7, '\p{ _Private USE AREA}', ""); +Expect(1, 7, '\p{^ _Private USE AREA}', ""); +Expect(1, 7, '\P{ _Private USE AREA}', ""); +Expect(0, 7, '\P{^ _Private USE AREA}', ""); +Error('\p{ -Is:=PrivateUse AREA}'); +Error('\P{ -Is:=PrivateUse AREA}'); +Expect(1, 63743, '\p{isprivateusearea}', ""); +Expect(0, 63743, '\p{^isprivateusearea}', ""); +Expect(0, 63743, '\P{isprivateusearea}', ""); +Expect(1, 63743, '\P{^isprivateusearea}', ""); +Expect(0, 7, '\p{isprivateusearea}', ""); +Expect(1, 7, '\p{^isprivateusearea}', ""); +Expect(1, 7, '\P{isprivateusearea}', ""); +Expect(0, 7, '\P{^isprivateusearea}', ""); +Expect(1, 63743, '\p{ Is PRIVATE Use Area}', ""); +Expect(0, 63743, '\p{^ Is PRIVATE Use Area}', ""); +Expect(0, 63743, '\P{ Is PRIVATE Use Area}', ""); +Expect(1, 63743, '\P{^ Is PRIVATE Use Area}', ""); +Expect(0, 7, '\p{ Is PRIVATE Use Area}', ""); +Expect(1, 7, '\p{^ Is PRIVATE Use Area}', ""); +Expect(1, 7, '\P{ Is PRIVATE Use Area}', ""); +Expect(0, 7, '\P{^ Is PRIVATE Use Area}', ""); +Error('\p{_ In/a/private USE Area}'); +Error('\P{_ In/a/private USE Area}'); +Expect(1, 63743, '\p{inprivateusearea}', ""); +Expect(0, 63743, '\p{^inprivateusearea}', ""); +Expect(0, 63743, '\P{inprivateusearea}', ""); +Expect(1, 63743, '\P{^inprivateusearea}', ""); +Expect(0, 7, '\p{inprivateusearea}', ""); +Expect(1, 7, '\p{^inprivateusearea}', ""); +Expect(1, 7, '\P{inprivateusearea}', ""); +Expect(0, 7, '\P{^inprivateusearea}', ""); +Expect(1, 63743, '\p{__INPRIVATE_use area}', ""); +Expect(0, 63743, '\p{^__INPRIVATE_use area}', ""); +Expect(0, 63743, '\P{__INPRIVATE_use area}', ""); +Expect(1, 63743, '\P{^__INPRIVATE_use area}', ""); +Expect(0, 7, '\p{__INPRIVATE_use area}', ""); +Expect(1, 7, '\p{^__INPRIVATE_use area}', ""); +Expect(1, 7, '\P{__INPRIVATE_use area}', ""); +Expect(0, 7, '\P{^__INPRIVATE_use area}', ""); +Error('\p{ _in:=Privateuse}'); +Error('\P{ _in:=Privateuse}'); +Expect(1, 63743, '\p{inprivateuse}', ""); +Expect(0, 63743, '\p{^inprivateuse}', ""); +Expect(0, 63743, '\P{inprivateuse}', ""); +Expect(1, 63743, '\P{^inprivateuse}', ""); +Expect(0, 7, '\p{inprivateuse}', ""); +Expect(1, 7, '\p{^inprivateuse}', ""); +Expect(1, 7, '\P{inprivateuse}', ""); +Expect(0, 7, '\P{^inprivateuse}', ""); +Expect(1, 63743, '\p{_-in Private use}', ""); +Expect(0, 63743, '\p{^_-in Private use}', ""); +Expect(0, 63743, '\P{_-in Private use}', ""); +Expect(1, 63743, '\P{^_-in Private use}', ""); +Expect(0, 7, '\p{_-in Private use}', ""); +Expect(1, 7, '\p{^_-in Private use}', ""); +Expect(1, 7, '\P{_-in Private use}', ""); +Expect(0, 7, '\P{^_-in Private use}', ""); +Error('\p{--Lycian:=}'); +Error('\P{--Lycian:=}'); +Expect(1, 66204, '\p{lycian}', ""); +Expect(0, 66204, '\p{^lycian}', ""); +Expect(0, 66204, '\P{lycian}', ""); +Expect(1, 66204, '\P{^lycian}', ""); +Expect(0, 66175, '\p{lycian}', ""); +Expect(1, 66175, '\p{^lycian}', ""); +Expect(1, 66175, '\P{lycian}', ""); +Expect(0, 66175, '\P{^lycian}', ""); +Expect(1, 66204, '\p{ Lycian}', ""); +Expect(0, 66204, '\p{^ Lycian}', ""); +Expect(0, 66204, '\P{ Lycian}', ""); +Expect(1, 66204, '\P{^ Lycian}', ""); +Expect(0, 66175, '\p{ Lycian}', ""); +Expect(1, 66175, '\p{^ Lycian}', ""); +Expect(1, 66175, '\P{ Lycian}', ""); +Expect(0, 66175, '\P{^ Lycian}', ""); +Error('\p{:=__is-Lycian}'); +Error('\P{:=__is-Lycian}'); +Expect(1, 66204, '\p{islycian}', ""); +Expect(0, 66204, '\p{^islycian}', ""); +Expect(0, 66204, '\P{islycian}', ""); +Expect(1, 66204, '\P{^islycian}', ""); +Expect(0, 66175, '\p{islycian}', ""); +Expect(1, 66175, '\p{^islycian}', ""); +Expect(1, 66175, '\P{islycian}', ""); +Expect(0, 66175, '\P{^islycian}', ""); +Expect(1, 66204, '\p{ is lycian}', ""); +Expect(0, 66204, '\p{^ is lycian}', ""); +Expect(0, 66204, '\P{ is lycian}', ""); +Expect(1, 66204, '\P{^ is lycian}', ""); +Expect(0, 66175, '\p{ is lycian}', ""); +Expect(1, 66175, '\p{^ is lycian}', ""); +Expect(1, 66175, '\P{ is lycian}', ""); +Expect(0, 66175, '\P{^ is lycian}', ""); +Error('\p{ /a/LYCI}'); +Error('\P{ /a/LYCI}'); +Expect(1, 66204, '\p{lyci}', ""); +Expect(0, 66204, '\p{^lyci}', ""); +Expect(0, 66204, '\P{lyci}', ""); +Expect(1, 66204, '\P{^lyci}', ""); +Expect(0, 66175, '\p{lyci}', ""); +Expect(1, 66175, '\p{^lyci}', ""); +Expect(1, 66175, '\P{lyci}', ""); +Expect(0, 66175, '\P{^lyci}', ""); +Expect(1, 66204, '\p{ lyci}', ""); +Expect(0, 66204, '\p{^ lyci}', ""); +Expect(0, 66204, '\P{ lyci}', ""); +Expect(1, 66204, '\P{^ lyci}', ""); +Expect(0, 66175, '\p{ lyci}', ""); +Expect(1, 66175, '\p{^ lyci}', ""); +Expect(1, 66175, '\P{ lyci}', ""); +Expect(0, 66175, '\P{^ lyci}', ""); +Error('\p{/a/_ IS_LYCI}'); +Error('\P{/a/_ IS_LYCI}'); +Expect(1, 66204, '\p{islyci}', ""); +Expect(0, 66204, '\p{^islyci}', ""); +Expect(0, 66204, '\P{islyci}', ""); +Expect(1, 66204, '\P{^islyci}', ""); +Expect(0, 66175, '\p{islyci}', ""); +Expect(1, 66175, '\p{^islyci}', ""); +Expect(1, 66175, '\P{islyci}', ""); +Expect(0, 66175, '\P{^islyci}', ""); +Expect(1, 66204, '\p{IS LYCI}', ""); +Expect(0, 66204, '\p{^IS LYCI}', ""); +Expect(0, 66204, '\P{IS LYCI}', ""); +Expect(1, 66204, '\P{^IS LYCI}', ""); +Expect(0, 66175, '\p{IS LYCI}', ""); +Expect(1, 66175, '\p{^IS LYCI}', ""); +Expect(1, 66175, '\P{IS LYCI}', ""); +Expect(0, 66175, '\P{^IS LYCI}', ""); +Error('\p{:=-_Number}'); +Error('\P{:=-_Number}'); +Expect(1, 57, '\p{number}', ""); +Expect(0, 57, '\p{^number}', ""); +Expect(0, 57, '\P{number}', ""); +Expect(1, 57, '\P{^number}', ""); +Expect(0, 47, '\p{number}', ""); +Expect(1, 47, '\p{^number}', ""); +Expect(1, 47, '\P{number}', ""); +Expect(0, 47, '\P{^number}', ""); +Expect(1, 57, '\p{Number}', ""); +Expect(0, 57, '\p{^Number}', ""); +Expect(0, 57, '\P{Number}', ""); +Expect(1, 57, '\P{^Number}', ""); +Expect(0, 47, '\p{Number}', ""); +Expect(1, 47, '\p{^Number}', ""); +Expect(1, 47, '\P{Number}', ""); +Expect(0, 47, '\P{^Number}', ""); +Error('\p{ _Is:=NUMBER}'); +Error('\P{ _Is:=NUMBER}'); +Expect(1, 57, '\p{isnumber}', ""); +Expect(0, 57, '\p{^isnumber}', ""); +Expect(0, 57, '\P{isnumber}', ""); +Expect(1, 57, '\P{^isnumber}', ""); +Expect(0, 47, '\p{isnumber}', ""); +Expect(1, 47, '\p{^isnumber}', ""); +Expect(1, 47, '\P{isnumber}', ""); +Expect(0, 47, '\P{^isnumber}', ""); +Expect(1, 57, '\p{ is-Number}', ""); +Expect(0, 57, '\p{^ is-Number}', ""); +Expect(0, 57, '\P{ is-Number}', ""); +Expect(1, 57, '\P{^ is-Number}', ""); +Expect(0, 47, '\p{ is-Number}', ""); +Expect(1, 47, '\p{^ is-Number}', ""); +Expect(1, 47, '\P{ is-Number}', ""); +Expect(0, 47, '\P{^ is-Number}', ""); +Error('\p{:= _N}'); +Error('\P{:= _N}'); +Expect(1, 57, '\p{n}', ""); +Expect(0, 57, '\p{^n}', ""); +Expect(0, 57, '\P{n}', ""); +Expect(1, 57, '\P{^n}', ""); +Expect(0, 47, '\p{n}', ""); +Expect(1, 47, '\p{^n}', ""); +Expect(1, 47, '\P{n}', ""); +Expect(0, 47, '\P{^n}', ""); +Expect(1, 57, '\p{-N}', ""); +Expect(0, 57, '\p{^-N}', ""); +Expect(0, 57, '\P{-N}', ""); +Expect(1, 57, '\P{^-N}', ""); +Expect(0, 47, '\p{-N}', ""); +Expect(1, 47, '\p{^-N}', ""); +Expect(1, 47, '\P{-N}', ""); +Expect(0, 47, '\P{^-N}', ""); +Error('\p{:=_ IS-N}'); +Error('\P{:=_ IS-N}'); +Expect(1, 57, '\p{isn}', ""); +Expect(0, 57, '\p{^isn}', ""); +Expect(0, 57, '\P{isn}', ""); +Expect(1, 57, '\P{^isn}', ""); +Expect(0, 47, '\p{isn}', ""); +Expect(1, 47, '\p{^isn}', ""); +Expect(1, 47, '\P{isn}', ""); +Expect(0, 47, '\P{^isn}', ""); +Expect(1, 57, '\p{-ISN}', ""); +Expect(0, 57, '\p{^-ISN}', ""); +Expect(0, 57, '\P{-ISN}', ""); +Expect(1, 57, '\P{^-ISN}', ""); +Expect(0, 47, '\p{-ISN}', ""); +Expect(1, 47, '\p{^-ISN}', ""); +Expect(1, 47, '\P{-ISN}', ""); +Expect(0, 47, '\P{^-ISN}', ""); +Error('\p{POSIXDIGIT:=}'); +Error('\P{POSIXDIGIT:=}'); +Expect(1, 57, '\p{posixdigit}', ""); +Expect(0, 57, '\p{^posixdigit}', ""); +Expect(0, 57, '\P{posixdigit}', ""); +Expect(1, 57, '\P{^posixdigit}', ""); +Expect(0, 47, '\p{posixdigit}', ""); +Expect(1, 47, '\p{^posixdigit}', ""); +Expect(1, 47, '\P{posixdigit}', ""); +Expect(0, 47, '\P{^posixdigit}', ""); +Expect(1, 57, '\p{- POSIXDIGIT}', ""); +Expect(0, 57, '\p{^- POSIXDIGIT}', ""); +Expect(0, 57, '\P{- POSIXDIGIT}', ""); +Expect(1, 57, '\P{^- POSIXDIGIT}', ""); +Expect(0, 47, '\p{- POSIXDIGIT}', ""); +Expect(1, 47, '\p{^- POSIXDIGIT}', ""); +Expect(1, 47, '\P{- POSIXDIGIT}', ""); +Expect(0, 47, '\P{^- POSIXDIGIT}', ""); +Error('\p{-:=Is posixdigit}'); +Error('\P{-:=Is posixdigit}'); +Expect(1, 57, '\p{isposixdigit}', ""); +Expect(0, 57, '\p{^isposixdigit}', ""); +Expect(0, 57, '\P{isposixdigit}', ""); +Expect(1, 57, '\P{^isposixdigit}', ""); +Expect(0, 47, '\p{isposixdigit}', ""); +Expect(1, 47, '\p{^isposixdigit}', ""); +Expect(1, 47, '\P{isposixdigit}', ""); +Expect(0, 47, '\P{^isposixdigit}', ""); +Expect(1, 57, '\p{ -isPOSIXDIGIT}', ""); +Expect(0, 57, '\p{^ -isPOSIXDIGIT}', ""); +Expect(0, 57, '\P{ -isPOSIXDIGIT}', ""); +Expect(1, 57, '\P{^ -isPOSIXDIGIT}', ""); +Expect(0, 47, '\p{ -isPOSIXDIGIT}', ""); +Expect(1, 47, '\p{^ -isPOSIXDIGIT}', ""); +Expect(1, 47, '\P{ -isPOSIXDIGIT}', ""); +Expect(0, 47, '\P{^ -isPOSIXDIGIT}', ""); +Error('\p{_-Georgian/a/}'); +Error('\P{_-Georgian/a/}'); +Expect(1, 4293, '\p{georgian}', ""); +Expect(0, 4293, '\p{^georgian}', ""); +Expect(0, 4293, '\P{georgian}', ""); +Expect(1, 4293, '\P{^georgian}', ""); +Expect(0, 4255, '\p{georgian}', ""); +Expect(1, 4255, '\p{^georgian}', ""); +Expect(1, 4255, '\P{georgian}', ""); +Expect(0, 4255, '\P{^georgian}', ""); +Expect(1, 4293, '\p{ -Georgian}', ""); +Expect(0, 4293, '\p{^ -Georgian}', ""); +Expect(0, 4293, '\P{ -Georgian}', ""); +Expect(1, 4293, '\P{^ -Georgian}', ""); +Expect(0, 4255, '\p{ -Georgian}', ""); +Expect(1, 4255, '\p{^ -Georgian}', ""); +Expect(1, 4255, '\P{ -Georgian}', ""); +Expect(0, 4255, '\P{^ -Georgian}', ""); +Error('\p{_/a/is-georgian}'); +Error('\P{_/a/is-georgian}'); +Expect(1, 4293, '\p{isgeorgian}', ""); +Expect(0, 4293, '\p{^isgeorgian}', ""); +Expect(0, 4293, '\P{isgeorgian}', ""); +Expect(1, 4293, '\P{^isgeorgian}', ""); +Expect(0, 4255, '\p{isgeorgian}', ""); +Expect(1, 4255, '\p{^isgeorgian}', ""); +Expect(1, 4255, '\P{isgeorgian}', ""); +Expect(0, 4255, '\P{^isgeorgian}', ""); +Expect(1, 4293, '\p{- Is Georgian}', ""); +Expect(0, 4293, '\p{^- Is Georgian}', ""); +Expect(0, 4293, '\P{- Is Georgian}', ""); +Expect(1, 4293, '\P{^- Is Georgian}', ""); +Expect(0, 4255, '\p{- Is Georgian}', ""); +Expect(1, 4255, '\p{^- Is Georgian}', ""); +Expect(1, 4255, '\P{- Is Georgian}', ""); +Expect(0, 4255, '\P{^- Is Georgian}', ""); +Error('\p{:=__geor}'); +Error('\P{:=__geor}'); +Expect(1, 4293, '\p{geor}', ""); +Expect(0, 4293, '\p{^geor}', ""); +Expect(0, 4293, '\P{geor}', ""); +Expect(1, 4293, '\P{^geor}', ""); +Expect(0, 4255, '\p{geor}', ""); +Expect(1, 4255, '\p{^geor}', ""); +Expect(1, 4255, '\P{geor}', ""); +Expect(0, 4255, '\P{^geor}', ""); +Expect(1, 4293, '\p{- geor}', ""); +Expect(0, 4293, '\p{^- geor}', ""); +Expect(0, 4293, '\P{- geor}', ""); +Expect(1, 4293, '\P{^- geor}', ""); +Expect(0, 4255, '\p{- geor}', ""); +Expect(1, 4255, '\p{^- geor}', ""); +Expect(1, 4255, '\P{- geor}', ""); +Expect(0, 4255, '\P{^- geor}', ""); +Error('\p{ Is/a/Geor}'); +Error('\P{ Is/a/Geor}'); +Expect(1, 4293, '\p{isgeor}', ""); +Expect(0, 4293, '\p{^isgeor}', ""); +Expect(0, 4293, '\P{isgeor}', ""); +Expect(1, 4293, '\P{^isgeor}', ""); +Expect(0, 4255, '\p{isgeor}', ""); +Expect(1, 4255, '\p{^isgeor}', ""); +Expect(1, 4255, '\P{isgeor}', ""); +Expect(0, 4255, '\P{^isgeor}', ""); +Expect(1, 4293, '\p{__isGeor}', ""); +Expect(0, 4293, '\p{^__isGeor}', ""); +Expect(0, 4293, '\P{__isGeor}', ""); +Expect(1, 4293, '\P{^__isGeor}', ""); +Expect(0, 4255, '\p{__isGeor}', ""); +Expect(1, 4255, '\p{^__isGeor}', ""); +Expect(1, 4255, '\P{__isGeor}', ""); +Expect(0, 4255, '\P{^__isGeor}', ""); +Error('\p{ /a/noBlock}'); +Error('\P{ /a/noBlock}'); +Expect(1, 2303, '\p{noblock}', ""); +Expect(0, 2303, '\p{^noblock}', ""); +Expect(0, 2303, '\P{noblock}', ""); +Expect(1, 2303, '\P{^noblock}', ""); +Expect(0, 2047, '\p{noblock}', ""); +Expect(1, 2047, '\p{^noblock}', ""); +Expect(1, 2047, '\P{noblock}', ""); +Expect(0, 2047, '\P{^noblock}', ""); +Expect(1, 2303, '\p{_-No Block}', ""); +Expect(0, 2303, '\p{^_-No Block}', ""); +Expect(0, 2303, '\P{_-No Block}', ""); +Expect(1, 2303, '\P{^_-No Block}', ""); +Expect(0, 2047, '\p{_-No Block}', ""); +Expect(1, 2047, '\p{^_-No Block}', ""); +Expect(1, 2047, '\P{_-No Block}', ""); +Expect(0, 2047, '\P{^_-No Block}', ""); +Error('\p{-Is-no:=Block}'); +Error('\P{-Is-no:=Block}'); +Expect(1, 2303, '\p{isnoblock}', ""); +Expect(0, 2303, '\p{^isnoblock}', ""); +Expect(0, 2303, '\P{isnoblock}', ""); +Expect(1, 2303, '\P{^isnoblock}', ""); +Expect(0, 2047, '\p{isnoblock}', ""); +Expect(1, 2047, '\p{^isnoblock}', ""); +Expect(1, 2047, '\P{isnoblock}', ""); +Expect(0, 2047, '\P{^isnoblock}', ""); +Expect(1, 2303, '\p{_ IsNo-Block}', ""); +Expect(0, 2303, '\p{^_ IsNo-Block}', ""); +Expect(0, 2303, '\P{_ IsNo-Block}', ""); +Expect(1, 2303, '\P{^_ IsNo-Block}', ""); +Expect(0, 2047, '\p{_ IsNo-Block}', ""); +Expect(1, 2047, '\p{^_ IsNo-Block}', ""); +Expect(1, 2047, '\P{_ IsNo-Block}', ""); +Expect(0, 2047, '\P{^_ IsNo-Block}', ""); +Error('\p{ -IN No:=Block}'); +Error('\P{ -IN No:=Block}'); +Expect(1, 2303, '\p{innoblock}', ""); +Expect(0, 2303, '\p{^innoblock}', ""); +Expect(0, 2303, '\P{innoblock}', ""); +Expect(1, 2303, '\P{^innoblock}', ""); +Expect(0, 2047, '\p{innoblock}', ""); +Expect(1, 2047, '\p{^innoblock}', ""); +Expect(1, 2047, '\P{innoblock}', ""); +Expect(0, 2047, '\P{^innoblock}', ""); +Expect(1, 2303, '\p{ In_NO Block}', ""); +Expect(0, 2303, '\p{^ In_NO Block}', ""); +Expect(0, 2303, '\P{ In_NO Block}', ""); +Expect(1, 2303, '\P{^ In_NO Block}', ""); +Expect(0, 2047, '\p{ In_NO Block}', ""); +Expect(1, 2047, '\p{^ In_NO Block}', ""); +Expect(1, 2047, '\P{ In_NO Block}', ""); +Expect(0, 2047, '\P{^ In_NO Block}', ""); +Error('\p{:=_-assigned}'); +Error('\P{:=_-assigned}'); +Expect(1, 887, '\p{assigned}', ""); +Expect(0, 887, '\p{^assigned}', ""); +Expect(0, 887, '\P{assigned}', ""); +Expect(1, 887, '\P{^assigned}', ""); +Expect(0, 889, '\p{assigned}', ""); +Expect(1, 889, '\p{^assigned}', ""); +Expect(1, 889, '\P{assigned}', ""); +Expect(0, 889, '\P{^assigned}', ""); +Expect(1, 887, '\p{_ Assigned}', ""); +Expect(0, 887, '\p{^_ Assigned}', ""); +Expect(0, 887, '\P{_ Assigned}', ""); +Expect(1, 887, '\P{^_ Assigned}', ""); +Expect(0, 889, '\p{_ Assigned}', ""); +Expect(1, 889, '\p{^_ Assigned}', ""); +Expect(1, 889, '\P{_ Assigned}', ""); +Expect(0, 889, '\P{^_ Assigned}', ""); +Error('\p{-Is/a/Assigned}'); +Error('\P{-Is/a/Assigned}'); +Expect(1, 887, '\p{isassigned}', ""); +Expect(0, 887, '\p{^isassigned}', ""); +Expect(0, 887, '\P{isassigned}', ""); +Expect(1, 887, '\P{^isassigned}', ""); +Expect(0, 889, '\p{isassigned}', ""); +Expect(1, 889, '\p{^isassigned}', ""); +Expect(1, 889, '\P{isassigned}', ""); +Expect(0, 889, '\P{^isassigned}', ""); +Expect(1, 887, '\p{ -IS Assigned}', ""); +Expect(0, 887, '\p{^ -IS Assigned}', ""); +Expect(0, 887, '\P{ -IS Assigned}', ""); +Expect(1, 887, '\P{^ -IS Assigned}', ""); +Expect(0, 889, '\p{ -IS Assigned}', ""); +Expect(1, 889, '\p{^ -IS Assigned}', ""); +Expect(1, 889, '\P{ -IS Assigned}', ""); +Expect(0, 889, '\P{^ -IS Assigned}', ""); +Error('\p{ /a/vertical_Forms}'); +Error('\P{ /a/vertical_Forms}'); +Expect(1, 65055, '\p{verticalforms}', ""); +Expect(0, 65055, '\p{^verticalforms}', ""); +Expect(0, 65055, '\P{verticalforms}', ""); +Expect(1, 65055, '\P{^verticalforms}', ""); +Expect(0, 65039, '\p{verticalforms}', ""); +Expect(1, 65039, '\p{^verticalforms}', ""); +Expect(1, 65039, '\P{verticalforms}', ""); +Expect(0, 65039, '\P{^verticalforms}', ""); +Expect(1, 65055, '\p{ -VERTICAL-forms}', ""); +Expect(0, 65055, '\p{^ -VERTICAL-forms}', ""); +Expect(0, 65055, '\P{ -VERTICAL-forms}', ""); +Expect(1, 65055, '\P{^ -VERTICAL-forms}', ""); +Expect(0, 65039, '\p{ -VERTICAL-forms}', ""); +Expect(1, 65039, '\p{^ -VERTICAL-forms}', ""); +Expect(1, 65039, '\P{ -VERTICAL-forms}', ""); +Expect(0, 65039, '\P{^ -VERTICAL-forms}', ""); +Error('\p{ /a/is-VERTICAL FORMS}'); +Error('\P{ /a/is-VERTICAL FORMS}'); +Expect(1, 65055, '\p{isverticalforms}', ""); +Expect(0, 65055, '\p{^isverticalforms}', ""); +Expect(0, 65055, '\P{isverticalforms}', ""); +Expect(1, 65055, '\P{^isverticalforms}', ""); +Expect(0, 65039, '\p{isverticalforms}', ""); +Expect(1, 65039, '\p{^isverticalforms}', ""); +Expect(1, 65039, '\P{isverticalforms}', ""); +Expect(0, 65039, '\P{^isverticalforms}', ""); +Expect(1, 65055, '\p{ IsVertical_Forms}', ""); +Expect(0, 65055, '\p{^ IsVertical_Forms}', ""); +Expect(0, 65055, '\P{ IsVertical_Forms}', ""); +Expect(1, 65055, '\P{^ IsVertical_Forms}', ""); +Expect(0, 65039, '\p{ IsVertical_Forms}', ""); +Expect(1, 65039, '\p{^ IsVertical_Forms}', ""); +Expect(1, 65039, '\P{ IsVertical_Forms}', ""); +Expect(0, 65039, '\P{^ IsVertical_Forms}', ""); +Error('\p{ :=IN vertical FORMS}'); +Error('\P{ :=IN vertical FORMS}'); +Expect(1, 65055, '\p{inverticalforms}', ""); +Expect(0, 65055, '\p{^inverticalforms}', ""); +Expect(0, 65055, '\P{inverticalforms}', ""); +Expect(1, 65055, '\P{^inverticalforms}', ""); +Expect(0, 65039, '\p{inverticalforms}', ""); +Expect(1, 65039, '\p{^inverticalforms}', ""); +Expect(1, 65039, '\P{inverticalforms}', ""); +Expect(0, 65039, '\P{^inverticalforms}', ""); +Expect(1, 65055, '\p{_ In Vertical Forms}', ""); +Expect(0, 65055, '\p{^_ In Vertical Forms}', ""); +Expect(0, 65055, '\P{_ In Vertical Forms}', ""); +Expect(1, 65055, '\P{^_ In Vertical Forms}', ""); +Expect(0, 65039, '\p{_ In Vertical Forms}', ""); +Expect(1, 65039, '\p{^_ In Vertical Forms}', ""); +Expect(1, 65039, '\P{_ In Vertical Forms}', ""); +Expect(0, 65039, '\P{^_ In Vertical Forms}', ""); +Error('\p{_ CJK Compatibility:=}'); +Error('\P{_ CJK Compatibility:=}'); +Expect(1, 13311, '\p{cjkcompatibility}', ""); +Expect(0, 13311, '\p{^cjkcompatibility}', ""); +Expect(0, 13311, '\P{cjkcompatibility}', ""); +Expect(1, 13311, '\P{^cjkcompatibility}', ""); +Expect(0, 13055, '\p{cjkcompatibility}', ""); +Expect(1, 13055, '\p{^cjkcompatibility}', ""); +Expect(1, 13055, '\P{cjkcompatibility}', ""); +Expect(0, 13055, '\P{^cjkcompatibility}', ""); +Expect(1, 13311, '\p{ -CJK Compatibility}', ""); +Expect(0, 13311, '\p{^ -CJK Compatibility}', ""); +Expect(0, 13311, '\P{ -CJK Compatibility}', ""); +Expect(1, 13311, '\P{^ -CJK Compatibility}', ""); +Expect(0, 13055, '\p{ -CJK Compatibility}', ""); +Expect(1, 13055, '\p{^ -CJK Compatibility}', ""); +Expect(1, 13055, '\P{ -CJK Compatibility}', ""); +Expect(0, 13055, '\P{^ -CJK Compatibility}', ""); +Error('\p{/a/IS CJK Compatibility}'); +Error('\P{/a/IS CJK Compatibility}'); +Expect(1, 13311, '\p{iscjkcompatibility}', ""); +Expect(0, 13311, '\p{^iscjkcompatibility}', ""); +Expect(0, 13311, '\P{iscjkcompatibility}', ""); +Expect(1, 13311, '\P{^iscjkcompatibility}', ""); +Expect(0, 13055, '\p{iscjkcompatibility}', ""); +Expect(1, 13055, '\p{^iscjkcompatibility}', ""); +Expect(1, 13055, '\P{iscjkcompatibility}', ""); +Expect(0, 13055, '\P{^iscjkcompatibility}', ""); +Expect(1, 13311, '\p{_ IScjkCompatibility}', ""); +Expect(0, 13311, '\p{^_ IScjkCompatibility}', ""); +Expect(0, 13311, '\P{_ IScjkCompatibility}', ""); +Expect(1, 13311, '\P{^_ IScjkCompatibility}', ""); +Expect(0, 13055, '\p{_ IScjkCompatibility}', ""); +Expect(1, 13055, '\p{^_ IScjkCompatibility}', ""); +Expect(1, 13055, '\P{_ IScjkCompatibility}', ""); +Expect(0, 13055, '\P{^_ IScjkCompatibility}', ""); +Error('\p{/a/_In-CJKCompatibility}'); +Error('\P{/a/_In-CJKCompatibility}'); +Expect(1, 13311, '\p{incjkcompatibility}', ""); +Expect(0, 13311, '\p{^incjkcompatibility}', ""); +Expect(0, 13311, '\P{incjkcompatibility}', ""); +Expect(1, 13311, '\P{^incjkcompatibility}', ""); +Expect(0, 13055, '\p{incjkcompatibility}', ""); +Expect(1, 13055, '\p{^incjkcompatibility}', ""); +Expect(1, 13055, '\P{incjkcompatibility}', ""); +Expect(0, 13055, '\P{^incjkcompatibility}', ""); +Expect(1, 13311, '\p{ In CJK Compatibility}', ""); +Expect(0, 13311, '\p{^ In CJK Compatibility}', ""); +Expect(0, 13311, '\P{ In CJK Compatibility}', ""); +Expect(1, 13311, '\P{^ In CJK Compatibility}', ""); +Expect(0, 13055, '\p{ In CJK Compatibility}', ""); +Expect(1, 13055, '\p{^ In CJK Compatibility}', ""); +Expect(1, 13055, '\P{ In CJK Compatibility}', ""); +Expect(0, 13055, '\P{^ In CJK Compatibility}', ""); +Error('\p{_ cjk/a/UNIFIED-Ideographs-extension_A}'); +Error('\P{_ cjk/a/UNIFIED-Ideographs-extension_A}'); +Expect(1, 19903, '\p{cjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\p{^cjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\P{cjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\P{^cjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\p{cjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\p{^cjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\P{cjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\P{^cjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\p{ cjk unified Ideographs_Extension_A}', ""); +Expect(0, 19903, '\p{^ cjk unified Ideographs_Extension_A}', ""); +Expect(0, 19903, '\P{ cjk unified Ideographs_Extension_A}', ""); +Expect(1, 19903, '\P{^ cjk unified Ideographs_Extension_A}', ""); +Expect(0, 13311, '\p{ cjk unified Ideographs_Extension_A}', ""); +Expect(1, 13311, '\p{^ cjk unified Ideographs_Extension_A}', ""); +Expect(1, 13311, '\P{ cjk unified Ideographs_Extension_A}', ""); +Expect(0, 13311, '\P{^ cjk unified Ideographs_Extension_A}', ""); +Error('\p{-:=IS CJK_Unified-Ideographs_EXTENSION A}'); +Error('\P{-:=IS CJK_Unified-Ideographs_EXTENSION A}'); +Expect(1, 19903, '\p{iscjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\p{^iscjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\P{iscjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\P{^iscjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\p{iscjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\p{^iscjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\P{iscjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\P{^iscjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\p{-IS_CJK-UNIFIEDideographs EXTENSION_A}', ""); +Expect(0, 19903, '\p{^-IS_CJK-UNIFIEDideographs EXTENSION_A}', ""); +Expect(0, 19903, '\P{-IS_CJK-UNIFIEDideographs EXTENSION_A}', ""); +Expect(1, 19903, '\P{^-IS_CJK-UNIFIEDideographs EXTENSION_A}', ""); +Expect(0, 13311, '\p{-IS_CJK-UNIFIEDideographs EXTENSION_A}', ""); +Expect(1, 13311, '\p{^-IS_CJK-UNIFIEDideographs EXTENSION_A}', ""); +Expect(1, 13311, '\P{-IS_CJK-UNIFIEDideographs EXTENSION_A}', ""); +Expect(0, 13311, '\P{^-IS_CJK-UNIFIEDideographs EXTENSION_A}', ""); +Error('\p{ IN:=cjk Unified ideographs-extension-A}'); +Error('\P{ IN:=cjk Unified ideographs-extension-A}'); +Expect(1, 19903, '\p{incjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\p{^incjkunifiedideographsextensiona}', ""); +Expect(0, 19903, '\P{incjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\P{^incjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\p{incjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\p{^incjkunifiedideographsextensiona}', ""); +Expect(1, 13311, '\P{incjkunifiedideographsextensiona}', ""); +Expect(0, 13311, '\P{^incjkunifiedideographsextensiona}', ""); +Expect(1, 19903, '\p{- in CJK UnifiedIdeographsEXTENSION A}', ""); +Expect(0, 19903, '\p{^- in CJK UnifiedIdeographsEXTENSION A}', ""); +Expect(0, 19903, '\P{- in CJK UnifiedIdeographsEXTENSION A}', ""); +Expect(1, 19903, '\P{^- in CJK UnifiedIdeographsEXTENSION A}', ""); +Expect(0, 13311, '\p{- in CJK UnifiedIdeographsEXTENSION A}', ""); +Expect(1, 13311, '\p{^- in CJK UnifiedIdeographsEXTENSION A}', ""); +Expect(1, 13311, '\P{- in CJK UnifiedIdeographsEXTENSION A}', ""); +Expect(0, 13311, '\P{^- in CJK UnifiedIdeographsEXTENSION A}', ""); +Error('\p{/a/-KHAROSHTHI}'); +Error('\P{/a/-KHAROSHTHI}'); +Expect(1, 68099, '\p{kharoshthi}', ""); +Expect(0, 68099, '\p{^kharoshthi}', ""); +Expect(0, 68099, '\P{kharoshthi}', ""); +Expect(1, 68099, '\P{^kharoshthi}', ""); +Expect(0, 68095, '\p{kharoshthi}', ""); +Expect(1, 68095, '\p{^kharoshthi}', ""); +Expect(1, 68095, '\P{kharoshthi}', ""); +Expect(0, 68095, '\P{^kharoshthi}', ""); +Expect(1, 68099, '\p{_Kharoshthi}', ""); +Expect(0, 68099, '\p{^_Kharoshthi}', ""); +Expect(0, 68099, '\P{_Kharoshthi}', ""); +Expect(1, 68099, '\P{^_Kharoshthi}', ""); +Expect(0, 68095, '\p{_Kharoshthi}', ""); +Expect(1, 68095, '\p{^_Kharoshthi}', ""); +Expect(1, 68095, '\P{_Kharoshthi}', ""); +Expect(0, 68095, '\P{^_Kharoshthi}', ""); +Error('\p{:=_IS Kharoshthi}'); +Error('\P{:=_IS Kharoshthi}'); +Expect(1, 68099, '\p{iskharoshthi}', ""); +Expect(0, 68099, '\p{^iskharoshthi}', ""); +Expect(0, 68099, '\P{iskharoshthi}', ""); +Expect(1, 68099, '\P{^iskharoshthi}', ""); +Expect(0, 68095, '\p{iskharoshthi}', ""); +Expect(1, 68095, '\p{^iskharoshthi}', ""); +Expect(1, 68095, '\P{iskharoshthi}', ""); +Expect(0, 68095, '\P{^iskharoshthi}', ""); +Expect(1, 68099, '\p{-is_KHAROSHTHI}', ""); +Expect(0, 68099, '\p{^-is_KHAROSHTHI}', ""); +Expect(0, 68099, '\P{-is_KHAROSHTHI}', ""); +Expect(1, 68099, '\P{^-is_KHAROSHTHI}', ""); +Expect(0, 68095, '\p{-is_KHAROSHTHI}', ""); +Expect(1, 68095, '\p{^-is_KHAROSHTHI}', ""); +Expect(1, 68095, '\P{-is_KHAROSHTHI}', ""); +Expect(0, 68095, '\P{^-is_KHAROSHTHI}', ""); +Error('\p{_/a/Khar}'); +Error('\P{_/a/Khar}'); +Expect(1, 68099, '\p{khar}', ""); +Expect(0, 68099, '\p{^khar}', ""); +Expect(0, 68099, '\P{khar}', ""); +Expect(1, 68099, '\P{^khar}', ""); +Expect(0, 68095, '\p{khar}', ""); +Expect(1, 68095, '\p{^khar}', ""); +Expect(1, 68095, '\P{khar}', ""); +Expect(0, 68095, '\P{^khar}', ""); +Expect(1, 68099, '\p{ _khar}', ""); +Expect(0, 68099, '\p{^ _khar}', ""); +Expect(0, 68099, '\P{ _khar}', ""); +Expect(1, 68099, '\P{^ _khar}', ""); +Expect(0, 68095, '\p{ _khar}', ""); +Expect(1, 68095, '\p{^ _khar}', ""); +Expect(1, 68095, '\P{ _khar}', ""); +Expect(0, 68095, '\P{^ _khar}', ""); +Error('\p{ /a/IsKhar}'); +Error('\P{ /a/IsKhar}'); +Expect(1, 68099, '\p{iskhar}', ""); +Expect(0, 68099, '\p{^iskhar}', ""); +Expect(0, 68099, '\P{iskhar}', ""); +Expect(1, 68099, '\P{^iskhar}', ""); +Expect(0, 68095, '\p{iskhar}', ""); +Expect(1, 68095, '\p{^iskhar}', ""); +Expect(1, 68095, '\P{iskhar}', ""); +Expect(0, 68095, '\P{^iskhar}', ""); +Expect(1, 68099, '\p{-_Is_Khar}', ""); +Expect(0, 68099, '\p{^-_Is_Khar}', ""); +Expect(0, 68099, '\P{-_Is_Khar}', ""); +Expect(1, 68099, '\P{^-_Is_Khar}', ""); +Expect(0, 68095, '\p{-_Is_Khar}', ""); +Expect(1, 68095, '\p{^-_Is_Khar}', ""); +Expect(1, 68095, '\P{-_Is_Khar}', ""); +Expect(0, 68095, '\P{^-_Is_Khar}', ""); +Error('\p{ math_SYMBOL/a/}'); +Error('\P{ math_SYMBOL/a/}'); +Expect(1, 43, '\p{mathsymbol}', ""); +Expect(0, 43, '\p{^mathsymbol}', ""); +Expect(0, 43, '\P{mathsymbol}', ""); +Expect(1, 43, '\P{^mathsymbol}', ""); +Expect(0, 42, '\p{mathsymbol}', ""); +Expect(1, 42, '\p{^mathsymbol}', ""); +Expect(1, 42, '\P{mathsymbol}', ""); +Expect(0, 42, '\P{^mathsymbol}', ""); +Expect(1, 43, '\p{ -MATH Symbol}', ""); +Expect(0, 43, '\p{^ -MATH Symbol}', ""); +Expect(0, 43, '\P{ -MATH Symbol}', ""); +Expect(1, 43, '\P{^ -MATH Symbol}', ""); +Expect(0, 42, '\p{ -MATH Symbol}', ""); +Expect(1, 42, '\p{^ -MATH Symbol}', ""); +Expect(1, 42, '\P{ -MATH Symbol}', ""); +Expect(0, 42, '\P{^ -MATH Symbol}', ""); +Error('\p{-IS Math:=SYMBOL}'); +Error('\P{-IS Math:=SYMBOL}'); +Expect(1, 43, '\p{ismathsymbol}', ""); +Expect(0, 43, '\p{^ismathsymbol}', ""); +Expect(0, 43, '\P{ismathsymbol}', ""); +Expect(1, 43, '\P{^ismathsymbol}', ""); +Expect(0, 42, '\p{ismathsymbol}', ""); +Expect(1, 42, '\p{^ismathsymbol}', ""); +Expect(1, 42, '\P{ismathsymbol}', ""); +Expect(0, 42, '\P{^ismathsymbol}', ""); +Expect(1, 43, '\p{ Is Math SYMBOL}', ""); +Expect(0, 43, '\p{^ Is Math SYMBOL}', ""); +Expect(0, 43, '\P{ Is Math SYMBOL}', ""); +Expect(1, 43, '\P{^ Is Math SYMBOL}', ""); +Expect(0, 42, '\p{ Is Math SYMBOL}', ""); +Expect(1, 42, '\p{^ Is Math SYMBOL}', ""); +Expect(1, 42, '\P{ Is Math SYMBOL}', ""); +Expect(0, 42, '\P{^ Is Math SYMBOL}', ""); +Error('\p{:=__SM}'); +Error('\P{:=__SM}'); +Expect(1, 43, '\p{sm}', ""); +Expect(0, 43, '\p{^sm}', ""); +Expect(0, 43, '\P{sm}', ""); +Expect(1, 43, '\P{^sm}', ""); +Expect(0, 42, '\p{sm}', ""); +Expect(1, 42, '\p{^sm}', ""); +Expect(1, 42, '\P{sm}', ""); +Expect(0, 42, '\P{^sm}', ""); +Expect(1, 43, '\p{ Sm}', ""); +Expect(0, 43, '\p{^ Sm}', ""); +Expect(0, 43, '\P{ Sm}', ""); +Expect(1, 43, '\P{^ Sm}', ""); +Expect(0, 42, '\p{ Sm}', ""); +Expect(1, 42, '\p{^ Sm}', ""); +Expect(1, 42, '\P{ Sm}', ""); +Expect(0, 42, '\P{^ Sm}', ""); +Error('\p{ Is_Sm:=}'); +Error('\P{ Is_Sm:=}'); +Expect(1, 43, '\p{issm}', ""); +Expect(0, 43, '\p{^issm}', ""); +Expect(0, 43, '\P{issm}', ""); +Expect(1, 43, '\P{^issm}', ""); +Expect(0, 42, '\p{issm}', ""); +Expect(1, 42, '\p{^issm}', ""); +Expect(1, 42, '\P{issm}', ""); +Expect(0, 42, '\P{^issm}', ""); +Expect(1, 43, '\p{--issm}', ""); +Expect(0, 43, '\p{^--issm}', ""); +Expect(0, 43, '\P{--issm}', ""); +Expect(1, 43, '\P{^--issm}', ""); +Expect(0, 42, '\p{--issm}', ""); +Expect(1, 42, '\p{^--issm}', ""); +Expect(1, 42, '\P{--issm}', ""); +Expect(0, 42, '\P{^--issm}', ""); +Error('\p{-Tagalog:=}'); +Error('\P{-Tagalog:=}'); +Expect(1, 5900, '\p{tagalog}', ""); +Expect(0, 5900, '\p{^tagalog}', ""); +Expect(0, 5900, '\P{tagalog}', ""); +Expect(1, 5900, '\P{^tagalog}', ""); +Expect(0, 5887, '\p{tagalog}', ""); +Expect(1, 5887, '\p{^tagalog}', ""); +Expect(1, 5887, '\P{tagalog}', ""); +Expect(0, 5887, '\P{^tagalog}', ""); +Expect(1, 5900, '\p{-Tagalog}', ""); +Expect(0, 5900, '\p{^-Tagalog}', ""); +Expect(0, 5900, '\P{-Tagalog}', ""); +Expect(1, 5900, '\P{^-Tagalog}', ""); +Expect(0, 5887, '\p{-Tagalog}', ""); +Expect(1, 5887, '\p{^-Tagalog}', ""); +Expect(1, 5887, '\P{-Tagalog}', ""); +Expect(0, 5887, '\P{^-Tagalog}', ""); +Error('\p{/a/- IS Tagalog}'); +Error('\P{/a/- IS Tagalog}'); +Expect(1, 5900, '\p{istagalog}', ""); +Expect(0, 5900, '\p{^istagalog}', ""); +Expect(0, 5900, '\P{istagalog}', ""); +Expect(1, 5900, '\P{^istagalog}', ""); +Expect(0, 5887, '\p{istagalog}', ""); +Expect(1, 5887, '\p{^istagalog}', ""); +Expect(1, 5887, '\P{istagalog}', ""); +Expect(0, 5887, '\P{^istagalog}', ""); +Expect(1, 5900, '\p{ Istagalog}', ""); +Expect(0, 5900, '\p{^ Istagalog}', ""); +Expect(0, 5900, '\P{ Istagalog}', ""); +Expect(1, 5900, '\P{^ Istagalog}', ""); +Expect(0, 5887, '\p{ Istagalog}', ""); +Expect(1, 5887, '\p{^ Istagalog}', ""); +Expect(1, 5887, '\P{ Istagalog}', ""); +Expect(0, 5887, '\P{^ Istagalog}', ""); +Error('\p{/a/ TGLG}'); +Error('\P{/a/ TGLG}'); +Expect(1, 5900, '\p{tglg}', ""); +Expect(0, 5900, '\p{^tglg}', ""); +Expect(0, 5900, '\P{tglg}', ""); +Expect(1, 5900, '\P{^tglg}', ""); +Expect(0, 5887, '\p{tglg}', ""); +Expect(1, 5887, '\p{^tglg}', ""); +Expect(1, 5887, '\P{tglg}', ""); +Expect(0, 5887, '\P{^tglg}', ""); +Expect(1, 5900, '\p{Tglg}', ""); +Expect(0, 5900, '\p{^Tglg}', ""); +Expect(0, 5900, '\P{Tglg}', ""); +Expect(1, 5900, '\P{^Tglg}', ""); +Expect(0, 5887, '\p{Tglg}', ""); +Expect(1, 5887, '\p{^Tglg}', ""); +Expect(1, 5887, '\P{Tglg}', ""); +Expect(0, 5887, '\P{^Tglg}', ""); +Error('\p{-isTGLG:=}'); +Error('\P{-isTGLG:=}'); +Expect(1, 5900, '\p{istglg}', ""); +Expect(0, 5900, '\p{^istglg}', ""); +Expect(0, 5900, '\P{istglg}', ""); +Expect(1, 5900, '\P{^istglg}', ""); +Expect(0, 5887, '\p{istglg}', ""); +Expect(1, 5887, '\p{^istglg}', ""); +Expect(1, 5887, '\P{istglg}', ""); +Expect(0, 5887, '\P{^istglg}', ""); +Expect(1, 5900, '\p{__Is Tglg}', ""); +Expect(0, 5900, '\p{^__Is Tglg}', ""); +Expect(0, 5900, '\P{__Is Tglg}', ""); +Expect(1, 5900, '\P{^__Is Tglg}', ""); +Expect(0, 5887, '\p{__Is Tglg}', ""); +Expect(1, 5887, '\p{^__Is Tglg}', ""); +Expect(1, 5887, '\P{__Is Tglg}', ""); +Expect(0, 5887, '\P{^__Is Tglg}', ""); +Error('\p{ syriac/a/}'); +Error('\P{ syriac/a/}'); +Expect(1, 1805, '\p{syriac}', ""); +Expect(0, 1805, '\p{^syriac}', ""); +Expect(0, 1805, '\P{syriac}', ""); +Expect(1, 1805, '\P{^syriac}', ""); +Expect(0, 1791, '\p{syriac}', ""); +Expect(1, 1791, '\p{^syriac}', ""); +Expect(1, 1791, '\P{syriac}', ""); +Expect(0, 1791, '\P{^syriac}', ""); +Expect(1, 1805, '\p{ -syriac}', ""); +Expect(0, 1805, '\p{^ -syriac}', ""); +Expect(0, 1805, '\P{ -syriac}', ""); +Expect(1, 1805, '\P{^ -syriac}', ""); +Expect(0, 1791, '\p{ -syriac}', ""); +Expect(1, 1791, '\p{^ -syriac}', ""); +Expect(1, 1791, '\P{ -syriac}', ""); +Expect(0, 1791, '\P{^ -syriac}', ""); +Error('\p{_IsSyriac/a/}'); +Error('\P{_IsSyriac/a/}'); +Expect(1, 1805, '\p{issyriac}', ""); +Expect(0, 1805, '\p{^issyriac}', ""); +Expect(0, 1805, '\P{issyriac}', ""); +Expect(1, 1805, '\P{^issyriac}', ""); +Expect(0, 1791, '\p{issyriac}', ""); +Expect(1, 1791, '\p{^issyriac}', ""); +Expect(1, 1791, '\P{issyriac}', ""); +Expect(0, 1791, '\P{^issyriac}', ""); +Expect(1, 1805, '\p{ _is-syriac}', ""); +Expect(0, 1805, '\p{^ _is-syriac}', ""); +Expect(0, 1805, '\P{ _is-syriac}', ""); +Expect(1, 1805, '\P{^ _is-syriac}', ""); +Expect(0, 1791, '\p{ _is-syriac}', ""); +Expect(1, 1791, '\p{^ _is-syriac}', ""); +Expect(1, 1791, '\P{ _is-syriac}', ""); +Expect(0, 1791, '\P{^ _is-syriac}', ""); +Error('\p{_SYRC:=}'); +Error('\P{_SYRC:=}'); +Expect(1, 1805, '\p{syrc}', ""); +Expect(0, 1805, '\p{^syrc}', ""); +Expect(0, 1805, '\P{syrc}', ""); +Expect(1, 1805, '\P{^syrc}', ""); +Expect(0, 1791, '\p{syrc}', ""); +Expect(1, 1791, '\p{^syrc}', ""); +Expect(1, 1791, '\P{syrc}', ""); +Expect(0, 1791, '\P{^syrc}', ""); +Expect(1, 1805, '\p{ syrc}', ""); +Expect(0, 1805, '\p{^ syrc}', ""); +Expect(0, 1805, '\P{ syrc}', ""); +Expect(1, 1805, '\P{^ syrc}', ""); +Expect(0, 1791, '\p{ syrc}', ""); +Expect(1, 1791, '\p{^ syrc}', ""); +Expect(1, 1791, '\P{ syrc}', ""); +Expect(0, 1791, '\P{^ syrc}', ""); +Error('\p{:= is SYRC}'); +Error('\P{:= is SYRC}'); +Expect(1, 1805, '\p{issyrc}', ""); +Expect(0, 1805, '\p{^issyrc}', ""); +Expect(0, 1805, '\P{issyrc}', ""); +Expect(1, 1805, '\P{^issyrc}', ""); +Expect(0, 1791, '\p{issyrc}', ""); +Expect(1, 1791, '\p{^issyrc}', ""); +Expect(1, 1791, '\P{issyrc}', ""); +Expect(0, 1791, '\P{^issyrc}', ""); +Expect(1, 1805, '\p{ Is Syrc}', ""); +Expect(0, 1805, '\p{^ Is Syrc}', ""); +Expect(0, 1805, '\P{ Is Syrc}', ""); +Expect(1, 1805, '\P{^ Is Syrc}', ""); +Expect(0, 1791, '\p{ Is Syrc}', ""); +Expect(1, 1791, '\p{^ Is Syrc}', ""); +Expect(1, 1791, '\P{ Is Syrc}', ""); +Expect(0, 1791, '\P{^ Is Syrc}', ""); +Error('\p{_In phoenician/a/}'); +Error('\P{_In phoenician/a/}'); +Expect(1, 67871, '\p{inphoenician}', ""); +Expect(0, 67871, '\p{^inphoenician}', ""); +Expect(0, 67871, '\P{inphoenician}', ""); +Expect(1, 67871, '\P{^inphoenician}', ""); +Expect(0, 67839, '\p{inphoenician}', ""); +Expect(1, 67839, '\p{^inphoenician}', ""); +Expect(1, 67839, '\P{inphoenician}', ""); +Expect(0, 67839, '\P{^inphoenician}', ""); +Expect(1, 67871, '\p{ _in-PHOENICIAN}', ""); +Expect(0, 67871, '\p{^ _in-PHOENICIAN}', ""); +Expect(0, 67871, '\P{ _in-PHOENICIAN}', ""); +Expect(1, 67871, '\P{^ _in-PHOENICIAN}', ""); +Expect(0, 67839, '\p{ _in-PHOENICIAN}', ""); +Expect(1, 67839, '\p{^ _in-PHOENICIAN}', ""); +Expect(1, 67839, '\P{ _in-PHOENICIAN}', ""); +Expect(0, 67839, '\P{^ _in-PHOENICIAN}', ""); +Error('\p{:= PERLWORD}'); +Error('\P{:= PERLWORD}'); +Expect(1, 57, '\p{perlword}', ""); +Expect(0, 57, '\p{^perlword}', ""); +Expect(0, 57, '\P{perlword}', ""); +Expect(1, 57, '\P{^perlword}', ""); +Expect(0, 47, '\p{perlword}', ""); +Expect(1, 47, '\p{^perlword}', ""); +Expect(1, 47, '\P{perlword}', ""); +Expect(0, 47, '\P{^perlword}', ""); +Expect(1, 57, '\p{- PerlWord}', ""); +Expect(0, 57, '\p{^- PerlWord}', ""); +Expect(0, 57, '\P{- PerlWord}', ""); +Expect(1, 57, '\P{^- PerlWord}', ""); +Expect(0, 47, '\p{- PerlWord}', ""); +Expect(1, 47, '\p{^- PerlWord}', ""); +Expect(1, 47, '\P{- PerlWord}', ""); +Expect(0, 47, '\P{^- PerlWord}', ""); +Error('\p{ -Is_PerlWord/a/}'); +Error('\P{ -Is_PerlWord/a/}'); +Expect(1, 57, '\p{isperlword}', ""); +Expect(0, 57, '\p{^isperlword}', ""); +Expect(0, 57, '\P{isperlword}', ""); +Expect(1, 57, '\P{^isperlword}', ""); +Expect(0, 47, '\p{isperlword}', ""); +Expect(1, 47, '\p{^isperlword}', ""); +Expect(1, 47, '\P{isperlword}', ""); +Expect(0, 47, '\P{^isperlword}', ""); +Expect(1, 57, '\p{ is perlword}', ""); +Expect(0, 57, '\p{^ is perlword}', ""); +Expect(0, 57, '\P{ is perlword}', ""); +Expect(1, 57, '\P{^ is perlword}', ""); +Expect(0, 47, '\p{ is perlword}', ""); +Expect(1, 47, '\p{^ is perlword}', ""); +Expect(1, 47, '\P{ is perlword}', ""); +Expect(0, 47, '\P{^ is perlword}', ""); +Error('\p{/a/_Halfwidth AND Fullwidth FORMS}'); +Error('\P{/a/_Halfwidth AND Fullwidth FORMS}'); +Expect(1, 65519, '\p{halfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\p{^halfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\P{halfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\P{^halfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\p{halfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\p{^halfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\P{halfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\P{^halfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\p{_ HALFWIDTH-AND FULLWIDTH FORMS}', ""); +Expect(0, 65519, '\p{^_ HALFWIDTH-AND FULLWIDTH FORMS}', ""); +Expect(0, 65519, '\P{_ HALFWIDTH-AND FULLWIDTH FORMS}', ""); +Expect(1, 65519, '\P{^_ HALFWIDTH-AND FULLWIDTH FORMS}', ""); +Expect(0, 65279, '\p{_ HALFWIDTH-AND FULLWIDTH FORMS}', ""); +Expect(1, 65279, '\p{^_ HALFWIDTH-AND FULLWIDTH FORMS}', ""); +Expect(1, 65279, '\P{_ HALFWIDTH-AND FULLWIDTH FORMS}', ""); +Expect(0, 65279, '\P{^_ HALFWIDTH-AND FULLWIDTH FORMS}', ""); +Error('\p{:= Is_HALFWIDTH and_FULLWIDTH-Forms}'); +Error('\P{:= Is_HALFWIDTH and_FULLWIDTH-Forms}'); +Expect(1, 65519, '\p{ishalfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\p{^ishalfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\P{ishalfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\P{^ishalfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\p{ishalfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\p{^ishalfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\P{ishalfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\P{^ishalfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\p{ ISHalfwidth_And-Fullwidth-Forms}', ""); +Expect(0, 65519, '\p{^ ISHalfwidth_And-Fullwidth-Forms}', ""); +Expect(0, 65519, '\P{ ISHalfwidth_And-Fullwidth-Forms}', ""); +Expect(1, 65519, '\P{^ ISHalfwidth_And-Fullwidth-Forms}', ""); +Expect(0, 65279, '\p{ ISHalfwidth_And-Fullwidth-Forms}', ""); +Expect(1, 65279, '\p{^ ISHalfwidth_And-Fullwidth-Forms}', ""); +Expect(1, 65279, '\P{ ISHalfwidth_And-Fullwidth-Forms}', ""); +Expect(0, 65279, '\P{^ ISHalfwidth_And-Fullwidth-Forms}', ""); +Error('\p{-:=InHalfwidth_and-Fullwidth_Forms}'); +Error('\P{-:=InHalfwidth_and-Fullwidth_Forms}'); +Expect(1, 65519, '\p{inhalfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\p{^inhalfwidthandfullwidthforms}', ""); +Expect(0, 65519, '\P{inhalfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\P{^inhalfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\p{inhalfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\p{^inhalfwidthandfullwidthforms}', ""); +Expect(1, 65279, '\P{inhalfwidthandfullwidthforms}', ""); +Expect(0, 65279, '\P{^inhalfwidthandfullwidthforms}', ""); +Expect(1, 65519, '\p{ In HALFWIDTHand-fullwidthforms}', ""); +Expect(0, 65519, '\p{^ In HALFWIDTHand-fullwidthforms}', ""); +Expect(0, 65519, '\P{ In HALFWIDTHand-fullwidthforms}', ""); +Expect(1, 65519, '\P{^ In HALFWIDTHand-fullwidthforms}', ""); +Expect(0, 65279, '\p{ In HALFWIDTHand-fullwidthforms}', ""); +Expect(1, 65279, '\p{^ In HALFWIDTHand-fullwidthforms}', ""); +Expect(1, 65279, '\P{ In HALFWIDTHand-fullwidthforms}', ""); +Expect(0, 65279, '\P{^ In HALFWIDTHand-fullwidthforms}', ""); +Error('\p{/a/-Ancient-greek-Numbers}'); +Error('\P{/a/-Ancient-greek-Numbers}'); +Expect(1, 65935, '\p{ancientgreeknumbers}', ""); +Expect(0, 65935, '\p{^ancientgreeknumbers}', ""); +Expect(0, 65935, '\P{ancientgreeknumbers}', ""); +Expect(1, 65935, '\P{^ancientgreeknumbers}', ""); +Expect(0, 65855, '\p{ancientgreeknumbers}', ""); +Expect(1, 65855, '\p{^ancientgreeknumbers}', ""); +Expect(1, 65855, '\P{ancientgreeknumbers}', ""); +Expect(0, 65855, '\P{^ancientgreeknumbers}', ""); +Expect(1, 65935, '\p{ Ancient-Greek_Numbers}', ""); +Expect(0, 65935, '\p{^ Ancient-Greek_Numbers}', ""); +Expect(0, 65935, '\P{ Ancient-Greek_Numbers}', ""); +Expect(1, 65935, '\P{^ Ancient-Greek_Numbers}', ""); +Expect(0, 65855, '\p{ Ancient-Greek_Numbers}', ""); +Expect(1, 65855, '\p{^ Ancient-Greek_Numbers}', ""); +Expect(1, 65855, '\P{ Ancient-Greek_Numbers}', ""); +Expect(0, 65855, '\P{^ Ancient-Greek_Numbers}', ""); +Error('\p{ Is Ancient:=GREEKNumbers}'); +Error('\P{ Is Ancient:=GREEKNumbers}'); +Expect(1, 65935, '\p{isancientgreeknumbers}', ""); +Expect(0, 65935, '\p{^isancientgreeknumbers}', ""); +Expect(0, 65935, '\P{isancientgreeknumbers}', ""); +Expect(1, 65935, '\P{^isancientgreeknumbers}', ""); +Expect(0, 65855, '\p{isancientgreeknumbers}', ""); +Expect(1, 65855, '\p{^isancientgreeknumbers}', ""); +Expect(1, 65855, '\P{isancientgreeknumbers}', ""); +Expect(0, 65855, '\P{^isancientgreeknumbers}', ""); +Expect(1, 65935, '\p{ Is_ANCIENT_GREEK-numbers}', ""); +Expect(0, 65935, '\p{^ Is_ANCIENT_GREEK-numbers}', ""); +Expect(0, 65935, '\P{ Is_ANCIENT_GREEK-numbers}', ""); +Expect(1, 65935, '\P{^ Is_ANCIENT_GREEK-numbers}', ""); +Expect(0, 65855, '\p{ Is_ANCIENT_GREEK-numbers}', ""); +Expect(1, 65855, '\p{^ Is_ANCIENT_GREEK-numbers}', ""); +Expect(1, 65855, '\P{ Is_ANCIENT_GREEK-numbers}', ""); +Expect(0, 65855, '\P{^ Is_ANCIENT_GREEK-numbers}', ""); +Error('\p{ in ancient GREEK NUMBERS/a/}'); +Error('\P{ in ancient GREEK NUMBERS/a/}'); +Expect(1, 65935, '\p{inancientgreeknumbers}', ""); +Expect(0, 65935, '\p{^inancientgreeknumbers}', ""); +Expect(0, 65935, '\P{inancientgreeknumbers}', ""); +Expect(1, 65935, '\P{^inancientgreeknumbers}', ""); +Expect(0, 65855, '\p{inancientgreeknumbers}', ""); +Expect(1, 65855, '\p{^inancientgreeknumbers}', ""); +Expect(1, 65855, '\P{inancientgreeknumbers}', ""); +Expect(0, 65855, '\P{^inancientgreeknumbers}', ""); +Expect(1, 65935, '\p{_ in_Ancient-greek_NUMBERS}', ""); +Expect(0, 65935, '\p{^_ in_Ancient-greek_NUMBERS}', ""); +Expect(0, 65935, '\P{_ in_Ancient-greek_NUMBERS}', ""); +Expect(1, 65935, '\P{^_ in_Ancient-greek_NUMBERS}', ""); +Expect(0, 65855, '\p{_ in_Ancient-greek_NUMBERS}', ""); +Expect(1, 65855, '\p{^_ in_Ancient-greek_NUMBERS}', ""); +Expect(1, 65855, '\P{_ in_Ancient-greek_NUMBERS}', ""); +Expect(0, 65855, '\P{^_ in_Ancient-greek_NUMBERS}', ""); +Error('\p{ Optical Character:=Recognition}'); +Error('\P{ Optical Character:=Recognition}'); +Expect(1, 9311, '\p{opticalcharacterrecognition}', ""); +Expect(0, 9311, '\p{^opticalcharacterrecognition}', ""); +Expect(0, 9311, '\P{opticalcharacterrecognition}', ""); +Expect(1, 9311, '\P{^opticalcharacterrecognition}', ""); +Expect(0, 9279, '\p{opticalcharacterrecognition}', ""); +Expect(1, 9279, '\p{^opticalcharacterrecognition}', ""); +Expect(1, 9279, '\P{opticalcharacterrecognition}', ""); +Expect(0, 9279, '\P{^opticalcharacterrecognition}', ""); +Expect(1, 9311, '\p{_-Optical-Character RECOGNITION}', ""); +Expect(0, 9311, '\p{^_-Optical-Character RECOGNITION}', ""); +Expect(0, 9311, '\P{_-Optical-Character RECOGNITION}', ""); +Expect(1, 9311, '\P{^_-Optical-Character RECOGNITION}', ""); +Expect(0, 9279, '\p{_-Optical-Character RECOGNITION}', ""); +Expect(1, 9279, '\p{^_-Optical-Character RECOGNITION}', ""); +Expect(1, 9279, '\P{_-Optical-Character RECOGNITION}', ""); +Expect(0, 9279, '\P{^_-Optical-Character RECOGNITION}', ""); +Error('\p{ IS:=OpticalCharacter_recognition}'); +Error('\P{ IS:=OpticalCharacter_recognition}'); +Expect(1, 9311, '\p{isopticalcharacterrecognition}', ""); +Expect(0, 9311, '\p{^isopticalcharacterrecognition}', ""); +Expect(0, 9311, '\P{isopticalcharacterrecognition}', ""); +Expect(1, 9311, '\P{^isopticalcharacterrecognition}', ""); +Expect(0, 9279, '\p{isopticalcharacterrecognition}', ""); +Expect(1, 9279, '\p{^isopticalcharacterrecognition}', ""); +Expect(1, 9279, '\P{isopticalcharacterrecognition}', ""); +Expect(0, 9279, '\P{^isopticalcharacterrecognition}', ""); +Expect(1, 9311, '\p{ Is OPTICALCHARACTER-RECOGNITION}', ""); +Expect(0, 9311, '\p{^ Is OPTICALCHARACTER-RECOGNITION}', ""); +Expect(0, 9311, '\P{ Is OPTICALCHARACTER-RECOGNITION}', ""); +Expect(1, 9311, '\P{^ Is OPTICALCHARACTER-RECOGNITION}', ""); +Expect(0, 9279, '\p{ Is OPTICALCHARACTER-RECOGNITION}', ""); +Expect(1, 9279, '\p{^ Is OPTICALCHARACTER-RECOGNITION}', ""); +Expect(1, 9279, '\P{ Is OPTICALCHARACTER-RECOGNITION}', ""); +Expect(0, 9279, '\P{^ Is OPTICALCHARACTER-RECOGNITION}', ""); +Error('\p{:=--in-optical CHARACTER RECOGNITION}'); +Error('\P{:=--in-optical CHARACTER RECOGNITION}'); +Expect(1, 9311, '\p{inopticalcharacterrecognition}', ""); +Expect(0, 9311, '\p{^inopticalcharacterrecognition}', ""); +Expect(0, 9311, '\P{inopticalcharacterrecognition}', ""); +Expect(1, 9311, '\P{^inopticalcharacterrecognition}', ""); +Expect(0, 9279, '\p{inopticalcharacterrecognition}', ""); +Expect(1, 9279, '\p{^inopticalcharacterrecognition}', ""); +Expect(1, 9279, '\P{inopticalcharacterrecognition}', ""); +Expect(0, 9279, '\P{^inopticalcharacterrecognition}', ""); +Expect(1, 9311, '\p{-inoptical CHARACTERrecognition}', ""); +Expect(0, 9311, '\p{^-inoptical CHARACTERrecognition}', ""); +Expect(0, 9311, '\P{-inoptical CHARACTERrecognition}', ""); +Expect(1, 9311, '\P{^-inoptical CHARACTERrecognition}', ""); +Expect(0, 9279, '\p{-inoptical CHARACTERrecognition}', ""); +Expect(1, 9279, '\p{^-inoptical CHARACTERrecognition}', ""); +Expect(1, 9279, '\P{-inoptical CHARACTERrecognition}', ""); +Expect(0, 9279, '\P{^-inoptical CHARACTERrecognition}', ""); +Error('\p{:=--limbu}'); +Error('\P{:=--limbu}'); +Expect(1, 6428, '\p{limbu}', ""); +Expect(0, 6428, '\p{^limbu}', ""); +Expect(0, 6428, '\P{limbu}', ""); +Expect(1, 6428, '\P{^limbu}', ""); +Expect(0, 6399, '\p{limbu}', ""); +Expect(1, 6399, '\p{^limbu}', ""); +Expect(1, 6399, '\P{limbu}', ""); +Expect(0, 6399, '\P{^limbu}', ""); +Expect(1, 6428, '\p{LIMBU}', ""); +Expect(0, 6428, '\p{^LIMBU}', ""); +Expect(0, 6428, '\P{LIMBU}', ""); +Expect(1, 6428, '\P{^LIMBU}', ""); +Expect(0, 6399, '\p{LIMBU}', ""); +Expect(1, 6399, '\p{^LIMBU}', ""); +Expect(1, 6399, '\P{LIMBU}', ""); +Expect(0, 6399, '\P{^LIMBU}', ""); +Error('\p{--Is_Limbu/a/}'); +Error('\P{--Is_Limbu/a/}'); +Expect(1, 6428, '\p{islimbu}', ""); +Expect(0, 6428, '\p{^islimbu}', ""); +Expect(0, 6428, '\P{islimbu}', ""); +Expect(1, 6428, '\P{^islimbu}', ""); +Expect(0, 6399, '\p{islimbu}', ""); +Expect(1, 6399, '\p{^islimbu}', ""); +Expect(1, 6399, '\P{islimbu}', ""); +Expect(0, 6399, '\P{^islimbu}', ""); +Expect(1, 6428, '\p{-Is-Limbu}', ""); +Expect(0, 6428, '\p{^-Is-Limbu}', ""); +Expect(0, 6428, '\P{-Is-Limbu}', ""); +Expect(1, 6428, '\P{^-Is-Limbu}', ""); +Expect(0, 6399, '\p{-Is-Limbu}', ""); +Expect(1, 6399, '\p{^-Is-Limbu}', ""); +Expect(1, 6399, '\P{-Is-Limbu}', ""); +Expect(0, 6399, '\P{^-Is-Limbu}', ""); +Error('\p{ LIMB:=}'); +Error('\P{ LIMB:=}'); +Expect(1, 6428, '\p{limb}', ""); +Expect(0, 6428, '\p{^limb}', ""); +Expect(0, 6428, '\P{limb}', ""); +Expect(1, 6428, '\P{^limb}', ""); +Expect(0, 6399, '\p{limb}', ""); +Expect(1, 6399, '\p{^limb}', ""); +Expect(1, 6399, '\P{limb}', ""); +Expect(0, 6399, '\P{^limb}', ""); +Expect(1, 6428, '\p{_ Limb}', ""); +Expect(0, 6428, '\p{^_ Limb}', ""); +Expect(0, 6428, '\P{_ Limb}', ""); +Expect(1, 6428, '\P{^_ Limb}', ""); +Expect(0, 6399, '\p{_ Limb}', ""); +Expect(1, 6399, '\p{^_ Limb}', ""); +Expect(1, 6399, '\P{_ Limb}', ""); +Expect(0, 6399, '\P{^_ Limb}', ""); +Error('\p{/a/-IS Limb}'); +Error('\P{/a/-IS Limb}'); +Expect(1, 6428, '\p{islimb}', ""); +Expect(0, 6428, '\p{^islimb}', ""); +Expect(0, 6428, '\P{islimb}', ""); +Expect(1, 6428, '\P{^islimb}', ""); +Expect(0, 6399, '\p{islimb}', ""); +Expect(1, 6399, '\p{^islimb}', ""); +Expect(1, 6399, '\P{islimb}', ""); +Expect(0, 6399, '\P{^islimb}', ""); +Expect(1, 6428, '\p{_Is Limb}', ""); +Expect(0, 6428, '\p{^_Is Limb}', ""); +Expect(0, 6428, '\P{_Is Limb}', ""); +Expect(1, 6428, '\P{^_Is Limb}', ""); +Expect(0, 6399, '\p{_Is Limb}', ""); +Expect(1, 6399, '\p{^_Is Limb}', ""); +Expect(1, 6399, '\P{_Is Limb}', ""); +Expect(0, 6399, '\P{^_Is Limb}', ""); +Error('\p{-_Terminal-PUNCTUATION/a/}'); +Error('\P{-_Terminal-PUNCTUATION/a/}'); +Expect(1, 33, '\p{terminalpunctuation}', ""); +Expect(0, 33, '\p{^terminalpunctuation}', ""); +Expect(0, 33, '\P{terminalpunctuation}', ""); +Expect(1, 33, '\P{^terminalpunctuation}', ""); +Expect(0, 32, '\p{terminalpunctuation}', ""); +Expect(1, 32, '\p{^terminalpunctuation}', ""); +Expect(1, 32, '\P{terminalpunctuation}', ""); +Expect(0, 32, '\P{^terminalpunctuation}', ""); +Expect(1, 33, '\p{ TERMINALpunctuation}', ""); +Expect(0, 33, '\p{^ TERMINALpunctuation}', ""); +Expect(0, 33, '\P{ TERMINALpunctuation}', ""); +Expect(1, 33, '\P{^ TERMINALpunctuation}', ""); +Expect(0, 32, '\p{ TERMINALpunctuation}', ""); +Expect(1, 32, '\p{^ TERMINALpunctuation}', ""); +Expect(1, 32, '\P{ TERMINALpunctuation}', ""); +Expect(0, 32, '\P{^ TERMINALpunctuation}', ""); +Error('\p{-:=IS TERMINALpunctuation}'); +Error('\P{-:=IS TERMINALpunctuation}'); +Expect(1, 33, '\p{isterminalpunctuation}', ""); +Expect(0, 33, '\p{^isterminalpunctuation}', ""); +Expect(0, 33, '\P{isterminalpunctuation}', ""); +Expect(1, 33, '\P{^isterminalpunctuation}', ""); +Expect(0, 32, '\p{isterminalpunctuation}', ""); +Expect(1, 32, '\p{^isterminalpunctuation}', ""); +Expect(1, 32, '\P{isterminalpunctuation}', ""); +Expect(0, 32, '\P{^isterminalpunctuation}', ""); +Expect(1, 33, '\p{ is TerminalPUNCTUATION}', ""); +Expect(0, 33, '\p{^ is TerminalPUNCTUATION}', ""); +Expect(0, 33, '\P{ is TerminalPUNCTUATION}', ""); +Expect(1, 33, '\P{^ is TerminalPUNCTUATION}', ""); +Expect(0, 32, '\p{ is TerminalPUNCTUATION}', ""); +Expect(1, 32, '\p{^ is TerminalPUNCTUATION}', ""); +Expect(1, 32, '\P{ is TerminalPUNCTUATION}', ""); +Expect(0, 32, '\P{^ is TerminalPUNCTUATION}', ""); +Error('\p{ -Term:=}'); +Error('\P{ -Term:=}'); +Expect(1, 33, '\p{term}', ""); +Expect(0, 33, '\p{^term}', ""); +Expect(0, 33, '\P{term}', ""); +Expect(1, 33, '\P{^term}', ""); +Expect(0, 32, '\p{term}', ""); +Expect(1, 32, '\p{^term}', ""); +Expect(1, 32, '\P{term}', ""); +Expect(0, 32, '\P{^term}', ""); +Expect(1, 33, '\p{_ term}', ""); +Expect(0, 33, '\p{^_ term}', ""); +Expect(0, 33, '\P{_ term}', ""); +Expect(1, 33, '\P{^_ term}', ""); +Expect(0, 32, '\p{_ term}', ""); +Expect(1, 32, '\p{^_ term}', ""); +Expect(1, 32, '\P{_ term}', ""); +Expect(0, 32, '\P{^_ term}', ""); +Error('\p{_is/a/term}'); +Error('\P{_is/a/term}'); +Expect(1, 33, '\p{isterm}', ""); +Expect(0, 33, '\p{^isterm}', ""); +Expect(0, 33, '\P{isterm}', ""); +Expect(1, 33, '\P{^isterm}', ""); +Expect(0, 32, '\p{isterm}', ""); +Expect(1, 32, '\p{^isterm}', ""); +Expect(1, 32, '\P{isterm}', ""); +Expect(0, 32, '\P{^isterm}', ""); +Expect(1, 33, '\p{_-Is Term}', ""); +Expect(0, 33, '\p{^_-Is Term}', ""); +Expect(0, 33, '\P{_-Is Term}', ""); +Expect(1, 33, '\P{^_-Is Term}', ""); +Expect(0, 32, '\p{_-Is Term}', ""); +Expect(1, 32, '\p{^_-Is Term}', ""); +Expect(1, 32, '\P{_-Is Term}', ""); +Expect(0, 32, '\P{^_-Is Term}', ""); +Error('\p{/a/- Other_Uppercase}'); +Error('\P{/a/- Other_Uppercase}'); +Expect(1, 8559, '\p{otheruppercase}', 'deprecated'); +Expect(0, 8559, '\p{^otheruppercase}', 'deprecated'); +Expect(0, 8559, '\P{otheruppercase}', 'deprecated'); +Expect(1, 8559, '\P{^otheruppercase}', 'deprecated'); +Expect(0, 8543, '\p{otheruppercase}', 'deprecated'); +Expect(1, 8543, '\p{^otheruppercase}', 'deprecated'); +Expect(1, 8543, '\P{otheruppercase}', 'deprecated'); +Expect(0, 8543, '\P{^otheruppercase}', 'deprecated'); +Expect(1, 8559, '\p{- Other_UPPERCASE}', 'deprecated'); +Expect(0, 8559, '\p{^- Other_UPPERCASE}', 'deprecated'); +Expect(0, 8559, '\P{- Other_UPPERCASE}', 'deprecated'); +Expect(1, 8559, '\P{^- Other_UPPERCASE}', 'deprecated'); +Expect(0, 8543, '\p{- Other_UPPERCASE}', 'deprecated'); +Expect(1, 8543, '\p{^- Other_UPPERCASE}', 'deprecated'); +Expect(1, 8543, '\P{- Other_UPPERCASE}', 'deprecated'); +Expect(0, 8543, '\P{^- Other_UPPERCASE}', 'deprecated'); +Error('\p{/a/--Is_Other Uppercase}'); +Error('\P{/a/--Is_Other Uppercase}'); +Expect(1, 8559, '\p{isotheruppercase}', 'deprecated'); +Expect(0, 8559, '\p{^isotheruppercase}', 'deprecated'); +Expect(0, 8559, '\P{isotheruppercase}', 'deprecated'); +Expect(1, 8559, '\P{^isotheruppercase}', 'deprecated'); +Expect(0, 8543, '\p{isotheruppercase}', 'deprecated'); +Expect(1, 8543, '\p{^isotheruppercase}', 'deprecated'); +Expect(1, 8543, '\P{isotheruppercase}', 'deprecated'); +Expect(0, 8543, '\P{^isotheruppercase}', 'deprecated'); +Expect(1, 8559, '\p{ -is-Other Uppercase}', 'deprecated'); +Expect(0, 8559, '\p{^ -is-Other Uppercase}', 'deprecated'); +Expect(0, 8559, '\P{ -is-Other Uppercase}', 'deprecated'); +Expect(1, 8559, '\P{^ -is-Other Uppercase}', 'deprecated'); +Expect(0, 8543, '\p{ -is-Other Uppercase}', 'deprecated'); +Expect(1, 8543, '\p{^ -is-Other Uppercase}', 'deprecated'); +Expect(1, 8543, '\P{ -is-Other Uppercase}', 'deprecated'); +Expect(0, 8543, '\P{^ -is-Other Uppercase}', 'deprecated'); +Error('\p{-:=OUpper}'); +Error('\P{-:=OUpper}'); +Expect(1, 8559, '\p{oupper}', 'deprecated'); +Expect(0, 8559, '\p{^oupper}', 'deprecated'); +Expect(0, 8559, '\P{oupper}', 'deprecated'); +Expect(1, 8559, '\P{^oupper}', 'deprecated'); +Expect(0, 8543, '\p{oupper}', 'deprecated'); +Expect(1, 8543, '\p{^oupper}', 'deprecated'); +Expect(1, 8543, '\P{oupper}', 'deprecated'); +Expect(0, 8543, '\P{^oupper}', 'deprecated'); +Expect(1, 8559, '\p{ _OUPPER}', 'deprecated'); +Expect(0, 8559, '\p{^ _OUPPER}', 'deprecated'); +Expect(0, 8559, '\P{ _OUPPER}', 'deprecated'); +Expect(1, 8559, '\P{^ _OUPPER}', 'deprecated'); +Expect(0, 8543, '\p{ _OUPPER}', 'deprecated'); +Expect(1, 8543, '\p{^ _OUPPER}', 'deprecated'); +Expect(1, 8543, '\P{ _OUPPER}', 'deprecated'); +Expect(0, 8543, '\P{^ _OUPPER}', 'deprecated'); +Error('\p{- Is/a/OUPPER}'); +Error('\P{- Is/a/OUPPER}'); +Expect(1, 8559, '\p{isoupper}', 'deprecated'); +Expect(0, 8559, '\p{^isoupper}', 'deprecated'); +Expect(0, 8559, '\P{isoupper}', 'deprecated'); +Expect(1, 8559, '\P{^isoupper}', 'deprecated'); +Expect(0, 8543, '\p{isoupper}', 'deprecated'); +Expect(1, 8543, '\p{^isoupper}', 'deprecated'); +Expect(1, 8543, '\P{isoupper}', 'deprecated'); +Expect(0, 8543, '\P{^isoupper}', 'deprecated'); +Expect(1, 8559, '\p{_ Is-OUpper}', 'deprecated'); +Expect(0, 8559, '\p{^_ Is-OUpper}', 'deprecated'); +Expect(0, 8559, '\P{_ Is-OUpper}', 'deprecated'); +Expect(1, 8559, '\P{^_ Is-OUpper}', 'deprecated'); +Expect(0, 8543, '\p{_ Is-OUpper}', 'deprecated'); +Expect(1, 8543, '\p{^_ Is-OUpper}', 'deprecated'); +Expect(1, 8543, '\P{_ Is-OUpper}', 'deprecated'); +Expect(0, 8543, '\P{^_ Is-OUpper}', 'deprecated'); +Error('\p{ POSIXPUNCT:=}'); +Error('\P{ POSIXPUNCT:=}'); +Expect(1, 47, '\p{posixpunct}', ""); +Expect(0, 47, '\p{^posixpunct}', ""); +Expect(0, 47, '\P{posixpunct}', ""); +Expect(1, 47, '\P{^posixpunct}', ""); +Expect(0, 32, '\p{posixpunct}', ""); +Expect(1, 32, '\p{^posixpunct}', ""); +Expect(1, 32, '\P{posixpunct}', ""); +Expect(0, 32, '\P{^posixpunct}', ""); +Expect(1, 47, '\p{ PosixPunct}', ""); +Expect(0, 47, '\p{^ PosixPunct}', ""); +Expect(0, 47, '\P{ PosixPunct}', ""); +Expect(1, 47, '\P{^ PosixPunct}', ""); +Expect(0, 32, '\p{ PosixPunct}', ""); +Expect(1, 32, '\p{^ PosixPunct}', ""); +Expect(1, 32, '\P{ PosixPunct}', ""); +Expect(0, 32, '\P{^ PosixPunct}', ""); +Error('\p{/a/ _is PosixPunct}'); +Error('\P{/a/ _is PosixPunct}'); +Expect(1, 47, '\p{isposixpunct}', ""); +Expect(0, 47, '\p{^isposixpunct}', ""); +Expect(0, 47, '\P{isposixpunct}', ""); +Expect(1, 47, '\P{^isposixpunct}', ""); +Expect(0, 32, '\p{isposixpunct}', ""); +Expect(1, 32, '\p{^isposixpunct}', ""); +Expect(1, 32, '\P{isposixpunct}', ""); +Expect(0, 32, '\P{^isposixpunct}', ""); +Expect(1, 47, '\p{ is POSIXPUNCT}', ""); +Expect(0, 47, '\p{^ is POSIXPUNCT}', ""); +Expect(0, 47, '\P{ is POSIXPUNCT}', ""); +Expect(1, 47, '\P{^ is POSIXPUNCT}', ""); +Expect(0, 32, '\p{ is POSIXPUNCT}', ""); +Expect(1, 32, '\p{^ is POSIXPUNCT}', ""); +Expect(1, 32, '\P{ is POSIXPUNCT}', ""); +Expect(0, 32, '\P{^ is POSIXPUNCT}', ""); +Error('\p{/a/-_block-Elements}'); +Error('\P{/a/-_block-Elements}'); +Expect(1, 9631, '\p{blockelements}', ""); +Expect(0, 9631, '\p{^blockelements}', ""); +Expect(0, 9631, '\P{blockelements}', ""); +Expect(1, 9631, '\P{^blockelements}', ""); +Expect(0, 9599, '\p{blockelements}', ""); +Expect(1, 9599, '\p{^blockelements}', ""); +Expect(1, 9599, '\P{blockelements}', ""); +Expect(0, 9599, '\P{^blockelements}', ""); +Expect(1, 9631, '\p{_-Block_ELEMENTS}', ""); +Expect(0, 9631, '\p{^_-Block_ELEMENTS}', ""); +Expect(0, 9631, '\P{_-Block_ELEMENTS}', ""); +Expect(1, 9631, '\P{^_-Block_ELEMENTS}', ""); +Expect(0, 9599, '\p{_-Block_ELEMENTS}', ""); +Expect(1, 9599, '\p{^_-Block_ELEMENTS}', ""); +Expect(1, 9599, '\P{_-Block_ELEMENTS}', ""); +Expect(0, 9599, '\P{^_-Block_ELEMENTS}', ""); +Error('\p{/a/Is_Block-Elements}'); +Error('\P{/a/Is_Block-Elements}'); +Expect(1, 9631, '\p{isblockelements}', ""); +Expect(0, 9631, '\p{^isblockelements}', ""); +Expect(0, 9631, '\P{isblockelements}', ""); +Expect(1, 9631, '\P{^isblockelements}', ""); +Expect(0, 9599, '\p{isblockelements}', ""); +Expect(1, 9599, '\p{^isblockelements}', ""); +Expect(1, 9599, '\P{isblockelements}', ""); +Expect(0, 9599, '\P{^isblockelements}', ""); +Expect(1, 9631, '\p{-Is block elements}', ""); +Expect(0, 9631, '\p{^-Is block elements}', ""); +Expect(0, 9631, '\P{-Is block elements}', ""); +Expect(1, 9631, '\P{^-Is block elements}', ""); +Expect(0, 9599, '\p{-Is block elements}', ""); +Expect(1, 9599, '\p{^-Is block elements}', ""); +Expect(1, 9599, '\P{-Is block elements}', ""); +Expect(0, 9599, '\P{^-Is block elements}', ""); +Error('\p{ -INBLOCK-ELEMENTS/a/}'); +Error('\P{ -INBLOCK-ELEMENTS/a/}'); +Expect(1, 9631, '\p{inblockelements}', ""); +Expect(0, 9631, '\p{^inblockelements}', ""); +Expect(0, 9631, '\P{inblockelements}', ""); +Expect(1, 9631, '\P{^inblockelements}', ""); +Expect(0, 9599, '\p{inblockelements}', ""); +Expect(1, 9599, '\p{^inblockelements}', ""); +Expect(1, 9599, '\P{inblockelements}', ""); +Expect(0, 9599, '\P{^inblockelements}', ""); +Expect(1, 9631, '\p{-_In-Block_elements}', ""); +Expect(0, 9631, '\p{^-_In-Block_elements}', ""); +Expect(0, 9631, '\P{-_In-Block_elements}', ""); +Expect(1, 9631, '\P{^-_In-Block_elements}', ""); +Expect(0, 9599, '\p{-_In-Block_elements}', ""); +Expect(1, 9599, '\p{^-_In-Block_elements}', ""); +Expect(1, 9599, '\P{-_In-Block_elements}', ""); +Expect(0, 9599, '\P{^-_In-Block_elements}', ""); +Error('\p{/a/-_Han}'); +Error('\P{/a/-_Han}'); +Expect(1, 11929, '\p{han}', ""); +Expect(0, 11929, '\p{^han}', ""); +Expect(0, 11929, '\P{han}', ""); +Expect(1, 11929, '\P{^han}', ""); +Expect(0, 11903, '\p{han}', ""); +Expect(1, 11903, '\p{^han}', ""); +Expect(1, 11903, '\P{han}', ""); +Expect(0, 11903, '\P{^han}', ""); +Expect(1, 11929, '\p{_han}', ""); +Expect(0, 11929, '\p{^_han}', ""); +Expect(0, 11929, '\P{_han}', ""); +Expect(1, 11929, '\P{^_han}', ""); +Expect(0, 11903, '\p{_han}', ""); +Expect(1, 11903, '\p{^_han}', ""); +Expect(1, 11903, '\P{_han}', ""); +Expect(0, 11903, '\P{^_han}', ""); +Error('\p{-:=IS Han}'); +Error('\P{-:=IS Han}'); +Expect(1, 11929, '\p{ishan}', ""); +Expect(0, 11929, '\p{^ishan}', ""); +Expect(0, 11929, '\P{ishan}', ""); +Expect(1, 11929, '\P{^ishan}', ""); +Expect(0, 11903, '\p{ishan}', ""); +Expect(1, 11903, '\p{^ishan}', ""); +Expect(1, 11903, '\P{ishan}', ""); +Expect(0, 11903, '\P{^ishan}', ""); +Expect(1, 11929, '\p{ IS_HAN}', ""); +Expect(0, 11929, '\p{^ IS_HAN}', ""); +Expect(0, 11929, '\P{ IS_HAN}', ""); +Expect(1, 11929, '\P{^ IS_HAN}', ""); +Expect(0, 11903, '\p{ IS_HAN}', ""); +Expect(1, 11903, '\p{^ IS_HAN}', ""); +Expect(1, 11903, '\P{ IS_HAN}', ""); +Expect(0, 11903, '\P{^ IS_HAN}', ""); +Error('\p{_:=hani}'); +Error('\P{_:=hani}'); +Expect(1, 11929, '\p{hani}', ""); +Expect(0, 11929, '\p{^hani}', ""); +Expect(0, 11929, '\P{hani}', ""); +Expect(1, 11929, '\P{^hani}', ""); +Expect(0, 11903, '\p{hani}', ""); +Expect(1, 11903, '\p{^hani}', ""); +Expect(1, 11903, '\P{hani}', ""); +Expect(0, 11903, '\P{^hani}', ""); +Expect(1, 11929, '\p{_-Hani}', ""); +Expect(0, 11929, '\p{^_-Hani}', ""); +Expect(0, 11929, '\P{_-Hani}', ""); +Expect(1, 11929, '\P{^_-Hani}', ""); +Expect(0, 11903, '\p{_-Hani}', ""); +Expect(1, 11903, '\p{^_-Hani}', ""); +Expect(1, 11903, '\P{_-Hani}', ""); +Expect(0, 11903, '\P{^_-Hani}', ""); +Error('\p{_ Is/a/Hani}'); +Error('\P{_ Is/a/Hani}'); +Expect(1, 11929, '\p{ishani}', ""); +Expect(0, 11929, '\p{^ishani}', ""); +Expect(0, 11929, '\P{ishani}', ""); +Expect(1, 11929, '\P{^ishani}', ""); +Expect(0, 11903, '\p{ishani}', ""); +Expect(1, 11903, '\p{^ishani}', ""); +Expect(1, 11903, '\P{ishani}', ""); +Expect(0, 11903, '\P{^ishani}', ""); +Expect(1, 11929, '\p{_is hani}', ""); +Expect(0, 11929, '\p{^_is hani}', ""); +Expect(0, 11929, '\P{_is hani}', ""); +Expect(1, 11929, '\P{^_is hani}', ""); +Expect(0, 11903, '\p{_is hani}', ""); +Expect(1, 11903, '\p{^_is hani}', ""); +Expect(1, 11903, '\P{_is hani}', ""); +Expect(0, 11903, '\P{^_is hani}', ""); +Error('\p{ /a/Hanunoo}'); +Error('\P{ /a/Hanunoo}'); +Expect(1, 5940, '\p{hanunoo}', ""); +Expect(0, 5940, '\p{^hanunoo}', ""); +Expect(0, 5940, '\P{hanunoo}', ""); +Expect(1, 5940, '\P{^hanunoo}', ""); +Expect(0, 5919, '\p{hanunoo}', ""); +Expect(1, 5919, '\p{^hanunoo}', ""); +Expect(1, 5919, '\P{hanunoo}', ""); +Expect(0, 5919, '\P{^hanunoo}', ""); +Expect(1, 5940, '\p{ _Hanunoo}', ""); +Expect(0, 5940, '\p{^ _Hanunoo}', ""); +Expect(0, 5940, '\P{ _Hanunoo}', ""); +Expect(1, 5940, '\P{^ _Hanunoo}', ""); +Expect(0, 5919, '\p{ _Hanunoo}', ""); +Expect(1, 5919, '\p{^ _Hanunoo}', ""); +Expect(1, 5919, '\P{ _Hanunoo}', ""); +Expect(0, 5919, '\P{^ _Hanunoo}', ""); +Error('\p{/a/ _isHanunoo}'); +Error('\P{/a/ _isHanunoo}'); +Expect(1, 5940, '\p{ishanunoo}', ""); +Expect(0, 5940, '\p{^ishanunoo}', ""); +Expect(0, 5940, '\P{ishanunoo}', ""); +Expect(1, 5940, '\P{^ishanunoo}', ""); +Expect(0, 5919, '\p{ishanunoo}', ""); +Expect(1, 5919, '\p{^ishanunoo}', ""); +Expect(1, 5919, '\P{ishanunoo}', ""); +Expect(0, 5919, '\P{^ishanunoo}', ""); +Expect(1, 5940, '\p{ -Is Hanunoo}', ""); +Expect(0, 5940, '\p{^ -Is Hanunoo}', ""); +Expect(0, 5940, '\P{ -Is Hanunoo}', ""); +Expect(1, 5940, '\P{^ -Is Hanunoo}', ""); +Expect(0, 5919, '\p{ -Is Hanunoo}', ""); +Expect(1, 5919, '\p{^ -Is Hanunoo}', ""); +Expect(1, 5919, '\P{ -Is Hanunoo}', ""); +Expect(0, 5919, '\P{^ -Is Hanunoo}', ""); +Error('\p{_:=Hano}'); +Error('\P{_:=Hano}'); +Expect(1, 5940, '\p{hano}', ""); +Expect(0, 5940, '\p{^hano}', ""); +Expect(0, 5940, '\P{hano}', ""); +Expect(1, 5940, '\P{^hano}', ""); +Expect(0, 5919, '\p{hano}', ""); +Expect(1, 5919, '\p{^hano}', ""); +Expect(1, 5919, '\P{hano}', ""); +Expect(0, 5919, '\P{^hano}', ""); +Expect(1, 5940, '\p{Hano}', ""); +Expect(0, 5940, '\p{^Hano}', ""); +Expect(0, 5940, '\P{Hano}', ""); +Expect(1, 5940, '\P{^Hano}', ""); +Expect(0, 5919, '\p{Hano}', ""); +Expect(1, 5919, '\p{^Hano}', ""); +Expect(1, 5919, '\P{Hano}', ""); +Expect(0, 5919, '\P{^Hano}', ""); +Error('\p{:=- Is_Hano}'); +Error('\P{:=- Is_Hano}'); +Expect(1, 5940, '\p{ishano}', ""); +Expect(0, 5940, '\p{^ishano}', ""); +Expect(0, 5940, '\P{ishano}', ""); +Expect(1, 5940, '\P{^ishano}', ""); +Expect(0, 5919, '\p{ishano}', ""); +Expect(1, 5919, '\p{^ishano}', ""); +Expect(1, 5919, '\P{ishano}', ""); +Expect(0, 5919, '\P{^ishano}', ""); +Expect(1, 5940, '\p{ ISHano}', ""); +Expect(0, 5940, '\p{^ ISHano}', ""); +Expect(0, 5940, '\P{ ISHano}', ""); +Expect(1, 5940, '\P{^ ISHano}', ""); +Expect(0, 5919, '\p{ ISHano}', ""); +Expect(1, 5919, '\p{^ ISHano}', ""); +Expect(1, 5919, '\P{ ISHano}', ""); +Expect(0, 5919, '\P{^ ISHano}', ""); +Error('\p{/a/_VertSpace}'); +Error('\P{/a/_VertSpace}'); +Expect(1, 13, '\p{vertspace}', ""); +Expect(0, 13, '\p{^vertspace}', ""); +Expect(0, 13, '\P{vertspace}', ""); +Expect(1, 13, '\P{^vertspace}', ""); +Expect(0, 9, '\p{vertspace}', ""); +Expect(1, 9, '\p{^vertspace}', ""); +Expect(1, 9, '\P{vertspace}', ""); +Expect(0, 9, '\P{^vertspace}', ""); +Expect(1, 13, '\p{VertSpace}', ""); +Expect(0, 13, '\p{^VertSpace}', ""); +Expect(0, 13, '\P{VertSpace}', ""); +Expect(1, 13, '\P{^VertSpace}', ""); +Expect(0, 9, '\p{VertSpace}', ""); +Expect(1, 9, '\p{^VertSpace}', ""); +Expect(1, 9, '\P{VertSpace}', ""); +Expect(0, 9, '\P{^VertSpace}', ""); +Error('\p{ isVERTSPACE:=}'); +Error('\P{ isVERTSPACE:=}'); +Expect(1, 13, '\p{isvertspace}', ""); +Expect(0, 13, '\p{^isvertspace}', ""); +Expect(0, 13, '\P{isvertspace}', ""); +Expect(1, 13, '\P{^isvertspace}', ""); +Expect(0, 9, '\p{isvertspace}', ""); +Expect(1, 9, '\p{^isvertspace}', ""); +Expect(1, 9, '\P{isvertspace}', ""); +Expect(0, 9, '\P{^isvertspace}', ""); +Expect(1, 13, '\p{ ISVertSpace}', ""); +Expect(0, 13, '\p{^ ISVertSpace}', ""); +Expect(0, 13, '\P{ ISVertSpace}', ""); +Expect(1, 13, '\P{^ ISVertSpace}', ""); +Expect(0, 9, '\p{ ISVertSpace}', ""); +Expect(1, 9, '\p{^ ISVertSpace}', ""); +Expect(1, 9, '\P{ ISVertSpace}', ""); +Expect(0, 9, '\P{^ ISVertSpace}', ""); +Error('\p{ :=Letterlike Symbols}'); +Error('\P{ :=Letterlike Symbols}'); +Expect(1, 8527, '\p{letterlikesymbols}', ""); +Expect(0, 8527, '\p{^letterlikesymbols}', ""); +Expect(0, 8527, '\P{letterlikesymbols}', ""); +Expect(1, 8527, '\P{^letterlikesymbols}', ""); +Expect(0, 8447, '\p{letterlikesymbols}', ""); +Expect(1, 8447, '\p{^letterlikesymbols}', ""); +Expect(1, 8447, '\P{letterlikesymbols}', ""); +Expect(0, 8447, '\P{^letterlikesymbols}', ""); +Expect(1, 8527, '\p{_Letterlike symbols}', ""); +Expect(0, 8527, '\p{^_Letterlike symbols}', ""); +Expect(0, 8527, '\P{_Letterlike symbols}', ""); +Expect(1, 8527, '\P{^_Letterlike symbols}', ""); +Expect(0, 8447, '\p{_Letterlike symbols}', ""); +Expect(1, 8447, '\p{^_Letterlike symbols}', ""); +Expect(1, 8447, '\P{_Letterlike symbols}', ""); +Expect(0, 8447, '\P{^_Letterlike symbols}', ""); +Error('\p{ -Is-Letterlike/a/symbols}'); +Error('\P{ -Is-Letterlike/a/symbols}'); +Expect(1, 8527, '\p{isletterlikesymbols}', ""); +Expect(0, 8527, '\p{^isletterlikesymbols}', ""); +Expect(0, 8527, '\P{isletterlikesymbols}', ""); +Expect(1, 8527, '\P{^isletterlikesymbols}', ""); +Expect(0, 8447, '\p{isletterlikesymbols}', ""); +Expect(1, 8447, '\p{^isletterlikesymbols}', ""); +Expect(1, 8447, '\P{isletterlikesymbols}', ""); +Expect(0, 8447, '\P{^isletterlikesymbols}', ""); +Expect(1, 8527, '\p{-isLETTERLIKEsymbols}', ""); +Expect(0, 8527, '\p{^-isLETTERLIKEsymbols}', ""); +Expect(0, 8527, '\P{-isLETTERLIKEsymbols}', ""); +Expect(1, 8527, '\P{^-isLETTERLIKEsymbols}', ""); +Expect(0, 8447, '\p{-isLETTERLIKEsymbols}', ""); +Expect(1, 8447, '\p{^-isLETTERLIKEsymbols}', ""); +Expect(1, 8447, '\P{-isLETTERLIKEsymbols}', ""); +Expect(0, 8447, '\P{^-isLETTERLIKEsymbols}', ""); +Error('\p{_ in:=Letterlike_SYMBOLS}'); +Error('\P{_ in:=Letterlike_SYMBOLS}'); +Expect(1, 8527, '\p{inletterlikesymbols}', ""); +Expect(0, 8527, '\p{^inletterlikesymbols}', ""); +Expect(0, 8527, '\P{inletterlikesymbols}', ""); +Expect(1, 8527, '\P{^inletterlikesymbols}', ""); +Expect(0, 8447, '\p{inletterlikesymbols}', ""); +Expect(1, 8447, '\p{^inletterlikesymbols}', ""); +Expect(1, 8447, '\P{inletterlikesymbols}', ""); +Expect(0, 8447, '\P{^inletterlikesymbols}', ""); +Expect(1, 8527, '\p{_-IN_letterlike Symbols}', ""); +Expect(0, 8527, '\p{^_-IN_letterlike Symbols}', ""); +Expect(0, 8527, '\P{_-IN_letterlike Symbols}', ""); +Expect(1, 8527, '\P{^_-IN_letterlike Symbols}', ""); +Expect(0, 8447, '\p{_-IN_letterlike Symbols}', ""); +Expect(1, 8447, '\p{^_-IN_letterlike Symbols}', ""); +Expect(1, 8447, '\P{_-IN_letterlike Symbols}', ""); +Expect(0, 8447, '\P{^_-IN_letterlike Symbols}', ""); +Error('\p{- In Mongolian/a/}'); +Error('\P{- In Mongolian/a/}'); +Expect(1, 6319, '\p{inmongolian}', ""); +Expect(0, 6319, '\p{^inmongolian}', ""); +Expect(0, 6319, '\P{inmongolian}', ""); +Expect(1, 6319, '\P{^inmongolian}', ""); +Expect(0, 6143, '\p{inmongolian}', ""); +Expect(1, 6143, '\p{^inmongolian}', ""); +Expect(1, 6143, '\P{inmongolian}', ""); +Expect(0, 6143, '\P{^inmongolian}', ""); +Expect(1, 6319, '\p{ IN mongolian}', ""); +Expect(0, 6319, '\p{^ IN mongolian}', ""); +Expect(0, 6319, '\P{ IN mongolian}', ""); +Expect(1, 6319, '\P{^ IN mongolian}', ""); +Expect(0, 6143, '\p{ IN mongolian}', ""); +Expect(1, 6143, '\p{^ IN mongolian}', ""); +Expect(1, 6143, '\P{ IN mongolian}', ""); +Expect(0, 6143, '\P{^ IN mongolian}', ""); +Error('\p{/a/IDEOGRAPHIC}'); +Error('\P{/a/IDEOGRAPHIC}'); +Expect(1, 12295, '\p{ideographic}', ""); +Expect(0, 12295, '\p{^ideographic}', ""); +Expect(0, 12295, '\P{ideographic}', ""); +Expect(1, 12295, '\P{^ideographic}', ""); +Expect(0, 12293, '\p{ideographic}', ""); +Expect(1, 12293, '\p{^ideographic}', ""); +Expect(1, 12293, '\P{ideographic}', ""); +Expect(0, 12293, '\P{^ideographic}', ""); +Expect(1, 12295, '\p{_ideographic}', ""); +Expect(0, 12295, '\p{^_ideographic}', ""); +Expect(0, 12295, '\P{_ideographic}', ""); +Expect(1, 12295, '\P{^_ideographic}', ""); +Expect(0, 12293, '\p{_ideographic}', ""); +Expect(1, 12293, '\p{^_ideographic}', ""); +Expect(1, 12293, '\P{_ideographic}', ""); +Expect(0, 12293, '\P{^_ideographic}', ""); +Error('\p{_Is/a/ideographic}'); +Error('\P{_Is/a/ideographic}'); +Expect(1, 12295, '\p{isideographic}', ""); +Expect(0, 12295, '\p{^isideographic}', ""); +Expect(0, 12295, '\P{isideographic}', ""); +Expect(1, 12295, '\P{^isideographic}', ""); +Expect(0, 12293, '\p{isideographic}', ""); +Expect(1, 12293, '\p{^isideographic}', ""); +Expect(1, 12293, '\P{isideographic}', ""); +Expect(0, 12293, '\P{^isideographic}', ""); +Expect(1, 12295, '\p{_IS-Ideographic}', ""); +Expect(0, 12295, '\p{^_IS-Ideographic}', ""); +Expect(0, 12295, '\P{_IS-Ideographic}', ""); +Expect(1, 12295, '\P{^_IS-Ideographic}', ""); +Expect(0, 12293, '\p{_IS-Ideographic}', ""); +Expect(1, 12293, '\p{^_IS-Ideographic}', ""); +Expect(1, 12293, '\P{_IS-Ideographic}', ""); +Expect(0, 12293, '\P{^_IS-Ideographic}', ""); +Error('\p{:= -Ideo}'); +Error('\P{:= -Ideo}'); +Expect(1, 12295, '\p{ideo}', ""); +Expect(0, 12295, '\p{^ideo}', ""); +Expect(0, 12295, '\P{ideo}', ""); +Expect(1, 12295, '\P{^ideo}', ""); +Expect(0, 12293, '\p{ideo}', ""); +Expect(1, 12293, '\p{^ideo}', ""); +Expect(1, 12293, '\P{ideo}', ""); +Expect(0, 12293, '\P{^ideo}', ""); +Expect(1, 12295, '\p{ IDEO}', ""); +Expect(0, 12295, '\p{^ IDEO}', ""); +Expect(0, 12295, '\P{ IDEO}', ""); +Expect(1, 12295, '\P{^ IDEO}', ""); +Expect(0, 12293, '\p{ IDEO}', ""); +Expect(1, 12293, '\p{^ IDEO}', ""); +Expect(1, 12293, '\P{ IDEO}', ""); +Expect(0, 12293, '\P{^ IDEO}', ""); +Error('\p{ /a/IsIdeo}'); +Error('\P{ /a/IsIdeo}'); +Expect(1, 12295, '\p{isideo}', ""); +Expect(0, 12295, '\p{^isideo}', ""); +Expect(0, 12295, '\P{isideo}', ""); +Expect(1, 12295, '\P{^isideo}', ""); +Expect(0, 12293, '\p{isideo}', ""); +Expect(1, 12293, '\p{^isideo}', ""); +Expect(1, 12293, '\P{isideo}', ""); +Expect(0, 12293, '\P{^isideo}', ""); +Expect(1, 12295, '\p{- Is Ideo}', ""); +Expect(0, 12295, '\p{^- Is Ideo}', ""); +Expect(0, 12295, '\P{- Is Ideo}', ""); +Expect(1, 12295, '\P{^- Is Ideo}', ""); +Expect(0, 12293, '\p{- Is Ideo}', ""); +Expect(1, 12293, '\p{^- Is Ideo}', ""); +Expect(1, 12293, '\P{- Is Ideo}', ""); +Expect(0, 12293, '\P{^- Is Ideo}', ""); +Error('\p{ /a/variation-selectors supplement}'); +Error('\P{ /a/variation-selectors supplement}'); +Expect(1, 917999, '\p{variationselectorssupplement}', ""); +Expect(0, 917999, '\p{^variationselectorssupplement}', ""); +Expect(0, 917999, '\P{variationselectorssupplement}', ""); +Expect(1, 917999, '\P{^variationselectorssupplement}', ""); +Expect(0, 917759, '\p{variationselectorssupplement}', ""); +Expect(1, 917759, '\p{^variationselectorssupplement}', ""); +Expect(1, 917759, '\P{variationselectorssupplement}', ""); +Expect(0, 917759, '\P{^variationselectorssupplement}', ""); +Expect(1, 917999, '\p{ _Variation_SELECTORS Supplement}', ""); +Expect(0, 917999, '\p{^ _Variation_SELECTORS Supplement}', ""); +Expect(0, 917999, '\P{ _Variation_SELECTORS Supplement}', ""); +Expect(1, 917999, '\P{^ _Variation_SELECTORS Supplement}', ""); +Expect(0, 917759, '\p{ _Variation_SELECTORS Supplement}', ""); +Expect(1, 917759, '\p{^ _Variation_SELECTORS Supplement}', ""); +Expect(1, 917759, '\P{ _Variation_SELECTORS Supplement}', ""); +Expect(0, 917759, '\P{^ _Variation_SELECTORS Supplement}', ""); +Error('\p{ :=Is-Variation Selectors-Supplement}'); +Error('\P{ :=Is-Variation Selectors-Supplement}'); +Expect(1, 917999, '\p{isvariationselectorssupplement}', ""); +Expect(0, 917999, '\p{^isvariationselectorssupplement}', ""); +Expect(0, 917999, '\P{isvariationselectorssupplement}', ""); +Expect(1, 917999, '\P{^isvariationselectorssupplement}', ""); +Expect(0, 917759, '\p{isvariationselectorssupplement}', ""); +Expect(1, 917759, '\p{^isvariationselectorssupplement}', ""); +Expect(1, 917759, '\P{isvariationselectorssupplement}', ""); +Expect(0, 917759, '\P{^isvariationselectorssupplement}', ""); +Expect(1, 917999, '\p{ Is_Variation Selectors supplement}', ""); +Expect(0, 917999, '\p{^ Is_Variation Selectors supplement}', ""); +Expect(0, 917999, '\P{ Is_Variation Selectors supplement}', ""); +Expect(1, 917999, '\P{^ Is_Variation Selectors supplement}', ""); +Expect(0, 917759, '\p{ Is_Variation Selectors supplement}', ""); +Expect(1, 917759, '\p{^ Is_Variation Selectors supplement}', ""); +Expect(1, 917759, '\P{ Is_Variation Selectors supplement}', ""); +Expect(0, 917759, '\P{^ Is_Variation Selectors supplement}', ""); +Error('\p{ IN_variation/a/SELECTORS_supplement}'); +Error('\P{ IN_variation/a/SELECTORS_supplement}'); +Expect(1, 917999, '\p{invariationselectorssupplement}', ""); +Expect(0, 917999, '\p{^invariationselectorssupplement}', ""); +Expect(0, 917999, '\P{invariationselectorssupplement}', ""); +Expect(1, 917999, '\P{^invariationselectorssupplement}', ""); +Expect(0, 917759, '\p{invariationselectorssupplement}', ""); +Expect(1, 917759, '\p{^invariationselectorssupplement}', ""); +Expect(1, 917759, '\P{invariationselectorssupplement}', ""); +Expect(0, 917759, '\P{^invariationselectorssupplement}', ""); +Expect(1, 917999, '\p{ -InvariationSelectors SUPPLEMENT}', ""); +Expect(0, 917999, '\p{^ -InvariationSelectors SUPPLEMENT}', ""); +Expect(0, 917999, '\P{ -InvariationSelectors SUPPLEMENT}', ""); +Expect(1, 917999, '\P{^ -InvariationSelectors SUPPLEMENT}', ""); +Expect(0, 917759, '\p{ -InvariationSelectors SUPPLEMENT}', ""); +Expect(1, 917759, '\p{^ -InvariationSelectors SUPPLEMENT}', ""); +Expect(1, 917759, '\P{ -InvariationSelectors SUPPLEMENT}', ""); +Expect(0, 917759, '\P{^ -InvariationSelectors SUPPLEMENT}', ""); +Error('\p{_:=In_thaana}'); +Error('\P{_:=In_thaana}'); +Expect(1, 1983, '\p{inthaana}', ""); +Expect(0, 1983, '\p{^inthaana}', ""); +Expect(0, 1983, '\P{inthaana}', ""); +Expect(1, 1983, '\P{^inthaana}', ""); +Expect(0, 1919, '\p{inthaana}', ""); +Expect(1, 1919, '\p{^inthaana}', ""); +Expect(1, 1919, '\P{inthaana}', ""); +Expect(0, 1919, '\P{^inthaana}', ""); +Expect(1, 1983, '\p{_-In-Thaana}', ""); +Expect(0, 1983, '\p{^_-In-Thaana}', ""); +Expect(0, 1983, '\P{_-In-Thaana}', ""); +Expect(1, 1983, '\P{^_-In-Thaana}', ""); +Expect(0, 1919, '\p{_-In-Thaana}', ""); +Expect(1, 1919, '\p{^_-In-Thaana}', ""); +Expect(1, 1919, '\P{_-In-Thaana}', ""); +Expect(0, 1919, '\P{^_-In-Thaana}', ""); +Error('\p{:=_-Supplemental ARROWS-a}'); +Error('\P{:=_-Supplemental ARROWS-a}'); +Expect(1, 10239, '\p{supplementalarrowsa}', ""); +Expect(0, 10239, '\p{^supplementalarrowsa}', ""); +Expect(0, 10239, '\P{supplementalarrowsa}', ""); +Expect(1, 10239, '\P{^supplementalarrowsa}', ""); +Expect(0, 10223, '\p{supplementalarrowsa}', ""); +Expect(1, 10223, '\p{^supplementalarrowsa}', ""); +Expect(1, 10223, '\P{supplementalarrowsa}', ""); +Expect(0, 10223, '\P{^supplementalarrowsa}', ""); +Expect(1, 10239, '\p{-Supplemental arrows a}', ""); +Expect(0, 10239, '\p{^-Supplemental arrows a}', ""); +Expect(0, 10239, '\P{-Supplemental arrows a}', ""); +Expect(1, 10239, '\P{^-Supplemental arrows a}', ""); +Expect(0, 10223, '\p{-Supplemental arrows a}', ""); +Expect(1, 10223, '\p{^-Supplemental arrows a}', ""); +Expect(1, 10223, '\P{-Supplemental arrows a}', ""); +Expect(0, 10223, '\P{^-Supplemental arrows a}', ""); +Error('\p{ :=is Supplemental-arrows_A}'); +Error('\P{ :=is Supplemental-arrows_A}'); +Expect(1, 10239, '\p{issupplementalarrowsa}', ""); +Expect(0, 10239, '\p{^issupplementalarrowsa}', ""); +Expect(0, 10239, '\P{issupplementalarrowsa}', ""); +Expect(1, 10239, '\P{^issupplementalarrowsa}', ""); +Expect(0, 10223, '\p{issupplementalarrowsa}', ""); +Expect(1, 10223, '\p{^issupplementalarrowsa}', ""); +Expect(1, 10223, '\P{issupplementalarrowsa}', ""); +Expect(0, 10223, '\P{^issupplementalarrowsa}', ""); +Expect(1, 10239, '\p{-Is_SUPPLEMENTAL arrows a}', ""); +Expect(0, 10239, '\p{^-Is_SUPPLEMENTAL arrows a}', ""); +Expect(0, 10239, '\P{-Is_SUPPLEMENTAL arrows a}', ""); +Expect(1, 10239, '\P{^-Is_SUPPLEMENTAL arrows a}', ""); +Expect(0, 10223, '\p{-Is_SUPPLEMENTAL arrows a}', ""); +Expect(1, 10223, '\p{^-Is_SUPPLEMENTAL arrows a}', ""); +Expect(1, 10223, '\P{-Is_SUPPLEMENTAL arrows a}', ""); +Expect(0, 10223, '\P{^-Is_SUPPLEMENTAL arrows a}', ""); +Error('\p{ IN:=SUPPLEMENTAL Arrows-A}'); +Error('\P{ IN:=SUPPLEMENTAL Arrows-A}'); +Expect(1, 10239, '\p{insupplementalarrowsa}', ""); +Expect(0, 10239, '\p{^insupplementalarrowsa}', ""); +Expect(0, 10239, '\P{insupplementalarrowsa}', ""); +Expect(1, 10239, '\P{^insupplementalarrowsa}', ""); +Expect(0, 10223, '\p{insupplementalarrowsa}', ""); +Expect(1, 10223, '\p{^insupplementalarrowsa}', ""); +Expect(1, 10223, '\P{insupplementalarrowsa}', ""); +Expect(0, 10223, '\P{^insupplementalarrowsa}', ""); +Expect(1, 10239, '\p{ -In_supplemental-Arrows_A}', ""); +Expect(0, 10239, '\p{^ -In_supplemental-Arrows_A}', ""); +Expect(0, 10239, '\P{ -In_supplemental-Arrows_A}', ""); +Expect(1, 10239, '\P{^ -In_supplemental-Arrows_A}', ""); +Expect(0, 10223, '\p{ -In_supplemental-Arrows_A}', ""); +Expect(1, 10223, '\p{^ -In_supplemental-Arrows_A}', ""); +Expect(1, 10223, '\P{ -In_supplemental-Arrows_A}', ""); +Expect(0, 10223, '\P{^ -In_supplemental-Arrows_A}', ""); +Error('\p{:=_-IN-SYRIAC}'); +Error('\P{:=_-IN-SYRIAC}'); +Expect(1, 1871, '\p{insyriac}', ""); +Expect(0, 1871, '\p{^insyriac}', ""); +Expect(0, 1871, '\P{insyriac}', ""); +Expect(1, 1871, '\P{^insyriac}', ""); +Expect(0, 1791, '\p{insyriac}', ""); +Expect(1, 1791, '\p{^insyriac}', ""); +Expect(1, 1791, '\P{insyriac}', ""); +Expect(0, 1791, '\P{^insyriac}', ""); +Expect(1, 1871, '\p{ in-Syriac}', ""); +Expect(0, 1871, '\p{^ in-Syriac}', ""); +Expect(0, 1871, '\P{ in-Syriac}', ""); +Expect(1, 1871, '\P{^ in-Syriac}', ""); +Expect(0, 1791, '\p{ in-Syriac}', ""); +Expect(1, 1791, '\p{^ in-Syriac}', ""); +Expect(1, 1791, '\P{ in-Syriac}', ""); +Expect(0, 1791, '\P{^ in-Syriac}', ""); +Error('\p{ :=Ethiopic_extended}'); +Error('\P{ :=Ethiopic_extended}'); +Expect(1, 11743, '\p{ethiopicextended}', ""); +Expect(0, 11743, '\p{^ethiopicextended}', ""); +Expect(0, 11743, '\P{ethiopicextended}', ""); +Expect(1, 11743, '\P{^ethiopicextended}', ""); +Expect(0, 11647, '\p{ethiopicextended}', ""); +Expect(1, 11647, '\p{^ethiopicextended}', ""); +Expect(1, 11647, '\P{ethiopicextended}', ""); +Expect(0, 11647, '\P{^ethiopicextended}', ""); +Expect(1, 11743, '\p{ ethiopic_Extended}', ""); +Expect(0, 11743, '\p{^ ethiopic_Extended}', ""); +Expect(0, 11743, '\P{ ethiopic_Extended}', ""); +Expect(1, 11743, '\P{^ ethiopic_Extended}', ""); +Expect(0, 11647, '\p{ ethiopic_Extended}', ""); +Expect(1, 11647, '\p{^ ethiopic_Extended}', ""); +Expect(1, 11647, '\P{ ethiopic_Extended}', ""); +Expect(0, 11647, '\P{^ ethiopic_Extended}', ""); +Error('\p{-:=IsEthiopicextended}'); +Error('\P{-:=IsEthiopicextended}'); +Expect(1, 11743, '\p{isethiopicextended}', ""); +Expect(0, 11743, '\p{^isethiopicextended}', ""); +Expect(0, 11743, '\P{isethiopicextended}', ""); +Expect(1, 11743, '\P{^isethiopicextended}', ""); +Expect(0, 11647, '\p{isethiopicextended}', ""); +Expect(1, 11647, '\p{^isethiopicextended}', ""); +Expect(1, 11647, '\P{isethiopicextended}', ""); +Expect(0, 11647, '\P{^isethiopicextended}', ""); +Expect(1, 11743, '\p{Is ethiopic Extended}', ""); +Expect(0, 11743, '\p{^Is ethiopic Extended}', ""); +Expect(0, 11743, '\P{Is ethiopic Extended}', ""); +Expect(1, 11743, '\P{^Is ethiopic Extended}', ""); +Expect(0, 11647, '\p{Is ethiopic Extended}', ""); +Expect(1, 11647, '\p{^Is ethiopic Extended}', ""); +Expect(1, 11647, '\P{Is ethiopic Extended}', ""); +Expect(0, 11647, '\P{^Is ethiopic Extended}', ""); +Error('\p{-/a/InEthiopic-extended}'); +Error('\P{-/a/InEthiopic-extended}'); +Expect(1, 11743, '\p{inethiopicextended}', ""); +Expect(0, 11743, '\p{^inethiopicextended}', ""); +Expect(0, 11743, '\P{inethiopicextended}', ""); +Expect(1, 11743, '\P{^inethiopicextended}', ""); +Expect(0, 11647, '\p{inethiopicextended}', ""); +Expect(1, 11647, '\p{^inethiopicextended}', ""); +Expect(1, 11647, '\P{inethiopicextended}', ""); +Expect(0, 11647, '\P{^inethiopicextended}', ""); +Expect(1, 11743, '\p{_ In Ethiopic EXTENDED}', ""); +Expect(0, 11743, '\p{^_ In Ethiopic EXTENDED}', ""); +Expect(0, 11743, '\P{_ In Ethiopic EXTENDED}', ""); +Expect(1, 11743, '\P{^_ In Ethiopic EXTENDED}', ""); +Expect(0, 11647, '\p{_ In Ethiopic EXTENDED}', ""); +Expect(1, 11647, '\p{^_ In Ethiopic EXTENDED}', ""); +Expect(1, 11647, '\P{_ In Ethiopic EXTENDED}', ""); +Expect(0, 11647, '\P{^_ In Ethiopic EXTENDED}', ""); +Error('\p{Phoenician/a/}'); +Error('\P{Phoenician/a/}'); +Expect(1, 67865, '\p{phoenician}', ""); +Expect(0, 67865, '\p{^phoenician}', ""); +Expect(0, 67865, '\P{phoenician}', ""); +Expect(1, 67865, '\P{^phoenician}', ""); +Expect(0, 67839, '\p{phoenician}', ""); +Expect(1, 67839, '\p{^phoenician}', ""); +Expect(1, 67839, '\P{phoenician}', ""); +Expect(0, 67839, '\P{^phoenician}', ""); +Expect(1, 67865, '\p{-_phoenician}', ""); +Expect(0, 67865, '\p{^-_phoenician}', ""); +Expect(0, 67865, '\P{-_phoenician}', ""); +Expect(1, 67865, '\P{^-_phoenician}', ""); +Expect(0, 67839, '\p{-_phoenician}', ""); +Expect(1, 67839, '\p{^-_phoenician}', ""); +Expect(1, 67839, '\P{-_phoenician}', ""); +Expect(0, 67839, '\P{^-_phoenician}', ""); +Error('\p{/a/_ ISPhoenician}'); +Error('\P{/a/_ ISPhoenician}'); +Expect(1, 67865, '\p{isphoenician}', ""); +Expect(0, 67865, '\p{^isphoenician}', ""); +Expect(0, 67865, '\P{isphoenician}', ""); +Expect(1, 67865, '\P{^isphoenician}', ""); +Expect(0, 67839, '\p{isphoenician}', ""); +Expect(1, 67839, '\p{^isphoenician}', ""); +Expect(1, 67839, '\P{isphoenician}', ""); +Expect(0, 67839, '\P{^isphoenician}', ""); +Expect(1, 67865, '\p{_Is_Phoenician}', ""); +Expect(0, 67865, '\p{^_Is_Phoenician}', ""); +Expect(0, 67865, '\P{_Is_Phoenician}', ""); +Expect(1, 67865, '\P{^_Is_Phoenician}', ""); +Expect(0, 67839, '\p{_Is_Phoenician}', ""); +Expect(1, 67839, '\p{^_Is_Phoenician}', ""); +Expect(1, 67839, '\P{_Is_Phoenician}', ""); +Expect(0, 67839, '\P{^_Is_Phoenician}', ""); +Error('\p{/a/-PHNX}'); +Error('\P{/a/-PHNX}'); +Expect(1, 67865, '\p{phnx}', ""); +Expect(0, 67865, '\p{^phnx}', ""); +Expect(0, 67865, '\P{phnx}', ""); +Expect(1, 67865, '\P{^phnx}', ""); +Expect(0, 67839, '\p{phnx}', ""); +Expect(1, 67839, '\p{^phnx}', ""); +Expect(1, 67839, '\P{phnx}', ""); +Expect(0, 67839, '\P{^phnx}', ""); +Expect(1, 67865, '\p{-Phnx}', ""); +Expect(0, 67865, '\p{^-Phnx}', ""); +Expect(0, 67865, '\P{-Phnx}', ""); +Expect(1, 67865, '\P{^-Phnx}', ""); +Expect(0, 67839, '\p{-Phnx}', ""); +Expect(1, 67839, '\p{^-Phnx}', ""); +Expect(1, 67839, '\P{-Phnx}', ""); +Expect(0, 67839, '\P{^-Phnx}', ""); +Error('\p{_ Is Phnx/a/}'); +Error('\P{_ Is Phnx/a/}'); +Expect(1, 67865, '\p{isphnx}', ""); +Expect(0, 67865, '\p{^isphnx}', ""); +Expect(0, 67865, '\P{isphnx}', ""); +Expect(1, 67865, '\P{^isphnx}', ""); +Expect(0, 67839, '\p{isphnx}', ""); +Expect(1, 67839, '\p{^isphnx}', ""); +Expect(1, 67839, '\P{isphnx}', ""); +Expect(0, 67839, '\P{^isphnx}', ""); +Expect(1, 67865, '\p{ IS Phnx}', ""); +Expect(0, 67865, '\p{^ IS Phnx}', ""); +Expect(0, 67865, '\P{ IS Phnx}', ""); +Expect(1, 67865, '\P{^ IS Phnx}', ""); +Expect(0, 67839, '\p{ IS Phnx}', ""); +Expect(1, 67839, '\p{^ IS Phnx}', ""); +Expect(1, 67839, '\P{ IS Phnx}', ""); +Expect(0, 67839, '\P{^ IS Phnx}', ""); +Error('\p{/a/ -Runic}'); +Error('\P{/a/ -Runic}'); +Expect(1, 5866, '\p{runic}', ""); +Expect(0, 5866, '\p{^runic}', ""); +Expect(0, 5866, '\P{runic}', ""); +Expect(1, 5866, '\P{^runic}', ""); +Expect(0, 5791, '\p{runic}', ""); +Expect(1, 5791, '\p{^runic}', ""); +Expect(1, 5791, '\P{runic}', ""); +Expect(0, 5791, '\P{^runic}', ""); +Expect(1, 5866, '\p{--Runic}', ""); +Expect(0, 5866, '\p{^--Runic}', ""); +Expect(0, 5866, '\P{--Runic}', ""); +Expect(1, 5866, '\P{^--Runic}', ""); +Expect(0, 5791, '\p{--Runic}', ""); +Expect(1, 5791, '\p{^--Runic}', ""); +Expect(1, 5791, '\P{--Runic}', ""); +Expect(0, 5791, '\P{^--Runic}', ""); +Error('\p{ IS runic/a/}'); +Error('\P{ IS runic/a/}'); +Expect(1, 5866, '\p{isrunic}', ""); +Expect(0, 5866, '\p{^isrunic}', ""); +Expect(0, 5866, '\P{isrunic}', ""); +Expect(1, 5866, '\P{^isrunic}', ""); +Expect(0, 5791, '\p{isrunic}', ""); +Expect(1, 5791, '\p{^isrunic}', ""); +Expect(1, 5791, '\P{isrunic}', ""); +Expect(0, 5791, '\P{^isrunic}', ""); +Expect(1, 5866, '\p{-Isrunic}', ""); +Expect(0, 5866, '\p{^-Isrunic}', ""); +Expect(0, 5866, '\P{-Isrunic}', ""); +Expect(1, 5866, '\P{^-Isrunic}', ""); +Expect(0, 5791, '\p{-Isrunic}', ""); +Expect(1, 5791, '\p{^-Isrunic}', ""); +Expect(1, 5791, '\P{-Isrunic}', ""); +Expect(0, 5791, '\P{^-Isrunic}', ""); +Error('\p{__Runr:=}'); +Error('\P{__Runr:=}'); +Expect(1, 5866, '\p{runr}', ""); +Expect(0, 5866, '\p{^runr}', ""); +Expect(0, 5866, '\P{runr}', ""); +Expect(1, 5866, '\P{^runr}', ""); +Expect(0, 5791, '\p{runr}', ""); +Expect(1, 5791, '\p{^runr}', ""); +Expect(1, 5791, '\P{runr}', ""); +Expect(0, 5791, '\P{^runr}', ""); +Expect(1, 5866, '\p{__Runr}', ""); +Expect(0, 5866, '\p{^__Runr}', ""); +Expect(0, 5866, '\P{__Runr}', ""); +Expect(1, 5866, '\P{^__Runr}', ""); +Expect(0, 5791, '\p{__Runr}', ""); +Expect(1, 5791, '\p{^__Runr}', ""); +Expect(1, 5791, '\P{__Runr}', ""); +Expect(0, 5791, '\P{^__Runr}', ""); +Error('\p{_-is/a/runr}'); +Error('\P{_-is/a/runr}'); +Expect(1, 5866, '\p{isrunr}', ""); +Expect(0, 5866, '\p{^isrunr}', ""); +Expect(0, 5866, '\P{isrunr}', ""); +Expect(1, 5866, '\P{^isrunr}', ""); +Expect(0, 5791, '\p{isrunr}', ""); +Expect(1, 5791, '\p{^isrunr}', ""); +Expect(1, 5791, '\P{isrunr}', ""); +Expect(0, 5791, '\P{^isrunr}', ""); +Expect(1, 5866, '\p{ _Is-Runr}', ""); +Expect(0, 5866, '\p{^ _Is-Runr}', ""); +Expect(0, 5866, '\P{ _Is-Runr}', ""); +Expect(1, 5866, '\P{^ _Is-Runr}', ""); +Expect(0, 5791, '\p{ _Is-Runr}', ""); +Expect(1, 5791, '\p{^ _Is-Runr}', ""); +Expect(1, 5791, '\P{ _Is-Runr}', ""); +Expect(0, 5791, '\P{^ _Is-Runr}', ""); +Error('\p{ HIGH:=Private_USE surrogates}'); +Error('\P{ HIGH:=Private_USE surrogates}'); +Expect(0, 7, '\p{highprivateusesurrogates}', ""); +Expect(1, 7, '\p{^highprivateusesurrogates}', ""); +Expect(1, 7, '\P{highprivateusesurrogates}', ""); +Expect(0, 7, '\P{^highprivateusesurrogates}', ""); +Expect(0, 7, '\p{_HighPrivate Use Surrogates}', ""); +Expect(1, 7, '\p{^_HighPrivate Use Surrogates}', ""); +Expect(1, 7, '\P{_HighPrivate Use Surrogates}', ""); +Expect(0, 7, '\P{^_HighPrivate Use Surrogates}', ""); +Error('\p{:= IS HIGH Private-Use-SURROGATES}'); +Error('\P{:= IS HIGH Private-Use-SURROGATES}'); +Expect(0, 7, '\p{ishighprivateusesurrogates}', ""); +Expect(1, 7, '\p{^ishighprivateusesurrogates}', ""); +Expect(1, 7, '\P{ishighprivateusesurrogates}', ""); +Expect(0, 7, '\P{^ishighprivateusesurrogates}', ""); +Expect(0, 7, '\p{-IS_highPRIVATE_Use surrogates}', ""); +Expect(1, 7, '\p{^-IS_highPRIVATE_Use surrogates}', ""); +Expect(1, 7, '\P{-IS_highPRIVATE_Use surrogates}', ""); +Expect(0, 7, '\P{^-IS_highPRIVATE_Use surrogates}', ""); +Error('\p{ In/a/HIGH PRIVATE Use-SURROGATES}'); +Error('\P{ In/a/HIGH PRIVATE Use-SURROGATES}'); +Expect(0, 7, '\p{inhighprivateusesurrogates}', ""); +Expect(1, 7, '\p{^inhighprivateusesurrogates}', ""); +Expect(1, 7, '\P{inhighprivateusesurrogates}', ""); +Expect(0, 7, '\P{^inhighprivateusesurrogates}', ""); +Expect(0, 7, '\p{ _INHigh-PrivateUseSURROGATES}', ""); +Expect(1, 7, '\p{^ _INHigh-PrivateUseSURROGATES}', ""); +Expect(1, 7, '\P{ _INHigh-PrivateUseSURROGATES}', ""); +Expect(0, 7, '\P{^ _INHigh-PrivateUseSURROGATES}', ""); +Error('\p{ :=kayah_Li}'); +Error('\P{ :=kayah_Li}'); +Expect(1, 43311, '\p{kayahli}', ""); +Expect(0, 43311, '\p{^kayahli}', ""); +Expect(0, 43311, '\P{kayahli}', ""); +Expect(1, 43311, '\P{^kayahli}', ""); +Expect(0, 43263, '\p{kayahli}', ""); +Expect(1, 43263, '\p{^kayahli}', ""); +Expect(1, 43263, '\P{kayahli}', ""); +Expect(0, 43263, '\P{^kayahli}', ""); +Expect(1, 43311, '\p{--KayahLI}', ""); +Expect(0, 43311, '\p{^--KayahLI}', ""); +Expect(0, 43311, '\P{--KayahLI}', ""); +Expect(1, 43311, '\P{^--KayahLI}', ""); +Expect(0, 43263, '\p{--KayahLI}', ""); +Expect(1, 43263, '\p{^--KayahLI}', ""); +Expect(1, 43263, '\P{--KayahLI}', ""); +Expect(0, 43263, '\P{^--KayahLI}', ""); +Error('\p{ Is KAYAHLI/a/}'); +Error('\P{ Is KAYAHLI/a/}'); +Expect(1, 43311, '\p{iskayahli}', ""); +Expect(0, 43311, '\p{^iskayahli}', ""); +Expect(0, 43311, '\P{iskayahli}', ""); +Expect(1, 43311, '\P{^iskayahli}', ""); +Expect(0, 43263, '\p{iskayahli}', ""); +Expect(1, 43263, '\p{^iskayahli}', ""); +Expect(1, 43263, '\P{iskayahli}', ""); +Expect(0, 43263, '\P{^iskayahli}', ""); +Expect(1, 43311, '\p{_-Is kayah Li}', ""); +Expect(0, 43311, '\p{^_-Is kayah Li}', ""); +Expect(0, 43311, '\P{_-Is kayah Li}', ""); +Expect(1, 43311, '\P{^_-Is kayah Li}', ""); +Expect(0, 43263, '\p{_-Is kayah Li}', ""); +Expect(1, 43263, '\p{^_-Is kayah Li}', ""); +Expect(1, 43263, '\P{_-Is kayah Li}', ""); +Expect(0, 43263, '\P{^_-Is kayah Li}', ""); +Error('\p{:= Kali}'); +Error('\P{:= Kali}'); +Expect(1, 43311, '\p{kali}', ""); +Expect(0, 43311, '\p{^kali}', ""); +Expect(0, 43311, '\P{kali}', ""); +Expect(1, 43311, '\P{^kali}', ""); +Expect(0, 43263, '\p{kali}', ""); +Expect(1, 43263, '\p{^kali}', ""); +Expect(1, 43263, '\P{kali}', ""); +Expect(0, 43263, '\P{^kali}', ""); +Expect(1, 43311, '\p{ -Kali}', ""); +Expect(0, 43311, '\p{^ -Kali}', ""); +Expect(0, 43311, '\P{ -Kali}', ""); +Expect(1, 43311, '\P{^ -Kali}', ""); +Expect(0, 43263, '\p{ -Kali}', ""); +Expect(1, 43263, '\p{^ -Kali}', ""); +Expect(1, 43263, '\P{ -Kali}', ""); +Expect(0, 43263, '\P{^ -Kali}', ""); +Error('\p{/a/IS Kali}'); +Error('\P{/a/IS Kali}'); +Expect(1, 43311, '\p{iskali}', ""); +Expect(0, 43311, '\p{^iskali}', ""); +Expect(0, 43311, '\P{iskali}', ""); +Expect(1, 43311, '\P{^iskali}', ""); +Expect(0, 43263, '\p{iskali}', ""); +Expect(1, 43263, '\p{^iskali}', ""); +Expect(1, 43263, '\P{iskali}', ""); +Expect(0, 43263, '\P{^iskali}', ""); +Expect(1, 43311, '\p{ Is KALI}', ""); +Expect(0, 43311, '\p{^ Is KALI}', ""); +Expect(0, 43311, '\P{ Is KALI}', ""); +Expect(1, 43311, '\P{^ Is KALI}', ""); +Expect(0, 43263, '\p{ Is KALI}', ""); +Expect(1, 43263, '\p{^ Is KALI}', ""); +Expect(1, 43263, '\P{ Is KALI}', ""); +Expect(0, 43263, '\P{^ Is KALI}', ""); +Error('\p{PosixGraph/a/}'); +Error('\P{PosixGraph/a/}'); +Expect(1, 126, '\p{posixgraph}', ""); +Expect(0, 126, '\p{^posixgraph}', ""); +Expect(0, 126, '\P{posixgraph}', ""); +Expect(1, 126, '\P{^posixgraph}', ""); +Expect(0, 32, '\p{posixgraph}', ""); +Expect(1, 32, '\p{^posixgraph}', ""); +Expect(1, 32, '\P{posixgraph}', ""); +Expect(0, 32, '\P{^posixgraph}', ""); +Expect(1, 126, '\p{-POSIXGRAPH}', ""); +Expect(0, 126, '\p{^-POSIXGRAPH}', ""); +Expect(0, 126, '\P{-POSIXGRAPH}', ""); +Expect(1, 126, '\P{^-POSIXGRAPH}', ""); +Expect(0, 32, '\p{-POSIXGRAPH}', ""); +Expect(1, 32, '\p{^-POSIXGRAPH}', ""); +Expect(1, 32, '\P{-POSIXGRAPH}', ""); +Expect(0, 32, '\P{^-POSIXGRAPH}', ""); +Error('\p{ :=IS PosixGraph}'); +Error('\P{ :=IS PosixGraph}'); +Expect(1, 126, '\p{isposixgraph}', ""); +Expect(0, 126, '\p{^isposixgraph}', ""); +Expect(0, 126, '\P{isposixgraph}', ""); +Expect(1, 126, '\P{^isposixgraph}', ""); +Expect(0, 32, '\p{isposixgraph}', ""); +Expect(1, 32, '\p{^isposixgraph}', ""); +Expect(1, 32, '\P{isposixgraph}', ""); +Expect(0, 32, '\P{^isposixgraph}', ""); +Expect(1, 126, '\p{ _Is posixgraph}', ""); +Expect(0, 126, '\p{^ _Is posixgraph}', ""); +Expect(0, 126, '\P{ _Is posixgraph}', ""); +Expect(1, 126, '\P{^ _Is posixgraph}', ""); +Expect(0, 32, '\p{ _Is posixgraph}', ""); +Expect(1, 32, '\p{^ _Is posixgraph}', ""); +Expect(1, 32, '\P{ _Is posixgraph}', ""); +Expect(0, 32, '\P{^ _Is posixgraph}', ""); +Error('\p{:= GRAPHEME-base}'); +Error('\P{:= GRAPHEME-base}'); +Expect(1, 126, '\p{graphemebase}', ""); +Expect(0, 126, '\p{^graphemebase}', ""); +Expect(0, 126, '\P{graphemebase}', ""); +Expect(1, 126, '\P{^graphemebase}', ""); +Expect(0, 7, '\p{graphemebase}', ""); +Expect(1, 7, '\p{^graphemebase}', ""); +Expect(1, 7, '\P{graphemebase}', ""); +Expect(0, 7, '\P{^graphemebase}', ""); +Expect(1, 126, '\p{ GRAPHEMEBase}', ""); +Expect(0, 126, '\p{^ GRAPHEMEBase}', ""); +Expect(0, 126, '\P{ GRAPHEMEBase}', ""); +Expect(1, 126, '\P{^ GRAPHEMEBase}', ""); +Expect(0, 7, '\p{ GRAPHEMEBase}', ""); +Expect(1, 7, '\p{^ GRAPHEMEBase}', ""); +Expect(1, 7, '\P{ GRAPHEMEBase}', ""); +Expect(0, 7, '\P{^ GRAPHEMEBase}', ""); +Error('\p{__Is/a/grapheme_base}'); +Error('\P{__Is/a/grapheme_base}'); +Expect(1, 126, '\p{isgraphemebase}', ""); +Expect(0, 126, '\p{^isgraphemebase}', ""); +Expect(0, 126, '\P{isgraphemebase}', ""); +Expect(1, 126, '\P{^isgraphemebase}', ""); +Expect(0, 7, '\p{isgraphemebase}', ""); +Expect(1, 7, '\p{^isgraphemebase}', ""); +Expect(1, 7, '\P{isgraphemebase}', ""); +Expect(0, 7, '\P{^isgraphemebase}', ""); +Expect(1, 126, '\p{_ IS_Grapheme base}', ""); +Expect(0, 126, '\p{^_ IS_Grapheme base}', ""); +Expect(0, 126, '\P{_ IS_Grapheme base}', ""); +Expect(1, 126, '\P{^_ IS_Grapheme base}', ""); +Expect(0, 7, '\p{_ IS_Grapheme base}', ""); +Expect(1, 7, '\p{^_ IS_Grapheme base}', ""); +Expect(1, 7, '\P{_ IS_Grapheme base}', ""); +Expect(0, 7, '\P{^_ IS_Grapheme base}', ""); +Error('\p{_:=Gr base}'); +Error('\P{_:=Gr base}'); +Expect(1, 126, '\p{grbase}', ""); +Expect(0, 126, '\p{^grbase}', ""); +Expect(0, 126, '\P{grbase}', ""); +Expect(1, 126, '\P{^grbase}', ""); +Expect(0, 7, '\p{grbase}', ""); +Expect(1, 7, '\p{^grbase}', ""); +Expect(1, 7, '\P{grbase}', ""); +Expect(0, 7, '\P{^grbase}', ""); +Expect(1, 126, '\p{-_grBASE}', ""); +Expect(0, 126, '\p{^-_grBASE}', ""); +Expect(0, 126, '\P{-_grBASE}', ""); +Expect(1, 126, '\P{^-_grBASE}', ""); +Expect(0, 7, '\p{-_grBASE}', ""); +Expect(1, 7, '\p{^-_grBASE}', ""); +Expect(1, 7, '\P{-_grBASE}', ""); +Expect(0, 7, '\P{^-_grBASE}', ""); +Error('\p{ :=IS_gr Base}'); +Error('\P{ :=IS_gr Base}'); +Expect(1, 126, '\p{isgrbase}', ""); +Expect(0, 126, '\p{^isgrbase}', ""); +Expect(0, 126, '\P{isgrbase}', ""); +Expect(1, 126, '\P{^isgrbase}', ""); +Expect(0, 7, '\p{isgrbase}', ""); +Expect(1, 7, '\p{^isgrbase}', ""); +Expect(1, 7, '\P{isgrbase}', ""); +Expect(0, 7, '\P{^isgrbase}', ""); +Expect(1, 126, '\p{ IS gr base}', ""); +Expect(0, 126, '\p{^ IS gr base}', ""); +Expect(0, 126, '\P{ IS gr base}', ""); +Expect(1, 126, '\P{^ IS gr base}', ""); +Expect(0, 7, '\p{ IS gr base}', ""); +Expect(1, 7, '\p{^ IS gr base}', ""); +Expect(1, 7, '\P{ IS gr base}', ""); +Expect(0, 7, '\P{^ IS gr base}', ""); +Error('\p{_/a/Inugaritic}'); +Error('\P{_/a/Inugaritic}'); +Expect(1, 66463, '\p{inugaritic}', ""); +Expect(0, 66463, '\p{^inugaritic}', ""); +Expect(0, 66463, '\P{inugaritic}', ""); +Expect(1, 66463, '\P{^inugaritic}', ""); +Expect(0, 66431, '\p{inugaritic}', ""); +Expect(1, 66431, '\p{^inugaritic}', ""); +Expect(1, 66431, '\P{inugaritic}', ""); +Expect(0, 66431, '\P{^inugaritic}', ""); +Expect(1, 66463, '\p{- INUgaritic}', ""); +Expect(0, 66463, '\p{^- INUgaritic}', ""); +Expect(0, 66463, '\P{- INUgaritic}', ""); +Expect(1, 66463, '\P{^- INUgaritic}', ""); +Expect(0, 66431, '\p{- INUgaritic}', ""); +Expect(1, 66431, '\p{^- INUgaritic}', ""); +Expect(1, 66431, '\P{- INUgaritic}', ""); +Expect(0, 66431, '\P{^- INUgaritic}', ""); +Error('\p{_-Devanagari:=}'); +Error('\P{_-Devanagari:=}'); +Expect(1, 2361, '\p{devanagari}', ""); +Expect(0, 2361, '\p{^devanagari}', ""); +Expect(0, 2361, '\P{devanagari}', ""); +Expect(1, 2361, '\P{^devanagari}', ""); +Expect(0, 2304, '\p{devanagari}', ""); +Expect(1, 2304, '\p{^devanagari}', ""); +Expect(1, 2304, '\P{devanagari}', ""); +Expect(0, 2304, '\P{^devanagari}', ""); +Expect(1, 2361, '\p{- Devanagari}', ""); +Expect(0, 2361, '\p{^- Devanagari}', ""); +Expect(0, 2361, '\P{- Devanagari}', ""); +Expect(1, 2361, '\P{^- Devanagari}', ""); +Expect(0, 2304, '\p{- Devanagari}', ""); +Expect(1, 2304, '\p{^- Devanagari}', ""); +Expect(1, 2304, '\P{- Devanagari}', ""); +Expect(0, 2304, '\P{^- Devanagari}', ""); +Error('\p{:=is_Devanagari}'); +Error('\P{:=is_Devanagari}'); +Expect(1, 2361, '\p{isdevanagari}', ""); +Expect(0, 2361, '\p{^isdevanagari}', ""); +Expect(0, 2361, '\P{isdevanagari}', ""); +Expect(1, 2361, '\P{^isdevanagari}', ""); +Expect(0, 2304, '\p{isdevanagari}', ""); +Expect(1, 2304, '\p{^isdevanagari}', ""); +Expect(1, 2304, '\P{isdevanagari}', ""); +Expect(0, 2304, '\P{^isdevanagari}', ""); +Expect(1, 2361, '\p{-is devanagari}', ""); +Expect(0, 2361, '\p{^-is devanagari}', ""); +Expect(0, 2361, '\P{-is devanagari}', ""); +Expect(1, 2361, '\P{^-is devanagari}', ""); +Expect(0, 2304, '\p{-is devanagari}', ""); +Expect(1, 2304, '\p{^-is devanagari}', ""); +Expect(1, 2304, '\P{-is devanagari}', ""); +Expect(0, 2304, '\P{^-is devanagari}', ""); +Error('\p{:=_ Deva}'); +Error('\P{:=_ Deva}'); +Expect(1, 2361, '\p{deva}', ""); +Expect(0, 2361, '\p{^deva}', ""); +Expect(0, 2361, '\P{deva}', ""); +Expect(1, 2361, '\P{^deva}', ""); +Expect(0, 2304, '\p{deva}', ""); +Expect(1, 2304, '\p{^deva}', ""); +Expect(1, 2304, '\P{deva}', ""); +Expect(0, 2304, '\P{^deva}', ""); +Expect(1, 2361, '\p{-deva}', ""); +Expect(0, 2361, '\p{^-deva}', ""); +Expect(0, 2361, '\P{-deva}', ""); +Expect(1, 2361, '\P{^-deva}', ""); +Expect(0, 2304, '\p{-deva}', ""); +Expect(1, 2304, '\p{^-deva}', ""); +Expect(1, 2304, '\P{-deva}', ""); +Expect(0, 2304, '\P{^-deva}', ""); +Error('\p{_:=IS DEVA}'); +Error('\P{_:=IS DEVA}'); +Expect(1, 2361, '\p{isdeva}', ""); +Expect(0, 2361, '\p{^isdeva}', ""); +Expect(0, 2361, '\P{isdeva}', ""); +Expect(1, 2361, '\P{^isdeva}', ""); +Expect(0, 2304, '\p{isdeva}', ""); +Expect(1, 2304, '\p{^isdeva}', ""); +Expect(1, 2304, '\P{isdeva}', ""); +Expect(0, 2304, '\P{^isdeva}', ""); +Expect(1, 2361, '\p{ Isdeva}', ""); +Expect(0, 2361, '\p{^ Isdeva}', ""); +Expect(0, 2361, '\P{ Isdeva}', ""); +Expect(1, 2361, '\P{^ Isdeva}', ""); +Expect(0, 2304, '\p{ Isdeva}', ""); +Expect(1, 2304, '\p{^ Isdeva}', ""); +Expect(1, 2304, '\P{ Isdeva}', ""); +Expect(0, 2304, '\P{^ Isdeva}', ""); +Error('\p{_final/a/Punctuation}'); +Error('\P{_final/a/Punctuation}'); +Expect(1, 8217, '\p{finalpunctuation}', ""); +Expect(0, 8217, '\p{^finalpunctuation}', ""); +Expect(0, 8217, '\P{finalpunctuation}', ""); +Expect(1, 8217, '\P{^finalpunctuation}', ""); +Expect(0, 7, '\p{finalpunctuation}', ""); +Expect(1, 7, '\p{^finalpunctuation}', ""); +Expect(1, 7, '\P{finalpunctuation}', ""); +Expect(0, 7, '\P{^finalpunctuation}', ""); +Expect(1, 8217, '\p{ FINAL_PUNCTUATION}', ""); +Expect(0, 8217, '\p{^ FINAL_PUNCTUATION}', ""); +Expect(0, 8217, '\P{ FINAL_PUNCTUATION}', ""); +Expect(1, 8217, '\P{^ FINAL_PUNCTUATION}', ""); +Expect(0, 7, '\p{ FINAL_PUNCTUATION}', ""); +Expect(1, 7, '\p{^ FINAL_PUNCTUATION}', ""); +Expect(1, 7, '\P{ FINAL_PUNCTUATION}', ""); +Expect(0, 7, '\P{^ FINAL_PUNCTUATION}', ""); +Error('\p{ /a/IS-FINAL_Punctuation}'); +Error('\P{ /a/IS-FINAL_Punctuation}'); +Expect(1, 8217, '\p{isfinalpunctuation}', ""); +Expect(0, 8217, '\p{^isfinalpunctuation}', ""); +Expect(0, 8217, '\P{isfinalpunctuation}', ""); +Expect(1, 8217, '\P{^isfinalpunctuation}', ""); +Expect(0, 7, '\p{isfinalpunctuation}', ""); +Expect(1, 7, '\p{^isfinalpunctuation}', ""); +Expect(1, 7, '\P{isfinalpunctuation}', ""); +Expect(0, 7, '\P{^isfinalpunctuation}', ""); +Expect(1, 8217, '\p{-IS_Final_PUNCTUATION}', ""); +Expect(0, 8217, '\p{^-IS_Final_PUNCTUATION}', ""); +Expect(0, 8217, '\P{-IS_Final_PUNCTUATION}', ""); +Expect(1, 8217, '\P{^-IS_Final_PUNCTUATION}', ""); +Expect(0, 7, '\p{-IS_Final_PUNCTUATION}', ""); +Expect(1, 7, '\p{^-IS_Final_PUNCTUATION}', ""); +Expect(1, 7, '\P{-IS_Final_PUNCTUATION}', ""); +Expect(0, 7, '\P{^-IS_Final_PUNCTUATION}', ""); +Error('\p{ Pf/a/}'); +Error('\P{ Pf/a/}'); +Expect(1, 8217, '\p{pf}', ""); +Expect(0, 8217, '\p{^pf}', ""); +Expect(0, 8217, '\P{pf}', ""); +Expect(1, 8217, '\P{^pf}', ""); +Expect(0, 7, '\p{pf}', ""); +Expect(1, 7, '\p{^pf}', ""); +Expect(1, 7, '\P{pf}', ""); +Expect(0, 7, '\P{^pf}', ""); +Expect(1, 8217, '\p{ pf}', ""); +Expect(0, 8217, '\p{^ pf}', ""); +Expect(0, 8217, '\P{ pf}', ""); +Expect(1, 8217, '\P{^ pf}', ""); +Expect(0, 7, '\p{ pf}', ""); +Expect(1, 7, '\p{^ pf}', ""); +Expect(1, 7, '\P{ pf}', ""); +Expect(0, 7, '\P{^ pf}', ""); +Error('\p{ :=IS Pf}'); +Error('\P{ :=IS Pf}'); +Expect(1, 8217, '\p{ispf}', ""); +Expect(0, 8217, '\p{^ispf}', ""); +Expect(0, 8217, '\P{ispf}', ""); +Expect(1, 8217, '\P{^ispf}', ""); +Expect(0, 7, '\p{ispf}', ""); +Expect(1, 7, '\p{^ispf}', ""); +Expect(1, 7, '\P{ispf}', ""); +Expect(0, 7, '\P{^ispf}', ""); +Expect(1, 8217, '\p{-_IsPf}', ""); +Expect(0, 8217, '\p{^-_IsPf}', ""); +Expect(0, 8217, '\P{-_IsPf}', ""); +Expect(1, 8217, '\P{^-_IsPf}', ""); +Expect(0, 7, '\p{-_IsPf}', ""); +Expect(1, 7, '\p{^-_IsPf}', ""); +Expect(1, 7, '\P{-_IsPf}', ""); +Expect(0, 7, '\P{^-_IsPf}', ""); +Error('\p{:=_Modifierletter}'); +Error('\P{:=_Modifierletter}'); +Expect(1, 705, '\p{modifierletter}', ""); +Expect(0, 705, '\p{^modifierletter}', ""); +Expect(0, 705, '\P{modifierletter}', ""); +Expect(1, 705, '\P{^modifierletter}', ""); +Expect(0, 687, '\p{modifierletter}', ""); +Expect(1, 687, '\p{^modifierletter}', ""); +Expect(1, 687, '\P{modifierletter}', ""); +Expect(0, 687, '\P{^modifierletter}', ""); +Expect(1, 705, '\p{ Modifier letter}', ""); +Expect(0, 705, '\p{^ Modifier letter}', ""); +Expect(0, 705, '\P{ Modifier letter}', ""); +Expect(1, 705, '\P{^ Modifier letter}', ""); +Expect(0, 687, '\p{ Modifier letter}', ""); +Expect(1, 687, '\p{^ Modifier letter}', ""); +Expect(1, 687, '\P{ Modifier letter}', ""); +Expect(0, 687, '\P{^ Modifier letter}', ""); +Error('\p{-_is Modifier:=Letter}'); +Error('\P{-_is Modifier:=Letter}'); +Expect(1, 705, '\p{ismodifierletter}', ""); +Expect(0, 705, '\p{^ismodifierletter}', ""); +Expect(0, 705, '\P{ismodifierletter}', ""); +Expect(1, 705, '\P{^ismodifierletter}', ""); +Expect(0, 687, '\p{ismodifierletter}', ""); +Expect(1, 687, '\p{^ismodifierletter}', ""); +Expect(1, 687, '\P{ismodifierletter}', ""); +Expect(0, 687, '\P{^ismodifierletter}', ""); +Expect(1, 705, '\p{-Is Modifier LETTER}', ""); +Expect(0, 705, '\p{^-Is Modifier LETTER}', ""); +Expect(0, 705, '\P{-Is Modifier LETTER}', ""); +Expect(1, 705, '\P{^-Is Modifier LETTER}', ""); +Expect(0, 687, '\p{-Is Modifier LETTER}', ""); +Expect(1, 687, '\p{^-Is Modifier LETTER}', ""); +Expect(1, 687, '\P{-Is Modifier LETTER}', ""); +Expect(0, 687, '\P{^-Is Modifier LETTER}', ""); +Error('\p{ /a/lm}'); +Error('\P{ /a/lm}'); +Expect(1, 705, '\p{lm}', ""); +Expect(0, 705, '\p{^lm}', ""); +Expect(0, 705, '\P{lm}', ""); +Expect(1, 705, '\P{^lm}', ""); +Expect(0, 687, '\p{lm}', ""); +Expect(1, 687, '\p{^lm}', ""); +Expect(1, 687, '\P{lm}', ""); +Expect(0, 687, '\P{^lm}', ""); +Expect(1, 705, '\p{ lm}', ""); +Expect(0, 705, '\p{^ lm}', ""); +Expect(0, 705, '\P{ lm}', ""); +Expect(1, 705, '\P{^ lm}', ""); +Expect(0, 687, '\p{ lm}', ""); +Expect(1, 687, '\p{^ lm}', ""); +Expect(1, 687, '\P{ lm}', ""); +Expect(0, 687, '\P{^ lm}', ""); +Error('\p{--Is LM:=}'); +Error('\P{--Is LM:=}'); +Expect(1, 705, '\p{islm}', ""); +Expect(0, 705, '\p{^islm}', ""); +Expect(0, 705, '\P{islm}', ""); +Expect(1, 705, '\P{^islm}', ""); +Expect(0, 687, '\p{islm}', ""); +Expect(1, 687, '\p{^islm}', ""); +Expect(1, 687, '\P{islm}', ""); +Expect(0, 687, '\P{^islm}', ""); +Expect(1, 705, '\p{ IS-lm}', ""); +Expect(0, 705, '\p{^ IS-lm}', ""); +Expect(0, 705, '\P{ IS-lm}', ""); +Expect(1, 705, '\P{^ IS-lm}', ""); +Expect(0, 687, '\p{ IS-lm}', ""); +Expect(1, 687, '\p{^ IS-lm}', ""); +Expect(1, 687, '\P{ IS-lm}', ""); +Expect(0, 687, '\P{^ IS-lm}', ""); +Error('\p{ /a/Kanbun}'); +Error('\P{ /a/Kanbun}'); +Expect(1, 12703, '\p{kanbun}', ""); +Expect(0, 12703, '\p{^kanbun}', ""); +Expect(0, 12703, '\P{kanbun}', ""); +Expect(1, 12703, '\P{^kanbun}', ""); +Expect(0, 12687, '\p{kanbun}', ""); +Expect(1, 12687, '\p{^kanbun}', ""); +Expect(1, 12687, '\P{kanbun}', ""); +Expect(0, 12687, '\P{^kanbun}', ""); +Expect(1, 12703, '\p{ _KANBUN}', ""); +Expect(0, 12703, '\p{^ _KANBUN}', ""); +Expect(0, 12703, '\P{ _KANBUN}', ""); +Expect(1, 12703, '\P{^ _KANBUN}', ""); +Expect(0, 12687, '\p{ _KANBUN}', ""); +Expect(1, 12687, '\p{^ _KANBUN}', ""); +Expect(1, 12687, '\P{ _KANBUN}', ""); +Expect(0, 12687, '\P{^ _KANBUN}', ""); +Error('\p{:=Is Kanbun}'); +Error('\P{:=Is Kanbun}'); +Expect(1, 12703, '\p{iskanbun}', ""); +Expect(0, 12703, '\p{^iskanbun}', ""); +Expect(0, 12703, '\P{iskanbun}', ""); +Expect(1, 12703, '\P{^iskanbun}', ""); +Expect(0, 12687, '\p{iskanbun}', ""); +Expect(1, 12687, '\p{^iskanbun}', ""); +Expect(1, 12687, '\P{iskanbun}', ""); +Expect(0, 12687, '\P{^iskanbun}', ""); +Expect(1, 12703, '\p{ -Is kanbun}', ""); +Expect(0, 12703, '\p{^ -Is kanbun}', ""); +Expect(0, 12703, '\P{ -Is kanbun}', ""); +Expect(1, 12703, '\P{^ -Is kanbun}', ""); +Expect(0, 12687, '\p{ -Is kanbun}', ""); +Expect(1, 12687, '\p{^ -Is kanbun}', ""); +Expect(1, 12687, '\P{ -Is kanbun}', ""); +Expect(0, 12687, '\P{^ -Is kanbun}', ""); +Error('\p{/a/ In_Kanbun}'); +Error('\P{/a/ In_Kanbun}'); +Expect(1, 12703, '\p{inkanbun}', ""); +Expect(0, 12703, '\p{^inkanbun}', ""); +Expect(0, 12703, '\P{inkanbun}', ""); +Expect(1, 12703, '\P{^inkanbun}', ""); +Expect(0, 12687, '\p{inkanbun}', ""); +Expect(1, 12687, '\p{^inkanbun}', ""); +Expect(1, 12687, '\P{inkanbun}', ""); +Expect(0, 12687, '\P{^inkanbun}', ""); +Expect(1, 12703, '\p{ -IN-kanbun}', ""); +Expect(0, 12703, '\p{^ -IN-kanbun}', ""); +Expect(0, 12703, '\P{ -IN-kanbun}', ""); +Expect(1, 12703, '\P{^ -IN-kanbun}', ""); +Expect(0, 12687, '\p{ -IN-kanbun}', ""); +Expect(1, 12687, '\p{^ -IN-kanbun}', ""); +Expect(1, 12687, '\P{ -IN-kanbun}', ""); +Expect(0, 12687, '\P{^ -IN-kanbun}', ""); +Error('\p{ MISCELLANEOUS MATHEMATICAL/a/Symbols a}'); +Error('\P{ MISCELLANEOUS MATHEMATICAL/a/Symbols a}'); +Expect(1, 10223, '\p{miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\p{^miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\P{miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\P{^miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\p{miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\p{^miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\P{miscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\P{^miscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\p{- miscellaneousMathematical-Symbols-a}', ""); +Expect(0, 10223, '\p{^- miscellaneousMathematical-Symbols-a}', ""); +Expect(0, 10223, '\P{- miscellaneousMathematical-Symbols-a}', ""); +Expect(1, 10223, '\P{^- miscellaneousMathematical-Symbols-a}', ""); +Expect(0, 10175, '\p{- miscellaneousMathematical-Symbols-a}', ""); +Expect(1, 10175, '\p{^- miscellaneousMathematical-Symbols-a}', ""); +Expect(1, 10175, '\P{- miscellaneousMathematical-Symbols-a}', ""); +Expect(0, 10175, '\P{^- miscellaneousMathematical-Symbols-a}', ""); +Error('\p{ -Is_MISCELLANEOUSMathematical/a/Symbols a}'); +Error('\P{ -Is_MISCELLANEOUSMathematical/a/Symbols a}'); +Expect(1, 10223, '\p{ismiscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\p{^ismiscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\P{ismiscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\P{^ismiscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\p{ismiscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\p{^ismiscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\P{ismiscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\P{^ismiscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\p{ isMiscellaneous-MATHEMATICALSymbols-a}', ""); +Expect(0, 10223, '\p{^ isMiscellaneous-MATHEMATICALSymbols-a}', ""); +Expect(0, 10223, '\P{ isMiscellaneous-MATHEMATICALSymbols-a}', ""); +Expect(1, 10223, '\P{^ isMiscellaneous-MATHEMATICALSymbols-a}', ""); +Expect(0, 10175, '\p{ isMiscellaneous-MATHEMATICALSymbols-a}', ""); +Expect(1, 10175, '\p{^ isMiscellaneous-MATHEMATICALSymbols-a}', ""); +Expect(1, 10175, '\P{ isMiscellaneous-MATHEMATICALSymbols-a}', ""); +Expect(0, 10175, '\P{^ isMiscellaneous-MATHEMATICALSymbols-a}', ""); +Error('\p{ /a/IN_MISCELLANEOUS_Mathematical Symbols-A}'); +Error('\P{ /a/IN_MISCELLANEOUS_Mathematical Symbols-A}'); +Expect(1, 10223, '\p{inmiscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\p{^inmiscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10223, '\P{inmiscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\P{^inmiscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\p{inmiscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\p{^inmiscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10175, '\P{inmiscellaneousmathematicalsymbolsa}', ""); +Expect(0, 10175, '\P{^inmiscellaneousmathematicalsymbolsa}', ""); +Expect(1, 10223, '\p{- InMISCELLANEOUS mathematical-symbolsA}', ""); +Expect(0, 10223, '\p{^- InMISCELLANEOUS mathematical-symbolsA}', ""); +Expect(0, 10223, '\P{- InMISCELLANEOUS mathematical-symbolsA}', ""); +Expect(1, 10223, '\P{^- InMISCELLANEOUS mathematical-symbolsA}', ""); +Expect(0, 10175, '\p{- InMISCELLANEOUS mathematical-symbolsA}', ""); +Expect(1, 10175, '\p{^- InMISCELLANEOUS mathematical-symbolsA}', ""); +Expect(1, 10175, '\P{- InMISCELLANEOUS mathematical-symbolsA}', ""); +Expect(0, 10175, '\P{^- InMISCELLANEOUS mathematical-symbolsA}', ""); +Error('\p{:= _in devanagari}'); +Error('\P{:= _in devanagari}'); +Expect(1, 2431, '\p{indevanagari}', ""); +Expect(0, 2431, '\p{^indevanagari}', ""); +Expect(0, 2431, '\P{indevanagari}', ""); +Expect(1, 2431, '\P{^indevanagari}', ""); +Expect(0, 2303, '\p{indevanagari}', ""); +Expect(1, 2303, '\p{^indevanagari}', ""); +Expect(1, 2303, '\P{indevanagari}', ""); +Expect(0, 2303, '\P{^indevanagari}', ""); +Expect(1, 2431, '\p{- in devanagari}', ""); +Expect(0, 2431, '\p{^- in devanagari}', ""); +Expect(0, 2431, '\P{- in devanagari}', ""); +Expect(1, 2431, '\P{^- in devanagari}', ""); +Expect(0, 2303, '\p{- in devanagari}', ""); +Expect(1, 2303, '\p{^- in devanagari}', ""); +Expect(1, 2303, '\P{- in devanagari}', ""); +Expect(0, 2303, '\P{^- in devanagari}', ""); +Error('\p{/a/-_Tibetan}'); +Error('\P{/a/-_Tibetan}'); +Expect(1, 3911, '\p{tibetan}', ""); +Expect(0, 3911, '\p{^tibetan}', ""); +Expect(0, 3911, '\P{tibetan}', ""); +Expect(1, 3911, '\P{^tibetan}', ""); +Expect(0, 3839, '\p{tibetan}', ""); +Expect(1, 3839, '\p{^tibetan}', ""); +Expect(1, 3839, '\P{tibetan}', ""); +Expect(0, 3839, '\P{^tibetan}', ""); +Expect(1, 3911, '\p{_Tibetan}', ""); +Expect(0, 3911, '\p{^_Tibetan}', ""); +Expect(0, 3911, '\P{_Tibetan}', ""); +Expect(1, 3911, '\P{^_Tibetan}', ""); +Expect(0, 3839, '\p{_Tibetan}', ""); +Expect(1, 3839, '\p{^_Tibetan}', ""); +Expect(1, 3839, '\P{_Tibetan}', ""); +Expect(0, 3839, '\P{^_Tibetan}', ""); +Error('\p{:=-Is Tibetan}'); +Error('\P{:=-Is Tibetan}'); +Expect(1, 3911, '\p{istibetan}', ""); +Expect(0, 3911, '\p{^istibetan}', ""); +Expect(0, 3911, '\P{istibetan}', ""); +Expect(1, 3911, '\P{^istibetan}', ""); +Expect(0, 3839, '\p{istibetan}', ""); +Expect(1, 3839, '\p{^istibetan}', ""); +Expect(1, 3839, '\P{istibetan}', ""); +Expect(0, 3839, '\P{^istibetan}', ""); +Expect(1, 3911, '\p{ _isTIBETAN}', ""); +Expect(0, 3911, '\p{^ _isTIBETAN}', ""); +Expect(0, 3911, '\P{ _isTIBETAN}', ""); +Expect(1, 3911, '\P{^ _isTIBETAN}', ""); +Expect(0, 3839, '\p{ _isTIBETAN}', ""); +Expect(1, 3839, '\p{^ _isTIBETAN}', ""); +Expect(1, 3839, '\P{ _isTIBETAN}', ""); +Expect(0, 3839, '\P{^ _isTIBETAN}', ""); +Error('\p{ -Tibt/a/}'); +Error('\P{ -Tibt/a/}'); +Expect(1, 3911, '\p{tibt}', ""); +Expect(0, 3911, '\p{^tibt}', ""); +Expect(0, 3911, '\P{tibt}', ""); +Expect(1, 3911, '\P{^tibt}', ""); +Expect(0, 3839, '\p{tibt}', ""); +Expect(1, 3839, '\p{^tibt}', ""); +Expect(1, 3839, '\P{tibt}', ""); +Expect(0, 3839, '\P{^tibt}', ""); +Expect(1, 3911, '\p{ _Tibt}', ""); +Expect(0, 3911, '\p{^ _Tibt}', ""); +Expect(0, 3911, '\P{ _Tibt}', ""); +Expect(1, 3911, '\P{^ _Tibt}', ""); +Expect(0, 3839, '\p{ _Tibt}', ""); +Expect(1, 3839, '\p{^ _Tibt}', ""); +Expect(1, 3839, '\P{ _Tibt}', ""); +Expect(0, 3839, '\P{^ _Tibt}', ""); +Error('\p{_-IS/a/tibt}'); +Error('\P{_-IS/a/tibt}'); +Expect(1, 3911, '\p{istibt}', ""); +Expect(0, 3911, '\p{^istibt}', ""); +Expect(0, 3911, '\P{istibt}', ""); +Expect(1, 3911, '\P{^istibt}', ""); +Expect(0, 3839, '\p{istibt}', ""); +Expect(1, 3839, '\p{^istibt}', ""); +Expect(1, 3839, '\P{istibt}', ""); +Expect(0, 3839, '\P{^istibt}', ""); +Expect(1, 3911, '\p{_ Is TIBT}', ""); +Expect(0, 3911, '\p{^_ Is TIBT}', ""); +Expect(0, 3911, '\P{_ Is TIBT}', ""); +Expect(1, 3911, '\P{^_ Is TIBT}', ""); +Expect(0, 3839, '\p{_ Is TIBT}', ""); +Expect(1, 3839, '\p{^_ Is TIBT}', ""); +Expect(1, 3839, '\P{_ Is TIBT}', ""); +Expect(0, 3839, '\P{^_ Is TIBT}', ""); +Error('\p{-:=telugu}'); +Error('\P{-:=telugu}'); +Expect(1, 3075, '\p{telugu}', ""); +Expect(0, 3075, '\p{^telugu}', ""); +Expect(0, 3075, '\P{telugu}', ""); +Expect(1, 3075, '\P{^telugu}', ""); +Expect(0, 3072, '\p{telugu}', ""); +Expect(1, 3072, '\p{^telugu}', ""); +Expect(1, 3072, '\P{telugu}', ""); +Expect(0, 3072, '\P{^telugu}', ""); +Expect(1, 3075, '\p{ TELUGU}', ""); +Expect(0, 3075, '\p{^ TELUGU}', ""); +Expect(0, 3075, '\P{ TELUGU}', ""); +Expect(1, 3075, '\P{^ TELUGU}', ""); +Expect(0, 3072, '\p{ TELUGU}', ""); +Expect(1, 3072, '\p{^ TELUGU}', ""); +Expect(1, 3072, '\P{ TELUGU}', ""); +Expect(0, 3072, '\P{^ TELUGU}', ""); +Error('\p{:= IS TELUGU}'); +Error('\P{:= IS TELUGU}'); +Expect(1, 3075, '\p{istelugu}', ""); +Expect(0, 3075, '\p{^istelugu}', ""); +Expect(0, 3075, '\P{istelugu}', ""); +Expect(1, 3075, '\P{^istelugu}', ""); +Expect(0, 3072, '\p{istelugu}', ""); +Expect(1, 3072, '\p{^istelugu}', ""); +Expect(1, 3072, '\P{istelugu}', ""); +Expect(0, 3072, '\P{^istelugu}', ""); +Expect(1, 3075, '\p{_is_Telugu}', ""); +Expect(0, 3075, '\p{^_is_Telugu}', ""); +Expect(0, 3075, '\P{_is_Telugu}', ""); +Expect(1, 3075, '\P{^_is_Telugu}', ""); +Expect(0, 3072, '\p{_is_Telugu}', ""); +Expect(1, 3072, '\p{^_is_Telugu}', ""); +Expect(1, 3072, '\P{_is_Telugu}', ""); +Expect(0, 3072, '\P{^_is_Telugu}', ""); +Error('\p{-/a/Telu}'); +Error('\P{-/a/Telu}'); +Expect(1, 3075, '\p{telu}', ""); +Expect(0, 3075, '\p{^telu}', ""); +Expect(0, 3075, '\P{telu}', ""); +Expect(1, 3075, '\P{^telu}', ""); +Expect(0, 3072, '\p{telu}', ""); +Expect(1, 3072, '\p{^telu}', ""); +Expect(1, 3072, '\P{telu}', ""); +Expect(0, 3072, '\P{^telu}', ""); +Expect(1, 3075, '\p{ Telu}', ""); +Expect(0, 3075, '\p{^ Telu}', ""); +Expect(0, 3075, '\P{ Telu}', ""); +Expect(1, 3075, '\P{^ Telu}', ""); +Expect(0, 3072, '\p{ Telu}', ""); +Expect(1, 3072, '\p{^ Telu}', ""); +Expect(1, 3072, '\P{ Telu}', ""); +Expect(0, 3072, '\P{^ Telu}', ""); +Error('\p{--Is_Telu:=}'); +Error('\P{--Is_Telu:=}'); +Expect(1, 3075, '\p{istelu}', ""); +Expect(0, 3075, '\p{^istelu}', ""); +Expect(0, 3075, '\P{istelu}', ""); +Expect(1, 3075, '\P{^istelu}', ""); +Expect(0, 3072, '\p{istelu}', ""); +Expect(1, 3072, '\p{^istelu}', ""); +Expect(1, 3072, '\P{istelu}', ""); +Expect(0, 3072, '\P{^istelu}', ""); +Expect(1, 3075, '\p{ ISTelu}', ""); +Expect(0, 3075, '\p{^ ISTelu}', ""); +Expect(0, 3075, '\P{ ISTelu}', ""); +Expect(1, 3075, '\P{^ ISTelu}', ""); +Expect(0, 3072, '\p{ ISTelu}', ""); +Expect(1, 3072, '\p{^ ISTelu}', ""); +Expect(1, 3072, '\P{ ISTelu}', ""); +Expect(0, 3072, '\P{^ ISTelu}', ""); +Error('\p{/a/ YIRadicals}'); +Error('\P{/a/ YIRadicals}'); +Expect(1, 42191, '\p{yiradicals}', ""); +Expect(0, 42191, '\p{^yiradicals}', ""); +Expect(0, 42191, '\P{yiradicals}', ""); +Expect(1, 42191, '\P{^yiradicals}', ""); +Expect(0, 42127, '\p{yiradicals}', ""); +Expect(1, 42127, '\p{^yiradicals}', ""); +Expect(1, 42127, '\P{yiradicals}', ""); +Expect(0, 42127, '\P{^yiradicals}', ""); +Expect(1, 42191, '\p{__YIradicals}', ""); +Expect(0, 42191, '\p{^__YIradicals}', ""); +Expect(0, 42191, '\P{__YIradicals}', ""); +Expect(1, 42191, '\P{^__YIradicals}', ""); +Expect(0, 42127, '\p{__YIradicals}', ""); +Expect(1, 42127, '\p{^__YIradicals}', ""); +Expect(1, 42127, '\P{__YIradicals}', ""); +Expect(0, 42127, '\P{^__YIradicals}', ""); +Error('\p{:=_-IS Yi RADICALS}'); +Error('\P{:=_-IS Yi RADICALS}'); +Expect(1, 42191, '\p{isyiradicals}', ""); +Expect(0, 42191, '\p{^isyiradicals}', ""); +Expect(0, 42191, '\P{isyiradicals}', ""); +Expect(1, 42191, '\P{^isyiradicals}', ""); +Expect(0, 42127, '\p{isyiradicals}', ""); +Expect(1, 42127, '\p{^isyiradicals}', ""); +Expect(1, 42127, '\P{isyiradicals}', ""); +Expect(0, 42127, '\P{^isyiradicals}', ""); +Expect(1, 42191, '\p{ is-YiRADICALS}', ""); +Expect(0, 42191, '\p{^ is-YiRADICALS}', ""); +Expect(0, 42191, '\P{ is-YiRADICALS}', ""); +Expect(1, 42191, '\P{^ is-YiRADICALS}', ""); +Expect(0, 42127, '\p{ is-YiRADICALS}', ""); +Expect(1, 42127, '\p{^ is-YiRADICALS}', ""); +Expect(1, 42127, '\P{ is-YiRADICALS}', ""); +Expect(0, 42127, '\P{^ is-YiRADICALS}', ""); +Error('\p{ _in/a/yi Radicals}'); +Error('\P{ _in/a/yi Radicals}'); +Expect(1, 42191, '\p{inyiradicals}', ""); +Expect(0, 42191, '\p{^inyiradicals}', ""); +Expect(0, 42191, '\P{inyiradicals}', ""); +Expect(1, 42191, '\P{^inyiradicals}', ""); +Expect(0, 42127, '\p{inyiradicals}', ""); +Expect(1, 42127, '\p{^inyiradicals}', ""); +Expect(1, 42127, '\P{inyiradicals}', ""); +Expect(0, 42127, '\P{^inyiradicals}', ""); +Expect(1, 42191, '\p{ IN yi Radicals}', ""); +Expect(0, 42191, '\p{^ IN yi Radicals}', ""); +Expect(0, 42191, '\P{ IN yi Radicals}', ""); +Expect(1, 42191, '\P{^ IN yi Radicals}', ""); +Expect(0, 42127, '\p{ IN yi Radicals}', ""); +Expect(1, 42127, '\p{^ IN yi Radicals}', ""); +Expect(1, 42127, '\P{ IN yi Radicals}', ""); +Expect(0, 42127, '\P{^ IN yi Radicals}', ""); +Error('\p{_In/a/shavian}'); +Error('\P{_In/a/shavian}'); +Expect(1, 66687, '\p{inshavian}', ""); +Expect(0, 66687, '\p{^inshavian}', ""); +Expect(0, 66687, '\P{inshavian}', ""); +Expect(1, 66687, '\P{^inshavian}', ""); +Expect(0, 66639, '\p{inshavian}', ""); +Expect(1, 66639, '\p{^inshavian}', ""); +Expect(1, 66639, '\P{inshavian}', ""); +Expect(0, 66639, '\P{^inshavian}', ""); +Expect(1, 66687, '\p{-_InSHAVIAN}', ""); +Expect(0, 66687, '\p{^-_InSHAVIAN}', ""); +Expect(0, 66687, '\P{-_InSHAVIAN}', ""); +Expect(1, 66687, '\P{^-_InSHAVIAN}', ""); +Expect(0, 66639, '\p{-_InSHAVIAN}', ""); +Expect(1, 66639, '\p{^-_InSHAVIAN}', ""); +Expect(1, 66639, '\P{-_InSHAVIAN}', ""); +Expect(0, 66639, '\P{^-_InSHAVIAN}', ""); +Error('\p{/a/ ANCIENT_SYMBOLS}'); +Error('\P{/a/ ANCIENT_SYMBOLS}'); +Expect(1, 65999, '\p{ancientsymbols}', ""); +Expect(0, 65999, '\p{^ancientsymbols}', ""); +Expect(0, 65999, '\P{ancientsymbols}', ""); +Expect(1, 65999, '\P{^ancientsymbols}', ""); +Expect(0, 65935, '\p{ancientsymbols}', ""); +Expect(1, 65935, '\p{^ancientsymbols}', ""); +Expect(1, 65935, '\P{ancientsymbols}', ""); +Expect(0, 65935, '\P{^ancientsymbols}', ""); +Expect(1, 65999, '\p{_ancient Symbols}', ""); +Expect(0, 65999, '\p{^_ancient Symbols}', ""); +Expect(0, 65999, '\P{_ancient Symbols}', ""); +Expect(1, 65999, '\P{^_ancient Symbols}', ""); +Expect(0, 65935, '\p{_ancient Symbols}', ""); +Expect(1, 65935, '\p{^_ancient Symbols}', ""); +Expect(1, 65935, '\P{_ancient Symbols}', ""); +Expect(0, 65935, '\P{^_ancient Symbols}', ""); +Error('\p{_ Is Ancient/a/Symbols}'); +Error('\P{_ Is Ancient/a/Symbols}'); +Expect(1, 65999, '\p{isancientsymbols}', ""); +Expect(0, 65999, '\p{^isancientsymbols}', ""); +Expect(0, 65999, '\P{isancientsymbols}', ""); +Expect(1, 65999, '\P{^isancientsymbols}', ""); +Expect(0, 65935, '\p{isancientsymbols}', ""); +Expect(1, 65935, '\p{^isancientsymbols}', ""); +Expect(1, 65935, '\P{isancientsymbols}', ""); +Expect(0, 65935, '\P{^isancientsymbols}', ""); +Expect(1, 65999, '\p{ Is Ancient Symbols}', ""); +Expect(0, 65999, '\p{^ Is Ancient Symbols}', ""); +Expect(0, 65999, '\P{ Is Ancient Symbols}', ""); +Expect(1, 65999, '\P{^ Is Ancient Symbols}', ""); +Expect(0, 65935, '\p{ Is Ancient Symbols}', ""); +Expect(1, 65935, '\p{^ Is Ancient Symbols}', ""); +Expect(1, 65935, '\P{ Is Ancient Symbols}', ""); +Expect(0, 65935, '\P{^ Is Ancient Symbols}', ""); +Error('\p{/a/In Ancient-symbols}'); +Error('\P{/a/In Ancient-symbols}'); +Expect(1, 65999, '\p{inancientsymbols}', ""); +Expect(0, 65999, '\p{^inancientsymbols}', ""); +Expect(0, 65999, '\P{inancientsymbols}', ""); +Expect(1, 65999, '\P{^inancientsymbols}', ""); +Expect(0, 65935, '\p{inancientsymbols}', ""); +Expect(1, 65935, '\p{^inancientsymbols}', ""); +Expect(1, 65935, '\P{inancientsymbols}', ""); +Expect(0, 65935, '\P{^inancientsymbols}', ""); +Expect(1, 65999, '\p{- In Ancient Symbols}', ""); +Expect(0, 65999, '\p{^- In Ancient Symbols}', ""); +Expect(0, 65999, '\P{- In Ancient Symbols}', ""); +Expect(1, 65999, '\P{^- In Ancient Symbols}', ""); +Expect(0, 65935, '\p{- In Ancient Symbols}', ""); +Expect(1, 65935, '\p{^- In Ancient Symbols}', ""); +Expect(1, 65935, '\P{- In Ancient Symbols}', ""); +Expect(0, 65935, '\P{^- In Ancient Symbols}', ""); +Error('\p{/a/_ Quotation mark}'); +Error('\P{/a/_ Quotation mark}'); +Expect(1, 34, '\p{quotationmark}', ""); +Expect(0, 34, '\p{^quotationmark}', ""); +Expect(0, 34, '\P{quotationmark}', ""); +Expect(1, 34, '\P{^quotationmark}', ""); +Expect(0, 33, '\p{quotationmark}', ""); +Expect(1, 33, '\p{^quotationmark}', ""); +Expect(1, 33, '\P{quotationmark}', ""); +Expect(0, 33, '\P{^quotationmark}', ""); +Expect(1, 34, '\p{ QUOTATION_mark}', ""); +Expect(0, 34, '\p{^ QUOTATION_mark}', ""); +Expect(0, 34, '\P{ QUOTATION_mark}', ""); +Expect(1, 34, '\P{^ QUOTATION_mark}', ""); +Expect(0, 33, '\p{ QUOTATION_mark}', ""); +Expect(1, 33, '\p{^ QUOTATION_mark}', ""); +Expect(1, 33, '\P{ QUOTATION_mark}', ""); +Expect(0, 33, '\P{^ QUOTATION_mark}', ""); +Error('\p{/a/ Is Quotation-MARK}'); +Error('\P{/a/ Is Quotation-MARK}'); +Expect(1, 34, '\p{isquotationmark}', ""); +Expect(0, 34, '\p{^isquotationmark}', ""); +Expect(0, 34, '\P{isquotationmark}', ""); +Expect(1, 34, '\P{^isquotationmark}', ""); +Expect(0, 33, '\p{isquotationmark}', ""); +Expect(1, 33, '\p{^isquotationmark}', ""); +Expect(1, 33, '\P{isquotationmark}', ""); +Expect(0, 33, '\P{^isquotationmark}', ""); +Expect(1, 34, '\p{ is quotation Mark}', ""); +Expect(0, 34, '\p{^ is quotation Mark}', ""); +Expect(0, 34, '\P{ is quotation Mark}', ""); +Expect(1, 34, '\P{^ is quotation Mark}', ""); +Expect(0, 33, '\p{ is quotation Mark}', ""); +Expect(1, 33, '\p{^ is quotation Mark}', ""); +Expect(1, 33, '\P{ is quotation Mark}', ""); +Expect(0, 33, '\P{^ is quotation Mark}', ""); +Error('\p{ _QMark:=}'); +Error('\P{ _QMark:=}'); +Expect(1, 34, '\p{qmark}', ""); +Expect(0, 34, '\p{^qmark}', ""); +Expect(0, 34, '\P{qmark}', ""); +Expect(1, 34, '\P{^qmark}', ""); +Expect(0, 33, '\p{qmark}', ""); +Expect(1, 33, '\p{^qmark}', ""); +Expect(1, 33, '\P{qmark}', ""); +Expect(0, 33, '\P{^qmark}', ""); +Expect(1, 34, '\p{ -QMark}', ""); +Expect(0, 34, '\p{^ -QMark}', ""); +Expect(0, 34, '\P{ -QMark}', ""); +Expect(1, 34, '\P{^ -QMark}', ""); +Expect(0, 33, '\p{ -QMark}', ""); +Expect(1, 33, '\p{^ -QMark}', ""); +Expect(1, 33, '\P{ -QMark}', ""); +Expect(0, 33, '\P{^ -QMark}', ""); +Error('\p{--isqmark/a/}'); +Error('\P{--isqmark/a/}'); +Expect(1, 34, '\p{isqmark}', ""); +Expect(0, 34, '\p{^isqmark}', ""); +Expect(0, 34, '\P{isqmark}', ""); +Expect(1, 34, '\P{^isqmark}', ""); +Expect(0, 33, '\p{isqmark}', ""); +Expect(1, 33, '\p{^isqmark}', ""); +Expect(1, 33, '\P{isqmark}', ""); +Expect(0, 33, '\P{^isqmark}', ""); +Expect(1, 34, '\p{ _isQMARK}', ""); +Expect(0, 34, '\p{^ _isQMARK}', ""); +Expect(0, 34, '\P{ _isQMARK}', ""); +Expect(1, 34, '\P{^ _isQMARK}', ""); +Expect(0, 33, '\p{ _isQMARK}', ""); +Expect(1, 33, '\p{^ _isQMARK}', ""); +Expect(1, 33, '\P{ _isQMARK}', ""); +Expect(0, 33, '\P{^ _isQMARK}', ""); +Error('\p{/a/InTIBETAN}'); +Error('\P{/a/InTIBETAN}'); +Expect(1, 4095, '\p{intibetan}', ""); +Expect(0, 4095, '\p{^intibetan}', ""); +Expect(0, 4095, '\P{intibetan}', ""); +Expect(1, 4095, '\P{^intibetan}', ""); +Expect(0, 3839, '\p{intibetan}', ""); +Expect(1, 3839, '\p{^intibetan}', ""); +Expect(1, 3839, '\P{intibetan}', ""); +Expect(0, 3839, '\P{^intibetan}', ""); +Expect(1, 4095, '\p{ _IN Tibetan}', ""); +Expect(0, 4095, '\p{^ _IN Tibetan}', ""); +Expect(0, 4095, '\P{ _IN Tibetan}', ""); +Expect(1, 4095, '\P{^ _IN Tibetan}', ""); +Expect(0, 3839, '\p{ _IN Tibetan}', ""); +Expect(1, 3839, '\p{^ _IN Tibetan}', ""); +Expect(1, 3839, '\P{ _IN Tibetan}', ""); +Expect(0, 3839, '\P{^ _IN Tibetan}', ""); +Error('\p{:=-SUPPLEMENTAL MATHEMATICAL OPERATORS}'); +Error('\P{:=-SUPPLEMENTAL MATHEMATICAL OPERATORS}'); +Expect(1, 11007, '\p{supplementalmathematicaloperators}', ""); +Expect(0, 11007, '\p{^supplementalmathematicaloperators}', ""); +Expect(0, 11007, '\P{supplementalmathematicaloperators}', ""); +Expect(1, 11007, '\P{^supplementalmathematicaloperators}', ""); +Expect(0, 10751, '\p{supplementalmathematicaloperators}', ""); +Expect(1, 10751, '\p{^supplementalmathematicaloperators}', ""); +Expect(1, 10751, '\P{supplementalmathematicaloperators}', ""); +Expect(0, 10751, '\P{^supplementalmathematicaloperators}', ""); +Expect(1, 11007, '\p{ SUPPLEMENTAL Mathematical Operators}', ""); +Expect(0, 11007, '\p{^ SUPPLEMENTAL Mathematical Operators}', ""); +Expect(0, 11007, '\P{ SUPPLEMENTAL Mathematical Operators}', ""); +Expect(1, 11007, '\P{^ SUPPLEMENTAL Mathematical Operators}', ""); +Expect(0, 10751, '\p{ SUPPLEMENTAL Mathematical Operators}', ""); +Expect(1, 10751, '\p{^ SUPPLEMENTAL Mathematical Operators}', ""); +Expect(1, 10751, '\P{ SUPPLEMENTAL Mathematical Operators}', ""); +Expect(0, 10751, '\P{^ SUPPLEMENTAL Mathematical Operators}', ""); +Error('\p{ -Is/a/Supplemental Mathematical OPERATORS}'); +Error('\P{ -Is/a/Supplemental Mathematical OPERATORS}'); +Expect(1, 11007, '\p{issupplementalmathematicaloperators}', ""); +Expect(0, 11007, '\p{^issupplementalmathematicaloperators}', ""); +Expect(0, 11007, '\P{issupplementalmathematicaloperators}', ""); +Expect(1, 11007, '\P{^issupplementalmathematicaloperators}', ""); +Expect(0, 10751, '\p{issupplementalmathematicaloperators}', ""); +Expect(1, 10751, '\p{^issupplementalmathematicaloperators}', ""); +Expect(1, 10751, '\P{issupplementalmathematicaloperators}', ""); +Expect(0, 10751, '\P{^issupplementalmathematicaloperators}', ""); +Expect(1, 11007, '\p{ IS_SUPPLEMENTALMathematical Operators}', ""); +Expect(0, 11007, '\p{^ IS_SUPPLEMENTALMathematical Operators}', ""); +Expect(0, 11007, '\P{ IS_SUPPLEMENTALMathematical Operators}', ""); +Expect(1, 11007, '\P{^ IS_SUPPLEMENTALMathematical Operators}', ""); +Expect(0, 10751, '\p{ IS_SUPPLEMENTALMathematical Operators}', ""); +Expect(1, 10751, '\p{^ IS_SUPPLEMENTALMathematical Operators}', ""); +Expect(1, 10751, '\P{ IS_SUPPLEMENTALMathematical Operators}', ""); +Expect(0, 10751, '\P{^ IS_SUPPLEMENTALMathematical Operators}', ""); +Error('\p{ :=In-Supplemental Mathematical operators}'); +Error('\P{ :=In-Supplemental Mathematical operators}'); +Expect(1, 11007, '\p{insupplementalmathematicaloperators}', ""); +Expect(0, 11007, '\p{^insupplementalmathematicaloperators}', ""); +Expect(0, 11007, '\P{insupplementalmathematicaloperators}', ""); +Expect(1, 11007, '\P{^insupplementalmathematicaloperators}', ""); +Expect(0, 10751, '\p{insupplementalmathematicaloperators}', ""); +Expect(1, 10751, '\p{^insupplementalmathematicaloperators}', ""); +Expect(1, 10751, '\P{insupplementalmathematicaloperators}', ""); +Expect(0, 10751, '\P{^insupplementalmathematicaloperators}', ""); +Expect(1, 11007, '\p{- In_supplemental-mathematicaloperators}', ""); +Expect(0, 11007, '\p{^- In_supplemental-mathematicaloperators}', ""); +Expect(0, 11007, '\P{- In_supplemental-mathematicaloperators}', ""); +Expect(1, 11007, '\P{^- In_supplemental-mathematicaloperators}', ""); +Expect(0, 10751, '\p{- In_supplemental-mathematicaloperators}', ""); +Expect(1, 10751, '\p{^- In_supplemental-mathematicaloperators}', ""); +Expect(1, 10751, '\P{- In_supplemental-mathematicaloperators}', ""); +Expect(0, 10751, '\P{^- In_supplemental-mathematicaloperators}', ""); +Error('\p{_ In/a/Carian}'); +Error('\P{_ In/a/Carian}'); +Expect(1, 66271, '\p{incarian}', ""); +Expect(0, 66271, '\p{^incarian}', ""); +Expect(0, 66271, '\P{incarian}', ""); +Expect(1, 66271, '\P{^incarian}', ""); +Expect(0, 66207, '\p{incarian}', ""); +Expect(1, 66207, '\p{^incarian}', ""); +Expect(1, 66207, '\P{incarian}', ""); +Expect(0, 66207, '\P{^incarian}', ""); +Expect(1, 66271, '\p{_-in carian}', ""); +Expect(0, 66271, '\p{^_-in carian}', ""); +Expect(0, 66271, '\P{_-in carian}', ""); +Expect(1, 66271, '\P{^_-in carian}', ""); +Expect(0, 66207, '\p{_-in carian}', ""); +Expect(1, 66207, '\p{^_-in carian}', ""); +Expect(1, 66207, '\P{_-in carian}', ""); +Expect(0, 66207, '\P{^_-in carian}', ""); +Error('\p{_ IN/a/Arabic}'); +Error('\P{_ IN/a/Arabic}'); +Expect(1, 1791, '\p{inarabic}', ""); +Expect(0, 1791, '\p{^inarabic}', ""); +Expect(0, 1791, '\P{inarabic}', ""); +Expect(1, 1791, '\P{^inarabic}', ""); +Expect(0, 1535, '\p{inarabic}', ""); +Expect(1, 1535, '\p{^inarabic}', ""); +Expect(1, 1535, '\P{inarabic}', ""); +Expect(0, 1535, '\P{^inarabic}', ""); +Expect(1, 1791, '\p{ IN arabic}', ""); +Expect(0, 1791, '\p{^ IN arabic}', ""); +Expect(0, 1791, '\P{ IN arabic}', ""); +Expect(1, 1791, '\P{^ IN arabic}', ""); +Expect(0, 1535, '\p{ IN arabic}', ""); +Expect(1, 1535, '\p{^ IN arabic}', ""); +Expect(1, 1535, '\P{ IN arabic}', ""); +Expect(0, 1535, '\P{^ IN arabic}', ""); +Error('\p{:=-_POSIXCNTRL}'); +Error('\P{:=-_POSIXCNTRL}'); +Expect(1, 7, '\p{posixcntrl}', ""); +Expect(0, 7, '\p{^posixcntrl}', ""); +Expect(0, 7, '\P{posixcntrl}', ""); +Expect(1, 7, '\P{^posixcntrl}', ""); +Expect(0, 126, '\p{posixcntrl}', ""); +Expect(1, 126, '\p{^posixcntrl}', ""); +Expect(1, 126, '\P{posixcntrl}', ""); +Expect(0, 126, '\P{^posixcntrl}', ""); +Expect(1, 7, '\p{-_PosixCntrl}', ""); +Expect(0, 7, '\p{^-_PosixCntrl}', ""); +Expect(0, 7, '\P{-_PosixCntrl}', ""); +Expect(1, 7, '\P{^-_PosixCntrl}', ""); +Expect(0, 126, '\p{-_PosixCntrl}', ""); +Expect(1, 126, '\p{^-_PosixCntrl}', ""); +Expect(1, 126, '\P{-_PosixCntrl}', ""); +Expect(0, 126, '\P{^-_PosixCntrl}', ""); +Error('\p{-_is/a/posixcntrl}'); +Error('\P{-_is/a/posixcntrl}'); +Expect(1, 7, '\p{isposixcntrl}', ""); +Expect(0, 7, '\p{^isposixcntrl}', ""); +Expect(0, 7, '\P{isposixcntrl}', ""); +Expect(1, 7, '\P{^isposixcntrl}', ""); +Expect(0, 126, '\p{isposixcntrl}', ""); +Expect(1, 126, '\p{^isposixcntrl}', ""); +Expect(1, 126, '\P{isposixcntrl}', ""); +Expect(0, 126, '\P{^isposixcntrl}', ""); +Expect(1, 7, '\p{ is PosixCntrl}', ""); +Expect(0, 7, '\p{^ is PosixCntrl}', ""); +Expect(0, 7, '\P{ is PosixCntrl}', ""); +Expect(1, 7, '\P{^ is PosixCntrl}', ""); +Expect(0, 126, '\p{ is PosixCntrl}', ""); +Expect(1, 126, '\p{^ is PosixCntrl}', ""); +Expect(1, 126, '\P{ is PosixCntrl}', ""); +Expect(0, 126, '\P{^ is PosixCntrl}', ""); +Error('\p{ :=InGothic}'); +Error('\P{ :=InGothic}'); +Expect(1, 66383, '\p{ingothic}', ""); +Expect(0, 66383, '\p{^ingothic}', ""); +Expect(0, 66383, '\P{ingothic}', ""); +Expect(1, 66383, '\P{^ingothic}', ""); +Expect(0, 66351, '\p{ingothic}', ""); +Expect(1, 66351, '\p{^ingothic}', ""); +Expect(1, 66351, '\P{ingothic}', ""); +Expect(0, 66351, '\P{^ingothic}', ""); +Expect(1, 66383, '\p{__In GOTHIC}', ""); +Expect(0, 66383, '\p{^__In GOTHIC}', ""); +Expect(0, 66383, '\P{__In GOTHIC}', ""); +Expect(1, 66383, '\P{^__In GOTHIC}', ""); +Expect(0, 66351, '\p{__In GOTHIC}', ""); +Expect(1, 66351, '\p{^__In GOTHIC}', ""); +Expect(1, 66351, '\P{__In GOTHIC}', ""); +Expect(0, 66351, '\P{^__In GOTHIC}', ""); +Error('\p{:=- Mark}'); +Error('\P{:=- Mark}'); +Expect(1, 879, '\p{mark}', ""); +Expect(0, 879, '\p{^mark}', ""); +Expect(0, 879, '\P{mark}', ""); +Expect(1, 879, '\P{^mark}', ""); +Expect(0, 767, '\p{mark}', ""); +Expect(1, 767, '\p{^mark}', ""); +Expect(1, 767, '\P{mark}', ""); +Expect(0, 767, '\P{^mark}', ""); +Expect(1, 879, '\p{ -Mark}', ""); +Expect(0, 879, '\p{^ -Mark}', ""); +Expect(0, 879, '\P{ -Mark}', ""); +Expect(1, 879, '\P{^ -Mark}', ""); +Expect(0, 767, '\p{ -Mark}', ""); +Expect(1, 767, '\p{^ -Mark}', ""); +Expect(1, 767, '\P{ -Mark}', ""); +Expect(0, 767, '\P{^ -Mark}', ""); +Error('\p{ /a/Is mark}'); +Error('\P{ /a/Is mark}'); +Expect(1, 879, '\p{ismark}', ""); +Expect(0, 879, '\p{^ismark}', ""); +Expect(0, 879, '\P{ismark}', ""); +Expect(1, 879, '\P{^ismark}', ""); +Expect(0, 767, '\p{ismark}', ""); +Expect(1, 767, '\p{^ismark}', ""); +Expect(1, 767, '\P{ismark}', ""); +Expect(0, 767, '\P{^ismark}', ""); +Expect(1, 879, '\p{_ ISMark}', ""); +Expect(0, 879, '\p{^_ ISMark}', ""); +Expect(0, 879, '\P{_ ISMark}', ""); +Expect(1, 879, '\P{^_ ISMark}', ""); +Expect(0, 767, '\p{_ ISMark}', ""); +Expect(1, 767, '\p{^_ ISMark}', ""); +Expect(1, 767, '\P{_ ISMark}', ""); +Expect(0, 767, '\P{^_ ISMark}', ""); +Error('\p{ M:=}'); +Error('\P{ M:=}'); +Expect(1, 879, '\p{m}', ""); +Expect(0, 879, '\p{^m}', ""); +Expect(0, 879, '\P{m}', ""); +Expect(1, 879, '\P{^m}', ""); +Expect(0, 767, '\p{m}', ""); +Expect(1, 767, '\p{^m}', ""); +Expect(1, 767, '\P{m}', ""); +Expect(0, 767, '\P{^m}', ""); +Expect(1, 879, '\p{ _M}', ""); +Expect(0, 879, '\p{^ _M}', ""); +Expect(0, 879, '\P{ _M}', ""); +Expect(1, 879, '\P{^ _M}', ""); +Expect(0, 767, '\p{ _M}', ""); +Expect(1, 767, '\p{^ _M}', ""); +Expect(1, 767, '\P{ _M}', ""); +Expect(0, 767, '\P{^ _M}', ""); +Error('\p{/a/--is M}'); +Error('\P{/a/--is M}'); +Expect(1, 879, '\p{ism}', ""); +Expect(0, 879, '\p{^ism}', ""); +Expect(0, 879, '\P{ism}', ""); +Expect(1, 879, '\P{^ism}', ""); +Expect(0, 767, '\p{ism}', ""); +Expect(1, 767, '\p{^ism}', ""); +Expect(1, 767, '\P{ism}', ""); +Expect(0, 767, '\P{^ism}', ""); +Expect(1, 879, '\p{_ ISM}', ""); +Expect(0, 879, '\p{^_ ISM}', ""); +Expect(0, 879, '\P{_ ISM}', ""); +Expect(1, 879, '\P{^_ ISM}', ""); +Expect(0, 767, '\p{_ ISM}', ""); +Expect(1, 767, '\p{^_ ISM}', ""); +Expect(1, 767, '\P{_ ISM}', ""); +Expect(0, 767, '\P{^_ ISM}', ""); +Error('\p{:= _hangul Syllables}'); +Error('\P{:= _hangul Syllables}'); +Expect(1, 55215, '\p{hangulsyllables}', ""); +Expect(0, 55215, '\p{^hangulsyllables}', ""); +Expect(0, 55215, '\P{hangulsyllables}', ""); +Expect(1, 55215, '\P{^hangulsyllables}', ""); +Expect(0, 44031, '\p{hangulsyllables}', ""); +Expect(1, 44031, '\p{^hangulsyllables}', ""); +Expect(1, 44031, '\P{hangulsyllables}', ""); +Expect(0, 44031, '\P{^hangulsyllables}', ""); +Expect(1, 55215, '\p{-hangul SYLLABLES}', ""); +Expect(0, 55215, '\p{^-hangul SYLLABLES}', ""); +Expect(0, 55215, '\P{-hangul SYLLABLES}', ""); +Expect(1, 55215, '\P{^-hangul SYLLABLES}', ""); +Expect(0, 44031, '\p{-hangul SYLLABLES}', ""); +Expect(1, 44031, '\p{^-hangul SYLLABLES}', ""); +Expect(1, 44031, '\P{-hangul SYLLABLES}', ""); +Expect(0, 44031, '\P{^-hangul SYLLABLES}', ""); +Error('\p{ Is hangul_Syllables:=}'); +Error('\P{ Is hangul_Syllables:=}'); +Expect(1, 55215, '\p{ishangulsyllables}', ""); +Expect(0, 55215, '\p{^ishangulsyllables}', ""); +Expect(0, 55215, '\P{ishangulsyllables}', ""); +Expect(1, 55215, '\P{^ishangulsyllables}', ""); +Expect(0, 44031, '\p{ishangulsyllables}', ""); +Expect(1, 44031, '\p{^ishangulsyllables}', ""); +Expect(1, 44031, '\P{ishangulsyllables}', ""); +Expect(0, 44031, '\P{^ishangulsyllables}', ""); +Expect(1, 55215, '\p{_-Is_Hangul_syllables}', ""); +Expect(0, 55215, '\p{^_-Is_Hangul_syllables}', ""); +Expect(0, 55215, '\P{_-Is_Hangul_syllables}', ""); +Expect(1, 55215, '\P{^_-Is_Hangul_syllables}', ""); +Expect(0, 44031, '\p{_-Is_Hangul_syllables}', ""); +Expect(1, 44031, '\p{^_-Is_Hangul_syllables}', ""); +Expect(1, 44031, '\P{_-Is_Hangul_syllables}', ""); +Expect(0, 44031, '\P{^_-Is_Hangul_syllables}', ""); +Error('\p{ in Hangul:=SYLLABLES}'); +Error('\P{ in Hangul:=SYLLABLES}'); +Expect(1, 55215, '\p{inhangulsyllables}', ""); +Expect(0, 55215, '\p{^inhangulsyllables}', ""); +Expect(0, 55215, '\P{inhangulsyllables}', ""); +Expect(1, 55215, '\P{^inhangulsyllables}', ""); +Expect(0, 44031, '\p{inhangulsyllables}', ""); +Expect(1, 44031, '\p{^inhangulsyllables}', ""); +Expect(1, 44031, '\P{inhangulsyllables}', ""); +Expect(0, 44031, '\P{^inhangulsyllables}', ""); +Expect(1, 55215, '\p{_ InHangul Syllables}', ""); +Expect(0, 55215, '\p{^_ InHangul Syllables}', ""); +Expect(0, 55215, '\P{_ InHangul Syllables}', ""); +Expect(1, 55215, '\P{^_ InHangul Syllables}', ""); +Expect(0, 44031, '\p{_ InHangul Syllables}', ""); +Expect(1, 44031, '\p{^_ InHangul Syllables}', ""); +Expect(1, 44031, '\P{_ InHangul Syllables}', ""); +Expect(0, 44031, '\P{^_ InHangul Syllables}', ""); +Error('\p{_ Space/a/}'); +Error('\P{_ Space/a/}'); +Expect(1, 13, '\p{space}', ""); +Expect(0, 13, '\p{^space}', ""); +Expect(0, 13, '\P{space}', ""); +Expect(1, 13, '\P{^space}', ""); +Expect(0, 8, '\p{space}', ""); +Expect(1, 8, '\p{^space}', ""); +Expect(1, 8, '\P{space}', ""); +Expect(0, 8, '\P{^space}', ""); +Expect(1, 13, '\p{-_Space}', ""); +Expect(0, 13, '\p{^-_Space}', ""); +Expect(0, 13, '\P{-_Space}', ""); +Expect(1, 13, '\P{^-_Space}', ""); +Expect(0, 8, '\p{-_Space}', ""); +Expect(1, 8, '\p{^-_Space}', ""); +Expect(1, 8, '\P{-_Space}', ""); +Expect(0, 8, '\P{^-_Space}', ""); +Error('\p{_ ISSpace:=}'); +Error('\P{_ ISSpace:=}'); +Expect(1, 13, '\p{isspace}', ""); +Expect(0, 13, '\p{^isspace}', ""); +Expect(0, 13, '\P{isspace}', ""); +Expect(1, 13, '\P{^isspace}', ""); +Expect(0, 8, '\p{isspace}', ""); +Expect(1, 8, '\p{^isspace}', ""); +Expect(1, 8, '\P{isspace}', ""); +Expect(0, 8, '\P{^isspace}', ""); +Expect(1, 13, '\p{_ IS-Space}', ""); +Expect(0, 13, '\p{^_ IS-Space}', ""); +Expect(0, 13, '\P{_ IS-Space}', ""); +Expect(1, 13, '\P{^_ IS-Space}', ""); +Expect(0, 8, '\p{_ IS-Space}', ""); +Expect(1, 8, '\p{^_ IS-Space}', ""); +Expect(1, 8, '\P{_ IS-Space}', ""); +Expect(0, 8, '\P{^_ IS-Space}', ""); +Error('\p{-_in/a/Telugu}'); +Error('\P{-_in/a/Telugu}'); +Expect(1, 3199, '\p{intelugu}', ""); +Expect(0, 3199, '\p{^intelugu}', ""); +Expect(0, 3199, '\P{intelugu}', ""); +Expect(1, 3199, '\P{^intelugu}', ""); +Expect(0, 3071, '\p{intelugu}', ""); +Expect(1, 3071, '\p{^intelugu}', ""); +Expect(1, 3071, '\P{intelugu}', ""); +Expect(0, 3071, '\P{^intelugu}', ""); +Expect(1, 3199, '\p{_In TELUGU}', ""); +Expect(0, 3199, '\p{^_In TELUGU}', ""); +Expect(0, 3199, '\P{_In TELUGU}', ""); +Expect(1, 3199, '\P{^_In TELUGU}', ""); +Expect(0, 3071, '\p{_In TELUGU}', ""); +Expect(1, 3071, '\p{^_In TELUGU}', ""); +Expect(1, 3071, '\P{_In TELUGU}', ""); +Expect(0, 3071, '\P{^_In TELUGU}', ""); +Error('\p{_:=CJK unified IdeographsEXTENSION_B}'); +Error('\P{_:=CJK unified IdeographsEXTENSION_B}'); +Expect(1, 173791, '\p{cjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\p{^cjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\P{cjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\P{^cjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\p{cjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\p{^cjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\P{cjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\P{^cjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\p{ CJKUnified_Ideographs Extension_B}', ""); +Expect(0, 173791, '\p{^ CJKUnified_Ideographs Extension_B}', ""); +Expect(0, 173791, '\P{ CJKUnified_Ideographs Extension_B}', ""); +Expect(1, 173791, '\P{^ CJKUnified_Ideographs Extension_B}', ""); +Expect(0, 7, '\p{ CJKUnified_Ideographs Extension_B}', ""); +Expect(1, 7, '\p{^ CJKUnified_Ideographs Extension_B}', ""); +Expect(1, 7, '\P{ CJKUnified_Ideographs Extension_B}', ""); +Expect(0, 7, '\P{^ CJKUnified_Ideographs Extension_B}', ""); +Error('\p{ /a/is-CJK Unified Ideographsextension b}'); +Error('\P{ /a/is-CJK Unified Ideographsextension b}'); +Expect(1, 173791, '\p{iscjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\p{^iscjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\P{iscjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\P{^iscjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\p{iscjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\p{^iscjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\P{iscjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\P{^iscjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\p{_Is-CJK_Unified-IDEOGRAPHS EXTENSION_B}', ""); +Expect(0, 173791, '\p{^_Is-CJK_Unified-IDEOGRAPHS EXTENSION_B}', ""); +Expect(0, 173791, '\P{_Is-CJK_Unified-IDEOGRAPHS EXTENSION_B}', ""); +Expect(1, 173791, '\P{^_Is-CJK_Unified-IDEOGRAPHS EXTENSION_B}', ""); +Expect(0, 7, '\p{_Is-CJK_Unified-IDEOGRAPHS EXTENSION_B}', ""); +Expect(1, 7, '\p{^_Is-CJK_Unified-IDEOGRAPHS EXTENSION_B}', ""); +Expect(1, 7, '\P{_Is-CJK_Unified-IDEOGRAPHS EXTENSION_B}', ""); +Expect(0, 7, '\P{^_Is-CJK_Unified-IDEOGRAPHS EXTENSION_B}', ""); +Error('\p{ /a/In CJK-unified-Ideographs_Extension-B}'); +Error('\P{ /a/In CJK-unified-Ideographs_Extension-B}'); +Expect(1, 173791, '\p{incjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\p{^incjkunifiedideographsextensionb}', ""); +Expect(0, 173791, '\P{incjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\P{^incjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\p{incjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\p{^incjkunifiedideographsextensionb}', ""); +Expect(1, 7, '\P{incjkunifiedideographsextensionb}', ""); +Expect(0, 7, '\P{^incjkunifiedideographsextensionb}', ""); +Expect(1, 173791, '\p{- In CJK-UnifiedIdeographs_ExtensionB}', ""); +Expect(0, 173791, '\p{^- In CJK-UnifiedIdeographs_ExtensionB}', ""); +Expect(0, 173791, '\P{- In CJK-UnifiedIdeographs_ExtensionB}', ""); +Expect(1, 173791, '\P{^- In CJK-UnifiedIdeographs_ExtensionB}', ""); +Expect(0, 7, '\p{- In CJK-UnifiedIdeographs_ExtensionB}', ""); +Expect(1, 7, '\p{^- In CJK-UnifiedIdeographs_ExtensionB}', ""); +Expect(1, 7, '\P{- In CJK-UnifiedIdeographs_ExtensionB}', ""); +Expect(0, 7, '\P{^- In CJK-UnifiedIdeographs_ExtensionB}', ""); +Error('\p{ :=In_Syloti_Nagri}'); +Error('\P{ :=In_Syloti_Nagri}'); +Expect(1, 43055, '\p{insylotinagri}', ""); +Expect(0, 43055, '\p{^insylotinagri}', ""); +Expect(0, 43055, '\P{insylotinagri}', ""); +Expect(1, 43055, '\P{^insylotinagri}', ""); +Expect(0, 43007, '\p{insylotinagri}', ""); +Expect(1, 43007, '\p{^insylotinagri}', ""); +Expect(1, 43007, '\P{insylotinagri}', ""); +Expect(0, 43007, '\P{^insylotinagri}', ""); +Expect(1, 43055, '\p{- IN Syloti NAGRI}', ""); +Expect(0, 43055, '\p{^- IN Syloti NAGRI}', ""); +Expect(0, 43055, '\P{- IN Syloti NAGRI}', ""); +Expect(1, 43055, '\P{^- IN Syloti NAGRI}', ""); +Expect(0, 43007, '\p{- IN Syloti NAGRI}', ""); +Expect(1, 43007, '\p{^- IN Syloti NAGRI}', ""); +Expect(1, 43007, '\P{- IN Syloti NAGRI}', ""); +Expect(0, 43007, '\P{^- IN Syloti NAGRI}', ""); +Error('\p{:=cuneiformnumbers AND_PUNCTUATION}'); +Error('\P{:=cuneiformnumbers AND_PUNCTUATION}'); +Expect(1, 74879, '\p{cuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\p{^cuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\P{cuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\P{^cuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\p{cuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\p{^cuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\P{cuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\P{^cuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\p{_CUNEIFORM NUMBERSAnd-Punctuation}', ""); +Expect(0, 74879, '\p{^_CUNEIFORM NUMBERSAnd-Punctuation}', ""); +Expect(0, 74879, '\P{_CUNEIFORM NUMBERSAnd-Punctuation}', ""); +Expect(1, 74879, '\P{^_CUNEIFORM NUMBERSAnd-Punctuation}', ""); +Expect(0, 74751, '\p{_CUNEIFORM NUMBERSAnd-Punctuation}', ""); +Expect(1, 74751, '\p{^_CUNEIFORM NUMBERSAnd-Punctuation}', ""); +Expect(1, 74751, '\P{_CUNEIFORM NUMBERSAnd-Punctuation}', ""); +Expect(0, 74751, '\P{^_CUNEIFORM NUMBERSAnd-Punctuation}', ""); +Error('\p{_-isCuneiform NumbersAnd-punctuation:=}'); +Error('\P{_-isCuneiform NumbersAnd-punctuation:=}'); +Expect(1, 74879, '\p{iscuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\p{^iscuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\P{iscuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\P{^iscuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\p{iscuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\p{^iscuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\P{iscuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\P{^iscuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\p{ is Cuneiform Numbers-And-Punctuation}', ""); +Expect(0, 74879, '\p{^ is Cuneiform Numbers-And-Punctuation}', ""); +Expect(0, 74879, '\P{ is Cuneiform Numbers-And-Punctuation}', ""); +Expect(1, 74879, '\P{^ is Cuneiform Numbers-And-Punctuation}', ""); +Expect(0, 74751, '\p{ is Cuneiform Numbers-And-Punctuation}', ""); +Expect(1, 74751, '\p{^ is Cuneiform Numbers-And-Punctuation}', ""); +Expect(1, 74751, '\P{ is Cuneiform Numbers-And-Punctuation}', ""); +Expect(0, 74751, '\P{^ is Cuneiform Numbers-And-Punctuation}', ""); +Error('\p{ _IN Cuneiform NUMBERS and Punctuation:=}'); +Error('\P{ _IN Cuneiform NUMBERS and Punctuation:=}'); +Expect(1, 74879, '\p{incuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\p{^incuneiformnumbersandpunctuation}', ""); +Expect(0, 74879, '\P{incuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\P{^incuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\p{incuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\p{^incuneiformnumbersandpunctuation}', ""); +Expect(1, 74751, '\P{incuneiformnumbersandpunctuation}', ""); +Expect(0, 74751, '\P{^incuneiformnumbersandpunctuation}', ""); +Expect(1, 74879, '\p{_-IN cuneiform_numbers_and Punctuation}', ""); +Expect(0, 74879, '\p{^_-IN cuneiform_numbers_and Punctuation}', ""); +Expect(0, 74879, '\P{_-IN cuneiform_numbers_and Punctuation}', ""); +Expect(1, 74879, '\P{^_-IN cuneiform_numbers_and Punctuation}', ""); +Expect(0, 74751, '\p{_-IN cuneiform_numbers_and Punctuation}', ""); +Expect(1, 74751, '\p{^_-IN cuneiform_numbers_and Punctuation}', ""); +Expect(1, 74751, '\P{_-IN cuneiform_numbers_and Punctuation}', ""); +Expect(0, 74751, '\P{^_-IN cuneiform_numbers_and Punctuation}', ""); +Error('\p{/a/- In OLD Italic}'); +Error('\P{/a/- In OLD Italic}'); +Expect(1, 66351, '\p{inolditalic}', ""); +Expect(0, 66351, '\p{^inolditalic}', ""); +Expect(0, 66351, '\P{inolditalic}', ""); +Expect(1, 66351, '\P{^inolditalic}', ""); +Expect(0, 66303, '\p{inolditalic}', ""); +Expect(1, 66303, '\p{^inolditalic}', ""); +Expect(1, 66303, '\P{inolditalic}', ""); +Expect(0, 66303, '\P{^inolditalic}', ""); +Expect(1, 66351, '\p{ -InOld-italic}', ""); +Expect(0, 66351, '\p{^ -InOld-italic}', ""); +Expect(0, 66351, '\P{ -InOld-italic}', ""); +Expect(1, 66351, '\P{^ -InOld-italic}', ""); +Expect(0, 66303, '\p{ -InOld-italic}', ""); +Expect(1, 66303, '\p{^ -InOld-italic}', ""); +Expect(1, 66303, '\P{ -InOld-italic}', ""); +Expect(0, 66303, '\P{^ -InOld-italic}', ""); +Error('\p{ -Miscellaneous/a/Symbols}'); +Error('\P{ -Miscellaneous/a/Symbols}'); +Expect(1, 9983, '\p{miscellaneoussymbols}', ""); +Expect(0, 9983, '\p{^miscellaneoussymbols}', ""); +Expect(0, 9983, '\P{miscellaneoussymbols}', ""); +Expect(1, 9983, '\P{^miscellaneoussymbols}', ""); +Expect(0, 9727, '\p{miscellaneoussymbols}', ""); +Expect(1, 9727, '\p{^miscellaneoussymbols}', ""); +Expect(1, 9727, '\P{miscellaneoussymbols}', ""); +Expect(0, 9727, '\P{^miscellaneoussymbols}', ""); +Expect(1, 9983, '\p{ -MiscellaneousSymbols}', ""); +Expect(0, 9983, '\p{^ -MiscellaneousSymbols}', ""); +Expect(0, 9983, '\P{ -MiscellaneousSymbols}', ""); +Expect(1, 9983, '\P{^ -MiscellaneousSymbols}', ""); +Expect(0, 9727, '\p{ -MiscellaneousSymbols}', ""); +Expect(1, 9727, '\p{^ -MiscellaneousSymbols}', ""); +Expect(1, 9727, '\P{ -MiscellaneousSymbols}', ""); +Expect(0, 9727, '\P{^ -MiscellaneousSymbols}', ""); +Error('\p{ :=is MISCELLANEOUSSymbols}'); +Error('\P{ :=is MISCELLANEOUSSymbols}'); +Expect(1, 9983, '\p{ismiscellaneoussymbols}', ""); +Expect(0, 9983, '\p{^ismiscellaneoussymbols}', ""); +Expect(0, 9983, '\P{ismiscellaneoussymbols}', ""); +Expect(1, 9983, '\P{^ismiscellaneoussymbols}', ""); +Expect(0, 9727, '\p{ismiscellaneoussymbols}', ""); +Expect(1, 9727, '\p{^ismiscellaneoussymbols}', ""); +Expect(1, 9727, '\P{ismiscellaneoussymbols}', ""); +Expect(0, 9727, '\P{^ismiscellaneoussymbols}', ""); +Expect(1, 9983, '\p{ _Is_Miscellaneous Symbols}', ""); +Expect(0, 9983, '\p{^ _Is_Miscellaneous Symbols}', ""); +Expect(0, 9983, '\P{ _Is_Miscellaneous Symbols}', ""); +Expect(1, 9983, '\P{^ _Is_Miscellaneous Symbols}', ""); +Expect(0, 9727, '\p{ _Is_Miscellaneous Symbols}', ""); +Expect(1, 9727, '\p{^ _Is_Miscellaneous Symbols}', ""); +Expect(1, 9727, '\P{ _Is_Miscellaneous Symbols}', ""); +Expect(0, 9727, '\P{^ _Is_Miscellaneous Symbols}', ""); +Error('\p{/a/ IN Miscellaneous_Symbols}'); +Error('\P{/a/ IN Miscellaneous_Symbols}'); +Expect(1, 9983, '\p{inmiscellaneoussymbols}', ""); +Expect(0, 9983, '\p{^inmiscellaneoussymbols}', ""); +Expect(0, 9983, '\P{inmiscellaneoussymbols}', ""); +Expect(1, 9983, '\P{^inmiscellaneoussymbols}', ""); +Expect(0, 9727, '\p{inmiscellaneoussymbols}', ""); +Expect(1, 9727, '\p{^inmiscellaneoussymbols}', ""); +Expect(1, 9727, '\P{inmiscellaneoussymbols}', ""); +Expect(0, 9727, '\P{^inmiscellaneoussymbols}', ""); +Expect(1, 9983, '\p{ -In Miscellaneous-Symbols}', ""); +Expect(0, 9983, '\p{^ -In Miscellaneous-Symbols}', ""); +Expect(0, 9983, '\P{ -In Miscellaneous-Symbols}', ""); +Expect(1, 9983, '\P{^ -In Miscellaneous-Symbols}', ""); +Expect(0, 9727, '\p{ -In Miscellaneous-Symbols}', ""); +Expect(1, 9727, '\p{^ -In Miscellaneous-Symbols}', ""); +Expect(1, 9727, '\P{ -In Miscellaneous-Symbols}', ""); +Expect(0, 9727, '\P{^ -In Miscellaneous-Symbols}', ""); +Error('\p{:= -PosixAlnum}'); +Error('\P{:= -PosixAlnum}'); +Expect(1, 57, '\p{posixalnum}', ""); +Expect(0, 57, '\p{^posixalnum}', ""); +Expect(0, 57, '\P{posixalnum}', ""); +Expect(1, 57, '\P{^posixalnum}', ""); +Expect(0, 47, '\p{posixalnum}', ""); +Expect(1, 47, '\p{^posixalnum}', ""); +Expect(1, 47, '\P{posixalnum}', ""); +Expect(0, 47, '\P{^posixalnum}', ""); +Expect(1, 57, '\p{--posixalnum}', ""); +Expect(0, 57, '\p{^--posixalnum}', ""); +Expect(0, 57, '\P{--posixalnum}', ""); +Expect(1, 57, '\P{^--posixalnum}', ""); +Expect(0, 47, '\p{--posixalnum}', ""); +Expect(1, 47, '\p{^--posixalnum}', ""); +Expect(1, 47, '\P{--posixalnum}', ""); +Expect(0, 47, '\P{^--posixalnum}', ""); +Error('\p{-Is POSIXALNUM:=}'); +Error('\P{-Is POSIXALNUM:=}'); +Expect(1, 57, '\p{isposixalnum}', ""); +Expect(0, 57, '\p{^isposixalnum}', ""); +Expect(0, 57, '\P{isposixalnum}', ""); +Expect(1, 57, '\P{^isposixalnum}', ""); +Expect(0, 47, '\p{isposixalnum}', ""); +Expect(1, 47, '\p{^isposixalnum}', ""); +Expect(1, 47, '\P{isposixalnum}', ""); +Expect(0, 47, '\P{^isposixalnum}', ""); +Expect(1, 57, '\p{Is_PosixAlnum}', ""); +Expect(0, 57, '\p{^Is_PosixAlnum}', ""); +Expect(0, 57, '\P{Is_PosixAlnum}', ""); +Expect(1, 57, '\P{^Is_PosixAlnum}', ""); +Expect(0, 47, '\p{Is_PosixAlnum}', ""); +Expect(1, 47, '\p{^Is_PosixAlnum}', ""); +Expect(1, 47, '\P{Is_PosixAlnum}', ""); +Expect(0, 47, '\P{^Is_PosixAlnum}', ""); +Error('\p{-_ArabicSupplement/a/}'); +Error('\P{-_ArabicSupplement/a/}'); +Expect(1, 1919, '\p{arabicsupplement}', ""); +Expect(0, 1919, '\p{^arabicsupplement}', ""); +Expect(0, 1919, '\P{arabicsupplement}', ""); +Expect(1, 1919, '\P{^arabicsupplement}', ""); +Expect(0, 1871, '\p{arabicsupplement}', ""); +Expect(1, 1871, '\p{^arabicsupplement}', ""); +Expect(1, 1871, '\P{arabicsupplement}', ""); +Expect(0, 1871, '\P{^arabicsupplement}', ""); +Expect(1, 1919, '\p{ ARABIC SUPPLEMENT}', ""); +Expect(0, 1919, '\p{^ ARABIC SUPPLEMENT}', ""); +Expect(0, 1919, '\P{ ARABIC SUPPLEMENT}', ""); +Expect(1, 1919, '\P{^ ARABIC SUPPLEMENT}', ""); +Expect(0, 1871, '\p{ ARABIC SUPPLEMENT}', ""); +Expect(1, 1871, '\p{^ ARABIC SUPPLEMENT}', ""); +Expect(1, 1871, '\P{ ARABIC SUPPLEMENT}', ""); +Expect(0, 1871, '\P{^ ARABIC SUPPLEMENT}', ""); +Error('\p{ IsArabicSupplement:=}'); +Error('\P{ IsArabicSupplement:=}'); +Expect(1, 1919, '\p{isarabicsupplement}', ""); +Expect(0, 1919, '\p{^isarabicsupplement}', ""); +Expect(0, 1919, '\P{isarabicsupplement}', ""); +Expect(1, 1919, '\P{^isarabicsupplement}', ""); +Expect(0, 1871, '\p{isarabicsupplement}', ""); +Expect(1, 1871, '\p{^isarabicsupplement}', ""); +Expect(1, 1871, '\P{isarabicsupplement}', ""); +Expect(0, 1871, '\P{^isarabicsupplement}', ""); +Expect(1, 1919, '\p{- IS ARABIC SUPPLEMENT}', ""); +Expect(0, 1919, '\p{^- IS ARABIC SUPPLEMENT}', ""); +Expect(0, 1919, '\P{- IS ARABIC SUPPLEMENT}', ""); +Expect(1, 1919, '\P{^- IS ARABIC SUPPLEMENT}', ""); +Expect(0, 1871, '\p{- IS ARABIC SUPPLEMENT}', ""); +Expect(1, 1871, '\p{^- IS ARABIC SUPPLEMENT}', ""); +Expect(1, 1871, '\P{- IS ARABIC SUPPLEMENT}', ""); +Expect(0, 1871, '\P{^- IS ARABIC SUPPLEMENT}', ""); +Error('\p{_in:=Arabic supplement}'); +Error('\P{_in:=Arabic supplement}'); +Expect(1, 1919, '\p{inarabicsupplement}', ""); +Expect(0, 1919, '\p{^inarabicsupplement}', ""); +Expect(0, 1919, '\P{inarabicsupplement}', ""); +Expect(1, 1919, '\P{^inarabicsupplement}', ""); +Expect(0, 1871, '\p{inarabicsupplement}', ""); +Expect(1, 1871, '\p{^inarabicsupplement}', ""); +Expect(1, 1871, '\P{inarabicsupplement}', ""); +Expect(0, 1871, '\P{^inarabicsupplement}', ""); +Expect(1, 1919, '\p{ _IN arabic Supplement}', ""); +Expect(0, 1919, '\p{^ _IN arabic Supplement}', ""); +Expect(0, 1919, '\P{ _IN arabic Supplement}', ""); +Expect(1, 1919, '\P{^ _IN arabic Supplement}', ""); +Expect(0, 1871, '\p{ _IN arabic Supplement}', ""); +Expect(1, 1871, '\p{^ _IN arabic Supplement}', ""); +Expect(1, 1871, '\P{ _IN arabic Supplement}', ""); +Expect(0, 1871, '\P{^ _IN arabic Supplement}', ""); +Error('\p{ -CJK_Compatibility IdeographsSupplement:=}'); +Error('\P{ -CJK_Compatibility IdeographsSupplement:=}'); +Expect(1, 195103, '\p{cjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\p{^cjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\P{cjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\P{^cjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\p{cjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\p{^cjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\P{cjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\P{^cjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\p{- CJKCompatibility ideographs-Supplement}', ""); +Expect(0, 195103, '\p{^- CJKCompatibility ideographs-Supplement}', ""); +Expect(0, 195103, '\P{- CJKCompatibility ideographs-Supplement}', ""); +Expect(1, 195103, '\P{^- CJKCompatibility ideographs-Supplement}', ""); +Expect(0, 194559, '\p{- CJKCompatibility ideographs-Supplement}', ""); +Expect(1, 194559, '\p{^- CJKCompatibility ideographs-Supplement}', ""); +Expect(1, 194559, '\P{- CJKCompatibility ideographs-Supplement}', ""); +Expect(0, 194559, '\P{^- CJKCompatibility ideographs-Supplement}', ""); +Error('\p{_ Is CJK/a/Compatibility_ideographs Supplement}'); +Error('\P{_ Is CJK/a/Compatibility_ideographs Supplement}'); +Expect(1, 195103, '\p{iscjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\p{^iscjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\P{iscjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\P{^iscjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\p{iscjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\p{^iscjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\P{iscjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\P{^iscjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\p{-iscjk-Compatibility_ideographsSUPPLEMENT}', ""); +Expect(0, 195103, '\p{^-iscjk-Compatibility_ideographsSUPPLEMENT}', ""); +Expect(0, 195103, '\P{-iscjk-Compatibility_ideographsSUPPLEMENT}', ""); +Expect(1, 195103, '\P{^-iscjk-Compatibility_ideographsSUPPLEMENT}', ""); +Expect(0, 194559, '\p{-iscjk-Compatibility_ideographsSUPPLEMENT}', ""); +Expect(1, 194559, '\p{^-iscjk-Compatibility_ideographsSUPPLEMENT}', ""); +Expect(1, 194559, '\P{-iscjk-Compatibility_ideographsSUPPLEMENT}', ""); +Expect(0, 194559, '\P{^-iscjk-Compatibility_ideographsSUPPLEMENT}', ""); +Error('\p{ in-CJK CompatibilityIdeographs:=Supplement}'); +Error('\P{ in-CJK CompatibilityIdeographs:=Supplement}'); +Expect(1, 195103, '\p{incjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\p{^incjkcompatibilityideographssupplement}', ""); +Expect(0, 195103, '\P{incjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\P{^incjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\p{incjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\p{^incjkcompatibilityideographssupplement}', ""); +Expect(1, 194559, '\P{incjkcompatibilityideographssupplement}', ""); +Expect(0, 194559, '\P{^incjkcompatibilityideographssupplement}', ""); +Expect(1, 195103, '\p{ in-cjk-Compatibility_Ideographs_supplement}', ""); +Expect(0, 195103, '\p{^ in-cjk-Compatibility_Ideographs_supplement}', ""); +Expect(0, 195103, '\P{ in-cjk-Compatibility_Ideographs_supplement}', ""); +Expect(1, 195103, '\P{^ in-cjk-Compatibility_Ideographs_supplement}', ""); +Expect(0, 194559, '\p{ in-cjk-Compatibility_Ideographs_supplement}', ""); +Expect(1, 194559, '\p{^ in-cjk-Compatibility_Ideographs_supplement}', ""); +Expect(1, 194559, '\P{ in-cjk-Compatibility_Ideographs_supplement}', ""); +Expect(0, 194559, '\P{^ in-cjk-Compatibility_Ideographs_supplement}', ""); +Error('\p{:=-_Ingurmukhi}'); +Error('\P{:=-_Ingurmukhi}'); +Expect(1, 2687, '\p{ingurmukhi}', ""); +Expect(0, 2687, '\p{^ingurmukhi}', ""); +Expect(0, 2687, '\P{ingurmukhi}', ""); +Expect(1, 2687, '\P{^ingurmukhi}', ""); +Expect(0, 2559, '\p{ingurmukhi}', ""); +Expect(1, 2559, '\p{^ingurmukhi}', ""); +Expect(1, 2559, '\P{ingurmukhi}', ""); +Expect(0, 2559, '\P{^ingurmukhi}', ""); +Expect(1, 2687, '\p{_IN_Gurmukhi}', ""); +Expect(0, 2687, '\p{^_IN_Gurmukhi}', ""); +Expect(0, 2687, '\P{_IN_Gurmukhi}', ""); +Expect(1, 2687, '\P{^_IN_Gurmukhi}', ""); +Expect(0, 2559, '\p{_IN_Gurmukhi}', ""); +Expect(1, 2559, '\p{^_IN_Gurmukhi}', ""); +Expect(1, 2559, '\P{_IN_Gurmukhi}', ""); +Expect(0, 2559, '\P{^_IN_Gurmukhi}', ""); +Error('\p{-Phaistos Disc/a/}'); +Error('\P{-Phaistos Disc/a/}'); +Expect(1, 66047, '\p{phaistosdisc}', ""); +Expect(0, 66047, '\p{^phaistosdisc}', ""); +Expect(0, 66047, '\P{phaistosdisc}', ""); +Expect(1, 66047, '\P{^phaistosdisc}', ""); +Expect(0, 65999, '\p{phaistosdisc}', ""); +Expect(1, 65999, '\p{^phaistosdisc}', ""); +Expect(1, 65999, '\P{phaistosdisc}', ""); +Expect(0, 65999, '\P{^phaistosdisc}', ""); +Expect(1, 66047, '\p{ phaistos disc}', ""); +Expect(0, 66047, '\p{^ phaistos disc}', ""); +Expect(0, 66047, '\P{ phaistos disc}', ""); +Expect(1, 66047, '\P{^ phaistos disc}', ""); +Expect(0, 65999, '\p{ phaistos disc}', ""); +Expect(1, 65999, '\p{^ phaistos disc}', ""); +Expect(1, 65999, '\P{ phaistos disc}', ""); +Expect(0, 65999, '\P{^ phaistos disc}', ""); +Error('\p{__IS:=Phaistos disc}'); +Error('\P{__IS:=Phaistos disc}'); +Expect(1, 66047, '\p{isphaistosdisc}', ""); +Expect(0, 66047, '\p{^isphaistosdisc}', ""); +Expect(0, 66047, '\P{isphaistosdisc}', ""); +Expect(1, 66047, '\P{^isphaistosdisc}', ""); +Expect(0, 65999, '\p{isphaistosdisc}', ""); +Expect(1, 65999, '\p{^isphaistosdisc}', ""); +Expect(1, 65999, '\P{isphaistosdisc}', ""); +Expect(0, 65999, '\P{^isphaistosdisc}', ""); +Expect(1, 66047, '\p{ IS PHAISTOS-disc}', ""); +Expect(0, 66047, '\p{^ IS PHAISTOS-disc}', ""); +Expect(0, 66047, '\P{ IS PHAISTOS-disc}', ""); +Expect(1, 66047, '\P{^ IS PHAISTOS-disc}', ""); +Expect(0, 65999, '\p{ IS PHAISTOS-disc}', ""); +Expect(1, 65999, '\p{^ IS PHAISTOS-disc}', ""); +Expect(1, 65999, '\P{ IS PHAISTOS-disc}', ""); +Expect(0, 65999, '\P{^ IS PHAISTOS-disc}', ""); +Error('\p{- In PHAISTOS Disc:=}'); +Error('\P{- In PHAISTOS Disc:=}'); +Expect(1, 66047, '\p{inphaistosdisc}', ""); +Expect(0, 66047, '\p{^inphaistosdisc}', ""); +Expect(0, 66047, '\P{inphaistosdisc}', ""); +Expect(1, 66047, '\P{^inphaistosdisc}', ""); +Expect(0, 65999, '\p{inphaistosdisc}', ""); +Expect(1, 65999, '\p{^inphaistosdisc}', ""); +Expect(1, 65999, '\P{inphaistosdisc}', ""); +Expect(0, 65999, '\P{^inphaistosdisc}', ""); +Expect(1, 66047, '\p{ In_Phaistos-Disc}', ""); +Expect(0, 66047, '\p{^ In_Phaistos-Disc}', ""); +Expect(0, 66047, '\P{ In_Phaistos-Disc}', ""); +Expect(1, 66047, '\P{^ In_Phaistos-Disc}', ""); +Expect(0, 65999, '\p{ In_Phaistos-Disc}', ""); +Expect(1, 65999, '\p{^ In_Phaistos-Disc}', ""); +Expect(1, 65999, '\P{ In_Phaistos-Disc}', ""); +Expect(0, 65999, '\P{^ In_Phaistos-Disc}', ""); +Error('\p{:=CombAbove}'); +Error('\P{:=CombAbove}'); +Expect(1, 788, '\p{_CombAbove}', ""); +Expect(0, 788, '\p{^_CombAbove}', ""); +Expect(0, 788, '\P{_CombAbove}', ""); +Expect(1, 788, '\P{^_CombAbove}', ""); +Expect(0, 767, '\p{_CombAbove}', ""); +Expect(1, 767, '\p{^_CombAbove}', ""); +Expect(1, 767, '\P{_CombAbove}', ""); +Expect(0, 767, '\P{^_CombAbove}', ""); +Error('\p{ Other/a/ID CONTINUE}'); +Error('\P{ Other/a/ID CONTINUE}'); +Expect(1, 903, '\p{otheridcontinue}', 'deprecated'); +Expect(0, 903, '\p{^otheridcontinue}', 'deprecated'); +Expect(0, 903, '\P{otheridcontinue}', 'deprecated'); +Expect(1, 903, '\P{^otheridcontinue}', 'deprecated'); +Expect(0, 7, '\p{otheridcontinue}', 'deprecated'); +Expect(1, 7, '\p{^otheridcontinue}', 'deprecated'); +Expect(1, 7, '\P{otheridcontinue}', 'deprecated'); +Expect(0, 7, '\P{^otheridcontinue}', 'deprecated'); +Expect(1, 903, '\p{ OTHER id Continue}', 'deprecated'); +Expect(0, 903, '\p{^ OTHER id Continue}', 'deprecated'); +Expect(0, 903, '\P{ OTHER id Continue}', 'deprecated'); +Expect(1, 903, '\P{^ OTHER id Continue}', 'deprecated'); +Expect(0, 7, '\p{ OTHER id Continue}', 'deprecated'); +Expect(1, 7, '\p{^ OTHER id Continue}', 'deprecated'); +Expect(1, 7, '\P{ OTHER id Continue}', 'deprecated'); +Expect(0, 7, '\P{^ OTHER id Continue}', 'deprecated'); +Error('\p{- Is/a/Other id Continue}'); +Error('\P{- Is/a/Other id Continue}'); +Expect(1, 903, '\p{isotheridcontinue}', 'deprecated'); +Expect(0, 903, '\p{^isotheridcontinue}', 'deprecated'); +Expect(0, 903, '\P{isotheridcontinue}', 'deprecated'); +Expect(1, 903, '\P{^isotheridcontinue}', 'deprecated'); +Expect(0, 7, '\p{isotheridcontinue}', 'deprecated'); +Expect(1, 7, '\p{^isotheridcontinue}', 'deprecated'); +Expect(1, 7, '\P{isotheridcontinue}', 'deprecated'); +Expect(0, 7, '\P{^isotheridcontinue}', 'deprecated'); +Expect(1, 903, '\p{__IsOther_ID Continue}', 'deprecated'); +Expect(0, 903, '\p{^__IsOther_ID Continue}', 'deprecated'); +Expect(0, 903, '\P{__IsOther_ID Continue}', 'deprecated'); +Expect(1, 903, '\P{^__IsOther_ID Continue}', 'deprecated'); +Expect(0, 7, '\p{__IsOther_ID Continue}', 'deprecated'); +Expect(1, 7, '\p{^__IsOther_ID Continue}', 'deprecated'); +Expect(1, 7, '\P{__IsOther_ID Continue}', 'deprecated'); +Expect(0, 7, '\P{^__IsOther_ID Continue}', 'deprecated'); +Error('\p{ /a/OIDC}'); +Error('\P{ /a/OIDC}'); +Expect(1, 903, '\p{oidc}', 'deprecated'); +Expect(0, 903, '\p{^oidc}', 'deprecated'); +Expect(0, 903, '\P{oidc}', 'deprecated'); +Expect(1, 903, '\P{^oidc}', 'deprecated'); +Expect(0, 7, '\p{oidc}', 'deprecated'); +Expect(1, 7, '\p{^oidc}', 'deprecated'); +Expect(1, 7, '\P{oidc}', 'deprecated'); +Expect(0, 7, '\P{^oidc}', 'deprecated'); +Expect(1, 903, '\p{ OIDC}', 'deprecated'); +Expect(0, 903, '\p{^ OIDC}', 'deprecated'); +Expect(0, 903, '\P{ OIDC}', 'deprecated'); +Expect(1, 903, '\P{^ OIDC}', 'deprecated'); +Expect(0, 7, '\p{ OIDC}', 'deprecated'); +Expect(1, 7, '\p{^ OIDC}', 'deprecated'); +Expect(1, 7, '\P{ OIDC}', 'deprecated'); +Expect(0, 7, '\P{^ OIDC}', 'deprecated'); +Error('\p{:= IS-OIDC}'); +Error('\P{:= IS-OIDC}'); +Expect(1, 903, '\p{isoidc}', 'deprecated'); +Expect(0, 903, '\p{^isoidc}', 'deprecated'); +Expect(0, 903, '\P{isoidc}', 'deprecated'); +Expect(1, 903, '\P{^isoidc}', 'deprecated'); +Expect(0, 7, '\p{isoidc}', 'deprecated'); +Expect(1, 7, '\p{^isoidc}', 'deprecated'); +Expect(1, 7, '\P{isoidc}', 'deprecated'); +Expect(0, 7, '\P{^isoidc}', 'deprecated'); +Expect(1, 903, '\p{__Is_OIDC}', 'deprecated'); +Expect(0, 903, '\p{^__Is_OIDC}', 'deprecated'); +Expect(0, 903, '\P{__Is_OIDC}', 'deprecated'); +Expect(1, 903, '\P{^__Is_OIDC}', 'deprecated'); +Expect(0, 7, '\p{__Is_OIDC}', 'deprecated'); +Expect(1, 7, '\p{^__Is_OIDC}', 'deprecated'); +Expect(1, 7, '\P{__Is_OIDC}', 'deprecated'); +Expect(0, 7, '\P{^__Is_OIDC}', 'deprecated'); +Error('\p{ IN Bengali/a/}'); +Error('\P{ IN Bengali/a/}'); +Expect(1, 2559, '\p{inbengali}', ""); +Expect(0, 2559, '\p{^inbengali}', ""); +Expect(0, 2559, '\P{inbengali}', ""); +Expect(1, 2559, '\P{^inbengali}', ""); +Expect(0, 2431, '\p{inbengali}', ""); +Expect(1, 2431, '\p{^inbengali}', ""); +Expect(1, 2431, '\P{inbengali}', ""); +Expect(0, 2431, '\P{^inbengali}', ""); +Expect(1, 2559, '\p{__InBengali}', ""); +Expect(0, 2559, '\p{^__InBengali}', ""); +Expect(0, 2559, '\P{__InBengali}', ""); +Expect(1, 2559, '\P{^__InBengali}', ""); +Expect(0, 2431, '\p{__InBengali}', ""); +Expect(1, 2431, '\p{^__InBengali}', ""); +Expect(1, 2431, '\P{__InBengali}', ""); +Expect(0, 2431, '\P{^__InBengali}', ""); +Error('\p{:= Cuneiform}'); +Error('\P{:= Cuneiform}'); +Expect(1, 74606, '\p{cuneiform}', ""); +Expect(0, 74606, '\p{^cuneiform}', ""); +Expect(0, 74606, '\P{cuneiform}', ""); +Expect(1, 74606, '\P{^cuneiform}', ""); +Expect(0, 73727, '\p{cuneiform}', ""); +Expect(1, 73727, '\p{^cuneiform}', ""); +Expect(1, 73727, '\P{cuneiform}', ""); +Expect(0, 73727, '\P{^cuneiform}', ""); +Expect(1, 74606, '\p{ Cuneiform}', ""); +Expect(0, 74606, '\p{^ Cuneiform}', ""); +Expect(0, 74606, '\P{ Cuneiform}', ""); +Expect(1, 74606, '\P{^ Cuneiform}', ""); +Expect(0, 73727, '\p{ Cuneiform}', ""); +Expect(1, 73727, '\p{^ Cuneiform}', ""); +Expect(1, 73727, '\P{ Cuneiform}', ""); +Expect(0, 73727, '\P{^ Cuneiform}', ""); +Error('\p{ :=Is Cuneiform}'); +Error('\P{ :=Is Cuneiform}'); +Expect(1, 74606, '\p{iscuneiform}', ""); +Expect(0, 74606, '\p{^iscuneiform}', ""); +Expect(0, 74606, '\P{iscuneiform}', ""); +Expect(1, 74606, '\P{^iscuneiform}', ""); +Expect(0, 73727, '\p{iscuneiform}', ""); +Expect(1, 73727, '\p{^iscuneiform}', ""); +Expect(1, 73727, '\P{iscuneiform}', ""); +Expect(0, 73727, '\P{^iscuneiform}', ""); +Expect(1, 74606, '\p{ Is cuneiform}', ""); +Expect(0, 74606, '\p{^ Is cuneiform}', ""); +Expect(0, 74606, '\P{ Is cuneiform}', ""); +Expect(1, 74606, '\P{^ Is cuneiform}', ""); +Expect(0, 73727, '\p{ Is cuneiform}', ""); +Expect(1, 73727, '\p{^ Is cuneiform}', ""); +Expect(1, 73727, '\P{ Is cuneiform}', ""); +Expect(0, 73727, '\P{^ Is cuneiform}', ""); +Error('\p{/a/- Xsux}'); +Error('\P{/a/- Xsux}'); +Expect(1, 74606, '\p{xsux}', ""); +Expect(0, 74606, '\p{^xsux}', ""); +Expect(0, 74606, '\P{xsux}', ""); +Expect(1, 74606, '\P{^xsux}', ""); +Expect(0, 73727, '\p{xsux}', ""); +Expect(1, 73727, '\p{^xsux}', ""); +Expect(1, 73727, '\P{xsux}', ""); +Expect(0, 73727, '\P{^xsux}', ""); +Expect(1, 74606, '\p{_Xsux}', ""); +Expect(0, 74606, '\p{^_Xsux}', ""); +Expect(0, 74606, '\P{_Xsux}', ""); +Expect(1, 74606, '\P{^_Xsux}', ""); +Expect(0, 73727, '\p{_Xsux}', ""); +Expect(1, 73727, '\p{^_Xsux}', ""); +Expect(1, 73727, '\P{_Xsux}', ""); +Expect(0, 73727, '\P{^_Xsux}', ""); +Error('\p{/a/IS_Xsux}'); +Error('\P{/a/IS_Xsux}'); +Expect(1, 74606, '\p{isxsux}', ""); +Expect(0, 74606, '\p{^isxsux}', ""); +Expect(0, 74606, '\P{isxsux}', ""); +Expect(1, 74606, '\P{^isxsux}', ""); +Expect(0, 73727, '\p{isxsux}', ""); +Expect(1, 73727, '\p{^isxsux}', ""); +Expect(1, 73727, '\P{isxsux}', ""); +Expect(0, 73727, '\P{^isxsux}', ""); +Expect(1, 74606, '\p{isXsux}', ""); +Expect(0, 74606, '\p{^isXsux}', ""); +Expect(0, 74606, '\P{isXsux}', ""); +Expect(1, 74606, '\P{^isXsux}', ""); +Expect(0, 73727, '\p{isXsux}', ""); +Expect(1, 73727, '\p{^isXsux}', ""); +Expect(1, 73727, '\P{isXsux}', ""); +Expect(0, 73727, '\P{^isXsux}', ""); +Error('\p{/a/_-Cased}'); +Error('\P{/a/_-Cased}'); +Expect(1, 90, '\p{cased}', ""); +Expect(0, 90, '\p{^cased}', ""); +Expect(0, 90, '\P{cased}', ""); +Expect(1, 90, '\P{^cased}', ""); +Expect(0, 64, '\p{cased}', ""); +Expect(1, 64, '\p{^cased}', ""); +Expect(1, 64, '\P{cased}', ""); +Expect(0, 64, '\P{^cased}', ""); +Expect(1, 90, '\p{_Cased}', ""); +Expect(0, 90, '\p{^_Cased}', ""); +Expect(0, 90, '\P{_Cased}', ""); +Expect(1, 90, '\P{^_Cased}', ""); +Expect(0, 64, '\p{_Cased}', ""); +Expect(1, 64, '\p{^_Cased}', ""); +Expect(1, 64, '\P{_Cased}', ""); +Expect(0, 64, '\P{^_Cased}', ""); +Error('\p{/a/_-Is_CASED}'); +Error('\P{/a/_-Is_CASED}'); +Expect(1, 90, '\p{iscased}', ""); +Expect(0, 90, '\p{^iscased}', ""); +Expect(0, 90, '\P{iscased}', ""); +Expect(1, 90, '\P{^iscased}', ""); +Expect(0, 64, '\p{iscased}', ""); +Expect(1, 64, '\p{^iscased}', ""); +Expect(1, 64, '\P{iscased}', ""); +Expect(0, 64, '\P{^iscased}', ""); +Expect(1, 90, '\p{ Is-CASED}', ""); +Expect(0, 90, '\p{^ Is-CASED}', ""); +Expect(0, 90, '\P{ Is-CASED}', ""); +Expect(1, 90, '\P{^ Is-CASED}', ""); +Expect(0, 64, '\p{ Is-CASED}', ""); +Expect(1, 64, '\p{^ Is-CASED}', ""); +Expect(1, 64, '\P{ Is-CASED}', ""); +Expect(0, 64, '\P{^ Is-CASED}', ""); +Error('\p{:=_In-Katakana}'); +Error('\P{:=_In-Katakana}'); +Expect(1, 12543, '\p{inkatakana}', ""); +Expect(0, 12543, '\p{^inkatakana}', ""); +Expect(0, 12543, '\P{inkatakana}', ""); +Expect(1, 12543, '\P{^inkatakana}', ""); +Expect(0, 12447, '\p{inkatakana}', ""); +Expect(1, 12447, '\p{^inkatakana}', ""); +Expect(1, 12447, '\P{inkatakana}', ""); +Expect(0, 12447, '\P{^inkatakana}', ""); +Expect(1, 12543, '\p{ -INkatakana}', ""); +Expect(0, 12543, '\p{^ -INkatakana}', ""); +Expect(0, 12543, '\P{ -INkatakana}', ""); +Expect(1, 12543, '\P{^ -INkatakana}', ""); +Expect(0, 12447, '\p{ -INkatakana}', ""); +Expect(1, 12447, '\p{^ -INkatakana}', ""); +Expect(1, 12447, '\P{ -INkatakana}', ""); +Expect(0, 12447, '\P{^ -INkatakana}', ""); +Error('\p{_:=Arabic-PRESENTATION-FormsA}'); +Error('\P{_:=Arabic-PRESENTATION-FormsA}'); +Expect(1, 65023, '\p{arabicpresentationformsa}', ""); +Expect(0, 65023, '\p{^arabicpresentationformsa}', ""); +Expect(0, 65023, '\P{arabicpresentationformsa}', ""); +Expect(1, 65023, '\P{^arabicpresentationformsa}', ""); +Expect(0, 64335, '\p{arabicpresentationformsa}', ""); +Expect(1, 64335, '\p{^arabicpresentationformsa}', ""); +Expect(1, 64335, '\P{arabicpresentationformsa}', ""); +Expect(0, 64335, '\P{^arabicpresentationformsa}', ""); +Expect(1, 65023, '\p{ ARABIC presentation formsA}', ""); +Expect(0, 65023, '\p{^ ARABIC presentation formsA}', ""); +Expect(0, 65023, '\P{ ARABIC presentation formsA}', ""); +Expect(1, 65023, '\P{^ ARABIC presentation formsA}', ""); +Expect(0, 64335, '\p{ ARABIC presentation formsA}', ""); +Expect(1, 64335, '\p{^ ARABIC presentation formsA}', ""); +Expect(1, 64335, '\P{ ARABIC presentation formsA}', ""); +Expect(0, 64335, '\P{^ ARABIC presentation formsA}', ""); +Error('\p{ -is:=arabic PresentationForms_a}'); +Error('\P{ -is:=arabic PresentationForms_a}'); +Expect(1, 65023, '\p{isarabicpresentationformsa}', ""); +Expect(0, 65023, '\p{^isarabicpresentationformsa}', ""); +Expect(0, 65023, '\P{isarabicpresentationformsa}', ""); +Expect(1, 65023, '\P{^isarabicpresentationformsa}', ""); +Expect(0, 64335, '\p{isarabicpresentationformsa}', ""); +Expect(1, 64335, '\p{^isarabicpresentationformsa}', ""); +Expect(1, 64335, '\P{isarabicpresentationformsa}', ""); +Expect(0, 64335, '\P{^isarabicpresentationformsa}', ""); +Expect(1, 65023, '\p{_-is-arabicPRESENTATION-Forms A}', ""); +Expect(0, 65023, '\p{^_-is-arabicPRESENTATION-Forms A}', ""); +Expect(0, 65023, '\P{_-is-arabicPRESENTATION-Forms A}', ""); +Expect(1, 65023, '\P{^_-is-arabicPRESENTATION-Forms A}', ""); +Expect(0, 64335, '\p{_-is-arabicPRESENTATION-Forms A}', ""); +Expect(1, 64335, '\p{^_-is-arabicPRESENTATION-Forms A}', ""); +Expect(1, 64335, '\P{_-is-arabicPRESENTATION-Forms A}', ""); +Expect(0, 64335, '\P{^_-is-arabicPRESENTATION-Forms A}', ""); +Error('\p{ /a/in-ArabicPresentationForms A}'); +Error('\P{ /a/in-ArabicPresentationForms A}'); +Expect(1, 65023, '\p{inarabicpresentationformsa}', ""); +Expect(0, 65023, '\p{^inarabicpresentationformsa}', ""); +Expect(0, 65023, '\P{inarabicpresentationformsa}', ""); +Expect(1, 65023, '\P{^inarabicpresentationformsa}', ""); +Expect(0, 64335, '\p{inarabicpresentationformsa}', ""); +Expect(1, 64335, '\p{^inarabicpresentationformsa}', ""); +Expect(1, 64335, '\P{inarabicpresentationformsa}', ""); +Expect(0, 64335, '\P{^inarabicpresentationformsa}', ""); +Expect(1, 65023, '\p{_-In-ARABIC_PRESENTATIONForms a}', ""); +Expect(0, 65023, '\p{^_-In-ARABIC_PRESENTATIONForms a}', ""); +Expect(0, 65023, '\P{_-In-ARABIC_PRESENTATIONForms a}', ""); +Expect(1, 65023, '\P{^_-In-ARABIC_PRESENTATIONForms a}', ""); +Expect(0, 64335, '\p{_-In-ARABIC_PRESENTATIONForms a}', ""); +Expect(1, 64335, '\p{^_-In-ARABIC_PRESENTATIONForms a}', ""); +Expect(1, 64335, '\P{_-In-ARABIC_PRESENTATIONForms a}', ""); +Expect(0, 64335, '\P{^_-In-ARABIC_PRESENTATIONForms a}', ""); +Error('\p{/a/IN-TAGALOG}'); +Error('\P{/a/IN-TAGALOG}'); +Expect(1, 5919, '\p{intagalog}', ""); +Expect(0, 5919, '\p{^intagalog}', ""); +Expect(0, 5919, '\P{intagalog}', ""); +Expect(1, 5919, '\P{^intagalog}', ""); +Expect(0, 5887, '\p{intagalog}', ""); +Expect(1, 5887, '\p{^intagalog}', ""); +Expect(1, 5887, '\P{intagalog}', ""); +Expect(0, 5887, '\P{^intagalog}', ""); +Expect(1, 5919, '\p{ -INtagalog}', ""); +Expect(0, 5919, '\p{^ -INtagalog}', ""); +Expect(0, 5919, '\P{ -INtagalog}', ""); +Expect(1, 5919, '\P{^ -INtagalog}', ""); +Expect(0, 5887, '\p{ -INtagalog}', ""); +Expect(1, 5887, '\p{^ -INtagalog}', ""); +Expect(1, 5887, '\P{ -INtagalog}', ""); +Expect(0, 5887, '\P{^ -INtagalog}', ""); +Error('\p{ Tai/a/xuan-JING symbols}'); +Error('\P{ Tai/a/xuan-JING symbols}'); +Expect(1, 119647, '\p{taixuanjingsymbols}', ""); +Expect(0, 119647, '\p{^taixuanjingsymbols}', ""); +Expect(0, 119647, '\P{taixuanjingsymbols}', ""); +Expect(1, 119647, '\P{^taixuanjingsymbols}', ""); +Expect(0, 119551, '\p{taixuanjingsymbols}', ""); +Expect(1, 119551, '\p{^taixuanjingsymbols}', ""); +Expect(1, 119551, '\P{taixuanjingsymbols}', ""); +Expect(0, 119551, '\P{^taixuanjingsymbols}', ""); +Expect(1, 119647, '\p{-tai_Xuan_jing_symbols}', ""); +Expect(0, 119647, '\p{^-tai_Xuan_jing_symbols}', ""); +Expect(0, 119647, '\P{-tai_Xuan_jing_symbols}', ""); +Expect(1, 119647, '\P{^-tai_Xuan_jing_symbols}', ""); +Expect(0, 119551, '\p{-tai_Xuan_jing_symbols}', ""); +Expect(1, 119551, '\p{^-tai_Xuan_jing_symbols}', ""); +Expect(1, 119551, '\P{-tai_Xuan_jing_symbols}', ""); +Expect(0, 119551, '\P{^-tai_Xuan_jing_symbols}', ""); +Error('\p{_-is Tai:=Xuan jing-Symbols}'); +Error('\P{_-is Tai:=Xuan jing-Symbols}'); +Expect(1, 119647, '\p{istaixuanjingsymbols}', ""); +Expect(0, 119647, '\p{^istaixuanjingsymbols}', ""); +Expect(0, 119647, '\P{istaixuanjingsymbols}', ""); +Expect(1, 119647, '\P{^istaixuanjingsymbols}', ""); +Expect(0, 119551, '\p{istaixuanjingsymbols}', ""); +Expect(1, 119551, '\p{^istaixuanjingsymbols}', ""); +Expect(1, 119551, '\P{istaixuanjingsymbols}', ""); +Expect(0, 119551, '\P{^istaixuanjingsymbols}', ""); +Expect(1, 119647, '\p{ _Is Tai-Xuan-Jing Symbols}', ""); +Expect(0, 119647, '\p{^ _Is Tai-Xuan-Jing Symbols}', ""); +Expect(0, 119647, '\P{ _Is Tai-Xuan-Jing Symbols}', ""); +Expect(1, 119647, '\P{^ _Is Tai-Xuan-Jing Symbols}', ""); +Expect(0, 119551, '\p{ _Is Tai-Xuan-Jing Symbols}', ""); +Expect(1, 119551, '\p{^ _Is Tai-Xuan-Jing Symbols}', ""); +Expect(1, 119551, '\P{ _Is Tai-Xuan-Jing Symbols}', ""); +Expect(0, 119551, '\P{^ _Is Tai-Xuan-Jing Symbols}', ""); +Error('\p{IN Tai/a/xuanJINGsymbols}'); +Error('\P{IN Tai/a/xuanJINGsymbols}'); +Expect(1, 119647, '\p{intaixuanjingsymbols}', ""); +Expect(0, 119647, '\p{^intaixuanjingsymbols}', ""); +Expect(0, 119647, '\P{intaixuanjingsymbols}', ""); +Expect(1, 119647, '\P{^intaixuanjingsymbols}', ""); +Expect(0, 119551, '\p{intaixuanjingsymbols}', ""); +Expect(1, 119551, '\p{^intaixuanjingsymbols}', ""); +Expect(1, 119551, '\P{intaixuanjingsymbols}', ""); +Expect(0, 119551, '\P{^intaixuanjingsymbols}', ""); +Expect(1, 119647, '\p{_In TAI_XuanJing SYMBOLS}', ""); +Expect(0, 119647, '\p{^_In TAI_XuanJing SYMBOLS}', ""); +Expect(0, 119647, '\P{_In TAI_XuanJing SYMBOLS}', ""); +Expect(1, 119647, '\P{^_In TAI_XuanJing SYMBOLS}', ""); +Expect(0, 119551, '\p{_In TAI_XuanJing SYMBOLS}', ""); +Expect(1, 119551, '\p{^_In TAI_XuanJing SYMBOLS}', ""); +Expect(1, 119551, '\P{_In TAI_XuanJing SYMBOLS}', ""); +Expect(0, 119551, '\P{^_In TAI_XuanJing SYMBOLS}', ""); +Error('\p{:=_INLepcha}'); +Error('\P{:=_INLepcha}'); +Expect(1, 7247, '\p{inlepcha}', ""); +Expect(0, 7247, '\p{^inlepcha}', ""); +Expect(0, 7247, '\P{inlepcha}', ""); +Expect(1, 7247, '\P{^inlepcha}', ""); +Expect(0, 7167, '\p{inlepcha}', ""); +Expect(1, 7167, '\p{^inlepcha}', ""); +Expect(1, 7167, '\P{inlepcha}', ""); +Expect(0, 7167, '\P{^inlepcha}', ""); +Expect(1, 7247, '\p{ In Lepcha}', ""); +Expect(0, 7247, '\p{^ In Lepcha}', ""); +Expect(0, 7247, '\P{ In Lepcha}', ""); +Expect(1, 7247, '\P{^ In Lepcha}', ""); +Expect(0, 7167, '\p{ In Lepcha}', ""); +Expect(1, 7167, '\p{^ In Lepcha}', ""); +Expect(1, 7167, '\P{ In Lepcha}', ""); +Expect(0, 7167, '\P{^ In Lepcha}', ""); +Error('\p{_in/a/CHAM}'); +Error('\P{_in/a/CHAM}'); +Expect(1, 43615, '\p{incham}', ""); +Expect(0, 43615, '\p{^incham}', ""); +Expect(0, 43615, '\P{incham}', ""); +Expect(1, 43615, '\P{^incham}', ""); +Expect(0, 43519, '\p{incham}', ""); +Expect(1, 43519, '\p{^incham}', ""); +Expect(1, 43519, '\P{incham}', ""); +Expect(0, 43519, '\P{^incham}', ""); +Expect(1, 43615, '\p{ IN-CHAM}', ""); +Expect(0, 43615, '\p{^ IN-CHAM}', ""); +Expect(0, 43615, '\P{ IN-CHAM}', ""); +Expect(1, 43615, '\P{^ IN-CHAM}', ""); +Expect(0, 43519, '\p{ IN-CHAM}', ""); +Expect(1, 43519, '\p{^ IN-CHAM}', ""); +Expect(1, 43519, '\P{ IN-CHAM}', ""); +Expect(0, 43519, '\P{^ IN-CHAM}', ""); +Error('\p{ In BOPOMOFO/a/}'); +Error('\P{ In BOPOMOFO/a/}'); +Expect(1, 12591, '\p{inbopomofo}', ""); +Expect(0, 12591, '\p{^inbopomofo}', ""); +Expect(0, 12591, '\P{inbopomofo}', ""); +Expect(1, 12591, '\P{^inbopomofo}', ""); +Expect(0, 12543, '\p{inbopomofo}', ""); +Expect(1, 12543, '\p{^inbopomofo}', ""); +Expect(1, 12543, '\P{inbopomofo}', ""); +Expect(0, 12543, '\P{^inbopomofo}', ""); +Expect(1, 12591, '\p{--In BOPOMOFO}', ""); +Expect(0, 12591, '\p{^--In BOPOMOFO}', ""); +Expect(0, 12591, '\P{--In BOPOMOFO}', ""); +Expect(1, 12591, '\P{^--In BOPOMOFO}', ""); +Expect(0, 12543, '\p{--In BOPOMOFO}', ""); +Expect(1, 12543, '\p{^--In BOPOMOFO}', ""); +Expect(1, 12543, '\P{--In BOPOMOFO}', ""); +Expect(0, 12543, '\P{^--In BOPOMOFO}', ""); +Error('\p{-CJK-Compatibility_Ideographs/a/}'); +Error('\P{-CJK-Compatibility_Ideographs/a/}'); +Expect(1, 64255, '\p{cjkcompatibilityideographs}', ""); +Expect(0, 64255, '\p{^cjkcompatibilityideographs}', ""); +Expect(0, 64255, '\P{cjkcompatibilityideographs}', ""); +Expect(1, 64255, '\P{^cjkcompatibilityideographs}', ""); +Expect(0, 63743, '\p{cjkcompatibilityideographs}', ""); +Expect(1, 63743, '\p{^cjkcompatibilityideographs}', ""); +Expect(1, 63743, '\P{cjkcompatibilityideographs}', ""); +Expect(0, 63743, '\P{^cjkcompatibilityideographs}', ""); +Expect(1, 64255, '\p{_CJK CompatibilityIdeographs}', ""); +Expect(0, 64255, '\p{^_CJK CompatibilityIdeographs}', ""); +Expect(0, 64255, '\P{_CJK CompatibilityIdeographs}', ""); +Expect(1, 64255, '\P{^_CJK CompatibilityIdeographs}', ""); +Expect(0, 63743, '\p{_CJK CompatibilityIdeographs}', ""); +Expect(1, 63743, '\p{^_CJK CompatibilityIdeographs}', ""); +Expect(1, 63743, '\P{_CJK CompatibilityIdeographs}', ""); +Expect(0, 63743, '\P{^_CJK CompatibilityIdeographs}', ""); +Error('\p{- is:=cjk Compatibility_IDEOGRAPHS}'); +Error('\P{- is:=cjk Compatibility_IDEOGRAPHS}'); +Expect(1, 64255, '\p{iscjkcompatibilityideographs}', ""); +Expect(0, 64255, '\p{^iscjkcompatibilityideographs}', ""); +Expect(0, 64255, '\P{iscjkcompatibilityideographs}', ""); +Expect(1, 64255, '\P{^iscjkcompatibilityideographs}', ""); +Expect(0, 63743, '\p{iscjkcompatibilityideographs}', ""); +Expect(1, 63743, '\p{^iscjkcompatibilityideographs}', ""); +Expect(1, 63743, '\P{iscjkcompatibilityideographs}', ""); +Expect(0, 63743, '\P{^iscjkcompatibilityideographs}', ""); +Expect(1, 64255, '\p{-isCJKCOMPATIBILITY Ideographs}', ""); +Expect(0, 64255, '\p{^-isCJKCOMPATIBILITY Ideographs}', ""); +Expect(0, 64255, '\P{-isCJKCOMPATIBILITY Ideographs}', ""); +Expect(1, 64255, '\P{^-isCJKCOMPATIBILITY Ideographs}', ""); +Expect(0, 63743, '\p{-isCJKCOMPATIBILITY Ideographs}', ""); +Expect(1, 63743, '\p{^-isCJKCOMPATIBILITY Ideographs}', ""); +Expect(1, 63743, '\P{-isCJKCOMPATIBILITY Ideographs}', ""); +Expect(0, 63743, '\P{^-isCJKCOMPATIBILITY Ideographs}', ""); +Error('\p{ -in:=CJK_COMPATIBILITY_Ideographs}'); +Error('\P{ -in:=CJK_COMPATIBILITY_Ideographs}'); +Expect(1, 64255, '\p{incjkcompatibilityideographs}', ""); +Expect(0, 64255, '\p{^incjkcompatibilityideographs}', ""); +Expect(0, 64255, '\P{incjkcompatibilityideographs}', ""); +Expect(1, 64255, '\P{^incjkcompatibilityideographs}', ""); +Expect(0, 63743, '\p{incjkcompatibilityideographs}', ""); +Expect(1, 63743, '\p{^incjkcompatibilityideographs}', ""); +Expect(1, 63743, '\P{incjkcompatibilityideographs}', ""); +Expect(0, 63743, '\P{^incjkcompatibilityideographs}', ""); +Expect(1, 64255, '\p{-_in CJK COMPATIBILITY-Ideographs}', ""); +Expect(0, 64255, '\p{^-_in CJK COMPATIBILITY-Ideographs}', ""); +Expect(0, 64255, '\P{-_in CJK COMPATIBILITY-Ideographs}', ""); +Expect(1, 64255, '\P{^-_in CJK COMPATIBILITY-Ideographs}', ""); +Expect(0, 63743, '\p{-_in CJK COMPATIBILITY-Ideographs}', ""); +Expect(1, 63743, '\p{^-_in CJK COMPATIBILITY-Ideographs}', ""); +Expect(1, 63743, '\P{-_in CJK COMPATIBILITY-Ideographs}', ""); +Expect(0, 63743, '\P{^-_in CJK COMPATIBILITY-Ideographs}', ""); +Error('\p{ :=arrows}'); +Error('\P{ :=arrows}'); +Expect(1, 8703, '\p{arrows}', ""); +Expect(0, 8703, '\p{^arrows}', ""); +Expect(0, 8703, '\P{arrows}', ""); +Expect(1, 8703, '\P{^arrows}', ""); +Expect(0, 8591, '\p{arrows}', ""); +Expect(1, 8591, '\p{^arrows}', ""); +Expect(1, 8591, '\P{arrows}', ""); +Expect(0, 8591, '\P{^arrows}', ""); +Expect(1, 8703, '\p{-Arrows}', ""); +Expect(0, 8703, '\p{^-Arrows}', ""); +Expect(0, 8703, '\P{-Arrows}', ""); +Expect(1, 8703, '\P{^-Arrows}', ""); +Expect(0, 8591, '\p{-Arrows}', ""); +Expect(1, 8591, '\p{^-Arrows}', ""); +Expect(1, 8591, '\P{-Arrows}', ""); +Expect(0, 8591, '\P{^-Arrows}', ""); +Error('\p{ _IS/a/Arrows}'); +Error('\P{ _IS/a/Arrows}'); +Expect(1, 8703, '\p{isarrows}', ""); +Expect(0, 8703, '\p{^isarrows}', ""); +Expect(0, 8703, '\P{isarrows}', ""); +Expect(1, 8703, '\P{^isarrows}', ""); +Expect(0, 8591, '\p{isarrows}', ""); +Expect(1, 8591, '\p{^isarrows}', ""); +Expect(1, 8591, '\P{isarrows}', ""); +Expect(0, 8591, '\P{^isarrows}', ""); +Expect(1, 8703, '\p{_-Is Arrows}', ""); +Expect(0, 8703, '\p{^_-Is Arrows}', ""); +Expect(0, 8703, '\P{_-Is Arrows}', ""); +Expect(1, 8703, '\P{^_-Is Arrows}', ""); +Expect(0, 8591, '\p{_-Is Arrows}', ""); +Expect(1, 8591, '\p{^_-Is Arrows}', ""); +Expect(1, 8591, '\P{_-Is Arrows}', ""); +Expect(0, 8591, '\P{^_-Is Arrows}', ""); +Error('\p{_ IN_Arrows/a/}'); +Error('\P{_ IN_Arrows/a/}'); +Expect(1, 8703, '\p{inarrows}', ""); +Expect(0, 8703, '\p{^inarrows}', ""); +Expect(0, 8703, '\P{inarrows}', ""); +Expect(1, 8703, '\P{^inarrows}', ""); +Expect(0, 8591, '\p{inarrows}', ""); +Expect(1, 8591, '\p{^inarrows}', ""); +Expect(1, 8591, '\P{inarrows}', ""); +Expect(0, 8591, '\P{^inarrows}', ""); +Expect(1, 8703, '\p{ in ARROWS}', ""); +Expect(0, 8703, '\p{^ in ARROWS}', ""); +Expect(0, 8703, '\P{ in ARROWS}', ""); +Expect(1, 8703, '\P{^ in ARROWS}', ""); +Expect(0, 8591, '\p{ in ARROWS}', ""); +Expect(1, 8591, '\p{^ in ARROWS}', ""); +Expect(1, 8591, '\P{ in ARROWS}', ""); +Expect(0, 8591, '\P{^ in ARROWS}', ""); +Error('\p{ _In/a/LAO}'); +Error('\P{ _In/a/LAO}'); +Expect(1, 3839, '\p{inlao}', ""); +Expect(0, 3839, '\p{^inlao}', ""); +Expect(0, 3839, '\P{inlao}', ""); +Expect(1, 3839, '\P{^inlao}', ""); +Expect(0, 3711, '\p{inlao}', ""); +Expect(1, 3711, '\p{^inlao}', ""); +Expect(1, 3711, '\P{inlao}', ""); +Expect(0, 3711, '\P{^inlao}', ""); +Expect(1, 3839, '\p{ in Lao}', ""); +Expect(0, 3839, '\p{^ in Lao}', ""); +Expect(0, 3839, '\P{ in Lao}', ""); +Expect(1, 3839, '\P{^ in Lao}', ""); +Expect(0, 3711, '\p{ in Lao}', ""); +Expect(1, 3711, '\p{^ in Lao}', ""); +Expect(1, 3711, '\P{ in Lao}', ""); +Expect(0, 3711, '\P{^ in Lao}', ""); +Error('\p{/a/ _Connector Punctuation}'); +Error('\P{/a/ _Connector Punctuation}'); +Expect(1, 95, '\p{connectorpunctuation}', ""); +Expect(0, 95, '\p{^connectorpunctuation}', ""); +Expect(0, 95, '\P{connectorpunctuation}', ""); +Expect(1, 95, '\P{^connectorpunctuation}', ""); +Expect(0, 94, '\p{connectorpunctuation}', ""); +Expect(1, 94, '\p{^connectorpunctuation}', ""); +Expect(1, 94, '\P{connectorpunctuation}', ""); +Expect(0, 94, '\P{^connectorpunctuation}', ""); +Expect(1, 95, '\p{ ConnectorPunctuation}', ""); +Expect(0, 95, '\p{^ ConnectorPunctuation}', ""); +Expect(0, 95, '\P{ ConnectorPunctuation}', ""); +Expect(1, 95, '\P{^ ConnectorPunctuation}', ""); +Expect(0, 94, '\p{ ConnectorPunctuation}', ""); +Expect(1, 94, '\p{^ ConnectorPunctuation}', ""); +Expect(1, 94, '\P{ ConnectorPunctuation}', ""); +Expect(0, 94, '\P{^ ConnectorPunctuation}', ""); +Error('\p{/a/ is Connector Punctuation}'); +Error('\P{/a/ is Connector Punctuation}'); +Expect(1, 95, '\p{isconnectorpunctuation}', ""); +Expect(0, 95, '\p{^isconnectorpunctuation}', ""); +Expect(0, 95, '\P{isconnectorpunctuation}', ""); +Expect(1, 95, '\P{^isconnectorpunctuation}', ""); +Expect(0, 94, '\p{isconnectorpunctuation}', ""); +Expect(1, 94, '\p{^isconnectorpunctuation}', ""); +Expect(1, 94, '\P{isconnectorpunctuation}', ""); +Expect(0, 94, '\P{^isconnectorpunctuation}', ""); +Expect(1, 95, '\p{_Is_Connector Punctuation}', ""); +Expect(0, 95, '\p{^_Is_Connector Punctuation}', ""); +Expect(0, 95, '\P{_Is_Connector Punctuation}', ""); +Expect(1, 95, '\P{^_Is_Connector Punctuation}', ""); +Expect(0, 94, '\p{_Is_Connector Punctuation}', ""); +Expect(1, 94, '\p{^_Is_Connector Punctuation}', ""); +Expect(1, 94, '\P{_Is_Connector Punctuation}', ""); +Expect(0, 94, '\P{^_Is_Connector Punctuation}', ""); +Error('\p{/a/ PC}'); +Error('\P{/a/ PC}'); +Expect(1, 95, '\p{pc}', ""); +Expect(0, 95, '\p{^pc}', ""); +Expect(0, 95, '\P{pc}', ""); +Expect(1, 95, '\P{^pc}', ""); +Expect(0, 94, '\p{pc}', ""); +Expect(1, 94, '\p{^pc}', ""); +Expect(1, 94, '\P{pc}', ""); +Expect(0, 94, '\P{^pc}', ""); +Expect(1, 95, '\p{--Pc}', ""); +Expect(0, 95, '\p{^--Pc}', ""); +Expect(0, 95, '\P{--Pc}', ""); +Expect(1, 95, '\P{^--Pc}', ""); +Expect(0, 94, '\p{--Pc}', ""); +Expect(1, 94, '\p{^--Pc}', ""); +Expect(1, 94, '\P{--Pc}', ""); +Expect(0, 94, '\P{^--Pc}', ""); +Error('\p{- Is/a/Pc}'); +Error('\P{- Is/a/Pc}'); +Expect(1, 95, '\p{ispc}', ""); +Expect(0, 95, '\p{^ispc}', ""); +Expect(0, 95, '\P{ispc}', ""); +Expect(1, 95, '\P{^ispc}', ""); +Expect(0, 94, '\p{ispc}', ""); +Expect(1, 94, '\p{^ispc}', ""); +Expect(1, 94, '\P{ispc}', ""); +Expect(0, 94, '\P{^ispc}', ""); +Expect(1, 95, '\p{IS pc}', ""); +Expect(0, 95, '\p{^IS pc}', ""); +Expect(0, 95, '\P{IS pc}', ""); +Expect(1, 95, '\P{^IS pc}', ""); +Expect(0, 94, '\p{IS pc}', ""); +Expect(1, 94, '\p{^IS pc}', ""); +Expect(1, 94, '\P{IS pc}', ""); +Expect(0, 94, '\P{^IS pc}', ""); +Error('\p{:= -VARIATION-SELECTORS}'); +Error('\P{:= -VARIATION-SELECTORS}'); +Expect(1, 65039, '\p{variationselectors}', ""); +Expect(0, 65039, '\p{^variationselectors}', ""); +Expect(0, 65039, '\P{variationselectors}', ""); +Expect(1, 65039, '\P{^variationselectors}', ""); +Expect(0, 65023, '\p{variationselectors}', ""); +Expect(1, 65023, '\p{^variationselectors}', ""); +Expect(1, 65023, '\P{variationselectors}', ""); +Expect(0, 65023, '\P{^variationselectors}', ""); +Expect(1, 65039, '\p{ Variation_Selectors}', ""); +Expect(0, 65039, '\p{^ Variation_Selectors}', ""); +Expect(0, 65039, '\P{ Variation_Selectors}', ""); +Expect(1, 65039, '\P{^ Variation_Selectors}', ""); +Expect(0, 65023, '\p{ Variation_Selectors}', ""); +Expect(1, 65023, '\p{^ Variation_Selectors}', ""); +Expect(1, 65023, '\P{ Variation_Selectors}', ""); +Expect(0, 65023, '\P{^ Variation_Selectors}', ""); +Error('\p{ is:=VARIATION Selectors}'); +Error('\P{ is:=VARIATION Selectors}'); +Expect(1, 65039, '\p{isvariationselectors}', ""); +Expect(0, 65039, '\p{^isvariationselectors}', ""); +Expect(0, 65039, '\P{isvariationselectors}', ""); +Expect(1, 65039, '\P{^isvariationselectors}', ""); +Expect(0, 65023, '\p{isvariationselectors}', ""); +Expect(1, 65023, '\p{^isvariationselectors}', ""); +Expect(1, 65023, '\P{isvariationselectors}', ""); +Expect(0, 65023, '\P{^isvariationselectors}', ""); +Expect(1, 65039, '\p{ is_VARIATION selectors}', ""); +Expect(0, 65039, '\p{^ is_VARIATION selectors}', ""); +Expect(0, 65039, '\P{ is_VARIATION selectors}', ""); +Expect(1, 65039, '\P{^ is_VARIATION selectors}', ""); +Expect(0, 65023, '\p{ is_VARIATION selectors}', ""); +Expect(1, 65023, '\p{^ is_VARIATION selectors}', ""); +Expect(1, 65023, '\P{ is_VARIATION selectors}', ""); +Expect(0, 65023, '\P{^ is_VARIATION selectors}', ""); +Error('\p{:=In Variation selectors}'); +Error('\P{:=In Variation selectors}'); +Expect(1, 65039, '\p{invariationselectors}', ""); +Expect(0, 65039, '\p{^invariationselectors}', ""); +Expect(0, 65039, '\P{invariationselectors}', ""); +Expect(1, 65039, '\P{^invariationselectors}', ""); +Expect(0, 65023, '\p{invariationselectors}', ""); +Expect(1, 65023, '\p{^invariationselectors}', ""); +Expect(1, 65023, '\P{invariationselectors}', ""); +Expect(0, 65023, '\P{^invariationselectors}', ""); +Expect(1, 65039, '\p{--IN variation_Selectors}', ""); +Expect(0, 65039, '\p{^--IN variation_Selectors}', ""); +Expect(0, 65039, '\P{--IN variation_Selectors}', ""); +Expect(1, 65039, '\P{^--IN variation_Selectors}', ""); +Expect(0, 65023, '\p{--IN variation_Selectors}', ""); +Expect(1, 65023, '\p{^--IN variation_Selectors}', ""); +Expect(1, 65023, '\P{--IN variation_Selectors}', ""); +Expect(0, 65023, '\P{^--IN variation_Selectors}', ""); +Error('\p{:=PRIVATE-Use}'); +Error('\P{:=PRIVATE-Use}'); +Expect(1, 63743, '\p{privateuse}', ""); +Expect(0, 63743, '\p{^privateuse}', ""); +Expect(0, 63743, '\P{privateuse}', ""); +Expect(1, 63743, '\P{^privateuse}', ""); +Expect(0, 7, '\p{privateuse}', ""); +Expect(1, 7, '\p{^privateuse}', ""); +Expect(1, 7, '\P{privateuse}', ""); +Expect(0, 7, '\P{^privateuse}', ""); +Expect(1, 63743, '\p{-PrivateUse}', ""); +Expect(0, 63743, '\p{^-PrivateUse}', ""); +Expect(0, 63743, '\P{-PrivateUse}', ""); +Expect(1, 63743, '\P{^-PrivateUse}', ""); +Expect(0, 7, '\p{-PrivateUse}', ""); +Expect(1, 7, '\p{^-PrivateUse}', ""); +Expect(1, 7, '\P{-PrivateUse}', ""); +Expect(0, 7, '\P{^-PrivateUse}', ""); +Error('\p{ Is_Private Use:=}'); +Error('\P{ Is_Private Use:=}'); +Expect(1, 63743, '\p{isprivateuse}', ""); +Expect(0, 63743, '\p{^isprivateuse}', ""); +Expect(0, 63743, '\P{isprivateuse}', ""); +Expect(1, 63743, '\P{^isprivateuse}', ""); +Expect(0, 7, '\p{isprivateuse}', ""); +Expect(1, 7, '\p{^isprivateuse}', ""); +Expect(1, 7, '\P{isprivateuse}', ""); +Expect(0, 7, '\P{^isprivateuse}', ""); +Expect(1, 63743, '\p{IS-PRIVATE_use}', ""); +Expect(0, 63743, '\p{^IS-PRIVATE_use}', ""); +Expect(0, 63743, '\P{IS-PRIVATE_use}', ""); +Expect(1, 63743, '\P{^IS-PRIVATE_use}', ""); +Expect(0, 7, '\p{IS-PRIVATE_use}', ""); +Expect(1, 7, '\p{^IS-PRIVATE_use}', ""); +Expect(1, 7, '\P{IS-PRIVATE_use}', ""); +Expect(0, 7, '\P{^IS-PRIVATE_use}', ""); +Error('\p{/a/-_Co}'); +Error('\P{/a/-_Co}'); +Expect(1, 63743, '\p{co}', ""); +Expect(0, 63743, '\p{^co}', ""); +Expect(0, 63743, '\P{co}', ""); +Expect(1, 63743, '\P{^co}', ""); +Expect(0, 7, '\p{co}', ""); +Expect(1, 7, '\p{^co}', ""); +Expect(1, 7, '\P{co}', ""); +Expect(0, 7, '\P{^co}', ""); +Expect(1, 63743, '\p{- co}', ""); +Expect(0, 63743, '\p{^- co}', ""); +Expect(0, 63743, '\P{- co}', ""); +Expect(1, 63743, '\P{^- co}', ""); +Expect(0, 7, '\p{- co}', ""); +Expect(1, 7, '\p{^- co}', ""); +Expect(1, 7, '\P{- co}', ""); +Expect(0, 7, '\P{^- co}', ""); +Error('\p{/a/ _IS co}'); +Error('\P{/a/ _IS co}'); +Expect(1, 63743, '\p{isco}', ""); +Expect(0, 63743, '\p{^isco}', ""); +Expect(0, 63743, '\P{isco}', ""); +Expect(1, 63743, '\P{^isco}', ""); +Expect(0, 7, '\p{isco}', ""); +Expect(1, 7, '\p{^isco}', ""); +Expect(1, 7, '\P{isco}', ""); +Expect(0, 7, '\P{^isco}', ""); +Expect(1, 63743, '\p{ ISCO}', ""); +Expect(0, 63743, '\p{^ ISCO}', ""); +Expect(0, 63743, '\P{ ISCO}', ""); +Expect(1, 63743, '\P{^ ISCO}', ""); +Expect(0, 7, '\p{ ISCO}', ""); +Expect(1, 7, '\p{^ ISCO}', ""); +Expect(1, 7, '\P{ ISCO}', ""); +Expect(0, 7, '\P{^ ISCO}', ""); +Error('\p{ /a/Dash PUNCTUATION}'); +Error('\P{ /a/Dash PUNCTUATION}'); +Expect(1, 45, '\p{dashpunctuation}', ""); +Expect(0, 45, '\p{^dashpunctuation}', ""); +Expect(0, 45, '\P{dashpunctuation}', ""); +Expect(1, 45, '\P{^dashpunctuation}', ""); +Expect(0, 44, '\p{dashpunctuation}', ""); +Expect(1, 44, '\p{^dashpunctuation}', ""); +Expect(1, 44, '\P{dashpunctuation}', ""); +Expect(0, 44, '\P{^dashpunctuation}', ""); +Expect(1, 45, '\p{-dashPunctuation}', ""); +Expect(0, 45, '\p{^-dashPunctuation}', ""); +Expect(0, 45, '\P{-dashPunctuation}', ""); +Expect(1, 45, '\P{^-dashPunctuation}', ""); +Expect(0, 44, '\p{-dashPunctuation}', ""); +Expect(1, 44, '\p{^-dashPunctuation}', ""); +Expect(1, 44, '\P{-dashPunctuation}', ""); +Expect(0, 44, '\P{^-dashPunctuation}', ""); +Error('\p{/a/-Is-DASH-Punctuation}'); +Error('\P{/a/-Is-DASH-Punctuation}'); +Expect(1, 45, '\p{isdashpunctuation}', ""); +Expect(0, 45, '\p{^isdashpunctuation}', ""); +Expect(0, 45, '\P{isdashpunctuation}', ""); +Expect(1, 45, '\P{^isdashpunctuation}', ""); +Expect(0, 44, '\p{isdashpunctuation}', ""); +Expect(1, 44, '\p{^isdashpunctuation}', ""); +Expect(1, 44, '\P{isdashpunctuation}', ""); +Expect(0, 44, '\P{^isdashpunctuation}', ""); +Expect(1, 45, '\p{ isDash Punctuation}', ""); +Expect(0, 45, '\p{^ isDash Punctuation}', ""); +Expect(0, 45, '\P{ isDash Punctuation}', ""); +Expect(1, 45, '\P{^ isDash Punctuation}', ""); +Expect(0, 44, '\p{ isDash Punctuation}', ""); +Expect(1, 44, '\p{^ isDash Punctuation}', ""); +Expect(1, 44, '\P{ isDash Punctuation}', ""); +Expect(0, 44, '\P{^ isDash Punctuation}', ""); +Error('\p{- pd/a/}'); +Error('\P{- pd/a/}'); +Expect(1, 45, '\p{pd}', ""); +Expect(0, 45, '\p{^pd}', ""); +Expect(0, 45, '\P{pd}', ""); +Expect(1, 45, '\P{^pd}', ""); +Expect(0, 44, '\p{pd}', ""); +Expect(1, 44, '\p{^pd}', ""); +Expect(1, 44, '\P{pd}', ""); +Expect(0, 44, '\P{^pd}', ""); +Expect(1, 45, '\p{ -Pd}', ""); +Expect(0, 45, '\p{^ -Pd}', ""); +Expect(0, 45, '\P{ -Pd}', ""); +Expect(1, 45, '\P{^ -Pd}', ""); +Expect(0, 44, '\p{ -Pd}', ""); +Expect(1, 44, '\p{^ -Pd}', ""); +Expect(1, 44, '\P{ -Pd}', ""); +Expect(0, 44, '\P{^ -Pd}', ""); +Error('\p{ -IS/a/pd}'); +Error('\P{ -IS/a/pd}'); +Expect(1, 45, '\p{ispd}', ""); +Expect(0, 45, '\p{^ispd}', ""); +Expect(0, 45, '\P{ispd}', ""); +Expect(1, 45, '\P{^ispd}', ""); +Expect(0, 44, '\p{ispd}', ""); +Expect(1, 44, '\p{^ispd}', ""); +Expect(1, 44, '\P{ispd}', ""); +Expect(0, 44, '\P{^ispd}', ""); +Expect(1, 45, '\p{ -Is-Pd}', ""); +Expect(0, 45, '\p{^ -Is-Pd}', ""); +Expect(0, 45, '\P{ -Is-Pd}', ""); +Expect(1, 45, '\P{^ -Is-Pd}', ""); +Expect(0, 44, '\p{ -Is-Pd}', ""); +Expect(1, 44, '\p{^ -Is-Pd}', ""); +Expect(1, 44, '\P{ -Is-Pd}', ""); +Expect(0, 44, '\P{^ -Is-Pd}', ""); +Error('\p{ :=bopomofo_Extended}'); +Error('\P{ :=bopomofo_Extended}'); +Expect(1, 12735, '\p{bopomofoextended}', ""); +Expect(0, 12735, '\p{^bopomofoextended}', ""); +Expect(0, 12735, '\P{bopomofoextended}', ""); +Expect(1, 12735, '\P{^bopomofoextended}', ""); +Expect(0, 12703, '\p{bopomofoextended}', ""); +Expect(1, 12703, '\p{^bopomofoextended}', ""); +Expect(1, 12703, '\P{bopomofoextended}', ""); +Expect(0, 12703, '\P{^bopomofoextended}', ""); +Expect(1, 12735, '\p{_ Bopomofo extended}', ""); +Expect(0, 12735, '\p{^_ Bopomofo extended}', ""); +Expect(0, 12735, '\P{_ Bopomofo extended}', ""); +Expect(1, 12735, '\P{^_ Bopomofo extended}', ""); +Expect(0, 12703, '\p{_ Bopomofo extended}', ""); +Expect(1, 12703, '\p{^_ Bopomofo extended}', ""); +Expect(1, 12703, '\P{_ Bopomofo extended}', ""); +Expect(0, 12703, '\P{^_ Bopomofo extended}', ""); +Error('\p{-:=is bopomofoExtended}'); +Error('\P{-:=is bopomofoExtended}'); +Expect(1, 12735, '\p{isbopomofoextended}', ""); +Expect(0, 12735, '\p{^isbopomofoextended}', ""); +Expect(0, 12735, '\P{isbopomofoextended}', ""); +Expect(1, 12735, '\P{^isbopomofoextended}', ""); +Expect(0, 12703, '\p{isbopomofoextended}', ""); +Expect(1, 12703, '\p{^isbopomofoextended}', ""); +Expect(1, 12703, '\P{isbopomofoextended}', ""); +Expect(0, 12703, '\P{^isbopomofoextended}', ""); +Expect(1, 12735, '\p{ -Is Bopomofoextended}', ""); +Expect(0, 12735, '\p{^ -Is Bopomofoextended}', ""); +Expect(0, 12735, '\P{ -Is Bopomofoextended}', ""); +Expect(1, 12735, '\P{^ -Is Bopomofoextended}', ""); +Expect(0, 12703, '\p{ -Is Bopomofoextended}', ""); +Expect(1, 12703, '\p{^ -Is Bopomofoextended}', ""); +Expect(1, 12703, '\P{ -Is Bopomofoextended}', ""); +Expect(0, 12703, '\P{^ -Is Bopomofoextended}', ""); +Error('\p{__In_bopomofo Extended/a/}'); +Error('\P{__In_bopomofo Extended/a/}'); +Expect(1, 12735, '\p{inbopomofoextended}', ""); +Expect(0, 12735, '\p{^inbopomofoextended}', ""); +Expect(0, 12735, '\P{inbopomofoextended}', ""); +Expect(1, 12735, '\P{^inbopomofoextended}', ""); +Expect(0, 12703, '\p{inbopomofoextended}', ""); +Expect(1, 12703, '\p{^inbopomofoextended}', ""); +Expect(1, 12703, '\P{inbopomofoextended}', ""); +Expect(0, 12703, '\P{^inbopomofoextended}', ""); +Expect(1, 12735, '\p{_ in BOPOMOFO-Extended}', ""); +Expect(0, 12735, '\p{^_ in BOPOMOFO-Extended}', ""); +Expect(0, 12735, '\P{_ in BOPOMOFO-Extended}', ""); +Expect(1, 12735, '\P{^_ in BOPOMOFO-Extended}', ""); +Expect(0, 12703, '\p{_ in BOPOMOFO-Extended}', ""); +Expect(1, 12703, '\p{^_ in BOPOMOFO-Extended}', ""); +Expect(1, 12703, '\P{_ in BOPOMOFO-Extended}', ""); +Expect(0, 12703, '\P{^_ in BOPOMOFO-Extended}', ""); +Error('\p{-/a/in_Khmer}'); +Error('\P{-/a/in_Khmer}'); +Expect(1, 6143, '\p{inkhmer}', ""); +Expect(0, 6143, '\p{^inkhmer}', ""); +Expect(0, 6143, '\P{inkhmer}', ""); +Expect(1, 6143, '\P{^inkhmer}', ""); +Expect(0, 6015, '\p{inkhmer}', ""); +Expect(1, 6015, '\p{^inkhmer}', ""); +Expect(1, 6015, '\P{inkhmer}', ""); +Expect(0, 6015, '\P{^inkhmer}', ""); +Expect(1, 6143, '\p{ in Khmer}', ""); +Expect(0, 6143, '\p{^ in Khmer}', ""); +Expect(0, 6143, '\P{ in Khmer}', ""); +Expect(1, 6143, '\P{^ in Khmer}', ""); +Expect(0, 6015, '\p{ in Khmer}', ""); +Expect(1, 6015, '\p{^ in Khmer}', ""); +Expect(1, 6015, '\P{ in Khmer}', ""); +Expect(0, 6015, '\P{^ in Khmer}', ""); +Error('\p{--General-Punctuation:=}'); +Error('\P{--General-Punctuation:=}'); +Expect(1, 8303, '\p{generalpunctuation}', ""); +Expect(0, 8303, '\p{^generalpunctuation}', ""); +Expect(0, 8303, '\P{generalpunctuation}', ""); +Expect(1, 8303, '\P{^generalpunctuation}', ""); +Expect(0, 8191, '\p{generalpunctuation}', ""); +Expect(1, 8191, '\p{^generalpunctuation}', ""); +Expect(1, 8191, '\P{generalpunctuation}', ""); +Expect(0, 8191, '\P{^generalpunctuation}', ""); +Expect(1, 8303, '\p{ General_Punctuation}', ""); +Expect(0, 8303, '\p{^ General_Punctuation}', ""); +Expect(0, 8303, '\P{ General_Punctuation}', ""); +Expect(1, 8303, '\P{^ General_Punctuation}', ""); +Expect(0, 8191, '\p{ General_Punctuation}', ""); +Expect(1, 8191, '\p{^ General_Punctuation}', ""); +Expect(1, 8191, '\P{ General_Punctuation}', ""); +Expect(0, 8191, '\P{^ General_Punctuation}', ""); +Error('\p{_ Is_GENERAL Punctuation:=}'); +Error('\P{_ Is_GENERAL Punctuation:=}'); +Expect(1, 8303, '\p{isgeneralpunctuation}', ""); +Expect(0, 8303, '\p{^isgeneralpunctuation}', ""); +Expect(0, 8303, '\P{isgeneralpunctuation}', ""); +Expect(1, 8303, '\P{^isgeneralpunctuation}', ""); +Expect(0, 8191, '\p{isgeneralpunctuation}', ""); +Expect(1, 8191, '\p{^isgeneralpunctuation}', ""); +Expect(1, 8191, '\P{isgeneralpunctuation}', ""); +Expect(0, 8191, '\P{^isgeneralpunctuation}', ""); +Expect(1, 8303, '\p{ _Is generalPUNCTUATION}', ""); +Expect(0, 8303, '\p{^ _Is generalPUNCTUATION}', ""); +Expect(0, 8303, '\P{ _Is generalPUNCTUATION}', ""); +Expect(1, 8303, '\P{^ _Is generalPUNCTUATION}', ""); +Expect(0, 8191, '\p{ _Is generalPUNCTUATION}', ""); +Expect(1, 8191, '\p{^ _Is generalPUNCTUATION}', ""); +Expect(1, 8191, '\P{ _Is generalPUNCTUATION}', ""); +Expect(0, 8191, '\P{^ _Is generalPUNCTUATION}', ""); +Error('\p{ _IN:=GeneralPUNCTUATION}'); +Error('\P{ _IN:=GeneralPUNCTUATION}'); +Expect(1, 8303, '\p{ingeneralpunctuation}', ""); +Expect(0, 8303, '\p{^ingeneralpunctuation}', ""); +Expect(0, 8303, '\P{ingeneralpunctuation}', ""); +Expect(1, 8303, '\P{^ingeneralpunctuation}', ""); +Expect(0, 8191, '\p{ingeneralpunctuation}', ""); +Expect(1, 8191, '\p{^ingeneralpunctuation}', ""); +Expect(1, 8191, '\P{ingeneralpunctuation}', ""); +Expect(0, 8191, '\P{^ingeneralpunctuation}', ""); +Expect(1, 8303, '\p{--In GENERALPUNCTUATION}', ""); +Expect(0, 8303, '\p{^--In GENERALPUNCTUATION}', ""); +Expect(0, 8303, '\P{--In GENERALPUNCTUATION}', ""); +Expect(1, 8303, '\P{^--In GENERALPUNCTUATION}', ""); +Expect(0, 8191, '\p{--In GENERALPUNCTUATION}', ""); +Expect(1, 8191, '\p{^--In GENERALPUNCTUATION}', ""); +Expect(1, 8191, '\P{--In GENERALPUNCTUATION}', ""); +Expect(0, 8191, '\P{^--In GENERALPUNCTUATION}', ""); +Error('\p{in Georgian/a/}'); +Error('\P{in Georgian/a/}'); +Expect(1, 4351, '\p{ingeorgian}', ""); +Expect(0, 4351, '\p{^ingeorgian}', ""); +Expect(0, 4351, '\P{ingeorgian}', ""); +Expect(1, 4351, '\P{^ingeorgian}', ""); +Expect(0, 4255, '\p{ingeorgian}', ""); +Expect(1, 4255, '\p{^ingeorgian}', ""); +Expect(1, 4255, '\P{ingeorgian}', ""); +Expect(0, 4255, '\P{^ingeorgian}', ""); +Expect(1, 4351, '\p{_-In_GEORGIAN}', ""); +Expect(0, 4351, '\p{^_-In_GEORGIAN}', ""); +Expect(0, 4351, '\P{_-In_GEORGIAN}', ""); +Expect(1, 4351, '\P{^_-In_GEORGIAN}', ""); +Expect(0, 4255, '\p{_-In_GEORGIAN}', ""); +Expect(1, 4255, '\p{^_-In_GEORGIAN}', ""); +Expect(1, 4255, '\P{_-In_GEORGIAN}', ""); +Expect(0, 4255, '\P{^_-In_GEORGIAN}', ""); +Error('\p{-/a/IN-Limbu}'); +Error('\P{-/a/IN-Limbu}'); +Expect(1, 6479, '\p{inlimbu}', ""); +Expect(0, 6479, '\p{^inlimbu}', ""); +Expect(0, 6479, '\P{inlimbu}', ""); +Expect(1, 6479, '\P{^inlimbu}', ""); +Expect(0, 6399, '\p{inlimbu}', ""); +Expect(1, 6399, '\p{^inlimbu}', ""); +Expect(1, 6399, '\P{inlimbu}', ""); +Expect(0, 6399, '\P{^inlimbu}', ""); +Expect(1, 6479, '\p{- IN Limbu}', ""); +Expect(0, 6479, '\p{^- IN Limbu}', ""); +Expect(0, 6479, '\P{- IN Limbu}', ""); +Expect(1, 6479, '\P{^- IN Limbu}', ""); +Expect(0, 6399, '\p{- IN Limbu}', ""); +Expect(1, 6399, '\p{^- IN Limbu}', ""); +Expect(1, 6399, '\P{- IN Limbu}', ""); +Expect(0, 6399, '\P{^- IN Limbu}', ""); +Error('\p{-_IN:=LYDIAN}'); +Error('\P{-_IN:=LYDIAN}'); +Expect(1, 67903, '\p{inlydian}', ""); +Expect(0, 67903, '\p{^inlydian}', ""); +Expect(0, 67903, '\P{inlydian}', ""); +Expect(1, 67903, '\P{^inlydian}', ""); +Expect(0, 67871, '\p{inlydian}', ""); +Expect(1, 67871, '\p{^inlydian}', ""); +Expect(1, 67871, '\P{inlydian}', ""); +Expect(0, 67871, '\P{^inlydian}', ""); +Expect(1, 67903, '\p{_INLydian}', ""); +Expect(0, 67903, '\p{^_INLydian}', ""); +Expect(0, 67903, '\P{_INLydian}', ""); +Expect(1, 67903, '\P{^_INLydian}', ""); +Expect(0, 67871, '\p{_INLydian}', ""); +Expect(1, 67871, '\p{^_INLydian}', ""); +Expect(1, 67871, '\P{_INLydian}', ""); +Expect(0, 67871, '\P{^_INLydian}', ""); +Error('\p{/a/_InKharoshthi}'); +Error('\P{/a/_InKharoshthi}'); +Expect(1, 68191, '\p{inkharoshthi}', ""); +Expect(0, 68191, '\p{^inkharoshthi}', ""); +Expect(0, 68191, '\P{inkharoshthi}', ""); +Expect(1, 68191, '\P{^inkharoshthi}', ""); +Expect(0, 68095, '\p{inkharoshthi}', ""); +Expect(1, 68095, '\p{^inkharoshthi}', ""); +Expect(1, 68095, '\P{inkharoshthi}', ""); +Expect(0, 68095, '\P{^inkharoshthi}', ""); +Expect(1, 68191, '\p{ In-kharoshthi}', ""); +Expect(0, 68191, '\p{^ In-kharoshthi}', ""); +Expect(0, 68191, '\P{ In-kharoshthi}', ""); +Expect(1, 68191, '\P{^ In-kharoshthi}', ""); +Expect(0, 68095, '\p{ In-kharoshthi}', ""); +Expect(1, 68095, '\p{^ In-kharoshthi}', ""); +Expect(1, 68095, '\P{ In-kharoshthi}', ""); +Expect(0, 68095, '\P{^ In-kharoshthi}', ""); +Error('\p{:=--Dash}'); +Error('\P{:=--Dash}'); +Expect(1, 45, '\p{dash}', ""); +Expect(0, 45, '\p{^dash}', ""); +Expect(0, 45, '\P{dash}', ""); +Expect(1, 45, '\P{^dash}', ""); +Expect(0, 44, '\p{dash}', ""); +Expect(1, 44, '\p{^dash}', ""); +Expect(1, 44, '\P{dash}', ""); +Expect(0, 44, '\P{^dash}', ""); +Expect(1, 45, '\p{ _DASH}', ""); +Expect(0, 45, '\p{^ _DASH}', ""); +Expect(0, 45, '\P{ _DASH}', ""); +Expect(1, 45, '\P{^ _DASH}', ""); +Expect(0, 44, '\p{ _DASH}', ""); +Expect(1, 44, '\p{^ _DASH}', ""); +Expect(1, 44, '\P{ _DASH}', ""); +Expect(0, 44, '\P{^ _DASH}', ""); +Error('\p{/a/--Is DASH}'); +Error('\P{/a/--Is DASH}'); +Expect(1, 45, '\p{isdash}', ""); +Expect(0, 45, '\p{^isdash}', ""); +Expect(0, 45, '\P{isdash}', ""); +Expect(1, 45, '\P{^isdash}', ""); +Expect(0, 44, '\p{isdash}', ""); +Expect(1, 44, '\p{^isdash}', ""); +Expect(1, 44, '\P{isdash}', ""); +Expect(0, 44, '\P{^isdash}', ""); +Expect(1, 45, '\p{Is-dash}', ""); +Expect(0, 45, '\p{^Is-dash}', ""); +Expect(0, 45, '\P{Is-dash}', ""); +Expect(1, 45, '\P{^Is-dash}', ""); +Expect(0, 44, '\p{Is-dash}', ""); +Expect(1, 44, '\p{^Is-dash}', ""); +Expect(1, 44, '\P{Is-dash}', ""); +Expect(0, 44, '\P{^Is-dash}', ""); +Error('\p{ _COUNTING_rod/a/Numerals}'); +Error('\P{ _COUNTING_rod/a/Numerals}'); +Expect(1, 119679, '\p{countingrodnumerals}', ""); +Expect(0, 119679, '\p{^countingrodnumerals}', ""); +Expect(0, 119679, '\P{countingrodnumerals}', ""); +Expect(1, 119679, '\P{^countingrodnumerals}', ""); +Expect(0, 119647, '\p{countingrodnumerals}', ""); +Expect(1, 119647, '\p{^countingrodnumerals}', ""); +Expect(1, 119647, '\P{countingrodnumerals}', ""); +Expect(0, 119647, '\P{^countingrodnumerals}', ""); +Expect(1, 119679, '\p{ counting_Rod_Numerals}', ""); +Expect(0, 119679, '\p{^ counting_Rod_Numerals}', ""); +Expect(0, 119679, '\P{ counting_Rod_Numerals}', ""); +Expect(1, 119679, '\P{^ counting_Rod_Numerals}', ""); +Expect(0, 119647, '\p{ counting_Rod_Numerals}', ""); +Expect(1, 119647, '\p{^ counting_Rod_Numerals}', ""); +Expect(1, 119647, '\P{ counting_Rod_Numerals}', ""); +Expect(0, 119647, '\P{^ counting_Rod_Numerals}', ""); +Error('\p{ IS:=COUNTING Rod-NUMERALS}'); +Error('\P{ IS:=COUNTING Rod-NUMERALS}'); +Expect(1, 119679, '\p{iscountingrodnumerals}', ""); +Expect(0, 119679, '\p{^iscountingrodnumerals}', ""); +Expect(0, 119679, '\P{iscountingrodnumerals}', ""); +Expect(1, 119679, '\P{^iscountingrodnumerals}', ""); +Expect(0, 119647, '\p{iscountingrodnumerals}', ""); +Expect(1, 119647, '\p{^iscountingrodnumerals}', ""); +Expect(1, 119647, '\P{iscountingrodnumerals}', ""); +Expect(0, 119647, '\P{^iscountingrodnumerals}', ""); +Expect(1, 119679, '\p{ IS-counting_Rod NUMERALS}', ""); +Expect(0, 119679, '\p{^ IS-counting_Rod NUMERALS}', ""); +Expect(0, 119679, '\P{ IS-counting_Rod NUMERALS}', ""); +Expect(1, 119679, '\P{^ IS-counting_Rod NUMERALS}', ""); +Expect(0, 119647, '\p{ IS-counting_Rod NUMERALS}', ""); +Expect(1, 119647, '\p{^ IS-counting_Rod NUMERALS}', ""); +Expect(1, 119647, '\P{ IS-counting_Rod NUMERALS}', ""); +Expect(0, 119647, '\P{^ IS-counting_Rod NUMERALS}', ""); +Error('\p{ :=In-Counting_rodNumerals}'); +Error('\P{ :=In-Counting_rodNumerals}'); +Expect(1, 119679, '\p{incountingrodnumerals}', ""); +Expect(0, 119679, '\p{^incountingrodnumerals}', ""); +Expect(0, 119679, '\P{incountingrodnumerals}', ""); +Expect(1, 119679, '\P{^incountingrodnumerals}', ""); +Expect(0, 119647, '\p{incountingrodnumerals}', ""); +Expect(1, 119647, '\p{^incountingrodnumerals}', ""); +Expect(1, 119647, '\P{incountingrodnumerals}', ""); +Expect(0, 119647, '\P{^incountingrodnumerals}', ""); +Expect(1, 119679, '\p{ in-Counting_Rod_numerals}', ""); +Expect(0, 119679, '\p{^ in-Counting_Rod_numerals}', ""); +Expect(0, 119679, '\P{ in-Counting_Rod_numerals}', ""); +Expect(1, 119679, '\P{^ in-Counting_Rod_numerals}', ""); +Expect(0, 119647, '\p{ in-Counting_Rod_numerals}', ""); +Expect(1, 119647, '\p{^ in-Counting_Rod_numerals}', ""); +Expect(1, 119647, '\P{ in-Counting_Rod_numerals}', ""); +Expect(0, 119647, '\P{^ in-Counting_Rod_numerals}', ""); +Error('\p{In:=tamil}'); +Error('\P{In:=tamil}'); +Expect(1, 3071, '\p{intamil}', ""); +Expect(0, 3071, '\p{^intamil}', ""); +Expect(0, 3071, '\P{intamil}', ""); +Expect(1, 3071, '\P{^intamil}', ""); +Expect(0, 2943, '\p{intamil}', ""); +Expect(1, 2943, '\p{^intamil}', ""); +Expect(1, 2943, '\P{intamil}', ""); +Expect(0, 2943, '\P{^intamil}', ""); +Expect(1, 3071, '\p{- IN_Tamil}', ""); +Expect(0, 3071, '\p{^- IN_Tamil}', ""); +Expect(0, 3071, '\P{- IN_Tamil}', ""); +Expect(1, 3071, '\P{^- IN_Tamil}', ""); +Expect(0, 2943, '\p{- IN_Tamil}', ""); +Expect(1, 2943, '\p{^- IN_Tamil}', ""); +Expect(1, 2943, '\P{- IN_Tamil}', ""); +Expect(0, 2943, '\P{^- IN_Tamil}', ""); +Error('\p{ :=IN Ethiopic}'); +Error('\P{ :=IN Ethiopic}'); +Expect(1, 4991, '\p{inethiopic}', ""); +Expect(0, 4991, '\p{^inethiopic}', ""); +Expect(0, 4991, '\P{inethiopic}', ""); +Expect(1, 4991, '\P{^inethiopic}', ""); +Expect(0, 4607, '\p{inethiopic}', ""); +Expect(1, 4607, '\p{^inethiopic}', ""); +Expect(1, 4607, '\P{inethiopic}', ""); +Expect(0, 4607, '\P{^inethiopic}', ""); +Expect(1, 4991, '\p{-_In-ETHIOPIC}', ""); +Expect(0, 4991, '\p{^-_In-ETHIOPIC}', ""); +Expect(0, 4991, '\P{-_In-ETHIOPIC}', ""); +Expect(1, 4991, '\P{^-_In-ETHIOPIC}', ""); +Expect(0, 4607, '\p{-_In-ETHIOPIC}', ""); +Expect(1, 4607, '\p{^-_In-ETHIOPIC}', ""); +Expect(1, 4607, '\P{-_In-ETHIOPIC}', ""); +Expect(0, 4607, '\P{^-_In-ETHIOPIC}', ""); +Error('\p{-In-Tai Le:=}'); +Error('\P{-In-Tai Le:=}'); +Expect(1, 6527, '\p{intaile}', ""); +Expect(0, 6527, '\p{^intaile}', ""); +Expect(0, 6527, '\P{intaile}', ""); +Expect(1, 6527, '\P{^intaile}', ""); +Expect(0, 6479, '\p{intaile}', ""); +Expect(1, 6479, '\p{^intaile}', ""); +Expect(1, 6479, '\P{intaile}', ""); +Expect(0, 6479, '\P{^intaile}', ""); +Expect(1, 6527, '\p{_ In-Tai-Le}', ""); +Expect(0, 6527, '\p{^_ In-Tai-Le}', ""); +Expect(0, 6527, '\P{_ In-Tai-Le}', ""); +Expect(1, 6527, '\P{^_ In-Tai-Le}', ""); +Expect(0, 6479, '\p{_ In-Tai-Le}', ""); +Expect(1, 6479, '\p{^_ In-Tai-Le}', ""); +Expect(1, 6479, '\P{_ In-Tai-Le}', ""); +Expect(0, 6479, '\P{^_ In-Tai-Le}', ""); +Error('\p{ /a/KANGXI_Radicals}'); +Error('\P{ /a/KANGXI_Radicals}'); +Expect(1, 12255, '\p{kangxiradicals}', ""); +Expect(0, 12255, '\p{^kangxiradicals}', ""); +Expect(0, 12255, '\P{kangxiradicals}', ""); +Expect(1, 12255, '\P{^kangxiradicals}', ""); +Expect(0, 12031, '\p{kangxiradicals}', ""); +Expect(1, 12031, '\p{^kangxiradicals}', ""); +Expect(1, 12031, '\P{kangxiradicals}', ""); +Expect(0, 12031, '\P{^kangxiradicals}', ""); +Expect(1, 12255, '\p{ -kangxi-Radicals}', ""); +Expect(0, 12255, '\p{^ -kangxi-Radicals}', ""); +Expect(0, 12255, '\P{ -kangxi-Radicals}', ""); +Expect(1, 12255, '\P{^ -kangxi-Radicals}', ""); +Expect(0, 12031, '\p{ -kangxi-Radicals}', ""); +Expect(1, 12031, '\p{^ -kangxi-Radicals}', ""); +Expect(1, 12031, '\P{ -kangxi-Radicals}', ""); +Expect(0, 12031, '\P{^ -kangxi-Radicals}', ""); +Error('\p{:= Is Kangxi_RADICALS}'); +Error('\P{:= Is Kangxi_RADICALS}'); +Expect(1, 12255, '\p{iskangxiradicals}', ""); +Expect(0, 12255, '\p{^iskangxiradicals}', ""); +Expect(0, 12255, '\P{iskangxiradicals}', ""); +Expect(1, 12255, '\P{^iskangxiradicals}', ""); +Expect(0, 12031, '\p{iskangxiradicals}', ""); +Expect(1, 12031, '\p{^iskangxiradicals}', ""); +Expect(1, 12031, '\P{iskangxiradicals}', ""); +Expect(0, 12031, '\P{^iskangxiradicals}', ""); +Expect(1, 12255, '\p{-_IS Kangxi_radicals}', ""); +Expect(0, 12255, '\p{^-_IS Kangxi_radicals}', ""); +Expect(0, 12255, '\P{-_IS Kangxi_radicals}', ""); +Expect(1, 12255, '\P{^-_IS Kangxi_radicals}', ""); +Expect(0, 12031, '\p{-_IS Kangxi_radicals}', ""); +Expect(1, 12031, '\p{^-_IS Kangxi_radicals}', ""); +Expect(1, 12031, '\P{-_IS Kangxi_radicals}', ""); +Expect(0, 12031, '\P{^-_IS Kangxi_radicals}', ""); +Error('\p{-/a/IN Kangxi Radicals}'); +Error('\P{-/a/IN Kangxi Radicals}'); +Expect(1, 12255, '\p{inkangxiradicals}', ""); +Expect(0, 12255, '\p{^inkangxiradicals}', ""); +Expect(0, 12255, '\P{inkangxiradicals}', ""); +Expect(1, 12255, '\P{^inkangxiradicals}', ""); +Expect(0, 12031, '\p{inkangxiradicals}', ""); +Expect(1, 12031, '\p{^inkangxiradicals}', ""); +Expect(1, 12031, '\P{inkangxiradicals}', ""); +Expect(0, 12031, '\P{^inkangxiradicals}', ""); +Expect(1, 12255, '\p{ In kangxi-radicals}', ""); +Expect(0, 12255, '\p{^ In kangxi-radicals}', ""); +Expect(0, 12255, '\P{ In kangxi-radicals}', ""); +Expect(1, 12255, '\P{^ In kangxi-radicals}', ""); +Expect(0, 12031, '\p{ In kangxi-radicals}', ""); +Expect(1, 12031, '\p{^ In kangxi-radicals}', ""); +Expect(1, 12031, '\P{ In kangxi-radicals}', ""); +Expect(0, 12031, '\P{^ In kangxi-radicals}', ""); +Error('\p{ /a/In-Hebrew}'); +Error('\P{ /a/In-Hebrew}'); +Expect(1, 1535, '\p{inhebrew}', ""); +Expect(0, 1535, '\p{^inhebrew}', ""); +Expect(0, 1535, '\P{inhebrew}', ""); +Expect(1, 1535, '\P{^inhebrew}', ""); +Expect(0, 1423, '\p{inhebrew}', ""); +Expect(1, 1423, '\p{^inhebrew}', ""); +Expect(1, 1423, '\P{inhebrew}', ""); +Expect(0, 1423, '\P{^inhebrew}', ""); +Expect(1, 1535, '\p{-_In HEBREW}', ""); +Expect(0, 1535, '\p{^-_In HEBREW}', ""); +Expect(0, 1535, '\P{-_In HEBREW}', ""); +Expect(1, 1535, '\P{^-_In HEBREW}', ""); +Expect(0, 1423, '\p{-_In HEBREW}', ""); +Expect(1, 1423, '\p{^-_In HEBREW}', ""); +Expect(1, 1423, '\P{-_In HEBREW}', ""); +Expect(0, 1423, '\P{^-_In HEBREW}', ""); +Error('\p{ In New:=tai_Lue}'); +Error('\P{ In New:=tai_Lue}'); +Expect(1, 6623, '\p{innewtailue}', ""); +Expect(0, 6623, '\p{^innewtailue}', ""); +Expect(0, 6623, '\P{innewtailue}', ""); +Expect(1, 6623, '\P{^innewtailue}', ""); +Expect(0, 6527, '\p{innewtailue}', ""); +Expect(1, 6527, '\p{^innewtailue}', ""); +Expect(1, 6527, '\P{innewtailue}', ""); +Expect(0, 6527, '\P{^innewtailue}', ""); +Expect(1, 6623, '\p{--in_New TAI-Lue}', ""); +Expect(0, 6623, '\p{^--in_New TAI-Lue}', ""); +Expect(0, 6623, '\P{--in_New TAI-Lue}', ""); +Expect(1, 6623, '\P{^--in_New TAI-Lue}', ""); +Expect(0, 6527, '\p{--in_New TAI-Lue}', ""); +Expect(1, 6527, '\p{^--in_New TAI-Lue}', ""); +Expect(1, 6527, '\P{--in_New TAI-Lue}', ""); +Expect(0, 6527, '\P{^--in_New TAI-Lue}', ""); +Error('\p{ :=CJKcompatibility_FORMS}'); +Error('\P{ :=CJKcompatibility_FORMS}'); +Expect(1, 65103, '\p{cjkcompatibilityforms}', ""); +Expect(0, 65103, '\p{^cjkcompatibilityforms}', ""); +Expect(0, 65103, '\P{cjkcompatibilityforms}', ""); +Expect(1, 65103, '\P{^cjkcompatibilityforms}', ""); +Expect(0, 65071, '\p{cjkcompatibilityforms}', ""); +Expect(1, 65071, '\p{^cjkcompatibilityforms}', ""); +Expect(1, 65071, '\P{cjkcompatibilityforms}', ""); +Expect(0, 65071, '\P{^cjkcompatibilityforms}', ""); +Expect(1, 65103, '\p{_-CJK Compatibility Forms}', ""); +Expect(0, 65103, '\p{^_-CJK Compatibility Forms}', ""); +Expect(0, 65103, '\P{_-CJK Compatibility Forms}', ""); +Expect(1, 65103, '\P{^_-CJK Compatibility Forms}', ""); +Expect(0, 65071, '\p{_-CJK Compatibility Forms}', ""); +Expect(1, 65071, '\p{^_-CJK Compatibility Forms}', ""); +Expect(1, 65071, '\P{_-CJK Compatibility Forms}', ""); +Expect(0, 65071, '\P{^_-CJK Compatibility Forms}', ""); +Error('\p{ :=Is-CJKcompatibility Forms}'); +Error('\P{ :=Is-CJKcompatibility Forms}'); +Expect(1, 65103, '\p{iscjkcompatibilityforms}', ""); +Expect(0, 65103, '\p{^iscjkcompatibilityforms}', ""); +Expect(0, 65103, '\P{iscjkcompatibilityforms}', ""); +Expect(1, 65103, '\P{^iscjkcompatibilityforms}', ""); +Expect(0, 65071, '\p{iscjkcompatibilityforms}', ""); +Expect(1, 65071, '\p{^iscjkcompatibilityforms}', ""); +Expect(1, 65071, '\P{iscjkcompatibilityforms}', ""); +Expect(0, 65071, '\P{^iscjkcompatibilityforms}', ""); +Expect(1, 65103, '\p{ _Is cjkcompatibility-forms}', ""); +Expect(0, 65103, '\p{^ _Is cjkcompatibility-forms}', ""); +Expect(0, 65103, '\P{ _Is cjkcompatibility-forms}', ""); +Expect(1, 65103, '\P{^ _Is cjkcompatibility-forms}', ""); +Expect(0, 65071, '\p{ _Is cjkcompatibility-forms}', ""); +Expect(1, 65071, '\p{^ _Is cjkcompatibility-forms}', ""); +Expect(1, 65071, '\P{ _Is cjkcompatibility-forms}', ""); +Expect(0, 65071, '\P{^ _Is cjkcompatibility-forms}', ""); +Error('\p{-/a/in_CJK-COMPATIBILITY Forms}'); +Error('\P{-/a/in_CJK-COMPATIBILITY Forms}'); +Expect(1, 65103, '\p{incjkcompatibilityforms}', ""); +Expect(0, 65103, '\p{^incjkcompatibilityforms}', ""); +Expect(0, 65103, '\P{incjkcompatibilityforms}', ""); +Expect(1, 65103, '\P{^incjkcompatibilityforms}', ""); +Expect(0, 65071, '\p{incjkcompatibilityforms}', ""); +Expect(1, 65071, '\p{^incjkcompatibilityforms}', ""); +Expect(1, 65071, '\P{incjkcompatibilityforms}', ""); +Expect(0, 65071, '\P{^incjkcompatibilityforms}', ""); +Expect(1, 65103, '\p{ IN CJK-CompatibilityForms}', ""); +Expect(0, 65103, '\p{^ IN CJK-CompatibilityForms}', ""); +Expect(0, 65103, '\P{ IN CJK-CompatibilityForms}', ""); +Expect(1, 65103, '\P{^ IN CJK-CompatibilityForms}', ""); +Expect(0, 65071, '\p{ IN CJK-CompatibilityForms}', ""); +Expect(1, 65071, '\p{^ IN CJK-CompatibilityForms}', ""); +Expect(1, 65071, '\P{ IN CJK-CompatibilityForms}', ""); +Expect(0, 65071, '\P{^ IN CJK-CompatibilityForms}', ""); +Error('\p{_ In:=Saurashtra}'); +Error('\P{_ In:=Saurashtra}'); +Expect(1, 43231, '\p{insaurashtra}', ""); +Expect(0, 43231, '\p{^insaurashtra}', ""); +Expect(0, 43231, '\P{insaurashtra}', ""); +Expect(1, 43231, '\P{^insaurashtra}', ""); +Expect(0, 43135, '\p{insaurashtra}', ""); +Expect(1, 43135, '\p{^insaurashtra}', ""); +Expect(1, 43135, '\P{insaurashtra}', ""); +Expect(0, 43135, '\P{^insaurashtra}', ""); +Expect(1, 43231, '\p{--In saurashtra}', ""); +Expect(0, 43231, '\p{^--In saurashtra}', ""); +Expect(0, 43231, '\P{--In saurashtra}', ""); +Expect(1, 43231, '\P{^--In saurashtra}', ""); +Expect(0, 43135, '\p{--In saurashtra}', ""); +Expect(1, 43135, '\p{^--In saurashtra}', ""); +Expect(1, 43135, '\P{--In saurashtra}', ""); +Expect(0, 43135, '\P{^--In saurashtra}', ""); +Error('\p{ _in/a/gujarati}'); +Error('\P{ _in/a/gujarati}'); +Expect(1, 2815, '\p{ingujarati}', ""); +Expect(0, 2815, '\p{^ingujarati}', ""); +Expect(0, 2815, '\P{ingujarati}', ""); +Expect(1, 2815, '\P{^ingujarati}', ""); +Expect(0, 2687, '\p{ingujarati}', ""); +Expect(1, 2687, '\p{^ingujarati}', ""); +Expect(1, 2687, '\P{ingujarati}', ""); +Expect(0, 2687, '\P{^ingujarati}', ""); +Expect(1, 2815, '\p{_-IN-GUJARATI}', ""); +Expect(0, 2815, '\p{^_-IN-GUJARATI}', ""); +Expect(0, 2815, '\P{_-IN-GUJARATI}', ""); +Expect(1, 2815, '\P{^_-IN-GUJARATI}', ""); +Expect(0, 2687, '\p{_-IN-GUJARATI}', ""); +Expect(1, 2687, '\p{^_-IN-GUJARATI}', ""); +Expect(1, 2687, '\P{_-IN-GUJARATI}', ""); +Expect(0, 2687, '\P{^_-IN-GUJARATI}', ""); +Error('\p{:= _In OSMANYA}'); +Error('\P{:= _In OSMANYA}'); +Expect(1, 66735, '\p{inosmanya}', ""); +Expect(0, 66735, '\p{^inosmanya}', ""); +Expect(0, 66735, '\P{inosmanya}', ""); +Expect(1, 66735, '\P{^inosmanya}', ""); +Expect(0, 66687, '\p{inosmanya}', ""); +Expect(1, 66687, '\p{^inosmanya}', ""); +Expect(1, 66687, '\P{inosmanya}', ""); +Expect(0, 66687, '\P{^inosmanya}', ""); +Expect(1, 66735, '\p{ _InOsmanya}', ""); +Expect(0, 66735, '\p{^ _InOsmanya}', ""); +Expect(0, 66735, '\P{ _InOsmanya}', ""); +Expect(1, 66735, '\P{^ _InOsmanya}', ""); +Expect(0, 66687, '\p{ _InOsmanya}', ""); +Expect(1, 66687, '\p{^ _InOsmanya}', ""); +Expect(1, 66687, '\P{ _InOsmanya}', ""); +Expect(0, 66687, '\P{^ _InOsmanya}', ""); +Error('\p{:= in_tifinagh}'); +Error('\P{:= in_tifinagh}'); +Expect(1, 11647, '\p{intifinagh}', ""); +Expect(0, 11647, '\p{^intifinagh}', ""); +Expect(0, 11647, '\P{intifinagh}', ""); +Expect(1, 11647, '\P{^intifinagh}', ""); +Expect(0, 11567, '\p{intifinagh}', ""); +Expect(1, 11567, '\p{^intifinagh}', ""); +Expect(1, 11567, '\P{intifinagh}', ""); +Expect(0, 11567, '\P{^intifinagh}', ""); +Expect(1, 11647, '\p{ -In-tifinagh}', ""); +Expect(0, 11647, '\p{^ -In-tifinagh}', ""); +Expect(0, 11647, '\P{ -In-tifinagh}', ""); +Expect(1, 11647, '\P{^ -In-tifinagh}', ""); +Expect(0, 11567, '\p{ -In-tifinagh}', ""); +Expect(1, 11567, '\p{^ -In-tifinagh}', ""); +Expect(1, 11567, '\P{ -In-tifinagh}', ""); +Expect(0, 11567, '\P{^ -In-tifinagh}', ""); +Error('\p{-_POSIXPRINT:=}'); +Error('\P{-_POSIXPRINT:=}'); +Expect(1, 126, '\p{posixprint}', ""); +Expect(0, 126, '\p{^posixprint}', ""); +Expect(0, 126, '\P{posixprint}', ""); +Expect(1, 126, '\P{^posixprint}', ""); +Expect(0, 7, '\p{posixprint}', ""); +Expect(1, 7, '\p{^posixprint}', ""); +Expect(1, 7, '\P{posixprint}', ""); +Expect(0, 7, '\P{^posixprint}', ""); +Expect(1, 126, '\p{_ posixprint}', ""); +Expect(0, 126, '\p{^_ posixprint}', ""); +Expect(0, 126, '\P{_ posixprint}', ""); +Expect(1, 126, '\P{^_ posixprint}', ""); +Expect(0, 7, '\p{_ posixprint}', ""); +Expect(1, 7, '\p{^_ posixprint}', ""); +Expect(1, 7, '\P{_ posixprint}', ""); +Expect(0, 7, '\P{^_ posixprint}', ""); +Error('\p{/a/-is posixprint}'); +Error('\P{/a/-is posixprint}'); +Expect(1, 126, '\p{isposixprint}', ""); +Expect(0, 126, '\p{^isposixprint}', ""); +Expect(0, 126, '\P{isposixprint}', ""); +Expect(1, 126, '\P{^isposixprint}', ""); +Expect(0, 7, '\p{isposixprint}', ""); +Expect(1, 7, '\p{^isposixprint}', ""); +Expect(1, 7, '\P{isposixprint}', ""); +Expect(0, 7, '\P{^isposixprint}', ""); +Expect(1, 126, '\p{_is-PosixPrint}', ""); +Expect(0, 126, '\p{^_is-PosixPrint}', ""); +Expect(0, 126, '\P{_is-PosixPrint}', ""); +Expect(1, 126, '\P{^_is-PosixPrint}', ""); +Expect(0, 7, '\p{_is-PosixPrint}', ""); +Expect(1, 7, '\p{^_is-PosixPrint}', ""); +Expect(1, 7, '\P{_is-PosixPrint}', ""); +Expect(0, 7, '\P{^_is-PosixPrint}', ""); +Error('\p{ in Hanunoo/a/}'); +Error('\P{ in Hanunoo/a/}'); +Expect(1, 5951, '\p{inhanunoo}', ""); +Expect(0, 5951, '\p{^inhanunoo}', ""); +Expect(0, 5951, '\P{inhanunoo}', ""); +Expect(1, 5951, '\P{^inhanunoo}', ""); +Expect(0, 5919, '\p{inhanunoo}', ""); +Expect(1, 5919, '\p{^inhanunoo}', ""); +Expect(1, 5919, '\P{inhanunoo}', ""); +Expect(0, 5919, '\P{^inhanunoo}', ""); +Expect(1, 5951, '\p{ IN-Hanunoo}', ""); +Expect(0, 5951, '\p{^ IN-Hanunoo}', ""); +Expect(0, 5951, '\P{ IN-Hanunoo}', ""); +Expect(1, 5951, '\P{^ IN-Hanunoo}', ""); +Expect(0, 5919, '\p{ IN-Hanunoo}', ""); +Expect(1, 5919, '\p{^ IN-Hanunoo}', ""); +Expect(1, 5919, '\P{ IN-Hanunoo}', ""); +Expect(0, 5919, '\P{^ IN-Hanunoo}', ""); +Error('\p{ /a/IN_Cyrillic}'); +Error('\P{ /a/IN_Cyrillic}'); +Expect(1, 1279, '\p{incyrillic}', ""); +Expect(0, 1279, '\p{^incyrillic}', ""); +Expect(0, 1279, '\P{incyrillic}', ""); +Expect(1, 1279, '\P{^incyrillic}', ""); +Expect(0, 1023, '\p{incyrillic}', ""); +Expect(1, 1023, '\p{^incyrillic}', ""); +Expect(1, 1023, '\P{incyrillic}', ""); +Expect(0, 1023, '\P{^incyrillic}', ""); +Expect(1, 1279, '\p{ IN_Cyrillic}', ""); +Expect(0, 1279, '\p{^ IN_Cyrillic}', ""); +Expect(0, 1279, '\P{ IN_Cyrillic}', ""); +Expect(1, 1279, '\P{^ IN_Cyrillic}', ""); +Expect(0, 1023, '\p{ IN_Cyrillic}', ""); +Expect(1, 1023, '\p{^ IN_Cyrillic}', ""); +Expect(1, 1023, '\P{ IN_Cyrillic}', ""); +Expect(0, 1023, '\P{^ IN_Cyrillic}', ""); +Error('\p{_ IN Buhid:=}'); +Error('\P{_ IN Buhid:=}'); +Expect(1, 5983, '\p{inbuhid}', ""); +Expect(0, 5983, '\p{^inbuhid}', ""); +Expect(0, 5983, '\P{inbuhid}', ""); +Expect(1, 5983, '\P{^inbuhid}', ""); +Expect(0, 5951, '\p{inbuhid}', ""); +Expect(1, 5951, '\p{^inbuhid}', ""); +Expect(1, 5951, '\P{inbuhid}', ""); +Expect(0, 5951, '\P{^inbuhid}', ""); +Expect(1, 5983, '\p{ In Buhid}', ""); +Expect(0, 5983, '\p{^ In Buhid}', ""); +Expect(0, 5983, '\P{ In Buhid}', ""); +Expect(1, 5983, '\P{^ In Buhid}', ""); +Expect(0, 5951, '\p{ In Buhid}', ""); +Expect(1, 5951, '\p{^ In Buhid}', ""); +Expect(1, 5951, '\P{ In Buhid}', ""); +Expect(0, 5951, '\P{^ In Buhid}', ""); +Error('\p{/a/__-CASE IGNORABLE}'); +Error('\P{/a/__-CASE IGNORABLE}'); +Expect(1, 39, '\p{_Case_ignorable}', ""); +Expect(0, 39, '\p{^_Case_ignorable}', ""); +Expect(0, 39, '\P{_Case_ignorable}', ""); +Expect(1, 39, '\P{^_Case_ignorable}', ""); +Expect(0, 38, '\p{_Case_ignorable}', ""); +Expect(1, 38, '\p{^_Case_ignorable}', ""); +Expect(1, 38, '\P{_Case_ignorable}', ""); +Expect(0, 38, '\P{^_Case_ignorable}', ""); +Error('\p{:=inRunic}'); +Error('\P{:=inRunic}'); +Expect(1, 5887, '\p{inrunic}', ""); +Expect(0, 5887, '\p{^inrunic}', ""); +Expect(0, 5887, '\P{inrunic}', ""); +Expect(1, 5887, '\P{^inrunic}', ""); +Expect(0, 5791, '\p{inrunic}', ""); +Expect(1, 5791, '\p{^inrunic}', ""); +Expect(1, 5791, '\P{inrunic}', ""); +Expect(0, 5791, '\P{^inrunic}', ""); +Expect(1, 5887, '\p{ In_runic}', ""); +Expect(0, 5887, '\p{^ In_runic}', ""); +Expect(0, 5887, '\P{ In_runic}', ""); +Expect(1, 5887, '\P{^ In_runic}', ""); +Expect(0, 5791, '\p{ In_runic}', ""); +Expect(1, 5791, '\p{^ In_runic}', ""); +Expect(1, 5791, '\P{ In_runic}', ""); +Expect(0, 5791, '\P{^ In_runic}', ""); +Error('\p{IDS_Binary_Operator=__Yes/a/}'); +Error('\P{IDS_Binary_Operator=__Yes/a/}'); +Expect(1, 12273, '\p{IDS_Binary_Operator=yes}', ""); +Expect(0, 12273, '\p{^IDS_Binary_Operator=yes}', ""); +Expect(0, 12273, '\P{IDS_Binary_Operator=yes}', ""); +Expect(1, 12273, '\P{^IDS_Binary_Operator=yes}', ""); +Expect(0, 12271, '\p{IDS_Binary_Operator=yes}', ""); +Expect(1, 12271, '\p{^IDS_Binary_Operator=yes}', ""); +Expect(1, 12271, '\P{IDS_Binary_Operator=yes}', ""); +Expect(0, 12271, '\P{^IDS_Binary_Operator=yes}', ""); +Expect(1, 12273, '\p{IDS_Binary_Operator: _ Yes}', ""); +Expect(0, 12273, '\p{^IDS_Binary_Operator: _ Yes}', ""); +Expect(0, 12273, '\P{IDS_Binary_Operator: _ Yes}', ""); +Expect(1, 12273, '\P{^IDS_Binary_Operator: _ Yes}', ""); +Expect(0, 12271, '\p{IDS_Binary_Operator: _ Yes}', ""); +Expect(1, 12271, '\p{^IDS_Binary_Operator: _ Yes}', ""); +Expect(1, 12271, '\P{IDS_Binary_Operator: _ Yes}', ""); +Expect(0, 12271, '\P{^IDS_Binary_Operator: _ Yes}', ""); +Error('\p{IDSB:/a/ y}'); +Error('\P{IDSB:/a/ y}'); +Expect(1, 12273, '\p{IDSB=y}', ""); +Expect(0, 12273, '\p{^IDSB=y}', ""); +Expect(0, 12273, '\P{IDSB=y}', ""); +Expect(1, 12273, '\P{^IDSB=y}', ""); +Expect(0, 12271, '\p{IDSB=y}', ""); +Expect(1, 12271, '\p{^IDSB=y}', ""); +Expect(1, 12271, '\P{IDSB=y}', ""); +Expect(0, 12271, '\P{^IDSB=y}', ""); +Expect(1, 12273, '\p{IDSB=Y}', ""); +Expect(0, 12273, '\p{^IDSB=Y}', ""); +Expect(0, 12273, '\P{IDSB=Y}', ""); +Expect(1, 12273, '\P{^IDSB=Y}', ""); +Expect(0, 12271, '\p{IDSB=Y}', ""); +Expect(1, 12271, '\p{^IDSB=Y}', ""); +Expect(1, 12271, '\P{IDSB=Y}', ""); +Expect(0, 12271, '\P{^IDSB=Y}', ""); +Error('\p{Is_IDS_Binary_Operator=:= t}'); +Error('\P{Is_IDS_Binary_Operator=:= t}'); +Expect(1, 12273, '\p{Is_IDS_Binary_Operator=t}', ""); +Expect(0, 12273, '\p{^Is_IDS_Binary_Operator=t}', ""); +Expect(0, 12273, '\P{Is_IDS_Binary_Operator=t}', ""); +Expect(1, 12273, '\P{^Is_IDS_Binary_Operator=t}', ""); +Expect(0, 12271, '\p{Is_IDS_Binary_Operator=t}', ""); +Expect(1, 12271, '\p{^Is_IDS_Binary_Operator=t}', ""); +Expect(1, 12271, '\P{Is_IDS_Binary_Operator=t}', ""); +Expect(0, 12271, '\P{^Is_IDS_Binary_Operator=t}', ""); +Expect(1, 12273, '\p{Is_IDS_Binary_Operator=-_t}', ""); +Expect(0, 12273, '\p{^Is_IDS_Binary_Operator=-_t}', ""); +Expect(0, 12273, '\P{Is_IDS_Binary_Operator=-_t}', ""); +Expect(1, 12273, '\P{^Is_IDS_Binary_Operator=-_t}', ""); +Expect(0, 12271, '\p{Is_IDS_Binary_Operator=-_t}', ""); +Expect(1, 12271, '\p{^Is_IDS_Binary_Operator=-_t}', ""); +Expect(1, 12271, '\P{Is_IDS_Binary_Operator=-_t}', ""); +Expect(0, 12271, '\P{^Is_IDS_Binary_Operator=-_t}', ""); +Error('\p{Is_IDSB= _True/a/}'); +Error('\P{Is_IDSB= _True/a/}'); +Expect(1, 12273, '\p{Is_IDSB=true}', ""); +Expect(0, 12273, '\p{^Is_IDSB=true}', ""); +Expect(0, 12273, '\P{Is_IDSB=true}', ""); +Expect(1, 12273, '\P{^Is_IDSB=true}', ""); +Expect(0, 12271, '\p{Is_IDSB=true}', ""); +Expect(1, 12271, '\p{^Is_IDSB=true}', ""); +Expect(1, 12271, '\P{Is_IDSB=true}', ""); +Expect(0, 12271, '\P{^Is_IDSB=true}', ""); +Expect(1, 12273, '\p{Is_IDSB=_TRUE}', ""); +Expect(0, 12273, '\p{^Is_IDSB=_TRUE}', ""); +Expect(0, 12273, '\P{Is_IDSB=_TRUE}', ""); +Expect(1, 12273, '\P{^Is_IDSB=_TRUE}', ""); +Expect(0, 12271, '\p{Is_IDSB=_TRUE}', ""); +Expect(1, 12271, '\p{^Is_IDSB=_TRUE}', ""); +Expect(1, 12271, '\P{Is_IDSB=_TRUE}', ""); +Expect(0, 12271, '\P{^Is_IDSB=_TRUE}', ""); +Error('\p{IDS_Binary_Operator: /a/_-no}'); +Error('\P{IDS_Binary_Operator: /a/_-no}'); +Expect(1, 12271, '\p{IDS_Binary_Operator=no}', ""); +Expect(0, 12271, '\p{^IDS_Binary_Operator=no}', ""); +Expect(0, 12271, '\P{IDS_Binary_Operator=no}', ""); +Expect(1, 12271, '\P{^IDS_Binary_Operator=no}', ""); +Expect(0, 12273, '\p{IDS_Binary_Operator=no}', ""); +Expect(1, 12273, '\p{^IDS_Binary_Operator=no}', ""); +Expect(1, 12273, '\P{IDS_Binary_Operator=no}', ""); +Expect(0, 12273, '\P{^IDS_Binary_Operator=no}', ""); +Expect(1, 12271, '\p{IDS_Binary_Operator=-No}', ""); +Expect(0, 12271, '\p{^IDS_Binary_Operator=-No}', ""); +Expect(0, 12271, '\P{IDS_Binary_Operator=-No}', ""); +Expect(1, 12271, '\P{^IDS_Binary_Operator=-No}', ""); +Expect(0, 12273, '\p{IDS_Binary_Operator=-No}', ""); +Expect(1, 12273, '\p{^IDS_Binary_Operator=-No}', ""); +Expect(1, 12273, '\P{IDS_Binary_Operator=-No}', ""); +Expect(0, 12273, '\P{^IDS_Binary_Operator=-No}', ""); +Error('\p{IDSB= :=N}'); +Error('\P{IDSB= :=N}'); +Expect(1, 12271, '\p{IDSB=n}', ""); +Expect(0, 12271, '\p{^IDSB=n}', ""); +Expect(0, 12271, '\P{IDSB=n}', ""); +Expect(1, 12271, '\P{^IDSB=n}', ""); +Expect(0, 12273, '\p{IDSB=n}', ""); +Expect(1, 12273, '\p{^IDSB=n}', ""); +Expect(1, 12273, '\P{IDSB=n}', ""); +Expect(0, 12273, '\P{^IDSB=n}', ""); +Expect(1, 12271, '\p{IDSB=- N}', ""); +Expect(0, 12271, '\p{^IDSB=- N}', ""); +Expect(0, 12271, '\P{IDSB=- N}', ""); +Expect(1, 12271, '\P{^IDSB=- N}', ""); +Expect(0, 12273, '\p{IDSB=- N}', ""); +Expect(1, 12273, '\p{^IDSB=- N}', ""); +Expect(1, 12273, '\P{IDSB=- N}', ""); +Expect(0, 12273, '\P{^IDSB=- N}', ""); +Error('\p{Is_IDS_Binary_Operator= /a/F}'); +Error('\P{Is_IDS_Binary_Operator= /a/F}'); +Expect(1, 12271, '\p{Is_IDS_Binary_Operator:f}', ""); +Expect(0, 12271, '\p{^Is_IDS_Binary_Operator:f}', ""); +Expect(0, 12271, '\P{Is_IDS_Binary_Operator:f}', ""); +Expect(1, 12271, '\P{^Is_IDS_Binary_Operator:f}', ""); +Expect(0, 12273, '\p{Is_IDS_Binary_Operator:f}', ""); +Expect(1, 12273, '\p{^Is_IDS_Binary_Operator:f}', ""); +Expect(1, 12273, '\P{Is_IDS_Binary_Operator:f}', ""); +Expect(0, 12273, '\P{^Is_IDS_Binary_Operator:f}', ""); +Expect(1, 12271, '\p{Is_IDS_Binary_Operator=_F}', ""); +Expect(0, 12271, '\p{^Is_IDS_Binary_Operator=_F}', ""); +Expect(0, 12271, '\P{Is_IDS_Binary_Operator=_F}', ""); +Expect(1, 12271, '\P{^Is_IDS_Binary_Operator=_F}', ""); +Expect(0, 12273, '\p{Is_IDS_Binary_Operator=_F}', ""); +Expect(1, 12273, '\p{^Is_IDS_Binary_Operator=_F}', ""); +Expect(1, 12273, '\P{Is_IDS_Binary_Operator=_F}', ""); +Expect(0, 12273, '\P{^Is_IDS_Binary_Operator=_F}', ""); +Error('\p{Is_IDSB=:=-false}'); +Error('\P{Is_IDSB=:=-false}'); +Expect(1, 12271, '\p{Is_IDSB=false}', ""); +Expect(0, 12271, '\p{^Is_IDSB=false}', ""); +Expect(0, 12271, '\P{Is_IDSB=false}', ""); +Expect(1, 12271, '\P{^Is_IDSB=false}', ""); +Expect(0, 12273, '\p{Is_IDSB=false}', ""); +Expect(1, 12273, '\p{^Is_IDSB=false}', ""); +Expect(1, 12273, '\P{Is_IDSB=false}', ""); +Expect(0, 12273, '\P{^Is_IDSB=false}', ""); +Expect(1, 12271, '\p{Is_IDSB=_ False}', ""); +Expect(0, 12271, '\p{^Is_IDSB=_ False}', ""); +Expect(0, 12271, '\P{Is_IDSB=_ False}', ""); +Expect(1, 12271, '\P{^Is_IDSB=_ False}', ""); +Expect(0, 12273, '\p{Is_IDSB=_ False}', ""); +Expect(1, 12273, '\p{^Is_IDSB=_ False}', ""); +Expect(1, 12273, '\P{Is_IDSB=_ False}', ""); +Expect(0, 12273, '\P{^Is_IDSB=_ False}', ""); +Error('\p{General_Category=:=_symbol}'); +Error('\P{General_Category=:=_symbol}'); +Expect(1, 36, '\p{General_Category=symbol}', ""); +Expect(0, 36, '\p{^General_Category=symbol}', ""); +Expect(0, 36, '\P{General_Category=symbol}', ""); +Expect(1, 36, '\P{^General_Category=symbol}', ""); +Expect(0, 35, '\p{General_Category=symbol}', ""); +Expect(1, 35, '\p{^General_Category=symbol}', ""); +Expect(1, 35, '\P{General_Category=symbol}', ""); +Expect(0, 35, '\P{^General_Category=symbol}', ""); +Expect(1, 36, '\p{General_Category= Symbol}', ""); +Expect(0, 36, '\p{^General_Category= Symbol}', ""); +Expect(0, 36, '\P{General_Category= Symbol}', ""); +Expect(1, 36, '\P{^General_Category= Symbol}', ""); +Expect(0, 35, '\p{General_Category= Symbol}', ""); +Expect(1, 35, '\p{^General_Category= Symbol}', ""); +Expect(1, 35, '\P{General_Category= Symbol}', ""); +Expect(0, 35, '\P{^General_Category= Symbol}', ""); +Error('\p{Gc=-_S:=}'); +Error('\P{Gc=-_S:=}'); +Expect(1, 36, '\p{Gc=s}', ""); +Expect(0, 36, '\p{^Gc=s}', ""); +Expect(0, 36, '\P{Gc=s}', ""); +Expect(1, 36, '\P{^Gc=s}', ""); +Expect(0, 35, '\p{Gc=s}', ""); +Expect(1, 35, '\p{^Gc=s}', ""); +Expect(1, 35, '\P{Gc=s}', ""); +Expect(0, 35, '\P{^Gc=s}', ""); +Expect(1, 36, '\p{Gc: S}', ""); +Expect(0, 36, '\p{^Gc: S}', ""); +Expect(0, 36, '\P{Gc: S}', ""); +Expect(1, 36, '\P{^Gc: S}', ""); +Expect(0, 35, '\p{Gc: S}', ""); +Expect(1, 35, '\p{^Gc: S}', ""); +Expect(1, 35, '\P{Gc: S}', ""); +Expect(0, 35, '\P{^Gc: S}', ""); +Error('\p{Category=/a/Symbol}'); +Error('\P{Category=/a/Symbol}'); +Expect(1, 36, '\p{Category=symbol}', ""); +Expect(0, 36, '\p{^Category=symbol}', ""); +Expect(0, 36, '\P{Category=symbol}', ""); +Expect(1, 36, '\P{^Category=symbol}', ""); +Expect(0, 35, '\p{Category=symbol}', ""); +Expect(1, 35, '\p{^Category=symbol}', ""); +Expect(1, 35, '\P{Category=symbol}', ""); +Expect(0, 35, '\P{^Category=symbol}', ""); +Expect(1, 36, '\p{Category=--Symbol}', ""); +Expect(0, 36, '\p{^Category=--Symbol}', ""); +Expect(0, 36, '\P{Category=--Symbol}', ""); +Expect(1, 36, '\P{^Category=--Symbol}', ""); +Expect(0, 35, '\p{Category=--Symbol}', ""); +Expect(1, 35, '\p{^Category=--Symbol}', ""); +Expect(1, 35, '\P{Category=--Symbol}', ""); +Expect(0, 35, '\P{^Category=--Symbol}', ""); +Error('\p{Is_General_Category: S/a/}'); +Error('\P{Is_General_Category: S/a/}'); +Expect(1, 36, '\p{Is_General_Category=s}', ""); +Expect(0, 36, '\p{^Is_General_Category=s}', ""); +Expect(0, 36, '\P{Is_General_Category=s}', ""); +Expect(1, 36, '\P{^Is_General_Category=s}', ""); +Expect(0, 35, '\p{Is_General_Category=s}', ""); +Expect(1, 35, '\p{^Is_General_Category=s}', ""); +Expect(1, 35, '\P{Is_General_Category=s}', ""); +Expect(0, 35, '\P{^Is_General_Category=s}', ""); +Expect(1, 36, '\p{Is_General_Category=__s}', ""); +Expect(0, 36, '\p{^Is_General_Category=__s}', ""); +Expect(0, 36, '\P{Is_General_Category=__s}', ""); +Expect(1, 36, '\P{^Is_General_Category=__s}', ""); +Expect(0, 35, '\p{Is_General_Category=__s}', ""); +Expect(1, 35, '\p{^Is_General_Category=__s}', ""); +Expect(1, 35, '\P{Is_General_Category=__s}', ""); +Expect(0, 35, '\P{^Is_General_Category=__s}', ""); +Error('\p{Is_Gc=-_Symbol:=}'); +Error('\P{Is_Gc=-_Symbol:=}'); +Expect(1, 36, '\p{Is_Gc=symbol}', ""); +Expect(0, 36, '\p{^Is_Gc=symbol}', ""); +Expect(0, 36, '\P{Is_Gc=symbol}', ""); +Expect(1, 36, '\P{^Is_Gc=symbol}', ""); +Expect(0, 35, '\p{Is_Gc=symbol}', ""); +Expect(1, 35, '\p{^Is_Gc=symbol}', ""); +Expect(1, 35, '\P{Is_Gc=symbol}', ""); +Expect(0, 35, '\P{^Is_Gc=symbol}', ""); +Expect(1, 36, '\p{Is_Gc=Symbol}', ""); +Expect(0, 36, '\p{^Is_Gc=Symbol}', ""); +Expect(0, 36, '\P{Is_Gc=Symbol}', ""); +Expect(1, 36, '\P{^Is_Gc=Symbol}', ""); +Expect(0, 35, '\p{Is_Gc=Symbol}', ""); +Expect(1, 35, '\p{^Is_Gc=Symbol}', ""); +Expect(1, 35, '\P{Is_Gc=Symbol}', ""); +Expect(0, 35, '\P{^Is_Gc=Symbol}', ""); +Error('\p{Is_Category=:=-_S}'); +Error('\P{Is_Category=:=-_S}'); +Expect(1, 36, '\p{Is_Category=s}', ""); +Expect(0, 36, '\p{^Is_Category=s}', ""); +Expect(0, 36, '\P{Is_Category=s}', ""); +Expect(1, 36, '\P{^Is_Category=s}', ""); +Expect(0, 35, '\p{Is_Category=s}', ""); +Expect(1, 35, '\p{^Is_Category=s}', ""); +Expect(1, 35, '\P{Is_Category=s}', ""); +Expect(0, 35, '\P{^Is_Category=s}', ""); +Expect(1, 36, '\p{Is_Category= _S}', ""); +Expect(0, 36, '\p{^Is_Category= _S}', ""); +Expect(0, 36, '\P{Is_Category= _S}', ""); +Expect(1, 36, '\P{^Is_Category= _S}', ""); +Expect(0, 35, '\p{Is_Category= _S}', ""); +Expect(1, 35, '\p{^Is_Category= _S}', ""); +Expect(1, 35, '\P{Is_Category= _S}', ""); +Expect(0, 35, '\P{^Is_Category= _S}', ""); +Error('\p{General_Category= /a/SPACING-Mark}'); +Error('\P{General_Category= /a/SPACING-Mark}'); +Expect(1, 2307, '\p{General_Category=spacingmark}', ""); +Expect(0, 2307, '\p{^General_Category=spacingmark}', ""); +Expect(0, 2307, '\P{General_Category=spacingmark}', ""); +Expect(1, 2307, '\P{^General_Category=spacingmark}', ""); +Expect(0, 2306, '\p{General_Category=spacingmark}', ""); +Expect(1, 2306, '\p{^General_Category=spacingmark}', ""); +Expect(1, 2306, '\P{General_Category=spacingmark}', ""); +Expect(0, 2306, '\P{^General_Category=spacingmark}', ""); +Expect(1, 2307, '\p{General_Category= _spacing_Mark}', ""); +Expect(0, 2307, '\p{^General_Category= _spacing_Mark}', ""); +Expect(0, 2307, '\P{General_Category= _spacing_Mark}', ""); +Expect(1, 2307, '\P{^General_Category= _spacing_Mark}', ""); +Expect(0, 2306, '\p{General_Category= _spacing_Mark}', ""); +Expect(1, 2306, '\p{^General_Category= _spacing_Mark}', ""); +Expect(1, 2306, '\P{General_Category= _spacing_Mark}', ""); +Expect(0, 2306, '\P{^General_Category= _spacing_Mark}', ""); +Error('\p{Gc: MC/a/}'); +Error('\P{Gc: MC/a/}'); +Expect(1, 2307, '\p{Gc=mc}', ""); +Expect(0, 2307, '\p{^Gc=mc}', ""); +Expect(0, 2307, '\P{Gc=mc}', ""); +Expect(1, 2307, '\P{^Gc=mc}', ""); +Expect(0, 2306, '\p{Gc=mc}', ""); +Expect(1, 2306, '\p{^Gc=mc}', ""); +Expect(1, 2306, '\P{Gc=mc}', ""); +Expect(0, 2306, '\P{^Gc=mc}', ""); +Expect(1, 2307, '\p{Gc: _Mc}', ""); +Expect(0, 2307, '\p{^Gc: _Mc}', ""); +Expect(0, 2307, '\P{Gc: _Mc}', ""); +Expect(1, 2307, '\P{^Gc: _Mc}', ""); +Expect(0, 2306, '\p{Gc: _Mc}', ""); +Expect(1, 2306, '\p{^Gc: _Mc}', ""); +Expect(1, 2306, '\P{Gc: _Mc}', ""); +Expect(0, 2306, '\P{^Gc: _Mc}', ""); +Error('\p{Category: /a/ SPACING mark}'); +Error('\P{Category: /a/ SPACING mark}'); +Expect(1, 2307, '\p{Category: spacingmark}', ""); +Expect(0, 2307, '\p{^Category: spacingmark}', ""); +Expect(0, 2307, '\P{Category: spacingmark}', ""); +Expect(1, 2307, '\P{^Category: spacingmark}', ""); +Expect(0, 2306, '\p{Category: spacingmark}', ""); +Expect(1, 2306, '\p{^Category: spacingmark}', ""); +Expect(1, 2306, '\P{Category: spacingmark}', ""); +Expect(0, 2306, '\P{^Category: spacingmark}', ""); +Expect(1, 2307, '\p{Category=_SpacingMark}', ""); +Expect(0, 2307, '\p{^Category=_SpacingMark}', ""); +Expect(0, 2307, '\P{Category=_SpacingMark}', ""); +Expect(1, 2307, '\P{^Category=_SpacingMark}', ""); +Expect(0, 2306, '\p{Category=_SpacingMark}', ""); +Expect(1, 2306, '\p{^Category=_SpacingMark}', ""); +Expect(1, 2306, '\P{Category=_SpacingMark}', ""); +Expect(0, 2306, '\P{^Category=_SpacingMark}', ""); +Error('\p{Is_General_Category=/a/ mc}'); +Error('\P{Is_General_Category=/a/ mc}'); +Expect(1, 2307, '\p{Is_General_Category=mc}', ""); +Expect(0, 2307, '\p{^Is_General_Category=mc}', ""); +Expect(0, 2307, '\P{Is_General_Category=mc}', ""); +Expect(1, 2307, '\P{^Is_General_Category=mc}', ""); +Expect(0, 2306, '\p{Is_General_Category=mc}', ""); +Expect(1, 2306, '\p{^Is_General_Category=mc}', ""); +Expect(1, 2306, '\P{Is_General_Category=mc}', ""); +Expect(0, 2306, '\P{^Is_General_Category=mc}', ""); +Expect(1, 2307, '\p{Is_General_Category=_Mc}', ""); +Expect(0, 2307, '\p{^Is_General_Category=_Mc}', ""); +Expect(0, 2307, '\P{Is_General_Category=_Mc}', ""); +Expect(1, 2307, '\P{^Is_General_Category=_Mc}', ""); +Expect(0, 2306, '\p{Is_General_Category=_Mc}', ""); +Expect(1, 2306, '\p{^Is_General_Category=_Mc}', ""); +Expect(1, 2306, '\P{Is_General_Category=_Mc}', ""); +Expect(0, 2306, '\P{^Is_General_Category=_Mc}', ""); +Error('\p{Is_Gc= :=Spacing-Mark}'); +Error('\P{Is_Gc= :=Spacing-Mark}'); +Expect(1, 2307, '\p{Is_Gc=spacingmark}', ""); +Expect(0, 2307, '\p{^Is_Gc=spacingmark}', ""); +Expect(0, 2307, '\P{Is_Gc=spacingmark}', ""); +Expect(1, 2307, '\P{^Is_Gc=spacingmark}', ""); +Expect(0, 2306, '\p{Is_Gc=spacingmark}', ""); +Expect(1, 2306, '\p{^Is_Gc=spacingmark}', ""); +Expect(1, 2306, '\P{Is_Gc=spacingmark}', ""); +Expect(0, 2306, '\P{^Is_Gc=spacingmark}', ""); +Expect(1, 2307, '\p{Is_Gc=- Spacing Mark}', ""); +Expect(0, 2307, '\p{^Is_Gc=- Spacing Mark}', ""); +Expect(0, 2307, '\P{Is_Gc=- Spacing Mark}', ""); +Expect(1, 2307, '\P{^Is_Gc=- Spacing Mark}', ""); +Expect(0, 2306, '\p{Is_Gc=- Spacing Mark}', ""); +Expect(1, 2306, '\p{^Is_Gc=- Spacing Mark}', ""); +Expect(1, 2306, '\P{Is_Gc=- Spacing Mark}', ""); +Expect(0, 2306, '\P{^Is_Gc=- Spacing Mark}', ""); +Error('\p{Is_Category: :=-Mc}'); +Error('\P{Is_Category: :=-Mc}'); +Expect(1, 2307, '\p{Is_Category=mc}', ""); +Expect(0, 2307, '\p{^Is_Category=mc}', ""); +Expect(0, 2307, '\P{Is_Category=mc}', ""); +Expect(1, 2307, '\P{^Is_Category=mc}', ""); +Expect(0, 2306, '\p{Is_Category=mc}', ""); +Expect(1, 2306, '\p{^Is_Category=mc}', ""); +Expect(1, 2306, '\P{Is_Category=mc}', ""); +Expect(0, 2306, '\P{^Is_Category=mc}', ""); +Expect(1, 2307, '\p{Is_Category=_Mc}', ""); +Expect(0, 2307, '\p{^Is_Category=_Mc}', ""); +Expect(0, 2307, '\P{Is_Category=_Mc}', ""); +Expect(1, 2307, '\P{^Is_Category=_Mc}', ""); +Expect(0, 2306, '\p{Is_Category=_Mc}', ""); +Expect(1, 2306, '\p{^Is_Category=_Mc}', ""); +Expect(1, 2306, '\P{Is_Category=_Mc}', ""); +Expect(0, 2306, '\P{^Is_Category=_Mc}', ""); +Error('\p{General_Category= _CASEDLetter/a/}'); +Error('\P{General_Category= _CASEDLetter/a/}'); +Expect(1, 90, '\p{General_Category=casedletter}', ""); +Expect(0, 90, '\p{^General_Category=casedletter}', ""); +Expect(0, 90, '\P{General_Category=casedletter}', ""); +Expect(1, 90, '\P{^General_Category=casedletter}', ""); +Expect(0, 64, '\p{General_Category=casedletter}', ""); +Expect(1, 64, '\p{^General_Category=casedletter}', ""); +Expect(1, 64, '\P{General_Category=casedletter}', ""); +Expect(0, 64, '\P{^General_Category=casedletter}', ""); +Expect(1, 90, '\p{General_Category: _cased-letter}', ""); +Expect(0, 90, '\p{^General_Category: _cased-letter}', ""); +Expect(0, 90, '\P{General_Category: _cased-letter}', ""); +Expect(1, 90, '\P{^General_Category: _cased-letter}', ""); +Expect(0, 64, '\p{General_Category: _cased-letter}', ""); +Expect(1, 64, '\p{^General_Category: _cased-letter}', ""); +Expect(1, 64, '\P{General_Category: _cased-letter}', ""); +Expect(0, 64, '\P{^General_Category: _cased-letter}', ""); +Error('\p{Gc=:=- LC}'); +Error('\P{Gc=:=- LC}'); +Expect(1, 90, '\p{Gc=lc}', ""); +Expect(0, 90, '\p{^Gc=lc}', ""); +Expect(0, 90, '\P{Gc=lc}', ""); +Expect(1, 90, '\P{^Gc=lc}', ""); +Expect(0, 64, '\p{Gc=lc}', ""); +Expect(1, 64, '\p{^Gc=lc}', ""); +Expect(1, 64, '\P{Gc=lc}', ""); +Expect(0, 64, '\P{^Gc=lc}', ""); +Expect(1, 90, '\p{Gc= LC}', ""); +Expect(0, 90, '\p{^Gc= LC}', ""); +Expect(0, 90, '\P{Gc= LC}', ""); +Expect(1, 90, '\P{^Gc= LC}', ""); +Expect(0, 64, '\p{Gc= LC}', ""); +Expect(1, 64, '\p{^Gc= LC}', ""); +Expect(1, 64, '\P{Gc= LC}', ""); +Expect(0, 64, '\P{^Gc= LC}', ""); +Error('\p{Category=:=_L}'); +Error('\P{Category=:=_L}'); +Expect(1, 90, '\p{Category=l_}', ""); +Expect(0, 90, '\p{^Category=l_}', ""); +Expect(0, 90, '\P{Category=l_}', ""); +Expect(1, 90, '\P{^Category=l_}', ""); +Expect(0, 64, '\p{Category=l_}', ""); +Expect(1, 64, '\p{^Category=l_}', ""); +Expect(1, 64, '\P{Category=l_}', ""); +Expect(0, 64, '\P{^Category=l_}', ""); +Expect(1, 90, '\p{Category=_-L}', ""); +Expect(0, 90, '\p{^Category=_-L}', ""); +Expect(0, 90, '\P{Category=_-L}', ""); +Expect(1, 90, '\P{^Category=_-L}', ""); +Expect(0, 64, '\p{Category=_-L}', ""); +Expect(1, 64, '\p{^Category=_-L}', ""); +Expect(1, 64, '\P{Category=_-L}', ""); +Expect(0, 64, '\P{^Category=_-L}', ""); +Error('\p{Is_General_Category=/a/--L&}'); +Error('\P{Is_General_Category=/a/--L&}'); +Expect(1, 90, '\p{Is_General_Category=l&}', ""); +Expect(0, 90, '\p{^Is_General_Category=l&}', ""); +Expect(0, 90, '\P{Is_General_Category=l&}', ""); +Expect(1, 90, '\P{^Is_General_Category=l&}', ""); +Expect(0, 64, '\p{Is_General_Category=l&}', ""); +Expect(1, 64, '\p{^Is_General_Category=l&}', ""); +Expect(1, 64, '\P{Is_General_Category=l&}', ""); +Expect(0, 64, '\P{^Is_General_Category=l&}', ""); +Expect(1, 90, '\p{Is_General_Category=- L&}', ""); +Expect(0, 90, '\p{^Is_General_Category=- L&}', ""); +Expect(0, 90, '\P{Is_General_Category=- L&}', ""); +Expect(1, 90, '\P{^Is_General_Category=- L&}', ""); +Expect(0, 64, '\p{Is_General_Category=- L&}', ""); +Expect(1, 64, '\p{^Is_General_Category=- L&}', ""); +Expect(1, 64, '\P{Is_General_Category=- L&}', ""); +Expect(0, 64, '\P{^Is_General_Category=- L&}', ""); +Error('\p{Is_Gc= -cased/a/Letter}'); +Error('\P{Is_Gc= -cased/a/Letter}'); +Expect(1, 90, '\p{Is_Gc=casedletter}', ""); +Expect(0, 90, '\p{^Is_Gc=casedletter}', ""); +Expect(0, 90, '\P{Is_Gc=casedletter}', ""); +Expect(1, 90, '\P{^Is_Gc=casedletter}', ""); +Expect(0, 64, '\p{Is_Gc=casedletter}', ""); +Expect(1, 64, '\p{^Is_Gc=casedletter}', ""); +Expect(1, 64, '\P{Is_Gc=casedletter}', ""); +Expect(0, 64, '\P{^Is_Gc=casedletter}', ""); +Expect(1, 90, '\p{Is_Gc= _casedLetter}', ""); +Expect(0, 90, '\p{^Is_Gc= _casedLetter}', ""); +Expect(0, 90, '\P{Is_Gc= _casedLetter}', ""); +Expect(1, 90, '\P{^Is_Gc= _casedLetter}', ""); +Expect(0, 64, '\p{Is_Gc= _casedLetter}', ""); +Expect(1, 64, '\p{^Is_Gc= _casedLetter}', ""); +Expect(1, 64, '\P{Is_Gc= _casedLetter}', ""); +Expect(0, 64, '\P{^Is_Gc= _casedLetter}', ""); +Error('\p{Is_Category=:=_lc}'); +Error('\P{Is_Category=:=_lc}'); +Expect(1, 90, '\p{Is_Category=lc}', ""); +Expect(0, 90, '\p{^Is_Category=lc}', ""); +Expect(0, 90, '\P{Is_Category=lc}', ""); +Expect(1, 90, '\P{^Is_Category=lc}', ""); +Expect(0, 64, '\p{Is_Category=lc}', ""); +Expect(1, 64, '\p{^Is_Category=lc}', ""); +Expect(1, 64, '\P{Is_Category=lc}', ""); +Expect(0, 64, '\P{^Is_Category=lc}', ""); +Expect(1, 90, '\p{Is_Category=_ lc}', ""); +Expect(0, 90, '\p{^Is_Category=_ lc}', ""); +Expect(0, 90, '\P{Is_Category=_ lc}', ""); +Expect(1, 90, '\P{^Is_Category=_ lc}', ""); +Expect(0, 64, '\p{Is_Category=_ lc}', ""); +Expect(1, 64, '\p{^Is_Category=_ lc}', ""); +Expect(1, 64, '\P{Is_Category=_ lc}', ""); +Expect(0, 64, '\P{^Is_Category=_ lc}', ""); +Error('\p{General_Category= -Connector-Punctuation/a/}'); +Error('\P{General_Category= -Connector-Punctuation/a/}'); +Expect(1, 95, '\p{General_Category: connectorpunctuation}', ""); +Expect(0, 95, '\p{^General_Category: connectorpunctuation}', ""); +Expect(0, 95, '\P{General_Category: connectorpunctuation}', ""); +Expect(1, 95, '\P{^General_Category: connectorpunctuation}', ""); +Expect(0, 94, '\p{General_Category: connectorpunctuation}', ""); +Expect(1, 94, '\p{^General_Category: connectorpunctuation}', ""); +Expect(1, 94, '\P{General_Category: connectorpunctuation}', ""); +Expect(0, 94, '\P{^General_Category: connectorpunctuation}', ""); +Expect(1, 95, '\p{General_Category= _Connector-punctuation}', ""); +Expect(0, 95, '\p{^General_Category= _Connector-punctuation}', ""); +Expect(0, 95, '\P{General_Category= _Connector-punctuation}', ""); +Expect(1, 95, '\P{^General_Category= _Connector-punctuation}', ""); +Expect(0, 94, '\p{General_Category= _Connector-punctuation}', ""); +Expect(1, 94, '\p{^General_Category= _Connector-punctuation}', ""); +Expect(1, 94, '\P{General_Category= _Connector-punctuation}', ""); +Expect(0, 94, '\P{^General_Category= _Connector-punctuation}', ""); +Error('\p{Gc=-/a/pc}'); +Error('\P{Gc=-/a/pc}'); +Expect(1, 95, '\p{Gc=pc}', ""); +Expect(0, 95, '\p{^Gc=pc}', ""); +Expect(0, 95, '\P{Gc=pc}', ""); +Expect(1, 95, '\P{^Gc=pc}', ""); +Expect(0, 94, '\p{Gc=pc}', ""); +Expect(1, 94, '\p{^Gc=pc}', ""); +Expect(1, 94, '\P{Gc=pc}', ""); +Expect(0, 94, '\P{^Gc=pc}', ""); +Expect(1, 95, '\p{Gc= PC}', ""); +Expect(0, 95, '\p{^Gc= PC}', ""); +Expect(0, 95, '\P{Gc= PC}', ""); +Expect(1, 95, '\P{^Gc= PC}', ""); +Expect(0, 94, '\p{Gc= PC}', ""); +Expect(1, 94, '\p{^Gc= PC}', ""); +Expect(1, 94, '\P{Gc= PC}', ""); +Expect(0, 94, '\P{^Gc= PC}', ""); +Error('\p{Category= CONNECTOR_Punctuation:=}'); +Error('\P{Category= CONNECTOR_Punctuation:=}'); +Expect(1, 95, '\p{Category:connectorpunctuation}', ""); +Expect(0, 95, '\p{^Category:connectorpunctuation}', ""); +Expect(0, 95, '\P{Category:connectorpunctuation}', ""); +Expect(1, 95, '\P{^Category:connectorpunctuation}', ""); +Expect(0, 94, '\p{Category:connectorpunctuation}', ""); +Expect(1, 94, '\p{^Category:connectorpunctuation}', ""); +Expect(1, 94, '\P{Category:connectorpunctuation}', ""); +Expect(0, 94, '\P{^Category:connectorpunctuation}', ""); +Expect(1, 95, '\p{Category=_CONNECTOR PUNCTUATION}', ""); +Expect(0, 95, '\p{^Category=_CONNECTOR PUNCTUATION}', ""); +Expect(0, 95, '\P{Category=_CONNECTOR PUNCTUATION}', ""); +Expect(1, 95, '\P{^Category=_CONNECTOR PUNCTUATION}', ""); +Expect(0, 94, '\p{Category=_CONNECTOR PUNCTUATION}', ""); +Expect(1, 94, '\p{^Category=_CONNECTOR PUNCTUATION}', ""); +Expect(1, 94, '\P{Category=_CONNECTOR PUNCTUATION}', ""); +Expect(0, 94, '\P{^Category=_CONNECTOR PUNCTUATION}', ""); +Error('\p{Is_General_Category=-Pc/a/}'); +Error('\P{Is_General_Category=-Pc/a/}'); +Expect(1, 95, '\p{Is_General_Category=pc}', ""); +Expect(0, 95, '\p{^Is_General_Category=pc}', ""); +Expect(0, 95, '\P{Is_General_Category=pc}', ""); +Expect(1, 95, '\P{^Is_General_Category=pc}', ""); +Expect(0, 94, '\p{Is_General_Category=pc}', ""); +Expect(1, 94, '\p{^Is_General_Category=pc}', ""); +Expect(1, 94, '\P{Is_General_Category=pc}', ""); +Expect(0, 94, '\P{^Is_General_Category=pc}', ""); +Expect(1, 95, '\p{Is_General_Category=_-Pc}', ""); +Expect(0, 95, '\p{^Is_General_Category=_-Pc}', ""); +Expect(0, 95, '\P{Is_General_Category=_-Pc}', ""); +Expect(1, 95, '\P{^Is_General_Category=_-Pc}', ""); +Expect(0, 94, '\p{Is_General_Category=_-Pc}', ""); +Expect(1, 94, '\p{^Is_General_Category=_-Pc}', ""); +Expect(1, 94, '\P{Is_General_Category=_-Pc}', ""); +Expect(0, 94, '\P{^Is_General_Category=_-Pc}', ""); +Error('\p{Is_Gc: -:=CONNECTORPunctuation}'); +Error('\P{Is_Gc: -:=CONNECTORPunctuation}'); +Expect(1, 95, '\p{Is_Gc: connectorpunctuation}', ""); +Expect(0, 95, '\p{^Is_Gc: connectorpunctuation}', ""); +Expect(0, 95, '\P{Is_Gc: connectorpunctuation}', ""); +Expect(1, 95, '\P{^Is_Gc: connectorpunctuation}', ""); +Expect(0, 94, '\p{Is_Gc: connectorpunctuation}', ""); +Expect(1, 94, '\p{^Is_Gc: connectorpunctuation}', ""); +Expect(1, 94, '\P{Is_Gc: connectorpunctuation}', ""); +Expect(0, 94, '\P{^Is_Gc: connectorpunctuation}', ""); +Expect(1, 95, '\p{Is_Gc=_Connector_punctuation}', ""); +Expect(0, 95, '\p{^Is_Gc=_Connector_punctuation}', ""); +Expect(0, 95, '\P{Is_Gc=_Connector_punctuation}', ""); +Expect(1, 95, '\P{^Is_Gc=_Connector_punctuation}', ""); +Expect(0, 94, '\p{Is_Gc=_Connector_punctuation}', ""); +Expect(1, 94, '\p{^Is_Gc=_Connector_punctuation}', ""); +Expect(1, 94, '\P{Is_Gc=_Connector_punctuation}', ""); +Expect(0, 94, '\P{^Is_Gc=_Connector_punctuation}', ""); +Error('\p{Is_Category=:= Pc}'); +Error('\P{Is_Category=:= Pc}'); +Expect(1, 95, '\p{Is_Category=pc}', ""); +Expect(0, 95, '\p{^Is_Category=pc}', ""); +Expect(0, 95, '\P{Is_Category=pc}', ""); +Expect(1, 95, '\P{^Is_Category=pc}', ""); +Expect(0, 94, '\p{Is_Category=pc}', ""); +Expect(1, 94, '\p{^Is_Category=pc}', ""); +Expect(1, 94, '\P{Is_Category=pc}', ""); +Expect(0, 94, '\P{^Is_Category=pc}', ""); +Expect(1, 95, '\p{Is_Category= Pc}', ""); +Expect(0, 95, '\p{^Is_Category= Pc}', ""); +Expect(0, 95, '\P{Is_Category= Pc}', ""); +Expect(1, 95, '\P{^Is_Category= Pc}', ""); +Expect(0, 94, '\p{Is_Category= Pc}', ""); +Expect(1, 94, '\p{^Is_Category= Pc}', ""); +Expect(1, 94, '\P{Is_Category= Pc}', ""); +Expect(0, 94, '\P{^Is_Category= Pc}', ""); +Error('\p{General_Category=:=-_surrogate}'); +Error('\P{General_Category=:=-_surrogate}'); +Expect(0, 55295, '\p{General_Category=surrogate}', ""); +Expect(1, 55295, '\p{^General_Category=surrogate}', ""); +Expect(1, 55295, '\P{General_Category=surrogate}', ""); +Expect(0, 55295, '\P{^General_Category=surrogate}', ""); +Expect(0, 55295, '\p{General_Category=__SURROGATE}', ""); +Expect(1, 55295, '\p{^General_Category=__SURROGATE}', ""); +Expect(1, 55295, '\P{General_Category=__SURROGATE}', ""); +Expect(0, 55295, '\P{^General_Category=__SURROGATE}', ""); +Error('\p{Gc= :=Cs}'); +Error('\P{Gc= :=Cs}'); +Expect(0, 55295, '\p{Gc=cs}', ""); +Expect(1, 55295, '\p{^Gc=cs}', ""); +Expect(1, 55295, '\P{Gc=cs}', ""); +Expect(0, 55295, '\P{^Gc=cs}', ""); +Expect(0, 55295, '\p{Gc=- Cs}', ""); +Expect(1, 55295, '\p{^Gc=- Cs}', ""); +Expect(1, 55295, '\P{Gc=- Cs}', ""); +Expect(0, 55295, '\P{^Gc=- Cs}', ""); +Error('\p{Category= /a/surrogate}'); +Error('\P{Category= /a/surrogate}'); +Expect(0, 55295, '\p{Category: surrogate}', ""); +Expect(1, 55295, '\p{^Category: surrogate}', ""); +Expect(1, 55295, '\P{Category: surrogate}', ""); +Expect(0, 55295, '\P{^Category: surrogate}', ""); +Expect(0, 55295, '\p{Category= Surrogate}', ""); +Expect(1, 55295, '\p{^Category= Surrogate}', ""); +Expect(1, 55295, '\P{Category= Surrogate}', ""); +Expect(0, 55295, '\P{^Category= Surrogate}', ""); +Error('\p{Is_General_Category= Cs/a/}'); +Error('\P{Is_General_Category= Cs/a/}'); +Expect(0, 55295, '\p{Is_General_Category=cs}', ""); +Expect(1, 55295, '\p{^Is_General_Category=cs}', ""); +Expect(1, 55295, '\P{Is_General_Category=cs}', ""); +Expect(0, 55295, '\P{^Is_General_Category=cs}', ""); +Expect(0, 55295, '\p{Is_General_Category=_-Cs}', ""); +Expect(1, 55295, '\p{^Is_General_Category=_-Cs}', ""); +Expect(1, 55295, '\P{Is_General_Category=_-Cs}', ""); +Expect(0, 55295, '\P{^Is_General_Category=_-Cs}', ""); +Error('\p{Is_Gc= -Surrogate:=}'); +Error('\P{Is_Gc= -Surrogate:=}'); +Expect(0, 55295, '\p{Is_Gc=surrogate}', ""); +Expect(1, 55295, '\p{^Is_Gc=surrogate}', ""); +Expect(1, 55295, '\P{Is_Gc=surrogate}', ""); +Expect(0, 55295, '\P{^Is_Gc=surrogate}', ""); +Expect(0, 55295, '\p{Is_Gc=- Surrogate}', ""); +Expect(1, 55295, '\p{^Is_Gc=- Surrogate}', ""); +Expect(1, 55295, '\P{Is_Gc=- Surrogate}', ""); +Expect(0, 55295, '\P{^Is_Gc=- Surrogate}', ""); +Error('\p{Is_Category= cs/a/}'); +Error('\P{Is_Category= cs/a/}'); +Expect(0, 55295, '\p{Is_Category=cs}', ""); +Expect(1, 55295, '\p{^Is_Category=cs}', ""); +Expect(1, 55295, '\P{Is_Category=cs}', ""); +Expect(0, 55295, '\P{^Is_Category=cs}', ""); +Expect(0, 55295, '\p{Is_Category=--Cs}', ""); +Expect(1, 55295, '\p{^Is_Category=--Cs}', ""); +Expect(1, 55295, '\P{Is_Category=--Cs}', ""); +Expect(0, 55295, '\P{^Is_Category=--Cs}', ""); +Error('\p{General_Category=/a/- privateUse}'); +Error('\P{General_Category=/a/- privateUse}'); +Expect(1, 63743, '\p{General_Category=privateuse}', ""); +Expect(0, 63743, '\p{^General_Category=privateuse}', ""); +Expect(0, 63743, '\P{General_Category=privateuse}', ""); +Expect(1, 63743, '\P{^General_Category=privateuse}', ""); +Expect(0, 7, '\p{General_Category=privateuse}', ""); +Expect(1, 7, '\p{^General_Category=privateuse}', ""); +Expect(1, 7, '\P{General_Category=privateuse}', ""); +Expect(0, 7, '\P{^General_Category=privateuse}', ""); +Expect(1, 63743, '\p{General_Category=-Private use}', ""); +Expect(0, 63743, '\p{^General_Category=-Private use}', ""); +Expect(0, 63743, '\P{General_Category=-Private use}', ""); +Expect(1, 63743, '\P{^General_Category=-Private use}', ""); +Expect(0, 7, '\p{General_Category=-Private use}', ""); +Expect(1, 7, '\p{^General_Category=-Private use}', ""); +Expect(1, 7, '\P{General_Category=-Private use}', ""); +Expect(0, 7, '\P{^General_Category=-Private use}', ""); +Error('\p{Gc=:=_-Co}'); +Error('\P{Gc=:=_-Co}'); +Expect(1, 63743, '\p{Gc: co}', ""); +Expect(0, 63743, '\p{^Gc: co}', ""); +Expect(0, 63743, '\P{Gc: co}', ""); +Expect(1, 63743, '\P{^Gc: co}', ""); +Expect(0, 7, '\p{Gc: co}', ""); +Expect(1, 7, '\p{^Gc: co}', ""); +Expect(1, 7, '\P{Gc: co}', ""); +Expect(0, 7, '\P{^Gc: co}', ""); +Expect(1, 63743, '\p{Gc: CO}', ""); +Expect(0, 63743, '\p{^Gc: CO}', ""); +Expect(0, 63743, '\P{Gc: CO}', ""); +Expect(1, 63743, '\P{^Gc: CO}', ""); +Expect(0, 7, '\p{Gc: CO}', ""); +Expect(1, 7, '\p{^Gc: CO}', ""); +Expect(1, 7, '\P{Gc: CO}', ""); +Expect(0, 7, '\P{^Gc: CO}', ""); +Error('\p{Category= /a/Private Use}'); +Error('\P{Category= /a/Private Use}'); +Expect(1, 63743, '\p{Category=privateuse}', ""); +Expect(0, 63743, '\p{^Category=privateuse}', ""); +Expect(0, 63743, '\P{Category=privateuse}', ""); +Expect(1, 63743, '\P{^Category=privateuse}', ""); +Expect(0, 7, '\p{Category=privateuse}', ""); +Expect(1, 7, '\p{^Category=privateuse}', ""); +Expect(1, 7, '\P{Category=privateuse}', ""); +Expect(0, 7, '\P{^Category=privateuse}', ""); +Expect(1, 63743, '\p{Category=--Private Use}', ""); +Expect(0, 63743, '\p{^Category=--Private Use}', ""); +Expect(0, 63743, '\P{Category=--Private Use}', ""); +Expect(1, 63743, '\P{^Category=--Private Use}', ""); +Expect(0, 7, '\p{Category=--Private Use}', ""); +Expect(1, 7, '\p{^Category=--Private Use}', ""); +Expect(1, 7, '\P{Category=--Private Use}', ""); +Expect(0, 7, '\P{^Category=--Private Use}', ""); +Error('\p{Is_General_Category=:=-Co}'); +Error('\P{Is_General_Category=:=-Co}'); +Expect(1, 63743, '\p{Is_General_Category=co}', ""); +Expect(0, 63743, '\p{^Is_General_Category=co}', ""); +Expect(0, 63743, '\P{Is_General_Category=co}', ""); +Expect(1, 63743, '\P{^Is_General_Category=co}', ""); +Expect(0, 7, '\p{Is_General_Category=co}', ""); +Expect(1, 7, '\p{^Is_General_Category=co}', ""); +Expect(1, 7, '\P{Is_General_Category=co}', ""); +Expect(0, 7, '\P{^Is_General_Category=co}', ""); +Expect(1, 63743, '\p{Is_General_Category=-Co}', ""); +Expect(0, 63743, '\p{^Is_General_Category=-Co}', ""); +Expect(0, 63743, '\P{Is_General_Category=-Co}', ""); +Expect(1, 63743, '\P{^Is_General_Category=-Co}', ""); +Expect(0, 7, '\p{Is_General_Category=-Co}', ""); +Expect(1, 7, '\p{^Is_General_Category=-Co}', ""); +Expect(1, 7, '\P{Is_General_Category=-Co}', ""); +Expect(0, 7, '\P{^Is_General_Category=-Co}', ""); +Error('\p{Is_Gc:/a/_-PRIVATE Use}'); +Error('\P{Is_Gc:/a/_-PRIVATE Use}'); +Expect(1, 63743, '\p{Is_Gc=privateuse}', ""); +Expect(0, 63743, '\p{^Is_Gc=privateuse}', ""); +Expect(0, 63743, '\P{Is_Gc=privateuse}', ""); +Expect(1, 63743, '\P{^Is_Gc=privateuse}', ""); +Expect(0, 7, '\p{Is_Gc=privateuse}', ""); +Expect(1, 7, '\p{^Is_Gc=privateuse}', ""); +Expect(1, 7, '\P{Is_Gc=privateuse}', ""); +Expect(0, 7, '\P{^Is_Gc=privateuse}', ""); +Expect(1, 63743, '\p{Is_Gc= _PRIVATE_Use}', ""); +Expect(0, 63743, '\p{^Is_Gc= _PRIVATE_Use}', ""); +Expect(0, 63743, '\P{Is_Gc= _PRIVATE_Use}', ""); +Expect(1, 63743, '\P{^Is_Gc= _PRIVATE_Use}', ""); +Expect(0, 7, '\p{Is_Gc= _PRIVATE_Use}', ""); +Expect(1, 7, '\p{^Is_Gc= _PRIVATE_Use}', ""); +Expect(1, 7, '\P{Is_Gc= _PRIVATE_Use}', ""); +Expect(0, 7, '\P{^Is_Gc= _PRIVATE_Use}', ""); +Error('\p{Is_Category=_/a/Co}'); +Error('\P{Is_Category=_/a/Co}'); +Expect(1, 63743, '\p{Is_Category=co}', ""); +Expect(0, 63743, '\p{^Is_Category=co}', ""); +Expect(0, 63743, '\P{Is_Category=co}', ""); +Expect(1, 63743, '\P{^Is_Category=co}', ""); +Expect(0, 7, '\p{Is_Category=co}', ""); +Expect(1, 7, '\p{^Is_Category=co}', ""); +Expect(1, 7, '\P{Is_Category=co}', ""); +Expect(0, 7, '\P{^Is_Category=co}', ""); +Expect(1, 63743, '\p{Is_Category= _Co}', ""); +Expect(0, 63743, '\p{^Is_Category= _Co}', ""); +Expect(0, 63743, '\P{Is_Category= _Co}', ""); +Expect(1, 63743, '\P{^Is_Category= _Co}', ""); +Expect(0, 7, '\p{Is_Category= _Co}', ""); +Expect(1, 7, '\p{^Is_Category= _Co}', ""); +Expect(1, 7, '\P{Is_Category= _Co}', ""); +Expect(0, 7, '\P{^Is_Category= _Co}', ""); +Error('\p{General_Category=/a/ LOWERCASE_LETTER}'); +Error('\P{General_Category=/a/ LOWERCASE_LETTER}'); +Expect(1, 122, '\p{General_Category=lowercaseletter}', ""); +Expect(0, 122, '\p{^General_Category=lowercaseletter}', ""); +Expect(0, 122, '\P{General_Category=lowercaseletter}', ""); +Expect(1, 122, '\P{^General_Category=lowercaseletter}', ""); +Expect(0, 96, '\p{General_Category=lowercaseletter}', ""); +Expect(1, 96, '\p{^General_Category=lowercaseletter}', ""); +Expect(1, 96, '\P{General_Category=lowercaseletter}', ""); +Expect(0, 96, '\P{^General_Category=lowercaseletter}', ""); +Expect(1, 122, '\p{General_Category: --lowercase letter}', ""); +Expect(0, 122, '\p{^General_Category: --lowercase letter}', ""); +Expect(0, 122, '\P{General_Category: --lowercase letter}', ""); +Expect(1, 122, '\P{^General_Category: --lowercase letter}', ""); +Expect(0, 96, '\p{General_Category: --lowercase letter}', ""); +Expect(1, 96, '\p{^General_Category: --lowercase letter}', ""); +Expect(1, 96, '\P{General_Category: --lowercase letter}', ""); +Expect(0, 96, '\P{^General_Category: --lowercase letter}', ""); +Error('\p{Gc=_ ll/a/}'); +Error('\P{Gc=_ ll/a/}'); +Expect(1, 122, '\p{Gc: ll}', ""); +Expect(0, 122, '\p{^Gc: ll}', ""); +Expect(0, 122, '\P{Gc: ll}', ""); +Expect(1, 122, '\P{^Gc: ll}', ""); +Expect(0, 96, '\p{Gc: ll}', ""); +Expect(1, 96, '\p{^Gc: ll}', ""); +Expect(1, 96, '\P{Gc: ll}', ""); +Expect(0, 96, '\P{^Gc: ll}', ""); +Expect(1, 122, '\p{Gc= _Ll}', ""); +Expect(0, 122, '\p{^Gc= _Ll}', ""); +Expect(0, 122, '\P{Gc= _Ll}', ""); +Expect(1, 122, '\P{^Gc= _Ll}', ""); +Expect(0, 96, '\p{Gc= _Ll}', ""); +Expect(1, 96, '\p{^Gc= _Ll}', ""); +Expect(1, 96, '\P{Gc= _Ll}', ""); +Expect(0, 96, '\P{^Gc= _Ll}', ""); +Error('\p{Category=-lowercase/a/LETTER}'); +Error('\P{Category=-lowercase/a/LETTER}'); +Expect(1, 122, '\p{Category=lowercaseletter}', ""); +Expect(0, 122, '\p{^Category=lowercaseletter}', ""); +Expect(0, 122, '\P{Category=lowercaseletter}', ""); +Expect(1, 122, '\P{^Category=lowercaseletter}', ""); +Expect(0, 96, '\p{Category=lowercaseletter}', ""); +Expect(1, 96, '\p{^Category=lowercaseletter}', ""); +Expect(1, 96, '\P{Category=lowercaseletter}', ""); +Expect(0, 96, '\P{^Category=lowercaseletter}', ""); +Expect(1, 122, '\p{Category=--LOWERCASE-letter}', ""); +Expect(0, 122, '\p{^Category=--LOWERCASE-letter}', ""); +Expect(0, 122, '\P{Category=--LOWERCASE-letter}', ""); +Expect(1, 122, '\P{^Category=--LOWERCASE-letter}', ""); +Expect(0, 96, '\p{Category=--LOWERCASE-letter}', ""); +Expect(1, 96, '\p{^Category=--LOWERCASE-letter}', ""); +Expect(1, 96, '\P{Category=--LOWERCASE-letter}', ""); +Expect(0, 96, '\P{^Category=--LOWERCASE-letter}', ""); +Error('\p{Is_General_Category=:=--ll}'); +Error('\P{Is_General_Category=:=--ll}'); +Expect(1, 122, '\p{Is_General_Category: ll}', ""); +Expect(0, 122, '\p{^Is_General_Category: ll}', ""); +Expect(0, 122, '\P{Is_General_Category: ll}', ""); +Expect(1, 122, '\P{^Is_General_Category: ll}', ""); +Expect(0, 96, '\p{Is_General_Category: ll}', ""); +Expect(1, 96, '\p{^Is_General_Category: ll}', ""); +Expect(1, 96, '\P{Is_General_Category: ll}', ""); +Expect(0, 96, '\P{^Is_General_Category: ll}', ""); +Expect(1, 122, '\p{Is_General_Category: Ll}', ""); +Expect(0, 122, '\p{^Is_General_Category: Ll}', ""); +Expect(0, 122, '\P{Is_General_Category: Ll}', ""); +Expect(1, 122, '\P{^Is_General_Category: Ll}', ""); +Expect(0, 96, '\p{Is_General_Category: Ll}', ""); +Expect(1, 96, '\p{^Is_General_Category: Ll}', ""); +Expect(1, 96, '\P{Is_General_Category: Ll}', ""); +Expect(0, 96, '\P{^Is_General_Category: Ll}', ""); +Error('\p{Is_Gc=:=__Lowercase Letter}'); +Error('\P{Is_Gc=:=__Lowercase Letter}'); +Expect(1, 122, '\p{Is_Gc: lowercaseletter}', ""); +Expect(0, 122, '\p{^Is_Gc: lowercaseletter}', ""); +Expect(0, 122, '\P{Is_Gc: lowercaseletter}', ""); +Expect(1, 122, '\P{^Is_Gc: lowercaseletter}', ""); +Expect(0, 96, '\p{Is_Gc: lowercaseletter}', ""); +Expect(1, 96, '\p{^Is_Gc: lowercaseletter}', ""); +Expect(1, 96, '\P{Is_Gc: lowercaseletter}', ""); +Expect(0, 96, '\P{^Is_Gc: lowercaseletter}', ""); +Expect(1, 122, '\p{Is_Gc: _LOWERCASEletter}', ""); +Expect(0, 122, '\p{^Is_Gc: _LOWERCASEletter}', ""); +Expect(0, 122, '\P{Is_Gc: _LOWERCASEletter}', ""); +Expect(1, 122, '\P{^Is_Gc: _LOWERCASEletter}', ""); +Expect(0, 96, '\p{Is_Gc: _LOWERCASEletter}', ""); +Expect(1, 96, '\p{^Is_Gc: _LOWERCASEletter}', ""); +Expect(1, 96, '\P{Is_Gc: _LOWERCASEletter}', ""); +Expect(0, 96, '\P{^Is_Gc: _LOWERCASEletter}', ""); +Error('\p{Is_Category:_/a/Ll}'); +Error('\P{Is_Category:_/a/Ll}'); +Expect(1, 122, '\p{Is_Category=ll}', ""); +Expect(0, 122, '\p{^Is_Category=ll}', ""); +Expect(0, 122, '\P{Is_Category=ll}', ""); +Expect(1, 122, '\P{^Is_Category=ll}', ""); +Expect(0, 96, '\p{Is_Category=ll}', ""); +Expect(1, 96, '\p{^Is_Category=ll}', ""); +Expect(1, 96, '\P{Is_Category=ll}', ""); +Expect(0, 96, '\P{^Is_Category=ll}', ""); +Expect(1, 122, '\p{Is_Category=-Ll}', ""); +Expect(0, 122, '\p{^Is_Category=-Ll}', ""); +Expect(0, 122, '\P{Is_Category=-Ll}', ""); +Expect(1, 122, '\P{^Is_Category=-Ll}', ""); +Expect(0, 96, '\p{Is_Category=-Ll}', ""); +Expect(1, 96, '\p{^Is_Category=-Ll}', ""); +Expect(1, 96, '\P{Is_Category=-Ll}', ""); +Expect(0, 96, '\P{^Is_Category=-Ll}', ""); +Error('\p{General_Category= -ClosePUNCTUATION:=}'); +Error('\P{General_Category= -ClosePUNCTUATION:=}'); +Expect(1, 41, '\p{General_Category: closepunctuation}', ""); +Expect(0, 41, '\p{^General_Category: closepunctuation}', ""); +Expect(0, 41, '\P{General_Category: closepunctuation}', ""); +Expect(1, 41, '\P{^General_Category: closepunctuation}', ""); +Expect(0, 40, '\p{General_Category: closepunctuation}', ""); +Expect(1, 40, '\p{^General_Category: closepunctuation}', ""); +Expect(1, 40, '\P{General_Category: closepunctuation}', ""); +Expect(0, 40, '\P{^General_Category: closepunctuation}', ""); +Expect(1, 41, '\p{General_Category=_Close_Punctuation}', ""); +Expect(0, 41, '\p{^General_Category=_Close_Punctuation}', ""); +Expect(0, 41, '\P{General_Category=_Close_Punctuation}', ""); +Expect(1, 41, '\P{^General_Category=_Close_Punctuation}', ""); +Expect(0, 40, '\p{General_Category=_Close_Punctuation}', ""); +Expect(1, 40, '\p{^General_Category=_Close_Punctuation}', ""); +Expect(1, 40, '\P{General_Category=_Close_Punctuation}', ""); +Expect(0, 40, '\P{^General_Category=_Close_Punctuation}', ""); +Error('\p{Gc= /a/Pe}'); +Error('\P{Gc= /a/Pe}'); +Expect(1, 41, '\p{Gc=pe}', ""); +Expect(0, 41, '\p{^Gc=pe}', ""); +Expect(0, 41, '\P{Gc=pe}', ""); +Expect(1, 41, '\P{^Gc=pe}', ""); +Expect(0, 40, '\p{Gc=pe}', ""); +Expect(1, 40, '\p{^Gc=pe}', ""); +Expect(1, 40, '\P{Gc=pe}', ""); +Expect(0, 40, '\P{^Gc=pe}', ""); +Expect(1, 41, '\p{Gc= pe}', ""); +Expect(0, 41, '\p{^Gc= pe}', ""); +Expect(0, 41, '\P{Gc= pe}', ""); +Expect(1, 41, '\P{^Gc= pe}', ""); +Expect(0, 40, '\p{Gc= pe}', ""); +Expect(1, 40, '\p{^Gc= pe}', ""); +Expect(1, 40, '\P{Gc= pe}', ""); +Expect(0, 40, '\P{^Gc= pe}', ""); +Error('\p{Category:/a/Closepunctuation}'); +Error('\P{Category:/a/Closepunctuation}'); +Expect(1, 41, '\p{Category=closepunctuation}', ""); +Expect(0, 41, '\p{^Category=closepunctuation}', ""); +Expect(0, 41, '\P{Category=closepunctuation}', ""); +Expect(1, 41, '\P{^Category=closepunctuation}', ""); +Expect(0, 40, '\p{Category=closepunctuation}', ""); +Expect(1, 40, '\p{^Category=closepunctuation}', ""); +Expect(1, 40, '\P{Category=closepunctuation}', ""); +Expect(0, 40, '\P{^Category=closepunctuation}', ""); +Expect(1, 41, '\p{Category=_CLOSEPunctuation}', ""); +Expect(0, 41, '\p{^Category=_CLOSEPunctuation}', ""); +Expect(0, 41, '\P{Category=_CLOSEPunctuation}', ""); +Expect(1, 41, '\P{^Category=_CLOSEPunctuation}', ""); +Expect(0, 40, '\p{Category=_CLOSEPunctuation}', ""); +Expect(1, 40, '\p{^Category=_CLOSEPunctuation}', ""); +Expect(1, 40, '\P{Category=_CLOSEPunctuation}', ""); +Expect(0, 40, '\P{^Category=_CLOSEPunctuation}', ""); +Error('\p{Is_General_Category=/a/ -Pe}'); +Error('\P{Is_General_Category=/a/ -Pe}'); +Expect(1, 41, '\p{Is_General_Category=pe}', ""); +Expect(0, 41, '\p{^Is_General_Category=pe}', ""); +Expect(0, 41, '\P{Is_General_Category=pe}', ""); +Expect(1, 41, '\P{^Is_General_Category=pe}', ""); +Expect(0, 40, '\p{Is_General_Category=pe}', ""); +Expect(1, 40, '\p{^Is_General_Category=pe}', ""); +Expect(1, 40, '\P{Is_General_Category=pe}', ""); +Expect(0, 40, '\P{^Is_General_Category=pe}', ""); +Expect(1, 41, '\p{Is_General_Category=-PE}', ""); +Expect(0, 41, '\p{^Is_General_Category=-PE}', ""); +Expect(0, 41, '\P{Is_General_Category=-PE}', ""); +Expect(1, 41, '\P{^Is_General_Category=-PE}', ""); +Expect(0, 40, '\p{Is_General_Category=-PE}', ""); +Expect(1, 40, '\p{^Is_General_Category=-PE}', ""); +Expect(1, 40, '\P{Is_General_Category=-PE}', ""); +Expect(0, 40, '\P{^Is_General_Category=-PE}', ""); +Error('\p{Is_Gc: :=CLOSE Punctuation}'); +Error('\P{Is_Gc: :=CLOSE Punctuation}'); +Expect(1, 41, '\p{Is_Gc=closepunctuation}', ""); +Expect(0, 41, '\p{^Is_Gc=closepunctuation}', ""); +Expect(0, 41, '\P{Is_Gc=closepunctuation}', ""); +Expect(1, 41, '\P{^Is_Gc=closepunctuation}', ""); +Expect(0, 40, '\p{Is_Gc=closepunctuation}', ""); +Expect(1, 40, '\p{^Is_Gc=closepunctuation}', ""); +Expect(1, 40, '\P{Is_Gc=closepunctuation}', ""); +Expect(0, 40, '\P{^Is_Gc=closepunctuation}', ""); +Expect(1, 41, '\p{Is_Gc= _CLOSE PUNCTUATION}', ""); +Expect(0, 41, '\p{^Is_Gc= _CLOSE PUNCTUATION}', ""); +Expect(0, 41, '\P{Is_Gc= _CLOSE PUNCTUATION}', ""); +Expect(1, 41, '\P{^Is_Gc= _CLOSE PUNCTUATION}', ""); +Expect(0, 40, '\p{Is_Gc= _CLOSE PUNCTUATION}', ""); +Expect(1, 40, '\p{^Is_Gc= _CLOSE PUNCTUATION}', ""); +Expect(1, 40, '\P{Is_Gc= _CLOSE PUNCTUATION}', ""); +Expect(0, 40, '\P{^Is_Gc= _CLOSE PUNCTUATION}', ""); +Error('\p{Is_Category=/a/ _PE}'); +Error('\P{Is_Category=/a/ _PE}'); +Expect(1, 41, '\p{Is_Category=pe}', ""); +Expect(0, 41, '\p{^Is_Category=pe}', ""); +Expect(0, 41, '\P{Is_Category=pe}', ""); +Expect(1, 41, '\P{^Is_Category=pe}', ""); +Expect(0, 40, '\p{Is_Category=pe}', ""); +Expect(1, 40, '\p{^Is_Category=pe}', ""); +Expect(1, 40, '\P{Is_Category=pe}', ""); +Expect(0, 40, '\P{^Is_Category=pe}', ""); +Expect(1, 41, '\p{Is_Category=--pe}', ""); +Expect(0, 41, '\p{^Is_Category=--pe}', ""); +Expect(0, 41, '\P{Is_Category=--pe}', ""); +Expect(1, 41, '\P{^Is_Category=--pe}', ""); +Expect(0, 40, '\p{Is_Category=--pe}', ""); +Expect(1, 40, '\p{^Is_Category=--pe}', ""); +Expect(1, 40, '\P{Is_Category=--pe}', ""); +Expect(0, 40, '\P{^Is_Category=--pe}', ""); +Error('\p{General_Category=-:=Letter}'); +Error('\P{General_Category=-:=Letter}'); +Expect(1, 90, '\p{General_Category=letter}', ""); +Expect(0, 90, '\p{^General_Category=letter}', ""); +Expect(0, 90, '\P{General_Category=letter}', ""); +Expect(1, 90, '\P{^General_Category=letter}', ""); +Expect(0, 64, '\p{General_Category=letter}', ""); +Expect(1, 64, '\p{^General_Category=letter}', ""); +Expect(1, 64, '\P{General_Category=letter}', ""); +Expect(0, 64, '\P{^General_Category=letter}', ""); +Expect(1, 90, '\p{General_Category= letter}', ""); +Expect(0, 90, '\p{^General_Category= letter}', ""); +Expect(0, 90, '\P{General_Category= letter}', ""); +Expect(1, 90, '\P{^General_Category= letter}', ""); +Expect(0, 64, '\p{General_Category= letter}', ""); +Expect(1, 64, '\p{^General_Category= letter}', ""); +Expect(1, 64, '\P{General_Category= letter}', ""); +Expect(0, 64, '\P{^General_Category= letter}', ""); +Error('\p{Gc=/a/L}'); +Error('\P{Gc=/a/L}'); +Expect(1, 90, '\p{Gc=l}', ""); +Expect(0, 90, '\p{^Gc=l}', ""); +Expect(0, 90, '\P{Gc=l}', ""); +Expect(1, 90, '\P{^Gc=l}', ""); +Expect(0, 64, '\p{Gc=l}', ""); +Expect(1, 64, '\p{^Gc=l}', ""); +Expect(1, 64, '\P{Gc=l}', ""); +Expect(0, 64, '\P{^Gc=l}', ""); +Expect(1, 90, '\p{Gc=__l}', ""); +Expect(0, 90, '\p{^Gc=__l}', ""); +Expect(0, 90, '\P{Gc=__l}', ""); +Expect(1, 90, '\P{^Gc=__l}', ""); +Expect(0, 64, '\p{Gc=__l}', ""); +Expect(1, 64, '\p{^Gc=__l}', ""); +Expect(1, 64, '\P{Gc=__l}', ""); +Expect(0, 64, '\P{^Gc=__l}', ""); +Error('\p{Category=-_letter/a/}'); +Error('\P{Category=-_letter/a/}'); +Expect(1, 90, '\p{Category: letter}', ""); +Expect(0, 90, '\p{^Category: letter}', ""); +Expect(0, 90, '\P{Category: letter}', ""); +Expect(1, 90, '\P{^Category: letter}', ""); +Expect(0, 64, '\p{Category: letter}', ""); +Expect(1, 64, '\p{^Category: letter}', ""); +Expect(1, 64, '\P{Category: letter}', ""); +Expect(0, 64, '\P{^Category: letter}', ""); +Expect(1, 90, '\p{Category=__LETTER}', ""); +Expect(0, 90, '\p{^Category=__LETTER}', ""); +Expect(0, 90, '\P{Category=__LETTER}', ""); +Expect(1, 90, '\P{^Category=__LETTER}', ""); +Expect(0, 64, '\p{Category=__LETTER}', ""); +Expect(1, 64, '\p{^Category=__LETTER}', ""); +Expect(1, 64, '\P{Category=__LETTER}', ""); +Expect(0, 64, '\P{^Category=__LETTER}', ""); +Error('\p{Is_General_Category=_L/a/}'); +Error('\P{Is_General_Category=_L/a/}'); +Expect(1, 90, '\p{Is_General_Category: l}', ""); +Expect(0, 90, '\p{^Is_General_Category: l}', ""); +Expect(0, 90, '\P{Is_General_Category: l}', ""); +Expect(1, 90, '\P{^Is_General_Category: l}', ""); +Expect(0, 64, '\p{Is_General_Category: l}', ""); +Expect(1, 64, '\p{^Is_General_Category: l}', ""); +Expect(1, 64, '\P{Is_General_Category: l}', ""); +Expect(0, 64, '\P{^Is_General_Category: l}', ""); +Expect(1, 90, '\p{Is_General_Category= -L}', ""); +Expect(0, 90, '\p{^Is_General_Category= -L}', ""); +Expect(0, 90, '\P{Is_General_Category= -L}', ""); +Expect(1, 90, '\P{^Is_General_Category= -L}', ""); +Expect(0, 64, '\p{Is_General_Category= -L}', ""); +Expect(1, 64, '\p{^Is_General_Category= -L}', ""); +Expect(1, 64, '\P{Is_General_Category= -L}', ""); +Expect(0, 64, '\P{^Is_General_Category= -L}', ""); +Error('\p{Is_Gc=-_LETTER/a/}'); +Error('\P{Is_Gc=-_LETTER/a/}'); +Expect(1, 90, '\p{Is_Gc=letter}', ""); +Expect(0, 90, '\p{^Is_Gc=letter}', ""); +Expect(0, 90, '\P{Is_Gc=letter}', ""); +Expect(1, 90, '\P{^Is_Gc=letter}', ""); +Expect(0, 64, '\p{Is_Gc=letter}', ""); +Expect(1, 64, '\p{^Is_Gc=letter}', ""); +Expect(1, 64, '\P{Is_Gc=letter}', ""); +Expect(0, 64, '\P{^Is_Gc=letter}', ""); +Expect(1, 90, '\p{Is_Gc= Letter}', ""); +Expect(0, 90, '\p{^Is_Gc= Letter}', ""); +Expect(0, 90, '\P{Is_Gc= Letter}', ""); +Expect(1, 90, '\P{^Is_Gc= Letter}', ""); +Expect(0, 64, '\p{Is_Gc= Letter}', ""); +Expect(1, 64, '\p{^Is_Gc= Letter}', ""); +Expect(1, 64, '\P{Is_Gc= Letter}', ""); +Expect(0, 64, '\P{^Is_Gc= Letter}', ""); +Error('\p{Is_Category=/a/ _L}'); +Error('\P{Is_Category=/a/ _L}'); +Expect(1, 90, '\p{Is_Category=l}', ""); +Expect(0, 90, '\p{^Is_Category=l}', ""); +Expect(0, 90, '\P{Is_Category=l}', ""); +Expect(1, 90, '\P{^Is_Category=l}', ""); +Expect(0, 64, '\p{Is_Category=l}', ""); +Expect(1, 64, '\p{^Is_Category=l}', ""); +Expect(1, 64, '\P{Is_Category=l}', ""); +Expect(0, 64, '\P{^Is_Category=l}', ""); +Expect(1, 90, '\p{Is_Category= L}', ""); +Expect(0, 90, '\p{^Is_Category= L}', ""); +Expect(0, 90, '\P{Is_Category= L}', ""); +Expect(1, 90, '\P{^Is_Category= L}', ""); +Expect(0, 64, '\p{Is_Category= L}', ""); +Expect(1, 64, '\p{^Is_Category= L}', ""); +Expect(1, 64, '\P{Is_Category= L}', ""); +Expect(0, 64, '\P{^Is_Category= L}', ""); +Error('\p{General_Category= -Modifier:=Symbol}'); +Error('\P{General_Category= -Modifier:=Symbol}'); +Expect(1, 94, '\p{General_Category=modifiersymbol}', ""); +Expect(0, 94, '\p{^General_Category=modifiersymbol}', ""); +Expect(0, 94, '\P{General_Category=modifiersymbol}', ""); +Expect(1, 94, '\P{^General_Category=modifiersymbol}', ""); +Expect(0, 93, '\p{General_Category=modifiersymbol}', ""); +Expect(1, 93, '\p{^General_Category=modifiersymbol}', ""); +Expect(1, 93, '\P{General_Category=modifiersymbol}', ""); +Expect(0, 93, '\P{^General_Category=modifiersymbol}', ""); +Expect(1, 94, '\p{General_Category=_ modifier-SYMBOL}', ""); +Expect(0, 94, '\p{^General_Category=_ modifier-SYMBOL}', ""); +Expect(0, 94, '\P{General_Category=_ modifier-SYMBOL}', ""); +Expect(1, 94, '\P{^General_Category=_ modifier-SYMBOL}', ""); +Expect(0, 93, '\p{General_Category=_ modifier-SYMBOL}', ""); +Expect(1, 93, '\p{^General_Category=_ modifier-SYMBOL}', ""); +Expect(1, 93, '\P{General_Category=_ modifier-SYMBOL}', ""); +Expect(0, 93, '\P{^General_Category=_ modifier-SYMBOL}', ""); +Error('\p{Gc: _:=sk}'); +Error('\P{Gc: _:=sk}'); +Expect(1, 94, '\p{Gc=sk}', ""); +Expect(0, 94, '\p{^Gc=sk}', ""); +Expect(0, 94, '\P{Gc=sk}', ""); +Expect(1, 94, '\P{^Gc=sk}', ""); +Expect(0, 93, '\p{Gc=sk}', ""); +Expect(1, 93, '\p{^Gc=sk}', ""); +Expect(1, 93, '\P{Gc=sk}', ""); +Expect(0, 93, '\P{^Gc=sk}', ""); +Expect(1, 94, '\p{Gc= Sk}', ""); +Expect(0, 94, '\p{^Gc= Sk}', ""); +Expect(0, 94, '\P{Gc= Sk}', ""); +Expect(1, 94, '\P{^Gc= Sk}', ""); +Expect(0, 93, '\p{Gc= Sk}', ""); +Expect(1, 93, '\p{^Gc= Sk}', ""); +Expect(1, 93, '\P{Gc= Sk}', ""); +Expect(0, 93, '\P{^Gc= Sk}', ""); +Error('\p{Category=--MODIFIER symbol:=}'); +Error('\P{Category=--MODIFIER symbol:=}'); +Expect(1, 94, '\p{Category=modifiersymbol}', ""); +Expect(0, 94, '\p{^Category=modifiersymbol}', ""); +Expect(0, 94, '\P{Category=modifiersymbol}', ""); +Expect(1, 94, '\P{^Category=modifiersymbol}', ""); +Expect(0, 93, '\p{Category=modifiersymbol}', ""); +Expect(1, 93, '\p{^Category=modifiersymbol}', ""); +Expect(1, 93, '\P{Category=modifiersymbol}', ""); +Expect(0, 93, '\P{^Category=modifiersymbol}', ""); +Expect(1, 94, '\p{Category= Modifier-SYMBOL}', ""); +Expect(0, 94, '\p{^Category= Modifier-SYMBOL}', ""); +Expect(0, 94, '\P{Category= Modifier-SYMBOL}', ""); +Expect(1, 94, '\P{^Category= Modifier-SYMBOL}', ""); +Expect(0, 93, '\p{Category= Modifier-SYMBOL}', ""); +Expect(1, 93, '\p{^Category= Modifier-SYMBOL}', ""); +Expect(1, 93, '\P{Category= Modifier-SYMBOL}', ""); +Expect(0, 93, '\P{^Category= Modifier-SYMBOL}', ""); +Error('\p{Is_General_Category= -sk/a/}'); +Error('\P{Is_General_Category= -sk/a/}'); +Expect(1, 94, '\p{Is_General_Category=sk}', ""); +Expect(0, 94, '\p{^Is_General_Category=sk}', ""); +Expect(0, 94, '\P{Is_General_Category=sk}', ""); +Expect(1, 94, '\P{^Is_General_Category=sk}', ""); +Expect(0, 93, '\p{Is_General_Category=sk}', ""); +Expect(1, 93, '\p{^Is_General_Category=sk}', ""); +Expect(1, 93, '\P{Is_General_Category=sk}', ""); +Expect(0, 93, '\P{^Is_General_Category=sk}', ""); +Expect(1, 94, '\p{Is_General_Category= -Sk}', ""); +Expect(0, 94, '\p{^Is_General_Category= -Sk}', ""); +Expect(0, 94, '\P{Is_General_Category= -Sk}', ""); +Expect(1, 94, '\P{^Is_General_Category= -Sk}', ""); +Expect(0, 93, '\p{Is_General_Category= -Sk}', ""); +Expect(1, 93, '\p{^Is_General_Category= -Sk}', ""); +Expect(1, 93, '\P{Is_General_Category= -Sk}', ""); +Expect(0, 93, '\P{^Is_General_Category= -Sk}', ""); +Error('\p{Is_Gc: _/a/ModifierSymbol}'); +Error('\P{Is_Gc: _/a/ModifierSymbol}'); +Expect(1, 94, '\p{Is_Gc=modifiersymbol}', ""); +Expect(0, 94, '\p{^Is_Gc=modifiersymbol}', ""); +Expect(0, 94, '\P{Is_Gc=modifiersymbol}', ""); +Expect(1, 94, '\P{^Is_Gc=modifiersymbol}', ""); +Expect(0, 93, '\p{Is_Gc=modifiersymbol}', ""); +Expect(1, 93, '\p{^Is_Gc=modifiersymbol}', ""); +Expect(1, 93, '\P{Is_Gc=modifiersymbol}', ""); +Expect(0, 93, '\P{^Is_Gc=modifiersymbol}', ""); +Expect(1, 94, '\p{Is_Gc=- MODIFIERSymbol}', ""); +Expect(0, 94, '\p{^Is_Gc=- MODIFIERSymbol}', ""); +Expect(0, 94, '\P{Is_Gc=- MODIFIERSymbol}', ""); +Expect(1, 94, '\P{^Is_Gc=- MODIFIERSymbol}', ""); +Expect(0, 93, '\p{Is_Gc=- MODIFIERSymbol}', ""); +Expect(1, 93, '\p{^Is_Gc=- MODIFIERSymbol}', ""); +Expect(1, 93, '\P{Is_Gc=- MODIFIERSymbol}', ""); +Expect(0, 93, '\P{^Is_Gc=- MODIFIERSymbol}', ""); +Error('\p{Is_Category=/a/SK}'); +Error('\P{Is_Category=/a/SK}'); +Expect(1, 94, '\p{Is_Category: sk}', ""); +Expect(0, 94, '\p{^Is_Category: sk}', ""); +Expect(0, 94, '\P{Is_Category: sk}', ""); +Expect(1, 94, '\P{^Is_Category: sk}', ""); +Expect(0, 93, '\p{Is_Category: sk}', ""); +Expect(1, 93, '\p{^Is_Category: sk}', ""); +Expect(1, 93, '\P{Is_Category: sk}', ""); +Expect(0, 93, '\P{^Is_Category: sk}', ""); +Expect(1, 94, '\p{Is_Category= SK}', ""); +Expect(0, 94, '\p{^Is_Category= SK}', ""); +Expect(0, 94, '\P{Is_Category= SK}', ""); +Expect(1, 94, '\P{^Is_Category= SK}', ""); +Expect(0, 93, '\p{Is_Category= SK}', ""); +Expect(1, 93, '\p{^Is_Category= SK}', ""); +Expect(1, 93, '\P{Is_Category= SK}', ""); +Expect(0, 93, '\P{^Is_Category= SK}', ""); +Error('\p{General_Category=_ Control/a/}'); +Error('\P{General_Category=_ Control/a/}'); +Expect(1, 7, '\p{General_Category=control}', ""); +Expect(0, 7, '\p{^General_Category=control}', ""); +Expect(0, 7, '\P{General_Category=control}', ""); +Expect(1, 7, '\P{^General_Category=control}', ""); +Expect(0, 126, '\p{General_Category=control}', ""); +Expect(1, 126, '\p{^General_Category=control}', ""); +Expect(1, 126, '\P{General_Category=control}', ""); +Expect(0, 126, '\P{^General_Category=control}', ""); +Expect(1, 7, '\p{General_Category=_ control}', ""); +Expect(0, 7, '\p{^General_Category=_ control}', ""); +Expect(0, 7, '\P{General_Category=_ control}', ""); +Expect(1, 7, '\P{^General_Category=_ control}', ""); +Expect(0, 126, '\p{General_Category=_ control}', ""); +Expect(1, 126, '\p{^General_Category=_ control}', ""); +Expect(1, 126, '\P{General_Category=_ control}', ""); +Expect(0, 126, '\P{^General_Category=_ control}', ""); +Error('\p{Gc=/a/Cc}'); +Error('\P{Gc=/a/Cc}'); +Expect(1, 7, '\p{Gc=cc}', ""); +Expect(0, 7, '\p{^Gc=cc}', ""); +Expect(0, 7, '\P{Gc=cc}', ""); +Expect(1, 7, '\P{^Gc=cc}', ""); +Expect(0, 126, '\p{Gc=cc}', ""); +Expect(1, 126, '\p{^Gc=cc}', ""); +Expect(1, 126, '\P{Gc=cc}', ""); +Expect(0, 126, '\P{^Gc=cc}', ""); +Expect(1, 7, '\p{Gc=-CC}', ""); +Expect(0, 7, '\p{^Gc=-CC}', ""); +Expect(0, 7, '\P{Gc=-CC}', ""); +Expect(1, 7, '\P{^Gc=-CC}', ""); +Expect(0, 126, '\p{Gc=-CC}', ""); +Expect(1, 126, '\p{^Gc=-CC}', ""); +Expect(1, 126, '\P{Gc=-CC}', ""); +Expect(0, 126, '\P{^Gc=-CC}', ""); +Error('\p{Category= CNTRL/a/}'); +Error('\P{Category= CNTRL/a/}'); +Expect(1, 7, '\p{Category: cntrl}', ""); +Expect(0, 7, '\p{^Category: cntrl}', ""); +Expect(0, 7, '\P{Category: cntrl}', ""); +Expect(1, 7, '\P{^Category: cntrl}', ""); +Expect(0, 126, '\p{Category: cntrl}', ""); +Expect(1, 126, '\p{^Category: cntrl}', ""); +Expect(1, 126, '\P{Category: cntrl}', ""); +Expect(0, 126, '\P{^Category: cntrl}', ""); +Expect(1, 7, '\p{Category=--cntrl}', ""); +Expect(0, 7, '\p{^Category=--cntrl}', ""); +Expect(0, 7, '\P{Category=--cntrl}', ""); +Expect(1, 7, '\P{^Category=--cntrl}', ""); +Expect(0, 126, '\p{Category=--cntrl}', ""); +Expect(1, 126, '\p{^Category=--cntrl}', ""); +Expect(1, 126, '\P{Category=--cntrl}', ""); +Expect(0, 126, '\P{^Category=--cntrl}', ""); +Error('\p{Is_General_Category= :=Control}'); +Error('\P{Is_General_Category= :=Control}'); +Expect(1, 7, '\p{Is_General_Category=control}', ""); +Expect(0, 7, '\p{^Is_General_Category=control}', ""); +Expect(0, 7, '\P{Is_General_Category=control}', ""); +Expect(1, 7, '\P{^Is_General_Category=control}', ""); +Expect(0, 126, '\p{Is_General_Category=control}', ""); +Expect(1, 126, '\p{^Is_General_Category=control}', ""); +Expect(1, 126, '\P{Is_General_Category=control}', ""); +Expect(0, 126, '\P{^Is_General_Category=control}', ""); +Expect(1, 7, '\p{Is_General_Category= _control}', ""); +Expect(0, 7, '\p{^Is_General_Category= _control}', ""); +Expect(0, 7, '\P{Is_General_Category= _control}', ""); +Expect(1, 7, '\P{^Is_General_Category= _control}', ""); +Expect(0, 126, '\p{Is_General_Category= _control}', ""); +Expect(1, 126, '\p{^Is_General_Category= _control}', ""); +Expect(1, 126, '\P{Is_General_Category= _control}', ""); +Expect(0, 126, '\P{^Is_General_Category= _control}', ""); +Error('\p{Is_Gc=/a/Cc}'); +Error('\P{Is_Gc=/a/Cc}'); +Expect(1, 7, '\p{Is_Gc=cc}', ""); +Expect(0, 7, '\p{^Is_Gc=cc}', ""); +Expect(0, 7, '\P{Is_Gc=cc}', ""); +Expect(1, 7, '\P{^Is_Gc=cc}', ""); +Expect(0, 126, '\p{Is_Gc=cc}', ""); +Expect(1, 126, '\p{^Is_Gc=cc}', ""); +Expect(1, 126, '\P{Is_Gc=cc}', ""); +Expect(0, 126, '\P{^Is_Gc=cc}', ""); +Expect(1, 7, '\p{Is_Gc=__cc}', ""); +Expect(0, 7, '\p{^Is_Gc=__cc}', ""); +Expect(0, 7, '\P{Is_Gc=__cc}', ""); +Expect(1, 7, '\P{^Is_Gc=__cc}', ""); +Expect(0, 126, '\p{Is_Gc=__cc}', ""); +Expect(1, 126, '\p{^Is_Gc=__cc}', ""); +Expect(1, 126, '\P{Is_Gc=__cc}', ""); +Expect(0, 126, '\P{^Is_Gc=__cc}', ""); +Error('\p{Is_Category=/a/__cntrl}'); +Error('\P{Is_Category=/a/__cntrl}'); +Expect(1, 7, '\p{Is_Category: cntrl}', ""); +Expect(0, 7, '\p{^Is_Category: cntrl}', ""); +Expect(0, 7, '\P{Is_Category: cntrl}', ""); +Expect(1, 7, '\P{^Is_Category: cntrl}', ""); +Expect(0, 126, '\p{Is_Category: cntrl}', ""); +Expect(1, 126, '\p{^Is_Category: cntrl}', ""); +Expect(1, 126, '\P{Is_Category: cntrl}', ""); +Expect(0, 126, '\P{^Is_Category: cntrl}', ""); +Expect(1, 7, '\p{Is_Category=__cntrl}', ""); +Expect(0, 7, '\p{^Is_Category=__cntrl}', ""); +Expect(0, 7, '\P{Is_Category=__cntrl}', ""); +Expect(1, 7, '\P{^Is_Category=__cntrl}', ""); +Expect(0, 126, '\p{Is_Category=__cntrl}', ""); +Expect(1, 126, '\p{^Is_Category=__cntrl}', ""); +Expect(1, 126, '\P{Is_Category=__cntrl}', ""); +Expect(0, 126, '\P{^Is_Category=__cntrl}', ""); +Error('\p{General_Category=:= Line Separator}'); +Error('\P{General_Category=:= Line Separator}'); +Expect(1, 8232, '\p{General_Category=lineseparator}', ""); +Expect(0, 8232, '\p{^General_Category=lineseparator}', ""); +Expect(0, 8232, '\P{General_Category=lineseparator}', ""); +Expect(1, 8232, '\P{^General_Category=lineseparator}', ""); +Expect(0, 8231, '\p{General_Category=lineseparator}', ""); +Expect(1, 8231, '\p{^General_Category=lineseparator}', ""); +Expect(1, 8231, '\P{General_Category=lineseparator}', ""); +Expect(0, 8231, '\P{^General_Category=lineseparator}', ""); +Expect(1, 8232, '\p{General_Category= LINE SEPARATOR}', ""); +Expect(0, 8232, '\p{^General_Category= LINE SEPARATOR}', ""); +Expect(0, 8232, '\P{General_Category= LINE SEPARATOR}', ""); +Expect(1, 8232, '\P{^General_Category= LINE SEPARATOR}', ""); +Expect(0, 8231, '\p{General_Category= LINE SEPARATOR}', ""); +Expect(1, 8231, '\p{^General_Category= LINE SEPARATOR}', ""); +Expect(1, 8231, '\P{General_Category= LINE SEPARATOR}', ""); +Expect(0, 8231, '\P{^General_Category= LINE SEPARATOR}', ""); +Error('\p{Gc=-/a/zl}'); +Error('\P{Gc=-/a/zl}'); +Expect(1, 8232, '\p{Gc=zl}', ""); +Expect(0, 8232, '\p{^Gc=zl}', ""); +Expect(0, 8232, '\P{Gc=zl}', ""); +Expect(1, 8232, '\P{^Gc=zl}', ""); +Expect(0, 8231, '\p{Gc=zl}', ""); +Expect(1, 8231, '\p{^Gc=zl}', ""); +Expect(1, 8231, '\P{Gc=zl}', ""); +Expect(0, 8231, '\P{^Gc=zl}', ""); +Expect(1, 8232, '\p{Gc=- ZL}', ""); +Expect(0, 8232, '\p{^Gc=- ZL}', ""); +Expect(0, 8232, '\P{Gc=- ZL}', ""); +Expect(1, 8232, '\P{^Gc=- ZL}', ""); +Expect(0, 8231, '\p{Gc=- ZL}', ""); +Expect(1, 8231, '\p{^Gc=- ZL}', ""); +Expect(1, 8231, '\P{Gc=- ZL}', ""); +Expect(0, 8231, '\P{^Gc=- ZL}', ""); +Error('\p{Category=:=Line_Separator}'); +Error('\P{Category=:=Line_Separator}'); +Expect(1, 8232, '\p{Category=lineseparator}', ""); +Expect(0, 8232, '\p{^Category=lineseparator}', ""); +Expect(0, 8232, '\P{Category=lineseparator}', ""); +Expect(1, 8232, '\P{^Category=lineseparator}', ""); +Expect(0, 8231, '\p{Category=lineseparator}', ""); +Expect(1, 8231, '\p{^Category=lineseparator}', ""); +Expect(1, 8231, '\P{Category=lineseparator}', ""); +Expect(0, 8231, '\P{^Category=lineseparator}', ""); +Expect(1, 8232, '\p{Category: _ LINE Separator}', ""); +Expect(0, 8232, '\p{^Category: _ LINE Separator}', ""); +Expect(0, 8232, '\P{Category: _ LINE Separator}', ""); +Expect(1, 8232, '\P{^Category: _ LINE Separator}', ""); +Expect(0, 8231, '\p{Category: _ LINE Separator}', ""); +Expect(1, 8231, '\p{^Category: _ LINE Separator}', ""); +Expect(1, 8231, '\P{Category: _ LINE Separator}', ""); +Expect(0, 8231, '\P{^Category: _ LINE Separator}', ""); +Error('\p{Is_General_Category: := Zl}'); +Error('\P{Is_General_Category: := Zl}'); +Expect(1, 8232, '\p{Is_General_Category=zl}', ""); +Expect(0, 8232, '\p{^Is_General_Category=zl}', ""); +Expect(0, 8232, '\P{Is_General_Category=zl}', ""); +Expect(1, 8232, '\P{^Is_General_Category=zl}', ""); +Expect(0, 8231, '\p{Is_General_Category=zl}', ""); +Expect(1, 8231, '\p{^Is_General_Category=zl}', ""); +Expect(1, 8231, '\P{Is_General_Category=zl}', ""); +Expect(0, 8231, '\P{^Is_General_Category=zl}', ""); +Expect(1, 8232, '\p{Is_General_Category= -Zl}', ""); +Expect(0, 8232, '\p{^Is_General_Category= -Zl}', ""); +Expect(0, 8232, '\P{Is_General_Category= -Zl}', ""); +Expect(1, 8232, '\P{^Is_General_Category= -Zl}', ""); +Expect(0, 8231, '\p{Is_General_Category= -Zl}', ""); +Expect(1, 8231, '\p{^Is_General_Category= -Zl}', ""); +Expect(1, 8231, '\P{Is_General_Category= -Zl}', ""); +Expect(0, 8231, '\P{^Is_General_Category= -Zl}', ""); +Error('\p{Is_Gc=/a/ -line-SEPARATOR}'); +Error('\P{Is_Gc=/a/ -line-SEPARATOR}'); +Expect(1, 8232, '\p{Is_Gc=lineseparator}', ""); +Expect(0, 8232, '\p{^Is_Gc=lineseparator}', ""); +Expect(0, 8232, '\P{Is_Gc=lineseparator}', ""); +Expect(1, 8232, '\P{^Is_Gc=lineseparator}', ""); +Expect(0, 8231, '\p{Is_Gc=lineseparator}', ""); +Expect(1, 8231, '\p{^Is_Gc=lineseparator}', ""); +Expect(1, 8231, '\P{Is_Gc=lineseparator}', ""); +Expect(0, 8231, '\P{^Is_Gc=lineseparator}', ""); +Expect(1, 8232, '\p{Is_Gc= Line separator}', ""); +Expect(0, 8232, '\p{^Is_Gc= Line separator}', ""); +Expect(0, 8232, '\P{Is_Gc= Line separator}', ""); +Expect(1, 8232, '\P{^Is_Gc= Line separator}', ""); +Expect(0, 8231, '\p{Is_Gc= Line separator}', ""); +Expect(1, 8231, '\p{^Is_Gc= Line separator}', ""); +Expect(1, 8231, '\P{Is_Gc= Line separator}', ""); +Expect(0, 8231, '\P{^Is_Gc= Line separator}', ""); +Error('\p{Is_Category=/a/Zl}'); +Error('\P{Is_Category=/a/Zl}'); +Expect(1, 8232, '\p{Is_Category=zl}', ""); +Expect(0, 8232, '\p{^Is_Category=zl}', ""); +Expect(0, 8232, '\P{Is_Category=zl}', ""); +Expect(1, 8232, '\P{^Is_Category=zl}', ""); +Expect(0, 8231, '\p{Is_Category=zl}', ""); +Expect(1, 8231, '\p{^Is_Category=zl}', ""); +Expect(1, 8231, '\P{Is_Category=zl}', ""); +Expect(0, 8231, '\P{^Is_Category=zl}', ""); +Expect(1, 8232, '\p{Is_Category=- Zl}', ""); +Expect(0, 8232, '\p{^Is_Category=- Zl}', ""); +Expect(0, 8232, '\P{Is_Category=- Zl}', ""); +Expect(1, 8232, '\P{^Is_Category=- Zl}', ""); +Expect(0, 8231, '\p{Is_Category=- Zl}', ""); +Expect(1, 8231, '\p{^Is_Category=- Zl}', ""); +Expect(1, 8231, '\P{Is_Category=- Zl}', ""); +Expect(0, 8231, '\P{^Is_Category=- Zl}', ""); +Error('\p{General_Category= :=OPEN Punctuation}'); +Error('\P{General_Category= :=OPEN Punctuation}'); +Expect(1, 40, '\p{General_Category=openpunctuation}', ""); +Expect(0, 40, '\p{^General_Category=openpunctuation}', ""); +Expect(0, 40, '\P{General_Category=openpunctuation}', ""); +Expect(1, 40, '\P{^General_Category=openpunctuation}', ""); +Expect(0, 39, '\p{General_Category=openpunctuation}', ""); +Expect(1, 39, '\p{^General_Category=openpunctuation}', ""); +Expect(1, 39, '\P{General_Category=openpunctuation}', ""); +Expect(0, 39, '\P{^General_Category=openpunctuation}', ""); +Expect(1, 40, '\p{General_Category= openpunctuation}', ""); +Expect(0, 40, '\p{^General_Category= openpunctuation}', ""); +Expect(0, 40, '\P{General_Category= openpunctuation}', ""); +Expect(1, 40, '\P{^General_Category= openpunctuation}', ""); +Expect(0, 39, '\p{General_Category= openpunctuation}', ""); +Expect(1, 39, '\p{^General_Category= openpunctuation}', ""); +Expect(1, 39, '\P{General_Category= openpunctuation}', ""); +Expect(0, 39, '\P{^General_Category= openpunctuation}', ""); +Error('\p{Gc=/a/ Ps}'); +Error('\P{Gc=/a/ Ps}'); +Expect(1, 40, '\p{Gc=ps}', ""); +Expect(0, 40, '\p{^Gc=ps}', ""); +Expect(0, 40, '\P{Gc=ps}', ""); +Expect(1, 40, '\P{^Gc=ps}', ""); +Expect(0, 39, '\p{Gc=ps}', ""); +Expect(1, 39, '\p{^Gc=ps}', ""); +Expect(1, 39, '\P{Gc=ps}', ""); +Expect(0, 39, '\P{^Gc=ps}', ""); +Expect(1, 40, '\p{Gc: _PS}', ""); +Expect(0, 40, '\p{^Gc: _PS}', ""); +Expect(0, 40, '\P{Gc: _PS}', ""); +Expect(1, 40, '\P{^Gc: _PS}', ""); +Expect(0, 39, '\p{Gc: _PS}', ""); +Expect(1, 39, '\p{^Gc: _PS}', ""); +Expect(1, 39, '\P{Gc: _PS}', ""); +Expect(0, 39, '\P{^Gc: _PS}', ""); +Error('\p{Category=/a/__open Punctuation}'); +Error('\P{Category=/a/__open Punctuation}'); +Expect(1, 40, '\p{Category=openpunctuation}', ""); +Expect(0, 40, '\p{^Category=openpunctuation}', ""); +Expect(0, 40, '\P{Category=openpunctuation}', ""); +Expect(1, 40, '\P{^Category=openpunctuation}', ""); +Expect(0, 39, '\p{Category=openpunctuation}', ""); +Expect(1, 39, '\p{^Category=openpunctuation}', ""); +Expect(1, 39, '\P{Category=openpunctuation}', ""); +Expect(0, 39, '\P{^Category=openpunctuation}', ""); +Expect(1, 40, '\p{Category= _Openpunctuation}', ""); +Expect(0, 40, '\p{^Category= _Openpunctuation}', ""); +Expect(0, 40, '\P{Category= _Openpunctuation}', ""); +Expect(1, 40, '\P{^Category= _Openpunctuation}', ""); +Expect(0, 39, '\p{Category= _Openpunctuation}', ""); +Expect(1, 39, '\p{^Category= _Openpunctuation}', ""); +Expect(1, 39, '\P{Category= _Openpunctuation}', ""); +Expect(0, 39, '\P{^Category= _Openpunctuation}', ""); +Error('\p{Is_General_Category=:=Ps}'); +Error('\P{Is_General_Category=:=Ps}'); +Expect(1, 40, '\p{Is_General_Category=ps}', ""); +Expect(0, 40, '\p{^Is_General_Category=ps}', ""); +Expect(0, 40, '\P{Is_General_Category=ps}', ""); +Expect(1, 40, '\P{^Is_General_Category=ps}', ""); +Expect(0, 39, '\p{Is_General_Category=ps}', ""); +Expect(1, 39, '\p{^Is_General_Category=ps}', ""); +Expect(1, 39, '\P{Is_General_Category=ps}', ""); +Expect(0, 39, '\P{^Is_General_Category=ps}', ""); +Expect(1, 40, '\p{Is_General_Category= Ps}', ""); +Expect(0, 40, '\p{^Is_General_Category= Ps}', ""); +Expect(0, 40, '\P{Is_General_Category= Ps}', ""); +Expect(1, 40, '\P{^Is_General_Category= Ps}', ""); +Expect(0, 39, '\p{Is_General_Category= Ps}', ""); +Expect(1, 39, '\p{^Is_General_Category= Ps}', ""); +Expect(1, 39, '\P{Is_General_Category= Ps}', ""); +Expect(0, 39, '\P{^Is_General_Category= Ps}', ""); +Error('\p{Is_Gc=/a/_-OPEN-Punctuation}'); +Error('\P{Is_Gc=/a/_-OPEN-Punctuation}'); +Expect(1, 40, '\p{Is_Gc=openpunctuation}', ""); +Expect(0, 40, '\p{^Is_Gc=openpunctuation}', ""); +Expect(0, 40, '\P{Is_Gc=openpunctuation}', ""); +Expect(1, 40, '\P{^Is_Gc=openpunctuation}', ""); +Expect(0, 39, '\p{Is_Gc=openpunctuation}', ""); +Expect(1, 39, '\p{^Is_Gc=openpunctuation}', ""); +Expect(1, 39, '\P{Is_Gc=openpunctuation}', ""); +Expect(0, 39, '\P{^Is_Gc=openpunctuation}', ""); +Expect(1, 40, '\p{Is_Gc= OpenPunctuation}', ""); +Expect(0, 40, '\p{^Is_Gc= OpenPunctuation}', ""); +Expect(0, 40, '\P{Is_Gc= OpenPunctuation}', ""); +Expect(1, 40, '\P{^Is_Gc= OpenPunctuation}', ""); +Expect(0, 39, '\p{Is_Gc= OpenPunctuation}', ""); +Expect(1, 39, '\p{^Is_Gc= OpenPunctuation}', ""); +Expect(1, 39, '\P{Is_Gc= OpenPunctuation}', ""); +Expect(0, 39, '\P{^Is_Gc= OpenPunctuation}', ""); +Error('\p{Is_Category=/a/ PS}'); +Error('\P{Is_Category=/a/ PS}'); +Expect(1, 40, '\p{Is_Category=ps}', ""); +Expect(0, 40, '\p{^Is_Category=ps}', ""); +Expect(0, 40, '\P{Is_Category=ps}', ""); +Expect(1, 40, '\P{^Is_Category=ps}', ""); +Expect(0, 39, '\p{Is_Category=ps}', ""); +Expect(1, 39, '\p{^Is_Category=ps}', ""); +Expect(1, 39, '\P{Is_Category=ps}', ""); +Expect(0, 39, '\P{^Is_Category=ps}', ""); +Expect(1, 40, '\p{Is_Category= PS}', ""); +Expect(0, 40, '\p{^Is_Category= PS}', ""); +Expect(0, 40, '\P{Is_Category= PS}', ""); +Expect(1, 40, '\P{^Is_Category= PS}', ""); +Expect(0, 39, '\p{Is_Category= PS}', ""); +Expect(1, 39, '\p{^Is_Category= PS}', ""); +Expect(1, 39, '\P{Is_Category= PS}', ""); +Expect(0, 39, '\P{^Is_Category= PS}', ""); +Error('\p{General_Category= Math_symbol/a/}'); +Error('\P{General_Category= Math_symbol/a/}'); +Expect(1, 43, '\p{General_Category=mathsymbol}', ""); +Expect(0, 43, '\p{^General_Category=mathsymbol}', ""); +Expect(0, 43, '\P{General_Category=mathsymbol}', ""); +Expect(1, 43, '\P{^General_Category=mathsymbol}', ""); +Expect(0, 42, '\p{General_Category=mathsymbol}', ""); +Expect(1, 42, '\p{^General_Category=mathsymbol}', ""); +Expect(1, 42, '\P{General_Category=mathsymbol}', ""); +Expect(0, 42, '\P{^General_Category=mathsymbol}', ""); +Expect(1, 43, '\p{General_Category=-_math_Symbol}', ""); +Expect(0, 43, '\p{^General_Category=-_math_Symbol}', ""); +Expect(0, 43, '\P{General_Category=-_math_Symbol}', ""); +Expect(1, 43, '\P{^General_Category=-_math_Symbol}', ""); +Expect(0, 42, '\p{General_Category=-_math_Symbol}', ""); +Expect(1, 42, '\p{^General_Category=-_math_Symbol}', ""); +Expect(1, 42, '\P{General_Category=-_math_Symbol}', ""); +Expect(0, 42, '\P{^General_Category=-_math_Symbol}', ""); +Error('\p{Gc: /a/sm}'); +Error('\P{Gc: /a/sm}'); +Expect(1, 43, '\p{Gc=sm}', ""); +Expect(0, 43, '\p{^Gc=sm}', ""); +Expect(0, 43, '\P{Gc=sm}', ""); +Expect(1, 43, '\P{^Gc=sm}', ""); +Expect(0, 42, '\p{Gc=sm}', ""); +Expect(1, 42, '\p{^Gc=sm}', ""); +Expect(1, 42, '\P{Gc=sm}', ""); +Expect(0, 42, '\P{^Gc=sm}', ""); +Expect(1, 43, '\p{Gc= Sm}', ""); +Expect(0, 43, '\p{^Gc= Sm}', ""); +Expect(0, 43, '\P{Gc= Sm}', ""); +Expect(1, 43, '\P{^Gc= Sm}', ""); +Expect(0, 42, '\p{Gc= Sm}', ""); +Expect(1, 42, '\p{^Gc= Sm}', ""); +Expect(1, 42, '\P{Gc= Sm}', ""); +Expect(0, 42, '\P{^Gc= Sm}', ""); +Error('\p{Category=_/a/Math symbol}'); +Error('\P{Category=_/a/Math symbol}'); +Expect(1, 43, '\p{Category=mathsymbol}', ""); +Expect(0, 43, '\p{^Category=mathsymbol}', ""); +Expect(0, 43, '\P{Category=mathsymbol}', ""); +Expect(1, 43, '\P{^Category=mathsymbol}', ""); +Expect(0, 42, '\p{Category=mathsymbol}', ""); +Expect(1, 42, '\p{^Category=mathsymbol}', ""); +Expect(1, 42, '\P{Category=mathsymbol}', ""); +Expect(0, 42, '\P{^Category=mathsymbol}', ""); +Expect(1, 43, '\p{Category=-MATH_symbol}', ""); +Expect(0, 43, '\p{^Category=-MATH_symbol}', ""); +Expect(0, 43, '\P{Category=-MATH_symbol}', ""); +Expect(1, 43, '\P{^Category=-MATH_symbol}', ""); +Expect(0, 42, '\p{Category=-MATH_symbol}', ""); +Expect(1, 42, '\p{^Category=-MATH_symbol}', ""); +Expect(1, 42, '\P{Category=-MATH_symbol}', ""); +Expect(0, 42, '\P{^Category=-MATH_symbol}', ""); +Error('\p{Is_General_Category=/a/_ Sm}'); +Error('\P{Is_General_Category=/a/_ Sm}'); +Expect(1, 43, '\p{Is_General_Category=sm}', ""); +Expect(0, 43, '\p{^Is_General_Category=sm}', ""); +Expect(0, 43, '\P{Is_General_Category=sm}', ""); +Expect(1, 43, '\P{^Is_General_Category=sm}', ""); +Expect(0, 42, '\p{Is_General_Category=sm}', ""); +Expect(1, 42, '\p{^Is_General_Category=sm}', ""); +Expect(1, 42, '\P{Is_General_Category=sm}', ""); +Expect(0, 42, '\P{^Is_General_Category=sm}', ""); +Expect(1, 43, '\p{Is_General_Category=__Sm}', ""); +Expect(0, 43, '\p{^Is_General_Category=__Sm}', ""); +Expect(0, 43, '\P{Is_General_Category=__Sm}', ""); +Expect(1, 43, '\P{^Is_General_Category=__Sm}', ""); +Expect(0, 42, '\p{Is_General_Category=__Sm}', ""); +Expect(1, 42, '\p{^Is_General_Category=__Sm}', ""); +Expect(1, 42, '\P{Is_General_Category=__Sm}', ""); +Expect(0, 42, '\P{^Is_General_Category=__Sm}', ""); +Error('\p{Is_Gc=:= -Math SYMBOL}'); +Error('\P{Is_Gc=:= -Math SYMBOL}'); +Expect(1, 43, '\p{Is_Gc=mathsymbol}', ""); +Expect(0, 43, '\p{^Is_Gc=mathsymbol}', ""); +Expect(0, 43, '\P{Is_Gc=mathsymbol}', ""); +Expect(1, 43, '\P{^Is_Gc=mathsymbol}', ""); +Expect(0, 42, '\p{Is_Gc=mathsymbol}', ""); +Expect(1, 42, '\p{^Is_Gc=mathsymbol}', ""); +Expect(1, 42, '\P{Is_Gc=mathsymbol}', ""); +Expect(0, 42, '\P{^Is_Gc=mathsymbol}', ""); +Expect(1, 43, '\p{Is_Gc=MATHSymbol}', ""); +Expect(0, 43, '\p{^Is_Gc=MATHSymbol}', ""); +Expect(0, 43, '\P{Is_Gc=MATHSymbol}', ""); +Expect(1, 43, '\P{^Is_Gc=MATHSymbol}', ""); +Expect(0, 42, '\p{Is_Gc=MATHSymbol}', ""); +Expect(1, 42, '\p{^Is_Gc=MATHSymbol}', ""); +Expect(1, 42, '\P{Is_Gc=MATHSymbol}', ""); +Expect(0, 42, '\P{^Is_Gc=MATHSymbol}', ""); +Error('\p{Is_Category=_SM/a/}'); +Error('\P{Is_Category=_SM/a/}'); +Expect(1, 43, '\p{Is_Category=sm}', ""); +Expect(0, 43, '\p{^Is_Category=sm}', ""); +Expect(0, 43, '\P{Is_Category=sm}', ""); +Expect(1, 43, '\P{^Is_Category=sm}', ""); +Expect(0, 42, '\p{Is_Category=sm}', ""); +Expect(1, 42, '\p{^Is_Category=sm}', ""); +Expect(1, 42, '\P{Is_Category=sm}', ""); +Expect(0, 42, '\P{^Is_Category=sm}', ""); +Expect(1, 43, '\p{Is_Category= Sm}', ""); +Expect(0, 43, '\p{^Is_Category= Sm}', ""); +Expect(0, 43, '\P{Is_Category= Sm}', ""); +Expect(1, 43, '\P{^Is_Category= Sm}', ""); +Expect(0, 42, '\p{Is_Category= Sm}', ""); +Expect(1, 42, '\p{^Is_Category= Sm}', ""); +Expect(1, 42, '\P{Is_Category= Sm}', ""); +Expect(0, 42, '\P{^Is_Category= Sm}', ""); +Error('\p{General_Category= OTHER LETTER:=}'); +Error('\P{General_Category= OTHER LETTER:=}'); +Expect(1, 443, '\p{General_Category=otherletter}', ""); +Expect(0, 443, '\p{^General_Category=otherletter}', ""); +Expect(0, 443, '\P{General_Category=otherletter}', ""); +Expect(1, 443, '\P{^General_Category=otherletter}', ""); +Expect(0, 442, '\p{General_Category=otherletter}', ""); +Expect(1, 442, '\p{^General_Category=otherletter}', ""); +Expect(1, 442, '\P{General_Category=otherletter}', ""); +Expect(0, 442, '\P{^General_Category=otherletter}', ""); +Expect(1, 443, '\p{General_Category=_ otherLetter}', ""); +Expect(0, 443, '\p{^General_Category=_ otherLetter}', ""); +Expect(0, 443, '\P{General_Category=_ otherLetter}', ""); +Expect(1, 443, '\P{^General_Category=_ otherLetter}', ""); +Expect(0, 442, '\p{General_Category=_ otherLetter}', ""); +Expect(1, 442, '\p{^General_Category=_ otherLetter}', ""); +Expect(1, 442, '\P{General_Category=_ otherLetter}', ""); +Expect(0, 442, '\P{^General_Category=_ otherLetter}', ""); +Error('\p{Gc= -LO:=}'); +Error('\P{Gc= -LO:=}'); +Expect(1, 443, '\p{Gc=lo}', ""); +Expect(0, 443, '\p{^Gc=lo}', ""); +Expect(0, 443, '\P{Gc=lo}', ""); +Expect(1, 443, '\P{^Gc=lo}', ""); +Expect(0, 442, '\p{Gc=lo}', ""); +Expect(1, 442, '\p{^Gc=lo}', ""); +Expect(1, 442, '\P{Gc=lo}', ""); +Expect(0, 442, '\P{^Gc=lo}', ""); +Expect(1, 443, '\p{Gc=_ Lo}', ""); +Expect(0, 443, '\p{^Gc=_ Lo}', ""); +Expect(0, 443, '\P{Gc=_ Lo}', ""); +Expect(1, 443, '\P{^Gc=_ Lo}', ""); +Expect(0, 442, '\p{Gc=_ Lo}', ""); +Expect(1, 442, '\p{^Gc=_ Lo}', ""); +Expect(1, 442, '\P{Gc=_ Lo}', ""); +Expect(0, 442, '\P{^Gc=_ Lo}', ""); +Error('\p{Category= Other Letter/a/}'); +Error('\P{Category= Other Letter/a/}'); +Expect(1, 443, '\p{Category=otherletter}', ""); +Expect(0, 443, '\p{^Category=otherletter}', ""); +Expect(0, 443, '\P{Category=otherletter}', ""); +Expect(1, 443, '\P{^Category=otherletter}', ""); +Expect(0, 442, '\p{Category=otherletter}', ""); +Expect(1, 442, '\p{^Category=otherletter}', ""); +Expect(1, 442, '\P{Category=otherletter}', ""); +Expect(0, 442, '\P{^Category=otherletter}', ""); +Expect(1, 443, '\p{Category=- Other letter}', ""); +Expect(0, 443, '\p{^Category=- Other letter}', ""); +Expect(0, 443, '\P{Category=- Other letter}', ""); +Expect(1, 443, '\P{^Category=- Other letter}', ""); +Expect(0, 442, '\p{Category=- Other letter}', ""); +Expect(1, 442, '\p{^Category=- Other letter}', ""); +Expect(1, 442, '\P{Category=- Other letter}', ""); +Expect(0, 442, '\P{^Category=- Other letter}', ""); +Error('\p{Is_General_Category=:=Lo}'); +Error('\P{Is_General_Category=:=Lo}'); +Expect(1, 443, '\p{Is_General_Category=lo}', ""); +Expect(0, 443, '\p{^Is_General_Category=lo}', ""); +Expect(0, 443, '\P{Is_General_Category=lo}', ""); +Expect(1, 443, '\P{^Is_General_Category=lo}', ""); +Expect(0, 442, '\p{Is_General_Category=lo}', ""); +Expect(1, 442, '\p{^Is_General_Category=lo}', ""); +Expect(1, 442, '\P{Is_General_Category=lo}', ""); +Expect(0, 442, '\P{^Is_General_Category=lo}', ""); +Expect(1, 443, '\p{Is_General_Category= -Lo}', ""); +Expect(0, 443, '\p{^Is_General_Category= -Lo}', ""); +Expect(0, 443, '\P{Is_General_Category= -Lo}', ""); +Expect(1, 443, '\P{^Is_General_Category= -Lo}', ""); +Expect(0, 442, '\p{Is_General_Category= -Lo}', ""); +Expect(1, 442, '\p{^Is_General_Category= -Lo}', ""); +Expect(1, 442, '\P{Is_General_Category= -Lo}', ""); +Expect(0, 442, '\P{^Is_General_Category= -Lo}', ""); +Error('\p{Is_Gc= /a/OTHER Letter}'); +Error('\P{Is_Gc= /a/OTHER Letter}'); +Expect(1, 443, '\p{Is_Gc=otherletter}', ""); +Expect(0, 443, '\p{^Is_Gc=otherletter}', ""); +Expect(0, 443, '\P{Is_Gc=otherletter}', ""); +Expect(1, 443, '\P{^Is_Gc=otherletter}', ""); +Expect(0, 442, '\p{Is_Gc=otherletter}', ""); +Expect(1, 442, '\p{^Is_Gc=otherletter}', ""); +Expect(1, 442, '\P{Is_Gc=otherletter}', ""); +Expect(0, 442, '\P{^Is_Gc=otherletter}', ""); +Expect(1, 443, '\p{Is_Gc= other LETTER}', ""); +Expect(0, 443, '\p{^Is_Gc= other LETTER}', ""); +Expect(0, 443, '\P{Is_Gc= other LETTER}', ""); +Expect(1, 443, '\P{^Is_Gc= other LETTER}', ""); +Expect(0, 442, '\p{Is_Gc= other LETTER}', ""); +Expect(1, 442, '\p{^Is_Gc= other LETTER}', ""); +Expect(1, 442, '\P{Is_Gc= other LETTER}', ""); +Expect(0, 442, '\P{^Is_Gc= other LETTER}', ""); +Error('\p{Is_Category=_Lo:=}'); +Error('\P{Is_Category=_Lo:=}'); +Expect(1, 443, '\p{Is_Category=lo}', ""); +Expect(0, 443, '\p{^Is_Category=lo}', ""); +Expect(0, 443, '\P{Is_Category=lo}', ""); +Expect(1, 443, '\P{^Is_Category=lo}', ""); +Expect(0, 442, '\p{Is_Category=lo}', ""); +Expect(1, 442, '\p{^Is_Category=lo}', ""); +Expect(1, 442, '\P{Is_Category=lo}', ""); +Expect(0, 442, '\P{^Is_Category=lo}', ""); +Expect(1, 443, '\p{Is_Category= lo}', ""); +Expect(0, 443, '\p{^Is_Category= lo}', ""); +Expect(0, 443, '\P{Is_Category= lo}', ""); +Expect(1, 443, '\P{^Is_Category= lo}', ""); +Expect(0, 442, '\p{Is_Category= lo}', ""); +Expect(1, 442, '\p{^Is_Category= lo}', ""); +Expect(1, 442, '\P{Is_Category= lo}', ""); +Expect(0, 442, '\P{^Is_Category= lo}', ""); +Error('\p{General_Category=_:=Separator}'); +Error('\P{General_Category=_:=Separator}'); +Expect(1, 32, '\p{General_Category=separator}', ""); +Expect(0, 32, '\p{^General_Category=separator}', ""); +Expect(0, 32, '\P{General_Category=separator}', ""); +Expect(1, 32, '\P{^General_Category=separator}', ""); +Expect(0, 7, '\p{General_Category=separator}', ""); +Expect(1, 7, '\p{^General_Category=separator}', ""); +Expect(1, 7, '\P{General_Category=separator}', ""); +Expect(0, 7, '\P{^General_Category=separator}', ""); +Expect(1, 32, '\p{General_Category=__Separator}', ""); +Expect(0, 32, '\p{^General_Category=__Separator}', ""); +Expect(0, 32, '\P{General_Category=__Separator}', ""); +Expect(1, 32, '\P{^General_Category=__Separator}', ""); +Expect(0, 7, '\p{General_Category=__Separator}', ""); +Expect(1, 7, '\p{^General_Category=__Separator}', ""); +Expect(1, 7, '\P{General_Category=__Separator}', ""); +Expect(0, 7, '\P{^General_Category=__Separator}', ""); +Error('\p{Gc: _z/a/}'); +Error('\P{Gc: _z/a/}'); +Expect(1, 32, '\p{Gc=z}', ""); +Expect(0, 32, '\p{^Gc=z}', ""); +Expect(0, 32, '\P{Gc=z}', ""); +Expect(1, 32, '\P{^Gc=z}', ""); +Expect(0, 7, '\p{Gc=z}', ""); +Expect(1, 7, '\p{^Gc=z}', ""); +Expect(1, 7, '\P{Gc=z}', ""); +Expect(0, 7, '\P{^Gc=z}', ""); +Expect(1, 32, '\p{Gc= Z}', ""); +Expect(0, 32, '\p{^Gc= Z}', ""); +Expect(0, 32, '\P{Gc= Z}', ""); +Expect(1, 32, '\P{^Gc= Z}', ""); +Expect(0, 7, '\p{Gc= Z}', ""); +Expect(1, 7, '\p{^Gc= Z}', ""); +Expect(1, 7, '\P{Gc= Z}', ""); +Expect(0, 7, '\P{^Gc= Z}', ""); +Error('\p{Category=:= Separator}'); +Error('\P{Category=:= Separator}'); +Expect(1, 32, '\p{Category=separator}', ""); +Expect(0, 32, '\p{^Category=separator}', ""); +Expect(0, 32, '\P{Category=separator}', ""); +Expect(1, 32, '\P{^Category=separator}', ""); +Expect(0, 7, '\p{Category=separator}', ""); +Expect(1, 7, '\p{^Category=separator}', ""); +Expect(1, 7, '\P{Category=separator}', ""); +Expect(0, 7, '\P{^Category=separator}', ""); +Expect(1, 32, '\p{Category=- Separator}', ""); +Expect(0, 32, '\p{^Category=- Separator}', ""); +Expect(0, 32, '\P{Category=- Separator}', ""); +Expect(1, 32, '\P{^Category=- Separator}', ""); +Expect(0, 7, '\p{Category=- Separator}', ""); +Expect(1, 7, '\p{^Category=- Separator}', ""); +Expect(1, 7, '\P{Category=- Separator}', ""); +Expect(0, 7, '\P{^Category=- Separator}', ""); +Error('\p{Is_General_Category=_Z/a/}'); +Error('\P{Is_General_Category=_Z/a/}'); +Expect(1, 32, '\p{Is_General_Category=z}', ""); +Expect(0, 32, '\p{^Is_General_Category=z}', ""); +Expect(0, 32, '\P{Is_General_Category=z}', ""); +Expect(1, 32, '\P{^Is_General_Category=z}', ""); +Expect(0, 7, '\p{Is_General_Category=z}', ""); +Expect(1, 7, '\p{^Is_General_Category=z}', ""); +Expect(1, 7, '\P{Is_General_Category=z}', ""); +Expect(0, 7, '\P{^Is_General_Category=z}', ""); +Expect(1, 32, '\p{Is_General_Category=__z}', ""); +Expect(0, 32, '\p{^Is_General_Category=__z}', ""); +Expect(0, 32, '\P{Is_General_Category=__z}', ""); +Expect(1, 32, '\P{^Is_General_Category=__z}', ""); +Expect(0, 7, '\p{Is_General_Category=__z}', ""); +Expect(1, 7, '\p{^Is_General_Category=__z}', ""); +Expect(1, 7, '\P{Is_General_Category=__z}', ""); +Expect(0, 7, '\P{^Is_General_Category=__z}', ""); +Error('\p{Is_Gc=:= -Separator}'); +Error('\P{Is_Gc=:= -Separator}'); +Expect(1, 32, '\p{Is_Gc=separator}', ""); +Expect(0, 32, '\p{^Is_Gc=separator}', ""); +Expect(0, 32, '\P{Is_Gc=separator}', ""); +Expect(1, 32, '\P{^Is_Gc=separator}', ""); +Expect(0, 7, '\p{Is_Gc=separator}', ""); +Expect(1, 7, '\p{^Is_Gc=separator}', ""); +Expect(1, 7, '\P{Is_Gc=separator}', ""); +Expect(0, 7, '\P{^Is_Gc=separator}', ""); +Expect(1, 32, '\p{Is_Gc= Separator}', ""); +Expect(0, 32, '\p{^Is_Gc= Separator}', ""); +Expect(0, 32, '\P{Is_Gc= Separator}', ""); +Expect(1, 32, '\P{^Is_Gc= Separator}', ""); +Expect(0, 7, '\p{Is_Gc= Separator}', ""); +Expect(1, 7, '\p{^Is_Gc= Separator}', ""); +Expect(1, 7, '\P{Is_Gc= Separator}', ""); +Expect(0, 7, '\P{^Is_Gc= Separator}', ""); +Error('\p{Is_Category=_:=Z}'); +Error('\P{Is_Category=_:=Z}'); +Expect(1, 32, '\p{Is_Category:z}', ""); +Expect(0, 32, '\p{^Is_Category:z}', ""); +Expect(0, 32, '\P{Is_Category:z}', ""); +Expect(1, 32, '\P{^Is_Category:z}', ""); +Expect(0, 7, '\p{Is_Category:z}', ""); +Expect(1, 7, '\p{^Is_Category:z}', ""); +Expect(1, 7, '\P{Is_Category:z}', ""); +Expect(0, 7, '\P{^Is_Category:z}', ""); +Expect(1, 32, '\p{Is_Category= Z}', ""); +Expect(0, 32, '\p{^Is_Category= Z}', ""); +Expect(0, 32, '\P{Is_Category= Z}', ""); +Expect(1, 32, '\P{^Is_Category= Z}', ""); +Expect(0, 7, '\p{Is_Category= Z}', ""); +Expect(1, 7, '\p{^Is_Category= Z}', ""); +Expect(1, 7, '\P{Is_Category= Z}', ""); +Expect(0, 7, '\P{^Is_Category= Z}', ""); +Error('\p{General_Category=:=- Otherpunctuation}'); +Error('\P{General_Category=:=- Otherpunctuation}'); +Expect(1, 35, '\p{General_Category=otherpunctuation}', ""); +Expect(0, 35, '\p{^General_Category=otherpunctuation}', ""); +Expect(0, 35, '\P{General_Category=otherpunctuation}', ""); +Expect(1, 35, '\P{^General_Category=otherpunctuation}', ""); +Expect(0, 32, '\p{General_Category=otherpunctuation}', ""); +Expect(1, 32, '\p{^General_Category=otherpunctuation}', ""); +Expect(1, 32, '\P{General_Category=otherpunctuation}', ""); +Expect(0, 32, '\P{^General_Category=otherpunctuation}', ""); +Expect(1, 35, '\p{General_Category=_ OTHER_Punctuation}', ""); +Expect(0, 35, '\p{^General_Category=_ OTHER_Punctuation}', ""); +Expect(0, 35, '\P{General_Category=_ OTHER_Punctuation}', ""); +Expect(1, 35, '\P{^General_Category=_ OTHER_Punctuation}', ""); +Expect(0, 32, '\p{General_Category=_ OTHER_Punctuation}', ""); +Expect(1, 32, '\p{^General_Category=_ OTHER_Punctuation}', ""); +Expect(1, 32, '\P{General_Category=_ OTHER_Punctuation}', ""); +Expect(0, 32, '\P{^General_Category=_ OTHER_Punctuation}', ""); +Error('\p{Gc=:= Po}'); +Error('\P{Gc=:= Po}'); +Expect(1, 35, '\p{Gc=po}', ""); +Expect(0, 35, '\p{^Gc=po}', ""); +Expect(0, 35, '\P{Gc=po}', ""); +Expect(1, 35, '\P{^Gc=po}', ""); +Expect(0, 32, '\p{Gc=po}', ""); +Expect(1, 32, '\p{^Gc=po}', ""); +Expect(1, 32, '\P{Gc=po}', ""); +Expect(0, 32, '\P{^Gc=po}', ""); +Expect(1, 35, '\p{Gc=-_po}', ""); +Expect(0, 35, '\p{^Gc=-_po}', ""); +Expect(0, 35, '\P{Gc=-_po}', ""); +Expect(1, 35, '\P{^Gc=-_po}', ""); +Expect(0, 32, '\p{Gc=-_po}', ""); +Expect(1, 32, '\p{^Gc=-_po}', ""); +Expect(1, 32, '\P{Gc=-_po}', ""); +Expect(0, 32, '\P{^Gc=-_po}', ""); +Error('\p{Category=/a/ other_punctuation}'); +Error('\P{Category=/a/ other_punctuation}'); +Expect(1, 35, '\p{Category=otherpunctuation}', ""); +Expect(0, 35, '\p{^Category=otherpunctuation}', ""); +Expect(0, 35, '\P{Category=otherpunctuation}', ""); +Expect(1, 35, '\P{^Category=otherpunctuation}', ""); +Expect(0, 32, '\p{Category=otherpunctuation}', ""); +Expect(1, 32, '\p{^Category=otherpunctuation}', ""); +Expect(1, 32, '\P{Category=otherpunctuation}', ""); +Expect(0, 32, '\P{^Category=otherpunctuation}', ""); +Expect(1, 35, '\p{Category=-_OTHER punctuation}', ""); +Expect(0, 35, '\p{^Category=-_OTHER punctuation}', ""); +Expect(0, 35, '\P{Category=-_OTHER punctuation}', ""); +Expect(1, 35, '\P{^Category=-_OTHER punctuation}', ""); +Expect(0, 32, '\p{Category=-_OTHER punctuation}', ""); +Expect(1, 32, '\p{^Category=-_OTHER punctuation}', ""); +Expect(1, 32, '\P{Category=-_OTHER punctuation}', ""); +Expect(0, 32, '\P{^Category=-_OTHER punctuation}', ""); +Error('\p{Is_General_Category= :=PO}'); +Error('\P{Is_General_Category= :=PO}'); +Expect(1, 35, '\p{Is_General_Category: po}', ""); +Expect(0, 35, '\p{^Is_General_Category: po}', ""); +Expect(0, 35, '\P{Is_General_Category: po}', ""); +Expect(1, 35, '\P{^Is_General_Category: po}', ""); +Expect(0, 32, '\p{Is_General_Category: po}', ""); +Expect(1, 32, '\p{^Is_General_Category: po}', ""); +Expect(1, 32, '\P{Is_General_Category: po}', ""); +Expect(0, 32, '\P{^Is_General_Category: po}', ""); +Expect(1, 35, '\p{Is_General_Category=--Po}', ""); +Expect(0, 35, '\p{^Is_General_Category=--Po}', ""); +Expect(0, 35, '\P{Is_General_Category=--Po}', ""); +Expect(1, 35, '\P{^Is_General_Category=--Po}', ""); +Expect(0, 32, '\p{Is_General_Category=--Po}', ""); +Expect(1, 32, '\p{^Is_General_Category=--Po}', ""); +Expect(1, 32, '\P{Is_General_Category=--Po}', ""); +Expect(0, 32, '\P{^Is_General_Category=--Po}', ""); +Error('\p{Is_Gc=-/a/Other Punctuation}'); +Error('\P{Is_Gc=-/a/Other Punctuation}'); +Expect(1, 35, '\p{Is_Gc=otherpunctuation}', ""); +Expect(0, 35, '\p{^Is_Gc=otherpunctuation}', ""); +Expect(0, 35, '\P{Is_Gc=otherpunctuation}', ""); +Expect(1, 35, '\P{^Is_Gc=otherpunctuation}', ""); +Expect(0, 32, '\p{Is_Gc=otherpunctuation}', ""); +Expect(1, 32, '\p{^Is_Gc=otherpunctuation}', ""); +Expect(1, 32, '\P{Is_Gc=otherpunctuation}', ""); +Expect(0, 32, '\P{^Is_Gc=otherpunctuation}', ""); +Expect(1, 35, '\p{Is_Gc=-OTHER_Punctuation}', ""); +Expect(0, 35, '\p{^Is_Gc=-OTHER_Punctuation}', ""); +Expect(0, 35, '\P{Is_Gc=-OTHER_Punctuation}', ""); +Expect(1, 35, '\P{^Is_Gc=-OTHER_Punctuation}', ""); +Expect(0, 32, '\p{Is_Gc=-OTHER_Punctuation}', ""); +Expect(1, 32, '\p{^Is_Gc=-OTHER_Punctuation}', ""); +Expect(1, 32, '\P{Is_Gc=-OTHER_Punctuation}', ""); +Expect(0, 32, '\P{^Is_Gc=-OTHER_Punctuation}', ""); +Error('\p{Is_Category=_ po/a/}'); +Error('\P{Is_Category=_ po/a/}'); +Expect(1, 35, '\p{Is_Category=po}', ""); +Expect(0, 35, '\p{^Is_Category=po}', ""); +Expect(0, 35, '\P{Is_Category=po}', ""); +Expect(1, 35, '\P{^Is_Category=po}', ""); +Expect(0, 32, '\p{Is_Category=po}', ""); +Expect(1, 32, '\p{^Is_Category=po}', ""); +Expect(1, 32, '\P{Is_Category=po}', ""); +Expect(0, 32, '\P{^Is_Category=po}', ""); +Expect(1, 35, '\p{Is_Category=-PO}', ""); +Expect(0, 35, '\p{^Is_Category=-PO}', ""); +Expect(0, 35, '\P{Is_Category=-PO}', ""); +Expect(1, 35, '\P{^Is_Category=-PO}', ""); +Expect(0, 32, '\p{Is_Category=-PO}', ""); +Expect(1, 32, '\p{^Is_Category=-PO}', ""); +Expect(1, 32, '\P{Is_Category=-PO}', ""); +Expect(0, 32, '\P{^Is_Category=-PO}', ""); +Error('\p{General_Category=:=_ Space separator}'); +Error('\P{General_Category=:=_ Space separator}'); +Expect(1, 32, '\p{General_Category: spaceseparator}', ""); +Expect(0, 32, '\p{^General_Category: spaceseparator}', ""); +Expect(0, 32, '\P{General_Category: spaceseparator}', ""); +Expect(1, 32, '\P{^General_Category: spaceseparator}', ""); +Expect(0, 7, '\p{General_Category: spaceseparator}', ""); +Expect(1, 7, '\p{^General_Category: spaceseparator}', ""); +Expect(1, 7, '\P{General_Category: spaceseparator}', ""); +Expect(0, 7, '\P{^General_Category: spaceseparator}', ""); +Expect(1, 32, '\p{General_Category=_Space separator}', ""); +Expect(0, 32, '\p{^General_Category=_Space separator}', ""); +Expect(0, 32, '\P{General_Category=_Space separator}', ""); +Expect(1, 32, '\P{^General_Category=_Space separator}', ""); +Expect(0, 7, '\p{General_Category=_Space separator}', ""); +Expect(1, 7, '\p{^General_Category=_Space separator}', ""); +Expect(1, 7, '\P{General_Category=_Space separator}', ""); +Expect(0, 7, '\P{^General_Category=_Space separator}', ""); +Error('\p{Gc=/a/ Zs}'); +Error('\P{Gc=/a/ Zs}'); +Expect(1, 32, '\p{Gc=zs}', ""); +Expect(0, 32, '\p{^Gc=zs}', ""); +Expect(0, 32, '\P{Gc=zs}', ""); +Expect(1, 32, '\P{^Gc=zs}', ""); +Expect(0, 7, '\p{Gc=zs}', ""); +Expect(1, 7, '\p{^Gc=zs}', ""); +Expect(1, 7, '\P{Gc=zs}', ""); +Expect(0, 7, '\P{^Gc=zs}', ""); +Expect(1, 32, '\p{Gc=-zs}', ""); +Expect(0, 32, '\p{^Gc=-zs}', ""); +Expect(0, 32, '\P{Gc=-zs}', ""); +Expect(1, 32, '\P{^Gc=-zs}', ""); +Expect(0, 7, '\p{Gc=-zs}', ""); +Expect(1, 7, '\p{^Gc=-zs}', ""); +Expect(1, 7, '\P{Gc=-zs}', ""); +Expect(0, 7, '\P{^Gc=-zs}', ""); +Error('\p{Category=/a/- Space separator}'); +Error('\P{Category=/a/- Space separator}'); +Expect(1, 32, '\p{Category=spaceseparator}', ""); +Expect(0, 32, '\p{^Category=spaceseparator}', ""); +Expect(0, 32, '\P{Category=spaceseparator}', ""); +Expect(1, 32, '\P{^Category=spaceseparator}', ""); +Expect(0, 7, '\p{Category=spaceseparator}', ""); +Expect(1, 7, '\p{^Category=spaceseparator}', ""); +Expect(1, 7, '\P{Category=spaceseparator}', ""); +Expect(0, 7, '\P{^Category=spaceseparator}', ""); +Expect(1, 32, '\p{Category=-_SPACESeparator}', ""); +Expect(0, 32, '\p{^Category=-_SPACESeparator}', ""); +Expect(0, 32, '\P{Category=-_SPACESeparator}', ""); +Expect(1, 32, '\P{^Category=-_SPACESeparator}', ""); +Expect(0, 7, '\p{Category=-_SPACESeparator}', ""); +Expect(1, 7, '\p{^Category=-_SPACESeparator}', ""); +Expect(1, 7, '\P{Category=-_SPACESeparator}', ""); +Expect(0, 7, '\P{^Category=-_SPACESeparator}', ""); +Error('\p{Is_General_Category=/a/--Zs}'); +Error('\P{Is_General_Category=/a/--Zs}'); +Expect(1, 32, '\p{Is_General_Category=zs}', ""); +Expect(0, 32, '\p{^Is_General_Category=zs}', ""); +Expect(0, 32, '\P{Is_General_Category=zs}', ""); +Expect(1, 32, '\P{^Is_General_Category=zs}', ""); +Expect(0, 7, '\p{Is_General_Category=zs}', ""); +Expect(1, 7, '\p{^Is_General_Category=zs}', ""); +Expect(1, 7, '\P{Is_General_Category=zs}', ""); +Expect(0, 7, '\P{^Is_General_Category=zs}', ""); +Expect(1, 32, '\p{Is_General_Category= Zs}', ""); +Expect(0, 32, '\p{^Is_General_Category= Zs}', ""); +Expect(0, 32, '\P{Is_General_Category= Zs}', ""); +Expect(1, 32, '\P{^Is_General_Category= Zs}', ""); +Expect(0, 7, '\p{Is_General_Category= Zs}', ""); +Expect(1, 7, '\p{^Is_General_Category= Zs}', ""); +Expect(1, 7, '\P{Is_General_Category= Zs}', ""); +Expect(0, 7, '\P{^Is_General_Category= Zs}', ""); +Error('\p{Is_Gc=:= SPACE_Separator}'); +Error('\P{Is_Gc=:= SPACE_Separator}'); +Expect(1, 32, '\p{Is_Gc=spaceseparator}', ""); +Expect(0, 32, '\p{^Is_Gc=spaceseparator}', ""); +Expect(0, 32, '\P{Is_Gc=spaceseparator}', ""); +Expect(1, 32, '\P{^Is_Gc=spaceseparator}', ""); +Expect(0, 7, '\p{Is_Gc=spaceseparator}', ""); +Expect(1, 7, '\p{^Is_Gc=spaceseparator}', ""); +Expect(1, 7, '\P{Is_Gc=spaceseparator}', ""); +Expect(0, 7, '\P{^Is_Gc=spaceseparator}', ""); +Expect(1, 32, '\p{Is_Gc=--Space-Separator}', ""); +Expect(0, 32, '\p{^Is_Gc=--Space-Separator}', ""); +Expect(0, 32, '\P{Is_Gc=--Space-Separator}', ""); +Expect(1, 32, '\P{^Is_Gc=--Space-Separator}', ""); +Expect(0, 7, '\p{Is_Gc=--Space-Separator}', ""); +Expect(1, 7, '\p{^Is_Gc=--Space-Separator}', ""); +Expect(1, 7, '\P{Is_Gc=--Space-Separator}', ""); +Expect(0, 7, '\P{^Is_Gc=--Space-Separator}', ""); +Error('\p{Is_Category= Zs:=}'); +Error('\P{Is_Category= Zs:=}'); +Expect(1, 32, '\p{Is_Category: zs}', ""); +Expect(0, 32, '\p{^Is_Category: zs}', ""); +Expect(0, 32, '\P{Is_Category: zs}', ""); +Expect(1, 32, '\P{^Is_Category: zs}', ""); +Expect(0, 7, '\p{Is_Category: zs}', ""); +Expect(1, 7, '\p{^Is_Category: zs}', ""); +Expect(1, 7, '\P{Is_Category: zs}', ""); +Expect(0, 7, '\P{^Is_Category: zs}', ""); +Expect(1, 32, '\p{Is_Category= Zs}', ""); +Expect(0, 32, '\p{^Is_Category= Zs}', ""); +Expect(0, 32, '\P{Is_Category= Zs}', ""); +Expect(1, 32, '\P{^Is_Category= Zs}', ""); +Expect(0, 7, '\p{Is_Category= Zs}', ""); +Expect(1, 7, '\p{^Is_Category= Zs}', ""); +Expect(1, 7, '\P{Is_Category= Zs}', ""); +Expect(0, 7, '\P{^Is_Category= Zs}', ""); +Error('\p{General_Category= Other number/a/}'); +Error('\P{General_Category= Other number/a/}'); +Expect(1, 2553, '\p{General_Category=othernumber}', ""); +Expect(0, 2553, '\p{^General_Category=othernumber}', ""); +Expect(0, 2553, '\P{General_Category=othernumber}', ""); +Expect(1, 2553, '\P{^General_Category=othernumber}', ""); +Expect(0, 7, '\p{General_Category=othernumber}', ""); +Expect(1, 7, '\p{^General_Category=othernumber}', ""); +Expect(1, 7, '\P{General_Category=othernumber}', ""); +Expect(0, 7, '\P{^General_Category=othernumber}', ""); +Expect(1, 2553, '\p{General_Category: Other Number}', ""); +Expect(0, 2553, '\p{^General_Category: Other Number}', ""); +Expect(0, 2553, '\P{General_Category: Other Number}', ""); +Expect(1, 2553, '\P{^General_Category: Other Number}', ""); +Expect(0, 7, '\p{General_Category: Other Number}', ""); +Expect(1, 7, '\p{^General_Category: Other Number}', ""); +Expect(1, 7, '\P{General_Category: Other Number}', ""); +Expect(0, 7, '\P{^General_Category: Other Number}', ""); +Error('\p{Gc= /a/NO}'); +Error('\P{Gc= /a/NO}'); +Expect(1, 2553, '\p{Gc=no}', ""); +Expect(0, 2553, '\p{^Gc=no}', ""); +Expect(0, 2553, '\P{Gc=no}', ""); +Expect(1, 2553, '\P{^Gc=no}', ""); +Expect(0, 7, '\p{Gc=no}', ""); +Expect(1, 7, '\p{^Gc=no}', ""); +Expect(1, 7, '\P{Gc=no}', ""); +Expect(0, 7, '\P{^Gc=no}', ""); +Expect(1, 2553, '\p{Gc= no}', ""); +Expect(0, 2553, '\p{^Gc= no}', ""); +Expect(0, 2553, '\P{Gc= no}', ""); +Expect(1, 2553, '\P{^Gc= no}', ""); +Expect(0, 7, '\p{Gc= no}', ""); +Expect(1, 7, '\p{^Gc= no}', ""); +Expect(1, 7, '\P{Gc= no}', ""); +Expect(0, 7, '\P{^Gc= no}', ""); +Error('\p{Category=/a/_Other-number}'); +Error('\P{Category=/a/_Other-number}'); +Expect(1, 2553, '\p{Category=othernumber}', ""); +Expect(0, 2553, '\p{^Category=othernumber}', ""); +Expect(0, 2553, '\P{Category=othernumber}', ""); +Expect(1, 2553, '\P{^Category=othernumber}', ""); +Expect(0, 7, '\p{Category=othernumber}', ""); +Expect(1, 7, '\p{^Category=othernumber}', ""); +Expect(1, 7, '\P{Category=othernumber}', ""); +Expect(0, 7, '\P{^Category=othernumber}', ""); +Expect(1, 2553, '\p{Category= other number}', ""); +Expect(0, 2553, '\p{^Category= other number}', ""); +Expect(0, 2553, '\P{Category= other number}', ""); +Expect(1, 2553, '\P{^Category= other number}', ""); +Expect(0, 7, '\p{Category= other number}', ""); +Expect(1, 7, '\p{^Category= other number}', ""); +Expect(1, 7, '\P{Category= other number}', ""); +Expect(0, 7, '\P{^Category= other number}', ""); +Error('\p{Is_General_Category:- NO/a/}'); +Error('\P{Is_General_Category:- NO/a/}'); +Expect(1, 2553, '\p{Is_General_Category=no}', ""); +Expect(0, 2553, '\p{^Is_General_Category=no}', ""); +Expect(0, 2553, '\P{Is_General_Category=no}', ""); +Expect(1, 2553, '\P{^Is_General_Category=no}', ""); +Expect(0, 7, '\p{Is_General_Category=no}', ""); +Expect(1, 7, '\p{^Is_General_Category=no}', ""); +Expect(1, 7, '\P{Is_General_Category=no}', ""); +Expect(0, 7, '\P{^Is_General_Category=no}', ""); +Expect(1, 2553, '\p{Is_General_Category= No}', ""); +Expect(0, 2553, '\p{^Is_General_Category= No}', ""); +Expect(0, 2553, '\P{Is_General_Category= No}', ""); +Expect(1, 2553, '\P{^Is_General_Category= No}', ""); +Expect(0, 7, '\p{Is_General_Category= No}', ""); +Expect(1, 7, '\p{^Is_General_Category= No}', ""); +Expect(1, 7, '\P{Is_General_Category= No}', ""); +Expect(0, 7, '\P{^Is_General_Category= No}', ""); +Error('\p{Is_Gc: /a/Other_Number}'); +Error('\P{Is_Gc: /a/Other_Number}'); +Expect(1, 2553, '\p{Is_Gc=othernumber}', ""); +Expect(0, 2553, '\p{^Is_Gc=othernumber}', ""); +Expect(0, 2553, '\P{Is_Gc=othernumber}', ""); +Expect(1, 2553, '\P{^Is_Gc=othernumber}', ""); +Expect(0, 7, '\p{Is_Gc=othernumber}', ""); +Expect(1, 7, '\p{^Is_Gc=othernumber}', ""); +Expect(1, 7, '\P{Is_Gc=othernumber}', ""); +Expect(0, 7, '\P{^Is_Gc=othernumber}', ""); +Expect(1, 2553, '\p{Is_Gc=other Number}', ""); +Expect(0, 2553, '\p{^Is_Gc=other Number}', ""); +Expect(0, 2553, '\P{Is_Gc=other Number}', ""); +Expect(1, 2553, '\P{^Is_Gc=other Number}', ""); +Expect(0, 7, '\p{Is_Gc=other Number}', ""); +Expect(1, 7, '\p{^Is_Gc=other Number}', ""); +Expect(1, 7, '\P{Is_Gc=other Number}', ""); +Expect(0, 7, '\P{^Is_Gc=other Number}', ""); +Error('\p{Is_Category= :=NO}'); +Error('\P{Is_Category= :=NO}'); +Expect(1, 2553, '\p{Is_Category=no}', ""); +Expect(0, 2553, '\p{^Is_Category=no}', ""); +Expect(0, 2553, '\P{Is_Category=no}', ""); +Expect(1, 2553, '\P{^Is_Category=no}', ""); +Expect(0, 7, '\p{Is_Category=no}', ""); +Expect(1, 7, '\p{^Is_Category=no}', ""); +Expect(1, 7, '\P{Is_Category=no}', ""); +Expect(0, 7, '\P{^Is_Category=no}', ""); +Expect(1, 2553, '\p{Is_Category=- NO}', ""); +Expect(0, 2553, '\p{^Is_Category=- NO}', ""); +Expect(0, 2553, '\P{Is_Category=- NO}', ""); +Expect(1, 2553, '\P{^Is_Category=- NO}', ""); +Expect(0, 7, '\p{Is_Category=- NO}', ""); +Expect(1, 7, '\p{^Is_Category=- NO}', ""); +Expect(1, 7, '\P{Is_Category=- NO}', ""); +Expect(0, 7, '\P{^Is_Category=- NO}', ""); +Error('\p{General_Category=:= Mark}'); +Error('\P{General_Category=:= Mark}'); +Expect(1, 879, '\p{General_Category=mark}', ""); +Expect(0, 879, '\p{^General_Category=mark}', ""); +Expect(0, 879, '\P{General_Category=mark}', ""); +Expect(1, 879, '\P{^General_Category=mark}', ""); +Expect(0, 767, '\p{General_Category=mark}', ""); +Expect(1, 767, '\p{^General_Category=mark}', ""); +Expect(1, 767, '\P{General_Category=mark}', ""); +Expect(0, 767, '\P{^General_Category=mark}', ""); +Expect(1, 879, '\p{General_Category= _MARK}', ""); +Expect(0, 879, '\p{^General_Category= _MARK}', ""); +Expect(0, 879, '\P{General_Category= _MARK}', ""); +Expect(1, 879, '\P{^General_Category= _MARK}', ""); +Expect(0, 767, '\p{General_Category= _MARK}', ""); +Expect(1, 767, '\p{^General_Category= _MARK}', ""); +Expect(1, 767, '\P{General_Category= _MARK}', ""); +Expect(0, 767, '\P{^General_Category= _MARK}', ""); +Error('\p{Gc=-m/a/}'); +Error('\P{Gc=-m/a/}'); +Expect(1, 879, '\p{Gc=m}', ""); +Expect(0, 879, '\p{^Gc=m}', ""); +Expect(0, 879, '\P{Gc=m}', ""); +Expect(1, 879, '\P{^Gc=m}', ""); +Expect(0, 767, '\p{Gc=m}', ""); +Expect(1, 767, '\p{^Gc=m}', ""); +Expect(1, 767, '\P{Gc=m}', ""); +Expect(0, 767, '\P{^Gc=m}', ""); +Expect(1, 879, '\p{Gc= -M}', ""); +Expect(0, 879, '\p{^Gc= -M}', ""); +Expect(0, 879, '\P{Gc= -M}', ""); +Expect(1, 879, '\P{^Gc= -M}', ""); +Expect(0, 767, '\p{Gc= -M}', ""); +Expect(1, 767, '\p{^Gc= -M}', ""); +Expect(1, 767, '\P{Gc= -M}', ""); +Expect(0, 767, '\P{^Gc= -M}', ""); +Error('\p{Category: Mark:=}'); +Error('\P{Category: Mark:=}'); +Expect(1, 879, '\p{Category=mark}', ""); +Expect(0, 879, '\p{^Category=mark}', ""); +Expect(0, 879, '\P{Category=mark}', ""); +Expect(1, 879, '\P{^Category=mark}', ""); +Expect(0, 767, '\p{Category=mark}', ""); +Expect(1, 767, '\p{^Category=mark}', ""); +Expect(1, 767, '\P{Category=mark}', ""); +Expect(0, 767, '\P{^Category=mark}', ""); +Expect(1, 879, '\p{Category= mark}', ""); +Expect(0, 879, '\p{^Category= mark}', ""); +Expect(0, 879, '\P{Category= mark}', ""); +Expect(1, 879, '\P{^Category= mark}', ""); +Expect(0, 767, '\p{Category= mark}', ""); +Expect(1, 767, '\p{^Category= mark}', ""); +Expect(1, 767, '\P{Category= mark}', ""); +Expect(0, 767, '\P{^Category= mark}', ""); +Error('\p{Is_General_Category= _M:=}'); +Error('\P{Is_General_Category= _M:=}'); +Expect(1, 879, '\p{Is_General_Category=m}', ""); +Expect(0, 879, '\p{^Is_General_Category=m}', ""); +Expect(0, 879, '\P{Is_General_Category=m}', ""); +Expect(1, 879, '\P{^Is_General_Category=m}', ""); +Expect(0, 767, '\p{Is_General_Category=m}', ""); +Expect(1, 767, '\p{^Is_General_Category=m}', ""); +Expect(1, 767, '\P{Is_General_Category=m}', ""); +Expect(0, 767, '\P{^Is_General_Category=m}', ""); +Expect(1, 879, '\p{Is_General_Category= M}', ""); +Expect(0, 879, '\p{^Is_General_Category= M}', ""); +Expect(0, 879, '\P{Is_General_Category= M}', ""); +Expect(1, 879, '\P{^Is_General_Category= M}', ""); +Expect(0, 767, '\p{Is_General_Category= M}', ""); +Expect(1, 767, '\p{^Is_General_Category= M}', ""); +Expect(1, 767, '\P{Is_General_Category= M}', ""); +Expect(0, 767, '\P{^Is_General_Category= M}', ""); +Error('\p{Is_Gc=/a/ Mark}'); +Error('\P{Is_Gc=/a/ Mark}'); +Expect(1, 879, '\p{Is_Gc=mark}', ""); +Expect(0, 879, '\p{^Is_Gc=mark}', ""); +Expect(0, 879, '\P{Is_Gc=mark}', ""); +Expect(1, 879, '\P{^Is_Gc=mark}', ""); +Expect(0, 767, '\p{Is_Gc=mark}', ""); +Expect(1, 767, '\p{^Is_Gc=mark}', ""); +Expect(1, 767, '\P{Is_Gc=mark}', ""); +Expect(0, 767, '\P{^Is_Gc=mark}', ""); +Expect(1, 879, '\p{Is_Gc= Mark}', ""); +Expect(0, 879, '\p{^Is_Gc= Mark}', ""); +Expect(0, 879, '\P{Is_Gc= Mark}', ""); +Expect(1, 879, '\P{^Is_Gc= Mark}', ""); +Expect(0, 767, '\p{Is_Gc= Mark}', ""); +Expect(1, 767, '\p{^Is_Gc= Mark}', ""); +Expect(1, 767, '\P{Is_Gc= Mark}', ""); +Expect(0, 767, '\P{^Is_Gc= Mark}', ""); +Error('\p{Is_Category: M/a/}'); +Error('\P{Is_Category: M/a/}'); +Expect(1, 879, '\p{Is_Category=m}', ""); +Expect(0, 879, '\p{^Is_Category=m}', ""); +Expect(0, 879, '\P{Is_Category=m}', ""); +Expect(1, 879, '\P{^Is_Category=m}', ""); +Expect(0, 767, '\p{Is_Category=m}', ""); +Expect(1, 767, '\p{^Is_Category=m}', ""); +Expect(1, 767, '\P{Is_Category=m}', ""); +Expect(0, 767, '\P{^Is_Category=m}', ""); +Expect(1, 879, '\p{Is_Category= M}', ""); +Expect(0, 879, '\p{^Is_Category= M}', ""); +Expect(0, 879, '\P{Is_Category= M}', ""); +Expect(1, 879, '\P{^Is_Category= M}', ""); +Expect(0, 767, '\p{Is_Category= M}', ""); +Expect(1, 767, '\p{^Is_Category= M}', ""); +Expect(1, 767, '\P{Is_Category= M}', ""); +Expect(0, 767, '\P{^Is_Category= M}', ""); +Error('\p{General_Category= other:=}'); +Error('\P{General_Category= other:=}'); +Expect(1, 7, '\p{General_Category=other}', ""); +Expect(0, 7, '\p{^General_Category=other}', ""); +Expect(0, 7, '\P{General_Category=other}', ""); +Expect(1, 7, '\P{^General_Category=other}', ""); +Expect(0, 126, '\p{General_Category=other}', ""); +Expect(1, 126, '\p{^General_Category=other}', ""); +Expect(1, 126, '\P{General_Category=other}', ""); +Expect(0, 126, '\P{^General_Category=other}', ""); +Expect(1, 7, '\p{General_Category= OTHER}', ""); +Expect(0, 7, '\p{^General_Category= OTHER}', ""); +Expect(0, 7, '\P{General_Category= OTHER}', ""); +Expect(1, 7, '\P{^General_Category= OTHER}', ""); +Expect(0, 126, '\p{General_Category= OTHER}', ""); +Expect(1, 126, '\p{^General_Category= OTHER}', ""); +Expect(1, 126, '\P{General_Category= OTHER}', ""); +Expect(0, 126, '\P{^General_Category= OTHER}', ""); +Error('\p{Gc=:=__C}'); +Error('\P{Gc=:=__C}'); +Expect(1, 7, '\p{Gc=c}', ""); +Expect(0, 7, '\p{^Gc=c}', ""); +Expect(0, 7, '\P{Gc=c}', ""); +Expect(1, 7, '\P{^Gc=c}', ""); +Expect(0, 126, '\p{Gc=c}', ""); +Expect(1, 126, '\p{^Gc=c}', ""); +Expect(1, 126, '\P{Gc=c}', ""); +Expect(0, 126, '\P{^Gc=c}', ""); +Expect(1, 7, '\p{Gc=-c}', ""); +Expect(0, 7, '\p{^Gc=-c}', ""); +Expect(0, 7, '\P{Gc=-c}', ""); +Expect(1, 7, '\P{^Gc=-c}', ""); +Expect(0, 126, '\p{Gc=-c}', ""); +Expect(1, 126, '\p{^Gc=-c}', ""); +Expect(1, 126, '\P{Gc=-c}', ""); +Expect(0, 126, '\P{^Gc=-c}', ""); +Error('\p{Category=/a/__Other}'); +Error('\P{Category=/a/__Other}'); +Expect(1, 7, '\p{Category=other}', ""); +Expect(0, 7, '\p{^Category=other}', ""); +Expect(0, 7, '\P{Category=other}', ""); +Expect(1, 7, '\P{^Category=other}', ""); +Expect(0, 126, '\p{Category=other}', ""); +Expect(1, 126, '\p{^Category=other}', ""); +Expect(1, 126, '\P{Category=other}', ""); +Expect(0, 126, '\P{^Category=other}', ""); +Expect(1, 7, '\p{Category= -Other}', ""); +Expect(0, 7, '\p{^Category= -Other}', ""); +Expect(0, 7, '\P{Category= -Other}', ""); +Expect(1, 7, '\P{^Category= -Other}', ""); +Expect(0, 126, '\p{Category= -Other}', ""); +Expect(1, 126, '\p{^Category= -Other}', ""); +Expect(1, 126, '\P{Category= -Other}', ""); +Expect(0, 126, '\P{^Category= -Other}', ""); +Error('\p{Is_General_Category=/a/__C}'); +Error('\P{Is_General_Category=/a/__C}'); +Expect(1, 7, '\p{Is_General_Category=c}', ""); +Expect(0, 7, '\p{^Is_General_Category=c}', ""); +Expect(0, 7, '\P{Is_General_Category=c}', ""); +Expect(1, 7, '\P{^Is_General_Category=c}', ""); +Expect(0, 126, '\p{Is_General_Category=c}', ""); +Expect(1, 126, '\p{^Is_General_Category=c}', ""); +Expect(1, 126, '\P{Is_General_Category=c}', ""); +Expect(0, 126, '\P{^Is_General_Category=c}', ""); +Expect(1, 7, '\p{Is_General_Category= -c}', ""); +Expect(0, 7, '\p{^Is_General_Category= -c}', ""); +Expect(0, 7, '\P{Is_General_Category= -c}', ""); +Expect(1, 7, '\P{^Is_General_Category= -c}', ""); +Expect(0, 126, '\p{Is_General_Category= -c}', ""); +Expect(1, 126, '\p{^Is_General_Category= -c}', ""); +Expect(1, 126, '\P{Is_General_Category= -c}', ""); +Expect(0, 126, '\P{^Is_General_Category= -c}', ""); +Error('\p{Is_Gc= -Other/a/}'); +Error('\P{Is_Gc= -Other/a/}'); +Expect(1, 7, '\p{Is_Gc=other}', ""); +Expect(0, 7, '\p{^Is_Gc=other}', ""); +Expect(0, 7, '\P{Is_Gc=other}', ""); +Expect(1, 7, '\P{^Is_Gc=other}', ""); +Expect(0, 126, '\p{Is_Gc=other}', ""); +Expect(1, 126, '\p{^Is_Gc=other}', ""); +Expect(1, 126, '\P{Is_Gc=other}', ""); +Expect(0, 126, '\P{^Is_Gc=other}', ""); +Error('\p{Is_Category=-C/a/}'); +Error('\P{Is_Category=-C/a/}'); +Expect(1, 7, '\p{Is_Category=c}', ""); +Expect(0, 7, '\p{^Is_Category=c}', ""); +Expect(0, 7, '\P{Is_Category=c}', ""); +Expect(1, 7, '\P{^Is_Category=c}', ""); +Expect(0, 126, '\p{Is_Category=c}', ""); +Expect(1, 126, '\p{^Is_Category=c}', ""); +Expect(1, 126, '\P{Is_Category=c}', ""); +Expect(0, 126, '\P{^Is_Category=c}', ""); +Expect(1, 7, '\p{Is_Category= C}', ""); +Expect(0, 7, '\p{^Is_Category= C}', ""); +Expect(0, 7, '\P{Is_Category= C}', ""); +Expect(1, 7, '\P{^Is_Category= C}', ""); +Expect(0, 126, '\p{Is_Category= C}', ""); +Expect(1, 126, '\p{^Is_Category= C}', ""); +Expect(1, 126, '\P{Is_Category= C}', ""); +Expect(0, 126, '\P{^Is_Category= C}', ""); +Error('\p{General_Category=_:=Enclosing MARK}'); +Error('\P{General_Category=_:=Enclosing MARK}'); +Expect(1, 1161, '\p{General_Category=enclosingmark}', ""); +Expect(0, 1161, '\p{^General_Category=enclosingmark}', ""); +Expect(0, 1161, '\P{General_Category=enclosingmark}', ""); +Expect(1, 1161, '\P{^General_Category=enclosingmark}', ""); +Expect(0, 1159, '\p{General_Category=enclosingmark}', ""); +Expect(1, 1159, '\p{^General_Category=enclosingmark}', ""); +Expect(1, 1159, '\P{General_Category=enclosingmark}', ""); +Expect(0, 1159, '\P{^General_Category=enclosingmark}', ""); +Expect(1, 1161, '\p{General_Category= Enclosing_MARK}', ""); +Expect(0, 1161, '\p{^General_Category= Enclosing_MARK}', ""); +Expect(0, 1161, '\P{General_Category= Enclosing_MARK}', ""); +Expect(1, 1161, '\P{^General_Category= Enclosing_MARK}', ""); +Expect(0, 1159, '\p{General_Category= Enclosing_MARK}', ""); +Expect(1, 1159, '\p{^General_Category= Enclosing_MARK}', ""); +Expect(1, 1159, '\P{General_Category= Enclosing_MARK}', ""); +Expect(0, 1159, '\P{^General_Category= Enclosing_MARK}', ""); +Error('\p{Gc=/a/ Me}'); +Error('\P{Gc=/a/ Me}'); +Expect(1, 1161, '\p{Gc=me}', ""); +Expect(0, 1161, '\p{^Gc=me}', ""); +Expect(0, 1161, '\P{Gc=me}', ""); +Expect(1, 1161, '\P{^Gc=me}', ""); +Expect(0, 1159, '\p{Gc=me}', ""); +Expect(1, 1159, '\p{^Gc=me}', ""); +Expect(1, 1159, '\P{Gc=me}', ""); +Expect(0, 1159, '\P{^Gc=me}', ""); +Expect(1, 1161, '\p{Gc= ME}', ""); +Expect(0, 1161, '\p{^Gc= ME}', ""); +Expect(0, 1161, '\P{Gc= ME}', ""); +Expect(1, 1161, '\P{^Gc= ME}', ""); +Expect(0, 1159, '\p{Gc= ME}', ""); +Expect(1, 1159, '\p{^Gc= ME}', ""); +Expect(1, 1159, '\P{Gc= ME}', ""); +Expect(0, 1159, '\P{^Gc= ME}', ""); +Error('\p{Category=:=enclosing_mark}'); +Error('\P{Category=:=enclosing_mark}'); +Expect(1, 1161, '\p{Category=enclosingmark}', ""); +Expect(0, 1161, '\p{^Category=enclosingmark}', ""); +Expect(0, 1161, '\P{Category=enclosingmark}', ""); +Expect(1, 1161, '\P{^Category=enclosingmark}', ""); +Expect(0, 1159, '\p{Category=enclosingmark}', ""); +Expect(1, 1159, '\p{^Category=enclosingmark}', ""); +Expect(1, 1159, '\P{Category=enclosingmark}', ""); +Expect(0, 1159, '\P{^Category=enclosingmark}', ""); +Expect(1, 1161, '\p{Category= -EnclosingMark}', ""); +Expect(0, 1161, '\p{^Category= -EnclosingMark}', ""); +Expect(0, 1161, '\P{Category= -EnclosingMark}', ""); +Expect(1, 1161, '\P{^Category= -EnclosingMark}', ""); +Expect(0, 1159, '\p{Category= -EnclosingMark}', ""); +Expect(1, 1159, '\p{^Category= -EnclosingMark}', ""); +Expect(1, 1159, '\P{Category= -EnclosingMark}', ""); +Expect(0, 1159, '\P{^Category= -EnclosingMark}', ""); +Error('\p{Is_General_Category=/a/ Me}'); +Error('\P{Is_General_Category=/a/ Me}'); +Expect(1, 1161, '\p{Is_General_Category=me}', ""); +Expect(0, 1161, '\p{^Is_General_Category=me}', ""); +Expect(0, 1161, '\P{Is_General_Category=me}', ""); +Expect(1, 1161, '\P{^Is_General_Category=me}', ""); +Expect(0, 1159, '\p{Is_General_Category=me}', ""); +Expect(1, 1159, '\p{^Is_General_Category=me}', ""); +Expect(1, 1159, '\P{Is_General_Category=me}', ""); +Expect(0, 1159, '\P{^Is_General_Category=me}', ""); +Expect(1, 1161, '\p{Is_General_Category:-me}', ""); +Expect(0, 1161, '\p{^Is_General_Category:-me}', ""); +Expect(0, 1161, '\P{Is_General_Category:-me}', ""); +Expect(1, 1161, '\P{^Is_General_Category:-me}', ""); +Expect(0, 1159, '\p{Is_General_Category:-me}', ""); +Expect(1, 1159, '\p{^Is_General_Category:-me}', ""); +Expect(1, 1159, '\P{Is_General_Category:-me}', ""); +Expect(0, 1159, '\P{^Is_General_Category:-me}', ""); +Error('\p{Is_Gc=:=_Enclosing mark}'); +Error('\P{Is_Gc=:=_Enclosing mark}'); +Expect(1, 1161, '\p{Is_Gc=enclosingmark}', ""); +Expect(0, 1161, '\p{^Is_Gc=enclosingmark}', ""); +Expect(0, 1161, '\P{Is_Gc=enclosingmark}', ""); +Expect(1, 1161, '\P{^Is_Gc=enclosingmark}', ""); +Expect(0, 1159, '\p{Is_Gc=enclosingmark}', ""); +Expect(1, 1159, '\p{^Is_Gc=enclosingmark}', ""); +Expect(1, 1159, '\P{Is_Gc=enclosingmark}', ""); +Expect(0, 1159, '\P{^Is_Gc=enclosingmark}', ""); +Expect(1, 1161, '\p{Is_Gc= Enclosing-Mark}', ""); +Expect(0, 1161, '\p{^Is_Gc= Enclosing-Mark}', ""); +Expect(0, 1161, '\P{Is_Gc= Enclosing-Mark}', ""); +Expect(1, 1161, '\P{^Is_Gc= Enclosing-Mark}', ""); +Expect(0, 1159, '\p{Is_Gc= Enclosing-Mark}', ""); +Expect(1, 1159, '\p{^Is_Gc= Enclosing-Mark}', ""); +Expect(1, 1159, '\P{Is_Gc= Enclosing-Mark}', ""); +Expect(0, 1159, '\P{^Is_Gc= Enclosing-Mark}', ""); +Error('\p{Is_Category=:= _Me}'); +Error('\P{Is_Category=:= _Me}'); +Expect(1, 1161, '\p{Is_Category=me}', ""); +Expect(0, 1161, '\p{^Is_Category=me}', ""); +Expect(0, 1161, '\P{Is_Category=me}', ""); +Expect(1, 1161, '\P{^Is_Category=me}', ""); +Expect(0, 1159, '\p{Is_Category=me}', ""); +Expect(1, 1159, '\p{^Is_Category=me}', ""); +Expect(1, 1159, '\P{Is_Category=me}', ""); +Expect(0, 1159, '\P{^Is_Category=me}', ""); +Expect(1, 1161, '\p{Is_Category=_ ME}', ""); +Expect(0, 1161, '\p{^Is_Category=_ ME}', ""); +Expect(0, 1161, '\P{Is_Category=_ ME}', ""); +Expect(1, 1161, '\P{^Is_Category=_ ME}', ""); +Expect(0, 1159, '\p{Is_Category=_ ME}', ""); +Expect(1, 1159, '\p{^Is_Category=_ ME}', ""); +Expect(1, 1159, '\P{Is_Category=_ ME}', ""); +Expect(0, 1159, '\P{^Is_Category=_ ME}', ""); +Error('\p{General_Category=_-Titlecase_letter:=}'); +Error('\P{General_Category=_-Titlecase_letter:=}'); +Expect(1, 453, '\p{General_Category=titlecaseletter}', ""); +Expect(0, 453, '\p{^General_Category=titlecaseletter}', ""); +Expect(0, 453, '\P{General_Category=titlecaseletter}', ""); +Expect(1, 453, '\P{^General_Category=titlecaseletter}', ""); +Expect(0, 452, '\p{General_Category=titlecaseletter}', ""); +Expect(1, 452, '\p{^General_Category=titlecaseletter}', ""); +Expect(1, 452, '\P{General_Category=titlecaseletter}', ""); +Expect(0, 452, '\P{^General_Category=titlecaseletter}', ""); +Expect(1, 453, '\p{General_Category= titlecase-LETTER}', ""); +Expect(0, 453, '\p{^General_Category= titlecase-LETTER}', ""); +Expect(0, 453, '\P{General_Category= titlecase-LETTER}', ""); +Expect(1, 453, '\P{^General_Category= titlecase-LETTER}', ""); +Expect(0, 452, '\p{General_Category= titlecase-LETTER}', ""); +Expect(1, 452, '\p{^General_Category= titlecase-LETTER}', ""); +Expect(1, 452, '\P{General_Category= titlecase-LETTER}', ""); +Expect(0, 452, '\P{^General_Category= titlecase-LETTER}', ""); +Error('\p{Gc= :=Lt}'); +Error('\P{Gc= :=Lt}'); +Expect(1, 453, '\p{Gc=lt}', ""); +Expect(0, 453, '\p{^Gc=lt}', ""); +Expect(0, 453, '\P{Gc=lt}', ""); +Expect(1, 453, '\P{^Gc=lt}', ""); +Expect(0, 452, '\p{Gc=lt}', ""); +Expect(1, 452, '\p{^Gc=lt}', ""); +Expect(1, 452, '\P{Gc=lt}', ""); +Expect(0, 452, '\P{^Gc=lt}', ""); +Expect(1, 453, '\p{Gc=-_Lt}', ""); +Expect(0, 453, '\p{^Gc=-_Lt}', ""); +Expect(0, 453, '\P{Gc=-_Lt}', ""); +Expect(1, 453, '\P{^Gc=-_Lt}', ""); +Expect(0, 452, '\p{Gc=-_Lt}', ""); +Expect(1, 452, '\p{^Gc=-_Lt}', ""); +Expect(1, 452, '\P{Gc=-_Lt}', ""); +Expect(0, 452, '\P{^Gc=-_Lt}', ""); +Error('\p{Category= -titlecase_letter:=}'); +Error('\P{Category= -titlecase_letter:=}'); +Expect(1, 453, '\p{Category=titlecaseletter}', ""); +Expect(0, 453, '\p{^Category=titlecaseletter}', ""); +Expect(0, 453, '\P{Category=titlecaseletter}', ""); +Expect(1, 453, '\P{^Category=titlecaseletter}', ""); +Expect(0, 452, '\p{Category=titlecaseletter}', ""); +Expect(1, 452, '\p{^Category=titlecaseletter}', ""); +Expect(1, 452, '\P{Category=titlecaseletter}', ""); +Expect(0, 452, '\P{^Category=titlecaseletter}', ""); +Expect(1, 453, '\p{Category= Titlecase-Letter}', ""); +Expect(0, 453, '\p{^Category= Titlecase-Letter}', ""); +Expect(0, 453, '\P{Category= Titlecase-Letter}', ""); +Expect(1, 453, '\P{^Category= Titlecase-Letter}', ""); +Expect(0, 452, '\p{Category= Titlecase-Letter}', ""); +Expect(1, 452, '\p{^Category= Titlecase-Letter}', ""); +Expect(1, 452, '\P{Category= Titlecase-Letter}', ""); +Expect(0, 452, '\P{^Category= Titlecase-Letter}', ""); +Error('\p{Is_General_Category=-_lt/a/}'); +Error('\P{Is_General_Category=-_lt/a/}'); +Expect(1, 453, '\p{Is_General_Category=lt}', ""); +Expect(0, 453, '\p{^Is_General_Category=lt}', ""); +Expect(0, 453, '\P{Is_General_Category=lt}', ""); +Expect(1, 453, '\P{^Is_General_Category=lt}', ""); +Expect(0, 452, '\p{Is_General_Category=lt}', ""); +Expect(1, 452, '\p{^Is_General_Category=lt}', ""); +Expect(1, 452, '\P{Is_General_Category=lt}', ""); +Expect(0, 452, '\P{^Is_General_Category=lt}', ""); +Expect(1, 453, '\p{Is_General_Category= Lt}', ""); +Expect(0, 453, '\p{^Is_General_Category= Lt}', ""); +Expect(0, 453, '\P{Is_General_Category= Lt}', ""); +Expect(1, 453, '\P{^Is_General_Category= Lt}', ""); +Expect(0, 452, '\p{Is_General_Category= Lt}', ""); +Expect(1, 452, '\p{^Is_General_Category= Lt}', ""); +Expect(1, 452, '\P{Is_General_Category= Lt}', ""); +Expect(0, 452, '\P{^Is_General_Category= Lt}', ""); +Error('\p{Is_Gc= -Titlecase:=Letter}'); +Error('\P{Is_Gc= -Titlecase:=Letter}'); +Expect(1, 453, '\p{Is_Gc=titlecaseletter}', ""); +Expect(0, 453, '\p{^Is_Gc=titlecaseletter}', ""); +Expect(0, 453, '\P{Is_Gc=titlecaseletter}', ""); +Expect(1, 453, '\P{^Is_Gc=titlecaseletter}', ""); +Expect(0, 452, '\p{Is_Gc=titlecaseletter}', ""); +Expect(1, 452, '\p{^Is_Gc=titlecaseletter}', ""); +Expect(1, 452, '\P{Is_Gc=titlecaseletter}', ""); +Expect(0, 452, '\P{^Is_Gc=titlecaseletter}', ""); +Expect(1, 453, '\p{Is_Gc= TITLECASE-Letter}', ""); +Expect(0, 453, '\p{^Is_Gc= TITLECASE-Letter}', ""); +Expect(0, 453, '\P{Is_Gc= TITLECASE-Letter}', ""); +Expect(1, 453, '\P{^Is_Gc= TITLECASE-Letter}', ""); +Expect(0, 452, '\p{Is_Gc= TITLECASE-Letter}', ""); +Expect(1, 452, '\p{^Is_Gc= TITLECASE-Letter}', ""); +Expect(1, 452, '\P{Is_Gc= TITLECASE-Letter}', ""); +Expect(0, 452, '\P{^Is_Gc= TITLECASE-Letter}', ""); +Error('\p{Is_Category=_-Lt/a/}'); +Error('\P{Is_Category=_-Lt/a/}'); +Expect(1, 453, '\p{Is_Category=lt}', ""); +Expect(0, 453, '\p{^Is_Category=lt}', ""); +Expect(0, 453, '\P{Is_Category=lt}', ""); +Expect(1, 453, '\P{^Is_Category=lt}', ""); +Expect(0, 452, '\p{Is_Category=lt}', ""); +Expect(1, 452, '\p{^Is_Category=lt}', ""); +Expect(1, 452, '\P{Is_Category=lt}', ""); +Expect(0, 452, '\P{^Is_Category=lt}', ""); +Expect(1, 453, '\p{Is_Category= Lt}', ""); +Expect(0, 453, '\p{^Is_Category= Lt}', ""); +Expect(0, 453, '\P{Is_Category= Lt}', ""); +Expect(1, 453, '\P{^Is_Category= Lt}', ""); +Expect(0, 452, '\p{Is_Category= Lt}', ""); +Expect(1, 452, '\p{^Is_Category= Lt}', ""); +Expect(1, 452, '\P{Is_Category= Lt}', ""); +Expect(0, 452, '\P{^Is_Category= Lt}', ""); +Error('\p{General_Category=/a/Punctuation}'); +Error('\P{General_Category=/a/Punctuation}'); +Expect(1, 35, '\p{General_Category=punctuation}', ""); +Expect(0, 35, '\p{^General_Category=punctuation}', ""); +Expect(0, 35, '\P{General_Category=punctuation}', ""); +Expect(1, 35, '\P{^General_Category=punctuation}', ""); +Expect(0, 32, '\p{General_Category=punctuation}', ""); +Expect(1, 32, '\p{^General_Category=punctuation}', ""); +Expect(1, 32, '\P{General_Category=punctuation}', ""); +Expect(0, 32, '\P{^General_Category=punctuation}', ""); +Expect(1, 35, '\p{General_Category=-PUNCTUATION}', ""); +Expect(0, 35, '\p{^General_Category=-PUNCTUATION}', ""); +Expect(0, 35, '\P{General_Category=-PUNCTUATION}', ""); +Expect(1, 35, '\P{^General_Category=-PUNCTUATION}', ""); +Expect(0, 32, '\p{General_Category=-PUNCTUATION}', ""); +Expect(1, 32, '\p{^General_Category=-PUNCTUATION}', ""); +Expect(1, 32, '\P{General_Category=-PUNCTUATION}', ""); +Expect(0, 32, '\P{^General_Category=-PUNCTUATION}', ""); +Error('\p{Gc= P:=}'); +Error('\P{Gc= P:=}'); +Expect(1, 35, '\p{Gc=p}', ""); +Expect(0, 35, '\p{^Gc=p}', ""); +Expect(0, 35, '\P{Gc=p}', ""); +Expect(1, 35, '\P{^Gc=p}', ""); +Expect(0, 32, '\p{Gc=p}', ""); +Expect(1, 32, '\p{^Gc=p}', ""); +Expect(1, 32, '\P{Gc=p}', ""); +Expect(0, 32, '\P{^Gc=p}', ""); +Expect(1, 35, '\p{Gc=--P}', ""); +Expect(0, 35, '\p{^Gc=--P}', ""); +Expect(0, 35, '\P{Gc=--P}', ""); +Expect(1, 35, '\P{^Gc=--P}', ""); +Expect(0, 32, '\p{Gc=--P}', ""); +Expect(1, 32, '\p{^Gc=--P}', ""); +Expect(1, 32, '\P{Gc=--P}', ""); +Expect(0, 32, '\P{^Gc=--P}', ""); +Error('\p{Category: --Punct/a/}'); +Error('\P{Category: --Punct/a/}'); +Expect(1, 35, '\p{Category=punct}', ""); +Expect(0, 35, '\p{^Category=punct}', ""); +Expect(0, 35, '\P{Category=punct}', ""); +Expect(1, 35, '\P{^Category=punct}', ""); +Expect(0, 32, '\p{Category=punct}', ""); +Expect(1, 32, '\p{^Category=punct}', ""); +Expect(1, 32, '\P{Category=punct}', ""); +Expect(0, 32, '\P{^Category=punct}', ""); +Expect(1, 35, '\p{Category=-_PUNCT}', ""); +Expect(0, 35, '\p{^Category=-_PUNCT}', ""); +Expect(0, 35, '\P{Category=-_PUNCT}', ""); +Expect(1, 35, '\P{^Category=-_PUNCT}', ""); +Expect(0, 32, '\p{Category=-_PUNCT}', ""); +Expect(1, 32, '\p{^Category=-_PUNCT}', ""); +Expect(1, 32, '\P{Category=-_PUNCT}', ""); +Expect(0, 32, '\P{^Category=-_PUNCT}', ""); +Error('\p{Is_General_Category=--Punctuation/a/}'); +Error('\P{Is_General_Category=--Punctuation/a/}'); +Expect(1, 35, '\p{Is_General_Category=punctuation}', ""); +Expect(0, 35, '\p{^Is_General_Category=punctuation}', ""); +Expect(0, 35, '\P{Is_General_Category=punctuation}', ""); +Expect(1, 35, '\P{^Is_General_Category=punctuation}', ""); +Expect(0, 32, '\p{Is_General_Category=punctuation}', ""); +Expect(1, 32, '\p{^Is_General_Category=punctuation}', ""); +Expect(1, 32, '\P{Is_General_Category=punctuation}', ""); +Expect(0, 32, '\P{^Is_General_Category=punctuation}', ""); +Expect(1, 35, '\p{Is_General_Category: _punctuation}', ""); +Expect(0, 35, '\p{^Is_General_Category: _punctuation}', ""); +Expect(0, 35, '\P{Is_General_Category: _punctuation}', ""); +Expect(1, 35, '\P{^Is_General_Category: _punctuation}', ""); +Expect(0, 32, '\p{Is_General_Category: _punctuation}', ""); +Expect(1, 32, '\p{^Is_General_Category: _punctuation}', ""); +Expect(1, 32, '\P{Is_General_Category: _punctuation}', ""); +Expect(0, 32, '\P{^Is_General_Category: _punctuation}', ""); +Error('\p{Is_Gc=--p/a/}'); +Error('\P{Is_Gc=--p/a/}'); +Expect(1, 35, '\p{Is_Gc=p}', ""); +Expect(0, 35, '\p{^Is_Gc=p}', ""); +Expect(0, 35, '\P{Is_Gc=p}', ""); +Expect(1, 35, '\P{^Is_Gc=p}', ""); +Expect(0, 32, '\p{Is_Gc=p}', ""); +Expect(1, 32, '\p{^Is_Gc=p}', ""); +Expect(1, 32, '\P{Is_Gc=p}', ""); +Expect(0, 32, '\P{^Is_Gc=p}', ""); +Expect(1, 35, '\p{Is_Gc= _P}', ""); +Expect(0, 35, '\p{^Is_Gc= _P}', ""); +Expect(0, 35, '\P{Is_Gc= _P}', ""); +Expect(1, 35, '\P{^Is_Gc= _P}', ""); +Expect(0, 32, '\p{Is_Gc= _P}', ""); +Expect(1, 32, '\p{^Is_Gc= _P}', ""); +Expect(1, 32, '\P{Is_Gc= _P}', ""); +Expect(0, 32, '\P{^Is_Gc= _P}', ""); +Error('\p{Is_Category: /a/Punct}'); +Error('\P{Is_Category: /a/Punct}'); +Expect(1, 35, '\p{Is_Category=punct}', ""); +Expect(0, 35, '\p{^Is_Category=punct}', ""); +Expect(0, 35, '\P{Is_Category=punct}', ""); +Expect(1, 35, '\P{^Is_Category=punct}', ""); +Expect(0, 32, '\p{Is_Category=punct}', ""); +Expect(1, 32, '\p{^Is_Category=punct}', ""); +Expect(1, 32, '\P{Is_Category=punct}', ""); +Expect(0, 32, '\P{^Is_Category=punct}', ""); +Expect(1, 35, '\p{Is_Category: Punct}', ""); +Expect(0, 35, '\p{^Is_Category: Punct}', ""); +Expect(0, 35, '\P{Is_Category: Punct}', ""); +Expect(1, 35, '\P{^Is_Category: Punct}', ""); +Expect(0, 32, '\p{Is_Category: Punct}', ""); +Expect(1, 32, '\p{^Is_Category: Punct}', ""); +Expect(1, 32, '\P{Is_Category: Punct}', ""); +Expect(0, 32, '\P{^Is_Category: Punct}', ""); +Error('\p{General_Category= uppercase:=Letter}'); +Error('\P{General_Category= uppercase:=Letter}'); +Expect(1, 90, '\p{General_Category: uppercaseletter}', ""); +Expect(0, 90, '\p{^General_Category: uppercaseletter}', ""); +Expect(0, 90, '\P{General_Category: uppercaseletter}', ""); +Expect(1, 90, '\P{^General_Category: uppercaseletter}', ""); +Expect(0, 64, '\p{General_Category: uppercaseletter}', ""); +Expect(1, 64, '\p{^General_Category: uppercaseletter}', ""); +Expect(1, 64, '\P{General_Category: uppercaseletter}', ""); +Expect(0, 64, '\P{^General_Category: uppercaseletter}', ""); +Expect(1, 90, '\p{General_Category= UPPERCASE letter}', ""); +Expect(0, 90, '\p{^General_Category= UPPERCASE letter}', ""); +Expect(0, 90, '\P{General_Category= UPPERCASE letter}', ""); +Expect(1, 90, '\P{^General_Category= UPPERCASE letter}', ""); +Expect(0, 64, '\p{General_Category= UPPERCASE letter}', ""); +Expect(1, 64, '\p{^General_Category= UPPERCASE letter}', ""); +Expect(1, 64, '\P{General_Category= UPPERCASE letter}', ""); +Expect(0, 64, '\P{^General_Category= UPPERCASE letter}', ""); +Error('\p{Gc= -lu/a/}'); +Error('\P{Gc= -lu/a/}'); +Expect(1, 90, '\p{Gc=lu}', ""); +Expect(0, 90, '\p{^Gc=lu}', ""); +Expect(0, 90, '\P{Gc=lu}', ""); +Expect(1, 90, '\P{^Gc=lu}', ""); +Expect(0, 64, '\p{Gc=lu}', ""); +Expect(1, 64, '\p{^Gc=lu}', ""); +Expect(1, 64, '\P{Gc=lu}', ""); +Expect(0, 64, '\P{^Gc=lu}', ""); +Expect(1, 90, '\p{Gc= -LU}', ""); +Expect(0, 90, '\p{^Gc= -LU}', ""); +Expect(0, 90, '\P{Gc= -LU}', ""); +Expect(1, 90, '\P{^Gc= -LU}', ""); +Expect(0, 64, '\p{Gc= -LU}', ""); +Expect(1, 64, '\p{^Gc= -LU}', ""); +Expect(1, 64, '\P{Gc= -LU}', ""); +Expect(0, 64, '\P{^Gc= -LU}', ""); +Error('\p{Category= _Uppercase/a/letter}'); +Error('\P{Category= _Uppercase/a/letter}'); +Expect(1, 90, '\p{Category=uppercaseletter}', ""); +Expect(0, 90, '\p{^Category=uppercaseletter}', ""); +Expect(0, 90, '\P{Category=uppercaseletter}', ""); +Expect(1, 90, '\P{^Category=uppercaseletter}', ""); +Expect(0, 64, '\p{Category=uppercaseletter}', ""); +Expect(1, 64, '\p{^Category=uppercaseletter}', ""); +Expect(1, 64, '\P{Category=uppercaseletter}', ""); +Expect(0, 64, '\P{^Category=uppercaseletter}', ""); +Expect(1, 90, '\p{Category=-UPPERCASE Letter}', ""); +Expect(0, 90, '\p{^Category=-UPPERCASE Letter}', ""); +Expect(0, 90, '\P{Category=-UPPERCASE Letter}', ""); +Expect(1, 90, '\P{^Category=-UPPERCASE Letter}', ""); +Expect(0, 64, '\p{Category=-UPPERCASE Letter}', ""); +Expect(1, 64, '\p{^Category=-UPPERCASE Letter}', ""); +Expect(1, 64, '\P{Category=-UPPERCASE Letter}', ""); +Expect(0, 64, '\P{^Category=-UPPERCASE Letter}', ""); +Error('\p{Is_General_Category=:=lu}'); +Error('\P{Is_General_Category=:=lu}'); +Expect(1, 90, '\p{Is_General_Category=lu}', ""); +Expect(0, 90, '\p{^Is_General_Category=lu}', ""); +Expect(0, 90, '\P{Is_General_Category=lu}', ""); +Expect(1, 90, '\P{^Is_General_Category=lu}', ""); +Expect(0, 64, '\p{Is_General_Category=lu}', ""); +Expect(1, 64, '\p{^Is_General_Category=lu}', ""); +Expect(1, 64, '\P{Is_General_Category=lu}', ""); +Expect(0, 64, '\P{^Is_General_Category=lu}', ""); +Expect(1, 90, '\p{Is_General_Category:- Lu}', ""); +Expect(0, 90, '\p{^Is_General_Category:- Lu}', ""); +Expect(0, 90, '\P{Is_General_Category:- Lu}', ""); +Expect(1, 90, '\P{^Is_General_Category:- Lu}', ""); +Expect(0, 64, '\p{Is_General_Category:- Lu}', ""); +Expect(1, 64, '\p{^Is_General_Category:- Lu}', ""); +Expect(1, 64, '\P{Is_General_Category:- Lu}', ""); +Expect(0, 64, '\P{^Is_General_Category:- Lu}', ""); +Error('\p{Is_Gc= uppercase/a/LETTER}'); +Error('\P{Is_Gc= uppercase/a/LETTER}'); +Expect(1, 90, '\p{Is_Gc=uppercaseletter}', ""); +Expect(0, 90, '\p{^Is_Gc=uppercaseletter}', ""); +Expect(0, 90, '\P{Is_Gc=uppercaseletter}', ""); +Expect(1, 90, '\P{^Is_Gc=uppercaseletter}', ""); +Expect(0, 64, '\p{Is_Gc=uppercaseletter}', ""); +Expect(1, 64, '\p{^Is_Gc=uppercaseletter}', ""); +Expect(1, 64, '\P{Is_Gc=uppercaseletter}', ""); +Expect(0, 64, '\P{^Is_Gc=uppercaseletter}', ""); +Expect(1, 90, '\p{Is_Gc= uppercaseletter}', ""); +Expect(0, 90, '\p{^Is_Gc= uppercaseletter}', ""); +Expect(0, 90, '\P{Is_Gc= uppercaseletter}', ""); +Expect(1, 90, '\P{^Is_Gc= uppercaseletter}', ""); +Expect(0, 64, '\p{Is_Gc= uppercaseletter}', ""); +Expect(1, 64, '\p{^Is_Gc= uppercaseletter}', ""); +Expect(1, 64, '\P{Is_Gc= uppercaseletter}', ""); +Expect(0, 64, '\P{^Is_Gc= uppercaseletter}', ""); +Error('\p{Is_Category=- Lu/a/}'); +Error('\P{Is_Category=- Lu/a/}'); +Expect(1, 90, '\p{Is_Category:lu}', ""); +Expect(0, 90, '\p{^Is_Category:lu}', ""); +Expect(0, 90, '\P{Is_Category:lu}', ""); +Expect(1, 90, '\P{^Is_Category:lu}', ""); +Expect(0, 64, '\p{Is_Category:lu}', ""); +Expect(1, 64, '\p{^Is_Category:lu}', ""); +Expect(1, 64, '\P{Is_Category:lu}', ""); +Expect(0, 64, '\P{^Is_Category:lu}', ""); +Expect(1, 90, '\p{Is_Category=_ LU}', ""); +Expect(0, 90, '\p{^Is_Category=_ LU}', ""); +Expect(0, 90, '\P{Is_Category=_ LU}', ""); +Expect(1, 90, '\P{^Is_Category=_ LU}', ""); +Expect(0, 64, '\p{Is_Category=_ LU}', ""); +Expect(1, 64, '\p{^Is_Category=_ LU}', ""); +Expect(1, 64, '\P{Is_Category=_ LU}', ""); +Expect(0, 64, '\P{^Is_Category=_ LU}', ""); +Error('\p{General_Category=/a/ Number}'); +Error('\P{General_Category=/a/ Number}'); +Expect(1, 57, '\p{General_Category=number}', ""); +Expect(0, 57, '\p{^General_Category=number}', ""); +Expect(0, 57, '\P{General_Category=number}', ""); +Expect(1, 57, '\P{^General_Category=number}', ""); +Expect(0, 47, '\p{General_Category=number}', ""); +Expect(1, 47, '\p{^General_Category=number}', ""); +Expect(1, 47, '\P{General_Category=number}', ""); +Expect(0, 47, '\P{^General_Category=number}', ""); +Expect(1, 57, '\p{General_Category=Number}', ""); +Expect(0, 57, '\p{^General_Category=Number}', ""); +Expect(0, 57, '\P{General_Category=Number}', ""); +Expect(1, 57, '\P{^General_Category=Number}', ""); +Expect(0, 47, '\p{General_Category=Number}', ""); +Expect(1, 47, '\p{^General_Category=Number}', ""); +Expect(1, 47, '\P{General_Category=Number}', ""); +Expect(0, 47, '\P{^General_Category=Number}', ""); +Error('\p{Gc=-/a/N}'); +Error('\P{Gc=-/a/N}'); +Expect(1, 57, '\p{Gc: n}', ""); +Expect(0, 57, '\p{^Gc: n}', ""); +Expect(0, 57, '\P{Gc: n}', ""); +Expect(1, 57, '\P{^Gc: n}', ""); +Expect(0, 47, '\p{Gc: n}', ""); +Expect(1, 47, '\p{^Gc: n}', ""); +Expect(1, 47, '\P{Gc: n}', ""); +Expect(0, 47, '\P{^Gc: n}', ""); +Expect(1, 57, '\p{Gc=N}', ""); +Expect(0, 57, '\p{^Gc=N}', ""); +Expect(0, 57, '\P{Gc=N}', ""); +Expect(1, 57, '\P{^Gc=N}', ""); +Expect(0, 47, '\p{Gc=N}', ""); +Expect(1, 47, '\p{^Gc=N}', ""); +Expect(1, 47, '\P{Gc=N}', ""); +Expect(0, 47, '\P{^Gc=N}', ""); +Error('\p{Category: :=Number}'); +Error('\P{Category: :=Number}'); +Expect(1, 57, '\p{Category=number}', ""); +Expect(0, 57, '\p{^Category=number}', ""); +Expect(0, 57, '\P{Category=number}', ""); +Expect(1, 57, '\P{^Category=number}', ""); +Expect(0, 47, '\p{Category=number}', ""); +Expect(1, 47, '\p{^Category=number}', ""); +Expect(1, 47, '\P{Category=number}', ""); +Expect(0, 47, '\P{^Category=number}', ""); +Expect(1, 57, '\p{Category= NUMBER}', ""); +Expect(0, 57, '\p{^Category= NUMBER}', ""); +Expect(0, 57, '\P{Category= NUMBER}', ""); +Expect(1, 57, '\P{^Category= NUMBER}', ""); +Expect(0, 47, '\p{Category= NUMBER}', ""); +Expect(1, 47, '\p{^Category= NUMBER}', ""); +Expect(1, 47, '\P{Category= NUMBER}', ""); +Expect(0, 47, '\P{^Category= NUMBER}', ""); +Error('\p{Is_General_Category=/a/_N}'); +Error('\P{Is_General_Category=/a/_N}'); +Expect(1, 57, '\p{Is_General_Category:n}', ""); +Expect(0, 57, '\p{^Is_General_Category:n}', ""); +Expect(0, 57, '\P{Is_General_Category:n}', ""); +Expect(1, 57, '\P{^Is_General_Category:n}', ""); +Expect(0, 47, '\p{Is_General_Category:n}', ""); +Expect(1, 47, '\p{^Is_General_Category:n}', ""); +Expect(1, 47, '\P{Is_General_Category:n}', ""); +Expect(0, 47, '\P{^Is_General_Category:n}', ""); +Expect(1, 57, '\p{Is_General_Category= -N}', ""); +Expect(0, 57, '\p{^Is_General_Category= -N}', ""); +Expect(0, 57, '\P{Is_General_Category= -N}', ""); +Expect(1, 57, '\P{^Is_General_Category= -N}', ""); +Expect(0, 47, '\p{Is_General_Category= -N}', ""); +Expect(1, 47, '\p{^Is_General_Category= -N}', ""); +Expect(1, 47, '\P{Is_General_Category= -N}', ""); +Expect(0, 47, '\P{^Is_General_Category= -N}', ""); +Error('\p{Is_Gc=/a/- number}'); +Error('\P{Is_Gc=/a/- number}'); +Expect(1, 57, '\p{Is_Gc=number}', ""); +Expect(0, 57, '\p{^Is_Gc=number}', ""); +Expect(0, 57, '\P{Is_Gc=number}', ""); +Expect(1, 57, '\P{^Is_Gc=number}', ""); +Expect(0, 47, '\p{Is_Gc=number}', ""); +Expect(1, 47, '\p{^Is_Gc=number}', ""); +Expect(1, 47, '\P{Is_Gc=number}', ""); +Expect(0, 47, '\P{^Is_Gc=number}', ""); +Expect(1, 57, '\p{Is_Gc= NUMBER}', ""); +Expect(0, 57, '\p{^Is_Gc= NUMBER}', ""); +Expect(0, 57, '\P{Is_Gc= NUMBER}', ""); +Expect(1, 57, '\P{^Is_Gc= NUMBER}', ""); +Expect(0, 47, '\p{Is_Gc= NUMBER}', ""); +Expect(1, 47, '\p{^Is_Gc= NUMBER}', ""); +Expect(1, 47, '\P{Is_Gc= NUMBER}', ""); +Expect(0, 47, '\P{^Is_Gc= NUMBER}', ""); +Error('\p{Is_Category: :=N}'); +Error('\P{Is_Category: :=N}'); +Expect(1, 57, '\p{Is_Category=n}', ""); +Expect(0, 57, '\p{^Is_Category=n}', ""); +Expect(0, 57, '\P{Is_Category=n}', ""); +Expect(1, 57, '\P{^Is_Category=n}', ""); +Expect(0, 47, '\p{Is_Category=n}', ""); +Expect(1, 47, '\p{^Is_Category=n}', ""); +Expect(1, 47, '\P{Is_Category=n}', ""); +Expect(0, 47, '\P{^Is_Category=n}', ""); +Expect(1, 57, '\p{Is_Category: _N}', ""); +Expect(0, 57, '\p{^Is_Category: _N}', ""); +Expect(0, 57, '\P{Is_Category: _N}', ""); +Expect(1, 57, '\P{^Is_Category: _N}', ""); +Expect(0, 47, '\p{Is_Category: _N}', ""); +Expect(1, 47, '\p{^Is_Category: _N}', ""); +Expect(1, 47, '\P{Is_Category: _N}', ""); +Expect(0, 47, '\P{^Is_Category: _N}', ""); +Error('\p{General_Category: Final/a/Punctuation}'); +Error('\P{General_Category: Final/a/Punctuation}'); +Expect(1, 8217, '\p{General_Category=finalpunctuation}', ""); +Expect(0, 8217, '\p{^General_Category=finalpunctuation}', ""); +Expect(0, 8217, '\P{General_Category=finalpunctuation}', ""); +Expect(1, 8217, '\P{^General_Category=finalpunctuation}', ""); +Expect(0, 7, '\p{General_Category=finalpunctuation}', ""); +Expect(1, 7, '\p{^General_Category=finalpunctuation}', ""); +Expect(1, 7, '\P{General_Category=finalpunctuation}', ""); +Expect(0, 7, '\P{^General_Category=finalpunctuation}', ""); +Expect(1, 8217, '\p{General_Category= _FINALpunctuation}', ""); +Expect(0, 8217, '\p{^General_Category= _FINALpunctuation}', ""); +Expect(0, 8217, '\P{General_Category= _FINALpunctuation}', ""); +Expect(1, 8217, '\P{^General_Category= _FINALpunctuation}', ""); +Expect(0, 7, '\p{General_Category= _FINALpunctuation}', ""); +Expect(1, 7, '\p{^General_Category= _FINALpunctuation}', ""); +Expect(1, 7, '\P{General_Category= _FINALpunctuation}', ""); +Expect(0, 7, '\P{^General_Category= _FINALpunctuation}', ""); +Error('\p{Gc= /a/Pf}'); +Error('\P{Gc= /a/Pf}'); +Expect(1, 8217, '\p{Gc: pf}', ""); +Expect(0, 8217, '\p{^Gc: pf}', ""); +Expect(0, 8217, '\P{Gc: pf}', ""); +Expect(1, 8217, '\P{^Gc: pf}', ""); +Expect(0, 7, '\p{Gc: pf}', ""); +Expect(1, 7, '\p{^Gc: pf}', ""); +Expect(1, 7, '\P{Gc: pf}', ""); +Expect(0, 7, '\P{^Gc: pf}', ""); +Expect(1, 8217, '\p{Gc=-pf}', ""); +Expect(0, 8217, '\p{^Gc=-pf}', ""); +Expect(0, 8217, '\P{Gc=-pf}', ""); +Expect(1, 8217, '\P{^Gc=-pf}', ""); +Expect(0, 7, '\p{Gc=-pf}', ""); +Expect(1, 7, '\p{^Gc=-pf}', ""); +Expect(1, 7, '\P{Gc=-pf}', ""); +Expect(0, 7, '\P{^Gc=-pf}', ""); +Error('\p{Category= Final Punctuation/a/}'); +Error('\P{Category= Final Punctuation/a/}'); +Expect(1, 8217, '\p{Category=finalpunctuation}', ""); +Expect(0, 8217, '\p{^Category=finalpunctuation}', ""); +Expect(0, 8217, '\P{Category=finalpunctuation}', ""); +Expect(1, 8217, '\P{^Category=finalpunctuation}', ""); +Expect(0, 7, '\p{Category=finalpunctuation}', ""); +Expect(1, 7, '\p{^Category=finalpunctuation}', ""); +Expect(1, 7, '\P{Category=finalpunctuation}', ""); +Expect(0, 7, '\P{^Category=finalpunctuation}', ""); +Expect(1, 8217, '\p{Category= FINALPunctuation}', ""); +Expect(0, 8217, '\p{^Category= FINALPunctuation}', ""); +Expect(0, 8217, '\P{Category= FINALPunctuation}', ""); +Expect(1, 8217, '\P{^Category= FINALPunctuation}', ""); +Expect(0, 7, '\p{Category= FINALPunctuation}', ""); +Expect(1, 7, '\p{^Category= FINALPunctuation}', ""); +Expect(1, 7, '\P{Category= FINALPunctuation}', ""); +Expect(0, 7, '\P{^Category= FINALPunctuation}', ""); +Error('\p{Is_General_Category=:=Pf}'); +Error('\P{Is_General_Category=:=Pf}'); +Expect(1, 8217, '\p{Is_General_Category=pf}', ""); +Expect(0, 8217, '\p{^Is_General_Category=pf}', ""); +Expect(0, 8217, '\P{Is_General_Category=pf}', ""); +Expect(1, 8217, '\P{^Is_General_Category=pf}', ""); +Expect(0, 7, '\p{Is_General_Category=pf}', ""); +Expect(1, 7, '\p{^Is_General_Category=pf}', ""); +Expect(1, 7, '\P{Is_General_Category=pf}', ""); +Expect(0, 7, '\P{^Is_General_Category=pf}', ""); +Expect(1, 8217, '\p{Is_General_Category= -pf}', ""); +Expect(0, 8217, '\p{^Is_General_Category= -pf}', ""); +Expect(0, 8217, '\P{Is_General_Category= -pf}', ""); +Expect(1, 8217, '\P{^Is_General_Category= -pf}', ""); +Expect(0, 7, '\p{Is_General_Category= -pf}', ""); +Expect(1, 7, '\p{^Is_General_Category= -pf}', ""); +Expect(1, 7, '\P{Is_General_Category= -pf}', ""); +Expect(0, 7, '\P{^Is_General_Category= -pf}', ""); +Error('\p{Is_Gc=_FINAL PUNCTUATION:=}'); +Error('\P{Is_Gc=_FINAL PUNCTUATION:=}'); +Expect(1, 8217, '\p{Is_Gc=finalpunctuation}', ""); +Expect(0, 8217, '\p{^Is_Gc=finalpunctuation}', ""); +Expect(0, 8217, '\P{Is_Gc=finalpunctuation}', ""); +Expect(1, 8217, '\P{^Is_Gc=finalpunctuation}', ""); +Expect(0, 7, '\p{Is_Gc=finalpunctuation}', ""); +Expect(1, 7, '\p{^Is_Gc=finalpunctuation}', ""); +Expect(1, 7, '\P{Is_Gc=finalpunctuation}', ""); +Expect(0, 7, '\P{^Is_Gc=finalpunctuation}', ""); +Expect(1, 8217, '\p{Is_Gc= Final_Punctuation}', ""); +Expect(0, 8217, '\p{^Is_Gc= Final_Punctuation}', ""); +Expect(0, 8217, '\P{Is_Gc= Final_Punctuation}', ""); +Expect(1, 8217, '\P{^Is_Gc= Final_Punctuation}', ""); +Expect(0, 7, '\p{Is_Gc= Final_Punctuation}', ""); +Expect(1, 7, '\p{^Is_Gc= Final_Punctuation}', ""); +Expect(1, 7, '\P{Is_Gc= Final_Punctuation}', ""); +Expect(0, 7, '\P{^Is_Gc= Final_Punctuation}', ""); +Error('\p{Is_Category=/a/_PF}'); +Error('\P{Is_Category=/a/_PF}'); +Expect(1, 8217, '\p{Is_Category=pf}', ""); +Expect(0, 8217, '\p{^Is_Category=pf}', ""); +Expect(0, 8217, '\P{Is_Category=pf}', ""); +Expect(1, 8217, '\P{^Is_Category=pf}', ""); +Expect(0, 7, '\p{Is_Category=pf}', ""); +Expect(1, 7, '\p{^Is_Category=pf}', ""); +Expect(1, 7, '\P{Is_Category=pf}', ""); +Expect(0, 7, '\P{^Is_Category=pf}', ""); +Expect(1, 8217, '\p{Is_Category= _Pf}', ""); +Expect(0, 8217, '\p{^Is_Category= _Pf}', ""); +Expect(0, 8217, '\P{Is_Category= _Pf}', ""); +Expect(1, 8217, '\P{^Is_Category= _Pf}', ""); +Expect(0, 7, '\p{Is_Category= _Pf}', ""); +Expect(1, 7, '\p{^Is_Category= _Pf}', ""); +Expect(1, 7, '\P{Is_Category= _Pf}', ""); +Expect(0, 7, '\P{^Is_Category= _Pf}', ""); +Error('\p{General_Category: -unassigned:=}'); +Error('\P{General_Category: -unassigned:=}'); +Expect(1, 889, '\p{General_Category=unassigned}', ""); +Expect(0, 889, '\p{^General_Category=unassigned}', ""); +Expect(0, 889, '\P{General_Category=unassigned}', ""); +Expect(1, 889, '\P{^General_Category=unassigned}', ""); +Expect(0, 887, '\p{General_Category=unassigned}', ""); +Expect(1, 887, '\p{^General_Category=unassigned}', ""); +Expect(1, 887, '\P{General_Category=unassigned}', ""); +Expect(0, 887, '\P{^General_Category=unassigned}', ""); +Expect(1, 889, '\p{General_Category=_UNASSIGNED}', ""); +Expect(0, 889, '\p{^General_Category=_UNASSIGNED}', ""); +Expect(0, 889, '\P{General_Category=_UNASSIGNED}', ""); +Expect(1, 889, '\P{^General_Category=_UNASSIGNED}', ""); +Expect(0, 887, '\p{General_Category=_UNASSIGNED}', ""); +Expect(1, 887, '\p{^General_Category=_UNASSIGNED}', ""); +Expect(1, 887, '\P{General_Category=_UNASSIGNED}', ""); +Expect(0, 887, '\P{^General_Category=_UNASSIGNED}', ""); +Error('\p{Gc=/a/ _Cn}'); +Error('\P{Gc=/a/ _Cn}'); +Expect(1, 889, '\p{Gc=cn}', ""); +Expect(0, 889, '\p{^Gc=cn}', ""); +Expect(0, 889, '\P{Gc=cn}', ""); +Expect(1, 889, '\P{^Gc=cn}', ""); +Expect(0, 887, '\p{Gc=cn}', ""); +Expect(1, 887, '\p{^Gc=cn}', ""); +Expect(1, 887, '\P{Gc=cn}', ""); +Expect(0, 887, '\P{^Gc=cn}', ""); +Expect(1, 889, '\p{Gc=--Cn}', ""); +Expect(0, 889, '\p{^Gc=--Cn}', ""); +Expect(0, 889, '\P{Gc=--Cn}', ""); +Expect(1, 889, '\P{^Gc=--Cn}', ""); +Expect(0, 887, '\p{Gc=--Cn}', ""); +Expect(1, 887, '\p{^Gc=--Cn}', ""); +Expect(1, 887, '\P{Gc=--Cn}', ""); +Expect(0, 887, '\P{^Gc=--Cn}', ""); +Error('\p{Category=/a/-unassigned}'); +Error('\P{Category=/a/-unassigned}'); +Expect(1, 889, '\p{Category=unassigned}', ""); +Expect(0, 889, '\p{^Category=unassigned}', ""); +Expect(0, 889, '\P{Category=unassigned}', ""); +Expect(1, 889, '\P{^Category=unassigned}', ""); +Expect(0, 887, '\p{Category=unassigned}', ""); +Expect(1, 887, '\p{^Category=unassigned}', ""); +Expect(1, 887, '\P{Category=unassigned}', ""); +Expect(0, 887, '\P{^Category=unassigned}', ""); +Expect(1, 889, '\p{Category= -UNASSIGNED}', ""); +Expect(0, 889, '\p{^Category= -UNASSIGNED}', ""); +Expect(0, 889, '\P{Category= -UNASSIGNED}', ""); +Expect(1, 889, '\P{^Category= -UNASSIGNED}', ""); +Expect(0, 887, '\p{Category= -UNASSIGNED}', ""); +Expect(1, 887, '\p{^Category= -UNASSIGNED}', ""); +Expect(1, 887, '\P{Category= -UNASSIGNED}', ""); +Expect(0, 887, '\P{^Category= -UNASSIGNED}', ""); +Error('\p{Is_General_Category=__CN/a/}'); +Error('\P{Is_General_Category=__CN/a/}'); +Expect(1, 889, '\p{Is_General_Category=cn}', ""); +Expect(0, 889, '\p{^Is_General_Category=cn}', ""); +Expect(0, 889, '\P{Is_General_Category=cn}', ""); +Expect(1, 889, '\P{^Is_General_Category=cn}', ""); +Expect(0, 887, '\p{Is_General_Category=cn}', ""); +Expect(1, 887, '\p{^Is_General_Category=cn}', ""); +Expect(1, 887, '\P{Is_General_Category=cn}', ""); +Expect(0, 887, '\P{^Is_General_Category=cn}', ""); +Expect(1, 889, '\p{Is_General_Category= CN}', ""); +Expect(0, 889, '\p{^Is_General_Category= CN}', ""); +Expect(0, 889, '\P{Is_General_Category= CN}', ""); +Expect(1, 889, '\P{^Is_General_Category= CN}', ""); +Expect(0, 887, '\p{Is_General_Category= CN}', ""); +Expect(1, 887, '\p{^Is_General_Category= CN}', ""); +Expect(1, 887, '\P{Is_General_Category= CN}', ""); +Expect(0, 887, '\P{^Is_General_Category= CN}', ""); +Error('\p{Is_Gc=:=__UNASSIGNED}'); +Error('\P{Is_Gc=:=__UNASSIGNED}'); +Expect(1, 889, '\p{Is_Gc=unassigned}', ""); +Expect(0, 889, '\p{^Is_Gc=unassigned}', ""); +Expect(0, 889, '\P{Is_Gc=unassigned}', ""); +Expect(1, 889, '\P{^Is_Gc=unassigned}', ""); +Expect(0, 887, '\p{Is_Gc=unassigned}', ""); +Expect(1, 887, '\p{^Is_Gc=unassigned}', ""); +Expect(1, 887, '\P{Is_Gc=unassigned}', ""); +Expect(0, 887, '\P{^Is_Gc=unassigned}', ""); +Expect(1, 889, '\p{Is_Gc=_ Unassigned}', ""); +Expect(0, 889, '\p{^Is_Gc=_ Unassigned}', ""); +Expect(0, 889, '\P{Is_Gc=_ Unassigned}', ""); +Expect(1, 889, '\P{^Is_Gc=_ Unassigned}', ""); +Expect(0, 887, '\p{Is_Gc=_ Unassigned}', ""); +Expect(1, 887, '\p{^Is_Gc=_ Unassigned}', ""); +Expect(1, 887, '\P{Is_Gc=_ Unassigned}', ""); +Expect(0, 887, '\P{^Is_Gc=_ Unassigned}', ""); +Error('\p{Is_Category=_ CN:=}'); +Error('\P{Is_Category=_ CN:=}'); +Expect(1, 889, '\p{Is_Category=cn}', ""); +Expect(0, 889, '\p{^Is_Category=cn}', ""); +Expect(0, 889, '\P{Is_Category=cn}', ""); +Expect(1, 889, '\P{^Is_Category=cn}', ""); +Expect(0, 887, '\p{Is_Category=cn}', ""); +Expect(1, 887, '\p{^Is_Category=cn}', ""); +Expect(1, 887, '\P{Is_Category=cn}', ""); +Expect(0, 887, '\P{^Is_Category=cn}', ""); +Expect(1, 889, '\p{Is_Category= Cn}', ""); +Expect(0, 889, '\p{^Is_Category= Cn}', ""); +Expect(0, 889, '\P{Is_Category= Cn}', ""); +Expect(1, 889, '\P{^Is_Category= Cn}', ""); +Expect(0, 887, '\p{Is_Category= Cn}', ""); +Expect(1, 887, '\p{^Is_Category= Cn}', ""); +Expect(1, 887, '\P{Is_Category= Cn}', ""); +Expect(0, 887, '\P{^Is_Category= Cn}', ""); +Error('\p{General_Category=_:=Decimal_number}'); +Error('\P{General_Category=_:=Decimal_number}'); +Expect(1, 57, '\p{General_Category=decimalnumber}', ""); +Expect(0, 57, '\p{^General_Category=decimalnumber}', ""); +Expect(0, 57, '\P{General_Category=decimalnumber}', ""); +Expect(1, 57, '\P{^General_Category=decimalnumber}', ""); +Expect(0, 47, '\p{General_Category=decimalnumber}', ""); +Expect(1, 47, '\p{^General_Category=decimalnumber}', ""); +Expect(1, 47, '\P{General_Category=decimalnumber}', ""); +Expect(0, 47, '\P{^General_Category=decimalnumber}', ""); +Expect(1, 57, '\p{General_Category= DECIMALNUMBER}', ""); +Expect(0, 57, '\p{^General_Category= DECIMALNUMBER}', ""); +Expect(0, 57, '\P{General_Category= DECIMALNUMBER}', ""); +Expect(1, 57, '\P{^General_Category= DECIMALNUMBER}', ""); +Expect(0, 47, '\p{General_Category= DECIMALNUMBER}', ""); +Expect(1, 47, '\p{^General_Category= DECIMALNUMBER}', ""); +Expect(1, 47, '\P{General_Category= DECIMALNUMBER}', ""); +Expect(0, 47, '\P{^General_Category= DECIMALNUMBER}', ""); +Error('\p{Gc=_Nd/a/}'); +Error('\P{Gc=_Nd/a/}'); +Expect(1, 57, '\p{Gc=nd}', ""); +Expect(0, 57, '\p{^Gc=nd}', ""); +Expect(0, 57, '\P{Gc=nd}', ""); +Expect(1, 57, '\P{^Gc=nd}', ""); +Expect(0, 47, '\p{Gc=nd}', ""); +Expect(1, 47, '\p{^Gc=nd}', ""); +Expect(1, 47, '\P{Gc=nd}', ""); +Expect(0, 47, '\P{^Gc=nd}', ""); +Expect(1, 57, '\p{Gc= Nd}', ""); +Expect(0, 57, '\p{^Gc= Nd}', ""); +Expect(0, 57, '\P{Gc= Nd}', ""); +Expect(1, 57, '\P{^Gc= Nd}', ""); +Expect(0, 47, '\p{Gc= Nd}', ""); +Expect(1, 47, '\p{^Gc= Nd}', ""); +Expect(1, 47, '\P{Gc= Nd}', ""); +Expect(0, 47, '\P{^Gc= Nd}', ""); +Error('\p{Category=:=_-Digit}'); +Error('\P{Category=:=_-Digit}'); +Expect(1, 57, '\p{Category=digit}', ""); +Expect(0, 57, '\p{^Category=digit}', ""); +Expect(0, 57, '\P{Category=digit}', ""); +Expect(1, 57, '\P{^Category=digit}', ""); +Expect(0, 47, '\p{Category=digit}', ""); +Expect(1, 47, '\p{^Category=digit}', ""); +Expect(1, 47, '\P{Category=digit}', ""); +Expect(0, 47, '\P{^Category=digit}', ""); +Expect(1, 57, '\p{Category=_-DIGIT}', ""); +Expect(0, 57, '\p{^Category=_-DIGIT}', ""); +Expect(0, 57, '\P{Category=_-DIGIT}', ""); +Expect(1, 57, '\P{^Category=_-DIGIT}', ""); +Expect(0, 47, '\p{Category=_-DIGIT}', ""); +Expect(1, 47, '\p{^Category=_-DIGIT}', ""); +Expect(1, 47, '\P{Category=_-DIGIT}', ""); +Expect(0, 47, '\P{^Category=_-DIGIT}', ""); +Error('\p{Is_General_Category=:=DECIMAL Number}'); +Error('\P{Is_General_Category=:=DECIMAL Number}'); +Expect(1, 57, '\p{Is_General_Category=decimalnumber}', ""); +Expect(0, 57, '\p{^Is_General_Category=decimalnumber}', ""); +Expect(0, 57, '\P{Is_General_Category=decimalnumber}', ""); +Expect(1, 57, '\P{^Is_General_Category=decimalnumber}', ""); +Expect(0, 47, '\p{Is_General_Category=decimalnumber}', ""); +Expect(1, 47, '\p{^Is_General_Category=decimalnumber}', ""); +Expect(1, 47, '\P{Is_General_Category=decimalnumber}', ""); +Expect(0, 47, '\P{^Is_General_Category=decimalnumber}', ""); +Expect(1, 57, '\p{Is_General_Category= decimalnumber}', ""); +Expect(0, 57, '\p{^Is_General_Category= decimalnumber}', ""); +Expect(0, 57, '\P{Is_General_Category= decimalnumber}', ""); +Expect(1, 57, '\P{^Is_General_Category= decimalnumber}', ""); +Expect(0, 47, '\p{Is_General_Category= decimalnumber}', ""); +Expect(1, 47, '\p{^Is_General_Category= decimalnumber}', ""); +Expect(1, 47, '\P{Is_General_Category= decimalnumber}', ""); +Expect(0, 47, '\P{^Is_General_Category= decimalnumber}', ""); +Error('\p{Is_Gc=-:=ND}'); +Error('\P{Is_Gc=-:=ND}'); +Expect(1, 57, '\p{Is_Gc=nd}', ""); +Expect(0, 57, '\p{^Is_Gc=nd}', ""); +Expect(0, 57, '\P{Is_Gc=nd}', ""); +Expect(1, 57, '\P{^Is_Gc=nd}', ""); +Expect(0, 47, '\p{Is_Gc=nd}', ""); +Expect(1, 47, '\p{^Is_Gc=nd}', ""); +Expect(1, 47, '\P{Is_Gc=nd}', ""); +Expect(0, 47, '\P{^Is_Gc=nd}', ""); +Expect(1, 57, '\p{Is_Gc=_ Nd}', ""); +Expect(0, 57, '\p{^Is_Gc=_ Nd}', ""); +Expect(0, 57, '\P{Is_Gc=_ Nd}', ""); +Expect(1, 57, '\P{^Is_Gc=_ Nd}', ""); +Expect(0, 47, '\p{Is_Gc=_ Nd}', ""); +Expect(1, 47, '\p{^Is_Gc=_ Nd}', ""); +Expect(1, 47, '\P{Is_Gc=_ Nd}', ""); +Expect(0, 47, '\P{^Is_Gc=_ Nd}', ""); +Error('\p{Is_Category: /a/DIGIT}'); +Error('\P{Is_Category: /a/DIGIT}'); +Expect(1, 57, '\p{Is_Category=digit}', ""); +Expect(0, 57, '\p{^Is_Category=digit}', ""); +Expect(0, 57, '\P{Is_Category=digit}', ""); +Expect(1, 57, '\P{^Is_Category=digit}', ""); +Expect(0, 47, '\p{Is_Category=digit}', ""); +Expect(1, 47, '\p{^Is_Category=digit}', ""); +Expect(1, 47, '\P{Is_Category=digit}', ""); +Expect(0, 47, '\P{^Is_Category=digit}', ""); +Expect(1, 57, '\p{Is_Category= Digit}', ""); +Expect(0, 57, '\p{^Is_Category= Digit}', ""); +Expect(0, 57, '\P{Is_Category= Digit}', ""); +Expect(1, 57, '\P{^Is_Category= Digit}', ""); +Expect(0, 47, '\p{Is_Category= Digit}', ""); +Expect(1, 47, '\p{^Is_Category= Digit}', ""); +Expect(1, 47, '\P{Is_Category= Digit}', ""); +Expect(0, 47, '\P{^Is_Category= Digit}', ""); +Error('\p{General_Category=_:=paragraphseparator}'); +Error('\P{General_Category=_:=paragraphseparator}'); +Expect(1, 8233, '\p{General_Category=paragraphseparator}', ""); +Expect(0, 8233, '\p{^General_Category=paragraphseparator}', ""); +Expect(0, 8233, '\P{General_Category=paragraphseparator}', ""); +Expect(1, 8233, '\P{^General_Category=paragraphseparator}', ""); +Expect(0, 8232, '\p{General_Category=paragraphseparator}', ""); +Expect(1, 8232, '\p{^General_Category=paragraphseparator}', ""); +Expect(1, 8232, '\P{General_Category=paragraphseparator}', ""); +Expect(0, 8232, '\P{^General_Category=paragraphseparator}', ""); +Expect(1, 8233, '\p{General_Category=_ PARAGRAPH SEPARATOR}', ""); +Expect(0, 8233, '\p{^General_Category=_ PARAGRAPH SEPARATOR}', ""); +Expect(0, 8233, '\P{General_Category=_ PARAGRAPH SEPARATOR}', ""); +Expect(1, 8233, '\P{^General_Category=_ PARAGRAPH SEPARATOR}', ""); +Expect(0, 8232, '\p{General_Category=_ PARAGRAPH SEPARATOR}', ""); +Expect(1, 8232, '\p{^General_Category=_ PARAGRAPH SEPARATOR}', ""); +Expect(1, 8232, '\P{General_Category=_ PARAGRAPH SEPARATOR}', ""); +Expect(0, 8232, '\P{^General_Category=_ PARAGRAPH SEPARATOR}', ""); +Error('\p{Gc= zp:=}'); +Error('\P{Gc= zp:=}'); +Expect(1, 8233, '\p{Gc=zp}', ""); +Expect(0, 8233, '\p{^Gc=zp}', ""); +Expect(0, 8233, '\P{Gc=zp}', ""); +Expect(1, 8233, '\P{^Gc=zp}', ""); +Expect(0, 8232, '\p{Gc=zp}', ""); +Expect(1, 8232, '\p{^Gc=zp}', ""); +Expect(1, 8232, '\P{Gc=zp}', ""); +Expect(0, 8232, '\P{^Gc=zp}', ""); +Expect(1, 8233, '\p{Gc= Zp}', ""); +Expect(0, 8233, '\p{^Gc= Zp}', ""); +Expect(0, 8233, '\P{Gc= Zp}', ""); +Expect(1, 8233, '\P{^Gc= Zp}', ""); +Expect(0, 8232, '\p{Gc= Zp}', ""); +Expect(1, 8232, '\p{^Gc= Zp}', ""); +Expect(1, 8232, '\P{Gc= Zp}', ""); +Expect(0, 8232, '\P{^Gc= Zp}', ""); +Error('\p{Category=_:=paragraph separator}'); +Error('\P{Category=_:=paragraph separator}'); +Expect(1, 8233, '\p{Category=paragraphseparator}', ""); +Expect(0, 8233, '\p{^Category=paragraphseparator}', ""); +Expect(0, 8233, '\P{Category=paragraphseparator}', ""); +Expect(1, 8233, '\P{^Category=paragraphseparator}', ""); +Expect(0, 8232, '\p{Category=paragraphseparator}', ""); +Expect(1, 8232, '\p{^Category=paragraphseparator}', ""); +Expect(1, 8232, '\P{Category=paragraphseparator}', ""); +Expect(0, 8232, '\P{^Category=paragraphseparator}', ""); +Expect(1, 8233, '\p{Category= _PARAGRAPH_SEPARATOR}', ""); +Expect(0, 8233, '\p{^Category= _PARAGRAPH_SEPARATOR}', ""); +Expect(0, 8233, '\P{Category= _PARAGRAPH_SEPARATOR}', ""); +Expect(1, 8233, '\P{^Category= _PARAGRAPH_SEPARATOR}', ""); +Expect(0, 8232, '\p{Category= _PARAGRAPH_SEPARATOR}', ""); +Expect(1, 8232, '\p{^Category= _PARAGRAPH_SEPARATOR}', ""); +Expect(1, 8232, '\P{Category= _PARAGRAPH_SEPARATOR}', ""); +Expect(0, 8232, '\P{^Category= _PARAGRAPH_SEPARATOR}', ""); +Error('\p{Is_General_Category=_/a/Zp}'); +Error('\P{Is_General_Category=_/a/Zp}'); +Expect(1, 8233, '\p{Is_General_Category=zp}', ""); +Expect(0, 8233, '\p{^Is_General_Category=zp}', ""); +Expect(0, 8233, '\P{Is_General_Category=zp}', ""); +Expect(1, 8233, '\P{^Is_General_Category=zp}', ""); +Expect(0, 8232, '\p{Is_General_Category=zp}', ""); +Expect(1, 8232, '\p{^Is_General_Category=zp}', ""); +Expect(1, 8232, '\P{Is_General_Category=zp}', ""); +Expect(0, 8232, '\P{^Is_General_Category=zp}', ""); +Expect(1, 8233, '\p{Is_General_Category= -zp}', ""); +Expect(0, 8233, '\p{^Is_General_Category= -zp}', ""); +Expect(0, 8233, '\P{Is_General_Category= -zp}', ""); +Expect(1, 8233, '\P{^Is_General_Category= -zp}', ""); +Expect(0, 8232, '\p{Is_General_Category= -zp}', ""); +Expect(1, 8232, '\p{^Is_General_Category= -zp}', ""); +Expect(1, 8232, '\P{Is_General_Category= -zp}', ""); +Expect(0, 8232, '\P{^Is_General_Category= -zp}', ""); +Error('\p{Is_Gc= PARAGRAPH_separator:=}'); +Error('\P{Is_Gc= PARAGRAPH_separator:=}'); +Expect(1, 8233, '\p{Is_Gc=paragraphseparator}', ""); +Expect(0, 8233, '\p{^Is_Gc=paragraphseparator}', ""); +Expect(0, 8233, '\P{Is_Gc=paragraphseparator}', ""); +Expect(1, 8233, '\P{^Is_Gc=paragraphseparator}', ""); +Expect(0, 8232, '\p{Is_Gc=paragraphseparator}', ""); +Expect(1, 8232, '\p{^Is_Gc=paragraphseparator}', ""); +Expect(1, 8232, '\P{Is_Gc=paragraphseparator}', ""); +Expect(0, 8232, '\P{^Is_Gc=paragraphseparator}', ""); +Expect(1, 8233, '\p{Is_Gc= _Paragraph-SEPARATOR}', ""); +Expect(0, 8233, '\p{^Is_Gc= _Paragraph-SEPARATOR}', ""); +Expect(0, 8233, '\P{Is_Gc= _Paragraph-SEPARATOR}', ""); +Expect(1, 8233, '\P{^Is_Gc= _Paragraph-SEPARATOR}', ""); +Expect(0, 8232, '\p{Is_Gc= _Paragraph-SEPARATOR}', ""); +Expect(1, 8232, '\p{^Is_Gc= _Paragraph-SEPARATOR}', ""); +Expect(1, 8232, '\P{Is_Gc= _Paragraph-SEPARATOR}', ""); +Expect(0, 8232, '\P{^Is_Gc= _Paragraph-SEPARATOR}', ""); +Error('\p{Is_Category= Zp/a/}'); +Error('\P{Is_Category= Zp/a/}'); +Expect(1, 8233, '\p{Is_Category=zp}', ""); +Expect(0, 8233, '\p{^Is_Category=zp}', ""); +Expect(0, 8233, '\P{Is_Category=zp}', ""); +Expect(1, 8233, '\P{^Is_Category=zp}', ""); +Expect(0, 8232, '\p{Is_Category=zp}', ""); +Expect(1, 8232, '\p{^Is_Category=zp}', ""); +Expect(1, 8232, '\P{Is_Category=zp}', ""); +Expect(0, 8232, '\P{^Is_Category=zp}', ""); +Expect(1, 8233, '\p{Is_Category:_Zp}', ""); +Expect(0, 8233, '\p{^Is_Category:_Zp}', ""); +Expect(0, 8233, '\P{Is_Category:_Zp}', ""); +Expect(1, 8233, '\P{^Is_Category:_Zp}', ""); +Expect(0, 8232, '\p{Is_Category:_Zp}', ""); +Expect(1, 8232, '\p{^Is_Category:_Zp}', ""); +Expect(1, 8232, '\P{Is_Category:_Zp}', ""); +Expect(0, 8232, '\P{^Is_Category:_Zp}', ""); +Error('\p{General_Category=-Modifier-letter:=}'); +Error('\P{General_Category=-Modifier-letter:=}'); +Expect(1, 705, '\p{General_Category=modifierletter}', ""); +Expect(0, 705, '\p{^General_Category=modifierletter}', ""); +Expect(0, 705, '\P{General_Category=modifierletter}', ""); +Expect(1, 705, '\P{^General_Category=modifierletter}', ""); +Expect(0, 687, '\p{General_Category=modifierletter}', ""); +Expect(1, 687, '\p{^General_Category=modifierletter}', ""); +Expect(1, 687, '\P{General_Category=modifierletter}', ""); +Expect(0, 687, '\P{^General_Category=modifierletter}', ""); +Expect(1, 705, '\p{General_Category= ModifierLETTER}', ""); +Expect(0, 705, '\p{^General_Category= ModifierLETTER}', ""); +Expect(0, 705, '\P{General_Category= ModifierLETTER}', ""); +Expect(1, 705, '\P{^General_Category= ModifierLETTER}', ""); +Expect(0, 687, '\p{General_Category= ModifierLETTER}', ""); +Expect(1, 687, '\p{^General_Category= ModifierLETTER}', ""); +Expect(1, 687, '\P{General_Category= ModifierLETTER}', ""); +Expect(0, 687, '\P{^General_Category= ModifierLETTER}', ""); +Error('\p{Gc=/a/ -lm}'); +Error('\P{Gc=/a/ -lm}'); +Expect(1, 705, '\p{Gc=lm}', ""); +Expect(0, 705, '\p{^Gc=lm}', ""); +Expect(0, 705, '\P{Gc=lm}', ""); +Expect(1, 705, '\P{^Gc=lm}', ""); +Expect(0, 687, '\p{Gc=lm}', ""); +Expect(1, 687, '\p{^Gc=lm}', ""); +Expect(1, 687, '\P{Gc=lm}', ""); +Expect(0, 687, '\P{^Gc=lm}', ""); +Expect(1, 705, '\p{Gc: _LM}', ""); +Expect(0, 705, '\p{^Gc: _LM}', ""); +Expect(0, 705, '\P{Gc: _LM}', ""); +Expect(1, 705, '\P{^Gc: _LM}', ""); +Expect(0, 687, '\p{Gc: _LM}', ""); +Expect(1, 687, '\p{^Gc: _LM}', ""); +Expect(1, 687, '\P{Gc: _LM}', ""); +Expect(0, 687, '\P{^Gc: _LM}', ""); +Error('\p{Category= -modifier letter:=}'); +Error('\P{Category= -modifier letter:=}'); +Expect(1, 705, '\p{Category=modifierletter}', ""); +Expect(0, 705, '\p{^Category=modifierletter}', ""); +Expect(0, 705, '\P{Category=modifierletter}', ""); +Expect(1, 705, '\P{^Category=modifierletter}', ""); +Expect(0, 687, '\p{Category=modifierletter}', ""); +Expect(1, 687, '\p{^Category=modifierletter}', ""); +Expect(1, 687, '\P{Category=modifierletter}', ""); +Expect(0, 687, '\P{^Category=modifierletter}', ""); +Expect(1, 705, '\p{Category=__MODIFIER letter}', ""); +Expect(0, 705, '\p{^Category=__MODIFIER letter}', ""); +Expect(0, 705, '\P{Category=__MODIFIER letter}', ""); +Expect(1, 705, '\P{^Category=__MODIFIER letter}', ""); +Expect(0, 687, '\p{Category=__MODIFIER letter}', ""); +Expect(1, 687, '\p{^Category=__MODIFIER letter}', ""); +Expect(1, 687, '\P{Category=__MODIFIER letter}', ""); +Expect(0, 687, '\P{^Category=__MODIFIER letter}', ""); +Error('\p{Is_General_Category: _-LM/a/}'); +Error('\P{Is_General_Category: _-LM/a/}'); +Expect(1, 705, '\p{Is_General_Category: lm}', ""); +Expect(0, 705, '\p{^Is_General_Category: lm}', ""); +Expect(0, 705, '\P{Is_General_Category: lm}', ""); +Expect(1, 705, '\P{^Is_General_Category: lm}', ""); +Expect(0, 687, '\p{Is_General_Category: lm}', ""); +Expect(1, 687, '\p{^Is_General_Category: lm}', ""); +Expect(1, 687, '\P{Is_General_Category: lm}', ""); +Expect(0, 687, '\P{^Is_General_Category: lm}', ""); +Expect(1, 705, '\p{Is_General_Category=_LM}', ""); +Expect(0, 705, '\p{^Is_General_Category=_LM}', ""); +Expect(0, 705, '\P{Is_General_Category=_LM}', ""); +Expect(1, 705, '\P{^Is_General_Category=_LM}', ""); +Expect(0, 687, '\p{Is_General_Category=_LM}', ""); +Expect(1, 687, '\p{^Is_General_Category=_LM}', ""); +Expect(1, 687, '\P{Is_General_Category=_LM}', ""); +Expect(0, 687, '\P{^Is_General_Category=_LM}', ""); +Error('\p{Is_Gc=:=MODIFIER Letter}'); +Error('\P{Is_Gc=:=MODIFIER Letter}'); +Expect(1, 705, '\p{Is_Gc:modifierletter}', ""); +Expect(0, 705, '\p{^Is_Gc:modifierletter}', ""); +Expect(0, 705, '\P{Is_Gc:modifierletter}', ""); +Expect(1, 705, '\P{^Is_Gc:modifierletter}', ""); +Expect(0, 687, '\p{Is_Gc:modifierletter}', ""); +Expect(1, 687, '\p{^Is_Gc:modifierletter}', ""); +Expect(1, 687, '\P{Is_Gc:modifierletter}', ""); +Expect(0, 687, '\P{^Is_Gc:modifierletter}', ""); +Expect(1, 705, '\p{Is_Gc=Modifier letter}', ""); +Expect(0, 705, '\p{^Is_Gc=Modifier letter}', ""); +Expect(0, 705, '\P{Is_Gc=Modifier letter}', ""); +Expect(1, 705, '\P{^Is_Gc=Modifier letter}', ""); +Expect(0, 687, '\p{Is_Gc=Modifier letter}', ""); +Expect(1, 687, '\p{^Is_Gc=Modifier letter}', ""); +Expect(1, 687, '\P{Is_Gc=Modifier letter}', ""); +Expect(0, 687, '\P{^Is_Gc=Modifier letter}', ""); +Error('\p{Is_Category=-lm:=}'); +Error('\P{Is_Category=-lm:=}'); +Expect(1, 705, '\p{Is_Category=lm}', ""); +Expect(0, 705, '\p{^Is_Category=lm}', ""); +Expect(0, 705, '\P{Is_Category=lm}', ""); +Expect(1, 705, '\P{^Is_Category=lm}', ""); +Expect(0, 687, '\p{Is_Category=lm}', ""); +Expect(1, 687, '\p{^Is_Category=lm}', ""); +Expect(1, 687, '\P{Is_Category=lm}', ""); +Expect(0, 687, '\P{^Is_Category=lm}', ""); +Expect(1, 705, '\p{Is_Category= Lm}', ""); +Expect(0, 705, '\p{^Is_Category= Lm}', ""); +Expect(0, 705, '\P{Is_Category= Lm}', ""); +Expect(1, 705, '\P{^Is_Category= Lm}', ""); +Expect(0, 687, '\p{Is_Category= Lm}', ""); +Expect(1, 687, '\p{^Is_Category= Lm}', ""); +Expect(1, 687, '\P{Is_Category= Lm}', ""); +Expect(0, 687, '\P{^Is_Category= Lm}', ""); +Error('\p{General_Category: - OTHER/a/Symbol}'); +Error('\P{General_Category: - OTHER/a/Symbol}'); +Expect(1, 1154, '\p{General_Category=othersymbol}', ""); +Expect(0, 1154, '\p{^General_Category=othersymbol}', ""); +Expect(0, 1154, '\P{General_Category=othersymbol}', ""); +Expect(1, 1154, '\P{^General_Category=othersymbol}', ""); +Expect(0, 7, '\p{General_Category=othersymbol}', ""); +Expect(1, 7, '\p{^General_Category=othersymbol}', ""); +Expect(1, 7, '\P{General_Category=othersymbol}', ""); +Expect(0, 7, '\P{^General_Category=othersymbol}', ""); +Expect(1, 1154, '\p{General_Category=-Other-symbol}', ""); +Expect(0, 1154, '\p{^General_Category=-Other-symbol}', ""); +Expect(0, 1154, '\P{General_Category=-Other-symbol}', ""); +Expect(1, 1154, '\P{^General_Category=-Other-symbol}', ""); +Expect(0, 7, '\p{General_Category=-Other-symbol}', ""); +Expect(1, 7, '\p{^General_Category=-Other-symbol}', ""); +Expect(1, 7, '\P{General_Category=-Other-symbol}', ""); +Expect(0, 7, '\P{^General_Category=-Other-symbol}', ""); +Error('\p{Gc=-So:=}'); +Error('\P{Gc=-So:=}'); +Expect(1, 1154, '\p{Gc=so}', ""); +Expect(0, 1154, '\p{^Gc=so}', ""); +Expect(0, 1154, '\P{Gc=so}', ""); +Expect(1, 1154, '\P{^Gc=so}', ""); +Expect(0, 7, '\p{Gc=so}', ""); +Expect(1, 7, '\p{^Gc=so}', ""); +Expect(1, 7, '\P{Gc=so}', ""); +Expect(0, 7, '\P{^Gc=so}', ""); +Expect(1, 1154, '\p{Gc= SO}', ""); +Expect(0, 1154, '\p{^Gc= SO}', ""); +Expect(0, 1154, '\P{Gc= SO}', ""); +Expect(1, 1154, '\P{^Gc= SO}', ""); +Expect(0, 7, '\p{Gc= SO}', ""); +Expect(1, 7, '\p{^Gc= SO}', ""); +Expect(1, 7, '\P{Gc= SO}', ""); +Expect(0, 7, '\P{^Gc= SO}', ""); +Error('\p{Category=:=-Other Symbol}'); +Error('\P{Category=:=-Other Symbol}'); +Expect(1, 1154, '\p{Category=othersymbol}', ""); +Expect(0, 1154, '\p{^Category=othersymbol}', ""); +Expect(0, 1154, '\P{Category=othersymbol}', ""); +Expect(1, 1154, '\P{^Category=othersymbol}', ""); +Expect(0, 7, '\p{Category=othersymbol}', ""); +Expect(1, 7, '\p{^Category=othersymbol}', ""); +Expect(1, 7, '\P{Category=othersymbol}', ""); +Expect(0, 7, '\P{^Category=othersymbol}', ""); +Expect(1, 1154, '\p{Category=--OTHER-Symbol}', ""); +Expect(0, 1154, '\p{^Category=--OTHER-Symbol}', ""); +Expect(0, 1154, '\P{Category=--OTHER-Symbol}', ""); +Expect(1, 1154, '\P{^Category=--OTHER-Symbol}', ""); +Expect(0, 7, '\p{Category=--OTHER-Symbol}', ""); +Expect(1, 7, '\p{^Category=--OTHER-Symbol}', ""); +Expect(1, 7, '\P{Category=--OTHER-Symbol}', ""); +Expect(0, 7, '\P{^Category=--OTHER-Symbol}', ""); +Error('\p{Is_General_Category=:=-So}'); +Error('\P{Is_General_Category=:=-So}'); +Expect(1, 1154, '\p{Is_General_Category=so}', ""); +Expect(0, 1154, '\p{^Is_General_Category=so}', ""); +Expect(0, 1154, '\P{Is_General_Category=so}', ""); +Expect(1, 1154, '\P{^Is_General_Category=so}', ""); +Expect(0, 7, '\p{Is_General_Category=so}', ""); +Expect(1, 7, '\p{^Is_General_Category=so}', ""); +Expect(1, 7, '\P{Is_General_Category=so}', ""); +Expect(0, 7, '\P{^Is_General_Category=so}', ""); +Expect(1, 1154, '\p{Is_General_Category= -SO}', ""); +Expect(0, 1154, '\p{^Is_General_Category= -SO}', ""); +Expect(0, 1154, '\P{Is_General_Category= -SO}', ""); +Expect(1, 1154, '\P{^Is_General_Category= -SO}', ""); +Expect(0, 7, '\p{Is_General_Category= -SO}', ""); +Expect(1, 7, '\p{^Is_General_Category= -SO}', ""); +Expect(1, 7, '\P{Is_General_Category= -SO}', ""); +Expect(0, 7, '\P{^Is_General_Category= -SO}', ""); +Error('\p{Is_Gc=- Other/a/Symbol}'); +Error('\P{Is_Gc=- Other/a/Symbol}'); +Expect(1, 1154, '\p{Is_Gc: othersymbol}', ""); +Expect(0, 1154, '\p{^Is_Gc: othersymbol}', ""); +Expect(0, 1154, '\P{Is_Gc: othersymbol}', ""); +Expect(1, 1154, '\P{^Is_Gc: othersymbol}', ""); +Expect(0, 7, '\p{Is_Gc: othersymbol}', ""); +Expect(1, 7, '\p{^Is_Gc: othersymbol}', ""); +Expect(1, 7, '\P{Is_Gc: othersymbol}', ""); +Expect(0, 7, '\P{^Is_Gc: othersymbol}', ""); +Expect(1, 1154, '\p{Is_Gc=-Other symbol}', ""); +Expect(0, 1154, '\p{^Is_Gc=-Other symbol}', ""); +Expect(0, 1154, '\P{Is_Gc=-Other symbol}', ""); +Expect(1, 1154, '\P{^Is_Gc=-Other symbol}', ""); +Expect(0, 7, '\p{Is_Gc=-Other symbol}', ""); +Expect(1, 7, '\p{^Is_Gc=-Other symbol}', ""); +Expect(1, 7, '\P{Is_Gc=-Other symbol}', ""); +Expect(0, 7, '\P{^Is_Gc=-Other symbol}', ""); +Error('\p{Is_Category: :=so}'); +Error('\P{Is_Category: :=so}'); +Expect(1, 1154, '\p{Is_Category=so}', ""); +Expect(0, 1154, '\p{^Is_Category=so}', ""); +Expect(0, 1154, '\P{Is_Category=so}', ""); +Expect(1, 1154, '\P{^Is_Category=so}', ""); +Expect(0, 7, '\p{Is_Category=so}', ""); +Expect(1, 7, '\p{^Is_Category=so}', ""); +Expect(1, 7, '\P{Is_Category=so}', ""); +Expect(0, 7, '\P{^Is_Category=so}', ""); +Expect(1, 1154, '\p{Is_Category= so}', ""); +Expect(0, 1154, '\p{^Is_Category= so}', ""); +Expect(0, 1154, '\P{Is_Category= so}', ""); +Expect(1, 1154, '\P{^Is_Category= so}', ""); +Expect(0, 7, '\p{Is_Category= so}', ""); +Expect(1, 7, '\p{^Is_Category= so}', ""); +Expect(1, 7, '\P{Is_Category= so}', ""); +Expect(0, 7, '\P{^Is_Category= so}', ""); +Error('\p{General_Category= nonspacing mark/a/}'); +Error('\P{General_Category= nonspacing mark/a/}'); +Expect(1, 879, '\p{General_Category=nonspacingmark}', ""); +Expect(0, 879, '\p{^General_Category=nonspacingmark}', ""); +Expect(0, 879, '\P{General_Category=nonspacingmark}', ""); +Expect(1, 879, '\P{^General_Category=nonspacingmark}', ""); +Expect(0, 767, '\p{General_Category=nonspacingmark}', ""); +Expect(1, 767, '\p{^General_Category=nonspacingmark}', ""); +Expect(1, 767, '\P{General_Category=nonspacingmark}', ""); +Expect(0, 767, '\P{^General_Category=nonspacingmark}', ""); +Expect(1, 879, '\p{General_Category= -NONSPACING-Mark}', ""); +Expect(0, 879, '\p{^General_Category= -NONSPACING-Mark}', ""); +Expect(0, 879, '\P{General_Category= -NONSPACING-Mark}', ""); +Expect(1, 879, '\P{^General_Category= -NONSPACING-Mark}', ""); +Expect(0, 767, '\p{General_Category= -NONSPACING-Mark}', ""); +Expect(1, 767, '\p{^General_Category= -NONSPACING-Mark}', ""); +Expect(1, 767, '\P{General_Category= -NONSPACING-Mark}', ""); +Expect(0, 767, '\P{^General_Category= -NONSPACING-Mark}', ""); +Error('\p{Gc=-Mn:=}'); +Error('\P{Gc=-Mn:=}'); +Expect(1, 879, '\p{Gc=mn}', ""); +Expect(0, 879, '\p{^Gc=mn}', ""); +Expect(0, 879, '\P{Gc=mn}', ""); +Expect(1, 879, '\P{^Gc=mn}', ""); +Expect(0, 767, '\p{Gc=mn}', ""); +Expect(1, 767, '\p{^Gc=mn}', ""); +Expect(1, 767, '\P{Gc=mn}', ""); +Expect(0, 767, '\P{^Gc=mn}', ""); +Expect(1, 879, '\p{Gc= Mn}', ""); +Expect(0, 879, '\p{^Gc= Mn}', ""); +Expect(0, 879, '\P{Gc= Mn}', ""); +Expect(1, 879, '\P{^Gc= Mn}', ""); +Expect(0, 767, '\p{Gc= Mn}', ""); +Expect(1, 767, '\p{^Gc= Mn}', ""); +Expect(1, 767, '\P{Gc= Mn}', ""); +Expect(0, 767, '\P{^Gc= Mn}', ""); +Error('\p{Category=:=_nonspacing mark}'); +Error('\P{Category=:=_nonspacing mark}'); +Expect(1, 879, '\p{Category=nonspacingmark}', ""); +Expect(0, 879, '\p{^Category=nonspacingmark}', ""); +Expect(0, 879, '\P{Category=nonspacingmark}', ""); +Expect(1, 879, '\P{^Category=nonspacingmark}', ""); +Expect(0, 767, '\p{Category=nonspacingmark}', ""); +Expect(1, 767, '\p{^Category=nonspacingmark}', ""); +Expect(1, 767, '\P{Category=nonspacingmark}', ""); +Expect(0, 767, '\P{^Category=nonspacingmark}', ""); +Expect(1, 879, '\p{Category= nonspacing Mark}', ""); +Expect(0, 879, '\p{^Category= nonspacing Mark}', ""); +Expect(0, 879, '\P{Category= nonspacing Mark}', ""); +Expect(1, 879, '\P{^Category= nonspacing Mark}', ""); +Expect(0, 767, '\p{Category= nonspacing Mark}', ""); +Expect(1, 767, '\p{^Category= nonspacing Mark}', ""); +Expect(1, 767, '\P{Category= nonspacing Mark}', ""); +Expect(0, 767, '\P{^Category= nonspacing Mark}', ""); +Error('\p{Is_General_Category= Mn/a/}'); +Error('\P{Is_General_Category= Mn/a/}'); +Expect(1, 879, '\p{Is_General_Category=mn}', ""); +Expect(0, 879, '\p{^Is_General_Category=mn}', ""); +Expect(0, 879, '\P{Is_General_Category=mn}', ""); +Expect(1, 879, '\P{^Is_General_Category=mn}', ""); +Expect(0, 767, '\p{Is_General_Category=mn}', ""); +Expect(1, 767, '\p{^Is_General_Category=mn}', ""); +Expect(1, 767, '\P{Is_General_Category=mn}', ""); +Expect(0, 767, '\P{^Is_General_Category=mn}', ""); +Expect(1, 879, '\p{Is_General_Category= mn}', ""); +Expect(0, 879, '\p{^Is_General_Category= mn}', ""); +Expect(0, 879, '\P{Is_General_Category= mn}', ""); +Expect(1, 879, '\P{^Is_General_Category= mn}', ""); +Expect(0, 767, '\p{Is_General_Category= mn}', ""); +Expect(1, 767, '\p{^Is_General_Category= mn}', ""); +Expect(1, 767, '\P{Is_General_Category= mn}', ""); +Expect(0, 767, '\P{^Is_General_Category= mn}', ""); +Error('\p{Is_Gc= /a/Nonspacing Mark}'); +Error('\P{Is_Gc= /a/Nonspacing Mark}'); +Expect(1, 879, '\p{Is_Gc=nonspacingmark}', ""); +Expect(0, 879, '\p{^Is_Gc=nonspacingmark}', ""); +Expect(0, 879, '\P{Is_Gc=nonspacingmark}', ""); +Expect(1, 879, '\P{^Is_Gc=nonspacingmark}', ""); +Expect(0, 767, '\p{Is_Gc=nonspacingmark}', ""); +Expect(1, 767, '\p{^Is_Gc=nonspacingmark}', ""); +Expect(1, 767, '\P{Is_Gc=nonspacingmark}', ""); +Expect(0, 767, '\P{^Is_Gc=nonspacingmark}', ""); +Expect(1, 879, '\p{Is_Gc= nonspacing mark}', ""); +Expect(0, 879, '\p{^Is_Gc= nonspacing mark}', ""); +Expect(0, 879, '\P{Is_Gc= nonspacing mark}', ""); +Expect(1, 879, '\P{^Is_Gc= nonspacing mark}', ""); +Expect(0, 767, '\p{Is_Gc= nonspacing mark}', ""); +Expect(1, 767, '\p{^Is_Gc= nonspacing mark}', ""); +Expect(1, 767, '\P{Is_Gc= nonspacing mark}', ""); +Expect(0, 767, '\P{^Is_Gc= nonspacing mark}', ""); +Error('\p{Is_Category=:=Mn}'); +Error('\P{Is_Category=:=Mn}'); +Expect(1, 879, '\p{Is_Category=mn}', ""); +Expect(0, 879, '\p{^Is_Category=mn}', ""); +Expect(0, 879, '\P{Is_Category=mn}', ""); +Expect(1, 879, '\P{^Is_Category=mn}', ""); +Expect(0, 767, '\p{Is_Category=mn}', ""); +Expect(1, 767, '\p{^Is_Category=mn}', ""); +Expect(1, 767, '\P{Is_Category=mn}', ""); +Expect(0, 767, '\P{^Is_Category=mn}', ""); +Expect(1, 879, '\p{Is_Category= -Mn}', ""); +Expect(0, 879, '\p{^Is_Category= -Mn}', ""); +Expect(0, 879, '\P{Is_Category= -Mn}', ""); +Expect(1, 879, '\P{^Is_Category= -Mn}', ""); +Expect(0, 767, '\p{Is_Category= -Mn}', ""); +Expect(1, 767, '\p{^Is_Category= -Mn}', ""); +Expect(1, 767, '\P{Is_Category= -Mn}', ""); +Expect(0, 767, '\P{^Is_Category= -Mn}', ""); +Error('\p{General_Category=- Dash:=Punctuation}'); +Error('\P{General_Category=- Dash:=Punctuation}'); +Expect(1, 45, '\p{General_Category=dashpunctuation}', ""); +Expect(0, 45, '\p{^General_Category=dashpunctuation}', ""); +Expect(0, 45, '\P{General_Category=dashpunctuation}', ""); +Expect(1, 45, '\P{^General_Category=dashpunctuation}', ""); +Expect(0, 44, '\p{General_Category=dashpunctuation}', ""); +Expect(1, 44, '\p{^General_Category=dashpunctuation}', ""); +Expect(1, 44, '\P{General_Category=dashpunctuation}', ""); +Expect(0, 44, '\P{^General_Category=dashpunctuation}', ""); +Expect(1, 45, '\p{General_Category= Dash Punctuation}', ""); +Expect(0, 45, '\p{^General_Category= Dash Punctuation}', ""); +Expect(0, 45, '\P{General_Category= Dash Punctuation}', ""); +Expect(1, 45, '\P{^General_Category= Dash Punctuation}', ""); +Expect(0, 44, '\p{General_Category= Dash Punctuation}', ""); +Expect(1, 44, '\p{^General_Category= Dash Punctuation}', ""); +Expect(1, 44, '\P{General_Category= Dash Punctuation}', ""); +Expect(0, 44, '\P{^General_Category= Dash Punctuation}', ""); +Error('\p{Gc=- Pd:=}'); +Error('\P{Gc=- Pd:=}'); +Expect(1, 45, '\p{Gc=pd}', ""); +Expect(0, 45, '\p{^Gc=pd}', ""); +Expect(0, 45, '\P{Gc=pd}', ""); +Expect(1, 45, '\P{^Gc=pd}', ""); +Expect(0, 44, '\p{Gc=pd}', ""); +Expect(1, 44, '\p{^Gc=pd}', ""); +Expect(1, 44, '\P{Gc=pd}', ""); +Expect(0, 44, '\P{^Gc=pd}', ""); +Expect(1, 45, '\p{Gc= Pd}', ""); +Expect(0, 45, '\p{^Gc= Pd}', ""); +Expect(0, 45, '\P{Gc= Pd}', ""); +Expect(1, 45, '\P{^Gc= Pd}', ""); +Expect(0, 44, '\p{Gc= Pd}', ""); +Expect(1, 44, '\p{^Gc= Pd}', ""); +Expect(1, 44, '\P{Gc= Pd}', ""); +Expect(0, 44, '\P{^Gc= Pd}', ""); +Error('\p{Category=:=__dash punctuation}'); +Error('\P{Category=:=__dash punctuation}'); +Expect(1, 45, '\p{Category=dashpunctuation}', ""); +Expect(0, 45, '\p{^Category=dashpunctuation}', ""); +Expect(0, 45, '\P{Category=dashpunctuation}', ""); +Expect(1, 45, '\P{^Category=dashpunctuation}', ""); +Expect(0, 44, '\p{Category=dashpunctuation}', ""); +Expect(1, 44, '\p{^Category=dashpunctuation}', ""); +Expect(1, 44, '\P{Category=dashpunctuation}', ""); +Expect(0, 44, '\P{^Category=dashpunctuation}', ""); +Expect(1, 45, '\p{Category: _DASH Punctuation}', ""); +Expect(0, 45, '\p{^Category: _DASH Punctuation}', ""); +Expect(0, 45, '\P{Category: _DASH Punctuation}', ""); +Expect(1, 45, '\P{^Category: _DASH Punctuation}', ""); +Expect(0, 44, '\p{Category: _DASH Punctuation}', ""); +Expect(1, 44, '\p{^Category: _DASH Punctuation}', ""); +Expect(1, 44, '\P{Category: _DASH Punctuation}', ""); +Expect(0, 44, '\P{^Category: _DASH Punctuation}', ""); +Error('\p{Is_General_Category= /a/pd}'); +Error('\P{Is_General_Category= /a/pd}'); +Expect(1, 45, '\p{Is_General_Category=pd}', ""); +Expect(0, 45, '\p{^Is_General_Category=pd}', ""); +Expect(0, 45, '\P{Is_General_Category=pd}', ""); +Expect(1, 45, '\P{^Is_General_Category=pd}', ""); +Expect(0, 44, '\p{Is_General_Category=pd}', ""); +Expect(1, 44, '\p{^Is_General_Category=pd}', ""); +Expect(1, 44, '\P{Is_General_Category=pd}', ""); +Expect(0, 44, '\P{^Is_General_Category=pd}', ""); +Expect(1, 45, '\p{Is_General_Category: - pd}', ""); +Expect(0, 45, '\p{^Is_General_Category: - pd}', ""); +Expect(0, 45, '\P{Is_General_Category: - pd}', ""); +Expect(1, 45, '\P{^Is_General_Category: - pd}', ""); +Expect(0, 44, '\p{Is_General_Category: - pd}', ""); +Expect(1, 44, '\p{^Is_General_Category: - pd}', ""); +Expect(1, 44, '\P{Is_General_Category: - pd}', ""); +Expect(0, 44, '\P{^Is_General_Category: - pd}', ""); +Error('\p{Is_Gc= Dash Punctuation/a/}'); +Error('\P{Is_Gc= Dash Punctuation/a/}'); +Expect(1, 45, '\p{Is_Gc=dashpunctuation}', ""); +Expect(0, 45, '\p{^Is_Gc=dashpunctuation}', ""); +Expect(0, 45, '\P{Is_Gc=dashpunctuation}', ""); +Expect(1, 45, '\P{^Is_Gc=dashpunctuation}', ""); +Expect(0, 44, '\p{Is_Gc=dashpunctuation}', ""); +Expect(1, 44, '\p{^Is_Gc=dashpunctuation}', ""); +Expect(1, 44, '\P{Is_Gc=dashpunctuation}', ""); +Expect(0, 44, '\P{^Is_Gc=dashpunctuation}', ""); +Expect(1, 45, '\p{Is_Gc=_dash-punctuation}', ""); +Expect(0, 45, '\p{^Is_Gc=_dash-punctuation}', ""); +Expect(0, 45, '\P{Is_Gc=_dash-punctuation}', ""); +Expect(1, 45, '\P{^Is_Gc=_dash-punctuation}', ""); +Expect(0, 44, '\p{Is_Gc=_dash-punctuation}', ""); +Expect(1, 44, '\p{^Is_Gc=_dash-punctuation}', ""); +Expect(1, 44, '\P{Is_Gc=_dash-punctuation}', ""); +Expect(0, 44, '\P{^Is_Gc=_dash-punctuation}', ""); +Error('\p{Is_Category= Pd/a/}'); +Error('\P{Is_Category= Pd/a/}'); +Expect(1, 45, '\p{Is_Category=pd}', ""); +Expect(0, 45, '\p{^Is_Category=pd}', ""); +Expect(0, 45, '\P{Is_Category=pd}', ""); +Expect(1, 45, '\P{^Is_Category=pd}', ""); +Expect(0, 44, '\p{Is_Category=pd}', ""); +Expect(1, 44, '\p{^Is_Category=pd}', ""); +Expect(1, 44, '\P{Is_Category=pd}', ""); +Expect(0, 44, '\P{^Is_Category=pd}', ""); +Expect(1, 45, '\p{Is_Category=_Pd}', ""); +Expect(0, 45, '\p{^Is_Category=_Pd}', ""); +Expect(0, 45, '\P{Is_Category=_Pd}', ""); +Expect(1, 45, '\P{^Is_Category=_Pd}', ""); +Expect(0, 44, '\p{Is_Category=_Pd}', ""); +Expect(1, 44, '\p{^Is_Category=_Pd}', ""); +Expect(1, 44, '\P{Is_Category=_Pd}', ""); +Expect(0, 44, '\P{^Is_Category=_Pd}', ""); +Error('\p{General_Category=/a/- letter-Number}'); +Error('\P{General_Category=/a/- letter-Number}'); +Expect(1, 5872, '\p{General_Category=letternumber}', ""); +Expect(0, 5872, '\p{^General_Category=letternumber}', ""); +Expect(0, 5872, '\P{General_Category=letternumber}', ""); +Expect(1, 5872, '\P{^General_Category=letternumber}', ""); +Expect(0, 5869, '\p{General_Category=letternumber}', ""); +Expect(1, 5869, '\p{^General_Category=letternumber}', ""); +Expect(1, 5869, '\P{General_Category=letternumber}', ""); +Expect(0, 5869, '\P{^General_Category=letternumber}', ""); +Expect(1, 5872, '\p{General_Category= -LetterNUMBER}', ""); +Expect(0, 5872, '\p{^General_Category= -LetterNUMBER}', ""); +Expect(0, 5872, '\P{General_Category= -LetterNUMBER}', ""); +Expect(1, 5872, '\P{^General_Category= -LetterNUMBER}', ""); +Expect(0, 5869, '\p{General_Category= -LetterNUMBER}', ""); +Expect(1, 5869, '\p{^General_Category= -LetterNUMBER}', ""); +Expect(1, 5869, '\P{General_Category= -LetterNUMBER}', ""); +Expect(0, 5869, '\P{^General_Category= -LetterNUMBER}', ""); +Error('\p{Gc=/a/-_Nl}'); +Error('\P{Gc=/a/-_Nl}'); +Expect(1, 5872, '\p{Gc: nl}', ""); +Expect(0, 5872, '\p{^Gc: nl}', ""); +Expect(0, 5872, '\P{Gc: nl}', ""); +Expect(1, 5872, '\P{^Gc: nl}', ""); +Expect(0, 5869, '\p{Gc: nl}', ""); +Expect(1, 5869, '\p{^Gc: nl}', ""); +Expect(1, 5869, '\P{Gc: nl}', ""); +Expect(0, 5869, '\P{^Gc: nl}', ""); +Expect(1, 5872, '\p{Gc= _NL}', ""); +Expect(0, 5872, '\p{^Gc= _NL}', ""); +Expect(0, 5872, '\P{Gc= _NL}', ""); +Expect(1, 5872, '\P{^Gc= _NL}', ""); +Expect(0, 5869, '\p{Gc= _NL}', ""); +Expect(1, 5869, '\p{^Gc= _NL}', ""); +Expect(1, 5869, '\P{Gc= _NL}', ""); +Expect(0, 5869, '\P{^Gc= _NL}', ""); +Error('\p{Category: :=- LETTER-Number}'); +Error('\P{Category: :=- LETTER-Number}'); +Expect(1, 5872, '\p{Category=letternumber}', ""); +Expect(0, 5872, '\p{^Category=letternumber}', ""); +Expect(0, 5872, '\P{Category=letternumber}', ""); +Expect(1, 5872, '\P{^Category=letternumber}', ""); +Expect(0, 5869, '\p{Category=letternumber}', ""); +Expect(1, 5869, '\p{^Category=letternumber}', ""); +Expect(1, 5869, '\P{Category=letternumber}', ""); +Expect(0, 5869, '\P{^Category=letternumber}', ""); +Expect(1, 5872, '\p{Category=-letter Number}', ""); +Expect(0, 5872, '\p{^Category=-letter Number}', ""); +Expect(0, 5872, '\P{Category=-letter Number}', ""); +Expect(1, 5872, '\P{^Category=-letter Number}', ""); +Expect(0, 5869, '\p{Category=-letter Number}', ""); +Expect(1, 5869, '\p{^Category=-letter Number}', ""); +Expect(1, 5869, '\P{Category=-letter Number}', ""); +Expect(0, 5869, '\P{^Category=-letter Number}', ""); +Error('\p{Is_General_Category= nl/a/}'); +Error('\P{Is_General_Category= nl/a/}'); +Expect(1, 5872, '\p{Is_General_Category=nl}', ""); +Expect(0, 5872, '\p{^Is_General_Category=nl}', ""); +Expect(0, 5872, '\P{Is_General_Category=nl}', ""); +Expect(1, 5872, '\P{^Is_General_Category=nl}', ""); +Expect(0, 5869, '\p{Is_General_Category=nl}', ""); +Expect(1, 5869, '\p{^Is_General_Category=nl}', ""); +Expect(1, 5869, '\P{Is_General_Category=nl}', ""); +Expect(0, 5869, '\P{^Is_General_Category=nl}', ""); +Expect(1, 5872, '\p{Is_General_Category= nl}', ""); +Expect(0, 5872, '\p{^Is_General_Category= nl}', ""); +Expect(0, 5872, '\P{Is_General_Category= nl}', ""); +Expect(1, 5872, '\P{^Is_General_Category= nl}', ""); +Expect(0, 5869, '\p{Is_General_Category= nl}', ""); +Expect(1, 5869, '\p{^Is_General_Category= nl}', ""); +Expect(1, 5869, '\P{Is_General_Category= nl}', ""); +Expect(0, 5869, '\P{^Is_General_Category= nl}', ""); +Error('\p{Is_Gc= letter/a/Number}'); +Error('\P{Is_Gc= letter/a/Number}'); +Expect(1, 5872, '\p{Is_Gc=letternumber}', ""); +Expect(0, 5872, '\p{^Is_Gc=letternumber}', ""); +Expect(0, 5872, '\P{Is_Gc=letternumber}', ""); +Expect(1, 5872, '\P{^Is_Gc=letternumber}', ""); +Expect(0, 5869, '\p{Is_Gc=letternumber}', ""); +Expect(1, 5869, '\p{^Is_Gc=letternumber}', ""); +Expect(1, 5869, '\P{Is_Gc=letternumber}', ""); +Expect(0, 5869, '\P{^Is_Gc=letternumber}', ""); +Expect(1, 5872, '\p{Is_Gc=_ Letter_NUMBER}', ""); +Expect(0, 5872, '\p{^Is_Gc=_ Letter_NUMBER}', ""); +Expect(0, 5872, '\P{Is_Gc=_ Letter_NUMBER}', ""); +Expect(1, 5872, '\P{^Is_Gc=_ Letter_NUMBER}', ""); +Expect(0, 5869, '\p{Is_Gc=_ Letter_NUMBER}', ""); +Expect(1, 5869, '\p{^Is_Gc=_ Letter_NUMBER}', ""); +Expect(1, 5869, '\P{Is_Gc=_ Letter_NUMBER}', ""); +Expect(0, 5869, '\P{^Is_Gc=_ Letter_NUMBER}', ""); +Error('\p{Is_Category= -NL:=}'); +Error('\P{Is_Category= -NL:=}'); +Expect(1, 5872, '\p{Is_Category=nl}', ""); +Expect(0, 5872, '\p{^Is_Category=nl}', ""); +Expect(0, 5872, '\P{Is_Category=nl}', ""); +Expect(1, 5872, '\P{^Is_Category=nl}', ""); +Expect(0, 5869, '\p{Is_Category=nl}', ""); +Expect(1, 5869, '\p{^Is_Category=nl}', ""); +Expect(1, 5869, '\P{Is_Category=nl}', ""); +Expect(0, 5869, '\P{^Is_Category=nl}', ""); +Expect(1, 5872, '\p{Is_Category: nl}', ""); +Expect(0, 5872, '\p{^Is_Category: nl}', ""); +Expect(0, 5872, '\P{Is_Category: nl}', ""); +Expect(1, 5872, '\P{^Is_Category: nl}', ""); +Expect(0, 5869, '\p{Is_Category: nl}', ""); +Expect(1, 5869, '\p{^Is_Category: nl}', ""); +Expect(1, 5869, '\P{Is_Category: nl}', ""); +Expect(0, 5869, '\P{^Is_Category: nl}', ""); +Error('\p{General_Category=:= InitialPUNCTUATION}'); +Error('\P{General_Category=:= InitialPUNCTUATION}'); +Expect(1, 8216, '\p{General_Category=initialpunctuation}', ""); +Expect(0, 8216, '\p{^General_Category=initialpunctuation}', ""); +Expect(0, 8216, '\P{General_Category=initialpunctuation}', ""); +Expect(1, 8216, '\P{^General_Category=initialpunctuation}', ""); +Expect(0, 7, '\p{General_Category=initialpunctuation}', ""); +Expect(1, 7, '\p{^General_Category=initialpunctuation}', ""); +Expect(1, 7, '\P{General_Category=initialpunctuation}', ""); +Expect(0, 7, '\P{^General_Category=initialpunctuation}', ""); +Expect(1, 8216, '\p{General_Category=_-Initial Punctuation}', ""); +Expect(0, 8216, '\p{^General_Category=_-Initial Punctuation}', ""); +Expect(0, 8216, '\P{General_Category=_-Initial Punctuation}', ""); +Expect(1, 8216, '\P{^General_Category=_-Initial Punctuation}', ""); +Expect(0, 7, '\p{General_Category=_-Initial Punctuation}', ""); +Expect(1, 7, '\p{^General_Category=_-Initial Punctuation}', ""); +Expect(1, 7, '\P{General_Category=_-Initial Punctuation}', ""); +Expect(0, 7, '\P{^General_Category=_-Initial Punctuation}', ""); +Error('\p{Gc=_/a/PI}'); +Error('\P{Gc=_/a/PI}'); +Expect(1, 8216, '\p{Gc=pi}', ""); +Expect(0, 8216, '\p{^Gc=pi}', ""); +Expect(0, 8216, '\P{Gc=pi}', ""); +Expect(1, 8216, '\P{^Gc=pi}', ""); +Expect(0, 7, '\p{Gc=pi}', ""); +Expect(1, 7, '\p{^Gc=pi}', ""); +Expect(1, 7, '\P{Gc=pi}', ""); +Expect(0, 7, '\P{^Gc=pi}', ""); +Expect(1, 8216, '\p{Gc:_-PI}', ""); +Expect(0, 8216, '\p{^Gc:_-PI}', ""); +Expect(0, 8216, '\P{Gc:_-PI}', ""); +Expect(1, 8216, '\P{^Gc:_-PI}', ""); +Expect(0, 7, '\p{Gc:_-PI}', ""); +Expect(1, 7, '\p{^Gc:_-PI}', ""); +Expect(1, 7, '\P{Gc:_-PI}', ""); +Expect(0, 7, '\P{^Gc:_-PI}', ""); +Error('\p{Category=- initial:=Punctuation}'); +Error('\P{Category=- initial:=Punctuation}'); +Expect(1, 8216, '\p{Category=initialpunctuation}', ""); +Expect(0, 8216, '\p{^Category=initialpunctuation}', ""); +Expect(0, 8216, '\P{Category=initialpunctuation}', ""); +Expect(1, 8216, '\P{^Category=initialpunctuation}', ""); +Expect(0, 7, '\p{Category=initialpunctuation}', ""); +Expect(1, 7, '\p{^Category=initialpunctuation}', ""); +Expect(1, 7, '\P{Category=initialpunctuation}', ""); +Expect(0, 7, '\P{^Category=initialpunctuation}', ""); +Expect(1, 8216, '\p{Category= Initial-PUNCTUATION}', ""); +Expect(0, 8216, '\p{^Category= Initial-PUNCTUATION}', ""); +Expect(0, 8216, '\P{Category= Initial-PUNCTUATION}', ""); +Expect(1, 8216, '\P{^Category= Initial-PUNCTUATION}', ""); +Expect(0, 7, '\p{Category= Initial-PUNCTUATION}', ""); +Expect(1, 7, '\p{^Category= Initial-PUNCTUATION}', ""); +Expect(1, 7, '\P{Category= Initial-PUNCTUATION}', ""); +Expect(0, 7, '\P{^Category= Initial-PUNCTUATION}', ""); +Error('\p{Is_General_Category=-:=Pi}'); +Error('\P{Is_General_Category=-:=Pi}'); +Expect(1, 8216, '\p{Is_General_Category=pi}', ""); +Expect(0, 8216, '\p{^Is_General_Category=pi}', ""); +Expect(0, 8216, '\P{Is_General_Category=pi}', ""); +Expect(1, 8216, '\P{^Is_General_Category=pi}', ""); +Expect(0, 7, '\p{Is_General_Category=pi}', ""); +Expect(1, 7, '\p{^Is_General_Category=pi}', ""); +Expect(1, 7, '\P{Is_General_Category=pi}', ""); +Expect(0, 7, '\P{^Is_General_Category=pi}', ""); +Expect(1, 8216, '\p{Is_General_Category:- pi}', ""); +Expect(0, 8216, '\p{^Is_General_Category:- pi}', ""); +Expect(0, 8216, '\P{Is_General_Category:- pi}', ""); +Expect(1, 8216, '\P{^Is_General_Category:- pi}', ""); +Expect(0, 7, '\p{Is_General_Category:- pi}', ""); +Expect(1, 7, '\p{^Is_General_Category:- pi}', ""); +Expect(1, 7, '\P{Is_General_Category:- pi}', ""); +Expect(0, 7, '\P{^Is_General_Category:- pi}', ""); +Error('\p{Is_Gc=:=-InitialPunctuation}'); +Error('\P{Is_Gc=:=-InitialPunctuation}'); +Expect(1, 8216, '\p{Is_Gc=initialpunctuation}', ""); +Expect(0, 8216, '\p{^Is_Gc=initialpunctuation}', ""); +Expect(0, 8216, '\P{Is_Gc=initialpunctuation}', ""); +Expect(1, 8216, '\P{^Is_Gc=initialpunctuation}', ""); +Expect(0, 7, '\p{Is_Gc=initialpunctuation}', ""); +Expect(1, 7, '\p{^Is_Gc=initialpunctuation}', ""); +Expect(1, 7, '\P{Is_Gc=initialpunctuation}', ""); +Expect(0, 7, '\P{^Is_Gc=initialpunctuation}', ""); +Expect(1, 8216, '\p{Is_Gc=__INITIAL_Punctuation}', ""); +Expect(0, 8216, '\p{^Is_Gc=__INITIAL_Punctuation}', ""); +Expect(0, 8216, '\P{Is_Gc=__INITIAL_Punctuation}', ""); +Expect(1, 8216, '\P{^Is_Gc=__INITIAL_Punctuation}', ""); +Expect(0, 7, '\p{Is_Gc=__INITIAL_Punctuation}', ""); +Expect(1, 7, '\p{^Is_Gc=__INITIAL_Punctuation}', ""); +Expect(1, 7, '\P{Is_Gc=__INITIAL_Punctuation}', ""); +Expect(0, 7, '\P{^Is_Gc=__INITIAL_Punctuation}', ""); +Error('\p{Is_Category= pi/a/}'); +Error('\P{Is_Category= pi/a/}'); +Expect(1, 8216, '\p{Is_Category:pi}', ""); +Expect(0, 8216, '\p{^Is_Category:pi}', ""); +Expect(0, 8216, '\P{Is_Category:pi}', ""); +Expect(1, 8216, '\P{^Is_Category:pi}', ""); +Expect(0, 7, '\p{Is_Category:pi}', ""); +Expect(1, 7, '\p{^Is_Category:pi}', ""); +Expect(1, 7, '\P{Is_Category:pi}', ""); +Expect(0, 7, '\P{^Is_Category:pi}', ""); +Expect(1, 8216, '\p{Is_Category= pi}', ""); +Expect(0, 8216, '\p{^Is_Category= pi}', ""); +Expect(0, 8216, '\P{Is_Category= pi}', ""); +Expect(1, 8216, '\P{^Is_Category= pi}', ""); +Expect(0, 7, '\p{Is_Category= pi}', ""); +Expect(1, 7, '\p{^Is_Category= pi}', ""); +Expect(1, 7, '\P{Is_Category= pi}', ""); +Expect(0, 7, '\P{^Is_Category= pi}', ""); +Error('\p{General_Category=_Currency/a/SYMBOL}'); +Error('\P{General_Category=_Currency/a/SYMBOL}'); +Expect(1, 36, '\p{General_Category=currencysymbol}', ""); +Expect(0, 36, '\p{^General_Category=currencysymbol}', ""); +Expect(0, 36, '\P{General_Category=currencysymbol}', ""); +Expect(1, 36, '\P{^General_Category=currencysymbol}', ""); +Expect(0, 35, '\p{General_Category=currencysymbol}', ""); +Expect(1, 35, '\p{^General_Category=currencysymbol}', ""); +Expect(1, 35, '\P{General_Category=currencysymbol}', ""); +Expect(0, 35, '\P{^General_Category=currencysymbol}', ""); +Expect(1, 36, '\p{General_Category= _currency symbol}', ""); +Expect(0, 36, '\p{^General_Category= _currency symbol}', ""); +Expect(0, 36, '\P{General_Category= _currency symbol}', ""); +Expect(1, 36, '\P{^General_Category= _currency symbol}', ""); +Expect(0, 35, '\p{General_Category= _currency symbol}', ""); +Expect(1, 35, '\p{^General_Category= _currency symbol}', ""); +Expect(1, 35, '\P{General_Category= _currency symbol}', ""); +Expect(0, 35, '\P{^General_Category= _currency symbol}', ""); +Error('\p{Gc=:=- Sc}'); +Error('\P{Gc=:=- Sc}'); +Expect(1, 36, '\p{Gc: sc}', ""); +Expect(0, 36, '\p{^Gc: sc}', ""); +Expect(0, 36, '\P{Gc: sc}', ""); +Expect(1, 36, '\P{^Gc: sc}', ""); +Expect(0, 35, '\p{Gc: sc}', ""); +Expect(1, 35, '\p{^Gc: sc}', ""); +Expect(1, 35, '\P{Gc: sc}', ""); +Expect(0, 35, '\P{^Gc: sc}', ""); +Expect(1, 36, '\p{Gc=_sc}', ""); +Expect(0, 36, '\p{^Gc=_sc}', ""); +Expect(0, 36, '\P{Gc=_sc}', ""); +Expect(1, 36, '\P{^Gc=_sc}', ""); +Expect(0, 35, '\p{Gc=_sc}', ""); +Expect(1, 35, '\p{^Gc=_sc}', ""); +Expect(1, 35, '\P{Gc=_sc}', ""); +Expect(0, 35, '\P{^Gc=_sc}', ""); +Error('\p{Category=:=Currency-Symbol}'); +Error('\P{Category=:=Currency-Symbol}'); +Expect(1, 36, '\p{Category=currencysymbol}', ""); +Expect(0, 36, '\p{^Category=currencysymbol}', ""); +Expect(0, 36, '\P{Category=currencysymbol}', ""); +Expect(1, 36, '\P{^Category=currencysymbol}', ""); +Expect(0, 35, '\p{Category=currencysymbol}', ""); +Expect(1, 35, '\p{^Category=currencysymbol}', ""); +Expect(1, 35, '\P{Category=currencysymbol}', ""); +Expect(0, 35, '\P{^Category=currencysymbol}', ""); +Expect(1, 36, '\p{Category=- Currency-Symbol}', ""); +Expect(0, 36, '\p{^Category=- Currency-Symbol}', ""); +Expect(0, 36, '\P{Category=- Currency-Symbol}', ""); +Expect(1, 36, '\P{^Category=- Currency-Symbol}', ""); +Expect(0, 35, '\p{Category=- Currency-Symbol}', ""); +Expect(1, 35, '\p{^Category=- Currency-Symbol}', ""); +Expect(1, 35, '\P{Category=- Currency-Symbol}', ""); +Expect(0, 35, '\P{^Category=- Currency-Symbol}', ""); +Error('\p{Is_General_Category=:=_ sc}'); +Error('\P{Is_General_Category=:=_ sc}'); +Expect(1, 36, '\p{Is_General_Category: sc}', ""); +Expect(0, 36, '\p{^Is_General_Category: sc}', ""); +Expect(0, 36, '\P{Is_General_Category: sc}', ""); +Expect(1, 36, '\P{^Is_General_Category: sc}', ""); +Expect(0, 35, '\p{Is_General_Category: sc}', ""); +Expect(1, 35, '\p{^Is_General_Category: sc}', ""); +Expect(1, 35, '\P{Is_General_Category: sc}', ""); +Expect(0, 35, '\P{^Is_General_Category: sc}', ""); +Expect(1, 36, '\p{Is_General_Category= sc}', ""); +Expect(0, 36, '\p{^Is_General_Category= sc}', ""); +Expect(0, 36, '\P{Is_General_Category= sc}', ""); +Expect(1, 36, '\P{^Is_General_Category= sc}', ""); +Expect(0, 35, '\p{Is_General_Category= sc}', ""); +Expect(1, 35, '\p{^Is_General_Category= sc}', ""); +Expect(1, 35, '\P{Is_General_Category= sc}', ""); +Expect(0, 35, '\P{^Is_General_Category= sc}', ""); +Error('\p{Is_Gc: _Currency_symbol:=}'); +Error('\P{Is_Gc: _Currency_symbol:=}'); +Expect(1, 36, '\p{Is_Gc=currencysymbol}', ""); +Expect(0, 36, '\p{^Is_Gc=currencysymbol}', ""); +Expect(0, 36, '\P{Is_Gc=currencysymbol}', ""); +Expect(1, 36, '\P{^Is_Gc=currencysymbol}', ""); +Expect(0, 35, '\p{Is_Gc=currencysymbol}', ""); +Expect(1, 35, '\p{^Is_Gc=currencysymbol}', ""); +Expect(1, 35, '\P{Is_Gc=currencysymbol}', ""); +Expect(0, 35, '\P{^Is_Gc=currencysymbol}', ""); +Expect(1, 36, '\p{Is_Gc=__CURRENCY symbol}', ""); +Expect(0, 36, '\p{^Is_Gc=__CURRENCY symbol}', ""); +Expect(0, 36, '\P{Is_Gc=__CURRENCY symbol}', ""); +Expect(1, 36, '\P{^Is_Gc=__CURRENCY symbol}', ""); +Expect(0, 35, '\p{Is_Gc=__CURRENCY symbol}', ""); +Expect(1, 35, '\p{^Is_Gc=__CURRENCY symbol}', ""); +Expect(1, 35, '\P{Is_Gc=__CURRENCY symbol}', ""); +Expect(0, 35, '\P{^Is_Gc=__CURRENCY symbol}', ""); +Error('\p{Is_Category= sc:=}'); +Error('\P{Is_Category= sc:=}'); +Expect(1, 36, '\p{Is_Category=sc}', ""); +Expect(0, 36, '\p{^Is_Category=sc}', ""); +Expect(0, 36, '\P{Is_Category=sc}', ""); +Expect(1, 36, '\P{^Is_Category=sc}', ""); +Expect(0, 35, '\p{Is_Category=sc}', ""); +Expect(1, 35, '\p{^Is_Category=sc}', ""); +Expect(1, 35, '\P{Is_Category=sc}', ""); +Expect(0, 35, '\P{^Is_Category=sc}', ""); +Expect(1, 36, '\p{Is_Category: sc}', ""); +Expect(0, 36, '\p{^Is_Category: sc}', ""); +Expect(0, 36, '\P{Is_Category: sc}', ""); +Expect(1, 36, '\P{^Is_Category: sc}', ""); +Expect(0, 35, '\p{Is_Category: sc}', ""); +Expect(1, 35, '\p{^Is_Category: sc}', ""); +Expect(1, 35, '\P{Is_Category: sc}', ""); +Expect(0, 35, '\P{^Is_Category: sc}', ""); +Error('\p{General_Category=/a/_FORMAT}'); +Error('\P{General_Category=/a/_FORMAT}'); +Expect(1, 1539, '\p{General_Category=format}', ""); +Expect(0, 1539, '\p{^General_Category=format}', ""); +Expect(0, 1539, '\P{General_Category=format}', ""); +Expect(1, 1539, '\P{^General_Category=format}', ""); +Expect(0, 7, '\p{General_Category=format}', ""); +Expect(1, 7, '\p{^General_Category=format}', ""); +Expect(1, 7, '\P{General_Category=format}', ""); +Expect(0, 7, '\P{^General_Category=format}', ""); +Expect(1, 1539, '\p{General_Category=--FORMAT}', ""); +Expect(0, 1539, '\p{^General_Category=--FORMAT}', ""); +Expect(0, 1539, '\P{General_Category=--FORMAT}', ""); +Expect(1, 1539, '\P{^General_Category=--FORMAT}', ""); +Expect(0, 7, '\p{General_Category=--FORMAT}', ""); +Expect(1, 7, '\p{^General_Category=--FORMAT}', ""); +Expect(1, 7, '\P{General_Category=--FORMAT}', ""); +Expect(0, 7, '\P{^General_Category=--FORMAT}', ""); +Error('\p{Gc= CF:=}'); +Error('\P{Gc= CF:=}'); +Expect(1, 1539, '\p{Gc=cf}', ""); +Expect(0, 1539, '\p{^Gc=cf}', ""); +Expect(0, 1539, '\P{Gc=cf}', ""); +Expect(1, 1539, '\P{^Gc=cf}', ""); +Expect(0, 7, '\p{Gc=cf}', ""); +Expect(1, 7, '\p{^Gc=cf}', ""); +Expect(1, 7, '\P{Gc=cf}', ""); +Expect(0, 7, '\P{^Gc=cf}', ""); +Expect(1, 1539, '\p{Gc: -cf}', ""); +Expect(0, 1539, '\p{^Gc: -cf}', ""); +Expect(0, 1539, '\P{Gc: -cf}', ""); +Expect(1, 1539, '\P{^Gc: -cf}', ""); +Expect(0, 7, '\p{Gc: -cf}', ""); +Expect(1, 7, '\p{^Gc: -cf}', ""); +Expect(1, 7, '\P{Gc: -cf}', ""); +Expect(0, 7, '\P{^Gc: -cf}', ""); +Error('\p{Category= /a/Format}'); +Error('\P{Category= /a/Format}'); +Expect(1, 1539, '\p{Category=format}', ""); +Expect(0, 1539, '\p{^Category=format}', ""); +Expect(0, 1539, '\P{Category=format}', ""); +Expect(1, 1539, '\P{^Category=format}', ""); +Expect(0, 7, '\p{Category=format}', ""); +Expect(1, 7, '\p{^Category=format}', ""); +Expect(1, 7, '\P{Category=format}', ""); +Expect(0, 7, '\P{^Category=format}', ""); +Expect(1, 1539, '\p{Category= -Format}', ""); +Expect(0, 1539, '\p{^Category= -Format}', ""); +Expect(0, 1539, '\P{Category= -Format}', ""); +Expect(1, 1539, '\P{^Category= -Format}', ""); +Expect(0, 7, '\p{Category= -Format}', ""); +Expect(1, 7, '\p{^Category= -Format}', ""); +Expect(1, 7, '\P{Category= -Format}', ""); +Expect(0, 7, '\P{^Category= -Format}', ""); +Error('\p{Is_General_Category=:=_cf}'); +Error('\P{Is_General_Category=:=_cf}'); +Expect(1, 1539, '\p{Is_General_Category=cf}', ""); +Expect(0, 1539, '\p{^Is_General_Category=cf}', ""); +Expect(0, 1539, '\P{Is_General_Category=cf}', ""); +Expect(1, 1539, '\P{^Is_General_Category=cf}', ""); +Expect(0, 7, '\p{Is_General_Category=cf}', ""); +Expect(1, 7, '\p{^Is_General_Category=cf}', ""); +Expect(1, 7, '\P{Is_General_Category=cf}', ""); +Expect(0, 7, '\P{^Is_General_Category=cf}', ""); +Expect(1, 1539, '\p{Is_General_Category=-Cf}', ""); +Expect(0, 1539, '\p{^Is_General_Category=-Cf}', ""); +Expect(0, 1539, '\P{Is_General_Category=-Cf}', ""); +Expect(1, 1539, '\P{^Is_General_Category=-Cf}', ""); +Expect(0, 7, '\p{Is_General_Category=-Cf}', ""); +Expect(1, 7, '\p{^Is_General_Category=-Cf}', ""); +Expect(1, 7, '\P{Is_General_Category=-Cf}', ""); +Expect(0, 7, '\P{^Is_General_Category=-Cf}', ""); +Error('\p{Is_Gc=:=_FORMAT}'); +Error('\P{Is_Gc=:=_FORMAT}'); +Expect(1, 1539, '\p{Is_Gc=format}', ""); +Expect(0, 1539, '\p{^Is_Gc=format}', ""); +Expect(0, 1539, '\P{Is_Gc=format}', ""); +Expect(1, 1539, '\P{^Is_Gc=format}', ""); +Expect(0, 7, '\p{Is_Gc=format}', ""); +Expect(1, 7, '\p{^Is_Gc=format}', ""); +Expect(1, 7, '\P{Is_Gc=format}', ""); +Expect(0, 7, '\P{^Is_Gc=format}', ""); +Expect(1, 1539, '\p{Is_Gc: Format}', ""); +Expect(0, 1539, '\p{^Is_Gc: Format}', ""); +Expect(0, 1539, '\P{Is_Gc: Format}', ""); +Expect(1, 1539, '\P{^Is_Gc: Format}', ""); +Expect(0, 7, '\p{Is_Gc: Format}', ""); +Expect(1, 7, '\p{^Is_Gc: Format}', ""); +Expect(1, 7, '\P{Is_Gc: Format}', ""); +Expect(0, 7, '\P{^Is_Gc: Format}', ""); +Error('\p{Is_Category=:= Cf}'); +Error('\P{Is_Category=:= Cf}'); +Expect(1, 1539, '\p{Is_Category=cf}', ""); +Expect(0, 1539, '\p{^Is_Category=cf}', ""); +Expect(0, 1539, '\P{Is_Category=cf}', ""); +Expect(1, 1539, '\P{^Is_Category=cf}', ""); +Expect(0, 7, '\p{Is_Category=cf}', ""); +Expect(1, 7, '\p{^Is_Category=cf}', ""); +Expect(1, 7, '\P{Is_Category=cf}', ""); +Expect(0, 7, '\P{^Is_Category=cf}', ""); +Expect(1, 1539, '\p{Is_Category: cf}', ""); +Expect(0, 1539, '\p{^Is_Category: cf}', ""); +Expect(0, 1539, '\P{Is_Category: cf}', ""); +Expect(1, 1539, '\P{^Is_Category: cf}', ""); +Expect(0, 7, '\p{Is_Category: cf}', ""); +Expect(1, 7, '\p{^Is_Category: cf}', ""); +Expect(1, 7, '\P{Is_Category: cf}', ""); +Expect(0, 7, '\P{^Is_Category: cf}', ""); +Error('\p{Default_Ignorable_Code_Point=-:=YES}'); +Error('\P{Default_Ignorable_Code_Point=-:=YES}'); +Expect(1, 847, '\p{Default_Ignorable_Code_Point=yes}', ""); +Expect(0, 847, '\p{^Default_Ignorable_Code_Point=yes}', ""); +Expect(0, 847, '\P{Default_Ignorable_Code_Point=yes}', ""); +Expect(1, 847, '\P{^Default_Ignorable_Code_Point=yes}', ""); +Expect(0, 7, '\p{Default_Ignorable_Code_Point=yes}', ""); +Expect(1, 7, '\p{^Default_Ignorable_Code_Point=yes}', ""); +Expect(1, 7, '\P{Default_Ignorable_Code_Point=yes}', ""); +Expect(0, 7, '\P{^Default_Ignorable_Code_Point=yes}', ""); +Expect(1, 847, '\p{Default_Ignorable_Code_Point=--yes}', ""); +Expect(0, 847, '\p{^Default_Ignorable_Code_Point=--yes}', ""); +Expect(0, 847, '\P{Default_Ignorable_Code_Point=--yes}', ""); +Expect(1, 847, '\P{^Default_Ignorable_Code_Point=--yes}', ""); +Expect(0, 7, '\p{Default_Ignorable_Code_Point=--yes}', ""); +Expect(1, 7, '\p{^Default_Ignorable_Code_Point=--yes}', ""); +Expect(1, 7, '\P{Default_Ignorable_Code_Point=--yes}', ""); +Expect(0, 7, '\P{^Default_Ignorable_Code_Point=--yes}', ""); +Error('\p{DI= -Y/a/}'); +Error('\P{DI= -Y/a/}'); +Expect(1, 847, '\p{DI=y}', ""); +Expect(0, 847, '\p{^DI=y}', ""); +Expect(0, 847, '\P{DI=y}', ""); +Expect(1, 847, '\P{^DI=y}', ""); +Expect(0, 7, '\p{DI=y}', ""); +Expect(1, 7, '\p{^DI=y}', ""); +Expect(1, 7, '\P{DI=y}', ""); +Expect(0, 7, '\P{^DI=y}', ""); +Expect(1, 847, '\p{DI=_ Y}', ""); +Expect(0, 847, '\p{^DI=_ Y}', ""); +Expect(0, 847, '\P{DI=_ Y}', ""); +Expect(1, 847, '\P{^DI=_ Y}', ""); +Expect(0, 7, '\p{DI=_ Y}', ""); +Expect(1, 7, '\p{^DI=_ Y}', ""); +Expect(1, 7, '\P{DI=_ Y}', ""); +Expect(0, 7, '\P{^DI=_ Y}', ""); +Error('\p{Is_Default_Ignorable_Code_Point=_ t/a/}'); +Error('\P{Is_Default_Ignorable_Code_Point=_ t/a/}'); +Expect(1, 847, '\p{Is_Default_Ignorable_Code_Point=t}', ""); +Expect(0, 847, '\p{^Is_Default_Ignorable_Code_Point=t}', ""); +Expect(0, 847, '\P{Is_Default_Ignorable_Code_Point=t}', ""); +Expect(1, 847, '\P{^Is_Default_Ignorable_Code_Point=t}', ""); +Expect(0, 7, '\p{Is_Default_Ignorable_Code_Point=t}', ""); +Expect(1, 7, '\p{^Is_Default_Ignorable_Code_Point=t}', ""); +Expect(1, 7, '\P{Is_Default_Ignorable_Code_Point=t}', ""); +Expect(0, 7, '\P{^Is_Default_Ignorable_Code_Point=t}', ""); +Expect(1, 847, '\p{Is_Default_Ignorable_Code_Point= t}', ""); +Expect(0, 847, '\p{^Is_Default_Ignorable_Code_Point= t}', ""); +Expect(0, 847, '\P{Is_Default_Ignorable_Code_Point= t}', ""); +Expect(1, 847, '\P{^Is_Default_Ignorable_Code_Point= t}', ""); +Expect(0, 7, '\p{Is_Default_Ignorable_Code_Point= t}', ""); +Expect(1, 7, '\p{^Is_Default_Ignorable_Code_Point= t}', ""); +Expect(1, 7, '\P{Is_Default_Ignorable_Code_Point= t}', ""); +Expect(0, 7, '\P{^Is_Default_Ignorable_Code_Point= t}', ""); +Error('\p{Is_DI=-true/a/}'); +Error('\P{Is_DI=-true/a/}'); +Expect(1, 847, '\p{Is_DI=true}', ""); +Expect(0, 847, '\p{^Is_DI=true}', ""); +Expect(0, 847, '\P{Is_DI=true}', ""); +Expect(1, 847, '\P{^Is_DI=true}', ""); +Expect(0, 7, '\p{Is_DI=true}', ""); +Expect(1, 7, '\p{^Is_DI=true}', ""); +Expect(1, 7, '\P{Is_DI=true}', ""); +Expect(0, 7, '\P{^Is_DI=true}', ""); +Expect(1, 847, '\p{Is_DI: _true}', ""); +Expect(0, 847, '\p{^Is_DI: _true}', ""); +Expect(0, 847, '\P{Is_DI: _true}', ""); +Expect(1, 847, '\P{^Is_DI: _true}', ""); +Expect(0, 7, '\p{Is_DI: _true}', ""); +Expect(1, 7, '\p{^Is_DI: _true}', ""); +Expect(1, 7, '\P{Is_DI: _true}', ""); +Expect(0, 7, '\P{^Is_DI: _true}', ""); +Error('\p{Default_Ignorable_Code_Point= :=no}'); +Error('\P{Default_Ignorable_Code_Point= :=no}'); +Expect(1, 7, '\p{Default_Ignorable_Code_Point=no}', ""); +Expect(0, 7, '\p{^Default_Ignorable_Code_Point=no}', ""); +Expect(0, 7, '\P{Default_Ignorable_Code_Point=no}', ""); +Expect(1, 7, '\P{^Default_Ignorable_Code_Point=no}', ""); +Expect(0, 847, '\p{Default_Ignorable_Code_Point=no}', ""); +Expect(1, 847, '\p{^Default_Ignorable_Code_Point=no}', ""); +Expect(1, 847, '\P{Default_Ignorable_Code_Point=no}', ""); +Expect(0, 847, '\P{^Default_Ignorable_Code_Point=no}', ""); +Expect(1, 7, '\p{Default_Ignorable_Code_Point= No}', ""); +Expect(0, 7, '\p{^Default_Ignorable_Code_Point= No}', ""); +Expect(0, 7, '\P{Default_Ignorable_Code_Point= No}', ""); +Expect(1, 7, '\P{^Default_Ignorable_Code_Point= No}', ""); +Expect(0, 847, '\p{Default_Ignorable_Code_Point= No}', ""); +Expect(1, 847, '\p{^Default_Ignorable_Code_Point= No}', ""); +Expect(1, 847, '\P{Default_Ignorable_Code_Point= No}', ""); +Expect(0, 847, '\P{^Default_Ignorable_Code_Point= No}', ""); +Error('\p{DI= n/a/}'); +Error('\P{DI= n/a/}'); +Expect(1, 7, '\p{DI=n}', ""); +Expect(0, 7, '\p{^DI=n}', ""); +Expect(0, 7, '\P{DI=n}', ""); +Expect(1, 7, '\P{^DI=n}', ""); +Expect(0, 847, '\p{DI=n}', ""); +Expect(1, 847, '\p{^DI=n}', ""); +Expect(1, 847, '\P{DI=n}', ""); +Expect(0, 847, '\P{^DI=n}', ""); +Expect(1, 7, '\p{DI= N}', ""); +Expect(0, 7, '\p{^DI= N}', ""); +Expect(0, 7, '\P{DI= N}', ""); +Expect(1, 7, '\P{^DI= N}', ""); +Expect(0, 847, '\p{DI= N}', ""); +Expect(1, 847, '\p{^DI= N}', ""); +Expect(1, 847, '\P{DI= N}', ""); +Expect(0, 847, '\P{^DI= N}', ""); +Error('\p{Is_Default_Ignorable_Code_Point=/a/__F}'); +Error('\P{Is_Default_Ignorable_Code_Point=/a/__F}'); +Expect(1, 7, '\p{Is_Default_Ignorable_Code_Point=f}', ""); +Expect(0, 7, '\p{^Is_Default_Ignorable_Code_Point=f}', ""); +Expect(0, 7, '\P{Is_Default_Ignorable_Code_Point=f}', ""); +Expect(1, 7, '\P{^Is_Default_Ignorable_Code_Point=f}', ""); +Expect(0, 847, '\p{Is_Default_Ignorable_Code_Point=f}', ""); +Expect(1, 847, '\p{^Is_Default_Ignorable_Code_Point=f}', ""); +Expect(1, 847, '\P{Is_Default_Ignorable_Code_Point=f}', ""); +Expect(0, 847, '\P{^Is_Default_Ignorable_Code_Point=f}', ""); +Expect(1, 7, '\p{Is_Default_Ignorable_Code_Point=-_f}', ""); +Expect(0, 7, '\p{^Is_Default_Ignorable_Code_Point=-_f}', ""); +Expect(0, 7, '\P{Is_Default_Ignorable_Code_Point=-_f}', ""); +Expect(1, 7, '\P{^Is_Default_Ignorable_Code_Point=-_f}', ""); +Expect(0, 847, '\p{Is_Default_Ignorable_Code_Point=-_f}', ""); +Expect(1, 847, '\p{^Is_Default_Ignorable_Code_Point=-_f}', ""); +Expect(1, 847, '\P{Is_Default_Ignorable_Code_Point=-_f}', ""); +Expect(0, 847, '\P{^Is_Default_Ignorable_Code_Point=-_f}', ""); +Error('\p{Is_DI= False/a/}'); +Error('\P{Is_DI= False/a/}'); +Expect(1, 7, '\p{Is_DI=false}', ""); +Expect(0, 7, '\p{^Is_DI=false}', ""); +Expect(0, 7, '\P{Is_DI=false}', ""); +Expect(1, 7, '\P{^Is_DI=false}', ""); +Expect(0, 847, '\p{Is_DI=false}', ""); +Expect(1, 847, '\p{^Is_DI=false}', ""); +Expect(1, 847, '\P{Is_DI=false}', ""); +Expect(0, 847, '\P{^Is_DI=false}', ""); +Expect(1, 7, '\p{Is_DI=--FALSE}', ""); +Expect(0, 7, '\p{^Is_DI=--FALSE}', ""); +Expect(0, 7, '\P{Is_DI=--FALSE}', ""); +Expect(1, 7, '\P{^Is_DI=--FALSE}', ""); +Expect(0, 847, '\p{Is_DI=--FALSE}', ""); +Expect(1, 847, '\p{^Is_DI=--FALSE}', ""); +Expect(1, 847, '\P{Is_DI=--FALSE}', ""); +Expect(0, 847, '\P{^Is_DI=--FALSE}', ""); +Error('\p{Terminal_Punctuation=:= Yes}'); +Error('\P{Terminal_Punctuation=:= Yes}'); +Expect(1, 33, '\p{Terminal_Punctuation=yes}', ""); +Expect(0, 33, '\p{^Terminal_Punctuation=yes}', ""); +Expect(0, 33, '\P{Terminal_Punctuation=yes}', ""); +Expect(1, 33, '\P{^Terminal_Punctuation=yes}', ""); +Expect(0, 32, '\p{Terminal_Punctuation=yes}', ""); +Expect(1, 32, '\p{^Terminal_Punctuation=yes}', ""); +Expect(1, 32, '\P{Terminal_Punctuation=yes}', ""); +Expect(0, 32, '\P{^Terminal_Punctuation=yes}', ""); +Expect(1, 33, '\p{Terminal_Punctuation=- Yes}', ""); +Expect(0, 33, '\p{^Terminal_Punctuation=- Yes}', ""); +Expect(0, 33, '\P{Terminal_Punctuation=- Yes}', ""); +Expect(1, 33, '\P{^Terminal_Punctuation=- Yes}', ""); +Expect(0, 32, '\p{Terminal_Punctuation=- Yes}', ""); +Expect(1, 32, '\p{^Terminal_Punctuation=- Yes}', ""); +Expect(1, 32, '\P{Terminal_Punctuation=- Yes}', ""); +Expect(0, 32, '\P{^Terminal_Punctuation=- Yes}', ""); +Error('\p{Term=:=- Y}'); +Error('\P{Term=:=- Y}'); +Expect(1, 33, '\p{Term=y}', ""); +Expect(0, 33, '\p{^Term=y}', ""); +Expect(0, 33, '\P{Term=y}', ""); +Expect(1, 33, '\P{^Term=y}', ""); +Expect(0, 32, '\p{Term=y}', ""); +Expect(1, 32, '\p{^Term=y}', ""); +Expect(1, 32, '\P{Term=y}', ""); +Expect(0, 32, '\P{^Term=y}', ""); +Expect(1, 33, '\p{Term= y}', ""); +Expect(0, 33, '\p{^Term= y}', ""); +Expect(0, 33, '\P{Term= y}', ""); +Expect(1, 33, '\P{^Term= y}', ""); +Expect(0, 32, '\p{Term= y}', ""); +Expect(1, 32, '\p{^Term= y}', ""); +Expect(1, 32, '\P{Term= y}', ""); +Expect(0, 32, '\P{^Term= y}', ""); +Error('\p{Is_Terminal_Punctuation= :=T}'); +Error('\P{Is_Terminal_Punctuation= :=T}'); +Expect(1, 33, '\p{Is_Terminal_Punctuation=t}', ""); +Expect(0, 33, '\p{^Is_Terminal_Punctuation=t}', ""); +Expect(0, 33, '\P{Is_Terminal_Punctuation=t}', ""); +Expect(1, 33, '\P{^Is_Terminal_Punctuation=t}', ""); +Expect(0, 32, '\p{Is_Terminal_Punctuation=t}', ""); +Expect(1, 32, '\p{^Is_Terminal_Punctuation=t}', ""); +Expect(1, 32, '\P{Is_Terminal_Punctuation=t}', ""); +Expect(0, 32, '\P{^Is_Terminal_Punctuation=t}', ""); +Expect(1, 33, '\p{Is_Terminal_Punctuation=--t}', ""); +Expect(0, 33, '\p{^Is_Terminal_Punctuation=--t}', ""); +Expect(0, 33, '\P{Is_Terminal_Punctuation=--t}', ""); +Expect(1, 33, '\P{^Is_Terminal_Punctuation=--t}', ""); +Expect(0, 32, '\p{Is_Terminal_Punctuation=--t}', ""); +Expect(1, 32, '\p{^Is_Terminal_Punctuation=--t}', ""); +Expect(1, 32, '\P{Is_Terminal_Punctuation=--t}', ""); +Expect(0, 32, '\P{^Is_Terminal_Punctuation=--t}', ""); +Error('\p{Is_Term=_ True:=}'); +Error('\P{Is_Term=_ True:=}'); +Expect(1, 33, '\p{Is_Term=true}', ""); +Expect(0, 33, '\p{^Is_Term=true}', ""); +Expect(0, 33, '\P{Is_Term=true}', ""); +Expect(1, 33, '\P{^Is_Term=true}', ""); +Expect(0, 32, '\p{Is_Term=true}', ""); +Expect(1, 32, '\p{^Is_Term=true}', ""); +Expect(1, 32, '\P{Is_Term=true}', ""); +Expect(0, 32, '\P{^Is_Term=true}', ""); +Expect(1, 33, '\p{Is_Term=-_TRUE}', ""); +Expect(0, 33, '\p{^Is_Term=-_TRUE}', ""); +Expect(0, 33, '\P{Is_Term=-_TRUE}', ""); +Expect(1, 33, '\P{^Is_Term=-_TRUE}', ""); +Expect(0, 32, '\p{Is_Term=-_TRUE}', ""); +Expect(1, 32, '\p{^Is_Term=-_TRUE}', ""); +Expect(1, 32, '\P{Is_Term=-_TRUE}', ""); +Expect(0, 32, '\P{^Is_Term=-_TRUE}', ""); +Error('\p{Terminal_Punctuation= No:=}'); +Error('\P{Terminal_Punctuation= No:=}'); +Expect(1, 32, '\p{Terminal_Punctuation=no}', ""); +Expect(0, 32, '\p{^Terminal_Punctuation=no}', ""); +Expect(0, 32, '\P{Terminal_Punctuation=no}', ""); +Expect(1, 32, '\P{^Terminal_Punctuation=no}', ""); +Expect(0, 33, '\p{Terminal_Punctuation=no}', ""); +Expect(1, 33, '\p{^Terminal_Punctuation=no}', ""); +Expect(1, 33, '\P{Terminal_Punctuation=no}', ""); +Expect(0, 33, '\P{^Terminal_Punctuation=no}', ""); +Expect(1, 32, '\p{Terminal_Punctuation=No}', ""); +Expect(0, 32, '\p{^Terminal_Punctuation=No}', ""); +Expect(0, 32, '\P{Terminal_Punctuation=No}', ""); +Expect(1, 32, '\P{^Terminal_Punctuation=No}', ""); +Expect(0, 33, '\p{Terminal_Punctuation=No}', ""); +Expect(1, 33, '\p{^Terminal_Punctuation=No}', ""); +Expect(1, 33, '\P{Terminal_Punctuation=No}', ""); +Expect(0, 33, '\P{^Terminal_Punctuation=No}', ""); +Error('\p{Term=_ n:=}'); +Error('\P{Term=_ n:=}'); +Expect(1, 32, '\p{Term=n}', ""); +Expect(0, 32, '\p{^Term=n}', ""); +Expect(0, 32, '\P{Term=n}', ""); +Expect(1, 32, '\P{^Term=n}', ""); +Expect(0, 33, '\p{Term=n}', ""); +Expect(1, 33, '\p{^Term=n}', ""); +Expect(1, 33, '\P{Term=n}', ""); +Expect(0, 33, '\P{^Term=n}', ""); +Expect(1, 32, '\p{Term=_N}', ""); +Expect(0, 32, '\p{^Term=_N}', ""); +Expect(0, 32, '\P{Term=_N}', ""); +Expect(1, 32, '\P{^Term=_N}', ""); +Expect(0, 33, '\p{Term=_N}', ""); +Expect(1, 33, '\p{^Term=_N}', ""); +Expect(1, 33, '\P{Term=_N}', ""); +Expect(0, 33, '\P{^Term=_N}', ""); +Error('\p{Is_Terminal_Punctuation=F:=}'); +Error('\P{Is_Terminal_Punctuation=F:=}'); +Expect(1, 32, '\p{Is_Terminal_Punctuation=f}', ""); +Expect(0, 32, '\p{^Is_Terminal_Punctuation=f}', ""); +Expect(0, 32, '\P{Is_Terminal_Punctuation=f}', ""); +Expect(1, 32, '\P{^Is_Terminal_Punctuation=f}', ""); +Expect(0, 33, '\p{Is_Terminal_Punctuation=f}', ""); +Expect(1, 33, '\p{^Is_Terminal_Punctuation=f}', ""); +Expect(1, 33, '\P{Is_Terminal_Punctuation=f}', ""); +Expect(0, 33, '\P{^Is_Terminal_Punctuation=f}', ""); +Expect(1, 32, '\p{Is_Terminal_Punctuation= -F}', ""); +Expect(0, 32, '\p{^Is_Terminal_Punctuation= -F}', ""); +Expect(0, 32, '\P{Is_Terminal_Punctuation= -F}', ""); +Expect(1, 32, '\P{^Is_Terminal_Punctuation= -F}', ""); +Expect(0, 33, '\p{Is_Terminal_Punctuation= -F}', ""); +Expect(1, 33, '\p{^Is_Terminal_Punctuation= -F}', ""); +Expect(1, 33, '\P{Is_Terminal_Punctuation= -F}', ""); +Expect(0, 33, '\P{^Is_Terminal_Punctuation= -F}', ""); +Error('\p{Is_Term=- False/a/}'); +Error('\P{Is_Term=- False/a/}'); +Expect(1, 32, '\p{Is_Term=false}', ""); +Expect(0, 32, '\p{^Is_Term=false}', ""); +Expect(0, 32, '\P{Is_Term=false}', ""); +Expect(1, 32, '\P{^Is_Term=false}', ""); +Expect(0, 33, '\p{Is_Term=false}', ""); +Expect(1, 33, '\p{^Is_Term=false}', ""); +Expect(1, 33, '\P{Is_Term=false}', ""); +Expect(0, 33, '\P{^Is_Term=false}', ""); +Expect(1, 32, '\p{Is_Term=_False}', ""); +Expect(0, 32, '\p{^Is_Term=_False}', ""); +Expect(0, 32, '\P{Is_Term=_False}', ""); +Expect(1, 32, '\P{^Is_Term=_False}', ""); +Expect(0, 33, '\p{Is_Term=_False}', ""); +Expect(1, 33, '\p{^Is_Term=_False}', ""); +Expect(1, 33, '\P{Is_Term=_False}', ""); +Expect(0, 33, '\P{^Is_Term=_False}', ""); +Finished(); diff --git a/t/uni/cache.t b/t/uni/cache.t index c3f7634..df12f33 100644 --- a/t/uni/cache.t +++ b/t/uni/cache.t @@ -8,7 +8,8 @@ plan tests => 1; my $count = 0; unshift @INC, sub { - $count++ if $_[1] eq 'unicore/lib/gc_sc/Hira.pl'; + # XXX Kludge requires exact path, which might change + $count++ if $_[1] eq 'unicore/lib/Sc/Hira.pl'; }; my $s = 'foo'; diff --git a/t/uni/class.t b/t/uni/class.t index 4620ca0..6dd6ee6 100644 --- a/t/uni/class.t +++ b/t/uni/class.t @@ -4,7 +4,7 @@ BEGIN { require "test.pl"; } -plan tests => 5092; +plan tests => 10; sub MyUniClass { <updir; - -# the %utf8::... hashes are already in existence -# because utf8_pva.pl was run by utf8_heavy.pl - -*utf8::PropertyAlias = *utf8::PropertyAlias; # thwart a warning - -no warnings 'utf8'; # we do not want warnings about surrogates etc - -sub char_range { - my ($h1, $h2) = @_; - - my $str; - - if (ord('A') == 193 && $h1 < 256) { - my $h3 = ($h2 || $h1) + 1; - if ($h3 - $h1 == 1) { - $str = join "", pack 'U*', $h1 .. $h3; # Using pack since chr doesn't generate Unicode chars for value < 256. - } elsif ($h3 - $h1 > 1) { - for (my $i = $h1; $i <= $h3; $i++) { - $str = join "", $str, pack 'U*', $i; - } - } - } else { - $str = join "", map chr, $h1 .. (($h2 || $h1) + 1); - } - - return $str; -} - -# non-General Category and non-Script -while (my ($abbrev, $files) = each %utf8::PVA_abbr_map) { - my $prop_name = $utf8::PropertyAlias{$abbrev}; - next unless $prop_name; - next if $abbrev eq "gc_sc"; - - for (sort keys %$files) { - my $filename = File::Spec->catfile( - $updir => lib => unicore => lib => $abbrev => "$files->{$_}.pl" - ); - - next unless -e $filename; - my ($h1, $h2) = map hex, (split(/\t/, (do $filename), 3))[0,1]; - - my $str = char_range($h1, $h2); - - for my $p ($prop_name, $abbrev) { - for my $c ($files->{$_}, $_) { - is($str =~ /(\p{$p: $c}+)/ && $1, substr($str, 0, -1)); - is($str =~ /(\P{$p= $c}+)/ && $1, substr($str, -1)); - } - } - } -} - -# General Category and Script -for my $p ('gc', 'sc') { - while (my ($abbr) = each %{ $utf8::PropValueAlias{$p} }) { - my $filename = File::Spec->catfile( - $updir => lib => unicore => lib => gc_sc => "$utf8::PVA_abbr_map{gc_sc}{$abbr}.pl" - ); - - next unless -e $filename; - my ($h1, $h2) = map hex, (split(/\t/, (do $filename), 3))[0,1]; - - my $str = char_range($h1, $h2); - - for my $x ($p, { gc => 'General Category', sc => 'Script' }->{$p}) { - for my $y ($abbr, $utf8::PropValueAlias{$p}{$abbr}, $utf8::PVA_abbr_map{gc_sc}{$abbr}) { - is($str =~ /(\p{$x: $y}+)/ && $1, substr($str, 0, -1)); - is($str =~ /(\P{$x= $y}+)/ && $1, substr($str, -1)); - SKIP: { - skip("surrogate", 1) if $abbr eq 'cs'; - test_regexp ($str, $y); - } - } - } - } -} - -# test extra properties (ASCII_Hex_Digit, Bidi_Control, etc.) -SKIP: -{ - skip "Can't reliably derive class names from file names", 576 if $^O eq 'VMS'; - - # On case tolerant filesystems, Cf.pl will cause a -e test for cf.pl to - # return true. Try to work around this by reading the filenames explicitly - # to get a case sensitive test. N.B. This will fail if filename case is - # not preserved because you might go looking for a class name of CF or cf - # when you really want Cf. Storing case sensitive data in filenames is - # simply not portable. - - my %files; - - my $dirname = File::Spec->catdir($updir => lib => unicore => lib => 'gc_sc'); - opendir D, $dirname or die $!; - @files{readdir(D)} = (); - closedir D; - - for (keys %utf8::PA_reverse) { - my $leafname = "$utf8::PA_reverse{$_}.pl"; - next unless exists $files{$leafname}; - - my $filename = File::Spec->catfile($dirname, $leafname); - - my ($h1, $h2) = map hex, (split(/\t/, (do $filename), 3))[0,1]; - - my $str = char_range($h1, $h2); - - for my $x ('gc', 'General Category') { - print "# $filename $x $_, $utf8::PA_reverse{$_}\n"; - for my $y ($_, $utf8::PA_reverse{$_}) { - is($str =~ /(\p{$x: $y}+)/ && $1, substr($str, 0, -1)); - is($str =~ /(\P{$x= $y}+)/ && $1, substr($str, -1)); - test_regexp ($str, $y); - } - } - } -} - -# test the blocks (InFoobar) -for (grep $utf8::Canonical{$_} =~ /^In/, keys %utf8::Canonical) { - my $filename = File::Spec->catfile( - $updir => lib => unicore => lib => gc_sc => "$utf8::Canonical{$_}.pl" - ); - - next unless -e $filename; - - print "# In$_ $filename\n"; - - my ($h1, $h2) = map hex, (split(/\t/, (do $filename), 3))[0,1]; - - my $str = char_range($h1, $h2); - - my $blk = $_; - - SKIP: { - skip($blk, 2) if $blk =~ /surrogates/i; - test_regexp ($str, $blk); - $blk =~ s/^In/Block:/; - test_regexp ($str, $blk); - } -} +# The other tests that are based on looking at the generated files are now +# generated by mktables. The location of that .t file is given by the main +# Makefile that calls mktables.