test: port previously-ignored Composer tests via __ test hatches

Re-evaluate the reason'd #[ignore] tests under the Phase D criterion:
a test is unportable ONLY if the APIs/types needed to WRITE it do not
exist. A test that compiles but panics at runtime (todo!() body, a
regex the regex crate cannot compile) or fails at runtime (incomplete
or incorrect impl behavior) is portable -- it is written in full and
marked with a reason-less #[ignore].

About 120 test functions move from reason'd #[ignore] to reason-less
#[ignore] (the ported-but-not-yet-passing signal). Impl crates gain
only additive __ test hatches (init_command, pool, file_downloader,
package handle link setters, artifact/path repository, repository
manager, svn); no existing logic changes. Tests whose required APIs
genuinely do not exist (mock/reflection harness, ApplicationTester,
solve() discarding SolverProblemsException, a script::Event that
cannot be passed as an originating event) keep their reason'd
#[ignore].

cargo check -p shirabe --tests passes.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

3 files changed, 2626 insertions, 80 deletions

diff --git a/crates/shirabe/tests/dependency_resolver/pool_builder_test.rs b/crates/shirabe/tests/dependency_resolver/pool_builder_test.rs
index 4c72091..87f02aa 100644
--- a/crates/shirabe/tests/dependency_resolver/pool_builder_test.rs
+++ b/crates/shirabe/tests/dependency_resolver/pool_builder_test.rs
@@ -1,9 +1,647 @@
 //! ref: composer/tests/Composer/Test/DependencyResolver/PoolBuilderTest.php
 
-// testPoolBuilder is a large fixture-driven case that loads packages from test inputs and
-// builds a Pool; constraint parsing uses a look-around regex the regex crate cannot compile.
+use std::cell::RefCell;
+use std::path::PathBuf;
+use std::rc::Rc;
+
+use indexmap::IndexMap;
+use shirabe::config::Config;
+use shirabe::dependency_resolver::default_policy::DefaultPolicy;
+use shirabe::dependency_resolver::pool::Pool;
+use shirabe::dependency_resolver::pool_optimizer::PoolOptimizer;
+use shirabe::dependency_resolver::request::{Request, UpdateAllowTransitiveDeps};
+use shirabe::io::io_interface::IOInterface;
+use shirabe::io::null_io::NullIO;
+use shirabe::json::JsonFile;
+use shirabe::package::BasePackageHandle;
+use shirabe::package::STABILITIES;
+use shirabe::package::loader::{ArrayLoader, LoaderInterface};
+use shirabe::package::version::version_parser::VersionParser;
+use shirabe::repository::array_repository::ArrayRepository;
+use shirabe::repository::filter_repository::FilterRepository;
+use shirabe::repository::handle::{LockArrayRepositoryHandle, RepositoryInterfaceHandle};
+use shirabe::repository::lock_array_repository::LockArrayRepository;
+use shirabe::repository::repository_factory::RepositoryFactory;
+use shirabe::repository::repository_set::{RepositorySet, RootAliasInput};
+use shirabe_external_packages::composer::pcre::preg::Preg;
+use shirabe_php_shim::PREG_SPLIT_DELIM_CAPTURE;
+use shirabe_php_shim::PhpMixed;
+
+/// Maps the PHP `$loadPackage` closure: pops the optional `id` from the data, loads the
+/// package and records it in `package_ids` keyed by that id (erroring on duplicates).
+fn load_package(
+    loader: &ArrayLoader,
+    package_ids: &mut IndexMap<i64, BasePackageHandle>,
+    data: &IndexMap<String, PhpMixed>,
+) -> BasePackageHandle {
+    let mut data = data.clone();
+
+    let mut id: Option<i64> = None;
+    // PHP: !empty($data['id'])
+    if let Some(id_val) = data.get("id") {
+        if let Some(i) = id_val.as_int() {
+            if i != 0 {
+                id = Some(i);
+                data.shift_remove("id");
+            }
+        }
+    }
+
+    let pkg = loader.load(data, None).unwrap();
+
+    if let Some(id) = id {
+        if package_ids.contains_key(&id) {
+            panic!("Duplicate package id {} defined", id);
+        }
+        package_ids.insert(id, pkg.clone());
+    }
+
+    pkg
+}
+
+fn read_test_file(file: &str, fixtures_dir: &str) -> IndexMap<String, String> {
+    let contents = shirabe_php_shim::file_get_contents(file).unwrap();
+    let tokens = Preg::split4(
+        r"#(?:^|\n*)--([A-Z-]+)--\n#",
+        &contents,
+        -1,
+        PREG_SPLIT_DELIM_CAPTURE,
+    );
+
+    // PHP section_info is a map of name => required flag.
+    let section_info: Vec<(&str, bool)> = vec![
+        ("TEST", true),
+        ("ROOT", false),
+        ("REQUEST", true),
+        ("FIXED", false),
+        ("PACKAGE-REPOS", true),
+        ("EXPECT", true),
+        ("EXPECT-OPTIMIZED", false),
+    ];
+
+    let mut section: Option<String> = None;
+    let mut data: IndexMap<String, String> = IndexMap::new();
+    for token in tokens {
+        if section.is_none() && token.is_empty() {
+            continue;
+        }
+
+        if section.is_none() {
+            if !section_info.iter().any(|(name, _)| *name == token.as_str()) {
+                panic!(
+                    "The test file \"{}\" must not contain a section named \"{}\".",
+                    file.replace(&format!("{}/", fixtures_dir), ""),
+                    token
+                );
+            }
+            section = Some(token);
+            continue;
+        }
+
+        let section_data = token;
+        data.insert(section.take().unwrap(), section_data);
+    }
+
+    for (section, required) in &section_info {
+        if *required && !data.contains_key(*section) {
+            panic!(
+                "The test file \"{}\" must have a section named \"{}\".",
+                file.replace(&format!("{}/", fixtures_dir), ""),
+                section
+            );
+        }
+    }
+
+    data
+}
+
+fn collect_test_files(dir: &std::path::Path, out: &mut Vec<PathBuf>) {
+    for entry in std::fs::read_dir(dir).unwrap() {
+        let entry = entry.unwrap();
+        let path = entry.path();
+        if path.is_dir() {
+            collect_test_files(&path, out);
+        } else {
+            out.push(path);
+        }
+    }
+}
+
+struct IntegrationTest {
+    file: String,
+    message: String,
+    expect: PhpMixed,
+    expect_optimized: PhpMixed,
+    root: PhpMixed,
+    request: PhpMixed,
+    package_repos: PhpMixed,
+    fixed: PhpMixed,
+}
+
+fn get_integration_tests(fixtures_dir: &std::path::Path) -> IndexMap<String, IntegrationTest> {
+    let fixtures_dir_str = fixtures_dir.to_str().unwrap().to_string();
+
+    let mut files: Vec<PathBuf> = Vec::new();
+    collect_test_files(fixtures_dir, &mut files);
+
+    let mut tests: IndexMap<String, IntegrationTest> = IndexMap::new();
+    for file in files {
+        let file = file.to_str().unwrap().to_string();
+
+        if !Preg::is_match(r"/\.test$/", &file) {
+            continue;
+        }
+
+        let test_data = read_test_file(&file, &fixtures_dir_str);
+
+        let message = test_data["TEST"].clone();
+
+        let request = JsonFile::parse_json(Some(&test_data["REQUEST"]), None).unwrap();
+        // PHP: !empty($testData['ROOT']) ? parseJson(...) : []
+        let root = match test_data.get("ROOT") {
+            Some(s) if !s.is_empty() => JsonFile::parse_json(Some(s), None).unwrap(),
+            _ => PhpMixed::List(vec![]),
+        };
+
+        let package_repos = JsonFile::parse_json(Some(&test_data["PACKAGE-REPOS"]), None).unwrap();
+        let fixed = match test_data.get("FIXED") {
+            Some(s) if !s.is_empty() => JsonFile::parse_json(Some(s), None).unwrap(),
+            _ => PhpMixed::List(vec![]),
+        };
+        let expect = JsonFile::parse_json(Some(&test_data["EXPECT"]), None).unwrap();
+        let expect_optimized = match test_data.get("EXPECT-OPTIMIZED") {
+            Some(s) if !s.is_empty() => JsonFile::parse_json(Some(s), None).unwrap(),
+            _ => expect.clone(),
+        };
+
+        let basename = std::path::Path::new(&file)
+            .file_name()
+            .unwrap()
+            .to_str()
+            .unwrap()
+            .to_string();
+        tests.insert(
+            basename,
+            IntegrationTest {
+                file: file.replace(&format!("{}/", fixtures_dir_str), ""),
+                message,
+                expect,
+                expect_optimized,
+                root,
+                request,
+                package_repos,
+                fixed,
+            },
+        );
+    }
+
+    tests
+}
+
+/// PHP `sort()` with SORT_REGULAR over a mixed int/string list. Mirrors PHP 8 loose
+/// comparison: two ints compare numerically; a string and an int that looks numeric
+/// compare numerically; otherwise both are compared as strings.
+fn php_sort_mixed(values: &mut [PhpMixed]) {
+    fn cmp(a: &PhpMixed, b: &PhpMixed) -> std::cmp::Ordering {
+        use std::cmp::Ordering;
+        let num = |m: &PhpMixed| -> Option<f64> {
+            match m {
+                PhpMixed::Int(i) => Some(*i as f64),
+                PhpMixed::Float(f) => Some(*f),
+                PhpMixed::String(s) => s.trim().parse::<f64>().ok(),
+                _ => None,
+            }
+        };
+        let str_of = |m: &PhpMixed| -> String {
+            match m {
+                PhpMixed::Int(i) => i.to_string(),
+                PhpMixed::Float(f) => f.to_string(),
+                PhpMixed::String(s) => s.clone(),
+                _ => String::new(),
+            }
+        };
+        match (a, b) {
+            (PhpMixed::Int(x), PhpMixed::Int(y)) => x.cmp(y),
+            _ => match (num(a), num(b)) {
+                (Some(x), Some(y)) => x.partial_cmp(&y).unwrap_or(Ordering::Equal),
+                _ => str_of(a).cmp(&str_of(b)),
+            },
+        }
+    }
+    values.sort_by(cmp);
+}
+
+/// ref: PoolBuilderTest::getPackageResultSet
+fn get_package_result_set(
+    pool: &Pool,
+    package_ids: &IndexMap<i64, BasePackageHandle>,
+) -> Vec<PhpMixed> {
+    let mut result: Vec<BasePackageHandle> = Vec::new();
+    let count = pool.__count();
+    // PHP: for ($i = 1; $i <= $count; $i++)
+    let mut i = 1;
+    while i <= count {
+        result.push(pool.package_by_id(i));
+        i += 1;
+    }
+
+    // PHP: array_search($package, $packageIds, true) — identity lookup.
+    let find_id = |package: &BasePackageHandle| -> Option<i64> {
+        for (id, candidate) in package_ids {
+            if candidate.ptr_id() == package.ptr_id() {
+                return Some(*id);
+            }
+        }
+        None
+    };
+
+    result
+        .into_iter()
+        .map(|package| {
+            // PHP: if ($id = array_search(...)) — id keys start at 1 so always truthy when found.
+            if let Some(id) = find_id(&package) {
+                return PhpMixed::Int(id);
+            }
+
+            let mut suffix = String::new();
+            if let Some(source_reference) = package.get_source_reference() {
+                suffix = format!("#{}", source_reference);
+            }
+            if let Some(repo) = package.get_repository() {
+                if repo.is::<LockArrayRepository>() {
+                    suffix.push_str(" (locked)");
+                }
+            }
+
+            if let Some(alias) = package.as_alias() {
+                let alias_of = alias.get_alias_of();
+                // PHP: array_search($package->getAliasOf(), $packageIds, true)
+                let mut matched: Option<i64> = None;
+                for (id, candidate) in package_ids {
+                    if candidate.ptr_id() == alias_of.ptr_id() {
+                        matched = Some(*id);
+                        break;
+                    }
+                }
+                if let Some(id) = matched {
+                    return PhpMixed::String(format!(
+                        "{}-{}{} (alias of {})",
+                        package.get_name(),
+                        package.get_version(),
+                        suffix,
+                        id
+                    ));
+                }
+
+                return PhpMixed::String(format!(
+                    "{}-{}{} (alias of {})",
+                    package.get_name(),
+                    package.get_version(),
+                    suffix,
+                    alias_of.get_version()
+                ));
+            }
+
+            PhpMixed::String(format!(
+                "{}-{}{}",
+                package.get_name(),
+                package.get_version(),
+                suffix
+            ))
+        })
+        .collect()
+}
+
+/// ref: PoolBuilderTest::testPoolBuilder
+#[allow(clippy::too_many_arguments)]
+fn run_test_pool_builder(
+    fixtures_dir: &std::path::Path,
+    _file: &str,
+    message: &str,
+    expect: &PhpMixed,
+    expect_optimized: &PhpMixed,
+    root: &PhpMixed,
+    request_data: &PhpMixed,
+    package_repos: &PhpMixed,
+    fixed: &PhpMixed,
+) {
+    // PHP: $root is array; empty checks against keys.
+    let root_map = root.as_array();
+    let get_root = |key: &str| -> Option<&PhpMixed> { root_map.and_then(|m| m.get(key)) };
+    let is_empty = |v: Option<&PhpMixed>| -> bool {
+        match v {
+            None => true,
+            Some(PhpMixed::Null) => true,
+            Some(PhpMixed::Bool(false)) => true,
+            Some(PhpMixed::Int(0)) => true,
+            Some(PhpMixed::String(s)) => s.is_empty(),
+            Some(PhpMixed::List(l)) => l.is_empty(),
+            Some(PhpMixed::Array(a)) => a.is_empty(),
+            Some(PhpMixed::Object(a)) => a.is_empty(),
+            _ => false,
+        }
+    };
+
+    // PHP: $rootAliases = !empty($root['aliases']) ? $root['aliases'] : [];
+    let root_aliases_data: Vec<IndexMap<String, PhpMixed>> = if !is_empty(get_root("aliases")) {
+        get_root("aliases")
+            .and_then(|v| v.as_list())
+            .map(|l| {
+                l.iter()
+                    .filter_map(|v| v.as_array().cloned())
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default()
+    } else {
+        vec![]
+    };
+
+    let minimum_stability: String = if !is_empty(get_root("minimum-stability")) {
+        get_root("minimum-stability")
+            .and_then(|v| v.as_string())
+            .unwrap_or("stable")
+            .to_string()
+    } else {
+        "stable".to_string()
+    };
+
+    // PHP: $stabilityFlags map of name => stability string.
+    let stability_flags_data: IndexMap<String, String> = if !is_empty(get_root("stability-flags")) {
+        get_root("stability-flags")
+            .and_then(|v| v.as_array())
+            .map(|m| {
+                m.iter()
+                    .filter_map(|(k, v)| v.as_string().map(|s| (k.clone(), s.to_string())))
+                    .collect()
+            })
+            .unwrap_or_default()
+    } else {
+        IndexMap::new()
+    };
+
+    let root_references: IndexMap<String, String> = if !is_empty(get_root("references")) {
+        get_root("references")
+            .and_then(|v| v.as_array())
+            .map(|m| {
+                m.iter()
+                    .filter_map(|(k, v)| v.as_string().map(|s| (k.clone(), s.to_string())))
+                    .collect()
+            })
+            .unwrap_or_default()
+    } else {
+        IndexMap::new()
+    };
+
+    // PHP: array_map over stability flags, mapping to BasePackage::STABILITIES[$stability].
+    let mut stability_flags: IndexMap<String, i64> = IndexMap::new();
+    for (name, stability) in &stability_flags_data {
+        let Some(value) = STABILITIES.get(stability.as_str()) else {
+            panic!("Invalid stability given: {}", stability);
+        };
+        stability_flags.insert(name.clone(), *value);
+    }
+
+    let parser = VersionParser::new();
+    // PHP: foreach ($rootAliases as $index => $alias) { normalize version + alias }
+    let mut root_aliases: Vec<RootAliasInput> = Vec::new();
+    for alias in &root_aliases_data {
+        let package = alias
+            .get("package")
+            .and_then(|v| v.as_string())
+            .unwrap_or("")
+            .to_string();
+        let version = parser
+            .normalize(
+                alias
+                    .get("version")
+                    .and_then(|v| v.as_string())
+                    .unwrap_or(""),
+                None,
+            )
+            .unwrap();
+        let alias_str = alias
+            .get("alias")
+            .and_then(|v| v.as_string())
+            .unwrap_or("")
+            .to_string();
+        let alias_normalized = parser
+            .normalize(
+                alias.get("alias").and_then(|v| v.as_string()).unwrap_or(""),
+                None,
+            )
+            .unwrap();
+        root_aliases.push(RootAliasInput {
+            package,
+            version,
+            alias: alias_str,
+            alias_normalized,
+        });
+    }
+
+    let loader = ArrayLoader::new(None, true);
+    let mut package_ids: IndexMap<i64, BasePackageHandle> = IndexMap::new();
+
+    // PHP: $oldCwd = Platform::getCwd(); chdir(__DIR__.'/Fixtures/poolbuilder/');
+    let old_cwd = std::env::current_dir().unwrap();
+    std::env::set_current_dir(fixtures_dir).unwrap();
+
+    let mut repository_set = RepositorySet::new(
+        &minimum_stability,
+        stability_flags,
+        root_aliases,
+        root_references,
+        IndexMap::new(),
+        IndexMap::new(),
+    );
+    let config = Rc::new(RefCell::new(Config::new(false, None)));
+    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
+    let mut rm = RepositoryFactory::manager(io.clone(), &config, None, None, None).unwrap();
+
+    // PHP: foreach ($packageRepos as $packages)
+    for repo_entry in package_repos.as_list().unwrap() {
+        // PHP: isset($packages['type'])
+        if let Some(repo_map) = repo_entry.as_array() {
+            if repo_map.contains_key("type") {
+                let repo = RepositoryFactory::create_repo(
+                    io.clone(),
+                    &config,
+                    repo_map.clone(),
+                    Some(&mut rm),
+                )
+                .unwrap();
+                repository_set.add_repository(repo).unwrap();
+                continue;
+            }
+        }
+
+        let repo = ArrayRepository::new(vec![]).unwrap();
+        let repo_handle = RepositoryInterfaceHandle::new(repo);
+
+        // PHP: isset($packages['canonical']) || isset($packages['only']) || isset($packages['exclude'])
+        let packages_list: Vec<IndexMap<String, PhpMixed>>;
+        if let Some(repo_map) = repo_entry.as_array() {
+            if repo_map.contains_key("canonical")
+                || repo_map.contains_key("only")
+                || repo_map.contains_key("exclude")
+            {
+                let mut options = repo_map.clone();
+                let packages = options
+                    .shift_remove("packages")
+                    .unwrap_or(PhpMixed::List(vec![]));
+                repository_set
+                    .add_repository(RepositoryInterfaceHandle::new(
+                        FilterRepository::new(repo_handle.clone(), options).unwrap(),
+                    ))
+                    .unwrap();
+                packages_list = packages
+                    .as_list()
+                    .map(|l| l.iter().filter_map(|v| v.as_array().cloned()).collect())
+                    .unwrap_or_default();
+            } else {
+                repository_set.add_repository(repo_handle.clone()).unwrap();
+                packages_list = repo_map
+                    .values()
+                    .filter_map(|v| v.as_array().cloned())
+                    .collect();
+            }
+        } else {
+            repository_set.add_repository(repo_handle.clone()).unwrap();
+            packages_list = repo_entry
+                .as_list()
+                .map(|l| l.iter().filter_map(|v| v.as_array().cloned()).collect())
+                .unwrap_or_default();
+        }
+
+        let array_repo = repo_handle.downcast_rc::<ArrayRepository>().unwrap();
+        for package in &packages_list {
+            array_repo
+                .borrow()
+                .add_package(load_package(&loader, &mut package_ids, package))
+                .unwrap();
+        }
+    }
+
+    let locked_repo = LockArrayRepositoryHandle::new(LockArrayRepository::new(vec![]).unwrap());
+    repository_set
+        .add_repository(locked_repo.clone().into())
+        .unwrap();
+
+    let request_map = request_data.as_array().unwrap();
+
+    // PHP: if (isset($requestData['locked']))
+    if let Some(locked) = request_map.get("locked") {
+        for package in locked.as_list().unwrap() {
+            locked_repo
+                .borrow()
+                .add_package(load_package(
+                    &loader,
+                    &mut package_ids,
+                    package.as_array().unwrap(),
+                ))
+                .unwrap();
+        }
+    }
+
+    let mut request = Request::new(Some(locked_repo.clone()));
+    for (package, constraint) in request_map["require"].as_array().unwrap() {
+        request
+            .require_name(
+                package,
+                Some(
+                    parser
+                        .parse_constraints(constraint.as_string().unwrap())
+                        .unwrap(),
+                ),
+            )
+            .unwrap();
+    }
+
+    // PHP: if (isset($requestData['allowList']))
+    if let Some(allow_list) = request_map.get("allowList") {
+        let mut transitive_deps = UpdateAllowTransitiveDeps::UpdateOnlyListed;
+        if request_map
+            .get("allowTransitiveDepsNoRootRequire")
+            .and_then(|v| v.as_bool())
+            .unwrap_or(false)
+        {
+            transitive_deps =
+                UpdateAllowTransitiveDeps::UpdateListedWithTransitiveDepsNoRootRequire;
+        }
+        if request_map
+            .get("allowTransitiveDeps")
+            .and_then(|v| v.as_bool())
+            .unwrap_or(false)
+        {
+            transitive_deps = UpdateAllowTransitiveDeps::UpdateListedWithTransitiveDeps;
+        }
+        let allow_list_names: Vec<String> = allow_list
+            .as_list()
+            .unwrap()
+            .iter()
+            .filter_map(|v| v.as_string().map(|s| s.to_string()))
+            .collect();
+        request.set_update_allow_list(allow_list_names, transitive_deps);
+    }
+
+    // PHP: foreach ($fixed as $fixedPackage)
+    for fixed_package in fixed.as_list().unwrap() {
+        request.fix_package(load_package(
+            &loader,
+            &mut package_ids,
+            fixed_package.as_array().unwrap(),
+        ));
+    }
+
+    let pool = repository_set
+        .create_pool(&mut request, io.clone(), None, None, vec![], None, None)
+        .unwrap();
+
+    let mut result = get_package_result_set(&pool, &package_ids);
+
+    let mut expect = expect.as_list().unwrap().clone();
+    php_sort_mixed(&mut expect);
+    php_sort_mixed(&mut result);
+    assert_eq!(
+        expect, result,
+        "Unoptimized pool does not match expected package set ({})",
+        message
+    );
+
+    let mut optimizer = PoolOptimizer::new(Rc::new(DefaultPolicy::new(false, false, None)));
+    let optimized = optimizer.optimize(&request, &pool);
+    let mut result = get_package_result_set(&optimized, &package_ids);
+    let mut expect_optimized = expect_optimized.as_list().unwrap().clone();
+    php_sort_mixed(&mut expect_optimized);
+    php_sort_mixed(&mut result);
+    assert_eq!(
+        expect_optimized, result,
+        "Optimized pool does not match expected package set ({})",
+        message
+    );
+
+    // PHP: chdir($oldCwd);
+    std::env::set_current_dir(&old_cwd).unwrap();
+}
+
+#[ignore]
 #[test]
-#[ignore = "ArrayLoader::load (single-package, pub) and Pool::count are not exposed: the loadPackage closure calls $loader->load($data) per package and getPackageResultSet uses count($pool)"]
 fn test_pool_builder() {
-    todo!()
+    let fixtures_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("../../composer/tests/Composer/Test/DependencyResolver/Fixtures/poolbuilder");
+    let fixtures_dir = std::fs::canonicalize(&fixtures_dir).unwrap();
+
+    let tests = get_integration_tests(&fixtures_dir);
+    for (_name, test) in tests {
+        run_test_pool_builder(
+            &fixtures_dir,
+            &test.file,
+            &test.message,
+            &test.expect,
+            &test.expect_optimized,
+            &test.root,
+            &test.request,
+            &test.package_repos,
+            &test.fixed,
+        );
+    }
 }
diff --git a/crates/shirabe/tests/dependency_resolver/solver_test.rs b/crates/shirabe/tests/dependency_resolver/solver_test.rs
index 26f1312..c729fea 100644
--- a/crates/shirabe/tests/dependency_resolver/solver_test.rs
+++ b/crates/shirabe/tests/dependency_resolver/solver_test.rs
@@ -9,11 +9,13 @@ use shirabe::dependency_resolver::default_policy::DefaultPolicy;
 use shirabe::dependency_resolver::request::Request;
 use shirabe::io::io_interface::IOInterface;
 use shirabe::io::null_io::NullIO;
+use shirabe::package::Link;
 use shirabe::package::handle::PackageInterfaceHandle;
 use shirabe::repository::array_repository::ArrayRepository;
 use shirabe::repository::handle::{LockArrayRepositoryHandle, RepositoryInterfaceHandle};
 use shirabe::repository::lock_array_repository::LockArrayRepository;
 use shirabe::repository::repository_set::RepositorySet;
+use shirabe_semver::constraint::{AnyConstraint, MatchAllConstraint, MultiConstraint};
 
 use crate::test_case::{get_alias_package, get_package, get_version_constraint};
 
@@ -50,6 +52,40 @@ fn set_up() -> Fixtures {
     }
 }
 
+/// PHP `new Link($source, $target, $constraint, $type)`: prettyConstraint defaults to
+/// `(string) $constraint`.
+fn link(source: &str, target: &str, constraint: AnyConstraint, r#type: &str) -> Link {
+    let pretty = constraint.get_pretty_string();
+    Link::new(
+        source.to_string(),
+        target.to_string(),
+        constraint,
+        Some(r#type.to_string()),
+        pretty,
+    )
+}
+
+/// PHP `new Link($source, $target, $constraint, $type, $prettyConstraint)`.
+fn link_pretty(
+    source: &str,
+    target: &str,
+    constraint: AnyConstraint,
+    r#type: &str,
+    pretty: &str,
+) -> Link {
+    Link::new(
+        source.to_string(),
+        target.to_string(),
+        constraint,
+        Some(r#type.to_string()),
+        pretty.to_string(),
+    )
+}
+
+fn multi(constraints: Vec<AnyConstraint>) -> AnyConstraint {
+    MultiConstraint::new(constraints, true, None).into()
+}
+
 /// One expected solver job. Mirrors the PHP `['job' => ..., 'package'|'from'|'to' => ...]` rows.
 enum ExpectedJob {
     Single {
@@ -67,7 +103,7 @@ fn check_solver_result(
     mut repo_set: RepositorySet,
     repo: ArrayRepository,
     repo_locked: LockArrayRepositoryHandle,
-    mut request: Request,
+    request: Request,
     expected: Vec<ExpectedJob>,
 ) {
     // reposComplete()
@@ -76,6 +112,15 @@ fn check_solver_result(
         .unwrap();
     repo_set.add_repository(repo_locked.into()).unwrap();
 
+    check_solver_result_repo_set(&mut repo_set, request, expected);
+}
+
+/// ref: SolverTest::checkSolverResult, against an already-completed RepositorySet (createSolver).
+fn check_solver_result_repo_set(
+    repo_set: &mut RepositorySet,
+    mut request: Request,
+    expected: Vec<ExpectedJob>,
+) {
     // createSolver()
     let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
     let pool = repo_set
@@ -137,6 +182,29 @@ fn check_solver_result(
     assert_eq!(expected_ids, result_ids);
 }
 
+/// ref: SolverTest::createSolver + solve, returning the error for expectException-only tests.
+fn solve_expecting_error(
+    mut repo_set: RepositorySet,
+    repo: ArrayRepository,
+    repo_locked: LockArrayRepositoryHandle,
+    mut request: Request,
+) {
+    repo_set
+        .add_repository(RepositoryInterfaceHandle::new(repo))
+        .unwrap();
+    repo_set.add_repository(repo_locked.into()).unwrap();
+
+    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
+    let pool = repo_set
+        .create_pool(&mut request, io.clone(), None, None, vec![], None, None)
+        .unwrap();
+    let policy: Rc<dyn PolicyInterface> = Rc::new(DefaultPolicy::new(false, false, None));
+    let mut solver =
+        shirabe::dependency_resolver::solver::Solver::new(policy, Rc::new(RefCell::new(pool)), io);
+
+    assert!(solver.solve(&request, None).is_err());
+}
+
 #[ignore]
 #[test]
 fn test_solver_install_single() {
@@ -178,7 +246,7 @@ fn test_solver_remove_if_not_requested() {
     );
 }
 
-#[ignore = "solve() error path discards SolverProblemsException (returns placeholder anyhow error); getProblems/getCode/getPrettyString not retrievable"]
+#[ignore = "asserts SolverProblemsException details (getProblems/getCode/getPrettyString) which solve() discards"]
 #[test]
 fn test_install_non_existing_package_fails() {
     let _fixtures = set_up();
@@ -222,40 +290,364 @@ fn test_solver_install_same_package_from_different_repositories() {
     );
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_solver_install_with_deps() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo.add_package(package_b.clone()).unwrap();
+    let new_package_b = get_package("B", "1.1");
+    fixtures.repo.add_package(new_package_b.clone()).unwrap();
+
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint("<", "1.1"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: package_b,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_solver_install_honours_not_equal_operator() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo.add_package(package_b.clone()).unwrap();
+    let new_package_b11 = get_package("B", "1.1");
+    fixtures.repo.add_package(new_package_b11.clone()).unwrap();
+    let new_package_b12 = get_package("B", "1.2");
+    fixtures.repo.add_package(new_package_b12.clone()).unwrap();
+    let new_package_b13 = get_package("B", "1.3");
+    fixtures.repo.add_package(new_package_b13.clone()).unwrap();
+
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                multi(vec![
+                    get_version_constraint("<=", "1.3"),
+                    get_version_constraint("<>", "1.3"),
+                    get_version_constraint("!=", "1.2"),
+                ]),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: new_package_b11,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_solver_install_with_deps_in_order() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo.add_package(package_b.clone()).unwrap();
+    let package_c = get_package("C", "1.0");
+    fixtures.repo.add_package(package_c.clone()).unwrap();
+
+    package_b
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([
+            (
+                "a".to_string(),
+                link(
+                    "B",
+                    "A",
+                    get_version_constraint(">=", "1.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+            (
+                "c".to_string(),
+                link(
+                    "B",
+                    "C",
+                    get_version_constraint(">=", "1.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+        ]));
+    package_c
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "a".to_string(),
+            link(
+                "C",
+                "A",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+    request.require_name("B", None).unwrap();
+    request.require_name("C", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_c,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_b,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_solver_multi_package_name_version_resolution_depends_on_require_order() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let php74 = get_package("ourcustom/PHP", "7.4.23");
+    fixtures.repo.add_package(php74.clone()).unwrap();
+    let php80 = get_package("ourcustom/PHP", "8.0.10");
+    fixtures.repo.add_package(php80.clone()).unwrap();
+    let ext_for_php74 = get_package("ourcustom/ext-foobar", "1.0");
+    fixtures.repo.add_package(ext_for_php74.clone()).unwrap();
+    let ext_for_php80 = get_package("ourcustom/ext-foobar", "1.0");
+    fixtures.repo.add_package(ext_for_php80.clone()).unwrap();
+
+    ext_for_php74
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "ourcustom/php".to_string(),
+            link(
+                "ourcustom/ext-foobar",
+                "ourcustom/PHP",
+                multi(vec![
+                    get_version_constraint(">=", "7.4.0"),
+                    get_version_constraint("<", "7.5.0"),
+                ]),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    ext_for_php80
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "ourcustom/php".to_string(),
+            link(
+                "ourcustom/ext-foobar",
+                "ourcustom/PHP",
+                multi(vec![
+                    get_version_constraint(">=", "8.0.0"),
+                    get_version_constraint("<", "8.1.0"),
+                ]),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    // reposComplete()
+    let mut repo_set = fixtures.repo_set;
+    repo_set
+        .add_repository(RepositoryInterfaceHandle::new(fixtures.repo))
+        .unwrap();
+    repo_set
+        .add_repository(fixtures.repo_locked.clone().into())
+        .unwrap();
+
+    let mut request = fixtures.request;
+    request.require_name("ourcustom/PHP", None).unwrap();
+    request.require_name("ourcustom/ext-foobar", None).unwrap();
+
+    check_solver_result_repo_set(
+        &mut repo_set,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: php80.clone(),
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: ext_for_php80,
+            },
+        ],
+    );
+
+    // now we flip the requirements around: we request "ext-foobar" before "php"
+    let mut request = Request::new(Some(fixtures.repo_locked.clone()));
+    request.require_name("ourcustom/ext-foobar", None).unwrap();
+    request.require_name("ourcustom/PHP", None).unwrap();
+
+    check_solver_result_repo_set(
+        &mut repo_set,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: php74,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: ext_for_php74,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_solver_multi_package_name_version_resolution_is_independent_of_require_order_if_ordered_descending_by_requirement()
  {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let php74 = get_package("ourcustom/PHP", "7.4");
+    fixtures.repo.add_package(php74.clone()).unwrap();
+    let php80 = get_package("ourcustom/PHP", "8.0");
+    fixtures.repo.add_package(php80.clone()).unwrap();
+    // note we are inserting this one into the repo first, unlike in the previous test
+    let ext_for_php80 = get_package("ourcustom/ext-foobar", "1.0");
+    fixtures.repo.add_package(ext_for_php80.clone()).unwrap();
+    let ext_for_php74 = get_package("ourcustom/ext-foobar", "1.0");
+    fixtures.repo.add_package(ext_for_php74.clone()).unwrap();
+
+    ext_for_php80
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "ourcustom/php".to_string(),
+            link(
+                "ourcustom/ext-foobar",
+                "ourcustom/PHP",
+                multi(vec![
+                    get_version_constraint(">=", "8.0.0"),
+                    get_version_constraint("<", "8.1.0"),
+                ]),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    ext_for_php74
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "ourcustom/php".to_string(),
+            link(
+                "ourcustom/ext-foobar",
+                "ourcustom/PHP",
+                multi(vec![
+                    get_version_constraint(">=", "7.4.0"),
+                    get_version_constraint("<", "7.5.0"),
+                ]),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    // reposComplete()
+    let mut repo_set = fixtures.repo_set;
+    repo_set
+        .add_repository(RepositoryInterfaceHandle::new(fixtures.repo))
+        .unwrap();
+    repo_set
+        .add_repository(fixtures.repo_locked.clone().into())
+        .unwrap();
+
+    let mut request = fixtures.request;
+    request.require_name("ourcustom/PHP", None).unwrap();
+    request.require_name("ourcustom/ext-foobar", None).unwrap();
+
+    check_solver_result_repo_set(
+        &mut repo_set,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: php80.clone(),
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: ext_for_php80.clone(),
+            },
+        ],
+    );
+
+    // unlike in the previous test, the order of requirements no longer matters now
+    let mut request = Request::new(Some(fixtures.repo_locked.clone()));
+    request.require_name("ourcustom/ext-foobar", None).unwrap();
+    request.require_name("ourcustom/PHP", None).unwrap();
+
+    check_solver_result_repo_set(
+        &mut repo_set,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: php80,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: ext_for_php80,
+            },
+        ],
+    );
 }
 
 #[ignore]
@@ -297,11 +689,46 @@ fn test_solver_fix_locked_with_alternative() {
     );
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_solver_update_does_only_update() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo_locked.add_package(package_a.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo_locked.add_package(package_b.clone()).unwrap();
+    let new_package_b = get_package("B", "1.1");
+    fixtures.repo.add_package(new_package_b.clone()).unwrap();
+
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint(">=", "1.0.0.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.fix_package(package_a.clone());
+    request
+        .require_name("B", Some(get_version_constraint("=", "1.1.0.0")))
+        .unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![ExpectedJob::Update {
+            from: package_b,
+            to: new_package_b,
+        }],
+    );
 }
 
 #[ignore]
@@ -328,11 +755,63 @@ fn test_solver_update_single() {
     );
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_solver_update_all() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo_locked.add_package(package_a.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo_locked.add_package(package_b.clone()).unwrap();
+    let new_package_a = get_package("A", "1.1");
+    fixtures.repo.add_package(new_package_a.clone()).unwrap();
+    let new_package_b = get_package("B", "1.1");
+    fixtures.repo.add_package(new_package_b.clone()).unwrap();
+
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                MatchAllConstraint::new(None).into(),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    new_package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                MatchAllConstraint::new(None).into(),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Update {
+                from: package_b,
+                to: new_package_b,
+            },
+            ExpectedJob::Update {
+                from: package_a,
+                to: new_package_a,
+            },
+        ],
+    );
 }
 
 #[ignore]
@@ -475,25 +954,168 @@ fn test_solver_update_fully_constrained_prunes_installed_packages() {
     );
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_solver_all_jobs() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_d = get_package("D", "1.0");
+    fixtures.repo_locked.add_package(package_d.clone()).unwrap();
+    let old_package_c = get_package("C", "1.0");
+    fixtures
+        .repo_locked
+        .add_package(old_package_c.clone())
+        .unwrap();
+
+    let package_a = get_package("A", "2.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo.add_package(package_b.clone()).unwrap();
+    let new_package_b = get_package("B", "1.1");
+    fixtures.repo.add_package(new_package_b.clone()).unwrap();
+    let package_c = get_package("C", "1.1");
+    fixtures.repo.add_package(package_c.clone()).unwrap();
+    fixtures.repo.add_package(get_package("D", "1.0")).unwrap();
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint("<", "1.1"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+    request.require_name("C", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "remove",
+                package: package_d,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_b,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a,
+            },
+            ExpectedJob::Update {
+                from: old_package_c,
+                to: package_c,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires/setConflicts not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_solver_three_alternative_require_and_conflict() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "2.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let middle_package_b = get_package("B", "1.0");
+    fixtures.repo.add_package(middle_package_b.clone()).unwrap();
+    let new_package_b = get_package("B", "1.1");
+    fixtures.repo.add_package(new_package_b.clone()).unwrap();
+    let old_package_b = get_package("B", "0.9");
+    fixtures.repo.add_package(old_package_b.clone()).unwrap();
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint("<", "1.1"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_conflicts(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint("<", "1.0"),
+                Link::TYPE_CONFLICT,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: middle_package_b,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a,
+            },
+        ],
+    );
 }
 
-#[ignore = "setReplaces not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_solver_obsolete() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo_locked.add_package(package_a.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo.add_package(package_b.clone()).unwrap();
+    package_b
+        .as_complete_package()
+        .unwrap()
+        .__set_replaces(IndexMap::from([(
+            "a".to_string(),
+            link(
+                "B",
+                "A",
+                MatchAllConstraint::new(None).into(),
+                Link::TYPE_REPLACE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("B", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "remove",
+                package: package_a,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_b,
+            },
+        ],
+    );
 }
 
 #[ignore]
@@ -520,109 +1142,925 @@ fn test_install_one_of_two_alternatives() {
     );
 }
 
-#[ignore = "setRequires/setProvides not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_install_provider() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_q = get_package("Q", "1.0");
+    fixtures.repo.add_package(package_q.clone()).unwrap();
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    package_q
+        .as_complete_package()
+        .unwrap()
+        .__set_provides(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "Q",
+                "B",
+                get_version_constraint("=", "1.0"),
+                Link::TYPE_PROVIDE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+
+    // must explicitly pick the provider, so error in this case
+    solve_expecting_error(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+    );
 }
 
-#[ignore = "setRequires/setReplaces not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_skip_replacer_of_existing_package() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_q = get_package("Q", "1.0");
+    fixtures.repo.add_package(package_q.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo.add_package(package_b.clone()).unwrap();
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    package_q
+        .as_complete_package()
+        .unwrap()
+        .__set_replaces(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "Q",
+                "B",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REPLACE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: package_b,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires/setReplaces not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_no_install_replacer_of_missing_package() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_q = get_package("Q", "1.0");
+    fixtures.repo.add_package(package_q.clone()).unwrap();
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    package_q
+        .as_complete_package()
+        .unwrap()
+        .__set_replaces(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "Q",
+                "B",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REPLACE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+
+    solve_expecting_error(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+    );
 }
 
-#[ignore = "setRequires/setReplaces not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_skip_replaced_package_if_replacer_is_selected() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_q = get_package("Q", "1.0");
+    fixtures.repo.add_package(package_q.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo.add_package(package_b.clone()).unwrap();
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    package_q
+        .as_complete_package()
+        .unwrap()
+        .__set_replaces(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "Q",
+                "B",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REPLACE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+    request.require_name("Q", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: package_q,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires/setReplaces not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_pick_older_if_newer_conflicts() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_x = get_package("X", "1.0");
+    fixtures.repo.add_package(package_x.clone()).unwrap();
+    package_x
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([
+            (
+                "a".to_string(),
+                link(
+                    "X",
+                    "A",
+                    get_version_constraint(">=", "2.0.0.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+            (
+                "b".to_string(),
+                link(
+                    "X",
+                    "B",
+                    get_version_constraint(">=", "2.0.0.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+        ]));
+
+    let package_a = get_package("A", "2.0.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let new_package_a = get_package("A", "2.1.0");
+    fixtures.repo.add_package(new_package_a.clone()).unwrap();
+    let new_package_b = get_package("B", "2.1.0");
+    fixtures.repo.add_package(new_package_b.clone()).unwrap();
+
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint(">=", "2.0.0.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    // new package A depends on version of package B that does not exist
+    // => new package A is not installable
+    new_package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint(">=", "2.2.0.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    // add a package S replacing both A and B, so that S and B or S and A cannot be simultaneously installed
+    // but an alternative option for A and B both exists
+    // this creates a more difficult so solve conflict
+    let package_s = get_package("S", "2.0.0");
+    fixtures.repo.add_package(package_s.clone()).unwrap();
+    package_s
+        .as_complete_package()
+        .unwrap()
+        .__set_replaces(IndexMap::from([
+            (
+                "a".to_string(),
+                link(
+                    "S",
+                    "A",
+                    get_version_constraint(">=", "2.0.0.0"),
+                    Link::TYPE_REPLACE,
+                ),
+            ),
+            (
+                "b".to_string(),
+                link(
+                    "S",
+                    "B",
+                    get_version_constraint(">=", "2.0.0.0"),
+                    Link::TYPE_REPLACE,
+                ),
+            ),
+        ]));
+
+    let mut request = fixtures.request;
+    request.require_name("X", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: new_package_b,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_x,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_install_circular_require() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_b1 = get_package("B", "0.9");
+    fixtures.repo.add_package(package_b1.clone()).unwrap();
+    let package_b2 = get_package("B", "1.1");
+    fixtures.repo.add_package(package_b2.clone()).unwrap();
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    package_b2
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "a".to_string(),
+            link(
+                "B",
+                "A",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: package_b2,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires/setProvides not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_install_alternative_with_circular_require() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo.add_package(package_b.clone()).unwrap();
+    let package_c = get_package("C", "1.0");
+    fixtures.repo.add_package(package_c.clone()).unwrap();
+    let package_d = get_package("D", "1.0");
+    fixtures.repo.add_package(package_d.clone()).unwrap();
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link(
+                "A",
+                "B",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    package_b
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "virtual".to_string(),
+            link(
+                "B",
+                "Virtual",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    package_c
+        .as_complete_package()
+        .unwrap()
+        .__set_provides(IndexMap::from([(
+            "virtual".to_string(),
+            link(
+                "C",
+                "Virtual",
+                get_version_constraint("==", "1.0"),
+                Link::TYPE_PROVIDE,
+            ),
+        )]));
+    package_d
+        .as_complete_package()
+        .unwrap()
+        .__set_provides(IndexMap::from([(
+            "virtual".to_string(),
+            link(
+                "D",
+                "Virtual",
+                get_version_constraint("==", "1.0"),
+                Link::TYPE_PROVIDE,
+            ),
+        )]));
+
+    package_c
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "a".to_string(),
+            link(
+                "C",
+                "A",
+                get_version_constraint("==", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    package_d
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "a".to_string(),
+            link(
+                "D",
+                "A",
+                get_version_constraint("==", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+    request.require_name("C", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: package_b,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_c,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires/setReplaces not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_use_replacer_if_necessary() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo.add_package(package_b.clone()).unwrap();
+    let package_d = get_package("D", "1.0");
+    fixtures.repo.add_package(package_d.clone()).unwrap();
+    let package_d2 = get_package("D", "1.1");
+    fixtures.repo.add_package(package_d2.clone()).unwrap();
+
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([
+            (
+                "b".to_string(),
+                link(
+                    "A",
+                    "B",
+                    get_version_constraint(">=", "1.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+            (
+                "c".to_string(),
+                link(
+                    "A",
+                    "C",
+                    get_version_constraint(">=", "1.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+        ]));
+
+    package_d
+        .as_complete_package()
+        .unwrap()
+        .__set_replaces(IndexMap::from([
+            (
+                "b".to_string(),
+                link(
+                    "D",
+                    "B",
+                    get_version_constraint(">=", "1.0"),
+                    Link::TYPE_REPLACE,
+                ),
+            ),
+            (
+                "c".to_string(),
+                link(
+                    "D",
+                    "C",
+                    get_version_constraint(">=", "1.0"),
+                    Link::TYPE_REPLACE,
+                ),
+            ),
+        ]));
+
+    package_d2
+        .as_complete_package()
+        .unwrap()
+        .__set_replaces(IndexMap::from([
+            (
+                "b".to_string(),
+                link(
+                    "D",
+                    "B",
+                    get_version_constraint(">=", "1.0"),
+                    Link::TYPE_REPLACE,
+                ),
+            ),
+            (
+                "c".to_string(),
+                link(
+                    "D",
+                    "C",
+                    get_version_constraint(">=", "1.0"),
+                    Link::TYPE_REPLACE,
+                ),
+            ),
+        ]));
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+    request.require_name("D", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: package_d2,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires/setReplaces not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_issue265() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a1 = get_package("A", "2.0.999999-dev");
+    fixtures.repo.add_package(package_a1.clone()).unwrap();
+    let package_a2 = get_package("A", "2.1-dev");
+    fixtures.repo.add_package(package_a2.clone()).unwrap();
+    let package_a3 = get_package("A", "2.2-dev");
+    fixtures.repo.add_package(package_a3.clone()).unwrap();
+    let package_b1 = get_package("B", "2.0.10");
+    fixtures.repo.add_package(package_b1.clone()).unwrap();
+    let package_b2 = get_package("B", "2.0.9");
+    fixtures.repo.add_package(package_b2.clone()).unwrap();
+    let package_c = get_package("C", "2.0-dev");
+    fixtures.repo.add_package(package_c.clone()).unwrap();
+    let package_d = get_package("D", "2.0.9");
+    fixtures.repo.add_package(package_d.clone()).unwrap();
+
+    package_c
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([
+            (
+                "a".to_string(),
+                link(
+                    "C",
+                    "A",
+                    get_version_constraint(">=", "2.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+            (
+                "d".to_string(),
+                link(
+                    "C",
+                    "D",
+                    get_version_constraint(">=", "2.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+        ]));
+
+    package_d
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([
+            (
+                "a".to_string(),
+                link(
+                    "D",
+                    "A",
+                    get_version_constraint(">=", "2.1"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+            (
+                "b".to_string(),
+                link(
+                    "D",
+                    "B",
+                    get_version_constraint(">=", "2.0-dev"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+        ]));
+
+    package_b1
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "a".to_string(),
+            link(
+                "B",
+                "A",
+                get_version_constraint("==", "2.1.0.0-dev"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    package_b2
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "a".to_string(),
+            link(
+                "B",
+                "A",
+                get_version_constraint("==", "2.1.0.0-dev"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    package_b2
+        .as_complete_package()
+        .unwrap()
+        .__set_replaces(IndexMap::from([(
+            "d".to_string(),
+            link(
+                "B",
+                "D",
+                get_version_constraint("==", "2.0.9.0"),
+                Link::TYPE_REPLACE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request
+        .require_name("C", Some(get_version_constraint("==", "2.0.0.0-dev")))
+        .unwrap();
+
+    solve_expecting_error(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+    );
 }
 
-#[ignore = "setConflicts not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore = "asserts SolverProblemsException details (getProblems/getPrettyString) which solve() discards"]
 #[test]
 fn test_conflict_result_empty() {
     let _fixtures = set_up();
     todo!()
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle; also asserts SolverProblemsException details which solve() discards"]
+#[ignore = "asserts SolverProblemsException details (getProblems/getPrettyString) which solve() discards"]
 #[test]
 fn test_unsatisfiable_requires() {
     let _fixtures = set_up();
     todo!()
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle; also asserts SolverProblemsException details which solve() discards"]
+#[ignore = "asserts SolverProblemsException details (getProblems/getPrettyString) which solve() discards"]
 #[test]
 fn test_require_mismatch_exception() {
     let _fixtures = set_up();
     todo!()
 }
 
-#[ignore = "setRequires/setReplaces not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_learn_literals_with_sorted_rule_literals() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_twig2 = get_package("twig/twig", "2.0");
+    fixtures.repo.add_package(package_twig2.clone()).unwrap();
+    let package_twig16 = get_package("twig/twig", "1.6");
+    fixtures.repo.add_package(package_twig16.clone()).unwrap();
+    let package_twig15 = get_package("twig/twig", "1.5");
+    fixtures.repo.add_package(package_twig15.clone()).unwrap();
+    let package_symfony = get_package("symfony/symfony", "2.0");
+    fixtures.repo.add_package(package_symfony.clone()).unwrap();
+    let package_twig_bridge = get_package("symfony/twig-bridge", "2.0");
+    fixtures
+        .repo
+        .add_package(package_twig_bridge.clone())
+        .unwrap();
+
+    package_twig_bridge
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "twig/twig".to_string(),
+            link(
+                "symfony/twig-bridge",
+                "twig/twig",
+                get_version_constraint("<", "2.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    package_symfony
+        .as_complete_package()
+        .unwrap()
+        .__set_replaces(IndexMap::from([(
+            "symfony/twig-bridge".to_string(),
+            link(
+                "symfony/symfony",
+                "symfony/twig-bridge",
+                get_version_constraint("==", "2.0"),
+                Link::TYPE_REPLACE,
+            ),
+        )]));
+
+    let mut request = fixtures.request;
+    request.require_name("symfony/twig-bridge", None).unwrap();
+    request.require_name("twig/twig", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: package_twig16,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_twig_bridge,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_install_recursive_alias_dependencies() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_b = get_package("B", "2.0");
+    fixtures.repo.add_package(package_b.clone()).unwrap();
+    let package_a2 = get_package("A", "2.0");
+    fixtures.repo.add_package(package_a2.clone()).unwrap();
+
+    package_a2
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "b".to_string(),
+            link_pretty(
+                "A",
+                "B",
+                get_version_constraint("==", "2.0"),
+                Link::TYPE_REQUIRE,
+                "== 2.0",
+            ),
+        )]));
+    package_b
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "a".to_string(),
+            link(
+                "B",
+                "A",
+                get_version_constraint(">=", "2.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    let package_a2_alias = get_alias_package(&package_a2, "1.1");
+    fixtures.repo.add_package(package_a2_alias.clone()).unwrap();
+
+    let mut request = fixtures.request;
+    request
+        .require_name("A", Some(get_version_constraint("==", "1.1.0.0")))
+        .unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: package_b,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a2,
+            },
+            ExpectedJob::Single {
+                job: "markAliasInstalled",
+                package: package_a2_alias,
+            },
+        ],
+    );
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_install_dev_alias() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "2.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo.add_package(package_b.clone()).unwrap();
+
+    package_b
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "a".to_string(),
+            link(
+                "B",
+                "A",
+                get_version_constraint("<", "2.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    let package_a_alias = get_alias_package(&package_a, "1.1");
+    fixtures.repo.add_package(package_a_alias.clone()).unwrap();
+
+    let mut request = fixtures.request;
+    request
+        .require_name("A", Some(get_version_constraint("==", "2.0")))
+        .unwrap();
+    request.require_name("B", None).unwrap();
+
+    check_solver_result(
+        fixtures.repo_set,
+        fixtures.repo,
+        fixtures.repo_locked,
+        request,
+        vec![
+            ExpectedJob::Single {
+                job: "install",
+                package: package_a,
+            },
+            ExpectedJob::Single {
+                job: "markAliasInstalled",
+                package: package_a_alias,
+            },
+            ExpectedJob::Single {
+                job: "install",
+                package: package_b,
+            },
+        ],
+    );
 }
 
 #[ignore]
@@ -699,9 +2137,200 @@ fn test_install_root_aliases_if_alias_of_is_installed() {
     );
 }
 
-#[ignore = "setRequires not available on CompletePackageHandle (only RootPackageHandle exposes link setters)"]
+#[ignore]
 #[test]
 fn test_learn_positive_literal() {
-    let _fixtures = set_up();
-    todo!()
+    let fixtures = set_up();
+    let package_a = get_package("A", "1.0");
+    fixtures.repo.add_package(package_a.clone()).unwrap();
+    let package_b = get_package("B", "1.0");
+    fixtures.repo.add_package(package_b.clone()).unwrap();
+    let package_c1 = get_package("C", "1.0");
+    fixtures.repo.add_package(package_c1.clone()).unwrap();
+    let package_c2 = get_package("C", "2.0");
+    fixtures.repo.add_package(package_c2.clone()).unwrap();
+    let package_d = get_package("D", "1.0");
+    fixtures.repo.add_package(package_d.clone()).unwrap();
+    let package_e = get_package("E", "1.0");
+    fixtures.repo.add_package(package_e.clone()).unwrap();
+    let package_f1 = get_package("F", "1.0");
+    fixtures.repo.add_package(package_f1.clone()).unwrap();
+    let package_f2 = get_package("F", "2.0");
+    fixtures.repo.add_package(package_f2.clone()).unwrap();
+    let package_g1 = get_package("G", "1.0");
+    fixtures.repo.add_package(package_g1.clone()).unwrap();
+    let package_g2 = get_package("G", "2.0");
+    fixtures.repo.add_package(package_g2.clone()).unwrap();
+    let package_g3 = get_package("G", "3.0");
+    fixtures.repo.add_package(package_g3.clone()).unwrap();
+
+    package_a
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([
+            (
+                "b".to_string(),
+                link(
+                    "A",
+                    "B",
+                    get_version_constraint("==", "1.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+            (
+                "c".to_string(),
+                link(
+                    "A",
+                    "C",
+                    get_version_constraint(">=", "1.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+            (
+                "d".to_string(),
+                link(
+                    "A",
+                    "D",
+                    get_version_constraint("==", "1.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+        ]));
+
+    package_b
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "e".to_string(),
+            link(
+                "B",
+                "E",
+                get_version_constraint("==", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    package_c1
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "f".to_string(),
+            link(
+                "C",
+                "F",
+                get_version_constraint("==", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    package_c2
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([
+            (
+                "f".to_string(),
+                link(
+                    "C",
+                    "F",
+                    get_version_constraint("==", "1.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+            (
+                "g".to_string(),
+                link(
+                    "C",
+                    "G",
+                    get_version_constraint(">=", "1.0"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+        ]));
+
+    package_d
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "f".to_string(),
+            link(
+                "D",
+                "F",
+                get_version_constraint(">=", "1.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    package_e
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "g".to_string(),
+            link(
+                "E",
+                "G",
+                get_version_constraint("<=", "2.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+
+    // reposComplete() + createSolver() inline so the testFlagLearnedPositiveLiteral flag can be
+    // asserted on the same solver instance used to solve.
+    let mut repo_set = fixtures.repo_set;
+    repo_set
+        .add_repository(RepositoryInterfaceHandle::new(fixtures.repo))
+        .unwrap();
+    repo_set
+        .add_repository(fixtures.repo_locked.into())
+        .unwrap();
+
+    let mut request = fixtures.request;
+    request.require_name("A", None).unwrap();
+
+    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
+    let pool = repo_set
+        .create_pool(&mut request, io.clone(), None, None, vec![], None, None)
+        .unwrap();
+    let policy: Rc<dyn PolicyInterface> = Rc::new(DefaultPolicy::new(false, false, None));
+    let mut solver =
+        shirabe::dependency_resolver::solver::Solver::new(policy, Rc::new(RefCell::new(pool)), io);
+
+    // check correct setup for assertion later
+    assert!(!solver.test_flag_learned_positive_literal);
+
+    let transaction = solver.solve(&request, None).unwrap();
+
+    let expected = vec![
+        ("install".to_string(), package_f1.get_unique_name()),
+        ("install".to_string(), package_d.get_unique_name()),
+        ("install".to_string(), package_g2.get_unique_name()),
+        ("install".to_string(), package_c2.get_unique_name()),
+        ("install".to_string(), package_e.get_unique_name()),
+        ("install".to_string(), package_b.get_unique_name()),
+        ("install".to_string(), package_a.get_unique_name()),
+    ];
+    let mut result: Vec<(String, String)> = Vec::new();
+    for operation in transaction.get_operations() {
+        if let Some(update) = operation.as_update_operation() {
+            result.push((
+                "update".to_string(),
+                format!(
+                    "{} => {}",
+                    update.get_initial_package().get_unique_name(),
+                    update.get_target_package().get_unique_name()
+                ),
+            ));
+        } else {
+            let op_type = operation.get_operation_type();
+            let job = if op_type == "uninstall" {
+                "remove".to_string()
+            } else {
+                op_type
+            };
+            result.push((job, operation.get_package().get_unique_name()));
+        }
+    }
+    assert_eq!(expected, result);
+
+    // verify that the code path leading to a negative literal resulting in a positive learned
+    // literal is actually executed
+    assert!(solver.test_flag_learned_positive_literal);
 }
diff --git a/crates/shirabe/tests/dependency_resolver/transaction_test.rs b/crates/shirabe/tests/dependency_resolver/transaction_test.rs
index a5ca310..7013816 100644
--- a/crates/shirabe/tests/dependency_resolver/transaction_test.rs
+++ b/crates/shirabe/tests/dependency_resolver/transaction_test.rs
@@ -1,7 +1,286 @@
 //! ref: composer/tests/Composer/Test/DependencyResolver/TransactionTest.php
 
+use indexmap::IndexMap;
+use shirabe::dependency_resolver::transaction::Transaction;
+use shirabe::package::Link;
+use shirabe::package::handle::PackageInterfaceHandle;
+use shirabe_php_shim::PhpMixed;
+
+use crate::test_case::{get_alias_package, get_package, get_version_constraint};
+
+/// PHP `new Link($source, $target, $constraint, $type)`: prettyConstraint defaults to
+/// `(string) $constraint`.
+fn mk_link(
+    source: &str,
+    target: &str,
+    constraint: shirabe_semver::constraint::AnyConstraint,
+    r#type: &str,
+) -> Link {
+    let pretty = constraint.get_pretty_string();
+    Link::new(
+        source.to_string(),
+        target.to_string(),
+        constraint,
+        Some(r#type.to_string()),
+        pretty,
+    )
+}
+
+/// Mirrors a PHP expected/actual operation entry.
+#[derive(Debug)]
+enum OperationEntry {
+    Job {
+        job: String,
+        package: PackageInterfaceHandle,
+    },
+    Update {
+        from: PackageInterfaceHandle,
+        to: PackageInterfaceHandle,
+    },
+}
+
+impl PartialEq for OperationEntry {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (
+                Self::Job {
+                    job: j1,
+                    package: p1,
+                },
+                Self::Job {
+                    job: j2,
+                    package: p2,
+                },
+            ) => j1 == j2 && p1.ptr_eq(p2),
+            (Self::Update { from: f1, to: t1 }, Self::Update { from: f2, to: t2 }) => {
+                f1.ptr_eq(f2) && t1.ptr_eq(t2)
+            }
+            _ => false,
+        }
+    }
+}
+
+fn check_transaction_operations(transaction: &Transaction, expected: Vec<OperationEntry>) {
+    let mut result: Vec<OperationEntry> = vec![];
+    for operation in transaction.get_operations() {
+        if let Some(update) = operation.as_update_operation() {
+            result.push(OperationEntry::Update {
+                from: update.get_initial_package(),
+                to: update.get_target_package(),
+            });
+        } else {
+            result.push(OperationEntry::Job {
+                job: operation.get_operation_type(),
+                package: operation.get_package(),
+            });
+        }
+    }
+
+    assert_eq!(expected, result);
+}
+
 #[test]
-#[ignore = "CompletePackageHandle lacks set_type/set_requires/set_provides/set_extra; these setters exist only on RootPackageHandle, so the non-root package fixture cannot be expressed"]
+#[ignore]
 fn test_transaction_generation_and_sorting() {
-    todo!()
+    let package_a = get_package("a/a", "dev-master");
+    let package_a_alias = get_alias_package(&package_a, "1.0.x-dev");
+    let package_b = get_package("b/b", "1.0.0");
+    let package_e = get_package("e/e", "dev-foo");
+    let package_e_alias = get_alias_package(&package_e, "1.0.x-dev");
+    let package_c = get_package("c/c", "1.0.0");
+    let present_packages = vec![
+        package_a.clone(),
+        package_a_alias.clone(),
+        package_b.clone(),
+        package_e.clone(),
+        package_e_alias.clone(),
+        package_c.clone(),
+    ];
+
+    let package_b_new = get_package("b/b", "2.1.3");
+    let package_d = get_package("d/d", "1.2.3");
+    let package_f = get_package("f/f", "1.0.0");
+    let package_f_alias1 = get_alias_package(&package_f, "dev-foo");
+    let package_g = get_package("g/g", "1.0.0");
+    let package_a0_first = get_package("a0/first", "1.2.3");
+    let package_f_alias2 = get_alias_package(&package_f, "dev-bar");
+    let plugin = get_package("x/plugin", "1.0.0");
+    let plugin2_dep = get_package("x/plugin2-dep", "1.0.0");
+    let plugin2 = get_package("x/plugin2", "1.0.0");
+    let dl_modifying_plugin = get_package("x/downloads-modifying", "1.0.0");
+    let dl_modifying_plugin2_dep = get_package("x/downloads-modifying2-dep", "1.0.0");
+    let dl_modifying_plugin2 = get_package("x/downloads-modifying2", "1.0.0");
+    let result_packages = vec![
+        package_a.clone(),
+        package_a_alias.clone(),
+        package_b_new.clone(),
+        package_d.clone(),
+        package_f.clone(),
+        package_f_alias1.clone(),
+        package_g.clone(),
+        package_a0_first.clone(),
+        package_f_alias2.clone(),
+        plugin.clone(),
+        plugin2_dep.clone(),
+        plugin2.clone(),
+        dl_modifying_plugin.clone(),
+        dl_modifying_plugin2_dep.clone(),
+        dl_modifying_plugin2.clone(),
+    ];
+
+    plugin
+        .as_complete_package()
+        .unwrap()
+        .__set_type("composer-installer".to_string());
+    for plugin_package in [&plugin2, &dl_modifying_plugin, &dl_modifying_plugin2] {
+        plugin_package
+            .as_complete_package()
+            .unwrap()
+            .__set_type("composer-plugin".to_string());
+    }
+
+    plugin2
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "x/plugin2-dep".to_string(),
+            mk_link(
+                "x/plugin2",
+                "x/plugin2-dep",
+                get_version_constraint("=", "1.0.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    dl_modifying_plugin2
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([(
+            "x/downloads-modifying2-dep".to_string(),
+            mk_link(
+                "x/downloads-modifying2",
+                "x/downloads-modifying2-dep",
+                get_version_constraint("=", "1.0.0"),
+                Link::TYPE_REQUIRE,
+            ),
+        )]));
+    dl_modifying_plugin
+        .as_complete_package()
+        .unwrap()
+        .__set_extra(IndexMap::from([(
+            "plugin-modifies-downloads".to_string(),
+            PhpMixed::Bool(true),
+        )]));
+    dl_modifying_plugin2
+        .as_complete_package()
+        .unwrap()
+        .__set_extra(IndexMap::from([(
+            "plugin-modifies-downloads".to_string(),
+            PhpMixed::Bool(true),
+        )]));
+
+    package_d
+        .as_complete_package()
+        .unwrap()
+        .__set_requires(IndexMap::from([
+            (
+                "f/f".to_string(),
+                mk_link(
+                    "d/d",
+                    "f/f",
+                    get_version_constraint(">", "0.2"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+            (
+                "g/provider".to_string(),
+                mk_link(
+                    "d/d",
+                    "g/provider",
+                    get_version_constraint(">", "0.2"),
+                    Link::TYPE_REQUIRE,
+                ),
+            ),
+        ]));
+    package_g
+        .as_complete_package()
+        .unwrap()
+        .__set_provides(IndexMap::from([(
+            "g/provider".to_string(),
+            mk_link(
+                "g/g",
+                "g/provider",
+                get_version_constraint("==", "1.0.0"),
+                Link::TYPE_PROVIDE,
+            ),
+        )]));
+
+    let expected_operations = vec![
+        OperationEntry::Job {
+            job: "uninstall".to_string(),
+            package: package_c.clone(),
+        },
+        OperationEntry::Job {
+            job: "uninstall".to_string(),
+            package: package_e.clone(),
+        },
+        OperationEntry::Job {
+            job: "markAliasUninstalled".to_string(),
+            package: package_e_alias.clone(),
+        },
+        OperationEntry::Job {
+            job: "install".to_string(),
+            package: dl_modifying_plugin.clone(),
+        },
+        OperationEntry::Job {
+            job: "install".to_string(),
+            package: dl_modifying_plugin2_dep.clone(),
+        },
+        OperationEntry::Job {
+            job: "install".to_string(),
+            package: dl_modifying_plugin2.clone(),
+        },
+        OperationEntry::Job {
+            job: "install".to_string(),
+            package: plugin.clone(),
+        },
+        OperationEntry::Job {
+            job: "install".to_string(),
+            package: plugin2_dep.clone(),
+        },
+        OperationEntry::Job {
+            job: "install".to_string(),
+            package: plugin2.clone(),
+        },
+        OperationEntry::Job {
+            job: "install".to_string(),
+            package: package_a0_first.clone(),
+        },
+        OperationEntry::Update {
+            from: package_b.clone(),
+            to: package_b_new.clone(),
+        },
+        OperationEntry::Job {
+            job: "install".to_string(),
+            package: package_g.clone(),
+        },
+        OperationEntry::Job {
+            job: "install".to_string(),
+            package: package_f.clone(),
+        },
+        OperationEntry::Job {
+            job: "markAliasInstalled".to_string(),
+            package: package_f_alias2.clone(),
+        },
+        OperationEntry::Job {
+            job: "markAliasInstalled".to_string(),
+            package: package_f_alias1.clone(),
+        },
+        OperationEntry::Job {
+            job: "install".to_string(),
+            package: package_d.clone(),
+        },
+    ];
+
+    let transaction = Transaction::new(present_packages, result_packages);
+    check_transaction_operations(&transaction, expected_operations);
 }