t_byte_format.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_text_dump                                                    *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Puts the byte formatting utilities through their paces.                  *
*                                                                             *
*******************************************************************************
* Copyright (c) 1992-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
\*****************************************************************************/

#include <basis/byte_array.h>
#include <basis/chaos.h>
#include <basis/function.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <basis/packable.h>
#include <opsystem/application_shell.h>
#include <data_struct/static_memory_gremlin.h>
#include <textual/byte_format.h>

HOOPLE_STARTUP_CODE;

class test_text_dump : public application_shell
{
public:
  test_text_dump();
  IMPLEMENT_CLASS_NAME("test_text_dump");
  int execute();
};

test_text_dump::test_text_dump() : application_shell("t_textdump")
{}

int test_text_dump::execute()
{
  FUNCDEF("execute");
  {
    // test out the byte shifting functions on a simple known array.
    byte_array source;
    source += 0x23; source += 0x5f; source += 0xa8; source += 0x2d; 
    source += 0xe2; source += 0x61; source += 0x90; source += 0x2d; 
    source += 0xf2; source += 0x38; 
    istring shifty;
    byte_format::bytes_to_shifted_string(source, shifty);
//    log(isprintf("A: shifted our %d bytes into: ", source.length())
//        + shifty);
    byte_array source_copy;
    byte_format::shifted_string_to_bytes(shifty, source_copy);
    if (source_copy != source) {
      deadly_error(class_name(), func, "A: shifting corrupted the bytes.");
    }
  }

  {
    // test out the byte shifting functions on a random array.
    for (int run = 0; run < 100; run++) {
      byte_array source;
      int size = randomizer().inclusive(1, 20923);
      for (int i = 0; i < size; i++) {
        source += byte(randomizer().inclusive(0, 255));
      }
      istring shifty;
      byte_format::bytes_to_shifted_string(source, shifty);
//      log(isprintf("B: shifted our %d bytes into: ", source.length())
//          + shifty);
      byte_array source_copy;
      byte_format::shifted_string_to_bytes(shifty, source_copy);
      if (source_copy != source) {
        deadly_error(class_name(), func, "B: shifting corrupted the bytes.");
      }
    }
  }

  {
    istring burf("alia bodalia petunia");
    istring dump(byte_format::text_dump((byte *)burf.s(), burf.length() + 1));
//doofus!  make this compare the output with expectations.
    log("dumped form is:");
    log("");
    log(dump);
  }
  {
    byte fodder[] = { 0x83, 0x0d, 0x93, 0x21, 0x82, 0xfe, 0xef, 0xdc, 0xb9,
        0xa9, 0x21, 0x54, 0x83, 0x38, 0x65, 0x59, 0x99, 0xff, 0x00, 0xa0,
        0x29, 0x03 };
    byte_array fred(sizeof(fodder), fodder);
    istring as_text1;
    byte_format::bytes_to_string(fred, as_text1, true);
    log(istring("got string #1 of: ") + as_text1);
    istring as_text2;
    byte_format::bytes_to_string(fred, as_text2, false);
    log(istring("got string #2 of: ") + as_text2);
    byte_array convert1;
    byte_format::string_to_bytes(as_text1, convert1);
    byte_array convert2;
    byte_format::string_to_bytes(as_text2, convert2);
    if (fred != convert1)
      deadly_error("test_byte_formatters", "first byte conversion",
          "failed due to inequality");
    if ( ! (fred == convert2))
      deadly_error("test_byte_formatters", "second byte conversion",
          "failed due to inequality");
    // now a harder test.
    istring as_text3("muggulo x83d x93, x21, x82, xfe, xef, xdc, xb9, "
        "xa9, x21, x54, x83, x38, x65, x59, x99, xff, x00a0, x293");
    byte_array harder_convert1;
    byte_format::string_to_bytes(as_text3, harder_convert1);
istring back3;
byte_format::bytes_to_string(harder_convert1, back3);
log(istring("got third: ") + back3);

    istring as_text4("muggulo x83d x93, x21, x82, xfe, xef, xdc, xb9, "
        "xa9, x21, x54, x83, x38, x65, x59, x99, xff, x00a0, x293gikkor");
    byte_array harder_convert2;
    byte_format::string_to_bytes(as_text4, harder_convert2);
istring back4;
byte_format::bytes_to_string(harder_convert2, back4);
log(istring("got fourth: ") + back4);
    if (fred != harder_convert1)
      deadly_error("test_byte_formatters", "third byte conversion",
          "failed due to inequality");
    if (fred != harder_convert2)
      deadly_error("test_byte_formatters", "fourth byte conversion",
          "failed due to inequality");

    byte fodder2[] = {
0x04, 0x00, 0x06, 0x00, 0x0a, 0x02, 0x03, 0x00, 0x06, 0x00, 0x48, 0x01, 0x1c, 0x00, 0x2c, 0x00, 0x04, 0x00, 0x09, 0x00, 0x17, 0x00, 0xff, 0xff, 0x00, 0x00,
0x00, 0x00, 0x09, 0x00 };
    fred = byte_array(sizeof(fodder2), fodder2);
    istring as_text5("040006000a020300060048011c002c00040009001700ffff000000000900");
    byte_array harder_convert3;
    byte_format::string_to_bytes(as_text5, harder_convert3);
istring back5;
byte_format::bytes_to_string(harder_convert3, back5);
log(istring("got fifth: ") + back5);
    if (fred != harder_convert3)
      deadly_error("test_byte_formatters", "fifth byte conversion",
          "failed due to inequality");

#ifndef EMBEDDED_BUILD
    // now a test of parse_dump.
    istring fred_dump;
    byte_format::text_dump(fred_dump, fred, 0x993834);
log("fred dump...");
log(fred_dump);
    byte_array fred_like;
    byte_format::parse_dump(fred_dump, fred_like);
    if (fred != fred_like)
      deadly_error("test_byte_formatters", "parse_dump test",
          "failed due to inequality");
#endif
  }
  {
    // an endian tester.
    u_short test1 = 0x3c5f;
    log("0x3c5f in intel:");
    log(byte_format::text_dump((byte *)&test1, 2));
    u_int test2 = 0x9eaad0cb;
    log("0x9eaad0cb in intel:");
    log(byte_format::text_dump((byte *)&test2, 4));

    // now see what they look like as packables.
    byte_array testa;
    basis::attach(testa, test1);
    log("0x3c5f in package:");
    log(byte_format::text_dump(testa));
    byte_array testb;
    basis::attach(testb, test2);
    log("0x9eaad0cb in package:");
    log(byte_format::text_dump(testb));
  }

  guards::alert_message("byte_formatters:: work for those functions tested.");
  return 0;
}

int main()
{
  test_text_dump to_test;
  return to_test.execute();
}

---