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::TestRenameFromEmptyNotExistL()

    24     {

    25     // Group:   Asynch Save

    26     // 

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

    28     // 

    29     // Action : Test that cfileman::rename returns error if no such file.

    30     //      

    31     // Output : A KErrNotFound.   

    32 	

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

    34 	

    35     currentTest = EREN001p1;

    36     numSaved = 0;

    37     wait = ETrue;

    38     TInt error = KErrNone;

    39     

    40     // Delete the file if it exists

    41     RFs aFs;

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

    43     TFileName ren001A = KNibblesREN001A;

    44     RFile deleter;

    45     TInt isDeleted = deleter.Open(aFs, ren001A, EFileRead);

    46     deleter.Close();

    47     if ( isDeleted == KErrNone )

    48         {

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

    50     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameFromEmptyNotExistL exists, deleting") );

    51         BaflUtils ba;

    52         ba.DeleteFile(aFs, ren001A);

    53         }

    54     aFs.Close();

    55     

    56     // Try delete

    57     CAsynchFSQ* aFSQ = NULL;

    58     TFileName ren001B = KNibblesREN001B;

    59     TRAPD( err, 

    60         aFSQ = CAsynchFSQ::NewL();

    61         error = aFSQ->Rename( ren001A, ren001B );

    62         );

    63     TRAP_IGNORE(

    64         delete aFSQ;

    65         aFSQ = NULL;

    66         );

    67     

    68     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameFromEmptyNotExistL errorIsKErrNotFound=%d notErr=%d"), (error == KErrNotFound), !err );

    69     

    70     assertL( (error == KErrNotFound) && !err );

    71     

    72     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameFromEmptyNotExistL out") );

    73     }

    74 

    75 void CAFSQTestAsynchSave::TestRenameFromEmptyExistsL()

    76     {

    77     // Group:   Asynch Save

    78     // 

    79     // ID:      CAE.FM.TESTRENAMEOBJECT.002

    80     // 

    81     // Action : Test that rename works if file exists and queue empty

    82     //      

    83     // Output : A KErrNone.  

    84 	

    85     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameFromEmptyExistsL in") );

    86 	 

    87     currentTest = EREN002p1;

    88     wait = ETrue;

    89     TInt error = KErrNone;

    90 

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

    92     TFileName aFilename = KNibbles;

    93     RFs aFs;

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

    95     RFile file;

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

    97     TInt iSize;   

    98     file.Size(iSize);

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

   100     TPtr8  myData = buf->Des();

   101     if ( !connectErr )

   102         {

   103         file.Read( myData );

   104         }

   105     file.Close();

   106 

   107     // Delete the file if it exists

   108     TFileName ren002A = KNibblesREN002A;

   109     RFile deleter;

   110     TInt isDeleted = deleter.Open(aFs, ren002A, EFileRead);

   111     deleter.Close();

   112     if ( isDeleted == KErrNone )

   113         {

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

   115     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameFromEmptyExistsL exists, deleting") );

   116         BaflUtils ba;

   117         ba.DeleteFile(aFs, ren002A);

   118         }

   119     aFs.Close();

   120 

   121     // Write the file to be used in testing

   122     TInt err2 = KErrNone;

   123     RFs fsSession;

   124     err2 = fsSession.Connect();

   125     RFile myFile;

   126     if ( !err2 )

   127         {

   128         err2 = myFile.Create( fsSession, ren002A, 

   129                              EFileStream | EFileShareExclusive | EFileWrite );

   130         }

   131     if( !err2 )

   132         {

   133         err2 = myFile.Write( myData );

   134         }

   135     if( !err2 )

   136         {

   137         err2 = myFile.Flush();

   138         }

   139     myFile.Close();

   140     fsSession.Close();

   141     delete buf;

   142     buf = NULL;

   143 

   144     //delete file

   145     CAsynchFSQ* aFSQ = NULL;

   146     TFileName ren002B = KNibblesREN002B;

   147     TRAPD( err, 

   148         aFSQ = CAsynchFSQ::NewL();

   149         error = aFSQ->Rename( ren002A, ren002B );

   150         );

   151     TRAP_IGNORE(

   152         delete aFSQ;

   153         aFSQ = NULL;

   154         );

   155 

   156     //check that file was deleted

   157     RFs fsSession2;

   158     TInt fsConnectErr = fsSession2.Connect();

   159     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameFromEmptyExistsL connectErr=%d"), fsConnectErr );

   160     RFile file2;

   161     TInt fileError = file2.Open(fsSession2, ren002B, EFileRead);

   162     file2.Close();

   163     fsSession2.Close();

   164 

   165     //assert

   166     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameFromEmptyExistsL errorIsKErrNone=%d notErr=%d !fileError=%d"), (error == KErrNone), !err, !(fileError ) );

   167     

   168     assertL( (error == KErrNone) && !err && (fileError==KErrNone) );

   169 

   170     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameFromEmptyExistsL out") );   

   171     }

   172 

   173 void CAFSQTestAsynchSave::TestRenameNonEmptyExistsButNotInQueueL()

   174     {

   175     // Group:   Asynch Save

   176     // 

   177     // ID:      CAE.FM.TESTRENAMEOBJECT.003

   178     // 

   179     // Action : Test that rename will work if the queue is not empty but

   180     //          the requested file is not in the queue (but it also exists)

   181     //      

   182     // Output : A KErrNone.   

   183 	

   184     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyExistsButNotInQueueL in") );

   185 	

   186     currentTest = EREN003p1;

   187     numSaved = 0;

   188     numToSave = 2;

   189     wait = ETrue;

   190     TInt error = KErrNone;

   191 

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

   193     TFileName aFilename = KNibbles;

   194     RFs aFs;

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

   196     RFile file;

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

   198     TInt iSize;   

   199     file.Size(iSize);

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

   201     TPtr8  myData = buf->Des();

   202     if ( !connectErr )

   203         {

   204         file.Read( myData );

   205         }

   206     file.Close();

   207 

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

   209     TFileName aFilename2 = KNibbles2;

   210     RFile file2;

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

   212     file2.Size(iSize);

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

   214     TPtr8  myData2 = buf2->Des();

   215     if ( !connectErr2 )

   216         {

   217         file2.Read( myData2 );

   218         }

   219     file2.Close();

   220 

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

   222     TFileName aFilename3 = KNibbles3;

   223     RFile file3;

   224     TInt connectErr3 = file3.Open(aFs, aFilename3,EFileRead);

   225     file3.Size(iSize);

   226     HBufC8* buf3 = HBufC8::NewL(iSize);

   227     TPtr8  myData3 = buf3->Des();

   228     if ( !connectErr3 )

   229         {

   230         file3.Read( myData3 );

   231         }

   232     file3.Close();

   233 

   234     // Delete the file if it exists

   235     TFileName ren003A = KNibblesREN003A;

   236     RFile deleter;

   237     TInt isDeleted = deleter.Open(aFs, ren003A, EFileRead);

   238     deleter.Close();

   239     if ( isDeleted == KErrNone )

   240         {

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

   242     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyExistsButNotInQueueL 1st exists, deleting") );

   243         BaflUtils ba;

   244         ba.DeleteFile(aFs, ren003A);

   245         }

   246 

   247     // Delete the file if it exists

   248     TFileName ren003B = KNibblesREN003B;

   249     RFile deleter2;

   250     TInt isDeleted2 = deleter2.Open(aFs, ren003B, EFileRead);

   251     deleter2.Close();

   252     if ( isDeleted2 == KErrNone )

   253         {

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

   255     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyExistsButNotInQueueL 2nd exists, deleting") );

   256         BaflUtils ba;

   257         ba.DeleteFile(aFs, ren003B);

   258         }

   259 

   260     // Delete the file if it exists

   261     TFileName ren003C = KNibblesREN003C;

   262     RFile deleter3;

   263     TInt isDeleted3 = deleter3.Open(aFs, ren003C, EFileRead);

   264     deleter3.Close();

   265     if ( isDeleted3 == KErrNone )

   266         {

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

   268     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyExistsButNotInQueueL 3rd exists, deleting") );

   269         BaflUtils ba;

   270         ba.DeleteFile(aFs, ren003C);

   271         }

   272         

   273     // Delete the file if it exists

   274     TFileName ren003A2 = KNibblesREN003A2;

   275     RFile deleter4;

   276     TInt isDeleted4 = deleter4.Open(aFs, ren003A2, EFileRead);

   277     deleter4.Close();

   278     if ( isDeleted4 == KErrNone )

   279         {

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

   281     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyExistsButNotInQueueL 4th exists, deleting") );

   282         BaflUtils ba;

   283         ba.DeleteFile(aFs, ren003A2);

   284         }    

   285 

   286     // Write the file to be used in testing

   287     TInt err2 = KErrNone;

   288     RFs fsSession;

   289     err2 = fsSession.Connect();

   290     RFile myFile;

   291     if ( !err2 )

   292         {

   293         err2 = myFile.Create( fsSession, ren003A, 

   294                              EFileStream | EFileShareExclusive | EFileWrite );

   295         }

   296     if( !err2 )

   297         {

   298         err2 = myFile.Write( myData );

   299         }

   300     if( !err2 )

   301         {

   302         err2 = myFile.Flush();

   303         }

   304     myFile.Close();

   305     fsSession.Close();

   306     aFs.Close();

   307     delete buf;

   308     buf = NULL;

   309 	    

   310     //delete

   311     TRAPD( err, 

   312         iFSQ = CAsynchFSQ::NewL();

   313         iFSQ->SetCallback( this );

   314         error = iFSQ->SaveAndDestroy( *buf2, ren003B );

   315         buf2 = NULL;

   316         error = iFSQ->SaveAndDestroy( *buf3, ren003C );

   317         buf3 = NULL;

   318         error = iFSQ->Rename( ren003A, ren003A2);

   319         );

   320 

   321     //delayed assert on callback

   322     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyExistsButNotInQueueL errorIsKErrNone=%d notErr=%d"), (error == KErrNone), !err );

   323     

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

   325     WaitForAsynchCompleteL();

   326     

   327     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyExistsButNotInQueueL out") );

   328     }

   329 

   330 void CAFSQTestAsynchSave::TestRenameNonEmptyNotExistAndNotInQueueL()

   331     {

   332     // Group:   Asynch Save

   333     // 

   334     // ID:      CAE.FM.TESTRENAMEOBJECT.004

   335     // 

   336     // Action : Test that rename will return error if the queue is not empty but

   337     //          the requested file is not in the queue (but it doesnt exist)

   338     //      

   339     // Output : A KErrNotFound.   

   340 	

   341     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyNotExistAndNotInQueueL in") );

   342 	

   343     currentTest = EREN004p1;

   344     numSaved = 0;

   345     numToSave = 2;

   346     wait = ETrue;

   347     TInt error = KErrNone;

   348 

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

   350     TFileName aFilename = KNibbles;

   351     RFs aFs;

   352     TInt connectError = User::LeaveIfError(aFs.Connect());

   353     RFile file;

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

   355     TInt iSize;   

   356     file.Size(iSize);

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

   358     TPtr8  myData = buf->Des();

   359     if ( !connectErr )

   360         {

   361         file.Read( myData );

   362         }

   363     file.Close();

   364 

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

   366     TFileName aFilename2 = KNibbles2;

   367     RFile file2;

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

   369     file2.Size(iSize);

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

   371     TPtr8  myData2 = buf2->Des();

   372     if ( !connectErr2 )

   373         {

   374         file2.Read( myData2 );

   375         }

   376     file2.Close();

   377 

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

   379     TFileName aFilename3 = KNibbles3;

   380     RFile file3;

   381     TInt connectErr3 = file3.Open(aFs, aFilename3,EFileRead);

   382     file3.Size(iSize);

   383     HBufC8* buf3 = HBufC8::NewL(iSize);

   384     TPtr8  myData3 = buf3->Des();

   385     if ( !connectErr3 )

   386         {

   387         file3.Read( myData3 );

   388         }

   389     file3.Close();

   390 

   391     // Delete the file if it exists

   392     TFileName ren004A = KNibblesREN004A;

   393     RFile deleter;

   394     TInt isDeleted = deleter.Open(aFs, ren004A, EFileRead);

   395     deleter.Close();

   396     if ( isDeleted == KErrNone )

   397         {

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

   399     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyNotExistAndNotInQueueL 1st exists, deleting") );

   400         BaflUtils ba;

   401         ba.DeleteFile(aFs, ren004A);

   402         }

   403 

   404     // Delete the file if it exists

   405     TFileName ren004B = KNibblesREN004B;

   406     RFile deleter2;

   407     TInt isDeleted2 = deleter2.Open(aFs, ren004B, EFileRead);

   408     deleter2.Close();

   409     if ( isDeleted2 == KErrNone )

   410         {

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

   412     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyNotExistAndNotInQueueL 2nd exists, deleting") );

   413         BaflUtils ba;

   414         ba.DeleteFile(aFs, ren004B);

   415         }

   416 

   417     // Delete the file if it exists

   418     TFileName ren004C = KNibblesREN004C;

   419     RFile deleter3;

   420     TInt isDeleted3 = deleter3.Open(aFs, ren004C,EFileRead);

   421     deleter3.Close();

   422     if ( isDeleted3 == KErrNone )

   423         {

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

   425     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyNotExistAndNotInQueueL 3rd exists, deleting") );

   426         BaflUtils ba;

   427         ba.DeleteFile(aFs, ren004C);

   428         }

   429     aFs.Close();

   430     delete buf;

   431     buf = NULL;

   432 

   433     //delete

   434     TFileName ren004A2 = KNibblesREN004A2;

   435     TRAPD( err, 

   436         iFSQ = CAsynchFSQ::NewL();

   437         iFSQ->SetCallback( this );

   438         error = iFSQ->SaveAndDestroy( *buf2, ren004B );

   439         buf2 = NULL;

   440         error = iFSQ->SaveAndDestroy( *buf3, ren004C );

   441         buf3 = NULL;

   442         error = iFSQ->Rename( ren004A, ren004A2 );

   443         );

   444 

   445     //delayed assert on callback

   446     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyNotExistAndNotInQueueL errorIsKErrNotFound=%d notErr=%d"), (error == KErrNotFound), !err );

   447     

   448     delayedBool = ( (error == KErrNotFound) && !err );

   449     WaitForAsynchCompleteL();

   450     

   451     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyNotExistAndNotInQueueL out") );

   452     }

   453 

   454 void CAFSQTestAsynchSave::TestRenameInQueueNotActiveL()

   455     {

   456     // Group:   Asynch Save

   457     // 

   458     // ID:      CAE.FM.TESTRENAMEOBJECT.005

   459     // 

   460     // Action : Test that rename will work ok if the queue is not empty and

   461     //          the file is in the queue.  Should also check filesystem for existence.

   462     //          This case checks that the file NOT ACTIVELY being saved gets renamed.

   463     //      

   464     // Output : A KErrNone.   

   465 	

   466     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueNotActiveL in") );

   467 	

   468     currentTest = EREN005p1;

   469     numSaved = 0;

   470     numToSave = 3;

   471     wait = ETrue;

   472     TInt error = KErrNone;

   473 

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

   475     TFileName aFilename = KNibbles;

   476     RFs aFs;

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

   478     RFile file;

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

   480     TInt iSize;   

   481     file.Size(iSize);

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

   483     TPtr8  myData = buf->Des();

   484     if ( !connectErr )

   485         {

   486         file.Read( myData );

   487         }

   488     file.Close();

   489 

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

   491     TFileName aFilename2 = KNibbles2;

   492     RFile file2;

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

   494     file2.Size(iSize);

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

   496     TPtr8  myData2 = buf2->Des();

   497     if ( !connectErr2 )

   498         {

   499         file2.Read( myData2 );

   500         }

   501     file2.Close();

   502 

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

   504     TFileName aFilename3 = KNibbles3;

   505     RFile file3;

   506     TInt connectErr3 = file3.Open(aFs, aFilename3,EFileRead);

   507     file3.Size(iSize);

   508     HBufC8* buf3 = HBufC8::NewL(iSize);

   509     TPtr8  myData3 = buf3->Des();

   510     if ( !connectErr3 )

   511         {

   512         file3.Read( myData3 );

   513         }

   514     file3.Close();

   515 

   516     // Delete the file if it exists

   517     TFileName ren005A = KNibblesREN005A;

   518     RFile deleter;

   519     TInt isDeleted = deleter.Open(aFs, ren005A, EFileRead);

   520     deleter.Close();

   521     if ( isDeleted == KErrNone )

   522         {

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

   524     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueNotActiveL 1st exists, deleting") );

   525         BaflUtils ba;

   526         ba.DeleteFile(aFs, ren005A);

   527         }

   528 

   529     // Delete the file if it exists

   530     TFileName ren005B = KNibblesREN005B;

   531     RFile deleter2;

   532     TInt isDeleted2 = deleter2.Open(aFs, ren005B, EFileRead);

   533     deleter2.Close();

   534     if ( isDeleted2 == KErrNone )

   535         {

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

   537     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueNotActiveL 2nd exists, deleting") );

   538         BaflUtils ba;

   539         ba.DeleteFile(aFs, ren005B);

   540         }

   541 

   542     // Delete the file if it exists

   543     TFileName ren005C = KNibblesREN005C;

   544     RFile deleter3;

   545     TInt isDeleted3 = deleter3.Open(aFs, ren005C, EFileRead);

   546     deleter3.Close();

   547     if ( isDeleted3 == KErrNone )

   548         {

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

   550     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueNotActiveL 3rd exists, deleting") );

   551         BaflUtils ba;

   552         ba.DeleteFile(aFs, ren005C);

   553         }

   554 

   555     // Delete the file if it exists

   556     TFileName ren005A2 = KNibblesREN005A2;

   557     RFile deleter4;

   558     TInt isDeleted4 = deleter4.Open(aFs, ren005A2, EFileRead);

   559     deleter4.Close();

   560     if ( isDeleted4 == KErrNone )

   561         {

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

   563     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameNonEmptyExistsButNotInQueueL 4th exists, deleting") );

   564         BaflUtils ba;

   565         ba.DeleteFile(aFs, ren005A2);

   566         }    

   567 

   568     aFs.Close();

   569 	    

   570     //delete

   571     TRAPD( err, 

   572         iFSQ = CAsynchFSQ::NewL();

   573         iFSQ->SetCallback( this );

   574         error = iFSQ->SaveAndDestroy( *buf2, ren005B );

   575         buf2 = NULL;

   576         error = iFSQ->SaveAndDestroy( *buf3, ren005C );

   577         buf3 = NULL;

   578         error = iFSQ->SaveAndDestroy( *buf, ren005A );

   579         buf = NULL;

   580         error = iFSQ->Rename( ren005A, ren005A2 );

   581         );

   582 

   583     //delayed assert on callback

   584     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueNotActiveL errorIsKErrNone=%d notErr=%d"), (error == KErrNone), !err );

   585     

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

   587     WaitForAsynchCompleteL();

   588     

   589     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueNotActiveL out") );

   590     }

   591 

   592 void CAFSQTestAsynchSave::TestRenameInQueueActiveL()

   593 {

   594     // Group:   Asynch Save

   595     // 

   596     // ID:      CAE.FM.TESTRENAMEOBJECT.006

   597     // 

   598     // Action : Test that rename will work ok if the queue is not empty and

   599     //          the file is in the queue.  Should also check filesystem for existence?

   600     //          This case checks that the file ACTIVELY being saved gets renamed.

   601     //      

   602     // Output : A KErrNone.   

   603 	

   604     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueActiveL in") );

   605 	

   606     currentTest = EREN006p1;

   607     numSaved = 0;

   608     numToSave = 3;

   609     wait = ETrue;

   610     TInt error = KErrNone;

   611 

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

   613     TFileName aFilename = KNibbles;

   614     RFs aFs;

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

   616     RFile file;

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

   618     TInt iSize;   

   619     file.Size(iSize);

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

   621     TPtr8  myData = buf->Des();

   622     if ( !connectErr )

   623         {

   624         file.Read( myData );

   625         }

   626     file.Close();

   627 

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

   629     TFileName aFilename2 = KNibbles2;

   630     RFile file2;

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

   632     file2.Size(iSize);

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

   634     TPtr8  myData2 = buf2->Des();

   635     if ( !connectErr2 )

   636         {

   637         file2.Read( myData2 );

   638         }

   639     file2.Close();

   640     

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

   642     TFileName aFilename3 = KNibbles3;

   643     RFile file3;

   644     TInt connectErr3 = file3.Open(aFs, aFilename3,EFileRead);

   645     file3.Size(iSize);

   646     HBufC8* buf3 = HBufC8::NewL(iSize);

   647     TPtr8  myData3 = buf3->Des();

   648     if ( !connectErr3 )

   649         {

   650         file3.Read( myData3 );

   651         }

   652     file3.Close();

   653 

   654     // Delete the file if it exists

   655     TFileName ren006A = KNibblesREN006A;

   656     RFile deleter;

   657     TInt isDeleted = deleter.Open(aFs, ren006A, EFileRead);

   658     deleter.Close();

   659     if ( isDeleted == KErrNone )

   660         {

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

   662     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueActiveL 1st exists, deleting") );

   663         BaflUtils ba;

   664         ba.DeleteFile(aFs, ren006A);

   665         }

   666 

   667     // Delete the file if it exists

   668     TFileName ren006B = KNibblesREN006B;

   669     RFile deleter2;

   670     TInt isDeleted2 = deleter2.Open(aFs, ren006B, EFileRead);

   671     deleter2.Close();

   672     if ( isDeleted2 == KErrNone )

   673         {

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

   675     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueActiveL 2nd exists, deleting") );

   676         BaflUtils ba;

   677         ba.DeleteFile(aFs, ren006B);

   678         }

   679         

   680     // Delete the file if it exists

   681     TFileName ren006C = KNibblesREN006C;

   682     RFile deleter3;

   683     TInt isDeleted3 = deleter3.Open(aFs, ren006C, EFileRead);

   684     deleter3.Close();

   685     if ( isDeleted3 == KErrNone )

   686         {

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

   688     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueActiveL 3rd exists, deleting") );

   689         BaflUtils ba;

   690         ba.DeleteFile(aFs, ren006C);

   691         }

   692         

   693     // Delete the file if it exists

   694     TFileName ren006B2 = KNibblesREN006B2;

   695     RFile deleter4;

   696     TInt isDeleted4 = deleter4.Open(aFs, ren006B2, EFileRead);

   697     deleter4.Close();

   698     if ( isDeleted4 == KErrNone )

   699         {

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

   701     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueActiveL 4th exists, deleting") );

   702         BaflUtils ba;

   703         ba.DeleteFile(aFs, ren006B2);

   704         }

   705         

   706     // Delete the file if it exists

   707     TFileName ren006C2 = KNibblesREN006C2;

   708     RFile deleter5;

   709     TInt isDeleted5 = deleter5.Open(aFs, ren006C2, EFileRead);

   710     deleter5.Close();

   711     if ( isDeleted5 == KErrNone )

   712         {

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

   714     	RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueActiveL 5th exists, deleting") );

   715         BaflUtils ba;

   716         ba.DeleteFile(aFs, ren006C2);

   717         }                

   718 

   719     aFs.Close();

   720 

   721     //delete

   722     TInt errorA = 0;

   723     TInt errorB = 0;

   724     TRAPD( err, 

   725         iFSQ = CAsynchFSQ::NewL();

   726         iFSQ->SetCallback( this );

   727         error = iFSQ->SaveAndDestroy( *buf2, ren006B );

   728         buf2 = NULL;

   729         error = iFSQ->SaveAndDestroy( *buf3, ren006C );

   730         buf3 = NULL;

   731         error = iFSQ->SaveAndDestroy( *buf, ren006A );

   732         buf = NULL;

   733         errorA = iFSQ->Rename( ren006B, ren006B2 );

   734         errorB = iFSQ->Rename( ren006C, ren006C2 );

   735         );

   736 

   737     //delayed assert on callback

   738     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueActiveL errorIsKErrNone=%d notErr=%d !errorA=%d !errorB=%d"), (error == KErrNone), !err, !errorA, !errorB );

   739     

   740     delayedBool = ( (error == KErrNone) && !err && !errorA && !errorB );

   741     WaitForAsynchCompleteL();

   742 

   743     RDebug::Print( _L("CAFSQTestAsynchSave::TestRenameInQueueActiveL out") );

   744     }

   745     

   746