def id1 = new ChannelIdentifier("channel1")
        def id2 = new ChannelIdentifier("channel2")
        def message1 = new ChannelMessage(id1, "message 1")
        def message2 = broadcast()

        given:
        def endpoint1 = queue.getChannel(id1).newEndpoint()
        def endpoint2 = queue.getChannel(id2).newEndpoint()

        when:
        def messages1 = []
        def messages2 = []
        queue.queue(message1)

        when:
        def result = registry.get(BigDecimal)

        then:
        result == value

        and:
        1 * parent.get(BigDecimal) >> value
    }

    def delegatesToParentsForUnknownService() {
        def value = BigDecimal.TEN
        def parent1 = Mock(ParentServices)
        def parent2 = Mock(ParentServices)

        unfilteredSubsnapshots.add(snapshot)
    }

    def "should snapshot without filters"() {
        given:
        def rootDir = tmpDir.createDir("root")
        def rootTextFile = rootDir.file("a.txt").createFile()
        def nestedTextFile = rootDir.file("a/b/c.txt").createFile()
        def nestedSiblingTextFile = rootDir.file("a/c/c.txt").createFile()
        def notTextFile = rootDir.file("a/b/c.html").createFile()

        def listener = Mock(ProgressListener)
        def adapter = createAdapter(listener)

        when:
        def unknownEvent = Mock(InternalTestProgressEvent)
        adapter.onEvent(unknownEvent)

        then:
        0 * listener.statusChanged(_)
    }

    def "conversion of start events throws exception if previous start event with same test descriptor exists"() {
        given:

    def format = new SimpleDateFormat('yyyyMMddHHmmssZ')

    def setup() {
        format.timeZone = TimeZone.getTimeZone("UTC")
    }

    def "final release is added to list"() {
        def snapshot = snapshot('4.3')
        def rc = releasedVersion('4.3-rc-1')
        def versions = releasedVersions(snapshot, rc, [])
        def version = new ReleasedVersion('4.2', '20170913122310+0000')

        def barFactory = factory(Bar)
        def buzzFactory = factory(Buzz)
        registry.withFactories(barFactory, fooFactory)

        expect:
        registry.lookup(buzzFactory.id) == null
    }

    def "can lookup factory in parent registry"() {
        def fooFactory = factory(Foo)
        def barFactory = factory(Bar)
        def parent = new DefaultManagedFactoryRegistry().withFactories(fooFactory)

        "Query(Ellipsis)",
    )


def test_query_repr_number():
    assert repr(Query(1)) == "Query(1)"


def test_query_repr_list():
    assert repr(Query([])) == "Query([])"


def test_header_repr_str():
    assert repr(Header("teststr")) == "Header(teststr)"


def test_header_repr_none():
    assert repr(Header(None)) == "Header(None)"


def test_header_repr_ellipsis():

    }

    def "attached GradleProperties methods succeed after loading"() {

        given:
        def loader = Mock(IGradlePropertiesLoader)
        def controller = new DefaultGradlePropertiesController(loader, Mock(SystemPropertiesInstaller), Mock(ProjectPropertiesLoader))
        def settingsDir = new File('.')
        def properties = controller.gradleProperties
        def loadedProperties = Mock(MutableGradleProperties)

    }

    def "view identity is retained when serialized"() {
        def protocolModel = new TestModelImpl()

        given:
        def model = adapter.adapt(TestModel.class, protocolModel)
        def copy = serialize([model, model.project, model.childList])

        expect:
        def copiedModel = copy[0]
        def copiedProject = copy[1]
        def projectList = copy[2]

    def "producer task with a dependency in another project will run before destroyer tasks when ordered first (type: #type)"() {
        def foo = subproject(':foo')
        def bar = subproject(':bar')

        def cleanFoo = foo.task('cleanFoo').destroys('build/foo')
        def cleanBar = bar.task('cleanBar').destroys('build/bar')