}
    pub fn null() -> Self {
        CowPage {
            data: core::ptr::null_mut(),
            offset: 0,
        }

    }
    {
        let hdr = header(left.0.as_page());
        assert_eq!(hdr.n() as u64 * 16, hdr.left_page() & 0xfff);
    }
    {
        let hdr = header(right.0.as_page());
        assert_eq!(hdr.n() as u64 * 16, hdr.left_page() & 0xfff);

    assert!(!split.0.is_null());

        assert_eq!(hdr.n() as u64 * 16, hdr.left_page() & 0xfff); // Just for the test with (u64, u64).

impl<K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> Db_<K, V, P> {
    pub fn from_page(db: CowPage) -> Self {
        Db_ {
            db,
            k: core::marker::PhantomData,
            v: core::marker::PhantomData,
            p: core::marker::PhantomData,
        }
    }
}

type B = btree::page::Page<u64, ()>;

    type B = btree::page::Page<u64, ()>;

    check_free(&mut txn, &refs);
    debug!("{:?}", refs);
}
fn check_free(txn: &mut MutTxn<&Env, ()>, refs: &BTreeMap<u64, usize>) {

        while let Some((k, _)) = curs.next(&mut txn).unwrap() {

        while let Some((k, _)) = curs.next(txn).unwrap() {

            assert!(refs.get(k).is_none())

    debug!("{:?}", refs);

    for (r, _) in refs.iter() {
        assert!(*r < txn.length)
    }

    env_logger::try_init().unwrap_or(());

    let env = Env::new("/tmp/sanakirja0", 4096 * 20, 2).unwrap();
    let mut txn = Env::mut_txn_begin(&env).unwrap();
    debug!("txn.root = {:?}", txn.env.root);
    let db = create_db::<MutTxn<&Env, ()>, u64, ()>(&mut txn).unwrap();
    debug!("db = {:?}", db.db.offset);
    txn.set_root(0, db.db.offset);
    txn.commit().unwrap();
    debug!("1. commit done");
    let txn = Env::mut_txn_begin(&env).unwrap();
    debug!("txn.root = {:?}", txn.env.root);
    let db: Db<u64, ()> = txn.root_db(0).unwrap().unwrap();
    debug!("txn.root = {:?}", db);
    txn.commit().unwrap();
    debug!("2. commit done");
    let txn = Env::mut_txn_begin(&env).unwrap();
    debug!("txn.root = {:?}", txn.env.root);
    txn.commit().unwrap();
    debug!("commit done");

    env_logger::try_init().unwrap_or(());
    let mut child = unsafe { libc::fork() };
    if child == 0 {
        // child
        let env = Env::new("/tmp/sanakirja0", 4096 * 20, 2).unwrap();
        // Mutable txn
        let mut txn = Env::mut_txn_begin(&env).unwrap();
        info!("started child mutable txn {:?}", txn.env.root.lock());
        let db = create_db::<MutTxn<&Env, ()>, u64, ()>(&mut txn).unwrap();
        debug!("db = {:?}", db.db.offset);
        txn.set_root(0, db.db.offset);
        std::thread::sleep(std::time::Duration::from_secs(2));
        txn.commit().unwrap();
        info!("committed");
        let t = std::time::SystemTime::now();
        let mut txn = Env::mut_txn_begin(&env).unwrap();
        // Since the parent has an immutable transaction started, we
        // need to wait for at least some time (1s - 100ms of
        // synchronisation margin).
        assert!(t.elapsed().unwrap() >= std::time::Duration::from_millis(900));
        info!("started child mutable txn {:?}", txn.env.root.lock());
        let db = create_db::<MutTxn<&Env, ()>, u64, ()>(&mut txn).unwrap();
        debug!("db = {:?}", db.db.offset);
        txn.set_root(0, db.db.offset);
        std::thread::sleep(std::time::Duration::from_secs(1));
        txn.commit().unwrap();
        unsafe { libc::exit(0) }
    } else {
        // parent
        std::thread::sleep(std::time::Duration::from_secs(1));
        let env = Env::new("/tmp/sanakirja0", 4096 * 20, 2).unwrap();
        // Immutable
        info!("starting parent txn {:?}", env.root);
        let txn = Env::txn_begin(&env).unwrap();
        info!("started parent txn");
        std::thread::sleep(std::time::Duration::from_secs(3));
        std::mem::drop(txn);
        unsafe { libc::wait(&mut child) };
    }

    debug!("{:?}", txn.free);
    check_free(&mut txn, &refs);

    println!("sized length = {:?}", txn.length >> 12);

    let len = txn.length >> 12;
    println!("sized length = {:?}", len);

    println!("unsized length = {:?}", txn.length >> 12);

    println!("unsized length = {:?}", (txn.length >> 12) - len);
    add_refs(&txn, &db, &mut refs).unwrap();
    for (p, r) in refs.iter() {
        if *r >= 2 {
            error!("{:?} referenced twice", p);
            err += 1
        }
    }
    assert_eq!(err, 0);
    check_free(&mut txn, &refs);

            debug!("unlock exclusive {:?}", *root);

            let mut free_db: btree::Db<u64, ()> = btree::Db {
                db: std::mem::replace(
                    &mut self.free,
                    CowPage {
                        data: std::ptr::null_mut(),
                        offset: 0,
                    },
                ),
                k: std::marker::PhantomData,
                v: std::marker::PhantomData,
                p: std::marker::PhantomData,
            };

            let mut free_db: btree::Db<u64, ()> =
                btree::Db::from_page(std::mem::replace(&mut self.free, CowPage::null()));

            self.free = free_db.db;

            *root = (*root + 1) % env.roots.len();

            debug!("commit: unlock {:?}", *root);

                debug!("commit: unlock file");

            *root = (*root + 1) % env.roots.len();

        use log::*;

            debug!("root lock");

            debug!("shared {:?}", root);
            env_.roots[root].rw.lock_shared();

            debug!("old_n_txn: {:?}", old_n_txn);

                env_.roots[root].rw.lock_shared();

                    debug!("file lock shared");

        unsafe { env.roots[self.root].rw.unlock_shared() }

            unsafe { env.roots[self.root].rw.unlock_shared() }

# lmdb-rs = "*"

libc = "*"
# lmdb-rs = "*"