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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
string_test.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：65k
源码类别：

Symbian

开发平台：

Visual C++

string_test.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: string_test.cpp,v 1.8.42.3 2004/07/09 01:45:55 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "./string_test.h"
  52. #include "hx_ut_debug.h"
  53. #include "ut_param_util.h"
  55. #include "./param_util.h"
  57. HLXStringTest::HLXStringTest() :
  58.     m_pA(0),
  59.     m_pB(0),
  60.     m_ANthFieldState(0),
  61.     m_BNthFieldState(0),
  62.     m_pABuffer(0),
  63.     m_pBBuffer(0)
  65. {}
  67. HLXStringTest::~HLXStringTest()
  68. {
  69.     delete m_pA;
  70.     delete m_pB;
  71. }
  73. const char* HLXStringTest::DefaultCommandLine() const
  74. {
  75.     return "tstring tstring.in";
  76. }
  77.     
  78. void HLXStringTest::GetCommandInfo(UTVector<HLXUnitTestCmdInfo*>& cmds)
  79. {
  80.     cmds.Resize(65);
  82.     int i = 0;
  84.     HX_ASSERT(i < cmds.Nelements());
  85.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  86.         this, 
  87.         "CHXString()",
  88.         &HLXStringTest::HandleConstruct1Cmd,
  89.         2);
  91.     HX_ASSERT(i < cmds.Nelements());
  92.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  93.         this, 
  94.         "CHXString(CHXString)",
  95.         &HLXStringTest::HandleConstruct2Cmd,
  96.         3);
  98.     HX_ASSERT(i < cmds.Nelements());
  99.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  100.         this, 
  101.         "CHXString(char,int)",
  102.         &HLXStringTest::HandleConstruct3Cmd,
  103.         4);
  105.     HX_ASSERT(i < cmds.Nelements());
  106.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  107.         this, 
  108.         "CHXString(char*)",
  109.         &HLXStringTest::HandleConstruct4Cmd,
  110.         3);
  112.     HX_ASSERT(i < cmds.Nelements());
  113.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  114.         this, 
  115.         "CHXString(char*,int)",
  116.         &HLXStringTest::HandleConstruct5Cmd,
  117.         4);
  119.     HX_ASSERT(i < cmds.Nelements());
  120.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  121.         this, 
  122.         "CHXString(uchar*)",
  123.         &HLXStringTest::HandleConstruct6Cmd,
  124.         3);
  126.     HX_ASSERT(i < cmds.Nelements());
  127.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  128.         this, 
  129.         "GetLength",
  130.         &HLXStringTest::HandleGetLengthCmd,
  131.         3);
  133.     HX_ASSERT(i < cmds.Nelements());
  134.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  135.         this, 
  136.         "IsEmpty",
  137.         &HLXStringTest::HandleIsEmptyCmd,
  138.         3);
  140.     HX_ASSERT(i < cmds.Nelements());
  141.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  142.         this, 
  143.         "Empty",
  144.         &HLXStringTest::HandleEmptyCmd,
  145.         2);
  147.     HX_ASSERT(i < cmds.Nelements());
  148.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  149.         this, 
  150.         "(char*)",
  151.         &HLXStringTest::HandleCharStarOpCmd,
  152.         3,999);                 // (char*) A|B <expected> [... <alternate returns>]
  154.     HX_ASSERT(i < cmds.Nelements());
  155.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  156.         this,
  157.         "GetAt",
  158.         &HLXStringTest::HandleGetAtCmd,
  159.         4);                     // GetAt A|B <index> <expected char return>
  161.     HX_ASSERT(i < cmds.Nelements());
  162.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  163.         this,
  164.         "SetAt",
  165.         &HLXStringTest::HandleSetAtCmd,
  166.         4);                     // SetAt A|B <index> <char>
  169.     HX_ASSERT(i < cmds.Nelements());
  170.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  171.         this,
  172.         "[]",
  173.         &HLXStringTest::HandleSubscriptCmd,
  174.         4);                     // [] A|B <index> <expected char return>
  177.     // XXXSAB: don't forget to verify that return value ref is same as A|B
  178.     //         on all these assignment ops.
  180.     HX_ASSERT(i < cmds.Nelements());
  181.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  182.         this,
  183.         "=CHXString",
  184.         &HLXStringTest::HandleAssignOp1Cmd,
  185.         3);                     // =CHXString A|B <from string: A|B>
  187.     HX_ASSERT(i < cmds.Nelements());
  188.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  189.         this,
  190.         "=char",
  191.         &HLXStringTest::HandleAssignOp2Cmd,
  192.         3);                     // =char A|B <from char>
  194.     HX_ASSERT(i < cmds.Nelements());
  195.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  196.         this,
  197.         "=char*",
  198.         &HLXStringTest::HandleAssignOp3Cmd,
  199.         3);                     // =char* A|B <from string>
  201.     HX_ASSERT(i < cmds.Nelements());
  202.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  203.         this,
  204.         "=uchar*",
  205.         &HLXStringTest::HandleAssignOp4Cmd,
  206.         3);                     // =uchar* A|B <from string>
  208.     HX_ASSERT(i < cmds.Nelements());
  209.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  210.         this,
  211.         "+=CHXString",
  212.         &HLXStringTest::HandleAppendTo1Cmd,
  213.         3);                     // +=CHXString A|B <from string: A|B>
  215.     HX_ASSERT(i < cmds.Nelements());
  216.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  217.         this,
  218.         "+=char",
  219.         &HLXStringTest::HandleAppendTo2Cmd,
  220.         3);                     // +=char A|B <from char>
  222.     HX_ASSERT(i < cmds.Nelements());
  223.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  224.         this,
  225.         "+=char*",
  226.         &HLXStringTest::HandleAppendTo3Cmd,
  227.         3);                     // +=char* A|B <from string>
  230.     HX_ASSERT(i < cmds.Nelements());
  231.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  232.         this,
  233.         "CHXString+CHXString",
  234.         &HLXStringTest::HandleAdd1Cmd,
  235.         4);                     // CHXString+CHXString A|B A|B <expected string>
  237.     HX_ASSERT(i < cmds.Nelements());
  238.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  239.         this,
  240.         "CHXString+char",
  241.         &HLXStringTest::HandleAdd2Cmd,
  242.         4);                     // CHXString+char A|B <char> <expected string>
  244.     HX_ASSERT(i < cmds.Nelements());
  245.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  246.         this,
  247.         "char+CHXString",
  248.         &HLXStringTest::HandleAdd3Cmd,
  249.         4);                     // char+CHXString <char> A|B <expected string>
  251.     HX_ASSERT(i < cmds.Nelements());
  252.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  253.         this,
  254.         "CHXString+char*",
  255.         &HLXStringTest::HandleAdd4Cmd,
  256.         4);                     // CHXString+char* A|B <string> <expected string>
  258.     HX_ASSERT(i < cmds.Nelements());
  259.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  260.         this,
  261.         "char*+CHXString",
  262.         &HLXStringTest::HandleAdd5Cmd,
  263.         4);                     // char*+CHXString <string> A|B <expected string>
  265.     HX_ASSERT(i < cmds.Nelements());
  266.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  267.         this,
  268.         "Center",
  269.         &HLXStringTest::HandleCenterCmd,
  270.         3);                     // Center A|B <length>
  273.     HX_ASSERT(i < cmds.Nelements());
  274.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  275.         this,
  276.         "Compare",
  277.         &HLXStringTest::HandleCompareCmd,
  278.         4);                     // Compare A|B <string> <expected value>
  280.     HX_ASSERT(i < cmds.Nelements());
  281.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  282.         this,
  283.         "CompareNoCase",
  284.         &HLXStringTest::HandleCompareNoCaseCmd,
  285.         4);                     // CompareNoCase A|B <string> <expected value>
  288.     HX_ASSERT(i < cmds.Nelements());
  289.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  290.         this,
  291.         "Mid",
  292.         &HLXStringTest::HandleMidCmd,
  293.         4, 5);                  // Mid A|B <index> [<length>] <expected string>
  295.     HX_ASSERT(i < cmds.Nelements());
  296.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  297.         this,
  298.         "Left",
  299.         &HLXStringTest::HandleLeftCmd,
  300.         4);                     // Left A|B <length> <expected string>
  302.     HX_ASSERT(i < cmds.Nelements());
  303.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  304.         this,
  305.         "Right",
  306.         &HLXStringTest::HandleRightCmd,
  307.         4);                     // Right A|B <length> <expected string>
  310.     HX_ASSERT(i < cmds.Nelements());
  311.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  312.         this,
  313.         "CountFields",
  314.         &HLXStringTest::HandleCountFieldsCmd,
  315.         4);                     // CountFields A|B <delimeter char> <expected value>
  317.     HX_ASSERT(i < cmds.Nelements());
  318.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  319.         this,
  320.         "NthField",
  321.         &HLXStringTest::HandleNthFieldCmd,
  322.         5);                     // NthField A|B <delimeter char> <field index> <expected string>
  324.     HX_ASSERT(i < cmds.Nelements());
  325.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  326.         this,
  327.         "GetNthField",
  328.         &HLXStringTest::HandleGetNthFieldCmd,
  329.         5);                     // GetNthField A|B <delimeter char> <field index> <expected string>
  331.     HX_ASSERT(i < cmds.Nelements());
  332.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  333.         this,
  334.         "ResetNthFieldState",
  335.         &HLXStringTest::HandleResetNthFieldStateCmd,
  336.         2);                     // ResetNthFieldState A|B
  339.     HX_ASSERT(i < cmds.Nelements());
  340.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  341.         this,
  342.         "SpanIncluding",
  343.         &HLXStringTest::HandleSpanIncludingCmd,
  344.         4);                     // SpanIncluding A|B <string> <expected string>
  346.     HX_ASSERT(i < cmds.Nelements());
  347.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  348.         this,
  349.         "SpanExcluding",
  350.         &HLXStringTest::HandleSpanExcludingCmd,
  351.         4);                     // SpanExcluding A|B <string> <expected string>
  354.     HX_ASSERT(i < cmds.Nelements());
  355.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  356.         this,
  357.         "MakeUpper",
  358.         &HLXStringTest::HandleMakeUpperCmd,
  359.         2);                     // MakeUpper A|B
  361.     HX_ASSERT(i < cmds.Nelements());
  362.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  363.         this,
  364.         "MakeLower",
  365.         &HLXStringTest::HandleMakeLowerCmd,
  366.         2);                     // MakeLower A|B
  369.     HX_ASSERT(i < cmds.Nelements());
  370.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  371.         this,
  372.         "TrimRight",
  373.         &HLXStringTest::HandleTrimRightCmd,
  374.         2);                     // TrimRight A|B
  376.     HX_ASSERT(i < cmds.Nelements());
  377.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  378.         this,
  379.         "TrimLeft",
  380.         &HLXStringTest::HandleTrimLeftCmd,
  381.         2);                     // TrimLeft A|B
  384.     HX_ASSERT(i < cmds.Nelements());
  385.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  386.         this,
  387.         "FindChar",
  388.         &HLXStringTest::HandleFind1Cmd,
  389.         4);                     // FindChar A|B <char> <expected value>
  391.     HX_ASSERT(i < cmds.Nelements());
  392.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  393.         this,
  394.         "FindChar*",
  395.         &HLXStringTest::HandleFind2Cmd,
  396.         4);                     // FindChar* A|B <string> <expected value>
  398.     HX_ASSERT(i < cmds.Nelements());
  399.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  400.         this,
  401.         "ReverseFind",
  402.         &HLXStringTest::HandleReverseFindCmd,
  403.         4);                     // ReverseFind A|B <char> <expected value>
  405.     HX_ASSERT(i < cmds.Nelements());
  406.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  407.         this,
  408.         "FindAndReplace",
  409.         &HLXStringTest::HandleFindAndReplaceCmd,
  410.         6);                     // FindAndReplace A|B <search string> <repl string> <repl all bool> <expected value>
  413.     HX_ASSERT(i < cmds.Nelements());
  414.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  415.         this,
  416.         "FormatInt",
  417.         &HLXStringTest::HandleFormatIntCmd,
  418.         4,13);                  // FormatInt A|B <format string> <data1> [... <data10>]
  420.     HX_ASSERT(i < cmds.Nelements());
  421.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  422.         this,
  423.         "FormatLong",
  424.         &HLXStringTest::HandleFormatLongCmd,
  425.         4,13);                  // FormatLong A|B <format string> <data1> [... <data10>]
  427.     HX_ASSERT(i < cmds.Nelements());
  428.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  429.         this,
  430.         "FormatUInt",
  431.         &HLXStringTest::HandleFormatUIntCmd,
  432.         4,13);                  // FormatUInt A|B <format string> <data1> [... <data10>]
  434.     HX_ASSERT(i < cmds.Nelements());
  435.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  436.         this,
  437.         "FormatULong",
  438.         &HLXStringTest::HandleFormatULongCmd,
  439.         4,13);                  // FormatULong A|B <format string> <data1> [... <data10>]
  441.     HX_ASSERT(i < cmds.Nelements());
  442.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  443.         this,
  444.         "FormatChar",
  445.         &HLXStringTest::HandleFormatCharCmd,
  446.         4,13);                  // FormatChar A|B <format string> <data1> [... <data10>]
  448.     HX_ASSERT(i < cmds.Nelements());
  449.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  450.         this,
  451.         "FormatCharStar",
  452.         &HLXStringTest::HandleFormatCharStarCmd,
  453.         4,13);                  // FormatChar* A|B <format string> <data1> [... <data10>]
  455.     HX_ASSERT(i < cmds.Nelements());
  456.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  457.         this,
  458.         "FormatPtr",
  459.         &HLXStringTest::HandleFormatPtrCmd,
  460.         4,13);                  // FormatPtr A|B <format string> <data1> [... <data10>]
  462.     HX_ASSERT(i < cmds.Nelements());
  463.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  464.         this,
  465.         "FormatDouble",
  466.         &HLXStringTest::HandleFormatDoubleCmd,
  467.         4,13);                  // FormatDouble A|B <format string> <data1> [... <data10>]
  469.     HX_ASSERT(i < cmds.Nelements());
  470.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  471.         this,
  472.         "FormatMixed",
  473.         &HLXStringTest::HandleFormatMixedCmd,
  474.         1);                     // FormatMixed
  476.     HX_ASSERT(i < cmds.Nelements());
  477.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  478.         this,
  479.         "AppendULONG",
  480.         &HLXStringTest::HandleAppendULONGCmd,
  481.         3);                     // AppendULONG A|B <ULONG value>
  484.     HX_ASSERT(i < cmds.Nelements());
  485.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  486.         this,
  487.         "AppendEndOfLine",
  488.         &HLXStringTest::HandleAppendEndOfLineCmd,
  489.         2);                     // AppendEndOfLine A|B
  492.     HX_ASSERT(i < cmds.Nelements());
  493.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  494.         this,
  495.         "GetBuffer",
  496.         &HLXStringTest::HandleGetBufferCmd,
  497.         3, 4);                  // GetBuffer A|B <length> [<expected value>]
  499.     HX_ASSERT(i < cmds.Nelements());
  500.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  501.         this,
  502.         "BufferSet",
  503.         &HLXStringTest::HandleBufferSetCmd,
  504.         3, 4);                  // BufferSet A|B [<index>] <string>
  506.     HX_ASSERT(i < cmds.Nelements());
  507.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  508.         this,
  509.         "BufferFill",
  510.         &HLXStringTest::HandleBufferFillCmd,
  511.         4, 5);                  // BufferFill A|B [<index>] <string> <repeat count>
  513.     HX_ASSERT(i < cmds.Nelements());
  514.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  515.         this,
  516.         "BufferEndString",
  517.         &HLXStringTest::HandleBufferEndStringCmd,
  518.         3);                     // BufferEndString A|B <index>
  520.     HX_ASSERT(i < cmds.Nelements());
  521.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  522.         this,
  523.         "GetBufferSetLength",
  524.         &HLXStringTest::HandleGetBufferSetLengthCmd,
  525.         4);                     // GetBufferSetLength A|B <length> <expected value>
  527. #ifdef XXXSAB
  528.     HX_ASSERT(i < cmds.Nelements());
  529.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  530.         this,
  531.         "ReleaseBuffer0",
  532.         &HLXStringTest::HandleReleaseBufferCmd,
  533.         2);                     // ReleaseBuffer0 A|B
  535.     HX_ASSERT(i < cmds.Nelements());
  536.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  537.         this,
  538.         "ReleaseBuffer1",
  539.         &HLXStringTest::HandleReleaseBufferCmd,
  540.         3);                     // ReleaseBuffer1 A|B <length>
  541. #endif /* XXXSAB */
  543.     HX_ASSERT(i < cmds.Nelements());
  544.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  545.         this,
  546.         "ReleaseBuffer",
  547.         &HLXStringTest::HandleReleaseBufferCmd,
  548.         2, 3);                  // ReleaseBuffer A|B [<length>]
  550.     HX_ASSERT(i < cmds.Nelements());
  551.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  552.         this,
  553.         "FreeExtra",
  554.         &HLXStringTest::HandleFreeExtraCmd,
  555.         2);                     // FreeExtra A|B
  558.     HX_ASSERT(i < cmds.Nelements());
  559.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  560.         this,
  561.         "GetAllocLength",
  562.         &HLXStringTest::HandleGetAllocLengthCmd,
  563.         3, 4);                  // GetAllocLength A|B <expected value> [<max expected>]
  565.     HX_ASSERT(i < cmds.Nelements());
  566.     cmds[i++] = new HLXUnitTestCmdInfoDisp<HLXStringTest>(
  567.         this,
  568.         "SetMinBufSize",
  569.         &HLXStringTest::HandleSetMinBufSizeCmd,
  570.         4);                     // SetMinBufSize A|B <new value> <expected value>
  571. }
  573. HLXCmdBasedTest* HLXStringTest::Clone() const
  574. {
  575.     return new HLXStringTest();
  576. }
  578. bool HLXStringTest::HandleConstruct1Cmd(const UTVector<UTString>& info)
  579. {
  580.     SetStringObj(info[1], new CHXString());
  582.     return true;
  583. }
  585. bool HLXStringTest::HandleConstruct2Cmd(const UTVector<UTString>& info)
  586. {
  587.     bool ret = false;
  589.     CHXString* pStr = GetStringObj(info[2]);
  591.     if (!pStr)
  592.     {
  593. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  594.   (const char*)info[2]));
  595.     }
  596.     else
  597.     {
  598. SetStringObj(info[1], new CHXString(*pStr));
  600. ret = true;
  601.     }
  603.     return ret;
  604. }
  606. bool HLXStringTest::HandleConstruct3Cmd(const UTVector<UTString>& info)
  607. {
  608.     bool ret = false;
  610.     char ch;
  611.     int size;
  613.     if (!UTParamUtil::GetChar(info[2], ch) || 
  614. !UTParamUtil::GetInt(info[3], size))
  615.     {
  616. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  617.     }
  618.     else
  619.     {
  620. SetStringObj(info[1], new CHXString(ch, size));
  622. ret = true;
  623.     }
  625.     return ret;
  626. }
  628. bool HLXStringTest::HandleConstruct4Cmd(const UTVector<UTString>& info)
  629. {
  630.     SetStringObj(info[1], new CHXString((const char*)info[2]));
  632.     return true;
  633. }
  635. bool HLXStringTest::HandleConstruct5Cmd(const UTVector<UTString>& info)
  636. {
  637.     bool ret = false;
  638.     int size;
  640.     if (!UTParamUtil::GetInt(info[3], size))
  641.     {
  642. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  643.     }
  644.     else
  645.     {
  646. SetStringObj(info[1], new CHXString((const char*)(info[2]), size));
  648. ret = true;
  649.     }
  651.     return ret;
  652. }
  654. bool HLXStringTest::HandleConstruct6Cmd(const UTVector<UTString>& info)
  655. {
  656.     SetStringObj(info[1], new CHXString((const unsigned char*)(const char*)(info[2])));
  658.     return true;
  659. }
  661. bool HLXStringTest::HandleGetLengthCmd(const UTVector<UTString>& info)
  662. {
  663.     bool ret = false;
  665.     CHXString* pStr = GetStringObj(info[1]);
  666.     int expected = 0;
  668.     if (!pStr)
  669.     {
  670. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  671.   (const char*)info[1]));
  672.     }
  673.     else if (!UTParamUtil::GetInt(info[2], expected))
  674.     {
  675. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  676.     }
  677.     else if ((int)pStr->GetLength() != expected)
  678.     {
  679. DPRINTF (D_ERROR, ("Got %lu expected %dn", 
  680.    (unsigned long)pStr->GetLength(), 
  681.    expected));
  682.     }
  683.     else
  684. ret = true;
  686.     return ret;
  687. }
  689. bool HLXStringTest::HandleIsEmptyCmd(const UTVector<UTString>& info)
  690. {
  691.     bool ret = false;
  693.     CHXString* pStr = GetStringObj(info[1]);
  694.     bool expected = false;
  696.     if (!pStr)
  697.     {
  698. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  699.   (const char*)info[1]));
  700.     }
  701.     else if (!UTParamUtil::GetBool(info[2], expected))
  702.     {
  703. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  704.     }
  705.     else if ((pStr->IsEmpty() == TRUE) != expected)
  706.     {
  707. DPRINTF(D_ERROR, ("Got %d expected %dn", 
  708.   pStr->IsEmpty(),
  709.   expected));
  710.     }
  711.     else
  712. ret = true;
  714.     return ret;
  715. }
  717. bool HLXStringTest::HandleEmptyCmd(const UTVector<UTString>& info)
  718. {
  719.     bool ret = false;
  720.     CHXString* pStr = GetStringObj(info[1]);
  722.     if (!pStr)
  723.     {
  724. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  725.   (const char*)info[1]));
  726.     }
  727.     else
  728.     {
  729. pStr->Empty();
  730. ret = true;
  731.     }
  733.     return ret;
  734. }
  736. bool HLXStringTest::HandleCharStarOpCmd(const UTVector<UTString>& info)
  737. {
  738.     bool ret = false;
  739.     CHXString* pStr = GetStringObj(info[1]);
  740.     int i;
  742.     if (!pStr)
  743.     {
  744. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  745.   (const char*)info[1]));
  746.     }
  748.     for (i = 2; i < info.Nelements(); ++i)
  749.     {
  750.         if (info[i] == (const char*)*pStr)
  751.         {
  752.             ret = true;
  753.             break;
  754.         }
  755.     }
  757.     if (! ret)
  758.     {
  759. DPRINTF(D_ERROR, ("Got "%s" expected%s "%s"",
  760.                           (const char*)*pStr,
  761.                           info.Nelements() > 3 ? " one of" : "",
  762.                           (const char*)info[2]));
  763.         for (i = 3; i < info.Nelements(); ++i)
  764.             DPRINTF(D_ERROR, (", "%s"", (const char*)info[i]));
  765.         DPRINTF(D_ERROR, ("n"));
  766.     }
  768.     return ret;
  769. }
  771. bool HLXStringTest::HandleGetAtCmd(const UTVector<UTString>& info)
  772. {
  773.     bool ret = false;
  774.     CHXString* pStr = GetStringObj(info[1]);
  775.     int index, expected, got;
  777.     if (!pStr)
  778.     {
  779. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  780.   (const char*)info[1]));
  781.     }
  782.     else if (!UTParamUtil::GetInt(info[2], index))
  783.     {
  784. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  785.     }
  786.     else if ((got = pStr->GetAt(index)) != (expected = *((const char*)info[3])))
  787.     {
  788.         DPRINTF(D_ERROR, ("HLXStringTest::GetAt: Got %c[0x%02x] expected %c[0x%02x]n",
  789.                           got, got, expected, expected));
  790.     }
  791.     else ret = true;
  793.     return ret;
  794. }
  796. bool HLXStringTest::HandleSetAtCmd(const UTVector<UTString>& info)
  797. {
  798.     bool ret = false;
  799.     CHXString* pStr = GetStringObj(info[1]);
  800.     int index;
  802.     if (!pStr)
  803.     {
  804. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  805.   (const char*)info[1]));
  806.     }
  807.     else if (!UTParamUtil::GetInt(info[2], index))
  808.     {
  809. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  810.     }
  811.     else
  812.     {
  813.         ret = true;
  814.         pStr->SetAt(index, *((const char*)info[3]));
  815.     }
  817.     return ret;
  818. }
  820. #define SUBTEST(TYPE) 
  821.     if ((got = (*pStr)[(TYPE)index]) != expected) { 
  822.         DPRINTF(D_ERROR, ("operator[](" #TYPE "): Got %c[0x%02x] expected %c[0x%02x]n", 
  823.                           got, got, expected, expected)); 
  824.         ret = false; 
  825.     }
  826. bool HLXStringTest::HandleSubscriptCmd(const UTVector<UTString>& info)
  827. {
  828.     bool ret = false;
  829.     CHXString* pStr = GetStringObj(info[1]);
  830.     int index;
  832.     if (!pStr)
  833.     {
  834. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  835.   (const char*)info[1]));
  836.     }
  837.     else if (!UTParamUtil::GetInt(info[2], index))
  838.     {
  839. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  840.     }
  841.     else
  842.     {
  843.         // cycle through various subscript types and make sure that they
  844.         // all work.
  845.         char expected = *((const char*)info[3]);
  846.         char got;
  847.         ret = true;
  849.         SUBTEST(short);
  850.         SUBTEST(unsigned short);
  851.         SUBTEST(int);
  852.         SUBTEST(unsigned int);
  853.         SUBTEST(long);
  854.         SUBTEST(unsigned long);
  855.     }
  857.     return ret;
  858. }
  859. #undef SUBTEST
  861. bool HLXStringTest::HandleAssignOp1Cmd(const UTVector<UTString>& info)
  862. {
  863.     bool ret = true;
  864.     CHXString* pDest = GetStringObj(info[1]);
  865.     CHXString* pSrc = GetStringObj(info[2]);
  867.     if (!pDest)
  868.     {
  869. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  870.   (const char*)info[1]));
  871.         ret = false;
  872.     }
  873.     if (!pSrc)
  874.     {
  875. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  876.   (const char*)info[2]));
  877.         ret = false;
  878.     }
  880.     if (ret)
  881.     {
  882.         const CHXString& result = (*pDest = *pSrc);
  883.         if (&result != pDest)
  884.         {
  885.             DPRINTF(D_ERROR, ("operator=(const CHXString&) didn't return object: got %p expected %pn",
  886.                               &result, pDest));
  887.             ret = false;
  888.         }
  889.     }
  891.     return ret;
  892. }
  894. bool HLXStringTest::HandleAssignOp2Cmd(const UTVector<UTString>& info)
  895. {
  896.     bool ret = false;
  897.     CHXString* pStr = GetStringObj(info[1]);
  898.     char ch = 0;
  900.     if (!pStr)
  901.     {
  902. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  903.   (const char*)info[1]));
  904.     }
  905.     else if (!UTParamUtil::GetChar(info[2], ch))
  906.     {
  907. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  908.     }
  909.     else
  910.     {
  911.         const CHXString& result = (*pStr = ch);
  912.         if (&result != pStr)
  913.         {
  914.             DPRINTF(D_ERROR, ("operator=(char) didn't return object: got %p expected %pn",
  915.                               &result, pStr));
  916.         }
  917.         else ret = true;
  918.     }
  920.     return ret;
  921. }
  923. bool HLXStringTest::HandleAssignOp3Cmd(const UTVector<UTString>& info)
  924. {
  925.     bool ret = false;
  926.     CHXString* pStr = GetStringObj(info[1]);
  928.     if (!pStr)
  929.     {
  930. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  931.   (const char*)info[1]));
  932.     }
  933.     else
  934.     {
  935.         const CHXString& result = (*pStr = (const char*)info[2]);
  936.         if (&result != pStr)
  937.         {
  938.             DPRINTF(D_ERROR, ("operator=(char) didn't return object: got %p expected %pn",
  939.                               &result, pStr));
  940.         }
  941.         else ret = true;
  942.     }
  944.     return ret;
  945. }
  947. bool HLXStringTest::HandleAssignOp4Cmd(const UTVector<UTString>& info)
  948. {
  949.     bool ret = false;
  950.     CHXString* pStr = GetStringObj(info[1]);
  952.     if (!pStr)
  953.     {
  954. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  955.   (const char*)info[1]));
  956.     }
  957.     else
  958.     {
  959.         const CHXString& result = (*pStr = (const unsigned char*)(const char*)info[2]);
  960.         if (&result != pStr)
  961.         {
  962.             DPRINTF(D_ERROR, ("operator=(char) didn't return object: got %p expected %pn",
  963.                               &result, pStr));
  964.         }
  965.         else ret = true;
  966.     }
  968.     return ret;
  969. }
  971. bool HLXStringTest::HandleAppendTo1Cmd(const UTVector<UTString>& info)
  972. {
  973.     bool ret = true;
  974.     CHXString* pDest = GetStringObj(info[1]);
  975.     CHXString* pSrc = GetStringObj(info[2]);
  977.     if (!pDest)
  978.     {
  979. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  980.   (const char*)info[1]));
  981.         ret = false;
  982.     }
  983.     if (!pSrc)
  984.     {
  985. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  986.   (const char*)info[2]));
  987.         ret = false;
  988.     }
  990.     if (ret)
  991.     {
  992.         const CHXString& result = (*pDest += *pSrc);
  993.         if (&result != pDest)
  994.         {
  995.             DPRINTF(D_ERROR, ("operator=(const CHXString&) didn't return object: got %p expected %pn",
  996.                               &result, pDest));
  997.             ret = false;
  998.         }
  999.     }
  1001.     return ret;
  1002. }
  1004. bool HLXStringTest::HandleAppendTo2Cmd(const UTVector<UTString>& info)
  1005. {
  1006.     bool ret = true;
  1007.     CHXString* pStr = GetStringObj(info[1]);
  1009.     if (!pStr)
  1010.     {
  1011. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1012.   (const char*)info[1]));
  1013.     }
  1014.     else
  1015.     {
  1016.         const CHXString& result = (*pStr += *((const char*)info[2]));
  1017.         if (&result != pStr)
  1018.         {
  1019.             DPRINTF(D_ERROR, ("operator=(const CHXString&) didn't return object: got %p expected %pn",
  1020.                               &result, pStr));
  1021.             ret = false;
  1022.         }
  1023.     }
  1024.     return ret;
  1025. }
  1027. bool HLXStringTest::HandleAppendTo3Cmd(const UTVector<UTString>& info)
  1028. {
  1029.     bool ret = true;
  1030.     CHXString* pStr = GetStringObj(info[1]);
  1032.     if (!pStr)
  1033.     {
  1034. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1035.   (const char*)info[1]));
  1036.     }
  1037.     else
  1038.     {
  1039.         const CHXString& result = (*pStr += (const char*)info[2]);
  1040.         if (&result != pStr)
  1041.         {
  1042.             DPRINTF(D_ERROR, ("operator=(const CHXString&) didn't return object: got %p expected %pn",
  1043.                               &result, pStr));
  1044.             ret = false;
  1045.         }
  1046.     }
  1048.     return ret;
  1049. }
  1051. bool HLXStringTest::HandleAdd1Cmd(const UTVector<UTString>& info)
  1052. {
  1053.     bool ret = true;
  1054.     CHXString* pStr1 = GetStringObj(info[1]);
  1055.     CHXString* pStr2 = GetStringObj(info[2]);
  1057.     if (!pStr1)
  1058.     {
  1059. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1060.   (const char*)info[1]));
  1061.         ret = false;
  1062.     }
  1063.     if (!pStr2)
  1064.     {
  1065. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1066.   (const char*)info[2]));
  1067.         ret = false;
  1068.     }
  1070.     if (ret)
  1071.     {
  1072.         CHXString got = *pStr1 + *pStr2;
  1073.         if (strcmp (got, (const char*)info[3]) != 0)
  1074.         {
  1075.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1076.                               (const char*)got,
  1077.                               (const char*)info[3]));
  1078.             ret = false;
  1079.         }
  1080.     }
  1082.     return ret;
  1083. }
  1085. bool HLXStringTest::HandleAdd2Cmd(const UTVector<UTString>& info)
  1086. {
  1087.     bool ret = true;
  1088.     CHXString* pStr1 = GetStringObj(info[1]);
  1090.     if (!pStr1)
  1091.     {
  1092. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1093.   (const char*)info[1]));
  1094.         ret = false;
  1095.     }
  1097.     if (ret)
  1098.     {
  1099.         CHXString got = *pStr1 + *((const char*)info[2]);
  1100.         if (strcmp (got, (const char*)info[3]) != 0)
  1101.         {
  1102.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1103.                               (const char*)got,
  1104.                               (const char*)info[3]));
  1105.             ret = false;
  1106.         }
  1107.     }
  1109.     return ret;
  1110. }
  1113. bool HLXStringTest::HandleAdd3Cmd(const UTVector<UTString>& info)
  1114. {
  1115.     bool ret = true;
  1116.     CHXString* pStr2 = GetStringObj(info[2]);
  1118.     if (!pStr2)
  1119.     {
  1120. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1121.   (const char*)info[2]));
  1122.         ret = false;
  1123.     }
  1125.     if (ret)
  1126.     {
  1127.         CHXString got = *((const char*)info[1]) + *pStr2;
  1128.         if (strcmp (got, (const char*)info[3]) != 0)
  1129.         {
  1130.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1131.                               (const char*)got,
  1132.                               (const char*)info[3]));
  1133.             ret = false;
  1134.         }
  1135.     }
  1137.     return ret;
  1138. }
  1141. bool HLXStringTest::HandleAdd4Cmd(const UTVector<UTString>& info)
  1142. {
  1143.     bool ret = true;
  1144.     CHXString* pStr1 = GetStringObj(info[1]);
  1146.     if (!pStr1)
  1147.     {
  1148. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1149.   (const char*)info[1]));
  1150.         ret = false;
  1151.     }
  1153.     if (ret)
  1154.     {
  1155.         CHXString got = *pStr1 + (const char*)info[2];
  1156.         if (strcmp (got, (const char*)info[3]) != 0)
  1157.         {
  1158.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1159.                               (const char*)got,
  1160.                               (const char*)info[3]));
  1161.             ret = false;
  1162.         }
  1163.     }
  1165.     return ret;
  1166. }
  1169. bool HLXStringTest::HandleAdd5Cmd(const UTVector<UTString>& info)
  1170. {
  1171.     bool ret = true;
  1172.     CHXString* pStr2 = GetStringObj(info[2]);
  1174.     if (!pStr2)
  1175.     {
  1176. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1177.   (const char*)info[2]));
  1178.         ret = false;
  1179.     }
  1181.     if (ret)
  1182.     {
  1183.         CHXString got = (const char*)info[1] + *pStr2;
  1184.         if (strcmp (got, (const char*)info[3]) != 0)
  1185.         {
  1186.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1187.                               (const char*)got,
  1188.                               (const char*)info[3]));
  1189.             ret = false;
  1190.         }
  1191.     }
  1193.     return ret;
  1194. }
  1197. bool HLXStringTest::HandleCenterCmd(const UTVector<UTString>& info)
  1198. {
  1199.     bool ret = false;
  1200.     CHXString* pStr = GetStringObj(info[1]);
  1201.     int len;
  1203.     if (!pStr)
  1204.     {
  1205. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1206.   (const char*)info[1]));
  1207.     }
  1208.     else if (!UTParamUtil::GetInt(info[2], len))
  1209.     {
  1210. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1211.     }
  1212.     else
  1213.     {
  1214.         pStr->Center(len);
  1215.         ret = true;
  1216.     }
  1218.     return ret;
  1219. }
  1221. bool HLXStringTest::HandleCompareCmd(const UTVector<UTString>& info)
  1222. {
  1223.     bool ret = false;
  1224.     CHXString* pStr = GetStringObj(info[1]);
  1225.     int expected = -9999;
  1226.     bool bNumberExpected = (info[3] != "-" && info[3] != "+");
  1228.     if (!pStr)
  1229.     {
  1230. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1231.   (const char*)info[1]));
  1232.     }
  1233.     else if (bNumberExpected && !UTParamUtil::GetInt(info[3], expected))
  1234.     {
  1235. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1236.     }
  1237.     else
  1238.     {
  1239.         INT32 got = pStr->Compare(info[2]);
  1240.         if ((info[3] == "+" && got > 0) ||
  1241.             (info[3] == "-" && got < 0) ||
  1242.             (bNumberExpected && got == expected)) ret = true;
  1243.         else DPRINTF(D_ERROR, ("Got %d expected %sn",
  1244.                                got, (const char*)info[3]));
  1245.     }
  1247.     return ret;
  1248. }
  1250. bool HLXStringTest::HandleCompareNoCaseCmd(const UTVector<UTString>& info)
  1251. {
  1252.     bool ret = false;
  1253.     CHXString* pStr = GetStringObj(info[1]);
  1254.     int expected = -9999;
  1255.     bool bNumberExpected = (info[3] != "-" && info[3] != "+");
  1257.     if (!pStr)
  1258.     {
  1259. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1260.   (const char*)info[1]));
  1261.     }
  1262.     else if (bNumberExpected && !UTParamUtil::GetInt(info[3], expected))
  1263.     {
  1264. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1265.     }
  1266.     else
  1267.     {
  1268.         INT32 got = pStr->CompareNoCase(info[2]);
  1269.         if ((info[3] == "+" && got > 0) ||
  1270.             (info[3] == "-" && got < 0) ||
  1271.             (bNumberExpected && got == expected)) ret = true;
  1272.         else DPRINTF(D_ERROR, ("Got %d expected %sn",
  1273.                                got, (const char*)info[3]));
  1274.     }
  1276.     return ret;
  1277. }
  1279. bool HLXStringTest::HandleMidCmd(const UTVector<UTString>& info)
  1280. {
  1281.     bool ret = true;
  1282.     CHXString* pStr = GetStringObj(info[1]);
  1283.     int index;
  1284.     const char* expected = NULL;
  1285.     int length = -9999;
  1287.     if (!pStr)
  1288.     {
  1289. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1290.   (const char*)info[1]));
  1291.         ret = false;
  1292.     }
  1293.     else if (!UTParamUtil::GetInt(info[2], index))
  1294.     {
  1295. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1296.         ret = false;
  1297.     }
  1298.     else if (info.Nelements() == 4)
  1299.     {
  1300.         expected = (const char*)info[3];
  1301.     }
  1302.     else if (info.Nelements() == 5)
  1303.     {
  1304.         if (!UTParamUtil::GetInt(info[3], length))
  1305.         {
  1306.             DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1307.             ret = false;
  1308.         }
  1309.         else expected = (const char*)info[4];
  1310.     }
  1311.     else
  1312.     {
  1313.         DPRINTF(D_ERROR, ("Bad number of arguments: %ldn",
  1314.                           (long)info.Nelements()));
  1315.         ret = false;
  1316.     }
  1318.     if (ret)
  1319.     {
  1320.         CHXString got =
  1321.             (length == -9999 ? pStr->Mid(index) : pStr->Mid(index, length));
  1322.         if (strcmp(got, expected) != 0)
  1323.         {
  1324.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1325.                               (const char*)got,
  1326.                               expected));
  1327.             ret = false;
  1328.         }
  1329.     }
  1331.     return ret;
  1332. }
  1334. bool HLXStringTest::HandleLeftCmd(const UTVector<UTString>& info)
  1335. {
  1336.     bool ret = true;
  1337.     CHXString* pStr = GetStringObj(info[1]);
  1338.     const char* expected = (const char*)info[3];
  1339.     int length = -9999;
  1341.     if (!pStr)
  1342.     {
  1343. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1344.   (const char*)info[1]));
  1345.         ret = false;
  1346.     }
  1347.     else if (!UTParamUtil::GetInt(info[2], length))
  1348.     {
  1349. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1350.         ret = false;
  1351.     }
  1352.     else
  1353.     {
  1354.         CHXString got = pStr->Left(length);
  1355.         if (strcmp(got, expected) != 0)
  1356.         {
  1357.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1358.                               (const char*)got,
  1359.                               expected));
  1360.             ret = false;
  1361.         }
  1362.     }
  1364.     return ret;
  1365. }
  1368. bool HLXStringTest::HandleRightCmd(const UTVector<UTString>& info)
  1369. {
  1370.     bool ret = true;
  1371.     CHXString* pStr = GetStringObj(info[1]);
  1372.     const char* expected = (const char*)info[3];
  1373.     int length = -9999;
  1375.     if (!pStr)
  1376.     {
  1377. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1378.   (const char*)info[1]));
  1379.         ret = false;
  1380.     }
  1381.     else if (!UTParamUtil::GetInt(info[2], length))
  1382.     {
  1383. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1384.         ret = false;
  1385.     }
  1386.     else
  1387.     {
  1388.         CHXString got = pStr->Right(length);
  1389.         if (strcmp(got, expected) != 0)
  1390.         {
  1391.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1392.                               (const char*)got,
  1393.                               expected));
  1394.             ret = false;
  1395.         }
  1396.     }
  1398.     return ret;
  1399. }
  1401. bool HLXStringTest::HandleCountFieldsCmd(const UTVector<UTString>& info)
  1402. {
  1403.     bool ret = true;
  1404.     CHXString* pStr = GetStringObj(info[1]);
  1405.     unsigned int expected;
  1407.     if (!pStr)
  1408.     {
  1409. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1410.   (const char*)info[1]));
  1411.         ret = false;
  1412.     }
  1413.     else if (!UTParamUtil::GetUInt(info[3], expected))
  1414.     {
  1415. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1416.         ret = false;
  1417.     }
  1418.     else
  1419.     {
  1420.         ULONG32 got = pStr->CountFields(*((const char*)info[2]));
  1421.         if (got != expected)
  1422.         {
  1423.             DPRINTF(D_ERROR, ("Got %lu expected %lun",
  1424.                               (unsigned long)got, (unsigned long)expected));
  1425.             ret = false;
  1426.         }
  1427.     }
  1429.     return ret;
  1430. }
  1432. bool HLXStringTest::HandleNthFieldCmd(const UTVector<UTString>& info)
  1433. {
  1434.     bool ret = true;
  1435.     CHXString* pStr = GetStringObj(info[1]);
  1436.     unsigned int field;
  1438.     if (!pStr)
  1439.     {
  1440. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1441.   (const char*)info[1]));
  1442.         ret = false;
  1443.     }
  1444.     else if (!UTParamUtil::GetUInt(info[3], field))
  1445.     {
  1446. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1447.         ret = false;
  1448.     }
  1449.     else
  1450.     {
  1451.         CHXString got = pStr->NthField(*((const char*)info[2]),
  1452.                                        (ULONG32)field);
  1453.         const char* expected = (const char*)info[4];
  1455.         if (strcmp(got, expected) != 0)
  1456.         {
  1457.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1458.                               (const char*)got, expected));
  1459.             ret = false;
  1460.         }
  1461.     }
  1463.     return ret;
  1464. }
  1467. bool HLXStringTest::HandleResetNthFieldStateCmd(const UTVector<UTString>& info)
  1468. {
  1469.     bool ret = true;
  1470.     CHXString* pStr = GetStringObj(info[1]);
  1472.     // XXXSAB: Should we have a way to set this NthFieldState thing to garbage???
  1474.     if (!pStr)
  1475.     {
  1476. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1477.   (const char*)info[1]));
  1478.         ret = false;
  1479.     }
  1480.     else
  1481.     {
  1482.         if (pStr == m_pA) m_ANthFieldState = 0;
  1483.         else if (pStr == m_pB) m_BNthFieldState = 0;
  1484.     }
  1486.     return ret;
  1487. }
  1489. bool HLXStringTest::HandleGetNthFieldCmd(const UTVector<UTString>& info)
  1490. {
  1491.     bool ret = true;
  1492.     CHXString* pStr = GetStringObj(info[1]);
  1493.     unsigned int field;
  1495.     if (!pStr)
  1496.     {
  1497. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1498.   (const char*)info[1]));
  1499.         ret = false;
  1500.     }
  1501.     else if (!UTParamUtil::GetUInt(info[3], field))
  1502.     {
  1503. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1504.         ret = false;
  1505.     }
  1506.     else
  1507.     {
  1508.         UINT64& state = (pStr == m_pA) ? m_ANthFieldState : m_BNthFieldState;
  1510.         CHXString got = pStr->GetNthField(*((const char*)info[2]),
  1511.                                           (ULONG32)field,
  1512.                                           state);
  1513.         const char* expected = (const char*)info[4];
  1515.         if (strcmp(got, expected) != 0)
  1516.         {
  1517.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1518.                               (const char*)got, expected));
  1519.             ret = false;
  1520.         }
  1521.     }
  1523.     return ret;
  1524. }
  1527. bool HLXStringTest::HandleSpanIncludingCmd(const UTVector<UTString>& info)
  1528. {
  1529.     bool ret = false;
  1530.     CHXString* pStr = GetStringObj(info[1]);
  1532.     if (!pStr)
  1533.     {
  1534. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1535.   (const char*)info[1]));
  1536.     }
  1537.     else
  1538.     {
  1539.         CHXString got = pStr->SpanIncluding((const char*)info[2]);
  1540.         if (strcmp(got, (const char*)info[3]) == 0) ret = true;
  1541.         else DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1542.                                (const char*)got, (const char*)info[3]));
  1543.     }
  1545.     return ret;
  1546. }
  1548. bool HLXStringTest::HandleSpanExcludingCmd(const UTVector<UTString>& info)
  1549. {
  1550.     bool ret = false;
  1551.     CHXString* pStr = GetStringObj(info[1]);
  1553.     if (!pStr)
  1554.     {
  1555. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1556.   (const char*)info[1]));
  1557.     }
  1558.     else
  1559.     {
  1560.         CHXString got = pStr->SpanExcluding((const char*)info[2]);
  1561.         if (strcmp(got, (const char*)info[3]) == 0) ret = true;
  1562.         else DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  1563.                                (const char*)got, (const char*)info[3]));
  1564.     }
  1566.     return ret;
  1567. }
  1569. bool HLXStringTest::HandleMakeUpperCmd(const UTVector<UTString>& info)
  1570. {
  1571.     bool ret = false;
  1572.     CHXString* pStr = GetStringObj(info[1]);
  1574.     if (!pStr)
  1575.     {
  1576. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1577.   (const char*)info[1]));
  1578.     }
  1579.     else
  1580.     {
  1581.         ret = true;
  1582.         pStr->MakeUpper();
  1583.     }
  1585.     return ret;
  1586. }
  1588. bool HLXStringTest::HandleMakeLowerCmd(const UTVector<UTString>& info)
  1589. {
  1590.     bool ret = false;
  1591.     CHXString* pStr = GetStringObj(info[1]);
  1593.     if (!pStr)
  1594.     {
  1595. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1596.   (const char*)info[1]));
  1597.     }
  1598.     else
  1599.     {
  1600.         ret = true;
  1601.         pStr->MakeLower();
  1602.     }
  1604.     return ret;
  1605. }
  1607. bool HLXStringTest::HandleTrimRightCmd(const UTVector<UTString>& info)
  1608. {
  1609.     bool ret = false;
  1610.     CHXString* pStr = GetStringObj(info[1]);
  1612.     if (!pStr)
  1613.     {
  1614. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1615.   (const char*)info[1]));
  1616.     }
  1617.     else
  1618.     {
  1619.         ret = true;
  1620.         pStr->TrimRight();
  1621.     }
  1623.     return ret;
  1624. }
  1626. bool HLXStringTest::HandleTrimLeftCmd(const UTVector<UTString>& info)
  1627. {
  1628.     bool ret = false;
  1629.     CHXString* pStr = GetStringObj(info[1]);
  1631.     if (!pStr)
  1632.     {
  1633. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1634.   (const char*)info[1]));
  1635.     }
  1636.     else
  1637.     {
  1638.         ret = true;
  1639.         pStr->TrimLeft();
  1640.     }
  1643.     return ret;
  1644. }
  1646. bool HLXStringTest::HandleFind1Cmd(const UTVector<UTString>& info)
  1647. {
  1648.     bool ret = false;
  1649.     CHXString* pStr = GetStringObj(info[1]);
  1650.     int expected;
  1652.     if (!pStr)
  1653.     {
  1654. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1655.   (const char*)info[1]));
  1656.     }
  1657.     else if (!UTParamUtil::GetInt(info[3], expected))
  1658.     {
  1659. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1660.     }
  1661.     else
  1662.     {
  1663.         INT32 got = pStr->Find(*((const char*)info[2]));
  1664.         if (got == expected) ret = true;
  1665.         else DPRINTF(D_ERROR, ("Got %ld expected %ldn",
  1666.                                (long)got, (long)expected));
  1667.     }
  1669.     return ret;
  1670. }
  1672. bool HLXStringTest::HandleFind2Cmd(const UTVector<UTString>& info)
  1673. {
  1674.     bool ret = false;
  1675.     CHXString* pStr = GetStringObj(info[1]);
  1676.     int expected;
  1678.     if (!pStr)
  1679.     {
  1680. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1681.   (const char*)info[1]));
  1682.     }
  1683.     else if (!UTParamUtil::GetInt(info[3], expected))
  1684.     {
  1685. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1686.     }
  1687.     else
  1688.     {
  1689.         INT32 got = pStr->Find((const char*)info[2]);
  1690.         if (got == expected) ret = true;
  1691.         else DPRINTF(D_ERROR, ("Got %ld expected %ldn",
  1692.                                (long)got, (long)expected));
  1693.     }
  1695.     return ret;
  1696. }
  1698. bool HLXStringTest::HandleReverseFindCmd(const UTVector<UTString>& info)
  1699. {
  1700.     bool ret = false;
  1701.     CHXString* pStr = GetStringObj(info[1]);
  1702.     int expected;
  1704.     if (!pStr)
  1705.     {
  1706. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1707.   (const char*)info[1]));
  1708.     }
  1709.     else if (!UTParamUtil::GetInt(info[3], expected))
  1710.     {
  1711. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1712.     }
  1713.     else
  1714.     {
  1715.         INT32 got = pStr->ReverseFind(*((const char*)info[2]));
  1716.         if (got == expected) ret = true;
  1717.         else DPRINTF(D_ERROR, ("Got %ld expected %ldn",
  1718.                                (long)got, (long)expected));
  1719.     }
  1721.     return ret;
  1722. }
  1724. bool HLXStringTest::HandleFindAndReplaceCmd(const UTVector<UTString>& info)
  1725. {
  1726.     bool ret = false;
  1727.     CHXString* pStr = GetStringObj(info[1]);
  1728.     bool expected, bReplaceAll;
  1730.     if (!pStr)
  1731.     {
  1732. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1733.   (const char*)info[1]));
  1734.     }
  1735.     else if (!UTParamUtil::GetBool(info[4], bReplaceAll) ||
  1736.              !UTParamUtil::GetBool(info[5], expected))
  1737.     {
  1738. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  1739.     }
  1740.     else
  1741.     {
  1742.         bool got = pStr->FindAndReplace((const char*)info[2],
  1743.                                         (const char*)info[3],
  1744.                                         bReplaceAll) ? true : false;
  1745.         if (got == expected) ret = true;
  1746.         else DPRINTF(D_ERROR, ("Got %s expected %sn",
  1747.                                got ? "TRUE" : "FALSE",
  1748.                                expected ? "TRUE" : "FALSE"));
  1749.     }
  1751.     return ret;
  1752. }
  1754. namespace
  1755. {
  1756.     inline bool
  1757.     GetCharStar (const char* strRep, const char*& value)
  1758.     {
  1759.         value = strRep;
  1760.         return true;
  1761.     }
  1763.     inline bool
  1764.     GetPtr (const char* strRep, void*& value)
  1765.     {
  1766.         unsigned long iValue;
  1767.         bool ret = UTParamUtil::GetULong(strRep, iValue);
  1768.         if (ret) value = (void*)iValue;
  1769.         return ret;
  1770.     }
  1772.     template <class T>
  1773.     bool HandleFormat (CHXString& str, const UTVector<UTString>& info,
  1774.                        bool (*GetValue)(const char* strRep, T& retValue))
  1775.     {
  1776.         const char* fmt = (const char*)info[2];
  1777.         T* values = new T[info.Nelements() - 3];
  1778.         
  1779.         int beginData = 3;
  1780.         int endData = info.Nelements();
  1782.         int infoIdx = beginData;
  1783.         int valIdx = 0;
  1785.         for (; infoIdx < endData; ++infoIdx, ++valIdx)
  1786.         {
  1787.             if (!GetValue(info[infoIdx], values[valIdx]))
  1788.             {
  1789.                 DPRINTF(D_ERROR, ("Failed to convert arg "%s"n",
  1790.                                   (const char*)info[infoIdx]));
  1791.                 return false;
  1792.             }
  1793.         }
  1795.         switch (valIdx)
  1796.         {
  1797.             case 1:
  1798.                 str.Format(fmt, values[0]);
  1799.                 break;
  1800.             case 2:
  1801.                 str.Format(fmt, values[0], values[1]);
  1802.                 break;
  1803.             case 3:
  1804.                 str.Format(fmt, values[0], values[1], values[2]);
  1805.                 break;
  1806.             case 4:
  1807.                 str.Format(fmt, values[0], values[1], values[2], values[3]);
  1808.                 break;
  1809.             case 5:
  1810.                 str.Format(fmt, values[0], values[1], values[2], values[3],
  1811.                            values[4]);
  1812.                 break;
  1813.             case 6:
  1814.                 str.Format(fmt, values[0], values[1], values[2], values[3],
  1815.                            values[4], values[5]);
  1816.                 break;
  1817.             case 7:
  1818.                 str.Format(fmt, values[0], values[1], values[2], values[3],
  1819.                            values[4], values[5], values[6]);
  1820.                 break;
  1821.             case 8:
  1822.                 str.Format(fmt, values[0], values[1], values[2], values[3],
  1823.                            values[4], values[5], values[6], values[7]);
  1824.                 break;
  1825.             case 9:
  1826.                 str.Format(fmt, values[0], values[1], values[2], values[3],
  1827.                            values[4], values[5], values[6], values[7],
  1828.                            values[8]);
  1829.                 break;
  1830.             case 10:
  1831.                 str.Format(fmt, values[0], values[1], values[2], values[3],
  1832.                            values[4], values[5], values[6], values[7],
  1833.                            values[8], values[9]);
  1834.                 break;
  1835.             default:
  1836.                 DPRINTF(D_ERROR, ("Unsupported num of data values (%d)n",
  1837.                                   valIdx));
  1838.                 return false;
  1839.                 break;
  1840.         }
  1842. delete [] values;
  1843.         return true;
  1844.     }
  1845. };
  1847. bool HLXStringTest::HandleFormatIntCmd(const UTVector<UTString>& info)
  1848. {
  1849.     bool ret = false;
  1850.     CHXString* pStr = GetStringObj(info[1]);
  1852.     if (!pStr)
  1853.     {
  1854. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1855.   (const char*)info[1]));
  1856.     }
  1857.     else ret = HandleFormat<int>(*pStr, info, UTParamUtil::GetInt);
  1859.     return ret;
  1860. }
  1862. bool HLXStringTest::HandleFormatLongCmd(const UTVector<UTString>& info)
  1863. {
  1864.     bool ret = false;
  1865.     CHXString* pStr = GetStringObj(info[1]);
  1867.     if (!pStr)
  1868.     {
  1869. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1870.   (const char*)info[1]));
  1871.     }
  1872.     else ret = HandleFormat<long int>(*pStr, info, UTParamUtil::GetLong);
  1874.     return ret;
  1875. }
  1877. bool HLXStringTest::HandleFormatUIntCmd(const UTVector<UTString>& info)
  1878. {
  1879.     bool ret = false;
  1880.     CHXString* pStr = GetStringObj(info[1]);
  1882.     if (!pStr)
  1883.     {
  1884. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1885.   (const char*)info[1]));
  1886.     }
  1887.     else ret = HandleFormat<unsigned int>(*pStr, info, UTParamUtil::GetUInt);
  1889.     return ret;
  1890. }
  1892. bool HLXStringTest::HandleFormatULongCmd(const UTVector<UTString>& info)
  1893. {
  1894.     bool ret = false;
  1895.     CHXString* pStr = GetStringObj(info[1]);
  1897.     if (!pStr)
  1898.     {
  1899. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1900.   (const char*)info[1]));
  1901.     }
  1902.     else ret = HandleFormat<unsigned long int>(*pStr, info, 
  1903.        UTParamUtil::GetULong);
  1905.     return ret;
  1906. }
  1908. bool HLXStringTest::HandleFormatCharCmd(const UTVector<UTString>& info)
  1909. {
  1910.     bool ret = false;
  1911.     CHXString* pStr = GetStringObj(info[1]);
  1913.     if (!pStr)
  1914.     {
  1915. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1916.   (const char*)info[1]));
  1917.     }
  1918.     else ret = HandleFormat<char>(*pStr, info, UTParamUtil::GetChar);
  1920.     return ret;
  1921. }
  1923. bool HLXStringTest::HandleFormatCharStarCmd(const UTVector<UTString>& info)
  1924. {
  1925.     bool ret = false;
  1926.     CHXString* pStr = GetStringObj(info[1]);
  1928.     if (!pStr)
  1929.     {
  1930. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1931.   (const char*)info[1]));
  1932.     }
  1933.     else ret = HandleFormat<const char*>(*pStr, info, GetCharStar);
  1935.     return ret;
  1936. }
  1938. bool HLXStringTest::HandleFormatPtrCmd(const UTVector<UTString>& info)
  1939. {
  1940.     bool ret = false;
  1941.     CHXString* pStr = GetStringObj(info[1]);
  1943.     if (!pStr)
  1944.     {
  1945. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  1946.   (const char*)info[1]));
  1947.     }
  1948.     else ret = HandleFormat<void*>(*pStr, info, GetPtr);
  1950.     return ret;
  1951. }
  1953. bool HLXStringTest::HandleFormatDoubleCmd(const UTVector<UTString>& info)
  1954. {
  1955.     bool ret = false;
  1956.     CHXString* pStr = GetStringObj(info[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 ret = HandleFormat<double>(*pStr, info, UTParamUtil::GetDouble);
  1965.     return ret;
  1966. }
  1968. bool HLXStringTest::HandleFormatMixedCmd(const UTVector<UTString>& /*info*/)
  1969. {
  1970.     CHXString str;
  1972.     // XXXSAB - now what???
  1974.     const char* expected = "";
  1975.     char* ptr = (char*)0x60616263;
  1977.     str.Format ("%p,%d,%u,%c",
  1978.                 ptr, (int)ptr, (unsigned int)ptr, (char)ptr);
  1979. #ifdef _WINDOWS
  1980.     expected = "60616263,1616994915,1616994915,c";
  1981. #else
  1982.     expected = "0x60616263,1616994915,1616994915,c";
  1983. #endif /* _WINDOWS */
  1984.     if (str != expected)
  1985.     {
  1986.         DPRINTF(D_ERROR, ("FormatMixed #1: Got "%s" expected "%s"n",
  1987.                           (const char*)str, expected));
  1988.         return false;
  1989.     }
  1991.     ptr = 0;
  1992.     str.Format ("%p,%p,%p,%p", ptr, ptr+1, ptr+2, ptr+3);
  1993. #ifdef _WINDOWS
  1994.     expected = "00000000,00000001,00000002,00000003";
  1995. #elif defined(_SYMBIAN)
  1996.     expected = "0x0,0x1,0x2,0x3";
  1997. #else
  1998.     expected = "(nil),0x1,0x2,0x3";
  1999. #endif /* _WINDOWS */
  2000.     if (str != expected)
  2001.     {
  2002.         DPRINTF(D_ERROR, ("FormatMixed #2: Got "%s" expected "%s"n",
  2003.                           (const char*)str, expected));
  2004.         return false;
  2005.     }
  2007.     str.Format ("%6d,%5u,%x", 1,1,1);
  2008.     expected = "     1,    1,1";
  2009.     if (str != expected)
  2010.     {
  2011.         DPRINTF(D_ERROR, ("FormatMixed #3: Got "%s" expected "%s"n",
  2012.                           (const char*)str, expected));
  2013.         return false;
  2014.     }
  2016.     return true;
  2017. }
  2019. bool HLXStringTest::HandleAppendULONGCmd(const UTVector<UTString>& info)
  2020. {
  2021.     bool ret = false;
  2022.     CHXString* pStr = GetStringObj(info[1]);
  2023.     unsigned int value;
  2025.     if (!pStr)
  2026.     {
  2027. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  2028.   (const char*)info[1]));
  2029.     }
  2030.     else if (!UTParamUtil::GetUInt(info[2], value))
  2031.     {
  2032. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  2033.     }
  2034.     else
  2035.     {
  2036.         ret = true;
  2037.         pStr->AppendULONG((ULONG32)value);
  2038.     }
  2040.     return ret;
  2041. }
  2043. bool HLXStringTest::HandleAppendEndOfLineCmd(const UTVector<UTString>& info)
  2044. {
  2045.     bool ret = false;
  2046.     CHXString* pStr = GetStringObj(info[1]);
  2048.     if (!pStr)
  2049.     {
  2050. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  2051.   (const char*)info[1]));
  2052.     }
  2053.     else
  2054.     {
  2055.         UINT32 beforeLength = pStr->GetLength();
  2056.         pStr->AppendEndOfLine();
  2058.         // Check that the proper EOL sequence was added
  2059.         if (pStr->IsEmpty())
  2060.         {
  2061.             DPRINTF(D_ERROR, ("Failed to add EOL sequence: string is now emptyn"));
  2062.         }
  2063.         else
  2064.         {
  2065.             const char* pEnd = (const char*)*pStr + pStr->GetLength() - 1;
  2066. #if defined(_UNIX) 
  2067.             ret = (*pEnd == 'n') &&
  2068.                 (pStr->GetLength() == (beforeLength+1));
  2069. #elif defined(_MACINTOSH)
  2070.             ret = (*pEnd == 'r') &&
  2071.                 (pStr->GetLength() == (beforeLength+1));
  2072. #elif defined(_WINDOWS) || defined(_SYMBIAN)
  2073.             ret = (*(pEnd-1) == 'r' && *pEnd == 'n') &&
  2074.                 (pStr->GetLength() == (beforeLength+2));
  2075. #else
  2076.            ret = (*pEnd == 'n') &&
  2077.                 (pStr->GetLength() == (beforeLength+1));
  2078. #endif
  2079.             if (!ret)
  2080.             {
  2081.                 DPRINTF(D_ERROR, ("Failed to add EOL: got "%s"n",
  2082.                               (const char*)*pStr));
  2083.             }
  2084.         }
  2085.     }
  2087.     return ret;
  2088. }
  2090. bool HLXStringTest::HandleGetBufferCmd(const UTVector<UTString>& info)
  2091. {
  2092.     bool ret = false;
  2093.     CHXString* pStr = GetStringObj(info[1]);
  2094.     int length;
  2096.     if (!pStr)
  2097.     {
  2098. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  2099.   (const char*)info[1]));
  2100.     }
  2101.     else if (!UTParamUtil::GetInt(info[2], length))
  2102.     {
  2103. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  2104.     }
  2105.     else
  2106.     {
  2107.         // NOTE: If didn't get at least 4 elements in 'info', then we
  2108.         //       don't care what's in the returned buffer...
  2110.         char*& p = (pStr == m_pA ? m_pABuffer : m_pBBuffer);
  2111.         p = pStr->GetBuffer(length);
  2113.         if (!p) DPRINTF(D_ERROR, ("Got NULL from GetBuffer()n"));
  2114.         else if (info.Nelements() >= 4 &&
  2115.                  strcmp(p, (const char*)info[3]) != 0)
  2116.         {
  2117.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  2118.                               p, (const char*)info[3]));
  2119.         }
  2120.         else ret = true;
  2121.     }
  2123.     return ret;
  2124. }
  2126. bool HLXStringTest::HandleGetBufferSetLengthCmd(const UTVector<UTString>& info)
  2127. {
  2128.     bool ret = false;
  2129.     CHXString* pStr = GetStringObj(info[1]);
  2130.     int length;
  2132.     if (!pStr)
  2133.     {
  2134. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  2135.   (const char*)info[1]));
  2136.     }
  2137.     else if (!UTParamUtil::GetInt(info[2], length))
  2138.     {
  2139. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  2140.     }
  2141.     else
  2142.     {
  2143.         // NOTE: If didn't get at least 4 elements in 'info', then we
  2144.         //       don't care what's in the returned buffer...
  2146.         char*& p = (pStr == m_pA ? m_pABuffer : m_pBBuffer);
  2147.         p = pStr->GetBufferSetLength(length);
  2149.         if (!p) DPRINTF(D_ERROR, ("Got NULL from GetBuffer()n"));
  2150.         else if (info.Nelements() >= 4 &&
  2151.                  strcmp(p, (const char*)info[3]) != 0)
  2152.         {
  2153.             DPRINTF(D_ERROR, ("Got "%s" expected "%s"n",
  2154.                               p, (const char*)info[3]));
  2155.         }
  2156.         else ret = true;
  2157.     }
  2159.     return ret;
  2160. }
  2162. bool HLXStringTest::HandleBufferSetCmd(const UTVector<UTString>& info)
  2163. {
  2164.     bool ret = false;
  2165.     CHXString* pStr = GetStringObj(info[1]);
  2166.     int index = 0;
  2168.     if (!pStr)
  2169.     {
  2170. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  2171.   (const char*)info[1]));
  2172.     }
  2173.     else if (info.Nelements() >= 4 && !UTParamUtil::GetInt(info[2], index))
  2174.     {
  2175. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  2176.     }
  2177.     else
  2178.     {
  2179.         char* p = (pStr == m_pA ? m_pABuffer : m_pBBuffer);
  2180.         const char* pValue = (const char*)info[info.Nelements()-1];
  2182.         memcpy (p+index, pValue, strlen(pValue)); /* Flawfinder: ignore */
  2183.         ret = true;
  2184.     }
  2186.     return ret;
  2187. }
  2189. bool HLXStringTest::HandleBufferFillCmd(const UTVector<UTString>& info)
  2190. {
  2191.     bool ret = false;
  2192.     CHXString* pStr = GetStringObj(info[1]);
  2193.     int index = 0;
  2194.     int repeat = 0;
  2196.     if (!pStr)
  2197.     {
  2198. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  2199.   (const char*)info[1]));
  2200.     }
  2201.     else if (!UTParamUtil::GetInt(info[info.Nelements() - 1], repeat) ||
  2202.              (info.Nelements() >= 5 && !UTParamUtil::GetInt(info[2], index)))
  2203.     {
  2204. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  2205.     }
  2206.     else
  2207.     {
  2208.         char* p = (pStr == m_pA ? m_pABuffer : m_pBBuffer);
  2209.         const char* pValue = (const char*)info[info.Nelements()-2];
  2210.         size_t len = strlen(pValue);
  2212.         for (p += index; repeat > 0; p += len, --repeat)
  2213.             memcpy (p, pValue, len); /* Flawfinder: ignore */
  2214.         
  2215.         ret = true;
  2216.     }
  2218.     return ret;
  2219. }
  2221. bool HLXStringTest::HandleBufferEndStringCmd(const UTVector<UTString>& info)
  2222. {
  2223.     bool ret = false;
  2224.     CHXString* pStr = GetStringObj(info[1]);
  2225.     int index = 0;
  2227.     if (!pStr)
  2228.     {
  2229. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  2230.   (const char*)info[1]));
  2231.     }
  2232.     else if (!UTParamUtil::GetInt(info[2], index))
  2233.     {
  2234. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  2235.     }
  2236.     else
  2237.     {
  2238.         char* p = (pStr == m_pA ? m_pABuffer : m_pBBuffer);
  2239.         *(p+index) = 0;
  2240.         ret = true;
  2241.     }
  2243.     return ret;
  2244. }
  2246. bool HLXStringTest::HandleReleaseBufferCmd(const UTVector<UTString>& info)
  2247. {
  2248.     bool ret = false;
  2249.     CHXString* pStr = GetStringObj(info[1]);
  2250.     int length = -9999;
  2252.     if (!pStr)
  2253.     {
  2254. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  2255.   (const char*)info[1]));
  2256.     }
  2257.     else if (info.Nelements() >= 3 && !UTParamUtil::GetInt(info[2], length))
  2258.     {
  2259. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  2260.     }
  2261.     else
  2262.     {
  2263.         ret = true;
  2264.         if (length == -9999) pStr->ReleaseBuffer();
  2265.         else pStr->ReleaseBuffer(length);
  2267.         if (pStr == m_pA) m_pABuffer = 0;
  2268.         else m_pBBuffer = 0;
  2269.     }
  2271.     return ret;
  2272. }
  2274. bool HLXStringTest::HandleFreeExtraCmd(const UTVector<UTString>& info)
  2275. {
  2276.     bool ret = false;
  2277.     CHXString* pStr = GetStringObj(info[1]);
  2279.     if (!pStr)
  2280.     {
  2281. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  2282.   (const char*)info[1]));
  2283.     }
  2284.     else
  2285.     {
  2286.         ret = true;
  2287.         pStr->FreeExtra();
  2288.     }
  2290.     return ret;
  2291. }
  2293. bool HLXStringTest::HandleGetAllocLengthCmd(const UTVector<UTString>& info)
  2294. {
  2295.     bool ret = false;
  2296.     CHXString* pStr = GetStringObj(info[1]);
  2297.     int expected, maxExpected = -1;
  2299.     if (!pStr)
  2300.     {
  2301. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  2302.   (const char*)info[1]));
  2303.     }
  2304.     else if (!UTParamUtil::GetInt(info[2], expected) ||
  2305.              (info.Nelements() >= 4 && !UTParamUtil::GetInt(info[3], maxExpected)))
  2306.     {
  2307. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  2308.     }
  2309.     else if (pStr->GetAllocLength() < expected ||
  2310.              pStr->GetAllocLength() > (maxExpected > expected ?
  2311.                                        maxExpected : expected))
  2312.     {
  2313.         if (maxExpected > expected)
  2314.             DPRINTF (D_ERROR, ("Got %d expected %d..%dn",
  2315.                                pStr->GetAllocLength(), 
  2316.                                expected, maxExpected));
  2317.         else
  2318.             DPRINTF (D_ERROR, ("Got %d expected %dn", 
  2319.                                pStr->GetAllocLength(), 
  2320.                                expected));
  2321.     }
  2322.     else ret = true;
  2324.     return ret;
  2325. }
  2327. bool HLXStringTest::HandleSetMinBufSizeCmd(const UTVector<UTString>& info)
  2328. {
  2329.     bool ret = false;
  2330.     CHXString* pStr = GetStringObj(info[1]);
  2331.     int value, expected;
  2333.     if (!pStr)
  2334.     {
  2335. DPRINTF(D_ERROR, ("Failed to get the string object '%s'n", 
  2336.   (const char*)info[1]));
  2337.     }
  2338.     else if (!UTParamUtil::GetInt(info[2], value) || 
  2339.      !UTParamUtil::GetInt(info[3], expected))
  2340.     {
  2341. DPRINTF(D_ERROR, ("Failed to convert parametersn"));
  2342.     }
  2343.     else
  2344.     {
  2345.         INT32 got = pStr->SetMinBufSize(value);
  2346.         if (got == expected) ret = true;
  2347. else DPRINTF (D_ERROR, ("Got %d expected %dn", got, expected));
  2348.     }
  2350.     return ret;
  2351. }
  2353. CHXString* HLXStringTest::GetStringObj(const UTString& strName)
  2354. {
  2355.     CHXString* pRet = 0;
  2357.     if (strName == "A")
  2358. pRet = m_pA;
  2359.     else if (strName == "B")
  2360. pRet = m_pB;
  2361.     else
  2362.     {
  2363. DPRINTF(D_ERROR, ("GetStringObj() : get '%s' failedn",
  2364.   (const char*)strName));
  2365.     }
  2367.     return pRet;
  2368. }
  2370. void HLXStringTest::SetStringObj(const UTString& strName, CHXString* pNewStr)
  2371. {
  2372.     if (strName == "A")
  2373.     {
  2374. delete m_pA;
  2375. m_pA = pNewStr;
  2376.     }
  2377.     else if (strName == "B")
  2378.     {
  2379. delete m_pB;
  2380. m_pB = pNewStr;
  2381.     }
  2382.     else
  2383. DPRINTF(D_ERROR, ("SetStringObj() : set '%s' failedn",
  2384.   (const char*)strName));
  2385. }