func RegisterDecompressor(method uint16, dcomp Decompressor) {
	if _, dup := decompressors.LoadOrStore(method, dcomp); dup {
		panic("decompressor already registered")
	}
}

// RegisterCompressor registers custom compressors for a specified method ID.
// The common methods [Store] and [Deflate] are built in.
func RegisterCompressor(method uint16, comp Compressor) {

        then:
        model.wtp.component == component
        model.wtp.facet == facet
        model.wtp.facet.facets.empty

        when: "configure wtp component and facet"
        model.wtp.component({ comp -> comp.deployName = 'name' } as Action<EclipseWtpComponent>)
        model.wtp.facet({ fac -> fac.facets.add(new Facet()) } as Action<EclipseWtpFacet>)

        then:
        model.wtp.component.deployName == 'name'

  x:U:1 -> x:U:1 - Could not resolve x:U:1.
"""
    }

    private void node(String module, ComponentSelectionReason reason = ComponentSelectionReasons.requested()) {
        DummyModuleVersionSelection moduleVersion = comp(module, reason)
        builder.startVisitComponent(moduleVersion.resultId, moduleVersion.selectionReason, "repo")
        builder.visitComponentDetails(moduleVersion.componentId, moduleVersion.moduleVersion)

		if err != nil {
			return nil, err
		}

		// Pick output column names
		if expr.As != "" {
			output, err = output.Set(expr.As, v)
		} else if comp, ok := getLastKeypathComponent(expr.Expression); ok {
			output, err = output.Set(comp, v)
		} else {
			output, err = output.Set(fmt.Sprintf("_%d", i+1), v)
		}
		if err != nil {
			return nil, err
		}
	}

	// Update count of records output.

        app.library.headerFiles*.writeToDir(file("src/helloApi"))
        app.library.sourceFiles*.writeToDir(file("src/hello"))

        and:
        buildFile << """
model {
    components { comp ->
        helloApi(NativeLibrarySpec)
        hello(NativeLibrarySpec) {
            sources {
                cpp.lib ${notation}
            }
        }
        main(NativeExecutableSpec) {
            sources {

                "--add-opens", "jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
                "--add-opens", "jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
                "--add-opens", "jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED",
                "--add-opens", "jdk.compiler/com.sun.tools.javac.jvm=ALL-UNNAMED",
                "--add-opens", "jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED",

        def lines = process.inputStream.readLines()
        return lines.findAll { it.contains(' | ') }.collect { line ->
            // Looks like:
            // 000 0105673E ABS    notype       Static       | @comp.id
            // 001 80000191 ABS    notype       Static       | @feat.00
            // 002 00000000 SECT1  notype       Static       | .drectve
            // 005 00000000 SECT2  notype       Static       | .debug$S

               .attribute(Attribute.of("test.attribute", String), "value")

            class MySoftwareComponent implements org.gradle.api.internal.component.SoftwareComponentInternal {
                String name = 'comp'
                Set<org.gradle.api.internal.component.UsageContext> getUsages() {
                    return Collections.emptySet()
                }
            }

	{
		"gif;LSB;8",
		"\x28\xff\xff\xff\x28\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
		"\x00\x51\xfc\x1b\x28\x70\xa0\xc1\x83\x01\x01",
		nil,
	},
	// This example comes from http://compgroups.net/comp.lang.ruby/Decompressing-LZW-compression-from-PDF-file
	{
		"pdf;MSB;8",
		"-----A---B",
		"\x80\x0b\x60\x50\x22\x0c\x0c\x85\x01",
		nil,
	},
}

func TestReader(t *testing.T) {
	var b bytes.Buffer

	}
	defer f.Close()

	err = checkFileIsNotPartOfNetpoll(f)
	if err != nil {
		t.Fatal(err)
	}
}

func TestSerialFdsAreInitialised(t *testing.T) {
	for _, name := range []string{"COM1", "COM2", "COM3", "COM4"} {
		t.Run(name, func(t *testing.T) {
			h, err := syscall.CreateFile(syscall.StringToUTF16Ptr(name),
				syscall.GENERIC_READ|syscall.GENERIC_WRITE,
				0,
				nil,
				syscall.OPEN_EXISTING,