public class MapsSortedTransformValuesTest extends AbstractMapsTransformValuesTest {
  @Override
  protected SortedMap<String, String> makeEmptyMap() {
    return transformValues(Maps.<String, String>newTreeMap(), Functions.<String>identity());
  }

  @Override
  protected SortedMap<String, String> makePopulatedMap() {
    SortedMap<String, Integer> underlying = Maps.newTreeMap();
    underlying.put("a", 1);
    underlying.put("b", 2);

  public void testIdentity_same() {
    Function<@Nullable String, @Nullable String> identity = Functions.identity();
    assertThat(identity.apply(null)).isNull();
    assertThat(identity.apply("foo")).isSameInstanceAs("foo");
  }

  public void testIdentity_notSame() {
    Function<Long, Long> identity = Functions.identity();
    assertThat(identity.apply(new Long(135135L))).isNotSameInstanceAs(new Long(135135L));
  }

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.artifact;

/**
 * Exception thrown when the identity of an artifact can not be established,
 * e.g. one of groupId, artifactId, version or type is null.
 */
public class InvalidArtifactRTException extends RuntimeException {

    private final String groupId;

}

description = "Provides a plugin to generate Gradle's DSL reference, User Manual and Javadocs"

dependencies {
    implementation("gradlebuild:basics")
    implementation("gradlebuild:module-identity")

    implementation(projects.buildUpdateUtils)

    implementation(buildLibs.gradleGuidesPlugin)
    implementation(buildLibs.javaParserCore)
    implementation(buildLibs.guava)

   *
   * <p>It is recommended that the funnel be implemented as a Java enum. This has the benefit of
   * ensuring proper serialization and deserialization, which is important since {@link #equals}
   * also relies on object identity of funnels.
   *
   * @param funnel the funnel of T's that the constructed {@code BloomFilter} will use
   * @param expectedInsertions the number of expected insertions to the constructed {@code

	"github.com/minio/minio/internal/config/heal"
	xldap "github.com/minio/minio/internal/config/identity/ldap"
	"github.com/minio/minio/internal/config/identity/openid"
	idplugin "github.com/minio/minio/internal/config/identity/plugin"
	xtls "github.com/minio/minio/internal/config/identity/tls"
	"github.com/minio/minio/internal/config/ilm"
	"github.com/minio/minio/internal/config/lambda"

  ASSERT_TRUE(TF_GetCode(status.get()) == TF_OK) << TF_Message(status.get());

  std::unique_ptr<TFE_Op, decltype(&TFE_DeleteOp)> reused_op(
      TFE_NewOp(context.get(), "Identity", status.get()), TFE_DeleteOp);
  TFE_OpReset(reused_op.get(), "Identity", custom_device_name, status.get());
  ASSERT_TRUE(TF_GetCode(status.get()) == TF_OK) << TF_Message(status.get());
  ASSERT_EQ(tensorflow::string(TFE_OpGetDevice(reused_op.get(), status.get())),

import gradlebuild.basics.capitalize
import gradlebuild.pluginpublish.extension.PluginPublishExtension
import org.gradle.plugin.compatibility.compatibility
import java.time.Year

plugins {
    id("gradlebuild.module-identity")
    `maven-publish`
    signing
    `java-gradle-plugin`
    id("com.gradle.plugin-publish")
}

extensions.create<PluginPublishExtension>("pluginPublish", gradlePlugin)

tasks.validatePlugins {

    from(components["java"])
    artifactId = gradleModule.identity.baseName.get()
    versionMapping {
        usage("java-api") {
            fromResolutionResult()
        }
        usage("java-runtime") {
            fromResolutionResult()
        }
    }

    pom {
        packaging = "jar"
        name = gradleModule.identity.baseName.map { "${project.group}:$it" }
    }
}

 *
 * The algorithm map will be turned into a heading such as "Accept-Encoding: br, gzip"
 *
 * If [algorithms] is empty this interceptor has no effect. To disable compression set
 * a specific "Accept-Encoding: identity" or similar.
 *
 * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Accept-Encoding
 */
open class CompressionInterceptor(
  vararg val algorithms: DecompressionAlgorithm,
) : Interceptor {