slicemap := make(map[string][]string,` + strconv.FormatInt(abi.MapBucketCount+3, 10) + `)
    chanint := make(chan int, 10)
    chanstr := make(chan string, 10)
    chanint <- 99
	chanint <- 11
    chanstr <- "spongepants"
    chanstr <- "squarebob"
	mapvar["abc"] = "def"
	mapvar["ghi"] = "jkl"
	slicemap["a"] = []string{"b","c","d"}
    slicemap["e"] = []string{"f","g","h"}
	strvar := "abc"

	data := []User{}
	if err := DB.Create(&data).Error; err != gorm.ErrEmptySlice {
		t.Errorf("no data should be created, got %v", err)
	}

	sliceMap := []map[string]interface{}{}
	if err := DB.Model(&User{}).Create(&sliceMap).Error; err != gorm.ErrEmptySlice {
		t.Errorf("no data should be created, got %v", err)
	}
}

func TestCreateInvalidSlice(t *testing.T) {
	users := []*User{

	t.Run("maxint", func(t *testing.T) {
		c := SliceCap[byte](1 << 63)
		if c >= 0 {
			t.Errorf("SliceCap returned %d, expected failure", c)
		}
	})

	t.Run("overflow", func(t *testing.T) {
		c := SliceCap[int64](1 << 62)
		if c >= 0 {
			t.Errorf("SliceCap returned %d, expected failure", c)
		}
	})

	}
	if size > 0 && c > (1<<64-1)/size {
		return -1
	}
	if c*size > chunk {
		c = chunk / size
		if c == 0 {
			c = 1
		}
	}
	return int(c)
}

// SliceCap is like SliceCapWithSize but using generics.
func SliceCap[E any](c uint64) int {
	var v E
	size := uint64(unsafe.Sizeof(v))
	return SliceCapWithSize(size, c)

  (Store {typ.Int}
    (OffPtr <typ.IntPtr> [config.PtrSize] dst)
    len
    (Store {typ.BytePtr} dst ptr mem))

// slice ops
(SlicePtr (SliceMake ptr _ _ )) => ptr
(SliceLen (SliceMake _ len _)) => len
(SliceCap (SliceMake _ _ cap)) => cap
(SlicePtrUnchecked (SliceMake ptr _ _ )) => ptr

(Load <t> ptr mem) && t.IsSlice() =>
  (SliceMake
    (Load <t.Elem().PtrTo()> ptr mem)
    (Load <typ.Int>

	// Make sure that all images are for the same MH_ type.
	var machoType Type

	// Following the fat_header comes narch fat_arch structs that index
	// Mach-O images further in the file.
	c := saferio.SliceCap[FatArch](uint64(narch))
	if c < 0 {
		return nil, &FormatError{offset, "too many images", nil}
	}
	ff.Arches = make([]FatArch, 0, c)
	for i := uint32(0); i < narch; i++ {
		var fa FatArch

	if fh.NumberOfSymbols <= 0 {
		return nil, nil
	}
	_, err := r.Seek(int64(fh.PointerToSymbolTable), io.SeekStart)
	if err != nil {
		return nil, fmt.Errorf("fail to seek to symbol table: %v", err)
	}
	c := saferio.SliceCap[COFFSymbol](uint64(fh.NumberOfSymbols))
	if c < 0 {
		return nil, errors.New("too many symbols; file may be corrupt")
	}
	syms := make([]COFFSymbol, 0, c)
	naux := 0
	for k := uint32(0); k < fh.NumberOfSymbols; k++ {

			return nil, err
		}
		f.StringTable = st
	}

	// Read section headers
	if _, err := sr.Seek(int64(hdrsz)+int64(opthdr), io.SeekStart); err != nil {
		return nil, err
	}
	c := saferio.SliceCap[*Section](uint64(nscns))
	if c < 0 {
		return nil, fmt.Errorf("too many XCOFF sections (%d)", nscns)
	}
	f.Sections = make([]*Section, 0, c)
	for i := 0; i < int(nscns); i++ {
		var scnptr uint64

	offset := int64(fileHeaderSize32)
	if f.Magic == Magic64 {
		offset = fileHeaderSize64
	}
	dat, err := saferio.ReadDataAt(r, uint64(f.Cmdsz), offset)
	if err != nil {
		return nil, err
	}
	c := saferio.SliceCap[Load](uint64(f.Ncmd))
	if c < 0 {
		return nil, &FormatError{offset, "too many load commands", nil}
	}
	f.Loads = make([]Load, 0, c)
	bo := f.ByteOrder
	for i := uint32(0); i < f.Ncmd; i++ {

	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (SliceCap (SliceMake _ _ cap))
	// result: cap
	for {
		if v_0.Op != OpSliceMake {
			break
		}
		cap := v_0.Args[2]
		v.copyOf(cap)
		return true
	}
	// match: (SliceCap x:(Load <t> ptr mem))
	// cond: t.IsSlice()