loggingManager.addStandardErrorListener(listener)
        loggingManager.start()

        when:
        def nestedManager = registry.newInstance(LoggingManagerInternal)
        nestedManager.captureStandardError(LogLevel.INFO)
        nestedManager.captureStandardOutput(LogLevel.DEBUG)
        nestedManager.start()

        System.out.println("info")
        System.err.println("error")

        then:

func (filter FilterRule) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	if filter.isEmpty() {
		return nil
	}
	type filterRuleWrapper FilterRule
	return e.EncodeElement(filterRuleWrapper(filter), start)
}

// UnmarshalXML - decodes XML data.
func (filter *FilterRule) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	// Make subtype to avoid recursive UnmarshalXML().

            this.andx = null;

            dst[ start + ANDX_COMMAND_OFFSET ] = (byte) 0xFF;
            dst[ start + ANDX_RESERVED_OFFSET ] = (byte) 0x00;
            // dst[start + ANDX_OFFSET_OFFSET] = (byte)0x00;
            // dst[start + ANDX_OFFSET_OFFSET + 1] = (byte)0x00;
            dst[ start + ANDX_OFFSET_OFFSET ] = (byte) 0xde;
            dst[ start + ANDX_OFFSET_OFFSET + 1 ] = (byte) 0xde;

    private int port

    @Override
    protected void after() {
        stop()
    }

    void start() {
        start(new SocksServer())
    }

    void start(SocksServer socksServer) {
        assert port > 0
        this.socksServer = socksServer
        socksServer.start(port)
        println(this)
    }

    void configureProxy(GradleExecuter executer) {
        if (port == 0) {

    }

    def "logs start of overall operation"() {
        when:
        log.start()
        then:
        logOutput() == """See $pathToLogStr for all output for <testTask>.
"""
        cleanup:
        log.done()
    }

    def "logs completion of operation"() {
        given:
        log.start()
        when:
        log.operationSuccess("<operation>", "<output>")

}

// unmarshalInterface unmarshals a single XML element into val.
// start is the opening tag of the element.
func (d *Decoder) unmarshalInterface(val Unmarshaler, start *StartElement) error {
	// Record that decoder must stop at end tag corresponding to start.
	d.pushEOF()

	d.unmarshalDepth++
	err := val.UnmarshalXML(d, *start)
	d.unmarshalDepth--
	if err != nil {
		d.popEOF()
		return err
	}

| `minio_node_scanner_bucket_scans_started`  | Total number of bucket scans started since server start.    |
| `minio_node_scanner_directories_scanned`   | Total number of directories scanned since server start.     |
| `minio_node_scanner_objects_scanned`       | Total number of unique objects scanned since server start.  |

      }
      return result;
    }

    @Override
    public long distance(Long start, Long end) {
      long result = end - start;
      if (end > start && result < 0) { // overflow
        return Long.MAX_VALUE;
      }
      if (end < start && result > 0) { // underflow
        return Long.MIN_VALUE;
      }
      return result;
    }

    @Override

        mod2.pom.expectGet()
        mod2.artifact.expectGet()

        // Start build 1 then wait until it has run task 'a'.
        executer.withTasks("a", "block1", "b")
        executer.withArgument("--info")
        def build1 = executer.start()
        block1.waitForAllPendingCalls()

        // Start build 2 then wait until it has run both 'a' and 'b'.
        executer.withTasks("a", "b", "block2")

import "runtime"

type big [10 << 20]byte

func f(x *big, start int64) {
	if delta := inuse() - start; delta < 9<<20 {
		println("after alloc: expected delta at least 9MB, got: ", delta)
	}
	runtime.KeepAlive(x)
	x = nil
	if delta := inuse() - start; delta > 1<<20 {
		println("after drop: expected delta below 1MB, got: ", delta)
	}
	x = new(big)
	if delta := inuse() - start; delta < 9<<20 {