private void EncodeAll(String[] strings, String expectedEncoding)
{
foreach (String str in strings)
{
Assert.AreEqual(expectedEncoding, StringEncoder.Encode(str), "Problem with " + str);
}
}
public void Encode_ABC_to_BCD_with_key_1()
{
/* Тестирование по 3-м ААА
* А arrange
* А act
* А assert */
#region Arrange
var str = "ABC";
var expected_result = "BCD";
var key = 1;
#endregion
#region Act
var actual_result = StringEncoder.Encode(str, key);
#endregion
#region Assert
Assert.AreEqual(expected_result, actual_result);
#endregion
}
public void Encode_ABC_to_BCD_with_key_1()
{
// Принцип ААА
// A - Arrange
// A - Act
// A - Assert
#region Arrange
var str = "ABC";
var expected_result = "BCD";
var key = 1;
#endregion
#region Act
var actual_result = StringEncoder.Encode(str, key);
#endregion
#region Assert
Assert.AreEqual(expected_result, actual_result);
#endregion
}
public void ShouldEncodeEmptyStringsWithoutHuffmanEncoding()
{
var testStr = "";
var bytes = StringEncoder.Encode(testStr, HuffmanStrategy.Never);
Assert.Equal(1, bytes.Length);
// Compare the bytes
Assert.Equal(0x00, bytes[0]);
}
public void WriteZString([NotNull] string str, bool withLength, StringEncoderMode mode = StringEncoderMode.Normal)
{
MaybeProcessEscapeChars(ref str);
var zstr = StringEncoder.Encode(str, mode);
if (FinalPass && AbbreviateMode)
{
AbbrevFinder.AddText(str);
}
if (withLength)
{
WriteByte((byte)(zstr.Length / 2));
}
position += zstr.Length;
stream?.Write(zstr, 0, zstr.Length);
}
public void EncodeTest()
{
const string str = "asd";
const int key = 1;
const string expected_str = "bte";
var actual_str = StringEncoder.Encode(str, key);
Assert.AreEqual(expected_str, actual_str);
}
public void Encode_WhenNoValueIsPassed_ShouldReturnEmptyString()
{
//Arrange
var sut = new StringEncoder();
//Act
var result = sut.Encode("");
//Assert
result.Should().BeNullOrEmpty();
}
public void Encode_WhenAValueIsPassed_ShouldReturnEncodedValue()
{
//Arrange
var value = "test_123_rkkr";
var sut = new StringEncoder();
//Act
var result = sut.Encode(value);
//Assert
result.Should().NotBe(value);
}
public void ShouldNotApplyHuffmanEncodingIfStringDoesNotGetSmaller()
{
var testStr = "XZ"; // 11111100 11111101
var bytes = StringEncoder.Encode(testStr, HuffmanStrategy.IfSmaller);
Assert.Equal(3, bytes.Length);
// Compare the bytes
Assert.Equal(0x02, bytes[0]);
Assert.Equal((byte)'X', bytes[1]);
Assert.Equal((byte)'Z', bytes[2]);
}
public void ShouldApplyHuffmanEncodingIfStringGetsSmaller()
{
var testStr = "test"; // 01001 00101 01000 01001 => 01001001 01010000 1001
var bytes = StringEncoder.Encode(testStr, HuffmanStrategy.IfSmaller);
Assert.Equal(4, bytes.Length);
// Compare the bytes
Assert.Equal(0x83, bytes[0]);
Assert.Equal(0x49, bytes[1]);
Assert.Equal(0x50, bytes[2]);
Assert.Equal(0x9F, bytes[3]);
}
static void AssertZword(byte[] buffer, [NotNull] StringEncoder encoder, int zwordLength, int address, string expected)
{
var expectedBytes = encoder.Encode(expected, zwordLength * 3 / 2, StringEncoderMode.NoAbbreviations);
Debug.Assert(expectedBytes.Length == zwordLength);
for (int i = 0; i < zwordLength; i++)
{
if (buffer[address + i] != expectedBytes[i])
{
Assert.Fail("Encoded word differs at position {0} (address {1}): expected {2}, found {3}",
i, address + i, expectedBytes[i], buffer[address + i]);
}
}
}
public void Encode_ABC_to_BCD_with_key_1()
{
//Принцип ААА
//А - arange - разместить исходные данные и результат, подготовить объект тестирования
//A - act - соверщить ОДНО действие над объектом
//A - Assert - сравнить полученный результат с заявленным в начале
//1
var str = "ABC";
var expected_result = "BCD";
var key = 1;
//2
var actual_result = StringEncoder.Encode(str, key);
//3
Assert.AreEqual(expected_result, actual_result);
}
public void Encode()
{
FormatterContext formatterContext =
new FormatterContext(FormatterContext.DefaultBufferSize);
_encoder.Encode(_data, ref formatterContext);
Assert.IsTrue(formatterContext.DataLength == _data.Length);
byte[] encodedData = formatterContext.GetData();
for (int i = _binaryData.Length - 1; i >= 0; i--)
{
Assert.IsTrue(_binaryData[i] == encodedData[i]);
}
}
public void ShouldEncodeStringsWithHuffmanEncoding()
{
var testStr = "Hello";
// 1100011 00101 101000 101000 00111
// 11000110 01011010 00101000 00111
// var expectedResult = 0xC65A283F;
var bytes = StringEncoder.Encode(testStr, HuffmanStrategy.Always);
Assert.Equal(5, bytes.Length);
// Compare the bytes
Assert.Equal(0x84, bytes[0]);
Assert.Equal(0xC6, bytes[1]);
Assert.Equal(0x5A, bytes[2]);
Assert.Equal(0x28, bytes[3]);
Assert.Equal(0x3F, bytes[4]);
// Test with a longer string
testStr = "";
for (var i = 0; i < 64; i++)
{
testStr += (char)9; // ffffea [24]
testStr += "Z"; // fd [ 8]
}
bytes = StringEncoder.Encode(testStr, HuffmanStrategy.Always);
Assert.Equal(3 + 4 * 64, bytes.Length);
// Compare the bytes
Assert.Equal(255, bytes[0]); // 127
Assert.Equal(0x81, bytes[1]); // 127 + 1 = 128
Assert.Equal(1, bytes[2]); // 128 + 128 = 256
for (var i = 3; i < testStr.Length; i += 4)
{
Assert.Equal(0xFF, bytes[i + 0]);
Assert.Equal(0xFF, bytes[i + 1]);
Assert.Equal(0xEA, bytes[i + 2]);
Assert.Equal(0xFD, bytes[i + 3]);
}
}
public void ShouldEncodeStringsWithoutHuffmanEncoding()
{
var testStr = "Hello World";
var bytes = StringEncoder.Encode(testStr, HuffmanStrategy.Never);
Assert.Equal(12, bytes.Length);
// Compare the bytes
Assert.Equal(11, bytes[0]);
for (var i = 0; i < testStr.Length; i++)
{
var c = testStr[i];
Assert.Equal((byte)c, bytes[1 + i]);
}
// Test with a longer string
testStr = "";
for (var i = 0; i < 64; i++)
{
testStr += "a";
}
for (var i = 0; i < 64; i++)
{
testStr += "b";
}
bytes = StringEncoder.Encode(testStr, HuffmanStrategy.Never);
Assert.Equal(130, bytes.Length);
// Compare the bytes
Assert.Equal(127, bytes[0]);
Assert.Equal(1, bytes[1]);
for (var i = 0; i < testStr.Length; i++)
{
var c = testStr[i];
Assert.Equal((byte)c, bytes[2 + i]);
}
}
private string Encode(string source)
{
return(StringEncoder.Encode(source));
}
public StringBuilder Render(StringBuilder stringBuilder)
{
stringBuilder.Append(_encoder.Encode(_text));
return(stringBuilder);
}
int CountSavings(string word)
{
encoder.Encode(word, 0, StringEncoderMode.NoAbbreviations, out int zchars);
return(zchars - 2);
}
