This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5579

rust: factorized testing Graphs
ClosedPublic

Authored by gracinet on Jan 14 2019, 9:13 PM.

Details

Reviewers
kevincox
Group Reviewers
hg-reviewers
Commits
rHG168041fa6d5f: rust: factorized testing Graphs
Summary

it will useful to use these outside of ancestors, too.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

gracinet created this revision.Jan 14 2019, 9:13 PM
kevincox accepted this revision.Jan 15 2019, 2:58 PM
yuja added a subscriber: yuja.Jan 16 2019, 7:42 AM

Queued the series, thanks.

+++ b/rust/hg-core/src/testing.rs

Maybe we can add separate test files, but I don't know which is preferred.

https://doc.rust-lang.org/book/ch11-03-test-organization.html#submodules-in-integration-tests

Closed by commit rHG168041fa6d5f: rust: factorized testing Graphs (authored by gracinet). · Explain WhyJan 16 2019, 7:43 AM
This revision was automatically updated to reflect the committed changes.
gracinet added a comment.Jan 16 2019, 9:50 AM

@yuja the doc you're linking is about integration tests, so it wouldn't apply to these tests which are really unitary in my mind. Usually the main difference would be the access to the private constructs that the integration tests can't perform, but it's true that most of these implementations are public anyway.

yuja added a comment.Jan 17 2019, 9:21 AM
@yuja the doc you're linking is about integration tests, so it wouldn't apply to these tests which are really unitary in my mind. Usually the main difference would be the access to the private constructs that the integration tests can't perform, but it's true that most of these implementations are public anyway.

Yep, I tend to ignore the theoretical meanings of unit vs integration, and
use them as test frameworks fit to small/simple and big/complex tests
respectively.

I just don't know if that's common in Rust community.

Revision Contents
Changeset List

Diff 13213

rust/hg-core/src/ancestors.rs

Ok(missing) Ok(missing)
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::testing::{SampleGraph, VecGraph};
use std::iter::FromIterator; use std::iter::FromIterator;
#[derive(Clone, Debug)]
struct Stub;
/// This is the same as the dict from test-ancestors.py
impl Graph for Stub {
fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
match rev {
0 => Ok([-1, -1]),
1 => Ok([0, -1]),
2 => Ok([1, -1]),
3 => Ok([1, -1]),
4 => Ok([2, -1]),
5 => Ok([4, -1]),
6 => Ok([4, -1]),
7 => Ok([4, -1]),
8 => Ok([-1, -1]),
9 => Ok([6, 7]),
10 => Ok([5, -1]),
11 => Ok([3, 7]),
12 => Ok([9, -1]),
13 => Ok([8, -1]),
r => Err(GraphError::ParentOutOfRange(r)),
}
}
}
fn list_ancestors<G: Graph>( fn list_ancestors<G: Graph>(
graph: G, graph: G,
initrevs: Vec<Revision>, initrevs: Vec<Revision>,
stoprev: Revision, stoprev: Revision,
inclusive: bool, inclusive: bool,
) -> Vec<Revision> { ) -> Vec<Revision> {
AncestorsIterator::new(graph, initrevs, stoprev, inclusive) AncestorsIterator::new(graph, initrevs, stoprev, inclusive)
.unwrap() .unwrap()
.map(|res| res.unwrap()) .map(|res| res.unwrap())
.collect() .collect()
} }
#[test] #[test]
/// Same tests as test-ancestor.py, without membership /// Same tests as test-ancestor.py, without membership
/// (see also test-ancestor.py.out) /// (see also test-ancestor.py.out)
fn test_list_ancestor() { fn test_list_ancestor() {
assert_eq!(list_ancestors(Stub, vec![], 0, false), vec![]); assert_eq!(list_ancestors(SampleGraph, vec![], 0, false), vec![]);
assert_eq!( assert_eq!(
list_ancestors(Stub, vec![11, 13], 0, false), list_ancestors(SampleGraph, vec![11, 13], 0, false),
vec![8, 7, 4, 3, 2, 1, 0] vec![8, 7, 4, 3, 2, 1, 0]
); );
assert_eq!(list_ancestors(Stub, vec![1, 3], 0, false), vec![1, 0]);
assert_eq!( assert_eq!(
list_ancestors(Stub, vec![11, 13], 0, true), list_ancestors(SampleGraph, vec![1, 3], 0, false),
vec![1, 0]
);
assert_eq!(
list_ancestors(SampleGraph, vec![11, 13], 0, true),
vec![13, 11, 8, 7, 4, 3, 2, 1, 0] vec![13, 11, 8, 7, 4, 3, 2, 1, 0]
); );
assert_eq!(list_ancestors(Stub, vec![11, 13], 6, false), vec![8, 7]);
assert_eq!( assert_eq!(
list_ancestors(Stub, vec![11, 13], 6, true), list_ancestors(SampleGraph, vec![11, 13], 6, false),
vec![8, 7]
);
assert_eq!(
list_ancestors(SampleGraph, vec![11, 13], 6, true),
vec![13, 11, 8, 7] vec![13, 11, 8, 7]
); );
assert_eq!(list_ancestors(Stub, vec![11, 13], 11, true), vec![13, 11]);
assert_eq!(list_ancestors(Stub, vec![11, 13], 12, true), vec![13]);
assert_eq!( assert_eq!(
list_ancestors(Stub, vec![10, 1], 0, true), list_ancestors(SampleGraph, vec![11, 13], 11, true),
vec![13, 11]
);
assert_eq!(
list_ancestors(SampleGraph, vec![11, 13], 12, true),
vec![13]
);
assert_eq!(
list_ancestors(SampleGraph, vec![10, 1], 0, true),
vec![10, 5, 4, 2, 1, 0] vec![10, 5, 4, 2, 1, 0]
); );
} }
#[test] #[test]
/// Corner case that's not directly in test-ancestors.py, but /// Corner case that's not directly in test-ancestors.py, but
/// that happens quite often, as demonstrated by running the whole /// that happens quite often, as demonstrated by running the whole
/// suite. /// suite.
/// For instance, run tests/test-obsolete-checkheads.t /// For instance, run tests/test-obsolete-checkheads.t
fn test_nullrev_input() { fn test_nullrev_input() {
let mut iter = let mut iter =
AncestorsIterator::new(Stub, vec![-1], 0, false).unwrap(); AncestorsIterator::new(SampleGraph, vec![-1], 0, false).unwrap();
assert_eq!(iter.next(), None) assert_eq!(iter.next(), None)
} }
#[test] #[test]
fn test_contains() { fn test_contains() {
let mut lazy = let mut lazy =
AncestorsIterator::new(Stub, vec![10, 1], 0, true).unwrap(); AncestorsIterator::new(SampleGraph, vec![10, 1], 0, true).unwrap();
assert!(lazy.contains(1).unwrap()); assert!(lazy.contains(1).unwrap());
assert!(!lazy.contains(3).unwrap()); assert!(!lazy.contains(3).unwrap());
let mut lazy = let mut lazy =
AncestorsIterator::new(Stub, vec![0], 0, false).unwrap(); AncestorsIterator::new(SampleGraph, vec![0], 0, false).unwrap();
assert!(!lazy.contains(NULL_REVISION).unwrap()); assert!(!lazy.contains(NULL_REVISION).unwrap());
} }
#[test] #[test]
fn test_peek() { fn test_peek() {
let mut iter = let mut iter =
AncestorsIterator::new(Stub, vec![10], 0, true).unwrap(); AncestorsIterator::new(SampleGraph, vec![10], 0, true).unwrap();
// peek() gives us the next value // peek() gives us the next value
assert_eq!(iter.peek(), Some(10)); assert_eq!(iter.peek(), Some(10));
// but it's not been consumed // but it's not been consumed
assert_eq!(iter.next(), Some(Ok(10))); assert_eq!(iter.next(), Some(Ok(10)));
// and iteration resumes normally // and iteration resumes normally
assert_eq!(iter.next(), Some(Ok(5))); assert_eq!(iter.next(), Some(Ok(5)));
// let's drain the iterator to test peek() at the end // let's drain the iterator to test peek() at the end
while iter.next().is_some() {} while iter.next().is_some() {}
assert_eq!(iter.peek(), None); assert_eq!(iter.peek(), None);
} }
#[test] #[test]
fn test_empty() { fn test_empty() {
let mut iter = let mut iter =
AncestorsIterator::new(Stub, vec![10], 0, true).unwrap(); AncestorsIterator::new(SampleGraph, vec![10], 0, true).unwrap();
assert!(!iter.is_empty()); assert!(!iter.is_empty());
while iter.next().is_some() {} while iter.next().is_some() {}
assert!(!iter.is_empty()); assert!(!iter.is_empty());
let iter = AncestorsIterator::new(Stub, vec![], 0, true).unwrap(); let iter =
AncestorsIterator::new(SampleGraph, vec![], 0, true).unwrap();
assert!(iter.is_empty()); assert!(iter.is_empty());
// case where iter.seen == {NULL_REVISION} // case where iter.seen == {NULL_REVISION}
let iter = AncestorsIterator::new(Stub, vec![0], 0, false).unwrap(); let iter =
AncestorsIterator::new(SampleGraph, vec![0], 0, false).unwrap();
assert!(iter.is_empty()); assert!(iter.is_empty());
} }
/// A corrupted Graph, supporting error handling tests /// A corrupted Graph, supporting error handling tests
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
struct Corrupted; struct Corrupted;
impl Graph for Corrupted { impl Graph for Corrupted {
fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> { fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
match rev { match rev {
1 => Ok([0, -1]), 1 => Ok([0, -1]),
r => Err(GraphError::ParentOutOfRange(r)), r => Err(GraphError::ParentOutOfRange(r)),
} }
} }
} }
#[test] #[test]
fn test_initrev_out_of_range() { fn test_initrev_out_of_range() {
// inclusive=false looks up initrev's parents right away // inclusive=false looks up initrev's parents right away
match AncestorsIterator::new(Stub, vec![25], 0, false) { match AncestorsIterator::new(SampleGraph, vec![25], 0, false) {
Ok(_) => panic!("Should have been ParentOutOfRange"), Ok(_) => panic!("Should have been ParentOutOfRange"),
Err(e) => assert_eq!(e, GraphError::ParentOutOfRange(25)), Err(e) => assert_eq!(e, GraphError::ParentOutOfRange(25)),
} }
} }
#[test] #[test]
fn test_next_out_of_range() { fn test_next_out_of_range() {
// inclusive=false looks up initrev's parents right away // inclusive=false looks up initrev's parents right away
let mut iter = let mut iter =
AncestorsIterator::new(Corrupted, vec![1], 0, false).unwrap(); AncestorsIterator::new(Corrupted, vec![1], 0, false).unwrap();
assert_eq!(iter.next(), Some(Err(GraphError::ParentOutOfRange(0)))); assert_eq!(iter.next(), Some(Err(GraphError::ParentOutOfRange(0))));
} }
#[test] #[test]
fn test_lazy_iter_contains() { fn test_lazy_iter_contains() {
let mut lazy = let mut lazy =
LazyAncestors::new(Stub, vec![11, 13], 0, false).unwrap(); LazyAncestors::new(SampleGraph, vec![11, 13], 0, false).unwrap();
let revs: Vec<Revision> = lazy.iter().map(|r| r.unwrap()).collect(); let revs: Vec<Revision> = lazy.iter().map(|r| r.unwrap()).collect();
// compare with iterator tests on the same initial revisions // compare with iterator tests on the same initial revisions
assert_eq!(revs, vec![8, 7, 4, 3, 2, 1, 0]); assert_eq!(revs, vec![8, 7, 4, 3, 2, 1, 0]);
// contains() results are correct, unaffected by the fact that // contains() results are correct, unaffected by the fact that
// we consumed entirely an iterator out of lazy // we consumed entirely an iterator out of lazy
assert_eq!(lazy.contains(2), Ok(true)); assert_eq!(lazy.contains(2), Ok(true));
assert_eq!(lazy.contains(9), Ok(false)); assert_eq!(lazy.contains(9), Ok(false));
} }
#[test] #[test]
fn test_lazy_contains_iter() { fn test_lazy_contains_iter() {
let mut lazy = let mut lazy =
LazyAncestors::new(Stub, vec![11, 13], 0, false).unwrap(); // reminder: [8, 7, 4, 3, 2, 1, 0] LazyAncestors::new(SampleGraph, vec![11, 13], 0, false).unwrap(); // reminder: [8, 7, 4, 3, 2, 1, 0]
assert_eq!(lazy.contains(2), Ok(true)); assert_eq!(lazy.contains(2), Ok(true));
assert_eq!(lazy.contains(6), Ok(false)); assert_eq!(lazy.contains(6), Ok(false));
// after consumption of 2 by the inner iterator, results stay // after consumption of 2 by the inner iterator, results stay
// consistent // consistent
assert_eq!(lazy.contains(2), Ok(true)); assert_eq!(lazy.contains(2), Ok(true));
assert_eq!(lazy.contains(5), Ok(false)); assert_eq!(lazy.contains(5), Ok(false));
// iter() still gives us a fresh iterator // iter() still gives us a fresh iterator
let revs: Vec<Revision> = lazy.iter().map(|r| r.unwrap()).collect(); let revs: Vec<Revision> = lazy.iter().map(|r| r.unwrap()).collect();
assert_eq!(revs, vec![8, 7, 4, 3, 2, 1, 0]); assert_eq!(revs, vec![8, 7, 4, 3, 2, 1, 0]);
} }
#[test] #[test]
/// Test constructor, add/get bases /// Test constructor, add/get bases
fn test_missing_bases() { fn test_missing_bases() {
let mut missing_ancestors = let mut missing_ancestors =
MissingAncestors::new(Stub, [5, 3, 1, 3].iter().cloned()); MissingAncestors::new(SampleGraph, [5, 3, 1, 3].iter().cloned());
let mut as_vec: Vec<Revision> = let mut as_vec: Vec<Revision> =
missing_ancestors.get_bases().iter().cloned().collect(); missing_ancestors.get_bases().iter().cloned().collect();
as_vec.sort(); as_vec.sort();
assert_eq!(as_vec, [1, 3, 5]); assert_eq!(as_vec, [1, 3, 5]);
missing_ancestors.add_bases([3, 7, 8].iter().cloned()); missing_ancestors.add_bases([3, 7, 8].iter().cloned());
as_vec = missing_ancestors.get_bases().iter().cloned().collect(); as_vec = missing_ancestors.get_bases().iter().cloned().collect();
as_vec.sort(); as_vec.sort();
assert_eq!(as_vec, [1, 3, 5, 7, 8]); assert_eq!(as_vec, [1, 3, 5, 7, 8]);
} }
fn assert_missing_remove( fn assert_missing_remove(
bases: &[Revision], bases: &[Revision],
revs: &[Revision], revs: &[Revision],
expected: &[Revision], expected: &[Revision],
) { ) {
let mut missing_ancestors = let mut missing_ancestors =
MissingAncestors::new(Stub, bases.iter().cloned()); MissingAncestors::new(SampleGraph, bases.iter().cloned());
let mut revset: HashSet<Revision> = revs.iter().cloned().collect(); let mut revset: HashSet<Revision> = revs.iter().cloned().collect();
missing_ancestors missing_ancestors
.remove_ancestors_from(&mut revset) .remove_ancestors_from(&mut revset)
.unwrap(); .unwrap();
let mut as_vec: Vec<Revision> = revset.into_iter().collect(); let mut as_vec: Vec<Revision> = revset.into_iter().collect();
as_vec.sort(); as_vec.sort();
assert_eq!(as_vec.as_slice(), expected); assert_eq!(as_vec.as_slice(), expected);
} }
} }
fn assert_missing_ancestors( fn assert_missing_ancestors(
bases: &[Revision], bases: &[Revision],
revs: &[Revision], revs: &[Revision],
expected: &[Revision], expected: &[Revision],
) { ) {
let mut missing_ancestors = let mut missing_ancestors =
MissingAncestors::new(Stub, bases.iter().cloned()); MissingAncestors::new(SampleGraph, bases.iter().cloned());
let missing = missing_ancestors let missing = missing_ancestors
.missing_ancestors(revs.iter().cloned()) .missing_ancestors(revs.iter().cloned())
.unwrap(); .unwrap();
assert_eq!(missing.as_slice(), expected); assert_eq!(missing.as_slice(), expected);
} }
#[test] #[test]
fn test_missing_ancestors() { fn test_missing_ancestors() {
// examples taken from test-ancestors.py by having it run // examples taken from test-ancestors.py by having it run
// on the same graph (both naive and fast Python algs) // on the same graph (both naive and fast Python algs)
assert_missing_ancestors(&[10], &[11], &[3, 7, 11]); assert_missing_ancestors(&[10], &[11], &[3, 7, 11]);
assert_missing_ancestors(&[11], &[10], &[5, 10]); assert_missing_ancestors(&[11], &[10], &[5, 10]);
assert_missing_ancestors(&[7], &[9, 11], &[3, 6, 9, 11]); assert_missing_ancestors(&[7], &[9, 11], &[3, 6, 9, 11]);
} }
// A Graph represented by a vector whose indices are revisions
// and values are parents of the revisions
type VecGraph = Vec<[Revision; 2]>;
impl Graph for VecGraph {
fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
Ok(self[rev as usize])
}
}
/// An interesting case found by a random generator similar to /// An interesting case found by a random generator similar to
/// the one in test-ancestor.py. An early version of Rust MissingAncestors /// the one in test-ancestor.py. An early version of Rust MissingAncestors
/// failed this, yet none of the integration tests of the whole suite /// failed this, yet none of the integration tests of the whole suite
/// catched it. /// catched it.
#[test] #[test]
fn test_remove_ancestors_from_case1() { fn test_remove_ancestors_from_case1() {
let graph: VecGraph = vec![ let graph: VecGraph = vec![
[NULL_REVISION, NULL_REVISION], [NULL_REVISION, NULL_REVISION],

rust/hg-core/src/lib.rs

// Copyright 2018 Georges Racinet <gracinet@anybox.fr> // Copyright 2018 Georges Racinet <gracinet@anybox.fr>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
mod ancestors; mod ancestors;
pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors}; pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors};
#[cfg(test)]
pub mod testing;
/// Mercurial revision numbers /// Mercurial revision numbers
/// ///
/// As noted in revlog.c, revision numbers are actually encoded in /// As noted in revlog.c, revision numbers are actually encoded in
/// 4 bytes, and are liberally converted to ints, whence the i32 /// 4 bytes, and are liberally converted to ints, whence the i32
pub type Revision = i32; pub type Revision = i32;
pub const NULL_REVISION: Revision = -1; pub const NULL_REVISION: Revision = -1;

rust/hg-core/src/testing.rs

  • This file was added.
// testing.rs
//
// Copyright 2018 Georges Racinet <georges.racinet@octobus.net>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.
use crate::{Graph, GraphError, Revision, NULL_REVISION};
/// A stub `Graph`, same as the one from `test-ancestor.py`
///
/// o 13
/// |
/// | o 12
/// | |
/// | | o 11
/// | | |\
/// | | | | o 10
/// | | | | |
/// | o---+ | 9
/// | | | | |
/// o | | | | 8
/// / / / /
/// | | o | 7
/// | | | |
/// o---+ | 6
/// / / /
/// | | o 5
/// | |/
/// | o 4
/// | |
/// o | 3
/// | |
/// | o 2
/// |/
/// o 1
/// |
/// o 0
#[derive(Clone, Debug)]
pub struct SampleGraph;
impl Graph for SampleGraph {
fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
match rev {
0 => Ok([NULL_REVISION, NULL_REVISION]),
1 => Ok([0, NULL_REVISION]),
2 => Ok([1, NULL_REVISION]),
3 => Ok([1, NULL_REVISION]),
4 => Ok([2, NULL_REVISION]),
5 => Ok([4, NULL_REVISION]),
6 => Ok([4, NULL_REVISION]),
7 => Ok([4, NULL_REVISION]),
8 => Ok([NULL_REVISION, NULL_REVISION]),
9 => Ok([6, 7]),
10 => Ok([5, NULL_REVISION]),
11 => Ok([3, 7]),
12 => Ok([9, NULL_REVISION]),
13 => Ok([8, NULL_REVISION]),
r => Err(GraphError::ParentOutOfRange(r)),
}
}
}
// A Graph represented by a vector whose indices are revisions
// and values are parents of the revisions
pub type VecGraph = Vec<[Revision; 2]>;
impl Graph for VecGraph {
fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
Ok(self[rev as usize])
}
}