weirflow 0.1.0

use super::*;

// 6. Seed handling
// ==================================================================

bfs_test!(
    zero_seeds_empty_result,
    1,
    2,
    1,
    &[(0, 0, 1)],
    &[],
    &[],
    &[],
    &[],
    vec![]
);

bfs_test!(
    single_seed_reaches_self,
    1,
    1,
    1,
    &[],
    &[],
    &[],
    &[],
    &[(0, 0, 0)],
    vec![(0, 0, 0)]
);

bfs_test!(
    two_seeds_same_node,
    1,
    1,
    1,
    &[],
    &[],
    &[],
    &[],
    &[(0, 0, 0), (0, 0, 0)],
    vec![(0, 0, 0)]
);

bfs_test!(
    two_seeds_different_nodes,
    1,
    2,
    1,
    &[],
    &[],
    &[],
    &[],
    &[(0, 0, 0), (0, 1, 0)],
    vec![(0, 0, 0), (0, 1, 0)]
);

bfs_test!(
    many_seeds_all_reached,
    1,
    5,
    1,
    &[],
    &[],
    &[],
    &[],
    &[(0, 0, 0), (0, 1, 0), (0, 2, 0), (0, 3, 0), (0, 4, 0)],
    vec![(0, 0, 0), (0, 1, 0), (0, 2, 0), (0, 3, 0), (0, 4, 0)]
);

bfs_test!(
    duplicate_seeds_no_duplicates_output,
    1,
    3,
    1,
    &[(0, 0, 1), (0, 1, 2)],
    &[],
    &[],
    &[],
    &[(0, 0, 0), (0, 0, 0), (0, 0, 0)],
    vec![(0, 0, 0), (0, 1, 0), (0, 2, 0)]
);

bfs_test!(
    seed_at_boundary_max_block,
    1,
    3,
    1,
    &[(0, 0, 1), (0, 1, 2)],
    &[],
    &[],
    &[],
    &[(0, 2, 0)],
    vec![(0, 2, 0)]
);

bfs_test!(
    seed_at_boundary_max_fact,
    1,
    1,
    3,
    &[],
    &[],
    &[],
    &[],
    &[(0, 0, 2)],
    vec![(0, 0, 2)]
);

bfs_test!(
    seed_at_boundary_max_proc,
    2,
    1,
    1,
    &[],
    &[],
    &[],
    &[],
    &[(1, 0, 0)],
    vec![(1, 0, 0)]
);

bfs_test!(
    all_possible_seeds,
    1,
    2,
    2,
    &[(0, 0, 1)],
    &[],
    &[],
    &[],
    &[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1)],
    all_triples(1, 2, 2)
);

bfs_test!(
    seed_not_reachable_by_edges,
    1,
    3,
    1,
    &[(0, 0, 1)],
    &[],
    &[],
    &[],
    &[(0, 2, 0)],
    vec![(0, 2, 0)]
);

bfs_test!(
    seed_on_kill_node,
    1,
    2,
    1,
    &[(0, 0, 1)],
    &[],
    &[],
    &[(0, 0, 0)],
    &[(0, 0, 0)],
    vec![(0, 0, 0)]
);

bfs_test!(
    seed_on_gen_node,
    1,
    2,
    2,
    &[(0, 0, 1)],
    &[],
    &[(0, 0, 1)],
    &[],
    &[(0, 0, 0)],
    vec![(0, 0, 0), (0, 1, 0), (0, 1, 1)]
);

bfs_test!(
    seeds_spanning_multiple_procs,
    3,
    2,
    1,
    &[(0, 0, 1), (1, 0, 1), (2, 0, 1)],
    &[],
    &[],
    &[],
    &[(0, 0, 0), (1, 0, 0), (2, 0, 0)],
    vec![
        (0, 0, 0),
        (0, 1, 0),
        (1, 0, 0),
        (1, 1, 0),
        (2, 0, 0),
        (2, 1, 0)
    ]
);

bfs_test!(
    seeds_with_inter_edges,
    2,
    2,
    1,
    &[(0, 0, 1)],
    &[(0, 1, 1, 0)],
    &[],
    &[],
    &[(0, 0, 0), (1, 1, 0)],
    vec![(0, 0, 0), (0, 1, 0), (1, 0, 0), (1, 1, 0)]
);

bfs_test!(
    seeds_in_disconnected_graph,
    2,
    2,
    1,
    &[(0, 0, 1)],
    &[],
    &[],
    &[],
    &[(0, 0, 0), (1, 1, 0)],
    vec![(0, 0, 0), (0, 1, 0), (1, 1, 0)]
);

bfs_test!(
    zero_seeds_nonempty_graph,
    1,
    3,
    1,
    &[(0, 0, 1), (0, 1, 2)],
    &[],
    &[],
    &[],
    &[],
    vec![]
);

bfs_test!(
    single_seed_star_center,
    1,
    5,
    1,
    &star_edges(4),
    &[],
    &[],
    &[],
    &[(0, 0, 0)],
    (0..5).map(|b| (0, b, 0)).collect()
);

bfs_test!(
    single_seed_star_leaf,
    1,
    5,
    1,
    &star_edges(4),
    &[],
    &[],
    &[],
    &[(0, 1, 0)],
    vec![(0, 1, 0)]
);

bfs_test!(
    single_seed_chain_end,
    1,
    5,
    1,
    &chain_edges(5),
    &[],
    &[],
    &[],
    &[(0, 4, 0)],
    vec![(0, 4, 0)]
);

bfs_test!(
    seed_on_isolated_node,
    1,
    3,
    1,
    &[(0, 0, 1)],
    &[],
    &[],
    &[],
    &[(0, 2, 0)],
    vec![(0, 2, 0)]
);

bfs_test!(
    multiple_duplicate_seeds_mixed,
    1,
    3,
    1,
    &[(0, 0, 1), (0, 1, 2)],
    &[],
    &[],
    &[],
    &[(0, 0, 0), (0, 0, 0), (0, 2, 0)],
    vec![(0, 0, 0), (0, 1, 0), (0, 2, 0)]
);

bfs_test!(
    every_node_is_seed,
    1,
    2,
    2,
    &[(0, 0, 1)],
    &[],
    &[],
    &[],
    &[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1)],
    all_triples(1, 2, 2)
);