def test_diff_summary(self): """Test diff tool summary""" cdt1 = space_time.generate_flat_spacetime(3, 3) cdt2 = space_time.generate_flat_spacetime(3, 4) diff = audit.node_diff(cdt1, cdt2) summary = audit.format_diff(diff) assert isinstance(summary, str)
def test_push_pop_identity(self): """Test that push * pop == identity""" base = space_time.generate_flat_spacetime(10, 10) # to compare against st = space_time.generate_flat_spacetime(10, 10) assert base == st node = event.Event(st, 13) st.push(st.pop([node])) assert base == st
def test_face_hash(self): """Test Event Hash""" dst_1 = space_time.generate_flat_spacetime(2, 2) f0_1, *_ = face.faces(dst_1) dst_2 = space_time.generate_flat_spacetime(2, 2) f0_2, *_ = face.faces(dst_2) assert hash(f0_1) == hash(f0_2)
def test_equality(self): """Test equality""" dst = space_time.generate_flat_spacetime(3, 3) dst_2 = space_time.generate_flat_spacetime(3, 3) assert dst == dst_2 e4 = event.Event(dst, 4) sub_dst = dst.pop([e4]) assert dst != dst_2
def test_event_hash(self): """Test Event Hash""" dst_1 = space_time.generate_flat_spacetime(2, 2) e0_1, *_ = event.events(dst_1, range(4)) dst_2 = space_time.generate_flat_spacetime(2, 2) e0_2, *_ = event.events(dst_2, range(4)) assert hash(e0_1) == hash(e0_2)
def test_find_duplicate_temp_conn(self): """Test duplicate connection finder""" valid_cdt = space_time.generate_flat_spacetime(10, 10) invalid_cdt = space_time.generate_flat_spacetime(10, 10) invalid_cdt.node_future[0] = [10, 19, 19] valid_dups = audit.find_duplicate_temporal_connections(valid_cdt) assert valid_dups is None invalid_dups = audit.find_duplicate_temporal_connections(invalid_cdt) assert invalid_dups is not None assert invalid_dups == [(0, 'future', [10, 19, 19])]
def test_event_equality(self): """Test Event equality""" dst = space_time.generate_flat_spacetime(2, 2) e1 = event.Event(space_time=dst, event_key=1) e2 = event.Event(space_time=dst, event_key=1) assert e1 == e2 # TODO uncomment the below test once equality defined for SpaceTime dst2 = space_time.generate_flat_spacetime(2, 3) e1_2 = event.Event(space_time=dst2, event_key=1) assert e1 != e1_2
def test_face_equality(self): """Test Event equality""" dst = space_time.generate_flat_spacetime(2, 2) e1 = face.Face(space_time=dst, key=0) e2 = face.Face(space_time=dst, key=0) assert e1 == e2 # TODO uncomment the below test once equality defined for SpaceTime dst2 = space_time.generate_flat_spacetime(2, 3) e1_2 = face.Face(space_time=dst2, key=0) assert e1 != e1_2
def test_pop_push_unique(self): """Test for temporal connection uniqueness, based on Jackson's repro 2021-02-21""" st = space_time.generate_flat_spacetime(10, 10) node = event.Event(st, 13) st.push(st.pop([node])) dups = audit.find_duplicate_temporal_connections(st) assert dups is None
def test_push(self): dst = space_time.generate_flat_spacetime(3, 3) e0 = event.Event(dst, 0) dst2 = dst.pop([e0]) dst.push(dst2) # TODO add real equivalence check assert isinstance(dst, SpaceTime)
def test_push_pop_gluing_points(self): st = space_time.generate_flat_spacetime(10, 10) node = event.Event(st, 13) st.push(st.pop([node])) gp_nodes, gp_refs = audit.find_gluing_point_references(st) assert gp_nodes == [] assert gp_refs == []
def test_face_repr(self): """Test event string representation""" dst = space_time.generate_flat_spacetime(2, 2) f = face.Face(space_time=dst, key=0) print(f) assert repr(f) == 'Face(ST4, 0, {0, 1, 3})'
def test_multiple_moves(self): dst = generate_flat_spacetime(4, 4) n1, f1, p1 = event.events(dst, [12, 0, 11]) moves.increase(dst, n1, f1, p1) n2, f2, p2 = event.events(dst, [13, 1, 9]) moves.increase(dst, n2, f2, p2) assert isinstance(dst, SpaceTime)
def test_is_gluing_point(self): """Test is gluing point""" dst = space_time.generate_flat_spacetime(2, 2) e1 = event.Event(dst, event.GluingPoint(0)) e2 = event.Event(dst, 0) assert e1.is_gluing_point assert not e2.is_gluing_point
def test_set_faces(self): dst = space_time.generate_flat_spacetime(2, 2) e0, e1, e2, e3 = event.events(dst) print(e0.faces) assert e0.faces == {0, 1, 2, 5, 6, 7} event.set_faces(e0, [2]) assert e0.faces == {2}
def test_get_layers(self): """Test layer calculation""" st = space_time.generate_flat_spacetime(8, 10) layers = st.get_layers() assert isinstance(layers, dict) for l in range(10): assert l in layers assert len(layers[l]) == 8
def test_multiple_imove(self): """Test inverse move""" dst = generate_flat_spacetime(4, 4) n = event.Event(dst, 5) moves.decrease(dst, n) n = event.Event(dst, 5) moves.decrease(dst, n) assert isinstance(dst, SpaceTime)
def test_event_pass_thru_getattr(self): """Test event getattr behavior for passthru attributes""" dst = space_time.generate_flat_spacetime(2, 2) e0, e1, e2, e3 = event.events(dst, range(4)) assert e0.right == e1 assert e1.left == e0 assert e0.future == {e2, e3} assert e3.past == {e0, e1}
def test_face_pass_thru_getattr(self): """Test event getattr behavior for passthru attributes""" dst = space_time.generate_flat_spacetime(3, 3) face_list = [5, 2, 10] e0, e1, e2 = face.faces(dst, face_list) assert e0.left == e1 assert e1.right == e0 assert e0.temporal_neighbor == e2 assert e0.type == 1
def test_consistent_set_left(self): """Check set .left""" dst = space_time.generate_flat_spacetime(3, 3) e0, e1, e2, e3, e4, e5, e6, e7, e8 = event.events(dst, range(9)) assert e0.right == e1 event.connect_spatial(e0, e2) assert e2.left == e0 assert e1.left is None
def test_volume_profile(self): """Test volume profile""" dst = space_time.generate_flat_spacetime(4, 4) n1, f1, p1 = event.events(dst, [12, 0, 11]) moves.increase(dst, n1, f1, p1) n2, f2, p2 = event.events(dst, [13, 1, 9]) moves.increase(dst, n2, f2, p2) vp = observables.volume_profile(dst) assert str(vp) == '[4 4 4 6]'
def test_consistent_set_future(self): """Check set .future""" dst = space_time.generate_flat_spacetime(3, 3) e0, e1, e2, e3, e4, e5, e6, e7, e8 = event.events(dst, range(9)) assert e0.future == {e3, e4} event.connect_temporal(e0, future={e4, e5}) assert e0 in e4.past assert e0 in e5.past assert e0 not in e3.past
def test_consistent_set_past(self): """Check set .past""" dst = space_time.generate_flat_spacetime(3, 3) e0, e1, e2, e3, e4, e5, e6, e7, e8 = event.events(dst, range(9)) assert e0.past == {e8, e6} event.connect_temporal(e0, past={e8, e7}) assert e0 in e7.future assert e0 in e8.future assert e0 not in e6.future
def test_coerce_gluing_point(self): """Test gluing point coercion""" dst_1 = space_time.generate_flat_spacetime(2, 2) e0_1 = event.Event(dst_1, 0) dst_2 = dst_1.pop([e0_1]) e0_2 = event.Event(dst_2, 0) e0_star = event.coerce_gluing_point(dst_1, e0_2) assert not isinstance(e0_1.key, event.GluingPoint) assert not isinstance(e0_2.key, event.GluingPoint) assert isinstance(e0_star.key, event.GluingPoint)
def test_from_dict(self): """Load SpaceTime from dictionary""" st_loaded = SpaceTime.from_dict(config_dict=self.SAMPLE_CONFIG_DICT) st = space_time.generate_flat_spacetime(2, 2) assert isinstance(st_loaded, SpaceTime) assert st_loaded == st # Test incomplete dict raises error incomplete_dict = self.SAMPLE_CONFIG_DICT.copy() incomplete_dict.pop('nodes') with pytest.raises(space_time.SerializationError): SpaceTime.from_dict(incomplete_dict)
def test_simulate_with_sampling(self): def size(st): return len(st.nodes) sample_funcs = {'size': size} st = space_time.generate_flat_spacetime(10, 10) samples = simulation.simulate(st, iters=6, sampling_interval=2, sampling_funcs=sample_funcs) assert isinstance(samples, dict) assert set(samples.keys()) == {'size'} assert len(samples['size']) == 3
def test_from_pickle(self): """Test creation of SpaceTime from pickle""" st = space_time.generate_flat_spacetime(2, 2) st_loaded = SpaceTime.from_pickle(data=self._sample_pickle()) assert isinstance(st_loaded, SpaceTime) assert st_loaded == st with tempfile.TemporaryDirectory() as tmp: path = pathlib.Path(tmp) / 'test_to_pickle.pkl' with open(path.as_posix(), 'wb') as fid: fid.write(self._sample_pickle()) st_loaded = SpaceTime.from_pickle(path=path) assert isinstance(st_loaded, SpaceTime) assert st_loaded == st
def test_to_pickle(self): """Test conversion of SpaceTime to pickle data""" st = space_time.generate_flat_spacetime(2, 2) st_s = st.to_pickle() assert st_s == self._sample_pickle() with tempfile.TemporaryDirectory() as tmp: path = pathlib.Path(tmp) / 'test_to_pickle.pkl' st.to_pickle(path=path) assert os.path.exists(path.as_posix()) # check file written out with open(path.as_posix(), 'rb') as fid: content = fid.read() assert content == self._sample_pickle()
def main(): size = 40 FST = generate_flat_spacetime(size, size) random.seed(9230) # for i in range(50): if i % 100: print(i) n = FST.get_random_node() f = random.choice(list(n.future)) p = random.choice(list(n.past)) increase(FST, n, f, p) # n = FST.get_random_node() # print(n) # imove(FST,n) # FST.imove(n) print("plottin") # display.get_naive_coords(FST) plot_st.plot_2d(FST)
def make_spacetime(size: int): return space_time.generate_flat_spacetime(size, size)