extern unsigned char *GoFn22();`,
		support: `//export GoFn22
		          func GoFn22() *byte { return (*byte)(C.malloc(1)) }`,
		body: `C.GoFn22()`,
	},
	{
		// Passing a Go string is fine.
		name: "passstring",
		c: `#include <stddef.h>
		    typedef struct { const char *p; ptrdiff_t n; } gostring23;
		    gostring23 f23(gostring23 s) { return s; }`,
		imports: []string{"unsafe"},

import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody

class PostString {
  private val client = OkHttpClient()

  fun run() {
    val postBody =
      """
      |Releases
      |--------
      |
      | * _1.0_ May 6, 2013
      | * _1.1_ June 15, 2013

	}
	for i, tc := range validCases {
		err := p.ParseString(tc, &id)
		if err != nil {
			t.Fatalf("%d: %v", i, err)
		}
		// repr.Println(id, repr.Indent("  "), repr.OmitEmpty(true))
	}

	invalidCases := []string{
		"+a",
		"-a",
		"1a",
		`"ab`,
		`abc"`,
		`aa""a`,
		`"a"a"`,
	}
	for i, tc := range invalidCases {
		err := p.ParseString(tc, &id)
		if err == nil {

package org.gradle.nativeplatform.internal;

import org.apache.commons.io.FilenameUtils;
import org.gradle.internal.file.RelativeFilePathResolver;

import java.io.File;

import static org.gradle.internal.hash.Hashing.hashString;

public class CompilerOutputFileNamingScheme {
    private String objectFileNameSuffix;
    private File outputBaseFolder;
    private final RelativeFilePathResolver fileResolver;

	time.Sleep(100 * time.Millisecond)
	ps.Lock()
	if len(ps.subs) != 1 {
		t.Fatal("expected 1 subscriber")
	}
	ps.Unlock()
	close(doneCh2)
}

type maskString string

func (m maskString) Mask() uint64 {
	return 1
}

func TestPubSub(t *testing.T) {
	ps := New[Maskable, Maskable](1)
	ch1 := make(chan Maskable, 1)
	doneCh1 := make(chan struct{})
	defer close(doneCh1)

    val compiledScriptTypeName by lazy {
        packagePrefixed(scriptClassNameForFile(scriptFile))
    }

    val packageName: String? by lazy {
        packageNameOf(scriptText)
    }

    val hashString by lazy {
        PrecompiledScriptDependenciesResolver.hashOfNormalisedString(scriptText)
    }

    val scriptText: String
        get() = convertLineSeparatorsToUnix(scriptFile.readText())

    private

            return super.hashCode();
        }
        StringBuilder hashString = new StringBuilder(128);
        hashString.append(md.groupId).append('|');
        hashString.append(md.artifactId).append('|');

        if (compareVersion) {
            hashString.append(md.version).append('|');
        }

        if (compareScope) {
            hashString.append(md.getArtifactScope()).append('|');
        }

        actions {}

        when:
        visit()

        then:
        2 * delegateAction.processFile({ it.relativePath.pathString == '/root/path/file1.txt' })
        1 * delegateAction.processFile({ it.relativePath.pathString == '/root/path/file2.txt' })
    }

    def duplicatesExcludedByPerFileConfiguration() {
        given:
        files 'path/file1.txt', 'path/file2.txt', 'path/file1.txt'

        when:
        executer.execute(copySpec, copyAction)

        then:
        1 * action.processFile({ it.relativePath.pathString == "a" })
        0 * action.processFile(_)
    }

    Closure path(path) {
        return { println it.relativePath.pathString; it.relativePath.pathString == path }
    }

    val properties = propertiesSupplier.get()
    for (p in properties) {
        when (jvmSignature) {
            p.fieldSignature?.asString() -> return predicate(p.flags)
            p.getterSignature?.asString() -> return predicate(p.getterFlags)
            p.setterSignature?.asString() -> return predicate(p.setterFlags)
        }
    }
    return false