/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
|
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
|
* add the following below this CDDL HEADER, with the fields enclosed
|
* by brackets "[]" replaced with your own identifying * information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Portions Copyright 2006 Sun Microsystems, Inc.
|
*/
|
package org.opends.server.protocols.asn1;
|
|
import static org.opends.server.util.StaticUtils.listsAreEqual;
|
import static org.testng.AssertJUnit.assertEquals;
|
import static org.testng.AssertJUnit.assertFalse;
|
import static org.testng.AssertJUnit.assertTrue;
|
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
|
import org.testng.annotations.Configuration;
|
import org.testng.annotations.Test;
|
|
/**
|
* This class defines a set of tests for the
|
* org.opends.server.protocols.asn1.ASN1Element class.
|
*/
|
public class TestASN1Element extends ASN1TestCase {
|
// The sets of pre-encoded ASN.1 elements that will be included in the
|
// test
|
// case.
|
private ArrayList<ArrayList<ASN1Element>> testElementSets;
|
|
// The set of pre-encoded element sets that will be used in the test
|
// cases.
|
private ArrayList<byte[]> testEncodedElementSets;
|
|
// The set of pre-encoded integer values that will be included in the
|
// test
|
// cases.
|
private ArrayList<byte[]> testEncodedIntegers;
|
|
// The set of pre-encoded lengths that will be included in the test
|
// cases.
|
private ArrayList<byte[]> testEncodedLengths;
|
|
// The set of BER types that will be included in the test cases.
|
private ArrayList<Byte> testTypes;
|
|
// The set of element values that will be included in the test cases.
|
private ArrayList<byte[]> testValues;
|
|
// The set of integer values that will be included in the test cases.
|
private ArrayList<Integer> testIntegers;
|
|
// The set of lengths that will be included in the test cases.
|
private ArrayList<Integer> testLengths;
|
|
/**
|
* Performs any necessary initialization for this test case.
|
*/
|
@Configuration(beforeTestClass = true)
|
public void setUp() {
|
// Initialize the set of types. It will encapsulate the entire range
|
// of
|
// possible byte values.
|
testTypes = new ArrayList<Byte>();
|
for (int i = 0; i < 0xFF; i++) {
|
testTypes.add((byte) (i & 0xFF));
|
}
|
|
// Initialize the set of values. Don't make these too big since they
|
// consume memory.
|
testValues = new ArrayList<byte[]>();
|
testValues.add(null); // The null value.
|
testValues.add(new byte[0x00]); // The zero-byte value.
|
testValues.add(new byte[0x01]); // The single-byte value.
|
testValues.add(new byte[0x7F]); // The largest 1-byte length
|
// encoding.
|
testValues.add(new byte[0x80]);
|
testValues.add(new byte[0xFF]); // The largest 2-byte length
|
// encoding.
|
testValues.add(new byte[0x0100]);
|
testValues.add(new byte[0xFFFF]); // The largest 3-byte length
|
// encoding.
|
testValues.add(new byte[0x010000]);
|
|
// Initialize the set of element lengths and their pre-encoded
|
// representations. Don't make these too big since we will create
|
// arrays
|
// with these lengths during testing.
|
testLengths = new ArrayList<Integer>();
|
testEncodedLengths = new ArrayList<byte[]>();
|
|
testLengths.add(0x00); // The zero-byte length.
|
testEncodedLengths.add(new byte[] { (byte) 0x00 });
|
|
testLengths.add(0x01); // A common 1-byte length.
|
testEncodedLengths.add(new byte[] { (byte) 0x01 });
|
|
testLengths.add(0x7F); // The largest 1-byte length encoding.
|
testEncodedLengths.add(new byte[] { (byte) 0x7F });
|
|
testLengths.add(0x80); // The smallest length that must use 2
|
// bytes.
|
testEncodedLengths.add(new byte[] { (byte) 0x81, (byte) 0x80 });
|
|
testLengths.add(0xFF); // The largest length that may use 2 bytes.
|
testEncodedLengths.add(new byte[] { (byte) 0x81, (byte) 0xFF });
|
|
testLengths.add(0x0100); // The smallest length that must use 3
|
// bytes.
|
testEncodedLengths.add(new byte[] { (byte) 0x82, (byte) 0x01,
|
(byte) 0x00 });
|
|
testLengths.add(0xFFFF); // The largest length that may use 3
|
// bytes.
|
testEncodedLengths.add(new byte[] { (byte) 0x82, (byte) 0xFF,
|
(byte) 0xFF });
|
|
testLengths.add(0x010000); // The smallest length that must use 4
|
// bytes.
|
testEncodedLengths.add(new byte[] { (byte) 0x83, (byte) 0x01,
|
(byte) 0x00, (byte) 0x00 });
|
|
// Initialize the set of integer values and their pre-encoded
|
// representations. These can get big since they will not be used to
|
// create
|
// arrays. Also, there is no need to test negative values since LDAP
|
// doesn't make use of them.
|
testIntegers = new ArrayList<Integer>();
|
testEncodedIntegers = new ArrayList<byte[]>();
|
|
testIntegers.add(0x00); // A common 1-byte encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x00 });
|
|
testIntegers.add(0x7F); // The largest 1-byte encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x7F });
|
|
testIntegers.add(0x80); // The smallest 2-byte encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x00, (byte) 0x80 });
|
|
testIntegers.add(0xFF); // A boundary case for 2-byte encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x00, (byte) 0xFF });
|
|
testIntegers.add(0x0100); // A boundary case for 2-byte encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x01, (byte) 0x00 });
|
|
testIntegers.add(0x7FFF); // The largest 2-byte encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x7F, (byte) 0xFF });
|
|
testIntegers.add(0x8000); // The smallest 3-byte encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x00, (byte) 0x80,
|
(byte) 0x00 });
|
|
testIntegers.add(0xFFFF); // A boundary case for 3-byte encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x00, (byte) 0xFF,
|
(byte) 0xFF });
|
|
testIntegers.add(0x010000); // A boundary case for 3-byte encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x01, (byte) 0x00,
|
(byte) 0x00 });
|
|
testIntegers.add(0x7FFFFF); // The largest 3-byte encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x7F, (byte) 0xFF,
|
(byte) 0xFF });
|
|
testIntegers.add(0x800000); // The smallest 4-byte encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x00, (byte) 0x80,
|
(byte) 0x00, (byte) 0x00 });
|
|
testIntegers.add(0xFFFFFF); // A boundary case for 4-byte encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x00, (byte) 0xFF,
|
(byte) 0xFF, (byte) 0xFF });
|
|
testIntegers.add(0x01000000); // A boundary case for 4-byte
|
// encoding.
|
testEncodedIntegers.add(new byte[] { (byte) 0x01, (byte) 0x00,
|
(byte) 0x00, (byte) 0x00 });
|
|
testIntegers.add(0x7FFFFFFF); // The largest value we will allow.
|
testEncodedIntegers.add(new byte[] { (byte) 0x7F, (byte) 0xFF,
|
(byte) 0xFF, (byte) 0xFF });
|
|
// Initialize the sets of ASN.1 elements that will be used in
|
// testing the
|
// group encode/decode operations.
|
testElementSets = new ArrayList<ArrayList<ASN1Element>>();
|
testEncodedElementSets = new ArrayList<byte[]>();
|
|
testElementSets.add(null); // The null set.
|
testEncodedElementSets.add(new byte[0]);
|
|
testElementSets.add(new ArrayList<ASN1Element>(0)); // The empty
|
// set.
|
testEncodedElementSets.add(new byte[0]);
|
|
// Sets containing from 1 to 10 elements.
|
for (int i = 1; i <= 10; i++) {
|
ArrayList<ASN1Element> elements = new ArrayList<ASN1Element>(i);
|
|
for (int j = 0; j < i; j++) {
|
elements.add(new ASN1Element((byte) 0x00));
|
}
|
testElementSets.add(elements);
|
testEncodedElementSets.add(new byte[i * 2]);
|
}
|
}
|
|
/**
|
* Tests the <CODE>getType</CODE> method.
|
*/
|
@Test()
|
public void testGetType() {
|
for (byte type : testTypes) {
|
ASN1Element element = new ASN1Element(type);
|
|
assertEquals(type, element.getType());
|
|
for (byte[] value : testValues) {
|
element = new ASN1Element(type, value);
|
|
assertEquals(type, element.getType());
|
}
|
}
|
}
|
|
/**
|
* Tests the <CODE>setType</CODE> method.
|
*/
|
@Test()
|
public void testSetType() {
|
ASN1Element element = new ASN1Element((byte) 0x00);
|
for (byte type : testTypes) {
|
element.setType(type);
|
|
assertEquals(type, element.getType());
|
}
|
}
|
|
/**
|
* Tests the <CODE>isUniversal</CODE> method.
|
*/
|
@Test()
|
public void testIsUniversal() {
|
ASN1Element element = new ASN1Element((byte) 0x00);
|
for (byte type : testTypes) {
|
element.setType(type);
|
boolean isUniversal = (((byte) (type & 0xC0)) == ((byte) 0x00));
|
|
assertEquals(isUniversal, element.isUniversal());
|
}
|
}
|
|
/**
|
* Tests the <CODE>isApplicationSpecific</CODE> method.
|
*/
|
@Test()
|
public void testIsApplicationSpecific() {
|
ASN1Element element = new ASN1Element((byte) 0x00);
|
for (byte type : testTypes) {
|
element.setType(type);
|
boolean isApplicationSpecific = (((byte) (type & 0xC0)) == ((byte) 0x40));
|
|
assertEquals(isApplicationSpecific, element.isApplicationSpecific());
|
}
|
}
|
|
/**
|
* Tests the <CODE>isContextSpecific</CODE> method.
|
*/
|
@Test()
|
public void testIsContextSpecific() {
|
ASN1Element element = new ASN1Element((byte) 0x00);
|
for (byte type : testTypes) {
|
element.setType(type);
|
boolean isContextSpecific = (((byte) (type & 0xC0)) == ((byte) 0x80));
|
|
assertEquals(isContextSpecific, element.isContextSpecific());
|
}
|
}
|
|
/**
|
* Tests the <CODE>isPrivate</CODE> method.
|
*/
|
@Test()
|
public void testIsPrivate() {
|
ASN1Element element = new ASN1Element((byte) 0x00);
|
for (byte type : testTypes) {
|
element.setType(type);
|
boolean isPrivate = (((byte) (type & 0xC0)) == ((byte) 0xC0));
|
|
assertEquals(isPrivate, element.isPrivate());
|
}
|
}
|
|
/**
|
* Tests the <CODE>isPrimitive</CODE> method.
|
*/
|
@Test()
|
public void testIsPrimitive() {
|
ASN1Element element = new ASN1Element((byte) 0x00);
|
for (byte type : testTypes) {
|
element.setType(type);
|
boolean isPrimitive = (((byte) (type & 0x20)) == ((byte) 0x00));
|
|
assertEquals(isPrimitive, element.isPrimitive());
|
}
|
}
|
|
/**
|
* Tests the <CODE>isConstructed</CODE> method.
|
*/
|
@Test()
|
public void testIsConstructed() {
|
ASN1Element element = new ASN1Element((byte) 0x00);
|
for (byte type : testTypes) {
|
element.setType(type);
|
boolean isConstructed = (((byte) (type & 0x20)) == ((byte) 0x20));
|
|
assertEquals(isConstructed, element.isConstructed());
|
}
|
}
|
|
/**
|
* Tests the <CODE>getValue</CODE> method.
|
*/
|
@Test()
|
public void testGetValue() {
|
for (byte type : testTypes) {
|
ASN1Element element = new ASN1Element(type);
|
|
assertTrue(Arrays.equals(new byte[0], element.value()));
|
|
for (byte[] value : testValues) {
|
element = new ASN1Element(type, value);
|
|
if (value == null) {
|
assertTrue(Arrays.equals(new byte[0], element.value()));
|
} else {
|
assertTrue(Arrays.equals(value, element.value()));
|
}
|
}
|
}
|
}
|
|
/**
|
* Tests the <CODE>setValue</CODE> method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testSetValue() throws Exception {
|
ASN1Element element = new ASN1Element((byte) 0x00);
|
|
for (byte[] value : testValues) {
|
element.setValue(value);
|
if (value == null) {
|
assertTrue(Arrays.equals(new byte[0], element.value()));
|
} else {
|
assertTrue(Arrays.equals(value, element.value()));
|
}
|
}
|
}
|
|
/**
|
* Tests the <CODE>encodeLength</CODE> method.
|
*/
|
@Test()
|
public void testEncodeLength() {
|
int numLengths = testLengths.size();
|
for (int i = 0; i < numLengths; i++) {
|
int length = testLengths.get(i);
|
byte[] encodedLength = testEncodedLengths.get(i);
|
|
assertTrue(Arrays.equals(encodedLength, ASN1Element
|
.encodeLength(length)));
|
}
|
}
|
|
/**
|
* Tests the <CODE>encode</CODE> and <CODE>decode</CODE> methods.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testEncodeAndDecode() throws Exception {
|
for (byte type : testTypes) {
|
for (byte[] value : testValues) {
|
int length;
|
byte[] encodedLength;
|
if (value == null) {
|
length = 0;
|
encodedLength = new byte[] { (byte) 0x00 };
|
} else {
|
length = value.length;
|
encodedLength = ASN1Element.encodeLength(length);
|
}
|
|
byte[] encodedElement = new byte[1 + length + encodedLength.length];
|
encodedElement[0] = type;
|
System.arraycopy(encodedLength, 0, encodedElement, 1,
|
encodedLength.length);
|
if (value != null) {
|
System.arraycopy(value, 0, encodedElement,
|
1 + encodedLength.length, length);
|
}
|
|
ASN1Element element = new ASN1Element(type, value);
|
|
assertTrue(Arrays.equals(encodedElement, element.encode()));
|
|
assertTrue(element.equals(ASN1Element.decode(encodedElement)));
|
}
|
|
int numLengths = testLengths.size();
|
for (int i = 0; i < numLengths; i++) {
|
int length = testLengths.get(i);
|
byte[] encodedLength = testEncodedLengths.get(i);
|
byte[] value = new byte[length];
|
|
byte[] encodedElement = new byte[1 + length + encodedLength.length];
|
encodedElement[0] = type;
|
System.arraycopy(encodedLength, 0, encodedElement, 1,
|
encodedLength.length);
|
|
ASN1Element element = new ASN1Element(type, value);
|
|
assertTrue(Arrays.equals(encodedElement, element.encode()));
|
|
assertTrue(element.equals(ASN1Element.decode(encodedElement)));
|
}
|
}
|
}
|
|
/**
|
* Tests the <CODE>encodeValue</CODE> method with a single boolean
|
* argument.
|
*/
|
@Test()
|
public void testEncodeBooleanValue() {
|
byte[] encodedFalse = new byte[] { (byte) 0x00 };
|
byte[] encodedTrue = new byte[] { (byte) 0xFF };
|
|
assertTrue(Arrays.equals(encodedFalse, ASN1Element.encodeValue(false)));
|
|
assertTrue(Arrays.equals(encodedTrue, ASN1Element.encodeValue(true)));
|
}
|
|
/**
|
* Tests the <CODE>encodeValue</CODE> method with a single int
|
* argument.
|
*/
|
@Test()
|
public void testEncodeIntValue() {
|
int numIntValues = testIntegers.size();
|
for (int i = 0; i < numIntValues; i++) {
|
int intValue = testIntegers.get(i);
|
byte[] encodedInt = testEncodedIntegers.get(i);
|
|
assertTrue(Arrays.equals(encodedInt, ASN1Element
|
.encodeValue(intValue)));
|
}
|
}
|
|
/**
|
* Tests the <CODE>encodeValue</CODE> method with a set of ASN.1
|
* elements.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testEncodeAndDecodeElements() throws Exception {
|
int numElementSets = testElementSets.size();
|
for (int i = 0; i < numElementSets; i++) {
|
ArrayList<ASN1Element> elementSet = testElementSets.get(i);
|
byte[] encodedElementSet = testEncodedElementSets.get(i);
|
|
assertTrue(Arrays.equals(encodedElementSet, ASN1Element
|
.encodeValue(elementSet)));
|
|
ArrayList<ASN1Element> decodedElementSet;
|
decodedElementSet = ASN1Element.decodeElements(encodedElementSet);
|
|
ArrayList<ASN1Element> compareSet;
|
if (elementSet == null) {
|
compareSet = new ArrayList<ASN1Element>(0);
|
} else {
|
compareSet = elementSet;
|
}
|
|
assertTrue(listsAreEqual(compareSet, decodedElementSet));
|
}
|
}
|
|
/**
|
* Tests the <CODE>decodeAsBoolean</CODE> method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testDecodeAsBoolean() throws Exception {
|
for (int i = 0; i < 256; i++) {
|
byte[] valueByte = new byte[] { (byte) i };
|
ASN1Element element = new ASN1Element((byte) 0x00, valueByte);
|
boolean booleanValue = (i != 0);
|
|
assertEquals(booleanValue, element.decodeAsBoolean().booleanValue());
|
|
element = new ASN1Element((byte) 0x01, valueByte);
|
|
assertEquals(booleanValue, element.decodeAsBoolean().booleanValue());
|
}
|
}
|
|
/**
|
* Tests the <CODE>decodeAsEnumerated</CODE> method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testDecodeAsEnumerated() throws Exception {
|
int numIntValues = testIntegers.size();
|
for (int i = 0; i < numIntValues; i++) {
|
int intValue = testIntegers.get(i);
|
byte[] encodedInt = testEncodedIntegers.get(i);
|
|
ASN1Element element = new ASN1Element((byte) 0x00, encodedInt);
|
|
assertEquals(intValue, element.decodeAsEnumerated().intValue());
|
|
element = new ASN1Element((byte) 0x0A, encodedInt);
|
|
assertEquals(intValue, element.decodeAsEnumerated().intValue());
|
}
|
}
|
|
/**
|
* Tests the <CODE>decodeAsInteger</CODE> method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testDecodeAsInteger() throws Exception {
|
int numIntValues = testIntegers.size();
|
for (int i = 0; i < numIntValues; i++) {
|
int intValue = testIntegers.get(i);
|
byte[] encodedInt = testEncodedIntegers.get(i);
|
|
ASN1Element element = new ASN1Element((byte) 0x00, encodedInt);
|
|
assertEquals(intValue, element.decodeAsInteger().intValue());
|
|
element = new ASN1Element((byte) 0x02, encodedInt);
|
|
assertEquals(intValue, element.decodeAsInteger().intValue());
|
}
|
}
|
|
/**
|
* Tests the <CODE>decodeAsNull</CODE> method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testDecodeAsNull() throws Exception {
|
for (byte type : testTypes) {
|
ASN1Element element = new ASN1Element(type);
|
ASN1Null nullElement = new ASN1Null(type);
|
|
assertEquals(nullElement, element.decodeAsNull());
|
}
|
}
|
|
/**
|
* Tests the <CODE>decodeAsOctetString</CODE> method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testDecodeAsOctetString() throws Exception {
|
for (byte[] value : testValues) {
|
ASN1Element element = new ASN1Element((byte) 0x00, value);
|
|
byte[] compareValue;
|
if (value == null) {
|
compareValue = new byte[0];
|
} else {
|
compareValue = value;
|
}
|
|
assertTrue(Arrays.equals(compareValue, element.decodeAsOctetString()
|
.value()));
|
|
element = new ASN1Element((byte) 0x04, value);
|
|
assertTrue(Arrays.equals(compareValue, element.decodeAsOctetString()
|
.value()));
|
}
|
}
|
|
/**
|
* Tests the <CODE>decodeAsSequence</CODE> method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testDecodeAsSequence() throws Exception {
|
int numElementSets = testElementSets.size();
|
for (int i = 0; i < numElementSets; i++) {
|
ArrayList<ASN1Element> elementSet = testElementSets.get(i);
|
byte[] encodedElementSet = testEncodedElementSets.get(i);
|
|
ArrayList<ASN1Element> compareList;
|
if (elementSet == null) {
|
compareList = new ArrayList<ASN1Element>(0);
|
} else {
|
compareList = elementSet;
|
}
|
|
ASN1Element element = new ASN1Element((byte) 0x00, encodedElementSet);
|
|
assertTrue(listsAreEqual(compareList, element.decodeAsSequence()
|
.elements()));
|
|
element = new ASN1Element((byte) 0x30, encodedElementSet);
|
|
assertTrue(listsAreEqual(compareList, element.decodeAsSequence()
|
.elements()));
|
}
|
}
|
|
/**
|
* Tests the <CODE>decodeAsSet</CODE> method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testDecodeAsSet() throws Exception {
|
int numElementSets = testElementSets.size();
|
for (int i = 0; i < numElementSets; i++) {
|
ArrayList<ASN1Element> elementSet = testElementSets.get(i);
|
byte[] encodedElementSet = testEncodedElementSets.get(i);
|
|
ArrayList<ASN1Element> compareList;
|
if (elementSet == null) {
|
compareList = new ArrayList<ASN1Element>(0);
|
} else {
|
compareList = elementSet;
|
}
|
|
ASN1Element element = new ASN1Element((byte) 0x00, encodedElementSet);
|
|
assertTrue(listsAreEqual(compareList, element.decodeAsSet()
|
.elements()));
|
|
element = new ASN1Element((byte) 0x31, encodedElementSet);
|
|
assertTrue(listsAreEqual(compareList, element.decodeAsSet()
|
.elements()));
|
}
|
}
|
|
/**
|
* Tests the <CODE>equals</CODE> and <CODE>hashCode</CODE>
|
* methods.
|
*/
|
@Test()
|
public void testEqualsAndHashCode() {
|
// Perform simple tests for two basic elements that should be the
|
// same, one
|
// that should differ in type, one that should differ in value, and
|
// one that
|
// should differ in both.
|
ASN1Element e1 = new ASN1Element((byte) 0x00);
|
ASN1Element e2 = new ASN1Element((byte) 0x00, new byte[0]);
|
ASN1Element e3 = new ASN1Element((byte) 0x01);
|
ASN1Element e4 = new ASN1Element((byte) 0x00,
|
new byte[] { (byte) 0x00 });
|
ASN1Element e5 = new ASN1Element((byte) 0x01,
|
new byte[] { (byte) 0x00 });
|
ASN1Element e6 = new ASN1Element((byte) 0x00,
|
new byte[] { (byte) 0x01 });
|
|
assertTrue(e1.equals(e2)); // Basic equality test.
|
|
assertTrue(e2.equals(e1)); // Reflexive equality test.
|
|
assertFalse(e1.equals(e3)); // Difference in type.
|
|
assertFalse(e1.equals(e4)); // Difference in value.
|
|
assertFalse(e1.equals(e5)); // Differences in type and value.
|
|
assertFalse(e4.equals(e6)); // Difference in values with the same
|
// length.
|
|
// Make sure that equal elements have equal hash codes.
|
assertEquals(e1.hashCode(), e2.hashCode()); // Hash code equality
|
// test.
|
|
// Test equals against a null element.
|
assertFalse(e1.equals(null));
|
|
// Test boolean elements against equivalent generic elements.
|
ASN1Element trueElement = new ASN1Element((byte) 0x01,
|
new byte[] { (byte) 0xFF });
|
ASN1Element falseElement = new ASN1Element((byte) 0x01,
|
new byte[] { (byte) 0x00 });
|
ASN1Boolean trueBoolean = new ASN1Boolean(true);
|
ASN1Boolean falseBoolean = new ASN1Boolean(false);
|
|
assertTrue(trueElement.equals(trueBoolean));
|
|
assertTrue(trueBoolean.equals(trueElement));
|
|
assertEquals(trueElement.hashCode(), trueBoolean.hashCode());
|
|
assertTrue(falseElement.equals(falseBoolean));
|
|
assertTrue(falseBoolean.equals(falseElement));
|
|
assertEquals(falseElement.hashCode(), falseBoolean.hashCode());
|
|
// Test integer elements against equivalent generic elements.
|
int numIntegers = testIntegers.size();
|
for (int i = 0; i < numIntegers; i++) {
|
int intValue = testIntegers.get(i);
|
byte[] encodedIntValue = testEncodedIntegers.get(i);
|
|
ASN1Element genericElement = new ASN1Element((byte) 0x02,
|
encodedIntValue);
|
ASN1Integer integerElement = new ASN1Integer(intValue);
|
|
assertTrue(genericElement.equals(integerElement));
|
|
assertTrue(integerElement.equals(genericElement)); // Reflexive
|
// test.
|
|
// Test for matching hash codes.
|
assertEquals(genericElement.hashCode(), integerElement.hashCode());
|
}
|
}
|
}
|
