Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
  • 13-add-coupled-operations-to-sfg
  • 14-coupling-sfg-s
  • 17-operation-replacement-in-a-sfg
  • 2-operation-id-system
  • 22-deep-copy-of-sfg
  • 23-create-custom-operation
  • 31-print-schedule
  • 34-processor-and-memory-information-in-schedules
  • 65-implement-a-workspace-in-the-gui-2
  • 66-load-save-sfg-to-file
  • 82-explode-sfg
  • 84-unfolding-of-an-sfg
  • 87-resize-gui-window
  • MultiSimPlot
  • add-fft-generator
  • add-memory-constraint-for-list-schedulers
  • add-slack-time-sched
  • aptcache
  • codegen-commit-hash
  • commutative
  • constantpropagation
  • develop
  • fixes
  • fixschedule2
  • fpl-2023
  • master
  • operationspc2
  • petka86-find_by_type_name
  • ruff
  • scheduler-gui
  • scriptdebug
  • sinkdc
  • tmin
  • wdfadaptors
  • 1.0.0
  • cbasedsim
36 results

Target

Select target project
  • da/B-ASIC
  • lukja239/B-ASIC
  • robal695/B-ASIC
3 results
Select Git revision
Show changes
...@@ -2,226 +2,165 @@ ...@@ -2,226 +2,165 @@
B-ASIC test suite for the core operations. B-ASIC test suite for the core operations.
""" """
from b_asic.core_operations import Constant, Addition, Subtraction, Multiplication, Division, SquareRoot, ComplexConjugate, Max, Min, Absolute, ConstantMultiplication, ConstantAddition, ConstantSubtraction, ConstantDivision from b_asic import \
Constant, Addition, Subtraction, Multiplication, ConstantMultiplication, Division, \
# Constant tests. SquareRoot, ComplexConjugate, Max, Min, Absolute, Butterfly
def test_constant():
constant_operation = Constant(3)
assert constant_operation.evaluate() == 3 class TestConstant:
def test_constant_positive(self):
def test_constant_negative(): test_operation = Constant(3)
constant_operation = Constant(-3) assert test_operation.evaluate_output(0, []) == 3
assert constant_operation.evaluate() == -3
def test_constant_negative(self):
def test_constant_complex(): test_operation = Constant(-3)
constant_operation = Constant(3+4j) assert test_operation.evaluate_output(0, []) == -3
assert constant_operation.evaluate() == 3+4j
def test_constant_complex(self):
# Addition tests. test_operation = Constant(3+4j)
def test_addition(): assert test_operation.evaluate_output(0, []) == 3+4j
test_operation = Addition()
constant_operation = Constant(3)
constant_operation_2 = Constant(5) class TestAddition:
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == 8 def test_addition_positive(self):
test_operation = Addition()
def test_addition_negative(): assert test_operation.evaluate_output(0, [3, 5]) == 8
test_operation = Addition()
constant_operation = Constant(-3) def test_addition_negative(self):
constant_operation_2 = Constant(-5) test_operation = Addition()
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == -8 assert test_operation.evaluate_output(0, [-3, -5]) == -8
def test_addition_complex(): def test_addition_complex(self):
test_operation = Addition() test_operation = Addition()
constant_operation = Constant((3+5j)) assert test_operation.evaluate_output(0, [3+5j, 4+6j]) == 7+11j
constant_operation_2 = Constant((4+6j))
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == (7+11j)
class TestSubtraction:
# Subtraction tests. def test_subtraction_positive(self):
def test_subtraction(): test_operation = Subtraction()
test_operation = Subtraction() assert test_operation.evaluate_output(0, [5, 3]) == 2
constant_operation = Constant(5)
constant_operation_2 = Constant(3) def test_subtraction_negative(self):
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == 2 test_operation = Subtraction()
assert test_operation.evaluate_output(0, [-5, -3]) == -2
def test_subtraction_negative():
test_operation = Subtraction() def test_subtraction_complex(self):
constant_operation = Constant(-5) test_operation = Subtraction()
constant_operation_2 = Constant(-3) assert test_operation.evaluate_output(0, [3+5j, 4+6j]) == -1-1j
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == -2
def test_subtraction_complex(): class TestMultiplication:
test_operation = Subtraction() def test_multiplication_positive(self):
constant_operation = Constant((3+5j)) test_operation = Multiplication()
constant_operation_2 = Constant((4+6j)) assert test_operation.evaluate_output(0, [5, 3]) == 15
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == (-1-1j)
def test_multiplication_negative(self):
# Multiplication tests. test_operation = Multiplication()
def test_multiplication(): assert test_operation.evaluate_output(0, [-5, -3]) == 15
test_operation = Multiplication()
constant_operation = Constant(5) def test_multiplication_complex(self):
constant_operation_2 = Constant(3) test_operation = Multiplication()
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == 15 assert test_operation.evaluate_output(0, [3+5j, 4+6j]) == -18+38j
def test_multiplication_negative():
test_operation = Multiplication() class TestDivision:
constant_operation = Constant(-5) def test_division_positive(self):
constant_operation_2 = Constant(-3) test_operation = Division()
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == 15 assert test_operation.evaluate_output(0, [30, 5]) == 6
def test_multiplication_complex(): def test_division_negative(self):
test_operation = Multiplication() test_operation = Division()
constant_operation = Constant((3+5j)) assert test_operation.evaluate_output(0, [-30, -5]) == 6
constant_operation_2 = Constant((4+6j))
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == (-18+38j) def test_division_complex(self):
test_operation = Division()
# Division tests. assert test_operation.evaluate_output(0, [60+40j, 10+20j]) == 2.8-1.6j
def test_division():
test_operation = Division()
constant_operation = Constant(30) class TestSquareRoot:
constant_operation_2 = Constant(5) def test_squareroot_positive(self):
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == 6 test_operation = SquareRoot()
assert test_operation.evaluate_output(0, [36]) == 6
def test_division_negative():
test_operation = Division() def test_squareroot_negative(self):
constant_operation = Constant(-30) test_operation = SquareRoot()
constant_operation_2 = Constant(-5) assert test_operation.evaluate_output(0, [-36]) == 6j
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == 6
def test_squareroot_complex(self):
def test_division_complex(): test_operation = SquareRoot()
test_operation = Division() assert test_operation.evaluate_output(0, [48+64j]) == 8+4j
constant_operation = Constant((60+40j))
constant_operation_2 = Constant((10+20j))
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == (2.8-1.6j) class TestComplexConjugate:
def test_complexconjugate_positive(self):
# SquareRoot tests. test_operation = ComplexConjugate()
def test_squareroot(): assert test_operation.evaluate_output(0, [3+4j]) == 3-4j
test_operation = SquareRoot()
constant_operation = Constant(36) def test_test_complexconjugate_negative(self):
assert test_operation.evaluate(constant_operation.evaluate()) == 6 test_operation = ComplexConjugate()
assert test_operation.evaluate_output(0, [-3-4j]) == -3+4j
def test_squareroot_negative():
test_operation = SquareRoot()
constant_operation = Constant(-36) class TestMax:
assert test_operation.evaluate(constant_operation.evaluate()) == 6j def test_max_positive(self):
test_operation = Max()
def test_squareroot_complex(): assert test_operation.evaluate_output(0, [30, 5]) == 30
test_operation = SquareRoot()
constant_operation = Constant((48+64j)) def test_max_negative(self):
assert test_operation.evaluate(constant_operation.evaluate()) == (8+4j) test_operation = Max()
assert test_operation.evaluate_output(0, [-30, -5]) == -5
# ComplexConjugate tests.
def test_complexconjugate():
test_operation = ComplexConjugate() class TestMin:
constant_operation = Constant(3+4j) def test_min_positive(self):
assert test_operation.evaluate(constant_operation.evaluate()) == (3-4j) test_operation = Min()
assert test_operation.evaluate_output(0, [30, 5]) == 5
def test_test_complexconjugate_negative():
test_operation = ComplexConjugate() def test_min_negative(self):
constant_operation = Constant(-3-4j) test_operation = Min()
assert test_operation.evaluate(constant_operation.evaluate()) == (-3+4j) assert test_operation.evaluate_output(0, [-30, -5]) == -30
# Max tests.
def test_max(): class TestAbsolute:
test_operation = Max() def test_absolute_positive(self):
constant_operation = Constant(30) test_operation = Absolute()
constant_operation_2 = Constant(5) assert test_operation.evaluate_output(0, [30]) == 30
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == 30
def test_absolute_negative(self):
def test_max_negative(): test_operation = Absolute()
test_operation = Max() assert test_operation.evaluate_output(0, [-5]) == 5
constant_operation = Constant(-30)
constant_operation_2 = Constant(-5) def test_absolute_complex(self):
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == -5 test_operation = Absolute()
assert test_operation.evaluate_output(0, [3+4j]) == 5.0
# Min tests.
def test_min():
test_operation = Min() class TestConstantMultiplication:
constant_operation = Constant(30) def test_constantmultiplication_positive(self):
constant_operation_2 = Constant(5) test_operation = ConstantMultiplication(5)
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == 5 assert test_operation.evaluate_output(0, [20]) == 100
def test_min_negative(): def test_constantmultiplication_negative(self):
test_operation = Min() test_operation = ConstantMultiplication(5)
constant_operation = Constant(-30) assert test_operation.evaluate_output(0, [-5]) == -25
constant_operation_2 = Constant(-5)
assert test_operation.evaluate(constant_operation.evaluate(), constant_operation_2.evaluate()) == -30 def test_constantmultiplication_complex(self):
test_operation = ConstantMultiplication(3+2j)
# Absolute tests. assert test_operation.evaluate_output(0, [3+4j]) == 1+18j
def test_absolute():
test_operation = Absolute()
constant_operation = Constant(30) class TestButterfly:
assert test_operation.evaluate(constant_operation.evaluate()) == 30 def test_butterfly_positive(self):
test_operation = Butterfly()
def test_absolute_negative(): assert test_operation.evaluate_output(0, [2, 3]) == 5
test_operation = Absolute() assert test_operation.evaluate_output(1, [2, 3]) == -1
constant_operation = Constant(-5)
assert test_operation.evaluate(constant_operation.evaluate()) == 5 def test_butterfly_negative(self):
test_operation = Butterfly()
def test_absolute_complex(): assert test_operation.evaluate_output(0, [-2, -3]) == -5
test_operation = Absolute() assert test_operation.evaluate_output(1, [-2, -3]) == 1
constant_operation = Constant((3+4j))
assert test_operation.evaluate(constant_operation.evaluate()) == 5.0 def test_buttefly_complex(self):
test_operation = Butterfly()
# ConstantMultiplication tests. assert test_operation.evaluate_output(0, [2+1j, 3-2j]) == 5-1j
def test_constantmultiplication(): assert test_operation.evaluate_output(1, [2+1j, 3-2j]) == -1+3j
test_operation = ConstantMultiplication(5)
constant_operation = Constant(20)
assert test_operation.evaluate(constant_operation.evaluate()) == 100
def test_constantmultiplication_negative():
test_operation = ConstantMultiplication(5)
constant_operation = Constant(-5)
assert test_operation.evaluate(constant_operation.evaluate()) == -25
def test_constantmultiplication_complex():
test_operation = ConstantMultiplication(3+2j)
constant_operation = Constant((3+4j))
assert test_operation.evaluate(constant_operation.evaluate()) == (1+18j)
# ConstantAddition tests.
def test_constantaddition():
test_operation = ConstantAddition(5)
constant_operation = Constant(20)
assert test_operation.evaluate(constant_operation.evaluate()) == 25
def test_constantaddition_negative():
test_operation = ConstantAddition(4)
constant_operation = Constant(-5)
assert test_operation.evaluate(constant_operation.evaluate()) == -1
def test_constantaddition_complex():
test_operation = ConstantAddition(3+2j)
constant_operation = Constant((3+4j))
assert test_operation.evaluate(constant_operation.evaluate()) == (6+6j)
# ConstantSubtraction tests.
def test_constantsubtraction():
test_operation = ConstantSubtraction(5)
constant_operation = Constant(20)
assert test_operation.evaluate(constant_operation.evaluate()) == 15
def test_constantsubtraction_negative():
test_operation = ConstantSubtraction(4)
constant_operation = Constant(-5)
assert test_operation.evaluate(constant_operation.evaluate()) == -9
def test_constantsubtraction_complex():
test_operation = ConstantSubtraction(4+6j)
constant_operation = Constant((3+4j))
assert test_operation.evaluate(constant_operation.evaluate()) == (-1-2j)
# ConstantDivision tests.
def test_constantdivision():
test_operation = ConstantDivision(5)
constant_operation = Constant(20)
assert test_operation.evaluate(constant_operation.evaluate()) == 4
def test_constantdivision_negative():
test_operation = ConstantDivision(4)
constant_operation = Constant(-20)
assert test_operation.evaluate(constant_operation.evaluate()) == -5
def test_constantdivision_complex():
test_operation = ConstantDivision(2+2j)
constant_operation = Constant((10+10j))
assert test_operation.evaluate(constant_operation.evaluate()) == (5+0j)
...@@ -2,9 +2,10 @@ ...@@ -2,9 +2,10 @@
B-ASIC test suite for graph id generator. B-ASIC test suite for graph id generator.
""" """
from b_asic.graph_id import GraphIDGenerator, GraphID
import pytest import pytest
from b_asic import GraphIDGenerator, GraphID
@pytest.fixture @pytest.fixture
def graph_id_generator(): def graph_id_generator():
return GraphIDGenerator() return GraphIDGenerator()
...@@ -12,17 +13,17 @@ def graph_id_generator(): ...@@ -12,17 +13,17 @@ def graph_id_generator():
class TestGetNextId: class TestGetNextId:
def test_empty_string_generator(self, graph_id_generator): def test_empty_string_generator(self, graph_id_generator):
"""Test the graph id generator for an empty string type.""" """Test the graph id generator for an empty string type."""
assert graph_id_generator.get_next_id("") == "1" assert graph_id_generator.next_id("") == "1"
assert graph_id_generator.get_next_id("") == "2" assert graph_id_generator.next_id("") == "2"
def test_normal_string_generator(self, graph_id_generator): def test_normal_string_generator(self, graph_id_generator):
""""Test the graph id generator for a normal string type.""" """"Test the graph id generator for a normal string type."""
assert graph_id_generator.get_next_id("add") == "add1" assert graph_id_generator.next_id("add") == "add1"
assert graph_id_generator.get_next_id("add") == "add2" assert graph_id_generator.next_id("add") == "add2"
def test_different_strings_generator(self, graph_id_generator): def test_different_strings_generator(self, graph_id_generator):
"""Test the graph id generator for different strings.""" """Test the graph id generator for different strings."""
assert graph_id_generator.get_next_id("sub") == "sub1" assert graph_id_generator.next_id("sub") == "sub1"
assert graph_id_generator.get_next_id("mul") == "mul1" assert graph_id_generator.next_id("mul") == "mul1"
assert graph_id_generator.get_next_id("sub") == "sub2" assert graph_id_generator.next_id("sub") == "sub2"
assert graph_id_generator.get_next_id("mul") == "mul2" assert graph_id_generator.next_id("mul") == "mul2"
...@@ -4,47 +4,41 @@ B-ASIC test suite for Inputport ...@@ -4,47 +4,41 @@ B-ASIC test suite for Inputport
import pytest import pytest
from b_asic import InputPort, OutputPort from b_asic import InputPort, OutputPort, Signal
from b_asic import Signal
@pytest.fixture @pytest.fixture
def inp_port(): def inp_port():
return InputPort(0, None) return InputPort(None, 0)
@pytest.fixture @pytest.fixture
def out_port(): def out_port():
return OutputPort(0, None) return OutputPort(None, 0)
@pytest.fixture @pytest.fixture
def out_port2(): def out_port2():
return OutputPort(1, None) return OutputPort(None, 1)
@pytest.fixture @pytest.fixture
def dangling_sig(): def dangling_sig():
return Signal() return Signal()
@pytest.fixture @pytest.fixture
def s_w_source(): def s_w_source(out_port):
out_port = OutputPort(0, None)
return Signal(source=out_port) return Signal(source=out_port)
@pytest.fixture @pytest.fixture
def sig_with_dest(): def sig_with_dest(inp_port):
inp_port = InputPort(0, None) return Signal(destination=inp_port)
return Signal(destination=out_port)
@pytest.fixture @pytest.fixture
def connected_sig(): def connected_sig(inp_port, out_port):
out_port = OutputPort(0, None)
inp_port = InputPort(0, None)
return Signal(source=out_port, destination=inp_port) return Signal(source=out_port, destination=inp_port)
def test_connect_then_disconnect(inp_port, out_port): def test_connect_then_disconnect(inp_port, out_port):
"""Test connect unused port to port.""" """Test connect unused port to port."""
s1 = inp_port.connect(out_port) s1 = inp_port.connect(out_port)
assert inp_port.connected_ports == [out_port] assert inp_port.connected_source == out_port
assert out_port.connected_ports == [inp_port]
assert inp_port.signals == [s1] assert inp_port.signals == [s1]
assert out_port.signals == [s1] assert out_port.signals == [s1]
assert s1.source is out_port assert s1.source is out_port
...@@ -52,8 +46,7 @@ def test_connect_then_disconnect(inp_port, out_port): ...@@ -52,8 +46,7 @@ def test_connect_then_disconnect(inp_port, out_port):
inp_port.remove_signal(s1) inp_port.remove_signal(s1)
assert inp_port.connected_ports == [] assert inp_port.connected_source is None
assert out_port.connected_ports == []
assert inp_port.signals == [] assert inp_port.signals == []
assert out_port.signals == [s1] assert out_port.signals == [s1]
assert s1.source is out_port assert s1.source is out_port
...@@ -62,34 +55,21 @@ def test_connect_then_disconnect(inp_port, out_port): ...@@ -62,34 +55,21 @@ def test_connect_then_disconnect(inp_port, out_port):
def test_connect_used_port_to_new_port(inp_port, out_port, out_port2): def test_connect_used_port_to_new_port(inp_port, out_port, out_port2):
"""Does connecting multiple ports to an inputport throw error?""" """Does connecting multiple ports to an inputport throw error?"""
inp_port.connect(out_port) inp_port.connect(out_port)
with pytest.raises(AssertionError): with pytest.raises(Exception):
inp_port.connect(out_port2) inp_port.connect(out_port2)
def test_add_signal_then_disconnect(inp_port, s_w_source): def test_add_signal_then_disconnect(inp_port, s_w_source):
"""Can signal be connected then disconnected properly?""" """Can signal be connected then disconnected properly?"""
inp_port.add_signal(s_w_source) inp_port.add_signal(s_w_source)
assert inp_port.connected_ports == [s_w_source.source] assert inp_port.connected_source == s_w_source.source
assert s_w_source.source.connected_ports == [inp_port]
assert inp_port.signals == [s_w_source] assert inp_port.signals == [s_w_source]
assert s_w_source.source.signals == [s_w_source] assert s_w_source.source.signals == [s_w_source]
assert s_w_source.destination is inp_port assert s_w_source.destination is inp_port
inp_port.remove_signal(s_w_source) inp_port.remove_signal(s_w_source)
assert inp_port.connected_ports == [] assert inp_port.connected_source is None
assert s_w_source.source.connected_ports == []
assert inp_port.signals == [] assert inp_port.signals == []
assert s_w_source.source.signals == [s_w_source] assert s_w_source.source.signals == [s_w_source]
assert s_w_source.destination is None assert s_w_source.destination is None
def test_connect_then_disconnect(inp_port, out_port):
"""Can port be connected and then disconnected properly?"""
inp_port.connect(out_port)
inp_port.disconnect(out_port)
print("outport signals:", out_port.signals, "count:", out_port.signal_count())
assert inp_port.signal_count() == 1
assert len(inp_port.connected_ports) == 0
assert out_port.signal_count() == 0
from b_asic.core_operations import Constant, Addition
from b_asic.signal import Signal
from b_asic.port import InputPort, OutputPort
import pytest import pytest
from b_asic import Constant, Addition
class TestTraverse: class TestTraverse:
def test_traverse_single_tree(self, operation): def test_traverse_single_tree(self, operation):
"""Traverse a tree consisting of one operation.""" """Traverse a tree consisting of one operation."""
...@@ -12,20 +10,16 @@ class TestTraverse: ...@@ -12,20 +10,16 @@ class TestTraverse:
def test_traverse_tree(self, operation_tree): def test_traverse_tree(self, operation_tree):
"""Traverse a basic addition tree with two constants.""" """Traverse a basic addition tree with two constants."""
assert len(list(operation_tree.traverse())) == 3 assert len(list(operation_tree.traverse())) == 5
def test_traverse_large_tree(self, large_operation_tree): def test_traverse_large_tree(self, large_operation_tree):
"""Traverse a larger tree.""" """Traverse a larger tree."""
assert len(list(large_operation_tree.traverse())) == 7 assert len(list(large_operation_tree.traverse())) == 13
def test_traverse_type(self, large_operation_tree): def test_traverse_type(self, large_operation_tree):
traverse = list(large_operation_tree.traverse()) result = list(large_operation_tree.traverse())
assert len(list(filter(lambda type_: isinstance(type_, Addition), traverse))) == 3 assert len(list(filter(lambda type_: isinstance(type_, Addition), result))) == 3
assert len(list(filter(lambda type_: isinstance(type_, Constant), traverse))) == 4 assert len(list(filter(lambda type_: isinstance(type_, Constant), result))) == 4
def test_traverse_loop(self, operation_tree): def test_traverse_loop(self, operation_graph_with_cycle):
add_oper_signal = Signal() assert len(list(operation_graph_with_cycle.traverse())) == 8
operation_tree._output_ports[0].add_signal(add_oper_signal) \ No newline at end of file
operation_tree._input_ports[0].remove_signal(add_oper_signal)
operation_tree._input_ports[0].add_signal(add_oper_signal)
assert len(list(operation_tree.traverse())) == 2
""" """
B-ASIC test suite for OutputPort. B-ASIC test suite for OutputPort.
""" """
from b_asic import OutputPort, InputPort, Signal
import pytest import pytest
from b_asic import OutputPort, InputPort, Signal
@pytest.fixture @pytest.fixture
def output_port(): def output_port():
return OutputPort(0, None) return OutputPort(None, 0)
@pytest.fixture @pytest.fixture
def input_port(): def input_port():
return InputPort(0, None) return InputPort(None, 0)
@pytest.fixture @pytest.fixture
def list_of_input_ports(): def list_of_input_ports():
return [InputPort(_, None) for _ in range(0,3)] return [InputPort(None, i) for i in range(0, 3)]
class TestConnect: class TestConnect:
def test_multiple_ports(self, output_port, list_of_input_ports): def test_multiple_ports(self, output_port, list_of_input_ports):
"""Can multiple ports connect to an output port?""" """Can multiple ports connect to an output port?"""
for port in list_of_input_ports: for port in list_of_input_ports:
output_port.connect(port) port.connect(output_port)
assert output_port.signal_count() == len(list_of_input_ports) assert output_port.signal_count == len(list_of_input_ports)
def test_same_port(self, output_port, list_of_input_ports): def test_same_port(self, output_port, list_of_input_ports):
"""Check error handing.""" """Check error handing."""
output_port.connect(list_of_input_ports[0]) list_of_input_ports[0].connect(output_port)
with pytest.raises(AssertionError): with pytest.raises(Exception):
output_port.connect(list_of_input_ports[0]) list_of_input_ports[0].connect(output_port)
assert output_port.signal_count() == 2 assert output_port.signal_count == 1
class TestAddSignal: class TestAddSignal:
def test_dangling(self, output_port): def test_dangling(self, output_port):
s = Signal() s = Signal()
output_port.add_signal(s) output_port.add_signal(s)
assert output_port.signal_count() == 1 assert output_port.signal_count == 1
assert output_port.signals == [s]
def test_with_destination(self, output_port, input_port):
s = Signal(destination=input_port)
output_port.add_signal(s)
assert output_port.connected_ports == [s.destination]
class TestDisconnect: class TestDisconnect:
def test_multiple_ports(self, output_port, list_of_input_ports): def test_others_clear(self, output_port, list_of_input_ports):
"""Can multiple ports disconnect from OutputPort?""" """Can multiple ports disconnect from OutputPort?"""
for port in list_of_input_ports: for port in list_of_input_ports:
output_port.connect(port) port.connect(output_port)
for port in list_of_input_ports: for port in list_of_input_ports:
output_port.disconnect(port) port.clear()
assert output_port.signal_count() == 3 assert output_port.signal_count == 3
assert output_port.connected_ports == [] assert all(s.dangling() for s in output_port.signals)
def test_self_clear(self, output_port, list_of_input_ports):
"""Can an OutputPort disconnect from multiple ports?"""
for port in list_of_input_ports:
port.connect(output_port)
output_port.clear()
assert output_port.signal_count == 0
assert output_port.signals == []
class TestRemoveSignal: class TestRemoveSignal:
def test_one_signal(self, output_port, input_port): def test_one_signal(self, output_port, input_port):
s = output_port.connect(input_port) s = input_port.connect(output_port)
output_port.remove_signal(s) output_port.remove_signal(s)
assert output_port.signal_count() == 0 assert output_port.signal_count == 0
assert output_port.signals == [] assert output_port.signals == []
assert output_port.connected_ports == []
def test_multiple_signals(self, output_port, list_of_input_ports): def test_multiple_signals(self, output_port, list_of_input_ports):
"""Can multiple signals disconnect from OutputPort?""" """Can multiple signals disconnect from OutputPort?"""
sigs = [] sigs = []
for port in list_of_input_ports: for port in list_of_input_ports:
sigs.append(output_port.connect(port)) sigs.append(port.connect(output_port))
for sig in sigs: for s in sigs:
output_port.remove_signal(sig) output_port.remove_signal(s)
assert output_port.signal_count() == 0 assert output_port.signal_count == 0
assert output_port.signals == [] assert output_port.signals == []
"""
B-ASIC test suite for printing a SFG
"""
from b_asic.signal_flow_graph import SFG
from b_asic.core_operations import Addition, Multiplication, Constant
from b_asic.port import InputPort, OutputPort
from b_asic.signal import Signal
from b_asic.special_operations import Input, Output
import pytest
class TestPrintSfg:
def test_print_one_addition(self):
inp1 = Input("INP1")
inp2 = Input("INP2")
add1 = Addition(inp1, inp2, "ADD1")
out1 = Output(add1, "OUT1")
sfg = SFG(inputs=[inp1, inp2], outputs=[out1], name="sf1")
assert sfg.__str__() == ("id: add1, name: ADD1, input: [s1, s2], output: [s3]\nid: in1, name: INP1, input: [], output: [s1]\nid: in2, name: INP2, input: [], output: [s2]\nid: out1, name: OUT1, input: [s3], output: []\n")
def test_print_add_mul(self):
inp1 = Input("INP1")
inp2 = Input("INP2")
inp3 = Input("INP3")
add1 = Addition(inp1, inp2, "ADD1")
mul1 = Multiplication(add1, inp3, "MUL1")
out1 = Output(mul1, "OUT1")
sfg = SFG(inputs=[inp1, inp2, inp3], outputs=[out1], name="mac_sfg")
assert sfg.__str__() == ("id: add1, name: ADD1, input: [s1, s2], output: [s5]\nid: in1, name: INP1, input: [], output: [s1]\nid: in2, name: INP2, input: [], output: [s2]\nid: mul1, name: MUL1, input: [s5, s3], output: [s4]\nid: in3, name: INP3, input: [], output: [s3]\nid: out1, name: OUT1, input: [s4], output: []\n")
def test_print_constant(self):
inp1 = Input("INP1")
const1 = Constant(3, "CONST")
add1 = Addition(const1, inp1, "ADD1")
out1 = Output(add1, "OUT1")
sfg = SFG(inputs=[inp1], outputs=[out1], name="sfg")
assert sfg.__str__() == ("id: add1, name: ADD1, input: [s3, s1], output: [s2]\nid: c1, name: CONST, value: 3, input: [], output: [s3]\nid: in1, name: INP1, input: [], output: [s1]\nid: out1, name: OUT1, input: [s2], output: []\n")
\ No newline at end of file
from b_asic import SFG, Operation
from b_asic.signal import Signal
from b_asic.core_operations import Addition, Constant, Multiplication
from b_asic.special_operations import Input, Output
class TestConstructor:
def test_direct_input_to_output_sfg_construction(self):
inp = Input("INP1")
out = Output(None, "OUT1")
out.input(0).connect(inp, "S1")
sfg = SFG(inputs=[inp], outputs=[out])
assert len(list(sfg.components)) == 3
assert sfg.input_count == 1
assert sfg.output_count == 1
def test_same_signal_input_and_output_sfg_construction(self):
add1 = Addition(None, None, "ADD1")
add2 = Addition(None, None, "ADD2")
sig1 = add2.input(0).connect(add1, "S1")
sfg = SFG(input_signals=[sig1], output_signals=[sig1])
assert len(list(sfg.components)) == 3
assert sfg.input_count == 1
assert sfg.output_count == 1
def test_outputs_construction(self, operation_tree):
outp = Output(operation_tree)
sfg = SFG(outputs=[outp])
assert len(list(sfg.components)) == 7
assert sfg.input_count == 0
assert sfg.output_count == 1
def test_signals_construction(self, operation_tree):
outs = Signal(source=operation_tree.output(0))
sfg = SFG(output_signals=[outs])
assert len(list(sfg.components)) == 7
assert sfg.input_count == 0
assert sfg.output_count == 1
class TestDeepCopy:
def test_deep_copy_no_duplicates(self):
inp1 = Input("INP1")
inp2 = Input("INP2")
inp3 = Input("INP3")
add1 = Addition(inp1, inp2, "ADD1")
mul1 = Multiplication(add1, inp3, "MUL1")
out1 = Output(mul1, "OUT1")
mac_sfg = SFG(inputs=[inp1, inp2],
outputs=[out1], name="mac_sfg")
mac_sfg_deep_copy = mac_sfg.deep_copy()
for g_id, component in mac_sfg._components_by_id.items():
component_copy = mac_sfg_deep_copy.find_by_id(g_id)
assert component.name == component_copy.name
def test_deep_copy(self):
inp1 = Input("INP1")
inp2 = Input("INP2")
inp3 = Input("INP3")
add1 = Addition(None, None, "ADD1")
add2 = Addition(None, None, "ADD2")
mul1 = Multiplication(None, None, "MUL1")
out1 = Output(None, "OUT1")
add1.input(0).connect(inp1, "S1")
add1.input(1).connect(inp2, "S2")
add2.input(0).connect(add1, "S4")
add2.input(1).connect(inp3, "S3")
mul1.input(0).connect(add1, "S5")
mul1.input(1).connect(add2, "S6")
out1.input(0).connect(mul1, "S7")
mac_sfg = SFG(inputs=[inp1, inp2],
outputs=[out1], name="mac_sfg")
mac_sfg_deep_copy = mac_sfg.deep_copy()
for g_id, component in mac_sfg._components_by_id.items():
component_copy = mac_sfg_deep_copy.find_by_id(g_id)
assert component.name == component_copy.name
class TestComponents:
def test_advanced_components(self):
inp1 = Input("INP1")
inp2 = Input("INP2")
inp3 = Input("INP3")
add1 = Addition(None, None, "ADD1")
add2 = Addition(None, None, "ADD2")
mul1 = Multiplication(None, None, "MUL1")
out1 = Output(None, "OUT1")
add1.input(0).connect(inp1, "S1")
add1.input(1).connect(inp2, "S2")
add2.input(0).connect(add1, "S4")
add2.input(1).connect(inp3, "S3")
mul1.input(0).connect(add1, "S5")
mul1.input(1).connect(add2, "S6")
out1.input(0).connect(mul1, "S7")
mac_sfg = SFG(inputs=[inp1, inp2],
outputs=[out1], name="mac_sfg")
assert set([comp.name for comp in mac_sfg.components]) == {
"INP1", "INP2", "INP3", "ADD1", "ADD2", "MUL1", "OUT1", "S1", "S2", "S3", "S4", "S5", "S6", "S7"}
...@@ -2,14 +2,14 @@ ...@@ -2,14 +2,14 @@
B-ASIC test suit for the signal module which consists of the Signal class. B-ASIC test suit for the signal module which consists of the Signal class.
""" """
from b_asic.port import InputPort, OutputPort
from b_asic.signal import Signal
import pytest import pytest
from b_asic import InputPort, OutputPort, Signal
def test_signal_creation_and_disconnction_and_connection_changing(): def test_signal_creation_and_disconnction_and_connection_changing():
in_port = InputPort(0, None) in_port = InputPort(None, 0)
out_port = OutputPort(1, None) out_port = OutputPort(None, 1)
s = Signal(out_port, in_port) s = Signal(out_port, in_port)
assert in_port.signals == [s] assert in_port.signals == [s]
...@@ -17,7 +17,7 @@ def test_signal_creation_and_disconnction_and_connection_changing(): ...@@ -17,7 +17,7 @@ def test_signal_creation_and_disconnction_and_connection_changing():
assert s.source is out_port assert s.source is out_port
assert s.destination is in_port assert s.destination is in_port
in_port1 = InputPort(0, None) in_port1 = InputPort(None, 0)
s.set_destination(in_port1) s.set_destination(in_port1)
assert in_port.signals == [] assert in_port.signals == []
...@@ -40,7 +40,7 @@ def test_signal_creation_and_disconnction_and_connection_changing(): ...@@ -40,7 +40,7 @@ def test_signal_creation_and_disconnction_and_connection_changing():
assert s.source is None assert s.source is None
assert s.destination is None assert s.destination is None
out_port1 = OutputPort(0, None) out_port1 = OutputPort(None, 0)
s.set_source(out_port1) s.set_source(out_port1)
assert out_port1.signals == [s] assert out_port1.signals == [s]
...@@ -60,3 +60,28 @@ def test_signal_creation_and_disconnction_and_connection_changing(): ...@@ -60,3 +60,28 @@ def test_signal_creation_and_disconnction_and_connection_changing():
assert in_port.signals == [s] assert in_port.signals == [s]
assert s.source is out_port assert s.source is out_port
assert s.destination is in_port assert s.destination is in_port
def test_signal_set_bits_pos_int(signal):
signal.bits = 10
assert signal.bits == 10
def test_signal_set_bits_zero(signal):
signal.bits = 0
assert signal.bits == 0
def test_signal_set_bits_neg_int(signal):
with pytest.raises(Exception):
signal.bits = -10
def test_signal_set_bits_complex(signal):
with pytest.raises(Exception):
signal.bits = (2+4j)
def test_signal_set_bits_float(signal):
with pytest.raises(Exception):
signal.bits = 3.2
def test_signal_set_bits_pos_then_none(signal):
signal.bits = 10
signal.bits = None
assert signal.bits is None
\ No newline at end of file
import pytest
from b_asic import SFG, Signal, Input, Output, Constant, Addition, Multiplication, SquareRoot
class TestConstructor:
def test_direct_input_to_output_sfg_construction(self):
in1 = Input("IN1")
out1 = Output(None, "OUT1")
out1.input(0).connect(in1, "S1")
sfg = SFG(inputs = [in1], outputs = [out1]) # in1 ---s1---> out1
assert len(list(sfg.components)) == 3
assert len(list(sfg.operations)) == 2
assert sfg.input_count == 1
assert sfg.output_count == 1
def test_same_signal_input_and_output_sfg_construction(self):
add1 = Addition(None, None, "ADD1")
add2 = Addition(None, None, "ADD2")
s1 = add2.input(0).connect(add1, "S1")
sfg = SFG(input_signals = [s1], output_signals = [s1]) # in1 ---s1---> out1
assert len(list(sfg.components)) == 3
assert len(list(sfg.operations)) == 2
assert sfg.input_count == 1
assert sfg.output_count == 1
def test_outputs_construction(self, operation_tree):
sfg = SFG(outputs = [Output(operation_tree)])
assert len(list(sfg.components)) == 7
assert len(list(sfg.operations)) == 4
assert sfg.input_count == 0
assert sfg.output_count == 1
def test_signals_construction(self, operation_tree):
sfg = SFG(output_signals = [Signal(source = operation_tree.output(0))])
assert len(list(sfg.components)) == 7
assert len(list(sfg.operations)) == 4
assert sfg.input_count == 0
assert sfg.output_count == 1
class TestEvaluation:
def test_evaluate_output(self, operation_tree):
sfg = SFG(outputs = [Output(operation_tree)])
assert sfg.evaluate_output(0, []) == 5
def test_evaluate_output_large(self, large_operation_tree):
sfg = SFG(outputs = [Output(large_operation_tree)])
assert sfg.evaluate_output(0, []) == 14
def test_evaluate_output_cycle(self, operation_graph_with_cycle):
sfg = SFG(outputs = [Output(operation_graph_with_cycle)])
with pytest.raises(Exception):
sfg.evaluate_output(0, [])
class TestDeepCopy:
def test_deep_copy_no_duplicates(self):
inp1 = Input("INP1")
inp2 = Input("INP2")
inp3 = Input("INP3")
add1 = Addition(inp1, inp2, "ADD1")
mul1 = Multiplication(add1, inp3, "MUL1")
out1 = Output(mul1, "OUT1")
mac_sfg = SFG(inputs = [inp1, inp2], outputs = [out1], name = "mac_sfg")
mac_sfg_new = mac_sfg()
assert mac_sfg.name == "mac_sfg"
assert mac_sfg_new.name == ""
for g_id, component in mac_sfg._components_by_id.items():
component_copy = mac_sfg_new.find_by_id(g_id)
assert component.name == component_copy.name
def test_deep_copy(self):
inp1 = Input("INP1")
inp2 = Input("INP2")
inp3 = Input("INP3")
add1 = Addition(None, None, "ADD1")
add2 = Addition(None, None, "ADD2")
mul1 = Multiplication(None, None, "MUL1")
out1 = Output(None, "OUT1")
add1.input(0).connect(inp1, "S1")
add1.input(1).connect(inp2, "S2")
add2.input(0).connect(add1, "S4")
add2.input(1).connect(inp3, "S3")
mul1.input(0).connect(add1, "S5")
mul1.input(1).connect(add2, "S6")
out1.input(0).connect(mul1, "S7")
mac_sfg = SFG(inputs = [inp1, inp2], outputs = [out1], id_number_offset = 100, name = "mac_sfg")
mac_sfg_new = mac_sfg(name = "mac_sfg2")
assert mac_sfg.name == "mac_sfg"
assert mac_sfg_new.name == "mac_sfg2"
assert mac_sfg.id_number_offset == 100
assert mac_sfg_new.id_number_offset == 100
for g_id, component in mac_sfg._components_by_id.items():
component_copy = mac_sfg_new.find_by_id(g_id)
assert component.name == component_copy.name
def test_deep_copy_with_new_sources(self):
inp1 = Input("INP1")
inp2 = Input("INP2")
inp3 = Input("INP3")
add1 = Addition(inp1, inp2, "ADD1")
mul1 = Multiplication(add1, inp3, "MUL1")
out1 = Output(mul1, "OUT1")
mac_sfg = SFG(inputs = [inp1, inp2], outputs = [out1], name = "mac_sfg")
a = Addition(Constant(3), Constant(5))
b = Constant(2)
mac_sfg_new = mac_sfg(a, b)
assert mac_sfg_new.input(0).signals[0].source.operation is a
assert mac_sfg_new.input(1).signals[0].source.operation is b
class TestComponents:
def test_advanced_components(self):
inp1 = Input("INP1")
inp2 = Input("INP2")
inp3 = Input("INP3")
add1 = Addition(None, None, "ADD1")
add2 = Addition(None, None, "ADD2")
mul1 = Multiplication(None, None, "MUL1")
out1 = Output(None, "OUT1")
add1.input(0).connect(inp1, "S1")
add1.input(1).connect(inp2, "S2")
add2.input(0).connect(add1, "S4")
add2.input(1).connect(inp3, "S3")
mul1.input(0).connect(add1, "S5")
mul1.input(1).connect(add2, "S6")
out1.input(0).connect(mul1, "S7")
mac_sfg = SFG(inputs = [inp1, inp2], outputs = [out1], name = "mac_sfg")
assert set([comp.name for comp in mac_sfg.components]) == {"INP1", "INP2", "INP3", "ADD1", "ADD2", "MUL1", "OUT1", "S1", "S2", "S3", "S4", "S5", "S6", "S7"}
class TestCoupling:
def test_couple_sfg_with_one_operation(self, large_operation_tree):
sfg = SFG(outputs=[Output(large_operation_tree)])
_sqrt = SquareRoot(name="Sqrt")
sfg = sfg.couple_operation(sfg.output(0), _sqrt.input(0))
assert "Sqrt" in sfg._components_by_name.keys()
def test_couple_sfg_with_operation_tree(self, large_operation_tree, large_operation_tree_one_input):
sfg = SFG(outputs=[Output(large_operation_tree)])
_sqrt = [comp for comp in large_operation_tree_one_input.traverse() if isinstance(comp, SquareRoot)][0]
sfg = sfg.couple_operation(sfg.output(0), _sqrt.input(0))
assert "Sqrt" in sfg._components_by_name.keys()
def test_couple_sfg_with_uneven_ports(self, large_operation_tree):
sfg = SFG(outputs=[Output(large_operation_tree)])
_addition = Addition()
sfg = sfg.couple_operation(sfg.output(0), _addition.input(0))
assert "Sqrt" in sfg._components_by_name.keys()
import pytest
import numpy as np
from b_asic import SFG, Output, Simulation
class TestSimulation:
def test_simulate_with_lambdas_as_input(self, sfg_two_inputs_two_outputs):
simulation = Simulation(sfg_two_inputs_two_outputs, [lambda n: n + 3, lambda n: 1 + n * 2], save_results = True)
output = simulation.run_for(101)
assert output[0] == 304
assert output[1] == 505
assert simulation.results[100]["0"] == 304
assert simulation.results[100]["1"] == 505
assert simulation.results[0]["in1"] == 3
assert simulation.results[0]["in2"] == 1
assert simulation.results[0]["add1"] == 4
assert simulation.results[0]["add2"] == 5
assert simulation.results[0]["0"] == 4
assert simulation.results[0]["1"] == 5
assert simulation.results[1]["in1"] == 4
assert simulation.results[1]["in2"] == 3
assert simulation.results[1]["add1"] == 7
assert simulation.results[1]["add2"] == 10
assert simulation.results[1]["0"] == 7
assert simulation.results[1]["1"] == 10
assert simulation.results[2]["in1"] == 5
assert simulation.results[2]["in2"] == 5
assert simulation.results[2]["add1"] == 10
assert simulation.results[2]["add2"] == 15
assert simulation.results[2]["0"] == 10
assert simulation.results[2]["1"] == 15
assert simulation.results[3]["in1"] == 6
assert simulation.results[3]["in2"] == 7
assert simulation.results[3]["add1"] == 13
assert simulation.results[3]["add2"] == 20
assert simulation.results[3]["0"] == 13
assert simulation.results[3]["1"] == 20
def test_simulate_with_numpy_arrays_as_input(self, sfg_two_inputs_two_outputs):
input0 = np.array([5, 9, 25, -5, 7])
input1 = np.array([7, 3, 3, 54, 2])
simulation = Simulation(sfg_two_inputs_two_outputs, [input0, input1])
simulation.save_results = True
output = simulation.run_for(5)
assert output[0] == 9
assert output[1] == 11
assert simulation.results[0]["in1"] == 5
assert simulation.results[0]["in2"] == 7
assert simulation.results[0]["add1"] == 12
assert simulation.results[0]["add2"] == 19
assert simulation.results[0]["0"] == 12
assert simulation.results[0]["1"] == 19
assert simulation.results[1]["in1"] == 9
assert simulation.results[1]["in2"] == 3
assert simulation.results[1]["add1"] == 12
assert simulation.results[1]["add2"] == 15
assert simulation.results[1]["0"] == 12
assert simulation.results[1]["1"] == 15
assert simulation.results[2]["in1"] == 25
assert simulation.results[2]["in2"] == 3
assert simulation.results[2]["add1"] == 28
assert simulation.results[2]["add2"] == 31
assert simulation.results[2]["0"] == 28
assert simulation.results[2]["1"] == 31
assert simulation.results[3]["in1"] == -5
assert simulation.results[3]["in2"] == 54
assert simulation.results[3]["add1"] == 49
assert simulation.results[3]["add2"] == 103
assert simulation.results[3]["0"] == 49
assert simulation.results[3]["1"] == 103
assert simulation.results[4]["0"] == 9
assert simulation.results[4]["1"] == 11
def test_simulate_with_numpy_array_overflow(self, sfg_two_inputs_two_outputs):
input0 = np.array([5, 9, 25, -5, 7])
input1 = np.array([7, 3, 3, 54, 2])
simulation = Simulation(sfg_two_inputs_two_outputs, [input0, input1])
simulation.run_for(5)
with pytest.raises(IndexError):
simulation.run_for(1)
def test_simulate_nested(self, sfg_nested):
input0 = np.array([5, 9])
input1 = np.array([7, 3])
simulation = Simulation(sfg_nested, [input0, input1])
output0 = simulation.run()
output1 = simulation.run()
assert output0[0] == 11405
assert output1[0] == 4221
def test_simulate_delay(self, sfg_delay):
simulation = Simulation(sfg_delay, save_results = True)
simulation.set_input(0, [5, -2, 25, -6, 7, 0])
simulation.run_for(6)
assert simulation.results[0]["0"] == 0
assert simulation.results[1]["0"] == 5
assert simulation.results[2]["0"] == -2
assert simulation.results[3]["0"] == 25
assert simulation.results[4]["0"] == -6
assert simulation.results[5]["0"] == 7
def test_simulate_accumulator(self, sfg_accumulator):
data_in = np.array([5, -2, 25, -6, 7, 0])
reset = np.array([0, 0, 0, 1, 0, 0])
simulation = Simulation(sfg_accumulator, [data_in, reset])
output0 = simulation.run()
output1 = simulation.run()
output2 = simulation.run()
output3 = simulation.run()
output4 = simulation.run()
output5 = simulation.run()
assert output0[0] == 0
assert output1[0] == 5
assert output2[0] == 3
assert output3[0] == 28
assert output4[0] == 0
assert output5[0] == 7
\ No newline at end of file