{
		name:        "built-ins",
		explanation: withSource("this test expects slog.TimeKey, slog.LevelKey and slog.MessageKey"),
		f: func(l *slog.Logger) {
			l.Info("message")
		},
		checks: []check{
			hasKey(slog.TimeKey),
			hasKey(slog.LevelKey),
			hasAttr(slog.MessageKey, "message"),
		},
	},
	{
		name:        "attrs",
		explanation: withSource("a Handler should output attributes passed to the logging function"),

	b.Name = &value
	return b
}

// WithSource sets the Source field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Source field is set to the value of the last call.
func (b *PodResourceClaimApplyConfiguration) WithSource(value *ClaimSourceApplyConfiguration) *PodResourceClaimApplyConfiguration {

    }

    def "can combine categories with custom runner"() {
        given:
        testSources.with {
            testCategory('CategoryA')
            sourceFile('LocaleHolder.java').withSource("""
                import java.util.Locale;

                class LocaleHolder {
                    private static Locale locale;

                    public static Locale set(Locale locale) {

public interface ModuleSources {
    <T extends ModuleSource> Optional<T> getSource(Class<T> sourceType);

    void withSources(Consumer<ModuleSource> consumer);

    /**
     * Executes an action on the first source found of the following type, if any.
     */
    default <T extends ModuleSource, R> R withSource(Class<T> sourceType, Function<Optional<T>, R> action) {
        return action.apply(getSource(sourceType));
    }

    }

    def "can combine tags with custom extension"() {
        given:
        testSources.with {
            sourceFile("Locales.java").withSource("""
                import org.junit.jupiter.api.extension.Extension;
                import org.junit.jupiter.api.extension.ExtensionContext;
                import org.junit.jupiter.api.extension.ParameterContext;

        message.contains('some.ArbitraryClass.withSource')

        where:
        fakeStackTrace = [
            new StackTraceElement(LoggingDeprecatedFeatureHandlerTest.name, 'calledFrom', 'FeatureUsageTest.java', 23),
            new StackTraceElement('some.ArbitraryClass', 'withSource', 'ArbitraryClass.java', 42),
        ]

    }

    private static Transformer<Object, ModuleComponentResolveMetadata> getKeyToSnapshotableTransformer() {
        return moduleMetadata -> moduleMetadata.getSources().withSource(ModuleDescriptorHashModuleSource.class, source -> {
            return source.map(metadataFileSource -> metadataFileSource.getDescriptorHash().toString() + moduleMetadata.getVariantDerivationStrategy().getClass().getName())

                sources.withSources(DefaultMetadataFileSource.class, metadataFileSource -> {
                    ModuleComponentArtifactIdentifier artifact = metadataFileSource.getArtifactId();
                    if (isExternalArtifactId(artifact)) {
                        sources.withSource(ModuleDescriptorHashModuleSource.class, hashSource -> {

	panic("unimplemented")
}

func (f *recorderResourceManager) ServeHTTP(http.ResponseWriter, *http.Request) {
	panic("unimplemented")
}

func (f *recorderResourceManager) WithSource(source Source) ResourceManager {
	panic("unimplemented")

	// Returns the same resource manager using a different source
	// The source is used to decide how to de-duplicate groups.
	// The group from the least-numbered source is used
	WithSource(source Source) ResourceManager

	http.Handler
}

type resourceManager struct {
	source Source
	*resourceDiscoveryManager
}