// #![feature(test)]

// extern crate adapton ;
// extern crate test;

// //use adapton::adapton_syntax::* ;
// use adapton::adapton_sigs::* ;
// use adapton::naive::* ;
// use adapton::collection_traits::* ;
// use adapton::collection_edit::* ;
// use adapton::collection::{List,Tree} ;
// use adapton::collection_algo::* ;
    
// pub fn zipper_get_tree<A:Adapton,T:TreeT<A,u64>,L:TreeListT<A,u64,T>> (st:&mut A, _nil1:L) {
//     let z = ListZipper::<A,u64,T,L>::empty(st);
//     let z = ListZipper::insert(st, z, Dir2::Left,  1);
//     let z = ListZipper::insert(st, z, Dir2::Right, 2);
//     let z = ListZipper::insert(st, z, Dir2::Left,  3);
//     let z = ListZipper::insert(st, z, Dir2::Right, 4);
//     let z = ListZipper::insert(st, z, Dir2::Left,  5);
//     let z = ListZipper::insert(st, z, Dir2::Right, 6);
//     let z = ListZipper::insert(st, z, Dir2::Left,  7);
//     let z = ListZipper::insert(st, z, Dir2::Right, 8);
//     println!("z = {:?}\n", z);
    
//     for get_tree_dir in vec![Dir2::Left,Dir2::Right].iter()
//     {
//         let t = ListZipper::get_tree(st, z.clone(), get_tree_dir.clone());
//         println!("t = get_tree z = {:?}\n", t);
        
//         let l_spec = match *get_tree_dir {
//             Dir2::Left  =>     list_of_vec::<A,u64,L>(st, vec![1,3,5,7, /*cursor*/ 8,6,4,2]),
//             Dir2::Right => rev_list_of_vec::<A,u64,L>(st, vec![1,3,5,7, /*cursor*/ 8,6,4,2]),
//         };
        
//         println!("l_spec  = {:?}", l_spec);
//         let l_spec_sorted = list_merge_sort::<A,u64,L,T>(st, l_spec.clone());
//         println!("l_spec_sorted  = list_merge_sort l_spec = {:?}\n", l_spec_sorted);
        
//         let l = list_of_tree::<A,u64,L,T>(st, t.clone());
//         println!("l  = list_of_tree t = {:?}\n", l);
        
//         println!("l == l_spec = {}\n", l == l_spec.clone());
//         assert_eq!(l, l_spec);
        
//         let t2 = tree_of_list::<A,u64,T,L>(st, Dir2::Left, l.clone());
//         println!("t2 = tree_of_list l = {:?}", t2);
//         println!("t2 == t = {}\n", t2 == t);
//         // assert_eq!(t2, t); // FIXME: tree_append needs to follow Pugh's algorithm (POPL 1989).
        
//         let t_spec = tree_of_list::<A,u64,T,L>(st, Dir2::Left, l_spec.clone());
//         println!("t_spec = tree_of_list l_spec = {:?}\n", t_spec);
        
//         let l2 = list_of_tree::<A,u64,L,T>(st, t2.clone());
//         println!("l2 = list_of_tree t2 = {:?}", l2);
//         println!("l2 == l = {}\n", l2 == l); // Tests `list_of_tree o tree_of_list = id`.
//         assert_eq!(l2, l);
        
//         let t3 = tree_of_list::<A,u64,T,L>(st, Dir2::Left, l2);
//         println!("t3 = tree_of_list l2 = {:?}", t3);
//         println!("t3 == l = {}\n", t3 == t2); // Tests `tree_of_list o list_of_tree = id`.
//         assert_eq!(t3, t2);            
//     }
//     //assert!(false)
// }

// #[test]
// pub fn zipper_test () {
//     let mut st = AdaptonFromScratch::new();
//     let nil1 = List::nil(&mut st);
//     zipper_get_tree::< AdaptonFromScratch,
//     Tree<AdaptonFromScratch,u64,u32>,
//     List<AdaptonFromScratch,u64>,
//     > (&mut st, nil1);
// }