1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @test

    19 */

    20 #ifndef EGLTEST_GETERRORANDDISPLAY_H

    21 #define EGLTEST_GETERRORANDDISPLAY_H

    22 

    23 #include "eglteststep.h"

    24 

    25 _LIT(KGetError, "GetError");

    26 NONSHARABLE_CLASS(CEglTest_GetError) : public CEglTestStep

    27     {

    28 public:

    29     TVerdict doTestStepL();    

    30     };

    31 

    32 _LIT(KGetErrorMultiThread, "GetErrorMultiThread");

    33 NONSHARABLE_CLASS(CEglTest_GetErrorMultiThread) : public CEglTestStep

    34     {

    35 public:

    36     TVerdict doTestStepL();

    37 protected:

    38     // from CEglTestStep

    39     void doThreadFunctionL(TInt aIdx);

    40     };

    41 

    42 _LIT(KDisplay_Positive_Basic, "Display_Positive_Basic");

    43 NONSHARABLE_CLASS(CEglTest_Display_Positive_Basic) : public CEglTestStep

    44     {

    45 public:

    46     TVerdict doTestStepL();    

    47     };

    48 

    49 _LIT(KDisplay_Negative_InvalidDisplay, "Display_Negative_InvalidDisplay");

    50 NONSHARABLE_CLASS(CEglTest_Display_Negative_InvalidDisplay) : public CEglTestStep

    51     {

    52 public:

    53     TVerdict doTestStepL();    

    54     };

    55 

    56 _LIT(KDisplay_Negative_NotInitializedDisplay, "Display_Negative_NotInitializedDisplay");

    57 NONSHARABLE_CLASS(CEglTest_Display_Negative_NotInitializedDisplay) : public CEglTestStep

    58     {

    59 public:

    60     TVerdict doTestStepL();    

    61     };

    62 

    63 _LIT(KDisplay_Positive_ReinitializeDisplay, "Display_Positive_ReinitializeDisplay");

    64 NONSHARABLE_CLASS(CEglTest_Display_Positive_ReinitializeDisplay) : public CEglTestStep

    65     {

    66 public:

    67     TVerdict doTestStepL();    

    68     };

    69 

    70 _LIT(KDisplay_Positive_MultipleInitialization, "Display_Positive_MultipleInitialization");

    71 NONSHARABLE_CLASS(CEglTest_Display_Positive_MultipleInitialization) : public CEglTestStep

    72     {

    73 public:

    74     TVerdict doTestStepL();    

    75     };

    76 

    77 _LIT(KDisplay_Positive_MultipleTermination, "Display_Positive_MultipleTermination");

    78 NONSHARABLE_CLASS(CEglTest_Display_Positive_MultipleTermination) : public CEglTestStep

    79     {

    80 public:

    81     TVerdict doTestStepL();    

    82     };

    83 

    84 _LIT(KDisplay_Positive_Multithread_Basic, "Display_Positive_Multithread_Basic");

    85 NONSHARABLE_CLASS(CEglTest_Display_Positive_Multithread_Basic) : public CEglTestStep

    86     {

    87 public:

    88     TVerdict doTestStepL();    

    89 protected:

    90     // from CEglTestStep

    91     void doThreadFunctionL(TInt aIdx);

    92     };

    93 

    94 _LIT(KDisplay_Positive_Multithread_InitTerminateInOneTread, "Display_Positive_Multithread_InitTerminateInOneTread");

    95 NONSHARABLE_CLASS(CEglTest_Display_Positive_Multithread_InitTerminateInOneTread) : public CEglTestStep

    96     {

    97 public:

    98     TVerdict doTestStepL();    

    99 protected:

   100     // from CEglTestStep

   101     void doThreadFunctionL(TInt aIdx);

   102     };

   103 

   104 _LIT(KDisplay_Positive_Multithread_InitTerminateFromDifferentThread, "Display_Positive_Multithread_InitTerminateFromDifferentThread");

   105 NONSHARABLE_CLASS(CEglTest_Display_Positive_Multithread_InitTerminateFromDifferentThread) : public CEglTestStep

   106     {

   107 public:

   108     TVerdict doTestStepL();    

   109 protected:

   110     // from CEglTestStep

   111     void doThreadFunctionL(TInt aIdx);

   112     };

   113 

   114 _LIT(KDisplay_Positive_Multithread_Stress, "Display_Positive_Multithread_Stress");

   115 NONSHARABLE_CLASS(CEglTest_Display_Positive_Multithread_Stress) : public CEglTestStep

   116     {

   117 public:

   118     TVerdict doTestStepL();    

   119 protected:

   120     // from CEglTestStep

   121     void doThreadFunctionL(TInt aIdx);

   122     };

   123 

   124 _LIT(KDisplay_Positive_Multiprocess_Basic, "Display_Positive_Multiprocess_Basic");

   125 NONSHARABLE_CLASS(CEglTest_Display_Positive_Multiprocess_Basic) : public CEglTestStep

   126     {

   127 public:

   128     TVerdict doTestStepL();    

   129 protected:

   130     // from CEglTestStep

   131     void doProcessFunctionL(TInt aIdx);

   132     };

   133 

   134 _LIT(KDisplay_OOM_ClientHeap, "Display_OOM_ClientHeap");

   135 NONSHARABLE_CLASS(CEglTest_Display_OOM_ClientHeap) : public CEglTestStep

   136     {

   137 public:

   138     TVerdict doTestStepL();

   139     };

   140 

   141 _LIT(KDisplay_OOM_ClientHeap_Initialize, "Display_OOM_ClientHeap_Initialize");

   142 NONSHARABLE_CLASS(CEglTest_Display_OOM_ClientHeap_Initialize) : public CEglTestStep

   143     {

   144 public:

   145     TVerdict doTestStepL();

   146     };

   147 #endif // EGLTEST_GETERRORANDDISPLAY_H