1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
// $Id$
// ============================================================================
//
// = LIBRARY
// tests
//
// = FILENAME
// Time_Value_Test.cpp
//
// = DESCRIPTION
// This is a simple test of ACE_Time_Value. No command line arguments
// are needed to run the test. It also tests the ACE_U_LongLong class.
// Because ACE_U_LongLong is used for ACE_hrtime_t on some platforms,
// this seems like a reasonable place to test it.
//
// = AUTHOR
// Prashant Jain <pjain@cs.wustl.edu> and David Levine <levine@cs.wustl.edu>
//
// ============================================================================
// Note, for this test the config.h file *must* come first!
#include "ace/config-all.h"
ACE_RCSID(tests, Time_Value_Test, "$Id$")
// Force test of ACE_U_LongLong class on Solaris.
#if defined (sun) && !defined (ACE_LACKS_LONGLONG_T)
# include <limits.h>
# undef ULLONG_MAX
# if defined (ACE_HAS_HI_RES_TIMER)
# undef ACE_HAS_HI_RES_TIMER
# endif /* ACE_HAS_HI_RES_TIMER */
# define ACE_LACKS_LONGLONG_T
// Force inlining, in case ACE_U_LongLong member function
// definitions are not in libACE.
# if !defined (__ACE_INLINE__)
# define __ACE_INLINE__
# endif /* ! __ACE_INLINE__ */
# if defined (ACE_NO_INLINE)
# undef ACE_NO_INLINE
# endif /* ACE_NO_INLINE */
#endif /* sun && ! ACE_LACKS_LONGLONG_T */
#include "test_config.h"
#include "ace/ACE.h"
#if defined (sun) && !defined (ACE_LACKS_LONGLONG_T)
static
u_long
check_ace_u_longlong (const ACE_TCHAR *const name,
const ACE_U_LongLong ull,
const u_long hi,
const u_long lo)
{
if (ull.hi () == hi && ull.lo () == lo)
return 0;
else
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%s; hi: %x, should be %x; ")
ACE_TEXT ("lo: %x, should be %x.\n"),
name, ull.hi (), hi, ull.lo (), lo),
1);
}
static
u_long
test_ace_u_longlong (void)
{
u_long errors = 0;
ACE_U_LongLong ull1 (0x21,1);
errors += check_ace_u_longlong (ACE_TEXT ("ull1"), ull1, 1, 0x21);
ACE_U_LongLong ull2 (0x20,2);
errors += check_ace_u_longlong (ACE_TEXT ("ull2"), ull2, 2, 0x20);
ull2 -= ull1;
errors += check_ace_u_longlong (ACE_TEXT ("ull2"), ull2, 0, 0xfffffffful);
ull2 += ull1;
errors += check_ace_u_longlong (ACE_TEXT ("ull2"), ull2, 2, 0x20);
ACE_U_LongLong ull3 = ull1 + ull1;
errors += check_ace_u_longlong (ACE_TEXT ("ull3"), ull3, 2, 0x42);
ACE_U_LongLong ull4 = ACE_U_LongLong (0x1111, 0) -
ACE_U_LongLong (0x1112, 0);
errors += check_ace_u_longlong (ACE_TEXT ("ull4"), ull4, 0xfffffffful, 0xfffffffful);
ACE_U_LongLong ull5 = ACE_U_LongLong (0x1111, 1) -
ACE_U_LongLong (0x1112, 0);
errors += check_ace_u_longlong (ACE_TEXT ("ull5"), ull5, 0, 0xfffffffful);
++ull5;
errors += check_ace_u_longlong (ACE_TEXT ("ull5"), ull5, 1, 0);
ACE_U_LongLong ull6 = ull2 + ACE_U_LongLong (0, 1);
errors += check_ace_u_longlong (ACE_TEXT ("ull6"), ull6, 3, 0x20);
ull6 += ACE_U_LongLong (0xffffffff, 0xfff0);
errors += check_ace_u_longlong (ACE_TEXT ("ull6"), ull6, 0xfff4, 0x1f);
++ull6;
errors += check_ace_u_longlong (ACE_TEXT ("ull6"), ull6, 0xfff4, 0x20);
// The hi part of ull6 will be lost in the following, because
// the quotient has only 32 bits.
errors += check_ace_u_longlong (ACE_TEXT ("ull6 / 1"),
(ACE_U_LongLong) (ull6 / 1u),
0, 0x20);
// There's apparently a small loss in precision in
// ACE_U_LongLong::operator/. It calculates
// ull6 / 0xd0000 as 0x13b013b4 instead of 0x13b04ec4.
errors += check_ace_u_longlong (ACE_TEXT ("ull6 / 0x10000 / 0xd"),
(ACE_U_LongLong) (ull6 / 0x10000u / 0xd),
0, 0x13b04ec4);
errors += check_ace_u_longlong (ACE_TEXT ("ull6 % 5"),
(ACE_U_LongLong) (ull6 % 5),
0, 1);
errors += check_ace_u_longlong (ACE_TEXT ("ull6 % 0x20007"),
(ACE_U_LongLong) (ull6 % 0x20007),
0, 0x3f63);
ACE_U_LongLong ull7 (12);
ull7 *= 3125;
errors += check_ace_u_longlong (ACE_TEXT ("12 * 3125"),
ull7,
0, 37500);
ull7 *= 100;
errors += check_ace_u_longlong (ACE_TEXT ("37500 * 100"),
ull7,
0, 3750000);
errors += check_ace_u_longlong (ACE_TEXT ("3750000 << 16"),
ull7 << 16 ,
0x39, 0x38700000);
errors += check_ace_u_longlong (ACE_TEXT ("3750000 >> 16"),
ull7 >> 16,
0, 0x39);
ull7 <<= 32;
errors += check_ace_u_longlong (ACE_TEXT ("3750000 <<= 32"),
ull7,
3750000, 0);
ull7 >>= 12;
errors += check_ace_u_longlong (ACE_TEXT ("3750000 <<= 32 >>= 15"),
ull7,
0x393, 0x87000000);
ACE_U_LongLong ull8 (0x0f0f, 0xf0f0);
ACE_U_LongLong ull9 (0xf0f0, 0xf0f0);
ull8 |= ull9;
errors += check_ace_u_longlong (ACE_TEXT ("ull8 |= ull9"),
ull8,
0xf0f0, 0xffff);
ull9.lo (0x5678);
ull9.hi (0x1234);
ull8 &= ull9;
errors += check_ace_u_longlong (ACE_TEXT ("ull8 &= 0x12345678"),
ull9,
0x1234, 0x5678);
return errors;
}
#endif /* sun && ! ACE_LACKS_LONGLONG_T */
int
ACE_TMAIN (int, ACE_TCHAR *[])
{
int ret = 0;
ACE_START_TEST (ACE_TEXT ("Time_Value_Test"));
ACE_Time_Value tv1;
ACE_Time_Value tv2 (2);
ACE_Time_Value tv3 (100U);
ACE_Time_Value tv4 (1, 1000000);
ACE_Time_Value tv5 (2UL);
ACE_Time_Value tv6 (1, -1000000);
ACE_Time_Value tv7 (ACE_static_cast (long, 2.0));
// Beware! 2.5 gets truncated to 2!
// NOTE: this is intended to show what happens with
// ACE_Time_Value (2.5). Some compilers, such as g++ 2.7.2.3,
// actually warn about it without the case.
ACE_Time_Value tv8 (ACE_static_cast (long, 2.5));
// Test assignment operator, tv9 and tv6 must be the same after this
ACE_Time_Value tv9;
tv9 = tv6;
ACE_ASSERT (tv1 == ACE_Time_Value (0));
ACE_ASSERT (tv2 < tv3);
ACE_ASSERT (tv2 <= tv2);
ACE_ASSERT (tv2 >= tv4);
ACE_ASSERT (tv5 >= tv6);
ACE_ASSERT (tv2 == ACE_Time_Value (1, 1000000));
ACE_ASSERT (tv5 == tv4);
ACE_ASSERT (tv2 == tv4);
ACE_ASSERT (tv1 != tv2);
ACE_ASSERT (tv6 == tv1);
ACE_ASSERT (tv5 == tv7);
ACE_ASSERT (tv7 == tv8); // That's right! See above . . .
ACE_ASSERT (tv9 == tv6);
#if defined (sun) && !defined (ACE_LACKS_LONGLONG_T)
if (test_ace_u_longlong () != 0)
++ret;
#endif /* sun && ! ACE_LACKS_LONGLONG_T */
ACE_END_TEST;
return ret;
}
|
