Refactoring in the unit test utility framework:
* Moved unit test utilities to the onlab-junit package under utils/junit
- ImmutableClassChecker
- TestUtils and TestUtilsTest
* Added/ported unit test utilities from the older code
- UtilityClassChecker and UtilityClassCheckerTest
- ImmutableClassCheckerTest
* Updated/fixed some of the pom.xml files in the context of the
onlab-junit package:
- Added <scope>test</scope>
- Replaced hard-coded "1.0.0-SNAPSHOT" with "${project.version}"
Change-Id: Ie5f51ba401ca1748340f38848ab6bfc251964adc
diff --git a/utils/junit/src/test/java/org/onlab/junit/ImmutableClassCheckerTest.java b/utils/junit/src/test/java/org/onlab/junit/ImmutableClassCheckerTest.java
new file mode 100644
index 0000000..b4a6ff5
--- /dev/null
+++ b/utils/junit/src/test/java/org/onlab/junit/ImmutableClassCheckerTest.java
@@ -0,0 +1,120 @@
+package org.onlab.junit;
+
+import org.junit.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.is;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Set of unit tests to check the implementation of the immutable class
+ * checker.
+ */
+public class ImmutableClassCheckerTest {
+ /**
+ * Test class for non final class check.
+ */
+ // CHECKSTYLE IGNORE FinalClass FOR NEXT 1 LINES
+ static class NonFinal {
+ private NonFinal() { }
+ }
+
+ /**
+ * Check that a non final class correctly produces an error.
+ * @throws Exception if any of the reflection lookups fail.
+ */
+ @Test
+ public void testNonFinalClass() throws Exception {
+ boolean gotException = false;
+ try {
+ assertThatClassIsImmutable(NonFinal.class);
+ } catch (AssertionError assertion) {
+ assertThat(assertion.getMessage(),
+ containsString("is not final"));
+ gotException = true;
+ }
+ assertThat(gotException, is(true));
+ }
+
+ /**
+ * Test class for non private member class check.
+ */
+ static final class FinalProtectedMember {
+ protected final int x = 0;
+ }
+
+ /**
+ * Check that a final class with a non-private member is properly detected.
+ *
+ * @throws Exception if any of the reflection lookups fail.
+ */
+ @Test
+ public void testFinalProtectedMember() throws Exception {
+ boolean gotException = false;
+ try {
+ assertThatClassIsImmutable(FinalProtectedMember.class);
+ } catch (AssertionError assertion) {
+ assertThat(assertion.getMessage(),
+ containsString("a field named 'x' that is not private"));
+ gotException = true;
+ }
+ assertThat(gotException, is(true));
+ }
+
+ /**
+ * Test class for non private member class check.
+ */
+ static final class NotFinalPrivateMember {
+ private int x = 0;
+ }
+
+ /**
+ * Check that a final class with a non-final private
+ * member is properly detected.
+ *
+ * @throws Exception if any of the reflection lookups fail.
+ */
+ @Test
+ public void testNotFinalPrivateMember() throws Exception {
+ boolean gotException = false;
+ try {
+ assertThatClassIsImmutable(NotFinalPrivateMember.class);
+ } catch (AssertionError assertion) {
+ assertThat(assertion.getMessage(),
+ containsString("a field named 'x' that is not final"));
+ gotException = true;
+ }
+ assertThat(gotException, is(true));
+ }
+
+ /**
+ * Test class for non private member class check.
+ */
+ static final class ClassWithSetter {
+ private final int x = 0;
+ public void setX(int newX) {
+ }
+ }
+
+ /**
+ * Check that a final class with a final private
+ * member that is modifyable by a setter is properly detected.
+ *
+ * @throws Exception if any of the reflection lookups fail.
+ */
+ @Test
+ public void testClassWithSetter() throws Exception {
+ boolean gotException = false;
+ try {
+ assertThatClassIsImmutable(ClassWithSetter.class);
+ } catch (AssertionError assertion) {
+ assertThat(assertion.getMessage(),
+ containsString("a class with a setter named 'setX'"));
+ gotException = true;
+ }
+ assertThat(gotException, is(true));
+ }
+
+}
+
diff --git a/utils/junit/src/test/java/org/onlab/junit/TestUtilsTest.java b/utils/junit/src/test/java/org/onlab/junit/TestUtilsTest.java
new file mode 100644
index 0000000..c57b351
--- /dev/null
+++ b/utils/junit/src/test/java/org/onlab/junit/TestUtilsTest.java
@@ -0,0 +1,170 @@
+package org.onlab.junit;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.junit.TestUtils.TestUtilsException;
+
+/**
+ * Test and usage examples for TestUtils.
+ */
+public class TestUtilsTest {
+
+ /**
+ * Test data.
+ */
+ private static final class TestClass {
+
+ @SuppressWarnings("unused")
+ private int privateField = 42;
+
+ @SuppressWarnings("unused")
+ protected int protectedField = 2501; // CHECKSTYLE IGNORE THIS LINE
+
+ /**
+ * Protected method with multiple argument.
+ *
+ * @param x simply returns
+ * @param y not used
+ * @return x
+ */
+ @SuppressWarnings("unused")
+ private int privateMethod(Number x, Long y) {
+ return x.intValue();
+ }
+
+ /**
+ * Protected method with no argument.
+ *
+ * @return int
+ */
+ @SuppressWarnings("unused")
+ protected int protectedMethod() {
+ return 42;
+ }
+
+ /**
+ * Method returning array.
+ *
+ * @param ary random array
+ * @return ary
+ */
+ @SuppressWarnings("unused")
+ private int[] arrayReturnMethod(int[] ary) {
+ return ary;
+ }
+
+ /**
+ * Method without return value.
+ *
+ * @param s ignored
+ */
+ @SuppressWarnings("unused")
+ private void voidMethod(String s) {
+ System.out.println(s);
+ }
+ }
+
+ private TestClass test;
+
+ /**
+ * Sets up the test fixture.
+ */
+ @Before
+ public void setUp() {
+ test = new TestClass();
+ }
+
+ /**
+ * Example to access private field.
+ *
+ * @throws TestUtilsException TestUtils error
+ */
+ @Test
+ public void testSetGetPrivateField() throws TestUtilsException {
+
+ assertEquals(42, TestUtils.getField(test, "privateField"));
+ TestUtils.setField(test, "privateField", 0xDEAD);
+ assertEquals(0xDEAD, TestUtils.getField(test, "privateField"));
+ }
+
+ /**
+ * Example to access protected field.
+ *
+ * @throws TestUtilsException TestUtils error
+ */
+ @Test
+ public void testSetGetProtectedField() throws TestUtilsException {
+
+ assertEquals(2501, TestUtils.getField(test, "protectedField"));
+ TestUtils.setField(test, "protectedField", 0xBEEF);
+ assertEquals(0xBEEF, TestUtils.getField(test, "protectedField"));
+ }
+
+ /**
+ * Example to call private method and multiple parameters.
+ * <p/>
+ * It also illustrates that paramTypes must match declared type,
+ * not the runtime types of arguments.
+ *
+ * @throws TestUtilsException TestUtils error
+ */
+ @Test
+ public void testCallPrivateMethod() throws TestUtilsException {
+
+ int result = TestUtils.callMethod(test, "privateMethod",
+ new Class<?>[] {Number.class, Long.class},
+ Long.valueOf(42), Long.valueOf(32));
+ assertEquals(42, result);
+ }
+
+ /**
+ * Example to call protected method and no parameters.
+ *
+ * @throws TestUtilsException TestUtils error
+ */
+ @Test
+ public void testCallProtectedMethod() throws TestUtilsException {
+
+ int result = TestUtils.callMethod(test, "protectedMethod",
+ new Class<?>[] {});
+ assertEquals(42, result);
+ }
+
+ /**
+ * Example to call method returning array.
+ * <p/>
+ * Note: It is not required to receive as Object.
+ * Following is just verifying it is not Boxed arrays.
+ *
+ * @throws TestUtilsException TestUtils error
+ */
+ @Test
+ public void testCallArrayReturnMethod() throws TestUtilsException {
+
+ int[] array = {1, 2, 3};
+ Object aryResult = TestUtils.callMethod(test, "arrayReturnMethod",
+ new Class<?>[] {int[].class}, array);
+ assertEquals(int[].class, aryResult.getClass());
+ assertArrayEquals(array, (int[]) aryResult);
+ }
+
+
+ /**
+ * Example to call void returning method.
+ * <p/>
+ * Note: Return value will be null for void methods.
+ *
+ * @throws TestUtilsException TestUtils error
+ */
+ @Test
+ public void testCallVoidReturnMethod() throws TestUtilsException {
+
+ Object voidResult = TestUtils.callMethod(test, "voidMethod",
+ String.class, "foobar");
+ assertNull(voidResult);
+ }
+}
diff --git a/utils/junit/src/test/java/org/onlab/junit/UtilityClassCheckerTest.java b/utils/junit/src/test/java/org/onlab/junit/UtilityClassCheckerTest.java
new file mode 100644
index 0000000..7f56d81
--- /dev/null
+++ b/utils/junit/src/test/java/org/onlab/junit/UtilityClassCheckerTest.java
@@ -0,0 +1,145 @@
+package org.onlab.junit;
+
+import org.junit.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.is;
+import static org.onlab.junit.UtilityClassChecker.assertThatClassIsUtility;
+
+/**
+ * Set of unit tests to check the implementation of the utility class
+ * checker.
+ */
+public class UtilityClassCheckerTest {
+
+ // CHECKSTYLE:OFF test data intentionally not final
+ /**
+ * Test class for non final class check.
+ */
+ static class NonFinal {
+ private NonFinal() { }
+ }
+ // CHECKSTYLE:ON
+
+ /**
+ * Check that a non final class correctly produces an error.
+ * @throws Exception if any of the reflection lookups fail.
+ */
+ @Test
+ public void testNonFinalClass() throws Exception {
+ boolean gotException = false;
+ try {
+ assertThatClassIsUtility(NonFinal.class);
+ } catch (AssertionError assertion) {
+ assertThat(assertion.getMessage(),
+ containsString("is not final"));
+ gotException = true;
+ }
+ assertThat(gotException, is(true));
+ }
+
+ /**
+ * Test class for final no constructor class check.
+ */
+ static final class FinalNoConstructor {
+ }
+
+ /**
+ * Check that a final class with no declared constructor correctly produces
+ * an error. In this case, the compiler generates a default constructor
+ * for you, but the constructor is 'protected' and will fail the check.
+ *
+ * @throws Exception if any of the reflection lookups fail.
+ */
+ @Test
+ public void testFinalNoConstructorClass() throws Exception {
+ boolean gotException = false;
+ try {
+ assertThatClassIsUtility(FinalNoConstructor.class);
+ } catch (AssertionError assertion) {
+ assertThat(assertion.getMessage(),
+ containsString("class with a default constructor that " +
+ "is not private"));
+ gotException = true;
+ }
+ assertThat(gotException, is(true));
+ }
+
+ /**
+ * Test class for class with more than one constructor check.
+ */
+ static final class TwoConstructors {
+ private TwoConstructors() { }
+ private TwoConstructors(int x) { }
+ }
+
+ /**
+ * Check that a non static class correctly produces an error.
+ * @throws Exception if any of the reflection lookups fail.
+ */
+ @Test
+ public void testOnlyOneConstructor() throws Exception {
+ boolean gotException = false;
+ try {
+ assertThatClassIsUtility(TwoConstructors.class);
+ } catch (AssertionError assertion) {
+ assertThat(assertion.getMessage(),
+ containsString("more than one constructor"));
+ gotException = true;
+ }
+ assertThat(gotException, is(true));
+ }
+
+ /**
+ * Test class with a non private constructor.
+ */
+ static final class NonPrivateConstructor {
+ protected NonPrivateConstructor() { }
+ }
+
+ /**
+ * Check that a class with a non private constructor correctly
+ * produces an error.
+ * @throws Exception if any of the reflection lookups fail.
+ */
+ @Test
+ public void testNonPrivateConstructor() throws Exception {
+
+ boolean gotException = false;
+ try {
+ assertThatClassIsUtility(NonPrivateConstructor.class);
+ } catch (AssertionError assertion) {
+ assertThat(assertion.getMessage(),
+ containsString("constructor that is not private"));
+ gotException = true;
+ }
+ assertThat(gotException, is(true));
+ }
+
+ /**
+ * Test class with a non static method.
+ */
+ static final class NonStaticMethod {
+ private NonStaticMethod() { }
+ public void aPublicMethod() { }
+ }
+
+ /**
+ * Check that a class with a non static method correctly produces an error.
+ * @throws Exception if any of the reflection lookups fail.
+ */
+ @Test
+ public void testNonStaticMethod() throws Exception {
+
+ boolean gotException = false;
+ try {
+ assertThatClassIsUtility(NonStaticMethod.class);
+ } catch (AssertionError assertion) {
+ assertThat(assertion.getMessage(),
+ containsString("one or more non-static methods"));
+ gotException = true;
+ }
+ assertThat(gotException, is(true));
+ }
+}