5689 lines
206 KiB
Python
5689 lines
206 KiB
Python
import pytest
|
|
import random
|
|
from tjnetwork import *
|
|
|
|
class TestApi:
|
|
def enter(self, p):
|
|
if is_project_open(p):
|
|
close_project(p)
|
|
|
|
if have_project(p):
|
|
delete_project(p)
|
|
|
|
create_project(p)
|
|
open_project(p)
|
|
|
|
|
|
def leave(self, p):
|
|
close_project(p)
|
|
delete_project(p)
|
|
|
|
|
|
# project
|
|
|
|
|
|
def test_project(self):
|
|
p = 'test_project'
|
|
|
|
assert not have_project(p)
|
|
assert not is_project_open(p)
|
|
|
|
create_project(p)
|
|
|
|
assert have_project(p)
|
|
assert not is_project_open(p)
|
|
|
|
open_project(p)
|
|
|
|
assert have_project(p)
|
|
assert is_project_open(p)
|
|
|
|
close_project(p)
|
|
|
|
assert have_project(p)
|
|
assert not is_project_open(p)
|
|
|
|
delete_project(p)
|
|
|
|
assert not have_project(p)
|
|
assert not is_project_open(p)
|
|
|
|
|
|
def test_project_name(self):
|
|
p = 'test_PROJECT_name'
|
|
|
|
assert not have_project(p)
|
|
assert not is_project_open(p)
|
|
|
|
create_project(p)
|
|
|
|
assert have_project(p)
|
|
assert not is_project_open(p)
|
|
|
|
open_project(p)
|
|
|
|
assert have_project(p)
|
|
assert is_project_open(p)
|
|
|
|
close_project(p)
|
|
|
|
assert have_project(p)
|
|
assert not is_project_open(p)
|
|
|
|
delete_project(p)
|
|
|
|
assert not have_project(p)
|
|
assert not is_project_open(p)
|
|
|
|
|
|
# operation
|
|
|
|
|
|
def test_snapshot(self):
|
|
p = "test_snapshot"
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
|
|
op_4 = get_current_operation(p)
|
|
assert op_4 == 4
|
|
take_snapshot(p, 'x')
|
|
assert get_snapshot_by_operation(p, 4) == 'x'
|
|
assert get_operation_by_snapshot(p, 'x') == 4
|
|
update_snapshot_for_current_operation(p, 'y')
|
|
assert get_snapshot_by_operation(p, 4) == 'y'
|
|
|
|
execute_undo(p)
|
|
execute_undo(p)
|
|
add_junction(p, ChangeSet({'id': 'j5', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j6', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
|
|
op_6 = get_current_operation(p)
|
|
assert op_6 == 6
|
|
take_snapshot(p, 'xx')
|
|
assert get_snapshot_by_operation(p, 6) == 'xx'
|
|
assert get_operation_by_snapshot(p, 'xx') == 6
|
|
|
|
cs = sync_with_server(p, op_4).operations
|
|
cs[0]['operation'] = API_DELETE
|
|
cs[0]['id'] = 'j4'
|
|
cs[1]['operation'] = API_DELETE
|
|
cs[1]['id'] = 'j3'
|
|
cs[2]['operation'] = API_ADD
|
|
cs[2]['id'] = 'j5'
|
|
cs[3]['operation'] = API_ADD
|
|
cs[3]['id'] = 'j6'
|
|
|
|
cs = pick_snapshot(p, 'y').operations
|
|
cs[0]['operation'] = 'delete'
|
|
cs[0]['id'] = 'j6'
|
|
cs[1]['operation'] = 'delete'
|
|
cs[1]['id'] = 'j5'
|
|
cs[2]['operation'] = 'add'
|
|
cs[2]['id'] = 'j3'
|
|
cs[3]['operation'] = 'add'
|
|
cs[3]['id'] = 'j4'
|
|
|
|
assert get_nodes(p) == ['j1', 'j2', 'j3', 'j4']
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_batch_commands(self):
|
|
p = 'test_batch_commands'
|
|
self.enter(p)
|
|
|
|
cs = ChangeSet()
|
|
cs.add({'type': JUNCTION, 'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0})
|
|
cs.add({'type': JUNCTION, 'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0})
|
|
cs.add({'type': JUNCTION, 'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}) # fail
|
|
|
|
cs = execute_batch_commands(p, cs)
|
|
assert len(cs.operations) == 2
|
|
|
|
cs = ChangeSet()
|
|
cs.delete({'type': JUNCTION, 'id': 'j1'})
|
|
cs.delete({'type': JUNCTION, 'id': 'j2'})
|
|
|
|
cs = execute_batch_commands(p, cs)
|
|
assert len(cs.operations) == 2
|
|
|
|
cs = execute_undo(p)
|
|
assert len(cs.operations) == 1
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_batch_command(self):
|
|
p = 'test_batch_command'
|
|
self.enter(p)
|
|
|
|
cs = ChangeSet()
|
|
cs.add({'type': JUNCTION, 'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0})
|
|
cs.add({'type': JUNCTION, 'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0})
|
|
cs.add({'type': JUNCTION, 'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}) # fail
|
|
|
|
cs = execute_batch_command(p, cs)
|
|
assert len(cs.operations) == 2
|
|
|
|
assert get_current_operation(p) == 1
|
|
|
|
cs = ChangeSet()
|
|
cs.delete({'type': JUNCTION, 'id': 'j1'})
|
|
cs.delete({'type': JUNCTION, 'id': 'j2'})
|
|
|
|
cs = execute_batch_command(p, cs)
|
|
|
|
assert get_current_operation(p) == 2
|
|
|
|
cs = execute_undo(p)
|
|
assert get_current_operation(p) == 1
|
|
|
|
cs = execute_undo(p)
|
|
assert get_current_operation(p) == 0
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# complex test
|
|
|
|
|
|
def test_delete_node_link_then_restore(self):
|
|
p = 'test_remove_node_link_then_restore'
|
|
read_inp(p, f'./inp/net3.inp', '2')
|
|
|
|
open_project(p)
|
|
|
|
nodes = []
|
|
links = []
|
|
|
|
nodes.append('131')
|
|
links += get_node_links(p, nodes[-1])
|
|
delete_junction(p, ChangeSet({'id': '131'}))
|
|
|
|
links.append('137')
|
|
delete_pipe(p, ChangeSet({'id': '137'}))
|
|
|
|
nodes.append('129')
|
|
links += get_node_links(p, nodes[-1])
|
|
delete_junction(p, ChangeSet({'id': '129'}))
|
|
|
|
nodes.append('127')
|
|
links += get_node_links(p, nodes[-1])
|
|
delete_junction(p, ChangeSet({'id': '127'}))
|
|
|
|
links.append('135')
|
|
delete_pipe(p, ChangeSet({'id': '135'}))
|
|
|
|
links.append('135')
|
|
delete_pipe(p, ChangeSet({'id': '133'}))
|
|
|
|
nodes.append('20')
|
|
links += get_node_links(p, nodes[-1])
|
|
delete_junction(p, ChangeSet({'id': '20'}))
|
|
|
|
nodes.append('3')
|
|
links += get_node_links(p, nodes[-1])
|
|
delete_tank(p, ChangeSet({'id': '3'}))
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node) == False
|
|
for link in links:
|
|
assert is_link(p, link) == False
|
|
|
|
op = get_restore_operation(p)
|
|
pick_operation(p, op)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node)
|
|
for link in links:
|
|
assert is_link(p, link)
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_delete_nodes_then_restore(self):
|
|
p = 'test_delete_nodes_then_restore'
|
|
read_inp(p, f'./inp/net3.inp', '2')
|
|
|
|
open_project(p)
|
|
|
|
nodes = get_nodes(p)
|
|
links = get_links(p)
|
|
|
|
for _ in range(10):
|
|
random.shuffle(nodes)
|
|
for node in nodes:
|
|
if is_junction(p, node):
|
|
delete_junction(p, ChangeSet({'id': node}))
|
|
if is_reservoir(p, node):
|
|
delete_reservoir(p, ChangeSet({'id': node}))
|
|
if is_tank(p, node):
|
|
delete_tank(p, ChangeSet({'id': node}))
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node) == False
|
|
for link in links:
|
|
assert is_link(p, link) == False
|
|
|
|
assert get_nodes(p) == []
|
|
assert get_links(p) == []
|
|
|
|
op = get_restore_operation(p)
|
|
pick_operation(p, op)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node)
|
|
for link in links:
|
|
assert is_link(p, link)
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_delete_links_then_restore(self):
|
|
p = 'test_delete_links_then_restore'
|
|
read_inp(p, f'./inp/net3.inp', '2')
|
|
|
|
open_project(p)
|
|
|
|
nodes = get_nodes(p)
|
|
links = get_links(p)
|
|
|
|
for _ in range(10):
|
|
random.shuffle(links)
|
|
for link in links:
|
|
if is_pipe(p, link):
|
|
delete_pipe(p, ChangeSet({'id': link}))
|
|
if is_pump(p, link):
|
|
delete_pump(p, ChangeSet({'id': link}))
|
|
if is_valve(p, link):
|
|
delete_valve(p, ChangeSet({'id': link}))
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node)
|
|
for link in links:
|
|
assert is_link(p, link) == False
|
|
|
|
assert get_links(p) == []
|
|
|
|
op = get_restore_operation(p)
|
|
pick_operation(p, op)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node)
|
|
for link in links:
|
|
assert is_link(p, link)
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_delete_nodes_then_restore_commands(self):
|
|
p = 'test_delete_nodes_then_restore_commands'
|
|
read_inp(p, f'./inp/net3.inp', '2')
|
|
|
|
open_project(p)
|
|
|
|
nodes = get_nodes(p)
|
|
links = get_links(p)
|
|
|
|
for _ in range(10):
|
|
random.shuffle(nodes)
|
|
|
|
batch = ChangeSet()
|
|
for node in nodes:
|
|
if is_junction(p, node):
|
|
batch.delete({'type' : 'junction', 'id': node })
|
|
if is_reservoir(p, node):
|
|
batch.delete({'type' : 'reservoir', 'id': node })
|
|
if is_tank(p, node):
|
|
batch.delete({'type' : 'tank', 'id': node })
|
|
execute_batch_commands(p, batch)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node) == False
|
|
for link in links:
|
|
assert is_link(p, link) == False
|
|
|
|
assert get_nodes(p) == []
|
|
assert get_links(p) == []
|
|
|
|
op = get_restore_operation(p)
|
|
pick_operation(p, op)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node)
|
|
for link in links:
|
|
assert is_link(p, link)
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_delete_links_then_restore_commands(self):
|
|
p = 'test_delete_links_then_restore_commands'
|
|
read_inp(p, f'./inp/net3.inp', '2')
|
|
|
|
open_project(p)
|
|
|
|
nodes = get_nodes(p)
|
|
links = get_links(p)
|
|
|
|
for _ in range(10):
|
|
random.shuffle(links)
|
|
|
|
batch = ChangeSet()
|
|
for link in links:
|
|
if is_pipe(p, link):
|
|
batch.delete({'type' : 'pipe', 'id': link })
|
|
if is_pump(p, link):
|
|
batch.delete({'type' : 'pump', 'id': link })
|
|
if is_valve(p, link):
|
|
batch.delete({'type' : 'valve', 'id': link })
|
|
execute_batch_commands(p, batch)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node)
|
|
for link in links:
|
|
assert is_link(p, link) == False
|
|
|
|
assert get_links(p) == []
|
|
|
|
op = get_restore_operation(p)
|
|
pick_operation(p, op)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node)
|
|
for link in links:
|
|
assert is_link(p, link)
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_delete_nodes_then_restore_command(self):
|
|
p = 'test_delete_nodes_then_restore_commands'
|
|
read_inp(p, f'./inp/net3.inp', '2')
|
|
|
|
open_project(p)
|
|
|
|
nodes = get_nodes(p)
|
|
links = get_links(p)
|
|
|
|
for _ in range(10):
|
|
random.shuffle(nodes)
|
|
|
|
batch = ChangeSet()
|
|
for node in nodes:
|
|
if is_junction(p, node):
|
|
batch.delete({'type' : 'junction', 'id': node })
|
|
if is_reservoir(p, node):
|
|
batch.delete({'type' : 'reservoir', 'id': node })
|
|
if is_tank(p, node):
|
|
batch.delete({'type' : 'tank', 'id': node })
|
|
execute_batch_command(p, batch)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node) == False
|
|
for link in links:
|
|
assert is_link(p, link) == False
|
|
|
|
assert get_nodes(p) == []
|
|
assert get_links(p) == []
|
|
|
|
op = get_restore_operation(p)
|
|
pick_operation(p, op)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node)
|
|
for link in links:
|
|
assert is_link(p, link)
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_delete_links_then_restore_command(self):
|
|
p = 'test_delete_links_then_restore_commands'
|
|
read_inp(p, f'./inp/net3.inp', '2')
|
|
|
|
open_project(p)
|
|
|
|
nodes = get_nodes(p)
|
|
links = get_links(p)
|
|
|
|
for _ in range(10):
|
|
random.shuffle(links)
|
|
|
|
batch = ChangeSet()
|
|
for link in links:
|
|
if is_pipe(p, link):
|
|
batch.delete({'type' : 'pipe', 'id': link })
|
|
if is_pump(p, link):
|
|
batch.delete({'type' : 'pump', 'id': link })
|
|
if is_valve(p, link):
|
|
batch.delete({'type' : 'valve', 'id': link })
|
|
execute_batch_command(p, batch)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node)
|
|
for link in links:
|
|
assert is_link(p, link) == False
|
|
|
|
assert get_links(p) == []
|
|
|
|
op = get_restore_operation(p)
|
|
pick_operation(p, op)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node)
|
|
for link in links:
|
|
assert is_link(p, link)
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_delete_nodes_links_then_restore_v2(self):
|
|
p = 'test_delete_nodes_links_then_restore_v2'
|
|
read_inp(p, f'./inp/net3.inp', '2')
|
|
|
|
open_project(p)
|
|
|
|
nls : list[tuple[str, str]] = []
|
|
|
|
nodes = get_nodes(p)
|
|
for node in nodes:
|
|
nls.append(('node', node))
|
|
|
|
links = get_links(p)
|
|
for link in links:
|
|
nls.append(('link', link))
|
|
|
|
for _ in range(10):
|
|
random.shuffle(nls)
|
|
for nl in nls:
|
|
if nl[0] == 'node':
|
|
node = nl[1]
|
|
if is_junction(p, node):
|
|
delete_junction(p, ChangeSet({'id': node}))
|
|
if is_reservoir(p, node):
|
|
delete_reservoir(p, ChangeSet({'id': node}))
|
|
if is_tank(p, node):
|
|
delete_tank(p, ChangeSet({'id': node}))
|
|
else:
|
|
link = nl[1]
|
|
if is_pipe(p, link):
|
|
delete_pipe(p, ChangeSet({'id': link}))
|
|
if is_pump(p, link):
|
|
delete_pump(p, ChangeSet({'id': link}))
|
|
if is_valve(p, link):
|
|
delete_valve(p, ChangeSet({'id': link}))
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node) == False
|
|
for link in links:
|
|
assert is_link(p, link) == False
|
|
|
|
assert get_nodes(p) == []
|
|
assert get_links(p) == []
|
|
|
|
op = get_restore_operation(p)
|
|
pick_operation(p, op)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node)
|
|
for link in links:
|
|
assert is_link(p, link)
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_delete_nodes_links_then_restore_v3(self):
|
|
p = 'test_delete_nodes_links_then_restore_v3'
|
|
read_inp(p, f'./inp/net3.inp', '3')
|
|
|
|
open_project(p)
|
|
|
|
nls : list[tuple[str, str]] = []
|
|
|
|
nodes = get_nodes(p)
|
|
for node in nodes:
|
|
nls.append(('node', node))
|
|
|
|
links = get_links(p)
|
|
for link in links:
|
|
nls.append(('link', link))
|
|
|
|
for _ in range(10):
|
|
random.shuffle(nls)
|
|
for nl in nls:
|
|
if nl[0] == 'node':
|
|
node = nl[1]
|
|
if is_junction(p, node):
|
|
delete_junction(p, ChangeSet({'id': node}))
|
|
if is_reservoir(p, node):
|
|
delete_reservoir(p, ChangeSet({'id': node}))
|
|
if is_tank(p, node):
|
|
delete_tank(p, ChangeSet({'id': node}))
|
|
else:
|
|
link = nl[1]
|
|
if is_pipe(p, link):
|
|
delete_pipe(p, ChangeSet({'id': link}))
|
|
if is_pump(p, link):
|
|
delete_pump(p, ChangeSet({'id': link}))
|
|
if is_valve(p, link):
|
|
delete_valve(p, ChangeSet({'id': link}))
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node) == False
|
|
for link in links:
|
|
assert is_link(p, link) == False
|
|
|
|
assert get_nodes(p) == []
|
|
assert get_links(p) == []
|
|
|
|
op = get_restore_operation(p)
|
|
pick_operation(p, op)
|
|
|
|
for node in nodes:
|
|
assert is_node(p, node)
|
|
for link in links:
|
|
assert is_link(p, link)
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 1 title
|
|
|
|
|
|
def test_title(self):
|
|
p = 'test_title'
|
|
self.enter(p)
|
|
|
|
assert get_title(p)['value'] == ''
|
|
|
|
change = set_title(p, ChangeSet({'value': 'title'})).operations[0]
|
|
assert change['operation'] == 'update'
|
|
assert change['type'] == 'title'
|
|
assert get_title(p)['value'] == 'title'
|
|
|
|
set_title(p, ChangeSet({'value': 'test'}))
|
|
assert get_title(p)['value'] == 'test'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_title_op(self):
|
|
p = 'test_title_op'
|
|
self.enter(p)
|
|
|
|
assert get_title(p)['value'] == ''
|
|
|
|
cs = set_title(p, ChangeSet({'value': 'title'})).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == 'title'
|
|
assert cs['value'] == 'title'
|
|
assert get_title(p)['value'] == 'title'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == 'title'
|
|
assert cs['value'] == ''
|
|
assert get_title(p)['value'] == ''
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == 'title'
|
|
assert cs['value'] == 'title'
|
|
assert get_title(p)['value'] == 'title'
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == 'title'
|
|
assert cs['value'] == ''
|
|
assert get_title(p)['value'] == ''
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
assert get_title(p)['value'] == ''
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 2 junction
|
|
|
|
|
|
def test_junction(self):
|
|
p = 'test_junction'
|
|
self.enter(p)
|
|
|
|
assert get_junction(p, 'j0') == {}
|
|
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
j0 = get_junction(p, 'j0')
|
|
assert j0['x'] == 0.0
|
|
assert j0['y'] == 10.0
|
|
assert j0['elevation'] == 20.0
|
|
assert j0['links'] == []
|
|
|
|
set_junction(p, ChangeSet({'id': 'j0', 'x': 100.0, 'y': 200.0}))
|
|
j0 = get_junction(p, 'j0')
|
|
assert j0['x'] == 100.0
|
|
assert j0['y'] == 200.0
|
|
|
|
set_junction(p, ChangeSet({'id': 'j0', 'elevation': 100.0}))
|
|
j0 = get_junction(p, 'j0')
|
|
assert j0['elevation'] == 100.0
|
|
|
|
# TODO: pattern
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 2
|
|
assert nodes[0] == 'j0'
|
|
assert nodes[1] == 'j1'
|
|
assert is_junction(p, 'j0')
|
|
assert is_junction(p, 'j1')
|
|
|
|
delete_junction(p, ChangeSet({'id': 'j1'}))
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 1
|
|
assert nodes[0] == 'j0'
|
|
|
|
delete_junction(p, ChangeSet({'id': 'j0'}))
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 0
|
|
|
|
assert get_junction(p, 'j0') == {}
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pipe(p, ChangeSet({'id': 'p1', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
add_pump(p, ChangeSet({'id': 'p2', 'node1': 'j1', 'node2': 'j2', 'power': 0.0}))
|
|
add_valve(p, ChangeSet({'id': 'v1', 'node1': 'j2', 'node2': 'j3', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': 0.1, 'minor_loss': 0.5 }))
|
|
assert get_junction(p, 'j1')['links'] == ['p1', 'p2']
|
|
assert get_junction(p, 'j2')['links'] == ['p1', 'p2', 'v1']
|
|
assert get_junction(p, 'j3')['links'] == ['v1']
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_junction_op(self):
|
|
p = 'test_junction_op'
|
|
self.enter(p)
|
|
|
|
cs = add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0})).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == JUNCTION
|
|
assert cs['id'] == 'j0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['elevation'] == 20.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == JUNCTION
|
|
assert cs['id'] == 'j0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == JUNCTION
|
|
assert cs['id'] == 'j0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['elevation'] == 20.0
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == JUNCTION
|
|
assert cs['id'] == 'j0'
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 0
|
|
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'demand': 100.0}))
|
|
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 1
|
|
|
|
cs = delete_junction(p, ChangeSet({'id': 'j0'})).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == JUNCTION
|
|
assert cs['id'] == 'j0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == JUNCTION
|
|
assert cs['id'] == 'j0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['elevation'] == 20.0
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == JUNCTION
|
|
assert cs['id'] == 'j0'
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == JUNCTION
|
|
assert cs['id'] == 'j0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['elevation'] == 20.0
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 1
|
|
|
|
cs = set_junction(p, ChangeSet({'id': 'j0', 'x': 100.0, 'y': 200.0})).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == JUNCTION
|
|
assert cs['id'] == 'j0'
|
|
assert cs['x'] == 100.0
|
|
assert cs['y'] == 200.0
|
|
assert cs['elevation'] == 20.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == JUNCTION
|
|
assert cs['id'] == 'j0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['elevation'] == 20.0
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_junction_del(self):
|
|
p = 'test_junction_del'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j0', 'node2': 'j1', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
set_tag(p, ChangeSet({'t_type': TAG_TYPE_NODE, 'id': 'j0', 'tag': 'j0t' }))
|
|
set_demand(p, ChangeSet({'junction': 'j0', 'demands': [{'demand': 10.0, 'pattern': None, 'category': 'x'}, {'demand': 20.0, 'pattern': None, 'category': None}]}))
|
|
set_emitter(p, ChangeSet({'junction': 'j0', 'coefficient': 10.0}))
|
|
set_quality(p, ChangeSet({'node': 'j0', 'quality': 10.0}))
|
|
add_source(p, ChangeSet({'node': 'j0', 's_type': SOURCE_TYPE_CONCEN, 'strength': 10.0, 'pattern': None }))
|
|
add_label(p, ChangeSet({'x': 0.0, 'y': 0.0, 'label': 'x', 'node': 'j0'}))
|
|
assert is_junction(p, 'j0')
|
|
assert is_junction(p, 'j1')
|
|
assert is_pipe(p, 'p0')
|
|
assert get_tag(p, TAG_TYPE_NODE, 'j0')['tag'] == 'j0t'
|
|
assert get_demand(p, 'j0')['demands'] == [{'demand': 10.0, 'pattern': None, 'category': 'x'}, {'demand': 20.0, 'pattern': None, 'category': None}]
|
|
assert get_emitter(p, 'j0')['coefficient'] == 10.0
|
|
assert get_quality(p, 'j0')['quality'] == 10.0
|
|
assert get_source(p, 'j0')['s_type'] == SOURCE_TYPE_CONCEN
|
|
assert get_label(p, 0.0, 0.0)['node'] == 'j0'
|
|
|
|
delete_junction(p, ChangeSet({'id': 'j0'}))
|
|
assert is_junction(p, 'j0') == False
|
|
assert is_junction(p, 'j1')
|
|
assert is_pipe(p, 'p0') == False
|
|
assert get_tag(p, TAG_TYPE_NODE, 'j0')['tag'] == None
|
|
assert get_demand(p, 'j1')['demands'] == []
|
|
assert get_emitter(p, 'j0')['coefficient'] == None
|
|
assert get_quality(p, 'j0')['quality'] == None
|
|
assert get_source(p, 'j0') == {}
|
|
assert get_label(p, 0.0, 0.0)['node'] == None
|
|
|
|
execute_undo(p)
|
|
assert is_junction(p, 'j0')
|
|
assert is_junction(p, 'j1')
|
|
assert is_pipe(p, 'p0')
|
|
assert get_tag(p, TAG_TYPE_NODE, 'j0')['tag'] == 'j0t'
|
|
assert get_demand(p, 'j0')['demands'] == [{'demand': 10.0, 'pattern': None, 'category': 'x'}, {'demand': 20.0, 'pattern': None, 'category': None}]
|
|
assert get_emitter(p, 'j0')['coefficient'] == 10.0
|
|
assert get_quality(p, 'j0')['quality'] == 10.0
|
|
assert get_source(p, 'j0')['s_type'] == SOURCE_TYPE_CONCEN
|
|
assert get_label(p, 0.0, 0.0)['node'] == 'j0'
|
|
|
|
execute_redo(p)
|
|
assert is_junction(p, 'j0') == False
|
|
assert is_junction(p, 'j1')
|
|
assert is_pipe(p, 'p0') == False
|
|
assert get_tag(p, TAG_TYPE_NODE, 'j0')['tag'] == None
|
|
assert get_demand(p, 'j1')['demands'] == []
|
|
assert get_emitter(p, 'j0')['coefficient'] == None
|
|
assert get_quality(p, 'j0')['quality'] == None
|
|
assert get_source(p, 'j0') == {}
|
|
assert get_label(p, 0.0, 0.0)['node'] == None
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 3 reservoir
|
|
|
|
|
|
def test_reservoir(self):
|
|
p = 'test_reservoir'
|
|
self.enter(p)
|
|
|
|
assert get_reservoir(p, 'r0') == {}
|
|
|
|
add_reservoir(p, ChangeSet({'id': 'r0', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
|
|
r0 = get_reservoir(p, 'r0')
|
|
assert r0['x'] == 0.0
|
|
assert r0['y'] == 10.0
|
|
assert r0['head'] == 20.0
|
|
assert r0['pattern'] == None
|
|
assert r0['links'] == []
|
|
|
|
set_reservoir(p, ChangeSet({'id': 'r0', 'x': 100.0, 'y': 200.0}))
|
|
r0 = get_reservoir(p, 'r0')
|
|
assert r0['x'] == 100.0
|
|
assert r0['y'] == 200.0
|
|
|
|
set_reservoir(p, ChangeSet({'id': 'r0', 'head': 100.0}))
|
|
r0 = get_reservoir(p, 'r0')
|
|
assert r0['head'] == 100.0
|
|
|
|
# TODO: pattern
|
|
|
|
add_reservoir(p, ChangeSet({'id': 'r1', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 2
|
|
assert nodes[0] == 'r0'
|
|
assert nodes[1] == 'r1'
|
|
assert is_reservoir(p, 'r0')
|
|
assert is_reservoir(p, 'r1')
|
|
|
|
delete_reservoir(p, ChangeSet({'id': 'r1'}))
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 1
|
|
assert nodes[0] == 'r0'
|
|
|
|
delete_reservoir(p, ChangeSet({'id': 'r0'}))
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 0
|
|
|
|
assert get_reservoir(p, 'r0') == {}
|
|
|
|
add_reservoir(p, ChangeSet({'id': 'r1', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
|
|
add_reservoir(p, ChangeSet({'id': 'r2', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
|
|
add_reservoir(p, ChangeSet({'id': 'r3', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
|
|
add_pipe(p, ChangeSet({'id': 'p1', 'node1': 'r1', 'node2': 'r2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
add_pump(p, ChangeSet({'id': 'p2', 'node1': 'r1', 'node2': 'r2', 'power': 0.0}))
|
|
add_valve(p, ChangeSet({'id': 'v1', 'node1': 'r2', 'node2': 'r3', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': 0.1, 'minor_loss': 0.5 }))
|
|
assert get_reservoir(p, 'r1')['links'] == ['p1', 'p2']
|
|
assert get_reservoir(p, 'r2')['links'] == ['p1', 'p2', 'v1']
|
|
assert get_reservoir(p, 'r3')['links'] == ['v1']
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_reservoir_op(self):
|
|
p = 'test_reservoir_op'
|
|
self.enter(p)
|
|
|
|
cs = add_reservoir(p, ChangeSet({'id': 'r0', 'x': 0.0, 'y': 10.0, 'head': 20.0})).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == RESERVOIR
|
|
assert cs['id'] == 'r0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['head'] == 20.0
|
|
assert cs['pattern'] == None
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == RESERVOIR
|
|
assert cs['id'] == 'r0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == RESERVOIR
|
|
assert cs['id'] == 'r0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['head'] == 20.0
|
|
assert cs['pattern'] == None
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == RESERVOIR
|
|
assert cs['id'] == 'r0'
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 0
|
|
|
|
add_reservoir(p, ChangeSet({'id': 'r0', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
|
|
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 1
|
|
|
|
cs = delete_reservoir(p, ChangeSet({'id': 'r0'})).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == RESERVOIR
|
|
assert cs['id'] == 'r0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == RESERVOIR
|
|
assert cs['id'] == 'r0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['head'] == 20.0
|
|
assert cs['pattern'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == RESERVOIR
|
|
assert cs['id'] == 'r0'
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == RESERVOIR
|
|
assert cs['id'] == 'r0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['head'] == 20.0
|
|
assert cs['pattern'] == None
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 1
|
|
|
|
cs = set_reservoir(p, ChangeSet({'id': 'r0', 'x': 100.0, 'y': 200.0})).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == RESERVOIR
|
|
assert cs['id'] == 'r0'
|
|
assert cs['x'] == 100.0
|
|
assert cs['y'] == 200.0
|
|
assert cs['head'] == 20.0
|
|
assert cs['pattern'] == None
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == RESERVOIR
|
|
assert cs['id'] == 'r0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['head'] == 20.0
|
|
assert cs['pattern'] == None
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_reservoir_del(self):
|
|
p = 'test_reservoir_del'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_reservoir(p, ChangeSet({'id': 'r0', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j0', 'node2': 'r0', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
assert is_junction(p, 'j0')
|
|
assert is_reservoir(p, 'r0')
|
|
assert is_pipe(p, 'p0')
|
|
|
|
delete_reservoir(p, ChangeSet({'id': 'r0'}))
|
|
assert is_junction(p, 'j0')
|
|
assert is_reservoir(p, 'r0') == False
|
|
assert is_pipe(p, 'p0') == False
|
|
|
|
execute_undo(p)
|
|
assert is_junction(p, 'j0')
|
|
assert is_reservoir(p, 'r0')
|
|
assert is_pipe(p, 'p0')
|
|
|
|
execute_redo(p)
|
|
assert is_junction(p, 'j0')
|
|
assert is_reservoir(p, 'r0') == False
|
|
assert is_pipe(p, 'p0') == False
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 4 tank
|
|
|
|
|
|
def test_tank(self):
|
|
p = 'test_tank'
|
|
self.enter(p)
|
|
|
|
assert get_tank(p, 't0') == {}
|
|
|
|
add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
|
|
t0 = get_tank(p, 't0')
|
|
assert t0['x'] == 0.0
|
|
assert t0['y'] == 10.0
|
|
assert t0['elevation'] == 20.0
|
|
assert t0['init_level'] == 1.0
|
|
assert t0['min_level'] == 0.0
|
|
assert t0['max_level'] == 2.0
|
|
assert t0['diameter'] == 10.0
|
|
assert t0['min_vol'] == 100.0
|
|
assert t0['vol_curve'] == None
|
|
assert t0['overflow'] == OVERFLOW_NO
|
|
assert t0['links'] == []
|
|
|
|
set_tank(p, ChangeSet({'id': 't0', 'x': 100.0, 'y': 200.0}))
|
|
t0 = get_tank(p, 't0')
|
|
assert t0['x'] == 100.0
|
|
assert t0['y'] == 200.0
|
|
|
|
set_tank(p, ChangeSet({'id': 't0', 'elevation': 100.0}))
|
|
t0 = get_tank(p, 't0')
|
|
assert t0['elevation'] == 100.0
|
|
|
|
set_tank(p, ChangeSet({'id': 't0', 'init_level': 100.0, 'min_level': 50.0, 'max_level': 200.0}))
|
|
t0 = get_tank(p, 't0')
|
|
assert t0['init_level'] == 100.0
|
|
assert t0['min_level'] == 50.0
|
|
assert t0['max_level'] == 200.0
|
|
|
|
set_tank(p, ChangeSet({'id': 't0', 'diameter': 100.0}))
|
|
t0 = get_tank(p, 't0')
|
|
assert t0['diameter'] == 100.0
|
|
|
|
set_tank(p, ChangeSet({'id': 't0', 'min_vol': 200.0}))
|
|
t0 = get_tank(p, 't0')
|
|
assert t0['min_vol'] == 200.0
|
|
|
|
# TODO: vol_curve
|
|
|
|
set_tank(p, ChangeSet({'id': 't0', 'overflow': OVERFLOW_YES}))
|
|
t0 = get_tank(p, 't0')
|
|
assert t0['overflow'] == OVERFLOW_YES
|
|
|
|
add_tank(p, ChangeSet({'id': 't1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 2
|
|
assert nodes[0] == 't0'
|
|
assert nodes[1] == 't1'
|
|
assert is_tank(p, 't0')
|
|
assert is_tank(p, 't1')
|
|
|
|
delete_tank(p, ChangeSet({'id': 't1'}))
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 1
|
|
assert nodes[0] == 't0'
|
|
|
|
delete_tank(p, ChangeSet({'id': 't0'}))
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 0
|
|
|
|
assert get_tank(p, 't0') == {}
|
|
|
|
add_tank(p, ChangeSet({'id': 't1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
|
|
add_tank(p, ChangeSet({'id': 't2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
|
|
add_tank(p, ChangeSet({'id': 't3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
|
|
add_pipe(p, ChangeSet({'id': 'p1', 'node1': 't1', 'node2': 't2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
add_pump(p, ChangeSet({'id': 'p2', 'node1': 't1', 'node2': 't2', 'power': 0.0}))
|
|
add_valve(p, ChangeSet({'id': 'v1', 'node1': 't2', 'node2': 't3', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': 0.1, 'minor_loss': 0.5 }))
|
|
assert get_tank(p, 't1')['links'] == ['p1', 'p2']
|
|
assert get_tank(p, 't2')['links'] == ['p1', 'p2', 'v1']
|
|
assert get_tank(p, 't3')['links'] == ['v1']
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_tank_op(self):
|
|
p = 'test_tank_op'
|
|
self.enter(p)
|
|
|
|
cs = add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO})).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == TANK
|
|
assert cs['id'] == 't0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['elevation'] == 20.0
|
|
assert cs['init_level'] == 1.0
|
|
assert cs['min_level'] == 0.0
|
|
assert cs['max_level'] == 2.0
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['min_vol'] == 100.0
|
|
assert cs['vol_curve'] == None
|
|
assert cs['overflow'] == OVERFLOW_NO
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == TANK
|
|
assert cs['id'] == 't0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == TANK
|
|
assert cs['id'] == 't0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['elevation'] == 20.0
|
|
assert cs['init_level'] == 1.0
|
|
assert cs['min_level'] == 0.0
|
|
assert cs['max_level'] == 2.0
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['min_vol'] == 100.0
|
|
assert cs['vol_curve'] == None
|
|
assert cs['overflow'] == OVERFLOW_NO
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == TANK
|
|
assert cs['id'] == 't0'
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 0
|
|
|
|
add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
|
|
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 1
|
|
|
|
cs = delete_tank(p, ChangeSet({'id': 't0'})).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == TANK
|
|
assert cs['id'] == 't0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == TANK
|
|
assert cs['id'] == 't0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['elevation'] == 20.0
|
|
assert cs['init_level'] == 1.0
|
|
assert cs['min_level'] == 0.0
|
|
assert cs['max_level'] == 2.0
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['min_vol'] == 100.0
|
|
assert cs['vol_curve'] == None
|
|
assert cs['overflow'] == OVERFLOW_NO
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == TANK
|
|
assert cs['id'] == 't0'
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == TANK
|
|
assert cs['id'] == 't0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['elevation'] == 20.0
|
|
assert cs['init_level'] == 1.0
|
|
assert cs['min_level'] == 0.0
|
|
assert cs['max_level'] == 2.0
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['min_vol'] == 100.0
|
|
assert cs['vol_curve'] == None
|
|
assert cs['overflow'] == OVERFLOW_NO
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
|
|
nodes = get_nodes(p)
|
|
assert len(nodes) == 1
|
|
|
|
cs = set_tank(p, ChangeSet({'id': 't0', 'x': 100.0, 'y': 200.0})).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == TANK
|
|
assert cs['id'] == 't0'
|
|
assert cs['x'] == 100.0
|
|
assert cs['y'] == 200.0
|
|
assert cs['elevation'] == 20.0
|
|
assert cs['init_level'] == 1.0
|
|
assert cs['min_level'] == 0.0
|
|
assert cs['max_level'] == 2.0
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['min_vol'] == 100.0
|
|
assert cs['vol_curve'] == None
|
|
assert cs['overflow'] == OVERFLOW_NO
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == TANK
|
|
assert cs['id'] == 't0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 10.0
|
|
assert cs['elevation'] == 20.0
|
|
assert cs['init_level'] == 1.0
|
|
assert cs['min_level'] == 0.0
|
|
assert cs['max_level'] == 2.0
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['min_vol'] == 100.0
|
|
assert cs['vol_curve'] == None
|
|
assert cs['overflow'] == OVERFLOW_NO
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_tank_del(self):
|
|
p = 'test_tank_del'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j0', 'node2': 't0', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
set_tank_reaction(p, ChangeSet({'tank': 't0', 'value': 10.0}))
|
|
assert is_junction(p, 'j0')
|
|
assert is_tank(p, 't0')
|
|
assert is_pipe(p, 'p0')
|
|
assert get_tank_reaction(p, 't0')['value'] == 10.0
|
|
|
|
delete_tank(p, ChangeSet({'id': 't0'}))
|
|
assert is_junction(p, 'j0')
|
|
assert is_tank(p, 't0') == False
|
|
assert is_pipe(p, 'p0') == False
|
|
assert get_tank_reaction(p, 't0')['value'] == None
|
|
|
|
execute_undo(p)
|
|
assert is_junction(p, 'j0')
|
|
assert is_tank(p, 't0')
|
|
assert is_pipe(p, 'p0')
|
|
assert get_tank_reaction(p, 't0')['value'] == 10.0
|
|
|
|
execute_redo(p)
|
|
assert is_junction(p, 'j0')
|
|
assert is_tank(p, 't0') == False
|
|
assert is_pipe(p, 'p0') == False
|
|
assert get_tank_reaction(p, 't0')['value'] == None
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 5 pipe
|
|
|
|
|
|
def test_pipe(self):
|
|
p = 'test_pipe'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
assert is_junction(p, 'j2')
|
|
assert is_junction(p, 'j3')
|
|
assert is_junction(p, 'j4')
|
|
|
|
assert get_pipe(p, 'p0') == {}
|
|
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
p0 = get_pipe(p, 'p0')
|
|
assert p0['node1'] == 'j1'
|
|
assert p0['node2'] == 'j2'
|
|
assert p0['length'] == 100.0
|
|
assert p0['diameter'] == 10.0
|
|
assert p0['roughness'] == 0.1
|
|
assert p0['minor_loss'] == 0.5
|
|
assert p0['status'] == PIPE_STATUS_OPEN
|
|
|
|
set_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j3', 'node2': 'j4'}))
|
|
p0 = get_pipe(p, 'p0')
|
|
assert p0['node1'] == 'j3'
|
|
assert p0['node2'] == 'j4'
|
|
|
|
set_pipe(p, ChangeSet({'id': 'p0', 'length': 200.0}))
|
|
p0 = get_pipe(p, 'p0')
|
|
assert p0['length'] == 200.0
|
|
|
|
set_pipe(p, ChangeSet({'id': 'p0', 'diameter': 100.0}))
|
|
p0 = get_pipe(p, 'p0')
|
|
assert p0['diameter'] == 100.0
|
|
|
|
set_pipe(p, ChangeSet({'id': 'p0', 'roughness': 0.2}))
|
|
p0 = get_pipe(p, 'p0')
|
|
assert p0['roughness'] == 0.2
|
|
|
|
set_pipe(p, ChangeSet({'id': 'p0', 'minor_loss': 0.1}))
|
|
p0 = get_pipe(p, 'p0')
|
|
assert p0['minor_loss'] == 0.1
|
|
|
|
set_pipe(p, ChangeSet({'id': 'p0', 'status': PIPE_STATUS_CLOSED}))
|
|
p0 = get_pipe(p, 'p0')
|
|
assert p0['status'] == PIPE_STATUS_CLOSED
|
|
|
|
add_pipe(p, ChangeSet({'id': 'p1', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
links = get_links(p)
|
|
assert len(links) == 2
|
|
assert links[0] == 'p0'
|
|
assert links[1] == 'p1'
|
|
assert is_pipe(p, 'p0')
|
|
assert is_pipe(p, 'p1')
|
|
|
|
delete_pipe(p, ChangeSet({'id': 'p1'}))
|
|
links = get_links(p)
|
|
assert len(links) == 1
|
|
assert links[0] == 'p0'
|
|
|
|
delete_pipe(p, ChangeSet({'id': 'p0'}))
|
|
links = get_links(p)
|
|
assert len(links) == 0
|
|
|
|
assert get_pipe(p, 'p0') == {}
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_pipe_op(self):
|
|
p = 'test_pipe_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
assert is_junction(p, 'j2')
|
|
assert is_junction(p, 'j3')
|
|
assert is_junction(p, 'j4')
|
|
|
|
cs = add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN })).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == PIPE
|
|
assert cs['id'] == 'p0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
assert cs['length'] == 100.0
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['roughness'] == 0.1
|
|
assert cs['minor_loss'] == 0.5
|
|
assert cs['status'] == PIPE_STATUS_OPEN
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == PIPE
|
|
assert cs['id'] == 'p0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == PIPE
|
|
assert cs['id'] == 'p0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
assert cs['length'] == 100.0
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['roughness'] == 0.1
|
|
assert cs['minor_loss'] == 0.5
|
|
assert cs['status'] == PIPE_STATUS_OPEN
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == PIPE
|
|
assert cs['id'] == 'p0'
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
|
|
links = get_links(p)
|
|
assert len(links) == 0
|
|
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
|
|
links = get_links(p)
|
|
assert len(links) == 1
|
|
|
|
cs = delete_pipe(p, ChangeSet({'id': 'p0'})).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == PIPE
|
|
assert cs['id'] == 'p0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == PIPE
|
|
assert cs['id'] == 'p0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
assert cs['length'] == 100.0
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['roughness'] == 0.1
|
|
assert cs['minor_loss'] == 0.5
|
|
assert cs['status'] == PIPE_STATUS_OPEN
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == PIPE
|
|
assert cs['id'] == 'p0'
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == PIPE
|
|
assert cs['id'] == 'p0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
assert cs['length'] == 100.0
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['roughness'] == 0.1
|
|
assert cs['minor_loss'] == 0.5
|
|
assert cs['status'] == PIPE_STATUS_OPEN
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
|
|
links = get_links(p)
|
|
assert len(links) == 1
|
|
|
|
cs = set_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j3', 'node2': 'j4'})).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == PIPE
|
|
assert cs['id'] == 'p0'
|
|
assert cs['node1'] == 'j3'
|
|
assert cs['node2'] == 'j4'
|
|
assert cs['length'] == 100.0
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['roughness'] == 0.1
|
|
assert cs['minor_loss'] == 0.5
|
|
assert cs['status'] == PIPE_STATUS_OPEN
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == PIPE
|
|
assert cs['id'] == 'p0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
assert cs['length'] == 100.0
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['roughness'] == 0.1
|
|
assert cs['minor_loss'] == 0.5
|
|
assert cs['status'] == PIPE_STATUS_OPEN
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_pipe_del(self):
|
|
p = 'test_pipe_del'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j0', 'node2': 'j1', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
set_tag(p, ChangeSet({'t_type': TAG_TYPE_LINK, 'id': 'p0', 'tag': 'p0t' }))
|
|
set_status(p, ChangeSet({'link': 'p0', 'status': LINK_STATUS_OPEN, 'setting': 10.0}))
|
|
set_pipe_reaction(p, ChangeSet({'pipe': 'p0', 'bulk': 10.0, 'wall': 20.0}))
|
|
set_vertex(p, ChangeSet({'link' : 'p0', 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
|
|
assert is_pipe(p, 'p0')
|
|
assert get_tag(p, TAG_TYPE_LINK, 'p0')['tag'] == 'p0t'
|
|
assert get_status(p, 'p0')['status'] == LINK_STATUS_OPEN
|
|
assert get_status(p, 'p0')['setting'] == 10.0
|
|
assert get_pipe_reaction(p, 'p0')['bulk'] == 10.0
|
|
assert get_pipe_reaction(p, 'p0')['wall'] == 20.0
|
|
assert get_vertex(p, 'p0')['coords'] == [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]
|
|
|
|
delete_pipe(p, ChangeSet({'id': 'p0'}))
|
|
assert is_pipe(p, 'p0') == False
|
|
assert get_tag(p, TAG_TYPE_LINK, 'p0')['tag'] == None
|
|
assert get_status(p, 'p0')['status'] == None
|
|
assert get_status(p, 'p0')['setting'] == None
|
|
assert get_pipe_reaction(p, 'p0')['bulk'] == None
|
|
assert get_pipe_reaction(p, 'p0')['wall'] == None
|
|
assert get_vertex(p, 'p0')['coords'] == []
|
|
|
|
execute_undo(p)
|
|
assert is_pipe(p, 'p0')
|
|
assert get_tag(p, TAG_TYPE_LINK, 'p0')['tag'] == 'p0t'
|
|
assert get_status(p, 'p0')['status'] == LINK_STATUS_OPEN
|
|
assert get_status(p, 'p0')['setting'] == 10.0
|
|
assert get_pipe_reaction(p, 'p0')['bulk'] == 10.0
|
|
assert get_pipe_reaction(p, 'p0')['wall'] == 20.0
|
|
assert get_vertex(p, 'p0')['coords'] == [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]
|
|
|
|
execute_redo(p)
|
|
assert is_pipe(p, 'p0') == False
|
|
assert get_tag(p, TAG_TYPE_LINK, 'p0')['tag'] == None
|
|
assert get_status(p, 'p0')['status'] == None
|
|
assert get_status(p, 'p0')['setting'] == None
|
|
assert get_pipe_reaction(p, 'p0')['bulk'] == None
|
|
assert get_pipe_reaction(p, 'p0')['wall'] == None
|
|
assert get_vertex(p, 'p0')['coords'] == []
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 6 pump
|
|
|
|
|
|
def test_pump(self):
|
|
p = 'test_pump'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
assert is_junction(p, 'j2')
|
|
assert is_junction(p, 'j3')
|
|
assert is_junction(p, 'j4')
|
|
|
|
assert get_pump(p, 'p0') == {}
|
|
|
|
add_pump(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'power': 0.0}))
|
|
p0 = get_pump(p, 'p0')
|
|
assert p0['node1'] == 'j1'
|
|
assert p0['node2'] == 'j2'
|
|
assert p0['power'] == 0.0
|
|
assert p0['head'] == None
|
|
assert p0['speed'] == None
|
|
assert p0['pattern'] == None
|
|
|
|
set_pump(p, ChangeSet({'id': 'p0', 'node1': 'j3', 'node2': 'j4'}))
|
|
p0 = get_pump(p, 'p0')
|
|
assert p0['node1'] == 'j3'
|
|
assert p0['node2'] == 'j4'
|
|
|
|
set_pump(p, ChangeSet({'id': 'p0', 'power': 100.0}))
|
|
p0 = get_pump(p, 'p0')
|
|
assert p0['power'] == 100.0
|
|
|
|
add_pump(p, ChangeSet({'id': 'p1', 'node1': 'j1', 'node2': 'j2', 'power': 0.0}))
|
|
links = get_links(p)
|
|
assert len(links) == 2
|
|
assert links[0] == 'p0'
|
|
assert links[1] == 'p1'
|
|
assert is_pump(p, 'p0')
|
|
assert is_pump(p, 'p1')
|
|
|
|
delete_pump(p, ChangeSet({'id': 'p1'}))
|
|
links = get_links(p)
|
|
assert len(links) == 1
|
|
assert links[0] == 'p0'
|
|
|
|
delete_pump(p, ChangeSet({'id': 'p0'}))
|
|
links = get_links(p)
|
|
assert len(links) == 0
|
|
|
|
assert get_pump(p, 'p0') == {}
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_pump_op(self):
|
|
p = 'test_pump_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
assert is_junction(p, 'j2')
|
|
assert is_junction(p, 'j3')
|
|
assert is_junction(p, 'j4')
|
|
|
|
cs = add_pump(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'power': 0.0})).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == PUMP
|
|
assert cs['id'] == 'p0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
assert cs['power'] == 0.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == PUMP
|
|
assert cs['id'] == 'p0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == PUMP
|
|
assert cs['id'] == 'p0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == PUMP
|
|
assert cs['id'] == 'p0'
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
|
|
links = get_links(p)
|
|
assert len(links) == 0
|
|
|
|
add_pump(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'power': 0.0}))
|
|
|
|
links = get_links(p)
|
|
assert len(links) == 1
|
|
|
|
cs = delete_pump(p, ChangeSet({'id': 'p0'})).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == PUMP
|
|
assert cs['id'] == 'p0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == PUMP
|
|
assert cs['id'] == 'p0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == PUMP
|
|
assert cs['id'] == 'p0'
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == PUMP
|
|
assert cs['id'] == 'p0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
|
|
links = get_links(p)
|
|
assert len(links) == 1
|
|
|
|
cs = set_pump(p, ChangeSet({'id': 'p0', 'node1': 'j3', 'node2': 'j4'})).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == PUMP
|
|
assert cs['id'] == 'p0'
|
|
assert cs['node1'] == 'j3'
|
|
assert cs['node2'] == 'j4'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == PUMP
|
|
assert cs['id'] == 'p0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
|
|
cs = set_pump(p, ChangeSet({'id': 'p0', 'power': 100.0})).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == PUMP
|
|
assert cs['id'] == 'p0'
|
|
assert cs['power'] == 100.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == PUMP
|
|
assert cs['id'] == 'p0'
|
|
assert cs['power'] == 0.0
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_pump_del(self):
|
|
p = 'test_pump_del'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pump(p, ChangeSet({'id': 'p0', 'node1': 'j0', 'node2': 'j1', 'power': 0.0}))
|
|
set_tag(p, ChangeSet({'t_type': TAG_TYPE_LINK, 'id': 'p0', 'tag': 'p0t' }))
|
|
set_status(p, ChangeSet({'link': 'p0', 'status': LINK_STATUS_OPEN, 'setting': 10.0}))
|
|
set_pump_energy(p, ChangeSet({'pump' : 'p0', 'price': 1.0}))
|
|
set_vertex(p, ChangeSet({'link' : 'p0', 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
|
|
assert is_pump(p, 'p0')
|
|
assert get_tag(p, TAG_TYPE_LINK, 'p0')['tag'] == 'p0t'
|
|
assert get_status(p, 'p0')['status'] == LINK_STATUS_OPEN
|
|
assert get_status(p, 'p0')['setting'] == 10.0
|
|
assert get_pump_energy(p, 'p0')['price'] == 1.0
|
|
assert get_vertex(p, 'p0')['coords'] == [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]
|
|
|
|
delete_pump(p, ChangeSet({'id': 'p0'}))
|
|
assert is_pump(p, 'p0') == False
|
|
assert get_tag(p, TAG_TYPE_LINK, 'p0')['tag'] == None
|
|
assert get_status(p, 'p0')['status'] == None
|
|
assert get_status(p, 'p0')['setting'] == None
|
|
assert get_pump_energy(p, 'p0')['price'] == None
|
|
assert get_vertex(p, 'p0')['coords'] == []
|
|
|
|
execute_undo(p)
|
|
assert is_pump(p, 'p0')
|
|
assert get_tag(p, TAG_TYPE_LINK, 'p0')['tag'] == 'p0t'
|
|
assert get_status(p, 'p0')['status'] == LINK_STATUS_OPEN
|
|
assert get_status(p, 'p0')['setting'] == 10.0
|
|
assert get_pump_energy(p, 'p0')['price'] == 1.0
|
|
assert get_vertex(p, 'p0')['coords'] == [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]
|
|
|
|
execute_redo(p)
|
|
assert is_pump(p, 'p0') == False
|
|
assert get_tag(p, TAG_TYPE_LINK, 'p0')['tag'] == None
|
|
assert get_status(p, 'p0')['status'] == None
|
|
assert get_status(p, 'p0')['setting'] == None
|
|
assert get_pump_energy(p, 'p0')['price'] == None
|
|
assert get_vertex(p, 'p0')['coords'] == []
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 7 valve
|
|
|
|
|
|
def test_valve(self):
|
|
p = 'test_valve'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
assert is_junction(p, 'j2')
|
|
assert is_junction(p, 'j3')
|
|
assert is_junction(p, 'j4')
|
|
|
|
assert get_valve(p, 'v0') == {}
|
|
|
|
add_valve(p, ChangeSet({'id': 'v0', 'node1': 'j1', 'node2': 'j2', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': '0.1', 'minor_loss': 0.5 }))
|
|
v0 = get_valve(p, 'v0')
|
|
assert v0['node1'] == 'j1'
|
|
assert v0['node2'] == 'j2'
|
|
assert v0['diameter'] == 10.0
|
|
assert v0['v_type'] == VALVES_TYPE_FCV
|
|
assert v0['setting'] == '0.1'
|
|
assert v0['minor_loss'] == 0.5
|
|
|
|
set_valve(p, ChangeSet({'id': 'v0', 'node1': 'j3', 'node2': 'j4'}))
|
|
v0 = get_valve(p, 'v0')
|
|
assert v0['node1'] == 'j3'
|
|
assert v0['node2'] == 'j4'
|
|
|
|
set_valve(p, ChangeSet({'id': 'v0', 'diameter': 100.0}))
|
|
v0 = get_valve(p, 'v0')
|
|
assert v0['diameter'] == 100.0
|
|
|
|
set_valve(p, ChangeSet({'id': 'v0', 'v_type': VALVES_TYPE_GPV}))
|
|
v0 = get_valve(p, 'v0')
|
|
assert v0['v_type'] == VALVES_TYPE_GPV
|
|
|
|
set_valve(p, ChangeSet({'id': 'v0', 'setting': '0.2'}))
|
|
v0 = get_valve(p, 'v0')
|
|
assert v0['setting'] == '0.2'
|
|
|
|
set_valve(p, ChangeSet({'id': 'v0', 'minor_loss': 0.1}))
|
|
v0 = get_valve(p, 'v0')
|
|
assert v0['minor_loss'] == 0.1
|
|
|
|
add_valve(p, ChangeSet({'id': 'v1', 'node1': 'j1', 'node2': 'j2', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': '0.1', 'minor_loss': 0.5 }))
|
|
links = get_links(p)
|
|
assert len(links) == 2
|
|
assert links[0] == 'v0'
|
|
assert links[1] == 'v1'
|
|
assert is_valve(p, 'v0')
|
|
assert is_valve(p, 'v1')
|
|
|
|
delete_valve(p, ChangeSet({'id': 'v1'}))
|
|
links = get_links(p)
|
|
assert len(links) == 1
|
|
assert links[0] == 'v0'
|
|
|
|
delete_valve(p, ChangeSet({'id': 'v0'}))
|
|
links = get_links(p)
|
|
assert len(links) == 0
|
|
|
|
assert get_valve(p, 'v0') == {}
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_valve_op(self):
|
|
p = 'test_valve_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
assert is_junction(p, 'j2')
|
|
assert is_junction(p, 'j3')
|
|
assert is_junction(p, 'j4')
|
|
|
|
cs = add_valve(p, ChangeSet({'id': 'v0', 'node1': 'j1', 'node2': 'j2', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': '0.1', 'minor_loss': 0.5 })).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == VALVE
|
|
assert cs['id'] == 'v0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['v_type'] == VALVES_TYPE_FCV
|
|
assert cs['setting'] == '0.1'
|
|
assert cs['minor_loss'] == 0.5
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == VALVE
|
|
assert cs['id'] == 'v0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == VALVE
|
|
assert cs['id'] == 'v0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['v_type'] == VALVES_TYPE_FCV
|
|
assert cs['setting'] == '0.1'
|
|
assert cs['minor_loss'] == 0.5
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == VALVE
|
|
assert cs['id'] == 'v0'
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
|
|
links = get_links(p)
|
|
assert len(links) == 0
|
|
|
|
add_valve(p, ChangeSet({'id': 'v0', 'node1': 'j1', 'node2': 'j2', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': '0.1', 'minor_loss': 0.5 }))
|
|
|
|
links = get_links(p)
|
|
assert len(links) == 1
|
|
|
|
cs = delete_valve(p, ChangeSet({'id': 'v0'})).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == VALVE
|
|
assert cs['id'] == 'v0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == VALVE
|
|
assert cs['id'] == 'v0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['v_type'] == VALVES_TYPE_FCV
|
|
assert cs['setting'] == '0.1'
|
|
assert cs['minor_loss'] == 0.5
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == 'delete'
|
|
assert cs['type'] == VALVE
|
|
assert cs['id'] == 'v0'
|
|
|
|
cs = execute_undo(p, True).operations[0]
|
|
assert cs['operation'] == 'add'
|
|
assert cs['type'] == VALVE
|
|
assert cs['id'] == 'v0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['v_type'] == VALVES_TYPE_FCV
|
|
assert cs['setting'] == '0.1'
|
|
assert cs['minor_loss'] == 0.5
|
|
|
|
cs = execute_redo(p)
|
|
assert len(cs.operations) == 0
|
|
|
|
links = get_links(p)
|
|
assert len(links) == 1
|
|
|
|
cs = set_valve(p, ChangeSet({'id': 'v0', 'node1': 'j3', 'node2': 'j4'})).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == VALVE
|
|
assert cs['id'] == 'v0'
|
|
assert cs['node1'] == 'j3'
|
|
assert cs['node2'] == 'j4'
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['v_type'] == VALVES_TYPE_FCV
|
|
assert cs['setting'] == '0.1'
|
|
assert cs['minor_loss'] == 0.5
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == 'update'
|
|
assert cs['type'] == VALVE
|
|
assert cs['id'] == 'v0'
|
|
assert cs['node1'] == 'j1'
|
|
assert cs['node2'] == 'j2'
|
|
assert cs['diameter'] == 10.0
|
|
assert cs['v_type'] == VALVES_TYPE_FCV
|
|
assert cs['setting'] == '0.1'
|
|
assert cs['minor_loss'] == 0.5
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_valve_del(self):
|
|
p = 'test_valve_del'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_valve(p, ChangeSet({'id': 'v0', 'node1': 'j0', 'node2': 'j1', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': '0.1', 'minor_loss': 0.5 }))
|
|
set_tag(p, ChangeSet({'t_type': TAG_TYPE_LINK, 'id': 'v0', 'tag': 'v0t' }))
|
|
set_status(p, ChangeSet({'link': 'v0', 'status': LINK_STATUS_OPEN, 'setting': 10.0}))
|
|
set_vertex(p, ChangeSet({'link' : 'v0', 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
|
|
assert is_valve(p, 'v0')
|
|
assert get_tag(p, TAG_TYPE_LINK, 'v0')['tag'] == 'v0t'
|
|
assert get_status(p, 'v0')['status'] == LINK_STATUS_OPEN
|
|
assert get_status(p, 'v0')['setting'] == 10.0
|
|
assert get_vertex(p, 'v0')['coords'] == [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]
|
|
|
|
delete_valve(p, ChangeSet({'id': 'v0'}))
|
|
assert is_valve(p, 'v0') == False
|
|
assert get_tag(p, TAG_TYPE_LINK, 'v0')['tag'] == None
|
|
assert get_status(p, 'v0')['status'] == None
|
|
assert get_status(p, 'v0')['setting'] == None
|
|
assert get_vertex(p, 'v0')['coords'] == []
|
|
|
|
execute_undo(p)
|
|
assert is_valve(p, 'v0')
|
|
assert get_tag(p, TAG_TYPE_LINK, 'v0')['tag'] == 'v0t'
|
|
assert get_status(p, 'v0')['status'] == LINK_STATUS_OPEN
|
|
assert get_status(p, 'v0')['setting'] == 10.0
|
|
assert get_vertex(p, 'v0')['coords'] == [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]
|
|
|
|
execute_redo(p)
|
|
assert is_valve(p, 'v0') == False
|
|
assert get_tag(p, TAG_TYPE_LINK, 'v0')['tag'] == None
|
|
assert get_status(p, 'v0')['status'] == None
|
|
assert get_status(p, 'v0')['setting'] == None
|
|
assert get_vertex(p, 'v0')['coords'] == []
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 8 tag
|
|
|
|
|
|
def test_tag(self):
|
|
p = 'test_tag'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
assert is_junction(p, 'j2')
|
|
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
assert is_pipe(p, 'p0')
|
|
|
|
t = get_tag(p, TAG_TYPE_NODE, 'j1')
|
|
assert t['tag'] == None
|
|
set_tag(p, ChangeSet({'t_type': TAG_TYPE_NODE, 'id': 'j1', 'tag': 'j1t' }))
|
|
t = get_tag(p, TAG_TYPE_NODE, 'j1')
|
|
assert t['tag'] == 'j1t'
|
|
|
|
tags = get_tags(p)
|
|
assert len(tags) == 1
|
|
assert tags[0]['t_type'] == TAG_TYPE_NODE
|
|
assert tags[0]['id'] == 'j1'
|
|
assert tags[0]['tag'] == 'j1t'
|
|
|
|
set_tag(p, ChangeSet({'t_type': TAG_TYPE_NODE, 'id': 'j1', 'tag': None }))
|
|
t = get_tag(p, TAG_TYPE_NODE, 'j1')
|
|
assert t['tag'] == None
|
|
|
|
tags = get_tags(p)
|
|
assert len(tags) == 0
|
|
|
|
t = get_tag(p, TAG_TYPE_NODE, 'j2')
|
|
assert t['tag'] == None
|
|
set_tag(p, ChangeSet({'t_type': TAG_TYPE_NODE, 'id': 'j2', 'tag': 'j2t' }))
|
|
t = get_tag(p, TAG_TYPE_NODE, 'j2')
|
|
assert t['tag'] == 'j2t'
|
|
|
|
t = get_tag(p, TAG_TYPE_LINK, 'p0')
|
|
assert t['tag'] == None
|
|
set_tag(p, ChangeSet({'t_type': TAG_TYPE_LINK, 'id': 'p0', 'tag': 'p0t' }))
|
|
t = get_tag(p, TAG_TYPE_LINK, 'p0')
|
|
assert t['tag'] == 'p0t'
|
|
|
|
tags = get_tags(p)
|
|
assert len(tags) == 2
|
|
assert tags[0]['t_type'] == TAG_TYPE_NODE
|
|
assert tags[0]['id'] == 'j2'
|
|
assert tags[0]['tag'] == 'j2t'
|
|
assert tags[1]['t_type'] == TAG_TYPE_LINK
|
|
assert tags[1]['id'] == 'p0'
|
|
assert tags[1]['tag'] == 'p0t'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_tag_op(self):
|
|
p = 'test_tag_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
assert is_junction(p, 'j2')
|
|
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
assert is_pipe(p, 'p0')
|
|
|
|
cs = set_tag(p, ChangeSet({'t_type': TAG_TYPE_NODE, 'id': 'j1', 'tag': 'j1t' })).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'tag'
|
|
assert cs['t_type'] == TAG_TYPE_NODE
|
|
assert cs['id'] == 'j1'
|
|
assert cs['tag'] == 'j1t'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'tag'
|
|
assert cs['t_type'] == TAG_TYPE_NODE
|
|
assert cs['id'] == 'j1'
|
|
assert cs['tag'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'tag'
|
|
assert cs['t_type'] == TAG_TYPE_NODE
|
|
assert cs['id'] == 'j1'
|
|
assert cs['tag'] == 'j1t'
|
|
|
|
cs = set_tag(p, ChangeSet({'t_type': TAG_TYPE_LINK, 'id': 'p0', 'tag': 'p0t' })).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'tag'
|
|
assert cs['t_type'] == TAG_TYPE_LINK
|
|
assert cs['id'] == 'p0'
|
|
assert cs['tag'] == 'p0t'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'tag'
|
|
assert cs['t_type'] == TAG_TYPE_LINK
|
|
assert cs['id'] == 'p0'
|
|
assert cs['tag'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'tag'
|
|
assert cs['t_type'] == TAG_TYPE_LINK
|
|
assert cs['id'] == 'p0'
|
|
assert cs['tag'] == 'p0t'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 9 demand
|
|
|
|
|
|
def test_demand(self):
|
|
p = 'test_demand'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
|
|
d = get_demand(p, 'j1')
|
|
assert d['junction'] == 'j1'
|
|
assert d['demands'] == []
|
|
|
|
set_demand(p, ChangeSet({'junction': 'j1', 'demands': [{'demand': 10.0, 'pattern': None, 'category': 'x'},
|
|
{'demand': 20.0, 'pattern': None, 'category': None}]}))
|
|
|
|
d = get_demand(p, 'j1')
|
|
assert d['junction'] == 'j1'
|
|
ds = d['demands']
|
|
assert len(ds) == 2
|
|
assert ds[0]['demand'] == 10.0
|
|
assert ds[0]['pattern'] == None
|
|
assert ds[0]['category'] == 'x'
|
|
assert ds[1]['demand'] == 20.0
|
|
assert ds[1]['pattern'] == None
|
|
assert ds[1]['category'] == None
|
|
|
|
set_demand(p, ChangeSet({'junction': 'j1', 'demands': []}))
|
|
|
|
d = get_demand(p, 'j1')
|
|
assert d['junction'] == 'j1'
|
|
assert d['demands'] == []
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_demand_op(self):
|
|
p = 'test_demand_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
|
|
result = set_demand(p, ChangeSet({'junction': 'j1', 'demands': [{'demand': 10.0, 'pattern': None, 'category': 'x'},
|
|
{'demand': 20.0, 'pattern': None, 'category': None}]}))
|
|
cs = result.operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'demand'
|
|
assert cs['junction'] == 'j1'
|
|
ds = cs['demands']
|
|
assert len(ds) == 2
|
|
assert ds[0]['demand'] == 10.0
|
|
assert ds[0]['pattern'] == None
|
|
assert ds[0]['category'] == 'x'
|
|
assert ds[1]['demand'] == 20.0
|
|
assert ds[1]['pattern'] == None
|
|
assert ds[1]['category'] == None
|
|
|
|
result = execute_undo(p)
|
|
cs = result.operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'demand'
|
|
assert cs['junction'] == 'j1'
|
|
assert len(cs['demands']) == 0
|
|
|
|
result = execute_redo(p)
|
|
cs = result.operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'demand'
|
|
assert cs['junction'] == 'j1'
|
|
ds = cs['demands']
|
|
assert len(ds) == 2
|
|
assert ds[0]['demand'] == 10.0
|
|
assert ds[0]['pattern'] == None
|
|
assert ds[0]['category'] == 'x'
|
|
assert ds[1]['demand'] == 20.0
|
|
assert ds[1]['pattern'] == None
|
|
assert ds[1]['category'] == None
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 10 status
|
|
|
|
|
|
def test_status(self):
|
|
p = 'test_status'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
assert is_junction(p, 'j2')
|
|
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
assert is_pipe(p, 'p0')
|
|
|
|
s = get_status(p, 'p0')
|
|
assert s['link'] == 'p0'
|
|
assert s['status'] == None
|
|
assert s['setting'] == None
|
|
|
|
set_status(p, ChangeSet({'link': 'p0', 'status': LINK_STATUS_OPEN, 'setting': 10.0}))
|
|
s = get_status(p, 'p0')
|
|
assert s['link'] == 'p0'
|
|
assert s['status'] == LINK_STATUS_OPEN
|
|
assert s['setting'] == 10.0
|
|
|
|
set_status(p, ChangeSet({'link': 'p0', 'status': None, 'setting': None}))
|
|
s = get_status(p, 'p0')
|
|
assert s['link'] == 'p0'
|
|
assert s['status'] == None
|
|
assert s['setting'] == None
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_status_op(self):
|
|
p = 'test_status_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
assert is_junction(p, 'j2')
|
|
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
assert is_pipe(p, 'p0')
|
|
|
|
s = get_status(p, 'p0')
|
|
assert s['link'] == 'p0'
|
|
assert s['status'] == None
|
|
assert s['setting'] == None
|
|
|
|
cs = set_status(p, ChangeSet({'link': 'p0', 'status': LINK_STATUS_OPEN, 'setting': 10.0})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'status'
|
|
assert cs['link'] == 'p0'
|
|
assert cs['status'] == LINK_STATUS_OPEN
|
|
assert cs['setting'] == 10.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'status'
|
|
assert cs['link'] == 'p0'
|
|
assert cs['status'] == None
|
|
assert cs['setting'] == None
|
|
|
|
s = get_status(p, 'p0')
|
|
assert s['link'] == 'p0'
|
|
assert s['status'] == None
|
|
assert s['setting'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'status'
|
|
assert cs['link'] == 'p0'
|
|
assert cs['status'] == LINK_STATUS_OPEN
|
|
assert cs['setting'] == 10.0
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 11 pattern
|
|
|
|
|
|
def test_pattern(self):
|
|
p = 'test_pattern'
|
|
self.enter(p)
|
|
|
|
assert is_pattern(p, 'p0') == False
|
|
|
|
assert get_pattern(p, 'p0') == {}
|
|
|
|
add_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]}))
|
|
|
|
assert is_pattern(p, 'p0')
|
|
p0 = get_pattern(p, 'p0')
|
|
assert p0['id'] == 'p0'
|
|
assert p0['factors'] == [1.0, 2.0, 3.0]
|
|
|
|
set_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0]}))
|
|
|
|
assert is_pattern(p, 'p0')
|
|
p0 = get_pattern(p, 'p0')
|
|
assert p0['id'] == 'p0'
|
|
assert p0['factors'] == [1.0, 2.0]
|
|
|
|
set_pattern(p, ChangeSet({'id' : 'p0', 'factors': []}))
|
|
|
|
assert is_pattern(p, 'p0')
|
|
p0 = get_pattern(p, 'p0')
|
|
assert p0['id'] == 'p0'
|
|
assert p0['factors'] == []
|
|
|
|
delete_pattern(p, ChangeSet({'id' : 'p0'}))
|
|
assert is_pattern(p, 'p0') == False
|
|
|
|
assert get_pattern(p, 'p0') == {}
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_pattern_op(self):
|
|
p = 'test_pattern_op'
|
|
self.enter(p)
|
|
|
|
cs = add_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == PATTERN
|
|
assert cs['id'] == 'p0'
|
|
assert cs['factors'] == [1.0, 2.0, 3.0]
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == PATTERN
|
|
assert cs['id'] == 'p0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == PATTERN
|
|
assert cs['id'] == 'p0'
|
|
assert cs['factors'] == [1.0, 2.0, 3.0]
|
|
|
|
cs = set_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0]})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == PATTERN
|
|
assert cs['id'] == 'p0'
|
|
assert cs['factors'] == [1.0, 2.0]
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == PATTERN
|
|
assert cs['id'] == 'p0'
|
|
assert cs['factors'] == [1.0, 2.0, 3.0]
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == PATTERN
|
|
assert cs['id'] == 'p0'
|
|
assert cs['factors'] == [1.0, 2.0]
|
|
|
|
cs = set_pattern(p, ChangeSet({'id' : 'p0', 'factors': []})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == PATTERN
|
|
assert cs['id'] == 'p0'
|
|
assert cs['factors'] == []
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == PATTERN
|
|
assert cs['id'] == 'p0'
|
|
assert cs['factors'] == [1.0, 2.0]
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == PATTERN
|
|
assert cs['id'] == 'p0'
|
|
assert cs['factors'] == []
|
|
|
|
cs = delete_pattern(p, ChangeSet({'id' : 'p0'})).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == PATTERN
|
|
assert cs['id'] == 'p0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == PATTERN
|
|
assert cs['id'] == 'p0'
|
|
assert cs['factors'] == []
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == PATTERN
|
|
assert cs['id'] == 'p0'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_pattern_del(self):
|
|
p = 'test_pattern_del'
|
|
self.enter(p)
|
|
|
|
add_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]}))
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_reservoir(p, ChangeSet({'id': 'r0', 'x': 0.0, 'y': 10.0, 'head': 20.0, 'pattern': 'p0'}))
|
|
add_pump(p, ChangeSet({'id': 'pump0', 'node1': 'j0', 'node2': 'r0', 'power': 0.0, 'pattern': 'p0'}))
|
|
set_demand(p, ChangeSet({'junction': 'j0', 'demands': [{'demand': 10.0, 'pattern': 'p0', 'category': 'x'}, {'demand': 20.0, 'pattern': 'p0', 'category': None}]}))
|
|
set_pump_energy(p, ChangeSet({'pump' : 'pump0', 'pattern': 'p0'}))
|
|
add_source(p, ChangeSet({'node': 'j0', 's_type': SOURCE_TYPE_CONCEN, 'strength': 10.0, 'pattern': 'p0' }))
|
|
assert is_pattern(p, 'p0')
|
|
assert get_reservoir(p, 'r0')['pattern'] == 'p0'
|
|
assert get_pump(p, 'pump0')['pattern'] == 'p0'
|
|
assert get_demand(p, 'j0')['demands'] == [{'demand': 10.0, 'pattern': 'p0', 'category': 'x'}, {'demand': 20.0, 'pattern': 'p0', 'category': None}]
|
|
assert get_pump_energy(p, 'pump0')['pattern'] == 'p0'
|
|
assert get_source(p, 'j0')['pattern'] == 'p0'
|
|
|
|
delete_pattern(p, ChangeSet({'id': 'p0'}))
|
|
assert is_pattern(p, 'p0') == False
|
|
assert get_reservoir(p, 'r0')['pattern'] == None
|
|
assert get_pump(p, 'pump0')['pattern'] == None
|
|
assert get_demand(p, 'j0')['demands'] == [{'demand': 10.0, 'pattern': None, 'category': 'x'}, {'demand': 20.0, 'pattern': None, 'category': None}]
|
|
assert get_pump_energy(p, 'pump0')['pattern'] == None
|
|
assert get_source(p, 'j0')['pattern'] == None
|
|
|
|
execute_undo(p)
|
|
assert is_pattern(p, 'p0')
|
|
assert get_reservoir(p, 'r0')['pattern'] == 'p0'
|
|
assert get_pump(p, 'pump0')['pattern'] == 'p0'
|
|
assert get_demand(p, 'j0')['demands'] == [{'demand': 10.0, 'pattern': 'p0', 'category': 'x'}, {'demand': 20.0, 'pattern': 'p0', 'category': None}]
|
|
assert get_pump_energy(p, 'pump0')['pattern'] == 'p0'
|
|
assert get_source(p, 'j0')['pattern'] == 'p0'
|
|
|
|
execute_redo(p)
|
|
assert is_pattern(p, 'p0') == False
|
|
assert get_reservoir(p, 'r0')['pattern'] == None
|
|
assert get_pump(p, 'pump0')['pattern'] == None
|
|
assert get_demand(p, 'j0')['demands'] == [{'demand': 10.0, 'pattern': None, 'category': 'x'}, {'demand': 20.0, 'pattern': None, 'category': None}]
|
|
assert get_pump_energy(p, 'pump0')['pattern'] == None
|
|
assert get_source(p, 'j0')['pattern'] == None
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 12 curve
|
|
|
|
|
|
def test_curve(self):
|
|
p = 'test_curve'
|
|
self.enter(p)
|
|
|
|
assert is_curve(p, 'c0') == False
|
|
|
|
assert get_curve(p, 'c0') == {}
|
|
|
|
add_curve(p, ChangeSet({'id' : 'c0', 'c_type' : CURVE_TYPE_PUMP, 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
|
|
|
|
assert is_curve(p, 'c0')
|
|
c0 = get_curve(p, 'c0')
|
|
assert c0['id'] == 'c0'
|
|
assert c0['c_type'] == CURVE_TYPE_PUMP
|
|
xys = c0['coords']
|
|
assert len(xys) == 2
|
|
assert xys[0]['x'] == 1.0
|
|
assert xys[0]['y'] == 2.0
|
|
assert xys[1]['x'] == 2.0
|
|
assert xys[1]['y'] == 1.0
|
|
|
|
set_curve(p, ChangeSet({'id' : 'c0', 'c_type': CURVE_TYPE_EFFICIENCY}))
|
|
|
|
c0 = get_curve(p, 'c0')
|
|
assert c0['id'] == 'c0'
|
|
assert c0['c_type'] == CURVE_TYPE_EFFICIENCY
|
|
xys = c0['coords']
|
|
assert len(xys) == 2
|
|
assert xys[0]['x'] == 1.0
|
|
assert xys[0]['y'] == 2.0
|
|
assert xys[1]['x'] == 2.0
|
|
assert xys[1]['y'] == 1.0
|
|
|
|
set_curve(p, ChangeSet({'id' : 'c0', 'coords': []}))
|
|
|
|
c0 = get_curve(p, 'c0')
|
|
assert c0['id'] == 'c0'
|
|
assert c0['c_type'] == CURVE_TYPE_EFFICIENCY
|
|
assert c0['coords'] == []
|
|
|
|
delete_curve(p, ChangeSet({'id' : 'c0'}))
|
|
|
|
assert is_curve(p, 'c0') == False
|
|
|
|
assert get_curve(p, 'c0') == {}
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_curve_op(self):
|
|
p = 'test_curve_op'
|
|
self.enter(p)
|
|
|
|
cs = add_curve(p, ChangeSet({'id' : 'c0', 'c_type' : CURVE_TYPE_PUMP, 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == CURVE
|
|
assert cs['id'] == 'c0'
|
|
assert cs['c_type'] == CURVE_TYPE_PUMP
|
|
xys = cs['coords']
|
|
assert len(xys) == 2
|
|
assert xys[0]['x'] == 1.0
|
|
assert xys[0]['y'] == 2.0
|
|
assert xys[1]['x'] == 2.0
|
|
assert xys[1]['y'] == 1.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == CURVE
|
|
assert cs['id'] == 'c0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == CURVE
|
|
assert cs['id'] == 'c0'
|
|
assert cs['c_type'] == CURVE_TYPE_PUMP
|
|
xys = cs['coords']
|
|
assert len(xys) == 2
|
|
assert xys[0]['x'] == 1.0
|
|
assert xys[0]['y'] == 2.0
|
|
assert xys[1]['x'] == 2.0
|
|
assert xys[1]['y'] == 1.0
|
|
|
|
cs = set_curve(p, ChangeSet({'id' : 'c0', 'c_type': CURVE_TYPE_EFFICIENCY})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == CURVE
|
|
assert cs['id'] == 'c0'
|
|
assert cs['c_type'] == CURVE_TYPE_EFFICIENCY
|
|
xys = cs['coords']
|
|
assert len(xys) == 2
|
|
assert xys[0]['x'] == 1.0
|
|
assert xys[0]['y'] == 2.0
|
|
assert xys[1]['x'] == 2.0
|
|
assert xys[1]['y'] == 1.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == CURVE
|
|
assert cs['id'] == 'c0'
|
|
assert cs['c_type'] == CURVE_TYPE_PUMP
|
|
xys = cs['coords']
|
|
assert len(xys) == 2
|
|
assert xys[0]['x'] == 1.0
|
|
assert xys[0]['y'] == 2.0
|
|
assert xys[1]['x'] == 2.0
|
|
assert xys[1]['y'] == 1.0
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == CURVE
|
|
assert cs['id'] == 'c0'
|
|
assert cs['c_type'] == CURVE_TYPE_EFFICIENCY
|
|
xys = cs['coords']
|
|
assert len(xys) == 2
|
|
assert xys[0]['x'] == 1.0
|
|
assert xys[0]['y'] == 2.0
|
|
assert xys[1]['x'] == 2.0
|
|
assert xys[1]['y'] == 1.0
|
|
|
|
cs = set_curve(p, ChangeSet({'id' : 'c0', 'coords': []})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == CURVE
|
|
assert cs['id'] == 'c0'
|
|
assert cs['c_type'] == CURVE_TYPE_EFFICIENCY
|
|
assert cs['coords'] == []
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == CURVE
|
|
assert cs['id'] == 'c0'
|
|
assert cs['c_type'] == CURVE_TYPE_EFFICIENCY
|
|
xys = cs['coords']
|
|
assert len(xys) == 2
|
|
assert xys[0]['x'] == 1.0
|
|
assert xys[0]['y'] == 2.0
|
|
assert xys[1]['x'] == 2.0
|
|
assert xys[1]['y'] == 1.0
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == CURVE
|
|
assert cs['id'] == 'c0'
|
|
assert cs['c_type'] == CURVE_TYPE_EFFICIENCY
|
|
assert cs['coords'] == []
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_curve_del(self):
|
|
p = 'test_curve_del'
|
|
self.enter(p)
|
|
|
|
add_curve(p, ChangeSet({'id' : 'c0', 'c_type' : CURVE_TYPE_PUMP, 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
|
|
add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': 'c0', 'overflow': OVERFLOW_NO}))
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'pattern': None}))
|
|
add_reservoir(p, ChangeSet({'id': 'r0', 'x': 0.0, 'y': 10.0, 'head': 20.0, 'pattern': None}))
|
|
add_pump(p, ChangeSet({'id': 'p0', 'node1': 'j0', 'node2': 'r0', 'head': 'c0'}))
|
|
set_pump_energy(p, ChangeSet({'pump' : 'p0', 'effic': 'c0'}))
|
|
assert is_curve(p, 'c0')
|
|
assert get_tank(p, 't0')['vol_curve'] == 'c0'
|
|
assert get_pump(p, 'p0')['head'] == 'c0'
|
|
assert get_pump_energy(p, 'p0')['effic'] == 'c0'
|
|
|
|
delete_curve(p, ChangeSet({'id': 'c0'}))
|
|
assert is_curve(p, 'c0') == False
|
|
assert get_tank(p, 't0')['vol_curve'] == None
|
|
assert get_pump(p, 'p0')['head'] == None
|
|
assert get_pump_energy(p, 'p0')['effic'] == None
|
|
|
|
execute_undo(p)
|
|
assert is_curve(p, 'c0')
|
|
assert get_tank(p, 't0')['vol_curve'] == 'c0'
|
|
assert get_pump(p, 'p0')['head'] == 'c0'
|
|
assert get_pump_energy(p, 'p0')['effic'] == 'c0'
|
|
|
|
execute_redo(p)
|
|
assert is_curve(p, 'c0') == False
|
|
assert get_tank(p, 't0')['vol_curve'] == None
|
|
assert get_pump(p, 'p0')['head'] == None
|
|
assert get_pump_energy(p, 'p0')['effic'] == None
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 13 control
|
|
|
|
|
|
def test_control(self):
|
|
p = 'test_control'
|
|
self.enter(p)
|
|
|
|
assert get_control(p)['controls'] == []
|
|
|
|
set_control(p, ChangeSet({'controls': ['x']}))
|
|
assert get_control(p)['controls'] == ['x']
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_control_op(self):
|
|
p = 'test_control_op'
|
|
self.enter(p)
|
|
|
|
cs = set_control(p, ChangeSet({'controls': ['x']})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'control'
|
|
assert cs['controls'] == ['x']
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'control'
|
|
assert cs['controls'] == []
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'control'
|
|
assert cs['controls'] == ['x']
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 14 rule
|
|
|
|
|
|
def test_rule(self):
|
|
p = 'test_rule'
|
|
self.enter(p)
|
|
|
|
assert get_rule(p)['rules'] == []
|
|
|
|
set_rule(p, ChangeSet({'rules': ['x']}))
|
|
assert get_rule(p)['rules'] == ['x']
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_rule_op(self):
|
|
p = 'test_rule_op'
|
|
self.enter(p)
|
|
|
|
cs = set_rule(p, ChangeSet({'rules': ['x']})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'rule'
|
|
assert cs['rules'] == ['x']
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'rule'
|
|
assert cs['rules'] == []
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'rule'
|
|
assert cs['rules'] == ['x']
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 15 energy
|
|
|
|
|
|
def test_energy(self):
|
|
p = 'test_energy'
|
|
self.enter(p)
|
|
|
|
ge = get_energy(p)
|
|
assert ge['GLOBAL PRICE'] == '0'
|
|
assert ge['GLOBAL PATTERN'] == ''
|
|
assert ge['GLOBAL EFFIC'] == '75'
|
|
assert ge['DEMAND CHARGE'] == '0'
|
|
|
|
set_energy(p, ChangeSet({ 'GLOBAL PRICE' : '10' }))
|
|
ge = get_energy(p)
|
|
assert ge['GLOBAL PRICE'] == '10'
|
|
assert ge['GLOBAL PATTERN'] == ''
|
|
assert ge['GLOBAL EFFIC'] == '75'
|
|
assert ge['DEMAND CHARGE'] == '0'
|
|
|
|
add_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]}))
|
|
set_energy(p, ChangeSet({ 'GLOBAL PATTERN' : 'p0' }))
|
|
ge = get_energy(p)
|
|
assert ge['GLOBAL PRICE'] == '10'
|
|
assert ge['GLOBAL PATTERN'] == 'p0'
|
|
assert ge['GLOBAL EFFIC'] == '75'
|
|
assert ge['DEMAND CHARGE'] == '0'
|
|
|
|
set_energy(p, ChangeSet({ 'GLOBAL EFFIC' : '0' }))
|
|
ge = get_energy(p)
|
|
assert ge['GLOBAL PRICE'] == '10'
|
|
assert ge['GLOBAL PATTERN'] == 'p0'
|
|
assert ge['GLOBAL EFFIC'] == '0'
|
|
assert ge['DEMAND CHARGE'] == '0'
|
|
|
|
set_energy(p, ChangeSet({ 'DEMAND CHARGE' : '10' }))
|
|
ge = get_energy(p)
|
|
assert ge['GLOBAL PRICE'] == '10'
|
|
assert ge['GLOBAL PATTERN'] == 'p0'
|
|
assert ge['GLOBAL EFFIC'] == '0'
|
|
assert ge['DEMAND CHARGE'] == '10'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_energy_op(self):
|
|
p = 'test_energy_op'
|
|
self.enter(p)
|
|
|
|
add_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]}))
|
|
|
|
cs = set_energy(p, ChangeSet({ 'GLOBAL PRICE' : '10' })).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'energy'
|
|
assert cs['GLOBAL PRICE'] == '10'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'energy'
|
|
assert cs['GLOBAL PRICE'] == '0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'energy'
|
|
assert cs['GLOBAL PRICE'] == '10'
|
|
|
|
cs = set_energy(p, ChangeSet({ 'GLOBAL PATTERN' : 'p0' })).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'energy'
|
|
assert cs['GLOBAL PATTERN'] == 'p0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'energy'
|
|
assert cs['GLOBAL PATTERN'] == ''
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'energy'
|
|
assert cs['GLOBAL PATTERN'] == 'p0'
|
|
|
|
cs = set_energy(p, ChangeSet({ 'GLOBAL EFFIC' : '0' })).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'energy'
|
|
assert cs['GLOBAL EFFIC'] == '0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'energy'
|
|
assert cs['GLOBAL EFFIC'] == '75'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'energy'
|
|
assert cs['GLOBAL EFFIC'] == '0'
|
|
|
|
cs = set_energy(p, ChangeSet({ 'DEMAND CHARGE' : '10' })).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'energy'
|
|
assert cs['DEMAND CHARGE'] == '10'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'energy'
|
|
assert cs['DEMAND CHARGE'] == '0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'energy'
|
|
assert cs['DEMAND CHARGE'] == '10'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_pump_energy(self):
|
|
p = 'test_pump_energy'
|
|
self.enter(p)
|
|
|
|
ge = get_pump_energy(p, 'p0')
|
|
assert ge['pump'] == 'p0'
|
|
assert ge['price'] == None
|
|
assert ge['pattern'] == None
|
|
assert ge['effic'] == None
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pump(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'power': 0.0}))
|
|
|
|
set_pump_energy(p, ChangeSet({'pump' : 'p0'}))
|
|
ge = get_pump_energy(p, 'p0')
|
|
assert ge['pump'] == 'p0'
|
|
assert ge['price'] == None
|
|
assert ge['pattern'] == None
|
|
assert ge['effic'] == None
|
|
|
|
set_pump_energy(p, ChangeSet({'pump' : 'p0', 'price': 0.0}))
|
|
ge = get_pump_energy(p, 'p0')
|
|
assert ge['pump'] == 'p0'
|
|
assert ge['price'] == 0.0
|
|
assert ge['pattern'] == None
|
|
assert ge['effic'] == None
|
|
|
|
add_pattern(p, ChangeSet({'id' : 'pa0', 'factors': [1.0, 2.0, 3.0]}))
|
|
set_pump_energy(p, ChangeSet({'pump' : 'p0', 'pattern': 'pa0'}))
|
|
ge = get_pump_energy(p, 'p0')
|
|
assert ge['pump'] == 'p0'
|
|
assert ge['price'] == 0.0
|
|
assert ge['pattern'] == 'pa0'
|
|
assert ge['effic'] == None
|
|
|
|
add_curve(p, ChangeSet({'id' : 'c0', 'c_type' : CURVE_TYPE_PUMP, 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
|
|
set_pump_energy(p, ChangeSet({'pump' : 'p0', 'effic': 'c0'}))
|
|
ge = get_pump_energy(p, 'p0')
|
|
assert ge['pump'] == 'p0'
|
|
assert ge['price'] == 0.0
|
|
assert ge['pattern'] == 'pa0'
|
|
assert ge['effic'] == 'c0'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_pump_energy_op(self):
|
|
p = 'test_pump_energy_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pump(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'power': 0.0}))
|
|
add_pattern(p, ChangeSet({'id' : 'pa0', 'factors': [1.0, 2.0, 3.0]}))
|
|
add_curve(p, ChangeSet({'id' : 'c0', 'c_type' : CURVE_TYPE_PUMP, 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
|
|
|
|
cs = set_pump_energy(p, ChangeSet({'pump' : 'p0'})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == None
|
|
assert cs['pattern'] == None
|
|
assert cs['effic'] == None
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == None
|
|
assert cs['pattern'] == None
|
|
assert cs['effic'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == None
|
|
assert cs['pattern'] == None
|
|
assert cs['effic'] == None
|
|
|
|
cs = set_pump_energy(p, ChangeSet({'pump' : 'p0', 'price': 0.0})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == 0.0
|
|
assert cs['pattern'] == None
|
|
assert cs['effic'] == None
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == None
|
|
assert cs['pattern'] == None
|
|
assert cs['effic'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == 0.0
|
|
assert cs['pattern'] == None
|
|
assert cs['effic'] == None
|
|
|
|
cs = set_pump_energy(p, ChangeSet({'pump' : 'p0', 'pattern': 'pa0'})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == 0.0
|
|
assert cs['pattern'] == 'pa0'
|
|
assert cs['effic'] == None
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == 0.0
|
|
assert cs['pattern'] == None
|
|
assert cs['effic'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == 0.0
|
|
assert cs['pattern'] == 'pa0'
|
|
assert cs['effic'] == None
|
|
|
|
cs = set_pump_energy(p, ChangeSet({'pump' : 'p0', 'effic': 'c0'})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == 0.0
|
|
assert cs['pattern'] == 'pa0'
|
|
assert cs['effic'] == 'c0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == 0.0
|
|
assert cs['pattern'] == 'pa0'
|
|
assert cs['effic'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == 0.0
|
|
assert cs['pattern'] == 'pa0'
|
|
assert cs['effic'] == 'c0'
|
|
|
|
cs = set_pump_energy(p, ChangeSet({'pump' : 'p0', 'price': None, 'pattern': None, 'effic': None})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == None
|
|
assert cs['pattern'] == None
|
|
assert cs['effic'] == None
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == 0.0
|
|
assert cs['pattern'] == 'pa0'
|
|
assert cs['effic'] == 'c0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == None
|
|
assert cs['pattern'] == None
|
|
assert cs['effic'] == None
|
|
|
|
cs = set_pump_energy(p, ChangeSet({'pump' : 'p0', 'price': 0.0, 'pattern': 'pa0', 'effic': 'c0'})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == 0.0
|
|
assert cs['pattern'] == 'pa0'
|
|
assert cs['effic'] == 'c0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == None
|
|
assert cs['pattern'] == None
|
|
assert cs['effic'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pump_energy'
|
|
assert cs['pump'] == 'p0'
|
|
assert cs['price'] == 0.0
|
|
assert cs['pattern'] == 'pa0'
|
|
assert cs['effic'] == 'c0'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 16 emitter
|
|
|
|
|
|
def test_emitter(self):
|
|
p = 'test_emitter'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
|
|
e = get_emitter(p, 'j1')
|
|
assert e['junction'] == 'j1'
|
|
assert e['coefficient'] == None
|
|
|
|
set_emitter(p, ChangeSet({'junction': 'j1', 'coefficient': 10.0}))
|
|
|
|
e = get_emitter(p, 'j1')
|
|
assert e['junction'] == 'j1'
|
|
assert e['coefficient'] == 10.0
|
|
|
|
set_emitter(p, ChangeSet({'junction': 'j1', 'coefficient': None}))
|
|
|
|
e = get_emitter(p, 'j1')
|
|
assert e['junction'] == 'j1'
|
|
assert e['coefficient'] == None
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_emitter_op(self):
|
|
p = 'test_emitter_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
|
|
cs = set_emitter(p, ChangeSet({'junction': 'j1', 'coefficient': 10.0})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'emitter'
|
|
assert cs['junction'] == 'j1'
|
|
assert cs['coefficient'] == 10.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'emitter'
|
|
assert cs['junction'] == 'j1'
|
|
assert cs['coefficient'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'emitter'
|
|
assert cs['junction'] == 'j1'
|
|
assert cs['coefficient'] == 10.0
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 17 quality
|
|
|
|
|
|
def test_quality(self):
|
|
p = 'test_quality'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
|
|
e = get_quality(p, 'j1')
|
|
assert e['node'] == 'j1'
|
|
assert e['quality'] == None
|
|
|
|
set_quality(p, ChangeSet({'node': 'j1', 'quality': 10.0}))
|
|
|
|
e = get_quality(p, 'j1')
|
|
assert e['node'] == 'j1'
|
|
assert e['quality'] == 10.0
|
|
|
|
set_quality(p, ChangeSet({'node': 'j1', 'quality': None}))
|
|
|
|
e = get_quality(p, 'j1')
|
|
assert e['node'] == 'j1'
|
|
assert e['quality'] == None
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_quality_op(self):
|
|
p = 'test_quality_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
assert is_junction(p, 'j1')
|
|
|
|
cs = set_quality(p, ChangeSet({'node': 'j1', 'quality': 10.0})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'quality'
|
|
assert cs['node'] == 'j1'
|
|
assert cs['quality'] == 10.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'quality'
|
|
assert cs['node'] == 'j1'
|
|
assert cs['quality'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'quality'
|
|
assert cs['node'] == 'j1'
|
|
assert cs['quality'] == 10.0
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 18 source
|
|
|
|
|
|
def test_source(self):
|
|
p = 'test_source'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]}))
|
|
add_pattern(p, ChangeSet({'id' : 'p1', 'factors': [1.0, 2.0, 3.0]}))
|
|
|
|
assert get_source(p, 'j0') == {}
|
|
|
|
add_source(p, ChangeSet({'node': 'j0', 's_type': SOURCE_TYPE_CONCEN, 'strength': 10.0, 'pattern': 'p0'}))
|
|
s = get_source(p, 'j0')
|
|
assert s['node'] == 'j0'
|
|
assert s['s_type'] == SOURCE_TYPE_CONCEN
|
|
assert s['strength'] == 10.0
|
|
assert s['pattern'] == 'p0'
|
|
|
|
set_source(p, ChangeSet({'node': 'j0', 's_type': SOURCE_TYPE_FLOWPACED}))
|
|
s = get_source(p, 'j0')
|
|
assert s['node'] == 'j0'
|
|
assert s['s_type'] == SOURCE_TYPE_FLOWPACED
|
|
assert s['strength'] == 10.0
|
|
assert s['pattern'] == 'p0'
|
|
|
|
set_source(p, ChangeSet({'node': 'j0', 'strength': 20.0}))
|
|
s = get_source(p, 'j0')
|
|
assert s['node'] == 'j0'
|
|
assert s['s_type'] == SOURCE_TYPE_FLOWPACED
|
|
assert s['strength'] == 20.0
|
|
assert s['pattern'] == 'p0'
|
|
|
|
set_source(p, ChangeSet({'node': 'j0', 'pattern': 'p1'}))
|
|
s = get_source(p, 'j0')
|
|
assert s['node'] == 'j0'
|
|
assert s['s_type'] == SOURCE_TYPE_FLOWPACED
|
|
assert s['strength'] == 20.0
|
|
assert s['pattern'] == 'p1'
|
|
|
|
delete_source(p, ChangeSet({'node': 'j0'}))
|
|
|
|
assert get_source(p, 'j0') == {}
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_source_op(self):
|
|
p = 'test_source_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]}))
|
|
add_pattern(p, ChangeSet({'id' : 'p1', 'factors': [1.0, 2.0, 3.0]}))
|
|
|
|
cs = add_source(p, ChangeSet({'node': 'j0', 's_type': SOURCE_TYPE_CONCEN, 'strength': 10.0, 'pattern': 'p0'})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
assert cs['s_type'] == SOURCE_TYPE_CONCEN
|
|
assert cs['strength'] == 10.0
|
|
assert cs['pattern'] == 'p0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
assert cs['s_type'] == SOURCE_TYPE_CONCEN
|
|
assert cs['strength'] == 10.0
|
|
assert cs['pattern'] == 'p0'
|
|
|
|
cs = set_source(p, ChangeSet({'node': 'j0', 's_type': SOURCE_TYPE_FLOWPACED})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
assert cs['s_type'] == SOURCE_TYPE_FLOWPACED
|
|
assert cs['strength'] == 10.0
|
|
assert cs['pattern'] == 'p0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
assert cs['s_type'] == SOURCE_TYPE_CONCEN
|
|
assert cs['strength'] == 10.0
|
|
assert cs['pattern'] == 'p0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
assert cs['s_type'] == SOURCE_TYPE_FLOWPACED
|
|
assert cs['strength'] == 10.0
|
|
assert cs['pattern'] == 'p0'
|
|
|
|
cs = set_source(p, ChangeSet({'node': 'j0', 'strength': 20.0})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
assert cs['s_type'] == SOURCE_TYPE_FLOWPACED
|
|
assert cs['strength'] == 20.0
|
|
assert cs['pattern'] == 'p0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
assert cs['s_type'] == SOURCE_TYPE_FLOWPACED
|
|
assert cs['strength'] == 10.0
|
|
assert cs['pattern'] == 'p0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
assert cs['s_type'] == SOURCE_TYPE_FLOWPACED
|
|
assert cs['strength'] == 20.0
|
|
assert cs['pattern'] == 'p0'
|
|
|
|
cs = set_source(p, ChangeSet({'node': 'j0', 'pattern': 'p1'})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
assert cs['s_type'] == SOURCE_TYPE_FLOWPACED
|
|
assert cs['strength'] == 20.0
|
|
assert cs['pattern'] == 'p1'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
assert cs['s_type'] == SOURCE_TYPE_FLOWPACED
|
|
assert cs['strength'] == 20.0
|
|
assert cs['pattern'] == 'p0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
assert cs['s_type'] == SOURCE_TYPE_FLOWPACED
|
|
assert cs['strength'] == 20.0
|
|
assert cs['pattern'] == 'p1'
|
|
|
|
cs = delete_source(p, ChangeSet({'node': 'j0'})).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
assert cs['s_type'] == SOURCE_TYPE_FLOWPACED
|
|
assert cs['strength'] == 20.0
|
|
assert cs['pattern'] == 'p1'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'source'
|
|
assert cs['node'] == 'j0'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 19 reaction
|
|
|
|
|
|
def test_reaction(self):
|
|
p = 'test_reaction'
|
|
self.enter(p)
|
|
|
|
gr = get_reaction(p)
|
|
assert gr['ORDER BULK'] == '1'
|
|
assert gr['ORDER WALL'] == '1'
|
|
assert gr['ORDER TANK'] == '1'
|
|
assert gr['GLOBAL BULK'] == '0'
|
|
assert gr['GLOBAL WALL'] == '0'
|
|
assert gr['LIMITING POTENTIAL'] == '0'
|
|
assert gr['ROUGHNESS CORRELATION'] == '0'
|
|
|
|
set_reaction(p, ChangeSet({ 'ORDER BULK' : '10' }))
|
|
gr = get_reaction(p)
|
|
assert gr['ORDER BULK'] == '10'
|
|
assert gr['ORDER WALL'] == '1'
|
|
assert gr['ORDER TANK'] == '1'
|
|
assert gr['GLOBAL BULK'] == '0'
|
|
assert gr['GLOBAL WALL'] == '0'
|
|
assert gr['LIMITING POTENTIAL'] == '0'
|
|
assert gr['ROUGHNESS CORRELATION'] == '0'
|
|
|
|
set_reaction(p, ChangeSet({ 'ORDER BULK' : '1' }))
|
|
gr = get_reaction(p)
|
|
assert gr['ORDER BULK'] == '1'
|
|
assert gr['ORDER WALL'] == '1'
|
|
assert gr['ORDER TANK'] == '1'
|
|
assert gr['GLOBAL BULK'] == '0'
|
|
assert gr['GLOBAL WALL'] == '0'
|
|
assert gr['LIMITING POTENTIAL'] == '0'
|
|
assert gr['ROUGHNESS CORRELATION'] == '0'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_reaction_op(self):
|
|
p = 'test_reaction_op'
|
|
self.enter(p)
|
|
|
|
cs = set_reaction(p, ChangeSet({ 'ORDER BULK' : '10' })).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'reaction'
|
|
assert cs['ORDER BULK'] == '10'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'reaction'
|
|
assert cs['ORDER BULK'] == '1'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'reaction'
|
|
assert cs['ORDER BULK'] == '10'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_pipe_reaction(self):
|
|
p = 'test_pipe_reaction'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
|
|
pp = get_pipe_reaction(p, 'p0')
|
|
assert pp['pipe'] == 'p0'
|
|
assert pp['bulk'] == None
|
|
assert pp['wall'] == None
|
|
|
|
set_pipe_reaction(p, ChangeSet({'pipe': 'p0', 'bulk': 10.0, 'wall': 20.0}))
|
|
pp = get_pipe_reaction(p, 'p0')
|
|
assert pp['pipe'] == 'p0'
|
|
assert pp['bulk'] == 10.0
|
|
assert pp['wall'] == 20.0
|
|
|
|
set_pipe_reaction(p, ChangeSet({'pipe': 'p0', 'bulk': None, 'wall': None}))
|
|
pp = get_pipe_reaction(p, 'p0')
|
|
assert pp['pipe'] == 'p0'
|
|
assert pp['bulk'] == None
|
|
assert pp['wall'] == None
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_pipe_reaction_op(self):
|
|
p = 'test_pipe_reaction_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
|
|
cs = set_pipe_reaction(p, ChangeSet({'pipe': 'p0', 'bulk': 10.0, 'wall': 20.0})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pipe_reaction'
|
|
assert cs['pipe'] == 'p0'
|
|
assert cs['bulk'] == 10.0
|
|
assert cs['wall'] == 20.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pipe_reaction'
|
|
assert cs['pipe'] == 'p0'
|
|
assert cs['bulk'] == None
|
|
assert cs['wall'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'pipe_reaction'
|
|
assert cs['pipe'] == 'p0'
|
|
assert cs['bulk'] == 10.0
|
|
assert cs['wall'] == 20.0
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_tank_reaction(self):
|
|
p = 'test_tank_reaction'
|
|
self.enter(p)
|
|
|
|
add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
|
|
|
|
pt = get_tank_reaction(p, 't0')
|
|
assert pt['tank'] == 't0'
|
|
assert pt['value'] == None
|
|
|
|
set_tank_reaction(p, ChangeSet({'tank': 't0', 'value': 10.0}))
|
|
pt = get_tank_reaction(p, 't0')
|
|
assert pt['tank'] == 't0'
|
|
assert pt['value'] == 10.0
|
|
|
|
set_tank_reaction(p, ChangeSet({'tank': 't0', 'value': None}))
|
|
pt = get_tank_reaction(p, 't0')
|
|
assert pt['tank'] == 't0'
|
|
assert pt['value'] == None
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_tank_reaction_op(self):
|
|
p = 'test_tank_reaction_op'
|
|
self.enter(p)
|
|
|
|
add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
|
|
|
|
cs = set_tank_reaction(p, ChangeSet({'tank': 't0', 'value': 10.0})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'tank_reaction'
|
|
assert cs['tank'] == 't0'
|
|
assert cs['value'] == 10.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'tank_reaction'
|
|
assert cs['tank'] == 't0'
|
|
assert cs['value'] == None
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'tank_reaction'
|
|
assert cs['tank'] == 't0'
|
|
assert cs['value'] == 10.0
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 20 mixing
|
|
|
|
|
|
def test_mixing(self):
|
|
p = 'test_mixing'
|
|
self.enter(p)
|
|
|
|
add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
|
|
|
|
assert get_mixing(p, 't0') == {}
|
|
|
|
add_mixing(p, ChangeSet({'tank': 't0', 'model': MIXING_MODEL_MIXED, 'value': 10.0}))
|
|
m = get_mixing(p,'t0')
|
|
assert m['tank'] == 't0'
|
|
assert m['model'] == MIXING_MODEL_MIXED
|
|
assert m['value'] == 10.0
|
|
|
|
set_mixing(p, ChangeSet({'tank': 't0', 'model': MIXING_MODEL_2COMP}))
|
|
m = get_mixing(p,'t0')
|
|
assert m['tank'] == 't0'
|
|
assert m['model'] == MIXING_MODEL_2COMP
|
|
assert m['value'] == 10.0
|
|
|
|
set_mixing(p, ChangeSet({'tank': 't0', 'value': 20.0}))
|
|
m = get_mixing(p,'t0')
|
|
assert m['tank'] == 't0'
|
|
assert m['model'] == MIXING_MODEL_2COMP
|
|
assert m['value'] == 20.0
|
|
|
|
delete_mixing(p, ChangeSet({'tank': 't0'}))
|
|
|
|
assert get_mixing(p, 't0') == {}
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_mixing_op(self):
|
|
p = 'test_mixing_op'
|
|
self.enter(p)
|
|
|
|
add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
|
|
|
|
cs = add_mixing(p, ChangeSet({'tank': 't0', 'model': MIXING_MODEL_MIXED, 'value': 10.0})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'mixing'
|
|
assert cs['tank'] == 't0'
|
|
assert cs['model'] == MIXING_MODEL_MIXED
|
|
assert cs['value'] == 10.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'mixing'
|
|
assert cs['tank'] == 't0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'mixing'
|
|
assert cs['tank'] == 't0'
|
|
assert cs['model'] == MIXING_MODEL_MIXED
|
|
assert cs['value'] == 10.0
|
|
|
|
cs = set_mixing(p, ChangeSet({'tank': 't0', 'model': MIXING_MODEL_2COMP})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'mixing'
|
|
assert cs['tank'] == 't0'
|
|
assert cs['model'] == MIXING_MODEL_2COMP
|
|
assert cs['value'] == 10.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'mixing'
|
|
assert cs['tank'] == 't0'
|
|
assert cs['model'] == MIXING_MODEL_MIXED
|
|
assert cs['value'] == 10.0
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'mixing'
|
|
assert cs['tank'] == 't0'
|
|
assert cs['model'] == MIXING_MODEL_2COMP
|
|
assert cs['value'] == 10.0
|
|
|
|
cs = set_mixing(p, ChangeSet({'tank': 't0', 'value': 20.0})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'mixing'
|
|
assert cs['tank'] == 't0'
|
|
assert cs['model'] == MIXING_MODEL_2COMP
|
|
assert cs['value'] == 20.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'mixing'
|
|
assert cs['tank'] == 't0'
|
|
assert cs['model'] == MIXING_MODEL_2COMP
|
|
assert cs['value'] == 10.0
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'mixing'
|
|
assert cs['tank'] == 't0'
|
|
assert cs['model'] == MIXING_MODEL_2COMP
|
|
assert cs['value'] == 20.0
|
|
|
|
cs = delete_mixing(p, ChangeSet({'tank': 't0'})).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'mixing'
|
|
assert cs['tank'] == 't0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'mixing'
|
|
assert cs['tank'] == 't0'
|
|
assert cs['model'] == MIXING_MODEL_2COMP
|
|
assert cs['value'] == 20.0
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'mixing'
|
|
assert cs['tank'] == 't0'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 21 time
|
|
|
|
|
|
def test_time(self):
|
|
p = 'test_time'
|
|
self.enter(p)
|
|
|
|
t = get_time(p)
|
|
assert t['DURATION'] == '0:00'
|
|
assert t['HYDRAULIC TIMESTEP'] == '1:00'
|
|
assert t['QUALITY TIMESTEP'] == '0:05'
|
|
assert t['RULE TIMESTEP'] == '0:05'
|
|
assert t['PATTERN TIMESTEP'] == '1:00'
|
|
assert t['PATTERN START'] == '0:00'
|
|
assert t['REPORT TIMESTEP'] == '1:00'
|
|
assert t['REPORT START'] == '0:00'
|
|
assert t['START CLOCKTIME'] == '12:00 AM'
|
|
assert t['STATISTIC'] == TIME_STATISTIC_NONE
|
|
|
|
t['STATISTIC'] = TIME_STATISTIC_AVERAGED
|
|
set_time(p, ChangeSet(t))
|
|
|
|
t = get_time(p)
|
|
assert t['DURATION'] == '0:00'
|
|
assert t['HYDRAULIC TIMESTEP'] == '1:00'
|
|
assert t['QUALITY TIMESTEP'] == '0:05'
|
|
assert t['RULE TIMESTEP'] == '0:05'
|
|
assert t['PATTERN TIMESTEP'] == '1:00'
|
|
assert t['PATTERN START'] == '0:00'
|
|
assert t['REPORT TIMESTEP'] == '1:00'
|
|
assert t['REPORT START'] == '0:00'
|
|
assert t['START CLOCKTIME'] == '12:00 AM'
|
|
assert t['STATISTIC'] == TIME_STATISTIC_AVERAGED
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_time_op(self):
|
|
p = 'test_time_op'
|
|
self.enter(p)
|
|
|
|
t = get_time(p)
|
|
assert t['DURATION'] == '0:00'
|
|
assert t['HYDRAULIC TIMESTEP'] == '1:00'
|
|
assert t['QUALITY TIMESTEP'] == '0:05'
|
|
assert t['RULE TIMESTEP'] == '0:05'
|
|
assert t['PATTERN TIMESTEP'] == '1:00'
|
|
assert t['PATTERN START'] == '0:00'
|
|
assert t['REPORT TIMESTEP'] == '1:00'
|
|
assert t['REPORT START'] == '0:00'
|
|
assert t['START CLOCKTIME'] == '12:00 AM'
|
|
assert t['STATISTIC'] == TIME_STATISTIC_NONE
|
|
|
|
t['STATISTIC'] = TIME_STATISTIC_AVERAGED
|
|
cs = set_time(p, ChangeSet(t)).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'time'
|
|
assert cs['DURATION'] == '0:00'
|
|
assert cs['HYDRAULIC TIMESTEP'] == '1:00'
|
|
assert cs['QUALITY TIMESTEP'] == '0:05'
|
|
assert cs['RULE TIMESTEP'] == '0:05'
|
|
assert cs['PATTERN TIMESTEP'] == '1:00'
|
|
assert cs['PATTERN START'] == '0:00'
|
|
assert cs['REPORT TIMESTEP'] == '1:00'
|
|
assert cs['REPORT START'] == '0:00'
|
|
assert cs['START CLOCKTIME'] == '12:00 AM'
|
|
assert cs['STATISTIC'] == TIME_STATISTIC_AVERAGED
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'time'
|
|
assert cs['DURATION'] == '0:00'
|
|
assert cs['HYDRAULIC TIMESTEP'] == '1:00'
|
|
assert cs['QUALITY TIMESTEP'] == '0:05'
|
|
assert cs['RULE TIMESTEP'] == '0:05'
|
|
assert cs['PATTERN TIMESTEP'] == '1:00'
|
|
assert cs['PATTERN START'] == '0:00'
|
|
assert cs['REPORT TIMESTEP'] == '1:00'
|
|
assert cs['REPORT START'] == '0:00'
|
|
assert cs['START CLOCKTIME'] == '12:00 AM'
|
|
assert cs['STATISTIC'] == TIME_STATISTIC_NONE
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'time'
|
|
assert cs['DURATION'] == '0:00'
|
|
assert cs['HYDRAULIC TIMESTEP'] == '1:00'
|
|
assert cs['QUALITY TIMESTEP'] == '0:05'
|
|
assert cs['RULE TIMESTEP'] == '0:05'
|
|
assert cs['PATTERN TIMESTEP'] == '1:00'
|
|
assert cs['PATTERN START'] == '0:00'
|
|
assert cs['REPORT TIMESTEP'] == '1:00'
|
|
assert cs['REPORT START'] == '0:00'
|
|
assert cs['START CLOCKTIME'] == '12:00 AM'
|
|
assert cs['STATISTIC'] == TIME_STATISTIC_AVERAGED
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 22 option
|
|
|
|
|
|
def test_option(self):
|
|
p = 'test_option'
|
|
self.enter(p)
|
|
|
|
o = get_option(p)
|
|
assert o['UNITS'] == OPTION_UNITS_GPM
|
|
assert o['PRESSURE'] == OPTION_PRESSURE_PSI
|
|
assert o['HEADLOSS'] == OPTION_HEADLOSS_HW
|
|
assert o['QUALITY'] == OPTION_QUALITY_NONE
|
|
assert o['UNBALANCED'] == OPTION_UNBALANCED_STOP
|
|
assert o['PATTERN'] == '1'
|
|
assert o['DEMAND MODEL'] == OPTION_DEMAND_MODEL_DDA
|
|
assert o['DEMAND MULTIPLIER'] == '1.0'
|
|
assert o['EMITTER EXPONENT'] == '0.5'
|
|
assert o['VISCOSITY'] == '1.0'
|
|
assert o['DIFFUSIVITY'] == '1.0'
|
|
assert o['SPECIFIC GRAVITY'] == '1.0'
|
|
assert o['TRIALS'] == '40'
|
|
assert o['ACCURACY'] == '0.001'
|
|
assert o['HEADERROR'] == '0.0'
|
|
assert o['FLOWCHANGE'] == '0.0'
|
|
assert o['MINIMUM PRESSURE'] == '0.0'
|
|
assert o['REQUIRED PRESSURE'] == '0.1'
|
|
assert o['PRESSURE EXPONENT'] == '0.5'
|
|
assert o['TOLERANCE'] == '0.01'
|
|
assert o['HTOL'] == '0.0005'
|
|
assert o['QTOL'] == '0.0001'
|
|
assert o['RQTOL'] == '0.0000001'
|
|
assert o['CHECKFREQ'] == '2'
|
|
assert o['MAXCHECK'] == '10'
|
|
assert o['DAMPLIMIT'] == '0'
|
|
|
|
o3 = get_option_v3(p)
|
|
assert o3['FLOW_UNITS'] == OPTION_V3_FLOW_UNITS_GPM
|
|
assert o3['PRESSURE_UNITS'] == OPTION_V3_PRESSURE_UNITS_PSI
|
|
assert o3['HEADLOSS_MODEL'] == OPTION_V3_HEADLOSS_MODEL_HW
|
|
assert o3['SPECIFIC_GRAVITY'] == '1.0'
|
|
assert o3['SPECIFIC_VISCOSITY'] == '1.0'
|
|
assert o3['MAXIMUM_TRIALS'] == '40'
|
|
assert o3['HEAD_TOLERANCE'] == '0.0005'
|
|
assert o3['FLOW_TOLERANCE'] == '0.0001'
|
|
assert o3['FLOW_CHANGE_LIMIT'] == '0.0'
|
|
assert o3['RELATIVE_ACCURACY'] == '0.001'
|
|
assert o3['TIME_WEIGHT'] == '0.0'
|
|
assert o3['STEP_SIZING'] == OPTION_V3_STEP_SIZING_FULL
|
|
assert o3['IF_UNBALANCED'] == OPTION_V3_IF_UNBALANCED_STOP
|
|
assert o3['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_FIXED
|
|
assert o3['DEMAND_PATTERN'] == '1'
|
|
assert o3['DEMAND_MULTIPLIER'] == '1.0'
|
|
assert o3['MINIMUM_PRESSURE'] == '0.0'
|
|
assert o3['SERVICE_PRESSURE'] == '0.1'
|
|
assert o3['PRESSURE_EXPONENT'] == '0.5'
|
|
assert o3['LEAKAGE_MODEL'] == OPTION_V3_LEAKAGE_MODEL_NONE
|
|
assert o3['LEAKAGE_COEFF1'] == '0.0'
|
|
assert o3['LEAKAGE_COEFF2'] == '0.0'
|
|
assert o3['EMITTER_EXPONENT'] == '0.5'
|
|
assert o3['QUALITY_MODEL'] == OPTION_V3_QUALITY_MODEL_NONE
|
|
assert o3['QUALITY_NAME'] == OPTION_V3_QUALITY_MODEL_CHEMICAL
|
|
assert o3['QUALITY_UNITS'] == OPTION_V3_QUALITY_UNITS_MGL
|
|
assert o3['TRACE_NODE'] == ''
|
|
assert o3['SPECIFIC_DIFFUSIVITY'] == '1.0'
|
|
assert o3['QUALITY_TOLERANCE'] == '0.01'
|
|
|
|
o['UNITS'] = OPTION_UNITS_LPS
|
|
o['PRESSURE'] = OPTION_PRESSURE_KPA
|
|
o['HEADLOSS'] = OPTION_HEADLOSS_DW
|
|
o['QUALITY'] = f'{OPTION_QUALITY_TRACE} 1'
|
|
o['UNBALANCED'] = OPTION_UNBALANCED_CONTINUE
|
|
o['PATTERN'] = '2'
|
|
o['DEMAND MODEL'] = OPTION_DEMAND_MODEL_PDA
|
|
o['DEMAND MULTIPLIER'] = '2.0'
|
|
o['EMITTER EXPONENT'] = '1.5'
|
|
o['VISCOSITY'] = '2.0'
|
|
o['DIFFUSIVITY'] = '2.0'
|
|
o['SPECIFIC GRAVITY'] = '2.0'
|
|
o['TRIALS'] = '50'
|
|
o['ACCURACY'] = '0.0001'
|
|
o['HEADERROR'] = '0.01'
|
|
o['FLOWCHANGE'] = '0.01'
|
|
o['MINIMUM PRESSURE'] = '0.01'
|
|
o['REQUIRED PRESSURE'] = '0.01'
|
|
o['PRESSURE EXPONENT'] = '0.05'
|
|
o['TOLERANCE'] = '0.001'
|
|
o['HTOL'] = '0.005'
|
|
o['QTOL'] = '0.001'
|
|
o['RQTOL'] = '0.000001'
|
|
o['CHECKFREQ'] = '1'
|
|
o['MAXCHECK'] = '15'
|
|
o['DAMPLIMIT'] = '1'
|
|
|
|
set_option(p, ChangeSet(o))
|
|
|
|
o = get_option(p)
|
|
assert o['UNITS'] == OPTION_UNITS_LPS
|
|
assert o['PRESSURE'] == OPTION_PRESSURE_KPA
|
|
assert o['HEADLOSS'] == OPTION_HEADLOSS_DW
|
|
assert o['QUALITY'] == f'{OPTION_QUALITY_TRACE} 1'
|
|
assert o['UNBALANCED'] == OPTION_UNBALANCED_CONTINUE
|
|
assert o['PATTERN'] == '2'
|
|
assert o['DEMAND MODEL'] == OPTION_DEMAND_MODEL_PDA
|
|
assert o['DEMAND MULTIPLIER'] == '2.0'
|
|
assert o['EMITTER EXPONENT'] == '1.5'
|
|
assert o['VISCOSITY'] == '2.0'
|
|
assert o['DIFFUSIVITY'] == '2.0'
|
|
assert o['SPECIFIC GRAVITY'] == '2.0'
|
|
assert o['TRIALS'] == '50'
|
|
assert o['ACCURACY'] == '0.0001'
|
|
assert o['HEADERROR'] == '0.01'
|
|
assert o['FLOWCHANGE'] == '0.01'
|
|
assert o['MINIMUM PRESSURE'] == '0.01'
|
|
assert o['REQUIRED PRESSURE'] == '0.01'
|
|
assert o['PRESSURE EXPONENT'] == '0.05'
|
|
assert o['TOLERANCE'] == '0.001'
|
|
assert o['HTOL'] == '0.005'
|
|
assert o['QTOL'] == '0.001'
|
|
assert o['RQTOL'] == '0.000001'
|
|
assert o['CHECKFREQ'] == '1'
|
|
assert o['MAXCHECK'] == '15'
|
|
assert o['DAMPLIMIT'] == '1'
|
|
|
|
o3 = get_option_v3(p)
|
|
assert o3['FLOW_UNITS'] == OPTION_V3_FLOW_UNITS_LPS
|
|
assert o3['PRESSURE_UNITS'] == OPTION_V3_PRESSURE_UNITS_KPA
|
|
assert o3['HEADLOSS_MODEL'] == OPTION_V3_HEADLOSS_MODEL_DW
|
|
assert o3['SPECIFIC_GRAVITY'] == '2.0'
|
|
assert o3['SPECIFIC_VISCOSITY'] == '2.0'
|
|
assert o3['MAXIMUM_TRIALS'] == '50'
|
|
assert o3['HEAD_TOLERANCE'] == '0.005'
|
|
assert o3['FLOW_TOLERANCE'] == '0.001'
|
|
assert o3['FLOW_CHANGE_LIMIT'] == '0.01'
|
|
assert o3['RELATIVE_ACCURACY'] == '0.0001'
|
|
assert o3['TIME_WEIGHT'] == '0.0'
|
|
assert o3['STEP_SIZING'] == OPTION_V3_STEP_SIZING_FULL
|
|
assert o3['IF_UNBALANCED'] == OPTION_V3_IF_UNBALANCED_CONTINUE
|
|
assert o3['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_POWER
|
|
assert o3['DEMAND_PATTERN'] == '2'
|
|
assert o3['DEMAND_MULTIPLIER'] == '2.0'
|
|
assert o3['MINIMUM_PRESSURE'] == '0.01'
|
|
assert o3['SERVICE_PRESSURE'] == '0.01'
|
|
assert o3['PRESSURE_EXPONENT'] == '0.05'
|
|
assert o3['LEAKAGE_MODEL'] == OPTION_V3_LEAKAGE_MODEL_NONE
|
|
assert o3['LEAKAGE_COEFF1'] == '0.0'
|
|
assert o3['LEAKAGE_COEFF2'] == '0.0'
|
|
assert o3['EMITTER_EXPONENT'] == '1.5'
|
|
assert o3['QUALITY_MODEL'] == OPTION_V3_QUALITY_MODEL_TRACE
|
|
assert o3['QUALITY_NAME'] == OPTION_V3_QUALITY_MODEL_CHEMICAL
|
|
assert o3['QUALITY_UNITS'] == OPTION_V3_QUALITY_UNITS_MGL
|
|
assert o3['TRACE_NODE'] == '1'
|
|
assert o3['SPECIFIC_DIFFUSIVITY'] == '2.0'
|
|
assert o3['QUALITY_TOLERANCE'] == '0.001'
|
|
|
|
o3['FLOW_UNITS'] = OPTION_V3_FLOW_UNITS_GPM
|
|
o3['PRESSURE_UNITS'] = OPTION_V3_PRESSURE_UNITS_PSI
|
|
o3['HEADLOSS_MODEL'] = OPTION_V3_HEADLOSS_MODEL_HW
|
|
o3['SPECIFIC_GRAVITY'] = '1.0'
|
|
o3['SPECIFIC_VISCOSITY'] = '1.0'
|
|
o3['MAXIMUM_TRIALS'] = '40'
|
|
o3['HEAD_TOLERANCE'] = '0.0005'
|
|
o3['FLOW_TOLERANCE'] = '0.0001'
|
|
o3['FLOW_CHANGE_LIMIT'] = '0.0'
|
|
o3['RELATIVE_ACCURACY'] = '0.001'
|
|
o3['TIME_WEIGHT'] = '0.0'
|
|
o3['STEP_SIZING'] = OPTION_V3_STEP_SIZING_RELAXATION
|
|
o3['IF_UNBALANCED'] = OPTION_V3_IF_UNBALANCED_STOP
|
|
o3['DEMAND_MODEL'] = OPTION_V3_DEMAND_MODEL_FIXED
|
|
o3['DEMAND_PATTERN'] = '1'
|
|
o3['DEMAND_MULTIPLIER'] = '1.0'
|
|
o3['MINIMUM_PRESSURE'] = '0.0'
|
|
o3['SERVICE_PRESSURE'] = '0.1'
|
|
o3['PRESSURE_EXPONENT'] = '0.5'
|
|
o3['LEAKAGE_MODEL'] = OPTION_V3_LEAKAGE_MODEL_POWER
|
|
o3['LEAKAGE_COEFF1'] = '1.0'
|
|
o3['LEAKAGE_COEFF2'] = '2.0'
|
|
o3['EMITTER_EXPONENT'] = '0.5'
|
|
o3['QUALITY_MODEL'] = OPTION_V3_QUALITY_MODEL_TRACE
|
|
o3['QUALITY_NAME'] = OPTION_V3_QUALITY_MODEL_NONE
|
|
o3['QUALITY_UNITS'] = OPTION_V3_QUALITY_UNITS_HRS
|
|
o3['TRACE_NODE'] = '2'
|
|
o3['SPECIFIC_DIFFUSIVITY'] = '1.0'
|
|
o3['QUALITY_TOLERANCE'] = '0.01'
|
|
|
|
set_option_v3(p, ChangeSet(o3))
|
|
|
|
o3 = get_option_v3(p)
|
|
assert o3['FLOW_UNITS'] == OPTION_V3_FLOW_UNITS_GPM
|
|
assert o3['PRESSURE_UNITS'] == OPTION_V3_PRESSURE_UNITS_PSI
|
|
assert o3['HEADLOSS_MODEL'] == OPTION_V3_HEADLOSS_MODEL_HW
|
|
assert o3['SPECIFIC_GRAVITY'] == '1.0'
|
|
assert o3['SPECIFIC_VISCOSITY'] == '1.0'
|
|
assert o3['MAXIMUM_TRIALS'] == '40'
|
|
assert o3['HEAD_TOLERANCE'] == '0.0005'
|
|
assert o3['FLOW_TOLERANCE'] == '0.0001'
|
|
assert o3['FLOW_CHANGE_LIMIT'] == '0.0'
|
|
assert o3['RELATIVE_ACCURACY'] == '0.001'
|
|
assert o3['TIME_WEIGHT'] == '0.0'
|
|
assert o3['STEP_SIZING'] == OPTION_V3_STEP_SIZING_RELAXATION
|
|
assert o3['IF_UNBALANCED'] == OPTION_V3_IF_UNBALANCED_STOP
|
|
assert o3['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_FIXED
|
|
assert o3['DEMAND_PATTERN'] == '1'
|
|
assert o3['DEMAND_MULTIPLIER'] == '1.0'
|
|
assert o3['MINIMUM_PRESSURE'] == '0.0'
|
|
assert o3['SERVICE_PRESSURE'] == '0.1'
|
|
assert o3['PRESSURE_EXPONENT'] == '0.5'
|
|
assert o3['LEAKAGE_MODEL'] == OPTION_V3_LEAKAGE_MODEL_POWER
|
|
assert o3['LEAKAGE_COEFF1'] == '1.0'
|
|
assert o3['LEAKAGE_COEFF2'] == '2.0'
|
|
assert o3['EMITTER_EXPONENT'] == '0.5'
|
|
assert o3['QUALITY_MODEL'] == OPTION_V3_QUALITY_MODEL_TRACE
|
|
assert o3['QUALITY_NAME'] == OPTION_V3_QUALITY_MODEL_NONE
|
|
assert o3['QUALITY_UNITS'] == OPTION_V3_QUALITY_UNITS_HRS
|
|
assert o3['TRACE_NODE'] == '2'
|
|
assert o3['SPECIFIC_DIFFUSIVITY'] == '1.0'
|
|
assert o3['QUALITY_TOLERANCE'] == '0.01'
|
|
|
|
o = get_option(p)
|
|
assert o['UNITS'] == OPTION_UNITS_GPM
|
|
assert o['PRESSURE'] == OPTION_PRESSURE_PSI
|
|
assert o['HEADLOSS'] == OPTION_HEADLOSS_HW
|
|
assert o['QUALITY'] == f'{OPTION_QUALITY_TRACE} 2'
|
|
assert o['UNBALANCED'] == OPTION_UNBALANCED_STOP
|
|
assert o['PATTERN'] == '1'
|
|
assert o['DEMAND MODEL'] == OPTION_DEMAND_MODEL_DDA
|
|
assert o['DEMAND MULTIPLIER'] == '1.0'
|
|
assert o['EMITTER EXPONENT'] == '0.5'
|
|
assert o['VISCOSITY'] == '1.0'
|
|
assert o['DIFFUSIVITY'] == '1.0'
|
|
assert o['SPECIFIC GRAVITY'] == '1.0'
|
|
assert o['TRIALS'] == '40'
|
|
assert o['ACCURACY'] == '0.001'
|
|
assert o['HEADERROR'] == '0.01'
|
|
assert o['FLOWCHANGE'] == '0.0'
|
|
assert o['MINIMUM PRESSURE'] == '0.0'
|
|
assert o['REQUIRED PRESSURE'] == '0.1'
|
|
assert o['PRESSURE EXPONENT'] == '0.5'
|
|
assert o['TOLERANCE'] == '0.01'
|
|
assert o['HTOL'] == '0.0005'
|
|
assert o['QTOL'] == '0.0001'
|
|
assert o['RQTOL'] == '0.000001'
|
|
assert o['CHECKFREQ'] == '1'
|
|
assert o['MAXCHECK'] == '15'
|
|
assert o['DAMPLIMIT'] == '1'
|
|
|
|
o3['DEMAND_MODEL'] = OPTION_V3_DEMAND_MODEL_CONSTRAINED
|
|
set_option_v3(p, ChangeSet(o3))
|
|
assert o3['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_CONSTRAINED
|
|
o = get_option(p)
|
|
assert o['DEMAND MODEL'] == OPTION_DEMAND_MODEL_PDA
|
|
|
|
o3['DEMAND_MODEL'] = OPTION_V3_DEMAND_MODEL_LOGISTIC
|
|
set_option_v3(p, ChangeSet(o3))
|
|
assert o3['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_LOGISTIC
|
|
o = get_option(p)
|
|
assert o['DEMAND MODEL'] == OPTION_DEMAND_MODEL_PDA
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_option_op(self):
|
|
p = 'test_option_op'
|
|
self.enter(p)
|
|
|
|
o = get_option(p)
|
|
assert o['UNITS'] == OPTION_UNITS_GPM
|
|
assert o['PRESSURE'] == OPTION_PRESSURE_PSI
|
|
assert o['HEADLOSS'] == OPTION_HEADLOSS_HW
|
|
assert o['QUALITY'] == OPTION_QUALITY_NONE
|
|
assert o['UNBALANCED'] == OPTION_UNBALANCED_STOP
|
|
assert o['PATTERN'] == '1'
|
|
assert o['DEMAND MODEL'] == OPTION_DEMAND_MODEL_DDA
|
|
assert o['DEMAND MULTIPLIER'] == '1.0'
|
|
assert o['EMITTER EXPONENT'] == '0.5'
|
|
assert o['VISCOSITY'] == '1.0'
|
|
assert o['DIFFUSIVITY'] == '1.0'
|
|
assert o['SPECIFIC GRAVITY'] == '1.0'
|
|
assert o['TRIALS'] == '40'
|
|
assert o['ACCURACY'] == '0.001'
|
|
assert o['HEADERROR'] == '0.0'
|
|
assert o['FLOWCHANGE'] == '0.0'
|
|
assert o['MINIMUM PRESSURE'] == '0.0'
|
|
assert o['REQUIRED PRESSURE'] == '0.1'
|
|
assert o['PRESSURE EXPONENT'] == '0.5'
|
|
assert o['TOLERANCE'] == '0.01'
|
|
assert o['HTOL'] == '0.0005'
|
|
assert o['QTOL'] == '0.0001'
|
|
assert o['RQTOL'] == '0.0000001'
|
|
assert o['CHECKFREQ'] == '2'
|
|
assert o['MAXCHECK'] == '10'
|
|
assert o['DAMPLIMIT'] == '0'
|
|
|
|
o3 = get_option_v3(p)
|
|
assert o3['FLOW_UNITS'] == OPTION_V3_FLOW_UNITS_GPM
|
|
assert o3['PRESSURE_UNITS'] == OPTION_V3_PRESSURE_UNITS_PSI
|
|
assert o3['HEADLOSS_MODEL'] == OPTION_V3_HEADLOSS_MODEL_HW
|
|
assert o3['SPECIFIC_GRAVITY'] == '1.0'
|
|
assert o3['SPECIFIC_VISCOSITY'] == '1.0'
|
|
assert o3['MAXIMUM_TRIALS'] == '40'
|
|
assert o3['HEAD_TOLERANCE'] == '0.0005'
|
|
assert o3['FLOW_TOLERANCE'] == '0.0001'
|
|
assert o3['FLOW_CHANGE_LIMIT'] == '0.0'
|
|
assert o3['RELATIVE_ACCURACY'] == '0.001'
|
|
assert o3['TIME_WEIGHT'] == '0.0'
|
|
assert o3['STEP_SIZING'] == OPTION_V3_STEP_SIZING_FULL
|
|
assert o3['IF_UNBALANCED'] == OPTION_V3_IF_UNBALANCED_STOP
|
|
assert o3['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_FIXED
|
|
assert o3['DEMAND_PATTERN'] == '1'
|
|
assert o3['DEMAND_MULTIPLIER'] == '1.0'
|
|
assert o3['MINIMUM_PRESSURE'] == '0.0'
|
|
assert o3['SERVICE_PRESSURE'] == '0.1'
|
|
assert o3['PRESSURE_EXPONENT'] == '0.5'
|
|
assert o3['LEAKAGE_MODEL'] == OPTION_V3_LEAKAGE_MODEL_NONE
|
|
assert o3['LEAKAGE_COEFF1'] == '0.0'
|
|
assert o3['LEAKAGE_COEFF2'] == '0.0'
|
|
assert o3['EMITTER_EXPONENT'] == '0.5'
|
|
assert o3['QUALITY_MODEL'] == OPTION_V3_QUALITY_MODEL_NONE
|
|
assert o3['QUALITY_NAME'] == OPTION_V3_QUALITY_MODEL_CHEMICAL
|
|
assert o3['QUALITY_UNITS'] == OPTION_V3_QUALITY_UNITS_MGL
|
|
assert o3['TRACE_NODE'] == ''
|
|
assert o3['SPECIFIC_DIFFUSIVITY'] == '1.0'
|
|
assert o3['QUALITY_TOLERANCE'] == '0.01'
|
|
|
|
o['UNITS'] = OPTION_UNITS_LPS
|
|
o['PRESSURE'] = OPTION_PRESSURE_KPA
|
|
o['HEADLOSS'] = OPTION_HEADLOSS_DW
|
|
o['QUALITY'] = f'{OPTION_QUALITY_TRACE} 1'
|
|
o['UNBALANCED'] = OPTION_UNBALANCED_CONTINUE
|
|
o['PATTERN'] = '2'
|
|
o['DEMAND MODEL'] = OPTION_DEMAND_MODEL_PDA
|
|
o['DEMAND MULTIPLIER'] = '2.0'
|
|
o['EMITTER EXPONENT'] = '1.5'
|
|
o['VISCOSITY'] = '2.0'
|
|
o['DIFFUSIVITY'] = '2.0'
|
|
o['SPECIFIC GRAVITY'] = '2.0'
|
|
o['TRIALS'] = '50'
|
|
o['ACCURACY'] = '0.0001'
|
|
o['HEADERROR'] = '0.01'
|
|
o['FLOWCHANGE'] = '0.01'
|
|
o['MINIMUM PRESSURE'] = '0.01'
|
|
o['REQUIRED PRESSURE'] = '0.01'
|
|
o['PRESSURE EXPONENT'] = '0.05'
|
|
o['TOLERANCE'] = '0.001'
|
|
o['HTOL'] = '0.005'
|
|
o['QTOL'] = '0.001'
|
|
o['RQTOL'] = '0.000001'
|
|
o['CHECKFREQ'] = '1'
|
|
o['MAXCHECK'] = '15'
|
|
o['DAMPLIMIT'] = '1'
|
|
|
|
css = set_option(p, ChangeSet(o)).operations
|
|
cs = css[0]
|
|
assert cs['UNITS'] == OPTION_UNITS_LPS
|
|
assert cs['PRESSURE'] == OPTION_PRESSURE_KPA
|
|
assert cs['HEADLOSS'] == OPTION_HEADLOSS_DW
|
|
assert cs['QUALITY'] == f'{OPTION_QUALITY_TRACE} 1'
|
|
assert cs['UNBALANCED'] == OPTION_UNBALANCED_CONTINUE
|
|
assert cs['PATTERN'] == '2'
|
|
assert cs['DEMAND MODEL'] == OPTION_DEMAND_MODEL_PDA
|
|
assert cs['DEMAND MULTIPLIER'] == '2.0'
|
|
assert cs['EMITTER EXPONENT'] == '1.5'
|
|
assert cs['VISCOSITY'] == '2.0'
|
|
assert cs['DIFFUSIVITY'] == '2.0'
|
|
assert cs['SPECIFIC GRAVITY'] == '2.0'
|
|
assert cs['TRIALS'] == '50'
|
|
assert cs['ACCURACY'] == '0.0001'
|
|
assert cs['HEADERROR'] == '0.01'
|
|
assert cs['FLOWCHANGE'] == '0.01'
|
|
assert cs['MINIMUM PRESSURE'] == '0.01'
|
|
assert cs['REQUIRED PRESSURE'] == '0.01'
|
|
assert cs['PRESSURE EXPONENT'] == '0.05'
|
|
assert cs['TOLERANCE'] == '0.001'
|
|
assert cs['HTOL'] == '0.005'
|
|
assert cs['QTOL'] == '0.001'
|
|
assert cs['RQTOL'] == '0.000001'
|
|
assert cs['CHECKFREQ'] == '1'
|
|
assert cs['MAXCHECK'] == '15'
|
|
assert cs['DAMPLIMIT'] == '1'
|
|
cs = css[1]
|
|
assert cs['FLOW_UNITS'] == OPTION_V3_FLOW_UNITS_LPS
|
|
assert cs['PRESSURE_UNITS'] == OPTION_V3_PRESSURE_UNITS_KPA
|
|
assert cs['HEADLOSS_MODEL'] == OPTION_V3_HEADLOSS_MODEL_DW
|
|
assert cs['SPECIFIC_GRAVITY'] == '2.0'
|
|
assert cs['SPECIFIC_VISCOSITY'] == '2.0'
|
|
assert cs['MAXIMUM_TRIALS'] == '50'
|
|
assert cs['HEAD_TOLERANCE'] == '0.005'
|
|
assert cs['FLOW_TOLERANCE'] == '0.001'
|
|
assert cs['FLOW_CHANGE_LIMIT'] == '0.01'
|
|
assert cs['RELATIVE_ACCURACY'] == '0.0001'
|
|
assert cs['IF_UNBALANCED'] == OPTION_V3_IF_UNBALANCED_CONTINUE
|
|
assert cs['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_POWER
|
|
assert cs['DEMAND_PATTERN'] == '2'
|
|
assert cs['DEMAND_MULTIPLIER'] == '2.0'
|
|
assert cs['MINIMUM_PRESSURE'] == '0.01'
|
|
assert cs['SERVICE_PRESSURE'] == '0.01'
|
|
assert cs['PRESSURE_EXPONENT'] == '0.05'
|
|
assert cs['EMITTER_EXPONENT'] == '1.5'
|
|
assert cs['QUALITY_MODEL'] == OPTION_V3_QUALITY_MODEL_TRACE
|
|
assert cs['TRACE_NODE'] == '1'
|
|
assert cs['SPECIFIC_DIFFUSIVITY'] == '2.0'
|
|
assert cs['QUALITY_TOLERANCE'] == '0.001'
|
|
|
|
css = execute_undo(p).operations
|
|
cs = css[0]
|
|
assert cs['FLOW_UNITS'] == OPTION_V3_FLOW_UNITS_GPM
|
|
assert cs['PRESSURE_UNITS'] == OPTION_V3_PRESSURE_UNITS_PSI
|
|
assert cs['HEADLOSS_MODEL'] == OPTION_V3_HEADLOSS_MODEL_HW
|
|
assert cs['SPECIFIC_GRAVITY'] == '1.0'
|
|
assert cs['SPECIFIC_VISCOSITY'] == '1.0'
|
|
assert cs['MAXIMUM_TRIALS'] == '40'
|
|
assert cs['HEAD_TOLERANCE'] == '0.0005'
|
|
assert cs['FLOW_TOLERANCE'] == '0.0001'
|
|
assert cs['FLOW_CHANGE_LIMIT'] == '0.0'
|
|
assert cs['RELATIVE_ACCURACY'] == '0.001'
|
|
assert cs['IF_UNBALANCED'] == OPTION_V3_IF_UNBALANCED_STOP
|
|
assert cs['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_FIXED
|
|
assert cs['DEMAND_PATTERN'] == '1'
|
|
assert cs['DEMAND_MULTIPLIER'] == '1.0'
|
|
assert cs['MINIMUM_PRESSURE'] == '0.0'
|
|
assert cs['SERVICE_PRESSURE'] == '0.1'
|
|
assert cs['PRESSURE_EXPONENT'] == '0.5'
|
|
assert cs['EMITTER_EXPONENT'] == '0.5'
|
|
assert cs['QUALITY_MODEL'] == OPTION_V3_QUALITY_MODEL_NONE
|
|
assert cs['TRACE_NODE'] == ''
|
|
assert cs['SPECIFIC_DIFFUSIVITY'] == '1.0'
|
|
assert cs['QUALITY_TOLERANCE'] == '0.01'
|
|
cs = css[1]
|
|
assert cs['UNITS'] == OPTION_UNITS_GPM
|
|
assert cs['PRESSURE'] == OPTION_PRESSURE_PSI
|
|
assert cs['HEADLOSS'] == OPTION_HEADLOSS_HW
|
|
assert cs['QUALITY'] == OPTION_QUALITY_NONE
|
|
assert cs['UNBALANCED'] == OPTION_UNBALANCED_STOP
|
|
assert cs['PATTERN'] == '1'
|
|
assert cs['DEMAND MODEL'] == OPTION_DEMAND_MODEL_DDA
|
|
assert cs['DEMAND MULTIPLIER'] == '1.0'
|
|
assert cs['EMITTER EXPONENT'] == '0.5'
|
|
assert cs['VISCOSITY'] == '1.0'
|
|
assert cs['DIFFUSIVITY'] == '1.0'
|
|
assert cs['SPECIFIC GRAVITY'] == '1.0'
|
|
assert cs['TRIALS'] == '40'
|
|
assert cs['ACCURACY'] == '0.001'
|
|
assert cs['HEADERROR'] == '0.0'
|
|
assert cs['FLOWCHANGE'] == '0.0'
|
|
assert cs['MINIMUM PRESSURE'] == '0.0'
|
|
assert cs['REQUIRED PRESSURE'] == '0.1'
|
|
assert cs['PRESSURE EXPONENT'] == '0.5'
|
|
assert cs['TOLERANCE'] == '0.01'
|
|
assert cs['HTOL'] == '0.0005'
|
|
assert cs['QTOL'] == '0.0001'
|
|
assert cs['RQTOL'] == '0.0000001'
|
|
assert cs['CHECKFREQ'] == '2'
|
|
assert cs['MAXCHECK'] == '10'
|
|
assert cs['DAMPLIMIT'] == '0'
|
|
|
|
css = execute_redo(p).operations
|
|
cs = css[0]
|
|
assert cs['UNITS'] == OPTION_UNITS_LPS
|
|
assert cs['PRESSURE'] == OPTION_PRESSURE_KPA
|
|
assert cs['HEADLOSS'] == OPTION_HEADLOSS_DW
|
|
assert cs['QUALITY'] == f'{OPTION_QUALITY_TRACE} 1'
|
|
assert cs['UNBALANCED'] == OPTION_UNBALANCED_CONTINUE
|
|
assert cs['PATTERN'] == '2'
|
|
assert cs['DEMAND MODEL'] == OPTION_DEMAND_MODEL_PDA
|
|
assert cs['DEMAND MULTIPLIER'] == '2.0'
|
|
assert cs['EMITTER EXPONENT'] == '1.5'
|
|
assert cs['VISCOSITY'] == '2.0'
|
|
assert cs['DIFFUSIVITY'] == '2.0'
|
|
assert cs['SPECIFIC GRAVITY'] == '2.0'
|
|
assert cs['TRIALS'] == '50'
|
|
assert cs['ACCURACY'] == '0.0001'
|
|
assert cs['HEADERROR'] == '0.01'
|
|
assert cs['FLOWCHANGE'] == '0.01'
|
|
assert cs['MINIMUM PRESSURE'] == '0.01'
|
|
assert cs['REQUIRED PRESSURE'] == '0.01'
|
|
assert cs['PRESSURE EXPONENT'] == '0.05'
|
|
assert cs['TOLERANCE'] == '0.001'
|
|
assert cs['HTOL'] == '0.005'
|
|
assert cs['QTOL'] == '0.001'
|
|
assert cs['RQTOL'] == '0.000001'
|
|
assert cs['CHECKFREQ'] == '1'
|
|
assert cs['MAXCHECK'] == '15'
|
|
assert cs['DAMPLIMIT'] == '1'
|
|
cs = css[1]
|
|
assert cs['FLOW_UNITS'] == OPTION_V3_FLOW_UNITS_LPS
|
|
assert cs['PRESSURE_UNITS'] == OPTION_V3_PRESSURE_UNITS_KPA
|
|
assert cs['HEADLOSS_MODEL'] == OPTION_V3_HEADLOSS_MODEL_DW
|
|
assert cs['SPECIFIC_GRAVITY'] == '2.0'
|
|
assert cs['SPECIFIC_VISCOSITY'] == '2.0'
|
|
assert cs['MAXIMUM_TRIALS'] == '50'
|
|
assert cs['HEAD_TOLERANCE'] == '0.005'
|
|
assert cs['FLOW_TOLERANCE'] == '0.001'
|
|
assert cs['FLOW_CHANGE_LIMIT'] == '0.01'
|
|
assert cs['RELATIVE_ACCURACY'] == '0.0001'
|
|
assert cs['IF_UNBALANCED'] == OPTION_V3_IF_UNBALANCED_CONTINUE
|
|
assert cs['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_POWER
|
|
assert cs['DEMAND_PATTERN'] == '2'
|
|
assert cs['DEMAND_MULTIPLIER'] == '2.0'
|
|
assert cs['MINIMUM_PRESSURE'] == '0.01'
|
|
assert cs['SERVICE_PRESSURE'] == '0.01'
|
|
assert cs['PRESSURE_EXPONENT'] == '0.05'
|
|
assert cs['EMITTER_EXPONENT'] == '1.5'
|
|
assert cs['QUALITY_MODEL'] == OPTION_V3_QUALITY_MODEL_TRACE
|
|
assert cs['TRACE_NODE'] == '1'
|
|
assert cs['SPECIFIC_DIFFUSIVITY'] == '2.0'
|
|
assert cs['QUALITY_TOLERANCE'] == '0.001'
|
|
|
|
o3['FLOW_UNITS'] = OPTION_V3_FLOW_UNITS_GPM
|
|
o3['PRESSURE_UNITS'] = OPTION_V3_PRESSURE_UNITS_PSI
|
|
o3['HEADLOSS_MODEL'] = OPTION_V3_HEADLOSS_MODEL_HW
|
|
o3['SPECIFIC_GRAVITY'] = '1.0'
|
|
o3['SPECIFIC_VISCOSITY'] = '1.0'
|
|
o3['MAXIMUM_TRIALS'] = '40'
|
|
o3['HEAD_TOLERANCE'] = '0.0005'
|
|
o3['FLOW_TOLERANCE'] = '0.0001'
|
|
o3['FLOW_CHANGE_LIMIT'] = '0.0'
|
|
o3['RELATIVE_ACCURACY'] = '0.001'
|
|
o3['TIME_WEIGHT'] = '0.0'
|
|
o3['STEP_SIZING'] = OPTION_V3_STEP_SIZING_RELAXATION
|
|
o3['IF_UNBALANCED'] = OPTION_V3_IF_UNBALANCED_STOP
|
|
o3['DEMAND_MODEL'] = OPTION_V3_DEMAND_MODEL_FIXED
|
|
o3['DEMAND_PATTERN'] = '1'
|
|
o3['DEMAND_MULTIPLIER'] = '1.0'
|
|
o3['MINIMUM_PRESSURE'] = '0.0'
|
|
o3['SERVICE_PRESSURE'] = '0.1'
|
|
o3['PRESSURE_EXPONENT'] = '0.5'
|
|
o3['LEAKAGE_MODEL'] = OPTION_V3_LEAKAGE_MODEL_POWER
|
|
o3['LEAKAGE_COEFF1'] = '1.0'
|
|
o3['LEAKAGE_COEFF2'] = '2.0'
|
|
o3['EMITTER_EXPONENT'] = '0.5'
|
|
o3['QUALITY_MODEL'] = OPTION_V3_QUALITY_MODEL_TRACE
|
|
o3['QUALITY_NAME'] = OPTION_V3_QUALITY_MODEL_NONE
|
|
o3['QUALITY_UNITS'] = OPTION_V3_QUALITY_UNITS_HRS
|
|
o3['TRACE_NODE'] = '2'
|
|
o3['SPECIFIC_DIFFUSIVITY'] = '1.0'
|
|
o3['QUALITY_TOLERANCE'] = '0.01'
|
|
|
|
css = set_option_v3(p, ChangeSet(o3)).operations
|
|
cs = css[0]
|
|
assert cs['FLOW_UNITS'] == OPTION_V3_FLOW_UNITS_GPM
|
|
assert cs['PRESSURE_UNITS'] == OPTION_V3_PRESSURE_UNITS_PSI
|
|
assert cs['HEADLOSS_MODEL'] == OPTION_V3_HEADLOSS_MODEL_HW
|
|
assert cs['SPECIFIC_GRAVITY'] == '1.0'
|
|
assert cs['SPECIFIC_VISCOSITY'] == '1.0'
|
|
assert cs['MAXIMUM_TRIALS'] == '40'
|
|
assert cs['HEAD_TOLERANCE'] == '0.0005'
|
|
assert cs['FLOW_TOLERANCE'] == '0.0001'
|
|
assert cs['FLOW_CHANGE_LIMIT'] == '0.0'
|
|
assert cs['RELATIVE_ACCURACY'] == '0.001'
|
|
assert cs['TIME_WEIGHT'] == '0.0'
|
|
assert cs['STEP_SIZING'] == OPTION_V3_STEP_SIZING_RELAXATION
|
|
assert cs['IF_UNBALANCED'] == OPTION_V3_IF_UNBALANCED_STOP
|
|
assert cs['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_FIXED
|
|
assert cs['DEMAND_PATTERN'] == '1'
|
|
assert cs['DEMAND_MULTIPLIER'] == '1.0'
|
|
assert cs['MINIMUM_PRESSURE'] == '0.0'
|
|
assert cs['SERVICE_PRESSURE'] == '0.1'
|
|
assert cs['PRESSURE_EXPONENT'] == '0.5'
|
|
assert cs['LEAKAGE_MODEL'] == OPTION_V3_LEAKAGE_MODEL_POWER
|
|
assert cs['LEAKAGE_COEFF1'] == '1.0'
|
|
assert cs['LEAKAGE_COEFF2'] == '2.0'
|
|
assert cs['EMITTER_EXPONENT'] == '0.5'
|
|
assert cs['QUALITY_MODEL'] == OPTION_V3_QUALITY_MODEL_TRACE
|
|
assert cs['QUALITY_NAME'] == OPTION_V3_QUALITY_MODEL_NONE
|
|
assert cs['QUALITY_UNITS'] == OPTION_V3_QUALITY_UNITS_HRS
|
|
assert cs['TRACE_NODE'] == '2'
|
|
assert cs['SPECIFIC_DIFFUSIVITY'] == '1.0'
|
|
assert cs['QUALITY_TOLERANCE'] == '0.01'
|
|
cs = css[1]
|
|
assert cs['UNITS'] == OPTION_UNITS_GPM
|
|
assert cs['PRESSURE'] == OPTION_PRESSURE_PSI
|
|
assert cs['HEADLOSS'] == OPTION_HEADLOSS_HW
|
|
assert cs['QUALITY'] == f'{OPTION_QUALITY_TRACE} 2'
|
|
assert cs['UNBALANCED'] == OPTION_UNBALANCED_STOP
|
|
assert cs['PATTERN'] == '1'
|
|
assert cs['DEMAND MODEL'] == OPTION_DEMAND_MODEL_DDA
|
|
assert cs['DEMAND MULTIPLIER'] == '1.0'
|
|
assert cs['EMITTER EXPONENT'] == '0.5'
|
|
assert cs['VISCOSITY'] == '1.0'
|
|
assert cs['DIFFUSIVITY'] == '1.0'
|
|
assert cs['SPECIFIC GRAVITY'] == '1.0'
|
|
assert cs['TRIALS'] == '40'
|
|
assert cs['ACCURACY'] == '0.001'
|
|
assert cs['FLOWCHANGE'] == '0.0'
|
|
assert cs['MINIMUM PRESSURE'] == '0.0'
|
|
assert cs['REQUIRED PRESSURE'] == '0.1'
|
|
assert cs['PRESSURE EXPONENT'] == '0.5'
|
|
assert cs['TOLERANCE'] == '0.01'
|
|
assert cs['HTOL'] == '0.0005'
|
|
assert cs['QTOL'] == '0.0001'
|
|
|
|
css = execute_undo(p).operations
|
|
cs = css[0]
|
|
assert cs['UNITS'] == OPTION_UNITS_LPS
|
|
assert cs['PRESSURE'] == OPTION_PRESSURE_KPA
|
|
assert cs['HEADLOSS'] == OPTION_HEADLOSS_DW
|
|
assert cs['QUALITY'] == f'{OPTION_QUALITY_TRACE} 1'
|
|
assert cs['UNBALANCED'] == OPTION_UNBALANCED_CONTINUE
|
|
assert cs['PATTERN'] == '2'
|
|
assert cs['DEMAND MODEL'] == OPTION_DEMAND_MODEL_PDA
|
|
assert cs['DEMAND MULTIPLIER'] == '2.0'
|
|
assert cs['EMITTER EXPONENT'] == '1.5'
|
|
assert cs['VISCOSITY'] == '2.0'
|
|
assert cs['DIFFUSIVITY'] == '2.0'
|
|
assert cs['SPECIFIC GRAVITY'] == '2.0'
|
|
assert cs['TRIALS'] == '50'
|
|
assert cs['ACCURACY'] == '0.0001'
|
|
assert cs['FLOWCHANGE'] == '0.01'
|
|
assert cs['MINIMUM PRESSURE'] == '0.01'
|
|
assert cs['REQUIRED PRESSURE'] == '0.01'
|
|
assert cs['PRESSURE EXPONENT'] == '0.05'
|
|
assert cs['TOLERANCE'] == '0.001'
|
|
assert cs['HTOL'] == '0.005'
|
|
assert cs['QTOL'] == '0.001'
|
|
cs = css[1]
|
|
o3['FLOW_UNITS'] = OPTION_V3_FLOW_UNITS_GPM
|
|
o3['PRESSURE_UNITS'] = OPTION_V3_PRESSURE_UNITS_PSI
|
|
o3['HEADLOSS_MODEL'] = OPTION_V3_HEADLOSS_MODEL_HW
|
|
o3['SPECIFIC_GRAVITY'] = '1.0'
|
|
o3['SPECIFIC_VISCOSITY'] = '1.0'
|
|
o3['MAXIMUM_TRIALS'] = '40'
|
|
o3['HEAD_TOLERANCE'] = '0.0005'
|
|
o3['FLOW_TOLERANCE'] = '0.0001'
|
|
o3['FLOW_CHANGE_LIMIT'] = '0.0'
|
|
o3['RELATIVE_ACCURACY'] = '0.001'
|
|
o3['TIME_WEIGHT'] = '0.0'
|
|
o3['STEP_SIZING'] = OPTION_V3_STEP_SIZING_RELAXATION
|
|
o3['IF_UNBALANCED'] = OPTION_V3_IF_UNBALANCED_STOP
|
|
o3['DEMAND_MODEL'] = OPTION_V3_DEMAND_MODEL_FIXED
|
|
o3['DEMAND_PATTERN'] = '1'
|
|
o3['DEMAND_MULTIPLIER'] = '1.0'
|
|
o3['MINIMUM_PRESSURE'] = '0.0'
|
|
o3['SERVICE_PRESSURE'] = '0.1'
|
|
o3['PRESSURE_EXPONENT'] = '0.5'
|
|
o3['LEAKAGE_MODEL'] = OPTION_V3_LEAKAGE_MODEL_POWER
|
|
o3['LEAKAGE_COEFF1'] = '1.0'
|
|
o3['LEAKAGE_COEFF2'] = '2.0'
|
|
o3['EMITTER_EXPONENT'] = '0.5'
|
|
o3['QUALITY_MODEL'] = OPTION_V3_QUALITY_MODEL_TRACE
|
|
o3['QUALITY_NAME'] = OPTION_V3_QUALITY_MODEL_NONE
|
|
o3['QUALITY_UNITS'] = OPTION_V3_QUALITY_UNITS_HRS
|
|
o3['TRACE_NODE'] = '2'
|
|
o3['SPECIFIC_DIFFUSIVITY'] = '1.0'
|
|
o3['QUALITY_TOLERANCE'] = '0.01'
|
|
|
|
css = execute_redo(p).operations
|
|
cs = css[0]
|
|
assert cs['FLOW_UNITS'] == OPTION_V3_FLOW_UNITS_GPM
|
|
assert cs['PRESSURE_UNITS'] == OPTION_V3_PRESSURE_UNITS_PSI
|
|
assert cs['HEADLOSS_MODEL'] == OPTION_V3_HEADLOSS_MODEL_HW
|
|
assert cs['SPECIFIC_GRAVITY'] == '1.0'
|
|
assert cs['SPECIFIC_VISCOSITY'] == '1.0'
|
|
assert cs['MAXIMUM_TRIALS'] == '40'
|
|
assert cs['HEAD_TOLERANCE'] == '0.0005'
|
|
assert cs['FLOW_TOLERANCE'] == '0.0001'
|
|
assert cs['FLOW_CHANGE_LIMIT'] == '0.0'
|
|
assert cs['RELATIVE_ACCURACY'] == '0.001'
|
|
assert cs['TIME_WEIGHT'] == '0.0'
|
|
assert cs['STEP_SIZING'] == OPTION_V3_STEP_SIZING_RELAXATION
|
|
assert cs['IF_UNBALANCED'] == OPTION_V3_IF_UNBALANCED_STOP
|
|
assert cs['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_FIXED
|
|
assert cs['DEMAND_PATTERN'] == '1'
|
|
assert cs['DEMAND_MULTIPLIER'] == '1.0'
|
|
assert cs['MINIMUM_PRESSURE'] == '0.0'
|
|
assert cs['SERVICE_PRESSURE'] == '0.1'
|
|
assert cs['PRESSURE_EXPONENT'] == '0.5'
|
|
assert cs['LEAKAGE_MODEL'] == OPTION_V3_LEAKAGE_MODEL_POWER
|
|
assert cs['LEAKAGE_COEFF1'] == '1.0'
|
|
assert cs['LEAKAGE_COEFF2'] == '2.0'
|
|
assert cs['EMITTER_EXPONENT'] == '0.5'
|
|
assert cs['QUALITY_MODEL'] == OPTION_V3_QUALITY_MODEL_TRACE
|
|
assert cs['QUALITY_NAME'] == OPTION_V3_QUALITY_MODEL_NONE
|
|
assert cs['QUALITY_UNITS'] == OPTION_V3_QUALITY_UNITS_HRS
|
|
assert cs['TRACE_NODE'] == '2'
|
|
assert cs['SPECIFIC_DIFFUSIVITY'] == '1.0'
|
|
assert cs['QUALITY_TOLERANCE'] == '0.01'
|
|
cs = css[1]
|
|
assert cs['UNITS'] == OPTION_UNITS_GPM
|
|
assert cs['PRESSURE'] == OPTION_PRESSURE_PSI
|
|
assert cs['HEADLOSS'] == OPTION_HEADLOSS_HW
|
|
assert cs['QUALITY'] == f'{OPTION_QUALITY_TRACE} 2'
|
|
assert cs['UNBALANCED'] == OPTION_UNBALANCED_STOP
|
|
assert cs['PATTERN'] == '1'
|
|
assert cs['DEMAND MODEL'] == OPTION_DEMAND_MODEL_DDA
|
|
assert cs['DEMAND MULTIPLIER'] == '1.0'
|
|
assert cs['EMITTER EXPONENT'] == '0.5'
|
|
assert cs['VISCOSITY'] == '1.0'
|
|
assert cs['DIFFUSIVITY'] == '1.0'
|
|
assert cs['SPECIFIC GRAVITY'] == '1.0'
|
|
assert cs['TRIALS'] == '40'
|
|
assert cs['ACCURACY'] == '0.001'
|
|
assert cs['FLOWCHANGE'] == '0.0'
|
|
assert cs['MINIMUM PRESSURE'] == '0.0'
|
|
assert cs['REQUIRED PRESSURE'] == '0.1'
|
|
assert cs['PRESSURE EXPONENT'] == '0.5'
|
|
assert cs['TOLERANCE'] == '0.01'
|
|
assert cs['HTOL'] == '0.0005'
|
|
assert cs['QTOL'] == '0.0001'
|
|
|
|
o3 = get_option_v3(p)
|
|
|
|
o3['DEMAND_MODEL'] = OPTION_V3_DEMAND_MODEL_CONSTRAINED
|
|
|
|
css = set_option_v3(p, ChangeSet(o3)).operations
|
|
cs = css[0]
|
|
assert cs['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_CONSTRAINED
|
|
cs = css[1]
|
|
assert cs['DEMAND MODEL'] == OPTION_DEMAND_MODEL_PDA
|
|
|
|
css = execute_undo(p).operations
|
|
cs = css[0]
|
|
assert cs['DEMAND MODEL'] == OPTION_DEMAND_MODEL_DDA
|
|
cs = css[1]
|
|
assert cs['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_FIXED
|
|
|
|
css = execute_redo(p).operations
|
|
cs = css[0]
|
|
assert cs['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_CONSTRAINED
|
|
cs = css[1]
|
|
assert cs['DEMAND MODEL'] == OPTION_DEMAND_MODEL_PDA
|
|
|
|
o3 = get_option_v3(p)
|
|
|
|
o3['DEMAND_MODEL'] = OPTION_V3_DEMAND_MODEL_LOGISTIC
|
|
|
|
css = set_option_v3(p, ChangeSet(o3)).operations
|
|
cs = css[0]
|
|
assert cs['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_LOGISTIC
|
|
cs = css[1]
|
|
assert cs['DEMAND MODEL'] == OPTION_DEMAND_MODEL_PDA
|
|
|
|
css = execute_undo(p).operations
|
|
cs = css[0]
|
|
assert cs['DEMAND MODEL'] == OPTION_DEMAND_MODEL_PDA
|
|
cs = css[1]
|
|
assert cs['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_CONSTRAINED
|
|
|
|
css = execute_redo(p).operations
|
|
cs = css[0]
|
|
assert cs['DEMAND_MODEL'] == OPTION_V3_DEMAND_MODEL_LOGISTIC
|
|
cs = css[1]
|
|
assert cs['DEMAND MODEL'] == OPTION_DEMAND_MODEL_PDA
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 25 vertex
|
|
|
|
|
|
def test_vertex(self):
|
|
p = 'test_vertex'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
|
|
v = get_vertex(p, 'p0')
|
|
assert v['link'] == 'p0'
|
|
assert v['coords'] == []
|
|
|
|
set_vertex(p, ChangeSet({'link' : 'p0', 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
|
|
|
|
v = get_vertex(p, 'p0')
|
|
xys = v['coords']
|
|
assert len(xys) == 2
|
|
assert xys[0]['x'] == 1.0
|
|
assert xys[0]['y'] == 2.0
|
|
assert xys[1]['x'] == 2.0
|
|
assert xys[1]['y'] == 1.0
|
|
|
|
set_vertex(p, ChangeSet({'link' : 'p0', 'coords': []}))
|
|
|
|
v = get_vertex(p, 'p0')
|
|
assert v['link'] == 'p0'
|
|
assert v['coords'] == []
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_vertex_op(self):
|
|
p = 'test_vertex_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
|
|
cs = set_vertex(p, ChangeSet({'link' : 'p0', 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'vertex'
|
|
assert cs['link'] == 'p0'
|
|
xys = cs['coords']
|
|
assert len(xys) == 2
|
|
assert xys[0]['x'] == 1.0
|
|
assert xys[0]['y'] == 2.0
|
|
assert xys[1]['x'] == 2.0
|
|
assert xys[1]['y'] == 1.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'vertex'
|
|
assert cs['link'] == 'p0'
|
|
assert cs['coords'] == []
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'vertex'
|
|
assert cs['link'] == 'p0'
|
|
xys = cs['coords']
|
|
assert len(xys) == 2
|
|
assert xys[0]['x'] == 1.0
|
|
assert xys[0]['y'] == 2.0
|
|
assert xys[1]['x'] == 2.0
|
|
assert xys[1]['y'] == 1.0
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 26 label
|
|
|
|
|
|
def test_label(self):
|
|
p = 'test_label'
|
|
self.enter(p)
|
|
|
|
l = get_label(p, 0.0, 0.0)
|
|
assert l['x'] == 0.0
|
|
assert l['y'] == 0.0
|
|
assert l['label'] == None
|
|
assert l['node'] == None
|
|
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_label(p, ChangeSet({'x': 0.0, 'y': 0.0, 'label': 'x', 'node': 'j0'}))
|
|
l = get_label(p, 0.0, 0.0)
|
|
assert l['x'] == 0.0
|
|
assert l['y'] == 0.0
|
|
assert l['label'] == 'x'
|
|
assert l['node'] == 'j0'
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 1.0, 'y': 20.0, 'elevation': 20.0}))
|
|
set_label(p, ChangeSet({'x': 0.0, 'y': 0.0, 'label': 'xxx', 'node': 'j1'}))
|
|
l = get_label(p, 0.0, 0.0)
|
|
assert l['x'] == 0.0
|
|
assert l['y'] == 0.0
|
|
assert l['label'] == 'xxx'
|
|
assert l['node'] == 'j1'
|
|
|
|
delete_label(p, ChangeSet({'x': 0.0, 'y': 0.0}))
|
|
l = get_label(p, 0.0, 0.0)
|
|
assert l['x'] == 0.0
|
|
assert l['y'] == 0.0
|
|
assert l['label'] == None
|
|
assert l['node'] == None
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_label_op(self):
|
|
p = 'test_label_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 1.0, 'y': 20.0, 'elevation': 20.0}))
|
|
|
|
cs = add_label(p, ChangeSet({'x': 0.0, 'y': 0.0, 'label': 'x', 'node': 'j0'})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'label'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 0.0
|
|
assert cs['label'] == 'x'
|
|
assert cs['node'] == 'j0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'label'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 0.0
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'label'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 0.0
|
|
assert cs['label'] == 'x'
|
|
assert cs['node'] == 'j0'
|
|
|
|
cs = set_label(p, ChangeSet({'x': 0.0, 'y': 0.0, 'label': 'xxx', 'node': 'j1'})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'label'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 0.0
|
|
assert cs['label'] == 'xxx'
|
|
assert cs['node'] == 'j1'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'label'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 0.0
|
|
assert cs['label'] == 'x'
|
|
assert cs['node'] == 'j0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'label'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 0.0
|
|
assert cs['label'] == 'xxx'
|
|
assert cs['node'] == 'j1'
|
|
|
|
cs = delete_label(p, ChangeSet({'x': 0.0, 'y': 0.0})).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'label'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 0.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'label'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 0.0
|
|
assert cs['label'] == 'xxx'
|
|
assert cs['node'] == 'j1'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'label'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 0.0
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 27 backdrop
|
|
|
|
|
|
def test_backdrop(self):
|
|
p = 'test_backdrop'
|
|
self.enter(p)
|
|
|
|
assert get_backdrop(p)['content'] == ''
|
|
|
|
set_backdrop(p, ChangeSet({'content': 'x'}))
|
|
assert get_backdrop(p)['content'] == 'x'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_backdrop_op(self):
|
|
p = 'test_backdrop_op'
|
|
self.enter(p)
|
|
|
|
cs = set_backdrop(p, ChangeSet({'content': 'x'})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'backdrop'
|
|
assert cs['content'] == 'x'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'backdrop'
|
|
assert cs['content'] == ''
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'backdrop'
|
|
assert cs['content'] == 'x'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 28 end
|
|
|
|
|
|
# 29 scada_device
|
|
|
|
|
|
def test_scada_device(self):
|
|
p = 'test_scada_device'
|
|
self.enter(p)
|
|
|
|
assert get_scada_devices(p) == []
|
|
|
|
d = get_scada_device(p, 'd0')
|
|
assert d == {}
|
|
|
|
add_scada_device(p, ChangeSet({'id': 'd0'}))
|
|
d = get_scada_device(p, 'd0')
|
|
assert d['id'] == 'd0'
|
|
assert d['name'] == None
|
|
assert d['address'] == None
|
|
assert d['sd_type'] == None
|
|
|
|
set_scada_device(p, ChangeSet({'id': 'd0', 'name': 'device0', 'address': 'x', 'sd_type': SCADA_DEVICE_TYPE_FLOW}))
|
|
d = get_scada_device(p, 'd0')
|
|
assert d['id'] == 'd0'
|
|
assert d['name'] == 'device0'
|
|
assert d['address'] == 'x'
|
|
assert d['sd_type'] == SCADA_DEVICE_TYPE_FLOW
|
|
|
|
add_scada_device(p, ChangeSet({'id': 'd1', 'name': 'device1', 'address': 'x', 'sd_type': SCADA_DEVICE_TYPE_PRESSURE}))
|
|
d = get_scada_device(p, 'd1')
|
|
assert d['id'] == 'd1'
|
|
assert d['name'] == 'device1'
|
|
assert d['address'] == 'x'
|
|
assert d['sd_type'] == SCADA_DEVICE_TYPE_PRESSURE
|
|
|
|
devices = get_scada_devices(p)
|
|
assert len(devices) == 2
|
|
assert devices[0] == 'd0'
|
|
assert devices[1] == 'd1'
|
|
|
|
delete_scada_device(p, ChangeSet({'id': 'd0'}))
|
|
d = get_scada_device(p, 'd0')
|
|
assert d == {}
|
|
|
|
delete_scada_device(p, ChangeSet({'id': 'd1'}))
|
|
d = get_scada_device(p, 'd1')
|
|
assert d == {}
|
|
|
|
assert get_scada_devices(p) == []
|
|
|
|
add_scada_device(p, ChangeSet({'id': 'd0'}))
|
|
d = get_scada_device(p, 'd0')
|
|
assert d['id'] == 'd0'
|
|
|
|
add_scada_device(p, ChangeSet({'id': 'd1'}))
|
|
d = get_scada_device(p, 'd1')
|
|
assert d['id'] == 'd1'
|
|
|
|
devices = get_scada_devices(p)
|
|
assert len(devices) == 2
|
|
assert devices[0] == 'd0'
|
|
assert devices[1] == 'd1'
|
|
|
|
clean_scada_device(p)
|
|
d = get_scada_device(p, 'd0')
|
|
assert d == {}
|
|
d = get_scada_device(p, 'd1')
|
|
assert d == {}
|
|
|
|
assert get_scada_devices(p) == []
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_scada_device_op(self):
|
|
p = 'test_scada_device_op'
|
|
|
|
self.enter(p)
|
|
|
|
cs = add_scada_device(p, ChangeSet({'id': 'd0'})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
assert cs['name'] == None
|
|
assert cs['address'] == None
|
|
assert cs['sd_type'] == None
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
assert cs['name'] == None
|
|
assert cs['address'] == None
|
|
assert cs['sd_type'] == None
|
|
|
|
cs = set_scada_device(p, ChangeSet({'id': 'd0', 'name': 'device0', 'address': 'x', 'sd_type': SCADA_DEVICE_TYPE_FLOW})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
assert cs['name'] == 'device0'
|
|
assert cs['address'] == 'x'
|
|
assert cs['sd_type'] == SCADA_DEVICE_TYPE_FLOW
|
|
|
|
cs = add_scada_device(p, ChangeSet({'id': 'd1', 'name': 'device1', 'address': 'x', 'sd_type': SCADA_DEVICE_TYPE_PRESSURE})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd1'
|
|
assert cs['name'] == 'device1'
|
|
assert cs['address'] == 'x'
|
|
assert cs['sd_type'] == SCADA_DEVICE_TYPE_PRESSURE
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd1'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd1'
|
|
assert cs['name'] == 'device1'
|
|
assert cs['address'] == 'x'
|
|
assert cs['sd_type'] == SCADA_DEVICE_TYPE_PRESSURE
|
|
|
|
cs = delete_scada_device(p, ChangeSet({'id': 'd0'})).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
assert cs['name'] == 'device0'
|
|
assert cs['address'] == 'x'
|
|
assert cs['sd_type'] == SCADA_DEVICE_TYPE_FLOW
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
|
|
cs = delete_scada_device(p, ChangeSet({'id': 'd1'})).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd1'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd1'
|
|
assert cs['name'] == 'device1'
|
|
assert cs['address'] == 'x'
|
|
assert cs['sd_type'] == SCADA_DEVICE_TYPE_PRESSURE
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd1'
|
|
|
|
cs = add_scada_device(p, ChangeSet({'id': 'd0'})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
assert cs['name'] == None
|
|
assert cs['address'] == None
|
|
assert cs['sd_type'] == None
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
assert cs['name'] == None
|
|
assert cs['address'] == None
|
|
assert cs['sd_type'] == None
|
|
|
|
cs = add_scada_device(p, ChangeSet({'id': 'd1'})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd1'
|
|
assert cs['name'] == None
|
|
assert cs['address'] == None
|
|
assert cs['sd_type'] == None
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd1'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd1'
|
|
assert cs['name'] == None
|
|
assert cs['address'] == None
|
|
assert cs['sd_type'] == None
|
|
|
|
css = clean_scada_device(p).operations
|
|
assert len(css) == 2
|
|
cs = css[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
cs = css[1]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd1'
|
|
|
|
css = execute_undo(p).operations
|
|
assert len(css) == 2
|
|
cs = css[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd1'
|
|
assert cs['name'] == None
|
|
assert cs['address'] == None
|
|
assert cs['sd_type'] == None
|
|
cs = css[1]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
assert cs['name'] == None
|
|
assert cs['address'] == None
|
|
assert cs['sd_type'] == None
|
|
|
|
css = execute_redo(p).operations
|
|
assert len(css) == 2
|
|
cs = css[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd0'
|
|
cs = css[1]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device'
|
|
assert cs['id'] == 'd1'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 30 scada_device_data
|
|
|
|
|
|
def test_scada_device_data(self):
|
|
p = 'test_scada_device_data'
|
|
self.enter(p)
|
|
|
|
add_scada_device(p, ChangeSet({'id': 'sd'}))
|
|
|
|
sa = get_scada_device_data(p, 'sd')
|
|
assert sa['device_id'] == 'sd'
|
|
assert sa['data'] == []
|
|
|
|
set_scada_device_data(p, ChangeSet({'device_id': 'sd', 'data': [{ 'time': '2023-02-10 00:02:22', 'value': 100.0 }]}))
|
|
sa = get_scada_device_data(p, 'sd')
|
|
assert sa['device_id'] == 'sd'
|
|
assert len(sa['data']) == 1
|
|
assert sa['data'][0]['time'] == '2023-02-10 00:02:22'
|
|
assert sa['data'][0]['value'] == 100.0
|
|
|
|
set_scada_device_data(p, ChangeSet({'device_id': 'sd', 'data': [{ 'time': '2023-02-10 00:02:22', 'value': 100.0 }, { 'time': '2023-02-10 00:03:22', 'value': 200.0 }]}))
|
|
sa = get_scada_device_data(p, 'sd')
|
|
assert sa['device_id'] == 'sd'
|
|
assert len(sa['data']) == 2
|
|
assert sa['data'][0]['time'] == '2023-02-10 00:02:22'
|
|
assert sa['data'][0]['value'] == 100.0
|
|
assert sa['data'][1]['time'] == '2023-02-10 00:03:22'
|
|
assert sa['data'][1]['value'] == 200.0
|
|
|
|
add_scada_device_data(p, ChangeSet({'device_id': 'sd', 'time': '2023-02-10 00:02:22', 'value': 100.0}))
|
|
sa = get_scada_device_data(p, 'sd')
|
|
assert sa['device_id'] == 'sd'
|
|
assert len(sa['data']) == 2
|
|
assert sa['data'][0]['time'] == '2023-02-10 00:02:22'
|
|
assert sa['data'][0]['value'] == 100.0
|
|
assert sa['data'][1]['time'] == '2023-02-10 00:03:22'
|
|
assert sa['data'][1]['value'] == 200.0
|
|
|
|
add_scada_device_data(p, ChangeSet({'device_id': 'sd', 'time': '2023-02-11 00:02:22', 'value': 100.0}))
|
|
sa = get_scada_device_data(p, 'sd')
|
|
assert sa['device_id'] == 'sd'
|
|
assert len(sa['data']) == 3
|
|
assert sa['data'][0]['time'] == '2023-02-10 00:02:22'
|
|
assert sa['data'][0]['value'] == 100.0
|
|
assert sa['data'][1]['time'] == '2023-02-10 00:03:22'
|
|
assert sa['data'][1]['value'] == 200.0
|
|
assert sa['data'][2]['time'] == '2023-02-11 00:02:22'
|
|
assert sa['data'][2]['value'] == 100.0
|
|
|
|
delete_scada_device_data(p, ChangeSet({'device_id': 'sd', 'time': '2023-02-12 00:02:22'}))
|
|
sa = get_scada_device_data(p, 'sd')
|
|
assert sa['device_id'] == 'sd'
|
|
assert len(sa['data']) == 3
|
|
assert sa['data'][0]['time'] == '2023-02-10 00:02:22'
|
|
assert sa['data'][0]['value'] == 100.0
|
|
assert sa['data'][1]['time'] == '2023-02-10 00:03:22'
|
|
assert sa['data'][1]['value'] == 200.0
|
|
assert sa['data'][2]['time'] == '2023-02-11 00:02:22'
|
|
assert sa['data'][2]['value'] == 100.0
|
|
|
|
delete_scada_device_data(p, ChangeSet({'device_id': 'sd', 'time': '2023-02-11 00:02:22'}))
|
|
sa = get_scada_device_data(p, 'sd')
|
|
assert sa['device_id'] == 'sd'
|
|
assert len(sa['data']) == 2
|
|
assert sa['data'][0]['time'] == '2023-02-10 00:02:22'
|
|
assert sa['data'][0]['value'] == 100.0
|
|
assert sa['data'][1]['time'] == '2023-02-10 00:03:22'
|
|
assert sa['data'][1]['value'] == 200.0
|
|
|
|
set_scada_device_data(p, ChangeSet({'device_id': 'sd', 'data': []}))
|
|
sa = get_scada_device_data(p, 'sd')
|
|
assert sa['device_id'] == 'sd'
|
|
assert sa['data'] == []
|
|
|
|
add_scada_device(p, ChangeSet({'id': 'sd0'}))
|
|
add_scada_device_data(p, ChangeSet({'device_id': 'sd0', 'time': '2023-02-10 00:02:22', 'value': 100.0}))
|
|
add_scada_device_data(p, ChangeSet({'device_id': 'sd0', 'time': '2023-02-11 00:02:22', 'value': 200.0}))
|
|
add_scada_device_data(p, ChangeSet({'device_id': 'sd0', 'time': '2023-02-12 00:02:22', 'value': 300.0}))
|
|
|
|
add_scada_device(p, ChangeSet({'id': 'sd1'}))
|
|
set_scada_device_data(p, ChangeSet({'device_id': 'sd1', 'data': [{'time': '2023-02-10 00:02:22', 'value': 100.0}, {'time': '2023-02-11 00:02:22', 'value': 200.0}, {'time': '2023-02-12 00:02:22', 'value': 300.0}]}))
|
|
|
|
clean_scada_device_data(p)
|
|
sa = get_scada_device_data(p, 'sd0')
|
|
assert sa['device_id'] == 'sd0'
|
|
assert sa['data'] == []
|
|
sa = get_scada_device_data(p, 'sd1')
|
|
assert sa['device_id'] == 'sd1'
|
|
assert sa['data'] == []
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_scada_device_data_op(self):
|
|
p = 'test_scada_device_data_op'
|
|
self.enter(p)
|
|
|
|
add_scada_device(p, ChangeSet({'id': 'sd'}))
|
|
|
|
cs = set_scada_device_data(p, ChangeSet({'device_id': 'sd', 'data': [{ 'time': '2023-02-10 00:02:22', 'value': 100.0 }]})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert len(cs['data']) == 1
|
|
assert cs['data'][0]['time'] == '2023-02-10 00:02:22'
|
|
assert cs['data'][0]['value'] == 100.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert cs['data'] == []
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert len(cs['data']) == 1
|
|
assert cs['data'][0]['time'] == '2023-02-10 00:02:22'
|
|
assert cs['data'][0]['value'] == 100.0
|
|
|
|
cs = set_scada_device_data(p, ChangeSet({'device_id': 'sd', 'data': [{ 'time': '2023-02-10 00:02:22', 'value': 100.0 }, { 'time': '2023-02-10 00:03:22', 'value': 200.0 }]})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert len(cs['data']) == 2
|
|
assert cs['data'][0]['time'] == '2023-02-10 00:02:22'
|
|
assert cs['data'][0]['value'] == 100.0
|
|
assert cs['data'][1]['time'] == '2023-02-10 00:03:22'
|
|
assert cs['data'][1]['value'] == 200.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert len(cs['data']) == 1
|
|
assert cs['data'][0]['time'] == '2023-02-10 00:02:22'
|
|
assert cs['data'][0]['value'] == 100.0
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert len(cs['data']) == 2
|
|
assert cs['data'][0]['time'] == '2023-02-10 00:02:22'
|
|
assert cs['data'][0]['value'] == 100.0
|
|
assert cs['data'][1]['time'] == '2023-02-10 00:03:22'
|
|
assert cs['data'][1]['value'] == 200.0
|
|
|
|
cs = add_scada_device_data(p, ChangeSet({'device_id': 'sd', 'time': '2023-02-10 00:02:22', 'value': 100.0}))
|
|
assert len(cs.operations) == 0
|
|
|
|
cs = add_scada_device_data(p, ChangeSet({'device_id': 'sd', 'time': '2023-02-11 00:02:22', 'value': 100.0})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert cs['time'] == '2023-02-11 00:02:22'
|
|
assert cs['value'] == 100.0
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert cs['time'] == '2023-02-11 00:02:22'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert cs['time'] == '2023-02-11 00:02:22'
|
|
assert cs['value'] == 100.0
|
|
|
|
cs = delete_scada_device_data(p, ChangeSet({'device_id': 'sd', 'time': '2023-02-12 00:02:22'}))
|
|
assert len(cs.operations) == 0
|
|
|
|
cs = delete_scada_device_data(p, ChangeSet({'device_id': 'sd', 'time': '2023-02-11 00:02:22'})).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert cs['time'] == '2023-02-11 00:02:22'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert cs['time'] == '2023-02-11 00:02:22'
|
|
assert cs['value'] == 100.0
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert cs['time'] == '2023-02-11 00:02:22'
|
|
|
|
cs = set_scada_device_data(p, ChangeSet({'device_id': 'sd', 'data': []})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert cs['data'] == []
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert len(cs['data']) == 2
|
|
assert cs['data'][0]['time'] == '2023-02-10 00:02:22'
|
|
assert cs['data'][0]['value'] == 100.0
|
|
assert cs['data'][1]['time'] == '2023-02-10 00:03:22'
|
|
assert cs['data'][1]['value'] == 200.0
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd'
|
|
assert cs['data'] == []
|
|
|
|
add_scada_device(p, ChangeSet({'id': 'sd0'}))
|
|
add_scada_device_data(p, ChangeSet({'device_id': 'sd0', 'time': '2023-02-10 00:02:22', 'value': 100.0}))
|
|
add_scada_device_data(p, ChangeSet({'device_id': 'sd0', 'time': '2023-02-11 00:02:22', 'value': 200.0}))
|
|
add_scada_device_data(p, ChangeSet({'device_id': 'sd0', 'time': '2023-02-12 00:02:22', 'value': 300.0}))
|
|
|
|
add_scada_device(p, ChangeSet({'id': 'sd1'}))
|
|
set_scada_device_data(p, ChangeSet({'device_id': 'sd1', 'data': [{'time': '2023-02-10 00:02:22', 'value': 100.0}, {'time': '2023-02-11 00:02:22', 'value': 200.0}, {'time': '2023-02-12 00:02:22', 'value': 300.0}]}))
|
|
|
|
css = clean_scada_device_data(p).operations
|
|
cs = css[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd0'
|
|
assert cs['data'] == []
|
|
cs = css[1]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd1'
|
|
assert cs['data'] == []
|
|
|
|
css = execute_undo(p).operations
|
|
cs = css[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd1'
|
|
assert cs['data'][0] == {'time': '2023-02-10 00:02:22', 'value': 100.0}
|
|
assert cs['data'][1] == {'time': '2023-02-11 00:02:22', 'value': 200.0}
|
|
assert cs['data'][2] == {'time': '2023-02-12 00:02:22', 'value': 300.0}
|
|
cs = css[1]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd0'
|
|
assert cs['data'][0] == {'time': '2023-02-10 00:02:22', 'value': 100.0}
|
|
assert cs['data'][1] == {'time': '2023-02-11 00:02:22', 'value': 200.0}
|
|
assert cs['data'][2] == {'time': '2023-02-12 00:02:22', 'value': 300.0}
|
|
|
|
css = execute_redo(p).operations
|
|
cs = css[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd0'
|
|
assert cs['data'] == []
|
|
cs = css[1]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_device_data'
|
|
assert cs['device_id'] == 'sd1'
|
|
assert cs['data'] == []
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 31 scada_element
|
|
|
|
|
|
def test_scada_element(self):
|
|
p = 'test_scada_element'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pipe(p, ChangeSet({'id': 'p1', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
add_scada_device(p, ChangeSet({'id': 'sd0', 'name': 'device0', 'address': 'x0', 'sd_type': SCADA_DEVICE_TYPE_PRESSURE}))
|
|
add_scada_device(p, ChangeSet({'id': 'sd1', 'name': 'device1', 'address': 'x1', 'sd_type': SCADA_DEVICE_TYPE_FLOW}))
|
|
|
|
assert get_scada_elements(p) == []
|
|
|
|
add_scada_element(p, ChangeSet({'id': 'sm0', 'x': 0.0, 'y': 1.0, 'device_id': 'sd0', 'model_id': 'j0', 'model_type': SCADA_MODEL_TYPE_JUNCTION, 'status': SCADA_ELEMENT_STATUS_OFFLINE}))
|
|
sm = get_scada_element(p, 'sm0')
|
|
assert sm == {}
|
|
add_scada_element(p, ChangeSet({'id': 'sm0', 'x': 0.0, 'y': 1.0, 'device_id': 'sd0', 'model_id': 'j0', 'status': SCADA_ELEMENT_STATUS_OFFLINE}))
|
|
sm = get_scada_element(p, 'sm0')
|
|
assert sm == {}
|
|
add_scada_element(p, ChangeSet({'id': 'sm0', 'x': 0.0, 'y': 1.0, 'device_id': 'sd0', 'model_type': SCADA_MODEL_TYPE_JUNCTION, 'status': SCADA_ELEMENT_STATUS_OFFLINE}))
|
|
sm = get_scada_element(p, 'sm0')
|
|
assert sm == {}
|
|
add_scada_element(p, ChangeSet({'id': 'sm0', 'x': 0.0, 'y': 1.0, 'device_id': 'sd0', 'model_type': SCADA_MODEL_TYPE_PIPE, 'status': SCADA_ELEMENT_STATUS_OFFLINE}))
|
|
sm = get_scada_element(p, 'sm0')
|
|
assert sm == {}
|
|
|
|
add_scada_element(p, ChangeSet({'id': 'sm0', 'x': 0.0, 'y': 1.0, 'device_id': 'sd0', 'model_id': 'j1', 'model_type': SCADA_MODEL_TYPE_JUNCTION, 'status': SCADA_ELEMENT_STATUS_OFFLINE}))
|
|
sm = get_scada_element(p, 'sm0')
|
|
assert sm['id'] == 'sm0'
|
|
assert sm['x'] == 0.0
|
|
assert sm['y'] == 1.0
|
|
assert sm['device_id'] == 'sd0'
|
|
assert sm['model_id'] == 'j1'
|
|
assert sm['model_type'] == SCADA_MODEL_TYPE_JUNCTION
|
|
assert sm['status'] == SCADA_ELEMENT_STATUS_OFFLINE
|
|
|
|
add_scada_element(p, ChangeSet({'id': 'sm1', 'x': 1.0, 'y': 2.0, 'device_id': 'sd1', 'model_id': 'p0', 'model_type': SCADA_MODEL_TYPE_PIPE, 'status': SCADA_ELEMENT_STATUS_ONLINE}))
|
|
sm = get_scada_element(p, 'sm1')
|
|
assert sm == {}
|
|
add_scada_element(p, ChangeSet({'id': 'sm1', 'x': 1.0, 'y': 2.0, 'device_id': 'sd1', 'model_id': 'p0', 'status': SCADA_ELEMENT_STATUS_ONLINE}))
|
|
sm = get_scada_element(p, 'sm1')
|
|
assert sm == {}
|
|
add_scada_element(p, ChangeSet({'id': 'sm1', 'x': 1.0, 'y': 2.0, 'device_id': 'sd1', 'model_type': SCADA_MODEL_TYPE_PIPE, 'status': SCADA_ELEMENT_STATUS_ONLINE}))
|
|
sm = get_scada_element(p, 'sm1')
|
|
assert sm == {}
|
|
add_scada_element(p, ChangeSet({'id': 'sm1', 'x': 1.0, 'y': 2.0, 'device_id': 'sd1', 'model_id': 'p0', 'model_type': SCADA_MODEL_TYPE_JUNCTION, 'status': SCADA_ELEMENT_STATUS_ONLINE}))
|
|
sm = get_scada_element(p, 'sm1')
|
|
assert sm == {}
|
|
|
|
add_scada_element(p, ChangeSet({'id': 'sm1', 'x': 1.0, 'y': 2.0, 'device_id': 'sd1', 'model_id': 'p1', 'model_type': SCADA_MODEL_TYPE_PIPE, 'status': SCADA_ELEMENT_STATUS_ONLINE}))
|
|
sm = get_scada_element(p, 'sm1')
|
|
assert sm['id'] == 'sm1'
|
|
assert sm['x'] == 1.0
|
|
assert sm['y'] == 2.0
|
|
assert sm['device_id'] == 'sd1'
|
|
assert sm['model_id'] == 'p1'
|
|
assert sm['model_type'] == SCADA_MODEL_TYPE_PIPE
|
|
assert sm['status'] == SCADA_ELEMENT_STATUS_ONLINE
|
|
|
|
elements = get_scada_elements(p)
|
|
assert len(elements) == 2
|
|
assert elements[0] == 'sm0'
|
|
assert elements[1] == 'sm1'
|
|
|
|
set_scada_element(p, ChangeSet({'id': 'sm0', 'x': 1.0, 'y': 2.0, 'device_id': 'sd1', 'model_id': 'p1', 'model_type': SCADA_MODEL_TYPE_PIPE, 'status': SCADA_ELEMENT_STATUS_ONLINE}))
|
|
sm = get_scada_element(p, 'sm0')
|
|
assert sm['id'] == 'sm0'
|
|
assert sm['x'] == 1.0
|
|
assert sm['y'] == 2.0
|
|
assert sm['device_id'] == 'sd1'
|
|
assert sm['model_id'] == 'p1'
|
|
assert sm['model_type'] == SCADA_MODEL_TYPE_PIPE
|
|
assert sm['status'] == SCADA_ELEMENT_STATUS_ONLINE
|
|
|
|
set_scada_element(p, ChangeSet({'id': 'sm0', 'x': 1.0, 'y': 2.0, 'device_id': 'sd1', 'model_id': 'p1', 'model_type': SCADA_MODEL_TYPE_JUNCTION, 'status': SCADA_ELEMENT_STATUS_ONLINE}))
|
|
sm = get_scada_element(p, 'sm0')
|
|
assert sm['id'] == 'sm0'
|
|
assert sm['x'] == 1.0
|
|
assert sm['y'] == 2.0
|
|
assert sm['device_id'] == 'sd1'
|
|
assert sm['model_id'] == 'p1'
|
|
assert sm['model_type'] == SCADA_MODEL_TYPE_PIPE
|
|
assert sm['status'] == SCADA_ELEMENT_STATUS_ONLINE
|
|
|
|
set_scada_element(p, ChangeSet({'id': 'sm1', 'x': 0.0, 'y': 1.0, 'device_id': 'sd0', 'model_id': 'j1', 'model_type': SCADA_MODEL_TYPE_JUNCTION, 'status': SCADA_ELEMENT_STATUS_OFFLINE}))
|
|
sm = get_scada_element(p, 'sm1')
|
|
assert sm['id'] == 'sm1'
|
|
assert sm['x'] == 0.0
|
|
assert sm['y'] == 1.0
|
|
assert sm['device_id'] == 'sd0'
|
|
assert sm['model_id'] == 'j1'
|
|
assert sm['model_type'] == SCADA_MODEL_TYPE_JUNCTION
|
|
assert sm['status'] == SCADA_ELEMENT_STATUS_OFFLINE
|
|
|
|
set_scada_element(p, ChangeSet({'id': 'sm1', 'x': 0.0, 'y': 1.0, 'device_id': 'sd0', 'model_id': 'j1', 'model_type': SCADA_MODEL_TYPE_PIPE, 'status': SCADA_ELEMENT_STATUS_OFFLINE}))
|
|
sm = get_scada_element(p, 'sm1')
|
|
assert sm['id'] == 'sm1'
|
|
assert sm['x'] == 0.0
|
|
assert sm['y'] == 1.0
|
|
assert sm['device_id'] == 'sd0'
|
|
assert sm['model_id'] == 'j1'
|
|
assert sm['model_type'] == SCADA_MODEL_TYPE_JUNCTION
|
|
assert sm['status'] == SCADA_ELEMENT_STATUS_OFFLINE
|
|
|
|
delete_scada_element(p, ChangeSet({'id': 'sm0'}))
|
|
sm = get_scada_element(p, 'sm0')
|
|
assert sm == {}
|
|
|
|
delete_scada_element(p, ChangeSet({'id': 'sm1'}))
|
|
sm = get_scada_element(p, 'sm1')
|
|
assert sm == {}
|
|
|
|
assert get_scada_elements(p) == []
|
|
|
|
add_scada_element(p, ChangeSet({'id': 'sm0', 'x': 0.0, 'y': 1.0, 'device_id': 'sd0', 'model_id': 'j1', 'model_type': SCADA_MODEL_TYPE_JUNCTION, 'status': SCADA_ELEMENT_STATUS_OFFLINE}))
|
|
sm = get_scada_element(p, 'sm0')
|
|
assert sm['id'] == 'sm0'
|
|
assert sm['x'] == 0.0
|
|
assert sm['y'] == 1.0
|
|
assert sm['device_id'] == 'sd0'
|
|
assert sm['model_id'] == 'j1'
|
|
assert sm['model_type'] == SCADA_MODEL_TYPE_JUNCTION
|
|
assert sm['status'] == SCADA_ELEMENT_STATUS_OFFLINE
|
|
|
|
add_scada_element(p, ChangeSet({'id': 'sm1', 'x': 1.0, 'y': 2.0, 'device_id': 'sd1', 'model_id': 'p1', 'model_type': SCADA_MODEL_TYPE_PIPE, 'status': SCADA_ELEMENT_STATUS_ONLINE}))
|
|
sm = get_scada_element(p, 'sm1')
|
|
assert sm['id'] == 'sm1'
|
|
assert sm['x'] == 1.0
|
|
assert sm['y'] == 2.0
|
|
assert sm['device_id'] == 'sd1'
|
|
assert sm['model_id'] == 'p1'
|
|
assert sm['model_type'] == SCADA_MODEL_TYPE_PIPE
|
|
assert sm['status'] == SCADA_ELEMENT_STATUS_ONLINE
|
|
|
|
elements = get_scada_elements(p)
|
|
assert len(elements) == 2
|
|
assert elements[0] == 'sm0'
|
|
assert elements[1] == 'sm1'
|
|
|
|
clean_scada_element(p)
|
|
sm = get_scada_element(p, 'sm0')
|
|
assert sm == {}
|
|
sm = get_scada_element(p, 'sm1')
|
|
assert sm == {}
|
|
|
|
assert get_scada_elements(p) == []
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_scada_element_op(self):
|
|
p = 'test_scada_element_op'
|
|
self.enter(p)
|
|
|
|
add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
|
|
add_pipe(p, ChangeSet({'id': 'p1', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
|
|
add_scada_device(p, ChangeSet({'id': 'sd0', 'name': 'device0', 'address': 'x0', 'sd_type': SCADA_DEVICE_TYPE_PRESSURE}))
|
|
add_scada_device(p, ChangeSet({'id': 'sd1', 'name': 'device1', 'address': 'x1', 'sd_type': SCADA_DEVICE_TYPE_FLOW}))
|
|
|
|
css = add_scada_element(p, ChangeSet({'id': 'sm0', 'x': 0.0, 'y': 1.0, 'device_id': 'sd0', 'model_id': 'j0', 'model_type': SCADA_MODEL_TYPE_JUNCTION, 'status': SCADA_ELEMENT_STATUS_OFFLINE})).operations
|
|
assert len(css) == 0
|
|
cs = add_scada_element(p, ChangeSet({'id': 'sm0', 'x': 0.0, 'y': 1.0, 'device_id': 'sd0', 'model_id': 'j1', 'model_type': SCADA_MODEL_TYPE_JUNCTION, 'status': SCADA_ELEMENT_STATUS_OFFLINE})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 1.0
|
|
assert cs['device_id'] == 'sd0'
|
|
assert cs['model_id'] == 'j1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_JUNCTION
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_OFFLINE
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 1.0
|
|
assert cs['device_id'] == 'sd0'
|
|
assert cs['model_id'] == 'j1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_JUNCTION
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_OFFLINE
|
|
|
|
css = add_scada_element(p, ChangeSet({'id': 'sm1', 'x': 1.0, 'y': 2.0, 'device_id': 'sd1', 'model_id': 'p0', 'model_type': SCADA_MODEL_TYPE_PIPE, 'status': SCADA_ELEMENT_STATUS_ONLINE})).operations
|
|
assert len(css) == 0
|
|
cs = add_scada_element(p, ChangeSet({'id': 'sm1', 'x': 1.0, 'y': 2.0, 'device_id': 'sd1', 'model_id': 'p1', 'model_type': SCADA_MODEL_TYPE_PIPE, 'status': SCADA_ELEMENT_STATUS_ONLINE})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
assert cs['x'] == 1.0
|
|
assert cs['y'] == 2.0
|
|
assert cs['device_id'] == 'sd1'
|
|
assert cs['model_id'] == 'p1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_PIPE
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_ONLINE
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
assert cs['x'] == 1.0
|
|
assert cs['y'] == 2.0
|
|
assert cs['device_id'] == 'sd1'
|
|
assert cs['model_id'] == 'p1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_PIPE
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_ONLINE
|
|
|
|
cs = set_scada_element(p, ChangeSet({'id': 'sm0', 'x': 1.0, 'y': 2.0, 'device_id': 'sd1', 'model_id': 'p1', 'model_type': SCADA_MODEL_TYPE_PIPE, 'status': SCADA_ELEMENT_STATUS_ONLINE})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
assert cs['x'] == 1.0
|
|
assert cs['y'] == 2.0
|
|
assert cs['device_id'] == 'sd1'
|
|
assert cs['model_id'] == 'p1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_PIPE
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_ONLINE
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 1.0
|
|
assert cs['device_id'] == 'sd0'
|
|
assert cs['model_id'] == 'j1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_JUNCTION
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_OFFLINE
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
assert cs['x'] == 1.0
|
|
assert cs['y'] == 2.0
|
|
assert cs['device_id'] == 'sd1'
|
|
assert cs['model_id'] == 'p1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_PIPE
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_ONLINE
|
|
|
|
cs = set_scada_element(p, ChangeSet({'id': 'sm1', 'x': 0.0, 'y': 1.0, 'device_id': 'sd0', 'model_id': 'j1', 'model_type': SCADA_MODEL_TYPE_JUNCTION, 'status': SCADA_ELEMENT_STATUS_OFFLINE})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 1.0
|
|
assert cs['device_id'] == 'sd0'
|
|
assert cs['model_id'] == 'j1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_JUNCTION
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_OFFLINE
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
assert cs['x'] == 1.0
|
|
assert cs['y'] == 2.0
|
|
assert cs['device_id'] == 'sd1'
|
|
assert cs['model_id'] == 'p1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_PIPE
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_ONLINE
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 1.0
|
|
assert cs['device_id'] == 'sd0'
|
|
assert cs['model_id'] == 'j1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_JUNCTION
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_OFFLINE
|
|
|
|
cs = delete_scada_element(p, ChangeSet({'id': 'sm0'})).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
assert cs['x'] == 1.0
|
|
assert cs['y'] == 2.0
|
|
assert cs['device_id'] == 'sd1'
|
|
assert cs['model_id'] == 'p1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_PIPE
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_ONLINE
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
|
|
cs = delete_scada_element(p, ChangeSet({'id': 'sm1'})).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 1.0
|
|
assert cs['device_id'] == 'sd0'
|
|
assert cs['model_id'] == 'j1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_JUNCTION
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_OFFLINE
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
|
|
cs = add_scada_element(p, ChangeSet({'id': 'sm0', 'x': 0.0, 'y': 1.0, 'device_id': 'sd0', 'model_id': 'j1', 'model_type': SCADA_MODEL_TYPE_JUNCTION, 'status': SCADA_ELEMENT_STATUS_OFFLINE})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 1.0
|
|
assert cs['device_id'] == 'sd0'
|
|
assert cs['model_id'] == 'j1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_JUNCTION
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_OFFLINE
|
|
|
|
cs = add_scada_element(p, ChangeSet({'id': 'sm1', 'x': 1.0, 'y': 2.0, 'device_id': 'sd1', 'model_id': 'p1', 'model_type': SCADA_MODEL_TYPE_PIPE, 'status': SCADA_ELEMENT_STATUS_ONLINE})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
assert cs['x'] == 1.0
|
|
assert cs['y'] == 2.0
|
|
assert cs['device_id'] == 'sd1'
|
|
assert cs['model_id'] == 'p1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_PIPE
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_ONLINE
|
|
|
|
css = clean_scada_element(p).operations
|
|
cs = css[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
cs = css[1]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
|
|
css = execute_undo(p).operations
|
|
cs = css[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
assert cs['x'] == 1.0
|
|
assert cs['y'] == 2.0
|
|
assert cs['device_id'] == 'sd1'
|
|
assert cs['model_id'] == 'p1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_PIPE
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_ONLINE
|
|
cs = css[1]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
assert cs['x'] == 0.0
|
|
assert cs['y'] == 1.0
|
|
assert cs['device_id'] == 'sd0'
|
|
assert cs['model_id'] == 'j1'
|
|
assert cs['model_type'] == SCADA_MODEL_TYPE_JUNCTION
|
|
assert cs['status'] == SCADA_ELEMENT_STATUS_OFFLINE
|
|
|
|
css = execute_redo(p).operations
|
|
cs = css[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm0'
|
|
cs = css[1]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'scada_element'
|
|
assert cs['id'] == 'sm1'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 33 region
|
|
|
|
|
|
def test_region(self):
|
|
p = 'test_region'
|
|
self.enter(p)
|
|
|
|
r = get_region(p, 'r')
|
|
assert r == {}
|
|
|
|
add_region(p, ChangeSet({'id': 'r', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]}))
|
|
r = get_region(p, 'r')
|
|
assert r == { 'id': 'r', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)] }
|
|
|
|
set_region(p, ChangeSet({'id': 'r', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 2.0), (0.0, 0.0)]}))
|
|
r = get_region(p, 'r')
|
|
assert r == { 'id': 'r', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 2.0), (0.0, 0.0)] }
|
|
|
|
delete_region(p, ChangeSet({'id': 'r'}))
|
|
r = get_region(p, 'r')
|
|
assert r == {}
|
|
|
|
self.leave(p)
|
|
|
|
|
|
def test_region_op(self):
|
|
p = 'test_region_op'
|
|
self.enter(p)
|
|
|
|
cs = add_region(p, ChangeSet({'id': 'r', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]})).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'region'
|
|
assert cs['id'] == 'r'
|
|
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'region'
|
|
assert cs['id'] == 'r'
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'region'
|
|
assert cs['id'] == 'r'
|
|
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
|
|
|
|
cs = set_region(p, ChangeSet({'id': 'r', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 2.0), (0.0, 0.0)]})).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'region'
|
|
assert cs['id'] == 'r'
|
|
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 2.0), (0.0, 0.0)]
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'region'
|
|
assert cs['id'] == 'r'
|
|
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_UPDATE
|
|
assert cs['type'] == 'region'
|
|
assert cs['id'] == 'r'
|
|
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 2.0), (0.0, 0.0)]
|
|
|
|
cs = delete_region(p, ChangeSet({'id': 'r'})).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'region'
|
|
assert cs['id'] == 'r'
|
|
|
|
cs = execute_undo(p).operations[0]
|
|
assert cs['operation'] == API_ADD
|
|
assert cs['type'] == 'region'
|
|
assert cs['id'] == 'r'
|
|
assert cs['boundary'] == [(0.0, 0.0), (1.0, 0.0), (1.0, 2.0), (0.0, 0.0)]
|
|
|
|
cs = execute_redo(p).operations[0]
|
|
assert cs['operation'] == API_DELETE
|
|
assert cs['type'] == 'region'
|
|
assert cs['id'] == 'r'
|
|
|
|
self.leave(p)
|
|
|
|
|
|
# 37 virtual_district
|
|
|
|
def test_virtual_district(self):
|
|
p = 'test_virtual_district'
|
|
read_inp(p, f'./inp/net3.inp', '3')
|
|
|
|
open_project(p)
|
|
|
|
result = calculate_virtual_district(p, ['107', '139', '267', '211'])
|
|
|
|
assert result == {
|
|
'virtual_districts':[
|
|
{
|
|
'center': '107',
|
|
'nodes': ['10', '101', '103', '105', '109', '111', '115', '117', '119', '120', '139', '257', '259', '261', '263', '267', 'Lake'],
|
|
'boundary': [(23.38, 12.95), (12.96, 21.31), (8.0, 27.53), (9.0, 27.85), (33.28, 24.54), (23.38, 12.95)]
|
|
},
|
|
{
|
|
'center': '139',
|
|
'nodes': ['15', '20', '60', '601', '61', '121', '123', '125', '127', '129', '131', '141', '143', '145', '147', '149', '151', '153', 'River', '3'],
|
|
'boundary': [(33.02, 19.29), (30.24, 20.38), (28.29, 21.39), (23.54, 25.5), (23.0, 29.49), (24.15, 31.06), (37.89, 29.55), (38.68, 23.76), (37.47, 21.97), (33.02, 19.29)]
|
|
},
|
|
{
|
|
'center': '267',
|
|
'nodes': ['35', '40', '113', '157', '159', '161', '163', '164', '166', '167', '169', '171', '173', '177', '179', '181', '183', '184', '185', '187', '189', '191', '193', '195', '197', '204', '211', '265', '269', '271', '1', '107'],
|
|
'boundary': [(34.2, 5.54), (25.15, 9.52), (23.64, 11.04), (20.97, 15.18), (18.45, 20.46), (24.85, 20.16), (34.2, 5.54)]
|
|
},
|
|
{
|
|
'center': '211',
|
|
'nodes': ['50', '199', '201', '203', '205', '206', '207', '208', '209', '213', '215', '217', '219', '225', '229', '231', '237', '239', '241', '243', '247', '249', '251', '253', '255', '273', '275', '2'],
|
|
'boundary': [(37.04, 0.0), (34.15, 1.1), (32.17, 1.88), (29.2, 6.46), (29.16, 7.38), (29.42, 8.44), (31.14, 8.89), (44.86, 9.32), (43.53, 7.38), (37.04, 0.0)]
|
|
}],
|
|
'isolated_nodes': []}
|
|
|
|
self.leave(p)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
pytest.main()
|