javaclass 0.0.3 → 0.0.4

data/test/test_maven_classpath.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/classpath/maven_classpath'
+
+module TestJavaClass
+  module TestClasspath
+   
+    class TestMavenClasspath < Test::Unit::TestCase
+
+      def setup
+        @cpe = JavaClass::Classpath::MavenClasspath.new("#{TEST_DATA_PATH}/maven_classpath")
+      end
+
+      def test_class_valid_location_eh
+        assert(JavaClass::Classpath::MavenClasspath.valid_location?("#{TEST_DATA_PATH}/maven_classpath"))
+        assert(JavaClass::Classpath::MavenClasspath.valid_location?("#{TEST_DATA_PATH}/maven_classpath/module"))
+      end
+
+      def test_class_valid_location_eh_no_pom
+        assert(!JavaClass::Classpath::MavenClasspath.valid_location?("#{TEST_DATA_PATH}/folder_classpath"))
+        assert(!JavaClass::Classpath::MavenClasspath.valid_location?("#{TEST_DATA_PATH}/not_existing_folder"))
+      end
+      
+      def test_count
+        assert_equal(3, @cpe.count)
+      end
+
+      def test_elements
+        assert_equal(3, @cpe.elements.size)
+      end
+
+      def test_includes_eh
+        assert(@cpe.includes?('ClassVersionTest10.class'))
+        assert(@cpe.includes?('ClassVersionTest11.class'))
+        assert(@cpe.includes?('ClassVersionTest12.class'))
+      end
+
+      def test_class_new_invalid
+        assert_raise(IOError) {
+          JavaClass::Classpath::MavenClasspath.new("#{TEST_DATA_PATH}/folder_classpath")
+        }
+      end
+      
+    end
+
+  end
+end

data/test/test_package_entry.rb

@@ -3,22 +3,22 @@ require 'javaclass/classlist/package_entry'
 
 module TestJavaClass
   module TestClassList
-    
+
     class TestPackageEntry < Test::Unit::TestCase
-      
+
       def test_size
         pkg = JavaClass::ClassList::PackageEntry.new('packagename', 2)
         assert_equal(0, pkg.size)
-        pkg.add_class('packagename.PublicClass', true, 2);
+        pkg.add_class('packagename.PublicClass', :public, 2);
         assert_equal(1, pkg.size)
-        pkg.add_class('packagename.PublicInterface', true, 2);
+        pkg.add_class('packagename.PublicInterface', :public, 2);
         assert_equal(2, pkg.size)
-      end      
-      
+      end
+
       def test_version
         pkg = JavaClass::ClassList::PackageEntry.new('packagename', 1)
         assert_equal([1], pkg.version)
-        pkg.add_class('packagename.PublicClass', true, 2);
+        pkg.add_class('packagename.PublicClass', :public, 2);
         assert_equal([1,2], pkg.version)
       end
 
@@ -26,25 +26,25 @@ module TestJavaClass
         # fake methods for zentest, tested in all other tests
         assert(true)
       end
-      
+
       def test_to_package_shortcut_s
         pkg = JavaClass::ClassList::PackageEntry.new('packagename', 2)
-        pkg.add_class('packagename.PublicClass', true, 2);
-        pkg.add_class('packagename.PublicInterface', true, 2);
+        pkg.add_class('packagename.PublicClass', :public, 2);
+        pkg.add_class('packagename.PublicInterface', :public, 2);
         assert_equal([2], pkg.version)
         assert_equal(2, pkg.size)
         assert_equal("packagename [2] - \n" + "   PublicClass - \n" + "   PublicInterface - \n", pkg.to_package_shortcut_s(1,2))
-        
+
         classes = pkg.classes
         assert_equal(2, classes.size)
         assert_equal('PublicClass', classes[0].name)
         assert_equal([2], classes[0].version)
-        
-        pkg.add_class('packagename.PublicClass', true, 3)
-        pkg.add_class('packagename.SomeClass', true, 3)
+
+        pkg.add_class('packagename.PublicClass', :public, 3)
+        pkg.add_class('packagename.SomeClass', :public, 3)
         assert_equal([2,3], pkg.version)
         assert_equal(3, pkg.size)
-        
+
         classes = pkg.classes
         assert_equal(3, classes.size)
         assert_equal([2,3], classes[0].version)
@@ -53,17 +53,17 @@ module TestJavaClass
         assert_equal("packagename [2] - \n" + "   PublicClass - \n" + "   PublicInterface [-2] - \n"+ "   SomeClass [3] - \n", pkg.to_package_shortcut_s(1,3))
         assert_equal("packagename [2-3] - \n" + "   PublicClass - \n" + "   PublicInterface [-2] - \n"+ "   SomeClass [3] - \n", pkg.to_package_shortcut_s(1,4))
       end
-      
+
       def test_to_package_shortcut_s_package
         pkg = JavaClass::ClassList::PackageEntry.new('packagename', 2)
-        pkg.add_class('packagename.PublicClass', true, 2);
+        pkg.add_class('packagename.PublicClass', :public, 2);
         pkg.add_class('packagename.PuckageClass', false, 2);
         assert_equal([2], pkg.version)
         assert_equal(2, pkg.size)
         assert_equal("packagename [2] - \n" + "   PublicClass - \n" + "   PuckageClass [2p] - \n", pkg.to_package_shortcut_s(1,2))
       end
-      
-      def test_spaceship 
+
+      def test_spaceship
         sorted = [
           a=JavaClass::ClassList::PackageEntry.new('com.sun'),
           b=JavaClass::ClassList::PackageEntry.new('java.beans'),
@@ -71,12 +71,12 @@ module TestJavaClass
           d=JavaClass::ClassList::PackageEntry.new('java.lang'),
           e=JavaClass::ClassList::PackageEntry.new('java.io')
         ].sort
-        
+
         assert_equal(-1, d<=>a)
         assert_equal(-1, d<=>b)
         assert_equal(-1, d<=>c)
         assert_equal(-1, d<=>e)
-        
+
         #sorting in packages is: java.lang, other java.*, javax, andere
         assert_equal('java.lang', sorted[0].name)
         assert_equal('java.beans', sorted[1].name)
@@ -84,8 +84,13 @@ module TestJavaClass
         assert_equal('javax.ejb', sorted[3].name)
         assert_equal('com.sun', sorted[4].name)
       end
+
+      def test_to_s
+        pkg = JavaClass::ClassList::PackageEntry.new('packagename', 2)
+        assert_equal('packagename', pkg.to_s)
+      end  
       
     end
-    
+
   end
 end

data/test/test_references.rb

@@ -3,45 +3,45 @@ require 'javaclass/classfile/java_class_header'
 
 module TestJavaClass
   module TestClassFile
-    
+
     class TestReferences < Test::Unit::TestCase
-      
+
       def setup
         @refs = JavaClass::ClassFile::JavaClassHeader.new(load_class('references/ReferencesTest')).references
       end
-      
+
       def test_referenced_fields
-        fields = @refs.referenced_fields(false)
+        fields = @refs.referenced_fields
         assert_equal(0, fields.size)
-        
-        fields = @refs.referenced_fields(true) 
+
+        fields = @refs.referenced_fields(:include_own)
         assert_equal(1, fields.size)
         assert_equal('ReferencesTest', fields[0].class_name)
         assert_equal('ReferencesTest', fields[0].class_name.to_classname)
         assert_equal('field:LReferencesTest;', fields[0].signature)
       end
-      
+
       def test_referenced_methods
-        methods = @refs.referenced_methods(false)
+        methods = @refs.referenced_methods
         assert_equal(1, methods.size) # ctor init
         assert_equal('java/lang/Object', methods[0].class_name)
         assert_equal('java.lang.Object', methods[0].class_name.to_classname)
-        
-        methods = @refs.referenced_methods(true)
-        assert_equal(2, methods.size) 
+
+        methods = @refs.referenced_methods(:include_own)
+        assert_equal(2, methods.size)
         assert_equal('java/lang/Object', methods[0].class_name)
         assert_equal('ReferencesTest', methods[1].class_name)
         assert_equal('x:()V', methods[1].signature)
       end
-      
+
       def test_used_classes
         classes = @refs.used_classes
         assert_equal(1, classes.size)
         assert_equal('java/lang/Object', classes[0].class_name)
         assert_equal('java.lang.Object', classes[0].class_name.to_classname)
       end
-      
+
     end
-    
+
   end
 end

data/test/test_string_hexdump.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/string_hexdump'
+
+class TestStringHexdump < Test::Unit::TestCase
+
+  def test_hexdump_line
+    assert_equal("00000000h: #{'   '*16}; \n", ''.hexdump)
+    assert_equal("00000000h: 61 #{'   '*15}; a\n", 'a'.hexdump)
+  end
+
+  def test_hexdump_non_printable
+    assert_equal("00000000h: 01 02 03 04 05 06 07 08 09 0A #{'   '*6}; ..........\n", "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a".hexdump)
+    assert_equal("00000000h: FF FE FC #{'   '*13}; ...\n", "\xff\xfe\xfc".hexdump)
+  end
+
+  def test_hexdump_more_lines
+    assert_equal("00000000h: 00 00 ; ..\n00000002h: 00 00 ; ..\n", "\x00\x00\x00\x00".hexdump(2));
+  end
+
+  def test_hexdump_whitespace
+    assert_equal("00000000h: 20 00 65 00 #{'   '*12};  .e.\n", " \x00e\x00".hexdump);
+  end
+
+end

data/test/test_string_ux.rb

@@ -1,127 +1,39 @@
 require File.dirname(__FILE__) + '/setup'
 require 'javaclass/string_ux'
 
-class TestString < Test::Unit::TestCase
-  
+class TestStringUx < Test::Unit::TestCase
+
   def test_u1
     assert_equal(49, "1".u1(0))
     assert_equal(49, "212".u1(1))
     assert_equal(50, "212".u1(2))
+
+    assert_equal(0, "\x00".u1(0))
+    assert_equal(7, "\x07".u1(0))
+    assert_equal(10, "\x0A".u1(0))
+    assert_equal(255, "\xFF".u1(0))
   end
-  
+
   def test_u2
     assert_equal(49*256+50, "12".u2(0))
     assert_equal(49*256+50, "312".u2(1))
+
+    assert_equal([49*256+50, 49*256+51], "1213".u2rep(2))
   end
-  
+
   def test_u4
     assert_equal(1, "\0\0\0\1".u4(0))
     assert_equal(256**4-2, "\xff\xff\xff\xfe".u4(0))
   end
-  
+
   def test_single
-    assert_in_delta(3.14159, "@I\x0f\xd0".single(0), 0.0000002) 
-    # assert_in_delta(3.14159, "@I\x0f\xef\xbf\xbd ".single(0), 0.0000002) 
+    assert_in_delta(3.14159, "@I\x0f\xd0".single(0), 0.0000002)
+    # assert_in_delta(3.14159, "@I\x0f\xef\xbf\xbd ".single(0), 0.0000002)
   end
-  
+
   def test_double
-    # assert_in_delta(3.14159265258981, "@\t!\xef\xbf\xbd\x54!\xef\xbf\xbd ".double(0), 0.00000000000001) 
-    assert_in_delta(3.14157056614432, "@\t!\xef\xbf\xbd\x54!\xef\xbf\xbd ".double(0), 0.00000000000001) 
+    # assert_in_delta(3.14159265258981, "@\t!\xef\xbf\xbd\x54!\xef\xbf\xbd ".double(0), 0.00000000000001)
+    assert_in_delta(3.14157056614432, "@\t!\xef\xbf\xbd\x54!\xef\xbf\xbd ".double(0), 0.00000000000001)
   end
-  
-  # --- fake methods for zentest ---
-  def test_capitalize() assert(true); end
-  def test_capitalize_bang() assert(true); end
-  def test_casecmp() assert(true); end
-  def test_center() assert(true); end
-  def test_chomp() assert(true); end
-  def test_chomp_bang() assert(true); end
-  def test_chop() assert(true); end
-  def test_chop_bang() assert(true); end
-  def test_concat() assert(true); end
-  def test_count() assert(true); end
-  def test_crypt() assert(true); end
-  def test_delete() assert(true); end
-  def test_delete_bang() assert(true); end
-  def test_downcase() assert(true); end
-  def test_downcase_bang() assert(true); end
-  def test_dump() assert(true); end
-  def test_each() assert(true); end
-  def test_each_byte() assert(true); end
-  def test_each_line() assert(true); end
-  def test_empty_eh() assert(true); end
-  def test_ends_with() assert(true); end
-  def test_ensure_end() assert(true); end
-  def test_eql_eh() assert(true); end
-  def test_equals2() assert(true); end
-  def test_equalstilde() assert(true); end
-  def test_gsub() assert(true); end
-  def test_gsub_bang() assert(true); end
-  def test_hash() assert(true); end
-  def test_hex() assert(true); end
-  def test_include_eh() assert(true); end
-  def test_index() assert(true); end
-  def test_index_equals() assert(true); end
-  def test_insert() assert(true); end
-  def test_inspect() assert(true); end
-  def test_intern() assert(true); end
-  def test_lchop() assert(true); end
-  def test_length() assert(true); end
-  def test_ljust() assert(true); end
-  def test_lstrip() assert(true); end
-  def test_lstrip_bang() assert(true); end
-  def test_lt2() assert(true); end
-  def test_match() assert(true); end
-  def test_next() assert(true); end
-  def test_next_bang() assert(true); end
-  def test_oct() assert(true); end
-  def test_percent() assert(true); end
-  def test_plus() assert(true); end
-  def test_replace() assert(true); end
-  def test_reverse() assert(true); end
-  def test_reverse_bang() assert(true); end
-  def test_rindex() assert(true); end
-  def test_rjust() assert(true); end
-  def test_rstrip() assert(true); end
-  def test_rstrip_bang() assert(true); end
-  def test_scan() assert(true); end
-  def test_size() assert(true); end
-  def test_slice() assert(true); end
-  def test_slice_bang() assert(true); end
-  def test_spaceship() assert(true); end
-  def test_split() assert(true); end
-  def test_squeeze() assert(true); end
-  def test_squeeze_bang() assert(true); end
-  def test_starts_with() assert(true); end
-  def test_strip() assert(true); end
-  def test_strip_bang() assert(true); end
-  def test_sub() assert(true); end
-  def test_sub_bang() assert(true); end
-  def test_succ() assert(true); end
-  def test_succ_bang() assert(true); end
-  def test_sum() assert(true); end
-  def test_swapcase() assert(true); end
-  def test_swapcase_bang() assert(true); end
-  def test_times() assert(true); end
-  def test_to_f() assert(true); end
-  def test_to_i() assert(true); end
-  def test_to_s() assert(true); end
-  def test_to_str() assert(true); end
-  def test_to_sym() assert(true); end
-  def test_tr() assert(true); end
-  def test_tr_bang() assert(true); end
-  def test_tr_s() assert(true); end
-  def test_tr_s_bang() assert(true); end
-  def test_u8() assert(true); end
-  def test_unpack() assert(true); end
-  def test_upcase() assert(true); end
-  def test_upcase_bang() assert(true); end
-  def test_upto() assert(true); end  
-  
-  def test_class_yaml_new() assert(true); end
-  def test_is_binary_data_eh() assert(true); end
-  def test_is_complex_yaml_eh() assert(true); end
-  def test_taguri() assert(true); end
-  def test_taguri_equals() assert(true); end
-  def test_to_yaml() assert(true); end
+
 end

data/test/test_tracking_classpath.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/classpath/tracking_classpath'
+require File.dirname(__FILE__) + '/test_folder_classpath'
+require File.dirname(__FILE__) + '/test_composite_classpath'
+
+module TestJavaClass
+  module TestClasspath
+
+    class TestTrackingFolderClasspath < TestFolderClasspath
+      # extend TestFolderClasspath to execute all tests again
+
+      def setup
+        super
+        @original = @cpe
+        @cpe = JavaClass::Classpath::TrackingClasspath.new(@cpe)
+      end
+
+      def test_reset_access
+        @cpe.mark_accessed('ClassVersionTest10')
+        assert_equal(1, @cpe.accessed('ClassVersionTest10'))
+        @cpe.reset_access
+        assert_equal(0, @cpe.accessed('ClassVersionTest10'))
+      end
+
+      def test_mark_accessed
+        assert_equal(0, @cpe.accessed)
+        assert_equal(0, @cpe.accessed('ClassVersionTest10'))
+        assert_equal(1, @cpe.mark_accessed('ClassVersionTest10'))
+        assert_equal(1, @cpe.accessed('ClassVersionTest10'))
+        assert_equal(0, @cpe.accessed('ClassVersionTest11'))
+        assert_equal(1, @cpe.accessed)
+
+        assert_equal(2, @cpe.mark_accessed('ClassVersionTest10'))
+        assert_nil(@cpe.mark_accessed('NonExistingClass'))
+      end
+
+      def test_load_binary_tracked
+        assert_equal(0, @cpe.accessed('ClassVersionTest10'))
+        @cpe.load_binary('ClassVersionTest10')
+        assert_equal(1, @cpe.accessed('ClassVersionTest10'))
+      end
+
+      def test_load_tracked
+        class << @original
+          def load(name)
+            load_binary(name)
+          end 
+        end
+        assert_equal(0, @cpe.accessed('ClassVersionTest10'))
+        @cpe.load('ClassVersionTest10')
+        assert_equal(1, @cpe.accessed('ClassVersionTest10'))
+      end
+      
+      def test_all_accessed
+        @cpe.mark_accessed('package/ClassVersionTest11')
+        @cpe.mark_accessed('ClassVersionTest10')
+        assert_equal(['ClassVersionTest10.class', 'package/ClassVersionTest11.class'], @cpe.all_accessed)
+      end
+
+      def test_class_new_invalud
+        assert_raise(ArgumentError){ 
+          JavaClass::Classpath::TrackingClasspath.new('123')
+        }
+      end
+      
+    end
+
+    class TestTrackingCompositeClasspath  < TestCompositeClasspath
+      # extend TestCompositeClasspath to execute all tests again
+
+      def test_reset_access
+        @cpe.mark_accessed('package/ClassVersionTest11.class')
+        assert_equal(1, @cpe.accessed('package/ClassVersionTest11.class'))
+        @cpe.reset_access
+        assert_equal(0, @cpe.accessed('package/ClassVersionTest11.class'))
+      end
+
+      def test_mark_accessed
+        assert_equal(0, @cpe.accessed)
+        assert_equal(0, @cpe.accessed('ClassVersionTest10'))
+        assert_equal(1, @cpe.mark_accessed('ClassVersionTest10'))
+        assert_equal(1, @cpe.accessed('ClassVersionTest10'))
+        assert_equal(0, @cpe.accessed('ClassVersionTest11'))
+        assert_equal(1, @cpe.accessed)
+
+        assert_equal(2, @cpe.mark_accessed('ClassVersionTest10'))
+        assert_nil(@cpe.mark_accessed('NonExistingClass'))
+      end
+  
+      def test_mark_accessed_elements
+        @cpe.mark_accessed('ClassVersionTest10')
+        
+        assert_equal(0, @cpe.elements[0].accessed)
+        assert_equal(1, @cpe.elements[1].accessed)
+      end
+
+      def test_load_binary_tracked
+        assert_equal(0, @cpe.accessed('ClassVersionTest10'))
+        @cpe.load_binary('ClassVersionTest10')
+        assert_equal(1, @cpe.accessed('ClassVersionTest10'))
+      end
+
+      def test_all_accessed
+        @cpe.mark_accessed('ClassVersionTest11')
+        @cpe.mark_accessed('ClassVersionTest10')
+        assert_equal(['ClassVersionTest10.class', 'ClassVersionTest11.class'], @cpe.all_accessed)
+      end
+
+    end
+
+  end
+end

data/test/test_transitive_dependencies.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/classpath/folder_classpath'
+require 'javaclass/dsl/loading_classpath'
+require 'javaclass/analyse/transitive_dependencies'
+
+module TestJavaClass
+  module TestAnalyse
+
+    class TestTransitiveDependencies < Test::Unit::TestCase
+
+      def setup
+        @cpe = JavaClass::Dsl::LoadingClasspath.new(
+                  JavaClass::Classpath::FolderClasspath.new("#{TEST_DATA_PATH}/transitive_dependencies"))
+        @cpe.extend(JavaClass::Analyse::TransitiveDependencies)
+      end
+
+      def test_transitive_dependency_tree_not_exist
+        tree = @cpe.transitive_dependency_tree('NotExisting'.to_javaname)
+        assert_equal(1, tree.size)
+      end
+
+      def test_transitive_dependency_tree
+        tree = @cpe.transitive_dependency_tree('Start'.to_javaname)
+        assert_equal(4, tree.size)
+        assert_equal(['Start', ['A', ['B', 'C']]], tree.to_a)
+      end
+
+    end
+
+  end
+end

data/test/test_unpacking_jar_classpath.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/logging_folder_classpath'
+require 'javaclass/classpath/jar_classpath'
+
+module JavaClass
+  module Classpath
+
+    # Add a method +used_unpacked_folder?+ to see if the load_binary of the unpacked folder was called.
+    class JarClasspath
+
+      # Helper method to assert it the cache was called.
+      def used_unpacked_folder?
+        result = @delegate.was_called
+        @delegate.was_called = false # reset flag
+        result
+      end
+    end
+
+  end
+end
+
+module TestJavaClass
+  module TestClasspath
+
+    class TestUnpackingJarClasspath < Test::Unit::TestCase
+
+      def setup
+        JavaClass.unpack_jars!(:unpack)
+        @cpe = JavaClass::Classpath::JarClasspath.new("#{TEST_DATA_PATH}/jar_classpath/JarClasspathTest.jar")
+      end
+
+      def teardown
+        JavaClass.unpack_jars!(false)
+      end
+
+      def test_load_binary
+        assert_equal(load_class('class_version/ClassVersionTest10'), @cpe.load_binary('ClassVersionTest10'))
+        assert(@cpe.used_unpacked_folder?)
+      end
+
+    end
+
+  end
+end

data/test/test_zip_file.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/setup'
+require 'javaclass/gems/zip_file'
+
+module TestJavaClass
+  module TestGems
+
+    class TestZipFile < Test::Unit::TestCase
+
+      def setup
+        @folder = "#{TEST_DATA_PATH}/zip_file"
+      end
+
+      def test_patch_for_invalid_flags
+        assert_two_directories('commons-math-2.2-broken.zip')
+        assert_two_directories('regenerated-with-7zip.zip')
+        assert_two_directories('regenerated-with-jar.zip')
+      end
+
+      def assert_two_directories(zip_name)
+        zip = JavaClass::Gems::ZipFile.new(File.join(@folder, zip_name))
+        number = 0
+        zip.entries { |entry|
+          assert_not_nil(entry)
+          assert(!entry.file?)
+          number += 1
+        }
+        assert_equal(2, number)
+      end
+      
+    end
+
+  end
+end