}
				out += tok
			}
			if out != tt.out {
				t.Errorf("lex(%q):\nhave %s\nwant %s", tt.in, out, tt.out)
			}
		})
	}
}

func lexHelp(p *exprParser) (tok string, err error) {
	defer func() {
		if e := recover(); e != nil {
			if e, ok := e.(*SyntaxError); ok {
				err = e
				return
			}
			panic(e)
		}
	}()

	p.lex()
	return p.tok, nil
}

var parseExprTests = []struct {

// Copyright 2015 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 lex

import (
	"go/build/constraint"
	"io"
	"os"
	"strings"
	"text/scanner"
	"unicode"

	"cmd/asm/internal/flags"
	"cmd/internal/objabi"
	"cmd/internal/src"
)

// A Tokenizer is a simple wrapping of text/scanner.Scanner, configured

    }

    private
    fun programFor(source: ProgramSource, kind: ProgramKind, target: ProgramTarget): Packaged<Program> {

        val topLevelBlockIds = TopLevelBlockId.topLevelBlockIdFor(target)

        return lex(source.text, *topLevelBlockIds).map { (comments, annotations, topLevelBlocks) ->

            checkForSingleBlocksOf(topLevelBlockIds, topLevelBlocks)

            checkForTopLevelBlockOrder(topLevelBlocks)

    val annotations: List<IntRange>,
    val topLevelBlocks: List<TopLevelBlock>
)


/**
 * Returns the comments and [top-level blocks][topLevelBlockIds] found in the given [script].
 */
internal
fun lex(script: String, vararg topLevelBlockIds: TopLevelBlockId): Packaged<LexedScript> {

    var packageName: String? = null
    val comments = mutableListOf<IntRange>()
    val annotations = mutableListOf<IntRange>()

// Copyright 2015 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 lex

import (
	"strings"
	"testing"
	"text/scanner"
)

type lexTest struct {
	name   string
	input  string
	output string
}

var lexTests = []lexTest{
	{
		"empty",
		"",
		"",
	},
	{
		"simple",
		"1 (a)",
		"1.(.a.)",
	},

	copies     map[string]string // copies stores a map of destination path -> source path
	user       string
	workdir    string
	base       string
	entrypoint []string
	cmd        []string

	shlex *shell.Lex
}

func cut(s, sep string) (before, after string) {
	if i := strings.Index(s, sep); i >= 0 {
		return s[:i], s[i+len(sep):]
	}
	return s, ""
}

// Parse parses the provided Dockerfile with the given args