Index: net/tools/dafsa/make_dafsa_unittest.py |
diff --git a/net/tools/dafsa/make_dafsa_unittest.py b/net/tools/dafsa/make_dafsa_unittest.py |
deleted file mode 100755 |
index 65a82445122303b27df1819244366d0849643a2d..0000000000000000000000000000000000000000 |
--- a/net/tools/dafsa/make_dafsa_unittest.py |
+++ /dev/null |
@@ -1,759 +0,0 @@ |
-#!/usr/bin/env python |
-# Copyright 2014 The Chromium Authors. All rights reserved. |
-# Use of this source code is governed by a BSD-style license that can be |
-# found in the LICENSE file. |
- |
- |
-import sys |
-import unittest |
-import make_dafsa |
- |
- |
-class ParseGperfTest(unittest.TestCase): |
- def testMalformedKey(self): |
- """Tests exception is thrown at bad format.""" |
- infile1 = [ '%%', '', '%%' ] |
- self.assertRaises(make_dafsa.InputError, make_dafsa.parse_gperf, infile1) |
- |
- infile2 = [ '%%', 'apa,1', '%%' ] |
- self.assertRaises(make_dafsa.InputError, make_dafsa.parse_gperf, infile2) |
- |
- infile3 = [ '%%', 'apa, 1', '%%' ] |
- self.assertRaises(make_dafsa.InputError, make_dafsa.parse_gperf, infile3) |
- |
- def testBadValues(self): |
- """Tests exception is thrown when value is out of range.""" |
- infile1 = [ '%%', 'a, -1', '%%' ] |
- self.assertRaises(make_dafsa.InputError, make_dafsa.parse_gperf, infile1) |
- |
- infile2 = [ '%%', 'a, x', '%%' ] |
- self.assertRaises(make_dafsa.InputError, make_dafsa.parse_gperf, infile2) |
- |
- infile5 = [ '%%', 'a, 12', '%%' ] |
- self.assertRaises(make_dafsa.InputError, make_dafsa.parse_gperf, infile5) |
- |
- def testValues(self): |
- """Tests legal values are accepted.""" |
- infile1 = [ '%%', 'a, 0', '%%' ] |
- words1 = [ 'a0' ] |
- self.assertEqual(make_dafsa.parse_gperf(infile1), words1) |
- |
- infile2 = [ '%%', 'a, 1', '%%' ] |
- words2 = [ 'a1' ] |
- self.assertEqual(make_dafsa.parse_gperf(infile2), words2) |
- |
- infile3 = [ '%%', 'a, 2', '%%' ] |
- words3 = [ 'a2' ] |
- self.assertEqual(make_dafsa.parse_gperf(infile3), words3) |
- |
- infile4 = [ '%%', 'a, 3', '%%' ] |
- words4 = [ 'a3' ] |
- self.assertEqual(make_dafsa.parse_gperf(infile4), words4) |
- |
- infile5 = [ '%%', 'a, 4', '%%' ] |
- words5 = [ 'a4' ] |
- self.assertEqual(make_dafsa.parse_gperf(infile5), words5) |
- |
- infile6 = [ '%%', 'a, 6', '%%' ] |
- words6 = [ 'a6' ] |
- self.assertEqual(make_dafsa.parse_gperf(infile6), words6) |
- |
- def testOneWord(self): |
- """Tests a single key can be parsed.""" |
- infile = [ '%%', 'apa, 1', '%%' ] |
- words = [ 'apa1' ] |
- self.assertEqual(make_dafsa.parse_gperf(infile), words) |
- |
- def testTwoWords(self): |
- """Tests a sequence of keys can be parsed.""" |
- infile = [ '%%', 'apa, 1', 'bepa.com, 2', '%%' ] |
- words = [ 'apa1', 'bepa.com2' ] |
- self.assertEqual(make_dafsa.parse_gperf(infile), words) |
- |
- |
-class ToDafsaTest(unittest.TestCase): |
- def testEmptyInput(self): |
- """Tests exception is thrown at empty input.""" |
- words = () |
- self.assertRaises(make_dafsa.InputError, make_dafsa.to_dafsa, words) |
- |
- def testNonASCII(self): |
- """Tests exception is thrown if illegal characters are used.""" |
- words1 = ( chr(0x1F) + 'a1', ) |
- self.assertRaises(make_dafsa.InputError, make_dafsa.to_dafsa, words1) |
- |
- words2 = ( 'a' + chr(0x1F) + '1', ) |
- self.assertRaises(make_dafsa.InputError, make_dafsa.to_dafsa, words2) |
- |
- words3 = ( chr(0x80) + 'a1', ) |
- self.assertRaises(make_dafsa.InputError, make_dafsa.to_dafsa, words3) |
- |
- words4 = ( 'a' + chr(0x80) + '1', ) |
- self.assertRaises(make_dafsa.InputError, make_dafsa.to_dafsa, words4) |
- |
- def testChar(self): |
- """Tests a DAFSA can be created from a single character domain name.""" |
- words = [ 'a0' ] |
- node2 = ( chr(0), [ None ] ) |
- node1 = ( 'a', [ node2 ] ) |
- source = [ node1 ] |
- self.assertEqual(make_dafsa.to_dafsa(words), source) |
- |
- def testChars(self): |
- """Tests a DAFSA can be created from a multi character domain name.""" |
- words = [ 'ab0' ] |
- node3 = ( chr(0), [ None ] ) |
- node2 = ( 'b', [ node3 ] ) |
- node1 = ( 'a', [ node2 ] ) |
- source = [ node1 ] |
- self.assertEqual(make_dafsa.to_dafsa(words), source) |
- |
- def testWords(self): |
- """Tests a DAFSA can be created from a sequence of domain names.""" |
- words = [ 'a0', 'b1' ] |
- node4 = ( chr(1), [ None ] ) |
- node3 = ( 'b', [ node4 ] ) |
- node2 = ( chr(0), [ None ] ) |
- node1 = ( 'a', [ node2 ] ) |
- source = [ node1, node3 ] |
- self.assertEqual(make_dafsa.to_dafsa(words), source) |
- |
- |
-class ToWordsTest(unittest.TestCase): |
- def testSink(self): |
- """Tests the sink is exapnded to a list with an empty string.""" |
- node1 = None |
- words = [ '' ] |
- self.assertEqual(make_dafsa.to_words(node1), words) |
- |
- def testSingleNode(self): |
- """Tests a single node is expanded to a list with the label string.""" |
- |
- # 'ab' -> [ 'ab' ] |
- |
- node1 = ( 'ab', [ None ] ) |
- words = [ 'ab' ] |
- self.assertEqual(make_dafsa.to_words(node1), words) |
- |
- def testChain(self): |
- """Tests a sequence of nodes are preoperly expanded.""" |
- |
- # 'ab' -> 'cd' => [ 'abcd' ] |
- |
- node2 = ( 'cd', [ None ] ) |
- node1 = ( 'ab', [ node2 ] ) |
- words = [ 'abcd' ] |
- self.assertEqual(make_dafsa.to_words(node1), words) |
- |
- def testInnerTerminator(self): |
- """Tests a sequence with an inner terminator is expanded to two strings.""" |
- |
- # 'a' -> 'b' |
- # \ => [ 'ab', 'a' ] |
- # {sink} |
- |
- node2 = ( 'b', [ None ] ) |
- node1 = ( 'a', [ node2, None ] ) |
- words = [ 'ab', 'a' ] |
- self.assertEqual(make_dafsa.to_words(node1), words) |
- |
- def testDiamond(self): |
- """Tests a diamond can be expanded to a word list.""" |
- |
- # 'cd' |
- # / \ |
- # 'ab' 'gh' |
- # \ / |
- # 'ef' |
- |
- node4 = ( 'gh', [ None ] ) |
- node3 = ( 'ef', [ node4 ] ) |
- node2 = ( 'cd', [ node4 ] ) |
- node1 = ( 'ab', [ node2, node3 ] ) |
- words = [ 'abcdgh', 'abefgh' ] |
- self.assertEqual(make_dafsa.to_words(node1), words) |
- |
- |
-class JoinLabelsTest(unittest.TestCase): |
- def testLabel(self): |
- """Tests a single label passes unchanged.""" |
- |
- # 'a' => 'a' |
- |
- node1 = ( 'a', [ None ] ) |
- source = [ node1 ] |
- self.assertEqual(make_dafsa.join_labels(source), source) |
- |
- def testInnerTerminator(self): |
- """Tests a sequence with an inner terminator passes unchanged.""" |
- |
- # 'a' -> 'b' 'a' -> 'b' |
- # \ => \ |
- # {sink} {sink} |
- |
- node2 = ( 'b', [ None ] ) |
- node1 = ( 'a', [ node2, None ] ) |
- source = [ node1 ] |
- self.assertEqual(make_dafsa.join_labels(source), source) |
- |
- def testLabels(self): |
- """Tests a sequence of labels can be joined.""" |
- |
- # 'a' -> 'b' => 'ab' |
- |
- node2 = ( 'b', [ None ] ) |
- node1 = ( 'a', [ node2 ] ) |
- source1 = [ node1 ] |
- node3 = ( 'ab', [ None ] ) |
- source2 = [ node3 ] |
- self.assertEqual(make_dafsa.join_labels(source1), source2) |
- |
- def testCompositeLabels(self): |
- """Tests a sequence of multi character labels can be joined.""" |
- |
- # 'ab' -> 'cd' => 'abcd' |
- |
- node2 = ( 'cd', [ None ] ) |
- node1 = ( 'ab', [ node2 ] ) |
- source1 = [ node1 ] |
- node3 = ( 'abcd', [ None ] ) |
- source2 = [ node3 ] |
- self.assertEqual(make_dafsa.join_labels(source1), source2) |
- |
- def testAtomicTrie(self): |
- """Tests a trie formed DAFSA with atomic labels passes unchanged.""" |
- |
- # 'b' 'b' |
- # / / |
- # 'a' => 'a' |
- # \ \ |
- # 'c' 'c' |
- |
- node3 = ( 'c', [ None ] ) |
- node2 = ( 'b', [ None ] ) |
- node1 = ( 'a', [ node2, node3 ] ) |
- source = [ node1 ] |
- self.assertEqual(make_dafsa.join_labels(source), source) |
- |
- def testReverseAtomicTrie(self): |
- """Tests a reverse trie formed DAFSA with atomic labels passes unchanged.""" |
- |
- # 'a' 'a' |
- # \ \ |
- # 'c' => 'c' |
- # / / |
- # 'b' 'b' |
- |
- node3 = ( 'c', [ None ] ) |
- node2 = ( 'b', [ node3 ] ) |
- node1 = ( 'a', [ node3 ] ) |
- source = [ node1, node2 ] |
- self.assertEqual(make_dafsa.join_labels(source), source) |
- |
- def testChainedTrie(self): |
- """Tests a trie formed DAFSA with chained labels can be joined.""" |
- |
- # 'c' -> 'd' 'cd' |
- # / / |
- # 'a' -> 'b' => 'ab' |
- # \ \ |
- # 'e' -> 'f' 'ef' |
- |
- node6 = ( 'f', [ None ] ) |
- node5 = ( 'e', [ node6 ] ) |
- node4 = ( 'd', [ None ] ) |
- node3 = ( 'c', [ node4 ] ) |
- node2 = ( 'b', [ node3, node5 ] ) |
- node1 = ( 'a', [ node2 ] ) |
- source1 = [ node1 ] |
- node9 = ( 'ef', [ None ] ) |
- node8 = ( 'cd', [ None ] ) |
- node7 = ( 'ab', [ node8, node9 ] ) |
- source2 = [ node7 ] |
- self.assertEqual(make_dafsa.join_labels(source1), source2) |
- |
- def testReverseChainedTrie(self): |
- """Tests a reverse trie formed DAFSA with chained labels can be joined.""" |
- |
- # 'a' -> 'b' 'ab' |
- # \ \ |
- # 'e' -> 'f' => 'ef' |
- # / / |
- # 'c' -> 'd' 'cd' |
- |
- node6 = ( 'f', [ None ] ) |
- node5 = ( 'e', [ node6 ] ) |
- node4 = ( 'd', [ node5 ] ) |
- node3 = ( 'c', [ node4 ] ) |
- node2 = ( 'b', [ node5 ] ) |
- node1 = ( 'a', [ node2 ] ) |
- source1 = [ node1, node3 ] |
- node9 = ( 'ef', [ None ] ) |
- node8 = ( 'cd', [ node9 ] ) |
- node7 = ( 'ab', [ node9 ] ) |
- source2 = [ node7, node8 ] |
- self.assertEqual(make_dafsa.join_labels(source1), source2) |
- |
- |
-class JoinSuffixesTest(unittest.TestCase): |
- def testSingleLabel(self): |
- """Tests a single label passes unchanged.""" |
- |
- # 'a' => 'a' |
- |
- node1 = ( 'a', [ None ] ) |
- source = [ node1 ] |
- self.assertEqual(make_dafsa.join_suffixes(source), source) |
- |
- def testInnerTerminator(self): |
- """Tests a sequence with an inner terminator passes unchanged.""" |
- |
- # 'a' -> 'b' 'a' -> 'b' |
- # \ => \ |
- # {sink} {sink} |
- |
- node2 = ( 'b', [ None ] ) |
- node1 = ( 'a', [ node2, None ] ) |
- source = [ node1 ] |
- self.assertEqual(make_dafsa.join_suffixes(source), source) |
- |
- def testDistinctTrie(self): |
- """Tests a trie formed DAFSA with distinct labels passes unchanged.""" |
- |
- # 'b' 'b' |
- # / / |
- # 'a' => 'a' |
- # \ \ |
- # 'c' 'c' |
- |
- node3 = ( 'c', [ None ] ) |
- node2 = ( 'b', [ None ] ) |
- node1 = ( 'a', [ node2, node3 ] ) |
- source = [ node1 ] |
- self.assertEqual(make_dafsa.join_suffixes(source), source) |
- |
- def testReverseDistinctTrie(self): |
- """Tests a reverse trie formed DAFSA with distinct labels passes unchanged. |
- """ |
- |
- # 'a' 'a' |
- # \ \ |
- # 'c' => 'c' |
- # / / |
- # 'b' 'b' |
- |
- node3 = ( 'c', [ None ] ) |
- node2 = ( 'b', [ node3 ] ) |
- node1 = ( 'a', [ node3 ] ) |
- source = [ node1, node2 ] |
- self.assertEqual(make_dafsa.join_suffixes(source), source) |
- |
- def testJoinTwoHeads(self): |
- """Tests two heads can be joined even if there is something else between.""" |
- |
- # 'a' ------'a' |
- # / |
- # 'b' => 'b' / |
- # / |
- # 'a' --- |
- # |
- # The picture above should shows that the new version should have just one |
- # instance of the node with label 'a'. |
- |
- node3 = ( 'a', [ None ] ) |
- node2 = ( 'b', [ None ] ) |
- node1 = ( 'a', [ None ] ) |
- source1 = [ node1, node2, node3 ] |
- source2 = make_dafsa.join_suffixes(source1) |
- |
- # Both versions should expand to the same content. |
- self.assertEqual(source1, source2) |
- # But the new version should have just one instance of 'a'. |
- self.assertIs(source2[0], source2[2]) |
- |
- def testJoinTails(self): |
- """Tests tails can be joined.""" |
- |
- # 'a' -> 'c' 'a' |
- # \ |
- # => 'c' |
- # / |
- # 'b' -> 'c' 'b' |
- |
- node4 = ( 'c', [ None ] ) |
- node3 = ( 'b', [ node4 ] ) |
- node2 = ( 'c', [ None ] ) |
- node1 = ( 'a', [ node2 ] ) |
- source1 = [ node1, node3 ] |
- source2 = make_dafsa.join_suffixes(source1) |
- |
- # Both versions should expand to the same content. |
- self.assertEqual(source1, source2) |
- # But the new version should have just one tail. |
- self.assertIs(source2[0][1][0], source2[1][1][0]) |
- |
- def testMakeRecursiveTrie(self): |
- """Tests recursive suffix join.""" |
- |
- # 'a' -> 'e' -> 'g' 'a' |
- # \ |
- # 'e' |
- # / \ |
- # 'b' -> 'e' -> 'g' 'b' \ |
- # \ |
- # => 'g' |
- # / |
- # 'c' -> 'f' -> 'g' 'c' / |
- # \ / |
- # 'f' |
- # / |
- # 'd' -> 'f' -> 'g' 'd' |
- |
- node7 = ( 'g', [ None ] ) |
- node6 = ( 'f', [ node7 ] ) |
- node5 = ( 'e', [ node7 ] ) |
- node4 = ( 'd', [ node6 ] ) |
- node3 = ( 'c', [ node6 ] ) |
- node2 = ( 'b', [ node5 ] ) |
- node1 = ( 'a', [ node5 ] ) |
- source1 = [ node1, node2, node3, node4 ] |
- source2 = make_dafsa.join_suffixes(source1) |
- |
- # Both versions should expand to the same content. |
- self.assertEqual(source1, source2) |
- # But the new version should have just one 'e'. |
- self.assertIs(source2[0][1][0], source2[1][1][0]) |
- # And one 'f'. |
- self.assertIs(source2[2][1][0], source2[3][1][0]) |
- # And one 'g'. |
- self.assertIs(source2[0][1][0][1][0], source2[2][1][0][1][0]) |
- |
- def testMakeDiamond(self): |
- """Test we can join suffixes of a trie.""" |
- |
- # 'b' -> 'd' 'b' |
- # / / \ |
- # 'a' => 'a' 'd' |
- # \ \ / |
- # 'c' -> 'd' 'c' |
- |
- node5 = ( 'd', [ None ] ) |
- node4 = ( 'c', [ node5 ] ) |
- node3 = ( 'd', [ None ] ) |
- node2 = ( 'b', [ node3 ] ) |
- node1 = ( 'a', [ node2, node4 ] ) |
- source1 = [ node1 ] |
- source2 = make_dafsa.join_suffixes(source1) |
- |
- # Both versions should expand to the same content. |
- self.assertEqual(source1, source2) |
- # But the new version should have just one 'd'. |
- self.assertIs(source2[0][1][0][1][0], source2[0][1][1][1][0]) |
- |
- def testJoinOneChild(self): |
- """Tests that we can join some children but not all.""" |
- |
- # 'c' ----'c' |
- # / / / |
- # 'a' 'a' / |
- # \ \ / |
- # 'd' 'd'/ |
- # => / |
- # 'c' / |
- # / / |
- # 'b' 'b' |
- # \ \ |
- # 'e' 'e' |
- |
- node6 = ( 'e', [ None ] ) |
- node5 = ( 'c', [ None ] ) |
- node4 = ( 'b', [ node5, node6 ] ) |
- node3 = ( 'd', [ None ] ) |
- node2 = ( 'c', [ None ] ) |
- node1 = ( 'a', [ node2, node3 ] ) |
- source1 = [ node1, node4 ] |
- source2 = make_dafsa.join_suffixes(source1) |
- |
- # Both versions should expand to the same content. |
- self.assertEqual(source1, source2) |
- # But the new version should have just one 'c'. |
- self.assertIs(source2[0][1][0], source2[1][1][0]) |
- |
- |
-class ReverseTest(unittest.TestCase): |
- def testAtomicLabel(self): |
- """Tests an atomic label passes unchanged.""" |
- |
- # 'a' => 'a' |
- |
- node1 = ( 'a', [ None ] ) |
- source = [ node1 ] |
- self.assertEqual(make_dafsa.reverse(source), source) |
- |
- def testLabel(self): |
- """Tests that labels are reversed.""" |
- |
- # 'ab' => 'ba' |
- |
- node1 = ( 'ab', [ None ] ) |
- source1 = [ node1 ] |
- node2 = ( 'ba', [ None ] ) |
- source2 = [ node2 ] |
- self.assertEqual(make_dafsa.reverse(source1), source2) |
- |
- def testChain(self): |
- """Tests that edges are reversed.""" |
- |
- # 'a' -> 'b' => 'b' -> 'a' |
- |
- node2 = ( 'b', [ None ] ) |
- node1 = ( 'a', [ node2 ] ) |
- source1 = [ node1 ] |
- node4 = ( 'a', [ None ] ) |
- node3 = ( 'b', [ node4 ] ) |
- source2 = [ node3 ] |
- self.assertEqual(make_dafsa.reverse(source1), source2) |
- |
- def testInnerTerminator(self): |
- """Tests a sequence with an inner terminator can be reversed.""" |
- |
- # 'a' -> 'b' 'b' -> 'a' |
- # \ => / |
- # {sink} ------ |
- |
- node2 = ( 'b', [ None ] ) |
- node1 = ( 'a', [ node2, None ] ) |
- source1 = [ node1 ] |
- node4 = ( 'a', [ None ] ) |
- node3 = ( 'b', [ node4 ] ) |
- source2 = [ node3, node4 ] |
- self.assertEqual(make_dafsa.reverse(source1), source2) |
- |
- def testAtomicTrie(self): |
- """Tests a trie formed DAFSA can be reversed.""" |
- |
- # 'b' 'b' |
- # / \ |
- # 'a' => 'a' |
- # \ / |
- # 'c' 'c' |
- |
- node3 = ( 'c', [ None ] ) |
- node2 = ( 'b', [ None ] ) |
- node1 = ( 'a', [ node2, node3 ] ) |
- source1 = [ node1 ] |
- node6 = ( 'a', [ None ] ) |
- node5 = ( 'c', [ node6 ] ) |
- node4 = ( 'b', [ node6 ] ) |
- source2 = [ node4, node5 ] |
- self.assertEqual(make_dafsa.reverse(source1), source2) |
- |
- def testReverseAtomicTrie(self): |
- """Tests a reverse trie formed DAFSA can be reversed.""" |
- |
- # 'a' 'a' |
- # \ / |
- # 'c' => 'c' |
- # / \ |
- # 'b' 'b' |
- |
- node3 = ( 'c', [ None ] ) |
- node2 = ( 'b', [ node3 ] ) |
- node1 = ( 'a', [ node3 ] ) |
- source1 = [ node1, node2 ] |
- node6 = ( 'b', [ None ] ) |
- node5 = ( 'a', [ None ] ) |
- node4 = ( 'c', [ node5, node6 ] ) |
- source2 = [ node4 ] |
- self.assertEqual(make_dafsa.reverse(source1), source2) |
- |
- def testDiamond(self): |
- """Tests we can reverse both edges and nodes in a diamond.""" |
- |
- # 'cd' 'dc' |
- # / \ / \ |
- # 'ab' 'gh' => 'hg' 'ba' |
- # \ / \ / |
- # 'ef' 'fe' |
- |
- node4 = ( 'gh', [ None ] ) |
- node3 = ( 'ef', [ node4 ] ) |
- node2 = ( 'cd', [ node4 ] ) |
- node1 = ( 'ab', [ node2, node3 ] ) |
- source1 = [ node1 ] |
- node8 = ( 'ba', [ None ] ) |
- node7 = ( 'fe', [ node8 ] ) |
- node6 = ( 'dc', [ node8 ] ) |
- node5 = ( 'hg', [ node6, node7 ] ) |
- source2 = [ node5 ] |
- self.assertEqual(make_dafsa.reverse(source1), source2) |
- |
- |
-class TopSortTest(unittest.TestCase): |
- def testNode(self): |
- """Tests a DAFSA with one node can be sorted.""" |
- |
- # 'a' => [ 'a' ] |
- |
- node1 = ( 'a', [ None ] ) |
- source = [ node1 ] |
- nodes = [ node1 ] |
- self.assertEqual(make_dafsa.top_sort(source), nodes) |
- |
- def testDiamond(self): |
- """Tests nodes in a diamond can be sorted.""" |
- |
- # 'b' |
- # / \ |
- # 'a' 'd' |
- # \ / |
- # 'c' |
- |
- node4 = ( 'd', [ None ] ) |
- node3 = ( 'c', [ node4 ] ) |
- node2 = ( 'b', [ node4 ] ) |
- node1 = ( 'a', [ node2, node3 ] ) |
- source = [ node1 ] |
- nodes = make_dafsa.top_sort(source) |
- self.assertLess(nodes.index(node1), nodes.index(node2)) |
- self.assertLess(nodes.index(node2), nodes.index(node4)) |
- self.assertLess(nodes.index(node3), nodes.index(node4)) |
- |
- |
-class EncodePrefixTest(unittest.TestCase): |
- def testChar(self): |
- """Tests to encode a single character prefix.""" |
- label = 'a' |
- bytes = [ ord('a') ] |
- self.assertEqual(make_dafsa.encode_prefix(label), bytes) |
- |
- def testChars(self): |
- """Tests to encode a multi character prefix.""" |
- label = 'ab' |
- bytes = [ ord('b'), ord('a') ] |
- self.assertEqual(make_dafsa.encode_prefix(label), bytes) |
- |
- |
-class EncodeLabelTest(unittest.TestCase): |
- def testChar(self): |
- """Tests to encode a single character label.""" |
- label = 'a' |
- bytes = [ ord('a') + 0x80 ] |
- self.assertEqual(make_dafsa.encode_label(label), bytes) |
- |
- def testChars(self): |
- """Tests to encode a multi character label.""" |
- label = 'ab' |
- bytes = [ ord('b') + 0x80, ord('a') ] |
- self.assertEqual(make_dafsa.encode_label(label), bytes) |
- |
- |
-class EncodeLinksTest(unittest.TestCase): |
- def testEndLabel(self): |
- """Tests to encode link to the sink.""" |
- children = [ None ] |
- offsets = {} |
- bytes = 0 |
- output = [] |
- self.assertEqual(make_dafsa.encode_links(children, offsets, bytes), |
- output) |
- |
- def testOneByteOffset(self): |
- """Tests to encode a single one byte offset.""" |
- node = ( '', [ None ] ) |
- children = [ node ] |
- offsets = { id(node) : 2 } |
- bytes = 5 |
- output = [ 132 ] |
- self.assertEqual(make_dafsa.encode_links(children, offsets, bytes), |
- output) |
- |
- def testOneByteOffsets(self): |
- """Tests to encode a sequence of one byte offsets.""" |
- node1 = ( '', [ None ] ) |
- node2 = ( '', [ None ] ) |
- children = [ node1, node2 ] |
- offsets = { id(node1) : 2, id(node2) : 1 } |
- bytes = 5 |
- output = [ 129, 5 ] |
- self.assertEqual(make_dafsa.encode_links(children, offsets, bytes), |
- output) |
- |
- def testTwoBytesOffset(self): |
- """Tests to encode a single two byte offset.""" |
- node = ( '', [ None ] ) |
- children = [ node ] |
- offsets = { id(node) : 2 } |
- bytes = 1005 |
- output = [ 237, 195] |
- self.assertEqual(make_dafsa.encode_links(children, offsets, bytes), |
- output) |
- |
- def testTwoBytesOffsets(self): |
- """Tests to encode a sequence of two byte offsets.""" |
- node1 = ( '', [ None ] ) |
- node2 = ( '', [ None ] ) |
- node3 = ( '', [ None ] ) |
- children = [ node1, node2, node3 ] |
- offsets = { id(node1) : 1002, id(node2) : 2, id(node3) : 2002 } |
- bytes = 3005 |
- output = [ 232, 195, 232, 67, 241, 67 ] |
- self.assertEqual(make_dafsa.encode_links(children, offsets, bytes), |
- output) |
- |
- def testThreeBytesOffset(self): |
- """Tests to encode a single three byte offset.""" |
- node = ( '', [ None ] ) |
- children = [ node ] |
- offsets = { id(node) : 2 } |
- bytes = 100005 |
- output = [ 166, 134, 225 ] |
- self.assertEqual(make_dafsa.encode_links(children, offsets, bytes), |
- output) |
- |
- def testThreeBytesOffsets(self): |
- """Tests to encode a sequence of three byte offsets.""" |
- node1 = ( '', [ None ] ) |
- node2 = ( '', [ None ] ) |
- node3 = ( '', [ None ] ) |
- children = [ node1, node2, node3 ] |
- offsets = { id(node1) : 100002, id(node2) : 2, id(node3) : 200002 } |
- bytes = 300005 |
- output = [ 160, 134, 225, 160, 134, 97, 172, 134, 97 ] |
- self.assertEqual(make_dafsa.encode_links(children, offsets, bytes), |
- output) |
- |
- def testOneTwoThreeBytesOffsets(self): |
- """Tests to encode offsets of different sizes.""" |
- node1 = ( '', [ None ] ) |
- node2 = ( '', [ None ] ) |
- node3 = ( '', [ None ] ) |
- children = [ node1, node2, node3 ] |
- offsets = { id(node1) : 10003, id(node2) : 10002, id(node3) : 100002 } |
- bytes = 300005 |
- output = [ 129, 143, 95, 97, 74, 13, 99 ] |
- self.assertEqual(make_dafsa.encode_links(children, offsets, bytes), |
- output) |
- |
- |
-class ExamplesTest(unittest.TestCase): |
- def testExample1(self): |
- """Tests Example 1 from make_dafsa.py.""" |
- infile = [ '%%', 'aa, 1', 'a, 2', '%%' ] |
- bytes = [ 0x81, 0xE1, 0x02, 0x81, 0x82, 0x61, 0x81 ] |
- outfile = make_dafsa.to_cxx(bytes) |
- self.assertEqual(make_dafsa.words_to_cxx(make_dafsa.parse_gperf(infile)), |
- outfile) |
- |
- def testExample2(self): |
- """Tests Example 2 from make_dafsa.py.""" |
- infile = [ '%%', 'aa, 1', 'bbb, 2', 'baa, 1', '%%' ] |
- bytes = [ 0x02, 0x83, 0xE2, 0x02, 0x83, 0x61, 0x61, 0x81, 0x62, 0x62, |
- 0x82 ] |
- outfile = make_dafsa.to_cxx(bytes) |
- self.assertEqual(make_dafsa.words_to_cxx(make_dafsa.parse_gperf(infile)), |
- outfile) |
- |
- |
-if __name__ == '__main__': |
- unittest.main() |