assertFalse(iterator.hasNext());
        assertNull(iterator.next());

        verify(resource, never()).close();
    }

    @Test
    @DisplayName("Empty iterator")
    void emptyIterator() {
        when(delegate.hasNext()).thenReturn(false);

        TestIterator iterator = new TestIterator(null);

        assertFalse(iterator.hasNext());

        @Test
        @DisplayName("getName can return null and empty strings via mock")
        void mock_nameEdgeValues() {
            // Arrange
            when(mockEntry.getName()).thenReturn(null, "", " ");

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

        assertNull(testImplementation.getFullUNCPath());
    }

    @Test
    @DisplayName("Test with empty strings")
    void testWithEmptyStrings() {
        // Test empty path
        testImplementation.setPath("");
        assertEquals("", testImplementation.getPath());

        // Test empty UNC path components
        testImplementation.setFullUNCPath("", "", "");

								><a class="nav-link active" href="${installationLink}" target="_olh"><em
										class="fa fa-exclamation-triangle text-warning"
									></a></li>
							</c:if>
							<c:choose>
								<c:when test="${!empty username && username != 'guest'}">
									<li class="nav-item">
										<div class="dropdown">
											<a id="userMenu" class="nav-link dropdown-toggle" data-bs-toggle="dropdown"

        assertNotNull(result);
        // The mock returns a fixed count of 3
        assertTrue(result.contains("docs"));
    }

    // Test with empty label set
    public void test_execute_withEmptyLabelSet() {
        // Override mock to return empty label set
        LabelTypeHelper emptyLabelHelper = new LabelTypeHelper() {
            @Override
            public Set<String> getMatchedLabelValueSet(String url) {

    // Consume '\'.
    readByte()
    result.write(this, 1L) // The escaped character.
  }
}

/**
 * Consumes and returns a non-empty token, terminating at special characters in
 * [TOKEN_DELIMITERS]. Returns null if the buffer is empty or prefixed with a delimiter.
 */
private fun Buffer.readToken(): String? {
  var tokenSize = indexOfElement(TOKEN_DELIMITERS)
  if (tokenSize == -1L) tokenSize = size

    public void test_FilePurgeVisitor_postVisitDirectory() throws IOException {
        // Test empty directory deletion logic
        File emptyDir = new File(tempDir, "empty");
        emptyDir.mkdirs();
        assertTrue(emptyDir.exists());

        // Simulate the behavior of postVisitDirectory - delete empty directories
        if (emptyDir.isDirectory() && emptyDir.list().length == 0) {
            emptyDir.delete();

    )

    val call = client.newCall(Request(server.url("/")))
    call.execute().use { response ->
      assertThat(response.body.source().readUtf8()).isEqualTo("")
      assertThat(response.trailers()).isEqualTo(Headers.EMPTY)
    }
  }

  @Test
  fun readEmptyTrailersHttp1NonEmptyFixedLengthResponse() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("Hello")
        .build(),
    )

        // Initially not deleted
        assertFalse(item.isDeleted());

        // Set newInputs to empty array and newOutput
        item.setNewInputs(new String[] {});
        item.setNewOutput("output");
        assertTrue(item.isDeleted());

        // Set newInputs to non-empty array - not deleted
        item.setNewInputs(new String[] { "something" });
        assertFalse(item.isDeleted());
    }

   * Booleans.contains(array, false)} with {@code bitSet.nextClearBit(0) == sizeOfBitSet}.
   *
   * @param array an array of {@code boolean} values, possibly empty
   * @param target a primitive {@code boolean} value
   * @return {@code true} if {@code array[i] == target} for some value of {@code i}
   */
  public static boolean contains(boolean[] array, boolean target) {