enum Colors {
	red
	green
	blue
	yellow
}

fn test_in_expression() {
	mut a := false
	arr1 := [1, 2]
	arr2 := [0, 2]
	arr3 := [1, 0]

	a = true && 2 in arr1
	assert a == true
	a = false && 2 in arr1
	assert a == false

	a = true && 0 in arr2
	assert a == true
	a = false && 0 in arr3
	assert a == false
	a = true && 0 in arr1
	assert a == false
	a = true && 3 in arr1
	assert a == false
	a = true && 2 !in arr2
	assert a == false
	a = true && 3 !in arr2
	assert a == true

	a = true && 2 !in arr2
	assert a == false
	a = true && 3 !in arr2
	assert a == true

	a = 1 in arr1 && true
	assert a == true
	a = 1 in arr1 && false
	assert a == false
}

/*
not implemented
fn test_in_expression_with_enum() {
	mut a := false
	arr1 := [Colors.green, .blue]
	arr2 := [Colors.red, .blue]
	arr3 := [Colors.green, .red]
	a = true && Colors.blue in arr1
	assert a == true
	a = false && Colors.blue in arr1
	assert a == false
	a = true && Colors.red in arr2
	assert a == true
	a = false && Colors.red in arr3
	assert a == false

	a = true && Colors.red in arr1
	assert a == false
	a = true && Colors.yellow in arr1
	assert a == false

	a = true && !(Colors.blue in arr2)
	assert a == false
	a = true && !(Colors.yellow in arr2)
	assert a == true

	a = Colors.green in arr1 && true
	assert a == true
	a = Colors.green in arr1 && false
	assert a == false
}
*/
fn test_in_expression_with_string() {
	mut a := false
	arr1 := ['ab', 'bc']
	arr2 := ['', 'bc']
	arr3 := ['ab', '']

	a = true && 'bc' in arr1
	assert a == true
	a = false && 'bc' in arr1
	assert a == false

	a = true && '' in arr2
	assert a == true
	a = false && '' in arr3
	assert a == false
	a = true && '' in arr1
	assert a == false
	a = true && 'abc' in arr1
	assert a == false
	a = true && 'bc' !in arr2
	assert a == false
	a = true && 'abc' !in arr2
	assert a == true

	a = true && 'bc' !in arr2
	assert a == false
	a = true && 'abc' !in arr2
	assert a == true

	a = 'ab' in arr1 && true
	assert a == true
	a = 'ab' in arr1 && false
	assert a == false
}

type MapAlias = map[string]int
type ArrayAlias = []int

fn test_in_expression_in_alias() {
	arr := ArrayAlias([0, 1])
	assert 0 in arr
	assert 100 !in arr

	m := MapAlias({
		'one':   1
		'two':   2
		'three': 3
	})
	assert 'one' in m
	assert 'four' !in m
}

fn test_in_expression_in_map() {
	m := {
		'one':   1
		'two':   2
		'three': 3
	}
	assert 'one' in m
	assert 'four' !in m
}

fn test_optimized_in_expression() {
	mut a := false
	a = true && 2 in [1, 2]
	assert a == true
	a = false && 2 in [1, 2]
	assert a == false

	a = true && 0 in [0, 2]
	assert a == true
	a = false && 0 in [1, 0]
	assert a == false
	a = true && 0 in [1, 2]
	assert a == false
	a = true && 3 in [1, 2]
	assert a == false
	a = true && 2 !in [0, 2]
	assert a == false
	a = true && 3 !in [0, 2]
	assert a == true

	a = true && 2 !in [0, 2]
	assert a == false
	a = true && 3 !in [0, 2]
	assert a == true

	a = 1 in [1, 2] && true
	assert a == true
	a = 1 in [1, 2] && false
	assert a == false
}

fn test_optimized_in_expression_with_enum() {
	mut a := false
	a = true && Colors.blue in [.green, .blue]
	assert a == true
	a = false && Colors.blue in [.green, .blue]
	assert a == false

	a = true && Colors.red in [.red, .blue]
	assert a == true
	a = false && Colors.red in [.green, .red]
	assert a == false
	a = true && Colors.red in [.green, .blue]
	assert a == false
	a = true && Colors.yellow in [.green, .blue]
	assert a == false
	a = true && Colors.blue !in [.red, .blue]
	assert a == false
	a = true && Colors.yellow !in [.red, .blue]
	assert a == true

	a = true && Colors.blue !in [.red, .blue]
	assert a == false
	a = true && Colors.yellow !in [.red, .blue]
	assert a == true

	a = Colors.green in [.green, .blue] && true
	assert a == true
	a = Colors.green in [.green, .blue] && false
	assert a == false
}

fn test_optimized_in_expression_with_string() {
	mut a := false
	a = true && 'bc' in ['ab', 'bc']
	assert a == true
	a = false && 'bc' in ['ab', 'bc']
	assert a == false

	a = true && '' in ['', 'bc']
	assert a == true
	a = false && '' in ['ab', '']
	assert a == false
	a = true && '' in ['ab', 'bc']
	assert a == false
	a = true && 'abc' in ['ab', 'bc']
	assert a == false
	a = true && 'bc' !in ['', 'bc']
	assert a == false
	a = true && 'abc' !in ['', 'bc']
	assert a == true

	a = true && 'bc' !in ['', 'bc']
	assert a == false
	a = true && 'abc' !in ['', 'bc']
	assert a == true

	a = 'ab' in ['ab', 'bc'] && true
	assert a == true
	a = 'ab' in ['ab', 'bc'] && false
	assert a == false
}

fn test_in_array_init() {
	assert 1 !in []int{}
	assert [1] in [[1], [2]]
}

fn test_in_expression_numeric() {
	b := [u8(2), 4, 7]
	b2 := [i8(3), -4, 9]
	s := [u16(6), 1, 0]
	s2 := [i16(34), -17, 45]
	i := [5, 7, 9]
	i2 := [u32(65), 12, 9]
	l := [u64(54), 23, 1]
	l2 := [i64(-45), 8, 2]
	f := [f32(12.5), 0, -17.25]
	f2 := [1.0625, 3, 17.125]
	assert u8(4) in b
	assert 3 !in b
	assert -4 in b2
	assert i8(5) !in b2
	assert 1 in s
	assert u16(3) !in s
	assert 45 in s2
	assert i16(0) !in s2
	assert 7 in i
	assert 8 !in i
	assert 12 in i2
	assert u32(13) !in i2
	assert u64(1) in l
	assert 2 !in l
	assert -45 in l2
	assert i64(-17) !in l2
	assert -17.25 in f
	assert f32(1) !in f
	assert 1.0625 in f2
	assert 3.5 !in f2
}

struct Foo1 {}

struct Foo2 {}

struct Foo3 {}

type Foo = Foo1 | Foo2 | Foo3

fn test_in_sumtype_array() {
	foo := Foo(Foo3{})

	if foo in [Foo1, Foo3] {
		println(foo)
		assert true
	}

	// without sumtype cast
	mut foos := []Foo{}
	foos << Foo1{}
	assert Foo1{} in foos
	assert Foo2{} !in foos
}

fn test_in_struct_array() {
	assert Foo1{} == Foo1{}
}

fn fn1() {}

fn fn2() {}

fn fn3() {}

fn test_in_func_array() {
	assert fn1 in [fn1, fn2, fn3]
}

type Str = string
type Struct = Foo1

fn test_in_alias_array() {
	assert Str('') in [Str(''), Str('a')]
	assert Struct{} == Struct{}
}

type TokenValue = rune | u64

fn test_in_array_literal_of_sumtype() {
	val1 := TokenValue(`+`)
	assert val1 in [TokenValue(`+`), TokenValue(`-`)]

	val2 := `+`
	assert val2 in [TokenValue(`+`), TokenValue(`-`)]
}

type StringOrNumber = int | string

fn test_in_array_of_sumtype() {
	arr := [StringOrNumber(1), 2, 'test']
	println(1 in arr)
	assert 1 in arr
}

// for issue 20268
struct Bar {}

fn in_both_mut_ref(mut arr []&Bar, mut bar &Bar) {
	assert bar !in arr
}

fn test_in_both_mut_and_ref() {
	mut arr := []&Bar{}
	mut bar := &Bar{}
	in_both_mut_ref(mut &arr, mut &bar)
}