enum MyEnum {
	abc
	def
	lock
	xyz
	if
}

@[flag]
enum MyFlaggedEnum {
	abc
	def
	xyz
}

/*
fn dump_enum_values[R,T](list []T) {
	for input in list {
		// TODO: R.from() should work, when R is an enum, but it does not right now
		x := R.from(input) or {
			eprintln('>>>> error input: `${input}` | err: `${err}`')
			continue
		}
		eprintln('> input: ${input} | x: ${x}')
	}
	assert true
}
fn test_enums_conversion_using_from() {
	dump_enum_values[MyEnum,string](['abc', 'bbb', 'xyz', 'if', 'def', 'zzz'])
	dump_enum_values[MyFlaggedEnum,int]([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
}
*/

fn test_enum_from_string() {
	x := MyEnum.from('def')!
	dump(x)
	assert x == .def
	y := MyFlaggedEnum.from('xyz')!
	dump(y)
	assert y == .xyz
	assert MyEnum.from('if')! == MyEnum.if
	assert MyEnum.from('lock')! == MyEnum.lock
	if z := MyEnum.from('unknown') {
		assert false
	} else {
		assert err.msg() == 'invalid value'
	}
}

fn test_enum_from_integer() {
	x := MyEnum.from(3)!
	dump(x)
	assert x == .xyz
	y := MyFlaggedEnum.from(4)!
	dump(y)
	assert y == .xyz
	if z := MyFlaggedEnum.from(9999) {
		assert false
	} else {
		assert err.msg() == 'invalid value'
	}
}

@[flag]
enum Test {
	first
	second
	third
}

fn test_flagged_enum_from_0_and_empty_string() {
	z := Test.zero()
	dump(z)

	x := Test.from(0)!
	dump(x)
	assert x == z

	y := Test.from('')!
	dump(y)
	assert y == z
}