aboutsummaryrefslogtreecommitdiff
path: root/src/rust
diff options
context:
space:
mode:
Diffstat (limited to 'src/rust')
-rw-r--r--src/rust/protover/protover.rs214
-rw-r--r--src/rust/protover/tests/protover.rs355
2 files changed, 285 insertions, 284 deletions
diff --git a/src/rust/protover/protover.rs b/src/rust/protover/protover.rs
index 247166c23a..96e9dd582b 100644
--- a/src/rust/protover/protover.rs
+++ b/src/rust/protover/protover.rs
@@ -659,154 +659,118 @@ mod test {
use super::*;
+ macro_rules! assert_protoentry_is_parseable {
+ ($e:expr) => (
+ let protoentry: Result<ProtoEntry, ProtoverError> = $e.parse();
+
+ assert!(protoentry.is_ok(), format!("{:?}", protoentry.err()));
+ )
+ }
+
+ macro_rules! assert_protoentry_is_unparseable {
+ ($e:expr) => (
+ let protoentry: Result<ProtoEntry, ProtoverError> = $e.parse();
+
+ assert!(protoentry.is_err());
+ )
+ }
+
#[test]
- fn test_versions_from_version_string() {
- use std::collections::HashSet;
+ fn test_protoentry_from_str_multiple_protocols_multiple_versions() {
+ assert_protoentry_is_parseable!("Cons=3-4 Link=1,3-5");
+ }
- use super::Versions;
+ #[test]
+ fn test_protoentry_from_str_empty() {
+ assert_protoentry_is_unparseable!("");
+ }
- assert_eq!(Err("invalid protocol entry"), Versions::from_version_string("a,b"));
- assert_eq!(Err("invalid protocol entry"), Versions::from_version_string("1,!"));
+ #[test]
+ fn test_protoentry_from_str_single_protocol_single_version() {
+ assert_protoentry_is_parseable!("HSDir=1");
+ }
- {
- let mut versions: HashSet<Version> = HashSet::new();
- versions.insert(1);
- assert_eq!(versions, Versions::from_version_string("1").unwrap().0);
- }
- {
- let mut versions: HashSet<Version> = HashSet::new();
- versions.insert(1);
- versions.insert(2);
- assert_eq!(versions, Versions::from_version_string("1,2").unwrap().0);
- }
- {
- let mut versions: HashSet<Version> = HashSet::new();
- versions.insert(1);
- versions.insert(2);
- versions.insert(3);
- assert_eq!(versions, Versions::from_version_string("1-3").unwrap().0);
- }
- {
- let mut versions: HashSet<Version> = HashSet::new();
- versions.insert(1);
- versions.insert(2);
- versions.insert(5);
- assert_eq!(versions, Versions::from_version_string("1-2,5").unwrap().0);
- }
- {
- let mut versions: HashSet<Version> = HashSet::new();
- versions.insert(1);
- versions.insert(3);
- versions.insert(4);
- versions.insert(5);
- assert_eq!(versions, Versions::from_version_string("1,3-5").unwrap().0);
- }
+ #[test]
+ fn test_protoentry_from_str_unknown_protocol() {
+ assert_protoentry_is_unparseable!("Ducks=5-7,8");
}
#[test]
- fn test_contains_only_supported_protocols() {
- use super::contains_only_supported_protocols;
-
- assert_eq!(false, contains_only_supported_protocols(""));
- assert_eq!(true, contains_only_supported_protocols("Cons="));
- assert_eq!(true, contains_only_supported_protocols("Cons=1"));
- assert_eq!(false, contains_only_supported_protocols("Cons=0"));
- assert_eq!(false, contains_only_supported_protocols("Cons=0-1"));
- assert_eq!(false, contains_only_supported_protocols("Cons=5"));
- assert_eq!(false, contains_only_supported_protocols("Cons=1-5"));
- assert_eq!(false, contains_only_supported_protocols("Cons=1,5"));
- assert_eq!(false, contains_only_supported_protocols("Cons=5,6"));
- assert_eq!(false, contains_only_supported_protocols("Cons=1,5,6"));
- assert_eq!(true, contains_only_supported_protocols("Cons=1,2"));
- assert_eq!(true, contains_only_supported_protocols("Cons=1-2"));
+ fn test_protoentry_from_str_too_many_versions() {
+ assert_protoentry_is_unparseable!("Desc=1-65537");
}
#[test]
- fn test_find_range() {
- use super::find_range;
+ fn test_protoentry_from_str_() {
+ assert_protoentry_is_unparseable!("");
+ }
- assert_eq!((false, 0), find_range(&vec![]));
- assert_eq!((false, 1), find_range(&vec![1]));
- assert_eq!((true, 2), find_range(&vec![1, 2]));
- assert_eq!((true, 3), find_range(&vec![1, 2, 3]));
- assert_eq!((true, 3), find_range(&vec![1, 2, 3, 5]));
+ #[test]
+ fn test_protoentry_all_supported_single_protocol_single_version() {
+ let protocol: UnvalidatedProtoEntry = "Cons=1".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocol.all_supported();
+ assert_eq!(true, unsupported.is_none());
}
#[test]
- fn test_expand_version_range() {
- use super::expand_version_range;
-
- assert_eq!(Err("version string empty"), expand_version_range(""));
- assert_eq!(Ok(1..3), expand_version_range("1-2"));
- assert_eq!(Ok(1..5), expand_version_range("1-4"));
- assert_eq!(
- Err("cannot parse protocol range lower bound"),
- expand_version_range("a")
- );
- assert_eq!(
- Err("cannot parse protocol range upper bound"),
- expand_version_range("1-a")
- );
- assert_eq!(Ok(1000..66536), expand_version_range("1000-66535"));
- assert_eq!(Err("Too many protocols in expanded range"),
- expand_version_range("1000-66536"));
+ fn test_protoentry_all_supported_multiple_protocol_multiple_versions() {
+ let protocols: UnvalidatedProtoEntry = "Link=3-4 Desc=2".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_none());
}
#[test]
- fn test_contract_protocol_list() {
- use std::collections::HashSet;
- use super::contract_protocol_list;
+ fn test_protoentry_all_supported_three_values() {
+ let protocols: UnvalidatedProtoEntry = "LinkAuth=1 Microdesc=1-2 Relay=2".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_none());
+ }
- {
- let mut versions = HashSet::<Version>::new();
- assert_eq!(String::from(""), contract_protocol_list(&versions));
+ #[test]
+ fn test_protoentry_all_supported_unknown_protocol() {
+ let protocols: UnvalidatedProtoEntry = "Wombat=9".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_some());
+ assert_eq!("Wombat=9", &unsupported.unwrap().to_string());
+ }
- versions.insert(1);
- assert_eq!(String::from("1"), contract_protocol_list(&versions));
+ #[test]
+ fn test_protoentry_all_supported_unsupported_high_version() {
+ let protocols: UnvalidatedProtoEntry = "HSDir=12-100".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_some());
+ assert_eq!("HSDir=12-100", &unsupported.unwrap().to_string());
+ }
- versions.insert(2);
- assert_eq!(String::from("1-2"), contract_protocol_list(&versions));
- }
+ #[test]
+ fn test_protoentry_all_supported_unsupported_low_version() {
+ let protocols: UnvalidatedProtoEntry = "Cons=0-1".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_some());
+ assert_eq!("Cons=0", &unsupported.unwrap().to_string());
+ }
- {
- let mut versions = HashSet::<Version>::new();
- versions.insert(1);
- versions.insert(3);
- assert_eq!(String::from("1,3"), contract_protocol_list(&versions));
- }
+ #[test]
+ fn test_contract_protocol_list() {
+ let mut versions = "";
+ assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
- {
- let mut versions = HashSet::<Version>::new();
- versions.insert(1);
- versions.insert(2);
- versions.insert(3);
- versions.insert(4);
- assert_eq!(String::from("1-4"), contract_protocol_list(&versions));
- }
+ versions = "1";
+ assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
- {
- let mut versions = HashSet::<Version>::new();
- versions.insert(1);
- versions.insert(3);
- versions.insert(5);
- versions.insert(6);
- versions.insert(7);
- assert_eq!(
- String::from("1,3,5-7"),
- contract_protocol_list(&versions)
- );
- }
+ versions = "1-2";
+ assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
- {
- let mut versions = HashSet::<Version>::new();
- versions.insert(1);
- versions.insert(2);
- versions.insert(3);
- versions.insert(500);
- assert_eq!(
- String::from("1-3,500"),
- contract_protocol_list(&versions)
- );
- }
+ versions = "1,3";
+ assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+
+ versions = "1-4";
+ assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+
+ versions = "1,3,5-7";
+ assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
+
+ versions = "1-3,500";
+ assert_eq!(String::from(versions), ProtoSet::from_str(&versions).unwrap().to_string());
}
}
diff --git a/src/rust/protover/tests/protover.rs b/src/rust/protover/tests/protover.rs
index f4e394b3e2..9f8b5a443a 100644
--- a/src/rust/protover/tests/protover.rs
+++ b/src/rust/protover/tests/protover.rs
@@ -3,289 +3,326 @@
extern crate protover;
+use protover::ProtoEntry;
+use protover::ProtoverVote;
+use protover::UnvalidatedProtoEntry;
+
#[test]
-fn parse_protocol_list_with_single_proto_and_single_version() {
- let protocol = "Cons=1";
- let (is_supported, unsupported) = protover::all_supported(protocol);
- assert_eq!(true, is_supported);
- assert_eq!("", &unsupported);
+fn parse_protocol_with_single_proto_and_single_version() {
+ let _: ProtoEntry = "Cons=1".parse().unwrap();
}
#[test]
-fn parse_protocol_list_with_single_protocol_and_multiple_versions() {
- let protocol = "Cons=1-2";
- let (is_supported, unsupported) = protover::all_supported(protocol);
- assert_eq!(true, is_supported);
- assert_eq!("", &unsupported);
+fn parse_protocol_with_single_protocol_and_multiple_versions() {
+ let _: ProtoEntry = "Cons=1-2".parse().unwrap();
}
#[test]
-fn parse_protocol_list_with_different_single_protocol_and_single_version() {
- let protocol = "HSDir=1";
- let (is_supported, unsupported) = protover::all_supported(protocol);
- assert_eq!(true, is_supported);
- assert_eq!("", &unsupported);
+fn parse_protocol_with_different_single_protocol_and_single_version() {
+ let _: ProtoEntry = "HSDir=1".parse().unwrap();
}
#[test]
-fn parse_protocol_list_with_single_protocol_and_supported_version() {
- let protocol = "Desc=2";
- let (is_supported, unsupported) = protover::all_supported(protocol);
- assert_eq!(true, is_supported);
- assert_eq!("", &unsupported);
+fn parse_protocol_with_single_protocol_and_supported_version() {
+ let _: ProtoEntry = "Desc=2".parse().unwrap();
}
#[test]
-fn parse_protocol_list_with_two_protocols_and_single_version() {
- let protocols = "Cons=1 HSDir=1";
- let (is_supported, unsupported) = protover::all_supported(protocols);
- assert_eq!(true, is_supported);
- assert_eq!("", &unsupported);
+fn parse_protocol_with_two_protocols_and_single_version() {
+ let _: ProtoEntry = "Cons=1 HSDir=1".parse().unwrap();
}
-
#[test]
-fn parse_protocol_list_with_single_protocol_and_two_nonsequential_versions() {
- let protocol = "Desc=1,2";
- let (is_supported, unsupported) = protover::all_supported(protocol);
- assert_eq!(true, is_supported);
- assert_eq!("", &unsupported);
+fn parse_protocol_with_single_protocol_and_two_sequential_versions() {
+ let _: ProtoEntry = "Desc=1-2".parse().unwrap();
}
+#[test]
+fn parse_protocol_with_single_protocol_and_protocol_range() {
+ let _: ProtoEntry = "Link=1-4".parse().unwrap();
+}
#[test]
-fn parse_protocol_list_with_single_protocol_and_two_sequential_versions() {
- let protocol = "Desc=1-2";
- let (is_supported, unsupported) = protover::all_supported(protocol);
- assert_eq!(true, is_supported);
- assert_eq!("", &unsupported);
+fn parse_protocol_with_single_protocol_and_protocol_set() {
+ let _: ProtoEntry = "Link=3-4 Desc=2".parse().unwrap();
}
#[test]
-fn parse_protocol_list_with_single_protocol_and_protocol_range_returns_set() {
- let protocol = "Link=1-4";
- let (is_supported, unsupported) = protover::all_supported(protocol);
- assert_eq!(true, is_supported);
- assert_eq!("", &unsupported);
+fn protocol_all_supported_with_single_protocol_and_protocol_set() {
+ let protocols: UnvalidatedProtoEntry = "Link=3-4 Desc=2".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_none());
}
#[test]
-fn parse_protocol_list_with_single_protocol_and_protocol_set() {
- let protocols = "Link=3-4 Desc=2";
- let (is_supported, unsupported) = protover::all_supported(protocols);
- assert_eq!(true, is_supported);
- assert_eq!("", &unsupported);
+fn protocol_all_supported_with_two_values() {
+ let protocols: UnvalidatedProtoEntry = "Microdesc=1-2 Relay=2".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_none());
}
#[test]
-fn protover_all_supported_with_two_values() {
- let protocols = "Microdesc=1-2 Relay=2";
- let (is_supported, unsupported) = protover::all_supported(protocols);
- assert_eq!("", &unsupported);
- assert_eq!(true, is_supported);
+fn protocol_all_supported_with_one_value() {
+ let protocols: UnvalidatedProtoEntry = "Microdesc=1-2".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_none());
}
#[test]
-fn protover_all_supported_with_one_value() {
- let protocols = "Microdesc=1-2";
- let (is_supported, unsupported) = protover::all_supported(protocols);
- assert_eq!("", &unsupported);
- assert_eq!(true, is_supported);
+#[should_panic]
+fn parse_protocol_unvalidated_with_empty() {
+ let _: UnvalidatedProtoEntry = "".parse().unwrap();
}
#[test]
-fn protover_all_supported_with_empty() {
- let protocols = "";
- let (is_supported, unsupported) = protover::all_supported(protocols);
- assert_eq!(true, is_supported);
- assert_eq!("", &unsupported);
+#[should_panic]
+fn parse_protocol_validated_with_empty() {
+ let _: UnvalidatedProtoEntry = "".parse().unwrap();
}
#[test]
-fn protover_all_supported_with_three_values() {
- let protocols = "LinkAuth=1 Microdesc=1-2 Relay=2";
- let (is_supported, unsupported) = protover::all_supported(protocols);
- assert_eq!("", &unsupported);
- assert_eq!(true, is_supported);
+fn protocol_all_supported_with_three_values() {
+ let protocols: UnvalidatedProtoEntry = "LinkAuth=1 Microdesc=1-2 Relay=2".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_none());
}
#[test]
-fn protover_all_supported_with_unsupported_protocol() {
- let protocols = "Wombat=9";
- let (is_supported, unsupported) = protover::all_supported(protocols);
- assert_eq!(false, is_supported);
- assert_eq!("Wombat=9", &unsupported);
+fn protocol_all_supported_with_unsupported_protocol() {
+ let protocols: UnvalidatedProtoEntry = "Wombat=9".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_some());
+ assert_eq!("Wombat=9", &unsupported.unwrap().to_string());
}
#[test]
-fn protover_all_supported_with_unsupported_versions() {
- let protocols = "Link=3-999";
- let (is_supported, unsupported) = protover::all_supported(protocols);
- assert_eq!(false, is_supported);
- assert_eq!("Link=3-999", &unsupported);
+fn protocol_all_supported_with_unsupported_versions() {
+ let protocols: UnvalidatedProtoEntry = "Link=3-999".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_some());
+ assert_eq!("Link=6-999", &unsupported.unwrap().to_string());
}
#[test]
-fn protover_all_supported_with_unsupported_low_version() {
- let protocols = "Cons=0-1";
- let (is_supported, unsupported) = protover::all_supported(protocols);
- assert_eq!(false, is_supported);
- assert_eq!("Cons=0-1", &unsupported);
+fn protocol_all_supported_with_unsupported_low_version() {
+ let protocols: UnvalidatedProtoEntry = "Cons=0-1".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_some());
+ assert_eq!("Cons=0", &unsupported.unwrap().to_string());
}
#[test]
-fn protover_all_supported_with_unsupported_high_version() {
- let protocols = "Cons=1-3";
- let (is_supported, unsupported) = protover::all_supported(protocols);
- assert_eq!(false, is_supported);
- assert_eq!("Cons=1-3", &unsupported);
+fn protocol_all_supported_with_unsupported_high_version() {
+ let protocols: UnvalidatedProtoEntry = "Cons=1-2,999".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_some());
+ assert_eq!("Cons=999", &unsupported.unwrap().to_string());
}
#[test]
-fn protover_all_supported_with_mix_of_supported_and_unsupproted() {
- let protocols = "Link=3-4 Wombat=9";
- let (is_supported, unsupported) = protover::all_supported(protocols);
- assert_eq!(false, is_supported);
- assert_eq!("Wombat=9", &unsupported);
+fn protocol_all_supported_with_mix_of_supported_and_unsupproted() {
+ let protocols: UnvalidatedProtoEntry = "Link=3-4 Wombat=9".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_some());
+ assert_eq!("Wombat=9", &unsupported.unwrap().to_string());
}
#[test]
fn protover_string_supports_protocol_returns_true_for_single_supported() {
- let protocols = "Link=3-4 Cons=1";
- let is_supported = protover::protover_string_supports_protocol(
- protocols,
- protover::Proto::Cons,
- 1,
- );
+ let protocols: UnvalidatedProtoEntry = "Link=3-4 Cons=1".parse().unwrap();
+ let is_supported = protocols.supports_protocol(&protover::Protocol::Cons.into(), &1);
assert_eq!(true, is_supported);
}
#[test]
fn protover_string_supports_protocol_returns_false_for_single_unsupported() {
- let protocols = "Link=3-4 Cons=1";
- let is_supported = protover::protover_string_supports_protocol(
- protocols,
- protover::Proto::Cons,
- 2,
- );
+ let protocols: UnvalidatedProtoEntry = "Link=3-4 Cons=1".parse().unwrap();
+ let is_supported = protocols.supports_protocol(&protover::Protocol::Cons.into(), &2);
assert_eq!(false, is_supported);
}
#[test]
fn protover_string_supports_protocol_returns_false_for_unsupported() {
- let protocols = "Link=3-4";
- let is_supported = protover::protover_string_supports_protocol(
- protocols,
- protover::Proto::Cons,
- 2,
- );
+ let protocols: UnvalidatedProtoEntry = "Link=3-4".parse().unwrap();
+ let is_supported = protocols.supports_protocol(&protover::Protocol::Cons.into(), &2);
assert_eq!(false, is_supported);
}
#[test]
-fn protover_all_supported_with_unexpected_characters() {
- let protocols = "Cons=*-%";
- let (is_supported, unsupported) = protover::all_supported(protocols);
- assert_eq!(false, is_supported);
- assert_eq!("Cons=*-%", &unsupported);
+#[should_panic]
+fn parse_protocol_with_unexpected_characters() {
+ let _: UnvalidatedProtoEntry = "Cons=*-%".parse().unwrap();
}
#[test]
+#[should_panic]
fn protover_compute_vote_returns_empty_for_empty_string() {
- let protocols = vec![String::from("")];
- let listed = protover::compute_vote(protocols, 1);
- assert_eq!("", listed);
+ let protocols: &[UnvalidatedProtoEntry] = &["".parse().unwrap()];
+ let listed = ProtoverVote::compute(protocols, &1);
+ assert_eq!("", listed.to_string());
}
#[test]
fn protover_compute_vote_returns_single_protocol_for_matching() {
- let protocols = vec![String::from("Cons=1")];
- let listed = protover::compute_vote(protocols, 1);
- assert_eq!("Cons=1", listed);
+ let protocols: &[UnvalidatedProtoEntry] = &["Cons=1".parse().unwrap()];
+ let listed = ProtoverVote::compute(protocols, &1);
+ assert_eq!("Cons=1", listed.to_string());
}
#[test]
fn protover_compute_vote_returns_two_protocols_for_two_matching() {
- let protocols = vec![String::from("Link=1 Cons=1")];
- let listed = protover::compute_vote(protocols, 1);
- assert_eq!("Cons=1 Link=1", listed);
+ let protocols: &[UnvalidatedProtoEntry] = &["Link=1 Cons=1".parse().unwrap()];
+ let listed = ProtoverVote::compute(protocols, &1);
+ assert_eq!("Cons=1 Link=1", listed.to_string());
}
#[test]
fn protover_compute_vote_returns_one_protocol_when_one_out_of_two_matches() {
- let protocols = vec![String::from("Cons=1 Link=2"), String::from("Cons=1")];
- let listed = protover::compute_vote(protocols, 2);
- assert_eq!("Cons=1", listed);
+ let protocols: &[UnvalidatedProtoEntry] = &["Cons=1 Link=2".parse().unwrap(), "Cons=1".parse().unwrap()];
+ let listed = ProtoverVote::compute(protocols, &2);
+ assert_eq!("Cons=1", listed.to_string());
}
#[test]
fn protover_compute_vote_returns_protocols_that_it_doesnt_currently_support() {
- let protocols = vec![String::from("Foo=1 Cons=2"), String::from("Bar=1")];
- let listed = protover::compute_vote(protocols, 1);
- assert_eq!("Bar=1 Cons=2 Foo=1", listed);
+ let protocols: &[UnvalidatedProtoEntry] = &["Foo=1 Cons=2".parse().unwrap(), "Bar=1".parse().unwrap()];
+ let listed = ProtoverVote::compute(protocols, &1);
+ assert_eq!("Bar=1 Cons=2 Foo=1", listed.to_string());
}
#[test]
fn protover_compute_vote_returns_matching_for_mix() {
- let protocols = vec![String::from("Link=1-10,500 Cons=1,3-7,8")];
- let listed = protover::compute_vote(protocols, 1);
- assert_eq!("Cons=1,3-8 Link=1-10,500", listed);
+ let protocols: &[UnvalidatedProtoEntry] = &["Link=1-10,500 Cons=1,3-7,8".parse().unwrap()];
+ let listed = ProtoverVote::compute(protocols, &1);
+ assert_eq!("Cons=1,3-8 Link=1-10,500", listed.to_string());
}
#[test]
fn protover_compute_vote_returns_matching_for_longer_mix() {
- let protocols = vec![
- String::from("Desc=1-10,500 Cons=1,3-7,8"),
- String::from("Link=123-456,78 Cons=2-6,8 Desc=9"),
+ let protocols: &[UnvalidatedProtoEntry] = &[
+ "Desc=1-10,500 Cons=1,3-7,8".parse().unwrap(),
+ "Link=123-456,78 Cons=2-6,8 Desc=9".parse().unwrap(),
];
- let listed = protover::compute_vote(protocols, 1);
- assert_eq!("Cons=1-8 Desc=1-10,500 Link=78,123-456", listed);
+ let listed = ProtoverVote::compute(protocols, &1);
+ assert_eq!("Cons=1-8 Desc=1-10,500 Link=78,123-456", listed.to_string());
}
#[test]
fn protover_compute_vote_returns_matching_for_longer_mix_with_threshold_two() {
- let protocols = vec![
- String::from("Desc=1-10,500 Cons=1,3-7,8"),
- String::from("Link=123-456,78 Cons=2-6,8 Desc=9"),
+ let protocols: &[UnvalidatedProtoEntry] = &[
+ "Desc=1-10,500 Cons=1,3-7,8".parse().unwrap(),
+ "Link=123-456,78 Cons=2-6,8 Desc=9".parse().unwrap(),
];
- let listed = protover::compute_vote(protocols, 2);
- assert_eq!("Cons=3-6,8 Desc=9", listed);
+ let listed = ProtoverVote::compute(protocols, &2);
+ assert_eq!("Cons=3-6,8 Desc=9", listed.to_string());
}
#[test]
fn protover_compute_vote_handles_duplicated_versions() {
- let protocols = vec![String::from("Cons=1"), String::from("Cons=1")];
- assert_eq!("Cons=1", protover::compute_vote(protocols, 2));
+ let protocols: &[UnvalidatedProtoEntry] = &["Cons=1".parse().unwrap(), "Cons=1".parse().unwrap()];
+ assert_eq!("Cons=1", ProtoverVote::compute(protocols, &2).to_string());
- let protocols = vec![String::from("Cons=1-2"), String::from("Cons=1-2")];
- assert_eq!("Cons=1-2", protover::compute_vote(protocols, 2));
+ let protocols: &[UnvalidatedProtoEntry] = &["Cons=1-2".parse().unwrap(), "Cons=1-2".parse().unwrap()];
+ assert_eq!("Cons=1-2", ProtoverVote::compute(protocols, &2).to_string());
}
#[test]
fn protover_compute_vote_handles_invalid_proto_entries() {
- let protocols = vec![
- String::from("Cons=1"),
- String::from("Cons=1"),
- String::from("Link=a"),
+ let protocols: &[UnvalidatedProtoEntry] = &[
+ "Cons=1".parse().unwrap(),
+ "Cons=1".parse().unwrap(),
+ "Dinosaur=1".parse().unwrap(),
];
- assert_eq!("Cons=1", protover::compute_vote(protocols, 2));
+ assert_eq!("Cons=1", ProtoverVote::compute(protocols, &2).to_string());
+}
- let protocols = vec![
- String::from("Cons=1"),
- String::from("Cons=1"),
- String::from("Link=1-%"),
- ];
- assert_eq!("Cons=1", protover::compute_vote(protocols, 2));
+#[test]
+fn parse_protocol_with_single_protocol_and_two_nonsequential_versions() {
+ let _: ProtoEntry = "Desc=1,2".parse().unwrap();
}
#[test]
fn protover_is_supported_here_returns_true_for_supported_protocol() {
- assert_eq!(true, protover::is_supported_here(protover::Proto::Cons, 1));
+ assert_eq!(true, protover::is_supported_here(&protover::Protocol::Cons, &1));
}
#[test]
fn protover_is_supported_here_returns_false_for_unsupported_protocol() {
- assert_eq!(false, protover::is_supported_here(protover::Proto::Cons, 5));
+ assert_eq!(false, protover::is_supported_here(&protover::Protocol::Cons, &5));
+}
+
+#[test]
+fn protocol_all_supported_with_single_proto_and_single_version() {
+ let protocol: UnvalidatedProtoEntry = "Cons=1".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocol.all_supported();
+ assert_eq!(true, unsupported.is_none());
+}
+
+#[test]
+fn protocol_all_supported_with_single_protocol_and_multiple_versions() {
+ let protocol: UnvalidatedProtoEntry = "Cons=1-2".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocol.all_supported();
+ assert_eq!(true, unsupported.is_none());
+}
+
+#[test]
+fn protocol_all_supported_with_different_single_protocol_and_single_version() {
+ let protocol: UnvalidatedProtoEntry = "HSDir=1".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocol.all_supported();
+ assert_eq!(true, unsupported.is_none());
+}
+
+#[test]
+fn protocol_all_supported_with_single_protocol_and_supported_version() {
+ let protocol: UnvalidatedProtoEntry = "Desc=2".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocol.all_supported();
+ assert_eq!(true, unsupported.is_none());
+}
+
+#[test]
+fn protocol_all_supported_with_two_protocols_and_single_version() {
+ let protocols: UnvalidatedProtoEntry = "Cons=1 HSDir=1".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocols.all_supported();
+ assert_eq!(true, unsupported.is_none());
+}
+
+#[test]
+fn protocol_all_supported_with_single_protocol_and_two_nonsequential_versions() {
+ let protocol: UnvalidatedProtoEntry = "Desc=1,2".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocol.all_supported();
+ assert_eq!(true, unsupported.is_none());
+}
+
+#[test]
+fn protocol_all_supported_with_single_protocol_and_two_sequential_versions() {
+ let protocol: UnvalidatedProtoEntry = "Desc=1-2".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocol.all_supported();
+ assert_eq!(true, unsupported.is_none());
+}
+
+#[test]
+fn protocol_all_supported_with_single_protocol_and_protocol_range() {
+ let protocol: UnvalidatedProtoEntry = "Link=1-4".parse().unwrap();
+ let unsupported: Option<UnvalidatedProtoEntry> = protocol.all_supported();
+ assert_eq!(true, unsupported.is_none());
+}
+
+// By allowing us to add to votes, the C implementation allows us to
+// exceed the limit.
+#[test]
+fn protover_compute_vote_may_exceed_limit() {
+ let proto1: UnvalidatedProtoEntry = "Sleen=1-65535".parse().unwrap();
+ let proto2: UnvalidatedProtoEntry = "Sleen=100000".parse().unwrap();
+
+ let _result: UnvalidatedProtoEntry = ProtoverVote::compute(&[proto1, proto2], &1);
+}
+
+#[test]
+fn protover_all_supported_should_include_version_we_actually_do_support() {
+ let proto: UnvalidatedProtoEntry = "Link=3-999".parse().unwrap();
+ let _result: String = proto.all_supported().unwrap().to_string();
+
+ assert_eq!(_result, "Link=3-999".to_string());
}
7apu2bq3rhoylwmucxizk54afw5jyda7pho4j5zdcqpwkufke7zdzwad.onion