if (first.getPattern().startsWith(second.getPattern())) {
                    toRemove.add(second);
                } else if (second.getPattern().startsWith(first.getPattern())) {
                    toRemove.add(first);
                    break;
                }
            }
        }
        if (toRemove.isEmpty()) {
            return patterns;
        } else {

	for key := range evictUnits {
		toRemove := len(evictUnits[key]) - MaxContainers

		if toRemove > 0 {
			evictUnits[key] = cgc.removeOldestN(ctx, evictUnits[key], toRemove)
		}
	}
}

// removeOldestN removes the oldest toRemove containers and returns the resulting slice.
func (cgc *containerGC) removeOldestN(ctx context.Context, containers []containerGCInfo, toRemove int) []containerGCInfo {

    }

    public Identifier safeForGradleDomainObjectName() {
        return without(GRADLE_NAME_FORBIDDEN_CHARACTERS);
    }

    public Identifier without(String toRemove) {
        String newSuffix = suffix;
        for (char c : toRemove.toCharArray()) {
            newSuffix = newSuffix.replace(c, '-');
        }
        return new Identifier(newSuffix, displayName);
    }

        return result;
      }

      @Override
      public void remove() {
        checkState(toRemove != null, "no calls to next() since the last call to remove()");
        LinkedHashMultimap.this.remove(toRemove.getKey(), toRemove.getValue());
        toRemove = null;
      }
    };
  }

  @Override
  Iterator<V> valueIterator() {
    return Maps.valueIterator(entryIterator());
  }

        return result;
      }

      @Override
      public void remove() {
        checkState(toRemove != null, "no calls to next() since the last call to remove()");
        LinkedHashMultimap.this.remove(toRemove.getKey(), toRemove.getValue());
        toRemove = null;
      }
    };
  }

  @Override
  Spliterator<Entry<K, V>> entrySpliterator() {

        changedWatchDirectories.forEach((absolutePath, value) -> {
            int count = value;
            if (count < 0) {
                int toRemove = -count;
                int contained = watchedDirectories.remove(absolutePath, toRemove);
                if (contained <= toRemove) {
                    directoriesToStopWatching.add(new File(absolutePath));
                }
            } else if (count > 0) {

    }

    @Execute
    public HtmlResponse prev(final SearchForm form) {
        return doMove(form, -1);
    }

    @Execute
    public HtmlResponse next(final SearchForm form) {
        return doMove(form, 1);
    }

    @Execute
    public HtmlResponse move(final SearchForm form) {
        return doMove(form, 0);
    }

    protected HtmlResponse doSearch(final SearchForm form) {

      next = entry.nextInKeyInsertionOrder;
      toRemove = entry;
      remaining--;
      return output(entry);
    }

    @Override
    public void remove() {
      if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
      }
      if (toRemove == null) {

    }

    def compile(TestFile... sourceToCompile) {
        List<TestFile> toCompile = Arrays.asList(sourceToCompile)
        List<TestFile> toRemove = sourceFiles - toCompile
        2 * spec.getSourceFiles() >> toCompile
        1 * spec.getRemovedSourceFiles() >> toRemove
        cleanCompiler.execute(spec)
    }

    def createObjDummy(File sourceFile) {

                configurations {
                    toRemove
                }
                eclipse {
                    classpath {
                        minusConfigurations += [ configurations.toRemove ]
                    }
                }
                dependencies {
                    implementation project(":child1");
                    toRemove project(":child1");
                }
            }