if err != nil {
				t.Fatal(err)
			}
			called := false
			op := func(uintptr) bool {
				called = true
				return true
			}
			err = cc.Write(op)
			if err == nil {
				t.Error("Write should return an error")
			}
			if called {
				t.Error("Write shouldn't call op")
			}
			called = false
			err = cc.Read(op)
			if err == nil {
				t.Error("Read should return an error")
			}
			if called {

    def testWriteNullValue() {
        when:
        booleanOption.write(writerContextMock)

        then:
        0 * _._
    }

    def testWriteFalseValue() throws IOException {
        booleanOption.setValue(false)

        when:
        booleanOption.write(writerContextMock)

        then:
        0 * _._
    }

    def testWriteTrueValue() throws IOException {

        this.resultsFile = new File(resultsDir, "results.bin");
    }

    public void write(Collection<TestClassResult> results) {
        try {
            OutputStream outputStream = new FileOutputStream(resultsFile);
            try {
                if (!results.isEmpty()) { // only write if we have results, otherwise truncate
                    FlushableEncoder encoder = new KryoBackedEncoder(outputStream);

// because while ptr does not escape, new does.
// If new is marked as not escaping, the compiler will make incorrect
// escape analysis decisions about the pointer value being stored.

// atomicwb performs a write barrier before an atomic pointer write.
// The caller should guard the call with "if writeBarrier.enabled".
//
// atomicwb should be an internal detail,
// but widely used packages access it using linkname.

	// Try to stop the kubelet service so no race conditions occur when configuring it
	if !data.DryRun() {
		klog.V(1).Infoln("Stopping the kubelet")
		kubeletphase.TryStopKubelet()
	}

	// Write env file with flags for the kubelet to use. We do not need to write the --register-with-taints for the control-plane,
	// as we handle that ourselves in the mark-control-plane phase

    }

    def "setting plain text to the label will only write the text to ansi"() {
        given:
        label.text = "text"

        when:
        redraw()

        then:
        1 * ansi.a("text")
        0 * ansi._
    }

    def "setting styled text (emphasis only) to the label will change the style and write the text to ansi"() {
        given:

        }

        @Override
        public void write(Encoder encoder, ClassAnalysis value) throws Exception {
            encoder.writeString(value.getClassName());
            encoder.writeNullableString(value.getDependencyToAllReason());
            stringSetSerializer.write(encoder, value.getPrivateClassDependencies());
            stringSetSerializer.write(encoder, value.getAccessibleClassDependencies());

	}
	if err := binary.Write(w, binary.LittleEndian, mh); err != nil {
		return digest, fmt.Errorf("error writing meta-file header: %v", err)
	}
	off := int64(coverage.CovMetaHeaderSize)

	// Write function offsets section
	off = b.emitFuncOffsets(w, off)

	// Check for any errors up to this point.
	if b.werr != nil {
		return digest, b.werr
	}

	// Write string table.

        def writer = stateful.newWriter(encoder)

        when:
        def result1 = reader.read()
        def result2 = reader.read()

        then:
        result1 == "one"
        result2 == "two"
        1 * serializer.read(decoder) >> "one"
        1 * serializer.read(decoder) >> "two"
        0 * serializer._

        when:
        writer.write("one")
        writer.write("two")

                start {
                    100.times {
                        outstr.write('write '.getBytes())
                        outstr.print(it)
                        outstr.println()
                    }
                }
            }
        }

        then:
        output.size() == 1000
        output.findAll({!it.matches('write \\d+<EOL>')}).empty
    }

    def flushForwardsBufferedText() {