processed.serverAddress == original.serverAddress
        processed.workerId == original.workerId
        processed.displayName == original.displayName
        processed.workerAction instanceof TestAction
        processed.workerAction.value == original.workerAction.value
    }

    private static class TestAction implements Action<WorkerProcessContext>, Serializable {

     * original.
     * @param original the property list to transform
     * @return the transformed property list
     */
    @Override
    public T transform(T original) {
        return doTransform(original);
    }

    /**
     * Transforms a property list object and write them out to a stream.
     * This will modify the original property list.

			defaulted := original.DeepCopyObject().(*flowcontrol.PriorityLevelConfiguration)
			scheme.Default(defaulted)
			if apiequality.Semantic.DeepEqual(original, defaulted) {
				t.Logf("Defaulting makes no change to PriorityLevelConfiguration: %q", original.Name)
				return
			}
			t.Errorf("Expected defaulting to not change PriorityLevelConfiguration: %q, diff: %s", original.Name, cmp.Diff(original, defaulted))

        def original = Proxy.newProxyInstance(cl, [payloadClass] as Class[], new GroovyInvocationHandler())

        when:
        def received = receiver.deserialize(originator.serialize(original))
        def reply = originator.deserialize(receiver.serialize(received))

        then:
        received.class != original.class
        !payloadClass.isInstance(received)

      other: null
    result:
      name: 1
      value: 1
  - description: defined null values should propagate removing original fields
    original:
      name: original-name
      value: original-value
    current:
      name: original-name
      value: original-value
      other: current-other
    modified:
      name: modified-name
      value: null
    twoWay:

    }

    @Override
    public ImmutableAttributes compileScope(ImmutableAttributes original) {
        List<Object> key = ImmutableList.of(original, Usage.JAVA_API);
        return concatCache.computeIfAbsent(key, k -> {
            ImmutableAttributes result = original;
            result = concat(result, USAGE_ATTRIBUTE, new CoercingStringValueSnapshot(Usage.JAVA_API, objectInstantiator));

    public PluginDescriptor(PluginDescriptor original) {
        this.setGroupId(original.getGroupId());
        this.setArtifactId(original.getArtifactId());
        this.setVersion(original.getVersion());
        this.setGoalPrefix(original.getGoalPrefix());
        this.setInheritedByDefault(original.isInheritedByDefault());
        this.setName(original.getName());
        this.setDescription(original.getDescription());

        when:
        executeWithException(original)
        then:
        def ex = thrown type
        ex === original

        where:
        original << [
            new RuntimeException("lajos"),
            new Error("lajos"),
            new UncheckedIOException(new IOException("lajos"))
        ]
        type = original.class
    }

    @Override
    public Version transform(String original) {
        return cache.computeIfAbsent(original, this::parse);
    }

    private Version parse(String original) {
        List<String> parts = new ArrayList<>();
        boolean digit = false;
        int startPart = 0;
        int pos = 0;
        int endBase = 0;
        int endBaseStr = 0;
        for (; pos < original.length(); pos++) {

    final T original

    ThreadLocalInterceptorSet(T original) {
        this.original = original
    }

    boolean isEmpty() {
        substitutions.get() == 0
    }

    void substituteForCurrentThread(T substitution) {
        if (threadLocalDecorators.get() != original) {