adsl 0.0.3 → 0.1.0

data/test/unit/adsl/util/csv_hash_formatter_test.rb

@@ -0,0 +1,68 @@
+require 'adsl/util/csv_hash_formatter'
+require 'test/unit'
+
+class ADSL::Util::CSVHashFormatterTest < Test::Unit::TestCase
+  include ADSL::Util
+
+  def wrap(col_count, *content)
+    output = ""
+    until content.empty?
+      row = content.shift col_count
+      output = output + row.map{ |c| "\"#{c}\"" }.join(',') + "\n"
+    end
+    output
+  end
+
+  def test_blank_if_empty
+    formatter = CSVHashFormatter.new
+    assert_equal '', formatter.to_s
+  end
+  
+  def test_single_row_column
+    formatter = CSVHashFormatter.new
+    formatter << { :asd => 'kme' }
+    assert_equal wrap(1, 'asd', 'kme'), formatter.to_s
+  end
+
+  def test_no_duplicate_columns
+    formatter = CSVHashFormatter.new
+    formatter.add_column 'a'
+    assert_raise do
+      formatter.add_column 'a'
+    end
+    
+    formatter = CSVHashFormatter.new 'a'
+    assert_raise do
+      formatter.add_column 'a'
+    end
+    
+    assert_raise do
+      formatter = CSVHashFormatter.new 'a', 'a'
+    end
+  end
+  
+  def test_two_rows_columns
+    formatter = CSVHashFormatter.new :asd, :asd2
+    formatter << { :asd => 'kme1', :asd2 => 'kme2'}
+    formatter << { :asd => 'kme3', :asd2 => 'kme4'}
+    assert_equal wrap(2, 'asd', 'asd2', 'kme1', 'kme2', 'kme3', 'kme4'), formatter.to_s
+    
+    formatter = CSVHashFormatter.new 'asd'
+    formatter << { :asd => 'kme1', :asd2 => 'kme2'}
+    formatter << { :asd2 => 'kme4', :asd => 'kme3'}
+    assert_equal wrap(2, 'asd', 'asd2', 'kme1', 'kme2', 'kme3', 'kme4'), formatter.to_s
+  end
+
+  def test_incomplete_column_lists
+    formatter = CSVHashFormatter.new :col1, :col2, :col3
+    formatter << { :col1 => 'val1', :col2 => 'val2'}
+    formatter << { :col3 => 'val4', :col2 => 'val3'}
+    assert_equal wrap(3, 'col1', 'col2', 'col3', 'val1', 'val2', '', '', 'val3', 'val4'), formatter.to_s
+  end
+
+  def test_csv_escaping
+    formatter = CSVHashFormatter.new
+    formatter << { :asd => '"kme"'}
+    assert_equal wrap(1, 'asd', '""kme""'), formatter.to_s
+  end
+end

data/test/unit/adsl/util/general_test.rb

@@ -0,0 +1,303 @@
+require 'test/unit'
+require 'adsl/util/general'
+require 'adsl/util/test_helper'
+
+class ADSL::Util::GeneralTest < Test::Unit::TestCase
+
+  def setup
+    assert_false class_defined? :Foo, :Foo2
+  end
+
+  def teardown
+    unload_class :Foo, :Foo2
+  end
+
+  def test_module__lookup_const
+    assert_equal Module, self.class.lookup_const('Module')
+    assert_equal Module, self.class.lookup_const(:Module)
+    assert_equal Object, self.class.lookup_const('::Object')
+    assert_equal Test::Unit, self.class.lookup_const('Test::Unit')
+    assert_equal Test::Unit::TestCase, self.class.lookup_const('Test::Unit::TestCase')
+    assert_equal Test::Unit::TestCase, Test::Unit.lookup_const('TestCase')
+  end
+
+  def test_module__lookup_or_create_module
+    assert_equal Module, self.class.lookup_or_create_module('Module')
+    assert_equal Module, self.class.lookup_or_create_module('::Module')
+    assert_equal Module, self.class.lookup_or_create_module(:Module)
+    foo = self.class.lookup_or_create_module(:Foo)
+    assert_equal Module, foo.class
+    assert_equal Foo, foo
+
+    assert_equal Test::Unit, self.class.lookup_or_create_module('Test::Unit')
+    new_deep = self.class.lookup_or_create_module('Test::Unit::NewDeep')
+    assert_equal Module, new_deep.class
+    assert_equal Test::Unit::NewDeep, new_deep
+  end
+  
+  def test_module__lookup_or_create_class
+    assert_equal Object, self.class.lookup_or_create_class('Object', nil)
+    assert_equal Object, self.class.lookup_or_create_class('::Object', nil)
+    assert_equal Object, self.class.lookup_or_create_class(:Object, nil)
+    foo = self.class.lookup_or_create_class(:Foo, Object)
+    assert_equal Class, foo.class
+    assert_equal Foo, foo
+    assert_equal Object, foo.superclass
+
+    assert_equal Test::Unit::TestCase, self.class.lookup_or_create_class('Test::Unit::TestCase', Test::Unit::TestCase.superclass)
+    new_deep = self.class.lookup_or_create_class('Test::Unit::NewDeep', String)
+    assert_equal Class, new_deep.class
+    assert_equal Test::Unit::NewDeep, new_deep
+    assert_equal String, new_deep.superclass
+  ensure
+    unload_class 'Test::Unit::NewDeep'
+  end
+
+  def test_container_for__blank
+    eval <<-ruby
+      class Foo
+        container_for
+      end
+    ruby
+
+    assert Foo.container_for_fields.empty?
+  end
+
+  def test_container_for__does_list
+    eval <<-ruby
+      class Foo
+        container_for :field
+      end
+    ruby
+
+    kme = Foo.new
+    assert_nil kme.field
+
+    kme = Foo.new :field => :asd
+    assert_equal :asd, kme.field
+  end
+
+  def test_container_for__nonoverwriting
+    eval <<-ruby
+      class Foo
+        container_for :field
+      end
+
+      class Foo
+        container_for :field2
+      end
+    ruby
+
+    assert_nothing_raised do
+      Foo.new
+      Foo.new :field => 4
+      Foo.new :field2 => 5
+      a = Foo.new :field => 1, :field2 => 2
+      assert_equal 1, a.field
+      assert_equal 2, a.field2
+    end
+  end
+
+  def test_container_for__container_for_fields_and_inheritance
+    eval <<-ruby
+      class Foo
+      end
+    ruby
+    
+    assert_raise do
+      Foo.container_for_fields
+    end
+    
+    eval <<-ruby
+      class Foo
+        container_for :field
+      end
+
+      class Foo2 < Foo
+      end
+    ruby
+
+    assert_raise do
+      Class.container_for_fields
+    end
+
+    assert_equal [:field], Foo.container_for_fields.to_a
+    assert_equal [:field], Foo2.container_for_fields.to_a
+    
+    eval <<-ruby
+      class Foo
+        container_for :field2
+      end
+    ruby
+    assert_equal [:field, :field2], Foo.container_for_fields.to_a.sort_by{ |a| a.to_s }
+    assert_equal [:field, :field2], Foo2.container_for_fields.to_a.sort_by{ |a| a.to_s }
+
+    eval <<-ruby
+      class Foo2 < Foo
+        container_for :field3
+      end
+    ruby
+    assert_equal [:field, :field2], Foo.container_for_fields.to_a.sort_by{ |a| a.to_s }
+    assert_equal [:field, :field2, :field3], Foo2.container_for_fields.to_a.sort_by{ |a| a.to_s }
+  end
+
+  def test_container_for__doesnt_list
+    eval <<-ruby
+      class Foo
+        container_for :field
+      end
+    ruby
+
+    assert_raise ArgumentError do
+      Foo.new :unknown_field => :value
+    end
+  end
+
+  def test_container_for__block
+    eval <<-ruby
+      class Foo
+        container_for :field do
+          raise 'inside block'
+        end
+      end
+    ruby
+
+    assert_raise RuntimeError, 'Inside block' do
+      Foo.new
+    end
+  end
+
+  def test_container_for__block_allows_extra_args
+    eval <<-ruby
+      class Foo
+        container_for :field do; end
+      end
+    ruby
+
+    Foo.new :unmentioned_field => :whatever
+  end
+
+  def test_container_for__recursively_gather
+    eval <<-ruby
+      class Foo
+        container_for :field1, :field2
+        attr_accessor :content
+      end
+    ruby
+
+    assert_equal [:field1, :field2], Foo.container_for_fields.to_a.sort_by{ |a| a.to_s }
+    assert Foo.method_defined?(:recursively_gather)
+    assert_equal Set[], Foo.new.recursively_gather(:field1)
+    assert_equal Set[:a], Foo.new(:field1 => :a).recursively_gather(:field1)
+    
+    foo = Foo.new
+    foo.content = :kme
+    foo.field1 = Foo.new :field1 => :kme
+    foo.field1.content = :kme2
+    foo.field2 = Foo.new :field1 => Foo.new
+    foo.field2.content = :kme
+    assert_equal Set[:kme, :kme2], foo.recursively_gather(:content)
+
+    newchild = Foo.new
+    newchild.content = :asd
+    foo.field1 = [newchild, foo.field1]
+    assert_equal Set[:kme, :kme2, :asd], foo.recursively_gather(:content)
+  end
+
+  def test_container_for__recursively_gather_recursively_safe
+    eval <<-ruby
+      class Foo
+        container_for :field
+        attr_accessor :content
+      end
+    ruby
+
+    foo = Foo.new
+    foo.field = foo
+    foo.content = :a
+    assert_equal Set[:a], foo.recursively_gather(:content)
+  end
+
+  def test_process_race__1_process
+    stdout = process_race "echo 'blah'"
+    assert_equal 'blah', stdout.strip
+  end
+  
+  def test_process_race__2_processes
+    time = Time.now
+    stdout = process_race "echo 'blah'", "sleep 20; echo 'blah2'"
+    assert (Time.now - time) < 1
+    assert_equal 'blah', stdout.strip
+  end
+  
+  def test_string__increment_suffix
+    assert_equal 'asd_2', 'asd'.increment_suffix
+    assert_equal 'asd_3', 'asd_2'.increment_suffix
+    assert_equal 'asd_123', 'asd_122'.increment_suffix
+    assert_equal 'a1s2_d4_2', 'a1s2_d4'.increment_suffix
+  end
+
+  def test_array__worklist_each__plain
+    worklist = [3, 2, 1, 0]
+    looking_for = 0
+    worklist.worklist_each do |task|
+      if task == looking_for
+        looking_for += 1
+        next
+      else
+        next task
+      end
+    end
+    assert worklist.empty?
+    assert_equal 4, looking_for
+  end
+  
+  def test_array__worklist_each__stops_on_no_change
+    worklist = [3, 2, 5, 19, 1, 0]
+    looking_for = 0
+    worklist.worklist_each do |task|
+      if task == looking_for
+        looking_for += 1
+        next
+      else
+        next task
+      end
+    end
+    assert_equal 4, looking_for
+  end
+
+  def test_module__parent_module
+    eval <<-ruby
+      module Foo
+        class Foo2
+        end
+      end
+    ruby
+
+    assert_equal Object, String.parent_module
+    assert_equal ADSL::Util::GeneralTest, Foo.parent_module
+    assert_equal ADSL::Util::GeneralTest::Foo, Foo::Foo2.parent_module
+  end
+
+  def test_array__split_simple
+    array = [-1, 3, 12, -5, 20, 0, 45]
+
+    accepted, rejected = array.select_reject{ |i| i > 0 }
+    assert_equal [3, 12, 20, 45], accepted
+    assert_equal [-1, -5, 0], rejected
+  end
+
+  def test_array__split_cornercases
+    accepted, rejected = [1, 2, 3, 4, 5].select_reject{ |i| i > 0 }
+    assert_equal [1, 2, 3, 4, 5], accepted
+    assert_equal [], rejected
+   
+    accepted, rejected = [1, 2, 3, 4, 5].select_reject{ |i| i < 0 }
+    assert_equal [], accepted
+    assert_equal [1, 2, 3, 4, 5], rejected
+
+    accepted, rejected = [].select_reject{ |i| i < 0 }
+    assert_equal [], accepted
+    assert_equal [], rejected
+  end
+end

data/test/unit/adsl/util/test_helper_test.rb

@@ -0,0 +1,120 @@
+require 'test/unit'
+require 'adsl/util/test_helper'
+require 'adsl/fol/first_order_logic'
+
+class ADSL::Util::TestHelperTest < Test::Unit::TestCase
+  def test_adsl_assert__plain
+    adsl_assert :correct, <<-ADSL
+      class Class {}
+      action Action() {}
+      invariant true
+    ADSL
+  end
+
+  def test_adsl_assert__custom_conjecture
+    adsl_assert :correct, <<-ADSL
+      class Class {}
+      action Action() {}
+      invariant true
+    ADSL
+    adsl_assert :correct, <<-ADSL, :conjecture => true
+      class Class {}
+      action Action() {}
+    ADSL
+    adsl_assert :incorrect, <<-ADSL, :conjecture => false
+      class Class {}
+      action Action() {}
+    ADSL
+  end
+
+  def test_class_defined__basic
+    assert_false class_defined? :TestClassDefinedBasic
+    eval <<-ruby
+      class TestClassDefinedBasic
+      end
+    ruby
+    assert_true class_defined? :TestClassDefinedBasic
+  end
+
+  def test_class_defined__multiple
+    assert_false class_defined? :Multiple1, :Multiple2
+    eval <<-ruby
+      class Multiple1
+      end
+    ruby
+    assert_true class_defined? :Multiple1, :Multiple2
+  end
+  
+  def test_unload_class__classes_unload
+    assert_false class_defined? :TestUnloadClassClassesUnload
+    eval <<-ruby
+      class TestUnloadClassClassesUnload
+      end
+    ruby
+    assert class_defined? :TestUnloadClassClassesUnload
+    unload_class :TestUnloadClassClassesUnload
+    assert_false class_defined? :TestUnloadClassClassesUnload
+  end
+
+  def test_unload_class__works_through_modules
+    assert_false class_defined? '::Mod::TestUnloadClassWorksThroughModules'
+    if Object.const_defined? :Mod
+      assert_false class_defined? '::Mod::TestUnloadClassWorksThroughModules'
+    end
+
+    eval <<-ruby
+      module ::Mod
+        class TestUnloadClassWorksThroughModules
+        end
+      end
+    ruby
+
+    assert class_defined? '::Mod::TestUnloadClassWorksThroughModules'
+    unload_class '::Mod::TestUnloadClassWorksThroughModules'
+    assert_false class_defined? '::Mod::TestUnloadClassWorksThroughModules'
+  end
+
+  def test_unload_class__methods_get_removed
+    assert_false class_defined? :TestUnloadClassMethodsGetRemoved
+    eval <<-ruby
+      class TestUnloadClassMethodsGetRemoved
+        def a; end
+      end
+    ruby
+    assert class_defined? :TestUnloadClassMethodsGetRemoved
+    assert self.class.const_get(:TestUnloadClassMethodsGetRemoved).method_defined?('a')
+    unload_class :TestUnloadClassMethodsGetRemoved
+    assert_false class_defined? :TestUnloadClassMethodsGetRemoved
+    eval <<-ruby
+      class TestUnloadClassMethodsGetRemoved
+      end
+    ruby
+    assert class_defined? :TestUnloadClassMethodsGetRemoved
+    assert_false self.class.const_get(:TestUnloadClassMethodsGetRemoved).methods.include?('a')
+  end
+
+  def test_in_temp_file__block_called
+    called = false
+    in_temp_file "" do |path|
+      called = true
+    end
+    assert called
+  end
+ 
+  def test_in_temp_file__content_there
+    expected_content = "blah\nasd\n\n"
+    in_temp_file expected_content do |path|
+      file = File.open path, 'r'
+      assert_equal expected_content, file.read
+      file.close
+    end
+  end
+
+  def test_in_temp_file__file_gone_after_call
+    stored_path = nil
+    in_temp_file "" do |path|
+      stored_path = path
+    end
+    assert_false File.exists? stored_path
+  end
+end