mirror of
https://github.com/restic/restic.git
synced 2024-09-08 12:29:39 +02:00
Among others, this updates minio-go, so that the new "eu-west-3" zone for AWS is supported.
179 lines
4.4 KiB
Go
179 lines
4.4 KiB
Go
// Copyright 2016 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 idna
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
|
|
"golang.org/x/text/internal/gen"
|
|
"golang.org/x/text/internal/testtext"
|
|
"golang.org/x/text/internal/ucd"
|
|
)
|
|
|
|
func TestAllocToUnicode(t *testing.T) {
|
|
avg := testtext.AllocsPerRun(1000, func() {
|
|
ToUnicode("www.golang.org")
|
|
})
|
|
if avg > 0 {
|
|
t.Errorf("got %f; want 0", avg)
|
|
}
|
|
}
|
|
|
|
func TestAllocToASCII(t *testing.T) {
|
|
avg := testtext.AllocsPerRun(1000, func() {
|
|
ToASCII("www.golang.org")
|
|
})
|
|
if avg > 0 {
|
|
t.Errorf("got %f; want 0", avg)
|
|
}
|
|
}
|
|
|
|
func TestProfiles(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
want, got *Profile
|
|
}{
|
|
{"Punycode", punycode, New()},
|
|
{"Registration", registration, New(ValidateForRegistration())},
|
|
{"Registration", registration, New(
|
|
ValidateForRegistration(),
|
|
VerifyDNSLength(true),
|
|
BidiRule(),
|
|
)},
|
|
{"Lookup", lookup, New(MapForLookup(), BidiRule(), Transitional(true))},
|
|
{"Display", display, New(MapForLookup(), BidiRule())},
|
|
}
|
|
for _, tc := range testCases {
|
|
// Functions are not comparable, but the printed version will include
|
|
// their pointers.
|
|
got := fmt.Sprintf("%#v", tc.got)
|
|
want := fmt.Sprintf("%#v", tc.want)
|
|
if got != want {
|
|
t.Errorf("%s: \ngot %#v,\nwant %#v", tc.name, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
// doTest performs a single test f(input) and verifies that the output matches
|
|
// out and that the returned error is expected. The errors string contains
|
|
// all allowed error codes as categorized in
|
|
// http://www.unicode.org/Public/idna/9.0.0/IdnaTest.txt:
|
|
// P: Processing
|
|
// V: Validity
|
|
// A: to ASCII
|
|
// B: Bidi
|
|
// C: Context J
|
|
func doTest(t *testing.T, f func(string) (string, error), name, input, want, errors string) {
|
|
errors = strings.Trim(errors, "[]")
|
|
test := "ok"
|
|
if errors != "" {
|
|
test = "err:" + errors
|
|
}
|
|
// Replace some of the escape sequences to make it easier to single out
|
|
// tests on the command name.
|
|
in := strings.Trim(strconv.QuoteToASCII(input), `"`)
|
|
in = strings.Replace(in, `\u`, "#", -1)
|
|
in = strings.Replace(in, `\U`, "#", -1)
|
|
name = fmt.Sprintf("%s/%s/%s", name, in, test)
|
|
|
|
testtext.Run(t, name, func(t *testing.T) {
|
|
got, err := f(input)
|
|
|
|
if err != nil {
|
|
code := err.(interface {
|
|
code() string
|
|
}).code()
|
|
if strings.Index(errors, code) == -1 {
|
|
t.Errorf("error %q not in set of expected errors {%v}", code, errors)
|
|
}
|
|
} else if errors != "" {
|
|
t.Errorf("no errors; want error in {%v}", errors)
|
|
}
|
|
|
|
if want != "" && got != want {
|
|
t.Errorf(`string: got %+q; want %+q`, got, want)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestConformance(t *testing.T) {
|
|
testtext.SkipIfNotLong(t)
|
|
|
|
r := gen.OpenUnicodeFile("idna", "", "IdnaTest.txt")
|
|
defer r.Close()
|
|
|
|
section := "main"
|
|
started := false
|
|
p := ucd.New(r, ucd.CommentHandler(func(s string) {
|
|
if started {
|
|
section = strings.ToLower(strings.Split(s, " ")[0])
|
|
}
|
|
}))
|
|
transitional := New(Transitional(true), VerifyDNSLength(true), BidiRule(), MapForLookup())
|
|
nonTransitional := New(VerifyDNSLength(true), BidiRule(), MapForLookup())
|
|
for p.Next() {
|
|
started = true
|
|
|
|
// What to test
|
|
profiles := []*Profile{}
|
|
switch p.String(0) {
|
|
case "T":
|
|
profiles = append(profiles, transitional)
|
|
case "N":
|
|
profiles = append(profiles, nonTransitional)
|
|
case "B":
|
|
profiles = append(profiles, transitional)
|
|
profiles = append(profiles, nonTransitional)
|
|
}
|
|
|
|
src := unescape(p.String(1))
|
|
|
|
wantToUnicode := unescape(p.String(2))
|
|
if wantToUnicode == "" {
|
|
wantToUnicode = src
|
|
}
|
|
wantToASCII := unescape(p.String(3))
|
|
if wantToASCII == "" {
|
|
wantToASCII = wantToUnicode
|
|
}
|
|
wantErrToUnicode := ""
|
|
if strings.HasPrefix(wantToUnicode, "[") {
|
|
wantErrToUnicode = wantToUnicode
|
|
wantToUnicode = ""
|
|
}
|
|
wantErrToASCII := ""
|
|
if strings.HasPrefix(wantToASCII, "[") {
|
|
wantErrToASCII = wantToASCII
|
|
wantToASCII = ""
|
|
}
|
|
|
|
// TODO: also do IDNA tests.
|
|
// invalidInIDNA2008 := p.String(4) == "NV8"
|
|
|
|
for _, p := range profiles {
|
|
name := fmt.Sprintf("%s:%s", section, p)
|
|
doTest(t, p.ToUnicode, name+":ToUnicode", src, wantToUnicode, wantErrToUnicode)
|
|
doTest(t, p.ToASCII, name+":ToASCII", src, wantToASCII, wantErrToASCII)
|
|
}
|
|
}
|
|
}
|
|
|
|
func unescape(s string) string {
|
|
s, err := strconv.Unquote(`"` + s + `"`)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return s
|
|
}
|
|
|
|
func BenchmarkProfile(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
Lookup.ToASCII("www.yahoogle.com")
|
|
}
|
|
}
|