← Back to branch summary

~ubuntu-branches/debian/sid/calligraplan/sid

« back to all changes in this revision

Viewing changes to src/libs/kernel/tests/EstimateTester.cpp

  • Committer: Package Import Robot
  • Author(s): Pino Toscano
  • Date: 2018-02-01 18:20:19 UTC
  • Revision ID: package-import@ubuntu.com-20180201182019-1qo7qaim5wejm5k9
Tags: upstream-3.1.0
Import upstream version 3.1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libs/kernel/tests/EstimateTester.cpp
 
1
/* This file is part of the KDE project
 
2
   Copyright (C) 2007 Dag Andersen <danders@get2net.dk>
 
3
 
 
4
   This library is free software; you can redistribute it and/or
 
5
   modify it under the terms of the GNU Library General Public
 
6
   License as published by the Free Software Foundation; either
 
7
   version 2 of the License, or (at your option) any later version.
 
8
 
 
9
   This library is distributed in the hope that it will be useful,
 
10
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
   Library General Public License for more details.
 
13
 
 
14
   You should have received a copy of the GNU Library General Public License
 
15
   along with this library; see the file COPYING.LIB.  If not, write to
 
16
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 
17
   Boston, MA 02110-1301, USA.
 
18
*/
 
19
#include "EstimateTester.h"
 
20
#include "kptduration.h"
 
21
#include "kptnode.h"
 
22
 
 
23
#include <QTest>
 
24
 
 
25
namespace KPlato
 
26
{
 
27
 
 
28
void EstimateTester::expected() {
 
29
    Estimate e1;
 
30
    e1.clear();
 
31
    QVERIFY( e1.expectedEstimate() == 0.0 );
 
32
    QVERIFY( e1.expectedValue().milliseconds() == 0.0 );
 
33
    
 
34
    e1.setExpectedEstimate( 1.0 );
 
35
    QVERIFY( e1.expectedEstimate() == 1.0 );
 
36
    QVERIFY( e1.expectedValue().milliseconds() == 1000*60*60 );
 
37
    
 
38
    e1.setUnit( Duration::Unit_ms );
 
39
    QVERIFY( e1.expectedEstimate() == 1.0 );
 
40
    QVERIFY( e1.expectedValue().milliseconds() == 1 );
 
41
 
 
42
    e1.setUnit( Duration::Unit_s );
 
43
    QVERIFY( e1.expectedEstimate() == 1.0 );
 
44
    QVERIFY( e1.expectedValue().milliseconds() == 1000 );
 
45
 
 
46
    e1.setUnit( Duration::Unit_m );
 
47
    QVERIFY( e1.expectedEstimate() == 1.0 );
 
48
    QVERIFY( e1.expectedValue().milliseconds() == 1000*60 );
 
49
 
 
50
    e1.setUnit( Duration::Unit_h );
 
51
    QVERIFY( e1.expectedEstimate() == 1.0 );
 
52
    QVERIFY( e1.expectedValue().milliseconds() == 1000*60*60 );
 
53
 
 
54
    e1.setUnit( Duration::Unit_d );
 
55
    QVERIFY( e1.expectedEstimate() == 1.0 );
 
56
    QVERIFY( e1.expectedValue().milliseconds() == 1000*60*60*24 );
 
57
 
 
58
    e1.setUnit( Duration::Unit_w );
 
59
    QVERIFY( e1.expectedEstimate() == 1.0 );
 
60
    QVERIFY( e1.expectedValue().milliseconds() == 1000*60*60*24*7 );
 
61
 
 
62
    e1.setUnit( Duration::Unit_M );
 
63
    QVERIFY( e1.expectedEstimate() == 1.0 );
 
64
    QCOMPARE( e1.expectedValue().milliseconds(), qint64(1000*60*60) * (24*30) );
 
65
 
 
66
    e1.setUnit( Duration::Unit_Y );
 
67
    QVERIFY( e1.expectedEstimate() == 1.0 );
 
68
    QCOMPARE( e1.expectedValue().milliseconds(), qint64(1000*60*60) * (24*365) );
 
69
 
 
70
}
 
71
 
 
72
void EstimateTester::optimistic() {
 
73
    Estimate e1;
 
74
    e1.clear();
 
75
    QVERIFY( e1.optimisticEstimate() == 0.0 );
 
76
    QVERIFY( e1.optimisticValue().milliseconds() == 0.0 );
 
77
    
 
78
    e1.setOptimisticEstimate( 1.0 );
 
79
    QVERIFY( e1.optimisticEstimate() == 1.0 );
 
80
    QVERIFY( e1.optimisticValue().milliseconds() == 1000*60*60 );
 
81
    
 
82
    e1.setUnit( Duration::Unit_ms );
 
83
    QVERIFY( e1.optimisticEstimate() == 1.0 );
 
84
    QVERIFY( e1.optimisticValue().milliseconds() == 1 );
 
85
 
 
86
    e1.setUnit( Duration::Unit_s );
 
87
    QVERIFY( e1.optimisticEstimate() == 1.0 );
 
88
    QVERIFY( e1.optimisticValue().milliseconds() == 1000 );
 
89
 
 
90
    e1.setUnit( Duration::Unit_m );
 
91
    QVERIFY( e1.optimisticEstimate() == 1.0 );
 
92
    QVERIFY( e1.optimisticValue().milliseconds() == 1000*60 );
 
93
 
 
94
    e1.setUnit( Duration::Unit_h );
 
95
    QVERIFY( e1.optimisticEstimate() == 1.0 );
 
96
    QVERIFY( e1.optimisticValue().milliseconds() == 1000*60*60 );
 
97
 
 
98
    e1.setUnit( Duration::Unit_d );
 
99
    QVERIFY( e1.optimisticEstimate() == 1.0 );
 
100
    QVERIFY( e1.optimisticValue().milliseconds() == 1000*60*60*24 );
 
101
 
 
102
}
 
103
 
 
104
void EstimateTester::pessimistic() {
 
105
    Estimate e1;
 
106
    e1.clear();
 
107
    QVERIFY( e1.pessimisticEstimate() == 0.0 );
 
108
    QVERIFY( e1.pessimisticValue().milliseconds() == 0.0 );
 
109
    
 
110
    e1.setPessimisticEstimate( 1.0 );
 
111
    QVERIFY( e1.pessimisticEstimate() == 1.0 );
 
112
    QVERIFY( e1.pessimisticValue().milliseconds() == 1000*60*60 );
 
113
    
 
114
    e1.setUnit( Duration::Unit_ms );
 
115
    QVERIFY( e1.pessimisticEstimate() == 1.0 );
 
116
    QVERIFY( e1.pessimisticValue().milliseconds() == 1 );
 
117
 
 
118
    e1.setUnit( Duration::Unit_s );
 
119
    QVERIFY( e1.pessimisticEstimate() == 1.0 );
 
120
    QVERIFY( e1.pessimisticValue().milliseconds() == 1000 );
 
121
 
 
122
    e1.setUnit( Duration::Unit_m );
 
123
    QVERIFY( e1.pessimisticEstimate() == 1.0 );
 
124
    QVERIFY( e1.pessimisticValue().milliseconds() == 1000*60 );
 
125
 
 
126
    e1.setUnit( Duration::Unit_h );
 
127
    QVERIFY( e1.pessimisticEstimate() == 1.0 );
 
128
    QVERIFY( e1.pessimisticValue().milliseconds() == 1000*60*60 );
 
129
 
 
130
    e1.setUnit( Duration::Unit_d );
 
131
    QVERIFY( e1.pessimisticEstimate() == 1.0 );
 
132
    QVERIFY( e1.pessimisticValue().milliseconds() == 1000*60*60*24 );
 
133
 
 
134
}
 
135
 
 
136
void EstimateTester::ratio() {
 
137
    Estimate e1;
 
138
    e1.clear();
 
139
    
 
140
    e1.setExpectedEstimate( 1.0 );
 
141
    e1.setOptimisticEstimate( 1.0 );
 
142
    e1.setPessimisticEstimate( 1.0 );
 
143
 
 
144
    QVERIFY( e1.pessimisticRatio() == 0 );
 
145
    QVERIFY( e1.optimisticRatio() == 0 );
 
146
    
 
147
    e1.setExpectedEstimate( 2.0 );
 
148
    e1.setOptimisticEstimate( 1.0 );
 
149
    e1.setPessimisticEstimate( 4.0 );
 
150
 
 
151
    QVERIFY( e1.pessimisticRatio() == 100 );
 
152
    QVERIFY( e1.optimisticRatio() == -50 );
 
153
 
 
154
    e1.setUnit( Duration::Unit_h );
 
155
    e1.setOptimisticEstimate( 0.5 );
 
156
    QVERIFY( e1.pessimisticRatio() == 100 );
 
157
    QVERIFY( e1.optimisticRatio() == -75 );
 
158
 
 
159
    e1.clear();
 
160
    e1.setUnit( Duration::Unit_d );
 
161
    e1.setExpectedEstimate( 1.0 );
 
162
    e1.setOptimisticRatio( -50 );
 
163
    e1.setPessimisticRatio( 100 );
 
164
    QVERIFY( e1.pessimisticEstimate() == 2.0 );
 
165
    QVERIFY( e1.optimisticEstimate() == 0.5 );
 
166
    QVERIFY( e1.pessimisticValue() == 1000*60*60 * 48 );
 
167
    QVERIFY( e1.optimisticValue() == 1000*60*60 * 12 );
 
168
 
 
169
}
 
170
 
 
171
void EstimateTester::defaultScale() {
 
172
    QList<qint64> s = Estimate::defaultScales();
 
173
 
 
174
    QCOMPARE( s.count(), 8 );
 
175
 
 
176
    Duration d = Estimate::scale( 1.0, Duration::Unit_Y, s );
 
177
    QCOMPARE( d.milliseconds(), s[0] );
 
178
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_Y, s ) );
 
179
 
 
180
    d = Estimate::scale( 1.0, Duration::Unit_M, s );
 
181
    QCOMPARE( d.milliseconds(), s[1] );
 
182
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_M, s ) );
 
183
 
 
184
    d = Estimate::scale( 1.0, Duration::Unit_w, s );
 
185
    QCOMPARE( d.milliseconds(), s[2] );
 
186
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_w, s ) );
 
187
 
 
188
    d = Estimate::scale( 1.0, Duration::Unit_d, s );
 
189
    QCOMPARE( d.milliseconds(), s[3] );
 
190
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_d, s ) );
 
191
 
 
192
    d = Estimate::scale( 1.0, Duration::Unit_h, s );
 
193
    QCOMPARE( d.milliseconds(), s[4] );
 
194
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_h, s ) );
 
195
 
 
196
    d = Estimate::scale( 1.0, Duration::Unit_m, s );
 
197
    QCOMPARE( d.milliseconds(), s[5] );
 
198
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_m, s ) );
 
199
 
 
200
    d = Estimate::scale( 1.0, Duration::Unit_s, s );
 
201
    QCOMPARE( d.milliseconds(), s[6] );
 
202
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_s, s ) );
 
203
 
 
204
    d = Estimate::scale( 1.0, Duration::Unit_ms, s );
 
205
    QCOMPARE( d.milliseconds(), s[7] );
 
206
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_ms, s ) );
 
207
}
 
208
 
 
209
void EstimateTester::scale() {
 
210
    StandardWorktime wt;
 
211
    QList<qint64> s = wt.scales();
 
212
 
 
213
    QCOMPARE( s.count(), 8 );
 
214
 
 
215
    Duration d = Estimate::scale( 1.0, Duration::Unit_Y, s );
 
216
    QCOMPARE( d.milliseconds(), s[0] );
 
217
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_Y, s ) );
 
218
 
 
219
    d = Estimate::scale( 1.0, Duration::Unit_M, s );
 
220
    QCOMPARE( d.milliseconds(), s[1] );
 
221
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_M, s ) );
 
222
 
 
223
    d = Estimate::scale( 1.0, Duration::Unit_w, s );
 
224
    QCOMPARE( d.milliseconds(), s[2] );
 
225
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_w, s ) );
 
226
 
 
227
    d = Estimate::scale( 1.0, Duration::Unit_d, s );
 
228
    QCOMPARE( d.milliseconds(), s[3] );
 
229
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_d, s ) );
 
230
 
 
231
    d = Estimate::scale( 1.0, Duration::Unit_h, s );
 
232
    QCOMPARE( d.milliseconds(), s[4] );
 
233
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_h, s ) );
 
234
 
 
235
    d = Estimate::scale( 1.0, Duration::Unit_m, s );
 
236
    QCOMPARE( d.milliseconds(), s[5] );
 
237
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_m, s ) );
 
238
 
 
239
    d = Estimate::scale( 1.0, Duration::Unit_s, s );
 
240
    QCOMPARE( d.milliseconds(), s[6] );
 
241
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_s, s ) );
 
242
 
 
243
    d = Estimate::scale( 1.0, Duration::Unit_ms, s );
 
244
    QCOMPARE( d.milliseconds(), s[7] );
 
245
    QCOMPARE( 1.0, Estimate::scale( d, Duration::Unit_ms, s ) );
 
246
}
 
247
 
 
248
void EstimateTester::pert() {
 
249
    Estimate e1;
 
250
    e1.clear();
 
251
    e1.setUnit( Duration::Unit_d );
 
252
    e1.setExpectedEstimate( 4.0 );
 
253
    e1.setOptimisticEstimate( 2.0 );
 
254
    e1.setPessimisticEstimate( 8.0 );
 
255
    
 
256
    QVERIFY( e1.deviation() == 1.0 );
 
257
    QVERIFY( e1.deviation( Duration::Unit_h ) == 24.0 );
 
258
 
 
259
    QVERIFY( e1.variance() == 1.0 );
 
260
    QVERIFY( e1.variance( Duration::Unit_h ) == 24.0*24.0 );
 
261
    
 
262
    qint64 day = 1000*60*60*24;
 
263
 
 
264
    e1.setRisktype( Estimate::Risk_None );
 
265
    QVERIFY( e1.pertExpected().milliseconds() == 4 * day );
 
266
    e1.setRisktype( Estimate::Risk_Low );
 
267
    QVERIFY( e1.pertExpected().milliseconds() == ((2 + 8 + (4*4))*day)/6 );
 
268
    e1.setRisktype( Estimate::Risk_High );
 
269
    QVERIFY( e1.pertExpected().milliseconds() == ((2 + 16 + (4*4))*day)/7 );
 
270
}
 
271
 
 
272
} //namespace KPlato
 
273
 
 
274
QTEST_GUILESS_MAIN( KPlato::EstimateTester )