C++ RBuf8::Compare方法代码示例

//.........这里部分代码省略.........
		file.Close();
		return(r);
		}
		
	TInt i;
	
	if (aPattern)
		{
		// ascending pattern
		for (i = 0; i < KCreateFileBufSize; i++)
			{			
			wBuf[i] = (TUint8) i;			
			}
		}
	else
		{
		// descending pattern
		for (i = 0; i < KCreateFileBufSize; i++)
			{
			wBuf[i] = (TUint8) ((KCreateFileBufSize - 1) - i);
			}
		}


	TInt pos;
	TInt chunkSize;
	TInt sectorCount = 0;
	
	for (pos = 0; pos < aSize; pos += chunkSize)
		{
		wBuf[0]=(TUint8)i;	// Insert sector count
		chunkSize = Min((aSize-pos), KCreateFileBufSize);
		r = file.Write(pos, wBuf, chunkSize);
		if (r != KErrNone)
			{
			LogError(r, KWrite, aFileName, pos, chunkSize, __LINE__);
			file.Close();
			wBuf.Close();
			return(r);
			}
			
		sectorCount++;
		}

	// Flush it
	r=file.Flush();
	if (r!=KErrNone)
		{
		LogError( r, KFlush, aFileName, 0, 0, __LINE__);
		file.Close();
		wBuf.Close();
		return(r);
		}

//	Test still works if this is commented out just doesn't verify
	// Read back and verify it
	RBuf8 rBuf;
	r = rBuf.CreateMax(KCreateFileBufSize);
	if(r != KErrNone)
		{
		LogError( r, KMemory, aFileName, 0, 0, __LINE__);
		file.Close();
		wBuf.Close();
		rBuf.Close();
		return(KErrGeneral);
		}
	
	
	for (pos = 0;pos < aSize; pos += chunkSize)
		{
		chunkSize = Min((aSize-pos), KCreateFileBufSize);
		r = file.Read(pos, rBuf, chunkSize);
		if (r != KErrNone)
			{
			LogError(r, KRead, aFileName, pos, 0, __LINE__);
			file.Close();
			wBuf.Close();
			rBuf.Close();
			return(r);
			}
			
		wBuf[0] = (TUint8) i; // Insert sector count
		wBuf.SetLength(chunkSize);
		r = rBuf.Compare(wBuf);
		if (r != 0)
			{
			LogError(r, KDataCompare, aFileName, 0, 0, __LINE__);
			file.Close();
			wBuf.Close();
			rBuf.Close();
			return(KErrGeneral);
			}
		}
//

	file.Close();
	wBuf.Close();
	rBuf.Close();
	return(KErrNone);
	}

// ---------------------------------------------------------------------------------
// CUpnpTmFilteredAppList::TmInfoElementMatchingL
// Method is used to compare with each of the desired key-value of a particular
// info element.
// @param aTmInfoElement Reference to Terminal Mode Info Element object.
// @return Returns the boolean value ( ETrue/EFalse )
// ---------------------------------------------------------------------------------
//
TBool CUpnpTmFilteredAppList::TmInfoElementMatchingL( const CUpnpTmInfoElement& aTmInfoElement,
                                                                            TInt aIndex )const
    {
    OstTraceFunctionEntry0( CUPNPTMFILTEREDAPPLIST_TMINFOELEMENTMATCHINGL_ENTRY );
    TBool match(EFalse);
    RBuf8 elementName;
    CleanupClosePushL(elementName);
    RBuf8 elementValue;
    CleanupClosePushL(elementValue);
    aTmInfoElement.GetTmInfoElementL(elementName,elementValue,aIndex );
    // Check for required "protocolID" element
    if ( elementName.Compare(KProtocolId()) == KErrNone ) 
     {
     const TDesC8& filterProtocol = iFilterInfo->ProtocolId();
     if ( ( filterProtocol.Length() == KErrNone) || 
         elementValue.MatchC(filterProtocol) != KErrNotFound )
         {
         // Either protocolID( required element )is unavailable or desired 
         // protocolID matches
         match = ETrue;     
         }
     }
    // Check for optional "format" element
    else if ( elementName.Compare(KFormat()) == KErrNone ) 
         {
         const TDesC8& filterFormat = iFilterInfo->Format();
         if ( ( filterFormat.Length() == KErrNone) || 
             elementValue.MatchC(filterFormat) != KErrNotFound )  
             {
             // Either format ( optional element )is unavailable or desired "format" matches
             match = ETrue;   
             }
         }
    // Check for optional "direction" element
    else if ( elementName.Compare(KRemotingDirection()) == KErrNone ) 
         {
         const TDesC8& filterDirection = iFilterInfo->Direction();
         if ( ( filterDirection.Length() == KErrNone) || 
             elementValue.MatchC(filterDirection) != KErrNotFound )  
             {
             // Either direction ( optional element )is unavailable or desired "direction" matches
             match = ETrue;      
             }
         }
    // Check for optional "appCategory" element
    else if ( elementName.Compare(KAppCategory()) == KErrNone ) 
         {
         const TDesC8& filterAppCategory = iFilterInfo->AppCategory(); 
         if ( ( filterAppCategory.Length() == KErrNone) || 
             elementValue.MatchC(filterAppCategory) != KErrNotFound )
             {
             // Either appCategory ( optional element )is unavailable or desired "appCategory" matches
             match = ETrue;     
             }
         }
    // Check for optional "trustLevel" element for App Info Type
    else if ( ( elementName.Compare(KTrustLevel()) == KErrNone ) &&
                           ( aTmInfoElement.TerminalModeInfoType() == KAppInfo()) )
         {
         const TDesC8& filterAppTrustLevel = iFilterInfo->AppTrustLevel();
         if ( ( filterAppTrustLevel.Length() == KErrNone) || 
             elementValue.MatchC(filterAppTrustLevel) != KErrNotFound )
             {
             // Either trustLevel ( optional element )is unavailable or desired "trustLevel" matches
             match = ETrue;    
             }
     }
    // Check for optional "contentCategory" element
    else if ( elementName.Compare(KContCategory()) == KErrNone ) 
         {
         const TDesC8& filterContCategory = iFilterInfo->ContentCategory();
         if ( ( filterContCategory.Length() == KErrNone) || 
             elementValue.MatchC(filterContCategory) != KErrNotFound )
             {
             // Either contentCategory ( optional element )is unavailable or desired
             // "contentCategory" matches
             match = ETrue;     
             }
         }
    // Check for optional "contentRules" element
    else if ( elementName.Compare(KContentRules()) == KErrNone ) 
         {
         const TDesC8& filterContentRules = iFilterInfo->ContentRules();
         if ( ( filterContentRules.Length() == KErrNone) || 
             elementValue.MatchC(filterContentRules) != KErrNotFound )
             {
             // Either contentRules ( optional element )is unavailable or desired "contentRules" matches
             match = ETrue;  
             }
         }
    // Check for optional "trustLevel" element for Display Info type
    else if ( ( elementName.Compare(KTrustLevel()) == KErrNone ) &&
//.........这里部分代码省略.........

//.........这里部分代码省略.........
		WriteL(atestdata2);
		WriteNewLineL();
		Close();	
		}

		
	//test the overwrite data option - outputfile should contain only 2 lines of data of the form:
	// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
	// 0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 11000
	for(TInt i=0; i!=appendcount;i++)
		{
		OpenL(KTestFileOverwrite, EFalse);
		WriteL(atestdata1);
		WriteNewLineL();
		WriteL(atestdata2);
		WriteNewLineL();
		Close();	
		}

	// read the files back to check they are valid, as an automated check
	
	RFs fsSession;
	RFile appendfile;
	RFile overwritefile;
	TInt filesize;
	User::LeaveIfError(fsSession.Connect());
	
	//sizes in bytes of generated output csv data
	TInt appendsize=appendcount*(sizeof(atestdata1)+sizeof(atestdata2)+2*sizeof(KCsvNewLine)+(data1element+data2element)*sizeof(KCsvComma));
	TInt overwritesize=(sizeof(atestdata1)+sizeof(atestdata2)+2*sizeof(KCsvNewLine)+(data1element+data2element)*sizeof(KCsvComma));
	
	// fill buffers used for data read from the outputted file
	RBuf8 readappendfile;
	readappendfile.CreateL(appendsize);
	RBuf8 readoverwritefile;
	readoverwritefile.CreateL(overwritesize);
	CleanupClosePushL(readappendfile); 
	CleanupClosePushL(readoverwritefile); 

	// comparison data buffers used to contain the expected data
	RBuf8 acompareappend;
	acompareappend.CreateL(appendsize);	
	RBuf8 acompareoverwrite;
	acompareoverwrite.CreateL(overwritesize);
	CleanupClosePushL(acompareappend); 
	CleanupClosePushL(acompareoverwrite); 
		
	//fill comparison array for appended data
	TInt err=FillReferenceBuffer(acompareappend, appendcount, atestdata1, data1element, atestdata2, data2element);

	//first check the appended file by reading back the last 6 lines in the file and comparing with acompareappend
	if(err==KErrNone)
		{
		if(appendfile.Open(fsSession, KTestFileAppend, EFileRead))
			{
			if(appendfile.Size(filesize))	
				{
				if(appendfile.Read((filesize-sizeof(acompareappend)),readappendfile))
					{
					if(!readappendfile.Compare(acompareappend))
						err=KErrGeneral;
					}
				}
			}
		}
	// close test output csv file
	appendfile.Close();
	
	
	//given the above has passed,
	//fill comparison array for overwritten data			
	if(err==KErrNone)
		err=FillReferenceBuffer(acompareoverwrite, (TInt) 0, atestdata1, data1element, atestdata2, data2element);
	
	//check the overwritten file by reading back the only 2 lines in the file and comparing with acompareoverwrite
	//Note: as a thorough check- read from a zero offset
	if(err==KErrNone)
		{
		if(overwritefile.Open(fsSession, KTestFileOverwrite, EFileRead))
			{
			if(overwritefile.Size(filesize))	
				{
				if(overwritefile.Read(0,readoverwritefile))
					{
					if(!readoverwritefile.Compare(acompareoverwrite))
						err=KErrGeneral;
					}
				}
			}
		}
	// close test output csv file
	overwritefile.Close();
	CleanupStack::PopAndDestroy(&atestdata1); 
	CleanupStack::PopAndDestroy(&atestdata2); 
	CleanupStack::PopAndDestroy(&readappendfile); 
	CleanupStack::PopAndDestroy(&readoverwritefile); 
	CleanupStack::PopAndDestroy(&acompareappend); 
	CleanupStack::PopAndDestroy(&acompareoverwrite); 
	return err;
	}