From e7307604ae290c437627c8433e5b21655adcd351 Mon Sep 17 00:00:00 2001 From: jochen Date: Thu, 11 Mar 1999 22:58:17 +0000 Subject: [PATCH] Initial revision git-svn-id: https://svn.code.sf.net/p/jode/code/trunk@383 379699f6-c40d-0410-875b-85095c16579e --- jode/test/EvilTypes.j | 81 ++++++++++++++++++++++++++++++++++++++ jode/test/Expressions.java | 73 ++++++++++++++++++++++++++++++++++ jode/test/StackOps.j | 41 +++++++++++++++++++ 3 files changed, 195 insertions(+) create mode 100644 jode/test/EvilTypes.j create mode 100644 jode/test/Expressions.java create mode 100644 jode/test/StackOps.j diff --git a/jode/test/EvilTypes.j b/jode/test/EvilTypes.j new file mode 100644 index 0000000..dde1011 --- /dev/null +++ b/jode/test/EvilTypes.j @@ -0,0 +1,81 @@ +; This class converts between boolean and ints without type casts. +; You can't decompile this directly, the decompiler probably gives type errors. + +.class public jode/test/EvilTypes +.super java/lang/Object + +.method public static boolToInt(Z)I + .limit locals 1 + .limit stack 1 + iload_0 + ireturn +.end method + +.method public static intToBool(I)Z + .limit locals 1 + .limit stack 1 + iload_0 + ireturn +.end method + +.method public static test()V + .limit locals 2 + .limit stack 2 + iconst_1 + invokestatic jode/test/EvilTypes/intToBool(I)Z + istore 0 + iconst_2 + istore 1 + iload 0 + iload 1 + ixor + pop + return +.end method + +.method private static useSerial(Ljava/io/Serializable;)V + .limit locals 1 + .limit stack 0 + return +.end method + +; This is a test where a type error occurs, because there is no Type +; that implements Cloneable, Serializable and is assignable form int +; array and java/lang/Date (though both objects are Cloneable and +; Serializable). We can't find any correct type for local 2. + +.method public static referenceCast(Ljava/util/Date;[I)Ljava/lang/Cloneable; + .limit locals 3 + .limit stack 2 + aload_0 + ifnonnull second + aload_0 + goto done +second: + aload_1 +done: + dup + astore_2 + invokestatic jode/test/EvilTypes/useSerial(Ljava/io/Serializable;)V + aload_2 + areturn +.end method + +; This shows that the bytecode verifier doesn't catch every type error. +.method public static test(Ljava/lang/String;)Ljava/lang/Runnable; + .limit locals 1 + .limit stack 1 + aload_0 + areturn +.end method + +.method public static main([Ljava/lang/String;)V + .limit locals 1 + .limit stack 2 + aload_0 + iconst_0 + aaload + invokestatic jode/test/EvilTypes/test(Ljava/lang/String;)Ljava/lang/Runnable; + invokeinterface java/lang/Runnable/run()V 1 + return +.end method diff --git a/jode/test/Expressions.java b/jode/test/Expressions.java new file mode 100644 index 0000000..247b46b --- /dev/null +++ b/jode/test/Expressions.java @@ -0,0 +1,73 @@ +package jode.test; +public class Expressions { + double cd; + float cf; + long cl; + int ci; + char cc; + short cs; + byte cb; + boolean cz; + + void postIncDecExpressions() { + cd++; + cf++; + cl++; + ci++; + cs++; + cb++; + cc++; + cd--; + cf--; + cl--; + ci--; + cs--; + cb--; + cc--; + float f = 0.0F; + double d = 0.0; + long l = 0L; + f++; + f--; + d++; + d--; + l++; + l--; + } + + + void unary() { + short s = 25; + s = (short) ~s; + boolean b = !true; + s = b? s: cs; + char c= 25; + c = b ? c: cc; + } + + void shift() { + int i = 0; + long l =0; + l >>= i; + l >>= i; + i >>= i; + l = l << l; + l = l << i; + l = i << l; + l = i << i; + i = (int) (l << l); + i = (int) (l << i); + i = i << l; + i = i << i; + cl >>= ci; + ci <<= ci; + cl = cl << cl; + cl = cl << ci; + cl = ci << cl; + cl = ci << ci; + ci = (int) (cl << cl); + ci = (int) (cl << ci); + ci = ci << cl; + ci = ci << ci; + } +} diff --git a/jode/test/StackOps.j b/jode/test/StackOps.j new file mode 100644 index 0000000..332fa29 --- /dev/null +++ b/jode/test/StackOps.j @@ -0,0 +1,41 @@ +; This class contains evil stack operations, that make it very hard to +; produce correct code. + +.class public jode/test/StackOps +.super java/lang/Object + +.method public static concatSwaped(ZLjava/lang/String;Ljava/lang/String;)Ljava/lang/String; + .limit locals 3 + .limit stack 3 + aload_1 + aload_2 + iload 0 + ifeq dontswap + swap +dontswap: + invokevirtual java/lang/String/concat(Ljava/lang/String;)Ljava/lang/String; + areturn +.end method + +.method public static dupTest(Ljava/lang/String;)Ljava/lang/String; + .limit locals 1 + .limit stack 2 + ; first a simple test that we can resolve + aload_0 + dup + invokevirtual java/lang/String/concat(Ljava/lang/String;)Ljava/lang/String; + ; now concat again. + dup + invokevirtual java/lang/String/concat(Ljava/lang/String;)Ljava/lang/String; + ; Now a more evil test. + aload_0 + swap + ifnull pushagain + dup + goto concat +pushagain: + aload_0 +concat: + invokevirtual java/lang/String/concat(Ljava/lang/String;)Ljava/lang/String; + areturn +.end method