mirror of https://github.com/OpenIdentityPlatform/OpenDJ.git

Matthew Swift
25.33.2012 263d085885df024dca9250cc03c807912b0a7662
opendj3/opendj-ldap-sdk/src/test/java/org/forgerock/opendj/asn1/ASN1ReaderTestCase.java
@@ -6,17 +6,16 @@
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at
 * trunk/opendj3/legal-notices/CDDLv1_0.txt
 * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
 * or http://forgerock.org/license/CDDLv1.0.html.
 * 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/opendj3/legal-notices/CDDLv1_0.txt.  If applicable,
 * add the following below this CDDL HEADER, with the fields enclosed
 * by brackets "[]" replaced with your own identifying information:
 * file and include the License file at legal-notices/CDDLv1_0.txt.
 * 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
@@ -27,16 +26,12 @@
 */
package org.forgerock.opendj.asn1;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
import java.io.IOException;
import org.forgerock.opendj.asn1.ASN1Constants;
import org.forgerock.opendj.asn1.ASN1Reader;
import org.forgerock.opendj.ldap.ByteString;
import org.forgerock.opendj.ldap.ByteStringBuilder;
import org.forgerock.opendj.ldap.DecodeException;
@@ -44,882 +39,731 @@
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
/**
 * An abstract base class for all ASN1Reader test cases.
 */
@Test(groups = { "precommit", "asn1", "sdk" })
public abstract class ASN1ReaderTestCase extends ForgeRockTestCase
{
public abstract class ASN1ReaderTestCase extends ForgeRockTestCase {
  /**
   * 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()
  {
    final Object[][] array = new Object[256][1];
    for (int i = 0; i < 256; i++)
    {
      array[i] = new Object[] { new byte[] { (byte) (i & 0xFF) } };
    /**
     * 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() {
        final Object[][] array = new Object[256][1];
        for (int i = 0; i < 256; i++) {
            array[i] = new Object[] { new byte[] { (byte) (i & 0xFF) } };
        }
        return array;
    }
    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.
   */
  @DataProvider(name = "elementArrays")
  public Object[][] getElementArrays()
  {
    return new Object[][] {
        new Object[] { new byte[] { 0x04, 0x00 } },
        new Object[] { new byte[] { (byte) 0x50, 0x00 } },
        new Object[] { new byte[] { 0x04, 0x05, 0x48, 0x65, 0x6C, 0x6C, 0x6F } },
        new Object[] { new byte[] { 0x01, 0x01, 0x00 } },
        new Object[] { new byte[] { 0x01, 0x01, (byte) 0xFF } },
        new Object[] { new byte[] { 0x0A, 0x01, 0x00 } },
        new Object[] { new byte[] { 0x0A, 0x01, 0x01 } },
        new Object[] { new byte[] { 0x0A, 0x01, 0x7F } },
        new Object[] { new byte[] { 0x0A, 0x01, (byte) 0x80 } },
        new Object[] { new byte[] { 0x0A, 0x01, (byte) 0xFF } },
        new Object[] { new byte[] { 0x0A, 0x02, 0x01, 0x00 } },
        new Object[] { new byte[] { 0x02, 0x01, 0x00 } },
        new Object[] { new byte[] { 0x02, 0x01, 0x01 } },
        new Object[] { new byte[] { 0x02, 0x01, 0x7F } },
        new Object[] { new byte[] { 0x02, 0x02, 0x00, (byte) 0x80 } },
        new Object[] { new byte[] { 0x02, 0x02, 0x00, (byte) 0xFF } },
        new Object[] { new byte[] { 0x02, 0x02, 0x01, 0x00 } },
        new Object[] { new byte[] { 0x05, 0x00 } },
        new Object[] { new byte[] { 0x30, 0x00 } },
        new Object[] { new byte[] { 0x31, 0x00 } },
        new Object[] { new byte[] { 0x05, (byte) 0x81, 0x00 } },
        new Object[] { new byte[] { 0x05, (byte) 0x82, 0x00, 0x00 } },
        new Object[] { new byte[] { 0x05, (byte) 0x83, 0x00, 0x00, 0x00 } },
        new Object[] { new byte[] { 0x05, (byte) 0x84, 0x00, 0x00, 0x00, 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
  {
    final byte[] b = new byte[] { 0x05, (byte) 0x81, 0x00 };
    getReader(b, 0).readNull();
  }
  /**
   * 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.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeLengthMismatchArrayAsBoolean() throws Exception
  {
    final byte[] b = { 0x01, 0x01 };
    getReader(b, 0).readBoolean();
  }
  /**
   * Tests the <CODE>readEnumerated</CODE> method that takes a byte array with a
   * length mismatch.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeLengthMismatchArrayAsEnumerated() throws Exception
  {
    final byte[] b = { 0x02, (byte) 0x81, 0x01 };
    getReader(b, 0).readEnumerated();
  }
  /**
   * Tests the <CODE>decodeAsInteger</CODE> method that takes a byte array with
   * a length mismatch.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeLengthMismatchArrayAsInteger() throws Exception
  {
    final byte[] b = { 0x02, (byte) 0x81, 0x01 };
    getReader(b, 0).readInteger();
  }
  /**
   * 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.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeLengthMismatchArrayAsOctetString() throws Exception
  {
    final byte[] b = { 0x04, 0x02, 0x00 };
    getReader(b, 0).readOctetString();
  }
  /**
   * 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 = { DecodeException.class, IOException.class })
  public void testDecodeLongLengthArrayAsBoolean() throws Exception
  {
    final byte[] b = { 0x01, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 };
    getReader(b, 0).readBoolean();
  }
  /**
   * Tests the <CODE>readEnumerated</CODE> method that takes a byte array with a
   * long length array.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeLongLengthArrayAsEnumerated() throws Exception
  {
    final byte[] b = { 0x02, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 };
    getReader(b, 0).readEnumerated();
  }
  /**
   * Tests the <CODE>decodeAsInteger</CODE> method that takes a byte array with
   * a long length array.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeLongLengthArrayAsInteger() throws Exception
  {
    final byte[] b = { 0x02, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 };
    getReader(b, 0).readInteger();
  }
  /**
   * 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.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeLongLengthArrayAsNull() throws Exception
  {
    final byte[] b = new byte[] { 0x05, (byte) 0x85, 0x00, 0x00, 0x00, 0x00,
        0x00 };
    getReader(b, 0).readNull();
  }
  /**
   * 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.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeLongLengthArrayAsOctetString() throws Exception
  {
    final byte[] b = { 0x04, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x00 };
    getReader(b, 0).readOctetString();
  }
  /**
   * 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.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeLongLengthArrayAsSequence() throws Exception
  {
    final byte[] b = { 0x30, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x00 };
    getReader(b, 0).readStartSequence();
  }
  /**
   * 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 = { DecodeException.class, IOException.class })
  public void testDecodeLongValueArrayAsBoolean() throws Exception
  {
    final byte[] b = { 0x01, 0x02, 0x00, 0x00 };
    getReader(b, 0).readBoolean();
  }
  /**
   * 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.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeNonZeroLengthArrayAsNull() throws Exception
  {
    final byte[] b = new byte[] { 0x05, 0x01, 0x00 };
    getReader(b, 0).readNull();
  }
  /**
   * Tests the <CODE>readOctetString</CODE> method when the max element size is
   * exceeded.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeOctetStringExceedMaxSize() throws Exception
  {
    final byte[] b = new byte[] { 0x04, 0x05, 0x48, 0x65, 0x6C, 0x6C, 0x6F };
    getReader(b, 3).readOctetString();
  }
  /**
   * Tests the <CODE>readOctetString</CODE> method when the max element size is
   * exceeded.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeSequenceExceedMaxSize() throws Exception
  {
    final byte[] b = new byte[] { 0x30, 0x07, 0x04, 0x05, 0x48, 0x65, 0x6C,
        0x6C, 0x6F };
    getReader(b, 3).readOctetString();
  }
  /**
   * 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
    final byte[] b = new byte[] { 0x30, 0x06, 0x01, 0x01, 0x01, 0x01, 0x01,
        0x01, 0x01, 0x01, 0x00 };
    final ASN1Reader reader = getReader(b, 0);
    reader.readStartSequence();
    reader.readEndSequence();
    assertFalse(reader.readBoolean());
  }
  /**
   * Tests to make sure a premature EOF while reading a sub sequence can be
   * detected.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeSequencePrematureEof() throws Exception
  {
    // An ASN.1 sequence of booleans missing one boolean element at the end
    final byte[] b = new byte[] { 0x30, 0x09, 0x01, 0x01, 0x00, 0x01, 0x01,
        0x00 };
    final ASN1Reader reader = getReader(b, 0);
    reader.readStartSequence();
    while (reader.hasNextElement())
    {
      reader.readBoolean();
    /**
     * 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.
     */
    @DataProvider(name = "elementArrays")
    public Object[][] getElementArrays() {
        return new Object[][] { new Object[] { new byte[] { 0x04, 0x00 } },
            new Object[] { new byte[] { (byte) 0x50, 0x00 } },
            new Object[] { new byte[] { 0x04, 0x05, 0x48, 0x65, 0x6C, 0x6C, 0x6F } },
            new Object[] { new byte[] { 0x01, 0x01, 0x00 } },
            new Object[] { new byte[] { 0x01, 0x01, (byte) 0xFF } },
            new Object[] { new byte[] { 0x0A, 0x01, 0x00 } },
            new Object[] { new byte[] { 0x0A, 0x01, 0x01 } },
            new Object[] { new byte[] { 0x0A, 0x01, 0x7F } },
            new Object[] { new byte[] { 0x0A, 0x01, (byte) 0x80 } },
            new Object[] { new byte[] { 0x0A, 0x01, (byte) 0xFF } },
            new Object[] { new byte[] { 0x0A, 0x02, 0x01, 0x00 } },
            new Object[] { new byte[] { 0x02, 0x01, 0x00 } },
            new Object[] { new byte[] { 0x02, 0x01, 0x01 } },
            new Object[] { new byte[] { 0x02, 0x01, 0x7F } },
            new Object[] { new byte[] { 0x02, 0x02, 0x00, (byte) 0x80 } },
            new Object[] { new byte[] { 0x02, 0x02, 0x00, (byte) 0xFF } },
            new Object[] { new byte[] { 0x02, 0x02, 0x01, 0x00 } },
            new Object[] { new byte[] { 0x05, 0x00 } }, new Object[] { new byte[] { 0x30, 0x00 } },
            new Object[] { new byte[] { 0x31, 0x00 } },
            new Object[] { new byte[] { 0x05, (byte) 0x81, 0x00 } },
            new Object[] { new byte[] { 0x05, (byte) 0x82, 0x00, 0x00 } },
            new Object[] { new byte[] { 0x05, (byte) 0x83, 0x00, 0x00, 0x00 } },
            new Object[] { new byte[] { 0x05, (byte) 0x84, 0x00, 0x00, 0x00, 0x00 } }, };
    }
    reader.readEndSequence();
  }
    /**
     * 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 {
        final byte[] b = new byte[] { 0x05, (byte) 0x81, 0x00 };
        getReader(b, 0).readNull();
    }
    /**
     * 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.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeLengthMismatchArrayAsBoolean() throws Exception {
        final byte[] b = { 0x01, 0x01 };
        getReader(b, 0).readBoolean();
    }
  /**
   * 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 = { DecodeException.class, IOException.class })
  public void testDecodeShortArrayAsBoolean() throws Exception
  {
    final byte[] b = new byte[1];
    getReader(b, 0).readBoolean();
  }
    /**
     * Tests the <CODE>readEnumerated</CODE> method that takes a byte array with
     * a length mismatch.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeLengthMismatchArrayAsEnumerated() throws Exception {
        final byte[] b = { 0x02, (byte) 0x81, 0x01 };
        getReader(b, 0).readEnumerated();
    }
    /**
     * Tests the <CODE>decodeAsInteger</CODE> method that takes a byte array
     * with a length mismatch.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeLengthMismatchArrayAsInteger() throws Exception {
        final byte[] b = { 0x02, (byte) 0x81, 0x01 };
        getReader(b, 0).readInteger();
    }
    /**
     * 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.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeLengthMismatchArrayAsOctetString() throws Exception {
        final byte[] b = { 0x04, 0x02, 0x00 };
        getReader(b, 0).readOctetString();
    }
  /**
   * Tests the <CODE>readEnumerated</CODE> method that takes a byte array with a
   * short array.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeShortArrayAsEnumerated() throws Exception
  {
    final byte[] b = new byte[0];
    getReader(b, 0).readEnumerated();
  }
    /**
     * 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 = { DecodeException.class, IOException.class })
    public void testDecodeLongLengthArrayAsBoolean() throws Exception {
        final byte[] b = { 0x01, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 };
        getReader(b, 0).readBoolean();
    }
    /**
     * Tests the <CODE>readEnumerated</CODE> method that takes a byte array with
     * a long length array.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeLongLengthArrayAsEnumerated() throws Exception {
        final byte[] b = { 0x02, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 };
        getReader(b, 0).readEnumerated();
    }
    /**
     * Tests the <CODE>decodeAsInteger</CODE> method that takes a byte array
     * with a long length array.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeLongLengthArrayAsInteger() throws Exception {
        final byte[] b = { 0x02, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 };
        getReader(b, 0).readInteger();
    }
  /**
   * Tests the <CODE>decodeAsInteger</CODE> method that takes a byte array with
   * a short array.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeShortArrayAsInteger() throws Exception
  {
    final byte[] b = new byte[0];
    getReader(b, 0).readInteger();
  }
    /**
     * 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.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeLongLengthArrayAsNull() throws Exception {
        final byte[] b = new byte[] { 0x05, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x00 };
        getReader(b, 0).readNull();
    }
    /**
     * 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.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeLongLengthArrayAsOctetString() throws Exception {
        final byte[] b = { 0x04, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x00 };
        getReader(b, 0).readOctetString();
    }
    /**
     * 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.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeLongLengthArrayAsSequence() throws Exception {
        final byte[] b = { 0x30, (byte) 0x85, 0x00, 0x00, 0x00, 0x00, 0x00 };
        getReader(b, 0).readStartSequence();
    }
  /**
   * Tests the <CODE>decodeAsNull</CODE> method that takes a byte array argument
   * with a short array.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeShortArrayAsNull() throws Exception
  {
    final byte[] b = new byte[1];
    getReader(b, 0).readNull();
  }
    /**
     * 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 = { DecodeException.class, IOException.class })
    public void testDecodeLongValueArrayAsBoolean() throws Exception {
        final byte[] b = { 0x01, 0x02, 0x00, 0x00 };
        getReader(b, 0).readBoolean();
    }
    /**
     * 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.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeNonZeroLengthArrayAsNull() throws Exception {
        final byte[] b = new byte[] { 0x05, 0x01, 0x00 };
        getReader(b, 0).readNull();
    }
    /**
     * Tests the <CODE>readOctetString</CODE> method when the max element size
     * is exceeded.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeOctetStringExceedMaxSize() throws Exception {
        final byte[] b = new byte[] { 0x04, 0x05, 0x48, 0x65, 0x6C, 0x6C, 0x6F };
        getReader(b, 3).readOctetString();
    }
  /**
   * Tests the <CODE>decodeAsOctetString</CODE> method that takes a byte array
   * using a short array.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeShortArrayAsOctetString() throws Exception
  {
    final byte[] b = new byte[1];
    getReader(b, 0).readOctetString();
  }
    /**
     * Tests the <CODE>readOctetString</CODE> method when the max element size
     * is exceeded.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeSequenceExceedMaxSize() throws Exception {
        final byte[] b = new byte[] { 0x30, 0x07, 0x04, 0x05, 0x48, 0x65, 0x6C, 0x6C, 0x6F };
        getReader(b, 3).readOctetString();
    }
    /**
     * 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
        final byte[] b =
                new byte[] { 0x30, 0x06, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00 };
        final ASN1Reader reader = getReader(b, 0);
        reader.readStartSequence();
        reader.readEndSequence();
        assertFalse(reader.readBoolean());
    }
    /**
     * Tests to make sure a premature EOF while reading a sub sequence can be
     * detected.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeSequencePrematureEof() throws Exception {
        // An ASN.1 sequence of booleans missing one boolean element at the end
        final byte[] b = new byte[] { 0x30, 0x09, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00 };
        final ASN1Reader reader = getReader(b, 0);
        reader.readStartSequence();
        while (reader.hasNextElement()) {
            reader.readBoolean();
        }
        reader.readEndSequence();
    }
  /**
   * Tests the <CODE>decodeAsSequence</CODE> method that takes a byte array
   * argument with a short array.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeShortArrayAsSequence() throws Exception
  {
    final byte[] b = new byte[1];
    getReader(b, 0).readStartSequence();
  }
    /**
     * 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 = { DecodeException.class, IOException.class })
    public void testDecodeShortArrayAsBoolean() throws Exception {
        final byte[] b = new byte[1];
        getReader(b, 0).readBoolean();
    }
    /**
     * Tests the <CODE>readEnumerated</CODE> method that takes a byte array with
     * a short array.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeShortArrayAsEnumerated() throws Exception {
        final byte[] b = new byte[0];
        getReader(b, 0).readEnumerated();
    }
    /**
     * Tests the <CODE>decodeAsInteger</CODE> method that takes a byte array
     * with a short array.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeShortArrayAsInteger() throws Exception {
        final byte[] b = new byte[0];
        getReader(b, 0).readInteger();
    }
  /**
   * 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 = { DecodeException.class, IOException.class })
  public void testDecodeShortValueArrayAsBoolean() throws Exception
  {
    final byte[] b = { 0x01, 0x00, 0x00, 0x00 };
    getReader(b, 0).readBoolean();
  }
    /**
     * Tests the <CODE>decodeAsNull</CODE> method that takes a byte array
     * argument with a short array.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeShortArrayAsNull() throws Exception {
        final byte[] b = new byte[1];
        getReader(b, 0).readNull();
    }
    /**
     * Tests the <CODE>decodeAsOctetString</CODE> method that takes a byte array
     * using a short array.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeShortArrayAsOctetString() throws Exception {
        final byte[] b = new byte[1];
        getReader(b, 0).readOctetString();
    }
    /**
     * Tests the <CODE>decodeAsSequence</CODE> method that takes a byte array
     * argument with a short array.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeShortArrayAsSequence() throws Exception {
        final byte[] b = new byte[1];
        getReader(b, 0).readStartSequence();
    }
  /**
   * 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 = { DecodeException.class, IOException.class })
  public void testDecodeTruncatedLengthArrayAsBoolean() throws Exception
  {
    final byte[] b = { 0x01, (byte) 0x82, 0x00 };
    getReader(b, 0).readBoolean();
  }
    /**
     * 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 = { DecodeException.class, IOException.class })
    public void testDecodeShortValueArrayAsBoolean() throws Exception {
        final byte[] b = { 0x01, 0x00, 0x00, 0x00 };
        getReader(b, 0).readBoolean();
    }
    /**
     * 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 = { DecodeException.class, IOException.class })
    public void testDecodeTruncatedLengthArrayAsBoolean() throws Exception {
        final byte[] b = { 0x01, (byte) 0x82, 0x00 };
        getReader(b, 0).readBoolean();
    }
    /**
     * Tests the <CODE>readEnumerated</CODE> method that takes a byte array with
     * a truncated length array.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeTruncatedLengthArrayAsEnumerated() throws Exception {
        final byte[] b = { 0x02, (byte) 0x82, 0x00 };
        getReader(b, 0).readEnumerated();
    }
  /**
   * Tests the <CODE>readEnumerated</CODE> method that takes a byte array with a
   * truncated length array.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeTruncatedLengthArrayAsEnumerated() throws Exception
  {
    final byte[] b = { 0x02, (byte) 0x82, 0x00 };
    getReader(b, 0).readEnumerated();
  }
    /**
     * Tests the <CODE>decodeAsInteger</CODE> method that takes a byte array
     * with a truncated length array.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeTruncatedLengthArrayAsInteger() throws Exception {
        final byte[] b = { 0x02, (byte) 0x82, 0x00 };
        getReader(b, 0).readInteger();
    }
    /**
     * 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.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeTruncatedLengthArrayAsNull() throws Exception {
        final byte[] b = new byte[] { 0x05, (byte) 0x82, 0x00 };
        getReader(b, 0).readNull();
    }
    /**
     * 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.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeTruncatedLengthArrayAsOctetString() throws Exception {
        final byte[] b = { 0x04, (byte) 0x82, 0x00 };
        getReader(b, 0).readOctetString();
    }
  /**
   * Tests the <CODE>decodeAsInteger</CODE> method that takes a byte array with
   * a truncated length array.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeTruncatedLengthArrayAsInteger() throws Exception
  {
    final byte[] b = { 0x02, (byte) 0x82, 0x00 };
    getReader(b, 0).readInteger();
  }
    /**
     * 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.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testDecodeTruncatedLengthArrayAsSequence() throws Exception {
        final byte[] b = { 0x30, (byte) 0x82, 0x00 };
        getReader(b, 0).readStartSequence();
    }
    /**
     * 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(final byte[] b) throws Exception {
        // First, test with the standard Boolean type.
        final byte[] elementArray = new byte[] { 0x01, 0x01, b[0] };
        assertEquals(getReader(elementArray, 0).readBoolean(), (b[0] != 0x00));
        // Next, test with a nonstandard Boolean type.
        elementArray[0] = (byte) 0x50;
        assertEquals(getReader(elementArray, 0).readBoolean(), (b[0] != 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.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeTruncatedLengthArrayAsNull() throws Exception
  {
    final byte[] b = new byte[] { 0x05, (byte) 0x82, 0x00 };
    getReader(b, 0).readNull();
  }
  /**
   * 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.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeTruncatedLengthArrayAsOctetString() throws Exception
  {
    final byte[] b = { 0x04, (byte) 0x82, 0x00 };
    getReader(b, 0).readOctetString();
  }
  /**
   * 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.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testDecodeTruncatedLengthArrayAsSequence() throws Exception
  {
    final byte[] b = { 0x30, (byte) 0x82, 0x00 };
    getReader(b, 0).readStartSequence();
  }
  /**
   * 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(final byte[] b) throws Exception
  {
    // First, test with the standard Boolean type.
    final byte[] elementArray = new byte[] { 0x01, 0x01, b[0] };
    assertEquals(getReader(elementArray, 0).readBoolean(), (b[0] != 0x00));
    // Next, test with a nonstandard Boolean type.
    elementArray[0] = (byte) 0x50;
    assertEquals(getReader(elementArray, 0).readBoolean(), (b[0] != 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.
   */
  @Test(dataProvider = "elementArrays")
  public void testDecodeValidArrayAsOctetString(final byte[] b)
      throws Exception
  {
    final ByteStringBuilder bsb = new ByteStringBuilder();
    bsb.append(ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE);
    bsb.appendBERLength(b.length);
    bsb.append(b);
    assertEquals(getReader(bsb.toByteArray(), 0).readOctetString(), 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.
   */
  @Test(dataProvider = "elementArrays")
  public void testDecodeValidArrayAsOctetStringAsString(final byte[] b)
      throws Exception
  {
    final ByteStringBuilder bsb = new ByteStringBuilder();
    bsb.append(ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE);
    bsb.appendBERLength(b.length);
    bsb.append(b);
    assertEquals(getReader(bsb.toByteArray(), 0).readOctetStringAsString(),
        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.
   */
  @Test(dataProvider = "elementArrays")
  public void testDecodeValidArrayAsOctetStringAsStringCharSet(final byte[] b)
      throws Exception
  {
    final ByteStringBuilder bsb = new ByteStringBuilder();
    bsb.append(ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE);
    bsb.appendBERLength(b.length);
    bsb.append(b);
    assertEquals(getReader(bsb.toByteArray(), 0).readOctetStringAsString(),
        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.
   */
  @Test(dataProvider = "elementArrays")
  public void testDecodeValidArrayAsOctetStringBuilder(final byte[] b)
      throws Exception
  {
    final ByteStringBuilder bsb = new ByteStringBuilder();
    bsb.append(ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE);
    bsb.appendBERLength(b.length);
    bsb.append(b);
    final ByteStringBuilder bsb2 = new ByteStringBuilder();
    getReader(bsb.toByteArray(), 0).readOctetString(bsb2);
    assertEquals(bsb2.toByteString(), ByteString.wrap(b));
  }
  /**
   * 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.
   */
  @Test(dataProvider = "elementArrays")
  public void testDecodeValidArrayAsSequence(final byte[] encodedElements)
      throws Exception
  {
    final ByteStringBuilder bsb = new ByteStringBuilder();
    bsb.append(ASN1Constants.UNIVERSAL_SEQUENCE_TYPE);
    bsb.appendBERLength(encodedElements.length + 2);
    bsb.append(ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE);
    bsb.appendBERLength(encodedElements.length);
    bsb.append(encodedElements);
    final ASN1Reader reader = getReader(bsb.toByteArray(), 0);
    assertEquals(reader.peekLength(), encodedElements.length + 2);
    reader.readStartSequence();
    assertEquals(reader.peekType(), ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE);
    assertEquals(reader.peekLength(), encodedElements.length);
    reader.readOctetString().equals(ByteString.wrap(encodedElements));
    reader.readEndSequence();
  }
  /**
   * 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(final byte[] b)
      throws Exception
  {
    // First, test with the standard Boolean type.
    final byte[] elementArray = new byte[] { 0x01, (byte) 0x81, 0x01, b[0] };
    assertEquals(getReader(elementArray, 0).readBoolean(), (b[0] != 0x00));
    // Next, test with a nonstandard Boolean type.
    elementArray[0] = (byte) 0x50;
    assertEquals(getReader(elementArray, 0).readBoolean(), (b[0] != 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
  {
    final byte[] b = new byte[] { 0x05, 0x00 };
    getReader(b, 0).readNull();
  }
    /**
     * 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.
     */
    @Test(dataProvider = "elementArrays")
    public void testDecodeValidArrayAsOctetString(final byte[] b) throws Exception {
        final ByteStringBuilder bsb = new ByteStringBuilder();
        bsb.append(ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE);
        bsb.appendBERLength(b.length);
        bsb.append(b);
        assertEquals(getReader(bsb.toByteArray(), 0).readOctetString(), 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.
     */
    @Test(dataProvider = "elementArrays")
    public void testDecodeValidArrayAsOctetStringAsString(final byte[] b) throws Exception {
        final ByteStringBuilder bsb = new ByteStringBuilder();
        bsb.append(ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE);
        bsb.appendBERLength(b.length);
        bsb.append(b);
  /**
   * 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 };
    ASN1Reader reader = getReader(b, 0);
    assertFalse(reader.elementAvailable());
        assertEquals(getReader(bsb.toByteArray(), 0).readOctetStringAsString(), new String(b,
                "UTF-8"));
    }
    b = new byte[] { 0x30, 0x03, 0x02, 0x01, 0x00 };
    reader = getReader(b, 0);
    assertTrue(reader.elementAvailable());
    reader.readStartSequence();
    assertTrue(reader.elementAvailable());
    reader.readInteger();
    assertFalse(reader.elementAvailable());
  }
    /**
     * 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.
     */
    @Test(dataProvider = "elementArrays")
    public void testDecodeValidArrayAsOctetStringAsStringCharSet(final byte[] b) throws Exception {
        final ByteStringBuilder bsb = new ByteStringBuilder();
        bsb.append(ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE);
        bsb.appendBERLength(b.length);
        bsb.append(b);
        assertEquals(getReader(bsb.toByteArray(), 0).readOctetStringAsString(), 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.
     */
    @Test(dataProvider = "elementArrays")
    public void testDecodeValidArrayAsOctetStringBuilder(final byte[] b) throws Exception {
        final ByteStringBuilder bsb = new ByteStringBuilder();
        bsb.append(ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE);
        bsb.appendBERLength(b.length);
        bsb.append(b);
  /**
   * 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 };
    ASN1Reader reader = getReader(b, 0);
    assertTrue(reader.hasNextElement());
    reader.readStartSequence();
    assertTrue(reader.hasNextElement());
    reader.readInteger();
    assertTrue(reader.hasNextElement());
        final ByteStringBuilder bsb2 = new ByteStringBuilder();
        getReader(bsb.toByteArray(), 0).readOctetString(bsb2);
        assertEquals(bsb2.toByteString(), ByteString.wrap(b));
    }
    b = new byte[] { 0x30, 0x03, 0x02, 0x01, 0x00 };
    reader = getReader(b, 0);
    assertTrue(reader.hasNextElement());
    reader.readStartSequence();
    assertTrue(reader.hasNextElement());
    reader.readInteger();
    assertFalse(reader.hasNextElement());
  }
    /**
     * 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.
     */
    @Test(dataProvider = "elementArrays")
    public void testDecodeValidArrayAsSequence(final byte[] encodedElements) throws Exception {
        final ByteStringBuilder bsb = new ByteStringBuilder();
        bsb.append(ASN1Constants.UNIVERSAL_SEQUENCE_TYPE);
        bsb.appendBERLength(encodedElements.length + 2);
        bsb.append(ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE);
        bsb.appendBERLength(encodedElements.length);
        bsb.append(encodedElements);
        final ASN1Reader reader = getReader(bsb.toByteArray(), 0);
        assertEquals(reader.peekLength(), encodedElements.length + 2);
        reader.readStartSequence();
        assertEquals(reader.peekType(), ASN1Constants.UNIVERSAL_OCTET_STRING_TYPE);
        assertEquals(reader.peekLength(), encodedElements.length);
        reader.readOctetString().equals(ByteString.wrap(encodedElements));
        reader.readEndSequence();
    }
    /**
     * 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(final byte[] b) throws Exception {
        // First, test with the standard Boolean type.
        final byte[] elementArray = new byte[] { 0x01, (byte) 0x81, 0x01, b[0] };
        assertEquals(getReader(elementArray, 0).readBoolean(), (b[0] != 0x00));
  /**
   * Tests the <CODE>readEndSequence</CODE> method without first calling
   * readStartSequence.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { IllegalStateException.class, IOException.class })
  public void testReadEndSequenceNoStartSequence() throws Exception
  {
    final byte[] b = { 0x30, 0x01, 0x00 };
    getReader(b, 0).readEndSequence();
  }
        // Next, test with a nonstandard Boolean type.
        elementArray[0] = (byte) 0x50;
        assertEquals(getReader(elementArray, 0).readBoolean(), (b[0] != 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 {
        final byte[] b = new byte[] { 0x05, 0x00 };
        getReader(b, 0).readNull();
    }
    /**
     * 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 };
        ASN1Reader reader = getReader(b, 0);
        assertFalse(reader.elementAvailable());
  /**
   * 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
    final byte[] b = new byte[] { 0x30, 0x09, 0x02, 0x01, 0x00, 0x02, 0x01,
        0x01, 0x02, 0x01, 0x02 };
    final ASN1Reader reader = getReader(b, 0);
    reader.readStartSequence();
    reader.readInteger();
    reader.skipElement();
    assertEquals(reader.readInteger(), 2);
    reader.readEndSequence();
  }
        b = new byte[] { 0x30, 0x03, 0x02, 0x01, 0x00 };
        reader = getReader(b, 0);
        assertTrue(reader.elementAvailable());
        reader.readStartSequence();
        assertTrue(reader.elementAvailable());
        reader.readInteger();
        assertFalse(reader.elementAvailable());
    }
    /**
     * 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 };
        ASN1Reader reader = getReader(b, 0);
        assertTrue(reader.hasNextElement());
        reader.readStartSequence();
        assertTrue(reader.hasNextElement());
        reader.readInteger();
        assertTrue(reader.hasNextElement());
        b = new byte[] { 0x30, 0x03, 0x02, 0x01, 0x00 };
        reader = getReader(b, 0);
        assertTrue(reader.hasNextElement());
        reader.readStartSequence();
        assertTrue(reader.hasNextElement());
        reader.readInteger();
        assertFalse(reader.hasNextElement());
    }
  /**
   * Tests the <CODE>skipElement</CODE> method.
   *
   * @throws Exception
   *           If an unexpected problem occurs.
   */
  @Test(expectedExceptions = { DecodeException.class, IOException.class })
  public void testSkipElementIncompleteRead() throws Exception
  {
    // An ASN.1 sequence of booleans missing one boolean element at the end
    final byte[] b = new byte[] { 0x30, 0x09, 0x01, 0x01, 0x00, 0x01, 0x02 };
    final ASN1Reader reader = getReader(b, 0);
    reader.readStartSequence();
    reader.readBoolean();
    reader.skipElement();
    reader.readEndSequence();
  }
    /**
     * Tests the <CODE>readEndSequence</CODE> method without first calling
     * readStartSequence.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { IllegalStateException.class, IOException.class })
    public void testReadEndSequenceNoStartSequence() throws Exception {
        final byte[] b = { 0x30, 0x01, 0x00 };
        getReader(b, 0).readEndSequence();
    }
    /**
     * 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
        final byte[] b =
                new byte[] { 0x30, 0x09, 0x02, 0x01, 0x00, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02 };
        final ASN1Reader reader = getReader(b, 0);
        reader.readStartSequence();
        reader.readInteger();
        reader.skipElement();
        assertEquals(reader.readInteger(), 2);
        reader.readEndSequence();
    }
    /**
     * Tests the <CODE>skipElement</CODE> method.
     *
     * @throws Exception
     *             If an unexpected problem occurs.
     */
    @Test(expectedExceptions = { DecodeException.class, IOException.class })
    public void testSkipElementIncompleteRead() throws Exception {
        // An ASN.1 sequence of booleans missing one boolean element at the end
        final byte[] b = new byte[] { 0x30, 0x09, 0x01, 0x01, 0x00, 0x01, 0x02 };
        final ASN1Reader reader = getReader(b, 0);
        reader.readStartSequence();
        reader.readBoolean();
        reader.skipElement();
        reader.readEndSequence();
    }
  /**
   * 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.
   */
  protected abstract ASN1Reader getReader(byte[] b, int maxElementSize)
      throws IOException;
    /**
     * 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.
     */
    protected abstract ASN1Reader getReader(byte[] b, int maxElementSize) throws IOException;
}