* If an object with the given [name] is not found, [UnknownDomainObjectException] is thrown.
 * If the object is found but cannot be cast to the expected [type], [IllegalArgumentException] is thrown.
 *
 * @param name object name
 * @param type expected type
 * @return the object, never null
 * @throws [UnknownDomainObjectException] When the given object is not found.

				Object: map[string]interface{}{
					"spec": "old",
				},
			},
			obj: &unstructured.Unstructured{
				Object: map[string]interface{}{
					"new": "new",
				},
			},
			expected: &unstructured.Unstructured{
				Object: map[string]interface{}{
					"spec": "old",
				},
			},
		},
		{
			// delete status
			old: &unstructured.Unstructured{
				Object: map[string]interface{}{

import java.io.OutputStream;

public class ExceptionReplacingObjectOutputStream extends ObjectOutputStream {
    private InternalTransformer<Object, Object> objectTransformer = new InternalTransformer<Object, Object>() {
        @Override
        public Object transform(Object obj) {
            try {
                return doReplaceObject(obj);
            } catch (IOException e) {

    public boolean containsValue(Object value) {
        return attributes.containsValue(value);
    }

    @Override
    public Object get(Object key) {
        return attributes.get(key);
    }

    @Override
    public Object put(String key, Object value) {
        if (key == null) {
            throw new ManifestException("The key of a manifest attribute must not be null.");
        }
        if (value == null) {

   *
   * @since 20.0 (varargs overload since 2.0)
   */
  @CanIgnoreReturnValue
  public static <T> T checkNotNull(
      @CheckForNull T reference,
      String errorMessageTemplate,
      @CheckForNull Object p1,
      @CheckForNull Object p2,
      @CheckForNull Object p3,
      @CheckForNull Object p4) {
    if (reference == null) {

public class DefaultGradleProperties implements MutableGradleProperties {
    private final Map<String, Object> defaultProperties;
    private final Map<String, Object> overrideProperties;
    private final Map<String, Object> gradleProperties;

    public DefaultGradleProperties(
        Map<String, Object> defaultProperties,
        Map<String, Object> overrideProperties
    ) {
        this.defaultProperties = defaultProperties;

func TestFilter(t *testing.T) {
	table := []Event{
		{Type: Added, Object: testType("foo")},
		{Type: Added, Object: testType("bar")},
		{Type: Added, Object: testType("baz")},
		{Type: Added, Object: testType("qux")},
		{Type: Added, Object: testType("zoo")},
	}

	source := NewFake()
	filtered := Filter(source, func(e Event) (Event, bool) {
		return e, e.Object.(testType)[0] != 'b'
	})

	go func() {

public void Log4JCategoryLog(org.apache.log4j.Category); public void trace(Object); public void trace(Object, Throwable); public void debug(Object); public void debug(Object, Throwable); public void info(Object); public void info(Object, Throwable); public void warn(Object); public void warn(Object, Throwable); public void error(Object); public void error(Object, Throwable); public void fatal(Object); public void fatal(Object, Throwable); public org.apache.log4j.Category getCategory(); public boolean...

	tests := []struct {
		name     string
		obj      func() runtime.Object
		old      func() runtime.Object
		expected bool
	}{
		{
			name: "same",
			obj: func() runtime.Object {
				return newPod()
			},
			old: func() runtime.Object {
				return newPod()
			},
			expected: true,
		},
		{
			name: "different managedFields",
			obj: func() runtime.Object {
				return newPod()
			},
			old: func() runtime.Object {

		}
	}`)
	newObj := &unstructured.Unstructured{Object: map[string]interface{}{}}
	if err := yaml.Unmarshal(patch, &newObj.Object); err != nil {
		t.Fatalf("error decoding YAML: %v", err)
	}

	if err := f.Update(newObj, "fieldmanager_test"); err != nil {
		t.Fatalf("failed to apply object: %v", err)
	}

	appliedObj := &unstructured.Unstructured{Object: map[string]interface{}{}}
	if err := yaml.Unmarshal([]byte(`{