/*
|
* 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 java.util.ArrayList;
|
import java.util.LinkedList;
|
import java.util.List;
|
|
import org.testng.annotations.DataProvider;
|
import org.testng.annotations.Test;
|
|
import org.opends.server.types.ByteString;
|
|
import static org.testng.Assert.*;
|
|
import static org.opends.server.messages.ProtocolMessages.*;
|
|
|
|
/**
|
* This class defines a set of tests for the
|
* org.opends.server.protocols.asn1.ASN1Element class.
|
*/
|
public class TestASN1Element
|
extends ASN1TestCase
|
{
|
/**
|
* Create the values that can be used for testing BER types.
|
*
|
* @return The values that can be used for testing BER types.
|
*/
|
@DataProvider(name = "testTypes")
|
public Object[][] getTestTypes()
|
{
|
// Create an array with all of the valid single-byte types. We don't
|
// support multi-byte types, so this should be a comprehensive data set.
|
Object[][] testTypes = new Object[0xFF][1];
|
for (int i=0x00; i < 0xFF; i++)
|
{
|
testTypes[i] = new Object[] { (byte) (i & 0xFF) };
|
}
|
|
return testTypes;
|
}
|
|
|
|
/**
|
* Tests the <CODE>getType</CODE> and <CODE>setType</CODE> methods.
|
*
|
* @param type The BER type to use in the test.
|
*/
|
@Test(dataProvider = "testTypes")
|
public void testGetAndSetType(byte type)
|
{
|
ASN1Element e = new ASN1Element((byte) 0x00);
|
e.setType(type);
|
assertEquals(e.getType(), type);
|
}
|
|
|
|
/**
|
* Tests the <CODE>isUniversal</CODE> method.
|
*
|
* @param type The BER type to use in the test.
|
*/
|
@Test(dataProvider = "testTypes")
|
public void testIsUniversal(byte type)
|
{
|
boolean isUniversal = (((type & 0xFF) >> 6) == 0x00);
|
assertEquals(new ASN1Element(type).isUniversal(), isUniversal);
|
}
|
|
|
|
/**
|
* Tests the <CODE>isApplicationSpecific</CODE> method.
|
*
|
* @param type The BER type to use in the test.
|
*/
|
@Test(dataProvider = "testTypes")
|
public void testIsApplicationSpecific(byte type)
|
{
|
boolean isApplicationSpecific = (((type & 0xFF) >> 6) == 0x01);
|
assertEquals(new ASN1Element(type).isApplicationSpecific(),
|
isApplicationSpecific);
|
}
|
|
|
|
/**
|
* Tests the <CODE>isContextSpecific</CODE> method.
|
*
|
* @param type The BER type to use in the test.
|
*/
|
@Test(dataProvider = "testTypes")
|
public void testIsContextSpecific(byte type)
|
{
|
boolean isContextSpecific = (((type & 0xFF) >> 6) == 0x02);
|
assertEquals(new ASN1Element(type).isContextSpecific(), isContextSpecific);
|
}
|
|
|
|
/**
|
* Tests the <CODE>isPrivate</CODE> method.
|
*
|
* @param type The BER type to use in the test.
|
*/
|
@Test(dataProvider = "testTypes")
|
public void testIsPrivate(byte type)
|
{
|
boolean isPrivate = (((type & 0xFF) >> 6) == 0x03);
|
assertEquals(new ASN1Element(type).isPrivate(), isPrivate);
|
}
|
|
|
|
/**
|
* Tests the <CODE>isPrimitive</CODE> method.
|
*
|
* @param type The BER type to use in the test.
|
*/
|
@Test(dataProvider = "testTypes")
|
public void testIsPrimitive(byte type)
|
{
|
boolean isPrimitive = ((type & 0xDF) == (type & 0xFF));
|
assertEquals(new ASN1Element(type).isPrimitive(), isPrimitive);
|
}
|
|
|
|
/**
|
* Tests the <CODE>isConstructed</CODE> method.
|
*
|
* @param type The BER type to use in the test.
|
*/
|
@Test(dataProvider = "testTypes")
|
public void testIsConstructed(byte type)
|
{
|
boolean isConstructed = ((type & 0xDF) != (type & 0xFF));
|
assertEquals(new ASN1Element(type).isConstructed(), isConstructed);
|
}
|
|
|
|
/**
|
* Create byte arrays to use for element values.
|
*
|
* @return A list of byte arrays that can be used as element values.
|
*/
|
@DataProvider(name = "testValues")
|
public Object[][] getTestValues()
|
{
|
// NOTE -- Don't make these arrays too big since they consume memory.
|
return new Object[][]
|
{
|
new Object[] { null }, // The null value
|
new Object[] { new byte[0x00] }, // The zero-byte value
|
new Object[] { new byte[0x01] }, // The single-byte value
|
new Object[] { new byte[0x7F] }, // The largest 1-byte length encoding
|
new Object[] { new byte[0x80] }, // The smallest 2-byte length encoding
|
new Object[] { new byte[0xFF] }, // The largest 2-byte length encoding
|
new Object[] { new byte[0x0100] }, // The smallest 3-byte length encoding
|
};
|
}
|
|
|
|
/**
|
* Tests the <CODE>getValue</CODE> and <CODE>setValue</CODE> methods.
|
*
|
* @param value The value to use in the test.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "testValues")
|
public void testGetAndSetValue(byte[] value)
|
throws Exception
|
{
|
ASN1Element e = new ASN1Element((byte) 0x00);
|
e.setValue(value);
|
|
if (value == null)
|
{
|
assertEquals(e.value(), new byte[0]);
|
}
|
else
|
{
|
assertEquals(e.value(), value);
|
}
|
}
|
|
|
|
/**
|
* Create decoded and encoded lengths.
|
*
|
* @return A list of decoded and encoded lengths.
|
*/
|
@DataProvider(name = "testLengths")
|
public Object[][] getTestLengths()
|
{
|
return new Object[][]
|
{
|
new Object[] { 0x00, new byte[] { 0x00 } },
|
new Object[] { 0x01, new byte[] { 0x01 } },
|
new Object[] { 0x7F, new byte[] { 0x7F } },
|
new Object[] { 0x80, new byte[] { (byte) 0x81, (byte) 0x80 } },
|
new Object[] { 0xFF, new byte[] { (byte) 0x81, (byte) 0xFF } },
|
new Object[] { 0x0100, new byte[] { (byte) 0x82, 0x01, 0x00 } },
|
new Object[] { 0xFFFF,
|
new byte[] { (byte) 0x82, (byte) 0xFF, (byte) 0xFF } },
|
new Object[] { 0x010000, new byte[] { (byte) 0x83, 0x01, 0x00, 0x00 } },
|
new Object[] { 0xFFFFFF,
|
new byte[] { (byte) 0x83, (byte) 0xFF, (byte) 0xFF,
|
(byte) 0xFF } },
|
new Object[] { 0x01000000,
|
new byte[] { (byte) 0x84, 0x01, 0x00, 0x00, 0x00 } },
|
new Object[] { 0x7FFFFFFF,
|
new byte[] { (byte) 0x84, (byte) 0x7F, (byte) 0xFF,
|
(byte) 0xFF, (byte) 0xFF } },
|
};
|
}
|
|
|
/**
|
* Tests the <CODE>encodeLength</CODE> method.
|
*
|
* @param decodedLength The decoded length to encode.
|
* @param encodedLength The encoded representation of the length.
|
*/
|
@Test(dataProvider = "testLengths")
|
public void testEncodeLength(int decodedLength, byte[] encodedLength)
|
{
|
assertEquals(ASN1Element.encodeLength(decodedLength), encodedLength);
|
}
|
|
|
|
/**
|
* Tests the <CODE>encode</CODE> and <CODE>decode</CODE> methods.
|
*
|
* @param value The value to use in the test.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "testValues")
|
public void testEncodeAndDecode(byte[] value)
|
throws Exception
|
{
|
for (int i=0x00; i < 0xFF; i++)
|
{
|
byte type = (byte) i;
|
ASN1Element e = new ASN1Element(type, value);
|
byte[] encodedElement = e.encode();
|
|
ASN1Element d = ASN1Element.decode(encodedElement);
|
assertEquals(e, d);
|
assertEquals(d.getType(), type);
|
assertTrue(e.equalsElement(d));
|
|
if (value == null)
|
{
|
assertEquals(d.value(), new byte[0]);
|
}
|
else
|
{
|
assertEquals(d.value(), value);
|
}
|
|
d = ASN1Element.decode(encodedElement, 0, encodedElement.length);
|
assertEquals(e, d);
|
assertEquals(d.getType(), type);
|
assertTrue(e.equalsElement(d));
|
|
if (value == null)
|
{
|
assertEquals(d.value(), new byte[0]);
|
}
|
else
|
{
|
assertEquals(d.value(), value);
|
}
|
}
|
}
|
|
|
|
/**
|
* Tests to ensure that there is a failure when trying to decode a null as an
|
* element.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeFailureNull()
|
throws Exception
|
{
|
ASN1Element.decode(null);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decodeAsBoolean</CODE> method.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testDecodeAsBoolean()
|
throws Exception
|
{
|
// First, make sure that we can decode actual Boolean elements as Boolean
|
// elements, using both the standard type as well as a nonstandard type.
|
boolean[] booleanValues = new boolean[] { true, false };
|
for (boolean b : booleanValues)
|
{
|
ASN1Element e = new ASN1Boolean(b);
|
ASN1Boolean booleanElement = e.decodeAsBoolean();
|
assertEquals(booleanElement.booleanValue(), b);
|
|
e = new ASN1Boolean((byte) 0x50, b);
|
booleanElement = e.decodeAsBoolean();
|
assertEquals(booleanElement.booleanValue(), b);
|
}
|
|
|
// Next, make sure we can decode generic ASN.1 elements with a single-byte
|
// value as a Boolean element.
|
for (int i=0; i < 256; i++)
|
{
|
ASN1Element e = new ASN1Element(ASN1Constants.UNIVERSAL_BOOLEAN_TYPE,
|
new byte[] { (byte) i });
|
ASN1Boolean b = e.decodeAsBoolean();
|
assertEquals(b.booleanValue(), (i != 0));
|
|
e = new ASN1Element((byte) 0x50, new byte[] { (byte) i });
|
b = e.decodeAsBoolean();
|
assertEquals(b.booleanValue(), (i != 0));
|
}
|
}
|
|
|
|
/**
|
* Tests the <CODE>decodeAsEnumerated</CODE> method.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testDecodeAsEnumerated()
|
throws Exception
|
{
|
int[] intValues =
|
{
|
0x00000000,
|
0x00000001,
|
0x0000000F,
|
0x00000010,
|
0x0000007F,
|
0x00000080,
|
0x000000FF,
|
0x00000100,
|
0x00000FFF,
|
0x00001000,
|
0x0000FFFF,
|
0x00010000,
|
0x000FFFFF,
|
0x00100000,
|
0x00FFFFFF,
|
0x01000000,
|
0x0FFFFFFF,
|
0x10000000,
|
0x7FFFFFFF
|
};
|
|
// First, make sure that we can decode actual enumerated elements as
|
// enumerated elements, using both the standard type as well as a
|
// nonstandard type.
|
for (int i : intValues)
|
{
|
ASN1Element e = new ASN1Enumerated(i);
|
ASN1Enumerated enumeratedElement = e.decodeAsEnumerated();
|
assertEquals(enumeratedElement.intValue(), i);
|
|
e = new ASN1Enumerated((byte) 0x50, i);
|
enumeratedElement = e.decodeAsEnumerated();
|
assertEquals(enumeratedElement.intValue(), i);
|
}
|
|
|
// Next, make sure we can decode generic ASN.1 elements as enumerated
|
// elements.
|
for (int i : intValues)
|
{
|
byte[] encoding;
|
if ((i & 0xFF) == i)
|
{
|
encoding = new byte[1];
|
encoding[0] = (byte) (i & 0xFF);
|
}
|
else if ((i & 0xFFFF) == i)
|
{
|
encoding = new byte[2];
|
encoding[0] = (byte) ((i >> 8) & 0xFF);
|
encoding[1] = (byte) (i & 0xFF);
|
}
|
else if ((i & 0xFFFFFF) == i)
|
{
|
encoding = new byte[3];
|
encoding[0] = (byte) ((i >> 16) & 0xFF);
|
encoding[1] = (byte) ((i >> 8) & 0xFF);
|
encoding[2] = (byte) (i & 0xFF);
|
}
|
else
|
{
|
encoding = new byte[4];
|
encoding[0] = (byte) ((i >> 24) & 0xFF);
|
encoding[1] = (byte) ((i >> 16) & 0xFF);
|
encoding[2] = (byte) ((i >> 8) & 0xFF);
|
encoding[3] = (byte) (i & 0xFF);
|
}
|
|
ASN1Element e = new ASN1Element(ASN1Constants.UNIVERSAL_ENUMERATED_TYPE,
|
encoding);
|
ASN1Enumerated enumeratedElement = e.decodeAsEnumerated();
|
assertEquals(enumeratedElement.intValue(), i);
|
|
e = new ASN1Element((byte) 0x50, encoding);
|
enumeratedElement = e.decodeAsEnumerated();
|
assertEquals(enumeratedElement.intValue(), i);
|
}
|
}
|
|
|
|
/**
|
* Tests the <CODE>decodeAsInteger</CODE> method.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testDecodeAsInteger()
|
throws Exception
|
{
|
int[] intValues =
|
{
|
0x00000000,
|
0x00000001,
|
0x0000000F,
|
0x00000010,
|
0x0000007F,
|
0x00000080,
|
0x000000FF,
|
0x00000100,
|
0x00000FFF,
|
0x00001000,
|
0x0000FFFF,
|
0x00010000,
|
0x000FFFFF,
|
0x00100000,
|
0x00FFFFFF,
|
0x01000000,
|
0x0FFFFFFF,
|
0x10000000,
|
0x7FFFFFFF,
|
-0x00000001,
|
-0x0000000F,
|
-0x00000010,
|
-0x0000007F,
|
-0x00000080,
|
-0x000000FF,
|
-0x00000100,
|
-0x00000FFF,
|
-0x00001000,
|
-0x0000FFFF,
|
-0x00010000,
|
-0x000FFFFF,
|
-0x00100000,
|
-0x00FFFFFF,
|
-0x01000000,
|
-0x0FFFFFFF,
|
-0x10000000,
|
-0x7FFFFFFF,
|
0x80000000
|
};
|
|
// First, make sure that we can decode actual integer elements as integer
|
// elements, using both the standard type as well as a nonstandard type.
|
for (int i : intValues)
|
{
|
ASN1Element e = new ASN1Integer(i);
|
ASN1Integer integerElement = e.decodeAsInteger();
|
assertEquals(integerElement.intValue(), i);
|
|
e = new ASN1Integer((byte) 0x50, i);
|
integerElement = e.decodeAsInteger();
|
assertEquals(integerElement.intValue(), i);
|
}
|
|
|
// Next, make sure we can decode generic ASN.1 elements as integer elements.
|
for (int i : intValues)
|
{
|
byte[] encoding;
|
if ((i & 0x7F) == i)
|
{
|
encoding = new byte[1];
|
encoding[0] = (byte) (i & 0xFF);
|
}
|
else if ((i & 0x7FFF) == i)
|
{
|
encoding = new byte[2];
|
encoding[0] = (byte) ((i >> 8) & 0xFF);
|
encoding[1] = (byte) (i & 0xFF);
|
}
|
else if ((i & 0x7FFFFF) == i)
|
{
|
encoding = new byte[3];
|
encoding[0] = (byte) ((i >> 16) & 0xFF);
|
encoding[1] = (byte) ((i >> 8) & 0xFF);
|
encoding[2] = (byte) (i & 0xFF);
|
}
|
else
|
{
|
encoding = new byte[4];
|
encoding[0] = (byte) ((i >> 24) & 0xFF);
|
encoding[1] = (byte) ((i >> 16) & 0xFF);
|
encoding[2] = (byte) ((i >> 8) & 0xFF);
|
encoding[3] = (byte) (i & 0xFF);
|
}
|
|
ASN1Element e = new ASN1Element(ASN1Constants.UNIVERSAL_INTEGER_TYPE,
|
encoding);
|
ASN1Integer integerElement = e.decodeAsInteger();
|
assertEquals(integerElement.intValue(), i);
|
|
e = new ASN1Element((byte) 0x50, encoding);
|
integerElement = e.decodeAsInteger();
|
assertEquals(integerElement.intValue(), i);
|
}
|
}
|
|
|
|
/**
|
* Tests the <CODE>decodeAsLong</CODE> method.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testDecodeAsLong()
|
throws Exception
|
{
|
long[] longValues =
|
{
|
0x0000000000000000L,
|
0x0000000000000001L,
|
0x000000000000007FL,
|
0x0000000000000080L,
|
0x00000000000000FFL,
|
0x0000000000000100L,
|
0x000000000000FFFFL,
|
0x0000000000010000L,
|
0x0000000000FFFFFFL,
|
0x0000000001000000L,
|
0x00000000FFFFFFFFL,
|
0x0000000100000000L,
|
0x000000FFFFFFFFFFL,
|
0x0000010000000000L,
|
0x0000FFFFFFFFFFFFL,
|
0x0001000000000000L,
|
0x00FFFFFFFFFFFFFFL,
|
0x0100000000000000L,
|
0x7FFFFFFFFFFFFFFFL,
|
-0x0000000000000001L,
|
-0x000000000000007FL,
|
-0x0000000000000080L,
|
-0x00000000000000FFL,
|
-0x0000000000000100L,
|
-0x000000000000FFFFL,
|
-0x0000000000010000L,
|
-0x0000000000FFFFFFL,
|
-0x0000000001000000L,
|
-0x00000000FFFFFFFFL,
|
-0x0000000100000000L,
|
-0x000000FFFFFFFFFFL,
|
-0x0000010000000000L,
|
-0x0000FFFFFFFFFFFFL,
|
-0x0001000000000000L,
|
-0x00FFFFFFFFFFFFFFL,
|
-0x0100000000000000L,
|
-0x7FFFFFFFFFFFFFFFL,
|
0x8000000000000000L
|
};
|
|
// First, make sure that we can decode actual long elements as long
|
// elements, using both the standard type as well as a nonstandard type.
|
for (long l : longValues)
|
{
|
ASN1Element e = new ASN1Long(l);
|
ASN1Long longElement = e.decodeAsLong();
|
assertEquals(longElement.longValue(), l);
|
|
e = new ASN1Long((byte) 0x50, l);
|
longElement = e.decodeAsLong();
|
assertEquals(longElement.longValue(), l);
|
}
|
|
|
// Next, make sure we can decode generic ASN.1 elements as long elements.
|
for (long l : longValues)
|
{
|
byte[] encoding;
|
if ((l & 0x7FL) == l)
|
{
|
encoding = new byte[1];
|
encoding[0] = (byte) (l & 0xFF);
|
}
|
else if ((l & 0x7FFFL) == l)
|
{
|
encoding = new byte[2];
|
encoding[0] = (byte) ((l >> 8) & 0xFF);
|
encoding[1] = (byte) (l & 0xFF);
|
}
|
else if ((l & 0x7FFFFFL) == l)
|
{
|
encoding = new byte[3];
|
encoding[0] = (byte) ((l >> 16) & 0xFF);
|
encoding[1] = (byte) ((l >> 8) & 0xFF);
|
encoding[2] = (byte) (l & 0xFF);
|
}
|
else if ((l & 0x7FFFFFFFL) == l)
|
{
|
encoding = new byte[4];
|
encoding[0] = (byte) ((l >> 24) & 0xFF);
|
encoding[1] = (byte) ((l >> 16) & 0xFF);
|
encoding[2] = (byte) ((l >> 8) & 0xFF);
|
encoding[3] = (byte) (l & 0xFF);
|
}
|
else if ((l & 0x7FFFFFFFFFL) == l)
|
{
|
encoding = new byte[5];
|
encoding[0] = (byte) ((l >> 32) & 0xFF);
|
encoding[1] = (byte) ((l >> 24) & 0xFF);
|
encoding[2] = (byte) ((l >> 16) & 0xFF);
|
encoding[3] = (byte) ((l >> 8) & 0xFF);
|
encoding[4] = (byte) (l & 0xFF);
|
}
|
else if ((l & 0x7FFFFFFFFFFFL) == l)
|
{
|
encoding = new byte[6];
|
encoding[0] = (byte) ((l >> 40) & 0xFF);
|
encoding[1] = (byte) ((l >> 32) & 0xFF);
|
encoding[2] = (byte) ((l >> 24) & 0xFF);
|
encoding[3] = (byte) ((l >> 16) & 0xFF);
|
encoding[4] = (byte) ((l >> 8) & 0xFF);
|
encoding[5] = (byte) (l & 0xFF);
|
}
|
else if ((l & 0x7FFFFFFFFFFFFFL) == l)
|
{
|
encoding = new byte[7];
|
encoding[0] = (byte) ((l >> 48) & 0xFF);
|
encoding[1] = (byte) ((l >> 40) & 0xFF);
|
encoding[2] = (byte) ((l >> 32) & 0xFF);
|
encoding[3] = (byte) ((l >> 24) & 0xFF);
|
encoding[4] = (byte) ((l >> 16) & 0xFF);
|
encoding[5] = (byte) ((l >> 8) & 0xFF);
|
encoding[6] = (byte) (l & 0xFF);
|
}
|
else
|
{
|
encoding = new byte[8];
|
encoding[0] = (byte) ((l >> 56) & 0xFF);
|
encoding[1] = (byte) ((l >> 48) & 0xFF);
|
encoding[2] = (byte) ((l >> 40) & 0xFF);
|
encoding[3] = (byte) ((l >> 32) & 0xFF);
|
encoding[4] = (byte) ((l >> 24) & 0xFF);
|
encoding[5] = (byte) ((l >> 16) & 0xFF);
|
encoding[6] = (byte) ((l >> 8) & 0xFF);
|
encoding[7] = (byte) (l & 0xFF);
|
}
|
|
ASN1Element e = new ASN1Element(ASN1Constants.UNIVERSAL_INTEGER_TYPE,
|
encoding);
|
ASN1Long longElement = e.decodeAsLong();
|
assertEquals(longElement.longValue(), l);
|
|
e = new ASN1Element((byte) 0x50, encoding);
|
longElement = e.decodeAsLong();
|
assertEquals(longElement.longValue(), l);
|
}
|
}
|
|
|
|
/**
|
* Tests the <CODE>decodeAsNull</CODE> method.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testDecodeAsNull()
|
throws Exception
|
{
|
// First, make sure that we can decode actual null elements as null
|
// elements, using both the standard type as well as a nonstandard type.
|
ASN1Element e = new ASN1Null();
|
e.decodeAsNull();
|
|
e = new ASN1Null((byte) 0x50);
|
e.decodeAsNull();
|
|
|
// Next, make sure we can decode generic ASN.1 elements with a zero-byte
|
// value as a null element.
|
e = new ASN1Element(ASN1Constants.UNIVERSAL_NULL_TYPE);
|
e.decodeAsNull();
|
|
e = new ASN1Element(ASN1Constants.UNIVERSAL_NULL_TYPE, null);
|
e.decodeAsNull();
|
|
e = new ASN1Element(ASN1Constants.UNIVERSAL_NULL_TYPE, new byte[0]);
|
e.decodeAsNull();
|
|
e = new ASN1Element((byte) 0x50);
|
e.decodeAsNull();
|
|
e = new ASN1Element((byte) 0x50, null);
|
e.decodeAsNull();
|
|
e = new ASN1Element((byte) 0x50, new byte[0]);
|
e.decodeAsNull();
|
}
|
|
|
|
/**
|
* Tests the <CODE>decodeAsOctetString</CODE> method.
|
*
|
* @param value The value to use for the octet string element.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "testValues")
|
public void testDecodeAsOctetString(byte[] value)
|
throws Exception
|
{
|
// First, make sure that we can decode actual octet string elements as octet
|
// string elements, using both the standard type as well as a nonstandard
|
// type.
|
ASN1Element e = new ASN1OctetString(value);
|
ASN1OctetString octetStringElement = e.decodeAsOctetString();
|
if (value == null)
|
{
|
assertEquals(octetStringElement.value(), new byte[0]);
|
}
|
else
|
{
|
assertEquals(octetStringElement.value(), value);
|
}
|
|
e = new ASN1OctetString((byte) 0x50, value);
|
octetStringElement = e.decodeAsOctetString();
|
if (value == null)
|
{
|
assertEquals(octetStringElement.value(), new byte[0]);
|
}
|
else
|
{
|
assertEquals(octetStringElement.value(), value);
|
}
|
|
|
// Next, make sure that we can decode a generic ASN.1 element as an octet
|
// string element.
|
e = new ASN1Element(ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE, value);
|
octetStringElement = e.decodeAsOctetString();
|
if (value == null)
|
{
|
assertEquals(octetStringElement.value(), new byte[0]);
|
}
|
else
|
{
|
assertEquals(octetStringElement.value(), value);
|
}
|
|
e = new ASN1Element((byte) 0x50, value);
|
octetStringElement = e.decodeAsOctetString();
|
if (value == null)
|
{
|
assertEquals(octetStringElement.value(), new byte[0]);
|
}
|
else
|
{
|
assertEquals(octetStringElement.value(), value);
|
}
|
}
|
|
|
|
/**
|
* Retrieves arrays of ASN.1 elements for use in testing with sequences and
|
* sets.
|
*
|
* @return Arrays of ASN.1 elements for use in testing with sequences and
|
* sets.
|
*/
|
@DataProvider(name = "elementArrays")
|
public Object[][] getElementArrays()
|
{
|
ArrayList<ASN1Element[]> arrays = new ArrayList<ASN1Element[]>();
|
arrays.add(null);
|
arrays.add(new ASN1Element[0]);
|
arrays.add(new ASN1Element[] { new ASN1Element((byte) 0x50) });
|
arrays.add(new ASN1Element[] { new ASN1Element((byte) 0x50, null) });
|
arrays.add(new ASN1Element[] { new ASN1Element((byte) 0x50, new byte[0]) });
|
arrays.add(new ASN1Element[] { new ASN1Element((byte) 0x50, new byte[1]) });
|
arrays.add(new ASN1Element[] { new ASN1Boolean(true) });
|
arrays.add(new ASN1Element[] { new ASN1Enumerated(0) });
|
arrays.add(new ASN1Element[] { new ASN1Integer(0) });
|
arrays.add(new ASN1Element[] { new ASN1Long(0) });
|
arrays.add(new ASN1Element[] { new ASN1OctetString() });
|
arrays.add(new ASN1Element[] { new ASN1OctetString(),
|
new ASN1OctetString() });
|
arrays.add(new ASN1Element[] { new ASN1OctetString(),
|
new ASN1OctetString(),
|
new ASN1OctetString() });
|
arrays.add(new ASN1Element[] { new ASN1OctetString(),
|
new ASN1OctetString(),
|
new ASN1OctetString(),
|
new ASN1OctetString() });
|
arrays.add(new ASN1Element[] { new ASN1OctetString(),
|
new ASN1OctetString(),
|
new ASN1OctetString(),
|
new ASN1OctetString(),
|
new ASN1OctetString() });
|
arrays.add(new ASN1Element[] { new ASN1Integer(1),
|
new ASN1Null((byte) 0x42) });
|
|
Object[][] objects = new Object[arrays.size()][];
|
for (int i=0; i < arrays.size(); i++)
|
{
|
objects[i] = new Object[] { arrays.get(i) };
|
}
|
|
return objects;
|
}
|
|
|
|
/**
|
* Tests the <CODE>decodeAsSequence</CODE> method.
|
*
|
* @param elements The set of ASN.1 elements to use in the tests.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "elementArrays")
|
public void testDecodeAsSequence(ASN1Element[] elements)
|
throws Exception
|
{
|
ArrayList<ASN1Element> elementList = new ArrayList<ASN1Element>();
|
if (elements == null)
|
{
|
elementList = null;
|
}
|
else
|
{
|
for (ASN1Element e : elements)
|
{
|
elementList.add(e);
|
}
|
}
|
|
|
// First, make sure that we can decode actual sequence elements as sequence
|
// elements, using both the standard type as well as a nonstandard type.
|
ASN1Element e = new ASN1Sequence(elementList);
|
ASN1Sequence sequenceElement = e.decodeAsSequence();
|
if (elements == null)
|
{
|
assertEquals(sequenceElement.elements(), new ArrayList<ASN1Element>());
|
}
|
else
|
{
|
assertEquals(sequenceElement.elements(), elementList);
|
}
|
|
e = new ASN1Sequence((byte) 0x50, elementList);
|
sequenceElement = e.decodeAsSequence();
|
if (elements == null)
|
{
|
assertEquals(sequenceElement.elements(), new ArrayList<ASN1Element>());
|
}
|
else
|
{
|
assertEquals(sequenceElement.elements(), elementList);
|
}
|
|
|
// Next, make sure that we can decode a generic ASN.1 element as an octet
|
// string element.
|
e = new ASN1Element(ASN1Constants.UNIVERSAL_SEQUENCE_TYPE,
|
ASN1Element.encodeValue(elementList));
|
sequenceElement = e.decodeAsSequence();
|
if (elements == null)
|
{
|
assertEquals(sequenceElement.elements(), new ArrayList<ASN1Element>());
|
}
|
else
|
{
|
assertEquals(sequenceElement.elements(), elementList);
|
}
|
|
e = new ASN1Element((byte) 0x50, ASN1Element.encodeValue(elementList));
|
sequenceElement = e.decodeAsSequence();
|
if (elements == null)
|
{
|
assertEquals(sequenceElement.elements(), new ArrayList<ASN1Element>());
|
}
|
else
|
{
|
assertEquals(sequenceElement.elements(), elementList);
|
}
|
}
|
|
|
|
/**
|
* Tests the <CODE>decodeAsSet</CODE> method.
|
*
|
* @param elements The set of ASN.1 elements to use in the tests.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "elementArrays")
|
public void testDecodeAsSet(ASN1Element[] elements)
|
throws Exception
|
{
|
ArrayList<ASN1Element> elementList = new ArrayList<ASN1Element>();
|
if (elements == null)
|
{
|
elementList = null;
|
}
|
else
|
{
|
for (ASN1Element e : elements)
|
{
|
elementList.add(e);
|
}
|
}
|
|
|
// First, make sure that we can decode actual set elements as set elements,
|
// using both the standard type as well as a nonstandard type.
|
ASN1Element e = new ASN1Set(elementList);
|
ASN1Set setElement = e.decodeAsSet();
|
if (elements == null)
|
{
|
assertEquals(setElement.elements(), new ArrayList<ASN1Element>());
|
}
|
else
|
{
|
assertEquals(setElement.elements(), elementList);
|
}
|
|
e = new ASN1Set((byte) 0x50, elementList);
|
setElement = e.decodeAsSet();
|
if (elements == null)
|
{
|
assertEquals(setElement.elements(), new ArrayList<ASN1Element>());
|
}
|
else
|
{
|
assertEquals(setElement.elements(), elementList);
|
}
|
|
|
// Next, make sure that we can decode a generic ASN.1 element as an octet
|
// string element.
|
e = new ASN1Element(ASN1Constants.UNIVERSAL_SET_TYPE,
|
ASN1Element.encodeValue(elementList));
|
setElement = e.decodeAsSet();
|
if (elements == null)
|
{
|
assertEquals(setElement.elements(), new ArrayList<ASN1Element>());
|
}
|
else
|
{
|
assertEquals(setElement.elements(), elementList);
|
}
|
|
e = new ASN1Element((byte) 0x50, ASN1Element.encodeValue(elementList));
|
setElement = e.decodeAsSet();
|
if (elements == null)
|
{
|
assertEquals(setElement.elements(), new ArrayList<ASN1Element>());
|
}
|
else
|
{
|
assertEquals(setElement.elements(), elementList);
|
}
|
}
|
|
|
|
/**
|
* Tests the <CODE>equals</CODE>, <CODE>equalsElement</CODE>, and
|
* <CODE>equalsIgnoreType</CODE> methods.
|
*
|
* @param value The value to use in the test.
|
*/
|
@Test(dataProvider = "testValues")
|
public void testEquals(byte[] value)
|
{
|
ASN1Element controlElement = new ASN1Element((byte) 0x00, value);
|
|
for (int i=0x00; i < 0xFF; i++)
|
{
|
ASN1Element e = new ASN1Element((byte) i, value);
|
|
if (i == 0x00)
|
{
|
assertTrue(controlElement.equals(e));
|
assertTrue(e.equals(controlElement));
|
assertTrue(controlElement.equalsElement(e));
|
assertTrue(e.equalsElement(controlElement));
|
}
|
else
|
{
|
assertFalse(controlElement.equals(e));
|
assertFalse(e.equals(controlElement));
|
assertFalse(controlElement.equalsElement(e));
|
assertFalse(e.equalsElement(controlElement));
|
}
|
|
assertTrue(e.equals(e));
|
assertTrue(e.equalsElement(e));
|
assertTrue(e.equalsIgnoreType(e));
|
assertTrue(e.equalsIgnoreType((ByteString) new ASN1OctetString(value)));
|
assertTrue(controlElement.equalsIgnoreType(e));
|
assertTrue(e.equalsIgnoreType(controlElement));
|
assertFalse(e.equals(null));
|
assertFalse(e.equals("notanelement"));
|
}
|
}
|
|
|
|
/**
|
* Tests the <CODE>decode</CODE> method taking an array argument with an
|
* invalid element that is too short to be valid.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeShortElement1()
|
throws Exception
|
{
|
ASN1Element.decode(new byte[1]);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decode</CODE> method taking an array and two integer
|
* arguments with an invalid element that is too short to be valid.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeShortElement2()
|
throws Exception
|
{
|
ASN1Element.decode(new byte[1], 0, 1);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decode</CODE> method taking an array argument with a null
|
* element.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeNull1()
|
throws Exception
|
{
|
ASN1Element.decode(null);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decode</CODE> method taking an array and two integer
|
* arguments with a null element.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeNull2()
|
throws Exception
|
{
|
ASN1Element.decode(null, 0, 0);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decode</CODE> method taking an array argument with an
|
* element indicating that it takes more than four bytes to describe the
|
* length.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeLongLength1()
|
throws Exception
|
{
|
byte[] elementBytes =
|
{
|
0x04,
|
(byte) 0x85,
|
0x00,
|
0x00,
|
0x00,
|
0x00,
|
0x00
|
};
|
|
ASN1Element.decode(elementBytes);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decode</CODE> method taking an array and two integer
|
* arguments with an indicating that it takes more than four bytes to describe
|
* the length.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeLongLength2()
|
throws Exception
|
{
|
byte[] elementBytes =
|
{
|
0x04,
|
(byte) 0x85,
|
0x00,
|
0x00,
|
0x00,
|
0x00,
|
0x00
|
};
|
|
ASN1Element.decode(elementBytes, 0, elementBytes.length);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decode</CODE> method taking an array argument with an
|
* element that isn't long enough to fully decode the length.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeTruncatedLength1()
|
throws Exception
|
{
|
byte[] elementBytes =
|
{
|
0x04,
|
(byte) 0x82,
|
0x00
|
};
|
|
ASN1Element.decode(elementBytes);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decode</CODE> method taking an array and two integer
|
* arguments with an element that isn't long enough to fully decode the
|
* length.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeTruncatedLength2()
|
throws Exception
|
{
|
byte[] elementBytes =
|
{
|
0x04,
|
(byte) 0x82,
|
0x00
|
};
|
|
ASN1Element.decode(elementBytes, 0, elementBytes.length);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decode</CODE> method taking an array argument with an
|
* element whose decoded length doesn't match the number of bytes remaining.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeLengthMismatch1()
|
throws Exception
|
{
|
byte[] elementBytes =
|
{
|
0x04,
|
0x01,
|
0x00,
|
0x00
|
};
|
|
ASN1Element.decode(elementBytes);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decode</CODE> method taking an array and two integer
|
* arguments with an element whose decoded length doesn't match the number of
|
* bytes remaining.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeLengthMismatch2()
|
throws Exception
|
{
|
byte[] elementBytes =
|
{
|
0x04,
|
0x01,
|
0x00,
|
0x00
|
};
|
|
ASN1Element.decode(elementBytes, 0, elementBytes.length);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decodeElements</CODE> method taking an array with a null
|
* array.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeElementsNull()
|
throws Exception
|
{
|
ASN1Element.decodeElements(null);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decodeElements</CODE> method taking an array with an array
|
* containing an element with too many bytes used to describe the length.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeElementsLongLength()
|
throws Exception
|
{
|
byte[] elementBytes =
|
{
|
0x04,
|
(byte) 0x85,
|
0x00,
|
0x00,
|
0x00,
|
0x00,
|
0x00
|
};
|
|
ASN1Element.decodeElements(elementBytes);
|
}
|
|
|
|
/**
|
* Tests the <CODE>decodeElements</CODE> method taking an array with an array
|
* containing an element without enough bytes to fully decode the length.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = { ASN1Exception.class })
|
public void testDecodeElementsTruncatedLength()
|
throws Exception
|
{
|
byte[] elementBytes =
|
{
|
0x04,
|
(byte) 0x82,
|
0x00,
|
};
|
|
ASN1Element.decodeElements(elementBytes);
|
}
|
|
|
|
/**
|
* Tests the <CODE>equalsElement</CODE> method taking an array with a null
|
* array.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test()
|
public void testEqualsElementNull()
|
throws Exception
|
{
|
ASN1Element e = new ASN1OctetString();
|
assertFalse(e.equalsElement(null));
|
}
|
|
|
|
/**
|
* Tests miscellaneous methods, including <CODE>toString</CODE> and
|
* <CODE>getProtocolElementName</CODE> that don't fit in anywhere else.
|
*
|
* @param value The value to use in the test.
|
*/
|
@Test(dataProvider = "testValues")
|
public void testMiscellaneous(byte[] value)
|
{
|
for (int i=0x00; i < 0xFF; i++)
|
{
|
byte type = (byte) i;
|
ASN1Element e = new ASN1Element(type, value);
|
e.toString();
|
e.toString(new StringBuilder());
|
e.toString(new StringBuilder(), 1);
|
assertEquals(e.getProtocolElementName(), "ASN.1");
|
}
|
}
|
}
|
