case <-timeout:
			srvErr <- fmt.Errorf("server: timeout waiting for connection to close")
			return
		case <-srvSPDYConn.CloseChan():
		}

		// Count pings sent by the server.
		gotPings := atomic.LoadInt64(&pingsSent)
		if gotPings < 1 {
			t.Errorf("server: failed to send any pings (check logs)")
		}
	}()

	// Set up client connection.
	clConn, err := net.Dial("tcp4", listener.Addr().String())
	if err != nil {

			}

			gotKinds := []string{}
			for gvk := range gvkmap {
				gotKinds = append(gotKinds, gvk.Kind)
			}

			sort.Strings(gotKinds)

			if !reflect.DeepEqual(gotKinds, test.expectedKinds) {
				t.Fatalf("kinds not matching:\n\texpectedKinds: %v\n\tgotKinds: %v\n", test.expectedKinds, gotKinds)
			}
		})
	}

import org.gradle.tooling.model.eclipse.EclipseProject

@TargetGradleVersion('>=3.1')
class ToolingApiEclipseModelCrossVersionSpec extends ToolingApiSpecification {

    def "Eclipse model can contain GStrings"() {
        given:
        buildFile << """
            apply plugin: 'eclipse'
            eclipse {
                project {
                    name = "\${'root'}"

// load/store on ppc64/ppc64le causes assembler error.

// Test other 8 byte loads and stores where the
// compile time offset is not aligned to 8, as
// well as cases where the offset is not known
// until link time (e.g. gostrings).

package main

import (
	"fmt"
)

type T struct {
	x [4]byte
	y [8]byte
}

var st T

const (
	gostring1 = "abc"
	gostring2 = "defghijk"
	gostring3 = "lmnopqrs"
)

        1 * selectedChild.store(searchedPath.pathFromChild(selectedChildPath), CASE_SENSITIVE, snapshot, diffListener) >> updatedChild
    }

    def "querying the snapshot for non-existing child #vfsSpec.searchedPath finds nothings (#vfsSpec)"() {
        setupTest(vfsSpec)

        when:
        def resultRoot = initialRoot.getSnapshot(searchedPath, CASE_SENSITIVE)
        then:
        !resultRoot.present

        compileOptions.fork = false
        compileOptions.define(debug: true)

        expect:
        compileOptions.debug
        !compileOptions.fork
    }

    def "converts GStrings to Strings when getting all compiler arguments"() {
        given:
        compileOptions.compilerArgs << "Foo${23}"

        expect:
        compileOptions.allCompilerArgs.contains('Foo23')
    }

        return hasExtension(input, ".java");
    }

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

    private void logSourceFiles(JavaCompileSpec spec) {

    }
}

abstract class MyWorkerTask
@Inject constructor(private var workerExecutor: WorkerExecutor) : DefaultTask() {
    @get:Input
    abstract val booleanFlag: Property<Boolean>
    @TaskAction
    fun doThings() {
        workerExecutor.noIsolation().submit(MyWorkAction::class.java) {}
    }
}

tasks.register("myWorkTask", MyWorkerTask::class) {}
// end::worker-executor[]

// tag::file-system[]

            LOGGER.debug("Class path: {}", spec.getCompileClasspath());
        }
    }

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

    private void logSourceFiles(ScalaJavaJointCompileSpec spec) {

            }
        });

        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) {