assertThat(map.get("d")).isEqualTo("4");

    underlying.remove("c");
    assertEquals(underlying.size(), map.size());
    assertFalse(map.containsKey("c"));

    underlying.clear();
    assertEquals(underlying.size(), map.size());
  }

  public void testTransformChangesAreReflectedInUnderlyingMap() {
    Map<String, Integer> underlying = new LinkedHashMap<>();
    underlying.put("a", 1);

                result.getManagedVersions(),
                result.getResolutionRepositories());

        cache.put(cacheKey, cacheRecord);
    }

    @Override
    public void flush() {
        cache.clear();
    }

     * @return HTML response with the reset related content list
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse reset(final SearchForm form) {
        relatedContentPager.clear();
        return asHtml(path_AdminRelatedcontent_AdminRelatedcontentJsp).renderWith(data -> {
            searchPaging(data, form);
        });
    }

    /**

            for (final String lang : form.lang) {
                if (StringUtil.isNotBlank(lang) && lang.length() < 1000) {
                    if (Constants.ALL_LANGUAGES.equals(lang)) {
                        langSet.clear();
                        break;
                    }
                    final String normalizeLang = systemHelper.normalizeLang(lang);
                    if (normalizeLang != null) {

        try (PrintWriter fw = new PrintWriter(new FileWriter(reportFile))) {
            writeHeader(fw);
            if (errors.isEmpty()) {
                fw.println("All clear!");
                return;
            }
            for (Map.Entry<File, List<Error>> e : errors.entrySet()) {
                File file = e.getKey();
                List<Error> errorsForFile = e.getValue();

internal fun FileSystem.deleteIfExists(path: Path) {
  try {
    delete(path)
  } catch (fnfe: FileNotFoundException) {
    return
  }
}

/** Tolerant delete, try to clear as many files as possible even after a failure. */
internal fun FileSystem.deleteContents(directory: Path) {
  var exception: IOException? = null
  val files =
    try {
      list(directory)

      CharBuffer buffer = CharBuffer.allocate(100);
      while (reader.read(buffer) != -1) {
        Java8Compatibility.flip(buffer);
        builder.append(buffer);
        Java8Compatibility.clear(buffer);
      }
      return builder.toString();
    }
  }

  private static class UrlByteSourceFactory extends FileByteSourceFactory {

        }
    }

    /**
     * Invalidate the cache
     */
    public void invalidate() {
        lock.writeLock().lock();
        try {
            children.clear();
            isComplete = false;
            hasChanges = true;
        } finally {
            lock.writeLock().unlock();
        }
    }

    /**
     * Gets the directory path for this cache entry

				err = msgp.WrapError(err, "OldDataDir")
				return
			}
			zb0001Mask |= 0x1
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.OldDataDir = ""
	}

	return
}

// EncodeMsg implements msgp.Encodable
func (z *DeleteOptions) EncodeMsg(en *msgp.Writer) (err error) {

  public void testSkip_structurallyModifiedSkipSomeList() throws Exception {
    List<String> list = Lists.newArrayList("a", "b", "c");
    FluentIterable<String> tail = FluentIterable.from(list).skip(1);
    list.subList(1, 3).clear();
    list.addAll(0, Lists.newArrayList("X", "Y", "Z"));
    assertThat(tail).containsExactly("Y", "Z", "a").inOrder();
  }

  public void testSkip_structurallyModifiedSkipAll() throws Exception {