mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-06-12 15:51:12 +00:00
Remove extra commas made redundent after rustfmt (#9404)
* Remove extra commas made redundent after rustfmt
This commit is contained in:
Squirrel
@@ -193,7 +193,7 @@ fn check_runtime_api_versions() {
|
||||
fn mock_runtime_api_has_api() {
|
||||
let mock = MockApi { block: None };
|
||||
|
||||
assert!(mock.has_api::<dyn ApiWithCustomVersion<Block>>(&BlockId::Number(0)).unwrap(),);
|
||||
assert!(mock.has_api::<dyn ApiWithCustomVersion<Block>>(&BlockId::Number(0)).unwrap());
|
||||
assert!(mock.has_api::<dyn Api<Block>>(&BlockId::Number(0)).unwrap());
|
||||
}
|
||||
|
||||
|
||||
@@ -51,7 +51,7 @@ fn main() {
|
||||
let sum: u128 = normalized.iter().map(|x| *x as u128).sum();
|
||||
|
||||
// if this function returns Ok(), then it will ALWAYS be accurate.
|
||||
assert_eq!(sum, norm as u128, "sums don't match {:?}, {}", normalized, norm,);
|
||||
assert_eq!(sum, norm as u128, "sums don't match {:?}, {}", normalized, norm);
|
||||
} else {
|
||||
panic!("Should have returned Ok for input = {:?}, target = {:?}", data, norm);
|
||||
}
|
||||
|
||||
@@ -639,9 +639,9 @@ pub mod tests {
|
||||
|
||||
#[test]
|
||||
fn equality_works() {
|
||||
assert_eq!(BigUint { digits: vec![1, 2, 3] } == BigUint { digits: vec![1, 2, 3] }, true,);
|
||||
assert_eq!(BigUint { digits: vec![3, 2, 3] } == BigUint { digits: vec![1, 2, 3] }, false,);
|
||||
assert_eq!(BigUint { digits: vec![0, 1, 2, 3] } == BigUint { digits: vec![1, 2, 3] }, true,);
|
||||
assert_eq!(BigUint { digits: vec![1, 2, 3] } == BigUint { digits: vec![1, 2, 3] }, true);
|
||||
assert_eq!(BigUint { digits: vec![3, 2, 3] } == BigUint { digits: vec![1, 2, 3] }, false);
|
||||
assert_eq!(BigUint { digits: vec![0, 1, 2, 3] } == BigUint { digits: vec![1, 2, 3] }, true);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -667,7 +667,7 @@ pub mod tests {
|
||||
use sp_std::convert::TryFrom;
|
||||
assert_eq!(u64::try_from(with_limbs(1)).unwrap(), 1);
|
||||
assert_eq!(u64::try_from(with_limbs(2)).unwrap(), u32::MAX as u64 + 2);
|
||||
assert_eq!(u64::try_from(with_limbs(3)).unwrap_err(), "cannot fit a number into u64",);
|
||||
assert_eq!(u64::try_from(with_limbs(3)).unwrap_err(), "cannot fit a number into u64");
|
||||
assert_eq!(u128::try_from(with_limbs(3)).unwrap(), u32::MAX as u128 + u64::MAX as u128 + 3);
|
||||
}
|
||||
|
||||
|
||||
@@ -300,13 +300,13 @@ mod normalize_tests {
|
||||
#[test]
|
||||
fn fails_on_if_input_sum_large() {
|
||||
assert!(normalize(vec![1u8; 255].as_ref(), 10).is_ok());
|
||||
assert_eq!(normalize(vec![1u8; 256].as_ref(), 10), Err("sum of input cannot fit in `T`"),);
|
||||
assert_eq!(normalize(vec![1u8; 256].as_ref(), 10), Err("sum of input cannot fit in `T`"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn does_not_fail_on_subtraction_overflow() {
|
||||
assert_eq!(normalize(vec![1u8, 100, 100].as_ref(), 10).unwrap(), vec![1, 9, 0],);
|
||||
assert_eq!(normalize(vec![1u8, 8, 9].as_ref(), 1).unwrap(), vec![0, 1, 0],);
|
||||
assert_eq!(normalize(vec![1u8, 100, 100].as_ref(), 10).unwrap(), vec![1, 9, 0]);
|
||||
assert_eq!(normalize(vec![1u8, 8, 9].as_ref(), 1).unwrap(), vec![0, 1, 0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -358,40 +358,40 @@ mod normalize_tests {
|
||||
|
||||
#[test]
|
||||
fn normalize_works_all_le() {
|
||||
assert_eq!(normalize(vec![8u32, 9, 7, 10].as_ref(), 40).unwrap(), vec![10, 10, 10, 10],);
|
||||
assert_eq!(normalize(vec![8u32, 9, 7, 10].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
|
||||
|
||||
assert_eq!(normalize(vec![7u32, 7, 7, 7].as_ref(), 40).unwrap(), vec![10, 10, 10, 10],);
|
||||
assert_eq!(normalize(vec![7u32, 7, 7, 7].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
|
||||
|
||||
assert_eq!(normalize(vec![7u32, 7, 7, 10].as_ref(), 40).unwrap(), vec![11, 11, 8, 10],);
|
||||
assert_eq!(normalize(vec![7u32, 7, 7, 10].as_ref(), 40).unwrap(), vec![11, 11, 8, 10]);
|
||||
|
||||
assert_eq!(normalize(vec![7u32, 8, 7, 10].as_ref(), 40).unwrap(), vec![11, 8, 11, 10],);
|
||||
assert_eq!(normalize(vec![7u32, 8, 7, 10].as_ref(), 40).unwrap(), vec![11, 8, 11, 10]);
|
||||
|
||||
assert_eq!(normalize(vec![7u32, 7, 8, 10].as_ref(), 40).unwrap(), vec![11, 11, 8, 10],);
|
||||
assert_eq!(normalize(vec![7u32, 7, 8, 10].as_ref(), 40).unwrap(), vec![11, 11, 8, 10]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn normalize_works_some_ge() {
|
||||
assert_eq!(normalize(vec![8u32, 11, 9, 10].as_ref(), 40).unwrap(), vec![10, 11, 9, 10],);
|
||||
assert_eq!(normalize(vec![8u32, 11, 9, 10].as_ref(), 40).unwrap(), vec![10, 11, 9, 10]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn always_inc_min() {
|
||||
assert_eq!(normalize(vec![10u32, 7, 10, 10].as_ref(), 40).unwrap(), vec![10, 10, 10, 10],);
|
||||
assert_eq!(normalize(vec![10u32, 10, 7, 10].as_ref(), 40).unwrap(), vec![10, 10, 10, 10],);
|
||||
assert_eq!(normalize(vec![10u32, 10, 10, 7].as_ref(), 40).unwrap(), vec![10, 10, 10, 10],);
|
||||
assert_eq!(normalize(vec![10u32, 7, 10, 10].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
|
||||
assert_eq!(normalize(vec![10u32, 10, 7, 10].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
|
||||
assert_eq!(normalize(vec![10u32, 10, 10, 7].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn normalize_works_all_ge() {
|
||||
assert_eq!(normalize(vec![12u32, 11, 13, 10].as_ref(), 40).unwrap(), vec![10, 10, 10, 10],);
|
||||
assert_eq!(normalize(vec![12u32, 11, 13, 10].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
|
||||
|
||||
assert_eq!(normalize(vec![13u32, 13, 13, 13].as_ref(), 40).unwrap(), vec![10, 10, 10, 10],);
|
||||
assert_eq!(normalize(vec![13u32, 13, 13, 13].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
|
||||
|
||||
assert_eq!(normalize(vec![13u32, 13, 13, 10].as_ref(), 40).unwrap(), vec![12, 9, 9, 10],);
|
||||
assert_eq!(normalize(vec![13u32, 13, 13, 10].as_ref(), 40).unwrap(), vec![12, 9, 9, 10]);
|
||||
|
||||
assert_eq!(normalize(vec![13u32, 12, 13, 10].as_ref(), 40).unwrap(), vec![9, 12, 9, 10],);
|
||||
assert_eq!(normalize(vec![13u32, 12, 13, 10].as_ref(), 40).unwrap(), vec![9, 12, 9, 10]);
|
||||
|
||||
assert_eq!(normalize(vec![13u32, 13, 12, 10].as_ref(), 40).unwrap(), vec![9, 9, 12, 10],);
|
||||
assert_eq!(normalize(vec![13u32, 13, 12, 10].as_ref(), 40).unwrap(), vec![9, 9, 12, 10]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -389,7 +389,7 @@ mod tests {
|
||||
r(7, MAX128).checked_sub(r(MAX128, MAX128)),
|
||||
Err("overflow while subtracting numerators"),
|
||||
);
|
||||
assert_eq!(r(1, 10).checked_sub(r(2, 10)), Err("overflow while subtracting numerators"),);
|
||||
assert_eq!(r(1, 10).checked_sub(r(2, 10)), Err("overflow while subtracting numerators"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -433,8 +433,8 @@ mod tests {
|
||||
(MAX128 / 1000 * 555) + (455 * 555 / 1000),
|
||||
);
|
||||
|
||||
assert_eq!(multiply_by_rational(2 * MAX64 - 1, MAX64, MAX64).unwrap(), 2 * MAX64 - 1,);
|
||||
assert_eq!(multiply_by_rational(2 * MAX64 - 1, MAX64 - 1, MAX64).unwrap(), 2 * MAX64 - 3,);
|
||||
assert_eq!(multiply_by_rational(2 * MAX64 - 1, MAX64, MAX64).unwrap(), 2 * MAX64 - 1);
|
||||
assert_eq!(multiply_by_rational(2 * MAX64 - 1, MAX64 - 1, MAX64).unwrap(), 2 * MAX64 - 3);
|
||||
|
||||
assert_eq!(
|
||||
multiply_by_rational(MAX64 + 100, MAX64_2, MAX64_2 / 2).unwrap(),
|
||||
@@ -449,7 +449,7 @@ mod tests {
|
||||
multiply_by_rational(2u128.pow(66) - 1, 2u128.pow(65) - 1, 2u128.pow(65)).unwrap(),
|
||||
73786976294838206461,
|
||||
);
|
||||
assert_eq!(multiply_by_rational(1_000_000_000, MAX128 / 8, MAX128 / 2).unwrap(), 250000000,);
|
||||
assert_eq!(multiply_by_rational(1_000_000_000, MAX128 / 8, MAX128 / 2).unwrap(), 250000000);
|
||||
|
||||
assert_eq!(
|
||||
multiply_by_rational(
|
||||
@@ -464,8 +464,8 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn multiply_by_rational_a_b_are_interchangeable() {
|
||||
assert_eq!(multiply_by_rational(10, MAX128, MAX128 / 2), Ok(20),);
|
||||
assert_eq!(multiply_by_rational(MAX128, 10, MAX128 / 2), Ok(20),);
|
||||
assert_eq!(multiply_by_rational(10, MAX128, MAX128 / 2), Ok(20));
|
||||
assert_eq!(multiply_by_rational(MAX128, 10, MAX128 / 2), Ok(20));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -150,7 +150,7 @@ impl OffchainState {
|
||||
panic!("Missing pending request: {:?}.\n\nAll: {:?}", id, self.requests);
|
||||
},
|
||||
Some(req) => {
|
||||
assert_eq!(*req, expected,);
|
||||
assert_eq!(*req, expected);
|
||||
req.response = Some(response.into());
|
||||
req.response_headers = response_headers.into_iter().collect();
|
||||
},
|
||||
|
||||
@@ -462,7 +462,7 @@ mod tests {
|
||||
|
||||
let inherent_data = provider.create_inherent_data().unwrap();
|
||||
|
||||
assert_eq!(inherent_data.get_data::<u32>(&TEST_INHERENT_0).unwrap().unwrap(), 42u32,);
|
||||
assert_eq!(inherent_data.get_data::<u32>(&TEST_INHERENT_0).unwrap().unwrap(), 42u32);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1108,7 +1108,7 @@ pub trait Logging {
|
||||
/// Instead of using directly, prefer setting up `RuntimeLogger` and using `log` macros.
|
||||
fn log(level: LogLevel, target: &str, message: &[u8]) {
|
||||
if let Ok(message) = std::str::from_utf8(message) {
|
||||
log::log!(target: target, log::Level::from(level), "{}", message,)
|
||||
log::log!(target: target, log::Level::from(level), "{}", message)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -191,20 +191,20 @@ mod tests {
|
||||
Node::set_parent_of(&e, &a);
|
||||
Node::set_parent_of(&a, &d);
|
||||
|
||||
assert_eq!(Node::root(&e), (d.clone(), vec![e.clone(), a.clone(), d.clone()]),);
|
||||
assert_eq!(Node::root(&e), (d.clone(), vec![e.clone(), a.clone(), d.clone()]));
|
||||
|
||||
assert_eq!(Node::root(&a), (d.clone(), vec![a.clone(), d.clone()]),);
|
||||
assert_eq!(Node::root(&a), (d.clone(), vec![a.clone(), d.clone()]));
|
||||
|
||||
assert_eq!(Node::root(&c), (d.clone(), vec![c.clone(), b.clone(), a.clone(), d.clone()]),);
|
||||
assert_eq!(Node::root(&c), (d.clone(), vec![c.clone(), b.clone(), a.clone(), d.clone()]));
|
||||
|
||||
// D A <-- B <-- C
|
||||
// F <-- / \
|
||||
// <-- E
|
||||
Node::set_parent_of(&a, &f);
|
||||
|
||||
assert_eq!(Node::root(&a), (f.clone(), vec![a.clone(), f.clone()]),);
|
||||
assert_eq!(Node::root(&a), (f.clone(), vec![a.clone(), f.clone()]));
|
||||
|
||||
assert_eq!(Node::root(&c), (f.clone(), vec![c.clone(), b.clone(), a.clone(), f.clone()]),);
|
||||
assert_eq!(Node::root(&c), (f.clone(), vec![c.clone(), b.clone(), a.clone(), f.clone()]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -747,7 +747,7 @@ mod assignment_convert_normalize {
|
||||
}
|
||||
);
|
||||
|
||||
assert_eq!(assignment.into_staked(125), staked,);
|
||||
assert_eq!(assignment.into_staked(125), staked);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -817,7 +817,7 @@ mod assignment_convert_normalize {
|
||||
fn staked_assignment_can_normalize() {
|
||||
let mut a = StakedAssignment { who: 1, distribution: vec![(2, 33), (3, 66)] };
|
||||
a.try_normalize(100).unwrap();
|
||||
assert_eq!(a, StakedAssignment { who: 1, distribution: vec![(2, 34), (3, 66),] },);
|
||||
assert_eq!(a, StakedAssignment { who: 1, distribution: vec![(2, 34), (3, 66),] });
|
||||
}
|
||||
}
|
||||
|
||||
@@ -827,16 +827,16 @@ mod score {
|
||||
fn score_comparison_is_lexicographical_no_epsilon() {
|
||||
let epsilon = Perbill::zero();
|
||||
// only better in the fist parameter, worse in the other two ✅
|
||||
assert_eq!(is_score_better([12, 10, 35], [10, 20, 30], epsilon), true,);
|
||||
assert_eq!(is_score_better([12, 10, 35], [10, 20, 30], epsilon), true);
|
||||
|
||||
// worse in the first, better in the other two ❌
|
||||
assert_eq!(is_score_better([9, 30, 10], [10, 20, 30], epsilon), false,);
|
||||
assert_eq!(is_score_better([9, 30, 10], [10, 20, 30], epsilon), false);
|
||||
|
||||
// equal in the first, the second one dictates.
|
||||
assert_eq!(is_score_better([10, 25, 40], [10, 20, 30], epsilon), true,);
|
||||
assert_eq!(is_score_better([10, 25, 40], [10, 20, 30], epsilon), true);
|
||||
|
||||
// equal in the first two, the last one dictates.
|
||||
assert_eq!(is_score_better([10, 20, 40], [10, 20, 30], epsilon), false,);
|
||||
assert_eq!(is_score_better([10, 20, 40], [10, 20, 30], epsilon), false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -845,37 +845,37 @@ mod score {
|
||||
|
||||
{
|
||||
// no more than 1 percent (10) better in the first param.
|
||||
assert_eq!(is_score_better([1009, 5000, 100000], [1000, 5000, 100000], epsilon), false,);
|
||||
assert_eq!(is_score_better([1009, 5000, 100000], [1000, 5000, 100000], epsilon), false);
|
||||
|
||||
// now equal, still not better.
|
||||
assert_eq!(is_score_better([1010, 5000, 100000], [1000, 5000, 100000], epsilon), false,);
|
||||
assert_eq!(is_score_better([1010, 5000, 100000], [1000, 5000, 100000], epsilon), false);
|
||||
|
||||
// now it is.
|
||||
assert_eq!(is_score_better([1011, 5000, 100000], [1000, 5000, 100000], epsilon), true,);
|
||||
assert_eq!(is_score_better([1011, 5000, 100000], [1000, 5000, 100000], epsilon), true);
|
||||
}
|
||||
|
||||
{
|
||||
// First score score is epsilon better, but first score is no longer `ge`. Then this is
|
||||
// still not a good solution.
|
||||
assert_eq!(is_score_better([999, 6000, 100000], [1000, 5000, 100000], epsilon), false,);
|
||||
assert_eq!(is_score_better([999, 6000, 100000], [1000, 5000, 100000], epsilon), false);
|
||||
}
|
||||
|
||||
{
|
||||
// first score is equal or better, but not epsilon. Then second one is the determinant.
|
||||
assert_eq!(is_score_better([1005, 5000, 100000], [1000, 5000, 100000], epsilon), false,);
|
||||
assert_eq!(is_score_better([1005, 5000, 100000], [1000, 5000, 100000], epsilon), false);
|
||||
|
||||
assert_eq!(is_score_better([1005, 5050, 100000], [1000, 5000, 100000], epsilon), false,);
|
||||
assert_eq!(is_score_better([1005, 5050, 100000], [1000, 5000, 100000], epsilon), false);
|
||||
|
||||
assert_eq!(is_score_better([1005, 5051, 100000], [1000, 5000, 100000], epsilon), true,);
|
||||
assert_eq!(is_score_better([1005, 5051, 100000], [1000, 5000, 100000], epsilon), true);
|
||||
}
|
||||
|
||||
{
|
||||
// first score and second are equal or less than epsilon more, third is determinant.
|
||||
assert_eq!(is_score_better([1005, 5025, 100000], [1000, 5000, 100000], epsilon), false,);
|
||||
assert_eq!(is_score_better([1005, 5025, 100000], [1000, 5000, 100000], epsilon), false);
|
||||
|
||||
assert_eq!(is_score_better([1005, 5025, 99_000], [1000, 5000, 100000], epsilon), false,);
|
||||
assert_eq!(is_score_better([1005, 5025, 99_000], [1000, 5000, 100000], epsilon), false);
|
||||
|
||||
assert_eq!(is_score_better([1005, 5025, 98_999], [1000, 5000, 100000], epsilon), true,);
|
||||
assert_eq!(is_score_better([1005, 5025, 98_999], [1000, 5000, 100000], epsilon), true);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -999,7 +999,7 @@ mod solution_type {
|
||||
|
||||
let encoded = compact.encode();
|
||||
|
||||
assert_eq!(compact, Decode::decode(&mut &encoded[..]).unwrap(),);
|
||||
assert_eq!(compact, Decode::decode(&mut &encoded[..]).unwrap());
|
||||
assert_eq!(compact.voter_count(), 4);
|
||||
assert_eq!(compact.edge_count(), 2 + 4);
|
||||
assert_eq!(compact.unique_targets(), vec![10, 11, 20, 40, 50, 51]);
|
||||
@@ -1137,7 +1137,7 @@ mod solution_type {
|
||||
}
|
||||
);
|
||||
|
||||
assert_eq!(compacted.unique_targets(), vec![0, 1, 2, 3, 4, 5, 6, 7, 8],);
|
||||
assert_eq!(compacted.unique_targets(), vec![0, 1, 2, 3, 4, 5, 6, 7, 8]);
|
||||
|
||||
let voter_at = |a: u32| -> Option<AccountId> {
|
||||
voters.get(<u32 as TryInto<usize>>::try_into(a).unwrap()).cloned()
|
||||
@@ -1146,7 +1146,7 @@ mod solution_type {
|
||||
targets.get(<u8 as TryInto<usize>>::try_into(a).unwrap()).cloned()
|
||||
};
|
||||
|
||||
assert_eq!(compacted.into_assignment(voter_at, target_at).unwrap(), assignments,);
|
||||
assert_eq!(compacted.into_assignment(voter_at, target_at).unwrap(), assignments);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
+1
-1
@@ -190,7 +190,7 @@ fn generate_call_to_trait(
|
||||
let crate_ = generate_crate_access();
|
||||
let method_name = create_function_ident_with_version(&method.sig.ident, version);
|
||||
let expect_msg =
|
||||
format!("`{}` called outside of an Externalities-provided environment.", method_name,);
|
||||
format!("`{}` called outside of an Externalities-provided environment.", method_name);
|
||||
let arg_names = get_function_argument_names(&method.sig);
|
||||
|
||||
if takes_self_argument(&method.sig) {
|
||||
|
||||
@@ -116,14 +116,14 @@ pub fn create_exchangeable_host_function_ident(name: &Ident) -> Ident {
|
||||
/// Create the host function identifier for the given function name.
|
||||
pub fn create_host_function_ident(name: &Ident, version: u32, trait_name: &Ident) -> Ident {
|
||||
Ident::new(
|
||||
&format!("ext_{}_{}_version_{}", trait_name.to_string().to_snake_case(), name, version,),
|
||||
&format!("ext_{}_{}_version_{}", trait_name.to_string().to_snake_case(), name, version),
|
||||
Span::call_site(),
|
||||
)
|
||||
}
|
||||
|
||||
/// Create the host function identifier for the given function name.
|
||||
pub fn create_function_ident_with_version(name: &Ident, version: u32) -> Ident {
|
||||
Ident::new(&format!("{}_version_{}", name, version,), Span::call_site())
|
||||
Ident::new(&format!("{}_version_{}", name, version), Span::call_site())
|
||||
}
|
||||
|
||||
/// Returns the function arguments of the given `Signature`, minus any `self` arguments.
|
||||
|
||||
@@ -929,7 +929,7 @@ mod tests {
|
||||
let encoded = error.encode();
|
||||
let decoded = DispatchError::decode(&mut &encoded[..]).unwrap();
|
||||
assert_eq!(encoded, vec![3, 1, 2]);
|
||||
assert_eq!(decoded, DispatchError::Module { index: 1, error: 2, message: None },);
|
||||
assert_eq!(decoded, DispatchError::Module { index: 1, error: 2, message: None });
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -39,7 +39,7 @@ mod ffi {
|
||||
// We need to ensure that sizes of a callable function pointer and host function index is
|
||||
// indeed equal.
|
||||
// We can't use `static_assertions` create because it makes compiler panic, fallback to runtime assert.
|
||||
// const_assert!(mem::size_of::<HostFuncIndex>() == mem::size_of::<HostFuncType<T>>(),);
|
||||
// const_assert!(mem::size_of::<HostFuncIndex>() == mem::size_of::<HostFuncType<T>>());
|
||||
assert!(mem::size_of::<HostFuncIndex>() == mem::size_of::<HostFuncType<T>>());
|
||||
mem::transmute::<HostFuncIndex, HostFuncType<T>>(idx)
|
||||
}
|
||||
|
||||
@@ -1118,7 +1118,7 @@ mod tests {
|
||||
);
|
||||
|
||||
assert_eq!(ext.child_storage(child_info, &[20]), None);
|
||||
assert_eq!(ext.child_storage_hash(child_info, &[20]), None,);
|
||||
assert_eq!(ext.child_storage_hash(child_info, &[20]), None);
|
||||
|
||||
assert_eq!(ext.child_storage(child_info, &[30]), Some(vec![31]));
|
||||
assert_eq!(
|
||||
|
||||
@@ -1062,7 +1062,7 @@ mod tests {
|
||||
TaskExecutor::new(),
|
||||
);
|
||||
|
||||
assert_eq!(state_machine.execute(ExecutionStrategy::NativeWhenPossible).unwrap(), vec![66],);
|
||||
assert_eq!(state_machine.execute(ExecutionStrategy::NativeWhenPossible).unwrap(), vec![66]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -1365,7 +1365,7 @@ mod tests {
|
||||
);
|
||||
|
||||
ext.storage_append(key.clone(), reference_data[0].encode());
|
||||
assert_eq!(ext.storage(key.as_slice()), Some(vec![reference_data[0].clone()].encode()),);
|
||||
assert_eq!(ext.storage(key.as_slice()), Some(vec![reference_data[0].clone()].encode()));
|
||||
}
|
||||
overlay.start_transaction();
|
||||
{
|
||||
@@ -1380,7 +1380,7 @@ mod tests {
|
||||
for i in reference_data.iter().skip(1) {
|
||||
ext.storage_append(key.clone(), i.encode());
|
||||
}
|
||||
assert_eq!(ext.storage(key.as_slice()), Some(reference_data.encode()),);
|
||||
assert_eq!(ext.storage(key.as_slice()), Some(reference_data.encode()));
|
||||
}
|
||||
overlay.rollback_transaction().unwrap();
|
||||
{
|
||||
@@ -1391,7 +1391,7 @@ mod tests {
|
||||
changes_trie::disabled_state::<_, u64>(),
|
||||
None,
|
||||
);
|
||||
assert_eq!(ext.storage(key.as_slice()), Some(vec![reference_data[0].clone()].encode()),);
|
||||
assert_eq!(ext.storage(key.as_slice()), Some(vec![reference_data[0].clone()].encode()));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1434,7 +1434,7 @@ mod tests {
|
||||
None,
|
||||
);
|
||||
|
||||
assert_eq!(ext.storage(key.as_slice()), Some(vec![Item::InitializationItem].encode()),);
|
||||
assert_eq!(ext.storage(key.as_slice()), Some(vec![Item::InitializationItem].encode()));
|
||||
|
||||
ext.storage_append(key.clone(), Item::DiscardedItem.encode());
|
||||
|
||||
@@ -1455,7 +1455,7 @@ mod tests {
|
||||
None,
|
||||
);
|
||||
|
||||
assert_eq!(ext.storage(key.as_slice()), Some(vec![Item::InitializationItem].encode()),);
|
||||
assert_eq!(ext.storage(key.as_slice()), Some(vec![Item::InitializationItem].encode()));
|
||||
|
||||
ext.storage_append(key.clone(), Item::CommitedItem.encode());
|
||||
|
||||
@@ -1536,7 +1536,7 @@ mod tests {
|
||||
local_result1.into_iter().collect::<Vec<_>>(),
|
||||
vec![(b"value3".to_vec(), Some(vec![142]))],
|
||||
);
|
||||
assert_eq!(local_result2.into_iter().collect::<Vec<_>>(), vec![(b"value2".to_vec(), None)],);
|
||||
assert_eq!(local_result2.into_iter().collect::<Vec<_>>(), vec![(b"value2".to_vec(), None)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
Reference in New Issue
Block a user