1 //
2 // sc_Subfield_t.cpp
3 //
4 // $Id: sc_Subfield_t.cpp,v 1.10 2003/06/10 17:50:56 mcoletti Exp $
5 //
6
7 #include <cassert>
8 #include <iostream>
9
10 #include <cmath>
11 #include <climits>
12
13 #ifdef _MSC_VER
14 #define HAVE_FLOAT_H
15 #endif
16
17 #ifdef HAVE_FLOAT_H
18 #include <float.h>
19 #endif
20
21
22 using namespace std;
23
24
25
26 #include <sdts++/container/sc_Subfield.h>
27
28
29 const double MIN_DBL_DISTANCE = DBL_MIN * 2;
30 const double MIN_FLT_DISTANCE = FLT_MIN * 2;
31
32
33
34 bool
equal(double const & l,double const & r)35 equal( double const& l, double const& r )
36 {
37 double d = fabs( l - r );
38
39 // if the difference is less than
40 // twice the smallest possible double
41 // value, then the two values are
42 // close enough to be equal
43 return d < MIN_DBL_DISTANCE;
44 } // equal
45
46
47
48 bool
equal(float const & l,float const & r)49 equal( float const& l, float const& r )
50 {
51 double d = fabs( static_cast<double>(l) -
52 static_cast<double>(r) );
53
54 float f = static_cast<float>(d);
55
56 // if the difference is less than
57 // twice the smallest possible double
58 // value, then the two values are
59 // close enough to be equal
60 return f < MIN_FLT_DISTANCE;
61 } // equal
62
63
64
65 int
main(int argc,char ** argv)66 main( int argc, char** argv )
67 {
68
69 sc_Subfield sf;
70
71 int int_val;
72 long long_val;
73 unsigned long ulong_val;
74 float float_val;
75 double double_val;
76 string name = "TEST";
77
78 // test initial state as being null
79
80 assert( ! sf.getI( long_val ) );
81
82
83 // name and mnemonic tests
84
85 assert( sf.setName( name ) == name );
86 assert( sf.setMnemonic( name ) == name );
87
88
89 // first test the "I" type set and get
90
91 sf.setI( 42 );
92
93 assert( sf.getI( long_val ) );
94
95 assert( 42 == long_val );
96
97 assert( sc_Subfield::is_I == sf.getSubfieldType() );
98
99 assert( sf.getInt( int_val ) );
100
101 assert( sf.getFloat( float_val ) );
102
103 assert( sf.getDouble( double_val ) );
104
105 // this should fail as the subfield is now "locked" as an "I" type
106
107 assert( ! sf.getBUI8( ulong_val ) );
108
109
110 // now test BUI*
111
112 sf.setBUI8( 24 );
113
114 assert( sf.getBUI8( ulong_val ) );
115
116 assert( 24 == ulong_val );
117
118 assert( sc_Subfield::is_BUI8 == sf.getSubfieldType() );
119
120 assert( sf.getInt( int_val ) );
121
122 assert( sf.getFloat( float_val ) );
123
124 assert( sf.getDouble( double_val ) );
125
126
127 sf.setBUI16( 24 );
128
129 assert( sf.getBUI16( ulong_val ) );
130
131 assert( 24 == ulong_val );
132
133 assert( sc_Subfield::is_BUI16 == sf.getSubfieldType() );
134
135 assert( sf.getInt( int_val ) );
136
137 assert( sf.getFloat( float_val ) );
138
139 assert( sf.getDouble( double_val ) );
140
141
142 sf.setBUI24( 24 );
143
144 assert( sf.getBUI24( ulong_val ) );
145
146 assert( 24 == ulong_val );
147
148 assert( sc_Subfield::is_BUI24 == sf.getSubfieldType() );
149
150 assert( sf.getInt( int_val ) );
151
152 assert( sf.getFloat( float_val ) );
153
154 assert( sf.getDouble( double_val ) );
155
156
157 sf.setBUI32( 24 );
158
159 assert( sf.getBUI32( ulong_val ) );
160
161 assert( 24 == ulong_val );
162
163 assert( sc_Subfield::is_BUI32 == sf.getSubfieldType() );
164
165 assert( sf.getInt( int_val ) );
166
167 assert( sf.getFloat( float_val ) );
168
169 assert( sf.getDouble( double_val ) );
170
171
172 // now test BI*
173
174
175 sf.setBI8( -99 );
176
177 assert( sf.getBI8( long_val ) );
178
179 assert( -99 == long_val );
180
181 assert( sc_Subfield::is_BI8 == sf.getSubfieldType() );
182
183 assert( sf.getInt( int_val ) );
184
185 assert( sf.getFloat( float_val ) );
186
187 assert( sf.getDouble( double_val ) );
188
189
190 sf.setBI16( -99 );
191
192 assert( sf.getBI16( long_val ) );
193
194 assert( -99 == long_val );
195
196 assert( sc_Subfield::is_BI16 == sf.getSubfieldType() );
197
198 assert( sf.getInt( int_val ) );
199
200 assert( sf.getFloat( float_val ) );
201
202 assert( sf.getDouble( double_val ) );
203
204
205 sf.setBI24( -99 );
206
207 assert( sf.getBI24( long_val ) );
208
209 assert( -99 == long_val );
210
211 assert( sc_Subfield::is_BI24 == sf.getSubfieldType() );
212
213 assert( sf.getInt( int_val ) );
214
215 assert( sf.getFloat( float_val ) );
216
217 assert( sf.getDouble( double_val ) );
218
219
220 sf.setBI32( -99 );
221
222 assert( sf.getBI32( long_val ) );
223
224 assert( -99 == long_val );
225
226 assert( sc_Subfield::is_BI32 == sf.getSubfieldType() );
227
228 assert( sf.getInt( int_val ) );
229
230 assert( sf.getFloat( float_val ) );
231
232 assert( sf.getDouble( double_val ) );
233
234
235
236
237
238 // now test BFP*
239
240
241 sf.setBFP32( 123.45 );
242
243 assert( sf.getBFP32( float_val ) );
244
245 assert( equal( static_cast<float>(123.45), float_val ) );
246
247 assert( sc_Subfield::is_BFP32 == sf.getSubfieldType() );
248
249 assert( sf.getInt( int_val ) );
250
251 assert( sf.getFloat( float_val ) );
252
253 assert( sf.getDouble( double_val ) );
254
255
256 sf.setBFP64( 123.45 );
257
258 assert( sf.getBFP64( double_val ) );
259
260 assert( equal( 123.45, double_val ) );
261
262 assert( sc_Subfield::is_BFP64 == sf.getSubfieldType() );
263
264 assert( sf.getInt( int_val ) );
265
266 assert( sf.getFloat( float_val ) );
267
268 assert( sf.getDouble( double_val ) );
269
270
271
272
273 // string testing
274
275 string tmp_string;
276
277 sf.setA( "FOO" );
278
279 assert( sf.getA( tmp_string ) );
280
281 assert( "FOO" == tmp_string );
282
283 assert( ! sf.getBUI8( ulong_val ) ); // can't get long from string
284
285 assert( ! sf.getInt( int_val ) );
286
287 assert( ! sf.getFloat( float_val ) );
288
289 assert( ! sf.getDouble( double_val ) );
290
291
292 // copy ctor test
293
294 {
295 sc_Subfield local_sf( sf );
296 string my_val;
297
298 assert( local_sf.getA( my_val ) );
299
300 assert( "FOO" == my_val );
301
302 assert( ! local_sf.getBUI8( ulong_val ) );
303
304 assert( sf.getName( ) == name );
305 assert( sf.getMnemonic( ) == name );
306
307 }
308
309
310 // assignment operator test
311
312 {
313 sc_Subfield local_sf;
314 string my_val;
315
316 local_sf = sf;
317
318 assert( local_sf.getA( my_val ) );
319
320 assert( "FOO" == my_val );
321
322 assert( ! local_sf.getBUI8( ulong_val ) );
323
324 assert( sf.getName( ) == name );
325 assert( sf.getMnemonic( ) == name );
326
327 }
328
329
330 // null reset test
331
332 sf.setUnvalued();
333
334 assert( ! sf.getA( tmp_string ) );
335
336
337 // done!
338
339 exit( 0 );
340 }
341