regexador 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b16d02292d2ae9d888a09c04d2e3330c72be9836
-  data.tar.gz: d4b472b343ece2a984b30ceecae7968fefdb6c93
+SHA256:
+  metadata.gz: ef781dea6cb100272e9885a401b5710d8721eddd9280a262b34c15ba444a35a0
+  data.tar.gz: bab1c2a5a233e23a701be3a852340092cff4710de52580692a5a184e5bee71ec
 SHA512:
-  metadata.gz: 1f12498dd028fb55dcef7f927d81a1057af6441824c56d2c6fb8dfe9ee9c99e3c6fb7caa9c94069e848489b737e5d025196a9bf74f4fa844014a61509d361adb
-  data.tar.gz: 896ba315badba2f4bdfce8d731c3a3802111ce712ac1bbb768bb4fa8c0f54d1306eabbba896214ccd97fef74c9439f66abcd66a5c9612eb494959dc67d2f256f
+  metadata.gz: b01ba0354deb1aab96a3d1aa95447ec5af4764511bdd9f4a6ec73586eb22db619aedee35c05977d40fc18b9e6f9d73638f332efca5cd3967c1fee6fe50dc78d3
+  data.tar.gz: '0980bc439ced111c2ae822dcd9416bd290e8cf8f3d17ec00b70e24bb65961c458a3fcd5844fcbbfb620f2463f128861c6b2698ce4d8705c30adb2fd33d233182'

data/README.md

@@ -19,21 +19,25 @@ as [the wiki](http://github.com/Hal9000/regexador/wiki).
 
 ### The Basic Concept
 
-Many people are intimidated or confused by regular expressions. 
-A large part of this is the confusing syntax.
+Many people are intimidated or confused by regular expressions. A large part of 
+this is the complex syntax.
 
-Regexador is a mini-language purely for building regular expressions.
-It's purely a Ruby project for now, though in theory it could be
-implemented in/for other languages.
+Regexador is a mini-language purely for building regular expressions. It's purely 
+a Ruby project at the moment, although there are tentative plans for ports to 
+Elixir and Python.
 
-For an analogy, think of how we sometimes manipulate databases by
-constructing SQL queries and passing them into the appropriate 
+A traditional (or internal) Ruby DSL consists of creative use of methods and 
+operators to "fake" a language inside Ruby code. The internal DSL is itself
+Ruby code that must obeu Ruby syntax.
+
+But what is an external DSL? For an analogy, think of how we sometimes manipulate 
+databases by constructing SQL queries and passing them into the appropriate 
 methods. Regexador works much the same way.
 
 ### A Short Example
 
-Suppose we want to match a string consisting of a single IP address. 
-(Remember that the numbers can only range as high as 255.)
+Suppose we want to match a string consisting of a single IP address. (Remember that 
+the numbers can only range as high as 255.)
 
 Here is traditional regular expression notation:
 
@@ -45,11 +49,10 @@ And here is Regexador notation:
     num = "25" D5 | `2 D4 D | maybe D1 1,2*D
     match BOS num dot num dot num dot num EOS end
 
-In your Ruby code, you can create a Regexador "script" or "program"
-(probably by means of a here-document) that you can then pass into
-the Regexador class. At minimum, you can convert this into a "real" 
-Ruby regular expression; there are a few other features and functions, 
-and more may be added.
+In your Ruby code, you can create a Regexador "script" or "program" (probably 
+by means of a here-document) that you can then pass into the Regexador class. 
+At minimum, you can convert this into a "real" Ruby regular expression; there 
+are a few other features and functions, and more are being added.
 
 So here is a complete Ruby program:
 
@@ -75,9 +78,7 @@ So here is a complete Ruby program:
     end
 
 
-
 **Traditional Syntax: Things I Personally Dislike**
-
 - There are no keywords -- only punctuation.
  These symbols all have special meanings: ^$.\[]()+\*?  (and others)
 - ^ has at least three different meanings
@@ -93,42 +94,39 @@ So here is a complete Ruby program:
 
 ### Regexador at a Glance
 
-I'm attracted to old-fashioned line-oriented syntax; but I don't want
-to lock myself into that completely.
+I'm attracted to old-fashioned line-oriented syntax; but I don't want to lock 
+myself into that completely.
 
-In general, useful definitions (variables) will come first. Many things 
-are predefined already, such as all the usual anchors and the POSIX
-character classes. These are in all caps and are considered constants.
+In general, useful definitions (variables) will come first. Many things are 
+predefined already, such as all the usual anchors and the POSIX character 
+classes. These are in all caps and are considered constants.
 
-At the end, a *match* clause drives the actual building of the final
-regular expression. Within this clause, names may be assigned to the 
-individual sub-matches (using variables that start with "@"). These will
-naturally be available externally as named captures.
+At the end, a *match* clause drives the actual building of the final regular 
+expression. Within this clause, names may be assigned to the individual 
+sub-matches (using variables that start with "@"). These will naturally be 
+available externally as named captures.
 
-Because this is really just a "builder," and because we don't have "hooks"
-into the regular expression engine itself, a Regexador script will not 
-look or act much like a "real program." There will be no arithmetic, no
-function calls, no looping or branching. Also there can be no printing
-of debug information "at matching time"; in principle, printing could be 
-done during parsing/compilation, but I don't see any value in this. 
+Because this is really just a "builder," and because we don't have "hooks" into 
+the regular expression engine itself, a Regexador script will not look or act 
+much like a "real program." There will be no arithmetic, no function calls, no 
+looping or branching. Also there can be no printing of debug information "at 
+matching time"; in principle, printing could be done during parsing/compilation,
+but I don't see any value in this. 
 
-Of course, syntax errors in Regexador will be found and made available
-to the caller.
+Of course, syntax errors in Regexador will be found and made available to the 
+caller.
 
 
 **Beginning at the Beginning**
 
-I've tried to "think ahead" so as not to paint myself into a corner
-too much.
+I've tried to "think ahead" so as not to paint myself into a corner too much.
 
-However, probably not all of this can be implemented in the first
-version. The current "working version" (0.2.7) has been implemented
-over a period of nine weeks.
+However, probably not all of this can be implemented in the earliest versions. 
+The original "working version" (0.2.7) was implemented over a period of nine 
+weeks.
 
-Therefore some of the syntax described in the following will not be
-available right away.
-
-Features still postponed:
+Therefore some of the functionality described here is not yet fully implemented.
+Features still postponed include:
   - intra-line comments:  #{...}
   - case/end
   - unsure about upto, thru
@@ -251,11 +249,13 @@ But data type matters, of course:
      n = "foo"
      m,n * "def"                          # Syntax error!
 
-The "match clause" uses all previous definitions to finally build the regular expression. It starts with "match" and ends with "end":
+The "match clause" uses all previous definitions to finally build the regular 
+expression. It starts with "match" and ends with "end":
     
      match "abc" | "def" | many `x end
    
-Named matches are only used inside the match clause; anywhere a pattern may be used, "@var = pattern" may also be used. 
+Named matches are only used inside the match clause; anywhere a pattern may be 
+used, "@var = pattern" may also be used. 
 
      match @first = (many %alpha) SPACES @last = (many %alpha) end
 
@@ -267,7 +267,7 @@ Multiple lines are fine (and more readable):
        @last = many %alpha
      end
 
- A "case" may be used for more complex alternatives (needed??):
+Planned: A "case" may be used for more complex alternatives. (Is this needed?)
 
      case
        when "abc" ...
@@ -275,7 +275,8 @@ Multiple lines are fine (and more readable):
        when "xyz" ...
      end
 
-Multiple "programs" can be concatenated, assuming the initial ones are all definitions and there is only one match clause at the end.
+Multiple "programs" can be concatenated, assuming the initial ones are all 
+definitions and there is only one match clause at the end.
 
      # Ruby code
      defs = "..."
@@ -373,6 +374,13 @@ Determine whether a credit card number is valid    Regex: /^(?:4[0-9]{12}(?:[0-9
 
 This history has been maintained only since version 0.4.2
 
+*0.4.6*
+  - Moving from rspec to minitest
+  - Verifying compatibility with Ruby 2.6, 2.7
+  - improving gemspec
+  - improving README
+  - working on railroad diagrams
+
 *0.4.3*
   - Experimenting with lookarounds (pos/neg lookahead/behind)
   - Rearranged tests

data/lib/chars.rb

@@ -1,6 +1,7 @@
 abort "Require out of order" if ! defined? Regexador
 
 class Regexador::Parser 
+  rule(:cSPACE)      { str(" ") }
   rule(:cSQUOTE)     { str("'") }
   rule(:cQUOTE)      { str('"') }
   rule(:cAMPERSAND)  { str('&') }

data/lib/keywords.rb

@@ -3,19 +3,21 @@ abort "Require out of order" if ! defined? Regexador
 
 class Regexador::Parser
 
-  rule(:kANY)          { str("any") }
-  rule(:kMANY)         { str("many") }
-  rule(:kMAYBE)        { str("maybe") }
-  rule(:kMATCH)        { str("match") }
-  rule(:kEND)          { str("end") }
-  rule(:kNOCASE)       { str("nocase") }
+  rule(:non_alphanum)  { lower.absent? >> upper.absent? >> cUNDERSCORE.absent? >> digit.absent? }
 
-  rule(:kWITH)         { str("with") }
-  rule(:kWITHOUT)      { str("without") }
-  rule(:kFIND)         { str("find") }
+  rule(:kANY)          { str("any")      >> non_alphanum }
+  rule(:kMANY)         { str("many")     >> non_alphanum }
+  rule(:kMAYBE)        { str("maybe")    >> non_alphanum }
+  rule(:kMATCH)        { str("match")    >> non_alphanum }
+  rule(:kEND)          { str("end")      >> non_alphanum }
+  rule(:kNOCASE)       { str("nocase")   >> non_alphanum }
 
-  rule(:kWITHIN)       { str("within") }
-  rule(:kESCAPING)     { str("escaping") }
+  rule(:kWITH)         { str("with")     >> non_alphanum }
+  rule(:kWITHOUT)      { str("without")  >> non_alphanum }
+  rule(:kFIND)         { str("find")     >> non_alphanum }
+
+  rule(:kWITHIN)       { str("within")   >> non_alphanum }
+  rule(:kESCAPING)     { str("escaping") >> non_alphanum }
 
   rule(:keyword)       { kANY   | kMANY    | kMAYBE | kMATCH  | kEND | kNOCASE | 
                          kWITH  | kWITHOUT | kFIND  | kWITHIN | kESCAPING }

data/lib/regexador_parser.rb

@@ -18,8 +18,9 @@ class Regexador::Parser
   rule(:lower)         { match('[a-z]') }
   rule(:upper)         { match('[A-Z]') }
 
-  rule(:comment)       { cHASH >> space >> (cNEWLINE.absent? >> any).repeat(0) }
+  rule(:comment)       { space? >> cHASH >> space >> (cNEWLINE.absent? >> any).repeat(0) >> cNEWLINE }
   rule(:endofline)     { space? >> comment.maybe >> cNEWLINE }
+  rule(:statement)     { (assignment | comment) }
 
   rule(:digit)         { match('[0-9]') }
   rule(:digits)        { digit.repeat(1) }
@@ -95,7 +96,7 @@ class Regexador::Parser
 
   rule(:assignment)    { space? >> name.as(:var) >> space? >> cEQUAL >> space? >> rvalue.as(:rvalue) }
 
-  rule(:definitions)   { (endofline | assignment >> endofline).repeat(0) }
+  rule(:definitions)   { (statement >> endofline).repeat(0).maybe }
 
   rule(:oneline_clause)   { space? >> kMATCH >> space? >> pattern >> kEND >> endofline.maybe }
 

data/spec/GENERATED_spec.rb

@@ -0,0 +1,3347 @@
+  require_relative '../lib/regexador'
+  require 'pp'
+
+  require 'parslet/convenience'
+  require 'parslet/rig/rspec'
+
+  describe Regexador do
+
+  before(:all) do
+    @parser = Regexador::Parser.new 
+    @pattern = @parser.pattern
+  end
+  
+  class Program
+    attr_accessor :description, :program, :regex, :good, :bad, :examples
+
+    def initialize(code)
+      @code = code
+      @parser = Regexador::Parser.new 
+    end
+
+    def parseable?
+      result = @parser.parse(@code) rescue nil  # != nil
+      !! result
+    end
+
+    def parse_pattern  # FIXME no longer used?
+      tree = @parser.pattern.parse(@code)
+      tree = tree[:alternation]         if tree.size == 1 && tree.keys.first == :alternation
+      tree = tree[:sequence].first         if tree.size == 1 && tree.keys.first == :sequence
+      tree
+    end
+
+    def parse
+      tree = @parser.parse(@code)
+    end
+
+    def debug_bad_program_parse
+      @parser.parse(@code)
+      atree = nil
+    rescue Parslet::ParseFailed => error
+      atree = error.cause.ascii_tree.split("
+")
+      lchar = /at line (d+) char (d+).$/
+      fname = rand(10**5).to_s + ".tree"
+      File.open(fname, "w") {|f| f.puts @code + "
+" + atree.join("
+") }
+      puts "See file: " + fname
+      return
+      # FIXME bad logic below
+      begin
+        atree.map! do |line|
+          line.gsub!(/`- ||- ||  /, "   ")
+          _, ln, cn = line.match(lchar).to_a
+          line.sub!(lchar, "")
+          line.sub!(/   /, "  ")
+          line = '%-5s' % (ln+':'+cn) + line
+        end
+      rescue
+      end
+      puts atree
+    end
+
+    def regexp
+      Regexador.new(@code).to_regex
+    end
+  end
+
+
+  def self.program &block
+    let(:code, &block)
+    let(:program) { Program.new(code) }
+    let(:regexp) { program.regexp }
+
+    subject { program }
+  end
+
+    ### Test 1: Single char
+
+    describe "A correct program (Single char)" do
+      prog = <<-'END'
+        match `x end
+      END
+
+      good = ["abcx", "xyzb", "x"]
+      bad  = ["yz", "", "ABC"]
+      wanted = /x/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 2: Unicode codepoint
+
+    describe "A correct program (Unicode codepoint)" do
+      prog = <<-'END'
+        match &20ac end
+      END
+
+      good = ["€", "xyz€", "x€yz"]
+      bad  = ["yz", "", "ABC"]
+      wanted = /€/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 3: Manual international characters
+
+    describe "A correct program (Manual international characters)" do
+      prog = <<-'END'
+        match "ö" end
+      END
+
+      good = ["öffnen", "xyzö", "xöyz"]
+      bad  = ["offnen", "yz", "", "ABC"]
+      wanted = /ö/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 4: Simple range
+
+    describe "A correct program (Simple range)" do
+      prog = <<-'END'
+        match `a-`f end
+      END
+
+      good = ["alpha", "xyzb", "c"]
+      bad  = ["xyz", "", "ABC"]
+      wanted = /[a-f]/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 5: Negated range
+
+    describe "A correct program (Negated range)" do
+      prog = <<-'END'
+        match `c~`p end
+      END
+
+      good = ["ab", "rst"]
+      bad  = ["def", "mno", ""]
+      wanted = /[^c-p]/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 6: Negated char
+
+    describe "A correct program (Negated char)" do
+      prog = <<-'END'
+        match ~`d end
+      END
+
+      good = ["xyz", "123"]
+      bad  = ["d", "dd"]
+      wanted = /[^d]/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 7: POSIX class
+
+    describe "A correct program (POSIX class)" do
+      prog = <<-'END'
+        match %alnum end
+      END
+
+      good = ["abc365", "237", "xyz"]
+      bad  = ["---", ":,.-"]
+      wanted = /[[:alnum:]]/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 8: Simple char class
+
+    describe "A correct program (Simple char class)" do
+      prog = <<-'END'
+        match 'prstu' end
+      END
+
+      good = ["du", "ppp", "sr"]
+      bad  = ["abc", "xyz"]
+      wanted = /[prstu]/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 9: Negated char class
+
+    describe "A correct program (Negated char class)" do
+      prog = <<-'END'
+        match ~'ilmnop' end
+      END
+
+      good = ["abacus", "peccata", "hydrogen"]
+      bad  = ["oil", "pill"]
+      wanted = /[^ilmnop]/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 10: Predef Beginning of string
+
+    describe "A correct program (Predef Beginning of string)" do
+      prog = <<-'END'
+        match BOS end
+      END
+
+      good = [""]
+      bad  = []
+      wanted = /^/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 11: Predef End of string
+
+    describe "A correct program (Predef End of string)" do
+      prog = <<-'END'
+        match EOS end
+      END
+
+      good = [""]
+      bad  = []
+      wanted = /$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 12: Predef Word boundary
+
+    describe "A correct program (Predef Word boundary)" do
+      prog = <<-'END'
+        match WB end
+      END
+
+      good = ["xyz"]
+      bad  = ["", "---"]
+      wanted = /\b/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 13: Simple string
+
+    describe "A correct program (Simple string)" do
+      prog = <<-'END'
+        match "xyz" end
+      END
+
+      good = ["xyz", "abcxyzdef"]
+      bad  = ["abc", "xydefz"]
+      wanted = /xyz/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 14: Single-bounded repetition
+
+    describe "A correct program (Single-bounded repetition)" do
+      prog = <<-'END'
+        match 5 * "xyz" end
+      END
+
+      good = ["xyzxyzxyzxyzxyz"]
+      bad  = ["xyzxyzxyzxyz"]
+      wanted = /(xyz){5}/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 15: Double-bounded repetition
+
+    describe "A correct program (Double-bounded repetition)" do
+      prog = <<-'END'
+        match 3,4 * %alpha end
+      END
+
+      good = ["abc", "abcd"]
+      bad  = ["ab", "x"]
+      wanted = /([[:alpha:]]){3,4}/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 16: any-qualifier
+
+    describe "A correct program (any-qualifier)" do
+      prog = <<-'END'
+        match any "abc" end
+      END
+
+      good = ["", "abc", "abcabc", "xyz"]
+      bad  = []
+      wanted = /(abc)*/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 17: many-qualifier
+
+    describe "A correct program (many-qualifier)" do
+      prog = <<-'END'
+        match many "def" end
+      END
+
+      good = ["def", "defdef", "defdefdef"]
+      bad  = ["", "de", "xyz"]
+      wanted = /(def)+/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 18: nocase-qualifier
+
+    describe "A correct program (nocase-qualifier)" do
+      prog = <<-'END'
+        match nocase "ghi" end
+      END
+
+      good = ["ghi", "GHI", "abGhicd"]
+      bad  = ["", "gh", "abc"]
+      wanted = /((?i)ghi)/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 19: maybe-qualifier
+
+    describe "A correct program (maybe-qualifier)" do
+      prog = <<-'END'
+        match maybe "ghi" end
+      END
+
+      good = ["", "ghi", "abghicd", "gh"]
+      bad  = []
+      wanted = /(ghi)?/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 20: Simple concatenation of two strings
+
+    describe "A correct program (Simple concatenation of two strings)" do
+      prog = <<-'END'
+        match "abc" "def" end
+      END
+
+      good = ["abcdefghi", "xyzabcdef"]
+      bad  = ["", "abcxyzdef"]
+      wanted = /abcdef/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 21: Concat of string and char class
+
+    describe "A correct program (Concat of string and char class)" do
+      prog = <<-'END'
+        match "abc"'def' end
+      END
+
+      good = ["abcd", "abce"]
+      bad  = ["", "abcx"]
+      wanted = /abc[def]/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 22: Simple alternation
+
+    describe "A correct program (Simple alternation)" do
+      prog = <<-'END'
+        match "abc" | "def" end
+      END
+
+      good = ["abc", "xyzabc123", "xdefy"]
+      bad  = ["", "abde", "ab c d ef"]
+      wanted = /(abc|def)/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 23: Alternation of concatenations
+
+    describe "A correct program (Alternation of concatenations)" do
+      prog = <<-'END'
+        match "ab" "c" | "d" "ef" end
+      END
+
+      good = ["abc", "xyzabc123", "xdefy"]
+      bad  = ["", "abde", "ab c d ef"]
+      wanted = /(abc|def)/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 24: Precedence of concatenation over alternation
+
+    describe "A correct program (Precedence of concatenation over alternation)" do
+      prog = <<-'END'
+        match "a" "b" | "c" end
+      END
+
+      good = ["ab", "c"]
+      bad  = ["b", "a", "d"]
+      wanted = /(ab|c)/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 25: Precedence of parens over concatenation
+
+    describe "A correct program (Precedence of parens over concatenation)" do
+      prog = <<-'END'
+        match "a" ("b" | "c") end
+      END
+
+      good = ["ab", "ac"]
+      bad  = ["a", "b", "c"]
+      wanted = /a(b|c)/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 26: Anchors and alternation
+
+    describe "A correct program (Anchors and alternation)" do
+      prog = <<-'END'
+        match BOS "x" | "y" EOS end
+      END
+
+      good = ["xabc", "abcy"]
+      bad  = ["abc", "abcx", "yabc", "axb", "ayb", "axyb"]
+      wanted = /(^x|y$)/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 27: Anchors, alternation, parens
+
+    describe "A correct program (Anchors, alternation, parens)" do
+      prog = <<-'END'
+        match BOS ("x" | "y") EOS end
+      END
+
+      good = ["x", "y"]
+      bad  = ["abc", "abcx", "yabc", "xabc", "abcy"]
+      wanted = /^(x|y)$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 28: Parens, concatenation, alternation
+
+    describe "A correct program (Parens, concatenation, alternation)" do
+      prog = <<-'END'
+        match BOS ((maybe `0) `1-`9 | `1 D2) EOS end
+      END
+
+      good = ["01", "09", "12"]
+      bad  = ["0", "00", "13"]
+      wanted = /^((0)?[1-9]|1[0-2])$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 29: Single backtick char
+
+    describe "A correct program (Single backtick char)" do
+      prog = <<-'END'
+        match `` end
+      END
+
+      good = ["`", "this is a tick: `", "tock ` tock"]
+      bad  = ["", "abc"]
+      wanted = /`/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 30: Single backslash char
+
+    describe "A correct program (Single backslash char)" do
+      prog = <<-'END'
+        match `\ end
+      END
+
+      good = ["\\", "trying \\n", "and \\b also"]
+      bad  = ["\n", "\b", "neither \r nor \t"]
+      wanted = /\\/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 31: Empty string
+
+    describe "A correct program (Empty string)" do
+      prog = <<-'END'
+        match "" end
+      END
+
+      good = ["", "abc"]
+      bad  = []
+      wanted = //
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 32: Simple char class
+
+    describe "A correct program (Simple char class)" do
+      prog = <<-'END'
+        match 'abcdef' end
+      END
+
+      good = ["there's a cat here", "item c"]
+      bad  = ["", "proton"]
+      wanted = /[abcdef]/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 33: Simple one-char class
+
+    describe "A correct program (Simple one-char class)" do
+      prog = <<-'END'
+        match 'x' end
+      END
+
+      good = ["x", "uvwxyz"]
+      bad  = ["", "abc"]
+      wanted = /[x]/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 34: Alternation of range and class
+
+    describe "A correct program (Alternation of range and class)" do
+      prog = <<-'END'
+        match `a-`f | 'xyz' end
+      END
+
+      good = ["a", "x", "z", "c"]
+      bad  = ["", "jkl", "gw"]
+      wanted = /([a-f]|[xyz])/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 35: Alternation of range and maybe-clause
+
+    describe "A correct program (Alternation of range and maybe-clause)" do
+      prog = <<-'END'
+        match `1-`6| maybe "#" end
+      END
+
+      good = ["", "1#", "1", " 2# abc"]
+      bad  = []
+      wanted = /([1-6]|(\#)?)/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 36: Four-way alternation
+
+    describe "A correct program (Four-way alternation)" do
+      prog = <<-'END'
+        match `a | `b|`c|`d end
+      END
+
+      good = ["xyza", "xybz", "xcyz", "dxyz"]
+      bad  = ["", "every", "ghijk"]
+      wanted = /(a|b|c|d)/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 37: Concatenation of range and class
+
+    describe "A correct program (Concatenation of range and class)" do
+      prog = <<-'END'
+        match `a-`f 'xyz' end
+      END
+
+      good = ["ax", "fz", "cy"]
+      bad  = ["zf", "xa", "gz", "hp", "mx"]
+      wanted = /[a-f][xyz]/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 38: Concat of strings and maybe-clause
+
+    describe "A correct program (Concat of strings and maybe-clause)" do
+      prog = <<-'END'
+        match "this" "that" maybe "other" end
+      END
+
+      good = ["thisthat", "thisthatother", "abc thisthat xyz", "abc thisthatother xyz"]
+      bad  = ["", "abc", "this that", "this that other"]
+      wanted = /thisthat(other)?/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 39: Simple repetition of class
+
+    describe "A correct program (Simple repetition of class)" do
+      prog = <<-'END'
+        match 3 * 'xyz' end
+      END
+
+      good = ["xyz", "xxx", "yzy", "xyzzy123"]
+      bad  = ["", "abc", "xy", "axy", "xyb", "axyb"]
+      wanted = /([xyz]){3}/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 40: Simple repetition of range
+
+    describe "A correct program (Simple repetition of range)" do
+      prog = <<-'END'
+        match 4 * `1-`6 end
+      END
+
+      good = ["1111", "1234", "abc 6543 def"]
+      bad  = ["", "abc", "123", "123 4"]
+      wanted = /([1-6]){4}/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 41: Complex repetition of char
+
+    describe "A correct program (Complex repetition of char)" do
+      prog = <<-'END'
+        match 3,5 * (`a) end
+      END
+
+      good = ["aaa", "aaaa", "aaaaa", "xaaay", "aaaaaaa"]
+      bad  = ["", "abc", "aa"]
+      wanted = /(a){3,5}/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 42: Complex repetition of parenthesized class
+
+    describe "A correct program (Complex repetition of parenthesized class)" do
+      prog = <<-'END'
+        match 4,7 * ('xyz') end
+      END
+
+      good = ["xxxx", "yyyy", "xyzy", "xyzzy", "zyzzyva", "xyzxyz", "xyzxyzx", "xyzxyzxyzxyz"]
+      bad  = ["", "abc", "x", "xx", "xxx", "xyz xy"]
+      wanted = /([xyz]){4,7}/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 43: Complex repetition of parenthesized range
+
+    describe "A correct program (Complex repetition of parenthesized range)" do
+      prog = <<-'END'
+        match 0,3 * (`1-`6) end
+      END
+
+      good = ["", "1", "11", "111", "56", "654", "1111", "x123y", "x123456y"]
+      bad  = []
+      wanted = /([1-6]){0,3}/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 44: Single char (anchored)
+
+    describe "A correct program (Single char (anchored))" do
+      prog = <<-'END'
+        match BOS `x EOS end
+      END
+
+      good = ["x"]
+      bad  = ["yz", "", "ABC"]
+      wanted = /^x$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 45: Simple range (anchored)
+
+    describe "A correct program (Simple range (anchored))" do
+      prog = <<-'END'
+        match BOS `a-`f EOS end
+      END
+
+      good = ["a", "b", "c", "d", "e", "f"]
+      bad  = ["xyz", "", "ABC"]
+      wanted = /^[a-f]$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 46: Negated range (anchored)
+
+    describe "A correct program (Negated range (anchored))" do
+      prog = <<-'END'
+        match BOS `c~`p EOS end
+      END
+
+      good = ["a", "r"]
+      bad  = ["def", "mno", ""]
+      wanted = /^[^c-p]$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 47: Negated char (anchored)
+
+    describe "A correct program (Negated char (anchored))" do
+      prog = <<-'END'
+        match BOS ~`d EOS end
+      END
+
+      good = ["x", "1"]
+      bad  = ["d", "dd", "abc"]
+      wanted = /^[^d]$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 48: POSIX class (anchored)
+
+    describe "A correct program (POSIX class (anchored))" do
+      prog = <<-'END'
+        match BOS %alnum EOS end
+      END
+
+      good = ["c", "2"]
+      bad  = ["", "abc", "123", "-", ":", ",", "."]
+      wanted = /^[[:alnum:]]$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 49: Simple char class (anchored)
+
+    describe "A correct program (Simple char class (anchored))" do
+      prog = <<-'END'
+        match BOS 'prstu' EOS end
+      END
+
+      good = ["u", "p", "s"]
+      bad  = ["", "abc", "x"]
+      wanted = /^[prstu]$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 50: Negated char class (anchored)
+
+    describe "A correct program (Negated char class (anchored))" do
+      prog = <<-'END'
+        match BOS ~'ilmnop' EOS end
+      END
+
+      good = ["a", "e", "h"]
+      bad  = ["o", "i", "l"]
+      wanted = /^[^ilmnop]$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 51: Simple string (anchored)
+
+    describe "A correct program (Simple string (anchored))" do
+      prog = <<-'END'
+        match BOS "xyz" EOS end
+      END
+
+      good = ["xyz"]
+      bad  = ["", "abc", "abcxyzdef", "xydefz"]
+      wanted = /^xyz$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 52: Single-bounded repetition (anchored)
+
+    describe "A correct program (Single-bounded repetition (anchored))" do
+      prog = <<-'END'
+        match BOS 5 * "xyz" EOS end
+      END
+
+      good = ["xyzxyzxyzxyzxyz"]
+      bad  = ["xyzxyzxyzxyz", "abcxyzxyzxyzxyz", "xyzxyzxyzxyzabc"]
+      wanted = /^(xyz){5}$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 53: Double-bounded repetition (anchored)
+
+    describe "A correct program (Double-bounded repetition (anchored))" do
+      prog = <<-'END'
+        match BOS 3,4 * %alpha EOS end
+      END
+
+      good = ["abc", "abcd"]
+      bad  = ["", "ab", "x", "abcde"]
+      wanted = /^([[:alpha:]]){3,4}$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 54: any-qualifier (anchored)
+
+    describe "A correct program (any-qualifier (anchored))" do
+      prog = <<-'END'
+        match BOS any "abc" EOS end
+      END
+
+      good = ["", "abc", "abcabc", "abcabcabc"]
+      bad  = ["ab", "abcab", "xyz"]
+      wanted = /^(abc)*$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 55: many-qualifier (anchored)
+
+    describe "A correct program (many-qualifier (anchored))" do
+      prog = <<-'END'
+        match BOS many "def" EOS end
+      END
+
+      good = ["def", "defdef", "defdefdef"]
+      bad  = ["", "d", "de", "defd", "xyz"]
+      wanted = /^(def)+$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 56: maybe-qualifier (anchored)
+
+    describe "A correct program (maybe-qualifier (anchored))" do
+      prog = <<-'END'
+        match BOS maybe "ghi" EOS end
+      END
+
+      good = ["", "ghi"]
+      bad  = ["abghicd", "gh"]
+      wanted = /^(ghi)?$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 57: Simple concatenation of two strings (anchored)
+
+    describe "A correct program (Simple concatenation of two strings (anchored))" do
+      prog = <<-'END'
+        match BOS "abc" "def" EOS end
+      END
+
+      good = ["abcdef"]
+      bad  = ["", "abcd", "xyzabcdef", "abcxyzdef", "abcdefxyz"]
+      wanted = /^abcdef$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 58: Concat of string and char class (anchored)
+
+    describe "A correct program (Concat of string and char class (anchored))" do
+      prog = <<-'END'
+        match BOS "abc" 'def' EOS end
+      END
+
+      good = ["abcd", "abce", "abcf"]
+      bad  = ["", "ab", "abc", "abcx"]
+      wanted = /^abc[def]$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 59: Simple alternation (anchored)
+
+    describe "A correct program (Simple alternation (anchored))" do
+      prog = <<-'END'
+        match BOS ("abc" | "def") EOS end
+      END
+
+      good = ["abc", "def"]
+      bad  = ["", "abde", "ab c d ef", "xdefy"]
+      wanted = /^(abc|def)$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 60: Alternation of concatenations (anchored)
+
+    describe "A correct program (Alternation of concatenations (anchored))" do
+      prog = <<-'END'
+        match BOS ("ab" "c" | "d" "ef") EOS end
+      END
+
+      good = ["abc", "def"]
+      bad  = ["", "abde", "ab c d ef", "xdefy"]
+      wanted = /^(abc|def)$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 61: Precedence of concatenation over alternation (anchored)
+
+    describe "A correct program (Precedence of concatenation over alternation (anchored))" do
+      prog = <<-'END'
+        match BOS ("a" "b" | "c") EOS end
+      END
+
+      good = ["ab", "c"]
+      bad  = ["", "b", "a", "d", "abc", "abcde"]
+      wanted = /^(ab|c)$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 62: Precedence of parens over concatenation (anchored)
+
+    describe "A correct program (Precedence of parens over concatenation (anchored))" do
+      prog = <<-'END'
+        match BOS "a" ("b" | "c") EOS end
+      END
+
+      good = ["ab", "ac"]
+      bad  = ["a", "b", "c", "abc", "abx", "bac"]
+      wanted = /^a(b|c)$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 63: Anchors and alternation (anchored)
+
+    describe "A correct program (Anchors and alternation (anchored))" do
+      prog = <<-'END'
+        match BOS "x" | "y" EOS end
+      END
+
+      good = ["xabc", "abcy"]
+      bad  = ["abc", "abcx", "yabc", "axb", "ayb", "axyb"]
+      wanted = /(^x|y$)/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 64: Parens, concatenation, alternation (anchored)
+
+    describe "A correct program (Parens, concatenation, alternation (anchored))" do
+      prog = <<-'END'
+        match BOS ((maybe `0) `1-`9 | `1 D2) EOS end
+      END
+
+      good = ["01", "09", "12"]
+      bad  = ["0", "00", "13"]
+      wanted = /^((0)?[1-9]|1[0-2])$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 65: Single backtick char (anchored)
+
+    describe "A correct program (Single backtick char (anchored))" do
+      prog = <<-'END'
+        match BOS `` EOS end
+      END
+
+      good = ["`"]
+      bad  = ["", "abc", "this is a tick: `", "tock ` tock"]
+      wanted = /^`$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 66: Single backslash char (anchored)
+
+    describe "A correct program (Single backslash char (anchored))" do
+      prog = <<-'END'
+        match BOS `\ EOS end
+      END
+
+      good = ["\\"]
+      bad  = ["\n", "\b", "neither \r nor \t", "trying \\n", "and \\b also"]
+      wanted = /^\\$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 67: Empty string (anchored)
+
+    describe "A correct program (Empty string (anchored))" do
+      prog = <<-'END'
+        match BOS "" EOS end
+      END
+
+      good = [""]
+      bad  = ["abc"]
+      wanted = /^$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 68: Simple one-char class (anchored)
+
+    describe "A correct program (Simple one-char class (anchored))" do
+      prog = <<-'END'
+        match BOS 'x' EOS end
+      END
+
+      good = ["x"]
+      bad  = ["", "abc", "uvwxyz"]
+      wanted = /^[x]$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 69: Alternation of range and class (anchored)
+
+    describe "A correct program (Alternation of range and class (anchored))" do
+      prog = <<-'END'
+        match BOS (`a-`f | 'xyz') EOS end
+      END
+
+      good = ["a", "x", "z", "c"]
+      bad  = ["", "ab", "abc", "xy", "jkl", "gw"]
+      wanted = /^([a-f]|[xyz])$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 70: Alternation of range and maybe-clause (anchored)
+
+    describe "A correct program (Alternation of range and maybe-clause (anchored))" do
+      prog = <<-'END'
+        match BOS (`1-`6| maybe "#") EOS end
+      END
+
+      good = ["", "1", "#", "6"]
+      bad  = ["55", "###"]
+      wanted = /^([1-6]|(\#)?)$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 71: Four-way alternation (anchored)
+
+    describe "A correct program (Four-way alternation (anchored))" do
+      prog = <<-'END'
+        match BOS (`a | `b|`c|`d) EOS end
+      END
+
+      good = ["a", "b", "c", "d"]
+      bad  = ["", "ab", "every", "ghijk"]
+      wanted = /^(a|b|c|d)$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 72: Concatenation of range and class (anchored)
+
+    describe "A correct program (Concatenation of range and class (anchored))" do
+      prog = <<-'END'
+        match BOS `a-`f 'xyz' EOS end
+      END
+
+      good = ["ax", "fz", "cy"]
+      bad  = ["axe", "fz123", "zf", "xa", "gz", "hp", "mx"]
+      wanted = /^[a-f][xyz]$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 73: Concat of strings and maybe-clause (anchored)
+
+    describe "A correct program (Concat of strings and maybe-clause (anchored))" do
+      prog = <<-'END'
+        match BOS "this" "that" maybe "other" EOS end
+      END
+
+      good = ["thisthat", "thisthatother"]
+      bad  = ["", "abc", "this that", "this that other", "abc thisthat xyz", "abc thisthatother xyz"]
+      wanted = /^thisthat(other)?$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 74: Simple repetition of class (anchored)
+
+    describe "A correct program (Simple repetition of class (anchored))" do
+      prog = <<-'END'
+        match BOS 3 * 'xyz' EOS end
+      END
+
+      good = ["xyz", "xxx", "yzy"]
+      bad  = ["", "abc", "xy", "axy", "xyb", "axyb", "xyzzy123"]
+      wanted = /^([xyz]){3}$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 75: Simple repetition of range (anchored)
+
+    describe "A correct program (Simple repetition of range (anchored))" do
+      prog = <<-'END'
+        match BOS 4 * `1-`6 EOS end
+      END
+
+      good = ["1111", "1234"]
+      bad  = ["", "abc", "123", "123 4", "abc 6543 def"]
+      wanted = /^([1-6]){4}$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 76: Complex repetition of char (anchored)
+
+    describe "A correct program (Complex repetition of char (anchored))" do
+      prog = <<-'END'
+        match BOS 3,5 * (`a) EOS end
+      END
+
+      good = ["aaa", "aaaa", "aaaaa"]
+      bad  = ["", "abc", "aa", "xaaay", "aaaaaaa"]
+      wanted = /^(a){3,5}$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 77: Complex repetition of parenthesized class (anchored)
+
+    describe "A correct program (Complex repetition of parenthesized class (anchored))" do
+      prog = <<-'END'
+        match BOS 4,7 * ('xyz') EOS end
+      END
+
+      good = ["xxxx", "yyyy", "xyzy", "xyzzy", "xyzxyz", "xyzxyzx"]
+      bad  = ["", "abc", "x", "xx", "xxx", "xyz xy", "xyzxyzxyzxyz", "zyzzyva"]
+      wanted = /^([xyz]){4,7}$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 78: Complex repetition of parenthesized range (anchored)
+
+    describe "A correct program (Complex repetition of parenthesized range (anchored))" do
+      prog = <<-'END'
+        match BOS 0,3 * (`1-`6) EOS end
+      END
+
+      good = ["", "1", "11", "111", "56", "654"]
+      bad  = ["1111", "x123y", "x123456y"]
+      wanted = /^([1-6]){0,3}$/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 79: Simple lookaround (pos-ahead)
+
+    describe "A correct program (Simple lookaround (pos-ahead))" do
+      prog = <<-'END'
+        match find "X" with "Y" end
+      END
+
+      good = ["XY"]
+      bad  = ["X", "Y", "YX"]
+      wanted = /(?=XY)X/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 80: Simple lookaround (neg-ahead)
+
+    describe "A correct program (Simple lookaround (neg-ahead))" do
+      prog = <<-'END'
+        match find "X" without "Y" end
+      END
+
+      good = ["X", "YX"]
+      bad  = ["XY", "Y"]
+      wanted = /(?!XY)X/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 81: Simple lookaround (pos-behind)
+
+    describe "A correct program (Simple lookaround (pos-behind))" do
+      prog = <<-'END'
+        match with "X" find "Y" end
+      END
+
+      good = ["XY"]
+      bad  = ["YX", "Y", "X"]
+      wanted = /(?<=X)Y/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 82: Simple lookaround (neg-behind)
+
+    describe "A correct program (Simple lookaround (neg-behind))" do
+      prog = <<-'END'
+        match without "X" find "Y" end
+      END
+
+      good = ["aY", "Y"]
+      bad  = ["XY", "X"]
+      wanted = /(?<!X)Y/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 83: Positive lookahead
+
+    describe "A correct program (Positive lookahead)" do
+      prog = <<-'END'
+        match find (3*D " dollars") with 3*D end
+      END
+
+      good = ["101 dollars"]
+      bad  = ["102 pesos"]
+      wanted = /(?=\d{3} dollars)\d{3}/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 84: Negative lookahead
+
+    describe "A correct program (Negative lookahead)" do
+      prog = <<-'END'
+        match find 3*D without " pesos" end
+      END
+
+      good = ["103 dollars", "104 euros"]
+      bad  = ["105 pesos"]
+      wanted = /(?!\d{3} pesos)\d{3}/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 85: Positive lookbehind
+
+    describe "A correct program (Positive lookbehind)" do
+      prog = <<-'END'
+        match with "USD" find 3*D end
+      END
+
+      good = ["USD106"]
+      bad  = ["EUR107"]
+      wanted = /(?<=USD)\d{3}/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+    ### Test 86: Negative lookbehind
+
+    describe "A correct program (Negative lookbehind)" do
+      prog = <<-'END'
+        match without "USD" find 3*D end
+      END
+
+      good = ["EUR108"]
+      bad  = ["USD109"]
+      wanted = /(?<!USD)\d{3}/
+
+      myprog = Program.new(prog)
+      parsed = nil
+
+      it "should parse correctly"  do
+        parsed = myprog.parseable?
+        myprog.debug_bad_program_parse unless parsed
+        parsed.should == true
+      end
+
+      rx = nil
+      it "can be converted to a regex" do
+        rx = myprog.regexp
+        rx.class.should == Regexp
+      end
+
+      # Check sanity: Is test valid?
+      good.each {|str| it('has expected regex matching ' + str.inspect) { wanted.should =~ str } } 
+      bad.each  {|str| it('has expected regex NOT matching ' + str.inspect) { wanted.should_not =~ str } } 
+
+      # Is compiled result valid?
+      good.each {|str| it('should match ' + str.inspect) { rx.should =~ str } } 
+      bad.each  {|str| it('should NOT match ' + str.inspect) { rx.should_not =~ str } } 
+
+      
+      end
+
+
+  end