Skip to content
This repository was archived by the owner on Nov 15, 2023. It is now read-only.

Return target_hash for finality_target instead of an Option #9867

Merged
9 commits merged into from
Sep 29, 2021
Merged

Return target_hash for finality_target instead of an Option #9867

Changes from 1 commit
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
9946d3e
.
liuchengxu Sep 26, 2021
cb8b8df
Fix test
liuchengxu Sep 26, 2021
465e371
Simplify test
liuchengxu Sep 26, 2021
c763e6b
Merge branch 'master' of https://github.com/paritytech/substrate into…
liuchengxu Sep 26, 2021
84bdc82
They are already imported
liuchengxu Sep 27, 2021
65ed953
Needless clone()
liuchengxu Sep 27, 2021
faf73da
Merge branch 'master' of https://github.com/paritytech/substrate into…
liuchengxu Sep 28, 2021
8d6e4e3
Merge branch 'master' of https://github.com/paritytech/substrate into…
liuchengxu Sep 29, 2021
a600490
Merge branch 'not-use-an-option-for-finality_target' of https://githu…
liuchengxu Sep 29, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
Simplify test
  • Loading branch information
@liuchengxu
liuchengxu committed Sep 26, 2021
commit 465e37179dbb4612921864353a13c248e0e90ffd
361 changes: 82 additions & 279 deletions client/service/test/src/client/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -789,298 +789,101 @@ fn best_containing_on_longest_chain_with_multiple_forks() {
assert!(leaves.contains(&d2.hash()));
assert_eq!(leaves.len(), 4);

let finality_target = |target_hash, number| {
block_on(longest_chain_select.finality_target(target_hash, number)).unwrap()
};

// search without restriction
assert_eq!(
a5.hash(),
block_on(longest_chain_select.finality_target(genesis_hash, None)).unwrap()
);
assert_eq!(a5.hash(), block_on(longest_chain_select.finality_target(a1.hash(), None)).unwrap());
assert_eq!(a5.hash(), block_on(longest_chain_select.finality_target(a2.hash(), None)).unwrap());
assert_eq!(a5.hash(), block_on(longest_chain_select.finality_target(a3.hash(), None)).unwrap());
assert_eq!(a5.hash(), block_on(longest_chain_select.finality_target(a4.hash(), None)).unwrap());
assert_eq!(a5.hash(), block_on(longest_chain_select.finality_target(a5.hash(), None)).unwrap());
assert_eq!(b4.hash(), block_on(longest_chain_select.finality_target(b2.hash(), None)).unwrap());
assert_eq!(b4.hash(), block_on(longest_chain_select.finality_target(b3.hash(), None)).unwrap());
assert_eq!(b4.hash(), block_on(longest_chain_select.finality_target(b4.hash(), None)).unwrap());
assert_eq!(c3.hash(), block_on(longest_chain_select.finality_target(c3.hash(), None)).unwrap());
assert_eq!(d2.hash(), block_on(longest_chain_select.finality_target(d2.hash(), None)).unwrap());
assert_eq!(a5.hash(), finality_target(genesis_hash, None));
assert_eq!(a5.hash(), finality_target(a1.hash(), None));
assert_eq!(a5.hash(), finality_target(a2.hash(), None));
assert_eq!(a5.hash(), finality_target(a3.hash(), None));
assert_eq!(a5.hash(), finality_target(a4.hash(), None));
assert_eq!(a5.hash(), finality_target(a5.hash(), None));
assert_eq!(b4.hash(), finality_target(b2.hash(), None));
assert_eq!(b4.hash(), finality_target(b3.hash(), None));
assert_eq!(b4.hash(), finality_target(b4.hash(), None));
assert_eq!(c3.hash(), finality_target(c3.hash(), None));
assert_eq!(d2.hash(), finality_target(d2.hash(), None));

// search only blocks with number <= 5. equivalent to without restriction for this scenario
assert_eq!(
a5.hash(),
block_on(longest_chain_select.finality_target(genesis_hash, Some(5))).unwrap()
);
assert_eq!(
a5.hash(),
block_on(longest_chain_select.finality_target(a1.hash(), Some(5))).unwrap()
);
assert_eq!(
a5.hash(),
block_on(longest_chain_select.finality_target(a2.hash(), Some(5))).unwrap()
);
assert_eq!(
a5.hash(),
block_on(longest_chain_select.finality_target(a3.hash(), Some(5))).unwrap()
);
assert_eq!(
a5.hash(),
block_on(longest_chain_select.finality_target(a4.hash(), Some(5))).unwrap()
);
assert_eq!(
a5.hash(),
block_on(longest_chain_select.finality_target(a5.hash(), Some(5))).unwrap()
);
assert_eq!(
b4.hash(),
block_on(longest_chain_select.finality_target(b2.hash(), Some(5))).unwrap()
);
assert_eq!(
b4.hash(),
block_on(longest_chain_select.finality_target(b3.hash(), Some(5))).unwrap()
);
assert_eq!(
b4.hash(),
block_on(longest_chain_select.finality_target(b4.hash(), Some(5))).unwrap()
);
assert_eq!(
c3.hash(),
block_on(longest_chain_select.finality_target(c3.hash(), Some(5))).unwrap()
);
assert_eq!(
d2.hash(),
block_on(longest_chain_select.finality_target(d2.hash(), Some(5))).unwrap()
);
assert_eq!(a5.hash(), finality_target(genesis_hash, Some(5)));
assert_eq!(a5.hash(), finality_target(a1.hash(), Some(5)));
assert_eq!(a5.hash(), finality_target(a2.hash(), Some(5)));
assert_eq!(a5.hash(), finality_target(a3.hash(), Some(5)));
assert_eq!(a5.hash(), finality_target(a4.hash(), Some(5)));
assert_eq!(a5.hash(), finality_target(a5.hash(), Some(5)));
assert_eq!(b4.hash(), finality_target(b2.hash(), Some(5)));
assert_eq!(b4.hash(), finality_target(b3.hash(), Some(5)));
assert_eq!(b4.hash(), finality_target(b4.hash(), Some(5)));
assert_eq!(c3.hash(), finality_target(c3.hash(), Some(5)));
assert_eq!(d2.hash(), finality_target(d2.hash(), Some(5)));

// search only blocks with number <= 4
assert_eq!(
a4.hash(),
block_on(longest_chain_select.finality_target(genesis_hash, Some(4))).unwrap()
);
assert_eq!(
a4.hash(),
block_on(longest_chain_select.finality_target(a1.hash(), Some(4))).unwrap()
);
assert_eq!(
a4.hash(),
block_on(longest_chain_select.finality_target(a2.hash(), Some(4))).unwrap()
);
assert_eq!(
a4.hash(),
block_on(longest_chain_select.finality_target(a3.hash(), Some(4))).unwrap()
);
assert_eq!(
a4.hash(),
block_on(longest_chain_select.finality_target(a4.hash(), Some(4))).unwrap()
);
assert_eq!(
a5.hash(),
block_on(longest_chain_select.finality_target(a5.hash(), Some(4))).unwrap()
);
assert_eq!(
b4.hash(),
block_on(longest_chain_select.finality_target(b2.hash(), Some(4))).unwrap()
);
assert_eq!(
b4.hash(),
block_on(longest_chain_select.finality_target(b3.hash(), Some(4))).unwrap()
);
assert_eq!(
b4.hash(),
block_on(longest_chain_select.finality_target(b4.hash(), Some(4))).unwrap()
);
assert_eq!(
c3.hash(),
block_on(longest_chain_select.finality_target(c3.hash(), Some(4))).unwrap()
);
assert_eq!(
d2.hash(),
block_on(longest_chain_select.finality_target(d2.hash(), Some(4))).unwrap()
);
assert_eq!(a4.hash(), finality_target(genesis_hash, Some(4)));
assert_eq!(a4.hash(), finality_target(a1.hash(), Some(4)));
assert_eq!(a4.hash(), finality_target(a2.hash(), Some(4)));
assert_eq!(a4.hash(), finality_target(a3.hash(), Some(4)));
assert_eq!(a4.hash(), finality_target(a4.hash(), Some(4)));
assert_eq!(a5.hash(), finality_target(a5.hash(), Some(4)));
assert_eq!(b4.hash(), finality_target(b2.hash(), Some(4)));
assert_eq!(b4.hash(), finality_target(b3.hash(), Some(4)));
assert_eq!(b4.hash(), finality_target(b4.hash(), Some(4)));
assert_eq!(c3.hash(), finality_target(c3.hash(), Some(4)));
assert_eq!(d2.hash(), finality_target(d2.hash(), Some(4)));

// search only blocks with number <= 3
assert_eq!(
a3.hash(),
block_on(longest_chain_select.finality_target(genesis_hash, Some(3))).unwrap()
);
assert_eq!(
a3.hash(),
block_on(longest_chain_select.finality_target(a1.hash(), Some(3))).unwrap()
);
assert_eq!(
a3.hash(),
block_on(longest_chain_select.finality_target(a2.hash(), Some(3))).unwrap()
);
assert_eq!(
a3.hash(),
block_on(longest_chain_select.finality_target(a3.hash(), Some(3))).unwrap()
);
assert_eq!(
a4.hash(),
block_on(longest_chain_select.finality_target(a4.hash(), Some(3))).unwrap()
);
assert_eq!(
a5.hash(),
block_on(longest_chain_select.finality_target(a5.hash(), Some(3))).unwrap()
);
assert_eq!(
b3.hash(),
block_on(longest_chain_select.finality_target(b2.hash(), Some(3))).unwrap()
);
assert_eq!(
b3.hash(),
block_on(longest_chain_select.finality_target(b3.hash(), Some(3))).unwrap()
);
assert_eq!(
b4.hash(),
block_on(longest_chain_select.finality_target(b4.hash(), Some(3))).unwrap()
);
assert_eq!(
c3.hash(),
block_on(longest_chain_select.finality_target(c3.hash(), Some(3))).unwrap()
);
assert_eq!(
d2.hash(),
block_on(longest_chain_select.finality_target(d2.hash(), Some(3))).unwrap()
);
assert_eq!(a3.hash(), finality_target(genesis_hash, Some(3)));
assert_eq!(a3.hash(), finality_target(a1.hash(), Some(3)));
assert_eq!(a3.hash(), finality_target(a2.hash(), Some(3)));
assert_eq!(a3.hash(), finality_target(a3.hash(), Some(3)));
assert_eq!(a4.hash(), finality_target(a4.hash(), Some(3)));
assert_eq!(a5.hash(), finality_target(a5.hash(), Some(3)));
assert_eq!(b3.hash(), finality_target(b2.hash(), Some(3)));
assert_eq!(b3.hash(), finality_target(b3.hash(), Some(3)));
assert_eq!(b4.hash(), finality_target(b4.hash(), Some(3)));
assert_eq!(c3.hash(), finality_target(c3.hash(), Some(3)));
assert_eq!(d2.hash(), finality_target(d2.hash(), Some(3)));

// search only blocks with number <= 2
assert_eq!(
a2.hash(),
block_on(longest_chain_select.finality_target(genesis_hash, Some(2))).unwrap()
);
assert_eq!(
a2.hash(),
block_on(longest_chain_select.finality_target(a1.hash(), Some(2))).unwrap()
);
assert_eq!(
a2.hash(),
block_on(longest_chain_select.finality_target(a2.hash(), Some(2))).unwrap()
);
assert_eq!(
a3.hash(),
block_on(longest_chain_select.finality_target(a3.hash(), Some(2))).unwrap()
);
assert_eq!(
a4.hash(),
block_on(longest_chain_select.finality_target(a4.hash(), Some(2))).unwrap()
);
assert_eq!(
a5.hash(),
block_on(longest_chain_select.finality_target(a5.hash(), Some(2))).unwrap()
);
assert_eq!(
b2.hash(),
block_on(longest_chain_select.finality_target(b2.hash(), Some(2))).unwrap()
);
assert_eq!(
b3.hash(),
block_on(longest_chain_select.finality_target(b3.hash(), Some(2))).unwrap()
);
assert_eq!(
b4.hash(),
block_on(longest_chain_select.finality_target(b4.hash(), Some(2))).unwrap()
);
assert_eq!(
c3.hash(),
block_on(longest_chain_select.finality_target(c3.hash(), Some(2))).unwrap()
);
assert_eq!(
d2.hash(),
block_on(longest_chain_select.finality_target(d2.hash(), Some(2))).unwrap()
);
assert_eq!(a2.hash(), finality_target(genesis_hash, Some(2)));
assert_eq!(a2.hash(), finality_target(a1.hash(), Some(2)));
assert_eq!(a2.hash(), finality_target(a2.hash(), Some(2)));
assert_eq!(a3.hash(), finality_target(a3.hash(), Some(2)));
assert_eq!(a4.hash(), finality_target(a4.hash(), Some(2)));
assert_eq!(a5.hash(), finality_target(a5.hash(), Some(2)));
assert_eq!(b2.hash(), finality_target(b2.hash(), Some(2)));
assert_eq!(b3.hash(), finality_target(b3.hash(), Some(2)));
assert_eq!(b4.hash(), finality_target(b4.hash(), Some(2)));
assert_eq!(c3.hash(), finality_target(c3.hash(), Some(2)));
assert_eq!(d2.hash(), finality_target(d2.hash(), Some(2)));

// search only blocks with number <= 1
assert_eq!(
a1.hash(),
block_on(longest_chain_select.finality_target(genesis_hash, Some(1))).unwrap()
);
assert_eq!(
a1.hash(),
block_on(longest_chain_select.finality_target(a1.hash(), Some(1))).unwrap()
);
assert_eq!(
a2.hash(),
block_on(longest_chain_select.finality_target(a2.hash(), Some(1))).unwrap()
);
assert_eq!(
a3.hash(),
block_on(longest_chain_select.finality_target(a3.hash(), Some(1))).unwrap()
);
assert_eq!(
a4.hash(),
block_on(longest_chain_select.finality_target(a4.hash(), Some(1))).unwrap()
);
assert_eq!(
a5.hash(),
block_on(longest_chain_select.finality_target(a5.hash(), Some(1))).unwrap()
);

assert_eq!(
b2.hash(),
block_on(longest_chain_select.finality_target(b2.hash(), Some(1))).unwrap()
);
assert_eq!(
b3.hash(),
block_on(longest_chain_select.finality_target(b3.hash(), Some(1))).unwrap()
);
assert_eq!(
b4.hash(),
block_on(longest_chain_select.finality_target(b4.hash(), Some(1))).unwrap()
);
assert_eq!(
c3.hash(),
block_on(longest_chain_select.finality_target(c3.hash(), Some(1))).unwrap()
);
assert_eq!(
d2.hash(),
block_on(longest_chain_select.finality_target(d2.hash(), Some(1))).unwrap()
);
assert_eq!(a1.hash(), finality_target(genesis_hash, Some(1)));
assert_eq!(a1.hash(), finality_target(a1.hash(), Some(1)));
assert_eq!(a2.hash(), finality_target(a2.hash(), Some(1)));
assert_eq!(a3.hash(), finality_target(a3.hash(), Some(1)));
assert_eq!(a4.hash(), finality_target(a4.hash(), Some(1)));
assert_eq!(a5.hash(), finality_target(a5.hash(), Some(1)));

assert_eq!(b2.hash(), finality_target(b2.hash(), Some(1)));
assert_eq!(b3.hash(), finality_target(b3.hash(), Some(1)));
assert_eq!(b4.hash(), finality_target(b4.hash(), Some(1)));
assert_eq!(c3.hash(), finality_target(c3.hash(), Some(1)));
assert_eq!(d2.hash(), finality_target(d2.hash(), Some(1)));

// search only blocks with number <= 0
assert_eq!(
genesis_hash,
block_on(longest_chain_select.finality_target(genesis_hash, Some(0))).unwrap()
);
assert_eq!(
a1.hash(),
block_on(longest_chain_select.finality_target(a1.hash(), Some(0))).unwrap()
);
assert_eq!(
a2.hash(),
block_on(longest_chain_select.finality_target(a2.hash(), Some(0))).unwrap()
);
assert_eq!(
a3.hash(),
block_on(longest_chain_select.finality_target(a3.hash(), Some(0))).unwrap()
);
assert_eq!(
a4.hash(),
block_on(longest_chain_select.finality_target(a4.hash(), Some(0))).unwrap()
);
assert_eq!(
a5.hash(),
block_on(longest_chain_select.finality_target(a5.hash(), Some(0))).unwrap()
);
assert_eq!(
b2.hash(),
block_on(longest_chain_select.finality_target(b2.hash(), Some(0))).unwrap()
);
assert_eq!(
b3.hash(),
block_on(longest_chain_select.finality_target(b3.hash(), Some(0))).unwrap()
);
assert_eq!(
b4.hash(),
block_on(longest_chain_select.finality_target(b4.hash(), Some(0))).unwrap()
);
assert_eq!(
c3.hash(),
block_on(longest_chain_select.finality_target(c3.hash().clone(), Some(0))).unwrap(),
);
assert_eq!(
d2.hash(),
block_on(longest_chain_select.finality_target(d2.hash().clone(), Some(0))).unwrap(),
);
assert_eq!(genesis_hash, finality_target(genesis_hash, Some(0)));
assert_eq!(a1.hash(), finality_target(a1.hash(), Some(0)));
assert_eq!(a2.hash(), finality_target(a2.hash(), Some(0)));
assert_eq!(a3.hash(), finality_target(a3.hash(), Some(0)));
assert_eq!(a4.hash(), finality_target(a4.hash(), Some(0)));
assert_eq!(a5.hash(), finality_target(a5.hash(), Some(0)));
assert_eq!(b2.hash(), finality_target(b2.hash(), Some(0)));
assert_eq!(b3.hash(), finality_target(b3.hash(), Some(0)));
assert_eq!(b4.hash(), finality_target(b4.hash(), Some(0)));
assert_eq!(c3.hash(), finality_target(c3.hash().clone(), Some(0)));
assert_eq!(d2.hash(), finality_target(d2.hash().clone(), Some(0)));
}

#[test]
Expand Down