when:
        succeeds "nothing"

        then:
        result.assertTasksNotSkipped(":nothing")

        // Is up to date
        when:
        succeeds "nothing", "-Puptodate"

        then:
        result.assertTasksSkipped(":nothing")

        // Predicate is false
        when:
        succeeds "nothing"

        then:

            }
            extensions.add('things', SomeThing)
            things {
                letter = 'a'
                withLetter('b')
            }
            assert things.letter == Letter.B
            things.other('ABC')
            assert things.letter == Letter.A
            things.other(Letter.C)
            assert things.letter == Letter.C
            things.other('A', 'ignore')

            correspondingProperty: PROPERTY name:firstValue visibility:public modality:FINAL [val]
            $this: VALUE_PARAMETER name:<this> type:<root>.Operation.Add
            BLOCK_BODY
              RETURN type=kotlin.Nothing from='public final fun <get-firstValue> (): kotlin.Int declared in <root>.Operation.Add'
                GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:firstValue type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null

func (o *CallOptions) FillDefaultsOrFail(t test.Failer) {
	t.Helper()
	if err := o.FillDefaults(); err != nil {
		t.Fatal(err)
	}
}

func (o *CallOptions) fillCallCount() {
	if o.Count > 0 {
		// Nothing to do.
		return
	}

	o.Count = common.DefaultCount

	// Try setting an appropriate count for the number of workloads.
	newCount := DefaultCallsPerWorkload() * o.numWorkloads()
	if newCount > o.Count {

        collection.visitStructure(new BrokenVisitor())
        collection.toString() == "some collection"
    }

    def "returns empty collection when fixed collection constructed with a fixed list containing nothing"() {
        expect:
        def collection = factory.fixed([])
        collection.files.empty
        collection.buildDependencies.getDependencies(null).empty
        collection.visitStructure(new BrokenVisitor())

            }

            def bag = project.objects.newInstance(Bag)
            bag.things.registerBinding(Thing, Thing)
            bag.things.registerBinding(AnotherThing, AnotherThing)

            bag.things {
                a(Thing) {
                    value = 1
                }
                b(AnotherThing) {
                    value = "foo"

func lexVariable(l *lexer) stateFn {
	if l.atTerminator() { // Nothing interesting follows -> "$".
		return l.emit(itemVariable)
	}
	return lexFieldOrVariable(l, itemVariable)
}

// lexFieldOrVariable scans a field or variable: [.$]Alphanumeric.
// The . or $ has been scanned.
func lexFieldOrVariable(l *lexer, typ itemType) stateFn {
	if l.atTerminator() { // Nothing interesting follows -> "." or "$".
		if typ == itemVariable {

        def dep = new LocalComponentDependencyMetadata(Stub(ComponentSelector), Dependency.DEFAULT_CONFIGURATION, [] as List, [], false, false, true, false, false, null)
        def conf = defaultConfiguration(attributes(key: 'nothing'))
        toComponent.getCandidatesForGraphVariantSelection().variants.addAll(conf)
        attributesSchema.attribute(Attribute.of('key', String))
        attributesSchema.attribute(Attribute.of('will', String))

			// Node2 scores (used resources) on 0-MaxNodeScore scale
			// CPU Score: (0 * MaxNodeScore) / 4000 = 0
			// Memory Score: (0 * MaxNodeScore) / 10000 = 0
			// Node2 Score: (0 + 0) / 2 = 0
			name:         "nothing scheduled, nothing requested",
			requestedPod: st.MakePod().Obj(),
			nodes: []*v1.Node{
				st.MakeNode().Name("node1").Capacity(map[v1.ResourceName]string{"cpu": "4000", "memory": "10000"}).Obj(),

								{
									Namespaces:        sets.New("ns"),
									Selector:          labels.SelectorFromSet(map[string]string{"baz": "qux"}),
									TopologyKey:       "baz",
									NamespaceSelector: labels.Nothing(),
								},
							},
						},
					},
				},
			},
			expectedNumNodes:         3,
			expectedPodsWithAffinity: 1,
		},
		{