when:
        succeeds "b"

        then:
        result.assertTasksSkipped(":a", ":b")

        // Change intermediate output file, different length
        when:
        outputFileA.text = 'changed'
        succeeds "b"

        then:
        result.assertTasksNotSkipped(":a")
        result.assertTasksSkipped(":b")

        outputFileA.text == '[new content]'

    public boolean removeAll(final Collection<?> collection) {
      boolean changed = false;
      Iterator<E> itr = unfiltered.iterator();
      while (itr.hasNext()) {
        E e = itr.next();
        if (predicate.apply(e) && collection.contains(e)) {
          itr.remove();
          changed = true;
        }
      }
      return changed;
    }

    @Override

        if (collection.size() == entry.getValue().size()) {
          entryIterator.remove();
        } else {
          collection.clear();
        }
        changed = true;
      }
    }
    return changed;
  }

  @WeakOuter
  class AsMap extends ViewCachingAbstractMap<K, Collection<V>> {
    @Override
    public boolean containsKey(@CheckForNull Object key) {

			old := tc.oldSvc.DeepCopy()

			// to test against user using IPFamily not set on cluster
			dropServiceDisabledFields(tc.svc, tc.oldSvc)

			// old node should never be changed
			if !reflect.DeepEqual(tc.oldSvc, old) {
				t.Errorf("%v: old svc changed: %v", tc.name, cmp.Diff(tc.oldSvc, old))
			}

			if !reflect.DeepEqual(tc.svc, tc.compareSvc) {

// and reports whether it differs from the default value.
func EnvOrAndChanged(name, def string) (v string, changed bool) {
	val := Getenv(name)
	if val != "" {
		v = val
		if g, ok := envCache.goroot[name]; ok {
			changed = val != g
		} else {
			changed = val != def
		}
		return v, changed
	}
	return def, false
}

var SumdbDir = gopathDir("pkg/sumdb")

          continue outer;
        }

        long newValue = oldValue + delta;
        if (atomic.compareAndSet(oldValue, newValue)) {
          return newValue;
        }
        // value changed
      }
    }
  }

  /**
   * Increments by one the value currently associated with {@code key}, and returns the old value.
   */
  @CanIgnoreReturnValue
  public long getAndIncrement(K key) {

		// handle changes in ownerReferences
		added, removed, changed := referencesDiffs(existingNode.owners, accessor.GetOwnerReferences())
		if len(added) != 0 || len(removed) != 0 || len(changed) != 0 {
			// check if the changed dependency graph unblock owners that are
			// waiting for the deletion of their dependents.
			gb.addUnblockedOwnersToDeleteQueue(logger, removed, changed)
			// update the node itself

        where:
        mergeRun     | typeHierachyChange | barContentOnChange                   | expectedFinalMergeAnalysisOutputs
        "re-run"     | "is changed"       | "class Bar extends Foo {}"           | 2
        "not re-run" | "is not changed"   | "class Bar { public void bar() {} }" | 1
    }

    def "project dependency analysis is #analysisRun if classes are #classChangeDescription and recompiled"() {

        if (collection.size() == entry.getValue().size()) {
          entryIterator.remove();
        } else {
          collection.clear();
        }
        changed = true;
      }
    }
    return changed;
  }

  @WeakOuter
  class AsMap extends ViewCachingAbstractMap<K, Collection<V>> {
    @Override
    public boolean containsKey(@CheckForNull Object key) {

            if (details.runsTasks) {
                "Calculating task graph as configuration cache cannot be reused because $reason has changed."
            } else {
                "Creating tooling model as configuration cache cannot be reused because $reason has changed."
            }
        }

        def found = messages.any { message -> spec.output.contains(message) }