when:
        twoStageArtifactsCache.get(key)

        then:
        1 * writeCache.get(key) >> Stub(AbstractArtifactsCache.ModuleArtifactsCacheEntry)
        0 * readCache.get(key)
    }

    def "writes are delegated to the writable cache"() {
        def entry = Stub(AbstractArtifactsCache.ModuleArtifactsCacheEntry)
        when:
        twoStageArtifactsCache.store(key, entry)

        then:

    <T extends BlockPayload> T read(BlockPointer pos, Class<T> payloadType);

    /**
     * Writes a block to this store, adding the block if required.
     */
    void write(BlockPayload block);

    /**
     * Adds a new block to this store. Allocates space for the block, but does not write the contents of the block
     * until {@link #write(BlockPayload)} is called.
     */
    void attach(BlockPayload block);

    /**

// with blank (_) field names.
func Write(w io.Writer, order ByteOrder, data any) error {
	// Fast path for basic types and slices.
	if n, bs := intDataSize(data); n != 0 {
		if bs == nil {
			bs = make([]byte, n)
			encodeFast(bs, order, data)
		}

		_, err := w.Write(bs)
		return err
	}

	// Fallback to reflect-based encoding.
	v := reflect.Indirect(reflect.ValueOf(data))

 * under the License.
 */
package org.apache.maven.api.services.xml;

import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.plugin.descriptor.PluginDescriptor;

/**
 * Reads and writes a {@link PluginDescriptor} object to/from XML.
 *
 * @since 4.0.0
 */
@Experimental

        when:
        new SimpleTemplateOperation(new URL("file://some/file"), null, [:])
        then:
        def e = thrown(BuildInitException)
        e.message == "Target file must not be null"
    }

    def "writes file from template with binding support"() {
        setup:
        def targetFile = new File(temporaryFolder, "test.out")
        def templateURL = getClass().getResource("SimpleTemplateOperationSpec-binding.template")

		t.Fatalf("failed to start tracing: %v", err)
	}
	Stop()
	size := buf.Len()
	if size == 0 {
		t.Fatalf("trace is empty")
	}
	time.Sleep(100 * time.Millisecond)
	if size != buf.Len() {
		t.Fatalf("trace writes after stop: %v -> %v", size, buf.Len())
	}
	saveTrace(t, buf, "TestTraceStartStop")
}

func TestTraceDoubleStart(t *testing.T) {
	if IsEnabled() {
		t.Skip("skipping because -test.trace is set")
	}
	Stop()

	// Insert the pointer to the type itself.
	id, _ := t.tab.put(noescape(unsafe.Pointer(&typ)), goarch.PtrSize)
	return id
}

// dump writes all previously cached types to trace buffers and
// releases all memory and resets state. It must only be called once the caller
// can guarantee that there are no more writers to the table.
func (t *traceTypeTable) dump(gen uintptr) {
	w := unsafeTraceExpWriter(gen, nil, traceExperimentAllocFree)

	})
}

// EmitTextual writes the accumulated coverage data in the legacy
// cmd/cover text format to the writer 'w'. We sort the data items by
// importpath, source file, and line number before emitting (this sorting
// is not explicitly mandated by the format, but seems like a good idea
// for repeatable/deterministic dumps).
func (fm *Formatter) EmitTextual(w io.Writer) error {
	if fm.cm == coverage.CtrModeInvalid {

pluginManagement {
    plugins {
        id "biz.aQute.bnd.builder" version "${TestedVersions.bnd}"
    }
}

rootProject.name = 'bnd-smoke-test'
"""
    }

    def "BND plugin writes direct external dependency versions to the manifest"() {
        given:
        def commonsVersion = "3.12.0"
        def calculatedCommonsVersionRange = "[3.12,4)"
        buildFile << """
${addBNDBuilderPlugin()}

			return err
		}
	}
	s.trim(nil)
	return p.cachedWriteError()
}

// Write implements io.Writer
func (p *printer) Write(b []byte) (n int, err error) {
	if p.closed && p.err == nil {
		p.err = errors.New("use of closed Encoder")
	}
	if p.err == nil {
		n, p.err = p.w.Write(b)
	}
	return n, p.err
}

// WriteString implements io.StringWriter