// -*- rust -*-
use std;
import std::map;
import std::str;
import std::uint;
import std::util;

fn test_simple() {
    log "*** starting test_simple";
    fn eq_uint(&uint x, &uint y) -> bool { ret x == y; }
    fn hash_uint(&uint u) -> uint {
        // FIXME: can't use std::util::id since we'd be capturing a type
        // param, and presently we can't close items over type params.

        ret u;
    }
    let map::hashfn[uint] hasher_uint = hash_uint;
    let map::eqfn[uint] eqer_uint = eq_uint;
    let map::hashfn[str] hasher_str = str::hash;
    let map::eqfn[str] eqer_str = str::eq;
    log "uint -> uint";
    let map::hashmap[uint, uint] hm_uu =
        map::mk_hashmap[uint, uint](hasher_uint, eqer_uint);
    assert (hm_uu.insert(10u, 12u));
    assert (hm_uu.insert(11u, 13u));
    assert (hm_uu.insert(12u, 14u));
    assert (hm_uu.get(11u) == 13u);
    assert (hm_uu.get(12u) == 14u);
    assert (hm_uu.get(10u) == 12u);
    assert (!hm_uu.insert(12u, 14u));
    assert (hm_uu.get(12u) == 14u);
    assert (!hm_uu.insert(12u, 12u));
    assert (hm_uu.get(12u) == 12u);
    let str ten = "ten";
    let str eleven = "eleven";
    let str twelve = "twelve";
    log "str -> uint";
    let map::hashmap[str, uint] hm_su =
        map::mk_hashmap[str, uint](hasher_str, eqer_str);
    assert (hm_su.insert("ten", 12u));
    assert (hm_su.insert(eleven, 13u));
    assert (hm_su.insert("twelve", 14u));
    assert (hm_su.get(eleven) == 13u);
    assert (hm_su.get("eleven") == 13u);
    assert (hm_su.get("twelve") == 14u);
    assert (hm_su.get("ten") == 12u);
    assert (!hm_su.insert("twelve", 14u));
    assert (hm_su.get("twelve") == 14u);
    assert (!hm_su.insert("twelve", 12u));
    assert (hm_su.get("twelve") == 12u);
    log "uint -> str";
    let map::hashmap[uint, str] hm_us =
        map::mk_hashmap[uint, str](hasher_uint, eqer_uint);
    assert (hm_us.insert(10u, "twelve"));
    assert (hm_us.insert(11u, "thirteen"));
    assert (hm_us.insert(12u, "fourteen"));
    assert (str::eq(hm_us.get(11u), "thirteen"));
    assert (str::eq(hm_us.get(12u), "fourteen"));
    assert (str::eq(hm_us.get(10u), "twelve"));
    assert (!hm_us.insert(12u, "fourteen"));
    assert (str::eq(hm_us.get(12u), "fourteen"));
    assert (!hm_us.insert(12u, "twelve"));
    assert (str::eq(hm_us.get(12u), "twelve"));
    log "str -> str";
    let map::hashmap[str, str] hm_ss =
        map::mk_hashmap[str, str](hasher_str, eqer_str);
    assert (hm_ss.insert(ten, "twelve"));
    assert (hm_ss.insert(eleven, "thirteen"));
    assert (hm_ss.insert(twelve, "fourteen"));
    assert (str::eq(hm_ss.get("eleven"), "thirteen"));
    assert (str::eq(hm_ss.get("twelve"), "fourteen"));
    assert (str::eq(hm_ss.get("ten"), "twelve"));
    assert (!hm_ss.insert("twelve", "fourteen"));
    assert (str::eq(hm_ss.get("twelve"), "fourteen"));
    assert (!hm_ss.insert("twelve", "twelve"));
    assert (str::eq(hm_ss.get("twelve"), "twelve"));
    log "*** finished test_simple";
}


/**
 * Force map growth and rehashing.
 */
fn test_growth() {
    log "*** starting test_growth";
    let uint num_to_insert = 64u;
    fn eq_uint(&uint x, &uint y) -> bool { ret x == y; }
    fn hash_uint(&uint u) -> uint {
        // FIXME: can't use std::util::id since we'd be capturing a type
        // param, and presently we can't close items over type params.

        ret u;
    }
    log "uint -> uint";
    let map::hashfn[uint] hasher_uint = hash_uint;
    let map::eqfn[uint] eqer_uint = eq_uint;
    let map::hashmap[uint, uint] hm_uu =
        map::mk_hashmap[uint, uint](hasher_uint, eqer_uint);
    let uint i = 0u;
    while (i < num_to_insert) {
        assert (hm_uu.insert(i, i * i));
        log "inserting " + uint::to_str(i, 10u) + " -> " +
                uint::to_str(i * i, 10u);
        i += 1u;
    }
    log "-----";
    i = 0u;
    while (i < num_to_insert) {
        log "get(" + uint::to_str(i, 10u) + ") = " +
                uint::to_str(hm_uu.get(i), 10u);
        assert (hm_uu.get(i) == i * i);
        i += 1u;
    }
    assert (hm_uu.insert(num_to_insert, 17u));
    assert (hm_uu.get(num_to_insert) == 17u);
    log "-----";
    hm_uu.rehash();
    i = 0u;
    while (i < num_to_insert) {
        log "get(" + uint::to_str(i, 10u) + ") = " +
                uint::to_str(hm_uu.get(i), 10u);
        assert (hm_uu.get(i) == i * i);
        i += 1u;
    }
    log "str -> str";
    let map::hashfn[str] hasher_str = str::hash;
    let map::eqfn[str] eqer_str = str::eq;
    let map::hashmap[str, str] hm_ss =
        map::mk_hashmap[str, str](hasher_str, eqer_str);
    i = 0u;
    while (i < num_to_insert) {
        assert (hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u)));
        log "inserting \"" + uint::to_str(i, 2u) + "\" -> \"" +
                uint::to_str(i * i, 2u) + "\"";
        i += 1u;
    }
    log "-----";
    i = 0u;
    while (i < num_to_insert) {
        log "get(\"" + uint::to_str(i, 2u) + "\") = \"" +
                hm_ss.get(uint::to_str(i, 2u)) + "\"";
        assert (str::eq(hm_ss.get(uint::to_str(i, 2u)),
                        uint::to_str(i * i, 2u)));
        i += 1u;
    }
    assert (hm_ss.insert(uint::to_str(num_to_insert, 2u),
                         uint::to_str(17u, 2u)));
    assert (str::eq(hm_ss.get(uint::to_str(num_to_insert, 2u)),
                    uint::to_str(17u, 2u)));
    log "-----";
    hm_ss.rehash();
    i = 0u;
    while (i < num_to_insert) {
        log "get(\"" + uint::to_str(i, 2u) + "\") = \"" +
                hm_ss.get(uint::to_str(i, 2u)) + "\"";
        assert (str::eq(hm_ss.get(uint::to_str(i, 2u)),
                        uint::to_str(i * i, 2u)));
        i += 1u;
    }
    log "*** finished test_growth";
}

fn test_removal() {
    log "*** starting test_removal";
    let uint num_to_insert = 64u;
    fn eq(&uint x, &uint y) -> bool { ret x == y; }
    fn hash(&uint u) -> uint {
        // This hash function intentionally causes collisions between
        // consecutive integer pairs.

        ret u / 2u * 2u;
    }
    assert (hash(0u) == hash(1u));
    assert (hash(2u) == hash(3u));
    assert (hash(0u) != hash(2u));
    let map::hashfn[uint] hasher = hash;
    let map::eqfn[uint] eqer = eq;
    let map::hashmap[uint, uint] hm =
        map::mk_hashmap[uint, uint](hasher, eqer);
    let uint i = 0u;
    while (i < num_to_insert) {
        assert (hm.insert(i, i * i));
        log "inserting " + uint::to_str(i, 10u) + " -> " +
                uint::to_str(i * i, 10u);
        i += 1u;
    }
    assert (hm.size() == num_to_insert);
    log "-----";
    log "removing evens";
    i = 0u;
    while (i < num_to_insert) {
        /**
         * FIXME (issue #150): we want to check the removed value as in the
         * following:

        let util.option[uint] v = hm.remove(i);
        alt (v) {
          case (util.some[uint](u)) {
            assert (u == (i * i));
          }
          case (util.none[uint]()) { fail; }
        }

         * but we util.option is a tag type so util.some and util.none are
         * off limits until we parse the dwarf for tag types.
         */

        hm.remove(i);
        i += 2u;
    }
    assert (hm.size() == num_to_insert / 2u);
    log "-----";
    i = 1u;
    while (i < num_to_insert) {
        log "get(" + uint::to_str(i, 10u) + ") = " +
                uint::to_str(hm.get(i), 10u);
        assert (hm.get(i) == i * i);
        i += 2u;
    }
    log "-----";
    log "rehashing";
    hm.rehash();
    log "-----";
    i = 1u;
    while (i < num_to_insert) {
        log "get(" + uint::to_str(i, 10u) + ") = " +
                uint::to_str(hm.get(i), 10u);
        assert (hm.get(i) == i * i);
        i += 2u;
    }
    log "-----";
    i = 0u;
    while (i < num_to_insert) {
        assert (hm.insert(i, i * i));
        log "inserting " + uint::to_str(i, 10u) + " -> " +
                uint::to_str(i * i, 10u);
        i += 2u;
    }
    assert (hm.size() == num_to_insert);
    log "-----";
    i = 0u;
    while (i < num_to_insert) {
        log "get(" + uint::to_str(i, 10u) + ") = " +
                uint::to_str(hm.get(i), 10u);
        assert (hm.get(i) == i * i);
        i += 1u;
    }
    log "-----";
    log "rehashing";
    hm.rehash();
    log "-----";
    assert (hm.size() == num_to_insert);
    i = 0u;
    while (i < num_to_insert) {
        log "get(" + uint::to_str(i, 10u) + ") = " +
                uint::to_str(hm.get(i), 10u);
        assert (hm.get(i) == i * i);
        i += 1u;
    }
    log "*** finished test_removal";
}

fn test_contains_key() {
    auto key = "k";
    auto map = map::mk_hashmap[str, str](str::hash, str::eq);
    assert (!map.contains_key(key));
    map.insert(key, "val");
    assert (map.contains_key(key));
}

fn test_find() {
    auto key = "k";
    auto map = map::mk_hashmap[str, str](str::hash, str::eq);
    assert (std::option::is_none(map.find(key)));
    map.insert(key, "val");
    assert (std::option::get(map.find(key)) == "val");
}

fn main() {
    test_simple();
    test_growth();
    test_removal();
    test_contains_key();
    test_find();
}