← Back to branch summary

~ubuntu-branches/ubuntu/vivid/juju-core/vivid-updates

« back to all changes in this revision

Viewing changes to src/golang.org/x/net/html/atom/atom_test.go

  • Committer: Package Import Robot
  • Author(s): Curtis C. Hovey
  • Date: 2015-09-29 19:43:29 UTC
  • mfrom: (47.1.4 wily-proposed)
  • Revision ID: package-import@ubuntu.com-20150929194329-9y496tbic30hc7vp
Tags: 1.24.6-0ubuntu1~15.04.1
https://launchpad.net/bugs/1500916
https://launchpad.net/bugs/1497087
Backport of 1.24.6 from wily. (LP: #1500916, #1497087)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/golang.org/x/net/html/atom/atom_test.go
 
1
// Copyright 2012 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 atom
 
6
 
 
7
import (
 
8
        "sort"
 
9
        "testing"
 
10
)
 
11
 
 
12
func TestKnown(t *testing.T) {
 
13
        for _, s := range testAtomList {
 
14
                if atom := Lookup([]byte(s)); atom.String() != s {
 
15
                        t.Errorf("Lookup(%q) = %#x (%q)", s, uint32(atom), atom.String())
 
16
                }
 
17
        }
 
18
}
 
19
 
 
20
func TestHits(t *testing.T) {
 
21
        for _, a := range table {
 
22
                if a == 0 {
 
23
                        continue
 
24
                }
 
25
                got := Lookup([]byte(a.String()))
 
26
                if got != a {
 
27
                        t.Errorf("Lookup(%q) = %#x, want %#x", a.String(), uint32(got), uint32(a))
 
28
                }
 
29
        }
 
30
}
 
31
 
 
32
func TestMisses(t *testing.T) {
 
33
        testCases := []string{
 
34
                "",
 
35
                "\x00",
 
36
                "\xff",
 
37
                "A",
 
38
                "DIV",
 
39
                "Div",
 
40
                "dIV",
 
41
                "aa",
 
42
                "a\x00",
 
43
                "ab",
 
44
                "abb",
 
45
                "abbr0",
 
46
                "abbr ",
 
47
                " abbr",
 
48
                " a",
 
49
                "acceptcharset",
 
50
                "acceptCharset",
 
51
                "accept_charset",
 
52
                "h0",
 
53
                "h1h2",
 
54
                "h7",
 
55
                "onClick",
 
56
                "λ",
 
57
                // The following string has the same hash (0xa1d7fab7) as "onmouseover".
 
58
                "\x00\x00\x00\x00\x00\x50\x18\xae\x38\xd0\xb7",
 
59
        }
 
60
        for _, tc := range testCases {
 
61
                got := Lookup([]byte(tc))
 
62
                if got != 0 {
 
63
                        t.Errorf("Lookup(%q): got %d, want 0", tc, got)
 
64
                }
 
65
        }
 
66
}
 
67
 
 
68
func TestForeignObject(t *testing.T) {
 
69
        const (
 
70
                afo = Foreignobject
 
71
                afO = ForeignObject
 
72
                sfo = "foreignobject"
 
73
                sfO = "foreignObject"
 
74
        )
 
75
        if got := Lookup([]byte(sfo)); got != afo {
 
76
                t.Errorf("Lookup(%q): got %#v, want %#v", sfo, got, afo)
 
77
        }
 
78
        if got := Lookup([]byte(sfO)); got != afO {
 
79
                t.Errorf("Lookup(%q): got %#v, want %#v", sfO, got, afO)
 
80
        }
 
81
        if got := afo.String(); got != sfo {
 
82
                t.Errorf("Atom(%#v).String(): got %q, want %q", afo, got, sfo)
 
83
        }
 
84
        if got := afO.String(); got != sfO {
 
85
                t.Errorf("Atom(%#v).String(): got %q, want %q", afO, got, sfO)
 
86
        }
 
87
}
 
88
 
 
89
func BenchmarkLookup(b *testing.B) {
 
90
        sortedTable := make([]string, 0, len(table))
 
91
        for _, a := range table {
 
92
                if a != 0 {
 
93
                        sortedTable = append(sortedTable, a.String())
 
94
                }
 
95
        }
 
96
        sort.Strings(sortedTable)
 
97
 
 
98
        x := make([][]byte, 1000)
 
99
        for i := range x {
 
100
                x[i] = []byte(sortedTable[i%len(sortedTable)])
 
101
        }
 
102
 
 
103
        b.ResetTimer()
 
104
        for i := 0; i < b.N; i++ {
 
105
                for _, s := range x {
 
106
                        Lookup(s)
 
107
                }
 
108
        }
 
109
}