diff options
Diffstat (limited to 'gcc-4.7/libgo/go/exp/norm/iter_test.go')
| -rw-r--r-- | gcc-4.7/libgo/go/exp/norm/iter_test.go | 186 |
1 files changed, 186 insertions, 0 deletions
diff --git a/gcc-4.7/libgo/go/exp/norm/iter_test.go b/gcc-4.7/libgo/go/exp/norm/iter_test.go new file mode 100644 index 000000000..f6e8d8172 --- /dev/null +++ b/gcc-4.7/libgo/go/exp/norm/iter_test.go @@ -0,0 +1,186 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package norm + +import ( + "strings" + "testing" +) + +var iterBufSizes = []int{ + MaxSegmentSize, + 1.5 * MaxSegmentSize, + 2 * MaxSegmentSize, + 3 * MaxSegmentSize, + 100 * MaxSegmentSize, +} + +func doIterNorm(f Form, buf []byte, s string) []byte { + acc := []byte{} + i := Iter{} + i.SetInputString(f, s) + for !i.Done() { + n := i.Next(buf) + acc = append(acc, buf[:n]...) + } + return acc +} + +func runIterTests(t *testing.T, name string, f Form, tests []AppendTest, norm bool) { + for i, test := range tests { + in := test.left + test.right + gold := test.out + if norm { + gold = string(f.AppendString(nil, test.out)) + } + for _, sz := range iterBufSizes { + buf := make([]byte, sz) + out := string(doIterNorm(f, buf, in)) + if len(out) != len(gold) { + const msg = "%s:%d:%d: length is %d; want %d" + t.Errorf(msg, name, i, sz, len(out), len(gold)) + } + if out != gold { + // Find first rune that differs and show context. + ir := []rune(out) + ig := []rune(gold) + for j := 0; j < len(ir) && j < len(ig); j++ { + if ir[j] == ig[j] { + continue + } + if j -= 3; j < 0 { + j = 0 + } + for e := j + 7; j < e && j < len(ir) && j < len(ig); j++ { + const msg = "%s:%d:%d: runeAt(%d) = %U; want %U" + t.Errorf(msg, name, i, sz, j, ir[j], ig[j]) + } + break + } + } + } + } +} + +func rep(r rune, n int) string { + return strings.Repeat(string(r), n) +} + +var iterTests = []AppendTest{ + {"", ascii, ascii}, + {"", txt_all, txt_all}, + {"", "a" + rep(0x0300, MaxSegmentSize/2), "a" + rep(0x0300, MaxSegmentSize/2)}, +} + +var iterTestsD = []AppendTest{ + { // segment overflow on unchanged character + "", + "a" + rep(0x0300, MaxSegmentSize/2) + "\u0316", + "a" + rep(0x0300, MaxSegmentSize/2-1) + "\u0316\u0300", + }, + { // segment overflow on unchanged character + start value + "", + "a" + rep(0x0300, MaxSegmentSize/2+maxCombiningChars+4) + "\u0316", + "a" + rep(0x0300, MaxSegmentSize/2+maxCombiningChars) + "\u0316" + rep(0x300, 4), + }, + { // segment overflow on decomposition + "", + "a" + rep(0x0300, MaxSegmentSize/2-1) + "\u0340", + "a" + rep(0x0300, MaxSegmentSize/2), + }, + { // segment overflow on decomposition + start value + "", + "a" + rep(0x0300, MaxSegmentSize/2-1) + "\u0340" + rep(0x300, maxCombiningChars+4) + "\u0320", + "a" + rep(0x0300, MaxSegmentSize/2-1) + rep(0x300, maxCombiningChars+1) + "\u0320" + rep(0x300, 4), + }, + { // start value after ASCII overflow + "", + rep('a', MaxSegmentSize) + rep(0x300, maxCombiningChars+2) + "\u0320", + rep('a', MaxSegmentSize) + rep(0x300, maxCombiningChars) + "\u0320\u0300\u0300", + }, + { // start value after Hangul overflow + "", + rep(0xAC00, MaxSegmentSize/6) + rep(0x300, maxCombiningChars+2) + "\u0320", + strings.Repeat("\u1100\u1161", MaxSegmentSize/6) + rep(0x300, maxCombiningChars-1) + "\u0320" + rep(0x300, 3), + }, + { // start value after cc=0 + "", + "您您" + rep(0x300, maxCombiningChars+4) + "\u0320", + "您您" + rep(0x300, maxCombiningChars) + "\u0320" + rep(0x300, 4), + }, + { // start value after normalization + "", + "\u0300\u0320a" + rep(0x300, maxCombiningChars+4) + "\u0320", + "\u0320\u0300a" + rep(0x300, maxCombiningChars) + "\u0320" + rep(0x300, 4), + }, +} + +var iterTestsC = []AppendTest{ + { // ordering of non-composing combining characters + "", + "\u0305\u0316", + "\u0316\u0305", + }, + { // segment overflow + "", + "a" + rep(0x0305, MaxSegmentSize/2+4) + "\u0316", + "a" + rep(0x0305, MaxSegmentSize/2-1) + "\u0316" + rep(0x305, 5), + }, +} + +func TestIterNextD(t *testing.T) { + runIterTests(t, "IterNextD1", NFKD, appendTests, true) + runIterTests(t, "IterNextD2", NFKD, iterTests, true) + runIterTests(t, "IterNextD3", NFKD, iterTestsD, false) +} + +func TestIterNextC(t *testing.T) { + runIterTests(t, "IterNextC1", NFKC, appendTests, true) + runIterTests(t, "IterNextC2", NFKC, iterTests, true) + runIterTests(t, "IterNextC3", NFKC, iterTestsC, false) +} + +type SegmentTest struct { + in string + out []string +} + +var segmentTests = []SegmentTest{ + {rep('a', MaxSegmentSize), []string{rep('a', MaxSegmentSize), ""}}, + {rep('a', MaxSegmentSize+2), []string{rep('a', MaxSegmentSize-1), "aaa", ""}}, + {rep('a', MaxSegmentSize) + "\u0300aa", []string{rep('a', MaxSegmentSize-1), "a\u0300", "aa", ""}}, +} + +// Note that, by design, segmentation is equal for composing and decomposing forms. +func TestIterSegmentation(t *testing.T) { + segmentTest(t, "SegmentTestD", NFD, segmentTests) + segmentTest(t, "SegmentTestC", NFC, segmentTests) +} + +func segmentTest(t *testing.T, name string, f Form, tests []SegmentTest) { + iter := Iter{} + for i, tt := range segmentTests { + buf := make([]byte, MaxSegmentSize) + iter.SetInputString(f, tt.in) + for j, seg := range tt.out { + if seg == "" { + if !iter.Done() { + n := iter.Next(buf) + res := string(buf[:n]) + t.Errorf(`%s:%d:%d: expected Done()==true, found segment "%s"`, name, i, j, res) + } + continue + } + if iter.Done() { + t.Errorf("%s:%d:%d: Done()==true, want false", name, i, j) + } + n := iter.Next(buf) + seg = f.String(seg) + if res := string(buf[:n]); res != seg { + t.Errorf(`%s:%d:%d" segment was "%s" (%d); want "%s" (%d)`, name, i, j, res, len(res), seg, len(seg)) + } + } + } +} |