regexp_parser 1.5.0 → 1.5.1

data/spec/scanner/keep_spec.rb

@@ -1,33 +1,10 @@
 require 'spec_helper'
 
 RSpec.describe('Keep scanning') do
-  specify('scan keep token') do
-    tokens = RS.scan(/ab\Kcd/)
-    result = tokens.at(1)
+  include_examples 'scan', /ab\Kcd/,
+    1 => [:keep, :mark, '\K', 2,  4]
 
-    expect(result[0]).to eq :keep
-    expect(result[1]).to eq :mark
-    expect(result[2]).to eq '\\K'
-    expect(result[3]).to eq 2
-    expect(result[4]).to eq 4
-  end
-
-  specify('scan keep nested') do
-    tokens = RS.scan(/(a\Kb)|(c\\\Kd)ef/)
-
-    first = tokens.at(2)
-    second = tokens.at(9)
-
-    expect(first[0]).to eq :keep
-    expect(first[1]).to eq :mark
-    expect(first[2]).to eq '\\K'
-    expect(first[3]).to eq 2
-    expect(first[4]).to eq 4
-
-    expect(second[0]).to eq :keep
-    expect(second[1]).to eq :mark
-    expect(second[2]).to eq '\\K'
-    expect(second[3]).to eq 11
-    expect(second[4]).to eq 13
-  end
+  include_examples 'scan', /(a\Kb)|(c\\\Kd)ef/,
+    2 => [:keep, :mark, '\K', 2,  4],
+    9 => [:keep, :mark, '\K', 11, 13]
 end

data/spec/scanner/literals_spec.rb

@@ -1,85 +1,49 @@
 require 'spec_helper'
 
 RSpec.describe('UTF8 scanning') do
-  tests = {
-    # ascii, single byte characters
-    'a' => {
-      0     => [:literal,     :literal,       'a',        0, 1],
-    },
-
-    'ab+' => {
-      0     => [:literal,     :literal,       'ab',       0, 2],
-      1     => [:quantifier,  :one_or_more,   '+',        2, 3],
-    },
-
-    # 2 byte wide characters, Arabic
-    'aاbبcت' => {
-      0     => [:literal,     :literal,       'aاbبcت',   0, 9],
-    },
-
-    'aاbبت?' => {
-      0     => [:literal,     :literal,       'aاbبت',    0, 8],
-      1     => [:quantifier,  :zero_or_one,   '?',        8, 9],
-    },
-
-    'aا?bبcت+' => {
-      0     => [:literal,     :literal,       'aا',       0, 3],
-      1     => [:quantifier,  :zero_or_one,   '?',        3, 4],
-      2     => [:literal,     :literal,       'bبcت',     4, 10],
-      3     => [:quantifier,  :one_or_more,   '+',        10, 11],
-    },
-
-    'a(اbب+)cت?' => {
-      0     => [:literal,     :literal,       'a',        0, 1],
-      1     => [:group,       :capture,       '(',        1, 2],
-      2     => [:literal,     :literal,       'اbب',      2, 7],
-      3     => [:quantifier,  :one_or_more,   '+',        7, 8],
-      4     => [:group,       :close,         ')',        8, 9],
-      5     => [:literal,     :literal,       'cت',       9, 12],
-      6     => [:quantifier,  :zero_or_one,   '?',        12, 13],
-    },
-
-    # 3 byte wide characters, Japanese
-    'ab?れます+cd' => {
-      0     => [:literal,     :literal,       'ab',       0, 2],
-      1     => [:quantifier,  :zero_or_one,   '?',        2, 3],
-      2     => [:literal,     :literal,       'れます',   3, 12],
-      3     => [:quantifier,  :one_or_more,   '+',        12, 13],
-      4     => [:literal,     :literal,       'cd',       13, 15],
-    },
-
-    # 4 byte wide characters, Osmanya
-    '𐒀𐒁?𐒂ab+𐒃' => {
-      0     => [:literal,     :literal,       '𐒀𐒁',       0, 8],
-      1     => [:quantifier,  :zero_or_one,   '?',        8, 9],
-      2     => [:literal,     :literal,       '𐒂ab',      9, 15],
-      3     => [:quantifier,  :one_or_more,   '+',        15, 16],
-      4     => [:literal,     :literal,       '𐒃',        16, 20],
-    },
-
-    'mu𝄞?si*𝄫c+' => {
-      0     => [:literal,     :literal,       'mu𝄞',      0, 6],
-      1     => [:quantifier,  :zero_or_one,   '?',        6, 7],
-      2     => [:literal,     :literal,       'si',       7, 9],
-      3     => [:quantifier,  :zero_or_more,  '*',        9, 10],
-      4     => [:literal,     :literal,       '𝄫c',       10, 15],
-      5     => [:quantifier,  :one_or_more,   '+',        15, 16],
-    },
-  }
-
-  tests.each_with_index do |(pattern, checks), count|
-    specify("scanner_utf8_runs_#{count}") do
-      tokens = RS.scan(pattern)
-
-      checks.each do |index, (type, token, text, ts, te)|
-        result = tokens[index]
-
-        expect(result[0]).to eq type
-        expect(result[1]).to eq token
-        expect(result[2]).to eq text
-        expect(result[3]).to eq ts
-        expect(result[4]).to eq te
-      end
-    end
-  end
+  # ascii, single byte characters
+  include_examples 'scan', 'a', 0              => [:literal,     :literal,       'a',        0, 1]
+
+  include_examples 'scan', 'ab+', 0            => [:literal,     :literal,       'ab',       0, 2]
+  include_examples 'scan', 'ab+', 1            => [:quantifier,  :one_or_more,   '+',        2, 3]
+
+  # 2 byte wide characters, Arabic
+  include_examples 'scan', 'aاbبcت', 0         => [:literal,     :literal,       'aاbبcت',   0, 9]
+
+  include_examples 'scan', 'aاbبت?', 0         => [:literal,     :literal,       'aاbبت',    0, 8]
+  include_examples 'scan', 'aاbبت?', 1         => [:quantifier,  :zero_or_one,   '?',        8, 9]
+
+  include_examples 'scan', 'aا?bبcت+', 0       => [:literal,     :literal,       'aا',       0, 3]
+  include_examples 'scan', 'aا?bبcت+', 1       => [:quantifier,  :zero_or_one,   '?',        3, 4]
+  include_examples 'scan', 'aا?bبcت+', 2       => [:literal,     :literal,       'bبcت',     4, 10]
+  include_examples 'scan', 'aا?bبcت+', 3       => [:quantifier,  :one_or_more,   '+',        10, 11]
+
+  include_examples 'scan', 'a(اbب+)cت?', 0     => [:literal,     :literal,       'a',        0, 1]
+  include_examples 'scan', 'a(اbب+)cت?', 1     => [:group,       :capture,       '(',        1, 2]
+  include_examples 'scan', 'a(اbب+)cت?', 2     => [:literal,     :literal,       'اbب',      2, 7]
+  include_examples 'scan', 'a(اbب+)cت?', 3     => [:quantifier,  :one_or_more,   '+',        7, 8]
+  include_examples 'scan', 'a(اbب+)cت?', 4     => [:group,       :close,         ')',        8, 9]
+  include_examples 'scan', 'a(اbب+)cت?', 5     => [:literal,     :literal,       'cت',       9, 12]
+  include_examples 'scan', 'a(اbب+)cت?', 6     => [:quantifier,  :zero_or_one,   '?',        12, 13]
+
+  # 3 byte wide characters, Japanese
+  include_examples 'scan', 'ab?れます+cd', 0    => [:literal,     :literal,       'ab',       0, 2]
+  include_examples 'scan', 'ab?れます+cd', 1    => [:quantifier,  :zero_or_one,   '?',        2, 3]
+  include_examples 'scan', 'ab?れます+cd', 2    => [:literal,     :literal,       'れます',    3, 12]
+  include_examples 'scan', 'ab?れます+cd', 3    => [:quantifier,  :one_or_more,   '+',        12, 13]
+  include_examples 'scan', 'ab?れます+cd', 4    => [:literal,     :literal,       'cd',       13, 15]
+
+  # 4 byte wide characters, Osmanya
+  include_examples 'scan', '𐒀𐒁?𐒂ab+𐒃', 0      => [:literal,     :literal,       '𐒀𐒁',       0, 8]
+  include_examples 'scan', '𐒀𐒁?𐒂ab+𐒃', 1      => [:quantifier,  :zero_or_one,   '?',        8, 9]
+  include_examples 'scan', '𐒀𐒁?𐒂ab+𐒃', 2      => [:literal,     :literal,       '𐒂ab',      9, 15]
+  include_examples 'scan', '𐒀𐒁?𐒂ab+𐒃', 3      => [:quantifier,  :one_or_more,   '+',        15, 16]
+  include_examples 'scan', '𐒀𐒁?𐒂ab+𐒃', 4      => [:literal,     :literal,       '𐒃',        16, 20]
+
+  include_examples 'scan', 'mu𝄞?si*𝄫c+', 0      => [:literal,     :literal,       'mu𝄞',       0, 6]
+  include_examples 'scan', 'mu𝄞?si*𝄫c+', 1      => [:quantifier,  :zero_or_one,   '?',        6, 7]
+  include_examples 'scan', 'mu𝄞?si*𝄫c+', 2      => [:literal,     :literal,       'si',       7, 9]
+  include_examples 'scan', 'mu𝄞?si*𝄫c+', 3      => [:quantifier,  :zero_or_more,  '*',        9, 10]
+  include_examples 'scan', 'mu𝄞?si*𝄫c+', 4      => [:literal,     :literal,       '𝄫c',       10, 15]
+  include_examples 'scan', 'mu𝄞?si*𝄫c+', 5      => [:quantifier,  :one_or_more,   '+',        15, 16]
 end

data/spec/scanner/meta_spec.rb

@@ -1,38 +1,18 @@
 require 'spec_helper'
 
 RSpec.describe('Meta scanning') do
-  tests = {
-    'abc??|def*+|ghi+' => {
-      0   => [:literal,     :literal,                 'abc',  0, 3],
-      1   => [:quantifier,  :zero_or_one_reluctant,   '??',   3, 5],
-      2   => [:meta,        :alternation,             '|',    5, 6],
-      3   => [:literal,     :literal,                 'def',  6, 9],
-      4   => [:quantifier,  :zero_or_more_possessive, '*+',   9, 11],
-      5   => [:meta,        :alternation,             '|',    11, 12],
-    },
+  include_examples 'scan', /abc??|def*+|ghi+/,
+    0  => [:literal,     :literal,                 'abc',  0,  3],
+    1  => [:quantifier,  :zero_or_one_reluctant,   '??',   3,  5],
+    2  => [:meta,        :alternation,             '|',    5,  6],
+    3  => [:literal,     :literal,                 'def',  6,  9],
+    4  => [:quantifier,  :zero_or_more_possessive, '*+',   9,  11],
+    5  => [:meta,        :alternation,             '|',    11, 12]
 
-    '(a\|b)|(c|d)\|(e[|]f)' => {
-      2   => [:escape,      :alternation,             '\|',   2, 4],
-      5   => [:meta,        :alternation,             '|',    6, 7],
-      8   => [:meta,        :alternation,             '|',    9, 10],
-      11  => [:escape,      :alternation,             '\|',   12, 14],
-      15  => [:literal,     :literal,                 '|',    17, 18],
-    },
-  }
-
-  tests.each_with_index do |(pattern, checks), count|
-    specify("scanner_meta_alternation_#{count}") do
-      tokens = RS.scan(pattern)
-
-      checks.each do |index, (type, token, text, ts, te)|
-        result = tokens.at(index)
-
-        expect(result[0]).to eq type
-        expect(result[1]).to eq token
-        expect(result[2]).to eq text
-        expect(result[3]).to eq ts
-        expect(result[4]).to eq te
-      end
-    end
-  end
+  include_examples 'scan', /(a\|b)|(c|d)\|(e[|]f)/,
+    2  => [:escape,      :alternation,             '\|',   2,  4],
+    5  => [:meta,        :alternation,             '|',    6,  7],
+    8  => [:meta,        :alternation,             '|',    9,  10],
+    11 => [:escape,      :alternation,             '\|',   12, 14],
+    15 => [:literal,     :literal,                 '|',    17, 18]
 end

data/spec/scanner/properties_spec.rb

@@ -1,307 +1,64 @@
 require 'spec_helper'
 
 RSpec.describe('Property scanning') do
-  tests = {
-    'Alnum'                               => :alnum,
-
-    'XPosixPunct'                         => :xposixpunct,
-
-    'Newline'                             => :newline,
-
-    'Any'                                 => :any,
-
-    'Assigned'                            => :assigned,
-
-    'L'                                   => :letter,
-    'Letter'                              => :letter,
-
-    'Lu'                                  => :uppercase_letter,
-    'Uppercase_Letter'                    => :uppercase_letter,
-
-    'Ll'                                  => :lowercase_letter,
-    'Lowercase_Letter'                    => :lowercase_letter,
-
-    'Lt'                                  => :titlecase_letter,
-    'Titlecase_Letter'                    => :titlecase_letter,
-
-    'Lm'                                  => :modifier_letter,
-    'Modifier_Letter'                     => :modifier_letter,
-
-    'Lo'                                  => :other_letter,
-    'Other_Letter'                        => :other_letter,
-
-    'M'                                   => :mark,
-    'Mark'                                => :mark,
-
-    'Mn'                                  => :nonspacing_mark,
-    'Nonspacing_Mark'                     => :nonspacing_mark,
-
-    'Mc'                                  => :spacing_mark,
-    'Spacing_Mark'                        => :spacing_mark,
-
-    'Me'                                  => :enclosing_mark,
-    'Enclosing_Mark'                      => :enclosing_mark,
-
-    'N'                                   => :number,
-    'Number'                              => :number,
-
-    'Nd'                                  => :decimal_number,
-    'Decimal_Number'                      => :decimal_number,
-
-    'Nl'                                  => :letter_number,
-    'Letter_Number'                       => :letter_number,
-
-    'No'                                  => :other_number,
-    'Other_Number'                        => :other_number,
-
-    'P'                                   => :punctuation,
-    'Punctuation'                         => :punctuation,
-
-    'Pc'                                  => :connector_punctuation,
-    'Connector_Punctuation'               => :connector_punctuation,
-
-    'Pd'                                  => :dash_punctuation,
-    'Dash_Punctuation'                    => :dash_punctuation,
-
-    'Ps'                                  => :open_punctuation,
-    'Open_Punctuation'                    => :open_punctuation,
-
-    'Pe'                                  => :close_punctuation,
-    'Close_Punctuation'                   => :close_punctuation,
-
-    'Pi'                                  => :initial_punctuation,
-    'Initial_Punctuation'                 => :initial_punctuation,
-
-    'Pf'                                  => :final_punctuation,
-    'Final_Punctuation'                   => :final_punctuation,
-
-    'Po'                                  => :other_punctuation,
-    'Other_Punctuation'                   => :other_punctuation,
-
-    'S'                                   => :symbol,
-    'Symbol'                              => :symbol,
-
-    'Sm'                                  => :math_symbol,
-    'Math_Symbol'                         => :math_symbol,
-
-    'Sc'                                  => :currency_symbol,
-    'Currency_Symbol'                     => :currency_symbol,
-
-    'Sk'                                  => :modifier_symbol,
-    'Modifier_Symbol'                     => :modifier_symbol,
-
-    'So'                                  => :other_symbol,
-    'Other_Symbol'                        => :other_symbol,
-
-    'Z'                                   => :separator,
-    'Separator'                           => :separator,
-
-    'Zs'                                  => :space_separator,
-    'Space_Separator'                     => :space_separator,
-
-    'Zl'                                  => :line_separator,
-    'Line_Separator'                      => :line_separator,
-
-    'Zp'                                  => :paragraph_separator,
-    'Paragraph_Separator'                 => :paragraph_separator,
-
-    'C'                                   => :other,
-    'Other'                               => :other,
-
-    'Cc'                                  => :control,
-    'Control'                             => :control,
-
-    'Cf'                                  => :format,
-    'Format'                              => :format,
-
-    'Cs'                                  => :surrogate,
-    'Surrogate'                           => :surrogate,
-
-    'Co'                                  => :private_use,
-    'Private_Use'                         => :private_use,
-
-    'Cn'                                  => :unassigned,
-    'Unassigned'                          => :unassigned,
-
-    'Age=1.1'                             => :'age=1.1',
-    'Age=6.0'                             => :'age=6.0',
-    'Age=10.0'                            => :'age=10.0',
-
-    'ahex'                                => :ascii_hex_digit,
-    'ASCII_Hex_Digit'                     => :ascii_hex_digit,
-
-    'Alphabetic'                          => :alphabetic,
-
-    'Cased'                               => :cased,
-
-    'cwcf'                                => :changes_when_casefolded,
-    'Changes_When_Casefolded'             => :changes_when_casefolded,
-
-    'cwcm'                                => :changes_when_casemapped,
-    'Changes_When_Casemapped'             => :changes_when_casemapped,
-
-    'cwl'                                 => :changes_when_lowercased,
-    'Changes_When_Lowercased'             => :changes_when_lowercased,
-
-    'cwt'                                 => :changes_when_titlecased,
-    'Changes_When_Titlecased'             => :changes_when_titlecased,
-
-    'cwu'                                 => :changes_when_uppercased,
-    'Changes_When_Uppercased'             => :changes_when_uppercased,
-
-    'ci'                                  => :case_ignorable,
-    'Case_Ignorable'                      => :case_ignorable,
-
-    'bidic'                               => :bidi_control,
-    'Bidi_Control'                        => :bidi_control,
-
-    'Dash'                                => :dash,
-
-    'dep'                                 => :deprecated,
-    'Deprecated'                          => :deprecated,
-
-    'di'                                  => :default_ignorable_code_point,
-    'Default_Ignorable_Code_Point'        => :default_ignorable_code_point,
-
-    'dia'                                 => :diacritic,
-    'Diacritic'                           => :diacritic,
-
-    'ext'                                 => :extender,
-    'Extender'                            => :extender,
-
-    'grbase'                              => :grapheme_base,
-    'Grapheme_Base'                       => :grapheme_base,
-
-    'grext'                               => :grapheme_extend,
-    'Grapheme_Extend'                     => :grapheme_extend,
-
-    'grlink'                              => :grapheme_link,
-    'Grapheme_Link'                       => :grapheme_link,
-
-    'hex'                                 => :hex_digit,
-    'Hex_Digit'                           => :hex_digit,
-
-    'Hyphen'                              => :hyphen,
-
-    'idc'                                 => :id_continue,
-    'ID_Continue'                         => :id_continue,
-
-    'ideo'                                => :ideographic,
-    'Ideographic'                         => :ideographic,
-
-    'ids'                                 => :id_start,
-    'ID_Start'                            => :id_start,
-
-    'idsb'                                => :ids_binary_operator,
-    'IDS_Binary_Operator'                 => :ids_binary_operator,
-
-    'idst'                                => :ids_trinary_operator,
-    'IDS_Trinary_Operator'                => :ids_trinary_operator,
-
-    'joinc'                               => :join_control,
-    'Join_Control'                        => :join_control,
-
-    'loe'                                 => :logical_order_exception,
-    'Logical_Order_Exception'             => :logical_order_exception,
-
-    'Lowercase'                           => :lowercase,
-
-    'Math'                                => :math,
-
-    'nchar'                               => :noncharacter_code_point,
-    'Noncharacter_Code_Point'             => :noncharacter_code_point,
-
-    'oalpha'                              => :other_alphabetic,
-    'Other_Alphabetic'                    => :other_alphabetic,
-
-    'odi'                                 => :other_default_ignorable_code_point,
-    'Other_Default_Ignorable_Code_Point'  => :other_default_ignorable_code_point,
-
-    'ogrext'                              => :other_grapheme_extend,
-    'Other_Grapheme_Extend'               => :other_grapheme_extend,
-
-    'oidc'                                => :other_id_continue,
-    'Other_ID_Continue'                   => :other_id_continue,
-
-    'oids'                                => :other_id_start,
-    'Other_ID_Start'                      => :other_id_start,
-
-    'olower'                              => :other_lowercase,
-    'Other_Lowercase'                     => :other_lowercase,
-
-    'omath'                               => :other_math,
-    'Other_Math'                          => :other_math,
-
-    'oupper'                              => :other_uppercase,
-    'Other_Uppercase'                     => :other_uppercase,
+  RSpec.shared_examples 'scan property' do |text, token|
+    it("scans \\p{#{text}} as property #{token}") do
+      result = RS.scan("\\p{#{text}}")[0]
+      expect(result[0..1]).to eq [:property, token]
+    end
 
-    'patsyn'                              => :pattern_syntax,
-    'Pattern_Syntax'                      => :pattern_syntax,
+    it("scans \\P{#{text}} as nonproperty #{token}") do
+      result = RS.scan("\\P{#{text}}")[0]
+      expect(result[0..1]).to eq [:nonproperty, token]
+    end
 
-    'patws'                               => :pattern_white_space,
-    'Pattern_Whitespace'                  => :pattern_white_space,
+    it("scans \\p{^#{text}} as nonproperty #{token}") do
+      result = RS.scan("\\p{^#{text}}")[0]
+      expect(result[0..1]).to eq [:nonproperty, token]
+    end
 
-    'qmark'                               => :quotation_mark,
-    'quotationmark'                       => :quotation_mark,
+    it("scans double-negated \\P{^#{text}} as property #{token}") do
+      result = RS.scan("\\P{^#{text}}")[0]
+      expect(result[0..1]).to eq [:property, token]
+    end
+  end
 
-    'radical'                             => :radical,
+  include_examples 'scan property', 'Alnum',                :alnum
 
-    'ri'                                  => :regional_indicator,
-    'Regional_Indicator'                  => :regional_indicator,
+  include_examples 'scan property', 'XPosixPunct',          :xposixpunct
 
-    'sd'                                  => :soft_dotted,
-    'Soft-Dotted'                         => :soft_dotted, # test dash spelling
+  include_examples 'scan property', 'Newline',              :newline
 
-    'sterm'                               => :sentence_terminal,
+  include_examples 'scan property', 'Any',                  :any
 
-    'term'                                => :terminal_punctuation,
-    'Terminal_Punctuation'                => :terminal_punctuation,
+  include_examples 'scan property', 'Assigned',             :assigned
 
-    'uideo'                               => :unified_ideograph,
-    'Unified_Ideograph'                   => :unified_ideograph,
+  include_examples 'scan property', 'Age=1.1',              :'age=1.1'
+  include_examples 'scan property', 'Age=10.0',             :'age=10.0'
 
-    'Uppercase'                           => :uppercase,
+  include_examples 'scan property', 'ahex',                 :ascii_hex_digit
+  include_examples 'scan property', 'ASCII_Hex_Digit',      :ascii_hex_digit # test underscore
 
-    'vs'                                  => :variation_selector,
-    'Variation_Selector'                  => :variation_selector,
+  include_examples 'scan property', 'sd',                   :soft_dotted
+  include_examples 'scan property', 'Soft-Dotted',          :soft_dotted # test dash
 
-    'wspace'                              => :white_space,
-    'whitespace'                          => :white_space,
+  include_examples 'scan property', 'Egyp',                 :egyptian_hieroglyphs
+  include_examples 'scan property', 'Egyptian Hieroglyphs', :egyptian_hieroglyphs # test whitespace
 
-    'xids'                                => :xid_start,
-    'XID_Start'                           => :xid_start,
+  include_examples 'scan property', 'Linb',                 :linear_b
+  include_examples 'scan property', 'Linear-B',             :linear_b # test dash
 
-    'xidc'                                => :xid_continue,
-    'XID_Continue'                        => :xid_continue,
-  }
+  include_examples 'scan property', 'InArabic',             :in_arabic # test block
+  include_examples 'scan property', 'in Arabic',            :in_arabic # test block w. whitespace
+  include_examples 'scan property', 'In_Arabic',            :in_arabic # test block w. underscore
 
-  tests.each_with_index do |(property, token), count|
-    specify("scan_property_#{token}_#{count}") do
-      tokens = RS.scan("a\\p{#{property}}c")
-      result = tokens.at(1)
-      expect(result[0]).to eq :property
-      expect(result[1]).to eq token
-    end
+  include_examples 'scan property', 'Yiii',                 :yi
+  include_examples 'scan property', 'Yi',                   :yi
 
-    specify("scan_nonproperty_#{token}_#{count}") do
-      tokens = RS.scan("a\\P{#{property}}c")
-      result = tokens.at(1)
-      expect(result[0]).to eq :nonproperty
-      expect(result[1]).to eq token
-    end
-
-    specify("scan_caret_nonproperty_#{token}_#{count}") do
-      tokens = RS.scan("a\\p{^#{property}}c")
-      result = tokens.at(1)
-      expect(result[0]).to eq :nonproperty
-      expect(result[1]).to eq token
-    end
+  include_examples 'scan property', 'Zinh',                 :inherited
+  include_examples 'scan property', 'Inherited',            :inherited
+  include_examples 'scan property', 'Qaai',                 :inherited
 
-    specify("scan_double_negated_property_#{token}_#{count}") do
-      tokens = RS.scan("a\\P{^#{property}}c")
-      result = tokens.at(1)
-      expect(result[0]).to eq :property
-      expect(result[1]).to eq token
-    end
-  end
+  include_examples 'scan property', 'Zzzz',                 :unknown
+  include_examples 'scan property', 'Unknown',              :unknown
 end