← Back to branch summary

~free.ekanayaka/landscape-client/lucid-1.5.0-0ubuntu0.10.04.0

« back to all changes in this revision

Viewing changes to landscape/tests/test_accumulate.py

  • Committer: Bazaar Package Importer
  • Author(s): Rick Clark
  • Date: 2008-09-08 16:35:57 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080908163557-l3ixzj5dxz37wnw2
Tags: 1.0.18-0ubuntu1
New upstream release 

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/tests/test_accumulate.py
 
1
from landscape.lib.persist import Persist
 
2
from landscape.accumulate import Accumulator, accumulate
 
3
from landscape.tests.helpers import LandscapeTest
 
4
 
 
5
 
 
6
class AccumulateTest(LandscapeTest):
 
7
    """Test for the accumulate function that implements accumulation logic."""
 
8
 
 
9
    def test_accumulate(self):
 
10
        """
 
11
        step:    0              5
 
12
               --|--+--+--+--+--|--
 
13
        value:   0              4
 
14
        """
 
15
        accumulated_value, step_data = accumulate(0, 0, 5, 4, 5)
 
16
        self.assertEquals(accumulated_value, 0)
 
17
        self.assertEquals(step_data, (5, 4))
 
18
 
 
19
    def test_accumulate_non_zero_accumulated_value(self):
 
20
        """
 
21
        step:    5              10             15
 
22
               --|--+--+--+--+--|--+--+--+--+--|--
 
23
        value:         4                 3
 
24
        """
 
25
        accumulated_value, step_data = accumulate(7, 8, 13, 3, 5)
 
26
        self.assertEquals(accumulated_value, 9)
 
27
        self.assertEquals(step_data, (10, float((2*4) + (3*3))/5))
 
28
 
 
29
    def test_accumulate_skipped_step(self):
 
30
        """
 
31
        step:    0              5              10             15
 
32
               --|--+--+--+--+--|--+--+--+--+--|--+--+--+--+--|--
 
33
        value:   0                                   4
 
34
        """
 
35
        accumulated_value, step_data = accumulate(0, 0, 12, 4, 5)
 
36
        self.assertEquals(accumulated_value, 8)
 
37
        self.assertEquals(step_data, None)
 
38
 
 
39
    def test_accumulate_within_step(self):
 
40
        """
 
41
        step:    0              5
 
42
               --|--+--+--+--+--|--
 
43
        value:   0     4
 
44
        """
 
45
        accumulated_value, step_data = accumulate(0, 0, 2, 4, 5)
 
46
        self.assertEquals(accumulated_value, 8)
 
47
        self.assertEquals(step_data, None)
 
48
 
 
49
    def test_accumulate_within_step_with_nonzero_start_accumulated_value(self):
 
50
        """
 
51
        step:    0              5
 
52
               --|--+--+--+--+--|--
 
53
        value:   0     3     4
 
54
        """
 
55
        accumulated_value, step_data = accumulate(2, 6, 4, 4, 5)
 
56
        self.assertEquals(accumulated_value, 14)
 
57
        self.assertEquals(step_data, None)
 
58
 
 
59
    def test_accumulate_with_first_value_on_step_boundary(self):
 
60
        """
 
61
        step:    0              5
 
62
               --|--+--+--+--+--|--
 
63
        value:   14
 
64
        """
 
65
        accumulated_value, step_data = accumulate(0, 0, 0, 14, 5)
 
66
        self.assertEquals(accumulated_value, 0)
 
67
        self.assertEquals(step_data, None)
 
68
 
 
69
 
 
70
class AccumulatorTest(LandscapeTest):
 
71
    """Tests for the Accumulator plugin helper class."""
 
72
 
 
73
    def test_accumulate(self):
 
74
        """
 
75
        step:    0              5
 
76
               --|--+--+--+--+--|--
 
77
        value:   0              4
 
78
        """
 
79
        persist = Persist()
 
80
        accumulate = Accumulator(persist, 5)
 
81
 
 
82
        self.assertEquals(persist.get("key"), None)
 
83
        step_data = accumulate(5, 4, "key")
 
84
        self.assertEquals(step_data, (5, 4))
 
85
        self.assertEquals(persist.get("key"), (5, 0))
 
86
 
 
87
    def test_accumulate_non_zero_accumulated_value(self):
 
88
        """
 
89
        step:    5              10             15
 
90
               --|--+--+--+--+--|--+--+--+--+--|--
 
91
        value:         4                 3
 
92
        """
 
93
        persist = Persist()
 
94
        accumulate = Accumulator(persist, 5)
 
95
 
 
96
        # Persist data that would have been stored when
 
97
        # accumulate(7, 4, "key") was called.
 
98
        persist.set("key", (7, 8))
 
99
        step_data = accumulate(13, 3, "key")
 
100
        self.assertEquals(step_data, (10, float((2*4) + (3*3))/5))
 
101
        self.assertEquals(persist.get("key"), (13, 9))
 
102
 
 
103
    def test_accumulate_skipped_step(self):
 
104
        """
 
105
        step:    0              5              10             15
 
106
               --|--+--+--+--+--|--+--+--+--+--|--+--+--+--+--|--
 
107
        value:   0                                   4
 
108
        """
 
109
        persist = Persist()
 
110
        accumulate = Accumulator(persist, 5)
 
111
 
 
112
        self.assertEquals(persist.get("key"), None)
 
113
        step_data = accumulate(12, 4, "key")
 
114
        self.assertEquals(step_data, None)
 
115
        self.assertEquals(persist.get("key"), (12, 8))
 
116
 
 
117
    def test_accumulate_within_step(self):
 
118
        """
 
119
        step:    0              5
 
120
               --|--+--+--+--+--|--
 
121
        value:   0     4
 
122
        """
 
123
        persist = Persist()
 
124
        accumulate = Accumulator(persist, 5)
 
125
 
 
126
        self.assertEquals(persist.get("key"), None)
 
127
        step_data = accumulate(2, 4, "key")
 
128
        self.assertEquals(step_data, None)
 
129
        self.assertEquals(persist.get("key"), (2, 8))
 
130
 
 
131
    def test_accumulate_within_step_with_nonzero_start_accumulated_value(self):
 
132
        """
 
133
        step:    0              5
 
134
               --|--+--+--+--+--|--
 
135
        value:   0     3     4
 
136
        """
 
137
        persist = Persist()
 
138
        accumulate = Accumulator(persist, 5)
 
139
 
 
140
        # Persist data that would have been stored when
 
141
        # accumulate(2, 3, "key") was called.
 
142
        persist.set("key", (2, 6))
 
143
        step_data = accumulate(4, 4, "key")
 
144
        self.assertEquals(step_data, None)
 
145
        self.assertEquals(persist.get("key"), (4, 14))
 
146
 
 
147
    def test_accumulate_with_first_value_on_step_boundary(self):
 
148
        """
 
149
        step:    0              5
 
150
               --|--+--+--+--+--|--
 
151
        value:   14
 
152
        """
 
153
        persist = Persist()
 
154
        accumulate = Accumulator(persist, 5)
 
155
 
 
156
        self.assertEquals(persist.get("key"), None)
 
157
        step_data = accumulate(0, 14, "key")
 
158
        self.assertEquals(step_data, None)
 
159
        self.assertEquals(persist.get("key"), (0, 0))