// Test exact thresholds
        assertEquals("1.024KB", MemoryUtil.byteCountToDisplaySize(1024L));
        assertEquals("1.024MB", MemoryUtil.byteCountToDisplaySize(1024L * 1024L));
        assertEquals("1.024GB", MemoryUtil.byteCountToDisplaySize(1024L * 1024L * 1024L));
    }

    public void test_sizeOf_nullObject() {
        assertEquals(0L, MemoryUtil.sizeOf(null));
    }

    assertMinSize(union(setSizeRange(10, 20), setSizeRange(11, 12)), 11);
    assertMinSize(union(setSizeRange(11, 12), setSizeRange(10, 20)), 11);
  }

  public void testUnion_maxSize() {
    assertMaxSize(union(emptySet(), emptySet()), 0);
    assertMaxSize(union(setSize(2), setSize(3)), 5);
    assertMaxSize(union(setSize(3), setSize(2)), 5);
    assertMaxSize(union(setSizeRange(10, 20), setSizeRange(11, 12)), 32);

        assertNull(directoryLeaseManager.getCachedDirectoryListing(directoryPath));

        // Setup mock files
        when(mockFile1.getName()).thenReturn("file1.txt");
        when(mockFile1.length()).thenReturn(1024L);
        when(mockFile1.lastModified()).thenReturn(1000L);
        when(mockFile1.isDirectory()).thenReturn(false);
        when(mockFile1.getAttributes()).thenReturn(0x20);

import org.dbflute.utflute.core.PlainTestCase;

/**
 * @author shinsuke
 *
 */
public class ContentLengthHelperTest extends PlainTestCase {
    private static long DEFAULT_MAX_LENGTH = 10L * 1024L * 1024L;

    public ContentLengthHelper contentLengthHelper;

    @Override
    protected void setUp() throws Exception {
        super.setUp();

          public Integer load(Integer key) throws Exception {
            return i++;
          }
        };

    LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder().build(loader);

    cache.put(10, 20);

    Map<Integer, Integer> map = cache.getAll(ImmutableList.of(10, 20, 30, 54, 443, 1));

    assertEquals(Integer.valueOf(20), map.get(10));
    assertEquals(Integer.valueOf(0), map.get(20));

        NdrBuffer buf = new NdrBuffer(new byte[1024], 0);
        m.encode(buf);
        assertTrue(m.alloc_hint > 0);
    }

    @Test
    void testEncodeWritesCorrectHeader() throws Exception {
        TestMessage m = new TestMessage();
        m.ptype = 0;
        m.flags = 0x05;
        m.call_id = 0x123;

        NdrBuffer buf = new NdrBuffer(new byte[1024], 0);
        m.encode(buf);

    class ConstructorTests {

        @Test
        @DisplayName("Should create lock with valid parameters")
        void testConstructorWithValidParameters() {
            long offset = 1024L;
            long length = 2048L;
            int flags = Smb2Lock.SMB2_LOCKFLAG_EXCLUSIVE_LOCK;

            lock = new Smb2Lock(offset, length, flags);

            assertNotNull(lock);
        }

            when(mockInfo.getSize()).thenReturn(1024L);
            when(mockInfo.getCreateTime()).thenReturn(1000000L);
            when(mockInfo.getLastWriteTime()).thenReturn(2000000L);

            // Use the mock
            response.info = mockInfo;

            // Verify interactions
            assertEquals(0x20, response.info.getAttributes());
            assertEquals(1024L, response.info.getSize());

	}
	if cap(ts) != 100 {
		t.Errorf("Slice() cap = %d, want 100", cap(ts))
	}
	ts[1].n = 42
}

func TestSmokeLarge(t *testing.T) {
	a := arena.NewArena()
	defer a.Free()
	for i := 0; i < 10*64; i++ {
		_ = arena.New[T2](a)
	}

    /** The initialization parameter map. */
    protected Map<String, Object> initParamMap;

    /** The maximum cached content size in bytes. Default is 1MB. */
    protected long maxCachedContentSize = 1024L * 1024L; // 1MB

    /** The access timeout in seconds. Default is null (no timeout). */
    protected Integer accessTimeout = null; // seconds

    /** The maximum content length in bytes. Default is null (no limit). */