From 9b1c439d2cfbbdf469ecd89421aeb6cf6b65f8dd Mon Sep 17 00:00:00 2001 From: akhercha Date: Thu, 2 Nov 2023 08:35:35 +0100 Subject: [PATCH] tests: Added tests for SerializableFelt252Dict (#573) feat(item_span_comparison): Added tests for SerializableDict Co-authored-by: Michel <105498726+Sk8erboi84@users.noreply.github.com> --- src/utils/serializable_dict.cairo | 4 +- tests/utils/test_serializable_dict.cairo | 101 +++++++++++++++++++++++ 2 files changed, 103 insertions(+), 2 deletions(-) diff --git a/src/utils/serializable_dict.cairo b/src/utils/serializable_dict.cairo index e5baed05..143c8037 100644 --- a/src/utils/serializable_dict.cairo +++ b/src/utils/serializable_dict.cairo @@ -45,13 +45,13 @@ impl ItemImpl of ItemTrait { fn unwrap_single>(self: @Item) -> T { match self { Item::Single(v) => (*v), - Item::Span(arr) => panic_with_felt252('should not be a span') + Item::Span(arr) => panic_with_felt252('should be single') } } fn unwrap_span(self: @Item) -> Span { match self { - Item::Single(v) => panic_with_felt252('should not be single'), + Item::Single(v) => panic_with_felt252('should be a span'), Item::Span(arr) => *arr } } diff --git a/tests/utils/test_serializable_dict.cairo b/tests/utils/test_serializable_dict.cairo index 64288d43..385b760d 100644 --- a/tests/utils/test_serializable_dict.cairo +++ b/tests/utils/test_serializable_dict.cairo @@ -52,6 +52,74 @@ fn test_item_span() { assert(item.len() == expected_len, 'incorrect len'); } +#[test] +fn test_item_comparison_single_equals() { + let item_a: Item = Item::Single(42); + let item_b: Item = Item::Single(42); + assert(item_a == item_b, 'u128 should be equals'); + + let item_a: Item = Item::Single(42); + let item_b: Item = Item::Single(69); + assert(item_a != item_b, 'u128 shouldnt be equals'); + + let item_a: Item = Item::Single(69); + let item_b: Item = Item::Single(69); + assert(item_a == item_b, 'felt252 should be equals'); + + let item_a: Item = Item::Single(42); + let item_b: Item = Item::Single(69); + assert(item_a != item_b, 'felt252 shouldnt be equals'); +} + +#[test] +fn test_item_comparison_spans() { + let item_a: Item = Item::Span(array![1, 2, 3].span()); + let item_b: Item = Item::Span(array![1, 2, 3].span()); + assert(item_a == item_b, 'u128 should be equals'); + + let item_a: Item = Item::Span(array![1, 2, 3].span()); + let item_b: Item = Item::Span(array![4, 5].span()); + assert(item_a != item_b, 'u128 shouldnt be equals'); + + let item_a: Item = Item::Span(array![1, 2, 3].span()); + let item_b: Item = Item::Span(array![1, 2, 3].span()); + assert(item_a == item_b, 'felt252 should be equals'); + + let item_a: Item = Item::Span(array![1, 2, 3].span()); + let item_b: Item = Item::Span(array![1, 2, 9].span()); + assert(item_a != item_b, 'felt252 shouldnt be equals'); + + let item_a: Item = Item::Span( + array![contract_address_const::<'satoshi'>(), contract_address_const::<'nakamoto'>()].span() + ); + let item_b: Item = Item::Span( + array![contract_address_const::<'satoshi'>(), contract_address_const::<'nakamoto'>()].span() + ); + assert(item_a == item_b, 'contract should be equals'); + + let item_a: Item = Item::Span( + array![contract_address_const::<'satoshi'>(), contract_address_const::<'nakamoto'>()].span() + ); + let item_b: Item = Item::Span( + array![contract_address_const::<'nakamoto'>(), contract_address_const::<'satoshi'>()].span() + ); + assert(item_a != item_b, 'contract shouldnt be equals'); +} + +#[test] +#[should_panic(expected: ('should be a span',))] +fn test_item_unwrap_single_as_span() { + let item: Item = Item::Single(8); + item.unwrap_span(); +} + +#[test] +#[should_panic(expected: ('should be single',))] +fn test_item_unwrap_span_as_single() { + let item: Item = Item::Span(array![1, 2].span()); + item.unwrap_single(); +} + // SerializableDict tests #[test] @@ -66,6 +134,8 @@ fn test_serializable_dict_insert_single() { let retrieved_item: Item = dict.get(key).expect('key should be in dict'); let out_value: u128 = retrieved_item.unwrap_single(); + assert(dict.contains(key), 'key should be in dict'); + assert(dict.len() == 1, 'wrong dict len'); assert(out_value == expected_value, 'wrong value'); } @@ -82,6 +152,7 @@ fn test_serializable_dict_insert_span() { let out_span: Span = retrieved_item.unwrap_span(); assert(dict.contains(key), 'key should be in dict'); + assert(dict.len() == 1, 'wrong dict len'); assert(out_span.at(0) == expected_array.at(0), 'wrong at idx 0'); assert(out_span.at(1) == expected_array.at(1), 'wrong at idx 1'); assert(out_span.at(2) == expected_array.at(2), 'wrong at idx 2'); @@ -91,6 +162,9 @@ fn test_serializable_dict_insert_span() { fn test_serializable_dict_serialize() { let mut dict: SerializableFelt252Dict = SerializableFelt252DictTrait::new(); + assert(dict.is_empty(), 'dict should be empty'); + assert(dict.len() == 0, 'wrong empty dict len'); + let expected_value: u128 = 42; let expected_array: Array = array![1, 2, 3]; @@ -115,7 +189,34 @@ fn test_serializable_dict_serialize() { .get('test_span') .expect('key should be in dict'); let out_span: Span = retrieved_item.unwrap_span(); + assert(dict.len() == 2, 'wrong deserialized dict len'); + assert(dict.contains('test'), 'test should be in dict'); + assert(dict.contains('test_span'), 'test should be in dict'); assert(out_span.at(0) == expected_array.at(0), 'wrong at idx 0'); assert(out_span.at(1) == expected_array.at(1), 'wrong at idx 1'); assert(out_span.at(2) == expected_array.at(2), 'wrong at idx 2'); } + +#[test] +#[should_panic(expected: ('err getting value',))] +fn test_error_deserialize_value() { + let serialized_dict: Array = array!['key', 1, 1, 'key_2', 2, 1]; + let mut span_serialized: Span = serialized_dict.span(); + + match SerializableFelt252DictTrait::::deserialize(ref span_serialized) { + Option::Some(d) => panic_with_felt252('should have panicked'), + Option::None => () + }; +} + +#[test] +#[should_panic(expected: ('err getting size',))] +fn test_error_deserialize_size() { + let serialized_dict: Array = array!['key', 1, 1, 'key_2']; + let mut span_serialized: Span = serialized_dict.span(); + + match SerializableFelt252DictTrait::::deserialize(ref span_serialized) { + Option::Some(d) => panic_with_felt252('should have panicked'), + Option::None => () + }; +}