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

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 "./slist_test.h"
  36. #include "hx_ut_debug.h"
  37. #include "ut_param_util.h"
  38. #include "./param_util.h"
  39. HLXSListTest::HLXSListTest() :
  40.     m_pos(0)
  41. {}
  42. HLXSListTest::~HLXSListTest()
  43. {}
  44. const char* HLXSListTest::DefaultCommandLine() const
  45. {
  46.     return "tslist tslist.in";
  47. }
  48.     
  49. void HLXSListTest::GetCommandInfo(UTVector<HLXUnitTestCmdInfo*>& cmds)
  50. {
  51.     cmds.Resize(34);
  52.     cmds[0] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  53.     "GetCount",
  54.     &HLXSListTest::HandleGetCountCmd,
  55.     2);
  56.     cmds[1] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  57.     "IsEmpty",
  58.     &HLXSListTest::HandleIsEmptyCmd,
  59.     2);
  60.     cmds[2] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  61.     "GetHead",
  62.     &HLXSListTest::HandleGetHeadCmd,
  63.     2);
  64.     cmds[3] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  65.     "ReplaceHead",
  66.     &HLXSListTest::HandleReplaceHeadCmd,
  67.     2);
  68.     cmds[4] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  69.     "GetTail",
  70.     &HLXSListTest::HandleGetTailCmd,
  71.     2);
  72.     cmds[5] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  73.     "ReplaceTail",
  74.     &HLXSListTest::HandleReplaceTailCmd,
  75.     2);
  76.     cmds[6] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  77.     "RemoveHead",
  78.     &HLXSListTest::HandleRemoveHeadCmd,
  79.     1);
  80.     cmds[7] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  81.     "RemoveTail",
  82.     &HLXSListTest::HandleRemoveTailCmd,
  83.     1);
  84.     cmds[8] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  85.     "AddHead",
  86.     &HLXSListTest::HandleAddHeadCmd,
  87.     2);
  88.     cmds[9] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  89.     "AddHeadList",
  90.     &HLXSListTest::HandleAddHeadListCmd,
  91.     2);
  92.     cmds[10] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  93.     "AddTail",
  94.     &HLXSListTest::HandleAddTailCmd,
  95.     2);
  96.     cmds[11] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  97.     "AddTailList",
  98.     &HLXSListTest::HandleAddTailListCmd,
  99.     2);
  100.     cmds[12] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  101.     "RemoveAll",
  102.     &HLXSListTest::HandleRemoveAllCmd,
  103.     1);
  104.     cmds[13] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  105.     "GetHeadPosition",
  106.     &HLXSListTest::HandleGetHeadPosCmd,
  107.     1);
  108.     cmds[14] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  109.     "GetTailPosition",
  110.     &HLXSListTest::HandleGetTailPosCmd,
  111.     1);
  112.     cmds[15] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  113.     "GetNext",
  114.     &HLXSListTest::HandleGetNextCmd,
  115.     2);
  116.     cmds[16] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  117.     "ReplaceNext",
  118.     &HLXSListTest::HandleReplaceNextCmd,
  119.     2);
  120.     cmds[17] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  121.     "GetPrev",
  122.     &HLXSListTest::HandleGetPrevCmd,
  123.     2);
  124.     cmds[18] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  125.     "ReplacePrev",
  126.     &HLXSListTest::HandleReplacePrevCmd,
  127.     2);
  128.     cmds[19] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  129.     "GetAtNext",
  130.     &HLXSListTest::HandleGetAtNextCmd,
  131.     3);
  132.     cmds[20] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  133.     "GetAtPrev",
  134.     &HLXSListTest::HandleGetAtPrevCmd,
  135.     3);
  136.     cmds[21] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  137.     "ReplaceAtPrev",
  138.     &HLXSListTest::HandleReplaceAtPrevCmd,
  139.     2);
  140.     cmds[22] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  141.     "GetAt",
  142.     &HLXSListTest::HandleGetAtCmd,
  143.     2);
  144.     cmds[23] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  145.     "ReplaceAt",
  146.     &HLXSListTest::HandleReplaceAtCmd,
  147.     2);
  148.     cmds[24] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  149.     "SetAt",
  150.     &HLXSListTest::HandleSetAtCmd,
  151.     2);
  152.     cmds[25] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  153.     "RemoveAt",
  154.     &HLXSListTest::HandleRemoveAtCmd,
  155.     1);
  156.     cmds[26] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  157.     "InsertBefore",
  158.     &HLXSListTest::HandleInsertBeforeCmd,
  159.     2);
  160.     cmds[27] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  161.     "InsertAfter",
  162.     &HLXSListTest::HandleInsertAfterCmd,
  163.     2);
  164.     cmds[28] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  165.     "Find",
  166.     &HLXSListTest::HandleFindCmd,
  167.     3);
  168.     cmds[29] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  169.     "FindIndex",
  170.     &HLXSListTest::HandleFindIndexCmd,
  171.     2);
  172.     cmds[30] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  173.     "IsPosValid",
  174.     &HLXSListTest::HandleIsPosValidCmd,
  175.     2);
  176.     cmds[31] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  177.     "ClearPos",
  178.     &HLXSListTest::HandleClearPosCmd,
  179.     1);
  180.     cmds[32] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  181.     "TestIterator",
  182.     &HLXSListTest::HandleTestIteratorCmd,
  183.     1);
  184.     cmds[33] = new HLXUnitTestCmdInfoDisp<HLXSListTest>(this, 
  185.     "Dump",
  186.     &HLXSListTest::HandleDumpCmd,
  187.     1, 2);
  188. }
  189. HLXCmdBasedTest* HLXSListTest::Clone() const
  190. {
  191.     return new HLXSListTest();
  192. }
  193. void* HLXSListTest::CreateValue(int val)
  194. {
  195.     return new int(val);
  196. }
  197. void HLXSListTest::DestroyValue(void* ptr)
  198. {
  199.     delete (int*)ptr;
  200. }
  201. bool HLXSListTest::GetValue(void* ptr, int& val)
  202. {
  203.     bool ret = false;
  204.     if (ptr)
  205.     {
  206. val = *((int*)ptr);
  207. ret = true;
  208.     }
  209.     return ret;
  210. }
  211. bool HLXSListTest::FindValue(int value, LISTPOSITION pos, void*& pValue)
  212. {
  213.     bool ret = false;
  214.     pValue = 0;
  215.     for(; pos && !pValue; m_list.GetNext(pos))
  216.     {
  217. int cur = 0;
  218. if ((GetValue(m_list.GetAt(pos), cur)) &&
  219.     (cur == value))
  220.     pValue = m_list.GetAt(pos);
  221.     }
  222.     if (pValue == 0)
  223.     {
  224. pValue = CreateValue(value);
  225. ret = true;
  226.     }
  227.     return ret;
  228. }
  229. bool HLXSListTest::HandleGetCountCmd(const UTVector<UTString>& info)
  230. {
  231.     bool ret = false;
  232.     int expected = 0;
  233.     if (!UTParamUtil::GetInt(info[1], expected))
  234.     {
  235. DPRINTF(D_ERROR, ("npSList::HandleGetCountCmd : failed to convert parametern"));
  236.     }
  237.     else if (m_list.GetCount() != expected)
  238.     {
  239. DPRINTF(D_ERROR, ("npSList::HandleGetCountCmd : got %d expected %dn",
  240.   m_list.GetCount(),
  241.   expected));
  242.     }
  243.     else
  244. ret = true;
  245.     return ret;
  246. }
  247. bool HLXSListTest::HandleIsEmptyCmd(const UTVector<UTString>& info)
  248. {
  249.     bool ret = false;
  250.     bool expected = false;
  251.     if (!UTParamUtil::GetBool(info[1], expected))
  252.     {
  253. DPRINTF(D_ERROR, ("npSList::HandleIsEmptyCmd : failed to convert parametern"));
  254.     }
  255.     else if ((m_list.IsEmpty() == TRUE) != expected)
  256.     {
  257. DPRINTF(D_ERROR, ("npSList::HandleIsEmptyCmd : got %d expected %dn",
  258.   m_list.IsEmpty(),
  259.   expected));
  260.     }
  261.     else
  262. ret = true;
  263.     
  264.     return ret;
  265. }
  266. bool HLXSListTest::HandleGetHeadCmd(const UTVector<UTString>& info)
  267. {
  268.     bool ret = false;
  269.     
  270.     int expected = 0;
  271.     int result = 0;
  272.     if (!UTParamUtil::GetInt(info[1], expected))
  273.     {
  274. DPRINTF(D_ERROR, ("npSList::HandleGetHeadCmd : failed to convert parametern"));
  275.     }
  276.     else if (!GetValue(m_list.GetHead(), result))
  277.     {
  278. DPRINTF(D_ERROR, ("npSList::HandleGetHeadCmd : failed to get valuen"));
  279.     }
  280.     else if (result != expected)
  281.     {
  282. DPRINTF(D_ERROR, ("npSList::HandleGetHeadCmd : got %d expected %dn",
  283.   result,
  284.   expected));
  285.     }
  286.     else
  287. ret = true;
  288.     return ret;
  289. }
  290. bool HLXSListTest::HandleReplaceHeadCmd(const UTVector<UTString>& info)
  291. {
  292.     bool ret = false;
  293.     int value = 0;
  294.     if (!UTParamUtil::GetInt(info[1], value))
  295.     {
  296. DPRINTF(D_ERROR, ("npSList::HandleReplaceHeadCmd : failed to convert parametern"));
  297.     }
  298.     else
  299.     {
  300. DestroyValue(m_list.GetHead());
  301. m_list.GetHead() = CreateValue(value);
  302. ret = true;
  303.     }
  304.     
  305.     return ret;
  306. }
  307. bool HLXSListTest::HandleGetTailCmd(const UTVector<UTString>& info)
  308. {
  309.     bool ret = false;
  310.     
  311.     int expected = 0;
  312.     int result = 0;
  313.     if (!UTParamUtil::GetInt(info[1], expected))
  314.     {
  315. DPRINTF(D_ERROR, ("npSList::HandleGetTailCmd : failed to convert parametern"));
  316.     }
  317.     else if (!GetValue(m_list.GetTail(), result))
  318.     {
  319. DPRINTF(D_ERROR, ("npSList::HandleGetTailCmd : failed to get valuen"));
  320.     }
  321.     else if (result != expected)
  322.     {
  323. DPRINTF(D_ERROR, ("npSList::HandleGetTailCmd : got %d expected %dn",
  324.   result,
  325.   expected));
  326.     }
  327.     else
  328. ret = true;
  329.     return ret;
  330. }
  331. bool HLXSListTest::HandleReplaceTailCmd(const UTVector<UTString>& info)
  332. {
  333.     bool ret = false;
  334.     int value = 0;
  335.     if (!UTParamUtil::GetInt(info[1], value))
  336.     {
  337. DPRINTF(D_ERROR, ("npSList::HandleReplaceTailCmd : failed to convert parametern"));
  338.     }
  339.     else
  340.     {
  341. DestroyValue(m_list.GetHead());
  342. m_list.GetTail() = CreateValue(value);
  343. ret = true;
  344.     }
  345.     return ret;
  346. }
  347. bool HLXSListTest::HandleRemoveHeadCmd(const UTVector<UTString>& /*info*/)
  348. {
  349.     DestroyValue(m_list.RemoveHead());
  350.     return true;
  351. }
  352. bool HLXSListTest::HandleRemoveTailCmd(const UTVector<UTString>& /*info*/)
  353. {
  354.     DestroyValue(m_list.RemoveTail());
  355.     return true;
  356. }
  357. bool HLXSListTest::HandleAddHeadCmd(const UTVector<UTString>& info)
  358. {
  359.     bool ret = false;
  360.     int value = 0;
  361.     if (!UTParamUtil::GetInt(info[1], value))
  362.     {
  363. DPRINTF(D_ERROR, ("npSList::HandleAddHeadCmd : failed to convert parametern"));
  364.     }
  365.     else
  366.     {
  367. m_list.AddHead(CreateValue(value));
  368. ret = true;
  369.     }
  370.     return ret;
  371. }
  372. bool HLXSListTest::HandleAddHeadListCmd(const UTVector<UTString>& info)
  373. {
  374.     bool ret = false;
  375.     CHXSimpleList list;
  376.     if (!GetList(info[1], list))
  377.     {
  378. DPRINTF(D_ERROR, ("npSList::HandleAddHeadListCmd : failed to convert parametern"));
  379.     }
  380.     else
  381.     {
  382. m_list.AddHead(&list);
  383. ret = true;
  384.     }
  385.     return ret;
  386. }
  387. bool HLXSListTest::HandleAddTailCmd(const UTVector<UTString>& info)
  388. {
  389.     bool ret = false;
  390.     int value = 0;
  391.     if (!UTParamUtil::GetInt(info[1], value))
  392.     {
  393. DPRINTF(D_ERROR, ("npSList::HandleAddTailCmd : failed to convert parametern"));
  394.     }
  395.     else
  396.     {
  397. m_list.AddTail(CreateValue(value));
  398. ret = true;
  399.     }
  400.     return ret;
  401. }
  402. bool HLXSListTest::HandleAddTailListCmd(const UTVector<UTString>& info)
  403. {
  404.     bool ret = false;
  405.     CHXSimpleList list;
  406.     if (!GetList(info[1], list))
  407.     {
  408. DPRINTF(D_ERROR, ("npSList::HandleAddTailListCmd : failed to convert parametern"));
  409.     }
  410.     else
  411.     {
  412. m_list.AddTail(&list);
  413. ret = true;
  414.     }
  415.     return ret;
  416. }
  417. bool HLXSListTest::HandleRemoveAllCmd(const UTVector<UTString>& /*info*/)
  418. {
  419.     m_list.RemoveAll();
  420.     return true;
  421. }
  422. bool HLXSListTest::HandleGetHeadPosCmd(const UTVector<UTString>& /*info*/)
  423. {
  424.     m_pos = m_list.GetHeadPosition();
  425.     return true;
  426. }
  427. bool HLXSListTest::HandleGetTailPosCmd(const UTVector<UTString>& /*info*/)
  428. {
  429.     m_pos = m_list.GetTailPosition();
  430.     return true;
  431. }
  432. bool HLXSListTest::HandleGetNextCmd(const UTVector<UTString>& info)
  433. {
  434.     bool ret = false;
  435.     int expected = 0;
  436.     int result = 0;
  437.     if (!UTParamUtil::GetInt(info[1], expected))
  438.     {
  439. DPRINTF(D_ERROR, ("npSList::HandleGetNextCmd : failed to convert parametern"));
  440.     }
  441.     else if (!GetValue(m_list.GetNext(m_pos), result))
  442.     {
  443. DPRINTF(D_ERROR, ("npSList::HandleGetNextCmd : failed to get valuen"));
  444.     }
  445.     else if (result != expected)
  446.     {
  447. DPRINTF(D_ERROR, ("npSList::HandleGetNextCmd : got %d expected %dn",
  448.   result,
  449.   expected));
  450.     }
  451.     else
  452. ret = true;
  453.     return ret;
  454. }
  455. bool HLXSListTest::HandleReplaceNextCmd(const UTVector<UTString>& info)
  456. {
  457.     bool ret = false;
  458.     int value = 0;
  459.     if (!UTParamUtil::GetInt(info[1], value))
  460.     {
  461. DPRINTF(D_ERROR, ("npSList::HandleReplaceNextCmd : failed to convert parametern"));
  462.     }
  463.     else
  464.     {
  465. LISTPOSITION tmpPos = m_pos;
  466. DestroyValue(m_list.GetNext(tmpPos));
  467. m_list.GetNext(m_pos) = CreateValue(value);
  468. ret = true;
  469.     }
  470.     return ret;
  471. }
  472. bool HLXSListTest::HandleGetPrevCmd(const UTVector<UTString>& info)
  473. {
  474.     bool ret = false;
  475.     int expected = 0;
  476.     int result = 0;
  477.     if (!UTParamUtil::GetInt(info[1], expected))
  478.     {
  479. DPRINTF(D_ERROR, ("npSList::HandleGetPrevCmd : failed to convert parametern"));
  480.     }
  481.     else if (!GetValue(m_list.GetPrev(m_pos), result))
  482.     {
  483. DPRINTF(D_ERROR, ("npSList::HandleGetPrevCmd : failed to get valuen"));
  484.     }
  485.     else if (result != expected)
  486.     {
  487. DPRINTF(D_ERROR, ("npSList::HandleGetPrevCmd : got %d expected %dn",
  488.   result,
  489.   expected));
  490.     }
  491.     else
  492. ret = true;
  493.     return ret;
  494. }
  495. bool HLXSListTest::HandleReplacePrevCmd(const UTVector<UTString>& info)
  496. {
  497.     bool ret = false;
  498.     int value = 0;
  499.     if (!UTParamUtil::GetInt(info[1], value))
  500.     {
  501. DPRINTF(D_ERROR, ("npSList::HandleReplacePrevCmd : failed to convert parametern"));
  502.     }
  503.     else
  504.     {
  505. LISTPOSITION tmpPos = m_pos;
  506. DestroyValue(m_list.GetPrev(tmpPos));
  507. m_list.GetPrev(m_pos) = CreateValue(value);
  508. ret = true;
  509.     }
  510.     return ret;
  511. }
  512. bool HLXSListTest::HandleGetAtNextCmd(const UTVector<UTString>& info)
  513. {
  514.     bool ret = false;
  515.     bool expectValid = false;
  516.     int expected = 0;
  517.     if (!UTParamUtil::GetBool(info[1], expectValid) ||
  518. !UTParamUtil::GetInt(info[2], expected))
  519.     {
  520. DPRINTF(D_ERROR, ("npSList::HandleGetAtNextCmd : failed to convert parametern"));
  521.     }
  522.     else
  523.     {
  524. int result = 0;
  525. bool resultValid = GetValue(m_list.GetAtNext(m_pos), result);
  526. if (expectValid != resultValid)
  527. {
  528.     DPRINTF(D_ERROR, ("npSList::HandleGetAtNextCmd : got valid=%d expected valid=%dn",
  529.       resultValid,
  530.       expectValid));
  531. }
  532. else if (expectValid && (result != expected))
  533. {
  534.     DPRINTF(D_ERROR, ("npSList::HandleGetAtNextCmd : got %d expected %dn",
  535.       result,
  536.       expected));
  537. }
  538. else
  539.     ret = true;
  540.     }
  541.     return ret;
  542. }
  543. bool HLXSListTest::HandleGetAtPrevCmd(const UTVector<UTString>& info)
  544. {
  545.     bool ret = false;
  546.     bool expectValid = false;
  547.     int expected = 0;
  548.     if (!UTParamUtil::GetBool(info[1], expectValid) ||
  549. !UTParamUtil::GetInt(info[2], expected))
  550.     {
  551. DPRINTF(D_ERROR, ("npSList::HandleGetAtPrevCmd : failed to convert parametern"));
  552.     }
  553.     else
  554.     {
  555. int result = 0;
  556. bool resultValid = GetValue(m_list.GetAtPrev(m_pos), result);
  557. if (expectValid != resultValid)
  558. {
  559.     DPRINTF(D_ERROR, ("npSList::HandleGetAtPrevCmd : got valid=%d expected valid=%dn",
  560.       resultValid,
  561.       expectValid));
  562. }
  563. else if (expectValid && (result != expected))
  564. {
  565.     DPRINTF(D_ERROR, ("npSList::HandleGetAtPrevCmd : got %d expected %dn",
  566.       result,
  567.       expected));
  568. }
  569. else
  570.     ret = true;
  571.     }
  572.     return ret;
  573. }
  574. bool HLXSListTest::HandleReplaceAtPrevCmd(const UTVector<UTString>& info)
  575. {
  576.     bool ret = false;
  577.     int value = 0;
  578.     if (!UTParamUtil::GetInt(info[1], value))
  579.     {
  580. DPRINTF(D_ERROR, ("npSList::HandleReplaceAtPrevCmd : failed to convert parametern"));
  581.     }
  582.     else
  583.     {
  584. LISTPOSITION tmpPos = m_pos;
  585. DestroyValue(m_list.GetAtPrev(tmpPos));
  586. m_list.GetAtPrev(m_pos) = CreateValue(value);
  587. ret = true;
  588.     }
  589.     return ret;
  590. }
  591. bool HLXSListTest::HandleGetAtCmd(const UTVector<UTString>& info)
  592. {
  593.     bool ret = false;
  594.     int expected = 0;
  595.     if (!UTParamUtil::GetInt(info[1], expected))
  596.     {
  597. DPRINTF(D_ERROR, ("npSList::HandleGetAtCmd : failed to convert parametern"));
  598.     }
  599.     else
  600.     {
  601. int result = 0;
  602. if (!GetValue(m_list.GetAt(m_pos), result))
  603. {
  604.     DPRINTF(D_ERROR, ("npSList::HandleGetAtCmd : invalid valuen"));
  605. }
  606. else if (result != expected)
  607. {
  608.     DPRINTF(D_ERROR, ("npSList::HandleGetAtCmd : got %d expected %dn",
  609.       result,
  610.       expected));
  611. }
  612. else
  613.     ret = true;
  614.     }
  615.     return ret;
  616. }
  617. bool HLXSListTest::HandleReplaceAtCmd(const UTVector<UTString>& info)
  618. {
  619.     bool ret = false;
  620.     int value = 0;
  621.     if (!UTParamUtil::GetInt(info[1], value))
  622.     {
  623. DPRINTF(D_ERROR, ("npSList::HandleReplaceAtCmd : failed to convert parametern"));
  624.     }
  625.     else
  626.     {
  627. DestroyValue(m_list.GetAt(m_pos));
  628. m_list.GetAt(m_pos) = CreateValue(value);
  629. ret = true;
  630.     }
  631.     
  632.     return ret;
  633. }
  634. bool HLXSListTest::HandleSetAtCmd(const UTVector<UTString>& info)
  635. {
  636.     bool ret = false;
  637.     int value = 0;
  638.     if (!UTParamUtil::GetInt(info[1], value))
  639.     {
  640. DPRINTF(D_ERROR, ("npSList::HandleSetAtCmd : failed to convert parametern"));
  641.     }
  642.     else
  643.     {
  644. DestroyValue(m_list.GetAt(m_pos));
  645. m_list.SetAt(m_pos, CreateValue(value));
  646. ret = true;
  647.     }
  648.     return ret;
  649. }
  650. bool HLXSListTest::HandleRemoveAtCmd(const UTVector<UTString>& /*info*/)
  651. {
  652.     m_pos = m_list.RemoveAt(m_pos);
  653.     return true;
  654. }
  655. bool HLXSListTest::HandleInsertBeforeCmd(const UTVector<UTString>& info)
  656. {
  657.     bool ret = false;
  658.     int value = 0;
  659.     if (!UTParamUtil::GetInt(info[1], value))
  660.     {
  661. DPRINTF(D_ERROR, ("npSList::HandleInsertBeforeCmd : failed to convert parametern"));
  662.     }
  663.     else
  664.     {
  665. m_pos = m_list.InsertBefore(m_pos, CreateValue(value));
  666. ret = true;
  667.     }
  668.     return ret;
  669. }
  670. bool HLXSListTest::HandleInsertAfterCmd(const UTVector<UTString>& info)
  671. {
  672.     bool ret = false;
  673.     int value = 0;
  674.     if (!UTParamUtil::GetInt(info[1], value))
  675.     {
  676. DPRINTF(D_ERROR, ("npSList::HandleInsertAfterCmd : failed to convert parametern"));
  677.     }
  678.     else
  679.     {
  680. m_pos = m_list.InsertAfter(m_pos, CreateValue(value));
  681. ret = true;
  682.     }
  683.     return ret;
  684. }
  685. bool HLXSListTest::HandleFindCmd(const UTVector<UTString>& info)
  686. {
  687.     bool ret = false;
  688.     int value = 0;
  689.     bool useCurrentPos = false;
  690.     if (!UTParamUtil::GetInt(info[1], value) ||
  691. !UTParamUtil::GetBool(info[2], useCurrentPos))
  692.     {
  693. DPRINTF(D_ERROR, ("npSList::HandleFindCmd : failed to convert parametern"));
  694.     }
  695.     else
  696.     {
  697. LISTPOSITION pos = (useCurrentPos) ? m_pos : m_list.GetHeadPosition();
  698. void* pValue = 0;
  699. bool destroyValue = FindValue(value, pos, pValue);
  700. if (useCurrentPos)
  701.     m_pos = m_list.Find(pValue, pos);
  702. else
  703.     m_pos =  m_list.Find(pValue);
  704. if (destroyValue)
  705.     DestroyValue(pValue);
  706. ret = true;
  707.     }
  708.     return ret;
  709. }
  710. bool HLXSListTest::HandleFindIndexCmd(const UTVector<UTString>& info)
  711. {
  712.     bool ret = false;
  713.     int index = 0;
  714.     if (!UTParamUtil::GetInt(info[1], index))
  715.     {
  716. DPRINTF(D_ERROR, ("npSList::HandleFindCmd : failed to convert parametern"));
  717.     }
  718.     else
  719.     {
  720. m_pos = m_list.FindIndex(index);
  721. ret = true;
  722.     }
  723.     return ret;
  724. }
  725. bool HLXSListTest::HandleIsPosValidCmd(const UTVector<UTString>& info)
  726. {
  727.     bool ret = false;
  728.     bool expected = false;
  729.     if (!UTParamUtil::GetBool(info[1], expected))
  730.     {
  731. DPRINTF(D_ERROR, ("npSList::HandleIsPosValidCmd : failed to convert parametern"));
  732.     }
  733.     else 
  734.     {
  735. bool result = (m_pos != 0);
  736. if (result != expected)
  737. {
  738.     DPRINTF(D_ERROR, ("npSList::HandleIsPosValidCmd : got %d expected %dn",
  739.       result,
  740.       expected));
  741. }
  742. else
  743.     ret = true;
  744.     }
  745.     return ret;
  746. }
  747. bool HLXSListTest::HandleClearPosCmd(const UTVector<UTString>& /*info*/)
  748. {
  749.     m_pos = 0;
  750.     return true;
  751. }
  752. bool HLXSListTest::HandleTestIteratorCmd(const UTVector<UTString>& /*info*/)
  753. {
  754.     bool ret = true;
  755.     LISTPOSITION pos = m_list.GetHeadPosition();
  756.     CHXSimpleList::Iterator itr = m_list.Begin();
  757.     for(; ret && (itr != m_list.End()) && pos; ++itr)
  758.     {
  759. int expected = 0;
  760. int result = 0;
  761. if (!GetValue(m_list.GetNext(pos), expected))
  762. {
  763.     DPRINTF (D_ERROR,("HLXSListTest::HandleTestIteratorCmd() : failed to get expected valuen"));
  764.     ret = false;
  765. }
  766. else if (!GetValue(*itr, result))
  767. {
  768.     DPRINTF (D_ERROR,("HLXSListTest::HandleTestIteratorCmd() : failed to get result valuen"));
  769.     ret = false;
  770. }
  771. else if (expected != result)
  772. {
  773.     DPRINTF (D_ERROR,("HLXSListTest::HandleTestIteratorCmd() : got %d expected %dn",
  774.       result,
  775.       expected));
  776.     ret = false;
  777. }
  778.     }
  779.     if (ret)
  780.     {
  781. // The comparisons are arranged this way so 
  782. // that I can test the == operator
  783. if (itr == m_list.End())
  784. {
  785.     if (pos != 0)
  786.     {
  787. DPRINTF (D_ERROR,("HLXSListTest::HandleTestIteratorCmd() : Position is not at the endn"));
  788. ret = false;
  789.     }
  790. }
  791. else
  792. {
  793.     DPRINTF (D_ERROR,("HLXSListTest::HandleTestIteratorCmd() : iterator not at the endn"));
  794.     ret = false;
  795. }
  796.     }
  797.     return ret;
  798. }
  799. bool HLXSListTest::HandleDumpCmd(const UTVector<UTString>& info)
  800. {
  801.     if (info.Nelements() >= 2) m_list.Dump((const char*)info[1]);
  802.     else m_list.Dump();
  803.     return true;
  804. }