activefacts 0.8.9 → 0.8.10

data/spec/cql/parser/constraints_spec.rb

@@ -0,0 +1,19 @@
+#
+# ActiveFacts tests: Test the CQL parser by looking at its parse trees.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+require 'activefacts/cql'
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'spec_helper'
+require 'helpers/test_parser'
+
+describe "ASTs from Derived Fact Types with expressions" do
+  it "should parse a simple comparison clause" do
+    %q{
+      each combination FamilyName, GivenName occurs at most one time in Competitor has FamilyName, Competitor has GivenName;
+    }.should parse_to_ast \
+      "PresenceConstraint over [[{Competitor} \"has\" {FamilyName}], [{Competitor} \"has\" {GivenName}]] -1 over ({FamilyName}, {GivenName})"
+  end
+end

data/spec/cql/parser/entity_types_spec.rb

@@ -0,0 +1,106 @@
+#
+# ActiveFacts tests: Test the CQL parser by looking at its parse trees.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+require 'activefacts/cql'
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'helpers/test_parser'
+
+describe "Entity Types" do
+  EntityTypes_RefMode = [
+    [ "a is identified by its id;",                     # Entity type declaration with reference mode
+      ["EntityType: a identified by its id;"]
+    ],
+    [ "a is identified by its number(12);",                     # Entity type declaration with reference mode
+      ["EntityType: a identified by its number(12);"]
+    ],
+    [ "a is identified by its id where c;",                   # Entity type declaration with reference mode and fact type(s)
+      ["EntityType: a identified by its id where [{c}];"]
+    ],
+    [ "a is identified by its id where c;",             # Entity type declaration with reference mode and where
+      ["EntityType: a identified by its id where [{c}];"]
+    ],
+  ]
+
+  EntityTypes_Simple = [
+    [ "a is identified by b where c;",                       # Entity type declaration
+      ["EntityType: a [{b}] where [{c}];"]
+    ],
+    [ "a is identified by b where c;",                  # Entity type declaration with where
+      ["EntityType: a [{b}] where [{c}];"]
+    ],
+    [ "a is identified by b and c where d;",                 # Entity type declaration with two-part identifier
+      ["EntityType: a [{b}, {c}] where [\"d\"];"]
+    ],
+    [ "a is identified by b, c where d;",                    # Entity type declaration with two-part identifier
+      ["EntityType: a [{b}, {c}] where [\"d\"];"]
+    ],
+    [ "a is written as b(); e is identified by a where d;",
+      ["ValueType: a is written as b;", "EntityType: e [{a}] where [\"d\"];"]
+    ],
+    [ " a is written as b ( ) ; e is identified by a where d ; ",
+      ["ValueType: a is written as b;", "EntityType: e [{a}] where [\"d\"];"]
+    ],
+    [ "e is written as b; a is identified by e where maybe d;",
+      ["ValueType: e is written as b;", "EntityType: a [{e}] where [[\"maybe\"] \"d\"];"]
+    ],
+  ]
+
+  EntityTypes_Objectified = [
+    [ "Director is where b directs c, c is directed by b;",
+      ["FactType: Director [{b} \"directs\" {c}, {c} \"is directed by\" {b}]"]
+    ],
+  ]
+
+  EntityTypes_Subtypes = [
+    [ "Employee is a kind of Person;",
+      ["EntityType: Employee < Person nil;"]
+    ],
+    [ "Employee is a subtype of Person;",
+      ["EntityType: Employee < Person nil;"]
+    ],
+    [ "AustralianEmployee is a subtype of Employee, Australian;",
+      ["EntityType: AustralianEmployee < Employee,Australian nil;"]
+    ],
+    [ "Employee is a kind of Person identified by EmployeeNumber;",
+      ["EntityType: Employee < Person [{EmployeeNumber}];"]
+    ],
+    [ "Employee is a subtype of Person identified by EmployeeNumber;",
+      ["EntityType: Employee < Person [{EmployeeNumber}];"]
+    ],
+    [ "AustralianEmployee is a subtype of Employee, Australian identified by TaxFileNumber;",
+      ["EntityType: AustralianEmployee < Employee,Australian [{TaxFileNumber}];"]
+    ],
+  ]
+
+  EntityTypes =
+    EntityTypes_RefMode +
+    EntityTypes_Simple +
+    EntityTypes_Objectified +
+    EntityTypes_Subtypes
+
+  before :each do
+    @parser = TestParser.new
+    @parser.parse_all("c is written as b;", :definition)
+  end
+
+  EntityTypes.each do |c|
+    source, ast = *c
+    it "should parse #{source.inspect}" do
+      result = @parser.parse_all(source, :definition)
+
+      puts @parser.failure_reason unless result
+      result.should_not be_nil
+
+      canonical_form = result.map{|d| d.ast.to_s}
+      if ast
+        canonical_form.should == ast
+      else
+        puts "#{source.inspect} should compile to"
+        puts "\t#{canonical_form}"
+      end
+    end
+  end
+end

data/spec/cql/parser/expressions_spec.rb

@@ -0,0 +1,179 @@
+#
+# ActiveFacts tests: Test the CQL parser by looking at its parse trees.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+require 'activefacts/cql'
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'spec_helper'
+require 'helpers/test_parser'
+
+describe "ASTs from Derived Fact Types with expressions" do
+  it "should parse a simple comparison clause" do
+    # Director is old: Company is directed by Person who is of Age > 60;
+    %q{
+      Director is old: Person directs Company, Person is of Age, Age > 60;
+    }.should parse_to_ast \
+      %q{FactType: [{Director} "is old"] where {Person} "directs" {Company} ,
+        {Person} "is of" {Age} ,
+        compare>({Age} 60)}
+  end
+
+  it "should parse a comparison clause with subscripts" do
+    %q{
+      Director is old: Person directs Company, Person has Salary(2), Person is of Age(1), Age(1) > Salary(2);
+    }.should parse_to_ast \
+      %q{
+        FactType: [{Director} "is old"]
+        where {Person} "directs" {Company} ,
+        {Person} "has" {Salary(2)} ,
+        {Person} "is of" {Age(1)} ,
+        compare>({Age(1)} {Salary(2)})
+      }
+  end
+
+  it "should parse simple comparison clause having an unmarked adjective" do
+    %q{
+      Person is independent: Person has taxable- Income and taxable Income >= 20000 dollars or Person has sugar-Daddy;
+    }.should parse_to_ast \
+      %q{FactType: [{Person} "is independent"] where {Person} "has" {taxable- Income} and
+        compare>=({taxable- Income} (20000 in dollars)) or {Person} "has" {sugar- Daddy}}
+  end
+
+  it "should parse a reading with a contracted comparison expression" do
+    %q{
+      Director is old: Person directs company, Person is of Age > 20+2*20;
+    }.should parse_to_ast \
+      %q{FactType: [{Director} "is old"] where {Person} "directs company" ,
+        {Person} "is of" {Age}
+        > compare>({Age} sum(20 product(2 20)))}
+  end
+
+  it "should parse a right-contracted comparison clause after a right-contracted clause" do
+    %q{
+      Director is old: Company is directed by Person who is of Age > 60;
+    }.should parse_to_ast \
+      %q{FactType: [{Director} "is old"] where {Company} "is directed by" {Person} who
+        {Person} "is of" {Age} >
+        compare>({Age} 60)}
+  end
+
+  it "should parse a simple reading with qualifiers" do
+    %q{
+      Person(1) is ancestor of Person(2): maybe Person(1) is parent of Person(2) [transitive];
+    }.should parse_to_ast \
+      %q{FactType: [{Person(1)} "is ancestor of" {Person(2)}] where
+        ["maybe", "transitive"] {Person(1)} "is parent of" {Person(2)}}
+  end
+
+  it "should parse a contracted reading with qualifiers" do
+    %q{
+      Person(1) provides lineage of Person(2): maybe Person(2) is child of Person(1) [transitive] who is male;
+    }.should parse_to_ast \
+      %q{FactType: [{Person(1)} "provides lineage of" {Person(2)}] where
+        ["maybe", "transitive"] {Person(2)} "is child of" {Person(1)} 
+        who {Person(1)} "is male"}
+  end
+
+  it "should parse a contracted readings and comparisons with qualifiers" do
+    %q{
+      Person(1) is ancestor of adult Person(2):
+        maybe Person(1) is parent of Person(2) [transitive]
+          who maybe is of Age [static]
+            definitely >= 21;
+    }.should parse_to_ast \
+      %q{FactType: [{Person(1)} "is ancestor of adult" {Person(2)}] where
+        ["maybe", "transitive"] {Person(1)} "is parent of" {Person(2)}
+        who ["maybe", "static"] {Person(2)} "is of" {Age}
+        >= compare>=({Age} 21, [definitely])}
+  end
+
+  it "should parse a comparison expression with a contracted reading" do
+    %q{
+      Director is old: Person directs company, 3*30 >= Age that is of Person;
+    }.should parse_to_ast \
+      %q{FactType: [{Director} "is old"] where {Person} "directs company" ,
+        compare>=(product(3 30) {Age})
+        that {Age} "is of" {Person}}
+  end
+
+  it "should parse a comparison expression with a contracted comparison" do
+    %q{
+      Director is old: Person directs company, Person is of Age, maybe 20 <= Age definitely < 60;
+    }.should parse_to_ast \
+      %q{FactType: [{Director} "is old"] where {Person} "directs company" ,
+        {Person} "is of" {Age} ,
+        compare<=(20 {Age}, [maybe]) 
+        < compare<({Age} 60, [definitely])}
+  end
+
+  it "should parse a comparison expression with right-contracted then left-contracted comparisons"
+    # Director is probably adult: Person directs company, Person is of Age maybe >= 21 and definitely < 60;
+  # end
+
+  it "should fail to parse a contracted comparison that doesn't follow a role" do
+    %q{
+      Director is old: Person directs company, Person is of Age considerable > 3*20;
+    }.should fail_to_parse /Expected (.|\n)* after (.|\n)* Age considerable $/
+  end
+
+  it "should parse pre and post-qualifiers and leading and trailing adjectives with contracted comparisons" do
+    %q{
+      A is a farce: maybe A has completely- B [transitive, acyclic] < 5, B -c = 2;
+    }.should parse_to_ast \
+      %q{FactType: [{A} "is a farce"] where ["acyclic", "maybe", "transitive"] {A} "has" {completely- B}
+        < compare<({completely- B} 5)
+        , compare=({B -c} 2)}
+  end
+
+  it "should parse multiple leading and trailing adjectives with contracted comparisons" do
+    %q{
+      A is a farce: maybe A has completely- green B [transitive, acyclic] < 9, B c -d = 2;
+    }.should parse_to_ast \
+      %q{FactType: [{A} "is a farce"] where ["acyclic", "maybe", "transitive"] {A} "has" {completely- green B} 
+      < compare<({completely- green B} 9)
+      , compare=({B c -d} 2)}
+  end
+
+  it "should parse a comparison clause containing units" do
+    %q{
+      254 mm converts to foot/feet;
+      Width is written as Integer mm;
+      Window requires toughening where
+        Window has Width,
+        Window has Height,
+        Width * Height >= 10 feet^2;
+    }.should parse_to_ast \
+      %q{Unit(foot/feet) is 254/1+0 mm^1},
+      %q{ValueType: Width is written as Integer in [["mm", 1]];},
+      %q{FactType: [{Window} "requires toughening"] where {Window} "has" {Width} ,
+        {Window} "has" {Height}
+        , compare>=(product({Width} {Height}) (10 in feet^2))}
+  end
+
+  it "should parse nested expressions" do
+    %q{
+      A is written as B;
+      A > B+3*(4+5)?
+    }.should parse_to_ast \
+      %q{ValueType: A is written as B;},
+      %q{FactType: [] where compare>({A} sum({B} product(3 sum(4 5))))}
+  end
+
+  it "should parse a fact type containing an expression with subscripts"
+
+  it "should parse a fact type containing objectification joins and contractions" do
+    %q{
+      Driving was negligent where
+        Driving (where maybe Driver drove in Incident [acyclic] that definitely is of Claim [intransitive]) followed Intoxication [static];
+    }.should parse_to_ast \
+      %q{
+        FactType: [{Driving} "was negligent"] where ["static"] {Driving}
+        (where ["acyclic", "maybe"] {Driver} "drove in" {Incident}
+          that ["definitely", "intransitive"] {Incident} "is of" {Claim})
+        "followed" {Intoxication}
+      }
+  end
+
+end

data/spec/cql/parser/fact_types_spec.rb

@@ -0,0 +1,41 @@
+#
+# ActiveFacts tests: Test the CQL parser by looking at its parse trees.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+require 'activefacts/cql'
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'spec_helper'
+require 'helpers/test_parser'
+
+describe "Fact Types" do
+  FactTypes = [
+    [ "Foo has at most one Bar, Bar is of one Foo restricted to {1..10};",
+      ["FactType: [{Foo} \"has\" {[..1] Bar}, {Bar} \"is of\" {[1..1] Foo ValueConstraint to ([1..10])}]"]
+    ],
+    [ "Bar(1) is related to Bar(2), primary-Bar(1) has secondary-Bar(2);",
+      ["FactType: [{Bar(1)} \"is related to\" {Bar(2)}, {primary- Bar(1)} \"has\" {secondary- Bar(2)}]"]
+    ],
+    # REVISIT: Test all quantifiers
+    # REVISIT: Test all post-qualifiers
+#    [ "AnnualIncome is where Person has total- Income in Year: Person has total- Income.sum(), Income was earned in current- Time.Year() (as Year);",
+#      [%q{FactType: AnnualIncome [{Person} "has" {total- Income} "in" {Year}] where {Person} "has" {total- Income}.sum() , {Income} "was earned in" {current- Time (as Year)}.Year()}]
+#    ],
+    [ "A is interesting : b- C has F -g;",
+      ["FactType: [{A} \"is interesting\"] where {b- C} \"has\" {F -g}"]
+    ]
+    # REVISIT: Test all quantifiers
+  ]
+
+  before :each do
+    @parser = TestParser.new
+  end
+
+  FactTypes.each do |c|
+    source, ast, definition = *c
+    it "should parse #{source.inspect}" do
+      source.should parse_to_ast *ast
+    end
+  end
+end

data/spec/cql/parser/literals_spec.rb

@@ -0,0 +1,312 @@
+#
+# ActiveFacts tests: Test the CQL parser by looking at its parse trees.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+
+require 'activefacts/cql'
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'helpers/test_parser'
+
+describe "Valid Numbers, Strings and Ranges" do
+  ValidNumbersEtc = [
+    [ "a is written as b;",                               # Value type declaration, no params, minimal whitespace
+      ['ValueType: a is written as b;']
+    ],
+    [ "a is written as B;",                               # Value type declaration, no params, minimal whitespace
+      ['ValueType: a is written as B;']
+    ],
+    [ "a is written as b();",                             # Value type declaration, minimal whitespace
+      ['ValueType: a is written as b;']
+    ],
+    [ "a is written as b ;",                              # Value type declaration, no params, trailing whitespace
+      ['ValueType: a is written as b;']
+    ],
+    [ "a is written as b ( ) ; ",                         # Value type declaration, maximal whitespace
+      ['ValueType: a is written as b;']
+    ],
+
+    # Comments and newlines, etc as whitespace
+    [ "\na\nis written as \nb\n(\n)\n;\n",                # Basic value type declaration, newlines for whitespace
+      ['ValueType: a is written as b;']
+    ],
+    [ "\ra\ris written as\rb\r(\r)\r;\r",                 # Basic value type declaration, returns for whitespace
+      ['ValueType: a is written as b;']
+    ],
+    [ "\ta\tis written as\tb\t(\t)\t;\t",                 # Basic value type declaration, tabs for whitespace
+      ['ValueType: a is written as b;']
+    ],
+    [ " /* Plugh */ a /* Plugh */ is written as\n b /* *Plugh* / */ ( /* *Plugh* / */ ) /* *Plugh* / */ ; /* *Plugh* / */ ",
+      ['ValueType: a is written as b;']
+    ],
+    [ "//Plugh\na // Plugh\n is written as // Plugh\n b // Plugh\n ( // Plugh\n ) // Plugh\n ; // Plugh\n ",
+      ['ValueType: a is written as b;']
+    ],
+
+    # Integers
+    [ "a is written as b(0);",                            # Integer zero
+      ['ValueType: a is written as b(0);']
+    ],
+    [ "a is written as b( 0 ) ; ",                        # Integer zero, maximal whitespace
+      ['ValueType: a is written as b(0);']
+    ],
+    [ "a is written as b(1);",                            # Integer one
+      ['ValueType: a is written as b(1);']
+    ],
+    [ "a is written as b(-1);",                           # Integer negative one
+      ['ValueType: a is written as b(-1);']
+    ],
+    [ "a is written as b(+1);",                           # Positive integer
+      ['ValueType: a is written as b(1);']
+    ],
+    [ "a is written as b(1e4);",                          # Integer with exponent
+      ['ValueType: a is written as b(10000.0);']
+    ],
+    [ "a is written as b(1e-4);",                         # Integer with negative exponent
+      ['ValueType: a is written as b(0.0001);']
+    ],
+    [ "a is written as b(-1e-4);",                        # Negative integer with negative exponent
+      ['ValueType: a is written as b(-0.0001);']
+    ],
+    [ "a is written as b(077);",                          # Octal integer
+      ['ValueType: a is written as b(63);']
+    ],
+    [ "a is written as b(0xFace8);",                      # Hexadecimal integer
+      ['ValueType: a is written as b(1027304);']
+    ],
+    [ "a is written as b(0,1);",                          # Two parameters
+      ['ValueType: a is written as b(0, 1);']
+    ],
+    [ "a is written as b( 0 , 1 );",
+      ['ValueType: a is written as b(0, 1);']
+    ],
+    [ "a is written as b(0,1,2) ;",                       # Three parameters now allowed
+      ['ValueType: a is written as b(0, 1, 2);']
+    ],
+
+    # Reals
+    [ "a is written as b(1.0);",
+      ['ValueType: a is written as b(1.0);']
+    ],
+    [ "a is written as b(-1.0);",
+      ['ValueType: a is written as b(-1.0);']
+    ],
+    [ "a is written as b(+1.0);",
+      ['ValueType: a is written as b(1.0);']
+    ],
+    [ "a is written as b(0.1);",
+      ['ValueType: a is written as b(0.1);']
+    ],
+    [ "a is written as b(-0.1);",
+      ['ValueType: a is written as b(-0.1);']
+    ],
+    [ "a is written as b(+0.1);",
+      ['ValueType: a is written as b(0.1);']
+    ],
+    [ "a is written as b(0.0);",
+      ['ValueType: a is written as b(0.0);']
+    ],
+    [ "a is written as b(-0.0);",
+      ['ValueType: a is written as b(-0.0);']
+    ],
+    [ "a is written as b(+0.0);",
+      ['ValueType: a is written as b(0.0);']
+    ],
+
+    # Value types with units
+    [ "a is written as b inch;",                          # Value type declaration with unit
+      ['ValueType: a is written as b in [["inch", 1]];']
+    ],
+    [ "a is written as b() inch ; ",                      # Value type declaration with unit and whitespace
+      ['ValueType: a is written as b in [["inch", 1]];']
+    ],
+    [ "a is written as b() inch;",                        # Value type declaration with unit
+      ['ValueType: a is written as b in [["inch", 1]];']
+    ],
+    [ "a is written as b inch^2;",                        # Value type declaration with unit and exponent
+      ['ValueType: a is written as b in [["inch", 2]];']
+    ],
+    [ "a is written as b() inch^2 ; ",                    # Value type declaration with unit and exponent with maximum whitespace
+      ['ValueType: a is written as b in [["inch", 2]];']
+    ],
+    [ "a is written as b second^-1;",                     # Value type declaration with unit and negative exponent
+      ['ValueType: a is written as b in [["second", -1]];']
+    ],
+    [ "a is written as b inch inch;",                     # Value type declaration with repeated unit
+      ['ValueType: a is written as b in [["inch", 1], ["inch", 1]];']
+    ],
+    [ "a is written as b inch^2/minute^-1;",              # Value type declaration with unit and divided unit with exponents
+      ['ValueType: a is written as b in [["inch", 2], ["minute", 1]];']
+    ],
+    [ "a is written as b() second^-1/mm^-1 mm^-1;",       # Value type declaration with repeated divided unit
+      ['ValueType: a is written as b in [["second", -1], ["mm", 1], ["mm", 1]];']
+    ],
+
+    # Integer value constraints
+    [ "a is written as b()restricted to{1};",             # Integer, minimal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([1]);']
+    ],
+    [ "a is written as b() restricted to { 1 } ;",        # Integer, maximal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([1]);']
+    ],
+    [ "a is written as b() restricted to {1..2};",        # Integer range, minimal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([1..2]);']
+    ],
+    [ "a is written as b() restricted to { 1 .. 2 };",    # Integer range, maximal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([1..2]);']
+    ],
+    [ "a is written as b() restricted to {..2};",         # Integer range with open start, minimal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([-Infinity..2]);']
+    ],
+    [ "a is written as b() restricted to { .. 2 };",      # Integer range with open start, maximal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([-Infinity..2]);']
+    ],
+    [ "a is written as b() restricted to { ..2,3};",      # Range followed by integer, minimal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([-Infinity..2, 3]);']
+    ],
+    [ "a is written as b() restricted to { 1,..2,3};",    # Integer, open-start range, integer, minimal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([1, -Infinity..2, 3]);']
+    ],
+    [ "a is written as b() restricted to { .. 2 , 3 };",  # Range followed by integer, maximal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([-Infinity..2, 3]);']
+    ],
+    [ "a is written as b() restricted to { ..2 , 3..4 };",# Range followed by range
+      ['ValueType: a is written as b ValueConstraint to ([-Infinity..2, 3..4]);']
+    ],
+    [ "a is written as b() restricted to { ..2, 3..};",   # Range followed by range with open end, minimal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([-Infinity..2, 3..Infinity]);']
+    ],
+    [ "a is written as b() restricted to { ..2, 3 .. };", # Range followed by range with open end, maximal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([-Infinity..2, 3..Infinity]);']
+    ],
+    [ "a is written as b() restricted to { 1e4 } ;",      # Integer with exponent
+      ['ValueType: a is written as b ValueConstraint to ([10000.0]);']
+    ],
+    [ "a is written as b() restricted to { -1e4 } ;",     # Negative integer with exponent
+      ['ValueType: a is written as b ValueConstraint to ([-10000.0]);']
+    ],
+    [ "a is written as b() restricted to { 1e-4 } ;",     # Integer with negative exponent
+      ['ValueType: a is written as b ValueConstraint to ([0.0001]);']
+    ],
+    [ "a is written as b() restricted to { -1e-4 } ;",    # Negative integer with negative exponent
+      ['ValueType: a is written as b ValueConstraint to ([-0.0001]);']
+    ],
+
+    # Real value constraints
+    [ "a is written as b() restricted to {1.0};",         # Real, minimal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([1.0]);']
+    ],
+    [ "a is written as b() restricted to { 1.0 } ;",      # Real, maximal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([1.0]);']
+    ],
+    [ "a is written as b() restricted to { 1.0e4 } ;",    # Real with exponent
+      ['ValueType: a is written as b ValueConstraint to ([10000.0]);']
+    ],
+    [ "a is written as b() restricted to { 1.0e-4 } ;",   # Real with negative exponent
+      ['ValueType: a is written as b ValueConstraint to ([0.0001]);']
+    ],
+    [ "a is written as b() restricted to { -1.0e-4 } ;",  # Negative real with negative exponent
+      ['ValueType: a is written as b ValueConstraint to ([-0.0001]);']
+    ],
+    [ "a is written as b() restricted to { 1.1 .. 2.2 } ;",       # Real range, maximal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([1.1..2.2]);']
+    ],
+    [ "a is written as b() restricted to { -1.1 .. 2.2 } ;",      # Real range, maximal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([-1.1..2.2]);']
+    ],
+    [ "a is written as b() restricted to { 1.1..2.2};",   # Real range, minimal whitespace
+      ['ValueType: a is written as b ValueConstraint to ([1.1..2.2]);']
+    ],
+    [ "a is written as b() restricted to { 1.1..2 } ;",   # Real-integer range
+      ['ValueType: a is written as b ValueConstraint to ([1.1..2]);']
+    ],
+    [ "a is written as b() restricted to { 1..2.2 } ;",   # Integer-real range
+      ['ValueType: a is written as b ValueConstraint to ([1..2.2]);']
+    ],
+    [ "a is written as b() restricted to { ..2.2};",      # Real range with open start
+      ['ValueType: a is written as b ValueConstraint to ([-Infinity..2.2]);']
+    ],
+    [ "a is written as b() restricted to { 1.1.. };",     # Real range with open end
+      ['ValueType: a is written as b ValueConstraint to ([1.1..Infinity]);']
+    ],
+    [ "a is written as b() restricted to { 1.1.., 2 };",  # Real range with open end and following integer
+      ['ValueType: a is written as b ValueConstraint to ([1.1..Infinity, 2]);']
+    ],
+
+    # Strings and string value constraints
+    [ "a is written as b() restricted to {''};",          # String, empty, minimal whitespace
+      ['ValueType: a is written as b ValueConstraint to (["\'\'"]);']
+    ],
+    [ "a is written as b() restricted to {'A'};",         # String, minimal whitespace
+      ['ValueType: a is written as b ValueConstraint to (["\'A\'"]);']
+    ],
+    [ "a is written as b() restricted to { 'A' };",       # String, maximal whitespace
+      ['ValueType: a is written as b ValueConstraint to (["\'A\'"]);']
+    ],
+    [ "a is written as b() restricted to { '\\b\\t\\f\\n\\r\\e\\\\' };",  # String with special escapes
+      ["ValueType: a is written as b ValueConstraint to ([\"'\\\\b\\\\t\\\\f\\\\n\\\\r\\\\e\\\\\\\\'\"]);"]
+    ],
+    [ "a is written as b() restricted to { ' ' };",       # String with space
+      ['ValueType: a is written as b ValueConstraint to (["\' \'"]);']
+    ],
+    [ "a is written as b() restricted to { '\t' };",      # String with literal tab
+      ['ValueType: a is written as b ValueConstraint to (["\'\t\'"]);']
+    ],
+    [ "a is written as b() restricted to { '\\0' };",     # String with nul character
+      ["ValueType: a is written as b ValueConstraint to ([\"'\\\\0'\"]);"]
+    ],
+    [ "a is written as b() restricted to { '\\077' };",   # String with octal escape
+      ["ValueType: a is written as b ValueConstraint to ([\"'\\\\077'\"]);"]
+    ],
+    [ "a is written as b() restricted to { '\\0xA9' };",  # String with hexadecimal escape
+      ["ValueType: a is written as b ValueConstraint to ([\"'\\\\0xA9'\"]);"]
+    ],
+    [ "a is written as b() restricted to { '\\0uBabe' };",# String with unicode escape
+      ["ValueType: a is written as b ValueConstraint to ([\"'\\\\0uBabe'\"]);"]
+    ],
+    [ "a is written as b() restricted to {'A'..'F'};",    # String range, minimal whitespace
+      ['ValueType: a is written as b ValueConstraint to (["\'A\'".."\'F\'"]);']
+    ],
+    [ "a is written as b() restricted to { 'A' .. 'F' };",# String range, maximal whitespace
+      ['ValueType: a is written as b ValueConstraint to (["\'A\'".."\'F\'"]);']
+    ],
+    [ "a is written as b() restricted to { ..'F' };",     # String range, open start
+      ['ValueType: a is written as b ValueConstraint to (["MIN".."F"]);']
+    ],
+    [ "a is written as b() restricted to { 'A'.. };",     # String range, open end
+      ['ValueType: a is written as b ValueConstraint to (["\'A\'".."MAX"]);']
+    ],
+
+    # Value constraints with units
+    [ "a is written as b() restricted to {1} inches^2/second;",    # constraint with units and exponent
+      ['ValueType: a is written as b ValueConstraint to ([1]) in [["inches", 2], ["second", -1]];']
+    ],
+    [ "a is written as b() second^-1/mm^-1 mm^-1 restricted to {1} inches^2/second;",    # type with unit and constraint with units and exponent
+      #['a is written as b ValueConstraint to ([1]) in [["inches", 2], ["second", -1]];']
+      ["ValueType: a is written as b in [[\"second\", -1], [\"mm\", 1], [\"mm\", 1]] ValueConstraint to ([1]) in [[\"inches\", 2], [\"second\", -1]];"]
+    ],
+  ]
+
+  before :each do
+    @parser = TestParser.new
+  end
+
+  ValidNumbersEtc.each do |c|
+    source, ast = *c
+    it "should parse #{source.inspect}" do
+      result = @parser.parse_all(source, :definition)
+
+      puts @parser.failure_reason unless result
+      result.should_not be_nil
+
+      canonical_form = result.map{|d| d.ast.to_s}
+      if ast
+        canonical_form.should == ast
+      else
+        puts "#{source.inspect} should compile to"
+        puts "\t#{canonical_form}"
+      end
+    end
+  end
+end
+