itsscb/cargo
1
0
Fork 0
mirror of https://github.com/rust-lang/cargo.git synced 2025-09-28 11:20:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

dont have arg if it is all ways pkg_id("root")

Browse Source
This commit is contained in:
Eh2406 2019-06-19 11:59:33 -04:00
parent 5a30d17238
commit f4bd3a4c6e
2 changed files with 57 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
crates/resolver-tests/src/lib.rs
View File

@ -17,16 +17,11 @@ use proptest::sample::Index;
use proptest::string::string_regex;
use varisat::{self, ExtendFormula};
pub fn resolve(
pkg: PackageId,
deps: Vec<Dependency>,
registry: &[Summary],
) -> CargoResult<Vec<PackageId>> {
resolve_with_config(pkg, deps, registry, None)
pub fn resolve(deps: Vec<Dependency>, registry: &[Summary]) -> CargoResult<Vec<PackageId>> {
resolve_with_config(deps, registry, None)
}
pub fn resolve_and_validated(
pkg: PackageId,
deps: Vec<Dependency>,
registry: &[Summary],
sat_resolve: Option<&mut SatResolve>,
@ -36,11 +31,11 @@ pub fn resolve_and_validated(
} else {
SatResolve::new(registry).sat_resolve(&deps)
};
let resolve = resolve_with_config_raw(pkg, deps, registry, None);
let resolve = resolve_with_config_raw(deps, registry, None);
assert_eq!(resolve.is_ok(), should_resolve);
let resolve = resolve?;
let mut stack = vec![pkg];
let mut stack = vec![pkg_id("root")];
let mut used = HashSet::new();
let mut links = HashSet::new();
while let Some(p) = stack.pop() {
@ -92,17 +87,15 @@ pub fn resolve_and_validated(
}
pub fn resolve_with_config(
pkg: PackageId,
deps: Vec<Dependency>,
registry: &[Summary],
config: Option<&Config>,
) -> CargoResult<Vec<PackageId>> {
let resolve = resolve_with_config_raw(pkg, deps, registry, config)?;
let resolve = resolve_with_config_raw(deps, registry, config)?;
Ok(resolve.sort())
}
pub fn resolve_with_config_raw(
pkg: PackageId,
deps: Vec<Dependency>,
registry: &[Summary],
config: Option<&Config>,
@ -158,7 +151,7 @@ pub fn resolve_with_config_raw(
used: HashSet::new(),
};
let summary = Summary::new(
pkg,
pkg_id("root"),
deps,
&BTreeMap::<String, Vec<String>>::new(),
None::<String>,
@ -856,7 +849,6 @@ fn meta_test_deep_trees_from_strategy() {
let reg = registry(input.clone());
for this in input.iter().rev().take(10) {
let res = resolve(
pkg_id("root"),
vec![dep_req(&this.name(), &format!("={}", this.version()))],
&reg,
);
@ -898,7 +890,6 @@ fn meta_test_multiple_versions_strategy() {
let reg = registry(input.clone());
for this in input.iter().rev().take(10) {
let res = resolve(
pkg_id("root"),
vec![dep_req(&this.name(), &format!("={}", this.version()))],
&reg,
);

162
crates/resolver-tests/tests/resolve.rs
View File

@ -6,8 +6,8 @@ use cargo::util::Config;
use resolver_tests::{
assert_contains, assert_same, dep, dep_kind, dep_loc, dep_req, dep_req_kind, loc_names, names,
pkg, pkg_id, pkg_loc, registry, registry_strategy, remove_dep, resolve,
resolve_and_validated, resolve_with_config, PrettyPrintRegistry, SatResolve, ToDep, ToPkgId,
pkg, pkg_id, pkg_loc, registry, registry_strategy, remove_dep, resolve, resolve_and_validated,
resolve_with_config, PrettyPrintRegistry, SatResolve, ToDep, ToPkgId,
};
use proptest::prelude::*;
@ -45,7 +45,6 @@ proptest! {
// So we try some of the most complicated.
for this in input.iter().rev().take(20) {
let _ = resolve_and_validated(
pkg_id("root"),
vec![dep_req(&this.name(), &format!("={}", this.version()))],
&reg,
Some(&mut sat_resolve),
@ -82,13 +81,11 @@ proptest! {
// minimal-versions change what order the candidates
// are tried but not the existence of a solution
let res = resolve(
pkg_id("root"),
vec![dep_req(&this.name(), &format!("={}", this.version()))],
&reg,
);
let mres = resolve_with_config(
pkg_id("root"),
vec![dep_req(&this.name(), &format!("={}", this.version()))],
&reg,
Some(&config),
@ -128,13 +125,11 @@ proptest! {
// So we try some of the most complicated.
for this in input.iter().rev().take(10) {
if resolve(
pkg_id("root"),
vec![dep_req(&this.name(), &format!("={}", this.version()))],
&reg,
).is_ok() {
prop_assert!(
resolve(
pkg_id("root"),
vec![dep_req(&this.name(), &format!("={}", this.version()))],
&removed_reg,
).is_ok(),
@ -158,7 +153,6 @@ proptest! {
// So we try some of the most complicated.
for this in input.iter().rev().take(10) {
let res = resolve(
pkg_id("root"),
vec![dep_req(&this.name(), &format!("={}", this.version()))],
&reg,
);
@ -184,7 +178,6 @@ proptest! {
);
let res = resolve(
pkg_id("root"),
vec![dep_req(&this.name(), &format!("={}", this.version()))],
&new_reg,
);
@ -218,7 +211,6 @@ proptest! {
);
let res = resolve(
pkg_id("root"),
vec![dep_req(&this.name(), &format!("={}", this.version()))],
&new_reg,
);
@ -245,7 +237,7 @@ fn pub_fail() {
pkg!(("kB", "0.0.3") => [dep_req("a", ">= 0.0.5"),dep("e"),]),
];
let reg = registry(input.clone());
assert!(resolve_and_validated(pkg_id("root"), vec![dep("kB")], &reg, None).is_err());
assert!(resolve_and_validated(vec![dep("kB")], &reg, None).is_err());
}
#[test]
@ -257,7 +249,7 @@ fn basic_public_dependency() {
pkg!("C" => [dep("A"), dep("B")]),
]);
let res = resolve_and_validated(pkg_id("root"), vec![dep("C")], &reg, None).unwrap();
let res = resolve_and_validated(vec![dep("C")], &reg, None).unwrap();
assert_same(
&res,
&names(&[
@ -293,7 +285,7 @@ fn public_dependency_filling_in() {
pkg!("d" => [dep("c"), dep("a"), dep("b")]),
]);
let res = resolve_and_validated(pkg_id("root"), vec![dep("d")], &reg, None).unwrap();
let res = resolve_and_validated(vec![dep("d")], &reg, None).unwrap();
assert_same(
&res,
&names(&[
@ -328,7 +320,7 @@ fn public_dependency_filling_in_and_update() {
pkg!("C" => [dep("A"),dep("B")]),
pkg!("D" => [dep("B"),dep("C")]),
]);
let res = resolve_and_validated(pkg_id("root"), vec![dep("D")], &reg, None).unwrap();
let res = resolve_and_validated(vec![dep("D")], &reg, None).unwrap();
assert_same(
&res,
&names(&[
@ -355,7 +347,7 @@ fn public_dependency_skipping() {
];
let reg = registry(input);
resolve_and_validated(pkg_id("root"), vec![dep("c")], &reg, None).unwrap();
resolve_and_validated(vec![dep("c")], &reg, None).unwrap();
}
#[test]
@ -375,7 +367,7 @@ fn public_dependency_skipping_in_backtracking() {
];
let reg = registry(input);
resolve_and_validated(pkg_id("root"), vec![dep("C")], &reg, None).unwrap();
resolve_and_validated(vec![dep("C")], &reg, None).unwrap();
}
#[test]
@ -389,7 +381,7 @@ fn public_sat_topological_order() {
];
let reg = registry(input);
assert!(resolve_and_validated(pkg_id("root"), vec![dep("A")], &reg, None).is_err());
assert!(resolve_and_validated(vec![dep("A")], &reg, None).is_err());
}
#[test]
@ -403,7 +395,7 @@ fn public_sat_unused_makes_things_pub() {
];
let reg = registry(input);
resolve_and_validated(pkg_id("root"), vec![dep("c")], &reg, None).unwrap();
resolve_and_validated(vec![dep("c")], &reg, None).unwrap();
}
#[test]
@ -418,7 +410,7 @@ fn public_sat_unused_makes_things_pub_2() {
];
let reg = registry(input);
resolve_and_validated(pkg_id("root"), vec![dep("A")], &reg, None).unwrap();
resolve_and_validated(vec![dep("A")], &reg, None).unwrap();
}
#[test]
@ -430,7 +422,7 @@ fn test_dependency_with_empty_name() {
#[test]
fn test_resolving_empty_dependency_list() {
let res = resolve(pkg_id("root"), Vec::new(), &registry(vec![])).unwrap();
let res = resolve(Vec::new(), &registry(vec![])).unwrap();
assert_eq!(res, names(&["root"]));
}
@ -438,28 +430,28 @@ fn test_resolving_empty_dependency_list() {
#[test]
fn test_resolving_only_package() {
let reg = registry(vec![pkg!("foo")]);
let res = resolve(pkg_id("root"), vec![dep("foo")], &reg).unwrap();
let res = resolve(vec![dep("foo")], &reg).unwrap();
assert_same(&res, &names(&["root", "foo"]));
}
#[test]
fn test_resolving_one_dep() {
let reg = registry(vec![pkg!("foo"), pkg!("bar")]);
let res = resolve(pkg_id("root"), vec![dep("foo")], &reg).unwrap();
let res = resolve(vec![dep("foo")], &reg).unwrap();
assert_same(&res, &names(&["root", "foo"]));
}
#[test]
fn test_resolving_multiple_deps() {
let reg = registry(vec![pkg!("foo"), pkg!("bar"), pkg!("baz")]);
let res = resolve(pkg_id("root"), vec![dep("foo"), dep("baz")], &reg).unwrap();
let res = resolve(vec![dep("foo"), dep("baz")], &reg).unwrap();
assert_same(&res, &names(&["root", "foo", "baz"]));
}
#[test]
fn test_resolving_transitive_deps() {
let reg = registry(vec![pkg!("foo"), pkg!("bar" => ["foo"])]);
let res = resolve(pkg_id("root"), vec![dep("bar")], &reg).unwrap();
let res = resolve(vec![dep("bar")], &reg).unwrap();
assert_same(&res, &names(&["root", "foo", "bar"]));
}
@ -467,7 +459,7 @@ fn test_resolving_transitive_deps() {
#[test]
fn test_resolving_common_transitive_deps() {
let reg = registry(vec![pkg!("foo" => ["bar"]), pkg!("bar")]);
let res = resolve(pkg_id("root"), vec![dep("foo"), dep("bar")], &reg).unwrap();
let res = resolve(vec![dep("foo"), dep("bar")], &reg).unwrap();
assert_same(&res, &names(&["root", "foo", "bar"]));
}
@ -481,7 +473,6 @@ fn test_resolving_with_same_name() {
let reg = registry(list);
let res = resolve(
pkg_id("root"),
vec![
dep_loc("foo", "https://first.example.com"),
dep_loc("bar", "https://second.example.com"),
@ -508,12 +499,7 @@ fn test_resolving_with_dev_deps() {
pkg!("bat"),
]);
let res = resolve(
pkg_id("root"),
vec![dep("foo"), dep_kind("baz", Kind::Development)],
&reg,
)
.unwrap();
let res = resolve(vec![dep("foo"), dep_kind("baz", Kind::Development)], &reg).unwrap();
assert_same(&res, &names(&["root", "foo", "bar", "baz", "bat"]));
}
@ -522,7 +508,7 @@ fn test_resolving_with_dev_deps() {
fn resolving_with_many_versions() {
let reg = registry(vec![pkg!(("foo", "1.0.1")), pkg!(("foo", "1.0.2"))]);
let res = resolve(pkg_id("root"), vec![dep("foo")], &reg).unwrap();
let res = resolve(vec![dep("foo")], &reg).unwrap();
assert_same(&res, &names(&[("root", "1.0.0"), ("foo", "1.0.2")]));
}
@ -531,7 +517,7 @@ fn resolving_with_many_versions() {
fn resolving_with_specific_version() {
let reg = registry(vec![pkg!(("foo", "1.0.1")), pkg!(("foo", "1.0.2"))]);
let res = resolve(pkg_id("root"), vec![dep_req("foo", "=1.0.1")], &reg).unwrap();
let res = resolve(vec![dep_req("foo", "=1.0.1")], &reg).unwrap();
assert_same(&res, &names(&[("root", "1.0.0"), ("foo", "1.0.1")]));
}
@ -546,12 +532,7 @@ fn test_resolving_maximum_version_with_transitive_deps() {
pkg!("bar" => [dep_req("util", ">=1.0.1")]),
]);
let res = resolve(
pkg_id("root"),
vec![dep_req("foo", "1.0.0"), dep_req("bar", "1.0.0")],
&reg,
)
.unwrap();
let res = resolve(vec![dep_req("foo", "1.0.0"), dep_req("bar", "1.0.0")], &reg).unwrap();
assert_contains(
&res,
@ -596,7 +577,6 @@ fn test_resolving_minimum_version_with_transitive_deps() {
.unwrap();
let res = resolve_with_config(
pkg_id("root"),
vec![dep_req("foo", "1.0.0"), dep_req("bar", "1.0.0")],
&reg,
Some(&config),
@ -624,12 +604,7 @@ fn resolving_incompat_versions() {
pkg!("bar" => [dep_req("foo", "=1.0.2")]),
]);
assert!(resolve(
pkg_id("root"),
vec![dep_req("foo", "=1.0.1"), dep("bar")],
&reg
)
.is_err());
assert!(resolve(vec![dep_req("foo", "=1.0.1"), dep("bar")], &reg).is_err());
}
#[test]
@ -640,7 +615,7 @@ fn resolving_wrong_case_from_registry() {
// This test documents the current behavior.
let reg = registry(vec![pkg!(("foo", "1.0.0")), pkg!("bar" => ["Foo"])]);
assert!(resolve(pkg_id("root"), vec![dep("bar")], &reg).is_err());
assert!(resolve(vec![dep("bar")], &reg).is_err());
}
#[test]
@ -651,7 +626,7 @@ fn resolving_mis_hyphenated_from_registry() {
// This test documents the current behavior.
let reg = registry(vec![pkg!(("fo-o", "1.0.0")), pkg!("bar" => ["fo_o"])]);
assert!(resolve(pkg_id("root"), vec![dep("bar")], &reg).is_err());
assert!(resolve(vec![dep("bar")], &reg).is_err());
}
#[test]
@ -663,7 +638,7 @@ fn resolving_backtrack() {
pkg!("baz"),
]);
let res = resolve(pkg_id("root"), vec![dep_req("foo", "^1")], &reg).unwrap();
let res = resolve(vec![dep_req("foo", "^1")], &reg).unwrap();
assert_contains(
&res,
@ -683,7 +658,7 @@ fn resolving_backtrack_features() {
pkg!("bar"),
]);
let res = resolve(pkg_id("root"), vec![dep_req("foo", "^1")], &reg).unwrap();
let res = resolve(vec![dep_req("foo", "^1")], &reg).unwrap();
assert_contains(
&res,
@ -705,7 +680,7 @@ fn resolving_allows_multiple_compatible_versions() {
pkg!("d4" => [dep_req("foo", "0.2")]),
]);
let res = resolve(pkg_id("root"), vec![dep("bar")], &reg).unwrap();
let res = resolve(vec![dep("bar")], &reg).unwrap();
assert_same(
&res,
@ -738,7 +713,7 @@ fn resolving_with_deep_backtracking() {
pkg!(("dep_req", "2.0.0")),
]);
let res = resolve(pkg_id("root"), vec![dep_req("foo", "1")], &reg).unwrap();
let res = resolve(vec![dep_req("foo", "1")], &reg).unwrap();
assert_same(
&res,
@ -765,12 +740,7 @@ fn resolving_with_sys_crates() {
pkg!(("r", "1.0.0") => [dep_req("l-sys", "0.9"), dep_req("l", "0.9")]),
]);
let res = resolve(
pkg_id("root"),
vec![dep_req("d", "1"), dep_req("r", "1")],
&reg,
)
.unwrap();
let res = resolve(vec![dep_req("d", "1"), dep_req("r", "1")], &reg).unwrap();
assert_same(
&res,
@ -819,7 +789,7 @@ fn resolving_with_constrained_sibling_backtrack_parent() {
}
let reg = registry(reglist);
let res = resolve(pkg_id("root"), vec![dep_req("foo", "1")], &reg).unwrap();
let res = resolve(vec![dep_req("foo", "1")], &reg).unwrap();
assert_contains(
&res,
@ -854,7 +824,7 @@ fn resolving_with_many_equivalent_backtracking() {
let reg = registry(reglist.clone());
let res = resolve(pkg_id("root"), vec![dep("level0")], &reg);
let res = resolve(vec![dep("level0")], &reg);
assert!(res.is_err());
@ -864,7 +834,7 @@ fn resolving_with_many_equivalent_backtracking() {
let reg = registry(reglist.clone());
let res = resolve(pkg_id("root"), vec![dep("level0")], &reg).unwrap();
let res = resolve(vec![dep("level0")], &reg).unwrap();
assert_contains(&res, &names(&[("root", "1.0.0"), ("level0", "1.0.0")]));
@ -877,12 +847,7 @@ fn resolving_with_many_equivalent_backtracking() {
let reg = registry(reglist.clone());
let res = resolve(
pkg_id("root"),
vec![dep("level0"), dep("constrained")],
&reg,
)
.unwrap();
let res = resolve(vec![dep("level0"), dep("constrained")], &reg).unwrap();
assert_contains(
&res,
@ -895,12 +860,7 @@ fn resolving_with_many_equivalent_backtracking() {
let reg = registry(reglist.clone());
let res = resolve(
pkg_id("root"),
vec![dep_req("level0", "1.0.1"), dep("constrained")],
&reg,
)
.unwrap();
let res = resolve(vec![dep_req("level0", "1.0.1"), dep("constrained")], &reg).unwrap();
assert_contains(
&res,
@ -914,7 +874,6 @@ fn resolving_with_many_equivalent_backtracking() {
let reg = registry(reglist);
let res = resolve(
pkg_id("root"),
vec![dep_req("level0", "1.0.1"), dep_req("constrained", "1.1.0")],
&reg,
);
@ -956,11 +915,7 @@ fn resolving_with_deep_traps() {
let reg = registry(reglist);
let res = resolve(
pkg_id("root"),
vec![dep("backtrack_trap0"), dep("cloaking")],
&reg,
);
let res = resolve(vec![dep("backtrack_trap0"), dep("cloaking")], &reg);
assert!(res.is_err());
}
@ -1009,7 +964,6 @@ fn resolving_with_constrained_cousins_backtrack() {
// but `constrained= "2.0.1"` is already picked.
// Only then to try and solve `constrained= "~1.0.0"` which is incompatible.
let res = resolve(
pkg_id("root"),
vec![
dep("backtrack_trap0"),
dep_req("constrained", "2.0.1"),
@ -1038,20 +992,11 @@ fn resolving_with_constrained_cousins_backtrack() {
let reg = registry(reglist);
let res = resolve(
pkg_id("root"),
vec![dep("level0"), dep_req("constrained", "2.0.1")],
&reg,
);
let res = resolve(vec![dep("level0"), dep_req("constrained", "2.0.1")], &reg);
assert!(res.is_err());
let res = resolve(
pkg_id("root"),
vec![dep("level0"), dep_req("constrained", "2.0.0")],
&reg,
)
.unwrap();
let res = resolve(vec![dep("level0"), dep_req("constrained", "2.0.0")], &reg).unwrap();
assert_contains(
&res,
@ -1091,7 +1036,7 @@ fn resolving_with_constrained_sibling_backtrack_activation() {
}
let reg = registry(reglist);
let res = resolve(pkg_id("root"), vec![dep_req("foo", "1")], &reg).unwrap();
let res = resolve(vec![dep_req("foo", "1")], &reg).unwrap();
assert_contains(
&res,
@ -1137,7 +1082,7 @@ fn resolving_with_constrained_sibling_transitive_dep_effects() {
pkg!(("D", "1.0.105")),
]);
let res = resolve(pkg_id("root"), vec![dep_req("A", "1")], &reg).unwrap();
let res = resolve(vec![dep_req("A", "1")], &reg).unwrap();
assert_same(
&res,
@ -1183,7 +1128,7 @@ fn incomplete_information_skipping() {
];
let reg = registry(input.clone());
let res = resolve(pkg_id("root"), vec![dep("g")], &reg).unwrap();
let res = resolve(vec![dep("g")], &reg).unwrap();
let package_to_yank = "to_yank".to_pkgid();
// this package is not used in the resolution.
assert!(!res.contains(&package_to_yank));
@ -1197,7 +1142,7 @@ fn incomplete_information_skipping() {
);
assert_eq!(input.len(), new_reg.len() + 1);
// it should still build
assert!(resolve(pkg_id("root"), vec![dep("g")], &new_reg).is_ok());
assert!(resolve(vec![dep("g")], &new_reg).is_ok());
}
#[test]
@ -1252,7 +1197,7 @@ fn incomplete_information_skipping_2() {
];
let reg = registry(input.clone());
let res = resolve(pkg_id("root"), vec![dep("i")], &reg).unwrap();
let res = resolve(vec![dep("i")], &reg).unwrap();
let package_to_yank = ("to_yank", "8.8.1").to_pkgid();
// this package is not used in the resolution.
assert!(!res.contains(&package_to_yank));
@ -1266,7 +1211,7 @@ fn incomplete_information_skipping_2() {
);
assert_eq!(input.len(), new_reg.len() + 1);
// it should still build
assert!(resolve(pkg_id("root"), vec![dep("i")], &new_reg).is_ok());
assert!(resolve(vec![dep("i")], &new_reg).is_ok());
}
#[test]
@ -1302,7 +1247,7 @@ fn incomplete_information_skipping_3() {
];
let reg = registry(input.clone());
let res = resolve(pkg_id("root"), vec![dep("b")], &reg).unwrap();
let res = resolve(vec![dep("b")], &reg).unwrap();
let package_to_yank = ("to_yank", "3.0.3").to_pkgid();
// this package is not used in the resolution.
assert!(!res.contains(&package_to_yank));
@ -1316,14 +1261,14 @@ fn incomplete_information_skipping_3() {
);
assert_eq!(input.len(), new_reg.len() + 1);
// it should still build
assert!(resolve(pkg_id("root"), vec![dep("b")], &new_reg).is_ok());
assert!(resolve(vec![dep("b")], &new_reg).is_ok());
}
#[test]
fn resolving_but_no_exists() {
let reg = registry(vec![]);
let res = resolve(pkg_id("root"), vec![dep_req("foo", "1")], &reg);
let res = resolve(vec![dep_req("foo", "1")], &reg);
assert!(res.is_err());
assert_eq!(
@ -1340,7 +1285,7 @@ fn resolving_but_no_exists() {
fn resolving_cycle() {
let reg = registry(vec![pkg!("foo" => ["foo"])]);
let _ = resolve(pkg_id("root"), vec![dep_req("foo", "1")], &reg);
let _ = resolve(vec![dep_req("foo", "1")], &reg);
}
#[test]
@ -1351,12 +1296,7 @@ fn hard_equality() {
pkg!(("bar", "1.0.0") => [dep_req("foo", "1.0.0")]),
]);
let res = resolve(
pkg_id("root"),
vec![dep_req("bar", "1"), dep_req("foo", "=1.0.0")],
&reg,
)
.unwrap();
let res = resolve(vec![dep_req("bar", "1"), dep_req("foo", "=1.0.0")], &reg).unwrap();
assert_same(
&res,
@ -1390,7 +1330,7 @@ fn large_conflict_cache() {
}
}
let reg = registry(input);
let _ = resolve(pkg_id("root"), root_deps, &reg);
let _ = resolve(root_deps, &reg);
}
#[test]
@ -1430,7 +1370,7 @@ fn conflict_store_bug() {
];
let reg = registry(input);
let _ = resolve_and_validated(pkg_id("root"), vec![dep("j")], &reg, None);
let _ = resolve_and_validated(vec![dep("j")], &reg, None);
}
#[test]
@ -1458,5 +1398,5 @@ fn conflict_store_more_then_one_match() {
]),
];
let reg = registry(input);
let _ = resolve_and_validated(pkg_id("root"), vec![dep("nA")], &reg, None);
let _ = resolve_and_validated(vec![dep("nA")], &reg, None);
}