string_test.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:64k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include "./string_test.h"
  36. #include "hx_ut_debug.h"
  37. #include "ut_param_util.h"
  38. #include "./param_util.h"
  39. HLXStringTest::HLXStringTest() :
  40.     m_pA(0),
  41.     m_pB(0),
  42.     m_ANthFieldState(0),
  43.     m_BNthFieldState(0),
  44.     m_pABuffer(0),
  45.     m_pBBuffer(0)
  46. {}
  47. HLXStringTest::~HLXStringTest()
  48. {
  49.     delete m_pA;
  50.     delete m_pB;
  51. }
  52. const char* HLXStringTest::DefaultCommandLine() const
  53. {
  54.     return "tstring tstring.in";
  55. }
  56.     
  57. void HLXStringTest::GetCommandInfo(UTVector<HLXUnitTestCmdInfo*>& cmds)
  58. {
  59.     cmds.Resize(65);
  60.     int i = 0;
  61.     HX_ASSERT(i < cmds.Nelements());
  62.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  63.         this, 
  64.         "CHXString()",
  65.         &HLXStringTest::HandleConstruct1Cmd,
  66.         2);
  67.     HX_ASSERT(i < cmds.Nelements());
  68.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  69.         this, 
  70.         "CHXString(CHXString)",
  71.         &HLXStringTest::HandleConstruct2Cmd,
  72.         3);
  73.     HX_ASSERT(i < cmds.Nelements());
  74.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  75.         this, 
  76.         "CHXString(char,int)",
  77.         &HLXStringTest::HandleConstruct3Cmd,
  78.         4);
  79.     HX_ASSERT(i < cmds.Nelements());
  80.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  81.         this, 
  82.         "CHXString(char*)",
  83.         &HLXStringTest::HandleConstruct4Cmd,
  84.         3);
  85.     HX_ASSERT(i < cmds.Nelements());
  86.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  87.         this, 
  88.         "CHXString(char*,int)",
  89.         &HLXStringTest::HandleConstruct5Cmd,
  90.         4);
  91.     HX_ASSERT(i < cmds.Nelements());
  92.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  93.         this, 
  94.         "CHXString(uchar*)",
  95.         &HLXStringTest::HandleConstruct6Cmd,
  96.         3);
  97.     HX_ASSERT(i < cmds.Nelements());
  98.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  99.         this, 
  100.         "GetLength",
  101.         &HLXStringTest::HandleGetLengthCmd,
  102.         3);
  103.     HX_ASSERT(i < cmds.Nelements());
  104.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  105.         this, 
  106.         "IsEmpty",
  107.         &HLXStringTest::HandleIsEmptyCmd,
  108.         3);
  109.     HX_ASSERT(i < cmds.Nelements());
  110.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  111.         this, 
  112.         "Empty",
  113.         &HLXStringTest::HandleEmptyCmd,
  114.         2);
  115.     HX_ASSERT(i < cmds.Nelements());
  116.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  117.         this, 
  118.         "(char*)",
  119.         &HLXStringTest::HandleCharStarOpCmd,
  120.         3,999);                 // (char*) A|B <expected> [... <alternate returns>]
  121.     HX_ASSERT(i < cmds.Nelements());
  122.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  123.         this,
  124.         "GetAt",
  125.         &HLXStringTest::HandleGetAtCmd,
  126.         4);                     // GetAt A|B <index> <expected char return>
  127.     HX_ASSERT(i < cmds.Nelements());
  128.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  129.         this,
  130.         "SetAt",
  131.         &HLXStringTest::HandleSetAtCmd,
  132.         4);                     // SetAt A|B <index> <char>
  133.     HX_ASSERT(i < cmds.Nelements());
  134.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  135.         this,
  136.         "[]",
  137.         &HLXStringTest::HandleSubscriptCmd,
  138.         4);                     // [] A|B <index> <expected char return>
  139.     // XXXSAB: don't forget to verify that return value ref is same as A|B
  140.     //         on all these assignment ops.
  141.     HX_ASSERT(i < cmds.Nelements());
  142.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  143.         this,
  144.         "=CHXString",
  145.         &HLXStringTest::HandleAssignOp1Cmd,
  146.         3);                     // =CHXString A|B <from string: A|B>
  147.     HX_ASSERT(i < cmds.Nelements());
  148.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  149.         this,
  150.         "=char",
  151.         &HLXStringTest::HandleAssignOp2Cmd,
  152.         3);                     // =char A|B <from char>
  153.     HX_ASSERT(i < cmds.Nelements());
  154.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  155.         this,
  156.         "=char*",
  157.         &HLXStringTest::HandleAssignOp3Cmd,
  158.         3);                     // =char* A|B <from string>
  159.     HX_ASSERT(i < cmds.Nelements());
  160.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  161.         this,
  162.         "=uchar*",
  163.         &HLXStringTest::HandleAssignOp4Cmd,
  164.         3);                     // =uchar* A|B <from string>
  165.     HX_ASSERT(i < cmds.Nelements());
  166.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  167.         this,
  168.         "+=CHXString",
  169.         &HLXStringTest::HandleAppendTo1Cmd,
  170.         3);                     // +=CHXString A|B <from string: A|B>
  171.     HX_ASSERT(i < cmds.Nelements());
  172.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  173.         this,
  174.         "+=char",
  175.         &HLXStringTest::HandleAppendTo2Cmd,
  176.         3);                     // +=char A|B <from char>
  177.     HX_ASSERT(i < cmds.Nelements());
  178.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  179.         this,
  180.         "+=char*",
  181.         &HLXStringTest::HandleAppendTo3Cmd,
  182.         3);                     // +=char* A|B <from string>
  183.     HX_ASSERT(i < cmds.Nelements());
  184.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  185.         this,
  186.         "CHXString+CHXString",
  187.         &HLXStringTest::HandleAdd1Cmd,
  188.         4);                     // CHXString+CHXString A|B A|B <expected string>
  189.     HX_ASSERT(i < cmds.Nelements());
  190.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  191.         this,
  192.         "CHXString+char",
  193.         &HLXStringTest::HandleAdd2Cmd,
  194.         4);                     // CHXString+char A|B <char> <expected string>
  195.     HX_ASSERT(i < cmds.Nelements());
  196.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  197.         this,
  198.         "char+CHXString",
  199.         &HLXStringTest::HandleAdd3Cmd,
  200.         4);                     // char+CHXString <char> A|B <expected string>
  201.     HX_ASSERT(i < cmds.Nelements());
  202.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  203.         this,
  204.         "CHXString+char*",
  205.         &HLXStringTest::HandleAdd4Cmd,
  206.         4);                     // CHXString+char* A|B <string> <expected string>
  207.     HX_ASSERT(i < cmds.Nelements());
  208.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  209.         this,
  210.         "char*+CHXString",
  211.         &HLXStringTest::HandleAdd5Cmd,
  212.         4);                     // char*+CHXString <string> A|B <expected string>
  213.     HX_ASSERT(i < cmds.Nelements());
  214.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  215.         this,
  216.         "Center",
  217.         &HLXStringTest::HandleCenterCmd,
  218.         3);                     // Center A|B <length>
  219.     HX_ASSERT(i < cmds.Nelements());
  220.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  221.         this,
  222.         "Compare",
  223.         &HLXStringTest::HandleCompareCmd,
  224.         4);                     // Compare A|B <string> <expected value>
  225.     HX_ASSERT(i < cmds.Nelements());
  226.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  227.         this,
  228.         "CompareNoCase",
  229.         &HLXStringTest::HandleCompareNoCaseCmd,
  230.         4);                     // CompareNoCase A|B <string> <expected value>
  231.     HX_ASSERT(i < cmds.Nelements());
  232.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  233.         this,
  234.         "Mid",
  235.         &HLXStringTest::HandleMidCmd,
  236.         4, 5);                  // Mid A|B <index> [<length>] <expected string>
  237.     HX_ASSERT(i < cmds.Nelements());
  238.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  239.         this,
  240.         "Left",
  241.         &HLXStringTest::HandleLeftCmd,
  242.         4);                     // Left A|B <length> <expected string>
  243.     HX_ASSERT(i < cmds.Nelements());
  244.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  245.         this,
  246.         "Right",
  247.         &HLXStringTest::HandleRightCmd,
  248.         4);                     // Right A|B <length> <expected string>
  249.     HX_ASSERT(i < cmds.Nelements());
  250.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  251.         this,
  252.         "CountFields",
  253.         &HLXStringTest::HandleCountFieldsCmd,
  254.         4);                     // CountFields A|B <delimeter char> <expected value>
  255.     HX_ASSERT(i < cmds.Nelements());
  256.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  257.         this,
  258.         "NthField",
  259.         &HLXStringTest::HandleNthFieldCmd,
  260.         5);                     // NthField A|B <delimeter char> <field index> <expected string>
  261.     HX_ASSERT(i < cmds.Nelements());
  262.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  263.         this,
  264.         "GetNthField",
  265.         &HLXStringTest::HandleGetNthFieldCmd,
  266.         5);                     // GetNthField A|B <delimeter char> <field index> <expected string>
  267.     HX_ASSERT(i < cmds.Nelements());
  268.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  269.         this,
  270.         "ResetNthFieldState",
  271.         &HLXStringTest::HandleResetNthFieldStateCmd,
  272.         2);                     // ResetNthFieldState A|B
  273.     HX_ASSERT(i < cmds.Nelements());
  274.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  275.         this,
  276.         "SpanIncluding",
  277.         &HLXStringTest::HandleSpanIncludingCmd,
  278.         4);                     // SpanIncluding A|B <string> <expected string>
  279.     HX_ASSERT(i < cmds.Nelements());
  280.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  281.         this,
  282.         "SpanExcluding",
  283.         &HLXStringTest::HandleSpanExcludingCmd,
  284.         4);                     // SpanExcluding A|B <string> <expected string>
  285.     HX_ASSERT(i < cmds.Nelements());
  286.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  287.         this,
  288.         "MakeUpper",
  289.         &HLXStringTest::HandleMakeUpperCmd,
  290.         2);                     // MakeUpper A|B
  291.     HX_ASSERT(i < cmds.Nelements());
  292.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  293.         this,
  294.         "MakeLower",
  295.         &HLXStringTest::HandleMakeLowerCmd,
  296.         2);                     // MakeLower A|B
  297.     HX_ASSERT(i < cmds.Nelements());
  298.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  299.         this,
  300.         "TrimRight",
  301.         &HLXStringTest::HandleTrimRightCmd,
  302.         2);                     // TrimRight A|B
  303.     HX_ASSERT(i < cmds.Nelements());
  304.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  305.         this,
  306.         "TrimLeft",
  307.         &HLXStringTest::HandleTrimLeftCmd,
  308.         2);                     // TrimLeft A|B
  309.     HX_ASSERT(i < cmds.Nelements());
  310.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  311.         this,
  312.         "FindChar",
  313.         &HLXStringTest::HandleFind1Cmd,
  314.         4);                     // FindChar A|B <char> <expected value>
  315.     HX_ASSERT(i < cmds.Nelements());
  316.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  317.         this,
  318.         "FindChar*",
  319.         &HLXStringTest::HandleFind2Cmd,
  320.         4);                     // FindChar* A|B <string> <expected value>
  321.     HX_ASSERT(i < cmds.Nelements());
  322.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  323.         this,
  324.         "ReverseFind",
  325.         &HLXStringTest::HandleReverseFindCmd,
  326.         4);                     // ReverseFind A|B <char> <expected value>
  327.     HX_ASSERT(i < cmds.Nelements());
  328.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  329.         this,
  330.         "FindAndReplace",
  331.         &HLXStringTest::HandleFindAndReplaceCmd,
  332.         6);                     // FindAndReplace A|B <search string> <repl string> <repl all bool> <expected value>
  333.     HX_ASSERT(i < cmds.Nelements());
  334.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  335.         this,
  336.         "FormatInt",
  337.         &HLXStringTest::HandleFormatIntCmd,
  338.         4,13);                  // FormatInt A|B <format string> <data1> [... <data10>]
  339.     HX_ASSERT(i < cmds.Nelements());
  340.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  341.         this,
  342.         "FormatLong",
  343.         &HLXStringTest::HandleFormatLongCmd,
  344.         4,13);                  // FormatLong A|B <format string> <data1> [... <data10>]
  345.     HX_ASSERT(i < cmds.Nelements());
  346.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  347.         this,
  348.         "FormatUInt",
  349.         &HLXStringTest::HandleFormatUIntCmd,
  350.         4,13);                  // FormatUInt A|B <format string> <data1> [... <data10>]
  351.     HX_ASSERT(i < cmds.Nelements());
  352.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  353.         this,
  354.         "FormatULong",
  355.         &HLXStringTest::HandleFormatULongCmd,
  356.         4,13);                  // FormatULong A|B <format string> <data1> [... <data10>]
  357.     HX_ASSERT(i < cmds.Nelements());
  358.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  359.         this,
  360.         "FormatChar",
  361.         &HLXStringTest::HandleFormatCharCmd,
  362.         4,13);                  // FormatChar A|B <format string> <data1> [... <data10>]
  363.     HX_ASSERT(i < cmds.Nelements());
  364.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  365.         this,
  366.         "FormatCharStar",
  367.         &HLXStringTest::HandleFormatCharStarCmd,
  368.         4,13);                  // FormatChar* A|B <format string> <data1> [... <data10>]
  369.     HX_ASSERT(i < cmds.Nelements());
  370.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  371.         this,
  372.         "FormatPtr",
  373.         &HLXStringTest::HandleFormatPtrCmd,
  374.         4,13);                  // FormatPtr A|B <format string> <data1> [... <data10>]
  375.     HX_ASSERT(i < cmds.Nelements());
  376.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  377.         this,
  378.         "FormatDouble",
  379.         &HLXStringTest::HandleFormatDoubleCmd,
  380.         4,13);                  // FormatDouble A|B <format string> <data1> [... <data10>]
  381.     HX_ASSERT(i < cmds.Nelements());
  382.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  383.         this,
  384.         "FormatMixed",
  385.         &HLXStringTest::HandleFormatMixedCmd,
  386.         1);                     // FormatMixed
  387.     HX_ASSERT(i < cmds.Nelements());
  388.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  389.         this,
  390.         "AppendULONG",
  391.         &HLXStringTest::HandleAppendULONGCmd,
  392.         3);                     // AppendULONG A|B <ULONG value>
  393.     HX_ASSERT(i < cmds.Nelements());
  394.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  395.         this,
  396.         "AppendEndOfLine",
  397.         &HLXStringTest::HandleAppendEndOfLineCmd,
  398.         2);                     // AppendEndOfLine A|B
  399.     HX_ASSERT(i < cmds.Nelements());
  400.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  401.         this,
  402.         "GetBuffer",
  403.         &HLXStringTest::HandleGetBufferCmd,
  404.         3, 4);                  // GetBuffer A|B <length> [<expected value>]
  405.     HX_ASSERT(i < cmds.Nelements());
  406.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  407.         this,
  408.         "BufferSet",
  409.         &HLXStringTest::HandleBufferSetCmd,
  410.         3, 4);                  // BufferSet A|B [<index>] <string>
  411.     HX_ASSERT(i < cmds.Nelements());
  412.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  413.         this,
  414.         "BufferFill",
  415.         &HLXStringTest::HandleBufferFillCmd,
  416.         4, 5);                  // BufferFill A|B [<index>] <string> <repeat count>
  417.     HX_ASSERT(i < cmds.Nelements());
  418.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  419.         this,
  420.         "BufferEndString",
  421.         &HLXStringTest::HandleBufferEndStringCmd,
  422.         3);                     // BufferEndString A|B <index>
  423.     HX_ASSERT(i < cmds.Nelements());
  424.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  425.         this,
  426.         "GetBufferSetLength",
  427.         &HLXStringTest::HandleGetBufferSetLengthCmd,
  428.         4);                     // GetBufferSetLength A|B <length> <expected value>
  429. #ifdef XXXSAB
  430.     HX_ASSERT(i < cmds.Nelements());
  431.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  432.         this,
  433.         "ReleaseBuffer0",
  434.         &HLXStringTest::HandleReleaseBufferCmd,
  435.         2);                     // ReleaseBuffer0 A|B
  436.     HX_ASSERT(i < cmds.Nelements());
  437.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  438.         this,
  439.         "ReleaseBuffer1",
  440.         &HLXStringTest::HandleReleaseBufferCmd,
  441.         3);                     // ReleaseBuffer1 A|B <length>
  442. #endif /* XXXSAB */
  443.     HX_ASSERT(i < cmds.Nelements());
  444.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  445.         this,
  446.         "ReleaseBuffer",
  447.         &HLXStringTest::HandleReleaseBufferCmd,
  448.         2, 3);                  // ReleaseBuffer A|B [<length>]
  449.     HX_ASSERT(i < cmds.Nelements());
  450.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  451.         this,
  452.         "FreeExtra",
  453.         &HLXStringTest::HandleFreeExtraCmd,
  454.         2);                     // FreeExtra A|B
  455.     HX_ASSERT(i < cmds.Nelements());
  456.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  457.         this,
  458.         "GetAllocLength",
  459.         &HLXStringTest::HandleGetAllocLengthCmd,
  460.         3, 4);                  // GetAllocLength A|B <expected value> [<max expected>]
  461.     HX_ASSERT(i < cmds.Nelements());
  462.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  463.         this,
  464.         "SetMinBufSize",
  465.         &HLXStringTest::HandleSetMinBufSizeCmd,
  466.         4);                     // SetMinBufSize A|B <new value> <expected value>
  467. }
  468. HLXCmdBasedTest* HLXStringTest::Clone() const
  469. {
  470.     return new HLXStringTest();
  471. }
  472. bool HLXStringTest::HandleConstruct1Cmd(const UTVector<UTString>& info)
  473. {
  474.     SetStringObj(info[1], new CHXString());
  475.     return true;
  476. }
  477. bool HLXStringTest::HandleConstruct2Cmd(const UTVector<UTString>& info)
  478. {
  479.     bool ret = false;
  480.     CHXString* pStr = GetStringObj(info[2]);
  481.     if (!pStr)
  482.     {
  483. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  484.   (const char*)info[2]));
  485.     }
  486.     else
  487.     {
  488. SetStringObj(info[1], new CHXString(*pStr));
  489. ret = true;
  490.     }
  491.     return ret;
  492. }
  493. bool HLXStringTest::HandleConstruct3Cmd(const UTVector<UTString>& info)
  494. {
  495.     bool ret = false;
  496.     char ch;
  497.     int size;
  498.     if (!UTParamUtil::GetChar(info[2], ch) || 
  499. !UTParamUtil::GetInt(info[3], size))
  500.     {
  501. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  502.     }
  503.     else
  504.     {
  505. SetStringObj(info[1], new CHXString(ch, size));
  506. ret = true;
  507.     }
  508.     return ret;
  509. }
  510. bool HLXStringTest::HandleConstruct4Cmd(const UTVector<UTString>& info)
  511. {
  512.     SetStringObj(info[1], new CHXString((const char*)info[2]));
  513.     return true;
  514. }
  515. bool HLXStringTest::HandleConstruct5Cmd(const UTVector<UTString>& info)
  516. {
  517.     bool ret = false;
  518.     int size;
  519.     if (!UTParamUtil::GetInt(info[3], size))
  520.     {
  521. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  522.     }
  523.     else
  524.     {
  525. SetStringObj(info[1], new CHXString((const char*)(info[2]), size));
  526. ret = true;
  527.     }
  528.     return ret;
  529. }
  530. bool HLXStringTest::HandleConstruct6Cmd(const UTVector<UTString>& info)
  531. {
  532.     SetStringObj(info[1], new CHXString((const unsigned char*)(const char*)(info[2])));
  533.     return true;
  534. }
  535. bool HLXStringTest::HandleGetLengthCmd(const UTVector<UTString>& info)
  536. {
  537.     bool ret = false;
  538.     CHXString* pStr = GetStringObj(info[1]);
  539.     int expected = 0;
  540.     if (!pStr)
  541.     {
  542. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  543.   (const char*)info[1]));
  544.     }
  545.     else if (!UTParamUtil::GetInt(info[2], expected))
  546.     {
  547. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  548.     }
  549.     else if ((int)pStr->GetLength() != expected)
  550.     {
  551. DPRINTF (D_ERROR, ("Got %lu expected %dn", 
  552.    (unsigned long)pStr->GetLength(), 
  553.    expected));
  554.     }
  555.     else
  556. ret = true;
  557.     return ret;
  558. }
  559. bool HLXStringTest::HandleIsEmptyCmd(const UTVector<UTString>& info)
  560. {
  561.     bool ret = false;
  562.     CHXString* pStr = GetStringObj(info[1]);
  563.     bool expected = false;
  564.     if (!pStr)
  565.     {
  566. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  567.   (const char*)info[1]));
  568.     }
  569.     else if (!UTParamUtil::GetBool(info[2], expected))
  570.     {
  571. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  572.     }
  573.     else if ((pStr->IsEmpty() == TRUE) != expected)
  574.     {
  575. DPRINTF(D_ERROR, ("Got %d expected %dn", 
  576.   pStr->IsEmpty(),
  577.   expected));
  578.     }
  579.     else
  580. ret = true;
  581.     return ret;
  582. }
  583. bool HLXStringTest::HandleEmptyCmd(const UTVector<UTString>& info)
  584. {
  585.     bool ret = false;
  586.     CHXString* pStr = GetStringObj(info[1]);
  587.     if (!pStr)
  588.     {
  589. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  590.   (const char*)info[1]));
  591.     }
  592.     else
  593.     {
  594. pStr->Empty();
  595. ret = true;
  596.     }
  597.     return ret;
  598. }
  599. bool HLXStringTest::HandleCharStarOpCmd(const UTVector<UTString>& info)
  600. {
  601.     bool ret = false;
  602.     CHXString* pStr = GetStringObj(info[1]);
  603.     int i;
  604.     if (!pStr)
  605.     {
  606. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  607.   (const char*)info[1]));
  608.     }
  609.     for (i = 2; i < info.Nelements(); ++i)
  610.     {
  611.         if (info[i] == (const char*)*pStr)
  612.         {
  613.             ret = true;
  614.             break;
  615.         }
  616.     }
  617.     if (! ret)
  618.     {
  619. DPRINTF(D_ERROR, ("Got "%s" expected%s "%s"",
  620.                           (const char*)*pStr,
  621.                           info.Nelements() > 3 ? " one of" : "",
  622.                           (const char*)info[2]));
  623.         for (i = 3; i < info.Nelements(); ++i)
  624.             DPRINTF(D_ERROR, (", "%s"", (const char*)info[i]));
  625.         DPRINTF(D_ERROR, ("n"));
  626.     }
  627.     return ret;
  628. }
  629. bool HLXStringTest::HandleGetAtCmd(const UTVector<UTString>& info)
  630. {
  631.     bool ret = false;
  632.     CHXString* pStr = GetStringObj(info[1]);
  633.     int index, expected, got;
  634.     if (!pStr)
  635.     {
  636. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  637.   (const char*)info[1]));
  638.     }
  639.     else if (!UTParamUtil::GetInt(info[2], index))
  640.     {
  641. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  642.     }
  643.     else if ((got = pStr->GetAt(index)) != (expected = *((const char*)info[3])))
  644.     {
  645.         DPRINTF(D_ERROR, ("HLXStringTest::GetAt: Got %c[0x%02x] expected %c[0x%02x]n",
  646.                           got, got, expected, expected));
  647.     }
  648.     else ret = true;
  649.     return ret;
  650. }
  651. bool HLXStringTest::HandleSetAtCmd(const UTVector<UTString>& info)
  652. {
  653.     bool ret = false;
  654.     CHXString* pStr = GetStringObj(info[1]);
  655.     int index;
  656.     if (!pStr)
  657.     {
  658. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  659.   (const char*)info[1]));
  660.     }
  661.     else if (!UTParamUtil::GetInt(info[2], index))
  662.     {
  663. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  664.     }
  665.     else
  666.     {
  667.         ret = true;
  668.         pStr->SetAt(index, *((const char*)info[3]));
  669.     }
  670.     return ret;
  671. }
  672. #define SUBTEST(TYPE) 
  673.     if ((got = (*pStr)[(TYPE)index]) != expected) { 
  674.         DPRINTF(D_ERROR, ("operator[](" #TYPE "): Got %c[0x%02x] expected %c[0x%02x]n", 
  675.                           got, got, expected, expected)); 
  676.         ret = false; 
  677.     }
  678. bool HLXStringTest::HandleSubscriptCmd(const UTVector<UTString>& info)
  679. {
  680.     bool ret = false;
  681.     CHXString* pStr = GetStringObj(info[1]);
  682.     int index;
  683.     if (!pStr)
  684.     {
  685. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  686.   (const char*)info[1]));
  687.     }
  688.     else if (!UTParamUtil::GetInt(info[2], index))
  689.     {
  690. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  691.     }
  692.     else
  693.     {
  694.         // cycle through various subscript types and make sure that they
  695.         // all work.
  696.         char expected = *((const char*)info[3]);
  697.         char got;
  698.         ret = true;
  699.         SUBTEST(short);
  700.         SUBTEST(unsigned short);
  701.         SUBTEST(int);
  702.         SUBTEST(unsigned int);
  703.         SUBTEST(long);
  704.         SUBTEST(unsigned long);
  705.     }
  706.     return ret;
  707. }
  708. #undef SUBTEST
  709. bool HLXStringTest::HandleAssignOp1Cmd(const UTVector<UTString>& info)
  710. {
  711.     bool ret = true;
  712.     CHXString* pDest = GetStringObj(info[1]);
  713.     CHXString* pSrc = GetStringObj(info[2]);
  714.     if (!pDest)
  715.     {
  716. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  717.   (const char*)info[1]));
  718.         ret = false;
  719.     }
  720.     if (!pSrc)
  721.     {
  722. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  723.   (const char*)info[2]));
  724.         ret = false;
  725.     }
  726.     if (ret)
  727.     {
  728.         const CHXString& result = (*pDest = *pSrc);
  729.         if (&result != pDest)
  730.         {
  731.             DPRINTF(D_ERROR, ("operator=(const CHXString&) didn't return object: got %p expected %pn",
  732.                               &result, pDest));
  733.             ret = false;
  734.         }
  735.     }
  736.     return ret;
  737. }
  738. bool HLXStringTest::HandleAssignOp2Cmd(const UTVector<UTString>& info)
  739. {
  740.     bool ret = false;
  741.     CHXString* pStr = GetStringObj(info[1]);
  742.     char ch = 0;
  743.     if (!pStr)
  744.     {
  745. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  746.   (const char*)info[1]));
  747.     }
  748.     else if (!UTParamUtil::GetChar(info[2], ch))
  749.     {
  750. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  751.     }
  752.     else
  753.     {
  754.         const CHXString& result = (*pStr = ch);
  755.         if (&result != pStr)
  756.         {
  757.             DPRINTF(D_ERROR, ("operator=(char) didn't return object: got %p expected %pn",
  758.                               &result, pStr));
  759.         }
  760.         else ret = true;
  761.     }
  762.     return ret;
  763. }
  764. bool HLXStringTest::HandleAssignOp3Cmd(const UTVector<UTString>& info)
  765. {
  766.     bool ret = false;
  767.     CHXString* pStr = GetStringObj(info[1]);
  768.     if (!pStr)
  769.     {
  770. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  771.   (const char*)info[1]));
  772.     }
  773.     else
  774.     {
  775.         const CHXString& result = (*pStr = (const char*)info[2]);
  776.         if (&result != pStr)
  777.         {
  778.             DPRINTF(D_ERROR, ("operator=(char) didn't return object: got %p expected %pn",
  779.                               &result, pStr));
  780.         }
  781.         else ret = true;
  782.     }
  783.     return ret;
  784. }
  785. bool HLXStringTest::HandleAssignOp4Cmd(const UTVector<UTString>& info)
  786. {
  787.     bool ret = false;
  788.     CHXString* pStr = GetStringObj(info[1]);
  789.     if (!pStr)
  790.     {
  791. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  792.   (const char*)info[1]));
  793.     }
  794.     else
  795.     {
  796.         const CHXString& result = (*pStr = (const unsigned char*)(const char*)info[2]);
  797.         if (&result != pStr)
  798.         {
  799.             DPRINTF(D_ERROR, ("operator=(char) didn't return object: got %p expected %pn",
  800.                               &result, pStr));
  801.         }
  802.         else ret = true;
  803.     }
  804.     return ret;
  805. }
  806. bool HLXStringTest::HandleAppendTo1Cmd(const UTVector<UTString>& info)
  807. {
  808.     bool ret = true;
  809.     CHXString* pDest = GetStringObj(info[1]);
  810.     CHXString* pSrc = GetStringObj(info[2]);
  811.     if (!pDest)
  812.     {
  813. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  814.   (const char*)info[1]));
  815.         ret = false;
  816.     }
  817.     if (!pSrc)
  818.     {
  819. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  820.   (const char*)info[2]));
  821.         ret = false;
  822.     }
  823.     if (ret)
  824.     {
  825.         const CHXString& result = (*pDest += *pSrc);
  826.         if (&result != pDest)
  827.         {
  828.             DPRINTF(D_ERROR, ("operator=(const CHXString&) didn't return object: got %p expected %pn",
  829.                               &result, pDest));
  830.             ret = false;
  831.         }
  832.     }
  833.     return ret;
  834. }
  835. bool HLXStringTest::HandleAppendTo2Cmd(const UTVector<UTString>& info)
  836. {
  837.     bool ret = true;
  838.     CHXString* pStr = GetStringObj(info[1]);
  839.     if (!pStr)
  840.     {
  841. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  842.   (const char*)info[1]));
  843.     }
  844.     else
  845.     {
  846.         const CHXString& result = (*pStr += *((const char*)info[2]));
  847.         if (&result != pStr)
  848.         {
  849.             DPRINTF(D_ERROR, ("operator=(const CHXString&) didn't return object: got %p expected %pn",
  850.                               &result, pStr));
  851.             ret = false;
  852.         }
  853.     }
  854.     return ret;
  855. }
  856. bool HLXStringTest::HandleAppendTo3Cmd(const UTVector<UTString>& info)
  857. {
  858.     bool ret = true;
  859.     CHXString* pStr = GetStringObj(info[1]);
  860.     if (!pStr)
  861.     {
  862. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  863.   (const char*)info[1]));
  864.     }
  865.     else
  866.     {
  867.         const CHXString& result = (*pStr += (const char*)info[2]);
  868.         if (&result != pStr)
  869.         {
  870.             DPRINTF(D_ERROR, ("operator=(const CHXString&) didn't return object: got %p expected %pn",
  871.                               &result, pStr));
  872.             ret = false;
  873.         }
  874.     }
  875.     return ret;
  876. }
  877. bool HLXStringTest::HandleAdd1Cmd(const UTVector<UTString>& info)
  878. {
  879.     bool ret = true;
  880.     CHXString* pStr1 = GetStringObj(info[1]);
  881.     CHXString* pStr2 = GetStringObj(info[2]);
  882.     if (!pStr1)
  883.     {
  884. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  885.   (const char*)info[1]));
  886.         ret = false;
  887.     }
  888.     if (!pStr2)
  889.     {
  890. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  891.   (const char*)info[2]));
  892.         ret = false;
  893.     }
  894.     if (ret)
  895.     {
  896.         CHXString got = *pStr1 + *pStr2;
  897.         if (strcmp (got, (const char*)info[3]) != 0)
  898.         {
  899.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  900.                               (const char*)got,
  901.                               (const char*)info[3]));
  902.             ret = false;
  903.         }
  904.     }
  905.     return ret;
  906. }
  907. bool HLXStringTest::HandleAdd2Cmd(const UTVector<UTString>& info)
  908. {
  909.     bool ret = true;
  910.     CHXString* pStr1 = GetStringObj(info[1]);
  911.     if (!pStr1)
  912.     {
  913. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  914.   (const char*)info[1]));
  915.         ret = false;
  916.     }
  917.     if (ret)
  918.     {
  919.         CHXString got = *pStr1 + *((const char*)info[2]);
  920.         if (strcmp (got, (const char*)info[3]) != 0)
  921.         {
  922.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  923.                               (const char*)got,
  924.                               (const char*)info[3]));
  925.             ret = false;
  926.         }
  927.     }
  928.     return ret;
  929. }
  930. bool HLXStringTest::HandleAdd3Cmd(const UTVector<UTString>& info)
  931. {
  932.     bool ret = true;
  933.     CHXString* pStr2 = GetStringObj(info[2]);
  934.     if (!pStr2)
  935.     {
  936. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  937.   (const char*)info[2]));
  938.         ret = false;
  939.     }
  940.     if (ret)
  941.     {
  942.         CHXString got = *((const char*)info[1]) + *pStr2;
  943.         if (strcmp (got, (const char*)info[3]) != 0)
  944.         {
  945.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  946.                               (const char*)got,
  947.                               (const char*)info[3]));
  948.             ret = false;
  949.         }
  950.     }
  951.     return ret;
  952. }
  953. bool HLXStringTest::HandleAdd4Cmd(const UTVector<UTString>& info)
  954. {
  955.     bool ret = true;
  956.     CHXString* pStr1 = GetStringObj(info[1]);
  957.     if (!pStr1)
  958.     {
  959. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  960.   (const char*)info[1]));
  961.         ret = false;
  962.     }
  963.     if (ret)
  964.     {
  965.         CHXString got = *pStr1 + (const char*)info[2];
  966.         if (strcmp (got, (const char*)info[3]) != 0)
  967.         {
  968.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  969.                               (const char*)got,
  970.                               (const char*)info[3]));
  971.             ret = false;
  972.         }
  973.     }
  974.     return ret;
  975. }
  976. bool HLXStringTest::HandleAdd5Cmd(const UTVector<UTString>& info)
  977. {
  978.     bool ret = true;
  979.     CHXString* pStr2 = GetStringObj(info[2]);
  980.     if (!pStr2)
  981.     {
  982. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  983.   (const char*)info[2]));
  984.         ret = false;
  985.     }
  986.     if (ret)
  987.     {
  988.         CHXString got = (const char*)info[1] + *pStr2;
  989.         if (strcmp (got, (const char*)info[3]) != 0)
  990.         {
  991.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  992.                               (const char*)got,
  993.                               (const char*)info[3]));
  994.             ret = false;
  995.         }
  996.     }
  997.     return ret;
  998. }
  999. bool HLXStringTest::HandleCenterCmd(const UTVector<UTString>& info)
  1000. {
  1001.     bool ret = false;
  1002.     CHXString* pStr = GetStringObj(info[1]);
  1003.     int len;
  1004.     if (!pStr)
  1005.     {
  1006. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1007.   (const char*)info[1]));
  1008.     }
  1009.     else if (!UTParamUtil::GetInt(info[2], len))
  1010.     {
  1011. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1012.     }
  1013.     else
  1014.     {
  1015.         pStr->Center(len);
  1016.         ret = true;
  1017.     }
  1018.     return ret;
  1019. }
  1020. bool HLXStringTest::HandleCompareCmd(const UTVector<UTString>& info)
  1021. {
  1022.     bool ret = false;
  1023.     CHXString* pStr = GetStringObj(info[1]);
  1024.     int expected = -9999;
  1025.     bool bNumberExpected = (info[3] != "-" && info[3] != "+");
  1026.     if (!pStr)
  1027.     {
  1028. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1029.   (const char*)info[1]));
  1030.     }
  1031.     else if (bNumberExpected && !UTParamUtil::GetInt(info[3], expected))
  1032.     {
  1033. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1034.     }
  1035.     else
  1036.     {
  1037.         INT32 got = pStr->Compare(info[2]);
  1038.         if ((info[3] == "+" && got > 0) ||
  1039.             (info[3] == "-" && got < 0) ||
  1040.             (bNumberExpected && got == expected)) ret = true;
  1041.         else DPRINTF(D_ERROR, ("Got %d expected %sn",
  1042.                                got, (const char*)info[3]));
  1043.     }
  1044.     return ret;
  1045. }
  1046. bool HLXStringTest::HandleCompareNoCaseCmd(const UTVector<UTString>& info)
  1047. {
  1048.     bool ret = false;
  1049.     CHXString* pStr = GetStringObj(info[1]);
  1050.     int expected = -9999;
  1051.     bool bNumberExpected = (info[3] != "-" && info[3] != "+");
  1052.     if (!pStr)
  1053.     {
  1054. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1055.   (const char*)info[1]));
  1056.     }
  1057.     else if (bNumberExpected && !UTParamUtil::GetInt(info[3], expected))
  1058.     {
  1059. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1060.     }
  1061.     else
  1062.     {
  1063.         INT32 got = pStr->CompareNoCase(info[2]);
  1064.         if ((info[3] == "+" && got > 0) ||
  1065.             (info[3] == "-" && got < 0) ||
  1066.             (bNumberExpected && got == expected)) ret = true;
  1067.         else DPRINTF(D_ERROR, ("Got %d expected %sn",
  1068.                                got, (const char*)info[3]));
  1069.     }
  1070.     return ret;
  1071. }
  1072. bool HLXStringTest::HandleMidCmd(const UTVector<UTString>& info)
  1073. {
  1074.     bool ret = true;
  1075.     CHXString* pStr = GetStringObj(info[1]);
  1076.     int index;
  1077.     const char* expected = NULL;
  1078.     int length = -9999;
  1079.     if (!pStr)
  1080.     {
  1081. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1082.   (const char*)info[1]));
  1083.         ret = false;
  1084.     }
  1085.     else if (!UTParamUtil::GetInt(info[2], index))
  1086.     {
  1087. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1088.         ret = false;
  1089.     }
  1090.     else if (info.Nelements() == 4)
  1091.     {
  1092.         expected = (const char*)info[3];
  1093.     }
  1094.     else if (info.Nelements() == 5)
  1095.     {
  1096.         if (!UTParamUtil::GetInt(info[3], length))
  1097.         {
  1098.             DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1099.             ret = false;
  1100.         }
  1101.         else expected = (const char*)info[4];
  1102.     }
  1103.     else
  1104.     {
  1105.         DPRINTF(D_ERROR, ("Bad number of arguments: %ldn",
  1106.                           (long)info.Nelements()));
  1107.         ret = false;
  1108.     }
  1109.     if (ret)
  1110.     {
  1111.         CHXString got =
  1112.             (length == -9999 ? pStr->Mid(index) : pStr->Mid(index, length));
  1113.         if (strcmp(got, expected) != 0)
  1114.         {
  1115.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1116.                               (const char*)got,
  1117.                               expected));
  1118.             ret = false;
  1119.         }
  1120.     }
  1121.     return ret;
  1122. }
  1123. bool HLXStringTest::HandleLeftCmd(const UTVector<UTString>& info)
  1124. {
  1125.     bool ret = true;
  1126.     CHXString* pStr = GetStringObj(info[1]);
  1127.     const char* expected = (const char*)info[3];
  1128.     int length = -9999;
  1129.     if (!pStr)
  1130.     {
  1131. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1132.   (const char*)info[1]));
  1133.         ret = false;
  1134.     }
  1135.     else if (!UTParamUtil::GetInt(info[2], length))
  1136.     {
  1137. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1138.         ret = false;
  1139.     }
  1140.     else
  1141.     {
  1142.         CHXString got = pStr->Left(length);
  1143.         if (strcmp(got, expected) != 0)
  1144.         {
  1145.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1146.                               (const char*)got,
  1147.                               expected));
  1148.             ret = false;
  1149.         }
  1150.     }
  1151.     return ret;
  1152. }
  1153. bool HLXStringTest::HandleRightCmd(const UTVector<UTString>& info)
  1154. {
  1155.     bool ret = true;
  1156.     CHXString* pStr = GetStringObj(info[1]);
  1157.     const char* expected = (const char*)info[3];
  1158.     int length = -9999;
  1159.     if (!pStr)
  1160.     {
  1161. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1162.   (const char*)info[1]));
  1163.         ret = false;
  1164.     }
  1165.     else if (!UTParamUtil::GetInt(info[2], length))
  1166.     {
  1167. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1168.         ret = false;
  1169.     }
  1170.     else
  1171.     {
  1172.         CHXString got = pStr->Right(length);
  1173.         if (strcmp(got, expected) != 0)
  1174.         {
  1175.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1176.                               (const char*)got,
  1177.                               expected));
  1178.             ret = false;
  1179.         }
  1180.     }
  1181.     return ret;
  1182. }
  1183. bool HLXStringTest::HandleCountFieldsCmd(const UTVector<UTString>& info)
  1184. {
  1185.     bool ret = true;
  1186.     CHXString* pStr = GetStringObj(info[1]);
  1187.     unsigned int expected;
  1188.     if (!pStr)
  1189.     {
  1190. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1191.   (const char*)info[1]));
  1192.         ret = false;
  1193.     }
  1194.     else if (!UTParamUtil::GetUInt(info[3], expected))
  1195.     {
  1196. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1197.         ret = false;
  1198.     }
  1199.     else
  1200.     {
  1201.         ULONG32 got = pStr->CountFields(*((const char*)info[2]));
  1202.         if (got != expected)
  1203.         {
  1204.             DPRINTF(D_ERROR, ("Got %lu expected %lun",
  1205.                               (unsigned long)got, (unsigned long)expected));
  1206.             ret = false;
  1207.         }
  1208.     }
  1209.     return ret;
  1210. }
  1211. bool HLXStringTest::HandleNthFieldCmd(const UTVector<UTString>& info)
  1212. {
  1213.     bool ret = true;
  1214.     CHXString* pStr = GetStringObj(info[1]);
  1215.     unsigned int field;
  1216.     if (!pStr)
  1217.     {
  1218. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1219.   (const char*)info[1]));
  1220.         ret = false;
  1221.     }
  1222.     else if (!UTParamUtil::GetUInt(info[3], field))
  1223.     {
  1224. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1225.         ret = false;
  1226.     }
  1227.     else
  1228.     {
  1229.         CHXString got = pStr->NthField(*((const char*)info[2]),
  1230.                                        (ULONG32)field);
  1231.         const char* expected = (const char*)info[4];
  1232.         if (strcmp(got, expected) != 0)
  1233.         {
  1234.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1235.                               (const char*)got, expected));
  1236.             ret = false;
  1237.         }
  1238.     }
  1239.     return ret;
  1240. }
  1241. bool HLXStringTest::HandleResetNthFieldStateCmd(const UTVector<UTString>& info)
  1242. {
  1243.     bool ret = true;
  1244.     CHXString* pStr = GetStringObj(info[1]);
  1245.     // XXXSAB: Should we have a way to set this NthFieldState thing to garbage???
  1246.     if (!pStr)
  1247.     {
  1248. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1249.   (const char*)info[1]));
  1250.         ret = false;
  1251.     }
  1252.     else
  1253.     {
  1254.         if (pStr == m_pA) m_ANthFieldState = 0;
  1255.         else if (pStr == m_pB) m_BNthFieldState = 0;
  1256.     }
  1257.     return ret;
  1258. }
  1259. bool HLXStringTest::HandleGetNthFieldCmd(const UTVector<UTString>& info)
  1260. {
  1261.     bool ret = true;
  1262.     CHXString* pStr = GetStringObj(info[1]);
  1263.     unsigned int field;
  1264.     if (!pStr)
  1265.     {
  1266. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1267.   (const char*)info[1]));
  1268.         ret = false;
  1269.     }
  1270.     else if (!UTParamUtil::GetUInt(info[3], field))
  1271.     {
  1272. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1273.         ret = false;
  1274.     }
  1275.     else
  1276.     {
  1277.         UINT64& state = (pStr == m_pA) ? m_ANthFieldState : m_BNthFieldState;
  1278.         CHXString got = pStr->GetNthField(*((const char*)info[2]),
  1279.                                           (ULONG32)field,
  1280.                                           state);
  1281.         const char* expected = (const char*)info[4];
  1282.         if (strcmp(got, expected) != 0)
  1283.         {
  1284.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1285.                               (const char*)got, expected));
  1286.             ret = false;
  1287.         }
  1288.     }
  1289.     return ret;
  1290. }
  1291. bool HLXStringTest::HandleSpanIncludingCmd(const UTVector<UTString>& info)
  1292. {
  1293.     bool ret = false;
  1294.     CHXString* pStr = GetStringObj(info[1]);
  1295.     if (!pStr)
  1296.     {
  1297. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1298.   (const char*)info[1]));
  1299.     }
  1300.     else
  1301.     {
  1302.         CHXString got = pStr->SpanIncluding((const char*)info[2]);
  1303.         if (strcmp(got, (const char*)info[3]) == 0) ret = true;
  1304.         else DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1305.                                (const char*)got, (const char*)info[3]));
  1306.     }
  1307.     return ret;
  1308. }
  1309. bool HLXStringTest::HandleSpanExcludingCmd(const UTVector<UTString>& info)
  1310. {
  1311.     bool ret = false;
  1312.     CHXString* pStr = GetStringObj(info[1]);
  1313.     if (!pStr)
  1314.     {
  1315. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1316.   (const char*)info[1]));
  1317.     }
  1318.     else
  1319.     {
  1320.         CHXString got = pStr->SpanExcluding((const char*)info[2]);
  1321.         if (strcmp(got, (const char*)info[3]) == 0) ret = true;
  1322.         else DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1323.                                (const char*)got, (const char*)info[3]));
  1324.     }
  1325.     return ret;
  1326. }
  1327. bool HLXStringTest::HandleMakeUpperCmd(const UTVector<UTString>& info)
  1328. {
  1329.     bool ret = false;
  1330.     CHXString* pStr = GetStringObj(info[1]);
  1331.     if (!pStr)
  1332.     {
  1333. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1334.   (const char*)info[1]));
  1335.     }
  1336.     else
  1337.     {
  1338.         ret = true;
  1339.         pStr->MakeUpper();
  1340.     }
  1341.     return ret;
  1342. }
  1343. bool HLXStringTest::HandleMakeLowerCmd(const UTVector<UTString>& info)
  1344. {
  1345.     bool ret = false;
  1346.     CHXString* pStr = GetStringObj(info[1]);
  1347.     if (!pStr)
  1348.     {
  1349. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1350.   (const char*)info[1]));
  1351.     }
  1352.     else
  1353.     {
  1354.         ret = true;
  1355.         pStr->MakeLower();
  1356.     }
  1357.     return ret;
  1358. }
  1359. bool HLXStringTest::HandleTrimRightCmd(const UTVector<UTString>& info)
  1360. {
  1361.     bool ret = false;
  1362.     CHXString* pStr = GetStringObj(info[1]);
  1363.     if (!pStr)
  1364.     {
  1365. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1366.   (const char*)info[1]));
  1367.     }
  1368.     else
  1369.     {
  1370.         ret = true;
  1371.         pStr->TrimRight();
  1372.     }
  1373.     return ret;
  1374. }
  1375. bool HLXStringTest::HandleTrimLeftCmd(const UTVector<UTString>& info)
  1376. {
  1377.     bool ret = false;
  1378.     CHXString* pStr = GetStringObj(info[1]);
  1379.     if (!pStr)
  1380.     {
  1381. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1382.   (const char*)info[1]));
  1383.     }
  1384.     else
  1385.     {
  1386.         ret = true;
  1387.         pStr->TrimLeft();
  1388.     }
  1389.     return ret;
  1390. }
  1391. bool HLXStringTest::HandleFind1Cmd(const UTVector<UTString>& info)
  1392. {
  1393.     bool ret = false;
  1394.     CHXString* pStr = GetStringObj(info[1]);
  1395.     int expected;
  1396.     if (!pStr)
  1397.     {
  1398. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1399.   (const char*)info[1]));
  1400.     }
  1401.     else if (!UTParamUtil::GetInt(info[3], expected))
  1402.     {
  1403. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1404.     }
  1405.     else
  1406.     {
  1407.         INT32 got = pStr->Find(*((const char*)info[2]));
  1408.         if (got == expected) ret = true;
  1409.         else DPRINTF(D_ERROR, ("Got %ld expected %ldn",
  1410.                                (long)got, (long)expected));
  1411.     }
  1412.     return ret;
  1413. }
  1414. bool HLXStringTest::HandleFind2Cmd(const UTVector<UTString>& info)
  1415. {
  1416.     bool ret = false;
  1417.     CHXString* pStr = GetStringObj(info[1]);
  1418.     int expected;
  1419.     if (!pStr)
  1420.     {
  1421. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1422.   (const char*)info[1]));
  1423.     }
  1424.     else if (!UTParamUtil::GetInt(info[3], expected))
  1425.     {
  1426. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1427.     }
  1428.     else
  1429.     {
  1430.         INT32 got = pStr->Find((const char*)info[2]);
  1431.         if (got == expected) ret = true;
  1432.         else DPRINTF(D_ERROR, ("Got %ld expected %ldn",
  1433.                                (long)got, (long)expected));
  1434.     }
  1435.     return ret;
  1436. }
  1437. bool HLXStringTest::HandleReverseFindCmd(const UTVector<UTString>& info)
  1438. {
  1439.     bool ret = false;
  1440.     CHXString* pStr = GetStringObj(info[1]);
  1441.     int expected;
  1442.     if (!pStr)
  1443.     {
  1444. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1445.   (const char*)info[1]));
  1446.     }
  1447.     else if (!UTParamUtil::GetInt(info[3], expected))
  1448.     {
  1449. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1450.     }
  1451.     else
  1452.     {
  1453.         INT32 got = pStr->ReverseFind(*((const char*)info[2]));
  1454.         if (got == expected) ret = true;
  1455.         else DPRINTF(D_ERROR, ("Got %ld expected %ldn",
  1456.                                (long)got, (long)expected));
  1457.     }
  1458.     return ret;
  1459. }
  1460. bool HLXStringTest::HandleFindAndReplaceCmd(const UTVector<UTString>& info)
  1461. {
  1462.     bool ret = false;
  1463.     CHXString* pStr = GetStringObj(info[1]);
  1464.     bool expected, bReplaceAll;
  1465.     if (!pStr)
  1466.     {
  1467. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1468.   (const char*)info[1]));
  1469.     }
  1470.     else if (!UTParamUtil::GetBool(info[4], bReplaceAll) ||
  1471.              !UTParamUtil::GetBool(info[5], expected))
  1472.     {
  1473. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1474.     }
  1475.     else
  1476.     {
  1477.         bool got = pStr->FindAndReplace((const char*)info[2],
  1478.                                         (const char*)info[3],
  1479.                                         bReplaceAll) ? true : false;
  1480.         if (got == expected) ret = true;
  1481.         else DPRINTF(D_ERROR, ("Got %s expected %sn",
  1482.                                got ? "TRUE" : "FALSE",
  1483.                                expected ? "TRUE" : "FALSE"));
  1484.     }
  1485.     return ret;
  1486. }
  1487. namespace
  1488. {
  1489.     inline bool
  1490.     GetCharStar (const char* strRep, const char*& value)
  1491.     {
  1492.         value = strRep;
  1493.         return true;
  1494.     }
  1495.     inline bool
  1496.     GetPtr (const char* strRep, void*& value)
  1497.     {
  1498.         unsigned long iValue;
  1499.         bool ret = UTParamUtil::GetULong(strRep, iValue);
  1500.         if (ret) value = (void*)iValue;
  1501.         return ret;
  1502.     }
  1503.     template <class T>
  1504.     bool HandleFormat (CHXString& str, const UTVector<UTString>& info,
  1505.                        bool (*GetValue)(const char* strRep, T& retValue))
  1506.     {
  1507.         const char* fmt = (const char*)info[2];
  1508.         T* values = new T[info.Nelements() - 3];
  1509.         
  1510.         int beginData = 3;
  1511.         int endData = info.Nelements();
  1512.         int infoIdx = beginData;
  1513.         int valIdx = 0;
  1514.         for (; infoIdx < endData; ++infoIdx, ++valIdx)
  1515.         {
  1516.             if (!GetValue(info[infoIdx], values[valIdx]))
  1517.             {
  1518.                 DPRINTF(D_ERROR, ("Failed to convert arg "%s"n",
  1519.                                   (const char*)info[infoIdx]));
  1520.                 return false;
  1521.             }
  1522.         }
  1523.         switch (valIdx)
  1524.         {
  1525.             case 1:
  1526.                 str.Format(fmt, values[0]);
  1527.                 break;
  1528.             case 2:
  1529.                 str.Format(fmt, values[0], values[1]);
  1530.                 break;
  1531.             case 3:
  1532.                 str.Format(fmt, values[0], values[1], values[2]);
  1533.                 break;
  1534.             case 4:
  1535.                 str.Format(fmt, values[0], values[1], values[2], values[3]);
  1536.                 break;
  1537.             case 5:
  1538.                 str.Format(fmt, values[0], values[1], values[2], values[3],
  1539.                            values[4]);
  1540.                 break;
  1541.             case 6:
  1542.                 str.Format(fmt, values[0], values[1], values[2], values[3],
  1543.                            values[4], values[5]);
  1544.                 break;
  1545.             case 7:
  1546.                 str.Format(fmt, values[0], values[1], values[2], values[3],
  1547.                            values[4], values[5], values[6]);
  1548.                 break;
  1549.             case 8:
  1550.                 str.Format(fmt, values[0], values[1], values[2], values[3],
  1551.                            values[4], values[5], values[6], values[7]);
  1552.                 break;
  1553.             case 9:
  1554.                 str.Format(fmt, values[0], values[1], values[2], values[3],
  1555.                            values[4], values[5], values[6], values[7],
  1556.                            values[8]);
  1557.                 break;
  1558.             case 10:
  1559.                 str.Format(fmt, values[0], values[1], values[2], values[3],
  1560.                            values[4], values[5], values[6], values[7],
  1561.                            values[8], values[9]);
  1562.                 break;
  1563.             default:
  1564.                 DPRINTF(D_ERROR, ("Unsupported num of data values (%d)n",
  1565.                                   valIdx));
  1566.                 return false;
  1567.                 break;
  1568.         }
  1569. delete [] values;
  1570.         return true;
  1571.     }
  1572. };
  1573. bool HLXStringTest::HandleFormatIntCmd(const UTVector<UTString>& info)
  1574. {
  1575.     bool ret = false;
  1576.     CHXString* pStr = GetStringObj(info[1]);
  1577.     if (!pStr)
  1578.     {
  1579. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1580.   (const char*)info[1]));
  1581.     }
  1582.     else ret = HandleFormat<int>(*pStr, info, UTParamUtil::GetInt);
  1583.     return ret;
  1584. }
  1585. bool HLXStringTest::HandleFormatLongCmd(const UTVector<UTString>& info)
  1586. {
  1587.     bool ret = false;
  1588.     CHXString* pStr = GetStringObj(info[1]);
  1589.     if (!pStr)
  1590.     {
  1591. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1592.   (const char*)info[1]));
  1593.     }
  1594.     else ret = HandleFormat<long int>(*pStr, info, UTParamUtil::GetLong);
  1595.     return ret;
  1596. }
  1597. bool HLXStringTest::HandleFormatUIntCmd(const UTVector<UTString>& info)
  1598. {
  1599.     bool ret = false;
  1600.     CHXString* pStr = GetStringObj(info[1]);
  1601.     if (!pStr)
  1602.     {
  1603. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1604.   (const char*)info[1]));
  1605.     }
  1606.     else ret = HandleFormat<unsigned int>(*pStr, info, UTParamUtil::GetUInt);
  1607.     return ret;
  1608. }
  1609. bool HLXStringTest::HandleFormatULongCmd(const UTVector<UTString>& info)
  1610. {
  1611.     bool ret = false;
  1612.     CHXString* pStr = GetStringObj(info[1]);
  1613.     if (!pStr)
  1614.     {
  1615. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1616.   (const char*)info[1]));
  1617.     }
  1618.     else ret = HandleFormat<unsigned long int>(*pStr, info, 
  1619.        UTParamUtil::GetULong);
  1620.     return ret;
  1621. }
  1622. bool HLXStringTest::HandleFormatCharCmd(const UTVector<UTString>& info)
  1623. {
  1624.     bool ret = false;
  1625.     CHXString* pStr = GetStringObj(info[1]);
  1626.     if (!pStr)
  1627.     {
  1628. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1629.   (const char*)info[1]));
  1630.     }
  1631.     else ret = HandleFormat<char>(*pStr, info, UTParamUtil::GetChar);
  1632.     return ret;
  1633. }
  1634. bool HLXStringTest::HandleFormatCharStarCmd(const UTVector<UTString>& info)
  1635. {
  1636.     bool ret = false;
  1637.     CHXString* pStr = GetStringObj(info[1]);
  1638.     if (!pStr)
  1639.     {
  1640. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1641.   (const char*)info[1]));
  1642.     }
  1643.     else ret = HandleFormat<const char*>(*pStr, info, GetCharStar);
  1644.     return ret;
  1645. }
  1646. bool HLXStringTest::HandleFormatPtrCmd(const UTVector<UTString>& info)
  1647. {
  1648.     bool ret = false;
  1649.     CHXString* pStr = GetStringObj(info[1]);
  1650.     if (!pStr)
  1651.     {
  1652. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1653.   (const char*)info[1]));
  1654.     }
  1655.     else ret = HandleFormat<void*>(*pStr, info, GetPtr);
  1656.     return ret;
  1657. }
  1658. bool HLXStringTest::HandleFormatDoubleCmd(const UTVector<UTString>& info)
  1659. {
  1660.     bool ret = false;
  1661.     CHXString* pStr = GetStringObj(info[1]);
  1662.     if (!pStr)
  1663.     {
  1664. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1665.   (const char*)info[1]));
  1666.     }
  1667.     else ret = HandleFormat<double>(*pStr, info, UTParamUtil::GetDouble);
  1668.     return ret;
  1669. }
  1670. bool HLXStringTest::HandleFormatMixedCmd(const UTVector<UTString>& /*info*/)
  1671. {
  1672.     CHXString str;
  1673.     // XXXSAB - now what???
  1674.     const char* expected = "";
  1675.     char* ptr = (char*)0x60616263;
  1676.     str.Format ("%p,%d,%u,%c",
  1677.                 ptr, (int)ptr, (unsigned int)ptr, (char)ptr);
  1678. #ifdef _WINDOWS
  1679.     expected = "60616263,1616994915,1616994915,c";
  1680. #else
  1681.     expected = "0x60616263,1616994915,1616994915,c";
  1682. #endif /* _WINDOWS */
  1683.     if (str != expected)
  1684.     {
  1685.         DPRINTF(D_ERROR, ("FormatMixed #1: Got "%s" expected "%s"n",
  1686.                           (const char*)str, expected));
  1687.         return false;
  1688.     }
  1689.     ptr = 0;
  1690.     str.Format ("%p,%p,%p,%p", ptr, ptr+1, ptr+2, ptr+3);
  1691. #ifdef _WINDOWS
  1692.     expected = "00000000,00000001,00000002,00000003";
  1693. #elif defined(_SYMBIAN)
  1694.     expected = "0x0,0x1,0x2,0x3";
  1695. #else
  1696.     expected = "(nil),0x1,0x2,0x3";
  1697. #endif /* _WINDOWS */
  1698.     if (str != expected)
  1699.     {
  1700.         DPRINTF(D_ERROR, ("FormatMixed #2: Got "%s" expected "%s"n",
  1701.                           (const char*)str, expected));
  1702.         return false;
  1703.     }
  1704.     str.Format ("%6d,%5u,%x", 1,1,1);
  1705.     expected = "     1,    1,1";
  1706.     if (str != expected)
  1707.     {
  1708.         DPRINTF(D_ERROR, ("FormatMixed #3: Got "%s" expected "%s"n",
  1709.                           (const char*)str, expected));
  1710.         return false;
  1711.     }
  1712.     return true;
  1713. }
  1714. bool HLXStringTest::HandleAppendULONGCmd(const UTVector<UTString>& info)
  1715. {
  1716.     bool ret = false;
  1717.     CHXString* pStr = GetStringObj(info[1]);
  1718.     unsigned int value;
  1719.     if (!pStr)
  1720.     {
  1721. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1722.   (const char*)info[1]));
  1723.     }
  1724.     else if (!UTParamUtil::GetUInt(info[2], value))
  1725.     {
  1726. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1727.     }
  1728.     else
  1729.     {
  1730.         ret = true;
  1731.         pStr->AppendULONG((ULONG32)value);
  1732.     }
  1733.     return ret;
  1734. }
  1735. bool HLXStringTest::HandleAppendEndOfLineCmd(const UTVector<UTString>& info)
  1736. {
  1737.     bool ret = false;
  1738.     CHXString* pStr = GetStringObj(info[1]);
  1739.     if (!pStr)
  1740.     {
  1741. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1742.   (const char*)info[1]));
  1743.     }
  1744.     else
  1745.     {
  1746.         UINT32 beforeLength = pStr->GetLength();
  1747.         pStr->AppendEndOfLine();
  1748.         // Check that the proper EOL sequence was added
  1749.         if (pStr->IsEmpty())
  1750.         {
  1751.             DPRINTF(D_ERROR, ("Failed to add EOL sequence: string is now emptyn"));
  1752.         }
  1753.         else
  1754.         {
  1755.             const char* pEnd = (const char*)*pStr + pStr->GetLength() - 1;
  1756. #if defined(_UNIX) 
  1757.             ret = (*pEnd == 'n') &&
  1758.                 (pStr->GetLength() == (beforeLength+1));
  1759. #elif defined(_MACINTOSH)
  1760.             ret = (*pEnd == 'r') &&
  1761.                 (pStr->GetLength() == (beforeLength+1));
  1762. #elif defined(_WINDOWS) || defined(_SYMBIAN)
  1763.             ret = (*(pEnd-1) == 'r' && *pEnd == 'n') &&
  1764.                 (pStr->GetLength() == (beforeLength+2));
  1765. #else
  1766.            ret = (*pEnd == 'n') &&
  1767.                 (pStr->GetLength() == (beforeLength+1));
  1768. #endif
  1769.             if (!ret)
  1770.             {
  1771.                 DPRINTF(D_ERROR, ("Failed to add EOL: got "%s"n",
  1772.                               (const char*)*pStr));
  1773.             }
  1774.         }
  1775.     }
  1776.     return ret;
  1777. }
  1778. bool HLXStringTest::HandleGetBufferCmd(const UTVector<UTString>& info)
  1779. {
  1780.     bool ret = false;
  1781.     CHXString* pStr = GetStringObj(info[1]);
  1782.     int length;
  1783.     if (!pStr)
  1784.     {
  1785. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1786.   (const char*)info[1]));
  1787.     }
  1788.     else if (!UTParamUtil::GetInt(info[2], length))
  1789.     {
  1790. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1791.     }
  1792.     else
  1793.     {
  1794.         // NOTE: If didn't get at least 4 elements in 'info', then we
  1795.         //       don't care what's in the returned buffer...
  1796.         char*& p = (pStr == m_pA ? m_pABuffer : m_pBBuffer);
  1797.         p = pStr->GetBuffer(length);
  1798.         if (!p) DPRINTF(D_ERROR, ("Got NULL from GetBuffer()n"));
  1799.         else if (info.Nelements() >= 4 &&
  1800.                  strcmp(p, (const char*)info[3]) != 0)
  1801.         {
  1802.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1803.                               p, (const char*)info[3]));
  1804.         }
  1805.         else ret = true;
  1806.     }
  1807.     return ret;
  1808. }
  1809. bool HLXStringTest::HandleGetBufferSetLengthCmd(const UTVector<UTString>& info)
  1810. {
  1811.     bool ret = false;
  1812.     CHXString* pStr = GetStringObj(info[1]);
  1813.     int length;
  1814.     if (!pStr)
  1815.     {
  1816. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1817.   (const char*)info[1]));
  1818.     }
  1819.     else if (!UTParamUtil::GetInt(info[2], length))
  1820.     {
  1821. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1822.     }
  1823.     else
  1824.     {
  1825.         // NOTE: If didn't get at least 4 elements in 'info', then we
  1826.         //       don't care what's in the returned buffer...
  1827.         char*& p = (pStr == m_pA ? m_pABuffer : m_pBBuffer);
  1828.         p = pStr->GetBufferSetLength(length);
  1829.         if (!p) DPRINTF(D_ERROR, ("Got NULL from GetBuffer()n"));
  1830.         else if (info.Nelements() >= 4 &&
  1831.                  strcmp(p, (const char*)info[3]) != 0)
  1832.         {
  1833.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1834.                               p, (const char*)info[3]));
  1835.         }
  1836.         else ret = true;
  1837.     }
  1838.     return ret;
  1839. }
  1840. bool HLXStringTest::HandleBufferSetCmd(const UTVector<UTString>& info)
  1841. {
  1842.     bool ret = false;
  1843.     CHXString* pStr = GetStringObj(info[1]);
  1844.     int index = 0;
  1845.     if (!pStr)
  1846.     {
  1847. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1848.   (const char*)info[1]));
  1849.     }
  1850.     else if (info.Nelements() >= 4 && !UTParamUtil::GetInt(info[2], index))
  1851.     {
  1852. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1853.     }
  1854.     else
  1855.     {
  1856.         char* p = (pStr == m_pA ? m_pABuffer : m_pBBuffer);
  1857.         const char* pValue = (const char*)info[info.Nelements()-1];
  1858.         memcpy (p+index, pValue, strlen(pValue)); /* Flawfinder: ignore */
  1859.         ret = true;
  1860.     }
  1861.     return ret;
  1862. }
  1863. bool HLXStringTest::HandleBufferFillCmd(const UTVector<UTString>& info)
  1864. {
  1865.     bool ret = false;
  1866.     CHXString* pStr = GetStringObj(info[1]);
  1867.     int index = 0;
  1868.     int repeat = 0;
  1869.     if (!pStr)
  1870.     {
  1871. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1872.   (const char*)info[1]));
  1873.     }
  1874.     else if (!UTParamUtil::GetInt(info[info.Nelements() - 1], repeat) ||
  1875.              (info.Nelements() >= 5 && !UTParamUtil::GetInt(info[2], index)))
  1876.     {
  1877. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1878.     }
  1879.     else
  1880.     {
  1881.         char* p = (pStr == m_pA ? m_pABuffer : m_pBBuffer);
  1882.         const char* pValue = (const char*)info[info.Nelements()-2];
  1883.         size_t len = strlen(pValue);
  1884.         for (p += index; repeat > 0; p += len, --repeat)
  1885.             memcpy (p, pValue, len); /* Flawfinder: ignore */
  1886.         
  1887.         ret = true;
  1888.     }
  1889.     return ret;
  1890. }
  1891. bool HLXStringTest::HandleBufferEndStringCmd(const UTVector<UTString>& info)
  1892. {
  1893.     bool ret = false;
  1894.     CHXString* pStr = GetStringObj(info[1]);
  1895.     int index = 0;
  1896.     if (!pStr)
  1897.     {
  1898. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1899.   (const char*)info[1]));
  1900.     }
  1901.     else if (!UTParamUtil::GetInt(info[2], index))
  1902.     {
  1903. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1904.     }
  1905.     else
  1906.     {
  1907.         char* p = (pStr == m_pA ? m_pABuffer : m_pBBuffer);
  1908.         *(p+index) = 0;
  1909.         ret = true;
  1910.     }
  1911.     return ret;
  1912. }
  1913. bool HLXStringTest::HandleReleaseBufferCmd(const UTVector<UTString>& info)
  1914. {
  1915.     bool ret = false;
  1916.     CHXString* pStr = GetStringObj(info[1]);
  1917.     int length = -9999;
  1918.     if (!pStr)
  1919.     {
  1920. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1921.   (const char*)info[1]));
  1922.     }
  1923.     else if (info.Nelements() >= 3 && !UTParamUtil::GetInt(info[2], length))
  1924.     {
  1925. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1926.     }
  1927.     else
  1928.     {
  1929.         ret = true;
  1930.         if (length == -9999) pStr->ReleaseBuffer();
  1931.         else pStr->ReleaseBuffer(length);
  1932.         if (pStr == m_pA) m_pABuffer = 0;
  1933.         else m_pBBuffer = 0;
  1934.     }
  1935.     return ret;
  1936. }
  1937. bool HLXStringTest::HandleFreeExtraCmd(const UTVector<UTString>& info)
  1938. {
  1939.     bool ret = false;
  1940.     CHXString* pStr = GetStringObj(info[1]);
  1941.     if (!pStr)
  1942.     {
  1943. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1944.   (const char*)info[1]));
  1945.     }
  1946.     else
  1947.     {
  1948.         ret = true;
  1949.         pStr->FreeExtra();
  1950.     }
  1951.     return ret;
  1952. }
  1953. bool HLXStringTest::HandleGetAllocLengthCmd(const UTVector<UTString>& info)
  1954. {
  1955.     bool ret = false;
  1956.     CHXString* pStr = GetStringObj(info[1]);
  1957.     int expected, maxExpected = -1;
  1958.     if (!pStr)
  1959.     {
  1960. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1961.   (const char*)info[1]));
  1962.     }
  1963.     else if (!UTParamUtil::GetInt(info[2], expected) ||
  1964.              (info.Nelements() >= 4 && !UTParamUtil::GetInt(info[3], maxExpected)))
  1965.     {
  1966. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1967.     }
  1968.     else if (pStr->GetAllocLength() < expected ||
  1969.              pStr->GetAllocLength() > (maxExpected > expected ?
  1970.                                        maxExpected : expected))
  1971.     {
  1972.         if (maxExpected > expected)
  1973.             DPRINTF (D_ERROR, ("Got %d expected %d..%dn",
  1974.                                pStr->GetAllocLength(), 
  1975.                                expected, maxExpected));
  1976.         else
  1977.             DPRINTF (D_ERROR, ("Got %d expected %dn", 
  1978.                                pStr->GetAllocLength(), 
  1979.                                expected));
  1980.     }
  1981.     else ret = true;
  1982.     return ret;
  1983. }
  1984. bool HLXStringTest::HandleSetMinBufSizeCmd(const UTVector<UTString>& info)
  1985. {
  1986.     bool ret = false;
  1987.     CHXString* pStr = GetStringObj(info[1]);
  1988.     int value, expected;
  1989.     if (!pStr)
  1990.     {
  1991. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1992.   (const char*)info[1]));
  1993.     }
  1994.     else if (!UTParamUtil::GetInt(info[2], value) || 
  1995.      !UTParamUtil::GetInt(info[3], expected))
  1996.     {
  1997. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1998.     }
  1999.     else
  2000.     {
  2001.         INT32 got = pStr->SetMinBufSize(value);
  2002.         if (got == expected) ret = true;
  2003. else DPRINTF (D_ERROR, ("Got %d expected %dn", got, expected));
  2004.     }
  2005.     return ret;
  2006. }
  2007. CHXString* HLXStringTest::GetStringObj(const UTString& strName)
  2008. {
  2009.     CHXString* pRet = 0;
  2010.     if (strName == "A")
  2011. pRet = m_pA;
  2012.     else if (strName == "B")
  2013. pRet = m_pB;
  2014.     else
  2015.     {
  2016. DPRINTF(D_ERROR, ("GetStringObj() : get '%s' failedn",
  2017.   (const char*)strName));
  2018.     }
  2019.     return pRet;
  2020. }
  2021. void HLXStringTest::SetStringObj(const UTString& strName, CHXString* pNewStr)
  2022. {
  2023.     if (strName == "A")
  2024.     {
  2025. delete m_pA;
  2026. m_pA = pNewStr;
  2027.     }
  2028.     else if (strName == "B")
  2029.     {
  2030. delete m_pB;
  2031. m_pB = pNewStr;
  2032.     }
  2033.     else
  2034. DPRINTF(D_ERROR, ("SetStringObj() : set '%s' failedn",
  2035.   (const char*)strName));
  2036. }