testcases := []struct {
		name           string
		fn             func(t *v1.Taint) bool
		expectedTaints []v1.Taint
	}{
		{
			name: "Filter out nothing",
			fn: func(t *v1.Taint) bool {
				if t.Key == v1.TaintNodeUnschedulable {
					return true
				}
				return false
			},
			expectedTaints: []v1.Taint{},
		},
		{

        "no conventions, top-level property is set"        | ""                                 | setId("test")         | """id = test\nbar = bar"""
        "everything has convention and nothing set"        | setAll("convention", "convention") | ""                    | """id = convention\nbar = convention"""

* `FilterSelects(labels)`: filters to only objects that **select** these labels. An empty selector matches everything.
* `FilterSelectsNonEmpty(labels)`: filters to only objects that **select** these labels. An empty selector matches nothing.
* `FilterGeneric(func(any) bool)`: filters by an arbitrary function.

Note that most filters may only be used if the objects being `Fetch`ed implement appropriate functions to extract the fields filtered against.

		//   From.Offset is table ID
		//   To.Offset is data
		if p.As == APCDATA && p.From.Offset >= int64(npcdata) && p.To.Offset != -1 { // ignore -1 as we start at -1, if we only see -1, nothing changed
			npcdata = int(p.From.Offset + 1)
		}
		// Find the highest ID of any FUNCDATA table.
		//   From.Offset is table ID
		if p.As == AFUNCDATA && p.From.Offset >= int64(nfuncdata) {

			t.Fatalf("%v: timeout while waiting for Node update: %v", tc.description, err)
		}

		if len(tc.expectedAllocatedCIDR) == 0 {
			// nothing further expected
			return
		}
		for _, updatedNode := range tc.fakeNodeHandler.GetUpdatedNodesCopy() {
			if len(updatedNode.Spec.PodCIDRs) == 0 {
				continue // not assigned yet
			}
			//match

    assertNull(q.peek());
    assertInterruptibleDrained(q);
    assertUninterruptibleDrained(q);
  }

  private void assertInterruptibleDrained(BlockingQueue<Object> q) {
    // nothing to drain, thus this should wait doing nothing
    try {
      assertEquals(0, Queues.drain(q, ImmutableList.of(), 0, 10, MILLISECONDS));
    } catch (InterruptedException e) {
      throw new AssertionError();
    }

    assertNull(q.peek());
    assertInterruptibleDrained(q);
    assertUninterruptibleDrained(q);
  }

  private void assertInterruptibleDrained(BlockingQueue<Object> q) {
    // nothing to drain, thus this should wait doing nothing
    try {
      assertEquals(0, Queues.drain(q, ImmutableList.of(), 0, 10, MILLISECONDS));
    } catch (InterruptedException e) {
      throw new AssertionError();
    }

     * <p>Look in the methodMap for an entry. If found,
     * it'll either be a CACHE_MISS, in which case we
     * simply give up, or it'll be a Method, in which
     * case, we return it.</p>
     * <p>If nothing is found, then we must actually go
     * and introspect the method from the MethodMap.</p>
     * @param name Method name.
     * @param params Method parameters.
     * @return The found method.

        source("class A { }")
        run language.compileTaskName

        then:
        outputs.recompiledClasses("A")
        outputs.hasFiles(file("A.class"), file("B.class"))
    }

    def "nothing is recompiled after a compile failure when file is reverted"() {
        source("class A {}", "class B {}")
        outputs.snapshot { run language.compileTaskName }
        source("class A { garbage }")

        buildFile """
            class Things {
                class Thing { }
            }

            extensions.create("thing", Things.Thing, "a")
        """

        expect:
        fails()
        failure.assertHasCause("Could not create an instance of type Things\$Thing.")
        failure.assertHasCause("Class Things.Thing is a non-static inner class.")
    }