assert System.getProperty("java.vendor") != "hollywood"
        assert System.getProperty("java.vendor") != null
        assert System.getProperty("sun.sunny") == null
    }
}
        """

        expect:
        executer.withBuildJvmOpts("-Djava.vendor=hollywood", "-Dsun.sunny=california").withTasks("verify").run()
    }

    def "other client JVM system properties are carried over to daemon JVM"() {
        given:

	"sun_with_face":                        "\U0001f31e",
	"sunflower":                            "\U0001f33b",
	"sunglasses":                           "\U0001f60e",
	"sunny":                                "\u2600\ufe0f",
	"sunrise":                              "\U0001f305",
	"sunrise_over_mountains":               "\U0001f304",
	"superhero":                            "\U0001f9b8",

	_ = sum3(tuple())
	_ = sum3(tuple()...) // ERROR "\.{3} in call to non-variadic|multiple-value|invalid use of .*[.][.][.]"
)

type T []T

func funny(args ...T) int { return 0 }

var (
	_ = funny(nil)
	_ = funny(nil, nil)
	_ = funny([]T{}) // ok because []T{} is a T; passes []T{[]T{}}
)

func Foo(n int) {}

func bad(args ...int) {
	print(1, 2, args...)	// ERROR "[.][.][.]"

[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
# execute at least one test.

        when:
        run("test")

        then:
        noExceptionThrown()
    }

    // This is named funny to keep the path to the project
    // under Windows's limits.  This checks that we can use
    // ServletCategory as an extension class when compiling
    // Groovy code.
    @Issue("GRADLE-3235")
    def gradle3235() {

stderr 'link.* -X=math.pi=3'

# -ldflags applies to current directory
cd my/cmd/prog
go build -a -n -ldflags=-X=math.pi=3
stderr 'link.* -X=math.pi=3'

# -ldflags applies to current directory even if GOPATH is funny
[!case-sensitive] cd $WORK/GoPath/src/my/cmd/prog
go build -a -n -ldflags=-X=math.pi=3
stderr 'link.* -X=math.pi=3'

# cgo.a should not be a dependency of internally-linked go package

    EXPECT_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
    EXPECT_EQ("bunny", string(static_cast<const char*>(val.get()), 5));
    TF_DeleteStatus(status);
    return static_cast<void*>(s);
  };

  AttrValue v;
  v.set_s("bunny");
  CreateAndCallKernelWithAttr(my_create_func, "TestKernelAttrString", v);
}

TEST_F(TestKernelAttr, StringList) {

# non-standard host objects.
#
# As of 1.21 we continue to use internal linking for programs whose
# CGO use comes only from stdlib packages in the absence of any flag
# funny business, however if the Go command sees flags that may be suspicious,
# it signals the Go linker to invoke the external linker.

# The next few tests run builds passing "-n" to the Go command, then

	if !utf8.ValidString(s) {
		return "" // Don't try to recover non-UTF-8 error messages.
	}
	for _, r := range s {
		if !unicode.IsGraphic(r) && !unicode.IsSpace(r) {
			return "" // Don't let the server do any funny business with the user's terminal.
		}
	}

	var detail strings.Builder
	for i, line := range strings.Split(s, "\n") {
		if strings.TrimSpace(line) == "" {
			break // Stop at the first blank line.
		}

		s.appendString(v.str())
	case KindInt64:
		*s.buf = strconv.AppendInt(*s.buf, v.Int64(), 10)
	case KindUint64:
		*s.buf = strconv.AppendUint(*s.buf, v.Uint64(), 10)
	case KindFloat64:
		// json.Marshal is funny about floats; it doesn't
		// always match strconv.AppendFloat. So just call it.
		// That's expensive, but floats are rare.
		if err := appendJSONMarshal(s.buf, v.Float64()); err != nil {
			return err
		}