ASN1ReaderTestCase.java revision e595b7115481489471844679dc84222cf121a754
/*
* 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
* 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
*
*
* Copyright 2006-2009 Sun Microsystems, Inc.
*/
/**
* An abstract base class for all ASN1Reader test cases.
*/
public abstract class ASN1ReaderTestCase extends DirectoryServerTestCase
{
/**
* 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.
*/
public Object[][] getByteValues()
{
for (int i=0; i < 256; i++)
{
}
return array;
}
/**
* Create byte arrays with encoded ASN.1 elements to test decoding them as
* octet strings.
*
* @return A list of byte arrays with encoded ASN.1 elements that can be
* decoded as octet strings.
*/
public Object[][] getElementArrays()
{
return new Object[][]
{
};
}
/**
* Gets the reader to be use for the unit tests.
*
* @param b
* The array of bytes to be read.
* @param maxElementSize
* The max element size.
* @return The reader to be use for the unit tests.
* @throws IOException
* In an unexpected IO exception occurred.
*/
throws IOException;
/**
* Tests the <CODE>decodeAsNull</CODE> method that takes a byte array argument
* with a short array.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeShortArrayAsNull()
throws Exception
{
byte[] b = new byte[1];
}
/**
* Tests the <CODE>decodeAsNull</CODE> method that takes a byte array argument
* with an array with a long length.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeLongLengthArrayAsNull()
throws Exception
{
byte[] b = new byte[] { 0x05, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x00 };
}
/**
* Tests the <CODE>decodeAsNull</CODE> method that takes a byte array argument
* with an array with a truncated length.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeTruncatedLengthArrayAsNull()
throws Exception
{
byte[] b = new byte[] { 0x05, (byte) 0x82, 0x00 };
}
/**
* Tests the <CODE>decodeAsNull</CODE> method that takes a byte array argument
* with an arry with a nonzero length.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeNonZeroLengthArrayAsNull()
throws Exception
{
byte[] b = new byte[] { 0x05, 0x01, 0x00 };
}
/**
* Tests the <CODE>decodeAsNull</CODE> method that takes a byte array argument
* with an arry with a zero length.
*
* @throws Exception If an unexpected problem occurs.
*/
@Test()
public void testDecodeZeroLengthArrayAsNull()
throws Exception
{
byte[] b = new byte[] { 0x05, 0x00 };
}
/**
* Tests the <CODE>decodeAsNull</CODE> method that takes a byte array argument
* with an arry with a zero length that takes multiple bytes to encode.
*
* @throws Exception If an unexpected problem occurs.
*/
@Test()
public void testDecodeExtendedZeroLengthArrayAsNull()
throws Exception
{
byte[] b = new byte[] { 0x05, (byte) 0x81, 0x00 };
}
/**
* Tests the <CODE>decodeAsInteger</CODE> method that takes a byte array with
* a short array.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeShortArrayAsInteger()
throws Exception
{
byte[] b = new byte[0];
}
/**
* Tests the <CODE>readEnumerated</CODE> method that takes a byte array with
* a short array.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeShortArrayAsEnumerated()
throws Exception
{
byte[] b = new byte[0];
}
/**
* Tests the <CODE>decodeAsInteger</CODE> method that takes a byte array with
* a long length array.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeLongLengthArrayAsInteger()
throws Exception
{
byte[] b = { 0x02, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 };
}
/**
* Tests the <CODE>readEnumerated</CODE> method that takes a byte array with
* a long length array.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeLongLengthArrayAsEnumerated()
throws Exception
{
byte[] b = { 0x02, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 };
}
/**
* Tests the <CODE>decodeAsInteger</CODE> method that takes a byte array with
* a truncated length array.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeTruncatedLengthArrayAsInteger()
throws Exception
{
byte[] b = { 0x02, (byte) 0x82, 0x00 };
}
/**
* Tests the <CODE>readEnumerated</CODE> method that takes a byte array with
* a truncated length array.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeTruncatedLengthArrayAsEnumerated()
throws Exception
{
byte[] b = { 0x02, (byte) 0x82, 0x00 };
}
/**
* Tests the <CODE>decodeAsInteger</CODE> method that takes a byte array with
* a length mismatch.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeLengthMismatchArrayAsInteger()
throws Exception
{
byte[] b = { 0x02, (byte) 0x81, 0x01 };
}
/**
* Tests the <CODE>readEnumerated</CODE> method that takes a byte array with
* a length mismatch.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeLengthMismatchArrayAsEnumerated()
throws Exception
{
byte[] b = { 0x02, (byte) 0x81, 0x01 };
}
/**
* 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.
*/
public void testDecodeValidArrayAsBoolean(byte[] b)
throws Exception
{
// First, test with the standard Boolean type.
// Next, test with a nonstandard Boolean type.
}
/**
* 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.
*/
public void testDecodeValidExtendedArrayAsBoolean(byte[] b)
throws Exception
{
// First, test with the standard Boolean type.
// Next, test with a nonstandard Boolean type.
}
/**
* Tests the <CODE>decodeAsBoolean</CODE> method that takes a byte array
* argument with a short array.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeShortArrayAsBoolean()
throws Exception
{
byte[] b = new byte[1];
}
/**
* 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.
*/
public void testDecodeLongLengthArrayAsBoolean()
throws Exception
{
byte[] b = { 0x01, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 };
}
/**
* 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.
*/
public void testDecodeTruncatedLengthArrayAsBoolean()
throws Exception
{
byte[] b = { 0x01, (byte) 0x82, 0x00 };
}
/**
* Tests the <CODE>decodeAsBoolean</CODE> method that takes a byte array
* argument with an array that has less bytes than indicated by the length.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeLengthMismatchArrayAsBoolean()
throws Exception
{
byte[] b = { 0x01, 0x01 };
}
/**
* 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.
*/
public void testDecodeShortValueArrayAsBoolean()
throws Exception
{
byte[] b = { 0x01, 0x00, 0x00, 0x00 };
}
/**
* 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.
*/
public void testDecodeLongValueArrayAsBoolean()
throws Exception
{
byte[] b = { 0x01, 0x02, 0x00, 0x00 };
}
/**
* Tests the <CODE>decodeAsOctetString</CODE> method that takes a byte array
* using a valid array.
*
* @param b The byte array to decode.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeValidArrayAsOctetString(byte[] b)
throws Exception
{
ByteString.wrap(b));
}
/**
* Tests the <CODE>decodeAsOctetStringAsString</CODE> method that takes a
* byte array using a valid array.
*
* @param b The byte array to decode.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeValidArrayAsOctetStringAsString(byte[] b)
throws Exception
{
new String(b, "UTF-8"));
}
/**
* Tests the <CODE>decodeAsOctetStringAsString</CODE> method that takes a
* byte array using a valid array.
*
* @param b The byte array to decode.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeValidArrayAsOctetStringAsStringCharSet(byte[] b)
throws Exception
{
new String(b, "UTF-8"));
}
/**
* Tests the <CODE>decodeAsOctetStringBuilder</CODE> method that takes a
* byte array using a valid array.
*
* @param b The byte array to decode.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeValidArrayAsOctetStringBuilder(byte[] b)
throws Exception
{
}
/**
* Tests the <CODE>decodeAsOctetString</CODE> method that takes a byte array
* using a short array.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeShortArrayAsOctetString()
throws Exception
{
byte[] b = new byte[1];
}
/**
* Tests the <CODE>decodeAsOctetString</CODE> method that takes a byte array
* using an array that indicates it takes more than four bytes to encode the
* length.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeLongLengthArrayAsOctetString()
throws Exception
{
byte[] b = { 0x04, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x00 };
}
/**
* Tests the <CODE>decodeAsOctetString</CODE> method that takes a byte array
* using an array that doesn't fully contain the length.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeTruncatedLengthArrayAsOctetString()
throws Exception
{
byte[] b = { 0x04, (byte) 0x82, 0x00 };
}
/**
* Tests the <CODE>decodeAsOctetString</CODE> method that takes a byte array
* using an array whose actual length doesn't match with the decoded length.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeLengthMismatchArrayAsOctetString()
throws Exception
{
byte[] b = { 0x04, 0x02, 0x00 };
}
/**
* Tests the <CODE>decodeAsSequence</CODE> method that takes a byte array
* argument with valid arrays.
*
* @param encodedElements Byte arrays that may be used as valid values for
* encoded elements.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeValidArrayAsSequence(byte[] encodedElements)
throws Exception
{
}
/**
* Tests the <CODE>decodeAsSequence</CODE> method that takes a byte array
* argument with a short array.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeShortArrayAsSequence()
throws Exception
{
byte[] b = new byte[1];
}
/**
* Tests the <CODE>decodeAsSequence</CODE> method that takes a byte array
* argument with an array that takes too many bytes to encode the length.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeLongLengthArrayAsSequence()
throws Exception
{
byte[] b = { 0x30, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x00 };
}
/**
* Tests the <CODE>decodeAsSequence</CODE> method that takes a byte array
* argument with an array that doesn't fully describe the length.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeTruncatedLengthArrayAsSequence()
throws Exception
{
byte[] b = { 0x30, (byte) 0x82, 0x00 };
}
/**
* Tests the <CODE>readOctetString</CODE> method when the max element size
* is exceeded.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeOctetStringExceedMaxSize()
throws Exception
{
byte[] b = new byte[] { 0x04, 0x05, 0x48, 0x65, 0x6C, 0x6C, 0x6F };
}
/**
* Tests the <CODE>readOctetString</CODE> method when the max element size
* is exceeded.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeSequenceExceedMaxSize()
throws Exception
{
byte[] b = new byte[] { 0x30, 0x07, 0x04, 0x05, 0x48, 0x65, 0x6C, 0x6C, 0x6F };
}
/**
* Tests to make sure a premature EOF while reading a sub sequence can be
* detected.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testDecodeSequencePrematureEof()
throws Exception
{
// An ASN.1 sequence of booleans missing one boolean element at the end
byte[] b = new byte[] { 0x30, 0x09, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00 };
while(reader.hasNextElement())
{
}
}
/**
* Tests to make sure trailing components are ignored if not used.
*
* @throws Exception If an unexpected problem occurs.
*/
@Test
public void testDecodeSequenceIncompleteRead()
throws Exception
{
// An ASN.1 sequence of booleans missing one boolean element at the end
byte[] b = new byte[] { 0x30, 0x06, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00 };
}
/**
* Tests the <CODE>skipElement</CODE> method.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testSkipElementIncompleteRead()
throws Exception
{
// An ASN.1 sequence of booleans missing one boolean element at the end
byte[] b = new byte[] { 0x30, 0x09, 0x01, 0x01, 0x00, 0x01, 0x02 };
}
/**
* Tests the <CODE>skipElement</CODE> method.
*
* @throws Exception If an unexpected problem occurs.
*/
@Test
public void testSkipElement()
throws Exception
{
// An ASN.1 sequence of booleans missing one boolean element at the end
byte[] b = new byte[] { 0x30, 0x09, 0x02, 0x01, 0x00, 0x02, 0x01, 0x01,
0x02, 0x01, 0x02 };
}
/**
* Tests the <CODE>elementAvailable</CODE> method.
*
* @throws Exception If an unexpected problem occurs.
*/
@Test
public void testElementAvailable()
throws Exception
{
// An ASN.1 sequence of booleans missing one boolean element at the end
byte[] b = new byte[] { 0x30, 0x06, 0x02, 0x01, 0x00, 0x02 };
b = new byte[] { 0x30, 0x03, 0x02, 0x01, 0x00 };
}
/**
* Tests the <CODE>hasNextElement</CODE> method.
*
* @throws Exception If an unexpected problem occurs.
*/
@Test
public void testHasNextElement()
throws Exception
{
// An ASN.1 sequence of booleans missing one boolean element at the end
byte[] b = new byte[] { 0x30, 0x06, 0x02, 0x01, 0x00, 0x02, 0x00, 0x03 };
b = new byte[] { 0x30, 0x03, 0x02, 0x01, 0x00 };
}
/**
* Tests the <CODE>readEndSequence</CODE> method without first calling
* readStartSequence.
*
* @throws Exception If an unexpected problem occurs.
*/
public void testReadEndSequenceNoStartSequence()
throws Exception
{
byte[] b = { 0x30, 0x01, 0x00 };
}
}