checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"

[[package]]

name = "errno"

version = "0.2.8"

source = "registry+https://github.com/rust-lang/crates.io-index"

]

[[package]]

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "rand 0.8.5",

]

[[package]]

version = "1.0.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "proc-macro2",

 "quote",

 "olpc-cjson",

 "once_cell",

 "pretty_assertions",

 "radicle-cob",

 "radicle-crdt",

 "radicle-crypto",

 "git2",

 "log",

 "petgraph",

 "radicle-crypto",

 "radicle-git-ext",

 "serde",

dependencies = [

 "fastrand",

 "num-traits",

 "radicle-crypto",

 "serde",

 "tempfile",

 "fastrand",

 "git-ref-format 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

 "multibase",

 "radicle-ssh",

 "serde",

 "sha2 0.10.6",

 "nakamoto-net",

 "nakamoto-net-poll",

 "nonempty 0.8.0",

 "radicle",

 "radicle-crypto",

 "scrypt",

fastrand = { version = "1.8.0", default-features = false }

git-ref-format = { version = "0.1", features = ["macro"] }

tempfile = { version = "3" }

[dev-dependencies.radicle-crypto]

path = "../radicle-crypto"

//! [RFC-0662]: https://github.com/radicle-dev/radicle-link/blob/master/docs/rfc/0662-collaborative-objects.adoc

#[cfg(test)]

#[cfg(test)]

#[macro_use(quickcheck)]

extern crate radicle_crypto as crypto;

extern crate radicle_git_ext as git_ext;

use std::{iter, marker::PhantomData};

use crate::{ObjectId, TypeName};

}

impl Arbitrary for TypeName {

        let rng = fastrand::Rng::with_seed(u64::arbitrary(g));

        let mut name: Vec<String> = Vec::new();

        for _ in 0..rng.usize(1..5) {

}

impl Arbitrary for ObjectId {

        let rng = fastrand::Rng::with_seed(u64::arbitrary(g));

        let bytes = iter::repeat_with(|| rng.u8(..))

            .take(20)

}

impl Arbitrary for Invalid<ObjectId> {

        let rng = fastrand::Rng::with_seed(u64::arbitrary(g));

        let value = iter::repeat_with(|| rng.alphanumeric())

            .take(rng.usize(21..50))

use crypto::test::signer::MockSigner;

use git_ref_format::{refname, Component, RefString};

use radicle_crypto::Signer;

use crate::{

}

fn gen<T: Arbitrary>(size: usize) -> T {

    T::arbitrary(&mut gen)

}

edition = "2021"

[features]

[dependencies]

fastrand = { version = "1.8.0", optional = true }

num-traits = { version = "0.2.15", default-features = false, features = ["std"] }

serde = { version = "1" }

[dependencies.radicle-crypto]

[dev-dependencies]

fastrand = { version = "1.8.0" }

radicle-crypto = { path = "../radicle-crypto", features = ["test"] }

tempfile = { version = "3" }

#[cfg(test)]

mod tests {

    use super::*;

    use crate::ord::Max;

#[cfg(test)]

mod tests {

    use crate::{test, Max, Min, Semilattice};

    #[quickcheck]

    fn prop_option_laws(a: Max<u8>, b: Max<u8>, c: Max<u8>) {

#[cfg(test)]

mod tests {

    use super::*;

    use crate::ord::Max;

#[cfg(test)]

mod tests {

    use super::*;

    use crate::Min;

#[cfg(test)]

mod tests {

    use super::*;

    #[quickcheck]

    fn prop_semilattice(

mod arbitrary {

    use super::*;

            Self::from(T::arbitrary(g))

        }

    }

            Self::from(T::arbitrary(g))

        }

    }

#[cfg(test)]

mod test {

    use super::*;

    use crate::test;

edition = "2021"

[features]

ssh = ["base64", "radicle-ssh", "ssh-key"]

[dependencies]

features = ["std", "encryption", "rand_core", "getrandom"]

optional = true

version = "1"

default-features = false

optional = true

[dev-dependencies]

fastrand = { version = "1.8.0", default-features = false }

tempfile = { version = "3.3.0" }

#[cfg(test)]

mod tests {

    use crate::PublicKey;

    use std::str::FromStr;

    #[quickcheck]

mod test {

    use std::sync::{Arc, Mutex};

    use super::{fmt, ExtendedSignature};

    use crate as crypto;

    use crate::{PublicKey, SecretKey};

    use radicle_ssh::agent::client::{AgentClient, ClientStream, Error};

    use radicle_ssh::encoding::*;

    }

    #[quickcheck]

        let mut buf = Buffer::default();

        sk.write(&mut buf);

        let mut cursor = buf.reader(0);

use crate::{hash, test::signer::MockSigner, KeyPair, PublicKey, SecretKey, Seed};

impl Arbitrary for MockSigner {

        let sk = KeyPair::from_seed(seed).sk;

        MockSigner::from(SecretKey::from(sk))

}

impl Arbitrary for PublicKey {

        let keypair = KeyPair::from_seed(seed);

        PublicKey(keypair.pk)

}

impl Arbitrary for hash::Digest {

        let bytes: Vec<u8> = Arbitrary::arbitrary(g);

        hash::Digest::new(&bytes)

    }

}

edition = "2021"

[features]

[dependencies]

anyhow = { version = "1" }

nakamoto-net = { version = "0.3.0" }

nakamoto-net-poll = { version = "0.3.0" }

nonempty = { version = "0.8.0", features = ["serialize"] }

sqlite = { version = "0.28.1" }

sqlite3-src = { version = "0.4.0", features = ["bundled"] } # Ensures static linking

scrypt = { version = "0.10.0", default-features = false }

[dev-dependencies]

radicle = { path = "../radicle", version = "*", features = ["test"] }

radicle-crypto = { path = "../radicle-crypto", version = "*", features = ["test"] }

#[cfg(test)]

mod test {

    use super::*;

    const MSG_HELLO: &[u8] = &[5, b'h', b'e', b'l', b'l', b'o'];

    const MSG_BYE: &[u8] = &[3, b'b', b'y', b'e'];

    use crate::crypto::test::signer::MockSigner;

    use crate::test::arbitrary;

    #[test]

    fn test_inventory_limit() {

use std::net;

use bloomy::BloomFilter;

use crate::crypto;

use crate::prelude::{BoundedVec, Id, NodeId, Refs, Timestamp};

pub use radicle::test::arbitrary::*;

impl Arbitrary for Filter {

        let size = *g

            .choose(&[FILTER_SIZE_S, FILTER_SIZE_M, FILTER_SIZE_L])

            .unwrap();

}

impl Arbitrary for Message {

        let type_id = g

            .choose(&[

                MessageType::InventoryAnnouncement,

                    timestamp: Timestamp::arbitrary(g),

                }

                .into(),

            }

            .into(),

            MessageType::RefsAnnouncement => Announcement {

                    timestamp: Timestamp::arbitrary(g),

                }

                .into(),

            }

            .into(),

            MessageType::NodeAnnouncement => {

                let message = NodeAnnouncement {

                    features: u64::arbitrary(g).into(),

                    timestamp: Timestamp::arbitrary(g),

                    addresses: Arbitrary::arbitrary(g),

                    nonce: u64::arbitrary(g),

                }

                .into();

                Announcement {

                    node: NodeId::arbitrary(g),

}

impl Arbitrary for Address {

        if bool::arbitrary(g) {

            Address::Ipv4 {

                ip: net::Ipv4Addr::from(u32::arbitrary(g)),

                port: u16::arbitrary(g),

            }

        } else {

            Address::Ipv6 {

                ip: net::Ipv6Addr::from(octets),

}

impl Arbitrary for ZeroBytes {

        ZeroBytes::new(u16::arbitrary(g))

    }

}

where

    T: Arbitrary + Eq,

{

        let mut v: Vec<T> = Arbitrary::arbitrary(g);

        v.truncate(N);

        v.try_into().expect("size within bounds")

            }

        }

    }

        .quickcheck(property as fn(MockStorage, MockStorage, MockStorage));

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::crypto::Unverified;

    use crate::storage::refs::SignedRefs;

    #[quickcheck]

    fn prop_u8(input: u8) {

    }

    #[quickcheck]

        if input.len() > u8::MAX as usize {

        }

        assert_eq!(deserialize::<String>(&serialize(&input)).unwrap(), input);

    }

    #[quickcheck]

    }

    #[quickcheck]

        assert_eq!(

            deserialize::<Signature>(&serialize(&signature)).unwrap(),

    }

    #[quickcheck]

        assert_eq!(deserialize::<git::Oid>(&serialize(&oid)).unwrap(), oid);

    }

#[cfg(test)]

mod tests {

    use super::*;

    use crate::deserializer::Deserializer;

    use crate::wire::{self, Encode};

            }

        }

            .quickcheck(property as fn(items: Vec<Message>));

    }

[features]

default = []

sql = ["sqlite"]

[dependencies]

version = "0"

default-features = false

version = "1"

default-features = false

optional = true

[dev-dependencies]

pretty_assertions = { version = "1.3.0" }

[dev-dependencies.radicle-crypto]

path = "../radicle-crypto"

    use radicle_crdt::test::{assert_laws, WeightedGenerator};

    use pretty_assertions::assert_eq;

    use super::*;

    use crate::cob::op::{Actor, ActorId};

    }

    impl<const N: usize> Arbitrary for Changes<N> {

            type State = (clock::Lamport, Vec<OpId>, Vec<Tag>);

            let author = ActorId::from([0; 32]);

            TestResult::passed()

        }

            .min_tests_passed(100)

            .quickcheck(property as fn(Changes<3>) -> TestResult);

    }

    use crate::crypto::test::signer::MockSigner;

    use pretty_assertions::assert_eq;

    use super::*;

    use crate as radicle;

    }

    impl<const N: usize> Arbitrary for Changes<N> {

            let author = ActorId::from([0; 32]);

            let rng = fastrand::Rng::with_seed(u64::arbitrary(g));

            let gen =

mod test {

    use super::*;

    use crate::crypto::PublicKey;

    use std::collections::HashSet;

    #[quickcheck]

    use crate::test::fixtures;

    use super::*;

    #[test]

    fn test_not_found() {

#[cfg(test)]

mod tests {

    use super::*;

    #[quickcheck]

    fn prop_canonical_roundtrip(refs: Refs) {

use crypto::test::signer::MockSigner;

use crypto::{PublicKey, Signer, Unverified, Verified};

use nonempty::NonEmpty;

use crate::collections::HashMap;

use crate::git;

pub fn set<T: Eq + Hash + Arbitrary>(range: impl RangeBounds<usize>) -> HashSet<T> {

    let size = fastrand::usize(range);

    let mut set = HashSet::with_capacity(size);

    while set.len() < size {

        set.insert(T::arbitrary(&mut g));

pub fn vec<T: Eq + Arbitrary>(size: usize) -> Vec<T> {

    let mut vec = Vec::with_capacity(size);

    for _ in 0..vec.capacity() {

        vec.push(T::arbitrary(&mut g));

}

pub fn gen<T: Arbitrary>(size: usize) -> T {

    T::arbitrary(&mut gen)

}

impl Arbitrary for storage::Remotes<crypto::Verified> {

        let remotes: HashMap<storage::RemoteId, storage::Remote<crypto::Verified>> =

            Arbitrary::arbitrary(g);

}

impl Arbitrary for Did {

        Self::from(PublicKey::arbitrary(g))

    }

}

impl Arbitrary for Delegate {

        Self {

            name: String::arbitrary(g),

            id: Did::arbitrary(g),

}

impl Arbitrary for Doc<Unverified> {

        let name = String::arbitrary(g);

        let description = String::arbitrary(g);

        let default_branch = git::RefString::try_from(String::arbitrary(g)).unwrap();

}

impl Arbitrary for Doc<Verified> {

        let rng = fastrand::Rng::with_seed(u64::arbitrary(g));

        let name = iter::repeat_with(|| rng.alphanumeric())

            .take(rng.usize(1..16))

}

impl Arbitrary for SignedRefs<Unverified> {

        let refs = Refs::arbitrary(g);

        Self::new(refs, signature)

}

impl Arbitrary for Refs {

        let mut refs: BTreeMap<git::RefString, storage::Oid> = BTreeMap::new();

        let mut bytes: [u8; 20] = [0; 20];

        let names = &[

}

impl Arbitrary for MockStorage {

        let inventory = Arbitrary::arbitrary(g);

        MockStorage::new(inventory)

    }

}

impl Arbitrary for storage::Remote<crypto::Verified> {

        let refs = Refs::arbitrary(g);

        let signer = MockSigner::arbitrary(g);

        let signed = refs.signed(&signer).unwrap();

}

impl Arbitrary for Id {

        let oid = git::Oid::try_from(bytes.as_slice()).unwrap();

        Id::from(oid)