package runtime

import (
	"internal/abi"
	"internal/goarch"
	"runtime/internal/math"
	"runtime/internal/sys"
	"unsafe"
)

type slice struct {
	array unsafe.Pointer
	len   int
	cap   int
}

// A notInHeapSlice is a slice backed by runtime/internal/sys.NotInHeap memory.
type notInHeapSlice struct {
	array *notInHeap
	len   int
	cap   int
}

func panicmakeslicelen() {

			errorf("decoding bool array or slice: length exceeds input size (%d elements)", length)
		}
		if i >= len(slice) {
			// This is a slice that we only partially allocated.
			growSlice(v, &slice, length)
		}
		slice[i] = state.decodeUint() != 0
	}
	return true
}

func decComplex64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
	// Can only slice if it is addressable.
	if !v.CanAddr() {

		&Pet{Name: "pet-slice-append-1"},
		[]*Pet{{Name: "pet-slice-append-2-1"}, {Name: "pet-slice-append-2-2"}},
		&Pet{Name: "pet-slice-append-3"},
	)

	AssertAssociationCount(t, users, "Pets", 10, "After Append")

	// Replace -> same as append
	DB.Model(&users).Association("Pets").Replace(
		[]*Pet{{Name: "pet-slice-replace-1-1"}, {Name: "pet-slice-replace-1-2"}},

  Output slice = ops::Slice(root.WithOpName("slice"), input, begin, size);
  root.graph()->AddControlEdge(control_pred.node(), slice.node());

  std::unique_ptr<Graph> result;
  TF_ASSERT_OK(IncreaseDynamismForAutoJit(root, &result));

  Node* static_shaped_slice = testing::FindNodeByName(
      result.get(), "slice/static_shaped_slice/static_shaped_slice");

			// like this in an existing slice.
			continue
		}

		if numObsoleteSlices > 0 {
			// Update one existing slice.
			slice := obsoleteSlices[numObsoleteSlices-1]
			numObsoleteSlices--
			slice = slice.DeepCopy()
			slice.ResourceModel = *resource
			logger.V(5).Info("Reusing existing node resource slice", "slice", klog.KObj(slice))

	if err != nil {
		t.Errorf("expected nil, got %#v", err)
	}

	// Append a non-nil error
	slice = append(slice, fmt.Errorf("err"))
	agg = NewAggregate(slice)
	if agg == nil {
		t.Errorf("expected non-nil")
	}
	if s := agg.Error(); s != "err" {
		t.Errorf("expected 'err', got %q", s)
	}
	if s := agg.Errors(); len(s) != 1 {
		t.Errorf("expected one-element slice, got %#v", s)
	}

  }

  for (const Edge* e : slice->in_edges()) {
    if (e->IsControlEdge()) {
      g->AddControlEdge(e->src(), static_shaped_slice);
    }
  }

  g->RemoveNode(slice);
}

Status RewriteSlice(Graph* g, Node* slice, const SliceInputs& slice_inputs,
                    absl::string_view cluster_name) {
  VLOG(3) << "Rewriting slice " << slice->name()
          << " to a \"static shaped\" Slice";

		for _, slice := range slices {
			esc.updateEndpointCacheForSlice(hostName, slice)
		}
	}

	return esc.endpointCache.Get(hostName)
}

func getServiceNamespacedName(slice *v1.EndpointSlice) types.NamespacedName {
	return types.NamespacedName{
		Namespace: slice.GetNamespace(),
		Name:      serviceNameForEndpointSlice(slice.GetLabels()),
	}
}

			}
		})
	}
}

func TestClone(t *testing.T) {
	tests := []struct {
		name  string
		slice []interface{}
	}{
		{
			name:  "Empty",
			slice: []interface{}{},
		},
		{
			name:  "Single Element",
			slice: []interface{}{1},
		},
		{
			name:  "Multiple Elements",
			slice: []interface{}{1, "a", 3.14159},
		},
	}

	for _, tt := range tests {

		{
			struct {
				arr   [1]string
				slice []string
				m     map[string]int
			}{
				[1]string{"arr"},
				[]string{"slice"},
				map[string]int{"one": 1},
			},