<simplelist columns="3" type="vert">
                        <member>
                            <apilink class="org.gradle.Subtype1"/>
                        </member>
                        <member>
                            <apilink class="org.gradle.Subtype2"/>
                        </member>
                        <member>
                            <apilink class="org.gradle.Subtype3"/>

    checkNotNull(map); // GWT specific check (do not optimize)
    if (map.isEmpty()) {
      return EMPTY_REPLACEMENT_ARRAY;
    }
    char max = max(map.keySet());
    char[][] replacements = new char[max + 1][];
    for (Character c : map.keySet()) {
      replacements[c] = map.get(c).toCharArray();
    }
    return replacements;
  }

  // Immutable empty array for when there are no replacements.

		BucketName:      bucketName,
		ConditionValues: conditions,
		ObjectName:      objectName,
		IsOwner:         owner,
		Claims:          cred.Claims,
	}) {
		retSet = true
	}
	if byPassSet || retSet {
		return ErrNone
	}
	return ErrAccessDenied
}

// isPutActionAllowed - check if PUT operation is allowed on the resource, this

        assertEquals(2, crawlerContext.getRobotsTxtUrlSet().size());

        // Set new set
        Set<String> newSet = new HashSet<>();
        newSet.add("http://new.com/robots.txt");
        crawlerContext.setRobotsTxtUrlSet(newSet);
        assertSame(newSet, crawlerContext.getRobotsTxtUrlSet());
        assertEquals(1, crawlerContext.getRobotsTxtUrlSet().size());

        // Set null

            putAll(map);
        }
    }

    @Override
    public String toString() {
        StringBuilder buffer = new StringBuilder("ManagedVersionMap (" + size() + " entries)\n");
        Iterator<String> iter = keySet().iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            buffer.append(key).append('=').append(get(key));
            if (iter.hasNext()) {
                buffer.append('\n');

        return projects;
    }

    public Map<String, String> aliases() {
        return aliases;
    }

    public Stream<MavenProject> projects() {
        return plan.keySet().stream();
    }

    public void addProject(MavenProject project, Map<String, BuildStep> steps) {
        plan.put(project, steps);
    }

    public void addStep(MavenProject project, String name, BuildStep step) {

    return asList(
        getPutNullKeyUnsupportedMethod(),
        getPutAllNullKeyUnsupportedMethod(),
        getCreateWithNullKeyUnsupportedMethod(),
        getCreateWithNullUnsupportedMethod(), // for keySet
        getContainsEntryWithIncomparableKeyMethod(),
        getContainsEntryWithIncomparableValueMethod());
  }

  @Override
  protected Collection<Method> suppressForConcurrentHashMap() {
    /*

        NdrHyper hyper = new NdrHyper(original);
        // Create buffer with extra space for alignment
        NdrBuffer buf = new NdrBuffer(new byte[16], 0);
        hyper.encode(buf);
        // Reset buffer position for decoding
        buf.reset();
        NdrHyper decoded = new NdrHyper(0);
        decoded.decode(buf);
        assertEquals(original, decoded.value, "Decoded value should match encoded value");
    }

    /**

      }
    }
    out.close();

    // Check that source returns the right data
    assertThat(source.read()).isEqualTo(data);

    // Make sure that reset deleted the file
    out.reset();
    if (file != null) {
      assertFalse(file.exists());
    }
  }


  public void testThreshold_resetOnFinalize() throws Exception {
    testThreshold(0, 100, true, true);

    assertEmpty(multimap());
    assertEquals(multimap(), getSubjectGenerator().create());
    assertEmpty(multimap().entries());
    assertEmpty(multimap().asMap());
    assertEmpty(multimap().keySet());
    assertEmpty(multimap().keys());
    assertEmpty(multimap().values());
    for (K key : sampleKeys()) {
      assertGet(key);
    }
  }

  @MapFeature.Require(SUPPORTS_REMOVE)