then:
        resolve.expectGraph {
            root(':', ':testproject:') {
                module("group:bom:1.0").noArtifacts()
            }
        }
    }

    def "fails late for dependency entries that fail to provide a missing version"() {
        given:
        bomDependency('moduleA')
        bomDependency('moduleB')
        bom.publish()

   Cannot select module with conflict on capability 'cglib:cglib:3.2.5' also provided by [cglib:cglib-nodep:3.2.5($variant)]""")
    }

    def "implicit capability conflict is detected if implicit capability is discovered late"() {
        given:
        repository {
            'cglib:cglib:3.2.5'()
            'cglib:cglib-nodep:3.2.5'()
            'org:lib:1.0' {
                dependsOn 'cglib:cglib:3.2.5'
            }
        }

                logger.lifecycle 'configureEach'
            }
            tasks.create('foo') {
                logger.lifecycle 'create'
            }
            tasks.all {
                logger.lifecycle 'too late'
            }
        """

        when:
        run('foo')

        then:
        verifyTaskIds()
        def realize = verifyTaskDetails(RealizeTaskBuildOperationType, withPath(':', ':foo'))

	{name: "ClosureLECall", argLength: -1, aux: "CallOff", call: true}, // late-expanded closure call. arg0=code pointer, arg1=context ptr,  arg2..argN-1 are inputs, argN is mem. auxint = arg size. Result is tuple of result(s), plus mem.

	hs.Updated(v1.IPv4Protocol)
	hs.Updated(v1.IPv6Protocol)
	fakeClock.Step(5 * time.Second)
	testHTTPHandler(hsTest, http.StatusOK, t)

	// If IPv6 proxier is late for an update but IPv4 proxier is not then updating IPv4 proxier should have no effect.
	hs.QueuedUpdate(v1.IPv6Protocol)
	fakeClock.Step(25 * time.Second)
	testHTTPHandler(hsTest, http.StatusServiceUnavailable, t)

		Canary:       false,
		TypeUrl:      resp.TypeUrl,
		Nonce:        resp.Nonce,
		ControlPlane: resp.ControlPlane,
	}:
	default:
		log.Infof("tap response %q arrived too late; discarding", resp.TypeUrl)
	}

	}
	c := atomic.LoadUint64(&counter)
	if c != 2 {
		t.Errorf("healthcheck() called etcd %d times, expected only two calls", c)
	}

	// cached request should be success and not be overridden by the late error
	<-signal
	err = healthcheck()
	if err != nil {
		t.Errorf("unexpected error: %v", err)
	}
	c = atomic.LoadUint64(&counter)
	if c != 2 {

				socketName      = newEndpoint()
			)

			testCompletedWG.Add(1)
			defer testCompletedWG.Done()

			ctx := testContext(t)

			kubeAPIServerWG.Add(1)
			go func() {
				// Simulating late start of kube-apiserver - plugin is up before kube-apiserver, if requested by the testcase.
				time.Sleep(tt.kubeAPIServerDelay)

				service, err = NewGRPCService(ctx, socketName.endpoint, tt.callTimeout)
				if err != nil {

            }
            targetNodes.clear();
        }
        targetNodeSelectionFailure = null;
    }

    /**
     * Call this method to attach a failure late in the process. This is typically
     * done when a failure is caused by graph validation. In that case we want to
     * perform as much resolution as possible, still have a valid graph, but in the
     * end fail resolution.

                    doLast {
                        def files = configurations.compile.files
                        assert files*.name.sort() == ["api.jar"] // Late dependency is not honoured
                        assert files*.exists() == [ true ]
                    }
                }
            }
"""

        when: