read_test.go

Documentation: go/build

		 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 build
		 6  
		 7  import (
		 8  	"fmt"
		 9  	"go/token"
		10  	"io"
		11  	"strings"
		12  	"testing"
		13  )
		14  
		15  const quote = "`"
		16  
		17  type readTest struct {
		18  	// Test input contains ℙ where readGoInfo should stop.
		19  	in	string
		20  	err string
		21  }
		22  
		23  var readGoInfoTests = []readTest{
		24  	{
		25  		`package p`,
		26  		"",
		27  	},
		28  	{
		29  		`package p; import "x"`,
		30  		"",
		31  	},
		32  	{
		33  		`package p; import . "x"`,
		34  		"",
		35  	},
		36  	{
		37  		`package p; import "x";ℙvar x = 1`,
		38  		"",
		39  	},
		40  	{
		41  		`package p
		42  
		43  		// comment
		44  
		45  		import "x"
		46  		import _ "x"
		47  		import a "x"
		48  
		49  		/* comment */
		50  
		51  		import (
		52  			"x" /* comment */
		53  			_ "x"
		54  			a "x" // comment
		55  			` + quote + `x` + quote + `
		56  			_ /*comment*/ ` + quote + `x` + quote + `
		57  			a ` + quote + `x` + quote + `
		58  		)
		59  		import (
		60  		)
		61  		import ()
		62  		import()import()import()
		63  		import();import();import()
		64  
		65  		ℙvar x = 1
		66  		`,
		67  		"",
		68  	},
		69  	{
		70  		"\ufeff𝔻" + `package p; import "x";ℙvar x = 1`,
		71  		"",
		72  	},
		73  }
		74  
		75  var readCommentsTests = []readTest{
		76  	{
		77  		`ℙpackage p`,
		78  		"",
		79  	},
		80  	{
		81  		`ℙpackage p; import "x"`,
		82  		"",
		83  	},
		84  	{
		85  		`ℙpackage p; import . "x"`,
		86  		"",
		87  	},
		88  	{
		89  		"\ufeff𝔻" + `ℙpackage p; import . "x"`,
		90  		"",
		91  	},
		92  	{
		93  		`// foo
		94  
		95  		/* bar */
		96  
		97  		/* quux */ // baz
		98  
		99  		/*/ zot */
	 100  
	 101  		// asdf
	 102  		ℙHello, world`,
	 103  		"",
	 104  	},
	 105  	{
	 106  		"\ufeff𝔻" + `// foo
	 107  
	 108  		/* bar */
	 109  
	 110  		/* quux */ // baz
	 111  
	 112  		/*/ zot */
	 113  
	 114  		// asdf
	 115  		ℙHello, world`,
	 116  		"",
	 117  	},
	 118  }
	 119  
	 120  func testRead(t *testing.T, tests []readTest, read func(io.Reader) ([]byte, error)) {
	 121  	for i, tt := range tests {
	 122  		var in, testOut string
	 123  		j := strings.Index(tt.in, "ℙ")
	 124  		if j < 0 {
	 125  			in = tt.in
	 126  			testOut = tt.in
	 127  		} else {
	 128  			in = tt.in[:j] + tt.in[j+len("ℙ"):]
	 129  			testOut = tt.in[:j]
	 130  		}
	 131  		d := strings.Index(tt.in, "𝔻")
	 132  		if d >= 0 {
	 133  			in = in[:d] + in[d+len("𝔻"):]
	 134  			testOut = testOut[d+len("𝔻"):]
	 135  		}
	 136  		r := strings.NewReader(in)
	 137  		buf, err := read(r)
	 138  		if err != nil {
	 139  			if tt.err == "" {
	 140  				t.Errorf("#%d: err=%q, expected success (%q)", i, err, string(buf))
	 141  			} else if !strings.Contains(err.Error(), tt.err) {
	 142  				t.Errorf("#%d: err=%q, expected %q", i, err, tt.err)
	 143  			}
	 144  			continue
	 145  		}
	 146  		if tt.err != "" {
	 147  			t.Errorf("#%d: success, expected %q", i, tt.err)
	 148  			continue
	 149  		}
	 150  
	 151  		out := string(buf)
	 152  		if out != testOut {
	 153  			t.Errorf("#%d: wrong output:\nhave %q\nwant %q\n", i, out, testOut)
	 154  		}
	 155  	}
	 156  }
	 157  
	 158  func TestReadGoInfo(t *testing.T) {
	 159  	testRead(t, readGoInfoTests, func(r io.Reader) ([]byte, error) {
	 160  		var info fileInfo
	 161  		err := readGoInfo(r, &info)
	 162  		return info.header, err
	 163  	})
	 164  }
	 165  
	 166  func TestReadComments(t *testing.T) {
	 167  	testRead(t, readCommentsTests, readComments)
	 168  }
	 169  
	 170  var readFailuresTests = []readTest{
	 171  	{
	 172  		`package`,
	 173  		"syntax error",
	 174  	},
	 175  	{
	 176  		"package p\n\x00\nimport `math`\n",
	 177  		"unexpected NUL in input",
	 178  	},
	 179  	{
	 180  		`package p; import`,
	 181  		"syntax error",
	 182  	},
	 183  	{
	 184  		`package p; import "`,
	 185  		"syntax error",
	 186  	},
	 187  	{
	 188  		"package p; import ` \n\n",
	 189  		"syntax error",
	 190  	},
	 191  	{
	 192  		`package p; import "x`,
	 193  		"syntax error",
	 194  	},
	 195  	{
	 196  		`package p; import _`,
	 197  		"syntax error",
	 198  	},
	 199  	{
	 200  		`package p; import _ "`,
	 201  		"syntax error",
	 202  	},
	 203  	{
	 204  		`package p; import _ "x`,
	 205  		"syntax error",
	 206  	},
	 207  	{
	 208  		`package p; import .`,
	 209  		"syntax error",
	 210  	},
	 211  	{
	 212  		`package p; import . "`,
	 213  		"syntax error",
	 214  	},
	 215  	{
	 216  		`package p; import . "x`,
	 217  		"syntax error",
	 218  	},
	 219  	{
	 220  		`package p; import (`,
	 221  		"syntax error",
	 222  	},
	 223  	{
	 224  		`package p; import ("`,
	 225  		"syntax error",
	 226  	},
	 227  	{
	 228  		`package p; import ("x`,
	 229  		"syntax error",
	 230  	},
	 231  	{
	 232  		`package p; import ("x"`,
	 233  		"syntax error",
	 234  	},
	 235  }
	 236  
	 237  func TestReadFailuresIgnored(t *testing.T) {
	 238  	// Syntax errors should not be reported (false arg to readImports).
	 239  	// Instead, entire file should be the output and no error.
	 240  	// Convert tests not to return syntax errors.
	 241  	tests := make([]readTest, len(readFailuresTests))
	 242  	copy(tests, readFailuresTests)
	 243  	for i := range tests {
	 244  		tt := &tests[i]
	 245  		if !strings.Contains(tt.err, "NUL") {
	 246  			tt.err = ""
	 247  		}
	 248  	}
	 249  	testRead(t, tests, func(r io.Reader) ([]byte, error) {
	 250  		var info fileInfo
	 251  		err := readGoInfo(r, &info)
	 252  		return info.header, err
	 253  	})
	 254  }
	 255  
	 256  var readEmbedTests = []struct {
	 257  	in, out string
	 258  }{
	 259  	{
	 260  		"package p\n",
	 261  		"",
	 262  	},
	 263  	{
	 264  		"package p\nimport \"embed\"\nvar i int\n//go:embed x y z\nvar files embed.FS",
	 265  		`test:4:12:x
	 266  		 test:4:14:y
	 267  		 test:4:16:z`,
	 268  	},
	 269  	{
	 270  		"package p\nimport \"embed\"\nvar i int\n//go:embed x \"\\x79\" `z`\nvar files embed.FS",
	 271  		`test:4:12:x
	 272  		 test:4:14:y
	 273  		 test:4:21:z`,
	 274  	},
	 275  	{
	 276  		"package p\nimport \"embed\"\nvar i int\n//go:embed x y\n//go:embed z\nvar files embed.FS",
	 277  		`test:4:12:x
	 278  		 test:4:14:y
	 279  		 test:5:12:z`,
	 280  	},
	 281  	{
	 282  		"package p\nimport \"embed\"\nvar i int\n\t //go:embed x y\n\t //go:embed z\n\t var files embed.FS",
	 283  		`test:4:14:x
	 284  		 test:4:16:y
	 285  		 test:5:14:z`,
	 286  	},
	 287  	{
	 288  		"package p\nimport \"embed\"\n//go:embed x y z\nvar files embed.FS",
	 289  		`test:3:12:x
	 290  		 test:3:14:y
	 291  		 test:3:16:z`,
	 292  	},
	 293  	{
	 294  		"\ufeffpackage p\nimport \"embed\"\n//go:embed x y z\nvar files embed.FS",
	 295  		`test:3:12:x
	 296  		 test:3:14:y
	 297  		 test:3:16:z`,
	 298  	},
	 299  	{
	 300  		"package p\nimport \"embed\"\nvar s = \"/*\"\n//go:embed x\nvar files embed.FS",
	 301  		`test:4:12:x`,
	 302  	},
	 303  	{
	 304  		`package p
	 305  		 import "embed"
	 306  		 var s = "\"\\\\"
	 307  		 //go:embed x
	 308  		 var files embed.FS`,
	 309  		`test:4:15:x`,
	 310  	},
	 311  	{
	 312  		"package p\nimport \"embed\"\nvar s = `/*`\n//go:embed x\nvar files embed.FS",
	 313  		`test:4:12:x`,
	 314  	},
	 315  	{
	 316  		"package p\nimport \"embed\"\nvar s = z/ *y\n//go:embed pointer\nvar pointer embed.FS",
	 317  		"test:4:12:pointer",
	 318  	},
	 319  	{
	 320  		"package p\n//go:embed x y z\n", // no import, no scan
	 321  		"",
	 322  	},
	 323  	{
	 324  		"package p\n//go:embed x y z\nvar files embed.FS", // no import, no scan
	 325  		"",
	 326  	},
	 327  	{
	 328  		"\ufeffpackage p\n//go:embed x y z\nvar files embed.FS", // no import, no scan
	 329  		"",
	 330  	},
	 331  }
	 332  
	 333  func TestReadEmbed(t *testing.T) {
	 334  	fset := token.NewFileSet()
	 335  	for i, tt := range readEmbedTests {
	 336  		info := fileInfo{
	 337  			name: "test",
	 338  			fset: fset,
	 339  		}
	 340  		err := readGoInfo(strings.NewReader(tt.in), &info)
	 341  		if err != nil {
	 342  			t.Errorf("#%d: %v", i, err)
	 343  			continue
	 344  		}
	 345  		b := &strings.Builder{}
	 346  		sep := ""
	 347  		for _, emb := range info.embeds {
	 348  			fmt.Fprintf(b, "%s%v:%s", sep, emb.pos, emb.pattern)
	 349  			sep = "\n"
	 350  		}
	 351  		got := b.String()
	 352  		want := strings.Join(strings.Fields(tt.out), "\n")
	 353  		if got != want {
	 354  			t.Errorf("#%d: embeds:\n%s\nwant:\n%s", i, got, want)
	 355  		}
	 356  	}
	 357  }
	 358
View as plain text