public XmlProviderImpl(String original) {
            this.stringValue = original;
        }

        public XmlProviderImpl(Node original) {
            this.node = original;
        }

        public XmlProviderImpl(DomNode original) {
            this.node = original;
            publicId = original.getPublicId();
            systemId = original.getSystemId();
        }

    }

    void looksLike(Throwable original, Throwable transported) {
        assert transported instanceof PlaceholderExceptionSupport
        assert transported.exceptionClassName == original.class.name
        assert transported.message == original.message
        assert transported.toString() == original.toString()
        assert transported.stackTrace == original.stackTrace

        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 {

		return
	}
}

func testPatchApplication(t *testing.T, original, patch, expected []byte, description string) {
	result, err := jsonpatch.MergePatch(original, patch)
	if err != nil {
		t.Errorf("error: %s\nin test case: %s\ncannot apply patch:\n%s\nto original:\n%s\n",
			err, description, jsonToYAMLOrError(patch), jsonToYAMLOrError(original))
		return
	}

	if !reflect.DeepEqual(result, expected) {

     * 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.

				}},
			},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			original := test.original
			expected := test.expected
			legacyscheme.Scheme.Default(original)
			if !apiequality.Semantic.DeepEqual(original, expected) {
				t.Error(cmp.Diff(expected, original))
			}
		})
	}
}

func TestDefaultAdmissionPolicy(t *testing.T) {
	fail := v1beta1.Fail

        val original = """
            // line 1
            // line 2
            buildscript {
                // line 4
            }
        """.replaceIndent()
        val begin = original.indexOf("buildscript")
        val end = original.indexOf("}")
        assertThat(
            original.linePreservingSubstring(begin..end),
            equalTo(
                """

        def buildCacheConfiguration = createConfig()
        def original = Stub(CustomBuildCache)
        when:
        buildCacheConfiguration.remote(CustomBuildCache) { config ->
            original = config
        }
        then:
        buildCacheConfiguration.remote == original
        1 * instantiator.newInstance(CustomBuildCache) >> original
        0 * _

        BuildCache updated = null
        when:

				},
			},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			original := test.original
			expected := test.expected
			legacyscheme.Scheme.Default(original)
			if !apiequality.Semantic.DeepEqual(original, expected) {
				t.Error(cmp.Diff(expected, original))
			}
		})
	}
}

func TestDefaultAdmissionPolicyBinding(t *testing.T) {

        then:
        transformer.transform('original') == 'original transformed'
    }

    def 'uses original object when Closure returns null'() {
        when:
        transformer.add { null }

        then:
        transformer.transform('original') == 'original'
    }

    def 'uses original object when Closure returns object of unexpected type'() {
        when:
        transformer.add { 9 }