public virtual void GetStandardValues()
        {
            LexographicEnumConverter TestSubject = new LexographicEnumConverter(typeof(Base64FormattingOptions));

            Base64FormattingOptions[] expected = new Base64FormattingOptions[]
            {
                Base64FormattingOptions.InsertLineBreaks,
                Base64FormattingOptions.None
            };

            Base64FormattingOptions[] actual = new Base64FormattingOptions[2];

            TestSubject.GetStandardValues().CopyTo(actual,0);

            for (int i = 0; i < expected.Length; i++)
            {
                Assert.AreEqual(expected[i], actual[i]);
            }
        }

		static string ToBase64 (int len, Base64FormattingOptions options)
		{
			return Convert.ToBase64String (new byte [len], options);
		}

		public static string ToBase64String (byte[] inArray, int offset, int length, Base64FormattingOptions options)
		{
			if (inArray == null)
				throw new ArgumentNullException ("inArray");
			if (offset < 0 || length < 0)
				throw new ArgumentOutOfRangeException ("offset < 0 || length < 0");
			// avoid integer overflow
			if (offset > inArray.Length - length)
				throw new ArgumentOutOfRangeException ("offset + length > array.Length");

			if (length == 0)
				return String.Empty;

			if (options == Base64FormattingOptions.InsertLineBreaks)
				return ToBase64StringBuilderWithLine (inArray, offset, length).ToString ();
			else
				return Encoding.ASCII.GetString (Base64Helper.TransformFinalBlock (inArray, offset, length));
		}

        public static unsafe String ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options) {
            //Do data verfication
            if (inArray==null) 
                throw new ArgumentNullException("inArray");
            if (length<0)
                throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_Index"));
            if (offset<0)
                throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
            if (options < Base64FormattingOptions.None || options > Base64FormattingOptions.InsertLineBreaks)
                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)options));
            Contract.Ensures(Contract.Result<string>() != null);
            Contract.EndContractBlock();

            int inArrayLength;
            int stringLength;

            inArrayLength = inArray.Length;
            if (offset > (inArrayLength - length))
                throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_OffsetLength"));
           
            if (inArrayLength == 0)
                return String.Empty;

            bool insertLineBreaks = (options == Base64FormattingOptions.InsertLineBreaks);
            //Create the new string.  This is the maximally required length.
            stringLength = ToBase64_CalculateAndValidateOutputLength(length, insertLineBreaks);

            string returnString = string.FastAllocateString(stringLength);
            fixed (char* outChars = returnString){
                fixed (byte* inData = inArray) {
                    int j = ConvertToBase64Array(outChars,inData,offset,length, insertLineBreaks);
                    BCLDebug.Assert(returnString.Length == j, "returnString.Length == j");
                    return returnString;
                }
            }
        }

		public unsafe static string ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options)
		{
			if (inArray == null)
			{
				throw new ArgumentNullException("inArray");
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_Index"));
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
			}
			if (options < Base64FormattingOptions.None || options > Base64FormattingOptions.InsertLineBreaks)
			{
				throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[]
				{
					(int)options
				}));
			}
			int num = inArray.Length;
			if (offset > num - length)
			{
				throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_OffsetLength"));
			}
			if (num == 0)
			{
				return string.Empty;
			}
			bool insertLineBreaks = options == Base64FormattingOptions.InsertLineBreaks;
			int length2 = Convert.CalculateOutputLength(length, insertLineBreaks);
			string text = string.FastAllocateString(length2);
			fixed (char* outChars = text)
			{
				fixed (byte* ptr = inArray)
				{
					Convert.ConvertToBase64Array(outChars, ptr, offset, length, insertLineBreaks);
					return text;
				}
			}
		}

    public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options)
    {
      Contract.Ensures(0 <= Contract.Result<int>());

      return default(int);
    }

 /// <summary>
 /// Create a Base64String from the Surface by saving it to a memory stream and converting it.
 /// Should be avoided if possible, as this uses a lot of memory.
 /// </summary>
 /// <returns>string</returns>
 public string ToBase64String(Base64FormattingOptions formattingOptions)
 {
     using (MemoryStream stream = new MemoryStream())
     {
         ImageOutput.SaveToStream(_surface, stream, _outputSettings);
         return Convert.ToBase64String(stream.GetBuffer(), 0, (int)stream.Length, formattingOptions);
     }
 }

 /// <summary>
 /// Converts a byte array into a base 64 string
 /// </summary>
 /// <param name="Input">Input array</param>
 /// <param name="Count">
 /// Number of bytes starting at the index to convert (use -1 for the entire array starting
 /// at the index)
 /// </param>
 /// <param name="Index">Index to start at</param>
 /// <param name="Options">Base 64 formatting options</param>
 /// <returns>The equivalent byte array in a base 64 string</returns>
 public static string ToString(this byte[] Input, Base64FormattingOptions Options, int Index = 0, int Count = -1)
 {
     Contract.Requires<ArgumentException>(Index >= 0, "Index");
     if (Count == -1)
         Count = Input.Length - Index;
     return Input == null ? "" : Convert.ToBase64String(Input, Index, Count, Options);
 }

        public static unsafe String ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options) {
            int     inArrayLength;
            int     stringLength;

            //Do data verfication
            if (inArray==null) 
                throw new ArgumentNullException("inArray");
            if (length<0)
                throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_Index"));
            if (offset<0)
                throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
            inArrayLength = inArray.Length;
            if (offset > (inArrayLength - length))
                throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_OffsetLength"));

            if( options < Base64FormattingOptions.None || options > Base64FormattingOptions.InsertLineBreaks) {
                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)options));
            }
            
            if (inArrayLength == 0)
                return String.Empty;

            bool insertLineBreaks = (options == Base64FormattingOptions.InsertLineBreaks);
            //Create the new string.  This is the maximally required length.
            stringLength = CalculateOutputLength(length, insertLineBreaks);

            string returnString = String.GetStringForStringBuilder(String.Empty, stringLength);
            fixed (char* outChars = returnString){
                fixed (byte* inData = inArray) {
                    int j = ConvertToBase64Array(outChars,inData,offset,length, insertLineBreaks);
                    returnString.SetLength(j);
                    return returnString;
                }
            }
        }

 /// <summary>
 ///     Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is
 ///     encoded with base-64 digits. Parameters specify the subset as an offset in the input array, the number of
 ///     elements in the array to convert, and whether to insert line breaks in the return value.
 /// </summary>
 /// <param name="inArray">An array of 8-bit unsigned integers.</param>
 /// <param name="offset">An offset in .</param>
 /// <param name="length">The number of elements of  to convert.</param>
 /// <param name="options">to insert a line break every 76 characters, or  to not insert line breaks.</param>
 /// <returns>The string representation in base 64 of  elements of , starting at position .</returns>
 public static String ToBase64String(this Byte[] inArray, Int32 offset, Int32 length, Base64FormattingOptions options)
 {
     return Convert.ToBase64String(inArray, offset, length, options);
 }

 /// <summary>
 /// Converts the route to IOF XML 3.0 binary format and returns it as a base64-encoded string.
 /// </summary>
 /// <param name="formattingOptions">The formatting options for the base64-encoded string.</param>
 public string ToBase64String(Base64FormattingOptions formattingOptions = Base64FormattingOptions.None)
 {
     return Convert.ToBase64String(ToByteArray(), formattingOptions);
 }

 private void WriteByteList(List<byte> bytes, Base64FormattingOptions options)
 {
     byte[] array = bytes.ToArray();
     bytes = null;
     string base64 = Convert.ToBase64String(array, options);
     array = null;
     WriteObject(base64);
 }

 /// <summary>Converts the specified array to a Base64 string.</summary>
 /// <param name="value">The array to convert.</param>
 /// <param name="options">The <see cref="T:Base64FormattingOptions"/> to use.</param>
 /// <returns>The converted string.</returns>
 public static string ToDataString(this byte[] value, Base64FormattingOptions options)
 {
     return value.HasItems()
         ? Convert.ToBase64String(value, options)
         : String.Empty;
 }

	public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options) {}

        public static string ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options)
        {
            if (inArray == null)
                throw new ArgumentNullException("inArray");
            if (offset < 0 || length < 0)
                throw new ArgumentOutOfRangeException("offset < 0 || length < 0");
            // avoid integer overflow
            if (offset > inArray.Length - length)
                throw new ArgumentOutOfRangeException("offset + length > array.Length");

            if (length == 0)
                return String.Empty;

#if ANDROID_8P
            return Base64.EncodeToString(inArray, offset, length, Base64.DEFAULT);
#else
			throw new NotImplementedException("System.Convert.ToBase64String");
#endif
        }

 public static string ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options)
 {
   return default(string);
 }

 public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length,
                     char[] outArray, int offsetOut, Base64FormattingOptions options)
 {
     if (outArray == null)
         throw new ArgumentNullException("outArray");
     if (offsetOut < 0)
         throw new ArgumentOutOfRangeException("offsetOut");
     var encoded = ToBase64String(inArray, offsetIn, length);
     encoded.CopyTo(0, outArray, offsetOut, encoded.Length);
     return encoded.Length;
 }

 /// <summary>
 ///     Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array
 ///     encoded with base-64 digits. Parameters specify the subsets as offsets in the input and output arrays, the
 ///     number of elements in the input array to convert, and whether line breaks are inserted in the output array.
 /// </summary>
 /// <param name="inArray">An input array of 8-bit unsigned integers.</param>
 /// <param name="offsetIn">A position within .</param>
 /// <param name="length">The number of elements of  to convert.</param>
 /// <param name="outArray">An output array of Unicode characters.</param>
 /// <param name="offsetOut">A position within .</param>
 /// <param name="options">to insert a line break every 76 characters, or  to not insert line breaks.</param>
 /// <returns>A 32-bit signed integer containing the number of bytes in .</returns>
 public static Int32 ToBase64CharArray(this Byte[] inArray, Int32 offsetIn, Int32 length, Char[] outArray, Int32 offsetOut, Base64FormattingOptions options)
 {
     return Convert.ToBase64CharArray(inArray, offsetIn, length, outArray, offsetOut, options);
 }

 /// <summary>
 /// Converts from the specified encoding to a base 64 string
 /// </summary>
 /// <param name="Input">Input string</param>
 /// <param name="Options">Base 64 formatting options</param>
 /// <param name="OriginalEncodingUsing">
 /// The type of encoding the string is using (defaults to UTF8)
 /// </param>
 /// <returns>Bas64 string</returns>
 public static string ToString(this string Input, Base64FormattingOptions Options, Encoding OriginalEncodingUsing = null)
 {
     if (string.IsNullOrEmpty(Input))
         return "";
     byte[] TempArray = OriginalEncodingUsing.Check(new UTF8Encoding()).GetBytes(Input);
     return Convert.ToBase64String(TempArray, Options);
 }

        public static unsafe int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options) {
            //Do data verfication
            if (inArray==null) 
                throw new ArgumentNullException("inArray");
            if (outArray==null)
                throw new ArgumentNullException("outArray");
            if (length<0)
                throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_Index"));
            if (offsetIn<0)
                throw new ArgumentOutOfRangeException("offsetIn", Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));
            if (offsetOut<0)
                throw new ArgumentOutOfRangeException("offsetOut", Environment.GetResourceString("ArgumentOutOfRange_GenericPositive"));

            if( options < Base64FormattingOptions.None || options > Base64FormattingOptions.InsertLineBreaks) {
                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)options));
            }
            Contract.Ensures(Contract.Result<int>() >= 0);
            Contract.Ensures(Contract.Result<int>() <= outArray.Length);
            Contract.EndContractBlock();


            int retVal;

            int inArrayLength;
            int outArrayLength;
            int numElementsToCopy;

            inArrayLength = inArray.Length;

            if (offsetIn > (int)(inArrayLength - length))
                throw new ArgumentOutOfRangeException("offsetIn", Environment.GetResourceString("ArgumentOutOfRange_OffsetLength"));

            if (inArrayLength == 0)
                return 0;

            bool insertLineBreaks = (options == Base64FormattingOptions.InsertLineBreaks);
            //This is the maximally required length that must be available in the char array
            outArrayLength = outArray.Length;

            // Length of the char buffer required
            numElementsToCopy = ToBase64_CalculateAndValidateOutputLength(length, insertLineBreaks);
    
            if (offsetOut > (int)(outArrayLength -  numElementsToCopy))
                throw new ArgumentOutOfRangeException("offsetOut", Environment.GetResourceString("ArgumentOutOfRange_OffsetOut"));

            fixed (char* outChars = &outArray[offsetOut]) {
                fixed (byte* inData = inArray) { 
                   retVal = ConvertToBase64Array(outChars,inData,offsetIn,length, insertLineBreaks);
                }
            }

            return retVal;
        }