104 lines
2.4 KiB
Plaintext
104 lines
2.4 KiB
Plaintext
import "@std/mem"
|
|
import "@std/testing"
|
|
|
|
@hide:file
|
|
TestEnum :: enum(u8) {
|
|
ident = 3
|
|
int = 8
|
|
eof = 21
|
|
}
|
|
|
|
handles_sparse_enum_get test {
|
|
names EnumMap(TestEnum, []u8) :: init({
|
|
ident = "identifier",
|
|
int = "integer",
|
|
})
|
|
|
|
ident :: get(&names, TestEnum.ident)
|
|
|
|
try testing.expect_type(?[]u8, ident)
|
|
try testing.expect(mem.eql("identifier", ident?))
|
|
|
|
eof :: get(&names, TestEnum.eof)
|
|
|
|
try testing.expect_type(?[]u8, eof)
|
|
try testing.expect_equal(null, eof)
|
|
}
|
|
|
|
@hide:file
|
|
sparse_optional_values :: $init_default(TestEnum, ?i16, null, {
|
|
ident = some!(null),
|
|
int = some!(some!(i16(42))),
|
|
})
|
|
|
|
filled_comptime_storage_preserves_absence_and_nested_optional_presence test {
|
|
absent :: get(&sparse_optional_values, TestEnum.eof)
|
|
present_null :: get(&sparse_optional_values, TestEnum.ident)
|
|
present_value :: get(&sparse_optional_values, TestEnum.int)
|
|
try testing.expect(absent == null)
|
|
try testing.expect(present_null != null)
|
|
try testing.expect(present_null? == null)
|
|
try testing.expect_equal(i16(42), present_value??)
|
|
}
|
|
|
|
@hide:file
|
|
TestLeftError :: enum {
|
|
shared
|
|
left
|
|
absent_left
|
|
}
|
|
|
|
@hide:file
|
|
TestRightError :: enum {
|
|
shared
|
|
right
|
|
absent_right
|
|
}
|
|
|
|
@hide:file
|
|
TestNestedError :: alias (TestLeftError | (TestRightError | TestLeftError))
|
|
|
|
@hide:file
|
|
TestComposedError :: alias TestNestedError
|
|
|
|
@hide:file
|
|
composed_values :: $init(TestComposedError, i32, {
|
|
shared = 11,
|
|
left = 22,
|
|
absent_left = 33,
|
|
right = 44,
|
|
absent_right = 55,
|
|
})
|
|
|
|
handles_composed_enum_keys_at_runtime test {
|
|
names EnumMap(TestComposedError, []u8) :: init({
|
|
shared = "shared error",
|
|
left = "left error",
|
|
right = "right error",
|
|
})
|
|
keys [_]TestComposedError :: [
|
|
TestLeftError.shared,
|
|
TestLeftError.left,
|
|
TestRightError.shared,
|
|
TestRightError.right,
|
|
TestLeftError.absent_left,
|
|
TestRightError.absent_right,
|
|
]
|
|
expected [_]?[]u8 :: [
|
|
"shared error",
|
|
"left error",
|
|
"shared error",
|
|
"right error",
|
|
null,
|
|
null,
|
|
]
|
|
expected_values [_]i32 :: [11, 22, 11, 44, 33, 55]
|
|
|
|
for keys |key, index| {
|
|
value :: get(&names, key)
|
|
try testing.expect_type(?[]u8, value)
|
|
try testing.expect_equal(expected[index], value)
|
|
try testing.expect_equal(expected_values[index], get(&composed_values, key)?)
|
|
}
|
|
}
|