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

# Test cgo coverage with an external test.

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

-- go.mod --
module cgocover2

go 1.16
-- p.go --
package p

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

var b bool

func F() {
	if b {
		for {
		}
	}
	C.f()
}

env GO111MODULE=off

# Test that the user can override default code generation flags.

[compiler:gccgo] skip  # gccgo does not use -gcflags
[!cgo] skip
[!GOOS:linux] skip  # test only works if c-archive implies -shared
[short] skip

env GOCACHE=$WORK/gocache  # Looking for compile commands, so need a clean cache.
go build -x -n -buildmode=c-archive -gcflags=all=-shared=false ./override.go
stderr '^.*/compile (.* )?-shared (.* )?-shared=false'

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

//go:build linux && gccgo && arm

package unix

import (
	"syscall"
	"unsafe"
)

func seek(fd int, offset int64, whence int) (int64, syscall.Errno) {
	var newoffset int64
	offsetLow := uint32(offset & 0xffffffff)
	offsetHigh := uint32((offset >> 32) & 0xffffffff)

// license that can be found in the LICENSE file.

// Test case for issue 30862.  This test as written will
// fail for the main 'gc' compiler unless GOEXPERIMENT=fieldtrack
// is set when building it, whereas gccgo has field tracking
// enabled by default (hence the build tag below).

[compiler:gccgo] skip 'gccgo has no cover tool'
[short] skip

go test -short -coverpkg=strings strings regexp
! stdout '[^0-9]0\.0%'
stdout  'strings.*coverage:.*[1-9][0-9.]+%'
stdout  'regexp.*coverage:.*[1-9][0-9.]+%'

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

}

// If gccgo is not available or not new enough, call t.Skip.
func requireGccgo(t *testing.T) {
	t.Helper()

	if runtime.GOARCH == "ppc64" || runtime.GOARCH == "ppc64le" {
		t.Skip("gccgo test skipped on PPC64 until issue #60798 is resolved")
	}

	gccgoName := os.Getenv("GCCGO")
	if gccgoName == "" {
		gccgoName = "gccgo"
	}
	gccgoPath, err := exec.LookPath(gccgoName)

// compile

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

// Caused a gofrontend crash.

//go:build gccgo

package p

//go:notinheap
type S1 struct{}

type S2 struct {
	r      interface{ Read([]byte) (int, error) }
	s1, s2 []byte
	p      *S1
	n      uintptr
}

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

// Test that it's OK to have C code that does nothing other than
// initialize a global variable.  This used to fail with gccgo.

package gcc68255

/*
#include "c.h"
*/
import "C"

func F() bool {
	return C.v != nil

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

# Test cover for a package that has an assembly function.

go test -outputdir=$WORK -coverprofile=cover.out coverasm
go tool cover -func=$WORK/cover.out
stdout '\tg\t*100.0%' # Check g is 100% covered.
! stdout '\tf\t*[0-9]' # Check for no coverage on the assembly function

-- go.mod --
module coverasm

go 1.16
-- p.go --
package p

func f()

func g() {

env GO111MODULE=off

# Coverage analysis should use 'set' mode by default,
# and should merge coverage profiles correctly.

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

go test -short -cover encoding/binary errors -coverprofile=$WORK/cover.out
! stderr '[^0-9]0\.0%'
! stdout '[^0-9]0\.0%'

grep -count=1 '^mode: set$' $WORK/cover.out
grep 'errors\.go' $WORK/cover.out
grep 'binary\.go' $WORK/cover.out

[!race] stop