import static org.gradle.performance.annotations.ScenarioType.PER_DAY
import static org.gradle.performance.results.OperatingSystem.LINUX
import static org.gradle.performance.results.OperatingSystem.MAC_OS
import static org.gradle.performance.results.OperatingSystem.WINDOWS

@RunFor(

            public void run() {
                T oldValue = deserialize();
                result = updateAction.update(oldValue);
                if (!(oldValue == null && result == null) && (oldValue == null || result == null || !oldValue.equals(result))) {
                    serialize(result);
                } else {
                    result = oldValue;
                }
            }
        }

 * for example. This means that the result of executing the rule is not necessarily the same as the
 * details object. It must be possible for the consumer (the object which executes the rule) to reproduce
 * the result of executing the rule from the {@link RESULT} object.
 *
 * The cache key consists of the provided key and the rule. This means that if the implementation of the

        expirationStrategy.onOsMemoryStatus(mockMemoryStatus)

        then:
        DaemonExpirationResult result = expirationStrategy.checkExpiration()
        result.status == GRACEFUL_EXPIRE
        result.reason == "to reclaim system physical memory"
    }

    def "daemon should expire when virtual memory falls below threshold"() {
        given:

    def "contains of existing element is tracked"() {
        when:
        def result = set.contains('existing')

        then:
        result
        1 * listener.onAccess('existing')
        0 * listener._
    }

    def "contains of null is tracked"() {
        when:
        def result = set.contains(null)

        then:
        !result
        1 * listener.onAccess(null)
        0 * listener._
    }

        expect:
        def result = event.convert("")
        result.response == 4
        result.newPrompt == null
    }

    def "can have negative minimum value"() {
        def event = new IntQuestionPromptEvent(123, "question?", -5, -2)

        expect:
        def result = event.convert(input)
        result.response == expected
        result.newPrompt == null

        where:

        result.output =~ /VFS> Statistics during current build:/
        result.output =~ /Received \d+ file system events since last build while watching \d+ locations/
        result.output =~ /Virtual file system retained information about \d+ files, \d+ directories and \d+ missing files since last build/
        result.output =~ /Received \d+ file system events during the current build while watching \d+ locations/

                    parent--;
                }
                parent = result.lastIndexOf('/', parent);
                if (parent < 0) {
                    result = result.substring(idx + 4);
                } else {
                    result = result.substring(0, parent) + result.substring(idx + 3);
                }
            }
        }

        return result;
    }

        1 * c2.checkExpiration() >> { new DaemonExpirationResult(c2Status, "r2") }

        then:
        DaemonExpirationResult result = agg.checkExpiration()
        result.status == allStatus
        result.reason == "r1 and r2"

        where:
        c1Status         | c2Status         | allStatus
        QUIET_EXPIRE     | QUIET_EXPIRE     | QUIET_EXPIRE

    @Override
    public int getFailureCount() {
        int result = 0;
        for (XCTestElement element : getTestSuites()) {
            result += element.getFailureCount();
        }
        return result;
    }

    @Override
    public int getPassCount() {
        int result = 0;
        for (XCTestElement element : getTestSuites()) {
            result += element.getPassCount();
        }
        return result;