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);
}
}
}
// ========= 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"));
}
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)
{
}
}
protected static void TestDecodeMethodArguments(BaseEncoding encoding)
{
try // null
{
encoding.Decode(null);
Assert.Fail(typeof(ArgumentNullException).ToString());
}
catch (ArgumentNullException)
{
}
}
// ========= 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"));
}
