activefacts 0.8.9 → 0.8.10

data/spec/absorption_spec.rb

@@ -9,7 +9,7 @@ require 'activefacts/input/cql'
 require 'activefacts/persistence'
 
 describe "Absorption" do
-  Prologue = %Q{
+  AT_Prologue = %Q{
     vocabulary Test;
     DateTime is written as DateAndTime();
     Month is written as VariableLengthText(3);
@@ -17,29 +17,29 @@ describe "Absorption" do
     PartyID is written as AutoCounter();
     ClaimID is written as AutoCounter();
   }
-  Claim = %Q{
+  AT_Claim = %Q{
     Claim is identified by ClaimID where
       Claim has exactly one ClaimID,
       ClaimID is of at most one Claim;
   }
-  Incident = %Q{
+  AT_Incident = %Q{
     Incident is identified by Claim where
       Claim concerns at most one Incident,
       Incident is of exactly one Claim;
   }
-  Party = %Q{
+  AT_Party = %Q{
     Party is identified by PartyID where
       Party has exactly one PartyID,
       PartyID is of at most one Party;
   }
-  Person = %Q{
+  AT_Person = %Q{
     Person is a kind of Party;
   }
 
   Tests = [
     { :should => "inject a value column into the table for an independent ValueType",
       :cql => %Q{
-        #{Prologue}
+        #{AT_Prologue}
         Month is in exactly one Season;
       },
       :tables => { "Month" => [["Month", "Value"], ["Season"]] }
@@ -47,7 +47,7 @@ describe "Absorption" do
 
     { :should => "absorb a one-to-one along the identification path",
       :cql => %Q{
-        #{Prologue} #{Claim} #{Incident}
+        #{AT_Prologue} #{AT_Claim} #{AT_Incident}
         Incident relates to loss on exactly one DateTime;
       },
       :tables => { "Claim" => [%w{Claim ID}, %w{Incident Date Time}]}
@@ -55,7 +55,7 @@ describe "Absorption" do
 
     { :should => "absorb an objectified binary with single-role UC",
       :cql => %Q{
-        #{Prologue} #{Claim} #{Party} #{Person}
+        #{AT_Prologue} #{AT_Claim} #{AT_Party} #{AT_Person}
         Lodgement is where
           Claim was lodged by at most one Person;
         Lodgement was made at at most one DateTime;

data/spec/cql/comparison_spec.rb

@@ -0,0 +1,91 @@
+#
+# ActiveFacts CQL Comparison Fact Type tests
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+
+require 'rspec/expectations'
+
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'activefacts/cql/compiler'
+require 'spec/helpers/compile_helpers'
+
+require 'ruby-debug'; Debugger.start
+
+describe "When matching a reading with an existing fact type" do
+  before :each do
+    extend CompileHelpers
+
+    prefix = %q{
+      vocabulary Tests;
+      Name is written as String;
+      year/years converts to 365.25 day;
+      Age is written as Integer year;
+      Person is identified by its Name;
+      Person is of Age;
+
+      // Company is identified by its Name;
+      // Directorship is where Person directs Company;
+    }
+    @compiler = ActiveFacts::CQL::Compiler.new('Test')
+    @compiler.compile(prefix)
+    @constellation = @compiler.vocabulary.constellation
+
+    baseline
+  end
+
+  describe "equality comparisons" do
+    before :each do
+      #debug_enable("binding"); debug_enable("matching"); debug_enable("matching_fails"); debug_enable("parse")
+    end
+    after :each do
+      #debug_disable("binding"); debug_disable("matching"); debug_disable("matching_fails"); debug_disable("parse")
+    end
+
+    def value_should_match value, lit, unit = nil
+      value.should_not be_nil
+      value.literal.should == lit.to_s
+      (!!value.is_a_string).should == lit.is_a?(String)
+      if unit
+        value.unit.should_not be_nil
+        value.unit.name.should == unit
+      else
+        value.unit.should be_nil
+      end
+    end
+
+    def one_join_with_value v, unit = nil
+      joins.size.should == 1
+      (jss = join_steps).size.should == 2
+      (jns = join_nodes).size.should == 3
+      integer_node = jns.detect{|jn| jn.object_type.name == 'Integer'}
+      integer_node.should_not be_nil
+      value_should_match integer_node.value, v, unit
+      # pending should test content of the join steps
+    end
+
+    it "should create a comparison fact type" do
+      compile %q{Person is old where Person is of Age >= 60 years; }
+      (new_fact_types = fact_types).size.should == 2
+
+      is_old_ft = new_fact_types.detect{|ft| ft.all_reading.detect{|r| r.text =~ /is old/} }
+      (is_old_ft.all_reading.map{ |r| r.expand }*', ').should == "Person is old"
+
+      comparison_ft = (new_fact_types - [is_old_ft])[0]
+      (comparison_ft.all_reading.map{ |r| r.expand }*', ').should == "Boolean = Age >= Integer"
+
+      one_join_with_value 60, 'year'
+    end
+
+    it "should create a comparison fact type twice without duplication"
+
+    it "should parse a query and comparison fact type" do
+      compile %q{Person is of Age >= 60 years? }
+      (new_fact_types = fact_types).size.should == 1
+      (readings = new_fact_types[0].all_reading).size.should == 1
+      readings.single.text.should == '{0} = {1} >= {2}'
+
+      one_join_with_value 60, 'year'
+    end
+  end
+end

data/spec/cql/contractions_spec.rb

@@ -0,0 +1,251 @@
+#
+# ActiveFacts CQL Fact Type matching tests - contractions.
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+# Contractions are where a fact type clause is followed by another (with
+# some conjunction except for comparisons) with one player *implicit* in
+# the following clause.
+#
+# Right contraction elides the repetition of the right-most player,
+# and left contraction elides the left-most player.
+#
+# So, using the notation "A rel B" for binaries,
+# "A relA B relA C" for ternaries, and "C prop" for properties,
+# we can write equivalences as follows.
+#
+# Note 1: Terms may be more than one word.
+# Note 2: For any "A rel B", the example also applies to a ternary or
+#       higher, as appropriate.
+
+=begin
+Right contractions with 'and':
+  A rel B and B prop
+    -> A rel B who/that prop
+  E.g. Person pats Cat that is asleep
+
+  A rel B and B rel2 C
+    -> A rel B who/that rel2 C
+  E.g. Person pats Cat that is lying on Mat
+
+  A rel B and B rel2A C rel2A D
+    -> A rel B who/that rel2A C rel2B D
+  E.g. Person pats Cat that ate Food at Time
+
+  A rel B and B > C
+    -> A rel B > C
+  E.g. Person is of Age >= 21
+
+  A > B and B rel C
+    -> A > B rel C
+  E.g. 21 > Age of Person
+
+Right contractions with ',':
+  A rel B, B rel2 C
+    -> A rel B who/that rel2 C
+
+  A rel B, B prop
+    -> A rel B who/that prop
+
+  A rel B, B > C
+    -> A rel B > C
+
+  A > B, B rel C
+    -> A > B rel C
+
+Left contractions with 'and':
+  A rel B and A rel2 C
+    -> A rel B and rel2 C
+  E.g. Boy seduces Girl and is drunk
+  
+  A rel B and A prop
+    -> A rel B and prop
+
+  A rel B and A > C
+    -> A rel B and > C
+
+Left contractions with 'or':
+  A rel B or A rel2 C
+    -> A rel B or rel2 C
+  
+  A rel B or A prop
+    -> A rel B or prop
+
+  A rel B or A > C
+    -> A rel B or > C
+
+  A > B or A rel C
+    -> A > B or rel C
+
+Double contractions (not supported in CQL yet):
+  A rel B and A rel2 B
+    -> A rel B and rel2
+  E.g. Person came to Party and was invited to
+
+Extended contractions (not supported in CQL yet) (note the ambiguity - if allowed, the first takes precedence!):
+  A rel B and B rel2 C and B prop
+    -> A rel B that rel2 C and prop
+  E.g. LazyDogOwner is a Person who owns Dog that barks and Dog is lazy.
+
+  A rel B and B rel2 C and A prop
+    -> A rel B that rel2 C and prop
+  E.g. LazyDogOwner is a Person who owns Dog that barks and Person is lazy.
+
+And/or resolution:
+  A rel B and B rel2 C or A rel3 D
+  A rel B and B rel2 C or B rel3 D  -> Logical, A must rel B but B can carry either rel
+  A rel B and B rel2 C or C rel3 D  -> Illogical form (mandates B rel2 C so 'or' is meaningless)
+
+Ambiguous, disallowed:
+  A > 2 + B > C
+
+Comments from Matt on contraction and verbalisation:
+
+I have two types of list phrases which I classify as 'header' and 'inline'.
+And and or are inline, the other four (negated and/or, positive or negative
+xor) all use header forms. There is also a header form of negation (it is not
+true that...). The header forms (all of the following must be true: etc) can
+introduce vars in the starting context, but not those introduced by previous
+elements in the list.
+
+You'll likely need something similar, though, on nested expressions. You also
+have to decide where your implicit existential placement is if you use the
+same var in multiple branches or under negation. Lots of fun stuff.
+
+=end
+
+
+require 'rspec/expectations'
+
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'activefacts/cql/compiler'
+require File.dirname(__FILE__) + '/../helpers/compile_helpers'  # Can't see how to include/extend these methods correctly
+
+describe "When compiling a join, " do
+  before :each do
+    extend CompileHelpers
+
+    prefix = %q{
+      vocabulary Tests;
+      Boy is written as String;
+      Girl is written as Integer;
+      Age is written as Integer;
+      Boy is of Age;
+      Boy is going out with Girl, Girl is going out with Boy;
+    }
+    @compiler = ActiveFacts::CQL::Compiler.new('Test')
+    @compiler.compile(prefix)
+    @constellation = @compiler.vocabulary.constellation
+
+    baseline
+
+=begin
+    def self.baseline
+      @base_facts = @constellation.FactType.values-@constellation.ImplicitFactType.values
+      @base_objects = @constellation.ObjectType.values
+    end
+
+    def self.fact_types
+      @constellation.FactType.values-@base_facts-@constellation.ImplicitFactType.values
+    end
+
+    def self.object_types
+      @constellation.ObjectType.values-@base_objects
+    end
+
+    def self.fact_pcs fact_type
+      fact_type.all_role.map{|r| r.all_role_ref.map{|rr| rr.role_sequence.all_presence_constraint.to_a}}.flatten.uniq
+    end
+
+    def self.derivation fact_type
+      join = (joins = @constellation.Join.values.to_a)[0]
+      # PENDING: When the fact type's roles are projected, use this instead:
+      # joins = fact_type.all_role.map{|r| r.all_join_role.map{|jr| jr.join}}.flatten.uniq
+      joins.size.should == 1
+      joins[0]
+    end
+=end
+
+    def self.compile string
+      lambda {
+        @compiler.compile string
+      }.should_not raise_error
+    end
+  end
+
+  shared_examples_for "single contractions" do
+    it "should produce one fact type" do
+      (new_fact_types = fact_types).size.should == 1
+    end
+    it "the fact type should have one reading" do
+      fact_type = fact_types[0]
+      fact_type.all_reading.size.should == 1
+    end
+    it "the fact type should have no presence constraints" do
+      fact_type = fact_types[0]
+      (pcs = fact_pcs(fact_type)).size.should == 0
+    end
+    it "should produce one join" do
+      fact_type = fact_types[0]
+      join = derivation(fact_type)
+    end
+    it "the join should have 3 nodes" do
+      fact_type = fact_types[0]
+      join = derivation(fact_type)
+      nodes = join.all_join_node.to_a
+      nodes.size.should == 3
+    end
+    it "the join should have 2 steps" do
+      fact_type = fact_types[0]
+      join = derivation(fact_type)
+      steps = join.all_join_step.to_a
+      steps.size.should == 2
+    end
+
+    it "and should project the fact type roles from the join" do
+      pending "Join roles are not yet projected" do
+        join = derivation(fact_type)
+        joins = fact_type.all_role.map{|r| r.all_join_role.map{|jr| jr.join}}.flatten.uniq
+        joins.size == 1
+        joins.should == [join]
+      end
+    end
+  end
+
+  describe "right contractions having" do
+    describe "a single contraction using 'who'" do
+      before :each do
+        compile %q{Boy is relevant where Girl is going out with Boy who is of Age; }
+      end
+
+      it_should_behave_like "single contractions"
+    end
+
+    describe "a single contraction using 'that'" do
+      before :each do
+        compile %q{Boy is relevant where Girl is going out with Boy that is of Age; }
+      end
+
+      it_should_behave_like "single contractions"
+    end
+  end
+
+  describe "left contractions having" do
+    describe "a single contraction" do
+      before :each do
+        compile %q{Boy is relevant where Boy is of Age and is going out with Girl; }
+      end
+
+      it_should_behave_like "single contractions"
+    end
+  end
+end
+
+=begin
+Examples on the Blog model:
+
+Post is nice where Post was written by Author and belongs to Topic and includes Ordinal paragraph;
+Post is nice where Post was written by Author and belongs to Topic or Post includes Ordinal paragraph or has Post Id;
+Post is nice where Post was written by Author and belongs to Topic or includes Ordinal paragraph;
+Post is nice where Post was written by Author and belongs to Topic or Post includes Ordinal paragraph or has Post Id;
+=end

data/spec/cql/entity_type_spec.rb

@@ -0,0 +1,319 @@
+#
+# ActiveFacts CQL Fact Type matching tests
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+
+require 'rspec/expectations'
+
+require 'activefacts/support'
+require 'activefacts/api/support'
+require 'activefacts/cql/compiler'
+# require File.dirname(__FILE__) + '/../helpers/compiler_helper'  # Can't see how to include/extend these methods correctly
+
+describe "When compiling an entity type, " do
+  MatchingPrefix = %q{
+    vocabulary Tests;
+    Boy is written as String;
+    Girl is written as Integer;
+  }
+  BaseObjectTypes = 4  # Integer, String, Boy, Girl
+
+  def self.SingleFact &b
+    lambda {|c|
+      real_fact_types = c.FactType.values-c.ImplicitFactType.values
+      real_fact_types.size.should == 1
+      @fact_type = real_fact_types[0]
+      b.call(@fact_type) if b
+      @fact_type
+    }
+  end
+
+  def self.FactHavingPlayers(*a, &b)
+    lambda {|c|
+      @fact_type = c.FactType.detect do |key, ft|
+        ft.all_role.map{|r| r.object_type.name}.sort == a.sort
+      end
+      b.call(@fact_type) if b
+      @fact_type
+    }
+  end
+
+  def self.PresenceConstraints fact_type, &b
+    @presence_constraints =
+      fact_type.all_role.map{|r|
+        r.all_role_ref.map{|rr|
+          rr.role_sequence.all_presence_constraint.to_a
+        }
+      }.flatten.uniq
+    b.call(@presence_constraints) if b
+    @presence_constraints
+  end
+
+  def self.Readings fact_type, &b
+    @readings = fact_type.all_reading.sort_by{|r| r.ordinal}
+    b.call(@readings) if b
+    @readings
+  end
+
+  def self.ReadingCount n
+    lambda {|c|
+      unless @fact_type.all_reading.size == n
+        puts "SPEC FAILED, wrong number of readings (should be #{n}):\n\t#{
+          @fact_type.all_reading.map{ |r| r.expand}*"\n\t"
+        }"
+      end
+      @fact_type.all_reading.size.should == n
+    }
+  end
+
+  def self.PresenceConstraintCount n
+    lambda{ |c|
+      @fact_type.all_role.map{|r|
+        r.all_role_ref.map{|rr|
+          rr.role_sequence.all_presence_constraint.to_a
+        }
+      }.flatten.uniq.size.should == n
+    }
+  end
+
+  def self.ObjectTypeCount n
+    lambda {|c|
+      @constellation = c
+      c.ObjectType.values.size.should == n
+    }
+  end
+
+  def self.ObjectType name, &b
+    lambda {|c|
+      @object_type = c.ObjectType[[["Tests"], name]]
+      @object_type.should_not == nil
+      b.call(@object_type) if b
+      @object_type
+    }
+  end
+
+  def self.WrittenAs name
+    lambda {|c|
+      @base_type = c.ObjectType[[["Tests"], name]]
+      @base_type.class.should == ActiveFacts::Metamodel::ValueType
+      @object_type.class.should == ActiveFacts::Metamodel::ValueType
+      @object_type.supertype.should == @base_type
+    }
+  end
+
+  def self.PreferredIdentifier num_roles
+    lambda {|c|
+      @preferred_identifier = @object_type.preferred_identifier
+      @preferred_identifier.should_not == nil
+      @preferred_identifier.role_sequence.all_role_ref.size.should == num_roles
+      #@preferred_identifier.min_frequency.should == 1
+      @preferred_identifier.max_frequency.should == 1
+      @preferred_identifier.is_preferred_identifier.should == true
+    }
+  end
+
+  def self.PreferredIdentifierRolePlayedBy name, num = 0
+    lambda {|c|
+      @preferred_identifier.role_sequence.all_role_ref.sort_by{|rr| rr.ordinal}[num].role.object_type.name.should == name
+    }
+  end
+
+  class BlackHole
+    def method_missing(m,*a,&b)
+      self
+    end
+  end
+  class PendingSilencer
+    def STDOUT; BlackHole.new; end
+    def puts; BlackHole.new; end
+    def p; BlackHole.new; end
+  end
+
+  def self.pending(msg = "TODO", &b)
+    lambda {|*c|
+      raised = nil
+      begin
+        example = b.call
+        eval(lambda { example.call(*c) }, BlackHole.new)
+      rescue => raised
+      end
+      raise RSpec::Core::PendingExampleFixedError.new(msg) unless raised
+      throw :pending_declared_in_example, msg
+    }
+  end
+
+  def self.ReadingContainsHyphenatedWord reading_num
+    lambda {|c|
+      hyphenated_reading =
+        c.FactType.values[0].all_reading.select {|reading|
+          reading.ordinal == reading_num
+        }[0]
+      hyphenated_reading.should_not == nil
+      (hyphenated_reading.text =~ /[a-z]-[a-z]/).should_not == nil
+    }
+  end
+
+  EntityIdentificationTests = [
+    [
+      # REVISIT: At present, this doesn't add the minimum frequency constraint that a preferred identifier requires.
+      %q{Thong is written as String;},
+      %q{Thing is identified by Thong where Thing has one Thong;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 1
+        PresenceConstraints(fact_type).size.should == 2
+      end,
+      ObjectType('Thong') do |object_type|
+        object_type.class.should == ActiveFacts::Metamodel::ValueType
+        # REVISIT: Figure out how WrittenAs can access the constellation.
+        WrittenAs('String')
+      end,
+      ObjectTypeCount(2+BaseObjectTypes),
+      ObjectType('Thing'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Thong'),
+    ],
+
+    [ # Auto-create Id and Thing Id:
+      %q{Thing is identified by its Id;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+      end,
+      ObjectTypeCount(3+BaseObjectTypes),
+      ObjectType('Thing'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Thing Id'),
+    ],
+
+    [ # Auto-create Thing Id:
+      %q{Id is written as String;},
+      %q{Thing is identified by its Id;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+      end,
+      ObjectTypeCount(3+BaseObjectTypes),
+      ObjectType('Thing'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Thing Id'),
+    ],
+
+    [ # Auto-create nothing (identifying value type exists already)
+      %q{Thing Id is written as String;},
+      %q{Thing is identified by its Id;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+      end,
+      ObjectTypeCount(2+BaseObjectTypes),
+      ObjectType('Thing'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Thing Id'),
+    ],
+
+    [ # Auto-create nothing (identifying entity type exists already so don't create a VT)
+      %q{Id is written as Id;},
+      %q{Thing Id is identified by Id where Thing Id has one Id, Id is of one Thing Id;},
+      %q{Thing is identified by its Id;},
+      FactHavingPlayers("Thing", "Thing Id") do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+      end,
+      ObjectTypeCount(3+BaseObjectTypes),
+      ObjectType('Thing'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Thing Id'),
+    ],
+
+    [
+      %q{Thong is written as String;},
+      %q{Thing is identified by Thong where Thing has one Thong, Thong is of one Thing;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+      end,
+      ObjectTypeCount(2+BaseObjectTypes),
+      ObjectType('Thing'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Thong'),
+    ],
+
+    [   # Objectified fact type with internal identification
+      %q{Relationship is where Boy relates to Girl;},
+      SingleFact() do |fact_type|
+        Readings(fact_type).size.should == 1
+        PresenceConstraints(fact_type).size.should == 1
+      end,
+      ObjectTypeCount(1+BaseObjectTypes),
+      ObjectType('Relationship'),
+        PreferredIdentifier(2),
+#          PreferredIdentifierRolePlayedBy('Thong'),
+    ],
+
+    [   # Objectified fact type with external identification
+      %q{Relationship is identified by its Id where Boy relates to Girl;},
+      ObjectTypeCount(3+BaseObjectTypes),
+      ObjectType('Relationship'),
+        PreferredIdentifier(1),   # 1 role in PI
+          PreferredIdentifierRolePlayedBy('Relationship Id'),
+      FactHavingPlayers('Relationship', 'Relationship Id') do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+        fact_type.all_reading.detect{|r| r.text == '{0} has {1}'}.should_not == nil
+        fact_type.all_reading.detect{|r| r.text == '{0} is of {1}'}.should_not == nil
+      end,
+      FactHavingPlayers('Boy', 'Girl') do |fact_type|
+        fact_type.entity_type.should == @object_type
+      end,
+    ],
+
+    [   # Objectified fact type with external identification and explicit reading
+      %q{Relationship is identified by its Id where Boy relates to Girl, Relationship is known by Relationship Id;},
+      ObjectTypeCount(3+BaseObjectTypes),
+      ObjectType('Relationship'),
+        PreferredIdentifier(1),
+          PreferredIdentifierRolePlayedBy('Relationship Id'),
+      FactHavingPlayers('Relationship', 'Relationship Id') do |fact_type|
+        Readings(fact_type).size.should == 2
+        PresenceConstraints(fact_type).size.should == 2
+        fact_type.all_reading.detect{|r| r.text == '{0} is known by {1}'}.should_not == nil
+        fact_type.all_reading.detect{|r| r.text == '{0} is of {1}'}.should_not == nil
+      end,
+      FactHavingPlayers('Boy', 'Girl') do |fact_type|
+        fact_type.entity_type.should == @object_type
+      end,
+    ],
+
+  ]
+
+  AllTests =
+    EntityIdentificationTests
+
+  before :each do
+    @compiler = ActiveFacts::CQL::Compiler.new('Test')
+  end
+
+  AllTests.each do |tests|
+    it "should process '#{(tests.select{|t| t.is_a?(String)}*' ').gsub(/\s+/m,' ')}' correctly" do
+      tests.each do |test|
+        case test
+        when String
+          result = @compiler.compile(MatchingPrefix+test)
+          puts @compiler.failure_reason unless result
+          result.should_not be_nil
+        when Proc
+          begin
+            test.call(@compiler.vocabulary.constellation)
+          rescue RSpec::Expectations::ExpectationNotMetError
+            raise
+          rescue RSpec::Core::ExamplePendingError
+            raise
+          rescue => e
+            puts "Failed on\n\t"+tests.select{|t| t.is_a?(String)}*" "
+            raise
+          end
+        end
+      end
+    end
+  end
+end