libgo/go/strconv/quote_test.go

   1 // Copyright 2009 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 strconv_test
   6
   7 import (
   8         . "strconv"
   9         "testing"
  10         "unicode"
  11 )
  12
  13 // Verify that our IsPrint agrees with unicode.IsPrint.
  14 func TestIsPrint(t *testing.T) {
  15         n := 0
  16         for r := rune(0); r <= unicode.MaxRune; r++ {
  17                 if IsPrint(r) != unicode.IsPrint(r) {
  18                         t.Errorf("IsPrint(%U)=%t incorrect", r, IsPrint(r))
  19                         n++
  20                         if n > 10 {
  21                                 return
  22                         }
  23                 }
  24         }
  25 }
  26
  27 // Verify that our IsGraphic agrees with unicode.IsGraphic.
  28 func TestIsGraphic(t *testing.T) {
  29         n := 0
  30         for r := rune(0); r <= unicode.MaxRune; r++ {
  31                 if IsGraphic(r) != unicode.IsGraphic(r) {
  32                         t.Errorf("IsGraphic(%U)=%t incorrect", r, IsGraphic(r))
  33                         n++
  34                         if n > 10 {
  35                                 return
  36                         }
  37                 }
  38         }
  39 }
  40
  41 type quoteTest struct {
  42         in      string
  43         out     string
  44         ascii   string
  45         graphic string
  46 }
  47
  48 var quotetests = []quoteTest{
  49         {"\a\b\f\r\n\t\v", `"\a\b\f\r\n\t\v"`, `"\a\b\f\r\n\t\v"`, `"\a\b\f\r\n\t\v"`},
  50         {"\\", `"\\"`, `"\\"`, `"\\"`},
  51         {"abc\xffdef", `"abc\xffdef"`, `"abc\xffdef"`, `"abc\xffdef"`},
  52         {"\u263a", `"☺"`, `"\u263a"`, `"☺"`},
  53         {"\U0010ffff", `"\U0010ffff"`, `"\U0010ffff"`, `"\U0010ffff"`},
  54         {"\x04", `"\x04"`, `"\x04"`, `"\x04"`},
  55         // Some non-printable but graphic runes. Final column is double-quoted.
  56         {"!\u00a0!\u2000!\u3000!", `"!\u00a0!\u2000!\u3000!"`, `"!\u00a0!\u2000!\u3000!"`, "\"!\u00a0!\u2000!\u3000!\""},
  57 }
  58
  59 func TestQuote(t *testing.T) {
  60         for _, tt := range quotetests {
  61                 if out := Quote(tt.in); out != tt.out {
  62                         t.Errorf("Quote(%s) = %s, want %s", tt.in, out, tt.out)
  63                 }
  64                 if out := AppendQuote([]byte("abc"), tt.in); string(out) != "abc"+tt.out {
  65                         t.Errorf("AppendQuote(%q, %s) = %s, want %s", "abc", tt.in, out, "abc"+tt.out)
  66                 }
  67         }
  68 }
  69
  70 func TestQuoteToASCII(t *testing.T) {
  71         for _, tt := range quotetests {
  72                 if out := QuoteToASCII(tt.in); out != tt.ascii {
  73                         t.Errorf("QuoteToASCII(%s) = %s, want %s", tt.in, out, tt.ascii)
  74                 }
  75                 if out := AppendQuoteToASCII([]byte("abc"), tt.in); string(out) != "abc"+tt.ascii {
  76                         t.Errorf("AppendQuoteToASCII(%q, %s) = %s, want %s", "abc", tt.in, out, "abc"+tt.ascii)
  77                 }
  78         }
  79 }
  80
  81 func TestQuoteToGraphic(t *testing.T) {
  82         for _, tt := range quotetests {
  83                 if out := QuoteToGraphic(tt.in); out != tt.graphic {
  84                         t.Errorf("QuoteToGraphic(%s) = %s, want %s", tt.in, out, tt.graphic)
  85                 }
  86                 if out := AppendQuoteToGraphic([]byte("abc"), tt.in); string(out) != "abc"+tt.graphic {
  87                         t.Errorf("AppendQuoteToGraphic(%q, %s) = %s, want %s", "abc", tt.in, out, "abc"+tt.graphic)
  88                 }
  89         }
  90 }
  91
  92 func BenchmarkQuote(b *testing.B) {
  93         for i := 0; i < b.N; i++ {
  94                 Quote("\a\b\f\r\n\t\v\a\b\f\r\n\t\v\a\b\f\r\n\t\v")
  95         }
  96 }
  97
  98 func BenchmarkQuoteRune(b *testing.B) {
  99         for i := 0; i < b.N; i++ {
 100                 QuoteRune('\a')
 101         }
 102 }
 103
 104 var benchQuoteBuf []byte
 105
 106 func BenchmarkAppendQuote(b *testing.B) {
 107         for i := 0; i < b.N; i++ {
 108                 benchQuoteBuf = AppendQuote(benchQuoteBuf[:0], "\a\b\f\r\n\t\v\a\b\f\r\n\t\v\a\b\f\r\n\t\v")
 109         }
 110 }
 111
 112 var benchQuoteRuneBuf []byte
 113
 114 func BenchmarkAppendQuoteRune(b *testing.B) {
 115         for i := 0; i < b.N; i++ {
 116                 benchQuoteRuneBuf = AppendQuoteRune(benchQuoteRuneBuf[:0], '\a')
 117         }
 118 }
 119
 120 type quoteRuneTest struct {
 121         in      rune
 122         out     string
 123         ascii   string
 124         graphic string
 125 }
 126
 127 var quoterunetests = []quoteRuneTest{
 128         {'a', `'a'`, `'a'`, `'a'`},
 129         {'\a', `'\a'`, `'\a'`, `'\a'`},
 130         {'\\', `'\\'`, `'\\'`, `'\\'`},
 131         {0xFF, `'ÿ'`, `'\u00ff'`, `'ÿ'`},
 132         {0x263a, `'☺'`, `'\u263a'`, `'☺'`},
 133         {0xfffd, `'�'`, `'\ufffd'`, `'�'`},
 134         {0x0010ffff, `'\U0010ffff'`, `'\U0010ffff'`, `'\U0010ffff'`},
 135         {0x0010ffff + 1, `'�'`, `'\ufffd'`, `'�'`},
 136         {0x04, `'\x04'`, `'\x04'`, `'\x04'`},
 137         // Some differences between graphic and printable. Note the last column is double-quoted.
 138         {'\u00a0', `'\u00a0'`, `'\u00a0'`, "'\u00a0'"},
 139         {'\u2000', `'\u2000'`, `'\u2000'`, "'\u2000'"},
 140         {'\u3000', `'\u3000'`, `'\u3000'`, "'\u3000'"},
 141 }
 142
 143 func TestQuoteRune(t *testing.T) {
 144         for _, tt := range quoterunetests {
 145                 if out := QuoteRune(tt.in); out != tt.out {
 146                         t.Errorf("QuoteRune(%U) = %s, want %s", tt.in, out, tt.out)
 147                 }
 148                 if out := AppendQuoteRune([]byte("abc"), tt.in); string(out) != "abc"+tt.out {
 149                         t.Errorf("AppendQuoteRune(%q, %U) = %s, want %s", "abc", tt.in, out, "abc"+tt.out)
 150                 }
 151         }
 152 }
 153
 154 func TestQuoteRuneToASCII(t *testing.T) {
 155         for _, tt := range quoterunetests {
 156                 if out := QuoteRuneToASCII(tt.in); out != tt.ascii {
 157                         t.Errorf("QuoteRuneToASCII(%U) = %s, want %s", tt.in, out, tt.ascii)
 158                 }
 159                 if out := AppendQuoteRuneToASCII([]byte("abc"), tt.in); string(out) != "abc"+tt.ascii {
 160                         t.Errorf("AppendQuoteRuneToASCII(%q, %U) = %s, want %s", "abc", tt.in, out, "abc"+tt.ascii)
 161                 }
 162         }
 163 }
 164
 165 func TestQuoteRuneToGraphic(t *testing.T) {
 166         for _, tt := range quoterunetests {
 167                 if out := QuoteRuneToGraphic(tt.in); out != tt.graphic {
 168                         t.Errorf("QuoteRuneToGraphic(%U) = %s, want %s", tt.in, out, tt.graphic)
 169                 }
 170                 if out := AppendQuoteRuneToGraphic([]byte("abc"), tt.in); string(out) != "abc"+tt.graphic {
 171                         t.Errorf("AppendQuoteRuneToGraphic(%q, %U) = %s, want %s", "abc", tt.in, out, "abc"+tt.graphic)
 172                 }
 173         }
 174 }
 175
 176 type canBackquoteTest struct {
 177         in  string
 178         out bool
 179 }
 180
 181 var canbackquotetests = []canBackquoteTest{
 182         {"`", false},
 183         {string(0), false},
 184         {string(1), false},
 185         {string(2), false},
 186         {string(3), false},
 187         {string(4), false},
 188         {string(5), false},
 189         {string(6), false},
 190         {string(7), false},
 191         {string(8), false},
 192         {string(9), true}, // \t
 193         {string(10), false},
 194         {string(11), false},
 195         {string(12), false},
 196         {string(13), false},
 197         {string(14), false},
 198         {string(15), false},
 199         {string(16), false},
 200         {string(17), false},
 201         {string(18), false},
 202         {string(19), false},
 203         {string(20), false},
 204         {string(21), false},
 205         {string(22), false},
 206         {string(23), false},
 207         {string(24), false},
 208         {string(25), false},
 209         {string(26), false},
 210         {string(27), false},
 211         {string(28), false},
 212         {string(29), false},
 213         {string(30), false},
 214         {string(31), false},
 215         {string(0x7F), false},
 216         {`' !"#$%&'()*+,-./:;<=>?@[\]^_{|}~`, true},
 217         {`0123456789`, true},
 218         {`ABCDEFGHIJKLMNOPQRSTUVWXYZ`, true},
 219         {`abcdefghijklmnopqrstuvwxyz`, true},
 220         {`☺`, true},
 221         {"\x80", false},
 222         {"a\xe0\xa0z", false},
 223         {"\ufeffabc", false},
 224         {"a\ufeffz", false},
 225 }
 226
 227 func TestCanBackquote(t *testing.T) {
 228         for _, tt := range canbackquotetests {
 229                 if out := CanBackquote(tt.in); out != tt.out {
 230                         t.Errorf("CanBackquote(%q) = %v, want %v", tt.in, out, tt.out)
 231                 }
 232         }
 233 }
 234
 235 type unQuoteTest struct {
 236         in  string
 237         out string
 238 }
 239
 240 var unquotetests = []unQuoteTest{
 241         {`""`, ""},
 242         {`"a"`, "a"},
 243         {`"abc"`, "abc"},
 244         {`"☺"`, "☺"},
 245         {`"hello world"`, "hello world"},
 246         {`"\xFF"`, "\xFF"},
 247         {`"\377"`, "\377"},
 248         {`"\u1234"`, "\u1234"},
 249         {`"\U00010111"`, "\U00010111"},
 250         {`"\U0001011111"`, "\U0001011111"},
 251         {`"\a\b\f\n\r\t\v\\\""`, "\a\b\f\n\r\t\v\\\""},
 252         {`"'"`, "'"},
 253
 254         {`'a'`, "a"},
 255         {`'☹'`, "☹"},
 256         {`'\a'`, "\a"},
 257         {`'\x10'`, "\x10"},
 258         {`'\377'`, "\377"},
 259         {`'\u1234'`, "\u1234"},
 260         {`'\U00010111'`, "\U00010111"},
 261         {`'\t'`, "\t"},
 262         {`' '`, " "},
 263         {`'\''`, "'"},
 264         {`'"'`, "\""},
 265
 266         {"``", ``},
 267         {"`a`", `a`},
 268         {"`abc`", `abc`},
 269         {"`☺`", `☺`},
 270         {"`hello world`", `hello world`},
 271         {"`\\xFF`", `\xFF`},
 272         {"`\\377`", `\377`},
 273         {"`\\`", `\`},
 274         {"`\n`", "\n"},
 275         {"`     `", `   `},
 276         {"` `", ` `},
 277         {"`a\rb`", "ab"},
 278 }
 279
 280 var misquoted = []string{
 281         ``,
 282         `"`,
 283         `"a`,
 284         `"'`,
 285         `b"`,
 286         `"\"`,
 287         `"\9"`,
 288         `"\19"`,
 289         `"\129"`,
 290         `'\'`,
 291         `'\9'`,
 292         `'\19'`,
 293         `'\129'`,
 294         `'ab'`,
 295         `"\x1!"`,
 296         `"\U12345678"`,
 297         `"\z"`,
 298         "`",
 299         "`xxx",
 300         "`\"",
 301         `"\'"`,
 302         `'\"'`,
 303         "\"\n\"",
 304         "\"\\n\n\"",
 305         "'\n'",
 306 }
 307
 308 func TestUnquote(t *testing.T) {
 309         for _, tt := range unquotetests {
 310                 if out, err := Unquote(tt.in); err != nil || out != tt.out {
 311                         t.Errorf("Unquote(%#q) = %q, %v want %q, nil", tt.in, out, err, tt.out)
 312                 }
 313         }
 314
 315         // run the quote tests too, backward
 316         for _, tt := range quotetests {
 317                 if in, err := Unquote(tt.out); in != tt.in {
 318                         t.Errorf("Unquote(%#q) = %q, %v, want %q, nil", tt.out, in, err, tt.in)
 319                 }
 320         }
 321
 322         for _, s := range misquoted {
 323                 if out, err := Unquote(s); out != "" || err != ErrSyntax {
 324                         t.Errorf("Unquote(%#q) = %q, %v want %q, %v", s, out, err, "", ErrSyntax)
 325                 }
 326         }
 327 }
 328
 329 func BenchmarkUnquoteEasy(b *testing.B) {
 330         for i := 0; i < b.N; i++ {
 331                 Unquote(`"Give me a rock, paper and scissors and I will move the world."`)
 332         }
 333 }
 334
 335 func BenchmarkUnquoteHard(b *testing.B) {
 336         for i := 0; i < b.N; i++ {
 337                 Unquote(`"\x47ive me a \x72ock, \x70aper and \x73cissors and \x49 will move the world."`)
 338         }
 339 }