innerCount++;
                    }
                }
                assertEquals(0, innerCount, "Inner iteration should not execute");
            }
            assertEquals(0, outerCount, "Outer iteration should not execute");
        }, "EmptyIterator should work correctly in nested iteration");
    }

    @Test
    @DisplayName("EmptyIterator should follow Iterator contract for empty collections")

                        try {
                            // Mix of success and failure
                            final int iteration = i;
                            String result = circuitBreaker.executeWithCircuitBreaker(() -> {
                                if ((threadId + iteration) % 10 == 0) {
                                    throw new RuntimeException("Simulated failure");
                                }

        // Verify iteration
        assertTrue(iterator.hasNext());
        assertSame(resource, iterator.next());
        assertFalse(iterator.hasNext());

        verify(filter, times(2)).accept(resource);
        verify(resource, times(2)).close();
    }

    @Test
    @DisplayName("Multiple iterations")
    void multipleIterations() {
        // Setup for three items

        t.url = null; // Null URL
        t.numIter = 0; // No iterations to avoid NPE

        // Should not throw exception
        assertDoesNotThrow(() -> t.run(), "run() should handle null URL gracefully");
        assertEquals(1, t.numComplete, "numComplete should still be incremented");
    }

    @Test
    @DisplayName("run method handles zero iterations")
    void testRunWithZeroIterations() {

 * need for a distinct {@code ImmutableBiMultimap} type.
 *
 * <p><a id="iteration"></a>
 *
 * <p><b>Key-grouped iteration.</b> All view collections follow the same iteration order. In all
 * current implementations, the iteration order always keeps multiple entries with the same key
 * together. Any creation method that would customarily respect insertion order (such as {@link

		//    a new entry in lockMap and acquires a lock for the same resource.

		<-lk2ch
		lk3ok := <-lk3ch
		lk4ok := <-lk4ch

		if lk3ok && lk4ok {
			t.Fatalf("multiple locks acquired; iteration=%d, lk3=%t, lk4=%t", i, lk3ok, lk4ok)
		}
	}

import jcifs.internal.smb1.net.NetServerEnum2Response;
import jcifs.internal.smb1.trans.SmbComTransaction;

/**
 * Iterator for enumerating network servers.
 *
 * This class provides iteration over network servers discovered
 * through NetBIOS server enumeration requests.
 */
public class NetServerEnumIterator implements CloseableIterator<FileEntry> {

        SmbResource r2 = it.next();
        assertNotNull(r2);
        assertEquals("bar/", r2.getName(), "Second child name should match with trailing slash");

        // End of iteration behavior
        assertFalse(it.hasNext(), "No more elements expected");
        assertNull(it.next(), "next() returns null when exhausted in this implementation");
    }

    @Test

                assertEquals(4, bytesRead, "Failed at iteration " + i);
            }

            // When - perform multiple write operations
            for (int i = 0; i < 100; i++) {
                int bytesWritten = response.writeBytesWireFormat(buffer, 0);
                // Then
                assertEquals(0, bytesWritten, "Failed at iteration " + i);
            }
        }
    }

    @Nested

import jcifs.SmbConstants;
import jcifs.SmbResource;
import jcifs.SmbResourceLocator;
import jcifs.context.SingletonContext;

/**
 * Tests for NetServerFileEntryAdapterIterator.
 *
 * Intent: Validate iteration behavior, filtering, invalid inputs handling,
 * and delegation to the underlying iterator.
 */
@ExtendWith(MockitoExtension.class)
class NetServerFileEntryAdapterIteratorTest {

    @Mock