def test_unroutable_demand(self):
node_a = Node(name='nodeA', lat=0, lon=0)
node_b = Node(name='nodeB', lat=0, lon=0)
node_d = Node(name='nodeD')
interface_a = Interface(name='inerfaceA-to-B',
cost=4,
capacity=100,
node_object=node_a,
remote_node_object=node_b,
circuit_id=1)
interface_b = Interface(name='inerfaceB-to-A',
cost=4,
capacity=100,
node_object=node_b,
remote_node_object=node_a,
circuit_id=1)
dmd_a_d = Demand(node_a, node_d, traffic=10)
model = Model(interface_objects=set([interface_a, interface_b]),
node_objects=set([node_a, node_b, node_d]),
demand_objects=set([dmd_a_d]),
rsvp_lsp_objects=set([]))
model.update_simulation()
self.assertEqual(dmd_a_d.path, 'Unrouted')
def test_demand_on_lsp(self):
"""
Ensure the demand takes an available LSP
:return:
"""
node_a = Node(name='nodeA', lat=0, lon=0)
node_b = Node(name='nodeB', lat=0, lon=0)
node_d = Node(name='nodeD')
interface_a = Interface(name='inerfaceA-to-B',
cost=4,
capacity=100,
node_object=node_a,
remote_node_object=node_b,
circuit_id=1)
interface_b = Interface(name='inerfaceB-to-A',
cost=4,
capacity=100,
node_object=node_b,
remote_node_object=node_a,
circuit_id=1)
dmd_a_b = Demand(node_a, node_b, traffic=10)
lsp_a_b = RSVP_LSP(source_node_object=node_a,
dest_node_object=node_b,
lsp_name='lsp_a_b')
model = Model(interface_objects=set([interface_a, interface_b]),
node_objects=set([node_a, node_b, node_d]),
demand_objects=set([dmd_a_b]),
rsvp_lsp_objects=set([lsp_a_b]))
model.update_simulation()
self.assertEqual(
str(dmd_a_b.path),
"[RSVP_LSP(source = nodeA, dest = nodeB, lsp_name = 'lsp_a_b')]")
def test_ecmp(self):
model8 = Model()
model8.rsvp_lsp_objects = set([])
model8.demand_objects = set([])
int_list = [{
'name': 'E-to-A',
'cost': 10,
'capacity': 300,
'node': 'E',
'remote_node': 'A',
'address': 1,
'failed': False
}, {
'name': 'C-to-D',
'cost': 30,
'capacity': 150,
'node': 'C',
'remote_node': 'D',
'address': 5,
'failed': False
}, {
'name': 'D-to-C',
'cost': 30,
'capacity': 150,
'node': 'D',
'remote_node': 'C',
'address': 5,
'failed': False
}, {
'name': 'A-to-E',
'cost': 10,
'capacity': 300,
'node': 'A',
'remote_node': 'E',
'address': 1,
'failed': False
}, {
'name': 'A-to-D',
'cost': 40,
'capacity': 20,
'node': 'A',
'remote_node': 'D',
'address': 2,
'failed': False
}, {
'name': 'D-to-A',
'cost': 40,
'capacity': 20,
'node': 'D',
'remote_node': 'A',
'address': 2,
'failed': False
}, {
'name': 'G-to-D',
'cost': 10,
'capacity': 100,
'node': 'G',
'remote_node': 'D',
'address': 7,
'failed': False
}, {
'name': 'C-to-A',
'cost': 30,
'capacity': 150,
'node': 'C',
'remote_node': 'A',
'address': 3,
'failed': False
}, {
'name': 'D-to-F',
'cost': 10,
'capacity': 300,
'node': 'D',
'remote_node': 'F',
'address': 6,
'failed': False
}, {
'name': 'F-to-D',
'cost': 10,
'capacity': 300,
'node': 'F',
'remote_node': 'D',
'address': 6,
'failed': False
}, {
'name': 'D-to-G',
'cost': 10,
'capacity': 100,
'node': 'D',
'remote_node': 'G',
'address': 7,
'failed': False
}, {
'name': 'B-to-A',
'cost': 20,
'capacity': 125,
'node': 'B',
'remote_node': 'A',
'address': 4,
'failed': False
}, {
'name': 'D-to-B',
'cost': 20,
'capacity': 125,
'node': 'D',
'remote_node': 'B',
'address': 8,
'failed': False
}, {
'name': 'B-to-G',
'cost': 10,
'capacity': 100,
'node': 'B',
'remote_node': 'G',
'address': 9,
'failed': False
}, {
'name': 'A-to-C',
'cost': 30,
'capacity': 150,
'node': 'A',
'remote_node': 'C',
'address': 3,
'failed': False
}, {
'name': 'B-to-D',
'cost': 20,
'capacity': 125,
'node': 'B',
'remote_node': 'D',
'address': 8,
'failed': False
}, {
'name': 'G-to-B',
'cost': 10,
'capacity': 100,
'node': 'G',
'remote_node': 'B',
'address': 9,
'failed': False
}, {
'name': 'A-to-B',
'cost': 20,
'capacity': 125,
'node': 'A',
'remote_node': 'B',
'address': 4,
'failed': False
}]
model8.add_network_interfaces_from_list(int_list)
demands = [
{
'source': 'A',
'dest': 'F',
'traffic': 40,
'name': 'dmd_a_f_1'
},
]
for demand in demands:
model8.add_demand(demand['source'], demand['dest'],
demand['traffic'], demand['name'])
int_a_b = model8.get_interface_object('A-to-B', 'A')
int_b_d = model8.get_interface_object('B-to-D', 'B')
int_b_g = model8.get_interface_object('B-to-G', 'B')
int_g_d = model8.get_interface_object('G-to-D', 'G')
int_d_f = model8.get_interface_object('D-to-F', 'D')
int_a_c = model8.get_interface_object('A-to-C', 'A')
int_c_d = model8.get_interface_object('C-to-D', 'C')
int_a_d = model8.get_interface_object('A-to-D', 'A')
model8.update_simulation()
self.assertEqual(int_a_b.traffic, 20)
self.assertEqual(int_b_d.traffic, 10)
self.assertEqual(int_d_f.traffic, 40)
self.assertEqual(int_b_g.traffic, 10)
self.assertEqual(int_g_d.traffic, 10)
self.assertEqual(int_a_c.traffic, 0)
self.assertEqual(int_c_d.traffic, 0)
self.assertEqual(int_a_d.traffic, 20)
def test_validate_lsp_routing(self):
"""
Test that all 4 LSPs between A and D route
"""
model1 = Model()
model1.rsvp_lsp_objects = set([])
model1.demand_objects = set([])
int_list = [{'name': 'E-to-A', 'cost': 10, 'capacity': 300, 'node': 'E', 'remote_node': 'A', 'address': 1,
'failed': False},
{'name': 'C-to-D', 'cost': 30, 'capacity': 150, 'node': 'C', 'remote_node': 'D', 'address': 5,
'failed': False},
{'name': 'D-to-C', 'cost': 30, 'capacity': 150, 'node': 'D', 'remote_node': 'C', 'address': 5,
'failed': False},
{'name': 'A-to-E', 'cost': 10, 'capacity': 300, 'node': 'A', 'remote_node': 'E', 'address': 1,
'failed': False},
{'name': 'A-to-D', 'cost': 40, 'capacity': 20, 'node': 'A', 'remote_node': 'D', 'address': 2,
'failed': False},
{'name': 'D-to-A', 'cost': 40, 'capacity': 20, 'node': 'D', 'remote_node': 'A', 'address': 2,
'failed': False},
{'name': 'G-to-D', 'cost': 10, 'capacity': 100, 'node': 'G', 'remote_node': 'D', 'address': 7,
'failed': False},
{'name': 'C-to-A', 'cost': 30, 'capacity': 150, 'node': 'C', 'remote_node': 'A', 'address': 3,
'failed': False},
{'name': 'D-to-F', 'cost': 10, 'capacity': 300, 'node': 'D', 'remote_node': 'F', 'address': 6,
'failed': False},
{'name': 'F-to-D', 'cost': 10, 'capacity': 300, 'node': 'F', 'remote_node': 'D', 'address': 6,
'failed': False},
{'name': 'D-to-G', 'cost': 10, 'capacity': 100, 'node': 'D', 'remote_node': 'G', 'address': 7,
'failed': False},
{'name': 'B-to-A', 'cost': 20, 'capacity': 125, 'node': 'B', 'remote_node': 'A', 'address': 4,
'failed': False},
{'name': 'D-to-B', 'cost': 20, 'capacity': 125, 'node': 'D', 'remote_node': 'B', 'address': 8,
'failed': False},
{'name': 'B-to-G', 'cost': 10, 'capacity': 100, 'node': 'B', 'remote_node': 'G', 'address': 9,
'failed': False},
{'name': 'A-to-C', 'cost': 30, 'capacity': 150, 'node': 'A', 'remote_node': 'C', 'address': 3,
'failed': False},
{'name': 'B-to-D', 'cost': 20, 'capacity': 125, 'node': 'B', 'remote_node': 'D', 'address': 8,
'failed': False},
{'name': 'G-to-B', 'cost': 10, 'capacity': 100, 'node': 'G', 'remote_node': 'B', 'address': 9,
'failed': False},
{'name': 'A-to-B', 'cost': 20, 'capacity': 125, 'node': 'A', 'remote_node': 'B', 'address': 4,
'failed': False}]
model1.add_network_interfaces_from_list(int_list)
model1.add_rsvp_lsp('A', 'D', 'lsp_a_d_1')
model1.add_rsvp_lsp('A', 'D', 'lsp_a_d_2')
model1.add_rsvp_lsp('A', 'D', 'lsp_a_d_3')
model1.add_rsvp_lsp('A', 'D', 'lsp_a_d_4')
demands = [{'source': 'A', 'dest': 'D', 'traffic': 100, 'name': 'dmd_a_d_3'},
{'source': 'A', 'dest': 'D', 'traffic': 70, 'name': 'dmd_a_d_2'},
{'source': 'A', 'dest': 'D', 'traffic': 80, 'name': 'dmd_a_d_1'},
{'source': 'F', 'dest': 'E', 'traffic': 400, 'name': 'dmd_f_e_1'},
{'source': 'A', 'dest': 'F', 'traffic': 40, 'name': 'dmd_a_f_1'},
]
for demand in demands:
model1.add_demand(demand['source'], demand['dest'],
demand['traffic'], demand['name'])
model1.update_simulation()
# All the paths for each LSP from Node('A') to Node('D')
paths = [lsp.path for lsp in model1.rsvp_lsp_objects if lsp.source_node_object.name == 'A' and
lsp.dest_node_object.name == 'D']
# Ensure all LSPs route
self.assertNotIn("Unrouted", paths)
counter = counter + 1
print()
# create demand objects from list of demands
# demand_objects = Demand.create_demand_objects(demands)
for demand in demands:
model1.add_demand(demand['source'], demand['dest'], demand['traffic'])
# find the best path from node A to B
best_A_B = model1.get_shortest_path(source, dest)
print("The best path from Node A to Node B is:", best_A_B)
print()
# display the traffic
print('Interface traffic with no failures:')
model1.update_simulation()
model1.display_interfaces_traffic()
print()
print()
# Find the remote interface for Node F, interface F-to-D
print("Find the remote interface for Node F, interface F-to-D:")
f_to_d = model1.get_interface_object('F-to-D', 'F')
remote_int = f_to_d.get_remote_interface(model1)
print("Remote interface is", remote_int)
print()
# Fail interface on node A, interface A-to-B
print('Failing interface A-to-B on node A')
int_to_fail = model1.get_interface_object('A-to-B', 'A')
int_to_fail.fail_interface(model1)
def test_setup_bandwidth(self):
model = Model()
model.rsvp_lsp_objects = set([])
model.demand_objects = set([])
int_list = [{'name': 'E-to-A', 'cost': 10, 'capacity': 300, 'node': 'E', 'remote_node': 'A', 'address': 1,
'failed': False},
{'name': 'C-to-D', 'cost': 30, 'capacity': 150, 'node': 'C', 'remote_node': 'D', 'address': 5,
'failed': False},
{'name': 'D-to-C', 'cost': 30, 'capacity': 150, 'node': 'D', 'remote_node': 'C', 'address': 5,
'failed': False},
{'name': 'A-to-E', 'cost': 10, 'capacity': 300, 'node': 'A', 'remote_node': 'E', 'address': 1,
'failed': False},
{'name': 'A-to-D', 'cost': 40, 'capacity': 20, 'node': 'A', 'remote_node': 'D', 'address': 2,
'failed': False},
{'name': 'D-to-A', 'cost': 40, 'capacity': 20, 'node': 'D', 'remote_node': 'A', 'address': 2,
'failed': False},
{'name': 'G-to-D', 'cost': 10, 'capacity': 100, 'node': 'G', 'remote_node': 'D', 'address': 7,
'failed': False},
{'name': 'C-to-A', 'cost': 30, 'capacity': 150, 'node': 'C', 'remote_node': 'A', 'address': 3,
'failed': False},
{'name': 'D-to-F', 'cost': 10, 'capacity': 300, 'node': 'D', 'remote_node': 'F', 'address': 6,
'failed': False},
{'name': 'F-to-D', 'cost': 10, 'capacity': 300, 'node': 'F', 'remote_node': 'D', 'address': 6,
'failed': False},
{'name': 'D-to-G', 'cost': 10, 'capacity': 100, 'node': 'D', 'remote_node': 'G', 'address': 7,
'failed': False},
{'name': 'B-to-A', 'cost': 20, 'capacity': 125, 'node': 'B', 'remote_node': 'A', 'address': 4,
'failed': False},
{'name': 'D-to-B', 'cost': 20, 'capacity': 125, 'node': 'D', 'remote_node': 'B', 'address': 8,
'failed': False},
{'name': 'B-to-G', 'cost': 10, 'capacity': 100, 'node': 'B', 'remote_node': 'G', 'address': 9,
'failed': False},
{'name': 'A-to-C', 'cost': 30, 'capacity': 150, 'node': 'A', 'remote_node': 'C', 'address': 3,
'failed': False},
{'name': 'B-to-D', 'cost': 20, 'capacity': 125, 'node': 'B', 'remote_node': 'D', 'address': 8,
'failed': False},
{'name': 'G-to-B', 'cost': 10, 'capacity': 100, 'node': 'G', 'remote_node': 'B', 'address': 9,
'failed': False},
{'name': 'A-to-B', 'cost': 20, 'capacity': 125, 'node': 'A', 'remote_node': 'B', 'address': 4,
'failed': False}]
model.add_network_interfaces_from_list(int_list)
model.add_rsvp_lsp('A', 'D', 'lsp_a_d_1')
model.add_rsvp_lsp('A', 'D', 'lsp_a_d_2')
demands = [{'source': 'A', 'dest': 'D', 'traffic': 100, 'name': 'dmd_a_d_3'},
{'source': 'A', 'dest': 'D', 'traffic': 70, 'name': 'dmd_a_d_2'},
{'source': 'A', 'dest': 'D', 'traffic': 80, 'name': 'dmd_a_d_1'},
{'source': 'F', 'dest': 'E', 'traffic': 400, 'name': 'dmd_f_e_1'},
{'source': 'A', 'dest': 'F', 'traffic': 40, 'name': 'dmd_a_f_1'},
]
for demand in demands:
model.add_demand(demand['source'], demand['dest'],
demand['traffic'], demand['name'])
lsp_a_d_1 = model.get_rsvp_lsp('A', 'D', 'lsp_a_d_1')
lsp_a_d_2 = model.get_rsvp_lsp('A', 'D', 'lsp_a_d_2')
model.update_simulation()
self.assertEqual(lsp_a_d_1.setup_bandwidth, 125.0)
self.assertEqual(lsp_a_d_2.setup_bandwidth, 125.0)
def test_lsp_failover(self):
model1 = Model()
model1.rsvp_lsp_objects = set()
model1.demand_objects = set()
int_list = [{
'name': 'E-to-A',
'cost': 10,
'capacity': 300,
'node': 'E',
'remote_node': 'A',
'circuit_id': 1,
'failed': False
}, {
'name': 'C-to-D',
'cost': 30,
'capacity': 150,
'node': 'C',
'remote_node': 'D',
'circuit_id': 5,
'failed': False
}, {
'name': 'D-to-C',
'cost': 30,
'capacity': 150,
'node': 'D',
'remote_node': 'C',
'circuit_id': 5,
'failed': False
}, {
'name': 'A-to-E',
'cost': 10,
'capacity': 300,
'node': 'A',
'remote_node': 'E',
'circuit_id': 1,
'failed': False
}, {
'name': 'A-to-D',
'cost': 40,
'capacity': 20,
'node': 'A',
'remote_node': 'D',
'circuit_id': 2,
'failed': False
}, {
'name': 'D-to-A',
'cost': 40,
'capacity': 20,
'node': 'D',
'remote_node': 'A',
'circuit_id': 2,
'failed': False
}, {
'name': 'G-to-D',
'cost': 10,
'capacity': 100,
'node': 'G',
'remote_node': 'D',
'circuit_id': 7,
'failed': False
}, {
'name': 'C-to-A',
'cost': 30,
'capacity': 150,
'node': 'C',
'remote_node': 'A',
'circuit_id': 3,
'failed': False
}, {
'name': 'D-to-F',
'cost': 10,
'capacity': 300,
'node': 'D',
'remote_node': 'F',
'circuit_id': 6,
'failed': False
}, {
'name': 'F-to-D',
'cost': 10,
'capacity': 300,
'node': 'F',
'remote_node': 'D',
'circuit_id': 6,
'failed': False
}, {
'name': 'D-to-G',
'cost': 10,
'capacity': 100,
'node': 'D',
'remote_node': 'G',
'circuit_id': 7,
'failed': False
}, {
'name': 'B-to-A',
'cost': 20,
'capacity': 125,
'node': 'B',
'remote_node': 'A',
'circuit_id': 4,
'failed': False
}, {
'name': 'D-to-B',
'cost': 20,
'capacity': 125,
'node': 'D',
'remote_node': 'B',
'circuit_id': 8,
'failed': False
}, {
'name': 'B-to-G',
'cost': 10,
'capacity': 100,
'node': 'B',
'remote_node': 'G',
'circuit_id': 9,
'failed': False
}, {
'name': 'A-to-C',
'cost': 30,
'capacity': 150,
'node': 'A',
'remote_node': 'C',
'circuit_id': 3,
'failed': False
}, {
'name': 'B-to-D',
'cost': 20,
'capacity': 125,
'node': 'B',
'remote_node': 'D',
'circuit_id': 8,
'failed': False
}, {
'name': 'G-to-B',
'cost': 10,
'capacity': 100,
'node': 'G',
'remote_node': 'B',
'circuit_id': 9,
'failed': False
}, {
'name': 'A-to-B',
'cost': 20,
'capacity': 125,
'node': 'A',
'remote_node': 'B',
'circuit_id': 4,
'failed': False
}]
model1.add_network_interfaces_from_list(int_list)
model1.add_rsvp_lsp('A', 'D', 'lsp_a_d_1')
model1.add_rsvp_lsp('A', 'D', 'lsp_a_d_2')
model1.fail_interface('A-to-B', 'A')
int_a_b = model1.get_interface_object('A-to-B', 'A')
int_a_c = model1.get_interface_object('A-to-C', 'A')
demands = [
{
'source': 'A',
'dest': 'D',
'traffic': 70,
'name': 'dmd_a_d_2'
},
{
'source': 'A',
'dest': 'D',
'traffic': 80,
'name': 'dmd_a_d_1'
},
{
'source': 'F',
'dest': 'E',
'traffic': 400,
'name': 'dmd_f_e_1'
},
{
'source': 'A',
'dest': 'F',
'traffic': 40,
'name': 'dmd_a_f_1'
},
]
for demand in demands:
model1.add_demand(demand['source'], demand['dest'],
demand['traffic'], demand['name'])
model1.update_simulation()
self.assertTrue(int_a_b.failed)
# int_a_b should not have any LSPs
lsps_on_int_a_b = [lsp for lsp in int_a_b.lsps(model1)]
self.assertTrue(len(lsps_on_int_a_b) == 0)
# int_a_c should have lsp_a_d_1 and lsp_a_d_2
lsp_names_on_int_a_c = [lsp.lsp_name for lsp in int_a_c.lsps(model1)]
self.assertIn('lsp_a_d_1', lsp_names_on_int_a_c)
self.assertIn('lsp_a_d_2', lsp_names_on_int_a_c)
# reservable_bandwidth on int_a_c
self.assertEqual(int_a_c.reserved_bandwidth, 150.0)
self.assertEqual(int_a_c.reservable_bandwidth, 0.0)
def test_int_bw(self):
model = Model()
model.rsvp_lsp_objects = set([])
model.demand_objects = set([])
int_list = [{
'name': 'E-to-A',
'cost': 10,
'capacity': 300,
'node': 'E',
'remote_node': 'A',
'circuit_id': 1,
'failed': False
}, {
'name': 'C-to-D',
'cost': 30,
'capacity': 150,
'node': 'C',
'remote_node': 'D',
'circuit_id': 5,
'failed': False
}, {
'name': 'D-to-C',
'cost': 30,
'capacity': 150,
'node': 'D',
'remote_node': 'C',
'circuit_id': 5,
'failed': False
}, {
'name': 'A-to-E',
'cost': 10,
'capacity': 300,
'node': 'A',
'remote_node': 'E',
'circuit_id': 1,
'failed': False
}, {
'name': 'A-to-D',
'cost': 40,
'capacity': 20,
'node': 'A',
'remote_node': 'D',
'circuit_id': 2,
'failed': False
}, {
'name': 'D-to-A',
'cost': 40,
'capacity': 20,
'node': 'D',
'remote_node': 'A',
'circuit_id': 2,
'failed': False
}, {
'name': 'G-to-D',
'cost': 10,
'capacity': 100,
'node': 'G',
'remote_node': 'D',
'circuit_id': 7,
'failed': False
}, {
'name': 'C-to-A',
'cost': 30,
'capacity': 150,
'node': 'C',
'remote_node': 'A',
'circuit_id': 3,
'failed': False
}, {
'name': 'D-to-F',
'cost': 10,
'capacity': 300,
'node': 'D',
'remote_node': 'F',
'circuit_id': 6,
'failed': False
}, {
'name': 'F-to-D',
'cost': 10,
'capacity': 300,
'node': 'F',
'remote_node': 'D',
'circuit_id': 6,
'failed': False
}, {
'name': 'D-to-G',
'cost': 10,
'capacity': 100,
'node': 'D',
'remote_node': 'G',
'circuit_id': 7,
'failed': False
}, {
'name': 'B-to-A',
'cost': 20,
'capacity': 125,
'node': 'B',
'remote_node': 'A',
'circuit_id': 4,
'failed': False
}, {
'name': 'D-to-B',
'cost': 20,
'capacity': 125,
'node': 'D',
'remote_node': 'B',
'circuit_id': 8,
'failed': False
}, {
'name': 'B-to-G',
'cost': 10,
'capacity': 100,
'node': 'B',
'remote_node': 'G',
'circuit_id': 9,
'failed': False
}, {
'name': 'A-to-C',
'cost': 30,
'capacity': 150,
'node': 'A',
'remote_node': 'C',
'circuit_id': 3,
'failed': False
}, {
'name': 'B-to-D',
'cost': 20,
'capacity': 125,
'node': 'B',
'remote_node': 'D',
'circuit_id': 8,
'failed': False
}, {
'name': 'G-to-B',
'cost': 10,
'capacity': 100,
'node': 'G',
'remote_node': 'B',
'circuit_id': 9,
'failed': False
}, {
'name': 'A-to-B',
'cost': 20,
'capacity': 125,
'node': 'A',
'remote_node': 'B',
'circuit_id': 4,
'failed': False
}]
model.add_network_interfaces_from_list(int_list)
model.add_rsvp_lsp('A', 'D', 'lsp_a_d_1')
model.add_rsvp_lsp('A', 'D', 'lsp_a_d_2')
demands = [
{
'source': 'A',
'dest': 'D',
'traffic': 100,
'name': 'dmd_a_d_3'
},
{
'source': 'A',
'dest': 'D',
'traffic': 70,
'name': 'dmd_a_d_2'
},
{
'source': 'A',
'dest': 'D',
'traffic': 80,
'name': 'dmd_a_d_1'
},
{
'source': 'F',
'dest': 'E',
'traffic': 400,
'name': 'dmd_f_e_1'
},
{
'source': 'A',
'dest': 'F',
'traffic': 40,
'name': 'dmd_a_f_1'
},
]
for demand in demands:
model.add_demand(demand['source'], demand['dest'],
demand['traffic'], demand['name'])
int_a_c = model.get_interface_object('A-to-C', 'A')
model.update_simulation()
print("int_a_c reserved and reservable bw = {} and {}".format(
int_a_c.reserved_bandwidth, int_a_c.reservable_bandwidth))
self.assertEqual(int_a_c.reserved_bandwidth, 125.0)
self.assertEqual(int_a_c.reservable_bandwidth, 25.0)
