sstr_02.cc

这是一个从音频信号里提取特征参量的程序

// file: $isip/class/system/SysString/sstr_02.cc
// version: $Id: sstr_02.cc,v 1.26 2002/07/29 15:05:46 zheng Exp $
//

// system include files:
//  note that we need some basic string functions. these are not included
//  in Integral.h since users are not expected to use these functions.
//
#include <strings.h>
//#include <widec.h>

// isip include files
//
#include "SysString.h"
#include <Console.h>

// method: diagnose
//
// arguments:
//  Integral::DEBUG level: (input) debug level for diagnostics
//
// return: a boolean value indicating status
//
boolean SysString::diagnose(Integral::DEBUG level_a) {

  //---------------------------------------------------------------------------
  //
  // 0. preliminaries
  //
  //---------------------------------------------------------------------------

  // output the class name
  //
  if (level_a > Integral::NONE) {
    SysString output(L"diagnosing class ");
    output.concat(CLASS_NAME);
    output.concat(L": ");
    Console::put(output);
    Console::increaseIndention();
  }
  
  //--------------------------------------------------------------------------
  //
  // 1. required public methods
  //
  //--------------------------------------------------------------------------

  // set indentation
  //
  if (level_a > Integral::NONE) {
    Console::put(L"testing required public methods...\n");
    Console::increaseIndention();
  }

  // do a quick test of constructors and destructors
  //
  SysString* ptr0, *ptr1, *ptr2, *ptr3;
  ptr0 = new SysString((byte*)"hello my name is");
  ptr1 = new SysString(L"rick");
  ptr2 = new SysString(100);
  ptr3 = new SysString(*ptr1);
  
  delete ptr0;
  delete ptr1;
  delete ptr2;
  delete ptr3;

  // constructors
  //
  SysString str1((byte*)"hello my name is");
  SysString str2(L"rjck");
  SysString str3(100);
  SysString str4(str2);

  // check setDebug method
  //
  setDebug(debug_level_d);
  
  if (level_a > Integral::BRIEF) {
    str1.debug(L"str1");
  }
  if (level_a > Integral::BRIEF) {
    str2.debug(L"str2");
  }
  if (level_a > Integral::BRIEF) {
    str3.debug(L"str3");
  }
  if (level_a > Integral::BRIEF) {
    str4.debug(L"str4");
  }

  // test operator= methods
  //
  SysString sstr_old(L"old");
  SysString sstr_new(L"new");

  sstr_old = sstr_new;
  
  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
  
  //---------------------------------------------------------------------------
  //
  // 2. class-specific public methods:
  //     extensions to required methods     
  //
  //---------------------------------------------------------------------------

  // set indentation
  //
  if (level_a > Integral::NONE) {
    Console::put(L"testing class-specific public methods: extensions to required methods...\n");
    Console::increaseIndention();
  }

  // test assign methods
  //
  SysChar chr(L'h');
  str3.assign(chr);

  if ((str3.value_d[0] != L'h') || (str3.length() != 1)) {
    Error::handle(name(), L"assign SysChar", Error::TEST, __FILE__, __LINE__);
  }

  str3.assign(L'h');
  if ((str3.value_d[0] != L'h') || (str3.length() != 1)) {
    Error::handle(name(), L"assign SysChar", Error::TEST, __FILE__, __LINE__);
  }

  str3.assign(str2);
  if (str3.ne(str2)) {
    Error::handle(name(), L"re-assign unichar", Error::TEST,
                  __FILE__, __LINE__);
  }
  
  str2.assign(L" Rick");
  if (str2.length() != 5) {
    Error::handle(name(), L"re-assign unichar", Error::TEST,
                  __FILE__, __LINE__);
  }
  
  str4.assign((byte*)"new byte* text");
  if (str4.ne(L"new byte* text")) {
    Error::handle(name(), L"re-assign byte", Error::TEST, __FILE__, __LINE__);
  }
  
  // make sure that an empty string fails
  //
  SysString num;
  long i;
  if (num.get(i)) {
    return Error::handle(name(), L"get", Error::TEST, __FILE__, __LINE__);
  }

  // make sure that non numeric types fail for get
  //
  num.assign(L"abc");
  if (num.get(i)) {
    return Error::handle(name(), L"get", Error::TEST, __FILE__, __LINE__);
  }

  // make sure that strings greater than length 1 fail for a get on SysChar
  //
  SysChar tmp_char;
  if (num.get(tmp_char)) {
    return Error::handle(name(), L"get", Error::TEST, __FILE__, __LINE__);
  }

  // setup temporary variables
  //
  byte dbyte = (long)27;
  byte dbyte_v;

  short dshort = (long)27;
  short dshort_v;

  long dlong = (long)277;
  long dlong_v;
  
  llong dllong = (llong)13020756033LL;
  llong dllong_v;
  
  ushort dushort = (ushort)6907;
  ushort dushort_v;
  
  ulong dulong = (ulong)2777;
  ulong dulong_v;
  
  ullong dullong = (ullong)1302075603332LL;
  ullong dullong_v;

  float dfloat = (float)27.27e-19;
  float dfloat_v;
  
  double ddouble = (double)272727272727.272727e+20;
  double ddouble_v;

  boolean dboolean = true;
  boolean dboolean_v;
  
  void* dvoidp = (void*)27;
  void* dvoidp_v;

  // test the byte conversions
  //
  num.assign(dbyte);
  num.get(dbyte_v);

  if (dbyte != dbyte_v) {
    Error::handle(name(), L"assign(byte)", Error::TEST, __FILE__, __LINE__);
  }

  num.assign(dbyte, L"asdf = %u xyz");
  if (num.ne(L"asdf = 27 xyz")) {
    Error::handle(name(), L"assign(byte)", Error::TEST, __FILE__, __LINE__);
  }
  
  // test the short conversions
  //
  num.assign(dshort);
  num.get(dshort_v);

  if (dshort != dshort_v) {
    Error::handle(name(), L"assign(short)", Error::TEST, __FILE__, __LINE__);
  }

  num.assign(dshort, L"asdf = %d xyz");
  if (num.ne(L"asdf = 27 xyz")) {
    Error::handle(name(), L"assign(short)", Error::TEST, __FILE__, __LINE__);
  }
  
  // test the long conversions
  //
  num.assign(dlong);
  num.get(dlong_v);

  if (dlong != dlong_v) {
    Error::handle(name(), L"assign(long)", Error::TEST, __FILE__, __LINE__);
  }

  num.assign(dlong, L"asdf = %ld xyz");
  if (num.ne(L"asdf = 277 xyz")) {
    Error::handle(name(), L"assign(long)", Error::TEST, __FILE__, __LINE__);
  }

  // test the llong conversions
  //
  num.assign(dllong);
  num.get(dllong_v);
  
  if (dllong != dllong_v) {
    Error::handle(name(), L"assign(llong)", Error::TEST, __FILE__, __LINE__);
  }
  
  num.assign(dllong, L"asdf = %lld xyz");
  if (num.ne(L"asdf = 13020756033 xyz")) {
    Error::handle(name(), L"assign(llong)", Error::TEST, __FILE__, __LINE__);
  }

  // test the ushort conversions
  //
  num.assign(dushort);
  num.get(dushort_v);
  
  if (dushort != dushort_v) {
    Error::handle(name(), L"assign(ushort)", Error::TEST, __FILE__, __LINE__);
  }

  num.assign(dushort, L"asdf = %lu xyz");
  if (num.ne(L"asdf = 6907 xyz")) {
    Error::handle(name(), L"assign(ushort)", Error::TEST, __FILE__, __LINE__);
  }

  // test the ulong conversions
  //
  num.assign(dulong);
  num.get(dulong_v);

  if (dulong != dulong_v) {
    Error::handle(name(), L"assign(ulong)", Error::TEST, __FILE__, __LINE__);
  }

  num.assign(dulong, L"asdf = %lu xyz");
  if (num.ne(L"asdf = 2777 xyz")) {
    Error::handle(name(), L"assign(ulong)", Error::TEST, __FILE__, __LINE__);
  }

  // test the ullong conversions
  //
  num.assign(dullong);
  num.get(dullong_v);

  if (dullong != dullong_v) {
    Error::handle(name(), L"assign(ullong)", Error::TEST, __FILE__, __LINE__);
  }

  num.assign(dullong, L"asdf = %llu xyz");
  if (num.ne(L"asdf = 1302075603332 xyz")) {
    num.debug(L"");
    Error::handle(name(), L"assign(long)", Error::TEST, __FILE__, __LINE__);
  }

  // test the float conversions
  //
  num.assign(dfloat);
  num.get(dfloat_v);

  if (level_a > Integral::ALL) {
    num.debug(L"float");
  }
  
  if (!Integral::almostEqual(dfloat, dfloat_v)) {
    fprintf(stdout, "%f != %f != '%s'\n", dfloat, dfloat_v, (char*)(byte*)num);
    Error::handle(name(), L"assign(float)", Error::TEST, __FILE__, __LINE__);
  }

  num.assign(dfloat, L"asdf = %e xyz");
  if (num.ne(L"asdf = 2.727000e-18 xyz")) {
    Error::handle(name(), L"assign(float)", Error::TEST, __FILE__, __LINE__);
  }

  // test the double conversions
  //
  num.assign(ddouble);
  num.get(ddouble_v);

  if (level_a > Integral::ALL) {
    num.debug(L"double");
  }
  
  if (!Integral::almostEqual(ddouble, ddouble_v)) {
    fprintf(stdout, "%f != %f != '%s'\n", ddouble, ddouble_v,
            (char*)(byte*)num);
    Error::handle(name(), L"assign(double)", Error::TEST, __FILE__, __LINE__);
  }

  num.assign(ddouble, L"asdf = %e xyz");
  if (num.ne(L"asdf = 2.727273e+31 xyz")) {
    Error::handle(name(), L"assign(double)", Error::TEST, __FILE__, __LINE__);
  }

  // test the boolean conversions
  //
  num.assign(dboolean);
  num.get(dboolean_v);

  if (dboolean != dboolean_v) {
    Error::handle(name(), L"assign(boolean)", Error::TEST, __FILE__, __LINE__);
  }

  num.assign(dboolean, L"asdf = %s xyz");
  if (num.ne(L"asdf = true xyz")) {
    Error::handle(name(), L"assign(boolean)", Error::TEST, __FILE__,
		  __LINE__);
  }
  
  // test the pointer conversions
  //
  num.assign(dvoidp);
  num.get(dvoidp_v);

  if (dvoidp != dvoidp_v) {
    Error::handle(name(), L"assign(void*)", Error::TEST, __FILE__, __LINE__);
  }

  dvoidp = NULL;
  num.assign(dvoidp);
  num.get(dvoidp_v);

  if (dvoidp != dvoidp_v) {
    Error::handle(name(), L"assign(void*)", Error::TEST, __FILE__, __LINE__);
  }
  
  // pointers are printed differently on different platforms so we generate
  // a reference string rather than assuming one. The functions used to do 
  // this have been tested above this point.
  //
  SysString voidp_tmp1(L"asdf = ");
  SysString voidp_tmp2;
  voidp_tmp2.assign((void*)NULL);
  SysString voidp_tmp3(L" xyz");
  SysString voidp_ref(voidp_tmp1);
  voidp_ref.concat(voidp_tmp2);
  voidp_ref.concat(voidp_tmp3);

  num.assign(dvoidp, L"asdf = %p xyz");
  if (num.ne(voidp_ref)) {
    voidp_ref.debug(L"reference");
    num.debug(L"num");
    Error::handle(name(), L"assign(voidp)", Error::TEST, __FILE__,
		  __LINE__);
  }

  voidp_tmp2.assign((void*)0x8192);
  voidp_ref.assign(voidp_tmp1);
  voidp_ref.concat(voidp_tmp2);
  voidp_ref.concat(voidp_tmp3);

  num.assign((void*)0x8192, L"asdf = %p xyz");
  if (num.ne(voidp_ref)){
    voidp_ref.debug(L"reference");
    num.debug(L"num");
    Error::handle(name(), L"assign(voidp)", Error::TEST, __FILE__,
		  __LINE__);
  }

  Error::set(Error::NONE);
  
  // test complex assign & such
  //
  SysComplex<float> dcfloat(3, 2);	// number in quadrant I
  num.assign(dcfloat);
  SysComplex<float> dcfloat_v;
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }

  dcfloat = SysComplex<float>(3, -2);	// number in quadrant IV
  num.assign(dcfloat);
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }

  num.assign(dcfloat, L"asdf = %s xyz");
  if (num.ne(L"asdf = 3-2j xyz")) {
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__,
		  __LINE__);
  }

  dcfloat = SysComplex<float>(-23,-24);	// number in quadrant III
  num.assign(dcfloat);
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }

  dcfloat = SysComplex<float>(-23,24);	// number in quadrant II
  num.assign(dcfloat);
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }

  dcfloat = SysComplex<float>(23,0);	// number on positive X axis
  num.assign(dcfloat);
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }

  dcfloat = SysComplex<float>(-23,0);	// number on negative X axis
  num.assign(dcfloat);
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }

  dcfloat = SysComplex<float>(0, 23);	// number on positive Y axis
  num.assign(dcfloat);
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }

  dcfloat = SysComplex<float>(0, -23);	// number on negative Y axis
  num.assign(dcfloat);
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }

  dcfloat = SysComplex<float>(0, -1);	// -j
  num.assign(L"-j");
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }

  dcfloat = SysComplex<float>(0, 1);	// j
  num.assign(L"j");
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }

  dcfloat = SysComplex<float>(2, 1);	// 2+j
  num.assign(L"2+j");
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }

  dcfloat = SysComplex<float>(3, -1);	// 3-j
  num.assign(L"3 - j");
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }
  
  // test assign enum type data
  //
  SysString str6(str1);
  str6.assign(Integral::DETAILED);
  if (str6.ne(DBG_DETAILED)) {
    str6.debug(L"str6");
    Error::handle(name(), L"assign(Integral::DEBUG arg)",
                  Error::TEST, __FILE__, __LINE__);
  }

  str6.assign(Integral::EQUAL);
  if (str6.ne(CMP_EQUAL)) {
    str6.debug(L"str6");
    Error::handle(name(), L"assign(Integral::COMPARE arg)",
                  Error::TEST, __FILE__, __LINE__);
  }
    
  str6.assign(File::READ_PLUS);
  if (str6.ne(MODE_READ_PLUS)) {
    Error::handle(name(), L"assign(File::arg)",
                  Error::TEST, __FILE__, __LINE__);
  }
  
  str6.assign(SysChar::ENCODE_ASCII);
  if (str6.ne(ENCODE_ASCII)) {
    Error::handle(name(), L"assign(SysChar::ENCODE arg)",
                  Error::TEST, __FILE__, __LINE__);
  }

  str6.assign(File::BIG_ENDIAN);
  if (str6.ne(BMODE_BIG_ENDIAN)) {
    Error::handle(name(), L"assign(File::BMODE arg)",
                  Error::TEST, __FILE__, __LINE__);
  }

  // test formated strings
  //
  str2.assign(L"qwer", L"asdf %20s xyz");
  if (str2.ne(L"asdf                 qwer xyz")) {
    return Error::handle(name(), L"assign", Error::TEST, __FILE__, __LINE__);
  }

  // test formated chars
  //
  str2.assign(L'a', L"asdf %20c xyz");
  if (str2.ne(L"asdf                    a xyz")) {
    return Error::handle(name(), L"assign", Error::TEST, __FILE__, __LINE__);
  }

  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
  
  //---------------------------------------------------------------------------
  //
  // 3. class-specific public methods: