def test_validate_traffic_matrix_diff_units(self):
topo = fnss.line_topology(2)
fnss.set_capacities_constant(topo, 1, capacity_unit='Gbps')
valid_tm = fnss.TrafficMatrix(volume_unit='Mbps')
valid_tm.add_flow(0, 1, 999)
self.assertTrue(fnss.validate_traffic_matrix(topo, valid_tm, validate_load=True))
invalid_tm = fnss.TrafficMatrix(volume_unit='Mbps')
invalid_tm.add_flow(0, 1, 1001)
self.assertFalse(fnss.validate_traffic_matrix(topo, invalid_tm, validate_load=True))
def test_link_loads_ecmp(self):
topo = fnss.ring_topology(5)
topo.add_edge(1, 3)
fnss.set_capacities_constant(topo, 100, capacity_unit='Mbps')
tm = fnss.TrafficMatrix(volume_unit='Mbps')
tm.add_flow(0, 1, 20)
tm.add_flow(1, 0, 30)
tm.add_flow(0, 2, 40)
tm.add_flow(1, 4, 70)
rm = {
0: {
0: [[0]],
1: [[0, 1]],
2: [[0, 1, 2]],
3: [[0, 1, 3], [0, 4, 3]],
4: [[0, 4]]
},
1: {
0: [[1, 0]],
1: [[1]],
2: [[1, 2]],
3: [[1, 3]],
4: [[1, 3, 4], [1, 0, 4]]
},
2: {
0: [[2, 1, 0]],
1: [[2, 1]],
2: [[2]],
3: [[2, 3]],
4: [[2, 3, 4]]
},
3: {
0: [[3, 1, 0], [3, 4, 0]],
1: [[3, 1]],
2: [[3, 2]],
3: [[3]],
4: [[3, 4]]
},
4: {
0: [[4, 0]],
1: [[4, 0, 1], [4, 3, 1]],
2: [[4, 3, 2]],
3: [[4, 3]],
4: [[4]]
}
}
load = fnss.link_loads(topo, tm, routing_matrix=rm, ecmp=True)
self.assertAlmostEqual(0.6, load[(0, 1)])
self.assertAlmostEqual(0.65, load[(1, 0)])
self.assertAlmostEqual(0.4, load[(1, 2)])
self.assertAlmostEqual(0.0, load[(2, 1)])
self.assertAlmostEqual(0.35, load[(0, 4)])
self.assertAlmostEqual(0.35, load[(3, 4)])
self.assertAlmostEqual(0.0, load[(4, 3)])
self.assertAlmostEqual(0.0, load[(4, 0)])
self.assertAlmostEqual(0.0, load[(2, 1)])
self.assertAlmostEqual(0.0, load[(2, 3)])
def test_validate_traffic_matrix(self):
topology = fnss.DirectedTopology()
topology.add_path([1, 2, 3])
topology.add_path([3, 2, 1])
topology.add_edge(3, 4)
fnss.set_capacities_constant(topology, 1, 'Mbps')
flows_valid_load = {1: {3: 0.4}, 2: {4: 0.3}}
flows_invalid_load = {1: {3: 0.4}, 2: {4: 0.7}}
flows_invalid_routes = {4: {1: 0.4}}
flows_invalid_pairs = {5: {2: 0.1}}
self.assertTrue(
fnss.validate_traffic_matrix(topology,
fnss.TrafficMatrix(
'Mbps', flows_valid_load),
validate_load=False))
self.assertTrue(
fnss.validate_traffic_matrix(topology,
fnss.TrafficMatrix(
'Mbps', flows_valid_load),
validate_load=True))
self.assertTrue(
fnss.validate_traffic_matrix(topology,
fnss.TrafficMatrix(
'Mbps', flows_invalid_load),
validate_load=False))
self.assertFalse(
fnss.validate_traffic_matrix(topology,
fnss.TrafficMatrix(
'Mbps', flows_invalid_load),
validate_load=True))
self.assertFalse(
fnss.validate_traffic_matrix(topology,
fnss.TrafficMatrix(
'Mbps', flows_invalid_routes),
validate_load=False))
self.assertFalse(
fnss.validate_traffic_matrix(topology,
fnss.TrafficMatrix(
'Mbps', flows_invalid_routes),
validate_load=True))
self.assertFalse(
fnss.validate_traffic_matrix(topology,
fnss.TrafficMatrix(
'Mbps', flows_invalid_pairs),
validate_load=False))
self.assertFalse(
fnss.validate_traffic_matrix(topology,
fnss.TrafficMatrix(
'Mbps', flows_invalid_pairs),
validate_load=True))
def test_traffic_matrix_sequence_class(self):
tms = fnss.TrafficMatrixSequence()
tm1 = fnss.TrafficMatrix(volume_unit='Mbps')
tm1.add_flow(1, 2, 1000)
tm1.add_flow(1, 3, 1500)
tm1.add_flow(3, 4, 4000)
tm2 = fnss.TrafficMatrix(volume_unit='Mbps')
tm2.add_flow(1, 2, 2000)
tm2.add_flow(1, 3, 3500)
tm2.add_flow(3, 4, 5000)
tm3 = fnss.TrafficMatrix(volume_unit='Mbps')
tm3.add_flow(1, 2, 5000)
tm3.add_flow(1, 3, 6500)
tm3.add_flow(3, 4, 7000)
tms.append(tm1)
tms.append(tm2)
tms.append(tm3)
self.assertEqual(1000, tms[0][(1, 2)])
self.assertEqual(1000, tms[0].flow[1][2])
self.assertEqual(1000, tms.get(0)[(1, 2)])
self.assertEqual(1000, tms.get(0).flows()[(1, 2)])
self.assertEqual(3, len(tms))
del tms[0]
self.assertEqual(2, len(tms))
def test_link_loads(self):
topo = fnss.ring_topology(5)
fnss.set_capacities_constant(topo, 100, capacity_unit='Mbps')
tm = fnss.TrafficMatrix(volume_unit='Mbps')
tm.add_flow(0, 1, 20)
tm.add_flow(1, 0, 30)
tm.add_flow(0, 2, 40)
tm.add_flow(1, 4, 70)
tm.add_flow(4, 2, 50)
load = fnss.link_loads(topo, tm)
self.assertAlmostEqual(0.6, load[(0, 1)])
self.assertAlmostEqual(1.0, load[(1, 0)])
self.assertAlmostEqual(0.4, load[(1, 2)])
self.assertAlmostEqual(0.0, load[(2, 1)])
self.assertAlmostEqual(0.7, load[(0, 4)])
self.assertAlmostEqual(0.5, load[(4, 3)])
def test_traffic_matrix_class(self):
tm = fnss.TrafficMatrix(volume_unit='Mbps')
tm.add_flow(1, 2, 1000)
tm.add_flow(1, 3, 1500)
tm.add_flow(3, 'Four', 4000)
tm[(4, 5)] = 3000
tm[('Orig', 'Dest')] = 3000
self.assertEqual(tm[(1, 3)], 1500)
self.assertEqual(tm.flow[1][3], 1500)
self.assertEqual(tm.flows()[(1, 3)], 1500)
self.assertEqual(5, len(tm))
flow = tm.pop_flow(1, 2)
self.assertEqual(1000, flow)
del tm[(1, 3)]
self.assertEqual(3, len(tm))
self.assertFalse(1 in tm.flow)
self.assertFalse((1, 3) in tm)
