def test_gate_library(self):
gl = hal_py.gate_library("test_glib")
# Identifier
self.assertEqual(gl.get_name(), "test_glib")
# Includes
gl.add_include("test_include_0")
gl.add_include("test_include_1")
self.assertEqual(set(gl.get_includes()),
{"test_include_0", "test_include_1"})
# Gate Types
# -- create some gate types
gt_gnd = hal_py.gate_type("TEST_GND")
gt_gnd.add_output_pin("O")
_0 = hal_py.boolean_function(hal_py.value.ZERO)
gt_gnd.add_boolean_function("O", _0)
gt_vcc = hal_py.gate_type("TEST_VCC")
gt_vcc.add_output_pin("O")
_1 = hal_py.boolean_function(hal_py.value.ONE)
gt_vcc.add_boolean_function("O", _1)
# -- the actual tests
gl.add_gate_types(gt_gnd)
gl.add_gate_types(gt_vcc)
self.assertEqual(gl.get_gate_types(), {
"TEST_GND": gt_gnd,
"TEST_VCC": gt_vcc
})
self.assertEqual(gl.get_gnd_gate_types(), {"TEST_GND": gt_gnd})
self.assertEqual(gl.get_vcc_gate_types(), {"TEST_VCC": gt_vcc})
def test_gate_functions(self):
nl = self.create_empty_netlist()
test_gate = nl.create_gate(self.min_id, self.get_gate_type_by_name("INV", nl.gate_library), "test_gate")
self.assertIsNotNone(nl)
self.assertIsNotNone(test_gate)
# Connect nets to the gate
in_net = nl.create_net(self.min_id, "in_net")
out_net = nl.create_net(self.min_id+1, "out_net")
in_net.add_dst(test_gate, "I")
out_net.set_src(test_gate, "O")
# Boolean function
bf = hal_py.boolean_function("A&B")
test_gate.add_boolean_function("test_bf", bf)
self.assertEqual(test_gate.get_boolean_function("test_bf"), bf)
self.assertEqual(len(test_gate.get_boolean_functions()), 2) # (test_bf -> A&B) + (O -> !I)
# Get connected nets
self.assertEqual(test_gate.get_fan_in_net("I"), in_net)
self.assertEqual(len(test_gate.get_fan_in_nets()), 1)
self.assertEqual(test_gate.get_fan_out_net("O"), out_net)
self.assertEqual(len(test_gate.get_fan_out_nets()), 1)
# Location management (Note: small difference after write and read)
self.assertFalse(test_gate.has_location())
test_gate.set_location_x(12.0)
test_gate.set_location_y(34.0)
self.assertTrue(test_gate.has_location())
self.assertEqual(test_gate.get_location_x(), 12.0)
self.assertEqual(test_gate.get_location_y(), 34.0)
test_gate.set_location((56.0, 78.0))
self.assertEqual(test_gate.get_location(), (56.0, 78.0))
# Identifier
self.assertEqual(test_gate.get_id(), self.min_id)
test_gate.set_name("new_name")
self.assertEqual(test_gate.get_name(), "new_name")
self.assertEqual(test_gate.get_type(), self.get_gate_type_by_name("INV", nl.gate_library))
# GND/VCC Marking
self.assertFalse(test_gate.is_gnd_gate())
self.assertFalse(test_gate.is_vcc_gate())
test_gate.mark_gnd_gate()
test_gate.mark_vcc_gate()
self.assertTrue(test_gate.is_gnd_gate())
self.assertTrue(test_gate.is_vcc_gate())
test_gate.unmark_gnd_gate()
test_gate.unmark_vcc_gate()
self.assertFalse(test_gate.is_gnd_gate())
self.assertFalse(test_gate.is_vcc_gate())
# Pin Information
self.assertEqual(test_gate.get_input_pins(), ["I"])
self.assertEqual(test_gate.get_output_pins(), ["O"])
# Context Information
self.assertEqual(test_gate.get_module(), nl.get_top_module())
self.assertEqual(test_gate.get_netlist(), nl)
def test_boolean_function(self):
a = hal_py.boolean_function("A")
b = hal_py.boolean_function("B")
c = hal_py.boolean_function("C")
_1 = hal_py.boolean_function(hal_py.value.ONE)
# Get Variables
self.assertEqual((a | b).get_variables(), {"A", "B"})
# Get Truth Table
self.assertEqual((a & b).get_truth_table(["A", "B"]), [
hal_py.value.ZERO, hal_py.value.ZERO, hal_py.value.ZERO,
hal_py.value.ONE
])
# From String
self.assertTrue(
self.are_equal(
hal_py.boolean_function.from_string("(A&(!B)) | ((!A)&B)",
["A", "B"]),
hal_py.boolean_function.from_string("A ^ B", ["A", "B"])))
# Constants
self.assertTrue((a ^ a).is_constant_zero())
self.assertFalse((a & a).is_constant_zero())
self.assertTrue((a | _1).is_constant_one())
self.assertFalse((a & a).is_constant_one())
# Evaluate
bf_input = {"A": hal_py.value.ONE, "B": hal_py.value.ZERO}
self.assertEqual((a | b)(bf_input), hal_py.value.ONE)
self.assertEqual((a & b)(bf_input), hal_py.value.ZERO)
# DNF/Optimize
self.assertFalse(((a | b) & c).is_dnf())
self.assertTrue(((a & b) | (a & c)).is_dnf())
self.assertTrue(((a | b) & c).to_dnf().is_dnf())
self.assertTrue(self.are_equal(((a | b) & c).to_dnf(), ((a | b) & c)))
self.assertTrue(
self.are_equal(((a | b | b | b) & c).optimize(), ((a | b) & c)))
# Substitute
self.assertTrue(self.are_equal((a | b).substitute("B", "C"), (a | c)))
self.assertTrue(
self.are_equal((a | b).substitute("B", (b | c)), (a | b | c)))
# Is Empty
self.assertTrue(hal_py.boolean_function().is_empty())
self.assertFalse((a | b).is_empty())
# Assign Operators
# Note: Copy constructor?
tmp_bf = hal_py.boolean_function("A")
tmp_bf &= b
tmp_bf |= c
tmp_bf ^= _1
self.assertTrue(self.are_equal(tmp_bf, ((a & b) | c) ^ _1))
# Comparison Operators
self.assertTrue((a & b) == (a & b))
self.assertTrue((a & b) != (a | b))