ires 0.1.3 → 0.1.4

data/ext/vendor/golang.org/x/text/unicode/cldr/resolve_test.go

@@ -0,0 +1,368 @@
+package cldr
+
+import (
+	"fmt"
+	"log"
+	"reflect"
+	"testing"
+)
+
+func failOnError(err error) {
+	if err != nil {
+		log.Panic(err)
+	}
+}
+
+func data() *CLDR {
+	d := Decoder{}
+	data, err := d.Decode(testLoader{})
+	failOnError(err)
+	return data
+}
+
+type h struct {
+	A string `xml:"ha,attr"`
+	E string `xml:"he"`
+	D string `xml:",chardata"`
+	X string
+}
+
+type fieldTest struct {
+	Common
+	To  string `xml:"to,attr"`
+	Key string `xml:"key,attr"`
+	E   string `xml:"e"`
+	D   string `xml:",chardata"`
+	X   string
+	h
+}
+
+var testStruct = fieldTest{
+	Common: Common{
+		name: "mapping", // exclude "type" as distinguishing attribute
+		Type: "foo",
+		Alt:  "foo",
+	},
+	To:  "nyc",
+	Key: "k",
+	E:   "E",
+	D:   "D",
+	h: h{
+		A: "A",
+		E: "E",
+		D: "D",
+	},
+}
+
+func TestIter(t *testing.T) {
+	tests := map[string]string{
+		"Type":  "foo",
+		"Alt":   "foo",
+		"To":    "nyc",
+		"A":     "A",
+		"Alias": "<nil>",
+	}
+	k := 0
+	for i := iter(reflect.ValueOf(testStruct)); !i.done(); i.next() {
+		v := i.value()
+		if v.Kind() == reflect.Ptr && v.Elem().Kind() == reflect.String {
+			v = v.Elem()
+		}
+		name := i.field().Name
+		if w, ok := tests[name]; ok {
+			s := fmt.Sprint(v.Interface())
+			if w != s {
+				t.Errorf("value: found %q; want %q", w, s)
+			}
+			delete(tests, name)
+		}
+		k++
+	}
+	if len(tests) != 0 {
+		t.Errorf("missing fields: %v", tests)
+	}
+}
+
+func TestFindField(t *testing.T) {
+	tests := []struct {
+		name, val string
+		exist     bool
+	}{
+		{"type", "foo", true},
+		{"alt", "foo", true},
+		{"to", "nyc", true},
+		{"he", "E", true},
+		{"q", "", false},
+	}
+	vf := reflect.ValueOf(testStruct)
+	for i, tt := range tests {
+		v, err := findField(vf, tt.name)
+		if (err == nil) != tt.exist {
+			t.Errorf("%d: field %q present is %v; want %v", i, tt.name, err == nil, tt.exist)
+		} else if tt.exist {
+			if v.Kind() == reflect.Ptr {
+				if v.IsNil() {
+					continue
+				}
+				v = v.Elem()
+			}
+			if v.String() != tt.val {
+				t.Errorf("%d: found value %q; want %q", i, v.String(), tt.val)
+			}
+		}
+	}
+}
+
+var keyTests = []struct {
+	exclude []string
+	key     string
+}{
+	{[]string{}, "alt=foo;key=k;to=nyc"},
+	{[]string{"type"}, "alt=foo;key=k;to=nyc"},
+	{[]string{"choice"}, "alt=foo;key=k;to=nyc"},
+	{[]string{"alt"}, "key=k;to=nyc"},
+	{[]string{"a"}, "alt=foo;key=k;to=nyc"},
+	{[]string{"to"}, "alt=foo;key=k"},
+	{[]string{"alt", "to"}, "key=k"},
+	{[]string{"alt", "to", "key"}, ""},
+}
+
+func TestAttrKey(t *testing.T) {
+	v := reflect.ValueOf(&testStruct)
+	for i, tt := range keyTests {
+		key := attrKey(v, tt.exclude...)
+		if key != tt.key {
+			t.Errorf("%d: found %q, want %q", i, key, tt.key)
+		}
+	}
+}
+
+func TestKey(t *testing.T) {
+	for i, tt := range keyTests {
+		key := Key(&testStruct, tt.exclude...)
+		if key != tt.key {
+			t.Errorf("%d: found %q, want %q", i, key, tt.key)
+		}
+	}
+}
+
+func testEnclosing(t *testing.T, x *LDML, name string) {
+	eq := func(a, b Elem, i int) {
+		for ; i > 0; i-- {
+			b = b.enclosing()
+		}
+		if a != b {
+			t.Errorf("%s: found path %q, want %q", name, getPath(a), getPath(b))
+		}
+	}
+	eq(x, x, 0)
+	eq(x, x.Identity, 1)
+	eq(x, x.Dates.Calendars, 2)
+	eq(x, x.Dates.Calendars.Calendar[0], 3)
+	eq(x, x.Dates.Calendars.Calendar[1], 3)
+	//eq(x, x.Dates.Calendars.Calendar[0].Months, 4)
+	eq(x, x.Dates.Calendars.Calendar[1].Months, 4)
+}
+
+func TestEnclosing(t *testing.T) {
+	testEnclosing(t, data().RawLDML("de"), "enclosing-raw")
+	de, _ := data().LDML("de")
+	testEnclosing(t, de, "enclosing")
+}
+
+func TestDeepCopy(t *testing.T) {
+	eq := func(have, want string) {
+		if have != want {
+			t.Errorf("found %q; want %q", have, want)
+		}
+	}
+	x, _ := data().LDML("de")
+	vc := deepCopy(reflect.ValueOf(x))
+	c := vc.Interface().(*LDML)
+	linkEnclosing(nil, c)
+	if x == c {
+		t.Errorf("did not copy")
+	}
+
+	eq(c.name, "ldml")
+	eq(c.Dates.name, "dates")
+	testEnclosing(t, c, "deepCopy")
+}
+
+type getTest struct {
+	loc     string
+	path    string
+	field   string // used in combination with length
+	data    string
+	altData string // used for buddhist calendar if value != ""
+	typ     string
+	length  int
+	missing bool
+}
+
+const (
+	budMon = "dates/calendars/calendar[@type='buddhist']/months/"
+	chnMon = "dates/calendars/calendar[@type='chinese']/months/"
+	greMon = "dates/calendars/calendar[@type='gregorian']/months/"
+)
+
+func monthVal(path, context, width string, month int) string {
+	const format = "%s/monthContext[@type='%s']/monthWidth[@type='%s']/month[@type='%d']"
+	return fmt.Sprintf(format, path, context, width, month)
+}
+
+var rootGetTests = []getTest{
+	{loc: "root", path: "identity/language", typ: "root"},
+	{loc: "root", path: "characters/moreInformation", data: "?"},
+	{loc: "root", path: "characters", field: "exemplarCharacters", length: 3},
+	{loc: "root", path: greMon, field: "monthContext", length: 2},
+	{loc: "root", path: greMon + "monthContext[@type='format']/monthWidth[@type='narrow']", field: "month", length: 4},
+	{loc: "root", path: greMon + "monthContext[@type='stand-alone']/monthWidth[@type='wide']", field: "month", length: 4},
+	// unescaping character data
+	{loc: "root", path: "characters/exemplarCharacters[@type='punctuation']", data: `[\- ‐ – — … ' ‘ ‚ " “ „ \& #]`},
+	// default resolution
+	{loc: "root", path: "dates/calendars/calendar", typ: "gregorian"},
+	// alias resolution
+	{loc: "root", path: budMon, field: "monthContext", length: 2},
+	// crossing but non-circular alias resolution
+	{loc: "root", path: budMon + "monthContext[@type='format']/monthWidth[@type='narrow']", field: "month", length: 4},
+	{loc: "root", path: budMon + "monthContext[@type='stand-alone']/monthWidth[@type='wide']", field: "month", length: 4},
+	{loc: "root", path: monthVal(greMon, "format", "wide", 1), data: "11"},
+	{loc: "root", path: monthVal(greMon, "format", "narrow", 2), data: "2"},
+	{loc: "root", path: monthVal(greMon, "stand-alone", "wide", 3), data: "33"},
+	{loc: "root", path: monthVal(greMon, "stand-alone", "narrow", 4), data: "4"},
+	{loc: "root", path: monthVal(budMon, "format", "wide", 1), data: "11"},
+	{loc: "root", path: monthVal(budMon, "format", "narrow", 2), data: "2"},
+	{loc: "root", path: monthVal(budMon, "stand-alone", "wide", 3), data: "33"},
+	{loc: "root", path: monthVal(budMon, "stand-alone", "narrow", 4), data: "4"},
+}
+
+// 19
+var deGetTests = []getTest{
+	{loc: "de", path: "identity/language", typ: "de"},
+	{loc: "de", path: "posix", length: 2},
+	{loc: "de", path: "characters", field: "exemplarCharacters", length: 4},
+	{loc: "de", path: "characters/exemplarCharacters[@type='auxiliary']", data: `[á à ă]`},
+	// identity is a blocking element, so de should not inherit generation from root.
+	{loc: "de", path: "identity/generation", missing: true},
+	// default resolution
+	{loc: "root", path: "dates/calendars/calendar", typ: "gregorian"},
+
+	// absolute path alias resolution
+	{loc: "gsw", path: "posix", field: "messages", length: 1},
+	{loc: "gsw", path: "posix/messages/yesstr", data: "yes:y"},
+}
+
+// 27(greMon) - 52(budMon) - 77(chnMon)
+func calGetTests(s string) []getTest {
+	tests := []getTest{
+		{loc: "de", path: s, length: 2},
+		{loc: "de", path: s + "monthContext[@type='format']/monthWidth[@type='wide']", field: "month", length: 5},
+		{loc: "de", path: monthVal(s, "format", "wide", 1), data: "11"},
+		{loc: "de", path: monthVal(s, "format", "wide", 2), data: "22"},
+		{loc: "de", path: monthVal(s, "format", "wide", 3), data: "Maerz", altData: "bbb"},
+		{loc: "de", path: monthVal(s, "format", "wide", 4), data: "April"},
+		{loc: "de", path: monthVal(s, "format", "wide", 5), data: "Mai"},
+
+		{loc: "de", path: s + "monthContext[@type='format']/monthWidth[@type='narrow']", field: "month", length: 5},
+		{loc: "de", path: monthVal(s, "format", "narrow", 1), data: "1"},
+		{loc: "de", path: monthVal(s, "format", "narrow", 2), data: "2"},
+		{loc: "de", path: monthVal(s, "format", "narrow", 3), data: "M", altData: "BBB"},
+		{loc: "de", path: monthVal(s, "format", "narrow", 4), data: "A"},
+		{loc: "de", path: monthVal(s, "format", "narrow", 5), data: "m"},
+
+		{loc: "de", path: s + "monthContext[@type='stand-alone']/monthWidth[@type='wide']", field: "month", length: 5},
+		{loc: "de", path: monthVal(s, "stand-alone", "wide", 1), data: "11"},
+		{loc: "de", path: monthVal(s, "stand-alone", "wide", 2), data: "22"},
+		{loc: "de", path: monthVal(s, "stand-alone", "wide", 3), data: "Maerz", altData: "bbb"},
+		{loc: "de", path: monthVal(s, "stand-alone", "wide", 4), data: "april"},
+		{loc: "de", path: monthVal(s, "stand-alone", "wide", 5), data: "mai"},
+
+		{loc: "de", path: s + "monthContext[@type='stand-alone']/monthWidth[@type='narrow']", field: "month", length: 5},
+		{loc: "de", path: monthVal(s, "stand-alone", "narrow", 1), data: "1"},
+		{loc: "de", path: monthVal(s, "stand-alone", "narrow", 2), data: "2"},
+		{loc: "de", path: monthVal(s, "stand-alone", "narrow", 3), data: "m"},
+		{loc: "de", path: monthVal(s, "stand-alone", "narrow", 4), data: "4"},
+		{loc: "de", path: monthVal(s, "stand-alone", "narrow", 5), data: "m"},
+	}
+	if s == budMon {
+		for i, t := range tests {
+			if t.altData != "" {
+				tests[i].data = t.altData
+			}
+		}
+	}
+	return tests
+}
+
+var getTests = append(rootGetTests,
+	append(deGetTests,
+		append(calGetTests(greMon),
+			append(calGetTests(budMon),
+				calGetTests(chnMon)...)...)...)...)
+
+func TestPath(t *testing.T) {
+	d := data()
+	for i, tt := range getTests {
+		x, _ := d.LDML(tt.loc)
+		e, err := walkXPath(x, tt.path)
+		if err != nil {
+			if !tt.missing {
+				t.Errorf("%d:error: %v %v", i, err, tt.missing)
+			}
+			continue
+		}
+		if tt.missing {
+			t.Errorf("%d: missing is %v; want %v", i, e == nil, tt.missing)
+			continue
+		}
+		if tt.data != "" && e.GetCommon().Data() != tt.data {
+			t.Errorf("%d: data is %v; want %v", i, e.GetCommon().Data(), tt.data)
+			continue
+		}
+		if tt.typ != "" && e.GetCommon().Type != tt.typ {
+			t.Errorf("%d: type is %v; want %v", i, e.GetCommon().Type, tt.typ)
+			continue
+		}
+		if tt.field != "" {
+			slice, _ := findField(reflect.ValueOf(e), tt.field)
+			if slice.Len() != tt.length {
+				t.Errorf("%d: length is %v; want %v", i, slice.Len(), tt.length)
+				continue
+			}
+		}
+	}
+}
+
+func TestGet(t *testing.T) {
+	d := data()
+	for i, tt := range getTests {
+		x, _ := d.LDML(tt.loc)
+		e, err := Get(x, tt.path)
+		if err != nil {
+			if !tt.missing {
+				t.Errorf("%d:error: %v %v", i, err, tt.missing)
+			}
+			continue
+		}
+		if tt.missing {
+			t.Errorf("%d: missing is %v; want %v", i, e == nil, tt.missing)
+			continue
+		}
+		if tt.data != "" && e.GetCommon().Data() != tt.data {
+			t.Errorf("%d: data is %v; want %v", i, e.GetCommon().Data(), tt.data)
+			continue
+		}
+		if tt.typ != "" && e.GetCommon().Type != tt.typ {
+			t.Errorf("%d: type is %v; want %v", i, e.GetCommon().Type, tt.typ)
+			continue
+		}
+		if tt.field != "" {
+			slice, _ := findField(reflect.ValueOf(e), tt.field)
+			if slice.Len() != tt.length {
+				t.Errorf("%d: length is %v; want %v", i, slice.Len(), tt.length)
+				continue
+			}
+		}
+	}
+}

data/ext/vendor/golang.org/x/text/unicode/cldr/slice.go

@@ -0,0 +1,144 @@
+// Copyright 2013 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 cldr
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+)
+
+// Slice provides utilities for modifying slices of elements.
+// It can be wrapped around any slice of which the element type implements
+// interface Elem.
+type Slice struct {
+	ptr reflect.Value
+	typ reflect.Type
+}
+
+// Value returns the reflect.Value of the underlying slice.
+func (s *Slice) Value() reflect.Value {
+	return s.ptr.Elem()
+}
+
+// MakeSlice wraps a pointer to a slice of Elems.
+// It replaces the array pointed to by the slice so that subsequent modifications
+// do not alter the data in a CLDR type.
+// It panics if an incorrect type is passed.
+func MakeSlice(slicePtr interface{}) Slice {
+	ptr := reflect.ValueOf(slicePtr)
+	if ptr.Kind() != reflect.Ptr {
+		panic(fmt.Sprintf("MakeSlice: argument must be pointer to slice, found %v", ptr.Type()))
+	}
+	sl := ptr.Elem()
+	if sl.Kind() != reflect.Slice {
+		panic(fmt.Sprintf("MakeSlice: argument must point to a slice, found %v", sl.Type()))
+	}
+	intf := reflect.TypeOf((*Elem)(nil)).Elem()
+	if !sl.Type().Elem().Implements(intf) {
+		panic(fmt.Sprintf("MakeSlice: element type of slice (%v) does not implement Elem", sl.Type().Elem()))
+	}
+	nsl := reflect.MakeSlice(sl.Type(), sl.Len(), sl.Len())
+	reflect.Copy(nsl, sl)
+	sl.Set(nsl)
+	return Slice{
+		ptr: ptr,
+		typ: sl.Type().Elem().Elem(),
+	}
+}
+
+func (s Slice) indexForAttr(a string) []int {
+	for i := iter(reflect.Zero(s.typ)); !i.done(); i.next() {
+		if n, _ := xmlName(i.field()); n == a {
+			return i.index
+		}
+	}
+	panic(fmt.Sprintf("MakeSlice: no attribute %q for type %v", a, s.typ))
+}
+
+// Filter filters s to only include elements for which fn returns true.
+func (s Slice) Filter(fn func(e Elem) bool) {
+	k := 0
+	sl := s.Value()
+	for i := 0; i < sl.Len(); i++ {
+		vi := sl.Index(i)
+		if fn(vi.Interface().(Elem)) {
+			sl.Index(k).Set(vi)
+			k++
+		}
+	}
+	sl.Set(sl.Slice(0, k))
+}
+
+// Group finds elements in s for which fn returns the same value and groups
+// them in a new Slice.
+func (s Slice) Group(fn func(e Elem) string) []Slice {
+	m := make(map[string][]reflect.Value)
+	sl := s.Value()
+	for i := 0; i < sl.Len(); i++ {
+		vi := sl.Index(i)
+		key := fn(vi.Interface().(Elem))
+		m[key] = append(m[key], vi)
+	}
+	keys := []string{}
+	for k, _ := range m {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	res := []Slice{}
+	for _, k := range keys {
+		nsl := reflect.New(sl.Type())
+		nsl.Elem().Set(reflect.Append(nsl.Elem(), m[k]...))
+		res = append(res, MakeSlice(nsl.Interface()))
+	}
+	return res
+}
+
+// SelectAnyOf filters s to contain only elements for which attr matches
+// any of the values.
+func (s Slice) SelectAnyOf(attr string, values ...string) {
+	index := s.indexForAttr(attr)
+	s.Filter(func(e Elem) bool {
+		vf := reflect.ValueOf(e).Elem().FieldByIndex(index)
+		return in(values, vf.String())
+	})
+}
+
+// SelectOnePerGroup filters s to include at most one element e per group of
+// elements matching Key(attr), where e has an attribute a that matches any
+// the values in v.
+// If more than one element in a group matches a value in v preference
+// is given to the element that matches the first value in v.
+func (s Slice) SelectOnePerGroup(a string, v []string) {
+	index := s.indexForAttr(a)
+	grouped := s.Group(func(e Elem) string { return Key(e, a) })
+	sl := s.Value()
+	sl.Set(sl.Slice(0, 0))
+	for _, g := range grouped {
+		e := reflect.Value{}
+		found := len(v)
+		gsl := g.Value()
+		for i := 0; i < gsl.Len(); i++ {
+			vi := gsl.Index(i).Elem().FieldByIndex(index)
+			j := 0
+			for ; j < len(v) && v[j] != vi.String(); j++ {
+			}
+			if j < found {
+				found = j
+				e = gsl.Index(i)
+			}
+		}
+		if found < len(v) {
+			sl.Set(reflect.Append(sl, e))
+		}
+	}
+}
+
+// SelectDraft drops all elements from the list with a draft level smaller than d
+// and selects the highest draft level of the remaining.
+// This method assumes that the input CLDR is canonicalized.
+func (s Slice) SelectDraft(d Draft) {
+	s.SelectOnePerGroup("draft", drafts[len(drafts)-2-int(d):])
+}