libgo/go/strconv/strconv_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 strconv_test
   6
   7 import (
   8         "runtime"
   9         . "strconv"
  10         "strings"
  11         "testing"
  12 )
  13
  14 var (
  15         globalBuf [64]byte
  16         nextToOne = "1.00000000000000011102230246251565404236316680908203125" + strings.Repeat("0", 10000) + "1"
  17
  18         mallocTest = []struct {
  19                 count int
  20                 desc  string
  21                 fn    func()
  22         }{
  23                 {0, `AppendInt(localBuf[:0], 123, 10)`, func() {
  24                         var localBuf [64]byte
  25                         AppendInt(localBuf[:0], 123, 10)
  26                 }},
  27                 {0, `AppendInt(globalBuf[:0], 123, 10)`, func() { AppendInt(globalBuf[:0], 123, 10) }},
  28                 {0, `AppendFloat(localBuf[:0], 1.23, 'g', 5, 64)`, func() {
  29                         var localBuf [64]byte
  30                         AppendFloat(localBuf[:0], 1.23, 'g', 5, 64)
  31                 }},
  32                 {0, `AppendFloat(globalBuf[:0], 1.23, 'g', 5, 64)`, func() { AppendFloat(globalBuf[:0], 1.23, 'g', 5, 64) }},
  33                 {0, `ParseFloat("123.45", 64)`, func() { ParseFloat("123.45", 64) }},
  34                 {0, `ParseFloat("123.456789123456789", 64)`, func() { ParseFloat("123.456789123456789", 64) }},
  35                 {0, `ParseFloat("1.000000000000000111022302462515654042363166809082031251", 64)`, func() {
  36                         ParseFloat("1.000000000000000111022302462515654042363166809082031251", 64)
  37                 }},
  38                 {0, `ParseFloat("1.0000000000000001110223024625156540423631668090820312500...001", 64)`, func() {
  39                         ParseFloat(nextToOne, 64)
  40                 }},
  41         }
  42 )
  43
  44 func TestCountMallocs(t *testing.T) {
  45         if runtime.Compiler == "gccgo" {
  46                 t.Skip("skipping on gccgo until escape analysis is turned on")
  47         }
  48         if testing.Short() {
  49                 t.Skip("skipping malloc count in short mode")
  50         }
  51         if runtime.GOMAXPROCS(0) > 1 {
  52                 t.Skip("skipping; GOMAXPROCS>1")
  53         }
  54         for _, mt := range mallocTest {
  55                 allocs := testing.AllocsPerRun(100, mt.fn)
  56                 if max := float64(mt.count); allocs > max {
  57                         t.Errorf("%s: %v allocs, want <=%v", mt.desc, allocs, max)
  58                 }
  59         }
  60 }
  61
  62 func TestErrorPrefixes(t *testing.T) {
  63         _, errInt := Atoi("INVALID")
  64         _, errBool := ParseBool("INVALID")
  65         _, errFloat := ParseFloat("INVALID", 64)
  66         _, errInt64 := ParseInt("INVALID", 10, 64)
  67         _, errUint64 := ParseUint("INVALID", 10, 64)
  68
  69         vectors := []struct {
  70                 err  error  // Input error
  71                 want string // Function name wanted
  72         }{
  73                 {errInt, "Atoi"},
  74                 {errBool, "ParseBool"},
  75                 {errFloat, "ParseFloat"},
  76                 {errInt64, "ParseInt"},
  77                 {errUint64, "ParseUint"},
  78         }
  79
  80         for _, v := range vectors {
  81                 nerr, ok := v.err.(*NumError)
  82                 if !ok {
  83                         t.Errorf("test %s, error was not a *NumError", v.want)
  84                         continue
  85                 }
  86                 if got := nerr.Func; got != v.want {
  87                         t.Errorf("mismatching Func: got %s, want %s", got, v.want)
  88                 }
  89         }
  90
  91 }