activefacts 1.6.0 → 1.7.1

data/spec/cql/parser/entity_types_spec.rb

@@ -1,106 +0,0 @@
-#
-# 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\"];"]
-    ],
-    [ "aa is written as b(); e is identified by aa where d;",
-      ["ValueType: aa is written as b;", "EntityType: e [{aa}] where [\"d\"];"]
-    ],
-    [ " aa is written as b ( ) ; e is identified by aa where d ; ",
-      ["ValueType: aa is written as b;", "EntityType: e [{aa}] where [\"d\"];"]
-    ],
-    [ "e is written as b; aa is identified by e where maybe d;",
-      ["ValueType: e is written as b;", "EntityType: aa [{e}] where [maybe \"d\"];"]
-    ],
-  ]
-
-  EntityTypes_Objectified = [
-    [ "Director is where b directs c, c is directed by b;",
-      ["FactType: [{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

@@ -1,199 +0,0 @@
-#
-# 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: Query: where {Person} "directs" {Company} ,
-	{Person} "is of" {Age} ,
-	COMPARE>({Age} WITH 60)
-	[{Director} "is old"]
-      }
-  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: Query: where {Person} "directs" {Company} ,
-	{Person} "has" {Salary(2)} ,
-	{Person} "is of" {Age(1)} ,
-	COMPARE>({Age(1)} WITH {Salary(2)})
-	[{Director} "is old"]
-      }
-  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: Query: where {Person} "has" {taxable- Income} and
-	COMPARE>=({taxable- Income} WITH (20000 in dollars)) or
-	{Person} "has" {sugar- Daddy}
-	[{Person} "is independent"]
-      }
-  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: Query: where {Person} "directs company" ,
-	{Person} "is of" {Age} > COMPARE>({Age} WITH SUM(20 PLUS PRODUCT(2 TIMES 20)))
-	[{Director} "is old"]
-      }
-  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: Query: where {Company} "is directed by" {Person} who {Person} "is of" {Age} > COMPARE>({Age} WITH 60) [{Director} "is old"]}
-  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: Query: where ["transitive"] maybe {Person(1)} "is parent of" {Person(2)} [{Person(1)} "is ancestor 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: Query: where ["transitive"] maybe {Person(2)} "is child of" {Person(1)} who {Person(1)} "is male" [{Person(1)} "provides lineage of" {Person(2)}]}
-  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: Query: where ["transitive"] maybe {Person(1)} "is parent of" {Person(2)} who
-	["static"] maybe {Person(2)} "is of" {Age} >=
-	COMPARE>=({Age} WITH 21)
-	[{Person(1)} "is ancestor of adult" {Person(2)}]
-      }
-  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: Query: where {Person} "directs company" ,
-	COMPARE>=(PRODUCT(3 TIMES 30) WITH {Age}) that
-	{Age} "is of" {Person}
-	[{Director} "is old"]
-      }
-  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: Query: where {Person} "directs company" ,
-	{Person} "is of" {Age} ,
-	COMPARE<=(maybe 20 WITH {Age}) <
-	COMPARE<({Age} WITH 60)
-	[{Director} "is old"]
-      }
-  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 > 3\*20;\n *$/
-  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: Query: where ["acyclic", "transitive"] maybe {A} "has" {completely- B} <
-	COMPARE<({completely- B} WITH 5) ,
-	COMPARE=({B -c} WITH 2)
-	[{A} "is a farce"]
-      }
-  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: Query: where ["acyclic", "transitive"] maybe {A} "has" {completely- green B} <
-	COMPARE<({completely- green B} WITH 9) ,
-	COMPARE=({B c -d} WITH 2)
-	[{A} "is a farce"]
-      }
-  end
-
-  it "should parse a comparison clause containing units" do
-    %q{
-      254 mm converts to foot/feet;
-      Width is written as Integer in 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: Query: where {Window} "has" {Width} ,
-	{Window} "has" {Height} ,
-	COMPARE>=(PRODUCT({Width} TIMES {Height}) WITH (10 in feet^2))
-	[{Window} "requires toughening"]
-      }
-  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: Query: where COMPARE>({A} WITH SUM({B} PLUS PRODUCT(3 TIMES SUM(4 PLUS 5)))) []}
-  end
-
-  it "should parse a fact type containing an expression with subscripts"
-
-  it "should parse a fact type containing objectification steps 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: Query: where ["static"] {Driving} (in which where
-	["acyclic"] maybe {Driver} "drove in" {Incident}
-	  that ["intransitive"] {Incident} "is of" {Claim}) "followed" {Intoxication}
-	[{Driving} "was negligent"]
-      }
-  end
-
-end

data/spec/cql/parser/fact_types_spec.rb

@@ -1,44 +0,0 @@
-#
-# 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;",
-      [%q{FactType: Query: where {b- C} "has" {F -g} [{A} "is interesting"]}]
-    ],
-    [ "A has one pre-- bound B;",
-      [%q{FactType: [{A} "has" {[1..1] pre-bound- B}]}]
-    ]
-    # 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

@@ -1,312 +0,0 @@
-#
-# 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 in inch;",                          # Value type declaration with unit
-      ['ValueType: a is written as b in [["inch", 1]];']
-    ],
-    [ "a is written as b() in inch ; ",                      # Value type declaration with unit and whitespace
-      ['ValueType: a is written as b in [["inch", 1]];']
-    ],
-    [ "a is written as b() in inch;",                        # Value type declaration with unit
-      ['ValueType: a is written as b in [["inch", 1]];']
-    ],
-    [ "a is written as b in inch^2;",                        # Value type declaration with unit and exponent
-      ['ValueType: a is written as b in [["inch", 2]];']
-    ],
-    [ "a is written as b() in 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 in second^-1;",                     # Value type declaration with unit and negative exponent
-      ['ValueType: a is written as b in [["second", -1]];']
-    ],
-    [ "a is written as b in inch inch;",                     # Value type declaration with repeated unit
-      ['ValueType: a is written as b in [["inch", 1], ["inch", 1]];']
-    ],
-    [ "a is written as b in 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() in 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() in 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
-