comp_tree 0.5.2 → 0.7.0

data/test/common.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'test/unit'
+require 'comp_tree'
+require 'benchmark'
+
+module TestCommon
+  if ARGV.include?("--bench")
+    def separator
+      puts
+      puts "-"*60
+    end
+
+    def bench_output(desc = nil, stream = STDOUT, &block)
+      if desc
+        stream.puts(desc)
+      end
+      if block
+        expression = block.call
+        result = eval(expression, block.binding)
+        stream.printf("%-16s => %s\n", expression, result.inspect)
+        result
+      end
+    end
+  else
+    def separator() end
+    def bench_output(desc = nil, stream = STDOUT, &block) end
+  end
+end

data/test/test_basic.rb

@@ -0,0 +1,189 @@
+require File.dirname(__FILE__) + "/common"
+
+class TestBasic < Test::Unit::TestCase
+  def test_define
+    (1..20).each { |threads|
+      CompTree.build { |driver|
+        driver.define(:area, :width, :height, :offset) { |width, height, offset|
+          width*height - offset
+        }
+        
+        driver.define(:width, :border) { |border|
+          2 + border
+        }
+        
+        driver.define(:height, :border) { |border|
+          3 + border
+        }
+        
+        driver.define(:border) {
+          5
+        }
+        
+        driver.define(:offset) {
+          7
+        }
+        
+        assert_equal((2 + 5)*(3 + 5) - 7, driver.compute(:area, threads))
+      }
+    }
+  end
+
+  def test_already_computed
+    [nil, false, true, 33].each { |result|
+      CompTree.build { |driver|
+        driver.define(:a) { result }
+        (1..3).each { |n|
+          assert_equal(result, driver.compute(:a, n))
+        }
+      }
+    }
+  end
+
+  def test_threads_opt
+    (1..20).each { |threads|
+      CompTree.build do |driver|
+        driver.define(:a) { 33 }
+        assert_equal(33, driver.compute(:a, :threads => threads))
+      end
+    }
+  end
+
+  def test_malformed
+    CompTree.build { |driver|
+      assert_raise(CompTree::ArgumentError) {
+        driver.define {
+        }
+      }
+      assert_raise(CompTree::RedefinitionError) {
+        driver.define(:a) {
+        }
+        driver.define(:a) {
+        }
+      }
+      assert_raise(CompTree::ArgumentError) {
+        driver.define(:b) {
+        }
+        driver.compute(:b, 0)
+      }
+      assert_raise(CompTree::ArgumentError) {
+        driver.define(:c) {
+        }
+        driver.compute(:c, -1)
+      }
+    }
+  end
+
+  def test_exception_in_compute
+    test_error = Class.new(RuntimeError)
+    CompTree.build { |driver|
+      driver.define(:area, :width, :height, :offset) { |width, height, offset|
+        width*height - offset
+      }
+      
+      driver.define(:width, :border) { |border|
+        2 + border
+      }
+      
+      driver.define(:height, :border) { |border|
+        3 + border
+      }
+      
+      driver.define(:border) {
+        raise test_error
+      }
+      
+      driver.define(:offset) {
+        7
+      }
+      
+      assert_raise(test_error) {
+        driver.compute(:area, 6)
+      }
+    }
+  end
+
+  def test_node_subclass
+    data = Object.new
+    subclass = Class.new(CompTree::Node) {
+      define_method :stuff do
+        data
+      end
+    }
+    CompTree.build(:node_class => subclass) { |driver|
+      driver.define(:a) { }
+      assert_equal(data, driver.nodes[:a].stuff)
+    }
+  end
+
+  def test_non_symbols
+    width_id = Object.new
+    height_id = 272727
+    (1..3).each { |threads|
+      CompTree.build { |driver|
+        driver.define("area", width_id, height_id, :offset) {
+          |width, height, offset|
+          width*height - offset
+        }
+          
+        driver.define(width_id, :border) { |border|
+          2 + border
+        }
+          
+        driver.define(height_id, :border) { |border|
+          3 + border
+        }
+          
+        driver.define(:border) {
+          5
+        }
+          
+        driver.define(:offset) {
+          7
+        }
+          
+        assert_equal((2 + 5)*(3 + 5) - 7, driver.compute("area", threads))
+      }
+    }
+  end
+
+  def test_node_name_equality_comparison
+    CompTree.build { |driver|
+      driver.define("hello") { }
+      assert_raise(CompTree::RedefinitionError) {
+        driver.define("hello") { }
+      }
+    }
+  end
+  
+  def test_result_variety
+    [true, false, nil, Object.new, 33].each { |result|
+      (1..20).each { |threads|
+        CompTree.build { |driver|
+          driver.define(:area, :width, :height, :offset) {
+            |width, height, offset|
+            result
+          }
+          
+          driver.define(:width, :border) { |border|
+            result
+          }
+          
+          driver.define(:height, :border) { |border|
+            result
+          }
+          
+          driver.define(:border) {
+            result
+          }
+          
+          driver.define(:offset) {
+            result
+          }
+          
+          assert_equal(result, driver.compute(:area, threads))
+        }
+      }
+    }
+  end
+end

data/test/test_circular.rb

@@ -1,36 +1,39 @@
-$LOAD_PATH.unshift(File.expand_path("#{File.dirname(__FILE__)}/../lib"))
+require File.dirname(__FILE__) + "/common"
 
-require 'comp_tree'
-require 'test/unit'
+class TestCircular < Test::Unit::TestCase
+  def test_circular
+    CompTree.build { |driver|
+      driver.define(:area, :width, :height, :offset) { |width, height, offset|
+        width*height - offset
+      }
+      
+      driver.define(:width, :border) { |border|
+        2 + border
+      }
+      
+      driver.define(:height, :border) { |border|
+        3 + border
+      }
+      
+      driver.define(:border) {
+        5
+      }
+      
+      driver.define(:offset, :area) {
+        7
+      }
 
-module CompTree
-  class TestCircular < Test::Unit::TestCase
-    def test_1
-      CompTree::Driver.new { |driver|
-        driver.define(:area, :width, :height, :offset) { |width, height, offset|
-          width*height - offset
-        }
-        
-        driver.define(:width, :border) { |border|
-          2 + border
-        }
-        
-        driver.define(:height, :border) { |border|
-          3 + border
-        }
-        
-        driver.define(:border) {
-          5
-        }
-        
-        driver.define(:offset, :area) {
-          7
-        }
+      assert_equal([:area, :offset, :area], driver.check_circular(:area))
+      assert_equal([:offset, :area, :offset], driver.check_circular(:offset))
+    }
+  end
 
-        assert_raises(Error::CircularError) {
-          driver.check_circular(:area)
-        }
-      }
-    end
+  def test_not_circular
+    CompTree.build { |driver|
+      driver.define(:a, :b) { true }
+      driver.define(:b) { true }
+      assert_nil(driver.check_circular(:a))
+      assert_nil(driver.check_circular(:b))
+    }
   end
 end

data/test/test_drain.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + "/common"
+
+class TestDrain < Test::Unit::TestCase
+  include TestCommon
+
+  def drain
+    500000.times { }
+  end
+  
+  def run_drain(threads)
+    CompTree.build { |driver|
+      func = lambda { |*args|
+        drain
+      }
+      driver.define(:area, :width, :height, :offset, &func)
+      driver.define(:width, :border, &func)
+      driver.define(:height, :border, &func)
+      driver.define(:border, &func)
+      driver.define(:offset, &func)
+      bench_output "number of threads: #{threads}"
+      bench = Benchmark.measure { driver.compute(:area, threads) }
+      bench_output bench
+    }
+  end
+
+  def each_drain
+    (1..10).each { |threads|
+      yield threads
+    }
+  end
+
+  def test_drain
+    separator
+    each_drain { |threads|
+      run_drain(threads)
+    }
+  end
+end

data/test/test_exception.rb

@@ -1,97 +1,48 @@
-
-#
-# Mean workaround using separate processes due to assert_raise causing
-# problems with threads.
-#
-
-require 'test/unit'
-
-module WorkaroundConfig
-  HERE = File.dirname(__FILE__)
-  LIB_DIR = File.expand_path("#{HERE}/../lib")
-  QUIX_LIB_DIR = File.expand_path("#{HERE}/../contrib/quix/lib")
-  OUTPUT_FILE = "#{HERE}/#{File.basename(__FILE__)}.output"
-  
-  $LOAD_PATH.unshift LIB_DIR
-  $LOAD_PATH.unshift QUIX_LIB_DIR
-end
-  
-require 'comp_tree'
-require 'quix/config'
-
-module CompTree
-  class TestRaises < Test::Unit::TestCase
-    include WorkaroundConfig
-
-    def test_exception
-      if RUBY_PLATFORM =~ %r!java!
-        puts "skipping #{File.basename(__FILE__)}."
-      else
-        [true, false].each { |use_fork|
-          [true, false].each { |define_all|
-            assert(
-              !system(
-                ::Quix::Config.ruby_executable,
-                "-e",
-                code(use_fork, define_all)))
+require File.dirname(__FILE__) + "/common"
+
+class TestException < Test::Unit::TestCase
+  def test_exception
+    test_error = Class.new StandardError
+    [true, false].each { |define_all|
+      error = (
+        begin
+          CompTree.build { |driver|
+            driver.define(:area, :width, :height, :offset) {
+              |width, height, offset|
+              width*height - offset
+            }
             
-            output = File.read(OUTPUT_FILE)
+            driver.define(:width, :border) { |border|
+              2 + border
+            }
 
+            driver.define(:height, :border) { |border|
+              3 + border
+            }
+            
             if define_all
-              assert_match(%r!CompTreeTestError!, output)
-            else
-              assert_match(%r!NoFunctionError!, output)
+              driver.define(:border) {
+                raise test_error
+              }
             end
             
-            File.unlink(OUTPUT_FILE) # leave when exception raised above
-          }
-        }
-      end
-    end
-
-    def code(use_fork, define_all)
-      %Q( 
-        $LOAD_PATH.unshift '#{LIB_DIR}'
-        require 'comp_tree'
-        require 'open3'
-        
-        class CompTreeTestError < Exception ; end
-        
-        CompTree::Driver.new { |driver|
-          driver.define(:area, :width, :height, :offset) {
-            |width, height, offset|
-            width*height - offset
-          }
-
-          driver.define(:width, :border) { |border|
-            2 + border
+            driver.define(:offset) {
+              7
+            }
+      
+            driver.compute(:area, 99) 
           }
+          nil
+        rescue => e
+          e
+        end
+      )
 
-          driver.define(:height, :border) { |border|
-            3 + border
-          }
-      ) +    
       if define_all
-        %Q(
-          driver.define(:border) {
-            raise CompTreeTestError
-          }
-        )
+        assert_block { error.is_a? test_error }
       else
-        ""
-      end +
-      %Q(        
-          driver.define(:offset) {
-            7
-          }
-          
-          File.open('#{OUTPUT_FILE}', "w") { |out|
-            $stderr = out
-            driver.compute(
-              :area, :threads => 99, :fork => #{use_fork.inspect})
-          }
-        }
-      )
-    end
+        assert_block { error.is_a? CompTree::NoFunctionError }
+      end
+    }
   end
 end 

data/test/test_flood.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + "/common"
+
+class TestFlood < Test::Unit::TestCase
+  def test_thread_flood
+    (1..200).each { |num_threads|
+      CompTree.build { |driver|
+        noop = lambda { |*args| true }
+        driver.define(:a, :b, &noop)
+        driver.define(:b, &noop)
+        driver.compute(:a, num_threads)
+      }
+    }
+  end
+end

data/test/test_grind.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + "/common"
+
+class TestGrind < Test::Unit::TestCase
+  include TestCommon
+
+  GENERATOR_DATA = {
+    :level_range => 1..4,
+    :children_range => 1..6,
+    :thread_range => 1..6,
+    :drain_iterations => 0,
+  }
+
+  ROOT = 'a'
+
+  def test_grind
+    run_generated_tree(GENERATOR_DATA)
+  end
+
+  def generate_comp_tree(num_levels, num_children, drain_iterations)
+    CompTree.build { |driver|
+      name_gen = ROOT.dup
+      pick_names = lambda { |*args|
+        (0..rand(num_children)).map {
+          name_gen.succ!
+          name_gen.dup
+        }
+      }
+      drain = lambda { |*args|
+        drain_iterations.times {
+        }
+      }
+      build_tree = lambda { |parent, children, level|
+        #trace "building #{parent} --> #{children.join(' ')}"
+        
+        driver.define(parent, *children, &drain)
+
+        if level < num_levels
+          children.each { |child|
+            build_tree.call(child, pick_names.call, level + 1)
+          }
+        else
+          children.each { |child|
+            driver.define(child, &drain)
+          }
+        end
+      }
+      build_tree.call(ROOT, pick_names.call, drain_iterations)
+      driver
+    }
+  end
+
+  def run_generated_tree(args)
+    args[:level_range].each { |num_levels|
+      args[:children_range].each { |num_children|
+        separator
+        bench_output {%{num_levels}}
+        bench_output {%{num_children}}
+        driver = generate_comp_tree(
+          num_levels,
+          num_children,
+          args[:drain_iterations])
+        args[:thread_range].each { |threads|
+         bench_output {%{threads}}
+          2.times {
+            driver.reset(ROOT)
+            result = nil
+            bench = Benchmark.measure {
+              result = driver.compute(ROOT, threads)
+            }
+            bench_output bench
+            assert_equal(result, args[:drain_iterations])
+          }
+        }
+      }
+    }
+  end
+end

data/test/test_sequential.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + "/common"
+
+class TestSequential < Test::Unit::TestCase
+  def test_sequential
+    (1..50).each { |num_threads|
+      [1, 2, 3, 20, 50].each { |num_nodes|
+        CompTree.build { |driver|
+          driver.define(:root) { true }
+          (1..num_nodes).each { |n|
+            if n == 0
+              driver.define("a#{n}".to_s, :root) { true }
+            else
+              driver.define("a#{n}".to_s, "a#{n-1}".to_s) { true }
+            end
+          }
+          driver.compute(:root, num_threads)
+        }
+      }
+    }
+  end
+end