/*
 * Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *  * Neither the name of The Linux Foundation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>
#include "hton.h" // for htonl
#include "MBIMAggregationTestFixture.h"
#include "MBIMAggregationTestFixtureConf10.h"
#include "MBIMAggregationTestFixtureConf11.h"
#include "MBIMAggregationTestFixtureConf12.h"
#include "Constants.h"
#include "TestsUtils.h"
#include "linux/msm_ipa.h"

#define AGGREGATION_LOOP 4
#define IPV4_DST_ADDR_OFFSET (16)

enum ipa_elan_version {
	ELAN1,
	ELAN2,
};

/////////////////////////////////////////////////////////////////////////////////
//							MBIM Aggregation scenarios                         //
/////////////////////////////////////////////////////////////////////////////////

class MBIMAggregationScenarios {
public:
	//MBIM Aggregation test - sends 5 packets and receives 1 aggregated packet
	static bool MBIMAggregationTest(enum ipa_elan_version elan, Pipe* input,
			Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM Deaggregation test - sends an aggregated packet made from 5 packets
	//and receives 5 packets
	static bool MBIMDeaggregationTest(enum ipa_elan_version elan, Pipe* input,
			Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM Deaggregation one packet test - sends an aggregated packet made from
	//1 packet and receives 1 packet
	static bool MBIMDeaggregationOnePacketTest(enum ipa_elan_version elan,
			Pipe* input, Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM Deaggregation and Aggregation test - sends an aggregated packet made
	//from 5 packets and receives the same aggregated packet
	static bool MBIMDeaggregationAndAggregationTest(enum ipa_elan_version elan,
			Pipe* input, Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM multiple Deaggregation and Aggregation test - sends 5 aggregated
	//packets each one made of 1 packet and receives an aggregated packet made
	//of the 5 packets
	static bool MBIMMultipleDeaggregationAndAggregationTest(
			enum ipa_elan_version elan, Pipe* input, Pipe* output,
			enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM Aggregation Loop test - sends 5 packets and expects to receive 1
	//aggregated packet a few times
	static bool MBIMAggregationLoopTest(enum ipa_elan_version elan, Pipe* input,
			Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM Aggregation time limit test - sends 1 small packet smaller than the
	//byte limit and receives 1 aggregated packet
	static bool MBIMAggregationTimeLimitTest(enum ipa_elan_version elan,
			Pipe* input, Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM Aggregation byte limit test - sends 2 packets that together are
	//larger than the byte limit
	static bool MBIMAggregationByteLimitTest(enum ipa_elan_version elan,
			Pipe* input, Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM Deaggregation multiple NDP test - sends an aggregated packet made
	//from 5 packets and 2 NDPs and receives 5 packets
	static bool MBIMDeaggregationMultipleNDPTest(enum ipa_elan_version elan,
			Pipe* input, Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM Aggregation 2 pipes test - sends 3 packets from one pipe and an
	//aggregated packet made of 2 packets from another pipe and receives 1
	//aggregated packet made of all 5 packets
	static bool MBIMAggregation2PipesTest(enum ipa_elan_version elan,
			Pipe* input1, Pipe* input2, Pipe* output, enum ipa_ip_type m_eIP,
			bool isQcncm);
	//MBIM Aggregation time limit loop test - sends 5 small packet smaller than
	//the byte limit and receives 5 aggregated packet
	static bool MBIMAggregationTimeLimitLoopTest(enum ipa_elan_version elan,
			Pipe* input, Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM Aggregation 0 limits test - sends 5 packets and expects to get each
	//packet back aggregated (both size and time limits are 0)
	static bool MBIMAggregation0LimitsTest(enum ipa_elan_version elan,
			Pipe* input, Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM Aggregation multiple packets test - sends 9 packets with same stream
	//ID and receives 1 aggregated packet with 2 NDPs
	static bool MBIMAggregationMultiplePacketsTest(enum ipa_elan_version elan,
			Pipe* input, Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM Aggregation different stream IDs test - sends 5 packets with
	//different stream IDs and receives 1 aggregated packet made of 5 NDPs
	static bool MBIMAggregationDifferentStreamIdsTest(enum ipa_elan_version elan,
			Pipe* input, Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm);
	//MBIM Aggregation no interleaving stream IDs test - sends 5 packets with
	//interleaving stream IDs (0, 1, 0, 1, 0) and receives 1 aggregated packet
	//made of 5 NDPs
	static bool MBIMAggregationNoInterleavingStreamIdsTest(
			enum ipa_elan_version elan, Pipe* input, Pipe* output,
			enum ipa_ip_type m_eIP, bool isQcncm);

private:
	//This method will deaggregate an aggregated packet and compare the packets
	//to the expected packets
	static bool DeaggragateAndComparePackets(
			Byte pAggregatedPacket[MAX_PACKET_SIZE],
			Byte pExpectedPackets[MAX_PACKETS_IN_MBIM_TESTS][MAX_PACKET_SIZE],
			int pPacketsSizes[MAX_PACKETS_IN_MBIM_TESTS], int nNumPackets,
			int nAggregatedPacketSize, bool isQcncm);
	//This method will aggregate packets
	static void AggregatePackets(
			Byte pAggregatedPacket[MAX_PACKET_SIZE]/*ouput*/,
			Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE],
			int pPacketsSizes[NUM_PACKETS], int nNumPackets,
			int nAggregatedPacketSize, bool isQcncm);
	//This method will aggregate packets and take into consideration their
	//stream id to seperate them into different NDPs
	static void AggregatePacketsWithStreamId(
			Byte pAggregatedPacket[MAX_PACKET_SIZE]/*ouput*/,
			Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE],
			int pPacketsSizes[NUM_PACKETS], int nNumPackets,
			int nAggregatedPacketSize, Byte pPacketsStreamId[NUM_PACKETS]);
	//This method will deaggregate an aggregated packet made of one packet and
	//compare the packet to the expected packet
	static bool DeaggragateAndCompareOnePacket(
			Byte pAggregatedPacket[MAX_PACKET_SIZE],
			Byte pExpectedPacket[MAX_PACKET_SIZE], int nPacketsSize,
			int nAggregatedPacketSize, bool isQcncm);
	//This method will deaggregate an aggregated packet and compare the packets
	//to the expected packets
	static bool DeaggragateAndComparePacketsWithStreamId(
			Byte pAggregatedPacket[MAX_PACKET_SIZE],
			Byte pExpectedPackets[][MAX_PACKET_SIZE], int pPacketsSizes[],
			int nNumPackets, int nAggregatedPacketSize,
			Byte pPacketsStreamId[NUM_PACKETS]);
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMAggregationTest(enum ipa_elan_version elan,
		Pipe* input, Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm)
{
	//The packets that will be sent
	Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//The real sizes of the packets that will be sent
	int pPacketsSizes[NUM_PACKETS];
	//Buffer for the packet that will be received
	Byte pReceivedPacket[2*MAX_PACKET_SIZE];
	//Total size of all sent packets (this is the max size of the aggregated
	//packet minus the size of the header and the NDP)
	int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 24;
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[NUM_PACKETS];

	//initialize the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		if (NUM_PACKETS - 1 == i)
			pPacketsSizes[i] = nTotalPacketsSize;
		else
			pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
		while (0 != pPacketsSizes[i] % 4)
		{
			pPacketsSizes[i]++;
		}
		nTotalPacketsSize -= pPacketsSizes[i];
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
			{
				pPackets[i][j] = i;
			}
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			nIPv4DSTAddr = ntohl(0x7F000001);
			memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
					sizeof(nIPv4DSTAddr));
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pPackets[i][size] = i;
				size++;
			}
		}
	}

	//send the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
					pPacketsSizes[i]);
		int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
		if (pPacketsSizes[i] != nBytesSent)
		{
			LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
					"failed!\n", i, pPacketsSizes[i]);
			return false;
		}
	}

	//receive the aggregated packet
	LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be there)"
			"\n", MAX_PACKET_SIZE);
	int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE);
	if (MAX_PACKET_SIZE != nBytesReceived)
	{
		LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
				"failed!\n", MAX_PACKET_SIZE);
		print_buff(pReceivedPacket, nBytesReceived);
		return false;
	}
	//deaggregating the aggregated packet
	return DeaggragateAndComparePackets(pReceivedPacket, pPackets,
			pPacketsSizes, NUM_PACKETS, MAX_PACKET_SIZE, isQcncm);
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMDeaggregationTest(enum ipa_elan_version elan,
		Pipe* input, Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm)
{
	bool bTestResult = true;
	//The packets that the aggregated packet will be made of
	Byte pExpectedPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//The real sizes of the packets that the aggregated packet will be made of
	int pPacketsSizes[NUM_PACKETS];
	//Buffers for the packets that will be received
	Byte pReceivedPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//Total size of all the packets that the aggregated packet will be made of
	//(this is the max size of the aggregated packet
	//minus the size of the header and the NDP)
	int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 24;
	//The aggregated packet that will be sent
	Byte pAggregatedPacket[MAX_PACKET_SIZE] = {0};

	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[NUM_PACKETS];

	//initialize the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		if (NUM_PACKETS - 1 == i)
			pPacketsSizes[i] = nTotalPacketsSize;
		else
			pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
		while (0 != pPacketsSizes[i] % 4)
		{
			pPacketsSizes[i]++;
		}
		nTotalPacketsSize -= pPacketsSizes[i];
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
			{
				pExpectedPackets[i][j] = i;
			}
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pExpectedPackets[i],
					pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			nIPv4DSTAddr = ntohl(0x7F000001);
			memcpy (&pExpectedPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
					sizeof(nIPv4DSTAddr));
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pExpectedPackets[i][size] = i;
				size++;
			}
		}
	}

	//initializing the aggregated packet
	AggregatePackets(pAggregatedPacket, pExpectedPackets, pPacketsSizes,
			NUM_PACKETS, MAX_PACKET_SIZE, isQcncm);

	//send the aggregated packet
	LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes)\n",
			sizeof(pAggregatedPacket));
	int nBytesSent = input->Send(pAggregatedPacket, sizeof(pAggregatedPacket));
	if (sizeof(pAggregatedPacket) != nBytesSent)
	{
		LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes) "
				"failed!\n", sizeof(pAggregatedPacket));
		return false;
	}

	//receive the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		LOG_MSG_DEBUG("Reading packet %d from the USB pipe(%d bytes should be "
				"there)\n", i, pPacketsSizes[i]);
		int nBytesReceived = output->Receive(pReceivedPackets[i],
				pPacketsSizes[i]);
		if (pPacketsSizes[i] != nBytesReceived)
		{
			LOG_MSG_DEBUG("Receiving packet %d from the USB pipe(%d bytes) "
					"failed!\n", i, pPacketsSizes[i]);
			print_buff(pReceivedPackets[i], nBytesReceived);
			return false;
		}
	}

	//comparing the received packet to the aggregated packet
	LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
	for (int i = 0; i < NUM_PACKETS; i++)
		bTestResult &= !memcmp(pExpectedPackets[i], pReceivedPackets[i],
				pPacketsSizes[i]);

	return bTestResult;
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMDeaggregationOnePacketTest(
		enum ipa_elan_version elan, Pipe* input, Pipe* output,
		enum ipa_ip_type m_eIP, bool isQcncm)
{
	bool bTestResult = true;
	//The packets that the aggregated packet will be made of
	Byte pExpectedPackets[1][MAX_PACKET_SIZE];
	//The real sizes of the packets that the aggregated packet will be made of
	int pPacketsSizes[1] = {100};
	//Buffers for the packets that will be received
	Byte pReceivedPackets[1][MAX_PACKET_SIZE];
	//Total size of the aggregated packet
	//(this is the max size of the aggregated packet
	//minus the size of the header and the NDP)
	int nTotalAggregatedPacketSize = 100 + 12 + 16;
	//The aggregated packet that will be sent
	Byte pAggregatedPacket[MAX_PACKET_SIZE] = {0};

	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[1];

	//initialize the packet
	if (ELAN1 == elan)
	{
		for (int j = 0; j < pPacketsSizes[0]; j++)
			pExpectedPackets[0][j] = 0;
	}
	else if (ELAN2 == elan)
	{
		// Load input data (IP packet) from file
		pIpPacketsSizes[0] = 100;
		if (!LoadDefaultPacket(m_eIP, pExpectedPackets[0], pIpPacketsSizes[0]))
		{
			LOG_MSG_ERROR("Failed default Packet");
			return false;
		}
		nIPv4DSTAddr = ntohl(0x7F000001);
		memcpy (&pExpectedPackets[0][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
				sizeof(nIPv4DSTAddr));
		int size = pIpPacketsSizes[0];
		while (size < pPacketsSizes[0])
		{
			pExpectedPackets[0][size] = 0;
			size++;
		}
	}

	//initializing the aggregated packet
	AggregatePackets(pAggregatedPacket, pExpectedPackets, pPacketsSizes, 1,
			nTotalAggregatedPacketSize, isQcncm);

	//send the aggregated packet
	LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes)\n",
			nTotalAggregatedPacketSize);
	int nBytesSent = input->Send(pAggregatedPacket, nTotalAggregatedPacketSize);
	if (nTotalAggregatedPacketSize != nBytesSent)
	{
		LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes) "
				"failed!\n", nTotalAggregatedPacketSize);
		return false;
	}

	//receive the packet
	for (int i = 0; i < 1; i++)
	{
		LOG_MSG_DEBUG("Reading packet %d from the USB pipe(%d bytes should be "
				"there)\n", i, pPacketsSizes[i]);
		int nBytesReceived = output->Receive(pReceivedPackets[i],
				pPacketsSizes[i]);
		if (pPacketsSizes[i] != nBytesReceived)
		{
			LOG_MSG_DEBUG("Receiving packet %d from the USB pipe(%d bytes) "
					"failed!\n", i, pPacketsSizes[i]);
			print_buff(pReceivedPackets[i], nBytesReceived);
			return false;
		}
	}

	//comparing the received packet to the aggregated packet
	LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
	for (int i = 0; i < 1; i++)
		bTestResult &= !memcmp(pExpectedPackets[i], pReceivedPackets[i],
				pPacketsSizes[i]);

	return bTestResult;
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMDeaggregationAndAggregationTest(
		enum ipa_elan_version elan, Pipe* input, Pipe* output,
		enum ipa_ip_type m_eIP, bool isQcncm)
{
	//The packets that the aggregated packet will be made of
	Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//The real sizes of the packets that the aggregated packet will be made of
	int pPacketsSizes[NUM_PACKETS];
	//Buffers for the packets that will be received
	Byte pReceivedPacket[MAX_PACKET_SIZE];
	//Total size of all the packets that the aggregated packet will be made of
	//(this is the max size of the aggregated packet
	//minus the size of the header and the NDP)
	int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 24;
	//The aggregated packet that will be sent
	Byte pAggregatedPacket[MAX_PACKET_SIZE] = {0};
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[NUM_PACKETS];

	//initialize the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		if (NUM_PACKETS - 1 == i)
			pPacketsSizes[i] = nTotalPacketsSize;
		else
			pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
		while (0 != pPacketsSizes[i] % 4)
			pPacketsSizes[i]++;
		nTotalPacketsSize -= pPacketsSizes[i];
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
				pPackets[i][j] = i;
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			nIPv4DSTAddr = ntohl(0x7F000001);
			memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
					sizeof(nIPv4DSTAddr));
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pPackets[i][size] = i;
				size++;
			}
		}
	}

	//initializing the aggregated packet
	AggregatePackets(pAggregatedPacket, pPackets, pPacketsSizes, NUM_PACKETS,
			MAX_PACKET_SIZE, isQcncm);

	//send the aggregated packet
	LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes)\n",
			MAX_PACKET_SIZE);
	int nBytesSent = input->Send(pAggregatedPacket, MAX_PACKET_SIZE);
	if (MAX_PACKET_SIZE != nBytesSent)
	{
		LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes) "
				"failed!\n", MAX_PACKET_SIZE);
		return false;
	}

	//receive the aggregated packet
	LOG_MSG_DEBUG("Reading aggregated packet from the USB pipe(%d bytes should "
			"be there)\n", MAX_PACKET_SIZE);
	int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE);
	if (MAX_PACKET_SIZE != nBytesReceived)
	{
		LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
				"failed!\n", MAX_PACKET_SIZE);
		LOG_MSG_DEBUG("Received %d bytes\n", nBytesReceived);
		print_buff(pReceivedPacket, nBytesReceived);
		return false;
	}


	//comparing the received packet to the aggregated packet
	LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
	return DeaggragateAndComparePackets(pReceivedPacket, pPackets, pPacketsSizes,
			NUM_PACKETS, MAX_PACKET_SIZE, isQcncm);
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMMultipleDeaggregationAndAggregationTest(
		enum ipa_elan_version elan, Pipe* input, Pipe* output,
		enum ipa_ip_type m_eIP, bool isQcncm)
{
	//The packets that the aggregated packets will be made of
	Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//The real sizes of the packets that the aggregated packet will be made of
	int pPacketsSizes[NUM_PACKETS];
	//Buffers for the packets that will be received
	Byte pReceivedPacket[MAX_PACKET_SIZE];
	//Total size of all the packets that the aggregated packet will be made of
	//(this is the max size of the aggregated packet
	//minus the size of the header and the NDP)
	int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 24;
	//The aggregated packet that will be sent
	Byte pAggregatedPacket[NUM_PACKETS][MAX_PACKET_SIZE];
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[NUM_PACKETS];

	//initialize the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		if (NUM_PACKETS - 1 == i)
			pPacketsSizes[i] = nTotalPacketsSize;
		else
			pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
		while (0 != pPacketsSizes[i] % 4)
			pPacketsSizes[i]++;
		nTotalPacketsSize -= pPacketsSizes[i];
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
				pPackets[i][j] = i;
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			nIPv4DSTAddr = ntohl(0x7F000001);
			memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
					sizeof(nIPv4DSTAddr));
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pPackets[i][size] = i;
				size++;
			}
		}
	}

	//initializing the aggregated packets
	for (int i = 0; i < NUM_PACKETS; i++)
		AggregatePackets(pAggregatedPacket[i], &pPackets[i], &pPacketsSizes[i],
				1, pPacketsSizes[i] + 12 + 16, isQcncm);

	//send the aggregated packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		LOG_MSG_DEBUG("Sending aggregated packet %d into the USB pipe(%d "
				"bytes)\n", i, pPacketsSizes[i] + 12 + 16);
		int nBytesSent = input->Send(pAggregatedPacket[i],
				pPacketsSizes[i] + 12 + 16);
		if (pPacketsSizes[i] + 12 + 16 != nBytesSent)
		{
			LOG_MSG_DEBUG("Sending aggregated packet %d into the USB pipe(%d "
					"bytes) failed!\n", i, pPacketsSizes[i] + 12 + 16);
			return false;
		}
	}

	//receive the aggregated packet
	LOG_MSG_DEBUG("Reading aggregated packet from the USB pipe(%d bytes should "
			"be there)\n", MAX_PACKET_SIZE);
	int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE);
	if (MAX_PACKET_SIZE != nBytesReceived)
	{
		LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
				"failed!\n", MAX_PACKET_SIZE);
		LOG_MSG_DEBUG("Received %d bytes\n", nBytesReceived);
		print_buff(pReceivedPacket, nBytesReceived);
		return false;
	}


	//comparing the received packet to the aggregated packet
	LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
	return DeaggragateAndComparePackets(pReceivedPacket, pPackets,
			pPacketsSizes, NUM_PACKETS, MAX_PACKET_SIZE, isQcncm);
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMAggregationLoopTest(enum ipa_elan_version elan,
		Pipe* input, Pipe* output, enum ipa_ip_type m_eIP, bool isQcncm)
{
	//The packets that will be sent
	Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//The real sizes of the packets that will be sent
	int pPacketsSizes[NUM_PACKETS];
	//Buffer for the packet that will be received
	Byte pReceivedPacket[MAX_PACKET_SIZE];
	//Total size of all sent packets (this is the max size of the aggregated
	//packet minus the size of the header and the NDP)
	int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 24;
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[NUM_PACKETS];

	//initialize the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		if (NUM_PACKETS - 1 == i)
			pPacketsSizes[i] = nTotalPacketsSize;
		else
			pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
		while (0 != pPacketsSizes[i] % 4)
			pPacketsSizes[i]++;
		nTotalPacketsSize -= pPacketsSizes[i];
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
				pPackets[i][j] = i;
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			nIPv4DSTAddr = ntohl(0x7F000001);
			memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
					sizeof(nIPv4DSTAddr));
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pPackets[i][size] = i;
				size++;
			}
		}
	}

	int num_iters = AGGREGATION_LOOP - 1;
	if (ELAN1 == elan)
		num_iters = AGGREGATION_LOOP + 1;
	for (int j = 0; j < num_iters; j++)
	{
		//send the packets
		for (int i = 0; i < NUM_PACKETS; i++)
		{
			LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
					pPacketsSizes[i]);
			int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
			if (pPacketsSizes[i] != nBytesSent)
			{
				LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
						"failed!\n", i, pPacketsSizes[i]);
				return false;
			}
		}

		memset(pReceivedPacket, 0, sizeof(pReceivedPacket));
		//receive the aggregated packet
		LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
				"there)\n", MAX_PACKET_SIZE);
		int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE);
		if (MAX_PACKET_SIZE != nBytesReceived)
		{
			LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d "
					"bytes) failed!\n", MAX_PACKET_SIZE);
			print_buff(pReceivedPacket, nBytesReceived);
			return false;
		}

		LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
		if (false == DeaggragateAndComparePackets(pReceivedPacket, pPackets,
				pPacketsSizes, NUM_PACKETS, MAX_PACKET_SIZE, isQcncm))
		{
			LOG_MSG_DEBUG("Comparing aggregated packet failed!\n");
			return false;
		}

	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMAggregationTimeLimitTest(
		enum ipa_elan_version elan, Pipe* input, Pipe* output,
		enum ipa_ip_type m_eIP, bool isQcncm)
{
	//The packets that will be sent
	Byte pPackets[1][MAX_PACKET_SIZE];
	//The real sizes of the packets that will be sent
	int pPacketsSizes[1] = {0};
	//Buffer for the packet that will be received
	Byte pReceivedPacket[MAX_PACKET_SIZE] = {0};
	//Size of aggregated packet
	int nTotalPacketsSize = 24;
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[1];

	//initialize the packets
	for (int i = 0; i < 1 ; i++)
	{
		pPacketsSizes[i] = 52 + 4*i;
		nTotalPacketsSize += pPacketsSizes[i] + 4; //size of the packet + 4 bytes for index and length
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
				pPackets[i][j] = i;
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			nIPv4DSTAddr = ntohl(0x7F000001);
			memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
					sizeof(nIPv4DSTAddr));
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pPackets[i][size] = i;
				size++;
			}
		}
	}
	int nAllPacketsSizes = 0;
	for (int i = 0; i < 1; i++)
		nAllPacketsSizes += pPacketsSizes[i];
	while (0 != nAllPacketsSizes % 4)
	{
		nAllPacketsSizes++;
		nTotalPacketsSize++;  //zero padding for NDP offset to be 4x
	}

	//send the packets
	for (int i = 0; i < 1; i++)
	{
		LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
				pPacketsSizes[i]);
		int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
		if (pPacketsSizes[i] != nBytesSent)
		{
			LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
					"failed!\n", i, pPacketsSizes[i]);
			return false;
		}
	}

	//receive the aggregated packet
	LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
			"there)\n", nTotalPacketsSize);
	int nBytesReceived = output->Receive(pReceivedPacket, nTotalPacketsSize);
	if (nTotalPacketsSize != nBytesReceived)
	{
		LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
				"failed!\n", nTotalPacketsSize);
		print_buff(pReceivedPacket, nBytesReceived);
		return false;
	}

	//comparing the received packet to the aggregated packet
	LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
	if (false == DeaggragateAndComparePackets(pReceivedPacket, pPackets,
			pPacketsSizes, 1, nTotalPacketsSize, isQcncm))
	{
		LOG_MSG_DEBUG("Comparing aggregated packet failed!\n");
		print_buff(pReceivedPacket, nBytesReceived);
		return false;
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMAggregationByteLimitTest(
		enum ipa_elan_version elan, Pipe* input, Pipe* output,
		enum ipa_ip_type m_eIP, bool isQcncm)
{
	//The packets that will be sent
	Byte pPackets[2][MAX_PACKET_SIZE];
	//The real sizes of the packets that will be sent
	int pPacketsSizes[2];
	//Buffer for the packet that will be received
	Byte pReceivedPacket[2*MAX_PACKET_SIZE] = {0};
	//Size of aggregated packet
	int nTotalPacketsSize = 24;
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[2];

	//initialize the packets
	for (int i = 0; i < 2; i++)
	{
		pPacketsSizes[i] = (MAX_PACKET_SIZE / 2) + 10;
		nTotalPacketsSize += pPacketsSizes[i] + 4;
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
				pPackets[i][j] = i;
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			nIPv4DSTAddr = ntohl(0x7F000001);
			memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
					sizeof(nIPv4DSTAddr));
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pPackets[i][size] = i;
				size++;
			}
		}
	}


	//send the packets
	for (int i = 0; i < 2; i++)
	{
		LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
				pPacketsSizes[i]);
		int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
		if (pPacketsSizes[i] != nBytesSent)
		{
			LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
					"failed!\n", i, pPacketsSizes[i]);
			return false;
		}
	}

	//receive the aggregated packet
	LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
			"there)\n", nTotalPacketsSize);
	int nBytesReceived = output->Receive(pReceivedPacket, nTotalPacketsSize);
	if (nTotalPacketsSize != nBytesReceived)
	{
		LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
				"failed!\n", nTotalPacketsSize);
		print_buff(pReceivedPacket, nBytesReceived);
		return false;
	}

	//comparing the received packet to the aggregated packet
	LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
	if (false == DeaggragateAndComparePackets(pReceivedPacket, pPackets,
			pPacketsSizes, 2, nTotalPacketsSize, isQcncm))
	{
		LOG_MSG_DEBUG("Comparing aggregated packet failed!\n");
		return false;
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMDeaggregationMultipleNDPTest(
		enum ipa_elan_version elan, Pipe* input, Pipe* output,
		enum ipa_ip_type m_eIP, bool isQcncm)
{
	bool bTestResult = true;
	//The packets that the aggregated packet will be made of
	Byte pExpectedPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//The real sizes of the packets that the aggregated packet will be made of
	int pPacketsSizes[NUM_PACKETS];
	//Buffers for the packets that will be received
	Byte pReceivedPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//Total size of all the packets that the aggregated packet will be made of
	//(this is the max size of the aggregated packet
	//minus the size of the header and the 2 NDPs)
	int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 36;
	//The aggregated packet that will be sent
	Byte pAggregatedPacket[MAX_PACKET_SIZE] = {0};
	//The stream Id byte for every packet - this will determine on which NDP the
	//packet will appear
	Byte pPacketsStreamId[NUM_PACKETS] = {0};
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[NUM_PACKETS];

	//initialize the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		if (NUM_PACKETS - 1 == i)
			pPacketsSizes[i] = nTotalPacketsSize;
		else {
			pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
			pPacketsSizes[i] += (pPacketsSizes[i] % 4 == 0 ? 0 :
				4 - pPacketsSizes[i] % 4);
		}
		nTotalPacketsSize -= pPacketsSizes[i];
		pPacketsStreamId[i] = i < 3 ? 0 : 1;
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
				pExpectedPackets[i][j] = i;
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pExpectedPackets[i],
					pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			nIPv4DSTAddr = ntohl(0x7F000001);
			memcpy (&pExpectedPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
					sizeof(nIPv4DSTAddr));
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pExpectedPackets[i][size] = i;
				size++;
			}
		}
	}

	//initializing the aggregated packet
	AggregatePacketsWithStreamId(pAggregatedPacket, pExpectedPackets,
			pPacketsSizes, NUM_PACKETS, MAX_PACKET_SIZE, pPacketsStreamId);

	//send the aggregated packet
	LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes)\n",
			sizeof(pAggregatedPacket));
	int nBytesSent = input->Send(pAggregatedPacket, sizeof(pAggregatedPacket));
	if (sizeof(pAggregatedPacket) != nBytesSent)
	{
		LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes) "
				"failed!\n", sizeof(pAggregatedPacket));
		return false;
	}

	//receive the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		LOG_MSG_DEBUG("Reading packet %d from the USB pipe(%d bytes should be "
				"there)\n", i, pPacketsSizes[i]);
		int nBytesReceived = output->Receive(pReceivedPackets[i],
				pPacketsSizes[i]);
		if (pPacketsSizes[i] != nBytesReceived)
		{
			LOG_MSG_DEBUG("Receiving packet %d from the USB pipe(%d bytes) "
					"failed!\n", i, pPacketsSizes[i]);
			print_buff(pReceivedPackets[i], nBytesReceived);
			return false;
		}
	}

	//comparing the received packet to the aggregated packet
	LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
	for (int i = 0; i < NUM_PACKETS; i++)
		bTestResult &= !memcmp(pExpectedPackets[i], pReceivedPackets[i],
				pPacketsSizes[i]);

	return bTestResult;
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMAggregation2PipesTest(enum ipa_elan_version elan,
		Pipe* input1, Pipe* input2, Pipe* output, enum ipa_ip_type m_eIP,
		bool isQcncm)
{
	//The packets that will be sent
	Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//The real sizes of the packets that will be sent
	int pPacketsSizes[NUM_PACKETS];
	//Buffer for the packet that will be received
	Byte pReceivedPacket[2*MAX_PACKET_SIZE];
	//Total size of all sent packets (this is the max size of the aggregated
	//packet minus the size of the header and the NDP)
	int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * NUM_PACKETS) - 24;
	//The aggregated packet that will be sent
	Byte pAggregatedPacket[2][MAX_PACKET_SIZE];
	//The size of the sent aggregated packet
	int nAggregatedPacketSize[2] = {0};
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[NUM_PACKETS];

	//initialize the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		if (NUM_PACKETS - 1 == i)
			pPacketsSizes[i] = nTotalPacketsSize;
		else
			pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
		while (0 != pPacketsSizes[i] % 4)
			pPacketsSizes[i]++;
		nTotalPacketsSize -= pPacketsSizes[i];
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
				pPackets[i][j] = i;
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			nIPv4DSTAddr = ntohl(0x7F000001);
			memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
					sizeof(nIPv4DSTAddr));
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pPackets[i][size] = i;
				size++;
			}
		}
	}

	if (ELAN1 == elan)
	{
		for (int i = 0; i < 2; i++)
		{
			nAggregatedPacketSize[i] += pPacketsSizes[i]; //adding the packet
			nAggregatedPacketSize[i] += 12;  //adding the header
			nAggregatedPacketSize[i] += 16; //adding the NDP
			//initializing the aggregated packet
			AggregatePackets(pAggregatedPacket[i], &pPackets[i],
					&pPacketsSizes[i], 1, nAggregatedPacketSize[i], isQcncm);
		}
	}
	else if (ELAN2 == elan)
	{
		nAggregatedPacketSize[0] += pPacketsSizes[0] + pPacketsSizes[1]; //adding the packets
		nAggregatedPacketSize[0] += 12;  //adding the header
		nAggregatedPacketSize[0] += 12 + 4*2; //adding the NDP
		//initializing the aggregated packet
		AggregatePackets(pAggregatedPacket[0], pPackets, pPacketsSizes, 2,
				nAggregatedPacketSize[0], isQcncm);
	}

	//send the aggregated packet
	if (ELAN1 == elan)
	{
		for (int i = 0; i < 2; i++)
		{
			LOG_MSG_DEBUG("Sending aggregated packet %d into the USB pipe(%d "
					"bytes)\n", i, nAggregatedPacketSize[i]);
			int nBytesSent = input1->Send(pAggregatedPacket[i],
					nAggregatedPacketSize[i]);
			if (nAggregatedPacketSize[i] != nBytesSent)
			{
				LOG_MSG_DEBUG("Sending aggregated packet %d into the USB pipe(%d "
						"bytes) failed!\n", i, nAggregatedPacketSize[i]);
				return false;
			}
		}
	}
	else if (ELAN2 == elan)
	{
		LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d "
				"bytes)\n", nAggregatedPacketSize[0]);
		int nBytesSent = input1->Send(pAggregatedPacket[0],
				nAggregatedPacketSize[0]);
		if (nAggregatedPacketSize[0] != nBytesSent)
		{
			LOG_MSG_DEBUG("Sending aggregated packet into the USB pipe(%d bytes) "
					"failed!\n", nAggregatedPacketSize[0]);
			return false;
		}
	}

	//send the packets
	for (int i = 2; i < NUM_PACKETS; i++)
	{
		LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
				pPacketsSizes[i]);
		int nBytesSent = input2->Send(pPackets[i], pPacketsSizes[i]);
		if (pPacketsSizes[i] != nBytesSent)
		{
			LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
					"failed!\n", i, pPacketsSizes[i]);
			return false;
		}
	}

	//receive the aggregated packet
	LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
			"there)\n", MAX_PACKET_SIZE);
	int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE);
	if (MAX_PACKET_SIZE != nBytesReceived)
	{
		LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
				"failed!\n", MAX_PACKET_SIZE);
		print_buff(pReceivedPacket, nBytesReceived);
		return false;
	}

	//deaggregating the aggregated packet
	return DeaggragateAndComparePackets(pReceivedPacket, pPackets, pPacketsSizes, NUM_PACKETS, MAX_PACKET_SIZE, isQcncm);
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMAggregationTimeLimitLoopTest(
		enum ipa_elan_version elan, Pipe* input, Pipe* output,
		enum ipa_ip_type m_eIP, bool isQcncm)
{
	//The packets that will be sent
	Byte pPackets[1][MAX_PACKET_SIZE];
	//The real sizes of the packets that will be sent
	int pPacketsSizes[1] = {0};
	//Buffer for the packet that will be received
	Byte pReceivedPacket[MAX_PACKET_SIZE] = {0};
	//Size of aggregated packet
	int nTotalPacketsSize = 24;
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[NUM_PACKETS];

	//initialize the packets
	for (int i = 0; i < 1 ; i++)
	{
		pPacketsSizes[i] = 52 + 4*i;
		nTotalPacketsSize += pPacketsSizes[i] + 4; //size of the packet + 4 bytes for index and length
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
				pPackets[i][j] = i;
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			nIPv4DSTAddr = ntohl(0x7F000001);
			memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
					sizeof(nIPv4DSTAddr));
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pPackets[i][size] = i;
				size++;
			}
		}
	}
	int nAllPacketsSizes = 0;
	for (int i = 0; i < 1; i++)
		nAllPacketsSizes += pPacketsSizes[i];
	while (0 != nAllPacketsSizes % 4)
	{
		nAllPacketsSizes++;
		nTotalPacketsSize++;  //zero padding for NDP offset to be 4x
	}

	for (int k = 0; k < AGGREGATION_LOOP; k++)
	{
		//send the packets
		for (int i = 0; i < 1; i++)
		{
			LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
					pPacketsSizes[i]);
			int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
			if (pPacketsSizes[i] != nBytesSent)
			{
				LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
						"failed!\n", i, pPacketsSizes[i]);
				return false;
			}
		}

		//receive the aggregated packet
		LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
				"there)\n", nTotalPacketsSize);
		int nBytesReceived = output->Receive(pReceivedPacket,
				nTotalPacketsSize);
		if (nTotalPacketsSize != nBytesReceived)
		{
			LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d "
					"bytes) failed!\n", nTotalPacketsSize);
			print_buff(pReceivedPacket, nBytesReceived);
			return false;
		}

		//comparing the received packet to the aggregated packet
		LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
		if (false == DeaggragateAndComparePackets(pReceivedPacket, pPackets,
				pPacketsSizes, 1, nTotalPacketsSize, isQcncm))
		{
			LOG_MSG_DEBUG("Comparing aggregated packet failed!\n");
			return false;
		}
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMAggregation0LimitsTest(
		enum ipa_elan_version elan, Pipe* input, Pipe* output,
		enum ipa_ip_type m_eIP, bool isQcncm)
{
	//The packets that will be sent
	Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//The real sizes of the packets that will be sent
	int pPacketsSizes[NUM_PACKETS];
	//Buffer for the packet that will be received
	Byte pReceivedPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//The expected aggregated packets sizes
	int pAggragatedPacketsSizes[NUM_PACKETS] = {0};
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[NUM_PACKETS];

	//initialize the packets
	for (int i = 0; i < NUM_PACKETS ; i++)
	{
		pPacketsSizes[i] = 52 + 4*i;
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
				pPackets[i][j] = i;
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			nIPv4DSTAddr = ntohl(0x7F000001);
			memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
					sizeof(nIPv4DSTAddr));
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pPackets[i][size] = i;
				size++;
			}
		}
	}

	//calculate aggregated packets sizes
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		pAggragatedPacketsSizes[i] += pPacketsSizes[i];
		while (0 != pAggragatedPacketsSizes[i] % 4)
			pAggragatedPacketsSizes[i]++;  //zero padding for NDP offset to be 4x
		pAggragatedPacketsSizes[i] += 28;  //header + NDP
	}

	//send the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
				pPacketsSizes[i]);
		int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
		if (pPacketsSizes[i] != nBytesSent)
		{
			LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
					"failed!\n", i, pPacketsSizes[i]);
			return false;
		}
	}

	//receive the aggregated packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		LOG_MSG_DEBUG("Reading packet %d from the USB pipe(%d bytes should be "
				"there)\n", i, pAggragatedPacketsSizes[i]);
		int nBytesReceived = output->Receive(pReceivedPackets[i],
				pAggragatedPacketsSizes[i]);
		if (pAggragatedPacketsSizes[i] != nBytesReceived)
		{
			LOG_MSG_DEBUG("Receiving aggregated packet %d from the USB pipe(%d "
					"bytes) failed!\n", i, pAggragatedPacketsSizes[i]);
			print_buff(pReceivedPackets[i], nBytesReceived);
			return false;
		}
	}


	//comparing the received packet to the aggregated packet
	LOG_MSG_DEBUG("Checking sent.vs.received packet\n");
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		if (false == DeaggragateAndCompareOnePacket(pReceivedPackets[i],
				pPackets[i], pPacketsSizes[i], pAggragatedPacketsSizes[i],
				isQcncm))
		{
			LOG_MSG_DEBUG("Comparing aggregated packet %d failed!\n", i);
			return false;
		}
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMAggregationMultiplePacketsTest(
		enum ipa_elan_version elan, Pipe* input, Pipe* output,
		enum ipa_ip_type m_eIP, bool isQcncm)
{
	//The packets that will be sent
	Byte pPackets[MAX_PACKETS_IN_NDP + 1][MAX_PACKET_SIZE];
	//The real sizes of the packets that will be sent
	int pPacketsSizes[MAX_PACKETS_IN_NDP + 1];
	//Buffer for the packet that will be received
	Byte pReceivedPacket[2*MAX_PACKET_SIZE];
	//Total size of all sent packets (this is the max size of the aggregated packet
	//minus the size of the header and the 2 NDPs)
	int nTotalPacketsSize = MAX_PACKET_SIZE - (4 * (MAX_PACKETS_IN_NDP + 1)) - 36;
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[MAX_PACKETS_IN_NDP + 1];
	//initialize the packets
	for (int i = 0; i < MAX_PACKETS_IN_NDP + 1; i++)
	{
		if (MAX_PACKETS_IN_NDP == i)
			pPacketsSizes[i] = nTotalPacketsSize;
		else
		{
			pPacketsSizes[i] = nTotalPacketsSize / (MAX_PACKETS_IN_NDP + 1);
			pPacketsSizes[i] += (pPacketsSizes[i] % 4 == 0 ? 0 :
				4 - pPacketsSizes[i] % 4);
		}
		nTotalPacketsSize -= pPacketsSizes[i];
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
				pPackets[i][j] = i;
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			nIPv4DSTAddr = ntohl(0x7F000001);
			memcpy (&pPackets[i][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
					sizeof(nIPv4DSTAddr));
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pPackets[i][size] = i;
				size++;
			}
		}
	}

	//send the packets
	for (int i = 0; i < MAX_PACKETS_IN_NDP + 1; i++)
	{
		LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
					pPacketsSizes[i]);
		int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);

		if (pPacketsSizes[i] != nBytesSent)
		{
			LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
					"failed!\n", i, pPacketsSizes[i]);
			return false;
		}
	}

	//receive the aggregated packet
	LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
			"there)\n", MAX_PACKET_SIZE);
	int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE);
	if (MAX_PACKET_SIZE != nBytesReceived)
	{
		LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
				"failed!\n", MAX_PACKET_SIZE);
		print_buff(pReceivedPacket, nBytesReceived);
		return false;
	}

	//deaggregating the aggregated packet
	return DeaggragateAndComparePackets(pReceivedPacket, pPackets,
			pPacketsSizes, NUM_PACKETS, MAX_PACKET_SIZE, isQcncm);
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMAggregationDifferentStreamIdsTest(
		enum ipa_elan_version elan, Pipe* input, Pipe* output,
		enum ipa_ip_type m_eIP, bool isQcncm)
{
	//The packets that will be sent
	Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//The real sizes of the packets that will be sent
	int pPacketsSizes[NUM_PACKETS];
	//Buffer for the packet that will be received
	Byte pReceivedPacket[2*MAX_PACKET_SIZE];
	//Total size of all sent packets (this is the max size of the aggregated
	//packet minus the size of the header and the NDPs)
	int nTotalPacketsSize = MAX_PACKET_SIZE - (16 * NUM_PACKETS) - 12;
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[NUM_PACKETS];
	Byte pPacketsStreamId[NUM_PACKETS];

	//initialize the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		pPacketsStreamId[i] = i;
		if (NUM_PACKETS - 1 == i)
			pPacketsSizes[i] = nTotalPacketsSize + 12;
		else
			pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
		while (0 != pPacketsSizes[i] % 4)
			pPacketsSizes[i]++;
		nTotalPacketsSize -= pPacketsSizes[i];
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
				pPackets[i][j] = i;
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pPackets[i][size] = i;
				size++;
			}
		}
	}

	nIPv4DSTAddr = ntohl(0x7F000001);
	memcpy (&pPackets[0][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
			sizeof(nIPv4DSTAddr));
	nIPv4DSTAddr = ntohl(0xC0A80101);
	memcpy (&pPackets[1][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
			sizeof(nIPv4DSTAddr));
	nIPv4DSTAddr = ntohl(0xC0A80102);
	memcpy (&pPackets[2][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
			sizeof(nIPv4DSTAddr));
	nIPv4DSTAddr = ntohl(0xC0A80103);
	memcpy (&pPackets[3][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
			sizeof(nIPv4DSTAddr));
	nIPv4DSTAddr = ntohl(0xC0A80104);
	memcpy (&pPackets[4][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
			sizeof(nIPv4DSTAddr));

	//send the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
				pPacketsSizes[i]);
		int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
		if (pPacketsSizes[i] != nBytesSent)
		{
			LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
					"failed!\n", i, pPacketsSizes[i]);
			return false;
		}
	}

	//receive the aggregated packet
	LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
			"there)\n", MAX_PACKET_SIZE + 12);
	int nBytesReceived = output->Receive(pReceivedPacket, MAX_PACKET_SIZE + 12);
	if (MAX_PACKET_SIZE + 12 != nBytesReceived)
	{
		LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes) "
				"failed!\n", MAX_PACKET_SIZE + 12);
		print_buff(pReceivedPacket, nBytesReceived + 12);
		return false;
	}

	//deaggregating the aggregated packet
	return DeaggragateAndComparePacketsWithStreamId(pReceivedPacket, pPackets,
			pPacketsSizes, NUM_PACKETS, MAX_PACKET_SIZE + 12, pPacketsStreamId);
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::MBIMAggregationNoInterleavingStreamIdsTest(
		enum ipa_elan_version elan, Pipe* input, Pipe* output,
		enum ipa_ip_type m_eIP, bool isQcncm)
{
	//The packets that will be sent
	Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE];
	//The real sizes of the packets that will be sent
	int pPacketsSizes[NUM_PACKETS];
	//Buffer for the packet that will be received
	Byte pReceivedPacket[2*MAX_PACKET_SIZE];
	//Total size of all sent packets (this is the max size of the aggregated packet
	//minus the size of the header and the NDPs)
	int nTotalPacketsSize = MAX_PACKET_SIZE - (16 * NUM_PACKETS) - 12;
	uint32_t nIPv4DSTAddr;
	size_t pIpPacketsSizes[NUM_PACKETS];
	Byte pPacketsStreamId[NUM_PACKETS];

	//initialize the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		pPacketsStreamId[i] = i % 2;
		if (NUM_PACKETS - 1 == i)
			pPacketsSizes[i] = nTotalPacketsSize + 12;
		else
			pPacketsSizes[i] = nTotalPacketsSize / NUM_PACKETS;
		while (0 != pPacketsSizes[i] % 4)
			pPacketsSizes[i]++;
		nTotalPacketsSize -= pPacketsSizes[i];
		if (ELAN1 == elan)
		{
			for (int j = 0; j < pPacketsSizes[i]; j++)
				pPackets[i][j] = i;
		}
		else if (ELAN2 == elan)
		{
			// Load input data (IP packet) from file
			pIpPacketsSizes[i] = MAX_PACKET_SIZE;
			if (!LoadDefaultPacket(m_eIP, pPackets[i], pIpPacketsSizes[i]))
			{
				LOG_MSG_ERROR("Failed default Packet");
				return false;
			}
			int size = pIpPacketsSizes[i];
			while (size < pPacketsSizes[i])
			{
				pPackets[i][size] = i;
				size++;
			}
		}
	}

	nIPv4DSTAddr = ntohl(0x7F000001);
	memcpy (&pPackets[0][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
			sizeof(nIPv4DSTAddr));
	nIPv4DSTAddr = ntohl(0xC0A80101);
	memcpy (&pPackets[1][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
			sizeof(nIPv4DSTAddr));
	nIPv4DSTAddr = ntohl(0x7F000001);
	memcpy (&pPackets[2][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
			sizeof(nIPv4DSTAddr));
	nIPv4DSTAddr = ntohl(0xC0A80101);
	memcpy (&pPackets[3][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
			sizeof(nIPv4DSTAddr));
	nIPv4DSTAddr = ntohl(0x7F000001);
	memcpy (&pPackets[4][IPV4_DST_ADDR_OFFSET],&nIPv4DSTAddr,
			sizeof(nIPv4DSTAddr));

	//send the packets
	for (int i = 0; i < NUM_PACKETS; i++)
	{
		LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes)\n", i,
				pPacketsSizes[i]);
		int nBytesSent = input->Send(pPackets[i], pPacketsSizes[i]);
		if (pPacketsSizes[i] != nBytesSent)
		{
			LOG_MSG_DEBUG("Sending packet %d into the USB pipe(%d bytes) "
					"failed!\n", i, pPacketsSizes[i]);
			return false;
		}
	}

	//receive the aggregated packet
	LOG_MSG_DEBUG("Reading packet from the USB pipe(%d bytes should be "
			"there)\n", MAX_PACKET_SIZE + 12);
	int nBytesReceived = output->Receive(pReceivedPacket,
			MAX_PACKET_SIZE + 12);
	if (MAX_PACKET_SIZE + 12 != nBytesReceived)
	{
		LOG_MSG_DEBUG("Receiving aggregated packet from the USB pipe(%d bytes)"
				" failed!\n", MAX_PACKET_SIZE + 12);
		print_buff(pReceivedPacket, nBytesReceived + 12);
		return false;
	}

	//deaggregating the aggregated packet
	return DeaggragateAndComparePacketsWithStreamId(pReceivedPacket, pPackets,
			pPacketsSizes, NUM_PACKETS, MAX_PACKET_SIZE + 12, pPacketsStreamId);
}

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::DeaggragateAndComparePackets(
		Byte pAggregatedPacket[MAX_PACKET_SIZE],
		Byte pExpectedPackets[MAX_PACKETS_IN_MBIM_TESTS][MAX_PACKET_SIZE],
		int pPacketsSizes[MAX_PACKETS_IN_MBIM_TESTS], int nNumPackets, int nAggregatedPacketSize,
		bool isQcncm)
{
	int nPacketNum = 0;
	int i = 0;
	int nNdpStart = 0;
	Byte pNdpIndex[2] = {0};
	Byte pNdpLen[2] = {0};
	if (0x4e != pAggregatedPacket[i] || 0x43 != pAggregatedPacket[i+1] ||
			0x4d != pAggregatedPacket[i+2]|| 0x48 != pAggregatedPacket[i+3])
	{
		LOG_MSG_DEBUG("Error: Wrong NTH16 signature: 0x%02x 0x%02x 0x%02x "
				"0x%02x(should be 0x4e, 0x43, 0x4d, 0x48)\n",
				pAggregatedPacket[i], pAggregatedPacket[i+1],
				pAggregatedPacket[i+2], pAggregatedPacket[i+3]);
		return false;
	}
	i += 4;
	if (0x0c != pAggregatedPacket[i] || 0x00 != pAggregatedPacket[i+1])
	{
		LOG_MSG_DEBUG("Error: Wrong header length: 0x%02x 0x%02x(should be 0x0c, "
				"0x00)\n",
				pAggregatedPacket[i], pAggregatedPacket[i+1]);
		return false;
	}
	i += 4;  //ignoring sequence number
	if ((nAggregatedPacketSize & 0x00FF) != pAggregatedPacket[i] ||
			(nAggregatedPacketSize >> 8) != pAggregatedPacket[i+1])
	{
		LOG_MSG_DEBUG("Error: Wrong aggregated packet length: 0x%02x 0x%02x"
				"(should be 0x%02x, 0x%02x)\n",
				pAggregatedPacket[i], pAggregatedPacket[i+1],
				nAggregatedPacketSize & 0x00FF, nAggregatedPacketSize >> 8);
		return false;
	}
	i += 2;
	pNdpIndex[0] = pAggregatedPacket[i];  //least significant byte
	pNdpIndex[1] = pAggregatedPacket[i+1];  //most significant byte
	//reading the NDP
	while (0x00 != pNdpIndex[0] || 0x00 != pNdpIndex[1])
	{
		i = pNdpIndex[0] + 256*pNdpIndex[1];  //NDP should begin here
		nNdpStart = i;
		if (!isQcncm)
		{
			if (0x49 != pAggregatedPacket[i] || 0x50 != pAggregatedPacket[i+1] ||
					0x53 != pAggregatedPacket[i+2] || 0x00 != pAggregatedPacket[i+3])
			{
				LOG_MSG_DEBUG("Error: Wrong NDP16 signature: 0x%02x 0x%02x "
						"0x%02x 0x%02x(should be 0x49, 0x50, 0x53, 0x00)\n",
						pAggregatedPacket[i], pAggregatedPacket[i+1],
						pAggregatedPacket[i+2], pAggregatedPacket[i+3]);
				return false;
			}
		}
		else
		{
			if (0x44 != pAggregatedPacket[i] || 0x4e != pAggregatedPacket[i+1] ||
					0x51 != pAggregatedPacket[i+2] || 0x50 != pAggregatedPacket[i+3])
			{
				LOG_MSG_DEBUG("Error: Wrong QNDP signature: 0x%02x 0x%02x "
						"0x%02x 0x%02x(should be 0x44, 0x4e, 0x51, 0x50)\n",
						pAggregatedPacket[i], pAggregatedPacket[i+1],
						pAggregatedPacket[i+2], pAggregatedPacket[i+3]);
				return false;
			}
		}
		i += 4;
		pNdpLen[0] = pAggregatedPacket[i];  //least significant byte
		pNdpLen[1] = pAggregatedPacket[i+1];  //most significant byte
		if (0x00 != pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2] ||
				0x00 != pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] -1])
		{
			LOG_MSG_DEBUG("Error: Wrong end of NDP: 0x%02x 0x%02x(should be 0x00,"
					" 0x00)\n",
					pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2],
					pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 1]);
			return false;
		}
		i += 2;
		pNdpIndex[0] = pAggregatedPacket[i];  //least significant byte
		pNdpIndex[1] = pAggregatedPacket[i+1];  //most significant byte
		i += 2;
		while (i <= nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2)
		{ //going over all the datagrams in this NDP
			Byte pDatagramIndex[2] = {0};
			Byte pDatagramLen[2] = {0};
			int packetIndex = 0;
			pDatagramIndex[0] = pAggregatedPacket[i];  //least significant byte
			pDatagramIndex[1] = pAggregatedPacket[i+1];  //most significant byte
			i += 2;
			if (0x00 == pDatagramIndex[0] && 0x00 == pDatagramIndex[1])
				break;  //zero padding after all datagrams
			if (nPacketNum >= nNumPackets)
			{
				LOG_MSG_DEBUG("Error: wrong number of packets: %d(should be %d)\n",
						nPacketNum, nNumPackets);
				return false;
			}
			pDatagramLen[0] = pAggregatedPacket[i];  //least significant byte
			pDatagramLen[1] = pAggregatedPacket[i+1];  //most significant byte
			i += 2;
			packetIndex = pDatagramIndex[0] + 256*pDatagramIndex[1];
			if (pDatagramLen[0] + 256*pDatagramLen[1] != pPacketsSizes[nPacketNum])
			{
				LOG_MSG_DEBUG("Error: Wrong packet %d length: 0x%02x 0x%02x"
						"(should be %d)\n", nPacketNum, pDatagramLen[0],
						pDatagramLen[1], pPacketsSizes[nPacketNum]);
				return false;
			}
			if (0 != memcmp(pExpectedPackets[nPacketNum],
					&pAggregatedPacket[packetIndex], pPacketsSizes[nPacketNum]))
			{
				LOG_MSG_DEBUG("Error: Comparison of packet %d failed!\n",
						nPacketNum);
				return false;
			}
			nPacketNum++;
		}
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////////

void MBIMAggregationScenarios::AggregatePackets(
		Byte pAggregatedPacket[MAX_PACKET_SIZE]/*ouput*/,
		Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE],
		int pPacketsSizes[NUM_PACKETS], int nNumPackets,
		int nAggregatedPacketSize, bool isQcncm)
{
	int i = 0;
	int pDatagramIndexes[NUM_PACKETS] = {0};
	int nNdpIndex = 0;
	int nNdpLen = 0;
	//NTH16 signature
	pAggregatedPacket[i] = 0x4e;
	pAggregatedPacket[i+1] = 0x43;
	pAggregatedPacket[i+2] = 0x4d;
	pAggregatedPacket[i+3] = 0x48;
	i += 4;
	//header length
	pAggregatedPacket[i] = 0x0c;
	pAggregatedPacket[i+1] = 0x00;
	i += 2;
	//sequence number
	pAggregatedPacket[i] = 0x00;
	pAggregatedPacket[i+1] = 0x00;
	i += 2;
	//aggregated packet length
	pAggregatedPacket[i] = nAggregatedPacketSize & 0x00FF;
	pAggregatedPacket[i+1] = nAggregatedPacketSize >> 8;
	i += 2;
	//NDP index
	for (int j = 0; j < nNumPackets; j++)
		nNdpIndex += pPacketsSizes[j];
	nNdpIndex += i + 2;
	while (0 != nNdpIndex % 4)
		nNdpIndex++;
	pAggregatedPacket[i] = nNdpIndex & 0x00FF;
	pAggregatedPacket[i+1] = nNdpIndex >> 8;
	i += 2;
	//packets
	for (int j = 0; j < nNumPackets; j++)
	{
		pDatagramIndexes[j] = i;
		for (int k = 0; k < pPacketsSizes[j]; k++)
		{
			pAggregatedPacket[i] = pPackets[j][k];
			i++;
		}
	}
	while (i < nNdpIndex)
	{
		pAggregatedPacket[i] = 0x00;
		i++;
	}
	if (!isQcncm)
	{
		//NDP16 signature
		pAggregatedPacket[i] = 0x49;
		pAggregatedPacket[i+1] = 0x50;
		pAggregatedPacket[i+2] = 0x53;
		pAggregatedPacket[i+3] = 0x00;
	}
	else
	{
		//QNDP signature
		pAggregatedPacket[i] = 0x44;
		pAggregatedPacket[i+1] = 0x4e;
		pAggregatedPacket[i+2] = 0x51;
		pAggregatedPacket[i+3] = 0x50;
	}
	i += 4;
	//NDP length
	nNdpLen = 4*nNumPackets + 8 + 2;
	while (nNdpLen % 4 != 0)
		nNdpLen += 2;
	pAggregatedPacket[i] = nNdpLen & 0x00FF;
	pAggregatedPacket[i+1] = nNdpLen >> 8;
	i += 2;
	//next NDP
	pAggregatedPacket[i] = 0x00;
	pAggregatedPacket[i+1] = 0x00;
	i += 2;
	for (int j = 0; j < nNumPackets; j++)
	{
		//datagram index
		pAggregatedPacket[i] = pDatagramIndexes[j] & 0x00FF;
		pAggregatedPacket[i+1] = pDatagramIndexes[j] >> 8;
		i += 2;
		//datagram length
		pAggregatedPacket[i] = pPacketsSizes[j] & 0x00FF;
		pAggregatedPacket[i+1] = pPacketsSizes[j] >> 8;
		i += 2;
	}
	//zeros in the end of NDP
	while (i < nAggregatedPacketSize)
	{
		pAggregatedPacket[i] = 0x00;
		i++;
	}
}

/////////////////////////////////////////////////////////////////////////////////

void MBIMAggregationScenarios::AggregatePacketsWithStreamId(
		Byte pAggregatedPacket[MAX_PACKET_SIZE]/*ouput*/,
		Byte pPackets[NUM_PACKETS][MAX_PACKET_SIZE],
		int pPacketsSizes[NUM_PACKETS], int nNumPackets, int nAggregatedPacketSize,
		Byte pPacketsStreamId[NUM_PACKETS])
{
	int i = 0;
	int n = 0;
	int pDatagramIndexes[NUM_PACKETS] = {0};
	int nNdpIndex[NUM_PACKETS] = {0};
	int nNdpLen = 0;
	Byte currStreamId = pPacketsStreamId[0];
	int nNdpFirstPacket[NUM_PACKETS] = {0};
	int nNdpAfterLastPacket[NUM_PACKETS] = {0};
	int nNumNDPs = 0;
	for (n = 0; n < nNumPackets; n++)
	{
		if (currStreamId != pPacketsStreamId[n])
		{
			nNdpAfterLastPacket[nNumNDPs] = n;
			nNumNDPs++;
			nNdpFirstPacket[nNumNDPs] = n;
			currStreamId = pPacketsStreamId[n];
		}
	}
	nNdpAfterLastPacket[nNumNDPs] = n;
	nNumNDPs++;
	//calculate NDP indexes
	nNdpIndex[0] += 12;  //adding the header
	for (int j = 0; j < nNumNDPs; j++)
	{
		for (n = nNdpFirstPacket[j]; n < nNdpAfterLastPacket[j]; n++)
			nNdpIndex[j] += pPacketsSizes[n];  //adding the packets
		while (0 != nNdpIndex[j] % 4)
			nNdpIndex[j]++;
		if (j < nNumNDPs - 1)
			nNdpIndex[j+1] += nNdpIndex[j] + 12 + 4*(nNdpAfterLastPacket[j] -
					nNdpFirstPacket[j]);  //adding the location after the current NDP to the next NDP
	}
	//start building the aggregated packet
	//NTH16 signature
	pAggregatedPacket[i] = 0x4e;
	pAggregatedPacket[i+1] = 0x43;
	pAggregatedPacket[i+2] = 0x4d;
	pAggregatedPacket[i+3] = 0x48;
	i += 4;
	//header length
	pAggregatedPacket[i] = 0x0c;
	pAggregatedPacket[i+1] = 0x00;
	i += 2;
	//sequence number
	pAggregatedPacket[i] = 0x00;
	pAggregatedPacket[i+1] = 0x00;
	i += 2;
	//aggregated packet length
	pAggregatedPacket[i] = nAggregatedPacketSize & 0x00FF;
	pAggregatedPacket[i+1] = nAggregatedPacketSize >> 8;;
	i += 2;
	//first NDP index
	pAggregatedPacket[i] = nNdpIndex[0] & 0x00FF;
	pAggregatedPacket[i+1] = nNdpIndex[0] >> 8;
	i += 2;
	for (n = 0; n < nNumNDPs; n++)
	{
		//packets
		for (int j = nNdpFirstPacket[n]; j < nNdpAfterLastPacket[n]; j++)
		{
			pDatagramIndexes[j] = i;
			for (int k = 0; k < pPacketsSizes[j]; k++)
			{
				pAggregatedPacket[i] = pPackets[j][k];
				i++;
			}
		}
		while (i < nNdpIndex[n])
		{
			pAggregatedPacket[i] = 0x00;
			i++;
		}
		//NDP signature
		pAggregatedPacket[i] = 0x49;
		pAggregatedPacket[i+1] = 0x50;
		pAggregatedPacket[i+2] = 0x53;
		pAggregatedPacket[i+3] = pPacketsStreamId[nNdpFirstPacket[n]];
		i += 4;
		//NDP length
		nNdpLen = 4*(nNdpAfterLastPacket[n] - nNdpFirstPacket[n]) + 8 + 2;
		while (nNdpLen % 4 != 0)
			nNdpLen += 2;
		pAggregatedPacket[i] = nNdpLen & 0x00FF;
		pAggregatedPacket[i+1] = nNdpLen >> 8;
		i += 2;
		//next NDP
		pAggregatedPacket[i] = nNdpIndex[n+1] & 0x00FF;
		pAggregatedPacket[i+1] = nNdpIndex[n+1] >> 8;
		i += 2;
		for (int j = nNdpFirstPacket[n]; j < nNdpAfterLastPacket[n]; j++)
		{
			//datagram index
			pAggregatedPacket[i] = pDatagramIndexes[j] & 0x00FF;
			pAggregatedPacket[i+1] = pDatagramIndexes[j] >> 8;
			i += 2;
			//datagram length
			pAggregatedPacket[i] = pPacketsSizes[j] & 0x00FF;
			pAggregatedPacket[i+1] = pPacketsSizes[j] >> 8;
			i += 2;
		}
		//zeros in the end of NDP
		while (i < nNdpIndex[n] + nNdpLen)
		{
			pAggregatedPacket[i] = 0x00;
			i++;
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::DeaggragateAndCompareOnePacket(
		Byte pAggregatedPacket[MAX_PACKET_SIZE],
		Byte pExpectedPacket[MAX_PACKET_SIZE], int nPacketsSize,
		int nAggregatedPacketSize, bool isQcncm)
{
	int nPacketNum = 0;
	int i = 0;
	int nNdpStart = 0;
	Byte pNdpIndex[2] = {0};
	Byte pNdpLen[2] = {0};
	if (0x4e != pAggregatedPacket[i] || 0x43 != pAggregatedPacket[i+1] ||
			0x4d != pAggregatedPacket[i+2]|| 0x48 != pAggregatedPacket[i+3])
	{
		LOG_MSG_DEBUG("Error: Wrong NTH16 signature: 0x%02x 0x%02x 0x%02x "
				"0x%02x(should be 0x4e, 0x43, 0x4d, 0x48)\n",
				pAggregatedPacket[i], pAggregatedPacket[i+1],
				pAggregatedPacket[i+2], pAggregatedPacket[i+3]);
		return false;
	}
	i += 4;
	if (0x0c != pAggregatedPacket[i] || 0x00 != pAggregatedPacket[i+1])
	{
		LOG_MSG_DEBUG("Error: Wrong header length: 0x%02x 0x%02x(should be 0x0c,"
				" 0x00)\n", pAggregatedPacket[i], pAggregatedPacket[i+1]);
		return false;
	}
	i += 4;  //ignoring sequence number
	if ((nAggregatedPacketSize & 0x00FF) != pAggregatedPacket[i] ||
			(nAggregatedPacketSize >> 8) != pAggregatedPacket[i+1])
	{
		LOG_MSG_DEBUG("Error: Wrong aggregated packet length: 0x%02x 0x%02x"
				"(should be 0x%02x, 0x%02x)\n",
				pAggregatedPacket[i], pAggregatedPacket[i+1],
				nAggregatedPacketSize & 0x00FF, nAggregatedPacketSize >> 8);
		return false;
	}
	i += 2;
	pNdpIndex[0] = pAggregatedPacket[i];  //least significant byte
	pNdpIndex[1] = pAggregatedPacket[i+1];  //most significant byte
	//reading the NDP
	while (0x00 != pNdpIndex[0] || 0x00 != pNdpIndex[1])
	{
		i = pNdpIndex[0] + 256*pNdpIndex[1];  //NDP should begin here
		nNdpStart = i;
		if (!isQcncm)
		{
			if (0x49 != pAggregatedPacket[i] || 0x50 != pAggregatedPacket[i+1] ||
					0x53 != pAggregatedPacket[i+2] || 0x00 != pAggregatedPacket[i+3])
			{
				LOG_MSG_DEBUG("Error: Wrong NDP16 signature: 0x%02x 0x%02x "
						"0x%02x 0x%02x(should be 0x49, 0x50, 0x53, 0x00)\n",
						pAggregatedPacket[i], pAggregatedPacket[i+1],
						pAggregatedPacket[i+2], pAggregatedPacket[i+3]);
				return false;
			}
		}
		else
		{
			if (0x44 != pAggregatedPacket[i] || 0x4e != pAggregatedPacket[i+1] ||
					0x51 != pAggregatedPacket[i+2] || 0x50 != pAggregatedPacket[i+3])
			{
				LOG_MSG_DEBUG("Error: Wrong QNDP signature: 0x%02x 0x%02x "
						"0x%02x 0x%02x(should be 0x44, 0x4e, 0x51, 0x50)\n",
						pAggregatedPacket[i], pAggregatedPacket[i+1],
						pAggregatedPacket[i+2], pAggregatedPacket[i+3]);
				return false;
			}
		}
		i += 4;
		pNdpLen[0] = pAggregatedPacket[i];  //least significant byte
		pNdpLen[1] = pAggregatedPacket[i+1];  //most significant byte
		if (0x00 != pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2] ||
				0x00 != pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] -1])
		{
			LOG_MSG_DEBUG("Error: Wrong end of NDP: 0x%02x 0x%02x(should be "
					"0x00, 0x00)\n",
					pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2],
					pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 1]);
			return false;
		}
		i += 2;
		pNdpIndex[0] = pAggregatedPacket[i];  //least significant byte
		pNdpIndex[1] = pAggregatedPacket[i+1];  //most significant byte
		i += 2;
		while (i <= nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2)
		{ //going over all the datagrams in this NDP
			Byte pDatagramIndex[2] = {0};
			Byte pDatagramLen[2] = {0};
			int packetIndex = 0;
			pDatagramIndex[0] = pAggregatedPacket[i];  //least significant byte
			pDatagramIndex[1] = pAggregatedPacket[i+1];  //most significant byte
			i += 2;
			if (0x00 == pDatagramIndex[0] && 0x00 == pDatagramIndex[1])
				break;  //zero padding after all datagrams
			if (nPacketNum > 1)
			{
				LOG_MSG_DEBUG("Error: wrong number of packets: %d(should be %d)\n",
						nPacketNum, 1);
				return false;
			}
			pDatagramLen[0] = pAggregatedPacket[i];  //least significant byte
			pDatagramLen[1] = pAggregatedPacket[i+1];  //most significant byte
			i += 2;
			packetIndex = pDatagramIndex[0] + 256*pDatagramIndex[1];
			if (pDatagramLen[0] + 256*pDatagramLen[1] != nPacketsSize)
			{
				LOG_MSG_DEBUG("Error: Wrong packet %d length: 0x%02x 0x%02x"
						"(should be %d)\n", nPacketNum, pDatagramLen[0],
						pDatagramLen[1], nPacketsSize);
				return false;
			}
			if (0 != memcmp(pExpectedPacket, &pAggregatedPacket[packetIndex],
					nPacketsSize))
			{
				LOG_MSG_DEBUG("Error: Comparison of packet %d failed!\n",
						nPacketNum);
				return false;
			}
			nPacketNum++;
		}
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////////

bool MBIMAggregationScenarios::DeaggragateAndComparePacketsWithStreamId(
		Byte pAggregatedPacket[MAX_PACKET_SIZE],
		Byte pExpectedPackets[][MAX_PACKET_SIZE], int pPacketsSizes[],
		int nNumPackets, int nAggregatedPacketSize,
		Byte pPacketsStreamId[NUM_PACKETS])
{
	int nPacketNum = 0;
	int i = 0;
	int nNdpStart = 0;
	Byte pNdpIndex[2] = {0};
	Byte pNdpLen[2] = {0};
	if (0x4e != pAggregatedPacket[i] || 0x43 != pAggregatedPacket[i+1] ||
			0x4d != pAggregatedPacket[i+2]|| 0x48 != pAggregatedPacket[i+3])
	{
		LOG_MSG_DEBUG("Error: Wrong NTH16 signature: 0x%02x 0x%02x 0x%02x "
				"0x%02x(should be 0x4e, 0x43, 0x4d, 0x48)\n",
				pAggregatedPacket[i], pAggregatedPacket[i+1],
				pAggregatedPacket[i+2], pAggregatedPacket[i+3]);
		return false;
	}
	i += 4;
	if (0x0c != pAggregatedPacket[i] || 0x00 != pAggregatedPacket[i+1])
	{
		LOG_MSG_DEBUG("Error: Wrong header length: 0x%02x 0x%02x(should be "
				"0x0c, 0x00)\n",pAggregatedPacket[i], pAggregatedPacket[i+1]);
		return false;
	}
	i += 4;  //ignoring sequence number
	if ((nAggregatedPacketSize & 0x00FF) != pAggregatedPacket[i] ||
			(nAggregatedPacketSize >> 8) != pAggregatedPacket[i+1])
	{
		LOG_MSG_DEBUG("Error: Wrong aggregated packet length: 0x%02x 0x%02x"
				"(should be 0x%02x, 0x%02x)\n", pAggregatedPacket[i],
				pAggregatedPacket[i+1], nAggregatedPacketSize & 0x00FF,
				nAggregatedPacketSize >> 8);
		return false;
	}
	i += 2;
	pNdpIndex[0] = pAggregatedPacket[i];  //least significant byte
	pNdpIndex[1] = pAggregatedPacket[i+1];  //most significant byte
	//reading the NDP
	while (0x00 != pNdpIndex[0] || 0x00 != pNdpIndex[1])
	{
		i = pNdpIndex[0] + 256*pNdpIndex[1];  //NDP should begin here
		nNdpStart = i;
		if (0x49 != pAggregatedPacket[i] || 0x50 != pAggregatedPacket[i+1] ||
				0x53 != pAggregatedPacket[i+2])
		{
			LOG_MSG_DEBUG("Error: Wrong NDP16 signature: 0x%02x 0x%02x 0x%02x"
					"(should be 0x49, 0x50, 0x53)\n", pAggregatedPacket[i],
					pAggregatedPacket[i+1], pAggregatedPacket[i+2]);
			return false;
		}
		if (pPacketsStreamId[nPacketNum] != pAggregatedPacket[i+3])
		{
			LOG_MSG_DEBUG("Error: Wrong NDP stream id: 0x%02x(should be 0x%02x)\n",
					pAggregatedPacket[i+3], pPacketsStreamId[nPacketNum]);
			return false;
		}
		i += 4;
		pNdpLen[0] = pAggregatedPacket[i];  //least significant byte
		pNdpLen[1] = pAggregatedPacket[i+1];  //most significant byte
		if (0x00 != pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2] ||
				0x00 != pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] -1])
		{
			LOG_MSG_DEBUG("Error: Wrong end of NDP: 0x%02x 0x%02x(should be 0x00, "
					"0x00)\n",
					pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2],
					pAggregatedPacket[nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 1]);
			return false;
		}
		i += 2;
		pNdpIndex[0] = pAggregatedPacket[i];  //least significant byte
		pNdpIndex[1] = pAggregatedPacket[i+1];  //most significant byte
		i += 2;
		while (i <= nNdpStart + pNdpLen[0] + 256*pNdpLen[1] - 2)
		{ //going over all the datagrams in this NDP
			Byte pDatagramIndex[2] = {0};
			Byte pDatagramLen[2] = {0};
			int packetIndex = 0;
			pDatagramIndex[0] = pAggregatedPacket[i];  //least significant byte
			pDatagramIndex[1] = pAggregatedPacket[i+1];  //most significant byte
			i += 2;
			if (0x00 == pDatagramIndex[0] && 0x00 == pDatagramIndex[1])
				break;  //zero padding after all datagrams
			if (nPacketNum >= nNumPackets)
			{
				LOG_MSG_DEBUG("Error: wrong number of packets: %d(should be %d)\n",
						nPacketNum, nNumPackets);
				return false;
			}
			pDatagramLen[0] = pAggregatedPacket[i];  //least significant byte
			pDatagramLen[1] = pAggregatedPacket[i+1];  //most significant byte
			i += 2;
			packetIndex = pDatagramIndex[0] + 256*pDatagramIndex[1];
			if (pDatagramLen[0] + 256*pDatagramLen[1] != (int)pPacketsSizes[nPacketNum])
			{
				LOG_MSG_DEBUG("Error: Wrong packet %d length: 0x%02x 0x%02x"
						"(should be %d)\n", nPacketNum, pDatagramLen[0],
						pDatagramLen[1], pPacketsSizes[nPacketNum]);
				return false;
			}
			if (0 != memcmp(pExpectedPackets[nPacketNum],
					&pAggregatedPacket[packetIndex], pPacketsSizes[nPacketNum]))
			{
				LOG_MSG_DEBUG("Error: Comparison of packet %d failed!\n",
						nPacketNum);
				return false;
			}
			nPacketNum++;
		}
	}

	return true;
}


/////////////////////////////////////////////////////////////////////////////////
//	            Configuration 9 tests - DMA mode for Elan1                     //
/////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class DmaModeMBIMAggregationTest: public MBIMAggregationTestFixture {
public:

	/////////////////////////////////////////////////////////////////////////////////

	DmaModeMBIMAggregationTest()
	{
		m_name = "DmaModeMBIMAggregationTest";
		m_description = "MBIM Aggregation test - sends 5 packets and receives 1 "
				"aggregated packet";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	bool Run()
	{
		return MBIMAggregationScenarios::MBIMAggregationTest(ELAN1,
				&m_UsbNoAggToIpaPipeAgg, &m_IpaToUsbPipeAggr, IPA_IP_v4, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class DmaModeMBIMDeaggregationOnePacketTest: public MBIMAggregationTestFixture {
public:

	/////////////////////////////////////////////////////////////////////////////////

	DmaModeMBIMDeaggregationOnePacketTest()
	{
		m_name = "DmaModeMBIMDeaggregationOnePacketTest";
		m_description = "MBIM Deaggregation one packet test - sends an aggregated packet "
				"made of 1 packet and receives 1 packet";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	bool Run()
	{
		return MBIMAggregationScenarios::MBIMDeaggregationOnePacketTest(ELAN1,
				&m_UsbDeaggToIpaPipeNoAgg, &m_IpaToUsbPipeNoAgg, IPA_IP_v4, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class DmaModeMBIMMultipleDeaggregationAndAggregationTest:
	public MBIMAggregationTestFixture {
public:

	/////////////////////////////////////////////////////////////////////////////////

	DmaModeMBIMMultipleDeaggregationAndAggregationTest()
	{
		m_name = "DmaModeMBIMMultipleDeaggregationAndAggregationTest";
		m_description = "MBIM Multiple Deaggregation and Aggregation test - sends 5 aggregated "
				"packets each one made of 1 packet and receives an aggregated packet made of the"
				"5 packets";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	bool Run()
	{
		return MBIMAggregationScenarios::MBIMMultipleDeaggregationAndAggregationTest(
				ELAN1, &m_UsbDeaggToIpaPipeAgg, &m_IpaToUsbPipeAggr, IPA_IP_v4, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class DmaModeMBIMAggregationLoopTest: public MBIMAggregationTestFixture {
public:

	/////////////////////////////////////////////////////////////////////////////////

	DmaModeMBIMAggregationLoopTest()
	{
		m_name = "DmaModeMBIMggregationLoopTest";
		m_description = "MBIM Aggregation Loop test - sends 5 packets and expects to"
				"receives 1 aggregated packet a few times";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	bool Run()
	{
		return MBIMAggregationScenarios::MBIMAggregationLoopTest(ELAN1,
				&m_UsbNoAggToIpaPipeAgg, &m_IpaToUsbPipeAggr, IPA_IP_v4, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class DmaModeMBIMAggregationTimeLimitTest: public MBIMAggregationTestFixture {
public:

	/////////////////////////////////////////////////////////////////////////////////

	DmaModeMBIMAggregationTimeLimitTest()
	{
		m_name = "DmaModeMBIMAggregationTimeLimitTest";
		m_description = "MBIM Aggregation time limit test - sends 1 small packet "
				"smaller than the byte limit and receives 1 aggregated packet";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	bool Run()
	{
		return MBIMAggregationScenarios::MBIMAggregationTimeLimitTest(ELAN1,
				&m_UsbNoAggToIpaPipeAggTime, &m_IpaToUsbPipeAggTime, IPA_IP_v4,
				false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class DmaModeMBIMAggregationByteLimitTest: public MBIMAggregationTestFixture {
public:

	/////////////////////////////////////////////////////////////////////////////////

	DmaModeMBIMAggregationByteLimitTest()
	{
		m_name = "DmaModeMBIMAggregationByteLimitTest";
		m_description = "MBIM Aggregation byte limit test - sends 2 packets that together "
				"are larger than the byte limit ";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	bool Run()
	{
		return MBIMAggregationScenarios::MBIMAggregationByteLimitTest(ELAN1,
				&m_UsbNoAggToIpaPipeAgg, &m_IpaToUsbPipeAggr, IPA_IP_v4, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class DmaModeMBIMAggregation2PipesTest: public MBIMAggregationTestFixture {
public:

	/////////////////////////////////////////////////////////////////////////////////

	DmaModeMBIMAggregation2PipesTest()
	{
		m_name = "DmaModeMBIMAggregation2PipesTest";
		m_description = "MBIM Aggregation 2 pipes test - sends 3 packets from one pipe"
				"and 2 aggregated packets made of 1 packet from another pipe and "
				"receives 1 aggregated packet made of all 5 packets";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	bool Run()
	{
		return MBIMAggregationScenarios::MBIMAggregation2PipesTest(ELAN1,
				&m_UsbDeaggToIpaPipeAgg, &m_UsbNoAggToIpaPipeAgg, &m_IpaToUsbPipeAggr,
				IPA_IP_v4, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class DmaModeMBIMAggregationTimeLimitLoopTest: public MBIMAggregationTestFixture {
public:

	/////////////////////////////////////////////////////////////////////////////////

	DmaModeMBIMAggregationTimeLimitLoopTest()
	{
		m_name = "DmaModeMBIMAggregationTimeLimitLoopTest";
		m_description = "MBIM Aggregation time limit loop test - sends 5 small packet "
				"smaller than the byte limit and receives 5 aggregated packet";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	bool Run()
	{
		return MBIMAggregationScenarios::MBIMAggregationTimeLimitLoopTest(ELAN1,
				&m_UsbNoAggToIpaPipeAggTime, &m_IpaToUsbPipeAggTime, IPA_IP_v4,
				false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
//			     Configuration 10 tests - DMA mode for Elan1                   //
/////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class DmaModeMBIMAggregation0LimitsTest: public MBIMAggregationTestFixtureConf10 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	DmaModeMBIMAggregation0LimitsTest()
	{
		m_name = "DmaModeMBIMAggregation0LimitsTest";
		m_description = "MBIM Aggregation 0 limits test - sends 5 packets and expects"
				"to get each packet back aggregated (both size and time limits are 0)";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	bool Run()
	{
		return MBIMAggregationScenarios::MBIMAggregation0LimitsTest(ELAN1,
				&m_UsbToIpaPipeAggZeroLimits, &m_IpaToUsbPipeAggZeroLimits,
				IPA_IP_v4, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
//				    Configuration 11 tests - Elan2 and later                   //
/////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class MBIMAggregationTest: public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMAggregationTest()
	{
		m_name = "MBIMAggregationTest";
		m_description = "MBIM Aggregation test - sends 5 packets and receives 1 "
				"aggregated packet";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationTest(ELAN2, &m_UsbToIpaPipe,
				&m_IpaToUsbPipeAgg, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class MBIMDeaggregationTest: public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMDeaggregationTest()
	{
		m_name = "MBIMDeaggregationTest";
		m_description = "MBIM Deaggregation test - sends an aggregated packet made from"
				"5 packets and receives 5 packets";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRulesDeaggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMDeaggregationTest(ELAN2,
				&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipe, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

class MBIMDeaggregationOnePacketTest: public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMDeaggregationOnePacketTest()
	{
		m_name = "MBIMDeaggregationOnePacketTest";
		m_description = "MBIM Deaggregation one packet test - sends an aggregated packet made"
				"of 1 packet and receives 1 packet";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRulesDeaggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMDeaggregationOnePacketTest(ELAN2,
				&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipe, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////


class MBIMDeaggregationAndAggregationTest: public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMDeaggregationAndAggregationTest()
	{
		m_name = "MBIMDeaggregationAndAggregationTest";
		m_description = "MBIM Deaggregation and Aggregation test - sends an aggregated "
				"packet made from 5 packets and receives the same aggregated packet";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMDeaggregationAndAggregationTest(ELAN2,
				&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipeAgg, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////

};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////


class MBIMMultipleDeaggregationAndAggregationTest:
	public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMMultipleDeaggregationAndAggregationTest()
	{
		m_name = "MBIMMultipleDeaggregationAndAggregationTest";
		m_description = "MBIM Multiple Deaggregation and Aggregation test - sends 5 aggregated "
				"packets each one made of 1 packet and receives an aggregated packet made of the"
				"5 packets";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMMultipleDeaggregationAndAggregationTest(
				ELAN2, &m_UsbToIpaPipeDeagg, &m_IpaToUsbPipeAgg, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////

};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class MBIMAggregationLoopTest: public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMAggregationLoopTest()
	{
		m_name = "MBIMggregationLoopTest";
		m_description = "MBIM Aggregation Loop test - sends 5 packets and expects to"
				"receives 1 aggregated packet a few times";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationLoopTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class MBIMAggregationTimeLimitTest: public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMAggregationTimeLimitTest()
	{
		m_name = "MBIMAggregationTimeLimitTest";
		m_description = "MBIM Aggregation time limit test - sends 1 small packet "
				"smaller than the byte limit and receives 1 aggregated packet";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregationTime();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationTimeLimitTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAggTime, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class MBIMAggregationByteLimitTest: public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMAggregationByteLimitTest()
	{
		m_name = "MBIMAggregationByteLimitTest";
		m_description = "MBIM Aggregation byte limit test - sends 2 packets that together "
				"are larger than the byte limit ";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationByteLimitTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class MBIMDeaggregationMultipleNDPTest: public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMDeaggregationMultipleNDPTest()
	{
		m_name = "MBIMDeaggregationMultipleNDPTest";
		m_description = "MBIM Deaggregation multiple NDP test - sends an aggregated"
				"packet made from 5 packets and 2 NDPs and receives 5 packets";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRulesDeaggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMDeaggregationMultipleNDPTest(ELAN2,
				&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipe, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class MBIMAggregation2PipesTest: public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMAggregation2PipesTest()
	{
		m_name = "MBIMAggregation2PipesTest";
		m_description = "MBIM Aggregation 2 pipes test - sends 3 packets from one pipe"
				"and an aggregated packet made of 2 packets from another pipe and "
				"receives 1 aggregated packet made of all 5 packets";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregation2PipesTest(ELAN2,
				&m_UsbToIpaPipeDeagg, &m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class MBIMAggregationTimeLimitLoopTest: public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMAggregationTimeLimitLoopTest()
	{
		m_name = "MBIMAggregationTimeLimitLoopTest";
		m_description = "MBIM Aggregation time limit loop test - sends 5 small packet "
				"smaller than the byte limit and receives 5 aggregated packet";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregationTime();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationTimeLimitLoopTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAggTime, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class MBIMAggregationMultiplePacketsTest: public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMAggregationMultiplePacketsTest()
	{
		m_name = "MBIMAggregationMultiplePacketsTest";
		m_description = "MBIM Aggregation multiple packets test - sends 9 packets "
				"with same stream ID and receives 1 aggregated packet with 2 NDPs";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationMultiplePacketsTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class MBIMAggregation0LimitsTest: public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMAggregation0LimitsTest()
	{
		m_name = "MBIMAggregation0LimitsTest";
		m_description = "MBIM Aggregation 0 limits test - sends 5 packets and expects"
				"to get each packet back aggregated (both size and time limits are 0)";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation0Limits();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregation0LimitsTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg0Limits, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class MBIMAggregationDifferentStreamIdsTest:
	public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMAggregationDifferentStreamIdsTest()
	{
		m_name = "MBIMAggregationDifferentStreamIdsTest";
		m_description = "MBIM Aggregation different stream IDs test - sends 5 packets"
				"with different stream IDs and receives 1 aggregated packet made of 5"
				"NDPs";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		m_eIP = IPA_IP_v4;
		const char aBypass[NUM_PACKETS][20] = {{"Bypass1"}, {"Bypass2"}, {"Bypass3"},
				{"Bypass4"}, {"Bypass5"}};
		uint32_t nTableHdl[NUM_PACKETS];
		bool bRetVal = true;
		IPAFilteringTable cFilterTable0;
		struct ipa_flt_rule_add sFilterRuleEntry;
		struct ipa_ioc_get_hdr sGetHeader[NUM_PACKETS];
		uint8_t aHeadertoAdd[NUM_PACKETS];

		for (int i = 0; i < NUM_PACKETS; i++)
			aHeadertoAdd[i] = (uint8_t)i;

		LOG_MSG_STACK("Entering Function");
		memset(&sFilterRuleEntry, 0, sizeof(sFilterRuleEntry));
		for (int i = 0; i < NUM_PACKETS; i++)
			memset(&sGetHeader[i], 0, sizeof(sGetHeader[i]));
		// Create Header:
		// Allocate Memory, populate it, and add in to the Header Insertion.
		struct ipa_ioc_add_hdr * pHeaderDescriptor = NULL;
		pHeaderDescriptor = (struct ipa_ioc_add_hdr *) calloc(1,
				sizeof(struct ipa_ioc_add_hdr)
						+ NUM_PACKETS * sizeof(struct ipa_hdr_add));
		if (!pHeaderDescriptor)
		{
			LOG_MSG_ERROR("calloc failed to allocate pHeaderDescriptor");
			bRetVal = false;
			goto bail;
		}

		pHeaderDescriptor->commit = true;
		pHeaderDescriptor->num_hdrs = NUM_PACKETS;
		// Adding Header No1.
		strlcpy(pHeaderDescriptor->hdr[0].name, "StreamId0", sizeof(pHeaderDescriptor->hdr[0].name)); // Header's Name
		memcpy(pHeaderDescriptor->hdr[0].hdr, (void*)&aHeadertoAdd[0],
				sizeof(uint8_t)); //Header's Data
		pHeaderDescriptor->hdr[0].hdr_len    = sizeof(uint8_t);
		pHeaderDescriptor->hdr[0].hdr_hdl    = -1; //Return Value
		pHeaderDescriptor->hdr[0].is_partial = false;
		pHeaderDescriptor->hdr[0].status     = -1; // Return Parameter

		// Adding Header No2.
		strlcpy(pHeaderDescriptor->hdr[1].name, "StreamId1", sizeof(pHeaderDescriptor->hdr[1].name)); // Header's Name
		memcpy(pHeaderDescriptor->hdr[1].hdr, (void*)&aHeadertoAdd[1],
				sizeof(uint8_t)); //Header's Data
		pHeaderDescriptor->hdr[1].hdr_len    = sizeof(uint8_t);
		pHeaderDescriptor->hdr[1].hdr_hdl    = -1; //Return Value
		pHeaderDescriptor->hdr[1].is_partial = false;
		pHeaderDescriptor->hdr[1].status     = -1; // Return Parameter

		// Adding Header No3.
		strlcpy(pHeaderDescriptor->hdr[2].name, "StreamId2", sizeof(pHeaderDescriptor->hdr[2].name)); // Header's Name
		memcpy(pHeaderDescriptor->hdr[2].hdr, (void*)&aHeadertoAdd[2],
				sizeof(uint8_t)); //Header's Data
		pHeaderDescriptor->hdr[2].hdr_len    = sizeof(uint8_t);
		pHeaderDescriptor->hdr[2].hdr_hdl    = -1; //Return Value
		pHeaderDescriptor->hdr[2].is_partial = false;
		pHeaderDescriptor->hdr[2].status     = -1; // Return Parameter

		// Adding Header No4.
		strlcpy(pHeaderDescriptor->hdr[3].name, "StreamId3", sizeof(pHeaderDescriptor->hdr[3].name)); // Header's Name
		memcpy(pHeaderDescriptor->hdr[3].hdr, (void*)&aHeadertoAdd[3],
				sizeof(uint8_t)); //Header's Data
		pHeaderDescriptor->hdr[3].hdr_len    = sizeof(uint8_t);
		pHeaderDescriptor->hdr[3].hdr_hdl    = -1; //Return Value
		pHeaderDescriptor->hdr[3].is_partial = false;
		pHeaderDescriptor->hdr[3].status     = -1; // Return Parameter

		// Adding Header No5.
		strlcpy(pHeaderDescriptor->hdr[4].name, "StreamId4", sizeof(pHeaderDescriptor->hdr[4].name)); // Header's Name
		memcpy(pHeaderDescriptor->hdr[4].hdr, (void*)&aHeadertoAdd[4],
				sizeof(uint8_t)); //Header's Data
		pHeaderDescriptor->hdr[4].hdr_len    = sizeof(uint8_t);
		pHeaderDescriptor->hdr[4].hdr_hdl    = -1; //Return Value
		pHeaderDescriptor->hdr[4].is_partial = false;
		pHeaderDescriptor->hdr[4].status     = -1; // Return Parameter

		for (int i = 0; i < NUM_PACKETS; i++)
			strlcpy(sGetHeader[i].name, pHeaderDescriptor->hdr[i].name, sizeof(sGetHeader[i].name));


		if (!m_HeaderInsertion.AddHeader(pHeaderDescriptor))
		{
			LOG_MSG_ERROR("m_HeaderInsertion.AddHeader(pHeaderDescriptor) Failed.");
			bRetVal = false;
			goto bail;
		}
		for (int i = 0; i < NUM_PACKETS; i++)
		{
			if (!m_HeaderInsertion.GetHeaderHandle(&sGetHeader[i]))
			{
				LOG_MSG_ERROR(" Failed");
				bRetVal = false;
				goto bail;
			}
			LOG_MSG_DEBUG("Received Header %d Handle = 0x%x", i, sGetHeader[i].hdl);
		}

		for (int i = 0; i < NUM_PACKETS; i++)
		{
			if (!CreateBypassRoutingTable(&m_Routing, m_eIP, aBypass[i],
					IPA_CLIENT_TEST2_CONS, sGetHeader[i].hdl,&nTableHdl[i]))
			{
				LOG_MSG_ERROR("CreateBypassRoutingTable Failed\n");
				bRetVal = false;
				goto bail;
			}
		}

		LOG_MSG_INFO("Creation of 5 bypass routing tables completed successfully");

		// Creating Filtering Rules
		cFilterTable0.Init(m_eIP,IPA_CLIENT_TEST_PROD, false, NUM_PACKETS);
		LOG_MSG_INFO("Creation of filtering table completed successfully");

		// Configuring Filtering Rule No.1
		cFilterTable0.GeneratePresetRule(1,sFilterRuleEntry);
		sFilterRuleEntry.at_rear = true;
		sFilterRuleEntry.flt_rule_hdl=-1; // return Value
		sFilterRuleEntry.status = -1; // return value
		sFilterRuleEntry.rule.action=IPA_PASS_TO_ROUTING;
		sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[0]; //put here the handle corresponding to Routing Rule 1
		sFilterRuleEntry.rule.attrib.attrib_mask = IPA_FLT_DST_ADDR; // Destination IP Based Filtering
		sFilterRuleEntry.rule.attrib.u.v4.dst_addr_mask = 0xFF0000FF; // Mask
		sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0x7F000001; // Filter DST_IP == 127.0.0.1.
		if (
				((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
				!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
				)
		{
			LOG_MSG_ERROR ("Adding Rule (0) to Filtering block Failed.");
			bRetVal = false;
			goto bail;
		}
		else
		{
			LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
					cFilterTable0.ReadRuleFromTable(0)->flt_rule_hdl,
					cFilterTable0.ReadRuleFromTable(0)->status);
		}

		// Configuring Filtering Rule No.2
		sFilterRuleEntry.flt_rule_hdl=-1; // return Value
		sFilterRuleEntry.status = -1; // return Value
		sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[1]; //put here the handle corresponding to Routing Rule 2
		sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0xC0A80101; // Filter DST_IP == 192.168.1.1.
		if (
				((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
				!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
			)
		{
			LOG_MSG_ERROR ("Adding Rule(1) to Filtering block Failed.");
			bRetVal = false;
			goto bail;
		}
		else
		{
			LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
					cFilterTable0.ReadRuleFromTable(1)->flt_rule_hdl,
					cFilterTable0.ReadRuleFromTable(1)->status);
		}

		// Configuring Filtering Rule No.3
		sFilterRuleEntry.flt_rule_hdl=-1; // return Value
		sFilterRuleEntry.status = -1; // return value
		sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[2]; //put here the handle corresponding to Routing Rule 2
		sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0xC0A80102; // Filter DST_IP == 192.168.1.2.

		if (
				((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
				!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
			)
		{
			LOG_MSG_ERROR ("Adding Rule(2) to Filtering block Failed.");
			bRetVal = false;
			goto bail;
		}
		else
		{
			LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
					cFilterTable0.ReadRuleFromTable(2)->flt_rule_hdl,
					cFilterTable0.ReadRuleFromTable(2)->status);
		}

		// Configuring Filtering Rule No.4
		sFilterRuleEntry.flt_rule_hdl=-1; // return Value
		sFilterRuleEntry.status = -1; // return value
		sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[3]; //put here the handle corresponding to Routing Rule 2
		sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0xC0A80103; // Filter DST_IP == 192.168.1.3.

		if (
				((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
				!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
			)
		{
			LOG_MSG_ERROR ("Adding Rule(3) to Filtering block Failed.");
			bRetVal = false;
			goto bail;
		}
		else
		{
			LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
					cFilterTable0.ReadRuleFromTable(2)->flt_rule_hdl,
					cFilterTable0.ReadRuleFromTable(2)->status);
		}

		// Configuring Filtering Rule No.5
		sFilterRuleEntry.flt_rule_hdl=-1; // return Value
		sFilterRuleEntry.status = -1; // return value
		sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[4]; //put here the handle corresponding to Routing Rule 2
		sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0xC0A80104; // Filter DST_IP == 192.168.1.4.

		if (
				((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
				!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
			)
		{
			LOG_MSG_ERROR ("Adding Rule(4) to Filtering block Failed.");
			bRetVal = false;
			goto bail;
		}
		else
		{
			LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
					cFilterTable0.ReadRuleFromTable(2)->flt_rule_hdl,
					cFilterTable0.ReadRuleFromTable(2)->status);
		}

	bail:
		Free(pHeaderDescriptor);
		LOG_MSG_STACK(
				"Leaving Function (Returning %s)", bRetVal?"True":"False");
		return bRetVal;
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationDifferentStreamIdsTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class MBIMAggregationNoInterleavingStreamIdsTest:
	public MBIMAggregationTestFixtureConf11 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	MBIMAggregationNoInterleavingStreamIdsTest()
	{
		m_name = "MBIMAggregationNoInterleavingStreamIdsTest";
		m_description = "MBIM Aggregation no interleaving stream IDs test - sends 5 packets"
				"with interleaving stream IDs (0, 1, 0, 1, 0) and receives 1 aggregated "
				"packet made of 5 NDPs";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		m_eIP = IPA_IP_v4;
		const char aBypass[2][20] = {{"Bypass1"}, {"Bypass2"}};
		uint32_t nTableHdl[2];
		bool bRetVal = true;
		IPAFilteringTable cFilterTable0;
		struct ipa_flt_rule_add sFilterRuleEntry;
		struct ipa_ioc_get_hdr sGetHeader[2];
		uint8_t aHeadertoAdd[2];

		for (int i = 0; i < 2; i++)
			aHeadertoAdd[i] = (uint8_t)i;

		LOG_MSG_STACK("Entering Function");
		memset(&sFilterRuleEntry, 0, sizeof(sFilterRuleEntry));
		for (int i = 0; i < 2; i++)
			memset(&sGetHeader[i], 0, sizeof(sGetHeader[i]));
		// Create Header:
		// Allocate Memory, populate it, and add in to the Header Insertion.
		struct ipa_ioc_add_hdr * pHeaderDescriptor = NULL;
		pHeaderDescriptor = (struct ipa_ioc_add_hdr *) calloc(1,
				sizeof(struct ipa_ioc_add_hdr)
						+ 2 * sizeof(struct ipa_hdr_add));
		if (!pHeaderDescriptor)
		{
			LOG_MSG_ERROR("calloc failed to allocate pHeaderDescriptor");
			bRetVal = false;
			goto bail;
		}

		pHeaderDescriptor->commit = true;
		pHeaderDescriptor->num_hdrs = 2;
		// Adding Header No1.
		strlcpy(pHeaderDescriptor->hdr[0].name, "StreamId0", sizeof(pHeaderDescriptor->hdr[0].name)); // Header's Name
		memcpy(pHeaderDescriptor->hdr[0].hdr, (void*)&aHeadertoAdd[0],
				sizeof(uint8_t)); //Header's Data
		pHeaderDescriptor->hdr[0].hdr_len    = sizeof(uint8_t);
		pHeaderDescriptor->hdr[0].hdr_hdl    = -1; //Return Value
		pHeaderDescriptor->hdr[0].is_partial = false;
		pHeaderDescriptor->hdr[0].status     = -1; // Return Parameter

		// Adding Header No2.
		strlcpy(pHeaderDescriptor->hdr[1].name, "StreamId1", sizeof(pHeaderDescriptor->hdr[1].name)); // Header's Name
		memcpy(pHeaderDescriptor->hdr[1].hdr, (void*)&aHeadertoAdd[1],
				sizeof(uint8_t)); //Header's Data
		pHeaderDescriptor->hdr[1].hdr_len    = sizeof(uint8_t);
		pHeaderDescriptor->hdr[1].hdr_hdl    = -1; //Return Value
		pHeaderDescriptor->hdr[1].is_partial = false;
		pHeaderDescriptor->hdr[1].status     = -1; // Return Parameter

		for (int i = 0; i < 2; i++)
			strlcpy(sGetHeader[i].name, pHeaderDescriptor->hdr[i].name, sizeof(sGetHeader[i].name));


		if (!m_HeaderInsertion.AddHeader(pHeaderDescriptor))
		{
			LOG_MSG_ERROR("m_HeaderInsertion.AddHeader(pHeaderDescriptor) Failed.");
			bRetVal = false;
			goto bail;
		}
		for (int i = 0; i < 2; i++)
		{
			if (!m_HeaderInsertion.GetHeaderHandle(&sGetHeader[i]))
			{
				LOG_MSG_ERROR(" Failed");
				bRetVal = false;
				goto bail;
			}
			LOG_MSG_DEBUG("Received Header %d Handle = 0x%x", i, sGetHeader[i].hdl);
		}

		for (int i = 0; i < 2; i++)
		{
			if (!CreateBypassRoutingTable(&m_Routing, m_eIP, aBypass[i],
					IPA_CLIENT_TEST2_CONS, sGetHeader[i].hdl,&nTableHdl[i]))
			{
				LOG_MSG_ERROR("CreateBypassRoutingTable Failed\n");
				bRetVal = false;
				goto bail;
			}
		}

		LOG_MSG_INFO("Creation of 2 bypass routing tables completed successfully");

		// Creating Filtering Rules
		cFilterTable0.Init(m_eIP,IPA_CLIENT_TEST_PROD, false, 2);
		LOG_MSG_INFO("Creation of filtering table completed successfully");

		// Configuring Filtering Rule No.1
		cFilterTable0.GeneratePresetRule(1,sFilterRuleEntry);
		sFilterRuleEntry.at_rear = true;
		sFilterRuleEntry.flt_rule_hdl=-1; // return Value
		sFilterRuleEntry.status = -1; // return value
		sFilterRuleEntry.rule.action=IPA_PASS_TO_ROUTING;
		sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[0]; //put here the handle corresponding to Routing Rule 1
		sFilterRuleEntry.rule.attrib.attrib_mask = IPA_FLT_DST_ADDR; // Destination IP Based Filtering
		sFilterRuleEntry.rule.attrib.u.v4.dst_addr_mask = 0xFF0000FF; // Mask
		sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0x7F000001; // Filter DST_IP == 127.0.0.1.
		if (
				((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
				!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
				)
		{
			LOG_MSG_ERROR ("Adding Rule (0) to Filtering block Failed.");
			bRetVal = false;
			goto bail;
		}
		else
		{
			LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
					cFilterTable0.ReadRuleFromTable(0)->flt_rule_hdl,
					cFilterTable0.ReadRuleFromTable(0)->status);
		}

		// Configuring Filtering Rule No.2
		sFilterRuleEntry.flt_rule_hdl=-1; // return Value
		sFilterRuleEntry.status = -1; // return Value
		sFilterRuleEntry.rule.rt_tbl_hdl=nTableHdl[1]; //put here the handle corresponding to Routing Rule 2
		sFilterRuleEntry.rule.attrib.u.v4.dst_addr = 0xC0A80101; // Filter DST_IP == 192.168.1.1.
		if (
				((uint8_t)-1 == cFilterTable0.AddRuleToTable(sFilterRuleEntry)) ||
				!m_Filtering.AddFilteringRule(cFilterTable0.GetFilteringTable())
			)
		{
			LOG_MSG_ERROR ("Adding Rule(1) to Filtering block Failed.");
			bRetVal = false;
			goto bail;
		}
		else
		{
			LOG_MSG_DEBUG("flt rule hdl0=0x%x, status=0x%x\n",
					cFilterTable0.ReadRuleFromTable(1)->flt_rule_hdl,
					cFilterTable0.ReadRuleFromTable(1)->status);
		}

	bail:
		Free(pHeaderDescriptor);
		LOG_MSG_STACK(
				"Leaving Function (Returning %s)", bRetVal?"True":"False");
		return bRetVal;
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationNoInterleavingStreamIdsTest(
				ELAN2, &m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP, false);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
//		      Configuration 12 tests - Qcncm for Elan2 and later               //
/////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class QcncmMBIMAggregationTest: public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	QcncmMBIMAggregationTest()
	{
		m_name = "QcncmMBIMAggregationTest";
		m_description = "MBIM Aggregation test - sends 5 packets and receives 1 "
				"aggregated packet";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationTest(ELAN2, &m_UsbToIpaPipe,
				&m_IpaToUsbPipeAgg, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class  QcncmMBIMDeaggregationTest: public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	 QcncmMBIMDeaggregationTest()
	 {
		m_name = "QcncmMBIMDeaggregationTest";
		m_description = "MBIM Deaggregation test - sends an aggregated packet made from"
				"5 packets and receives 5 packets";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRulesDeaggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMDeaggregationTest(ELAN2,
				&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipe, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

class QcncmMBIMDeaggregationOnePacketTest: public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	QcncmMBIMDeaggregationOnePacketTest()
	{
		m_name = "QcncmMBIMDeaggregationOnePacketTest";
		m_description = "MBIM Deaggregation one packet test - sends an aggregated packet made"
				"of 1 packet and receives 1 packet";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRulesDeaggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMDeaggregationOnePacketTest(ELAN2,
				&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipe, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////


class QcncmMBIMDeaggregationAndAggregationTest:
	public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	QcncmMBIMDeaggregationAndAggregationTest()
	{
		m_name = "QcncmMBIMDeaggregationAndAggregationTest";
		m_description = "MBIM Deaggregation and Aggregation test - sends an aggregated "
				"packet made from 5 packets and receives the same aggregated packet";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMDeaggregationAndAggregationTest(ELAN2,
				&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipeAgg, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////

};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////


class QcncmMBIMMultipleDeaggregationAndAggregationTest:
	public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	QcncmMBIMMultipleDeaggregationAndAggregationTest()
	{
		m_name = "QcncmMBIMMultipleDeaggregationAndAggregationTest";
		m_description = "MBIM Multiple Deaggregation and Aggregation test - sends 5 aggregated "
				"packets each one made of 1 packet and receives an aggregated packet made of the"
				"5 packets";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMMultipleDeaggregationAndAggregationTest(
				ELAN2, &m_UsbToIpaPipeDeagg, &m_IpaToUsbPipeAgg, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////

};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class QcncmMBIMAggregationLoopTest: public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	QcncmMBIMAggregationLoopTest()
	{
		m_name = "QcncmMBIMAggregationLoopTest";
		m_description = "MBIM Aggregation Loop test - sends 5 packets and expects to"
				"receives 1 aggregated packet a few times";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationLoopTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class QcncmMBIMDeaggregationMultipleNDPTest:
	public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	QcncmMBIMDeaggregationMultipleNDPTest()
	{
		m_name = "QcncmMBIMDeaggregationMultipleNDPTest";
		m_description = "MBIM Deaggregation multiple NDP test - sends an aggregated"
				"packet made from 5 packets and 2 NDPs and receives 5 packets";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRulesDeaggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMDeaggregationMultipleNDPTest(ELAN2,
				&m_UsbToIpaPipeDeagg, &m_IpaToUsbPipe, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class QcncmMBIMAggregationMultiplePacketsTest:
	public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	QcncmMBIMAggregationMultiplePacketsTest()
	{
		m_name = "QcncmMBIMAggregationMultiplePacketsTest";
		m_description = "MBIM Aggregation multiple packets test - sends 9 packets "
				"with same stream ID and receives 1 aggregated packet with 2 NDPs";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationMultiplePacketsTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class QcncmMBIMAggregation2PipesTest: public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	QcncmMBIMAggregation2PipesTest()
	{
		m_name = "QcncmMBIMAggregation2PipesTest";
		m_description = "MBIM Aggregation 2 pipes test - sends 3 packets from one pipe"
				"and an aggregated packet made of 2 packets from another pipe and "
				"receives 1 aggregated packet made of all 5 packets";
		m_minIPAHwType = IPA_HW_v1_0;
		m_maxIPAHwType = IPA_HW_v2_1;
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregation2PipesTest(ELAN2,
				&m_UsbToIpaPipeDeagg, &m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class QcncmMBIMAggregationTimeLimitTest: public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	QcncmMBIMAggregationTimeLimitTest()
	{
		m_name = "QcncmMBIMAggregationTimeLimitTest";
		m_description = "MBIM Aggregation time limit test - sends 1 small packet "
				"smaller than the byte limit and receives 1 aggregated packet";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregationTime();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationTimeLimitTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAggTime, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class QcncmMBIMAggregationByteLimitTest: public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	QcncmMBIMAggregationByteLimitTest()
	{
		m_name = "QcncmMBIMAggregationByteLimitTest";
		m_description = "MBIM Aggregation byte limit test - sends 2 packets that together "
				"are larger than the byte limit ";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationByteLimitTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class QcncmMBIMAggregationTimeLimitLoopTest:
	public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	QcncmMBIMAggregationTimeLimitLoopTest()
	{
		m_name = "QcncmMBIMAggregationTimeLimitLoopTest";
		m_description = "MBIM Aggregation time limit loop test - sends 5 small packet "
				"smaller than the byte limit and receives 5 aggregated packet";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregationTime();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregationTimeLimitLoopTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAggTime, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

class QcncmMBIMAggregation0LimitsTest: public MBIMAggregationTestFixtureConf12 {
public:

	/////////////////////////////////////////////////////////////////////////////////

	QcncmMBIMAggregation0LimitsTest()
	{
		m_name = "QcncmMBIMAggregation0LimitsTest";
		m_description = "MBIM Aggregation 0 limits test - sends 5 packets and expects"
				"to get each packet back aggregated (both size and time limits are 0)";
	}

	/////////////////////////////////////////////////////////////////////////////////

	virtual bool AddRules()
	{
		return AddRules1HeaderAggregation0Limits();
	} // AddRules()

	/////////////////////////////////////////////////////////////////////////////////

	bool TestLogic()
	{
		return MBIMAggregationScenarios::MBIMAggregation0LimitsTest(ELAN2,
				&m_UsbToIpaPipe, &m_IpaToUsbPipeAgg0Limits, m_eIP, true);
	}

	/////////////////////////////////////////////////////////////////////////////////
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

//Those tests should be run with configuration number 9 for Elan1
//Please look at the Fixture for more configurations update.
static DmaModeMBIMAggregationTest dmaModeMBIMAggregationTest;
static DmaModeMBIMDeaggregationOnePacketTest dmaModeMBIMDeaggregationOnePacketTest;
static DmaModeMBIMMultipleDeaggregationAndAggregationTest
			dmaModeMBIMMultipleDeaggregationAndAggregationTest;
static DmaModeMBIMAggregationLoopTest dmaModeMBIMAggregationLoopTest;
static DmaModeMBIMAggregationTimeLimitTest dmaModeMBIMAggregationTimeLimitTest;
static DmaModeMBIMAggregation2PipesTest dmaModeMBIMAggregation2PipesTest;
static DmaModeMBIMAggregationByteLimitTest dmaModeMBIMAggregationByteLimitTest;
static DmaModeMBIMAggregationTimeLimitLoopTest
			dmaModeMBIMAggregationTimeLimitLoopTest;

//This tests should be run with configuration number 10 for Elan1
static DmaModeMBIMAggregation0LimitsTest dmaModeMBIMAggregation0LimitsTest;

//Those tests should be run with configuration number 11 for Elan2 and later
static MBIMAggregationTest mbimAggregationTest;
static MBIMDeaggregationTest mbimDeaggregationTest;
static MBIMDeaggregationOnePacketTest mbimDeaggregationOnePacketTest;
static MBIMDeaggregationAndAggregationTest mbimDeaggregationAndAggregationTest;
static MBIMMultipleDeaggregationAndAggregationTest
		mbimMultipleDeaggregationAndAggregationTest;
static MBIMAggregationLoopTest mbimAggregationLoopTest;
static MBIMDeaggregationMultipleNDPTest mbimDeaggregationMultipleNDPTest;
static MBIMAggregationMultiplePacketsTest mbimAggregationMultiplePacketsTest;
static MBIMAggregation2PipesTest mbimAggregation2PipesTest;
static MBIMAggregationNoInterleavingStreamIdsTest
		mbimAggregationNoInterleavingStreamIdsTest;
static MBIMAggregationDifferentStreamIdsTest mbimAggregationDifferentStreamIdsTest;
static MBIMAggregationTimeLimitTest mbimAggregationTimeLimitTest;
static MBIMAggregationByteLimitTest mbimAggregationByteLimitTest;
static MBIMAggregationTimeLimitLoopTest mbimAggregationTimeLimitLoopTest;
static MBIMAggregation0LimitsTest mbimAggregation0LimitsTest;

//Those tests should be run with configuration number 12 for qcncm on Elan2 and later
static QcncmMBIMAggregationTest qcncmMBIMAggregationTest;
static QcncmMBIMDeaggregationTest qcncmMBIMDeaggregationTest;
static QcncmMBIMDeaggregationOnePacketTest qcncmMBIMDeaggregationOnePacketTest;
static QcncmMBIMDeaggregationAndAggregationTest
		qcncmMBIMDeaggregationAndAggregationTest;
static QcncmMBIMMultipleDeaggregationAndAggregationTest
		qcncmMBIMMultipleDeaggregationAndAggregationTest;
static QcncmMBIMAggregationLoopTest qcncmMBIMAggregationLoopTest;
static QcncmMBIMDeaggregationMultipleNDPTest qcncmMBIMDeaggregationMultipleNDPTest;
static QcncmMBIMAggregationMultiplePacketsTest
		qcncmMBIMAggregationMultiplePacketsTest;
static QcncmMBIMAggregation2PipesTest qcncmMBIMAggregation2PipesTest;
static QcncmMBIMAggregationTimeLimitTest qcncmMBIMAggregationTimeLimitTest;
static QcncmMBIMAggregationByteLimitTest qcncmMBIMAggregationByteLimitTest;
static QcncmMBIMAggregationTimeLimitLoopTest qcncmMBIMAggregationTimeLimitLoopTest;
static QcncmMBIMAggregation0LimitsTest qcncmMBIMAggregation0LimitsTest;

/////////////////////////////////////////////////////////////////////////////////
//                                  EOF                                      ////
/////////////////////////////////////////////////////////////////////////////////