StreamUtil.split(overrides, "\n").of(stream -> stream.filter(StringUtil::isNotBlank).forEach(s -> {
                final String[] values = StringUtils.split(s, "=", 2);
                if (values.length == 2) {
                    map.put(values[0].trim(), values[1].trim());
                }
            }));
            setExtensionMimeTypeMap(map);
            if (logger.isDebugEnabled()) {

            setAttribute(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "")
        }.newDocumentBuilder()
            .parse(url)
            .getElementsByTagName("version").let { versions ->
                (0 until versions.length)
                    .map { idx -> (versions.item(idx) as Element).textContent }
                    .reversed()
            }

    protected
    fun updateProperties(populateProperties: Properties.() -> Unit) =

        Objects.requireNonNull(model, "model cannot be null");

        String encoding = model.getModelEncoding();
        // TODO Use StringUtils here
        if (encoding == null || encoding.length() <= 0) {
            encoding = "UTF-8";
        }

        try (Writer out = new OutputStreamWriter(output, encoding)) {
            write(out, options, model);
        }
    }

# Usage

```go
package main

import (
	"fmt"

	"github.com/smallnest/ringbuffer"
)

func main() {
	rb := ringbuffer.New(1024)

	// write
	rb.Write([]byte("abcd"))
	fmt.Println(rb.Length())
	fmt.Println(rb.Free())

	// read
	buf := make([]byte, 4)
	rb.Read(buf)
	fmt.Println(string(buf))
}
```

It is possible to use an existing buffer with by replacing `New` with `NewBuffer`.

        sb.append(dm).append(teletexTerminalIdentifier);
        sb.append(dm).append(title);
        sb.append(dm).append(uidNumber);
        sb.append(dm).append(x121Address);
        if (sb.length() > dm.length()) {
            sb.delete(0, dm.length());
        }
        sb.insert(0, "{").append("}");
        return sb.toString();
    }

    // ===================================================================================

        rpc.sid_t s = new rpc.sid_t();
        s.revision = revision;
        s.sub_authority_count = (byte) subs.length;
        s.identifier_authority = Arrays.copyOf(identAuth, 6);
        s.sub_authority = Arrays.copyOf(subs, subs.length);
        return s;
    }

    @Nested
    @DisplayName("Basic Constructor and Utility Tests")
    class BasicTests {

        @Test

    @Override
    int writeParametersWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int writeDataWireFormat(final byte[] dst, final int dstIndex) {
        if (dst.length - dstIndex < pipeDataLen) {
            if (LogStream.level >= 3) {
                log.println("TransTransactNamedPipe data too long for buffer");
            }
            return 0;
        }

        String result = scoreUpdater.execute();

        // Check format with class name, colon, count, and newline
        String[] lines = result.split("\n");
        assertEquals(2, lines.length);
        assertTrue(lines[0].matches("TestScoreBooster : \\d+"));
        assertTrue(lines[1].matches("TestScoreBooster : \\d+"));
    }

    // Test with null pointer exception
    @Test

        HashMap<String, LifecyclePhase> defaultBindings = null;
        if (pluginBindings != null) {
            final int len = pluginBindings.length;

            if (len < 2 || len % 2 != 0) {
                throw new IllegalArgumentException("Plugin bindings must have more than 0, even count of elements");
            }

        Object proxy, Method method, @Nullable Object[] args) {
      Invokable<?, ?> invokable = interfaceType.method(method);
      ImmutableList<Parameter> params = invokable.getParameters();
      for (int i = 0; i < args.length; i++) {
        Parameter param = params.get(i);
        if (!isNullable(param)) {
          checkNotNull(args[i]);
        }
      }