}

                        if (dfd == null || !dfd.isValid()) {
                            // don't reopen the file for every round if it's not necessary, keep the lock
                            dfd = openCopyTargetFile(dest, src.getAttributes(), !write);
                        }

      case SATISFIED_BEFORE_WAITING:
        guard.setSatisfied(true);
        break;
      case SATISFIED_WHILE_WAITING:
        guard.setSatisfied(false);
        enterSatisfyGuardAndLeaveInAnotherThread(); // enter blocks until we call waitFor
        break;
      case UNSATISFIED_BEFORE_AND_WHILE_WAITING:
        guard.setSatisfied(false);
        break;
      case SATISFIED_AND_INTERRUPTED_BEFORE_WAITING:

        @Test
        @DisplayName("Should handle typical Linux ext4 configuration")
        void shouldHandleTypicalExt4Configuration() throws SMBProtocolDecodingException {
            // Given - typical ext4: 4KB blocks
            long totalBlocks = 26214400L; // 100GB / 4KB
            long freeBlocks = 5242880L; // 20GB / 4KB

            ByteBuffer buffer = ByteBuffer.allocate(32);
            buffer.order(ByteOrder.LITTLE_ENDIAN);

                    response.adjustOffset(n);
                }

            } while (len > effectiveBlockSize && n == r);

            // Optimization: Continue reading if we have small remaining data and got full blocks
            // This reduces round trips for slightly larger reads
            if (len > 0 && len <= (effectiveBlockSize / 4) && n == r) {
                try {
                    if (th.isSMB2()) {

        void testStaticToByteArrayNull() {
            assertThrows(NullPointerException.class, () -> SID.toByteArray(null));
        }
    }

    @Nested
    @DisplayName("Tests requiring mocks")
    @ExtendWith(MockitoExtension.class)
    class MockedTests {
        @Mock
        CIFSContext mockCtx;

        @Mock
        SidResolver mockResolver;

        @BeforeEach

	MediumBlock = 128 * humanize.KiByte // Default r/w block size for medium sized objects.
	LargeBlock  = 1 * humanize.MiByte   // Default r/w block size for normal objects.
)

// AlignedBytePool is a pool of fixed size aligned blocks
type AlignedBytePool struct {
	size int
	p    bpool.Pool[*[]byte]
}

// NewAlignedBytePool creates a new pool with the specified size.
func NewAlignedBytePool(sz int) *AlignedBytePool {

lifeinsurance
lifestyle
lig.it
lighting
liguria.it
like
likes-pie.com
likescandy.com
lillehammer.no
lillesand.no
lilly
lima-city.at
lima-city.ch
lima-city.de
lima-city.rocks
lima.zone
limanowa.pl
limited
limo
lincoln
lindas.no
lindesnes.no
lindås.no
link
linkyard-cloud.ch
linkyard.cloud
lipsy
littlestar.jp
live
live-on.net

    }
  }
}
```

## Explore Further

- [Use `minio-java` SDK with MinIO Server](https://docs.min.io/community/minio-object-store/developers/java/minio-java.html)
- [Object Lock and Immutability Guide](https://docs.min.io/community/minio-object-store/administration/object-management/object-retention.html)
- [MinIO Admin Complete Guide](https://docs.min.io/community/minio-object-store/reference/minio-mc-admin.html)

        byte[] result = digest.digest();

        assertNotNull(result);
        assertTrue(result.length > 0);
    }

    // Helper method to setup transport mocks
    private void setupTransportMocks(int lmCompatibility) throws Exception {
        byte[] serverEncryptionKey = new byte[8];
        byte[] unicodeHash = new byte[24];

        ReferenceQueue<Object> queue,
        PhantomReference<Object> frqRef) {
      Finalizer.startFinalizer(finalizableReferenceClass, queue, frqRef);
    }
  }

  /** Looks up Finalizer.startFinalizer(). */
  static Method getStartFinalizer(Class<?> finalizer) {
    try {
      return finalizer.getMethod(
          "startFinalizer", Class.class, ReferenceQueue.class, PhantomReference.class);