"16777215, 16777215" })
    void testWriteReadInt2RoundTrip(long input, int expected) {
        byte[] buffer = new byte[4];
        SMBUtil.writeInt2(input, buffer, 0);
        int result = SMBUtil.readInt2(buffer, 0);
        assertEquals(expected & 0xFFFF, result);
    }

    @ParameterizedTest
    @ValueSource(longs = { 0L, 1L, 0xFFFFFFFFL, 0x12345678L, 0x80000000L })

	echo "BUG: MD5 checksum of object 'minio2/test-bucket/encrypted' doesn't match with source. Expected: '${src_obj1_md5}', Found: '${rep_obj1_md5}'"
	exit_1
fi
if [ "${src_obj2_md5}" != "${rep_obj2_md5}" ]; then
	echo "BUG: MD5 checksum of object 'minio2/test-bucket/defpartsize' doesn't match with source. Expected: '${src_obj2_md5}', Found: '${rep_obj2_md5}'"
	exit_1
fi

            // We primarily want to ensure the method can be called without compilation errors

            // Log the exception for debugging purposes but don't fail the test
            System.out.println("Expected exception in test environment: " + t.getClass().getSimpleName() + ": " + t.getMessage());

            // Verify that it's a system-related exception, not a method signature issue

        assertNotNull(Curl.connect("http://proxy.example.com:3128"));
    }

    @Test
    public void test_HttpMethodEnumValues() {
        // ## Test that all expected HTTP methods are present in the enum ##

        // ## Act ##
        final Method[] methods = Method.values();

        // ## Assert ##

    File file = createTempFile();
    Files.write(bytes, file);

    // Test
    MappedByteBuffer actual = Files.map(file);

    // Verify
    ByteBuffer expected = ByteBuffer.wrap(bytes);
    assertTrue("ByteBuffers should be equal.", expected.equals(actual));
  }

  public void testMap_noSuchFile() throws IOException {
    // Setup
    File file = createTempFile();
    boolean deleted = file.delete();

        TestHttpServletResponse response = new TestHttpServletResponse();
        TestFilterChain chain = new TestFilterChain();

        try {
            manager.process(request, response, chain);
            fail("Expected ServletException");
        } catch (ServletException e) {
            assertEquals("Test error", e.getMessage());
        }
    }

                        "Should throw SMBProtocolDecodingException for invalid structure size");

        assertEquals("Expected structureSize = 9", exception.getMessage());
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 100, 255, 256, 65535 })

            return delegate.failureCause();
          }
        };
    IllegalArgumentException expected =
        assertThrows(
            IllegalArgumentException.class,
            () -> new ServiceManager(Arrays.asList(service1, service2)));
    assertThat(expected).hasMessageThat().contains("started transitioning asynchronously");
  }

  /**

        try {
            method.invoke(multiChannelManager, localhost, loopback);
            // If it doesn't throw, that's unexpected for localhost
            fail("Expected CIFSException for localhost multi-channel attempt");
        } catch (java.lang.reflect.InvocationTargetException e) {
            // We expect this to fail, but it should be a CIFSException, not a NullPointerException

    assertTrue(
        from.getType() + " is expected to be assignable to " + to.getType(),
        to.isSupertypeOf(from));
    assertTrue(
        to.getType() + " is expected to be a supertype of " + from.getType(),
        to.isSupertypeOf(from));
    assertTrue(
        from.getType() + " is expected to be a subtype of " + to.getType(), from.isSubtypeOf(to));
  }