when(mockEntry.getName()).thenReturn(null, "", " ");

            // Act & Assert
            assertNull(mockEntry.getName(), "first call returns null");
            assertEquals("", mockEntry.getName(), "second call returns empty");
            assertEquals(" ", mockEntry.getName(), "third call returns space");

            verify(mockEntry, times(3)).getName();
        }
    }

     *
     * @param name the circuit breaker name
     */
    public SimpleCircuitBreaker(String name) {
        this(name, 5, 3, 30000L); // 5 failures, 3 successes, 30 second timeout
    }

    /**
     * Creates a simple circuit breaker
     *
     * @param name the circuit breaker name
     * @param failureThreshold number of consecutive failures to open circuit

        assertSame(d, r1, "nextElement should return the same instance");
        // After first call isPrimary should be false
        assertFalse(d.getIsPrimary(), "isPrimary should be cleared after first call");
        // Second call keeps the same state
        SmbComTransactionResponse r2 = (SmbComTransactionResponse) d.nextElement();
        assertSame(d, r2, "Subsequent calls still return same instance");

        NtlmUtil.E(key7, data8, out7);

        // Assert: first block identical to single-chunk encryption
        assertArrayEquals(Arrays.copyOfRange(out14, 0, 8), out7);
        // And second block is present and not all zeros
        assertFalse(Arrays.equals(new byte[8], Arrays.copyOfRange(out14, 8, 16)));
    }

                    } finally {
                        latch.countDown();
                    }
                }).start();
            }

            latch.await(5, java.util.concurrent.TimeUnit.SECONDS);
            assertEquals(5, successCount.get(), "All concurrent calls should succeed");
        }
    }

        System.arraycopy(name1.getBytes("US-ASCII"), 0, src, srcIndex + 1, 16);
        src[srcIndex + 16] = 0x00; // hex code
        src[srcIndex + 17] = 0x04; // flags: active

        // Second name entry (18 bytes)
        String name2 = "DOMAIN          ";
        System.arraycopy(name2.getBytes("US-ASCII"), 0, src, srcIndex + 19, 16);
        src[srcIndex + 34] = 0x00; // hex code

        response.readParametersWireFormat(buffer1, 0, 6);
        assertEquals(100, response.getAvailable());
        assertEquals(TransPeekNamedPipeResponse.STATUS_CONNECTION_OK, response.getStatus());

        // Second read - should update values
        byte[] buffer2 = new byte[10];
        SMBUtil.writeInt2(500, buffer2, 0);
        SMBUtil.writeInt2(0, buffer2, 2);

   - Multi-channel provides >1.5x throughput improvement
   - RDMA reduces latency by >50%
3. **Reliability**: 
   - Persistent handles survive 99% of network interruptions
   - Witness protocol achieves <5 second failover time
4. **Compatibility**: Works with Windows Server 2016+ and Azure Files

## Next Steps

1. **Immediate Actions**:
   - Set up Windows Server test environment

        assertNotNull(polled);
        assertEquals("http://www.example.com/page1", polled.getUrl());
        assertEquals(sessionId, polled.getSessionId());

        // Second poll should return null (queue is empty)
        final OpenSearchUrlQueue polled2 = urlQueueService.poll(sessionId);
        assertNull(polled2);

        urlQueueService.delete(sessionId);
    }

     * on an SMB server addressed by the <code>SmbFile</code> parameter. See
     * {@link jcifs.smb.SmbFile} for a detailed description and examples of
     * the smb URL syntax. If the second argument is <code>true</code>, then
     * bytes will be written to the end of the file rather than the beginning.
     *
     * @param file
     *            An <code>SmbFile</code> representing the file to write to