diametric 0.1.1-java → 0.1.2-java

data/ext/diametric/DiametricUtils.java

@@ -1,6 +1,5 @@
 package diametric;
 
-import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.Reader;
@@ -8,8 +7,10 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.UUID;
 
 import org.jruby.Ruby;
@@ -30,6 +31,11 @@ import org.jruby.javasupport.util.RuntimeHelpers;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
+import clojure.lang.APersistentVector;
+import clojure.lang.IPersistentSet;
+import clojure.lang.LazySeq;
+import clojure.lang.PersistentHashSet;
+import clojure.lang.PersistentVector;
 import datomic.Util;
 
 @JRubyModule(name="Diametric::Persistence::Utils")
@@ -71,6 +77,7 @@ public class DiametricUtils {
     }
     
     static Object convertRubyToJava(ThreadContext context, IRubyObject value) {
+        if (value instanceof RubyNil) return null;
         if (value instanceof RubyString) {
             String str = (String)((RubyString)value).toJava(String.class);
             try {
@@ -97,26 +104,39 @@ public class DiametricUtils {
             RubyTime tmvalue = (RubyTime)RuntimeHelpers.invoke(context, value, "to_time");
             return (Object)tmvalue.getJavaDate();
         }
+        // needs to check Set since Set responses to "to_a"
+        if (value.respondsTo("intersection")) {
+            return getPersistentSet(context, value);
+        }
         //System.out.println("NOT YET CONVERTED");
         //System.out.println("RESPONDSTO? TO_A:" + value.respondsTo("to_a"));
         if (value.respondsTo("to_a")) { // might be Set for cardinality many type
-            RubyArray ruby_array = (RubyArray)RuntimeHelpers.invoke(context, value, "to_a");
-            List<Object> list = new ArrayList<Object>();
-            while (true) {
-                IRubyObject element = ruby_array.shift(context);
-                if (element.isNil()) break;
-                list.add(DiametricUtils.convertRubyToJava(context, element));
-            }
-            return Collections.unmodifiableList(list);
+            return getList(context, value);
         }
         if (value instanceof DiametricObject) {
             return ((DiametricObject)value).toJava();
         }
         return (Object)value.toJava(Object.class);
     }
-   
+
+    static IPersistentSet getPersistentSet(ThreadContext context, IRubyObject value) {
+        return PersistentHashSet.create((List)value.callMethod(context, "to_a"));
+    }
+
+    static List<Object> getList(ThreadContext context, IRubyObject value) {
+        RubyArray ruby_array = (RubyArray)RuntimeHelpers.invoke(context, value, "to_a");
+        List<Object> list = new ArrayList<Object>();
+        while (true) {
+            IRubyObject element = ruby_array.shift(context);
+            if (element.isNil()) break;
+            list.add(DiametricUtils.convertRubyToJava(context, element));
+        }
+        return Collections.unmodifiableList(list);
+    }
+
     static IRubyObject convertJavaToRuby(ThreadContext context, Object value) {
         Ruby runtime = context.getRuntime();
+        if (value == null) return context.getRuntime().getNil();
         if (value instanceof String) return RubyString.newString(runtime, (String)value);
         if (value instanceof Boolean) return RubyBoolean.newBoolean(runtime, (Boolean)value);
         if (value instanceof Long) return RubyFixnum.newFixnum(runtime, (Long)value);
@@ -126,6 +146,14 @@ public class DiametricUtils {
         if (value instanceof java.math.BigInteger) return RubyBignum.newBignum(runtime, ((java.math.BigInteger)value).longValue());
         if (value instanceof Double) return RubyFloat.newFloat(runtime, (Double)value);
         if (value instanceof Date) return RubyTime.newTime(runtime, ((Date)value).getTime());
+        if (value instanceof Set) {
+            return getDiametricSet(context, (Set)value);
+        }
+        if ((value instanceof APersistentVector) ||
+                (value instanceof LazySeq) ||
+                (value instanceof PersistentVector.ChunkedSeq)){
+            return getDiametricCollection(context, (List)value);
+        }
         if (value instanceof java.util.UUID) {
             RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::UUID");
             DiametricUUID diametric_uuid = (DiametricUUID)clazz.allocate();
@@ -135,6 +163,20 @@ public class DiametricUtils {
         return JavaUtil.convertJavaToUsableRubyObject(runtime, value);
     }
 
+    static IRubyObject getDiametricSet(ThreadContext context, Set value) {
+        RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Set");
+        DiametricSet diametric_set = (DiametricSet)clazz.allocate();
+        diametric_set.init(value);
+        return diametric_set;
+    }
+
+    static IRubyObject getDiametricCollection(ThreadContext context, List value) {
+        RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::Collection");
+        DiametricCollection diametric_collection = (DiametricCollection)clazz.allocate();
+        diametric_collection.init((List)value);
+        return diametric_collection;
+    }
+
     static List<Object> convertRubyTxDataToJava(ThreadContext context, IRubyObject arg) {
         List<Object> tx_data = null;
         if (arg instanceof RubyArray) {

data/lib/diametric/entity.rb

@@ -317,12 +317,12 @@ module Diametric
           if parent.class.attributes[e][:value_type] == "ref"
             ref = parent.instance_variable_get("@#{e.to_s}")
             if ref.is_a?(Fixnum) || ref.is_a?(Java::DatomicQuery::EntityMap)
-              child = from_dbid_or_entity(ref, connection)
+              child = reify(ref, connection)
               child = resolve_ref_dbid(child, connection)
               parent.instance_variable_set("@#{e.to_s}", child)
             elsif ref.is_a?(Set)
               children = ref.inject(Set.new) do |memo, entity|
-               child = from_dbid_or_entity(entity, connection)
+               child = reify(entity, connection)
                 memo.add(child)
                 memo
               end
@@ -333,7 +333,7 @@ module Diametric
         parent
       end
 
-      def from_dbid_or_entity(thing, conn_or_db=nil, resolve=false)
+      def reify(thing, conn_or_db=nil, resolve=false)
         conn_or_db ||= Diametric::Persistence::Peer.connect.db
 
         if conn_or_db.respond_to?(:db)
@@ -350,6 +350,8 @@ module Diametric
           else
             entity = conn_or_db.entity(dbid)
           end
+        elsif thing.kind_of? java.lang.Long
+          entity = conn_or_db.entity(Diametric::Persistence::Object.new(thing))
         elsif thing.respond_to?(:to_java)
           dbid = thing.to_java
           entity = conn_or_db.entity(dbid)
@@ -365,7 +367,7 @@ module Diametric
           match_data = /:([a-zA-Z0-9_]+)\/([a-zA-Z0-9_]+)/.match(key)
           instance.send("#{match_data[2]}=", entity[key])
         end
-        instance.send("dbid=", Diametric::Persistence::Object.new(dbid))
+        instance.send("dbid=", Diametric::Persistence::Object.new(entity.get("db/id")))
 
         if resolve
           instance = resolve_ref_dbid(instance, conn_or_db)
@@ -378,7 +380,7 @@ module Diametric
         if self.instance_variable_get("@peer")
           connection ||= Diametric::Persistence::Peer.connect
         end
-        from_dbid_or_entity(id, connection)
+        reify(id, connection)
       end
 
       # Returns the prefix for this model used in Datomic. Can be

data/lib/diametric/persistence/common.rb

@@ -45,21 +45,21 @@ module Diametric
           end
         end
 
-        def all(connection=nil, resolve=false)
+        def all(connection=nil, resolve=true)
           if self.instance_variable_get("@peer")
             connection ||= Diametric::Persistence::Peer.connect
           end
           Diametric::Query.new(self, connection, resolve).all
         end
 
-        def first(conditions = {}, connection=nil, resolve=false)
+        def first(conditions = {}, connection=nil, resolve=true)
           if self.instance_variable_get("@peer")
             connection ||= Diametric::Persistence::Peer.connect
           end
           where(conditions, connection, resolve).first
         end
 
-        def where(conditions = {}, connection=nil, resolve=false)
+        def where(conditions = {}, connection=nil, resolve=true)
           if self.instance_variable_get("@peer")
             connection ||= Diametric::Persistence::Peer.connect
           end

data/lib/diametric/persistence/peer.rb

@@ -102,7 +102,6 @@ module Diametric
           child.instance_variable_set("@previously_changed", child.changes)
           child.changed_attributes.clear
           child.dbid = resolve_tempid(map, child.dbid)
-          child.instance_variable_set("@tx_map", map)
         end
         resolve_changes(queue, map) unless queue.empty?
       end
@@ -116,7 +115,7 @@ module Diametric
         if result
           query_string = ":#{result[1]}/_#{result[2]}"
           entities = Diametric::Persistence::Peer.reverse_q(args[0].db, self.dbid, query_string)
-          entities.collect {|e| self.class.from_dbid_or_entity(e, args[0])}
+          entities.collect {|e| self.class.reify(e, args[0])}
         else
           super
         end
@@ -127,7 +126,7 @@ module Diametric
           entity = self.new
           dbid = dbid.to_i if dbid.is_a?(String)
           connection ||= Diametric::Persistence::Peer.connect
-          entity = self.from_dbid_or_entity(dbid, connection, resolve)
+          entity = self.reify(dbid, connection, resolve)
           entity
         end
 
@@ -138,15 +137,7 @@ module Diametric
           else
             db = conn_or_db
           end
-
-          results = Diametric::Persistence::Peer.q(query, db, args)
-          # Diametric query expects the first element of each array in
-          # results is dbid. Wraps dbid here by
-          # Diametric::Persistence::Object to make it consistent
-          results.each do |r|
-            r[0] = Diametric::Persistence::Object.new(r[0])
-          end
-          results
+          Diametric::Persistence::Peer.q(query, db, args)
         end
       end
     end

data/lib/diametric/persistence/rest.rb

@@ -7,7 +7,7 @@ module Diametric
   module Persistence
     module REST
       @connection = nil
-      @persisted_classes = Set.new
+      @persisted_classes = ::Set.new
 
       def self.included(base)
         base.send(:include, Diametric::Persistence::Common)

data/lib/diametric/query.rb

@@ -81,23 +81,22 @@ module Diametric
         filter = filter.map { |e| convert_filter_element(e) }
         filter = EDN::Type::List.new(*filter)
       end
-
       query.filters += [[filter]]
       query
     end
 
     def peer_filter(*filter)
       query = self.dup
-
       if filter.first.is_a?(Array)
         filter = filter.first
       end
       filter_attrs << filter[1].to_s
-      filter[1] = "?#{filter[1].to_s}"
-      filter = filter.tap {|e| e.to_s }.join(" ")
-      filter = "[(#{filter})]"
-
-      query.filters << filter
+      query_filter = []
+      query_filter << filter[0].to_s
+      query_filter << "?#{filter[1].to_s}"
+      query_filter << filter[2..-1]
+      query_filter = query_filter.flatten
+      query.filters += [query_filter]
       query
     end
 
@@ -113,9 +112,9 @@ module Diametric
       res = model.q(*data, @conn_or_db)
       collapse_results(res).each do |entity|
         if self.model.instance_variable_get("@peer") && @resolve
-          yield model.from_dbid_or_entity(entity.first.to_java, @conn_or_db, @resolve)
+          yield model.reify(entity.first, @conn_or_db, @resolve)
         elsif self.model.instance_variable_get("@peer")
-          yield entity.first.to_java
+          yield entity
         # The map is for compatibility with Java peer persistence.
         # TODO remove if possible
         else
@@ -127,8 +126,13 @@ module Diametric
     # Return all query results.
     #
     # @return [Array<Entity>] Query results.
-    def all
-      map { |x| x }
+    #         or Set([Array<dbid>]) for Peer without resolve option
+    def all(conn_or_db=@conn_or_db)
+      if self.model.instance_variable_get("@peer") && !@resolve
+        model.q(*data, conn_or_db)
+      else
+        map { |x| x }
+      end
     end
 
     # Create a Datomic query from the conditions and filters passed to this
@@ -177,7 +181,7 @@ EOQ
           clauses = conditions.keys.inject("") do |memo, attribute|
             memo + "[?e " + model.namespace(model.prefix, attribute) + " ?#{attribute} ] "
           end
-          from = conditions.inject("[") {|memo, kv| memo + "?#{kv.shift} "} +"]"
+          from = conditions.inject("") {|memo, kv| memo + "?#{kv.shift} "}
           args = conditions.map { |_, v| v }
         end
 
@@ -186,8 +190,16 @@ EOQ
           clauses = filter_attrs.inject(clauses) do |memo, attribute|
             memo + "[?e " + model.namespace(model.prefix, attribute) + " ?#{attribute} ] "
           end
+          from ||= ""
+          from = filter_attrs.inject(from) {|from, attr| from + "?#{attr}_value "}
+          filter_query =
+            "[" +
+            filters.inject("") {|memo, filter| memo + "(#{filter[0]} #{filter[1]} #{filter[1]}_value) "} +
+            "]"
+          args ||= []
+          args = filters.inject(args) {|args, filter| args + filter[2..-1]}
         end
-        query = "[:find ?e :in $ #{from} :where #{clauses} #{filters.join}]"
+        query = "[:find ?e :in $ [#{from}] :where #{clauses} #{filter_query}]"
       end
 
       [query, args]
@@ -216,7 +228,7 @@ EOQ
     end
 
     def collapse_results(res)
-      return res unless @resolve
+      return res if self.model.instance_variable_get("@peer")
 
       res.group_by(&:first).map do |dbid, results|
         # extract dbid from results

data/lib/diametric/version.rb

@@ -1,3 +1,3 @@
 module Diametric
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/spec/developer_query_spec.rb

@@ -55,7 +55,7 @@ describe Developer, :jruby => true do
     result = query.all
     result.size.should == 1
 
-    developer = Developer.from_dbid_or_entity(result.first, @conn.db, false)
+    developer = Developer.reify(result.first.first, @conn.db, false)
     friends = developer.friends
     friends.each do |f|
       f.should be_a(Java::DatomicQuery::EntityMap)
@@ -77,7 +77,7 @@ describe Developer, :jruby => true do
     query = Diametric::Query.new(Developer, @conn)
     result = query.all
     result.size.should == 3
-    resolved_result = result.map {|m| Developer.from_dbid_or_entity(m, @conn)}
+    resolved_result = result.map {|m| Developer.reify(m.first, @conn)}
     resolved_result.collect(&:nerd_rate).should =~ [50, 98, 80]
   end
 
@@ -94,7 +94,7 @@ describe Developer, :jruby => true do
     ryan.save(@conn)
 
     query = Diametric::Query.new(Developer, @conn).filter(:>, :nerd_rate, 70)
-    query_data = "[:find ?e :in $ :where [?e :developer/nerd_rate ?nerd_rate] [(> ?nerd_rate 70)]]"
+    query_data = "[:find ?e :in $ [?nerd_rate_value] :where [?e :developer/nerd_rate ?nerd_rate] [(> ?nerd_rate ?nerd_rate_value)]]"
     query.data.first.gsub(" ", "").should == query_data.gsub(" ", "")
     result = query.all
     result.size.should == 2

data/spec/diametric/peer_api_spec.rb

@@ -99,7 +99,7 @@ if is_jruby?
 
       it 'should get ids from datomic' do
         results = Diametric::Persistence::Peer.q("[:find ?c :where [?c :person/name]]", @connection.db)
-        results.class.should == Array
+        results.class.should == Diametric::Persistence::Set
         results.size.should be >= 3
         #puts results.inspect
       end
@@ -107,23 +107,21 @@ if is_jruby?
       it 'should get names from datomic' do
         results = Diametric::Persistence::Peer.q("[:find ?c ?name :where [?c :person/name ?name]]\
   ", @connection.db)
-        results.flatten.should include("Alice")
-        results.flatten.should include("Bob")
-        results.flatten.should include("Chris")
-        #puts results.inspect
+        results.collect { |r| r[1] }.should =~ ["Alice", "Bob", "Chris"]
+        results.collect { |r| r if r.include?("Alice") }.compact.size.should == 1
       end
 
       it 'should get entity by id' do
         results = Diametric::Persistence::Peer.q("[:find ?c :where [?c :person/name]]",\
                                                  @connection.db)
-        id = results[0][0]
+        id = results.first.first
         @connection.db.entity(id).should be_true
       end
 
       it 'should get keys from entity id' do
         results = Diametric::Persistence::Peer.q("[:find ?c :where [?c :person/name]]",\
                                                  @connection.db)
-        id = results[0][0]
+        id = results.first.first
         entity = @connection.db.entity(id)
         entity.keys.should include(":person/name")
         #puts entity.keys
@@ -132,13 +130,432 @@ if is_jruby?
       it 'should get value from entity id' do
         results = Diametric::Persistence::Peer.q("[:find ?c :where [?c :person/name]]",\
                                                  @connection.db)
-        id = results[0][0]
+        id = results.first.first
         entity = @connection.db.entity(id)
         value =  entity.get(entity.keys[0])
         value.should match(/Alice|Bob|Chris/)
         #puts value
       end
     end
+
+    context Diametric::Persistence::Collection do
+      before(:all) do
+        vector =  Java::ClojureLang::PersistentVector.create(12, 23, 34, 45, 56, 67)
+        @collection = Diametric::Persistence::Collection.wrap(vector)
+        @seq = Diametric::Persistence::Collection.be_lazy(vector)
+        vector2 =  Java::ClojureLang::PersistentVector.create(12, false, 23, nil, 34, 45, nil, 56, nil, false, 67)
+        @collection2 = Diametric::Persistence::Collection.wrap(vector2)
+        @seq2 = Diametric::Persistence::Collection.be_lazy(vector2)
+        empty_vector =  Java::ClojureLang::PersistentVector.create()
+        @empty_collection = Diametric::Persistence::Collection.wrap(empty_vector)
+        @empty_seq = Diametric::Persistence::Collection.be_lazy(empty_vector)
+      end
+
+      it 'should raise error for & method' do
+        expect { @collection & [100, 200] }.to raise_error(RuntimeError)
+      end
+
+      it 'should raise error for assoc method' do
+        expect { @collection.assoc("something") }.to raise_error(RuntimeError)
+      end
+
+      it 'should repeat elements by * method' do
+        @collection.*(2).should == [12, 23, 34, 45, 56, 67, 12, 23, 34, 45, 56, 67]
+        @collection.*(",").should == "12,23,34,45,56,67"
+      end
+
+      it 'should concat other array' do
+        @collection.+([100, 200]).should == [12, 23, 34, 45, 56, 67, 100, 200]
+      end
+
+      it 'should get difference from other array' do
+        @collection.-([12, 45, 67]).should == [23, 34, 56]
+      end
+
+      it 'should return length' do
+        @collection.length.should == 6
+        @collection.size.should == 6
+        @seq.length.should == 6
+        @seq.size.should == 6
+      end
+
+      it 'should return string expression' do
+        @collection.to_s.should == "[12, 23, 34, 45, 56, 67]"
+        @seq.to_s.should == "[12, 23, 34, 45, 56, 67]"
+      end
+
+      it 'should return object or nil for [index]' do
+        @collection[0].should == 12
+        @collection[4].should == 56
+        @collection[6].should == nil
+        @collection[-3].should == 45
+        @collection[0].should == 12
+        @collection[4].should == 56
+        @collection[6].should == nil
+        @collection[-3].should == 45
+
+        @seq[0].should == 12
+        @seq[4].should == 56
+        @seq[6].should == nil
+        @seq[-3].should == 45
+        @seq[0].should == 12
+        @seq[4].should == 56
+        @seq[6].should == nil
+        @seq[-3].should == 45
+      end
+
+      it 'should return new collection or nil for [start, length]' do
+        @collection[1, 2].should == [23, 34]
+        @collection[7, 1].should == nil
+        @collection[6, 1].should == []
+        @collection[-2, 5].should == [56, 67]
+        @collection[3, -1].should == nil
+
+        @seq[1, 2].should == [23, 34]
+        @seq[7, 1].should == nil
+        @seq[6, 1].should == []
+        @seq[-2, 5].should == [56, 67]
+        @seq[3, -1].should == nil
+      end
+
+      it 'should return new collection or nil for [range]' do
+        @collection[1..3].should == [23, 34, 45]
+        @collection[1...3].should == [23, 34]
+        @collection[5..10].should == [67]
+        @collection[6..10].should == []
+        @collection[7..10].should == nil
+
+        @seq[1..3].should == [23, 34, 45]
+        @seq[1...3].should == [23, 34]
+        @seq[5..10].should == [67]
+        @seq[6..10].should == []
+        @seq[7..10].should == nil
+      end
+
+      it 'should return object or nil at(index)' do
+        @collection.at(4).should == 56
+        @collection.at(-1).should == 67
+
+        @seq.at(4).should == 56
+        @seq.at(-1).should == 67
+      end
+
+      it 'should raise error for bsearch method' do
+        expect { @collection.bsearch {|x| x} }.to raise_error(RuntimeError)
+      end
+
+      it 'should raise error for clear method' do
+        expect { @collection.clear }.to raise_error(RuntimeError)
+      end
+
+      it 'should return new array for collect or map method' do
+        @collection.collect {|x| x > 40 }.should == [false, false, false, true, true, true]
+        @collection.map(&:to_s).should == ["12", "23", "34", "45", "56", "67"]
+
+        @seq.collect {|x| x > 40 }.should == [false, false, false, true, true, true]
+        @seq.map(&:to_s).should == ["12", "23", "34", "45", "56", "67"]
+      end
+
+      it 'should raise error for collect! or map! method' do
+        expect { @collection.collect! {|x| x > 40 } }.to raise_error(RuntimeError)
+        expect { @collection.map!(&:to_s) }.to raise_error(RuntimeError)
+      end
+
+      it 'should strip nil element out from vector but not false for compact method' do
+        @collection2.compact.should == [12, false, 23, 34, 45, 56, false, 67]
+
+        @seq2.compact.should == [12, false, 23, 34, 45, 56, false, 67]
+      end
+
+      it 'should raise error for compact! method' do
+        expect { @collection.compact! }.to raise_error(RuntimeError)
+      end
+
+      it 'should raise error for concat method' do
+        expect { @collection.concat([100, 200]) }.to raise_error(RuntimeError)
+      end
+
+      it 'should count speicfied object for count method' do
+        @collection.count.should == 6
+        @collection2.count(false).should == 2
+        @collection2.count(100).should == 0
+        @collection2.count(67).should == 1
+        @collection2.count(nil).should == 3
+
+        @seq.count.should == 6
+        @seq2.count(false).should == 2
+        @seq2.count(100).should == 0
+        @seq2.count(67).should == 1
+        @seq2.count(nil).should == 3
+      end
+
+      it 'should raise error for cycle method' do
+        expect { @collection.cycle { |x| x } }.to raise_error(RuntimeError)
+        expect { @collection.cycle(2) { |x| x } }.to raise_error(RuntimeError)
+      end
+
+      it 'should raise error for delete method' do
+        expect { @collection.delete(12) }.to raise_error(RuntimeError)
+        expect { @collection.delete(100) { "not found" } }.to raise_error(RuntimeError)
+      end
+
+      it 'should raise error for delete_at and slice! method' do
+        expect { @collection.delete_at(2) }.to raise_error(RuntimeError)
+        expect { @collection.slice!(2) }.to raise_error(RuntimeError)
+        expect { @collection.slice!(2, 2) }.to raise_error(RuntimeError)
+        expect { @collection.slice!(2, 2) }.to raise_error(RuntimeError)
+        expect { @collection.slice!(0...2) }.to raise_error(RuntimeError)
+      end
+
+      it 'should raise error for delete_if and reject! method' do
+        expect { @collection.delete_if {|x| x > 30} }.to raise_error(RuntimeError)
+        expect { @collection.reject! {|x| x < 30} }.to raise_error(RuntimeError)
+      end
+
+      it 'should drop or take elements' do
+        @collection.drop(2).should == [34, 45, 56, 67]
+        @collection.take(3).should == [45, 56, 67]
+
+        @seq.drop(2).should == [34, 45, 56, 67]
+        @seq.take(3).should == [45, 56, 67]
+      end
+
+      it 'should drop or take elements while block returns true' do
+        @collection.drop_while {|x| x < 30}.should == [34, 45, 56, 67]
+        @collection2.take_while {|x| x != nil}.should == [nil, 34, 45, nil, 56, nil, false, 67]
+
+        @seq.drop_while {|x| x < 30}.should == [34, 45, 56, 67]
+        @seq2.take_while {|x| x != nil}.should == [nil, 34, 45, nil, 56, nil, false, 67]
+      end
+
+      it 'should iterate elements' do
+        result = []
+        @collection.each {|e| result << e.to_s}
+        result.should == ["12", "23", "34", "45", "56", "67"]
+
+        result = []
+        @collection.each_index {|e| result << e.to_s}
+        result.should == ["0", "1", "2", "3", "4", "5"]
+
+        result = []
+        @seq.each {|e| result << e.to_s}
+        result.should == ["12", "23", "34", "45", "56", "67"]
+
+        result = []
+        @seq.each_index {|e| result << e.to_s}
+        result.should == ["0", "1", "2", "3", "4", "5"]
+      end
+
+      it 'should return true or false for empty test' do
+        @collection.empty?.should == false
+        @empty_collection.empty?.should == true
+
+        @seq.empty?.should == false
+        @empty_seq.empty?.should == true
+      end
+
+      it 'should return true or false for eql? test' do
+        @collection.eql?([12, 23, 34, 45, 56, 67]).should be_true
+        @collection.eql?(@collection2).should be_false
+
+        @seq.eql?([12, 23, 34, 45, 56, 67]).should be_true
+        @seq.eql?(@seq2).should be_false
+      end
+
+      it 'should fetch a value or raise IndexError/default/block value' do
+        @collection.fetch(1).should == 23
+        @collection.fetch(-1).should == 67
+        @collection.fetch(100, "have a nice day").should == "have a nice day"
+        message = ""
+        @collection.fetch(-100) {|i| message = "#{i} is out of bounds"}
+        message.should == "-100 is out of bounds"
+
+        @seq.fetch(1).should == 23
+        @seq.fetch(-1).should == 67
+        @seq.fetch(100, "have a nice day").should == "have a nice day"
+        message = ""
+        @seq.fetch(-100) {|i| message = "#{i} is out of bounds"}
+        message.should == "-100 is out of bounds"
+      end
+
+      it 'should raise error for fill method' do
+        expect { @collection.fill("x") }.to raise_error(RuntimeError)
+        expect { @collection.fill("z", 2, 2) }.to raise_error(RuntimeError)
+        expect { @collection.fill("y", 0..1) }.to raise_error(RuntimeError)
+        expect { @collection.fill {|i| i*i} }.to raise_error(RuntimeError)
+        expect { @collection.fill(-2) {|i| i*i} }.to raise_error(RuntimeError)
+      end
+
+      it 'should return index of the first matched object' do
+        @collection.find_index(34).should == 2
+        @collection2.find_index(nil).should == 3
+        @collection.find_index(100).should == nil
+        @collection.find_index { |x| x % 7 == 0 }.should == 4
+        @collection.find_index { |x| x < 0 }.should == nil
+        @collection.index(45).should == 3
+        @collection2.index(false).should == 1
+        @collection2.index(true).should == nil
+        @collection.index { |x| x.odd? }.should == 1
+        @collection.index { |x| x > 100 }.should == nil
+
+        @seq.find_index(34).should == 2
+        @seq2.find_index(nil).should == 3
+        @seq.find_index(100).should == nil
+        @seq.find_index { |x| x % 7 == 0 }.should == 4
+        @seq.find_index { |x| x < 0 }.should == nil
+        @seq.index(45).should == 3
+        @seq2.index(false).should == 1
+        @seq2.index(true).should == nil
+        @seq.index { |x| x.odd? }.should == 1
+        @seq.index { |x| x > 100 }.should == nil
+      end
+
+      it 'should return first element or first n elements' do
+        @collection.first.should == 12
+        @collection.first(3).should == [12, 23, 34]
+        @collection.first(100).should == [12, 23, 34, 45, 56, 67]
+
+        @seq.first.should == 12
+        @seq.first(3).should == [12, 23, 34]
+        @seq.first(100).should == [12, 23, 34, 45, 56, 67]
+      end
+
+      it 'should raise error for flatten/flatten! methods' do
+        expect { @collection.flatten }.to raise_error(RuntimeError)
+        expect { @collection.flatten(2) }.to raise_error(RuntimeError)
+        expect { @collection.flatten! }.to raise_error(RuntimeError)
+        expect { @collection.flatten(100) }.to raise_error(RuntimeError)
+      end
+
+      it 'should return true from frozen? method' do
+        @collection.frozen?.should == true
+
+        @seq.frozen?.should == true
+      end
+
+      it 'should return truethiness for include? method' do
+        @collection.include?(56).should be_true
+        @collection2.include?(nil).should be_true
+        @collection2.include?(false).should be_true
+        @collection.include?("a").should be_false
+
+        @seq.include?(56).should be_true
+        @seq2.include?(nil).should be_true
+        @seq2.include?(false).should be_true
+        @seq.include?("a").should be_false
+      end
+
+      it 'should raise error for replace method' do
+        expect { @collection.replace(["x", "y", "z"]) }.to raise_error(RuntimeError)
+      end
+
+      it 'should raise error for insert method' do
+        expect { @collection.insert(2, 99) }.to raise_error(RuntimeError)
+        expect { @collection.insert(-2, 1, 2, 3) }.to raise_error(RuntimeError)
+      end
+
+      it 'should return string representation' do
+        @collection.inspect.should == "[12, 23, 34, 45, 56, 67]"
+
+        @seq.inspect.should == "[12, 23, 34, 45, 56, 67]"
+      end
+
+      it 'should return joined string' do
+        @collection.join.should == "122334455667"
+        @collection.join(", ").should == "12, 23, 34, 45, 56, 67"
+
+        @seq.join.should == "122334455667"
+        @seq.join(", ").should == "12, 23, 34, 45, 56, 67"
+      end
+
+      it 'should raise error for keep_if and select! methods' do
+        expect { @collection.keep_if {|v| v == 0} }.to raise_error(RuntimeError)
+        expect { @collection.keep_if }.to raise_error(RuntimeError)
+        expect { @collection.select! {|v| v == 0} }.to raise_error(RuntimeError)
+        expect { @collection.select! }.to raise_error(RuntimeError)
+      end
+
+      it 'should return last elements' do
+        @collection.last.should == 67
+        @collection.last(2).should == [56, 67]
+
+        @seq.last.should == 67
+        @seq.last(2).should == [56, 67]
+      end
+    end
+
+    context Diametric::Persistence::Set do
+      before(:each) do
+        java_set = java.util.HashSet.new([0, 1, 2, 3, 4, 5, 6])
+        @set = Diametric::Persistence::Set.wrap(java_set)
+        java_set2 = java.util.HashSet.new([0, 11, 2, 3, 44, 5, 66])
+        @set2 = Diametric::Persistence::Set.wrap(java_set)
+      end
+
+      it 'should return intersection'  do
+        @set.&(Set.new([3, 6, 9])).should == [3, 6].to_set
+        @set.intersection(Set.new([0, 4, 8])).should == [0, 4].to_set
+      end
+
+      it 'should return union' do
+        @set.|(Set.new([3, 6, 9])).should == [0, 1, 2, 3, 4, 5, 6, 9].to_set
+        @set.union(Set.new([0, 4, 8])).should == [0, 1, 2, 3, 4, 5, 6, 8].to_set
+      end
+
+      it 'should return length' do
+        @set.length.should == 7
+        @set.size.should == 7
+      end
+
+      it 'should return false for empty test' do
+        @set.empty?.should == false
+      end
+
+      it 'should test inclusion' do
+        @set.include?(3).should == true
+        @set.include?(-1).should == false
+      end
+
+      it 'should return first element' do
+        [0, 1, 2, 3, 4, 5, 6].should include(@set.first)
+      end
+
+      it 'should iterate elements' do
+        @set.each do |e|
+          [0, 1, 2, 3, 4, 5, 6].should include(e)
+        end
+      end
+
+      it 'should return collected array' do
+        ret = @set.collect { |i| i * i }
+        ret.should =~ [0, 1, 4, 9, 16, 25, 36]
+      end
+
+      it 'should group the element' do
+        ret = @set.group_by { |i| i % 3 }
+        ret[0].should =~ [0, 3, 6]
+        ret[1].should =~ [1, 4]
+        ret[2].should =~ [2, 5]
+      end
+
+      it 'should group by the length' do
+        s = java.util.HashSet.new(["Homer", "Marge", "Bart", "Lisa", "Abraham", "Herb"])
+        set_of_words = Diametric::Persistence::Set.wrap(s)
+        ret = set_of_words.group_by {|w| w.length }
+        ret[4].should =~ ["Bart", "Lisa", "Herb"]
+        ret[5].should =~ ["Homer", "Marge"]
+        ret[7].should =~ ["Abraham"]
+      end
+
+      it 'should group each array by the first element' do
+        s = java.util.HashSet.new([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        set_of_ary = Diametric::Persistence::Set.wrap(s)
+        ret = set_of_ary.group_by(&:first)
+        ret[1].should == [[1, 2, 3]]
+        ret[4].should == [[4, 5, 6]]
+        ret[7].should == [[7, 8, 9]]
+      end
+    end
   end
 end