*/
        public boolean hasWriteCache() {
            return Smb2LeaseState.hasWriteCaching(leaseState);
        }

        /**
         * Check if lease has handle caching
         *
         * @return true if handle caching is enabled
         */
        public boolean hasHandleCache() {
            return Smb2LeaseState.hasHandleCaching(leaseState);
        }

        /**

    @DisplayName("Constructor with null pipe name should handle gracefully")
    void testConstructorWithNullPipeName() {
        // Act
        transWaitNamedPipe = new TransWaitNamedPipe(mockConfig, null);

        // Assert
        assertNotNull(transWaitNamedPipe);
        assertNull(transWaitNamedPipe.name);
    }

    @Test
    @DisplayName("Constructor with empty pipe name should handle gracefully")

        leaseManager.updateLease(key, grantedState);

        LeaseEntry entry = leaseManager.getLease(key);
        assertEquals(grantedState, entry.getLeaseState());
    }

    @Test
    @DisplayName("Should handle lease break")
    void testHandleLeaseBreak() {
        String path = "/share/file.txt";
        int initialState = Smb2LeaseState.SMB2_LEASE_FULL;
        int newState = Smb2LeaseState.SMB2_LEASE_READ_CACHING;

## Use Case { #use-case }

Let's start with an example **use case** and then see how to solve it with this.

Let's imagine that you have some **machine learning models** that you want to use to handle requests. 🤖

The same models are shared among requests, so, it's not one model per request, or one per user or something similar.

            assertArrayEquals(originalHashAlgos, decodedContext.getHashAlgos());
            assertArrayEquals(originalSalt, decodedContext.getSalt());
        }

        @Test
        @DisplayName("Should handle round-trip at non-zero offset")
        void testRoundTripWithOffset() throws SMBProtocolDecodingException {
            int offset = 100;
            int[] originalHashAlgos = { 0x01, 0x02 };

        // Each name should write at least 34 bytes (encoded name + scope)
        assertTrue(bytesWritten >= 68);
    }

    @Test
    @DisplayName("writeTrailerWireFormat with scope should handle scoped names")
    void testWriteTrailerWireFormatWithScope() {
        when(mockCalledName.getName()).thenReturn("SERVER");
        when(mockCalledName.getNameType()).thenReturn(0x20);

            assertEquals((byte) 0x00, uuid.node[5]); // Missing data defaults to 0
        }

        @Test
        @DisplayName("Constructor with empty node array in rpc.uuid_t should handle gracefully")
        void testConstructorWithEmptyNode() {
            // Arrange
            rpc.uuid_t rpcUuid = new rpc.uuid_t();
            rpcUuid.time_low = TIME_LOW;
            rpcUuid.time_mid = TIME_MID;

  "author": "John Doe",
  "version": "1.0",
  "published": "2025-01-15",
  "tags": ["crawler", "extractor", "json"],
  "content": {
    "summary": "This is a sample JSON document for testing",
    "body": "The extractor should handle nested objects and arrays properly"
  },
  "metadata": {
    "created_at": "2025-01-01T00:00:00Z",
    "updated_at": "2025-01-15T12:00:00Z"
  }

                "flags should be DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");
        // Verify that the super constructor was called with the correct handle.
        // This is implicitly tested by the object being created without error and
        // the fields set by the constructor being correct.
    }

			return errFileAccessDenied
		case isSysErrPathNotFound(err):
			// This is a special case should be handled only for
			// windows, because windows API does not return "not a
			// directory" error message. Handle this specifically
			// here.
			return errFileAccessDenied
		}
	}
	return err
}

// Reliably retries os.RemoveAll if for some reason os.RemoveAll returns
// syscall.ENOTEMPTY (children has files).