import hash.adler32

fn test_adler32_rfc_vectors() {
	assert adler32.sum([]u8{}) == u32(0x00000001)
	assert adler32.sum('123456789'.bytes()) == u32(0x091e01de)
	assert adler32.sum('Wikipedia'.bytes()) == u32(0x11e60398)
}

fn test_adler32_basic_aliases() {
	data := 'Hello world!'.bytes()
	expected := u32(0x1d09045e)
	assert adler32.checksum(data) == expected
	assert adler32.sum(data) == expected
}

fn test_adler32_update_matches_full_sum() {
	data := 'streaming adler32 data'.bytes()
	part1 := data[..8]
	part2 := data[8..14]
	part3 := data[14..]

	mut state := u32(1)
	state = adler32.update(state, part1)
	state = adler32.update(state, part2)
	state = adler32.update(state, part3)

	assert state == adler32.sum(data)
}

fn test_adler32_update_state_matches_update() {
	data := ('chunked data '.repeat(80)).bytes()
	mut via_state := u32(1)
	mut via_update := u32(1)
	for chunk_size in [1, 2, 3, 5, 8, 16, 64, 257] {
		mut state_a := u32(1)
		mut state_b := u32(1)
		mut i := 0
		for i < data.len {
			end := if i + chunk_size < data.len { i + chunk_size } else { data.len }
			chunk := data[i..end]
			state_a = adler32.update_state(state_a, chunk)
			state_b = adler32.update(state_b, chunk)
			i = end
		}
		assert state_a == adler32.sum(data)
		assert state_b == adler32.sum(data)
		via_state = state_a
		via_update = state_b
	}
	assert via_state == via_update
}

fn test_adler32_all_bytes() {
	mut all_bytes := []u8{len: 256}
	for i in 0 .. 256 {
		all_bytes[i] = u8(i)
	}
	assert adler32.sum(all_bytes) == u32(0xadf67f81)
}

fn test_adler32_large_input() {
	data := 'a'.repeat(7000).bytes()
	assert adler32.sum(data) == u32(0x1a305cef)
}