Test Failed
Pull Request — master (#68)
by Arturo
02:47
created

build.tests.integration.test_results_edges_aux_3   A

Complexity

Total Complexity 40

Size/Duplication

Total Lines 601
Duplicated Lines 0 %

Importance

Changes 0
Metric Value
eloc 231
dl 0
loc 601
rs 9.2
c 0
b 0
f 0
wmc 40

40 Methods

Rating   Name   Duplication   Size   Complexity  
A TestResultsEdgesAux3.test_path8_1_3() 0 14 1
A TestResultsEdgesAux3.test_path8_3_1() 0 13 1
A TestResultsEdgesAux3.test_path8_1_1() 0 14 1
A TestResultsEdgesAux3.test_path8_2_4() 0 14 1
A TestResultsEdgesAux3.test_path8_1_0() 0 14 1
A TestResultsEdgesAux3.test_path8_3_5() 0 13 1
A TestResultsEdgesAux3.test_path8_1_9() 0 14 1
A TestResultsEdgesAux3.test_path8_3_0() 0 13 1
A TestResultsEdgesAux3.test_path8_3_2() 0 13 1
A TestResultsEdgesAux3.test_path8_2_7() 0 14 1
A TestResultsEdgesAux3.test_path8_4() 0 14 1
A TestResultsEdgesAux3.test_path8_2_2() 0 14 1
A TestResultsEdgesAux3.test_path8_2_9() 0 13 1
A TestResultsEdgesAux3.test_path8_2_8() 0 14 1
A TestResultsEdgesAux3.test_path8_2_3() 0 14 1
A TestResultsEdgesAux3.test_path8_3_8() 0 13 1
A TestResultsEdgesAux3.test_path8_1() 0 14 1
A TestResultsEdgesAux3.test_path8_2_6() 0 14 1
A TestResultsEdgesAux3.test_path8_2_5() 0 14 1
A TestResultsEdgesAux3.test_path8_3_4() 0 13 1
A TestResultsEdgesAux3.test_path8_1_8() 0 14 1
A TestResultsEdgesAux3.test_path8_3_7() 0 13 1
A TestResultsEdgesAux3.test_path8_3_9() 0 13 1
A TestResultsEdgesAux3.test_path8_3_3() 0 13 1
A TestResultsEdgesAux3.test_path8_8() 0 14 1
A TestResultsEdgesAux3.test_path8_1_7() 0 14 1
A TestResultsEdgesAux3.test_path8_1_4() 0 14 1
A TestResultsEdgesAux3.test_path8_2() 0 14 1
A TestResultsEdgesAux3.test_path8_5() 0 14 1
A TestResultsEdgesAux3.test_path8_1_5() 0 14 1
A TestResultsEdgesAux3.test_path8_4_0() 0 13 1
A TestResultsEdgesAux3.test_path8_1_6() 0 14 1
A TestResultsEdgesAux3.test_path8_9() 0 14 1
A TestResultsEdgesAux3.test_path8_6() 0 14 1
A TestResultsEdgesAux3.test_path8_3_6() 0 13 1
A TestResultsEdgesAux3.test_path8_3() 0 14 1
A TestResultsEdgesAux3.test_path8_2_0() 0 14 1
A TestResultsEdgesAux3.test_path8_7() 0 14 1
A TestResultsEdgesAux3.test_path8_2_1() 0 14 1
A TestResultsEdgesAux3.test_path8_1_2() 0 14 1

How to fix   Complexity   

Complexity

Complex classes like build.tests.integration.test_results_edges_aux_3 often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

1
"""Module to test the KytosGraph in graph.py. Auxiliary Third"""
2
3
# module under test
4
from tests.integration.edges_settings import EdgesSettings
5
6
7
class TestResultsEdgesAux3(EdgesSettings):
8
    """Tests for the graph class.
9
10
    Tests to see if reflexive searches and impossible searches
11
    show correct results.
12
    """
13
14
    def test_path8_1(self):
15
        """Tests paths between all users using constrained path algorithm,
16
        with the delay constraint set to 50, the bandwidth constraint
17
        set to 100, the reliability constraint set to 3, and the ownership
18
        constraint set to 'B'
19
20
        Tests conducted with flexibility enabled
21
        """
22
        # delay = 50
23
        self.assertTrue(self.paths_between_all_users("S1:1", flexible={'delay': 50,
24
                                                                       'bandwidth': 100,
25
                                                                       'reliability': 3,
26
                                                                       'ownership': "B"},
27
                                                     metrics='delay'))
28
29
    def test_path8_2(self):
30
        """Tests paths between all users using constrained path algorithm,
31
        with the delay constraint set to 50, the bandwidth constraint
32
        set to 100, the reliability constraint set to 3, and the ownership
33
        constraint set to 'B'
34
35
        Tests conducted with flexibility enabled
36
        """
37
        # delay = 50
38
        self.assertTrue(self.paths_between_all_users("S2:1", flexible={'delay': 50,
39
                                                                       'bandwidth': 100,
40
                                                                       'reliability': 3,
41
                                                                       'ownership': "B"},
42
                                                     metrics='delay'))
43
44
    def test_path8_3(self):
45
        """Tests paths between all users using constrained path algorithm,
46
        with the delay constraint set to 50, the bandwidth constraint
47
        set to 100, the reliability constraint set to 3, and the ownership
48
        constraint set to 'B'
49
50
        Tests conducted with flexibility enabled
51
        """
52
        # delay = 50
53
        self.assertTrue(self.paths_between_all_users("S3:1", flexible={'delay': 50,
54
                                                                       'bandwidth': 100,
55
                                                                       'reliability': 3,
56
                                                                       'ownership': "B"},
57
                                                     metrics='delay'))
58
59
    def test_path8_4(self):
60
        """Tests paths between all users using constrained path algorithm,
61
        with the delay constraint set to 50, the bandwidth constraint
62
        set to 100, the reliability constraint set to 3, and the ownership
63
        constraint set to 'B'
64
65
        Tests conducted with flexibility enabled
66
        """
67
        # delay = 50
68
        self.assertTrue(self.paths_between_all_users("S5:1", flexible={'delay': 50,
69
                                                                       'bandwidth': 100,
70
                                                                       'reliability': 3,
71
                                                                       'ownership': "B"},
72
                                                     metrics='delay'))
73
74
    def test_path8_5(self):
75
        """Tests paths between all users using constrained path algorithm,
76
        with the delay constraint set to 50, the bandwidth constraint
77
        set to 100, the reliability constraint set to 3, and the ownership
78
        constraint set to 'B'
79
80
        Tests conducted with flexibility enabled
81
        """
82
        # delay = 50
83
        self.assertTrue(self.paths_between_all_users("S4:2", flexible={'delay': 50,
84
                                                                       'bandwidth': 100,
85
                                                                       'reliability': 3,
86
                                                                       'ownership': "B"},
87
                                                     metrics='delay'))
88
89
    def test_path8_6(self):
90
        """Tests paths between all users using constrained path algorithm,
91
        with the delay constraint set to 50, the bandwidth constraint
92
        set to 100, the reliability constraint set to 3, and the ownership
93
        constraint set to 'B'
94
95
        Tests conducted with flexibility enabled
96
        """
97
        # delay = 50
98
        self.assertTrue(self.paths_between_all_users("User1:2", flexible={'delay': 50,
99
                                                                          'bandwidth': 100,
100
                                                                          'reliability': 3,
101
                                                                          'ownership': "B"},
102
                                                     metrics='delay'))
103
104
    def test_path8_7(self):
105
        """Tests paths between all users using constrained path algorithm,
106
        with the delay constraint set to 50, the bandwidth constraint
107
        set to 100, the reliability constraint set to 3, and the ownership
108
        constraint set to 'B'
109
110
        Tests conducted with flexibility enabled
111
        """
112
        # delay = 50
113
        self.assertTrue(self.paths_between_all_users("S5:5", flexible={'delay': 50,
114
                                                                       'bandwidth': 100,
115
                                                                       'reliability': 3,
116
                                                                       'ownership': "B"},
117
                                                     metrics='delay'))
118
119
    def test_path8_8(self):
120
        """Tests paths between all users using constrained path algorithm,
121
        with the delay constraint set to 50, the bandwidth constraint
122
        set to 100, the reliability constraint set to 3, and the ownership
123
        constraint set to 'B'
124
125
        Tests conducted with flexibility enabled
126
        """
127
        # delay = 50
128
        self.assertTrue(self.paths_between_all_users("S8:2", flexible={'delay': 50,
129
                                                                       'bandwidth': 100,
130
                                                                       'reliability': 3,
131
                                                                       'ownership': "B"},
132
                                                     metrics='delay'))
133
134
    def test_path8_9(self):
135
        """Tests paths between all users using constrained path algorithm,
136
        with the delay constraint set to 50, the bandwidth constraint
137
        set to 100, the reliability constraint set to 3, and the ownership
138
        constraint set to 'B'
139
140
        Tests conducted with flexibility enabled
141
        """
142
        # delay = 50
143
        self.assertTrue(self.paths_between_all_users("S5:6", flexible={'delay': 50,
144
                                                                       'bandwidth': 100,
145
                                                                       'reliability': 3,
146
                                                                       'ownership': "B"},
147
                                                     metrics='delay'))
148
149
    def test_path8_1_0(self):
150
        """Tests paths between all users using constrained path algorithm,
151
        with the delay constraint set to 50, the bandwidth constraint
152
        set to 100, the reliability constraint set to 3, and the ownership
153
        constraint set to 'B'
154
155
        Tests conducted with flexibility enabled
156
        """
157
        # delay = 50
158
        self.assertTrue(self.paths_between_all_users("User1:3", flexible={'delay': 50,
159
                                                                          'bandwidth': 100,
160
                                                                          'reliability': 3,
161
                                                                          'ownership': "B"},
162
                                                     metrics='delay'))
163
164
    def test_path8_1_1(self):
165
        """Tests paths between all users using constrained path algorithm,
166
        with the delay constraint set to 50, the bandwidth constraint
167
        set to 100, the reliability constraint set to 3, and the ownership
168
        constraint set to 'B'
169
170
        Tests conducted with flexibility enabled
171
        """
172
        # delay = 50
173
        self.assertTrue(self.paths_between_all_users("S6:3", flexible={'delay': 50,
174
                                                                       'bandwidth': 100,
175
                                                                       'reliability': 3,
176
                                                                       'ownership': "B"},
177
                                                     metrics='delay'))
178
179
    def test_path8_1_2(self):
180
        """Tests paths between all users using constrained path algorithm,
181
        with the delay constraint set to 50, the bandwidth constraint
182
        set to 100, the reliability constraint set to 3, and the ownership
183
        constraint set to 'B'
184
185
        Tests conducted with flexibility enabled
186
        """
187
        # delay = 50
188
        self.assertTrue(self.paths_between_all_users("S9:1", flexible={'delay': 50,
189
                                                                       'bandwidth': 100,
190
                                                                       'reliability': 3,
191
                                                                       'ownership': "B"},
192
                                                     metrics='delay'))
193
194
    def test_path8_1_3(self):
195
        """Tests paths between all users using constrained path algorithm,
196
        with the delay constraint set to 50, the bandwidth constraint
197
        set to 100, the reliability constraint set to 3, and the ownership
198
        constraint set to 'B'
199
200
        Tests conducted with flexibility enabled
201
        """
202
        # delay = 50
203
        self.assertTrue(self.paths_between_all_users("S6:4", flexible={'delay': 50,
204
                                                                       'bandwidth': 100,
205
                                                                       'reliability': 3,
206
                                                                       'ownership': "B"},
207
                                                     metrics='delay'))
208
209
    def test_path8_1_4(self):
210
        """Tests paths between all users using constrained path algorithm,
211
        with the delay constraint set to 50, the bandwidth constraint
212
        set to 100, the reliability constraint set to 3, and the ownership
213
        constraint set to 'B'
214
215
        Tests conducted with flexibility enabled
216
        """
217
        # delay = 50
218
        self.assertTrue(self.paths_between_all_users("S9:2", flexible={'delay': 50,
219
                                                                       'bandwidth': 100,
220
                                                                       'reliability': 3,
221
                                                                       'ownership': "B"},
222
                                                     metrics='delay'))
223
224
    def test_path8_1_5(self):
225
        """Tests paths between all users using constrained path algorithm,
226
        with the delay constraint set to 50, the bandwidth constraint
227
        set to 100, the reliability constraint set to 3, and the ownership
228
        constraint set to 'B'
229
230
        Tests conducted with flexibility enabled
231
        """
232
        # delay = 50
233
        self.assertTrue(self.paths_between_all_users("S6:5", flexible={'delay': 50,
234
                                                                       'bandwidth': 100,
235
                                                                       'reliability': 3,
236
                                                                       'ownership': "B"},
237
                                                     metrics='delay'))
238
239
    def test_path8_1_6(self):
240
        """Tests paths between all users using constrained path algorithm,
241
        with the delay constraint set to 50, the bandwidth constraint
242
        set to 100, the reliability constraint set to 3, and the ownership
243
        constraint set to 'B'
244
245
        Tests conducted with flexibility enabled
246
        """
247
        # delay = 50
248
        self.assertTrue(self.paths_between_all_users("S10:1", flexible={'delay': 50,
249
                                                                        'bandwidth': 100,
250
                                                                        'reliability': 3,
251
                                                                        'ownership': "B"},
252
                                                     metrics='delay'))
253
254
    def test_path8_1_7(self):
255
        """Tests paths between all users using constrained path algorithm,
256
        with the delay constraint set to 50, the bandwidth constraint
257
        set to 100, the reliability constraint set to 3, and the ownership
258
        constraint set to 'B'
259
260
        Tests conducted with flexibility enabled
261
        """
262
        # delay = 50
263
        self.assertTrue(self.paths_between_all_users("S8:5", flexible={'delay': 50,
264
                                                                       'bandwidth': 100,
265
                                                                       'reliability': 3,
266
                                                                       'ownership': "B"},
267
                                                     metrics='delay'))
268
269
    def test_path8_1_8(self):
270
        """Tests paths between all users using constrained path algorithm,
271
        with the delay constraint set to 50, the bandwidth constraint
272
        set to 100, the reliability constraint set to 3, and the ownership
273
        constraint set to 'B'
274
275
        Tests conducted with flexibility enabled
276
        """
277
        # delay = 50
278
        self.assertTrue(self.paths_between_all_users("S9:4", flexible={'delay': 50,
279
                                                                       'bandwidth': 100,
280
                                                                       'reliability': 3,
281
                                                                       'ownership': "B"},
282
                                                     metrics='delay'))
283
284
    def test_path8_1_9(self):
285
        """Tests paths between all users using constrained path algorithm,
286
        with the delay constraint set to 50, the bandwidth constraint
287
        set to 100, the reliability constraint set to 3, and the ownership
288
        constraint set to 'B'
289
290
        Tests conducted with flexibility enabled
291
        """
292
        # delay = 50
293
        self.assertTrue(self.paths_between_all_users("User1:4", flexible={'delay': 50,
294
                                                                          'bandwidth': 100,
295
                                                                          'reliability': 3,
296
                                                                          'ownership': "B"},
297
                                                     metrics='delay'))
298
299
    def test_path8_2_0(self):
300
        """Tests paths between all users using constrained path algorithm,
301
        with the delay constraint set to 50, the bandwidth constraint
302
        set to 100, the reliability constraint set to 3, and the ownership
303
        constraint set to 'B'
304
305
        Tests conducted with flexibility enabled
306
        """
307
        # delay = 50
308
        self.assertTrue(self.paths_between_all_users("User4:3", flexible={'delay': 50,
309
                                                                          'bandwidth': 100,
310
                                                                          'reliability': 3,
311
                                                                          'ownership': "B"},
312
                                                     metrics='delay'))
313
314
    def test_path8_2_1(self):
315
        """Tests paths between all users using constrained path algorithm,
316
        with the delay constraint set to 50, the bandwidth constraint
317
        set to 100, the reliability constraint set to 3, and the ownership
318
        constraint set to 'B'
319
320
        Tests conducted with flexibility enabled
321
        """
322
        # bandwidth = 100
323
        self.assertTrue(self.paths_between_all_users("S3:1", flexible={'delay': 50,
324
                                                                       'bandwidth': 100,
325
                                                                       'reliability': 3,
326
                                                                       'ownership': "B"},
327
                                                     metrics='bandwidth'))
328
329
    def test_path8_2_2(self):
330
        """Tests paths between all users using constrained path algorithm,
331
        with the delay constraint set to 50, the bandwidth constraint
332
        set to 100, the reliability constraint set to 3, and the ownership
333
        constraint set to 'B'
334
335
        Tests conducted with flexibility enabled
336
        """
337
        # bandwidth = 100
338
        self.assertTrue(self.paths_between_all_users("S5:1", flexible={'delay': 50,
339
                                                                       'bandwidth': 100,
340
                                                                       'reliability': 3,
341
                                                                       'ownership': "B"},
342
                                                     metrics='bandwidth'))
343
344
    def test_path8_2_3(self):
345
        """Tests paths between all users using constrained path algorithm,
346
        with the delay constraint set to 50, the bandwidth constraint
347
        set to 100, the reliability constraint set to 3, and the ownership
348
        constraint set to 'B'
349
350
        Tests conducted with flexibility enabled
351
        """
352
        # bandwidth = 100
353
        self.assertTrue(self.paths_between_all_users("User1:4", flexible={'delay': 50,
354
                                                                          'bandwidth': 100,
355
                                                                          'reliability': 3,
356
                                                                          'ownership': "B"},
357
                                                     metrics='bandwidth'))
358
359
    def test_path8_2_4(self):
360
        """Tests paths between all users using constrained path algorithm,
361
        with the delay constraint set to 50, the bandwidth constraint
362
        set to 100, the reliability constraint set to 3, and the ownership
363
        constraint set to 'B'
364
365
        Tests conducted with flexibility enabled
366
        """
367
        # bandwidth = 100
368
        self.assertTrue(self.paths_between_all_users("User4:3", flexible={'delay': 50,
369
                                                                          'bandwidth': 100,
370
                                                                          'reliability': 3,
371
                                                                          'ownership': "B"},
372
                                                     metrics='bandwidth'))
373
374
    def test_path8_2_5(self):
375
        """Tests paths between all users using constrained path algorithm,
376
        with the delay constraint set to 50, the bandwidth constraint
377
        set to 100, the reliability constraint set to 3, and the ownership
378
        constraint set to 'B'
379
380
        Tests conducted with flexibility enabled
381
        """
382
        # reliability = 3
383
        self.assertTrue(self.paths_between_all_users("S4:1", flexible={'delay': 50,
384
                                                                       'bandwidth': 100,
385
                                                                       'reliability': 3,
386
                                                                       'ownership': "B"},
387
                                                     metrics='reliability'))
388
389
    def test_path8_2_6(self):
390
        """Tests paths between all users using constrained path algorithm,
391
        with the delay constraint set to 50, the bandwidth constraint
392
        set to 100, the reliability constraint set to 3, and the ownership
393
        constraint set to 'B'
394
395
        Tests conducted with flexibility enabled
396
        """
397
        # reliability = 3
398
        self.assertTrue(self.paths_between_all_users("S5:2", flexible={'delay': 50,
399
                                                                       'bandwidth': 100,
400
                                                                       'reliability': 3,
401
                                                                       'ownership': "B"},
402
                                                     metrics='reliability'))
403
404
    def test_path8_2_7(self):
405
        """Tests paths between all users using constrained path algorithm,
406
        with the delay constraint set to 50, the bandwidth constraint
407
        set to 100, the reliability constraint set to 3, and the ownership
408
        constraint set to 'B'
409
410
        Tests conducted with flexibility enabled
411
        """
412
        # reliability = 3
413
        self.assertTrue(self.paths_between_all_users("S5:3", flexible={'delay': 50,
414
                                                                       'bandwidth': 100,
415
                                                                       'reliability': 3,
416
                                                                       'ownership': "B"},
417
                                                     metrics='reliability'))
418
419
    def test_path8_2_8(self):
420
        """Tests paths between all users using constrained path algorithm,
421
        with the delay constraint set to 50, the bandwidth constraint
422
        set to 100, the reliability constraint set to 3, and the ownership
423
        constraint set to 'B'
424
425
        Tests conducted with flexibility enabled
426
        """
427
        # reliability = 3
428
        self.assertTrue(self.paths_between_all_users("S6:1", flexible={'delay': 50,
429
                                                                       'bandwidth': 100,
430
                                                                       'reliability': 3,
431
                                                                       'ownership': "B"},
432
                                                     metrics='reliability'))
433
434
    def test_path8_2_9(self):
435
        """Tests paths between all users using constrained path algorithm,
436
        with the delay constraint set to 50, the bandwidth constraint
437
        set to 100, the reliability constraint set to 3, and the ownership
438
        constraint set to 'B'
439
440
        Tests conducted with flexibility enabled
441
        """
442
        # ownership = "B"
443
        self.assertTrue(self.paths_between_all_users("S4:1", flexible={'delay': 50,
444
                                                                       'bandwidth': 100,
445
                                                                       'reliability': 3,
446
                                                                       'ownership': "B"}))
447
448
    def test_path8_3_0(self):
449
        """Tests paths between all users using constrained path algorithm,
450
        with the delay constraint set to 50, the bandwidth constraint
451
        set to 100, the reliability constraint set to 3, and the ownership
452
        constraint set to 'B'
453
454
        Tests conducted with flexibility enabled
455
        """
456
        # ownership = "B"
457
        self.assertTrue(self.paths_between_all_users("S5:2", flexible={'delay': 50,
458
                                                                       'bandwidth': 100,
459
                                                                       'reliability': 3,
460
                                                                       'ownership': "B"}))
461
462
    def test_path8_3_1(self):
463
        """Tests paths between all users using constrained path algorithm,
464
        with the delay constraint set to 50, the bandwidth constraint
465
        set to 100, the reliability constraint set to 3, and the ownership
466
        constraint set to 'B'
467
468
        Tests conducted with flexibility enabled
469
        """
470
        # ownership = "B"
471
        self.assertTrue(self.paths_between_all_users("S4:2", flexible={'delay': 50,
472
                                                                       'bandwidth': 100,
473
                                                                       'reliability': 3,
474
                                                                       'ownership': "B"}))
475
476
    def test_path8_3_2(self):
477
        """Tests paths between all users using constrained path algorithm,
478
        with the delay constraint set to 50, the bandwidth constraint
479
        set to 100, the reliability constraint set to 3, and the ownership
480
        constraint set to 'B'
481
482
        Tests conducted with flexibility enabled
483
        """
484
        # ownership = "B"
485
        self.assertTrue(self.paths_between_all_users("User1:2", flexible={'delay': 50,
486
                                                                          'bandwidth': 100,
487
                                                                          'reliability': 3,
488
                                                                          'ownership': "B"}))
489
490
    def test_path8_3_3(self):
491
        """Tests paths between all users using constrained path algorithm,
492
        with the delay constraint set to 50, the bandwidth constraint
493
        set to 100, the reliability constraint set to 3, and the ownership
494
        constraint set to 'B'
495
496
        Tests conducted with flexibility enabled
497
        """
498
        # ownership = "B"
499
        self.assertTrue(self.paths_between_all_users("S5:4", flexible={'delay': 50,
500
                                                                       'bandwidth': 100,
501
                                                                       'reliability': 3,
502
                                                                       'ownership': "B"}))
503
504
    def test_path8_3_4(self):
505
        """Tests paths between all users using constrained path algorithm,
506
        with the delay constraint set to 50, the bandwidth constraint
507
        set to 100, the reliability constraint set to 3, and the ownership
508
        constraint set to 'B'
509
510
        Tests conducted with flexibility enabled
511
        """
512
        # ownership = "B"
513
        self.assertTrue(self.paths_between_all_users("S6:2", flexible={'delay': 50,
514
                                                                       'bandwidth': 100,
515
                                                                       'reliability': 3,
516
                                                                       'ownership': "B"}))
517
518
    def test_path8_3_5(self):
519
        """Tests paths between all users using constrained path algorithm,
520
        with the delay constraint set to 50, the bandwidth constraint
521
        set to 100, the reliability constraint set to 3, and the ownership
522
        constraint set to 'B'
523
524
        Tests conducted with flexibility enabled
525
        """
526
        # ownership = "B"
527
        self.assertTrue(self.paths_between_all_users("S6:5", flexible={'delay': 50,
528
                                                                       'bandwidth': 100,
529
                                                                       'reliability': 3,
530
                                                                       'ownership': "B"}))
531
532
    def test_path8_3_6(self):
533
        """Tests paths between all users using constrained path algorithm,
534
        with the delay constraint set to 50, the bandwidth constraint
535
        set to 100, the reliability constraint set to 3, and the ownership
536
        constraint set to 'B'
537
538
        Tests conducted with flexibility enabled
539
        """
540
        # ownership = "B"
541
        self.assertTrue(self.paths_between_all_users("S10:1", flexible={'delay': 50,
542
                                                                        'bandwidth': 100,
543
                                                                        'reliability': 3,
544
                                                                        'ownership': "B"}))
545
546
    def test_path8_3_7(self):
547
        """Tests paths between all users using constrained path algorithm,
548
        with the delay constraint set to 50, the bandwidth constraint
549
        set to 100, the reliability constraint set to 3, and the ownership
550
        constraint set to 'B'
551
552
        Tests conducted with flexibility enabled
553
        """
554
        # ownership = "B"
555
        self.assertTrue(self.paths_between_all_users("S8:6", flexible={'delay': 50,
556
                                                                       'bandwidth': 100,
557
                                                                       'reliability': 3,
558
                                                                       'ownership': "B"}))
559
560
    def test_path8_3_8(self):
561
        """Tests paths between all users using constrained path algorithm,
562
        with the delay constraint set to 50, the bandwidth constraint
563
        set to 100, the reliability constraint set to 3, and the ownership
564
        constraint set to 'B'
565
566
        Tests conducted with flexibility enabled
567
        """
568
        # ownership = "B"
569
        self.assertTrue(self.paths_between_all_users("S10:2", flexible={'delay': 50,
570
                                                                        'bandwidth': 100,
571
                                                                        'reliability': 3,
572
                                                                        'ownership': "B"}))
573
574
    def test_path8_3_9(self):
575
        """Tests paths between all users using constrained path algorithm,
576
        with the delay constraint set to 50, the bandwidth constraint
577
        set to 100, the reliability constraint set to 3, and the ownership
578
        constraint set to 'B'
579
580
        Tests conducted with flexibility enabled
581
        """
582
        # ownership = "B"
583
        self.assertTrue(self.paths_between_all_users("S10:3", flexible={'delay': 50,
584
                                                                        'bandwidth': 100,
585
                                                                        'reliability': 3,
586
                                                                        'ownership': "B"}))
587
588
    def test_path8_4_0(self):
589
        """Tests paths between all users using constrained path algorithm,
590
        with the delay constraint set to 50, the bandwidth constraint
591
        set to 100, the reliability constraint set to 3, and the ownership
592
        constraint set to 'B'
593
594
        Tests conducted with flexibility enabled
595
        """
596
        # ownership = "B"
597
        self.assertTrue(self.paths_between_all_users("User2:1", flexible={'delay': 50,
598
                                                                          'bandwidth': 100,
599
                                                                          'reliability': 3,
600
                                                                          'ownership': "B"}))
601