Invercargill/src/tests/Integration/Vector.vala

using Invercargill;
using Invercargill.DataStructures;


void vector_tests() {

    Test.add_func("/invercargill/structure/vector/add_item", () => {

        var vector = new Vector<int>();
        vector.add(8);

        assert(vector.first_or_default() == 8);
        assert(vector.get_or_default(0) == 8);
        assert(vector[0] == 8);
        assert(vector.count() == 1);
    });

    Test.add_func("/invercargill/structure/vector/add_strings", () => {

        var vector = new Vector<string>();
        vector.add("test string");

        assert(vector.first_or_default() == "test string");
        assert(vector.get_or_default(0) == "test string");
        assert(vector.count() == 1);
    });

    Test.add_func("/invercargill/structure/vector/from_attempts", () => {

        var vector = Iterate.range(0,64).select<Attempt<int>>(i => new Attempt<int>(() => i+2)).to_vector();

        assert(vector.first_or_default().success);
        assert(vector.get_or_default(1).success);
        assert(vector.get_or_default(2).result == 4);
        assert(vector.count() == 64);
    });

    Test.add_func("/invercargill/structure/vector/add_objects", () => {

        var vector = new Vector<TestObject>();
        var obj = new TestObject() {
            string_value = "hello, world",
            int_value = 1999
        };
        vector.add(obj);

        assert(vector.first_or_default() == obj);
        assert(vector.get_or_default(0) == obj);
        assert(vector.first_or_default().int_value == 1999);
        assert(vector.first_or_default().string_value == "hello, world");
        assert(vector.count() == 1);
    });

    Test.add_func("/invercargill/structure/vector/expand", () => {

        var vector = new Vector<int>();
        vector.add(8);
        vector.add(10);
        vector.add(64);
        vector.add(35);
        vector.add(129);

        assert(vector.first_or_default() == 8);
        assert(vector.get_or_default(0) == 8);
        assert(vector.get_or_default(1) == 10);
        assert(vector.get_or_default(2) == 64);
        assert(vector.get_or_default(3) == 35);
        assert(vector.get_or_default(4) == 129);
        assert(vector.last_or_default() == 129);
        assert(vector.count() == 5);
    });

    Test.add_func("/invercargill/structure/vector/to_vector", () => {

        var items = new int[] { 1, 8, 2, 4, 6, 5, 3, 10, 3, 7 };
        var vector = Wrap.array(items).to_vector();
        assert(vector.count() == 10);

        for(int i = 0; i < items.length; i++) {
            assert(vector.get_or_default(i) == items[i]);
        }
    });

    Test.add_func("/invercargill/structure/vector/to_array", () => {

        var items = new int[] { 1, 8, 2, 4, 6, 5, 3, 10, 3, 7 };
        var vector = Wrap.array(items).to_vector();
        var array = vector.to_array();
        assert(array.length == 10);

        for(int i = 0; i < items.length; i++) {
            assert(array[i] == items[i]);
        }
    });

    Test.add_func("/invercargill/structure/vector/many_items", () => {

        var items = Iterate.range(0, 10000000);
        var vector = items.to_vector();
        assert(vector.count() == 10000000);

        assert(vector.matches(items, (a, b) => a == b));
    });

    Test.add_func("/invercargill/structure/vector/remove", () => {

        var items = new int[] { 1, 8, 2, 4, 6, 5, 3, 10, 3, 7 };
        var expected = new int[] { 1, 8, 2, 4, 6, 3, 10, 3, 7 };
        var vector = Wrap.array(items).to_vector();

        try {
            vector.remove_at(5);
            assert(vector.count() == 9);
            assert(vector.matches(Wrap.array(expected), (a, b) => a == b));
        }
        catch(Error e) {
            assert_no_error(e);
        }

    });

    Test.add_func("/invercargill/structure/vector/last/no-condition", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5, 6}).to_vector();

        try{
            var last = items.last();
            assert_true(last == 6);
        }
        catch (Error e) {
            assert_no_error(e);
        }
        
    });

    Test.add_func("/invercargill/structure/vector/last/condition", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5, 6}).to_vector();

        try {
            var last = items.last(i => i < 4);
            assert_true(last == 3);
        }
        catch (Error e) {
            assert_no_error(e);
        }
    });

    Test.add_func("/invercargill/structure/vector/last/empty", () => {
        var items = new Vector<int>();

        try {
            items.last();
            assert_not_reached();
        }
        catch (Error e) {

        }
    });

    Test.add_func("/invercargill/structure/vector/get/empty", () => {
        var items = new Vector<int>();

        try {
            items.get(0);
            assert_not_reached();
        }
        catch (Error e) {

        }
    });


    Test.add_func("/invercargill/structure/vector/get/negative-index", () => {
        var items = new Vector<int>();

        try {
            items.get(-5);
            assert_not_reached();
        }
        catch (Error e) {

        }
    });

    Test.add_func("/invercargill/structure/vector/get/out-of-bounds", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5, 6}).to_vector();

        try {
            items.get(6);
            assert_not_reached();
        }
        catch (Error e) {

        }
    });

    Test.add_func("/invercargill/structure/vector/set/empty", () => {
        var items = new Vector<int>();

        try {
            items.set(0, 5);
            assert_not_reached();
        }
        catch (Error e) {

        }
    });


    Test.add_func("/invercargill/structure/vector/set/negative-index", () => {
        var items = new Vector<int>();

        try {
            items.set(-5, 73);
            assert_not_reached();
        }
        catch (Error e) {

        }
    });

    Test.add_func("/invercargill/structure/vector/set/out-of-bounds", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5, 6}).to_vector();

        try {
            items.set(6, 7);
            assert_not_reached();
        }
        catch (Error e) {

        }
    });

    Test.add_func("/invercargill/structure/vector/set/valid", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5, 6}).to_vector();

        try {
            items.set(1, 8);
        }
        catch (Error e) {
            assert_not_reached();
        }
        
        assert(items.get_or_default(1) == 8);
    });
}

private class TestObject {
    public string string_value { get; set; }
    public int int_value { get; set; }
}