Use ignore_provenance in tests

Author: hyanwong

python/tests/test_tables.py

@@ -2968,9 +2968,7 @@ def test_zero_mutation_sites(self):
                 t1.simplify([0, 1], filter_zero_mutation_sites=filter_sites)
             t2 = ts.dump_tables()
             t2.simplify([0, 1], filter_sites=filter_sites)
-            t1.provenances.clear()
-            t2.provenances.clear()
-            t1.assert_equals(t2)
+            t1.assert_equals(t2, ignore_provenance=True)
             if filter_sites:
                 assert ts.num_sites > len(t1.sites)
 
@@ -3515,7 +3513,7 @@ def test_equals(self):
         t1.provenances.clear()
         t2.provenances.clear()
         assert t1 == t2
-        assert t1 == t2
+        assert t2 == t1
         assert not (t1 != t2)
 
         t1.nodes.clear()
@@ -4253,9 +4251,7 @@ def test_no_effect(self):
         t2 = msprime.simulate(10, mutation_rate=1, random_seed=1).dump_tables()
         assert len(t1.sites) > 0
         t1.deduplicate_sites()
-        t1.provenances.clear()
-        t2.provenances.clear()
-        t1.assert_equals(t2)
+        t1.assert_equals(t2, ignore_provenance=True)
 
     def test_same_sites(self):
         t1 = msprime.simulate(10, mutation_rate=1, random_seed=1).dump_tables()
@@ -4269,9 +4265,7 @@ def test_same_sites(self):
         assert len(t1.sites) == 2 * len(t2.sites)
         t1.sort()
         t1.deduplicate_sites()
-        t1.provenances.clear()
-        t2.provenances.clear()
-        t1.assert_equals(t2)
+        t1.assert_equals(t2, ignore_provenance=True)
 
     def test_order_maintained(self):
         t1 = tskit.TableCollection(1)

python/tests/test_topology.py

@@ -2415,10 +2415,8 @@ def verify_unary_tree_sequence(self, ts):
             py_ts, py_node_map = s.simplify()
             lib_ts, lib_node_map = ts_new.simplify(map_nodes=True, **params)
             py_tables = py_ts.dump_tables()
-            py_tables.provenances.clear()
             lib_tables = lib_ts.dump_tables()
-            lib_tables.provenances.clear()
-            assert lib_tables == py_tables
+            lib_tables.assert_equals(py_tables, ignore_provenance=True)
             assert np.all(lib_node_map == py_node_map)
 
     def test_binary_tree_sequence_unary_nodes(self):
@@ -2564,34 +2562,9 @@ def verify_permuted_nodes(self, ts):
         # form, and identical to the original.
         simplified, s_node_map = permuted.simplify(map_nodes=True)
 
-        original_tables = ts.dump_tables()
-        simplified_tables = simplified.dump_tables()
-        original_tables.provenances.clear()
-        simplified_tables.provenances.clear()
-
-        assert original_tables.sequence_length == simplified_tables.sequence_length
-        assert original_tables.nodes == simplified_tables.nodes
-        assert original_tables.edges == simplified_tables.edges
-        assert original_tables.sites == simplified_tables.sites
-        assert original_tables.mutations == simplified_tables.mutations
-        assert original_tables.individuals == simplified_tables.individuals
-        assert original_tables.populations == simplified_tables.populations
-
-        assert original_tables == simplified_tables
-        assert ts.sequence_length == simplified.sequence_length
-        for _ in simplified.trees():
-            pass
-
         for u, v in enumerate(node_map):
             assert s_node_map[v] == u
-        assert np.array_equal(simplified.samples(), ts.samples())
-        assert list(simplified.nodes()) == list(ts.nodes())
-        assert list(simplified.edges()) == list(ts.edges())
-        assert list(simplified.sites()) == list(ts.sites())
-        assert list(simplified.haplotypes()) == list(ts.haplotypes())
-        assert list(simplified.variants(as_bytes=True)) == list(
-            ts.variants(as_bytes=True)
-        )
+        ts.tables.assert_equals(simplified.tables, ignore_provenance=True)
 
     def test_single_tree_permuted_nodes(self):
         ts = msprime.simulate(10, mutation_rate=5, random_seed=self.random_seed)

python/tests/test_wright_fisher.py

@@ -579,9 +579,7 @@ def test_simplify_tables(self, ts, nsamples):
         node_map = tables.simplify(samples=sub_samples)
         small_ts = tables.tree_sequence()
         other_tables = small_ts.dump_tables()
-        tables.provenances.clear()
-        other_tables.provenances.clear()
-        tables.assert_equals(other_tables)
+        tables.assert_equals(other_tables, ignore_provenance=True)
         self.verify_simplify(ts, small_ts, sub_samples, node_map)
 
     @pytest.mark.parametrize("ts", wf_sims)