1 /*

     2 * Copyright (c) 2002-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:  FSQ Test DLL

    15 *

    16 */

    17 

    18 

    19 #include "../inc/AFSQTestAsynchSave.h"

    20 #include <f32file.h> // for opening / creating files

    21 #include <bautils.h> // for deleting files

    22 

    23 void CAFSQTestAsynchSave::TestAddEmptyObjectToQueueL()

    24     {

    25     // Group:   Asynch Save

    26     // 

    27     // ID:      CAE.FM.TESTADDOBJECT.001

    28     // 

    29     // Action : Test that adding an null object to the queue will return an error.

    30     //      

    31     // Output : An error code.   

    32 

    33     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddEmptyObjectToQueueL in") );

    34 

    35     TInt error = KErrNone;

    36     currentTest = EADD001p1;

    37     numSaved = 0;

    38     wait = ETrue;

    39     

    40     HBufC8 * myData = HBufC8::NewL(1000);

    41     delete myData;

    42     myData = NULL;

    43     

    44     TRAPD( err, 

    45         iFSQ = CAsynchFSQ::NewL();

    46         iFSQ->SetCallback( this );

    47         TFileName add001 = KNibblesADD001;

    48         error = iFSQ->SaveAndDestroy( *myData, add001);

    49         );

    50     TRAPD( err2,

    51         delete iFSQ;

    52         iFSQ = NULL;

    53         );

    54     

    55     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddEmptyObjectToQueueL isKErrArgument=%d notErr=%d notErr2=%d"), (error == KErrArgument), !err, !err2 );

    56     

    57     //do not delay assert because queue should not be active

    58     assertL( (error == KErrArgument) && !err && !err2);

    59     

    60     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddEmptyObjectToQueueL out") );

    61     }

    62 

    63 void CAFSQTestAsynchSave::TestAddObjectToEmptyQueueL()

    64     {

    65     // Group:   Asynch Save

    66     // 

    67     // ID:      CAE.FM.TESTADDOBJECT.002

    68     // 

    69     // Action : Test that adding an object to an empty queue will at least start OK.

    70     //      

    71     // Output : An error code.  

    72 

    73     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueL in") );

    74 

    75     TInt error = KErrNone;

    76     currentTest = EADD002p1;

    77     numSaved = 0;

    78     wait = ETrue;

    79 

    80     // Read the file to be used in testing.

    81     TFileName aFilename = KNibbles;

    82     RFs aFs;

    83     User::LeaveIfError(aFs.Connect());

    84     RFile file;

    85     TInt connectErr = file.Open(aFs, aFilename, EFileRead);

    86     TInt iSize;   

    87     file.Size(iSize);

    88     HBufC8* buf = HBufC8::NewL(iSize);

    89     TPtr8  myData = buf->Des();

    90     if ( !connectErr )

    91         {

    92         file.Read( myData );

    93         }

    94     file.Close();

    95     

    96     // Delete the file if it exists

    97     TFileName add002 = KNibblesADD002;

    98     RFile deleter;

    99     TInt isDeleted = deleter.Open(aFs, add002, EFileRead);

   100     deleter.Close();

   101 

   102     if ( isDeleted == KErrNone )

   103         {

   104         // if no error, assume the file exists, so delete it

   105     	RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueL exists, deleting") );

   106         BaflUtils ba;

   107         ba.DeleteFile(aFs, add002);

   108         }

   109     aFs.Close();

   110     

   111     // Save    

   112     TRAPD( err, 

   113         iFSQ = CAsynchFSQ::NewL();        

   114         //add this as a callback

   115         iFSQ->SetCallback( this );

   116         error = iFSQ->SaveAndDestroy( *buf, add002 );

   117         buf = NULL; // transfer ownership 

   118         );

   119     

   120     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueL isKErrNone=%d notErr=%d"), (error == KErrNone), !err );

   121    

   122     delayedBool = ( (error == KErrNone) && !err );

   123     //wait for callback to assert

   124     WaitForAsynchCompleteL();

   125     

   126     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueL out") );

   127     }

   128 

   129 void CAFSQTestAsynchSave::TestAddObjectToEmptyQueueWillSaveL()

   130     {

   131     // Group:   Asynch Save

   132     // 

   133     // ID:      CAE.FM.TESTADDOBJECT.003

   134     // 

   135     // Action : Test that adding an object to an empty queue will finish OK.

   136     //      

   137     // Output : Asynchronous report.    

   138 

   139     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueWillSaveL in") );

   140 

   141     currentTest = EADD003p1;

   142     numSaved = 0;

   143     wait = ETrue;

   144     

   145     // Read the file to be used in testing.

   146     TFileName aFilename = KNibbles;

   147     RFs aFs;

   148     User::LeaveIfError(aFs.Connect());

   149     RFile file;

   150     TInt connectErr = file.Open(aFs, aFilename, EFileRead);

   151     TInt iSize;   

   152     file.Size(iSize);

   153     HBufC8* buf = HBufC8::NewL(iSize);

   154     TPtr8  myData = buf->Des();

   155     if ( !connectErr )

   156         {

   157         file.Read( myData );

   158         }

   159     file.Close();

   160     

   161     // Delete the file if it exists

   162     TFileName add003 = KNibblesADD003;

   163     RFile deleter;

   164     TInt isDeleted = deleter.Open(aFs, add003, EFileRead);

   165     deleter.Close();

   166     if ( isDeleted == KErrNone )

   167         {

   168         // if no error, assume the file exists, so delete it

   169     	RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueL exists, deleting") );

   170         BaflUtils ba;

   171         ba.DeleteFile(aFs, add003);

   172         }

   173     aFs.Close();

   174     

   175     TRAP_IGNORE(  

   176         iFSQ = CAsynchFSQ::NewL();

   177         //add this as a callback

   178         iFSQ->SetCallback( this );

   179         iFSQ->SaveAndDestroy( *buf, add003 );

   180         buf = NULL; // transfer ownership

   181         );

   182     

   183     //wait for callback to assert

   184     WaitForAsynchCompleteL();

   185     

   186     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueWillSaveL out") );

   187     }

   188 

   189 void CAFSQTestAsynchSave::TestAddObjectToNonEmptyQueueL()

   190     {

   191     // Group:   Asynch Save

   192     // 

   193     // ID:      CAE.FM.TESTADDOBJECT.004

   194     // 

   195     // Action : Test that adding an object to a non empty queue will at least start OK.

   196     //      

   197     // Output : An error code.

   198 

   199     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToNonEmptyQueueL in") );

   200 

   201     TInt error = KErrNone;

   202     TInt error2 = KErrNone;

   203     currentTest = EADD004p1;

   204     numSaved = 0;

   205     numToSave = 2;

   206     wait = ETrue;

   207    

   208     // Read the file to be used in testing.

   209     TFileName aFilename = KNibbles;

   210     RFs aFs;

   211     User::LeaveIfError(aFs.Connect());

   212     RFile file;

   213     TInt connectErr = file.Open(aFs, aFilename,EFileRead);

   214     TInt iSize;   

   215     file.Size(iSize);

   216     HBufC8* buf = HBufC8::NewL(iSize);

   217     TPtr8  myData = buf->Des();

   218     if ( !connectErr )

   219         {

   220         file.Read( myData );

   221         }

   222     file.Close();

   223 

   224     // Read the file to be used in testing.

   225     TFileName aFilename2 = KNibbles2;

   226     RFile file2;

   227     TInt connectErr2 = file2.Open(aFs, aFilename2,EFileRead);

   228     file2.Size(iSize);

   229     HBufC8* buf2 = HBufC8::NewL(iSize);

   230     TPtr8  myData2 = buf2->Des();

   231     if ( !connectErr2 )

   232         {

   233         file2.Read( myData2 );

   234         }

   235     file2.Close();

   236 

   237     // Delete the file if it exists

   238     TFileName add004A = KNibblesADD004A;

   239     RFile deleter;

   240     TInt isDeleted = deleter.Open(aFs, add004A, EFileRead);

   241     deleter.Close();

   242     if ( isDeleted == KErrNone )

   243         {

   244         // if no error, assume the file exists, so delete it

   245     	RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueL 1st exists, deleting") );

   246         BaflUtils ba;

   247         ba.DeleteFile(aFs, add004A);

   248         }

   249 

   250     // Delete the file if it exists

   251     TFileName add004B = KNibblesADD004B;

   252     RFile deleter2;

   253     TInt isDeleted2 = deleter2.Open(aFs, add004B, EFileRead);

   254     deleter2.Close();

   255     if ( isDeleted2 == KErrNone )

   256         {

   257         // if no error, assume the file exists, so delete it

   258     	RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueL 2nd exists, deleting") );

   259         BaflUtils ba;

   260         ba.DeleteFile(aFs, add004B);

   261         }

   262     aFs.Close();

   263 

   264     // Save    

   265     TRAPD( err, 

   266         iFSQ = CAsynchFSQ::NewL();

   267         iFSQ->SetCallback( this );

   268         error = iFSQ->SaveAndDestroy( *buf, add004A );

   269         buf = NULL; // transfer ownership

   270         error2 = iFSQ->SaveAndDestroy( *buf2, add004B );

   271         buf2 = NULL; // transfer ownership

   272         );

   273     

   274     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToNonEmptyQueueL isKErrNone=%d is2KErrNone=%d notErr=%d"), (error == KErrNone), (error2 == KErrNone), !err );

   275     

   276     delayedBool = ( (error == KErrNone) && (error2 == KErrNone) && (!err) );

   277     //wait for callback to assert

   278     WaitForAsynchCompleteL();

   279     

   280     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToNonEmptyQueueL out") );

   281     }

   282 

   283 void CAFSQTestAsynchSave::TestAddObjectToNonEmptyQueueWillSaveL()

   284     {

   285     // Group:   Asynch Save

   286     // 

   287     // ID:      CAE.FM.TESTADDOBJECT.005

   288     // 

   289     // Action : Test that adding an object to a non empty queue will finish OK.

   290     //      

   291     // Output : Asynchronous report.   

   292 	

   293     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToNonEmptyQueueWillSaveL in") );

   294 

   295     //TInt error = KErrNone;

   296     currentTest = EADD005p1;

   297     numSaved = 0;

   298     numToSave = 2;

   299     wait = ETrue;

   300     

   301     // Read the file to be used in testing.

   302     TFileName aFilename = KNibbles;

   303     RFs aFs;

   304     User::LeaveIfError(aFs.Connect());

   305     RFile file;

   306     TInt connectErr = file.Open(aFs, aFilename,EFileRead);

   307     TInt iSize;   

   308     file.Size(iSize);

   309     HBufC8* buf = HBufC8::NewL(iSize);

   310     TPtr8  myData = buf->Des();

   311     if ( !connectErr )

   312         {

   313         file.Read( myData );

   314         }

   315     file.Close();

   316 

   317     // Read the file to be used in testing.

   318     TFileName aFilename2 = KNibbles2;

   319     RFile file2;

   320     TInt connectErr2 = file2.Open(aFs, aFilename2,EFileRead);

   321     file2.Size(iSize);

   322     HBufC8* buf2 = HBufC8::NewL(iSize);

   323     TPtr8  myData2 = buf2->Des();

   324     if ( !connectErr2 )

   325         {

   326         file2.Read( myData2 );

   327         }

   328     file2.Close();

   329 

   330     // Delete the file if it exists

   331     TFileName add005A = KNibblesADD005A;

   332     RFile deleter;

   333     TInt isDeleted = deleter.Open(aFs, add005A, EFileRead);

   334     deleter.Close();

   335     if ( isDeleted == KErrNone )

   336         {

   337         // if no error, assume the file exists, so delete it

   338     	RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToNonEmptyQueueWillSaveL 1st exists, deleting") );

   339         BaflUtils ba;

   340         ba.DeleteFile(aFs, add005A);

   341         }

   342 

   343     // Delete the file if it exists

   344     TFileName add005B = KNibblesADD005B;

   345     RFile deleter2;

   346     TInt isDeleted2 = deleter2.Open(aFs, add005B, EFileRead);

   347     deleter2.Close();

   348     if ( isDeleted2 == KErrNone )

   349         {

   350         // if no error, assume the file exists, so delete it

   351     	RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToNonEmptyQueueWillSaveL 2nd exists, deleting") );

   352         BaflUtils ba;

   353         ba.DeleteFile(aFs, add005B);

   354         }

   355     aFs.Close();

   356 

   357     // Save    

   358     TRAPD( err, 

   359         iFSQ = CAsynchFSQ::NewL();

   360         iFSQ->SetCallback( this );

   361         iFSQ->SaveAndDestroy( *buf, add005A );

   362         buf = NULL; // transfer ownership

   363         iFSQ->SaveAndDestroy( *buf2, add005B );

   364         buf2 = NULL; // transfer ownership

   365         );

   366     

   367     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToNonEmptyQueueWillSaveL notErr=%d"), !err );

   368     

   369     //wait for callback to assert

   370     WaitForAsynchCompleteL();

   371     

   372     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToNonEmptyQueueWillSaveL out") );

   373     }

   374 

   375 void CAFSQTestAsynchSave::TestAddObjectThatExistsAlreadyL()

   376     {

   377     // Group:   Asynch Save

   378     // 

   379     // ID:      CAE.FM.TESTADDOBJECT.006

   380     // 

   381     // Action : Test that adding an object to an empty queue which exists int the file

   382     //          system will report KErrAlreadyExists.

   383     //      

   384     // Output : An error code.  

   385 

   386     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectThatExistsAlready in") );

   387 

   388     TInt error = KErrNone;

   389     currentTest = EADD006p1;

   390     numSaved = 0;

   391     wait = ETrue;

   392 

   393     // Read the file to be used in testing.

   394     TFileName aFilename = KNibbles;

   395     RFs aFs;

   396     User::LeaveIfError(aFs.Connect());

   397     RFile file;

   398     TInt connectErr = file.Open(aFs, aFilename,EFileRead);

   399     TInt iSize;   

   400     file.Size(iSize);

   401     HBufC8* buf = HBufC8::NewL(iSize);

   402     TPtr8  myData = buf->Des();

   403     if ( !connectErr )

   404         {

   405         file.Read( myData );

   406         }

   407     file.Close();

   408 

   409     // Delete the file if it exists

   410     TFileName add006 = KNibblesADD006;

   411     RFile deleter;

   412     TInt isDeleted = deleter.Open(aFs, add006, EFileRead);

   413     deleter.Close();

   414     if ( isDeleted == KErrNone )

   415         {

   416         // if no error, assume the file exists, so delete it

   417     	RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectThatExistsAlreadyL exists, deleting") );

   418         BaflUtils ba;

   419         ba.DeleteFile(aFs, add006);

   420         }

   421     aFs.Close();

   422 

   423     // Write the file to be used in testing

   424     TInt err2 = KErrNone;

   425     RFs fsSession;

   426     err2 = fsSession.Connect();

   427     RFile myFile;

   428     if ( !err2 )

   429         {

   430         err2 = myFile.Create( fsSession, add006, 

   431                              EFileStream | EFileShareExclusive | EFileWrite );

   432         }

   433     if( !err2 )

   434         {

   435         err2 = myFile.Write( myData );

   436         }

   437     if( !err2 )

   438         {

   439         err2 = myFile.Flush();

   440         }

   441 	myFile.Close();

   442 	fsSession.Close();

   443 	

   444     // Reuse the file name, to write where it exists.

   445     TRAPD( err, 

   446         iFSQ = CAsynchFSQ::NewL();

   447         //add this as a callback

   448         iFSQ->SetCallback( this );

   449         error = iFSQ->SaveAndDestroy( *buf, add006, EFalse );

   450         buf = NULL; // transfer ownership 

   451         );

   452     

   453     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectThatExistsAlreadyL isKErrNone=%d notErr=%d"), (error == KErrNone), !err );

   454    

   455     delayedBool = ( (error == KErrNone) && !err );

   456     //wait for callback to assert

   457     WaitForAsynchCompleteL();

   458     

   459     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectThatExistsAlreadyL out") );

   460     }

   461 

   462 

   463 void CAFSQTestAsynchSave::TestAddObjectToEmptyQueueLManualStart()

   464     {

   465     // Group:   Asynch Save

   466     // 

   467     // ID:      CAE.FM.TESTADDOBJECT.007

   468     // 

   469     // Action : Test that adding an object to an empty manual queue will be OK.

   470     //      

   471     // Output : An error code.  

   472 

   473     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueLManualStart in") );

   474 

   475     TInt error = KErrNone;

   476     TInt error2 = KErrNone;

   477     currentTest = EADD007p1;

   478     numSaved = 0;

   479     wait = ETrue;

   480 

   481     // Read the file to be used in testing.

   482     TFileName aFilename = KNibbles;

   483     RFs aFs;

   484     User::LeaveIfError(aFs.Connect());

   485     RFile file;

   486     TInt connectErr = file.Open(aFs, aFilename, EFileRead);

   487     TInt iSize;   

   488     file.Size(iSize);

   489     HBufC8* buf = HBufC8::NewL(iSize);

   490     TPtr8  myData = buf->Des();

   491     if ( !connectErr )

   492         {

   493         file.Read( myData );

   494         }

   495     file.Close();

   496     

   497     // Delete the file if it exists

   498     TFileName add007 = KNibblesADD007;

   499     RFile deleter;

   500     TInt isDeleted = deleter.Open(aFs, add007, EFileRead);

   501     deleter.Close();

   502 

   503     if ( isDeleted == KErrNone )

   504         {

   505         // if no error, assume the file exists, so delete it

   506         RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueLManualStart exists, deleting") );

   507         BaflUtils ba;

   508         ba.DeleteFile(aFs, add007);

   509         }

   510     aFs.Close();

   511     

   512     // Save    

   513     TRAPD( err, 

   514         iFSQ = CAsynchFSQ::NewL();        

   515         //add this as a callback

   516         iFSQ->SetCallback( this );

   517         iFSQ->SetManualStart( ETrue );

   518         error = iFSQ->SaveAndDestroy( *buf, add007 );

   519         buf = NULL; // transfer ownership 

   520         error2 = iFSQ->Go();

   521         );

   522     

   523     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueLManualStart isKErrNone=%d notErr=%d"), ((error == KErrNone) && (error2 == KErrNone)), !err );

   524    

   525     delayedBool = ( (error == KErrNone) && (error2 == KErrNone) && !err );

   526     //wait for callback to assert

   527     WaitForAsynchCompleteL();

   528     

   529     RDebug::Print( _L("CAFSQTestAsynchSave::TestAddObjectToEmptyQueueLManualStart out") );

   530     }