1 files changed, 235 insertions, 0 deletions
diff --git a/tests/pureJava/AssertInOnePackage.java b/tests/pureJava/AssertInOnePackage.java
new file mode 100644
index 000000000..3d822680e
--- /dev/null
+++ b/tests/pureJava/AssertInOnePackage.java
@@ -0,0 +1,235 @@
+// attempts to be a comprehensive test of assert statements that have
+// only intra-package behaviour.
+
+import org.aspectj.testing.Tester;
+
+public class AssertInOnePackage {
+    public static void main(String[] args) {
+	turnOnAssertions();
+	runTests();
+    }
+
+    // we first turn on assertions.  This is run _before_ any other
+    // method is run, so the only classes that are loaded are
+    // AssertInOnePackage.
+    static void turnOnAssertions() {
+	ClassLoader cl = AssertInOnePackage.class.getClassLoader();
+
+	cl.setClassAssertionStatus("StaticInitializerOnHelper", true);
+	cl.setClassAssertionStatus("StaticInitializerOffHelper", false);
+
+	cl.setClassAssertionStatus("ConstructorOnHelper", true);
+	cl.setClassAssertionStatus("ConstructorOffHelper", false);
+
+	cl.setClassAssertionStatus("InnerStaticInitializerOnHelper", true);
+	cl.setClassAssertionStatus("InnerStaticInitializerOffHelper", false);
+
+	cl.setClassAssertionStatus("InnerStaticInitializerOnHelperI", true);
+	cl.setClassAssertionStatus("InnerStaticInitializerOffHelperI", false);
+
+	cl.setClassAssertionStatus("CycleSubOn", true);
+	cl.setClassAssertionStatus("CycleSubOff", false);
+
+    }
+
+    // In the following tests, the assignment to the static field
+    // translates into a putstatic bytecode, which, by section 5.5 of
+    // the JVM spec, will initialize the class.
+    static void runTests() {
+
+	check(true,
+	      "static initializer should throw",
+	      new Runnable() {
+		  void run() { StaticInitializerOnHelper.x = 3; }
+	      });
+	check(false,
+	      "static initializer should not throw",
+	      new Runnable() {
+		  void run() { StaticInitializerOffHelper.x = 3; }
+	      });
+
+	check(true,
+	      "constructor should throw",
+	      new Runnable() {
+		  void pre() { ConstructorOnHelper.x = 3; }
+		  void run() { new ConstructorOnHelper(); }
+
+	      });
+	check(false,
+	      "static initializer should not throw",
+	      new Runnable() {
+		  void pre() { ConstructorOffHelper.x = 3; }
+		  void run() { new ConstructorOffHelper(); }
+	      });
+
+	check(true,
+	      "inner static initializer should throw",
+	      new Runnable() {
+		  void run() { InnerStaticInitializerOnHelper.Inner.x = 3; }
+	      });
+	check(false,
+	      "inner static initializer should not throw",
+	      new Runnable() {
+		  void run() { InnerStaticInitializerOffHelper.Inner.x = 3; }
+	      });
+
+	check(true,
+	      "inner static initializer of interface should throw",
+	      new Runnable() {
+		  void run() { InnerStaticInitializerOnHelperI.Inner.x = 3; }
+	      });
+	check(false,
+	      "inner static initializer of interface should not throw",
+	      new Runnable() {
+		  void run() { InnerStaticInitializerOffHelperI.Inner.x = 3; }
+	      });
+
+
+	check(true,
+	      "static initializer in cyclic should throw",
+	      new Runnable() {
+		  void run() { CycleSubOn.x = 3; }
+	      });
+	check(true,
+	      "static initializer in cyclic should always throw",
+	      new Runnable() {
+		  void run() { CycleSubOff.x = 3; }
+	      });
+
+    }
+
+
+    static void check(boolean shouldThrow, String message, Runnable r) {
+	r.pre();
+	boolean threw = false;
+	try {
+	    r.run();
+	} catch (AssertionError e) {
+	    threw = true;
+	}
+	if (threw != shouldThrow) {
+	    //System.err.println(message);
+	    Tester.check(false, message);
+	}
+	r.post();
+    }
+
+    static class Runnable {
+	void pre() {}
+	void run() {}
+	void post() {}
+    }
+}
+
+// ------------------------------
+
+// Asserts in a static initializer of a class
+
+class StaticInitializerOnHelper {
+    static int x;
+    static {
+	assert false;
+    }
+}
+
+class StaticInitializerOffHelper {
+    static int x;
+    static {
+	assert false;
+    }
+}
+
+// ------------------------------
+
+// Asserts in a constructor of a class.  This stands in for all
+// "normal" assertion, so I'm not going to bother writing asserts in
+// other post-class-initialization contexts.
+
+class ConstructorOnHelper {
+    static int x;
+    ConstructorOnHelper() {
+	assert false;
+    }
+}
+
+class ConstructorOffHelper {
+    static int x;
+    ConstructorOffHelper() {
+	assert false;
+    }
+}
+
+// ------------------------------
+
+// Asserts in a static initializer of an inner class.
+
+class InnerStaticInitializerOnHelper {
+    static class Inner {
+	static int x;
+	static {
+	    assert false;
+	}
+    }
+}
+
+class InnerStaticInitializerOffHelper {
+    static class Inner {
+	static int x;
+	static {
+	    assert false;
+	}
+    }
+}
+
+// ------------------------------
+
+// Asserts in a static initializer of an inner class of an interface.
+
+interface InnerStaticInitializerOnHelperI {
+    static class Inner {
+	static int x;
+	static {
+	    assert false;
+	}
+    }
+}
+
+interface InnerStaticInitializerOffHelperI {
+    static class Inner {
+	static int x;
+	static {
+	    assert false;
+	}
+    }
+}
+
+
+// ------------------------------
+
+// Asserts in the subclass called in an initialization inversion
+
+class CycleSuperOn {
+    static {
+	CycleSubOn.foo();
+    }
+}
+class CycleSubOn extends CycleSuperOn {
+    static int x;
+    static void foo() {
+	assert false;
+    }
+}
+
+class CycleSuperOff {
+    static {
+	CycleSubOff.foo();
+    }
+}
+class CycleSubOff extends CycleSuperOff {
+    static int x;
+    static void foo() {
+	assert false;
+    }
+}
+
+