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)
