env GO111MODULE=off

# gccgo does not have standard packages.
[compiler:gccgo] skip

# fmt should have no rewritten imports.
# The import from a/b should map c/d to a's vendor directory.
go list -f '{{.ImportPath}}: {{.ImportMap}}' fmt a/b
stdout 'fmt: map\[\]'
stdout 'a/b: map\[c/d:a/vendor/c/d\]'

# flag [fmt.test] should import fmt [fmt.test] as fmt
# fmt.test should import testing [fmt.test] as testing
# fmt.test should not import a modified os

// run

// Copyright 2018 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.

// Issue 26495: gccgo produces incorrect order of evaluation
// for expressions involving &&, || subexpressions.

package main

var i int

func checkorder(order int) {
	if i != order {
		panic("FAIL: wrong evaluation order")
	}
	i++
}

// run

// Copyright 2012 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.

// Gccgo used to crash compiling this.

package main

func foo() (int, int) {
	return 1, 2
}

var c = b
var a, b = foo()
var d = b + 1

func main() {
	if a != 1 {
		panic(a)
	}
	if b != 2 {
		panic(b)
	}
	if c != 2 {
		panic(c)

// compile

// Copyright 2014 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.

// The gccgo compiler had a bug: mentioning a function type in an
// expression in a function literal messed up the list of variables
// referenced in enclosing functions.

package main

func main() {
	v1, v2 := 0, 0
	f := func() {
		a := v1
		g := (func())(nil)

				// Fake packages - nothing to build.
				a.Mode = "built-in package"
				a.Actor = nil
				return a
			}

			// gccgo standard library is "fake" too.
			if cfg.BuildToolchainName == "gccgo" {
				// the target name is needed for cgo.
				a.Mode = "gccgo stdlib"
				a.Target = p.Target
				a.Actor = nil
				return a
			}
		}

		return a
	})

[short] skip
[compiler:gccgo] skip # gccgo has no cover tool
[!GOEXPERIMENT:coverageredesign] skip

go test -short -cover -covermode=atomic -coverpkg=coverdep/p1 coverdep

# In addition to the above, test to make sure there is no funny
# business if we try "go test -cover" in atomic mode targeting
# sync/atomic itself (see #57445). Just a short test run is needed
# since we're mainly interested in making sure the test builds and can

[short] skip
[!cgo] skip
[compiler:gccgo] skip # gccgo has no cover tool

# Test coverage on cgo code. This test case includes an
# extra empty non-cgo file in the package being checked.

go test -short -cover cgocover4
stdout  'coverage:.*[1-9][0-9.]+%'
! stderr '[^0-9]0\.0%'

-- go.mod --
module cgocover4

go 1.16
-- notcgo.go --
package p
-- p.go --
package p

/*
void
f(void)
{
}
*/
import "C"

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test multiple identical unnamed structs with methods.  This caused
// a compilation error with gccgo.

package p

type S1 struct{}

func (s S1) M() {}

type S2 struct {
	F1 struct {
		S1
	}
	F2 struct {
		S1
	}
}

type I interface {
	M()
}

func F() {

	"C_INCLUDE_PATH",     // allow override non-standard include paths
	"CC",                 // don't lose user settings when invoking cgo
	"GO_TESTING_GOTOOLS", // for gccgo testing
	"GCCGO",              // for gccgo testing
	"GCCGOTOOLDIR",       // for gccgo testing
}

// updateSum runs 'go mod tidy', 'go list -mod=mod -m all', or
// 'go list -mod=mod all' in the test's current directory if a file named

// run

// Copyright 2013 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.

// Used to be miscompiled by gccgo, due to a bug in handling
// initialization ordering.

package main

func F(a ...interface{}) interface{} {
	s := 0
	for _, v := range a {
		s += v.(int)
	}
	return s
}

var V1 = F(V10, V4, V3, V11)

var V2 = F(V1)