CoreTests_ValueVector.cpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:13k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  * 
  4.  * Copyright (c) 1999-2000 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  * 
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  * 
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer. 
  13.  * 
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  * 
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:  
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  * 
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written 
  29.  *    permission, please contact apache@apache.org.
  30.  * 
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  * 
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  * 
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  56. /*
  57.  * $Log: CoreTests_ValueVector.cpp,v $
  58.  * Revision 1.5  2002/02/01 22:46:28  peiyongz
  59.  * sane_include
  60.  *
  61.  * Revision 1.4  2000/03/02 19:55:49  roddey
  62.  * This checkin includes many changes done while waiting for the
  63.  * 1.1.0 code to be finished. I can't list them all here, but a list is
  64.  * available elsewhere.
  65.  *
  66.  * Revision 1.3  2000/02/06 07:48:40  rahulj
  67.  * Year 2K copyright swat.
  68.  *
  69.  * Revision 1.2  2000/01/19 00:59:07  roddey
  70.  * Get rid of dependence on old utils output streams.
  71.  *
  72.  * Revision 1.1.1.1  1999/11/09 01:02:10  twl
  73.  * Initial checkin
  74.  *
  75.  * Revision 1.2  1999/11/08 20:42:29  rahul
  76.  * Swat for adding in Product name and CVS comment log variable.
  77.  *
  78.  */
  79. // ---------------------------------------------------------------------------
  80. //  XML4C2 includes
  81. // ---------------------------------------------------------------------------
  82. #include "CoreTests.hpp"
  83. #include <xercesc/util/ValueVectorOf.hpp>
  84. #include <xercesc/util/ArrayIndexOutOfBoundsException.hpp>
  85. // ---------------------------------------------------------------------------
  86. //  Force a full instantiation of our vector and its enumerator, just to
  87. //  insure that all methods get instantiated and compiled.
  88. // ---------------------------------------------------------------------------
  89. template ValueVectorOf<int>;
  90. template ValueVectorEnumerator<int>;
  91. // ---------------------------------------------------------------------------
  92. //  Templatized testing code. These allow the exact same tests to be run
  93. //  for any number of instantiation types over the by value vectors.
  94. // ---------------------------------------------------------------------------
  95. template <class T> bool commonValueTests()
  96. {
  97.     const unsigned int  testMax = 3;
  98.     bool                caughtIt;
  99.     // Create a vector of testMax of the instantiation type
  100.     ValueVectorOf<T> testVec(testMax);
  101.     // Make sure the initial capacity is what we set
  102.     if (testVec.curCapacity() != testMax)
  103.     {
  104.         std::wcout << L"   Init capacity was bad" << std::endl;
  105.         return false;
  106.     }
  107.     // Make sure the initial size is zero
  108.     if (testVec.size() != 0)
  109.     {
  110.         std::wcout << L"   Init size was bad" << std::endl;
  111.         return false;
  112.     }
  113.     // Test value for adding
  114.     T testElem;
  115.     // Add a value and check the count is 1
  116.     testVec.addElement(testElem);
  117.     if (testVec.size() != 1)
  118.     {
  119.         std::wcout << L"   Adding one element caused bad size" << std::endl;
  120.         return false;
  121.     }
  122.     // Add another value and check the count is 2
  123.     testVec.addElement(testElem);
  124.     if (testVec.size() != 2)
  125.     {
  126.         std::wcout << L"   Adding another element caused bad size" << std::endl;
  127.         return false;
  128.     }
  129.     // Test that the two of them are the same
  130.     if (testVec.elementAt(0) != testVec.elementAt(1))
  131.     {
  132.         std::wcout << L"   First two elements did not match" << std::endl;
  133.         return false;
  134.     }
  135.     // Add two more, which should cause an expansion of the vector
  136.     testVec.addElement(testElem);
  137.     testVec.addElement(testElem);
  138.     if (testVec.curCapacity() == testMax)
  139.     {
  140.         std::wcout  << L"   Adding another element failed to cause an expansion"
  141.                     << std::endl;
  142.         return false;
  143.     }
  144.     // Check that we get an array bounds exception after an expansion
  145.     caughtIt = false;
  146.     try
  147.     {
  148.         testVec.elementAt(4);
  149.     }
  150.     catch(const ArrayIndexOutOfBoundsException&)
  151.     {
  152.         caughtIt = true;
  153.     }
  154.     if (!caughtIt)
  155.     {
  156.         std::wcout  << L"   Failed to catch array bounds error at element 4"
  157.                     << std::endl;
  158.         return false;
  159.     }
  160.     // Remove an item and see if the count went down by one
  161.     testVec.removeElementAt(0);
  162.     if (testVec.size() != 3)
  163.     {
  164.         std::wcout  << L"   Removing an element did not adjust size correctly"
  165.                     << std::endl;
  166.         return false;
  167.     }
  168.     // Remove the rest of them and make sure we hit zero
  169.     testVec.removeElementAt(0);
  170.     testVec.removeElementAt(0);
  171.     testVec.removeElementAt(0);
  172.     if (testVec.size() != 0)
  173.     {
  174.         std::wcout  << L"   Removing all elements did not zero the size"
  175.                     << std::endl;
  176.         return false;
  177.     }
  178.     // Check that we get an array bounds exception now still
  179.     caughtIt = false;
  180.     try
  181.     {
  182.         testVec.elementAt(0);
  183.     }
  184.     catch(const ArrayIndexOutOfBoundsException&)
  185.     {
  186.         caughtIt = true;
  187.     }
  188.     if (!caughtIt)
  189.     {
  190.         std::wcout  << L"   Failed to catch array bounds error at element 0"
  191.                     << std::endl;
  192.         return false;
  193.     }
  194.     // Add a few more elements back in, via insertion
  195.     testVec.insertElementAt(testElem, 0);
  196.     testVec.insertElementAt(testElem, 0);
  197.     testVec.insertElementAt(testElem, 0);
  198.     if (testVec.size() != 3)
  199.     {
  200.         std::wcout << L"   Inserting elements caused bad size" << std::endl;
  201.         return false;
  202.     }
  203.     // Now do a remove all elements
  204.     testVec.removeAllElements();
  205.     if (testVec.size() != 0)
  206.     {
  207.         std::wcout << L"   removeAllElements caused bad size" << std::endl;
  208.         return false;
  209.     }
  210.     return true;
  211. }
  212. template <class T> bool extendedValueTests()
  213. {
  214.     const unsigned int testMax = 8;
  215.     // Create a test vector and put in ascending test values
  216.     ValueVectorOf<T> testVec(testMax);
  217.     testVec.addElement(T(0));
  218.     testVec.addElement(T(1));
  219.     testVec.addElement(T(2));
  220.     testVec.addElement(T(3));
  221.     testVec.addElement(T(4));
  222.     testVec.addElement(T(5));
  223.     testVec.addElement(T(6));
  224.     testVec.addElement(T(7));
  225.     // Now check that they went in that way
  226.     unsigned int index;
  227.     for (index = 0; index < testMax; index++)
  228.     {
  229.         if (testVec.elementAt(index) != T(index))
  230.         {
  231.             std::wcout  << L"   addElement put elements in wrong order"
  232.                         << std::endl;
  233.             return false;
  234.         }
  235.     }
  236.     // Remove the zero'th element and test again
  237.     testVec.removeElementAt(0);
  238.     for (index = 0; index < testMax-1; index++)
  239.     {
  240.         if (testVec.elementAt(index) != T(index+1))
  241.         {
  242.             std::wcout  << L"   removeElement at head removed wrong element"
  243.                         << std::endl;
  244.             return false;
  245.         }
  246.     }
  247.     // Test edge case by removing last element and test again
  248.     testVec.removeElementAt(6);
  249.     for (index = 0; index < testMax-2; index++)
  250.     {
  251.         if (testVec.elementAt(index) != T(index+1))
  252.         {
  253.             std::wcout  << L"   removeElement at end removed wrong element"
  254.                         << std::endl;
  255.             return false;
  256.         }
  257.     }
  258.     return true;
  259. }
  260. // ---------------------------------------------------------------------------
  261. //  Local functions
  262. // ---------------------------------------------------------------------------
  263. static bool doBasicTests()
  264. {
  265.     bool retVal = true;
  266.     //
  267.     // Do the common value vector tests for ints, bools and strings.
  268.     //
  269.     std::wcout << L"Testing ValueVectorOf<int>, common tests" << std::endl;
  270.     if (!commonValueTests<int>())
  271.     {
  272.         std::wcout << L"ValueVectorOf<int> failed" << std::endl;
  273.         retVal = false;
  274.     }
  275.      else
  276.     {
  277.         std::wcout << L"ValueVectorOf<int> passed" << std::endl;
  278.     }
  279.     std::wcout << std::endl;
  280.     std::wcout << L"Testing ValueVectorOf<bool>, common tests" << std::endl;
  281.     if (!commonValueTests<bool>())
  282.     {
  283.         std::wcout << L"ValueVectorOf<bool> failed" << std::endl;
  284.         retVal = false;
  285.     }
  286.      else
  287.     {
  288.         std::wcout << L"ValueVectorOf<bool> passed" << std::endl;
  289.     }
  290.     std::wcout << std::endl;
  291.     //
  292.     //  And now do the second round of extended tests. These require that
  293.     //  the instantiation type be of a fundamental value, because its going
  294.     //  to test element ordering issues.
  295.     //
  296.     std::wcout << L"Testing ValueVectorOf<int>, extended tests" << std::endl;
  297.     if (!extendedValueTests<int>())
  298.     {
  299.         std::wcout << L"Extended ValueVectorOf<int> failed" << std::endl;
  300.         retVal = false;
  301.     }
  302.      else
  303.     {
  304.         std::wcout << L"Extended ValueVectorOf<int> passed" << std::endl;
  305.     }
  306.     std::wcout << std::endl;
  307.     return retVal;
  308. }
  309. static bool enumTests()
  310. {
  311.     // Create a vector and fill it in with some known values
  312.     ValueVectorOf<unsigned int> testVec(32);
  313.     unsigned int index;
  314.     for (index = 0; index < 32; index++)
  315.         testVec.addElement(index);
  316.     // Create an enumeration for it
  317.     ValueVectorEnumerator<unsigned int> enumTest(&testVec);
  318.     index = 0;
  319.     while (enumTest.hasMoreElements())
  320.     {
  321.         if (enumTest.nextElement() != index++)
  322.         {
  323.             std::wcout  << L"    Enumerator sequence was incorrect"
  324.                         << std::endl;
  325.             return false;
  326.         }
  327.     }
  328.     if (index != 32)
  329.     {
  330.         std::wcout  << L"    Enumerator did not enum enough elements"
  331.                     << std::endl;
  332.         return false;
  333.     }
  334.     return true;
  335. }
  336. // ---------------------------------------------------------------------------
  337. //  Test entry point
  338. // ---------------------------------------------------------------------------
  339. bool testValueVector()
  340. {
  341.     std::wcout  << L"----------------------------------n"
  342.                 << L"Testing ValueVectorOf template classn"
  343.                 << L"----------------------------------" << std::endl;
  344.     bool retVal = true;
  345.     try
  346.     {
  347.         // Do the basic suite of tests, which is templatized
  348.         if (!doBasicTests())
  349.             retVal = false;
  350.         // Test the enumerator
  351.         std::wcout << L"Testing ValueVectorEnumerator" << std::endl;
  352.         if (!enumTests())
  353.         {
  354.             std::wcout << L"ValueVectorEnumeration failed" << std::endl;
  355.             retVal = false;
  356.         }
  357.          else
  358.         {
  359.             std::wcout << L"ValueVectorEnumeration passed" << std::endl;
  360.         }
  361.         std::wcout << std::endl;
  362.     }
  363.     catch(const XMLException& toCatch)
  364.     {
  365.         std::wcout  << L"  ERROR: Unexpected exception!n   Msg: "
  366.                     << toCatch.getMessage() << std::endl;
  367.         return false;
  368.     }
  369.     return retVal;
  370. }