/**
     * Creates a new map instance whose keys are Class instances. Keys are referenced using strong or weak references, values by strong or other references depending on their usage.
     * This allows the classes to be collected.
     *
     * <p>A map differs from a cache in that entries are not discarded based on memory pressure, but are discarded only when the key is collected.

        if (!declarationsBySchemaFunctions.isEmpty()) {
            collectorDeclarationsByClass[kClass] = declarationsBySchemaFunctions
        }

        return declarationsBySchemaFunctions.keys
    }

    override fun constructors(kClass: KClass<*>, preIndex: DataSchemaBuilder.PreIndex): Iterable<DataConstructor> = emptyList()

            return null;
        }
    }

    public static String toLongIdHexString(long key) {
        return String.format("%016X", key).trim();
    }

    public static String toHexString(byte[] fingerprint) {
        return Fingerprint.wrap(fingerprint).toString();
    }

        assertTrue(schema.analysisSchema.dataClassesByFqName.keys.any { it.simpleName == NestedReceiver::class.simpleName })
    }

    @Test
    fun `general dsl schema has types discovered via factory functions`() {
        val schema = schemaFrom(UtilsContainer::class)
        assertTrue(schema.analysisSchema.dataClassesByFqName.keys.any { it.simpleName == NestedReceiver::class.simpleName })
    }

    @Test

     *
     * @param key the key
     * @param value the value
     */
    void put(K key, V value);

    /**
     * Adds a map entry to the property value.
     *
     * <p>The given provider will be queried when the value of this property is queried.
     * This property will have no value when the given provider has no value.
     *
     * @param key the key

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.

                } catch (MissingPropertyException e) {
                    throw new GradleException(String.format("Missing property (%s) for Groovy template expansion. Defined keys %s.", e.getProperty(), properties.keySet()), e);
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            }
        });
    }