javaclass 0.0.3 → 0.0.4

data/test/test_java_name.rb

@@ -2,107 +2,247 @@ require File.dirname(__FILE__) + '/setup'
 require 'javaclass/java_name'
 
 class TestString < Test::Unit::TestCase
+
   def test_to_javaname
-    assert_equal(JavaClass::JavaName, 'at/kugel/tool/Some.class'.to_javaname.class)
+    assert_equal(JavaClass::JavaClassFileName, 'at/kugel/tool/Some.class'.to_javaname.class)
     assert_equal('Some', 'Some'.to_javaname)
     assert_equal('at/kugel/tool/Some.class', 'at/kugel/tool/Some.class'.to_javaname)
-    assert_equal("at\\kugel\\tool\\Some.java", "at\\kugel\\tool\\Some.java".to_javaname)
+    assert_equal("at/kugel/tool/Some", "at\\kugel\\tool\\Some.java".to_javaname)
     assert_equal('at.kugel.tool.Some', 'at.kugel.tool.Some'.to_javaname)
+    assert_raise(ArgumentError) { 'abc/xyz.123'.to_javaname }
   end
 
 end
 
 module TestJavaClass
-  class TestJavaName < Test::Unit::TestCase
+
+  class TestPackageLogic < Test::Unit::TestCase
+    include JavaClass::PackageLogic
+
     def setup
-      @c0 = JavaClass::JavaName.new('Some')
-      @cn = JavaClass::JavaName.new("at\\kugel\\tool\\Some.java")
-      @cm = JavaClass::JavaName.new('at/kugel/tool/SomeClassWithMoreNames')
-      @cs = JavaClass::JavaName.new('at/kugel/tool/Some.<init>')
+      @package = 'at.kugel.tool.'
+    end
+        
+    def test_same_or_subpackage_of_eh
+      assert(same_or_subpackage_of?(%w[ at.kugel ]))
+      assert(same_or_subpackage_of?(%w[ at.kugel.tool ]))
+      assert(!same_or_subpackage_of?(%w[ at.kugel.tool.some ]))
+      assert(same_or_subpackage_of?(%w[ java at.kugel ]))
+
+      @package = ''
+      assert(!same_or_subpackage_of?(%w[ at at.kugel ]))
     end
 
-    def test_to_classname
-      assert_equal('Some', @c0.to_classname)
-      assert_equal('at.kugel.tool.Some', @cn.to_classname)
-      assert_equal('at.kugel.tool.SomeClassWithMoreNames', @cm.to_classname)
-      assert_equal('at.kugel.tool.Some', @cs.to_classname)
+    def test_subpackage_of_eh
+      assert(subpackage_of?(%w[ at.kugel ]))
+      assert(subpackage_of?(%w[ at.kugel.tool ]))
+      assert(!subpackage_of?(%w[ at.kugel.tool.class ]))
+    end
+
+    def test_in_jdk_eh
+      assert(!in_jdk?)
+
+      @package = 'java.lang'
+      assert(in_jdk?)
+
+      @package = '' # default
+      assert(!in_jdk?)
+    end
+        
+  end
+  
+  class TestSimpleNameLogic < Test::Unit::TestCase
+    include JavaClass::SimpleNameLogic
+
+    def setup
+      @simple_name = 'SomeClassWithMoreNames'
+    end
+
+    def test_split_simple_name
+      assert_equal(['', 'SomeClassWithMoreNames'], split_simple_name(0))
+      assert_equal(['Some', 'ClassWithMoreNames'], split_simple_name(1))
+      assert_equal(['SomeClass', 'WithMoreNames'], split_simple_name(2))
+      assert_equal(['SomeClassWith', 'MoreNames'], split_simple_name(3))
+      assert_equal(['SomeClassWithMore', 'Names'], split_simple_name(4))
+      assert_equal(['SomeClassWithMoreNames', ''], split_simple_name(5))
+      assert_equal(['SomeClassWithMoreNames', ''], split_simple_name(6))
+
+      assert_equal(['SomeClassWithMoreNames', ''], split_simple_name(-1))
+      assert_equal(['SomeClassWithMore', 'Names'], split_simple_name(-2))
+      assert_equal(['SomeClassWith', 'MoreNames'], split_simple_name(-3))
+      assert_equal(['SomeClass', 'WithMoreNames'], split_simple_name(-4))
+      assert_equal(['Some', 'ClassWithMoreNames'], split_simple_name(-5))
+      assert_equal(['', 'SomeClassWithMoreNames'], split_simple_name(-6))
+      assert_equal(['', 'SomeClassWithMoreNames'], split_simple_name(-7))
+    end
+  
+  end
+  
+  class TestJavaQualifiedName < Test::Unit::TestCase
+
+    def setup
+      @simple_name = JavaClass::JavaQualifiedName.new('Some')
+      @qualified_name = JavaClass::JavaQualifiedName.new('at.kugel.tool.Some')
+      @frozen_name = JavaClass::JavaQualifiedName.new('at.kugel.tool.Some')
+      @frozen_name.freeze
+    end
+
+    def test_class_new_invalid
+      assert_raise(ArgumentError) { JavaClass::JavaQualifiedName.new('at.kugel.tool/Some') }
+      assert_raise(ArgumentError) { JavaClass::JavaQualifiedName.new('at.kugel.tool.') }
+    end
+
+    def test_class_new_caches
+      cn = JavaClass::JavaQualifiedName.new('at.kugel.tool.Some', 1, 2 )
+      assert_equal(1, cn.to_jvmname)
+      assert_equal(2, cn.to_class_file)
+    end
+    
+    def test_package
+      assert_equal('', @simple_name.package)
+      assert_equal('at.kugel.tool', @qualified_name.package)
+    end
+
+    def test_simple_name
+      assert_equal('Some', @simple_name.simple_name)
+      assert_equal('Some', @qualified_name.simple_name)
+    end
+
+    def test_full_name
+      assert_equal('Some', @simple_name.full_name)
+      assert_equal('at.kugel.tool.Some', @qualified_name.full_name)
     end
 
     def test_to_javaname
-      assert(@cn == @cn.to_javaname)
-      assert(@cn === @cn.to_javaname)
+      assert_same(@qualified_name, @qualified_name.to_javaname)
+    end
+
+    def test_to_classname
+      assert_same(@qualified_name, @qualified_name.to_classname)
+    end
+
+    def test_to_jvmname
+      assert_equal('at/kugel/tool/Some', @qualified_name.to_jvmname)
+      assert_same(@qualified_name.to_jvmname, @qualified_name.to_jvmname) # is saved
+
+      assert_equal('at/kugel/tool/Some', @frozen_name.to_jvmname)
+      assert_not_same(@frozen_name.to_jvmname, @frozen_name.to_jvmname) # is not saved
+    end
+  
+    def test_to_java_file
+      assert_equal('at/kugel/tool/Some.java', @qualified_name.to_java_file)
+    end
+
+    def test_to_class_file
+      assert_equal('at/kugel/tool/Some.class', @qualified_name.to_class_file)
+      assert_same(@qualified_name.to_class_file, @qualified_name.to_class_file) # is saved
+
+      assert_equal('at/kugel/tool/Some.class', @frozen_name.to_class_file)
+      assert_not_same(@frozen_name.to_class_file, @frozen_name.to_class_file) # is not saved
+    end
+    
+    def test_hash_keys_needs_freeze
+      map = Hash.new # x (JavaQualifiedName) => anything
+      map[@qualified_name.freeze] = :anything
+      qn = map.keys[0]
+      assert_same(JavaClass::JavaQualifiedName, qn.class)
+      assert_equal('Some', qn.simple_name)
+    end
+    
+  end
+
+  class TestJavaVMName < Test::Unit::TestCase
+
+    def setup
+      @jvm_path = JavaClass::JavaVMName.new('at/kugel/tool/SomeClassWithMoreNames')
+      #@jvm_method_name = JavaClass::JavaName.new('at/kugel/tool/Some.<init>')
+      @jvm_array_name = JavaClass::JavaVMName.new('[Ljava/lang/String;')
+      @jvm_atom_name = JavaClass::JavaVMName.new('[[[B')
+      @frozen_path = JavaClass::JavaVMName.new('at/kugel/tool/SomeClassWithMoreNames')
+      @frozen_path.freeze
+    end
+
+    def test_to_classname
+      assert_equal('at.kugel.tool.SomeClassWithMoreNames', @jvm_path.to_classname)
+      #assert_equal('at.kugel.tool.Some', @jvm_method_name.to_classname)
+      assert_equal('java.lang.String', @jvm_array_name.to_classname)
+      assert_equal('java.lang.Byte', @jvm_atom_name.to_classname)
+      assert_equal('at.kugel.tool.SomeClassWithMoreNames', @frozen_path.to_classname)
     end
 
     def test_to_jvmname
-      assert_equal('Some', @c0.to_jvmname)
-      assert_equal('at/kugel/tool/Some', @cn.to_jvmname)
-      assert_equal('at/kugel/tool/SomeClassWithMoreNames', @cm.to_jvmname)
+      assert_equal('at/kugel/tool/SomeClassWithMoreNames', @jvm_path.to_jvmname)
+      #assert_equal('at/kugel/tool/Some', @jvm_method_name.to_jvmname)
+      assert_same(@jvm_path.to_jvmname, @jvm_path.to_jvmname)
     end
 
     def test_to_java_file
-      assert_equal('Some.java', @c0.to_java_file)
-      assert_equal('at/kugel/tool/Some.java', @cn.to_java_file)
-      assert_equal('at/kugel/tool/SomeClassWithMoreNames.java', @cm.to_java_file)
+      assert_equal('at/kugel/tool/SomeClassWithMoreNames.java', @jvm_path.to_java_file)
+      #assert_equal('at/kugel/tool/Some.java', @jvm_method_name.to_java_file)
     end
 
     def test_to_class_file
-      assert_equal('Some.class', @c0.to_class_file)
-      assert_equal('at/kugel/tool/Some.class', @cn.to_class_file)
-      assert_equal('at/kugel/tool/SomeClassWithMoreNames.class', @cm.to_class_file)
+      assert_equal('at/kugel/tool/SomeClassWithMoreNames.class', @jvm_path.to_class_file)
+      #assert_equal('at/kugel/tool/Some.class', @jvm_method_name.to_class_file)
+      assert_equal('at/kugel/tool/SomeClassWithMoreNames.class', @frozen_path.to_class_file)
     end
 
     def test_full_name
-      assert_equal('Some', @c0.full_name)
-      assert_equal('at.kugel.tool.Some', @cn.full_name)
-      assert_equal('at.kugel.tool.SomeClassWithMoreNames', @cm.full_name)
+      assert_equal('at.kugel.tool.SomeClassWithMoreNames', @jvm_path.full_name)
+      #assert_equal('at.kugel.tool.Some', @jvm_method_name.full_name)
     end
-        
-    def test_package
-      assert_equal('', @c0.package)
-      assert_equal('at.kugel.tool', @cn.package)
-      assert_equal('at.kugel.tool', @cm.package)
+    
+    def test_array_eh
+      assert(!@jvm_path.array?)
+      assert_equal(1, @jvm_array_name.array?)
+      assert_equal(3, @jvm_atom_name.array?)
     end
+    
+  end
+  
+  class TestJavaClassFile < Test::Unit::TestCase
 
-    def test_simple_name
-      assert_equal('Some', @c0.simple_name)
-      assert_equal('Some', @cn.simple_name)
-      assert_equal('SomeClassWithMoreNames', @cm.simple_name)
-      
-      # simple name is a classname itself
-      assert_equal('Some.class', @cn.simple_name.to_class_file)
+    def setup
+      @win_file = JavaClass::JavaClassFileName.new("at\\kugel\\tool\\Some.class")
+      @class_file = JavaClass::JavaClassFileName.new('at/kugel/tool/Some.class')
+      @jdk_class_file = JavaClass::JavaClassFileName.new('java/lang/String.class')
+      @frozen_file = JavaClass::JavaClassFileName.new('at/kugel/tool/Some.class')
+      @frozen_file.freeze
     end
 
-    def test_same_or_subpackage_of_eh
-      assert(@cn.same_or_subpackage_of?(%w[ at.kugel ]))
-      assert(@cn.same_or_subpackage_of?(%w[ at.kugel.tool ]))
-      assert(!@cn.same_or_subpackage_of?(%w[ at.kugel.tool.some ]))
-      assert(@cn.same_or_subpackage_of?(%w[ java at.kugel ]))
+    def test_to_classname
+      assert_equal('at.kugel.tool.Some', @win_file.to_classname)
+      assert_equal('at.kugel.tool', @win_file.to_classname.package)
+      assert_equal('at.kugel.tool.Some', @class_file.to_classname)
+      assert_equal('java.lang.String', @jdk_class_file.to_classname)
+      assert_equal('at.kugel.tool.Some', @frozen_file.to_classname)
+    end
 
-      assert(!@c0.same_or_subpackage_of?(%w[ at at.kugel ]))
+    def test_to_javaname
+      assert(@class_file == @class_file.to_javaname)
+      assert(@class_file === @class_file.to_javaname)
     end
 
-    def test_subpackage_of_eh
-      assert(@cn.subpackage_of?(%w[ at.kugel ]))
-      assert(!@cn.subpackage_of?(%w[ at.kugel.tool ]))
-      assert(!@cn.subpackage_of?(%w[ at.kugel.tool.some ]))
+    def test_to_jvmname
+      assert_equal('at/kugel/tool/Some', @win_file.to_jvmname)
+      assert_equal('at/kugel/tool/Some', @class_file.to_jvmname)
+      assert_equal('at/kugel/tool/Some', @frozen_file.to_jvmname)
     end
 
-    def test_split_simple_name
-      assert_equal(['', 'SomeClassWithMoreNames'], @cm.split_simple_name(0))
-      assert_equal(['Some', 'ClassWithMoreNames'], @cm.split_simple_name(1))
-      assert_equal(['SomeClass', 'WithMoreNames'], @cm.split_simple_name(2))
-      assert_equal(['SomeClassWith', 'MoreNames'], @cm.split_simple_name(3))
-      assert_equal(['SomeClassWithMore', 'Names'], @cm.split_simple_name(4))
-      assert_equal(['SomeClassWithMoreNames', ''], @cm.split_simple_name(5))
-      assert_equal(['SomeClassWithMoreNames', ''], @cm.split_simple_name(6))
-
-      assert_equal(['SomeClassWithMoreNames', ''], @cm.split_simple_name(-1))
-      assert_equal(['SomeClassWithMore', 'Names'], @cm.split_simple_name(-2))
-      assert_equal(['SomeClassWith', 'MoreNames'], @cm.split_simple_name(-3))
-      assert_equal(['SomeClass', 'WithMoreNames'], @cm.split_simple_name(-4))
-      assert_equal(['Some', 'ClassWithMoreNames'], @cm.split_simple_name(-5))
-      assert_equal(['', 'SomeClassWithMoreNames'], @cm.split_simple_name(-6))
-      assert_equal(['', 'SomeClassWithMoreNames'], @cm.split_simple_name(-7))
+    def test_to_java_file
+      assert_equal('at/kugel/tool/Some.java', @win_file.to_java_file)
+      assert_equal('at/kugel/tool/Some.java', @class_file.to_java_file)
+    end
+
+    def test_to_class_file
+      assert_equal('at\\kugel\\tool\\Some.class', @win_file.to_class_file)
+      assert_equal('at/kugel/tool/Some.class', @class_file.to_class_file)
+      assert_equal('at/kugel/tool/Some.class', @frozen_file.to_class_file)
+    end
+
+    def test_full_name
+      assert_equal('at.kugel.tool.Some', @win_file.full_name)
+      assert_equal('at.kugel.tool.Some', @class_file.full_name)
     end
 
   end

data/test/test_java_name_factory.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/dsl/java_name_factory'
+
+module TestJavaClass
+  module TestDsl
+
+    class TestJavaNameFactory < Test::Unit::TestCase
+
+      include JavaClass::Dsl::JavaNameFactory
+
+      def test_java_class
+        assert_equal('java.lang.String', java.lang.String)
+      end
+      
+      def test_java_package
+        assert_equal('java.lang', java.lang.*)
+      end
+
+      def test_java_result_is_javaname
+        assert_equal('java.lang.String', java.lang.String.full_name)
+        assert_equal('java.lang', java.lang.*.package)
+      end
+      
+      def test_java_reserved_word
+        assert_raise(NoMethodError) { java.long.Class }
+      end
+
+      def test_javax
+        assert_equal('javax.xml.Document', javax.xml.Document)
+      end
+
+      def test_method_missing
+        assert_equal('org.codecop.kata.PrimeFactors', org.codecop.kata.PrimeFactors)
+      end
+
+      def test_method_missing_no_java_identifier_character
+        assert_raise(NoMethodError) { java.lang.Signal! }
+        assert_raise(NoMethodError) { com.sun.Signal! }
+      end
+
+      def test_method_missing_no_country_iso_code
+        assert_raise(NameError) { xx.cmp.Signal }
+      end
+
+      def test_method_missing_no_valid_subpackage
+        assert_raise(NoMethodError) { org.somePackage.Signal }
+      end
+      
+    end
+
+  end
+end

data/test/test_java_name_scanner.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/java_name_scanner'
+
+module TestJavaClass
+  
+  class TestJavaNameScanner < Test::Unit::TestCase
+    include JavaClass::JavaNameScanner
+    
+    def test_scan_text_for_class_names
+      assert_equal([], scan_text_for_class_names(''))
+      assert_equal(['java.lang.String'], scan_text_for_class_names('java.lang.String'))
+      assert_equal(['java.lang.String'], scan_text_for_class_names("Bundle-Version: 1.0.0.qualifier\nBundle-Activator: java.lang.String\nBundle-ActivationPolicy: lazy"))
+      assert_equal(['java.lang.String'], scan_text_for_class_names("   <extension\n      point=\"java.lang.String\">\n   </extension>"))
+    end
+
+    def test_scan_config_for_class_names
+      result = scan_config_for_class_names("#{TEST_DATA_PATH}/java_name_scanner")
+      assert_equal(2, result.size)
+      assert_equal('some.PrivilegeCheck', result[0])
+      assert_equal('some.plugin.Activator', result[1])
+    end
+  end
+
+end

data/test/test_javaclass_api.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass'
+
+module TestJavaClass
+
+  # Test the public API usage.
+  class TestJavaClassAPI < Test::Unit::TestCase # ZenTest SKIP
+
+    # See http://api.javaclass-rb.googlecode.com/hg/0.0.2/index.html
+    def test_usage_002
+      clazz = JavaClass.parse("#{TEST_DATA_PATH}/api/packagename/AccessFlagsTestPublic.class")
+      assert_not_nil(clazz)
+      assert_equal('50.0', clazz.version.to_s)
+      assert_equal('packagename/AccessFlagsTestPublic', clazz.constant_pool.items[1].to_s)
+      assert(clazz.access_flags.public?)
+      assert_equal('packagename/AccessFlagsTestPublic', clazz.this_class.to_s)
+      assert_equal('java/lang/Object', clazz.super_class.to_s)
+      assert_equal('java/lang/Object.<init>:()V', clazz.references.referenced_methods[0].to_s)
+    end
+
+    # See http://api.javaclass-rb.googlecode.com/hg/0.0.3/index.html
+    def test_usage_003
+      clazz = JavaClass.load_fs("#{TEST_DATA_PATH}/api/packagename/AccessFlagsTestPublic.class")
+      assert_not_nil(clazz)
+
+      classpath = JavaClass.classpath("#{TEST_DATA_PATH}/api")
+      clazz = JavaClass.load_cp('packagename/AccessFlagsTestPublic', classpath)
+      assert_not_nil(clazz)
+
+      assert_equal(50, clazz.version.major)
+      assert_equal(0, clazz.version.minor)
+      assert_equal('packagename/AccessFlagsTestPublic', clazz.constant_pool.items[1].to_s)
+      assert(clazz.access_flags.public?)
+      assert_equal('packagename/AccessFlagsTestPublic', clazz.this_class.to_s)
+      assert_equal('packagename/AccessFlagsTestPublic.java', clazz.this_class.to_java_file)
+      assert_equal('java/lang/Object', clazz.super_class.to_s)
+      assert_equal('java.lang.Object', clazz.super_class.to_classname)
+      assert_equal('java/lang/Object.<init>:()V', clazz.references.referenced_methods[0].to_s)
+    end
+
+  end
+
+end

data/test/test_list.rb

@@ -3,120 +3,134 @@ require 'javaclass/classlist/list'
 
 module TestJavaClass
   module TestClassList
-    
+
     class TestList < Test::Unit::TestCase
-      
+
       PACKAGE_CLASS = 'packagename/PackageClass.class'
       PUBLIC_CLASS = 'packagename/PublicClass.class'
       PUBLIC_INTERFACE = 'packagename/PublicInterface.class'
-      
+
       def setup
         @list = JavaClass::ClassList::List.new
       end
-      
+
       def test_add_class
         # fake methods for zentest, tested in all other tests
         assert(true)
       end
-      
+
       def test_packages
         @list.add_class(PACKAGE_CLASS, false, 0)
-        @list.add_class(PUBLIC_CLASS, true, 0)
-        
-        @list.add_class(PUBLIC_CLASS, true, 1)
-        @list.add_class(PUBLIC_INTERFACE, true, 1)
-        
+        @list.add_class(PUBLIC_CLASS, :public, 0)
+
+        @list.add_class(PUBLIC_CLASS, :public, 1)
+        @list.add_class(PUBLIC_INTERFACE, :public, 1)
+
         packages = @list.packages
         assert_equal(1, packages.size)
         assert_equal('packagename', packages[0].name)
         assert_equal([0,1], packages[0].version)
       end
-      
+
       def test_old_access_list
         @list.add_class(PACKAGE_CLASS, false, 0)
-        @list.add_class(PUBLIC_CLASS, true, 0)
+        @list.add_class(PUBLIC_CLASS, :public, 0)
         assert_equal(["packagename.PackageClass [p] - \n"], @list.old_access_list)
-        
+
         @list.add_class(PACKAGE_CLASS, false, 1)
-        @list.add_class(PUBLIC_CLASS, true, 1)
+        @list.add_class(PUBLIC_CLASS, :public, 1)
         @list.add_class(PUBLIC_INTERFACE, false, 1)
         assert_equal(["packagename.PublicInterface [1p] - \n"], @list.old_access_list)
       end
-      
+
       def test_plain_class_list
         @list.add_class(PACKAGE_CLASS, false, 0)
-        @list.add_class(PUBLIC_CLASS, true, 1)
+        @list.add_class(PUBLIC_CLASS, :public, 1)
         assert_equal(["packagename.PackageClass\n", "packagename.PublicClass\n"], @list.plain_class_list)
       end
-      
+
       def test_plain_class_list_block_given
         @list.add_class(PACKAGE_CLASS, false, 0)
-        @list.add_class(PUBLIC_CLASS, true, 1)
+        @list.add_class(PUBLIC_CLASS, :public, 1)
         assert_equal(["packagename.PublicClass\n"], @list.plain_class_list { |c| c.public? })
       end
-      
+
       def test_full_class_list
         @list.add_class(PACKAGE_CLASS, false, 0)
-        @list.add_class(PUBLIC_CLASS, true, 0)
-        
+        @list.add_class(PUBLIC_CLASS, :public, 0)
+
         @list.add_class(PACKAGE_CLASS, false, 1)
-        @list.add_class(PUBLIC_CLASS, true, 1)
-        @list.add_class(PUBLIC_INTERFACE, true, 1)
-        
+        @list.add_class(PUBLIC_CLASS, :public, 1)
+        @list.add_class(PUBLIC_INTERFACE, :public, 1)
+
         @list.add_class(PACKAGE_CLASS, false, 2)
-        @list.add_class(PUBLIC_INTERFACE, true, 2)
-        
+        @list.add_class(PUBLIC_INTERFACE, :public, 2)
+
         expected = [
-          "packagename.PackageClass [p] - \n", 
+          "packagename.PackageClass [p] - \n",
           "packagename.PublicClass [-1] - \n",
           "packagename.PublicInterface [1] - \n"
         ]
         result = @list.full_class_list
         assert_equal(expected, result)
       end
-      
+
       def test_parse_line
         expected = [
-          "packagename.PackageClass [p] - \n", 
+          "packagename.PackageClass [p] - \n",
           "packagename.PublicClass [-1] - \n",
           "packagename.PublicInterface [1] - \n"
         ]
-        
+
         expected.each {|line| @list.parse_line(line, 2) }
         result = @list.full_class_list
         assert_equal(expected, result)
       end
-      
-      def test_version 
+
+      def test_version_normal
         @list.parse_line("javax.swing.HeaderParser [1] - \n", 1)
+        assert_equal([1], @list.version)
+      end
+
+      def test_version_only
         @list.parse_line("javax.swing.HeaderParser [only 2] - \n", 3)
-        assert_equal([1,2], @list.version)
+        assert_equal([2], @list.version)
       end
-      
+
+      def test_version_range
+        @list.parse_line("javax.swing.HeaderParser [3-4] - \n", 0)
+        assert_equal([3,4], @list.version)
+      end
+
       def test_first_last_versions
-        @list.add_class(PUBLIC_CLASS, true, 0)
-        @list.add_class(PUBLIC_CLASS, true, 1)
-        @list.add_class(PUBLIC_INTERFACE, true, 2)
+        @list.add_class(PUBLIC_CLASS, :public, 0)
+        @list.add_class(PUBLIC_CLASS, :public, 1)
+        @list.add_class(PUBLIC_INTERFACE, :public, 2)
         assert_equal([0,2], @list.first_last_versions)
       end
-      
+
       def test_size
-        @list.add_class(PUBLIC_CLASS, true, 0)
+        @list.add_class(PUBLIC_CLASS, :public, 0)
         assert_equal(1, @list.size)
-        @list.add_class(PUBLIC_CLASS, true, 1)
+        @list.add_class(PUBLIC_CLASS, :public, 1)
         assert_equal(1, @list.size)
-        
-        @list.add_class(PUBLIC_INTERFACE, true, 2)
+
+        @list.add_class(PUBLIC_INTERFACE, :public, 2)
         assert_equal(2, @list.size)
       end
-      
+
       def test_version_throws
         @list.parse_line("javax.swing.HeaderParser [1] - \n", 4)
-        assert_raise(RuntimeError) do 
+        assert_raise(RuntimeError) do
           @list.parse_line("javax.swing.HeaderParser [only 2p] - \n", 4)
           # occurs because 1-4 is already set in versions, so we cant set 2 again
         end
       end
+
+      def test_to_s
+        @list.add_class(PACKAGE_CLASS, false, 0)
+        assert_equal('packagename', @list.to_s)
+      end
       
     end
   end

data/test/test_load_directive.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/dsl/loading_classpath'
+require 'javaclass/classpath/composite_classpath'
+
+module TestJavaClass
+  module TestDsl
+
+    class TestLoadDirective < Test::Unit::TestCase
+      extend JavaClass::Dsl::LoadDirective
+
+      def create_1
+        JavaClass::Classpath::CompositeClasspath.new('1')
+      end
+
+      def create_2
+        JavaClass::Classpath::CompositeClasspath.new('2')
+      end
+
+      wrap_classpath :create_2
+
+      def test_wrap_classpath
+        cp = create_1
+        assert_equal('1', cp.to_s)
+        assert_equal(JavaClass::Classpath::CompositeClasspath, cp.class)
+
+        cp = create_2
+        assert_equal('2', cp.to_s)
+        assert_equal(JavaClass::Dsl::LoadingClasspath, cp.class)
+      end
+
+    end
+
+  end
+end