throw new RuntimeException("Failed to create Mac instance", e);
            }

            mac.update(data, offset, length);
            final byte[] sig = mac.doFinal();
            System.arraycopy(sig, 0, data, offset + SIGNATURE_OFFSET, SIGNATURE_LENGTH);
        } finally {
            this.signingLock.unlock();
        }
    }

    /**
     *
     * {@inheritDoc}
     *

        byte[] buffer = new byte[testString.length()];

        // When - Manual string encoding using individual bytes
        byte[] strBytes = testString.getBytes();
        System.arraycopy(strBytes, 0, buffer, 0, strBytes.length);

        // Then
        String decoded = new String(buffer);
        assertEquals(testString, decoded);
    }

    @Test

        if (defaultWords == null) {
            updateDefaultBadwords();
        }
        final String[] concat = new String[defaultWords.length + badWords.length];
        System.arraycopy(badWords, 0, concat, 0, badWords.length);
        System.arraycopy(defaultWords, 0, concat, badWords.length, defaultWords.length);
        return concat;
    }

    /**
     * Add a bad word.
     * @param badWord Bad word
     */

                byte[] addr = new byte[4];
                System.arraycopy(data, offset + 4, addr, 0, 4);
                return InetAddress.getByAddress(addr);
            } else if (family == 23) { // AF_INET6
                byte[] addr = new byte[16];
                System.arraycopy(data, offset + 8, addr, 0, 16);
                return InetAddress.getByAddress(addr);
            }
        } catch (Exception e) {

        final int start = bufferIndex;

        if ((server.capabilities & CAP_EXTENDED_SECURITY) == 0) {
            server.encryptionKey = new byte[server.encryptionKeyLength];
            System.arraycopy(buffer, bufferIndex, server.encryptionKey, 0, server.encryptionKeyLength);
            bufferIndex += server.encryptionKeyLength;
            if (byteCount > server.encryptionKeyLength) {
                int len = 0;

            System.arraycopy(buffer, bufferIndex, txn_buf, bufParameterStart + parameterDisplacement, parameterCount);
            bufferIndex += parameterCount;
        }
        if (dataCount > 0) {
            bufferIndex += pad1 = dataOffset - (bufferIndex - headerStart);
            System.arraycopy(buffer, bufferIndex, txn_buf, bufDataStart + dataDisplacement, dataCount);

    }
  }

  private static Double[] concat(Double[] left, Double[] right) {
    Double[] result = new Double[left.length + right.length];
    System.arraycopy(left, 0, result, 0, left.length);
    System.arraycopy(right, 0, result, left.length, right.length);
    return result;
  }

  public abstract static class TestDoubleListGenerator implements TestListGenerator<Double> {
    @Override

        writeInt4(buffer, offset + 12, 16);  // DataLength
        
        // Name
        System.arraycopy(getName().getBytes(), 0, buffer, offset + 16, nameLen);
        
        // Data (16-byte file ID)
        int dataOffset = offset + 16 + nameLen;
        dataOffset = (dataOffset + 7) & ~7;  // 8-byte alignment
        System.arraycopy(fileId, 0, buffer, dataOffset, 16);
    }
}
```

### 4.5 Persistent Handle Manager

        final int start = dstIndex;

        if (blob != null) {
            System.arraycopy(blob, 0, dst, dstIndex, blob.length);
            dstIndex += blob.length;
        } else {
            System.arraycopy(lmHash, 0, dst, dstIndex, lmHash.length);
            dstIndex += lmHash.length;
            System.arraycopy(ntHash, 0, dst, dstIndex, ntHash.length);
            dstIndex += ntHash.length;

        byte[] result = cipher.doFinal(data);

        decrypt = new byte[result.length];
        System.arraycopy(result, 0, decrypt, 0, result.length);

        int tempSize = decrypt.length - 24;

        byte[] output = new byte[tempSize];
        System.arraycopy(decrypt, 24, output, 0, tempSize);

        return output;
    }