}
  }

  public final void testPut() {
    for (Table<Character, Integer, String> testInstance : getTestInstances()) {
      assertThrows(UnsupportedOperationException.class, () -> testInstance.put('a', 1, "blah"));
    }
  }

  public final void testPutAll() {
    for (Table<Character, Integer, String> testInstance : getTestInstances()) {
      assertThrows(
          UnsupportedOperationException.class,

    val globalExtension = rootProject.extensions.getByType<TestFilesCleanupBuildServiceRootExtension>()

    val projectState = objects.newInstance(TestFilesCleanupProjectState::class.java)

    globalExtension.projectStates.put(path, projectState)
    projectState.projectBuildDir = layout.buildDirectory
    projectState.projectPath = path
    projectState.reportOnly = testFilesCleanup.reportOnly

    ResolutionGroup get(
            Artifact artifact,
            boolean resolveManagedVersions,
            ArtifactRepository localRepository,
            List<ArtifactRepository> remoteRepositories);

    void put(
            Artifact artifact,
            boolean resolveManagedVersions,
            ArtifactRepository localRepository,
            List<ArtifactRepository> remoteRepositories,
            ResolutionGroup result);

        for (int i = 1; key != null || value != null; i++) {
            List<String> values = map.get(key);
            if (values == null) {
                values = new ArrayList<>();
                map.put(key, values);
            }
            values.add(value);
            key = this.connection.getHeaderFieldKey(i);
            value = this.connection.getHeaderField(i);
        }

    @Test
    void testGetTrustedDomains_Cached() throws SmbAuthException {
        Dfs.CacheEntry cacheEntry = new Dfs.CacheEntry(300);
        HashMap<String, HashMap> trustedDomains = new HashMap<>();
        trustedDomains.put("domain.com", new HashMap());
        cacheEntry.map = trustedDomains;
        dfs._domains = cacheEntry;

        assertEquals(trustedDomains, dfs.getTrustedDomains(auth));
    }

    @Test

  @Override
  public boolean containsValue(@Nullable Object value) {
    return inverse.containsKey(value);
  }

  // Modification Operations

  @CanIgnoreReturnValue
  @Override
  public @Nullable V put(@ParametricNullness K key, @ParametricNullness V value) {
    return putInBothMaps(key, value, false);
  }

  @CanIgnoreReturnValue
  @Override

      for (int index2 = 0; index2 <= 100; index2++) {
        ImmutableMap.Builder<Integer, Double> expectedBuilder = ImmutableMap.builder();
        expectedBuilder.put(index1, expectedLargeDatasetPercentile(index1));
        if (index2 != index1) {
          expectedBuilder.put(index2, expectedLargeDatasetPercentile(index2));
        }
        assertThat(percentiles().indexes(index1, index2).compute(PSEUDORANDOM_DATASET))

      for (int index2 = 0; index2 <= 100; index2++) {
        ImmutableMap.Builder<Integer, Double> expectedBuilder = ImmutableMap.builder();
        expectedBuilder.put(index1, expectedLargeDatasetPercentile(index1));
        if (index2 != index1) {
          expectedBuilder.put(index2, expectedLargeDatasetPercentile(index2));
        }
        assertThat(percentiles().indexes(index1, index2).compute(PSEUDORANDOM_DATASET))

        public List<Artifact> getArtifacts() {
            return artifacts;
        }
    }

    Key createKey(List<Artifact> extensionArtifacts);

    CacheRecord get(Key key);

    CacheRecord put(
            Key key, ClassRealm extensionRealm, ExtensionDescriptor extensionDescriptor, List<Artifact> artifacts);

    void flush();

    /**

                for (Dependency dependency : model.getDependencies()) {
                    Object key = getDependencyKey(dependency);
                    dependencies.put(key, dependency);
                }

                for (Dependency managedDependency : dependencyManagement.getDependencies()) {
                    Object key = getDependencyKey(managedDependency);