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

    24     {

    25     // Group:   Asynch Save

    26     // 

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

    28     // 

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

    30     //      

    31     // Output : A KErrNotFound.   

    32 	

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

    34 	

    35     currentTest = EDEL001p1;

    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 del001 = KNibblesDEL001;

    44     RFile deleter;

    45     TInt isDeleted = deleter.Open(aFs, del001, 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::TestDeleteFromEmptyNotExistL exists, deleting") );

    51         BaflUtils ba;

    52         ba.DeleteFile(aFs, del001);

    53         }

    54     aFs.Close();

    55     

    56     // Try delete

    57     CAsynchFSQ* aFSQ = NULL;

    58     TRAPD( err, 

    59         aFSQ = CAsynchFSQ::NewL();

    60         error = aFSQ->Delete( del001 );

    61         );

    62     TRAP_IGNORE(

    63         delete aFSQ;

    64         aFSQ = NULL;

    65         );

    66     

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

    68     

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

    70     

    71     RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteFromEmptyNotExistL out") );

    72     }

    73 

    74 void CAFSQTestAsynchSave::TestDeleteFromEmptyExistsL()

    75     {

    76     // Group:   Asynch Save

    77     // 

    78     // ID:      CAE.FM.TESTDELETEOBJECT.002

    79     // 

    80     // Action : Test that delete works if file exists and queue empty

    81     //      

    82     // Output : A KErrNone.   

    83 	

    84     RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteFromEmptyExistsL in") );

    85 

    86     currentTest = EDEL002p1;

    87     numSaved = 0;

    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 del002 = KNibblesDEL002;

   109     RFile deleter;

   110     TInt isDeleted = deleter.Open(aFs, del002, 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::TestDeleteFromEmptyExistsL exists, deleting") );

   116         BaflUtils ba;

   117         ba.DeleteFile(aFs, del002);

   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, del002, 

   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

   145     CAsynchFSQ* aFSQ = NULL;

   146     TRAPD( err, 

   147         aFSQ = CAsynchFSQ::NewL();

   148         error = aFSQ->Delete( del002 );

   149         );

   150     TRAP_IGNORE(

   151         delete aFSQ;

   152         aFSQ = NULL;

   153         );

   154     

   155     //check that file was deleted

   156     RFs fsSession2;

   157     TInt fsConnectErr = fsSession2.Connect();

   158     RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteFromEmptyExistsL fsConnectErr=%d"), fsConnectErr );

   159     RFile file2;

   160     TInt fileError = file2.Open(fsSession2, del002, EFileRead);

   161     file2.Close();

   162     fsSession2.Close();

   163     

   164     //assert

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

   166     

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

   168 

   169     RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteFromEmptyExistsL out") );

   170     }

   171 

   172 void CAFSQTestAsynchSave::TestDeleteNonEmptyExistsButNotInQueueL()

   173     {

   174     // Group:   Asynch Save

   175     // 

   176     // ID:      CAE.FM.TESTDELETEOBJECT.003

   177     // 

   178     // Action : Test that delete will work if the queue is not empty but

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

   180     //      

   181     // Output : A KErrNone.   

   182 	

   183     RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteNonEmptyExistsButNotInQueueL in") );

   184 	

   185     currentTest = EDEL003p1;

   186     numSaved = 0;

   187     numToSave = 2;

   188     wait = ETrue;

   189     TInt error = KErrNone;

   190 

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

   192     TFileName aFilename = KNibbles;

   193     RFs aFs;

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

   195     RFile file;

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

   197     TInt iSize;   

   198     file.Size(iSize);

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

   200     TPtr8  myData = buf->Des();

   201     if ( !connectErr )

   202         {

   203         file.Read( myData );

   204         }

   205     file.Close();

   206 

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

   208     TFileName aFilename2 = KNibbles2;

   209     RFile file2;

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

   211     file2.Size(iSize);

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

   213     TPtr8  myData2 = buf2->Des();

   214     if ( !connectErr2 )

   215         {

   216         file2.Read( myData2 );

   217         }

   218     file2.Close();

   219     

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

   221     TFileName aFilename3 = KNibbles3;

   222     RFile file3;

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

   224     file3.Size(iSize);

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

   226     TPtr8  myData3 = buf3->Des();

   227     if ( !connectErr3 )

   228         {

   229         file3.Read( myData3 );

   230         }

   231     file3.Close();

   232 

   233     // Delete the file if it exists

   234     TFileName del003A = KNibblesDEL003A;

   235     RFile deleter;

   236     TInt isDeleted = deleter.Open(aFs, del003A, EFileRead);

   237     deleter.Close();

   238     if ( isDeleted == KErrNone )

   239         {

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

   241     	RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteNonEmptyExistsButNotInQueueL 1st exists, deleting") );

   242         BaflUtils ba;

   243         ba.DeleteFile(aFs, del003A);

   244         }

   245 

   246     // Delete the file if it exists

   247     TFileName del003B = KNibblesDEL003B;

   248     RFile deleter2;

   249     TInt isDeleted2 = deleter2.Open(aFs, del003B, EFileRead);

   250     deleter2.Close();

   251     if ( isDeleted2 == KErrNone )

   252         {

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

   254     	RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteNonEmptyExistsButNotInQueueL 2nd exists, deleting") );

   255         BaflUtils ba;

   256         ba.DeleteFile(aFs, del003B);

   257         }

   258         

   259     // Delete the file if it exists

   260     TFileName del003C = KNibblesDEL003C;

   261     RFile deleter3;

   262     TInt isDeleted3 = deleter3.Open(aFs, del003C, EFileRead);

   263     deleter3.Close();

   264     if ( isDeleted3 == KErrNone )

   265         {

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

   267     	RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteNonEmptyExistsButNotInQueueL 3rd exists, deleting") );

   268         BaflUtils ba;

   269         ba.DeleteFile(aFs, del003C);

   270         }

   271 

   272     // Write the file to be used in testing

   273     TInt err2 = KErrNone;

   274     RFs fsSession;

   275     err2 = fsSession.Connect();

   276     RFile myFile;

   277     if ( !err2 )

   278         {

   279         err2 = myFile.Create( fsSession, del003A, 

   280                              EFileStream | EFileShareExclusive | EFileWrite );

   281         }

   282     if( !err2 )

   283         {

   284         err2 = myFile.Write( myData );

   285         }

   286     if( !err2 )

   287         {

   288         err2 = myFile.Flush();

   289         }

   290 	myFile.Close();

   291 	fsSession.Close();

   292 	aFs.Close();

   293 	delete buf;

   294 	buf = NULL;

   295 

   296     //delete

   297     TRAPD( err, 

   298         iFSQ = CAsynchFSQ::NewL();

   299         iFSQ->SetCallback( this );

   300         error = iFSQ->SaveAndDestroy( *buf2, del003B );

   301         buf2 = NULL;

   302         error = iFSQ->SaveAndDestroy( *buf3, del003C );

   303         buf3 = NULL;

   304         error = iFSQ->Delete( del003A );

   305         );

   306 

   307     //delayed assert on callback

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

   309     

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

   311     WaitForAsynchCompleteL();

   312 

   313     RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteNonEmptyExistsButNotInQueueL out") );

   314     }

   315 

   316 void CAFSQTestAsynchSave::TestDeleteNonEmptyNotExistAndNotInQueueL()

   317     {

   318     // Group:   Asynch Save

   319     // 

   320     // ID:      CAE.FM.TESTDELETEOBJECT.004

   321     // 

   322     // Action : Test that delete will return error if the queue is not empty but

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

   324     //      

   325     // Output : A KErrNotFound.   

   326 	

   327     RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteNonEmptyNotExistAndNotInQueueL in") );

   328 

   329     currentTest = EDEL004p1;

   330     numSaved = 0;

   331     numToSave = 2;

   332     wait = ETrue;

   333     TInt error = KErrNone;

   334 

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

   336     TFileName aFilename = KNibbles;

   337     RFs aFs;

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

   339     RFile file;

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

   341     TInt iSize;   

   342     file.Size(iSize);

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

   344     TPtr8  myData = buf->Des();

   345     if ( !connectErr )

   346         {

   347         file.Read( myData );

   348         }

   349     file.Close();

   350 

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

   352     TFileName aFilename2 = KNibbles2;

   353     RFile file2;

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

   355     file2.Size(iSize);

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

   357     TPtr8  myData2 = buf2->Des();

   358     if ( !connectErr2 )

   359         {

   360         file2.Read( myData2 );

   361         }

   362     file2.Close();

   363     

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

   365     TFileName aFilename3 = KNibbles3;

   366     RFile file3;

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

   368     file3.Size(iSize);

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

   370     TPtr8  myData3 = buf3->Des();

   371     if ( !connectErr3 )

   372         {

   373         file3.Read( myData3 );

   374         }

   375     file3.Close();

   376 

   377     // Delete the file if it exists

   378     TFileName del004A = KNibblesDEL004A;

   379     RFile deleter;

   380     TInt isDeleted = deleter.Open(aFs, del004A, EFileRead);

   381     deleter.Close();

   382     if ( isDeleted == KErrNone )

   383         {

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

   385     	RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteNonEmptyNotExistAndNotInQueueL 1st exists, deleting") );

   386         BaflUtils ba;

   387         ba.DeleteFile(aFs, del004A);

   388         }

   389 

   390     // Delete the file if it exists

   391     TFileName del004B = KNibblesDEL004B;

   392     RFile deleter2;

   393     TInt isDeleted2 = deleter2.Open(aFs, del004B, EFileRead);

   394     deleter2.Close();

   395     if ( isDeleted2 == KErrNone )

   396         {

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

   398     	RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteNonEmptyNotExistAndNotInQueueL 2nd exists, deleting") );

   399         BaflUtils ba;

   400         ba.DeleteFile(aFs, del004B);

   401         }

   402         

   403     // Delete the file if it exists

   404     TFileName del004C = KNibblesDEL004C;

   405     RFile deleter3;

   406     TInt isDeleted3 = deleter3.Open(aFs, del004C, EFileRead);

   407     deleter3.Close();

   408     if ( isDeleted3 == KErrNone )

   409         {

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

   411     	RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteNonEmptyNotExistAndNotInQueueL 3rd exists, deleting") );

   412         BaflUtils ba;

   413         ba.DeleteFile(aFs, del004C);

   414         }

   415 

   416     aFs.Close();

   417     delete buf;

   418     buf = NULL;

   419 

   420     //delete

   421     TRAPD( err, 

   422         iFSQ = CAsynchFSQ::NewL();

   423         iFSQ->SetCallback( this );

   424         error = iFSQ->SaveAndDestroy( *buf2, del004B );

   425         buf2 = NULL;

   426         error = iFSQ->SaveAndDestroy( *buf3, del004C );

   427         buf3 = NULL;

   428         error = iFSQ->Delete( del004A );

   429         );

   430 

   431     //delayed assert on callback

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

   433     

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

   435     WaitForAsynchCompleteL();

   436 

   437     RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteNonEmptyNotExistAndNotInQueueL out") );

   438     }

   439 

   440 void CAFSQTestAsynchSave::TestDeleteInQueueNotActiveL()

   441     {

   442     // Group:   Asynch Save

   443     // 

   444     // ID:      CAE.FM.TESTDELETEOBJECT.005

   445     // 

   446     // Action : Test that delete will work ok if the queue is not empty and

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

   448     //          This case checks that the file NOT ACTIVELY being saved gets deleted.

   449     //      

   450     // Output : A KErrNone.   

   451 	

   452     RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteInQueueNotActiveL in") );

   453 	

   454     currentTest = EDEL005p1;

   455     numSaved = 0;

   456     numToSave = 2;

   457     wait = ETrue;

   458     TInt error = KErrNone;

   459 

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

   461     TFileName aFilename = KNibbles;

   462     RFs aFs;

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

   464     RFile file;

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

   466     TInt iSize;   

   467     file.Size(iSize);

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

   469     TPtr8  myData = buf->Des();

   470     if ( !connectErr )

   471         {

   472         file.Read( myData );

   473         }

   474     file.Close();

   475 

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

   477     TFileName aFilename2 = KNibbles2;

   478     RFile file2;

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

   480     file2.Size(iSize);

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

   482     TPtr8  myData2 = buf2->Des();

   483     if ( !connectErr2 )

   484         {

   485         file2.Read( myData2 );

   486         }

   487     file2.Close();

   488     

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

   490     TFileName aFilename3 = KNibbles3;

   491     RFile file3;

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

   493     file3.Size(iSize);

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

   495     TPtr8  myData3 = buf3->Des();

   496     if ( !connectErr3 )

   497         {

   498         file3.Read( myData3 );

   499         }

   500     file3.Close();

   501 

   502     // Delete the file if it exists

   503     TFileName del005A = KNibblesDEL005A;

   504     RFile deleter;

   505     TInt isDeleted = deleter.Open(aFs, del005A, EFileRead);

   506     deleter.Close();

   507     if ( isDeleted == KErrNone )

   508         {

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

   510     	RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteInQueueNotActiveL 1st exists, deleting") );

   511         BaflUtils ba;

   512         ba.DeleteFile(aFs, del005A);

   513         }

   514 

   515     // Delete the file if it exists

   516     TFileName del005B = KNibblesDEL005B;

   517     RFile deleter2;

   518     TInt isDeleted2 = deleter2.Open(aFs, del005B, EFileRead);

   519     deleter2.Close();

   520     if ( isDeleted2 == KErrNone )

   521         {

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

   523     	RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteNonEmptyNotExistAndNotInQueueL 2nd exists, deleting") );

   524         BaflUtils ba;

   525         ba.DeleteFile(aFs, del005B);

   526         }

   527         

   528     // Delete the file if it exists

   529     TFileName del005C = KNibblesDEL005C;

   530     RFile deleter3;

   531     TInt isDeleted3 = deleter3.Open(aFs, del005C, EFileRead);

   532     deleter3.Close();

   533     if ( isDeleted3 == KErrNone )

   534         {

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

   536     	RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteInQueueNotActiveL 3rd exists, deleting") );

   537         BaflUtils ba;

   538         ba.DeleteFile(aFs, del005C);

   539         }

   540 

   541     aFs.Close();

   542 

   543     //delete

   544     TRAPD( err, 

   545         iFSQ = CAsynchFSQ::NewL();

   546         iFSQ->SetCallback( this );

   547         error = iFSQ->SaveAndDestroy( *buf2, del005B );

   548         buf2 = NULL;

   549         error = iFSQ->SaveAndDestroy( *buf3, del005C );

   550         buf3 = NULL;

   551         error = iFSQ->SaveAndDestroy( *buf, del005A );

   552         buf = NULL;

   553         error = iFSQ->Delete( del005A );

   554         );

   555 

   556     //delayed assert on callback

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

   558     

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

   560     WaitForAsynchCompleteL();

   561 

   562     RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteInQueueNotActiveL out") );

   563     }

   564 

   565 void CAFSQTestAsynchSave::TestDeleteInQueueActiveL()

   566     {

   567     // Group:   Asynch Save

   568     // 

   569     // ID:      CAE.FM.TESTDELETEOBJECT.006

   570     // 

   571     // Action : Test that delete will work ok if the queue is not empty and

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

   573     //          This case checks that the file ACTIVELY being saved gets deleted.

   574     //      

   575     // Output : A KErrNone.   

   576 	

   577     RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteInQueueActiveL in") );

   578 	

   579     currentTest = EDEL006p1;

   580     numSaved = 0;

   581     wait = ETrue;

   582     TInt error = KErrNone;

   583 

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

   585     TFileName aFilename = KNibbles;

   586     RFs aFs;

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

   588     RFile file;

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

   590     TInt iSize;   

   591     file.Size(iSize);

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

   593     TPtr8  myData = buf->Des();

   594     if ( !connectErr )

   595         {

   596         file.Read( myData );

   597         }

   598     file.Close();

   599 

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

   601     TFileName aFilename2 = KNibbles2;

   602     RFile file2;

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

   604     file2.Size(iSize);

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

   606     TPtr8  myData2 = buf2->Des();

   607     if ( !connectErr2 )

   608         {

   609         file2.Read( myData2 );

   610         }

   611     file2.Close();

   612     

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

   614     TFileName aFilename3 = KNibbles3;

   615     RFile file3;

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

   617     file3.Size(iSize);

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

   619     TPtr8  myData3 = buf3->Des();

   620     if ( !connectErr3 )

   621         {

   622         file3.Read( myData3 );

   623         }

   624     file3.Close();

   625 

   626     // Delete the file if it exists

   627     TFileName del006A = KNibblesDEL006A;

   628     RFile deleter;

   629     TInt isDeleted = deleter.Open(aFs, del006A, EFileRead);

   630     deleter.Close();

   631     if ( isDeleted == KErrNone )

   632         {

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

   634     	RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteInQueueNotActiveL 1st exists, deleting") );

   635         BaflUtils ba;

   636         ba.DeleteFile(aFs, del006A);

   637         }

   638 

   639     // Delete the file if it exists

   640     TFileName del006B = KNibblesDEL006B;

   641     RFile deleter2;

   642     TInt isDeleted2 = deleter2.Open(aFs, del006B, EFileRead);

   643     deleter2.Close();

   644     if ( isDeleted2 == KErrNone )

   645         {

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

   647     	RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteNonEmptyNotExistAndNotInQueueL 2nd exists, deleting") );

   648         BaflUtils ba;

   649         ba.DeleteFile(aFs, del006B);

   650         }

   651         

   652     // Delete the file if it exists

   653     TFileName del006C = KNibblesDEL006C;

   654     RFile deleter3;

   655     TInt isDeleted3 = deleter3.Open(aFs, del006C, EFileRead);

   656     deleter3.Close();

   657     if ( isDeleted3 == KErrNone )

   658         {

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

   660     	RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteInQueueNotActiveL 3rd exists, deleting") );

   661         BaflUtils ba;

   662         ba.DeleteFile(aFs, del006C);

   663         }

   664 

   665     aFs.Close();

   666 	    

   667     //delete

   668     TInt errorA = 0;

   669     TInt errorB = 0;

   670     TRAPD( err, 

   671         iFSQ = CAsynchFSQ::NewL();

   672         iFSQ->SetCallback( this );

   673         error = iFSQ->SaveAndDestroy( *buf2, del006B );

   674         buf2 = NULL;

   675         error = iFSQ->SaveAndDestroy( *buf3, del006C );

   676         buf3 = NULL;

   677         error = iFSQ->SaveAndDestroy( *buf, del006A );

   678         buf = NULL;

   679         errorA = iFSQ->Delete( del006B );

   680         errorB = iFSQ->Delete( del006C );

   681         );

   682 

   683     //delayed assert on callback

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

   685     

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

   687     WaitForAsynchCompleteL();

   688     

   689     RDebug::Print( _L("CAFSQTestAsynchSave::TestDeleteInQueueActiveL out") );

   690     }

   691 

   692