开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
test_ncbistr.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：28k
源码类别：

生物技术

开发平台：

C/C++

test_ncbistr.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: test_ncbistr.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:10:19  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.28
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: test_ncbistr.cpp,v 1000.2 2004/06/01 19:10:19 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Denis Vakatov
  36.  *
  37.  * File Description:
  38.  *   TEST for:  NCBI C++ core string-related API
  39.  *
  40.  */
  42. #include <ncbi_pch.hpp>
  43. #include <corelib/ncbiapp.hpp>
  44. #include <corelib/ncbienv.hpp>
  45. #include <corelib/ncbireg.hpp>
  46. #include <algorithm>
  48. #include <test/test_assert.h>  /* This header must go last */
  51. // This is to use the ANSI C++ standard templates without the "std::" prefix
  52. // and to use NCBI C++ entities without the "ncbi::" prefix
  53. USING_NCBI_SCOPE;
  56. /////////////////////////////////
  57. // Utilities
  58. //
  60. static void TestStrings_StrCompare(int expr_res, int valid_res)
  61. {
  62.     int res = expr_res > 0 ? 1 :
  63.         expr_res == 0 ? 0 : -1;
  64.     assert(res == valid_res);
  65. }
  68. typedef struct {
  69.     const char* s1;
  70.     const char* s2;
  72.     int case_res;      /* -1, 0, 1 */
  73.     int nocase_res;    /* -1, 0, 1 */
  75.     SIZE_TYPE n; 
  76.     int n_case_res;    /* -1, 0, 1 */
  77.     int n_nocase_res;  /* -1, 0, 1 */
  78. } SStrCompare;
  81. static const SStrCompare s_StrCompare[] = {
  82.     { "", "",  0, 0,  0,     0, 0 },
  83.     { "", "",  0, 0,  NPOS,  0, 0 },
  84.     { "", "",  0, 0,  10,    0, 0 },
  85.     { "", "",  0, 0,  1,     0, 0 },
  87.     { "a", "",  1, 1,  0,     0, 0 },
  88.     { "a", "",  1, 1,  1,     1, 1 },
  89.     { "a", "",  1, 1,  2,     1, 1 },
  90.     { "a", "",  1, 1,  NPOS,  1, 1 },
  92.     { "", "bb",  -1, -1,  0,     -1, -1 },
  93.     { "", "bb",  -1, -1,  1,     -1, -1 },
  94.     { "", "bb",  -1, -1,  2,     -1, -1 },
  95.     { "", "bb",  -1, -1,  3,     -1, -1 },
  96.     { "", "bb",  -1, -1,  NPOS,  -1, -1 },
  98.     { "ba", "bb",  -1, -1,  0,     -1, -1 },
  99.     { "ba", "bb",  -1, -1,  1,     -1, -1 },
  100.     { "ba", "b",    1,  1,  1,      0,  0 },
  101.     { "ba", "bb",  -1, -1,  2,     -1, -1 },
  102.     { "ba", "bb",  -1, -1,  3,     -1, -1 },
  103.     { "ba", "bb",  -1, -1,  NPOS,  -1, -1 },
  105.     { "a", "A",  1, 0,  0,    -1, -1 },
  106.     { "a", "A",  1, 0,  1,     1,  0 },
  107.     { "a", "A",  1, 0,  2,     1,  0 },
  108.     { "a", "A",  1, 0,  NPOS,  1,  0 },
  110.     { "A", "a",  -1, 0,  0,     -1, -1 },
  111.     { "A", "a",  -1, 0,  1,     -1,  0 },
  112.     { "A", "a",  -1, 0,  2,     -1,  0 },
  113.     { "A", "a",  -1, 0,  NPOS,  -1,  0 },
  115.     { "ba", "ba1",  -1, -1,  0,     -1, -1 },
  116.     { "ba", "ba1",  -1, -1,  1,     -1, -1 },
  117.     { "ba", "ba1",  -1, -1,  2,     -1, -1 },
  118.     { "bA", "ba",   -1,  0,  2,     -1,  0 },
  119.     { "ba", "ba1",  -1, -1,  3,     -1, -1 },
  120.     { "ba", "ba1",  -1, -1,  NPOS,  -1, -1 },
  122.     { "ba1", "ba",  1, 1,  0,    -1, -1 },
  123.     { "ba1", "ba",  1, 1,  1,    -1, -1 },
  124.     { "ba1", "ba",  1, 1,  2,     0,  0 },
  125.     { "ba",  "bA",  1, 0,  2,     1,  0 },
  126.     { "ba1", "ba",  1, 1,  3,     1,  1 },
  127.     { "ba1", "ba",  1, 1,  NPOS,  1,  1 },
  128.     { "ba1", "ba",  1, 1,  NPOS,  1,  1 }
  129. };
  132. typedef struct {
  133.     const char* pchar;    // String input
  134.     int         base;     // Radix base 
  135.     Uint8       expected; // Expected value
  136. } SRadixTest;
  139. /////////////////////////////////
  140. // Test application
  141. //
  143. class CTestApplication : public CNcbiApplication
  144. {
  145. public:
  146.     void Init(void);
  147.     int Run(void);
  148. };
  151. void CTestApplication::Init(void)
  152. {
  153.     // Set err.-posting and tracing to maximum
  154.     SetDiagTrace(eDT_Enable);
  155.     SetDiagPostFlag(eDPF_All);
  156.     SetDiagPostLevel(eDiag_Info);
  157. }
  160. //#define TEST_MEMORY_USAGE
  161. #ifdef TEST_MEMORY_USAGE
  162. enum ContainerType {
  163.     eVector,
  164.     eList,
  165.     eSet,
  166.     eRef
  167. };
  170. void DumpSize(void)
  171. {
  172.     char buffer[1024];
  173.     NcbiCout << "Press enter..." << flush;
  174.     gets(buffer);
  175. }
  178. void TestAllocate(ContainerType cont, int size, int count)
  179. {
  180.     switch ( cont ) {
  181.     case eVector:
  182.     {{
  183.         NcbiCout << "Allocating " << size <<
  184.             " vectors<int> with " << count << " elements" << NcbiEndl;
  185.         DumpSize();
  186.         vector<int>* v = new vector<int>[size];
  187.         for ( int i = 0; i < size; ++i ) {
  188.             for ( int j = 0; j < count; ++j ) {
  189.                 v[i].push_back(j);
  190.             }
  191.         }
  192.         NcbiCout << "Allocated." << NcbiEndl;
  193.         DumpSize();
  194.         delete[] v;
  195.         break;
  196.     }}
  197.     case eList:
  198.     {{
  199.         NcbiCout << "Allocating " << size <<
  200.             " list<int> with " << count << " elements" << NcbiEndl;
  201.         DumpSize();
  202.         list<int>* v = new list<int>[size];
  203.         for ( int i = 0; i < size; ++i ) {
  204.             for ( int j = 0; j < count; ++j ) {
  205.                 v[i].push_back(j);
  206.             }
  207.         }
  208.         NcbiCout << "Allocated." << NcbiEndl;
  209.         DumpSize();
  210.         delete[] v;
  211.         break;
  212.     }}
  213.     case eRef:
  214.     {{
  215.         NcbiCout << "Allocating " << size <<
  216.             " CRef<CObject> with " << count << " elements" << NcbiEndl;
  217.         DumpSize();
  218.         CRef<CObject>* v = new CRef<CObject>[size];
  219.         for ( int i = 0; i < size; ++i ) {
  220.             for ( int j = 0; j < count; ++j ) {
  221.                 v[i].Reset(new CObject);
  222.             }
  223.         }
  224.         NcbiCout << "Allocated." << NcbiEndl;
  225.         DumpSize();
  226.         delete[] v;
  227.         break;
  228.     }}
  229.     }
  230. }
  233. void Test(ContainerType cont)
  234. {
  235.     for ( int j = 0; j <= 2; ++j ) {
  236.         TestAllocate(cont, 100000, j);
  237.     }
  238.     for ( int j = 0; j <= 2; ++j ) {
  239.         TestAllocate(cont, 1000000, j);
  240.     }
  241. }
  242. #endif
  245. int CTestApplication::Run(void)
  246. {
  247. #ifdef TEST_MEMORY_USAGE
  248.     Test(eRef);
  249. #endif
  251.     static const string s_Strings[] = {
  252.         "",
  253.         ".",
  254.         "..",
  255.         ".0",
  256.         ".0.",
  257.         "..0",
  258.         ".01",
  259.         "1.",
  260.         "1.1",
  261.         "1.1.",
  262.         "1..",
  263.         "-2147483649",
  264.         "-2147483648",
  265.         "-1",
  266.         "0",
  267.         "2147483647",
  268.         "2147483648",
  269.         "4294967295",
  270.         "4294967296",
  271.         " 123 ",
  272.         "-324",
  273.         " 567",
  274.         "+890",
  275.         "zzz"
  276.     };
  278.     NcbiCout << "Test NCBISTR:" << NcbiEndl;
  280.     const size_t count = sizeof(s_Strings) / sizeof(s_Strings[0]);
  282.     //        CExceptionReporterStream reporter(cerr);
  283.     //        CExceptionReporter::SetDefault(&reporter);
  284.     //        CExceptionReporter::EnableDefault(false);
  285.     //        CExceptionReporter::EnableDefault(true);
  286.     //        CExceptionReporter::SetDefault(0);
  287.     
  288.     SetupDiag(eDS_ToStdout);
  289.     /*
  290.       
  291.     CExceptionReporter::EnableDefault(true);
  292.     cerr << endl;
  293.     NCBI_REPORT_EXCEPTION(
  294.     "****** default reporter (stream) ******",e);
  296.     CExceptionReporter::SetDefault(0);
  297.     cerr << endl;
  298.     NCBI_REPORT_EXCEPTION(
  299.     "****** default reporter (diag) ******",e);
  300.     */
  301.     
  302.     for (size_t i = 0;  i < count;  ++i) {
  303.         const string& str = s_Strings[i];
  304.         NcbiCout << "n*** Checking string '" << str << "'***" << NcbiEndl;
  306.         {{
  307.             int value = NStr::StringToNumeric(str);
  308.             NcbiCout << "numeric value: " << value << ", toString: '"
  309.                      << NStr::IntToString(value) << "'" << NcbiEndl;
  310.         }}
  312.         try {
  313.             int value = NStr::StringToInt(str);
  314.             NcbiCout << "int value: " << value << ", toString: '"
  315.                      << NStr::IntToString(value) << "'" << NcbiEndl;
  316.         }
  317.         catch (CException& e) {
  318.             NCBI_REPORT_EXCEPTION("TestStrings",e);
  319.         }
  321.         try {
  322.             unsigned int value = NStr::StringToUInt(str);
  323.             NcbiCout << "unsigned int value: " << value << ", toString: '"
  324.                      << NStr::UIntToString(value) << "'" << NcbiEndl;
  325.         }
  326.         catch (CException& e) {
  327.             NCBI_REPORT_EXCEPTION("TestStrings",e);
  328.         }
  330.         try {
  331.             long value = NStr::StringToLong(str);
  332.             NcbiCout << "long value: " << value << ", toString: '"
  333.                      << NStr::IntToString(value) << "'" << NcbiEndl;
  334.             NcbiCout << "      Int8ToString: '"
  335.                      << NStr::Int8ToString(value) << "'" << NcbiEndl;
  336.         }
  337.         catch (CException& e) {
  338.             NCBI_REPORT_EXCEPTION("TestStrings",e);
  339.         }
  341.         try {
  342.             unsigned long value = NStr::StringToULong(str);
  343.             NcbiCout << "unsigned long value: " << value << ", toString: '"
  344.                      << NStr::UIntToString(value) << "'" << NcbiEndl;
  345.             NcbiCout << "      UInt8ToString: '"
  346.                      << NStr::UInt8ToString(value) << "'" << NcbiEndl;
  347.         }
  348.         catch (CException& e) {
  349.             NCBI_REPORT_EXCEPTION("TestStrings",e);
  350.         }
  352.         try {
  353.             double value = NStr::StringToDouble(str);
  354.             NcbiCout << "double value: " << value << ", toString: '"
  355.                      << NStr::DoubleToString(value) << "'" << NcbiEndl;
  356.         }
  357.         catch (CException& e) {
  358.             NCBI_REPORT_EXCEPTION("TestStrings",e);
  359.         }
  360.         
  361.         try {
  362.             Int8 value = NStr::StringToInt8(str);
  363.             NcbiCout << "Int8 value: " << (int)value << ", toString: '"
  364.                      << NStr::Int8ToString(value) << "'" << NcbiEndl;
  365.         }
  366.         catch (CException& e) {
  367.             NCBI_REPORT_EXCEPTION("TestStrings",e);
  368.         }
  370.         try {
  371.             Uint8 value = NStr::StringToUInt8(str);
  372.             NcbiCout << "Uint8 value: " << (unsigned)value << ", toString: '"
  373.                      << NStr::UInt8ToString(value) << "'" << NcbiEndl;
  374.         }
  375.         catch (CException& e) {
  376.             NCBI_REPORT_EXCEPTION("TestStrings",e);
  377.         }
  378.         
  379.     }
  381.     // Writing separate tests for StringToUInt8 because we
  382.     // need to test for different radix values such as 2, 8, and 16
  383.     // and s_Strings presents string samples with radix of 10 only.
  384.     //
  385.     static const SRadixTest s_RadixTests[] = {
  386.         {"A", 16, 10},
  387.         {"B9", 16, 185},
  388.         {"C5D", 16, 3165},
  389.         {"FFFF", 16, 65535},
  390.         {"17ABCDEF", 16, 397135343},
  391.         {"BADBADBA", 16, 3134959034U},
  392.         {"7", 8, 7},
  393.         {"17", 8, 15},
  394.         {"177", 8, 127},
  395.         {"0123", 8, 83},
  396.         {"01234567", 8, 342391},
  397.         {"0", 2, 0},
  398.         {"1", 2, 1},
  399.         {"10", 2, 2},
  400.         {"11", 2, 3},
  401.         {"100", 2, 4},
  402.         {"101", 2, 5}, 
  403.         {"110", 2, 6},
  404.         {"111", 2, 7},
  406.         // Invalid values come next
  407.         {"10ABCDEFGH", 16, 0},
  408.         {"12345A", 10, 0},
  409.         {"012345678", 8, 0},
  410.         {"012", 2, 0}
  411.     };
  413.     for (size_t i = 0;  
  414.          i < sizeof(s_RadixTests)/sizeof(s_RadixTests[0]);
  415.          ++i) {
  416.         const string& str = s_RadixTests[i].pchar;
  417.         int base = s_RadixTests[i].base;
  418.         Uint8 expected = s_RadixTests[i].expected;
  419.         NcbiCout << "Checking numeric string: '" << str 
  420.                  << "': with base " << base << NcbiEndl;
  421.         try {
  422.             Uint8 value = NStr::StringToUInt8(str, base);
  423.             NcbiCout << "Uint8 value: " << ((unsigned)value)
  424.                      << ", Expected: " << (unsigned)expected << NcbiEndl;
  425.         }
  426.         catch (CException& e) {
  427.             NCBI_REPORT_EXCEPTION("TestStrings",e);
  428.         }
  429.     } 
  431.     NcbiCout << NcbiEndl << "NStr::Replace() tests...";
  433.     string src("aaabbbaaccczzcccXX");
  434.     string dst;
  436.     string search("ccc");
  437.     string replace("RrR");
  438.     NStr::Replace(src, search, replace, dst);
  439.     assert(dst == "aaabbbaaRrRzzRrRXX");
  441.     search = "a";
  442.     replace = "W";
  443.     NStr::Replace(src, search, replace, dst, 6, 1);
  444.     assert(dst == "aaabbbWaccczzcccXX");
  445.     
  446.     search = "bbb";
  447.     replace = "BBB";
  448.     NStr::Replace(src, search, replace, dst, 50);
  449.     assert(dst == "aaabbbaaccczzcccXX");
  451.     search = "ggg";
  452.     replace = "no";
  453.     dst = NStr::Replace(src, search, replace);
  454.     assert(dst == "aaabbbaaccczzcccXX");
  456.     search = "a";
  457.     replace = "A";
  458.     dst = NStr::Replace(src, search, replace);
  459.     assert(dst == "AAAbbbAAccczzcccXX");
  461.     search = "X";
  462.     replace = "x";
  463.     dst = NStr::Replace(src, search, replace, src.size() - 1);
  464.     assert(dst == "aaabbbaaccczzcccXx");
  466.     NcbiCout << " completed successfully!" << NcbiEndl;
  469.     // NStr::PrintableString()
  470.     assert(NStr::PrintableString(kEmptyStr).empty());
  471.     assert(NStr::PrintableString("AB\CDnABrCDvABtCD'AB"").
  472.            compare("AB\\CD\nAB\rCD\vAB\tCD'AB\"") == 0);
  473.     assert(NStr::PrintableString("A20B" + string(1, '') + "CD").
  474.            compare("A\x10B\x00CD") == 0);
  476.     // NStr::ParseEscapes
  477.     assert(NStr::ParseEscapes(kEmptyStr).empty());
  478.     assert(NStr::ParseEscapes("AB\\CD\nAB\rCD\vAB\tCD'AB\"").
  479.            compare("AB\CDnABrCDvABtCD'AB"") == 0);
  480.     assert(NStr::ParseEscapes("A\x10B\x00CD").
  481.            compare("A20B" + string(1, '') + "CD") == 0);
  484.     // NStr::Compare()
  485.     NcbiCout << NcbiEndl << "NStr::Compare() tests...";
  487.     size_t j;
  488.     const SStrCompare* rec;
  490.     for (j = 0;  j < sizeof(s_StrCompare) / sizeof(s_StrCompare[0]);  j++) {
  491.         rec = &s_StrCompare[j];
  492.         string s1 = rec->s1;
  494.         TestStrings_StrCompare
  495.             (NStr::Compare(s1, rec->s2, NStr::eCase), rec->case_res);
  496.         TestStrings_StrCompare
  497.             (NStr::Compare(s1, rec->s2, NStr::eNocase), rec->nocase_res);
  499.         TestStrings_StrCompare
  500.             (NStr::Compare(s1, 0, rec->n, rec->s2, NStr::eCase),
  501.              rec->n_case_res);
  502.         TestStrings_StrCompare
  503.             (NStr::Compare(s1, 0, rec->n, rec->s2, NStr::eNocase),
  504.              rec->n_nocase_res);
  506.         string s2 = rec->s2;
  508.         TestStrings_StrCompare
  509.             (NStr::Compare(s1, s2, NStr::eCase), rec->case_res);
  510.         TestStrings_StrCompare
  511.             (NStr::Compare(s1, s2, NStr::eNocase), rec->nocase_res);
  513.         TestStrings_StrCompare
  514.             (NStr::Compare(s1, 0, rec->n, s2, NStr::eCase),
  515.              rec->n_case_res);
  516.         TestStrings_StrCompare
  517.             (NStr::Compare(s1, 0, rec->n, s2, NStr::eNocase),
  518.              rec->n_nocase_res);
  519.     }
  521.     assert(NStr::Compare("0123", 0, 2, "12") <  0);
  522.     assert(NStr::Compare("0123", 1, 2, "12") == 0);
  523.     assert(NStr::Compare("0123", 2, 2, "12") >  0);
  524.     assert(NStr::Compare("0123", 3, 2,  "3") == 0);
  526.     NcbiCout << " completed successfully!" << NcbiEndl;
  529.     NcbiCout << NcbiEndl << "NStr::Split() tests...";
  531.     static const string s_SplitStr[] = {
  532.         "ab+cd+ef",
  533.         "aaAAabBbbb",
  534.         "-abc-def--ghijk---",
  535.         "a12c3ba45acb678bc"
  536.         "nodelim",
  537.         "emptydelim",
  538.         ""
  539.     };
  540.     static const string s_SplitDelim[] = {
  541.         "+", "AB", "-", "abc", "*", "", "*"
  542.     };
  543.     static const string split_result[] = {
  544.         "ab", "cd", "ef",
  545.         "aa", "ab", "bbb",
  546.         "abc", "def", "ghijk",
  547.         "12", "3", "45", "678",
  548.         "nodelim",
  549.         "emptydelim"
  550.     };
  552.     list<string> split;
  554.     for (size_t i = 0; i < sizeof(s_SplitStr) / sizeof(s_SplitStr[0]); i++) {
  555.         NStr::Split(s_SplitStr[i], s_SplitDelim[i], split);
  556.     }
  558.     {{
  559.         int i = 0;
  560.         ITERATE(list<string>, it, split) {
  561.             assert(NStr::Compare(*it, split_result[i++]) == 0);
  562.         }
  563.     }}
  564.     
  565.     NcbiCout << " completed successfully!" << NcbiEndl;
  567.     
  569.     // NStr::Tokenize()
  570.     NcbiCout << NcbiEndl << "NStr::Tokenize() tests...";
  572.     static const string s_TokStr[] = {
  573.         "ab+cd+ef",
  574.         "123;45,78",
  575.         "1;",
  576.         ";1",
  577.         "emptydelim"
  578.     };
  579.     static const string s_TokDelim[] = {
  580.         "+", ";,", ";", ";", ""
  581.     };
  583.     static const string tok_result[] = {
  584.         "ab", "cd", "ef",
  585.         "123", "45", "78",
  586.         "1", "", 
  587.         "", "1",
  588.         "emptydelim"
  589.     };
  591.     vector<string> tok;
  593.     for (size_t i = 0; i < sizeof(s_TokStr) / sizeof(s_TokStr[0]); ++i) {
  594.         NStr::Tokenize(s_TokStr[i], s_TokDelim[i], tok);               
  595.     }
  597.     {{
  598.         int i = 0;
  599.         ITERATE(vector<string>, it, tok) {
  600.             assert(NStr::Compare(*it, tok_result[i++]) == 0);
  601.         }
  602.     }}
  603.     
  604.     NcbiCout << " completed successfully!" << NcbiEndl;
  607.     // NStr::SplitInTwo()
  608.     NcbiCout << NcbiEndl << "NStr::SplitInTwo() tests...";
  611.     static const struct {
  612.         const char* str;
  613.         const char* delim;
  614.         const char* expected_str1;
  615.         const char* expected_str2;
  616.         bool    expected_ret;
  617.     }  s_SplitInTwoTest[] = {
  618.         { "ab+cd+ef", "+", "ab", "cd+ef", true },
  619.         { "aaAAabBbbb", "AB", "aa", "AabBbbb", true },
  620.         { "aaCAabBCbbb", "ABC", "aa", "AabBCbbb", true },
  621.         { "-beg-delim-", "-", "", "beg-delim-", true },
  622.         { "end-delim:", ":", "end-delim", "", true },
  623.         { "nodelim", ".,:;-+", "nodelim", "", false },
  624.         { "emptydelim", "", "emptydelim", "", false },
  625.         { "", "emtpystring", "", "", false },
  626.         { "", "", "", "", false }
  627.     };
  630.     {{
  631.         string  string1, string2;
  632.         bool    result;
  633.         for ( size_t i = 0; 
  634.               i < sizeof(s_SplitInTwoTest) / sizeof(s_SplitInTwoTest[0]);
  635.               i++) {
  636.             result = NStr::SplitInTwo(s_SplitInTwoTest[i].str,
  637.                                       s_SplitInTwoTest[i].delim,
  638.                                       string1, string2);
  639.             assert(s_SplitInTwoTest[i].expected_ret == result);
  640.             assert(s_SplitInTwoTest[i].expected_str1 == string1);
  641.             assert(s_SplitInTwoTest[i].expected_str2 == string2);
  642.         }
  643.     }}
  644.     
  645.     NcbiCout << " completed successfully!" << NcbiEndl;
  648.     NcbiCout << NcbiEndl << "NStr::ToLower/ToUpper() tests...";
  650.     static const struct {
  651.         const char* orig;
  652.         const char* x_lower;
  653.         const char* x_upper;
  654.     } s_Tri[] = {
  655.         { "", "", "" },
  656.         { "a", "a", "A" },
  657.         { "4", "4", "4" },
  658.         { "B5a", "b5a", "B5A" },
  659.         { "baObaB", "baobab", "BAOBAB" },
  660.         { "B", "b", "B" },
  661.         { "B", "b", "B" }
  662.     };
  664.     static const char s_Indiff[] =
  665.         "#@+_)(*&^%/?"':;~`'\!v|=-0123456789.,><{}[]tnr";
  666.     {{
  667.         char indiff[sizeof(s_Indiff) + 1];
  668.         ::strcpy(indiff, s_Indiff);
  669.         assert(NStr::Compare(s_Indiff, indiff) == 0);
  670.         assert(NStr::Compare(s_Indiff, NStr::ToLower(indiff)) == 0);
  671.         ::strcpy(indiff, s_Indiff);
  672.         assert(NStr::Compare(s_Indiff, NStr::ToUpper(indiff)) == 0);
  673.         assert(NStr::Compare(s_Indiff, NStr::ToLower(indiff)) == 0);
  674.     }}
  676.     {{
  677.         string indiff;
  678.         indiff = s_Indiff;
  679.         assert(NStr::Compare(s_Indiff, indiff) == 0);
  680.         assert(NStr::Compare(s_Indiff, NStr::ToLower(indiff)) == 0);
  681.         indiff = s_Indiff;
  682.         assert(NStr::Compare(s_Indiff, NStr::ToUpper(indiff)) == 0);
  683.         assert(NStr::Compare(s_Indiff, NStr::ToLower(indiff)) == 0);
  684.     }}
  687.     for (j = 0;  j < sizeof(s_Tri) / sizeof(s_Tri[0]);  j++) {
  688.         assert(NStr::Compare(s_Tri[j].orig, s_Tri[j].x_lower, NStr::eNocase)
  689.                == 0);
  690.         assert(NStr::Compare(s_Tri[j].orig, s_Tri[j].x_upper, NStr::eNocase)
  691.                == 0);
  693.         string orig = s_Tri[j].orig;
  694.         assert(NStr::Compare(orig, s_Tri[j].x_lower, NStr::eNocase)
  695.                == 0);
  696.         assert(NStr::Compare(orig, s_Tri[j].x_upper, NStr::eNocase)
  697.                == 0);
  699.         string x_lower = s_Tri[j].x_lower;
  701.         {{
  702.             char x_str[16];
  703.             ::strcpy(x_str, s_Tri[j].orig);
  704.             assert(::strlen(x_str) < sizeof(x_str));
  705.             assert(NStr::Compare(NStr::ToLower(x_str), x_lower) == 0);
  706.             ::strcpy(x_str, s_Tri[j].orig);
  707.             assert(NStr::Compare(NStr::ToUpper(x_str), s_Tri[j].x_upper) ==0);
  708.             assert(NStr::Compare(x_lower, NStr::ToLower(x_str)) == 0);
  709.         }}
  711.         {{
  712.             string x_str;
  713.             x_lower = s_Tri[j].x_lower;
  714.             x_str = s_Tri[j].orig;
  715.             assert(NStr::Compare(NStr::ToLower(x_str), x_lower) == 0);
  716.             x_str = s_Tri[j].orig;
  717.             assert(NStr::Compare(NStr::ToUpper(x_str), s_Tri[j].x_upper) ==0);
  718.             assert(NStr::Compare(x_lower, NStr::ToLower(x_str)) == 0);
  719.         }}
  720.     }
  721.     NcbiCout << " completed successfully!" << NcbiEndl;
  723.     NcbiCout << NcbiEndl << "AStrEquiv tests...";
  725.     string as1("abcdefg ");
  726.     string as2("abcdefg ");
  727.     string as3("aBcdEfg ");
  728.     string as4("lsekfu");
  730.     assert( AStrEquiv(as1, as2, PNocase()) == true );
  731.     assert( AStrEquiv(as1, as3, PNocase()) == true );
  732.     assert( AStrEquiv(as3, as4, PNocase()) == false );
  733.     assert( AStrEquiv(as1, as2, PCase())   == true );
  734.     assert( AStrEquiv(as1, as3, PCase())   == false );
  735.     assert( AStrEquiv(as2, as4, PCase())   == false );
  737.     NcbiCout << " completed successfully!" << NcbiEndl;
  739.     NcbiCout << NcbiEndl << "Equal{Case,Nocase} tests...";
  741.     assert( NStr::EqualNocase(as1, as2) == true );
  742.     assert( NStr::EqualNocase(as1, as3) == true );
  743.     assert( NStr::EqualNocase(as3, as4) == false );
  744.     assert( NStr::EqualCase(as1, as2)   == true );
  745.     assert( NStr::EqualCase(as1, as3)   == false );
  746.     assert( NStr::EqualCase(as2, as4)   == false );
  748.     NcbiCout << " completed successfully!" << NcbiEndl;
  750.     {{
  751.         NcbiCout << NcbiEndl 
  752.                  << "Testing string reference counting properties:"
  753.                  << NcbiEndl;
  754.         string s1(10, '1');
  755.         string s2(s1);
  756.         if ( s1.data() != s2.data() ) {
  757.             NcbiCout << "BAD: string reference counting is OFF" << NcbiEndl;
  758.         }
  759.         else {
  760.             NcbiCout << "GOOD: string reference counting is ON" << NcbiEndl;
  761.             for ( int i = 0; i < 4; ++i ) {
  763.                 NcbiCout << "Restoring reference counting"<<NcbiEndl;
  764.                 s2 = s1;
  765.                 if ( s1.data() != s2.data() ) {
  766.                     NcbiCout << "BAD: cannot restore string reference " 
  767.                         "counting" << NcbiEndl;
  768.                     continue;
  769.                 }
  770.                 NcbiCout << "GOOD: reference counting is ON" << NcbiEndl;
  772.                 const char* type = i&1? "str.begin()": "str.c_str()";
  773.                 NcbiCout << "Calling "<<type<<NcbiEndl;
  774.                 if ( i&1 ) {
  775.                     s2.begin();
  776.                 }
  777.                 else {
  778.                     s1.c_str();
  779.                 }
  780.                 if ( s1.data() == s2.data() ) {
  781.                     NcbiCout << "GOOD: "<< type 
  782.                              <<" doesn't affect reference counting"<< NcbiEndl;
  783.                     continue;
  784.                 }
  785.                 NcbiCout << "OK: "<< type 
  786.                          << " turns reference counting OFF" << NcbiEndl;
  788.                 NcbiCout << "Restoring reference counting"<<NcbiEndl;
  789.                 s2 = s1;
  790.                 if ( s1.data() != s2.data() ) {
  791.                     NcbiCout << "BAD: " << type 
  792.                              <<" turns reference counting OFF completely"
  793.                              << NcbiEndl;
  794.                     continue;
  795.                 }
  796.                 NcbiCout << "GOOD: reference counting is ON" << NcbiEndl;
  798.                 if ( i&1 ) continue;
  800.                 NcbiCout << "Calling " << type << " on source" << NcbiEndl;
  801.                 s1.c_str();
  802.                 if ( s1.data() != s2.data() ) {
  803.                     NcbiCout << "BAD: "<< type
  804.                              << " on source turns reference counting OFF"
  805.                              << NcbiEndl;
  806.                 }
  808.                 NcbiCout << "Calling "<< type <<" on destination" << NcbiEndl;
  809.                 s2.c_str();
  810.                 if ( s1.data() != s2.data() ) {
  811.                     NcbiCout << "BAD: " << type
  812.                              <<" on destination turns reference counting OFF"
  813.                              << NcbiEndl;
  814.                 }
  815.             }
  816.         }
  817.     }}
  819.     NcbiCout << NcbiEndl << "NStr::FindNoCase() tests...";
  820.     assert(NStr::FindNoCase(" abcd", " xyz") == NPOS);
  821.     assert(NStr::FindNoCase(" abcd", " xyz", 0, NPOS, NStr::eLast) == NPOS);
  822.     assert(NStr::FindNoCase(" abcd", " aBc", 0, NPOS, NStr::eLast) == 0);
  823.     NcbiCout << " completed successfully!" << NcbiEndl;
  825.     NcbiCout << NcbiEndl << "TEST_NCBISTR execution completed successfully!"
  826.              << NcbiEndl << NcbiEndl << NcbiEndl;
  828.     return 0;
  829. }
  831.   
  832. /////////////////////////////////
  833. // APPLICATION OBJECT and MAIN
  834. //
  836. int main(int argc, const char* argv[] /*, const char* envp[]*/)
  837. {
  838.     CTestApplication theTestApplication;
  839.     return theTestApplication.AppMain(argc, argv, 0 /*envp*/, eDS_ToMemory);
  840. }
  843. /*
  844.  * ==========================================================================
  845.  * $Log: test_ncbistr.cpp,v $
  846.  * Revision 1000.2  2004/06/01 19:10:19  gouriano
  847.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.28
  848.  *
  849.  * Revision 6.28  2004/05/26 20:46:54  ucko
  850.  * Add tests for Equal{Case,Nocase}.
  851.  *
  852.  * Revision 6.27  2004/05/26 19:26:29  ucko
  853.  * Add a(n incomplete) set of tests for FindNoCase.
  854.  *
  855.  * Revision 6.26  2004/05/14 13:59:51  gorelenk
  856.  * Added include of ncbi_pch.hpp
  857.  *
  858.  * Revision 6.25  2003/12/02 15:23:25  ucko
  859.  * Add tests for NStr::ParseEscapes (inverted from tests for PrintableString)
  860.  *
  861.  * Revision 6.24  2003/10/01 20:43:30  ivanov
  862.  * Get rid of compilation warnings; some formal code rearrangement
  863.  *
  864.  * Revision 6.23  2003/08/19 15:17:20  rsmith
  865.  * Add NStr::SplitInTwo() function.
  866.  *
  867.  * Revision 6.22  2003/07/23 17:49:55  vasilche
  868.  * Commented out memory usage test.
  869.  *
  870.  * Revision 6.21  2003/07/22 21:45:05  vasilche
  871.  * Commented out memory usage test.
  872.  *
  873.  * Revision 6.20  2003/07/17 20:01:38  vasilche
  874.  * Added test for string reference counting.
  875.  *
  876.  * Revision 6.19  2003/07/09 20:52:20  vasilche
  877.  * Added test for string's reference counting.
  878.  *
  879.  * Revision 6.18  2003/03/25 22:16:11  lavr
  880.  * Conform to new NUL char representation from NStr::PrintableString()
  881.  *
  882.  * Revision 6.17  2003/03/10 18:57:08  kuznets
  883.  * iterate->ITERATE
  884.  *
  885.  * Revision 6.16  2003/02/27 15:34:23  lavr
  886.  * Add tests for stray dots in numbers
  887.  *
  888.  * Revision 6.15  2003/02/26 20:35:13  siyan
  889.  * Added/deleted whitespaces to conform to existing code style.
  890.  *
  891.  * Revision 6.14  2003/02/26 16:47:36  siyan
  892.  * Added test cases to test new version of NStr::StringToUInt8.
  893.  *
  894.  * Revision 6.13  2003/01/21 23:55:44  vakatov
  895.  * Get rid of a warning
  896.  *
  897.  * Revision 6.12  2003/01/14 21:17:58  kuznets
  898.  * + test for NStr::Tokenize
  899.  *
  900.  * Revision 6.11  2003/01/13 14:48:08  kuznets
  901.  * minor fix
  902.  *
  903.  * Revision 6.10  2003/01/10 22:17:39  kuznets
  904.  * Implemented test for NStr::String2Int8
  905.  *
  906.  * Revision 6.9  2003/01/10 00:08:28  vakatov
  907.  * + Int8ToString(),  UInt8ToString()
  908.  *
  909.  * Revision 6.8  2002/10/17 16:56:02  ivanov
  910.  * Added tests for 'b' and 'B' time format symbols
  911.  *
  912.  * Revision 6.7  2002/09/04 19:32:11  vakatov
  913.  * Minor change to reflect the changed handling of '"' by NStr::PrintableString
  914.  *
  915.  * Revision 6.6  2002/07/15 18:17:26  gouriano
  916.  * renamed CNcbiException and its descendents
  917.  *
  918.  * Revision 6.5  2002/07/11 14:18:29  gouriano
  919.  * exceptions replaced by CNcbiException-type ones
  920.  *
  921.  * Revision 6.4  2002/04/16 18:49:08  ivanov
  922.  * Centralize threatment of assert() in tests.
  923.  * Added #include <test/test_assert.h>. CVS log moved to end of file.
  924.  *
  925.  * Revision 6.3  2001/08/30 00:39:58  vakatov
  926.  * + NStr::StringToNumeric()
  927.  *
  928.  * Revision 6.2  2001/05/17 15:05:09  lavr
  929.  * Typos corrected
  930.  *
  931.  * Revision 6.1  2001/03/26 20:34:38  vakatov
  932.  * Initial revision (moved from "coretest.cpp")
  933.  *
  934.  * ==========================================================================
  935.  */