Russ Cox <******@****.***> 1410149331 -0400

apiVersion: release-notes/v2
kind: feature
area: networking
issue:
  - 23369
releaseNotes:
  - |

        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);
            }

		}
		// Delete the element at originalKey.
		original = append(original[:originalKey], original[originalKey+1:]...)
	}
	return original, nil
}

// mergeSliceWithoutSpecialElements merges slices with non-special elements.
// original and patch must be slices of maps, they should be checked before calling this function.

    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