```kotlin
cache.evictAll()
```

Removing individual items can be done using the urls iterator.
This would be typical after a user initiates a force refresh by a pull to refresh type action.

```java
    val urlIterator = cache.urls()
    while (urlIterator.hasNext()) {
      if (urlIterator.next().startsWith("https://www.google.com/")) {
        urlIterator.remove()
      }

        module.pom.expectGet()

        then:
        executer.withArgument(execArg)
        succeeds("verify")

        where:
        condition                     | execArg
        "with --refresh-dependencies" | "--refresh-dependencies"
        "when maven pom changes"      | "-Pnocache"
    }

    private MavenHttpModule publishModule() {
        def module = createModule()
        module.publish()
    }

    String[] getRoleNames();

    String[] getGroupNames();

    String[] getPermissions();

    default boolean isEditable() {
        return false;
    }

    default boolean refresh() {
        return false;
    }

        module.ivy.expectGet()

        then:
        executer.withArgument(execArg)
        succeeds("verify")

        where:
        condition                     | execArg
        "with --refresh-dependencies" | "--refresh-dependencies"
        "when ivy descriptor changes" | "-Pnocache"
    }

    private IvyHttpModule publishModule() {
        def module = createModule()
        module.publish()
    }

	return restClient.Call("/v1/unlock", args)
}

func (restClient *ReconnectRESTClient) Refresh(ctx context.Context, args LockArgs) (refreshed bool, err error) {
	return restClient.Call("/v1/refresh", args)
}

func (restClient *ReconnectRESTClient) ForceUnlock(ctx context.Context, args LockArgs) (reply bool, err error) {

        latest.moduleMetadata.expectGet()
        latest.artifact.expectHead()
        latest.artifact.sha1.expectGet()
        latest.artifact.expectGet()

        succeeds ':checkDeps', '--refresh-dependencies'

        then:
        resolve.expectGraph {
            root(':', 'org.gradle:ro-test:20') {
                module('org.module:core:1.0-SNAPSHOT')
            }
        }

        and:

   * <p>Returns without doing anything if another thread is currently loading the value for {@code
   * key}. If the cache loader associated with this cache performs refresh asynchronously then this
   * method may return before refresh completes.
   *
   * @since 11.0
   */
  void refresh(K key);

  /**
   * {@inheritDoc}
   *
   * <p><b>Note that although the view <i>is</i> modifiable, no method on the returned map will ever

     * If not cachedResult is available, resolution should fail.
     */
    void useCachedResult();

    /**
     * States that any cached value should be ignored, forcing a fresh resolve.
     */
    void refresh();

)

// To abstract a node over network.
type lockRESTServer struct {
	ll *localLocker
}

// RefreshHandler - refresh the current lock
func (l *lockRESTServer) RefreshHandler(args *dsync.LockArgs) (*dsync.LockResp, *grid.RemoteErr) {
	resp := lockRPCRefresh.NewResponse()
	refreshed, err := l.ll.Refresh(context.Background(), *args)
	if err != nil {
		return l.makeResp(resp, err)
	}
	if !refreshed {

            }
        """

        when:
        withReadOnlyCache()
        latest.rootMetaData.allowGetOrHead()
        expectResolve(latest)
        if (resolveDynamic) {
            executer.withArgument("--refresh-dependencies")
        }

        succeeds ':checkDeps'

        then:
        resolve.expectGraph {
            root(':', 'org.gradle:ro-test:20') {