fmt.Printf("%q: {%d, %d}\n", q.Name, *q.X, *q.Y)
	err = dec.Decode(&q)
	if err != nil {
		log.Fatal("decode error 2:", err)
	}
	fmt.Printf("%q: {%d, %d}\n", q.Name, *q.X, *q.Y)

	// Output:
	// "Pythagoras": {3, 4}
	// "Treehouse": {1782, 1841}

import org.junit.Assume
import spock.lang.Issue

class ToolingApiIdeaLocalGroovyCrossVersionSpec extends ToolingApiSpecification {

    @Issue("https://github.com/gradle/gradle/issues/12274")
    @TargetGradleVersion(">=3.4")
    def "resolves localGroovy() as IdeaSingleEntryLibraryDependency for IdeaProject via tooling API"() {
        given:

    def setup() {
        buildFile << """
            task noSourceTask(type:Copy) {
                from("notexist")
                into("notexisteither")
            }"""
    }

    @TargetGradleVersion('>=3.4')
    def "tasks with no source is reported as NO-SOURCE"() {
        when:
        def taskEvents = ProgressEvents.create()
        runBuild(taskEvents)
        then:

import javax.inject.Inject;

/**
 * <p>A {@link Plugin} which extends the capabilities of the {@link JavaPlugin Java plugin} by cleanly separating
 * the API and implementation dependencies of a library.</p>
 *
 * @since 3.4
 * @see <a href="https://docs.gradle.org/current/userguide/java_library_plugin.html">Java Library plugin reference</a>
 */
public abstract class JavaLibraryPlugin implements Plugin<Project> {

    @Inject

            assert str.readByte() == 1
            assert str.readBoolean() != dirty
            // info version + port, lock-id, pid, operation-name
            assert str.readByte() == 3
            assert str.readInt() == 34
            assert str.readLong() == 678L
            assert str.readUTF() == processIdentifier
            assert str.readUTF() == operationalName
            assert str.read() < 0
        }
    }

import org.gradle.util.internal.DefaultGradleVersion.Stage
import spock.lang.Specification

class StageTest extends Specification {
    def "builds simple stage"() {
        when:
        def s = Stage.from(3, "4")

        then:
        s.stage == 3
        s.number == 4
    }

    def "builds stage with patch no"() {
        when:
        def s = Stage.from(3, "4a")

        then:
        s.stage == 3

import org.gradle.api.Action;
import org.gradle.api.tasks.Input;

import java.util.List;

/**
 * The violation rules configuration for the {@link org.gradle.testing.jacoco.tasks.JacocoReport} task.
 *
 * @since 3.4
 */
public interface JacocoViolationRulesContainer {

    /**
     * Indicates whether build should fail in case of rule violation.
     *
     * @param ignore Only render violation but do not fail build
     */

	assert(f(S{3, 5}, S{3, 5}))
	assert(!f(S{3, 5}, S{4, 6}))
	assert(g(S{3, 5}, S{3, 5}))
	assert(!g(S{3, 5}, S{4, 6}))

	assert(k(3, struct{ a, b int }{3, 3}))
	assert(!k(3, struct{ a, b int }{3, 4}))
}

func assert(b bool) {
	if !b {
		panic("assertion failed")
	}

	MOVL	dig+0(FP),	BP
	MOVL	p+4(FP),	SI
	MOVL	p_len+8(FP),	DX
	SHRL	$6,		DX
	SHLL	$6,		DX

	LEAL	(SI)(DX*1),	DI
	MOVL	(0*4)(BP),	AX
	MOVL	(1*4)(BP),	BX
	MOVL	(2*4)(BP),	CX
	MOVL	(3*4)(BP),	DX
	MOVL	(4*4)(BP),	BP

	CMPL	SI,		DI
	JEQ	end

	MOVL	DI,	84(SP)

loop:
	MOVL	SI,	88(SP)

	MOVL	AX,	64(SP)
	MOVL	BX,	68(SP)
	MOVL	CX,	72(SP)
	MOVL	DX,	76(SP)

0: 5
34:			a := y
35:			f1(a)
37:				b := 0
38:				f2(b)
39:				if gretbool() {
40:					c := 0
41:					f3(c)
46:				f5(b)
48:			f6(a)
33:		for x := 0; x <= 1; x++ { // From delve scopetest.go
34:			a := y
35:			f1(a)
37:				b := 0
38:				f2(b)
39:				if gretbool() {
43:					c := 1.1
44:					f4(int(c))
46:				f5(b)
48:			f6(a)
33:		for x := 0; x <= 1; x++ { // From delve scopetest.go
53:				j = id(1)