module datatypes

fn test_is_empty() {
    mut list := LinkedList[int]{}
    assert list.is_empty() == true
    list.push(1)
    assert list.is_empty() == false
}

fn test_len() {
    mut list := LinkedList[int]{}
    assert list.len() == 0
    list.push(1)
    assert list.len() == 1
    list.pop()!
    assert list.len() == 0
}

fn test_first() {
    mut list := LinkedList[int]{}
    list.push(1)
    assert list.first()! == 1
    list.push(2)
    assert list.first()! == 1
    list = LinkedList[int]{}
    list.first() or { return }
    assert false
}

fn test_last() {
    mut list := LinkedList[int]{}
    list.push(1)
    assert list.last()! == 1
    list.push(2)
    assert list.last()! == 2
    list = LinkedList[int]{}
    list.last() or { return }
    assert false
}

fn test_index() {
    mut list := LinkedList[int]{}
    list.push(1)
    assert list.index(0)! == 1
    list.push(2)
    assert list.index(1)! == 2
    list.pop()!
    list.index(1) or { return }
    assert false
}

fn test_push() {
    mut list := LinkedList[int]{}
    list.push(1)
    assert list.last()! == 1
    list.push(2)
    assert list.last()! == 2
    list.push(3)
    assert list.last()! == 3
}

fn test_pop() {
    mut list := LinkedList[int]{}
    list.push(1)
    list.push(2)
    list.push(3)
    assert list.pop()! == 3
    list.push(4)
    assert list.pop()! == 4
    assert list.pop()! == 2
    list = LinkedList[int]{}
    list.pop() or { return }
    assert false
}

fn test_shift() {
    mut list := LinkedList[int]{}
    list.push(1)
    list.push(2)
    list.push(3)
    assert list.shift()! == 1
    list.push(4)
    assert list.shift()! == 2
    assert list.shift()! == 3
    list = LinkedList[int]{}
    list.shift() or { return }
    assert false
}

fn test_insert() {
    mut list := LinkedList[int]{}
    list.push(1)
    list.push(2)
    list.push(3)
    list.insert(1, 111) or { return }
    assert true
}

fn test_prepend() {
    mut list := LinkedList[int]{}
    list.push(1)
    list.push(2)
    list.push(3)
    list.prepend(111)
    assert list.first()! == 111
}

fn test_str() {
    mut list := LinkedList[int]{}
    list.push(1)
    list.push(2)
    list.push(3)
    assert list.str() == '[1, 2, 3]'
}

fn test_array() {
    mut list := LinkedList[int]{}
    list.push(1)
    list.push(2)
    list.push(3)
    assert list.array() == [1, 2, 3]
}

fn test_linked_list_iterating_with_for() {
    mut list := LinkedList[int]{}
    list.push(1)
    list.push(2)
    list.push(3)
    mut res := []int{}
    for x in list {
        res << x
    }
    assert res == [1, 2, 3]
}

fn test_linked_list_separate_iterators() {
    mut list := LinkedList[int]{}
    list.push(1)
    list.push(2)
    list.push(3)
    mut it1 := list.iterator()
    mut it2 := list.iterator()
    mut it3 := list.iterator()
    assert it1.next()! == 1
    assert it1.next()! == 2
    assert it1.next()! == 3
    assert it2.next()! == 1
    if _ := it1.next() {
        assert false
    } else {
        assert true
    }
    if _ := it1.next() {
        assert false
    } else {
        assert true
    }
    assert it2.next()! == 2
    assert it2.next()! == 3
    if _ := it2.next() {
        assert false
    } else {
        assert true
    }
    mut res := []int{}
    for x in it3 {
        res << x
    }
    assert res == [1, 2, 3]
}

struct Foo {
mut:
    field LinkedList[map[string]int]
}

fn test_linked_list_map() {
    mut foo := Foo{}
    foo.field.push({
        'one': 1
    })
    foo.field.push({
        'two': 2
    })
    println(foo)
    mut iter := foo.field.iterator()
    assert iter.next()! == {
        'one': 1
    }
    assert iter.next()! == {
        'two': 2
    }
}