mab122
/
radicle-heartwood-lfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rust/edition: 2021 → 2024 

Switch from Rust 2021 to Rust 2024.

See <https://doc.rust-lang.org/edition-guide/rust-2024/>.

Regarding the added bound `use<>`, see
<https://blog.rust-lang.org/2024/09/05/impl-trait-capture-rules/>.
This commit is contained in:
Lorenz Leutgeb 2026-03-25 08:09:41 +01:00
parent edde15d9ea
commit 0494227e75
No known key found for this signature in database
62 changed files with 392 additions and 379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -3,7 +3,7 @@ members = ["crates/*"]
resolver = "2"
[workspace.package]
edition = "2021"
edition = "2024"
homepage = "https://radicle.xyz"
license = "MIT OR Apache-2.0"
repository = "https://app.radicle.xyz/seeds/seed.radicle.xyz/rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5"

2
crates/radicle-cli/src/main.rs
View File

@ -223,7 +223,7 @@ impl ExternalCommand {
exe
}
fn display_exe(&self) -> impl Display {
fn display_exe(&self) -> impl Display + use<> {
match self.exe().into_string() {
Ok(exe) => exe,
Err(exe) => format!("{exe:?}"),

16
crates/radicle-cob/src/tests.rs
View File

@ -22,7 +22,7 @@ mod git {
#[test]
fn roundtrip() {
let storage = test::Storage::new();
let signer = gen::<MockSigner>(1);
let signer = r#gen::<MockSigner>(1);
let terry = test::Person::new(&storage, "terry", *signer.public_key()).unwrap();
let proj = test::Project::new(&storage, "discworld", *signer.public_key()).unwrap();
let proj = test::RemoteProject {
@ -56,7 +56,7 @@ mod git {
#[test]
fn list_cobs() {
let storage = test::Storage::new();
let signer = gen::<MockSigner>(1);
let signer = r#gen::<MockSigner>(1);
let terry = test::Person::new(&storage, "terry", *signer.public_key()).unwrap();
let proj = test::Project::new(&storage, "discworld", *signer.public_key()).unwrap();
let proj = test::RemoteProject {
@ -108,7 +108,7 @@ mod git {
#[test]
fn update_cob() {
let storage = test::Storage::new();
let signer = gen::<MockSigner>(1);
let signer = r#gen::<MockSigner>(1);
let terry = test::Person::new(&storage, "terry", *signer.public_key()).unwrap();
let proj = test::Project::new(&storage, "discworld", *signer.public_key()).unwrap();
let proj = test::RemoteProject {
@ -163,9 +163,9 @@ mod git {
#[test]
fn traverse_cobs() {
let storage = test::Storage::new();
let neil_signer = gen::<MockSigner>(2);
let neil_signer = r#gen::<MockSigner>(2);
let neil = test::Person::new(&storage, "gaiman", *neil_signer.public_key()).unwrap();
let terry_signer = gen::<MockSigner>(1);
let terry_signer = r#gen::<MockSigner>(1);
let terry = test::Person::new(&storage, "pratchett", *terry_signer.public_key()).unwrap();
let proj = test::Project::new(&storage, "discworld", *terry_signer.public_key()).unwrap();
let terry_proj = test::RemoteProject {
@ -264,10 +264,10 @@ mod git {
Ok(())
}
fn gen<T: Arbitrary>(size: usize) -> T {
let mut gen = qcheck::Gen::new(size);
fn r#gen<T: Arbitrary>(size: usize) -> T {
let mut r#gen = qcheck::Gen::new(size);
T::arbitrary(&mut gen)
T::arbitrary(&mut r#gen)
}
}

4
crates/radicle-crypto/src/ssh/keystore.rs
View File

@ -284,7 +284,7 @@ impl EcSk for MemorySigner {
where
Self: Sized,
{
let ms = Self::gen();
let ms = Self::r#gen();
let pk = ms.public;
(ms, pk)
@ -356,7 +356,7 @@ impl MemorySigner {
}
/// Generate a new memory signer.
pub fn gen() -> Self {
pub fn r#gen() -> Self {
let keypair = KeyPair::generate();
let sk = keypair.sk;

4
crates/radicle-node/src/control.rs
View File

@ -342,8 +342,8 @@ mod tests {
fn test_seed_unseed() {
let tmp = tempfile::tempdir().unwrap();
let socket = tmp.path().join("node.sock");
let proj = test::arbitrary::gen::<RepoId>(1);
let peer = test::arbitrary::gen::<NodeId>(1);
let proj = test::arbitrary::r#gen::<RepoId>(1);
let peer = test::arbitrary::r#gen::<NodeId>(1);
let listener = UnixListener::bind(&socket).unwrap();
let mut handle = Node::new(&socket);

3
crates/radicle-node/src/runtime.rs
View File

@ -318,7 +318,8 @@ impl Runtime {
#[cfg(all(feature = "systemd", target_os = "linux"))]
fn receive_listener() -> Option<UnixListener> {
let fd = match radicle_systemd::listen::fd("control") {
// SAFETY: When `fd` is called, no other threads are spawned (yet).
let fd = match unsafe { radicle_systemd::listen::fd("control") } {
Ok(Some(fd)) => fd,
Ok(None) => return None,
Err(err) => {

4
crates/radicle-node/src/test/gossip.rs
View File

@ -3,7 +3,7 @@ use std::str::FromStr;
use radicle::node;
use radicle::node::device::Device;
use radicle::node::UserAgent;
use radicle::test::fixtures::gen;
use radicle::test::fixtures::r#gen;
use crate::test::arbitrary;
use crate::{
@ -35,7 +35,7 @@ pub fn messages(count: usize, now: LocalTime, delta: LocalDuration) -> Vec<Messa
version: PROTOCOL_VERSION,
features: node::Features::SEED,
timestamp: time.into(),
alias: node::Alias::new(gen::string(5)),
alias: node::Alias::new(r#gen::string(5)),
addresses: None.into(),
nonce: 0,
agent: UserAgent::from_str("/radicle:test/").unwrap(),

2
crates/radicle-node/src/test/peer.rs
View File

@ -434,7 +434,7 @@ where
}
/// Drain outgoing messages sent from this peer to the remote peer.
pub fn messages(&mut self, remote: NodeId) -> impl Iterator<Item = Message> {
pub fn messages(&mut self, remote: NodeId) -> impl Iterator<Item = Message> + use<S, G> {
let mut msgs = Vec::new();
Service::outbox(&mut self.service)

2
crates/radicle-node/src/test/simulator.rs
View File

@ -666,7 +666,7 @@ where
canonical: fetch::UpdatedCanonicalRefs::default(),
namespaces: HashSet::new(),
clone: true,
doc: arbitrary::gen(1),
doc: arbitrary::r#gen(1),
})),
),
},

32
crates/radicle-node/src/tests.rs
View File

@ -22,7 +22,7 @@ use radicle::node::Link;
use radicle::node::{ConnectOptions, DEFAULT_TIMEOUT};
use radicle::storage::refs::RefsAt;
use radicle::storage::RefUpdate;
use radicle::test::arbitrary::gen;
use radicle::test::arbitrary::r#gen;
use radicle::test::storage::MockRepository;
use radicle_protocol::bounded::BoundedVec;
@ -78,7 +78,7 @@ pub static TEST_CASES: LazyLock<usize> = LazyLock::new(|| {
#[test]
fn test_inventory_decode() {
let inventory: Vec<RepoId> = arbitrary::gen(300);
let inventory: Vec<RepoId> = arbitrary::r#gen(300);
let timestamp: Timestamp = LocalTime::now().into();
let mut buf = Vec::new();
@ -414,7 +414,7 @@ fn test_inventory_pruning() {
#[test]
fn test_seeding() {
let mut alice = Peer::new("alice", [7, 7, 7, 7]);
let proj_id: identity::RepoId = test::arbitrary::gen(1);
let proj_id: identity::RepoId = test::arbitrary::r#gen(1);
let (cmd, receiver) = Command::seed(proj_id, policy::Scope::default());
alice.command(cmd);
@ -722,7 +722,7 @@ fn test_refs_announcement_relay_public() {
.elapse(service::GOSSIP_INTERVAL);
// Pretend Alice cloned Bob's repos.
let repos = gen::<[MockRepository; 3]>(1);
let repos = r#gen::<[MockRepository; 3]>(1);
for (i, mut repo) in repos.into_iter().enumerate() {
repo.doc.doc = repo
.doc
@ -803,7 +803,7 @@ fn test_refs_announcement_relay_private() {
// The first repo is not visible to Eve.
let repo1 = {
let mut repo = gen::<MockRepository>(1);
let mut repo = r#gen::<MockRepository>(1);
repo.doc.doc = repo
.doc
.doc
@ -817,7 +817,7 @@ fn test_refs_announcement_relay_private() {
// The second repo is visible to Eve.
let repo2 = {
let mut repo = gen::<MockRepository>(1);
let mut repo = r#gen::<MockRepository>(1);
repo.doc.doc = repo
.doc
.doc
@ -960,7 +960,7 @@ fn test_refs_announcement_no_subscribe() {
let mut alice = Peer::with_storage("alice", [7, 7, 7, 7], storage);
let bob = Peer::new("bob", [8, 8, 8, 8]);
let eve = Peer::new("eve", [9, 9, 9, 9]);
let id = arbitrary::gen(1);
let id = arbitrary::r#gen(1);
alice.seed(&id, policy::Scope::All).unwrap();
alice.connect_to(&bob);
@ -1406,7 +1406,7 @@ fn test_maintain_connections_failed_attempt() {
fn test_seed_repo_subscribe() {
let mut alice = Peer::new("alice", [7, 7, 7, 7]);
let bob = Peer::new("bob", [8, 8, 8, 8]);
let rid = arbitrary::gen::<RepoId>(1);
let rid = arbitrary::r#gen::<RepoId>(1);
alice.connect_to(&bob);
let (cmd, recv) = Command::seed(rid, policy::Scope::default());
@ -1425,7 +1425,7 @@ fn test_seed_repo_subscribe() {
#[test]
fn test_fetch_missing_inventory_on_gossip() {
let rid = arbitrary::gen::<RepoId>(1);
let rid = arbitrary::r#gen::<RepoId>(1);
let mut alice = Peer::new("alice", [7, 7, 7, 7]);
let bob = Peer::new("bob", [8, 8, 8, 8]);
let now = LocalTime::now();
@ -1450,7 +1450,7 @@ fn test_fetch_missing_inventory_on_gossip() {
#[test]
fn test_fetch_missing_inventory_on_schedule() {
let rid = arbitrary::gen::<RepoId>(1);
let rid = arbitrary::r#gen::<RepoId>(1);
let mut alice = Peer::new("alice", [7, 7, 7, 7]);
let bob = Peer::new("bob", [8, 8, 8, 8]);
let now = LocalTime::now();
@ -1596,7 +1596,7 @@ fn test_queued_fetch_from_ann_same_rid() {
canonical: fetch::UpdatedCanonicalRefs::default(),
namespaces: [carol.id()].into_iter().collect(),
clone: false,
doc: arbitrary::gen(1),
doc: arbitrary::r#gen(1),
}),
);
// Now the 1st fetch is done, but the 2nd and 3rd fetches are redundant.
@ -1646,7 +1646,7 @@ fn test_queued_fetch_from_command_same_rid() {
alice.elapse(KEEP_ALIVE_DELTA);
// Finish the 1st fetch.
alice.fetched(rid1, nid, Ok(arbitrary::gen::<fetch::FetchResult>(1)));
alice.fetched(rid1, nid, Ok(arbitrary::r#gen::<fetch::FetchResult>(1)));
// Now the 1st fetch is done, the 2nd fetch is dequeued.
let (rid, nid) = alice.fetches().next().unwrap();
assert_eq!(rid, rid1);
@ -1656,7 +1656,7 @@ fn test_queued_fetch_from_command_same_rid() {
assert_matches!(alice.fetches().next(), None);
// Finish the 2nd fetch.
alice.fetched(rid1, nid, Ok(arbitrary::gen::<fetch::FetchResult>(1)));
alice.fetched(rid1, nid, Ok(arbitrary::r#gen::<fetch::FetchResult>(1)));
// Now the 2nd fetch is done, the 3rd fetch is dequeued.
assert_matches!(alice.fetches().next(), Some((rid, nid)) if rid == rid1 && peers.remove(&nid));
// All fetches were initiated.
@ -1909,7 +1909,7 @@ fn prop_inventory_exchange_dense() {
}
}
qcheck::QuickCheck::new()
.gen(qcheck::Gen::new(5))
.r#gen(qcheck::Gen::new(5))
.tests(20)
.quickcheck(property as fn(MockStorage, MockStorage, MockStorage));
}
@ -1933,7 +1933,7 @@ fn test_announcement_message_amplification() {
failure_rate: 0.,
},
);
let rid = gen::<RepoId>(1);
let rid = r#gen::<RepoId>(1);
// Make sure the node gossip intervals are not accidentally synchronized.
alice.elapse(LocalDuration::from_millis(
@ -2030,7 +2030,7 @@ fn test_announcement_message_amplification() {
alice
.storage_mut()
.repos
.insert(rid, gen::<MockRepository>(1));
.insert(rid, r#gen::<MockRepository>(1));
let (cmd, _) = Command::add_inventory(rid);
alice.command(cmd);

6
crates/radicle-node/src/wire.rs
View File

@ -1297,9 +1297,9 @@ mod test {
}
}
let rid = radicle::test::arbitrary::gen(1);
let pk = radicle::test::arbitrary::gen(1);
let sig: [u8; 64] = radicle::test::arbitrary::gen(1);
let rid = radicle::test::arbitrary::r#gen(1);
let pk = radicle::test::arbitrary::r#gen(1);
let sig: [u8; 64] = radicle::test::arbitrary::r#gen(1);
// Message with extension.
let mut stream = Vec::new();

2
crates/radicle-node/src/worker/upload_pack.rs
View File

@ -39,7 +39,7 @@ where
.extra
.iter()
.find_map(|kv| match kv {
(ref k, Some(v)) if k == "version" => {
(k, Some(v)) if k == "version" => {
let version = match v.as_str() {
"2" => 2,
"1" => 1,

4
crates/radicle-oid/src/lib.rs
View File

@ -108,7 +108,7 @@ impl Oid {
/// See also [`::git2::Oid::is_zero`].
pub fn is_zero(&self) -> bool {
match self {
Oid::Sha1(ref array) => array.iter().all(|b| *b == 0),
Oid::Sha1(array) => array.iter().all(|b| *b == 0),
}
}
}
@ -116,7 +116,7 @@ impl Oid {
impl AsRef<[u8]> for Oid {
fn as_ref(&self) -> &[u8] {
match self {
Oid::Sha1(ref array) => array,
Oid::Sha1(array) => array,
}
}
}

4
crates/radicle-protocol/src/bounded.rs
View File

@ -268,9 +268,11 @@ unsafe impl<const N: usize> bytes::BufMut for BoundedVec<u8, N> {
debug_assert!(len <= N);
// Addition will not overflow since the sum is at most the capacity.
// SAFETY: See bounds check above.
unsafe {
self.v.set_len(len);
}
}
fn chunk_mut(&mut self) -> &mut bytes::buf::UninitSlice {
let len = self.v.len();

2
crates/radicle-protocol/src/deserializer.rs
View File

@ -85,8 +85,10 @@ unsafe impl<const B: usize, D: wire::Decode> bytes::BufMut for Deserializer<B, D
}
unsafe fn advance_mut(&mut self, cnt: usize) {
unsafe {
self.unparsed.advance_mut(cnt);
}
}
fn chunk_mut(&mut self) -> &mut bytes::buf::UninitSlice {
self.unparsed.chunk_mut()

4
crates/radicle-protocol/src/fetcher/service.rs
View File

@ -176,8 +176,8 @@ mod tests {
.with_max_concurrency(NonZeroUsize::new(1).unwrap())
.with_max_capacity(MaxQueueSize::new(NonZeroUsize::new(10).unwrap()));
let mut service = FetcherService::<usize>::new(config);
let node = arbitrary::gen(1);
let repo = arbitrary::gen(1);
let node = arbitrary::r#gen(1);
let repo = arbitrary::r#gen(1);
let refs_specific: Vec<RefsAt> = arbitrary::vec(2);
let refs_all = vec![];
let config = FetchConfig::default();

2
crates/radicle-protocol/src/fetcher/test/queue/helpers.rs
View File

@ -12,7 +12,7 @@ pub fn create_queue(capacity: usize) -> Queue {
pub fn create_fetch() -> QueuedFetch {
QueuedFetch {
rid: arbitrary::gen(1),
rid: arbitrary::r#gen(1),
refs: RefsToFetch::All,
config: FetchConfig::default(),
}

28
crates/radicle-protocol/src/fetcher/test/queue/properties/merge.rs
View File

@ -32,7 +32,7 @@ fn same_rid_merges_anywhere_in_queue(max_size: MaxQueueSize, merge_index: usize)
let target_index = merge_index % items.len();
let same_rid_item = QueuedFetch {
rid: items[target_index].rid,
refs: vec![arbitrary::gen(1)].into(),
refs: vec![arbitrary::r#gen(1)].into(),
config: FetchConfig::default(),
};
@ -47,9 +47,9 @@ fn combines_refs(base_refs_count: u8, merge_refs_count: u8) -> bool {
let mut queue = create_queue(10);
let config = FetchConfig::default();
let rid: RepoId = arbitrary::gen(1);
let base_refs: Vec<RefsAt> = (0..base_refs_count).map(|_| arbitrary::gen(1)).collect();
let merge_refs: Vec<RefsAt> = (0..merge_refs_count).map(|_| arbitrary::gen(1)).collect();
let rid: RepoId = arbitrary::r#gen(1);
let base_refs: Vec<RefsAt> = (0..base_refs_count).map(|_| arbitrary::r#gen(1)).collect();
let merge_refs: Vec<RefsAt> = (0..merge_refs_count).map(|_| arbitrary::r#gen(1)).collect();
let base_item = QueuedFetch {
rid,
@ -84,13 +84,13 @@ fn combines_refs(base_refs_count: u8, merge_refs_count: u8) -> bool {
#[quickcheck]
fn empty_refs_fetches_all() -> bool {
let mut queue = create_queue(10);
let rid: RepoId = arbitrary::gen(1);
let rid: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
// First enqueue with specific refs
let item_with_refs = QueuedFetch {
rid,
refs: vec![arbitrary::gen(1), arbitrary::gen(1)].into(),
refs: vec![arbitrary::r#gen(1), arbitrary::r#gen(1)].into(),
config,
};
@ -114,7 +114,7 @@ fn longer_timeout_preserved(short_secs: u16, long_secs: u16) -> bool {
let long = Duration::from_secs(short_secs.max(long_secs) as u64);
let config = FetchConfig::default();
let mut queue = create_queue(10);
let rid: RepoId = arbitrary::gen(1);
let rid: RepoId = arbitrary::r#gen(1);
let item_short = QueuedFetch {
rid,
@ -144,18 +144,18 @@ fn longer_timeout_preserved(short_secs: u16, long_secs: u16) -> bool {
#[quickcheck]
fn does_not_increase_queue_length() -> bool {
let mut queue = create_queue(10);
let rid: RepoId = arbitrary::gen(1);
let rid: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
let item1 = QueuedFetch {
rid,
refs: vec![arbitrary::gen(1)].into(),
refs: vec![arbitrary::r#gen(1)].into(),
config: config.with_timeout(Duration::from_secs(30)),
};
let item2 = QueuedFetch {
rid,
refs: vec![arbitrary::gen(1)].into(),
refs: vec![arbitrary::r#gen(1)].into(),
config: config.with_timeout(Duration::from_secs(60)),
};
@ -175,7 +175,7 @@ fn different_rid_accepted(base_item: QueuedFetch) -> bool {
// Item with different rid should be queued (not merged)
let different_rid = QueuedFetch {
rid: arbitrary::gen(1),
rid: arbitrary::r#gen(1),
..base_item
};
@ -186,7 +186,7 @@ fn different_rid_accepted(base_item: QueuedFetch) -> bool {
fn succeed_when_at_capacity() -> bool {
// When queue is at capacity, merging with existing item should still work
let mut queue = create_queue(2);
let rid: RepoId = arbitrary::gen(1);
let rid: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
let item1 = QueuedFetch {
@ -196,14 +196,14 @@ fn succeed_when_at_capacity() -> bool {
};
let item2 = QueuedFetch {
rid: arbitrary::gen(1), // Different rid
rid: arbitrary::r#gen(1), // Different rid
refs: RefsToFetch::All,
config: config.with_timeout(Duration::from_secs(30)),
};
let merge_item = QueuedFetch {
rid, // Same as item1
refs: vec![arbitrary::gen(1)].into(),
refs: vec![arbitrary::r#gen(1)].into(),
config: config.with_timeout(Duration::from_secs(60)),
};

14
crates/radicle-protocol/src/fetcher/test/queue/unit.rs
View File

@ -14,7 +14,7 @@ fn zero_timeout_accepted() {
let mut queue = create_queue(10);
let config = FetchConfig::default().with_timeout(Duration::ZERO);
let item = QueuedFetch {
rid: arbitrary::gen(1),
rid: arbitrary::r#gen(1),
refs: RefsToFetch::All,
config,
};
@ -26,7 +26,7 @@ fn max_timeout_accepted() {
let mut queue = create_queue(10);
let config = FetchConfig::default().with_timeout(Duration::MAX);
let item = QueuedFetch {
rid: arbitrary::gen(1),
rid: arbitrary::r#gen(1),
refs: RefsToFetch::All,
config,
};
@ -35,7 +35,7 @@ fn max_timeout_accepted() {
#[test]
fn empty_refs_items_can_be_equal() {
let rid: RepoId = arbitrary::gen(1);
let rid: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
let item1 = QueuedFetch {
@ -56,9 +56,9 @@ fn empty_refs_items_can_be_equal() {
fn merge_preserves_position_in_queue() {
let mut queue = create_queue(10);
let rid_first: RepoId = arbitrary::gen(1);
let rid_second: RepoId = arbitrary::gen(2);
let rid_third: RepoId = arbitrary::gen(3);
let rid_first: RepoId = arbitrary::r#gen(1);
let rid_second: RepoId = arbitrary::r#gen(2);
let rid_third: RepoId = arbitrary::r#gen(3);
let config = FetchConfig::default();
// Enqueue three items
@ -81,7 +81,7 @@ fn merge_preserves_position_in_queue() {
// Merge into the second item
let result = queue.enqueue(QueuedFetch {
rid: rid_second,
refs: vec![arbitrary::gen(1)].into(),
refs: vec![arbitrary::r#gen(1)].into(),
config: config.with_timeout(Duration::from_secs(60)),
});
assert_eq!(result, Enqueue::Merged);

22
crates/radicle-protocol/src/fetcher/test/state/command/cancel.rs
View File

@ -8,8 +8,8 @@ use crate::fetcher::{ActiveFetch, FetchConfig, FetcherState};
#[test]
fn single_ongoing() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let refs_1 = helpers::gen_refs(1);
let config = FetchConfig::default();
@ -47,10 +47,10 @@ fn single_ongoing() {
#[test]
fn ongoing_and_queued() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let repo_3: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let repo_3: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
state.fetch(command::Fetch {
@ -91,7 +91,7 @@ fn ongoing_and_queued() {
#[test]
fn non_existent_returns_unexpected() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_unknown: NodeId = arbitrary::gen(1);
let node_unknown: NodeId = arbitrary::r#gen(1);
let event = state.cancel(command::Cancel { from: node_unknown });
@ -101,10 +101,10 @@ fn non_existent_returns_unexpected() {
#[test]
fn cancellation_is_isolated() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let node_b: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let node_b: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
state.fetch(command::Fetch {

62
crates/radicle-protocol/src/fetcher/test/state/command/fetch.rs
View File

@ -11,8 +11,8 @@ use crate::fetcher::{FetchConfig, RefsToFetch};
#[test]
fn fetch_start_first_fetch_for_node() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let refs_1 = helpers::gen_refs(2);
let config = FetchConfig::default();
@ -44,9 +44,9 @@ fn fetch_start_first_fetch_for_node() {
#[test]
fn fetch_different_repo_same_node_within_capacity() {
let mut state = FetcherState::new(helpers::config(2, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
let event1 = state.fetch(command::Fetch {
@ -72,9 +72,9 @@ fn fetch_different_repo_same_node_within_capacity() {
#[test]
fn fetch_same_repo_different_nodes_queues_second() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let node_b: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let node_b: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let refs_1 = helpers::gen_refs(1);
let config = FetchConfig::default();
@ -106,8 +106,8 @@ fn fetch_same_repo_different_nodes_queues_second() {
#[test]
fn fetch_duplicate_returns_already_fetching() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let refs_1 = helpers::gen_refs(2);
let config = FetchConfig::default();
@ -137,8 +137,8 @@ fn fetch_duplicate_returns_already_fetching() {
#[test]
fn fetch_same_repo_different_refs_enqueues() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let refs_1 = helpers::gen_refs(1);
let refs_2 = helpers::gen_refs(2);
let config = FetchConfig::default();
@ -169,9 +169,9 @@ fn fetch_same_repo_different_refs_enqueues() {
#[test]
fn fetch_at_capacity_enqueues() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
state.fetch(command::Fetch {
@ -202,11 +202,11 @@ fn fetch_at_capacity_enqueues() {
#[test]
fn fetch_queue_rejected_capacity_reached() {
let mut state = FetcherState::new(helpers::config(1, 2));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let repo_3: RepoId = arbitrary::gen(1);
let repo_4: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let repo_3: RepoId = arbitrary::r#gen(1);
let repo_4: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
// Fill concurrency
@ -255,9 +255,9 @@ fn fetch_queue_rejected_capacity_reached() {
#[test]
fn fetch_queue_merges_already_queued() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let refs_2a = helpers::gen_refs(1);
let refs_2b = helpers::gen_refs(1);
let config = FetchConfig::default();
@ -315,9 +315,9 @@ fn fetch_queue_merges_already_queued() {
#[test]
fn fetch_queue_merge_empty_refs_fetches_all() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let refs_2 = helpers::gen_refs(2);
let config = FetchConfig::default();
@ -357,9 +357,9 @@ fn fetch_queue_merge_empty_refs_fetches_all() {
#[test]
fn fetch_queue_merge_takes_longer_timeout() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let short_timeout = Duration::from_secs(10);
let long_timeout = Duration::from_secs(60);
let config = FetchConfig::default();
@ -399,8 +399,8 @@ fn fetch_queue_merge_takes_longer_timeout() {
#[test]
fn fetch_after_previous_completed() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let refs_1 = helpers::gen_refs(1);
let config = FetchConfig::default();

24
crates/radicle-protocol/src/fetcher/test/state/command/fetched.rs
View File

@ -8,8 +8,8 @@ use crate::fetcher::{FetchConfig, FetcherState};
#[test]
fn complete_single_ongoing() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let refs_1 = helpers::gen_refs(2);
let config = FetchConfig::default();
@ -39,10 +39,10 @@ fn complete_single_ongoing() {
#[test]
fn complete_then_dequeue_fifo() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let repo_3: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let repo_3: RepoId = arbitrary::r#gen(1);
let refs_2 = helpers::gen_refs(1);
let config = FetchConfig::default();
@ -85,10 +85,10 @@ fn complete_then_dequeue_fifo() {
#[test]
fn complete_one_of_multiple() {
let mut state = FetcherState::new(helpers::config(3, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let repo_3: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let repo_3: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
state.fetch(command::Fetch {
@ -124,8 +124,8 @@ fn complete_one_of_multiple() {
#[test]
fn non_existent_returns_not_found() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let event = state.fetched(command::Fetched {
from: node_a,

16
crates/radicle-protocol/src/fetcher/test/state/concurrent.rs
View File

@ -8,11 +8,11 @@ use crate::fetcher::{FetchConfig, FetcherState};
#[test]
fn interleaved_operations() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let node_b: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let repo_3: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let node_b: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let repo_3: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
// fetch(A, r1)
@ -65,9 +65,9 @@ fn interleaved_operations() {
#[test]
fn fetched_then_cancel() {
let mut state = FetcherState::new(helpers::config(2, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
state.fetch(command::Fetch {

12
crates/radicle-protocol/src/fetcher/test/state/config.rs
View File

@ -8,11 +8,11 @@ use crate::fetcher::{FetchConfig, FetcherState};
#[test]
fn high_concurrency() {
let mut state = FetcherState::new(helpers::config(100, 10));
let node_a: NodeId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let config = FetchConfig::default();
for i in 0..100 {
let repo: RepoId = arbitrary::gen(i + 1);
let repo: RepoId = arbitrary::r#gen(i + 1);
let event = state.fetch(command::Fetch {
from: node_a,
rid: repo,
@ -39,10 +39,10 @@ fn high_concurrency() {
#[test]
fn min_queue_size() {
let mut state = FetcherState::new(helpers::config(1, 1));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let repo_3: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let repo_3: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
state.fetch(command::Fetch {

18
crates/radicle-protocol/src/fetcher/test/state/dequeue.rs
View File

@ -10,9 +10,9 @@ use crate::fetcher::{FetchConfig, FetcherState};
#[test]
fn cannot_dequeue_while_node_at_capacity() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let refs_2 = helpers::gen_refs(3);
let timeout_2 = Duration::from_secs(42);
@ -48,11 +48,11 @@ fn cannot_dequeue_while_node_at_capacity() {
#[test]
fn maintains_fifo_order() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let repo_3: RepoId = arbitrary::gen(1);
let repo_4: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let repo_3: RepoId = arbitrary::r#gen(1);
let repo_4: RepoId = arbitrary::r#gen(1);
let config = FetchConfig::default();
state.fetch(command::Fetch {
@ -105,7 +105,7 @@ fn maintains_fifo_order() {
#[test]
fn empty_queue_returns_none() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
assert!(state.dequeue(&node_a).is_none());
}

2
crates/radicle-protocol/src/fetcher/test/state/helpers.rs
View File

@ -13,6 +13,6 @@ pub fn config(max_concurrency: usize, max_queue_size: usize) -> Config {
}
pub fn gen_refs(count: usize) -> RefsToFetch {
let refs: Vec<_> = (0..count).map(|_| arbitrary::gen(1)).collect();
let refs: Vec<_> = (0..count).map(|_| arbitrary::r#gen(1)).collect();
refs.into()
}

6
crates/radicle-protocol/src/fetcher/test/state/invariant.rs
View File

@ -8,9 +8,9 @@ use crate::fetcher::{FetchConfig, FetcherState};
#[test]
fn queue_integrity_after_merge() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let repo_1: RepoId = arbitrary::gen(1);
let repo_2: RepoId = arbitrary::gen(1);
let node_a: NodeId = arbitrary::r#gen(1);
let repo_1: RepoId = arbitrary::r#gen(1);
let repo_2: RepoId = arbitrary::r#gen(1);
let refs_2a = helpers::gen_refs(1);
let refs_2b = helpers::gen_refs(1);
let config = FetchConfig::default();

16
crates/radicle-protocol/src/fetcher/test/state/multinode.rs
View File

@ -8,12 +8,12 @@ use crate::fetcher::{FetchConfig, FetcherState};
#[test]
fn independent_queues() {
let mut state = FetcherState::new(helpers::config(1, 10));
let node_a: NodeId = arbitrary::gen(1);
let node_b: NodeId = arbitrary::gen(1);
let repo_a_active: RepoId = arbitrary::gen(1);
let repo_b_active: RepoId = arbitrary::gen(2);
let repo_a_queued: RepoId = arbitrary::gen(10);
let repo_b_queued: RepoId = arbitrary::gen(20);
let node_a: NodeId = arbitrary::r#gen(1);
let node_b: NodeId = arbitrary::r#gen(1);
let repo_a_active: RepoId = arbitrary::r#gen(1);
let repo_b_active: RepoId = arbitrary::r#gen(2);
let repo_a_queued: RepoId = arbitrary::r#gen(10);
let repo_b_queued: RepoId = arbitrary::r#gen(20);
let fetch_config = FetchConfig::default();
// Fill capacity for both nodes
@ -66,8 +66,8 @@ fn high_count() {
let config = FetchConfig::default();
for i in 0..100 {
let node: NodeId = arbitrary::gen(i + 1);
let repo: RepoId = arbitrary::gen(i + 1);
let node: NodeId = arbitrary::r#gen(i + 1);
let repo: RepoId = arbitrary::r#gen(i + 1);
let event = state.fetch(command::Fetch {
from: node,
rid: repo,

4
crates/radicle-protocol/src/service/gossip/store.rs
View File

@ -389,8 +389,8 @@ mod test {
#[test]
fn test_announced() {
let mut db = Database::memory().unwrap();
let nid = arbitrary::gen::<NodeId>(1);
let rid = arbitrary::gen::<RepoId>(1);
let nid = arbitrary::r#gen::<NodeId>(1);
let rid = arbitrary::r#gen::<RepoId>(1);
let timestamp = LocalTime::now().into();
let signer = Device::mock();
let refs = AnnouncementMessage::Refs(RefsAnnouncement {

6
crates/radicle-protocol/src/service/limiter.rs
View File

@ -159,7 +159,7 @@ mod test {
let mut r = RateLimiter::default();
let t = (3, 0.2); // Three tokens burst. One token every 5 seconds.
let a = HostName::Dns(String::from("seed.radicle.example.com"));
let n = arbitrary::gen::<NodeId>(1);
let n = arbitrary::r#gen::<NodeId>(1);
let n = Some(&n);
assert_eq!(r.limit(a.clone(), n, &t, LocalTime::from_secs(0)), false); // Burst capacity
@ -189,7 +189,7 @@ mod test {
#[rustfmt::skip]
fn test_limiter_multi() {
let t = (1, 1.0); // One token per second. One token burst.
let n = arbitrary::gen::<NodeId>(1);
let n = arbitrary::r#gen::<NodeId>(1);
let n = Some(&n);
let mut r = RateLimiter::default();
let addr1 = HostName::Dns(String::from("seed.radicle.example.com"));
@ -210,7 +210,7 @@ mod test {
fn test_limiter_different_rates() {
let t1 = (1, 1.0); // One token per second. One token burst.
let t2 = (2, 2.0); // Two tokens per second. Two token burst.
let n = arbitrary::gen::<NodeId>(1);
let n = arbitrary::r#gen::<NodeId>(1);
let n = Some(&n);
let mut r = RateLimiter::default();
let addr1 = HostName::Dns(String::from("seed.radicle.example.com"));

4
crates/radicle-protocol/src/service/message.rs
View File

@ -92,7 +92,7 @@ impl NodeAnnouncement {
.expect("proof-of-work output vector is a valid length");
// Calculate the number of leading zero bits in the output vector.
if let Some((zero_bytes, non_zero)) = output.iter().enumerate().find(|(_, &x)| x != 0) {
if let Some((zero_bytes, non_zero)) = output.iter().enumerate().find(|&(_, &x)| x != 0) {
zero_bytes as u32 * 8 + non_zero.leading_zeros()
} else {
output.len() as u32 * 8
@ -703,7 +703,7 @@ mod tests {
}
let msg: Message = AnnouncementMessage::from(RefsAnnouncement {
rid: arbitrary::gen(1),
rid: arbitrary::r#gen(1),
refs,
timestamp: LocalTime::now().into(),
})

16
crates/radicle-protocol/src/wire/message.rs
View File

@ -443,11 +443,11 @@ mod tests {
#[test]
fn test_refs_ann_max_size() {
let signer = Device::mock();
let refs: [RefsAt; REF_REMOTE_LIMIT] = arbitrary::gen(1);
let refs: [RefsAt; REF_REMOTE_LIMIT] = arbitrary::r#gen(1);
let ann = AnnouncementMessage::Refs(RefsAnnouncement {
rid: arbitrary::gen(1),
rid: arbitrary::r#gen(1),
refs: BoundedVec::collect_from(&mut refs.into_iter()),
timestamp: arbitrary::gen(1),
timestamp: arbitrary::r#gen(1),
});
let ann = ann.signed(&signer);
let msg = Message::Announcement(ann);
@ -459,10 +459,10 @@ mod tests {
#[test]
fn test_inv_ann_max_size() {
let signer = Device::mock();
let inv: [RepoId; INVENTORY_LIMIT] = arbitrary::gen(1);
let inv: [RepoId; INVENTORY_LIMIT] = arbitrary::r#gen(1);
let ann = AnnouncementMessage::Inventory(InventoryAnnouncement {
inventory: BoundedVec::collect_from(&mut inv.into_iter()),
timestamp: arbitrary::gen(1),
timestamp: arbitrary::r#gen(1),
});
let ann = ann.signed(&signer);
let msg = Message::Announcement(ann);
@ -474,14 +474,14 @@ mod tests {
#[test]
fn test_node_ann_max_size() {
let signer = Device::mock();
let addrs: [Address; ADDRESS_LIMIT] = arbitrary::gen(1);
let addrs: [Address; ADDRESS_LIMIT] = arbitrary::r#gen(1);
let alias = ['@'; radicle::node::MAX_ALIAS_LENGTH];
let ann = AnnouncementMessage::Node(NodeAnnouncement {
version: 1,
features: Default::default(),
alias: radicle::node::Alias::new(String::from_iter(alias)),
addresses: BoundedVec::collect_from(&mut addrs.into_iter()),
timestamp: arbitrary::gen(1),
timestamp: arbitrary::r#gen(1),
nonce: u64::MAX,
agent: UserAgent::default(),
});
@ -539,7 +539,7 @@ mod tests {
}
qcheck::QuickCheck::new()
.gen(qcheck::Gen::new(16))
.r#gen(qcheck::Gen::new(16))
.quickcheck(property as fn(items: Vec<Message>));
}

20
crates/radicle-systemd/src/listen.rs
View File

@ -20,20 +20,28 @@ const SD_LISTEN_FDS_START: RawFd = 3;
/// - <https://github.com/systemd/systemd/blob/v254/src/libsystemd/sd-daemon/sd-daemon.c>
/// - <https://0pointer.de/blog/projects/socket-activation.html>
/// - <https://0pointer.de/blog/projects/socket-activation2.html>
pub fn fd(name: &str) -> Result<Option<RawFd>, VarError> {
let fd = match var(LISTEN_PID) {
///
/// # Safety
///
/// This function calls [`remove_var`] to remove the environment variables
/// it interpreted in case it returns `Ok(Some(_))`. In this case, this
/// function inherits the unsafe behavior of [`remove_var`].
pub unsafe fn fd(name: &str) -> Result<Option<RawFd>, VarError> {
match var(LISTEN_PID) {
Err(VarError::NotPresent) => Ok(None),
Err(err) => Err(err),
Ok(pid) if pid != id().to_string() => Ok(None),
_ if var(LISTEN_FDS)? != "1" || var(LISTEN_FDNAMES).ok() != Some(name.to_string()) => {
Ok(None)
}
_ => Ok(Some(SD_LISTEN_FDS_START)),
};
_ => {
unsafe {
remove_var(LISTEN_PID);
remove_var(LISTEN_FDS);
remove_var(LISTEN_FDNAMES);
}
fd
Ok(Some(SD_LISTEN_FDS_START))
}
}
}

6
crates/radicle-term/src/io.rs
View File

@ -70,7 +70,7 @@ impl PaintTarget {
#[macro_export]
macro_rules! info {
($writer:expr; $($arg:tt)*) => ({
($writer:expr_2021; $($arg:tt)*) => ({
writeln!($writer, $($arg)*).ok();
});
($($arg:tt)*) => ({
@ -81,7 +81,7 @@ macro_rules! info {
#[macro_export]
macro_rules! success {
// Pattern when a writer is provided.
($writer:expr; $($arg:tt)*) => ({
($writer:expr_2021; $($arg:tt)*) => ({
$crate::io::success_args($writer, format_args!($($arg)*));
});
// Pattern without writer.
@ -100,7 +100,7 @@ macro_rules! tip {
#[macro_export]
macro_rules! notice {
// Pattern when a writer is provided.
($writer:expr; $($arg:tt)*) => ({
($writer:expr_2021; $($arg:tt)*) => ({
$crate::io::notice_args($writer, format_args!($($arg)*));
});
($($arg:tt)*) => ({

2
crates/radicle-term/src/textarea.rs
View File

@ -30,7 +30,7 @@ impl TextArea {
}
/// Get the lines of text in this text area.
pub fn lines(&self) -> impl Iterator<Item = String> {
pub fn lines(&self) -> impl Iterator<Item = String> + use<> {
let mut lines: Vec<String> = Vec::new();
let mut fenced = false;

12
crates/radicle/src/cob/issue.rs
View File

@ -1080,8 +1080,8 @@ mod test {
let test::setup::NodeWithRepo { node, repo, .. } = test::setup::NodeWithRepo::default();
let mut issues = Cache::no_cache(&*repo).unwrap();
let assignee = Did::from(arbitrary::gen::<ActorId>(1));
let assignee_two = Did::from(arbitrary::gen::<ActorId>(1));
let assignee = Did::from(arbitrary::r#gen::<ActorId>(1));
let assignee_two = Did::from(arbitrary::r#gen::<ActorId>(1));
let issue = issues
.create(
cob::Title::new("My first issue").unwrap(),
@ -1119,8 +1119,8 @@ mod test {
let test::setup::NodeWithRepo { node, repo, .. } = test::setup::NodeWithRepo::default();
let mut issues = Cache::no_cache(&*repo).unwrap();
let assignee = Did::from(arbitrary::gen::<ActorId>(1));
let assignee_two = Did::from(arbitrary::gen::<ActorId>(1));
let assignee = Did::from(arbitrary::r#gen::<ActorId>(1));
let assignee_two = Did::from(arbitrary::r#gen::<ActorId>(1));
let mut issue = issues
.create(
cob::Title::new("My first issue").unwrap(),
@ -1218,8 +1218,8 @@ mod test {
let test::setup::NodeWithRepo { node, repo, .. } = test::setup::NodeWithRepo::default();
let mut issues = Cache::no_cache(&*repo).unwrap();
let assignee = Did::from(arbitrary::gen::<ActorId>(1));
let assignee_two = Did::from(arbitrary::gen::<ActorId>(1));
let assignee = Did::from(arbitrary::r#gen::<ActorId>(1));
let assignee_two = Did::from(arbitrary::r#gen::<ActorId>(1));
let mut issue = issues
.create(
cob::Title::new("My first issue").unwrap(),

26
crates/radicle/src/cob/issue/cache.rs
View File

@ -635,7 +635,7 @@ mod tests {
#[test]
fn test_is_empty() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
assert!(cache.is_empty().unwrap());
@ -657,10 +657,10 @@ mod tests {
#[test]
fn test_counts() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
let n_open = arbitrary::gen::<u8>(0);
let n_closed = arbitrary::gen::<u8>(1);
let n_open = arbitrary::r#gen::<u8>(0);
let n_closed = arbitrary::r#gen::<u8>(1);
let open_ids = (0..n_open)
.map(|_| IssueId::from(arbitrary::oid()))
.collect::<BTreeSet<IssueId>>();
@ -698,12 +698,12 @@ mod tests {
#[test]
fn test_get() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
let ids = (0..arbitrary::gen::<u8>(1))
let ids = (0..arbitrary::r#gen::<u8>(1))
.map(|_| IssueId::from(arbitrary::oid()))
.collect::<BTreeSet<IssueId>>();
let missing = (0..arbitrary::gen::<u8>(2))
let missing = (0..arbitrary::r#gen::<u8>(2))
.filter_map(|_| {
let id = IssueId::from(arbitrary::oid());
(!ids.contains(&id)).then_some(id)
@ -733,9 +733,9 @@ mod tests {
#[test]
fn test_list() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
let ids = (0..arbitrary::gen::<u8>(1))
let ids = (0..arbitrary::r#gen::<u8>(1))
.map(|_| IssueId::from(arbitrary::oid()))
.collect::<BTreeSet<IssueId>>();
let mut issues = Vec::with_capacity(ids.len());
@ -763,9 +763,9 @@ mod tests {
#[test]
fn test_list_by_status() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
let ids = (0..arbitrary::gen::<u8>(1))
let ids = (0..arbitrary::r#gen::<u8>(1))
.map(|_| IssueId::from(arbitrary::oid()))
.collect::<BTreeSet<IssueId>>();
let mut issues = Vec::with_capacity(ids.len());
@ -793,9 +793,9 @@ mod tests {
#[test]
fn test_remove() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
let ids = (0..arbitrary::gen::<u8>(1))
let ids = (0..arbitrary::r#gen::<u8>(1))
.map(|_| IssueId::from(arbitrary::oid()))
.collect::<BTreeSet<IssueId>>();

10
crates/radicle/src/cob/patch.rs
View File

@ -2999,7 +2999,7 @@ mod test {
use crate::profile::env;
use crate::test;
use crate::test::arbitrary;
use crate::test::arbitrary::gen;
use crate::test::arbitrary::r#gen;
use crate::test::storage::MockRepository;
use cob::migrate;
@ -3251,9 +3251,9 @@ mod test {
let base = git::Oid::from_str("cb18e95ada2bb38aadd8e6cef0963ce37a87add3").unwrap();
let oid = git::Oid::from_str("518d5069f94c03427f694bb494ac1cd7d1339380").unwrap();
let mut alice = Actor::<MockSigner>::default();
let rid = gen::<RepoId>(1);
let rid = r#gen::<RepoId>(1);
let doc = RawDoc::new(
gen::<Project>(1),
r#gen::<Project>(1),
vec![alice.did()],
1,
identity::Visibility::Public,
@ -3308,7 +3308,7 @@ mod test {
fn test_revision_edit_redact() {
let base = arbitrary::oid();
let oid = arbitrary::oid();
let repo = gen::<MockRepository>(1);
let repo = r#gen::<MockRepository>(1);
let time = env::local_time();
let alice = MockSigner::default();
let bob = MockSigner::default();
@ -3370,7 +3370,7 @@ mod test {
let base = git::Oid::from_str("cb18e95ada2bb38aadd8e6cef0963ce37a87add3").unwrap();
let oid = git::Oid::from_str("518d5069f94c03427f694bb494ac1cd7d1339380").unwrap();
let mut alice = Actor::<MockSigner>::default();
let repo = gen::<MockRepository>(1);
let repo = r#gen::<MockRepository>(1);
let reaction = Reaction::new('👍').expect("failed to create a reaction");
let a1 = alice.op::<Patch>([

38
crates/radicle/src/cob/patch/cache.rs
View File

@ -732,8 +732,8 @@ mod tests {
}
fn revision() -> (RevisionId, Revision) {
let author = arbitrary::gen::<Did>(1);
let description = arbitrary::gen::<String>(1);
let author = arbitrary::r#gen::<Did>(1);
let description = arbitrary::r#gen::<String>(1);
let base = arbitrary::oid();
let oid = arbitrary::oid();
let timestamp = env::local_time();
@ -763,7 +763,7 @@ mod tests {
#[test]
fn test_is_empty() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
assert!(cache.is_empty().unwrap());
@ -791,12 +791,12 @@ mod tests {
#[test]
fn test_counts() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
let n_open = arbitrary::gen::<u8>(0);
let n_draft = arbitrary::gen::<u8>(1);
let n_archived = arbitrary::gen::<u8>(1);
let n_merged = arbitrary::gen::<u8>(1);
let n_open = arbitrary::r#gen::<u8>(0);
let n_draft = arbitrary::r#gen::<u8>(1);
let n_archived = arbitrary::r#gen::<u8>(1);
let n_merged = arbitrary::r#gen::<u8>(1);
let open_ids = (0..n_open)
.map(|_| PatchId::from(arbitrary::oid()))
.collect::<BTreeSet<PatchId>>();
@ -879,12 +879,12 @@ mod tests {
#[test]
fn test_get() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
let ids = (0..arbitrary::gen::<u8>(1))
let ids = (0..arbitrary::r#gen::<u8>(1))
.map(|_| PatchId::from(arbitrary::oid()))
.collect::<BTreeSet<PatchId>>();
let missing = (0..arbitrary::gen::<u8>(2))
let missing = (0..arbitrary::r#gen::<u8>(2))
.filter_map(|_| {
let id = PatchId::from(arbitrary::oid());
(!ids.contains(&id)).then_some(id)
@ -915,10 +915,10 @@ mod tests {
#[test]
fn test_find_by_revision() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
let patch_id = PatchId::from(arbitrary::oid());
let revisions = (0..arbitrary::gen::<NonZeroU8>(1).into())
let revisions = (0..arbitrary::r#gen::<NonZeroU8>(1).into())
.map(|_| revision())
.collect::<BTreeMap<RevisionId, Revision>>();
let (rev_id, rev) = revisions
@ -957,9 +957,9 @@ mod tests {
#[test]
fn test_list() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
let ids = (0..arbitrary::gen::<u8>(1))
let ids = (0..arbitrary::r#gen::<u8>(1))
.map(|_| PatchId::from(arbitrary::oid()))
.collect::<BTreeSet<PatchId>>();
let mut patches = Vec::with_capacity(ids.len());
@ -988,9 +988,9 @@ mod tests {
#[test]
fn test_list_by_status() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
let ids = (0..arbitrary::gen::<u8>(1))
let ids = (0..arbitrary::r#gen::<u8>(1))
.map(|_| PatchId::from(arbitrary::oid()))
.collect::<BTreeSet<PatchId>>();
let mut patches = Vec::with_capacity(ids.len());
@ -1019,9 +1019,9 @@ mod tests {
#[test]
fn test_remove() {
let repo = arbitrary::gen::<MockRepository>(1);
let repo = arbitrary::r#gen::<MockRepository>(1);
let mut cache = memory(repo);
let ids = (0..arbitrary::gen::<u8>(1))
let ids = (0..arbitrary::r#gen::<u8>(1))
.map(|_| PatchId::from(arbitrary::oid()))
.collect::<BTreeSet<PatchId>>();

2
crates/radicle/src/cob/store.rs
View File

@ -344,7 +344,7 @@ where
/// Return all objects.
pub fn all(
&self,
) -> Result<impl ExactSizeIterator<Item = Result<(ObjectId, T), Error>> + 'a, Error> {
) -> Result<impl ExactSizeIterator<Item = Result<(ObjectId, T), Error>> + use<'a, T, R>, Error> {
let raw = cob::list::<T, _>(self.repo, self.type_name)?;
Ok(raw.into_iter().map(|o| Ok((*o.id(), o.object))))

8
crates/radicle/src/cob/stream.rs
View File

@ -177,7 +177,7 @@ mod tests {
use crate::cob::change::Storage as _;
use crate::crypto::test::signer::MockSigner;
use crate::test::arbitrary;
use crate::test::arbitrary::gen;
use crate::test::arbitrary::r#gen;
use crate::{cob, test};
use super::*;
@ -188,13 +188,13 @@ mod tests {
fn gen_ops(repo: &git::raw::Repository, signer: &MockSigner) -> Vec<cob::Entry> {
// Number of ops
let n = gen::<u8>(1).clamp(1, 10);
let n = r#gen::<u8>(1).clamp(1, 10);
let mut entries = Vec::with_capacity(n.into());
let mut parent = None;
for _ in 0..n {
// Number of actions in this op
let m = gen::<u8>(1).clamp(1, 3);
let m = r#gen::<u8>(1).clamp(1, 3);
let contents = create_contents((0..m).map(|_| arbitrary::alphanumeric(1)));
let entry = create_entry(repo, signer, contents, parent);
parent = Some(entry.id);
@ -383,7 +383,7 @@ mod tests {
until: ops.last().unwrap().id.into(),
};
let n = ops.len() - 1;
let (x, y) = gen::<(usize, usize)>(1);
let (x, y) = r#gen::<(usize, usize)>(1);
let x = x.clamp(0, n);
let y = y.clamp(0, n);
let (from, until) = if x <= y {

18
crates/radicle/src/cob/thread.rs
View File

@ -638,7 +638,7 @@ mod tests {
use crate::node::device::Device;
use crate::profile::env;
use crate::test::arbitrary;
use crate::test::arbitrary::gen;
use crate::test::arbitrary::r#gen;
use crate::test::storage::MockRepository;
/// An object that can be used to create and sign changes.
@ -700,7 +700,7 @@ mod tests {
#[test]
fn test_redact_comment() {
let radicle::test::setup::Node { signer, .. } = radicle::test::setup::Node::default();
let repo = gen::<MockRepository>(1);
let repo = r#gen::<MockRepository>(1);
let mut alice = Actor::new(signer);
let a0 = alice.comment("First comment", None);
@ -725,7 +725,7 @@ mod tests {
#[test]
fn test_edit_comment() {
let mut alice = Actor::<MockSigner>::default();
let repo = gen::<MockRepository>(1);
let repo = r#gen::<MockRepository>(1);
let c0 = alice.comment("Hello world!", None);
let c1 = alice.edit(c0.id(), "Goodbye world.");
@ -747,7 +747,7 @@ mod tests {
let alice = MockSigner::default();
let bob = MockSigner::default();
let eve = MockSigner::default();
let repo = gen::<MockRepository>(1);
let repo = r#gen::<MockRepository>(1);
let time = env::local_time();
let mut a = test::history::<Thread, _>(
@ -812,7 +812,7 @@ mod tests {
#[test]
fn test_duplicate_comments() {
let repo = gen::<MockRepository>(1);
let repo = r#gen::<MockRepository>(1);
let alice = MockSigner::default();
let bob = MockSigner::default();
let time = env::local_time();
@ -856,7 +856,7 @@ mod tests {
#[quickcheck]
fn prop_ordering(timestamp: u64) {
let repo = gen::<MockRepository>(1);
let repo = r#gen::<MockRepository>(1);
let alice = MockSigner::default();
let bob = MockSigner::default();
let timestamp = Timestamp::from_secs(timestamp);
@ -915,7 +915,7 @@ mod tests {
#[test]
fn test_comment_redact_missing() {
let repo = gen::<MockRepository>(1);
let repo = r#gen::<MockRepository>(1);
let mut alice = Actor::<MockSigner>::default();
let mut t = Thread::default();
let id = arbitrary::entry_id();
@ -925,7 +925,7 @@ mod tests {
#[test]
fn test_comment_edit_missing() {
let repo = gen::<MockRepository>(1);
let repo = r#gen::<MockRepository>(1);
let mut alice = Actor::<MockSigner>::default();
let mut t = Thread::default();
let id = arbitrary::entry_id();
@ -935,7 +935,7 @@ mod tests {
#[test]
fn test_comment_edit_redacted() {
let repo = gen::<MockRepository>(1);
let repo = r#gen::<MockRepository>(1);
let mut alice = Actor::<MockSigner>::default();
let a1 = alice.comment("Hi", None);

2
crates/radicle/src/git/canonical.rs
View File

@ -304,7 +304,7 @@ impl<'a, 'b> QuorumFinder<'a, 'b> {
}
}
fn find_merge_bases(&mut self) -> ControlFlow<(), impl Iterator<Item = (Oid, Oid)>> {
fn find_merge_bases(&mut self) -> ControlFlow<(), impl Iterator<Item = (Oid, Oid)> + use<>> {
match self.commit_quorum.next_candidate() {
Some(candidate) => ControlFlow::Continue(candidate),
None => ControlFlow::Break(()),

2
crates/radicle/src/git/canonical/quorum.rs
View File

@ -156,7 +156,7 @@ impl CommitQuorum {
///
/// A [`MergeBase`] should be calculated for each, and these should be
/// recorded using [`CommitQuorum::found_merge_bases`].
pub fn next_candidate(&mut self) -> Option<impl Iterator<Item = (Oid, Oid)>> {
pub fn next_candidate(&mut self) -> Option<impl Iterator<Item = (Oid, Oid)> + use<>> {
self.voting.next_candidate()
}

4
crates/radicle/src/git/canonical/rules.rs
View File

@ -1026,7 +1026,7 @@ mod tests {
#[test]
fn test_rule_validate_success() {
let doc = arbitrary::gen::<Doc>(1);
let doc = arbitrary::r#gen::<Doc>(1);
let delegates = Allowed::Set(doc.delegates().as_ref().clone());
let threshold = doc.majority();
@ -1041,7 +1041,7 @@ mod tests {
#[test]
fn test_rule_validate_failures() {
let doc = arbitrary::gen::<Doc>(1);
let doc = arbitrary::r#gen::<Doc>(1);
let pattern = pattern(qualified_pattern!("refs/heads/main"));
assert!(matches!(

2
crates/radicle/src/git/canonical/voting.rs
View File

@ -66,7 +66,7 @@ impl CommitVoting {
/// compared to the other commit to see what their common merge base is. The
/// merge base is then recorded using [`MergeBase`] and is recorded using
/// [`CommitVoting::found_merge_base`].
pub fn next_candidate(&mut self) -> Option<impl Iterator<Item = (Oid, Oid)>> {
pub fn next_candidate(&mut self) -> Option<impl Iterator<Item = (Oid, Oid)> + use<>> {
self.candidates
.pop()
.map(|(oid, others)| others.into_iter().map(move |other| (oid, other)))

14
crates/radicle/src/identity/doc.rs
View File

@ -978,7 +978,7 @@ mod test {
use crate::storage::git::Storage;
use crate::storage::{ReadStorage as _, RemoteId, WriteStorage as _};
use crate::test::arbitrary;
use crate::test::arbitrary::gen;
use crate::test::arbitrary::r#gen;
use crate::test::fixtures;
use super::*;
@ -988,7 +988,7 @@ mod test {
fn test_duplicate_dids() {
let delegate = Device::mock_from_seed([0xff; 32]);
let did = Did::from(delegate.public_key());
let mut doc = RawDoc::new(gen::<Project>(1), vec![did], 1, Visibility::Public);
let mut doc = RawDoc::new(r#gen::<Project>(1), vec![did], 1, Visibility::Public);
doc.delegate(did);
let doc = doc.verified().unwrap();
assert!(doc.delegates().len() == 1, "Duplicate DID was not removed");
@ -998,11 +998,11 @@ mod test {
#[test]
fn test_max_delegates() {
// Generate more than the max delegates
let delegates = (0..MAX_DELEGATES + 1).map(gen).collect::<Vec<Did>>();
let delegates = (0..MAX_DELEGATES + 1).map(r#gen).collect::<Vec<Did>>();
// A document with max delegates will be fine
let doc = RawDoc::new(
gen::<Project>(1),
r#gen::<Project>(1),
delegates[0..MAX_DELEGATES].into(),
1,
Visibility::Public,
@ -1010,7 +1010,7 @@ mod test {
assert_matches!(doc.verified(), Ok(_));
// A document that exceeds max delegates should fail
let doc = RawDoc::new(gen::<Project>(1), delegates, 1, Visibility::Public);
let doc = RawDoc::new(r#gen::<Project>(1), delegates, 1, Visibility::Public);
assert_matches!(doc.verified(), Err(DocError::Delegates(DelegatesError(_))));
}
@ -1149,8 +1149,8 @@ mod test {
fn test_not_found() {
let tempdir = tempfile::tempdir().unwrap();
let storage = Storage::open(tempdir.path().join("storage"), fixtures::user()).unwrap();
let remote = arbitrary::gen::<RemoteId>(1);
let proj = arbitrary::gen::<RepoId>(1);
let remote = arbitrary::r#gen::<RemoteId>(1);
let proj = arbitrary::r#gen::<RepoId>(1);
let repo = storage.create(proj).unwrap();
let oid = git::raw::Oid::from_str("2d52a53ce5e4f141148a5f770cfd3ead2d6a45b8").unwrap();

6
crates/radicle/src/identity/doc/update.rs
View File

@ -289,7 +289,7 @@ mod test {
#[test]
fn test_can_update_crefs() {
let raw = arbitrary::gen::<RawDoc>(1);
let raw = arbitrary::r#gen::<RawDoc>(1);
let raw = super::payload(
raw,
[PayloadUpsert {
@ -310,7 +310,7 @@ mod test {
#[test]
fn test_cannot_include_default_branch_rule() {
let raw = arbitrary::gen::<RawDoc>(1);
let raw = arbitrary::r#gen::<RawDoc>(1);
let branch = git::fmt::Qualified::from(git::fmt::lit::refs_heads(
raw.project().unwrap().default_branch(),
));
@ -343,7 +343,7 @@ mod test {
#[test]
fn test_default_branch_rule_exists_after_verification() {
let raw = arbitrary::gen::<RawDoc>(1);
let raw = arbitrary::r#gen::<RawDoc>(1);
let branch = git::fmt::Qualified::from(git::fmt::lit::refs_heads(
raw.project().unwrap().default_branch(),
));

6
crates/radicle/src/node.rs
View File

@ -488,7 +488,7 @@ impl Address {
self.0.port
}
pub fn display_compact(&self) -> impl Display {
pub fn display_compact(&self) -> impl Display + use<> {
let host = match self.host() {
HostName::Ip(IpAddr::V4(ip)) => ip.to_string(),
HostName::Ip(IpAddr::V6(ip)) => format!("[{ip}]"),
@ -1420,11 +1420,11 @@ pub(crate) mod properties {
impl AliasInput {
pub fn new() -> Self {
let short = arbitrary::gen::<Alias>(0);
let short = arbitrary::r#gen::<Alias>(0);
let long = {
// Ensure we have a second, unique alias
let mut a = short.to_string();
a.push_str(arbitrary::gen::<Alias>(1).as_str());
a.push_str(arbitrary::r#gen::<Alias>(1).as_str());
Alias::new(a)
};
Self {

28
crates/radicle/src/node/address/store.rs
View File

@ -575,7 +575,7 @@ mod test {
#[test]
fn test_get_none() {
let alice = arbitrary::gen::<NodeId>(1);
let alice = arbitrary::r#gen::<NodeId>(1);
let cache = Database::memory().unwrap();
let result = cache.get(&alice).unwrap();
@ -584,7 +584,7 @@ mod test {
#[test]
fn test_remove_nothing() {
let alice = arbitrary::gen::<NodeId>(1);
let alice = arbitrary::r#gen::<NodeId>(1);
let mut cache = Database::memory().unwrap();
let removed = cache.remove(&alice).unwrap();
@ -593,7 +593,7 @@ mod test {
#[test]
fn test_alias() {
let alice = arbitrary::gen::<NodeId>(1);
let alice = arbitrary::r#gen::<NodeId>(1);
let mut cache = Database::memory().unwrap();
let features = node::Features::SEED;
let timestamp = Timestamp::from(LocalTime::now());
@ -632,7 +632,7 @@ mod test {
#[test]
fn test_insert_and_get() {
let alice = arbitrary::gen::<NodeId>(1);
let alice = arbitrary::r#gen::<NodeId>(1);
let mut cache = Database::memory().unwrap();
let version = 2;
let features = node::Features::SEED;
@ -672,7 +672,7 @@ mod test {
#[test]
fn test_insert_duplicate() {
let alice = arbitrary::gen::<NodeId>(1);
let alice = arbitrary::r#gen::<NodeId>(1);
let mut cache = Database::memory().unwrap();
let features = node::Features::SEED;
let timestamp = LocalTime::now().into();
@ -701,7 +701,7 @@ mod test {
#[test]
fn test_insert_and_update() {
let alice = arbitrary::gen::<NodeId>(1);
let alice = arbitrary::r#gen::<NodeId>(1);
let mut cache = Database::memory().unwrap();
let timestamp = LocalTime::now().into();
let features = node::Features::SEED;
@ -776,8 +776,8 @@ mod test {
#[test]
fn test_insert_and_remove() {
let alice = arbitrary::gen::<NodeId>(1);
let bob = arbitrary::gen::<NodeId>(1);
let alice = arbitrary::r#gen::<NodeId>(1);
let bob = arbitrary::r#gen::<NodeId>(1);
let mut cache = Database::memory().unwrap();
let timestamp = LocalTime::now().into();
let ua = UserAgent::default();
@ -868,8 +868,8 @@ mod test {
#[test]
fn test_disconnected() {
let alice = arbitrary::gen::<NodeId>(1);
let addr = arbitrary::gen::<Address>(1);
let alice = arbitrary::r#gen::<NodeId>(1);
let addr = arbitrary::r#gen::<Address>(1);
let mut cache = Database::memory().unwrap();
let features = node::Features::SEED;
let timestamp = Timestamp::from(LocalTime::now());
@ -909,16 +909,16 @@ mod test {
#[test]
fn test_disconnected_ban() {
let alice = arbitrary::gen::<NodeId>(1);
let alice = arbitrary::r#gen::<NodeId>(1);
let ua = UserAgent::default();
let ip1: net::Ipv4Addr = [8, 8, 8, 8].into();
let ip2: net::Ipv4Addr = [9, 9, 9, 9].into();
let ka1 = arbitrary::gen::<KnownAddress>(1);
let ka1 = arbitrary::r#gen::<KnownAddress>(1);
let ka1 = KnownAddress {
addr: Address::from(NetAddr::new(ip1.into(), 8776)),
..ka1
};
let ka2 = arbitrary::gen::<KnownAddress>(1);
let ka2 = arbitrary::r#gen::<KnownAddress>(1);
let ka2 = KnownAddress {
addr: Address::from(NetAddr::new(ip2.into(), 8776)),
..ka2
@ -980,7 +980,7 @@ mod test {
let features = node::Features::SEED;
let agent = UserAgent::default();
let timestamp = Timestamp::from(LocalTime::now());
let ka = arbitrary::gen::<KnownAddress>(1);
let ka = arbitrary::r#gen::<KnownAddress>(1);
for id in short_ids {
db.insert(id, 1, features, short, 16, &agent, timestamp, [ka.clone()])

2
crates/radicle/src/node/config.rs
View File

@ -718,7 +718,7 @@ impl From<LimitGossipMaxAge> for LocalDuration {
/// - `Deserialize`
/// - `From<$name> for $type`, i.e. can convert back into the original type
macro_rules! wrapper {
($name:ident, $type:ty, $default:expr $(, $derive:ty)*) => {
($name:ident, $type:ty, $default:expr_2021 $(, $derive:ty)*) => {
#[derive(Clone, Debug, Deserialize, Display, Serialize, From $(, $derive)*)]
#[display("{0}")]
#[serde(transparent)]

16
crates/radicle/src/node/notifications/store.rs
View File

@ -294,7 +294,7 @@ impl<T> Store<T> {
&self,
repo: &RepoId,
order_by: &str,
) -> Result<impl Iterator<Item = Result<Notification, Error>> + '_, Error> {
) -> Result<impl Iterator<Item = Result<Notification, Error>> + '_ + use<'_, T>, Error> {
let mut stmt = self.db.prepare(format!(
"SELECT rowid, repo, ref, old, new, status, timestamp
FROM `repository-notifications`
@ -424,7 +424,7 @@ mod test {
#[test]
fn test_clear() {
let mut db = Store::open(":memory:").unwrap();
let repo = arbitrary::gen::<RepoId>(1);
let repo = arbitrary::r#gen::<RepoId>(1);
let old = arbitrary::oid();
let time = LocalTime::from_millis(32188142);
let master = arbitrary::oid();
@ -447,8 +447,8 @@ mod test {
#[test]
fn test_counts_by_repo() {
let mut db = Store::open(":memory:").unwrap();
let repo1 = arbitrary::gen::<RepoId>(1);
let repo2 = arbitrary::gen::<RepoId>(1);
let repo1 = arbitrary::r#gen::<RepoId>(1);
let repo2 = arbitrary::r#gen::<RepoId>(1);
let oid = arbitrary::oid();
let time = LocalTime::from_millis(32188142);
@ -480,7 +480,7 @@ mod test {
#[test]
fn test_branch_notifications() {
let repo = arbitrary::gen::<RepoId>(1);
let repo = arbitrary::r#gen::<RepoId>(1);
let old = arbitrary::oid();
let master = arbitrary::oid();
let other = arbitrary::oid();
@ -558,7 +558,7 @@ mod test {
#[test]
fn test_notification_status() {
let repo = arbitrary::gen::<RepoId>(1);
let repo = arbitrary::r#gen::<RepoId>(1);
let oid = arbitrary::oid();
let time = LocalTime::from_millis(32188142);
let mut db = Store::open(":memory:").unwrap();
@ -600,7 +600,7 @@ mod test {
#[test]
fn test_duplicate_notifications() {
let repo = arbitrary::gen::<RepoId>(1);
let repo = arbitrary::r#gen::<RepoId>(1);
let old = arbitrary::oid();
let master1 = arbitrary::oid();
let master2 = arbitrary::oid();
@ -647,7 +647,7 @@ mod test {
#[test]
fn test_cob_notifications() {
let repo = arbitrary::gen::<RepoId>(1);
let repo = arbitrary::r#gen::<RepoId>(1);
let old = arbitrary::oid();
let new = arbitrary::oid();
let timestamp = LocalTime::from_millis(32189874);

12
crates/radicle/src/node/policy/store.rs
View File

@ -467,7 +467,7 @@ mod test {
#[test]
fn test_follow_and_unfollow_node() {
let id = arbitrary::gen::<NodeId>(1);
let id = arbitrary::r#gen::<NodeId>(1);
let mut db = Store::open(":memory:").unwrap();
let eve = Alias::new("eve");
@ -480,7 +480,7 @@ mod test {
#[test]
fn test_seed_and_unseed_repo() {
let id = arbitrary::gen::<RepoId>(1);
let id = arbitrary::r#gen::<RepoId>(1);
let mut db = Store::open(":memory:").unwrap();
assert!(db.seed(&id, Scope::All).unwrap());
@ -520,7 +520,7 @@ mod test {
#[test]
fn test_update_alias() {
let id = arbitrary::gen::<NodeId>(1);
let id = arbitrary::r#gen::<NodeId>(1);
let mut db = Store::open(":memory:").unwrap();
assert!(db.follow(&id, Some(&Alias::new("eve"))).unwrap());
@ -540,7 +540,7 @@ mod test {
#[test]
fn test_update_scope() {
let id = arbitrary::gen::<RepoId>(1);
let id = arbitrary::r#gen::<RepoId>(1);
let mut db = Store::open(":memory:").unwrap();
assert!(db.seed(&id, Scope::All).unwrap());
@ -557,7 +557,7 @@ mod test {
#[test]
fn test_repo_policy() {
let id = arbitrary::gen::<RepoId>(1);
let id = arbitrary::r#gen::<RepoId>(1);
let mut db = Store::open(":memory:").unwrap();
assert!(db.seed(&id, Scope::All).unwrap());
@ -569,7 +569,7 @@ mod test {
#[test]
fn test_node_policy() {
let id = arbitrary::gen::<NodeId>(1);
let id = arbitrary::r#gen::<NodeId>(1);
let mut db = Store::open(":memory:").unwrap();
assert!(db.follow(&id, None).unwrap());

12
crates/radicle/src/node/refs/store.rs
View File

@ -186,8 +186,8 @@ mod test {
let mut db = Database::memory().unwrap();
let oid = arbitrary::oid();
let repo = arbitrary::gen::<RepoId>(1);
let namespace = arbitrary::gen::<NodeId>(1);
let repo = arbitrary::r#gen::<RepoId>(1);
let namespace = arbitrary::r#gen::<NodeId>(1);
let refname1 = qualified!("refs/heads/master");
let refname2 = qualified!("refs/heads/main");
let timestamp = LocalTime::now();
@ -212,8 +212,8 @@ mod test {
let mut db = Database::memory().unwrap();
let oid = arbitrary::oid();
let repo = arbitrary::gen::<RepoId>(1);
let namespace = arbitrary::gen::<NodeId>(1);
let repo = arbitrary::r#gen::<RepoId>(1);
let namespace = arbitrary::r#gen::<NodeId>(1);
let refname = qualified!("refs/heads/master");
let timestamp = LocalTime::now();
@ -232,8 +232,8 @@ mod test {
assert_ne!(oid1, oid2);
let repo = arbitrary::gen::<RepoId>(1);
let namespace = arbitrary::gen::<NodeId>(1);
let repo = arbitrary::r#gen::<RepoId>(1);
let namespace = arbitrary::r#gen::<NodeId>(1);
let refname = qualified!("refs/heads/master");
let mut timestamp = LocalTime::now();

32
crates/radicle/src/node/routing.rs
View File

@ -357,8 +357,8 @@ mod test {
#[test]
fn test_insert_duplicate() {
let id = arbitrary::gen::<RepoId>(1);
let node = arbitrary::gen::<NodeId>(1);
let id = arbitrary::r#gen::<RepoId>(1);
let node = arbitrary::r#gen::<NodeId>(1);
let mut db = database(":memory:");
assert_eq!(
@ -377,8 +377,8 @@ mod test {
#[test]
fn test_insert_existing_updated_time() {
let id = arbitrary::gen::<RepoId>(1);
let node = arbitrary::gen::<NodeId>(1);
let id = arbitrary::r#gen::<RepoId>(1);
let node = arbitrary::r#gen::<NodeId>(1);
let mut db = database(":memory:");
assert_eq!(
@ -398,9 +398,9 @@ mod test {
#[test]
fn test_update_existing_multi() {
let id1 = arbitrary::gen::<RepoId>(1);
let id2 = arbitrary::gen::<RepoId>(1);
let node = arbitrary::gen::<NodeId>(1);
let id1 = arbitrary::r#gen::<RepoId>(1);
let id2 = arbitrary::r#gen::<RepoId>(1);
let node = arbitrary::r#gen::<NodeId>(1);
let mut db = database(":memory:");
assert_eq!(
@ -427,8 +427,8 @@ mod test {
#[test]
fn test_remove_redundant() {
let id = arbitrary::gen::<RepoId>(1);
let node = arbitrary::gen::<NodeId>(1);
let id = arbitrary::r#gen::<RepoId>(1);
let node = arbitrary::r#gen::<NodeId>(1);
let mut db = database(":memory:");
assert_eq!(
@ -441,10 +441,10 @@ mod test {
#[test]
fn test_remove_many() {
let id1 = arbitrary::gen::<RepoId>(1);
let id2 = arbitrary::gen::<RepoId>(1);
let id3 = arbitrary::gen::<RepoId>(1);
let node = arbitrary::gen::<NodeId>(1);
let id1 = arbitrary::r#gen::<RepoId>(1);
let id2 = arbitrary::r#gen::<RepoId>(1);
let id3 = arbitrary::r#gen::<RepoId>(1);
let node = arbitrary::r#gen::<NodeId>(1);
let mut db = database(":memory:");
db.add_inventory([&id1, &id2, &id3], node, Timestamp::EPOCH)
@ -459,7 +459,7 @@ mod test {
fn test_len() {
let mut db = database(":memory:");
let ids = arbitrary::vec::<RepoId>(10);
let node = arbitrary::gen(1);
let node = arbitrary::r#gen(1);
db.add_inventory(&ids, node, LocalTime::now().into())
.unwrap();
@ -490,7 +490,7 @@ mod test {
.unwrap();
}
let pruned = db.prune(now.into(), None, &arbitrary::gen(1)).unwrap();
let pruned = db.prune(now.into(), None, &arbitrary::r#gen(1)).unwrap();
assert_eq!(pruned, ids.len() * nodes.len());
for id in &ids {
@ -503,7 +503,7 @@ mod test {
#[test]
fn test_count() {
let id = arbitrary::gen::<RepoId>(1);
let id = arbitrary::r#gen::<RepoId>(1);
let nodes = arbitrary::set::<NodeId>(5..10);
let mut db = database(":memory:");

52
crates/radicle/src/node/sync/announce.rs
View File

@ -586,7 +586,7 @@ mod test {
#[test]
fn all_synced_nodes_are_preferred_seeds() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let seeds = arbitrary::set::<NodeId>(5..=5);
// All preferred seeds, no regular seeds in unsynced
@ -642,7 +642,7 @@ mod test {
#[test]
fn preferred_seeds_already_synced() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let seeds = arbitrary::set::<NodeId>(6..=6);
let preferred_seeds = seeds.iter().take(2).copied().collect::<BTreeSet<_>>();
@ -668,7 +668,7 @@ mod test {
#[test]
fn announcer_reached_min_replication_target() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let seeds = arbitrary::set::<NodeId>(10..=10);
let unsynced = seeds.iter().skip(3).copied().collect::<BTreeSet<_>>();
let preferred_seeds = seeds.iter().take(2).copied().collect::<BTreeSet<_>>();
@ -729,7 +729,7 @@ mod test {
#[test]
fn announcer_reached_max_replication_target() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let seeds = arbitrary::set::<NodeId>(10..=10);
let unsynced = seeds.iter().skip(3).copied().collect::<BTreeSet<_>>();
let preferred_seeds = seeds.iter().take(2).copied().collect::<BTreeSet<_>>();
@ -776,7 +776,7 @@ mod test {
#[test]
fn announcer_preferred_seeds_or_replica_factor() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let seeds = arbitrary::set::<NodeId>(10..=10);
let unsynced = seeds.iter().skip(2).copied().collect::<BTreeSet<_>>();
let preferred_seeds = seeds.iter().take(2).copied().collect::<BTreeSet<_>>();
@ -840,7 +840,7 @@ mod test {
#[test]
fn announcer_reached_preferred_seeds() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let seeds = arbitrary::set::<NodeId>(10..=10);
let unsynced = seeds.iter().skip(2).copied().collect::<BTreeSet<_>>();
let preferred_seeds = seeds.iter().take(2).copied().collect::<BTreeSet<_>>();
@ -887,7 +887,7 @@ mod test {
#[test]
fn announcer_timed_out() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let seeds = arbitrary::set::<NodeId>(10..=10);
let unsynced = seeds.iter().skip(2).copied().collect::<BTreeSet<_>>();
let preferred_seeds = seeds.iter().take(2).copied().collect::<BTreeSet<_>>();
@ -948,7 +948,7 @@ mod test {
#[test]
fn announcer_adapts_target_to_reach() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
// Only 3 nodes available
let unsynced = arbitrary::set::<NodeId>(3..=3)
.into_iter()
@ -968,7 +968,7 @@ mod test {
#[test]
fn announcer_with_replication_factor_zero_and_preferred_seeds() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let seeds = arbitrary::set::<NodeId>(5..=5);
let preferred_seeds = seeds.iter().take(2).copied().collect::<BTreeSet<_>>();
@ -1010,11 +1010,11 @@ mod test {
#[test]
fn announcer_synced_with_unknown_node() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let seeds = arbitrary::set::<NodeId>(5..=5);
let unsynced = seeds.iter().take(3).copied().collect::<BTreeSet<_>>();
let unknown_node = arbitrary::gen::<NodeId>(100); // Node not in any set
let unknown_node = arbitrary::r#gen::<NodeId>(100); // Node not in any set
let config = AnnouncerConfig::public(
local,
@ -1054,7 +1054,7 @@ mod test {
#[test]
fn synced_with_same_node_multiple_times() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let unsynced = arbitrary::set::<NodeId>(3..=3)
.into_iter()
.collect::<BTreeSet<_>>();
@ -1122,7 +1122,7 @@ mod test {
#[test]
fn timed_out_after_reaching_success() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let unsynced = arbitrary::set::<NodeId>(3..=3)
.into_iter()
.collect::<BTreeSet<_>>();
@ -1170,7 +1170,7 @@ mod test {
fn construct_only_preferred_seeds_provided() {
// Test: preferred_seeds non-empty, synced and unsynced empty
// Expected: preferred seeds should be moved to to_sync, constructor succeeds
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let preferred_seeds = arbitrary::set::<NodeId>(2..=2)
.into_iter()
.collect::<BTreeSet<_>>();
@ -1193,10 +1193,10 @@ mod test {
#[test]
fn construct_node_appears_in_multiple_input_sets() {
let local = arbitrary::gen::<NodeId>(0);
let alice = arbitrary::gen::<NodeId>(1);
let bob = arbitrary::gen::<NodeId>(2);
let eve = arbitrary::gen::<NodeId>(3);
let local = arbitrary::r#gen::<NodeId>(0);
let alice = arbitrary::r#gen::<NodeId>(1);
let bob = arbitrary::r#gen::<NodeId>(2);
let eve = arbitrary::r#gen::<NodeId>(3);
// alice will appear in synced and unsynced
let synced = [alice].iter().copied().collect::<BTreeSet<_>>();
@ -1230,7 +1230,7 @@ mod test {
#[test]
fn cannot_construct_announcer() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let seeds = arbitrary::set::<NodeId>(10..=10);
let synced = seeds.iter().take(3).copied().collect::<BTreeSet<_>>();
let unsynced = seeds.iter().skip(3).copied().collect::<BTreeSet<_>>();
@ -1301,7 +1301,7 @@ mod test {
#[test]
fn invariant_progress_should_match_state() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let seeds = arbitrary::set::<NodeId>(6..=6);
// Set up: 2 already synced, 4 unsynced initially
@ -1375,7 +1375,7 @@ mod test {
#[test]
fn local_node_in_preferred_seeds() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let other_seeds = arbitrary::set::<NodeId>(5..=5);
// Include local node in preferred seeds
@ -1416,7 +1416,7 @@ mod test {
#[test]
fn local_node_in_synced_set() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let other_seeds = arbitrary::set::<NodeId>(5..=5);
// Include local node in synced set
@ -1451,7 +1451,7 @@ mod test {
#[test]
fn local_node_in_unsynced_set() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let other_seeds = arbitrary::set::<NodeId>(5..=5);
let synced = other_seeds.iter().take(2).copied().collect::<BTreeSet<_>>();
@ -1492,7 +1492,7 @@ mod test {
#[test]
fn local_node_in_multiple_sets() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let other_seeds = arbitrary::set::<NodeId>(5..=5);
// Include local node in ALL sets
@ -1554,7 +1554,7 @@ mod test {
#[test]
fn synced_with_local_node_is_ignored() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let unsynced = arbitrary::set::<NodeId>(3..=3).into_iter().collect();
let config = AnnouncerConfig::public(
@ -1596,7 +1596,7 @@ mod test {
#[test]
fn local_node_only_in_all_sets_results_in_no_seeds_error() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
// Create sets that contain ONLY the local node
let preferred_seeds = [local].iter().copied().collect::<BTreeSet<_>>();

32
crates/radicle/src/node/sync/fetch.rs
View File

@ -545,7 +545,7 @@ mod test {
#[test]
fn all_nodes_are_candidates() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let replicas = ReplicationFactor::default();
let seeds = arbitrary::set::<NodeId>(3..=6)
.into_iter()
@ -574,10 +574,10 @@ mod test {
#[test]
fn ignores_duplicates_and_local_node() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let replicas = ReplicationFactor::default();
let bob = arbitrary::gen::<NodeId>(1);
let eve = arbitrary::gen::<NodeId>(2);
let bob = arbitrary::r#gen::<NodeId>(1);
let eve = arbitrary::r#gen::<NodeId>(2);
let seeds = [bob].into_iter().collect::<BTreeSet<_>>();
let extra_candidates = vec![bob, local, eve];
let config = FetcherConfig::public(seeds.clone(), replicas, local)
@ -597,7 +597,7 @@ mod test {
#[test]
fn all_nodes_are_fetchable() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let replicas = ReplicationFactor::default();
let seeds = arbitrary::set::<NodeId>(3..=6)
.into_iter()
@ -614,7 +614,7 @@ mod test {
.collect::<Vec<_>>();
while let Some(node) = fetcher.next_node() {
fetcher.ready_to_fetch(node, arbitrary::gen::<Address>(0));
fetcher.ready_to_fetch(node, arbitrary::r#gen::<Address>(0));
}
while let Some((node, _)) = fetcher.next_fetch() {
@ -626,7 +626,7 @@ mod test {
#[test]
fn reaches_target_of_preferred_seeds() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let replicas = ReplicationFactor::default();
let seeds = arbitrary::set::<NodeId>(3..=3)
.into_iter()
@ -640,7 +640,7 @@ mod test {
let expected = seeds.into_iter().collect::<Vec<_>>();
while let Some(node) = fetcher.next_node() {
fetcher.ready_to_fetch(node, arbitrary::gen::<Address>(0));
fetcher.ready_to_fetch(node, arbitrary::r#gen::<Address>(0));
if let Some((node, _)) = fetcher.next_fetch() {
match fetcher.fetch_complete(
@ -668,7 +668,7 @@ mod test {
#[test]
fn reaches_target_of_replicas() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let replicas = ReplicationFactor::must_reach(3);
let seeds = arbitrary::set::<NodeId>(3..=3)
.into_iter()
@ -686,7 +686,7 @@ mod test {
.collect::<Vec<_>>();
while let Some(node) = fetcher.next_node() {
fetcher.ready_to_fetch(node, arbitrary::gen::<Address>(0));
fetcher.ready_to_fetch(node, arbitrary::r#gen::<Address>(0));
if let Some((node, _)) = fetcher.next_fetch() {
if seeds.contains(&node) {
@ -718,7 +718,7 @@ mod test {
#[test]
fn reaches_target_of_max_replicas() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let replicas = ReplicationFactor::range(1, 3);
let candidates = arbitrary::set::<NodeId>(3..=3);
let seeds = candidates.iter().take(3).copied().collect::<BTreeSet<_>>();
@ -735,7 +735,7 @@ mod test {
.collect::<Vec<_>>();
while let Some(node) = fetcher.next_node() {
fetcher.ready_to_fetch(node, arbitrary::gen::<Address>(0));
fetcher.ready_to_fetch(node, arbitrary::r#gen::<Address>(0));
if let Some((node, _)) = fetcher.next_fetch() {
if seeds.contains(&node) {
@ -777,7 +777,7 @@ mod test {
#[test]
fn preferred_seeds_target_returned_over_replicas() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let replicas = ReplicationFactor::range(1, 3);
let candidates = arbitrary::set::<NodeId>(3..=3);
let seeds = candidates.into_iter().collect::<BTreeSet<_>>();
@ -787,7 +787,7 @@ mod test {
let mut result = Vec::with_capacity(seeds.len());
while let Some(node) = fetcher.next_node() {
fetcher.ready_to_fetch(node, arbitrary::gen::<Address>(0));
fetcher.ready_to_fetch(node, arbitrary::r#gen::<Address>(0));
if let Some((node, _)) = fetcher.next_fetch() {
match fetcher.fetch_complete(
@ -815,7 +815,7 @@ mod test {
#[test]
fn could_not_reach_target() {
let local = arbitrary::gen::<NodeId>(0);
let local = arbitrary::r#gen::<NodeId>(0);
let replicas = ReplicationFactor::must_reach(4);
let candidates = arbitrary::set::<NodeId>(3..=3);
let seeds = candidates.into_iter().collect::<BTreeSet<_>>();
@ -824,7 +824,7 @@ mod test {
let mut fetcher = Fetcher::new(config).expect("fetcher should be constructed correctly");
while let Some(node) = fetcher.next_node() {
fetcher.ready_to_fetch(node, arbitrary::gen::<Address>(0));
fetcher.ready_to_fetch(node, arbitrary::r#gen::<Address>(0));
if let Some((node, _)) = fetcher.next_fetch() {
fetcher.fetch_failed(node, "could not connect");

8
crates/radicle/src/profile.rs
View File

@ -431,7 +431,7 @@ impl Profile {
/// Returns the routing store, with SQLite
/// configuration from [`Self::config`] applied.
pub fn routing(&self) -> Result<impl node::routing::Store, node::db::Error> {
pub fn routing(&self) -> Result<impl node::routing::Store + use<>, node::db::Error> {
self.home.routing(self.config.node.database)
}
}
@ -721,7 +721,7 @@ impl Home {
pub fn addresses(
&self,
config: node::db::config::Config,
) -> Result<impl node::address::Store, node::db::Error> {
) -> Result<impl node::address::Store + use<>, node::db::Error> {
self.database_mut(config)
}
@ -729,7 +729,7 @@ impl Home {
pub fn routing(
&self,
config: node::db::config::Config,
) -> Result<impl node::routing::Store, node::db::Error> {
) -> Result<impl node::routing::Store + use<>, node::db::Error> {
self.database(config)
}
@ -737,7 +737,7 @@ impl Home {
pub fn routing_mut(
&self,
config: node::db::config::Config,
) -> Result<impl node::routing::Store, node::db::Error> {
) -> Result<impl node::routing::Store + use<>, node::db::Error> {
self.database_mut(config)
}

2
crates/radicle/src/profile/config.rs
View File

@ -380,7 +380,7 @@ impl RawConfig {
let mut current = &mut self.0;
for key in config_path.iter() {
current = match current {
json::Value::Object(ref mut map) => {
json::Value::Object(map) => {
map.entry(key).or_insert_with(|| json::json!({}))
}
_ => {

24
crates/radicle/src/test/arbitrary.rs
View File

@ -23,7 +23,7 @@ use crate::test::storage::{MockRepository, MockStorage};
use crate::{cob, git};
pub fn oid() -> storage::Oid {
let oid_bytes: [u8; 20] = gen(1);
let oid_bytes: [u8; 20] = r#gen(1);
storage::Oid::from_sha1(oid_bytes)
}
@ -65,9 +65,9 @@ pub fn vec<T: Eq + Arbitrary>(size: usize) -> Vec<T> {
}
pub fn nonempty_storage(size: usize) -> MockStorage {
let mut storage = gen::<MockStorage>(size);
let mut storage = r#gen::<MockStorage>(size);
for _ in 0..size {
let doc = gen::<DocAt>(1);
let doc = r#gen::<DocAt>(1);
let id = RepoId::from(doc.blob);
storage.repos.insert(
id,
@ -86,32 +86,32 @@ pub fn nonempty_storage(size: usize) -> MockStorage {
pub fn alphanumeric(size: usize) -> String {
let mut s = String::with_capacity(size);
for _ in 0..size {
let choice = gen::<u8>(size).clamp(0, 3);
let choice = r#gen::<u8>(size).clamp(0, 3);
let c = match choice {
// Generate A-Z
0 => gen::<u8>(size).clamp(0x41, 0x5A),
0 => r#gen::<u8>(size).clamp(0x41, 0x5A),
// Generate a-z
1 => gen::<u8>(size).clamp(0x61, 0x7A),
1 => r#gen::<u8>(size).clamp(0x61, 0x7A),
// Generate 0-9
_ => gen::<u8>(size).clamp(0x30, 0x39),
_ => r#gen::<u8>(size).clamp(0x30, 0x39),
};
s.push(char::from(c));
}
s
}
pub fn gen<T: Arbitrary>(size: usize) -> T {
let mut gen = qcheck::Gen::new(size);
pub fn r#gen<T: Arbitrary>(size: usize) -> T {
let mut r#gen = qcheck::Gen::new(size);
T::arbitrary(&mut gen)
T::arbitrary(&mut r#gen)
}
pub fn with_gen<T, F>(size: usize, f: F) -> T
where
F: FnOnce(&mut qcheck::Gen) -> T,
{
let mut gen = qcheck::Gen::new(size);
f(&mut gen)
let mut r#gen = qcheck::Gen::new(size);
f(&mut r#gen)
}
impl Arbitrary for Did {

16
crates/radicle/src/test/assert.rs
View File

@ -40,56 +40,56 @@
///
#[macro_export]
macro_rules! assert_matches {
( $e:expr , $($pat:pat_param)|+ ) => {
( $e:expr_2021 , $($pat:pat_param)|+ ) => {
match $e {
$($pat)|+ => (),
ref e => panic!("assertion failed: `{:?}` does not match `{}`",
e, stringify!($($pat)|+))
}
};
( $e:expr , $($pat:pat_param)|+ if $cond:expr ) => {
( $e:expr_2021 , $($pat:pat_param)|+ if $cond:expr_2021 ) => {
match $e {
$($pat)|+ if $cond => (),
ref e => panic!("assertion failed: `{:?}` does not match `{}`",
e, stringify!($($pat)|+ if $cond))
}
};
( $e:expr , $($pat:pat_param)|+ => $arm:expr ) => {
( $e:expr_2021 , $($pat:pat_param)|+ => $arm:expr_2021 ) => {
match $e {
$($pat)|+ => $arm,
ref e => panic!("assertion failed: `{:?}` does not match `{}`",
e, stringify!($($pat)|+))
}
};
( $e:expr , $($pat:pat_param)|+ if $cond:expr => $arm:expr ) => {
( $e:expr_2021 , $($pat:pat_param)|+ if $cond:expr_2021 => $arm:expr_2021 ) => {
match $e {
$($pat)|+ if $cond => $arm,
ref e => panic!("assertion failed: `{:?}` does not match `{}`",
e, stringify!($($pat)|+ if $cond))
}
};
( $e:expr , $($pat:pat_param)|+ , $($arg:tt)* ) => {
( $e:expr_2021 , $($pat:pat_param)|+ , $($arg:tt)* ) => {
match $e {
$($pat)|+ => (),
ref e => panic!("assertion failed: `{:?}` does not match `{}`: {}",
e, stringify!($($pat)|+), format_args!($($arg)*))
}
};
( $e:expr , $($pat:pat_param)|+ if $cond:expr , $($arg:tt)* ) => {
( $e:expr_2021 , $($pat:pat_param)|+ if $cond:expr_2021 , $($arg:tt)* ) => {
match $e {
$($pat)|+ if $cond => (),
ref e => panic!("assertion failed: `{:?}` does not match `{}`: {}",
e, stringify!($($pat)|+ if $cond), format_args!($($arg)*))
}
};
( $e:expr , $($pat:pat_param)|+ => $arm:expr , $($arg:tt)* ) => {
( $e:expr_2021 , $($pat:pat_param)|+ => $arm:expr_2021 , $($arg:tt)* ) => {
match $e {
$($pat)|+ => $arm,
ref e => panic!("assertion failed: `{:?}` does not match `{}`: {}",
e, stringify!($($pat)|+), format_args!($($arg)*))
}
};
( $e:expr , $($pat:pat_param)|+ if $cond:expr => $arm:expr , $($arg:tt)* ) => {
( $e:expr_2021 , $($pat:pat_param)|+ if $cond:expr_2021 => $arm:expr_2021 , $($arg:tt)* ) => {
match $e {
$($pat)|+ if $cond => $arm,
ref e => panic!("assertion failed: `{:?}` does not match `{}`: {}",

2
crates/radicle/src/test/fixtures.rs
View File

@ -244,7 +244,7 @@ pub fn populate(repo: &git::raw::Repository, scale: usize) -> Vec<git::fmt::Qual
}
/// Generate random fixtures.
pub mod gen {
pub mod r#gen {
use super::*;
/// Generate a random string of the given length.