build.tests.integration.test_results_edges_aux_3 - Code Metrics - Inspection of "Merge all marvin" - kytos/pathfinder - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#68)

by Arturo

created 2021-04-15 17:57 UTC

build.tests.integration.test_results_edges_aux_3 A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	601
Duplicated Lines	0 %

Importance

Changes

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

40 Methods

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

How to fix Complexity

"""Module to test the KytosGraph in graph.py. Auxiliary Third"""

# module under test
from tests.integration.edges_settings import EdgesSettings


class TestResultsEdgesAux3(EdgesSettings):
    """Tests for the graph class.

    Tests to see if reflexive searches and impossible searches
    show correct results.
    """

    def test_path8_1(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S1:1", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_2(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S2:1", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_3(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S3:1", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_4(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S5:1", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_5(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S4:2", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_6(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("User1:2", flexible={'delay': 50,
                                                                          'bandwidth': 100,
                                                                          'reliability': 3,
                                                                          'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_7(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S5:5", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_8(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S8:2", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_9(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S5:6", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_1_0(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("User1:3", flexible={'delay': 50,
                                                                          'bandwidth': 100,
                                                                          'reliability': 3,
                                                                          'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_1_1(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S6:3", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_1_2(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S9:1", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_1_3(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S6:4", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_1_4(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S9:2", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_1_5(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S6:5", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_1_6(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S10:1", flexible={'delay': 50,
                                                                        'bandwidth': 100,
                                                                        'reliability': 3,
                                                                        'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_1_7(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S8:5", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_1_8(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("S9:4", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_1_9(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("User1:4", flexible={'delay': 50,
                                                                          'bandwidth': 100,
                                                                          'reliability': 3,
                                                                          'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_2_0(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # delay = 50
        self.assertTrue(self.paths_between_all_users("User4:3", flexible={'delay': 50,
                                                                          'bandwidth': 100,
                                                                          'reliability': 3,
                                                                          'ownership': "B"},
                                                     metrics='delay'))

    def test_path8_2_1(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # bandwidth = 100
        self.assertTrue(self.paths_between_all_users("S3:1", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='bandwidth'))

    def test_path8_2_2(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # bandwidth = 100
        self.assertTrue(self.paths_between_all_users("S5:1", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='bandwidth'))

    def test_path8_2_3(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # bandwidth = 100
        self.assertTrue(self.paths_between_all_users("User1:4", flexible={'delay': 50,
                                                                          'bandwidth': 100,
                                                                          'reliability': 3,
                                                                          'ownership': "B"},
                                                     metrics='bandwidth'))

    def test_path8_2_4(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # bandwidth = 100
        self.assertTrue(self.paths_between_all_users("User4:3", flexible={'delay': 50,
                                                                          'bandwidth': 100,
                                                                          'reliability': 3,
                                                                          'ownership': "B"},
                                                     metrics='bandwidth'))

    def test_path8_2_5(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # reliability = 3
        self.assertTrue(self.paths_between_all_users("S4:1", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='reliability'))

    def test_path8_2_6(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # reliability = 3
        self.assertTrue(self.paths_between_all_users("S5:2", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='reliability'))

    def test_path8_2_7(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # reliability = 3
        self.assertTrue(self.paths_between_all_users("S5:3", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='reliability'))

    def test_path8_2_8(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # reliability = 3
        self.assertTrue(self.paths_between_all_users("S6:1", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"},
                                                     metrics='reliability'))

    def test_path8_2_9(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # ownership = "B"
        self.assertTrue(self.paths_between_all_users("S4:1", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"}))

    def test_path8_3_0(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # ownership = "B"
        self.assertTrue(self.paths_between_all_users("S5:2", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"}))

    def test_path8_3_1(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # ownership = "B"
        self.assertTrue(self.paths_between_all_users("S4:2", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"}))

    def test_path8_3_2(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # ownership = "B"
        self.assertTrue(self.paths_between_all_users("User1:2", flexible={'delay': 50,
                                                                          'bandwidth': 100,
                                                                          'reliability': 3,
                                                                          'ownership': "B"}))

    def test_path8_3_3(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # ownership = "B"
        self.assertTrue(self.paths_between_all_users("S5:4", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"}))

    def test_path8_3_4(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # ownership = "B"
        self.assertTrue(self.paths_between_all_users("S6:2", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"}))

    def test_path8_3_5(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # ownership = "B"
        self.assertTrue(self.paths_between_all_users("S6:5", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"}))

    def test_path8_3_6(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # ownership = "B"
        self.assertTrue(self.paths_between_all_users("S10:1", flexible={'delay': 50,
                                                                        'bandwidth': 100,
                                                                        'reliability': 3,
                                                                        'ownership': "B"}))

    def test_path8_3_7(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # ownership = "B"
        self.assertTrue(self.paths_between_all_users("S8:6", flexible={'delay': 50,
                                                                       'bandwidth': 100,
                                                                       'reliability': 3,
                                                                       'ownership': "B"}))

    def test_path8_3_8(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # ownership = "B"
        self.assertTrue(self.paths_between_all_users("S10:2", flexible={'delay': 50,
                                                                        'bandwidth': 100,
                                                                        'reliability': 3,
                                                                        'ownership': "B"}))

    def test_path8_3_9(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # ownership = "B"
        self.assertTrue(self.paths_between_all_users("S10:3", flexible={'delay': 50,
                                                                        'bandwidth': 100,
                                                                        'reliability': 3,
                                                                        'ownership': "B"}))

    def test_path8_4_0(self):
        """Tests paths between all users using constrained path algorithm,
        with the delay constraint set to 50, the bandwidth constraint
        set to 100, the reliability constraint set to 3, and the ownership
        constraint set to 'B'

        Tests conducted with flexibility enabled
        """
        # ownership = "B"
        self.assertTrue(self.paths_between_all_users("User2:1", flexible={'delay': 50,
                                                                          'bandwidth': 100,
                                                                          'reliability': 3,
                                                                          'ownership': "B"}))


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

kytos / pathfinder

Pull Request — master (#68)

build.tests.integration.test_results_edges_aux_3 A

Complexity

Size/Duplication

Importance

40 Methods

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like