feisty meow concerns codebase  2.140
test_packing.cpp
Go to the documentation of this file.
1 /*
2 * Name : test_object_packing
3 * Author : Chris Koeritz
4 **
5 * Copyright (c) 1996-$now By Author. This program is free software; you can *
6 * redistribute it and/or modify it under the terms of the GNU General Public *
7 * License as published by the Free Software Foundation; either version 2 of *
8 * the License or (at your option) any later version. This is online at: *
9 * http://www.fsf.org/copyleft/gpl.html *
10 * Please send any updates to: fred@gruntose.com *
11 */
12 
13 #include <application/hoople_main.h>
14 #include <basis/astring.h>
15 #include <basis/byte_array.h>
16 #include <basis/functions.h>
17 #include <basis/guards.h>
18 #include <loggers/critical_events.h>
19 #include <mathematics/chaos.h>
20 #include <mathematics/double_plus.h>
21 #include <structures/static_memory_gremlin.h>
22 #include <unit_test/unit_base.h>
23 
24 #include <math.h>
25 
26 using namespace application;
27 using namespace basis;
28 using namespace loggers;
29 using namespace mathematics;
30 using namespace structures;
31 using namespace unit_test;
32 
33 #define GENERATE_TEST_NAME(group, message) \
34  (astring(group) + " test group: " + message)
35 
36 #define TRY_ON(type, value, group) { \
37  byte_array temp_array; \
38  attach(temp_array, type(value)); \
39  type output; \
40 /*log(astring(astring::SPRINTF, "parms are: type=%s value=%s group=%s", #type, #value, #group));*/ \
41  ASSERT_TRUE(detach(temp_array, output), \
42  GENERATE_TEST_NAME(group, "should unpack " #type " okay")); \
43  ASSERT_TRUE(output == type(value), \
44  GENERATE_TEST_NAME(group, #type " value should match")); \
45  ASSERT_FALSE(temp_array.length(), \
46  GENERATE_TEST_NAME(group, #type " detached should be empty")); \
47 }
48 
49 #define TRY_ON_OBSCURE(type, value, group) { \
50  byte_array temp_array; \
51  obscure_attach(temp_array, type(value)); \
52  type output; \
53 /*log(astring(astring::SPRINTF, "parms are: type=%s value=%s group=%s", #type, #value, #group));*/ \
54  ASSERT_TRUE(obscure_detach(temp_array, output), \
55  GENERATE_TEST_NAME(group, "should obscure unpack " #type " okay")); \
56  ASSERT_TRUE(output == type(value), \
57  GENERATE_TEST_NAME(group, #type " value should obscure match")); \
58  ASSERT_FALSE(temp_array.length(), \
59  GENERATE_TEST_NAME(group, #type " obscure detached should be empty")); \
60 }
61 
62 #define TRY_ON_F(type, value, group) { \
63  byte_array temp_array; \
64  attach(temp_array, type(value)); \
65  type output; \
66 /*log(astring(astring::SPRINTF, "parms are: type=%s value=%s group=%s", #type, #value, #group));*/ \
67  ASSERT_TRUE(detach(temp_array, output), \
68  GENERATE_TEST_NAME(group, "should unpack " #type " fine")); \
69 /* double_plus<type> a(output); \
70  double_plus<type> b(value); */ \
71  /*double diff = maximum(output, value) - minimum(output, value);*/ \
72  int exponent_1, exponent_2; \
73  double mantissa_1 = frexp(output, &exponent_1); \
74  double mantissa_2 = frexp(output, &exponent_2); \
75  ASSERT_FALSE( (mantissa_1 != mantissa_2) || (exponent_1 != exponent_2), \
76  GENERATE_TEST_NAME(group, #type " value should match just so")); \
77  ASSERT_FALSE(temp_array.length(), \
78  GENERATE_TEST_NAME(group, #type " detached should have no data left")); \
79 }
80 
81 class test_object_packing : virtual public unit_base, virtual public application_shell
82 {
83 public:
84  test_object_packing() : application_shell() {}
85  ~test_object_packing() {}
86 
87  DEFINE_CLASS_NAME("test_object_packing");
88 
89  int execute();
90 };
91 
93 
94 int test_object_packing::execute()
95 {
96  FUNCDEF("execute");
97  {
98  #define TEST "first"
99  TRY_ON(int, 2383, TEST);
100  TRY_ON(int, -18281, TEST);
101 // TRY_ON(long, 337628, TEST);
102 // TRY_ON(long, -987887, TEST);
103  TRY_ON(short, 12983, TEST);
104  TRY_ON(short, -32700, TEST);
105  TRY_ON(int, 2988384, TEST);
106  TRY_ON(int, 92982984, TEST);
107 // TRY_ON(un_long, 388745, TEST);
108 // TRY_ON(un_long, 993787, TEST);
109  TRY_ON(basis::un_short, 12983, TEST);
110  TRY_ON(basis::un_short, 48377, TEST);
111  TRY_ON_OBSCURE(un_int, -23948377, TEST);
112  TRY_ON_OBSCURE(un_int, 28938, TEST);
113  #undef TEST
114  }
115  {
116  #define TEST "second"
117  TRY_ON(int, 0, TEST);
118  TRY_ON(int, MAXINT32, TEST);
119  TRY_ON(int, MININT32, TEST);
120  TRY_ON(abyte, 0, TEST);
121  TRY_ON(abyte, MAXBYTE, TEST);
122  TRY_ON(abyte, MINBYTE, TEST);
123  TRY_ON(char, 0, TEST);
124  TRY_ON(char, MAXCHAR, TEST);
125  TRY_ON(char, MINCHAR, TEST);
126 // TRY_ON(long, 0, TEST);
127 // TRY_ON(long, MAXLONG, TEST);
128 // TRY_ON(long, MINLONG, TEST);
129  TRY_ON(short, 0, TEST);
130  TRY_ON(short, MAXINT16, TEST);
131  TRY_ON(short, MININT16, TEST);
132  TRY_ON(basis::un_int, 0, TEST);
133  un_int max_u_int = MAXINT32 | MININT32;
134  TRY_ON(basis::un_int, max_u_int, TEST);
135  TRY_ON(basis::un_int, max_u_int - 1, TEST);
136  TRY_ON(basis::un_int, max_u_int - 2, TEST);
137  TRY_ON(basis::un_int, max_u_int - 3, TEST);
138 // un_long max_u_long = MAXLONG | MINLONG;
139 // TRY_ON(un_long, 0, TEST);
140 // TRY_ON(un_long, max_u_long, TEST);
141 // TRY_ON(un_long, max_u_long - 1, TEST);
142 // TRY_ON(un_long, max_u_long - 2, TEST);
143 // TRY_ON(un_long, max_u_long - 3, TEST);
144  basis::un_short max_u_short = MAXINT16 | MININT16;
145  TRY_ON(basis::un_short, 0, TEST);
146  TRY_ON(basis::un_short, max_u_short, TEST);
147  TRY_ON(basis::un_short, max_u_short - 1, TEST);
148  TRY_ON(basis::un_short, max_u_short - 2, TEST);
149  TRY_ON(basis::un_short, max_u_short - 3, TEST);
150  #undef TEST
151  }
152  {
153  #define TEST "third"
154  // new bit for floating point packing.
155  TRY_ON_F(double, 0.0, TEST);
156  TRY_ON_F(double, 1.0, TEST);
157  TRY_ON_F(double, -1.0, TEST);
158  TRY_ON_F(double, 1.1, TEST);
159  TRY_ON_F(double, -1.1, TEST);
160  TRY_ON_F(double, 1983.293, TEST);
161  TRY_ON_F(double, -1983.293, TEST);
162  TRY_ON_F(double, 984.293e20, TEST);
163  TRY_ON_F(double, -984.293e31, TEST);
164 
165  const int MAX_FLOAT_ITERS = 100;
166  int iters = 0;
167  while (iters++ < MAX_FLOAT_ITERS) {
168  double dividend = randomizer().inclusive(1, MAXINT32 / 2);
169  double divisor = randomizer().inclusive(1, MAXINT32 / 2);
170  double multiplier = randomizer().inclusive(1, MAXINT32 / 2);
171  double rand_float = (dividend / divisor) * multiplier;
172  if (randomizer().inclusive(0, 1) == 1)
173  rand_float = -1.0 * rand_float;
174  TRY_ON_F(double, rand_float, "third--loop");
175 //log(a_sprintf("%f", rand_float));
176  }
177  #undef TEST
178  }
179 
180  {
181  #define TEST "fourth"
182  // new test for char * packing.
183  const char *tunnel_vision = "plants can make good friends.";
184  const char *fresnel_lense = "chimney sweeps carry some soot.";
185  const char *snoopy = "small white dog with black spots.";
186  byte_array stored;
187  int fregose = 38861;
188  double perky_doodle = 3799.283e10;
189  const char *emptyish = "";
190  int jumboat = 998;
191  // now stuff the array with some things.
192  attach(stored, fregose);
193  attach(stored, tunnel_vision);
194  attach(stored, snoopy);
195  attach(stored, perky_doodle);
196  attach(stored, fresnel_lense);
197  attach(stored, emptyish);
198  attach(stored, jumboat);
199  // time to restore those contents.
200  astring tunnel_copy;
201  astring fresnel_copy;
202  astring snoopy_copy;
203  int freg_copy;
204  double perk_copy;
205  astring emp_copy;
206  int jum_copy;
207  ASSERT_TRUE(detach(stored, freg_copy),
208  GENERATE_TEST_NAME(TEST, "first int failed to unpack"));
209  ASSERT_TRUE(detach(stored, tunnel_copy),
210  GENERATE_TEST_NAME(TEST, "first string failed to unpack"));
211  ASSERT_TRUE(detach(stored, snoopy_copy),
212  GENERATE_TEST_NAME(TEST, "second string failed to unpack"));
213  ASSERT_TRUE(detach(stored, perk_copy),
214  GENERATE_TEST_NAME(TEST, "first double failed to unpack"));
215  ASSERT_TRUE(detach(stored, fresnel_copy),
216  GENERATE_TEST_NAME(TEST, "third string failed to unpack"));
217  ASSERT_TRUE(detach(stored, emp_copy),
218  GENERATE_TEST_NAME(TEST, "fourth string failed to unpack"));
219  ASSERT_TRUE(detach(stored, jum_copy),
220  GENERATE_TEST_NAME(TEST, "second int failed to unpack"));
221  // now test contents.
222  ASSERT_EQUAL(freg_copy, fregose,
223  GENERATE_TEST_NAME(TEST, "first int had wrong contents"));
224  ASSERT_EQUAL(tunnel_copy, astring(tunnel_vision),
225  GENERATE_TEST_NAME(TEST, "first string had wrong contents"));
226  ASSERT_EQUAL(snoopy_copy, astring(snoopy),
227  GENERATE_TEST_NAME(TEST, "second string had wrong contents"));
228  ASSERT_EQUAL(perk_copy, perky_doodle,
229  GENERATE_TEST_NAME(TEST, "first double had wrong contents"));
230  ASSERT_EQUAL(fresnel_copy, astring(fresnel_lense),
231  GENERATE_TEST_NAME(TEST, "third string had wrong contents"));
232  ASSERT_EQUAL(emp_copy, astring(emptyish),
233  GENERATE_TEST_NAME(TEST, "fourth string had wrong contents"));
234  ASSERT_EQUAL(jum_copy, jumboat,
235  GENERATE_TEST_NAME(TEST, "second int had wrong contents"));
236  ASSERT_FALSE(stored.length(),
237  GENERATE_TEST_NAME(TEST, "array still had contents after detaching"));
238  #undef TEST
239  }
240 
241 // critical_events::alert_message("packable:: works for those functions tested.");
242  return final_report();
243 }
244 
246 
247 HOOPLE_MAIN(test_object_packing, );
248 
byte_array.h
application::application_shell
The application_shell is a base object for console programs.
Definition: application_shell.h:33
basis::array::length
int length() const
Returns the current reported length of the allocated C array.
Definition: array.h:115
basis::astring
Provides a dynamically resizable ASCII character string.
Definition: astring.h:35
basis::byte_array
A very common template for a dynamic array of bytes.
Definition: byte_array.h:36
unit_test::unit_base
Definition: unit_base.h:59
critical_events.h
MINBYTE
#define MINBYTE
Minimum unsigned byte value.
Definition: definitions.h:103
MINCHAR
#define MINCHAR
Minimum byte-based character value.
Definition: definitions.h:95
MAXBYTE
#define MAXBYTE
Maximum unsigned byte value.
Definition: definitions.h:99
MAXINT16
#define MAXINT16
Maximum 32-bit integer value.
Definition: definitions.h:83
MAXCHAR
#define MAXCHAR
Maximum byte-based character value.
Definition: definitions.h:91
MAXINT32
#define MAXINT32
Maximum 32-bit integer value.
Definition: definitions.h:75
MININT16
#define MININT16
Minimum 32-bit integer value.
Definition: definitions.h:87
MININT32
#define MININT32
Minimum 32-bit integer value.
Definition: definitions.h:79
double_plus.h
DEFINE_CLASS_NAME
#define DEFINE_CLASS_NAME(objname)
Defines the name of a class by providing a couple standard methods.
Definition: enhance_cpp.h:45
FUNCDEF
#define FUNCDEF(func_in)
FUNCDEF sets the name of a function (and plugs it into the callstack).
Definition: enhance_cpp.h:57
hoople_main.h
Provides macros that implement the 'main' program of an application.
application
Implements an application lock to ensure only one is running at once.
Definition: application_shell.cpp:40
basis
The guards collection helps in testing preconditions and reporting errors.
Definition: array.h:30
basis::abyte
unsigned char abyte
A fairly important unit which is seldom defined...
Definition: definitions.h:51
basis::attach
void attach(byte_array &packed_form, const char *to_attach)
Packs a character string "to_attach" into "packed_form".
Definition: astring.cpp:1015
basis::un_int
unsigned int un_int
Abbreviated name for unsigned integers.
Definition: definitions.h:62
basis::detach
bool detach(byte_array &packed_form, astring &to_detach)
Unpacks a character string "to_attach" from "packed_form".
Definition: astring.cpp:1023
basis::un_short
unsigned short un_short
Abbreviated name for unsigned short integers.
Definition: definitions.h:64
loggers
A logger that sends to the console screen using the standard output device.
Definition: combo_logger.cpp:36
mathematics
An extension to floating point primitives providing approximate equality.
Definition: averager.h:21
structures
A dynamic container class that holds any kind of object via pointers.
Definition: amorph.h:55
unit_test
Useful support functions for unit testing, especially within hoople.
Definition: unit_base.cpp:35
static_memory_gremlin.h
randomizer
#define randomizer()
Definition: t_bin_threaded.cpp:98
GENERATE_TEST_NAME
#define GENERATE_TEST_NAME(group, message)
Definition: test_packing.cpp:33
TRY_ON_F
#define TRY_ON_F(type, value, group)
Definition: test_packing.cpp:62
TRY_ON
#define TRY_ON(type, value, group)
Definition: test_packing.cpp:36
HOOPLE_MAIN
HOOPLE_MAIN(test_object_packing,)
TEST
#define TEST
TRY_ON_OBSCURE
#define TRY_ON_OBSCURE(type, value, group)
Definition: test_packing.cpp:49
unit_base.h
ASSERT_EQUAL
#define ASSERT_EQUAL(a, b, test_name)
Definition: unit_base.h:38
ASSERT_TRUE
#define ASSERT_TRUE(a, test_name)
Definition: unit_base.h:46
ASSERT_FALSE
#define ASSERT_FALSE(a, test_name)
Definition: unit_base.h:50