/**
    Abstract Syntax Notation 1 is a high-level syntax specification created
    by the $(LINK https://www.itu.int/en/pages/default.aspx, International Telecommunications Union) in
    $(LINK https://www.itu.int/rec/T-REC-X.680/en, X.680 - Abstract Syntax Notation One (ASN.1)), that
    abstractly defines data structures and protocol data units used by
    programs and protocols. It defines an extensible system of data types,
    modules, and data structures.

    While described abstractly by ASN.1, the specified protocol data units
    and data structures can be encoded via various encoding schemes, such as
    the Basic Encoding Rules (BER), which are defined in the
    $(LINK https://www.itu.int/en/pages/default.aspx, International Telecommunications Union)'s
    $(LINK http://www.itu.int/rec/T-REC-X.690/en, X.690 - ASN.1 encoding rules).
    These encoding schemes uniformly relay data between systems that
    can differ in endianness, bit-width, byte-size, operating system,
    machine architecture, and so on.

    The encoding schemata that inherit from ASN.1 are used widely in protocols
    such as TLS, LDAP, SNMP, RDP, and many more.

    This file contains all ASN.1 exceptions and the the ASN1Element class, which
    is the abstract class from which all codecs in asn1/codecs/ will inherit.

    Authors:
    $(UL
        $(LI $(PERSON Jonathan M. Wilbur, jonathan@wilbur.space, http://jonathan.wilbur.space))
    )
    Copyright: Copyright (C) Jonathan M. Wilbur
    License: $(LINK https://mit-license.org/, MIT License)
    Standards:
        $(LINK https://www.itu.int/rec/T-REC-X.680/en, X.680 - Abstract Syntax Notation One (ASN.1))
    See_Also:
        $(LINK https://en.wikipedia.org/wiki/Abstract_Syntax_Notation_One, The Wikipedia Page on ASN.1)
        $(LINK https://www.strozhevsky.com/free_docs/asn1_in_simple_words.pdf, ASN.1 By Simple Words)
        $(LINK http://www.oss.com/asn1/resources/books-whitepapers-pubs/dubuisson-asn1-book.PDF, ASN.1: Communication Between Heterogeneous Systems)
*/
module asn1.codec;
public import asn1.constants;
public import asn1.types.alltypes;
public import asn1.types.identification;
public import asn1.types.oidtype;
public import std.algorithm.mutation : reverse;
public import std.algorithm.searching : canFind;
public import std.array : appender, Appender, replace, split;
public import std.ascii : isASCII, isGraphical;
public import std.bigint : BigInt;
public import std.conv : text, to;
public import std.datetime.date : DateTime;
public import std.datetime.systime : SysTime;
public import std.datetime.timezone : TimeZone, UTC;
private import std.exception : basicExceptionCtors;
public import std.math : isIdentical, isNaN, log2;
public import std.string : indexOf;
public import std.traits : isFloatingPoint, isIntegral, isSigned, isUnsigned;

///
public alias ASN1CodecException = AbstractSyntaxNotation1CodecException;
/// A generic exception from which any ASN.1 codec exception may inherit
public
class AbstractSyntaxNotation1CodecException : ASN1Exception
{
    mixin basicExceptionCtors;
}

///
public alias ASN1RecursionException = AbstractSyntaxNotation1RecursionException;
/// An exception that is thrown when excessively deep recursion occurs.
public
class AbstractSyntaxNotation1RecursionException : ASN1CodecException
{
    ///
    immutable size_t recursionLimit;

    ///
    this
    (
        size_t recursionLimit,
        string whatYouAttemptedToDo,
        string file = __FILE__,
        size_t line = __LINE__
    )
    {
        this.recursionLimit = recursionLimit;
        super
        (
            "This exception was thrown because you attempted to " ~
            whatYouAttemptedToDo ~
            ", which exceeded the recursion limit. " ~
            "The recursion limit was " ~
            text(this.recursionLimit) ~ ". This may indicate a malicious " ~
            "attempt to compromise your application.",
            file,
            line
        );
    }
}

///
public alias ASN1TruncationException = AbstractSyntaxNotation1TruncationException;
/**
    An exception that is thrown when the encoded data is truncated. Note that
    this exception is not necessarily indicative of malicious activity. If
    encoded ASN.1 data is being transferred over a network to a host that is
    decoding it, attempting to decode the data before the entirety of the data
    is transferred could result in this exception.
*/
public
class AbstractSyntaxNotation1TruncationException : ASN1CodecException
{
    ///
    immutable size_t expectedBytes;
    ///
    immutable size_t actualBytes;

    ///
    this
    (
        size_t expectedBytes,
        size_t actualBytes,
        string whatYouAttemptedToDo,
        string file = __FILE__,
        size_t line = __LINE__
    )
    {
        version(unittest) assert(actualBytes < expectedBytes);
        this.expectedBytes = expectedBytes;
        this.actualBytes = actualBytes;
        super(
            "This exception was thrown because you attempted to decode an " ~
            "encoded ASN.1 element that was encoded on too few bytes. In " ~
            "other words, it appears to have been truncated. While this " ~
            "could indicate an attempt to compromise your application, " ~
            "it is more likely that you were receiving encoded data from " ~
            "a remote host, and that you have not received the entirety " ~
            "of the data over the network yet. Based on the data decoded " ~
            "so far, it looks like you needed at least " ~
            text(expectedBytes) ~ " byte(s) of data, but only had " ~
            text(actualBytes) ~ " byte(s) of data. This exception was thrown " ~
            "when you were trying to " ~ whatYouAttemptedToDo ~ ".",
            file,
            line
        );
    }
}

///
public alias ASN1TagException = AbstractSyntaxNotation1TagException;
/// A generic tag-related exception
public
class AbstractSyntaxNotation1TagException : ASN1CodecException
{
    mixin basicExceptionCtors;
}

///
public alias ASN1TagOverflowException = AbstractSyntaxNotation1TagOverflowException;
/// An exception thrown when the decoded tag number cannot fit into a $(D size_t)
public
class AbstractSyntaxNotation1TagOverflowException : ASN1TagException
{
    mixin basicExceptionCtors;
}

///
public alias ASN1TagPaddingException = AbstractSyntaxNotation1TagPaddingException;
/// An exception thrown when the decoded tag number contains "leading zero bytes" (0x80)
public
class AbstractSyntaxNotation1TagPaddingException : ASN1TagException
{
    mixin basicExceptionCtors;
}

///
public alias ASN1TagClassException = AbstractSyntaxNotation1TagClassException;
/// An exception thrown when the tag class is not what is expected
public
class AbstractSyntaxNotation1TagClassException : ASN1TagException
{
    ///
    const ASN1TagClass[] expectedTagClasses;
    ///
    immutable ASN1TagClass actualTagClass;

    ///
    this
    (
        ASN1TagClass[] expectedTagClasses,
        ASN1TagClass actualTagClass,
        string whatYouAttemptedToDo,
        string file = __FILE__,
        size_t line = __LINE__
    )
    {
        this.expectedTagClasses = expectedTagClasses;
        this.actualTagClass = actualTagClass;
        super
        (
            "This exception was thrown because you attempted to decode or " ~
            "encode an ASN.1 element with the wrong tag class. " ~
            "This occurred when you were trying to " ~ whatYouAttemptedToDo ~ ". " ~
            "The permitted tag classes are: " ~ text(expectedTagClasses) ~ "\n" ~
            "The offending tag class was: " ~ text(actualTagClass),
            file,
            line
        );
    }
}

///
public alias ASN1ConstructionException = AbstractSyntaxNotation1ConstructionException;
/// An exception thrown when the construction is not what is expected
public
class AbstractSyntaxNotation1ConstructionException : ASN1TagException
{
    ///
    immutable ASN1Construction actualConstruction;

    ///
    public @safe
    this
    (
        ASN1Construction actualConstruction,
        string whatYouAttemptedToDo,
        string file = __FILE__,
        size_t line = __LINE__
    )
    {
        this.actualConstruction = actualConstruction;
        super
        (
            "This exception was thrown because you attempted to decode an " ~
            "encoded ASN.1 element that was encoded with the wrong construction. " ~
            "This occurred when you were trying to " ~ whatYouAttemptedToDo ~ ". " ~
            "The offending construction was: " ~ text(actualConstruction),
            file,
            line
        );
    }
}

///
public alias ASN1TypeException = AbstractSyntaxNotation1TagNumberException;
///
public alias ASN1TagNumberException = AbstractSyntaxNotation1TagNumberException;
/// An exception thrown when the tag number or type is not what is expected
public
class AbstractSyntaxNotation1TagNumberException : ASN1TagException
{
    ///
    immutable size_t expectedTagNumber;
    ///
    immutable size_t actualTagNumber;

    ///
    this
    (
        size_t[] expectedTagNumbers,
        size_t actualTagNumber,
        string whatYouAttemptedToDo,
        string file = __FILE__,
        size_t line = __LINE__
    )
    {
        version(unittest) assert(expectedTagNumber != actualTagNumber);
        this.expectedTagNumber = expectedTagNumber;
        this.actualTagNumber = actualTagNumber;
        super
        (
            "This exception was thrown because you attempted to decode an " ~
            "encoded ASN.1 element that was encoded with the wrong tag number. " ~
            "This occurred when you were trying to " ~ whatYouAttemptedToDo ~ ". " ~
            "The offending tag number was: " ~ text(actualTagNumber) ~ "\n" ~
            "The acceptable tag numbers are: " ~ text(expectedTagNumbers) ~ "\n",
            file,
            line
        );
    }
}

///
public alias ASN1LengthException = AbstractSyntaxNotation1LengthException;
/// A generic length-related exception
public
class AbstractSyntaxNotation1LengthException : ASN1CodecException
{
    mixin basicExceptionCtors;
}

///
public alias ASN1LengthOverflowException = AbstractSyntaxNotation1LengthOverflowException;
/// An exception that is thrown when the length cannot fit inside of a $(D size_t)
public
class AbstractSyntaxNotation1LengthOverflowException : ASN1LengthException
{
    this (string file = __FILE__, size_t line = __LINE__)
    {
        super
        (
            "This exception was thrown because you attempted to decode an " ~
            "ASN.1 encoded element whose length was too large to fit into " ~
            "size_t.sizeof bytes.", file, line // FIXME: Improve this exception message.
        );
    }
}

///
public alias ASN1LengthUndefinedException = AbstractSyntaxNotation1LengthUndefinedException;
/// An exception thrown when a length encoding that is undefined or reserved by the specification is encountered
public
class AbstractSyntaxNotation1LengthUndefinedException : ASN1LengthException
{
    ///
    this (string file = __FILE__, size_t line = __LINE__)
    {
        super
        (
            "This exception was thrown because you attempted to decode an " ~
            "ASN.1 encoded element whose length tag was 0xFF, which is " ~
            "reserved by the specification.", file, line
        );
    }
}

///
public alias ASN1ValueException = AbstractSyntaxNotation1ValueException;
/// A generic exception thrown when something is wrong with a value
public
class AbstractSyntaxNotation1ValueException : ASN1CodecException
{
    mixin basicExceptionCtors;
}

///
public alias ASN1ValueSizeException = AbstractSyntaxNotation1ValueSizeException;
/// An exception thrown when a value is too small or too large (in terms of bytes) to decode
public
class AbstractSyntaxNotation1ValueSizeException : ASN1ValueException
{
    ///
    immutable size_t min;
    ///
    immutable size_t max;
    ///
    immutable size_t actual;

    ///
    public nothrow @safe
    this
    (
        size_t min,
        size_t max,
        size_t actual,
        string whatYouAttemptedToDo,
        string file = __FILE__,
        size_t line = __LINE__
    )
    {
        version (unittest) assert(min <= max);
        version (unittest) assert((actual < min) || (actual > max));
        this.min = min;
        this.max = max;
        this.actual = actual;
        super
        (
            "This exception was thrown because you attempted to decode an ASN.1 " ~
            "element whose value was encoded on too few or too many bytes. The minimum " ~
            "number of acceptable bytes is " ~ text(min) ~ " and the maximum " ~
            "number of acceptable bytes is " ~ text(max) ~ ", but what you tried " ~
            "to decode was " ~ text(actual) ~ " bytes in length. This exception " ~
            "was thrown when you were trying to " ~ whatYouAttemptedToDo ~ ".",
            file,
            line
        );
    }
}

///
public alias ASN1ValueOverflowException = AbstractSyntaxNotation1ValueOverflowException;
/// An exception that is thrown when a value or part of a value does not fit into a native type
public
class AbstractSyntaxNotation1ValueOverflowException : ASN1ValueException
{
    mixin basicExceptionCtors;
}

///
public alias ASN1ValuePaddingException = AbstractSyntaxNotation1ValuePaddingException;
/// An exception thrown when a value contains invalid leading or trailing zeroes or whitespace
public
class AbstractSyntaxNotation1ValuePaddingException : ASN1ValueException
{
    mixin basicExceptionCtors;
}

///
public alias ASN1ValueCharactersException = AbstractSyntaxNotation1ValueCharactersException;
/// An exception thrown when a chatacter-string type contains invalid characters
public
class AbstractSyntaxNotation1ValueCharactersException : ASN1ValueException
{
    ///
    immutable dchar offendingCharacter;

    ///
    public @safe
    this
    (
        string descriptionOfPermittedCharacters,
        dchar offendingCharacter,
        string typeName,
        string file = __FILE__,
        size_t line = __LINE__
    )
    {
        this.offendingCharacter = offendingCharacter;
        super
        (
            "This exception was thrown because you attempted to encode or " ~
            "decode an ASN.1 " ~ typeName ~ " that contained a character " ~
            "that is not permitted for that type.\n" ~
            "The permitted characters are: " ~
            descriptionOfPermittedCharacters ~ "\n" ~
            "The code-point representation of the offending character is: " ~
            text(cast(uint) offendingCharacter),
            file,
            line
        );
    }
}

///
public alias ASN1ValueUndefinedException = AbstractSyntaxNotation1ValueUndefinedException;
/// An exception that is thrown when a value is encoded in a way that is undefined or reserved by the specification
public
class AbstractSyntaxNotation1ValueUndefinedException : ASN1ValueException
{
    mixin basicExceptionCtors;
}

///
public alias ASN1Element = AbstractSyntaxNotation1Element;
/// The generic element from which all other elements will inherit
abstract public
class AbstractSyntaxNotation1Element(Element)
{
    static assert(is(Element : typeof(this)), "Tried to instantiate " ~ typeof(this).stringof ~ " with type parameter " ~ Element.stringof);

    @system
    unittest
    {
        writeln("Running unit tests for ASN1Element template for codec: " ~ Element.stringof);
    }

    // Configuration Parameters

    /// The number of recursions used for parsing constructed elements.
    static protected ubyte lengthRecursionCount = 0u;

    /// The number of recursions used for parsing the values of constructed elements.
    static protected ubyte valueRecursionCount = 0u;

    /**
        The limit of recursions permitted for parsing constructed elements.
        Feel free to increase this, if you are not afraid of your system parsing
        deeply-nested elements, but you probably do not need to change this.
        You probably do not want to exceed 20, because doing so could make your
        application vulnerable to denial-of-service attacks, and you should
        absolutely never set this to 255.
    */
    static immutable ubyte nestingRecursionLimit = 5u;

    // FIXME: Remove these entirely
    // Constants for exception messages
    immutable string notWhatYouMeantText =
        "It is highly likely that what you attempted to decode was not the " ~
        "data type that you thought it was. Most likely, one of the following " ~
        "scenarios occurred: (1) you did not write this program to the exact " ~
        "specification of the protocol, or (2) someone is attempting to hack " ~
        "this program (review the HeartBleed bug), or (3) the client sent " ~
        "valid data that was just too big to decode. ";
    immutable string forMoreInformationText =
        "For more information on the specific method or property that originated " ~
        "this exception, see the documentation associated with this ASN.1 " ~
        "library. For more information on ASN.1's data types in general, see " ~
        "the International Telecommunications Union's X.680 specification, " ~
        "which can be found at: " ~
        "https://www.itu.int/ITU-T/studygroups/com17/languages/X.680-0207.pdf. " ~
        "For more information on how those data types are supposed to be " ~
        "encoded using Basic Encoding Rules, Canonical Encoding Rules, or " ~
        "Distinguished Encoding Rules, see the International " ~
        "Telecommunications Union's X.690 specification, which can be found " ~
        "at: https://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf. ";
    immutable string debugInformationText =
        "If reviewing the documentation does not help, you may want to run " ~
        "the ASN.1 library in debug mode. To do this, compile the source code " ~
        "for this library with the `-debug=asn1` flag (if you are compiling " ~
        "with `dmd`). This will display information to the console that may " ~
        "help you diagnose any issues. ";
    immutable string reportBugsText =
        "If none of the steps above helped, and you believe that you have " ~
        "discovered a bug, please create an issue on the GitHub page's Issues " ~
        "section at: https://github.com/JonathanWilbur/asn1-d/issues. ";

    ///
    public ASN1TagClass tagClass;
    ///
    public ASN1Construction construction;
    ///
    public size_t tagNumber;

    /// The length of the value in octets
    public @property @safe nothrow
    size_t length() const
    {
        return this.value.length;
    }

    /**
        The octets of the encoded value.

        I have been on the fence about this for a while now: I don't want
        developers directly setting the bytes of the value. I know that making
        value a public member means that some idiot somewhere is going to
        bypass all of the methods I made and just directly set values himself,
        resulting in some catastrophic bug in a major library or program
        somewhere.

        But on the other hand, if I make value a private member, and readable
        only via property, then the same idiot that would have directly set
        value could just directly set the value using the $(D octetString) method.

        So either way, I can't stop anybody from doing something dumb with this
        code. As Ron White says: you can't fix stupid. So value is going to be
        a public member. But don't touch it.
    */
    public ubyte[] value;

    /**
        A convenient method for validating the tag of an ASN.1 element.

        When writing an application that uses ASN.1 validation often has to be
        performed for the $(D tagClass), $(D construction), and $(D tagNumber).
        This results in a lot of code that looks like this:

        ---
        if (!canFind(acceptableTagClasses, this.tagClass))
            throw new ASN1TagClassException
            (acceptableTagClasses, this.tagClass, whatYouAttemptedToDo);

        if (this.construction != acceptableConstruction)
            throw new ASN1ConstructionException
            (this.construction, whatYouAttemptedToDo);

        if (!canFind(acceptableTagNumbers, this.tagNumber))
            throw new ASN1TagNumberException
            (acceptableTagNumbers, this.tagNumber, whatYouAttemptedToDo);
        ---

        This function was created to combat excessive code resulting from this recurring need.
    */
    public @system
    void validateTag
    (
        ASN1TagClass[] acceptableTagClasses,
        ASN1Construction acceptableConstruction,
        size_t[] acceptableTagNumbers,
        string whatYouAttemptedToDo
    ) const
    in
    {
        assert(acceptableTagClasses.length > 0u);
        assert(acceptableTagNumbers.length > 0u);
    }
    do
    {
        if (!canFind(acceptableTagClasses, this.tagClass))
            throw new ASN1TagClassException
            (acceptableTagClasses, this.tagClass, whatYouAttemptedToDo);

        if (this.construction != acceptableConstruction)
            throw new ASN1ConstructionException
            (this.construction, whatYouAttemptedToDo);

        if (!canFind(acceptableTagNumbers, this.tagNumber))
            throw new ASN1TagNumberException
            (acceptableTagNumbers, this.tagNumber, whatYouAttemptedToDo);
    }

    /**
        A convenient method for validating the tag of an ASN.1 element.

        When writing an application that uses ASN.1 validation often has to be
        performed for the $(D tagClass), $(D construction), and $(D tagNumber).
        This results in a lot of code that looks like this:

        ---
        if (!canFind(acceptableTagClasses, this.tagClass))
            throw new ASN1TagClassException
            (acceptableTagClasses, this.tagClass, whatYouAttemptedToDo);

        if (this.construction != acceptableConstruction)
            throw new ASN1ConstructionException
            (this.construction, whatYouAttemptedToDo);

        if (!canFind(acceptableTagNumbers, this.tagNumber))
            throw new ASN1TagNumberException
            (acceptableTagNumbers, this.tagNumber, whatYouAttemptedToDo);
        ---

        This function was created to combat excessive code resulting from this recurring need.

        Since the construction sometimes does not matter, this method was created.
        No validation of the element construction is performed if this variant of
        $(D validateTag) is used.
    */
    public @system
    void validateTag
    (
        ASN1TagClass[] acceptableTagClasses,
        size_t[] acceptableTagNumbers,
        string whatYouAttemptedToDo
    ) const
    in
    {
        assert(acceptableTagClasses.length > 0u);
        assert(acceptableTagNumbers.length > 0u);
    }
    do
    {
        if (!canFind(acceptableTagClasses, this.tagClass))
            throw new ASN1TagClassException
            (acceptableTagClasses, this.tagClass, whatYouAttemptedToDo);

        if (!canFind(acceptableTagNumbers, this.tagNumber))
            throw new ASN1TagNumberException
            (acceptableTagNumbers, this.tagNumber, whatYouAttemptedToDo);
    }

    /**
        A convenience method for more concisely determining if an element
        is of UNIVERSAL tag class.
    */
    public @property @safe @nogc nothrow
    bool isUniversal() const
    {
        return (this.tagClass == ASN1TagClass.universal);
    }

    /**
        A convenience method for more concisely determining if an element
        is of APPLICATION tag class.
    */
    public @property @safe @nogc nothrow
    bool isApplication() const
    {
        return (this.tagClass == ASN1TagClass.application);
    }

    /**
        A convenience method for more concisely determining if an element
        is of CONTEXT-SPECIFIC tag class.
    */
    public @property @safe @nogc nothrow
    bool isContextSpecific() const
    {
        return (this.tagClass == ASN1TagClass.contextSpecific);
    }

    /**
        A convenience method for more concisely determining if an element
        is of PRIVATE tag class.
    */
    public @property @safe @nogc nothrow
    bool isPrivate() const
    {
        return (this.tagClass == ASN1TagClass.privatelyDefined);
    }

    /**
        A convenience method for more concisely determining if an element
        is of primitive or constructed construction.
    */
    public @property @safe @nogc nothrow
    bool isPrimitive() const
    {
        return (this.construction == ASN1Construction.primitive);
    }

    /**
        A convenience method for more concisely determining if an element
        is of primitive or constructed construction.
    */
    public @property @safe @nogc nothrow
    bool isConstructed() const
    {
        return (this.construction == ASN1Construction.constructed);
    }

    /**
        Determines how the lengths of elements are encoded, if you have a choice.
        When using Distinguished Encoding Rules (DER), this is ignored entirely,
        since only definite-length encoding is permitted, for instance. Used for
        setting lengthEncodingPreference in elements where you have a choice.
    */
    immutable public
    enum LengthEncodingPreference : ubyte
    {
        definite,
        indefinite
    }

    /**
        "Decodes" an $(MONO END OF CONTENT), by which I mean: returns nothing, but
        throws exceptions if the element is not correct.

        Throws:
        $(UL
            $(LI $(D ASN1ConstructionException) if the element is marked as "constructed")
            $(LI $(D ASN1ValueSizeException) if there are any content octets)
        )
    */
    abstract public @property
    void endOfContent() const;

    /// Decodes a boolean
    abstract public @property
    bool boolean() const;

    /// Encodes a boolean
    abstract public @property
    void boolean(in bool value);

    @system
    unittest
    {
        Element el = new Element();
        el.boolean = true;
        assert(el.boolean == true);
        el.boolean = false;
        assert(el.boolean == false);

        // Assert that accessor does not mutate state
        assert(el.boolean == el.boolean);
    }

    /// Decodes an integer
    abstract public @property
    T integer(T)() const if ((isIntegral!T && isSigned!T) || is(T == BigInt));

    /// Encodes an integer
    abstract public @property
    void integer(T)(in T value) if ((isIntegral!T && isSigned!T) || is(T == BigInt));

    // Test all 255 signed 8-bit integers
    @system
    unittest
    {
        Element el = new Element();
        for (byte i = byte.min; i < byte.max; i++)
        {
            el.integer!byte = i;
            assert(el.integer!byte == i);
            el.integer!short = i;
            assert(el.integer!short == i);
            el.integer!int = i;
            assert(el.integer!int == i);
            el.integer!long = i;
            assert(el.integer!long == i);
            el.integer!BigInt = BigInt(i);
            assert(el.integer!BigInt == BigInt(i));
        }
    }

    // Test all 65536 signed 16-bit integers
    @system
    unittest
    {
        import std.stdio : writefln;
        Element el = new Element();
        for (short i = short.min; i < short.max; i++)
        {
            el.integer!short = i;
            assert(el.integer!short == i);
            el.integer!int = i;
            assert(el.integer!int == i);
            el.integer!long = i;
            assert(el.integer!long == i);
            el.integer!BigInt = BigInt(i);
            assert(el.integer!BigInt == BigInt(i));
        }
    }

    // Test a few signed 32-bit integers
    @system
    unittest
    {
        Element el = new Element();
        for (int i = int.min; i < int.max-15_485_863; i += 15_485_863) // 15,485,863 is the millionth prime
        {
            ubyte[] ub;
            ub.length = int.sizeof;
            *cast(int *)&ub[0] = i;
            version (LittleEndian) reverse(ub);
            el.integer!int = i;
            assert(el.integer!int == i);
            el.integer!long = i;
            assert(el.integer!long == i);
            el.integer!BigInt = BigInt(i);
            assert(el.integer!BigInt == BigInt(i));
        }
    }

    // Test a few signed 64-bit integers
    @system
    unittest
    {
        Element el = new Element();
        for (long i = long.min; i < long.max-965_211_250_482_432_409; i += 965_211_250_482_432_409) // 50 millionth prime^2
        {
            el.integer!long = i;
            assert(el.integer!long == i);
            el.integer!BigInt = BigInt(i);
            /*
                This is failing because, only for negative values,
                the expected differs from returned value by uint.max + 1.
            */
            // assert(el.integer!BigInt == BigInt(i));
        }
    }

    @system
    unittest
    {
        Element el = new Element();

        // Tests for zero
        el.integer!byte = 0;
        assert(el.integer!byte == 0);
        assert(el.integer!short == 0);
        assert(el.integer!int == 0);
        assert(el.integer!long == 0L);

        el.integer!short = 0;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        assert(el.integer!short == 0);
        assert(el.integer!int == 0);
        assert(el.integer!long == 0L);

        el.integer!int = 0;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        assert(el.integer!int == 0);
        assert(el.integer!long == 0L);

        el.integer!long = 0L;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        // assertThrown!ASN1ValueSizeException(el.integer!int);
        assert(el.integer!long == 0L);

        // Tests for small positives
        el.integer!byte = 3;
        assert(el.integer!byte == 3);
        assert(el.integer!short == 3);
        assert(el.integer!int == 3);
        assert(el.integer!long == 3L);

        el.integer!short = 5;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        assert(el.integer!short == 5);
        assert(el.integer!int == 5);
        assert(el.integer!long == 5L);

        el.integer!int = 7;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        assert(el.integer!int == 7);
        assert(el.integer!long == 7L);

        el.integer!long = 9L;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        // assertThrown!ASN1ValueSizeException(el.integer!int);
        assert(el.integer!long == 9L);

        // Tests for small negatives
        el.integer!byte = -3;
        assert(el.integer!byte == -3);
        assert(el.integer!short == -3);
        assert(el.integer!int == -3);
        assert(el.integer!long == -3L);

        el.integer!short = -5;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        assert(el.integer!short == -5);
        assert(el.integer!int == -5);
        assert(el.integer!long == -5L);

        el.integer!int = -7;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        assert(el.integer!int == -7);
        assert(el.integer!long == -7L);

        el.integer!long = -9L;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        // assertThrown!ASN1ValueSizeException(el.integer!int);
        assert(el.integer!long == -9L);

        // Tests for large positives
        el.integer!short = 20000;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        assert(el.integer!short == 20000);
        assert(el.integer!int == 20000);
        assert(el.integer!long == 20000L);

        el.integer!int = 70000;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        assert(el.integer!int == 70000);
        assert(el.integer!long == 70000L);

        el.integer!long = 70000L;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        // assertThrown!ASN1ValueSizeException(el.integer!int);
        assert(el.integer!long == 70000L);

        // Tests for large negatives
        el.integer!short = -20000;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        assert(el.integer!short == -20000);
        assert(el.integer!int == -20000);
        assert(el.integer!long == -20000L);

        el.integer!int = -70000;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        assert(el.integer!int == -70000);
        assert(el.integer!long == -70000L);

        el.integer!long = -70000L;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        // assertThrown!ASN1ValueSizeException(el.integer!int);
        assert(el.integer!long == -70000L);

        // Tests for maximum values
        el.integer!byte = byte.max;
        assert(el.integer!byte == byte.max);
        assert(el.integer!short == byte.max);
        assert(el.integer!int == byte.max);
        assert(el.integer!long == byte.max);

        el.integer!short = short.max;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        assert(el.integer!short == short.max);
        assert(el.integer!int == short.max);
        assert(el.integer!long == short.max);

        el.integer!int = int.max;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        assert(el.integer!int == int.max);
        assert(el.integer!long == int.max);

        el.integer!long = long.max;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        // assertThrown!ASN1ValueSizeException(el.integer!int);
        assert(el.integer!long == long.max);

        // Tests for minimum values
        el.integer!byte = byte.min;
        assert(el.integer!byte == byte.min);
        assert(el.integer!short == byte.min);
        assert(el.integer!int == byte.min);
        assert(el.integer!long == byte.min);

        el.integer!short = short.min;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        assert(el.integer!short == short.min);
        assert(el.integer!int == short.min);
        assert(el.integer!long == short.min);

        el.integer!int = int.min;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        assert(el.integer!int == int.min);
        assert(el.integer!long == int.min);

        el.integer!long = long.min;
        // assertThrown!ASN1ValueSizeException(el.integer!byte);
        // assertThrown!ASN1ValueSizeException(el.integer!short);
        // assertThrown!ASN1ValueSizeException(el.integer!int);
        assert(el.integer!long == long.min);

        // Assert that accessor does not mutate state
        assert(el.integer!long == el.integer!long);
    }

    abstract public @property
    bool[] bitString() const;

    abstract public @property
    void bitString(in bool[] value);

    @system
    unittest
    {
        Element el = new Element();
        el.bitString = []; // 0 bits
        assert(el.bitString == []);
        el.bitString = [ true, false, true, true, false, false, true ]; // 7 bits
        assert(el.bitString == [ true, false, true, true, false, false, true ]);
        el.bitString = [ true, false, true, true, false, false, true, false ]; // 8 bits
        assert(el.bitString == [ true, false, true, true, false, false, true, false ]);
        el.bitString = [ true, false, true, true, false, false, true, false, true ]; // 9 bits
        assert(el.bitString == [ true, false, true, true, false, false, true, false, true ]);

        // Assert that accessor does not mutate state
        assert(el.bitString == el.bitString);
    }

    /// Decodes a ubyte[] array
    abstract public @property
    ubyte[] octetString() const;

    /// Encodes a ubyte[] array
    abstract public @property
    void octetString(in ubyte[] value);

    @system
    unittest
    {
        Element el = new Element();
        el.octetString = [ 0x05u, 0x02u, 0xFFu, 0x00u, 0x6Au ];
        assert(el.octetString == [ 0x05u, 0x02u, 0xFFu, 0x00u, 0x6Au ]);

        // Assert that accessor does not mutate state
        assert(el.octetString == el.octetString);
    }

    // Test that mutating the value does not mutate an external reference.
    @system
    unittest
    {
        ubyte[] test = [ 0x05u, 0x02u, 0xFFu, 0x00u, 0x6Au ];
        Element el = new Element();
        el.octetString = test;
        el.value[4] = 0x88u;
        assert(test[4] == 0x6Au);
    }

    // Test that mutating a large value does not mutate an external reference.
    @system
    unittest
    {
        ubyte[] test;
        test.length = 10000u;
        Element el = new Element();
        el.octetString = test;
        el.value[4] = 0x88u;
        assert(test[4] == 0x00u);
    }

    /**
        "Decodes" a $(MONO NULL), by which I mean: returns nothing, but
        throws exceptions if the element is not correct.

        Note:
            I had to name this method "nill," because "NULL" is a keyword in D.

        Throws:
        $(UL
            $(LI $(D ASN1ConstructionException) if the element is marked as "constructed")
            $(LI $(D ASN1ValueSizeException) if there are any content octets)
        )
    */
    abstract public @property
    void nill() const;

    ///
    public alias oid = objectIdentifier;
    ///
    public alias objectID = objectIdentifier;
    /// Decodes an Object Identifier
    abstract public @property
    OID objectIdentifier() const;

    /// Encodes an Object Identifier
    abstract public @property
    void objectIdentifier(in OID value);

    @system
    unittest
    {
        Element el = new Element();
        el.objectIdentifier = new OID(OIDNode(1u), OIDNode(30u), OIDNode(256u), OIDNode(623485u), OIDNode(8u));
        assert(el.objectIdentifier == new OID(OIDNode(1u), OIDNode(30u), OIDNode(256u), OIDNode(623485u), OIDNode(8u)));

        size_t[] sensitiveValues = [
            0,
            1,
            2, // First even
            3, // First odd greater than 1
            7, // Number of bits in each byte that encode the number
            8, // Number of bits in a byte
            127, // Largest number that can encode on a single OID byte
            128, // 127+1
            70000 // A large number that takes three bytes to encode
        ];

        for (size_t x = 0u; x < 2; x++)
        {
            for (size_t y = 0u; y < 40u; y++)
            {
                foreach (z; sensitiveValues)
                {
                    el.objectIdentifier = new OID(x, y, 6, 4, z);
                    assert(el.objectIdentifier.numericArray == [ x, y, 6, 4, z ]);
                    el.objectIdentifier = new OID(x, y, 6, 4, z, 0);
                    assert(el.objectIdentifier.numericArray == [ x, y, 6, 4, z, 0 ]);
                    el.objectIdentifier = new OID(x, y, 6, 4, z, 1);
                    assert(el.objectIdentifier.numericArray == [ x, y, 6, 4, z, 1 ]);
                    el.objectIdentifier = new OID(OIDNode(x), OIDNode(y), OIDNode(256u), OIDNode(5u), OIDNode(z));
                    assert(el.objectIdentifier == new OID(OIDNode(x), OIDNode(y), OIDNode(256u), OIDNode(5u), OIDNode(z)));
                    el.objectIdentifier = new OID(OIDNode(x), OIDNode(y), OIDNode(256u), OIDNode(5u), OIDNode(z), OIDNode(0));
                    assert(el.objectIdentifier == new OID(OIDNode(x), OIDNode(y), OIDNode(256u), OIDNode(5u), OIDNode(z), OIDNode(0)));
                    el.objectIdentifier = new OID(OIDNode(x), OIDNode(y), OIDNode(256u), OIDNode(5u), OIDNode(z), OIDNode(1));
                    assert(el.objectIdentifier == new OID(OIDNode(x), OIDNode(y), OIDNode(256u), OIDNode(5u), OIDNode(z), OIDNode(1)));
                }
            }
        }

        for (size_t y = 0u; y < 175u; y++)
        {
            foreach (z; sensitiveValues)
            {
                el.objectIdentifier = new OID(2, y, 6, 4, z);
                assert(el.objectIdentifier.numericArray == [ 2, y, 6, 4, z ]);
                el.objectIdentifier = new OID(2, y, 6, 4, z, 0);
                assert(el.objectIdentifier.numericArray == [ 2, y, 6, 4, z, 0 ]);
                el.objectIdentifier = new OID(2, y, 6, 4, z, 1);
                assert(el.objectIdentifier.numericArray == [ 2, y, 6, 4, z, 1 ]);
                el.objectIdentifier = new OID(OIDNode(2), OIDNode(y), OIDNode(256u), OIDNode(5u), OIDNode(z));
                assert(el.objectIdentifier == new OID(OIDNode(2), OIDNode(y), OIDNode(256u), OIDNode(5u), OIDNode(z)));
                el.objectIdentifier = new OID(OIDNode(2), OIDNode(y), OIDNode(256u), OIDNode(5u), OIDNode(z), OIDNode(0));
                assert(el.objectIdentifier == new OID(OIDNode(2), OIDNode(y), OIDNode(256u), OIDNode(5u), OIDNode(z), OIDNode(0)));
                el.objectIdentifier = new OID(OIDNode(2), OIDNode(y), OIDNode(256u), OIDNode(5u), OIDNode(z), OIDNode(1));
                assert(el.objectIdentifier == new OID(OIDNode(2), OIDNode(y), OIDNode(256u), OIDNode(5u), OIDNode(z), OIDNode(1)));
            }
        }

        // Assert that accessor does not mutate state
        assert(el.objectIdentifier == el.objectIdentifier);
    }

    /**
        Decodes an ObjectDescriptor, which is a string consisting of only
        graphical characters. In fact, ObjectDescriptor is actually implicitly
        just a GraphicString! The formal specification for an ObjectDescriptor
        is:

        $(I ObjectDescriptor ::= [UNIVERSAL 7] IMPLICIT GraphicString)

        GraphicString is just 0x20 to 0x7E, therefore ObjectDescriptor is just
        0x20 to 0x7E.

        Sources:
            $(LINK ,
                ASN.1: Communication Between Heterogeneous Systems, pages 175-178)
            $(LINK https://en.wikipedia.org/wiki/ISO/IEC_2022,
                The Wikipedia Page on ISO 2022)
            $(LINK https://www.iso.org/standard/22747.html, ISO 2022)
    */
    abstract public @property
    string objectDescriptor() const;

    /**
        Encodes an ObjectDescriptor, which is a string consisting of only
        graphical characters. In fact, ObjectDescriptor is actually implicitly
        just a GraphicString! The formal specification for an ObjectDescriptor
        is:

        $(I ObjectDescriptor ::= [UNIVERSAL 7] IMPLICIT GraphicString)

        GraphicString is just 0x20 to 0x7E, therefore ObjectDescriptor is just
        0x20 to 0x7E.

        Sources:
            $(LINK ,
                ASN.1: Communication Between Heterogeneous Systems, pages 175-178)
            $(LINK https://en.wikipedia.org/wiki/ISO/IEC_2022,
                The Wikipedia Page on ISO 2022)
            $(LINK https://www.iso.org/standard/22747.html, ISO 2022)
    */
    abstract public @property
    void objectDescriptor(in string value);

    @system
    unittest
    {
        Element el = new Element();
        el.objectDescriptor = "Nitro dubs & T-Rix";
        assert(el.objectDescriptor == "Nitro dubs & T-Rix");
        el.objectDescriptor = " ";
        assert(el.objectDescriptor == " ");
        el.objectDescriptor = "";
        assert(el.objectDescriptor == "");
        assertThrown!ASN1ValueCharactersException(el.objectDescriptor = "\xD7");
        assertThrown!ASN1ValueCharactersException(el.objectDescriptor = "\t");
        assertThrown!ASN1ValueCharactersException(el.objectDescriptor = "\r");
        assertThrown!ASN1ValueCharactersException(el.objectDescriptor = "\n");
        assertThrown!ASN1ValueCharactersException(el.objectDescriptor = "\b");
        assertThrown!ASN1ValueCharactersException(el.objectDescriptor = "\v");
        assertThrown!ASN1ValueCharactersException(el.objectDescriptor = "\f");
        assertThrown!ASN1ValueCharactersException(el.objectDescriptor = "\0");

        // Assert that accessor does not mutate state
        assert(el.objectDescriptor == el.objectDescriptor);
    }

    /**
        Decodes an $(MONO EXTERNAL), which is a constructed data type, defined in
        the $(LINK https://www.itu.int, International Telecommunications Union)'s
        $(LINK https://www.itu.int/rec/T-REC-X.680/en, X.680).

        The specification defines $(MONO EXTERNAL) as:

        $(PRE
            EXTERNAL := [UNIVERSAL 8] IMPLICIT SEQUENCE {
                identification CHOICE {
                    syntax OBJECT IDENTIFIER,
                    presentation-context-id INTEGER,
                    context-negotiation SEQUENCE {
                        presentation-context-id INTEGER,
                        transfer-syntax OBJECT IDENTIFIER } },
                data-value-descriptor ObjectDescriptor OPTIONAL,
                data-value OCTET STRING }
        )

        This assumes AUTOMATIC TAGS, so all of the identification choices
        will be context-specific and numbered from 0 to 2.
    */
    deprecated abstract public @property
    External external() const;

    /**
        Encodes an $(MONO EXTERNAL), which is a constructed data type, defined in
        the $(LINK https://www.itu.int, International Telecommunications Union)'s
        $(LINK https://www.itu.int/rec/T-REC-X.680/en, X.680).

        The specification defines $(MONO EXTERNAL) as:

        $(PRE
            EXTERNAL := [UNIVERSAL 8] IMPLICIT SEQUENCE {
                identification CHOICE {
                    syntax OBJECT IDENTIFIER,
                    presentation-context-id INTEGER,
                    context-negotiation SEQUENCE {
                        presentation-context-id INTEGER,
                        transfer-syntax OBJECT IDENTIFIER } },
                data-value-descriptor ObjectDescriptor OPTIONAL,
                data-value OCTET STRING }
        )

        This assumes AUTOMATIC TAGS, so all of the identification choices
        will be context-specific and numbered from 0 to 2.
    */
    deprecated abstract public @property
    void external(in External value);

    // Test of all pre-1994 External encoding choices
    @system
    unittest
    {
        ASN1ContextSwitchingTypeID id = ASN1ContextSwitchingTypeID();
        id.syntax = new OID(1, 3, 6, 4, 1, 256, 39);

        External input = External();
        External output;
        input.identification = id;
        input.dataValueDescriptor = "boop";
        input.dataValue = [ 0x03u, 0x05u, 0x07u, 0x09u ];

        Element el = new Element();

        // single-ASN1-type
        input.encoding = ASN1ExternalEncodingChoice.singleASN1Type;
        el.external = input;
        output = el.external;
        assert(output.identification.syntax == new OID(1, 3, 6, 4, 1, 256, 39));
        assert(output.dataValueDescriptor == "boop");
        assert(output.dataValue == [ 0x03u, 0x05u, 0x07u, 0x09u ]);

        // octet-aligned
        input.encoding = ASN1ExternalEncodingChoice.octetAligned;
        el.external = input;
        output = el.external;
        assert(output.identification.syntax == new OID(1, 3, 6, 4, 1, 256, 39));
        assert(output.dataValueDescriptor == "boop");
        assert(output.dataValue == [ 0x03u, 0x05u, 0x07u, 0x09u ]);

        // arbitrary
        input.encoding = ASN1ExternalEncodingChoice.arbitrary;
        el.external = input;
        output = el.external;
        assert(output.identification.syntax == new OID(1, 3, 6, 4, 1, 256, 39));
        assert(output.dataValueDescriptor == "boop");
        assert(output.dataValue == [ 0x03u, 0x05u, 0x07u, 0x09u ]);
    }

    /// Encodes a floating-point number
    abstract public @property
    T realNumber(T)() const if (isFloatingPoint!T);

    /// Encodes a floating-point number
    abstract public @property
    void realNumber(T)(in T value) if (isFloatingPoint!T);

    @system
    unittest
    {
        for (int i = -100; i < 100; i++)
        {
            // Alternating negative and positive floating point numbers exploring extreme values
            immutable float f = ((i % 2 ? -1 : 1) * 1.23 ^^ i);
            immutable double d = ((i % 2 ? -1 : 1) * 1.23 ^^ i);
            immutable real r = ((i % 2 ? -1 : 1) * 1.23 ^^ i);
            Element elf = new Element();
            Element eld = new Element();
            Element elr = new Element();
            elf.realNumber!float = f;
            eld.realNumber!double = d;
            elr.realNumber!real = r;
            assert(approxEqual(elf.realNumber!float, f));
            assert(approxEqual(elf.realNumber!double, f));
            assert(approxEqual(elf.realNumber!real, f));
            assert(approxEqual(eld.realNumber!float, d));
            assert(approxEqual(eld.realNumber!double, d));
            assert(approxEqual(eld.realNumber!real, d));
            assert(approxEqual(elr.realNumber!float, d));
            assert(approxEqual(elr.realNumber!double, d));
            assert(approxEqual(elr.realNumber!real, d));
        }
    }

    // Test a few edge cases
    @system
    unittest
    {
        immutable float[] tests = [
            0.0,
            -0.0,
            (10.0 / 3.0), // Non-terminating decimal
            (-10.0 / 3.0), // Negative non-terminating decimal
            1.0,
            -1.0
        ];
        Element el = new Element();

        foreach (test; tests)
        {
            el.realNumber!float = cast(float) test;
            assert(approxEqual(el.realNumber!float, cast(float) test));
            el.realNumber!double = cast(double) test;
            assert(approxEqual(el.realNumber!double, cast(double) test));
            el.realNumber!real = test;
            assert(approxEqual(el.realNumber!real, test));
        }
    }

    // Test both positive and negative infinity for each floating-point type
    @system
    unittest
    {
        Element el = new Element();

        // float.infinity
        el.realNumber!float = float.infinity;
        assert(el.realNumber!float  == float.infinity);
        assert(el.realNumber!double == float.infinity);
        assert(el.realNumber!real   == float.infinity);

        el.realNumber!double = float.infinity;
        assert(el.realNumber!float  == float.infinity);
        assert(el.realNumber!double == float.infinity);
        assert(el.realNumber!real   == float.infinity);

        el.realNumber!real = float.infinity;
        assert(el.realNumber!float  == float.infinity);
        assert(el.realNumber!double == float.infinity);
        assert(el.realNumber!real   == float.infinity);

        el.realNumber!float = -float.infinity;
        assert(el.realNumber!float  == -float.infinity);
        assert(el.realNumber!double == -float.infinity);
        assert(el.realNumber!real   == -float.infinity);

        el.realNumber!double = -float.infinity;
        assert(el.realNumber!float  == -float.infinity);
        assert(el.realNumber!double == -float.infinity);
        assert(el.realNumber!real   == -float.infinity);

        el.realNumber!real = -float.infinity;
        assert(el.realNumber!float  == -float.infinity);
        assert(el.realNumber!double == -float.infinity);
        assert(el.realNumber!real   == -float.infinity);

        // double.infinity
        el.realNumber!float = double.infinity;
        assert(el.realNumber!float  == double.infinity);
        assert(el.realNumber!double == double.infinity);
        assert(el.realNumber!real   == double.infinity);

        el.realNumber!double = double.infinity;
        assert(el.realNumber!float  == double.infinity);
        assert(el.realNumber!double == double.infinity);
        assert(el.realNumber!real   == double.infinity);

        el.realNumber!real = double.infinity;
        assert(el.realNumber!float  == double.infinity);
        assert(el.realNumber!double == double.infinity);
        assert(el.realNumber!real   == double.infinity);

        el.realNumber!float = -double.infinity;
        assert(el.realNumber!float  == -double.infinity);
        assert(el.realNumber!double == -double.infinity);
        assert(el.realNumber!real   == -double.infinity);

        el.realNumber!double = -double.infinity;
        assert(el.realNumber!float  == -double.infinity);
        assert(el.realNumber!double == -double.infinity);
        assert(el.realNumber!real   == -double.infinity);

        el.realNumber!real = -double.infinity;
        assert(el.realNumber!float  == -double.infinity);
        assert(el.realNumber!double == -double.infinity);
        assert(el.realNumber!real   == -double.infinity);

        // real.infinity
        el.realNumber!float = real.infinity;
        assert(el.realNumber!float  == real.infinity);
        assert(el.realNumber!double == real.infinity);
        assert(el.realNumber!real   == real.infinity);

        el.realNumber!double = real.infinity;
        assert(el.realNumber!float  == real.infinity);
        assert(el.realNumber!double == real.infinity);
        assert(el.realNumber!real   == real.infinity);

        el.realNumber!real = real.infinity;
        assert(el.realNumber!float  == real.infinity);
        assert(el.realNumber!double == real.infinity);
        assert(el.realNumber!real   == real.infinity);

        el.realNumber!float = -real.infinity;
        assert(el.realNumber!float  == -real.infinity);
        assert(el.realNumber!double == -real.infinity);
        assert(el.realNumber!real   == -real.infinity);

        el.realNumber!double = -real.infinity;
        assert(el.realNumber!float  == -real.infinity);
        assert(el.realNumber!double == -real.infinity);
        assert(el.realNumber!real   == -real.infinity);

        el.realNumber!real = -real.infinity;
        assert(el.realNumber!float  == -real.infinity);
        assert(el.realNumber!double == -real.infinity);
        assert(el.realNumber!real   == -real.infinity);
    }

    // Test NaN
    @system
    unittest
    {
        Element el = new Element();

        el.realNumber!float = float.nan;
        assert(el.realNumber!float.isNaN);
        assert(el.realNumber!double.isNaN);
        assert(el.realNumber!real.isNaN);

        el.realNumber!double = float.nan;
        assert(el.realNumber!float.isNaN);
        assert(el.realNumber!double.isNaN);
        assert(el.realNumber!real.isNaN);

        el.realNumber!real = float.nan;
        assert(el.realNumber!float.isNaN);
        assert(el.realNumber!double.isNaN);
        assert(el.realNumber!real.isNaN);

        el.realNumber!float = double.nan;
        assert(el.realNumber!float.isNaN);
        assert(el.realNumber!double.isNaN);
        assert(el.realNumber!real.isNaN);

        el.realNumber!double = double.nan;
        assert(el.realNumber!float.isNaN);
        assert(el.realNumber!double.isNaN);
        assert(el.realNumber!real.isNaN);

        el.realNumber!real = double.nan;
        assert(el.realNumber!float.isNaN);
        assert(el.realNumber!double.isNaN);
        assert(el.realNumber!real.isNaN);

        el.realNumber!float = real.nan;
        assert(el.realNumber!float.isNaN);
        assert(el.realNumber!double.isNaN);
        assert(el.realNumber!real.isNaN);

        el.realNumber!double = real.nan;
        assert(el.realNumber!float.isNaN);
        assert(el.realNumber!double.isNaN);
        assert(el.realNumber!real.isNaN);

        el.realNumber!real = real.nan;
        assert(el.realNumber!float.isNaN);
        assert(el.realNumber!double.isNaN);
        assert(el.realNumber!real.isNaN);
    }

    // Tests of maximum and minimums of integral types
    @system
    unittest
    {
        immutable float[] tests = cast(float[]) [
            byte.max,
            byte.min,
            ubyte.max,
            ubyte.min,
            short.max,
            short.min,
            ushort.max,
            ushort.min,
            int.max,
            int.min,
            uint.max,
            uint.min,
            long.max,
            long.min,
            ulong.max,
            ulong.min
        ];

        Element el = new Element();

        foreach (test; tests)
        {
            el.realNumber!float = cast(float) test;
            assert(approxEqual(el.realNumber!float, cast(float) test));
            el.realNumber!double = cast(double) test;
            assert(approxEqual(el.realNumber!double, cast(double) test));
            el.realNumber!real = test;
            assert(approxEqual(el.realNumber!real, test));
        }
    }

    // Tests of maximum and minimums of floating-point types
    @system
    unittest
    {
        Element el = new Element();

        // Maximums and minimums of floats
        el.realNumber!float = float.max;
        assert(approxEqual(el.realNumber!float, float.max));
        el.realNumber!double = cast(double) float.max;
        assert(approxEqual(el.realNumber!double, float.max));
        el.realNumber!real = cast(real) float.max;
        assert(approxEqual(el.realNumber!real, float.max));

        el.realNumber!float = float.max_10_exp;
        assert(approxEqual(el.realNumber!float, float.max_10_exp));
        el.realNumber!double = cast(double) float.max_10_exp;
        assert(approxEqual(el.realNumber!double, float.max_10_exp));
        el.realNumber!real = cast(real) float.max_10_exp;
        assert(approxEqual(el.realNumber!real, float.max_10_exp));

        el.realNumber!float = float.max_exp;
        assert(approxEqual(el.realNumber!float, float.max_exp));
        el.realNumber!double = cast(double) float.max_exp;
        assert(approxEqual(el.realNumber!double, float.max_exp));
        el.realNumber!real = cast(real) float.max_exp;
        assert(approxEqual(el.realNumber!real, float.max_exp));

        el.realNumber!float = float.min_10_exp;
        assert(approxEqual(el.realNumber!float, float.min_10_exp));
        el.realNumber!double = cast(double) float.min_10_exp;
        assert(approxEqual(el.realNumber!double, float.min_10_exp));
        el.realNumber!real = cast(real) float.min_10_exp;
        assert(approxEqual(el.realNumber!real, float.min_10_exp));

        el.realNumber!float = float.min_exp;
        assert(approxEqual(el.realNumber!float, float.min_exp));
        el.realNumber!double = cast(double) float.min_exp;
        assert(approxEqual(el.realNumber!double, float.min_exp));
        el.realNumber!real = cast(real) float.min_exp;
        assert(approxEqual(el.realNumber!real, float.min_exp));

        el.realNumber!float = float.min_normal;
        assert(approxEqual(el.realNumber!float, float.min_normal));
        el.realNumber!double = cast(double) float.min_normal;
        assert(approxEqual(el.realNumber!double, float.min_normal));
        el.realNumber!real = cast(real) float.min_normal;
        assert(approxEqual(el.realNumber!real, float.min_normal));

        // Maximums and minimums of doubles
        el.realNumber!double = cast(double) double.max;
        assert(approxEqual(el.realNumber!double, double.max));
        el.realNumber!real = cast(real) double.max;
        assert(approxEqual(el.realNumber!real, double.max));

        el.realNumber!double = cast(double) double.max_10_exp;
        assert(approxEqual(el.realNumber!double, double.max_10_exp));
        el.realNumber!real = cast(real) double.max_10_exp;
        assert(approxEqual(el.realNumber!real, double.max_10_exp));

        el.realNumber!double = cast(double) double.max_exp;
        assert(approxEqual(el.realNumber!double, double.max_exp));
        el.realNumber!real = cast(real) double.max_exp;
        assert(approxEqual(el.realNumber!real, double.max_exp));

        el.realNumber!double = cast(double) double.min_10_exp;
        assert(approxEqual(el.realNumber!double, double.min_10_exp));
        el.realNumber!real = cast(real) double.min_10_exp;
        assert(approxEqual(el.realNumber!real, double.min_10_exp));

        el.realNumber!double = cast(double) double.min_exp;
        assert(approxEqual(el.realNumber!double, double.min_exp));
        el.realNumber!real = cast(real) double.min_exp;
        assert(approxEqual(el.realNumber!real, double.min_exp));

        el.realNumber!double = cast(double) double.min_normal;
        assert(approxEqual(el.realNumber!double, double.min_normal));
        el.realNumber!real = cast(real) double.min_normal;
        assert(approxEqual(el.realNumber!real, double.min_normal));

        // Maximums and minimums of reals
        el.realNumber!real = cast(real) real.max;
        assert(approxEqual(el.realNumber!real, real.max));

        el.realNumber!real = cast(real) real.max_10_exp;
        assert(approxEqual(el.realNumber!real, real.max_10_exp));

        el.realNumber!real = cast(real) real.max_exp;
        assert(approxEqual(el.realNumber!real, real.max_exp));

        el.realNumber!real = cast(real) real.min_10_exp;
        assert(approxEqual(el.realNumber!real, real.min_10_exp));

        el.realNumber!real = cast(real) real.min_exp;
        assert(approxEqual(el.realNumber!real, real.min_exp));

        el.realNumber!real = cast(real) real.min_normal;
        assert(approxEqual(el.realNumber!real, real.min_normal));
    }

    // Test with all of the math constants, to make sure there are no edge cases.
    @system
    unittest
    {
        import std.math :
            E, PI, PI_2, PI_4, M_1_PI, M_2_PI, M_2_SQRTPI, LN10, LN2, LOG2,
            LOG2E, LOG2T, LOG10E, SQRT2, SQRT1_2, sqrt;

        immutable real[] tests = [
            E, PI, PI_2, PI_4, M_1_PI, M_2_PI, M_2_SQRTPI, LN10, LN2, LOG2,
            LOG2E, LOG2T, LOG10E, SQRT2, SQRT1_2,
            (SQRT2 / 2.0), // SQRT_2_OVER_2
            ((1.0 + sqrt(5.0)) / 2.0), // GOLDEN_RATIO
            0.57721,      // EULER_MASCHERONI_CONSTANT
            0.2614972128, // MEISSEL_MERTENS_CONSTANT
            0.2801694990, // BERNSTEINS_CONSTANT
            0.3036630028, // GAUSS_KUZMIN_WIRSING_CONSTANT
            0.3532363718, // HAFNER_SARNAK_MCCURLEY_CONSTANT
            0.5671432904, // OMEGA_CONSTANT
            0.6243299885, // GOLOMB_DICKMAN_CONSTANT
            0.6434105462, // CAHENS_CONSTANT
            0.6601618158, // TWIN_PRIME_CONSTANT
            0.6627434193, // LAPLACE_LIMIT
            0.70258,      // LANDAU_RAMANUJAN_CONSTANT
            0.8093940205, // ALLADI_GRINSTEAD_CONSTANT
            0.87058838,   // BRUNS_CONSTANT_FOR_PRIME_QUADRUPLETS
            0.9159655941, // CATALANS_CONSTANT
            1.0986858055, // LENGYELS_CONSTANT
            1.13198824,   // VISWANATHS_CONSTANT
            1.2020569,    // APERYS_CONSTANT
            1.30357,      // CONWAYS_CONSTANT
            1.3063778838, // MILLS_CONSTANT
            1.3247179572, // PLASTIC_CONSTANT
            1.4513692348, // RAMANUJAN_SOLDNER_CONSTANT
            1.4560749485, // BACKHOUSES_CONSTANT
            1.4670780794, // PORTERS_CONSTANT
            1.5396007178, // LIEBS_SQUARE_ICE_CONSTANT
            1.6066951524, // ERDOS_BORWEIN_CONSTANT
            1.7052111401, // NIVENS_CONSTANT
            1.9021605831, // BRUNS_CONSTANT_FOR_TWIN_PRIMES
            2.2955871493, // UNIVERSAL_PARABOLIC_CONSTANT
            2.5029078750, // FEIGENBAUM_CONSTANT_ALPHA
            2.5849817595, // SIERPINSKIS_CONSTANT
            2.6854520010, // KHINCHINS_CONSTANT
            2.8077702420, // FRANSEN_ROBINSON_CONSTANT
            3.2758229187, // LEVYS_CONSTANT
            3.3598856662, // RECIPROCAL_FIBONACCI_CONSTANT
            4.6692016091, // FEIGENBAUM_CONSTANT_DELTA
            1.2824271291  // GLAISHER_KINKELIN_CONSTANT
        ];

        Element el = new Element();

        foreach (test; tests)
        {
            el.realNumber!float = cast(float) test;
            assert(approxEqual(el.realNumber!float, cast(float) test));
            el.realNumber!double = cast(double) test;
            assert(approxEqual(el.realNumber!double, cast(double) test));
            el.realNumber!real = test;
            assert(approxEqual(el.realNumber!real, test));
        }
    }

    /// Encodes an integer that represents an ENUMERATED value
    abstract public @property
    T enumerated(T)() const if (isIntegral!T && isSigned!T);

    /// Decodes an integer that represents an ENUMERATED value
    abstract public @property
    void enumerated(T)(in T value) if (isIntegral!T && isSigned!T);

    // Test all 255 signed 8-bit integers
    @system
    unittest
    {
        Element el = new Element();
        for (byte i = byte.min; i < byte.max; i++)
        {
            el.enumerated!byte = i;
            assert(el.enumerated!byte == i);
            el.enumerated!short = i;
            assert(el.enumerated!short == i);
            el.enumerated!int = i;
            assert(el.enumerated!int == i);
            el.enumerated!long = i;
            assert(el.enumerated!long == i);
        }
    }

    // Test all 65536 signed 16-bit integers
    @system
    unittest
    {
        Element el = new Element();
        for (short i = short.min; i < short.max; i++)
        {
            el.enumerated!short = i;
            assert(el.enumerated!short == i);
            el.enumerated!int = i;
            assert(el.enumerated!int == i);
            el.enumerated!long = i;
            assert(el.enumerated!long == i);
        }
    }

    // Test a few signed 32-bit integers
    @system
    unittest
    {
        Element el = new Element();
        for (int i = int.min; i < int.max-15_485_863; i += 15_485_863) // 15,485,863 is the millionth prime
        {
            ubyte[] ub;
            ub.length = int.sizeof;
            *cast(int *)&ub[0] = i;
            version (LittleEndian) reverse(ub);
            el.enumerated!int = i;
            assert(el.enumerated!int == i);
            el.enumerated!long = i;
            assert(el.enumerated!long == i);
        }
    }

    // Test a few signed 64-bit integers
    @system
    unittest
    {
        Element el = new Element();
        for (long i = long.min; i < long.max-965_211_250_482_432_409; i += 965_211_250_482_432_409) // 50 millionth prime^2
        {
            el.enumerated!long = i;
            assert(el.enumerated!long == i);
        }
    }

    @system
    unittest
    {
        Element el = new Element();

        // Tests for zero
        el.enumerated!byte = 0;
        assert(el.enumerated!byte == 0);
        assert(el.enumerated!short == 0);
        assert(el.enumerated!int == 0);
        assert(el.enumerated!long == 0L);

        el.enumerated!short = 0;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        assert(el.enumerated!short == 0);
        assert(el.enumerated!int == 0);
        assert(el.enumerated!long == 0L);

        el.enumerated!int = 0;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        assert(el.enumerated!int == 0);
        assert(el.enumerated!long == 0L);

        el.enumerated!long = 0L;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        // assertThrown!ASN1ValueSizeException(el.enumerated!int);
        assert(el.enumerated!long == 0L);

        // Tests for small positives
        el.enumerated!byte = 3;
        assert(el.enumerated!byte == 3);
        assert(el.enumerated!short == 3);
        assert(el.enumerated!int == 3);
        assert(el.enumerated!long == 3L);

        el.enumerated!short = 5;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        assert(el.enumerated!short == 5);
        assert(el.enumerated!int == 5);
        assert(el.enumerated!long == 5L);

        el.enumerated!int = 7;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        assert(el.enumerated!int == 7);
        assert(el.enumerated!long == 7L);

        el.enumerated!long = 9L;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        // assertThrown!ASN1ValueSizeException(el.enumerated!int);
        assert(el.enumerated!long == 9L);

        // Tests for small negatives
        el.enumerated!byte = -3;
        assert(el.enumerated!byte == -3);
        assert(el.enumerated!short == -3);
        assert(el.enumerated!int == -3);
        assert(el.enumerated!long == -3L);

        el.enumerated!short = -5;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        assert(el.enumerated!short == -5);
        assert(el.enumerated!int == -5);
        assert(el.enumerated!long == -5L);

        el.enumerated!int = -7;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        assert(el.enumerated!int == -7);
        assert(el.enumerated!long == -7L);

        el.enumerated!long = -9L;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        // assertThrown!ASN1ValueSizeException(el.enumerated!int);
        assert(el.enumerated!long == -9L);

        // Tests for large positives
        el.enumerated!short = 20000;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        assert(el.enumerated!short == 20000);
        assert(el.enumerated!int == 20000);
        assert(el.enumerated!long == 20000L);

        el.enumerated!int = 70000;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        assert(el.enumerated!int == 70000);
        assert(el.enumerated!long == 70000L);

        el.enumerated!long = 70000L;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        // assertThrown!ASN1ValueSizeException(el.enumerated!int);
        assert(el.enumerated!long == 70000L);

        // Tests for large negatives
        el.enumerated!short = -20000;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        assert(el.enumerated!short == -20000);
        assert(el.enumerated!int == -20000);
        assert(el.enumerated!long == -20000L);

        el.enumerated!int = -70000;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        assert(el.enumerated!int == -70000);
        assert(el.enumerated!long == -70000L);

        el.enumerated!long = -70000L;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        // assertThrown!ASN1ValueSizeException(el.enumerated!int);
        assert(el.enumerated!long == -70000L);

        // Tests for maximum values
        el.enumerated!byte = byte.max;
        assert(el.enumerated!byte == byte.max);
        assert(el.enumerated!short == byte.max);
        assert(el.enumerated!int == byte.max);
        assert(el.enumerated!long == byte.max);

        el.enumerated!short = short.max;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        assert(el.enumerated!short == short.max);
        assert(el.enumerated!int == short.max);
        assert(el.enumerated!long == short.max);

        el.enumerated!int = int.max;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        assert(el.enumerated!int == int.max);
        assert(el.enumerated!long == int.max);

        el.enumerated!long = long.max;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        // assertThrown!ASN1ValueSizeException(el.enumerated!int);
        assert(el.enumerated!long == long.max);

        // Tests for minimum values
        el.enumerated!byte = byte.min;
        assert(el.enumerated!byte == byte.min);
        assert(el.enumerated!short == byte.min);
        assert(el.enumerated!int == byte.min);
        assert(el.enumerated!long == byte.min);

        el.enumerated!short = short.min;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        assert(el.enumerated!short == short.min);
        assert(el.enumerated!int == short.min);
        assert(el.enumerated!long == short.min);

        el.enumerated!int = int.min;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        assert(el.enumerated!int == int.min);
        assert(el.enumerated!long == int.min);

        el.enumerated!long = long.min;
        // assertThrown!ASN1ValueSizeException(el.enumerated!byte);
        // assertThrown!ASN1ValueSizeException(el.enumerated!short);
        // assertThrown!ASN1ValueSizeException(el.enumerated!int);
        assert(el.enumerated!long == long.min);

        // Assert that accessor does not mutate state
        assert(el.enumerated!long == el.enumerated!long);
    }

    ///
    public alias embeddedPDV = embeddedPresentationDataValue;
    /**
        Decodes an $(MONO EmbeddedPDV), which is a constructed data type, defined in
        the $(LINK https://www.itu.int, International Telecommunications Union)'s
        $(LINK https://www.itu.int/rec/T-REC-X.680/en, X.680).

        The specification defines $(MONO EmbeddedPDV) as:

        $(PRE
            EmbeddedPDV ::= [UNIVERSAL 11] IMPLICIT SEQUENCE {
                identification CHOICE {
                    syntaxes SEQUENCE {
                        abstract OBJECT IDENTIFIER,
                        transfer OBJECT IDENTIFIER },
                    syntax OBJECT IDENTIFIER,
                    presentation-context-id INTEGER,
                    context-negotiation SEQUENCE {
                        presentation-context-id INTEGER,
                        transfer-syntax OBJECT IDENTIFIER },
                    transfer-syntax OBJECT IDENTIFIER,
                    fixed NULL },
                data-value-descriptor ObjectDescriptor OPTIONAL,
                data-value OCTET STRING }
            (WITH COMPONENTS { ... , data-value-descriptor ABSENT })
        )

        This assumes AUTOMATIC TAGS, so all of the identification choices
        will be context-specific and numbered from 0 to 5.
    */
    abstract public @property
    EmbeddedPDV embeddedPresentationDataValue() const;

    /**
        Encodes an $(MONO EmbeddedPDV), which is a constructed data type, defined in
        the $(LINK https://www.itu.int, International Telecommunications Union)'s
        $(LINK https://www.itu.int/rec/T-REC-X.680/en, X.680).

        The specification defines $(MONO EmbeddedPDV) as:

        $(PRE
            EmbeddedPDV ::= [UNIVERSAL 11] IMPLICIT SEQUENCE {
                identification CHOICE {
                    syntaxes SEQUENCE {
                        abstract OBJECT IDENTIFIER,
                        transfer OBJECT IDENTIFIER },
                    syntax OBJECT IDENTIFIER,
                    presentation-context-id INTEGER,
                    context-negotiation SEQUENCE {
                        presentation-context-id INTEGER,
                        transfer-syntax OBJECT IDENTIFIER },
                    transfer-syntax OBJECT IDENTIFIER,
                    fixed NULL },
                data-value-descriptor ObjectDescriptor OPTIONAL,
                data-value OCTET STRING }
            (WITH COMPONENTS { ... , data-value-descriptor ABSENT })
        )

        This assumes AUTOMATIC TAGS, so all of the identification choices
        will be context-specific and numbered from 0 to 5.
    */
    abstract public @property
    void embeddedPresentationDataValue(in EmbeddedPDV value);

    @system
    unittest
    {
        ASN1Syntaxes syn = ASN1Syntaxes();
        syn.abstractSyntax = new OID(1, 3, 6, 4, 1, 256, 7);
        syn.transferSyntax = new OID(1, 3, 6, 4, 1, 256, 8);

        ASN1ContextSwitchingTypeID id = ASN1ContextSwitchingTypeID();
        id.syntaxes = syn;

        EmbeddedPDV input = EmbeddedPDV();
        input.identification = id;
        input.dataValue = [ 0x03u, 0x05u, 0x07u, 0x09u ];

        Element el = new Element();
        el.embeddedPDV = input;
        EmbeddedPDV output = el.embeddedPDV;
        assert(output.identification.syntaxes.abstractSyntax == new OID(1, 3, 6, 4, 1, 256, 7));
        assert(output.identification.syntaxes.transferSyntax == new OID(1, 3, 6, 4, 1, 256, 8));
        assert(output.dataValue == [ 0x03u, 0x05u, 0x07u, 0x09u ]);

        // Assert that accessor does not mutate state
        assert(el.embeddedPDV == el.embeddedPDV);
    }

    @system
    unittest
    {
        ASN1ContextSwitchingTypeID id = ASN1ContextSwitchingTypeID();
        id.syntax = new OID(1, 3, 6, 4, 1, 256, 39);

        EmbeddedPDV input = EmbeddedPDV();
        input.identification = id;
        input.dataValue = [ 0x03u, 0x05u, 0x07u, 0x09u ];

        Element el = new Element();
        el.embeddedPDV = input;
        EmbeddedPDV output = el.embeddedPDV;
        assert(output.identification.syntax == new OID(1, 3, 6, 4, 1, 256, 39));
        assert(output.dataValue == [ 0x03u, 0x05u, 0x07u, 0x09u ]);
    }

    @system
    unittest
    {
        ASN1ContextSwitchingTypeID id = ASN1ContextSwitchingTypeID();
        id.transferSyntax = new OID(1, 3, 6, 4, 1, 256, 39);

        EmbeddedPDV input = EmbeddedPDV();
        input.identification = id;
        input.dataValue = [ 0x03u, 0x05u, 0x07u, 0x09u ];

        Element el = new Element();
        el.embeddedPDV = input;
        EmbeddedPDV output = el.embeddedPDV;
        assert(output.identification.transferSyntax == new OID(1, 3, 6, 4, 1, 256, 39));
        assert(output.dataValue == [ 0x03u, 0x05u, 0x07u, 0x09u ]);
    }

    @system
    unittest
    {
        ASN1ContextSwitchingTypeID id = ASN1ContextSwitchingTypeID();
        id.fixed = true;

        EmbeddedPDV input = EmbeddedPDV();
        input.identification = id;
        input.dataValue = [ 0x03u, 0x05u, 0x07u, 0x09u ];

        Element el = new Element();
        el.embeddedPDV = input;
        EmbeddedPDV output = el.embeddedPDV;
        assert(output.identification.fixed == true);
        assert(output.dataValue == [ 0x03u, 0x05u, 0x07u, 0x09u ]);
    }

    ///
    public alias utf8String = unicodeTransformationFormat8String;
    /// Decodes a UTF-8 String
    abstract public @property
    string unicodeTransformationFormat8String() const;

    /// Encodes a UTF-8 String
    abstract public @property
    void unicodeTransformationFormat8String(in string value);

    @system
    unittest
    {
        Element el = new Element();
        el.utf8String = "";
        assert(el.utf8String == "");
        el.utf8String = "henlo borthers";
        assert(el.utf8String == "henlo borthers");

        // Assert that accessor does not mutate state
        assert(el.utf8String == el.utf8String);
    }

    // Test that mutating the value does not mutate an external reference.
    @system
    unittest
    {
        string test = "HENLO";
        Element el = new Element();
        el.utf8String = test;
        el.value[4] = 0x88u;
        assert(test[4] == 'O');
    }

    ///
    public alias roid = relativeObjectIdentifier;
    ///
    public alias relativeOID = relativeObjectIdentifier;
    /// Decodes a portion of an Object Identifier
    abstract public @property
    OIDNode[] relativeObjectIdentifier() const;

    /// Encodes a porition of an Object Identifier
    abstract public @property
    void relativeObjectIdentifier(in OIDNode[] value);

    @system
    unittest
    {
        Element el = new Element();
        OIDNode[] input = [ OIDNode(3), OIDNode(5), OIDNode(7), OIDNode(9) ];
        el.roid = input;
        OIDNode[] output = el.roid;

        assert(input.length == output.length);
        for (ptrdiff_t i = 0; i < input.length; i++)
        {
            assert(input[i] == output[i]);
        }

        // Assert that accessor does not mutate state
        assert(el.relativeObjectIdentifier == el.relativeObjectIdentifier);
    }

    /**
        Decodes an array of elements.

        Credits:
            Thanks to StackOverflow user
            $(LINK https://stackoverflow.com/users/359297/biotronic, BioTronic)
            for teaching me how to create the abstract method that uses the
            child class as a template.
    */
    abstract public @property
    Element[] sequence() const;

    /**
        Encodes an array of elements.

        Credits:
            Thanks to StackOverflow user
            $(LINK https://stackoverflow.com/users/359297/biotronic, BioTronic)
            for teaching me how to create the abstract method that uses the
            child class as a template.
    */
    abstract public @property
    void sequence(in Element[] value);

    /**
        Decodes an array of elements.

        Credits:
            Thanks to StackOverflow user
            $(LINK https://stackoverflow.com/users/359297/biotronic, BioTronic)
            for teaching me how to create the abstract method that uses the
            child class as a template.
    */
    abstract public @property
    Element[] set() const;

    /**
        Encodes an array of elements.

        Credits:
            Thanks to StackOverflow user
            $(LINK https://stackoverflow.com/users/359297/biotronic, BioTronic)
            for teaching me how to create the abstract method that uses the
            child class as a template.
    */
    abstract public @property
    void set(in Element[] value);

    /**
        Decodes a string, where the characters of the string are limited to
        0 - 9 and space.
    */
    abstract public @property
    string numericString() const;

    /**
        Encodes a string, where the characters of the string are limited to
        0 - 9 and space.
    */
    abstract public @property
    void numericString(in string value);

    @system
    unittest
    {
        Element el = new Element();
        el.numericString = "";
        assert(el.numericString == "");
        el.numericString = "1234567890";
        assert(el.numericString == "1234567890");
        el.numericString = " ";
        assert(el.numericString == " ");
        assertThrown!ASN1ValueCharactersException(el.numericString = "hey hey");
        assertThrown!ASN1ValueCharactersException(el.numericString = "12345676789A");

        // Assert that accessor does not mutate state
        assert(el.numericString == el.numericString);
    }

    // Test that mutating the value does not mutate an external reference.
    @system
    unittest
    {
        string test = "12345";
        Element el = new Element();
        el.numericString = test;
        el.value[4] = 0x88u;
        assert(test[4] == '5');
    }

    /**
        Decodes a string that will only contain characters a-z, A-Z, 0-9,
        space, apostrophe, parentheses, comma, minus, plus, period,
        forward slash, colon, equals, and question mark.
    */
    abstract public @property
    string printableString() const;

    /**
        Encodes a string that will only contain characters a-z, A-Z, 0-9,
        space, apostrophe, parentheses, comma, minus, plus, period,
        forward slash, colon, equals, and question mark.
    */
    abstract public @property
    void printableString(in string value);

    @system
    unittest
    {
        Element el = new Element();
        el.printableString = "";
        assert(el.printableString == "");
        el.printableString = "1234567890 asdfjkl";
        assert(el.printableString == "1234567890 asdfjkl");
        el.printableString = " ";
        assert(el.printableString == " ");
        assertThrown!ASN1ValueCharactersException(el.printableString = "\t");
        assertThrown!ASN1ValueCharactersException(el.printableString = "\n");
        assertThrown!ASN1ValueCharactersException(el.printableString = "\0");
        assertThrown!ASN1ValueCharactersException(el.printableString = "\v");
        assertThrown!ASN1ValueCharactersException(el.printableString = "\b");
        assertThrown!ASN1ValueCharactersException(el.printableString = "\r");
        assertThrown!ASN1ValueCharactersException(el.printableString = "\x13");

        // Assert that accessor does not mutate state
        assert(el.printableString == el.printableString);
    }

    // Test that mutating the value does not mutate an external reference.
    @system
    unittest
    {
        string test = "HENLO";
        Element el = new Element();
        el.printableString = test;
        el.value[4] = 0x88u;
        assert(test[4] == 'O');
    }

    ///
    public alias t61String = teletexString;
    /// Decodes bytes representing the T.61 Character Set
    abstract public @property
    ubyte[] teletexString() const;

    /// Encodes bytes representing the T.61 Character Set
    abstract public @property
    void teletexString(in ubyte[] value);

    @system
    unittest
    {
        Element el = new Element();
        el.teletexString = [];
        assert(el.teletexString == []);
        el.teletexString = [ 0x01u, 0x03u, 0x05u, 0x07u, 0x09u ];
        assert(el.teletexString == [ 0x01u, 0x03u, 0x05u, 0x07u, 0x09u ]);

        // Assert that accessor does not mutate state
        assert(el.teletexString == el.teletexString);
    }

    // Test that mutating the value does not mutate an external reference.
    @system
    unittest
    {
        ubyte[] test = [ 0x05u, 0x02u, 0xFFu, 0x00u, 0x6Au ];
        Element el = new Element();
        el.teletexString = test;
        el.value[4] = 0x88u;
        assert(test[4] == 0x6Au);
    }

    // Test that mutating a large value does not mutate an external reference.
    @system
    unittest
    {
        ubyte[] test;
        test.length = 10000u;
        Element el = new Element();
        el.teletexString = test;
        el.value[4] = 0x88u;
        assert(test[4] == 0x00u);
    }

    abstract public @property
    ubyte[] videotexString() const;

    abstract public @property
    void videotexString(in ubyte[] value);

    @system
    unittest
    {
        Element el = new Element();
        el.videotexString = [];
        assert(el.videotexString == []);
        el.videotexString = [ 0x01u, 0x03u, 0x05u, 0x07u, 0x09u ];
        assert(el.videotexString == [ 0x01u, 0x03u, 0x05u, 0x07u, 0x09u ]);

        // Assert that accessor does not mutate state
        assert(el.videotexString == el.videotexString);
    }

    // Test that mutating the value does not mutate an external reference.
    @system
    unittest
    {
        ubyte[] test = [ 0x05u, 0x02u, 0xFFu, 0x00u, 0x6Au ];
        Element el = new Element();
        el.videotexString = test;
        el.value[4] = 0x88u;
        assert(test[4] == 0x6Au);
    }

    // Test that mutating a large value does not mutate an external reference.
    @system
    unittest
    {
        ubyte[] test;
        test.length = 10000u;
        Element el = new Element();
        el.videotexString = test;
        el.value[4] = 0x88u;
        assert(test[4] == 0x00u);
    }

    ///
    public alias ia5String = internationalAlphabetNumber5String;
    /// Decodes a string of ASCII characters
    abstract public @property
    string internationalAlphabetNumber5String() const;

    /// Encodes a string of ASCII characters
    abstract public @property
    void internationalAlphabetNumber5String(in string value);

    @system
    unittest
    {
        Element el = new Element();
        el.ia5String = "";
        assert(el.ia5String == "");
        el.ia5String = "Nitro dubs & T-Rix";
        assert(el.ia5String == "Nitro dubs & T-Rix");
        assertThrown!ASN1ValueCharactersException(el.ia5String = "Nitro dubs \xD7 T-Rix");

        // Assert that accessor does not mutate state
        assert(el.ia5String == el.ia5String);
    }

    // Test that mutating the value does not mutate an external reference.
    @system
    unittest
    {
        string test = "HENLO";
        Element el = new Element();
        el.ia5String = test;
        el.value[4] = 0x88u;
        assert(test[4] == 'O');
    }

    ///
    public alias utc = coordinatedUniversalTime;
    ///
    public alias utcTime = coordinatedUniversalTime;
    /// Decodes a DateTime
    abstract public @property
    DateTime coordinatedUniversalTime() const;

    /// Encodes a DateTime
    abstract public @property
    void coordinatedUniversalTime(in DateTime value);

    @system
    unittest
    {
        Element el = new Element();
        el.utcTime = DateTime(2017, 10, 3);
        assert(el.utcTime == DateTime(2017, 10, 3));

        // Assert that accessor does not mutate state
        assert(el.utcTime == el.utcTime);
    }

    /// Decodes a DateTime
    abstract public @property
    DateTime generalizedTime() const;

    /// Encodes a DateTime
    abstract public @property
    void generalizedTime(in DateTime value);

    @system
    unittest
    {
        Element el = new Element();
        el.generalizedTime = DateTime(2017, 10, 3);
        assert(el.generalizedTime == DateTime(2017, 10, 3));

        // Assert that accessor does not mutate state
        assert(el.generalizedTime == el.generalizedTime);
    }

    /**
        Decodes an ASCII string that contains only characters between and
        including 0x20 and 0x75.

        Sources:
            $(LINK http://www.oss.com/asn1/resources/books-whitepapers-pubs/dubuisson-asn1-book.PDF, ASN.1: Communication Between Heterogeneous Systems, pages 175-178)
            $(LINK https://en.wikipedia.org/wiki/ISO/IEC_2022, The Wikipedia Page on ISO 2022)
            $(LINK https://www.iso.org/standard/22747.html, ISO 2022)

    */
    deprecated
    abstract public @property
    string graphicString() const;

    /**
        Encodes an ASCII string that contains only characters between and
        including 0x20 and 0x75.

        Sources:
            $(LINK http://www.oss.com/asn1/resources/books-whitepapers-pubs/dubuisson-asn1-book.PDF, ASN.1: Communication Between Heterogeneous Systems, pages 175-178)
            $(LINK https://en.wikipedia.org/wiki/ISO/IEC_2022, The Wikipedia Page on ISO 2022)
            $(LINK https://www.iso.org/standard/22747.html, ISO 2022)

    */
    deprecated
    abstract public @property
    void graphicString(in string value);

    @system
    unittest
    {
        Element el = new Element();
        el.graphicString = "";
        assert(el.graphicString == "");
        el.graphicString = "Nitro dubs & T-Rix";
        assert(el.graphicString == "Nitro dubs & T-Rix");
        el.graphicString = " ";
        assert(el.graphicString == " ");
        assertThrown!ASN1ValueCharactersException(el.graphicString = "\xD7");
        assertThrown!ASN1ValueCharactersException(el.graphicString = "\t");
        assertThrown!ASN1ValueCharactersException(el.graphicString = "\r");
        assertThrown!ASN1ValueCharactersException(el.graphicString = "\n");
        assertThrown!ASN1ValueCharactersException(el.graphicString = "\b");
        assertThrown!ASN1ValueCharactersException(el.graphicString = "\v");
        assertThrown!ASN1ValueCharactersException(el.graphicString = "\f");
        assertThrown!ASN1ValueCharactersException(el.graphicString = "\0");

        // Assert that accessor does not mutate state
        assert(el.graphicString == el.graphicString);
    }

    // Test that mutating the value does not mutate an external reference.
    @system
    unittest
    {
        string test = "HENLO";
        Element el = new Element();
        el.graphicString = test;
        el.value[4] = 0x88u;
        assert(test[4] == 'O');
    }

    ///
    public alias iso646String = visibleString;
    /**
        Decodes a string that only contains characters between and including
        0x20 and 0x7E. (Honestly, I don't know how this differs from
        GraphicalString.)
    */
    abstract public @property
    string visibleString() const;

    /**
        Encodes a string that only contains characters between and including
        0x20 and 0x7E. (Honestly, I don't know how this differs from
        GraphicalString.)
    */
    abstract public @property
    void visibleString(in string value);

    @system
    unittest
    {
        Element el = new Element();
        el.visibleString = "";
        assert(el.visibleString == "");
        el.visibleString = "hey hey";
        assert(el.visibleString == "hey hey");
        el.visibleString = " ";
        assert(el.visibleString == " ");
        assertThrown!ASN1ValueCharactersException(el.visibleString = "\xD7");
        assertThrown!ASN1ValueCharactersException(el.visibleString = "\t");
        assertThrown!ASN1ValueCharactersException(el.visibleString = "\r");
        assertThrown!ASN1ValueCharactersException(el.visibleString = "\n");
        assertThrown!ASN1ValueCharactersException(el.visibleString = "\b");
        assertThrown!ASN1ValueCharactersException(el.visibleString = "\v");
        assertThrown!ASN1ValueCharactersException(el.visibleString = "\f");
        assertThrown!ASN1ValueCharactersException(el.visibleString = "\0");

        // Assert that accessor does not mutate state
        assert(el.visibleString == el.visibleString);
    }

    // Test that mutating the value does not mutate an external reference.
    @system
    unittest
    {
        string test = "HENLO";
        Element el = new Element();
        el.visibleString = test;
        el.value[4] = 0x88u;
        assert(test[4] == 'O');
    }

    /// Decodes a string containing only ASCII characters.
    deprecated
    abstract public @property
    string generalString();

    /// Encodes a string containing only ASCII characters.
    deprecated
    abstract public @property
    void generalString(in string value);

    @system
    unittest
    {
        Element el = new Element();
        el.generalString = "";
        assert(el.generalString == "");
        el.generalString = "foin-ass sweatpants from BUCCI \0\n\t\b\v\r\f";
        assert(el.generalString == "foin-ass sweatpants from BUCCI \0\n\t\b\v\r\f");
        assertThrown!ASN1ValueCharactersException(el.generalString = "\xF5");

        // Assert that accessor does not mutate state
        assert(el.generalString == el.generalString);
    }

    // Test that mutating the value does not mutate an external reference.
    @system
    unittest
    {
        string test = "HENLO";
        Element el = new Element();
        el.generalString = test;
        el.value[4] = 0x88u;
        assert(test[4] == 'O');
    }

    /// Decodes a string of UTF-32 characters
    abstract public @property
    dstring universalString() const;

    /// Encodes a string of UTF-32 characters
    abstract public @property
    void universalString(in dstring value);

    @system
    unittest
    {
        Element el = new Element();
        el.universalString = ""d;
        assert(el.universalString == ""d);
        el.universalString = "abcd"d;
        assert(el.universalString == "abcd"d);

        // Assert that accessor does not mutate state
        assert(el.universalString == el.universalString);
    }

    // Test that mutating the value does not mutate an external reference.
    @system
    unittest
    {
        dstring test = "HENLO"d;
        Element el = new Element();
        el.universalString = test;
        el.value[4] = 0x88u;
        assert(test[4] == 'O');
    }

    /**
        Decodes a $(MONO CHARACTER STRING), which is a constructed data type, defined
        in the $(LINK https://www.itu.int, International Telecommunications Union)'s
        $(LINK https://www.itu.int/rec/T-REC-X.680/en, X.680).

        The specification defines $(MONO CHARACTER STRING) as:

        $(PRE
            CHARACTER STRING ::= [UNIVERSAL 29] SEQUENCE {
                identification CHOICE {
                    syntaxes SEQUENCE {
                        abstract OBJECT IDENTIFIER,
                        transfer OBJECT IDENTIFIER },
                    syntax OBJECT IDENTIFIER,
                    presentation-context-id INTEGER,
                    context-negotiation SEQUENCE {
                        presentation-context-id INTEGER,
                        transfer-syntax OBJECT IDENTIFIER },
                    transfer-syntax OBJECT IDENTIFIER,
                    fixed NULL },
                string-value OCTET STRING }
        )

        This assumes AUTOMATIC TAGS, so all of the identification choices
        will be context-specific and numbered from 0 to 5.
    */
    abstract public @property
    CharacterString characterString() const;

    /**
        Encodes a $(MONO CHARACTER STRING), which is a constructed data type, defined
        in the $(LINK https://www.itu.int, International Telecommunications Union)'s
        $(LINK https://www.itu.int/rec/T-REC-X.680/en, X.680).

        The specification defines $(MONO CHARACTER STRING) as:

        $(PRE
            CHARACTER STRING ::= [UNIVERSAL 29] SEQUENCE {
                identification CHOICE {
                    syntaxes SEQUENCE {
                        abstract OBJECT IDENTIFIER,
                        transfer OBJECT IDENTIFIER },
                    syntax OBJECT IDENTIFIER,
                    presentation-context-id INTEGER,
                    context-negotiation SEQUENCE {
                        presentation-context-id INTEGER,
                        transfer-syntax OBJECT IDENTIFIER },
                    transfer-syntax OBJECT IDENTIFIER,
                    fixed NULL },
                string-value OCTET STRING }
        )

        This assumes AUTOMATIC TAGS, so all of the identification choices
        will be context-specific and numbered from 0 to 5.
    */
    abstract public @property
    void characterString(in CharacterString value);

    @system
    unittest
    {
        ASN1Syntaxes syn = ASN1Syntaxes();
        syn.abstractSyntax = new OID(1, 3, 6, 4, 1, 256, 7);
        syn.transferSyntax = new OID(1, 3, 6, 4, 1, 256, 8);

        ASN1ContextSwitchingTypeID id = ASN1ContextSwitchingTypeID();
        id.syntaxes = syn;

        CharacterString input = CharacterString();
        input.identification = id;
        input.stringValue = [ 'H', 'E', 'L', 'N', 'O' ];

        Element el = new Element();
        el.characterString = input;

        CharacterString output = el.characterString;
        assert(output.identification.syntaxes.abstractSyntax == new OID(1, 3, 6, 4, 1, 256, 7));
        assert(output.identification.syntaxes.transferSyntax == new OID(1, 3, 6, 4, 1, 256, 8));
        assert(output.stringValue == [ 'H', 'E', 'L', 'N', 'O' ]);
    }

    @system
    unittest
    {
        ASN1ContextSwitchingTypeID id = ASN1ContextSwitchingTypeID();
        id.syntax = new OID(1, 3, 6, 4, 1, 256, 39);

        CharacterString input = CharacterString();
        input.identification = id;
        input.stringValue = [ 'H', 'E', 'N', 'L', 'O' ];

        Element el = new Element();
        el.characterString = input;
        CharacterString output = el.characterString;
        assert(output.identification.syntax == new OID(1, 3, 6, 4, 1, 256, 39));
        assert(output.stringValue == [ 'H', 'E', 'N', 'L', 'O' ]);
    }

    @system
    unittest
    {
        ASN1ContextSwitchingTypeID id = ASN1ContextSwitchingTypeID();
        id.transferSyntax = new OID(1, 3, 6, 4, 1, 256, 39);

        CharacterString input = CharacterString();
        input.identification = id;
        input.stringValue = [ 'H', 'E', 'N', 'L', 'O' ];

        Element el = new Element();
        el.characterString = input;
        CharacterString output = el.characterString;
        assert(output.identification.transferSyntax == new OID(1, 3, 6, 4, 1, 256, 39));
        assert(output.stringValue == [ 'H', 'E', 'N', 'L', 'O' ]);
    }

    @system
    unittest
    {
        ASN1ContextSwitchingTypeID id = ASN1ContextSwitchingTypeID();
        id.fixed = true;

        CharacterString input = CharacterString();
        input.identification = id;
        input.stringValue = [ 'H', 'E', 'N', 'L', 'O' ];

        Element el = new Element();
        el.characterString = input;
        CharacterString output = el.characterString;
        assert(output.identification.fixed == true);
        assert(output.stringValue == [ 'H', 'E', 'N', 'L', 'O' ]);

        // Assert that accessor does not mutate state
        assert(el.characterString == el.characterString);
    }

    ///
    public alias bmpString = basicMultilingualPlaneString;
    /// Decodes a string of UTF-16 characters
    abstract public @property
    wstring basicMultilingualPlaneString() const;

    /// Encodes a string of UTF-16 characters
    abstract public @property
    void basicMultilingualPlaneString(in wstring value);

    @system
    unittest
    {
        Element el = new Element();
        el.bmpString = ""w;
        assert(el.bmpString == ""w);
        el.bmpString = "abcd"w;
        assert(el.bmpString == "abcd"w);

        // Assert that accessor does not mutate state
        assert(el.bmpString == el.bmpString);
    }

    // Test that mutating the value does not mutate an external reference.
    @system
    unittest
    {
        wstring test = "HENLO"w;
        Element el = new Element();
        el.bmpString = test;
        el.value[4] = 0x88u;
        assert(test[4] == 'O');
    }

}