sstr_02.cc

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

  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.clear();
  num.concat(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.clear();
  num.concat(dboolean);
  num.get(dboolean_v);

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

  num.clear();
  num.concat(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.clear();
  num.concat(dvoidp);
  num.get(dvoidp_v);

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

  dvoidp = NULL;
  num.clear();
  num.concat(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.
  //
  voidp_tmp2.assign((void*)NULL);
  voidp_ref.assign(voidp_tmp1);
  voidp_ref.concat(voidp_tmp2);
  voidp_ref.concat(voidp_tmp3);
  num.clear();
  num.concat(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.clear();
  num.concat((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__);
  }

  // test complex assign & such
  //
  dcfloat = SysComplex<float>(3, 2);
  num.clear();
  num.concat(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>(3, -2);
  num.clear();
  num.concat(dcfloat);
  num.get(dcfloat_v);
  if (dcfloat != dcfloat_v) {
    num.debug(L"dcfloat");
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__, __LINE__);
  }

  num.clear();
  num.concat(dcfloat, L"asdf = %s xyz");
  if (num.ne(L"asdf = 3-2j xyz")) {
    Error::handle(name(), L"assign(complex)", Error::TEST, __FILE__,
		  __LINE__);
  }
  
  // test trim methods
  //
  str1.assign(L"   ...Hello my name is ...     ");
  if (level_a > Integral::ALL) {
    str1.debug(L"str1");
  }
  str2.assign(str1);
  str3.assign(str1);
  str4.assign(str1);

  str4.trim();
  if (level_a > Integral::ALL) {
    str4.debug(L"str4");
  }
  if (str4.ne(L"...Hello my name is ...")) {
    Error::handle(name(), L"trim 1", Error::TEST, __FILE__, __LINE__);
  }
  
  str4.trim(L". ");
  if (level_a > Integral::ALL) {
    str4.debug(L"str4");
  }
  if (str4.ne(L"Hello my name is")) {
    Error::handle(name(), L"trim 2", Error::TEST, __FILE__, __LINE__);
  }
  
  str4.trim(L"Hello ");
  if (str4.ne(L"my name is")) {
    Error::handle(name(), L"trim 3", Error::TEST, __FILE__, __LINE__);
  }
  
  str2.trimLeft();
  if (level_a > Integral::ALL) {
    str2.debug(L"str2");
  }
  if (str2.ne(L"...Hello my name is ...     ")) {
    Error::handle(name(), L"trimLeft 1", Error::TEST, __FILE__, __LINE__);
  }
  
  str2.trimLeft(L". ");
  if (level_a > Integral::ALL) {
    str2.debug(L"str2");
  }
  if (str2.ne(L"Hello my name is ...     ")) {
    Error::handle(name(), L"trimLeft 2", Error::TEST, __FILE__, __LINE__);
  }

  str2.trimLeft(L"Hello ");
  if (str2.ne(L"my name is ...     ")) {
    str2.debug(L"str2");
    Error::handle(name(), L"trimLeft 3", Error::TEST, __FILE__, __LINE__);
  }
  
  str3.trimRight();
  if (level_a > Integral::ALL) {
    str3.debug(L"str3");
  }

  if (str3.ne(L"   ...Hello my name is ...")) {
    Error::handle(name(), L"trimRight 1", Error::TEST, __FILE__, __LINE__);
  }
  
  str3.trimRight(L". ");
  if (level_a > Integral::ALL) {
    str3.debug(L"str3");
  }
  if (str3.ne(L"   ...Hello my name is")) {
    Error::handle(name(), L"trimRight 2", Error::TEST, __FILE__, __LINE__);
  }

  str3.trimRight(L"is"); 
  if (str3.ne(L"   ...Hello my name ")) {
    Error::handle(name(), L"trimRight 3", Error::TEST, __FILE__, __LINE__);
  }
  
 str1.assign(L"hello my name is Rick duncan");
  if (level_a > Integral::ALL) {
    str1.debug(L"str1");
  }
  str2.assign(str1);

  // test case conversion methods
  //
  str2.toUpper();
  if (level_a > Integral::ALL) {
    str2.debug(L"str2");
  }
  if (str2.ne(L"HELLO MY NAME IS RICK DUNCAN")) {
    Error::handle(name(), L"toUpper", Error::TEST, __FILE__, __LINE__);
  }
  
  str2.toLower();
  if (level_a > Integral::ALL) {
    str2.debug(L"str2");
  }
  if (str2.ne(L"hello my name is rick duncan")) {
    Error::handle(name(), L"toUpper", Error::TEST, __FILE__, __LINE__);
  }
  
  str2.toMixed();
  if (level_a > Integral::ALL) {
    str2.debug(L"str2");
  }
  if (str2.ne(L"Hello My Name Is Rick Duncan")) {
    Error::handle(name(), L"toUpper", Error::TEST, __FILE__, __LINE__);
  }
  
  str3.assign(L"hello my name is rick duncan");
  str3.toMixed();
  if (level_a > Integral::ALL) {
    str3.debug(L"str3");
  }
  if (str3.ne(L"Hello My Name Is Rick Duncan")) {
    Error::handle(name(), L"toMixed", Error::TEST, __FILE__, __LINE__);
  }

  str3.assign(L"hello my-name is rick_duncan");
  str2.assign(L"-_ ");
  str3.toMixed(str2);
  if (str3.ne(L"Hello My-Name Is Rick_Duncan")) { 
    str3.debug(L"str2 ");
    Error::handle(name(), L"toMixed", Error::TEST, __FILE__, __LINE__);
  }
  
  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }

  //---------------------------------------------------------------------------
  //
  // 8. class-specific public methods:
  //     string search methods
  //
  //---------------------------------------------------------------------------

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

  // test search methods
  //
  str1.assign(L"Hello, I'm Rick Duncan. People call me Rick Duncan");
  str2.assign(L"Rick");
  str3.assign(L"Ricky");
  str4.assign(str3);
  
  long pos = str1.firstStr(str2);
  if (pos != 11) {
    Error::handle(name(), L"firstStr 0", Error::TEST, __FILE__, __LINE__);
  }
  pos = str1.firstStr(str2, 12);
  if (pos != 39) {
    Error::handle(name(), L"firstStr 1", Error::TEST, __FILE__, __LINE__);
  }
  
  pos = str1.firstStr(str3);
  if (pos != Integral::NO_POS) {
    Error::handle(name(), L"firstStr 2", Error::TEST, __FILE__, __LINE__);
  }

  pos = str3.firstStr(str4);
  if (pos != 0) {
    Error::handle(name(), L"firstStr 2", Error::TEST, __FILE__, __LINE__);
  }

  pos = str3.lastStr(str4);
  if (pos != 0) {
    fprintf(stdout, "pos = %ld\n", pos);
    Error::handle(name(), L"lastStr 2", Error::TEST, __FILE__, __LINE__);
  }
  
  pos = str1.firstStr(str2, 41);
  if (pos != Integral::NO_POS) {
    Error::handle(name(), L"firstStr 3", Error::TEST, __FILE__, __LINE__);
  }
  
  pos = str1.lastStr(str2);
  if (pos != 39) {
    Error::handle(name(), L"lastStr 0", Error::TEST, __FILE__, __LINE__);
  }
  
  pos = str1.lastStr(str2, 41);
  if (pos != 11) {
    Error::handle(name(), L"lastStr 1", Error::TEST, __FILE__, __LINE__);
  }
  
  pos = str1.lastStr(str3);
  if (pos != Integral::NO_POS) {
    Error::handle(name(), L"lastStr 2", Error::TEST, __FILE__, __LINE__);
  }
  
  pos = str1.lastStr(str2, 13);
  if (pos != Integral::NO_POS) {
    Error::handle(name(), L"lastStr 3", Error::TEST, __FILE__, __LINE__);
  }

  str1.assign(L"hello");
  str2.assign(L"..hi, world");
  if (str2.firstChr(str1) != 2) {
    Error::handle(name(), L"firstChr 1", Error::TEST, __FILE__, __LINE__);
  }

  if (str2.lastChr(str1) != 9) {
    Error::handle(name(), L"firstChr 1", Error::TEST, __FILE__, __LINE__);
  }

  if (str2.firstChr(L"he") != 2) {
    Error::handle(name(), L"firstChr 1", Error::TEST, __FILE__, __LINE__);
  }

  if (str2.lastChr(L"hi") != 3 ) {
    fprintf(stdout, "firstChr=%ld", str2.firstChr(str1));
    Error::handle(name(), L"lastChr 1", Error::TEST, __FILE__, __LINE__);
  }

  if(str2.firstChr((unichar)'h') != 2) {
    Error::handle(name(), L"firstChr 1", Error::TEST, __FILE__, __LINE__);
  }

  if (str2.lastChr(L"l") != 9) {
    Error::handle(name(), L"lastChr 1", Error::TEST, __FILE__, __LINE__);
  }
  
  str1.assign(L"  123aBCd,456  ");
  
  if (str1.firstAlnum() != 2) {
    Error::handle(name(), L"firstAlnum", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.firstAlpha() != 5) {
    Error::handle(name(), L"firstApha", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.firstDigit() != 2) {
    Error::handle(name(), L"firstDigit", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.firstLower() != 5) {
    Error::handle(name(), L"firstLower", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.firstPrint() != 0) {
    Error::handle(name(), L"firstPrint", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.firstPunct() != 9) {
    Error::handle(name(), L"firstPunct", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.firstSpace() != 0) {
    Error::handle(name(), L"firstPunct", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.firstUpper() != 6) {
    Error::handle(name(), L"firstPunct", Error::TEST, __FILE__, __LINE__);
  }

  str1.assign(L"  123aBCd,456  ");

  if (str1.lastAlnum() != 12) {
    Error::handle(name(), L"lastAlnum", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.lastAlpha() != 8) {
    Error::handle(name(), L"lastApha", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.lastDigit() != 12) {
    Error::handle(name(), L"lastDigit", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.lastLower() != 8) {
    Error::handle(name(), L"lastLower", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.lastPrint() != 14) {
    Error::handle(name(), L"lastPrint", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.lastPunct() != 9) {
    Error::handle(name(), L"lastPunct", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.lastSpace() != 14) {
    Error::handle(name(), L"lastSpace", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.lastUpper() != 7) {
    Error::handle(name(), L"lastUpper", Error::TEST, __FILE__, __LINE__);
  }

  str1.assign(L"13, Aab ");

  if (str1.firstNotAlnum() != 2) {
    Error::handle(name(), L"firstNotAlnum", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.firstNotAlpha() != 0) {
    Error::handle(name(), L"firstNotApha", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.firstNotDigit() != 2) {
    Error::handle(name(), L"firstNotDigit", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.firstNotLower() != 0) {
    Error::handle(name(), L"firstNotLower", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.firstNotPrint() != Integral::NO_POS) {
    Error::handle(name(), L"firstNotPrint", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.firstNotPunct() != 0) {
    Error::handle(name(), L"firstNotPunct", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.firstNotSpace() != 0) {
    Error::handle(name(), L"firstNotSpace", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.firstNotUpper() != 0) {
    Error::handle(name(), L"firstNotUpper", Error::TEST, __FILE__, __LINE__);
  }

  str1.assign(L"13, ABb ");
  
  if (str1.lastNotAlnum() != 7) {
    Error::handle(name(), L"lastNotAlnum", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.lastNotAlpha() != 7) {
    Error::handle(name(), L"lastNotApha", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.lastNotDigit() != 7) {
    Error::handle(name(), L"lastNotDigit", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.lastNotLower() != 7) {
    Error::handle(name(), L"lastNotLower", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.lastNotPrint() != Integral::NO_POS) {
    Error::handle(name(), L"lastNotPrint", Error::TEST, __FILE__, __LINE__);
  }

  if (str1.lastNotPunct() != 7) {
    Error::handle(name(), L"lastNotPunct", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.lastNotSpace() != 6) {
    Error::handle(name(), L"lastNotSpace", Error::TEST, __FILE__, __LINE__);
  }
  
  if (str1.lastNotUpper() != 7) {
    Error::handle(name(), L"lastNotUpper", Error::TEST, __FILE__, __LINE__);
  }

  // test tokenization methods
  //
  str1.assign(L"oscar had a heap of apples");
  SysString sub_str;
  pos = 0;
  
  SysString temp_space(L" ");
  
  if (str1.tokenize(sub_str, pos, L" ")) {
    if (level_a > Integral::ALL) {
      sub_str.debug(L"token");
    }
  }

  while (str1.tokenize(sub_str, pos, L" ")) {
    if (level_a > Integral::ALL) {
      sub_str.debug(L"token");
    }
  }

  long tok = str1.countTokens(L" ");
  if (tok != 6) {
    Error::handle(name(), L"countTokens", Error::TEST, __FILE__, __LINE__);
  }
  
  // test symbolPad methods
  //
  str1.assign(L"{where |what}&|(did) (I) ( do }");
  str2.assign(L"{}()&|");
  str1.symbolPad(str2);

  if (level_a > Integral::ALL) {
    str1.debug(L"padded");
  }
  if (str1.ne(L"{ where | what } & | ( did ) ( I ) ( do }")) {
    Error::handle(name(), L"symbolPad", Error::TEST, __FILE__, __LINE__);
  }

  // testing debugStr methods
  //
  str1.assign(L"testing method");
  str2.debugStr(name(), L"test", L"variable", str1);
  if (level_a > Integral::ALL) {
    str1.debug(L"str1");
    str2.debug(L"str2");
    Console::put(L"\n");
  }
  if (str2.ne(L"<SysString::test> variable = testing method")) {
    Error::handle(name(), L"debugStr", Error::TEST, __FILE__, __LINE__);
  }
  
  str1.assign(L"2nd testing method");
  str2.debugStr(name(), L"test2", L"variable", str1);

  if (level_a > Integral::ALL) {
    str1.debug(L"str1");
    str2.debug(L"str2");
    Console::put(L"\n");
  }
  if (str2.ne(L"<SysString::test2> variable = 2nd testing method")) {
    Error::handle(name(), L"debugStr", Error::TEST, __FILE__, __LINE__);
  }

  // test getEmptyString methods
  //
  if (getEmptyString().length() != 0) {
    return Error::handle(name(), L"getEmptyString", Error::TEST,
                         __FILE__, __LINE__);
  }
  
  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
  
  //---------------------------------------------------------------------------
  //
  // 9. print completion message
  //
  //---------------------------------------------------------------------------

  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
  
  if (level_a > Integral::NONE) {
    SysString output(L"diagnostics passed for class ");
    output.concat(name());
    output.concat(L"\n");
    Console::put(output);
  }

  // exit gracefully
  //
  return true;
}