| Was requested : didn't match versions <versions>
| The dependency appears with a <<dynamic_versions#sub:declaring_dependency_with_dynamic_version, dynamic version>> which did not include the listed versions.
May be followed by a `because` text.

| Was requested : reject version <versions>

	}
}

func withoutRecover() {
	mustNotRecover() // because it's a sub-call
}

func withoutRecoverRecursive(n int) {
	if n == 0 {
		withoutRecoverRecursive(1)
	} else {
		v := recover()
		if v != nil {
			println("spurious recover (recursive)", v)
			die()
		}
	}
}

func test1() {
	defer mustNotRecover()           // because mustRecover will squelch it

        then:
        failure.assertHasCause("Cannot map a dependency on dep:dep that defines both a branch (release) and a version constraint (1.0).")
    }

    @ToBeFixedForConfigurationCache(because = "Task.getProject() during execution")
    def "produces manifest for Swift component with dependencies on multiple repositories"() {
        given:
        def lib1Repo = GitFileRepository.init(testDirectory.file("repos/lib1"))

                if (details.requested.name == 'foo') {
                    details.useVersion '0.11'
                    details.because 'because I can'
                }
            }
            dependencies {
                constraints {
                    conf('org:foo') {
                       version { strictly '1.0' }
                    }

              (TFL_QuantizeOp (TF_ReshapeOp $input, $shape),
              (UpdateShapeWithAxis<-1> $qtype, $old_value))),
          [(CanUpdateShapeWithAxis<-1> $qtype, $old_value)]>;

// The axis is set to 0 because the transpose is from the legalization of
// tf.conv2d and the new channel axis is the first dimension.
def ReorderTransposeDequantQuantUsedByConv :
      Pat<(TF_TransposeOp:$old_value

// is already in flight, then a new event cannot begin because the current time is
// already being attributed to that event. In this case, this function returns false.
// Otherwise, it returns true.
//
// The caller must be non-preemptible until at least stop is called or this function
// returns false. Because this is trying to measure "on-CPU" time of some event, getting

        provider.getOrElse(someValue()) == someValue()

        when:
        provider.get()

        then:
        def t = thrown(MissingValueException)
        t.message == "Cannot query the value of ${displayName} because it has no value available."
    }

    def "mapped provider uses the result of transformer as its value"() {
        def transform = Mock(Transformer)

        given:

                        break;
                    }
                } else {
                    result.matches(candidateId);
                    return;
                }
            }
        }

        // if we reach this point, no match was found, either because there are no versions matching the selector

        "Collection<T> += Provider<T>"           | "+="      | "ListProperty<MyObject>"        | 'provider { MyObject("a") }'                               | unsupportedWithDescription("Unresolved reference. None of the following candidates is applicable because of receiver type mismatch:")

					// 1) If the core type has a tilde, per spec requirement for tilde
					//    elements, the core type is an underlying (literal) type.
					//    And because of the tilde, the underlying type of tx must match
					//    against the core type.
					//    But because unify automatically matches a defined type against
					//    an underlying literal type, we can simply unify tx with the
					//    core type.