int data1 = (int) (mostSig >>> 32); // first 4 bytes
        short data2 = (short) (mostSig >>> 16); // next 2 bytes
        short data3 = (short) mostSig; // next 2 bytes

        // Write in little-endian format as specified by MS-SMB2
        bb.putInt(data1); // data1 (4 bytes, little-endian)
        bb.putShort(data2); // data2 (2 bytes, little-endian)
        bb.putShort(data3); // data3 (2 bytes, little-endian)

    hostname: minio1
    volumes:
      - data1-1:/data1
      - data1-2:/data2

  minio2:
    <<: *minio-common
    hostname: minio2
    volumes:
      - data2-1:/data1
      - data2-2:/data2

  minio3:
    <<: *minio-common
    hostname: minio3
    volumes:
      - data3-1:/data1
      - data3-2:/data2

  minio4:
    <<: *minio-common
    hostname: minio4
    volumes:

		{data1, 2, io.EOF},
		{data1[:2048] + data2[:1536], 3, io.EOF},
		{data2[:511], 0, io.ErrUnexpectedEOF},
		{data2[:512], 1, io.ErrUnexpectedEOF},
		{data2[:1195], 1, io.ErrUnexpectedEOF},
		{data2[:1196], 1, io.EOF}, // Exact end of data and start of padding
		{data2[:1200], 1, io.EOF},
		{data2[:1535], 1, io.EOF},
		{data2[:1536], 1, io.EOF}, // Exact end of padding
		{data2[:1536] + trash[:1], 1, io.ErrUnexpectedEOF},

        byte[] data1 = "data1".getBytes();
        byte[] data2 = "data2".getBytes();

        HMACT64 hmac1 = new HMACT64(TEST_KEY);
        HMACT64 hmac2 = new HMACT64(TEST_KEY);

        hmac1.engineUpdate(data1, 0, data1.length);
        hmac2.engineUpdate(data2, 0, data2.length);

        byte[] result1 = hmac1.engineDigest();
        byte[] result2 = hmac2.engineDigest();

        byte[] data2 = { (byte) 0xFF, (byte) 0xFE, (byte) 0x80, 0x7F };
        assertEquals("FF", Hexdump.toHexString(data2, 0, 2)); // 2 chars = 1 byte
        assertEquals("FFF", Hexdump.toHexString(data2, 0, 3)); // 3 chars = 1.5 bytes (rounds up to 2)
        assertEquals("FFFE", Hexdump.toHexString(data2, 0, 4)); // 4 chars = 2 bytes
        assertEquals("FFFE80", Hexdump.toHexString(data2, 0, 6)); // 6 chars = 3 bytes

        crawlJob.dataConfigIds(new String[] { "data1", "data2", "data3" });

        String result = crawlJob.execute();

        assertNotNull(result);
        assertTrue(result.contains("Web  Config Id: web1 web2"));
        assertTrue(result.contains("File Config Id: file1"));
        assertTrue(result.contains("Data Config Id: data1 data2 data3"));
    }

    // Test execute method with sessionId already set

        final byte[] data1 = "abc".getBytes();
        assertEquals("YWJj", Base64Util.encode(data1));

        // Test case 2: Single padding
        final byte[] data2 = "abcd".getBytes();
        assertEquals("YWJjZA==", Base64Util.encode(data2));

        // Test case 3: Double padding
        final byte[] data3 = "abcde".getBytes();
        assertEquals("YWJjZGU=", Base64Util.encode(data3));

    # Subsequent legitimate request with no root_path
    clean_client = TestClient(app)
    response2 = clean_client.get("/openapi.json")
    data2 = response2.json()
    servers = [s.get("url") for s in data2.get("servers", [])]
    assert "/evil-api" not in servers


def test_multiple_different_root_paths_do_not_accumulate():
    app = FastAPI()

    @app.get("/")

            data2 = DfsReferralDataImpl.fromReferral(mockReferral, reqPath, System.currentTimeMillis() + 10000, consumed);
        }

        @Test
        @DisplayName("Should be equal for same values")
        void testEquals() {
            assertEquals(data1, data2);
            assertEquals(data2, data1);
        }

        @Test

            // Second decode should overwrite
            response.decode(buffer2, 10, 60);
            byte[] data2 = response.getData();

            // Verify second decode overwrote first
            assertEquals(60, data2.length);
            assertEquals((byte) 0x22, data2[0]);
        }
    }

    @Nested
    @DisplayName("Integration Pattern Tests")
    class IntegrationPatternTests {