Mercurial Mercurial > oss > FCL > sf > tools > rndtools / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
stifui/qt/src/stifexecutor.cpp
branchRCL_3
changeset 13 822c625f7adc
parent 9 404ad6c9bc20
child 17 65b472535a0d
equal deleted inserted replaced
11:454d022d514b 13:822c625f7adc 
    19 #include <e32cons.h>
 
    19 #include <e32cons.h>
 
    20 #include <e32svr.h>
 
    20 #include <e32svr.h>
 
    21 #include <f32file.h>
 
    21 #include <f32file.h>
 
    22 #include <HAL.h>
 
    22 #include <HAL.h>
 
    23 #include <hal_data.h>
 
    23 #include <hal_data.h>
 
    24 #include <stiflogger.h>
 
    24 #include "stiflogger.h"
 
    25 #include <QString>
 
    25 #include <QString>
 
    26 #include "stifexecutor.h"
 
    26 #include "stifexecutor.h"
 
    27 #include "StifTFwIf.h"
 
    27 #include "StifTFwIf.h"
 
    28 
    28 
       
    29 _LIT( KLogPath, "\\Logs\\STFUI\\" ); 
       
    30 // Log file
 
       
    31 _LIT( KLogFile, "StifUi.log" ); 
    29 
    32 
    30 CStifExecutor::CStifExecutor() :
 
    33 CStifExecutor::CStifExecutor() :
 
    31     listenerList(NULL)
 
    34     listenerList(NULL)
 
    32     {
 
    35     {
 
    33 //    __LOG(_L("started"));
 
    36     iLog = CStifLogger::NewL( KLogPath, 
       
    37             KLogFile,
 
       
    38             CStifLogger::ETxt,
 
       
    39             CStifLogger::EFile,
 
       
    40             ETrue,
 
       
    41             ETrue,
 
       
    42             ETrue,
 
       
    43             EFalse,
 
       
    44             ETrue,
 
       
    45             EFalse,
 
       
    46             100 );
 
       
    47 
       
    48 
       
    49     iLog->Log(_L("started"));
 
    34     TInt result;
 
    50     TInt result;
 
    35     TRAP(result, CUIStoreIf::ConstructL());
 
    51     TRAP(result, CUIStoreIf::ConstructL());
 
    36 //    __LOG1(_L("CUIStoreIf ConstructL, result=%d"), result);
 
    52     iLog->Log(_L("CUIStoreIf ConstructL, result=%d"), result);
 
    37     if (result != KErrNone)
 
    53     if (result != KErrNone)
 
    38         {
 
    54         {
 
    39         return;
 
    55         return;
 
    40         }
 
    56         }
 
    41     TRAP(result, iBuffer = HBufC::NewL(500));
 
    57     TRAP(result, iBuffer = HBufC::NewL(500));
 
    42 //    __LOG1(_L("Create Case Execution output buffer, result=%d"), result);
 
    58     iLog->Log(_L("Create Case Execution output buffer, result=%d"), result);
 
    43 
    59 
    44     }
 
    60     }
 
    45 
    61 
    46 CStifExecutor::~CStifExecutor()
 
    62 CStifExecutor::~CStifExecutor()
 
    47     {
 
    63     {
 
    50     if (listenerList)
 
    66     if (listenerList)
 
    51         {
 
    67         {
 
    52         delete listenerList;
 
    68         delete listenerList;
 
    53         listenerList = NULL;
 
    69         listenerList = NULL;
 
    54         }
 
    70         }
 
    55 //    __LOG(_L("finished"));
 
    71     iLog->Log(_L("finished"));
 
    56     }
 
    72     }
 
    57 
    73 
    58 bool CStifExecutor::OpenIniFile(const QString& filename)
 
    74 bool CStifExecutor::OpenIniFile(const QString& filename)
 
    59     {
 
    75     {
 
    60     TInt result = UIStore().Open(QString2TPtrC(filename));
 
    76     TInt result = UIStore().Open(QString2TPtrC(filename));
 
    61 //    __LOG2(_L("Open ini file %s.result=%d"),QString2TPtrC(filename).Ptr(),result);
 
    77     iLog->Log(_L("Open ini file %s.result=%d"),QString2TPtrC(filename).Ptr(),result);
 
    62     return (result == KErrNone);
 
    78     return (result == KErrNone);
 
    63     }
 
    79     }
 
    64 
    80 
    65 TPtrC CStifExecutor::QString2TPtrC(const QString& aString)
 
    81 TPtrC CStifExecutor::QString2TPtrC(const QString& aString)
 
    66     {
 
    82     {
 
    76     QString rst = QString::fromUtf16(des.Ptr(), des.Length());
 
    92     QString rst = QString::fromUtf16(des.Ptr(), des.Length());
 
    77     return rst;
 
    93     return rst;
 
    78     //#endif
 
    94     //#endif
 
    79     }
 
    95     }
 
    80 
    96 
       
    97 bool CStifExecutor::LogResult(const TInt result,const QString str)
 
       
    98     {
 
       
    99     QString tmp = str + " result=%d";
 
       
   100     iLog->Log(QString2TPtrC(tmp), result);
 
       
   101     bool rst = true;
 
       
   102     if(result != KErrNone)
 
       
   103         {
 
       
   104         rst = false;
 
       
   105         }
 
       
   106     return rst;
 
       
   107     }
 
       
   108 
    81 void CStifExecutor::AddStifCaseUpdateListener(
 
   109 void CStifExecutor::AddStifCaseUpdateListener(
 
    82         IStifCaseUpdateListener* listener)
 
   110         IStifCaseUpdateListener* listener)
 
    83     {
 
   111     {
 
    84 //    __LOG(_L("AddStifCaseUpdateListener"));
 
   112     iLog->Log(_L("AddStifCaseUpdateListener"));
 
    85     if (!listenerList)
 
   113     if (!listenerList)
 
    86         {
 
   114         {
 
    87         listenerList = new QList<IStifCaseUpdateListener*> ();
 
   115         listenerList = new QList<IStifCaseUpdateListener*> ();
 
    88         }
 
   116         }
 
    89     if (!listenerList->contains(listener))
 
   117     if (!listenerList->contains(listener))
 
    93     }
 
   121     }
 
    94 
   122 
    95 void CStifExecutor::RemoveStifCaseUpdateListener(
 
   123 void CStifExecutor::RemoveStifCaseUpdateListener(
 
    96         IStifCaseUpdateListener* listener)
 
   124         IStifCaseUpdateListener* listener)
 
    97     {
 
   125     {
 
    98 //    __LOG(_L("RemoveStifCaseUpdateListener"));
 
   126     iLog->Log(_L("RemoveStifCaseUpdateListener"));
 
    99     if (!listenerList)
 
   127     if (!listenerList)
 
   100         {
 
   128         {
 
   101         return;
 
   129         return;
 
   102         }
 
   130         }
 
   103 
   131 
   110 
   138 
   111 QList<CSTFModule> CStifExecutor::GetModuleList()
 
   139 QList<CSTFModule> CStifExecutor::GetModuleList()
 
   112     {
 
   140     {
 
   113     QList<CSTFModule> list;
 
   141     QList<CSTFModule> list;
 
   114     RRefArray<TDesC> modules;
 
   142     RRefArray<TDesC> modules;
 
   115 //    __LOG(_L("GetModuleList"));
 
   143     iLog->Log(_L("GetModuleList"));
 
   116     TInt ret = UIStore().Modules(modules);
 
   144     TInt ret = UIStore().Modules(modules);
 
   117 //    __LOG1(_L("LoadAllModules %d"), ret);
 
   145     iLog->Log(_L("LoadAllModules %d"), ret);
 
   118 //    __LOG1(_L("Modules number=%d"), modules.Count());
 
   146     iLog->Log(_L("Modules number=%d"), modules.Count());
 
   119     for (TInt i = 0; i < modules.Count(); i++)
 
   147     for (TInt i = 0; i < modules.Count(); i++)
 
   120         {
 
   148         {
 
   121 //        __LOG1(_L("Get Module Names %d"), i);
 
   149         iLog->Log(_L("Get Module Names %d"), i);
 
       
   150         iLog->Log(_L("Get Module Name = %d .=%s"),i,modules[i].Ptr());
 
       
   151             
   122         CSTFModule module;
 
   152         CSTFModule module;
 
   123         module.SetName(QString::fromUtf16(modules[i].Ptr(),
 
   153         module.SetName(QString::fromUtf16(modules[i].Ptr(),
 
   124                 modules[i].Length()));
 
   154                 modules[i].Length()));
 
   125         //module.SetName(TDesC2QString(modules[i]));
 
   155         //module.SetName(TDesC2QString(modules[i]));
 
   126         list.append(module);
 
   156         list.append(module);
 
   134     {
 
   164     {
 
   135     TPtrC name = QString2TPtrC(moduleName);
 
   165     TPtrC name = QString2TPtrC(moduleName);
 
   136     QList<CSTFCase> list;
 
   166     QList<CSTFCase> list;
 
   137     RRefArray<CTestInfo> testCases;
 
   167     RRefArray<CTestInfo> testCases;
 
   138     TInt ret = UIStore().TestCases(testCases, name, KNullDesC);
 
   168     TInt ret = UIStore().TestCases(testCases, name, KNullDesC);
 
   139 //    __LOG1(_L("Get TestCases: %d"), ret);
 
   169     iLog->Log(_L("Get TestCases: %d"), ret);
 
   140     for (TInt i = 0; i < testCases.Count(); i++)
 
   170     for (TInt i = 0; i < testCases.Count(); i++)
 
   141         {
 
   171         {
 
   142 //       __LOG1(_L("Case Number: %d"),testCases[i].TestCaseNum());
 
   172         iLog->Log(_L("Case Number: %d"),testCases[i].TestCaseNum());
 
       
   173         iLog->Log(_L("Case Name: %s"),testCases[i].TestCaseTitle().Ptr());
 
   143         CSTFCase testcase;
 
   174         CSTFCase testcase;
 
   144         testcase.SetName(TDesC2QString(testCases[i].TestCaseTitle()));
 
   175         testcase.SetName(TDesC2QString(testCases[i].TestCaseTitle()));
 
   145         testcase.SetIndex(i);
 
   176         testcase.SetIndex(i);
 
   146         list.append(testcase);
 
   177         list.append(testcase);
 
   147         }
 
   178         }
 
   150     return list;
 
   181     return list;
 
   151     }
 
   182     }
 
   152 
   183 
   153 void CStifExecutor::ExecuteSingleCase(const QString& moduleName, const int caseIndex)
 
   184 void CStifExecutor::ExecuteSingleCase(const QString& moduleName, const int caseIndex)
 
   154     {
 
   185     {
 
   155 //    __LOG(_L("ExecuteCase start"));
 
   186     iLog->Log(_L("ExecuteCase start"));
 
   156     TPtrC name = QString2TPtrC(moduleName);
 
   187     TPtrC name = QString2TPtrC(moduleName);
 
   157     RRefArray<CTestInfo> testCases;
 
   188     RRefArray<CTestInfo> testCases;
 
   158     TInt ret = UIStore().TestCases(testCases, name, KNullDesC);
 
   189     TInt ret = UIStore().TestCases(testCases, name, KNullDesC);
 
   159 //    __LOG1(_L("Get TestCases return code=%d"), ret);
 
   190     iLog->Log(_L("Get TestCases return code=%d"), ret);
 
   160     if (testCases.Count() > caseIndex)
 
   191     if (testCases.Count() > caseIndex)
 
   161         {
 
   192         {
 
   162         TInt index;
 
   193         TInt index;
 
   163         UIStore().StartTestCase(testCases[caseIndex], index);
 
   194         UIStore().StartTestCase(testCases[caseIndex], index);
 
   164 //        __LOG1(_L("start test case index=%d"), index);
 
   195         iLog->Log(_L("start test case index=%d"), index);
 
   165         }
 
   196         }
 
   166     testCases.Reset();
 
   197     testCases.Reset();
 
   167     testCases.Close();
 
   198     testCases.Close();
 
   168 //    __LOG(_L("ExecuteCase end"));
 
   199     iLog->Log(_L("ExecuteCase end"));
 
   169 
   200 
   170     }
 
   201     }
 
   171 
   202 
   172 QList<QString> CStifExecutor::GetSetList()
 
   203 QList<QString> CStifExecutor::GetSetList()
 
   173     {
 
   204     {
 
   174     QList<QString> list;
 
   205     QList<QString> list;
 
   175     RRefArray<TDesC> aArray;
 
   206     RRefArray<TDesC> aArray;
 
   176     TInt ret = UIStore().GetTestSetsList(aArray);
 
   207     TInt ret = UIStore().GetTestSetsList(aArray);
 
   177 //    __LOG1(_L("Get TestSet list return code=%d"), ret);
 
   208     iLog->Log(_L("Get TestSet list return code=%d"), ret);
 
   178     if (ret != KErrNone) //setInfos.Count() != 1
 
   209     if (ret != KErrNone) //setInfos.Count() != 1
 
   179         {
 
   210         {
 
   180         return list;
 
   211         return list;
 
   181         }
 
   212         }
 
   182     for (int i = 0; i < aArray.Count(); i++)
 
   213     for (int i = 0; i < aArray.Count(); i++)
 
   188     return list;
 
   219     return list;
 
   189     }
 
   220     }
 
   190 
   221 
   191 QList<CSTFCase> CStifExecutor::GetCaseListFromSet(const QString& setName)
 
   222 QList<CSTFCase> CStifExecutor::GetCaseListFromSet(const QString& setName)
 
   192     {
 
   223     {
 
   193 //    __LOG(_L("GetCaseListFromSet start."));
 
   224     iLog->Log(_L("GetCaseListFromSet start."));
 
   194     QList<CSTFCase> list;
 
   225     QList<CSTFCase> list;
 
   195     TPtrC name = QString2TPtrC(setName);
 
   226     TPtrC name = QString2TPtrC(setName);
 
   196 
   227 
   197     //__LOG(name);
 
   228     //iLog->Log(name);
 
   198     if (name.Length() == 0)
 
   229     if (name.Length() == 0)
 
   199         {
 
   230         {
 
   200         return list;
 
   231         return list;
 
   201         }
 
   232         }
 
   202 
   233 
   203 //    __LOG1(_L("name.Length()=%d"), name.Length());
 
   234     iLog->Log(_L("name.Length()=%d"), name.Length());
 
   204     TInt ret = UIStore().LoadTestSet(name);
 
   235     TInt ret = UIStore().LoadTestSet(name);
 
   205 //    __LOG1(_L("Load Test Set return=%d"),ret);
 
   236     iLog->Log(_L("Load Test Set return=%d"),ret);
 
   206     const CTestSetInfo* set = NULL;
 
   237     const CTestSetInfo* set = NULL;
 
   207     TRAP(ret , set = &UIStore().TestSetL(name));
 
   238     TRAP(ret , set = &UIStore().TestSetL(name));
 
   208 //    __LOG(_L("GetCaseListFromSet TestSetL."));
 
   239     iLog->Log(_L("GetCaseListFromSet TestSetL."));
 
   209     if(ret != KErrNone)
 
   240     if(ret != KErrNone)
 
   210         {
 
   241         {
 
   211         return list;
 
   242         return list;
 
   212         }
 
   243         }
 
   213     const RRefArray<const CTestInfo>& testCases = set->TestCases();
 
   244     const RRefArray<const CTestInfo>& testCases = set->TestCases();
 
   214 //    __LOG(_L("GetCaseListFromSet TestCases."));
 
   245     iLog->Log(_L("GetCaseListFromSet TestCases."));
 
   215     TInt count = testCases.Count();
 
   246     TInt count = testCases.Count();
 
   216     for (TInt i = 0; i < count; i++)
 
   247     for (TInt i = 0; i < count; i++)
 
   217         {
 
   248         {
 
   218         CSTFCase testcase;
 
   249         CSTFCase testcase;
 
   219         testcase.SetName(TDesC2QString(testCases[i].TestCaseTitle()));
 
   250         testcase.SetName(TDesC2QString(testCases[i].TestCaseTitle()));
 
   220         testcase.SetIndex(testCases[i].TestCaseNum());
 
   251         testcase.SetIndex(testCases[i].TestCaseNum());
 
   221         testcase.SetModuleName(TDesC2QString(testCases[i].ModuleName()));
 
   252         testcase.SetModuleName(TDesC2QString(testCases[i].ModuleName()));
 
   222         list.append(testcase);
 
   253         list.append(testcase);
 
   223         }
 
   254         }
 
   224 //    __LOG(_L("GetCaseListFromSet end."));
 
   255     iLog->Log(_L("GetCaseListFromSet end."));
 
   225     return list;
 
   256     return list;
 
   226     }
 
   257     }
 
   227 
   258 
   228 void CStifExecutor::CreateSet(const QString& setName)
 
   259 bool CStifExecutor::CreateSet(const QString& setName)
 
   229     {
 
   260     {
 
   230     TPtrC name = QString2TPtrC(setName);
 
   261     TPtrC name = QString2TPtrC(setName);
 
   231     TInt ret = UIStore().CreateTestSet(name);
 
   262     TInt ret = UIStore().CreateTestSet(name);
 
   232 //    __LOG1(_L("CreateSet return: %d"), ret);
 
   263     return LogResult(ret, "CreateSet");
 
   233 //    ret = UIStore().LoadTestSet(name);
 
   264     }
 
   234 //    __LOG1(_L("Load Set after CreateSet return: %d"), ret);
 
   265 
   235         
   266 bool CStifExecutor::SaveSet(QString& setName)
 
   236         
       
   237     }
 
       
   238 
       
   239 void CStifExecutor::SaveSet(QString& setName)
 
       
   240     {
 
   267     {
 
   241     TPtrC name = QString2TPtrC(setName);
 
   268     TPtrC name = QString2TPtrC(setName);
 
   242     TFileName testSetName;
 
   269     TFileName testSetName;
 
   243     testSetName.Copy(name);
 
   270     testSetName.Copy(name);
 
   244     TInt ret = UIStore().SaveTestSet(testSetName);
 
   271     TInt ret = UIStore().SaveTestSet2(testSetName);
 
   245     setName = TDesC2QString(testSetName);
 
   272     setName = TDesC2QString(testSetName);
 
   246 //    __LOG1(_L("SaveSet return: %d"),ret);
 
   273     return LogResult(ret, "SaveSet");
 
   247     }
 
   274     }
 
   248 
   275 
   249 void CStifExecutor::RemoveSet(const QString& setName)
 
   276 bool CStifExecutor::RemoveSet(const QString& setName)
 
   250     {
 
   277     {
 
   251     //This method wil not work at this stage.
 
   278     //This method wil not work at this stage.
 
   252     TPtrC name = QString2TPtrC(setName);
 
   279     TPtrC name = QString2TPtrC(setName);
 
   253     UIStore().RemoveTestSet(name);
 
   280     TInt ret = UIStore().RemoveTestSet(name);
 
   254     }
 
   281     return LogResult(ret, "RemoveSet");
 
   255 
   282     }
 
   256 void CStifExecutor::AddtoSet(const QString& setName, CSTFCase& caseInfo)
 
   283 
   257     {
 
   284 bool CStifExecutor::AddtoSet(const QString& setName, CSTFCase& caseInfo)
 
       
   285     {
 
       
   286     iLog->Log(_L("AddToSet Start"));
 
       
   287         
   258     //IMPORT_C TInt AddToTestSet( const TDesC& aSetName, const CTestInfo& aTestInfo );
 
   288     //IMPORT_C TInt AddToTestSet( const TDesC& aSetName, const CTestInfo& aTestInfo );
 
   259     TPtrC modulename = QString2TPtrC(caseInfo.ModuleName());
 
   289     TPtrC modulename = QString2TPtrC(caseInfo.ModuleName());
 
       
   290     iLog->Log(_L("AddToSet dealwith module: %s"), modulename.Ptr());
 
       
   291     iLog->Log(_L("Case name: %s"),QString2TPtrC(caseInfo.Name()).Ptr());
 
       
   292     iLog->Log(_L("Case index: %d"),caseInfo.Index());
 
       
   293     TInt caseIndex = caseInfo.Index();
 
       
   294     if(caseInfo.ModuleName().toLower() == "testscripter"
 
       
   295             ||caseInfo.ModuleName().toLower() == "teftestmodule")
 
       
   296         {
 
       
   297         caseIndex++;
 
       
   298         }
 
   260     RRefArray<CTestInfo> testCases;
 
   299     RRefArray<CTestInfo> testCases;
 
   261     TInt ret = UIStore().TestCases(testCases, modulename, KNullDesC);
 
   300     TInt ret = UIStore().TestCases(testCases, modulename, KNullDesC);
 
   262 //    __LOG1(_L("Get TestCases: %d"), ret);
 
   301     if(!LogResult(ret, "AddToSet, GetTestCases"))
 
       
   302         {
 
       
   303         return false;
 
       
   304         }
 
       
   305     
       
   306     ret = -1;
 
   263     for (TInt i = 0; i < testCases.Count(); i++)
 
   307     for (TInt i = 0; i < testCases.Count(); i++)
 
   264         {
 
   308         {
 
   265 //        __LOG1(_L("Case Number: %d"),testCases[i].TestCaseNum());
 
   309         iLog->Log(_L("Case Number: %d"),testCases[i].TestCaseNum());
 
   266         if (TDesC2QString(testCases[i].TestCaseTitle()) == caseInfo.Name()
 
   310         iLog->Log(_L("Case Title: %s"),testCases[i].TestCaseTitle().Ptr());        
   267                 && testCases[i].TestCaseNum() == caseInfo.Index())
 
   311         
       
   312         if (testCases[i].TestCaseNum() == caseIndex)
 
   268             {
 
   313             {
 
   269             ret = UIStore().AddToTestSet(QString2TPtrC(setName), testCases[i]);
 
   314             ret = UIStore().AddToTestSet(QString2TPtrC(setName), testCases[i]);
 
   270 //            __LOG1(_L("AddToTestSet: %d"), ret);
 
   315             iLog->Log(_L("AddToTestSet: %d"), ret);
 
   271             break;
 
   316             break;
 
   272             }
 
   317             }
 
   273         }
 
   318         }
 
   274     testCases.Reset();
 
   319     testCases.Reset();
 
   275     testCases.Close();
 
   320     testCases.Close();
 
       
   321     return LogResult(ret, "AddToSet");
 
   276     }
 
   322     }
 
   277 
   323 
   278 void CStifExecutor::ExecuteSet(const QString& SetName, const int startIndex,
 
   324 void CStifExecutor::ExecuteSet(const QString& SetName, const int startIndex,
 
   279         const TSTFCaseRunningType type)
 
   325         const TSTFCaseRunningType type)
 
   280     {
 
   326     {
 
   285         }
 
   331         }
 
   286     const CTestSetInfo* set = NULL;
 
   332     const CTestSetInfo* set = NULL;
 
   287     TInt ret;
 
   333     TInt ret;
 
   288     TBuf<30> test;
 
   334     TBuf<30> test;
 
   289     test.Append(QString2TPtrC(SetName));
 
   335     test.Append(QString2TPtrC(SetName));
 
   290 //    __LOG(_L("StartTestSet GetSetName:"));
 
   336     iLog->Log(_L("StartTestSet GetSetName:"));
 
   291 //    __LOG(test);
 
   337     iLog->Log(test);
 
   292     TRAP(ret, set = &UIStore().TestSetL(test));
 
   338     TRAP(ret, set = &UIStore().TestSetL(test));
 
   293             
   339             
   294     //const CTestSetInfo& set = UIStore().TestSetL(QString2TPtrC(SetName));
 
   340     //const CTestSetInfo& set = UIStore().TestSetL(QString2TPtrC(SetName));
 
   295     if(ret != KErrNone)
 
   341     if(ret != KErrNone)
 
   296         {
 
   342         {
 
   297 //        __LOG1(_L("StartTestSet GetTestSet Error return=%d"),ret);
 
   343         iLog->Log(_L("StartTestSet GetTestSet Error return=%d"),ret);
 
   298         return;
 
   344         return;
 
   299         }
 
   345         }
 
   300     int a = startIndex;
 
   346     int a = startIndex;
 
   301     ret = UIStore().StartTestSet(*set, a, setType);
 
   347     ret = UIStore().StartTestSet(*set, a, setType);
 
   302 //    __LOG1(_L("StartTestSet return=%d"),ret);
 
   348     iLog->Log(_L("StartTestSet return=%d"),ret);
 
   303     }
 
   349     }
 
   304 
   350 
   305 void CStifExecutor::Update(CStartedTestCase* aCase, int flags)
 
   351 void CStifExecutor::Update(CStartedTestCase* aCase, int flags)
 
   306     {
 
   352     {
 
   307 //    __LOG1(_L("CStifExecutor::Update return case=%d"),aCase);
 
   353     iLog->Log(_L("CStifExecutor::Update return case=%d"),aCase);
 
   308 //    __LOG1(_L("CStifExecutor::Update return status=%d"),flags);
 
   354     iLog->Log(_L("CStifExecutor::Update return status=%d"),flags);
 
   309     
   355     
   310     if(aCase == NULL)
 
   356     if(aCase == NULL)
 
   311         {
 
   357         {
 
   312         return;
 
   358         return;
 
   313         }
 
   359         }
 
   326             buffer.Append(_L(" "));
 
   372             buffer.Append(_L(" "));
 
   327             buffer.Append(printArray[i]->iText);
 
   373             buffer.Append(printArray[i]->iText);
 
   328             buffer.Append(_L("\r\n"));
 
   374             buffer.Append(_L("\r\n"));
 
   329             }
 
   375             }
 
   330         QString msg = TDesC2QString(buffer);
 
   376         QString msg = TDesC2QString(buffer);
 
   331 //        __LOG(_L("Get output msg:"));
 
   377         iLog->Log(_L("Get output msg:"));
 
   332 //        __LOG(buffer);
 
   378         iLog->Log(buffer);
 
   333         if (listenerList)
 
   379         if (listenerList)
 
   334             {
 
   380             {
 
   335             for (int i = 0; i < listenerList->size(); i++)
 
   381             for (int i = 0; i < listenerList->size(); i++)
 
   336                 {
 
   382                 {
 
   337                 listenerList->at(i)->OnGetCaseOutput(aCase, msg);
 
   383                 listenerList->at(i)->OnGetCaseOutput(aCase, msg);
FCL/sf/tools/rndtools