1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
//! ref: composer/tests/Composer/Test/DependencyResolver/RuleSetIteratorTest.php
use indexmap::IndexMap;
use shirabe::dependency_resolver::generic_rule::GenericRule;
use shirabe::dependency_resolver::pool::Pool;
use shirabe::dependency_resolver::rule::{RULE_LEARNED, RULE_ROOT_REQUIRE, ReasonData, Rule};
use shirabe::dependency_resolver::rule_set::RuleSet;
use shirabe::dependency_resolver::rule_set_iterator::RuleSetIterator;
use shirabe_semver::constraint::MatchAllConstraint;
use std::cell::RefCell;
use std::rc::Rc;
type Rules = IndexMap<i64, Vec<Rc<RefCell<Rule>>>>;
fn root_require_rule() -> Rc<RefCell<Rule>> {
Rc::new(RefCell::new(Rule::Generic(GenericRule::new(
vec![],
RULE_ROOT_REQUIRE,
ReasonData::RootRequire {
package_name: String::new(),
constraint: MatchAllConstraint::new(None).into(),
},
))))
}
fn set_up() -> (Pool, Rules) {
let pool = Pool::new(
vec![],
vec![],
IndexMap::new(),
IndexMap::new(),
IndexMap::new(),
IndexMap::new(),
);
let mut rules: Rules = IndexMap::new();
rules.insert(
RuleSet::TYPE_REQUEST,
vec![root_require_rule(), root_require_rule()],
);
rules.insert(
RuleSet::TYPE_LEARNED,
vec![Rc::new(RefCell::new(Rule::Generic(GenericRule::new(
vec![],
RULE_LEARNED,
ReasonData::Int(1),
))))],
);
rules.insert(RuleSet::TYPE_PACKAGE, vec![]);
(pool, rules)
}
#[test]
fn test_foreach() {
let (_pool, rules) = set_up();
let mut rule_set_iterator = RuleSetIterator::new(rules.clone());
let mut result: Vec<Rc<RefCell<Rule>>> = Vec::new();
while rule_set_iterator.valid() {
result.push(rule_set_iterator.current());
rule_set_iterator.next();
}
let expected = [
rules[&RuleSet::TYPE_REQUEST][0].clone(),
rules[&RuleSet::TYPE_REQUEST][1].clone(),
rules[&RuleSet::TYPE_LEARNED][0].clone(),
];
assert_eq!(expected.len(), result.len());
for (e, r) in expected.iter().zip(result.iter()) {
assert!(Rc::ptr_eq(e, r));
}
}
#[test]
fn test_keys() {
let (_pool, rules) = set_up();
let mut rule_set_iterator = RuleSetIterator::new(rules);
let mut result: Vec<i64> = Vec::new();
while rule_set_iterator.valid() {
result.push(rule_set_iterator.key());
rule_set_iterator.next();
}
let expected = vec![
RuleSet::TYPE_REQUEST,
RuleSet::TYPE_REQUEST,
RuleSet::TYPE_LEARNED,
];
assert_eq!(expected, result);
}
|
