Add some tests for connecting ports to signals

test/port/test_inputport.py

-"""
-B-ASIC test suite for Inputport
-"""
-
-from b_asic import InputPort
-
-import pytest
-
-def test_connect_multiple_signals(signals):
-    """test if only one signal can connect to an input port."""
-    inp_port = InputPort(0, None)
-
-    for s in signals:
-        inp_port.connect(s)
-
-    assert inp_port.signal_count() == 1
-    assert inp_port.signals[0] == signals[-1]
-

test/port/test_outputport.py

@@ -2,15 +2,51 @@
 B-ASIC test suite for InputPort
 TODO: More info
 """
-from b_asic import OutputPort
+from b_asic import InputPort, OutputPort, Signal
 import pytest
 
-def test_connect_multiple_signals(signals):
+def test_connect_and_disconnect_multiple_signals(signals):
     """test if multiple signals can connect to an output port."""
-    outp_port = OutputPort(0, None)
+    out_port = OutputPort(0, None)
+    in_port = InputPort(0, None)
+    in_port1 = InputPort(0, None)
 
-    for s in signals:
-        outp_port.connect(s)
+    s1 = out_port.connect_to_port(in_port)
 
-    assert outp_port.signal_count() == 3
-    assert outp_port.signals == signals
+    assert in_port.connected_ports == [out_port]
+    assert out_port.connected_ports == [in_port]
+    assert in_port.signals == [s1]
+    assert out_port.signals == [s1]
+    assert s1.source is out_port
+    assert s1.destination is in_port
+    assert out_port.signal_count() == 1
+
+    s2 = Signal(destination=in_port1)
+    out_port.connect_to_signal(s2)
+
+    assert in_port1.connected_ports == [out_port]
+    assert out_port.connected_ports == [in_port, in_port1]
+    assert in_port1.signals == [s2]
+    assert out_port.signals == [s1, s2]
+    assert s2.source is out_port
+    assert s2.destination is in_port1
+    assert out_port.signal_count() == 2
+
+    s3 = Signal()
+    out_port.connect_to_signal(s3)
+
+    assert out_port.connected_ports == [in_port, in_port1]
+    assert out_port.signals == [s1, s2, s3]
+    assert s3.source is out_port
+    assert s3.destination is None
+    assert out_port.signal_count() == 3
+
+    out_port.disconnect_signal(1)
+
+    assert out_port.connected_ports == [in_port]
+    assert out_port.signals == [s1, s3]
+    assert out_port.signal_count() == 2
+
+    assert s2.destination is in_port1
+    assert s2.source is None
+    assert in_port1.signals == [s2]

test/port/test_port.py

-from b_asic import InputPort, OutputPort
+"""
+B-ASIC test suite for Inputport
+"""
 
 import pytest
 
-def test_connect_two_ports(signal):
-    """test if one inputport can connect to one outputport with one signal."""
+from b_asic import InputPort, OutputPort
+from b_asic import Signal
+
+# Fixtures 
+@pytest.fixture
+def inp_port():
+    return InputPort(0, None)
+
+@pytest.fixture
+def out_port():
+    return OutputPort(0, None)
+
+@pytest.fixture
+def out_port2():
+    return OutputPort(1, None)
+
+@pytest.fixture
+def dangling_sig():
+    return Signal()
+
+@pytest.fixture
+def s_w_source():
+    out_port = OutputPort(0, None)
+    return Signal(source=out_port)
+
+@pytest.fixture
+def sig_with_dest():
+    inp_port = InputPort(0, None)
+    return Signal(destination=out_port)
+
+@pytest.fixture
+def connected_sig():
+    out_port = OutputPort(0, None)
     inp_port = InputPort(0, None)
-    outp_port = OutputPort(1, None)
+    return Signal(source=out_port, destination=inp_port)
+
+# Tests
+def test_connect_to_port_then_disconnect(inp_port, out_port):
+    """Test connect unused port to port."""
+    s1 = inp_port.connect_to_port(out_port)
+
+    assert inp_port.connected_ports == [out_port]
+    assert out_port.connected_ports == [inp_port]
+    assert inp_port.signals == [s1]
+    assert out_port.signals == [s1]
+    assert s1.source is out_port
+    assert s1.destination is inp_port
+
+    inp_port.disconnect_signal()
+
+    assert inp_port.connected_ports == []
+    assert out_port.connected_ports == []
+    assert inp_port.signals == []
+    assert out_port.signals == [s1]
+    assert s1.source is out_port
+    assert s1.destination is None
+
+def test_connect_used_port_to_new_port(inp_port, out_port, out_port2):
+    """Test connect used port to new used port."""
+    s1 = inp_port.connect_to_port(out_port)
+
+    correct_exception = False
+    try:
+        s2 = inp_port.connect_to_port(out_port2)
+    except AssertionError:
+        correct_exception = True
+
+    assert correct_exception
+
+def test_connect_to_signal_then_disconnect(inp_port, s_w_source):
+    inp_port.connect_to_signal(s_w_source)
+
+    assert inp_port.connected_ports == [s_w_source.source]
+    assert s_w_source.source.connected_ports == [inp_port]
+    assert inp_port.signals == [s_w_source]
+    assert s_w_source.source.signals == [s_w_source]
+    assert s_w_source.destination is inp_port
+
+    inp_port.disconnect_signal()
 
-    outp_port.connect(inp_port)
+    assert inp_port.connected_ports == []
+    assert s_w_source.source.connected_ports == []
+    assert inp_port.signals == []
+    assert s_w_source.source.signals == [s_w_source]
+    assert s_w_source.destination is None
 
-    assert inp_port.connected_ports == [outp_port]
-    assert outp_port.connected_ports == [inp_port]
\ No newline at end of file