1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:    CGlxFetchErrorArray unit tests

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 //  CLASS HEADER

    22 #include "t_cglxfetcherrorarray.h"

    23 

    24 //  EXTERNAL INCLUDES

    25 #include <digia/eunit/EUnitMacros.h>

    26 #include <digia/eunit/EUnitDecorators.h>

    27 

    28 #include <mpxmediageneraldefs.h>

    29 

    30 #include <glxmediageneraldefs.h>

    31 

    32 //  INTERNAL INCLUDES

    33 #include "glxfetcherrorarray.h"

    34 #include "glxfetcherror.h"

    35 

    36 const TInt KTestMediaIdGeneral = 1;

    37 

    38 // CONSTRUCTION

    39 T_CGlxFetchErrorArray* T_CGlxFetchErrorArray::NewL()

    40     {

    41     T_CGlxFetchErrorArray* self = T_CGlxFetchErrorArray::NewLC();

    42     CleanupStack::Pop();

    43 

    44     return self;

    45     }

    46 

    47 T_CGlxFetchErrorArray* T_CGlxFetchErrorArray::NewLC()

    48     {

    49     T_CGlxFetchErrorArray* self = new( ELeave ) T_CGlxFetchErrorArray();

    50     CleanupStack::PushL( self );

    51 

    52     self->ConstructL();

    53 

    54     return self;

    55     }

    56 

    57 // Destructor (virtual by CBase)

    58 T_CGlxFetchErrorArray::~T_CGlxFetchErrorArray()

    59     {

    60     }

    61 

    62 // Default constructor

    63 T_CGlxFetchErrorArray::T_CGlxFetchErrorArray()

    64     {

    65     }

    66 

    67 // Second phase construct

    68 void T_CGlxFetchErrorArray::ConstructL()

    69     {

    70     // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    71     // It generates the test case table.

    72     CEUnitTestSuiteClass::ConstructL();

    73     }

    74 

    75 //  METHODS

    76 

    77 

    78 void T_CGlxFetchErrorArray::SetupL(  )

    79     {

    80     EUNIT_PRINT(_L("Initial setup"));

    81 

    82     EUNIT_PRINT(_L("ErrorArray1 has 2 errors"));

    83     iCGlxFetchErrorArray1 = new (ELeave) CGlxFetchErrorArray();

    84 

    85     TGlxFetchError error1(KMPXMediaGeneralSize, KErrNotSupported);

    86     iCGlxFetchErrorArray1->AddErrorL(error1);

    87 

    88     TGlxFetchError error2(KGlxMediaGeneralSystemItem, KErrNotFound);

    89     iCGlxFetchErrorArray1->AddErrorL(error2);

    90 

    91     EUNIT_PRINT(_L("ErrorArray2 has 0 errors"));

    92     iCGlxFetchErrorArray2 = new (ELeave) CGlxFetchErrorArray();

    93     }

    94     

    95 

    96 void T_CGlxFetchErrorArray::Teardown(  )

    97     {

    98     delete iCGlxFetchErrorArray1; 

    99     iCGlxFetchErrorArray1 = NULL; 

   100 

   101     delete iCGlxFetchErrorArray2; 

   102     iCGlxFetchErrorArray2 = NULL; 

   103     }

   104     

   105 

   106 void T_CGlxFetchErrorArray::T_CGlxFetchErrorArray_ErrorCountL(  )

   107     {

   108     // Check ErrorArray1 has 2 errors

   109     EUNIT_PRINT(_L("Check ErrorArray1 has 2 errors"));

   110     EUNIT_ASSERT_DESC(iCGlxFetchErrorArray1->ErrorCount() == 2, "Incorrect error count");

   111 

   112     // Check ErrorArray2 has 0 errors

   113     EUNIT_PRINT(_L("Check ErrorArray2 has 0 errors"));

   114     EUNIT_ASSERT_DESC(iCGlxFetchErrorArray2->ErrorCount() == 0, "Incorrect error count");

   115     }

   116     

   117 void T_CGlxFetchErrorArray::T_CGlxFetchErrorArray_ErrorL(  )

   118     {

   119     // Obtain error at index 0

   120     EUNIT_PRINT(_L("Obtain error at ErrorArray1 index 0"));

   121     const TGlxFetchError& error1 = iCGlxFetchErrorArray1->Error(0);

   122 

   123     EUNIT_PRINT(_L("Check error at ErrorArray1 index 0"));

   124     EUNIT_ASSERT_DESC(error1.iAttr == KMPXMediaGeneralSize && error1.iError == KErrNotSupported, "Incorrect error returned");

   125 

   126     // Obtain error at index 1

   127     EUNIT_PRINT(_L("Obtain error at ErrorArray1 index 1"));

   128     const TGlxFetchError& error2 = iCGlxFetchErrorArray1->Error(1);

   129 

   130     EUNIT_PRINT(_L("Check error at ErrorArray1 index 1"));

   131     EUNIT_ASSERT_DESC(error2.iAttr == KGlxMediaGeneralSystemItem && error2.iError == KErrNotFound, "Incorrect error returned");

   132     }

   133     

   134 void T_CGlxFetchErrorArray::T_CGlxFetchErrorArray_AddErrorLL(  )

   135     {

   136     // Add existing error

   137     EUNIT_PRINT(_L("Add existing error to ErrorArray1"));

   138     TGlxFetchError error1(KMPXMediaGeneralSize, KErrGeneral);

   139     iCGlxFetchErrorArray1->AddErrorL(error1);

   140 

   141     EUNIT_PRINT(_L("Check ErrorArray1 still has 2 errors"));

   142     EUNIT_ASSERT_DESC(iCGlxFetchErrorArray1->ErrorCount() == 2, "Incorrect error count");

   143 

   144     const TGlxFetchError& storedError1 = iCGlxFetchErrorArray1->Error(0);

   145     EUNIT_ASSERT_DESC(storedError1.iAttr == KMPXMediaGeneralSize && storedError1.iError == KErrGeneral, "Incorrect error returned");

   146 

   147     // Add new error

   148     EUNIT_PRINT(_L("Add new error to ErrorArray2"));

   149     TGlxFetchError error2(KMPXMediaGeneralDate, KErrCorrupt);

   150     iCGlxFetchErrorArray2->AddErrorL(error2);

   151 

   152     EUNIT_PRINT(_L("Check ErrorArray2 has 1 new error"));

   153     EUNIT_ASSERT_DESC(iCGlxFetchErrorArray2->ErrorCount() == 1, "Incorrect error count");

   154 

   155     const TGlxFetchError& storedError2 = iCGlxFetchErrorArray2->Error(0);

   156     EUNIT_ASSERT_DESC(storedError2.iAttr == KMPXMediaGeneralDate && storedError2.iError == KErrCorrupt, "Incorrect error returned");

   157     }

   158     

   159 void T_CGlxFetchErrorArray::T_CGlxFetchErrorArray_RemoveL(  )

   160     {

   161     // Remove error at index 1

   162     EUNIT_PRINT(_L("Remove error at ErrorArray1 index 1"));

   163     iCGlxFetchErrorArray1->Remove(1);

   164 

   165     EUNIT_PRINT(_L("Check ErrorArray1 still has 1 error"));

   166     EUNIT_ASSERT_DESC(iCGlxFetchErrorArray1->ErrorCount() == 1, "Incorrect error count");

   167 

   168     const TGlxFetchError& storedError1 = iCGlxFetchErrorArray1->Error(0);

   169     EUNIT_ASSERT_DESC(storedError1.iAttr == KMPXMediaGeneralSize && storedError1.iError == KErrNotSupported, "Incorrect error returned");

   170     }

   171     

   172 void T_CGlxFetchErrorArray::T_CGlxFetchErrorArray_FindErrorL(  )

   173     {

   174     // Find existing error

   175     EUNIT_PRINT(_L("Find existing error in ErrorArray1"));

   176 

   177     EUNIT_PRINT(_L("Check correct ErrorArray1 index returned"));

   178     EUNIT_ASSERT_DESC(iCGlxFetchErrorArray1->FindError(KMPXMediaGeneralSize) == 0, "Incorrect index for error");

   179 

   180     // Find non-existing error

   181     EUNIT_PRINT(_L("Find non-existing error in ErrorArray1"));

   182 

   183     EUNIT_PRINT(_L("Check KErrNotFound returned"));

   184     EUNIT_ASSERT_DESC(iCGlxFetchErrorArray1->FindError(KMPXMediaGeneralTitle) == KErrNotFound, "Index should be KErrNotFound");

   185 

   186     // Find non-existing error on empty ErrorArray2

   187     EUNIT_PRINT(_L("Find non-existing error in empty ErrorArray2"));

   188 

   189     EUNIT_PRINT(_L("Check KErrNotFound returned"));

   190     EUNIT_ASSERT_DESC(iCGlxFetchErrorArray2->FindError(KMPXMediaGeneralSize) == KErrNotFound, "Index should be KErrNotFound");

   191     }

   192     

   193 void T_CGlxFetchErrorArray::T_CGlxFetchErrorArray_FindError2L(  )

   194     {

   195     // Find KMPXMediaIdGeneral errors

   196     EUNIT_PRINT(_L("Find KMPXMediaIdGeneral errors in ErrorArray1"));

   197 

   198     EUNIT_PRINT(_L("Check correct ErrorArray1 index returned"));

   199     EUNIT_ASSERT_DESC(iCGlxFetchErrorArray1->FindError(KMPXMediaIdGeneral) == 0, "Incorrect index for error");

   200 

   201     // Find KGlxMediaIdGeneral errors

   202     EUNIT_PRINT(_L("Find KGlxMediaIdGeneral errors in ErrorArray1"));

   203 

   204     EUNIT_PRINT(_L("Check correct ErrorArray1 index returned"));

   205     EUNIT_ASSERT_DESC(iCGlxFetchErrorArray1->FindError(KGlxMediaIdGeneral) == 1, "Incorrect index for error");

   206 

   207     // Find non-existing error

   208     EUNIT_PRINT(_L("Find non-existing error in ErrorArray1"));

   209 

   210     EUNIT_PRINT(_L("Check KErrNotFound returned"));

   211     EUNIT_ASSERT_DESC(iCGlxFetchErrorArray1->FindError(KTestMediaIdGeneral) == KErrNotFound, "Index should be KErrNotFound");

   212 

   213     // Find non-existing error on empty ErrorArray2

   214     EUNIT_PRINT(_L("Find non-existing error on empty ErrorArray2"));

   215 

   216     EUNIT_PRINT(_L("Check KErrNotFound returned"));

   217     EUNIT_ASSERT_DESC(iCGlxFetchErrorArray2->FindError(KTestMediaIdGeneral) == KErrNotFound, "Index should be KErrNotFound");

   218     }

   219     

   220 

   221 //  TEST TABLE

   222 EUNIT_BEGIN_TEST_TABLE(

   223     T_CGlxFetchErrorArray,

   224     "Add test suite description here.",

   225     "UNIT" )

   226 

   227 EUNIT_TEST(

   228     "ErrorCount - test1",

   229     "CGlxFetchErrorArray",

   230     "ErrorCount - test1",

   231     "FUNCTIONALITY",

   232     SetupL, T_CGlxFetchErrorArray_ErrorCountL, Teardown)

   233     

   234 EUNIT_TEST(

   235     "Error - test2",

   236     "CGlxFetchErrorArray",

   237     "Error - test2",

   238     "FUNCTIONALITY",

   239     SetupL, T_CGlxFetchErrorArray_ErrorL, Teardown)

   240     

   241 EUNIT_TEST(

   242     "AddErrorL - test3",

   243     "CGlxFetchErrorArray",

   244     "AddErrorL - test3",

   245     "FUNCTIONALITY",

   246     SetupL, T_CGlxFetchErrorArray_AddErrorLL, Teardown)

   247     

   248 EUNIT_TEST(

   249     "Remove - test4",

   250     "CGlxFetchErrorArray",

   251     "Remove - test4",

   252     "FUNCTIONALITY",

   253     SetupL, T_CGlxFetchErrorArray_RemoveL, Teardown)

   254     

   255 EUNIT_TEST(

   256     "FindError - test5",

   257     "CGlxFetchErrorArray",

   258     "FindError - test5",

   259     "FUNCTIONALITY",

   260     SetupL, T_CGlxFetchErrorArray_FindErrorL, Teardown)

   261     

   262 EUNIT_TEST(

   263     "FindError - test6",

   264     "CGlxFetchErrorArray",

   265     "FindError - test6",

   266     "FUNCTIONALITY",

   267     SetupL, T_CGlxFetchErrorArray_FindError2L, Teardown)

   268     

   269 

   270 EUNIT_END_TEST_TABLE

   271 

   272 //  END OF FILE