unageanu-javaclass 0.0.1

data/sample/java_src/com/example/Deprecated.java

@@ -0,0 +1,16 @@
+package com.example;
+
+/**
+ * @deprecated
+ */
+public class Deprecated {
+
+    /**@deprecated*/
+    static final int DEPRECATED_FIELD = 0;
+
+    /**@deprecated*/
+    Deprecated() {}
+
+    /**@deprecated*/
+    public void deprecatedMethod () {}
+}

data/sample/java_src/com/example/InnerClass.java

@@ -0,0 +1,23 @@
+package com.example;
+
+
+import java.util.Map;
+
+public interface InnerClass {
+
+    // staticなインナークラス
+    static class StaticInnerClass {
+        // インナークラス内インナークラス
+        static class StaticInnerInnerClass{}
+        class InnerInnerClass{}
+    }
+
+    // インナークラス
+    class BasicInnerClass {}
+
+    // 匿名クラス
+    Object x = new Object() {
+        public String toString() { return "x"; }
+    };
+
+}

data/sample/java_src/com/example/InnerClassImpl.java

@@ -0,0 +1,31 @@
+package com.example;
+
+
+import java.util.Map;
+
+
+public class InnerClassImpl
+implements InnerClass {
+
+    // staticなインナークラス
+    static class StaticInnerClass2 {}
+
+    // インナークラス
+    class BasicInnerClass2 {}
+
+    // 匿名クラス
+    Object xx = new Object() {
+        public String toString() { return "xx"; }
+    };
+
+    public static void main() {
+
+        // 関数内クラス
+        class MethodInnerClass {}
+
+        // 関数内の匿名クラス
+        Object yy = new Object() {
+            public String toString() { return "yy"; }
+        };
+    }
+}

data/sample/java_src/com/example/Kitten.java

@@ -0,0 +1,78 @@
+package com.example;
+
+import java.io.Serializable;
+
+/**
+ * 猫。
+ *
+ * @version $Revision:$
+ * @author  $Author:$
+ */
+public class Kitten implements Serializable {
+
+    /**
+     * 名前
+     */
+    private String name = "";
+
+    /**
+     * 年齢
+     */
+    private int age = 0;
+
+    /**
+     * コンストラクタ
+     */
+    public Kitten (){}
+
+    /**
+     * コンストラクタ
+     *
+     * @param name
+     *        名前
+     * @param age
+     *        年齢
+     */
+    public Kitten (
+        String name,
+        int age ) {
+        this.name = name;
+        this.age = age;
+    }
+
+    /**
+     * 名前を取得する。
+     * @return 名前
+     */
+    public String getName () {
+        return name;
+    }
+    /**
+     * 名前を設定する。
+     * @param name 名前
+     */
+    public void setName ( String name ) {
+        this.name = name;
+    }
+
+    /**
+     * 年齢を取得する。
+     * @return 年齢
+     */
+    public int getAge () {
+        return age;
+    }
+    /**
+     * 年齢を設定する。
+     * @param age 年齢
+     */
+    public void setAge ( int age ) {
+        this.age = age;
+    }
+    /**
+     * 鳴く
+     */
+    public void meow( ) {
+        System.out.println( "meow!" );
+    }
+}

data/sample/java_src/com/example/ThrowsException.java

@@ -0,0 +1,12 @@
+package com.example;
+
+import java.io.IOException;
+
+/**
+ * 例外を投げる
+ */
+public class ThrowsException {
+    public static void main ( String[] args )
+    throws IOException, IllegalArgumentException, OutOfMemoryError {}
+
+}

data/sample/java_src/com/example/annotation/Annotated.java

@@ -0,0 +1,47 @@
+package com.example.annotation;
+
+import java.util.ArrayList;
+
+@RuntimeAnnotationA(
+  string      = "aaa",
+  stringArray = { "a", "b", "c" },
+  bool        = false,
+  integer     = 1000,
+  state       = Thread.State.BLOCKED,
+  type        = ArrayList.class
+)
+@RuntimeAnnotationB("test")
+@SourceAnnotationA("test")
+@ClassAnnotationA("test")
+public class Annotated {
+
+	@RuntimeAnnotationA(
+			  string      = "bbb",
+			  stringArray = { "a", "b", "c" },
+			  bool        = false,
+			  integer     = 1000,
+			  state       = Thread.State.BLOCKED,
+			  type        = ArrayList.class
+			)
+	@RuntimeAnnotationB("test")
+	@SourceAnnotationA("test")
+	@ClassAnnotationA("test")
+	public String foo;
+
+    // アノテーション付きメソッド。
+    // パラメータもアノテーションを持つ。
+	@RuntimeAnnotationA(
+			  string      = "ccc",
+			  stringArray = { "a", "b", "c" },
+			  bool        = false,
+			  integer     = 1000,
+			  state       = Thread.State.BLOCKED,
+			  type        = ArrayList.class
+			)
+	@RuntimeAnnotationB("test")
+	@SourceAnnotationA("test")
+	@ClassAnnotationA("test")
+	void foo(
+        @HasDefaultValue @RuntimeAnnotationB("test") @RuntimeAnnotationC String str,
+        @RuntimeAnnotationC @RuntimeAnnotationB("test") int x ) {}
+}

data/sample/java_src/com/example/annotation/AnnotatedMethod.java

@@ -0,0 +1,18 @@
+package com.example.annotation;
+
+import java.util.ArrayList;
+
+public class AnnotatedMethod {
+
+
+    // アノテーション付きパラメータを持つメソッド。
+	void foo(
+        @A("test") @B @C String str,
+        @B @C int x ) {}
+
+    static @interface A {
+        String value();
+    }
+    static @interface B {}
+    static @interface C {}
+}

data/sample/java_src/com/example/annotation/ClassAnnotationA.java

@@ -0,0 +1,10 @@
+package com.example.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.List;
+
+@Retention( RetentionPolicy.CLASS )
+public @interface ClassAnnotationA {
+    String value();
+}

data/sample/java_src/com/example/annotation/HasDefaultValue.java

@@ -0,0 +1,10 @@
+package com.example.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.List;
+
+@Retention( RetentionPolicy.RUNTIME )
+public @interface HasDefaultValue {
+    String value() default "default";
+}

data/sample/java_src/com/example/annotation/RuntimeAnnotationA.java

@@ -0,0 +1,15 @@
+package com.example.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.List;
+
+@Retention( RetentionPolicy.RUNTIME )
+public @interface RuntimeAnnotationA {
+    String string();
+    String[] stringArray();
+    int integer();
+    boolean bool();
+    java.lang.Class<? extends List> type();
+    Thread.State state();
+}

data/sample/java_src/com/example/annotation/RuntimeAnnotationB.java

@@ -0,0 +1,10 @@
+package com.example.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.List;
+
+@Retention( RetentionPolicy.RUNTIME )
+public @interface RuntimeAnnotationB {
+    String value();
+}

data/sample/java_src/com/example/annotation/RuntimeAnnotationC.java

@@ -0,0 +1,8 @@
+package com.example.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.List;
+
+@Retention( RetentionPolicy.RUNTIME )
+public @interface RuntimeAnnotationC {}

data/sample/java_src/com/example/annotation/SourceAnnotationA.java

@@ -0,0 +1,10 @@
+package com.example.annotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.List;
+
+@Retention( RetentionPolicy.SOURCE )
+public @interface SourceAnnotationA {
+    String value();
+}

data/sample/java_src/com/example/types/TypeVariables.java

@@ -0,0 +1,19 @@
+package com.example.types;
+
+import java.util.List;
+import java.util.Set;
+
+public class TypeVariables<T> {
+
+    private List<T> list;
+    private List<String> list2;
+    private List<? extends String>[] list3;
+
+    public <S, U extends T> S foo( List<U> args ) {
+        return null;
+    }
+
+    public <U extends Object & List & Set > U var( List<U> args ) {
+        return null;
+    }
+}

data/sample/sample.rb

@@ -0,0 +1,27 @@
+
+require "rubygems"
+require "javaclass"
+require "kconv"
+
+[
+  "./java_class/com/example/Kitten.class",
+  "./java_class/HelloWorld.class",
+  "./java_class/com/example/Constants.class",
+  "./java_class/com/example/InnerClass.class",
+  "./java_class/com/example/InnerClassImpl.class",
+  "./java_class/com/example/InnerClass$StaticInnerClass.class",
+  "./java_class/com/example/ThrowsException.class",
+  "./java_class/com/example/InnerClassImpl$1MethodInnerClass.class",
+  "./java_class/com/example/InnerClassImpl$2.class",
+  "./java_class/com/example/types/TypeVariables.class",
+  "./java_class/com/example/Deprecated.class",
+  "./java_class/com/example/annotation/Annotated.class",
+  "./java_class/com/example/annotation/HasDefaultValue.class",
+  "./java_class/com/example/annotation/AnnotatedMethod.class"
+].each { |c|
+  open( c, "r+b" ) {|io|
+    jc = JavaClass.from io
+    puts jc.to_s.tosjis
+    puts ""
+  }
+}

data/test/all-tests.rb

@@ -0,0 +1,32 @@
+
+$: << "../src"
+
+require 'test/unit/testsuite'
+require 'access-flag-test'
+require 'attribute-test'
+require 'constant-test'
+require 'member-test'
+
+module JavaClass
+
+  class AllTests
+    def self.suite
+      suite = Test::Unit::TestSuite.new( "javaclass all tests." )
+      suite << AccessFlagTest.suite
+      suite << AttributeTest.suite
+      suite << AttributeTest.suite
+      suite << UTF8ConstantTest
+      suite << IntegerConstantTest
+      suite << LongConstantTest.suite
+      suite << FloatConstantTest.suite
+      suite << DoubleConstantTest.suite
+      suite << StringConstantTest.suite
+      suite << NameAndTypeConstantTest.suite
+      suite << ClassConstantTest.suite
+      suite << MemberRefConstantTest.suite
+      suite << MemberTest.suite
+      return suite
+    end
+  end
+
+end

data/test/java_src/com/example/TestClass1.java

@@ -0,0 +1,28 @@
+package com.example;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class TestClass1<T, X extends Runnable> 
+extends ArrayList<T> 
+implements Serializable, Closeable{
+    
+    static class Hoo {};
+    class Var {};
+    Object x = new Object() {}; // 無名クラス
+    
+    static String stringConstant = "あいう";
+    static int intConstant = 1;
+    static long longConstant = 100L;
+    static List<String> listConstant = new ArrayList<String>();
+    static float floatConstant  = 0F;
+    static double doubleConstant0 = 0D;
+    static byte byteConstant  = 10;
+    static char charConstant  = 'a';
+    static boolean booleanConstant  = false;
+    
+    public void close() throws IOException {}
+}

data/test/test_access_flag.rb

@@ -0,0 +1,205 @@
+#!/usr/bin/ruby
+
+$: << "../lib"
+
+require "test/unit"
+require "javaclass"
+require "test_util"
+
+require "javaclass"
+
+module JavaClass
+
+#
+#=== AccessFlagのテスト。
+#
+class AccessFlagTest < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_class_access_flag
+
+    a = ClassAccessFlag.new( ClassAccessFlag::ACC_PUBLIC )
+    assert_equal a.to_s, "public class"
+    assert_equal a.dump, "0001"
+    assert_equal a.source_modifiers, []
+    assert_equal a.accessor, "public"
+    assert_equal a.type, "class"
+    assert  a.on?(ClassAccessFlag::ACC_PUBLIC)
+    assert  !a.on?(ClassAccessFlag::ACC_FINAL)
+    assert  !a.on?(ClassAccessFlag::ACC_ABSTRACT)
+
+    a.on( ClassAccessFlag::ACC_INTERFACE )
+    a.on( ClassAccessFlag::ACC_ABSTRACT )
+    assert_equal a.to_s, "public abstract interface"
+    assert_equal a.dump, "0601"
+    assert_equal a.source_modifiers, ["abstract"]
+    assert_equal a.accessor, "public"
+    assert_equal a.type, "interface"
+    assert  a.on?(ClassAccessFlag::ACC_PUBLIC)
+    assert  a.on?(ClassAccessFlag::ACC_INTERFACE)
+    assert  !a.on?(ClassAccessFlag::ACC_FINAL)
+    assert  a.on?(ClassAccessFlag::ACC_ABSTRACT)
+
+    a.off( ClassAccessFlag::ACC_INTERFACE )
+    a.off( ClassAccessFlag::ACC_ABSTRACT )
+    a.off( ClassAccessFlag::ACC_PUBLIC )
+    a.on( ClassAccessFlag::ACC_ENUM )
+    assert_equal a.to_s, "enum"
+    assert_equal a.dump, "4000"
+    assert_equal a.source_modifiers, []
+    assert_equal a.accessor, ""
+    assert_equal a.type, "enum"
+    assert  !a.on?(ClassAccessFlag::ACC_PUBLIC)
+    assert  !a.on?(ClassAccessFlag::ACC_INTERFACE)
+    assert  !a.on?(ClassAccessFlag::ACC_FINAL)
+    assert  a.on?(ClassAccessFlag::ACC_ENUM)
+
+    a.off( ClassAccessFlag::ACC_ENUM )
+    a.on( ClassAccessFlag::ACC_PUBLIC )
+    a.on( ClassAccessFlag::ACC_ANNOTATION )
+    a.on( ClassAccessFlag::ACC_INTERFACE )
+    assert_equal a.to_s, "public @interface"
+    assert_equal a.dump, "2201"
+    assert_equal a.source_modifiers, []
+    assert_equal a.accessor, "public"
+    assert_equal a.type, "@interface"
+    assert  a.on?(ClassAccessFlag::ACC_PUBLIC)
+    assert  a.on?(ClassAccessFlag::ACC_INTERFACE)
+    assert  !a.on?(ClassAccessFlag::ACC_FINAL)
+    assert  a.on?(ClassAccessFlag::ACC_ANNOTATION)
+
+  end
+  def test_field_access_flag
+
+    a = FieldAccessFlag.new( FieldAccessFlag::ACC_PUBLIC )
+    assert_equal a.to_s, "public"
+    assert_equal a.dump, "0001"
+    assert_equal a.source_modifiers, []
+    assert_equal a.accessor, "public"
+    assert  a.on?(FieldAccessFlag::ACC_PUBLIC)
+    assert  !a.on?(FieldAccessFlag::ACC_FINAL)
+    assert  !a.on?(FieldAccessFlag::ACC_STATIC)
+
+    a.off( FieldAccessFlag::ACC_PUBLIC )
+    a.on( FieldAccessFlag::ACC_PROTECTED )
+    a.on( FieldAccessFlag::ACC_STATIC )
+    a.on( FieldAccessFlag::ACC_FINAL )
+    a.on( FieldAccessFlag::ACC_ENUM )
+    assert_equal a.to_s, "protected static final"
+    assert_equal a.dump, "401C"
+    assert_equal a.source_modifiers, ["static","final"]
+    assert_equal a.accessor, "protected"
+
+    a.off( FieldAccessFlag::ACC_PROTECTED )
+    a.on( FieldAccessFlag::ACC_PRIVATE )
+    a.on( FieldAccessFlag::ACC_VOLATILE )
+    a.on( FieldAccessFlag::ACC_TRANSIENT )
+    a.off( FieldAccessFlag::ACC_STATIC )
+    a.off( FieldAccessFlag::ACC_FINAL )
+    a.off( FieldAccessFlag::ACC_ENUM )
+    assert_equal a.to_s, "private volatile transient"
+    assert_equal a.dump, "00C2"
+    assert_equal a.source_modifiers, ["volatile","transient"]
+    assert_equal a.accessor, "private"
+
+    a.off( FieldAccessFlag::ACC_PRIVATE )
+    a.off( FieldAccessFlag::ACC_VOLATILE )
+    a.off( FieldAccessFlag::ACC_TRANSIENT )
+    assert_equal a.to_s, ""
+    assert_equal a.dump, "0000"
+    assert_equal a.source_modifiers, []
+    assert_equal a.accessor, ""
+
+  end
+
+  def test_method_access_flag
+
+    a = MethodAccessFlag.new( MethodAccessFlag::ACC_PUBLIC )
+    assert_equal a.to_s, "public"
+    assert_equal a.dump, "0001"
+    assert_equal a.source_modifiers, []
+    assert_equal a.accessor, "public"
+    assert  a.on?(MethodAccessFlag::ACC_PUBLIC)
+    assert  !a.on?(MethodAccessFlag::ACC_FINAL)
+    assert  !a.on?(MethodAccessFlag::ACC_STATIC)
+
+    a.off( MethodAccessFlag::ACC_PUBLIC )
+    a.on( MethodAccessFlag::ACC_PROTECTED )
+    a.on( MethodAccessFlag::ACC_STATIC )
+    a.on( MethodAccessFlag::ACC_FINAL )
+    assert_equal a.to_s, "protected static final"
+    assert_equal a.dump, "001C"
+    assert_equal a.source_modifiers, ["static","final"]
+    assert_equal a.accessor, "protected"
+
+    a.off( MethodAccessFlag::ACC_PROTECTED )
+    a.on( MethodAccessFlag::ACC_PRIVATE )
+    a.on( MethodAccessFlag::ACC_NATIVE )
+    a.on( MethodAccessFlag::ACC_VARARGS )
+    a.on( MethodAccessFlag::ACC_SYNCHRONIZED)
+    a.off( MethodAccessFlag::ACC_STATIC )
+    a.off( MethodAccessFlag::ACC_FINAL )
+    assert_equal a.to_s, "private synchronized native"
+    assert_equal a.dump, "01A2"
+    assert_equal a.source_modifiers, ["synchronized", "native"]
+    assert_equal a.accessor, "private"
+
+    a.off( MethodAccessFlag::ACC_PRIVATE )
+    a.off( MethodAccessFlag::ACC_NATIVE )
+    a.off( MethodAccessFlag::ACC_VARARGS )
+    a.off( MethodAccessFlag::ACC_SYNCHRONIZED)
+    assert_equal a.to_s, ""
+    assert_equal a.dump, "0000"
+    assert_equal a.source_modifiers, []
+    assert_equal a.accessor, ""
+
+  end
+
+  def test_inner_class_access_flag
+
+    a = InnerClassAccessFlag.new( InnerClassAccessFlag::ACC_PUBLIC )
+    assert_equal a.to_s, "public class"
+    assert_equal a.dump, "0001"
+    assert_equal a.source_modifiers, []
+    assert_equal a.accessor, "public"
+    assert  a.on?(InnerClassAccessFlag::ACC_PUBLIC)
+    assert  !a.on?(InnerClassAccessFlag::ACC_FINAL)
+    assert  !a.on?(InnerClassAccessFlag::ACC_STATIC)
+
+    a.off( InnerClassAccessFlag::ACC_PUBLIC )
+    a.on( InnerClassAccessFlag::ACC_PROTECTED )
+    a.on( InnerClassAccessFlag::ACC_STATIC )
+    a.on( InnerClassAccessFlag::ACC_FINAL )
+    assert_equal a.to_s, "protected static final class"
+    assert_equal a.dump, "001C"
+    assert_equal a.source_modifiers, ["static","final"]
+    assert_equal a.accessor, "protected"
+
+    a.off( InnerClassAccessFlag::ACC_PROTECTED )
+    a.on( InnerClassAccessFlag::ACC_PRIVATE )
+    a.on( InnerClassAccessFlag::ACC_SYNTHETIC )
+    a.on( InnerClassAccessFlag::ACC_ENUM )
+    a.off( InnerClassAccessFlag::ACC_STATIC )
+    a.off( InnerClassAccessFlag::ACC_FINAL )
+    assert_equal a.to_s, "private enum"
+    assert_equal a.dump, "5002"
+    assert_equal a.source_modifiers, []
+    assert_equal a.accessor, "private"
+
+    a.off( InnerClassAccessFlag::ACC_PRIVATE )
+    a.off( InnerClassAccessFlag::ACC_SYNTHETIC )
+    a.off( InnerClassAccessFlag::ACC_ENUM)
+    assert_equal a.to_s, "class"
+    assert_equal a.dump, "0000"
+    assert_equal a.source_modifiers, []
+    assert_equal a.accessor, ""
+
+  end  
+  
+end
+end