assert expected instanceof KotlinDslScriptsModel
        assert actual instanceof KotlinDslScriptsModel

        checkModel(actual, expected, [
            [{ it.scriptModels }, { a, e -> checkKotlinDslScriptModel(a, e) }]
        ])
    }

    static void checkKotlinDslScriptModel(actual, expected) {
        assert expected instanceof KotlinDslScriptModel

    }

    private static void assertModelIsPolymorphic(Object model) {
        assert model != null

        assert model instanceof BaseModel

        assert model instanceof ShallowChildModel
        assert ((ShallowChildModel) model).getShallowMessage() == "shallow poly from 'root'"

        assert model instanceof DeepChildModel
        assert ((DeepChildModel) model).getDeepMessage() == "deep poly from 'root'"

    protected ConfigurationCacheProblemsFixture problems

    def setup() {
        // Verify that the previous test cleaned up state correctly
        assert System.getProperty(StartParameterBuildOptions.ConfigurationCacheOption.PROPERTY_NAME) == null
        assert System.getProperty(StartParameterBuildOptions.IsolatedProjectsOption.PROPERTY_NAME) == null
        problems = new ConfigurationCacheProblemsFixture(testDirectory)
    }

        given:
        buildFile """
        task check {
            assert gradle.startParameter.configurationCache.get() == ${ccOn}
            assert ${maxProblems == _ } || gradle.startParameter.configurationCacheMaxProblems == ${maxProblems}
            assert ${problemsAs == _ } || gradle.startParameter.configurationCacheProblems.name() == "${problemsAs}"
            assert ${quiet == _ } || gradle.startParameter.configurationCacheQuiet == ${quiet}

		return fmt.Sprintf("%v/%v: %v", have.Name, haveType, s)
	}
	if want.Name != "" {
		assert.Equal(t, want.Name, have.Name, context("name should be equal"))
	}
	if want.Type != "" {
		assert.Equal(t, want.Type, haveType, context(fmt.Sprintf("type should be equal (%+v)", have.FilterChainMatch)))
	}
	if want.Port != 0 {
		assert.Equal(t, want.Port, have.GetFilterChainMatch().GetDestinationPort().GetValue(), context("port should be equal"))

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.cc.impl

import org.junit.Assert
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test
import java.lang.IllegalStateException
import java.util.concurrent.Executors


class InputTrackingStateTest {

    @Test

        assert accessedFile.exists()
        configurationCacheRunLenient()

        then: "the cache entry is reused"
        configurationCache.assertStateLoaded()

        when: "the file used in configuration is deleted and a directory is created in its place"
        assert accessedFile.isFile()
        assert accessedFile.delete()
        assert accessedFile.mkdirs()

 * limitations under the License.
 */

package org.gradle.internal.cc.impl

import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertThrows
import org.junit.Assert.assertTrue
import org.junit.Test
import java.util.Collections
import java.util.concurrent.CountDownLatch
import kotlin.concurrent.thread

    @Test
    fun `defers evaluation of Callable objects`() {
        assertDeferredEvaluationOf(callable()) {
            call()
        }
    }

    @Test
    fun `defers evaluation of dynamic Callable fields`() {
        assertDeferredEvaluationOf(BeanOf(callable())) {
            value.call()
        }
    }

    @Test
    fun `defers evaluation of static Callable fields`() {

    @Test
    fun `defers evaluation of Supplier objects`() {
        assertDeferredEvaluationOf(supplier()) {
            get()
        }
    }

    @Test
    fun `defers evaluation of dynamic Supplier fields`() {
        assertDeferredEvaluationOf(BeanOf(supplier())) {
            value.get()
        }
    }

    @Test
    fun `defers evaluation of static Supplier fields`() {