adsl 0.0.3 → 0.1.0

data/test/unit/adsl/extract/rails/rails_test_helper_test.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require 'active_record'
+require 'ruby_parser'
+require 'ruby2ruby'
+require 'adsl/util/test_helper'
+require 'adsl/extract/rails/rails_test_helper'
+require 'adsl/extract/rails/rails_instrumentation_test_case'
+
+class ADSL::Extract::Rails::RailsTestHelperTest < ADSL::Extract::Rails::RailsInstrumentationTestCase
+  def test__ar_classes_exist_and_work
+    assert self.class.const_defined? :Asd
+    assert self.class.const_defined? :Kme
+    assert self.class.const_defined? :Mod
+    assert Mod.const_defined? :Blah
+
+    a = Asd.new
+    a.blahs.build
+    a.save!
+
+    assert_equal 1, Asd.all.length
+    a_from_db = Asd.all.first
+    assert_equal 1, a_from_db.blahs.length
+    assert_equal a_from_db, Mod::Blah.all.first.asd
+  end
+end

data/test/unit/adsl/extract/sexp_utils_test.rb

@@ -0,0 +1,100 @@
+require 'test/unit'
+require 'pp'
+require 'adsl/extract/sexp_utils'
+require 'adsl/util/test_helper'
+
+class ADSL::Extract::SexpUtilsTest < Test::Unit::TestCase
+  def test_block_replace__no_match
+    sexp = s(:array, s(:lit, 1), s(:lit, 2))
+    
+    replacement = sexp.block_replace(:call) do |a|
+      "#{a}2".to_sym
+    end
+    assert_equal s(:array, s(:lit, 1), s(:lit, 2)), replacement
+  end
+
+  def test_block_replace__plain
+    sexp = s(:array, s(:lit, 1), s(:lit, 2), s(:lit, 0))
+    
+    replacement = sexp.block_replace(:array) do |a|
+      Sexp.from_array [:array] + a.sexp_body.map{ |e| [:lit, e[1] * 2] }
+    end
+
+    assert_equal s(:array, s(:lit, 2), s(:lit, 4), s(:lit, 0)), replacement
+  end
+  
+  def test_block_replace__nested
+    sexp = s(:array, s(:lit, 1), s(:lit, 2), s(:array, s(:lit, 3)))
+    
+    replacement = sexp.block_replace(:array) do |a|
+      Sexp.from_array [:array] + a.sexp_body.map{ |e| e.sexp_type == :lit ? [:lit, e[1] * 2] : e }
+    end
+
+    assert_equal s(:array, s(:lit, 2), s(:lit, 4), s(:array, s(:lit, 6))), replacement
+  end
+  
+  def test_block_replace__deep
+    sexp = s(:blah, s(:array, s(:lit, 1), s(:lit, 2)))
+    
+    replacement = sexp.block_replace(:lit) do |a|
+      s(:lit, a[1]*2)
+    end
+
+    assert_equal s(:blah, s(:array, s(:lit, 2), s(:lit, 4))), replacement
+  end
+
+  def test_block_replace__unless_in
+    sexp = s(:blah, s(:array, s(:lit, 1), s(:blah, s(:lit, 1))), s(:lit, 1))
+    
+    replacement = sexp.block_replace(:lit, :unless_in => :array) do |sexp|
+      s(:lit, sexp[1]*2)
+    end
+
+    assert_equal s(:blah, s(:array, s(:lit, 1), s(:blah, s(:lit, 1))), s(:lit, 2)), replacement
+    
+    
+    sexp = s(:blah, s(:array, s(:lit, 1), s(:blah, s(:lit, 1))), s(:lit, 1))
+    
+    replacement = sexp.block_replace(:lit, :unless_in => [:array]) do |sexp|
+      s(:lit, sexp[1]*2)
+    end
+
+    assert_equal s(:blah, s(:array, s(:lit, 1), s(:blah, s(:lit, 1))), s(:lit, 2)), replacement
+  end
+
+  def test_find_shallowest__plain
+    assert_equal [], s(s(:self)).find_shallowest(:lit)
+    assert_equal [s(:lit, 1), s(:lit, 2)], s(s(:lit, 1), s(:self), s(:lit, 2), s(:self)).find_shallowest(:lit)
+  end
+
+  def test_find_shallowest__goes_through_depth
+    assert_equal [s(:lit, 1), s(:lit, 2)], s(s(s(:lit, 1), s(:self), s(:lit, 2), s(:self))).find_shallowest(:lit)
+    assert_equal [s(:lit, 1), s(:lit, 2)], s(s(:lit, 1), s(s(:self), s(:lit, 2), s(:self))).find_shallowest(:lit)
+  end
+  
+  def test_find_shallowest__only_the_shallowest
+    assert_equal [s(:lit, s(:lit, 2))], s(s(:lit, s(:lit, 2)), s(:self)).find_shallowest(:lit)
+  end
+
+  def test_may_return_or_raise__simple
+    assert_false s(:block, s(:if, s(:true), s(:block), s(:block))).may_return_or_raise?
+    assert s(:block, s(:if, s(:true), s(:block), s(:block, s(:return, s(:nil))))).may_return_or_raise?
+    
+    assert_false s(:block, s(:if, s(:true), s(:block), s(:block))).may_return_or_raise?
+    assert s(:block, s(:if, s(:true), s(:block), s(:block, s(:call, nil, :raise)))).may_return_or_raise?
+  end
+
+  def test_may_return_or_raise__deep
+    sexp = s(:if,
+      s(:lasgn, :user, s(:call, s(:const, :User), :authenticate, s(:call, nil, :http_user), s(:call, nil, :http_pass))),
+      s(:block,
+        s(:attrasgn, s(:call, nil, :session), :[]=, s(:str, "user_id"), s(:call, s(:lvar, :user), :id)),
+        s(:call, nil, :set_current_user, s(:lvar, :user)),
+        s(:return, s(:true))
+      ),
+      nil
+    )
+    assert sexp.may_return_or_raise?
+  end
+
+end

data/test/unit/adsl/fol/first_order_logic_test.rb

@@ -0,0 +1,227 @@
+require 'adsl/fol/first_order_logic'
+require 'test/unit'
+require 'pp'
+
+class ADSL::FOL::FirstOrderLogicTest < Test::Unit::TestCase
+  def teardown
+    if Object.constants.include?(:Foo)
+      Object.send(:remove_const, :Foo)
+    end
+  end
+  
+  def test_fol_class_integration
+    eval <<-ruby
+      class Foo
+        include ADSL::FOL
+      end
+    ruby
+    foo = Foo.new
+    assert foo.methods.include?("_and") || foo.methods.include?(:_and)
+
+    eval <<-ruby
+      class Foo
+        def asd
+          _and(:a, :b)
+        end
+      end
+    ruby
+    assert_equal "and(a, b)", Foo.new.asd.resolve_spass
+  end
+
+  def test_literals
+    assert_equal "true", true.resolve_spass
+    assert_equal "false", false.resolve_spass
+    assert_equal "symbol_here", :symbol_here.resolve_spass
+    assert_equal "sometext", "sometext".resolve_spass
+  end
+
+  def test_split_by_zero_level_comma
+    assert_equal [""], "".split_by_zero_level_comma
+    assert_equal ["asd"], "asd".split_by_zero_level_comma
+    assert_equal ["asd", "kme"], "asd,kme".split_by_zero_level_comma
+    assert_equal ["asd", ""], "asd,".split_by_zero_level_comma
+    assert_equal ["", ""], ",".split_by_zero_level_comma
+    assert_equal ["(asd, asd)"], "(asd, asd)".split_by_zero_level_comma
+    assert_equal ["(a,a,a,()((()())))", ""], "(a,a,a,()((()()))),".split_by_zero_level_comma
+    assert_raise do
+      ")(".split_by_zero_level_comma
+    end
+  end
+
+  def test_not
+    assert_raise ArgumentError do
+      ADSL::FOL::Not.new
+    end
+    assert_equal "not(a)", ADSL::FOL::Not.new(:a).resolve_spass
+    assert_equal "and(not(a), not(b))".gsub(/\s+/, ''), \
+        ADSL::FOL::Not.new(:a, :b).resolve_spass.gsub(/\s+/, '')
+    assert_equal "true", ADSL::FOL::Not.new(false).resolve_spass
+    assert_equal "false", ADSL::FOL::Not.new(true).resolve_spass
+    assert_equal "false", ADSL::FOL::Not.new(true, false).resolve_spass
+    assert_equal "a", ADSL::FOL::Not.new(ADSL::FOL::Not.new(:a)).resolve_spass
+    assert_equal "and(a, not(b))", ADSL::FOL::Not.new(ADSL::FOL::Not.new(:a), ADSL::FOL::Not.new(ADSL::FOL::Not.new(:b))).resolve_spass
+  end
+
+  def test_and
+    assert_equal "true", ADSL::FOL::And.new.resolve_spass
+
+    assert_equal "a", ADSL::FOL::And.new("a").resolve_spass
+    assert_equal "and(a, b)", ADSL::FOL::And.new("a", "b").resolve_spass
+    
+    assert_equal "a", ADSL::FOL::And.new(true, 'a').resolve_spass
+    assert_equal "and(a, b)", ADSL::FOL::And.new(true, "a", "b").resolve_spass
+    assert_equal "false", ADSL::FOL::And.new(true, false).resolve_spass
+    assert_equal "true", ADSL::FOL::And.new(true).resolve_spass
+
+    assert_equal "and(a, b, c)", ADSL::FOL::And.new(ADSL::FOL::And.new(:a, :b), :c).resolve_spass
+  end
+  
+  def test_or
+    assert_equal "false", ADSL::FOL::Or.new.resolve_spass
+
+    assert_equal "a", ADSL::FOL::Or.new("a").resolve_spass
+    assert_equal "or(a, b)", ADSL::FOL::Or.new("a", "b").resolve_spass
+    
+    assert_equal "a", ADSL::FOL::Or.new(false, 'a').resolve_spass
+    assert_equal "or(a, b)", ADSL::FOL::Or.new(false, "a", "b").resolve_spass
+    assert_equal "true", ADSL::FOL::Or.new(true, false).resolve_spass
+    assert_equal "false", ADSL::FOL::Or.new(false).resolve_spass
+    
+    assert_equal "or(a, b, c)", ADSL::FOL::Or.new(ADSL::FOL::Or.new(:a, :b), :c).resolve_spass
+  end
+  
+  def test_forall
+    assert_raise ArgumentError do
+      ADSL::FOL::ForAll.new
+    end
+
+    assert_equal "a", ADSL::FOL::ForAll.new(:a).resolve_spass
+    assert_equal "true", ADSL::FOL::ForAll.new(:a, :b, true).resolve_spass
+    assert_equal "false", ADSL::FOL::ForAll.new(:a, :b, false).resolve_spass
+    assert_equal "forall([a], blah(a))".gsub(/\s+/, ''), \
+        ADSL::FOL::ForAll.new(:a, "blah(a)").resolve_spass.gsub(/\s+/, '')
+    assert_equal "forall([a, b], blah(a))".gsub(/\s+/, ''), \
+        ADSL::FOL::ForAll.new(:a, :b, "blah(a)").resolve_spass.gsub(/\s+/, '')
+  end
+  
+  def test_exists
+    assert_raise ArgumentError do
+      ADSL::FOL::Exists.new
+    end
+
+    assert_equal "a", ADSL::FOL::Exists.new(:a).resolve_spass
+    assert_equal "true", ADSL::FOL::ForAll.new(:a, :b, true).resolve_spass
+    assert_equal "false", ADSL::FOL::ForAll.new(:a, :b, false).resolve_spass
+    assert_equal "exists([a], true(a))".gsub(/\s+/, ''), \
+        ADSL::FOL::Exists.new(:a, "true(a)").resolve_spass.gsub(/\s+/, '')
+    assert_equal "exists([a, b], true(a))".gsub(/\s+/, ''), \
+        ADSL::FOL::Exists.new(:a, :b, "true(a)").resolve_spass.gsub(/\s+/, '')
+  end
+
+  def test_equiv
+    assert_raise ArgumentError do
+      ADSL::FOL::Equiv.new
+    end
+    assert_raise ArgumentError do
+      ADSL::FOL::Equiv.new :a
+    end
+
+    assert_equal 'a', ADSL::FOL::Equiv.new(true, :a).resolve_spass
+    assert_equal 'and(a, b)', ADSL::FOL::Equiv.new(:a, true, :b).resolve_spass
+    assert_equal 'and(not(a), not(b))', ADSL::FOL::Equiv.new(:a, false, :b).resolve_spass
+    assert_equal 'false', ADSL::FOL::Equiv.new(:a, false, :b, true).resolve_spass
+    assert_equal "equiv(a, b)".gsub(/\s+/, ''), \
+        ADSL::FOL::Equiv.new(:a, :b).resolve_spass.gsub(/\s+/, '')
+    assert_equal "and(equiv(a, b), equiv(b, c))".gsub(/\s+/, ''), \
+        ADSL::FOL::Equiv.new(:a, :b, :c).resolve_spass.gsub(/\s+/, '')
+  end
+  
+  def test_implies
+    assert_raise ArgumentError do
+      ADSL::FOL::Implies.new
+    end
+    assert_raise ArgumentError do
+      ADSL::FOL::Implies.new :a
+    end
+    assert_raise ArgumentError do
+      ADSL::FOL::Implies.new :a, :b, :c
+    end
+
+    assert_equal "implies(a, b)".gsub(/\s+/, ''), \
+        ADSL::FOL::Implies.new(:a, :b).resolve_spass.gsub(/\s+/, '')
+    assert_equal "a".gsub(/\s+/, ''), \
+        ADSL::FOL::Implies.new(true, :a).resolve_spass.gsub(/\s+/, '')
+    assert_equal "true".gsub(/\s+/, ''), \
+        ADSL::FOL::Implies.new(:a, true).resolve_spass.gsub(/\s+/, '')
+    assert_equal "true".gsub(/\s+/, ''), \
+        ADSL::FOL::Implies.new(false, :a).resolve_spass.gsub(/\s+/, '')
+    assert_equal "not(a)".gsub(/\s+/, ''), \
+        ADSL::FOL::Implies.new(:a, false).resolve_spass.gsub(/\s+/, '')
+
+    assert_equal 'true', ADSL::FOL::Implies.new(true, true).resolve_spass
+    assert_equal 'false', ADSL::FOL::Implies.new(true, false).resolve_spass
+    assert_equal 'true', ADSL::FOL::Implies.new(false, true).resolve_spass
+    assert_equal 'true', ADSL::FOL::Implies.new(false, false).resolve_spass
+  end
+  
+  def test_equal
+    assert_raise ArgumentError do
+      ADSL::FOL::Equal.new
+    end
+    assert_raise ArgumentError do
+      ADSL::FOL::Equal.new :a
+    end
+
+    assert_equal "equal(a, b)".gsub(/\s+/, ''), \
+        ADSL::FOL::Equal.new(:a, :b).resolve_spass.gsub(/\s+/, '')
+    assert_equal "and(equal(a, b), equal(b, c))".gsub(/\s+/, ''), \
+        ADSL::FOL::Equal.new(:a, :b, :c).resolve_spass.gsub(/\s+/, '')
+  end
+
+  def test_one_of
+    assert_equal 'false', ADSL::FOL::OneOf.new.resolve_spass
+    assert_equal "a".gsub(/\s+/, ''), \
+        ADSL::FOL::OneOf.new(:a).resolve_spass.gsub(/\s+/, '')
+    assert_equal "equiv(not(a), b)".gsub(/\s+/, ''), \
+        ADSL::FOL::OneOf.new(:a, :b).resolve_spass.gsub(/\s+/, '')
+    assert_equal "and(or(a, b, c), implies(a, and(not(b), not(c))), implies(b, and(not(a), not(c))), implies(c, and(not(a), not(b))))".gsub(/\s+/, ''), \
+        ADSL::FOL::OneOf.new(:a, :b, :c).resolve_spass.gsub(/\s+/, '')
+  end
+
+  def test_if_then_else
+    assert_equal "and(implies(a, b), implies(not(a), c))".gsub(/\s+/, ''), \
+        ADSL::FOL::IfThenElse.new(:a, :b, :c).resolve_spass.gsub(/\s+/, '')
+  end
+
+  def test_if_then_else_eq
+    assert_equal "and(equiv(a, b), equiv(not(a), c))".gsub(/\s+/, ''), \
+        ADSL::FOL::IfThenElseEq.new(:a, :b, :c).resolve_spass.gsub(/\s+/, '')
+  end
+
+  def test_pairwise_equal__explicit_lists
+    assert_raise ArgumentError do
+      ADSL::FOL::PairwiseEqual.new [], [:a]
+    end
+    assert_raise ArgumentError do
+      ADSL::FOL::PairwiseEqual.new [:b, :c], [:a]
+    end
+
+    assert_equal "true", ADSL::FOL::PairwiseEqual.new([], []).resolve_spass
+    assert_equal "equal(a1, b1)", ADSL::FOL::PairwiseEqual.new([:a1], [:b1]).resolve_spass
+    assert_equal "and(equal(a1, b1), equal(a2, b2))", ADSL::FOL::PairwiseEqual.new([:a1, :a2], [:b1, :b2]).resolve_spass
+  end
+  
+  def test_pairwise_equal__implicit_lists
+    assert_raise ArgumentError do
+      ADSL::FOL::PairwiseEqual.new :a
+    end
+    assert_raise ArgumentError do
+      ADSL::FOL::PairwiseEqual.new :b, [[:c]], :a
+    end
+
+    assert_equal "true", ADSL::FOL::PairwiseEqual.new().resolve_spass
+    assert_equal "equal(a1, b1)", ADSL::FOL::PairwiseEqual.new(:a1, :b1).resolve_spass
+    assert_equal "and(equal(a1, b1), equal(a2, b2))", ADSL::FOL::PairwiseEqual.new(:a1, :a2, :b1, [:b2]).resolve_spass
+  end
+end
+

data/test/unit/adsl/parser/action_parser_test.rb

@@ -0,0 +1,1040 @@
+require 'adsl/parser/adsl_parser.tab'
+require 'adsl/ds/data_store_spec'
+require 'test/unit'
+require 'pp'
+
+module ADSL::Parser
+  class ActionParserTest < Test::Unit::TestCase
+    include ADSL::DS
+
+    def test_action__empty
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse ""
+      end
+      assert_equal([], spec.actions)
+    end
+
+    def test_action__no_stmts
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          action do_something() {
+          }
+        adsl
+      end
+      assert_equal 1, spec.actions.length
+      assert_equal 0, spec.actions.first.block.statements.length
+      assert_equal "do_something", spec.actions.first.name
+    end
+
+    def test_action__vars_are_stored
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class {}
+          action do_something() {
+            var = allof(Class)
+            var = var
+          }
+        adsl
+      end
+      assert_equal 1, spec.actions.length
+      assert_equal 2, spec.actions.first.block.statements.length
+      var1 = spec.actions.first.statements.first.var
+      assert_equal var1, spec.actions.first.statements.last.objset
+      var2 = spec.actions.first.statements.last.var
+      assert var1 != var2
+    end
+
+    def test_action__context_difference
+      context1 = ASTTypecheckResolveContext.new
+      context1.push_frame
+
+      a1 = DSVariable.new :name => 'a'
+      a2 = DSVariable.new :name => 'a'
+      b = DSVariable.new :name => 'b'
+      b2 = DSVariable.new :name => 'b'
+
+      context1.define_var a1, true
+      context1.define_var b, true
+
+      context2 = context1.dup
+
+      context2.redefine_var a2, false
+
+      assert_equal({"a" => [a1, a2]}, ASTTypecheckResolveContext.context_vars_that_differ(context1, context2))
+
+      context3 = context2.dup
+      assert_equal({"a" => [a1, a2, a2]}, ASTTypecheckResolveContext.context_vars_that_differ(context1, context2, context3))
+
+      context3.redefine_var b2, false
+      assert_equal({"a" => [a1, a2, a2], "b" => [b, b, b2]}, ASTTypecheckResolveContext.context_vars_that_differ(context1, context2, context3))
+    end
+
+    def test_action__all_stmts_no_subblocks
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class { 0+ Class relation }
+          action do_something() {
+            var = create(Class)
+            create(Class)
+            delete var
+            var.relation += var
+            var.relation -= var
+          }
+        adsl
+      end
+      assert_equal 1, spec.actions.length
+      assert_equal 'do_something', spec.actions.first.name
+      statements = spec.actions.first.block.statements
+      assert_equal 6, statements.length
+      relation = spec.classes.first.relations.first
+      
+      assert_equal spec.classes.first, statements[0].klass
+
+      var = statements[1].var
+      assert !var.nil?
+      assert_equal 'var', var.name
+      
+      assert_equal spec.classes.first, statements[2].klass
+      
+      assert_equal var, statements[3].objset
+
+      assert_equal var, statements[4].objset1
+      assert_equal var, statements[4].objset2
+      assert_equal relation, statements[4].relation
+   
+      assert_equal var, statements[5].objset1
+      assert_equal var, statements[5].objset2
+      assert_equal relation, statements[5].relation
+    end
+
+    def test_action__multiple_creates_in_single_stmt
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class { 0+ Class relation}
+          action do_something() {
+            create(Class).relation += create(Class)
+          }
+        adsl
+      end
+      statements = spec.actions.first.block.statements
+      assert_equal 3, statements.length
+      assert_equal spec.classes.first, statements[0].klass
+      assert_equal spec.classes.first, statements[1].klass
+    end
+
+    def test_action__args_typecheck
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class {}
+          action do_something(0+ Class var1) {
+            var2 = var1
+          }
+        adsl
+      end
+      
+      klass = spec.classes.first
+      var1 = spec.actions.first.args.first
+      var2 = spec.actions.first.statements.first.var
+
+      assert_equal klass, var1.type
+      assert_equal klass, var2.type
+    end
+
+    def test_action__args_multiple
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class1 {}
+          class Class2 {}
+          class Class3 {}
+          action do_something(0..1 Class1 var1, 1 Class2 var2, 1+ Class3 var3) {
+          }
+        adsl
+      end
+      assert_equal ['var1', 'var2', 'var3'], spec.actions.first.args.map{ |v| v.name }
+      assert_equal spec.classes, spec.actions.first.args.map{ |v| v.type }
+      assert_equal [[0, 1], [1, 1], [1, 1.0/0.0]], spec.actions.first.cardinalities
+    end
+    
+    def test_action__createtup_deletetup_typecheck
+      ['+=', '-='].each do |operator|
+        parser = ADSLParser.new
+        spec = nil
+        assert_nothing_raised ADSLError do
+          spec = parser.parse <<-adsl
+            class Class { 1 Class rel }
+            action blah() {
+              allof(Class).rel #{operator} allof(Class)
+            }
+          adsl
+        end
+        stmt = spec.actions.first.block.statements.first
+        assert_equal spec.classes.first, stmt.objset1.klass
+        assert_equal spec.classes.first, stmt.objset2.klass
+        assert_equal spec.classes.first.relations.first, stmt.relation
+        
+        assert_raise ADSLError do
+          parser.parse <<-adsl
+            class Class1 { 1 Class1 rel }
+            class Class2 {}
+            action blah() {
+              allof(Class2).rel #{operator} allof(Class1)
+            }
+          adsl
+        end
+        
+        assert_raise ADSLError do
+          parser.parse <<-adsl
+            class Class1 { 1 Class1 rel }
+            class Class2 {}
+            action blah() {
+              allof(Class1).rel #{operator} allof(Class2)
+            }
+          adsl
+        end
+      end
+    end
+    
+    def test_action__superclass_createtup_deletetup_typecheck
+      parser = ADSLParser.new
+      ['+=', '-='].each do |operator|
+        spec = nil
+        assert_nothing_raised ADSLError do
+          spec = parser.parse <<-adsl
+            class Super { 1 Super rel }
+            class Sub extends Super {}
+            action blah() {
+              allof(Super).rel #{operator} allof(Sub)
+            }
+          adsl
+        end
+        stmt = spec.actions.first.block.statements.first
+        assert_equal spec.classes[0], stmt.objset1.klass
+        assert_equal spec.classes[1], stmt.objset2.klass
+        assert_equal spec.classes[0].relations.first, stmt.relation
+        
+        assert_nothing_raised ADSLError do
+          spec = parser.parse <<-adsl
+            class Super { 1 Super rel }
+            class Sub extends Super {}
+            action blah() {
+              allof(Sub).rel #{operator} allof(Sub)
+            }
+          adsl
+        end
+        stmt = spec.actions.first.block.statements.first
+        assert_equal spec.classes[1], stmt.objset1.klass
+        assert_equal spec.classes[1], stmt.objset2.klass
+        assert_equal spec.classes[0].relations.first, stmt.relation
+        
+        assert_nothing_raised ADSLError do
+          spec = parser.parse <<-adsl
+            class Super {}
+            class Sub extends Super { 1 Super rel }
+            action blah() {
+              allof(Sub).rel #{operator} allof(Sub)
+            }
+          adsl
+        end
+        stmt = spec.actions.first.block.statements.first
+        assert_equal spec.classes[1], stmt.objset1.klass
+        assert_equal spec.classes[1], stmt.objset2.klass
+        assert_equal spec.classes[1].relations.first, stmt.relation
+
+        assert_raise ADSLError do
+          parser.parse <<-adsl
+            class Super {}
+            class Sub extends Super { 1 Sub rel }
+            action blah() {
+              allof(Super).rel #{operator} allof(Super)
+            }
+          adsl
+        end
+        
+        assert_raise ADSLError do
+          parser.parse <<-adsl
+            class Super {}
+            class Sub extends Super { 1 Sub rel }
+            action blah() {
+              allof(Sub).rel #{operator} allof(Super)
+            }
+          adsl
+        end
+      end
+    end
+
+    def test_action__superclass_settup_typecheck
+      parser = ADSLParser.new
+        
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Super { 1 Super rel }
+          class Sub extends Super {}
+          action blah() {
+            allof(Super).rel = allof(Sub)
+          }
+        adsl
+      end
+      stmt1 = spec.actions.first.block.statements.first
+      stmt2 = spec.actions.first.block.statements.last
+      assert_equal spec.classes[0], stmt1.objset1.klass
+      assert_equal spec.classes[0], stmt1.objset2.klass
+      assert_equal spec.classes[0].relations.first, stmt1.relation
+      assert_equal spec.classes[0], stmt2.objset1.klass
+      assert_equal spec.classes[1], stmt2.objset2.klass
+      assert_equal spec.classes[0].relations.first, stmt2.relation
+      
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Super { 1 Super rel }
+          class Sub extends Super {}
+          action blah() {
+            allof(Sub).rel = allof(Sub)
+          }
+        adsl
+      end
+      stmt1 = spec.actions.first.block.statements.first
+      stmt2 = spec.actions.first.block.statements.last
+      assert_equal spec.classes[1], stmt1.objset1.klass
+      assert_equal spec.classes[0], stmt1.objset2.klass
+      assert_equal spec.classes[0].relations.first, stmt1.relation
+      assert_equal spec.classes[1], stmt2.objset1.klass
+      assert_equal spec.classes[1], stmt2.objset2.klass
+      assert_equal spec.classes[0].relations.first, stmt2.relation
+      
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Super {}
+          class Sub extends Super { 1 Super rel }
+          action blah() {
+            allof(Sub).rel = allof(Sub)
+          }
+        adsl
+      end
+      stmt1 = spec.actions.first.block.statements.first
+      stmt2 = spec.actions.first.block.statements.last
+      assert_equal spec.classes[1], stmt1.objset1.klass
+      assert_equal spec.classes[0], stmt1.objset2.klass
+      assert_equal spec.classes[1].relations.first, stmt1.relation
+      assert_equal spec.classes[1], stmt2.objset1.klass
+      assert_equal spec.classes[1], stmt2.objset2.klass
+      assert_equal spec.classes[1].relations.first, stmt2.relation
+
+      assert_raise ADSLError do
+        parser.parse <<-adsl
+          class Super {}
+          class Sub extends Super { 1 Sub rel }
+          action blah() {
+            allof(Super).rel = allof(Super)
+          }
+        adsl
+      end
+      
+      assert_raise ADSLError do
+        parser.parse <<-adsl
+          class Super {}
+          class Sub extends Super { 1 Sub rel }
+          action blah() {
+            allof(Sub).rel = allof(Super)
+          }
+        adsl
+      end
+    end
+
+    def test_action__args_cardinality
+      parser = ADSLParser.new
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class {}
+          action do_something(0..1 Class var1) {
+          }
+        adsl
+        spec = parser.parse <<-adsl
+          class Class {}
+          action do_something(1 Class var1) {
+          }
+        adsl
+        spec = parser.parse <<-adsl
+          class Class {}
+          action do_something(1..1 Class var1) {
+          }
+        adsl
+        spec = parser.parse <<-adsl
+          class Class {}
+          action do_something(0+ Class var1) {
+          }
+        adsl
+        spec = parser.parse <<-adsl
+          class Class {}
+          action do_something(1+ Class var1) {
+          }
+        adsl
+      end
+      assert_raise do
+        parser.parse <<-adsl
+          class Class{}
+          action do_something(1..0)
+        adsl
+      end
+      assert_raise do
+        parser.parse <<-adsl
+          class Class{}
+          action do_something(0)
+        adsl
+      end
+      assert_raise do
+        parser.parse <<-adsl
+          class Class{}
+          action do_something(0..0)
+        adsl
+      end
+    end
+
+    def test_action__ssa_by_default
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class {}
+          action do_something(0+ Class var1, 0+ Class var2) {
+            var2 = var1
+          }
+        adsl
+      end
+
+      arg1 = spec.actions.first.args.first
+      arg2 = spec.actions.first.args.last
+      redefined = spec.actions.first.statements.first.var
+      
+      assert arg1 != arg2
+      assert arg2 != redefined
+    end
+
+    def test_action__allof_typecheck
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class { 0+ Class relation }
+          action do_something() {
+            var = allof(Class)
+            var.relation -= var
+          }
+        adsl
+      end
+
+      assert_equal 1, spec.actions.length
+      klass = spec.classes.first
+      relation = spec.classes.first.relations.first
+
+      assert_equal relation, spec.actions.first.block.statements.last.relation
+      
+      assert_raise ADSLError do
+        parser.parse <<-adsl
+          class Class { 0+ Class relation }
+          class Class2 {}
+          action do_something() {
+            var1 = allof(Class)
+            var2 = allof(Class2)
+            var1.relation -= var2
+          }
+        adsl
+      end
+    end
+
+    def test_action__subset_typecheck
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class { 0+ Class relation }
+          action do_something() {
+            var = subset(allof(Class))
+            var.relation -= var
+          }
+        adsl
+      end
+
+      assert_equal 1, spec.actions.length
+      klass = spec.classes.first
+      relation = spec.classes.first.relations.first
+
+      assert_equal relation, spec.actions.first.block.statements.last.relation
+      
+      assert_raise ADSLError do
+        parser.parse <<-adsl
+          class Class { 0+ Class relation }
+          class Class2 {}
+          action do_something() {
+            var1 = allof(Class)
+            var2 = subset(allof(Class2))
+            var1.relation -= var2
+          }
+        adsl
+      end
+    end
+    
+    def test_action__oneof_typecheck
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class { 0+ Class relation }
+          action do_something() {
+            var = oneof(allof(Class))
+            var.relation -= var
+          }
+        adsl
+      end
+
+      assert_equal 1, spec.actions.length
+      klass = spec.classes.first
+      relation = spec.classes.first.relations.first
+
+      assert_equal relation, spec.actions.first.block.statements.last.relation
+      
+      assert_raise ADSLError do
+        parser.parse <<-adsl
+          class Class { 0+ Class relation }
+          class Class2 {}
+          action do_something() {
+            var1 = allof(Class)
+            var2 = oneof(allof(Class2))
+            var1.relation -= var2
+          }
+        adsl
+      end
+    end
+
+    def test_action__deref_typecheck
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class1 { 0+ Class2 relation }
+          class Class2 { 0+ Class2 other_relation }
+          action do_something() {
+            allof(Class1).relation.other_relation -= allof(Class2)
+          }
+        adsl
+      end
+
+      assert_equal 1, spec.actions.length
+      klass2 = spec.classes.last
+      relation = klass2.relations.first
+
+      stmt = spec.actions.first.block.statements.last
+      assert_equal klass2, stmt.objset1.type
+      assert_equal relation, stmt.relation
+      
+      assert_raise ADSLError do
+        parser.parse <<-adsl
+          class Class1 { 0+ Class2 relation }
+          class Class2 { 0+ Class2 other_relation }
+          action do_something() {
+            allof(Class1).relation.relation -= allof(Class2)
+          }
+        adsl
+      end
+    end 
+    
+    def test_action__deref_superclass_typecheck
+      parser = ADSLParser.new
+      spec = nil
+
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class1 { 0+ Class2 relation }
+          class Class2 extends Class1 { 0+ Class2 other_relation }
+          action do_something() {
+            allof(Class1).relation.other_relation -= allof(Class2)
+          }
+        adsl
+      end
+      klass2 = spec.classes.last
+      relation = klass2.relations.first
+      stmt = spec.actions.first.block.statements.last
+      assert_equal klass2, stmt.objset1.type
+      assert_equal relation, stmt.relation
+      
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class1 { 0+ Class2 relation }
+          class Class2 extends Class1 { 0+ Class2 other_relation }
+          action do_something() {
+            allof(Class2).relation.other_relation -= allof(Class2)
+          }
+        adsl
+      end
+      klass2 = spec.classes.last
+      relation = klass2.relations.first
+      stmt = spec.actions.first.block.statements.last
+      assert_equal klass2, stmt.objset1.type
+      assert_equal relation, stmt.relation
+    end 
+    
+    def test_action__subblocks
+      parser = ADSLParser.new
+      spec = parser.parse <<-adsl
+        class Class { 0+ Class relation }
+        action do_something() {
+          var = allof(Class)
+          foreach subvar: var {
+            var.relation -= subvar
+          }
+          either {
+            delete var
+          } or {
+            create(Class)
+          }
+          foreach subvar: var {}
+        }
+      adsl
+      
+      assert_equal 1, spec.actions.length
+      stmts = spec.actions.first.block.statements
+      var = stmts[0].var
+      klass = spec.classes.first
+      
+      assert_equal var, stmts[1].objset
+
+      assert_equal var, stmts[2].blocks[0].statements.first.objset
+
+      assert_equal klass, stmts[2].blocks[1].statements.first.klass
+    end
+
+    def test_action__subblocks_dont_undefine_variables
+      parser = ADSLParser.new
+      assert_nothing_raised ADSLError do
+        parser.parse <<-adsl
+          class Class {}
+          action do_something() {
+            var = allof(Class)
+            either {
+              var = allof(Class)
+            } or {
+            }
+            var = var
+          }
+        adsl
+      end
+    end
+
+    def test_action__types_are_static
+      parser = ADSLParser.new
+      assert_raise ADSLError do
+        parser.parse <<-adsl
+          class Class {}
+          class Class2 {}
+          action do_something() {
+            var = allof(Class)
+            var = allof(Class2)
+          }
+        adsl
+      end 
+    end
+
+    def test_action__either_variable_number_of_blocks
+      parser = ADSLParser.new
+      assert_raise do
+        parser.parse <<-adsl
+          class Class {}
+          action do_something() {
+            either {}
+          }
+        adsl
+      end 
+      spec = parser.parse <<-adsl
+        class Class {}
+        action do_something() {
+          either {
+          } or {
+            create(Class)
+          }
+        }
+      adsl
+      either = spec.actions.first.block.statements.first
+      assert_equal 2, either.blocks.length
+      assert_equal 0, either.blocks[0].statements.length
+      assert_equal 1, either.blocks[1].statements.length
+
+      spec = parser.parse <<-adsl
+        class Class {}
+        action do_something() {
+          either {
+          } or {
+            create(Class)
+          } or {
+            create(Class)
+            create(Class)
+          }
+        }
+      adsl
+      either = spec.actions.first.block.statements.first
+      assert_equal 3, either.blocks.length
+      assert_equal 0, either.blocks[0].statements.length
+      assert_equal 1, either.blocks[1].statements.length
+      assert_equal 2, either.blocks[2].statements.length
+    end
+
+    def test_action__unmatching_types_in_either
+      parser = ADSLParser.new
+      assert_raise ADSLError do
+        parser.parse <<-adsl
+          class Class {}
+          class Class2 {}
+          action do_something() {
+            var = allof(Class)
+            either {
+              var = allof(Class)
+            } or {
+              var = allof(Class2)
+            }
+          }
+        adsl
+      end
+    end
+
+    def test_action__unmatching_types_in_either_but_inside
+      parser = ADSLParser.new
+      assert_nothing_raised ADSLError do
+        parser.parse <<-adsl
+          class Class {}
+          class Class2 {}
+          action do_something() {
+            either {
+              var = allof(Class2)
+            } or {
+              var = allof(Class)
+            }
+          }
+        adsl
+      end
+    end
+
+    def test_action__foreach_iterator_var_typecheck
+      parser = ADSLParser.new
+      assert_nothing_raised ADSLError do
+        parser.parse <<-adsl
+          class Class { 0+ Class relation }
+          action do_something() {
+            foreach var: allof(Class) {
+              var.relation -= allof(Class)
+            }
+          }
+        adsl
+      end
+      assert_raise ADSLError do
+        parser.parse <<-adsl
+          class Class {}
+          class Class2 { 0+ Class2 relation }
+          action do_something() {
+            foreach var: allof(Class) {
+              var.relation -= allof(Class)
+            }
+          }
+        adsl
+      end
+    end
+
+    def test_action__foreach_does_not_redefine_var
+      parser = ADSLParser.new
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class { 0+ Class relation }
+          action do_something(0+ Class var) {
+            foreach var: var {
+            }
+          }
+        adsl
+      end
+    end
+
+    def test_action__flat_for_each_is_by_default
+      parser = ADSLParser.new
+      spec = parser.parse <<-adsl
+        class Class { 0+ Class relation }
+        action do_something() {
+          foreach o: allof(Class) {
+          }
+        }
+      adsl
+      assert spec.actions.first.statements.map{ |c| c.class }.include? DSFlatForEach
+    end
+
+    def test_action__either_lambda_works
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class { 0+ Class relation }
+          action do_something() {
+            var = allof(Class)
+            either {
+              var = subset(var)
+            } or {
+              var = subset(var)
+            }
+            var = var
+          }
+        adsl
+      end
+
+      action = spec.actions.first
+      orig_def = action.statements[0].var
+      inside_def1 = action.statements[1].blocks[0].statements.first.var
+      inside_def2 = action.statements[1].blocks[1].statements.first.var
+      after_def = action.statements[2].objset
+
+      assert orig_def != inside_def1
+      assert orig_def != inside_def2
+      assert inside_def1 != after_def
+      assert inside_def2 != after_def
+      assert inside_def1 != inside_def2
+      assert orig_def != after_def
+      assert_equal after_def.vars[0], inside_def1
+      assert_equal after_def.vars[1], inside_def2
+    end
+
+    def test_action__foreach_pre_lambda
+      get_pre_lambdas = lambda do |for_each|
+        for_each.block.statements.select do |stat|
+          stat.kind_of?(DSAssignment) and stat.objset.kind_of?(DSForEachPreLambdaObjset)
+        end
+      end
+
+      parser = ADSLParser.new
+      spec = parser.parse <<-adsl
+        class Class {}
+        action do_something() {
+          foreach var: allof(Class) {}
+        }
+      adsl
+      assert_equal 0, get_pre_lambdas.call(spec.actions.first.block.statements[0]).length
+
+      spec = parser.parse <<-adsl
+        class Class {}
+        action do_something() {
+          foreach var: allof(Class) {
+            var = allof(Class)
+          }
+        }
+      adsl
+      assert_equal 0, get_pre_lambdas.call(spec.actions.first.block.statements[0]).length
+
+      spec = parser.parse <<-adsl
+        class Class {}
+        action do_something() {
+          var = allof(Class)
+          foreach a: allof(Class) {
+            var = subset(var)
+            var = subset(var)
+          }
+        }
+      adsl
+      pre_lambdas = get_pre_lambdas.call(spec.actions.first.block.statements[1])
+      assert_equal 1, pre_lambdas.length
+      assert_equal spec.actions.first.block.statements[0].var, pre_lambdas.first.objset.before_var
+      assert_equal spec.actions.first.block.statements[1], pre_lambdas.first.objset.for_each
+      assert_equal spec.actions.first.block.statements[1].block.statements.last.var, pre_lambdas.first.objset.inside_var
+
+      spec = parser.parse <<-adsl
+        class Class {}
+        action do_something() {
+          var = allof(Class)
+          foreach var: allof(Class) {
+            var = allof(Class)
+          }
+        }
+      adsl
+      assert_equal 0, get_pre_lambdas.call(spec.actions.first.block.statements[1]).length
+    end
+
+    def test_action__empty_set__typecheck
+      parser = ADSLParser.new
+      
+      assert_nothing_raised ADSLError do
+        parser.parse <<-adsl
+          class Class {
+            1 Class klass
+          }
+          class Class2 {
+            1 Class2 klass2
+          }
+          action do_something() {
+            allof(Class).klass += empty
+            allof(Class2).klass2 += empty
+          }
+        adsl
+      end
+
+      assert_raise ADSLError do
+        parser.parse <<-adsl
+          action do_something() {
+            empty.some_relation += empty
+          }
+        adsl
+      end
+      
+      assert_nothing_raised ADSLError do
+        parser.parse <<-adsl
+          class Class {
+            1 Class klass
+          }
+          action do_something() {
+            foreach c: empty {
+              allof(Class).klass += c
+            }
+          }
+        adsl
+      end
+      
+      assert_raise ADSLError do
+        parser.parse <<-adsl
+          class Class {
+            1 Class klass
+          }
+          action do_something() {
+            foreach c: empty {
+              c.klass += allof(Class)
+            }
+          }
+        adsl
+      end
+    end
+
+    def test_action__empty_set_and_var_types
+      parser = ADSLParser.new
+
+      assert_nothing_raised ADSLError do
+        parser.parse <<-adsl
+          class Class {
+            1 Class klass
+          }
+          action do_something() {
+            a = empty
+            a = allof(Class)
+            a.klass += a
+          }
+        adsl
+      end
+      assert_nothing_raised ADSLError do
+        parser.parse <<-adsl
+          class Class {
+            1 Class klass
+          }
+          action do_something() {
+            a = empty
+            a = allof(Class)
+            a.klass += a
+          }
+        adsl
+      end
+      assert_nothing_raised ADSLError do
+        parser.parse <<-adsl
+          class Class {
+            1 Class klass
+          }
+          action do_something() {
+            a = allof(Class)
+            a = empty
+            a.klass += a
+          }
+        adsl
+      end
+      assert_nothing_raised ADSLError do
+        parser.parse <<-adsl
+          class Class {
+            1 Class klass
+          }
+          action do_something() {
+            a = allof(Class)
+            a = empty
+            b = a
+            b.klass += a
+          }
+        adsl
+      end
+    end
+
+    def test_action__entity_class_writes
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class {}
+          class Class2 {}
+          action do_something() {
+            create(Class)
+          }
+        adsl
+      end
+      assert_equal Set[spec.classes.first], spec.actions.first.block.list_entity_classes_written_to
+
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class {}
+          class Class2 {}
+          action do_something() {
+            create(Class)
+            either {
+              foreach a: allof(Class) {
+                delete allof(Class2)
+              }
+            } or {}
+          }
+        adsl
+      end
+      assert_equal Set[*spec.classes], spec.actions.first.block.list_entity_classes_written_to
+      assert_equal Set[spec.classes.first], spec.actions.first.block.statements.first.list_entity_classes_written_to
+      assert_equal Set[spec.classes.second], spec.actions.first.block.statements.last.list_entity_classes_written_to
+    end
+
+    def test_action__entity_class_reads
+      parser = ADSLParser.new
+      spec = nil
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class {}
+          class Class2 {}
+          action do_something() {
+            delete allof(Class)
+          }
+        adsl
+      end
+      assert_equal Set[spec.classes.first], spec.actions.first.block.list_entity_classes_read
+
+      assert_nothing_raised ADSLError do
+        spec = parser.parse <<-adsl
+          class Class {}
+          class Class2 {}
+          action do_something() {
+            create(Class)
+            either {
+              foreach a: allof(Class) {
+                delete allof(Class2)
+              }
+            } or {}
+          }
+        adsl
+      end
+      assert_equal Set[*spec.classes], spec.actions.first.block.list_entity_classes_read
+      assert_equal Set[], spec.actions.first.block.statements.first.list_entity_classes_read
+      assert_equal Set[*spec.classes], spec.actions.first.block.statements.last.list_entity_classes_read
+    end
+  end
+end