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

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

生物技术

开发平台：

C/C++

test_ncbireg_mt.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: test_ncbireg_mt.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 19:10:16  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.8
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: test_ncbireg_mt.cpp,v 1000.1 2004/06/01 19:10:16 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:  Aleksey Grichenko
  36.  *
  37.  * File Description:
  38.  *   Test for "NCBIREG" in multithreaded environment
  39.  *
  40.  */
  42. #include <ncbi_pch.hpp>
  43. #include <corelib/test_mt.hpp>
  44. #include <corelib/ncbireg.hpp>
  45. #include <algorithm>
  47. #include <test/test_assert.h>  /* This header must go last */
  49. USING_NCBI_SCOPE;
  52. DEFINE_STATIC_FAST_MUTEX(s_GlobalLock);
  55. /////////////////////////////////////////////////////////////////////////////
  56. //  Test application
  58. class CTestRegApp : public CThreadedApp
  59. {
  60. public:
  61.     virtual bool Thread_Run(int idx);
  62. protected:
  63.     virtual bool TestApp_Init(void);
  64.     virtual bool TestApp_Exit(void);
  65. private:
  66.     CNcbiRegistry m_Registry;
  67. };
  70. bool CTestRegApp::Thread_Run(int /*idx*/)
  71. {
  72.     list<string> sections;
  73.     list<string> entries;
  75.     CNcbiOstrstream os;
  76.     const char*  os_str;
  77.     string       test_str("" V481" n"V482 ");
  79.     // Compose a test registry
  80.     {{
  81.     CFastMutexGuard LOCK(s_GlobalLock);
  83.     assert( m_Registry.Set("Section0", "Name01", "Val01_BAD!!!") );
  84.     assert( m_Registry.Set("Section1 ", "nName11", "Val11_t") );
  85.     assert(!m_Registry.Empty() );
  86.     assert( m_Registry.Get(" Section1", "Name11t") == "Val11_t" );
  87.     assert( m_Registry.Get("Section1", "Name11",
  88.                            CNcbiRegistry::ePersistent).empty() );
  91.     assert( m_Registry.Set("Section1", "Name11", "Val11_t") );
  92.     assert(!m_Registry.Set("Section1", "Name11", "Val11_BAD!!!",
  93.                            CNcbiRegistry::eNoOverride) );
  94.     assert( m_Registry.Set("   Section2", "nName21  ", "Val21",
  95.                            CNcbiRegistry::ePersistent) );
  96.     assert( m_Registry.Set("Section2", "Name21", "Val21_t") );
  97.     assert(!m_Registry.Empty() );
  98.     assert( m_Registry.Set("Section3", "Name31", "Val31_t") );
  100.     assert( m_Registry.Get(" nSection1", " Name11  ") == "Val11_t" );
  101.     assert( m_Registry.Get("Section2", "Name21",
  102.                            CNcbiRegistry::ePersistent) == "Val21" );
  103.     assert( m_Registry.Get(" Section2", " Name21n") == "Val21_t" );
  104.     assert( m_Registry.Get("SectionX", "Name21").empty() );
  107.     assert( m_Registry.Set("Section4", "Name41", "Val410 Val411 Val413",
  108.                            CNcbiRegistry::ePersistent) );
  109.     assert(!m_Registry.Set("Sect ion4", "Name41", "BAD1",
  110.                            CNcbiRegistry::ePersistent) );
  111.     assert(!m_Registry.Set("Section4", "Na me41", "BAD2") );
  112.     assert( m_Registry.Set("SECTION4", "Name42", "V420 V421nV422 V423 "",
  113.                            CNcbiRegistry::ePersistent) );
  114.     assert( m_Registry.Set("Section4", "NAME43",
  115.                            " tV430 V431  n V432 V433 ",
  116.                            CNcbiRegistry::ePersistent) );
  117.     assert( m_Registry.Set("tSection4", "Name43T",
  118.                            " tV430 V431  n V432 V433 ",
  119.                            CNcbiRegistry::ePersistent |
  120.                            CNcbiRegistry::eTruncate) );
  121.     assert( m_Registry.Set("Section4", "Name44", "n V440 V441 rn",
  122.                            CNcbiRegistry::ePersistent) );
  123.     assert( m_Registry.Set("r Section4", "  trName45",
  124.                            "rn V450 V451  n  ",
  125.                            CNcbiRegistry::ePersistent) );
  126.     assert( m_Registry.Set("Section4 n", "  Name46  ",
  127.                            "nnV460" n t nt",
  128.                            CNcbiRegistry::ePersistent) );
  129.     assert( m_Registry.Set(" Section4", "Name46T", "nnV460" n t nt",
  130.                            CNcbiRegistry::ePersistent |
  131.                            CNcbiRegistry::eTruncate) );
  132.     assert( m_Registry.Set("Section4", "Name47",
  133.                            "470n471\n 472\n473\",
  134.                            CNcbiRegistry::ePersistent) );
  135.     assert( m_Registry.Set("Section4", "Name47T",
  136.                            "470n471\n 472\n473\",
  137.                            CNcbiRegistry::ePersistent |
  138.                            CNcbiRegistry::eTruncate) );
  139.     assert( m_Registry.Set("Section4", "Name48", test_str,
  140.                            CNcbiRegistry::ePersistent) );
  143.     assert( m_Registry.Set("Section5", "Name51", "Section5/Name51",
  144.                            CNcbiRegistry::ePersistent) );
  145.     assert( m_Registry.Set("_Section_5", "Name51", "_Section_5/Name51",
  146.                            CNcbiRegistry::ePersistent) );
  147.     assert( m_Registry.Set("_Section_5_", "_Name52", "_Section_5_/_Name52",
  148.                            CNcbiRegistry::ePersistent) );
  149.     assert( m_Registry.Set("_Section_5_", "Name52", "_Section_5_/Name52",
  150.                            CNcbiRegistry::ePersistent) );
  151.     assert( m_Registry.Set("_Section_5_", "_Name53_", "_Section_5_/_Name53_",
  152.                            CNcbiRegistry::ePersistent) );
  153.     assert( m_Registry.Set("Section-5.6", "Name-5.6", "Section-5.6/Name-5.6",
  154.                            CNcbiRegistry::ePersistent) );
  155.     assert( m_Registry.Set("-Section_5", ".Name.5-3", "-Section_5/.Name.5-3",
  156.                            CNcbiRegistry::ePersistent) );
  158.     // Numeric conversions
  159.     assert( m_Registry.Set("Section_61", "Int_Good", "12345",
  160.                            CNcbiRegistry::ePersistent) );
  161.     assert( m_Registry.Set("Section_61", "Bool_Good", "true",
  162.                            CNcbiRegistry::ePersistent) );
  163.     assert( m_Registry.Set("Section_61", "Double_Good", "45.98",
  164.                            CNcbiRegistry::ePersistent) );
  166.     assert( m_Registry.Set("Section_62", "Int_Bad", "bad_int",
  167.                            CNcbiRegistry::ePersistent) );
  168.     assert( m_Registry.Set("Section_62", "Bool_Bad", "bad_bool",
  169.                            CNcbiRegistry::ePersistent) );
  170.     assert( m_Registry.Set("Section_62", "Double_Bad", "bad_double",
  171.                            CNcbiRegistry::ePersistent) );
  173.     assert( m_Registry.GetInt   ("Section_61", "Int_Good",    999)   == 12345);
  174.     assert( m_Registry.GetBool  ("Section_61", "Bool_Good",   false) == true);
  175.     assert( m_Registry.GetDouble("Section_61", "Double_Good", 9.99)  == 45.98);
  177.     assert( m_Registry.GetInt   ("Section_61", "Undef", 999)   == 999);
  178.     assert( m_Registry.GetBool  ("Section_61", "Undef", false) == false);
  179.     assert( m_Registry.GetDouble("Section_61", "Undef", 9.99)  == 9.99);
  181.     assert( m_Registry.GetInt   ("Section_62", "Int_Bad",
  182.                                  999, 0, CNcbiRegistry::eReturn)   == 999);
  183.     assert( m_Registry.GetBool  ("Section_62", "Bool_Bad",
  184.                                  false, 0, CNcbiRegistry::eReturn) == false);
  185.     assert( m_Registry.GetDouble("Section_62", "Double_Bad",
  186.                                  9.99, 0, CNcbiRegistry::eReturn)  == 9.99);
  188.     bool ex_int = false;
  189.     try {
  190.         (void) m_Registry.GetInt("Section_62", "Int_Bad", 999);
  191.     } catch (CException& ) {
  192.         ex_int = true;
  193.     }
  194.     assert( ex_int );
  196.     bool ex_bool = false;
  197.     try {
  198.         (void) m_Registry.GetBool("Section_62", "Bool_Bad", false);
  199.     } catch (CException& ) {
  200.         ex_bool = true;
  201.     }
  202.     assert( ex_bool );
  204.     bool ex_double = false;
  205.     try {
  206.         (void) m_Registry.GetDouble("Section_62", "Double_Bad", 9.99);
  207.     } catch (CException& ) {
  208.         ex_double = true;
  209.     }
  210.     assert( ex_double );
  212.     m_Registry.EnumerateSections(&sections);
  213.     assert( find(sections.begin(), sections.end(), "Section1")
  214.             != sections.end() );
  215.     assert( !sections.empty() );
  217.     // Dump
  218.     assert ( m_Registry.Write(os) );
  219.     os << '';
  220.     os_str = os.str();
  221.     os.freeze(false);
  223.     }}
  225.     // "Persistent" load
  226.     CNcbiIstrstream is1(os_str);
  227.     CNcbiRegistry   reg1(is1);
  228.     assert(  reg1.Get("Section2", "Name21", CNcbiRegistry::ePersistent) ==
  229.              "Val21" );
  230.     assert(  reg1.Get("Section2", "Name21") == "Val21" );
  231.     assert( !reg1.Set("Section2", "Name21", NcbiEmptyString) );
  232.     assert( !reg1.Set("Section2", "Name21", NcbiEmptyString,
  233.                       CNcbiRegistry::ePersistent |
  234.                       CNcbiRegistry::eNoOverride) );
  235.     assert( !reg1.Empty() );
  236.     assert(  reg1.Set("Section2", "Name21", NcbiEmptyString,
  237.                       CNcbiRegistry::ePersistent) );
  239.     // "Transient" load
  240.     CNcbiIstrstream is2(os_str);
  241.     CNcbiRegistry  reg2(is2, CNcbiRegistry::eTransient);
  242.     assert(  reg2.Get("Section2", "Name21",
  243.                       CNcbiRegistry::ePersistent).empty() );
  244.     assert(  reg2.Get("Section2", "Name21") == "Val21" );
  245.     assert( !reg2.Set("Section2", "Name21", NcbiEmptyString,
  246.                       CNcbiRegistry::ePersistent) );
  247.     assert( !reg2.Set("Section2", "Name21", NcbiEmptyString,
  248.                       CNcbiRegistry::ePersistent |
  249.                       CNcbiRegistry::eNoOverride) );
  250.     assert( !reg2.Empty() );
  251.     assert(  reg2.Set("Section2", "Name21", NcbiEmptyString) );
  253.     assert( reg2.Get("Section4", "Name41")  == "Val410 Val411 Val413" );
  254.     assert( reg2.Get("Section4", "Name42")  == "V420 V421nV422 V423 "" );
  255.     assert( reg2.Get("Section4", "Name43")  ==
  256.             " tV430 V431  n V432 V433 ");
  257.     assert( reg2.Get("Section4", "Name43T") == "V430 V431  n V432 V433" );
  258.     assert( reg2.Get("Section4", "Name44")  == "n V440 V441 rn" );
  259.     assert( reg2.Get("Section4", "NaMe45")  == "rn V450 V451  n  " );
  260.     assert( reg2.Get("SecTIOn4", "NAme46")  == "nnV460" n t nt" );
  261.     assert( reg2.Get("Section4", "Name46T") == "nnV460" n t n" );
  262.     assert( reg2.Get("Section4", "Name47")  == "470n471\n 472\n473\" );
  263.     assert( reg2.Get("Section4", "Name47T") == "470n471\n 472\n473\" );
  264.     assert( reg2.Get("Section4", "Name48")  == test_str );
  266.     assert( reg2.Get(" Section5",    "Name51 ")   == "Section5/Name51" );
  267.     assert( reg2.Get("_Section_5",   " Name51")   == "_Section_5/Name51" );
  268.     assert( reg2.Get(" _Section_5_", " _Name52")  == "_Section_5_/_Name52");
  269.     assert( reg2.Get("_Section_5_ ", "Name52")    == "_Section_5_/Name52");
  270.     assert( reg2.Get("_Section_5_",  "_Name53_ ") ==
  271.             "_Section_5_/_Name53_" );
  272.     assert( reg2.Get(" Section-5.6", "Name-5.6 ") == "Section-5.6/Name-5.6");
  273.     assert( reg2.Get("-Section_5",   ".Name.5-3") == "-Section_5/.Name.5-3");
  275.     return true;
  276. }
  278. bool CTestRegApp::TestApp_Init(void)
  279. {
  280.     NcbiCout << NcbiEndl
  281.              << "Testing NCBIREG with "
  282.              << NStr::IntToString(s_NumThreads)
  283.              << " threads..."
  284.              << NcbiEndl;
  286.     assert( m_Registry.Empty() );
  288.     list<string> sections;
  289.     m_Registry.EnumerateSections(&sections);
  290.     assert( sections.empty() );
  292.     list<string> entries;
  293.     m_Registry.EnumerateEntries(NcbiEmptyString, &entries);
  294.     assert( entries.empty() );
  296.     return true;
  297. }
  299. bool CTestRegApp::TestApp_Exit(void)
  300. {
  301.     m_Registry.Clear();
  302.     assert( m_Registry.Empty() );
  304.     NcbiCout << "Test completed successfully!"
  305.              << NcbiEndl << NcbiEndl;
  306.     return true;
  307. }
  311. /////////////////////////////////////////////////////////////////////////////
  312. //  MAIN
  314. int main(int argc, const char* argv[]) 
  315. {
  316.     CTestRegApp app;
  317.     return app.AppMain(argc, argv, 0, eDS_Default, 0);
  318. }
  322. /*
  323.  * ===========================================================================
  324.  * $Log: test_ncbireg_mt.cpp,v $
  325.  * Revision 1000.1  2004/06/01 19:10:16  gouriano
  326.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.8
  327.  *
  328.  * Revision 6.8  2004/05/14 13:59:51  gorelenk
  329.  * Added include of ncbi_pch.hpp
  330.  *
  331.  * Revision 6.7  2003/05/14 20:57:30  ivanov
  332.  * Made WIN to UNIX eol conversion
  333.  *
  334.  * Revision 6.6  2003/05/14 20:49:04  ivanov
  335.  * Added MT lock for m_Registry protection
  336.  *
  337.  * Revision 6.5  2003/01/31 16:48:32  lavr
  338.  * Remove unused variable "e" from catch() clause
  339.  *
  340.  * Revision 6.4  2002/12/30 23:23:09  vakatov
  341.  * + GetString(), GetInt(), GetBool(), GetDouble() -- with defaults,
  342.  * conversions and error handling control (to extend Get()'s functionality).
  343.  *
  344.  * Revision 6.3  2002/04/23 13:11:50  gouriano
  345.  * test_mt.cpp/hpp moved into another location
  346.  *
  347.  * Revision 6.2  2002/04/16 18:49:08  ivanov
  348.  * Centralize threatment of assert() in tests.
  349.  * Added #include <test/test_assert.h>. CVS log moved to end of file.
  350.  *
  351.  * Revision 6.1  2001/04/06 15:57:09  grichenk
  352.  * Initial revision
  353.  *
  354.  * ===========================================================================
  355.  */