c.h.Write(p[:n])
	}
	if errors.Is(err, io.EOF) {
		got := c.h.Sum(nil)
		if !bytes.Equal(got, c.want) {
			return n, ErrInvalidChecksum
		}
		return n, err
	}
	return n, err
}

// Close satisfies io.Closer
func (c Checker) Close() error {
	err := c.c.Close()
	if err == nil {
		got := c.h.Sum(nil)
		if !bytes.Equal(got, c.want) {
			return ErrInvalidChecksum
		}
	}
	return err

	err error // Last error seen
}

type formatter struct {
	err error // Last error seen
}

// parseString parses bytes as a NUL-terminated C-style string.
// If a NUL byte is not found then the whole slice is returned as a string.
func (*parser) parseString(b []byte) string {
	if i := bytes.IndexByte(b, 0); i >= 0 {
		return string(b[:i])
	}
	return string(b)
}

   *
   * @throws IllegalArgumentException if {@code bytes} has fewer than 4 elements
   */
  public static int fromByteArray(byte[] bytes) {
    checkArgument(bytes.length >= BYTES, "array too small: %s < %s", bytes.length, BYTES);
    return fromBytes(bytes[0], bytes[1], bytes[2], bytes[3]);
  }

  /**
   * Returns the {@code int} value whose byte representation is the given 4 bytes, in big-endian

    /** HTTP/2: Size in bytes of the table used to decode the sender's header blocks. */
    const val HEADER_TABLE_SIZE = 1

    /** HTTP/2: The peer must not send a PUSH_PROMISE frame when this is 0. */
    const val ENABLE_PUSH = 2

    /** Sender's maximum number of concurrent streams. */
    const val MAX_CONCURRENT_STREAMS = 3

    /** Window size in bytes. */
    const val INITIAL_WINDOW_SIZE = 4

    }

    /// Encrypt a block of eight bytes.
    private void encrypt(final byte[] clearText, final int clearOff, final byte[] cipherText, final int cipherOff) {

        squashBytesToInts(clearText, clearOff, tempInts, 0, 2);
        des(tempInts, tempInts, encryptKeys);
        spreadIntsToBytes(tempInts, 0, cipherText, cipherOff, 2);
    }

    /// Decrypt a block of eight bytes.

 * Provides standardized method for converting objects to their binary representation.
 *
 * @author mbechler
 */
public class ByteEncodable implements Encodable {

    private final byte[] bytes;
    private final int off;
    private final int len;

    /**
     * Constructs a ByteEncodable object wrapping a byte array segment.
     *
     * @param b the byte array to wrap

        return read(b, 0, b.length);
    }

    /**
     * Reads up to len bytes from the file into the specified byte array.
     *
     * @param b the byte array to read data into
     * @param off the offset in the array at which to start storing bytes
     * @param len the maximum number of bytes to read
     * @return the number of bytes read, or -1 if end of file is reached
     * @throws SmbException if an I/O error occurs

     * @param usage the Kerberos key usage number for this operation
     * @param baseKey the base Kerberos key for key derivation
     * @param input the data to calculate the MAC for
     * @return the calculated MAC bytes (truncated to 12 bytes)
     * @throws GeneralSecurityException if cryptographic operations fail
     */
    public static byte[] calculateMacHMACAES(int usage, KerberosKey baseKey, byte[] input) throws GeneralSecurityException {

			return err
		}
	}

	path := filepath.Join(store.directory, key.String())
	if key.Compress {
		err = os.WriteFile(path, s2.Encode(nil, buf.Bytes()), os.FileMode(0o770))
	} else {
		err = os.WriteFile(path, buf.Bytes(), os.FileMode(0o770))
	}

	buf.Reset()
	if err != nil {
		return err
	}

	// Increment the item count.
	store.entries[key.String()] = time.Now().UnixNano()

    public TemporaryFolder tempFolder = new TemporaryFolder();

    /**
     * @throws Exception
     */
    @Test
    public void testFileToFile() throws Exception {
        final byte[] bytes = readBytes(inputFile);
        assertThat(bytes, is("あいうえお".getBytes("UTF-8")));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testReadUTF8() throws Exception {