return nil
	}
	obj2, err := runtime.Decode(codec, data)
	if err != nil {
		t.Errorf("%v\nData: %s\nSource: %#v", err, string(data), obj)
		return nil
	}
	obj3 := reflect.New(reflect.TypeOf(obj).Elem()).Interface().(runtime.Object)
	err = legacyscheme.Scheme.Convert(obj2, obj3, nil)
	if err != nil {
		t.Errorf("%v\nSource: %#v", err, obj2)
		return nil
	}
	return obj3

        switch (type) {
            case FILE:
                return INPUT_FILE_VALIDATOR;
            case DIRECTORY:
                return INPUT_DIRECTORY_VALIDATOR;
            case FILES:
                return NO_OP;
            default:
                throw new AssertionError("Unknown input property type " + type);
        }
    }

func roundTrip(codec runtime.Codec, object runtime.Object) {
	printer := spew.ConfigState{DisableMethods: true}

	// deep copy the original object
	object = object.DeepCopyObject()
	name := reflect.TypeOf(object).Elem().Name()

	// encode (serialize) the deep copy using the provided codec
	data, err := runtime.Encode(codec, object)
	if err != nil {
		return
	}

			log.Fatalf("bad sl[j] value: got %d, want %d", *sl[j], iValue)
		}
	}

	t := reflect.TypeOf(int(0))
	v := reflect.ArenaNew(a, t)
	if want := reflect.PointerTo(t); v.Type() != want {
		log.Fatalf("unexpected type for arena-allocated value: got %s, want %s", v.Type(), want)
	}
	i2 := v.Interface().(*int)
	*i2 = iValue

	if *i2 != iValue {

}

// SerializerInfoForMediaType returns the first info in types that has a matching media type (which cannot
// include media-type parameters), or the first info with an empty media type, or false if no type matches.
func SerializerInfoForMediaType(types []SerializerInfo, mediaType string) (SerializerInfo, bool) {
	for _, info := range types {
		if info.MediaType == mediaType {
			return info, true
		}
	}

...Default,\n        ...$(this).data()\n      }\n\n      if (typeof config === 'object') {\n        _config = {\n          ..._config,\n          ...config\n        }\n      }\n\n      const action = typeof config === 'string' ? config : _config.slide\n\n      if (!data) {\n        data = new Carousel(this, _config)\n        $(this).data(DATA_KEY, data)\n      }\n\n      if (typeof config === 'number') {\n        data.to(config)\n      } else if (typeof action === 'string') {\n        if (typeof data[action]...

			log.Fatalf("%s: expected generated file", name)
		}
		if err := os.Remove(name); err != nil {
			log.Fatal(err)
		}
	}

	// Generate new experiment constant files.
	rt := reflect.TypeOf(&goexperiment.Flags{}).Elem()
	for i := 0; i < rt.NumField(); i++ {
		f := rt.Field(i).Name
		buildTag := "goexperiment." + strings.ToLower(f)
		for _, val := range []bool{false, true} {

	// know how a bitfield should correspond to a Go type, even if
	// it appears to be aligned correctly.
	bitfieldType := reflect.TypeOf(bitfields{})
	check := func(name string) {
		_, ok := bitfieldType.FieldByName(name)
		if ok {
			fmt.Fprintf(os.Stderr, "found unexpected bitfields field %s\n", name)
			pass = false
		}
	}
	check("Short1")
	check("Short2")
	check("Short3")

	if !pass {
		os.Exit(1)
	}

		for vidx, v := range allTypes {
			if got, want := tt.function(reflect.TypeOf(v)), isInListOfInterface(tt.okTypes, v); got != want {
				t.Errorf("%s with %s (#%d): got: %t, want: %t", tt.desc, reflect.TypeOf(v), vidx, got, want)
			}
		}
	}
}

type interfaceContainer struct {
	I anInterface
}

type anInterface interface {
	IsU()
}

type implementsInterface struct {
	A string
}

				t.Errorf("Unexpected error: %v", err)
			}

			var handler http.Handler
			handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				switch v := w.(type) {
				case *respLogger:
					t.Errorf("Did not expect %v", reflect.TypeOf(v))
					return
				default:
				}

				//lint:file-ignore SA1019 Keep supporting deprecated http.CloseNotifier
				if _, ok := w.(http.CloseNotifier); !ok {