@Nullable Object value;
      @Nullable ValueHolder next;
    }

    /**
     * Holder object for values that cannot be null or empty (will be printed unconditionally). This
     * helps to shortcut most calls to isEmpty(), which is important because the check for emptiness
     * is relatively expensive. Use a subtype so this also doesn't need any extra storage.
     */

    @Test
    @DisplayName("Should handle multiple close() calls gracefully")
    void testMultipleCloseCallsSafe() {
        // Given
        Smb2EncryptionContext closeableContext = new Smb2EncryptionContext(EncryptionNegotiateContext.CIPHER_AES128_CCM,
                DialectVersion.SMB302, testEncryptionKey, testDecryptionKey);

        // When/Then - Multiple close calls should not throw
        assertDoesNotThrow(() -> {

   *
   * <p>The returned iterable's iterator supports {@code remove()} when the corresponding input
   * iterator supports it.
   *
   * <p><b>{@code Stream} equivalent:</b> use nested calls to {@link Stream#concat}, or see the
   * advice in {@link #concat(Iterable...)}.
   *
   * @since 20.0
   */
  public static <T extends @Nullable Object> FluentIterable<T> concat(

            } catch (final IOException ioe) {}
        }
    }

    @Override
    public void destroy() {
    }

    /**
     * This method simply calls {@code negotiate( req, resp, false )}
     * and then {@code chain.doFilter}. You can override and call
     * negotiate manually to achive a variety of different behavior.
     */
    @Override

import java.net.URL;
import java.net.UnknownHostException;

/**
 * This class will allow a Java program to read and write data to Named
 * Pipes and Transact NamedPipes.
 *
 * <p>There are three Win32 function calls provided by the Windows SDK
 * that are important in the context of using jCIFS. They are:
 *
 * <ul>
 * <li> <code>CallNamedPipe</code> A message-type pipe call that opens,

        response.readDataWireFormat(buffer, 0, buffer.length);

        SecurityDescriptor sd = response.getSecurityDescriptor();
        assertNotNull(sd);

        // Verify it's the same instance on subsequent calls
        SecurityDescriptor sd2 = response.getSecurityDescriptor();
        assertSame(sd, sd2);
    }

    @Test
    @DisplayName("Test readDataWireFormat with zero length buffer")

                throw new IOException("Failed to access " + url, e);
            }
        }

        /**
         * Gets the Blob object from GCS.
         * This method caches the response to avoid repeated calls.
         *
         * @return The Blob object
         * @throws IOException If an I/O error occurs
         */
        private Blob getBlob() throws IOException {
            if (blob == null) {

            }
        }

        /**
         * Gets the object head response from the S3 service.
         * This method caches the response to avoid repeated calls.
         *
         * @return The object head response
         * @throws IOException If an error occurs
         */
        private HeadObjectResponse getHeadObject() throws IOException {

        lenient().when(fileEntry.getName()).thenReturn("test");
    }

    @Test
    @DisplayName("Iterator without filter - simple case")
    void iteratorWithoutFilter() {
        // Setup: constructor calls advance() once
        when(delegate.hasNext()).thenReturn(true, false);
        when(delegate.next()).thenReturn(fileEntry);

        TestIterator iterator = new TestIterator(null);

        // Verify iteration

        verify(mockEntry, times(1)).lastAccess();
        verify(mockEntry, times(1)).length();
        verify(mockEntry, never()).getFileIndex();

        // Verify order among a subset of calls
        InOrder inOrder = inOrder(mockEntry);
        inOrder.verify(mockEntry).getName();
        inOrder.verify(mockEntry, times(2)).getType();
    }

    @Test