summaryrefslogtreecommitdiff
path: root/src/pkg/go/scanner/scanner_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/go/scanner/scanner_test.go')
-rw-r--r--src/pkg/go/scanner/scanner_test.go775
1 files changed, 0 insertions, 775 deletions
diff --git a/src/pkg/go/scanner/scanner_test.go b/src/pkg/go/scanner/scanner_test.go
deleted file mode 100644
index fc450d8a6..000000000
--- a/src/pkg/go/scanner/scanner_test.go
+++ /dev/null
@@ -1,775 +0,0 @@
-// Copyright 2009 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 scanner
-
-import (
- "go/token"
- "io/ioutil"
- "os"
- "path/filepath"
- "runtime"
- "testing"
-)
-
-var fset = token.NewFileSet()
-
-const /* class */ (
- special = iota
- literal
- operator
- keyword
-)
-
-func tokenclass(tok token.Token) int {
- switch {
- case tok.IsLiteral():
- return literal
- case tok.IsOperator():
- return operator
- case tok.IsKeyword():
- return keyword
- }
- return special
-}
-
-type elt struct {
- tok token.Token
- lit string
- class int
-}
-
-var tokens = [...]elt{
- // Special tokens
- {token.COMMENT, "/* a comment */", special},
- {token.COMMENT, "// a comment \n", special},
- {token.COMMENT, "/*\r*/", special},
- {token.COMMENT, "//\r\n", special},
-
- // Identifiers and basic type literals
- {token.IDENT, "foobar", literal},
- {token.IDENT, "a۰۱۸", literal},
- {token.IDENT, "foo६४", literal},
- {token.IDENT, "bar９８７６", literal},
- {token.IDENT, "ŝ", literal}, // was bug (issue 4000)
- {token.IDENT, "ŝfoo", literal}, // was bug (issue 4000)
- {token.INT, "0", literal},
- {token.INT, "1", literal},
- {token.INT, "123456789012345678890", literal},
- {token.INT, "01234567", literal},
- {token.INT, "0xcafebabe", literal},
- {token.FLOAT, "0.", literal},
- {token.FLOAT, ".0", literal},
- {token.FLOAT, "3.14159265", literal},
- {token.FLOAT, "1e0", literal},
- {token.FLOAT, "1e+100", literal},
- {token.FLOAT, "1e-100", literal},
- {token.FLOAT, "2.71828e-1000", literal},
- {token.IMAG, "0i", literal},
- {token.IMAG, "1i", literal},
- {token.IMAG, "012345678901234567889i", literal},
- {token.IMAG, "123456789012345678890i", literal},
- {token.IMAG, "0.i", literal},
- {token.IMAG, ".0i", literal},
- {token.IMAG, "3.14159265i", literal},
- {token.IMAG, "1e0i", literal},
- {token.IMAG, "1e+100i", literal},
- {token.IMAG, "1e-100i", literal},
- {token.IMAG, "2.71828e-1000i", literal},
- {token.CHAR, "'a'", literal},
- {token.CHAR, "'\\000'", literal},
- {token.CHAR, "'\\xFF'", literal},
- {token.CHAR, "'\\uff16'", literal},
- {token.CHAR, "'\\U0000ff16'", literal},
- {token.STRING, "`foobar`", literal},
- {token.STRING, "`" + `foo
- bar` +
- "`",
- literal,
- },
- {token.STRING, "`\r`", literal},
- {token.STRING, "`foo\r\nbar`", literal},
-
- // Operators and delimiters
- {token.ADD, "+", operator},
- {token.SUB, "-", operator},
- {token.MUL, "*", operator},
- {token.QUO, "/", operator},
- {token.REM, "%", operator},
-
- {token.AND, "&", operator},
- {token.OR, "|", operator},
- {token.XOR, "^", operator},
- {token.SHL, "<<", operator},
- {token.SHR, ">>", operator},
- {token.AND_NOT, "&^", operator},
-
- {token.ADD_ASSIGN, "+=", operator},
- {token.SUB_ASSIGN, "-=", operator},
- {token.MUL_ASSIGN, "*=", operator},
- {token.QUO_ASSIGN, "/=", operator},
- {token.REM_ASSIGN, "%=", operator},
-
- {token.AND_ASSIGN, "&=", operator},
- {token.OR_ASSIGN, "|=", operator},
- {token.XOR_ASSIGN, "^=", operator},
- {token.SHL_ASSIGN, "<<=", operator},
- {token.SHR_ASSIGN, ">>=", operator},
- {token.AND_NOT_ASSIGN, "&^=", operator},
-
- {token.LAND, "&&", operator},
- {token.LOR, "||", operator},
- {token.ARROW, "<-", operator},
- {token.INC, "++", operator},
- {token.DEC, "--", operator},
-
- {token.EQL, "==", operator},
- {token.LSS, "<", operator},
- {token.GTR, ">", operator},
- {token.ASSIGN, "=", operator},
- {token.NOT, "!", operator},
-
- {token.NEQ, "!=", operator},
- {token.LEQ, "<=", operator},
- {token.GEQ, ">=", operator},
- {token.DEFINE, ":=", operator},
- {token.ELLIPSIS, "...", operator},
-
- {token.LPAREN, "(", operator},
- {token.LBRACK, "[", operator},
- {token.LBRACE, "{", operator},
- {token.COMMA, ",", operator},
- {token.PERIOD, ".", operator},
-
- {token.RPAREN, ")", operator},
- {token.RBRACK, "]", operator},
- {token.RBRACE, "}", operator},
- {token.SEMICOLON, ";", operator},
- {token.COLON, ":", operator},
-
- // Keywords
- {token.BREAK, "break", keyword},
- {token.CASE, "case", keyword},
- {token.CHAN, "chan", keyword},
- {token.CONST, "const", keyword},
- {token.CONTINUE, "continue", keyword},
-
- {token.DEFAULT, "default", keyword},
- {token.DEFER, "defer", keyword},
- {token.ELSE, "else", keyword},
- {token.FALLTHROUGH, "fallthrough", keyword},
- {token.FOR, "for", keyword},
-
- {token.FUNC, "func", keyword},
- {token.GO, "go", keyword},
- {token.GOTO, "goto", keyword},
- {token.IF, "if", keyword},
- {token.IMPORT, "import", keyword},
-
- {token.INTERFACE, "interface", keyword},
- {token.MAP, "map", keyword},
- {token.PACKAGE, "package", keyword},
- {token.RANGE, "range", keyword},
- {token.RETURN, "return", keyword},
-
- {token.SELECT, "select", keyword},
- {token.STRUCT, "struct", keyword},
- {token.SWITCH, "switch", keyword},
- {token.TYPE, "type", keyword},
- {token.VAR, "var", keyword},
-}
-
-const whitespace = " \t \n\n\n" // to separate tokens
-
-var source = func() []byte {
- var src []byte
- for _, t := range tokens {
- src = append(src, t.lit...)
- src = append(src, whitespace...)
- }
- return src
-}()
-
-func newlineCount(s string) int {
- n := 0
- for i := 0; i < len(s); i++ {
- if s[i] == '\n' {
- n++
- }
- }
- return n
-}
-
-func checkPos(t *testing.T, lit string, p token.Pos, expected token.Position) {
- pos := fset.Position(p)
- if pos.Filename != expected.Filename {
- t.Errorf("bad filename for %q: got %s, expected %s", lit, pos.Filename, expected.Filename)
- }
- if pos.Offset != expected.Offset {
- t.Errorf("bad position for %q: got %d, expected %d", lit, pos.Offset, expected.Offset)
- }
- if pos.Line != expected.Line {
- t.Errorf("bad line for %q: got %d, expected %d", lit, pos.Line, expected.Line)
- }
- if pos.Column != expected.Column {
- t.Errorf("bad column for %q: got %d, expected %d", lit, pos.Column, expected.Column)
- }
-}
-
-// Verify that calling Scan() provides the correct results.
-func TestScan(t *testing.T) {
- whitespace_linecount := newlineCount(whitespace)
-
- // error handler
- eh := func(_ token.Position, msg string) {
- t.Errorf("error handler called (msg = %s)", msg)
- }
-
- // verify scan
- var s Scanner
- s.Init(fset.AddFile("", fset.Base(), len(source)), source, eh, ScanComments|dontInsertSemis)
-
- // set up expected position
- epos := token.Position{
- Filename: "",
- Offset: 0,
- Line: 1,
- Column: 1,
- }
-
- index := 0
- for {
- pos, tok, lit := s.Scan()
-
- // check position
- if tok == token.EOF {
- // correction for EOF
- epos.Line = newlineCount(string(source))
- epos.Column = 2
- }
- checkPos(t, lit, pos, epos)
-
- // check token
- e := elt{token.EOF, "", special}
- if index < len(tokens) {
- e = tokens[index]
- index++
- }
- if tok != e.tok {
- t.Errorf("bad token for %q: got %s, expected %s", lit, tok, e.tok)
- }
-
- // check token class
- if tokenclass(tok) != e.class {
- t.Errorf("bad class for %q: got %d, expected %d", lit, tokenclass(tok), e.class)
- }
-
- // check literal
- elit := ""
- switch e.tok {
- case token.COMMENT:
- // no CRs in comments
- elit = string(stripCR([]byte(e.lit)))
- //-style comment literal doesn't contain newline
- if elit[1] == '/' {
- elit = elit[0 : len(elit)-1]
- }
- case token.IDENT:
- elit = e.lit
- case token.SEMICOLON:
- elit = ";"
- default:
- if e.tok.IsLiteral() {
- // no CRs in raw string literals
- elit = e.lit
- if elit[0] == '`' {
- elit = string(stripCR([]byte(elit)))
- }
- } else if e.tok.IsKeyword() {
- elit = e.lit
- }
- }
- if lit != elit {
- t.Errorf("bad literal for %q: got %q, expected %q", lit, lit, elit)
- }
-
- if tok == token.EOF {
- break
- }
-
- // update position
- epos.Offset += len(e.lit) + len(whitespace)
- epos.Line += newlineCount(e.lit) + whitespace_linecount
-
- }
-
- if s.ErrorCount != 0 {
- t.Errorf("found %d errors", s.ErrorCount)
- }
-}
-
-func checkSemi(t *testing.T, line string, mode Mode) {
- var S Scanner
- file := fset.AddFile("TestSemis", fset.Base(), len(line))
- S.Init(file, []byte(line), nil, mode)
- pos, tok, lit := S.Scan()
- for tok != token.EOF {
- if tok == token.ILLEGAL {
- // the illegal token literal indicates what
- // kind of semicolon literal to expect
- semiLit := "\n"
- if lit[0] == '#' {
- semiLit = ";"
- }
- // next token must be a semicolon
- semiPos := file.Position(pos)
- semiPos.Offset++
- semiPos.Column++
- pos, tok, lit = S.Scan()
- if tok == token.SEMICOLON {
- if lit != semiLit {
- t.Errorf(`bad literal for %q: got %q, expected %q`, line, lit, semiLit)
- }
- checkPos(t, line, pos, semiPos)
- } else {
- t.Errorf("bad token for %q: got %s, expected ;", line, tok)
- }
- } else if tok == token.SEMICOLON {
- t.Errorf("bad token for %q: got ;, expected no ;", line)
- }
- pos, tok, lit = S.Scan()
- }
-}
-
-var lines = []string{
- // # indicates a semicolon present in the source
- // $ indicates an automatically inserted semicolon
- "",
- "\ufeff#;", // first BOM is ignored
- "#;",
- "foo$\n",
- "123$\n",
- "1.2$\n",
- "'x'$\n",
- `"x"` + "$\n",
- "`x`$\n",
-
- "+\n",
- "-\n",
- "*\n",
- "/\n",
- "%\n",
-
- "&\n",
- "|\n",
- "^\n",
- "<<\n",
- ">>\n",
- "&^\n",
-
- "+=\n",
- "-=\n",
- "*=\n",
- "/=\n",
- "%=\n",
-
- "&=\n",
- "|=\n",
- "^=\n",
- "<<=\n",
- ">>=\n",
- "&^=\n",
-
- "&&\n",
- "||\n",
- "<-\n",
- "++$\n",
- "--$\n",
-
- "==\n",
- "<\n",
- ">\n",
- "=\n",
- "!\n",
-
- "!=\n",
- "<=\n",
- ">=\n",
- ":=\n",
- "...\n",
-
- "(\n",
- "[\n",
- "{\n",
- ",\n",
- ".\n",
-
- ")$\n",
- "]$\n",
- "}$\n",
- "#;\n",
- ":\n",
-
- "break$\n",
- "case\n",
- "chan\n",
- "const\n",
- "continue$\n",
-
- "default\n",
- "defer\n",
- "else\n",
- "fallthrough$\n",
- "for\n",
-
- "func\n",
- "go\n",
- "goto\n",
- "if\n",
- "import\n",
-
- "interface\n",
- "map\n",
- "package\n",
- "range\n",
- "return$\n",
-
- "select\n",
- "struct\n",
- "switch\n",
- "type\n",
- "var\n",
-
- "foo$//comment\n",
- "foo$//comment",
- "foo$/*comment*/\n",
- "foo$/*\n*/",
- "foo$/*comment*/ \n",
- "foo$/*\n*/ ",
-
- "foo $// comment\n",
- "foo $// comment",
- "foo $/*comment*/\n",
- "foo $/*\n*/",
- "foo $/* */ /* \n */ bar$/**/\n",
- "foo $/*0*/ /*1*/ /*2*/\n",
-
- "foo $/*comment*/ \n",
- "foo $/*0*/ /*1*/ /*2*/ \n",
- "foo $/**/ /*-------------*/ /*----\n*/bar $/* \n*/baa$\n",
- "foo $/* an EOF terminates a line */",
- "foo $/* an EOF terminates a line */ /*",
- "foo $/* an EOF terminates a line */ //",
-
- "package main$\n\nfunc main() {\n\tif {\n\t\treturn /* */ }$\n}$\n",
- "package main$",
-}
-
-func TestSemis(t *testing.T) {
- for _, line := range lines {
- checkSemi(t, line, 0)
- checkSemi(t, line, ScanComments)
-
- // if the input ended in newlines, the input must tokenize the
- // same with or without those newlines
- for i := len(line) - 1; i >= 0 && line[i] == '\n'; i-- {
- checkSemi(t, line[0:i], 0)
- checkSemi(t, line[0:i], ScanComments)
- }
- }
-}
-
-type segment struct {
- srcline string // a line of source text
- filename string // filename for current token
- line int // line number for current token
-}
-
-var segments = []segment{
- // exactly one token per line since the test consumes one token per segment
- {" line1", filepath.Join("dir", "TestLineComments"), 1},
- {"\nline2", filepath.Join("dir", "TestLineComments"), 2},
- {"\nline3 //line File1.go:100", filepath.Join("dir", "TestLineComments"), 3}, // bad line comment, ignored
- {"\nline4", filepath.Join("dir", "TestLineComments"), 4},
- {"\n//line File1.go:100\n line100", filepath.Join("dir", "File1.go"), 100},
- {"\n//line \t :42\n line1", "", 42},
- {"\n//line File2.go:200\n line200", filepath.Join("dir", "File2.go"), 200},
- {"\n//line foo\t:42\n line42", filepath.Join("dir", "foo"), 42},
- {"\n //line foo:42\n line44", filepath.Join("dir", "foo"), 44}, // bad line comment, ignored
- {"\n//line foo 42\n line46", filepath.Join("dir", "foo"), 46}, // bad line comment, ignored
- {"\n//line foo:42 extra text\n line48", filepath.Join("dir", "foo"), 48}, // bad line comment, ignored
- {"\n//line ./foo:42\n line42", filepath.Join("dir", "foo"), 42},
- {"\n//line a/b/c/File1.go:100\n line100", filepath.Join("dir", "a", "b", "c", "File1.go"), 100},
-}
-
-var unixsegments = []segment{
- {"\n//line /bar:42\n line42", "/bar", 42},
-}
-
-var winsegments = []segment{
- {"\n//line c:\\bar:42\n line42", "c:\\bar", 42},
- {"\n//line c:\\dir\\File1.go:100\n line100", "c:\\dir\\File1.go", 100},
-}
-
-// Verify that comments of the form "//line filename:line" are interpreted correctly.
-func TestLineComments(t *testing.T) {
- segs := segments
- if runtime.GOOS == "windows" {
- segs = append(segs, winsegments...)
- } else {
- segs = append(segs, unixsegments...)
- }
-
- // make source
- var src string
- for _, e := range segs {
- src += e.srcline
- }
-
- // verify scan
- var S Scanner
- file := fset.AddFile(filepath.Join("dir", "TestLineComments"), fset.Base(), len(src))
- S.Init(file, []byte(src), nil, dontInsertSemis)
- for _, s := range segs {
- p, _, lit := S.Scan()
- pos := file.Position(p)
- checkPos(t, lit, p, token.Position{
- Filename: s.filename,
- Offset: pos.Offset,
- Line: s.line,
- Column: pos.Column,
- })
- }
-
- if S.ErrorCount != 0 {
- t.Errorf("found %d errors", S.ErrorCount)
- }
-}
-
-// Verify that initializing the same scanner more than once works correctly.
-func TestInit(t *testing.T) {
- var s Scanner
-
- // 1st init
- src1 := "if true { }"
- f1 := fset.AddFile("src1", fset.Base(), len(src1))
- s.Init(f1, []byte(src1), nil, dontInsertSemis)
- if f1.Size() != len(src1) {
- t.Errorf("bad file size: got %d, expected %d", f1.Size(), len(src1))
- }
- s.Scan() // if
- s.Scan() // true
- _, tok, _ := s.Scan() // {
- if tok != token.LBRACE {
- t.Errorf("bad token: got %s, expected %s", tok, token.LBRACE)
- }
-
- // 2nd init
- src2 := "go true { ]"
- f2 := fset.AddFile("src2", fset.Base(), len(src2))
- s.Init(f2, []byte(src2), nil, dontInsertSemis)
- if f2.Size() != len(src2) {
- t.Errorf("bad file size: got %d, expected %d", f2.Size(), len(src2))
- }
- _, tok, _ = s.Scan() // go
- if tok != token.GO {
- t.Errorf("bad token: got %s, expected %s", tok, token.GO)
- }
-
- if s.ErrorCount != 0 {
- t.Errorf("found %d errors", s.ErrorCount)
- }
-}
-
-func TestStdErrorHander(t *testing.T) {
- const src = "@\n" + // illegal character, cause an error
- "@ @\n" + // two errors on the same line
- "//line File2:20\n" +
- "@\n" + // different file, but same line
- "//line File2:1\n" +
- "@ @\n" + // same file, decreasing line number
- "//line File1:1\n" +
- "@ @ @" // original file, line 1 again
-
- var list ErrorList
- eh := func(pos token.Position, msg string) { list.Add(pos, msg) }
-
- var s Scanner
- s.Init(fset.AddFile("File1", fset.Base(), len(src)), []byte(src), eh, dontInsertSemis)
- for {
- if _, tok, _ := s.Scan(); tok == token.EOF {
- break
- }
- }
-
- if len(list) != s.ErrorCount {
- t.Errorf("found %d errors, expected %d", len(list), s.ErrorCount)
- }
-
- if len(list) != 9 {
- t.Errorf("found %d raw errors, expected 9", len(list))
- PrintError(os.Stderr, list)
- }
-
- list.Sort()
- if len(list) != 9 {
- t.Errorf("found %d sorted errors, expected 9", len(list))
- PrintError(os.Stderr, list)
- }
-
- list.RemoveMultiples()
- if len(list) != 4 {
- t.Errorf("found %d one-per-line errors, expected 4", len(list))
- PrintError(os.Stderr, list)
- }
-}
-
-type errorCollector struct {
- cnt int // number of errors encountered
- msg string // last error message encountered
- pos token.Position // last error position encountered
-}
-
-func checkError(t *testing.T, src string, tok token.Token, pos int, lit, err string) {
- var s Scanner
- var h errorCollector
- eh := func(pos token.Position, msg string) {
- h.cnt++
- h.msg = msg
- h.pos = pos
- }
- s.Init(fset.AddFile("", fset.Base(), len(src)), []byte(src), eh, ScanComments|dontInsertSemis)
- _, tok0, lit0 := s.Scan()
- if tok0 != tok {
- t.Errorf("%q: got %s, expected %s", src, tok0, tok)
- }
- if tok0 != token.ILLEGAL && lit0 != lit {
- t.Errorf("%q: got literal %q, expected %q", src, lit0, lit)
- }
- cnt := 0
- if err != "" {
- cnt = 1
- }
- if h.cnt != cnt {
- t.Errorf("%q: got cnt %d, expected %d", src, h.cnt, cnt)
- }
- if h.msg != err {
- t.Errorf("%q: got msg %q, expected %q", src, h.msg, err)
- }
- if h.pos.Offset != pos {
- t.Errorf("%q: got offset %d, expected %d", src, h.pos.Offset, pos)
- }
-}
-
-var errors = []struct {
- src string
- tok token.Token
- pos int
- lit string
- err string
-}{
- {"\a", token.ILLEGAL, 0, "", "illegal character U+0007"},
- {`#`, token.ILLEGAL, 0, "", "illegal character U+0023 '#'"},
- {`…`, token.ILLEGAL, 0, "", "illegal character U+2026 '…'"},
- {`' '`, token.CHAR, 0, `' '`, ""},
- {`''`, token.CHAR, 0, `''`, "illegal rune literal"},
- {`'12'`, token.CHAR, 0, `'12'`, "illegal rune literal"},
- {`'123'`, token.CHAR, 0, `'123'`, "illegal rune literal"},
- {`'\0'`, token.CHAR, 3, `'\0'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\07'`, token.CHAR, 4, `'\07'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\8'`, token.CHAR, 2, `'\8'`, "unknown escape sequence"},
- {`'\08'`, token.CHAR, 3, `'\08'`, "illegal character U+0038 '8' in escape sequence"},
- {`'\x'`, token.CHAR, 3, `'\x'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\x0'`, token.CHAR, 4, `'\x0'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\x0g'`, token.CHAR, 4, `'\x0g'`, "illegal character U+0067 'g' in escape sequence"},
- {`'\u'`, token.CHAR, 3, `'\u'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\u0'`, token.CHAR, 4, `'\u0'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\u00'`, token.CHAR, 5, `'\u00'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\u000'`, token.CHAR, 6, `'\u000'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\u000`, token.CHAR, 6, `'\u000`, "escape sequence not terminated"},
- {`'\u0000'`, token.CHAR, 0, `'\u0000'`, ""},
- {`'\U'`, token.CHAR, 3, `'\U'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\U0'`, token.CHAR, 4, `'\U0'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\U00'`, token.CHAR, 5, `'\U00'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\U000'`, token.CHAR, 6, `'\U000'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\U0000'`, token.CHAR, 7, `'\U0000'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\U00000'`, token.CHAR, 8, `'\U00000'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\U000000'`, token.CHAR, 9, `'\U000000'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\U0000000'`, token.CHAR, 10, `'\U0000000'`, "illegal character U+0027 ''' in escape sequence"},
- {`'\U0000000`, token.CHAR, 10, `'\U0000000`, "escape sequence not terminated"},
- {`'\U00000000'`, token.CHAR, 0, `'\U00000000'`, ""},
- {`'\Uffffffff'`, token.CHAR, 2, `'\Uffffffff'`, "escape sequence is invalid Unicode code point"},
- {`'`, token.CHAR, 0, `'`, "rune literal not terminated"},
- {`'\`, token.CHAR, 2, `'\`, "escape sequence not terminated"},
- {"'\n", token.CHAR, 0, "'", "rune literal not terminated"},
- {"'\n ", token.CHAR, 0, "'", "rune literal not terminated"},
- {`""`, token.STRING, 0, `""`, ""},
- {`"abc`, token.STRING, 0, `"abc`, "string literal not terminated"},
- {"\"abc\n", token.STRING, 0, `"abc`, "string literal not terminated"},
- {"\"abc\n ", token.STRING, 0, `"abc`, "string literal not terminated"},
- {"``", token.STRING, 0, "``", ""},
- {"`", token.STRING, 0, "`", "raw string literal not terminated"},
- {"/**/", token.COMMENT, 0, "/**/", ""},
- {"/*", token.COMMENT, 0, "/*", "comment not terminated"},
- {"077", token.INT, 0, "077", ""},
- {"078.", token.FLOAT, 0, "078.", ""},
- {"07801234567.", token.FLOAT, 0, "07801234567.", ""},
- {"078e0", token.FLOAT, 0, "078e0", ""},
- {"078", token.INT, 0, "078", "illegal octal number"},
- {"07800000009", token.INT, 0, "07800000009", "illegal octal number"},
- {"0x", token.INT, 0, "0x", "illegal hexadecimal number"},
- {"0X", token.INT, 0, "0X", "illegal hexadecimal number"},
- {"\"abc\x00def\"", token.STRING, 4, "\"abc\x00def\"", "illegal character NUL"},
- {"\"abc\x80def\"", token.STRING, 4, "\"abc\x80def\"", "illegal UTF-8 encoding"},
- {"\ufeff\ufeff", token.ILLEGAL, 3, "\ufeff\ufeff", "illegal byte order mark"}, // only first BOM is ignored
- {"//\ufeff", token.COMMENT, 2, "//\ufeff", "illegal byte order mark"}, // only first BOM is ignored
- {"'\ufeff" + `'`, token.CHAR, 1, "'\ufeff" + `'`, "illegal byte order mark"}, // only first BOM is ignored
- {`"` + "abc\ufeffdef" + `"`, token.STRING, 4, `"` + "abc\ufeffdef" + `"`, "illegal byte order mark"}, // only first BOM is ignored
-}
-
-func TestScanErrors(t *testing.T) {
- for _, e := range errors {
- checkError(t, e.src, e.tok, e.pos, e.lit, e.err)
- }
-}
-
-func BenchmarkScan(b *testing.B) {
- b.StopTimer()
- fset := token.NewFileSet()
- file := fset.AddFile("", fset.Base(), len(source))
- var s Scanner
- b.StartTimer()
- for i := 0; i < b.N; i++ {
- s.Init(file, source, nil, ScanComments)
- for {
- _, tok, _ := s.Scan()
- if tok == token.EOF {
- break
- }
- }
- }
-}
-
-func BenchmarkScanFile(b *testing.B) {
- b.StopTimer()
- const filename = "scanner.go"
- src, err := ioutil.ReadFile(filename)
- if err != nil {
- panic(err)
- }
- fset := token.NewFileSet()
- file := fset.AddFile(filename, fset.Base(), len(src))
- b.SetBytes(int64(len(src)))
- var s Scanner
- b.StartTimer()
- for i := 0; i < b.N; i++ {
- s.Init(file, src, nil, ScanComments)
- for {
- _, tok, _ := s.Scan()
- if tok == token.EOF {
- break
- }
- }
- }
-}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-29 11:34:52 +0000