// Guards the single element push fast path in `array.push`/`push_noscan`.
// Single element pushes dispatch the common small element sizes (1/2/4/8/16 bytes) to
// `vmemcpy` with a constant size, and fall back to a runtime sized `vmemcpy` otherwise.
// These tests make sure every size copies the right bytes for awkward element types too:
// low alignment size 8/16 structs, structs with padding, and floats - i.e. types where a
// typed integer copy would impose alignment it does not have or read padding through the
// wrong type. They also check that pushing to a slice view clones the backing buffer
// instead of corrupting the parent array.

struct S16 {
	a u64
	b u64
}

struct S3 {
	a u8
	b u8
	c u8
}

struct S24 {
	a u64
	b u64
	c u64
}

// Pair8 is 8 bytes with only 4 byte alignment (no field needs 8 byte alignment).
struct Pair8 {
	a int
	b int
}

// Padded8 is 8 bytes and contains padding: a u8 followed by 3 padding bytes, then a u32.
struct Padded8 {
	a u8
	b u32
}

// LowAlign16 is a 16 byte element with only 1 byte alignment (a fixed byte array field).
// This is the case a 16 byte typed (two u64) copy would mishandle on strict alignment targets.
struct LowAlign16 {
mut:
	data [16]u8
}

// Padded16 is 16 bytes and contains padding: a u8 followed by 3 padding bytes, then three
// u32s. It avoids u64 fields so its size is exactly 16 on every ABI (u64 alignment can be 4
// on some 32-bit targets, which would make a u8+u64 struct 12 bytes instead of 16).
struct Padded16 {
	a u8
	b u32
	c u32
	d u32
}

fn test_push_u8() {
	mut a := []u8{cap: 4}
	for i in 0 .. 300 {
		a << u8(i & 0xff)
	}
	assert a.len == 300
	for i in 0 .. 300 {
		assert a[i] == u8(i & 0xff)
	}
}

fn test_push_u16() {
	mut a := []u16{}
	for i in 0 .. 300 {
		a << u16(i * 7)
	}
	for i in 0 .. 300 {
		assert a[i] == u16(i * 7)
	}
}

fn test_push_int() {
	mut a := []int{}
	for i in 0 .. 300 {
		a << i * 12345
	}
	for i in 0 .. 300 {
		assert a[i] == i * 12345
	}
}

fn test_push_i64() {
	mut a := []i64{}
	for i in 0 .. 300 {
		a << i64(i) * 9876543210
	}
	for i in 0 .. 300 {
		assert a[i] == i64(i) * 9876543210
	}
}

fn test_push_f64() {
	mut a := []f64{}
	for i in 0 .. 100 {
		a << f64(i) + 0.5
	}
	for i in 0 .. 100 {
		assert a[i] == f64(i) + 0.5
	}
}

fn test_push_string() {
	// string is a 16 byte element
	mut a := []string{}
	for i in 0 .. 200 {
		a << 'item_${i}'
	}
	for i in 0 .. 200 {
		assert a[i] == 'item_${i}'
	}
}

fn test_push_struct_16() {
	mut a := []S16{}
	for i in 0 .. 200 {
		a << S16{u64(i), u64(i) * 2}
	}
	for i in 0 .. 200 {
		assert a[i].a == u64(i)
		assert a[i].b == u64(i) * 2
	}
}

fn test_push_struct_odd_size() {
	// 3 byte element exercises the vmemcpy fallback path
	mut a := []S3{}
	for i in 0 .. 200 {
		a << S3{u8(i), u8(i + 1), u8(i + 2)}
	}
	for i in 0 .. 200 {
		assert a[i].a == u8(i)
		assert a[i].b == u8(i + 1)
		assert a[i].c == u8(i + 2)
	}
}

fn test_push_struct_large() {
	// 24 byte element exercises the vmemcpy fallback path
	mut a := []S24{}
	for i in 0 .. 200 {
		a << S24{u64(i), u64(i) * 2, u64(i) * 3}
	}
	for i in 0 .. 200 {
		assert a[i].a == u64(i)
		assert a[i].b == u64(i) * 2
		assert a[i].c == u64(i) * 3
	}
}

fn test_push_to_slice_view_clones() {
	mut a := []int{cap: 10}
	for i in 0 .. 5 {
		a << i
	}
	// a real slice view into a's buffer, with spare capacity after it
	mut s := unsafe { a[1..3] }
	// pushing to a slice view must clone first, not overwrite a[3]
	s << 999
	assert a == [0, 1, 2, 3, 4]
	assert s == [1, 2, 999]
}

fn test_push_to_byte_slice_view_clones() {
	mut a := []u8{cap: 10}
	for i in 0 .. 5 {
		a << u8(i)
	}
	mut s := unsafe { a[1..3] }
	s << u8(200)
	assert a == [u8(0), 1, 2, 3, 4]
	assert s == [u8(1), 2, 200]
}

fn test_push_f32() {
	// f32 is a 4 byte element; the copy must not route it through an integer type
	mut a := []f32{}
	for i in 0 .. 100 {
		a << f32(i) + 0.25
	}
	for i in 0 .. 100 {
		assert a[i] == f32(i) + 0.25
	}
}

fn test_push_pair8_low_alignment() {
	assert sizeof(Pair8) == 8
	mut a := []Pair8{}
	for i in 0 .. 200 {
		a << Pair8{i, i * 3}
	}
	for i in 0 .. 200 {
		assert a[i].a == i
		assert a[i].b == i * 3
	}
}

fn test_push_padded8() {
	assert sizeof(Padded8) == 8
	mut a := []Padded8{}
	for i in 0 .. 200 {
		a << Padded8{u8(i), u32(i) * 7}
	}
	for i in 0 .. 200 {
		assert a[i].a == u8(i)
		assert a[i].b == u32(i) * 7
	}
}

fn test_push_low_alignment_16() {
	assert sizeof(LowAlign16) == 16
	mut a := []LowAlign16{}
	for i in 0 .. 200 {
		mut e := LowAlign16{}
		for j in 0 .. 16 {
			e.data[j] = u8(i + j)
		}
		a << e
	}
	for i in 0 .. 200 {
		for j in 0 .. 16 {
			assert a[i].data[j] == u8(i + j)
		}
	}
}

fn test_push_padded16() {
	assert sizeof(Padded16) == 16
	mut a := []Padded16{}
	for i in 0 .. 200 {
		a << Padded16{u8(i), u32(i) * 99, u32(i) * 7, u32(i) * 13}
	}
	for i in 0 .. 200 {
		assert a[i].a == u8(i)
		assert a[i].b == u32(i) * 99
		assert a[i].c == u32(i) * 7
		assert a[i].d == u32(i) * 13
	}
}