// We should not attempt to compare compatible/compatible2 with fromIndirect because we should not attempt to make this chain
        0 * attributeMatcher.isMatching(compatible, fromIndirect) >> true
        0 * attributeMatcher.isMatching(compatible2, fromIndirect) >> true

        // compatible, compatible2 and compatibleIndirect are all compatible with requested attributes

        def candidate2 = candidate("best", "best", "compatible")
        def candidate3 = candidate("best", "compatible", "compatible")
        def candidate4 = candidate("compatible", "best", "best")
        def candidate5 = candidate("compatible", "compatible", "best")
        def candidate6 = candidate("compatible", "compatible", "compatible")
        def requested = requested("requested", "requested","requested")

        expect:
        compatible
    }

    def "contexts with different quantity of opts are not compatible"() {
        clientWants(Jvm.forHome(javaHome), ["-Xmx256m", "-Dfoo=foo"])
        candidate.javaHome >> javaHome
        candidate.daemonOpts >> ["-Xmx256m"]

        expect:
        !compatible
        unsatisfiedReason.contains "At least one daemon option is different"

        when:
        compatible = [ d1, d2 ]

        then:
        wouldExpire(d1)
        wouldExpire(d2)
    }

    def "does not expire when there are no compatible daemons"() {
        given:
        DaemonInfo d1 = registerDaemon(Idle)
        DaemonInfo d2 = registerDaemon(Idle)
        DaemonInfo d3 = registerDaemon(Idle)

        when:
        compatible = []

        then:

            // they should not even be called in this case
            0 * details._()
        } else if (compatible) {
            1 * details.compatible()
        } else {
            0 * details._()
        }

        where:
        consumer                     | producer                                             | compatible

# JSON Compatible Encoder

There are some cases where you might need to convert a data type (like a Pydantic model) to something compatible with JSON (like a `dict`, `list`, etc).

For example, if you need to store it in a database.

For that, **FastAPI** provides a `jsonable_encoder()` function.

## Using the `jsonable_encoder`

Let's imagine that you have a database `fake_db` that only receives JSON compatible data.

        assert done;
        return compatible;
    }

    @Override
    public boolean hasResult() {
        return done;
    }

    @Override
    public T getConsumerValue() {
        return consumerValue;
    }

    @Override
    public T getProducerValue() {
        return producerValue;
    }

    @Override
    public void compatible() {
        done = true;

	m1[i0] = 42
	m1[i1] = 42
	m1[new(struct {
		x int
	})] = 42       // this should work: *struct{x int} is assignment-compatible with I1
	m1[false] = 42 // this should work: false is assignment-compatible with I1
	m1[17] = 42    // this should work: 17 is assignment-compatible with I1
	m1["foo"] = 42 // this should work: "foo" is assignment-compatible with I1

        @Override
        void execute(CompatibilityCheckDetails<String> details) {
            assert details.consumerValue == "value1"
            assert details.producerValue == "value2"
            details.compatible()
        }
    }

    static class CompatibilityRuleWithParams implements AttributeCompatibilityRule<String> {
        String p1

        @Inject
        CompatibilityRuleWithParams(String p1) {

        when:
        def options = daemonForkOptionsBuilder().build()

        then:
        options.keepAliveMode == KeepAliveMode.DAEMON
    }

    def "is compatible with compatible java forkOptions"() {
        def javaForkOptions = TestFiles.execFactory().newJavaForkOptions()
        javaForkOptions.workingDir = systemSpecificAbsolutePath("foo")
        javaForkOptions.minHeapSize = "128m"