linda 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 146404ba1cf1f376a8754616b292b0ff61e31bad
-  data.tar.gz: d1a42ff0cd3844a5c284651535f92b6ae1db37df
+  metadata.gz: 70d0f9c426b9d5b9aaf4105883f9a5e63a1aecb1
+  data.tar.gz: a4ff1571d734b2c0d7064edb2c7475a9b7c41584
 SHA512:
-  metadata.gz: 155875330105acc2169853d1a52a8c2f7847997a0e0249d246e4df97f9950a26371ebfe90d8db05272146e46e2d703b65e6cbf9b1c48c6bd60ac32f07dad37e1
-  data.tar.gz: 3f7fa331981194463618bb2c9df007e6ea57727efc59da57d46d8cd39232408bc3bbb98df2e7fd82b3e45b42c55d04b97286f102d9bc85bb660b0068d7d00ffd
+  metadata.gz: c24929e587bd7a72822e61d1ddf01d38a7a9194f2b542041d9231fa69a3a82e1e9fec84988d0199a134bc3b50efa08561cebda2b57facd07ac6dae8301118df4
+  data.tar.gz: b7b1248e760c20aff1fa7736ba205d6f345848d8585066dc999d4d5d15628908ce8320179226a9709fd136dd2bae1656be3470f92519b32032936290671bddc1

data/History.txt

@@ -1,3 +1,9 @@
+=== 0.0.2 2013-05-19
+
+* provide tests
+  * Linda::Test::Tuple
+  * Linda::Test::TupleSpace
+
 === 0.0.1 2013-05-18
 
 * implements tuple and tuplespace / tests

data/README.md

@@ -60,46 +60,117 @@ Linda::Tuple.new(:a => 1, :b => 2).match?(:a => 1, :b => 5)  # => false
 Tuple/TupleSpace Functions
 --------------------------
 
-### TupleSpace#write( tuple, options={} )
+### TupleSpace#write(tuple, options={})
 
 - write a Tuple into TupleSpace.
 - default : options = {:expire => 300}
   - expire 300(sec) after.
 - similar to `out` function in C-Linda.
 
-### TupleSpace#read( tuple )
+### TupleSpace#read(tuple)
 
 - return a Tuple which matches in TupleSpace. return `nil` if not exists.
 - similar to `rdp` function in C-Linda.
 
 
-### TupleSpace#read( tuple, &callback(tuple) )
+### TupleSpace#read(tuple, &callback(tuple))
 
 - callback a Tuple which matches in TupleSpace. wait until available.
 - async function : it does not return a value.
 - similar to `rd` function in C-Linda.
 
 
-### TupleSpace#take( tuple )
+### TupleSpace#take(tuple)
 
 - delete a Tuple, then return it which matches in TupleSpace. return `nil` if not exists.
 - similar to `inp` function in C-Linda.
 
 
-### TupleSpace#take( tuple, &callback(tuple) )
+### TupleSpace#take(tuple, &callback(tuple))
 
 - delete a Tuple, then callback it which matches in TupleSpace. wait until available.
 - async function : it does not return a value.
 - similar to `in` function in C-Linda.
 
 
-### TupleSpace#watch( tuple, &callback(tuple) )
+### TupleSpace#watch(tuple, &callback(tuple))
 
 - callback Tuples which matches when TupleSpace#write(tuple) is called.
 
 
+Test your Linda implementation
+------------------------------
+
+with [minitest](https://github.com/seattlerb/minitest).
+
+### Test Tuple
+
+`test/test_tuple.rb`
+```ruby
+require 'rubygems'
+require 'minitest/autorun'
+require 'linda/test/tuple'
+require 'path/to/my/linda/tuple'  # load your Tuple class
+
+class TestMyTuple < MiniTest::Test
+  include Linda::Test::Tuple      # mix-in test code
+
+  def target_tuple
+    My::Linda::Tuple              # set your Tuple class name
+  end
+end
+```
+
+    % ruby test/test_tuple.rb
+
+
+### Test TupleSpace
+
+`test/test_tuplespace.rb`
+```ruby
+require 'rubygems'
+require 'minitest/autorun'
+require 'linda/test/tuplespace'
+require 'path/to/my/linda/tuple'       # load your Tuple class
+require 'path/to/my/linda/tuplespace'  # load your TupleSpace class
+
+class TestMyTupleSpace < MiniTest::Test
+  include Linda::Test::TupleSpace      # mix-in test code
+
+  def target_tuple
+    My::Linda::Tuple                   # set your Tuple class name
+  end
+
+  def target_tuplespace
+    My::Linda::TupleSpace              # set your TupleSpace class name
+  end
+end
+```
+
+    % ruby test/test_tuplespace.rb
+
+
+### Rake
+
+`Rakefile`
+```ruby
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/test_*.rb"
+end
+
+task :default => :test
+```
+
+    % rake test
+
+=> run all tests
+
+
 Test
 ----
+test this gem
 
     % gem install bundler
     % bundle install

data/lib/linda/test/tuple.rb

@@ -0,0 +1,56 @@
+module Linda
+  module Test
+    module Tuple
+
+      def test_match_array_tuple
+        tuple = target_tuple.new [1,2,3]
+        assert tuple.match? target_tuple.new [1,2,3]
+        assert tuple.match? target_tuple.new [1,2,3,4]
+        assert !tuple.match?(target_tuple.new [1,2])
+        assert !tuple.match?(target_tuple.new [1,"a",3])
+        assert !tuple.match?(target_tuple.new :a => 1, :b => 2)
+        tuple = target_tuple.new ["a","b","c"]
+        assert tuple.match? target_tuple.new ["a","b","c"]
+        assert tuple.match? target_tuple.new ["a","b","c","d","efg",123,"h"]
+        assert !tuple.match?(target_tuple.new ["a","b"])
+        assert !tuple.match?(target_tuple.new ["a","b",789])
+        assert !tuple.match?(target_tuple.new :foo => 1, :bar => 2)
+      end
+
+      def test_match_array
+        tuple = target_tuple.new [1,2,3]
+        assert tuple.match? [1,2,3]
+        assert tuple.match? [1,2,3,4]
+        assert !tuple.match?([1,2])
+        assert !tuple.match?([1,"a",3])
+        assert !tuple.match?(:a => 1, :b => 2)
+        tuple = target_tuple.new ["a","b","c"]
+        assert tuple.match? ["a","b","c"]
+        assert tuple.match? ["a","b","c","d","efg",123,"h"]
+        assert !tuple.match?(["a","b"])
+        assert !tuple.match?(["a","b",789])
+        assert !tuple.match?(:foo => 1, :bar => 2)
+      end
+
+      def test_match_hash_tuple
+        tuple = target_tuple.new :a => 1, :b => 2
+        assert tuple.match? target_tuple.new :a => 1, :b => 2
+        assert tuple.match? target_tuple.new :a => 1, :b => 2, :c => 3
+        assert tuple.match? target_tuple.new :a => 1, :b => 2, :c => {:foo => "bar"}
+        assert !tuple.match?(target_tuple.new :a => 0, :b => 2)
+        assert !tuple.match?(target_tuple.new :b => 2, :c => 3)
+        assert !tuple.match?(target_tuple.new [1,2,3])
+      end
+
+      def test_match_hash
+        tuple = target_tuple.new :a => 1, :b => 2
+        assert tuple.match? :a => 1, :b => 2
+        assert tuple.match? :a => 1, :b => 2, :c => 3
+        assert tuple.match? :a => 1, :b => 2, :c => {:foo => "bar"}
+        assert !tuple.match?(:a => 0, :b => 2)
+        assert !tuple.match?(:b => 2, :c => 3)
+        assert !tuple.match?([1,2,3])
+      end
+    end
+  end
+end

data/lib/linda/test/tuplespace.rb

@@ -0,0 +1,134 @@
+module Linda
+  module Test
+    module TupleSpace
+
+      def setup
+        @space = target_tuplespace.new
+      end
+
+      def test_write_read
+        assert_equal @space.size, 0
+        @space.write target_tuple.new [1,2,3]
+        assert_equal @space.size, 1
+        assert_equal @space.read([1,2]).data, [1,2,3]
+        @space.write :a => 1, :b => 2, :c => 999
+        @space.write :a => 1, :b => 2, :c => 3
+        assert_equal @space.size, 3
+        assert_equal @space.read(:a => 1, :c => 999).data, {:a => 1, :b => 2, :c => 999}
+        assert_equal @space.read(:a => 1, :c => 999).data, {:a => 1, :b => 2, :c => 999}
+        assert_equal @space.read(:a => 1).data, {:a => 1, :b => 2, :c => 3}
+      end
+
+      def test_write_read_callback
+        assert_equal @space.size, 0
+        _tuple1 = nil
+        @space.read [1,2] do |tuple|
+          _tuple1 = tuple
+        end
+        _tuple2 = nil
+        @space.read [1,"a"] do |tuple|
+          _tuple2 = tuple
+        end
+        _tuple3 = nil
+        @space.read [1,2,3] do |tuple|
+          _tuple3 = tuple
+        end
+        @space.write [1,2,3]
+        assert_equal _tuple1.data, [1,2,3]
+        assert_equal _tuple2, nil
+        assert_equal _tuple3.data, [1,2,3]
+        assert_equal @space.read([1]).data, [1,2,3]
+        assert_equal @space.size, 1
+        @space.write [1,2,4]
+        assert_equal _tuple1.data, [1,2,3]
+        assert_equal @space.size, 2
+      end
+
+      def test_take
+        assert_equal @space.size, 0
+        1.upto(3) do |i|
+          @space.write [1,2,3,"a"*i]
+        end
+        assert_equal @space.size, 3
+        assert_equal @space.take([1,2,3]).data, [1,2,3,"aaa"]
+        assert_equal @space.size, 2
+        @space.write :a => 1, :b => 2, :c => 3
+        assert_equal @space.size, 3
+        assert_equal @space.take([1,3]), nil
+        assert_equal @space.take(:a => 1, :b => 2, :c => 4), nil
+        assert_equal @space.take([1,2,3]).data, [1,2,3,"aa"]
+        assert_equal @space.size, 2
+        assert_equal @space.take([1,2,3]).data, [1,2,3,"a"]
+        assert_equal @space.size, 1
+        assert_equal @space.take(:b => 2, :a => 1).data, {:a => 1, :b => 2, :c => 3}
+        assert_equal @space.size, 0
+      end
+
+      def test_take_callback
+        assert_equal @space.size, 0
+        _tuple1 = nil
+        @space.take [1,2] do |tuple|
+          _tuple1 = tuple
+        end
+        _tuple2 = nil
+        @space.take [1,"a"] do |tuple|
+          _tuple2 = tuple
+        end
+        _tuple3 = nil
+        @space.read [1,2,3] do |tuple|
+          _tuple3 = tuple
+        end
+        _tuple4 = nil
+        @space.take [1,2,3] do |tuple|
+          _tuple4 = tuple
+        end
+        1.upto(3) do |i|
+          @space.write [1,2,3,"a"*i]
+        end
+        assert_equal @space.size, 1
+        assert_equal _tuple1.data, [1,2,3,"a"]
+        assert_equal _tuple2, nil
+        assert_equal _tuple3.data, [1,2,3,"aa"]
+        assert_equal _tuple4.data, [1,2,3,"aa"]
+        assert_equal @space.take([1]).data, [1,2,3,"aaa"]
+        assert_equal @space.size, 0
+      end
+
+      def test_watch
+        assert_equal @space.size, 0
+        _tuple1 = nil
+        @space.take [1] do |tuple|
+          _tuple1 = tuple
+        end
+        results = []
+        @space.watch [1,2] do |tuple|
+          results << tuple
+        end
+        @space.write [1,2,3]
+        @space.write [1,2,"aa"]
+        @space.write [1,"a",3]
+        assert_equal _tuple1.data, [1,2,3]
+        assert_equal @space.size, 2
+        assert_equal results.size, 2
+        assert_equal results[0].data, [1,2,3]
+        assert_equal results[1].data, [1,2,"aa"]
+      end
+
+      def test_tuple_expire
+        @space.write [1,2,999], :expire => false
+        @space.write [1,2,3], :expire => 3
+        @space.write [1,2,"a","b"], :expire => 2
+        assert_equal @space.size, 3
+        sleep 2
+        @space.check_expire
+        assert_equal @space.size, 2
+        assert_equal @space.take([1,2]).data, [1,2,3]
+        assert_equal @space.size, 1
+        sleep 1
+        assert_equal @space.take([1,2]).data, [1,2,999]
+        assert_equal @space.size, 0
+      end
+
+    end
+  end
+end

data/lib/linda/version.rb

@@ -1,3 +1,3 @@
 module Linda
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/test_tuple.rb

@@ -1,53 +1,10 @@
 require File.expand_path 'test_helper', File.dirname(__FILE__)
+require 'linda/test/tuple'
 
 class TestTuple < MiniTest::Test
-  def test_match_array_tuple
-    tuple = Linda::Tuple.new [1,2,3]
-    assert tuple.match? Linda::Tuple.new [1,2,3]
-    assert tuple.match? Linda::Tuple.new [1,2,3,4]
-    assert !tuple.match?(Linda::Tuple.new [1,2])
-    assert !tuple.match?(Linda::Tuple.new [1,"a",3])
-    assert !tuple.match?(Linda::Tuple.new :a => 1, :b => 2)
-    tuple = Linda::Tuple.new ["a","b","c"]
-    assert tuple.match? Linda::Tuple.new ["a","b","c"]
-    assert tuple.match? Linda::Tuple.new ["a","b","c","d","efg",123,"h"]
-    assert !tuple.match?(Linda::Tuple.new ["a","b"])
-    assert !tuple.match?(Linda::Tuple.new ["a","b",789])
-    assert !tuple.match?(Linda::Tuple.new :foo => 1, :bar => 2)
-  end
-
-  def test_match_array
-    tuple = Linda::Tuple.new [1,2,3]
-    assert tuple.match? [1,2,3]
-    assert tuple.match? [1,2,3,4]
-    assert !tuple.match?([1,2])
-    assert !tuple.match?([1,"a",3])
-    assert !tuple.match?(:a => 1, :b => 2)
-    tuple = Linda::Tuple.new ["a","b","c"]
-    assert tuple.match? ["a","b","c"]
-    assert tuple.match? ["a","b","c","d","efg",123,"h"]
-    assert !tuple.match?(["a","b"])
-    assert !tuple.match?(["a","b",789])
-    assert !tuple.match?(:foo => 1, :bar => 2)
-  end
-
-  def test_match_hash_tuple
-    tuple = Linda::Tuple.new :a => 1, :b => 2
-    assert tuple.match? Linda::Tuple.new :a => 1, :b => 2
-    assert tuple.match? Linda::Tuple.new :a => 1, :b => 2, :c => 3
-    assert tuple.match? Linda::Tuple.new :a => 1, :b => 2, :c => {:foo => "bar"}
-    assert !tuple.match?(Linda::Tuple.new :a => 0, :b => 2)
-    assert !tuple.match?(Linda::Tuple.new :b => 2, :c => 3)
-    assert !tuple.match?(Linda::Tuple.new [1,2,3])
-  end
+  include Linda::Test::Tuple
 
-  def test_match_hash
-    tuple = Linda::Tuple.new :a => 1, :b => 2
-    assert tuple.match? :a => 1, :b => 2
-    assert tuple.match? :a => 1, :b => 2, :c => 3
-    assert tuple.match? :a => 1, :b => 2, :c => {:foo => "bar"}
-    assert !tuple.match?(:a => 0, :b => 2)
-    assert !tuple.match?(:b => 2, :c => 3)
-    assert !tuple.match?([1,2,3])
+  def target_tuple
+    Linda::Tuple
   end
 end

data/test/test_tuplespace.rb

@@ -1,132 +1,14 @@
 require File.expand_path 'test_helper', File.dirname(__FILE__)
+require 'linda/test/tuplespace'
 
 class TestTupleSpace < MiniTest::Test
+  include Linda::Test::TupleSpace
 
-  def setup
-    @space = Linda::TupleSpace.new
+  def target_tuplespace
+    Linda::TupleSpace
   end
 
-  def test_write_read
-    assert_equal @space.size, 0
-    @space.write Linda::Tuple.new [1,2,3]
-    assert_equal @space.size, 1
-    assert_equal @space.read([1,2]).data, [1,2,3]
-    @space.write :a => 1, :b => 2, :c => 999
-    @space.write :a => 1, :b => 2, :c => 3
-    assert_equal @space.size, 3
-    assert_equal @space.read(:a => 1, :c => 999).data, {:a => 1, :b => 2, :c => 999}
-    assert_equal @space.read(:a => 1, :c => 999).data, {:a => 1, :b => 2, :c => 999}
-    assert_equal @space.read(:a => 1).data, {:a => 1, :b => 2, :c => 3}
+  def target_tuple
+    Linda::Tuple
   end
-
-  def test_write_read_callback
-    assert_equal @space.size, 0
-    _tuple1 = nil
-    @space.read [1,2] do |tuple|
-      _tuple1 = tuple
-    end
-    _tuple2 = nil
-    @space.read [1,"a"] do |tuple|
-      _tuple2 = tuple
-    end
-    _tuple3 = nil
-    @space.read [1,2,3] do |tuple|
-      _tuple3 = tuple
-    end
-    @space.write [1,2,3]
-    assert_equal _tuple1.data, [1,2,3]
-    assert_equal _tuple2, nil
-    assert_equal _tuple3.data, [1,2,3]
-    assert_equal @space.read([1]).data, [1,2,3]
-    assert_equal @space.size, 1
-    @space.write [1,2,4]
-    assert_equal _tuple1.data, [1,2,3]
-    assert_equal @space.size, 2
-  end
-
-  def test_take
-    assert_equal @space.size, 0
-    1.upto(3) do |i|
-      @space.write [1,2,3,"a"*i]
-    end
-    assert_equal @space.size, 3
-    assert_equal @space.take([1,2,3]).data, [1,2,3,"aaa"]
-    assert_equal @space.size, 2
-    @space.write :a => 1, :b => 2, :c => 3
-    assert_equal @space.size, 3
-    assert_equal @space.take([1,3]), nil
-    assert_equal @space.take(:a => 1, :b => 2, :c => 4), nil
-    assert_equal @space.take([1,2,3]).data, [1,2,3,"aa"]
-    assert_equal @space.size, 2
-    assert_equal @space.take([1,2,3]).data, [1,2,3,"a"]
-    assert_equal @space.size, 1
-    assert_equal @space.take(:b => 2, :a => 1).data, {:a => 1, :b => 2, :c => 3}
-    assert_equal @space.size, 0
-  end
-
-  def test_take_callback
-    assert_equal @space.size, 0
-    _tuple1 = nil
-    @space.take [1,2] do |tuple|
-      _tuple1 = tuple
-    end
-    _tuple2 = nil
-    @space.take [1,"a"] do |tuple|
-      _tuple2 = tuple
-    end
-    _tuple3 = nil
-    @space.read [1,2,3] do |tuple|
-      _tuple3 = tuple
-    end
-    _tuple4 = nil
-    @space.take [1,2,3] do |tuple|
-      _tuple4 = tuple
-    end
-    1.upto(3) do |i|
-      @space.write [1,2,3,"a"*i]
-    end
-    assert_equal @space.size, 1
-    assert_equal _tuple1.data, [1,2,3,"a"]
-    assert_equal _tuple2, nil
-    assert_equal _tuple3.data, [1,2,3,"aa"]
-    assert_equal _tuple4.data, [1,2,3,"aa"]
-    assert_equal @space.take([1]).data, [1,2,3,"aaa"]
-    assert_equal @space.size, 0
-  end
-
-  def test_watch
-    assert_equal @space.size, 0
-    _tuple1 = nil
-    @space.take [1] do |tuple|
-      _tuple1 = tuple
-    end
-    results = []
-    @space.watch [1,2] do |tuple|
-      results << tuple
-    end
-    @space.write [1,2,3]
-    @space.write [1,2,"aa"]
-    @space.write [1,"a",3]
-    assert_equal _tuple1.data, [1,2,3]
-    assert_equal @space.size, 2
-    assert_equal results.size, 2
-    assert_equal results[0].data, [1,2,3]
-    assert_equal results[1].data, [1,2,"aa"]
-  end
-
-  def test_tuple_expire
-    @space.write [1,2,999], :expire => false
-    @space.write [1,2,3], :expire => 3
-    @space.write [1,2,"a","b"], :expire => 2
-    assert_equal @space.size, 3
-    sleep 2
-    @space.check_expire
-    assert_equal @space.size, 2
-    assert_equal @space.take([1,2]).data, [1,2,3]
-    assert_equal @space.size, 1
-    sleep 1
-    assert_equal @space.take([1,2]).data, [1,2,999]
-    assert_equal @space.size, 0
-  end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: linda
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Sho Hashimoto
@@ -67,6 +67,8 @@ files:
 - README.md
 - Rakefile
 - lib/linda.rb
+- lib/linda/test/tuple.rb
+- lib/linda/test/tuplespace.rb
 - lib/linda/tuple.rb
 - lib/linda/tuplespace.rb
 - lib/linda/version.rb