fun <V> Map<String, V>.filterKeysByPrefix(prefix: String): Map<String, V?> =
    filterKeys { key -> key.length > prefix.length && key.startsWith(prefix) }


/**
 * Inverts the given map by swapping its keys with their corresponding values and returns the resulting map.
 *
 * If the original map contains duplicate values, the resulting map will map each value to the key associated
 * with the last occurrence of that value in the original map's iteration order.

    ModuleComponentArtifactIdentifier artifact
    File artifactFile = Mock(File)
    File signatureFile = Mock(File)

    @Issue("https://github.com/gradle/gradle/issues/11999")
    def "handles duplicate keys"() {
        artifact("org", "foo", "1.0")

        when:
        artifactFile.exists() >> true
        signatureFile.exists() >> true
        verify()

        then:

        for (K item : keys) {
            destination.put(item, keyGenerator.transform(item));
        }
    }

    /**
     * Given a set of keys, derive a set of values and return a map
     */

        final List<DependencyVerificationConfiguration.TrustedKey> keys = configuration.getTrustedKeys();
        if (keys.isEmpty()) {
            return;
        }
        writer.startElement(TRUSTED_KEYS);
        Map<String, List<DependencyVerificationConfiguration.TrustedKey>> groupedByKeyId = keys
            .stream()

 * plugins {
 *     id 'war' // or 'ear' or 'java'
 *     id 'eclipse-wtp'
 * }
 *
 * eclipse {
 *   wtp {
 *     facet {
 *       //you can add some extra wtp facets or update existing ones; mandatory keys: 'name', 'version':
 *       facet name: 'someCoolFacet', version: '1.3'
 *
 *       file {
 *         //if you want to mess with the resulting XML in whatever way you fancy
 *         withXml {

        addPrefixedSigningProperties(args.prefix, properties.keyId, properties.secretKeyRingFile, properties.password)
    }

    def getKeyResourceFile(setName, fileName) {
        getResourceFile("keys/$setName/$fileName")
    }

    def getResourceFile(path) {
        def copiedFile = temporaryFolder.file(path)
        if (!copiedFile.exists()) {
            copiedFile.parentFile.mkdirs()
            Files.copy(

         */
        @Nullable
        List<String> getActionClassNames();

        /**
         * The input value property hashes.
         * <p>
         * key = property name
         * <p>
         * Ordered by key, lexicographically.
         * No null keys or values.
         * Never empty.
         * Null if the task has no inputs.
         */
        @Nullable
        Map<String, byte[]> getInputValueHashesBytes();

        private static final String LONG_OPTION = "refresh-keys";

        public RefreshKeysOption() {
            super(null,
                CommandLineOptionConfiguration.create(LONG_OPTION, "Refresh the public keys used for dependency verification."));
        }

        @Override

fun sourceNameOfBinaryName(binaryName: String): String =
    when (binaryName) {
        "void" -> "Unit"
        "?" -> "*"
        in mappedTypeStrings.keys -> mappedTypeStrings[binaryName]!!
        in primitiveTypeStrings.keys -> primitiveTypeStrings[binaryName]!!
        else -> binaryName.replace('$', '.')
    }


/**
 * See https://kotlinlang.org/docs/reference/java-interop.html#mapped-types

        setupSystemProperties()
        System.clearProperty("javax.net.ssl.keyStorePassword")

        when:
        performAuthenticatedRequest(false)

        // NOTE: This should fail, as the private keys password must match
        //       the keystore password, so a password is necessary
        then:
        Exception exception = thrown()
        TestUtil.isOrIsCausedBy(exception, UnrecoverableKeyException.class)
    }