// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// This test step feeds precompressed IP/TCP packets into both 
// the VJDeCompressor (unit under test) and the Referece Decompressor 
// (provided in RFC 1144).
// The output of the VJDeCompressor is compared against the output of 
// the Reference Decompressor to verify its corectness
// 
//

/**
 @file VJDecompressTypeErrorTest.cpp
*/
 
#include "VJTest.h"

// Reference decompressor needs this much space before the compressed
// packet so it can store the TCP/IP header
static const TUint KRefPacketHeaderSpace = 128;

void CVJDecompressTypeErrorTest::ProcessPacketL()
/**
This is a virtual function. 
This function feeds precompressed IP/TCP packets into both 
the VJDeCompressor (unit under test) and the Referece Decompressor 
(provided in RFC 1144).
The output of the VJDeCompressor is compared against the output of 
the Reference Decompressor to verify its corectness 
*/

{	
		TUint packetType = TrimPacketBeforeDecompression();
		
		if (packetType == 911)
		{
		    // Packet type is unsupported. Abort test.
		    SetTestStepResult(EFail);
		    return;
		}
			
		// Create packet buffer to be sent to reference decompressor
		// This is to prevent compromising the test results if the compressor/decompressor alters the original data
	    HBufC8* refPacketBuffer = HBufC8::NewMaxLC(TPcapRecord::KMaxPacketSize+KRefPacketHeaderSpace);
	    // Reserve some space at the head of the HBufC8 for the uncompressed header
	    // The reference decompressor expects the packet has enough space to prepend 120 byes of resconstructed header 
	    TPtr8 refInputPtr(const_cast<TUint8*>(refPacketBuffer->Ptr())+KRefPacketHeaderSpace, refPacketBuffer->Length()-KRefPacketHeaderSpace);
	    refInputPtr = iRec->Data();
	    
	    TUint8 *refdecompOutput = NULL;
	    TInt refPacketLen = refInputPtr.Length();
	  
	    // Create packet buffer to be sent to VJDecompressor
	    // This is to prevent compromising the test results if the compressor/decompressor alters the original data
	    // The size of the HBuf object must have a maximum length that is big enough to hold the decompressed data
	    HBufC8* vjPacketBuffer = HBufC8::NewLC(TPcapRecord::KMaxPacketSize);
	    TPtr8 vjOutputPtr (vjPacketBuffer->Des());
	    vjOutputPtr = iRec->Data();
	    		  
	    iPacket.CopyIn(*vjPacketBuffer, 0); 
	    iPacket.TrimEnd(vjPacketBuffer->Length());
		 
	   
	    // Create info packet
 	    RMBufPacket pkt;
	    RMBufPktInfo* info = 0;
        info = pkt.NewInfoL();  
       	info->iLength = vjPacketBuffer->Length();
        pkt.Pack();
        iPacket.Prepend(pkt);
	    		
	    // Put info packet in front of this packet 
	    TUint vjdecompRet;
	    
	     //-------------- substep 7 -------------------- 
	    // decompress the packet using VJDeCompressor and Reference decompressor 
	    INFO_PRINTF1(_L("  07, 08 Decompress the packet using VJDeCompressor and Reference Decompressor:"));
	    
	    switch (packetType)
	    {
	        case KPppIdIp:
	        // the packet is TYPE_IP
	             // decompress TYPE_IP packet using our reference decompressor
	            INFO_PRINTF1(_L("  07 Decompress TYPE_IP packet using reference decompressor:"));
      			refdecompOutput = sl_uncompress_tcp(const_cast<TUint8*>(refInputPtr.Ptr()), &refPacketLen, (TUint)TYPE_IP, iComp);
	    
	            // VJ Decompressor function is not called because the packet is TYPE_IP
	            INFO_PRINTF1(_L("  08 TYPE_IP packet is not modified by VJDecompressor."));
	            vjdecompRet = ETrue;
	    		break;
  		    case KPppIdVjCompTcp:
	        // the packet is COMPRESSED_TCP
	            // decompress using our reference decompressor
	            INFO_PRINTF1(_L("  07 Decompress COMPRESSED_TCP packet using reference decompressor:"));
      			refdecompOutput = sl_uncompress_tcp(const_cast<TUint8*>(refInputPtr.Ptr()), &refPacketLen, (TUint)TYPE_COMPRESSED_TCP, iComp);
	        
                //decompress using our VJ Decompressor
	            INFO_PRINTF1(_L("  08 Decompress COMPRESSED_TCP packet using VJDeCompressor:"));
	            vjdecompRet = iVJDeCompressor->DecompVJComp(iPacket);
	            INFO_PRINTF2(_L(" 08 COMPRESSED_TCP packet is decompressed: %d"), vjdecompRet);
	   	  		break;
	        case KPppIdVjUncompTcp:
	        // the packet is UNCOMPRESSED_TCP
	            // decompress using our reference Compressor
	            INFO_PRINTF1(_L("  07 Decompress UNCOMPRESSED_TCP packet using reference decompressor:"));
      			refdecompOutput = sl_uncompress_tcp(const_cast<TUint8*>(refInputPtr.Ptr()), &refPacketLen, (TUint)TYPE_UNCOMPRESSED_TCP, iComp);
	        	
	        //decompress using our VJ Decompressor
	            INFO_PRINTF1(_L("  08 Decompress UNCOMPRESSED_TCP packet using VJDeCompressor:"));
	            vjdecompRet = iVJDeCompressor->DecompVJUncomp(iPacket);
	            INFO_PRINTF2(_L(" 08 UNCOMPRESSED_TCP packet is decompressed: %d"), vjdecompRet);
	        	break;
	        default: 
	        //the packet is TYPE_ERROR
	            // set 'toss' flag and discard COMPRESSED_TCP packet until one with C bit set
	            // or an UNCOMPRESSED_TCP packet arrives
	             // decompress using our reference decompressor
	            INFO_PRINTF1(_L("  07 Decompress TYPE_ERROR packet using reference decompressor:"));
      			refdecompOutput = sl_uncompress_tcp(const_cast<TUint8*>(refInputPtr.Ptr()), &refPacketLen, (TUint)TYPE_ERROR, iComp);
	     		//decompress using our VJ Decompressor
	            INFO_PRINTF1(_L("  08 Handle TYPE_ERROR packet using VJDeCompressor:"));
	            iVJDeCompressor->CRCError(); 
	            vjdecompRet = EFalse;
	    		break;
	    }    
	    
	     if ((vjdecompRet) && refdecompOutput != 0)
	     {
	         //--------------substep 09----------------------
 	         // Display VJ decompressed packet
	         INFO_PRINTF1(_L("  09 The VJ decompressed packet:"));
	     
	         // The decompressed data should be larger than the compressed data
	         // So we need to expand the size of the pointer in order to hold the decompressed data
	         vjOutputPtr.SetMax();
	         
	         // Remove info packet 
	         iPacket.Remove();
	         iPacket.CopyOut(vjOutputPtr);	
 			 
	         INFO_PRINTF2(_L("VJ decompressed packet len: %d"), vjPacketBuffer->Length()); 
	         // TPtrC8 object is created because DumpIp() takes a TPtrC8 object as a parameter
	         TPtrC8 vjOutputPtrC (vjOutputPtr);
	         DumpIp(vjOutputPtrC);
	     
	         //--------------substep 10----------------------
 	         // Display REF decompressed packet
	         INFO_PRINTF1(_L("10 The REF decompressed packet is:")); 
	         TPtrC8 refOutputPtrC(refdecompOutput, refPacketLen);
	         DumpIp(refOutputPtrC);
	         
 	         //--------------substep 11----------------------
 	         //Compare the results of the reference compressor output and our VJ compressor output
 	     
 	         INFO_PRINTF1(_L("  11 Compare the result of the compression by VJCompressor to Reference compressor:"));
 	         INFO_PRINTF2(_L(" Size of VJ comp output: %d"), vjOutputPtrC.Length()); 
 		     INFO_PRINTF2(_L(" Size of Reference comp output: %d"), refOutputPtrC.Length()); 
 	     
 	    	 if (!CompareOutput(vjOutputPtrC, refOutputPtrC))
 		     {
 	              INFO_PRINTF1(_L("The results are not equal"));
 	              
 	              SetTestStepResult(EFail);   
 	         }
 	     }
 	     else
 	     {
 	           IsItATossPacket(vjdecompRet, refdecompOutput);
 	     }
 	     
 	     
 	     CleanupStack::PopAndDestroy(vjPacketBuffer);
 	        
		 CleanupStack::PopAndDestroy(refPacketBuffer);
 	   
		 vjPacketBuffer = NULL;
		 refPacketBuffer = NULL;
	
} // VJDecompressTypeErrorTest