octopi/library/tests_octopus/t_unpacker.cpp

   1 /*****************************************************************************\
   2 *                                                                             *
   3 *  Name   : unpacking octopus test                                            *
   4 *  Author : Chris Koeritz                                                     *
   5 *                                                                             *
   6 *  Purpose:                                                                   *
   7 *                                                                             *
   8 *    A test of octopuses used for unpacking flat structures.                  *
   9 *                                                                             *
  10 *******************************************************************************
  11 * Copyright (c) 2002-$now By Author.  This program is free software; you can  *
  12 * redistribute it and/or modify it under the terms of the GNU General Public  *
  13 * License as published by the Free Software Foundation; either version 2 of   *
  14 * the License or (at your option) any later version.  This is online at:      *
  15 *     http://www.fsf.org/copyleft/gpl.html                                    *
  16 * Please send any updates to: fred@gruntose.com                               *
  17 \*****************************************************************************/
  18
  19 #include <basis/astring.h>
  20 #include <structures/static_memory_gremlin.h>
  21 #include <octopus/entity_defs.h>
  22 #include <octopus/infoton.h>
  23 #include <octopus/octopus.h>
  24 #include <octopus/tentacle_helper.h>
  25 #include <application/application_shell.h>
  26 #include <loggers/console_logger.h>
  27 #include <loggers/file_logger.h>
  28 #include <structures/static_memory_gremlin.h>
  29 #include <sockets/internet_address.h>
  30
  31 //hmmm: provide equality ops to be able to check that same stuff
  32 //      came back out that went in.
  33
  34 class test_unpacker : public application_shell
  35 {
  36 public:
  37   test_unpacker() : application_shell(class_name()) {}
  38   DEFINE_CLASS_NAME("test_unpacker");
  39   virtual int execute();
  40   void test_unpacking();
  41 };
  42
  43 //////////////
  44
  45 // the infotons here have a three level classifier.  the outer level is
  46 // for the benefit of the handler_arm tentacle that just checks that the
  47 // group name is correct before passing off the request to its internal
  48 // octopus.  then the second level specifies which class of infotons are
  49 // being managed.  the third level specifies the leaf type of the infoton--
  50 // the specific type of data being wrapped.
  51
  52 const char *base_list[] = { "gruntiak" };
  53
  54 SAFE_STATIC_CONST(string_array, base_classifier, (1, base_list))
  55
  56 const char *math_list[] = { "math" };
  57
  58 SAFE_STATIC_CONST(string_array, math_classifier, (base_classifier()
  59     + string_array(1, math_list)))
  60
  61 const char *addr_list[] = { "address" };
  62
  63 SAFE_STATIC_CONST(string_array, addr_classifier, (base_classifier()
  64     + string_array(1, addr_list)))
  65
  66 class address_ton : public infoton, public network_address
  67 {
  68 public:
  69   address_ton() : infoton(addr_classifier() + "leaf") {}
  70
  71   virtual void pack(byte_array &packed_form) const {
  72     network_address::pack(packed_form);
  73   }
  74
  75   virtual bool unpack(byte_array &packed_form) {
  76     return network_address::unpack(packed_form);
  77   }
  78
  79   virtual int packed_size() const {
  80     return 5 * sizeof(int) + 128 /*address estimate*/;
  81   }
  82
  83   virtual clonable *clone() const {
  84     return new address_ton(*this);
  85   }
  86 };
  87
  88 //some floating point nums.
  89 class float_ton : public infoton
  90 {
  91 public:
  92   float f1;
  93   double d1;
  94
  95   float_ton() : infoton(math_classifier() + "float") {}
  96
  97   virtual void pack(byte_array &packed_form) const {
  98     structures::attach(packed_form, f1);
  99     structures::attach(packed_form, d1);
 100   }
 101
 102   virtual int packed_size() const {
 103     return sizeof(double) + sizeof(float);
 104   }
 105
 106   virtual bool unpack(byte_array &packed_form) {
 107     double hold;
 108     if (!structures::detach(packed_form, hold)) return false;
 109     f1 = float(hold);
 110     if (!structures::detach(packed_form, d1)) return false;
 111     return true;
 112   }
 113
 114   virtual clonable *clone() const {
 115     return new float_ton(*this);
 116   }
 117 };
 118
 119 //an integer set.
 120 class int_set_ton : public infoton
 121 {
 122 public:
 123   int_set nums;
 124
 125   int_set_ton() : infoton(math_classifier() + "intset") {}
 126
 127   virtual void pack(byte_array &packed_form) const {
 128     structures::attach(packed_form, nums.elements());
 129     for (int i = 0; i < nums.elements(); i++)
 130       structures::attach(packed_form, nums[i]);
 131   }
 132
 133   virtual int packed_size() const {
 134     return sizeof(int) + nums.elements() * sizeof(int);
 135   }
 136
 137   virtual bool unpack(byte_array &packed_form) {
 138     int len = 0;
 139     nums.reset();
 140     if (!structures::detach(packed_form, len)) return false;
 141     for (int i = 0; i < len; i++) {
 142       int got = 0;
 143       if (!structures::detach(packed_form, got)) return false;
 144       nums += got;
 145     }
 146     return true;
 147   }
 148
 149   virtual clonable *clone() const {
 150     return new int_set_ton(*this);
 151   }
 152 };
 153
 154 //////////////
 155
 156 // handles network addresses.
 157 class address_chomper : public tentacle_helper<address_ton>
 158 {
 159 public:
 160   address_chomper()
 161   : tentacle_helper<address_ton>(addr_classifier().subarray(1, 1), true) {}
 162 };
 163
 164 // handles floats and int_sets.
 165 class numerical_chomper : public tentacle
 166 {
 167 public:
 168   numerical_chomper() : tentacle(math_classifier().subarray(1, 1), true) {}
 169
 170   outcome reconstitute(const string_array &classifier, byte_array &packed_form,
 171       infoton * &reformed)
 172   {
 173     reformed = NULL_POINTER;
 174     if (classifier.length() < 2) return BAD_INPUT;
 175     astring key = classifier[1];
 176     if (key == "float") {
 177       float_ton *to_return = new float_ton;
 178       if (!to_return->unpack(packed_form)) {
 179         WHACK(to_return);
 180         return NULL_POINTER;
 181       }
 182       reformed = to_return;
 183       return OKAY;
 184     } else if (key == "intset") {
 185       int_set_ton *to_return = new int_set_ton;
 186       if (!to_return->unpack(packed_form)) {
 187         WHACK(to_return);
 188         return NULL_POINTER;
 189       }
 190       reformed = to_return;
 191       return OKAY;
 192     } else
 193       return NO_HANDLER;
 194   }
 195
 196   outcome consume(infoton &formal(to_chow), const octopus_request_id &formal(item_id),
 197           byte_array &transformed)
 198   { transformed.reset(); return tentacle::BAD_INPUT; }
 199
 200   virtual void expunge(const octopus_entity &formal(zapola)) {}
 201 };
 202
 203 //////////////
 204
 205 // delegates the unpacking to an internal tentacle.  it peels off a level
 206 // of classifier to find the real handler.
 207 class outer_arm : public tentacle
 208 {
 209 public:
 210   outer_arm()
 211   : tentacle(base_classifier(), true),
 212     _unpackers("local", 10 * MEGABYTE),
 213     _numer(new numerical_chomper),
 214     _addron(new address_chomper)
 215   {
 216     // register the two tentacles.
 217     outcome ret = _unpackers.add_tentacle(_numer);
 218     if (ret != tentacle::OKAY)
 219       deadly_error(class_name(), "adding numerical tentacle",
 220           astring("failed to add: ") + tentacle::outcome_name(ret));
 221     ret = _unpackers.add_tentacle(_addron);
 222     if (ret != tentacle::OKAY)
 223       deadly_error(class_name(), "adding address tentacle",
 224           astring("failed to add: ") + tentacle::outcome_name(ret));
 225   }
 226
 227   ~outer_arm() {
 228     // just reset the two tentacles, since the _unpackers octopus should
 229     // clean them up.
 230     _numer = NULL_POINTER;
 231     _addron = NULL_POINTER;
 232   }
 233
 234   outcome reconstitute(const string_array &classifier, byte_array &packed_form,
 235       infoton * &reformed)
 236   {
 237     // strip first word of classifier.
 238     string_array real_class = classifier;
 239     real_class.zap(0, 0);
 240     // route to octopus.
 241     return _unpackers.restore(real_class, packed_form, reformed);
 242   }
 243
 244   outcome consume(infoton &to_chow, const octopus_request_id &item_id,
 245           byte_array &transformed)
 246   {
 247     transformed.reset();
 248     // strip first word of classifier.
 249     string_array real_class = to_chow.classifier();
 250     real_class.zap(0, 0);
 251     to_chow.set_classifier(real_class);
 252     // route to octopus.
 253     return _unpackers.evaluate((infoton *)to_chow.clone(), item_id);
 254   }
 255
 256   void expunge(const octopus_entity &formal(whackola)) {}
 257
 258 private:
 259   octopus _unpackers;
 260   numerical_chomper *_numer;
 261   address_chomper *_addron;
 262 };
 263
 264 //////////////
 265
 266 void test_unpacker::test_unpacking()
 267 {
 268   octopus unpacky("local", 10 * MEGABYTE);
 269   outer_arm *outer = new outer_arm;
 270   outcome ret = unpacky.add_tentacle(outer);
 271   if (ret != tentacle::OKAY)
 272     deadly_error(class_name(), "adding outer tentacle",
 273         astring("failed to add: ") + tentacle::outcome_name(ret));
 274
 275   // test infoton fast packing.
 276   int_set_ton jubjub;
 277   jubjub.nums.add(299);
 278   jubjub.nums.add(39274);
 279   jubjub.nums.add(25182);
 280   byte_array packed(10388);  // have data in there to start.
 281   infoton::fast_pack(packed, jubjub);
 282   if (jubjub.packed_size() + infoton::fast_pack_overhead(jubjub.classifier())
 283       != packed.length() - 10388)
 284     deadly_error(class_name(), "packing test",
 285         astring("erroneous size calculated for first fast_pack"));
 286   string_array shirley_class;
 287   byte_array shirley_data;
 288   packed.zap(0, 10387);  // remove the original data.
 289
 290   // testing the overhead calculation.
 291   byte_array junk_jub;
 292   jubjub.pack(junk_jub);
 293   if (packed.length() != junk_jub.length()
 294       + infoton::fast_pack_overhead(jubjub.classifier()))
 295     deadly_error(class_name(), "test fast pack overhead",
 296         "sizes differed from calculated");
 297
 298   if (!infoton::fast_unpack(packed, shirley_class, shirley_data))
 299     deadly_error(class_name(), "test infoton fast pack",
 300         "failed shirley unpack");
 301   if (packed.length() != 0)
 302     deadly_error(class_name(), "test infoton fast pack",
 303         "shirley didn't consume all");
 304   if (shirley_class != jubjub.classifier())
 305     deadly_error(class_name(), "test infoton fast pack",
 306         "inequal orig classifier");
 307   int_set_ton scroop;
 308   if (!scroop.unpack(shirley_data))
 309     deadly_error(class_name(), "test infoton fast pack",
 310         "failed scroop unpack");
 311   if (shirley_data.length())
 312     deadly_error(class_name(), "test infoton fast pack",
 313         "scroop didn't consume all");
 314   if (scroop.nums.length() != 3)
 315     deadly_error(class_name(), "test infoton fast pack",
 316         "wrong length in scroop");
 317   if ( (scroop.nums[0] != jubjub.nums[0]) || (scroop.nums[1] != jubjub.nums[1])
 318       || (scroop.nums[2] != jubjub.nums[2]) )
 319     deadly_error(class_name(), "test infoton fast pack",
 320         "erroneous information");
 321
 322   byte_array fasting;
 323   infoton::fast_pack(fasting, jubjub);
 324   if (jubjub.packed_size() + infoton::fast_pack_overhead(jubjub.classifier())
 325       != fasting.length())
 326     deadly_error(class_name(), "packing test",
 327         astring("erroneous size calculated for second fast_pack"));
 328
 329   // another test of the overhead calculator.
 330   byte_array junk_fast;
 331   jubjub.pack(junk_fast);
 332   if (fasting.length() != junk_fast.length()
 333       + infoton::fast_pack_overhead(jubjub.classifier()))
 334     deadly_error(class_name(), "test fast pack overhead 2",
 335         "sizes differed from calculated");
 336
 337   string_array nudge_class;
 338   byte_array nudge_data;
 339   if (!infoton::fast_unpack(fasting, nudge_class, nudge_data))
 340     deadly_error(class_name(), "test infoton fast pack", "fast pack failed to unpack");
 341   if (fasting.length())
 342     deadly_error(class_name(), "test infoton fast pack", "fast pack didn't consume all");
 343   int_set_ton croup;
 344   if (!croup.unpack(nudge_data))
 345     deadly_error(class_name(), "test infoton fast pack", "croup wouldn't unpack");
 346   if ( (croup.nums[0] != jubjub.nums[0]) || (croup.nums[1] != jubjub.nums[1])
 347       || (croup.nums[2] != jubjub.nums[2]) )
 348     deadly_error(class_name(), "test infoton fast pack", "croup has errors");
 349   byte_array chunkmo;
 350   chunkmo += 0x23;
 351   chunkmo += 0xf8;
 352   chunkmo += 0x37;
 353   chunkmo += 0x65;
 354   address_ton norf;
 355   (network_address &)norf = network_address(internet_address
 356       (chunkmo, "urp", 23841));
 357   chunkmo.reset();
 358   infoton::fast_pack(chunkmo, norf);
 359   string_array clarfiator;
 360   byte_array pacula;
 361   if (!infoton::fast_unpack(chunkmo, clarfiator, pacula))
 362     deadly_error(class_name(), "test fast_unpack", "chunkmo has errors");
 363   infoton *scrung = NULL_POINTER;
 364 //log(astring("classif is ") + clarfiator.text_form());
 365
 366   outcome scrung_ret = unpacky.restore(clarfiator, pacula, scrung);
 367   if (scrung_ret != tentacle::OKAY)
 368     deadly_error(class_name(), "test fast_unpack",
 369         a_sprintf("can't restore scrung: %s",
 370             tentacle::outcome_name(scrung_ret)));
 371   address_ton *rescrung = dynamic_cast<address_ton *>(scrung);
 372   if (!rescrung)
 373     deadly_error(class_name(), "test fast_unpack", "wrong dynamic type for scrung");
 374   address_ton &prescrung = *rescrung;
 375   if ((network_address &)prescrung != (network_address &)norf)
 376     deadly_error(class_name(), "test fast_unpack", "wrong network address restored");
 377   WHACK(scrung);
 378 }
 379
 380 const int MAXIMUM_TESTS = 10;
 381   // was added to check for memory leaks.
 382
 383 int test_unpacker::execute()
 384 {
 385   int iters = 0;
 386   while (iters++ < MAXIMUM_TESTS) {
 387 //log(a_sprintf("iter #%d", iters));
 388     test_unpacking();
 389   }
 390   log("unpacking octopus:: works for all functions tested.");
 391 //time_control::sleep_ms(30000);
 392   return 0;
 393 }
 394
 395 HOOPLE_MAIN(test_unpacker, )
 396