I have tested the methods in determining nodes and branches. What is left is the main method that calls these methods. The code can be found on:
https://bitbucket.org/shivkiyer/ppe_simulator/src/testing/
https://sourceforge.net/p/pythonpowerelec/code/ci/testing/tree/
And if you would like a full length course on simulating power electronics using Python, check out:
https://www.udemy.com/course/simulating-power-electronic-circuits-using-python/
Here is the code for the tests in command line and web app:
The tests work ok except for a few discrepancies. There is a case in the branch_advance method where an invalid jump does not throw an exception or even return an indication of an error, but rather returns the correct element. For example, while advancing to the right on a branch, the method checks if there is an element to the right of the current element and if that element has already been added to the temporary branch. Legally the advance should occur if the element on the right exists. There could be no jump executed in which case it is simply an element that exists to the right of the last element in the temporary branch. If a jump is executed, the jump direction should be to the right.
However, if the jump executed has a direction of up, down or right, there will be no exception and the element to the right of the current element will be returned. The only time an exception will be generated will be when the jump direction executed will be to the left. The reason this did not cause a major issue was because the methods related to the jump are fairly ok and do not produce wrong jump directions. But in principle, the code is wrong.
The check should be, according to the jump direction, is there an element in that direction? If there is no jump, we could follow some sequence of directions while searching for the next element.
Now that the methods have been tested, the next issue is to test the outer method determine_nodes_branches which calls these methods. At this point, the only was to test this outer method is manually by inputting different circuits. And that doesn't seem like a good way to test as the testing is not at all automatic and how many circuits can I come up with?
This brings me to the next crossroad. I need an automatic circuit builder. This is because things will get more complicated at the next step where I will have to test loops and loop manipulations. I need to generate loops automatically while also introducing errors and bugs in the loops automatically. So, the circuit builder will need to generate circuit topologies only while testing at every stage. For example, I need to start with a simple two node, three branch, two loop circuit and verify that that is generated. Then continuously add nodes and branches automatically to form new loops. The structure should not matter as long as there are a few random jump labels inserted every now and then.
This circuit builder seems very interesting and challenging. The next few blog posts will be dedicated to this.
https://bitbucket.org/shivkiyer/ppe_simulator/src/testing/
https://sourceforge.net/p/pythonpowerelec/code/ci/testing/tree/
And if you would like a full length course on simulating power electronics using Python, check out:
https://www.udemy.com/course/simulating-power-electronic-circuits-using-python/
Here is the code for the tests in command line and web app:
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| class TestNodesBranches: | |
| """ | |
| This class tests functions related to processing nodes and | |
| branches of a circuit. | |
| """ | |
| def test_node_checking(self): | |
| """ | |
| node_checking function determines if an element is a node by it's neighbors. | |
| params - circuit matrix | |
| params - sheet, row, column of the element. | |
| params - number of rows and columns of that sheet. | |
| result/modifies - list of nodes to which the element is added if it is a node. | |
| """ | |
| from network_reader import node_checking | |
| print() | |
| print('*'*80) | |
| print('Testing the node_checking function') | |
| print() | |
| test_matrix = [ | |
| [ | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['dyxcsdc', 'wire', 'wire', 'Resistor', 'jump1'], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ], | |
| ] | |
| test_list = [] | |
| no_rows = len(test_matrix[0]) | |
| no_cols = len(test_matrix[0][0]) | |
| no_of_nodes = 0 | |
| # The center wire is a legal node | |
| node_checking(test_matrix, test_list, 0, 2, 2, no_rows, no_cols) | |
| assert no_of_nodes != len(test_list) | |
| assert test_list[-1] == [0, 2, 2] | |
| no_of_nodes = len(test_list) | |
| # The element below that is not a node | |
| node_checking(test_matrix, test_list, 0, 1, 2, no_rows, no_cols) | |
| assert no_of_nodes == len(test_list) | |
| # The element in the first row and second column is not a node | |
| node_checking(test_matrix, test_list, 0, 0, 2, no_rows, no_cols) | |
| assert no_of_nodes == len(test_list) | |
| # Adding a dummy wire in element in first row, second column | |
| test_matrix[0][0][1] = 'wire' | |
| # STill not a node | |
| node_checking(test_matrix, test_list, 0, 0, 2, no_rows, no_cols) | |
| assert no_of_nodes == len(test_list) | |
| # Adding another dummy element to right of it. | |
| test_matrix[0][0][3] = 'wire' | |
| # Now is a node | |
| node_checking(test_matrix, test_list, 0, 0, 2, no_rows, no_cols) | |
| assert no_of_nodes != len(test_list) | |
| assert test_list[-1] == [0, 0, 2] | |
| no_of_nodes = len(test_list) | |
| # Corner element should never be a node | |
| node_checking(test_matrix, test_list, 0, 0, 0, no_rows, no_cols) | |
| assert no_of_nodes == len(test_list) | |
| # Resetting the element in first row, second column | |
| test_matrix[0][0][1] = '' | |
| # Element in second row, second column should not be a node | |
| node_checking(test_matrix, test_list, 0, 1, 1, no_rows, no_cols) | |
| assert no_of_nodes == len(test_list) | |
| # Placing a component in the element | |
| test_matrix[0][0][1] = 'wire' | |
| # Now the element in second row, second column is a node | |
| node_checking(test_matrix, test_list, 0, 1, 1, no_rows, no_cols) | |
| assert no_of_nodes != len(test_list) | |
| assert test_list[-1] == [0, 1, 1] | |
| no_of_nodes = len(test_list) | |
| # Confirming that a corner element should never be a node | |
| test_matrix[0][0][1] = 'wire' | |
| test_matrix[0][1][0] = 'wire' | |
| node_checking(test_matrix, test_list, 0, 0, 0, no_rows, no_cols) | |
| assert no_of_nodes == len(test_list) | |
| # Element in first row, third column should not a node | |
| node_checking(test_matrix, test_list, 0, 2, 0, no_rows, no_cols) | |
| assert no_of_nodes == len(test_list) | |
| # Adding a component to the right of it. | |
| test_matrix[0][3][0] = 'wire' | |
| # Now is a node | |
| node_checking(test_matrix, test_list, 0, 2, 0, no_rows, no_cols) | |
| assert no_of_nodes != len(test_list) | |
| assert test_list[-1] == [0, 2, 0] | |
| no_of_nodes = len(test_list) | |
| # Element in 4th row and 2nd column is a node | |
| # This element is null. This method does not check for component. | |
| # The parent method performs the check before calling this function. | |
| node_checking(test_matrix, test_list, 0, 3, 1, no_rows, no_cols) | |
| assert no_of_nodes != len(test_list) | |
| assert test_list[-1] == [0, 3, 1] | |
| no_of_nodes = len(test_list) | |
| # Element in 4th row and 3rd column is not a node. | |
| node_checking(test_matrix, test_list, 0, 3, 2, no_rows, no_cols) | |
| assert no_of_nodes == len(test_list) | |
| # Element in last row, 3rd column is not a node | |
| node_checking(test_matrix, test_list, 0, 5, 2, no_rows, no_cols) | |
| assert no_of_nodes == len(test_list) | |
| # Adding an element to the left | |
| test_matrix[0][5][1] = 'wire' | |
| # Still not a node | |
| node_checking(test_matrix, test_list, 0, 5, 2, no_rows, no_cols) | |
| assert no_of_nodes == len(test_list) | |
| # Adding an element to the right | |
| test_matrix[0][5][3] = 'wire' | |
| # Now a node | |
| node_checking(test_matrix, test_list, 0, 5, 2, no_rows, no_cols) | |
| assert no_of_nodes != len(test_list) | |
| assert test_list[-1] == [0, 5, 2] | |
| no_of_nodes = len(test_list) | |
| # element in last column, 3rd row is not a node | |
| node_checking(test_matrix, test_list, 0, 2, 4, no_rows, no_cols) | |
| assert no_of_nodes == len(test_list) | |
| # Setting element below it to be a component | |
| test_matrix[0][1][4] = 'wire' | |
| # Still not a node | |
| node_checking(test_matrix, test_list, 0, 2, 4, no_rows, no_cols) | |
| assert no_of_nodes == len(test_list) | |
| # Setting element above it to be a component | |
| test_matrix[0][3][4] = 'wire' | |
| # Now a node | |
| node_checking(test_matrix, test_list, 0, 2, 4, no_rows, no_cols) | |
| assert no_of_nodes != len(test_list) | |
| assert test_list[-1] == [0, 2, 4] | |
| no_of_nodes = len(test_list) | |
| print() | |
| return | |
| def test_jump_move(self): | |
| """ | |
| jump_move - function to return the next cell after encountering a jump | |
| params - circuit matrix | |
| params - dictionary of jumps with pairs of jumps, each jump - [[sheet, row, col], direction] | |
| params - sheet, row, column of originating jump | |
| params - position of destination jump in jump dictionary value list with the jump label as key. | |
| returns - list - [direction, co-ordinates of destination cell after jump] | |
| """ | |
| from network_reader import jump_move | |
| print() | |
| print('*'*80) | |
| print('Testing the jump_move function') | |
| print() | |
| test_matrix = [ | |
| [ | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['dyxcsdc', 'wire', 'wire', 'Resistor', 'jump1'], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ], | |
| ] | |
| # First is a jump label that exists. Second is fictitious | |
| temp_jump_matrix = { | |
| 'jump1': [[[0, 2, 4], 'left'], [[0, 2, 1], 'left']] | |
| } | |
| # Start jump is ok. | |
| # Destination is not a jump. No exception raises. Next cell is an element. | |
| result = jump_move(test_matrix, temp_jump_matrix, [0, 2, 4], 1) | |
| assert result == ['left', 0, 2, 0] | |
| # Start is not a jump - so exception raised as element is checked with jump dictionary. | |
| with pytest.raises(Exception): | |
| jump_move(test_matrix, temp_jump_matrix, [0, 2, 2], 1) | |
| # Also ok. | |
| temp_jump_matrix['jump1'][1][1] = 'right' | |
| result = jump_move(test_matrix, temp_jump_matrix, [0, 2, 4], 1) | |
| assert result == ['right', 0, 2, 2] | |
| # Destination element is not a component. | |
| temp_jump_matrix['jump1'][1][1] = 'up' | |
| result = jump_move(test_matrix, temp_jump_matrix, [0, 2, 4], 1) | |
| assert result == ['up', 0, 1, 1] | |
| # Destination element is not a component. | |
| temp_jump_matrix['jump1'][1][1] = 'down' | |
| result = jump_move(test_matrix, temp_jump_matrix, [0, 2, 4], 1) | |
| assert result == ['down', 0, 3, 1] | |
| print() | |
| return | |
| def test_branch_jump(self): | |
| """ | |
| branch_jump takes an element, checks if it is a jump and | |
| returns the element next to the corresponding jump if so | |
| or else return back the element. | |
| params - circuit matrix | |
| params - jump matrix dictionary | |
| params - current element | |
| returns - list [direction, sheet, row, column] | |
| """ | |
| from network_reader import branch_jump | |
| print() | |
| print('*'*80) | |
| print('Testing the branch_jump function') | |
| print() | |
| test_matrix = [ | |
| [ | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['dyxcsdc', 'wire', 'wire', 'Resistor', 'jump1'], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ], | |
| ] | |
| # First is a jump label that exists. Second is fictitious | |
| temp_jump_matrix = { | |
| 'jump1': [[[0, 2, 4], 'left'], [[0, 2, 1], 'left']] | |
| } | |
| # If the element is not a jump, jump executed is null (not executed) | |
| # and same element is returned. | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 3]) | |
| assert result == ['', 0, 2, 3] | |
| # If element is jump, element next to corresponding jump is returned. | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| assert result == ['left', 0, 2, 0] | |
| # Also ok. | |
| temp_jump_matrix['jump1'][1][1] = 'right' | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| assert result == ['right', 0, 2, 2] | |
| # Element does not exist. Error checking does not happen at this stage. | |
| temp_jump_matrix['jump1'][1][1] = 'up' | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| assert result == ['up', 0, 1, 1] | |
| # Element does not exist. Error checking does not happen at this stage. | |
| temp_jump_matrix['jump1'][1][1] = 'down' | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| assert result == ['down', 0, 3, 1] | |
| # Flipping the jump labels to check if method still maps jump labels. | |
| temp_jump_matrix = { | |
| 'jump1': [ [[0, 2, 1], 'left'], [[0, 2, 4], 'left'] ] | |
| } | |
| # No jump, same behaviour. | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 3]) | |
| assert result == ['', 0, 2, 3] | |
| # Again no jump. | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 1]) | |
| assert result == ['', 0, 2, 1] | |
| # Legal jump | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| assert result == ['left', 0, 2, 0] | |
| # Legal jump | |
| temp_jump_matrix['jump1'][0][1] = 'right' | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| assert result == ['right', 0, 2, 2] | |
| # Element does not exist, no error. | |
| temp_jump_matrix['jump1'][0][1] = 'up' | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| assert result == ['up', 0, 1, 1] | |
| # Element does not exist, no error. | |
| temp_jump_matrix['jump1'][0][1] = 'down' | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| assert result == ['down', 0, 3, 1] | |
| print() | |
| return | |
| def test_branch_advance(self): | |
| """ | |
| branch_advance takes an element and returns the next element | |
| to extend the branch checking whether the element already is | |
| in the temporary branch or if a jump is executed. | |
| params - circuit matrix | |
| params - temporary branch | |
| params - current element | |
| params - jump executed | |
| returns - [jump, next element] | |
| """ | |
| from network_reader import branch_advance | |
| print() | |
| print('*'*80) | |
| print('Testing the branch_advance function') | |
| print() | |
| test_matrix = [ | |
| [ | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['dyxcsdc', 'wire', 'wire', 'Resistor', 'jump1'], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ], | |
| ] | |
| test_branch_iter = [ [0, 2, 2] ] | |
| # Since starting with a node that has elements on all 4 sides, | |
| # First check is for an element to the left if no jump is specified. | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 2], '') | |
| assert result == ['', 0, 2, 1] | |
| # Since left element is in temp branch, next check is to the top | |
| test_branch_iter = [ [0, 2, 1], [0, 2, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 2], '') | |
| assert result == ['', 0, 1, 2] | |
| # Since top element is in temp branch, next check is to the right | |
| test_branch_iter = [ [0, 2, 1], [0, 2, 2], [0, 1, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 2], '') | |
| assert result == ['', 0, 2, 3] | |
| # Since right element is in temp branch, next check is to the bottom | |
| test_branch_iter = [ [0, 2, 1], [0, 2, 2], [0, 1, 2], [0, 2, 3] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 2], '') | |
| assert result == ['', 0, 3, 2] | |
| # Since all adj elements are in temp branch, fails returning back node. | |
| test_branch_iter = [ [0, 2, 1], [0, 2, 2], [0, 1, 2], [0, 2, 3], [0, 3, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 2], '') | |
| assert result == ['', 0, 2, 2] | |
| # Extending branch to the right from node. | |
| test_branch_iter = [ [0, 2, 2], [0, 2, 3] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 3], '') | |
| assert result == ['', 0, 2, 4] | |
| # If right element is included, advance fails returning current element | |
| test_branch_iter = [ [0, 2, 2], [0, 2, 3], [0, 2, 4] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 3], '') | |
| assert result == ['', 0, 2, 3] | |
| # Executing legal right jump to move right | |
| test_branch_iter = [ [0, 2, 2], [0, 2, 3] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 3], 'right') | |
| assert result == ['', 0, 2, 4] | |
| # Invalid down jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 3], 'down') | |
| assert result == ['', 0, 2, 4] | |
| # Invalid up jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 3], 'up') | |
| assert result == ['', 0, 2, 4] | |
| # Illegal left jump as left element is in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 3], 'left') | |
| assert result == ['left', 0, 2, 3] | |
| # Moving left from the node | |
| test_branch_iter = [ [0, 2, 2], [0, 2, 1] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 1], '') | |
| assert result == ['', 0, 2, 0] | |
| # If left element is included, advance fails returning current element | |
| test_branch_iter = [ [0, 2, 2], [0, 2, 1], [0, 2, 0] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 1], '') | |
| assert result == ['', 0, 2, 1] | |
| # Executing legal left jump to move left | |
| test_branch_iter = [ [0, 2, 2], [0, 2, 1] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 1], 'left') | |
| assert result == ['', 0, 2, 0] | |
| # Invalid down jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 1], 'down') | |
| assert result == ['', 0, 2, 0] | |
| # Invalid up jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 1], 'up') | |
| assert result == ['', 0, 2, 0] | |
| # Illegal right jump as left element is in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 1], 'right') | |
| assert result == ['right', 0, 2, 1] | |
| # Moving up from the node | |
| test_branch_iter = [ [0, 2, 2], [0, 1, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 1, 2], '') | |
| assert result == ['', 0, 0, 2] | |
| # If up element is included, advance fails returning current element | |
| test_branch_iter = [ [0, 2, 2], [0, 1, 2], [0, 0, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 1, 2], '') | |
| assert result == ['', 0, 1, 2] | |
| # Executing legal up jump to move left | |
| test_branch_iter = [ [0, 2, 2], [0, 1, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 1, 2], 'up') | |
| assert result == ['', 0, 0, 2] | |
| # Invalid left jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 1, 2], 'left') | |
| assert result == ['', 0, 0, 2] | |
| # Invalid right jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 1, 2], 'right') | |
| assert result == ['', 0, 0, 2] | |
| # Illegal right jump as left element is in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 1, 2], 'down') | |
| assert result == ['down', 0, 1, 2] | |
| # Moving down from the node | |
| test_branch_iter = [ [0, 2, 2], [0, 3, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 3, 2], '') | |
| assert result == ['', 0, 4, 2] | |
| # If down element is included, advance fails returning current element | |
| test_branch_iter = [ [0, 2, 2], [0, 3, 2], [0, 4, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 3, 2], '') | |
| assert result == ['', 0, 3, 2] | |
| # Executing legal down jump to move left | |
| test_branch_iter = [ [0, 2, 2], [0, 3, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 3, 2], 'down') | |
| assert result == ['', 0, 4, 2] | |
| # Invalid left jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 3, 2], 'left') | |
| assert result == ['', 0, 4, 2] | |
| # Invalid right jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 3, 2], 'right') | |
| assert result == ['', 0, 4, 2] | |
| # Illegal up jump as left element is in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 3, 2], 'up') | |
| assert result == ['up', 0, 3, 2] | |
| print() | |
| return | |
| class TestNodesBranches(TestCase): | |
| """ | |
| This class tests functions related to processing nodes and | |
| branches of a circuit. | |
| """ | |
| def test_node_checking(self): | |
| """ | |
| node_checking function determines if an element is a node by it's neighbors. | |
| params - circuit matrix | |
| params - sheet, row, column of the element. | |
| params - number of rows and columns of that sheet. | |
| result/modifies - list of nodes to which the element is added if it is a node. | |
| """ | |
| from simulations.network_reader import node_checking | |
| print() | |
| print('*'*80) | |
| print('Testing the node_checking function') | |
| print() | |
| test_matrix = [ | |
| [ | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['dyxcsdc', 'wire', 'wire', 'Resistor', 'jump1'], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ], | |
| ] | |
| test_list = [] | |
| no_rows = len(test_matrix[0]) | |
| no_cols = len(test_matrix[0][0]) | |
| no_of_nodes = 0 | |
| # The center wire is a legal node | |
| node_checking(test_matrix, test_list, 0, 2, 2, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes != len(test_list)) | |
| self.assertTrue(test_list[-1] == [0, 2, 2]) | |
| no_of_nodes = len(test_list) | |
| # The element below that is not a node | |
| node_checking(test_matrix, test_list, 0, 1, 2, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes == len(test_list)) | |
| # The element in the first row and second column is not a node | |
| node_checking(test_matrix, test_list, 0, 0, 2, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes == len(test_list)) | |
| # Adding a dummy wire in element in first row, second column | |
| test_matrix[0][0][1] = 'wire' | |
| # STill not a node | |
| node_checking(test_matrix, test_list, 0, 0, 2, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes == len(test_list)) | |
| # Adding another dummy element to right of it. | |
| test_matrix[0][0][3] = 'wire' | |
| # Now is a node | |
| node_checking(test_matrix, test_list, 0, 0, 2, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes != len(test_list)) | |
| self.assertTrue(test_list[-1] == [0, 0, 2]) | |
| no_of_nodes = len(test_list) | |
| # Corner element should never be a node | |
| node_checking(test_matrix, test_list, 0, 0, 0, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes == len(test_list)) | |
| # Resetting the element in first row, second column | |
| test_matrix[0][0][1] = '' | |
| # Element in second row, second column should not be a node | |
| node_checking(test_matrix, test_list, 0, 1, 1, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes == len(test_list)) | |
| # Placing a component in the element | |
| test_matrix[0][0][1] = 'wire' | |
| # Now the element in second row, second column is a node | |
| node_checking(test_matrix, test_list, 0, 1, 1, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes != len(test_list)) | |
| self.assertTrue(test_list[-1] == [0, 1, 1]) | |
| no_of_nodes = len(test_list) | |
| # Confirming that a corner element should never be a node | |
| test_matrix[0][0][1] = 'wire' | |
| test_matrix[0][1][0] = 'wire' | |
| node_checking(test_matrix, test_list, 0, 0, 0, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes == len(test_list)) | |
| # Element in first row, third column should not a node | |
| node_checking(test_matrix, test_list, 0, 2, 0, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes == len(test_list)) | |
| # Adding a component to the right of it. | |
| test_matrix[0][3][0] = 'wire' | |
| # Now is a node | |
| node_checking(test_matrix, test_list, 0, 2, 0, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes != len(test_list)) | |
| self.assertTrue(test_list[-1] == [0, 2, 0]) | |
| no_of_nodes = len(test_list) | |
| # Element in 4th row and 2nd column is a node | |
| # This element is null. This method does not check for component. | |
| # The parent method performs the check before calling this function. | |
| node_checking(test_matrix, test_list, 0, 3, 1, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes != len(test_list)) | |
| self.assertTrue(test_list[-1] == [0, 3, 1]) | |
| no_of_nodes = len(test_list) | |
| # Element in 4th row and 3rd column is not a node. | |
| node_checking(test_matrix, test_list, 0, 3, 2, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes == len(test_list)) | |
| # Element in last row, 3rd column is not a node | |
| node_checking(test_matrix, test_list, 0, 5, 2, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes == len(test_list)) | |
| # Adding an element to the left | |
| test_matrix[0][5][1] = 'wire' | |
| # Still not a node | |
| node_checking(test_matrix, test_list, 0, 5, 2, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes == len(test_list)) | |
| # Adding an element to the right | |
| test_matrix[0][5][3] = 'wire' | |
| # Now a node | |
| node_checking(test_matrix, test_list, 0, 5, 2, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes != len(test_list)) | |
| self.assertTrue(test_list[-1] == [0, 5, 2]) | |
| no_of_nodes = len(test_list) | |
| # element in last column, 3rd row is not a node | |
| node_checking(test_matrix, test_list, 0, 2, 4, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes == len(test_list)) | |
| # Setting element below it to be a component | |
| test_matrix[0][1][4] = 'wire' | |
| # Still not a node | |
| node_checking(test_matrix, test_list, 0, 2, 4, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes == len(test_list)) | |
| # Setting element above it to be a component | |
| test_matrix[0][3][4] = 'wire' | |
| # Now a node | |
| node_checking(test_matrix, test_list, 0, 2, 4, no_rows, no_cols) | |
| self.assertTrue(no_of_nodes != len(test_list)) | |
| self.assertTrue(test_list[-1] == [0, 2, 4]) | |
| no_of_nodes = len(test_list) | |
| print() | |
| return | |
| def test_jump_move(self): | |
| """ | |
| jump_move - function to return the next cell after encountering a jump | |
| params - circuit matrix | |
| params - dictionary of jumps with pairs of jumps, each jump - [[sheet, row, col], direction] | |
| params - sheet, row, column of originating jump | |
| params - position of destination jump in jump dictionary value list with the jump label as key. | |
| results - test_matrix, temp_jump_matrix, [0, 2, 2], 1 | |
| """ | |
| from simulations.network_reader import jump_move | |
| print() | |
| print('*'*80) | |
| print('Testing the jump_move function') | |
| print() | |
| test_matrix = [ | |
| [ | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['dyxcsdc', 'wire', 'wire', 'Resistor', 'jump1'], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ], | |
| ] | |
| temp_jump_matrix = { | |
| 'jump1': [[[0, 2, 4], 'left'], [[0, 2, 1], 'left']] | |
| } | |
| # First is a jump label that exists. Second is fictitious | |
| result = jump_move(test_matrix, temp_jump_matrix, [0, 2, 4], 1) | |
| self.assertTrue(result == ['left', 0, 2, 0]) | |
| # Start jump is ok. | |
| # Destination is not a jump. No exception raises. Next cell is an element. | |
| self.assertRaises(Exception, jump_move, test_matrix, temp_jump_matrix, [0, 2, 2], 1) | |
| # Also ok. | |
| temp_jump_matrix['jump1'][1][1] = 'right' | |
| result = jump_move(test_matrix, temp_jump_matrix, [0, 2, 4], 1) | |
| self.assertTrue(result == ['right', 0, 2, 2]) | |
| # Destination element is not a component. | |
| temp_jump_matrix['jump1'][1][1] = 'up' | |
| result = jump_move(test_matrix, temp_jump_matrix, [0, 2, 4], 1) | |
| self.assertTrue(result == ['up', 0, 1, 1]) | |
| # Destination element is not a component. | |
| temp_jump_matrix['jump1'][1][1] = 'down' | |
| result = jump_move(test_matrix, temp_jump_matrix, [0, 2, 4], 1) | |
| self.assertTrue(result == ['down', 0, 3, 1]) | |
| print() | |
| return | |
| def test_branch_jump(self): | |
| """ | |
| branch_jump takes an element, checks if it is a jump and | |
| returns the element next to the corresponding jump if so | |
| or else return back the element. | |
| params - circuit matrix | |
| params - jump matrix dictionary | |
| params - current element | |
| returns - list [direction, sheet, row, column] | |
| """ | |
| from simulations.network_reader import branch_jump | |
| print() | |
| print('*'*80) | |
| print('Testing the branch_jump function') | |
| print() | |
| test_matrix = [ | |
| [ | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['dyxcsdc', 'wire', 'wire', 'Resistor', 'jump1'], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ], | |
| ] | |
| # First is a jump label that exists. Second is fictitious | |
| temp_jump_matrix = { | |
| 'jump1': [[[0, 2, 4], 'left'], [[0, 2, 1], 'left']] | |
| } | |
| # If the element is not a jump, jump executed is null (not executed) | |
| # and same element is returned. | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 3]) | |
| self.assertTrue(result == ['', 0, 2, 3]) | |
| # If element is jump, element next to corresponding jump is returned. | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| self.assertTrue(result == ['left', 0, 2, 0]) | |
| # Also ok. | |
| temp_jump_matrix['jump1'][1][1] = 'right' | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| self.assertTrue(result == ['right', 0, 2, 2]) | |
| # Element does not exist. Error checking does not happen at this stage. | |
| temp_jump_matrix['jump1'][1][1] = 'up' | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| self.assertTrue(result == ['up', 0, 1, 1]) | |
| # Element does not exist. Error checking does not happen at this stage. | |
| temp_jump_matrix['jump1'][1][1] = 'down' | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| self.assertTrue(result == ['down', 0, 3, 1]) | |
| # Flipping the jump labels to check if method still maps jump labels. | |
| temp_jump_matrix = { | |
| 'jump1': [ [[0, 2, 1], 'left'], [[0, 2, 4], 'left'] ] | |
| } | |
| # No jump, same behaviour. | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 3]) | |
| self.assertTrue(result == ['', 0, 2, 3]) | |
| # Again no jump. | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 1]) | |
| self.assertTrue(result == ['', 0, 2, 1]) | |
| # Legal jump | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| self.assertTrue(result == ['left', 0, 2, 0]) | |
| # Legal jump | |
| temp_jump_matrix['jump1'][0][1] = 'right' | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| self.assertTrue(result == ['right', 0, 2, 2]) | |
| # Element does not exist, no error. | |
| temp_jump_matrix['jump1'][0][1] = 'up' | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| self.assertTrue(result == ['up', 0, 1, 1]) | |
| # Element does not exist, no error. | |
| temp_jump_matrix['jump1'][0][1] = 'down' | |
| result = branch_jump(test_matrix, temp_jump_matrix, [0, 2, 4]) | |
| self.assertTrue(result == ['down', 0, 3, 1]) | |
| print() | |
| return | |
| def test_branch_advance(self): | |
| """ | |
| branch_advance takes an element and returns the next element | |
| to extend the branch checking whether the element already is | |
| in the temporary branch or if a jump is executed. | |
| params - circuit matrix | |
| params - temporary branch | |
| params - current element | |
| params - jump executed | |
| returns - [jump, next element] | |
| """ | |
| from simulations.network_reader import branch_advance | |
| print() | |
| print('*'*80) | |
| print('Testing the branch_advance function') | |
| print() | |
| test_matrix = [ | |
| [ | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['dyxcsdc', 'wire', 'wire', 'Resistor', 'jump1'], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ['', '', 'wire', '', ''], | |
| ], | |
| ] | |
| test_branch_iter = [ [0, 2, 2] ] | |
| # Since starting with a node that has elements on all 4 sides, | |
| # First check is for an element to the left if no jump is specified. | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 2], '') | |
| self.assertTrue(result == ['', 0, 2, 1]) | |
| # Since left element is in temp branch, next check is to the top | |
| test_branch_iter = [ [0, 2, 1], [0, 2, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 2], '') | |
| self.assertTrue(result == ['', 0, 1, 2]) | |
| # Since top element is in temp branch, next check is to the right | |
| test_branch_iter = [ [0, 2, 1], [0, 2, 2], [0, 1, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 2], '') | |
| self.assertTrue(result == ['', 0, 2, 3]) | |
| # Since right element is in temp branch, next check is to the bottom | |
| test_branch_iter = [ [0, 2, 1], [0, 2, 2], [0, 1, 2], [0, 2, 3] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 2], '') | |
| self.assertTrue(result == ['', 0, 3, 2]) | |
| # Since all adj elements are in temp branch, fails returning back node. | |
| test_branch_iter = [ [0, 2, 1], [0, 2, 2], [0, 1, 2], [0, 2, 3], [0, 3, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 2], '') | |
| self.assertTrue(result == ['', 0, 2, 2]) | |
| # Extending branch to the right from node. | |
| test_branch_iter = [ [0, 2, 2], [0, 2, 3] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 3], '') | |
| self.assertTrue(result == ['', 0, 2, 4]) | |
| # If right element is included, advance fails returning current element | |
| test_branch_iter = [ [0, 2, 2], [0, 2, 3], [0, 2, 4] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 3], '') | |
| self.assertTrue(result == ['', 0, 2, 3]) | |
| # Executing legal right jump to move right | |
| test_branch_iter = [ [0, 2, 2], [0, 2, 3] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 3], 'right') | |
| self.assertTrue(result == ['', 0, 2, 4]) | |
| # Invalid down jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 3], 'down') | |
| self.assertTrue(result == ['', 0, 2, 4]) | |
| # Invalid up jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 3], 'up') | |
| self.assertTrue(result == ['', 0, 2, 4]) | |
| # Illegal left jump as left element is in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 3], 'left') | |
| self.assertTrue(result == ['left', 0, 2, 3]) | |
| # Moving left from the node | |
| test_branch_iter = [ [0, 2, 2], [0, 2, 1] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 1], '') | |
| self.assertTrue(result == ['', 0, 2, 0]) | |
| # If left element is included, advance fails returning current element | |
| test_branch_iter = [ [0, 2, 2], [0, 2, 1], [0, 2, 0] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 1], '') | |
| self.assertTrue(result == ['', 0, 2, 1]) | |
| # Executing legal left jump to move left | |
| test_branch_iter = [ [0, 2, 2], [0, 2, 1] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 1], 'left') | |
| self.assertTrue(result == ['', 0, 2, 0]) | |
| # Invalid down jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 1], 'down') | |
| self.assertTrue(result == ['', 0, 2, 0]) | |
| # Invalid up jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 1], 'up') | |
| self.assertTrue(result == ['', 0, 2, 0]) | |
| # Illegal right jump as left element is in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 2, 1], 'right') | |
| self.assertTrue(result == ['right', 0, 2, 1]) | |
| # Moving up from the node | |
| test_branch_iter = [ [0, 2, 2], [0, 1, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 1, 2], '') | |
| self.assertTrue(result == ['', 0, 0, 2]) | |
| # If up element is included, advance fails returning current element | |
| test_branch_iter = [ [0, 2, 2], [0, 1, 2], [0, 0, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 1, 2], '') | |
| self.assertTrue(result == ['', 0, 1, 2]) | |
| # Executing legal up jump to move left | |
| test_branch_iter = [ [0, 2, 2], [0, 1, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 1, 2], 'up') | |
| self.assertTrue(result == ['', 0, 0, 2]) | |
| # Invalid left jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 1, 2], 'left') | |
| self.assertTrue(result == ['', 0, 0, 2]) | |
| # Invalid right jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 1, 2], 'right') | |
| self.assertTrue(result == ['', 0, 0, 2]) | |
| # Illegal right jump as left element is in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 1, 2], 'down') | |
| self.assertTrue(result == ['down', 0, 1, 2]) | |
| # Moving down from the node | |
| test_branch_iter = [ [0, 2, 2], [0, 3, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 3, 2], '') | |
| self.assertTrue(result == ['', 0, 4, 2]) | |
| # If down element is included, advance fails returning current element | |
| test_branch_iter = [ [0, 2, 2], [0, 3, 2], [0, 4, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 3, 2], '') | |
| self.assertTrue(result == ['', 0, 3, 2]) | |
| # Executing legal down jump to move left | |
| test_branch_iter = [ [0, 2, 2], [0, 3, 2] ] | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 3, 2], 'down') | |
| self.assertTrue(result == ['', 0, 4, 2]) | |
| # Invalid left jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 3, 2], 'left') | |
| self.assertTrue(result == ['', 0, 4, 2]) | |
| # Invalid right jump but function checks only for adjacent element | |
| # that is not in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 3, 2], 'right') | |
| self.assertTrue(result == ['', 0, 4, 2]) | |
| # Illegal up jump as left element is in temp branch | |
| result = branch_advance(test_matrix, test_branch_iter, [0, 3, 2], 'up') | |
| self.assertTrue(result == ['up', 0, 3, 2]) | |
| print() | |
| return | |
The tests work ok except for a few discrepancies. There is a case in the branch_advance method where an invalid jump does not throw an exception or even return an indication of an error, but rather returns the correct element. For example, while advancing to the right on a branch, the method checks if there is an element to the right of the current element and if that element has already been added to the temporary branch. Legally the advance should occur if the element on the right exists. There could be no jump executed in which case it is simply an element that exists to the right of the last element in the temporary branch. If a jump is executed, the jump direction should be to the right.
However, if the jump executed has a direction of up, down or right, there will be no exception and the element to the right of the current element will be returned. The only time an exception will be generated will be when the jump direction executed will be to the left. The reason this did not cause a major issue was because the methods related to the jump are fairly ok and do not produce wrong jump directions. But in principle, the code is wrong.
The check should be, according to the jump direction, is there an element in that direction? If there is no jump, we could follow some sequence of directions while searching for the next element.
Now that the methods have been tested, the next issue is to test the outer method determine_nodes_branches which calls these methods. At this point, the only was to test this outer method is manually by inputting different circuits. And that doesn't seem like a good way to test as the testing is not at all automatic and how many circuits can I come up with?
This brings me to the next crossroad. I need an automatic circuit builder. This is because things will get more complicated at the next step where I will have to test loops and loop manipulations. I need to generate loops automatically while also introducing errors and bugs in the loops automatically. So, the circuit builder will need to generate circuit topologies only while testing at every stage. For example, I need to start with a simple two node, three branch, two loop circuit and verify that that is generated. Then continuously add nodes and branches automatically to form new loops. The structure should not matter as long as there are a few random jump labels inserted every now and then.
This circuit builder seems very interesting and challenging. The next few blog posts will be dedicated to this.
