byte[] buf = new byte[] {'y', 'a', 'm', 's'};
    HashingOutputStream out = new HashingOutputStream(hashFunction, buffer);
    out.write(buf);

    verify(hashFunction).newHasher();
    verify(hasher).putBytes(buf, 0, buf.length);
    verifyNoMoreInteractions(hashFunction, hasher);
  }

  public void testWrite_putByteArrayAtPos() throws Exception {
    byte[] buf = new byte[] {'y', 'a', 'm', 's'};

	// Calculate the size of the bitrot file and compare
	// it with the actual file size.
	if left != bitrotShardFileSize(partSize, shardSize, algo) {
		return errFileCorrupt
	}

	bufp := xioutil.ODirectPoolSmall.Get()
	defer xioutil.ODirectPoolSmall.Put(bufp)

	for left > 0 {
		// Read expected hash...
		h.Reset()
		n, err := io.ReadFull(r, hashBuf)
		if err != nil {

                                buf.append("<input type=\"hidden\" name=\"");
                                buf.append(StringEscapeUtils.escapeHtml4(name));
                                buf.append("\" value=\"");
                                buf.append(StringEscapeUtils.escapeHtml4(value));
                                buf.append("\"/>");
                            }
                        }

      h ^= fingerprint(buf, bufLen);
      h = remix(h);
      buf[bufLen++] = getChar(h);

      int x0 = buf[bufLen - 1] & 0xff;
      int x1 = buf[bufLen - 2] & 0xff;
      int x2 = buf[bufLen - 3] & 0xff;
      int x3 = buf[bufLen / 2] & 0xff;
      buf[((x0 << 16) + (x1 << 8) + x2) % bufLen] ^= x3;
      buf[((x1 << 16) + (x2 << 8) + x3) % bufLen] ^= i % 256;
    }

// the incoming AWS Signature V4 streaming signature.
func (cr *s3UnsignedChunkedReader) Read(buf []byte) (n int, err error) {
	// First, if there is any unread data, copy it to the client
	// provided buffer.
	if cr.offset > 0 {
		n = copy(buf, cr.buffer[cr.offset:])
		if n == len(buf) {
			cr.offset += n
			return n, nil
		}
		cr.offset = 0
		buf = buf[n:]
	}
	// mustRead reads from input and compares against provided slice.

                break;
            case ':':
                buf.append("%3a");
                break;
            case '/':
                buf.append("%2f");
                break;
            default:
                buf.append(c);
                break;
            }
        }
        return buf.toString();
    }

    /**

    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 = 0;
        assertEquals(65535, SMBUtil.readInt2(buf, off));
        off += 2;
        assertEquals(65535, SMBUtil.readInt2(buf, off));
        off += 2;
        assertEquals(0, SMBUtil.readInt2(buf, off));
        off += 2;
        assertEquals(0x12345678, SMBUtil.readInt4(buf, off));
        off += 4;
        assertEquals(blob.length, SMBUtil.readInt2(buf, off));
    }

                return resp.getResponseLength();
            }
            final SmbPipeOutputStream out = getOutput();
            final SmbPipeInputStream in = getInput();
            out.write(buf, off, length);
            return in.read(inB);
        }
    }

    @Override

	headerVer, metaVer uint
}

func decodeXLHeaders(buf []byte) (x xlHeaders, b []byte, err error) {
	x.headerVer, buf, err = msgp.ReadUintBytes(buf)
	if err != nil {
		return x, buf, err
	}
	x.metaVer, buf, err = msgp.ReadUintBytes(buf)
	if err != nil {
		return x, buf, err
	}
	if x.headerVer > xlHeaderVersion {
		return x, buf, fmt.Errorf("decodeXLHeaders: Unknown xl header version %d", x.headerVer)
	}