}

    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'"

            BigDecimal createBigDecimal() {
                return 123
            }
        })

        expect:
        10.times {
            start {
                assert registry.get(String) == "12"
                assert registry.get(Long) == 123
            }
        }
    }

    def "multiple threads can locate factories"() {
        def registry = new DefaultServiceRegistry()

			expectedFullPath: "unix:/path/file.sock",
		},
	}
	for _, test := range tests {
		fullPath, err := LocalEndpoint(test.path, test.file)
		if test.expectError {
			assert.NotNil(t, err, "expected error")
			continue
		}
		assert.Nil(t, err, "expected no error")
		assert.Equal(t, test.expectedFullPath, fullPath)
	}

            GradleConnectionException failure = args[0]
            assert failure instanceof BuildActionFailureException
            GradleConnectionException cause = failure.cause
            assert cause instanceof UnknownModelException
            assert cause.message == "No model of type '${CustomModel2.simpleName}' is available in this build."

            assert action.startParameter == startParameter
            assert context.cancellationToken instanceof DefaultBuildCancellationToken
            assert context.client == clientMetaData
            assert context.startTime == startTime
            assert build == parameters
            return BuildActionResult.of(null)
        }

    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"))

            }

            assert configurations.apiElements.attributes.getAttribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE) == ${javaVersion}
            assert configurations.runtimeElements.attributes.getAttribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE) == ${javaVersion}

 * 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