try {
            int read = sis.read(buffer, 0, 10);

            // Should read all 5 available bytes
            assertEquals(5, read);

            // Verify correct data
            for (int i = 0; i < 5; i++) {
                assertEquals(i + 1, buffer[i]);
            }

            // Next read will try to read header and should fail

  }

  @Test
  public void edgesConnecting_oneEdge() {
    addEdge(N1, N2, E12);
    assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12);
    // Passed nodes should be in the correct edge direction, first is the
    // source node and the second is the target node
    assertThat(network.edgesConnecting(N2, N1)).isEmpty();
  }

  @Test
  public void inEdges_oneEdge() {

            msg.decode_header(fragBuf);
            final int stub_frag_len = msg.length - 24;
            if (off + stub_frag_len > in.length) {
                // shouldn't happen if alloc_hint is correct or greater
                final byte[] tmp = new byte[off + stub_frag_len];
                System.arraycopy(in, 0, tmp, 0, off);
                in = tmp;
            }

        for (int i = 0; i < result1.size(); i++) {
            assertEquals(result1.get(i), result2.get(i));
            assertEquals(result2.get(i), result3.get(i));
        }

        // Verify content is correct
        assertEquals(2, result1.size());
        assertEquals(mockNotifyInfo1, result1.get(0));
        assertEquals(mockNotifyInfo2, result1.get(1));
    }

This package does not support disk spanning.

A note about ZIP64:

To be backwards compatible the FileHeader has both 32 and 64 bit Size
fields. The 64 bit fields will always contain the correct value and
for normal archives both fields will be the same. For files requiring
the ZIP64 format the 32 bit fields will be 0xffffffff and the 64 bit
fields must be used instead.

 * difference. A CharEscaper can only process Java <a
 * href="http://en.wikipedia.org/wiki/UTF-16">UTF16</a> characters in isolation and may not cope
 * when it encounters surrogate pairs. This class facilitates the correct escaping of all Unicode
 * characters.
 *
 * <p>As there are important reasons, including potential security issues, to handle Unicode

<img src="/img/deployment/https/https07.drawio.svg">

The client (browser) will know that the response comes from the correct server because it is using the cryptography they agreed using the **HTTPS certificate** before.

### Multiple Applications { #multiple-applications }

    }

    @Test
    public void test_static_method_signatures() {
        // Verify all public static methods exist with correct signatures
        try {
            // setObject(String, Object)
            Method setObjectMethod = WebApiUtil.class.getMethod("setObject", String.class, Object.class);

        // Should write FileInformation data + 6 bytes padding
        assertEquals(36, written); // 30 + 6

        // Verify encode was called with correct offset
        verify(mockFileInfo).encode(buffer, offset);
    }

    @Test
    @DisplayName("Test readSetupWireFormat returns 0")
    void testReadSetupWireFormat() {

        // Create a new digest for verification with same key
        SMB1SigningDigest verifyDigest = new SMB1SigningDigest(testMacSigningKey);

        // Verify should return false when signature is correct (no error)
        // The code returns true on line 281 when signatures DON'T match
        boolean result = verifyDigest.verify(data, 0, data.length, 0, mockRequest);