dropDisabledFields(&newPod.Spec, nil, oldPodSpec, nil)

					// old pod should never be changed
					if !reflect.DeepEqual(oldPod, oldPodInfo.pod()) {
						t.Errorf("old pod changed: %v", cmp.Diff(oldPod, oldPodInfo.pod()))
					}

					switch {
					case enabled || oldPodHasProcMount:
						// new pod should not be changed if the feature is enabled, or if the old pod had ProcMount

        checkCompile recompiled: [], removed: [source1]
    }

    def "detects source file changed"() {
        given:
        initialFiles()

        when:
        modified(source2)

        then:
        checkCompile recompiled: [source2], removed: []
    }

    def "detects dependency file changed"() {
        given:
        initialFiles()

        when:
        modified(dep4)

        e.message == 'The value for this property is final and cannot be changed any further.'

        when:
        property.add(Stub(PropertyInternal))

        then:
        def e2 = thrown(IllegalStateException)
        e2.message == 'The value for this property is final and cannot be changed any further.'
    }

    def "cannot add element after value finalized implicitly"() {
        given:

            }
        }

        boolean changed;

        // If file could not be found or was not valid, start from scratch
        if (metadata == null) {
            metadata = this.metadata;

            changed = true;
        } else {
            changed = metadata.merge(this.metadata);
        }

        // beware meta-versions!

 * The work action can then query what changed for an input parameter since the last execution to only process the changes.
 *
 * The following example shows a task which reverses the text in each of its input files.
 * It demonstrates how to use {@link InputChanges} to only process the changed files.
 *
 * <pre class='autoTested'>
 * abstract class IncrementalReverseTask extends DefaultTask {

                                        op->getUsers().end());

    bool changed = false;
    for (auto& use : op->getUses()) {
      Operation* user_op = use.getOwner();
      int user_idx = use.getOperandNumber();
      if (!IsOpWithInt8TypeOperand(user_op)) continue;
      // If the next op is terminator, function type needs to be changed so
      // handle this case separately when propagating for function op is
      // added.

 *  * for library symbols:
 *    * for function & property symbol if its signature was not changed
 *    * for local variable symbol if code block it was declared in was not changed
 *    * for class & type alias symbols if its qualified name was not changed
 *    * for package symbol if the package is still exists
 *
 * @see org.jetbrains.kotlin.analysis.api.lifetime.KaReadActionConfinementLifetimeToken

	SetToCurrentTime()
}

// RatioedGauge tracks ratios.
// The numerator is set/changed through the Gauge methods,
// and the denominator can be updated through the SetDenominator method.
// A ratio is tracked whenever the numerator or denominator is set/changed.
type RatioedGauge interface {
	Gauge

	// SetDenominator sets the denominator to use until it is changed again
	SetDenominator(float64)
}

            changed()
        }

        void remove() {
            assert backingFile.delete()
            changed()
        }

        void add() {
            backingFile << "First creation of file"
            changed()
        }

        void changed() {
            onChange.call()
        }
    }

    class ManifestResource extends TestResource {

        for (Path changedPath : changedPaths) {
            if (!changedPath.isAbsolute()) {
                throw new IllegalArgumentException(String.format("Changed path '%s' is not absolute", changedPath));
            }
            absolutePaths.add(changedPath.toString());
        }