protected static void ConvertTest(BaseEncoding encoding)
{
var initialData = new Byte[128];
var odd = false;
for (var index = 0; index < UnitTestsIterationsCount; index++, odd = !odd)
{
// Generate test data
Random.NextBytes(initialData);
var offset = odd ? 0 : Random.Next(64);
var count = odd ? 128 : Random.Next(64);
// Convert byte array to string
var intermediateResult = odd ? encoding.Encode(initialData) : encoding.Encode(initialData, offset, count);
// Convert string to byte array
var actualResult = encoding.Decode(intermediateResult, 0, intermediateResult.Length);
// Compare by item
for (Int32 expectedResultIndex = offset, actualResultIndex = 0; expectedResultIndex < offset + count; expectedResultIndex++, actualResultIndex++)
{
var expectedItem = initialData[expectedResultIndex];
var actualItem = actualResult[actualResultIndex];
Assert.AreEqual(expectedItem, actualItem);
}
}
}
static Base64Encoding()
{
Blowfish = new BaseEncoding("./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", true);
UnixCrypt = new BaseEncoding("./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", true);
UnixMD5 = new BaseEncoding("./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", false);
}
// ========= USAGE 2 =========
// char[] BaseEncoding.Encode(byte[] bytes, int offset, int length)
// byte[] BaseEncoding.Decode(char[] chars, int offset, int length)
static void Usage2(string testName, BaseEncoding encoding, string testVector)
{
byte[] origin = Encoding.Default.GetBytes(testVector);
char[] baseChars = encoding.Encode(origin, 0, origin.Length);
byte[] bytes = encoding.Decode(baseChars, 0, baseChars.Length);
Console.WriteLine("[" + testName + "]\tVector: " + testVector + "\tBaseString: "
+ new string(baseChars) + "\t" + (ArrayEquals(origin, bytes) ? "Success" : "failed"));
}
static Base64Encoding()
{
Blowfish = new BaseEncoding("./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", true);
UnixCrypt = new BaseEncoding("./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", true);
UnixMD5 = new BaseEncoding("./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", false);
}
public static string GetUniqueID()
{
var guidBytes = new byte[9];
System.Security.Cryptography.RandomNumberGenerator.Fill(guidBytes);
var guid = DateTimeOffset.UtcNow.ToUnixTimeSeconds() + "_" + BaseEncoding.ToBaseString(guidBytes, BaseEncoding.CHAR_SETS.BASE36); //HexUtil.GetHexFromBytes(guidBytes);
return(guid);
}
// ========= USAGE 1 =========
// string BaseEncoding.ToBaseString(byte[] bytes)
// byte[] BaseEncoding.FromBaseString(string s)
static void Usage1(string testName, BaseEncoding encoding, string testVector)
{
byte[] origin = Encoding.Default.GetBytes(testVector);
string baseString = encoding.ToBaseString(origin);
byte[] bytes = encoding.FromBaseString(baseString);
Console.WriteLine("[" + testName + "]\tVector: " + testVector + "\tBaseString: "
+ baseString + "\t" + (ArrayEquals(origin, bytes) ? "Success" : "failed"));
}
protected static void TestDecodeMethodArguments(BaseEncoding encoding)
{
try // null
{
encoding.Decode(null);
Assert.Fail(typeof(ArgumentNullException).ToString());
}
catch (ArgumentNullException)
{
}
}
static void Main(string[] args)
{
BaseEncoding b64 = BaseEncoding.Base64
, b64Safe = BaseEncoding.Base64Safe
, b32 = BaseEncoding.Base32
, b32Hex = BaseEncoding.Base32Hex
, b16 = BaseEncoding.Base16;
foreach (string vector in TEST_VECTORS)
{
Usage1("Base64", b64, vector);
Usage2("Base64Safe", b64Safe, vector);
Usage1("Base32", b32, vector);
Usage3("Base32Hex", b32Hex, vector);
Usage2("Base16", b16, vector);
}
Console.ReadKey();
}
protected static void TestDecodeOffsetCountMethodArguments(BaseEncoding encoding)
{
try // null
{
encoding.Decode(null, 0, 2);
Assert.Fail(typeof(ArgumentNullException).ToString());
}
catch (ArgumentNullException)
{
}
try // bad count
{
encoding.Decode("abcd", 0, -4);
Assert.Fail(typeof(ArgumentOutOfRangeException).ToString());
}
catch (ArgumentOutOfRangeException)
{
}
try // bad offset
{
encoding.Decode("abcd", -1, 4);
Assert.Fail(typeof(ArgumentOutOfRangeException).ToString());
}
catch (ArgumentOutOfRangeException)
{
}
try // bad offset
{
encoding.Decode("abcd", 1, 4);
Assert.Fail(typeof(ArgumentOutOfRangeException).ToString());
}
catch (ArgumentOutOfRangeException)
{
}
}
// ========= USAGE 3 =========
// int BaseEncoding.GetEncodeCount(int length)
// int BaseEncoding.Encode(byte[] bytesIn, int offsetIn, int lengthIn, char[] charsOut, int offsetOut)
// int BaseEncoding.GetDecodeCount(char[] chars, int offset, int length)
// int BaseEncoding.Decode(char[] charsIn, int offsetIn, int lengthIn, byte[] bytesOut, int offsetOut)
static void Usage3(string testName, BaseEncoding encoding, string testVector)
{
int encodeOffset = 99, decodeOffset = 199;
byte[] origin = Encoding.Default.GetBytes(testVector);
byte[] originBuffer = WrapArray <byte>(origin, 33, 44);
char[] baseCharsBuffer = new char[encoding.GetEncodeCount(origin.Length) + encodeOffset * 2];
// == encode
int encodeNum = encoding.Encode(originBuffer, 33, origin.Length, baseCharsBuffer, encodeOffset);
// ==
byte[] binBuffer = new byte[encoding.GetDecodeCount(baseCharsBuffer, encodeOffset, encodeNum) + decodeOffset * 2];
// == decode
int decodeNum = encoding.Decode(baseCharsBuffer, encodeOffset, encodeNum, binBuffer, decodeOffset);
// ====== result
char[] baseChars = SubArray <char>(baseCharsBuffer, encodeOffset, encodeNum);
byte[] binData = SubArray <byte>(binBuffer, decodeOffset, decodeNum);
// == output
Console.WriteLine("[" + testName + "]\tVector: " + testVector + "\tBaseString: "
+ new string(baseChars) + "\t" + (ArrayEquals(origin, binData) ? "Success" : "failed"));
}
static Base2Encoding()
{
Binary = new BaseEncoding("01", true);
}
static Base16Encoding()
{
Hex = new BaseEncoding("0123456789ABCDEF", true, null, ch => char.ToUpperInvariant(ch));
}
protected static void TestEncodeOffsetCountMethodArguments(BaseEncoding encoding)
{
var testData = new Byte[]
{
0, 1, 2, 3
};
try // null data
{
encoding.Encode(null, 0, 2);
Assert.Fail(typeof(ArgumentNullException).ToString());
}
catch (ArgumentNullException)
{
}
try // bad length
{
encoding.Encode(testData, 0, -4);
Assert.Fail(typeof(ArgumentOutOfRangeException).ToString());
}
catch (ArgumentOutOfRangeException)
{
}
try // bad offset
{
encoding.Encode(testData, -1, 4);
Assert.Fail(typeof(ArgumentOutOfRangeException).ToString());
}
catch (ArgumentOutOfRangeException)
{
}
try // bad offset
{
encoding.Encode(testData, 1, 4);
Assert.Fail(typeof(ArgumentOutOfRangeException).ToString());
}
catch (ArgumentOutOfRangeException)
{
}
try // good pass zero length
{
encoding.Encode(testData, 0, 0);
}
catch (Exception)
{
Assert.Fail();
}
}
protected static void TestEncodeMethodArguments(BaseEncoding encoding)
{
var testData = new Byte[]
{
0, 1, 2, 3
};
try // null data
{
encoding.Encode(null);
Assert.Fail(typeof(ArgumentNullException).ToString());
}
catch (ArgumentNullException)
{
}
try // good pass zero length
{
encoding.Encode(new Byte[0]);
}
catch (Exception)
{
Assert.Fail();
}
try // good pass
{
encoding.Encode(testData);
}
catch (Exception)
{
Assert.Fail();
}
}
static Base2Encoding()
{
Binary = new BaseEncoding("01", true);
}
static Base16Encoding()
{
Hex = new BaseEncoding("0123456789ABCDEF", true, null, ch => char.ToUpperInvariant(ch));
}
