public void BuildTree_ExceptionWhenNoSymbolsAdded()
{
//given when
var tree = new HuffmanCodecBuilder <char>().BuildTree(Comparer <char> .Default, new Dictionary <char, int>());
//then - no exception, fail
throw new AssertFailedException();
}
public void Decode()
{
var builder = new HuffmanCodecBuilder <byte>();
var tree = builder.BuildTree(Comparer <byte> .Default, symbolQuantityDic);
var decoder = builder.GetDecoder(tree);
var symbolsCount = symbolQuantityDic.Sum(x => x.Value);
decoder.Decode(new HuffmanDecoderInput(decoderReader), new StandardHuffmanDecoderOutput(decoderFileWriter, symbolsCount));
}
public void BuildTree_WhenOneSymbolIsAdded()
{
//given when
var tree = new HuffmanCodecBuilder <char>().BuildTree(Comparer <char> .Default, new Dictionary <char, int>()
{
{ 'c', 2 }
});
//then - sukces
}
public void Decode()
{
var builder = new HuffmanCodecBuilder <Tuple <byte, DefaultableSymbol <byte> > >();
var tree = builder.BuildTree(new PairComparer(), symbolQuantityDic);
var decoder = builder.GetDecoder(tree);
int symbolsCount = symbolQuantityDic.Sum(x => x.Value);
decoder.Decode(new HuffmanDecoderInput(decoderReader), new PairHuffmanDecoderOutput(decoderFileWriter, symbolsCount, isByteCountEven));
}
public void Encode()
{
Dictionary <byte, int> symbolQuantityDic = createDictionary();
var builder = new HuffmanCodecBuilder <byte>();
var tree = builder.BuildTree(Comparer <byte> .Default, symbolQuantityDic);
ICoder <byte> huffmanCoder = builder.GetCoder(tree);
huffmanCoder.Encode(new StandardHuffmanCoderInput(inputReader), new HuffmanCoderOutput(coderOutputWriter));
coderOutputWriter.CreateFileBytes(HuffmanEncodeModel.Standard, false, SymbolQuantityMapConverter.StandardIntToExtConvert(symbolQuantityDic, huffmanCoder.GetEncodingDictionary()));
}
public void GetDecoder_ReturnsOneSymbolDecoder_WhenOneSymbolOnly()
{
//given
var builder = new HuffmanCodecBuilder <char>();
var treeRoot = new HuffmanTreeNode <char>(value: 'a', quantity: 1);
//when
var decoder = builder.GetDecoder(treeRoot);
//then
Assert.IsInstanceOfType(decoder, typeof(OneSymbolDecoder <char>));
}
public void Encode()
{
var symbolQuantityDic = createDictionary();
var builder = new HuffmanCodecBuilder <Tuple <byte, DefaultableSymbol <byte> > >();
var tree = builder.BuildTree(new PairComparer(), symbolQuantityDic);
var coder = builder.GetCoder(tree);
var coderInput = new PairHuffmanCoderInput(inputReader);
coder.Encode(coderInput, new HuffmanCoderOutput(coderOutputWriter));
coderOutputWriter.CreateFileBytes(HuffmanEncodeModel.Block, coderInput.isSpecialSymbol, SymbolQuantityMapConverter.PairIntToExtConvert(symbolQuantityDic, coder.GetEncodingDictionary()));
}
public void BuildTree_WhenEqualyProbable_BigIsRight_BecauseComparator()
{
//given when
var treeRoot = new HuffmanCodecBuilder <char>().BuildTree(Comparer <char> .Default, new Dictionary <char, int>()
{
{ 'a', 10 }, //0
{ 'b', 10 }, //1
});
//then
Assert.AreEqual('a', treeRoot.LeftChild.Value);
Assert.AreEqual('b', treeRoot.RightChild.Value);
}
public void BuildTree_LessProbableIsLeft()
{
//given when
var treeRoot = new HuffmanCodecBuilder <char>().BuildTree(Comparer <char> .Default, new Dictionary <char, int>()
{
{ 'a', 10 }, //1
{ 'b', 5 }, //0
});
//then
Assert.AreEqual('a', treeRoot.RightChild.Value);
Assert.AreEqual('b', treeRoot.LeftChild.Value);
}
private Dictionary <DefaultableSymbol <byte>, IDecoder <byte> > createDecoderDictionary()
{
Dictionary <DefaultableSymbol <byte>, IDecoder <byte> > coderDictionary = new Dictionary <DefaultableSymbol <byte>, IDecoder <byte> >();
foreach (DefaultableSymbol <byte> key in perSymbolDictionary.Keys)
{
var builder = new HuffmanCodecBuilder <byte>();
var tree = builder.BuildTree(Comparer <byte> .Default, perSymbolDictionary[key]);
var decoder = builder.GetDecoder(tree);
coderDictionary.Add(key, decoder);
}
return(coderDictionary);
}
public void BuildTree_TwoSmallAreLessProbableThanBig_BigIsRight_BecauseMoreProbable()
{
//given when
var treeRoot = new HuffmanCodecBuilder <char>().BuildTree(Comparer <char> .Default, new Dictionary <char, int>()
{
{ 'a', 2 }, //01
{ 'b', 1 }, //00
{ 'c', 10 }, //1
});
//then
Assert.AreEqual('a', treeRoot.LeftChild.RightChild.Value);
Assert.AreEqual('b', treeRoot.LeftChild.LeftChild.Value);
Assert.AreEqual('c', treeRoot.RightChild.Value);
}
public void BuildTree_TwoSmallAreEqualyProbableToBig_BigIsRLeft_BecauseLessSubtreeDepth()
{
//given when
var treeRoot = new HuffmanCodecBuilder <char>().BuildTree(Comparer <char> .Default, new Dictionary <char, int>()
{
{ 'a', 5 }, //10
{ 'b', 5 }, //11
{ 'c', 10 }, //0
});
//then
Assert.AreEqual('a', treeRoot.RightChild.LeftChild.Value);
Assert.AreEqual('b', treeRoot.RightChild.RightChild.Value);
Assert.AreEqual('c', treeRoot.LeftChild.Value);
}
public void GetCoder_ReturnsHuffmanDecoder_WhenMoreThanOneSymbol()
{
//given when
var builder = new HuffmanCodecBuilder <char>();
var treeRoot = new HuffmanTreeNode <char>(value: 'a', quantity: 1);
var leftChild = new HuffmanTreeNode <char>(value: 'b', quantity: 1);
var rightChild = new HuffmanTreeNode <char>(value: 'c', quantity: 1);
treeRoot.LeftChild = leftChild;
treeRoot.RightChild = rightChild;
leftChild.Parent = rightChild.Parent = treeRoot;
//when
var decoder = builder.GetDecoder(treeRoot);
//then
Assert.IsInstanceOfType(decoder, typeof(HuffmanDecoder <char>));
}
