← Back to branch summary

~ubuntu-branches/ubuntu/quantal/checkbox/quantal

« back to all changes in this revision

Viewing changes to checkbox/lib/tests/resolver.py

  • Committer: Package Import Robot
  • Author(s): Javier Collado, Brendan Donegan, Javier Collado, Marc Tardif, Daniel Manrique, Jeff Lane
  • Date: 2012-06-26 16:07:04 UTC
  • mfrom: (15.1.1 lucid-proposed)
  • Revision ID: package-import@ubuntu.com-20120626160704-xukgwy5skzi4hwt4
Tags: 0.14.1
https://launchpad.net/bugs/1018571
https://launchpad.net/bugs/990075
https://launchpad.net/bugs/1017951
https://launchpad.net/bugs/1018354
https://launchpad.net/bugs/1018353
* New upstream release (LP: #1018571)

[Brendan Donegan]
* Fixed up a few things with the gpu_lockup tests. Removed depends,
  renamed to gpu_lockup_suspend to reflect behaviour and removed the
  requirement on Firefox
* Changed suspend_advanced and suspend_advanced_auto to use less
  strict definition of fwts s3 test.

[Javier Collado]
* Make sure that jobs are topologically ordered (LP: #990075)
* Keep job ordering as close to whitelist as possible (LP: #1017951)

[Marc Tardif]
* New version 0.14.1 for Quantal Quetzal development.
* jobs/suspend.txt.in: Fixed trailing newline on otherwise empty line.
* scripts/run_templates: Fixed calls to Popen to use universal_newlines
  to return strings instead of bytes (LP: #1018354)

[Daniel Manrique]
* Fixed duplicate suspend/bluetooth_obex_after_suspend job name.
* scripts/dpkg_resource: Changed encoding from ascii to utf-8 to handle
  non-ascii locales (LP: #1018353)

[Jeff Lane]
* Migrated audio/external-HDMI-playback into checkbox. Modified the
  command to match our other audio tests that save and reset mixer
  levels.

Show diffs side-by-side

added added

removed removed

Lines of Context:
checkbox/lib/tests/resolver.py
22
22
 
23
23
 
24
24
class ResolverTest(unittest.TestCase):
 
25
    def setUp(self):
 
26
        self.resolver = Resolver()
 
27
 
25
28
    def test_dependencies_none(self):
26
 
        resolver = Resolver()
27
29
        try:
28
 
            resolver.get_dependencies('a')
 
30
            self.resolver.get_dependencies('a')
29
31
        except Exception as error:
30
32
            self.assertTrue(error.args[0].startswith('no dependencies'))
31
33
        else:
32
34
            self.fail('non existing element accepted by resolver')
33
35
 
34
36
    def test_dependencies_one_level(self):
35
 
        resolver = Resolver()
36
 
        resolver.add('a')
 
37
        self.resolver.add('a')
37
38
 
38
 
        results = resolver.get_dependencies('a')
39
 
        self.assertTrue(len(results) == 1)
40
 
        self.assertTrue(results[0] == 'a')
 
39
        results = self.resolver.get_dependencies('a')
 
40
        self.assertListEqual(results, ['a'])
41
41
 
42
42
    def test_dependencies_two_level(self):
43
 
        resolver = Resolver()
44
 
        resolver.add('a')
45
 
        resolver.add('b', 'a')
 
43
        self.resolver.add('a')
 
44
        self.resolver.add('b', 'a')
46
45
 
47
 
        results = resolver.get_dependencies('b')
48
 
        self.assertTrue(len(results) == 2)
49
 
        self.assertTrue(results[0] == 'a')
50
 
        self.assertTrue(results[1] == 'b')
 
46
        results = self.resolver.get_dependencies('b')
 
47
        self.assertListEqual(results, ['a', 'b'])
51
48
 
52
49
    def test_dependencies_multiple(self):
53
 
        resolver = Resolver()
54
 
        resolver.add('a')
55
 
        resolver.add('b')
56
 
        resolver.add('c', 'a', 'b')
 
50
        self.resolver.add('a')
 
51
        self.resolver.add('b')
 
52
        self.resolver.add('c', 'a', 'b')
57
53
 
58
 
        results = resolver.get_dependencies('c')
59
 
        self.assertTrue(len(results) == 3)
60
 
        self.assertTrue(results[0] == 'a')
61
 
        self.assertTrue(results[1] == 'b')
62
 
        self.assertTrue(results[2] == 'c')
 
54
        results = self.resolver.get_dependencies('c')
 
55
        self.assertListEqual(results, ['a', 'b', 'c'])
63
56
 
64
57
    def test_dependencies_circular(self):
65
 
        resolver = Resolver()
66
 
        resolver.add('a', 'b')
67
 
        resolver.add('b', 'a')
68
58
        try:
69
 
            resolver.get_dependencies('a')
 
59
            self.resolver.add('a', 'b')
 
60
            self.resolver.add('b', 'a')
 
61
            self.resolver.get_dependencies('a')
70
62
        except Exception as error:
71
63
            self.assertTrue(error.args[0].startswith('circular dependency'))
72
64
        else:
73
65
            self.fail('circular dependency not detected')
74
66
 
75
67
    def test_dependents_none(self):
76
 
        resolver = Resolver()
77
 
        resolver.add('a')
 
68
        self.resolver.add('a')
78
69
 
79
 
        results = resolver.get_dependents('a')
 
70
        results = self.resolver.get_dependents('a')
80
71
        self.assertTrue(len(results) == 0)
81
72
 
82
73
    def test_dependents_one(self):
83
 
        resolver = Resolver()
84
 
        resolver.add('a')
85
 
        resolver.add('b', 'a')
 
74
        self.resolver.add('a')
 
75
        self.resolver.add('b', 'a')
86
76
 
87
 
        results = resolver.get_dependents('a')
88
 
        self.assertTrue(len(results) == 1)
89
 
        self.assertTrue(results[0] == 'b')
 
77
        results = self.resolver.get_dependents('a')
 
78
        self.assertListEqual(results, ['b'])
90
79
 
91
80
    def test_dependents_two(self):
92
81
        resolver = Resolver()
95
84
        resolver.add('c', 'b')
96
85
 
97
86
        results = resolver.get_dependents('a')
98
 
        self.assertTrue(len(results) == 2)
99
 
        self.assertTrue(results[0] == 'b')
100
 
        self.assertTrue(results[1] == 'c')
 
87
        self.assertListEqual(results, ['b', 'c'])
 
88
 
 
89
    def test_multiple_resolve_steps(self):
 
90
        self.resolver.add('a', 'b')
 
91
        results = self.resolver.get_dependents()
 
92
        self.assertListEqual(results, ['a'])
 
93
 
 
94
        self.resolver.add('b')
 
95
        results = self.resolver.get_dependents()
 
96
        self.assertListEqual(results, ['b', 'a'])