assertTrue(bf2.mightContain(element2));

    assertTrue(bf1.isCompatible(bf2));
    bf1.putAll(bf2);
    assertTrue(bf1.mightContain(element1));
    assertTrue(bf1.mightContain(element2));
    assertFalse(bf2.mightContain(element1));
    assertTrue(bf2.mightContain(element2));
  }

  public void testPutAllDifferentSizes() {
    BloomFilter<Integer> bf1 = BloomFilter.create(Funnels.integerFunnel(), 1);

        }

        int off = this.handle.recv(buf, 0, buf.length);
        if (buf[0] != 5 || buf[1] != 0) {
            throw new IOException("Unexpected DCERPC PDU header");
        }

        final int length = Encdec.dec_uint16le(buf, 8);
        if (length > getMaxRecv()) {
            throw new IOException("Unexpected fragment length: " + length);
        }

        while (off < length) {

		if o.prefixAll != "" {
			name = pathJoin(o.prefixAll, name)
		}

		// Do small files async
		n++
		if header.Size <= xioutil.MediumBlock {
			asyncWriters <- struct{}{}
			bufp := xioutil.ODirectPoolMedium.Get()
			b := (*bufp)[:header.Size]
			if _, err := io.ReadFull(tarReader, b); err != nil {
				return err
			}
			wg.Add(1)
			go func(name string, fi fs.FileInfo, b []byte) {

        final StringBuilder buf = new StringBuilder(1000);

        buf.append("[SYSTEM MONITOR] ");
        buf.append('{');

        appendOsStats(buf);
        appendProcessStats(buf);
        appendJvmStats(buf);
        appendFesenStats(buf);

        appendTimestamp(buf);
        buf.append('}');

        if (logger.isInfoEnabled()) {
            logger.info(buf.toString());
        }
    }

        monitorTarget.appendException(buf, exception);
        assertTrue(buf.toString().contains("Special test exception"));
    }

    // Test multiple appends to the same buffer
    public void test_multipleAppends() {
        StringBuilder buf = new StringBuilder();

        monitorTarget.append(buf, "key1", () -> "value1");
        buf.append(",");
        monitorTarget.append(buf, "key2", () -> 123);

func TestEncodeDecodeRStat(t *testing.T) {
	v := RStat{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeRStat Msgsize() is inaccurate")
	}

	vn := RStat{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

     */
    protected void write(final String text, final String contentType, final String encoding) {
        final StringBuilder buf = new StringBuilder(50);
        if (contentType == null) {
            buf.append("text/plain");
        } else {
            buf.append(contentType);
        }
        buf.append("; charset=");
        final String enc;
        if (encoding == null) {

func genLine(buf *bytes.Buffer, lineNum, n int, addNewline bool) {
	buf.Reset()
	doCR := lineNum%5 == 0
	if doCR {
		n--
	}
	for i := 0; i < n-1; i++ { // Stop early for \n.
		c := 'a' + byte(lineNum+i)
		if c == '\n' || c == '\r' { // Don't confuse us.
			c = 'N'
		}
		buf.WriteByte(c)
	}
	if addNewline {
		if doCR {
			buf.WriteByte('\r')
		}
		buf.WriteByte('\n')
	}
}

     */
    private void buildHeader(byte[] buf, int start, int status, int command, long sessionId) {
        System.arraycopy(SMBUtil.SMB2_HEADER, 0, buf, start, SMBUtil.SMB2_HEADER.length);
        // Status at +8
        SMBUtil.writeInt4(status, buf, start + 8);
        // Command at +12
        SMBUtil.writeInt2(command, buf, start + 12);
        // Flags at +16: server-to-redirector

            }
        }
        if (buf.indexOf("MM") == -1) {
            final int pos = buf.indexOf("M");
            if (pos != -1) {
                buf.replace(pos, pos + 1, "MM");
            }
        }
        if (buf.indexOf("dd") == -1) {
            final int pos = buf.indexOf("d");
            if (pos != -1) {
                buf.replace(pos, pos + 1, "dd");
            }