* to ["a", "b", ""].
     */
    private fun pop() {
      val removed = encodedPathSegments.removeAt(encodedPathSegments.size - 1)

      // Make sure the path ends with a '/' by either adding an empty string or clearing a segment.
      if (removed.isEmpty() && encodedPathSegments.isNotEmpty()) {
        encodedPathSegments[encodedPathSegments.size - 1] = ""
      } else {

    PushObserver,
    Lockable {
    val events = mutableListOf<Any>()

    @Synchronized fun takeEvent(): Any {
      while (events.isEmpty()) {
        wait()
      }
      return events.removeAt(0)
    }

    @Synchronized override fun onRequest(
      streamId: Int,
      requestHeaders: List<Header>,
    ): Boolean {
      assertThat(streamId).isEqualTo(2)

      }

      @Override
      public void remove() {
        iterator.remove();
      }
    };
  }

  /**
   * Returns an iterator that cycles indefinitely over the provided elements.
   *
   * <p>The returned iterator supports {@code remove()}. After {@code remove()} is called,
   * subsequent cycles omit the removed element, but {@code elements} does not change. The

                .resolve(Objects.requireNonNull(directory, "directory cannot be null"))
                .normalize();
        sources.removeIf(source -> source.scope() == scope
                && source.language() == language
                && source.directory().equals(path));
    }

    /**
     * Removes a source root from the project.
     *
     * @param scope the scope of the source root

    taskFaker.runNextTask()
    assertThat(cache.remove("a")).isTrue()
    assertAbsent("a")
    cache.close()
    createNewCache()

    // The journal will have no record that 'a' was removed. It will have an entry for 'a', but when
    // it tries to read the cache files, it will find they were deleted. Once it encounters an entry
    // with missing cache files, it should remove it from the cache entirely.

        } finally {
          unlock();
        }
      }
    }

    /**
     * Removes an entry from within a table. All entries following the removed node can stay, but
     * all preceding ones need to be cloned.
     *
     * <p>This method does not decrement count for the removed entry, but does decrement count for

    @Override
    public boolean remove(@Nullable Object key, @Nullable Object value) {
      return map.entrySet().remove(Maps.immutableEntry(key, value));
    }

    @Override
    public Set<V> removeAll(@Nullable Object key) {
      Set<V> values = new HashSet<>(2);
      if (!map.containsKey(key)) {
        return values;
      }
      values.add(map.remove(key));
      return values;
    }

# then tackle this issue again.
#
# TODO: Remove the following two lines once TF doesn't depend on Bazel wrapping
# all library archives in -whole_archive -no_whole_archive.
common --noincompatible_remove_legacy_whole_archive
common --features=-force_no_whole_archive
common --host_features=-force_no_whole_archive

# TODO(mihaimaruseac): Document this option or remove if no longer needed
common --enable_platform_specific_config

      }
    }

    @Override
    public @Nullable V remove(@Nullable Object key) {
      synchronized (mutex) {
        return delegate().remove(key);
      }
    }

    @Override
    public boolean remove(@Nullable Object key, @Nullable Object value) {
      synchronized (mutex) {
        return delegate().remove(key, value);
      }
    }

    @Override

    assertTrue(cycle.hasNext());
    assertThrows(IllegalStateException.class, () -> cycle.remove());
  }

  public void testCycleRemoveSameElementTwice() {
    Iterator<String> cycle = Iterators.cycle("a", "b");
    cycle.next();
    cycle.remove();
    assertThrows(IllegalStateException.class, () -> cycle.remove());
  }

  public void testCycleWhenRemoveIsNotSupported() {