} else if (values.hasAnyNegativeInfinity()) {
        assertWithMessage("mean of " + values).that(mean).isNegativeInfinity();
      } else {
        assertWithMessage("mean of " + values)
            .that(mean)
            .isWithin(ALLOWED_ERROR)
            .of(MANY_VALUES_MEAN);
      }
    }

        where:
        firstBuildArgs | firstRequest | secondBuildArgs | secondRequest
        ['--scan']     | REQUESTED    | []              | null
        []             | null         | ['--scan']      | REQUESTED
        ['--scan']     | REQUESTED    | ['--scan']      | REQUESTED
    }

    void assertRequestedOrNotApplied(@Nullable GradleEnterprisePluginConfig.BuildScanRequest buildScanRequest) {

            }

            class Bean {
                @InputFiles FileCollection files
            }

            abstract class Test extends DefaultTask {
                @Nested abstract Property<Bean> getBean()
                @TaskAction def test() { assert false }
            }

            tasks.register('test', Test) {
                bean = new Bean().tap {

 */

package org.gradle.api.internal.tasks.properties.bean

import org.gradle.internal.properties.bean.ImplementationResolver
import org.gradle.internal.snapshot.impl.ImplementationValue

class TestImplementationResolver implements ImplementationResolver {
    @Override
    ImplementationValue resolveImplementation(Object bean) {
        new ImplementationValue(bean.getClass().getName(), bean)
    }

                Object bean

                @OutputFile
                final RegularFileProperty outputFile = project.objects.fileProperty()

                @TaskAction
                void writeInputToFile() {
                    outputFile.getAsFile().get().text = bean == null ? 'null' : bean.toString()
                    if (bean != null) {
                        bean.doStuff()
                    }

        given:
        def bean = create(Bean, Describables.of("<display name>"))
        def beanWithNoName = create(Bean)

        expect:
        bean.toString() == "<display name>"
        bean.hasUsefulDisplayName()
        bean.modelIdentityDisplayName.displayName == "<display name>"

        beanWithNoName.toString().startsWith("${Bean.name}_Decorated@")
        !beanWithNoName.hasUsefulDisplayName()

	if res.ID != user3.ID || res.Name != user3.Name || res.Age != int(user3.Age) {
		t.Fatalf("Scan into struct should work, got %#v, should %#v", res, user3)
	}

	doubleAgeRes := &result{}
	if err := DB.Table("users").Select("age + age as age").Where("id = ?", user3.ID).Scan(&doubleAgeRes).Error; err != nil {
		t.Errorf("Scan to pointer of pointer")
	}

	if doubleAgeRes.Age != int(res.Age)*2 {

        // track the closure itself, not the action class.
        if (bean instanceof ConfigureUtil.WrappedConfigureAction) {
            return ((ConfigureUtil.WrappedConfigureAction<?>) bean).getConfigureClosure();
        }

        if (bean instanceof ClosureBackedAction) {
            return ((ClosureBackedAction<?>) bean).getClosure();
        }
        return bean;
    }

    enum BuildScanRequest {
        NONE, // no explicit request
        REQUESTED, // --scan is present, but not --no-scan
        SUPPRESSED // --no-scan is present
    }

    BuildScanRequest getBuildScanRequest();

    boolean isTaskExecutingBuild();

    /**
     * Whether the plugin was auto-applied via {@code --scan} without being explicitly applied.
     *
     * @since 8.0
     */
    boolean isAutoApplied();

        val bean = beanReader.run { newBeanWithId(generated, id) }
        val effectiveBeanType = bean.javaClass
        val effectiveBeanReader =
            if (beanType === effectiveBeanType) beanReader
            else beanStateReaderFor(effectiveBeanType)
        effectiveBeanReader.run {
            readStateOf(bean)
        }
        return bean
    }