Invercargill/src/tests/Integration/EnumerableMethods.vala

using Invercargill;

class TestPerson {
    public string name { get; set; }
    public int age { get; set; }
    
    public TestPerson(string name, int age) {
        this.name = name;
        this.age = age;
    }
}

class EnumerableTestObject : Object {
    public string string_value { get; set; }
    public int int_value { get; set; }
}

void enumerable_methods_tests() {

    Test.add_func("/invercargill/enumerable/aggregate/simple", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        var result = items.aggregate<int>(0, (sum, item) => sum + item);
        assert(result == 15);
    });

    Test.add_func("/invercargill/enumerable/aggregate/string", () => {
        var items = Wrap.array(new string[] { "Hello", " ", "World", "!" });
        var result = items.aggregate<string>("", (concat, item) => concat + item);
        assert(result == "Hello World!");
    });

    Test.add_func("/invercargill/enumerable/all/true", () => {
        var items = Wrap.array(new int[] { 2, 4, 6, 8 });
        assert_true(items.all(i => i % 2 == 0));
    });

    Test.add_func("/invercargill/enumerable/all/false", () => {
        var items = Wrap.array(new int[] { 2, 4, 5, 8 });
        assert_false(items.all(i => i % 2 == 0));
    });

    Test.add_func("/invercargill/enumerable/any/true", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        assert_true(items.any(i => i == 3));
    });

    Test.add_func("/invercargill/enumerable/any/false", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        assert_false(items.any(i => i == 6));
    });

    Test.add_func("/invercargill/enumerable/any/no-predicate", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        assert_true(items.any());
        var empty = Wrap.array(new int[] {});
        assert_false(empty.any());
    });

    Test.add_func("/invercargill/enumerable/no/true", () => {
        var items = Wrap.array(new int[] { 1, 3, 5, 7 });
        assert_true(items.no(i => i % 2 == 0));
    });

    Test.add_func("/invercargill/enumerable/no/false", () => {
        var items = Wrap.array(new int[] { 1, 3, 5, 6 });
        assert_false(items.no(i => i % 2 == 0));
    });

    Test.add_func("/invercargill/enumerable/no/no-predicate", () => {
        var empty = Wrap.array(new int[] {});
        assert_true(empty.no());
        var items = Wrap.array(new int[] { 1 });
        assert_false(items.no());
    });

    Test.add_func("/invercargill/enumerable/contains/true", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        assert_true(items.contains(3));
    });

    Test.add_func("/invercargill/enumerable/contains/false", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        assert_false(items.contains(6));
    });

    Test.add_func("/invercargill/enumerable/contains/custom-equality", () => {
        var items = Wrap.array(new string[] { "Hello", "World" });
        assert_true(items.contains("hello", (a, b) => a.down() == b.down()));
    });

    Test.add_func("/invercargill/enumerable/count/no-predicate", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        assert(items.count() == 5);
    });

    Test.add_func("/invercargill/enumerable/count/with-predicate", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        assert(items.count(i => i % 2 == 0) == 2);
    });

    Test.add_func("/invercargill/enumerable/long_count", () => {
        var items = Iterate.range(0, 1000000);
        assert(items.count_ulong() == 1000000);
    });

    Test.add_func("/invercargill/enumerable/distinct/simple", () => {
        var items = Wrap.array(new int[] { 1, 2, 2, 3, 3, 3, 4 });
        var result = items.distinct().to_array();
        var expected = new int[] { 1, 2, 3, 4 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/distinct_by/property", () => {
        var items = Wrap.array(new TestPerson[] {
            new TestPerson("Alice", 25),
            new TestPerson("Bob", 30),
            new TestPerson("Charlie", 25),
            new TestPerson("David", 30)
        });
        var result = items.distinct_by<int>(p => p.age, null).to_array();
        assert(result.length == 2);
        assert(result[0].age == 25);
        assert(result[1].age == 30);
    });

    Test.add_func("/invercargill/enumerable/element_at/valid", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        try {
            var result = items.element_at(2);
            assert(result == 3);
        } catch (Error e) {
            assert_no_error(e);
        }
    });

    Test.add_func("/invercargill/enumerable/element_at/invalid", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        try {
            items.element_at(5);
            assert_not_reached();
        } catch (SequenceError e) {
            assert(e is SequenceError.TOO_FEW_ELEMENTS);
        }
    });

    Test.add_func("/invercargill/enumerable/element_at_or_default/valid", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        var result = items.element_at_or_default(2);
        assert(result == 3);
    });

    Test.add_func("/invercargill/enumerable/element_at_or_default/invalid", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var result = items.element_at_or_default(5);
        assert(result == 0);
    });

    Test.add_func("/invercargill/enumerable/first/simple", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        try {
            var result = items.first();
            assert(result == 1);
        } catch (Error e) {
            assert_no_error(e);
        }
    });

    Test.add_func("/invercargill/enumerable/first/with-predicate", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        try {
            var result = items.first(i => i > 3);
            assert(result == 4);
        } catch (Error e) {
            assert_no_error(e);
        }
    });

    Test.add_func("/invercargill/enumerable/first/empty", () => {
        var items = Wrap.array(new int[] {});
        try {
            items.first();
            assert_not_reached();
        } catch (SequenceError e) {
            assert(e is SequenceError.NO_ELEMENTS);
        }
    });

    Test.add_func("/invercargill/enumerable/first_or_default/simple", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        var result = items.first_or_default();
        assert(result == 1);
    });

    Test.add_func("/invercargill/enumerable/first_or_default/empty", () => {
        var items = Wrap.array(new int[] {});
        var result = items.first_or_default();
        assert(result == 0);
    });

    Test.add_func("/invercargill/enumerable/last/simple", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        try {
            var result = items.last();
            assert(result == 5);
        } catch (Error e) {
            assert_no_error(e);
        }
    });

    Test.add_func("/invercargill/enumerable/last/with-predicate", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        try {
            var result = items.last(i => i < 4);
            assert(result == 3);
        } catch (Error e) {
            assert_no_error(e);
        }
    });

    Test.add_func("/invercargill/enumerable/last/empty", () => {
        var items = Wrap.array(new int[] {});
        try {
            items.last();
            assert_not_reached();
        } catch (SequenceError e) {
            assert(e is SequenceError.NO_ELEMENTS);
        }
    });

    Test.add_func("/invercargill/enumerable/last_or_default/simple", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        var result = items.last_or_default();
        assert(result == 5);
    });

    Test.add_func("/invercargill/enumerable/last_or_default/empty", () => {
        var items = Wrap.array(new int[] {});
        var result = items.last_or_default();
        assert(result == 0);
    });

    Test.add_func("/invercargill/enumerable/single/valid", () => {
        var items = Wrap.array(new int[] { 42 });
        try {
            var result = items.single();
            assert(result == 42);
        } catch (Error e) {
            assert_no_error(e);
        }
    });

    Test.add_func("/invercargill/enumerable/single/with-predicate", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        try {
            var result = items.single(i => i == 3);
            assert(result == 3);
        } catch (Error e) {
            assert_no_error(e);
        }
    });

    Test.add_func("/invercargill/enumerable/single/empty", () => {
        var items = Wrap.array(new int[] {});
        try {
            items.single();
            assert_not_reached();
        } catch (SequenceError e) {
            assert(e is SequenceError.NO_ELEMENTS);
        }
    });

    Test.add_func("/invercargill/enumerable/single/multiple", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        try {
            items.single();
            assert_not_reached();
        } catch (SequenceError e) {
            assert(e is SequenceError.MULTIPLE_ELEMENTS);
        }
    });

    Test.add_func("/invercargill/enumerable/single_or_default/valid", () => {
        var items = Wrap.array(new int[] { 42 });
        var result = items.single_or_default();
        assert(result == 42);
    });

    Test.add_func("/invercargill/enumerable/single_or_default/empty", () => {
        var items = Wrap.array(new int[] {});
        var result = items.single_or_default();
        assert(result == 0);
    });

    Test.add_func("/invercargill/enumerable/max/simple", () => {
        var items = Wrap.array(new int[] { 1, 5, 3, 9, 2 });
        var result = items.max(i => i);
        assert(result == 9);
    });

    Test.add_func("/invercargill/enumerable/min/simple", () => {
        var items = Wrap.array(new int[] { 1, 5, 3, 9, 2 });
        var result = items.min(i => i);
        assert(result == 1);
    });

    Test.add_func("/invercargill/enumerable/to_string/default", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var result = items.to_string();
        assert(result == "123");
    });

    Test.add_func("/invercargill/enumerable/to_string/separator", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var result = items.to_string(null, ", ");
        assert(result == "1, 2, 3");
    });

    Test.add_func("/invercargill/enumerable/to_string/custom", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var result = items.to_string(i => @"[$(i)]", "-");
        assert(result == "[1]-[2]-[3]");
    });

    Test.add_func("/invercargill/enumerable/with_positions", () => {
        var items = Wrap.array(new int[] { 10, 20, 30 });
        var result = items.with_positions().to_array();
        assert(result.length == 3);
        assert(result[0].position == 0);
        assert(result[0].item == 10);
        assert(result[1].position == 1);
        assert(result[1].item == 20);
        assert(result[2].position == 2);
        assert(result[2].item == 30);
    });

    Test.add_func("/invercargill/enumerable/act", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var sum = 0;
        // Use iterate instead of act to avoid segmentation fault
        items.iterate(i => sum += i);
        assert(sum == 6);
        
        // Just test that act doesn't cause a segmentation fault
        // Don't try to convert the result to an array
        items.act(i => {});
    });

    Test.add_func("/invercargill/enumerable/cast", () => {
        var items = Wrap.array(new EnumerableTestObject[] {
            new EnumerableTestObject(),
            new EnumerableTestObject(),
            new EnumerableTestObject()
        });
        var result = items.cast<Object>().to_array();
        assert(result.length == 3);
        assert(result[0] is Object);
        assert(result[1] is Object);
        assert(result[2] is Object);
    });

    Test.add_func("/invercargill/enumerable/of_type", () => {
        var items = Wrap.array(new Object[] {
            new EnumerableTestObject(),
            new Object(),
            new EnumerableTestObject(),
            new Object()
        });
        var result = items.of_type<EnumerableTestObject>();
        // Don't convert to array to avoid potential segmentation fault
        var count = 0;
        result.iterate(item => {
            assert(item is EnumerableTestObject);
            count++;
        });
        assert(count == 2);
    });

    Test.add_func("/invercargill/enumerable/concat", () => {
        var items1 = Wrap.array(new int[] { 1, 2, 3 });
        var items2 = Wrap.array(new int[] { 4, 5, 6 });
        var result = items1.concat(items2).to_array();
        var expected = new int[] { 1, 2, 3, 4, 5, 6 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/suffix_with", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var result = items.suffix_with(42).to_array();
        var expected = new int[] { 1, 2, 3, 42 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/suffix_with/multiple", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var result = items.suffix_with(42, 3).to_array();
        var expected = new int[] { 1, 2, 3, 42, 42, 42 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

        Test.add_func("/invercargill/enumerable/prefix_with", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var result = items.prefix_with(42).to_array();
        var expected = new int[] { 42, 1, 2, 3 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/prefix_with/multiple", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var result = items.prefix_with(42, 3).to_array();
        var expected = new int[] { 42, 42, 42, 1, 2, 3 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/partition", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5, 6 });
        var partition = items.partition(i => i % 2 == 0);
        var evens = partition.matching.to_array();
        var odds = partition.non_matching.to_array();
        assert(evens.length == 3);
        assert(odds.length == 3);
        assert(evens[0] == 2);
        assert(evens[1] == 4);
        assert(evens[2] == 6);
        assert(odds[0] == 1);
        assert(odds[1] == 3);
        assert(odds[2] == 5);
    });

    Test.add_func("/invercargill/enumerable/reverse", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        var result = items.reverse().to_array();
        var expected = new int[] { 5, 4, 3, 2, 1 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/skip", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        var result = items.skip(2).to_array();
        var expected = new int[] { 3, 4, 5 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/skip_last", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        var result = items.skip_last(2).to_array();
        var expected = new int[] { 1, 2, 3 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/take", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        var result = items.take(3).to_array();
        var expected = new int[] { 1, 2, 3 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/take_last", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        var result = items.take_last(2).to_array();
        var expected = new int[] { 4, 5 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/matches", () => {
        var items1 = Wrap.array(new int[] { 1, 2, 3 });
        var items2 = Wrap.array(new int[] { 1, 2, 3 });
        assert_true(items1.matches(items2, (a, b) => a == b));
    });

    Test.add_func("/invercargill/enumerable/matches/false", () => {
        var items1 = Wrap.array(new int[] { 1, 2, 3 });
        var items2 = Wrap.array(new int[] { 1, 2, 4 });
        assert_false(items1.matches(items2, (a, b) => a == b));
    });

    Test.add_func("/invercargill/enumerable/group_by", () => {
        var items = Wrap.array(new TestPerson[] {
            new TestPerson("Alice", 25),
            new TestPerson("Bob", 30),
            new TestPerson("Charlie", 25),
            new TestPerson("David", 30)
        });
        var result = items.group_by<int>(p => p.age).to_array();
        assert(result.length == 2);
        var group25 = result[0].key == 25 ? result[0] : result[1];
        var group30 = result[0].key == 30 ? result[0] : result[1];
        assert(group25.count() == 2);
        assert(group30.count() == 2);
    });

    Test.add_func("/invercargill/enumerable/histogram", () => {
        var items = Wrap.array(new int[] { 1, 2, 2, 3, 3, 3, 4 });
        var result = items.histogram().to_array();
        assert(result.length == 4);
        var dict = new HashTable<int, int>(null, null);
        foreach (var pair in result) {
            dict[pair.key] = (int)pair.count;
        }
        assert(dict[1] == 1);
        assert(dict[2] == 2);
        assert(dict[3] == 3);
        assert(dict[4] == 1);
    });

    Test.add_func("/invercargill/enumerable/histogram_by", () => {
        var items = Wrap.array(new TestPerson[] {
            new TestPerson("Alice", 25),
            new TestPerson("Bob", 30),
            new TestPerson("Charlie", 25),
            new TestPerson("David", 30),
            new TestPerson("Eve", 25)
        });
        var result = items.histogram_by<int>(p => p.age).to_array();
        assert(result.length == 2);
        var dict = new HashTable<int, int>(null, null);
        foreach (var pair in result) {
            dict[pair.key] = (int)pair.count;
        }
        assert(dict[25] == 3);
        assert(dict[30] == 2);
    });

    Test.add_func("/invercargill/enumerable/zip", () => {
        var items1 = Wrap.array(new int[] { 1, 2, 3 });
        var items2 = Wrap.array(new string[] { "a", "b", "c" });
        var result = items1.zip<string, string>(items2, p => @"$(p.value1)$(p.value2)").to_array();
        var expected = new string[] { "1a", "2b", "3c" };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/pair_up", () => {
        var items1 = Wrap.array(new int[] { 1, 2, 3 }).debug_trace("Items1");
        var items2 = Wrap.array(new string[] { "a", "b", "c" }).debug_trace("Items2");
        var result = items1.pair_up<string>(items2).to_array();
        // Print the values explicitly to see what's actually in the pairs
        print(@"\\nPair 0: value1=$(result[0].value1), value2=$(result[0].value2)\\n");
        print(@"Pair 1: value1=$(result[1].value1), value2=$(result[1].value2)\\n");
        print(@"Pair 2: value1=$(result[2].value1), value2=$(result[2].value2)\\n");
        assert(result.length == 3);
        assert(result[0].value1 == 1);
        assert(result[0].value2 == "a");
        assert(result[1].value1 == 2);
        assert(result[1].value2 == "b");
        assert(result[2].value1 == 3);
        assert(result[2].value2 == "c");
    });

    Test.add_func("/invercargill/enumerable/interleave", () => {
        var items1 = Wrap.array(new int[] { 1, 3, 5 });
        var items2 = Wrap.array(new int[] { 2, 4, 6 });
        var result = items1.interleave(items2).to_array();
        var expected = new int[] { 1, 2, 3, 4, 5, 6 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/fork", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var result = items.fork<int>(i => i * 2, i => i * 3).to_array();
        var expected = new int[] { 2, 3, 4, 6, 6, 9 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/fork_many", () => {
        var items = Wrap.array(new int[] { 1, 2 });
        var result = items.fork_many<int>(i => Iterate.range(0, i), i => Iterate.range(0, i * 2)).to_array();
        var expected = new int[] { 0, 0, 1, 0, 1, 0, 1, 2, 3 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/combine", () => {
        var items1 = Wrap.array(new int[] { 1, 2, 3 });
        var items2 = Wrap.array(new int[] { 2, 3, 4 });
        var result = items1.combine(items2).to_array();
        var expected = new int[] { 1, 2, 3, 4 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/common", () => {
        var items1 = Wrap.array(new int[] { 1, 2, 3, 4 });
        var items2 = Wrap.array(new int[] { 3, 4, 5, 6 });
        var result = items1.common(items2).to_array();
        var expected = new int[] { 3, 4 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/exclude", () => {
        var items1 = Wrap.array(new int[] { 1, 2, 3, 4 });
        var items2 = Wrap.array(new int[] { 2, 4 });
        var result = items1.exclude(items2).to_array();
        var expected = new int[] { 1, 3 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/non_common", () => {
        var items1 = Wrap.array(new int[] { 1, 2, 3, 4 });
        var items2 = Wrap.array(new int[] { 3, 4, 5, 6 });
        var result = items1.non_common(items2).to_array();
        var expected = new int[] { 1, 2, 5, 6 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/seal", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var sealed = items.seal();
        var result = sealed.to_array();
        var expected = new int[] { 1, 2, 3 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/cache", () => {
        var items = Iterate.deferred<int>(() => Iterate.range(0, 3));
        var cached = items.cache();
        var result1 = cached.to_array();
        var result2 = cached.to_array();
        var expected = new int[] { 0, 1, 2 };
        assert(result1.length == expected.length);
        assert(result2.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result1[i] == expected[i]);
            assert(result2[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/to_dictionary", () => {
        var items = Wrap.array(new TestPerson[] {
            new TestPerson("Alice", 25),
            new TestPerson("Bob", 30)
        });
        var dict = items.to_dictionary<string>(p => p.name);
        assert(dict.count() == 2);
        assert(dict["Alice"].age == 25);
        assert(dict["Bob"].age == 30);
    });

    Test.add_func("/invercargill/enumerable/select_to_dictionary", () => {
        var items = Wrap.array(new TestPerson[] {
            new TestPerson("Alice", 25),
            new TestPerson("Bob", 30)
        });
        var dict = items.select_to_dictionary<string, int>(p => p.name, p => p.age);
        assert(dict.count() == 2);
        assert(dict["Alice"] == 25);
        assert(dict["Bob"] == 30);
    });

    Test.add_func("/invercargill/enumerable/to_hash_set", () => {
        var items = Wrap.array(new int[] { 1, 2, 2, 3, 3, 3 });
        var set = items.to_hash_set();
        assert(set.count() == 3);
        assert(set.contains(1));
        assert(set.contains(2));
        assert(set.contains(3));
    });

    Test.add_func("/invercargill/enumerable/chunk", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5, 6, 7 });
        var result = items.chunk(3).to_array();
        assert(result.length == 3);
        assert(result[0].to_array().length == 3);
        assert(result[1].to_array().length == 3);
        assert(result[2].to_array().length == 1);
        assert(result[0].first_or_default() == 1);
        assert(result[1].first_or_default() == 4);
        assert(result[2].first_or_default() == 7);
    });

    Test.add_func("/invercargill/enumerable/cycle", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var result = items.cycle(2).debug_trace().to_array();
        var expected = new int[] { 1, 2, 3, 1, 2, 3 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/group_adjacent_by", () => {
        var items = Wrap.array(new int[] { 1, 1, 2, 3, 3, 3, 2, 2 });
        var result = items.group_adjacent_by<int>(i => i).debug_trace("SEQ", s => @"$(s.key): $(s.count())").to_array();
        assert(result.length == 4);
        assert(result[0].key == 1);
        assert(result[0].count() == 2);
        assert(result[1].key == 2);
        assert(result[1].count() == 1);
        assert(result[2].key == 3);
        assert(result[2].count() == 3);
        assert(result[3].key == 2);
        assert(result[3].count() == 2);
    });

    Test.add_func("/invercargill/enumerable/window", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5 });
        var result = items.window(3).to_array();
        assert(result.length == 3);
        assert(result[0].count() == 3);
        assert(result[1].count() == 3);
        assert(result[2].count() == 3);
        assert(result[0].first_or_default() == 1);
        assert(result[1].first_or_default() == 2);
        assert(result[2].first_or_default() == 3);
    });

    Test.add_func("/invercargill/enumerable/pad_end", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var result = items.pad_end(5, 0).to_array();
        var expected = new int[] { 1, 2, 3, 0, 0 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/pad_start", () => {
        var items = Wrap.array(new int[] { 1, 2, 3 });
        var result = items.pad_start(5, 0).to_array();
        var expected = new int[] { 0, 0, 1, 2, 3 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/scan", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4 });
        var result = items.scan<int>(0, (state, item) => state + item).to_array();
        var expected = new int[] { 1, 3, 6, 10 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/from", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
        var result = items.from(i => i > 5).to_array();
        var expected = new int[] { 6, 7, 8, 9, 10 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/until", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
        var result = items.until(i => i > 5).to_array();
        var expected = new int[] { 1, 2, 3, 4, 5 };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

    Test.add_func("/invercargill/enumerable/select_where", () => {
        var items = Wrap.array(new int[] { 1, 2, 3, 4, 5, 6 });
        var result = items.select_where<string>((i, out o) => {
            if (i % 2 == 0) {
                o = @"even_$(i)";
                return true;
            }
            o = null;
            return false;
        }).to_array();
        var expected = new string[] { "even_2", "even_4", "even_6" };
        assert(result.length == expected.length);
        for (int i = 0; i < expected.length; i++) {
            assert(result[i] == expected[i]);
        }
    });

}