expect:
        def original = "abc"
        def isolated = isolatableFactory.isolate(original)
        isolated instanceof StringValueSnapshot
        isolated.isolate().is(original)
    }

    def "can coerce string value"() {
        expect:
        def original = "abc"
        def isolated = isolatableFactory.isolate(original)
        isolated.coerce(String).is(original)

         *
         * @param original the original JAR or classes directory
         * @param transformed the transformed JAR or classes directory
         * @return this builder
         */
        public Builder add(File original, File transformed) {
            originals.add(original);
            if (!original.equals(transformed)) {
                transforms.put(original, transformed);
            }

    transpose.put("foo", 1, 'a');
    assertEquals((Character) 'a', original.get(1, "foo"));
  }

  public void testTransposedViews() {
    Table<Integer, String, Character> original = HashBasedTable.create();
    Table<String, Integer, Character> transpose = Tables.transpose(original);
    original.put(1, "foo", 'a');
    assertSame(original.columnKeySet(), transpose.rowKeySet());
    assertSame(original.rowKeySet(), transpose.columnKeySet());

        }

        TransformedClassPath cp = classPath((original): transformed)

        expect:
        INSTRUMENTED_CLASS == loadTransformedClass(cp, "Foo", original)
    }

    def "replaces original class with transformed in JAR without manifest"() {
        given:
        def original = jar(testDir.file("original.jar")) {
            manifest {}

            entry("Foo.class", ORIGINAL_CLASS)

    def "toString() generally produces same output as original exception"() {
        def original = new Exception("original exception")
        def placeholder = new PlaceholderException(original.getClass().name, original.message, null, original.toString(), null, original.cause)

        expect:
        placeholder.toString() == original.toString()
    }

    def "toString() produces same output as original exception if the latter overrides toString()"() {

        write(original)

        expect:
        original == written
    }

    def "serializes managed type properties"() {
        def original = new ManagedValueSnapshot("named", integer(123))
        write(original)

        expect:
        original == written
    }

    def "serializes immutable managed type properties"() {

				}},
			},
		},
	}

	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 := v1.Fail

        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 {