Broken sets

src/lib/DataStructures/HashSet.vala

@@ -111,7 +111,11 @@ namespace Invercargill.DataStructures {
         }
 
         public override Tracker<T> get_tracker () {
-            return range(0, n_items).select<T>(i => read_item(i)).get_tracker();
+            return range(0, buckets.length)
+                .where(i => buckets[i] != BUCKET_EMPTY && buckets[i] != BUCKET_TOMBSTONE)
+                .select<T>(i => read_item(buckets[i]))
+                .debug_trace("hashset tracker!")
+                .get_tracker();
         }
 
         public bool add (T item) {
@@ -188,13 +192,29 @@ namespace Invercargill.DataStructures {
                     if(equal_func(ours, item)) {
                         write_item(buckets[bucket_index], null);
                         buckets[bucket_index] = BUCKET_TOMBSTONE;
+                        n_items--;
+                        print(@"Removed $((int)item)\n");
                         return ours;
                     }
                 }
                 bucket_index++;
             }
+            print(@"Did not remove $((int)item)\n");
             return null;
         }
 
+        public bool equals(Enumerable<T> other) {
+            if(other == this) {
+                return true;
+            }
+            return other.debug_trace("other").non_common(this.debug_trace("this"), hash_func, equal_func).debug_trace("Non common").count() == 0;
+        }
+        public bool is_subset_of(Enumerable<T> other) {
+            return this.exclude(other, hash_func, equal_func).count() == 0;
+        }
+        public bool is_proper_subset_of(Enumerable<T> other) {
+            return !equals(other) && is_subset_of(other);
+        }
+
     }
 }

src/lib/DataStructures/ImmutableBuffer.vala

@@ -0,0 +1,70 @@
+
+namespace Invercargill.DataStructures {
+
+    public class ImmutableBuffer<T> : Enumerable<T>, Lot<T>, ImmutableLot<T>, ReadOnlyAddressable<T> {
+
+        private T[] array;
+        private SafeReadFunc<T>? safe_read;
+
+        public override Tracker<T> get_tracker () {
+            int pos = 0;
+            var read = safe_read;
+            if(read == null) {
+                read = (a, i) => a[i];
+            }
+            return new LambdaTracker<T> (() => pos < array.length, () => read(array, pos++));
+        }
+        public override int? peek_count () {
+            return array.length;
+        }
+        public override EnumerableInfo get_info () {
+            return new EnumerableInfo.infer_ultimate(this, EnumerableCategory.IN_MEMORY);
+        }
+
+        public ImmutableBuffer(Enumerable<T> items) {
+            array = items.to_array();
+            safe_read = get_safe_read_function_for<T>();
+        }
+
+        public new T get (uint index) throws IndexError {
+            if(index >= array.length) {
+                throw new IndexError.INDEX_EXCEEDS_UPPER_BOUNDS(@"Tried to access index $(index) on a buffer of length $(array.length)");
+            }
+            if(safe_read != null) {
+                return safe_read(array, index);
+            }
+            return array[index];
+        }
+
+        public bool try_get (uint index, out T value) {
+            try {
+                value = get(index);
+                return true;
+            }
+            catch {
+                value = null;
+                return false;
+            }
+        }
+
+        public uint? first_index_of (Invercargill.PredicateDelegate<T> predicate) {
+            var i = 0;
+            foreach (var item in this) {
+                if(predicate(item)) {
+                    return i;
+                }
+                i++;
+            }
+            return null;
+        }
+
+        public override int count(PredicateDelegate<T>? predicate = null) {
+            if(predicate == null) {
+                return array.length;
+            }
+            return base.count(predicate);
+        }
+
+    }
+
+}

src/lib/Enumerable.vala

@@ -76,6 +76,10 @@ namespace Invercargill {
             return new Buffer<T>.take_array(to_array());
         }
 
+        public virtual ImmutableBuffer<T> to_immutable_buffer() {
+            return new ImmutableBuffer<T>(this);
+        }
+
         public virtual RingBuffer<T> to_ring_buffer(uint? size = null) {
             if(size == null) {
                 return new RingBuffer<T>.take_array(to_array());
@@ -333,25 +337,46 @@ namespace Invercargill {
             return keys.select<Grouping<TKey, T>>(g => new Grouping<TKey, T>(g, this.where(i => equality(g, key_selector(i)))));
         }
 
-        public virtual Enumerable<T> union_by<TKey>(Enumerable<T> other, owned TransformDelegate<T, TKey> key_selector, owned HashDelegate<TKey>? hash_func = null, owned EqualityDelegate<TKey>? equal_func = null) {
+        public virtual Enumerable<T> combine_by<TKey>(Enumerable<T> other, owned TransformDelegate<T, TKey> key_selector, owned HashDelegate<TKey>? hash_func = null, owned EqualityDelegate<TKey>? equal_func = null) {
             return new Union<T, TKey>(this, other, (owned)key_selector, (owned)hash_func, (owned)equal_func);
         }
 
-        // Can't name it union because of C reserved keywords
-        // New names
-        // - union: combine or merge
-        // - intersect: overlap or common
-        // - difference: exclude or subtract
-        // - symmetric difference: mismatch or disjoint
-        public virtual Enumerable<T> union(Enumerable<T> other, owned HashDelegate<T>? hash_func = null, owned EqualityDelegate<T>? equal_func = null) {
-            return union_by<T>(other, i => i, (owned)hash_func, (owned) equal_func);
+        public virtual Enumerable<T> combine(Enumerable<T> other, owned HashDelegate<T>? hash_func = null, owned EqualityDelegate<T>? equal_func = null) {
+            return combine_by<T>(other, i => i, (owned)hash_func, (owned) equal_func);
+        }
+
+        public virtual Enumerable<T> common_by<TKey>(Enumerable<T> other, owned TransformDelegate<T, TKey> key_selector, owned HashDelegate<TKey>? hash_func = null, owned EqualityDelegate<TKey>? equal_func = null) {
+            return new Intersect<T, TKey>(this, other, (owned)key_selector, (owned)hash_func, (owned)equal_func);
         }
 
+        public virtual Enumerable<T> common(Enumerable<T> other, owned HashDelegate<T>? hash_func = null, owned EqualityDelegate<T>? equal_func = null) {
+            return common_by<T>(other, i => i, (owned)hash_func, (owned) equal_func);
+        }
+
+        public virtual Enumerable<T> exclude_by<TKey>(Enumerable<T> other, owned TransformDelegate<T, TKey> key_selector, owned HashDelegate<TKey>? hash_func = null, owned EqualityDelegate<TKey>? equal_func = null) {
+            return new Difference<T, TKey>(this, other, (owned)key_selector, (owned)hash_func, (owned)equal_func);
+        }
+
+        public virtual Enumerable<T> exclude(Enumerable<T> other, owned HashDelegate<T>? hash_func = null, owned EqualityDelegate<T>? equal_func = null) {
+            return exclude_by<T>(other, i => i, (owned)hash_func, (owned) equal_func);
+        }
+
+        public virtual Enumerable<T> non_common_by<TKey>(Enumerable<T> other, owned TransformDelegate<T, TKey> key_selector, owned HashDelegate<TKey>? hash_func = null, owned EqualityDelegate<TKey>? equal_func = null) {
+            return new SymmetricDifference<T, TKey>(this, other, (owned)key_selector, (owned)hash_func, (owned)equal_func);
+        }
+
+        public virtual Enumerable<T> non_common(Enumerable<T> other, owned HashDelegate<T>? hash_func = null, owned EqualityDelegate<T>? equal_func = null) {
+            return non_common_by<T>(other, i => i, (owned)hash_func, (owned) equal_func);
+        }
 
         public virtual Enumerable<T> @with(T item, uint times = 1) {
             return concat(range(0, (int)times, 1).select<T>(i => item));
         }
 
+        public virtual Partition<T> partition(PredicateDelegate<T> test) {
+            return new Partition<T>(this, test);
+        }
+
         public virtual T first(owned PredicateDelegate<T>? predicate = null) throws SequenceError {
             var tracker = predicate == null ? get_tracker() : where((owned)predicate).get_tracker();
             if(tracker.has_next()) {

src/lib/Interfaces/ImmutableLot.vala

@@ -0,0 +1,8 @@
+namespace Invercargill {
+
+    [GenericAccessors]
+    public interface ImmutableLot<T> : Lot<T> {
+
+    }
+
+}

src/lib/Interfaces/ReadOnlySet.vala

@@ -5,26 +5,22 @@ namespace Invercargill {
 
         public abstract bool has(T item);
         public abstract bool try_find(T search, out T item);
+        public abstract bool equals(Enumerable<T> other);
+        public abstract bool is_subset_of(Enumerable<T> other);
+        public abstract bool is_proper_subset_of(Enumerable<T> other);
 
-        public virtual bool is_proper_subset_of(Enumerable<T> other) {
-            return false;
-        }
-        public virtual bool is_subset_of(Enumerable<T> other) {
-            return false;
-        }
         public virtual bool is_proper_superset_of(Enumerable<T> other) {
-            return false;
+            var search = other.partition(i => has(i));
+            return search.matching.any() && search.matching.any();
         }
         public virtual bool is_superset_of(Enumerable<T> other) {
-            return false;
+            return other == this || other.all(i => has(i));
         }
         public virtual bool overlaps(Enumerable<T> other) {
-            return false;
-        }
-        public virtual bool equals(Enumerable<T> other) {
-            return false;
+            return other == this || other.any(i => has(i));
         }
 
+
         public virtual T? find(T search) {
             T? item;
             if(try_find(search, out item)) {

src/lib/Interfaces/Set.vala

@@ -19,6 +19,8 @@ namespace Invercargill {
         public virtual void symmetric_except_with(Enumerable<T> items) {
             var other = items.cache();
             var to_remove = other.where(i => has(i)).to_series();
+            other.debug_dump("other");
+            to_remove.debug_dump("To remove");
             union_with(other);
             except_with(to_remove);
         }

src/lib/Iterate.vala

@@ -22,6 +22,7 @@ namespace Invercargill.Iterate {
     public static Enumerable<T> these<T>(T item1, ...) {
         var series = new Series<T>();
         var args = va_list();
+        series.add(item1);
         while(true) {
             T? item = args.arg<T>();
             if(item == null) {

src/lib/Modifiers/Difference.vala

@@ -0,0 +1,56 @@
+
+using Invercargill.DataStructures;
+namespace Invercargill.Modifiers {
+
+    public class Difference<T, TKey> : Enumerable<T> {
+
+        private Enumerable<T> e1;
+        private Enumerable<T> e2;
+        private TransformDelegate<T, TKey> key_sf;
+        private HashDelegate<TKey> key_hf;
+        private EqualityDelegate<TKey> key_ef;
+
+        public Difference(Enumerable<T> first, Enumerable<T> second, owned TransformDelegate<T, TKey> key_selector, owned HashDelegate<TKey>? key_hasher = null, owned EqualityDelegate<TKey>? key_equator = null) {
+            e1 = first;
+            e2 = second;
+            key_sf = (owned)key_selector;
+            key_ef = (owned)key_equator ?? Operators.equality<TKey>();
+            key_hf = (owned)key_hasher ?? Operators.hash<TKey>();
+        }
+
+        public override int? peek_count() {
+            return null;
+        }
+
+        public override EnumerableInfo get_info() {
+            return new EnumerableInfo.infer(this, EnumerableCategory.COMPUTED, Iterate.these(e1, e2));
+        }
+
+        public override Tracker<T> get_tracker() {
+            var tracker = e1.get_tracker();
+            var exclude = e2.to_hash_set(key_hf, key_ef);
+
+            return new AdvanceTracker<T>((out result) => {
+                T? item = null;
+                while(item != null) {
+                    if(tracker.has_next()) {
+                        item = tracker.get_next();
+                    }
+                    else {
+                        result = null;
+                        return false;
+                    }
+
+                    var key = key_sf(item);
+                    if(exclude.has(key)) {
+                        item = null;
+                    }
+                }
+                result = item;
+                return true;
+            });
+        }
+
+    }
+
+}

src/lib/Modifiers/Except.vala

@@ -1,42 +0,0 @@
-
-namespace Invercargill.Modifiers {
-
-    public class Concat<T> : Enumerable<T> {
-
-        private Enumerable<T> e1;
-        private Enumerable<T> e2;
-
-        public Concat(Enumerable<T> first, Enumerable<T> second) {
-            e1 = first;
-            e2 = second;
-        }
-
-        public override int? peek_count() {
-            var c1 = e1.peek_count();
-            var c2 = e2.peek_count();
-            if(c1 == null || c2 == null)
-                return null;
-            return c1 + c2;
-        }
-
-        public override EnumerableInfo get_info() {
-            return new EnumerableInfo.infer(this, EnumerableCategory.COMPUTED, Convert.ate(new Enumerable[] {e1, e2}));
-        }
-
-        public override Tracker<T> get_tracker() {
-            var tracker1 = e1.get_tracker();
-            var tracker2 = e2.get_tracker();
-
-            return new LambdaTracker<T>(
-                () => tracker1.has_next() || tracker2.has_next(),
-                () => {
-                    if(tracker1.has_next()) {
-                        return tracker1.get_next();
-                    }
-                    return tracker2.get_next();
-                });
-        }
-
-    }
-
-}

src/lib/Modifiers/Intersect.vala

@@ -1,40 +1,54 @@
 
+using Invercargill.DataStructures;
 namespace Invercargill.Modifiers {
 
-    public class Concat<T> : Enumerable<T> {
+    public class Intersect<T, TKey> : Enumerable<T> {
 
         private Enumerable<T> e1;
         private Enumerable<T> e2;
+        private TransformDelegate<T, TKey> key_sf;
+        private HashDelegate<TKey> key_hf;
+        private EqualityDelegate<TKey> key_ef;
 
-        public Concat(Enumerable<T> first, Enumerable<T> second) {
+        public Intersect(Enumerable<T> first, Enumerable<T> second, owned TransformDelegate<T, TKey> key_selector, owned HashDelegate<TKey>? key_hasher = null, owned EqualityDelegate<TKey>? key_equator = null) {
             e1 = first;
             e2 = second;
+            key_sf = (owned)key_selector;
+            key_ef = (owned)key_equator ?? Operators.equality<TKey>();
+            key_hf = (owned)key_hasher ?? Operators.hash<TKey>();
         }
 
         public override int? peek_count() {
-            var c1 = e1.peek_count();
-            var c2 = e2.peek_count();
-            if(c1 == null || c2 == null)
-                return null;
-            return c1 + c2;
+            return null;
         }
 
         public override EnumerableInfo get_info() {
-            return new EnumerableInfo.infer(this, EnumerableCategory.COMPUTED, Convert.ate(new Enumerable[] {e1, e2}));
+            return new EnumerableInfo.infer(this, EnumerableCategory.COMPUTED, Iterate.these(e1, e2));
         }
 
         public override Tracker<T> get_tracker() {
-            var tracker1 = e1.get_tracker();
-            var tracker2 = e2.get_tracker();
-
-            return new LambdaTracker<T>(
-                () => tracker1.has_next() || tracker2.has_next(),
-                () => {
-                    if(tracker1.has_next()) {
-                        return tracker1.get_next();
+            var tracker = e1.get_tracker();
+            var include = e2.to_hash_set(key_hf, key_ef);
+
+            return new AdvanceTracker<T>((out result) => {
+                T? item = null;
+                while(item != null) {
+                    if(tracker.has_next()) {
+                        item = tracker.get_next();
                     }
-                    return tracker2.get_next();
-                });
+                    else {
+                        result = null;
+                        return false;
+                    }
+
+                    var key = key_sf(item);
+                    if(!include.has(key)) {
+                        item = null;
+                    }
+                }
+                result = item;
+                return true;
+            });
         }
 
     }

src/lib/Modifiers/SymmetricDifference.vala

@@ -0,0 +1,39 @@
+
+using Invercargill.DataStructures;
+namespace Invercargill.Modifiers {
+
+    public class SymmetricDifference<T, TKey> : Enumerable<T> {
+
+        private Enumerable<T> e1;
+        private Enumerable<T> e2;
+        private TransformDelegate<T, TKey> key_sf;
+        private HashDelegate<TKey> key_hf;
+        private EqualityDelegate<TKey> key_ef;
+
+        public SymmetricDifference(Enumerable<T> first, Enumerable<T> second, owned TransformDelegate<T, TKey> key_selector, owned HashDelegate<TKey>? key_hasher = null, owned EqualityDelegate<TKey>? key_equator = null) {
+            e1 = first;
+            e2 = second;
+            key_sf = (owned)key_selector;
+            key_ef = (owned)key_equator ?? Operators.equality<TKey>();
+            key_hf = (owned)key_hasher ?? Operators.hash<TKey>();
+        }
+
+        public override int? peek_count() {
+            return null;
+        }
+
+        public override EnumerableInfo get_info() {
+            return new EnumerableInfo.infer(this, EnumerableCategory.COMPUTED, Iterate.these(e1, e2));
+        }
+
+        public override Tracker<T> get_tracker() {
+            var result = e1.to_hash_set(i => key_hf(key_sf(i)), (a, b) => key_ef(key_sf(a), key_sf(b)));
+            result.debug_dump("Pre execpt");
+            result.symmetric_except_with(e2);
+            result.debug_dump("Post execpt");
+            return result.get_tracker();
+        }
+
+    }
+
+}

src/lib/Partition.vala

@@ -0,0 +1,26 @@
+
+namespace Invercargill {
+
+    public class Partition<T> { 
+
+        public ImmutableLot<T> matching { get; private set; }
+        public ImmutableLot<T> non_matching { get; private set; }
+
+        public Partition(Enumerable<T> items, PredicateDelegate<T> test) {
+            var match = new DataStructures.Series<T>();
+            var non_match = new DataStructures.Series<T>();
+            foreach (var item in items) {
+                if(test(item)) {
+                    match.add(item);
+                }
+                else {
+                    non_match.add(item);
+                }
+            }
+            matching = match.to_immutable_buffer();
+            non_matching = non_match.to_immutable_buffer();
+        }
+        
+    }
+
+}

src/lib/meson.build

@@ -31,6 +31,7 @@ sources += files('Debug.vala')
 sources += files('OrderConfiguration.vala')
 sources += files('Iterate.vala')
 sources += files('Wrap.vala')
+sources += files('Partition.vala')
 
 sources += files('Modifiers/Transform.vala')
 sources += files('Modifiers/Filter.vala')
@@ -51,9 +52,9 @@ sources += files('Modifiers/Sealed.vala')
 sources += files('Modifiers/Interleave.vala')
 sources += files('Modifiers/Order.vala')
 sources += files('Modifiers/Union.vala')
-# sources += files('Modifiers/Except.vala')
-# sources += files('Modifiers/Intersect.vala')
-# sources += files('Modifiers/SymmetricExcept.vala')
+sources += files('Modifiers/Difference.vala')
+sources += files('Modifiers/Intersect.vala')
+sources += files('Modifiers/SymmetricDifference.vala')
 
 sources += files('Wrappers/Array.vala')
 sources += files('Wrappers/GeeIterable.vala')
@@ -71,6 +72,7 @@ sources += files('Promotions/Attempts.vala')
 sources += files('Promotions/PropertyGroups.vala')
 
 sources += files('Interfaces/Lot.vala')
+sources += files('Interfaces/ImmutableLot.vala')
 sources += files('Interfaces/ReadOnlyCollection.vala')
 sources += files('Interfaces/ReadOnlyAssociative.vala')
 sources += files('Interfaces/ReadOnlyAddressable.vala')
@@ -94,6 +96,7 @@ sources += files('DataStructures/SortedVector.vala')
 sources += files('DataStructures/SortedSeries.vala')
 sources += files('DataStructures/Buffer.vala')
 sources += files('DataStructures/RingBuffer.vala')
+sources += files('DataStructures/ImmutableBuffer.vala')
 
 sources += files('Mapping/Mapper.vala')
 sources += files('Mapping/PropertyMapper.vala')

src/tests/Integration/Series.vala

@@ -19,7 +19,7 @@ void series_tests() {
         var series = items.to_series();
         assert(series.count() == 10000000);
 
-        series.matches(items, (a, b) => a == b);
+        assert(series.matches(items, (a, b) => a == b));
     });
 
     Test.add_func("/invercargill/structure/series/to_array", () => {

src/tests/Integration/Set.vala

@@ -0,0 +1,78 @@
+using Invercargill;
+using Invercargill.Convert;
+using Invercargill.DataStructures;
+
+
+void set_tests() {
+
+    Test.add_func("/invercargill/structure/hash_set/add_item", () => {
+        var hashset = new HashSet<int>();
+        hashset.add(8);
+
+        assert(hashset.count() == 1);
+        assert(hashset.first_or_default() == 8);
+    });
+
+    //  Test.add_func("/invercargill/structure/hash_set/add_many", () => {
+
+    //      var items = range(0, 10000000);
+    //      var hashset = items.to_hash_set();
+    //      assert_cmpint(hashset.count(), CompareOperator.EQ, 10000000);
+    //      assert_true(hashset.equals(items));
+    //  });
+
+    Test.add_func("/invercargill/structure/hash_set/de_duplicates", () => {
+
+        var series = new HashSet<int>();
+        var items = range(0, 100);
+        series.union_with(items);
+        series.union_with(items);
+        assert_cmpint(series.count(), CompareOperator.EQ, 100);
+    });
+
+    Test.add_func("/invercargill/structure/hash_set/set_comparisons", () => {
+
+        var hashset = Iterate.these<int>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).to_hash_set();
+        var sub_set = Iterate.these<int>(5, 6, 7);
+        var overlap = Iterate.these<int>(8, 9, 10, 11, 12);
+        var sup_set = Iterate.these<int>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
+        var equal = Iterate.these<int>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        var empty = Iterate.nothing<int>();
+
+        assert_true(hashset.equals(equal));
+        assert_true(hashset.is_subset_of(equal));
+        assert_true(hashset.is_superset_of(equal));
+        assert_false(hashset.is_proper_subset_of(equal));
+        assert_false(hashset.is_proper_superset_of(equal));
+        assert_true(hashset.overlaps(equal));
+
+        assert_false(hashset.equals(empty));
+        assert_false(hashset.is_subset_of(empty));
+        assert_true(hashset.is_superset_of(empty));
+        assert_false(hashset.is_proper_subset_of(empty));
+        assert_true(hashset.is_proper_superset_of(empty));
+        assert_false(hashset.overlaps(equal));
+
+        assert_false(hashset.equals(sup_set));
+        assert_true(hashset.is_subset_of(sup_set));
+        assert_false(hashset.is_superset_of(sup_set));
+        assert_true(hashset.is_proper_subset_of(sup_set));
+        assert_false(hashset.is_proper_superset_of(sup_set));
+        assert_true(hashset.overlaps(equal));
+
+        assert_false(hashset.equals(sub_set));
+        assert_false(hashset.is_subset_of(sub_set));
+        assert_true(hashset.is_superset_of(sub_set));
+        assert_false(hashset.is_proper_subset_of(sub_set));
+        assert_true(hashset.is_proper_superset_of(sub_set));
+        assert_true(hashset.overlaps(equal));
+
+        assert_false(hashset.equals(overlap));
+        assert_false(hashset.is_subset_of(overlap));
+        assert_false(hashset.is_superset_of(overlap));
+        assert_false(hashset.is_proper_subset_of(overlap));
+        assert_false(hashset.is_proper_superset_of(overlap));
+        assert_true(hashset.overlaps(equal));
+
+    });
+}

src/tests/Integration/SortedSeries.vala

@@ -20,7 +20,7 @@ void sorted_series_tests() {
         series.add_all(items);
         assert_cmpint(series.count(), CompareOperator.EQ, 10000000);
 
-        series.matches(items, (a, b) => a == b);
+        assert(series.matches(items, (a, b) => a == b));
     });
 
     Test.add_func("/invercargill/structure/sorted_series/add_many_reversed", () => {
@@ -29,8 +29,6 @@ void sorted_series_tests() {
         var items = range(10000000, 0, -1);
         series.add_all(items);
         assert_cmpint(series.count(), CompareOperator.EQ, 10000000);
-
-        series.matches(items, (a, b) => a == b);
     });
 
     Test.add_func("/invercargill/structure/sorted_series/add_twice", () => {

src/tests/Integration/SortedVector.vala

@@ -19,8 +19,7 @@ void sorted_vector_tests() {
         var items = range(0, 10000000);
         series.add_all(items);
         assert(series.count() == 10000000);
-
-        series.matches(items, (a, b) => a == b);
+        assert(series.matches(items, (a, b) => a == b));
     });
 
     Test.add_func("/invercargill/structure/sorted_vector/add_many_reversed", () => {
@@ -30,7 +29,6 @@ void sorted_vector_tests() {
         series.add_all(items);
         assert(series.count() == 300000);
 
-        series.matches(items, (a, b) => a == b);
     });
 
     Test.add_func("/invercargill/structure/sorted_vector/add_twice", () => {

src/tests/Integration/Vector.vala

@@ -100,7 +100,7 @@ void vector_tests() {
         var vector = items.to_vector();
         assert(vector.count() == 10000000);
 
-        vector.matches(items, (a, b) => a == b);
+        assert(vector.matches(items, (a, b) => a == b));
     });
 
     Test.add_func("/invercargill/structure/vector/remove", () => {

src/tests/TestRunner.vala

@@ -3,26 +3,27 @@ public static int main(string[] args) {
 
     Test.init(ref args);
 
-    where_tests();
-    select_tests();
-    select_many_tests();
-    gee_tests();
-    tracker_tests();
-    parallel_tests();
-    first_tests();
-    binary_data_tests();
-    sort_tests();
-    vector_tests();
-    series_tests();
-    array_tests();
-    promotion_tests();
-    numbers_test();
-    dictionary_tests();
-    property_mapper_tests();
-    cache_tests();
-    sorted_vector_tests();
-    sorted_series_tests();
-    order_by_tests();
+    //  where_tests();
+    //  select_tests();
+    //  select_many_tests();
+    //  gee_tests();
+    //  tracker_tests();
+    //  parallel_tests();
+    //  first_tests();
+    //  binary_data_tests();
+    //  sort_tests();
+    //  vector_tests();
+    //  series_tests();
+    //  array_tests();
+    //  promotion_tests();
+    //  numbers_test();
+    //  dictionary_tests();
+    //  property_mapper_tests();
+    //  cache_tests();
+    //  sorted_vector_tests();
+    //  sorted_series_tests();
+    //  order_by_tests();
+    set_tests();
 
     Test.run();
     

src/tests/meson.build

@@ -22,6 +22,7 @@ sources += files('Integration/Cache.vala')
 sources += files('Integration/SortedVector.vala')
 sources += files('Integration/SortedSeries.vala')
 sources += files('Integration/OrderBy.vala')
+sources += files('Integration/Set.vala')
 
 sources += files('Speed/SpeedTest.vala')
 sources += files('Speed/Series.vala')