def testComplement2(self):
"""Test the correct operation of the complementPattern function
in a normal case"""
dec = decoder.decoderCreator({}, {})
dec.complementPattern([0, None], 0)
self.assertEqual(1, len(dec.instrPattern))
self.assert_([1, None] in [i[0] for i in dec.instrPattern])
def testComplement2(self):
"""Test the correct operation of the complementPattern function in a
normal case."""
dec = decoder.decoderCreator({}, {})
dec.complementPattern([0, None], 0)
self.assertEqual(1, len(dec.instrPattern))
self.assert_([1, None] in [i[0] for i in dec.instrPattern])
def testComputeCost3(self):
"""Tests that the computational cost of a subtree is computed correctly.
This means that the corresponding huffman tree is computed correctly."""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode(
(((1, 1), 0.1), ((1, 1), 0.1), ((1, 1), 0.1), ((1, 1), 0.1)))
self.assertEqual(3, dec.computationalCost(surSubtree))
def testBestPattern(self):
"""Tests that, given a subtree, the correct best pattern matching
function is computed"""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode((((1, 1, 0), 0.1), ((1, 0, 0), 0.1), ((1, 0, 1), 0.1), ((0, 0, 0), 0.1)))
splitFunc, bestLeaves, bestCost = dec.findBestPattern(surSubtree)
self.assertEqual([0, None, None], splitFunc.pattern)
self.assertEqual(decoder.DecodingNode((((0, 0, 0), 0.1), )), bestLeaves[0][0])
self.assertEqual(decoder.DecodingNode((((1, 1, 0), 0.1), ((1, 0, 0), 0.1), ((1, 0, 1), 0.1))), bestLeaves[1][0])
def testPatternCost4(self):
"""Tests that, given a subtree, the computational cost is correctly computed"""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode((((1, None, 0), 0.1), ((0, 0), 0.1), ((0, 1), 0.1), ((1, 0), 0.1)))
cost, (subTreeEq, subTreeNe) = dec.computePatternCost(surSubtree, ([0], [0]), 1, 0)
self.assertEqual((1, 1.1), subTreeEq[1])
self.assertEqual((0, 1.3000000000000003), subTreeNe[1])
self.assertEqual(decoder.DecodingNode((((0, 0), 0.1), )), subTreeEq[0])
self.assertEqual(decoder.DecodingNode((((1, None, 0), 0.1), ((0, 1), 0.1), ((1, 0), 0.1))), subTreeNe[0])
def testIllegalBitsream3(self):
"""Tests the computation of the negation of the union of the valid
bitstrings."""
dec = decoder.decoderCreator({}, {})
dec.instrPattern += [([1, None], 0)]
dec.computeIllegalBistreams()
self.assertEqual(2, len(dec.instrPattern))
self.assert_([1, None] in [i[0] for i in dec.instrPattern])
self.assert_([0, None] in [i[0] for i in dec.instrPattern])
def testIllegalBitsream3(self):
"""Tests the computation of the negation of the union of the valid
bitstrings"""
dec = decoder.decoderCreator({}, {})
dec.instrPattern += [([1, None], 0)]
dec.computeIllegalBistreams()
self.assertEqual(2, len(dec.instrPattern))
self.assert_([1, None] in [i[0] for i in dec.instrPattern])
self.assert_([0, None] in [i[0] for i in dec.instrPattern])
def testBestPattern(self):
"""Tests that the best pattern matching function of a subtree is
computed correctly."""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode((((1, 1, 0), 0.1), ((1, 0, 0), 0.1), ((1, 0, 1), 0.1), ((0, 0, 0), 0.1)))
splitFunc, bestLeaves, bestCost = dec.findBestPattern(surSubtree)
self.assertEqual([0, None, None], splitFunc.pattern)
self.assertEqual(decoder.DecodingNode((((0, 0, 0), 0.1), )), bestLeaves[0][0])
self.assertEqual(decoder.DecodingNode((((1, 1, 0), 0.1), ((1, 0, 0), 0.1), ((1, 0, 1), 0.1))), bestLeaves[1][0])
def testBestTable(self):
"""Tests that, given a subtree, the correct best pattern matching
function is computed"""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode((((1, 1, 0), 0.1), ((1, 0, 0), 0.1), ((1, 0, 1), 0.1), ((0, 0, 0), 0.1)))
splitFunc, bestLeaves, bestCost = dec.findBestTable(surSubtree)
self.assertEqual([1, 1, 0], splitFunc.table)
self.assertEqual(decoder.DecodingNode((((0, 0, 0), 0.1), )), bestLeaves[0][0])
self.assertEqual(decoder.DecodingNode((((1, 0, 0), 0.1), ((1, 0, 1), 0.1))), bestLeaves[1][0])
self.assertEqual(decoder.DecodingNode((((1, 1, 0), 0.1), )), bestLeaves[2][0])
def testPatternCost2(self):
"""Tests that the computational cost of a subtree is computed
correctly."""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode((((1, 1), 0.1), ((0, 0), 0.1), ((0, 1), 0.1), ((1, 0), 0.1)))
cost, (subTreeEq, subTreeNe) = dec.computePatternCost(surSubtree, ([], []), 1, 0)
self.assertEqual((1, 1.2000000000000002), subTreeEq[1])
self.assertEqual((0, 1.2000000000000002), subTreeNe[1])
self.assertEqual(decoder.DecodingNode((((0, 0), 0.1), ((1, 0), 0.1))), subTreeEq[0])
self.assertEqual(decoder.DecodingNode((((1, 1), 0.1), ((0, 1), 0.1))), subTreeNe[0])
def testTableCost3(self):
"""Tests that, given a subtree, the computational cost is correctly computed"""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode((((1, 0, None), 0.1), ((0, 0), 0.1), ((0, 1), 0.1), ((1, 0), 0.1)))
cost, subTree = dec.computeTableCost(surSubtree, 0, 2)
self.assertEqual((0, 0.1), subTree[0][1])
self.assertEqual((2, 0.1), subTree[2][1])
self.assertEqual((1, 0.2), subTree[1][1])
self.assertEqual(decoder.DecodingNode((((0, 0), 0.1), )), subTree[0][0])
self.assertEqual(decoder.DecodingNode((((1, 0, None), 0.1), ((1, 0), 0.1))), subTree[1][0])
self.assertEqual(decoder.DecodingNode((((0, 1), 0.1), )), subTree[2][0])
def testBestTable1(self):
"""Tests that, given a subtree, the correct best pattern matching
function is computed"""
bitString1 = [None for i in range(0, 4)] + [0, 0, 0, 0, 1, 0, 1] + [None for i in range(0, 16)] + [0] + [None for i in range(0, 4)]
bitString2 = [None for i in range(0, 4)] + [0, 0, 0, 0, 1, 0, 1] + [None for i in range(0, 13)] + [0] + [None, None] + [1] + [None for i in range(0, 4)]
bitString3 = [None for i in range(0, 4)] + [0, 0, 1, 0, 1, 0, 1] + [None for i in range(0, 21)]
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode(((bitString1, 1), (bitString2, 1), (bitString3, 1)))
splitFunc, bestLeaves, bestCost = dec.findBestTable(surSubtree)
self.assertEqual([0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], splitFunc.table)
self.assertEqual(decoder.DecodingNode(((bitString1, 1), (bitString2, 1))), bestLeaves[0][0])
self.assertEqual(decoder.DecodingNode(((bitString3, 1), )), bestLeaves[1][0])
def testBestPattern1(self):
"""Tests that, given a subtree, the correct best pattern matching
function is computed"""
bitString1 = [None for i in range(0, 4)] + [0, 0, 0, 0, 1, 0, 1] + [None for i in range(0, 16)] + [0] + [None for i in range(0, 4)]
bitString2 = [None for i in range(0, 4)] + [0, 0, 0, 0, 1, 0, 1] + [None for i in range(0, 13)] + [0] + [None, None] + [1] + [None for i in range(0, 4)]
bitString3 = [None for i in range(0, 4)] + [0, 0, 1, 0, 1, 0, 1] + [None for i in range(0, 21)]
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode(((bitString1, 1), (bitString2, 1), (bitString3, 1)))
splitFunc, bestLeaves, bestCost = dec.findBestPattern(surSubtree)
self.assertEqual([None for i in range(0, 6)] + [1] + [None for i in range(0, 25)], splitFunc.pattern)
self.assertEqual(decoder.DecodingNode(((bitString1, 1), (bitString2, 1))), bestLeaves[1][0])
self.assertEqual(decoder.DecodingNode(((bitString3, 1), )), bestLeaves[0][0])
def testBestTable1(self):
"""Tests that the best table matching function of a subtree is computed
correctly."""
bitString1 = [None for i in range(0, 4)] + [0, 0, 0, 0, 1, 0, 1] + [None for i in range(0, 16)] + [0] + [None for i in range(0, 4)]
bitString2 = [None for i in range(0, 4)] + [0, 0, 0, 0, 1, 0, 1] + [None for i in range(0, 13)] + [0] + [None, None] + [1] + [None for i in range(0, 4)]
bitString3 = [None for i in range(0, 4)] + [0, 0, 1, 0, 1, 0, 1] + [None for i in range(0, 21)]
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode(((bitString1, 1), (bitString2, 1), (bitString3, 1)))
splitFunc, bestLeaves, bestCost = dec.findBestTable(surSubtree)
self.assertEqual([0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], splitFunc.table)
self.assertEqual(decoder.DecodingNode(((bitString1, 1), (bitString2, 1))), bestLeaves[0][0])
self.assertEqual(decoder.DecodingNode(((bitString3, 1), )), bestLeaves[1][0])
def testPatternCost2(self):
"""Tests that the computational cost of a subtree is computed
correctly."""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode(
(((1, 1), 0.1), ((0, 0), 0.1), ((0, 1), 0.1), ((1, 0), 0.1)))
cost, (subTreeEq,
subTreeNe) = dec.computePatternCost(surSubtree, ([], []), 1, 0)
self.assertEqual((1, 1.2000000000000002), subTreeEq[1])
self.assertEqual((0, 1.2000000000000002), subTreeNe[1])
self.assertEqual(decoder.DecodingNode((((0, 0), 0.1), ((1, 0), 0.1))),
subTreeEq[0])
self.assertEqual(decoder.DecodingNode((((1, 1), 0.1), ((0, 1), 0.1))),
subTreeNe[0])
def testTableCost1(self):
"""Tests that the computational cost of a subtree is computed
correctly."""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode((((1, 1), 0.1), ((0, 0), 0.1), ((0, 1), 0.1), ((1, 0), 0.1)))
cost, subTree = dec.computeTableCost(surSubtree, 0, 2)
self.assertEqual((0, 0.1), subTree[0][1])
self.assertEqual((1, 0.1), subTree[1][1])
self.assertEqual((2, 0.1), subTree[2][1])
self.assertEqual((3, 0.1), subTree[3][1])
self.assertEqual(decoder.DecodingNode((((0, 0), 0.1), )), subTree[0][0])
self.assertEqual(decoder.DecodingNode((((0, 1), 0.1), )), subTree[2][0])
self.assertEqual(decoder.DecodingNode((((1, 0), 0.1), )), subTree[1][0])
self.assertEqual(decoder.DecodingNode((((1, 1), 0.1), )), subTree[3][0])
def testBestTable(self):
"""Tests that the best pattern matching function of a subtree is
computed correctly."""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode((((1, 1, 0), 0.1), ((1, 0, 0), 0.1),
((1, 0, 1), 0.1), ((0, 0, 0), 0.1)))
splitFunc, bestLeaves, bestCost = dec.findBestTable(surSubtree)
self.assertEqual([1, 1, 0], splitFunc.table)
self.assertEqual(decoder.DecodingNode((((0, 0, 0), 0.1), )),
bestLeaves[0][0])
self.assertEqual(
decoder.DecodingNode((((1, 0, 0), 0.1), ((1, 0, 1), 0.1))),
bestLeaves[1][0])
self.assertEqual(decoder.DecodingNode((((1, 1, 0), 0.1), )),
bestLeaves[2][0])
def testTableCost1(self):
"""Tests that the computational cost of a subtree is computed
correctly."""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode(
(((1, 1), 0.1), ((0, 0), 0.1), ((0, 1), 0.1), ((1, 0), 0.1)))
cost, subTree = dec.computeTableCost(surSubtree, 0, 2)
self.assertEqual((0, 0.1), subTree[0][1])
self.assertEqual((1, 0.1), subTree[1][1])
self.assertEqual((2, 0.1), subTree[2][1])
self.assertEqual((3, 0.1), subTree[3][1])
self.assertEqual(decoder.DecodingNode((((0, 0), 0.1), )),
subTree[0][0])
self.assertEqual(decoder.DecodingNode((((0, 1), 0.1), )),
subTree[2][0])
self.assertEqual(decoder.DecodingNode((((1, 0), 0.1), )),
subTree[1][0])
self.assertEqual(decoder.DecodingNode((((1, 1), 0.1), )),
subTree[3][0])
def testBestPattern1(self):
"""Tests that the best pattern matching function of a subtree is
computed correctly."""
bitString1 = [None for i in range(0, 4)] + [0, 0, 0, 0, 1, 0, 1] + [
None for i in range(0, 16)
] + [0] + [None for i in range(0, 4)]
bitString2 = [None for i in range(0, 4)] + [0, 0, 0, 0, 1, 0, 1] + [
None for i in range(0, 13)
] + [0] + [None, None] + [1] + [None for i in range(0, 4)]
bitString3 = [None for i in range(0, 4)
] + [0, 0, 1, 0, 1, 0, 1] + [None for i in range(0, 21)]
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode(
((bitString1, 1), (bitString2, 1), (bitString3, 1)))
splitFunc, bestLeaves, bestCost = dec.findBestPattern(surSubtree)
self.assertEqual([None for i in range(0, 6)] + [1] +
[None for i in range(0, 25)], splitFunc.pattern)
self.assertEqual(
decoder.DecodingNode(((bitString1, 1), (bitString2, 1))),
bestLeaves[1][0])
self.assertEqual(decoder.DecodingNode(((bitString3, 1), )),
bestLeaves[0][0])
def testComplementDegen(self):
"""Test the correct operation of the complementPattern function in a
degenerate case where the complement set is null."""
dec = decoder.decoderCreator({}, {})
dec.complementPattern([None, None], 0)
self.assertEqual(0, len(dec.instrPattern))
def testComputeCost3(self):
"""Tests that the computational cost of a subtree is computed correctly.
This means that the corresponding huffman tree is computed correctly."""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode((((1, 1), 0.1), ((1, 1), 0.1), ((1, 1), 0.1), ((1, 1), 0.1)))
self.assertEqual(3, dec.computationalCost(surSubtree))
def testComputeCost2(self):
"""Tests that, given a subtree, the computational cost is correctly computed
this means that the corresponding huffman tree is comrrectly computed"""
dec = decoder.decoderCreator({}, {})
surSubtree = decoder.DecodingNode((((1, 1), 0.1), ((1, 1), 0.1), ((1, 1), 0.8), ((1, 1), 0.05)))
self.assertEqual(4, dec.computationalCost(surSubtree))
def testComplementDegen(self):
"""Test the correct operation of the complementPattern function
in a degenrated case where the complement set is null"""
dec = decoder.decoderCreator({}, {})
dec.complementPattern([None, None], 0)
self.assertEqual(0, len(dec.instrPattern))
