libgo/go/exp/norm/trie_test.go

   1 package norm
   2
   3 import (
   4         "testing"
   5         "utf8"
   6 )
   7
   8 // Test data is located in triedata_test.go; generated by maketesttables.
   9 var testdata = testdataTrie
  10
  11 type rangeTest struct {
  12         block   uint8
  13         lookup  byte
  14         result  uint16
  15         table   []valueRange
  16         offsets []uint16
  17 }
  18
  19 var range1Off = []uint16{0, 2}
  20 var range1 = []valueRange{
  21         {0, 1, 0},
  22         {1, 0x80, 0x80},
  23         {0, 2, 0},
  24         {1, 0x80, 0x80},
  25         {9, 0xff, 0xff},
  26 }
  27
  28 var rangeTests = []rangeTest{
  29         {10, 0x80, 1, range1, range1Off},
  30         {10, 0x00, 0, range1, range1Off},
  31         {11, 0x80, 1, range1, range1Off},
  32         {11, 0xff, 9, range1, range1Off},
  33         {11, 0x00, 0, range1, range1Off},
  34 }
  35
  36 func TestLookupSparse(t *testing.T) {
  37         for i, test := range rangeTests {
  38                 n := trie{sparse: test.table, sparseOffset: test.offsets, cutoff: 10}
  39                 v := n.lookupValue(test.block, test.lookup)
  40                 if v != test.result {
  41                         t.Errorf("LookupSparse:%d: found %X; want %X", i, v, test.result)
  42                 }
  43         }
  44 }
  45
  46 // Test cases for illegal runes.
  47 type trietest struct {
  48         size  int
  49         bytes []byte
  50 }
  51
  52 var tests = []trietest{
  53         // illegal runes
  54         {1, []byte{0x80}},
  55         {1, []byte{0xFF}},
  56         {1, []byte{t2, tx - 1}},
  57         {1, []byte{t2, t2}},
  58         {2, []byte{t3, tx, tx - 1}},
  59         {2, []byte{t3, tx, t2}},
  60         {1, []byte{t3, tx - 1, tx}},
  61         {3, []byte{t4, tx, tx, tx - 1}},
  62         {3, []byte{t4, tx, tx, t2}},
  63         {1, []byte{t4, t2, tx, tx - 1}},
  64         {2, []byte{t4, tx, t2, tx - 1}},
  65
  66         // short runes
  67         {0, []byte{t2}},
  68         {0, []byte{t3, tx}},
  69         {0, []byte{t4, tx, tx}},
  70
  71         // we only support UTF-8 up to utf8.UTFMax bytes (4 bytes)
  72         {1, []byte{t5, tx, tx, tx, tx}},
  73         {1, []byte{t6, tx, tx, tx, tx, tx}},
  74 }
  75
  76 func mkUtf8(rune int) ([]byte, int) {
  77         var b [utf8.UTFMax]byte
  78         sz := utf8.EncodeRune(b[:], rune)
  79         return b[:sz], sz
  80 }
  81
  82 func TestLookup(t *testing.T) {
  83         for i, tt := range testRunes {
  84                 b, szg := mkUtf8(tt)
  85                 v, szt := testdata.lookup(b)
  86                 if int(v) != i {
  87                         t.Errorf("lookup(%U): found value %#x, expected %#x", tt, v, i)
  88                 }
  89                 if szt != szg {
  90                         t.Errorf("lookup(%U): found size %d, expected %d", tt, szt, szg)
  91                 }
  92         }
  93         for i, tt := range tests {
  94                 v, sz := testdata.lookup(tt.bytes)
  95                 if int(v) != 0 {
  96                         t.Errorf("lookup of illegal rune, case %d: found value %#x, expected 0", i, v)
  97                 }
  98                 if sz != tt.size {
  99                         t.Errorf("lookup of illegal rune, case %d: found size %d, expected %d", i, sz, tt.size)
 100                 }
 101         }
 102 }
 103
 104 func TestLookupUnsafe(t *testing.T) {
 105         for i, tt := range testRunes {
 106                 b, _ := mkUtf8(tt)
 107                 v := testdata.lookupUnsafe(b)
 108                 if int(v) != i {
 109                         t.Errorf("lookupUnsafe(%U): found value %#x, expected %#x", i, v, i)
 110                 }
 111         }
 112 }
 113
 114 func TestLookupString(t *testing.T) {
 115         for i, tt := range testRunes {
 116                 b, szg := mkUtf8(tt)
 117                 v, szt := testdata.lookupString(string(b))
 118                 if int(v) != i {
 119                         t.Errorf("lookup(%U): found value %#x, expected %#x", i, v, i)
 120                 }
 121                 if szt != szg {
 122                         t.Errorf("lookup(%U): found size %d, expected %d", i, szt, szg)
 123                 }
 124         }
 125         for i, tt := range tests {
 126                 v, sz := testdata.lookupString(string(tt.bytes))
 127                 if int(v) != 0 {
 128                         t.Errorf("lookup of illegal rune, case %d: found value %#x, expected 0", i, v)
 129                 }
 130                 if sz != tt.size {
 131                         t.Errorf("lookup of illegal rune, case %d: found size %d, expected %d", i, sz, tt.size)
 132                 }
 133         }
 134 }
 135
 136 func TestLookupStringUnsafe(t *testing.T) {
 137         for i, tt := range testRunes {
 138                 b, _ := mkUtf8(tt)
 139                 v := testdata.lookupStringUnsafe(string(b))
 140                 if int(v) != i {
 141                         t.Errorf("lookupUnsafe(%U): found value %#x, expected %#x", i, v, i)
 142                 }
 143         }
 144 }