From 789074e6a0fb44a75499bf9f50369348278b223c Mon Sep 17 00:00:00 2001
From: neil_a_wilson <neil_a_wilson@localhost>
Date: Mon, 11 Sep 2006 14:32:05 +0000
Subject: [PATCH] Update ASN.1 test cases for the integer, long, enumerated, Boolean, and null element types.
---
opends/tests/unit-tests-testng/src/server/org/opends/server/protocols/asn1/TestASN1Boolean.java | 512 ++++++++++++++++++++++++++++++++++++++++++++++----------
1 files changed, 416 insertions(+), 96 deletions(-)
diff --git a/opends/tests/unit-tests-testng/src/server/org/opends/server/protocols/asn1/TestASN1Boolean.java b/opends/tests/unit-tests-testng/src/server/org/opends/server/protocols/asn1/TestASN1Boolean.java
index 67a2793..9f0b626 100644
--- a/opends/tests/unit-tests-testng/src/server/org/opends/server/protocols/asn1/TestASN1Boolean.java
+++ b/opends/tests/unit-tests-testng/src/server/org/opends/server/protocols/asn1/TestASN1Boolean.java
@@ -26,128 +26,448 @@
*/
package org.opends.server.protocols.asn1;
-import static org.testng.AssertJUnit.assertEquals;
-import static org.testng.AssertJUnit.assertFalse;
-import static org.testng.AssertJUnit.assertTrue;
+
+import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
+import static org.testng.Assert.*;
+
+
+
/**
* This class defines a set of tests for the
* org.opends.server.protocols.asn1.ASN1Boolean class.
*/
-public class TestASN1Boolean extends ASN1TestCase {
+public class TestASN1Boolean
+ extends ASN1TestCase
+{
+ /**
+ * Retrieves the set of boolean values that may be used for testing.
+ *
+ * @return The set of boolean values that may be used for testing.
+ */
+ @DataProvider(name = "booleanValues")
+ public Object[][] getBooleanValues()
+ {
+ return new Object[][]
+ {
+ new Object[] { false },
+ new Object[] { true }
+ };
+ }
+
+
+
+ /**
+ * Tests the first constructor, which takes a single boolean argument.
+ *
+ * @param b The boolean value to use in the test.
+ */
+ @Test(dataProvider = "booleanValues")
+ public void testConstructor1(boolean b)
+ {
+ new ASN1Boolean(b);
+ }
+
+
+
+ /**
+ * Tests the second constructor, which takes byte and boolean arguments.
+ *
+ * @param b The boolean value to use in the test.
+ */
+ @Test(dataProvider = "booleanValues")
+ public void testConstructor2(boolean b)
+ {
+ new ASN1Boolean((byte) 0x50, b);
+ }
+
+
+
/**
* Tests the <CODE>booleanValue</CODE> method.
+ *
+ * @param b The boolean value to use in the test.
*/
- @Test
- public void testBooleanValue() {
- assertTrue(new ASN1Boolean(true).booleanValue());
-
- assertFalse(new ASN1Boolean(false).booleanValue());
+ @Test(dataProvider = "booleanValues")
+ public void testBooleanValue(boolean b)
+ {
+ assertEquals(b, new ASN1Boolean(b).booleanValue());
}
+
+
/**
- * Tests the <CODE>setValue</CODE> method that takes a boolean
- * argument.
+ * Tests the <CODE>setValue</CODE> method that takes a boolean argument.
+ *
+ * @param b The boolean value to use in the test.
*/
- @Test(dependsOnMethods = { "testBooleanValue" })
- public void testSetBooleanValue() {
- ASN1Boolean element = new ASN1Boolean(true); // Create a new true
- // element.
-
- element.setValue(true); // Test setting the same value.
- assertTrue(element.booleanValue());
-
- element.setValue(false); // Test setting the opposite value.
- assertFalse(element.booleanValue());
-
- element = new ASN1Boolean(false); // Create a new false element.
-
- element.setValue(false); // Test setting the same value.
- assertFalse(element.booleanValue());
-
- element.setValue(true); // Test setting the opposite value.
- assertTrue(element.booleanValue());
+ @Test(dataProvider = "booleanValues")
+ public void testSetBooleanValue(boolean b)
+ {
+ ASN1Boolean booleanElement = new ASN1Boolean(!b);
+ booleanElement.setValue(b);
+ assertEquals(b, booleanElement.booleanValue());
}
+
+
/**
- * Tests the <CODE>setValue</CODE> method that takes a byte array
+ * Retrieves the set of byte array values that may be used for testing.
+ *
+ * @return The set of byte array values that may be used for testing.
+ */
+ @DataProvider(name = "byteValues")
+ public Object[][] getByteValues()
+ {
+ Object[][] array = new Object[256][1];
+ for (int i=0; i < 256; i++)
+ {
+ array[i] = new Object[] { new byte[] { (byte) (i & 0xFF) } };
+ }
+
+ return array;
+ }
+
+
+
+ /**
+ * Tests the <CODE>setValue</CODE> method that takes a byte array argument
+ * with valid values.
+ *
+ * @param b The byte array to use in the test.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(dataProvider = "byteValues")
+ public void testSetValidByteValue(byte[] b)
+ throws Exception
+ {
+ ASN1Boolean booleanElement = new ASN1Boolean(false);
+ booleanElement.setValue(b);
+ assertEquals((b[0] != 0x00), booleanElement.booleanValue());
+ }
+
+
+
+ /**
+ * Tests the <CODE>setValue</CODE> method that takes a byte array argument
+ * with a null value.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(expectedExceptions = { ASN1Exception.class })
+ public void testSetNullByteValue()
+ throws Exception
+ {
+ ASN1Boolean booleanElement = new ASN1Boolean(false);
+ byte[] b = null;
+ booleanElement.setValue(b);
+ }
+
+
+
+ /**
+ * Tests the <CODE>setValue</CODE> method that takes a byte array argument
+ * with an empty array value.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(expectedExceptions = { ASN1Exception.class })
+ public void testSetZeroByteValue()
+ throws Exception
+ {
+ ASN1Boolean booleanElement = new ASN1Boolean(false);
+ byte[] b = new byte[0];
+ booleanElement.setValue(b);
+ }
+
+
+
+ /**
+ * Tests the <CODE>setValue</CODE> method that takes a byte array argument
+ * with a multi-byte array value.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(expectedExceptions = { ASN1Exception.class })
+ public void testSetMultiByteValue()
+ throws Exception
+ {
+ ASN1Boolean booleanElement = new ASN1Boolean(false);
+ byte[] b = new byte[2];
+ booleanElement.setValue(b);
+ }
+
+
+
+ /**
+ * Tests the <CODE>decodeAsBoolean</CODE> method that takes an ASN1Element
+ * argument with valid elements.
+ *
+ * @param b The byte array to use for the element values.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(dataProvider = "byteValues")
+ public void testDecodeValidElementAsBoolean(byte[] b)
+ throws Exception
+ {
+ // First, try with an actual boolean element.
+ ASN1Element e = new ASN1Boolean(false);
+ e.setValue(b);
+ ASN1Boolean booleanElement = ASN1Boolean.decodeAsBoolean(e);
+ assertEquals((b[0] != 0x00), booleanElement.booleanValue());
+
+ e = new ASN1Boolean((byte) 0x50, false);
+ e.setValue(b);
+ booleanElement = ASN1Boolean.decodeAsBoolean(e);
+ assertEquals((b[0] != 0x00), booleanElement.booleanValue());
+
+
+ // Next, test with a generic ASN.1 element.
+ e = new ASN1Element(ASN1Constants.UNIVERSAL_BOOLEAN_TYPE, b);
+ booleanElement = ASN1Boolean.decodeAsBoolean(e);
+ assertEquals((b[0] != 0x00), booleanElement.booleanValue());
+
+ e = new ASN1Element((byte) 0x50, b);
+ booleanElement = ASN1Boolean.decodeAsBoolean(e);
+ assertEquals((b[0] != 0x00), booleanElement.booleanValue());
+ }
+
+
+
+ /**
+ * Tests the <CODE>decodeAsBoolean</CODE> method that takes an ASN1Element
+ * argument with a null element.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(expectedExceptions = { ASN1Exception.class })
+ public void testDecodeNullElementAsBoolean()
+ throws Exception
+ {
+ ASN1Element e = null;
+ ASN1Boolean.decodeAsBoolean(e);
+ }
+
+
+
+ /**
+ * Tests the <CODE>decodeAsBoolean</CODE> method that takes an ASN1Element
+ * argument with a zero-byte element.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(expectedExceptions = { ASN1Exception.class })
+ public void testDecodeZeroByteElementAsBoolean()
+ throws Exception
+ {
+ ASN1Element e = new ASN1Element((byte) 0x50, new byte[0]);
+ ASN1Boolean.decodeAsBoolean(e);
+ }
+
+
+
+ /**
+ * Tests the <CODE>decodeAsBoolean</CODE> method that takes an ASN1Element
+ * argument with a multi-byte element.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(expectedExceptions = { ASN1Exception.class })
+ public void testDecodeMultiByteElementAsBoolean()
+ throws Exception
+ {
+ ASN1Element e = new ASN1Element((byte) 0x50, new byte[2]);
+ ASN1Boolean.decodeAsBoolean(e);
+ }
+
+
+
+ /**
+ * Tests the <CODE>decodeAsBoolean</CODE> method that takes a byte array
+ * argument with valid arrays.
+ *
+ * @param b The byte array to use for the element values.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(dataProvider = "byteValues")
+ public void testDecodeValidArrayAsBoolean(byte[] b)
+ throws Exception
+ {
+ // First, test with the standard Boolean type.
+ byte[] elementArray = new byte[] { 0x01, 0x01, b[0] };
+ ASN1Boolean booleanElement = ASN1Boolean.decodeAsBoolean(elementArray);
+ assertEquals((b[0] != 0x00), booleanElement.booleanValue());
+
+
+ // Next, test with a nonstandard Boolean type.
+ elementArray[0] = (byte) 0x50;
+ booleanElement = ASN1Boolean.decodeAsBoolean(elementArray);
+ assertEquals((b[0] != 0x00), booleanElement.booleanValue());
+ }
+
+
+
+ /**
+ * Tests the <CODE>decodeAsBoolean</CODE> method that takes a byte array
+ * argument with valid arrays using extended lengths.
+ *
+ * @param b The byte array to use for the element values.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(dataProvider = "byteValues")
+ public void testDecodeValidExtendedArrayAsBoolean(byte[] b)
+ throws Exception
+ {
+ // First, test with the standard Boolean type.
+ byte[] elementArray = new byte[] { 0x01, (byte) 0x81, 0x01, b[0] };
+ ASN1Boolean booleanElement = ASN1Boolean.decodeAsBoolean(elementArray);
+ assertEquals((b[0] != 0x00), booleanElement.booleanValue());
+
+
+ // Next, test with a nonstandard Boolean type.
+ elementArray[0] = (byte) 0x50;
+ booleanElement = ASN1Boolean.decodeAsBoolean(elementArray);
+ assertEquals((b[0] != 0x00), booleanElement.booleanValue());
+ }
+
+
+
+ /**
+ * Tests the <CODE>decodeAsBoolean</CODE> method that takes a byte array
+ * argument with a null array.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(expectedExceptions = { ASN1Exception.class })
+ public void testDecodeNullArrayAsBoolean()
+ throws Exception
+ {
+ byte[] b = null;
+ ASN1Boolean.decodeAsBoolean(b);
+ }
+
+
+
+ /**
+ * Tests the <CODE>decodeAsBoolean</CODE> method that takes a byte array
+ * argument with a short array.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(expectedExceptions = { ASN1Exception.class })
+ public void testDecodeShortArrayAsBoolean()
+ throws Exception
+ {
+ byte[] b = new byte[1];
+ ASN1Boolean.decodeAsBoolean(b);
+ }
+
+
+
+ /**
+ * Tests the <CODE>decodeAsBoolean</CODE> method that takes a byte array
+ * argument with an array that takes too many bytes to expressthe length.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(expectedExceptions = { ASN1Exception.class })
+ public void testDecodeLongLengthArrayAsBoolean()
+ throws Exception
+ {
+ byte[] b = { 0x01, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 };
+ ASN1Boolean.decodeAsBoolean(b);
+ }
+
+
+
+ /**
+ * Tests the <CODE>decodeAsBoolean</CODE> method that takes a byte array
+ * argument with an array that doesn't contain a full length.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(expectedExceptions = { ASN1Exception.class })
+ public void testDecodeTruncatedLengthArrayAsBoolean()
+ throws Exception
+ {
+ byte[] b = { 0x01, (byte) 0x82, 0x00 };
+ ASN1Boolean.decodeAsBoolean(b);
+ }
+
+
+
+ /**
+ * Tests the <CODE>decodeAsBoolean</CODE> method that takes a byte array
+ * argument with an array that has more bytes than indicated by the length.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(expectedExceptions = { ASN1Exception.class })
+ public void testDecodeLengthMismatchArrayAsBoolean()
+ throws Exception
+ {
+ byte[] b = { 0x01, 0x01, 0x00, 0x00 };
+ ASN1Boolean.decodeAsBoolean(b);
+ }
+
+
+
+ /**
+ * Tests the <CODE>decodeAsBoolean</CODE> method that takes a byte array
+ * argument with an array that has an invalid number of bytes in the value.
+ *
+ * @throws Exception If an unexpected problem occurs.
+ */
+ @Test(expectedExceptions = { ASN1Exception.class })
+ public void testDecodeLongValueArrayAsBoolean()
+ throws Exception
+ {
+ byte[] b = { 0x01, 0x02, 0x00, 0x00 };
+ ASN1Boolean.decodeAsBoolean(b);
+ }
+
+
+
+ /**
+ * Tests the first <CODE>toString</CODE> method which takes a string builder
* argument.
*
- * @throws Exception
- * If the test failed unexpectedly.
+ * @param b The byte array to use as the element value.
+ *
+ * @throws Exception If an unexpected problem occurs.
*/
- @Test(dependsOnMethods = { "testBooleanValue" })
- public void testSetByteValue() throws Exception {
- ASN1Boolean element = new ASN1Boolean(true);
-
- element.setValue(new byte[] { 0x00 });
- assertFalse(element.booleanValue());
-
- // Test setting the value to all other possible byte
- // representations, which
- // should evaluate to "true".
- for (int i = 1; i < 256; i++) {
- byte byteValue = (byte) (i & 0xFF);
-
- element.setValue(new byte[] { byteValue });
- assertTrue(element.booleanValue());
- }
+ @Test(dataProvider = "byteValues")
+ public void testToString1(byte[] b)
+ throws Exception
+ {
+ ASN1Boolean booleanElement = new ASN1Boolean(false);
+ booleanElement.setValue(b);
+ booleanElement.toString(new StringBuilder());
}
- /**
- * Tests the <CODE>decodeAsBoolean</CODE> method that takes an ASN.1
- * element argument.
- *
- * @throws Exception
- * If the test failed unexpectedly.
- */
- @Test(dependsOnMethods = { "testBooleanValue" })
- public void testDecodeElementAsBoolean() throws Exception {
- // Test a boolean element of "true".
- ASN1Boolean trueBoolean = new ASN1Boolean(true);
- assertTrue(ASN1Boolean.decodeAsBoolean(trueBoolean).booleanValue());
- // Test a boolean element of "false".
- ASN1Boolean falseBoolean = new ASN1Boolean(false);
- assertFalse(ASN1Boolean.decodeAsBoolean(falseBoolean).booleanValue());
-
- // Test the valid generic elements that may be used.
- for (int i = 0; i < 256; i++) {
- byte byteValue = (byte) (i & 0xFF);
- boolean compareValue = (i != 0);
-
- ASN1Element element = new ASN1Element((byte) 0x00,
- new byte[] { byteValue });
-
- assertEquals(compareValue, ASN1Boolean.decodeAsBoolean(element)
- .booleanValue());
- }
- }
/**
- * Tests the <CODE>decodeAsBoolean</CODE> method that takes a byte
- * array argument.
+ * Tests the second <CODE>toString</CODE> method which takes string builder
+ * and integer arguments.
*
- * @throws Exception
- * If the test failed unexpectedly.
+ * @param b The byte array to use as the element value.
+ *
+ * @throws Exception If an unexpected problem occurs.
*/
- @Test(dependsOnMethods = { "testBooleanValue" })
- public void testDecodeBytesAsBoolean() throws Exception {
- byte[] encodedElement = new byte[] { 0x00, 0x01, 0x00 };
-
- // Test all possible byte values.
- for (int i = 0; i < 256; i++) {
- boolean compareValue = (i != 0);
-
- // Set the value.
- encodedElement[2] = (byte) (i & 0xFF);
-
- // Test with the standard Boolean type.
- encodedElement[0] = (byte) 0x01;
- assertEquals(compareValue, ASN1Boolean
- .decodeAsBoolean(encodedElement).booleanValue());
- }
+ @Test(dataProvider = "byteValues")
+ public void testToString2(byte[] b)
+ throws Exception
+ {
+ ASN1Boolean booleanElement = new ASN1Boolean(false);
+ booleanElement.setValue(b);
+ booleanElement.toString(new StringBuilder(), 1);
}
}
+
--
Gitblit v1.10.0