objectToConvert               runtime.Object
		expectedErr                   error
		expectedConvertedUnstructured *unstructured.Unstructured
	}{
		{
			name:                          "convert nil object to unstructured should fail",
			objectToConvert:               nil,
			expectedErr:                   fmt.Errorf("unable to convert object type <nil> to Unstructured, must be a runtime.Object"),

sealed interface UnsupportedSyntaxCause {
    data object DanglingExpr : UnsupportedSyntaxCause
    data object LocalVal : UnsupportedSyntaxCause
    data object AssignmentWithExplicitReceiver : UnsupportedSyntaxCause
    data object ElementWithExplicitReceiver : UnsupportedSyntaxCause
    data object ElementArgumentFormat : UnsupportedSyntaxCause
    data object ElementMultipleLambdas : UnsupportedSyntaxCause

public final class CollectorTester<
    T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object> {
  /**
   * Creates a {@code CollectorTester} for the specified {@code Collector}. The result of the {@code
   * Collector} will be compared to the expected value using {@link Object#equals}.
   */
  public static <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>

	Namespace(obj runtime.Object) (string, error)
	SetNamespace(obj runtime.Object, namespace string) error

	Name(obj runtime.Object) (string, error)
	SetName(obj runtime.Object, name string) error

	GenerateName(obj runtime.Object) (string, error)
	SetGenerateName(obj runtime.Object, name string) error

	UID(obj runtime.Object) (types.UID, error)
	SetUID(obj runtime.Object, uid types.UID) error

	SelfLink(obj runtime.Object) (string, error)

                addAllFirst(queue, toArray(iterable, Object.class));
            } else if (dependency instanceof Map) {
                Map<?, ?> map = Cast.uncheckedNonnullCast(dependency);
                addAllFirst(queue, map.values().toArray());
            } else if (dependency instanceof Object[]) {
                Object[] array = (Object[]) dependency;
                addAllFirst(queue, array);

func roundTrip(t *testing.T, scheme *runtime.Scheme, codec runtime.Codec, object runtime.Object) {
	original := object

	// deep copy the original object
	object = object.DeepCopyObject()
	name := reflect.TypeOf(object).Elem().Name()
	if !apiequality.Semantic.DeepEqual(original, object) {
		t.Errorf("%v: DeepCopy altered the object, diff: %v", name, cmp.Diff(original, object))
		t.Errorf("%s", dump.Pretty(original))

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

  ForwardingImmutableList() {}

  abstract List<E> delegateList();

  public int indexOf(@Nullable Object object) {
    return delegateList().indexOf(object);
  }

  public int lastIndexOf(@Nullable Object object) {
    return delegateList().lastIndexOf(object);
  }

  public E get(int index) {
    return delegateList().get(index);
  }

   *
   * @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) {

func (u *UnstructuredList) EachListItem(fn func(runtime.Object) error) error {
	for i := range u.Items {
		if err := fn(&u.Items[i]); err != nil {
			return err
		}
	}
	return nil
}

func (u *UnstructuredList) EachListItemWithAlloc(fn func(runtime.Object) error) error {
	for i := range u.Items {
		if err := fn(&Unstructured{Object: u.Items[i].Object}); err != nil {
			return err
		}
	}
	return nil
}