github.com/graybobo/golang.org-package-offline-cache@v0.0.0-20200626051047-6608995c132f/x/text/collate/colltab/numeric_test.go (about)

     1  // Copyright 2014 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package colltab
     6  
     7  import (
     8  	"reflect"
     9  	"strings"
    10  	"testing"
    11  )
    12  
    13  const (
    14  	digSec  = defaultSecondary
    15  	digTert = defaultTertiary
    16  )
    17  
    18  var tPlus3 = e(0, 50, digTert+3)
    19  
    20  // numWeighter is a testWeighter used for testing numericWeighter.
    21  var numWeighter = testWeighter{
    22  	"0": p(100),
    23  	"０": []Elem{e(100, digSec, digTert+1)}, // U+FF10 FULLWIDTH DIGIT ZERO
    24  	"₀": []Elem{e(100, digSec, digTert+5)}, // U+2080 SUBSCRIPT ZERO
    25  
    26  	"1": p(101),
    27  	// Allow non-primary collation elements to be inserted.
    28  	"١": append(p(101), tPlus3), // U+0661 ARABIC-INDIC DIGIT ONE
    29  	// Allow varying tertiary weight if the number is Nd.
    30  	"１": []Elem{e(101, digSec, digTert+1)}, // U+FF11 FULLWIDTH DIGIT ONE
    31  	"2": p(102),
    32  	// Allow non-primary collation elements to be inserted.
    33  	"٢": append(p(102), tPlus3), // U+0662 ARABIC-INDIC DIGIT TWO
    34  	// Varying tertiary weights should be ignored.
    35  	"２": []Elem{e(102, digSec, digTert+3)}, // U+FF12 FULLWIDTH DIGIT TWO
    36  	"3": p(103),
    37  	"4": p(104),
    38  	"5": p(105),
    39  	"6": p(106),
    40  	"7": p(107),
    41  	// Weights must be strictly monotonically increasing, but do not need to be
    42  	// consecutive.
    43  	"8": p(118),
    44  	"9": p(119),
    45  	// Allow non-primary collation elements to be inserted.
    46  	"٩": append(p(119), tPlus3), // U+0669 ARABIC-INDIC DIGIT NINE
    47  	// Varying tertiary weights should be ignored.
    48  	"９": []Elem{e(119, digSec, digTert+1)}, // U+FF19 FULLWIDTH DIGIT NINE
    49  	"₉": []Elem{e(119, digSec, digTert+5)}, // U+2089 SUBSCRIPT NINE
    50  
    51  	"a": p(5),
    52  	"b": p(6),
    53  	"c": p(8, 2),
    54  
    55  	"klm": p(99),
    56  
    57  	"nop": p(121),
    58  
    59  	"x": p(200),
    60  	"y": p(201),
    61  }
    62  
    63  func p(w ...int) (elems []Elem) {
    64  	for _, x := range w {
    65  		e, _ := MakeElem(x, digSec, digTert, 0)
    66  		elems = append(elems, e)
    67  	}
    68  	return elems
    69  }
    70  
    71  func TestNumericAppendNext(t *testing.T) {
    72  	for _, tt := range []struct {
    73  		in string
    74  		w  []Elem
    75  	}{
    76  		{"a", p(5)},
    77  		{"klm", p(99)},
    78  		{"aa", p(5, 5)},
    79  		{"1", p(120, 1, 101)},
    80  		{"0", p(120, 0)},
    81  		{"01", p(120, 1, 101)},
    82  		{"0001", p(120, 1, 101)},
    83  		{"10", p(120, 2, 101, 100)},
    84  		{"99", p(120, 2, 119, 119)},
    85  		{"9999", p(120, 4, 119, 119, 119, 119)},
    86  		{"1a", p(120, 1, 101, 5)},
    87  		{"0b", p(120, 0, 6)},
    88  		{"01c", p(120, 1, 101, 8, 2)},
    89  		{"10x", p(120, 2, 101, 100, 200)},
    90  		{"99y", p(120, 2, 119, 119, 201)},
    91  		{"9999nop", p(120, 4, 119, 119, 119, 119, 121)},
    92  
    93  		// Allow follow-up collation elements if they have a zero non-primary.
    94  		{"١٢٩", []Elem{e(120), e(3), e(101), tPlus3, e(102), tPlus3, e(119), tPlus3}},
    95  		{
    96  			"１２９",
    97  			[]Elem{
    98  				e(120), e(3),
    99  				e(101, digSec, digTert+1),
   100  				e(102, digSec, digTert+3),
   101  				e(119, digSec, digTert+1),
   102  			},
   103  		},
   104  
   105  		// Ensure AppendNext* adds to the given buffer.
   106  		{"a10", p(5, 120, 2, 101, 100)},
   107  	} {
   108  		nw := NewNumericWeighter(numWeighter)
   109  
   110  		b := []byte(tt.in)
   111  		got := []Elem(nil)
   112  		for n, sz := 0, 0; n < len(b); {
   113  			got, sz = nw.AppendNext(got, b[n:])
   114  			n += sz
   115  		}
   116  		if !reflect.DeepEqual(got, tt.w) {
   117  			t.Errorf("AppendNext(%q) =\n%v; want\n%v", tt.in, got, tt.w)
   118  		}
   119  
   120  		got = nil
   121  		for n, sz := 0, 0; n < len(tt.in); {
   122  			got, sz = nw.AppendNextString(got, tt.in[n:])
   123  			n += sz
   124  		}
   125  		if !reflect.DeepEqual(got, tt.w) {
   126  			t.Errorf("AppendNextString(%q) =\n%v; want\n%v", tt.in, got, tt.w)
   127  		}
   128  	}
   129  }
   130  
   131  func TestNumericOverflow(t *testing.T) {
   132  	manyDigits := strings.Repeat("9", maxDigits+1) + "a"
   133  
   134  	nw := NewNumericWeighter(numWeighter)
   135  
   136  	got, n := nw.AppendNextString(nil, manyDigits)
   137  
   138  	if n != maxDigits {
   139  		t.Errorf("n: got %d; want %d", n, maxDigits)
   140  	}
   141  
   142  	if got[1].Primary() != maxDigits {
   143  		t.Errorf("primary(e[1]): got %d; want %d", n, maxDigits)
   144  	}
   145  }
   146  
   147  func TestNumericWeighterAlloc(t *testing.T) {
   148  	buf := make([]Elem, 100)
   149  	w := NewNumericWeighter(numWeighter)
   150  	s := "1234567890a"
   151  
   152  	nNormal := testing.AllocsPerRun(3, func() { numWeighter.AppendNextString(buf, s) })
   153  	nNumeric := testing.AllocsPerRun(3, func() { w.AppendNextString(buf, s) })
   154  	if n := nNumeric - nNormal; n > 0 {
   155  		t.Errorf("got %f; want 0", n)
   156  	}
   157  }