}
        });

        spec.setSourceFiles(ImmutableSet.copyOf(filtered));
    }

    private void resolveNonStringsInCompilerArgs(GroovyJavaJointCompileSpec spec) {
        // in particular, this is about GStrings
        spec.getCompileOptions().setCompilerArgs(CollectionUtils.toStringList(spec.getCompileOptions().getCompilerArgs()));
    }

    private void logSourceFiles(GroovyJavaJointCompileSpec spec) {

	}
}

// api

const greeting = "hello, world"

type testPair struct {
	Name      string
	Got, Want interface{}
}

var testPairs = []testPair{
	{"GoString", C.GoString(C.greeting), greeting},
	{"GoStringN", C.GoStringN(C.greeting, 5), greeting[:5]},
	{"GoBytes", C.GoBytes(unsafe.Pointer(C.greeting), 5), []byte(greeting[:5])},
}

func testHelpers(t *testing.T) {
	for _, pair := range testPairs {

		// and used as the new base register and the offset field in the instruction
		// can be set to zero.

		// This same problem can happen with gostrings since the final offset is not
		// known yet, but could be unaligned after the relocation is resolved.
		// So gostrings are handled the same way.

		// This allows the MOVDload and MOVWload to be generated in more cases and

// #include <stdlib.h>
// #include <unistd.h>
import "C"

import "os"

func main() {
	os.Setenv("FOO", "bar")
	s := C.GoString(C.getenv(C.CString("FOO")))
	if s != "bar" {
		panic("bad setenv, environment variable only has value \"" + s + "\"")
	}
	os.Unsetenv("FOO")
	s = C.GoString(C.getenv(C.CString("FOO")))
	if s != "" {
		panic("bad unsetenv, environment variable still has value \"" + s + "\"")
	}

	r1, _, _ := syscall_syscall(abi.FuncPCABI0(libc_gai_strerror_trampoline),
		uintptr(ecode),
		0, 0)
	return GoString((*byte)(unsafe.Pointer(r1)))
}

// Implemented in the runtime package.
func gostring(*byte) string

func GoString(p *byte) string {
	return gostring(p)
}

//go:linkname syscall_syscall syscall.syscall
func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno)

// such as [Print].
type Stringer interface {
	String() string
}

// GoStringer is implemented by any value that has a GoString method,
// which defines the Go syntax for that value.
// The GoString method is used to print values passed as an operand
// to a %#v format.
type GoStringer interface {
	GoString() string
}

// FormatString returns a string representing the fully qualified formatting

        assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
        assertEquals("1.4", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
        assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
        restriction = restrictions.get(2);
        assertEquals("1.5", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);

            build.run()
        }

        then:
        stdout.toString().contains('this is stdout')
        stdout.toString().contains('A warning using SLF4j')
        stdout.toString().contains('A warning using JCL')
        stdout.toString().contains('A warning using Log4j')
        stdout.toString().contains('A warning using JUL')
        if (targetVersion.baseVersion >= GradleVersion.version('4.7')) {

        container.size == 1
        container.popConflict().toString() == "b:1,2"
    }

    def "contains multiple conflicting elements"() {
        container.newElement("a", [1, 2], null)
        container.newElement("b", [3, 4], null)
        expect:
        container.size == 2
        container.popConflict().toString() == "a:1,2"
        container.popConflict().toString() == "b:3,4"
    }

    def "pops conflicts orderly"() {

        new NamedWithToString(name: null)    | "toString():null"
        new NamedWithToString(name: "Lajos") | "toString():Lajos"
    }

    def "returns '#expected' when toString() returns #toStringReturns"() {
        def value = Mock(Object)

        when:
        def result = RendererUtils.displayValueOf(value)

        then:
        result == expected
        _ * value.toString() >> toStringReturns

        where: